diff --git a/.melli.py.swp b/.melli.py.swp
new file mode 100644
index 0000000..124def3
Binary files /dev/null and b/.melli.py.swp differ
diff --git a/.test_melli.py.swp b/.test_melli.py.swp
new file mode 100644
index 0000000..9f250cf
Binary files /dev/null and b/.test_melli.py.swp differ
diff --git a/melli.py b/melli.py
index d6854d2..7fb0346 100644
--- a/melli.py
+++ b/melli.py
@@ -1,4 +1,5 @@
 from fastapi import FastAPI
+from typing import Any, Dict, List
 
 app = FastAPI(
     title="Melli Hiring Challenge 👩‍💻",
@@ -12,25 +13,35 @@
 
 
 @app.get("/task1/greet/{name}", tags=["Task 1"], summary="👋🇩🇪🇬🇧🇪🇸")
-async def task1_greet(name: str) -> str:
+async def task1_greet(name: str, language: str = "de") -> str:
     """Greet somebody in German, English or Spanish!"""
     # Write your code below
-    ...
-    return f"Hello {name}, I am Melli."
-
+    greetings: Dict[str, str] = {
+    "en": f"Hello {name}, I am Melli.",
+    "de": f"Hallo {name}, ich bin Melli.",
+    "es": f"Hola {name}, soy Melli.",
+    }
+    try:
+        return greetings[language]
+    except:
+        return f"Hallo {name}, leider spreche ich nicht '{language}'!"
 
 """
 Task 2 - snake_case to cameCase
 """
 
-from typing import Any
-
-
-def camelize(key: str):
+def camelize(key: str) -> str:
     """Takes string in snake_case format returns camelCase formatted version."""
     # Write your code below
-    ...
-    return key
+    temp: List[str] = [c for c in key[::-1]]
+    ret: str = ""
+    while temp:
+        c: str = temp.pop()
+        if c != '_':
+            ret += c
+        else:
+            temp[-1] = temp[-1].upper()
+    return ret
 
 
 @app.post("/task2/camelize", tags=["Task 2"], summary="🐍➡️🐪")
@@ -45,7 +56,7 @@ async def task2_camelize(data: dict[str, Any]) -> dict[str, Any]:
 
 from pydantic import BaseModel
 
-friends = {
+friends: Dict[str, List[str]] = {
     "Matthias": ["Sahar", "Franziska", "Hans"],
     "Stefan": ["Felix", "Ben", "Philip"],
 }
@@ -60,28 +71,27 @@ class ActionResponse(BaseModel):
     message: str
 
 
-def handle_call_action(action: str):
+def handle_call_action(action: str, user: str = None) -> str:
     # Write your code below
-    ...
-    return "🤙 Why don't you call them yourself!"
+    for f in friends[user]:
+        if f in action:
+            return {"message": f"🤙 Calling {f} ..."}
+    return {"message": f"{user}, I can't find this person in your contacts."}
 
 
-def handle_reminder_action(action: str):
+def handle_reminder_action(action: str, user: str = None) -> str:
     # Write your code below
-    ...
-    return "🔔 I can't even remember my own stuff!"
+    return {"message": "🔔 Alright, I will remind you!"}
 
 
-def handle_timer_action(action: str):
+def handle_timer_action(action: str, user: str = None) -> str:
     # Write your code below
-    ...
-    return "⏰ I don't know how to read the clock!"
+    return {"message": "⏰ Alright, the timer is set!"}
 
 
-def handle_unknown_action(action: str):
+def handle_unknown_action(action: str, user: str = None) -> str:
     # Write your code below
-    ...
-    return "🤬 #$!@"
+    return {"message": "👀 Sorry , but I can't help with that!"}
 
 
 @app.post("/task3/action", tags=["Task 3"], summary="🤌")
@@ -90,19 +100,18 @@ def task3_action(request: ActionRequest):
     # tip: you have to use the response model above and also might change the signature
     #      of the action handlers
     # Write your code below
-    ...
-    from random import choice
-
-    # There must be a better way!
-    handler = choice(
-        [
-            handle_call_action,
-            handle_reminder_action,
-            handle_timer_action,
-            handle_unknown_action,
-        ]
-    )
-    return handler(request.action)
+    if request.username not in friends:
+        return {"message": f"Hi {request.username}, I don't know you yet. But I would love to meet you!"}
+    if "call" in request.action.lower():
+        handler = handle_call_action
+    elif "remind" in request.action.lower():
+        handler = handle_reminder_action
+    elif "timer" in request.action.lower():
+        handler = handle_timer_action
+    else:
+        handler = handle_unknown_action
+
+    return handler(request.action, request.username)
 
 
 """
@@ -167,6 +176,17 @@ async def login(form_data: OAuth2PasswordRequestForm = Depends()):
     # tip: check the verify_password above
     # Write your code below
     ...
+    user = fake_users_db.get(form_data.username)
+    
+    if user is None or not verify_password(form_data.password, user["hashed_password"]):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    # If the user is found and the password is correct, create a JWT token
+
     payload = {
         "sub": form_data.username,
         "exp": datetime.utcnow() + timedelta(minutes=30),
@@ -193,18 +213,41 @@ async def get_current_user(token: str = Depends(oauth2_scheme)) -> User:
     # otherwise raise the credentials_exception above
     # Write your code below
     ...
+    try:
+        payload = decode_jwt(token)
+        username = payload["sub"]
+        user = fake_users_db.get(username)
+        
+        if user is None:
+            raise credentials_exception
+        return User(**user)
+    except JWTError:
+        raise credentials_exception
+
 
 
 @app.get("/task4/users/{username}/secret", summary="🤫", tags=["Task 4"])
 async def read_user_secret(
     username: str, current_user: User = Depends(get_current_user)
-):
+) -> str:
     """Read a user's secret."""
     # uppps 🤭 maybe we should check if the requested secret actually belongs to the user
     # Write your code below
     ...
-    if user := get_user(username):
-        return user.secret
+    user: User = get_user(username)
+    
+    if user is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found",
+        )
+    if user.username != current_user.username:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Don't spy on other user!",
+        )
+    
+    return user.secret
 
 
 """
diff --git a/myenv/bin/Activate.ps1 b/myenv/bin/Activate.ps1
new file mode 100644
index 0000000..2fb3852
--- /dev/null
+++ b/myenv/bin/Activate.ps1
@@ -0,0 +1,241 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virutal environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"
diff --git a/myenv/bin/activate b/myenv/bin/activate
new file mode 100644
index 0000000..251f6b5
--- /dev/null
+++ b/myenv/bin/activate
@@ -0,0 +1,66 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+        hash -r 2> /dev/null
+    fi
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="/Users/kerianyousfi/fun/python-challenge/myenv"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1="(myenv) ${PS1:-}"
+    export PS1
+fi
+
+# This should detect bash and zsh, which have a hash command that must
+# be called to get it to forget past commands.  Without forgetting
+# past commands the $PATH changes we made may not be respected
+if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+    hash -r 2> /dev/null
+fi
diff --git a/myenv/bin/activate.csh b/myenv/bin/activate.csh
new file mode 100644
index 0000000..4a73a1a
--- /dev/null
+++ b/myenv/bin/activate.csh
@@ -0,0 +1,25 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV "/Users/kerianyousfi/fun/python-challenge/myenv"
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/bin:$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = "(myenv) $prompt"
+endif
+
+alias pydoc python -m pydoc
+
+rehash
diff --git a/myenv/bin/activate.fish b/myenv/bin/activate.fish
new file mode 100644
index 0000000..9f39418
--- /dev/null
+++ b/myenv/bin/activate.fish
@@ -0,0 +1,64 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/); you cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        functions -e fish_prompt
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        functions -c _old_fish_prompt fish_prompt
+        functions -e _old_fish_prompt
+    end
+
+    set -e VIRTUAL_ENV
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV "/Users/kerianyousfi/fun/python-challenge/myenv"
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/bin" $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) "(myenv) " (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+end
diff --git a/myenv/bin/black b/myenv/bin/black
new file mode 100755
index 0000000..581e566
--- /dev/null
+++ b/myenv/bin/black
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from black import patched_main
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(patched_main())
diff --git a/myenv/bin/black-primer b/myenv/bin/black-primer
new file mode 100755
index 0000000..f8f3bb0
--- /dev/null
+++ b/myenv/bin/black-primer
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from black_primer.cli import main
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(main())
diff --git a/myenv/bin/blackd b/myenv/bin/blackd
new file mode 100755
index 0000000..c81e4e0
--- /dev/null
+++ b/myenv/bin/blackd
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from blackd import patched_main
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(patched_main())
diff --git a/myenv/bin/dotenv b/myenv/bin/dotenv
new file mode 100755
index 0000000..3d1efb7
--- /dev/null
+++ b/myenv/bin/dotenv
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from dotenv.cli import cli
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(cli())
diff --git a/myenv/bin/easy_install b/myenv/bin/easy_install
new file mode 100755
index 0000000..28a43f0
--- /dev/null
+++ b/myenv/bin/easy_install
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python3.9
+# -*- coding: utf-8 -*-
+import re
+import sys
+from setuptools.command.easy_install import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/myenv/bin/easy_install-3.9 b/myenv/bin/easy_install-3.9
new file mode 100755
index 0000000..28a43f0
--- /dev/null
+++ b/myenv/bin/easy_install-3.9
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python3.9
+# -*- coding: utf-8 -*-
+import re
+import sys
+from setuptools.command.easy_install import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/myenv/bin/epylint b/myenv/bin/epylint
new file mode 100755
index 0000000..a0d8d7c
--- /dev/null
+++ b/myenv/bin/epylint
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pylint import run_epylint
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(run_epylint())
diff --git a/myenv/bin/future-fstrings-show b/myenv/bin/future-fstrings-show
new file mode 100755
index 0000000..9c35bed
--- /dev/null
+++ b/myenv/bin/future-fstrings-show
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from future_fstrings import main
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(main())
diff --git a/myenv/bin/get_objgraph b/myenv/bin/get_objgraph
new file mode 100755
index 0000000..9f437d9
--- /dev/null
+++ b/myenv/bin/get_objgraph
@@ -0,0 +1,54 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+display the reference paths for objects in ``dill.types`` or a .pkl file
+
+Notes:
+    the generated image is useful in showing the pointer references in
+    objects that are or can be pickled.  Any object in ``dill.objects``
+    listed in ``dill.load_types(picklable=True, unpicklable=True)`` works.
+
+Examples::
+
+    $ get_objgraph FrameType
+    Image generated as FrameType.png
+"""
+
+import dill as pickle
+#pickle.debug.trace(True)
+#import pickle
+
+# get all objects for testing
+from dill import load_types
+load_types(pickleable=True,unpickleable=True)
+from dill import objects
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) != 2:
+        print ("Please provide exactly one file or type name (e.g. 'IntType')")
+        msg = "\n"
+        for objtype in list(objects.keys())[:40]:
+            msg += objtype + ', '
+        print (msg + "...")
+    else:
+        objtype = str(sys.argv[-1])
+        try:
+            obj = objects[objtype]
+        except KeyError:
+            obj = pickle.load(open(objtype,'rb'))
+            import os
+            objtype = os.path.splitext(objtype)[0]
+        try:
+            import objgraph
+            objgraph.show_refs(obj, filename=objtype+'.png')
+        except ImportError:
+            print ("Please install 'objgraph' to view object graphs")
+
+
+# EOF
diff --git a/myenv/bin/httpx b/myenv/bin/httpx
new file mode 100755
index 0000000..4650911
--- /dev/null
+++ b/myenv/bin/httpx
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from httpx import main
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(main())
diff --git a/myenv/bin/isort b/myenv/bin/isort
new file mode 100755
index 0000000..133a8c2
--- /dev/null
+++ b/myenv/bin/isort
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from isort.main import main
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(main())
diff --git a/myenv/bin/isort-identify-imports b/myenv/bin/isort-identify-imports
new file mode 100755
index 0000000..9e7e113
--- /dev/null
+++ b/myenv/bin/isort-identify-imports
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from isort.main import identify_imports_main
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(identify_imports_main())
diff --git a/myenv/bin/pip b/myenv/bin/pip
new file mode 100755
index 0000000..7a69eac
--- /dev/null
+++ b/myenv/bin/pip
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python3.9
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/myenv/bin/pip3 b/myenv/bin/pip3
new file mode 100755
index 0000000..7a69eac
--- /dev/null
+++ b/myenv/bin/pip3
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python3.9
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/myenv/bin/pip3.9 b/myenv/bin/pip3.9
new file mode 100755
index 0000000..7a69eac
--- /dev/null
+++ b/myenv/bin/pip3.9
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python3.9
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/myenv/bin/py.test b/myenv/bin/py.test
new file mode 100755
index 0000000..bff0c09
--- /dev/null
+++ b/myenv/bin/py.test
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pytest import console_main
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(console_main())
diff --git a/myenv/bin/pylint b/myenv/bin/pylint
new file mode 100755
index 0000000..25dd42d
--- /dev/null
+++ b/myenv/bin/pylint
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pylint import run_pylint
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(run_pylint())
diff --git a/myenv/bin/pyreverse b/myenv/bin/pyreverse
new file mode 100755
index 0000000..ab48604
--- /dev/null
+++ b/myenv/bin/pyreverse
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pylint import run_pyreverse
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(run_pyreverse())
diff --git a/myenv/bin/pyrsa-decrypt b/myenv/bin/pyrsa-decrypt
new file mode 100755
index 0000000..e32a47e
--- /dev/null
+++ b/myenv/bin/pyrsa-decrypt
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import decrypt
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(decrypt())
diff --git a/myenv/bin/pyrsa-encrypt b/myenv/bin/pyrsa-encrypt
new file mode 100755
index 0000000..e8dced7
--- /dev/null
+++ b/myenv/bin/pyrsa-encrypt
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import encrypt
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(encrypt())
diff --git a/myenv/bin/pyrsa-keygen b/myenv/bin/pyrsa-keygen
new file mode 100755
index 0000000..d8cf5c0
--- /dev/null
+++ b/myenv/bin/pyrsa-keygen
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import keygen
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(keygen())
diff --git a/myenv/bin/pyrsa-priv2pub b/myenv/bin/pyrsa-priv2pub
new file mode 100755
index 0000000..68cf697
--- /dev/null
+++ b/myenv/bin/pyrsa-priv2pub
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.util import private_to_public
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(private_to_public())
diff --git a/myenv/bin/pyrsa-sign b/myenv/bin/pyrsa-sign
new file mode 100755
index 0000000..46756be
--- /dev/null
+++ b/myenv/bin/pyrsa-sign
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import sign
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(sign())
diff --git a/myenv/bin/pyrsa-verify b/myenv/bin/pyrsa-verify
new file mode 100755
index 0000000..4afcbd2
--- /dev/null
+++ b/myenv/bin/pyrsa-verify
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import verify
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(verify())
diff --git a/myenv/bin/pytest b/myenv/bin/pytest
new file mode 100755
index 0000000..bff0c09
--- /dev/null
+++ b/myenv/bin/pytest
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pytest import console_main
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(console_main())
diff --git a/myenv/bin/python b/myenv/bin/python
new file mode 120000
index 0000000..e616d26
--- /dev/null
+++ b/myenv/bin/python
@@ -0,0 +1 @@
+python3.9
\ No newline at end of file
diff --git a/myenv/bin/python3 b/myenv/bin/python3
new file mode 120000
index 0000000..e616d26
--- /dev/null
+++ b/myenv/bin/python3
@@ -0,0 +1 @@
+python3.9
\ No newline at end of file
diff --git a/myenv/bin/python3.9 b/myenv/bin/python3.9
new file mode 120000
index 0000000..c03713e
--- /dev/null
+++ b/myenv/bin/python3.9
@@ -0,0 +1 @@
+/Library/Frameworks/Python.framework/Versions/3.9/bin/python3.9
\ No newline at end of file
diff --git a/myenv/bin/symilar b/myenv/bin/symilar
new file mode 100755
index 0000000..5a5f2ac
--- /dev/null
+++ b/myenv/bin/symilar
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pylint import run_symilar
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(run_symilar())
diff --git a/myenv/bin/undill b/myenv/bin/undill
new file mode 100755
index 0000000..da19feb
--- /dev/null
+++ b/myenv/bin/undill
@@ -0,0 +1,22 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+unpickle the contents of a pickled object file
+
+Examples::
+
+    $ undill hello.pkl
+    ['hello', 'world']
+"""
+
+if __name__ == '__main__':
+    import sys
+    import dill
+    for file in sys.argv[1:]:
+        print (dill.load(open(file,'rb')))
+
diff --git a/myenv/bin/uvicorn b/myenv/bin/uvicorn
new file mode 100755
index 0000000..a7b06ce
--- /dev/null
+++ b/myenv/bin/uvicorn
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from uvicorn.main import main
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(main())
diff --git a/myenv/bin/watchgod b/myenv/bin/watchgod
new file mode 100755
index 0000000..4a948f9
--- /dev/null
+++ b/myenv/bin/watchgod
@@ -0,0 +1,8 @@
+#!/Users/kerianyousfi/fun/python-challenge/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from watchgod.cli import cli
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(cli())
diff --git a/myenv/lib/python3.9/site-packages/CHANGELOG.md b/myenv/lib/python3.9/site-packages/CHANGELOG.md
new file mode 100644
index 0000000..3781be9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/CHANGELOG.md
@@ -0,0 +1,235 @@
+# Python-RSA changelog
+
+## Version 4.8 - in development
+
+- Switch to [Poetry](https://python-poetry.org/) for dependency and release management.
+- Compatibility with Python 3.10.
+- Chain exceptions using `raise new_exception from old_exception`
+  ([#157](https://github.com/sybrenstuvel/python-rsa/pull/157))
+- Added marker file for PEP 561. This will allow type checking tools in dependent projects
+  to use type annotations from Python-RSA
+  ([#136](https://github.com/sybrenstuvel/python-rsa/pull/136)).
+- Use the Chinese Remainder Theorem when decrypting with a private key. This
+  makes decryption 2-4x faster
+  ([#163](https://github.com/sybrenstuvel/python-rsa/pull/163)).
+
+## Version 4.7.2 - released 2021-02-24
+
+- Fix picking/unpickling issue introduced in 4.7
+  ([#173](https://github.com/sybrenstuvel/python-rsa/issues/173))
+
+## Version 4.7.1 - released 2021-02-15
+
+- Fix threading issue introduced in 4.7
+  ([#173](https://github.com/sybrenstuvel/python-rsa/issues/173))
+
+## Version 4.7 - released 2021-01-10
+
+- Fix [#165](https://github.com/sybrenstuvel/python-rsa/issues/165):
+  CVE-2020-25658 - Bleichenbacher-style timing oracle in PKCS#1 v1.5 decryption
+  code
+- Add padding length check as described by PKCS#1 v1.5 (Fixes
+  [#164](https://github.com/sybrenstuvel/python-rsa/issues/164))
+- Reuse of blinding factors to speed up blinding operations.
+  Fixes [#162](https://github.com/sybrenstuvel/python-rsa/issues/162).
+- Declare & test support for Python 3.9
+
+
+## Version 4.4 & 4.6 - released 2020-06-12
+
+Version 4.4 and 4.6 are almost a re-tagged release of version 4.2. It requires
+Python 3.5+. To avoid older Python installations from trying to upgrade to RSA
+4.4, this is now made explicit in the `python_requires` argument in `setup.py`.
+There was a mistake releasing 4.4 as "3.5+ only", which made it necessary to
+retag 4.4 as 4.6 as well.
+
+No functional changes compared to version 4.2.
+
+
+## Version 4.3 & 4.5 - released 2020-06-12
+
+Version 4.3 and 4.5 are almost a re-tagged release of version 4.0. It is the
+last to support Python 2.7. This is now made explicit in the `python_requires`
+argument in `setup.py`. Python 3.4 is not supported by this release. There was a
+mistake releasing 4.4 as "3.5+ only", which made it necessary to retag 4.3 as
+4.5 as well.
+
+Two security fixes have also been backported, so 4.3 = 4.0 + these two fixes.
+
+- Choose blinding factor relatively prime to N. Thanks Christian Heimes for pointing this out.
+- Reject cyphertexts (when decrypting) and signatures (when verifying) that have
+  been modified by prepending zero bytes. This resolves CVE-2020-13757. Thanks
+  Carnil for pointing this out.
+
+
+## Version 4.2 - released 2020-06-10
+
+- Rolled back the switch to Poetry, and reverted back to using Pipenv + setup.py
+  for dependency management. There apparently is an issue no-binary installs of
+  packages build with Poetry. This fixes
+  [#148](https://github.com/sybrenstuvel/python-rsa/issues/148)
+- Limited SHA3 support to those Python versions (3.6+) that support it natively.
+  The third-party library that adds support for this to Python 3.5 is a binary
+  package, and thus breaks the pure-Python nature of Python-RSA.
+  This should fix [#147](https://github.com/sybrenstuvel/python-rsa/issues/147).
+
+
+## Version 4.1 - released 2020-06-10
+
+- Added support for Python 3.8.
+- Dropped support for Python 2 and 3.4.
+- Added type annotations to the source code. This will make Python-RSA easier to use in
+  your IDE, and allows better type checking.
+- Added static type checking via [MyPy](http://mypy-lang.org/).
+- Fix [#129](https://github.com/sybrenstuvel/python-rsa/issues/129) Installing from source
+  gives UnicodeDecodeError.
+- Switched to using [Poetry](https://poetry.eustace.io/) for package
+  management.
+- Added support for SHA3 hashing: SHA3-256, SHA3-384, SHA3-512. This
+  is natively supported by Python 3.6+ and supported via a third-party
+  library on Python 3.5.
+- Choose blinding factor relatively prime to N. Thanks Christian Heimes for pointing this out.
+- Reject cyphertexts (when decrypting) and signatures (when verifying) that have
+  been modified by prepending zero bytes. This resolves CVE-2020-13757. Thanks
+  Adelapie for pointing this out.
+
+
+## Version 4.0 - released 2018-09-16
+
+- Removed deprecated modules:
+    - rsa.varblock
+    - rsa.bigfile
+    - rsa._version133
+    - rsa._version200
+- Removed CLI commands that use the VARBLOCK/bigfile format.
+- Ensured that PublicKey.save_pkcs1() and PrivateKey.save_pkcs1() always return bytes.
+- Dropped support for Python 2.6 and 3.3.
+- Dropped support for Psyco.
+- Miller-Rabin iterations determined by bitsize of key.
+  [#58](https://github.com/sybrenstuvel/python-rsa/pull/58)
+- Added function `rsa.find_signature_hash()` to return the name of the hashing
+  algorithm used to sign a message. `rsa.verify()` now also returns that name,
+  instead of always returning `True`.
+  [#78](https://github.com/sybrenstuvel/python-rsa/issues/13)
+- Add support for SHA-224 for PKCS1 signatures.
+  [#104](https://github.com/sybrenstuvel/python-rsa/pull/104)
+- Transitioned from `requirements.txt` to Pipenv for package management.
+
+
+## Version 3.4.2 - released 2016-03-29
+
+- Fixed dates in CHANGELOG.txt
+
+
+## Version 3.4.1 - released 2016-03-26
+
+- Included tests/private.pem in MANIFEST.in
+- Included README.md and CHANGELOG.txt in MANIFEST.in
+
+
+## Version 3.4 - released 2016-03-17
+
+- Moved development to GitHub: https://github.com/sybrenstuvel/python-rsa
+- Solved side-channel vulnerability by implementing blinding, fixes #19
+- Deprecated the VARBLOCK format and rsa.bigfile module due to security issues, see
+    https://github.com/sybrenstuvel/python-rsa/issues/13
+- Integration with Travis-CI [1], Coveralls [2] and Code Climate [3]
+- Deprecated the old rsa._version133 and rsa._version200 submodules, they will be
+  completely removed in version 4.0.
+- Add an 'exponent' argument to key.newkeys()
+- Switched from Solovay-Strassen to Miller-Rabin primality testing, to
+  comply with NIST FIPS 186-4 [4] as probabilistic primality test
+  (Appendix C, subsection C.3):
+- Fixed bugs #12, #14, #27, #30, #49
+
+[1] https://travis-ci.org/sybrenstuvel/python-rsa
+[2] https://coveralls.io/github/sybrenstuvel/python-rsa
+[3] https://codeclimate.com/github/sybrenstuvel/python-rsa
+[4] http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
+
+
+## Version 3.3 - released 2016-01-13
+
+- Thanks to Filippo Valsorda: Fix BB'06 attack in verify() by
+  switching from parsing to comparison. See [1] for more information.
+- Simplified Tox configuration and dropped Python 3.2 support. The
+  coverage package uses a u'' prefix, which was reintroduced in 3.3
+  for ease of porting.
+
+[1] https://blog.filippo.io/bleichenbacher-06-signature-forgery-in-python-rsa/
+
+
+## Version 3.2.3 - released 2015-11-05
+
+- Added character encoding markers for Python 2.x
+
+
+## Version 3.2.1 - released 2015-11-05
+
+- Added per-file licenses
+- Added support for wheel packages
+- Made example code more consistent and up to date with Python 3.4
+
+
+## Version 3.2 - released 2015-07-29
+
+- Mentioned support for Python 3 in setup.py
+
+
+## Version 3.1.4 - released 2014-02-22
+
+- Fixed some bugs
+
+
+## Version 3.1.3 - released 2014-02-02
+
+- Dropped support for Python 2.5
+
+
+## Version 3.1.2 - released 2013-09-15
+
+- Added Python 3.3 to the test environment.
+- Removed dependency on Distribute
+- Added support for loading public keys from OpenSSL
+
+
+## Version 3.1.1 - released 2012-06-18
+
+- Fixed doctests for Python 2.7
+- Removed obsolete unittest so all tests run fine on Python 3.2
+
+## Version 3.1 - released 2012-06-17
+
+- Big, big credits to Yesudeep Mangalapilly for all the changes listed
+  below!
+- Added ability to generate keys on multiple cores simultaneously.
+- Massive speedup
+- Partial Python 3.2 compatibility (core functionality works, but
+  saving or loading keys doesn't, for that the pyasn1 package needs to
+  be ported to Python 3 first)
+- Lots of bug fixes
+
+
+
+## Version 3.0.1 - released 2011-08-07
+
+- Removed unused import of abc module
+
+
+## Version 3.0 - released 2011-08-05
+
+- Changed the meaning of the keysize to mean the size of ``n`` rather than
+  the size of both ``p`` and ``q``. This is the common interpretation of
+  RSA keysize. To get the old behaviour, double the keysize when generating a
+  new key.
+- Added a lot of doctests
+- Added random-padded encryption and decryption using PKCS#1 version 1.5
+- Added hash-based signatures and verification using PKCS#1v1.5
+- Modeling private and public key as real objects rather than dicts.
+- Support for saving and loading keys as PEM and DER files.
+- Ability to extract a public key from a private key (PEM+DER)
+
+
+## Version 2.0
+
+- Security improvements by Barry Mead.
diff --git a/myenv/lib/python3.9/site-packages/LICENSE b/myenv/lib/python3.9/site-packages/LICENSE
new file mode 100644
index 0000000..67589cb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/LICENSE
@@ -0,0 +1,13 @@
+Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/LICENSE
new file mode 100644
index 0000000..2f1b8e1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2017-2021 Ingy döt Net
+Copyright (c) 2006-2016 Kirill Simonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/METADATA
new file mode 100644
index 0000000..9a91076
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/METADATA
@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: PyYAML
+Version: 6.0
+Summary: YAML parser and emitter for Python
+Home-page: https://pyyaml.org/
+Author: Kirill Simonov
+Author-email: xi@resolvent.net
+License: MIT
+Download-URL: https://pypi.org/project/PyYAML/
+Project-URL: Bug Tracker, https://github.com/yaml/pyyaml/issues
+Project-URL: CI, https://github.com/yaml/pyyaml/actions
+Project-URL: Documentation, https://pyyaml.org/wiki/PyYAMLDocumentation
+Project-URL: Mailing lists, http://lists.sourceforge.net/lists/listinfo/yaml-core
+Project-URL: Source Code, https://github.com/yaml/pyyaml
+Platform: Any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.6
+License-File: LICENSE
+
+YAML is a data serialization format designed for human readability
+and interaction with scripting languages.  PyYAML is a YAML parser
+and emitter for Python.
+
+PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
+support, capable extension API, and sensible error messages.  PyYAML
+supports standard YAML tags and provides Python-specific tags that
+allow to represent an arbitrary Python object.
+
+PyYAML is applicable for a broad range of tasks from complex
+configuration files to object serialization and persistence.
+
diff --git a/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/RECORD
new file mode 100644
index 0000000..ac2b633
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/RECORD
@@ -0,0 +1,25 @@
+PyYAML-6.0.dist-info/LICENSE,sha256=jTko-dxEkP1jVwfLiOsmvXZBAqcoKVQwfT5RZ6V36KQ,1101
+PyYAML-6.0.dist-info/WHEEL,sha256=JIE30nfOWUuazI4Vcfiuv_cYm-SkZCh6YOqQQjhm90A,109
+PyYAML-6.0.dist-info/top_level.txt,sha256=rpj0IVMTisAjh_1vG3Ccf9v5jpCQwAz6cD1IVU5ZdhQ,11
+PyYAML-6.0.dist-info/METADATA,sha256=QmHx9kGp_0yezQCXYaft4eEFeJ6W4oyFfYwHDLP1kdg,2006
+_yaml/__init__.py,sha256=04Ae_5osxahpJHa3XBZUAf4wi6XX32gR8D6X6p64GEA,1402
+yaml/scanner.py,sha256=YEM3iLZSaQwXcQRg2l2R4MdT0zGP2F9eHkKGKnHyWQY,51279
+yaml/_yaml.cpython-39-darwin.so,sha256=MwASErZMw1iveBOlLW1RJRrd4yYWYf2bWYq_nhpnFD0,462160
+yaml/error.py,sha256=Ah9z-toHJUbE9j-M8YpxgSRM5CgLCcwVzJgLLRF2Fxo,2533
+yaml/constructor.py,sha256=kNgkfaeLUkwQYY_Q6Ff1Tz2XVw_pG1xVE9Ak7z-viLA,28639
+yaml/composer.py,sha256=_Ko30Wr6eDWUeUpauUGT3Lcg9QPBnOPVlTnIMRGJ9FM,4883
+yaml/events.py,sha256=50_TksgQiE4up-lKo_V-nBy-tAIxkIPQxY5qDhKCeHw,2445
+yaml/__init__.py,sha256=NDS7S8XgA72-hY6LRmGzUWTPvzGzjWVrWk-OGA-77AA,12309
+yaml/representer.py,sha256=IuWP-cAW9sHKEnS0gCqSa894k1Bg4cgTxaDwIcbRQ-Y,14190
+yaml/tokens.py,sha256=lTQIzSVw8Mg9wv459-TjiOQe6wVziqaRlqX2_89rp54,2573
+yaml/dumper.py,sha256=PLctZlYwZLp7XmeUdwRuv4nYOZ2UBnDIUy8-lKfLF-o,2837
+yaml/cyaml.py,sha256=6ZrAG9fAYvdVe2FK_w0hmXoG7ZYsoYUwapG8CiC72H0,3851
+yaml/parser.py,sha256=ilWp5vvgoHFGzvOZDItFoGjD6D42nhlZrZyjAwa0oJo,25495
+yaml/reader.py,sha256=0dmzirOiDG4Xo41RnuQS7K9rkY3xjHiVasfDMNTqCNw,6794
+yaml/loader.py,sha256=UVa-zIqmkFSCIYq_PgSGm4NSJttHY2Rf_zQ4_b1fHN0,2061
+yaml/resolver.py,sha256=9L-VYfm4mWHxUD1Vg4X7rjDRK_7VZd6b92wzq7Y2IKY,9004
+yaml/serializer.py,sha256=ChuFgmhU01hj4xgI8GaKv6vfM2Bujwa9i7d2FAHj7cA,4165
+yaml/nodes.py,sha256=gPKNj8pKCdh2d4gr3gIYINnPOaOxGhJAUiYhGRnPE84,1440
+yaml/emitter.py,sha256=jghtaU7eFwg31bG0B7RZea_29Adi9CKmXq_QjgQpCkQ,43006
+PyYAML-6.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+PyYAML-6.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/WHEEL
new file mode 100644
index 0000000..9c3644e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_9_x86_64
+
diff --git a/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/top_level.txt
new file mode 100644
index 0000000..e6475e9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/PyYAML-6.0.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+_yaml
+yaml
diff --git a/myenv/lib/python3.9/site-packages/README.md b/myenv/lib/python3.9/site-packages/README.md
new file mode 100644
index 0000000..02761da
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/README.md
@@ -0,0 +1,43 @@
+# Pure Python RSA implementation
+
+[![PyPI](https://img.shields.io/pypi/v/rsa.svg)](https://pypi.org/project/rsa/)
+[![Build Status](https://travis-ci.org/sybrenstuvel/python-rsa.svg?branch=master)](https://travis-ci.org/sybrenstuvel/python-rsa)
+[![Coverage Status](https://coveralls.io/repos/github/sybrenstuvel/python-rsa/badge.svg?branch=master)](https://coveralls.io/github/sybrenstuvel/python-rsa?branch=master)
+[![Code Climate](https://api.codeclimate.com/v1/badges/a99a88d28ad37a79dbf6/maintainability)](https://codeclimate.com/github/codeclimate/codeclimate/maintainability)
+
+[Python-RSA](https://stuvel.eu/rsa) is a pure-Python RSA implementation. It supports
+encryption and decryption, signing and verifying signatures, and key
+generation according to PKCS#1 version 1.5. It can be used as a Python
+library as well as on the commandline. The code was mostly written by
+Sybren A.  Stüvel.
+
+Documentation can be found at the [Python-RSA homepage](https://stuvel.eu/rsa). For all changes, check [the changelog](https://github.com/sybrenstuvel/python-rsa/blob/master/CHANGELOG.md).
+
+Download and install using:
+
+    pip install rsa
+
+or download it from the [Python Package Index](https://pypi.org/project/rsa/).
+
+The source code is maintained at [GitHub](https://github.com/sybrenstuvel/python-rsa/) and is
+licensed under the [Apache License, version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+## Security
+
+Because of how Python internally stores numbers, it is very hard (if not impossible) to make a pure-Python program secure against timing attacks. This library is no exception, so use it with care. See https://securitypitfalls.wordpress.com/2018/08/03/constant-time-compare-in-python/ for more info.
+
+## Setup of Development Environment
+
+```
+python3 -m venv .venv
+. ./.venv/bin/activate
+pip install poetry
+poetry install
+```
+
+## Publishing a New Release
+
+```
+. ./.venv/bin/activate
+poetry publish --build
+```
diff --git a/myenv/lib/python3.9/site-packages/_black_version.py b/myenv/lib/python3.9/site-packages/_black_version.py
new file mode 100644
index 0000000..8c76549
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_black_version.py
@@ -0,0 +1 @@
+version = "21.12b0"
diff --git a/myenv/lib/python3.9/site-packages/_cffi_backend.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/_cffi_backend.cpython-39-darwin.so
new file mode 100755
index 0000000..bdcbe38
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/_cffi_backend.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/_pytest/__init__.py b/myenv/lib/python3.9/site-packages/_pytest/__init__.py
new file mode 100644
index 0000000..46c7827
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/__init__.py
@@ -0,0 +1,8 @@
+__all__ = ["__version__"]
+
+try:
+    from ._version import version as __version__
+except ImportError:
+    # broken installation, we don't even try
+    # unknown only works because we do poor mans version compare
+    __version__ = "unknown"
diff --git a/myenv/lib/python3.9/site-packages/_pytest/_argcomplete.py b/myenv/lib/python3.9/site-packages/_pytest/_argcomplete.py
new file mode 100644
index 0000000..41d9d94
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/_argcomplete.py
@@ -0,0 +1,117 @@
+"""Allow bash-completion for argparse with argcomplete if installed.
+
+Needs argcomplete>=0.5.6 for python 3.2/3.3 (older versions fail
+to find the magic string, so _ARGCOMPLETE env. var is never set, and
+this does not need special code).
+
+Function try_argcomplete(parser) should be called directly before
+the call to ArgumentParser.parse_args().
+
+The filescompleter is what you normally would use on the positional
+arguments specification, in order to get "dirname/" after "dirn<TAB>"
+instead of the default "dirname ":
+
+   optparser.add_argument(Config._file_or_dir, nargs='*').completer=filescompleter
+
+Other, application specific, completers should go in the file
+doing the add_argument calls as they need to be specified as .completer
+attributes as well. (If argcomplete is not installed, the function the
+attribute points to will not be used).
+
+SPEEDUP
+=======
+
+The generic argcomplete script for bash-completion
+(/etc/bash_completion.d/python-argcomplete.sh)
+uses a python program to determine startup script generated by pip.
+You can speed up completion somewhat by changing this script to include
+  # PYTHON_ARGCOMPLETE_OK
+so the python-argcomplete-check-easy-install-script does not
+need to be called to find the entry point of the code and see if that is
+marked  with PYTHON_ARGCOMPLETE_OK.
+
+INSTALL/DEBUGGING
+=================
+
+To include this support in another application that has setup.py generated
+scripts:
+
+- Add the line:
+    # PYTHON_ARGCOMPLETE_OK
+  near the top of the main python entry point.
+
+- Include in the file calling parse_args():
+    from _argcomplete import try_argcomplete, filescompleter
+  Call try_argcomplete just before parse_args(), and optionally add
+  filescompleter to the positional arguments' add_argument().
+
+If things do not work right away:
+
+- Switch on argcomplete debugging with (also helpful when doing custom
+  completers):
+    export _ARC_DEBUG=1
+
+- Run:
+    python-argcomplete-check-easy-install-script $(which appname)
+    echo $?
+  will echo 0 if the magic line has been found, 1 if not.
+
+- Sometimes it helps to find early on errors using:
+    _ARGCOMPLETE=1 _ARC_DEBUG=1 appname
+  which should throw a KeyError: 'COMPLINE' (which is properly set by the
+  global argcomplete script).
+"""
+import argparse
+import os
+import sys
+from glob import glob
+from typing import Any
+from typing import List
+from typing import Optional
+
+
+class FastFilesCompleter:
+    """Fast file completer class."""
+
+    def __init__(self, directories: bool = True) -> None:
+        self.directories = directories
+
+    def __call__(self, prefix: str, **kwargs: Any) -> List[str]:
+        # Only called on non option completions.
+        if os.path.sep in prefix[1:]:
+            prefix_dir = len(os.path.dirname(prefix) + os.path.sep)
+        else:
+            prefix_dir = 0
+        completion = []
+        globbed = []
+        if "*" not in prefix and "?" not in prefix:
+            # We are on unix, otherwise no bash.
+            if not prefix or prefix[-1] == os.path.sep:
+                globbed.extend(glob(prefix + ".*"))
+            prefix += "*"
+        globbed.extend(glob(prefix))
+        for x in sorted(globbed):
+            if os.path.isdir(x):
+                x += "/"
+            # Append stripping the prefix (like bash, not like compgen).
+            completion.append(x[prefix_dir:])
+        return completion
+
+
+if os.environ.get("_ARGCOMPLETE"):
+    try:
+        import argcomplete.completers
+    except ImportError:
+        sys.exit(-1)
+    filescompleter: Optional[FastFilesCompleter] = FastFilesCompleter()
+
+    def try_argcomplete(parser: argparse.ArgumentParser) -> None:
+        argcomplete.autocomplete(parser, always_complete_options=False)
+
+
+else:
+
+    def try_argcomplete(parser: argparse.ArgumentParser) -> None:
+        pass
+
+    filescompleter = None
diff --git a/myenv/lib/python3.9/site-packages/_pytest/_code/__init__.py b/myenv/lib/python3.9/site-packages/_pytest/_code/__init__.py
new file mode 100644
index 0000000..511d0dd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/_code/__init__.py
@@ -0,0 +1,22 @@
+"""Python inspection/code generation API."""
+from .code import Code
+from .code import ExceptionInfo
+from .code import filter_traceback
+from .code import Frame
+from .code import getfslineno
+from .code import Traceback
+from .code import TracebackEntry
+from .source import getrawcode
+from .source import Source
+
+__all__ = [
+    "Code",
+    "ExceptionInfo",
+    "filter_traceback",
+    "Frame",
+    "getfslineno",
+    "getrawcode",
+    "Traceback",
+    "TracebackEntry",
+    "Source",
+]
diff --git a/myenv/lib/python3.9/site-packages/_pytest/_code/code.py b/myenv/lib/python3.9/site-packages/_pytest/_code/code.py
new file mode 100644
index 0000000..4230693
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/_code/code.py
@@ -0,0 +1,1259 @@
+import inspect
+import re
+import sys
+import traceback
+from inspect import CO_VARARGS
+from inspect import CO_VARKEYWORDS
+from io import StringIO
+from pathlib import Path
+from traceback import format_exception_only
+from types import CodeType
+from types import FrameType
+from types import TracebackType
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import Generic
+from typing import Iterable
+from typing import List
+from typing import Mapping
+from typing import Optional
+from typing import overload
+from typing import Pattern
+from typing import Sequence
+from typing import Set
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import TypeVar
+from typing import Union
+from weakref import ref
+
+import attr
+import pluggy
+import py
+
+import _pytest
+from _pytest._code.source import findsource
+from _pytest._code.source import getrawcode
+from _pytest._code.source import getstatementrange_ast
+from _pytest._code.source import Source
+from _pytest._io import TerminalWriter
+from _pytest._io.saferepr import safeformat
+from _pytest._io.saferepr import saferepr
+from _pytest.compat import final
+from _pytest.compat import get_real_func
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+    from weakref import ReferenceType
+
+    _TracebackStyle = Literal["long", "short", "line", "no", "native", "value", "auto"]
+
+
+class Code:
+    """Wrapper around Python code objects."""
+
+    __slots__ = ("raw",)
+
+    def __init__(self, obj: CodeType) -> None:
+        self.raw = obj
+
+    @classmethod
+    def from_function(cls, obj: object) -> "Code":
+        return cls(getrawcode(obj))
+
+    def __eq__(self, other):
+        return self.raw == other.raw
+
+    # Ignore type because of https://github.com/python/mypy/issues/4266.
+    __hash__ = None  # type: ignore
+
+    @property
+    def firstlineno(self) -> int:
+        return self.raw.co_firstlineno - 1
+
+    @property
+    def name(self) -> str:
+        return self.raw.co_name
+
+    @property
+    def path(self) -> Union[py.path.local, str]:
+        """Return a path object pointing to source code, or an ``str`` in
+        case of ``OSError`` / non-existing file."""
+        if not self.raw.co_filename:
+            return ""
+        try:
+            p = py.path.local(self.raw.co_filename)
+            # maybe don't try this checking
+            if not p.check():
+                raise OSError("py.path check failed.")
+            return p
+        except OSError:
+            # XXX maybe try harder like the weird logic
+            # in the standard lib [linecache.updatecache] does?
+            return self.raw.co_filename
+
+    @property
+    def fullsource(self) -> Optional["Source"]:
+        """Return a _pytest._code.Source object for the full source file of the code."""
+        full, _ = findsource(self.raw)
+        return full
+
+    def source(self) -> "Source":
+        """Return a _pytest._code.Source object for the code object's source only."""
+        # return source only for that part of code
+        return Source(self.raw)
+
+    def getargs(self, var: bool = False) -> Tuple[str, ...]:
+        """Return a tuple with the argument names for the code object.
+
+        If 'var' is set True also return the names of the variable and
+        keyword arguments when present.
+        """
+        # Handy shortcut for getting args.
+        raw = self.raw
+        argcount = raw.co_argcount
+        if var:
+            argcount += raw.co_flags & CO_VARARGS
+            argcount += raw.co_flags & CO_VARKEYWORDS
+        return raw.co_varnames[:argcount]
+
+
+class Frame:
+    """Wrapper around a Python frame holding f_locals and f_globals
+    in which expressions can be evaluated."""
+
+    __slots__ = ("raw",)
+
+    def __init__(self, frame: FrameType) -> None:
+        self.raw = frame
+
+    @property
+    def lineno(self) -> int:
+        return self.raw.f_lineno - 1
+
+    @property
+    def f_globals(self) -> Dict[str, Any]:
+        return self.raw.f_globals
+
+    @property
+    def f_locals(self) -> Dict[str, Any]:
+        return self.raw.f_locals
+
+    @property
+    def code(self) -> Code:
+        return Code(self.raw.f_code)
+
+    @property
+    def statement(self) -> "Source":
+        """Statement this frame is at."""
+        if self.code.fullsource is None:
+            return Source("")
+        return self.code.fullsource.getstatement(self.lineno)
+
+    def eval(self, code, **vars):
+        """Evaluate 'code' in the frame.
+
+        'vars' are optional additional local variables.
+
+        Returns the result of the evaluation.
+        """
+        f_locals = self.f_locals.copy()
+        f_locals.update(vars)
+        return eval(code, self.f_globals, f_locals)
+
+    def repr(self, object: object) -> str:
+        """Return a 'safe' (non-recursive, one-line) string repr for 'object'."""
+        return saferepr(object)
+
+    def getargs(self, var: bool = False):
+        """Return a list of tuples (name, value) for all arguments.
+
+        If 'var' is set True, also include the variable and keyword arguments
+        when present.
+        """
+        retval = []
+        for arg in self.code.getargs(var):
+            try:
+                retval.append((arg, self.f_locals[arg]))
+            except KeyError:
+                pass  # this can occur when using Psyco
+        return retval
+
+
+class TracebackEntry:
+    """A single entry in a Traceback."""
+
+    __slots__ = ("_rawentry", "_excinfo", "_repr_style")
+
+    def __init__(
+        self,
+        rawentry: TracebackType,
+        excinfo: Optional["ReferenceType[ExceptionInfo[BaseException]]"] = None,
+    ) -> None:
+        self._rawentry = rawentry
+        self._excinfo = excinfo
+        self._repr_style: Optional['Literal["short", "long"]'] = None
+
+    @property
+    def lineno(self) -> int:
+        return self._rawentry.tb_lineno - 1
+
+    def set_repr_style(self, mode: "Literal['short', 'long']") -> None:
+        assert mode in ("short", "long")
+        self._repr_style = mode
+
+    @property
+    def frame(self) -> Frame:
+        return Frame(self._rawentry.tb_frame)
+
+    @property
+    def relline(self) -> int:
+        return self.lineno - self.frame.code.firstlineno
+
+    def __repr__(self) -> str:
+        return "<TracebackEntry %s:%d>" % (self.frame.code.path, self.lineno + 1)
+
+    @property
+    def statement(self) -> "Source":
+        """_pytest._code.Source object for the current statement."""
+        source = self.frame.code.fullsource
+        assert source is not None
+        return source.getstatement(self.lineno)
+
+    @property
+    def path(self) -> Union[py.path.local, str]:
+        """Path to the source code."""
+        return self.frame.code.path
+
+    @property
+    def locals(self) -> Dict[str, Any]:
+        """Locals of underlying frame."""
+        return self.frame.f_locals
+
+    def getfirstlinesource(self) -> int:
+        return self.frame.code.firstlineno
+
+    def getsource(self, astcache=None) -> Optional["Source"]:
+        """Return failing source code."""
+        # we use the passed in astcache to not reparse asttrees
+        # within exception info printing
+        source = self.frame.code.fullsource
+        if source is None:
+            return None
+        key = astnode = None
+        if astcache is not None:
+            key = self.frame.code.path
+            if key is not None:
+                astnode = astcache.get(key, None)
+        start = self.getfirstlinesource()
+        try:
+            astnode, _, end = getstatementrange_ast(
+                self.lineno, source, astnode=astnode
+            )
+        except SyntaxError:
+            end = self.lineno + 1
+        else:
+            if key is not None:
+                astcache[key] = astnode
+        return source[start:end]
+
+    source = property(getsource)
+
+    def ishidden(self) -> bool:
+        """Return True if the current frame has a var __tracebackhide__
+        resolving to True.
+
+        If __tracebackhide__ is a callable, it gets called with the
+        ExceptionInfo instance and can decide whether to hide the traceback.
+
+        Mostly for internal use.
+        """
+        tbh: Union[bool, Callable[[Optional[ExceptionInfo[BaseException]]], bool]] = (
+            False
+        )
+        for maybe_ns_dct in (self.frame.f_locals, self.frame.f_globals):
+            # in normal cases, f_locals and f_globals are dictionaries
+            # however via `exec(...)` / `eval(...)` they can be other types
+            # (even incorrect types!).
+            # as such, we suppress all exceptions while accessing __tracebackhide__
+            try:
+                tbh = maybe_ns_dct["__tracebackhide__"]
+            except Exception:
+                pass
+            else:
+                break
+        if tbh and callable(tbh):
+            return tbh(None if self._excinfo is None else self._excinfo())
+        return tbh
+
+    def __str__(self) -> str:
+        name = self.frame.code.name
+        try:
+            line = str(self.statement).lstrip()
+        except KeyboardInterrupt:
+            raise
+        except BaseException:
+            line = "???"
+        # This output does not quite match Python's repr for traceback entries,
+        # but changing it to do so would break certain plugins.  See
+        # https://github.com/pytest-dev/pytest/pull/7535/ for details.
+        return "  File %r:%d in %s\n  %s\n" % (
+            str(self.path),
+            self.lineno + 1,
+            name,
+            line,
+        )
+
+    @property
+    def name(self) -> str:
+        """co_name of underlying code."""
+        return self.frame.code.raw.co_name
+
+
+class Traceback(List[TracebackEntry]):
+    """Traceback objects encapsulate and offer higher level access to Traceback entries."""
+
+    def __init__(
+        self,
+        tb: Union[TracebackType, Iterable[TracebackEntry]],
+        excinfo: Optional["ReferenceType[ExceptionInfo[BaseException]]"] = None,
+    ) -> None:
+        """Initialize from given python traceback object and ExceptionInfo."""
+        self._excinfo = excinfo
+        if isinstance(tb, TracebackType):
+
+            def f(cur: TracebackType) -> Iterable[TracebackEntry]:
+                cur_: Optional[TracebackType] = cur
+                while cur_ is not None:
+                    yield TracebackEntry(cur_, excinfo=excinfo)
+                    cur_ = cur_.tb_next
+
+            super().__init__(f(tb))
+        else:
+            super().__init__(tb)
+
+    def cut(
+        self,
+        path=None,
+        lineno: Optional[int] = None,
+        firstlineno: Optional[int] = None,
+        excludepath: Optional[py.path.local] = None,
+    ) -> "Traceback":
+        """Return a Traceback instance wrapping part of this Traceback.
+
+        By providing any combination of path, lineno and firstlineno, the
+        first frame to start the to-be-returned traceback is determined.
+
+        This allows cutting the first part of a Traceback instance e.g.
+        for formatting reasons (removing some uninteresting bits that deal
+        with handling of the exception/traceback).
+        """
+        for x in self:
+            code = x.frame.code
+            codepath = code.path
+            if (
+                (path is None or codepath == path)
+                and (
+                    excludepath is None
+                    or not isinstance(codepath, py.path.local)
+                    or not codepath.relto(excludepath)
+                )
+                and (lineno is None or x.lineno == lineno)
+                and (firstlineno is None or x.frame.code.firstlineno == firstlineno)
+            ):
+                return Traceback(x._rawentry, self._excinfo)
+        return self
+
+    @overload
+    def __getitem__(self, key: int) -> TracebackEntry:
+        ...
+
+    @overload
+    def __getitem__(self, key: slice) -> "Traceback":
+        ...
+
+    def __getitem__(self, key: Union[int, slice]) -> Union[TracebackEntry, "Traceback"]:
+        if isinstance(key, slice):
+            return self.__class__(super().__getitem__(key))
+        else:
+            return super().__getitem__(key)
+
+    def filter(
+        self, fn: Callable[[TracebackEntry], bool] = lambda x: not x.ishidden()
+    ) -> "Traceback":
+        """Return a Traceback instance with certain items removed
+
+        fn is a function that gets a single argument, a TracebackEntry
+        instance, and should return True when the item should be added
+        to the Traceback, False when not.
+
+        By default this removes all the TracebackEntries which are hidden
+        (see ishidden() above).
+        """
+        return Traceback(filter(fn, self), self._excinfo)
+
+    def getcrashentry(self) -> TracebackEntry:
+        """Return last non-hidden traceback entry that lead to the exception of a traceback."""
+        for i in range(-1, -len(self) - 1, -1):
+            entry = self[i]
+            if not entry.ishidden():
+                return entry
+        return self[-1]
+
+    def recursionindex(self) -> Optional[int]:
+        """Return the index of the frame/TracebackEntry where recursion originates if
+        appropriate, None if no recursion occurred."""
+        cache: Dict[Tuple[Any, int, int], List[Dict[str, Any]]] = {}
+        for i, entry in enumerate(self):
+            # id for the code.raw is needed to work around
+            # the strange metaprogramming in the decorator lib from pypi
+            # which generates code objects that have hash/value equality
+            # XXX needs a test
+            key = entry.frame.code.path, id(entry.frame.code.raw), entry.lineno
+            # print "checking for recursion at", key
+            values = cache.setdefault(key, [])
+            if values:
+                f = entry.frame
+                loc = f.f_locals
+                for otherloc in values:
+                    if f.eval(
+                        co_equal,
+                        __recursioncache_locals_1=loc,
+                        __recursioncache_locals_2=otherloc,
+                    ):
+                        return i
+            values.append(entry.frame.f_locals)
+        return None
+
+
+co_equal = compile(
+    "__recursioncache_locals_1 == __recursioncache_locals_2", "?", "eval"
+)
+
+
+_E = TypeVar("_E", bound=BaseException, covariant=True)
+
+
+@final
+@attr.s(repr=False)
+class ExceptionInfo(Generic[_E]):
+    """Wraps sys.exc_info() objects and offers help for navigating the traceback."""
+
+    _assert_start_repr = "AssertionError('assert "
+
+    _excinfo = attr.ib(type=Optional[Tuple[Type["_E"], "_E", TracebackType]])
+    _striptext = attr.ib(type=str, default="")
+    _traceback = attr.ib(type=Optional[Traceback], default=None)
+
+    @classmethod
+    def from_exc_info(
+        cls,
+        exc_info: Tuple[Type[_E], _E, TracebackType],
+        exprinfo: Optional[str] = None,
+    ) -> "ExceptionInfo[_E]":
+        """Return an ExceptionInfo for an existing exc_info tuple.
+
+        .. warning::
+
+            Experimental API
+
+        :param exprinfo:
+            A text string helping to determine if we should strip
+            ``AssertionError`` from the output. Defaults to the exception
+            message/``__str__()``.
+        """
+        _striptext = ""
+        if exprinfo is None and isinstance(exc_info[1], AssertionError):
+            exprinfo = getattr(exc_info[1], "msg", None)
+            if exprinfo is None:
+                exprinfo = saferepr(exc_info[1])
+            if exprinfo and exprinfo.startswith(cls._assert_start_repr):
+                _striptext = "AssertionError: "
+
+        return cls(exc_info, _striptext)
+
+    @classmethod
+    def from_current(
+        cls, exprinfo: Optional[str] = None
+    ) -> "ExceptionInfo[BaseException]":
+        """Return an ExceptionInfo matching the current traceback.
+
+        .. warning::
+
+            Experimental API
+
+        :param exprinfo:
+            A text string helping to determine if we should strip
+            ``AssertionError`` from the output. Defaults to the exception
+            message/``__str__()``.
+        """
+        tup = sys.exc_info()
+        assert tup[0] is not None, "no current exception"
+        assert tup[1] is not None, "no current exception"
+        assert tup[2] is not None, "no current exception"
+        exc_info = (tup[0], tup[1], tup[2])
+        return ExceptionInfo.from_exc_info(exc_info, exprinfo)
+
+    @classmethod
+    def for_later(cls) -> "ExceptionInfo[_E]":
+        """Return an unfilled ExceptionInfo."""
+        return cls(None)
+
+    def fill_unfilled(self, exc_info: Tuple[Type[_E], _E, TracebackType]) -> None:
+        """Fill an unfilled ExceptionInfo created with ``for_later()``."""
+        assert self._excinfo is None, "ExceptionInfo was already filled"
+        self._excinfo = exc_info
+
+    @property
+    def type(self) -> Type[_E]:
+        """The exception class."""
+        assert (
+            self._excinfo is not None
+        ), ".type can only be used after the context manager exits"
+        return self._excinfo[0]
+
+    @property
+    def value(self) -> _E:
+        """The exception value."""
+        assert (
+            self._excinfo is not None
+        ), ".value can only be used after the context manager exits"
+        return self._excinfo[1]
+
+    @property
+    def tb(self) -> TracebackType:
+        """The exception raw traceback."""
+        assert (
+            self._excinfo is not None
+        ), ".tb can only be used after the context manager exits"
+        return self._excinfo[2]
+
+    @property
+    def typename(self) -> str:
+        """The type name of the exception."""
+        assert (
+            self._excinfo is not None
+        ), ".typename can only be used after the context manager exits"
+        return self.type.__name__
+
+    @property
+    def traceback(self) -> Traceback:
+        """The traceback."""
+        if self._traceback is None:
+            self._traceback = Traceback(self.tb, excinfo=ref(self))
+        return self._traceback
+
+    @traceback.setter
+    def traceback(self, value: Traceback) -> None:
+        self._traceback = value
+
+    def __repr__(self) -> str:
+        if self._excinfo is None:
+            return "<ExceptionInfo for raises contextmanager>"
+        return "<{} {} tblen={}>".format(
+            self.__class__.__name__, saferepr(self._excinfo[1]), len(self.traceback)
+        )
+
+    def exconly(self, tryshort: bool = False) -> str:
+        """Return the exception as a string.
+
+        When 'tryshort' resolves to True, and the exception is a
+        _pytest._code._AssertionError, only the actual exception part of
+        the exception representation is returned (so 'AssertionError: ' is
+        removed from the beginning).
+        """
+        lines = format_exception_only(self.type, self.value)
+        text = "".join(lines)
+        text = text.rstrip()
+        if tryshort:
+            if text.startswith(self._striptext):
+                text = text[len(self._striptext) :]
+        return text
+
+    def errisinstance(
+        self, exc: Union[Type[BaseException], Tuple[Type[BaseException], ...]]
+    ) -> bool:
+        """Return True if the exception is an instance of exc.
+
+        Consider using ``isinstance(excinfo.value, exc)`` instead.
+        """
+        return isinstance(self.value, exc)
+
+    def _getreprcrash(self) -> "ReprFileLocation":
+        exconly = self.exconly(tryshort=True)
+        entry = self.traceback.getcrashentry()
+        path, lineno = entry.frame.code.raw.co_filename, entry.lineno
+        return ReprFileLocation(path, lineno + 1, exconly)
+
+    def getrepr(
+        self,
+        showlocals: bool = False,
+        style: "_TracebackStyle" = "long",
+        abspath: bool = False,
+        tbfilter: bool = True,
+        funcargs: bool = False,
+        truncate_locals: bool = True,
+        chain: bool = True,
+    ) -> Union["ReprExceptionInfo", "ExceptionChainRepr"]:
+        """Return str()able representation of this exception info.
+
+        :param bool showlocals:
+            Show locals per traceback entry.
+            Ignored if ``style=="native"``.
+
+        :param str style:
+            long|short|no|native|value traceback style.
+
+        :param bool abspath:
+            If paths should be changed to absolute or left unchanged.
+
+        :param bool tbfilter:
+            Hide entries that contain a local variable ``__tracebackhide__==True``.
+            Ignored if ``style=="native"``.
+
+        :param bool funcargs:
+            Show fixtures ("funcargs" for legacy purposes) per traceback entry.
+
+        :param bool truncate_locals:
+            With ``showlocals==True``, make sure locals can be safely represented as strings.
+
+        :param bool chain:
+            If chained exceptions in Python 3 should be shown.
+
+        .. versionchanged:: 3.9
+
+            Added the ``chain`` parameter.
+        """
+        if style == "native":
+            return ReprExceptionInfo(
+                ReprTracebackNative(
+                    traceback.format_exception(
+                        self.type, self.value, self.traceback[0]._rawentry
+                    )
+                ),
+                self._getreprcrash(),
+            )
+
+        fmt = FormattedExcinfo(
+            showlocals=showlocals,
+            style=style,
+            abspath=abspath,
+            tbfilter=tbfilter,
+            funcargs=funcargs,
+            truncate_locals=truncate_locals,
+            chain=chain,
+        )
+        return fmt.repr_excinfo(self)
+
+    def match(self, regexp: Union[str, Pattern[str]]) -> "Literal[True]":
+        """Check whether the regular expression `regexp` matches the string
+        representation of the exception using :func:`python:re.search`.
+
+        If it matches `True` is returned, otherwise an `AssertionError` is raised.
+        """
+        __tracebackhide__ = True
+        msg = "Regex pattern {!r} does not match {!r}."
+        if regexp == str(self.value):
+            msg += " Did you mean to `re.escape()` the regex?"
+        assert re.search(regexp, str(self.value)), msg.format(regexp, str(self.value))
+        # Return True to allow for "assert excinfo.match()".
+        return True
+
+
+@attr.s
+class FormattedExcinfo:
+    """Presenting information about failing Functions and Generators."""
+
+    # for traceback entries
+    flow_marker = ">"
+    fail_marker = "E"
+
+    showlocals = attr.ib(type=bool, default=False)
+    style = attr.ib(type="_TracebackStyle", default="long")
+    abspath = attr.ib(type=bool, default=True)
+    tbfilter = attr.ib(type=bool, default=True)
+    funcargs = attr.ib(type=bool, default=False)
+    truncate_locals = attr.ib(type=bool, default=True)
+    chain = attr.ib(type=bool, default=True)
+    astcache = attr.ib(default=attr.Factory(dict), init=False, repr=False)
+
+    def _getindent(self, source: "Source") -> int:
+        # Figure out indent for the given source.
+        try:
+            s = str(source.getstatement(len(source) - 1))
+        except KeyboardInterrupt:
+            raise
+        except BaseException:
+            try:
+                s = str(source[-1])
+            except KeyboardInterrupt:
+                raise
+            except BaseException:
+                return 0
+        return 4 + (len(s) - len(s.lstrip()))
+
+    def _getentrysource(self, entry: TracebackEntry) -> Optional["Source"]:
+        source = entry.getsource(self.astcache)
+        if source is not None:
+            source = source.deindent()
+        return source
+
+    def repr_args(self, entry: TracebackEntry) -> Optional["ReprFuncArgs"]:
+        if self.funcargs:
+            args = []
+            for argname, argvalue in entry.frame.getargs(var=True):
+                args.append((argname, saferepr(argvalue)))
+            return ReprFuncArgs(args)
+        return None
+
+    def get_source(
+        self,
+        source: Optional["Source"],
+        line_index: int = -1,
+        excinfo: Optional[ExceptionInfo[BaseException]] = None,
+        short: bool = False,
+    ) -> List[str]:
+        """Return formatted and marked up source lines."""
+        lines = []
+        if source is None or line_index >= len(source.lines):
+            source = Source("???")
+            line_index = 0
+        if line_index < 0:
+            line_index += len(source)
+        space_prefix = "    "
+        if short:
+            lines.append(space_prefix + source.lines[line_index].strip())
+        else:
+            for line in source.lines[:line_index]:
+                lines.append(space_prefix + line)
+            lines.append(self.flow_marker + "   " + source.lines[line_index])
+            for line in source.lines[line_index + 1 :]:
+                lines.append(space_prefix + line)
+        if excinfo is not None:
+            indent = 4 if short else self._getindent(source)
+            lines.extend(self.get_exconly(excinfo, indent=indent, markall=True))
+        return lines
+
+    def get_exconly(
+        self,
+        excinfo: ExceptionInfo[BaseException],
+        indent: int = 4,
+        markall: bool = False,
+    ) -> List[str]:
+        lines = []
+        indentstr = " " * indent
+        # Get the real exception information out.
+        exlines = excinfo.exconly(tryshort=True).split("\n")
+        failindent = self.fail_marker + indentstr[1:]
+        for line in exlines:
+            lines.append(failindent + line)
+            if not markall:
+                failindent = indentstr
+        return lines
+
+    def repr_locals(self, locals: Mapping[str, object]) -> Optional["ReprLocals"]:
+        if self.showlocals:
+            lines = []
+            keys = [loc for loc in locals if loc[0] != "@"]
+            keys.sort()
+            for name in keys:
+                value = locals[name]
+                if name == "__builtins__":
+                    lines.append("__builtins__ = <builtins>")
+                else:
+                    # This formatting could all be handled by the
+                    # _repr() function, which is only reprlib.Repr in
+                    # disguise, so is very configurable.
+                    if self.truncate_locals:
+                        str_repr = saferepr(value)
+                    else:
+                        str_repr = safeformat(value)
+                    # if len(str_repr) < 70 or not isinstance(value, (list, tuple, dict)):
+                    lines.append(f"{name:<10} = {str_repr}")
+                    # else:
+                    #    self._line("%-10s =\\" % (name,))
+                    #    # XXX
+                    #    pprint.pprint(value, stream=self.excinfowriter)
+            return ReprLocals(lines)
+        return None
+
+    def repr_traceback_entry(
+        self,
+        entry: TracebackEntry,
+        excinfo: Optional[ExceptionInfo[BaseException]] = None,
+    ) -> "ReprEntry":
+        lines: List[str] = []
+        style = entry._repr_style if entry._repr_style is not None else self.style
+        if style in ("short", "long"):
+            source = self._getentrysource(entry)
+            if source is None:
+                source = Source("???")
+                line_index = 0
+            else:
+                line_index = entry.lineno - entry.getfirstlinesource()
+            short = style == "short"
+            reprargs = self.repr_args(entry) if not short else None
+            s = self.get_source(source, line_index, excinfo, short=short)
+            lines.extend(s)
+            if short:
+                message = "in %s" % (entry.name)
+            else:
+                message = excinfo and excinfo.typename or ""
+            path = self._makepath(entry.path)
+            reprfileloc = ReprFileLocation(path, entry.lineno + 1, message)
+            localsrepr = self.repr_locals(entry.locals)
+            return ReprEntry(lines, reprargs, localsrepr, reprfileloc, style)
+        elif style == "value":
+            if excinfo:
+                lines.extend(str(excinfo.value).split("\n"))
+            return ReprEntry(lines, None, None, None, style)
+        else:
+            if excinfo:
+                lines.extend(self.get_exconly(excinfo, indent=4))
+            return ReprEntry(lines, None, None, None, style)
+
+    def _makepath(self, path):
+        if not self.abspath:
+            try:
+                np = py.path.local().bestrelpath(path)
+            except OSError:
+                return path
+            if len(np) < len(str(path)):
+                path = np
+        return path
+
+    def repr_traceback(self, excinfo: ExceptionInfo[BaseException]) -> "ReprTraceback":
+        traceback = excinfo.traceback
+        if self.tbfilter:
+            traceback = traceback.filter()
+
+        if isinstance(excinfo.value, RecursionError):
+            traceback, extraline = self._truncate_recursive_traceback(traceback)
+        else:
+            extraline = None
+
+        last = traceback[-1]
+        entries = []
+        if self.style == "value":
+            reprentry = self.repr_traceback_entry(last, excinfo)
+            entries.append(reprentry)
+            return ReprTraceback(entries, None, style=self.style)
+
+        for index, entry in enumerate(traceback):
+            einfo = (last == entry) and excinfo or None
+            reprentry = self.repr_traceback_entry(entry, einfo)
+            entries.append(reprentry)
+        return ReprTraceback(entries, extraline, style=self.style)
+
+    def _truncate_recursive_traceback(
+        self, traceback: Traceback
+    ) -> Tuple[Traceback, Optional[str]]:
+        """Truncate the given recursive traceback trying to find the starting
+        point of the recursion.
+
+        The detection is done by going through each traceback entry and
+        finding the point in which the locals of the frame are equal to the
+        locals of a previous frame (see ``recursionindex()``).
+
+        Handle the situation where the recursion process might raise an
+        exception (for example comparing numpy arrays using equality raises a
+        TypeError), in which case we do our best to warn the user of the
+        error and show a limited traceback.
+        """
+        try:
+            recursionindex = traceback.recursionindex()
+        except Exception as e:
+            max_frames = 10
+            extraline: Optional[str] = (
+                "!!! Recursion error detected, but an error occurred locating the origin of recursion.\n"
+                "  The following exception happened when comparing locals in the stack frame:\n"
+                "    {exc_type}: {exc_msg}\n"
+                "  Displaying first and last {max_frames} stack frames out of {total}."
+            ).format(
+                exc_type=type(e).__name__,
+                exc_msg=str(e),
+                max_frames=max_frames,
+                total=len(traceback),
+            )
+            # Type ignored because adding two instaces of a List subtype
+            # currently incorrectly has type List instead of the subtype.
+            traceback = traceback[:max_frames] + traceback[-max_frames:]  # type: ignore
+        else:
+            if recursionindex is not None:
+                extraline = "!!! Recursion detected (same locals & position)"
+                traceback = traceback[: recursionindex + 1]
+            else:
+                extraline = None
+
+        return traceback, extraline
+
+    def repr_excinfo(
+        self, excinfo: ExceptionInfo[BaseException]
+    ) -> "ExceptionChainRepr":
+        repr_chain: List[
+            Tuple[ReprTraceback, Optional[ReprFileLocation], Optional[str]]
+        ] = []
+        e: Optional[BaseException] = excinfo.value
+        excinfo_: Optional[ExceptionInfo[BaseException]] = excinfo
+        descr = None
+        seen: Set[int] = set()
+        while e is not None and id(e) not in seen:
+            seen.add(id(e))
+            if excinfo_:
+                reprtraceback = self.repr_traceback(excinfo_)
+                reprcrash: Optional[ReprFileLocation] = (
+                    excinfo_._getreprcrash() if self.style != "value" else None
+                )
+            else:
+                # Fallback to native repr if the exception doesn't have a traceback:
+                # ExceptionInfo objects require a full traceback to work.
+                reprtraceback = ReprTracebackNative(
+                    traceback.format_exception(type(e), e, None)
+                )
+                reprcrash = None
+
+            repr_chain += [(reprtraceback, reprcrash, descr)]
+            if e.__cause__ is not None and self.chain:
+                e = e.__cause__
+                excinfo_ = (
+                    ExceptionInfo((type(e), e, e.__traceback__))
+                    if e.__traceback__
+                    else None
+                )
+                descr = "The above exception was the direct cause of the following exception:"
+            elif (
+                e.__context__ is not None and not e.__suppress_context__ and self.chain
+            ):
+                e = e.__context__
+                excinfo_ = (
+                    ExceptionInfo((type(e), e, e.__traceback__))
+                    if e.__traceback__
+                    else None
+                )
+                descr = "During handling of the above exception, another exception occurred:"
+            else:
+                e = None
+        repr_chain.reverse()
+        return ExceptionChainRepr(repr_chain)
+
+
+@attr.s(eq=False)
+class TerminalRepr:
+    def __str__(self) -> str:
+        # FYI this is called from pytest-xdist's serialization of exception
+        # information.
+        io = StringIO()
+        tw = TerminalWriter(file=io)
+        self.toterminal(tw)
+        return io.getvalue().strip()
+
+    def __repr__(self) -> str:
+        return "<{} instance at {:0x}>".format(self.__class__, id(self))
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        raise NotImplementedError()
+
+
+# This class is abstract -- only subclasses are instantiated.
+@attr.s(eq=False)
+class ExceptionRepr(TerminalRepr):
+    # Provided by subclasses.
+    reprcrash: Optional["ReprFileLocation"]
+    reprtraceback: "ReprTraceback"
+
+    def __attrs_post_init__(self) -> None:
+        self.sections: List[Tuple[str, str, str]] = []
+
+    def addsection(self, name: str, content: str, sep: str = "-") -> None:
+        self.sections.append((name, content, sep))
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        for name, content, sep in self.sections:
+            tw.sep(sep, name)
+            tw.line(content)
+
+
+@attr.s(eq=False)
+class ExceptionChainRepr(ExceptionRepr):
+    chain = attr.ib(
+        type=Sequence[
+            Tuple["ReprTraceback", Optional["ReprFileLocation"], Optional[str]]
+        ]
+    )
+
+    def __attrs_post_init__(self) -> None:
+        super().__attrs_post_init__()
+        # reprcrash and reprtraceback of the outermost (the newest) exception
+        # in the chain.
+        self.reprtraceback = self.chain[-1][0]
+        self.reprcrash = self.chain[-1][1]
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        for element in self.chain:
+            element[0].toterminal(tw)
+            if element[2] is not None:
+                tw.line("")
+                tw.line(element[2], yellow=True)
+        super().toterminal(tw)
+
+
+@attr.s(eq=False)
+class ReprExceptionInfo(ExceptionRepr):
+    reprtraceback = attr.ib(type="ReprTraceback")
+    reprcrash = attr.ib(type="ReprFileLocation")
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        self.reprtraceback.toterminal(tw)
+        super().toterminal(tw)
+
+
+@attr.s(eq=False)
+class ReprTraceback(TerminalRepr):
+    reprentries = attr.ib(type=Sequence[Union["ReprEntry", "ReprEntryNative"]])
+    extraline = attr.ib(type=Optional[str])
+    style = attr.ib(type="_TracebackStyle")
+
+    entrysep = "_ "
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        # The entries might have different styles.
+        for i, entry in enumerate(self.reprentries):
+            if entry.style == "long":
+                tw.line("")
+            entry.toterminal(tw)
+            if i < len(self.reprentries) - 1:
+                next_entry = self.reprentries[i + 1]
+                if (
+                    entry.style == "long"
+                    or entry.style == "short"
+                    and next_entry.style == "long"
+                ):
+                    tw.sep(self.entrysep)
+
+        if self.extraline:
+            tw.line(self.extraline)
+
+
+class ReprTracebackNative(ReprTraceback):
+    def __init__(self, tblines: Sequence[str]) -> None:
+        self.style = "native"
+        self.reprentries = [ReprEntryNative(tblines)]
+        self.extraline = None
+
+
+@attr.s(eq=False)
+class ReprEntryNative(TerminalRepr):
+    lines = attr.ib(type=Sequence[str])
+    style: "_TracebackStyle" = "native"
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        tw.write("".join(self.lines))
+
+
+@attr.s(eq=False)
+class ReprEntry(TerminalRepr):
+    lines = attr.ib(type=Sequence[str])
+    reprfuncargs = attr.ib(type=Optional["ReprFuncArgs"])
+    reprlocals = attr.ib(type=Optional["ReprLocals"])
+    reprfileloc = attr.ib(type=Optional["ReprFileLocation"])
+    style = attr.ib(type="_TracebackStyle")
+
+    def _write_entry_lines(self, tw: TerminalWriter) -> None:
+        """Write the source code portions of a list of traceback entries with syntax highlighting.
+
+        Usually entries are lines like these:
+
+            "     x = 1"
+            ">    assert x == 2"
+            "E    assert 1 == 2"
+
+        This function takes care of rendering the "source" portions of it (the lines without
+        the "E" prefix) using syntax highlighting, taking care to not highlighting the ">"
+        character, as doing so might break line continuations.
+        """
+
+        if not self.lines:
+            return
+
+        # separate indents and source lines that are not failures: we want to
+        # highlight the code but not the indentation, which may contain markers
+        # such as ">   assert 0"
+        fail_marker = f"{FormattedExcinfo.fail_marker}   "
+        indent_size = len(fail_marker)
+        indents: List[str] = []
+        source_lines: List[str] = []
+        failure_lines: List[str] = []
+        for index, line in enumerate(self.lines):
+            is_failure_line = line.startswith(fail_marker)
+            if is_failure_line:
+                # from this point on all lines are considered part of the failure
+                failure_lines.extend(self.lines[index:])
+                break
+            else:
+                if self.style == "value":
+                    source_lines.append(line)
+                else:
+                    indents.append(line[:indent_size])
+                    source_lines.append(line[indent_size:])
+
+        tw._write_source(source_lines, indents)
+
+        # failure lines are always completely red and bold
+        for line in failure_lines:
+            tw.line(line, bold=True, red=True)
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        if self.style == "short":
+            assert self.reprfileloc is not None
+            self.reprfileloc.toterminal(tw)
+            self._write_entry_lines(tw)
+            if self.reprlocals:
+                self.reprlocals.toterminal(tw, indent=" " * 8)
+            return
+
+        if self.reprfuncargs:
+            self.reprfuncargs.toterminal(tw)
+
+        self._write_entry_lines(tw)
+
+        if self.reprlocals:
+            tw.line("")
+            self.reprlocals.toterminal(tw)
+        if self.reprfileloc:
+            if self.lines:
+                tw.line("")
+            self.reprfileloc.toterminal(tw)
+
+    def __str__(self) -> str:
+        return "{}\n{}\n{}".format(
+            "\n".join(self.lines), self.reprlocals, self.reprfileloc
+        )
+
+
+@attr.s(eq=False)
+class ReprFileLocation(TerminalRepr):
+    path = attr.ib(type=str, converter=str)
+    lineno = attr.ib(type=int)
+    message = attr.ib(type=str)
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        # Filename and lineno output for each entry, using an output format
+        # that most editors understand.
+        msg = self.message
+        i = msg.find("\n")
+        if i != -1:
+            msg = msg[:i]
+        tw.write(self.path, bold=True, red=True)
+        tw.line(f":{self.lineno}: {msg}")
+
+
+@attr.s(eq=False)
+class ReprLocals(TerminalRepr):
+    lines = attr.ib(type=Sequence[str])
+
+    def toterminal(self, tw: TerminalWriter, indent="") -> None:
+        for line in self.lines:
+            tw.line(indent + line)
+
+
+@attr.s(eq=False)
+class ReprFuncArgs(TerminalRepr):
+    args = attr.ib(type=Sequence[Tuple[str, object]])
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        if self.args:
+            linesofar = ""
+            for name, value in self.args:
+                ns = f"{name} = {value}"
+                if len(ns) + len(linesofar) + 2 > tw.fullwidth:
+                    if linesofar:
+                        tw.line(linesofar)
+                    linesofar = ns
+                else:
+                    if linesofar:
+                        linesofar += ", " + ns
+                    else:
+                        linesofar = ns
+            if linesofar:
+                tw.line(linesofar)
+            tw.line("")
+
+
+def getfslineno(obj: object) -> Tuple[Union[str, py.path.local], int]:
+    """Return source location (path, lineno) for the given object.
+
+    If the source cannot be determined return ("", -1).
+
+    The line number is 0-based.
+    """
+    # xxx let decorators etc specify a sane ordering
+    # NOTE: this used to be done in _pytest.compat.getfslineno, initially added
+    #       in 6ec13a2b9.  It ("place_as") appears to be something very custom.
+    obj = get_real_func(obj)
+    if hasattr(obj, "place_as"):
+        obj = obj.place_as  # type: ignore[attr-defined]
+
+    try:
+        code = Code.from_function(obj)
+    except TypeError:
+        try:
+            fn = inspect.getsourcefile(obj) or inspect.getfile(obj)  # type: ignore[arg-type]
+        except TypeError:
+            return "", -1
+
+        fspath = fn and py.path.local(fn) or ""
+        lineno = -1
+        if fspath:
+            try:
+                _, lineno = findsource(obj)
+            except OSError:
+                pass
+        return fspath, lineno
+
+    return code.path, code.firstlineno
+
+
+# Relative paths that we use to filter traceback entries from appearing to the user;
+# see filter_traceback.
+# note: if we need to add more paths than what we have now we should probably use a list
+# for better maintenance.
+
+_PLUGGY_DIR = Path(pluggy.__file__.rstrip("oc"))
+# pluggy is either a package or a single module depending on the version
+if _PLUGGY_DIR.name == "__init__.py":
+    _PLUGGY_DIR = _PLUGGY_DIR.parent
+_PYTEST_DIR = Path(_pytest.__file__).parent
+_PY_DIR = Path(py.__file__).parent
+
+
+def filter_traceback(entry: TracebackEntry) -> bool:
+    """Return True if a TracebackEntry instance should be included in tracebacks.
+
+    We hide traceback entries of:
+
+    * dynamically generated code (no code to show up for it);
+    * internal traceback from pytest or its internal libraries, py and pluggy.
+    """
+    # entry.path might sometimes return a str object when the entry
+    # points to dynamically generated code.
+    # See https://bitbucket.org/pytest-dev/py/issues/71.
+    raw_filename = entry.frame.code.raw.co_filename
+    is_generated = "<" in raw_filename and ">" in raw_filename
+    if is_generated:
+        return False
+
+    # entry.path might point to a non-existing file, in which case it will
+    # also return a str object. See #1133.
+    p = Path(entry.path)
+
+    parents = p.parents
+    if _PLUGGY_DIR in parents:
+        return False
+    if _PYTEST_DIR in parents:
+        return False
+    if _PY_DIR in parents:
+        return False
+
+    return True
diff --git a/myenv/lib/python3.9/site-packages/_pytest/_code/source.py b/myenv/lib/python3.9/site-packages/_pytest/_code/source.py
new file mode 100644
index 0000000..6f54057
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/_code/source.py
@@ -0,0 +1,212 @@
+import ast
+import inspect
+import textwrap
+import tokenize
+import types
+import warnings
+from bisect import bisect_right
+from typing import Iterable
+from typing import Iterator
+from typing import List
+from typing import Optional
+from typing import overload
+from typing import Tuple
+from typing import Union
+
+
+class Source:
+    """An immutable object holding a source code fragment.
+
+    When using Source(...), the source lines are deindented.
+    """
+
+    def __init__(self, obj: object = None) -> None:
+        if not obj:
+            self.lines: List[str] = []
+        elif isinstance(obj, Source):
+            self.lines = obj.lines
+        elif isinstance(obj, (tuple, list)):
+            self.lines = deindent(x.rstrip("\n") for x in obj)
+        elif isinstance(obj, str):
+            self.lines = deindent(obj.split("\n"))
+        else:
+            try:
+                rawcode = getrawcode(obj)
+                src = inspect.getsource(rawcode)
+            except TypeError:
+                src = inspect.getsource(obj)  # type: ignore[arg-type]
+            self.lines = deindent(src.split("\n"))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Source):
+            return NotImplemented
+        return self.lines == other.lines
+
+    # Ignore type because of https://github.com/python/mypy/issues/4266.
+    __hash__ = None  # type: ignore
+
+    @overload
+    def __getitem__(self, key: int) -> str:
+        ...
+
+    @overload
+    def __getitem__(self, key: slice) -> "Source":
+        ...
+
+    def __getitem__(self, key: Union[int, slice]) -> Union[str, "Source"]:
+        if isinstance(key, int):
+            return self.lines[key]
+        else:
+            if key.step not in (None, 1):
+                raise IndexError("cannot slice a Source with a step")
+            newsource = Source()
+            newsource.lines = self.lines[key.start : key.stop]
+            return newsource
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.lines)
+
+    def __len__(self) -> int:
+        return len(self.lines)
+
+    def strip(self) -> "Source":
+        """Return new Source object with trailing and leading blank lines removed."""
+        start, end = 0, len(self)
+        while start < end and not self.lines[start].strip():
+            start += 1
+        while end > start and not self.lines[end - 1].strip():
+            end -= 1
+        source = Source()
+        source.lines[:] = self.lines[start:end]
+        return source
+
+    def indent(self, indent: str = " " * 4) -> "Source":
+        """Return a copy of the source object with all lines indented by the
+        given indent-string."""
+        newsource = Source()
+        newsource.lines = [(indent + line) for line in self.lines]
+        return newsource
+
+    def getstatement(self, lineno: int) -> "Source":
+        """Return Source statement which contains the given linenumber
+        (counted from 0)."""
+        start, end = self.getstatementrange(lineno)
+        return self[start:end]
+
+    def getstatementrange(self, lineno: int) -> Tuple[int, int]:
+        """Return (start, end) tuple which spans the minimal statement region
+        which containing the given lineno."""
+        if not (0 <= lineno < len(self)):
+            raise IndexError("lineno out of range")
+        ast, start, end = getstatementrange_ast(lineno, self)
+        return start, end
+
+    def deindent(self) -> "Source":
+        """Return a new Source object deindented."""
+        newsource = Source()
+        newsource.lines[:] = deindent(self.lines)
+        return newsource
+
+    def __str__(self) -> str:
+        return "\n".join(self.lines)
+
+
+#
+# helper functions
+#
+
+
+def findsource(obj) -> Tuple[Optional[Source], int]:
+    try:
+        sourcelines, lineno = inspect.findsource(obj)
+    except Exception:
+        return None, -1
+    source = Source()
+    source.lines = [line.rstrip() for line in sourcelines]
+    return source, lineno
+
+
+def getrawcode(obj: object, trycall: bool = True) -> types.CodeType:
+    """Return code object for given function."""
+    try:
+        return obj.__code__  # type: ignore[attr-defined,no-any-return]
+    except AttributeError:
+        pass
+    if trycall:
+        call = getattr(obj, "__call__", None)
+        if call and not isinstance(obj, type):
+            return getrawcode(call, trycall=False)
+    raise TypeError(f"could not get code object for {obj!r}")
+
+
+def deindent(lines: Iterable[str]) -> List[str]:
+    return textwrap.dedent("\n".join(lines)).splitlines()
+
+
+def get_statement_startend2(lineno: int, node: ast.AST) -> Tuple[int, Optional[int]]:
+    # Flatten all statements and except handlers into one lineno-list.
+    # AST's line numbers start indexing at 1.
+    values: List[int] = []
+    for x in ast.walk(node):
+        if isinstance(x, (ast.stmt, ast.ExceptHandler)):
+            values.append(x.lineno - 1)
+            for name in ("finalbody", "orelse"):
+                val: Optional[List[ast.stmt]] = getattr(x, name, None)
+                if val:
+                    # Treat the finally/orelse part as its own statement.
+                    values.append(val[0].lineno - 1 - 1)
+    values.sort()
+    insert_index = bisect_right(values, lineno)
+    start = values[insert_index - 1]
+    if insert_index >= len(values):
+        end = None
+    else:
+        end = values[insert_index]
+    return start, end
+
+
+def getstatementrange_ast(
+    lineno: int,
+    source: Source,
+    assertion: bool = False,
+    astnode: Optional[ast.AST] = None,
+) -> Tuple[ast.AST, int, int]:
+    if astnode is None:
+        content = str(source)
+        # See #4260:
+        # Don't produce duplicate warnings when compiling source to find AST.
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            astnode = ast.parse(content, "source", "exec")
+
+    start, end = get_statement_startend2(lineno, astnode)
+    # We need to correct the end:
+    # - ast-parsing strips comments
+    # - there might be empty lines
+    # - we might have lesser indented code blocks at the end
+    if end is None:
+        end = len(source.lines)
+
+    if end > start + 1:
+        # Make sure we don't span differently indented code blocks
+        # by using the BlockFinder helper used which inspect.getsource() uses itself.
+        block_finder = inspect.BlockFinder()
+        # If we start with an indented line, put blockfinder to "started" mode.
+        block_finder.started = source.lines[start][0].isspace()
+        it = ((x + "\n") for x in source.lines[start:end])
+        try:
+            for tok in tokenize.generate_tokens(lambda: next(it)):
+                block_finder.tokeneater(*tok)
+        except (inspect.EndOfBlock, IndentationError):
+            end = block_finder.last + start
+        except Exception:
+            pass
+
+    # The end might still point to a comment or empty line, correct it.
+    while end:
+        line = source.lines[end - 1].lstrip()
+        if line.startswith("#") or not line:
+            end -= 1
+        else:
+            break
+    return astnode, start, end
diff --git a/myenv/lib/python3.9/site-packages/_pytest/_io/__init__.py b/myenv/lib/python3.9/site-packages/_pytest/_io/__init__.py
new file mode 100644
index 0000000..db001e9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/_io/__init__.py
@@ -0,0 +1,8 @@
+from .terminalwriter import get_terminal_width
+from .terminalwriter import TerminalWriter
+
+
+__all__ = [
+    "TerminalWriter",
+    "get_terminal_width",
+]
diff --git a/myenv/lib/python3.9/site-packages/_pytest/_io/saferepr.py b/myenv/lib/python3.9/site-packages/_pytest/_io/saferepr.py
new file mode 100644
index 0000000..5eb1e08
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/_io/saferepr.py
@@ -0,0 +1,129 @@
+import pprint
+import reprlib
+from typing import Any
+from typing import Dict
+from typing import IO
+from typing import Optional
+
+
+def _try_repr_or_str(obj: object) -> str:
+    try:
+        return repr(obj)
+    except (KeyboardInterrupt, SystemExit):
+        raise
+    except BaseException:
+        return '{}("{}")'.format(type(obj).__name__, obj)
+
+
+def _format_repr_exception(exc: BaseException, obj: object) -> str:
+    try:
+        exc_info = _try_repr_or_str(exc)
+    except (KeyboardInterrupt, SystemExit):
+        raise
+    except BaseException as exc:
+        exc_info = "unpresentable exception ({})".format(_try_repr_or_str(exc))
+    return "<[{} raised in repr()] {} object at 0x{:x}>".format(
+        exc_info, type(obj).__name__, id(obj)
+    )
+
+
+def _ellipsize(s: str, maxsize: int) -> str:
+    if len(s) > maxsize:
+        i = max(0, (maxsize - 3) // 2)
+        j = max(0, maxsize - 3 - i)
+        return s[:i] + "..." + s[len(s) - j :]
+    return s
+
+
+class SafeRepr(reprlib.Repr):
+    """repr.Repr that limits the resulting size of repr() and includes
+    information on exceptions raised during the call."""
+
+    def __init__(self, maxsize: int) -> None:
+        super().__init__()
+        self.maxstring = maxsize
+        self.maxsize = maxsize
+
+    def repr(self, x: object) -> str:
+        try:
+            s = super().repr(x)
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            s = _format_repr_exception(exc, x)
+        return _ellipsize(s, self.maxsize)
+
+    def repr_instance(self, x: object, level: int) -> str:
+        try:
+            s = repr(x)
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            s = _format_repr_exception(exc, x)
+        return _ellipsize(s, self.maxsize)
+
+
+def safeformat(obj: object) -> str:
+    """Return a pretty printed string for the given object.
+
+    Failing __repr__ functions of user instances will be represented
+    with a short exception info.
+    """
+    try:
+        return pprint.pformat(obj)
+    except Exception as exc:
+        return _format_repr_exception(exc, obj)
+
+
+def saferepr(obj: object, maxsize: int = 240) -> str:
+    """Return a size-limited safe repr-string for the given object.
+
+    Failing __repr__ functions of user instances will be represented
+    with a short exception info and 'saferepr' generally takes
+    care to never raise exceptions itself.
+
+    This function is a wrapper around the Repr/reprlib functionality of the
+    standard 2.6 lib.
+    """
+    return SafeRepr(maxsize).repr(obj)
+
+
+class AlwaysDispatchingPrettyPrinter(pprint.PrettyPrinter):
+    """PrettyPrinter that always dispatches (regardless of width)."""
+
+    def _format(
+        self,
+        object: object,
+        stream: IO[str],
+        indent: int,
+        allowance: int,
+        context: Dict[int, Any],
+        level: int,
+    ) -> None:
+        # Type ignored because _dispatch is private.
+        p = self._dispatch.get(type(object).__repr__, None)  # type: ignore[attr-defined]
+
+        objid = id(object)
+        if objid in context or p is None:
+            # Type ignored because _format is private.
+            super()._format(  # type: ignore[misc]
+                object, stream, indent, allowance, context, level,
+            )
+            return
+
+        context[objid] = 1
+        p(self, object, stream, indent, allowance, context, level + 1)
+        del context[objid]
+
+
+def _pformat_dispatch(
+    object: object,
+    indent: int = 1,
+    width: int = 80,
+    depth: Optional[int] = None,
+    *,
+    compact: bool = False,
+) -> str:
+    return AlwaysDispatchingPrettyPrinter(
+        indent=indent, width=width, depth=depth, compact=compact
+    ).pformat(object)
diff --git a/myenv/lib/python3.9/site-packages/_pytest/_io/terminalwriter.py b/myenv/lib/python3.9/site-packages/_pytest/_io/terminalwriter.py
new file mode 100644
index 0000000..8edf4cd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/_io/terminalwriter.py
@@ -0,0 +1,210 @@
+"""Helper functions for writing to terminals and files."""
+import os
+import shutil
+import sys
+from typing import Optional
+from typing import Sequence
+from typing import TextIO
+
+from .wcwidth import wcswidth
+from _pytest.compat import final
+
+
+# This code was initially copied from py 1.8.1, file _io/terminalwriter.py.
+
+
+def get_terminal_width() -> int:
+    width, _ = shutil.get_terminal_size(fallback=(80, 24))
+
+    # The Windows get_terminal_size may be bogus, let's sanify a bit.
+    if width < 40:
+        width = 80
+
+    return width
+
+
+def should_do_markup(file: TextIO) -> bool:
+    if os.environ.get("PY_COLORS") == "1":
+        return True
+    if os.environ.get("PY_COLORS") == "0":
+        return False
+    if "NO_COLOR" in os.environ:
+        return False
+    if "FORCE_COLOR" in os.environ:
+        return True
+    return (
+        hasattr(file, "isatty") and file.isatty() and os.environ.get("TERM") != "dumb"
+    )
+
+
+@final
+class TerminalWriter:
+    _esctable = dict(
+        black=30,
+        red=31,
+        green=32,
+        yellow=33,
+        blue=34,
+        purple=35,
+        cyan=36,
+        white=37,
+        Black=40,
+        Red=41,
+        Green=42,
+        Yellow=43,
+        Blue=44,
+        Purple=45,
+        Cyan=46,
+        White=47,
+        bold=1,
+        light=2,
+        blink=5,
+        invert=7,
+    )
+
+    def __init__(self, file: Optional[TextIO] = None) -> None:
+        if file is None:
+            file = sys.stdout
+        if hasattr(file, "isatty") and file.isatty() and sys.platform == "win32":
+            try:
+                import colorama
+            except ImportError:
+                pass
+            else:
+                file = colorama.AnsiToWin32(file).stream
+                assert file is not None
+        self._file = file
+        self.hasmarkup = should_do_markup(file)
+        self._current_line = ""
+        self._terminal_width: Optional[int] = None
+        self.code_highlight = True
+
+    @property
+    def fullwidth(self) -> int:
+        if self._terminal_width is not None:
+            return self._terminal_width
+        return get_terminal_width()
+
+    @fullwidth.setter
+    def fullwidth(self, value: int) -> None:
+        self._terminal_width = value
+
+    @property
+    def width_of_current_line(self) -> int:
+        """Return an estimate of the width so far in the current line."""
+        return wcswidth(self._current_line)
+
+    def markup(self, text: str, **markup: bool) -> str:
+        for name in markup:
+            if name not in self._esctable:
+                raise ValueError(f"unknown markup: {name!r}")
+        if self.hasmarkup:
+            esc = [self._esctable[name] for name, on in markup.items() if on]
+            if esc:
+                text = "".join("\x1b[%sm" % cod for cod in esc) + text + "\x1b[0m"
+        return text
+
+    def sep(
+        self,
+        sepchar: str,
+        title: Optional[str] = None,
+        fullwidth: Optional[int] = None,
+        **markup: bool,
+    ) -> None:
+        if fullwidth is None:
+            fullwidth = self.fullwidth
+        # The goal is to have the line be as long as possible
+        # under the condition that len(line) <= fullwidth.
+        if sys.platform == "win32":
+            # If we print in the last column on windows we are on a
+            # new line but there is no way to verify/neutralize this
+            # (we may not know the exact line width).
+            # So let's be defensive to avoid empty lines in the output.
+            fullwidth -= 1
+        if title is not None:
+            # we want 2 + 2*len(fill) + len(title) <= fullwidth
+            # i.e.    2 + 2*len(sepchar)*N + len(title) <= fullwidth
+            #         2*len(sepchar)*N <= fullwidth - len(title) - 2
+            #         N <= (fullwidth - len(title) - 2) // (2*len(sepchar))
+            N = max((fullwidth - len(title) - 2) // (2 * len(sepchar)), 1)
+            fill = sepchar * N
+            line = f"{fill} {title} {fill}"
+        else:
+            # we want len(sepchar)*N <= fullwidth
+            # i.e.    N <= fullwidth // len(sepchar)
+            line = sepchar * (fullwidth // len(sepchar))
+        # In some situations there is room for an extra sepchar at the right,
+        # in particular if we consider that with a sepchar like "_ " the
+        # trailing space is not important at the end of the line.
+        if len(line) + len(sepchar.rstrip()) <= fullwidth:
+            line += sepchar.rstrip()
+
+        self.line(line, **markup)
+
+    def write(self, msg: str, *, flush: bool = False, **markup: bool) -> None:
+        if msg:
+            current_line = msg.rsplit("\n", 1)[-1]
+            if "\n" in msg:
+                self._current_line = current_line
+            else:
+                self._current_line += current_line
+
+            msg = self.markup(msg, **markup)
+
+            try:
+                self._file.write(msg)
+            except UnicodeEncodeError:
+                # Some environments don't support printing general Unicode
+                # strings, due to misconfiguration or otherwise; in that case,
+                # print the string escaped to ASCII.
+                # When the Unicode situation improves we should consider
+                # letting the error propagate instead of masking it (see #7475
+                # for one brief attempt).
+                msg = msg.encode("unicode-escape").decode("ascii")
+                self._file.write(msg)
+
+            if flush:
+                self.flush()
+
+    def line(self, s: str = "", **markup: bool) -> None:
+        self.write(s, **markup)
+        self.write("\n")
+
+    def flush(self) -> None:
+        self._file.flush()
+
+    def _write_source(self, lines: Sequence[str], indents: Sequence[str] = ()) -> None:
+        """Write lines of source code possibly highlighted.
+
+        Keeping this private for now because the API is clunky. We should discuss how
+        to evolve the terminal writer so we can have more precise color support, for example
+        being able to write part of a line in one color and the rest in another, and so on.
+        """
+        if indents and len(indents) != len(lines):
+            raise ValueError(
+                "indents size ({}) should have same size as lines ({})".format(
+                    len(indents), len(lines)
+                )
+            )
+        if not indents:
+            indents = [""] * len(lines)
+        source = "\n".join(lines)
+        new_lines = self._highlight(source).splitlines()
+        for indent, new_line in zip(indents, new_lines):
+            self.line(indent + new_line)
+
+    def _highlight(self, source: str) -> str:
+        """Highlight the given source code if we have markup support."""
+        if not self.hasmarkup or not self.code_highlight:
+            return source
+        try:
+            from pygments.formatters.terminal import TerminalFormatter
+            from pygments.lexers.python import PythonLexer
+            from pygments import highlight
+        except ImportError:
+            return source
+        else:
+            highlighted: str = highlight(
+                source, PythonLexer(), TerminalFormatter(bg="dark")
+            )
+            return highlighted
diff --git a/myenv/lib/python3.9/site-packages/_pytest/_io/wcwidth.py b/myenv/lib/python3.9/site-packages/_pytest/_io/wcwidth.py
new file mode 100644
index 0000000..e5c7bf4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/_io/wcwidth.py
@@ -0,0 +1,55 @@
+import unicodedata
+from functools import lru_cache
+
+
+@lru_cache(100)
+def wcwidth(c: str) -> int:
+    """Determine how many columns are needed to display a character in a terminal.
+
+    Returns -1 if the character is not printable.
+    Returns 0, 1 or 2 for other characters.
+    """
+    o = ord(c)
+
+    # ASCII fast path.
+    if 0x20 <= o < 0x07F:
+        return 1
+
+    # Some Cf/Zp/Zl characters which should be zero-width.
+    if (
+        o == 0x0000
+        or 0x200B <= o <= 0x200F
+        or 0x2028 <= o <= 0x202E
+        or 0x2060 <= o <= 0x2063
+    ):
+        return 0
+
+    category = unicodedata.category(c)
+
+    # Control characters.
+    if category == "Cc":
+        return -1
+
+    # Combining characters with zero width.
+    if category in ("Me", "Mn"):
+        return 0
+
+    # Full/Wide east asian characters.
+    if unicodedata.east_asian_width(c) in ("F", "W"):
+        return 2
+
+    return 1
+
+
+def wcswidth(s: str) -> int:
+    """Determine how many columns are needed to display a string in a terminal.
+
+    Returns -1 if the string contains non-printable characters.
+    """
+    width = 0
+    for c in unicodedata.normalize("NFC", s):
+        wc = wcwidth(c)
+        if wc < 0:
+            return -1
+        width += wc
+    return width
diff --git a/myenv/lib/python3.9/site-packages/_pytest/_version.py b/myenv/lib/python3.9/site-packages/_pytest/_version.py
new file mode 100644
index 0000000..8351858
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/_version.py
@@ -0,0 +1,5 @@
+# coding: utf-8
+# file generated by setuptools_scm
+# don't change, don't track in version control
+version = '6.2.5'
+version_tuple = (6, 2, 5)
diff --git a/myenv/lib/python3.9/site-packages/_pytest/assertion/__init__.py b/myenv/lib/python3.9/site-packages/_pytest/assertion/__init__.py
new file mode 100644
index 0000000..a18cf19
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/assertion/__init__.py
@@ -0,0 +1,179 @@
+"""Support for presenting detailed information in failing assertions."""
+import sys
+from typing import Any
+from typing import Generator
+from typing import List
+from typing import Optional
+from typing import TYPE_CHECKING
+
+from _pytest.assertion import rewrite
+from _pytest.assertion import truncate
+from _pytest.assertion import util
+from _pytest.assertion.rewrite import assertstate_key
+from _pytest.config import Config
+from _pytest.config import hookimpl
+from _pytest.config.argparsing import Parser
+from _pytest.nodes import Item
+
+if TYPE_CHECKING:
+    from _pytest.main import Session
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("debugconfig")
+    group.addoption(
+        "--assert",
+        action="store",
+        dest="assertmode",
+        choices=("rewrite", "plain"),
+        default="rewrite",
+        metavar="MODE",
+        help=(
+            "Control assertion debugging tools.\n"
+            "'plain' performs no assertion debugging.\n"
+            "'rewrite' (the default) rewrites assert statements in test modules"
+            " on import to provide assert expression information."
+        ),
+    )
+    parser.addini(
+        "enable_assertion_pass_hook",
+        type="bool",
+        default=False,
+        help="Enables the pytest_assertion_pass hook."
+        "Make sure to delete any previously generated pyc cache files.",
+    )
+
+
+def register_assert_rewrite(*names: str) -> None:
+    """Register one or more module names to be rewritten on import.
+
+    This function will make sure that this module or all modules inside
+    the package will get their assert statements rewritten.
+    Thus you should make sure to call this before the module is
+    actually imported, usually in your __init__.py if you are a plugin
+    using a package.
+
+    :raises TypeError: If the given module names are not strings.
+    """
+    for name in names:
+        if not isinstance(name, str):
+            msg = "expected module names as *args, got {0} instead"  # type: ignore[unreachable]
+            raise TypeError(msg.format(repr(names)))
+    for hook in sys.meta_path:
+        if isinstance(hook, rewrite.AssertionRewritingHook):
+            importhook = hook
+            break
+    else:
+        # TODO(typing): Add a protocol for mark_rewrite() and use it
+        # for importhook and for PytestPluginManager.rewrite_hook.
+        importhook = DummyRewriteHook()  # type: ignore
+    importhook.mark_rewrite(*names)
+
+
+class DummyRewriteHook:
+    """A no-op import hook for when rewriting is disabled."""
+
+    def mark_rewrite(self, *names: str) -> None:
+        pass
+
+
+class AssertionState:
+    """State for the assertion plugin."""
+
+    def __init__(self, config: Config, mode) -> None:
+        self.mode = mode
+        self.trace = config.trace.root.get("assertion")
+        self.hook: Optional[rewrite.AssertionRewritingHook] = None
+
+
+def install_importhook(config: Config) -> rewrite.AssertionRewritingHook:
+    """Try to install the rewrite hook, raise SystemError if it fails."""
+    config._store[assertstate_key] = AssertionState(config, "rewrite")
+    config._store[assertstate_key].hook = hook = rewrite.AssertionRewritingHook(config)
+    sys.meta_path.insert(0, hook)
+    config._store[assertstate_key].trace("installed rewrite import hook")
+
+    def undo() -> None:
+        hook = config._store[assertstate_key].hook
+        if hook is not None and hook in sys.meta_path:
+            sys.meta_path.remove(hook)
+
+    config.add_cleanup(undo)
+    return hook
+
+
+def pytest_collection(session: "Session") -> None:
+    # This hook is only called when test modules are collected
+    # so for example not in the master process of pytest-xdist
+    # (which does not collect test modules).
+    assertstate = session.config._store.get(assertstate_key, None)
+    if assertstate:
+        if assertstate.hook is not None:
+            assertstate.hook.set_session(session)
+
+
+@hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_protocol(item: Item) -> Generator[None, None, None]:
+    """Setup the pytest_assertrepr_compare and pytest_assertion_pass hooks.
+
+    The rewrite module will use util._reprcompare if it exists to use custom
+    reporting via the pytest_assertrepr_compare hook.  This sets up this custom
+    comparison for the test.
+    """
+
+    ihook = item.ihook
+
+    def callbinrepr(op, left: object, right: object) -> Optional[str]:
+        """Call the pytest_assertrepr_compare hook and prepare the result.
+
+        This uses the first result from the hook and then ensures the
+        following:
+        * Overly verbose explanations are truncated unless configured otherwise
+          (eg. if running in verbose mode).
+        * Embedded newlines are escaped to help util.format_explanation()
+          later.
+        * If the rewrite mode is used embedded %-characters are replaced
+          to protect later % formatting.
+
+        The result can be formatted by util.format_explanation() for
+        pretty printing.
+        """
+        hook_result = ihook.pytest_assertrepr_compare(
+            config=item.config, op=op, left=left, right=right
+        )
+        for new_expl in hook_result:
+            if new_expl:
+                new_expl = truncate.truncate_if_required(new_expl, item)
+                new_expl = [line.replace("\n", "\\n") for line in new_expl]
+                res = "\n~".join(new_expl)
+                if item.config.getvalue("assertmode") == "rewrite":
+                    res = res.replace("%", "%%")
+                return res
+        return None
+
+    saved_assert_hooks = util._reprcompare, util._assertion_pass
+    util._reprcompare = callbinrepr
+
+    if ihook.pytest_assertion_pass.get_hookimpls():
+
+        def call_assertion_pass_hook(lineno: int, orig: str, expl: str) -> None:
+            ihook.pytest_assertion_pass(item=item, lineno=lineno, orig=orig, expl=expl)
+
+        util._assertion_pass = call_assertion_pass_hook
+
+    yield
+
+    util._reprcompare, util._assertion_pass = saved_assert_hooks
+
+
+def pytest_sessionfinish(session: "Session") -> None:
+    assertstate = session.config._store.get(assertstate_key, None)
+    if assertstate:
+        if assertstate.hook is not None:
+            assertstate.hook.set_session(None)
+
+
+def pytest_assertrepr_compare(
+    config: Config, op: str, left: Any, right: Any
+) -> Optional[List[str]]:
+    return util.assertrepr_compare(config=config, op=op, left=left, right=right)
diff --git a/myenv/lib/python3.9/site-packages/_pytest/assertion/rewrite.py b/myenv/lib/python3.9/site-packages/_pytest/assertion/rewrite.py
new file mode 100644
index 0000000..37ff076
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/assertion/rewrite.py
@@ -0,0 +1,1125 @@
+"""Rewrite assertion AST to produce nice error messages."""
+import ast
+import errno
+import functools
+import importlib.abc
+import importlib.machinery
+import importlib.util
+import io
+import itertools
+import marshal
+import os
+import struct
+import sys
+import tokenize
+import types
+from pathlib import Path
+from pathlib import PurePath
+from typing import Callable
+from typing import Dict
+from typing import IO
+from typing import Iterable
+from typing import List
+from typing import Optional
+from typing import Sequence
+from typing import Set
+from typing import Tuple
+from typing import TYPE_CHECKING
+from typing import Union
+
+import py
+
+from _pytest._io.saferepr import saferepr
+from _pytest._version import version
+from _pytest.assertion import util
+from _pytest.assertion.util import (  # noqa: F401
+    format_explanation as _format_explanation,
+)
+from _pytest.config import Config
+from _pytest.main import Session
+from _pytest.pathlib import fnmatch_ex
+from _pytest.store import StoreKey
+
+if TYPE_CHECKING:
+    from _pytest.assertion import AssertionState
+
+
+assertstate_key = StoreKey["AssertionState"]()
+
+
+# pytest caches rewritten pycs in pycache dirs
+PYTEST_TAG = f"{sys.implementation.cache_tag}-pytest-{version}"
+PYC_EXT = ".py" + (__debug__ and "c" or "o")
+PYC_TAIL = "." + PYTEST_TAG + PYC_EXT
+
+
+class AssertionRewritingHook(importlib.abc.MetaPathFinder, importlib.abc.Loader):
+    """PEP302/PEP451 import hook which rewrites asserts."""
+
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        try:
+            self.fnpats = config.getini("python_files")
+        except ValueError:
+            self.fnpats = ["test_*.py", "*_test.py"]
+        self.session: Optional[Session] = None
+        self._rewritten_names: Set[str] = set()
+        self._must_rewrite: Set[str] = set()
+        # flag to guard against trying to rewrite a pyc file while we are already writing another pyc file,
+        # which might result in infinite recursion (#3506)
+        self._writing_pyc = False
+        self._basenames_to_check_rewrite = {"conftest"}
+        self._marked_for_rewrite_cache: Dict[str, bool] = {}
+        self._session_paths_checked = False
+
+    def set_session(self, session: Optional[Session]) -> None:
+        self.session = session
+        self._session_paths_checked = False
+
+    # Indirection so we can mock calls to find_spec originated from the hook during testing
+    _find_spec = importlib.machinery.PathFinder.find_spec
+
+    def find_spec(
+        self,
+        name: str,
+        path: Optional[Sequence[Union[str, bytes]]] = None,
+        target: Optional[types.ModuleType] = None,
+    ) -> Optional[importlib.machinery.ModuleSpec]:
+        if self._writing_pyc:
+            return None
+        state = self.config._store[assertstate_key]
+        if self._early_rewrite_bailout(name, state):
+            return None
+        state.trace("find_module called for: %s" % name)
+
+        # Type ignored because mypy is confused about the `self` binding here.
+        spec = self._find_spec(name, path)  # type: ignore
+        if (
+            # the import machinery could not find a file to import
+            spec is None
+            # this is a namespace package (without `__init__.py`)
+            # there's nothing to rewrite there
+            # python3.6: `namespace`
+            # python3.7+: `None`
+            or spec.origin == "namespace"
+            or spec.origin is None
+            # we can only rewrite source files
+            or not isinstance(spec.loader, importlib.machinery.SourceFileLoader)
+            # if the file doesn't exist, we can't rewrite it
+            or not os.path.exists(spec.origin)
+        ):
+            return None
+        else:
+            fn = spec.origin
+
+        if not self._should_rewrite(name, fn, state):
+            return None
+
+        return importlib.util.spec_from_file_location(
+            name,
+            fn,
+            loader=self,
+            submodule_search_locations=spec.submodule_search_locations,
+        )
+
+    def create_module(
+        self, spec: importlib.machinery.ModuleSpec
+    ) -> Optional[types.ModuleType]:
+        return None  # default behaviour is fine
+
+    def exec_module(self, module: types.ModuleType) -> None:
+        assert module.__spec__ is not None
+        assert module.__spec__.origin is not None
+        fn = Path(module.__spec__.origin)
+        state = self.config._store[assertstate_key]
+
+        self._rewritten_names.add(module.__name__)
+
+        # The requested module looks like a test file, so rewrite it. This is
+        # the most magical part of the process: load the source, rewrite the
+        # asserts, and load the rewritten source. We also cache the rewritten
+        # module code in a special pyc. We must be aware of the possibility of
+        # concurrent pytest processes rewriting and loading pycs. To avoid
+        # tricky race conditions, we maintain the following invariant: The
+        # cached pyc is always a complete, valid pyc. Operations on it must be
+        # atomic. POSIX's atomic rename comes in handy.
+        write = not sys.dont_write_bytecode
+        cache_dir = get_cache_dir(fn)
+        if write:
+            ok = try_makedirs(cache_dir)
+            if not ok:
+                write = False
+                state.trace(f"read only directory: {cache_dir}")
+
+        cache_name = fn.name[:-3] + PYC_TAIL
+        pyc = cache_dir / cache_name
+        # Notice that even if we're in a read-only directory, I'm going
+        # to check for a cached pyc. This may not be optimal...
+        co = _read_pyc(fn, pyc, state.trace)
+        if co is None:
+            state.trace(f"rewriting {fn!r}")
+            source_stat, co = _rewrite_test(fn, self.config)
+            if write:
+                self._writing_pyc = True
+                try:
+                    _write_pyc(state, co, source_stat, pyc)
+                finally:
+                    self._writing_pyc = False
+        else:
+            state.trace(f"found cached rewritten pyc for {fn}")
+        exec(co, module.__dict__)
+
+    def _early_rewrite_bailout(self, name: str, state: "AssertionState") -> bool:
+        """A fast way to get out of rewriting modules.
+
+        Profiling has shown that the call to PathFinder.find_spec (inside of
+        the find_spec from this class) is a major slowdown, so, this method
+        tries to filter what we're sure won't be rewritten before getting to
+        it.
+        """
+        if self.session is not None and not self._session_paths_checked:
+            self._session_paths_checked = True
+            for initial_path in self.session._initialpaths:
+                # Make something as c:/projects/my_project/path.py ->
+                #     ['c:', 'projects', 'my_project', 'path.py']
+                parts = str(initial_path).split(os.path.sep)
+                # add 'path' to basenames to be checked.
+                self._basenames_to_check_rewrite.add(os.path.splitext(parts[-1])[0])
+
+        # Note: conftest already by default in _basenames_to_check_rewrite.
+        parts = name.split(".")
+        if parts[-1] in self._basenames_to_check_rewrite:
+            return False
+
+        # For matching the name it must be as if it was a filename.
+        path = PurePath(os.path.sep.join(parts) + ".py")
+
+        for pat in self.fnpats:
+            # if the pattern contains subdirectories ("tests/**.py" for example) we can't bail out based
+            # on the name alone because we need to match against the full path
+            if os.path.dirname(pat):
+                return False
+            if fnmatch_ex(pat, path):
+                return False
+
+        if self._is_marked_for_rewrite(name, state):
+            return False
+
+        state.trace(f"early skip of rewriting module: {name}")
+        return True
+
+    def _should_rewrite(self, name: str, fn: str, state: "AssertionState") -> bool:
+        # always rewrite conftest files
+        if os.path.basename(fn) == "conftest.py":
+            state.trace(f"rewriting conftest file: {fn!r}")
+            return True
+
+        if self.session is not None:
+            if self.session.isinitpath(py.path.local(fn)):
+                state.trace(f"matched test file (was specified on cmdline): {fn!r}")
+                return True
+
+        # modules not passed explicitly on the command line are only
+        # rewritten if they match the naming convention for test files
+        fn_path = PurePath(fn)
+        for pat in self.fnpats:
+            if fnmatch_ex(pat, fn_path):
+                state.trace(f"matched test file {fn!r}")
+                return True
+
+        return self._is_marked_for_rewrite(name, state)
+
+    def _is_marked_for_rewrite(self, name: str, state: "AssertionState") -> bool:
+        try:
+            return self._marked_for_rewrite_cache[name]
+        except KeyError:
+            for marked in self._must_rewrite:
+                if name == marked or name.startswith(marked + "."):
+                    state.trace(f"matched marked file {name!r} (from {marked!r})")
+                    self._marked_for_rewrite_cache[name] = True
+                    return True
+
+            self._marked_for_rewrite_cache[name] = False
+            return False
+
+    def mark_rewrite(self, *names: str) -> None:
+        """Mark import names as needing to be rewritten.
+
+        The named module or package as well as any nested modules will
+        be rewritten on import.
+        """
+        already_imported = (
+            set(names).intersection(sys.modules).difference(self._rewritten_names)
+        )
+        for name in already_imported:
+            mod = sys.modules[name]
+            if not AssertionRewriter.is_rewrite_disabled(
+                mod.__doc__ or ""
+            ) and not isinstance(mod.__loader__, type(self)):
+                self._warn_already_imported(name)
+        self._must_rewrite.update(names)
+        self._marked_for_rewrite_cache.clear()
+
+    def _warn_already_imported(self, name: str) -> None:
+        from _pytest.warning_types import PytestAssertRewriteWarning
+
+        self.config.issue_config_time_warning(
+            PytestAssertRewriteWarning(
+                "Module already imported so cannot be rewritten: %s" % name
+            ),
+            stacklevel=5,
+        )
+
+    def get_data(self, pathname: Union[str, bytes]) -> bytes:
+        """Optional PEP302 get_data API."""
+        with open(pathname, "rb") as f:
+            return f.read()
+
+
+def _write_pyc_fp(
+    fp: IO[bytes], source_stat: os.stat_result, co: types.CodeType
+) -> None:
+    # Technically, we don't have to have the same pyc format as
+    # (C)Python, since these "pycs" should never be seen by builtin
+    # import. However, there's little reason to deviate.
+    fp.write(importlib.util.MAGIC_NUMBER)
+    # https://www.python.org/dev/peps/pep-0552/
+    if sys.version_info >= (3, 7):
+        flags = b"\x00\x00\x00\x00"
+        fp.write(flags)
+    # as of now, bytecode header expects 32-bit numbers for size and mtime (#4903)
+    mtime = int(source_stat.st_mtime) & 0xFFFFFFFF
+    size = source_stat.st_size & 0xFFFFFFFF
+    # "<LL" stands for 2 unsigned longs, little-endian.
+    fp.write(struct.pack("<LL", mtime, size))
+    fp.write(marshal.dumps(co))
+
+
+if sys.platform == "win32":
+    from atomicwrites import atomic_write
+
+    def _write_pyc(
+        state: "AssertionState",
+        co: types.CodeType,
+        source_stat: os.stat_result,
+        pyc: Path,
+    ) -> bool:
+        try:
+            with atomic_write(os.fspath(pyc), mode="wb", overwrite=True) as fp:
+                _write_pyc_fp(fp, source_stat, co)
+        except OSError as e:
+            state.trace(f"error writing pyc file at {pyc}: {e}")
+            # we ignore any failure to write the cache file
+            # there are many reasons, permission-denied, pycache dir being a
+            # file etc.
+            return False
+        return True
+
+
+else:
+
+    def _write_pyc(
+        state: "AssertionState",
+        co: types.CodeType,
+        source_stat: os.stat_result,
+        pyc: Path,
+    ) -> bool:
+        proc_pyc = f"{pyc}.{os.getpid()}"
+        try:
+            fp = open(proc_pyc, "wb")
+        except OSError as e:
+            state.trace(f"error writing pyc file at {proc_pyc}: errno={e.errno}")
+            return False
+
+        try:
+            _write_pyc_fp(fp, source_stat, co)
+            os.rename(proc_pyc, os.fspath(pyc))
+        except OSError as e:
+            state.trace(f"error writing pyc file at {pyc}: {e}")
+            # we ignore any failure to write the cache file
+            # there are many reasons, permission-denied, pycache dir being a
+            # file etc.
+            return False
+        finally:
+            fp.close()
+        return True
+
+
+def _rewrite_test(fn: Path, config: Config) -> Tuple[os.stat_result, types.CodeType]:
+    """Read and rewrite *fn* and return the code object."""
+    fn_ = os.fspath(fn)
+    stat = os.stat(fn_)
+    with open(fn_, "rb") as f:
+        source = f.read()
+    tree = ast.parse(source, filename=fn_)
+    rewrite_asserts(tree, source, fn_, config)
+    co = compile(tree, fn_, "exec", dont_inherit=True)
+    return stat, co
+
+
+def _read_pyc(
+    source: Path, pyc: Path, trace: Callable[[str], None] = lambda x: None
+) -> Optional[types.CodeType]:
+    """Possibly read a pytest pyc containing rewritten code.
+
+    Return rewritten code if successful or None if not.
+    """
+    try:
+        fp = open(os.fspath(pyc), "rb")
+    except OSError:
+        return None
+    with fp:
+        # https://www.python.org/dev/peps/pep-0552/
+        has_flags = sys.version_info >= (3, 7)
+        try:
+            stat_result = os.stat(os.fspath(source))
+            mtime = int(stat_result.st_mtime)
+            size = stat_result.st_size
+            data = fp.read(16 if has_flags else 12)
+        except OSError as e:
+            trace(f"_read_pyc({source}): OSError {e}")
+            return None
+        # Check for invalid or out of date pyc file.
+        if len(data) != (16 if has_flags else 12):
+            trace("_read_pyc(%s): invalid pyc (too short)" % source)
+            return None
+        if data[:4] != importlib.util.MAGIC_NUMBER:
+            trace("_read_pyc(%s): invalid pyc (bad magic number)" % source)
+            return None
+        if has_flags and data[4:8] != b"\x00\x00\x00\x00":
+            trace("_read_pyc(%s): invalid pyc (unsupported flags)" % source)
+            return None
+        mtime_data = data[8 if has_flags else 4 : 12 if has_flags else 8]
+        if int.from_bytes(mtime_data, "little") != mtime & 0xFFFFFFFF:
+            trace("_read_pyc(%s): out of date" % source)
+            return None
+        size_data = data[12 if has_flags else 8 : 16 if has_flags else 12]
+        if int.from_bytes(size_data, "little") != size & 0xFFFFFFFF:
+            trace("_read_pyc(%s): invalid pyc (incorrect size)" % source)
+            return None
+        try:
+            co = marshal.load(fp)
+        except Exception as e:
+            trace(f"_read_pyc({source}): marshal.load error {e}")
+            return None
+        if not isinstance(co, types.CodeType):
+            trace("_read_pyc(%s): not a code object" % source)
+            return None
+        return co
+
+
+def rewrite_asserts(
+    mod: ast.Module,
+    source: bytes,
+    module_path: Optional[str] = None,
+    config: Optional[Config] = None,
+) -> None:
+    """Rewrite the assert statements in mod."""
+    AssertionRewriter(module_path, config, source).run(mod)
+
+
+def _saferepr(obj: object) -> str:
+    r"""Get a safe repr of an object for assertion error messages.
+
+    The assertion formatting (util.format_explanation()) requires
+    newlines to be escaped since they are a special character for it.
+    Normally assertion.util.format_explanation() does this but for a
+    custom repr it is possible to contain one of the special escape
+    sequences, especially '\n{' and '\n}' are likely to be present in
+    JSON reprs.
+    """
+    return saferepr(obj).replace("\n", "\\n")
+
+
+def _format_assertmsg(obj: object) -> str:
+    r"""Format the custom assertion message given.
+
+    For strings this simply replaces newlines with '\n~' so that
+    util.format_explanation() will preserve them instead of escaping
+    newlines.  For other objects saferepr() is used first.
+    """
+    # reprlib appears to have a bug which means that if a string
+    # contains a newline it gets escaped, however if an object has a
+    # .__repr__() which contains newlines it does not get escaped.
+    # However in either case we want to preserve the newline.
+    replaces = [("\n", "\n~"), ("%", "%%")]
+    if not isinstance(obj, str):
+        obj = saferepr(obj)
+        replaces.append(("\\n", "\n~"))
+
+    for r1, r2 in replaces:
+        obj = obj.replace(r1, r2)
+
+    return obj
+
+
+def _should_repr_global_name(obj: object) -> bool:
+    if callable(obj):
+        return False
+
+    try:
+        return not hasattr(obj, "__name__")
+    except Exception:
+        return True
+
+
+def _format_boolop(explanations: Iterable[str], is_or: bool) -> str:
+    explanation = "(" + (is_or and " or " or " and ").join(explanations) + ")"
+    return explanation.replace("%", "%%")
+
+
+def _call_reprcompare(
+    ops: Sequence[str],
+    results: Sequence[bool],
+    expls: Sequence[str],
+    each_obj: Sequence[object],
+) -> str:
+    for i, res, expl in zip(range(len(ops)), results, expls):
+        try:
+            done = not res
+        except Exception:
+            done = True
+        if done:
+            break
+    if util._reprcompare is not None:
+        custom = util._reprcompare(ops[i], each_obj[i], each_obj[i + 1])
+        if custom is not None:
+            return custom
+    return expl
+
+
+def _call_assertion_pass(lineno: int, orig: str, expl: str) -> None:
+    if util._assertion_pass is not None:
+        util._assertion_pass(lineno, orig, expl)
+
+
+def _check_if_assertion_pass_impl() -> bool:
+    """Check if any plugins implement the pytest_assertion_pass hook
+    in order not to generate explanation unecessarily (might be expensive)."""
+    return True if util._assertion_pass else False
+
+
+UNARY_MAP = {ast.Not: "not %s", ast.Invert: "~%s", ast.USub: "-%s", ast.UAdd: "+%s"}
+
+BINOP_MAP = {
+    ast.BitOr: "|",
+    ast.BitXor: "^",
+    ast.BitAnd: "&",
+    ast.LShift: "<<",
+    ast.RShift: ">>",
+    ast.Add: "+",
+    ast.Sub: "-",
+    ast.Mult: "*",
+    ast.Div: "/",
+    ast.FloorDiv: "//",
+    ast.Mod: "%%",  # escaped for string formatting
+    ast.Eq: "==",
+    ast.NotEq: "!=",
+    ast.Lt: "<",
+    ast.LtE: "<=",
+    ast.Gt: ">",
+    ast.GtE: ">=",
+    ast.Pow: "**",
+    ast.Is: "is",
+    ast.IsNot: "is not",
+    ast.In: "in",
+    ast.NotIn: "not in",
+    ast.MatMult: "@",
+}
+
+
+def set_location(node, lineno, col_offset):
+    """Set node location information recursively."""
+
+    def _fix(node, lineno, col_offset):
+        if "lineno" in node._attributes:
+            node.lineno = lineno
+        if "col_offset" in node._attributes:
+            node.col_offset = col_offset
+        for child in ast.iter_child_nodes(node):
+            _fix(child, lineno, col_offset)
+
+    _fix(node, lineno, col_offset)
+    return node
+
+
+def _get_assertion_exprs(src: bytes) -> Dict[int, str]:
+    """Return a mapping from {lineno: "assertion test expression"}."""
+    ret: Dict[int, str] = {}
+
+    depth = 0
+    lines: List[str] = []
+    assert_lineno: Optional[int] = None
+    seen_lines: Set[int] = set()
+
+    def _write_and_reset() -> None:
+        nonlocal depth, lines, assert_lineno, seen_lines
+        assert assert_lineno is not None
+        ret[assert_lineno] = "".join(lines).rstrip().rstrip("\\")
+        depth = 0
+        lines = []
+        assert_lineno = None
+        seen_lines = set()
+
+    tokens = tokenize.tokenize(io.BytesIO(src).readline)
+    for tp, source, (lineno, offset), _, line in tokens:
+        if tp == tokenize.NAME and source == "assert":
+            assert_lineno = lineno
+        elif assert_lineno is not None:
+            # keep track of depth for the assert-message `,` lookup
+            if tp == tokenize.OP and source in "([{":
+                depth += 1
+            elif tp == tokenize.OP and source in ")]}":
+                depth -= 1
+
+            if not lines:
+                lines.append(line[offset:])
+                seen_lines.add(lineno)
+            # a non-nested comma separates the expression from the message
+            elif depth == 0 and tp == tokenize.OP and source == ",":
+                # one line assert with message
+                if lineno in seen_lines and len(lines) == 1:
+                    offset_in_trimmed = offset + len(lines[-1]) - len(line)
+                    lines[-1] = lines[-1][:offset_in_trimmed]
+                # multi-line assert with message
+                elif lineno in seen_lines:
+                    lines[-1] = lines[-1][:offset]
+                # multi line assert with escapd newline before message
+                else:
+                    lines.append(line[:offset])
+                _write_and_reset()
+            elif tp in {tokenize.NEWLINE, tokenize.ENDMARKER}:
+                _write_and_reset()
+            elif lines and lineno not in seen_lines:
+                lines.append(line)
+                seen_lines.add(lineno)
+
+    return ret
+
+
+class AssertionRewriter(ast.NodeVisitor):
+    """Assertion rewriting implementation.
+
+    The main entrypoint is to call .run() with an ast.Module instance,
+    this will then find all the assert statements and rewrite them to
+    provide intermediate values and a detailed assertion error.  See
+    http://pybites.blogspot.be/2011/07/behind-scenes-of-pytests-new-assertion.html
+    for an overview of how this works.
+
+    The entry point here is .run() which will iterate over all the
+    statements in an ast.Module and for each ast.Assert statement it
+    finds call .visit() with it.  Then .visit_Assert() takes over and
+    is responsible for creating new ast statements to replace the
+    original assert statement: it rewrites the test of an assertion
+    to provide intermediate values and replace it with an if statement
+    which raises an assertion error with a detailed explanation in
+    case the expression is false and calls pytest_assertion_pass hook
+    if expression is true.
+
+    For this .visit_Assert() uses the visitor pattern to visit all the
+    AST nodes of the ast.Assert.test field, each visit call returning
+    an AST node and the corresponding explanation string.  During this
+    state is kept in several instance attributes:
+
+    :statements: All the AST statements which will replace the assert
+       statement.
+
+    :variables: This is populated by .variable() with each variable
+       used by the statements so that they can all be set to None at
+       the end of the statements.
+
+    :variable_counter: Counter to create new unique variables needed
+       by statements.  Variables are created using .variable() and
+       have the form of "@py_assert0".
+
+    :expl_stmts: The AST statements which will be executed to get
+       data from the assertion.  This is the code which will construct
+       the detailed assertion message that is used in the AssertionError
+       or for the pytest_assertion_pass hook.
+
+    :explanation_specifiers: A dict filled by .explanation_param()
+       with %-formatting placeholders and their corresponding
+       expressions to use in the building of an assertion message.
+       This is used by .pop_format_context() to build a message.
+
+    :stack: A stack of the explanation_specifiers dicts maintained by
+       .push_format_context() and .pop_format_context() which allows
+       to build another %-formatted string while already building one.
+
+    This state is reset on every new assert statement visited and used
+    by the other visitors.
+    """
+
+    def __init__(
+        self, module_path: Optional[str], config: Optional[Config], source: bytes
+    ) -> None:
+        super().__init__()
+        self.module_path = module_path
+        self.config = config
+        if config is not None:
+            self.enable_assertion_pass_hook = config.getini(
+                "enable_assertion_pass_hook"
+            )
+        else:
+            self.enable_assertion_pass_hook = False
+        self.source = source
+
+    @functools.lru_cache(maxsize=1)
+    def _assert_expr_to_lineno(self) -> Dict[int, str]:
+        return _get_assertion_exprs(self.source)
+
+    def run(self, mod: ast.Module) -> None:
+        """Find all assert statements in *mod* and rewrite them."""
+        if not mod.body:
+            # Nothing to do.
+            return
+
+        # We'll insert some special imports at the top of the module, but after any
+        # docstrings and __future__ imports, so first figure out where that is.
+        doc = getattr(mod, "docstring", None)
+        expect_docstring = doc is None
+        if doc is not None and self.is_rewrite_disabled(doc):
+            return
+        pos = 0
+        lineno = 1
+        for item in mod.body:
+            if (
+                expect_docstring
+                and isinstance(item, ast.Expr)
+                and isinstance(item.value, ast.Str)
+            ):
+                doc = item.value.s
+                if self.is_rewrite_disabled(doc):
+                    return
+                expect_docstring = False
+            elif (
+                isinstance(item, ast.ImportFrom)
+                and item.level == 0
+                and item.module == "__future__"
+            ):
+                pass
+            else:
+                break
+            pos += 1
+        # Special case: for a decorated function, set the lineno to that of the
+        # first decorator, not the `def`. Issue #4984.
+        if isinstance(item, ast.FunctionDef) and item.decorator_list:
+            lineno = item.decorator_list[0].lineno
+        else:
+            lineno = item.lineno
+        # Now actually insert the special imports.
+        if sys.version_info >= (3, 10):
+            aliases = [
+                ast.alias("builtins", "@py_builtins", lineno=lineno, col_offset=0),
+                ast.alias(
+                    "_pytest.assertion.rewrite",
+                    "@pytest_ar",
+                    lineno=lineno,
+                    col_offset=0,
+                ),
+            ]
+        else:
+            aliases = [
+                ast.alias("builtins", "@py_builtins"),
+                ast.alias("_pytest.assertion.rewrite", "@pytest_ar"),
+            ]
+        imports = [
+            ast.Import([alias], lineno=lineno, col_offset=0) for alias in aliases
+        ]
+        mod.body[pos:pos] = imports
+
+        # Collect asserts.
+        nodes: List[ast.AST] = [mod]
+        while nodes:
+            node = nodes.pop()
+            for name, field in ast.iter_fields(node):
+                if isinstance(field, list):
+                    new: List[ast.AST] = []
+                    for i, child in enumerate(field):
+                        if isinstance(child, ast.Assert):
+                            # Transform assert.
+                            new.extend(self.visit(child))
+                        else:
+                            new.append(child)
+                            if isinstance(child, ast.AST):
+                                nodes.append(child)
+                    setattr(node, name, new)
+                elif (
+                    isinstance(field, ast.AST)
+                    # Don't recurse into expressions as they can't contain
+                    # asserts.
+                    and not isinstance(field, ast.expr)
+                ):
+                    nodes.append(field)
+
+    @staticmethod
+    def is_rewrite_disabled(docstring: str) -> bool:
+        return "PYTEST_DONT_REWRITE" in docstring
+
+    def variable(self) -> str:
+        """Get a new variable."""
+        # Use a character invalid in python identifiers to avoid clashing.
+        name = "@py_assert" + str(next(self.variable_counter))
+        self.variables.append(name)
+        return name
+
+    def assign(self, expr: ast.expr) -> ast.Name:
+        """Give *expr* a name."""
+        name = self.variable()
+        self.statements.append(ast.Assign([ast.Name(name, ast.Store())], expr))
+        return ast.Name(name, ast.Load())
+
+    def display(self, expr: ast.expr) -> ast.expr:
+        """Call saferepr on the expression."""
+        return self.helper("_saferepr", expr)
+
+    def helper(self, name: str, *args: ast.expr) -> ast.expr:
+        """Call a helper in this module."""
+        py_name = ast.Name("@pytest_ar", ast.Load())
+        attr = ast.Attribute(py_name, name, ast.Load())
+        return ast.Call(attr, list(args), [])
+
+    def builtin(self, name: str) -> ast.Attribute:
+        """Return the builtin called *name*."""
+        builtin_name = ast.Name("@py_builtins", ast.Load())
+        return ast.Attribute(builtin_name, name, ast.Load())
+
+    def explanation_param(self, expr: ast.expr) -> str:
+        """Return a new named %-formatting placeholder for expr.
+
+        This creates a %-formatting placeholder for expr in the
+        current formatting context, e.g. ``%(py0)s``.  The placeholder
+        and expr are placed in the current format context so that it
+        can be used on the next call to .pop_format_context().
+        """
+        specifier = "py" + str(next(self.variable_counter))
+        self.explanation_specifiers[specifier] = expr
+        return "%(" + specifier + ")s"
+
+    def push_format_context(self) -> None:
+        """Create a new formatting context.
+
+        The format context is used for when an explanation wants to
+        have a variable value formatted in the assertion message.  In
+        this case the value required can be added using
+        .explanation_param().  Finally .pop_format_context() is used
+        to format a string of %-formatted values as added by
+        .explanation_param().
+        """
+        self.explanation_specifiers: Dict[str, ast.expr] = {}
+        self.stack.append(self.explanation_specifiers)
+
+    def pop_format_context(self, expl_expr: ast.expr) -> ast.Name:
+        """Format the %-formatted string with current format context.
+
+        The expl_expr should be an str ast.expr instance constructed from
+        the %-placeholders created by .explanation_param().  This will
+        add the required code to format said string to .expl_stmts and
+        return the ast.Name instance of the formatted string.
+        """
+        current = self.stack.pop()
+        if self.stack:
+            self.explanation_specifiers = self.stack[-1]
+        keys = [ast.Str(key) for key in current.keys()]
+        format_dict = ast.Dict(keys, list(current.values()))
+        form = ast.BinOp(expl_expr, ast.Mod(), format_dict)
+        name = "@py_format" + str(next(self.variable_counter))
+        if self.enable_assertion_pass_hook:
+            self.format_variables.append(name)
+        self.expl_stmts.append(ast.Assign([ast.Name(name, ast.Store())], form))
+        return ast.Name(name, ast.Load())
+
+    def generic_visit(self, node: ast.AST) -> Tuple[ast.Name, str]:
+        """Handle expressions we don't have custom code for."""
+        assert isinstance(node, ast.expr)
+        res = self.assign(node)
+        return res, self.explanation_param(self.display(res))
+
+    def visit_Assert(self, assert_: ast.Assert) -> List[ast.stmt]:
+        """Return the AST statements to replace the ast.Assert instance.
+
+        This rewrites the test of an assertion to provide
+        intermediate values and replace it with an if statement which
+        raises an assertion error with a detailed explanation in case
+        the expression is false.
+        """
+        if isinstance(assert_.test, ast.Tuple) and len(assert_.test.elts) >= 1:
+            from _pytest.warning_types import PytestAssertRewriteWarning
+            import warnings
+
+            # TODO: This assert should not be needed.
+            assert self.module_path is not None
+            warnings.warn_explicit(
+                PytestAssertRewriteWarning(
+                    "assertion is always true, perhaps remove parentheses?"
+                ),
+                category=None,
+                filename=os.fspath(self.module_path),
+                lineno=assert_.lineno,
+            )
+
+        self.statements: List[ast.stmt] = []
+        self.variables: List[str] = []
+        self.variable_counter = itertools.count()
+
+        if self.enable_assertion_pass_hook:
+            self.format_variables: List[str] = []
+
+        self.stack: List[Dict[str, ast.expr]] = []
+        self.expl_stmts: List[ast.stmt] = []
+        self.push_format_context()
+        # Rewrite assert into a bunch of statements.
+        top_condition, explanation = self.visit(assert_.test)
+
+        negation = ast.UnaryOp(ast.Not(), top_condition)
+
+        if self.enable_assertion_pass_hook:  # Experimental pytest_assertion_pass hook
+            msg = self.pop_format_context(ast.Str(explanation))
+
+            # Failed
+            if assert_.msg:
+                assertmsg = self.helper("_format_assertmsg", assert_.msg)
+                gluestr = "\n>assert "
+            else:
+                assertmsg = ast.Str("")
+                gluestr = "assert "
+            err_explanation = ast.BinOp(ast.Str(gluestr), ast.Add(), msg)
+            err_msg = ast.BinOp(assertmsg, ast.Add(), err_explanation)
+            err_name = ast.Name("AssertionError", ast.Load())
+            fmt = self.helper("_format_explanation", err_msg)
+            exc = ast.Call(err_name, [fmt], [])
+            raise_ = ast.Raise(exc, None)
+            statements_fail = []
+            statements_fail.extend(self.expl_stmts)
+            statements_fail.append(raise_)
+
+            # Passed
+            fmt_pass = self.helper("_format_explanation", msg)
+            orig = self._assert_expr_to_lineno()[assert_.lineno]
+            hook_call_pass = ast.Expr(
+                self.helper(
+                    "_call_assertion_pass",
+                    ast.Num(assert_.lineno),
+                    ast.Str(orig),
+                    fmt_pass,
+                )
+            )
+            # If any hooks implement assert_pass hook
+            hook_impl_test = ast.If(
+                self.helper("_check_if_assertion_pass_impl"),
+                self.expl_stmts + [hook_call_pass],
+                [],
+            )
+            statements_pass = [hook_impl_test]
+
+            # Test for assertion condition
+            main_test = ast.If(negation, statements_fail, statements_pass)
+            self.statements.append(main_test)
+            if self.format_variables:
+                variables = [
+                    ast.Name(name, ast.Store()) for name in self.format_variables
+                ]
+                clear_format = ast.Assign(variables, ast.NameConstant(None))
+                self.statements.append(clear_format)
+
+        else:  # Original assertion rewriting
+            # Create failure message.
+            body = self.expl_stmts
+            self.statements.append(ast.If(negation, body, []))
+            if assert_.msg:
+                assertmsg = self.helper("_format_assertmsg", assert_.msg)
+                explanation = "\n>assert " + explanation
+            else:
+                assertmsg = ast.Str("")
+                explanation = "assert " + explanation
+            template = ast.BinOp(assertmsg, ast.Add(), ast.Str(explanation))
+            msg = self.pop_format_context(template)
+            fmt = self.helper("_format_explanation", msg)
+            err_name = ast.Name("AssertionError", ast.Load())
+            exc = ast.Call(err_name, [fmt], [])
+            raise_ = ast.Raise(exc, None)
+
+            body.append(raise_)
+
+        # Clear temporary variables by setting them to None.
+        if self.variables:
+            variables = [ast.Name(name, ast.Store()) for name in self.variables]
+            clear = ast.Assign(variables, ast.NameConstant(None))
+            self.statements.append(clear)
+        # Fix line numbers.
+        for stmt in self.statements:
+            set_location(stmt, assert_.lineno, assert_.col_offset)
+        return self.statements
+
+    def visit_Name(self, name: ast.Name) -> Tuple[ast.Name, str]:
+        # Display the repr of the name if it's a local variable or
+        # _should_repr_global_name() thinks it's acceptable.
+        locs = ast.Call(self.builtin("locals"), [], [])
+        inlocs = ast.Compare(ast.Str(name.id), [ast.In()], [locs])
+        dorepr = self.helper("_should_repr_global_name", name)
+        test = ast.BoolOp(ast.Or(), [inlocs, dorepr])
+        expr = ast.IfExp(test, self.display(name), ast.Str(name.id))
+        return name, self.explanation_param(expr)
+
+    def visit_BoolOp(self, boolop: ast.BoolOp) -> Tuple[ast.Name, str]:
+        res_var = self.variable()
+        expl_list = self.assign(ast.List([], ast.Load()))
+        app = ast.Attribute(expl_list, "append", ast.Load())
+        is_or = int(isinstance(boolop.op, ast.Or))
+        body = save = self.statements
+        fail_save = self.expl_stmts
+        levels = len(boolop.values) - 1
+        self.push_format_context()
+        # Process each operand, short-circuiting if needed.
+        for i, v in enumerate(boolop.values):
+            if i:
+                fail_inner: List[ast.stmt] = []
+                # cond is set in a prior loop iteration below
+                self.expl_stmts.append(ast.If(cond, fail_inner, []))  # noqa
+                self.expl_stmts = fail_inner
+            self.push_format_context()
+            res, expl = self.visit(v)
+            body.append(ast.Assign([ast.Name(res_var, ast.Store())], res))
+            expl_format = self.pop_format_context(ast.Str(expl))
+            call = ast.Call(app, [expl_format], [])
+            self.expl_stmts.append(ast.Expr(call))
+            if i < levels:
+                cond: ast.expr = res
+                if is_or:
+                    cond = ast.UnaryOp(ast.Not(), cond)
+                inner: List[ast.stmt] = []
+                self.statements.append(ast.If(cond, inner, []))
+                self.statements = body = inner
+        self.statements = save
+        self.expl_stmts = fail_save
+        expl_template = self.helper("_format_boolop", expl_list, ast.Num(is_or))
+        expl = self.pop_format_context(expl_template)
+        return ast.Name(res_var, ast.Load()), self.explanation_param(expl)
+
+    def visit_UnaryOp(self, unary: ast.UnaryOp) -> Tuple[ast.Name, str]:
+        pattern = UNARY_MAP[unary.op.__class__]
+        operand_res, operand_expl = self.visit(unary.operand)
+        res = self.assign(ast.UnaryOp(unary.op, operand_res))
+        return res, pattern % (operand_expl,)
+
+    def visit_BinOp(self, binop: ast.BinOp) -> Tuple[ast.Name, str]:
+        symbol = BINOP_MAP[binop.op.__class__]
+        left_expr, left_expl = self.visit(binop.left)
+        right_expr, right_expl = self.visit(binop.right)
+        explanation = f"({left_expl} {symbol} {right_expl})"
+        res = self.assign(ast.BinOp(left_expr, binop.op, right_expr))
+        return res, explanation
+
+    def visit_Call(self, call: ast.Call) -> Tuple[ast.Name, str]:
+        new_func, func_expl = self.visit(call.func)
+        arg_expls = []
+        new_args = []
+        new_kwargs = []
+        for arg in call.args:
+            res, expl = self.visit(arg)
+            arg_expls.append(expl)
+            new_args.append(res)
+        for keyword in call.keywords:
+            res, expl = self.visit(keyword.value)
+            new_kwargs.append(ast.keyword(keyword.arg, res))
+            if keyword.arg:
+                arg_expls.append(keyword.arg + "=" + expl)
+            else:  # **args have `arg` keywords with an .arg of None
+                arg_expls.append("**" + expl)
+
+        expl = "{}({})".format(func_expl, ", ".join(arg_expls))
+        new_call = ast.Call(new_func, new_args, new_kwargs)
+        res = self.assign(new_call)
+        res_expl = self.explanation_param(self.display(res))
+        outer_expl = f"{res_expl}\n{{{res_expl} = {expl}\n}}"
+        return res, outer_expl
+
+    def visit_Starred(self, starred: ast.Starred) -> Tuple[ast.Starred, str]:
+        # A Starred node can appear in a function call.
+        res, expl = self.visit(starred.value)
+        new_starred = ast.Starred(res, starred.ctx)
+        return new_starred, "*" + expl
+
+    def visit_Attribute(self, attr: ast.Attribute) -> Tuple[ast.Name, str]:
+        if not isinstance(attr.ctx, ast.Load):
+            return self.generic_visit(attr)
+        value, value_expl = self.visit(attr.value)
+        res = self.assign(ast.Attribute(value, attr.attr, ast.Load()))
+        res_expl = self.explanation_param(self.display(res))
+        pat = "%s\n{%s = %s.%s\n}"
+        expl = pat % (res_expl, res_expl, value_expl, attr.attr)
+        return res, expl
+
+    def visit_Compare(self, comp: ast.Compare) -> Tuple[ast.expr, str]:
+        self.push_format_context()
+        left_res, left_expl = self.visit(comp.left)
+        if isinstance(comp.left, (ast.Compare, ast.BoolOp)):
+            left_expl = f"({left_expl})"
+        res_variables = [self.variable() for i in range(len(comp.ops))]
+        load_names = [ast.Name(v, ast.Load()) for v in res_variables]
+        store_names = [ast.Name(v, ast.Store()) for v in res_variables]
+        it = zip(range(len(comp.ops)), comp.ops, comp.comparators)
+        expls = []
+        syms = []
+        results = [left_res]
+        for i, op, next_operand in it:
+            next_res, next_expl = self.visit(next_operand)
+            if isinstance(next_operand, (ast.Compare, ast.BoolOp)):
+                next_expl = f"({next_expl})"
+            results.append(next_res)
+            sym = BINOP_MAP[op.__class__]
+            syms.append(ast.Str(sym))
+            expl = f"{left_expl} {sym} {next_expl}"
+            expls.append(ast.Str(expl))
+            res_expr = ast.Compare(left_res, [op], [next_res])
+            self.statements.append(ast.Assign([store_names[i]], res_expr))
+            left_res, left_expl = next_res, next_expl
+        # Use pytest.assertion.util._reprcompare if that's available.
+        expl_call = self.helper(
+            "_call_reprcompare",
+            ast.Tuple(syms, ast.Load()),
+            ast.Tuple(load_names, ast.Load()),
+            ast.Tuple(expls, ast.Load()),
+            ast.Tuple(results, ast.Load()),
+        )
+        if len(comp.ops) > 1:
+            res: ast.expr = ast.BoolOp(ast.And(), load_names)
+        else:
+            res = load_names[0]
+        return res, self.explanation_param(self.pop_format_context(expl_call))
+
+
+def try_makedirs(cache_dir: Path) -> bool:
+    """Attempt to create the given directory and sub-directories exist.
+
+    Returns True if successful or if it already exists.
+    """
+    try:
+        os.makedirs(os.fspath(cache_dir), exist_ok=True)
+    except (FileNotFoundError, NotADirectoryError, FileExistsError):
+        # One of the path components was not a directory:
+        # - we're in a zip file
+        # - it is a file
+        return False
+    except PermissionError:
+        return False
+    except OSError as e:
+        # as of now, EROFS doesn't have an equivalent OSError-subclass
+        if e.errno == errno.EROFS:
+            return False
+        raise
+    return True
+
+
+def get_cache_dir(file_path: Path) -> Path:
+    """Return the cache directory to write .pyc files for the given .py file path."""
+    if sys.version_info >= (3, 8) and sys.pycache_prefix:
+        # given:
+        #   prefix = '/tmp/pycs'
+        #   path = '/home/user/proj/test_app.py'
+        # we want:
+        #   '/tmp/pycs/home/user/proj'
+        return Path(sys.pycache_prefix) / Path(*file_path.parts[1:-1])
+    else:
+        # classic pycache directory
+        return file_path.parent / "__pycache__"
diff --git a/myenv/lib/python3.9/site-packages/_pytest/assertion/truncate.py b/myenv/lib/python3.9/site-packages/_pytest/assertion/truncate.py
new file mode 100644
index 0000000..5ba9ddc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/assertion/truncate.py
@@ -0,0 +1,100 @@
+"""Utilities for truncating assertion output.
+
+Current default behaviour is to truncate assertion explanations at
+~8 terminal lines, unless running in "-vv" mode or running on CI.
+"""
+import os
+from typing import List
+from typing import Optional
+
+from _pytest.nodes import Item
+
+
+DEFAULT_MAX_LINES = 8
+DEFAULT_MAX_CHARS = 8 * 80
+USAGE_MSG = "use '-vv' to show"
+
+
+def truncate_if_required(
+    explanation: List[str], item: Item, max_length: Optional[int] = None
+) -> List[str]:
+    """Truncate this assertion explanation if the given test item is eligible."""
+    if _should_truncate_item(item):
+        return _truncate_explanation(explanation)
+    return explanation
+
+
+def _should_truncate_item(item: Item) -> bool:
+    """Whether or not this test item is eligible for truncation."""
+    verbose = item.config.option.verbose
+    return verbose < 2 and not _running_on_ci()
+
+
+def _running_on_ci() -> bool:
+    """Check if we're currently running on a CI system."""
+    env_vars = ["CI", "BUILD_NUMBER"]
+    return any(var in os.environ for var in env_vars)
+
+
+def _truncate_explanation(
+    input_lines: List[str],
+    max_lines: Optional[int] = None,
+    max_chars: Optional[int] = None,
+) -> List[str]:
+    """Truncate given list of strings that makes up the assertion explanation.
+
+    Truncates to either 8 lines, or 640 characters - whichever the input reaches
+    first. The remaining lines will be replaced by a usage message.
+    """
+
+    if max_lines is None:
+        max_lines = DEFAULT_MAX_LINES
+    if max_chars is None:
+        max_chars = DEFAULT_MAX_CHARS
+
+    # Check if truncation required
+    input_char_count = len("".join(input_lines))
+    if len(input_lines) <= max_lines and input_char_count <= max_chars:
+        return input_lines
+
+    # Truncate first to max_lines, and then truncate to max_chars if max_chars
+    # is exceeded.
+    truncated_explanation = input_lines[:max_lines]
+    truncated_explanation = _truncate_by_char_count(truncated_explanation, max_chars)
+
+    # Add ellipsis to final line
+    truncated_explanation[-1] = truncated_explanation[-1] + "..."
+
+    # Append useful message to explanation
+    truncated_line_count = len(input_lines) - len(truncated_explanation)
+    truncated_line_count += 1  # Account for the part-truncated final line
+    msg = "...Full output truncated"
+    if truncated_line_count == 1:
+        msg += f" ({truncated_line_count} line hidden)"
+    else:
+        msg += f" ({truncated_line_count} lines hidden)"
+    msg += f", {USAGE_MSG}"
+    truncated_explanation.extend(["", str(msg)])
+    return truncated_explanation
+
+
+def _truncate_by_char_count(input_lines: List[str], max_chars: int) -> List[str]:
+    # Check if truncation required
+    if len("".join(input_lines)) <= max_chars:
+        return input_lines
+
+    # Find point at which input length exceeds total allowed length
+    iterated_char_count = 0
+    for iterated_index, input_line in enumerate(input_lines):
+        if iterated_char_count + len(input_line) > max_chars:
+            break
+        iterated_char_count += len(input_line)
+
+    # Create truncated explanation with modified final line
+    truncated_result = input_lines[:iterated_index]
+    final_line = input_lines[iterated_index]
+    if final_line:
+        final_line_truncate_point = max_chars - iterated_char_count
+        final_line = final_line[:final_line_truncate_point]
+    truncated_result.append(final_line)
+    return truncated_result
diff --git a/myenv/lib/python3.9/site-packages/_pytest/assertion/util.py b/myenv/lib/python3.9/site-packages/_pytest/assertion/util.py
new file mode 100644
index 0000000..da1ffd1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/assertion/util.py
@@ -0,0 +1,477 @@
+"""Utilities for assertion debugging."""
+import collections.abc
+import pprint
+from typing import AbstractSet
+from typing import Any
+from typing import Callable
+from typing import Iterable
+from typing import List
+from typing import Mapping
+from typing import Optional
+from typing import Sequence
+
+import _pytest._code
+from _pytest import outcomes
+from _pytest._io.saferepr import _pformat_dispatch
+from _pytest._io.saferepr import safeformat
+from _pytest._io.saferepr import saferepr
+
+# The _reprcompare attribute on the util module is used by the new assertion
+# interpretation code and assertion rewriter to detect this plugin was
+# loaded and in turn call the hooks defined here as part of the
+# DebugInterpreter.
+_reprcompare: Optional[Callable[[str, object, object], Optional[str]]] = None
+
+# Works similarly as _reprcompare attribute. Is populated with the hook call
+# when pytest_runtest_setup is called.
+_assertion_pass: Optional[Callable[[int, str, str], None]] = None
+
+
+def format_explanation(explanation: str) -> str:
+    r"""Format an explanation.
+
+    Normally all embedded newlines are escaped, however there are
+    three exceptions: \n{, \n} and \n~.  The first two are intended
+    cover nested explanations, see function and attribute explanations
+    for examples (.visit_Call(), visit_Attribute()).  The last one is
+    for when one explanation needs to span multiple lines, e.g. when
+    displaying diffs.
+    """
+    lines = _split_explanation(explanation)
+    result = _format_lines(lines)
+    return "\n".join(result)
+
+
+def _split_explanation(explanation: str) -> List[str]:
+    r"""Return a list of individual lines in the explanation.
+
+    This will return a list of lines split on '\n{', '\n}' and '\n~'.
+    Any other newlines will be escaped and appear in the line as the
+    literal '\n' characters.
+    """
+    raw_lines = (explanation or "").split("\n")
+    lines = [raw_lines[0]]
+    for values in raw_lines[1:]:
+        if values and values[0] in ["{", "}", "~", ">"]:
+            lines.append(values)
+        else:
+            lines[-1] += "\\n" + values
+    return lines
+
+
+def _format_lines(lines: Sequence[str]) -> List[str]:
+    """Format the individual lines.
+
+    This will replace the '{', '}' and '~' characters of our mini formatting
+    language with the proper 'where ...', 'and ...' and ' + ...' text, taking
+    care of indentation along the way.
+
+    Return a list of formatted lines.
+    """
+    result = list(lines[:1])
+    stack = [0]
+    stackcnt = [0]
+    for line in lines[1:]:
+        if line.startswith("{"):
+            if stackcnt[-1]:
+                s = "and   "
+            else:
+                s = "where "
+            stack.append(len(result))
+            stackcnt[-1] += 1
+            stackcnt.append(0)
+            result.append(" +" + "  " * (len(stack) - 1) + s + line[1:])
+        elif line.startswith("}"):
+            stack.pop()
+            stackcnt.pop()
+            result[stack[-1]] += line[1:]
+        else:
+            assert line[0] in ["~", ">"]
+            stack[-1] += 1
+            indent = len(stack) if line.startswith("~") else len(stack) - 1
+            result.append("  " * indent + line[1:])
+    assert len(stack) == 1
+    return result
+
+
+def issequence(x: Any) -> bool:
+    return isinstance(x, collections.abc.Sequence) and not isinstance(x, str)
+
+
+def istext(x: Any) -> bool:
+    return isinstance(x, str)
+
+
+def isdict(x: Any) -> bool:
+    return isinstance(x, dict)
+
+
+def isset(x: Any) -> bool:
+    return isinstance(x, (set, frozenset))
+
+
+def isnamedtuple(obj: Any) -> bool:
+    return isinstance(obj, tuple) and getattr(obj, "_fields", None) is not None
+
+
+def isdatacls(obj: Any) -> bool:
+    return getattr(obj, "__dataclass_fields__", None) is not None
+
+
+def isattrs(obj: Any) -> bool:
+    return getattr(obj, "__attrs_attrs__", None) is not None
+
+
+def isiterable(obj: Any) -> bool:
+    try:
+        iter(obj)
+        return not istext(obj)
+    except TypeError:
+        return False
+
+
+def assertrepr_compare(config, op: str, left: Any, right: Any) -> Optional[List[str]]:
+    """Return specialised explanations for some operators/operands."""
+    verbose = config.getoption("verbose")
+    if verbose > 1:
+        left_repr = safeformat(left)
+        right_repr = safeformat(right)
+    else:
+        # XXX: "15 chars indentation" is wrong
+        #      ("E       AssertionError: assert "); should use term width.
+        maxsize = (
+            80 - 15 - len(op) - 2
+        ) // 2  # 15 chars indentation, 1 space around op
+        left_repr = saferepr(left, maxsize=maxsize)
+        right_repr = saferepr(right, maxsize=maxsize)
+
+    summary = f"{left_repr} {op} {right_repr}"
+
+    explanation = None
+    try:
+        if op == "==":
+            explanation = _compare_eq_any(left, right, verbose)
+        elif op == "not in":
+            if istext(left) and istext(right):
+                explanation = _notin_text(left, right, verbose)
+    except outcomes.Exit:
+        raise
+    except Exception:
+        explanation = [
+            "(pytest_assertion plugin: representation of details failed: {}.".format(
+                _pytest._code.ExceptionInfo.from_current()._getreprcrash()
+            ),
+            " Probably an object has a faulty __repr__.)",
+        ]
+
+    if not explanation:
+        return None
+
+    return [summary] + explanation
+
+
+def _compare_eq_any(left: Any, right: Any, verbose: int = 0) -> List[str]:
+    explanation = []
+    if istext(left) and istext(right):
+        explanation = _diff_text(left, right, verbose)
+    else:
+        if type(left) == type(right) and (
+            isdatacls(left) or isattrs(left) or isnamedtuple(left)
+        ):
+            # Note: unlike dataclasses/attrs, namedtuples compare only the
+            # field values, not the type or field names. But this branch
+            # intentionally only handles the same-type case, which was often
+            # used in older code bases before dataclasses/attrs were available.
+            explanation = _compare_eq_cls(left, right, verbose)
+        elif issequence(left) and issequence(right):
+            explanation = _compare_eq_sequence(left, right, verbose)
+        elif isset(left) and isset(right):
+            explanation = _compare_eq_set(left, right, verbose)
+        elif isdict(left) and isdict(right):
+            explanation = _compare_eq_dict(left, right, verbose)
+        elif verbose > 0:
+            explanation = _compare_eq_verbose(left, right)
+        if isiterable(left) and isiterable(right):
+            expl = _compare_eq_iterable(left, right, verbose)
+            explanation.extend(expl)
+    return explanation
+
+
+def _diff_text(left: str, right: str, verbose: int = 0) -> List[str]:
+    """Return the explanation for the diff between text.
+
+    Unless --verbose is used this will skip leading and trailing
+    characters which are identical to keep the diff minimal.
+    """
+    from difflib import ndiff
+
+    explanation: List[str] = []
+
+    if verbose < 1:
+        i = 0  # just in case left or right has zero length
+        for i in range(min(len(left), len(right))):
+            if left[i] != right[i]:
+                break
+        if i > 42:
+            i -= 10  # Provide some context
+            explanation = [
+                "Skipping %s identical leading characters in diff, use -v to show" % i
+            ]
+            left = left[i:]
+            right = right[i:]
+        if len(left) == len(right):
+            for i in range(len(left)):
+                if left[-i] != right[-i]:
+                    break
+            if i > 42:
+                i -= 10  # Provide some context
+                explanation += [
+                    "Skipping {} identical trailing "
+                    "characters in diff, use -v to show".format(i)
+                ]
+                left = left[:-i]
+                right = right[:-i]
+    keepends = True
+    if left.isspace() or right.isspace():
+        left = repr(str(left))
+        right = repr(str(right))
+        explanation += ["Strings contain only whitespace, escaping them using repr()"]
+    # "right" is the expected base against which we compare "left",
+    # see https://github.com/pytest-dev/pytest/issues/3333
+    explanation += [
+        line.strip("\n")
+        for line in ndiff(right.splitlines(keepends), left.splitlines(keepends))
+    ]
+    return explanation
+
+
+def _compare_eq_verbose(left: Any, right: Any) -> List[str]:
+    keepends = True
+    left_lines = repr(left).splitlines(keepends)
+    right_lines = repr(right).splitlines(keepends)
+
+    explanation: List[str] = []
+    explanation += ["+" + line for line in left_lines]
+    explanation += ["-" + line for line in right_lines]
+
+    return explanation
+
+
+def _surrounding_parens_on_own_lines(lines: List[str]) -> None:
+    """Move opening/closing parenthesis/bracket to own lines."""
+    opening = lines[0][:1]
+    if opening in ["(", "[", "{"]:
+        lines[0] = " " + lines[0][1:]
+        lines[:] = [opening] + lines
+    closing = lines[-1][-1:]
+    if closing in [")", "]", "}"]:
+        lines[-1] = lines[-1][:-1] + ","
+        lines[:] = lines + [closing]
+
+
+def _compare_eq_iterable(
+    left: Iterable[Any], right: Iterable[Any], verbose: int = 0
+) -> List[str]:
+    if not verbose:
+        return ["Use -v to get the full diff"]
+    # dynamic import to speedup pytest
+    import difflib
+
+    left_formatting = pprint.pformat(left).splitlines()
+    right_formatting = pprint.pformat(right).splitlines()
+
+    # Re-format for different output lengths.
+    lines_left = len(left_formatting)
+    lines_right = len(right_formatting)
+    if lines_left != lines_right:
+        left_formatting = _pformat_dispatch(left).splitlines()
+        right_formatting = _pformat_dispatch(right).splitlines()
+
+    if lines_left > 1 or lines_right > 1:
+        _surrounding_parens_on_own_lines(left_formatting)
+        _surrounding_parens_on_own_lines(right_formatting)
+
+    explanation = ["Full diff:"]
+    # "right" is the expected base against which we compare "left",
+    # see https://github.com/pytest-dev/pytest/issues/3333
+    explanation.extend(
+        line.rstrip() for line in difflib.ndiff(right_formatting, left_formatting)
+    )
+    return explanation
+
+
+def _compare_eq_sequence(
+    left: Sequence[Any], right: Sequence[Any], verbose: int = 0
+) -> List[str]:
+    comparing_bytes = isinstance(left, bytes) and isinstance(right, bytes)
+    explanation: List[str] = []
+    len_left = len(left)
+    len_right = len(right)
+    for i in range(min(len_left, len_right)):
+        if left[i] != right[i]:
+            if comparing_bytes:
+                # when comparing bytes, we want to see their ascii representation
+                # instead of their numeric values (#5260)
+                # using a slice gives us the ascii representation:
+                # >>> s = b'foo'
+                # >>> s[0]
+                # 102
+                # >>> s[0:1]
+                # b'f'
+                left_value = left[i : i + 1]
+                right_value = right[i : i + 1]
+            else:
+                left_value = left[i]
+                right_value = right[i]
+
+            explanation += [f"At index {i} diff: {left_value!r} != {right_value!r}"]
+            break
+
+    if comparing_bytes:
+        # when comparing bytes, it doesn't help to show the "sides contain one or more
+        # items" longer explanation, so skip it
+
+        return explanation
+
+    len_diff = len_left - len_right
+    if len_diff:
+        if len_diff > 0:
+            dir_with_more = "Left"
+            extra = saferepr(left[len_right])
+        else:
+            len_diff = 0 - len_diff
+            dir_with_more = "Right"
+            extra = saferepr(right[len_left])
+
+        if len_diff == 1:
+            explanation += [f"{dir_with_more} contains one more item: {extra}"]
+        else:
+            explanation += [
+                "%s contains %d more items, first extra item: %s"
+                % (dir_with_more, len_diff, extra)
+            ]
+    return explanation
+
+
+def _compare_eq_set(
+    left: AbstractSet[Any], right: AbstractSet[Any], verbose: int = 0
+) -> List[str]:
+    explanation = []
+    diff_left = left - right
+    diff_right = right - left
+    if diff_left:
+        explanation.append("Extra items in the left set:")
+        for item in diff_left:
+            explanation.append(saferepr(item))
+    if diff_right:
+        explanation.append("Extra items in the right set:")
+        for item in diff_right:
+            explanation.append(saferepr(item))
+    return explanation
+
+
+def _compare_eq_dict(
+    left: Mapping[Any, Any], right: Mapping[Any, Any], verbose: int = 0
+) -> List[str]:
+    explanation: List[str] = []
+    set_left = set(left)
+    set_right = set(right)
+    common = set_left.intersection(set_right)
+    same = {k: left[k] for k in common if left[k] == right[k]}
+    if same and verbose < 2:
+        explanation += ["Omitting %s identical items, use -vv to show" % len(same)]
+    elif same:
+        explanation += ["Common items:"]
+        explanation += pprint.pformat(same).splitlines()
+    diff = {k for k in common if left[k] != right[k]}
+    if diff:
+        explanation += ["Differing items:"]
+        for k in diff:
+            explanation += [saferepr({k: left[k]}) + " != " + saferepr({k: right[k]})]
+    extra_left = set_left - set_right
+    len_extra_left = len(extra_left)
+    if len_extra_left:
+        explanation.append(
+            "Left contains %d more item%s:"
+            % (len_extra_left, "" if len_extra_left == 1 else "s")
+        )
+        explanation.extend(
+            pprint.pformat({k: left[k] for k in extra_left}).splitlines()
+        )
+    extra_right = set_right - set_left
+    len_extra_right = len(extra_right)
+    if len_extra_right:
+        explanation.append(
+            "Right contains %d more item%s:"
+            % (len_extra_right, "" if len_extra_right == 1 else "s")
+        )
+        explanation.extend(
+            pprint.pformat({k: right[k] for k in extra_right}).splitlines()
+        )
+    return explanation
+
+
+def _compare_eq_cls(left: Any, right: Any, verbose: int) -> List[str]:
+    if isdatacls(left):
+        all_fields = left.__dataclass_fields__
+        fields_to_check = [field for field, info in all_fields.items() if info.compare]
+    elif isattrs(left):
+        all_fields = left.__attrs_attrs__
+        fields_to_check = [field.name for field in all_fields if getattr(field, "eq")]
+    elif isnamedtuple(left):
+        fields_to_check = left._fields
+    else:
+        assert False
+
+    indent = "  "
+    same = []
+    diff = []
+    for field in fields_to_check:
+        if getattr(left, field) == getattr(right, field):
+            same.append(field)
+        else:
+            diff.append(field)
+
+    explanation = []
+    if same or diff:
+        explanation += [""]
+    if same and verbose < 2:
+        explanation.append("Omitting %s identical items, use -vv to show" % len(same))
+    elif same:
+        explanation += ["Matching attributes:"]
+        explanation += pprint.pformat(same).splitlines()
+    if diff:
+        explanation += ["Differing attributes:"]
+        explanation += pprint.pformat(diff).splitlines()
+        for field in diff:
+            field_left = getattr(left, field)
+            field_right = getattr(right, field)
+            explanation += [
+                "",
+                "Drill down into differing attribute %s:" % field,
+                ("%s%s: %r != %r") % (indent, field, field_left, field_right),
+            ]
+            explanation += [
+                indent + line
+                for line in _compare_eq_any(field_left, field_right, verbose)
+            ]
+    return explanation
+
+
+def _notin_text(term: str, text: str, verbose: int = 0) -> List[str]:
+    index = text.find(term)
+    head = text[:index]
+    tail = text[index + len(term) :]
+    correct_text = head + tail
+    diff = _diff_text(text, correct_text, verbose)
+    newdiff = ["%s is contained here:" % saferepr(term, maxsize=42)]
+    for line in diff:
+        if line.startswith("Skipping"):
+            continue
+        if line.startswith("- "):
+            continue
+        if line.startswith("+ "):
+            newdiff.append("  " + line[2:])
+        else:
+            newdiff.append(line)
+    return newdiff
diff --git a/myenv/lib/python3.9/site-packages/_pytest/cacheprovider.py b/myenv/lib/python3.9/site-packages/_pytest/cacheprovider.py
new file mode 100644
index 0000000..03acd03
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/cacheprovider.py
@@ -0,0 +1,575 @@
+"""Implementation of the cache provider."""
+# This plugin was not named "cache" to avoid conflicts with the external
+# pytest-cache version.
+import json
+import os
+from pathlib import Path
+from typing import Dict
+from typing import Generator
+from typing import Iterable
+from typing import List
+from typing import Optional
+from typing import Set
+from typing import Union
+
+import attr
+import py
+
+from .pathlib import resolve_from_str
+from .pathlib import rm_rf
+from .reports import CollectReport
+from _pytest import nodes
+from _pytest._io import TerminalWriter
+from _pytest.compat import final
+from _pytest.config import Config
+from _pytest.config import ExitCode
+from _pytest.config import hookimpl
+from _pytest.config.argparsing import Parser
+from _pytest.deprecated import check_ispytest
+from _pytest.fixtures import fixture
+from _pytest.fixtures import FixtureRequest
+from _pytest.main import Session
+from _pytest.python import Module
+from _pytest.python import Package
+from _pytest.reports import TestReport
+
+
+README_CONTENT = """\
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/cache.html) for more information.
+"""
+
+CACHEDIR_TAG_CONTENT = b"""\
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	http://www.bford.info/cachedir/spec.html
+"""
+
+
+@final
+@attr.s(init=False)
+class Cache:
+    _cachedir = attr.ib(type=Path, repr=False)
+    _config = attr.ib(type=Config, repr=False)
+
+    # sub-directory under cache-dir for directories created by "makedir"
+    _CACHE_PREFIX_DIRS = "d"
+
+    # sub-directory under cache-dir for values created by "set"
+    _CACHE_PREFIX_VALUES = "v"
+
+    def __init__(
+        self, cachedir: Path, config: Config, *, _ispytest: bool = False
+    ) -> None:
+        check_ispytest(_ispytest)
+        self._cachedir = cachedir
+        self._config = config
+
+    @classmethod
+    def for_config(cls, config: Config, *, _ispytest: bool = False) -> "Cache":
+        """Create the Cache instance for a Config.
+
+        :meta private:
+        """
+        check_ispytest(_ispytest)
+        cachedir = cls.cache_dir_from_config(config, _ispytest=True)
+        if config.getoption("cacheclear") and cachedir.is_dir():
+            cls.clear_cache(cachedir, _ispytest=True)
+        return cls(cachedir, config, _ispytest=True)
+
+    @classmethod
+    def clear_cache(cls, cachedir: Path, _ispytest: bool = False) -> None:
+        """Clear the sub-directories used to hold cached directories and values.
+
+        :meta private:
+        """
+        check_ispytest(_ispytest)
+        for prefix in (cls._CACHE_PREFIX_DIRS, cls._CACHE_PREFIX_VALUES):
+            d = cachedir / prefix
+            if d.is_dir():
+                rm_rf(d)
+
+    @staticmethod
+    def cache_dir_from_config(config: Config, *, _ispytest: bool = False) -> Path:
+        """Get the path to the cache directory for a Config.
+
+        :meta private:
+        """
+        check_ispytest(_ispytest)
+        return resolve_from_str(config.getini("cache_dir"), config.rootpath)
+
+    def warn(self, fmt: str, *, _ispytest: bool = False, **args: object) -> None:
+        """Issue a cache warning.
+
+        :meta private:
+        """
+        check_ispytest(_ispytest)
+        import warnings
+        from _pytest.warning_types import PytestCacheWarning
+
+        warnings.warn(
+            PytestCacheWarning(fmt.format(**args) if args else fmt),
+            self._config.hook,
+            stacklevel=3,
+        )
+
+    def makedir(self, name: str) -> py.path.local:
+        """Return a directory path object with the given name.
+
+        If the directory does not yet exist, it will be created. You can use
+        it to manage files to e.g. store/retrieve database dumps across test
+        sessions.
+
+        :param name:
+            Must be a string not containing a ``/`` separator.
+            Make sure the name contains your plugin or application
+            identifiers to prevent clashes with other cache users.
+        """
+        path = Path(name)
+        if len(path.parts) > 1:
+            raise ValueError("name is not allowed to contain path separators")
+        res = self._cachedir.joinpath(self._CACHE_PREFIX_DIRS, path)
+        res.mkdir(exist_ok=True, parents=True)
+        return py.path.local(res)
+
+    def _getvaluepath(self, key: str) -> Path:
+        return self._cachedir.joinpath(self._CACHE_PREFIX_VALUES, Path(key))
+
+    def get(self, key: str, default):
+        """Return the cached value for the given key.
+
+        If no value was yet cached or the value cannot be read, the specified
+        default is returned.
+
+        :param key:
+            Must be a ``/`` separated value. Usually the first
+            name is the name of your plugin or your application.
+        :param default:
+            The value to return in case of a cache-miss or invalid cache value.
+        """
+        path = self._getvaluepath(key)
+        try:
+            with path.open("r") as f:
+                return json.load(f)
+        except (ValueError, OSError):
+            return default
+
+    def set(self, key: str, value: object) -> None:
+        """Save value for the given key.
+
+        :param key:
+            Must be a ``/`` separated value. Usually the first
+            name is the name of your plugin or your application.
+        :param value:
+            Must be of any combination of basic python types,
+            including nested types like lists of dictionaries.
+        """
+        path = self._getvaluepath(key)
+        try:
+            if path.parent.is_dir():
+                cache_dir_exists_already = True
+            else:
+                cache_dir_exists_already = self._cachedir.exists()
+                path.parent.mkdir(exist_ok=True, parents=True)
+        except OSError:
+            self.warn("could not create cache path {path}", path=path, _ispytest=True)
+            return
+        if not cache_dir_exists_already:
+            self._ensure_supporting_files()
+        data = json.dumps(value, indent=2, sort_keys=True)
+        try:
+            f = path.open("w")
+        except OSError:
+            self.warn("cache could not write path {path}", path=path, _ispytest=True)
+        else:
+            with f:
+                f.write(data)
+
+    def _ensure_supporting_files(self) -> None:
+        """Create supporting files in the cache dir that are not really part of the cache."""
+        readme_path = self._cachedir / "README.md"
+        readme_path.write_text(README_CONTENT)
+
+        gitignore_path = self._cachedir.joinpath(".gitignore")
+        msg = "# Created by pytest automatically.\n*\n"
+        gitignore_path.write_text(msg, encoding="UTF-8")
+
+        cachedir_tag_path = self._cachedir.joinpath("CACHEDIR.TAG")
+        cachedir_tag_path.write_bytes(CACHEDIR_TAG_CONTENT)
+
+
+class LFPluginCollWrapper:
+    def __init__(self, lfplugin: "LFPlugin") -> None:
+        self.lfplugin = lfplugin
+        self._collected_at_least_one_failure = False
+
+    @hookimpl(hookwrapper=True)
+    def pytest_make_collect_report(self, collector: nodes.Collector):
+        if isinstance(collector, Session):
+            out = yield
+            res: CollectReport = out.get_result()
+
+            # Sort any lf-paths to the beginning.
+            lf_paths = self.lfplugin._last_failed_paths
+            res.result = sorted(
+                res.result, key=lambda x: 0 if Path(str(x.fspath)) in lf_paths else 1,
+            )
+            return
+
+        elif isinstance(collector, Module):
+            if Path(str(collector.fspath)) in self.lfplugin._last_failed_paths:
+                out = yield
+                res = out.get_result()
+                result = res.result
+                lastfailed = self.lfplugin.lastfailed
+
+                # Only filter with known failures.
+                if not self._collected_at_least_one_failure:
+                    if not any(x.nodeid in lastfailed for x in result):
+                        return
+                    self.lfplugin.config.pluginmanager.register(
+                        LFPluginCollSkipfiles(self.lfplugin), "lfplugin-collskip"
+                    )
+                    self._collected_at_least_one_failure = True
+
+                session = collector.session
+                result[:] = [
+                    x
+                    for x in result
+                    if x.nodeid in lastfailed
+                    # Include any passed arguments (not trivial to filter).
+                    or session.isinitpath(x.fspath)
+                    # Keep all sub-collectors.
+                    or isinstance(x, nodes.Collector)
+                ]
+                return
+        yield
+
+
+class LFPluginCollSkipfiles:
+    def __init__(self, lfplugin: "LFPlugin") -> None:
+        self.lfplugin = lfplugin
+
+    @hookimpl
+    def pytest_make_collect_report(
+        self, collector: nodes.Collector
+    ) -> Optional[CollectReport]:
+        # Packages are Modules, but _last_failed_paths only contains
+        # test-bearing paths and doesn't try to include the paths of their
+        # packages, so don't filter them.
+        if isinstance(collector, Module) and not isinstance(collector, Package):
+            if Path(str(collector.fspath)) not in self.lfplugin._last_failed_paths:
+                self.lfplugin._skipped_files += 1
+
+                return CollectReport(
+                    collector.nodeid, "passed", longrepr=None, result=[]
+                )
+        return None
+
+
+class LFPlugin:
+    """Plugin which implements the --lf (run last-failing) option."""
+
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        active_keys = "lf", "failedfirst"
+        self.active = any(config.getoption(key) for key in active_keys)
+        assert config.cache
+        self.lastfailed: Dict[str, bool] = config.cache.get("cache/lastfailed", {})
+        self._previously_failed_count: Optional[int] = None
+        self._report_status: Optional[str] = None
+        self._skipped_files = 0  # count skipped files during collection due to --lf
+
+        if config.getoption("lf"):
+            self._last_failed_paths = self.get_last_failed_paths()
+            config.pluginmanager.register(
+                LFPluginCollWrapper(self), "lfplugin-collwrapper"
+            )
+
+    def get_last_failed_paths(self) -> Set[Path]:
+        """Return a set with all Paths()s of the previously failed nodeids."""
+        rootpath = self.config.rootpath
+        result = {rootpath / nodeid.split("::")[0] for nodeid in self.lastfailed}
+        return {x for x in result if x.exists()}
+
+    def pytest_report_collectionfinish(self) -> Optional[str]:
+        if self.active and self.config.getoption("verbose") >= 0:
+            return "run-last-failure: %s" % self._report_status
+        return None
+
+    def pytest_runtest_logreport(self, report: TestReport) -> None:
+        if (report.when == "call" and report.passed) or report.skipped:
+            self.lastfailed.pop(report.nodeid, None)
+        elif report.failed:
+            self.lastfailed[report.nodeid] = True
+
+    def pytest_collectreport(self, report: CollectReport) -> None:
+        passed = report.outcome in ("passed", "skipped")
+        if passed:
+            if report.nodeid in self.lastfailed:
+                self.lastfailed.pop(report.nodeid)
+                self.lastfailed.update((item.nodeid, True) for item in report.result)
+        else:
+            self.lastfailed[report.nodeid] = True
+
+    @hookimpl(hookwrapper=True, tryfirst=True)
+    def pytest_collection_modifyitems(
+        self, config: Config, items: List[nodes.Item]
+    ) -> Generator[None, None, None]:
+        yield
+
+        if not self.active:
+            return
+
+        if self.lastfailed:
+            previously_failed = []
+            previously_passed = []
+            for item in items:
+                if item.nodeid in self.lastfailed:
+                    previously_failed.append(item)
+                else:
+                    previously_passed.append(item)
+            self._previously_failed_count = len(previously_failed)
+
+            if not previously_failed:
+                # Running a subset of all tests with recorded failures
+                # only outside of it.
+                self._report_status = "%d known failures not in selected tests" % (
+                    len(self.lastfailed),
+                )
+            else:
+                if self.config.getoption("lf"):
+                    items[:] = previously_failed
+                    config.hook.pytest_deselected(items=previously_passed)
+                else:  # --failedfirst
+                    items[:] = previously_failed + previously_passed
+
+                noun = "failure" if self._previously_failed_count == 1 else "failures"
+                suffix = " first" if self.config.getoption("failedfirst") else ""
+                self._report_status = "rerun previous {count} {noun}{suffix}".format(
+                    count=self._previously_failed_count, suffix=suffix, noun=noun
+                )
+
+            if self._skipped_files > 0:
+                files_noun = "file" if self._skipped_files == 1 else "files"
+                self._report_status += " (skipped {files} {files_noun})".format(
+                    files=self._skipped_files, files_noun=files_noun
+                )
+        else:
+            self._report_status = "no previously failed tests, "
+            if self.config.getoption("last_failed_no_failures") == "none":
+                self._report_status += "deselecting all items."
+                config.hook.pytest_deselected(items=items[:])
+                items[:] = []
+            else:
+                self._report_status += "not deselecting items."
+
+    def pytest_sessionfinish(self, session: Session) -> None:
+        config = self.config
+        if config.getoption("cacheshow") or hasattr(config, "workerinput"):
+            return
+
+        assert config.cache is not None
+        saved_lastfailed = config.cache.get("cache/lastfailed", {})
+        if saved_lastfailed != self.lastfailed:
+            config.cache.set("cache/lastfailed", self.lastfailed)
+
+
+class NFPlugin:
+    """Plugin which implements the --nf (run new-first) option."""
+
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        self.active = config.option.newfirst
+        assert config.cache is not None
+        self.cached_nodeids = set(config.cache.get("cache/nodeids", []))
+
+    @hookimpl(hookwrapper=True, tryfirst=True)
+    def pytest_collection_modifyitems(
+        self, items: List[nodes.Item]
+    ) -> Generator[None, None, None]:
+        yield
+
+        if self.active:
+            new_items: Dict[str, nodes.Item] = {}
+            other_items: Dict[str, nodes.Item] = {}
+            for item in items:
+                if item.nodeid not in self.cached_nodeids:
+                    new_items[item.nodeid] = item
+                else:
+                    other_items[item.nodeid] = item
+
+            items[:] = self._get_increasing_order(
+                new_items.values()
+            ) + self._get_increasing_order(other_items.values())
+            self.cached_nodeids.update(new_items)
+        else:
+            self.cached_nodeids.update(item.nodeid for item in items)
+
+    def _get_increasing_order(self, items: Iterable[nodes.Item]) -> List[nodes.Item]:
+        return sorted(items, key=lambda item: item.fspath.mtime(), reverse=True)  # type: ignore[no-any-return]
+
+    def pytest_sessionfinish(self) -> None:
+        config = self.config
+        if config.getoption("cacheshow") or hasattr(config, "workerinput"):
+            return
+
+        if config.getoption("collectonly"):
+            return
+
+        assert config.cache is not None
+        config.cache.set("cache/nodeids", sorted(self.cached_nodeids))
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("general")
+    group.addoption(
+        "--lf",
+        "--last-failed",
+        action="store_true",
+        dest="lf",
+        help="rerun only the tests that failed "
+        "at the last run (or all if none failed)",
+    )
+    group.addoption(
+        "--ff",
+        "--failed-first",
+        action="store_true",
+        dest="failedfirst",
+        help="run all tests, but run the last failures first.\n"
+        "This may re-order tests and thus lead to "
+        "repeated fixture setup/teardown.",
+    )
+    group.addoption(
+        "--nf",
+        "--new-first",
+        action="store_true",
+        dest="newfirst",
+        help="run tests from new files first, then the rest of the tests "
+        "sorted by file mtime",
+    )
+    group.addoption(
+        "--cache-show",
+        action="append",
+        nargs="?",
+        dest="cacheshow",
+        help=(
+            "show cache contents, don't perform collection or tests. "
+            "Optional argument: glob (default: '*')."
+        ),
+    )
+    group.addoption(
+        "--cache-clear",
+        action="store_true",
+        dest="cacheclear",
+        help="remove all cache contents at start of test run.",
+    )
+    cache_dir_default = ".pytest_cache"
+    if "TOX_ENV_DIR" in os.environ:
+        cache_dir_default = os.path.join(os.environ["TOX_ENV_DIR"], cache_dir_default)
+    parser.addini("cache_dir", default=cache_dir_default, help="cache directory path.")
+    group.addoption(
+        "--lfnf",
+        "--last-failed-no-failures",
+        action="store",
+        dest="last_failed_no_failures",
+        choices=("all", "none"),
+        default="all",
+        help="which tests to run with no previously (known) failures.",
+    )
+
+
+def pytest_cmdline_main(config: Config) -> Optional[Union[int, ExitCode]]:
+    if config.option.cacheshow:
+        from _pytest.main import wrap_session
+
+        return wrap_session(config, cacheshow)
+    return None
+
+
+@hookimpl(tryfirst=True)
+def pytest_configure(config: Config) -> None:
+    config.cache = Cache.for_config(config, _ispytest=True)
+    config.pluginmanager.register(LFPlugin(config), "lfplugin")
+    config.pluginmanager.register(NFPlugin(config), "nfplugin")
+
+
+@fixture
+def cache(request: FixtureRequest) -> Cache:
+    """Return a cache object that can persist state between testing sessions.
+
+    cache.get(key, default)
+    cache.set(key, value)
+
+    Keys must be ``/`` separated strings, where the first part is usually the
+    name of your plugin or application to avoid clashes with other cache users.
+
+    Values can be any object handled by the json stdlib module.
+    """
+    assert request.config.cache is not None
+    return request.config.cache
+
+
+def pytest_report_header(config: Config) -> Optional[str]:
+    """Display cachedir with --cache-show and if non-default."""
+    if config.option.verbose > 0 or config.getini("cache_dir") != ".pytest_cache":
+        assert config.cache is not None
+        cachedir = config.cache._cachedir
+        # TODO: evaluate generating upward relative paths
+        # starting with .., ../.. if sensible
+
+        try:
+            displaypath = cachedir.relative_to(config.rootpath)
+        except ValueError:
+            displaypath = cachedir
+        return f"cachedir: {displaypath}"
+    return None
+
+
+def cacheshow(config: Config, session: Session) -> int:
+    from pprint import pformat
+
+    assert config.cache is not None
+
+    tw = TerminalWriter()
+    tw.line("cachedir: " + str(config.cache._cachedir))
+    if not config.cache._cachedir.is_dir():
+        tw.line("cache is empty")
+        return 0
+
+    glob = config.option.cacheshow[0]
+    if glob is None:
+        glob = "*"
+
+    dummy = object()
+    basedir = config.cache._cachedir
+    vdir = basedir / Cache._CACHE_PREFIX_VALUES
+    tw.sep("-", "cache values for %r" % glob)
+    for valpath in sorted(x for x in vdir.rglob(glob) if x.is_file()):
+        key = str(valpath.relative_to(vdir))
+        val = config.cache.get(key, dummy)
+        if val is dummy:
+            tw.line("%s contains unreadable content, will be ignored" % key)
+        else:
+            tw.line("%s contains:" % key)
+            for line in pformat(val).splitlines():
+                tw.line("  " + line)
+
+    ddir = basedir / Cache._CACHE_PREFIX_DIRS
+    if ddir.is_dir():
+        contents = sorted(ddir.rglob(glob))
+        tw.sep("-", "cache directories for %r" % glob)
+        for p in contents:
+            # if p.check(dir=1):
+            #    print("%s/" % p.relto(basedir))
+            if p.is_file():
+                key = str(p.relative_to(basedir))
+                tw.line(f"{key} is a file of length {p.stat().st_size:d}")
+    return 0
diff --git a/myenv/lib/python3.9/site-packages/_pytest/capture.py b/myenv/lib/python3.9/site-packages/_pytest/capture.py
new file mode 100644
index 0000000..0863026
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/capture.py
@@ -0,0 +1,967 @@
+"""Per-test stdout/stderr capturing mechanism."""
+import contextlib
+import functools
+import io
+import os
+import sys
+from io import UnsupportedOperation
+from tempfile import TemporaryFile
+from typing import Any
+from typing import AnyStr
+from typing import Generator
+from typing import Generic
+from typing import Iterator
+from typing import Optional
+from typing import TextIO
+from typing import Tuple
+from typing import TYPE_CHECKING
+from typing import Union
+
+from _pytest.compat import final
+from _pytest.config import Config
+from _pytest.config import hookimpl
+from _pytest.config.argparsing import Parser
+from _pytest.deprecated import check_ispytest
+from _pytest.fixtures import fixture
+from _pytest.fixtures import SubRequest
+from _pytest.nodes import Collector
+from _pytest.nodes import File
+from _pytest.nodes import Item
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
+    _CaptureMethod = Literal["fd", "sys", "no", "tee-sys"]
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("general")
+    group._addoption(
+        "--capture",
+        action="store",
+        default="fd",
+        metavar="method",
+        choices=["fd", "sys", "no", "tee-sys"],
+        help="per-test capturing method: one of fd|sys|no|tee-sys.",
+    )
+    group._addoption(
+        "-s",
+        action="store_const",
+        const="no",
+        dest="capture",
+        help="shortcut for --capture=no.",
+    )
+
+
+def _colorama_workaround() -> None:
+    """Ensure colorama is imported so that it attaches to the correct stdio
+    handles on Windows.
+
+    colorama uses the terminal on import time. So if something does the
+    first import of colorama while I/O capture is active, colorama will
+    fail in various ways.
+    """
+    if sys.platform.startswith("win32"):
+        try:
+            import colorama  # noqa: F401
+        except ImportError:
+            pass
+
+
+def _readline_workaround() -> None:
+    """Ensure readline is imported so that it attaches to the correct stdio
+    handles on Windows.
+
+    Pdb uses readline support where available--when not running from the Python
+    prompt, the readline module is not imported until running the pdb REPL.  If
+    running pytest with the --pdb option this means the readline module is not
+    imported until after I/O capture has been started.
+
+    This is a problem for pyreadline, which is often used to implement readline
+    support on Windows, as it does not attach to the correct handles for stdout
+    and/or stdin if they have been redirected by the FDCapture mechanism.  This
+    workaround ensures that readline is imported before I/O capture is setup so
+    that it can attach to the actual stdin/out for the console.
+
+    See https://github.com/pytest-dev/pytest/pull/1281.
+    """
+    if sys.platform.startswith("win32"):
+        try:
+            import readline  # noqa: F401
+        except ImportError:
+            pass
+
+
+def _py36_windowsconsoleio_workaround(stream: TextIO) -> None:
+    """Workaround for Windows Unicode console handling on Python>=3.6.
+
+    Python 3.6 implemented Unicode console handling for Windows. This works
+    by reading/writing to the raw console handle using
+    ``{Read,Write}ConsoleW``.
+
+    The problem is that we are going to ``dup2`` over the stdio file
+    descriptors when doing ``FDCapture`` and this will ``CloseHandle`` the
+    handles used by Python to write to the console. Though there is still some
+    weirdness and the console handle seems to only be closed randomly and not
+    on the first call to ``CloseHandle``, or maybe it gets reopened with the
+    same handle value when we suspend capturing.
+
+    The workaround in this case will reopen stdio with a different fd which
+    also means a different handle by replicating the logic in
+    "Py_lifecycle.c:initstdio/create_stdio".
+
+    :param stream:
+        In practice ``sys.stdout`` or ``sys.stderr``, but given
+        here as parameter for unittesting purposes.
+
+    See https://github.com/pytest-dev/py/issues/103.
+    """
+    if not sys.platform.startswith("win32") or hasattr(sys, "pypy_version_info"):
+        return
+
+    # Bail out if ``stream`` doesn't seem like a proper ``io`` stream (#2666).
+    if not hasattr(stream, "buffer"):  # type: ignore[unreachable]
+        return
+
+    buffered = hasattr(stream.buffer, "raw")
+    raw_stdout = stream.buffer.raw if buffered else stream.buffer  # type: ignore[attr-defined]
+
+    if not isinstance(raw_stdout, io._WindowsConsoleIO):  # type: ignore[attr-defined]
+        return
+
+    def _reopen_stdio(f, mode):
+        if not buffered and mode[0] == "w":
+            buffering = 0
+        else:
+            buffering = -1
+
+        return io.TextIOWrapper(
+            open(os.dup(f.fileno()), mode, buffering),  # type: ignore[arg-type]
+            f.encoding,
+            f.errors,
+            f.newlines,
+            f.line_buffering,
+        )
+
+    sys.stdin = _reopen_stdio(sys.stdin, "rb")
+    sys.stdout = _reopen_stdio(sys.stdout, "wb")
+    sys.stderr = _reopen_stdio(sys.stderr, "wb")
+
+
+@hookimpl(hookwrapper=True)
+def pytest_load_initial_conftests(early_config: Config):
+    ns = early_config.known_args_namespace
+    if ns.capture == "fd":
+        _py36_windowsconsoleio_workaround(sys.stdout)
+    _colorama_workaround()
+    _readline_workaround()
+    pluginmanager = early_config.pluginmanager
+    capman = CaptureManager(ns.capture)
+    pluginmanager.register(capman, "capturemanager")
+
+    # Make sure that capturemanager is properly reset at final shutdown.
+    early_config.add_cleanup(capman.stop_global_capturing)
+
+    # Finally trigger conftest loading but while capturing (issue #93).
+    capman.start_global_capturing()
+    outcome = yield
+    capman.suspend_global_capture()
+    if outcome.excinfo is not None:
+        out, err = capman.read_global_capture()
+        sys.stdout.write(out)
+        sys.stderr.write(err)
+
+
+# IO Helpers.
+
+
+class EncodedFile(io.TextIOWrapper):
+    __slots__ = ()
+
+    @property
+    def name(self) -> str:
+        # Ensure that file.name is a string. Workaround for a Python bug
+        # fixed in >=3.7.4: https://bugs.python.org/issue36015
+        return repr(self.buffer)
+
+    @property
+    def mode(self) -> str:
+        # TextIOWrapper doesn't expose a mode, but at least some of our
+        # tests check it.
+        return self.buffer.mode.replace("b", "")
+
+
+class CaptureIO(io.TextIOWrapper):
+    def __init__(self) -> None:
+        super().__init__(io.BytesIO(), encoding="UTF-8", newline="", write_through=True)
+
+    def getvalue(self) -> str:
+        assert isinstance(self.buffer, io.BytesIO)
+        return self.buffer.getvalue().decode("UTF-8")
+
+
+class TeeCaptureIO(CaptureIO):
+    def __init__(self, other: TextIO) -> None:
+        self._other = other
+        super().__init__()
+
+    def write(self, s: str) -> int:
+        super().write(s)
+        return self._other.write(s)
+
+
+class DontReadFromInput:
+    encoding = None
+
+    def read(self, *args):
+        raise OSError(
+            "pytest: reading from stdin while output is captured!  Consider using `-s`."
+        )
+
+    readline = read
+    readlines = read
+    __next__ = read
+
+    def __iter__(self):
+        return self
+
+    def fileno(self) -> int:
+        raise UnsupportedOperation("redirected stdin is pseudofile, has no fileno()")
+
+    def isatty(self) -> bool:
+        return False
+
+    def close(self) -> None:
+        pass
+
+    @property
+    def buffer(self):
+        return self
+
+
+# Capture classes.
+
+
+patchsysdict = {0: "stdin", 1: "stdout", 2: "stderr"}
+
+
+class NoCapture:
+    EMPTY_BUFFER = None
+    __init__ = start = done = suspend = resume = lambda *args: None
+
+
+class SysCaptureBinary:
+
+    EMPTY_BUFFER = b""
+
+    def __init__(self, fd: int, tmpfile=None, *, tee: bool = False) -> None:
+        name = patchsysdict[fd]
+        self._old = getattr(sys, name)
+        self.name = name
+        if tmpfile is None:
+            if name == "stdin":
+                tmpfile = DontReadFromInput()
+            else:
+                tmpfile = CaptureIO() if not tee else TeeCaptureIO(self._old)
+        self.tmpfile = tmpfile
+        self._state = "initialized"
+
+    def repr(self, class_name: str) -> str:
+        return "<{} {} _old={} _state={!r} tmpfile={!r}>".format(
+            class_name,
+            self.name,
+            hasattr(self, "_old") and repr(self._old) or "<UNSET>",
+            self._state,
+            self.tmpfile,
+        )
+
+    def __repr__(self) -> str:
+        return "<{} {} _old={} _state={!r} tmpfile={!r}>".format(
+            self.__class__.__name__,
+            self.name,
+            hasattr(self, "_old") and repr(self._old) or "<UNSET>",
+            self._state,
+            self.tmpfile,
+        )
+
+    def _assert_state(self, op: str, states: Tuple[str, ...]) -> None:
+        assert (
+            self._state in states
+        ), "cannot {} in state {!r}: expected one of {}".format(
+            op, self._state, ", ".join(states)
+        )
+
+    def start(self) -> None:
+        self._assert_state("start", ("initialized",))
+        setattr(sys, self.name, self.tmpfile)
+        self._state = "started"
+
+    def snap(self):
+        self._assert_state("snap", ("started", "suspended"))
+        self.tmpfile.seek(0)
+        res = self.tmpfile.buffer.read()
+        self.tmpfile.seek(0)
+        self.tmpfile.truncate()
+        return res
+
+    def done(self) -> None:
+        self._assert_state("done", ("initialized", "started", "suspended", "done"))
+        if self._state == "done":
+            return
+        setattr(sys, self.name, self._old)
+        del self._old
+        self.tmpfile.close()
+        self._state = "done"
+
+    def suspend(self) -> None:
+        self._assert_state("suspend", ("started", "suspended"))
+        setattr(sys, self.name, self._old)
+        self._state = "suspended"
+
+    def resume(self) -> None:
+        self._assert_state("resume", ("started", "suspended"))
+        if self._state == "started":
+            return
+        setattr(sys, self.name, self.tmpfile)
+        self._state = "started"
+
+    def writeorg(self, data) -> None:
+        self._assert_state("writeorg", ("started", "suspended"))
+        self._old.flush()
+        self._old.buffer.write(data)
+        self._old.buffer.flush()
+
+
+class SysCapture(SysCaptureBinary):
+    EMPTY_BUFFER = ""  # type: ignore[assignment]
+
+    def snap(self):
+        res = self.tmpfile.getvalue()
+        self.tmpfile.seek(0)
+        self.tmpfile.truncate()
+        return res
+
+    def writeorg(self, data):
+        self._assert_state("writeorg", ("started", "suspended"))
+        self._old.write(data)
+        self._old.flush()
+
+
+class FDCaptureBinary:
+    """Capture IO to/from a given OS-level file descriptor.
+
+    snap() produces `bytes`.
+    """
+
+    EMPTY_BUFFER = b""
+
+    def __init__(self, targetfd: int) -> None:
+        self.targetfd = targetfd
+
+        try:
+            os.fstat(targetfd)
+        except OSError:
+            # FD capturing is conceptually simple -- create a temporary file,
+            # redirect the FD to it, redirect back when done. But when the
+            # target FD is invalid it throws a wrench into this loveley scheme.
+            #
+            # Tests themselves shouldn't care if the FD is valid, FD capturing
+            # should work regardless of external circumstances. So falling back
+            # to just sys capturing is not a good option.
+            #
+            # Further complications are the need to support suspend() and the
+            # possibility of FD reuse (e.g. the tmpfile getting the very same
+            # target FD). The following approach is robust, I believe.
+            self.targetfd_invalid: Optional[int] = os.open(os.devnull, os.O_RDWR)
+            os.dup2(self.targetfd_invalid, targetfd)
+        else:
+            self.targetfd_invalid = None
+        self.targetfd_save = os.dup(targetfd)
+
+        if targetfd == 0:
+            self.tmpfile = open(os.devnull)
+            self.syscapture = SysCapture(targetfd)
+        else:
+            self.tmpfile = EncodedFile(
+                TemporaryFile(buffering=0),
+                encoding="utf-8",
+                errors="replace",
+                newline="",
+                write_through=True,
+            )
+            if targetfd in patchsysdict:
+                self.syscapture = SysCapture(targetfd, self.tmpfile)
+            else:
+                self.syscapture = NoCapture()
+
+        self._state = "initialized"
+
+    def __repr__(self) -> str:
+        return "<{} {} oldfd={} _state={!r} tmpfile={!r}>".format(
+            self.__class__.__name__,
+            self.targetfd,
+            self.targetfd_save,
+            self._state,
+            self.tmpfile,
+        )
+
+    def _assert_state(self, op: str, states: Tuple[str, ...]) -> None:
+        assert (
+            self._state in states
+        ), "cannot {} in state {!r}: expected one of {}".format(
+            op, self._state, ", ".join(states)
+        )
+
+    def start(self) -> None:
+        """Start capturing on targetfd using memorized tmpfile."""
+        self._assert_state("start", ("initialized",))
+        os.dup2(self.tmpfile.fileno(), self.targetfd)
+        self.syscapture.start()
+        self._state = "started"
+
+    def snap(self):
+        self._assert_state("snap", ("started", "suspended"))
+        self.tmpfile.seek(0)
+        res = self.tmpfile.buffer.read()
+        self.tmpfile.seek(0)
+        self.tmpfile.truncate()
+        return res
+
+    def done(self) -> None:
+        """Stop capturing, restore streams, return original capture file,
+        seeked to position zero."""
+        self._assert_state("done", ("initialized", "started", "suspended", "done"))
+        if self._state == "done":
+            return
+        os.dup2(self.targetfd_save, self.targetfd)
+        os.close(self.targetfd_save)
+        if self.targetfd_invalid is not None:
+            if self.targetfd_invalid != self.targetfd:
+                os.close(self.targetfd)
+            os.close(self.targetfd_invalid)
+        self.syscapture.done()
+        self.tmpfile.close()
+        self._state = "done"
+
+    def suspend(self) -> None:
+        self._assert_state("suspend", ("started", "suspended"))
+        if self._state == "suspended":
+            return
+        self.syscapture.suspend()
+        os.dup2(self.targetfd_save, self.targetfd)
+        self._state = "suspended"
+
+    def resume(self) -> None:
+        self._assert_state("resume", ("started", "suspended"))
+        if self._state == "started":
+            return
+        self.syscapture.resume()
+        os.dup2(self.tmpfile.fileno(), self.targetfd)
+        self._state = "started"
+
+    def writeorg(self, data):
+        """Write to original file descriptor."""
+        self._assert_state("writeorg", ("started", "suspended"))
+        os.write(self.targetfd_save, data)
+
+
+class FDCapture(FDCaptureBinary):
+    """Capture IO to/from a given OS-level file descriptor.
+
+    snap() produces text.
+    """
+
+    # Ignore type because it doesn't match the type in the superclass (bytes).
+    EMPTY_BUFFER = ""  # type: ignore
+
+    def snap(self):
+        self._assert_state("snap", ("started", "suspended"))
+        self.tmpfile.seek(0)
+        res = self.tmpfile.read()
+        self.tmpfile.seek(0)
+        self.tmpfile.truncate()
+        return res
+
+    def writeorg(self, data):
+        """Write to original file descriptor."""
+        super().writeorg(data.encode("utf-8"))  # XXX use encoding of original stream
+
+
+# MultiCapture
+
+
+# This class was a namedtuple, but due to mypy limitation[0] it could not be
+# made generic, so was replaced by a regular class which tries to emulate the
+# pertinent parts of a namedtuple. If the mypy limitation is ever lifted, can
+# make it a namedtuple again.
+# [0]: https://github.com/python/mypy/issues/685
+@final
+@functools.total_ordering
+class CaptureResult(Generic[AnyStr]):
+    """The result of :method:`CaptureFixture.readouterr`."""
+
+    __slots__ = ("out", "err")
+
+    def __init__(self, out: AnyStr, err: AnyStr) -> None:
+        self.out: AnyStr = out
+        self.err: AnyStr = err
+
+    def __len__(self) -> int:
+        return 2
+
+    def __iter__(self) -> Iterator[AnyStr]:
+        return iter((self.out, self.err))
+
+    def __getitem__(self, item: int) -> AnyStr:
+        return tuple(self)[item]
+
+    def _replace(
+        self, *, out: Optional[AnyStr] = None, err: Optional[AnyStr] = None
+    ) -> "CaptureResult[AnyStr]":
+        return CaptureResult(
+            out=self.out if out is None else out, err=self.err if err is None else err
+        )
+
+    def count(self, value: AnyStr) -> int:
+        return tuple(self).count(value)
+
+    def index(self, value) -> int:
+        return tuple(self).index(value)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, (CaptureResult, tuple)):
+            return NotImplemented
+        return tuple(self) == tuple(other)
+
+    def __hash__(self) -> int:
+        return hash(tuple(self))
+
+    def __lt__(self, other: object) -> bool:
+        if not isinstance(other, (CaptureResult, tuple)):
+            return NotImplemented
+        return tuple(self) < tuple(other)
+
+    def __repr__(self) -> str:
+        return f"CaptureResult(out={self.out!r}, err={self.err!r})"
+
+
+class MultiCapture(Generic[AnyStr]):
+    _state = None
+    _in_suspended = False
+
+    def __init__(self, in_, out, err) -> None:
+        self.in_ = in_
+        self.out = out
+        self.err = err
+
+    def __repr__(self) -> str:
+        return "<MultiCapture out={!r} err={!r} in_={!r} _state={!r} _in_suspended={!r}>".format(
+            self.out, self.err, self.in_, self._state, self._in_suspended,
+        )
+
+    def start_capturing(self) -> None:
+        self._state = "started"
+        if self.in_:
+            self.in_.start()
+        if self.out:
+            self.out.start()
+        if self.err:
+            self.err.start()
+
+    def pop_outerr_to_orig(self) -> Tuple[AnyStr, AnyStr]:
+        """Pop current snapshot out/err capture and flush to orig streams."""
+        out, err = self.readouterr()
+        if out:
+            self.out.writeorg(out)
+        if err:
+            self.err.writeorg(err)
+        return out, err
+
+    def suspend_capturing(self, in_: bool = False) -> None:
+        self._state = "suspended"
+        if self.out:
+            self.out.suspend()
+        if self.err:
+            self.err.suspend()
+        if in_ and self.in_:
+            self.in_.suspend()
+            self._in_suspended = True
+
+    def resume_capturing(self) -> None:
+        self._state = "started"
+        if self.out:
+            self.out.resume()
+        if self.err:
+            self.err.resume()
+        if self._in_suspended:
+            self.in_.resume()
+            self._in_suspended = False
+
+    def stop_capturing(self) -> None:
+        """Stop capturing and reset capturing streams."""
+        if self._state == "stopped":
+            raise ValueError("was already stopped")
+        self._state = "stopped"
+        if self.out:
+            self.out.done()
+        if self.err:
+            self.err.done()
+        if self.in_:
+            self.in_.done()
+
+    def is_started(self) -> bool:
+        """Whether actively capturing -- not suspended or stopped."""
+        return self._state == "started"
+
+    def readouterr(self) -> CaptureResult[AnyStr]:
+        if self.out:
+            out = self.out.snap()
+        else:
+            out = ""
+        if self.err:
+            err = self.err.snap()
+        else:
+            err = ""
+        return CaptureResult(out, err)
+
+
+def _get_multicapture(method: "_CaptureMethod") -> MultiCapture[str]:
+    if method == "fd":
+        return MultiCapture(in_=FDCapture(0), out=FDCapture(1), err=FDCapture(2))
+    elif method == "sys":
+        return MultiCapture(in_=SysCapture(0), out=SysCapture(1), err=SysCapture(2))
+    elif method == "no":
+        return MultiCapture(in_=None, out=None, err=None)
+    elif method == "tee-sys":
+        return MultiCapture(
+            in_=None, out=SysCapture(1, tee=True), err=SysCapture(2, tee=True)
+        )
+    raise ValueError(f"unknown capturing method: {method!r}")
+
+
+# CaptureManager and CaptureFixture
+
+
+class CaptureManager:
+    """The capture plugin.
+
+    Manages that the appropriate capture method is enabled/disabled during
+    collection and each test phase (setup, call, teardown). After each of
+    those points, the captured output is obtained and attached to the
+    collection/runtest report.
+
+    There are two levels of capture:
+
+    * global: enabled by default and can be suppressed by the ``-s``
+      option. This is always enabled/disabled during collection and each test
+      phase.
+
+    * fixture: when a test function or one of its fixture depend on the
+      ``capsys`` or ``capfd`` fixtures. In this case special handling is
+      needed to ensure the fixtures take precedence over the global capture.
+    """
+
+    def __init__(self, method: "_CaptureMethod") -> None:
+        self._method = method
+        self._global_capturing: Optional[MultiCapture[str]] = None
+        self._capture_fixture: Optional[CaptureFixture[Any]] = None
+
+    def __repr__(self) -> str:
+        return "<CaptureManager _method={!r} _global_capturing={!r} _capture_fixture={!r}>".format(
+            self._method, self._global_capturing, self._capture_fixture
+        )
+
+    def is_capturing(self) -> Union[str, bool]:
+        if self.is_globally_capturing():
+            return "global"
+        if self._capture_fixture:
+            return "fixture %s" % self._capture_fixture.request.fixturename
+        return False
+
+    # Global capturing control
+
+    def is_globally_capturing(self) -> bool:
+        return self._method != "no"
+
+    def start_global_capturing(self) -> None:
+        assert self._global_capturing is None
+        self._global_capturing = _get_multicapture(self._method)
+        self._global_capturing.start_capturing()
+
+    def stop_global_capturing(self) -> None:
+        if self._global_capturing is not None:
+            self._global_capturing.pop_outerr_to_orig()
+            self._global_capturing.stop_capturing()
+            self._global_capturing = None
+
+    def resume_global_capture(self) -> None:
+        # During teardown of the python process, and on rare occasions, capture
+        # attributes can be `None` while trying to resume global capture.
+        if self._global_capturing is not None:
+            self._global_capturing.resume_capturing()
+
+    def suspend_global_capture(self, in_: bool = False) -> None:
+        if self._global_capturing is not None:
+            self._global_capturing.suspend_capturing(in_=in_)
+
+    def suspend(self, in_: bool = False) -> None:
+        # Need to undo local capsys-et-al if it exists before disabling global capture.
+        self.suspend_fixture()
+        self.suspend_global_capture(in_)
+
+    def resume(self) -> None:
+        self.resume_global_capture()
+        self.resume_fixture()
+
+    def read_global_capture(self) -> CaptureResult[str]:
+        assert self._global_capturing is not None
+        return self._global_capturing.readouterr()
+
+    # Fixture Control
+
+    def set_fixture(self, capture_fixture: "CaptureFixture[Any]") -> None:
+        if self._capture_fixture:
+            current_fixture = self._capture_fixture.request.fixturename
+            requested_fixture = capture_fixture.request.fixturename
+            capture_fixture.request.raiseerror(
+                "cannot use {} and {} at the same time".format(
+                    requested_fixture, current_fixture
+                )
+            )
+        self._capture_fixture = capture_fixture
+
+    def unset_fixture(self) -> None:
+        self._capture_fixture = None
+
+    def activate_fixture(self) -> None:
+        """If the current item is using ``capsys`` or ``capfd``, activate
+        them so they take precedence over the global capture."""
+        if self._capture_fixture:
+            self._capture_fixture._start()
+
+    def deactivate_fixture(self) -> None:
+        """Deactivate the ``capsys`` or ``capfd`` fixture of this item, if any."""
+        if self._capture_fixture:
+            self._capture_fixture.close()
+
+    def suspend_fixture(self) -> None:
+        if self._capture_fixture:
+            self._capture_fixture._suspend()
+
+    def resume_fixture(self) -> None:
+        if self._capture_fixture:
+            self._capture_fixture._resume()
+
+    # Helper context managers
+
+    @contextlib.contextmanager
+    def global_and_fixture_disabled(self) -> Generator[None, None, None]:
+        """Context manager to temporarily disable global and current fixture capturing."""
+        do_fixture = self._capture_fixture and self._capture_fixture._is_started()
+        if do_fixture:
+            self.suspend_fixture()
+        do_global = self._global_capturing and self._global_capturing.is_started()
+        if do_global:
+            self.suspend_global_capture()
+        try:
+            yield
+        finally:
+            if do_global:
+                self.resume_global_capture()
+            if do_fixture:
+                self.resume_fixture()
+
+    @contextlib.contextmanager
+    def item_capture(self, when: str, item: Item) -> Generator[None, None, None]:
+        self.resume_global_capture()
+        self.activate_fixture()
+        try:
+            yield
+        finally:
+            self.deactivate_fixture()
+            self.suspend_global_capture(in_=False)
+
+        out, err = self.read_global_capture()
+        item.add_report_section(when, "stdout", out)
+        item.add_report_section(when, "stderr", err)
+
+    # Hooks
+
+    @hookimpl(hookwrapper=True)
+    def pytest_make_collect_report(self, collector: Collector):
+        if isinstance(collector, File):
+            self.resume_global_capture()
+            outcome = yield
+            self.suspend_global_capture()
+            out, err = self.read_global_capture()
+            rep = outcome.get_result()
+            if out:
+                rep.sections.append(("Captured stdout", out))
+            if err:
+                rep.sections.append(("Captured stderr", err))
+        else:
+            yield
+
+    @hookimpl(hookwrapper=True)
+    def pytest_runtest_setup(self, item: Item) -> Generator[None, None, None]:
+        with self.item_capture("setup", item):
+            yield
+
+    @hookimpl(hookwrapper=True)
+    def pytest_runtest_call(self, item: Item) -> Generator[None, None, None]:
+        with self.item_capture("call", item):
+            yield
+
+    @hookimpl(hookwrapper=True)
+    def pytest_runtest_teardown(self, item: Item) -> Generator[None, None, None]:
+        with self.item_capture("teardown", item):
+            yield
+
+    @hookimpl(tryfirst=True)
+    def pytest_keyboard_interrupt(self) -> None:
+        self.stop_global_capturing()
+
+    @hookimpl(tryfirst=True)
+    def pytest_internalerror(self) -> None:
+        self.stop_global_capturing()
+
+
+class CaptureFixture(Generic[AnyStr]):
+    """Object returned by the :fixture:`capsys`, :fixture:`capsysbinary`,
+    :fixture:`capfd` and :fixture:`capfdbinary` fixtures."""
+
+    def __init__(
+        self, captureclass, request: SubRequest, *, _ispytest: bool = False
+    ) -> None:
+        check_ispytest(_ispytest)
+        self.captureclass = captureclass
+        self.request = request
+        self._capture: Optional[MultiCapture[AnyStr]] = None
+        self._captured_out = self.captureclass.EMPTY_BUFFER
+        self._captured_err = self.captureclass.EMPTY_BUFFER
+
+    def _start(self) -> None:
+        if self._capture is None:
+            self._capture = MultiCapture(
+                in_=None, out=self.captureclass(1), err=self.captureclass(2),
+            )
+            self._capture.start_capturing()
+
+    def close(self) -> None:
+        if self._capture is not None:
+            out, err = self._capture.pop_outerr_to_orig()
+            self._captured_out += out
+            self._captured_err += err
+            self._capture.stop_capturing()
+            self._capture = None
+
+    def readouterr(self) -> CaptureResult[AnyStr]:
+        """Read and return the captured output so far, resetting the internal
+        buffer.
+
+        :returns:
+            The captured content as a namedtuple with ``out`` and ``err``
+            string attributes.
+        """
+        captured_out, captured_err = self._captured_out, self._captured_err
+        if self._capture is not None:
+            out, err = self._capture.readouterr()
+            captured_out += out
+            captured_err += err
+        self._captured_out = self.captureclass.EMPTY_BUFFER
+        self._captured_err = self.captureclass.EMPTY_BUFFER
+        return CaptureResult(captured_out, captured_err)
+
+    def _suspend(self) -> None:
+        """Suspend this fixture's own capturing temporarily."""
+        if self._capture is not None:
+            self._capture.suspend_capturing()
+
+    def _resume(self) -> None:
+        """Resume this fixture's own capturing temporarily."""
+        if self._capture is not None:
+            self._capture.resume_capturing()
+
+    def _is_started(self) -> bool:
+        """Whether actively capturing -- not disabled or closed."""
+        if self._capture is not None:
+            return self._capture.is_started()
+        return False
+
+    @contextlib.contextmanager
+    def disabled(self) -> Generator[None, None, None]:
+        """Temporarily disable capturing while inside the ``with`` block."""
+        capmanager = self.request.config.pluginmanager.getplugin("capturemanager")
+        with capmanager.global_and_fixture_disabled():
+            yield
+
+
+# The fixtures.
+
+
+@fixture
+def capsys(request: SubRequest) -> Generator[CaptureFixture[str], None, None]:
+    """Enable text capturing of writes to ``sys.stdout`` and ``sys.stderr``.
+
+    The captured output is made available via ``capsys.readouterr()`` method
+    calls, which return a ``(out, err)`` namedtuple.
+    ``out`` and ``err`` will be ``text`` objects.
+    """
+    capman = request.config.pluginmanager.getplugin("capturemanager")
+    capture_fixture = CaptureFixture[str](SysCapture, request, _ispytest=True)
+    capman.set_fixture(capture_fixture)
+    capture_fixture._start()
+    yield capture_fixture
+    capture_fixture.close()
+    capman.unset_fixture()
+
+
+@fixture
+def capsysbinary(request: SubRequest) -> Generator[CaptureFixture[bytes], None, None]:
+    """Enable bytes capturing of writes to ``sys.stdout`` and ``sys.stderr``.
+
+    The captured output is made available via ``capsysbinary.readouterr()``
+    method calls, which return a ``(out, err)`` namedtuple.
+    ``out`` and ``err`` will be ``bytes`` objects.
+    """
+    capman = request.config.pluginmanager.getplugin("capturemanager")
+    capture_fixture = CaptureFixture[bytes](SysCaptureBinary, request, _ispytest=True)
+    capman.set_fixture(capture_fixture)
+    capture_fixture._start()
+    yield capture_fixture
+    capture_fixture.close()
+    capman.unset_fixture()
+
+
+@fixture
+def capfd(request: SubRequest) -> Generator[CaptureFixture[str], None, None]:
+    """Enable text capturing of writes to file descriptors ``1`` and ``2``.
+
+    The captured output is made available via ``capfd.readouterr()`` method
+    calls, which return a ``(out, err)`` namedtuple.
+    ``out`` and ``err`` will be ``text`` objects.
+    """
+    capman = request.config.pluginmanager.getplugin("capturemanager")
+    capture_fixture = CaptureFixture[str](FDCapture, request, _ispytest=True)
+    capman.set_fixture(capture_fixture)
+    capture_fixture._start()
+    yield capture_fixture
+    capture_fixture.close()
+    capman.unset_fixture()
+
+
+@fixture
+def capfdbinary(request: SubRequest) -> Generator[CaptureFixture[bytes], None, None]:
+    """Enable bytes capturing of writes to file descriptors ``1`` and ``2``.
+
+    The captured output is made available via ``capfd.readouterr()`` method
+    calls, which return a ``(out, err)`` namedtuple.
+    ``out`` and ``err`` will be ``byte`` objects.
+    """
+    capman = request.config.pluginmanager.getplugin("capturemanager")
+    capture_fixture = CaptureFixture[bytes](FDCaptureBinary, request, _ispytest=True)
+    capman.set_fixture(capture_fixture)
+    capture_fixture._start()
+    yield capture_fixture
+    capture_fixture.close()
+    capman.unset_fixture()
diff --git a/myenv/lib/python3.9/site-packages/_pytest/compat.py b/myenv/lib/python3.9/site-packages/_pytest/compat.py
new file mode 100644
index 0000000..c7f86ea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/compat.py
@@ -0,0 +1,400 @@
+"""Python version compatibility code."""
+import enum
+import functools
+import inspect
+import re
+import sys
+from contextlib import contextmanager
+from inspect import Parameter
+from inspect import signature
+from pathlib import Path
+from typing import Any
+from typing import Callable
+from typing import Generic
+from typing import Optional
+from typing import Tuple
+from typing import TYPE_CHECKING
+from typing import TypeVar
+from typing import Union
+
+import attr
+
+from _pytest.outcomes import fail
+from _pytest.outcomes import TEST_OUTCOME
+
+if TYPE_CHECKING:
+    from typing import NoReturn
+    from typing_extensions import Final
+
+
+_T = TypeVar("_T")
+_S = TypeVar("_S")
+
+
+# fmt: off
+# Singleton type for NOTSET, as described in:
+# https://www.python.org/dev/peps/pep-0484/#support-for-singleton-types-in-unions
+class NotSetType(enum.Enum):
+    token = 0
+NOTSET: "Final" = NotSetType.token  # noqa: E305
+# fmt: on
+
+if sys.version_info >= (3, 8):
+    from importlib import metadata as importlib_metadata
+else:
+    import importlib_metadata  # noqa: F401
+
+
+def _format_args(func: Callable[..., Any]) -> str:
+    return str(signature(func))
+
+
+# The type of re.compile objects is not exposed in Python.
+REGEX_TYPE = type(re.compile(""))
+
+
+def is_generator(func: object) -> bool:
+    genfunc = inspect.isgeneratorfunction(func)
+    return genfunc and not iscoroutinefunction(func)
+
+
+def iscoroutinefunction(func: object) -> bool:
+    """Return True if func is a coroutine function (a function defined with async
+    def syntax, and doesn't contain yield), or a function decorated with
+    @asyncio.coroutine.
+
+    Note: copied and modified from Python 3.5's builtin couroutines.py to avoid
+    importing asyncio directly, which in turns also initializes the "logging"
+    module as a side-effect (see issue #8).
+    """
+    return inspect.iscoroutinefunction(func) or getattr(func, "_is_coroutine", False)
+
+
+def is_async_function(func: object) -> bool:
+    """Return True if the given function seems to be an async function or
+    an async generator."""
+    return iscoroutinefunction(func) or inspect.isasyncgenfunction(func)
+
+
+def getlocation(function, curdir: Optional[str] = None) -> str:
+    function = get_real_func(function)
+    fn = Path(inspect.getfile(function))
+    lineno = function.__code__.co_firstlineno
+    if curdir is not None:
+        try:
+            relfn = fn.relative_to(curdir)
+        except ValueError:
+            pass
+        else:
+            return "%s:%d" % (relfn, lineno + 1)
+    return "%s:%d" % (fn, lineno + 1)
+
+
+def num_mock_patch_args(function) -> int:
+    """Return number of arguments used up by mock arguments (if any)."""
+    patchings = getattr(function, "patchings", None)
+    if not patchings:
+        return 0
+
+    mock_sentinel = getattr(sys.modules.get("mock"), "DEFAULT", object())
+    ut_mock_sentinel = getattr(sys.modules.get("unittest.mock"), "DEFAULT", object())
+
+    return len(
+        [
+            p
+            for p in patchings
+            if not p.attribute_name
+            and (p.new is mock_sentinel or p.new is ut_mock_sentinel)
+        ]
+    )
+
+
+def getfuncargnames(
+    function: Callable[..., Any],
+    *,
+    name: str = "",
+    is_method: bool = False,
+    cls: Optional[type] = None,
+) -> Tuple[str, ...]:
+    """Return the names of a function's mandatory arguments.
+
+    Should return the names of all function arguments that:
+    * Aren't bound to an instance or type as in instance or class methods.
+    * Don't have default values.
+    * Aren't bound with functools.partial.
+    * Aren't replaced with mocks.
+
+    The is_method and cls arguments indicate that the function should
+    be treated as a bound method even though it's not unless, only in
+    the case of cls, the function is a static method.
+
+    The name parameter should be the original name in which the function was collected.
+    """
+    # TODO(RonnyPfannschmidt): This function should be refactored when we
+    # revisit fixtures. The fixture mechanism should ask the node for
+    # the fixture names, and not try to obtain directly from the
+    # function object well after collection has occurred.
+
+    # The parameters attribute of a Signature object contains an
+    # ordered mapping of parameter names to Parameter instances.  This
+    # creates a tuple of the names of the parameters that don't have
+    # defaults.
+    try:
+        parameters = signature(function).parameters
+    except (ValueError, TypeError) as e:
+        fail(
+            f"Could not determine arguments of {function!r}: {e}", pytrace=False,
+        )
+
+    arg_names = tuple(
+        p.name
+        for p in parameters.values()
+        if (
+            p.kind is Parameter.POSITIONAL_OR_KEYWORD
+            or p.kind is Parameter.KEYWORD_ONLY
+        )
+        and p.default is Parameter.empty
+    )
+    if not name:
+        name = function.__name__
+
+    # If this function should be treated as a bound method even though
+    # it's passed as an unbound method or function, remove the first
+    # parameter name.
+    if is_method or (
+        cls and not isinstance(cls.__dict__.get(name, None), staticmethod)
+    ):
+        arg_names = arg_names[1:]
+    # Remove any names that will be replaced with mocks.
+    if hasattr(function, "__wrapped__"):
+        arg_names = arg_names[num_mock_patch_args(function) :]
+    return arg_names
+
+
+if sys.version_info < (3, 7):
+
+    @contextmanager
+    def nullcontext():
+        yield
+
+
+else:
+    from contextlib import nullcontext as nullcontext  # noqa: F401
+
+
+def get_default_arg_names(function: Callable[..., Any]) -> Tuple[str, ...]:
+    # Note: this code intentionally mirrors the code at the beginning of
+    # getfuncargnames, to get the arguments which were excluded from its result
+    # because they had default values.
+    return tuple(
+        p.name
+        for p in signature(function).parameters.values()
+        if p.kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY)
+        and p.default is not Parameter.empty
+    )
+
+
+_non_printable_ascii_translate_table = {
+    i: f"\\x{i:02x}" for i in range(128) if i not in range(32, 127)
+}
+_non_printable_ascii_translate_table.update(
+    {ord("\t"): "\\t", ord("\r"): "\\r", ord("\n"): "\\n"}
+)
+
+
+def _translate_non_printable(s: str) -> str:
+    return s.translate(_non_printable_ascii_translate_table)
+
+
+STRING_TYPES = bytes, str
+
+
+def _bytes_to_ascii(val: bytes) -> str:
+    return val.decode("ascii", "backslashreplace")
+
+
+def ascii_escaped(val: Union[bytes, str]) -> str:
+    r"""If val is pure ASCII, return it as an str, otherwise, escape
+    bytes objects into a sequence of escaped bytes:
+
+    b'\xc3\xb4\xc5\xd6' -> r'\xc3\xb4\xc5\xd6'
+
+    and escapes unicode objects into a sequence of escaped unicode
+    ids, e.g.:
+
+    r'4\nV\U00043efa\x0eMXWB\x1e\u3028\u15fd\xcd\U0007d944'
+
+    Note:
+       The obvious "v.decode('unicode-escape')" will return
+       valid UTF-8 unicode if it finds them in bytes, but we
+       want to return escaped bytes for any byte, even if they match
+       a UTF-8 string.
+    """
+    if isinstance(val, bytes):
+        ret = _bytes_to_ascii(val)
+    else:
+        ret = val.encode("unicode_escape").decode("ascii")
+    return _translate_non_printable(ret)
+
+
+@attr.s
+class _PytestWrapper:
+    """Dummy wrapper around a function object for internal use only.
+
+    Used to correctly unwrap the underlying function object when we are
+    creating fixtures, because we wrap the function object ourselves with a
+    decorator to issue warnings when the fixture function is called directly.
+    """
+
+    obj = attr.ib()
+
+
+def get_real_func(obj):
+    """Get the real function object of the (possibly) wrapped object by
+    functools.wraps or functools.partial."""
+    start_obj = obj
+    for i in range(100):
+        # __pytest_wrapped__ is set by @pytest.fixture when wrapping the fixture function
+        # to trigger a warning if it gets called directly instead of by pytest: we don't
+        # want to unwrap further than this otherwise we lose useful wrappings like @mock.patch (#3774)
+        new_obj = getattr(obj, "__pytest_wrapped__", None)
+        if isinstance(new_obj, _PytestWrapper):
+            obj = new_obj.obj
+            break
+        new_obj = getattr(obj, "__wrapped__", None)
+        if new_obj is None:
+            break
+        obj = new_obj
+    else:
+        from _pytest._io.saferepr import saferepr
+
+        raise ValueError(
+            ("could not find real function of {start}\nstopped at {current}").format(
+                start=saferepr(start_obj), current=saferepr(obj)
+            )
+        )
+    if isinstance(obj, functools.partial):
+        obj = obj.func
+    return obj
+
+
+def get_real_method(obj, holder):
+    """Attempt to obtain the real function object that might be wrapping
+    ``obj``, while at the same time returning a bound method to ``holder`` if
+    the original object was a bound method."""
+    try:
+        is_method = hasattr(obj, "__func__")
+        obj = get_real_func(obj)
+    except Exception:  # pragma: no cover
+        return obj
+    if is_method and hasattr(obj, "__get__") and callable(obj.__get__):
+        obj = obj.__get__(holder)
+    return obj
+
+
+def getimfunc(func):
+    try:
+        return func.__func__
+    except AttributeError:
+        return func
+
+
+def safe_getattr(object: Any, name: str, default: Any) -> Any:
+    """Like getattr but return default upon any Exception or any OutcomeException.
+
+    Attribute access can potentially fail for 'evil' Python objects.
+    See issue #214.
+    It catches OutcomeException because of #2490 (issue #580), new outcomes
+    are derived from BaseException instead of Exception (for more details
+    check #2707).
+    """
+    try:
+        return getattr(object, name, default)
+    except TEST_OUTCOME:
+        return default
+
+
+def safe_isclass(obj: object) -> bool:
+    """Ignore any exception via isinstance on Python 3."""
+    try:
+        return inspect.isclass(obj)
+    except Exception:
+        return False
+
+
+if TYPE_CHECKING:
+    if sys.version_info >= (3, 8):
+        from typing import final as final
+    else:
+        from typing_extensions import final as final
+elif sys.version_info >= (3, 8):
+    from typing import final as final
+else:
+
+    def final(f):
+        return f
+
+
+if sys.version_info >= (3, 8):
+    from functools import cached_property as cached_property
+else:
+    from typing import overload
+    from typing import Type
+
+    class cached_property(Generic[_S, _T]):
+        __slots__ = ("func", "__doc__")
+
+        def __init__(self, func: Callable[[_S], _T]) -> None:
+            self.func = func
+            self.__doc__ = func.__doc__
+
+        @overload
+        def __get__(
+            self, instance: None, owner: Optional[Type[_S]] = ...
+        ) -> "cached_property[_S, _T]":
+            ...
+
+        @overload
+        def __get__(self, instance: _S, owner: Optional[Type[_S]] = ...) -> _T:
+            ...
+
+        def __get__(self, instance, owner=None):
+            if instance is None:
+                return self
+            value = instance.__dict__[self.func.__name__] = self.func(instance)
+            return value
+
+
+# Perform exhaustiveness checking.
+#
+# Consider this example:
+#
+#     MyUnion = Union[int, str]
+#
+#     def handle(x: MyUnion) -> int {
+#         if isinstance(x, int):
+#             return 1
+#         elif isinstance(x, str):
+#             return 2
+#         else:
+#             raise Exception('unreachable')
+#
+# Now suppose we add a new variant:
+#
+#     MyUnion = Union[int, str, bytes]
+#
+# After doing this, we must remember ourselves to go and update the handle
+# function to handle the new variant.
+#
+# With `assert_never` we can do better:
+#
+#     // raise Exception('unreachable')
+#     return assert_never(x)
+#
+# Now, if we forget to handle the new variant, the type-checker will emit a
+# compile-time error, instead of the runtime error we would have gotten
+# previously.
+#
+# This also work for Enums (if you use `is` to compare) and Literals.
+def assert_never(value: "NoReturn") -> "NoReturn":
+    assert False, "Unhandled value: {} ({})".format(value, type(value).__name__)
diff --git a/myenv/lib/python3.9/site-packages/_pytest/config/__init__.py b/myenv/lib/python3.9/site-packages/_pytest/config/__init__.py
new file mode 100644
index 0000000..bd9e288
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/config/__init__.py
@@ -0,0 +1,1606 @@
+"""Command line options, ini-file and conftest.py processing."""
+import argparse
+import collections.abc
+import contextlib
+import copy
+import enum
+import inspect
+import os
+import re
+import shlex
+import sys
+import types
+import warnings
+from functools import lru_cache
+from pathlib import Path
+from types import TracebackType
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import Generator
+from typing import IO
+from typing import Iterable
+from typing import Iterator
+from typing import List
+from typing import Optional
+from typing import Sequence
+from typing import Set
+from typing import TextIO
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import Union
+
+import attr
+import py
+from pluggy import HookimplMarker
+from pluggy import HookspecMarker
+from pluggy import PluginManager
+
+import _pytest._code
+import _pytest.deprecated
+import _pytest.hookspec
+from .exceptions import PrintHelp as PrintHelp
+from .exceptions import UsageError as UsageError
+from .findpaths import determine_setup
+from _pytest._code import ExceptionInfo
+from _pytest._code import filter_traceback
+from _pytest._io import TerminalWriter
+from _pytest.compat import final
+from _pytest.compat import importlib_metadata
+from _pytest.outcomes import fail
+from _pytest.outcomes import Skipped
+from _pytest.pathlib import bestrelpath
+from _pytest.pathlib import import_path
+from _pytest.pathlib import ImportMode
+from _pytest.store import Store
+from _pytest.warning_types import PytestConfigWarning
+
+if TYPE_CHECKING:
+
+    from _pytest._code.code import _TracebackStyle
+    from _pytest.terminal import TerminalReporter
+    from .argparsing import Argument
+
+
+_PluggyPlugin = object
+"""A type to represent plugin objects.
+
+Plugins can be any namespace, so we can't narrow it down much, but we use an
+alias to make the intent clear.
+
+Ideally this type would be provided by pluggy itself.
+"""
+
+
+hookimpl = HookimplMarker("pytest")
+hookspec = HookspecMarker("pytest")
+
+
+@final
+class ExitCode(enum.IntEnum):
+    """Encodes the valid exit codes by pytest.
+
+    Currently users and plugins may supply other exit codes as well.
+
+    .. versionadded:: 5.0
+    """
+
+    #: Tests passed.
+    OK = 0
+    #: Tests failed.
+    TESTS_FAILED = 1
+    #: pytest was interrupted.
+    INTERRUPTED = 2
+    #: An internal error got in the way.
+    INTERNAL_ERROR = 3
+    #: pytest was misused.
+    USAGE_ERROR = 4
+    #: pytest couldn't find tests.
+    NO_TESTS_COLLECTED = 5
+
+
+class ConftestImportFailure(Exception):
+    def __init__(
+        self,
+        path: py.path.local,
+        excinfo: Tuple[Type[Exception], Exception, TracebackType],
+    ) -> None:
+        super().__init__(path, excinfo)
+        self.path = path
+        self.excinfo = excinfo
+
+    def __str__(self) -> str:
+        return "{}: {} (from {})".format(
+            self.excinfo[0].__name__, self.excinfo[1], self.path
+        )
+
+
+def filter_traceback_for_conftest_import_failure(
+    entry: _pytest._code.TracebackEntry,
+) -> bool:
+    """Filter tracebacks entries which point to pytest internals or importlib.
+
+    Make a special case for importlib because we use it to import test modules and conftest files
+    in _pytest.pathlib.import_path.
+    """
+    return filter_traceback(entry) and "importlib" not in str(entry.path).split(os.sep)
+
+
+def main(
+    args: Optional[Union[List[str], py.path.local]] = None,
+    plugins: Optional[Sequence[Union[str, _PluggyPlugin]]] = None,
+) -> Union[int, ExitCode]:
+    """Perform an in-process test run.
+
+    :param args: List of command line arguments.
+    :param plugins: List of plugin objects to be auto-registered during initialization.
+
+    :returns: An exit code.
+    """
+    try:
+        try:
+            config = _prepareconfig(args, plugins)
+        except ConftestImportFailure as e:
+            exc_info = ExceptionInfo(e.excinfo)
+            tw = TerminalWriter(sys.stderr)
+            tw.line(f"ImportError while loading conftest '{e.path}'.", red=True)
+            exc_info.traceback = exc_info.traceback.filter(
+                filter_traceback_for_conftest_import_failure
+            )
+            exc_repr = (
+                exc_info.getrepr(style="short", chain=False)
+                if exc_info.traceback
+                else exc_info.exconly()
+            )
+            formatted_tb = str(exc_repr)
+            for line in formatted_tb.splitlines():
+                tw.line(line.rstrip(), red=True)
+            return ExitCode.USAGE_ERROR
+        else:
+            try:
+                ret: Union[ExitCode, int] = config.hook.pytest_cmdline_main(
+                    config=config
+                )
+                try:
+                    return ExitCode(ret)
+                except ValueError:
+                    return ret
+            finally:
+                config._ensure_unconfigure()
+    except UsageError as e:
+        tw = TerminalWriter(sys.stderr)
+        for msg in e.args:
+            tw.line(f"ERROR: {msg}\n", red=True)
+        return ExitCode.USAGE_ERROR
+
+
+def console_main() -> int:
+    """The CLI entry point of pytest.
+
+    This function is not meant for programmable use; use `main()` instead.
+    """
+    # https://docs.python.org/3/library/signal.html#note-on-sigpipe
+    try:
+        code = main()
+        sys.stdout.flush()
+        return code
+    except BrokenPipeError:
+        # Python flushes standard streams on exit; redirect remaining output
+        # to devnull to avoid another BrokenPipeError at shutdown
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+        return 1  # Python exits with error code 1 on EPIPE
+
+
+class cmdline:  # compatibility namespace
+    main = staticmethod(main)
+
+
+def filename_arg(path: str, optname: str) -> str:
+    """Argparse type validator for filename arguments.
+
+    :path: Path of filename.
+    :optname: Name of the option.
+    """
+    if os.path.isdir(path):
+        raise UsageError(f"{optname} must be a filename, given: {path}")
+    return path
+
+
+def directory_arg(path: str, optname: str) -> str:
+    """Argparse type validator for directory arguments.
+
+    :path: Path of directory.
+    :optname: Name of the option.
+    """
+    if not os.path.isdir(path):
+        raise UsageError(f"{optname} must be a directory, given: {path}")
+    return path
+
+
+# Plugins that cannot be disabled via "-p no:X" currently.
+essential_plugins = (
+    "mark",
+    "main",
+    "runner",
+    "fixtures",
+    "helpconfig",  # Provides -p.
+)
+
+default_plugins = essential_plugins + (
+    "python",
+    "terminal",
+    "debugging",
+    "unittest",
+    "capture",
+    "skipping",
+    "tmpdir",
+    "monkeypatch",
+    "recwarn",
+    "pastebin",
+    "nose",
+    "assertion",
+    "junitxml",
+    "doctest",
+    "cacheprovider",
+    "freeze_support",
+    "setuponly",
+    "setupplan",
+    "stepwise",
+    "warnings",
+    "logging",
+    "reports",
+    *(["unraisableexception", "threadexception"] if sys.version_info >= (3, 8) else []),
+    "faulthandler",
+)
+
+builtin_plugins = set(default_plugins)
+builtin_plugins.add("pytester")
+builtin_plugins.add("pytester_assertions")
+
+
+def get_config(
+    args: Optional[List[str]] = None,
+    plugins: Optional[Sequence[Union[str, _PluggyPlugin]]] = None,
+) -> "Config":
+    # subsequent calls to main will create a fresh instance
+    pluginmanager = PytestPluginManager()
+    config = Config(
+        pluginmanager,
+        invocation_params=Config.InvocationParams(
+            args=args or (), plugins=plugins, dir=Path.cwd(),
+        ),
+    )
+
+    if args is not None:
+        # Handle any "-p no:plugin" args.
+        pluginmanager.consider_preparse(args, exclude_only=True)
+
+    for spec in default_plugins:
+        pluginmanager.import_plugin(spec)
+
+    return config
+
+
+def get_plugin_manager() -> "PytestPluginManager":
+    """Obtain a new instance of the
+    :py:class:`_pytest.config.PytestPluginManager`, with default plugins
+    already loaded.
+
+    This function can be used by integration with other tools, like hooking
+    into pytest to run tests into an IDE.
+    """
+    return get_config().pluginmanager
+
+
+def _prepareconfig(
+    args: Optional[Union[py.path.local, List[str]]] = None,
+    plugins: Optional[Sequence[Union[str, _PluggyPlugin]]] = None,
+) -> "Config":
+    if args is None:
+        args = sys.argv[1:]
+    elif isinstance(args, py.path.local):
+        args = [str(args)]
+    elif not isinstance(args, list):
+        msg = "`args` parameter expected to be a list of strings, got: {!r} (type: {})"
+        raise TypeError(msg.format(args, type(args)))
+
+    config = get_config(args, plugins)
+    pluginmanager = config.pluginmanager
+    try:
+        if plugins:
+            for plugin in plugins:
+                if isinstance(plugin, str):
+                    pluginmanager.consider_pluginarg(plugin)
+                else:
+                    pluginmanager.register(plugin)
+        config = pluginmanager.hook.pytest_cmdline_parse(
+            pluginmanager=pluginmanager, args=args
+        )
+        return config
+    except BaseException:
+        config._ensure_unconfigure()
+        raise
+
+
+@final
+class PytestPluginManager(PluginManager):
+    """A :py:class:`pluggy.PluginManager <pluggy.PluginManager>` with
+    additional pytest-specific functionality:
+
+    * Loading plugins from the command line, ``PYTEST_PLUGINS`` env variable and
+      ``pytest_plugins`` global variables found in plugins being loaded.
+    * ``conftest.py`` loading during start-up.
+    """
+
+    def __init__(self) -> None:
+        import _pytest.assertion
+
+        super().__init__("pytest")
+        # The objects are module objects, only used generically.
+        self._conftest_plugins: Set[types.ModuleType] = set()
+
+        # State related to local conftest plugins.
+        self._dirpath2confmods: Dict[py.path.local, List[types.ModuleType]] = {}
+        self._conftestpath2mod: Dict[Path, types.ModuleType] = {}
+        self._confcutdir: Optional[py.path.local] = None
+        self._noconftest = False
+        self._duplicatepaths: Set[py.path.local] = set()
+
+        # plugins that were explicitly skipped with pytest.skip
+        # list of (module name, skip reason)
+        # previously we would issue a warning when a plugin was skipped, but
+        # since we refactored warnings as first citizens of Config, they are
+        # just stored here to be used later.
+        self.skipped_plugins: List[Tuple[str, str]] = []
+
+        self.add_hookspecs(_pytest.hookspec)
+        self.register(self)
+        if os.environ.get("PYTEST_DEBUG"):
+            err: IO[str] = sys.stderr
+            encoding: str = getattr(err, "encoding", "utf8")
+            try:
+                err = open(
+                    os.dup(err.fileno()), mode=err.mode, buffering=1, encoding=encoding,
+                )
+            except Exception:
+                pass
+            self.trace.root.setwriter(err.write)
+            self.enable_tracing()
+
+        # Config._consider_importhook will set a real object if required.
+        self.rewrite_hook = _pytest.assertion.DummyRewriteHook()
+        # Used to know when we are importing conftests after the pytest_configure stage.
+        self._configured = False
+
+    def parse_hookimpl_opts(self, plugin: _PluggyPlugin, name: str):
+        # pytest hooks are always prefixed with "pytest_",
+        # so we avoid accessing possibly non-readable attributes
+        # (see issue #1073).
+        if not name.startswith("pytest_"):
+            return
+        # Ignore names which can not be hooks.
+        if name == "pytest_plugins":
+            return
+
+        method = getattr(plugin, name)
+        opts = super().parse_hookimpl_opts(plugin, name)
+
+        # Consider only actual functions for hooks (#3775).
+        if not inspect.isroutine(method):
+            return
+
+        # Collect unmarked hooks as long as they have the `pytest_' prefix.
+        if opts is None and name.startswith("pytest_"):
+            opts = {}
+        if opts is not None:
+            # TODO: DeprecationWarning, people should use hookimpl
+            # https://github.com/pytest-dev/pytest/issues/4562
+            known_marks = {m.name for m in getattr(method, "pytestmark", [])}
+
+            for name in ("tryfirst", "trylast", "optionalhook", "hookwrapper"):
+                opts.setdefault(name, hasattr(method, name) or name in known_marks)
+        return opts
+
+    def parse_hookspec_opts(self, module_or_class, name: str):
+        opts = super().parse_hookspec_opts(module_or_class, name)
+        if opts is None:
+            method = getattr(module_or_class, name)
+
+            if name.startswith("pytest_"):
+                # todo: deprecate hookspec hacks
+                # https://github.com/pytest-dev/pytest/issues/4562
+                known_marks = {m.name for m in getattr(method, "pytestmark", [])}
+                opts = {
+                    "firstresult": hasattr(method, "firstresult")
+                    or "firstresult" in known_marks,
+                    "historic": hasattr(method, "historic")
+                    or "historic" in known_marks,
+                }
+        return opts
+
+    def register(
+        self, plugin: _PluggyPlugin, name: Optional[str] = None
+    ) -> Optional[str]:
+        if name in _pytest.deprecated.DEPRECATED_EXTERNAL_PLUGINS:
+            warnings.warn(
+                PytestConfigWarning(
+                    "{} plugin has been merged into the core, "
+                    "please remove it from your requirements.".format(
+                        name.replace("_", "-")
+                    )
+                )
+            )
+            return None
+        ret: Optional[str] = super().register(plugin, name)
+        if ret:
+            self.hook.pytest_plugin_registered.call_historic(
+                kwargs=dict(plugin=plugin, manager=self)
+            )
+
+            if isinstance(plugin, types.ModuleType):
+                self.consider_module(plugin)
+        return ret
+
+    def getplugin(self, name: str):
+        # Support deprecated naming because plugins (xdist e.g.) use it.
+        plugin: Optional[_PluggyPlugin] = self.get_plugin(name)
+        return plugin
+
+    def hasplugin(self, name: str) -> bool:
+        """Return whether a plugin with the given name is registered."""
+        return bool(self.get_plugin(name))
+
+    def pytest_configure(self, config: "Config") -> None:
+        """:meta private:"""
+        # XXX now that the pluginmanager exposes hookimpl(tryfirst...)
+        # we should remove tryfirst/trylast as markers.
+        config.addinivalue_line(
+            "markers",
+            "tryfirst: mark a hook implementation function such that the "
+            "plugin machinery will try to call it first/as early as possible.",
+        )
+        config.addinivalue_line(
+            "markers",
+            "trylast: mark a hook implementation function such that the "
+            "plugin machinery will try to call it last/as late as possible.",
+        )
+        self._configured = True
+
+    #
+    # Internal API for local conftest plugin handling.
+    #
+    def _set_initial_conftests(self, namespace: argparse.Namespace) -> None:
+        """Load initial conftest files given a preparsed "namespace".
+
+        As conftest files may add their own command line options which have
+        arguments ('--my-opt somepath') we might get some false positives.
+        All builtin and 3rd party plugins will have been loaded, however, so
+        common options will not confuse our logic here.
+        """
+        current = py.path.local()
+        self._confcutdir = (
+            current.join(namespace.confcutdir, abs=True)
+            if namespace.confcutdir
+            else None
+        )
+        self._noconftest = namespace.noconftest
+        self._using_pyargs = namespace.pyargs
+        testpaths = namespace.file_or_dir
+        foundanchor = False
+        for testpath in testpaths:
+            path = str(testpath)
+            # remove node-id syntax
+            i = path.find("::")
+            if i != -1:
+                path = path[:i]
+            anchor = current.join(path, abs=1)
+            if anchor.exists():  # we found some file object
+                self._try_load_conftest(anchor, namespace.importmode)
+                foundanchor = True
+        if not foundanchor:
+            self._try_load_conftest(current, namespace.importmode)
+
+    def _try_load_conftest(
+        self, anchor: py.path.local, importmode: Union[str, ImportMode]
+    ) -> None:
+        self._getconftestmodules(anchor, importmode)
+        # let's also consider test* subdirs
+        if anchor.check(dir=1):
+            for x in anchor.listdir("test*"):
+                if x.check(dir=1):
+                    self._getconftestmodules(x, importmode)
+
+    @lru_cache(maxsize=128)
+    def _getconftestmodules(
+        self, path: py.path.local, importmode: Union[str, ImportMode],
+    ) -> List[types.ModuleType]:
+        if self._noconftest:
+            return []
+
+        if path.isfile():
+            directory = path.dirpath()
+        else:
+            directory = path
+
+        # XXX these days we may rather want to use config.rootpath
+        # and allow users to opt into looking into the rootdir parent
+        # directories instead of requiring to specify confcutdir.
+        clist = []
+        for parent in directory.parts():
+            if self._confcutdir and self._confcutdir.relto(parent):
+                continue
+            conftestpath = parent.join("conftest.py")
+            if conftestpath.isfile():
+                mod = self._importconftest(conftestpath, importmode)
+                clist.append(mod)
+        self._dirpath2confmods[directory] = clist
+        return clist
+
+    def _rget_with_confmod(
+        self, name: str, path: py.path.local, importmode: Union[str, ImportMode],
+    ) -> Tuple[types.ModuleType, Any]:
+        modules = self._getconftestmodules(path, importmode)
+        for mod in reversed(modules):
+            try:
+                return mod, getattr(mod, name)
+            except AttributeError:
+                continue
+        raise KeyError(name)
+
+    def _importconftest(
+        self, conftestpath: py.path.local, importmode: Union[str, ImportMode],
+    ) -> types.ModuleType:
+        # Use a resolved Path object as key to avoid loading the same conftest
+        # twice with build systems that create build directories containing
+        # symlinks to actual files.
+        # Using Path().resolve() is better than py.path.realpath because
+        # it resolves to the correct path/drive in case-insensitive file systems (#5792)
+        key = Path(str(conftestpath)).resolve()
+
+        with contextlib.suppress(KeyError):
+            return self._conftestpath2mod[key]
+
+        pkgpath = conftestpath.pypkgpath()
+        if pkgpath is None:
+            _ensure_removed_sysmodule(conftestpath.purebasename)
+
+        try:
+            mod = import_path(conftestpath, mode=importmode)
+        except Exception as e:
+            assert e.__traceback__ is not None
+            exc_info = (type(e), e, e.__traceback__)
+            raise ConftestImportFailure(conftestpath, exc_info) from e
+
+        self._check_non_top_pytest_plugins(mod, conftestpath)
+
+        self._conftest_plugins.add(mod)
+        self._conftestpath2mod[key] = mod
+        dirpath = conftestpath.dirpath()
+        if dirpath in self._dirpath2confmods:
+            for path, mods in self._dirpath2confmods.items():
+                if path and path.relto(dirpath) or path == dirpath:
+                    assert mod not in mods
+                    mods.append(mod)
+        self.trace(f"loading conftestmodule {mod!r}")
+        self.consider_conftest(mod)
+        return mod
+
+    def _check_non_top_pytest_plugins(
+        self, mod: types.ModuleType, conftestpath: py.path.local,
+    ) -> None:
+        if (
+            hasattr(mod, "pytest_plugins")
+            and self._configured
+            and not self._using_pyargs
+        ):
+            msg = (
+                "Defining 'pytest_plugins' in a non-top-level conftest is no longer supported:\n"
+                "It affects the entire test suite instead of just below the conftest as expected.\n"
+                "  {}\n"
+                "Please move it to a top level conftest file at the rootdir:\n"
+                "  {}\n"
+                "For more information, visit:\n"
+                "  https://docs.pytest.org/en/stable/deprecations.html#pytest-plugins-in-non-top-level-conftest-files"
+            )
+            fail(msg.format(conftestpath, self._confcutdir), pytrace=False)
+
+    #
+    # API for bootstrapping plugin loading
+    #
+    #
+
+    def consider_preparse(
+        self, args: Sequence[str], *, exclude_only: bool = False
+    ) -> None:
+        i = 0
+        n = len(args)
+        while i < n:
+            opt = args[i]
+            i += 1
+            if isinstance(opt, str):
+                if opt == "-p":
+                    try:
+                        parg = args[i]
+                    except IndexError:
+                        return
+                    i += 1
+                elif opt.startswith("-p"):
+                    parg = opt[2:]
+                else:
+                    continue
+                if exclude_only and not parg.startswith("no:"):
+                    continue
+                self.consider_pluginarg(parg)
+
+    def consider_pluginarg(self, arg: str) -> None:
+        if arg.startswith("no:"):
+            name = arg[3:]
+            if name in essential_plugins:
+                raise UsageError("plugin %s cannot be disabled" % name)
+
+            # PR #4304: remove stepwise if cacheprovider is blocked.
+            if name == "cacheprovider":
+                self.set_blocked("stepwise")
+                self.set_blocked("pytest_stepwise")
+
+            self.set_blocked(name)
+            if not name.startswith("pytest_"):
+                self.set_blocked("pytest_" + name)
+        else:
+            name = arg
+            # Unblock the plugin.  None indicates that it has been blocked.
+            # There is no interface with pluggy for this.
+            if self._name2plugin.get(name, -1) is None:
+                del self._name2plugin[name]
+            if not name.startswith("pytest_"):
+                if self._name2plugin.get("pytest_" + name, -1) is None:
+                    del self._name2plugin["pytest_" + name]
+            self.import_plugin(arg, consider_entry_points=True)
+
+    def consider_conftest(self, conftestmodule: types.ModuleType) -> None:
+        self.register(conftestmodule, name=conftestmodule.__file__)
+
+    def consider_env(self) -> None:
+        self._import_plugin_specs(os.environ.get("PYTEST_PLUGINS"))
+
+    def consider_module(self, mod: types.ModuleType) -> None:
+        self._import_plugin_specs(getattr(mod, "pytest_plugins", []))
+
+    def _import_plugin_specs(
+        self, spec: Union[None, types.ModuleType, str, Sequence[str]]
+    ) -> None:
+        plugins = _get_plugin_specs_as_list(spec)
+        for import_spec in plugins:
+            self.import_plugin(import_spec)
+
+    def import_plugin(self, modname: str, consider_entry_points: bool = False) -> None:
+        """Import a plugin with ``modname``.
+
+        If ``consider_entry_points`` is True, entry point names are also
+        considered to find a plugin.
+        """
+        # Most often modname refers to builtin modules, e.g. "pytester",
+        # "terminal" or "capture".  Those plugins are registered under their
+        # basename for historic purposes but must be imported with the
+        # _pytest prefix.
+        assert isinstance(modname, str), (
+            "module name as text required, got %r" % modname
+        )
+        if self.is_blocked(modname) or self.get_plugin(modname) is not None:
+            return
+
+        importspec = "_pytest." + modname if modname in builtin_plugins else modname
+        self.rewrite_hook.mark_rewrite(importspec)
+
+        if consider_entry_points:
+            loaded = self.load_setuptools_entrypoints("pytest11", name=modname)
+            if loaded:
+                return
+
+        try:
+            __import__(importspec)
+        except ImportError as e:
+            raise ImportError(
+                'Error importing plugin "{}": {}'.format(modname, str(e.args[0]))
+            ).with_traceback(e.__traceback__) from e
+
+        except Skipped as e:
+            self.skipped_plugins.append((modname, e.msg or ""))
+        else:
+            mod = sys.modules[importspec]
+            self.register(mod, modname)
+
+
+def _get_plugin_specs_as_list(
+    specs: Union[None, types.ModuleType, str, Sequence[str]]
+) -> List[str]:
+    """Parse a plugins specification into a list of plugin names."""
+    # None means empty.
+    if specs is None:
+        return []
+    # Workaround for #3899 - a submodule which happens to be called "pytest_plugins".
+    if isinstance(specs, types.ModuleType):
+        return []
+    # Comma-separated list.
+    if isinstance(specs, str):
+        return specs.split(",") if specs else []
+    # Direct specification.
+    if isinstance(specs, collections.abc.Sequence):
+        return list(specs)
+    raise UsageError(
+        "Plugins may be specified as a sequence or a ','-separated string of plugin names. Got: %r"
+        % specs
+    )
+
+
+def _ensure_removed_sysmodule(modname: str) -> None:
+    try:
+        del sys.modules[modname]
+    except KeyError:
+        pass
+
+
+class Notset:
+    def __repr__(self):
+        return "<NOTSET>"
+
+
+notset = Notset()
+
+
+def _iter_rewritable_modules(package_files: Iterable[str]) -> Iterator[str]:
+    """Given an iterable of file names in a source distribution, return the "names" that should
+    be marked for assertion rewrite.
+
+    For example the package "pytest_mock/__init__.py" should be added as "pytest_mock" in
+    the assertion rewrite mechanism.
+
+    This function has to deal with dist-info based distributions and egg based distributions
+    (which are still very much in use for "editable" installs).
+
+    Here are the file names as seen in a dist-info based distribution:
+
+        pytest_mock/__init__.py
+        pytest_mock/_version.py
+        pytest_mock/plugin.py
+        pytest_mock.egg-info/PKG-INFO
+
+    Here are the file names as seen in an egg based distribution:
+
+        src/pytest_mock/__init__.py
+        src/pytest_mock/_version.py
+        src/pytest_mock/plugin.py
+        src/pytest_mock.egg-info/PKG-INFO
+        LICENSE
+        setup.py
+
+    We have to take in account those two distribution flavors in order to determine which
+    names should be considered for assertion rewriting.
+
+    More information:
+        https://github.com/pytest-dev/pytest-mock/issues/167
+    """
+    package_files = list(package_files)
+    seen_some = False
+    for fn in package_files:
+        is_simple_module = "/" not in fn and fn.endswith(".py")
+        is_package = fn.count("/") == 1 and fn.endswith("__init__.py")
+        if is_simple_module:
+            module_name, _ = os.path.splitext(fn)
+            # we ignore "setup.py" at the root of the distribution
+            if module_name != "setup":
+                seen_some = True
+                yield module_name
+        elif is_package:
+            package_name = os.path.dirname(fn)
+            seen_some = True
+            yield package_name
+
+    if not seen_some:
+        # At this point we did not find any packages or modules suitable for assertion
+        # rewriting, so we try again by stripping the first path component (to account for
+        # "src" based source trees for example).
+        # This approach lets us have the common case continue to be fast, as egg-distributions
+        # are rarer.
+        new_package_files = []
+        for fn in package_files:
+            parts = fn.split("/")
+            new_fn = "/".join(parts[1:])
+            if new_fn:
+                new_package_files.append(new_fn)
+        if new_package_files:
+            yield from _iter_rewritable_modules(new_package_files)
+
+
+def _args_converter(args: Iterable[str]) -> Tuple[str, ...]:
+    return tuple(args)
+
+
+@final
+class Config:
+    """Access to configuration values, pluginmanager and plugin hooks.
+
+    :param PytestPluginManager pluginmanager:
+
+    :param InvocationParams invocation_params:
+        Object containing parameters regarding the :func:`pytest.main`
+        invocation.
+    """
+
+    @final
+    @attr.s(frozen=True)
+    class InvocationParams:
+        """Holds parameters passed during :func:`pytest.main`.
+
+        The object attributes are read-only.
+
+        .. versionadded:: 5.1
+
+        .. note::
+
+            Note that the environment variable ``PYTEST_ADDOPTS`` and the ``addopts``
+            ini option are handled by pytest, not being included in the ``args`` attribute.
+
+            Plugins accessing ``InvocationParams`` must be aware of that.
+        """
+
+        args = attr.ib(type=Tuple[str, ...], converter=_args_converter)
+        """The command-line arguments as passed to :func:`pytest.main`.
+
+        :type: Tuple[str, ...]
+        """
+        plugins = attr.ib(type=Optional[Sequence[Union[str, _PluggyPlugin]]])
+        """Extra plugins, might be `None`.
+
+        :type: Optional[Sequence[Union[str, plugin]]]
+        """
+        dir = attr.ib(type=Path)
+        """The directory from which :func:`pytest.main` was invoked.
+
+        :type: pathlib.Path
+        """
+
+    def __init__(
+        self,
+        pluginmanager: PytestPluginManager,
+        *,
+        invocation_params: Optional[InvocationParams] = None,
+    ) -> None:
+        from .argparsing import Parser, FILE_OR_DIR
+
+        if invocation_params is None:
+            invocation_params = self.InvocationParams(
+                args=(), plugins=None, dir=Path.cwd()
+            )
+
+        self.option = argparse.Namespace()
+        """Access to command line option as attributes.
+
+        :type: argparse.Namespace
+        """
+
+        self.invocation_params = invocation_params
+        """The parameters with which pytest was invoked.
+
+        :type: InvocationParams
+        """
+
+        _a = FILE_OR_DIR
+        self._parser = Parser(
+            usage=f"%(prog)s [options] [{_a}] [{_a}] [...]",
+            processopt=self._processopt,
+        )
+        self.pluginmanager = pluginmanager
+        """The plugin manager handles plugin registration and hook invocation.
+
+        :type: PytestPluginManager
+        """
+
+        self.trace = self.pluginmanager.trace.root.get("config")
+        self.hook = self.pluginmanager.hook
+        self._inicache: Dict[str, Any] = {}
+        self._override_ini: Sequence[str] = ()
+        self._opt2dest: Dict[str, str] = {}
+        self._cleanup: List[Callable[[], None]] = []
+        # A place where plugins can store information on the config for their
+        # own use. Currently only intended for internal plugins.
+        self._store = Store()
+        self.pluginmanager.register(self, "pytestconfig")
+        self._configured = False
+        self.hook.pytest_addoption.call_historic(
+            kwargs=dict(parser=self._parser, pluginmanager=self.pluginmanager)
+        )
+
+        if TYPE_CHECKING:
+            from _pytest.cacheprovider import Cache
+
+            self.cache: Optional[Cache] = None
+
+    @property
+    def invocation_dir(self) -> py.path.local:
+        """The directory from which pytest was invoked.
+
+        Prefer to use :attr:`invocation_params.dir <InvocationParams.dir>`,
+        which is a :class:`pathlib.Path`.
+
+        :type: py.path.local
+        """
+        return py.path.local(str(self.invocation_params.dir))
+
+    @property
+    def rootpath(self) -> Path:
+        """The path to the :ref:`rootdir <rootdir>`.
+
+        :type: pathlib.Path
+
+        .. versionadded:: 6.1
+        """
+        return self._rootpath
+
+    @property
+    def rootdir(self) -> py.path.local:
+        """The path to the :ref:`rootdir <rootdir>`.
+
+        Prefer to use :attr:`rootpath`, which is a :class:`pathlib.Path`.
+
+        :type: py.path.local
+        """
+        return py.path.local(str(self.rootpath))
+
+    @property
+    def inipath(self) -> Optional[Path]:
+        """The path to the :ref:`configfile <configfiles>`.
+
+        :type: Optional[pathlib.Path]
+
+        .. versionadded:: 6.1
+        """
+        return self._inipath
+
+    @property
+    def inifile(self) -> Optional[py.path.local]:
+        """The path to the :ref:`configfile <configfiles>`.
+
+        Prefer to use :attr:`inipath`, which is a :class:`pathlib.Path`.
+
+        :type: Optional[py.path.local]
+        """
+        return py.path.local(str(self.inipath)) if self.inipath else None
+
+    def add_cleanup(self, func: Callable[[], None]) -> None:
+        """Add a function to be called when the config object gets out of
+        use (usually coninciding with pytest_unconfigure)."""
+        self._cleanup.append(func)
+
+    def _do_configure(self) -> None:
+        assert not self._configured
+        self._configured = True
+        with warnings.catch_warnings():
+            warnings.simplefilter("default")
+            self.hook.pytest_configure.call_historic(kwargs=dict(config=self))
+
+    def _ensure_unconfigure(self) -> None:
+        if self._configured:
+            self._configured = False
+            self.hook.pytest_unconfigure(config=self)
+            self.hook.pytest_configure._call_history = []
+        while self._cleanup:
+            fin = self._cleanup.pop()
+            fin()
+
+    def get_terminal_writer(self) -> TerminalWriter:
+        terminalreporter: TerminalReporter = self.pluginmanager.get_plugin(
+            "terminalreporter"
+        )
+        return terminalreporter._tw
+
+    def pytest_cmdline_parse(
+        self, pluginmanager: PytestPluginManager, args: List[str]
+    ) -> "Config":
+        try:
+            self.parse(args)
+        except UsageError:
+
+            # Handle --version and --help here in a minimal fashion.
+            # This gets done via helpconfig normally, but its
+            # pytest_cmdline_main is not called in case of errors.
+            if getattr(self.option, "version", False) or "--version" in args:
+                from _pytest.helpconfig import showversion
+
+                showversion(self)
+            elif (
+                getattr(self.option, "help", False) or "--help" in args or "-h" in args
+            ):
+                self._parser._getparser().print_help()
+                sys.stdout.write(
+                    "\nNOTE: displaying only minimal help due to UsageError.\n\n"
+                )
+
+            raise
+
+        return self
+
+    def notify_exception(
+        self,
+        excinfo: ExceptionInfo[BaseException],
+        option: Optional[argparse.Namespace] = None,
+    ) -> None:
+        if option and getattr(option, "fulltrace", False):
+            style: _TracebackStyle = "long"
+        else:
+            style = "native"
+        excrepr = excinfo.getrepr(
+            funcargs=True, showlocals=getattr(option, "showlocals", False), style=style
+        )
+        res = self.hook.pytest_internalerror(excrepr=excrepr, excinfo=excinfo)
+        if not any(res):
+            for line in str(excrepr).split("\n"):
+                sys.stderr.write("INTERNALERROR> %s\n" % line)
+                sys.stderr.flush()
+
+    def cwd_relative_nodeid(self, nodeid: str) -> str:
+        # nodeid's are relative to the rootpath, compute relative to cwd.
+        if self.invocation_params.dir != self.rootpath:
+            fullpath = self.rootpath / nodeid
+            nodeid = bestrelpath(self.invocation_params.dir, fullpath)
+        return nodeid
+
+    @classmethod
+    def fromdictargs(cls, option_dict, args) -> "Config":
+        """Constructor usable for subprocesses."""
+        config = get_config(args)
+        config.option.__dict__.update(option_dict)
+        config.parse(args, addopts=False)
+        for x in config.option.plugins:
+            config.pluginmanager.consider_pluginarg(x)
+        return config
+
+    def _processopt(self, opt: "Argument") -> None:
+        for name in opt._short_opts + opt._long_opts:
+            self._opt2dest[name] = opt.dest
+
+        if hasattr(opt, "default"):
+            if not hasattr(self.option, opt.dest):
+                setattr(self.option, opt.dest, opt.default)
+
+    @hookimpl(trylast=True)
+    def pytest_load_initial_conftests(self, early_config: "Config") -> None:
+        self.pluginmanager._set_initial_conftests(early_config.known_args_namespace)
+
+    def _initini(self, args: Sequence[str]) -> None:
+        ns, unknown_args = self._parser.parse_known_and_unknown_args(
+            args, namespace=copy.copy(self.option)
+        )
+        rootpath, inipath, inicfg = determine_setup(
+            ns.inifilename,
+            ns.file_or_dir + unknown_args,
+            rootdir_cmd_arg=ns.rootdir or None,
+            config=self,
+        )
+        self._rootpath = rootpath
+        self._inipath = inipath
+        self.inicfg = inicfg
+        self._parser.extra_info["rootdir"] = str(self.rootpath)
+        self._parser.extra_info["inifile"] = str(self.inipath)
+        self._parser.addini("addopts", "extra command line options", "args")
+        self._parser.addini("minversion", "minimally required pytest version")
+        self._parser.addini(
+            "required_plugins",
+            "plugins that must be present for pytest to run",
+            type="args",
+            default=[],
+        )
+        self._override_ini = ns.override_ini or ()
+
+    def _consider_importhook(self, args: Sequence[str]) -> None:
+        """Install the PEP 302 import hook if using assertion rewriting.
+
+        Needs to parse the --assert=<mode> option from the commandline
+        and find all the installed plugins to mark them for rewriting
+        by the importhook.
+        """
+        ns, unknown_args = self._parser.parse_known_and_unknown_args(args)
+        mode = getattr(ns, "assertmode", "plain")
+        if mode == "rewrite":
+            import _pytest.assertion
+
+            try:
+                hook = _pytest.assertion.install_importhook(self)
+            except SystemError:
+                mode = "plain"
+            else:
+                self._mark_plugins_for_rewrite(hook)
+        self._warn_about_missing_assertion(mode)
+
+    def _mark_plugins_for_rewrite(self, hook) -> None:
+        """Given an importhook, mark for rewrite any top-level
+        modules or packages in the distribution package for
+        all pytest plugins."""
+        self.pluginmanager.rewrite_hook = hook
+
+        if os.environ.get("PYTEST_DISABLE_PLUGIN_AUTOLOAD"):
+            # We don't autoload from setuptools entry points, no need to continue.
+            return
+
+        package_files = (
+            str(file)
+            for dist in importlib_metadata.distributions()
+            if any(ep.group == "pytest11" for ep in dist.entry_points)
+            for file in dist.files or []
+        )
+
+        for name in _iter_rewritable_modules(package_files):
+            hook.mark_rewrite(name)
+
+    def _validate_args(self, args: List[str], via: str) -> List[str]:
+        """Validate known args."""
+        self._parser._config_source_hint = via  # type: ignore
+        try:
+            self._parser.parse_known_and_unknown_args(
+                args, namespace=copy.copy(self.option)
+            )
+        finally:
+            del self._parser._config_source_hint  # type: ignore
+
+        return args
+
+    def _preparse(self, args: List[str], addopts: bool = True) -> None:
+        if addopts:
+            env_addopts = os.environ.get("PYTEST_ADDOPTS", "")
+            if len(env_addopts):
+                args[:] = (
+                    self._validate_args(shlex.split(env_addopts), "via PYTEST_ADDOPTS")
+                    + args
+                )
+        self._initini(args)
+        if addopts:
+            args[:] = (
+                self._validate_args(self.getini("addopts"), "via addopts config") + args
+            )
+
+        self.known_args_namespace = self._parser.parse_known_args(
+            args, namespace=copy.copy(self.option)
+        )
+        self._checkversion()
+        self._consider_importhook(args)
+        self.pluginmanager.consider_preparse(args, exclude_only=False)
+        if not os.environ.get("PYTEST_DISABLE_PLUGIN_AUTOLOAD"):
+            # Don't autoload from setuptools entry point. Only explicitly specified
+            # plugins are going to be loaded.
+            self.pluginmanager.load_setuptools_entrypoints("pytest11")
+        self.pluginmanager.consider_env()
+
+        self.known_args_namespace = self._parser.parse_known_args(
+            args, namespace=copy.copy(self.known_args_namespace)
+        )
+
+        self._validate_plugins()
+        self._warn_about_skipped_plugins()
+
+        if self.known_args_namespace.strict:
+            self.issue_config_time_warning(
+                _pytest.deprecated.STRICT_OPTION, stacklevel=2
+            )
+
+        if self.known_args_namespace.confcutdir is None and self.inipath is not None:
+            confcutdir = str(self.inipath.parent)
+            self.known_args_namespace.confcutdir = confcutdir
+        try:
+            self.hook.pytest_load_initial_conftests(
+                early_config=self, args=args, parser=self._parser
+            )
+        except ConftestImportFailure as e:
+            if self.known_args_namespace.help or self.known_args_namespace.version:
+                # we don't want to prevent --help/--version to work
+                # so just let is pass and print a warning at the end
+                self.issue_config_time_warning(
+                    PytestConfigWarning(f"could not load initial conftests: {e.path}"),
+                    stacklevel=2,
+                )
+            else:
+                raise
+
+    @hookimpl(hookwrapper=True)
+    def pytest_collection(self) -> Generator[None, None, None]:
+        """Validate invalid ini keys after collection is done so we take in account
+        options added by late-loading conftest files."""
+        yield
+        self._validate_config_options()
+
+    def _checkversion(self) -> None:
+        import pytest
+
+        minver = self.inicfg.get("minversion", None)
+        if minver:
+            # Imported lazily to improve start-up time.
+            from packaging.version import Version
+
+            if not isinstance(minver, str):
+                raise pytest.UsageError(
+                    "%s: 'minversion' must be a single value" % self.inipath
+                )
+
+            if Version(minver) > Version(pytest.__version__):
+                raise pytest.UsageError(
+                    "%s: 'minversion' requires pytest-%s, actual pytest-%s'"
+                    % (self.inipath, minver, pytest.__version__,)
+                )
+
+    def _validate_config_options(self) -> None:
+        for key in sorted(self._get_unknown_ini_keys()):
+            self._warn_or_fail_if_strict(f"Unknown config option: {key}\n")
+
+    def _validate_plugins(self) -> None:
+        required_plugins = sorted(self.getini("required_plugins"))
+        if not required_plugins:
+            return
+
+        # Imported lazily to improve start-up time.
+        from packaging.version import Version
+        from packaging.requirements import InvalidRequirement, Requirement
+
+        plugin_info = self.pluginmanager.list_plugin_distinfo()
+        plugin_dist_info = {dist.project_name: dist.version for _, dist in plugin_info}
+
+        missing_plugins = []
+        for required_plugin in required_plugins:
+            try:
+                spec = Requirement(required_plugin)
+            except InvalidRequirement:
+                missing_plugins.append(required_plugin)
+                continue
+
+            if spec.name not in plugin_dist_info:
+                missing_plugins.append(required_plugin)
+            elif Version(plugin_dist_info[spec.name]) not in spec.specifier:
+                missing_plugins.append(required_plugin)
+
+        if missing_plugins:
+            raise UsageError(
+                "Missing required plugins: {}".format(", ".join(missing_plugins)),
+            )
+
+    def _warn_or_fail_if_strict(self, message: str) -> None:
+        if self.known_args_namespace.strict_config:
+            raise UsageError(message)
+
+        self.issue_config_time_warning(PytestConfigWarning(message), stacklevel=3)
+
+    def _get_unknown_ini_keys(self) -> List[str]:
+        parser_inicfg = self._parser._inidict
+        return [name for name in self.inicfg if name not in parser_inicfg]
+
+    def parse(self, args: List[str], addopts: bool = True) -> None:
+        # Parse given cmdline arguments into this config object.
+        assert not hasattr(
+            self, "args"
+        ), "can only parse cmdline args at most once per Config object"
+        self.hook.pytest_addhooks.call_historic(
+            kwargs=dict(pluginmanager=self.pluginmanager)
+        )
+        self._preparse(args, addopts=addopts)
+        # XXX deprecated hook:
+        self.hook.pytest_cmdline_preparse(config=self, args=args)
+        self._parser.after_preparse = True  # type: ignore
+        try:
+            args = self._parser.parse_setoption(
+                args, self.option, namespace=self.option
+            )
+            if not args:
+                if self.invocation_params.dir == self.rootpath:
+                    args = self.getini("testpaths")
+                if not args:
+                    args = [str(self.invocation_params.dir)]
+            self.args = args
+        except PrintHelp:
+            pass
+
+    def issue_config_time_warning(self, warning: Warning, stacklevel: int) -> None:
+        """Issue and handle a warning during the "configure" stage.
+
+        During ``pytest_configure`` we can't capture warnings using the ``catch_warnings_for_item``
+        function because it is not possible to have hookwrappers around ``pytest_configure``.
+
+        This function is mainly intended for plugins that need to issue warnings during
+        ``pytest_configure`` (or similar stages).
+
+        :param warning: The warning instance.
+        :param stacklevel: stacklevel forwarded to warnings.warn.
+        """
+        if self.pluginmanager.is_blocked("warnings"):
+            return
+
+        cmdline_filters = self.known_args_namespace.pythonwarnings or []
+        config_filters = self.getini("filterwarnings")
+
+        with warnings.catch_warnings(record=True) as records:
+            warnings.simplefilter("always", type(warning))
+            apply_warning_filters(config_filters, cmdline_filters)
+            warnings.warn(warning, stacklevel=stacklevel)
+
+        if records:
+            frame = sys._getframe(stacklevel - 1)
+            location = frame.f_code.co_filename, frame.f_lineno, frame.f_code.co_name
+            self.hook.pytest_warning_captured.call_historic(
+                kwargs=dict(
+                    warning_message=records[0],
+                    when="config",
+                    item=None,
+                    location=location,
+                )
+            )
+            self.hook.pytest_warning_recorded.call_historic(
+                kwargs=dict(
+                    warning_message=records[0],
+                    when="config",
+                    nodeid="",
+                    location=location,
+                )
+            )
+
+    def addinivalue_line(self, name: str, line: str) -> None:
+        """Add a line to an ini-file option. The option must have been
+        declared but might not yet be set in which case the line becomes
+        the first line in its value."""
+        x = self.getini(name)
+        assert isinstance(x, list)
+        x.append(line)  # modifies the cached list inline
+
+    def getini(self, name: str):
+        """Return configuration value from an :ref:`ini file <configfiles>`.
+
+        If the specified name hasn't been registered through a prior
+        :py:func:`parser.addini <_pytest.config.argparsing.Parser.addini>`
+        call (usually from a plugin), a ValueError is raised.
+        """
+        try:
+            return self._inicache[name]
+        except KeyError:
+            self._inicache[name] = val = self._getini(name)
+            return val
+
+    def _getini(self, name: str):
+        try:
+            description, type, default = self._parser._inidict[name]
+        except KeyError as e:
+            raise ValueError(f"unknown configuration value: {name!r}") from e
+        override_value = self._get_override_ini_value(name)
+        if override_value is None:
+            try:
+                value = self.inicfg[name]
+            except KeyError:
+                if default is not None:
+                    return default
+                if type is None:
+                    return ""
+                return []
+        else:
+            value = override_value
+        # Coerce the values based on types.
+        #
+        # Note: some coercions are only required if we are reading from .ini files, because
+        # the file format doesn't contain type information, but when reading from toml we will
+        # get either str or list of str values (see _parse_ini_config_from_pyproject_toml).
+        # For example:
+        #
+        #   ini:
+        #     a_line_list = "tests acceptance"
+        #   in this case, we need to split the string to obtain a list of strings.
+        #
+        #   toml:
+        #     a_line_list = ["tests", "acceptance"]
+        #   in this case, we already have a list ready to use.
+        #
+        if type == "pathlist":
+            # TODO: This assert is probably not valid in all cases.
+            assert self.inipath is not None
+            dp = self.inipath.parent
+            input_values = shlex.split(value) if isinstance(value, str) else value
+            return [py.path.local(str(dp / x)) for x in input_values]
+        elif type == "args":
+            return shlex.split(value) if isinstance(value, str) else value
+        elif type == "linelist":
+            if isinstance(value, str):
+                return [t for t in map(lambda x: x.strip(), value.split("\n")) if t]
+            else:
+                return value
+        elif type == "bool":
+            return _strtobool(str(value).strip())
+        else:
+            assert type in [None, "string"]
+            return value
+
+    def _getconftest_pathlist(
+        self, name: str, path: py.path.local
+    ) -> Optional[List[py.path.local]]:
+        try:
+            mod, relroots = self.pluginmanager._rget_with_confmod(
+                name, path, self.getoption("importmode")
+            )
+        except KeyError:
+            return None
+        modpath = py.path.local(mod.__file__).dirpath()
+        values: List[py.path.local] = []
+        for relroot in relroots:
+            if not isinstance(relroot, py.path.local):
+                relroot = relroot.replace("/", os.sep)
+                relroot = modpath.join(relroot, abs=True)
+            values.append(relroot)
+        return values
+
+    def _get_override_ini_value(self, name: str) -> Optional[str]:
+        value = None
+        # override_ini is a list of "ini=value" options.
+        # Always use the last item if multiple values are set for same ini-name,
+        # e.g. -o foo=bar1 -o foo=bar2 will set foo to bar2.
+        for ini_config in self._override_ini:
+            try:
+                key, user_ini_value = ini_config.split("=", 1)
+            except ValueError as e:
+                raise UsageError(
+                    "-o/--override-ini expects option=value style (got: {!r}).".format(
+                        ini_config
+                    )
+                ) from e
+            else:
+                if key == name:
+                    value = user_ini_value
+        return value
+
+    def getoption(self, name: str, default=notset, skip: bool = False):
+        """Return command line option value.
+
+        :param name: Name of the option.  You may also specify
+            the literal ``--OPT`` option instead of the "dest" option name.
+        :param default: Default value if no option of that name exists.
+        :param skip: If True, raise pytest.skip if option does not exists
+            or has a None value.
+        """
+        name = self._opt2dest.get(name, name)
+        try:
+            val = getattr(self.option, name)
+            if val is None and skip:
+                raise AttributeError(name)
+            return val
+        except AttributeError as e:
+            if default is not notset:
+                return default
+            if skip:
+                import pytest
+
+                pytest.skip(f"no {name!r} option found")
+            raise ValueError(f"no option named {name!r}") from e
+
+    def getvalue(self, name: str, path=None):
+        """Deprecated, use getoption() instead."""
+        return self.getoption(name)
+
+    def getvalueorskip(self, name: str, path=None):
+        """Deprecated, use getoption(skip=True) instead."""
+        return self.getoption(name, skip=True)
+
+    def _warn_about_missing_assertion(self, mode: str) -> None:
+        if not _assertion_supported():
+            if mode == "plain":
+                warning_text = (
+                    "ASSERTIONS ARE NOT EXECUTED"
+                    " and FAILING TESTS WILL PASS.  Are you"
+                    " using python -O?"
+                )
+            else:
+                warning_text = (
+                    "assertions not in test modules or"
+                    " plugins will be ignored"
+                    " because assert statements are not executed "
+                    "by the underlying Python interpreter "
+                    "(are you using python -O?)\n"
+                )
+            self.issue_config_time_warning(
+                PytestConfigWarning(warning_text), stacklevel=3,
+            )
+
+    def _warn_about_skipped_plugins(self) -> None:
+        for module_name, msg in self.pluginmanager.skipped_plugins:
+            self.issue_config_time_warning(
+                PytestConfigWarning(f"skipped plugin {module_name!r}: {msg}"),
+                stacklevel=2,
+            )
+
+
+def _assertion_supported() -> bool:
+    try:
+        assert False
+    except AssertionError:
+        return True
+    else:
+        return False  # type: ignore[unreachable]
+
+
+def create_terminal_writer(
+    config: Config, file: Optional[TextIO] = None
+) -> TerminalWriter:
+    """Create a TerminalWriter instance configured according to the options
+    in the config object.
+
+    Every code which requires a TerminalWriter object and has access to a
+    config object should use this function.
+    """
+    tw = TerminalWriter(file=file)
+
+    if config.option.color == "yes":
+        tw.hasmarkup = True
+    elif config.option.color == "no":
+        tw.hasmarkup = False
+
+    if config.option.code_highlight == "yes":
+        tw.code_highlight = True
+    elif config.option.code_highlight == "no":
+        tw.code_highlight = False
+
+    return tw
+
+
+def _strtobool(val: str) -> bool:
+    """Convert a string representation of truth to True or False.
+
+    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
+    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
+    'val' is anything else.
+
+    .. note:: Copied from distutils.util.
+    """
+    val = val.lower()
+    if val in ("y", "yes", "t", "true", "on", "1"):
+        return True
+    elif val in ("n", "no", "f", "false", "off", "0"):
+        return False
+    else:
+        raise ValueError(f"invalid truth value {val!r}")
+
+
+@lru_cache(maxsize=50)
+def parse_warning_filter(
+    arg: str, *, escape: bool
+) -> Tuple[str, str, Type[Warning], str, int]:
+    """Parse a warnings filter string.
+
+    This is copied from warnings._setoption, but does not apply the filter,
+    only parses it, and makes the escaping optional.
+    """
+    parts = arg.split(":")
+    if len(parts) > 5:
+        raise warnings._OptionError(f"too many fields (max 5): {arg!r}")
+    while len(parts) < 5:
+        parts.append("")
+    action_, message, category_, module, lineno_ = [s.strip() for s in parts]
+    action: str = warnings._getaction(action_)  # type: ignore[attr-defined]
+    category: Type[Warning] = warnings._getcategory(category_)  # type: ignore[attr-defined]
+    if message and escape:
+        message = re.escape(message)
+    if module and escape:
+        module = re.escape(module) + r"\Z"
+    if lineno_:
+        try:
+            lineno = int(lineno_)
+            if lineno < 0:
+                raise ValueError
+        except (ValueError, OverflowError) as e:
+            raise warnings._OptionError(f"invalid lineno {lineno_!r}") from e
+    else:
+        lineno = 0
+    return action, message, category, module, lineno
+
+
+def apply_warning_filters(
+    config_filters: Iterable[str], cmdline_filters: Iterable[str]
+) -> None:
+    """Applies pytest-configured filters to the warnings module"""
+    # Filters should have this precedence: cmdline options, config.
+    # Filters should be applied in the inverse order of precedence.
+    for arg in config_filters:
+        warnings.filterwarnings(*parse_warning_filter(arg, escape=False))
+
+    for arg in cmdline_filters:
+        warnings.filterwarnings(*parse_warning_filter(arg, escape=True))
diff --git a/myenv/lib/python3.9/site-packages/_pytest/config/argparsing.py b/myenv/lib/python3.9/site-packages/_pytest/config/argparsing.py
new file mode 100644
index 0000000..9a48196
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/config/argparsing.py
@@ -0,0 +1,522 @@
+import argparse
+import sys
+import warnings
+from gettext import gettext
+from typing import Any
+from typing import Callable
+from typing import cast
+from typing import Dict
+from typing import List
+from typing import Mapping
+from typing import Optional
+from typing import Sequence
+from typing import Tuple
+from typing import TYPE_CHECKING
+from typing import Union
+
+import py
+
+import _pytest._io
+from _pytest.compat import final
+from _pytest.config.exceptions import UsageError
+
+if TYPE_CHECKING:
+    from typing import NoReturn
+    from typing_extensions import Literal
+
+FILE_OR_DIR = "file_or_dir"
+
+
+@final
+class Parser:
+    """Parser for command line arguments and ini-file values.
+
+    :ivar extra_info: Dict of generic param -> value to display in case
+        there's an error processing the command line arguments.
+    """
+
+    prog: Optional[str] = None
+
+    def __init__(
+        self,
+        usage: Optional[str] = None,
+        processopt: Optional[Callable[["Argument"], None]] = None,
+    ) -> None:
+        self._anonymous = OptionGroup("custom options", parser=self)
+        self._groups: List[OptionGroup] = []
+        self._processopt = processopt
+        self._usage = usage
+        self._inidict: Dict[str, Tuple[str, Optional[str], Any]] = {}
+        self._ininames: List[str] = []
+        self.extra_info: Dict[str, Any] = {}
+
+    def processoption(self, option: "Argument") -> None:
+        if self._processopt:
+            if option.dest:
+                self._processopt(option)
+
+    def getgroup(
+        self, name: str, description: str = "", after: Optional[str] = None
+    ) -> "OptionGroup":
+        """Get (or create) a named option Group.
+
+        :name: Name of the option group.
+        :description: Long description for --help output.
+        :after: Name of another group, used for ordering --help output.
+
+        The returned group object has an ``addoption`` method with the same
+        signature as :py:func:`parser.addoption
+        <_pytest.config.argparsing.Parser.addoption>` but will be shown in the
+        respective group in the output of ``pytest. --help``.
+        """
+        for group in self._groups:
+            if group.name == name:
+                return group
+        group = OptionGroup(name, description, parser=self)
+        i = 0
+        for i, grp in enumerate(self._groups):
+            if grp.name == after:
+                break
+        self._groups.insert(i + 1, group)
+        return group
+
+    def addoption(self, *opts: str, **attrs: Any) -> None:
+        """Register a command line option.
+
+        :opts: Option names, can be short or long options.
+        :attrs: Same attributes which the ``add_argument()`` function of the
+           `argparse library <https://docs.python.org/library/argparse.html>`_
+           accepts.
+
+        After command line parsing, options are available on the pytest config
+        object via ``config.option.NAME`` where ``NAME`` is usually set
+        by passing a ``dest`` attribute, for example
+        ``addoption("--long", dest="NAME", ...)``.
+        """
+        self._anonymous.addoption(*opts, **attrs)
+
+    def parse(
+        self,
+        args: Sequence[Union[str, py.path.local]],
+        namespace: Optional[argparse.Namespace] = None,
+    ) -> argparse.Namespace:
+        from _pytest._argcomplete import try_argcomplete
+
+        self.optparser = self._getparser()
+        try_argcomplete(self.optparser)
+        strargs = [str(x) if isinstance(x, py.path.local) else x for x in args]
+        return self.optparser.parse_args(strargs, namespace=namespace)
+
+    def _getparser(self) -> "MyOptionParser":
+        from _pytest._argcomplete import filescompleter
+
+        optparser = MyOptionParser(self, self.extra_info, prog=self.prog)
+        groups = self._groups + [self._anonymous]
+        for group in groups:
+            if group.options:
+                desc = group.description or group.name
+                arggroup = optparser.add_argument_group(desc)
+                for option in group.options:
+                    n = option.names()
+                    a = option.attrs()
+                    arggroup.add_argument(*n, **a)
+        file_or_dir_arg = optparser.add_argument(FILE_OR_DIR, nargs="*")
+        # bash like autocompletion for dirs (appending '/')
+        # Type ignored because typeshed doesn't know about argcomplete.
+        file_or_dir_arg.completer = filescompleter  # type: ignore
+        return optparser
+
+    def parse_setoption(
+        self,
+        args: Sequence[Union[str, py.path.local]],
+        option: argparse.Namespace,
+        namespace: Optional[argparse.Namespace] = None,
+    ) -> List[str]:
+        parsedoption = self.parse(args, namespace=namespace)
+        for name, value in parsedoption.__dict__.items():
+            setattr(option, name, value)
+        return cast(List[str], getattr(parsedoption, FILE_OR_DIR))
+
+    def parse_known_args(
+        self,
+        args: Sequence[Union[str, py.path.local]],
+        namespace: Optional[argparse.Namespace] = None,
+    ) -> argparse.Namespace:
+        """Parse and return a namespace object with known arguments at this point."""
+        return self.parse_known_and_unknown_args(args, namespace=namespace)[0]
+
+    def parse_known_and_unknown_args(
+        self,
+        args: Sequence[Union[str, py.path.local]],
+        namespace: Optional[argparse.Namespace] = None,
+    ) -> Tuple[argparse.Namespace, List[str]]:
+        """Parse and return a namespace object with known arguments, and
+        the remaining arguments unknown at this point."""
+        optparser = self._getparser()
+        strargs = [str(x) if isinstance(x, py.path.local) else x for x in args]
+        return optparser.parse_known_args(strargs, namespace=namespace)
+
+    def addini(
+        self,
+        name: str,
+        help: str,
+        type: Optional[
+            "Literal['string', 'pathlist', 'args', 'linelist', 'bool']"
+        ] = None,
+        default=None,
+    ) -> None:
+        """Register an ini-file option.
+
+        :name: Name of the ini-variable.
+        :type: Type of the variable, can be ``string``, ``pathlist``, ``args``,
+               ``linelist`` or ``bool``.  Defaults to ``string`` if ``None`` or
+               not passed.
+        :default: Default value if no ini-file option exists but is queried.
+
+        The value of ini-variables can be retrieved via a call to
+        :py:func:`config.getini(name) <_pytest.config.Config.getini>`.
+        """
+        assert type in (None, "string", "pathlist", "args", "linelist", "bool")
+        self._inidict[name] = (help, type, default)
+        self._ininames.append(name)
+
+
+class ArgumentError(Exception):
+    """Raised if an Argument instance is created with invalid or
+    inconsistent arguments."""
+
+    def __init__(self, msg: str, option: Union["Argument", str]) -> None:
+        self.msg = msg
+        self.option_id = str(option)
+
+    def __str__(self) -> str:
+        if self.option_id:
+            return f"option {self.option_id}: {self.msg}"
+        else:
+            return self.msg
+
+
+class Argument:
+    """Class that mimics the necessary behaviour of optparse.Option.
+
+    It's currently a least effort implementation and ignoring choices
+    and integer prefixes.
+
+    https://docs.python.org/3/library/optparse.html#optparse-standard-option-types
+    """
+
+    _typ_map = {"int": int, "string": str, "float": float, "complex": complex}
+
+    def __init__(self, *names: str, **attrs: Any) -> None:
+        """Store parms in private vars for use in add_argument."""
+        self._attrs = attrs
+        self._short_opts: List[str] = []
+        self._long_opts: List[str] = []
+        if "%default" in (attrs.get("help") or ""):
+            warnings.warn(
+                'pytest now uses argparse. "%default" should be'
+                ' changed to "%(default)s" ',
+                DeprecationWarning,
+                stacklevel=3,
+            )
+        try:
+            typ = attrs["type"]
+        except KeyError:
+            pass
+        else:
+            # This might raise a keyerror as well, don't want to catch that.
+            if isinstance(typ, str):
+                if typ == "choice":
+                    warnings.warn(
+                        "`type` argument to addoption() is the string %r."
+                        " For choices this is optional and can be omitted, "
+                        " but when supplied should be a type (for example `str` or `int`)."
+                        " (options: %s)" % (typ, names),
+                        DeprecationWarning,
+                        stacklevel=4,
+                    )
+                    # argparse expects a type here take it from
+                    # the type of the first element
+                    attrs["type"] = type(attrs["choices"][0])
+                else:
+                    warnings.warn(
+                        "`type` argument to addoption() is the string %r, "
+                        " but when supplied should be a type (for example `str` or `int`)."
+                        " (options: %s)" % (typ, names),
+                        DeprecationWarning,
+                        stacklevel=4,
+                    )
+                    attrs["type"] = Argument._typ_map[typ]
+                # Used in test_parseopt -> test_parse_defaultgetter.
+                self.type = attrs["type"]
+            else:
+                self.type = typ
+        try:
+            # Attribute existence is tested in Config._processopt.
+            self.default = attrs["default"]
+        except KeyError:
+            pass
+        self._set_opt_strings(names)
+        dest: Optional[str] = attrs.get("dest")
+        if dest:
+            self.dest = dest
+        elif self._long_opts:
+            self.dest = self._long_opts[0][2:].replace("-", "_")
+        else:
+            try:
+                self.dest = self._short_opts[0][1:]
+            except IndexError as e:
+                self.dest = "???"  # Needed for the error repr.
+                raise ArgumentError("need a long or short option", self) from e
+
+    def names(self) -> List[str]:
+        return self._short_opts + self._long_opts
+
+    def attrs(self) -> Mapping[str, Any]:
+        # Update any attributes set by processopt.
+        attrs = "default dest help".split()
+        attrs.append(self.dest)
+        for attr in attrs:
+            try:
+                self._attrs[attr] = getattr(self, attr)
+            except AttributeError:
+                pass
+        if self._attrs.get("help"):
+            a = self._attrs["help"]
+            a = a.replace("%default", "%(default)s")
+            # a = a.replace('%prog', '%(prog)s')
+            self._attrs["help"] = a
+        return self._attrs
+
+    def _set_opt_strings(self, opts: Sequence[str]) -> None:
+        """Directly from optparse.
+
+        Might not be necessary as this is passed to argparse later on.
+        """
+        for opt in opts:
+            if len(opt) < 2:
+                raise ArgumentError(
+                    "invalid option string %r: "
+                    "must be at least two characters long" % opt,
+                    self,
+                )
+            elif len(opt) == 2:
+                if not (opt[0] == "-" and opt[1] != "-"):
+                    raise ArgumentError(
+                        "invalid short option string %r: "
+                        "must be of the form -x, (x any non-dash char)" % opt,
+                        self,
+                    )
+                self._short_opts.append(opt)
+            else:
+                if not (opt[0:2] == "--" and opt[2] != "-"):
+                    raise ArgumentError(
+                        "invalid long option string %r: "
+                        "must start with --, followed by non-dash" % opt,
+                        self,
+                    )
+                self._long_opts.append(opt)
+
+    def __repr__(self) -> str:
+        args: List[str] = []
+        if self._short_opts:
+            args += ["_short_opts: " + repr(self._short_opts)]
+        if self._long_opts:
+            args += ["_long_opts: " + repr(self._long_opts)]
+        args += ["dest: " + repr(self.dest)]
+        if hasattr(self, "type"):
+            args += ["type: " + repr(self.type)]
+        if hasattr(self, "default"):
+            args += ["default: " + repr(self.default)]
+        return "Argument({})".format(", ".join(args))
+
+
+class OptionGroup:
+    def __init__(
+        self, name: str, description: str = "", parser: Optional[Parser] = None
+    ) -> None:
+        self.name = name
+        self.description = description
+        self.options: List[Argument] = []
+        self.parser = parser
+
+    def addoption(self, *optnames: str, **attrs: Any) -> None:
+        """Add an option to this group.
+
+        If a shortened version of a long option is specified, it will
+        be suppressed in the help. addoption('--twowords', '--two-words')
+        results in help showing '--two-words' only, but --twowords gets
+        accepted **and** the automatic destination is in args.twowords.
+        """
+        conflict = set(optnames).intersection(
+            name for opt in self.options for name in opt.names()
+        )
+        if conflict:
+            raise ValueError("option names %s already added" % conflict)
+        option = Argument(*optnames, **attrs)
+        self._addoption_instance(option, shortupper=False)
+
+    def _addoption(self, *optnames: str, **attrs: Any) -> None:
+        option = Argument(*optnames, **attrs)
+        self._addoption_instance(option, shortupper=True)
+
+    def _addoption_instance(self, option: "Argument", shortupper: bool = False) -> None:
+        if not shortupper:
+            for opt in option._short_opts:
+                if opt[0] == "-" and opt[1].islower():
+                    raise ValueError("lowercase shortoptions reserved")
+        if self.parser:
+            self.parser.processoption(option)
+        self.options.append(option)
+
+
+class MyOptionParser(argparse.ArgumentParser):
+    def __init__(
+        self,
+        parser: Parser,
+        extra_info: Optional[Dict[str, Any]] = None,
+        prog: Optional[str] = None,
+    ) -> None:
+        self._parser = parser
+        argparse.ArgumentParser.__init__(
+            self,
+            prog=prog,
+            usage=parser._usage,
+            add_help=False,
+            formatter_class=DropShorterLongHelpFormatter,
+            allow_abbrev=False,
+        )
+        # extra_info is a dict of (param -> value) to display if there's
+        # an usage error to provide more contextual information to the user.
+        self.extra_info = extra_info if extra_info else {}
+
+    def error(self, message: str) -> "NoReturn":
+        """Transform argparse error message into UsageError."""
+        msg = f"{self.prog}: error: {message}"
+
+        if hasattr(self._parser, "_config_source_hint"):
+            # Type ignored because the attribute is set dynamically.
+            msg = f"{msg} ({self._parser._config_source_hint})"  # type: ignore
+
+        raise UsageError(self.format_usage() + msg)
+
+    # Type ignored because typeshed has a very complex type in the superclass.
+    def parse_args(  # type: ignore
+        self,
+        args: Optional[Sequence[str]] = None,
+        namespace: Optional[argparse.Namespace] = None,
+    ) -> argparse.Namespace:
+        """Allow splitting of positional arguments."""
+        parsed, unrecognized = self.parse_known_args(args, namespace)
+        if unrecognized:
+            for arg in unrecognized:
+                if arg and arg[0] == "-":
+                    lines = ["unrecognized arguments: %s" % (" ".join(unrecognized))]
+                    for k, v in sorted(self.extra_info.items()):
+                        lines.append(f"  {k}: {v}")
+                    self.error("\n".join(lines))
+            getattr(parsed, FILE_OR_DIR).extend(unrecognized)
+        return parsed
+
+    if sys.version_info[:2] < (3, 9):  # pragma: no cover
+        # Backport of https://github.com/python/cpython/pull/14316 so we can
+        # disable long --argument abbreviations without breaking short flags.
+        def _parse_optional(
+            self, arg_string: str
+        ) -> Optional[Tuple[Optional[argparse.Action], str, Optional[str]]]:
+            if not arg_string:
+                return None
+            if not arg_string[0] in self.prefix_chars:
+                return None
+            if arg_string in self._option_string_actions:
+                action = self._option_string_actions[arg_string]
+                return action, arg_string, None
+            if len(arg_string) == 1:
+                return None
+            if "=" in arg_string:
+                option_string, explicit_arg = arg_string.split("=", 1)
+                if option_string in self._option_string_actions:
+                    action = self._option_string_actions[option_string]
+                    return action, option_string, explicit_arg
+            if self.allow_abbrev or not arg_string.startswith("--"):
+                option_tuples = self._get_option_tuples(arg_string)
+                if len(option_tuples) > 1:
+                    msg = gettext(
+                        "ambiguous option: %(option)s could match %(matches)s"
+                    )
+                    options = ", ".join(option for _, option, _ in option_tuples)
+                    self.error(msg % {"option": arg_string, "matches": options})
+                elif len(option_tuples) == 1:
+                    (option_tuple,) = option_tuples
+                    return option_tuple
+            if self._negative_number_matcher.match(arg_string):
+                if not self._has_negative_number_optionals:
+                    return None
+            if " " in arg_string:
+                return None
+            return None, arg_string, None
+
+
+class DropShorterLongHelpFormatter(argparse.HelpFormatter):
+    """Shorten help for long options that differ only in extra hyphens.
+
+    - Collapse **long** options that are the same except for extra hyphens.
+    - Shortcut if there are only two options and one of them is a short one.
+    - Cache result on the action object as this is called at least 2 times.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        # Use more accurate terminal width.
+        if "width" not in kwargs:
+            kwargs["width"] = _pytest._io.get_terminal_width()
+        super().__init__(*args, **kwargs)
+
+    def _format_action_invocation(self, action: argparse.Action) -> str:
+        orgstr = argparse.HelpFormatter._format_action_invocation(self, action)
+        if orgstr and orgstr[0] != "-":  # only optional arguments
+            return orgstr
+        res: Optional[str] = getattr(action, "_formatted_action_invocation", None)
+        if res:
+            return res
+        options = orgstr.split(", ")
+        if len(options) == 2 and (len(options[0]) == 2 or len(options[1]) == 2):
+            # a shortcut for '-h, --help' or '--abc', '-a'
+            action._formatted_action_invocation = orgstr  # type: ignore
+            return orgstr
+        return_list = []
+        short_long: Dict[str, str] = {}
+        for option in options:
+            if len(option) == 2 or option[2] == " ":
+                continue
+            if not option.startswith("--"):
+                raise ArgumentError(
+                    'long optional argument without "--": [%s]' % (option), option
+                )
+            xxoption = option[2:]
+            shortened = xxoption.replace("-", "")
+            if shortened not in short_long or len(short_long[shortened]) < len(
+                xxoption
+            ):
+                short_long[shortened] = xxoption
+        # now short_long has been filled out to the longest with dashes
+        # **and** we keep the right option ordering from add_argument
+        for option in options:
+            if len(option) == 2 or option[2] == " ":
+                return_list.append(option)
+            if option[2:] == short_long.get(option.replace("-", "")):
+                return_list.append(option.replace(" ", "=", 1))
+        formatted_action_invocation = ", ".join(return_list)
+        action._formatted_action_invocation = formatted_action_invocation  # type: ignore
+        return formatted_action_invocation
+
+    def _split_lines(self, text, width):
+        """Wrap lines after splitting on original newlines.
+
+        This allows to have explicit line breaks in the help text.
+        """
+        import textwrap
+
+        lines = []
+        for line in text.splitlines():
+            lines.extend(textwrap.wrap(line.strip(), width))
+        return lines
diff --git a/myenv/lib/python3.9/site-packages/_pytest/config/exceptions.py b/myenv/lib/python3.9/site-packages/_pytest/config/exceptions.py
new file mode 100644
index 0000000..4f1320e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/config/exceptions.py
@@ -0,0 +1,11 @@
+from _pytest.compat import final
+
+
+@final
+class UsageError(Exception):
+    """Error in pytest usage or invocation."""
+
+
+class PrintHelp(Exception):
+    """Raised when pytest should print its help to skip the rest of the
+    argument parsing and validation."""
diff --git a/myenv/lib/python3.9/site-packages/_pytest/config/findpaths.py b/myenv/lib/python3.9/site-packages/_pytest/config/findpaths.py
new file mode 100644
index 0000000..2edf545
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/config/findpaths.py
@@ -0,0 +1,211 @@
+import os
+from pathlib import Path
+from typing import Dict
+from typing import Iterable
+from typing import List
+from typing import Optional
+from typing import Sequence
+from typing import Tuple
+from typing import TYPE_CHECKING
+from typing import Union
+
+import iniconfig
+
+from .exceptions import UsageError
+from _pytest.outcomes import fail
+from _pytest.pathlib import absolutepath
+from _pytest.pathlib import commonpath
+
+if TYPE_CHECKING:
+    from . import Config
+
+
+def _parse_ini_config(path: Path) -> iniconfig.IniConfig:
+    """Parse the given generic '.ini' file using legacy IniConfig parser, returning
+    the parsed object.
+
+    Raise UsageError if the file cannot be parsed.
+    """
+    try:
+        return iniconfig.IniConfig(str(path))
+    except iniconfig.ParseError as exc:
+        raise UsageError(str(exc)) from exc
+
+
+def load_config_dict_from_file(
+    filepath: Path,
+) -> Optional[Dict[str, Union[str, List[str]]]]:
+    """Load pytest configuration from the given file path, if supported.
+
+    Return None if the file does not contain valid pytest configuration.
+    """
+
+    # Configuration from ini files are obtained from the [pytest] section, if present.
+    if filepath.suffix == ".ini":
+        iniconfig = _parse_ini_config(filepath)
+
+        if "pytest" in iniconfig:
+            return dict(iniconfig["pytest"].items())
+        else:
+            # "pytest.ini" files are always the source of configuration, even if empty.
+            if filepath.name == "pytest.ini":
+                return {}
+
+    # '.cfg' files are considered if they contain a "[tool:pytest]" section.
+    elif filepath.suffix == ".cfg":
+        iniconfig = _parse_ini_config(filepath)
+
+        if "tool:pytest" in iniconfig.sections:
+            return dict(iniconfig["tool:pytest"].items())
+        elif "pytest" in iniconfig.sections:
+            # If a setup.cfg contains a "[pytest]" section, we raise a failure to indicate users that
+            # plain "[pytest]" sections in setup.cfg files is no longer supported (#3086).
+            fail(CFG_PYTEST_SECTION.format(filename="setup.cfg"), pytrace=False)
+
+    # '.toml' files are considered if they contain a [tool.pytest.ini_options] table.
+    elif filepath.suffix == ".toml":
+        import toml
+
+        config = toml.load(str(filepath))
+
+        result = config.get("tool", {}).get("pytest", {}).get("ini_options", None)
+        if result is not None:
+            # TOML supports richer data types than ini files (strings, arrays, floats, ints, etc),
+            # however we need to convert all scalar values to str for compatibility with the rest
+            # of the configuration system, which expects strings only.
+            def make_scalar(v: object) -> Union[str, List[str]]:
+                return v if isinstance(v, list) else str(v)
+
+            return {k: make_scalar(v) for k, v in result.items()}
+
+    return None
+
+
+def locate_config(
+    args: Iterable[Path],
+) -> Tuple[
+    Optional[Path], Optional[Path], Dict[str, Union[str, List[str]]],
+]:
+    """Search in the list of arguments for a valid ini-file for pytest,
+    and return a tuple of (rootdir, inifile, cfg-dict)."""
+    config_names = [
+        "pytest.ini",
+        "pyproject.toml",
+        "tox.ini",
+        "setup.cfg",
+    ]
+    args = [x for x in args if not str(x).startswith("-")]
+    if not args:
+        args = [Path.cwd()]
+    for arg in args:
+        argpath = absolutepath(arg)
+        for base in (argpath, *argpath.parents):
+            for config_name in config_names:
+                p = base / config_name
+                if p.is_file():
+                    ini_config = load_config_dict_from_file(p)
+                    if ini_config is not None:
+                        return base, p, ini_config
+    return None, None, {}
+
+
+def get_common_ancestor(paths: Iterable[Path]) -> Path:
+    common_ancestor: Optional[Path] = None
+    for path in paths:
+        if not path.exists():
+            continue
+        if common_ancestor is None:
+            common_ancestor = path
+        else:
+            if common_ancestor in path.parents or path == common_ancestor:
+                continue
+            elif path in common_ancestor.parents:
+                common_ancestor = path
+            else:
+                shared = commonpath(path, common_ancestor)
+                if shared is not None:
+                    common_ancestor = shared
+    if common_ancestor is None:
+        common_ancestor = Path.cwd()
+    elif common_ancestor.is_file():
+        common_ancestor = common_ancestor.parent
+    return common_ancestor
+
+
+def get_dirs_from_args(args: Iterable[str]) -> List[Path]:
+    def is_option(x: str) -> bool:
+        return x.startswith("-")
+
+    def get_file_part_from_node_id(x: str) -> str:
+        return x.split("::")[0]
+
+    def get_dir_from_path(path: Path) -> Path:
+        if path.is_dir():
+            return path
+        return path.parent
+
+    def safe_exists(path: Path) -> bool:
+        # This can throw on paths that contain characters unrepresentable at the OS level,
+        # or with invalid syntax on Windows (https://bugs.python.org/issue35306)
+        try:
+            return path.exists()
+        except OSError:
+            return False
+
+    # These look like paths but may not exist
+    possible_paths = (
+        absolutepath(get_file_part_from_node_id(arg))
+        for arg in args
+        if not is_option(arg)
+    )
+
+    return [get_dir_from_path(path) for path in possible_paths if safe_exists(path)]
+
+
+CFG_PYTEST_SECTION = "[pytest] section in {filename} files is no longer supported, change to [tool:pytest] instead."
+
+
+def determine_setup(
+    inifile: Optional[str],
+    args: Sequence[str],
+    rootdir_cmd_arg: Optional[str] = None,
+    config: Optional["Config"] = None,
+) -> Tuple[Path, Optional[Path], Dict[str, Union[str, List[str]]]]:
+    rootdir = None
+    dirs = get_dirs_from_args(args)
+    if inifile:
+        inipath_ = absolutepath(inifile)
+        inipath: Optional[Path] = inipath_
+        inicfg = load_config_dict_from_file(inipath_) or {}
+        if rootdir_cmd_arg is None:
+            rootdir = get_common_ancestor(dirs)
+    else:
+        ancestor = get_common_ancestor(dirs)
+        rootdir, inipath, inicfg = locate_config([ancestor])
+        if rootdir is None and rootdir_cmd_arg is None:
+            for possible_rootdir in (ancestor, *ancestor.parents):
+                if (possible_rootdir / "setup.py").is_file():
+                    rootdir = possible_rootdir
+                    break
+            else:
+                if dirs != [ancestor]:
+                    rootdir, inipath, inicfg = locate_config(dirs)
+                if rootdir is None:
+                    if config is not None:
+                        cwd = config.invocation_params.dir
+                    else:
+                        cwd = Path.cwd()
+                    rootdir = get_common_ancestor([cwd, ancestor])
+                    is_fs_root = os.path.splitdrive(str(rootdir))[1] == "/"
+                    if is_fs_root:
+                        rootdir = ancestor
+    if rootdir_cmd_arg:
+        rootdir = absolutepath(os.path.expandvars(rootdir_cmd_arg))
+        if not rootdir.is_dir():
+            raise UsageError(
+                "Directory '{}' not found. Check your '--rootdir' option.".format(
+                    rootdir
+                )
+            )
+    assert rootdir is not None
+    return rootdir, inipath, inicfg or {}
diff --git a/myenv/lib/python3.9/site-packages/_pytest/debugging.py b/myenv/lib/python3.9/site-packages/_pytest/debugging.py
new file mode 100644
index 0000000..d3a5c61
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/debugging.py
@@ -0,0 +1,388 @@
+"""Interactive debugging with PDB, the Python Debugger."""
+import argparse
+import functools
+import sys
+import types
+from typing import Any
+from typing import Callable
+from typing import Generator
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import Union
+
+from _pytest import outcomes
+from _pytest._code import ExceptionInfo
+from _pytest.config import Config
+from _pytest.config import ConftestImportFailure
+from _pytest.config import hookimpl
+from _pytest.config import PytestPluginManager
+from _pytest.config.argparsing import Parser
+from _pytest.config.exceptions import UsageError
+from _pytest.nodes import Node
+from _pytest.reports import BaseReport
+
+if TYPE_CHECKING:
+    from _pytest.capture import CaptureManager
+    from _pytest.runner import CallInfo
+
+
+def _validate_usepdb_cls(value: str) -> Tuple[str, str]:
+    """Validate syntax of --pdbcls option."""
+    try:
+        modname, classname = value.split(":")
+    except ValueError as e:
+        raise argparse.ArgumentTypeError(
+            f"{value!r} is not in the format 'modname:classname'"
+        ) from e
+    return (modname, classname)
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("general")
+    group._addoption(
+        "--pdb",
+        dest="usepdb",
+        action="store_true",
+        help="start the interactive Python debugger on errors or KeyboardInterrupt.",
+    )
+    group._addoption(
+        "--pdbcls",
+        dest="usepdb_cls",
+        metavar="modulename:classname",
+        type=_validate_usepdb_cls,
+        help="start a custom interactive Python debugger on errors. "
+        "For example: --pdbcls=IPython.terminal.debugger:TerminalPdb",
+    )
+    group._addoption(
+        "--trace",
+        dest="trace",
+        action="store_true",
+        help="Immediately break when running each test.",
+    )
+
+
+def pytest_configure(config: Config) -> None:
+    import pdb
+
+    if config.getvalue("trace"):
+        config.pluginmanager.register(PdbTrace(), "pdbtrace")
+    if config.getvalue("usepdb"):
+        config.pluginmanager.register(PdbInvoke(), "pdbinvoke")
+
+    pytestPDB._saved.append(
+        (pdb.set_trace, pytestPDB._pluginmanager, pytestPDB._config)
+    )
+    pdb.set_trace = pytestPDB.set_trace
+    pytestPDB._pluginmanager = config.pluginmanager
+    pytestPDB._config = config
+
+    # NOTE: not using pytest_unconfigure, since it might get called although
+    #       pytest_configure was not (if another plugin raises UsageError).
+    def fin() -> None:
+        (
+            pdb.set_trace,
+            pytestPDB._pluginmanager,
+            pytestPDB._config,
+        ) = pytestPDB._saved.pop()
+
+    config._cleanup.append(fin)
+
+
+class pytestPDB:
+    """Pseudo PDB that defers to the real pdb."""
+
+    _pluginmanager: Optional[PytestPluginManager] = None
+    _config: Optional[Config] = None
+    _saved: List[
+        Tuple[Callable[..., None], Optional[PytestPluginManager], Optional[Config]]
+    ] = []
+    _recursive_debug = 0
+    _wrapped_pdb_cls: Optional[Tuple[Type[Any], Type[Any]]] = None
+
+    @classmethod
+    def _is_capturing(cls, capman: Optional["CaptureManager"]) -> Union[str, bool]:
+        if capman:
+            return capman.is_capturing()
+        return False
+
+    @classmethod
+    def _import_pdb_cls(cls, capman: Optional["CaptureManager"]):
+        if not cls._config:
+            import pdb
+
+            # Happens when using pytest.set_trace outside of a test.
+            return pdb.Pdb
+
+        usepdb_cls = cls._config.getvalue("usepdb_cls")
+
+        if cls._wrapped_pdb_cls and cls._wrapped_pdb_cls[0] == usepdb_cls:
+            return cls._wrapped_pdb_cls[1]
+
+        if usepdb_cls:
+            modname, classname = usepdb_cls
+
+            try:
+                __import__(modname)
+                mod = sys.modules[modname]
+
+                # Handle --pdbcls=pdb:pdb.Pdb (useful e.g. with pdbpp).
+                parts = classname.split(".")
+                pdb_cls = getattr(mod, parts[0])
+                for part in parts[1:]:
+                    pdb_cls = getattr(pdb_cls, part)
+            except Exception as exc:
+                value = ":".join((modname, classname))
+                raise UsageError(
+                    f"--pdbcls: could not import {value!r}: {exc}"
+                ) from exc
+        else:
+            import pdb
+
+            pdb_cls = pdb.Pdb
+
+        wrapped_cls = cls._get_pdb_wrapper_class(pdb_cls, capman)
+        cls._wrapped_pdb_cls = (usepdb_cls, wrapped_cls)
+        return wrapped_cls
+
+    @classmethod
+    def _get_pdb_wrapper_class(cls, pdb_cls, capman: Optional["CaptureManager"]):
+        import _pytest.config
+
+        # Type ignored because mypy doesn't support "dynamic"
+        # inheritance like this.
+        class PytestPdbWrapper(pdb_cls):  # type: ignore[valid-type,misc]
+            _pytest_capman = capman
+            _continued = False
+
+            def do_debug(self, arg):
+                cls._recursive_debug += 1
+                ret = super().do_debug(arg)
+                cls._recursive_debug -= 1
+                return ret
+
+            def do_continue(self, arg):
+                ret = super().do_continue(arg)
+                if cls._recursive_debug == 0:
+                    assert cls._config is not None
+                    tw = _pytest.config.create_terminal_writer(cls._config)
+                    tw.line()
+
+                    capman = self._pytest_capman
+                    capturing = pytestPDB._is_capturing(capman)
+                    if capturing:
+                        if capturing == "global":
+                            tw.sep(">", "PDB continue (IO-capturing resumed)")
+                        else:
+                            tw.sep(
+                                ">",
+                                "PDB continue (IO-capturing resumed for %s)"
+                                % capturing,
+                            )
+                        assert capman is not None
+                        capman.resume()
+                    else:
+                        tw.sep(">", "PDB continue")
+                assert cls._pluginmanager is not None
+                cls._pluginmanager.hook.pytest_leave_pdb(config=cls._config, pdb=self)
+                self._continued = True
+                return ret
+
+            do_c = do_cont = do_continue
+
+            def do_quit(self, arg):
+                """Raise Exit outcome when quit command is used in pdb.
+
+                This is a bit of a hack - it would be better if BdbQuit
+                could be handled, but this would require to wrap the
+                whole pytest run, and adjust the report etc.
+                """
+                ret = super().do_quit(arg)
+
+                if cls._recursive_debug == 0:
+                    outcomes.exit("Quitting debugger")
+
+                return ret
+
+            do_q = do_quit
+            do_exit = do_quit
+
+            def setup(self, f, tb):
+                """Suspend on setup().
+
+                Needed after do_continue resumed, and entering another
+                breakpoint again.
+                """
+                ret = super().setup(f, tb)
+                if not ret and self._continued:
+                    # pdb.setup() returns True if the command wants to exit
+                    # from the interaction: do not suspend capturing then.
+                    if self._pytest_capman:
+                        self._pytest_capman.suspend_global_capture(in_=True)
+                return ret
+
+            def get_stack(self, f, t):
+                stack, i = super().get_stack(f, t)
+                if f is None:
+                    # Find last non-hidden frame.
+                    i = max(0, len(stack) - 1)
+                    while i and stack[i][0].f_locals.get("__tracebackhide__", False):
+                        i -= 1
+                return stack, i
+
+        return PytestPdbWrapper
+
+    @classmethod
+    def _init_pdb(cls, method, *args, **kwargs):
+        """Initialize PDB debugging, dropping any IO capturing."""
+        import _pytest.config
+
+        if cls._pluginmanager is None:
+            capman: Optional[CaptureManager] = None
+        else:
+            capman = cls._pluginmanager.getplugin("capturemanager")
+        if capman:
+            capman.suspend(in_=True)
+
+        if cls._config:
+            tw = _pytest.config.create_terminal_writer(cls._config)
+            tw.line()
+
+            if cls._recursive_debug == 0:
+                # Handle header similar to pdb.set_trace in py37+.
+                header = kwargs.pop("header", None)
+                if header is not None:
+                    tw.sep(">", header)
+                else:
+                    capturing = cls._is_capturing(capman)
+                    if capturing == "global":
+                        tw.sep(">", f"PDB {method} (IO-capturing turned off)")
+                    elif capturing:
+                        tw.sep(
+                            ">",
+                            "PDB %s (IO-capturing turned off for %s)"
+                            % (method, capturing),
+                        )
+                    else:
+                        tw.sep(">", f"PDB {method}")
+
+        _pdb = cls._import_pdb_cls(capman)(**kwargs)
+
+        if cls._pluginmanager:
+            cls._pluginmanager.hook.pytest_enter_pdb(config=cls._config, pdb=_pdb)
+        return _pdb
+
+    @classmethod
+    def set_trace(cls, *args, **kwargs) -> None:
+        """Invoke debugging via ``Pdb.set_trace``, dropping any IO capturing."""
+        frame = sys._getframe().f_back
+        _pdb = cls._init_pdb("set_trace", *args, **kwargs)
+        _pdb.set_trace(frame)
+
+
+class PdbInvoke:
+    def pytest_exception_interact(
+        self, node: Node, call: "CallInfo[Any]", report: BaseReport
+    ) -> None:
+        capman = node.config.pluginmanager.getplugin("capturemanager")
+        if capman:
+            capman.suspend_global_capture(in_=True)
+            out, err = capman.read_global_capture()
+            sys.stdout.write(out)
+            sys.stdout.write(err)
+        assert call.excinfo is not None
+        _enter_pdb(node, call.excinfo, report)
+
+    def pytest_internalerror(self, excinfo: ExceptionInfo[BaseException]) -> None:
+        tb = _postmortem_traceback(excinfo)
+        post_mortem(tb)
+
+
+class PdbTrace:
+    @hookimpl(hookwrapper=True)
+    def pytest_pyfunc_call(self, pyfuncitem) -> Generator[None, None, None]:
+        wrap_pytest_function_for_tracing(pyfuncitem)
+        yield
+
+
+def wrap_pytest_function_for_tracing(pyfuncitem):
+    """Change the Python function object of the given Function item by a
+    wrapper which actually enters pdb before calling the python function
+    itself, effectively leaving the user in the pdb prompt in the first
+    statement of the function."""
+    _pdb = pytestPDB._init_pdb("runcall")
+    testfunction = pyfuncitem.obj
+
+    # we can't just return `partial(pdb.runcall, testfunction)` because (on
+    # python < 3.7.4) runcall's first param is `func`, which means we'd get
+    # an exception if one of the kwargs to testfunction was called `func`.
+    @functools.wraps(testfunction)
+    def wrapper(*args, **kwargs):
+        func = functools.partial(testfunction, *args, **kwargs)
+        _pdb.runcall(func)
+
+    pyfuncitem.obj = wrapper
+
+
+def maybe_wrap_pytest_function_for_tracing(pyfuncitem):
+    """Wrap the given pytestfunct item for tracing support if --trace was given in
+    the command line."""
+    if pyfuncitem.config.getvalue("trace"):
+        wrap_pytest_function_for_tracing(pyfuncitem)
+
+
+def _enter_pdb(
+    node: Node, excinfo: ExceptionInfo[BaseException], rep: BaseReport
+) -> BaseReport:
+    # XXX we re-use the TerminalReporter's terminalwriter
+    # because this seems to avoid some encoding related troubles
+    # for not completely clear reasons.
+    tw = node.config.pluginmanager.getplugin("terminalreporter")._tw
+    tw.line()
+
+    showcapture = node.config.option.showcapture
+
+    for sectionname, content in (
+        ("stdout", rep.capstdout),
+        ("stderr", rep.capstderr),
+        ("log", rep.caplog),
+    ):
+        if showcapture in (sectionname, "all") and content:
+            tw.sep(">", "captured " + sectionname)
+            if content[-1:] == "\n":
+                content = content[:-1]
+            tw.line(content)
+
+    tw.sep(">", "traceback")
+    rep.toterminal(tw)
+    tw.sep(">", "entering PDB")
+    tb = _postmortem_traceback(excinfo)
+    rep._pdbshown = True  # type: ignore[attr-defined]
+    post_mortem(tb)
+    return rep
+
+
+def _postmortem_traceback(excinfo: ExceptionInfo[BaseException]) -> types.TracebackType:
+    from doctest import UnexpectedException
+
+    if isinstance(excinfo.value, UnexpectedException):
+        # A doctest.UnexpectedException is not useful for post_mortem.
+        # Use the underlying exception instead:
+        return excinfo.value.exc_info[2]
+    elif isinstance(excinfo.value, ConftestImportFailure):
+        # A config.ConftestImportFailure is not useful for post_mortem.
+        # Use the underlying exception instead:
+        return excinfo.value.excinfo[2]
+    else:
+        assert excinfo._excinfo is not None
+        return excinfo._excinfo[2]
+
+
+def post_mortem(t: types.TracebackType) -> None:
+    p = pytestPDB._init_pdb("post_mortem")
+    p.reset()
+    p.interaction(None, t)
+    if p.quitting:
+        outcomes.exit("Quitting debugger")
diff --git a/myenv/lib/python3.9/site-packages/_pytest/deprecated.py b/myenv/lib/python3.9/site-packages/_pytest/deprecated.py
new file mode 100644
index 0000000..19b31d6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/deprecated.py
@@ -0,0 +1,87 @@
+"""Deprecation messages and bits of code used elsewhere in the codebase that
+is planned to be removed in the next pytest release.
+
+Keeping it in a central location makes it easy to track what is deprecated and should
+be removed when the time comes.
+
+All constants defined in this module should be either instances of
+:class:`PytestWarning`, or :class:`UnformattedWarning`
+in case of warnings which need to format their messages.
+"""
+from warnings import warn
+
+from _pytest.warning_types import PytestDeprecationWarning
+from _pytest.warning_types import UnformattedWarning
+
+# set of plugins which have been integrated into the core; we use this list to ignore
+# them during registration to avoid conflicts
+DEPRECATED_EXTERNAL_PLUGINS = {
+    "pytest_catchlog",
+    "pytest_capturelog",
+    "pytest_faulthandler",
+}
+
+
+FILLFUNCARGS = UnformattedWarning(
+    PytestDeprecationWarning,
+    "{name} is deprecated, use "
+    "function._request._fillfixtures() instead if you cannot avoid reaching into internals.",
+)
+
+PYTEST_COLLECT_MODULE = UnformattedWarning(
+    PytestDeprecationWarning,
+    "pytest.collect.{name} was moved to pytest.{name}\n"
+    "Please update to the new name.",
+)
+
+YIELD_FIXTURE = PytestDeprecationWarning(
+    "@pytest.yield_fixture is deprecated.\n"
+    "Use @pytest.fixture instead; they are the same."
+)
+
+MINUS_K_DASH = PytestDeprecationWarning(
+    "The `-k '-expr'` syntax to -k is deprecated.\nUse `-k 'not expr'` instead."
+)
+
+MINUS_K_COLON = PytestDeprecationWarning(
+    "The `-k 'expr:'` syntax to -k is deprecated.\n"
+    "Please open an issue if you use this and want a replacement."
+)
+
+WARNING_CAPTURED_HOOK = PytestDeprecationWarning(
+    "The pytest_warning_captured is deprecated and will be removed in a future release.\n"
+    "Please use pytest_warning_recorded instead."
+)
+
+FSCOLLECTOR_GETHOOKPROXY_ISINITPATH = PytestDeprecationWarning(
+    "The gethookproxy() and isinitpath() methods of FSCollector and Package are deprecated; "
+    "use self.session.gethookproxy() and self.session.isinitpath() instead. "
+)
+
+STRICT_OPTION = PytestDeprecationWarning(
+    "The --strict option is deprecated, use --strict-markers instead."
+)
+
+PRIVATE = PytestDeprecationWarning("A private pytest class or function was used.")
+
+
+# You want to make some `__init__` or function "private".
+#
+#   def my_private_function(some, args):
+#       ...
+#
+# Do this:
+#
+#   def my_private_function(some, args, *, _ispytest: bool = False):
+#       check_ispytest(_ispytest)
+#       ...
+#
+# Change all internal/allowed calls to
+#
+#   my_private_function(some, args, _ispytest=True)
+#
+# All other calls will get the default _ispytest=False and trigger
+# the warning (possibly error in the future).
+def check_ispytest(ispytest: bool) -> None:
+    if not ispytest:
+        warn(PRIVATE, stacklevel=3)
diff --git a/myenv/lib/python3.9/site-packages/_pytest/doctest.py b/myenv/lib/python3.9/site-packages/_pytest/doctest.py
new file mode 100644
index 0000000..64e8f0e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/doctest.py
@@ -0,0 +1,724 @@
+"""Discover and run doctests in modules and test files."""
+import bdb
+import inspect
+import platform
+import sys
+import traceback
+import types
+import warnings
+from contextlib import contextmanager
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import Generator
+from typing import Iterable
+from typing import List
+from typing import Optional
+from typing import Pattern
+from typing import Sequence
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import Union
+
+import py.path
+
+import pytest
+from _pytest import outcomes
+from _pytest._code.code import ExceptionInfo
+from _pytest._code.code import ReprFileLocation
+from _pytest._code.code import TerminalRepr
+from _pytest._io import TerminalWriter
+from _pytest.compat import safe_getattr
+from _pytest.config import Config
+from _pytest.config.argparsing import Parser
+from _pytest.fixtures import FixtureRequest
+from _pytest.nodes import Collector
+from _pytest.outcomes import OutcomeException
+from _pytest.pathlib import import_path
+from _pytest.python_api import approx
+from _pytest.warning_types import PytestWarning
+
+if TYPE_CHECKING:
+    import doctest
+
+DOCTEST_REPORT_CHOICE_NONE = "none"
+DOCTEST_REPORT_CHOICE_CDIFF = "cdiff"
+DOCTEST_REPORT_CHOICE_NDIFF = "ndiff"
+DOCTEST_REPORT_CHOICE_UDIFF = "udiff"
+DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE = "only_first_failure"
+
+DOCTEST_REPORT_CHOICES = (
+    DOCTEST_REPORT_CHOICE_NONE,
+    DOCTEST_REPORT_CHOICE_CDIFF,
+    DOCTEST_REPORT_CHOICE_NDIFF,
+    DOCTEST_REPORT_CHOICE_UDIFF,
+    DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE,
+)
+
+# Lazy definition of runner class
+RUNNER_CLASS = None
+# Lazy definition of output checker class
+CHECKER_CLASS: Optional[Type["doctest.OutputChecker"]] = None
+
+
+def pytest_addoption(parser: Parser) -> None:
+    parser.addini(
+        "doctest_optionflags",
+        "option flags for doctests",
+        type="args",
+        default=["ELLIPSIS"],
+    )
+    parser.addini(
+        "doctest_encoding", "encoding used for doctest files", default="utf-8"
+    )
+    group = parser.getgroup("collect")
+    group.addoption(
+        "--doctest-modules",
+        action="store_true",
+        default=False,
+        help="run doctests in all .py modules",
+        dest="doctestmodules",
+    )
+    group.addoption(
+        "--doctest-report",
+        type=str.lower,
+        default="udiff",
+        help="choose another output format for diffs on doctest failure",
+        choices=DOCTEST_REPORT_CHOICES,
+        dest="doctestreport",
+    )
+    group.addoption(
+        "--doctest-glob",
+        action="append",
+        default=[],
+        metavar="pat",
+        help="doctests file matching pattern, default: test*.txt",
+        dest="doctestglob",
+    )
+    group.addoption(
+        "--doctest-ignore-import-errors",
+        action="store_true",
+        default=False,
+        help="ignore doctest ImportErrors",
+        dest="doctest_ignore_import_errors",
+    )
+    group.addoption(
+        "--doctest-continue-on-failure",
+        action="store_true",
+        default=False,
+        help="for a given doctest, continue to run after the first failure",
+        dest="doctest_continue_on_failure",
+    )
+
+
+def pytest_unconfigure() -> None:
+    global RUNNER_CLASS
+
+    RUNNER_CLASS = None
+
+
+def pytest_collect_file(
+    path: py.path.local, parent: Collector,
+) -> Optional[Union["DoctestModule", "DoctestTextfile"]]:
+    config = parent.config
+    if path.ext == ".py":
+        if config.option.doctestmodules and not _is_setup_py(path):
+            mod: DoctestModule = DoctestModule.from_parent(parent, fspath=path)
+            return mod
+    elif _is_doctest(config, path, parent):
+        txt: DoctestTextfile = DoctestTextfile.from_parent(parent, fspath=path)
+        return txt
+    return None
+
+
+def _is_setup_py(path: py.path.local) -> bool:
+    if path.basename != "setup.py":
+        return False
+    contents = path.read_binary()
+    return b"setuptools" in contents or b"distutils" in contents
+
+
+def _is_doctest(config: Config, path: py.path.local, parent) -> bool:
+    if path.ext in (".txt", ".rst") and parent.session.isinitpath(path):
+        return True
+    globs = config.getoption("doctestglob") or ["test*.txt"]
+    for glob in globs:
+        if path.check(fnmatch=glob):
+            return True
+    return False
+
+
+class ReprFailDoctest(TerminalRepr):
+    def __init__(
+        self, reprlocation_lines: Sequence[Tuple[ReprFileLocation, Sequence[str]]]
+    ) -> None:
+        self.reprlocation_lines = reprlocation_lines
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        for reprlocation, lines in self.reprlocation_lines:
+            for line in lines:
+                tw.line(line)
+            reprlocation.toterminal(tw)
+
+
+class MultipleDoctestFailures(Exception):
+    def __init__(self, failures: Sequence["doctest.DocTestFailure"]) -> None:
+        super().__init__()
+        self.failures = failures
+
+
+def _init_runner_class() -> Type["doctest.DocTestRunner"]:
+    import doctest
+
+    class PytestDoctestRunner(doctest.DebugRunner):
+        """Runner to collect failures.
+
+        Note that the out variable in this case is a list instead of a
+        stdout-like object.
+        """
+
+        def __init__(
+            self,
+            checker: Optional["doctest.OutputChecker"] = None,
+            verbose: Optional[bool] = None,
+            optionflags: int = 0,
+            continue_on_failure: bool = True,
+        ) -> None:
+            doctest.DebugRunner.__init__(
+                self, checker=checker, verbose=verbose, optionflags=optionflags
+            )
+            self.continue_on_failure = continue_on_failure
+
+        def report_failure(
+            self, out, test: "doctest.DocTest", example: "doctest.Example", got: str,
+        ) -> None:
+            failure = doctest.DocTestFailure(test, example, got)
+            if self.continue_on_failure:
+                out.append(failure)
+            else:
+                raise failure
+
+        def report_unexpected_exception(
+            self,
+            out,
+            test: "doctest.DocTest",
+            example: "doctest.Example",
+            exc_info: Tuple[Type[BaseException], BaseException, types.TracebackType],
+        ) -> None:
+            if isinstance(exc_info[1], OutcomeException):
+                raise exc_info[1]
+            if isinstance(exc_info[1], bdb.BdbQuit):
+                outcomes.exit("Quitting debugger")
+            failure = doctest.UnexpectedException(test, example, exc_info)
+            if self.continue_on_failure:
+                out.append(failure)
+            else:
+                raise failure
+
+    return PytestDoctestRunner
+
+
+def _get_runner(
+    checker: Optional["doctest.OutputChecker"] = None,
+    verbose: Optional[bool] = None,
+    optionflags: int = 0,
+    continue_on_failure: bool = True,
+) -> "doctest.DocTestRunner":
+    # We need this in order to do a lazy import on doctest
+    global RUNNER_CLASS
+    if RUNNER_CLASS is None:
+        RUNNER_CLASS = _init_runner_class()
+    # Type ignored because the continue_on_failure argument is only defined on
+    # PytestDoctestRunner, which is lazily defined so can't be used as a type.
+    return RUNNER_CLASS(  # type: ignore
+        checker=checker,
+        verbose=verbose,
+        optionflags=optionflags,
+        continue_on_failure=continue_on_failure,
+    )
+
+
+class DoctestItem(pytest.Item):
+    def __init__(
+        self,
+        name: str,
+        parent: "Union[DoctestTextfile, DoctestModule]",
+        runner: Optional["doctest.DocTestRunner"] = None,
+        dtest: Optional["doctest.DocTest"] = None,
+    ) -> None:
+        super().__init__(name, parent)
+        self.runner = runner
+        self.dtest = dtest
+        self.obj = None
+        self.fixture_request: Optional[FixtureRequest] = None
+
+    @classmethod
+    def from_parent(  # type: ignore
+        cls,
+        parent: "Union[DoctestTextfile, DoctestModule]",
+        *,
+        name: str,
+        runner: "doctest.DocTestRunner",
+        dtest: "doctest.DocTest",
+    ):
+        # incompatible signature due to to imposed limits on sublcass
+        """The public named constructor."""
+        return super().from_parent(name=name, parent=parent, runner=runner, dtest=dtest)
+
+    def setup(self) -> None:
+        if self.dtest is not None:
+            self.fixture_request = _setup_fixtures(self)
+            globs = dict(getfixture=self.fixture_request.getfixturevalue)
+            for name, value in self.fixture_request.getfixturevalue(
+                "doctest_namespace"
+            ).items():
+                globs[name] = value
+            self.dtest.globs.update(globs)
+
+    def runtest(self) -> None:
+        assert self.dtest is not None
+        assert self.runner is not None
+        _check_all_skipped(self.dtest)
+        self._disable_output_capturing_for_darwin()
+        failures: List["doctest.DocTestFailure"] = []
+        # Type ignored because we change the type of `out` from what
+        # doctest expects.
+        self.runner.run(self.dtest, out=failures)  # type: ignore[arg-type]
+        if failures:
+            raise MultipleDoctestFailures(failures)
+
+    def _disable_output_capturing_for_darwin(self) -> None:
+        """Disable output capturing. Otherwise, stdout is lost to doctest (#985)."""
+        if platform.system() != "Darwin":
+            return
+        capman = self.config.pluginmanager.getplugin("capturemanager")
+        if capman:
+            capman.suspend_global_capture(in_=True)
+            out, err = capman.read_global_capture()
+            sys.stdout.write(out)
+            sys.stderr.write(err)
+
+    # TODO: Type ignored -- breaks Liskov Substitution.
+    def repr_failure(  # type: ignore[override]
+        self, excinfo: ExceptionInfo[BaseException],
+    ) -> Union[str, TerminalRepr]:
+        import doctest
+
+        failures: Optional[
+            Sequence[Union[doctest.DocTestFailure, doctest.UnexpectedException]]
+        ] = (None)
+        if isinstance(
+            excinfo.value, (doctest.DocTestFailure, doctest.UnexpectedException)
+        ):
+            failures = [excinfo.value]
+        elif isinstance(excinfo.value, MultipleDoctestFailures):
+            failures = excinfo.value.failures
+
+        if failures is not None:
+            reprlocation_lines = []
+            for failure in failures:
+                example = failure.example
+                test = failure.test
+                filename = test.filename
+                if test.lineno is None:
+                    lineno = None
+                else:
+                    lineno = test.lineno + example.lineno + 1
+                message = type(failure).__name__
+                # TODO: ReprFileLocation doesn't expect a None lineno.
+                reprlocation = ReprFileLocation(filename, lineno, message)  # type: ignore[arg-type]
+                checker = _get_checker()
+                report_choice = _get_report_choice(
+                    self.config.getoption("doctestreport")
+                )
+                if lineno is not None:
+                    assert failure.test.docstring is not None
+                    lines = failure.test.docstring.splitlines(False)
+                    # add line numbers to the left of the error message
+                    assert test.lineno is not None
+                    lines = [
+                        "%03d %s" % (i + test.lineno + 1, x)
+                        for (i, x) in enumerate(lines)
+                    ]
+                    # trim docstring error lines to 10
+                    lines = lines[max(example.lineno - 9, 0) : example.lineno + 1]
+                else:
+                    lines = [
+                        "EXAMPLE LOCATION UNKNOWN, not showing all tests of that example"
+                    ]
+                    indent = ">>>"
+                    for line in example.source.splitlines():
+                        lines.append(f"??? {indent} {line}")
+                        indent = "..."
+                if isinstance(failure, doctest.DocTestFailure):
+                    lines += checker.output_difference(
+                        example, failure.got, report_choice
+                    ).split("\n")
+                else:
+                    inner_excinfo = ExceptionInfo(failure.exc_info)
+                    lines += ["UNEXPECTED EXCEPTION: %s" % repr(inner_excinfo.value)]
+                    lines += [
+                        x.strip("\n")
+                        for x in traceback.format_exception(*failure.exc_info)
+                    ]
+                reprlocation_lines.append((reprlocation, lines))
+            return ReprFailDoctest(reprlocation_lines)
+        else:
+            return super().repr_failure(excinfo)
+
+    def reportinfo(self):
+        assert self.dtest is not None
+        return self.fspath, self.dtest.lineno, "[doctest] %s" % self.name
+
+
+def _get_flag_lookup() -> Dict[str, int]:
+    import doctest
+
+    return dict(
+        DONT_ACCEPT_TRUE_FOR_1=doctest.DONT_ACCEPT_TRUE_FOR_1,
+        DONT_ACCEPT_BLANKLINE=doctest.DONT_ACCEPT_BLANKLINE,
+        NORMALIZE_WHITESPACE=doctest.NORMALIZE_WHITESPACE,
+        ELLIPSIS=doctest.ELLIPSIS,
+        IGNORE_EXCEPTION_DETAIL=doctest.IGNORE_EXCEPTION_DETAIL,
+        COMPARISON_FLAGS=doctest.COMPARISON_FLAGS,
+        ALLOW_UNICODE=_get_allow_unicode_flag(),
+        ALLOW_BYTES=_get_allow_bytes_flag(),
+        NUMBER=_get_number_flag(),
+    )
+
+
+def get_optionflags(parent):
+    optionflags_str = parent.config.getini("doctest_optionflags")
+    flag_lookup_table = _get_flag_lookup()
+    flag_acc = 0
+    for flag in optionflags_str:
+        flag_acc |= flag_lookup_table[flag]
+    return flag_acc
+
+
+def _get_continue_on_failure(config):
+    continue_on_failure = config.getvalue("doctest_continue_on_failure")
+    if continue_on_failure:
+        # We need to turn off this if we use pdb since we should stop at
+        # the first failure.
+        if config.getvalue("usepdb"):
+            continue_on_failure = False
+    return continue_on_failure
+
+
+class DoctestTextfile(pytest.Module):
+    obj = None
+
+    def collect(self) -> Iterable[DoctestItem]:
+        import doctest
+
+        # Inspired by doctest.testfile; ideally we would use it directly,
+        # but it doesn't support passing a custom checker.
+        encoding = self.config.getini("doctest_encoding")
+        text = self.fspath.read_text(encoding)
+        filename = str(self.fspath)
+        name = self.fspath.basename
+        globs = {"__name__": "__main__"}
+
+        optionflags = get_optionflags(self)
+
+        runner = _get_runner(
+            verbose=False,
+            optionflags=optionflags,
+            checker=_get_checker(),
+            continue_on_failure=_get_continue_on_failure(self.config),
+        )
+
+        parser = doctest.DocTestParser()
+        test = parser.get_doctest(text, globs, name, filename, 0)
+        if test.examples:
+            yield DoctestItem.from_parent(
+                self, name=test.name, runner=runner, dtest=test
+            )
+
+
+def _check_all_skipped(test: "doctest.DocTest") -> None:
+    """Raise pytest.skip() if all examples in the given DocTest have the SKIP
+    option set."""
+    import doctest
+
+    all_skipped = all(x.options.get(doctest.SKIP, False) for x in test.examples)
+    if all_skipped:
+        pytest.skip("all tests skipped by +SKIP option")
+
+
+def _is_mocked(obj: object) -> bool:
+    """Return if an object is possibly a mock object by checking the
+    existence of a highly improbable attribute."""
+    return (
+        safe_getattr(obj, "pytest_mock_example_attribute_that_shouldnt_exist", None)
+        is not None
+    )
+
+
+@contextmanager
+def _patch_unwrap_mock_aware() -> Generator[None, None, None]:
+    """Context manager which replaces ``inspect.unwrap`` with a version
+    that's aware of mock objects and doesn't recurse into them."""
+    real_unwrap = inspect.unwrap
+
+    def _mock_aware_unwrap(
+        func: Callable[..., Any], *, stop: Optional[Callable[[Any], Any]] = None
+    ) -> Any:
+        try:
+            if stop is None or stop is _is_mocked:
+                return real_unwrap(func, stop=_is_mocked)
+            _stop = stop
+            return real_unwrap(func, stop=lambda obj: _is_mocked(obj) or _stop(func))
+        except Exception as e:
+            warnings.warn(
+                "Got %r when unwrapping %r.  This is usually caused "
+                "by a violation of Python's object protocol; see e.g. "
+                "https://github.com/pytest-dev/pytest/issues/5080" % (e, func),
+                PytestWarning,
+            )
+            raise
+
+    inspect.unwrap = _mock_aware_unwrap
+    try:
+        yield
+    finally:
+        inspect.unwrap = real_unwrap
+
+
+class DoctestModule(pytest.Module):
+    def collect(self) -> Iterable[DoctestItem]:
+        import doctest
+
+        class MockAwareDocTestFinder(doctest.DocTestFinder):
+            """A hackish doctest finder that overrides stdlib internals to fix a stdlib bug.
+
+            https://github.com/pytest-dev/pytest/issues/3456
+            https://bugs.python.org/issue25532
+            """
+
+            def _find_lineno(self, obj, source_lines):
+                """Doctest code does not take into account `@property`, this
+                is a hackish way to fix it.
+
+                https://bugs.python.org/issue17446
+                """
+                if isinstance(obj, property):
+                    obj = getattr(obj, "fget", obj)
+                # Type ignored because this is a private function.
+                return doctest.DocTestFinder._find_lineno(  # type: ignore
+                    self, obj, source_lines,
+                )
+
+            def _find(
+                self, tests, obj, name, module, source_lines, globs, seen
+            ) -> None:
+                if _is_mocked(obj):
+                    return
+                with _patch_unwrap_mock_aware():
+
+                    # Type ignored because this is a private function.
+                    doctest.DocTestFinder._find(  # type: ignore
+                        self, tests, obj, name, module, source_lines, globs, seen
+                    )
+
+        if self.fspath.basename == "conftest.py":
+            module = self.config.pluginmanager._importconftest(
+                self.fspath, self.config.getoption("importmode")
+            )
+        else:
+            try:
+                module = import_path(self.fspath)
+            except ImportError:
+                if self.config.getvalue("doctest_ignore_import_errors"):
+                    pytest.skip("unable to import module %r" % self.fspath)
+                else:
+                    raise
+        # Uses internal doctest module parsing mechanism.
+        finder = MockAwareDocTestFinder()
+        optionflags = get_optionflags(self)
+        runner = _get_runner(
+            verbose=False,
+            optionflags=optionflags,
+            checker=_get_checker(),
+            continue_on_failure=_get_continue_on_failure(self.config),
+        )
+
+        for test in finder.find(module, module.__name__):
+            if test.examples:  # skip empty doctests
+                yield DoctestItem.from_parent(
+                    self, name=test.name, runner=runner, dtest=test
+                )
+
+
+def _setup_fixtures(doctest_item: DoctestItem) -> FixtureRequest:
+    """Used by DoctestTextfile and DoctestItem to setup fixture information."""
+
+    def func() -> None:
+        pass
+
+    doctest_item.funcargs = {}  # type: ignore[attr-defined]
+    fm = doctest_item.session._fixturemanager
+    doctest_item._fixtureinfo = fm.getfixtureinfo(  # type: ignore[attr-defined]
+        node=doctest_item, func=func, cls=None, funcargs=False
+    )
+    fixture_request = FixtureRequest(doctest_item, _ispytest=True)
+    fixture_request._fillfixtures()
+    return fixture_request
+
+
+def _init_checker_class() -> Type["doctest.OutputChecker"]:
+    import doctest
+    import re
+
+    class LiteralsOutputChecker(doctest.OutputChecker):
+        # Based on doctest_nose_plugin.py from the nltk project
+        # (https://github.com/nltk/nltk) and on the "numtest" doctest extension
+        # by Sebastien Boisgerault (https://github.com/boisgera/numtest).
+
+        _unicode_literal_re = re.compile(r"(\W|^)[uU]([rR]?[\'\"])", re.UNICODE)
+        _bytes_literal_re = re.compile(r"(\W|^)[bB]([rR]?[\'\"])", re.UNICODE)
+        _number_re = re.compile(
+            r"""
+            (?P<number>
+              (?P<mantissa>
+                (?P<integer1> [+-]?\d*)\.(?P<fraction>\d+)
+                |
+                (?P<integer2> [+-]?\d+)\.
+              )
+              (?:
+                [Ee]
+                (?P<exponent1> [+-]?\d+)
+              )?
+              |
+              (?P<integer3> [+-]?\d+)
+              (?:
+                [Ee]
+                (?P<exponent2> [+-]?\d+)
+              )
+            )
+            """,
+            re.VERBOSE,
+        )
+
+        def check_output(self, want: str, got: str, optionflags: int) -> bool:
+            if doctest.OutputChecker.check_output(self, want, got, optionflags):
+                return True
+
+            allow_unicode = optionflags & _get_allow_unicode_flag()
+            allow_bytes = optionflags & _get_allow_bytes_flag()
+            allow_number = optionflags & _get_number_flag()
+
+            if not allow_unicode and not allow_bytes and not allow_number:
+                return False
+
+            def remove_prefixes(regex: Pattern[str], txt: str) -> str:
+                return re.sub(regex, r"\1\2", txt)
+
+            if allow_unicode:
+                want = remove_prefixes(self._unicode_literal_re, want)
+                got = remove_prefixes(self._unicode_literal_re, got)
+
+            if allow_bytes:
+                want = remove_prefixes(self._bytes_literal_re, want)
+                got = remove_prefixes(self._bytes_literal_re, got)
+
+            if allow_number:
+                got = self._remove_unwanted_precision(want, got)
+
+            return doctest.OutputChecker.check_output(self, want, got, optionflags)
+
+        def _remove_unwanted_precision(self, want: str, got: str) -> str:
+            wants = list(self._number_re.finditer(want))
+            gots = list(self._number_re.finditer(got))
+            if len(wants) != len(gots):
+                return got
+            offset = 0
+            for w, g in zip(wants, gots):
+                fraction: Optional[str] = w.group("fraction")
+                exponent: Optional[str] = w.group("exponent1")
+                if exponent is None:
+                    exponent = w.group("exponent2")
+                if fraction is None:
+                    precision = 0
+                else:
+                    precision = len(fraction)
+                if exponent is not None:
+                    precision -= int(exponent)
+                if float(w.group()) == approx(float(g.group()), abs=10 ** -precision):
+                    # They're close enough. Replace the text we actually
+                    # got with the text we want, so that it will match when we
+                    # check the string literally.
+                    got = (
+                        got[: g.start() + offset] + w.group() + got[g.end() + offset :]
+                    )
+                    offset += w.end() - w.start() - (g.end() - g.start())
+            return got
+
+    return LiteralsOutputChecker
+
+
+def _get_checker() -> "doctest.OutputChecker":
+    """Return a doctest.OutputChecker subclass that supports some
+    additional options:
+
+    * ALLOW_UNICODE and ALLOW_BYTES options to ignore u'' and b''
+      prefixes (respectively) in string literals. Useful when the same
+      doctest should run in Python 2 and Python 3.
+
+    * NUMBER to ignore floating-point differences smaller than the
+      precision of the literal number in the doctest.
+
+    An inner class is used to avoid importing "doctest" at the module
+    level.
+    """
+    global CHECKER_CLASS
+    if CHECKER_CLASS is None:
+        CHECKER_CLASS = _init_checker_class()
+    return CHECKER_CLASS()
+
+
+def _get_allow_unicode_flag() -> int:
+    """Register and return the ALLOW_UNICODE flag."""
+    import doctest
+
+    return doctest.register_optionflag("ALLOW_UNICODE")
+
+
+def _get_allow_bytes_flag() -> int:
+    """Register and return the ALLOW_BYTES flag."""
+    import doctest
+
+    return doctest.register_optionflag("ALLOW_BYTES")
+
+
+def _get_number_flag() -> int:
+    """Register and return the NUMBER flag."""
+    import doctest
+
+    return doctest.register_optionflag("NUMBER")
+
+
+def _get_report_choice(key: str) -> int:
+    """Return the actual `doctest` module flag value.
+
+    We want to do it as late as possible to avoid importing `doctest` and all
+    its dependencies when parsing options, as it adds overhead and breaks tests.
+    """
+    import doctest
+
+    return {
+        DOCTEST_REPORT_CHOICE_UDIFF: doctest.REPORT_UDIFF,
+        DOCTEST_REPORT_CHOICE_CDIFF: doctest.REPORT_CDIFF,
+        DOCTEST_REPORT_CHOICE_NDIFF: doctest.REPORT_NDIFF,
+        DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE: doctest.REPORT_ONLY_FIRST_FAILURE,
+        DOCTEST_REPORT_CHOICE_NONE: 0,
+    }[key]
+
+
+@pytest.fixture(scope="session")
+def doctest_namespace() -> Dict[str, Any]:
+    """Fixture that returns a :py:class:`dict` that will be injected into the
+    namespace of doctests."""
+    return dict()
diff --git a/myenv/lib/python3.9/site-packages/_pytest/faulthandler.py b/myenv/lib/python3.9/site-packages/_pytest/faulthandler.py
new file mode 100644
index 0000000..ff673b5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/faulthandler.py
@@ -0,0 +1,116 @@
+import io
+import os
+import sys
+from typing import Generator
+from typing import TextIO
+
+import pytest
+from _pytest.config import Config
+from _pytest.config.argparsing import Parser
+from _pytest.nodes import Item
+from _pytest.store import StoreKey
+
+
+fault_handler_stderr_key = StoreKey[TextIO]()
+
+
+def pytest_addoption(parser: Parser) -> None:
+    help = (
+        "Dump the traceback of all threads if a test takes "
+        "more than TIMEOUT seconds to finish."
+    )
+    parser.addini("faulthandler_timeout", help, default=0.0)
+
+
+def pytest_configure(config: Config) -> None:
+    import faulthandler
+
+    if not faulthandler.is_enabled():
+        # faulthhandler is not enabled, so install plugin that does the actual work
+        # of enabling faulthandler before each test executes.
+        config.pluginmanager.register(FaultHandlerHooks(), "faulthandler-hooks")
+    else:
+        # Do not handle dumping to stderr if faulthandler is already enabled, so warn
+        # users that the option is being ignored.
+        timeout = FaultHandlerHooks.get_timeout_config_value(config)
+        if timeout > 0:
+            config.issue_config_time_warning(
+                pytest.PytestConfigWarning(
+                    "faulthandler module enabled before pytest configuration step, "
+                    "'faulthandler_timeout' option ignored"
+                ),
+                stacklevel=2,
+            )
+
+
+class FaultHandlerHooks:
+    """Implements hooks that will actually install fault handler before tests execute,
+    as well as correctly handle pdb and internal errors."""
+
+    def pytest_configure(self, config: Config) -> None:
+        import faulthandler
+
+        stderr_fd_copy = os.dup(self._get_stderr_fileno())
+        config._store[fault_handler_stderr_key] = open(stderr_fd_copy, "w")
+        faulthandler.enable(file=config._store[fault_handler_stderr_key])
+
+    def pytest_unconfigure(self, config: Config) -> None:
+        import faulthandler
+
+        faulthandler.disable()
+        # close our dup file installed during pytest_configure
+        # re-enable the faulthandler, attaching it to the default sys.stderr
+        # so we can see crashes after pytest has finished, usually during
+        # garbage collection during interpreter shutdown
+        config._store[fault_handler_stderr_key].close()
+        del config._store[fault_handler_stderr_key]
+        faulthandler.enable(file=self._get_stderr_fileno())
+
+    @staticmethod
+    def _get_stderr_fileno():
+        try:
+            fileno = sys.stderr.fileno()
+            # The Twisted Logger will return an invalid file descriptor since it is not backed
+            # by an FD. So, let's also forward this to the same code path as with pytest-xdist.
+            if fileno == -1:
+                raise AttributeError()
+            return fileno
+        except (AttributeError, io.UnsupportedOperation):
+            # pytest-xdist monkeypatches sys.stderr with an object that is not an actual file.
+            # https://docs.python.org/3/library/faulthandler.html#issue-with-file-descriptors
+            # This is potentially dangerous, but the best we can do.
+            return sys.__stderr__.fileno()
+
+    @staticmethod
+    def get_timeout_config_value(config):
+        return float(config.getini("faulthandler_timeout") or 0.0)
+
+    @pytest.hookimpl(hookwrapper=True, trylast=True)
+    def pytest_runtest_protocol(self, item: Item) -> Generator[None, None, None]:
+        timeout = self.get_timeout_config_value(item.config)
+        stderr = item.config._store[fault_handler_stderr_key]
+        if timeout > 0 and stderr is not None:
+            import faulthandler
+
+            faulthandler.dump_traceback_later(timeout, file=stderr)
+            try:
+                yield
+            finally:
+                faulthandler.cancel_dump_traceback_later()
+        else:
+            yield
+
+    @pytest.hookimpl(tryfirst=True)
+    def pytest_enter_pdb(self) -> None:
+        """Cancel any traceback dumping due to timeout before entering pdb."""
+        import faulthandler
+
+        faulthandler.cancel_dump_traceback_later()
+
+    @pytest.hookimpl(tryfirst=True)
+    def pytest_exception_interact(self) -> None:
+        """Cancel any traceback dumping due to an interactive exception being
+        raised."""
+        import faulthandler
+
+        faulthandler.cancel_dump_traceback_later()
diff --git a/myenv/lib/python3.9/site-packages/_pytest/fixtures.py b/myenv/lib/python3.9/site-packages/_pytest/fixtures.py
new file mode 100644
index 0000000..273bcaf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/fixtures.py
@@ -0,0 +1,1680 @@
+import functools
+import inspect
+import os
+import sys
+import warnings
+from collections import defaultdict
+from collections import deque
+from types import TracebackType
+from typing import Any
+from typing import Callable
+from typing import cast
+from typing import Dict
+from typing import Generator
+from typing import Generic
+from typing import Iterable
+from typing import Iterator
+from typing import List
+from typing import Optional
+from typing import overload
+from typing import Sequence
+from typing import Set
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import TypeVar
+from typing import Union
+
+import attr
+import py
+
+import _pytest
+from _pytest import nodes
+from _pytest._code import getfslineno
+from _pytest._code.code import FormattedExcinfo
+from _pytest._code.code import TerminalRepr
+from _pytest._io import TerminalWriter
+from _pytest.compat import _format_args
+from _pytest.compat import _PytestWrapper
+from _pytest.compat import assert_never
+from _pytest.compat import final
+from _pytest.compat import get_real_func
+from _pytest.compat import get_real_method
+from _pytest.compat import getfuncargnames
+from _pytest.compat import getimfunc
+from _pytest.compat import getlocation
+from _pytest.compat import is_generator
+from _pytest.compat import NOTSET
+from _pytest.compat import safe_getattr
+from _pytest.config import _PluggyPlugin
+from _pytest.config import Config
+from _pytest.config.argparsing import Parser
+from _pytest.deprecated import check_ispytest
+from _pytest.deprecated import FILLFUNCARGS
+from _pytest.deprecated import YIELD_FIXTURE
+from _pytest.mark import Mark
+from _pytest.mark import ParameterSet
+from _pytest.mark.structures import MarkDecorator
+from _pytest.outcomes import fail
+from _pytest.outcomes import TEST_OUTCOME
+from _pytest.pathlib import absolutepath
+from _pytest.store import StoreKey
+
+if TYPE_CHECKING:
+    from typing import Deque
+    from typing import NoReturn
+    from typing_extensions import Literal
+
+    from _pytest.main import Session
+    from _pytest.python import CallSpec2
+    from _pytest.python import Function
+    from _pytest.python import Metafunc
+
+    _Scope = Literal["session", "package", "module", "class", "function"]
+
+
+# The value of the fixture -- return/yield of the fixture function (type variable).
+_FixtureValue = TypeVar("_FixtureValue")
+# The type of the fixture function (type variable).
+_FixtureFunction = TypeVar("_FixtureFunction", bound=Callable[..., object])
+# The type of a fixture function (type alias generic in fixture value).
+_FixtureFunc = Union[
+    Callable[..., _FixtureValue], Callable[..., Generator[_FixtureValue, None, None]]
+]
+# The type of FixtureDef.cached_result (type alias generic in fixture value).
+_FixtureCachedResult = Union[
+    Tuple[
+        # The result.
+        _FixtureValue,
+        # Cache key.
+        object,
+        None,
+    ],
+    Tuple[
+        None,
+        # Cache key.
+        object,
+        # Exc info if raised.
+        Tuple[Type[BaseException], BaseException, TracebackType],
+    ],
+]
+
+
+@attr.s(frozen=True)
+class PseudoFixtureDef(Generic[_FixtureValue]):
+    cached_result = attr.ib(type="_FixtureCachedResult[_FixtureValue]")
+    scope = attr.ib(type="_Scope")
+
+
+def pytest_sessionstart(session: "Session") -> None:
+    session._fixturemanager = FixtureManager(session)
+
+
+def get_scope_package(node, fixturedef: "FixtureDef[object]"):
+    import pytest
+
+    cls = pytest.Package
+    current = node
+    fixture_package_name = "{}/{}".format(fixturedef.baseid, "__init__.py")
+    while current and (
+        type(current) is not cls or fixture_package_name != current.nodeid
+    ):
+        current = current.parent
+    if current is None:
+        return node.session
+    return current
+
+
+def get_scope_node(
+    node: nodes.Node, scope: "_Scope"
+) -> Optional[Union[nodes.Item, nodes.Collector]]:
+    import _pytest.python
+
+    if scope == "function":
+        return node.getparent(nodes.Item)
+    elif scope == "class":
+        return node.getparent(_pytest.python.Class)
+    elif scope == "module":
+        return node.getparent(_pytest.python.Module)
+    elif scope == "package":
+        return node.getparent(_pytest.python.Package)
+    elif scope == "session":
+        return node.getparent(_pytest.main.Session)
+    else:
+        assert_never(scope)
+
+
+# Used for storing artificial fixturedefs for direct parametrization.
+name2pseudofixturedef_key = StoreKey[Dict[str, "FixtureDef[Any]"]]()
+
+
+def add_funcarg_pseudo_fixture_def(
+    collector: nodes.Collector, metafunc: "Metafunc", fixturemanager: "FixtureManager"
+) -> None:
+    # This function will transform all collected calls to functions
+    # if they use direct funcargs (i.e. direct parametrization)
+    # because we want later test execution to be able to rely on
+    # an existing FixtureDef structure for all arguments.
+    # XXX we can probably avoid this algorithm  if we modify CallSpec2
+    # to directly care for creating the fixturedefs within its methods.
+    if not metafunc._calls[0].funcargs:
+        # This function call does not have direct parametrization.
+        return
+    # Collect funcargs of all callspecs into a list of values.
+    arg2params: Dict[str, List[object]] = {}
+    arg2scope: Dict[str, _Scope] = {}
+    for callspec in metafunc._calls:
+        for argname, argvalue in callspec.funcargs.items():
+            assert argname not in callspec.params
+            callspec.params[argname] = argvalue
+            arg2params_list = arg2params.setdefault(argname, [])
+            callspec.indices[argname] = len(arg2params_list)
+            arg2params_list.append(argvalue)
+            if argname not in arg2scope:
+                scopenum = callspec._arg2scopenum.get(argname, scopenum_function)
+                arg2scope[argname] = scopes[scopenum]
+        callspec.funcargs.clear()
+
+    # Register artificial FixtureDef's so that later at test execution
+    # time we can rely on a proper FixtureDef to exist for fixture setup.
+    arg2fixturedefs = metafunc._arg2fixturedefs
+    for argname, valuelist in arg2params.items():
+        # If we have a scope that is higher than function, we need
+        # to make sure we only ever create an according fixturedef on
+        # a per-scope basis. We thus store and cache the fixturedef on the
+        # node related to the scope.
+        scope = arg2scope[argname]
+        node = None
+        if scope != "function":
+            node = get_scope_node(collector, scope)
+            if node is None:
+                assert scope == "class" and isinstance(collector, _pytest.python.Module)
+                # Use module-level collector for class-scope (for now).
+                node = collector
+        if node is None:
+            name2pseudofixturedef = None
+        else:
+            default: Dict[str, FixtureDef[Any]] = {}
+            name2pseudofixturedef = node._store.setdefault(
+                name2pseudofixturedef_key, default
+            )
+        if name2pseudofixturedef is not None and argname in name2pseudofixturedef:
+            arg2fixturedefs[argname] = [name2pseudofixturedef[argname]]
+        else:
+            fixturedef = FixtureDef(
+                fixturemanager=fixturemanager,
+                baseid="",
+                argname=argname,
+                func=get_direct_param_fixture_func,
+                scope=arg2scope[argname],
+                params=valuelist,
+                unittest=False,
+                ids=None,
+            )
+            arg2fixturedefs[argname] = [fixturedef]
+            if name2pseudofixturedef is not None:
+                name2pseudofixturedef[argname] = fixturedef
+
+
+def getfixturemarker(obj: object) -> Optional["FixtureFunctionMarker"]:
+    """Return fixturemarker or None if it doesn't exist or raised
+    exceptions."""
+    try:
+        fixturemarker: Optional[FixtureFunctionMarker] = getattr(
+            obj, "_pytestfixturefunction", None
+        )
+    except TEST_OUTCOME:
+        # some objects raise errors like request (from flask import request)
+        # we don't expect them to be fixture functions
+        return None
+    return fixturemarker
+
+
+# Parametrized fixture key, helper alias for code below.
+_Key = Tuple[object, ...]
+
+
+def get_parametrized_fixture_keys(item: nodes.Item, scopenum: int) -> Iterator[_Key]:
+    """Return list of keys for all parametrized arguments which match
+    the specified scope. """
+    assert scopenum < scopenum_function  # function
+    try:
+        callspec = item.callspec  # type: ignore[attr-defined]
+    except AttributeError:
+        pass
+    else:
+        cs: CallSpec2 = callspec
+        # cs.indices.items() is random order of argnames.  Need to
+        # sort this so that different calls to
+        # get_parametrized_fixture_keys will be deterministic.
+        for argname, param_index in sorted(cs.indices.items()):
+            if cs._arg2scopenum[argname] != scopenum:
+                continue
+            if scopenum == 0:  # session
+                key: _Key = (argname, param_index)
+            elif scopenum == 1:  # package
+                key = (argname, param_index, item.fspath.dirpath())
+            elif scopenum == 2:  # module
+                key = (argname, param_index, item.fspath)
+            elif scopenum == 3:  # class
+                item_cls = item.cls  # type: ignore[attr-defined]
+                key = (argname, param_index, item.fspath, item_cls)
+            yield key
+
+
+# Algorithm for sorting on a per-parametrized resource setup basis.
+# It is called for scopenum==0 (session) first and performs sorting
+# down to the lower scopes such as to minimize number of "high scope"
+# setups and teardowns.
+
+
+def reorder_items(items: Sequence[nodes.Item]) -> List[nodes.Item]:
+    argkeys_cache: Dict[int, Dict[nodes.Item, Dict[_Key, None]]] = {}
+    items_by_argkey: Dict[int, Dict[_Key, Deque[nodes.Item]]] = {}
+    for scopenum in range(0, scopenum_function):
+        d: Dict[nodes.Item, Dict[_Key, None]] = {}
+        argkeys_cache[scopenum] = d
+        item_d: Dict[_Key, Deque[nodes.Item]] = defaultdict(deque)
+        items_by_argkey[scopenum] = item_d
+        for item in items:
+            keys = dict.fromkeys(get_parametrized_fixture_keys(item, scopenum), None)
+            if keys:
+                d[item] = keys
+                for key in keys:
+                    item_d[key].append(item)
+    items_dict = dict.fromkeys(items, None)
+    return list(reorder_items_atscope(items_dict, argkeys_cache, items_by_argkey, 0))
+
+
+def fix_cache_order(
+    item: nodes.Item,
+    argkeys_cache: Dict[int, Dict[nodes.Item, Dict[_Key, None]]],
+    items_by_argkey: Dict[int, Dict[_Key, "Deque[nodes.Item]"]],
+) -> None:
+    for scopenum in range(0, scopenum_function):
+        for key in argkeys_cache[scopenum].get(item, []):
+            items_by_argkey[scopenum][key].appendleft(item)
+
+
+def reorder_items_atscope(
+    items: Dict[nodes.Item, None],
+    argkeys_cache: Dict[int, Dict[nodes.Item, Dict[_Key, None]]],
+    items_by_argkey: Dict[int, Dict[_Key, "Deque[nodes.Item]"]],
+    scopenum: int,
+) -> Dict[nodes.Item, None]:
+    if scopenum >= scopenum_function or len(items) < 3:
+        return items
+    ignore: Set[Optional[_Key]] = set()
+    items_deque = deque(items)
+    items_done: Dict[nodes.Item, None] = {}
+    scoped_items_by_argkey = items_by_argkey[scopenum]
+    scoped_argkeys_cache = argkeys_cache[scopenum]
+    while items_deque:
+        no_argkey_group: Dict[nodes.Item, None] = {}
+        slicing_argkey = None
+        while items_deque:
+            item = items_deque.popleft()
+            if item in items_done or item in no_argkey_group:
+                continue
+            argkeys = dict.fromkeys(
+                (k for k in scoped_argkeys_cache.get(item, []) if k not in ignore), None
+            )
+            if not argkeys:
+                no_argkey_group[item] = None
+            else:
+                slicing_argkey, _ = argkeys.popitem()
+                # We don't have to remove relevant items from later in the
+                # deque because they'll just be ignored.
+                matching_items = [
+                    i for i in scoped_items_by_argkey[slicing_argkey] if i in items
+                ]
+                for i in reversed(matching_items):
+                    fix_cache_order(i, argkeys_cache, items_by_argkey)
+                    items_deque.appendleft(i)
+                break
+        if no_argkey_group:
+            no_argkey_group = reorder_items_atscope(
+                no_argkey_group, argkeys_cache, items_by_argkey, scopenum + 1
+            )
+            for item in no_argkey_group:
+                items_done[item] = None
+        ignore.add(slicing_argkey)
+    return items_done
+
+
+def _fillfuncargs(function: "Function") -> None:
+    """Fill missing fixtures for a test function, old public API (deprecated)."""
+    warnings.warn(FILLFUNCARGS.format(name="pytest._fillfuncargs()"), stacklevel=2)
+    _fill_fixtures_impl(function)
+
+
+def fillfixtures(function: "Function") -> None:
+    """Fill missing fixtures for a test function (deprecated)."""
+    warnings.warn(
+        FILLFUNCARGS.format(name="_pytest.fixtures.fillfixtures()"), stacklevel=2
+    )
+    _fill_fixtures_impl(function)
+
+
+def _fill_fixtures_impl(function: "Function") -> None:
+    """Internal implementation to fill fixtures on the given function object."""
+    try:
+        request = function._request
+    except AttributeError:
+        # XXX this special code path is only expected to execute
+        # with the oejskit plugin.  It uses classes with funcargs
+        # and we thus have to work a bit to allow this.
+        fm = function.session._fixturemanager
+        assert function.parent is not None
+        fi = fm.getfixtureinfo(function.parent, function.obj, None)
+        function._fixtureinfo = fi
+        request = function._request = FixtureRequest(function, _ispytest=True)
+        request._fillfixtures()
+        # Prune out funcargs for jstests.
+        newfuncargs = {}
+        for name in fi.argnames:
+            newfuncargs[name] = function.funcargs[name]
+        function.funcargs = newfuncargs
+    else:
+        request._fillfixtures()
+
+
+def get_direct_param_fixture_func(request):
+    return request.param
+
+
+@attr.s(slots=True)
+class FuncFixtureInfo:
+    # Original function argument names.
+    argnames = attr.ib(type=Tuple[str, ...])
+    # Argnames that function immediately requires. These include argnames +
+    # fixture names specified via usefixtures and via autouse=True in fixture
+    # definitions.
+    initialnames = attr.ib(type=Tuple[str, ...])
+    names_closure = attr.ib(type=List[str])
+    name2fixturedefs = attr.ib(type=Dict[str, Sequence["FixtureDef[Any]"]])
+
+    def prune_dependency_tree(self) -> None:
+        """Recompute names_closure from initialnames and name2fixturedefs.
+
+        Can only reduce names_closure, which means that the new closure will
+        always be a subset of the old one. The order is preserved.
+
+        This method is needed because direct parametrization may shadow some
+        of the fixtures that were included in the originally built dependency
+        tree. In this way the dependency tree can get pruned, and the closure
+        of argnames may get reduced.
+        """
+        closure: Set[str] = set()
+        working_set = set(self.initialnames)
+        while working_set:
+            argname = working_set.pop()
+            # Argname may be smth not included in the original names_closure,
+            # in which case we ignore it. This currently happens with pseudo
+            # FixtureDefs which wrap 'get_direct_param_fixture_func(request)'.
+            # So they introduce the new dependency 'request' which might have
+            # been missing in the original tree (closure).
+            if argname not in closure and argname in self.names_closure:
+                closure.add(argname)
+                if argname in self.name2fixturedefs:
+                    working_set.update(self.name2fixturedefs[argname][-1].argnames)
+
+        self.names_closure[:] = sorted(closure, key=self.names_closure.index)
+
+
+class FixtureRequest:
+    """A request for a fixture from a test or fixture function.
+
+    A request object gives access to the requesting test context and has
+    an optional ``param`` attribute in case the fixture is parametrized
+    indirectly.
+    """
+
+    def __init__(self, pyfuncitem, *, _ispytest: bool = False) -> None:
+        check_ispytest(_ispytest)
+        self._pyfuncitem = pyfuncitem
+        #: Fixture for which this request is being performed.
+        self.fixturename: Optional[str] = None
+        #: Scope string, one of "function", "class", "module", "session".
+        self.scope: _Scope = "function"
+        self._fixture_defs: Dict[str, FixtureDef[Any]] = {}
+        fixtureinfo: FuncFixtureInfo = pyfuncitem._fixtureinfo
+        self._arg2fixturedefs = fixtureinfo.name2fixturedefs.copy()
+        self._arg2index: Dict[str, int] = {}
+        self._fixturemanager: FixtureManager = (pyfuncitem.session._fixturemanager)
+
+    @property
+    def fixturenames(self) -> List[str]:
+        """Names of all active fixtures in this request."""
+        result = list(self._pyfuncitem._fixtureinfo.names_closure)
+        result.extend(set(self._fixture_defs).difference(result))
+        return result
+
+    @property
+    def node(self):
+        """Underlying collection node (depends on current request scope)."""
+        return self._getscopeitem(self.scope)
+
+    def _getnextfixturedef(self, argname: str) -> "FixtureDef[Any]":
+        fixturedefs = self._arg2fixturedefs.get(argname, None)
+        if fixturedefs is None:
+            # We arrive here because of a dynamic call to
+            # getfixturevalue(argname) usage which was naturally
+            # not known at parsing/collection time.
+            assert self._pyfuncitem.parent is not None
+            parentid = self._pyfuncitem.parent.nodeid
+            fixturedefs = self._fixturemanager.getfixturedefs(argname, parentid)
+            # TODO: Fix this type ignore. Either add assert or adjust types.
+            #       Can this be None here?
+            self._arg2fixturedefs[argname] = fixturedefs  # type: ignore[assignment]
+        # fixturedefs list is immutable so we maintain a decreasing index.
+        index = self._arg2index.get(argname, 0) - 1
+        if fixturedefs is None or (-index > len(fixturedefs)):
+            raise FixtureLookupError(argname, self)
+        self._arg2index[argname] = index
+        return fixturedefs[index]
+
+    @property
+    def config(self) -> Config:
+        """The pytest config object associated with this request."""
+        return self._pyfuncitem.config  # type: ignore[no-any-return]
+
+    @property
+    def function(self):
+        """Test function object if the request has a per-function scope."""
+        if self.scope != "function":
+            raise AttributeError(
+                f"function not available in {self.scope}-scoped context"
+            )
+        return self._pyfuncitem.obj
+
+    @property
+    def cls(self):
+        """Class (can be None) where the test function was collected."""
+        if self.scope not in ("class", "function"):
+            raise AttributeError(f"cls not available in {self.scope}-scoped context")
+        clscol = self._pyfuncitem.getparent(_pytest.python.Class)
+        if clscol:
+            return clscol.obj
+
+    @property
+    def instance(self):
+        """Instance (can be None) on which test function was collected."""
+        # unittest support hack, see _pytest.unittest.TestCaseFunction.
+        try:
+            return self._pyfuncitem._testcase
+        except AttributeError:
+            function = getattr(self, "function", None)
+            return getattr(function, "__self__", None)
+
+    @property
+    def module(self):
+        """Python module object where the test function was collected."""
+        if self.scope not in ("function", "class", "module"):
+            raise AttributeError(f"module not available in {self.scope}-scoped context")
+        return self._pyfuncitem.getparent(_pytest.python.Module).obj
+
+    @property
+    def fspath(self) -> py.path.local:
+        """The file system path of the test module which collected this test."""
+        if self.scope not in ("function", "class", "module", "package"):
+            raise AttributeError(f"module not available in {self.scope}-scoped context")
+        # TODO: Remove ignore once _pyfuncitem is properly typed.
+        return self._pyfuncitem.fspath  # type: ignore
+
+    @property
+    def keywords(self):
+        """Keywords/markers dictionary for the underlying node."""
+        return self.node.keywords
+
+    @property
+    def session(self) -> "Session":
+        """Pytest session object."""
+        return self._pyfuncitem.session  # type: ignore[no-any-return]
+
+    def addfinalizer(self, finalizer: Callable[[], object]) -> None:
+        """Add finalizer/teardown function to be called after the last test
+        within the requesting test context finished execution."""
+        # XXX usually this method is shadowed by fixturedef specific ones.
+        self._addfinalizer(finalizer, scope=self.scope)
+
+    def _addfinalizer(self, finalizer: Callable[[], object], scope) -> None:
+        colitem = self._getscopeitem(scope)
+        self._pyfuncitem.session._setupstate.addfinalizer(
+            finalizer=finalizer, colitem=colitem
+        )
+
+    def applymarker(self, marker: Union[str, MarkDecorator]) -> None:
+        """Apply a marker to a single test function invocation.
+
+        This method is useful if you don't want to have a keyword/marker
+        on all function invocations.
+
+        :param marker:
+            A :py:class:`_pytest.mark.MarkDecorator` object created by a call
+            to ``pytest.mark.NAME(...)``.
+        """
+        self.node.add_marker(marker)
+
+    def raiseerror(self, msg: Optional[str]) -> "NoReturn":
+        """Raise a FixtureLookupError with the given message."""
+        raise self._fixturemanager.FixtureLookupError(None, self, msg)
+
+    def _fillfixtures(self) -> None:
+        item = self._pyfuncitem
+        fixturenames = getattr(item, "fixturenames", self.fixturenames)
+        for argname in fixturenames:
+            if argname not in item.funcargs:
+                item.funcargs[argname] = self.getfixturevalue(argname)
+
+    def getfixturevalue(self, argname: str) -> Any:
+        """Dynamically run a named fixture function.
+
+        Declaring fixtures via function argument is recommended where possible.
+        But if you can only decide whether to use another fixture at test
+        setup time, you may use this function to retrieve it inside a fixture
+        or test function body.
+
+        :raises pytest.FixtureLookupError:
+            If the given fixture could not be found.
+        """
+        fixturedef = self._get_active_fixturedef(argname)
+        assert fixturedef.cached_result is not None
+        return fixturedef.cached_result[0]
+
+    def _get_active_fixturedef(
+        self, argname: str
+    ) -> Union["FixtureDef[object]", PseudoFixtureDef[object]]:
+        try:
+            return self._fixture_defs[argname]
+        except KeyError:
+            try:
+                fixturedef = self._getnextfixturedef(argname)
+            except FixtureLookupError:
+                if argname == "request":
+                    cached_result = (self, [0], None)
+                    scope: _Scope = "function"
+                    return PseudoFixtureDef(cached_result, scope)
+                raise
+        # Remove indent to prevent the python3 exception
+        # from leaking into the call.
+        self._compute_fixture_value(fixturedef)
+        self._fixture_defs[argname] = fixturedef
+        return fixturedef
+
+    def _get_fixturestack(self) -> List["FixtureDef[Any]"]:
+        current = self
+        values: List[FixtureDef[Any]] = []
+        while 1:
+            fixturedef = getattr(current, "_fixturedef", None)
+            if fixturedef is None:
+                values.reverse()
+                return values
+            values.append(fixturedef)
+            assert isinstance(current, SubRequest)
+            current = current._parent_request
+
+    def _compute_fixture_value(self, fixturedef: "FixtureDef[object]") -> None:
+        """Create a SubRequest based on "self" and call the execute method
+        of the given FixtureDef object.
+
+        This will force the FixtureDef object to throw away any previous
+        results and compute a new fixture value, which will be stored into
+        the FixtureDef object itself.
+        """
+        # prepare a subrequest object before calling fixture function
+        # (latter managed by fixturedef)
+        argname = fixturedef.argname
+        funcitem = self._pyfuncitem
+        scope = fixturedef.scope
+        try:
+            param = funcitem.callspec.getparam(argname)
+        except (AttributeError, ValueError):
+            param = NOTSET
+            param_index = 0
+            has_params = fixturedef.params is not None
+            fixtures_not_supported = getattr(funcitem, "nofuncargs", False)
+            if has_params and fixtures_not_supported:
+                msg = (
+                    "{name} does not support fixtures, maybe unittest.TestCase subclass?\n"
+                    "Node id: {nodeid}\n"
+                    "Function type: {typename}"
+                ).format(
+                    name=funcitem.name,
+                    nodeid=funcitem.nodeid,
+                    typename=type(funcitem).__name__,
+                )
+                fail(msg, pytrace=False)
+            if has_params:
+                frame = inspect.stack()[3]
+                frameinfo = inspect.getframeinfo(frame[0])
+                source_path = py.path.local(frameinfo.filename)
+                source_lineno = frameinfo.lineno
+                rel_source_path = source_path.relto(funcitem.config.rootdir)
+                if rel_source_path:
+                    source_path_str = rel_source_path
+                else:
+                    source_path_str = str(source_path)
+                msg = (
+                    "The requested fixture has no parameter defined for test:\n"
+                    "    {}\n\n"
+                    "Requested fixture '{}' defined in:\n{}"
+                    "\n\nRequested here:\n{}:{}".format(
+                        funcitem.nodeid,
+                        fixturedef.argname,
+                        getlocation(fixturedef.func, funcitem.config.rootdir),
+                        source_path_str,
+                        source_lineno,
+                    )
+                )
+                fail(msg, pytrace=False)
+        else:
+            param_index = funcitem.callspec.indices[argname]
+            # If a parametrize invocation set a scope it will override
+            # the static scope defined with the fixture function.
+            paramscopenum = funcitem.callspec._arg2scopenum.get(argname)
+            if paramscopenum is not None:
+                scope = scopes[paramscopenum]
+
+        subrequest = SubRequest(
+            self, scope, param, param_index, fixturedef, _ispytest=True
+        )
+
+        # Check if a higher-level scoped fixture accesses a lower level one.
+        subrequest._check_scope(argname, self.scope, scope)
+        try:
+            # Call the fixture function.
+            fixturedef.execute(request=subrequest)
+        finally:
+            self._schedule_finalizers(fixturedef, subrequest)
+
+    def _schedule_finalizers(
+        self, fixturedef: "FixtureDef[object]", subrequest: "SubRequest"
+    ) -> None:
+        # If fixture function failed it might have registered finalizers.
+        self.session._setupstate.addfinalizer(
+            functools.partial(fixturedef.finish, request=subrequest), subrequest.node
+        )
+
+    def _check_scope(
+        self, argname: str, invoking_scope: "_Scope", requested_scope: "_Scope",
+    ) -> None:
+        if argname == "request":
+            return
+        if scopemismatch(invoking_scope, requested_scope):
+            # Try to report something helpful.
+            lines = self._factorytraceback()
+            fail(
+                "ScopeMismatch: You tried to access the %r scoped "
+                "fixture %r with a %r scoped request object, "
+                "involved factories\n%s"
+                % ((requested_scope, argname, invoking_scope, "\n".join(lines))),
+                pytrace=False,
+            )
+
+    def _factorytraceback(self) -> List[str]:
+        lines = []
+        for fixturedef in self._get_fixturestack():
+            factory = fixturedef.func
+            fs, lineno = getfslineno(factory)
+            p = self._pyfuncitem.session.fspath.bestrelpath(fs)
+            args = _format_args(factory)
+            lines.append("%s:%d:  def %s%s" % (p, lineno + 1, factory.__name__, args))
+        return lines
+
+    def _getscopeitem(self, scope: "_Scope") -> Union[nodes.Item, nodes.Collector]:
+        if scope == "function":
+            # This might also be a non-function Item despite its attribute name.
+            node: Optional[Union[nodes.Item, nodes.Collector]] = self._pyfuncitem
+        elif scope == "package":
+            # FIXME: _fixturedef is not defined on FixtureRequest (this class),
+            # but on FixtureRequest (a subclass).
+            node = get_scope_package(self._pyfuncitem, self._fixturedef)  # type: ignore[attr-defined]
+        else:
+            node = get_scope_node(self._pyfuncitem, scope)
+        if node is None and scope == "class":
+            # Fallback to function item itself.
+            node = self._pyfuncitem
+        assert node, 'Could not obtain a node for scope "{}" for function {!r}'.format(
+            scope, self._pyfuncitem
+        )
+        return node
+
+    def __repr__(self) -> str:
+        return "<FixtureRequest for %r>" % (self.node)
+
+
+@final
+class SubRequest(FixtureRequest):
+    """A sub request for handling getting a fixture from a test function/fixture."""
+
+    def __init__(
+        self,
+        request: "FixtureRequest",
+        scope: "_Scope",
+        param,
+        param_index: int,
+        fixturedef: "FixtureDef[object]",
+        *,
+        _ispytest: bool = False,
+    ) -> None:
+        check_ispytest(_ispytest)
+        self._parent_request = request
+        self.fixturename = fixturedef.argname
+        if param is not NOTSET:
+            self.param = param
+        self.param_index = param_index
+        self.scope = scope
+        self._fixturedef = fixturedef
+        self._pyfuncitem = request._pyfuncitem
+        self._fixture_defs = request._fixture_defs
+        self._arg2fixturedefs = request._arg2fixturedefs
+        self._arg2index = request._arg2index
+        self._fixturemanager = request._fixturemanager
+
+    def __repr__(self) -> str:
+        return f"<SubRequest {self.fixturename!r} for {self._pyfuncitem!r}>"
+
+    def addfinalizer(self, finalizer: Callable[[], object]) -> None:
+        """Add finalizer/teardown function to be called after the last test
+        within the requesting test context finished execution."""
+        self._fixturedef.addfinalizer(finalizer)
+
+    def _schedule_finalizers(
+        self, fixturedef: "FixtureDef[object]", subrequest: "SubRequest"
+    ) -> None:
+        # If the executing fixturedef was not explicitly requested in the argument list (via
+        # getfixturevalue inside the fixture call) then ensure this fixture def will be finished
+        # first.
+        if fixturedef.argname not in self.fixturenames:
+            fixturedef.addfinalizer(
+                functools.partial(self._fixturedef.finish, request=self)
+            )
+        super()._schedule_finalizers(fixturedef, subrequest)
+
+
+scopes: List["_Scope"] = ["session", "package", "module", "class", "function"]
+scopenum_function = scopes.index("function")
+
+
+def scopemismatch(currentscope: "_Scope", newscope: "_Scope") -> bool:
+    return scopes.index(newscope) > scopes.index(currentscope)
+
+
+def scope2index(scope: str, descr: str, where: Optional[str] = None) -> int:
+    """Look up the index of ``scope`` and raise a descriptive value error
+    if not defined."""
+    strscopes: Sequence[str] = scopes
+    try:
+        return strscopes.index(scope)
+    except ValueError:
+        fail(
+            "{} {}got an unexpected scope value '{}'".format(
+                descr, f"from {where} " if where else "", scope
+            ),
+            pytrace=False,
+        )
+
+
+@final
+class FixtureLookupError(LookupError):
+    """Could not return a requested fixture (missing or invalid)."""
+
+    def __init__(
+        self, argname: Optional[str], request: FixtureRequest, msg: Optional[str] = None
+    ) -> None:
+        self.argname = argname
+        self.request = request
+        self.fixturestack = request._get_fixturestack()
+        self.msg = msg
+
+    def formatrepr(self) -> "FixtureLookupErrorRepr":
+        tblines: List[str] = []
+        addline = tblines.append
+        stack = [self.request._pyfuncitem.obj]
+        stack.extend(map(lambda x: x.func, self.fixturestack))
+        msg = self.msg
+        if msg is not None:
+            # The last fixture raise an error, let's present
+            # it at the requesting side.
+            stack = stack[:-1]
+        for function in stack:
+            fspath, lineno = getfslineno(function)
+            try:
+                lines, _ = inspect.getsourcelines(get_real_func(function))
+            except (OSError, IndexError, TypeError):
+                error_msg = "file %s, line %s: source code not available"
+                addline(error_msg % (fspath, lineno + 1))
+            else:
+                addline("file {}, line {}".format(fspath, lineno + 1))
+                for i, line in enumerate(lines):
+                    line = line.rstrip()
+                    addline("  " + line)
+                    if line.lstrip().startswith("def"):
+                        break
+
+        if msg is None:
+            fm = self.request._fixturemanager
+            available = set()
+            parentid = self.request._pyfuncitem.parent.nodeid
+            for name, fixturedefs in fm._arg2fixturedefs.items():
+                faclist = list(fm._matchfactories(fixturedefs, parentid))
+                if faclist:
+                    available.add(name)
+            if self.argname in available:
+                msg = " recursive dependency involving fixture '{}' detected".format(
+                    self.argname
+                )
+            else:
+                msg = f"fixture '{self.argname}' not found"
+            msg += "\n available fixtures: {}".format(", ".join(sorted(available)))
+            msg += "\n use 'pytest --fixtures [testpath]' for help on them."
+
+        return FixtureLookupErrorRepr(fspath, lineno, tblines, msg, self.argname)
+
+
+class FixtureLookupErrorRepr(TerminalRepr):
+    def __init__(
+        self,
+        filename: Union[str, py.path.local],
+        firstlineno: int,
+        tblines: Sequence[str],
+        errorstring: str,
+        argname: Optional[str],
+    ) -> None:
+        self.tblines = tblines
+        self.errorstring = errorstring
+        self.filename = filename
+        self.firstlineno = firstlineno
+        self.argname = argname
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        # tw.line("FixtureLookupError: %s" %(self.argname), red=True)
+        for tbline in self.tblines:
+            tw.line(tbline.rstrip())
+        lines = self.errorstring.split("\n")
+        if lines:
+            tw.line(
+                "{}       {}".format(FormattedExcinfo.fail_marker, lines[0].strip()),
+                red=True,
+            )
+            for line in lines[1:]:
+                tw.line(
+                    f"{FormattedExcinfo.flow_marker}       {line.strip()}", red=True,
+                )
+        tw.line()
+        tw.line("%s:%d" % (self.filename, self.firstlineno + 1))
+
+
+def fail_fixturefunc(fixturefunc, msg: str) -> "NoReturn":
+    fs, lineno = getfslineno(fixturefunc)
+    location = "{}:{}".format(fs, lineno + 1)
+    source = _pytest._code.Source(fixturefunc)
+    fail(msg + ":\n\n" + str(source.indent()) + "\n" + location, pytrace=False)
+
+
+def call_fixture_func(
+    fixturefunc: "_FixtureFunc[_FixtureValue]", request: FixtureRequest, kwargs
+) -> _FixtureValue:
+    if is_generator(fixturefunc):
+        fixturefunc = cast(
+            Callable[..., Generator[_FixtureValue, None, None]], fixturefunc
+        )
+        generator = fixturefunc(**kwargs)
+        try:
+            fixture_result = next(generator)
+        except StopIteration:
+            raise ValueError(f"{request.fixturename} did not yield a value") from None
+        finalizer = functools.partial(_teardown_yield_fixture, fixturefunc, generator)
+        request.addfinalizer(finalizer)
+    else:
+        fixturefunc = cast(Callable[..., _FixtureValue], fixturefunc)
+        fixture_result = fixturefunc(**kwargs)
+    return fixture_result
+
+
+def _teardown_yield_fixture(fixturefunc, it) -> None:
+    """Execute the teardown of a fixture function by advancing the iterator
+    after the yield and ensure the iteration ends (if not it means there is
+    more than one yield in the function)."""
+    try:
+        next(it)
+    except StopIteration:
+        pass
+    else:
+        fail_fixturefunc(fixturefunc, "fixture function has more than one 'yield'")
+
+
+def _eval_scope_callable(
+    scope_callable: "Callable[[str, Config], _Scope]",
+    fixture_name: str,
+    config: Config,
+) -> "_Scope":
+    try:
+        # Type ignored because there is no typing mechanism to specify
+        # keyword arguments, currently.
+        result = scope_callable(fixture_name=fixture_name, config=config)  # type: ignore[call-arg]
+    except Exception as e:
+        raise TypeError(
+            "Error evaluating {} while defining fixture '{}'.\n"
+            "Expected a function with the signature (*, fixture_name, config)".format(
+                scope_callable, fixture_name
+            )
+        ) from e
+    if not isinstance(result, str):
+        fail(
+            "Expected {} to return a 'str' while defining fixture '{}', but it returned:\n"
+            "{!r}".format(scope_callable, fixture_name, result),
+            pytrace=False,
+        )
+    return result
+
+
+@final
+class FixtureDef(Generic[_FixtureValue]):
+    """A container for a factory definition."""
+
+    def __init__(
+        self,
+        fixturemanager: "FixtureManager",
+        baseid: Optional[str],
+        argname: str,
+        func: "_FixtureFunc[_FixtureValue]",
+        scope: "Union[_Scope, Callable[[str, Config], _Scope]]",
+        params: Optional[Sequence[object]],
+        unittest: bool = False,
+        ids: Optional[
+            Union[
+                Tuple[Union[None, str, float, int, bool], ...],
+                Callable[[Any], Optional[object]],
+            ]
+        ] = None,
+    ) -> None:
+        self._fixturemanager = fixturemanager
+        self.baseid = baseid or ""
+        self.has_location = baseid is not None
+        self.func = func
+        self.argname = argname
+        if callable(scope):
+            scope_ = _eval_scope_callable(scope, argname, fixturemanager.config)
+        else:
+            scope_ = scope
+        self.scopenum = scope2index(
+            # TODO: Check if the `or` here is really necessary.
+            scope_ or "function",  # type: ignore[unreachable]
+            descr=f"Fixture '{func.__name__}'",
+            where=baseid,
+        )
+        self.scope = scope_
+        self.params: Optional[Sequence[object]] = params
+        self.argnames: Tuple[str, ...] = getfuncargnames(
+            func, name=argname, is_method=unittest
+        )
+        self.unittest = unittest
+        self.ids = ids
+        self.cached_result: Optional[_FixtureCachedResult[_FixtureValue]] = None
+        self._finalizers: List[Callable[[], object]] = []
+
+    def addfinalizer(self, finalizer: Callable[[], object]) -> None:
+        self._finalizers.append(finalizer)
+
+    def finish(self, request: SubRequest) -> None:
+        exc = None
+        try:
+            while self._finalizers:
+                try:
+                    func = self._finalizers.pop()
+                    func()
+                except BaseException as e:
+                    # XXX Only first exception will be seen by user,
+                    #     ideally all should be reported.
+                    if exc is None:
+                        exc = e
+            if exc:
+                raise exc
+        finally:
+            hook = self._fixturemanager.session.gethookproxy(request.node.fspath)
+            hook.pytest_fixture_post_finalizer(fixturedef=self, request=request)
+            # Even if finalization fails, we invalidate the cached fixture
+            # value and remove all finalizers because they may be bound methods
+            # which will keep instances alive.
+            self.cached_result = None
+            self._finalizers = []
+
+    def execute(self, request: SubRequest) -> _FixtureValue:
+        # Get required arguments and register our own finish()
+        # with their finalization.
+        for argname in self.argnames:
+            fixturedef = request._get_active_fixturedef(argname)
+            if argname != "request":
+                # PseudoFixtureDef is only for "request".
+                assert isinstance(fixturedef, FixtureDef)
+                fixturedef.addfinalizer(functools.partial(self.finish, request=request))
+
+        my_cache_key = self.cache_key(request)
+        if self.cached_result is not None:
+            # note: comparison with `==` can fail (or be expensive) for e.g.
+            # numpy arrays (#6497).
+            cache_key = self.cached_result[1]
+            if my_cache_key is cache_key:
+                if self.cached_result[2] is not None:
+                    _, val, tb = self.cached_result[2]
+                    raise val.with_traceback(tb)
+                else:
+                    result = self.cached_result[0]
+                    return result
+            # We have a previous but differently parametrized fixture instance
+            # so we need to tear it down before creating a new one.
+            self.finish(request)
+            assert self.cached_result is None
+
+        hook = self._fixturemanager.session.gethookproxy(request.node.fspath)
+        result = hook.pytest_fixture_setup(fixturedef=self, request=request)
+        return result
+
+    def cache_key(self, request: SubRequest) -> object:
+        return request.param_index if not hasattr(request, "param") else request.param
+
+    def __repr__(self) -> str:
+        return "<FixtureDef argname={!r} scope={!r} baseid={!r}>".format(
+            self.argname, self.scope, self.baseid
+        )
+
+
+def resolve_fixture_function(
+    fixturedef: FixtureDef[_FixtureValue], request: FixtureRequest
+) -> "_FixtureFunc[_FixtureValue]":
+    """Get the actual callable that can be called to obtain the fixture
+    value, dealing with unittest-specific instances and bound methods."""
+    fixturefunc = fixturedef.func
+    if fixturedef.unittest:
+        if request.instance is not None:
+            # Bind the unbound method to the TestCase instance.
+            fixturefunc = fixturedef.func.__get__(request.instance)  # type: ignore[union-attr]
+    else:
+        # The fixture function needs to be bound to the actual
+        # request.instance so that code working with "fixturedef" behaves
+        # as expected.
+        if request.instance is not None:
+            # Handle the case where fixture is defined not in a test class, but some other class
+            # (for example a plugin class with a fixture), see #2270.
+            if hasattr(fixturefunc, "__self__") and not isinstance(
+                request.instance, fixturefunc.__self__.__class__  # type: ignore[union-attr]
+            ):
+                return fixturefunc
+            fixturefunc = getimfunc(fixturedef.func)
+            if fixturefunc != fixturedef.func:
+                fixturefunc = fixturefunc.__get__(request.instance)  # type: ignore[union-attr]
+    return fixturefunc
+
+
+def pytest_fixture_setup(
+    fixturedef: FixtureDef[_FixtureValue], request: SubRequest
+) -> _FixtureValue:
+    """Execution of fixture setup."""
+    kwargs = {}
+    for argname in fixturedef.argnames:
+        fixdef = request._get_active_fixturedef(argname)
+        assert fixdef.cached_result is not None
+        result, arg_cache_key, exc = fixdef.cached_result
+        request._check_scope(argname, request.scope, fixdef.scope)
+        kwargs[argname] = result
+
+    fixturefunc = resolve_fixture_function(fixturedef, request)
+    my_cache_key = fixturedef.cache_key(request)
+    try:
+        result = call_fixture_func(fixturefunc, request, kwargs)
+    except TEST_OUTCOME:
+        exc_info = sys.exc_info()
+        assert exc_info[0] is not None
+        fixturedef.cached_result = (None, my_cache_key, exc_info)
+        raise
+    fixturedef.cached_result = (result, my_cache_key, None)
+    return result
+
+
+def _ensure_immutable_ids(
+    ids: Optional[
+        Union[
+            Iterable[Union[None, str, float, int, bool]],
+            Callable[[Any], Optional[object]],
+        ]
+    ],
+) -> Optional[
+    Union[
+        Tuple[Union[None, str, float, int, bool], ...],
+        Callable[[Any], Optional[object]],
+    ]
+]:
+    if ids is None:
+        return None
+    if callable(ids):
+        return ids
+    return tuple(ids)
+
+
+def _params_converter(
+    params: Optional[Iterable[object]],
+) -> Optional[Tuple[object, ...]]:
+    return tuple(params) if params is not None else None
+
+
+def wrap_function_to_error_out_if_called_directly(
+    function: _FixtureFunction, fixture_marker: "FixtureFunctionMarker",
+) -> _FixtureFunction:
+    """Wrap the given fixture function so we can raise an error about it being called directly,
+    instead of used as an argument in a test function."""
+    message = (
+        'Fixture "{name}" called directly. Fixtures are not meant to be called directly,\n'
+        "but are created automatically when test functions request them as parameters.\n"
+        "See https://docs.pytest.org/en/stable/fixture.html for more information about fixtures, and\n"
+        "https://docs.pytest.org/en/stable/deprecations.html#calling-fixtures-directly about how to update your code."
+    ).format(name=fixture_marker.name or function.__name__)
+
+    @functools.wraps(function)
+    def result(*args, **kwargs):
+        fail(message, pytrace=False)
+
+    # Keep reference to the original function in our own custom attribute so we don't unwrap
+    # further than this point and lose useful wrappings like @mock.patch (#3774).
+    result.__pytest_wrapped__ = _PytestWrapper(function)  # type: ignore[attr-defined]
+
+    return cast(_FixtureFunction, result)
+
+
+@final
+@attr.s(frozen=True)
+class FixtureFunctionMarker:
+    scope = attr.ib(type="Union[_Scope, Callable[[str, Config], _Scope]]")
+    params = attr.ib(type=Optional[Tuple[object, ...]], converter=_params_converter)
+    autouse = attr.ib(type=bool, default=False)
+    ids = attr.ib(
+        type=Union[
+            Tuple[Union[None, str, float, int, bool], ...],
+            Callable[[Any], Optional[object]],
+        ],
+        default=None,
+        converter=_ensure_immutable_ids,
+    )
+    name = attr.ib(type=Optional[str], default=None)
+
+    def __call__(self, function: _FixtureFunction) -> _FixtureFunction:
+        if inspect.isclass(function):
+            raise ValueError("class fixtures not supported (maybe in the future)")
+
+        if getattr(function, "_pytestfixturefunction", False):
+            raise ValueError(
+                "fixture is being applied more than once to the same function"
+            )
+
+        function = wrap_function_to_error_out_if_called_directly(function, self)
+
+        name = self.name or function.__name__
+        if name == "request":
+            location = getlocation(function)
+            fail(
+                "'request' is a reserved word for fixtures, use another name:\n  {}".format(
+                    location
+                ),
+                pytrace=False,
+            )
+
+        # Type ignored because https://github.com/python/mypy/issues/2087.
+        function._pytestfixturefunction = self  # type: ignore[attr-defined]
+        return function
+
+
+@overload
+def fixture(
+    fixture_function: _FixtureFunction,
+    *,
+    scope: "Union[_Scope, Callable[[str, Config], _Scope]]" = ...,
+    params: Optional[Iterable[object]] = ...,
+    autouse: bool = ...,
+    ids: Optional[
+        Union[
+            Iterable[Union[None, str, float, int, bool]],
+            Callable[[Any], Optional[object]],
+        ]
+    ] = ...,
+    name: Optional[str] = ...,
+) -> _FixtureFunction:
+    ...
+
+
+@overload
+def fixture(
+    fixture_function: None = ...,
+    *,
+    scope: "Union[_Scope, Callable[[str, Config], _Scope]]" = ...,
+    params: Optional[Iterable[object]] = ...,
+    autouse: bool = ...,
+    ids: Optional[
+        Union[
+            Iterable[Union[None, str, float, int, bool]],
+            Callable[[Any], Optional[object]],
+        ]
+    ] = ...,
+    name: Optional[str] = None,
+) -> FixtureFunctionMarker:
+    ...
+
+
+def fixture(
+    fixture_function: Optional[_FixtureFunction] = None,
+    *,
+    scope: "Union[_Scope, Callable[[str, Config], _Scope]]" = "function",
+    params: Optional[Iterable[object]] = None,
+    autouse: bool = False,
+    ids: Optional[
+        Union[
+            Iterable[Union[None, str, float, int, bool]],
+            Callable[[Any], Optional[object]],
+        ]
+    ] = None,
+    name: Optional[str] = None,
+) -> Union[FixtureFunctionMarker, _FixtureFunction]:
+    """Decorator to mark a fixture factory function.
+
+    This decorator can be used, with or without parameters, to define a
+    fixture function.
+
+    The name of the fixture function can later be referenced to cause its
+    invocation ahead of running tests: test modules or classes can use the
+    ``pytest.mark.usefixtures(fixturename)`` marker.
+
+    Test functions can directly use fixture names as input arguments in which
+    case the fixture instance returned from the fixture function will be
+    injected.
+
+    Fixtures can provide their values to test functions using ``return`` or
+    ``yield`` statements. When using ``yield`` the code block after the
+    ``yield`` statement is executed as teardown code regardless of the test
+    outcome, and must yield exactly once.
+
+    :param scope:
+        The scope for which this fixture is shared; one of ``"function"``
+        (default), ``"class"``, ``"module"``, ``"package"`` or ``"session"``.
+
+        This parameter may also be a callable which receives ``(fixture_name, config)``
+        as parameters, and must return a ``str`` with one of the values mentioned above.
+
+        See :ref:`dynamic scope` in the docs for more information.
+
+    :param params:
+        An optional list of parameters which will cause multiple invocations
+        of the fixture function and all of the tests using it. The current
+        parameter is available in ``request.param``.
+
+    :param autouse:
+        If True, the fixture func is activated for all tests that can see it.
+        If False (the default), an explicit reference is needed to activate
+        the fixture.
+
+    :param ids:
+        List of string ids each corresponding to the params so that they are
+        part of the test id. If no ids are provided they will be generated
+        automatically from the params.
+
+    :param name:
+        The name of the fixture. This defaults to the name of the decorated
+        function. If a fixture is used in the same module in which it is
+        defined, the function name of the fixture will be shadowed by the
+        function arg that requests the fixture; one way to resolve this is to
+        name the decorated function ``fixture_<fixturename>`` and then use
+        ``@pytest.fixture(name='<fixturename>')``.
+    """
+    fixture_marker = FixtureFunctionMarker(
+        scope=scope, params=params, autouse=autouse, ids=ids, name=name,
+    )
+
+    # Direct decoration.
+    if fixture_function:
+        return fixture_marker(fixture_function)
+
+    return fixture_marker
+
+
+def yield_fixture(
+    fixture_function=None,
+    *args,
+    scope="function",
+    params=None,
+    autouse=False,
+    ids=None,
+    name=None,
+):
+    """(Return a) decorator to mark a yield-fixture factory function.
+
+    .. deprecated:: 3.0
+        Use :py:func:`pytest.fixture` directly instead.
+    """
+    warnings.warn(YIELD_FIXTURE, stacklevel=2)
+    return fixture(
+        fixture_function,
+        *args,
+        scope=scope,
+        params=params,
+        autouse=autouse,
+        ids=ids,
+        name=name,
+    )
+
+
+@fixture(scope="session")
+def pytestconfig(request: FixtureRequest) -> Config:
+    """Session-scoped fixture that returns the :class:`_pytest.config.Config` object.
+
+    Example::
+
+        def test_foo(pytestconfig):
+            if pytestconfig.getoption("verbose") > 0:
+                ...
+
+    """
+    return request.config
+
+
+def pytest_addoption(parser: Parser) -> None:
+    parser.addini(
+        "usefixtures",
+        type="args",
+        default=[],
+        help="list of default fixtures to be used with this project",
+    )
+
+
+class FixtureManager:
+    """pytest fixture definitions and information is stored and managed
+    from this class.
+
+    During collection fm.parsefactories() is called multiple times to parse
+    fixture function definitions into FixtureDef objects and internal
+    data structures.
+
+    During collection of test functions, metafunc-mechanics instantiate
+    a FuncFixtureInfo object which is cached per node/func-name.
+    This FuncFixtureInfo object is later retrieved by Function nodes
+    which themselves offer a fixturenames attribute.
+
+    The FuncFixtureInfo object holds information about fixtures and FixtureDefs
+    relevant for a particular function. An initial list of fixtures is
+    assembled like this:
+
+    - ini-defined usefixtures
+    - autouse-marked fixtures along the collection chain up from the function
+    - usefixtures markers at module/class/function level
+    - test function funcargs
+
+    Subsequently the funcfixtureinfo.fixturenames attribute is computed
+    as the closure of the fixtures needed to setup the initial fixtures,
+    i.e. fixtures needed by fixture functions themselves are appended
+    to the fixturenames list.
+
+    Upon the test-setup phases all fixturenames are instantiated, retrieved
+    by a lookup of their FuncFixtureInfo.
+    """
+
+    FixtureLookupError = FixtureLookupError
+    FixtureLookupErrorRepr = FixtureLookupErrorRepr
+
+    def __init__(self, session: "Session") -> None:
+        self.session = session
+        self.config: Config = session.config
+        self._arg2fixturedefs: Dict[str, List[FixtureDef[Any]]] = {}
+        self._holderobjseen: Set[object] = set()
+        # A mapping from a nodeid to a list of autouse fixtures it defines.
+        self._nodeid_autousenames: Dict[str, List[str]] = {
+            "": self.config.getini("usefixtures"),
+        }
+        session.config.pluginmanager.register(self, "funcmanage")
+
+    def _get_direct_parametrize_args(self, node: nodes.Node) -> List[str]:
+        """Return all direct parametrization arguments of a node, so we don't
+        mistake them for fixtures.
+
+        Check https://github.com/pytest-dev/pytest/issues/5036.
+
+        These things are done later as well when dealing with parametrization
+        so this could be improved.
+        """
+        parametrize_argnames: List[str] = []
+        for marker in node.iter_markers(name="parametrize"):
+            if not marker.kwargs.get("indirect", False):
+                p_argnames, _ = ParameterSet._parse_parametrize_args(
+                    *marker.args, **marker.kwargs
+                )
+                parametrize_argnames.extend(p_argnames)
+
+        return parametrize_argnames
+
+    def getfixtureinfo(
+        self, node: nodes.Node, func, cls, funcargs: bool = True
+    ) -> FuncFixtureInfo:
+        if funcargs and not getattr(node, "nofuncargs", False):
+            argnames = getfuncargnames(func, name=node.name, cls=cls)
+        else:
+            argnames = ()
+
+        usefixtures = tuple(
+            arg for mark in node.iter_markers(name="usefixtures") for arg in mark.args
+        )
+        initialnames = usefixtures + argnames
+        fm = node.session._fixturemanager
+        initialnames, names_closure, arg2fixturedefs = fm.getfixtureclosure(
+            initialnames, node, ignore_args=self._get_direct_parametrize_args(node)
+        )
+        return FuncFixtureInfo(argnames, initialnames, names_closure, arg2fixturedefs)
+
+    def pytest_plugin_registered(self, plugin: _PluggyPlugin) -> None:
+        nodeid = None
+        try:
+            p = absolutepath(plugin.__file__)  # type: ignore[attr-defined]
+        except AttributeError:
+            pass
+        else:
+            # Construct the base nodeid which is later used to check
+            # what fixtures are visible for particular tests (as denoted
+            # by their test id).
+            if p.name.startswith("conftest.py"):
+                try:
+                    nodeid = str(p.parent.relative_to(self.config.rootpath))
+                except ValueError:
+                    nodeid = ""
+                if nodeid == ".":
+                    nodeid = ""
+                if os.sep != nodes.SEP:
+                    nodeid = nodeid.replace(os.sep, nodes.SEP)
+
+        self.parsefactories(plugin, nodeid)
+
+    def _getautousenames(self, nodeid: str) -> Iterator[str]:
+        """Return the names of autouse fixtures applicable to nodeid."""
+        for parentnodeid in nodes.iterparentnodeids(nodeid):
+            basenames = self._nodeid_autousenames.get(parentnodeid)
+            if basenames:
+                yield from basenames
+
+    def getfixtureclosure(
+        self,
+        fixturenames: Tuple[str, ...],
+        parentnode: nodes.Node,
+        ignore_args: Sequence[str] = (),
+    ) -> Tuple[Tuple[str, ...], List[str], Dict[str, Sequence[FixtureDef[Any]]]]:
+        # Collect the closure of all fixtures, starting with the given
+        # fixturenames as the initial set.  As we have to visit all
+        # factory definitions anyway, we also return an arg2fixturedefs
+        # mapping so that the caller can reuse it and does not have
+        # to re-discover fixturedefs again for each fixturename
+        # (discovering matching fixtures for a given name/node is expensive).
+
+        parentid = parentnode.nodeid
+        fixturenames_closure = list(self._getautousenames(parentid))
+
+        def merge(otherlist: Iterable[str]) -> None:
+            for arg in otherlist:
+                if arg not in fixturenames_closure:
+                    fixturenames_closure.append(arg)
+
+        merge(fixturenames)
+
+        # At this point, fixturenames_closure contains what we call "initialnames",
+        # which is a set of fixturenames the function immediately requests. We
+        # need to return it as well, so save this.
+        initialnames = tuple(fixturenames_closure)
+
+        arg2fixturedefs: Dict[str, Sequence[FixtureDef[Any]]] = {}
+        lastlen = -1
+        while lastlen != len(fixturenames_closure):
+            lastlen = len(fixturenames_closure)
+            for argname in fixturenames_closure:
+                if argname in ignore_args:
+                    continue
+                if argname in arg2fixturedefs:
+                    continue
+                fixturedefs = self.getfixturedefs(argname, parentid)
+                if fixturedefs:
+                    arg2fixturedefs[argname] = fixturedefs
+                    merge(fixturedefs[-1].argnames)
+
+        def sort_by_scope(arg_name: str) -> int:
+            try:
+                fixturedefs = arg2fixturedefs[arg_name]
+            except KeyError:
+                return scopes.index("function")
+            else:
+                return fixturedefs[-1].scopenum
+
+        fixturenames_closure.sort(key=sort_by_scope)
+        return initialnames, fixturenames_closure, arg2fixturedefs
+
+    def pytest_generate_tests(self, metafunc: "Metafunc") -> None:
+        """Generate new tests based on parametrized fixtures used by the given metafunc"""
+
+        def get_parametrize_mark_argnames(mark: Mark) -> Sequence[str]:
+            args, _ = ParameterSet._parse_parametrize_args(*mark.args, **mark.kwargs)
+            return args
+
+        for argname in metafunc.fixturenames:
+            # Get the FixtureDefs for the argname.
+            fixture_defs = metafunc._arg2fixturedefs.get(argname)
+            if not fixture_defs:
+                # Will raise FixtureLookupError at setup time if not parametrized somewhere
+                # else (e.g @pytest.mark.parametrize)
+                continue
+
+            # If the test itself parametrizes using this argname, give it
+            # precedence.
+            if any(
+                argname in get_parametrize_mark_argnames(mark)
+                for mark in metafunc.definition.iter_markers("parametrize")
+            ):
+                continue
+
+            # In the common case we only look at the fixture def with the
+            # closest scope (last in the list). But if the fixture overrides
+            # another fixture, while requesting the super fixture, keep going
+            # in case the super fixture is parametrized (#1953).
+            for fixturedef in reversed(fixture_defs):
+                # Fixture is parametrized, apply it and stop.
+                if fixturedef.params is not None:
+                    metafunc.parametrize(
+                        argname,
+                        fixturedef.params,
+                        indirect=True,
+                        scope=fixturedef.scope,
+                        ids=fixturedef.ids,
+                    )
+                    break
+
+                # Not requesting the overridden super fixture, stop.
+                if argname not in fixturedef.argnames:
+                    break
+
+                # Try next super fixture, if any.
+
+    def pytest_collection_modifyitems(self, items: List[nodes.Item]) -> None:
+        # Separate parametrized setups.
+        items[:] = reorder_items(items)
+
+    def parsefactories(
+        self, node_or_obj, nodeid=NOTSET, unittest: bool = False
+    ) -> None:
+        if nodeid is not NOTSET:
+            holderobj = node_or_obj
+        else:
+            holderobj = node_or_obj.obj
+            nodeid = node_or_obj.nodeid
+        if holderobj in self._holderobjseen:
+            return
+
+        self._holderobjseen.add(holderobj)
+        autousenames = []
+        for name in dir(holderobj):
+            # The attribute can be an arbitrary descriptor, so the attribute
+            # access below can raise. safe_getatt() ignores such exceptions.
+            obj = safe_getattr(holderobj, name, None)
+            marker = getfixturemarker(obj)
+            if not isinstance(marker, FixtureFunctionMarker):
+                # Magic globals  with __getattr__ might have got us a wrong
+                # fixture attribute.
+                continue
+
+            if marker.name:
+                name = marker.name
+
+            # During fixture definition we wrap the original fixture function
+            # to issue a warning if called directly, so here we unwrap it in
+            # order to not emit the warning when pytest itself calls the
+            # fixture function.
+            obj = get_real_method(obj, holderobj)
+
+            fixture_def = FixtureDef(
+                fixturemanager=self,
+                baseid=nodeid,
+                argname=name,
+                func=obj,
+                scope=marker.scope,
+                params=marker.params,
+                unittest=unittest,
+                ids=marker.ids,
+            )
+
+            faclist = self._arg2fixturedefs.setdefault(name, [])
+            if fixture_def.has_location:
+                faclist.append(fixture_def)
+            else:
+                # fixturedefs with no location are at the front
+                # so this inserts the current fixturedef after the
+                # existing fixturedefs from external plugins but
+                # before the fixturedefs provided in conftests.
+                i = len([f for f in faclist if not f.has_location])
+                faclist.insert(i, fixture_def)
+            if marker.autouse:
+                autousenames.append(name)
+
+        if autousenames:
+            self._nodeid_autousenames.setdefault(nodeid or "", []).extend(autousenames)
+
+    def getfixturedefs(
+        self, argname: str, nodeid: str
+    ) -> Optional[Sequence[FixtureDef[Any]]]:
+        """Get a list of fixtures which are applicable to the given node id.
+
+        :param str argname: Name of the fixture to search for.
+        :param str nodeid: Full node id of the requesting test.
+        :rtype: Sequence[FixtureDef]
+        """
+        try:
+            fixturedefs = self._arg2fixturedefs[argname]
+        except KeyError:
+            return None
+        return tuple(self._matchfactories(fixturedefs, nodeid))
+
+    def _matchfactories(
+        self, fixturedefs: Iterable[FixtureDef[Any]], nodeid: str
+    ) -> Iterator[FixtureDef[Any]]:
+        parentnodeids = set(nodes.iterparentnodeids(nodeid))
+        for fixturedef in fixturedefs:
+            if fixturedef.baseid in parentnodeids:
+                yield fixturedef
diff --git a/myenv/lib/python3.9/site-packages/_pytest/freeze_support.py b/myenv/lib/python3.9/site-packages/_pytest/freeze_support.py
new file mode 100644
index 0000000..8b93ed5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/freeze_support.py
@@ -0,0 +1,45 @@
+"""Provides a function to report all internal modules for using freezing
+tools."""
+import types
+from typing import Iterator
+from typing import List
+from typing import Union
+
+
+def freeze_includes() -> List[str]:
+    """Return a list of module names used by pytest that should be
+    included by cx_freeze."""
+    import py
+    import _pytest
+
+    result = list(_iter_all_modules(py))
+    result += list(_iter_all_modules(_pytest))
+    return result
+
+
+def _iter_all_modules(
+    package: Union[str, types.ModuleType], prefix: str = "",
+) -> Iterator[str]:
+    """Iterate over the names of all modules that can be found in the given
+    package, recursively.
+
+        >>> import _pytest
+        >>> list(_iter_all_modules(_pytest))
+        ['_pytest._argcomplete', '_pytest._code.code', ...]
+    """
+    import os
+    import pkgutil
+
+    if isinstance(package, str):
+        path = package
+    else:
+        # Type ignored because typeshed doesn't define ModuleType.__path__
+        # (only defined on packages).
+        package_path = package.__path__  # type: ignore[attr-defined]
+        path, prefix = package_path[0], package.__name__ + "."
+    for _, name, is_package in pkgutil.iter_modules([path]):
+        if is_package:
+            for m in _iter_all_modules(os.path.join(path, name), prefix=name + "."):
+                yield prefix + m
+        else:
+            yield prefix + name
diff --git a/myenv/lib/python3.9/site-packages/_pytest/helpconfig.py b/myenv/lib/python3.9/site-packages/_pytest/helpconfig.py
new file mode 100644
index 0000000..4384d07
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/helpconfig.py
@@ -0,0 +1,261 @@
+"""Version info, help messages, tracing configuration."""
+import os
+import sys
+from argparse import Action
+from typing import List
+from typing import Optional
+from typing import Union
+
+import py
+
+import pytest
+from _pytest.config import Config
+from _pytest.config import ExitCode
+from _pytest.config import PrintHelp
+from _pytest.config.argparsing import Parser
+
+
+class HelpAction(Action):
+    """An argparse Action that will raise an exception in order to skip the
+    rest of the argument parsing when --help is passed.
+
+    This prevents argparse from quitting due to missing required arguments
+    when any are defined, for example by ``pytest_addoption``.
+    This is similar to the way that the builtin argparse --help option is
+    implemented by raising SystemExit.
+    """
+
+    def __init__(self, option_strings, dest=None, default=False, help=None):
+        super().__init__(
+            option_strings=option_strings,
+            dest=dest,
+            const=True,
+            default=default,
+            nargs=0,
+            help=help,
+        )
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, self.const)
+
+        # We should only skip the rest of the parsing after preparse is done.
+        if getattr(parser._parser, "after_preparse", False):
+            raise PrintHelp
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("debugconfig")
+    group.addoption(
+        "--version",
+        "-V",
+        action="count",
+        default=0,
+        dest="version",
+        help="display pytest version and information about plugins."
+        "When given twice, also display information about plugins.",
+    )
+    group._addoption(
+        "-h",
+        "--help",
+        action=HelpAction,
+        dest="help",
+        help="show help message and configuration info",
+    )
+    group._addoption(
+        "-p",
+        action="append",
+        dest="plugins",
+        default=[],
+        metavar="name",
+        help="early-load given plugin module name or entry point (multi-allowed).\n"
+        "To avoid loading of plugins, use the `no:` prefix, e.g. "
+        "`no:doctest`.",
+    )
+    group.addoption(
+        "--traceconfig",
+        "--trace-config",
+        action="store_true",
+        default=False,
+        help="trace considerations of conftest.py files.",
+    )
+    group.addoption(
+        "--debug",
+        action="store_true",
+        dest="debug",
+        default=False,
+        help="store internal tracing debug information in 'pytestdebug.log'.",
+    )
+    group._addoption(
+        "-o",
+        "--override-ini",
+        dest="override_ini",
+        action="append",
+        help='override ini option with "option=value" style, e.g. `-o xfail_strict=True -o cache_dir=cache`.',
+    )
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_cmdline_parse():
+    outcome = yield
+    config: Config = outcome.get_result()
+    if config.option.debug:
+        path = os.path.abspath("pytestdebug.log")
+        debugfile = open(path, "w")
+        debugfile.write(
+            "versions pytest-%s, py-%s, "
+            "python-%s\ncwd=%s\nargs=%s\n\n"
+            % (
+                pytest.__version__,
+                py.__version__,
+                ".".join(map(str, sys.version_info)),
+                os.getcwd(),
+                config.invocation_params.args,
+            )
+        )
+        config.trace.root.setwriter(debugfile.write)
+        undo_tracing = config.pluginmanager.enable_tracing()
+        sys.stderr.write("writing pytestdebug information to %s\n" % path)
+
+        def unset_tracing() -> None:
+            debugfile.close()
+            sys.stderr.write("wrote pytestdebug information to %s\n" % debugfile.name)
+            config.trace.root.setwriter(None)
+            undo_tracing()
+
+        config.add_cleanup(unset_tracing)
+
+
+def showversion(config: Config) -> None:
+    if config.option.version > 1:
+        sys.stderr.write(
+            "This is pytest version {}, imported from {}\n".format(
+                pytest.__version__, pytest.__file__
+            )
+        )
+        plugininfo = getpluginversioninfo(config)
+        if plugininfo:
+            for line in plugininfo:
+                sys.stderr.write(line + "\n")
+    else:
+        sys.stderr.write(f"pytest {pytest.__version__}\n")
+
+
+def pytest_cmdline_main(config: Config) -> Optional[Union[int, ExitCode]]:
+    if config.option.version > 0:
+        showversion(config)
+        return 0
+    elif config.option.help:
+        config._do_configure()
+        showhelp(config)
+        config._ensure_unconfigure()
+        return 0
+    return None
+
+
+def showhelp(config: Config) -> None:
+    import textwrap
+
+    reporter = config.pluginmanager.get_plugin("terminalreporter")
+    tw = reporter._tw
+    tw.write(config._parser.optparser.format_help())
+    tw.line()
+    tw.line(
+        "[pytest] ini-options in the first pytest.ini|tox.ini|setup.cfg file found:"
+    )
+    tw.line()
+
+    columns = tw.fullwidth  # costly call
+    indent_len = 24  # based on argparse's max_help_position=24
+    indent = " " * indent_len
+    for name in config._parser._ininames:
+        help, type, default = config._parser._inidict[name]
+        if type is None:
+            type = "string"
+        if help is None:
+            raise TypeError(f"help argument cannot be None for {name}")
+        spec = f"{name} ({type}):"
+        tw.write("  %s" % spec)
+        spec_len = len(spec)
+        if spec_len > (indent_len - 3):
+            # Display help starting at a new line.
+            tw.line()
+            helplines = textwrap.wrap(
+                help,
+                columns,
+                initial_indent=indent,
+                subsequent_indent=indent,
+                break_on_hyphens=False,
+            )
+
+            for line in helplines:
+                tw.line(line)
+        else:
+            # Display help starting after the spec, following lines indented.
+            tw.write(" " * (indent_len - spec_len - 2))
+            wrapped = textwrap.wrap(help, columns - indent_len, break_on_hyphens=False)
+
+            if wrapped:
+                tw.line(wrapped[0])
+                for line in wrapped[1:]:
+                    tw.line(indent + line)
+
+    tw.line()
+    tw.line("environment variables:")
+    vars = [
+        ("PYTEST_ADDOPTS", "extra command line options"),
+        ("PYTEST_PLUGINS", "comma-separated plugins to load during startup"),
+        ("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "set to disable plugin auto-loading"),
+        ("PYTEST_DEBUG", "set to enable debug tracing of pytest's internals"),
+    ]
+    for name, help in vars:
+        tw.line(f"  {name:<24} {help}")
+    tw.line()
+    tw.line()
+
+    tw.line("to see available markers type: pytest --markers")
+    tw.line("to see available fixtures type: pytest --fixtures")
+    tw.line(
+        "(shown according to specified file_or_dir or current dir "
+        "if not specified; fixtures with leading '_' are only shown "
+        "with the '-v' option"
+    )
+
+    for warningreport in reporter.stats.get("warnings", []):
+        tw.line("warning : " + warningreport.message, red=True)
+    return
+
+
+conftest_options = [("pytest_plugins", "list of plugin names to load")]
+
+
+def getpluginversioninfo(config: Config) -> List[str]:
+    lines = []
+    plugininfo = config.pluginmanager.list_plugin_distinfo()
+    if plugininfo:
+        lines.append("setuptools registered plugins:")
+        for plugin, dist in plugininfo:
+            loc = getattr(plugin, "__file__", repr(plugin))
+            content = f"{dist.project_name}-{dist.version} at {loc}"
+            lines.append("  " + content)
+    return lines
+
+
+def pytest_report_header(config: Config) -> List[str]:
+    lines = []
+    if config.option.debug or config.option.traceconfig:
+        lines.append(f"using: pytest-{pytest.__version__} pylib-{py.__version__}")
+
+        verinfo = getpluginversioninfo(config)
+        if verinfo:
+            lines.extend(verinfo)
+
+    if config.option.traceconfig:
+        lines.append("active plugins:")
+        items = config.pluginmanager.list_name_plugin()
+        for name, plugin in items:
+            if hasattr(plugin, "__file__"):
+                r = plugin.__file__
+            else:
+                r = repr(plugin)
+            lines.append(f"    {name:<20}: {r}")
+    return lines
diff --git a/myenv/lib/python3.9/site-packages/_pytest/hookspec.py b/myenv/lib/python3.9/site-packages/_pytest/hookspec.py
new file mode 100644
index 0000000..e499b74
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/hookspec.py
@@ -0,0 +1,891 @@
+"""Hook specifications for pytest plugins which are invoked by pytest itself
+and by builtin plugins."""
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Mapping
+from typing import Optional
+from typing import Sequence
+from typing import Tuple
+from typing import TYPE_CHECKING
+from typing import Union
+
+import py.path
+from pluggy import HookspecMarker
+
+from _pytest.deprecated import WARNING_CAPTURED_HOOK
+
+if TYPE_CHECKING:
+    import pdb
+    import warnings
+    from typing_extensions import Literal
+
+    from _pytest._code.code import ExceptionRepr
+    from _pytest.code import ExceptionInfo
+    from _pytest.config import Config
+    from _pytest.config import ExitCode
+    from _pytest.config import PytestPluginManager
+    from _pytest.config import _PluggyPlugin
+    from _pytest.config.argparsing import Parser
+    from _pytest.fixtures import FixtureDef
+    from _pytest.fixtures import SubRequest
+    from _pytest.main import Session
+    from _pytest.nodes import Collector
+    from _pytest.nodes import Item
+    from _pytest.outcomes import Exit
+    from _pytest.python import Function
+    from _pytest.python import Metafunc
+    from _pytest.python import Module
+    from _pytest.python import PyCollector
+    from _pytest.reports import CollectReport
+    from _pytest.reports import TestReport
+    from _pytest.runner import CallInfo
+    from _pytest.terminal import TerminalReporter
+
+
+hookspec = HookspecMarker("pytest")
+
+# -------------------------------------------------------------------------
+# Initialization hooks called for every plugin
+# -------------------------------------------------------------------------
+
+
+@hookspec(historic=True)
+def pytest_addhooks(pluginmanager: "PytestPluginManager") -> None:
+    """Called at plugin registration time to allow adding new hooks via a call to
+    ``pluginmanager.add_hookspecs(module_or_class, prefix)``.
+
+    :param _pytest.config.PytestPluginManager pluginmanager: pytest plugin manager.
+
+    .. note::
+        This hook is incompatible with ``hookwrapper=True``.
+    """
+
+
+@hookspec(historic=True)
+def pytest_plugin_registered(
+    plugin: "_PluggyPlugin", manager: "PytestPluginManager"
+) -> None:
+    """A new pytest plugin got registered.
+
+    :param plugin: The plugin module or instance.
+    :param _pytest.config.PytestPluginManager manager: pytest plugin manager.
+
+    .. note::
+        This hook is incompatible with ``hookwrapper=True``.
+    """
+
+
+@hookspec(historic=True)
+def pytest_addoption(parser: "Parser", pluginmanager: "PytestPluginManager") -> None:
+    """Register argparse-style options and ini-style config values,
+    called once at the beginning of a test run.
+
+    .. note::
+
+        This function should be implemented only in plugins or ``conftest.py``
+        files situated at the tests root directory due to how pytest
+        :ref:`discovers plugins during startup <pluginorder>`.
+
+    :param _pytest.config.argparsing.Parser parser:
+        To add command line options, call
+        :py:func:`parser.addoption(...) <_pytest.config.argparsing.Parser.addoption>`.
+        To add ini-file values call :py:func:`parser.addini(...)
+        <_pytest.config.argparsing.Parser.addini>`.
+
+    :param _pytest.config.PytestPluginManager pluginmanager:
+        pytest plugin manager, which can be used to install :py:func:`hookspec`'s
+        or :py:func:`hookimpl`'s and allow one plugin to call another plugin's hooks
+        to change how command line options are added.
+
+    Options can later be accessed through the
+    :py:class:`config <_pytest.config.Config>` object, respectively:
+
+    - :py:func:`config.getoption(name) <_pytest.config.Config.getoption>` to
+      retrieve the value of a command line option.
+
+    - :py:func:`config.getini(name) <_pytest.config.Config.getini>` to retrieve
+      a value read from an ini-style file.
+
+    The config object is passed around on many internal objects via the ``.config``
+    attribute or can be retrieved as the ``pytestconfig`` fixture.
+
+    .. note::
+        This hook is incompatible with ``hookwrapper=True``.
+    """
+
+
+@hookspec(historic=True)
+def pytest_configure(config: "Config") -> None:
+    """Allow plugins and conftest files to perform initial configuration.
+
+    This hook is called for every plugin and initial conftest file
+    after command line options have been parsed.
+
+    After that, the hook is called for other conftest files as they are
+    imported.
+
+    .. note::
+        This hook is incompatible with ``hookwrapper=True``.
+
+    :param _pytest.config.Config config: The pytest config object.
+    """
+
+
+# -------------------------------------------------------------------------
+# Bootstrapping hooks called for plugins registered early enough:
+# internal and 3rd party plugins.
+# -------------------------------------------------------------------------
+
+
+@hookspec(firstresult=True)
+def pytest_cmdline_parse(
+    pluginmanager: "PytestPluginManager", args: List[str]
+) -> Optional["Config"]:
+    """Return an initialized config object, parsing the specified args.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+
+    .. note::
+        This hook will only be called for plugin classes passed to the
+        ``plugins`` arg when using `pytest.main`_ to perform an in-process
+        test run.
+
+    :param _pytest.config.PytestPluginManager pluginmanager: Pytest plugin manager.
+    :param List[str] args: List of arguments passed on the command line.
+    """
+
+
+def pytest_cmdline_preparse(config: "Config", args: List[str]) -> None:
+    """(**Deprecated**) modify command line arguments before option parsing.
+
+    This hook is considered deprecated and will be removed in a future pytest version. Consider
+    using :func:`pytest_load_initial_conftests` instead.
+
+    .. note::
+        This hook will not be called for ``conftest.py`` files, only for setuptools plugins.
+
+    :param _pytest.config.Config config: The pytest config object.
+    :param List[str] args: Arguments passed on the command line.
+    """
+
+
+@hookspec(firstresult=True)
+def pytest_cmdline_main(config: "Config") -> Optional[Union["ExitCode", int]]:
+    """Called for performing the main command line action. The default
+    implementation will invoke the configure hooks and runtest_mainloop.
+
+    .. note::
+        This hook will not be called for ``conftest.py`` files, only for setuptools plugins.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+
+    :param _pytest.config.Config config: The pytest config object.
+    """
+
+
+def pytest_load_initial_conftests(
+    early_config: "Config", parser: "Parser", args: List[str]
+) -> None:
+    """Called to implement the loading of initial conftest files ahead
+    of command line option parsing.
+
+    .. note::
+        This hook will not be called for ``conftest.py`` files, only for setuptools plugins.
+
+    :param _pytest.config.Config early_config: The pytest config object.
+    :param List[str] args: Arguments passed on the command line.
+    :param _pytest.config.argparsing.Parser parser: To add command line options.
+    """
+
+
+# -------------------------------------------------------------------------
+# collection hooks
+# -------------------------------------------------------------------------
+
+
+@hookspec(firstresult=True)
+def pytest_collection(session: "Session") -> Optional[object]:
+    """Perform the collection phase for the given session.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+    The return value is not used, but only stops further processing.
+
+    The default collection phase is this (see individual hooks for full details):
+
+    1. Starting from ``session`` as the initial collector:
+
+      1. ``pytest_collectstart(collector)``
+      2. ``report = pytest_make_collect_report(collector)``
+      3. ``pytest_exception_interact(collector, call, report)`` if an interactive exception occurred
+      4. For each collected node:
+
+        1. If an item, ``pytest_itemcollected(item)``
+        2. If a collector, recurse into it.
+
+      5. ``pytest_collectreport(report)``
+
+    2. ``pytest_collection_modifyitems(session, config, items)``
+
+      1. ``pytest_deselected(items)`` for any deselected items (may be called multiple times)
+
+    3. ``pytest_collection_finish(session)``
+    4. Set ``session.items`` to the list of collected items
+    5. Set ``session.testscollected`` to the number of collected items
+
+    You can implement this hook to only perform some action before collection,
+    for example the terminal plugin uses it to start displaying the collection
+    counter (and returns `None`).
+
+    :param pytest.Session session: The pytest session object.
+    """
+
+
+def pytest_collection_modifyitems(
+    session: "Session", config: "Config", items: List["Item"]
+) -> None:
+    """Called after collection has been performed. May filter or re-order
+    the items in-place.
+
+    :param pytest.Session session: The pytest session object.
+    :param _pytest.config.Config config: The pytest config object.
+    :param List[pytest.Item] items: List of item objects.
+    """
+
+
+def pytest_collection_finish(session: "Session") -> None:
+    """Called after collection has been performed and modified.
+
+    :param pytest.Session session: The pytest session object.
+    """
+
+
+@hookspec(firstresult=True)
+def pytest_ignore_collect(path: py.path.local, config: "Config") -> Optional[bool]:
+    """Return True to prevent considering this path for collection.
+
+    This hook is consulted for all files and directories prior to calling
+    more specific hooks.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+
+    :param py.path.local path: The path to analyze.
+    :param _pytest.config.Config config: The pytest config object.
+    """
+
+
+def pytest_collect_file(
+    path: py.path.local, parent: "Collector"
+) -> "Optional[Collector]":
+    """Create a Collector for the given path, or None if not relevant.
+
+    The new node needs to have the specified ``parent`` as a parent.
+
+    :param py.path.local path: The path to collect.
+    """
+
+
+# logging hooks for collection
+
+
+def pytest_collectstart(collector: "Collector") -> None:
+    """Collector starts collecting."""
+
+
+def pytest_itemcollected(item: "Item") -> None:
+    """We just collected a test item."""
+
+
+def pytest_collectreport(report: "CollectReport") -> None:
+    """Collector finished collecting."""
+
+
+def pytest_deselected(items: Sequence["Item"]) -> None:
+    """Called for deselected test items, e.g. by keyword.
+
+    May be called multiple times.
+    """
+
+
+@hookspec(firstresult=True)
+def pytest_make_collect_report(collector: "Collector") -> "Optional[CollectReport]":
+    """Perform ``collector.collect()`` and return a CollectReport.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+    """
+
+
+# -------------------------------------------------------------------------
+# Python test function related hooks
+# -------------------------------------------------------------------------
+
+
+@hookspec(firstresult=True)
+def pytest_pycollect_makemodule(path: py.path.local, parent) -> Optional["Module"]:
+    """Return a Module collector or None for the given path.
+
+    This hook will be called for each matching test module path.
+    The pytest_collect_file hook needs to be used if you want to
+    create test modules for files that do not match as a test module.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+
+    :param py.path.local path: The path of module to collect.
+    """
+
+
+@hookspec(firstresult=True)
+def pytest_pycollect_makeitem(
+    collector: "PyCollector", name: str, obj: object
+) -> Union[None, "Item", "Collector", List[Union["Item", "Collector"]]]:
+    """Return a custom item/collector for a Python object in a module, or None.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+    """
+
+
+@hookspec(firstresult=True)
+def pytest_pyfunc_call(pyfuncitem: "Function") -> Optional[object]:
+    """Call underlying test function.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+    """
+
+
+def pytest_generate_tests(metafunc: "Metafunc") -> None:
+    """Generate (multiple) parametrized calls to a test function."""
+
+
+@hookspec(firstresult=True)
+def pytest_make_parametrize_id(
+    config: "Config", val: object, argname: str
+) -> Optional[str]:
+    """Return a user-friendly string representation of the given ``val``
+    that will be used by @pytest.mark.parametrize calls, or None if the hook
+    doesn't know about ``val``.
+
+    The parameter name is available as ``argname``, if required.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+
+    :param _pytest.config.Config config: The pytest config object.
+    :param val: The parametrized value.
+    :param str argname: The automatic parameter name produced by pytest.
+    """
+
+
+# -------------------------------------------------------------------------
+# runtest related hooks
+# -------------------------------------------------------------------------
+
+
+@hookspec(firstresult=True)
+def pytest_runtestloop(session: "Session") -> Optional[object]:
+    """Perform the main runtest loop (after collection finished).
+
+    The default hook implementation performs the runtest protocol for all items
+    collected in the session (``session.items``), unless the collection failed
+    or the ``collectonly`` pytest option is set.
+
+    If at any point :py:func:`pytest.exit` is called, the loop is
+    terminated immediately.
+
+    If at any point ``session.shouldfail`` or ``session.shouldstop`` are set, the
+    loop is terminated after the runtest protocol for the current item is finished.
+
+    :param pytest.Session session: The pytest session object.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+    The return value is not used, but only stops further processing.
+    """
+
+
+@hookspec(firstresult=True)
+def pytest_runtest_protocol(
+    item: "Item", nextitem: "Optional[Item]"
+) -> Optional[object]:
+    """Perform the runtest protocol for a single test item.
+
+    The default runtest protocol is this (see individual hooks for full details):
+
+    - ``pytest_runtest_logstart(nodeid, location)``
+
+    - Setup phase:
+        - ``call = pytest_runtest_setup(item)`` (wrapped in ``CallInfo(when="setup")``)
+        - ``report = pytest_runtest_makereport(item, call)``
+        - ``pytest_runtest_logreport(report)``
+        - ``pytest_exception_interact(call, report)`` if an interactive exception occurred
+
+    - Call phase, if the the setup passed and the ``setuponly`` pytest option is not set:
+        - ``call = pytest_runtest_call(item)`` (wrapped in ``CallInfo(when="call")``)
+        - ``report = pytest_runtest_makereport(item, call)``
+        - ``pytest_runtest_logreport(report)``
+        - ``pytest_exception_interact(call, report)`` if an interactive exception occurred
+
+    - Teardown phase:
+        - ``call = pytest_runtest_teardown(item, nextitem)`` (wrapped in ``CallInfo(when="teardown")``)
+        - ``report = pytest_runtest_makereport(item, call)``
+        - ``pytest_runtest_logreport(report)``
+        - ``pytest_exception_interact(call, report)`` if an interactive exception occurred
+
+    - ``pytest_runtest_logfinish(nodeid, location)``
+
+    :param item: Test item for which the runtest protocol is performed.
+    :param nextitem: The scheduled-to-be-next test item (or None if this is the end my friend).
+
+    Stops at first non-None result, see :ref:`firstresult`.
+    The return value is not used, but only stops further processing.
+    """
+
+
+def pytest_runtest_logstart(
+    nodeid: str, location: Tuple[str, Optional[int], str]
+) -> None:
+    """Called at the start of running the runtest protocol for a single item.
+
+    See :func:`pytest_runtest_protocol` for a description of the runtest protocol.
+
+    :param str nodeid: Full node ID of the item.
+    :param location: A tuple of ``(filename, lineno, testname)``.
+    """
+
+
+def pytest_runtest_logfinish(
+    nodeid: str, location: Tuple[str, Optional[int], str]
+) -> None:
+    """Called at the end of running the runtest protocol for a single item.
+
+    See :func:`pytest_runtest_protocol` for a description of the runtest protocol.
+
+    :param str nodeid: Full node ID of the item.
+    :param location: A tuple of ``(filename, lineno, testname)``.
+    """
+
+
+def pytest_runtest_setup(item: "Item") -> None:
+    """Called to perform the setup phase for a test item.
+
+    The default implementation runs ``setup()`` on ``item`` and all of its
+    parents (which haven't been setup yet). This includes obtaining the
+    values of fixtures required by the item (which haven't been obtained
+    yet).
+    """
+
+
+def pytest_runtest_call(item: "Item") -> None:
+    """Called to run the test for test item (the call phase).
+
+    The default implementation calls ``item.runtest()``.
+    """
+
+
+def pytest_runtest_teardown(item: "Item", nextitem: Optional["Item"]) -> None:
+    """Called to perform the teardown phase for a test item.
+
+    The default implementation runs the finalizers and calls ``teardown()``
+    on ``item`` and all of its parents (which need to be torn down). This
+    includes running the teardown phase of fixtures required by the item (if
+    they go out of scope).
+
+    :param nextitem:
+        The scheduled-to-be-next test item (None if no further test item is
+        scheduled). This argument can be used to perform exact teardowns,
+        i.e. calling just enough finalizers so that nextitem only needs to
+        call setup-functions.
+    """
+
+
+@hookspec(firstresult=True)
+def pytest_runtest_makereport(
+    item: "Item", call: "CallInfo[None]"
+) -> Optional["TestReport"]:
+    """Called to create a :py:class:`_pytest.reports.TestReport` for each of
+    the setup, call and teardown runtest phases of a test item.
+
+    See :func:`pytest_runtest_protocol` for a description of the runtest protocol.
+
+    :param CallInfo[None] call: The ``CallInfo`` for the phase.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+    """
+
+
+def pytest_runtest_logreport(report: "TestReport") -> None:
+    """Process the :py:class:`_pytest.reports.TestReport` produced for each
+    of the setup, call and teardown runtest phases of an item.
+
+    See :func:`pytest_runtest_protocol` for a description of the runtest protocol.
+    """
+
+
+@hookspec(firstresult=True)
+def pytest_report_to_serializable(
+    config: "Config", report: Union["CollectReport", "TestReport"],
+) -> Optional[Dict[str, Any]]:
+    """Serialize the given report object into a data structure suitable for
+    sending over the wire, e.g. converted to JSON."""
+
+
+@hookspec(firstresult=True)
+def pytest_report_from_serializable(
+    config: "Config", data: Dict[str, Any],
+) -> Optional[Union["CollectReport", "TestReport"]]:
+    """Restore a report object previously serialized with pytest_report_to_serializable()."""
+
+
+# -------------------------------------------------------------------------
+# Fixture related hooks
+# -------------------------------------------------------------------------
+
+
+@hookspec(firstresult=True)
+def pytest_fixture_setup(
+    fixturedef: "FixtureDef[Any]", request: "SubRequest"
+) -> Optional[object]:
+    """Perform fixture setup execution.
+
+    :returns: The return value of the call to the fixture function.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+
+    .. note::
+        If the fixture function returns None, other implementations of
+        this hook function will continue to be called, according to the
+        behavior of the :ref:`firstresult` option.
+    """
+
+
+def pytest_fixture_post_finalizer(
+    fixturedef: "FixtureDef[Any]", request: "SubRequest"
+) -> None:
+    """Called after fixture teardown, but before the cache is cleared, so
+    the fixture result ``fixturedef.cached_result`` is still available (not
+    ``None``)."""
+
+
+# -------------------------------------------------------------------------
+# test session related hooks
+# -------------------------------------------------------------------------
+
+
+def pytest_sessionstart(session: "Session") -> None:
+    """Called after the ``Session`` object has been created and before performing collection
+    and entering the run test loop.
+
+    :param pytest.Session session: The pytest session object.
+    """
+
+
+def pytest_sessionfinish(
+    session: "Session", exitstatus: Union[int, "ExitCode"],
+) -> None:
+    """Called after whole test run finished, right before returning the exit status to the system.
+
+    :param pytest.Session session: The pytest session object.
+    :param int exitstatus: The status which pytest will return to the system.
+    """
+
+
+def pytest_unconfigure(config: "Config") -> None:
+    """Called before test process is exited.
+
+    :param _pytest.config.Config config: The pytest config object.
+    """
+
+
+# -------------------------------------------------------------------------
+# hooks for customizing the assert methods
+# -------------------------------------------------------------------------
+
+
+def pytest_assertrepr_compare(
+    config: "Config", op: str, left: object, right: object
+) -> Optional[List[str]]:
+    """Return explanation for comparisons in failing assert expressions.
+
+    Return None for no custom explanation, otherwise return a list
+    of strings. The strings will be joined by newlines but any newlines
+    *in* a string will be escaped. Note that all but the first line will
+    be indented slightly, the intention is for the first line to be a summary.
+
+    :param _pytest.config.Config config: The pytest config object.
+    """
+
+
+def pytest_assertion_pass(item: "Item", lineno: int, orig: str, expl: str) -> None:
+    """**(Experimental)** Called whenever an assertion passes.
+
+    .. versionadded:: 5.0
+
+    Use this hook to do some processing after a passing assertion.
+    The original assertion information is available in the `orig` string
+    and the pytest introspected assertion information is available in the
+    `expl` string.
+
+    This hook must be explicitly enabled by the ``enable_assertion_pass_hook``
+    ini-file option:
+
+    .. code-block:: ini
+
+        [pytest]
+        enable_assertion_pass_hook=true
+
+    You need to **clean the .pyc** files in your project directory and interpreter libraries
+    when enabling this option, as assertions will require to be re-written.
+
+    :param pytest.Item item: pytest item object of current test.
+    :param int lineno: Line number of the assert statement.
+    :param str orig: String with the original assertion.
+    :param str expl: String with the assert explanation.
+
+    .. note::
+
+        This hook is **experimental**, so its parameters or even the hook itself might
+        be changed/removed without warning in any future pytest release.
+
+        If you find this hook useful, please share your feedback in an issue.
+    """
+
+
+# -------------------------------------------------------------------------
+# Hooks for influencing reporting (invoked from _pytest_terminal).
+# -------------------------------------------------------------------------
+
+
+def pytest_report_header(
+    config: "Config", startdir: py.path.local
+) -> Union[str, List[str]]:
+    """Return a string or list of strings to be displayed as header info for terminal reporting.
+
+    :param _pytest.config.Config config: The pytest config object.
+    :param py.path.local startdir: The starting dir.
+
+    .. note::
+
+        Lines returned by a plugin are displayed before those of plugins which
+        ran before it.
+        If you want to have your line(s) displayed first, use
+        :ref:`trylast=True <plugin-hookorder>`.
+
+    .. note::
+
+        This function should be implemented only in plugins or ``conftest.py``
+        files situated at the tests root directory due to how pytest
+        :ref:`discovers plugins during startup <pluginorder>`.
+    """
+
+
+def pytest_report_collectionfinish(
+    config: "Config", startdir: py.path.local, items: Sequence["Item"],
+) -> Union[str, List[str]]:
+    """Return a string or list of strings to be displayed after collection
+    has finished successfully.
+
+    These strings will be displayed after the standard "collected X items" message.
+
+    .. versionadded:: 3.2
+
+    :param _pytest.config.Config config: The pytest config object.
+    :param py.path.local startdir: The starting dir.
+    :param items: List of pytest items that are going to be executed; this list should not be modified.
+
+    .. note::
+
+        Lines returned by a plugin are displayed before those of plugins which
+        ran before it.
+        If you want to have your line(s) displayed first, use
+        :ref:`trylast=True <plugin-hookorder>`.
+    """
+
+
+@hookspec(firstresult=True)
+def pytest_report_teststatus(
+    report: Union["CollectReport", "TestReport"], config: "Config"
+) -> Tuple[
+    str, str, Union[str, Mapping[str, bool]],
+]:
+    """Return result-category, shortletter and verbose word for status
+    reporting.
+
+    The result-category is a category in which to count the result, for
+    example "passed", "skipped", "error" or the empty string.
+
+    The shortletter is shown as testing progresses, for example ".", "s",
+    "E" or the empty string.
+
+    The verbose word is shown as testing progresses in verbose mode, for
+    example "PASSED", "SKIPPED", "ERROR" or the empty string.
+
+    pytest may style these implicitly according to the report outcome.
+    To provide explicit styling, return a tuple for the verbose word,
+    for example ``"rerun", "R", ("RERUN", {"yellow": True})``.
+
+    :param report: The report object whose status is to be returned.
+    :param _pytest.config.Config config: The pytest config object.
+
+    Stops at first non-None result, see :ref:`firstresult`.
+    """
+
+
+def pytest_terminal_summary(
+    terminalreporter: "TerminalReporter", exitstatus: "ExitCode", config: "Config",
+) -> None:
+    """Add a section to terminal summary reporting.
+
+    :param _pytest.terminal.TerminalReporter terminalreporter: The internal terminal reporter object.
+    :param int exitstatus: The exit status that will be reported back to the OS.
+    :param _pytest.config.Config config: The pytest config object.
+
+    .. versionadded:: 4.2
+        The ``config`` parameter.
+    """
+
+
+@hookspec(historic=True, warn_on_impl=WARNING_CAPTURED_HOOK)
+def pytest_warning_captured(
+    warning_message: "warnings.WarningMessage",
+    when: "Literal['config', 'collect', 'runtest']",
+    item: Optional["Item"],
+    location: Optional[Tuple[str, int, str]],
+) -> None:
+    """(**Deprecated**) Process a warning captured by the internal pytest warnings plugin.
+
+    .. deprecated:: 6.0
+
+    This hook is considered deprecated and will be removed in a future pytest version.
+    Use :func:`pytest_warning_recorded` instead.
+
+    :param warnings.WarningMessage warning_message:
+        The captured warning. This is the same object produced by :py:func:`warnings.catch_warnings`, and contains
+        the same attributes as the parameters of :py:func:`warnings.showwarning`.
+
+    :param str when:
+        Indicates when the warning was captured. Possible values:
+
+        * ``"config"``: during pytest configuration/initialization stage.
+        * ``"collect"``: during test collection.
+        * ``"runtest"``: during test execution.
+
+    :param pytest.Item|None item:
+        The item being executed if ``when`` is ``"runtest"``, otherwise ``None``.
+
+    :param tuple location:
+        When available, holds information about the execution context of the captured
+        warning (filename, linenumber, function). ``function`` evaluates to <module>
+        when the execution context is at the module level.
+    """
+
+
+@hookspec(historic=True)
+def pytest_warning_recorded(
+    warning_message: "warnings.WarningMessage",
+    when: "Literal['config', 'collect', 'runtest']",
+    nodeid: str,
+    location: Optional[Tuple[str, int, str]],
+) -> None:
+    """Process a warning captured by the internal pytest warnings plugin.
+
+    :param warnings.WarningMessage warning_message:
+        The captured warning. This is the same object produced by :py:func:`warnings.catch_warnings`, and contains
+        the same attributes as the parameters of :py:func:`warnings.showwarning`.
+
+    :param str when:
+        Indicates when the warning was captured. Possible values:
+
+        * ``"config"``: during pytest configuration/initialization stage.
+        * ``"collect"``: during test collection.
+        * ``"runtest"``: during test execution.
+
+    :param str nodeid:
+        Full id of the item.
+
+    :param tuple|None location:
+        When available, holds information about the execution context of the captured
+        warning (filename, linenumber, function). ``function`` evaluates to <module>
+        when the execution context is at the module level.
+
+    .. versionadded:: 6.0
+    """
+
+
+# -------------------------------------------------------------------------
+# Hooks for influencing skipping
+# -------------------------------------------------------------------------
+
+
+def pytest_markeval_namespace(config: "Config") -> Dict[str, Any]:
+    """Called when constructing the globals dictionary used for
+    evaluating string conditions in xfail/skipif markers.
+
+    This is useful when the condition for a marker requires
+    objects that are expensive or impossible to obtain during
+    collection time, which is required by normal boolean
+    conditions.
+
+    .. versionadded:: 6.2
+
+    :param _pytest.config.Config config: The pytest config object.
+    :returns: A dictionary of additional globals to add.
+    """
+
+
+# -------------------------------------------------------------------------
+# error handling and internal debugging hooks
+# -------------------------------------------------------------------------
+
+
+def pytest_internalerror(
+    excrepr: "ExceptionRepr", excinfo: "ExceptionInfo[BaseException]",
+) -> Optional[bool]:
+    """Called for internal errors.
+
+    Return True to suppress the fallback handling of printing an
+    INTERNALERROR message directly to sys.stderr.
+    """
+
+
+def pytest_keyboard_interrupt(
+    excinfo: "ExceptionInfo[Union[KeyboardInterrupt, Exit]]",
+) -> None:
+    """Called for keyboard interrupt."""
+
+
+def pytest_exception_interact(
+    node: Union["Item", "Collector"],
+    call: "CallInfo[Any]",
+    report: Union["CollectReport", "TestReport"],
+) -> None:
+    """Called when an exception was raised which can potentially be
+    interactively handled.
+
+    May be called during collection (see :py:func:`pytest_make_collect_report`),
+    in which case ``report`` is a :py:class:`_pytest.reports.CollectReport`.
+
+    May be called during runtest of an item (see :py:func:`pytest_runtest_protocol`),
+    in which case ``report`` is a :py:class:`_pytest.reports.TestReport`.
+
+    This hook is not called if the exception that was raised is an internal
+    exception like ``skip.Exception``.
+    """
+
+
+def pytest_enter_pdb(config: "Config", pdb: "pdb.Pdb") -> None:
+    """Called upon pdb.set_trace().
+
+    Can be used by plugins to take special action just before the python
+    debugger enters interactive mode.
+
+    :param _pytest.config.Config config: The pytest config object.
+    :param pdb.Pdb pdb: The Pdb instance.
+    """
+
+
+def pytest_leave_pdb(config: "Config", pdb: "pdb.Pdb") -> None:
+    """Called when leaving pdb (e.g. with continue after pdb.set_trace()).
+
+    Can be used by plugins to take special action just after the python
+    debugger leaves interactive mode.
+
+    :param _pytest.config.Config config: The pytest config object.
+    :param pdb.Pdb pdb: The Pdb instance.
+    """
diff --git a/myenv/lib/python3.9/site-packages/_pytest/junitxml.py b/myenv/lib/python3.9/site-packages/_pytest/junitxml.py
new file mode 100644
index 0000000..c4761cd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/junitxml.py
@@ -0,0 +1,700 @@
+"""Report test results in JUnit-XML format, for use with Jenkins and build
+integration servers.
+
+Based on initial code from Ross Lawley.
+
+Output conforms to
+https://github.com/jenkinsci/xunit-plugin/blob/master/src/main/resources/org/jenkinsci/plugins/xunit/types/model/xsd/junit-10.xsd
+"""
+import functools
+import os
+import platform
+import re
+import xml.etree.ElementTree as ET
+from datetime import datetime
+from typing import Callable
+from typing import Dict
+from typing import List
+from typing import Match
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+import pytest
+from _pytest import nodes
+from _pytest import timing
+from _pytest._code.code import ExceptionRepr
+from _pytest._code.code import ReprFileLocation
+from _pytest.config import Config
+from _pytest.config import filename_arg
+from _pytest.config.argparsing import Parser
+from _pytest.fixtures import FixtureRequest
+from _pytest.reports import TestReport
+from _pytest.store import StoreKey
+from _pytest.terminal import TerminalReporter
+
+
+xml_key = StoreKey["LogXML"]()
+
+
+def bin_xml_escape(arg: object) -> str:
+    r"""Visually escape invalid XML characters.
+
+    For example, transforms
+        'hello\aworld\b'
+    into
+        'hello#x07world#x08'
+    Note that the #xABs are *not* XML escapes - missing the ampersand &#xAB.
+    The idea is to escape visually for the user rather than for XML itself.
+    """
+
+    def repl(matchobj: Match[str]) -> str:
+        i = ord(matchobj.group())
+        if i <= 0xFF:
+            return "#x%02X" % i
+        else:
+            return "#x%04X" % i
+
+    # The spec range of valid chars is:
+    # Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
+    # For an unknown(?) reason, we disallow #x7F (DEL) as well.
+    illegal_xml_re = (
+        "[^\u0009\u000A\u000D\u0020-\u007E\u0080-\uD7FF\uE000-\uFFFD\u10000-\u10FFFF]"
+    )
+    return re.sub(illegal_xml_re, repl, str(arg))
+
+
+def merge_family(left, right) -> None:
+    result = {}
+    for kl, vl in left.items():
+        for kr, vr in right.items():
+            if not isinstance(vl, list):
+                raise TypeError(type(vl))
+            result[kl] = vl + vr
+    left.update(result)
+
+
+families = {}
+families["_base"] = {"testcase": ["classname", "name"]}
+families["_base_legacy"] = {"testcase": ["file", "line", "url"]}
+
+# xUnit 1.x inherits legacy attributes.
+families["xunit1"] = families["_base"].copy()
+merge_family(families["xunit1"], families["_base_legacy"])
+
+# xUnit 2.x uses strict base attributes.
+families["xunit2"] = families["_base"]
+
+
+class _NodeReporter:
+    def __init__(self, nodeid: Union[str, TestReport], xml: "LogXML") -> None:
+        self.id = nodeid
+        self.xml = xml
+        self.add_stats = self.xml.add_stats
+        self.family = self.xml.family
+        self.duration = 0
+        self.properties: List[Tuple[str, str]] = []
+        self.nodes: List[ET.Element] = []
+        self.attrs: Dict[str, str] = {}
+
+    def append(self, node: ET.Element) -> None:
+        self.xml.add_stats(node.tag)
+        self.nodes.append(node)
+
+    def add_property(self, name: str, value: object) -> None:
+        self.properties.append((str(name), bin_xml_escape(value)))
+
+    def add_attribute(self, name: str, value: object) -> None:
+        self.attrs[str(name)] = bin_xml_escape(value)
+
+    def make_properties_node(self) -> Optional[ET.Element]:
+        """Return a Junit node containing custom properties, if any."""
+        if self.properties:
+            properties = ET.Element("properties")
+            for name, value in self.properties:
+                properties.append(ET.Element("property", name=name, value=value))
+            return properties
+        return None
+
+    def record_testreport(self, testreport: TestReport) -> None:
+        names = mangle_test_address(testreport.nodeid)
+        existing_attrs = self.attrs
+        classnames = names[:-1]
+        if self.xml.prefix:
+            classnames.insert(0, self.xml.prefix)
+        attrs: Dict[str, str] = {
+            "classname": ".".join(classnames),
+            "name": bin_xml_escape(names[-1]),
+            "file": testreport.location[0],
+        }
+        if testreport.location[1] is not None:
+            attrs["line"] = str(testreport.location[1])
+        if hasattr(testreport, "url"):
+            attrs["url"] = testreport.url
+        self.attrs = attrs
+        self.attrs.update(existing_attrs)  # Restore any user-defined attributes.
+
+        # Preserve legacy testcase behavior.
+        if self.family == "xunit1":
+            return
+
+        # Filter out attributes not permitted by this test family.
+        # Including custom attributes because they are not valid here.
+        temp_attrs = {}
+        for key in self.attrs.keys():
+            if key in families[self.family]["testcase"]:
+                temp_attrs[key] = self.attrs[key]
+        self.attrs = temp_attrs
+
+    def to_xml(self) -> ET.Element:
+        testcase = ET.Element("testcase", self.attrs, time="%.3f" % self.duration)
+        properties = self.make_properties_node()
+        if properties is not None:
+            testcase.append(properties)
+        testcase.extend(self.nodes)
+        return testcase
+
+    def _add_simple(self, tag: str, message: str, data: Optional[str] = None) -> None:
+        node = ET.Element(tag, message=message)
+        node.text = bin_xml_escape(data)
+        self.append(node)
+
+    def write_captured_output(self, report: TestReport) -> None:
+        if not self.xml.log_passing_tests and report.passed:
+            return
+
+        content_out = report.capstdout
+        content_log = report.caplog
+        content_err = report.capstderr
+        if self.xml.logging == "no":
+            return
+        content_all = ""
+        if self.xml.logging in ["log", "all"]:
+            content_all = self._prepare_content(content_log, " Captured Log ")
+        if self.xml.logging in ["system-out", "out-err", "all"]:
+            content_all += self._prepare_content(content_out, " Captured Out ")
+            self._write_content(report, content_all, "system-out")
+            content_all = ""
+        if self.xml.logging in ["system-err", "out-err", "all"]:
+            content_all += self._prepare_content(content_err, " Captured Err ")
+            self._write_content(report, content_all, "system-err")
+            content_all = ""
+        if content_all:
+            self._write_content(report, content_all, "system-out")
+
+    def _prepare_content(self, content: str, header: str) -> str:
+        return "\n".join([header.center(80, "-"), content, ""])
+
+    def _write_content(self, report: TestReport, content: str, jheader: str) -> None:
+        tag = ET.Element(jheader)
+        tag.text = bin_xml_escape(content)
+        self.append(tag)
+
+    def append_pass(self, report: TestReport) -> None:
+        self.add_stats("passed")
+
+    def append_failure(self, report: TestReport) -> None:
+        # msg = str(report.longrepr.reprtraceback.extraline)
+        if hasattr(report, "wasxfail"):
+            self._add_simple("skipped", "xfail-marked test passes unexpectedly")
+        else:
+            assert report.longrepr is not None
+            reprcrash: Optional[ReprFileLocation] = getattr(
+                report.longrepr, "reprcrash", None
+            )
+            if reprcrash is not None:
+                message = reprcrash.message
+            else:
+                message = str(report.longrepr)
+            message = bin_xml_escape(message)
+            self._add_simple("failure", message, str(report.longrepr))
+
+    def append_collect_error(self, report: TestReport) -> None:
+        # msg = str(report.longrepr.reprtraceback.extraline)
+        assert report.longrepr is not None
+        self._add_simple("error", "collection failure", str(report.longrepr))
+
+    def append_collect_skipped(self, report: TestReport) -> None:
+        self._add_simple("skipped", "collection skipped", str(report.longrepr))
+
+    def append_error(self, report: TestReport) -> None:
+        assert report.longrepr is not None
+        reprcrash: Optional[ReprFileLocation] = getattr(
+            report.longrepr, "reprcrash", None
+        )
+        if reprcrash is not None:
+            reason = reprcrash.message
+        else:
+            reason = str(report.longrepr)
+
+        if report.when == "teardown":
+            msg = f'failed on teardown with "{reason}"'
+        else:
+            msg = f'failed on setup with "{reason}"'
+        self._add_simple("error", msg, str(report.longrepr))
+
+    def append_skipped(self, report: TestReport) -> None:
+        if hasattr(report, "wasxfail"):
+            xfailreason = report.wasxfail
+            if xfailreason.startswith("reason: "):
+                xfailreason = xfailreason[8:]
+            xfailreason = bin_xml_escape(xfailreason)
+            skipped = ET.Element("skipped", type="pytest.xfail", message=xfailreason)
+            self.append(skipped)
+        else:
+            assert isinstance(report.longrepr, tuple)
+            filename, lineno, skipreason = report.longrepr
+            if skipreason.startswith("Skipped: "):
+                skipreason = skipreason[9:]
+            details = f"{filename}:{lineno}: {skipreason}"
+
+            skipped = ET.Element("skipped", type="pytest.skip", message=skipreason)
+            skipped.text = bin_xml_escape(details)
+            self.append(skipped)
+            self.write_captured_output(report)
+
+    def finalize(self) -> None:
+        data = self.to_xml()
+        self.__dict__.clear()
+        # Type ignored becuase mypy doesn't like overriding a method.
+        # Also the return value doesn't match...
+        self.to_xml = lambda: data  # type: ignore[assignment]
+
+
+def _warn_incompatibility_with_xunit2(
+    request: FixtureRequest, fixture_name: str
+) -> None:
+    """Emit a PytestWarning about the given fixture being incompatible with newer xunit revisions."""
+    from _pytest.warning_types import PytestWarning
+
+    xml = request.config._store.get(xml_key, None)
+    if xml is not None and xml.family not in ("xunit1", "legacy"):
+        request.node.warn(
+            PytestWarning(
+                "{fixture_name} is incompatible with junit_family '{family}' (use 'legacy' or 'xunit1')".format(
+                    fixture_name=fixture_name, family=xml.family
+                )
+            )
+        )
+
+
+@pytest.fixture
+def record_property(request: FixtureRequest) -> Callable[[str, object], None]:
+    """Add extra properties to the calling test.
+
+    User properties become part of the test report and are available to the
+    configured reporters, like JUnit XML.
+
+    The fixture is callable with ``name, value``. The value is automatically
+    XML-encoded.
+
+    Example::
+
+        def test_function(record_property):
+            record_property("example_key", 1)
+    """
+    _warn_incompatibility_with_xunit2(request, "record_property")
+
+    def append_property(name: str, value: object) -> None:
+        request.node.user_properties.append((name, value))
+
+    return append_property
+
+
+@pytest.fixture
+def record_xml_attribute(request: FixtureRequest) -> Callable[[str, object], None]:
+    """Add extra xml attributes to the tag for the calling test.
+
+    The fixture is callable with ``name, value``. The value is
+    automatically XML-encoded.
+    """
+    from _pytest.warning_types import PytestExperimentalApiWarning
+
+    request.node.warn(
+        PytestExperimentalApiWarning("record_xml_attribute is an experimental feature")
+    )
+
+    _warn_incompatibility_with_xunit2(request, "record_xml_attribute")
+
+    # Declare noop
+    def add_attr_noop(name: str, value: object) -> None:
+        pass
+
+    attr_func = add_attr_noop
+
+    xml = request.config._store.get(xml_key, None)
+    if xml is not None:
+        node_reporter = xml.node_reporter(request.node.nodeid)
+        attr_func = node_reporter.add_attribute
+
+    return attr_func
+
+
+def _check_record_param_type(param: str, v: str) -> None:
+    """Used by record_testsuite_property to check that the given parameter name is of the proper
+    type."""
+    __tracebackhide__ = True
+    if not isinstance(v, str):
+        msg = "{param} parameter needs to be a string, but {g} given"  # type: ignore[unreachable]
+        raise TypeError(msg.format(param=param, g=type(v).__name__))
+
+
+@pytest.fixture(scope="session")
+def record_testsuite_property(request: FixtureRequest) -> Callable[[str, object], None]:
+    """Record a new ``<property>`` tag as child of the root ``<testsuite>``.
+
+    This is suitable to writing global information regarding the entire test
+    suite, and is compatible with ``xunit2`` JUnit family.
+
+    This is a ``session``-scoped fixture which is called with ``(name, value)``. Example:
+
+    .. code-block:: python
+
+        def test_foo(record_testsuite_property):
+            record_testsuite_property("ARCH", "PPC")
+            record_testsuite_property("STORAGE_TYPE", "CEPH")
+
+    ``name`` must be a string, ``value`` will be converted to a string and properly xml-escaped.
+
+    .. warning::
+
+        Currently this fixture **does not work** with the
+        `pytest-xdist <https://github.com/pytest-dev/pytest-xdist>`__ plugin. See issue
+        `#7767 <https://github.com/pytest-dev/pytest/issues/7767>`__ for details.
+    """
+
+    __tracebackhide__ = True
+
+    def record_func(name: str, value: object) -> None:
+        """No-op function in case --junitxml was not passed in the command-line."""
+        __tracebackhide__ = True
+        _check_record_param_type("name", name)
+
+    xml = request.config._store.get(xml_key, None)
+    if xml is not None:
+        record_func = xml.add_global_property  # noqa
+    return record_func
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("terminal reporting")
+    group.addoption(
+        "--junitxml",
+        "--junit-xml",
+        action="store",
+        dest="xmlpath",
+        metavar="path",
+        type=functools.partial(filename_arg, optname="--junitxml"),
+        default=None,
+        help="create junit-xml style report file at given path.",
+    )
+    group.addoption(
+        "--junitprefix",
+        "--junit-prefix",
+        action="store",
+        metavar="str",
+        default=None,
+        help="prepend prefix to classnames in junit-xml output",
+    )
+    parser.addini(
+        "junit_suite_name", "Test suite name for JUnit report", default="pytest"
+    )
+    parser.addini(
+        "junit_logging",
+        "Write captured log messages to JUnit report: "
+        "one of no|log|system-out|system-err|out-err|all",
+        default="no",
+    )
+    parser.addini(
+        "junit_log_passing_tests",
+        "Capture log information for passing tests to JUnit report: ",
+        type="bool",
+        default=True,
+    )
+    parser.addini(
+        "junit_duration_report",
+        "Duration time to report: one of total|call",
+        default="total",
+    )  # choices=['total', 'call'])
+    parser.addini(
+        "junit_family",
+        "Emit XML for schema: one of legacy|xunit1|xunit2",
+        default="xunit2",
+    )
+
+
+def pytest_configure(config: Config) -> None:
+    xmlpath = config.option.xmlpath
+    # Prevent opening xmllog on worker nodes (xdist).
+    if xmlpath and not hasattr(config, "workerinput"):
+        junit_family = config.getini("junit_family")
+        config._store[xml_key] = LogXML(
+            xmlpath,
+            config.option.junitprefix,
+            config.getini("junit_suite_name"),
+            config.getini("junit_logging"),
+            config.getini("junit_duration_report"),
+            junit_family,
+            config.getini("junit_log_passing_tests"),
+        )
+        config.pluginmanager.register(config._store[xml_key])
+
+
+def pytest_unconfigure(config: Config) -> None:
+    xml = config._store.get(xml_key, None)
+    if xml:
+        del config._store[xml_key]
+        config.pluginmanager.unregister(xml)
+
+
+def mangle_test_address(address: str) -> List[str]:
+    path, possible_open_bracket, params = address.partition("[")
+    names = path.split("::")
+    try:
+        names.remove("()")
+    except ValueError:
+        pass
+    # Convert file path to dotted path.
+    names[0] = names[0].replace(nodes.SEP, ".")
+    names[0] = re.sub(r"\.py$", "", names[0])
+    # Put any params back.
+    names[-1] += possible_open_bracket + params
+    return names
+
+
+class LogXML:
+    def __init__(
+        self,
+        logfile,
+        prefix: Optional[str],
+        suite_name: str = "pytest",
+        logging: str = "no",
+        report_duration: str = "total",
+        family="xunit1",
+        log_passing_tests: bool = True,
+    ) -> None:
+        logfile = os.path.expanduser(os.path.expandvars(logfile))
+        self.logfile = os.path.normpath(os.path.abspath(logfile))
+        self.prefix = prefix
+        self.suite_name = suite_name
+        self.logging = logging
+        self.log_passing_tests = log_passing_tests
+        self.report_duration = report_duration
+        self.family = family
+        self.stats: Dict[str, int] = dict.fromkeys(
+            ["error", "passed", "failure", "skipped"], 0
+        )
+        self.node_reporters: Dict[
+            Tuple[Union[str, TestReport], object], _NodeReporter
+        ] = ({})
+        self.node_reporters_ordered: List[_NodeReporter] = []
+        self.global_properties: List[Tuple[str, str]] = []
+
+        # List of reports that failed on call but teardown is pending.
+        self.open_reports: List[TestReport] = []
+        self.cnt_double_fail_tests = 0
+
+        # Replaces convenience family with real family.
+        if self.family == "legacy":
+            self.family = "xunit1"
+
+    def finalize(self, report: TestReport) -> None:
+        nodeid = getattr(report, "nodeid", report)
+        # Local hack to handle xdist report order.
+        workernode = getattr(report, "node", None)
+        reporter = self.node_reporters.pop((nodeid, workernode))
+        if reporter is not None:
+            reporter.finalize()
+
+    def node_reporter(self, report: Union[TestReport, str]) -> _NodeReporter:
+        nodeid: Union[str, TestReport] = getattr(report, "nodeid", report)
+        # Local hack to handle xdist report order.
+        workernode = getattr(report, "node", None)
+
+        key = nodeid, workernode
+
+        if key in self.node_reporters:
+            # TODO: breaks for --dist=each
+            return self.node_reporters[key]
+
+        reporter = _NodeReporter(nodeid, self)
+
+        self.node_reporters[key] = reporter
+        self.node_reporters_ordered.append(reporter)
+
+        return reporter
+
+    def add_stats(self, key: str) -> None:
+        if key in self.stats:
+            self.stats[key] += 1
+
+    def _opentestcase(self, report: TestReport) -> _NodeReporter:
+        reporter = self.node_reporter(report)
+        reporter.record_testreport(report)
+        return reporter
+
+    def pytest_runtest_logreport(self, report: TestReport) -> None:
+        """Handle a setup/call/teardown report, generating the appropriate
+        XML tags as necessary.
+
+        Note: due to plugins like xdist, this hook may be called in interlaced
+        order with reports from other nodes. For example:
+
+        Usual call order:
+            -> setup node1
+            -> call node1
+            -> teardown node1
+            -> setup node2
+            -> call node2
+            -> teardown node2
+
+        Possible call order in xdist:
+            -> setup node1
+            -> call node1
+            -> setup node2
+            -> call node2
+            -> teardown node2
+            -> teardown node1
+        """
+        close_report = None
+        if report.passed:
+            if report.when == "call":  # ignore setup/teardown
+                reporter = self._opentestcase(report)
+                reporter.append_pass(report)
+        elif report.failed:
+            if report.when == "teardown":
+                # The following vars are needed when xdist plugin is used.
+                report_wid = getattr(report, "worker_id", None)
+                report_ii = getattr(report, "item_index", None)
+                close_report = next(
+                    (
+                        rep
+                        for rep in self.open_reports
+                        if (
+                            rep.nodeid == report.nodeid
+                            and getattr(rep, "item_index", None) == report_ii
+                            and getattr(rep, "worker_id", None) == report_wid
+                        )
+                    ),
+                    None,
+                )
+                if close_report:
+                    # We need to open new testcase in case we have failure in
+                    # call and error in teardown in order to follow junit
+                    # schema.
+                    self.finalize(close_report)
+                    self.cnt_double_fail_tests += 1
+            reporter = self._opentestcase(report)
+            if report.when == "call":
+                reporter.append_failure(report)
+                self.open_reports.append(report)
+                if not self.log_passing_tests:
+                    reporter.write_captured_output(report)
+            else:
+                reporter.append_error(report)
+        elif report.skipped:
+            reporter = self._opentestcase(report)
+            reporter.append_skipped(report)
+        self.update_testcase_duration(report)
+        if report.when == "teardown":
+            reporter = self._opentestcase(report)
+            reporter.write_captured_output(report)
+
+            for propname, propvalue in report.user_properties:
+                reporter.add_property(propname, str(propvalue))
+
+            self.finalize(report)
+            report_wid = getattr(report, "worker_id", None)
+            report_ii = getattr(report, "item_index", None)
+            close_report = next(
+                (
+                    rep
+                    for rep in self.open_reports
+                    if (
+                        rep.nodeid == report.nodeid
+                        and getattr(rep, "item_index", None) == report_ii
+                        and getattr(rep, "worker_id", None) == report_wid
+                    )
+                ),
+                None,
+            )
+            if close_report:
+                self.open_reports.remove(close_report)
+
+    def update_testcase_duration(self, report: TestReport) -> None:
+        """Accumulate total duration for nodeid from given report and update
+        the Junit.testcase with the new total if already created."""
+        if self.report_duration == "total" or report.when == self.report_duration:
+            reporter = self.node_reporter(report)
+            reporter.duration += getattr(report, "duration", 0.0)
+
+    def pytest_collectreport(self, report: TestReport) -> None:
+        if not report.passed:
+            reporter = self._opentestcase(report)
+            if report.failed:
+                reporter.append_collect_error(report)
+            else:
+                reporter.append_collect_skipped(report)
+
+    def pytest_internalerror(self, excrepr: ExceptionRepr) -> None:
+        reporter = self.node_reporter("internal")
+        reporter.attrs.update(classname="pytest", name="internal")
+        reporter._add_simple("error", "internal error", str(excrepr))
+
+    def pytest_sessionstart(self) -> None:
+        self.suite_start_time = timing.time()
+
+    def pytest_sessionfinish(self) -> None:
+        dirname = os.path.dirname(os.path.abspath(self.logfile))
+        if not os.path.isdir(dirname):
+            os.makedirs(dirname)
+        logfile = open(self.logfile, "w", encoding="utf-8")
+        suite_stop_time = timing.time()
+        suite_time_delta = suite_stop_time - self.suite_start_time
+
+        numtests = (
+            self.stats["passed"]
+            + self.stats["failure"]
+            + self.stats["skipped"]
+            + self.stats["error"]
+            - self.cnt_double_fail_tests
+        )
+        logfile.write('<?xml version="1.0" encoding="utf-8"?>')
+
+        suite_node = ET.Element(
+            "testsuite",
+            name=self.suite_name,
+            errors=str(self.stats["error"]),
+            failures=str(self.stats["failure"]),
+            skipped=str(self.stats["skipped"]),
+            tests=str(numtests),
+            time="%.3f" % suite_time_delta,
+            timestamp=datetime.fromtimestamp(self.suite_start_time).isoformat(),
+            hostname=platform.node(),
+        )
+        global_properties = self._get_global_properties_node()
+        if global_properties is not None:
+            suite_node.append(global_properties)
+        for node_reporter in self.node_reporters_ordered:
+            suite_node.append(node_reporter.to_xml())
+        testsuites = ET.Element("testsuites")
+        testsuites.append(suite_node)
+        logfile.write(ET.tostring(testsuites, encoding="unicode"))
+        logfile.close()
+
+    def pytest_terminal_summary(self, terminalreporter: TerminalReporter) -> None:
+        terminalreporter.write_sep("-", f"generated xml file: {self.logfile}")
+
+    def add_global_property(self, name: str, value: object) -> None:
+        __tracebackhide__ = True
+        _check_record_param_type("name", name)
+        self.global_properties.append((name, bin_xml_escape(value)))
+
+    def _get_global_properties_node(self) -> Optional[ET.Element]:
+        """Return a Junit node containing custom properties, if any."""
+        if self.global_properties:
+            properties = ET.Element("properties")
+            for name, value in self.global_properties:
+                properties.append(ET.Element("property", name=name, value=value))
+            return properties
+        return None
diff --git a/myenv/lib/python3.9/site-packages/_pytest/logging.py b/myenv/lib/python3.9/site-packages/_pytest/logging.py
new file mode 100644
index 0000000..2e48473
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/logging.py
@@ -0,0 +1,821 @@
+"""Access and control log capturing."""
+import logging
+import os
+import re
+import sys
+from contextlib import contextmanager
+from io import StringIO
+from pathlib import Path
+from typing import AbstractSet
+from typing import Dict
+from typing import Generator
+from typing import List
+from typing import Mapping
+from typing import Optional
+from typing import Tuple
+from typing import TypeVar
+from typing import Union
+
+from _pytest import nodes
+from _pytest._io import TerminalWriter
+from _pytest.capture import CaptureManager
+from _pytest.compat import final
+from _pytest.compat import nullcontext
+from _pytest.config import _strtobool
+from _pytest.config import Config
+from _pytest.config import create_terminal_writer
+from _pytest.config import hookimpl
+from _pytest.config import UsageError
+from _pytest.config.argparsing import Parser
+from _pytest.deprecated import check_ispytest
+from _pytest.fixtures import fixture
+from _pytest.fixtures import FixtureRequest
+from _pytest.main import Session
+from _pytest.store import StoreKey
+from _pytest.terminal import TerminalReporter
+
+
+DEFAULT_LOG_FORMAT = "%(levelname)-8s %(name)s:%(filename)s:%(lineno)d %(message)s"
+DEFAULT_LOG_DATE_FORMAT = "%H:%M:%S"
+_ANSI_ESCAPE_SEQ = re.compile(r"\x1b\[[\d;]+m")
+caplog_handler_key = StoreKey["LogCaptureHandler"]()
+caplog_records_key = StoreKey[Dict[str, List[logging.LogRecord]]]()
+
+
+def _remove_ansi_escape_sequences(text: str) -> str:
+    return _ANSI_ESCAPE_SEQ.sub("", text)
+
+
+class ColoredLevelFormatter(logging.Formatter):
+    """A logging formatter which colorizes the %(levelname)..s part of the
+    log format passed to __init__."""
+
+    LOGLEVEL_COLOROPTS: Mapping[int, AbstractSet[str]] = {
+        logging.CRITICAL: {"red"},
+        logging.ERROR: {"red", "bold"},
+        logging.WARNING: {"yellow"},
+        logging.WARN: {"yellow"},
+        logging.INFO: {"green"},
+        logging.DEBUG: {"purple"},
+        logging.NOTSET: set(),
+    }
+    LEVELNAME_FMT_REGEX = re.compile(r"%\(levelname\)([+-.]?\d*s)")
+
+    def __init__(self, terminalwriter: TerminalWriter, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._original_fmt = self._style._fmt
+        self._level_to_fmt_mapping: Dict[int, str] = {}
+
+        assert self._fmt is not None
+        levelname_fmt_match = self.LEVELNAME_FMT_REGEX.search(self._fmt)
+        if not levelname_fmt_match:
+            return
+        levelname_fmt = levelname_fmt_match.group()
+
+        for level, color_opts in self.LOGLEVEL_COLOROPTS.items():
+            formatted_levelname = levelname_fmt % {
+                "levelname": logging.getLevelName(level)
+            }
+
+            # add ANSI escape sequences around the formatted levelname
+            color_kwargs = {name: True for name in color_opts}
+            colorized_formatted_levelname = terminalwriter.markup(
+                formatted_levelname, **color_kwargs
+            )
+            self._level_to_fmt_mapping[level] = self.LEVELNAME_FMT_REGEX.sub(
+                colorized_formatted_levelname, self._fmt
+            )
+
+    def format(self, record: logging.LogRecord) -> str:
+        fmt = self._level_to_fmt_mapping.get(record.levelno, self._original_fmt)
+        self._style._fmt = fmt
+        return super().format(record)
+
+
+class PercentStyleMultiline(logging.PercentStyle):
+    """A logging style with special support for multiline messages.
+
+    If the message of a record consists of multiple lines, this style
+    formats the message as if each line were logged separately.
+    """
+
+    def __init__(self, fmt: str, auto_indent: Union[int, str, bool, None]) -> None:
+        super().__init__(fmt)
+        self._auto_indent = self._get_auto_indent(auto_indent)
+
+    @staticmethod
+    def _update_message(
+        record_dict: Dict[str, object], message: str
+    ) -> Dict[str, object]:
+        tmp = record_dict.copy()
+        tmp["message"] = message
+        return tmp
+
+    @staticmethod
+    def _get_auto_indent(auto_indent_option: Union[int, str, bool, None]) -> int:
+        """Determine the current auto indentation setting.
+
+        Specify auto indent behavior (on/off/fixed) by passing in
+        extra={"auto_indent": [value]} to the call to logging.log() or
+        using a --log-auto-indent [value] command line or the
+        log_auto_indent [value] config option.
+
+        Default behavior is auto-indent off.
+
+        Using the string "True" or "on" or the boolean True as the value
+        turns auto indent on, using the string "False" or "off" or the
+        boolean False or the int 0 turns it off, and specifying a
+        positive integer fixes the indentation position to the value
+        specified.
+
+        Any other values for the option are invalid, and will silently be
+        converted to the default.
+
+        :param None|bool|int|str auto_indent_option:
+            User specified option for indentation from command line, config
+            or extra kwarg. Accepts int, bool or str. str option accepts the
+            same range of values as boolean config options, as well as
+            positive integers represented in str form.
+
+        :returns:
+            Indentation value, which can be
+            -1 (automatically determine indentation) or
+            0 (auto-indent turned off) or
+            >0 (explicitly set indentation position).
+        """
+
+        if auto_indent_option is None:
+            return 0
+        elif isinstance(auto_indent_option, bool):
+            if auto_indent_option:
+                return -1
+            else:
+                return 0
+        elif isinstance(auto_indent_option, int):
+            return int(auto_indent_option)
+        elif isinstance(auto_indent_option, str):
+            try:
+                return int(auto_indent_option)
+            except ValueError:
+                pass
+            try:
+                if _strtobool(auto_indent_option):
+                    return -1
+            except ValueError:
+                return 0
+
+        return 0
+
+    def format(self, record: logging.LogRecord) -> str:
+        if "\n" in record.message:
+            if hasattr(record, "auto_indent"):
+                # Passed in from the "extra={}" kwarg on the call to logging.log().
+                auto_indent = self._get_auto_indent(record.auto_indent)  # type: ignore[attr-defined]
+            else:
+                auto_indent = self._auto_indent
+
+            if auto_indent:
+                lines = record.message.splitlines()
+                formatted = self._fmt % self._update_message(record.__dict__, lines[0])
+
+                if auto_indent < 0:
+                    indentation = _remove_ansi_escape_sequences(formatted).find(
+                        lines[0]
+                    )
+                else:
+                    # Optimizes logging by allowing a fixed indentation.
+                    indentation = auto_indent
+                lines[0] = formatted
+                return ("\n" + " " * indentation).join(lines)
+        return self._fmt % record.__dict__
+
+
+def get_option_ini(config: Config, *names: str):
+    for name in names:
+        ret = config.getoption(name)  # 'default' arg won't work as expected
+        if ret is None:
+            ret = config.getini(name)
+        if ret:
+            return ret
+
+
+def pytest_addoption(parser: Parser) -> None:
+    """Add options to control log capturing."""
+    group = parser.getgroup("logging")
+
+    def add_option_ini(option, dest, default=None, type=None, **kwargs):
+        parser.addini(
+            dest, default=default, type=type, help="default value for " + option
+        )
+        group.addoption(option, dest=dest, **kwargs)
+
+    add_option_ini(
+        "--log-level",
+        dest="log_level",
+        default=None,
+        metavar="LEVEL",
+        help=(
+            "level of messages to catch/display.\n"
+            "Not set by default, so it depends on the root/parent log handler's"
+            ' effective level, where it is "WARNING" by default.'
+        ),
+    )
+    add_option_ini(
+        "--log-format",
+        dest="log_format",
+        default=DEFAULT_LOG_FORMAT,
+        help="log format as used by the logging module.",
+    )
+    add_option_ini(
+        "--log-date-format",
+        dest="log_date_format",
+        default=DEFAULT_LOG_DATE_FORMAT,
+        help="log date format as used by the logging module.",
+    )
+    parser.addini(
+        "log_cli",
+        default=False,
+        type="bool",
+        help='enable log display during test run (also known as "live logging").',
+    )
+    add_option_ini(
+        "--log-cli-level", dest="log_cli_level", default=None, help="cli logging level."
+    )
+    add_option_ini(
+        "--log-cli-format",
+        dest="log_cli_format",
+        default=None,
+        help="log format as used by the logging module.",
+    )
+    add_option_ini(
+        "--log-cli-date-format",
+        dest="log_cli_date_format",
+        default=None,
+        help="log date format as used by the logging module.",
+    )
+    add_option_ini(
+        "--log-file",
+        dest="log_file",
+        default=None,
+        help="path to a file when logging will be written to.",
+    )
+    add_option_ini(
+        "--log-file-level",
+        dest="log_file_level",
+        default=None,
+        help="log file logging level.",
+    )
+    add_option_ini(
+        "--log-file-format",
+        dest="log_file_format",
+        default=DEFAULT_LOG_FORMAT,
+        help="log format as used by the logging module.",
+    )
+    add_option_ini(
+        "--log-file-date-format",
+        dest="log_file_date_format",
+        default=DEFAULT_LOG_DATE_FORMAT,
+        help="log date format as used by the logging module.",
+    )
+    add_option_ini(
+        "--log-auto-indent",
+        dest="log_auto_indent",
+        default=None,
+        help="Auto-indent multiline messages passed to the logging module. Accepts true|on, false|off or an integer.",
+    )
+
+
+_HandlerType = TypeVar("_HandlerType", bound=logging.Handler)
+
+
+# Not using @contextmanager for performance reasons.
+class catching_logs:
+    """Context manager that prepares the whole logging machinery properly."""
+
+    __slots__ = ("handler", "level", "orig_level")
+
+    def __init__(self, handler: _HandlerType, level: Optional[int] = None) -> None:
+        self.handler = handler
+        self.level = level
+
+    def __enter__(self):
+        root_logger = logging.getLogger()
+        if self.level is not None:
+            self.handler.setLevel(self.level)
+        root_logger.addHandler(self.handler)
+        if self.level is not None:
+            self.orig_level = root_logger.level
+            root_logger.setLevel(min(self.orig_level, self.level))
+        return self.handler
+
+    def __exit__(self, type, value, traceback):
+        root_logger = logging.getLogger()
+        if self.level is not None:
+            root_logger.setLevel(self.orig_level)
+        root_logger.removeHandler(self.handler)
+
+
+class LogCaptureHandler(logging.StreamHandler):
+    """A logging handler that stores log records and the log text."""
+
+    stream: StringIO
+
+    def __init__(self) -> None:
+        """Create a new log handler."""
+        super().__init__(StringIO())
+        self.records: List[logging.LogRecord] = []
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """Keep the log records in a list in addition to the log text."""
+        self.records.append(record)
+        super().emit(record)
+
+    def reset(self) -> None:
+        self.records = []
+        self.stream = StringIO()
+
+    def handleError(self, record: logging.LogRecord) -> None:
+        if logging.raiseExceptions:
+            # Fail the test if the log message is bad (emit failed).
+            # The default behavior of logging is to print "Logging error"
+            # to stderr with the call stack and some extra details.
+            # pytest wants to make such mistakes visible during testing.
+            raise
+
+
+@final
+class LogCaptureFixture:
+    """Provides access and control of log capturing."""
+
+    def __init__(self, item: nodes.Node, *, _ispytest: bool = False) -> None:
+        check_ispytest(_ispytest)
+        self._item = item
+        self._initial_handler_level: Optional[int] = None
+        # Dict of log name -> log level.
+        self._initial_logger_levels: Dict[Optional[str], int] = {}
+
+    def _finalize(self) -> None:
+        """Finalize the fixture.
+
+        This restores the log levels changed by :meth:`set_level`.
+        """
+        # Restore log levels.
+        if self._initial_handler_level is not None:
+            self.handler.setLevel(self._initial_handler_level)
+        for logger_name, level in self._initial_logger_levels.items():
+            logger = logging.getLogger(logger_name)
+            logger.setLevel(level)
+
+    @property
+    def handler(self) -> LogCaptureHandler:
+        """Get the logging handler used by the fixture.
+
+        :rtype: LogCaptureHandler
+        """
+        return self._item._store[caplog_handler_key]
+
+    def get_records(self, when: str) -> List[logging.LogRecord]:
+        """Get the logging records for one of the possible test phases.
+
+        :param str when:
+            Which test phase to obtain the records from. Valid values are: "setup", "call" and "teardown".
+
+        :returns: The list of captured records at the given stage.
+        :rtype: List[logging.LogRecord]
+
+        .. versionadded:: 3.4
+        """
+        return self._item._store[caplog_records_key].get(when, [])
+
+    @property
+    def text(self) -> str:
+        """The formatted log text."""
+        return _remove_ansi_escape_sequences(self.handler.stream.getvalue())
+
+    @property
+    def records(self) -> List[logging.LogRecord]:
+        """The list of log records."""
+        return self.handler.records
+
+    @property
+    def record_tuples(self) -> List[Tuple[str, int, str]]:
+        """A list of a stripped down version of log records intended
+        for use in assertion comparison.
+
+        The format of the tuple is:
+
+            (logger_name, log_level, message)
+        """
+        return [(r.name, r.levelno, r.getMessage()) for r in self.records]
+
+    @property
+    def messages(self) -> List[str]:
+        """A list of format-interpolated log messages.
+
+        Unlike 'records', which contains the format string and parameters for
+        interpolation, log messages in this list are all interpolated.
+
+        Unlike 'text', which contains the output from the handler, log
+        messages in this list are unadorned with levels, timestamps, etc,
+        making exact comparisons more reliable.
+
+        Note that traceback or stack info (from :func:`logging.exception` or
+        the `exc_info` or `stack_info` arguments to the logging functions) is
+        not included, as this is added by the formatter in the handler.
+
+        .. versionadded:: 3.7
+        """
+        return [r.getMessage() for r in self.records]
+
+    def clear(self) -> None:
+        """Reset the list of log records and the captured log text."""
+        self.handler.reset()
+
+    def set_level(self, level: Union[int, str], logger: Optional[str] = None) -> None:
+        """Set the level of a logger for the duration of a test.
+
+        .. versionchanged:: 3.4
+            The levels of the loggers changed by this function will be
+            restored to their initial values at the end of the test.
+
+        :param int level: The level.
+        :param str logger: The logger to update. If not given, the root logger.
+        """
+        logger_obj = logging.getLogger(logger)
+        # Save the original log-level to restore it during teardown.
+        self._initial_logger_levels.setdefault(logger, logger_obj.level)
+        logger_obj.setLevel(level)
+        if self._initial_handler_level is None:
+            self._initial_handler_level = self.handler.level
+        self.handler.setLevel(level)
+
+    @contextmanager
+    def at_level(
+        self, level: int, logger: Optional[str] = None
+    ) -> Generator[None, None, None]:
+        """Context manager that sets the level for capturing of logs. After
+        the end of the 'with' statement the level is restored to its original
+        value.
+
+        :param int level: The level.
+        :param str logger: The logger to update. If not given, the root logger.
+        """
+        logger_obj = logging.getLogger(logger)
+        orig_level = logger_obj.level
+        logger_obj.setLevel(level)
+        handler_orig_level = self.handler.level
+        self.handler.setLevel(level)
+        try:
+            yield
+        finally:
+            logger_obj.setLevel(orig_level)
+            self.handler.setLevel(handler_orig_level)
+
+
+@fixture
+def caplog(request: FixtureRequest) -> Generator[LogCaptureFixture, None, None]:
+    """Access and control log capturing.
+
+    Captured logs are available through the following properties/methods::
+
+    * caplog.messages        -> list of format-interpolated log messages
+    * caplog.text            -> string containing formatted log output
+    * caplog.records         -> list of logging.LogRecord instances
+    * caplog.record_tuples   -> list of (logger_name, level, message) tuples
+    * caplog.clear()         -> clear captured records and formatted log output string
+    """
+    result = LogCaptureFixture(request.node, _ispytest=True)
+    yield result
+    result._finalize()
+
+
+def get_log_level_for_setting(config: Config, *setting_names: str) -> Optional[int]:
+    for setting_name in setting_names:
+        log_level = config.getoption(setting_name)
+        if log_level is None:
+            log_level = config.getini(setting_name)
+        if log_level:
+            break
+    else:
+        return None
+
+    if isinstance(log_level, str):
+        log_level = log_level.upper()
+    try:
+        return int(getattr(logging, log_level, log_level))
+    except ValueError as e:
+        # Python logging does not recognise this as a logging level
+        raise UsageError(
+            "'{}' is not recognized as a logging level name for "
+            "'{}'. Please consider passing the "
+            "logging level num instead.".format(log_level, setting_name)
+        ) from e
+
+
+# run after terminalreporter/capturemanager are configured
+@hookimpl(trylast=True)
+def pytest_configure(config: Config) -> None:
+    config.pluginmanager.register(LoggingPlugin(config), "logging-plugin")
+
+
+class LoggingPlugin:
+    """Attaches to the logging module and captures log messages for each test."""
+
+    def __init__(self, config: Config) -> None:
+        """Create a new plugin to capture log messages.
+
+        The formatter can be safely shared across all handlers so
+        create a single one for the entire test session here.
+        """
+        self._config = config
+
+        # Report logging.
+        self.formatter = self._create_formatter(
+            get_option_ini(config, "log_format"),
+            get_option_ini(config, "log_date_format"),
+            get_option_ini(config, "log_auto_indent"),
+        )
+        self.log_level = get_log_level_for_setting(config, "log_level")
+        self.caplog_handler = LogCaptureHandler()
+        self.caplog_handler.setFormatter(self.formatter)
+        self.report_handler = LogCaptureHandler()
+        self.report_handler.setFormatter(self.formatter)
+
+        # File logging.
+        self.log_file_level = get_log_level_for_setting(config, "log_file_level")
+        log_file = get_option_ini(config, "log_file") or os.devnull
+        if log_file != os.devnull:
+            directory = os.path.dirname(os.path.abspath(log_file))
+            if not os.path.isdir(directory):
+                os.makedirs(directory)
+
+        self.log_file_handler = _FileHandler(log_file, mode="w", encoding="UTF-8")
+        log_file_format = get_option_ini(config, "log_file_format", "log_format")
+        log_file_date_format = get_option_ini(
+            config, "log_file_date_format", "log_date_format"
+        )
+
+        log_file_formatter = logging.Formatter(
+            log_file_format, datefmt=log_file_date_format
+        )
+        self.log_file_handler.setFormatter(log_file_formatter)
+
+        # CLI/live logging.
+        self.log_cli_level = get_log_level_for_setting(
+            config, "log_cli_level", "log_level"
+        )
+        if self._log_cli_enabled():
+            terminal_reporter = config.pluginmanager.get_plugin("terminalreporter")
+            capture_manager = config.pluginmanager.get_plugin("capturemanager")
+            # if capturemanager plugin is disabled, live logging still works.
+            self.log_cli_handler: Union[
+                _LiveLoggingStreamHandler, _LiveLoggingNullHandler
+            ] = _LiveLoggingStreamHandler(terminal_reporter, capture_manager)
+        else:
+            self.log_cli_handler = _LiveLoggingNullHandler()
+        log_cli_formatter = self._create_formatter(
+            get_option_ini(config, "log_cli_format", "log_format"),
+            get_option_ini(config, "log_cli_date_format", "log_date_format"),
+            get_option_ini(config, "log_auto_indent"),
+        )
+        self.log_cli_handler.setFormatter(log_cli_formatter)
+
+    def _create_formatter(self, log_format, log_date_format, auto_indent):
+        # Color option doesn't exist if terminal plugin is disabled.
+        color = getattr(self._config.option, "color", "no")
+        if color != "no" and ColoredLevelFormatter.LEVELNAME_FMT_REGEX.search(
+            log_format
+        ):
+            formatter: logging.Formatter = ColoredLevelFormatter(
+                create_terminal_writer(self._config), log_format, log_date_format
+            )
+        else:
+            formatter = logging.Formatter(log_format, log_date_format)
+
+        formatter._style = PercentStyleMultiline(
+            formatter._style._fmt, auto_indent=auto_indent
+        )
+
+        return formatter
+
+    def set_log_path(self, fname: str) -> None:
+        """Set the filename parameter for Logging.FileHandler().
+
+        Creates parent directory if it does not exist.
+
+        .. warning::
+            This is an experimental API.
+        """
+        fpath = Path(fname)
+
+        if not fpath.is_absolute():
+            fpath = self._config.rootpath / fpath
+
+        if not fpath.parent.exists():
+            fpath.parent.mkdir(exist_ok=True, parents=True)
+
+        stream = fpath.open(mode="w", encoding="UTF-8")
+        if sys.version_info >= (3, 7):
+            old_stream = self.log_file_handler.setStream(stream)
+        else:
+            old_stream = self.log_file_handler.stream
+            self.log_file_handler.acquire()
+            try:
+                self.log_file_handler.flush()
+                self.log_file_handler.stream = stream
+            finally:
+                self.log_file_handler.release()
+        if old_stream:
+            old_stream.close()
+
+    def _log_cli_enabled(self):
+        """Return whether live logging is enabled."""
+        enabled = self._config.getoption(
+            "--log-cli-level"
+        ) is not None or self._config.getini("log_cli")
+        if not enabled:
+            return False
+
+        terminal_reporter = self._config.pluginmanager.get_plugin("terminalreporter")
+        if terminal_reporter is None:
+            # terminal reporter is disabled e.g. by pytest-xdist.
+            return False
+
+        return True
+
+    @hookimpl(hookwrapper=True, tryfirst=True)
+    def pytest_sessionstart(self) -> Generator[None, None, None]:
+        self.log_cli_handler.set_when("sessionstart")
+
+        with catching_logs(self.log_cli_handler, level=self.log_cli_level):
+            with catching_logs(self.log_file_handler, level=self.log_file_level):
+                yield
+
+    @hookimpl(hookwrapper=True, tryfirst=True)
+    def pytest_collection(self) -> Generator[None, None, None]:
+        self.log_cli_handler.set_when("collection")
+
+        with catching_logs(self.log_cli_handler, level=self.log_cli_level):
+            with catching_logs(self.log_file_handler, level=self.log_file_level):
+                yield
+
+    @hookimpl(hookwrapper=True)
+    def pytest_runtestloop(self, session: Session) -> Generator[None, None, None]:
+        if session.config.option.collectonly:
+            yield
+            return
+
+        if self._log_cli_enabled() and self._config.getoption("verbose") < 1:
+            # The verbose flag is needed to avoid messy test progress output.
+            self._config.option.verbose = 1
+
+        with catching_logs(self.log_cli_handler, level=self.log_cli_level):
+            with catching_logs(self.log_file_handler, level=self.log_file_level):
+                yield  # Run all the tests.
+
+    @hookimpl
+    def pytest_runtest_logstart(self) -> None:
+        self.log_cli_handler.reset()
+        self.log_cli_handler.set_when("start")
+
+    @hookimpl
+    def pytest_runtest_logreport(self) -> None:
+        self.log_cli_handler.set_when("logreport")
+
+    def _runtest_for(self, item: nodes.Item, when: str) -> Generator[None, None, None]:
+        """Implement the internals of the pytest_runtest_xxx() hooks."""
+        with catching_logs(
+            self.caplog_handler, level=self.log_level,
+        ) as caplog_handler, catching_logs(
+            self.report_handler, level=self.log_level,
+        ) as report_handler:
+            caplog_handler.reset()
+            report_handler.reset()
+            item._store[caplog_records_key][when] = caplog_handler.records
+            item._store[caplog_handler_key] = caplog_handler
+
+            yield
+
+            log = report_handler.stream.getvalue().strip()
+            item.add_report_section(when, "log", log)
+
+    @hookimpl(hookwrapper=True)
+    def pytest_runtest_setup(self, item: nodes.Item) -> Generator[None, None, None]:
+        self.log_cli_handler.set_when("setup")
+
+        empty: Dict[str, List[logging.LogRecord]] = {}
+        item._store[caplog_records_key] = empty
+        yield from self._runtest_for(item, "setup")
+
+    @hookimpl(hookwrapper=True)
+    def pytest_runtest_call(self, item: nodes.Item) -> Generator[None, None, None]:
+        self.log_cli_handler.set_when("call")
+
+        yield from self._runtest_for(item, "call")
+
+    @hookimpl(hookwrapper=True)
+    def pytest_runtest_teardown(self, item: nodes.Item) -> Generator[None, None, None]:
+        self.log_cli_handler.set_when("teardown")
+
+        yield from self._runtest_for(item, "teardown")
+        del item._store[caplog_records_key]
+        del item._store[caplog_handler_key]
+
+    @hookimpl
+    def pytest_runtest_logfinish(self) -> None:
+        self.log_cli_handler.set_when("finish")
+
+    @hookimpl(hookwrapper=True, tryfirst=True)
+    def pytest_sessionfinish(self) -> Generator[None, None, None]:
+        self.log_cli_handler.set_when("sessionfinish")
+
+        with catching_logs(self.log_cli_handler, level=self.log_cli_level):
+            with catching_logs(self.log_file_handler, level=self.log_file_level):
+                yield
+
+    @hookimpl
+    def pytest_unconfigure(self) -> None:
+        # Close the FileHandler explicitly.
+        # (logging.shutdown might have lost the weakref?!)
+        self.log_file_handler.close()
+
+
+class _FileHandler(logging.FileHandler):
+    """A logging FileHandler with pytest tweaks."""
+
+    def handleError(self, record: logging.LogRecord) -> None:
+        # Handled by LogCaptureHandler.
+        pass
+
+
+class _LiveLoggingStreamHandler(logging.StreamHandler):
+    """A logging StreamHandler used by the live logging feature: it will
+    write a newline before the first log message in each test.
+
+    During live logging we must also explicitly disable stdout/stderr
+    capturing otherwise it will get captured and won't appear in the
+    terminal.
+    """
+
+    # Officially stream needs to be a IO[str], but TerminalReporter
+    # isn't. So force it.
+    stream: TerminalReporter = None  # type: ignore
+
+    def __init__(
+        self,
+        terminal_reporter: TerminalReporter,
+        capture_manager: Optional[CaptureManager],
+    ) -> None:
+        logging.StreamHandler.__init__(self, stream=terminal_reporter)  # type: ignore[arg-type]
+        self.capture_manager = capture_manager
+        self.reset()
+        self.set_when(None)
+        self._test_outcome_written = False
+
+    def reset(self) -> None:
+        """Reset the handler; should be called before the start of each test."""
+        self._first_record_emitted = False
+
+    def set_when(self, when: Optional[str]) -> None:
+        """Prepare for the given test phase (setup/call/teardown)."""
+        self._when = when
+        self._section_name_shown = False
+        if when == "start":
+            self._test_outcome_written = False
+
+    def emit(self, record: logging.LogRecord) -> None:
+        ctx_manager = (
+            self.capture_manager.global_and_fixture_disabled()
+            if self.capture_manager
+            else nullcontext()
+        )
+        with ctx_manager:
+            if not self._first_record_emitted:
+                self.stream.write("\n")
+                self._first_record_emitted = True
+            elif self._when in ("teardown", "finish"):
+                if not self._test_outcome_written:
+                    self._test_outcome_written = True
+                    self.stream.write("\n")
+            if not self._section_name_shown and self._when:
+                self.stream.section("live log " + self._when, sep="-", bold=True)
+                self._section_name_shown = True
+            super().emit(record)
+
+    def handleError(self, record: logging.LogRecord) -> None:
+        # Handled by LogCaptureHandler.
+        pass
+
+
+class _LiveLoggingNullHandler(logging.NullHandler):
+    """A logging handler used when live logging is disabled."""
+
+    def reset(self) -> None:
+        pass
+
+    def set_when(self, when: str) -> None:
+        pass
+
+    def handleError(self, record: logging.LogRecord) -> None:
+        # Handled by LogCaptureHandler.
+        pass
diff --git a/myenv/lib/python3.9/site-packages/_pytest/main.py b/myenv/lib/python3.9/site-packages/_pytest/main.py
new file mode 100644
index 0000000..41a33d4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/main.py
@@ -0,0 +1,876 @@
+"""Core implementation of the testing process: init, session, runtest loop."""
+import argparse
+import fnmatch
+import functools
+import importlib
+import os
+import sys
+from pathlib import Path
+from typing import Callable
+from typing import Dict
+from typing import FrozenSet
+from typing import Iterator
+from typing import List
+from typing import Optional
+from typing import overload
+from typing import Sequence
+from typing import Set
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import Union
+
+import attr
+import py
+
+import _pytest._code
+from _pytest import nodes
+from _pytest.compat import final
+from _pytest.config import Config
+from _pytest.config import directory_arg
+from _pytest.config import ExitCode
+from _pytest.config import hookimpl
+from _pytest.config import PytestPluginManager
+from _pytest.config import UsageError
+from _pytest.config.argparsing import Parser
+from _pytest.fixtures import FixtureManager
+from _pytest.outcomes import exit
+from _pytest.pathlib import absolutepath
+from _pytest.pathlib import bestrelpath
+from _pytest.pathlib import visit
+from _pytest.reports import CollectReport
+from _pytest.reports import TestReport
+from _pytest.runner import collect_one_node
+from _pytest.runner import SetupState
+
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
+
+def pytest_addoption(parser: Parser) -> None:
+    parser.addini(
+        "norecursedirs",
+        "directory patterns to avoid for recursion",
+        type="args",
+        default=[
+            "*.egg",
+            ".*",
+            "_darcs",
+            "build",
+            "CVS",
+            "dist",
+            "node_modules",
+            "venv",
+            "{arch}",
+        ],
+    )
+    parser.addini(
+        "testpaths",
+        "directories to search for tests when no files or directories are given in the "
+        "command line.",
+        type="args",
+        default=[],
+    )
+    group = parser.getgroup("general", "running and selection options")
+    group._addoption(
+        "-x",
+        "--exitfirst",
+        action="store_const",
+        dest="maxfail",
+        const=1,
+        help="exit instantly on first error or failed test.",
+    )
+    group = parser.getgroup("pytest-warnings")
+    group.addoption(
+        "-W",
+        "--pythonwarnings",
+        action="append",
+        help="set which warnings to report, see -W option of python itself.",
+    )
+    parser.addini(
+        "filterwarnings",
+        type="linelist",
+        help="Each line specifies a pattern for "
+        "warnings.filterwarnings. "
+        "Processed after -W/--pythonwarnings.",
+    )
+    group._addoption(
+        "--maxfail",
+        metavar="num",
+        action="store",
+        type=int,
+        dest="maxfail",
+        default=0,
+        help="exit after first num failures or errors.",
+    )
+    group._addoption(
+        "--strict-config",
+        action="store_true",
+        help="any warnings encountered while parsing the `pytest` section of the configuration file raise errors.",
+    )
+    group._addoption(
+        "--strict-markers",
+        action="store_true",
+        help="markers not registered in the `markers` section of the configuration file raise errors.",
+    )
+    group._addoption(
+        "--strict", action="store_true", help="(deprecated) alias to --strict-markers.",
+    )
+    group._addoption(
+        "-c",
+        metavar="file",
+        type=str,
+        dest="inifilename",
+        help="load configuration from `file` instead of trying to locate one of the implicit "
+        "configuration files.",
+    )
+    group._addoption(
+        "--continue-on-collection-errors",
+        action="store_true",
+        default=False,
+        dest="continue_on_collection_errors",
+        help="Force test execution even if collection errors occur.",
+    )
+    group._addoption(
+        "--rootdir",
+        action="store",
+        dest="rootdir",
+        help="Define root directory for tests. Can be relative path: 'root_dir', './root_dir', "
+        "'root_dir/another_dir/'; absolute path: '/home/user/root_dir'; path with variables: "
+        "'$HOME/root_dir'.",
+    )
+
+    group = parser.getgroup("collect", "collection")
+    group.addoption(
+        "--collectonly",
+        "--collect-only",
+        "--co",
+        action="store_true",
+        help="only collect tests, don't execute them.",
+    )
+    group.addoption(
+        "--pyargs",
+        action="store_true",
+        help="try to interpret all arguments as python packages.",
+    )
+    group.addoption(
+        "--ignore",
+        action="append",
+        metavar="path",
+        help="ignore path during collection (multi-allowed).",
+    )
+    group.addoption(
+        "--ignore-glob",
+        action="append",
+        metavar="path",
+        help="ignore path pattern during collection (multi-allowed).",
+    )
+    group.addoption(
+        "--deselect",
+        action="append",
+        metavar="nodeid_prefix",
+        help="deselect item (via node id prefix) during collection (multi-allowed).",
+    )
+    group.addoption(
+        "--confcutdir",
+        dest="confcutdir",
+        default=None,
+        metavar="dir",
+        type=functools.partial(directory_arg, optname="--confcutdir"),
+        help="only load conftest.py's relative to specified dir.",
+    )
+    group.addoption(
+        "--noconftest",
+        action="store_true",
+        dest="noconftest",
+        default=False,
+        help="Don't load any conftest.py files.",
+    )
+    group.addoption(
+        "--keepduplicates",
+        "--keep-duplicates",
+        action="store_true",
+        dest="keepduplicates",
+        default=False,
+        help="Keep duplicate tests.",
+    )
+    group.addoption(
+        "--collect-in-virtualenv",
+        action="store_true",
+        dest="collect_in_virtualenv",
+        default=False,
+        help="Don't ignore tests in a local virtualenv directory",
+    )
+    group.addoption(
+        "--import-mode",
+        default="prepend",
+        choices=["prepend", "append", "importlib"],
+        dest="importmode",
+        help="prepend/append to sys.path when importing test modules and conftest files, "
+        "default is to prepend.",
+    )
+
+    group = parser.getgroup("debugconfig", "test session debugging and configuration")
+    group.addoption(
+        "--basetemp",
+        dest="basetemp",
+        default=None,
+        type=validate_basetemp,
+        metavar="dir",
+        help=(
+            "base temporary directory for this test run."
+            "(warning: this directory is removed if it exists)"
+        ),
+    )
+
+
+def validate_basetemp(path: str) -> str:
+    # GH 7119
+    msg = "basetemp must not be empty, the current working directory or any parent directory of it"
+
+    # empty path
+    if not path:
+        raise argparse.ArgumentTypeError(msg)
+
+    def is_ancestor(base: Path, query: Path) -> bool:
+        """Return whether query is an ancestor of base."""
+        if base == query:
+            return True
+        for parent in base.parents:
+            if parent == query:
+                return True
+        return False
+
+    # check if path is an ancestor of cwd
+    if is_ancestor(Path.cwd(), Path(path).absolute()):
+        raise argparse.ArgumentTypeError(msg)
+
+    # check symlinks for ancestors
+    if is_ancestor(Path.cwd().resolve(), Path(path).resolve()):
+        raise argparse.ArgumentTypeError(msg)
+
+    return path
+
+
+def wrap_session(
+    config: Config, doit: Callable[[Config, "Session"], Optional[Union[int, ExitCode]]]
+) -> Union[int, ExitCode]:
+    """Skeleton command line program."""
+    session = Session.from_config(config)
+    session.exitstatus = ExitCode.OK
+    initstate = 0
+    try:
+        try:
+            config._do_configure()
+            initstate = 1
+            config.hook.pytest_sessionstart(session=session)
+            initstate = 2
+            session.exitstatus = doit(config, session) or 0
+        except UsageError:
+            session.exitstatus = ExitCode.USAGE_ERROR
+            raise
+        except Failed:
+            session.exitstatus = ExitCode.TESTS_FAILED
+        except (KeyboardInterrupt, exit.Exception):
+            excinfo = _pytest._code.ExceptionInfo.from_current()
+            exitstatus: Union[int, ExitCode] = ExitCode.INTERRUPTED
+            if isinstance(excinfo.value, exit.Exception):
+                if excinfo.value.returncode is not None:
+                    exitstatus = excinfo.value.returncode
+                if initstate < 2:
+                    sys.stderr.write(f"{excinfo.typename}: {excinfo.value.msg}\n")
+            config.hook.pytest_keyboard_interrupt(excinfo=excinfo)
+            session.exitstatus = exitstatus
+        except BaseException:
+            session.exitstatus = ExitCode.INTERNAL_ERROR
+            excinfo = _pytest._code.ExceptionInfo.from_current()
+            try:
+                config.notify_exception(excinfo, config.option)
+            except exit.Exception as exc:
+                if exc.returncode is not None:
+                    session.exitstatus = exc.returncode
+                sys.stderr.write("{}: {}\n".format(type(exc).__name__, exc))
+            else:
+                if isinstance(excinfo.value, SystemExit):
+                    sys.stderr.write("mainloop: caught unexpected SystemExit!\n")
+
+    finally:
+        # Explicitly break reference cycle.
+        excinfo = None  # type: ignore
+        session.startdir.chdir()
+        if initstate >= 2:
+            try:
+                config.hook.pytest_sessionfinish(
+                    session=session, exitstatus=session.exitstatus
+                )
+            except exit.Exception as exc:
+                if exc.returncode is not None:
+                    session.exitstatus = exc.returncode
+                sys.stderr.write("{}: {}\n".format(type(exc).__name__, exc))
+        config._ensure_unconfigure()
+    return session.exitstatus
+
+
+def pytest_cmdline_main(config: Config) -> Union[int, ExitCode]:
+    return wrap_session(config, _main)
+
+
+def _main(config: Config, session: "Session") -> Optional[Union[int, ExitCode]]:
+    """Default command line protocol for initialization, session,
+    running tests and reporting."""
+    config.hook.pytest_collection(session=session)
+    config.hook.pytest_runtestloop(session=session)
+
+    if session.testsfailed:
+        return ExitCode.TESTS_FAILED
+    elif session.testscollected == 0:
+        return ExitCode.NO_TESTS_COLLECTED
+    return None
+
+
+def pytest_collection(session: "Session") -> None:
+    session.perform_collect()
+
+
+def pytest_runtestloop(session: "Session") -> bool:
+    if session.testsfailed and not session.config.option.continue_on_collection_errors:
+        raise session.Interrupted(
+            "%d error%s during collection"
+            % (session.testsfailed, "s" if session.testsfailed != 1 else "")
+        )
+
+    if session.config.option.collectonly:
+        return True
+
+    for i, item in enumerate(session.items):
+        nextitem = session.items[i + 1] if i + 1 < len(session.items) else None
+        item.config.hook.pytest_runtest_protocol(item=item, nextitem=nextitem)
+        if session.shouldfail:
+            raise session.Failed(session.shouldfail)
+        if session.shouldstop:
+            raise session.Interrupted(session.shouldstop)
+    return True
+
+
+def _in_venv(path: py.path.local) -> bool:
+    """Attempt to detect if ``path`` is the root of a Virtual Environment by
+    checking for the existence of the appropriate activate script."""
+    bindir = path.join("Scripts" if sys.platform.startswith("win") else "bin")
+    if not bindir.isdir():
+        return False
+    activates = (
+        "activate",
+        "activate.csh",
+        "activate.fish",
+        "Activate",
+        "Activate.bat",
+        "Activate.ps1",
+    )
+    return any([fname.basename in activates for fname in bindir.listdir()])
+
+
+def pytest_ignore_collect(path: py.path.local, config: Config) -> Optional[bool]:
+    ignore_paths = config._getconftest_pathlist("collect_ignore", path=path.dirpath())
+    ignore_paths = ignore_paths or []
+    excludeopt = config.getoption("ignore")
+    if excludeopt:
+        ignore_paths.extend([py.path.local(x) for x in excludeopt])
+
+    if py.path.local(path) in ignore_paths:
+        return True
+
+    ignore_globs = config._getconftest_pathlist(
+        "collect_ignore_glob", path=path.dirpath()
+    )
+    ignore_globs = ignore_globs or []
+    excludeglobopt = config.getoption("ignore_glob")
+    if excludeglobopt:
+        ignore_globs.extend([py.path.local(x) for x in excludeglobopt])
+
+    if any(fnmatch.fnmatch(str(path), str(glob)) for glob in ignore_globs):
+        return True
+
+    allow_in_venv = config.getoption("collect_in_virtualenv")
+    if not allow_in_venv and _in_venv(path):
+        return True
+    return None
+
+
+def pytest_collection_modifyitems(items: List[nodes.Item], config: Config) -> None:
+    deselect_prefixes = tuple(config.getoption("deselect") or [])
+    if not deselect_prefixes:
+        return
+
+    remaining = []
+    deselected = []
+    for colitem in items:
+        if colitem.nodeid.startswith(deselect_prefixes):
+            deselected.append(colitem)
+        else:
+            remaining.append(colitem)
+
+    if deselected:
+        config.hook.pytest_deselected(items=deselected)
+        items[:] = remaining
+
+
+class FSHookProxy:
+    def __init__(self, pm: PytestPluginManager, remove_mods) -> None:
+        self.pm = pm
+        self.remove_mods = remove_mods
+
+    def __getattr__(self, name: str):
+        x = self.pm.subset_hook_caller(name, remove_plugins=self.remove_mods)
+        self.__dict__[name] = x
+        return x
+
+
+class Interrupted(KeyboardInterrupt):
+    """Signals that the test run was interrupted."""
+
+    __module__ = "builtins"  # For py3.
+
+
+class Failed(Exception):
+    """Signals a stop as failed test run."""
+
+
+@attr.s
+class _bestrelpath_cache(Dict[Path, str]):
+    path = attr.ib(type=Path)
+
+    def __missing__(self, path: Path) -> str:
+        r = bestrelpath(self.path, path)
+        self[path] = r
+        return r
+
+
+@final
+class Session(nodes.FSCollector):
+    Interrupted = Interrupted
+    Failed = Failed
+    # Set on the session by runner.pytest_sessionstart.
+    _setupstate: SetupState
+    # Set on the session by fixtures.pytest_sessionstart.
+    _fixturemanager: FixtureManager
+    exitstatus: Union[int, ExitCode]
+
+    def __init__(self, config: Config) -> None:
+        super().__init__(
+            config.rootdir, parent=None, config=config, session=self, nodeid=""
+        )
+        self.testsfailed = 0
+        self.testscollected = 0
+        self.shouldstop: Union[bool, str] = False
+        self.shouldfail: Union[bool, str] = False
+        self.trace = config.trace.root.get("collection")
+        self.startdir = config.invocation_dir
+        self._initialpaths: FrozenSet[py.path.local] = frozenset()
+
+        self._bestrelpathcache: Dict[Path, str] = _bestrelpath_cache(config.rootpath)
+
+        self.config.pluginmanager.register(self, name="session")
+
+    @classmethod
+    def from_config(cls, config: Config) -> "Session":
+        session: Session = cls._create(config)
+        return session
+
+    def __repr__(self) -> str:
+        return "<%s %s exitstatus=%r testsfailed=%d testscollected=%d>" % (
+            self.__class__.__name__,
+            self.name,
+            getattr(self, "exitstatus", "<UNSET>"),
+            self.testsfailed,
+            self.testscollected,
+        )
+
+    def _node_location_to_relpath(self, node_path: Path) -> str:
+        # bestrelpath is a quite slow function.
+        return self._bestrelpathcache[node_path]
+
+    @hookimpl(tryfirst=True)
+    def pytest_collectstart(self) -> None:
+        if self.shouldfail:
+            raise self.Failed(self.shouldfail)
+        if self.shouldstop:
+            raise self.Interrupted(self.shouldstop)
+
+    @hookimpl(tryfirst=True)
+    def pytest_runtest_logreport(
+        self, report: Union[TestReport, CollectReport]
+    ) -> None:
+        if report.failed and not hasattr(report, "wasxfail"):
+            self.testsfailed += 1
+            maxfail = self.config.getvalue("maxfail")
+            if maxfail and self.testsfailed >= maxfail:
+                self.shouldfail = "stopping after %d failures" % (self.testsfailed)
+
+    pytest_collectreport = pytest_runtest_logreport
+
+    def isinitpath(self, path: py.path.local) -> bool:
+        return path in self._initialpaths
+
+    def gethookproxy(self, fspath: py.path.local):
+        # Check if we have the common case of running
+        # hooks with all conftest.py files.
+        pm = self.config.pluginmanager
+        my_conftestmodules = pm._getconftestmodules(
+            fspath, self.config.getoption("importmode")
+        )
+        remove_mods = pm._conftest_plugins.difference(my_conftestmodules)
+        if remove_mods:
+            # One or more conftests are not in use at this fspath.
+            proxy = FSHookProxy(pm, remove_mods)
+        else:
+            # All plugins are active for this fspath.
+            proxy = self.config.hook
+        return proxy
+
+    def _recurse(self, direntry: "os.DirEntry[str]") -> bool:
+        if direntry.name == "__pycache__":
+            return False
+        path = py.path.local(direntry.path)
+        ihook = self.gethookproxy(path.dirpath())
+        if ihook.pytest_ignore_collect(path=path, config=self.config):
+            return False
+        norecursepatterns = self.config.getini("norecursedirs")
+        if any(path.check(fnmatch=pat) for pat in norecursepatterns):
+            return False
+        return True
+
+    def _collectfile(
+        self, path: py.path.local, handle_dupes: bool = True
+    ) -> Sequence[nodes.Collector]:
+        assert (
+            path.isfile()
+        ), "{!r} is not a file (isdir={!r}, exists={!r}, islink={!r})".format(
+            path, path.isdir(), path.exists(), path.islink()
+        )
+        ihook = self.gethookproxy(path)
+        if not self.isinitpath(path):
+            if ihook.pytest_ignore_collect(path=path, config=self.config):
+                return ()
+
+        if handle_dupes:
+            keepduplicates = self.config.getoption("keepduplicates")
+            if not keepduplicates:
+                duplicate_paths = self.config.pluginmanager._duplicatepaths
+                if path in duplicate_paths:
+                    return ()
+                else:
+                    duplicate_paths.add(path)
+
+        return ihook.pytest_collect_file(path=path, parent=self)  # type: ignore[no-any-return]
+
+    @overload
+    def perform_collect(
+        self, args: Optional[Sequence[str]] = ..., genitems: "Literal[True]" = ...
+    ) -> Sequence[nodes.Item]:
+        ...
+
+    @overload
+    def perform_collect(
+        self, args: Optional[Sequence[str]] = ..., genitems: bool = ...
+    ) -> Sequence[Union[nodes.Item, nodes.Collector]]:
+        ...
+
+    def perform_collect(
+        self, args: Optional[Sequence[str]] = None, genitems: bool = True
+    ) -> Sequence[Union[nodes.Item, nodes.Collector]]:
+        """Perform the collection phase for this session.
+
+        This is called by the default
+        :func:`pytest_collection <_pytest.hookspec.pytest_collection>` hook
+        implementation; see the documentation of this hook for more details.
+        For testing purposes, it may also be called directly on a fresh
+        ``Session``.
+
+        This function normally recursively expands any collectors collected
+        from the session to their items, and only items are returned. For
+        testing purposes, this may be suppressed by passing ``genitems=False``,
+        in which case the return value contains these collectors unexpanded,
+        and ``session.items`` is empty.
+        """
+        if args is None:
+            args = self.config.args
+
+        self.trace("perform_collect", self, args)
+        self.trace.root.indent += 1
+
+        self._notfound: List[Tuple[str, Sequence[nodes.Collector]]] = []
+        self._initial_parts: List[Tuple[py.path.local, List[str]]] = []
+        self.items: List[nodes.Item] = []
+
+        hook = self.config.hook
+
+        items: Sequence[Union[nodes.Item, nodes.Collector]] = self.items
+        try:
+            initialpaths: List[py.path.local] = []
+            for arg in args:
+                fspath, parts = resolve_collection_argument(
+                    self.config.invocation_params.dir,
+                    arg,
+                    as_pypath=self.config.option.pyargs,
+                )
+                self._initial_parts.append((fspath, parts))
+                initialpaths.append(fspath)
+            self._initialpaths = frozenset(initialpaths)
+            rep = collect_one_node(self)
+            self.ihook.pytest_collectreport(report=rep)
+            self.trace.root.indent -= 1
+            if self._notfound:
+                errors = []
+                for arg, cols in self._notfound:
+                    line = f"(no name {arg!r} in any of {cols!r})"
+                    errors.append(f"not found: {arg}\n{line}")
+                raise UsageError(*errors)
+            if not genitems:
+                items = rep.result
+            else:
+                if rep.passed:
+                    for node in rep.result:
+                        self.items.extend(self.genitems(node))
+
+            self.config.pluginmanager.check_pending()
+            hook.pytest_collection_modifyitems(
+                session=self, config=self.config, items=items
+            )
+        finally:
+            hook.pytest_collection_finish(session=self)
+
+        self.testscollected = len(items)
+        return items
+
+    def collect(self) -> Iterator[Union[nodes.Item, nodes.Collector]]:
+        from _pytest.python import Package
+
+        # Keep track of any collected nodes in here, so we don't duplicate fixtures.
+        node_cache1: Dict[py.path.local, Sequence[nodes.Collector]] = {}
+        node_cache2: Dict[
+            Tuple[Type[nodes.Collector], py.path.local], nodes.Collector
+        ] = ({})
+
+        # Keep track of any collected collectors in matchnodes paths, so they
+        # are not collected more than once.
+        matchnodes_cache: Dict[Tuple[Type[nodes.Collector], str], CollectReport] = ({})
+
+        # Dirnames of pkgs with dunder-init files.
+        pkg_roots: Dict[str, Package] = {}
+
+        for argpath, names in self._initial_parts:
+            self.trace("processing argument", (argpath, names))
+            self.trace.root.indent += 1
+
+            # Start with a Session root, and delve to argpath item (dir or file)
+            # and stack all Packages found on the way.
+            # No point in finding packages when collecting doctests.
+            if not self.config.getoption("doctestmodules", False):
+                pm = self.config.pluginmanager
+                for parent in reversed(argpath.parts()):
+                    if pm._confcutdir and pm._confcutdir.relto(parent):
+                        break
+
+                    if parent.isdir():
+                        pkginit = parent.join("__init__.py")
+                        if pkginit.isfile() and pkginit not in node_cache1:
+                            col = self._collectfile(pkginit, handle_dupes=False)
+                            if col:
+                                if isinstance(col[0], Package):
+                                    pkg_roots[str(parent)] = col[0]
+                                node_cache1[col[0].fspath] = [col[0]]
+
+            # If it's a directory argument, recurse and look for any Subpackages.
+            # Let the Package collector deal with subnodes, don't collect here.
+            if argpath.check(dir=1):
+                assert not names, "invalid arg {!r}".format((argpath, names))
+
+                seen_dirs: Set[py.path.local] = set()
+                for direntry in visit(str(argpath), self._recurse):
+                    if not direntry.is_file():
+                        continue
+
+                    path = py.path.local(direntry.path)
+                    dirpath = path.dirpath()
+
+                    if dirpath not in seen_dirs:
+                        # Collect packages first.
+                        seen_dirs.add(dirpath)
+                        pkginit = dirpath.join("__init__.py")
+                        if pkginit.exists():
+                            for x in self._collectfile(pkginit):
+                                yield x
+                                if isinstance(x, Package):
+                                    pkg_roots[str(dirpath)] = x
+                    if str(dirpath) in pkg_roots:
+                        # Do not collect packages here.
+                        continue
+
+                    for x in self._collectfile(path):
+                        key = (type(x), x.fspath)
+                        if key in node_cache2:
+                            yield node_cache2[key]
+                        else:
+                            node_cache2[key] = x
+                            yield x
+            else:
+                assert argpath.check(file=1)
+
+                if argpath in node_cache1:
+                    col = node_cache1[argpath]
+                else:
+                    collect_root = pkg_roots.get(argpath.dirname, self)
+                    col = collect_root._collectfile(argpath, handle_dupes=False)
+                    if col:
+                        node_cache1[argpath] = col
+
+                matching = []
+                work: List[
+                    Tuple[Sequence[Union[nodes.Item, nodes.Collector]], Sequence[str]]
+                ] = [(col, names)]
+                while work:
+                    self.trace("matchnodes", col, names)
+                    self.trace.root.indent += 1
+
+                    matchnodes, matchnames = work.pop()
+                    for node in matchnodes:
+                        if not matchnames:
+                            matching.append(node)
+                            continue
+                        if not isinstance(node, nodes.Collector):
+                            continue
+                        key = (type(node), node.nodeid)
+                        if key in matchnodes_cache:
+                            rep = matchnodes_cache[key]
+                        else:
+                            rep = collect_one_node(node)
+                            matchnodes_cache[key] = rep
+                        if rep.passed:
+                            submatchnodes = []
+                            for r in rep.result:
+                                # TODO: Remove parametrized workaround once collection structure contains
+                                # parametrization.
+                                if (
+                                    r.name == matchnames[0]
+                                    or r.name.split("[")[0] == matchnames[0]
+                                ):
+                                    submatchnodes.append(r)
+                            if submatchnodes:
+                                work.append((submatchnodes, matchnames[1:]))
+                            # XXX Accept IDs that don't have "()" for class instances.
+                            elif len(rep.result) == 1 and rep.result[0].name == "()":
+                                work.append((rep.result, matchnames))
+                        else:
+                            # Report collection failures here to avoid failing to run some test
+                            # specified in the command line because the module could not be
+                            # imported (#134).
+                            node.ihook.pytest_collectreport(report=rep)
+
+                    self.trace("matchnodes finished -> ", len(matching), "nodes")
+                    self.trace.root.indent -= 1
+
+                if not matching:
+                    report_arg = "::".join((str(argpath), *names))
+                    self._notfound.append((report_arg, col))
+                    continue
+
+                # If __init__.py was the only file requested, then the matched
+                # node will be the corresponding Package (by default), and the
+                # first yielded item will be the __init__ Module itself, so
+                # just use that. If this special case isn't taken, then all the
+                # files in the package will be yielded.
+                if argpath.basename == "__init__.py" and isinstance(
+                    matching[0], Package
+                ):
+                    try:
+                        yield next(iter(matching[0].collect()))
+                    except StopIteration:
+                        # The package collects nothing with only an __init__.py
+                        # file in it, which gets ignored by the default
+                        # "python_files" option.
+                        pass
+                    continue
+
+                yield from matching
+
+            self.trace.root.indent -= 1
+
+    def genitems(
+        self, node: Union[nodes.Item, nodes.Collector]
+    ) -> Iterator[nodes.Item]:
+        self.trace("genitems", node)
+        if isinstance(node, nodes.Item):
+            node.ihook.pytest_itemcollected(item=node)
+            yield node
+        else:
+            assert isinstance(node, nodes.Collector)
+            rep = collect_one_node(node)
+            if rep.passed:
+                for subnode in rep.result:
+                    yield from self.genitems(subnode)
+            node.ihook.pytest_collectreport(report=rep)
+
+
+def search_pypath(module_name: str) -> str:
+    """Search sys.path for the given a dotted module name, and return its file system path."""
+    try:
+        spec = importlib.util.find_spec(module_name)
+    # AttributeError: looks like package module, but actually filename
+    # ImportError: module does not exist
+    # ValueError: not a module name
+    except (AttributeError, ImportError, ValueError):
+        return module_name
+    if spec is None or spec.origin is None or spec.origin == "namespace":
+        return module_name
+    elif spec.submodule_search_locations:
+        return os.path.dirname(spec.origin)
+    else:
+        return spec.origin
+
+
+def resolve_collection_argument(
+    invocation_path: Path, arg: str, *, as_pypath: bool = False
+) -> Tuple[py.path.local, List[str]]:
+    """Parse path arguments optionally containing selection parts and return (fspath, names).
+
+    Command-line arguments can point to files and/or directories, and optionally contain
+    parts for specific tests selection, for example:
+
+        "pkg/tests/test_foo.py::TestClass::test_foo"
+
+    This function ensures the path exists, and returns a tuple:
+
+        (py.path.path("/full/path/to/pkg/tests/test_foo.py"), ["TestClass", "test_foo"])
+
+    When as_pypath is True, expects that the command-line argument actually contains
+    module paths instead of file-system paths:
+
+        "pkg.tests.test_foo::TestClass::test_foo"
+
+    In which case we search sys.path for a matching module, and then return the *path* to the
+    found module.
+
+    If the path doesn't exist, raise UsageError.
+    If the path is a directory and selection parts are present, raise UsageError.
+    """
+    strpath, *parts = str(arg).split("::")
+    if as_pypath:
+        strpath = search_pypath(strpath)
+    fspath = invocation_path / strpath
+    fspath = absolutepath(fspath)
+    if not fspath.exists():
+        msg = (
+            "module or package not found: {arg} (missing __init__.py?)"
+            if as_pypath
+            else "file or directory not found: {arg}"
+        )
+        raise UsageError(msg.format(arg=arg))
+    if parts and fspath.is_dir():
+        msg = (
+            "package argument cannot contain :: selection parts: {arg}"
+            if as_pypath
+            else "directory argument cannot contain :: selection parts: {arg}"
+        )
+        raise UsageError(msg.format(arg=arg))
+    return py.path.local(str(fspath)), parts
diff --git a/myenv/lib/python3.9/site-packages/_pytest/mark/__init__.py b/myenv/lib/python3.9/site-packages/_pytest/mark/__init__.py
new file mode 100644
index 0000000..329a11c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/mark/__init__.py
@@ -0,0 +1,282 @@
+"""Generic mechanism for marking and selecting python functions."""
+import warnings
+from typing import AbstractSet
+from typing import Collection
+from typing import List
+from typing import Optional
+from typing import TYPE_CHECKING
+from typing import Union
+
+import attr
+
+from .expression import Expression
+from .expression import ParseError
+from .structures import EMPTY_PARAMETERSET_OPTION
+from .structures import get_empty_parameterset_mark
+from .structures import Mark
+from .structures import MARK_GEN
+from .structures import MarkDecorator
+from .structures import MarkGenerator
+from .structures import ParameterSet
+from _pytest.config import Config
+from _pytest.config import ExitCode
+from _pytest.config import hookimpl
+from _pytest.config import UsageError
+from _pytest.config.argparsing import Parser
+from _pytest.deprecated import MINUS_K_COLON
+from _pytest.deprecated import MINUS_K_DASH
+from _pytest.store import StoreKey
+
+if TYPE_CHECKING:
+    from _pytest.nodes import Item
+
+
+__all__ = [
+    "MARK_GEN",
+    "Mark",
+    "MarkDecorator",
+    "MarkGenerator",
+    "ParameterSet",
+    "get_empty_parameterset_mark",
+]
+
+
+old_mark_config_key = StoreKey[Optional[Config]]()
+
+
+def param(
+    *values: object,
+    marks: Union[MarkDecorator, Collection[Union[MarkDecorator, Mark]]] = (),
+    id: Optional[str] = None,
+) -> ParameterSet:
+    """Specify a parameter in `pytest.mark.parametrize`_ calls or
+    :ref:`parametrized fixtures <fixture-parametrize-marks>`.
+
+    .. code-block:: python
+
+        @pytest.mark.parametrize(
+            "test_input,expected",
+            [("3+5", 8), pytest.param("6*9", 42, marks=pytest.mark.xfail),],
+        )
+        def test_eval(test_input, expected):
+            assert eval(test_input) == expected
+
+    :param values: Variable args of the values of the parameter set, in order.
+    :keyword marks: A single mark or a list of marks to be applied to this parameter set.
+    :keyword str id: The id to attribute to this parameter set.
+    """
+    return ParameterSet.param(*values, marks=marks, id=id)
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("general")
+    group._addoption(
+        "-k",
+        action="store",
+        dest="keyword",
+        default="",
+        metavar="EXPRESSION",
+        help="only run tests which match the given substring expression. "
+        "An expression is a python evaluatable expression "
+        "where all names are substring-matched against test names "
+        "and their parent classes. Example: -k 'test_method or test_"
+        "other' matches all test functions and classes whose name "
+        "contains 'test_method' or 'test_other', while -k 'not test_method' "
+        "matches those that don't contain 'test_method' in their names. "
+        "-k 'not test_method and not test_other' will eliminate the matches. "
+        "Additionally keywords are matched to classes and functions "
+        "containing extra names in their 'extra_keyword_matches' set, "
+        "as well as functions which have names assigned directly to them. "
+        "The matching is case-insensitive.",
+    )
+
+    group._addoption(
+        "-m",
+        action="store",
+        dest="markexpr",
+        default="",
+        metavar="MARKEXPR",
+        help="only run tests matching given mark expression.\n"
+        "For example: -m 'mark1 and not mark2'.",
+    )
+
+    group.addoption(
+        "--markers",
+        action="store_true",
+        help="show markers (builtin, plugin and per-project ones).",
+    )
+
+    parser.addini("markers", "markers for test functions", "linelist")
+    parser.addini(EMPTY_PARAMETERSET_OPTION, "default marker for empty parametersets")
+
+
+@hookimpl(tryfirst=True)
+def pytest_cmdline_main(config: Config) -> Optional[Union[int, ExitCode]]:
+    import _pytest.config
+
+    if config.option.markers:
+        config._do_configure()
+        tw = _pytest.config.create_terminal_writer(config)
+        for line in config.getini("markers"):
+            parts = line.split(":", 1)
+            name = parts[0]
+            rest = parts[1] if len(parts) == 2 else ""
+            tw.write("@pytest.mark.%s:" % name, bold=True)
+            tw.line(rest)
+            tw.line()
+        config._ensure_unconfigure()
+        return 0
+
+    return None
+
+
+@attr.s(slots=True)
+class KeywordMatcher:
+    """A matcher for keywords.
+
+    Given a list of names, matches any substring of one of these names. The
+    string inclusion check is case-insensitive.
+
+    Will match on the name of colitem, including the names of its parents.
+    Only matches names of items which are either a :class:`Class` or a
+    :class:`Function`.
+
+    Additionally, matches on names in the 'extra_keyword_matches' set of
+    any item, as well as names directly assigned to test functions.
+    """
+
+    _names = attr.ib(type=AbstractSet[str])
+
+    @classmethod
+    def from_item(cls, item: "Item") -> "KeywordMatcher":
+        mapped_names = set()
+
+        # Add the names of the current item and any parent items.
+        import pytest
+
+        for node in item.listchain():
+            if not isinstance(node, (pytest.Instance, pytest.Session)):
+                mapped_names.add(node.name)
+
+        # Add the names added as extra keywords to current or parent items.
+        mapped_names.update(item.listextrakeywords())
+
+        # Add the names attached to the current function through direct assignment.
+        function_obj = getattr(item, "function", None)
+        if function_obj:
+            mapped_names.update(function_obj.__dict__)
+
+        # Add the markers to the keywords as we no longer handle them correctly.
+        mapped_names.update(mark.name for mark in item.iter_markers())
+
+        return cls(mapped_names)
+
+    def __call__(self, subname: str) -> bool:
+        subname = subname.lower()
+        names = (name.lower() for name in self._names)
+
+        for name in names:
+            if subname in name:
+                return True
+        return False
+
+
+def deselect_by_keyword(items: "List[Item]", config: Config) -> None:
+    keywordexpr = config.option.keyword.lstrip()
+    if not keywordexpr:
+        return
+
+    if keywordexpr.startswith("-"):
+        # To be removed in pytest 7.0.0.
+        warnings.warn(MINUS_K_DASH, stacklevel=2)
+        keywordexpr = "not " + keywordexpr[1:]
+    selectuntil = False
+    if keywordexpr[-1:] == ":":
+        # To be removed in pytest 7.0.0.
+        warnings.warn(MINUS_K_COLON, stacklevel=2)
+        selectuntil = True
+        keywordexpr = keywordexpr[:-1]
+
+    try:
+        expression = Expression.compile(keywordexpr)
+    except ParseError as e:
+        raise UsageError(
+            f"Wrong expression passed to '-k': {keywordexpr}: {e}"
+        ) from None
+
+    remaining = []
+    deselected = []
+    for colitem in items:
+        if keywordexpr and not expression.evaluate(KeywordMatcher.from_item(colitem)):
+            deselected.append(colitem)
+        else:
+            if selectuntil:
+                keywordexpr = None
+            remaining.append(colitem)
+
+    if deselected:
+        config.hook.pytest_deselected(items=deselected)
+        items[:] = remaining
+
+
+@attr.s(slots=True)
+class MarkMatcher:
+    """A matcher for markers which are present.
+
+    Tries to match on any marker names, attached to the given colitem.
+    """
+
+    own_mark_names = attr.ib()
+
+    @classmethod
+    def from_item(cls, item) -> "MarkMatcher":
+        mark_names = {mark.name for mark in item.iter_markers()}
+        return cls(mark_names)
+
+    def __call__(self, name: str) -> bool:
+        return name in self.own_mark_names
+
+
+def deselect_by_mark(items: "List[Item]", config: Config) -> None:
+    matchexpr = config.option.markexpr
+    if not matchexpr:
+        return
+
+    try:
+        expression = Expression.compile(matchexpr)
+    except ParseError as e:
+        raise UsageError(f"Wrong expression passed to '-m': {matchexpr}: {e}") from None
+
+    remaining = []
+    deselected = []
+    for item in items:
+        if expression.evaluate(MarkMatcher.from_item(item)):
+            remaining.append(item)
+        else:
+            deselected.append(item)
+
+    if deselected:
+        config.hook.pytest_deselected(items=deselected)
+        items[:] = remaining
+
+
+def pytest_collection_modifyitems(items: "List[Item]", config: Config) -> None:
+    deselect_by_keyword(items, config)
+    deselect_by_mark(items, config)
+
+
+def pytest_configure(config: Config) -> None:
+    config._store[old_mark_config_key] = MARK_GEN._config
+    MARK_GEN._config = config
+
+    empty_parameterset = config.getini(EMPTY_PARAMETERSET_OPTION)
+
+    if empty_parameterset not in ("skip", "xfail", "fail_at_collect", None, ""):
+        raise UsageError(
+            "{!s} must be one of skip, xfail or fail_at_collect"
+            " but it is {!r}".format(EMPTY_PARAMETERSET_OPTION, empty_parameterset)
+        )
+
+
+def pytest_unconfigure(config: Config) -> None:
+    MARK_GEN._config = config._store.get(old_mark_config_key, None)
diff --git a/myenv/lib/python3.9/site-packages/_pytest/mark/expression.py b/myenv/lib/python3.9/site-packages/_pytest/mark/expression.py
new file mode 100644
index 0000000..dc3991b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/mark/expression.py
@@ -0,0 +1,221 @@
+r"""Evaluate match expressions, as used by `-k` and `-m`.
+
+The grammar is:
+
+expression: expr? EOF
+expr:       and_expr ('or' and_expr)*
+and_expr:   not_expr ('and' not_expr)*
+not_expr:   'not' not_expr | '(' expr ')' | ident
+ident:      (\w|:|\+|-|\.|\[|\])+
+
+The semantics are:
+
+- Empty expression evaluates to False.
+- ident evaluates to True of False according to a provided matcher function.
+- or/and/not evaluate according to the usual boolean semantics.
+"""
+import ast
+import enum
+import re
+import types
+from typing import Callable
+from typing import Iterator
+from typing import Mapping
+from typing import Optional
+from typing import Sequence
+from typing import TYPE_CHECKING
+
+import attr
+
+if TYPE_CHECKING:
+    from typing import NoReturn
+
+
+__all__ = [
+    "Expression",
+    "ParseError",
+]
+
+
+class TokenType(enum.Enum):
+    LPAREN = "left parenthesis"
+    RPAREN = "right parenthesis"
+    OR = "or"
+    AND = "and"
+    NOT = "not"
+    IDENT = "identifier"
+    EOF = "end of input"
+
+
+@attr.s(frozen=True, slots=True)
+class Token:
+    type = attr.ib(type=TokenType)
+    value = attr.ib(type=str)
+    pos = attr.ib(type=int)
+
+
+class ParseError(Exception):
+    """The expression contains invalid syntax.
+
+    :param column: The column in the line where the error occurred (1-based).
+    :param message: A description of the error.
+    """
+
+    def __init__(self, column: int, message: str) -> None:
+        self.column = column
+        self.message = message
+
+    def __str__(self) -> str:
+        return f"at column {self.column}: {self.message}"
+
+
+class Scanner:
+    __slots__ = ("tokens", "current")
+
+    def __init__(self, input: str) -> None:
+        self.tokens = self.lex(input)
+        self.current = next(self.tokens)
+
+    def lex(self, input: str) -> Iterator[Token]:
+        pos = 0
+        while pos < len(input):
+            if input[pos] in (" ", "\t"):
+                pos += 1
+            elif input[pos] == "(":
+                yield Token(TokenType.LPAREN, "(", pos)
+                pos += 1
+            elif input[pos] == ")":
+                yield Token(TokenType.RPAREN, ")", pos)
+                pos += 1
+            else:
+                match = re.match(r"(:?\w|:|\+|-|\.|\[|\])+", input[pos:])
+                if match:
+                    value = match.group(0)
+                    if value == "or":
+                        yield Token(TokenType.OR, value, pos)
+                    elif value == "and":
+                        yield Token(TokenType.AND, value, pos)
+                    elif value == "not":
+                        yield Token(TokenType.NOT, value, pos)
+                    else:
+                        yield Token(TokenType.IDENT, value, pos)
+                    pos += len(value)
+                else:
+                    raise ParseError(
+                        pos + 1, 'unexpected character "{}"'.format(input[pos]),
+                    )
+        yield Token(TokenType.EOF, "", pos)
+
+    def accept(self, type: TokenType, *, reject: bool = False) -> Optional[Token]:
+        if self.current.type is type:
+            token = self.current
+            if token.type is not TokenType.EOF:
+                self.current = next(self.tokens)
+            return token
+        if reject:
+            self.reject((type,))
+        return None
+
+    def reject(self, expected: Sequence[TokenType]) -> "NoReturn":
+        raise ParseError(
+            self.current.pos + 1,
+            "expected {}; got {}".format(
+                " OR ".join(type.value for type in expected), self.current.type.value,
+            ),
+        )
+
+
+# True, False and None are legal match expression identifiers,
+# but illegal as Python identifiers. To fix this, this prefix
+# is added to identifiers in the conversion to Python AST.
+IDENT_PREFIX = "$"
+
+
+def expression(s: Scanner) -> ast.Expression:
+    if s.accept(TokenType.EOF):
+        ret: ast.expr = ast.NameConstant(False)
+    else:
+        ret = expr(s)
+        s.accept(TokenType.EOF, reject=True)
+    return ast.fix_missing_locations(ast.Expression(ret))
+
+
+def expr(s: Scanner) -> ast.expr:
+    ret = and_expr(s)
+    while s.accept(TokenType.OR):
+        rhs = and_expr(s)
+        ret = ast.BoolOp(ast.Or(), [ret, rhs])
+    return ret
+
+
+def and_expr(s: Scanner) -> ast.expr:
+    ret = not_expr(s)
+    while s.accept(TokenType.AND):
+        rhs = not_expr(s)
+        ret = ast.BoolOp(ast.And(), [ret, rhs])
+    return ret
+
+
+def not_expr(s: Scanner) -> ast.expr:
+    if s.accept(TokenType.NOT):
+        return ast.UnaryOp(ast.Not(), not_expr(s))
+    if s.accept(TokenType.LPAREN):
+        ret = expr(s)
+        s.accept(TokenType.RPAREN, reject=True)
+        return ret
+    ident = s.accept(TokenType.IDENT)
+    if ident:
+        return ast.Name(IDENT_PREFIX + ident.value, ast.Load())
+    s.reject((TokenType.NOT, TokenType.LPAREN, TokenType.IDENT))
+
+
+class MatcherAdapter(Mapping[str, bool]):
+    """Adapts a matcher function to a locals mapping as required by eval()."""
+
+    def __init__(self, matcher: Callable[[str], bool]) -> None:
+        self.matcher = matcher
+
+    def __getitem__(self, key: str) -> bool:
+        return self.matcher(key[len(IDENT_PREFIX) :])
+
+    def __iter__(self) -> Iterator[str]:
+        raise NotImplementedError()
+
+    def __len__(self) -> int:
+        raise NotImplementedError()
+
+
+class Expression:
+    """A compiled match expression as used by -k and -m.
+
+    The expression can be evaulated against different matchers.
+    """
+
+    __slots__ = ("code",)
+
+    def __init__(self, code: types.CodeType) -> None:
+        self.code = code
+
+    @classmethod
+    def compile(self, input: str) -> "Expression":
+        """Compile a match expression.
+
+        :param input: The input expression - one line.
+        """
+        astexpr = expression(Scanner(input))
+        code: types.CodeType = compile(
+            astexpr, filename="<pytest match expression>", mode="eval",
+        )
+        return Expression(code)
+
+    def evaluate(self, matcher: Callable[[str], bool]) -> bool:
+        """Evaluate the match expression.
+
+        :param matcher:
+            Given an identifier, should return whether it matches or not.
+            Should be prepared to handle arbitrary strings as input.
+
+        :returns: Whether the expression matches or not.
+        """
+        ret: bool = eval(self.code, {"__builtins__": {}}, MatcherAdapter(matcher))
+        return ret
diff --git a/myenv/lib/python3.9/site-packages/_pytest/mark/structures.py b/myenv/lib/python3.9/site-packages/_pytest/mark/structures.py
new file mode 100644
index 0000000..6c126cf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/mark/structures.py
@@ -0,0 +1,559 @@
+import collections.abc
+import inspect
+import warnings
+from typing import Any
+from typing import Callable
+from typing import Collection
+from typing import Iterable
+from typing import Iterator
+from typing import List
+from typing import Mapping
+from typing import MutableMapping
+from typing import NamedTuple
+from typing import Optional
+from typing import overload
+from typing import Sequence
+from typing import Set
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import TypeVar
+from typing import Union
+
+import attr
+
+from .._code import getfslineno
+from ..compat import ascii_escaped
+from ..compat import final
+from ..compat import NOTSET
+from ..compat import NotSetType
+from _pytest.config import Config
+from _pytest.outcomes import fail
+from _pytest.warning_types import PytestUnknownMarkWarning
+
+if TYPE_CHECKING:
+    from ..nodes import Node
+
+
+EMPTY_PARAMETERSET_OPTION = "empty_parameter_set_mark"
+
+
+def istestfunc(func) -> bool:
+    return (
+        hasattr(func, "__call__")
+        and getattr(func, "__name__", "<lambda>") != "<lambda>"
+    )
+
+
+def get_empty_parameterset_mark(
+    config: Config, argnames: Sequence[str], func
+) -> "MarkDecorator":
+    from ..nodes import Collector
+
+    fs, lineno = getfslineno(func)
+    reason = "got empty parameter set %r, function %s at %s:%d" % (
+        argnames,
+        func.__name__,
+        fs,
+        lineno,
+    )
+
+    requested_mark = config.getini(EMPTY_PARAMETERSET_OPTION)
+    if requested_mark in ("", None, "skip"):
+        mark = MARK_GEN.skip(reason=reason)
+    elif requested_mark == "xfail":
+        mark = MARK_GEN.xfail(reason=reason, run=False)
+    elif requested_mark == "fail_at_collect":
+        f_name = func.__name__
+        _, lineno = getfslineno(func)
+        raise Collector.CollectError(
+            "Empty parameter set in '%s' at line %d" % (f_name, lineno + 1)
+        )
+    else:
+        raise LookupError(requested_mark)
+    return mark
+
+
+class ParameterSet(
+    NamedTuple(
+        "ParameterSet",
+        [
+            ("values", Sequence[Union[object, NotSetType]]),
+            ("marks", Collection[Union["MarkDecorator", "Mark"]]),
+            ("id", Optional[str]),
+        ],
+    )
+):
+    @classmethod
+    def param(
+        cls,
+        *values: object,
+        marks: Union["MarkDecorator", Collection[Union["MarkDecorator", "Mark"]]] = (),
+        id: Optional[str] = None,
+    ) -> "ParameterSet":
+        if isinstance(marks, MarkDecorator):
+            marks = (marks,)
+        else:
+            assert isinstance(marks, collections.abc.Collection)
+
+        if id is not None:
+            if not isinstance(id, str):
+                raise TypeError(
+                    "Expected id to be a string, got {}: {!r}".format(type(id), id)
+                )
+            id = ascii_escaped(id)
+        return cls(values, marks, id)
+
+    @classmethod
+    def extract_from(
+        cls,
+        parameterset: Union["ParameterSet", Sequence[object], object],
+        force_tuple: bool = False,
+    ) -> "ParameterSet":
+        """Extract from an object or objects.
+
+        :param parameterset:
+            A legacy style parameterset that may or may not be a tuple,
+            and may or may not be wrapped into a mess of mark objects.
+
+        :param force_tuple:
+            Enforce tuple wrapping so single argument tuple values
+            don't get decomposed and break tests.
+        """
+
+        if isinstance(parameterset, cls):
+            return parameterset
+        if force_tuple:
+            return cls.param(parameterset)
+        else:
+            # TODO: Refactor to fix this type-ignore. Currently the following
+            # passes type-checking but crashes:
+            #
+            #   @pytest.mark.parametrize(('x', 'y'), [1, 2])
+            #   def test_foo(x, y): pass
+            return cls(parameterset, marks=[], id=None)  # type: ignore[arg-type]
+
+    @staticmethod
+    def _parse_parametrize_args(
+        argnames: Union[str, List[str], Tuple[str, ...]],
+        argvalues: Iterable[Union["ParameterSet", Sequence[object], object]],
+        *args,
+        **kwargs,
+    ) -> Tuple[Union[List[str], Tuple[str, ...]], bool]:
+        if not isinstance(argnames, (tuple, list)):
+            argnames = [x.strip() for x in argnames.split(",") if x.strip()]
+            force_tuple = len(argnames) == 1
+        else:
+            force_tuple = False
+        return argnames, force_tuple
+
+    @staticmethod
+    def _parse_parametrize_parameters(
+        argvalues: Iterable[Union["ParameterSet", Sequence[object], object]],
+        force_tuple: bool,
+    ) -> List["ParameterSet"]:
+        return [
+            ParameterSet.extract_from(x, force_tuple=force_tuple) for x in argvalues
+        ]
+
+    @classmethod
+    def _for_parametrize(
+        cls,
+        argnames: Union[str, List[str], Tuple[str, ...]],
+        argvalues: Iterable[Union["ParameterSet", Sequence[object], object]],
+        func,
+        config: Config,
+        nodeid: str,
+    ) -> Tuple[Union[List[str], Tuple[str, ...]], List["ParameterSet"]]:
+        argnames, force_tuple = cls._parse_parametrize_args(argnames, argvalues)
+        parameters = cls._parse_parametrize_parameters(argvalues, force_tuple)
+        del argvalues
+
+        if parameters:
+            # Check all parameter sets have the correct number of values.
+            for param in parameters:
+                if len(param.values) != len(argnames):
+                    msg = (
+                        '{nodeid}: in "parametrize" the number of names ({names_len}):\n'
+                        "  {names}\n"
+                        "must be equal to the number of values ({values_len}):\n"
+                        "  {values}"
+                    )
+                    fail(
+                        msg.format(
+                            nodeid=nodeid,
+                            values=param.values,
+                            names=argnames,
+                            names_len=len(argnames),
+                            values_len=len(param.values),
+                        ),
+                        pytrace=False,
+                    )
+        else:
+            # Empty parameter set (likely computed at runtime): create a single
+            # parameter set with NOTSET values, with the "empty parameter set" mark applied to it.
+            mark = get_empty_parameterset_mark(config, argnames, func)
+            parameters.append(
+                ParameterSet(values=(NOTSET,) * len(argnames), marks=[mark], id=None)
+            )
+        return argnames, parameters
+
+
+@final
+@attr.s(frozen=True)
+class Mark:
+    #: Name of the mark.
+    name = attr.ib(type=str)
+    #: Positional arguments of the mark decorator.
+    args = attr.ib(type=Tuple[Any, ...])
+    #: Keyword arguments of the mark decorator.
+    kwargs = attr.ib(type=Mapping[str, Any])
+
+    #: Source Mark for ids with parametrize Marks.
+    _param_ids_from = attr.ib(type=Optional["Mark"], default=None, repr=False)
+    #: Resolved/generated ids with parametrize Marks.
+    _param_ids_generated = attr.ib(
+        type=Optional[Sequence[str]], default=None, repr=False
+    )
+
+    def _has_param_ids(self) -> bool:
+        return "ids" in self.kwargs or len(self.args) >= 4
+
+    def combined_with(self, other: "Mark") -> "Mark":
+        """Return a new Mark which is a combination of this
+        Mark and another Mark.
+
+        Combines by appending args and merging kwargs.
+
+        :param Mark other: The mark to combine with.
+        :rtype: Mark
+        """
+        assert self.name == other.name
+
+        # Remember source of ids with parametrize Marks.
+        param_ids_from: Optional[Mark] = None
+        if self.name == "parametrize":
+            if other._has_param_ids():
+                param_ids_from = other
+            elif self._has_param_ids():
+                param_ids_from = self
+
+        return Mark(
+            self.name,
+            self.args + other.args,
+            dict(self.kwargs, **other.kwargs),
+            param_ids_from=param_ids_from,
+        )
+
+
+# A generic parameter designating an object to which a Mark may
+# be applied -- a test function (callable) or class.
+# Note: a lambda is not allowed, but this can't be represented.
+_Markable = TypeVar("_Markable", bound=Union[Callable[..., object], type])
+
+
+@attr.s
+class MarkDecorator:
+    """A decorator for applying a mark on test functions and classes.
+
+    MarkDecorators are created with ``pytest.mark``::
+
+        mark1 = pytest.mark.NAME              # Simple MarkDecorator
+        mark2 = pytest.mark.NAME(name1=value) # Parametrized MarkDecorator
+
+    and can then be applied as decorators to test functions::
+
+        @mark2
+        def test_function():
+            pass
+
+    When a MarkDecorator is called it does the following:
+
+    1. If called with a single class as its only positional argument and no
+       additional keyword arguments, it attaches the mark to the class so it
+       gets applied automatically to all test cases found in that class.
+
+    2. If called with a single function as its only positional argument and
+       no additional keyword arguments, it attaches the mark to the function,
+       containing all the arguments already stored internally in the
+       MarkDecorator.
+
+    3. When called in any other case, it returns a new MarkDecorator instance
+       with the original MarkDecorator's content updated with the arguments
+       passed to this call.
+
+    Note: The rules above prevent MarkDecorators from storing only a single
+    function or class reference as their positional argument with no
+    additional keyword or positional arguments. You can work around this by
+    using `with_args()`.
+    """
+
+    mark = attr.ib(type=Mark, validator=attr.validators.instance_of(Mark))
+
+    @property
+    def name(self) -> str:
+        """Alias for mark.name."""
+        return self.mark.name
+
+    @property
+    def args(self) -> Tuple[Any, ...]:
+        """Alias for mark.args."""
+        return self.mark.args
+
+    @property
+    def kwargs(self) -> Mapping[str, Any]:
+        """Alias for mark.kwargs."""
+        return self.mark.kwargs
+
+    @property
+    def markname(self) -> str:
+        return self.name  # for backward-compat (2.4.1 had this attr)
+
+    def __repr__(self) -> str:
+        return f"<MarkDecorator {self.mark!r}>"
+
+    def with_args(self, *args: object, **kwargs: object) -> "MarkDecorator":
+        """Return a MarkDecorator with extra arguments added.
+
+        Unlike calling the MarkDecorator, with_args() can be used even
+        if the sole argument is a callable/class.
+
+        :rtype: MarkDecorator
+        """
+        mark = Mark(self.name, args, kwargs)
+        return self.__class__(self.mark.combined_with(mark))
+
+    # Type ignored because the overloads overlap with an incompatible
+    # return type. Not much we can do about that. Thankfully mypy picks
+    # the first match so it works out even if we break the rules.
+    @overload
+    def __call__(self, arg: _Markable) -> _Markable:  # type: ignore[misc]
+        pass
+
+    @overload
+    def __call__(self, *args: object, **kwargs: object) -> "MarkDecorator":
+        pass
+
+    def __call__(self, *args: object, **kwargs: object):
+        """Call the MarkDecorator."""
+        if args and not kwargs:
+            func = args[0]
+            is_class = inspect.isclass(func)
+            if len(args) == 1 and (istestfunc(func) or is_class):
+                store_mark(func, self.mark)
+                return func
+        return self.with_args(*args, **kwargs)
+
+
+def get_unpacked_marks(obj) -> List[Mark]:
+    """Obtain the unpacked marks that are stored on an object."""
+    mark_list = getattr(obj, "pytestmark", [])
+    if not isinstance(mark_list, list):
+        mark_list = [mark_list]
+    return normalize_mark_list(mark_list)
+
+
+def normalize_mark_list(mark_list: Iterable[Union[Mark, MarkDecorator]]) -> List[Mark]:
+    """Normalize marker decorating helpers to mark objects.
+
+    :type List[Union[Mark, Markdecorator]] mark_list:
+    :rtype: List[Mark]
+    """
+    extracted = [
+        getattr(mark, "mark", mark) for mark in mark_list
+    ]  # unpack MarkDecorator
+    for mark in extracted:
+        if not isinstance(mark, Mark):
+            raise TypeError(f"got {mark!r} instead of Mark")
+    return [x for x in extracted if isinstance(x, Mark)]
+
+
+def store_mark(obj, mark: Mark) -> None:
+    """Store a Mark on an object.
+
+    This is used to implement the Mark declarations/decorators correctly.
+    """
+    assert isinstance(mark, Mark), mark
+    # Always reassign name to avoid updating pytestmark in a reference that
+    # was only borrowed.
+    obj.pytestmark = get_unpacked_marks(obj) + [mark]
+
+
+# Typing for builtin pytest marks. This is cheating; it gives builtin marks
+# special privilege, and breaks modularity. But practicality beats purity...
+if TYPE_CHECKING:
+    from _pytest.fixtures import _Scope
+
+    class _SkipMarkDecorator(MarkDecorator):
+        @overload  # type: ignore[override,misc]
+        def __call__(self, arg: _Markable) -> _Markable:
+            ...
+
+        @overload
+        def __call__(self, reason: str = ...) -> "MarkDecorator":
+            ...
+
+    class _SkipifMarkDecorator(MarkDecorator):
+        def __call__(  # type: ignore[override]
+            self,
+            condition: Union[str, bool] = ...,
+            *conditions: Union[str, bool],
+            reason: str = ...,
+        ) -> MarkDecorator:
+            ...
+
+    class _XfailMarkDecorator(MarkDecorator):
+        @overload  # type: ignore[override,misc]
+        def __call__(self, arg: _Markable) -> _Markable:
+            ...
+
+        @overload
+        def __call__(
+            self,
+            condition: Union[str, bool] = ...,
+            *conditions: Union[str, bool],
+            reason: str = ...,
+            run: bool = ...,
+            raises: Union[Type[BaseException], Tuple[Type[BaseException], ...]] = ...,
+            strict: bool = ...,
+        ) -> MarkDecorator:
+            ...
+
+    class _ParametrizeMarkDecorator(MarkDecorator):
+        def __call__(  # type: ignore[override]
+            self,
+            argnames: Union[str, List[str], Tuple[str, ...]],
+            argvalues: Iterable[Union[ParameterSet, Sequence[object], object]],
+            *,
+            indirect: Union[bool, Sequence[str]] = ...,
+            ids: Optional[
+                Union[
+                    Iterable[Union[None, str, float, int, bool]],
+                    Callable[[Any], Optional[object]],
+                ]
+            ] = ...,
+            scope: Optional[_Scope] = ...,
+        ) -> MarkDecorator:
+            ...
+
+    class _UsefixturesMarkDecorator(MarkDecorator):
+        def __call__(  # type: ignore[override]
+            self, *fixtures: str
+        ) -> MarkDecorator:
+            ...
+
+    class _FilterwarningsMarkDecorator(MarkDecorator):
+        def __call__(  # type: ignore[override]
+            self, *filters: str
+        ) -> MarkDecorator:
+            ...
+
+
+@final
+class MarkGenerator:
+    """Factory for :class:`MarkDecorator` objects - exposed as
+    a ``pytest.mark`` singleton instance.
+
+    Example::
+
+         import pytest
+
+         @pytest.mark.slowtest
+         def test_function():
+            pass
+
+    applies a 'slowtest' :class:`Mark` on ``test_function``.
+    """
+
+    _config: Optional[Config] = None
+    _markers: Set[str] = set()
+
+    # See TYPE_CHECKING above.
+    if TYPE_CHECKING:
+        skip: _SkipMarkDecorator
+        skipif: _SkipifMarkDecorator
+        xfail: _XfailMarkDecorator
+        parametrize: _ParametrizeMarkDecorator
+        usefixtures: _UsefixturesMarkDecorator
+        filterwarnings: _FilterwarningsMarkDecorator
+
+    def __getattr__(self, name: str) -> MarkDecorator:
+        if name[0] == "_":
+            raise AttributeError("Marker name must NOT start with underscore")
+
+        if self._config is not None:
+            # We store a set of markers as a performance optimisation - if a mark
+            # name is in the set we definitely know it, but a mark may be known and
+            # not in the set.  We therefore start by updating the set!
+            if name not in self._markers:
+                for line in self._config.getini("markers"):
+                    # example lines: "skipif(condition): skip the given test if..."
+                    # or "hypothesis: tests which use Hypothesis", so to get the
+                    # marker name we split on both `:` and `(`.
+                    marker = line.split(":")[0].split("(")[0].strip()
+                    self._markers.add(marker)
+
+            # If the name is not in the set of known marks after updating,
+            # then it really is time to issue a warning or an error.
+            if name not in self._markers:
+                if self._config.option.strict_markers or self._config.option.strict:
+                    fail(
+                        f"{name!r} not found in `markers` configuration option",
+                        pytrace=False,
+                    )
+
+                # Raise a specific error for common misspellings of "parametrize".
+                if name in ["parameterize", "parametrise", "parameterise"]:
+                    __tracebackhide__ = True
+                    fail(f"Unknown '{name}' mark, did you mean 'parametrize'?")
+
+                warnings.warn(
+                    "Unknown pytest.mark.%s - is this a typo?  You can register "
+                    "custom marks to avoid this warning - for details, see "
+                    "https://docs.pytest.org/en/stable/mark.html" % name,
+                    PytestUnknownMarkWarning,
+                    2,
+                )
+
+        return MarkDecorator(Mark(name, (), {}))
+
+
+MARK_GEN = MarkGenerator()
+
+
+@final
+class NodeKeywords(MutableMapping[str, Any]):
+    def __init__(self, node: "Node") -> None:
+        self.node = node
+        self.parent = node.parent
+        self._markers = {node.name: True}
+
+    def __getitem__(self, key: str) -> Any:
+        try:
+            return self._markers[key]
+        except KeyError:
+            if self.parent is None:
+                raise
+            return self.parent.keywords[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self._markers[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        raise ValueError("cannot delete key in keywords dict")
+
+    def __iter__(self) -> Iterator[str]:
+        seen = self._seen()
+        return iter(seen)
+
+    def _seen(self) -> Set[str]:
+        seen = set(self._markers)
+        if self.parent is not None:
+            seen.update(self.parent.keywords)
+        return seen
+
+    def __len__(self) -> int:
+        return len(self._seen())
+
+    def __repr__(self) -> str:
+        return f"<NodeKeywords for node {self.node}>"
diff --git a/myenv/lib/python3.9/site-packages/_pytest/monkeypatch.py b/myenv/lib/python3.9/site-packages/_pytest/monkeypatch.py
new file mode 100644
index 0000000..a052f69
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/monkeypatch.py
@@ -0,0 +1,379 @@
+"""Monkeypatching and mocking functionality."""
+import os
+import re
+import sys
+import warnings
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any
+from typing import Generator
+from typing import List
+from typing import MutableMapping
+from typing import Optional
+from typing import overload
+from typing import Tuple
+from typing import TypeVar
+from typing import Union
+
+from _pytest.compat import final
+from _pytest.fixtures import fixture
+from _pytest.warning_types import PytestWarning
+
+RE_IMPORT_ERROR_NAME = re.compile(r"^No module named (.*)$")
+
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+@fixture
+def monkeypatch() -> Generator["MonkeyPatch", None, None]:
+    """A convenient fixture for monkey-patching.
+
+    The fixture provides these methods to modify objects, dictionaries or
+    os.environ::
+
+        monkeypatch.setattr(obj, name, value, raising=True)
+        monkeypatch.delattr(obj, name, raising=True)
+        monkeypatch.setitem(mapping, name, value)
+        monkeypatch.delitem(obj, name, raising=True)
+        monkeypatch.setenv(name, value, prepend=False)
+        monkeypatch.delenv(name, raising=True)
+        monkeypatch.syspath_prepend(path)
+        monkeypatch.chdir(path)
+
+    All modifications will be undone after the requesting test function or
+    fixture has finished. The ``raising`` parameter determines if a KeyError
+    or AttributeError will be raised if the set/deletion operation has no target.
+    """
+    mpatch = MonkeyPatch()
+    yield mpatch
+    mpatch.undo()
+
+
+def resolve(name: str) -> object:
+    # Simplified from zope.dottedname.
+    parts = name.split(".")
+
+    used = parts.pop(0)
+    found = __import__(used)
+    for part in parts:
+        used += "." + part
+        try:
+            found = getattr(found, part)
+        except AttributeError:
+            pass
+        else:
+            continue
+        # We use explicit un-nesting of the handling block in order
+        # to avoid nested exceptions.
+        try:
+            __import__(used)
+        except ImportError as ex:
+            expected = str(ex).split()[-1]
+            if expected == used:
+                raise
+            else:
+                raise ImportError(f"import error in {used}: {ex}") from ex
+        found = annotated_getattr(found, part, used)
+    return found
+
+
+def annotated_getattr(obj: object, name: str, ann: str) -> object:
+    try:
+        obj = getattr(obj, name)
+    except AttributeError as e:
+        raise AttributeError(
+            "{!r} object at {} has no attribute {!r}".format(
+                type(obj).__name__, ann, name
+            )
+        ) from e
+    return obj
+
+
+def derive_importpath(import_path: str, raising: bool) -> Tuple[str, object]:
+    if not isinstance(import_path, str) or "." not in import_path:  # type: ignore[unreachable]
+        raise TypeError(f"must be absolute import path string, not {import_path!r}")
+    module, attr = import_path.rsplit(".", 1)
+    target = resolve(module)
+    if raising:
+        annotated_getattr(target, attr, ann=module)
+    return attr, target
+
+
+class Notset:
+    def __repr__(self) -> str:
+        return "<notset>"
+
+
+notset = Notset()
+
+
+@final
+class MonkeyPatch:
+    """Helper to conveniently monkeypatch attributes/items/environment
+    variables/syspath.
+
+    Returned by the :fixture:`monkeypatch` fixture.
+
+    :versionchanged:: 6.2
+        Can now also be used directly as `pytest.MonkeyPatch()`, for when
+        the fixture is not available. In this case, use
+        :meth:`with MonkeyPatch.context() as mp: <context>` or remember to call
+        :meth:`undo` explicitly.
+    """
+
+    def __init__(self) -> None:
+        self._setattr: List[Tuple[object, str, object]] = []
+        self._setitem: List[Tuple[MutableMapping[Any, Any], object, object]] = ([])
+        self._cwd: Optional[str] = None
+        self._savesyspath: Optional[List[str]] = None
+
+    @classmethod
+    @contextmanager
+    def context(cls) -> Generator["MonkeyPatch", None, None]:
+        """Context manager that returns a new :class:`MonkeyPatch` object
+        which undoes any patching done inside the ``with`` block upon exit.
+
+        Example:
+
+        .. code-block:: python
+
+            import functools
+
+
+            def test_partial(monkeypatch):
+                with monkeypatch.context() as m:
+                    m.setattr(functools, "partial", 3)
+
+        Useful in situations where it is desired to undo some patches before the test ends,
+        such as mocking ``stdlib`` functions that might break pytest itself if mocked (for examples
+        of this see `#3290 <https://github.com/pytest-dev/pytest/issues/3290>`_.
+        """
+        m = cls()
+        try:
+            yield m
+        finally:
+            m.undo()
+
+    @overload
+    def setattr(
+        self, target: str, name: object, value: Notset = ..., raising: bool = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def setattr(
+        self, target: object, name: str, value: object, raising: bool = ...,
+    ) -> None:
+        ...
+
+    def setattr(
+        self,
+        target: Union[str, object],
+        name: Union[object, str],
+        value: object = notset,
+        raising: bool = True,
+    ) -> None:
+        """Set attribute value on target, memorizing the old value.
+
+        For convenience you can specify a string as ``target`` which
+        will be interpreted as a dotted import path, with the last part
+        being the attribute name. For example,
+        ``monkeypatch.setattr("os.getcwd", lambda: "/")``
+        would set the ``getcwd`` function of the ``os`` module.
+
+        Raises AttributeError if the attribute does not exist, unless
+        ``raising`` is set to False.
+        """
+        __tracebackhide__ = True
+        import inspect
+
+        if isinstance(value, Notset):
+            if not isinstance(target, str):
+                raise TypeError(
+                    "use setattr(target, name, value) or "
+                    "setattr(target, value) with target being a dotted "
+                    "import string"
+                )
+            value = name
+            name, target = derive_importpath(target, raising)
+        else:
+            if not isinstance(name, str):
+                raise TypeError(
+                    "use setattr(target, name, value) with name being a string or "
+                    "setattr(target, value) with target being a dotted "
+                    "import string"
+                )
+
+        oldval = getattr(target, name, notset)
+        if raising and oldval is notset:
+            raise AttributeError(f"{target!r} has no attribute {name!r}")
+
+        # avoid class descriptors like staticmethod/classmethod
+        if inspect.isclass(target):
+            oldval = target.__dict__.get(name, notset)
+        self._setattr.append((target, name, oldval))
+        setattr(target, name, value)
+
+    def delattr(
+        self,
+        target: Union[object, str],
+        name: Union[str, Notset] = notset,
+        raising: bool = True,
+    ) -> None:
+        """Delete attribute ``name`` from ``target``.
+
+        If no ``name`` is specified and ``target`` is a string
+        it will be interpreted as a dotted import path with the
+        last part being the attribute name.
+
+        Raises AttributeError it the attribute does not exist, unless
+        ``raising`` is set to False.
+        """
+        __tracebackhide__ = True
+        import inspect
+
+        if isinstance(name, Notset):
+            if not isinstance(target, str):
+                raise TypeError(
+                    "use delattr(target, name) or "
+                    "delattr(target) with target being a dotted "
+                    "import string"
+                )
+            name, target = derive_importpath(target, raising)
+
+        if not hasattr(target, name):
+            if raising:
+                raise AttributeError(name)
+        else:
+            oldval = getattr(target, name, notset)
+            # Avoid class descriptors like staticmethod/classmethod.
+            if inspect.isclass(target):
+                oldval = target.__dict__.get(name, notset)
+            self._setattr.append((target, name, oldval))
+            delattr(target, name)
+
+    def setitem(self, dic: MutableMapping[K, V], name: K, value: V) -> None:
+        """Set dictionary entry ``name`` to value."""
+        self._setitem.append((dic, name, dic.get(name, notset)))
+        dic[name] = value
+
+    def delitem(self, dic: MutableMapping[K, V], name: K, raising: bool = True) -> None:
+        """Delete ``name`` from dict.
+
+        Raises ``KeyError`` if it doesn't exist, unless ``raising`` is set to
+        False.
+        """
+        if name not in dic:
+            if raising:
+                raise KeyError(name)
+        else:
+            self._setitem.append((dic, name, dic.get(name, notset)))
+            del dic[name]
+
+    def setenv(self, name: str, value: str, prepend: Optional[str] = None) -> None:
+        """Set environment variable ``name`` to ``value``.
+
+        If ``prepend`` is a character, read the current environment variable
+        value and prepend the ``value`` adjoined with the ``prepend``
+        character.
+        """
+        if not isinstance(value, str):
+            warnings.warn(  # type: ignore[unreachable]
+                PytestWarning(
+                    "Value of environment variable {name} type should be str, but got "
+                    "{value!r} (type: {type}); converted to str implicitly".format(
+                        name=name, value=value, type=type(value).__name__
+                    )
+                ),
+                stacklevel=2,
+            )
+            value = str(value)
+        if prepend and name in os.environ:
+            value = value + prepend + os.environ[name]
+        self.setitem(os.environ, name, value)
+
+    def delenv(self, name: str, raising: bool = True) -> None:
+        """Delete ``name`` from the environment.
+
+        Raises ``KeyError`` if it does not exist, unless ``raising`` is set to
+        False.
+        """
+        environ: MutableMapping[str, str] = os.environ
+        self.delitem(environ, name, raising=raising)
+
+    def syspath_prepend(self, path) -> None:
+        """Prepend ``path`` to ``sys.path`` list of import locations."""
+        from pkg_resources import fixup_namespace_packages
+
+        if self._savesyspath is None:
+            self._savesyspath = sys.path[:]
+        sys.path.insert(0, str(path))
+
+        # https://github.com/pypa/setuptools/blob/d8b901bc/docs/pkg_resources.txt#L162-L171
+        fixup_namespace_packages(str(path))
+
+        # A call to syspathinsert() usually means that the caller wants to
+        # import some dynamically created files, thus with python3 we
+        # invalidate its import caches.
+        # This is especially important when any namespace package is in use,
+        # since then the mtime based FileFinder cache (that gets created in
+        # this case already) gets not invalidated when writing the new files
+        # quickly afterwards.
+        from importlib import invalidate_caches
+
+        invalidate_caches()
+
+    def chdir(self, path) -> None:
+        """Change the current working directory to the specified path.
+
+        Path can be a string or a py.path.local object.
+        """
+        if self._cwd is None:
+            self._cwd = os.getcwd()
+        if hasattr(path, "chdir"):
+            path.chdir()
+        elif isinstance(path, Path):
+            # Modern python uses the fspath protocol here LEGACY
+            os.chdir(str(path))
+        else:
+            os.chdir(path)
+
+    def undo(self) -> None:
+        """Undo previous changes.
+
+        This call consumes the undo stack. Calling it a second time has no
+        effect unless you do more monkeypatching after the undo call.
+
+        There is generally no need to call `undo()`, since it is
+        called automatically during tear-down.
+
+        Note that the same `monkeypatch` fixture is used across a
+        single test function invocation. If `monkeypatch` is used both by
+        the test function itself and one of the test fixtures,
+        calling `undo()` will undo all of the changes made in
+        both functions.
+        """
+        for obj, name, value in reversed(self._setattr):
+            if value is not notset:
+                setattr(obj, name, value)
+            else:
+                delattr(obj, name)
+        self._setattr[:] = []
+        for dictionary, key, value in reversed(self._setitem):
+            if value is notset:
+                try:
+                    del dictionary[key]
+                except KeyError:
+                    pass  # Was already deleted, so we have the desired state.
+            else:
+                dictionary[key] = value
+        self._setitem[:] = []
+        if self._savesyspath is not None:
+            sys.path[:] = self._savesyspath
+            self._savesyspath = None
+
+        if self._cwd is not None:
+            os.chdir(self._cwd)
+            self._cwd = None
diff --git a/myenv/lib/python3.9/site-packages/_pytest/nodes.py b/myenv/lib/python3.9/site-packages/_pytest/nodes.py
new file mode 100644
index 0000000..27434fb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/nodes.py
@@ -0,0 +1,591 @@
+import os
+import warnings
+from pathlib import Path
+from typing import Callable
+from typing import Iterable
+from typing import Iterator
+from typing import List
+from typing import Optional
+from typing import overload
+from typing import Set
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import TypeVar
+from typing import Union
+
+import py
+
+import _pytest._code
+from _pytest._code import getfslineno
+from _pytest._code.code import ExceptionInfo
+from _pytest._code.code import TerminalRepr
+from _pytest.compat import cached_property
+from _pytest.config import Config
+from _pytest.config import ConftestImportFailure
+from _pytest.deprecated import FSCOLLECTOR_GETHOOKPROXY_ISINITPATH
+from _pytest.mark.structures import Mark
+from _pytest.mark.structures import MarkDecorator
+from _pytest.mark.structures import NodeKeywords
+from _pytest.outcomes import fail
+from _pytest.pathlib import absolutepath
+from _pytest.store import Store
+
+if TYPE_CHECKING:
+    # Imported here due to circular import.
+    from _pytest.main import Session
+    from _pytest._code.code import _TracebackStyle
+
+
+SEP = "/"
+
+tracebackcutdir = py.path.local(_pytest.__file__).dirpath()
+
+
+def iterparentnodeids(nodeid: str) -> Iterator[str]:
+    """Return the parent node IDs of a given node ID, inclusive.
+
+    For the node ID
+
+        "testing/code/test_excinfo.py::TestFormattedExcinfo::test_repr_source"
+
+    the result would be
+
+        ""
+        "testing"
+        "testing/code"
+        "testing/code/test_excinfo.py"
+        "testing/code/test_excinfo.py::TestFormattedExcinfo"
+        "testing/code/test_excinfo.py::TestFormattedExcinfo::test_repr_source"
+
+    Note that :: parts are only considered at the last / component.
+    """
+    pos = 0
+    sep = SEP
+    yield ""
+    while True:
+        at = nodeid.find(sep, pos)
+        if at == -1 and sep == SEP:
+            sep = "::"
+        elif at == -1:
+            if nodeid:
+                yield nodeid
+            break
+        else:
+            if at:
+                yield nodeid[:at]
+            pos = at + len(sep)
+
+
+_NodeType = TypeVar("_NodeType", bound="Node")
+
+
+class NodeMeta(type):
+    def __call__(self, *k, **kw):
+        msg = (
+            "Direct construction of {name} has been deprecated, please use {name}.from_parent.\n"
+            "See "
+            "https://docs.pytest.org/en/stable/deprecations.html#node-construction-changed-to-node-from-parent"
+            " for more details."
+        ).format(name=self.__name__)
+        fail(msg, pytrace=False)
+
+    def _create(self, *k, **kw):
+        return super().__call__(*k, **kw)
+
+
+class Node(metaclass=NodeMeta):
+    """Base class for Collector and Item, the components of the test
+    collection tree.
+
+    Collector subclasses have children; Items are leaf nodes.
+    """
+
+    # Use __slots__ to make attribute access faster.
+    # Note that __dict__ is still available.
+    __slots__ = (
+        "name",
+        "parent",
+        "config",
+        "session",
+        "fspath",
+        "_nodeid",
+        "_store",
+        "__dict__",
+    )
+
+    def __init__(
+        self,
+        name: str,
+        parent: "Optional[Node]" = None,
+        config: Optional[Config] = None,
+        session: "Optional[Session]" = None,
+        fspath: Optional[py.path.local] = None,
+        nodeid: Optional[str] = None,
+    ) -> None:
+        #: A unique name within the scope of the parent node.
+        self.name = name
+
+        #: The parent collector node.
+        self.parent = parent
+
+        #: The pytest config object.
+        if config:
+            self.config: Config = config
+        else:
+            if not parent:
+                raise TypeError("config or parent must be provided")
+            self.config = parent.config
+
+        #: The pytest session this node is part of.
+        if session:
+            self.session = session
+        else:
+            if not parent:
+                raise TypeError("session or parent must be provided")
+            self.session = parent.session
+
+        #: Filesystem path where this node was collected from (can be None).
+        self.fspath = fspath or getattr(parent, "fspath", None)
+
+        #: Keywords/markers collected from all scopes.
+        self.keywords = NodeKeywords(self)
+
+        #: The marker objects belonging to this node.
+        self.own_markers: List[Mark] = []
+
+        #: Allow adding of extra keywords to use for matching.
+        self.extra_keyword_matches: Set[str] = set()
+
+        if nodeid is not None:
+            assert "::()" not in nodeid
+            self._nodeid = nodeid
+        else:
+            if not self.parent:
+                raise TypeError("nodeid or parent must be provided")
+            self._nodeid = self.parent.nodeid
+            if self.name != "()":
+                self._nodeid += "::" + self.name
+
+        # A place where plugins can store information on the node for their
+        # own use. Currently only intended for internal plugins.
+        self._store = Store()
+
+    @classmethod
+    def from_parent(cls, parent: "Node", **kw):
+        """Public constructor for Nodes.
+
+        This indirection got introduced in order to enable removing
+        the fragile logic from the node constructors.
+
+        Subclasses can use ``super().from_parent(...)`` when overriding the
+        construction.
+
+        :param parent: The parent node of this Node.
+        """
+        if "config" in kw:
+            raise TypeError("config is not a valid argument for from_parent")
+        if "session" in kw:
+            raise TypeError("session is not a valid argument for from_parent")
+        return cls._create(parent=parent, **kw)
+
+    @property
+    def ihook(self):
+        """fspath-sensitive hook proxy used to call pytest hooks."""
+        return self.session.gethookproxy(self.fspath)
+
+    def __repr__(self) -> str:
+        return "<{} {}>".format(self.__class__.__name__, getattr(self, "name", None))
+
+    def warn(self, warning: Warning) -> None:
+        """Issue a warning for this Node.
+
+        Warnings will be displayed after the test session, unless explicitly suppressed.
+
+        :param Warning warning:
+            The warning instance to issue.
+
+        :raises ValueError: If ``warning`` instance is not a subclass of Warning.
+
+        Example usage:
+
+        .. code-block:: python
+
+            node.warn(PytestWarning("some message"))
+            node.warn(UserWarning("some message"))
+
+        .. versionchanged:: 6.2
+            Any subclass of :class:`Warning` is now accepted, rather than only
+            :class:`PytestWarning <pytest.PytestWarning>` subclasses.
+        """
+        # enforce type checks here to avoid getting a generic type error later otherwise.
+        if not isinstance(warning, Warning):
+            raise ValueError(
+                "warning must be an instance of Warning or subclass, got {!r}".format(
+                    warning
+                )
+            )
+        path, lineno = get_fslocation_from_item(self)
+        assert lineno is not None
+        warnings.warn_explicit(
+            warning, category=None, filename=str(path), lineno=lineno + 1,
+        )
+
+    # Methods for ordering nodes.
+
+    @property
+    def nodeid(self) -> str:
+        """A ::-separated string denoting its collection tree address."""
+        return self._nodeid
+
+    def __hash__(self) -> int:
+        return hash(self._nodeid)
+
+    def setup(self) -> None:
+        pass
+
+    def teardown(self) -> None:
+        pass
+
+    def listchain(self) -> List["Node"]:
+        """Return list of all parent collectors up to self, starting from
+        the root of collection tree."""
+        chain = []
+        item: Optional[Node] = self
+        while item is not None:
+            chain.append(item)
+            item = item.parent
+        chain.reverse()
+        return chain
+
+    def add_marker(
+        self, marker: Union[str, MarkDecorator], append: bool = True
+    ) -> None:
+        """Dynamically add a marker object to the node.
+
+        :param append:
+            Whether to append the marker, or prepend it.
+        """
+        from _pytest.mark import MARK_GEN
+
+        if isinstance(marker, MarkDecorator):
+            marker_ = marker
+        elif isinstance(marker, str):
+            marker_ = getattr(MARK_GEN, marker)
+        else:
+            raise ValueError("is not a string or pytest.mark.* Marker")
+        self.keywords[marker_.name] = marker_
+        if append:
+            self.own_markers.append(marker_.mark)
+        else:
+            self.own_markers.insert(0, marker_.mark)
+
+    def iter_markers(self, name: Optional[str] = None) -> Iterator[Mark]:
+        """Iterate over all markers of the node.
+
+        :param name: If given, filter the results by the name attribute.
+        """
+        return (x[1] for x in self.iter_markers_with_node(name=name))
+
+    def iter_markers_with_node(
+        self, name: Optional[str] = None
+    ) -> Iterator[Tuple["Node", Mark]]:
+        """Iterate over all markers of the node.
+
+        :param name: If given, filter the results by the name attribute.
+        :returns: An iterator of (node, mark) tuples.
+        """
+        for node in reversed(self.listchain()):
+            for mark in node.own_markers:
+                if name is None or getattr(mark, "name", None) == name:
+                    yield node, mark
+
+    @overload
+    def get_closest_marker(self, name: str) -> Optional[Mark]:
+        ...
+
+    @overload
+    def get_closest_marker(self, name: str, default: Mark) -> Mark:
+        ...
+
+    def get_closest_marker(
+        self, name: str, default: Optional[Mark] = None
+    ) -> Optional[Mark]:
+        """Return the first marker matching the name, from closest (for
+        example function) to farther level (for example module level).
+
+        :param default: Fallback return value if no marker was found.
+        :param name: Name to filter by.
+        """
+        return next(self.iter_markers(name=name), default)
+
+    def listextrakeywords(self) -> Set[str]:
+        """Return a set of all extra keywords in self and any parents."""
+        extra_keywords: Set[str] = set()
+        for item in self.listchain():
+            extra_keywords.update(item.extra_keyword_matches)
+        return extra_keywords
+
+    def listnames(self) -> List[str]:
+        return [x.name for x in self.listchain()]
+
+    def addfinalizer(self, fin: Callable[[], object]) -> None:
+        """Register a function to be called when this node is finalized.
+
+        This method can only be called when this node is active
+        in a setup chain, for example during self.setup().
+        """
+        self.session._setupstate.addfinalizer(fin, self)
+
+    def getparent(self, cls: Type[_NodeType]) -> Optional[_NodeType]:
+        """Get the next parent node (including self) which is an instance of
+        the given class."""
+        current: Optional[Node] = self
+        while current and not isinstance(current, cls):
+            current = current.parent
+        assert current is None or isinstance(current, cls)
+        return current
+
+    def _prunetraceback(self, excinfo: ExceptionInfo[BaseException]) -> None:
+        pass
+
+    def _repr_failure_py(
+        self,
+        excinfo: ExceptionInfo[BaseException],
+        style: "Optional[_TracebackStyle]" = None,
+    ) -> TerminalRepr:
+        from _pytest.fixtures import FixtureLookupError
+
+        if isinstance(excinfo.value, ConftestImportFailure):
+            excinfo = ExceptionInfo(excinfo.value.excinfo)
+        if isinstance(excinfo.value, fail.Exception):
+            if not excinfo.value.pytrace:
+                style = "value"
+        if isinstance(excinfo.value, FixtureLookupError):
+            return excinfo.value.formatrepr()
+        if self.config.getoption("fulltrace", False):
+            style = "long"
+        else:
+            tb = _pytest._code.Traceback([excinfo.traceback[-1]])
+            self._prunetraceback(excinfo)
+            if len(excinfo.traceback) == 0:
+                excinfo.traceback = tb
+            if style == "auto":
+                style = "long"
+        # XXX should excinfo.getrepr record all data and toterminal() process it?
+        if style is None:
+            if self.config.getoption("tbstyle", "auto") == "short":
+                style = "short"
+            else:
+                style = "long"
+
+        if self.config.getoption("verbose", 0) > 1:
+            truncate_locals = False
+        else:
+            truncate_locals = True
+
+        # excinfo.getrepr() formats paths relative to the CWD if `abspath` is False.
+        # It is possible for a fixture/test to change the CWD while this code runs, which
+        # would then result in the user seeing confusing paths in the failure message.
+        # To fix this, if the CWD changed, always display the full absolute path.
+        # It will be better to just always display paths relative to invocation_dir, but
+        # this requires a lot of plumbing (#6428).
+        try:
+            abspath = Path(os.getcwd()) != self.config.invocation_params.dir
+        except OSError:
+            abspath = True
+
+        return excinfo.getrepr(
+            funcargs=True,
+            abspath=abspath,
+            showlocals=self.config.getoption("showlocals", False),
+            style=style,
+            tbfilter=False,  # pruned already, or in --fulltrace mode.
+            truncate_locals=truncate_locals,
+        )
+
+    def repr_failure(
+        self,
+        excinfo: ExceptionInfo[BaseException],
+        style: "Optional[_TracebackStyle]" = None,
+    ) -> Union[str, TerminalRepr]:
+        """Return a representation of a collection or test failure.
+
+        :param excinfo: Exception information for the failure.
+        """
+        return self._repr_failure_py(excinfo, style)
+
+
+def get_fslocation_from_item(
+    node: "Node",
+) -> Tuple[Union[str, py.path.local], Optional[int]]:
+    """Try to extract the actual location from a node, depending on available attributes:
+
+    * "location": a pair (path, lineno)
+    * "obj": a Python object that the node wraps.
+    * "fspath": just a path
+
+    :rtype: A tuple of (str|py.path.local, int) with filename and line number.
+    """
+    # See Item.location.
+    location: Optional[Tuple[str, Optional[int], str]] = getattr(node, "location", None)
+    if location is not None:
+        return location[:2]
+    obj = getattr(node, "obj", None)
+    if obj is not None:
+        return getfslineno(obj)
+    return getattr(node, "fspath", "unknown location"), -1
+
+
+class Collector(Node):
+    """Collector instances create children through collect() and thus
+    iteratively build a tree."""
+
+    class CollectError(Exception):
+        """An error during collection, contains a custom message."""
+
+    def collect(self) -> Iterable[Union["Item", "Collector"]]:
+        """Return a list of children (items and collectors) for this
+        collection node."""
+        raise NotImplementedError("abstract")
+
+    # TODO: This omits the style= parameter which breaks Liskov Substitution.
+    def repr_failure(  # type: ignore[override]
+        self, excinfo: ExceptionInfo[BaseException]
+    ) -> Union[str, TerminalRepr]:
+        """Return a representation of a collection failure.
+
+        :param excinfo: Exception information for the failure.
+        """
+        if isinstance(excinfo.value, self.CollectError) and not self.config.getoption(
+            "fulltrace", False
+        ):
+            exc = excinfo.value
+            return str(exc.args[0])
+
+        # Respect explicit tbstyle option, but default to "short"
+        # (_repr_failure_py uses "long" with "fulltrace" option always).
+        tbstyle = self.config.getoption("tbstyle", "auto")
+        if tbstyle == "auto":
+            tbstyle = "short"
+
+        return self._repr_failure_py(excinfo, style=tbstyle)
+
+    def _prunetraceback(self, excinfo: ExceptionInfo[BaseException]) -> None:
+        if hasattr(self, "fspath"):
+            traceback = excinfo.traceback
+            ntraceback = traceback.cut(path=self.fspath)
+            if ntraceback == traceback:
+                ntraceback = ntraceback.cut(excludepath=tracebackcutdir)
+            excinfo.traceback = ntraceback.filter()
+
+
+def _check_initialpaths_for_relpath(session, fspath):
+    for initial_path in session._initialpaths:
+        if fspath.common(initial_path) == initial_path:
+            return fspath.relto(initial_path)
+
+
+class FSCollector(Collector):
+    def __init__(
+        self,
+        fspath: py.path.local,
+        parent=None,
+        config: Optional[Config] = None,
+        session: Optional["Session"] = None,
+        nodeid: Optional[str] = None,
+    ) -> None:
+        name = fspath.basename
+        if parent is not None:
+            rel = fspath.relto(parent.fspath)
+            if rel:
+                name = rel
+            name = name.replace(os.sep, SEP)
+        self.fspath = fspath
+
+        session = session or parent.session
+
+        if nodeid is None:
+            nodeid = self.fspath.relto(session.config.rootdir)
+
+            if not nodeid:
+                nodeid = _check_initialpaths_for_relpath(session, fspath)
+            if nodeid and os.sep != SEP:
+                nodeid = nodeid.replace(os.sep, SEP)
+
+        super().__init__(name, parent, config, session, nodeid=nodeid, fspath=fspath)
+
+    @classmethod
+    def from_parent(cls, parent, *, fspath, **kw):
+        """The public constructor."""
+        return super().from_parent(parent=parent, fspath=fspath, **kw)
+
+    def gethookproxy(self, fspath: py.path.local):
+        warnings.warn(FSCOLLECTOR_GETHOOKPROXY_ISINITPATH, stacklevel=2)
+        return self.session.gethookproxy(fspath)
+
+    def isinitpath(self, path: py.path.local) -> bool:
+        warnings.warn(FSCOLLECTOR_GETHOOKPROXY_ISINITPATH, stacklevel=2)
+        return self.session.isinitpath(path)
+
+
+class File(FSCollector):
+    """Base class for collecting tests from a file.
+
+    :ref:`non-python tests`.
+    """
+
+
+class Item(Node):
+    """A basic test invocation item.
+
+    Note that for a single function there might be multiple test invocation items.
+    """
+
+    nextitem = None
+
+    def __init__(
+        self,
+        name,
+        parent=None,
+        config: Optional[Config] = None,
+        session: Optional["Session"] = None,
+        nodeid: Optional[str] = None,
+    ) -> None:
+        super().__init__(name, parent, config, session, nodeid=nodeid)
+        self._report_sections: List[Tuple[str, str, str]] = []
+
+        #: A list of tuples (name, value) that holds user defined properties
+        #: for this test.
+        self.user_properties: List[Tuple[str, object]] = []
+
+    def runtest(self) -> None:
+        raise NotImplementedError("runtest must be implemented by Item subclass")
+
+    def add_report_section(self, when: str, key: str, content: str) -> None:
+        """Add a new report section, similar to what's done internally to add
+        stdout and stderr captured output::
+
+            item.add_report_section("call", "stdout", "report section contents")
+
+        :param str when:
+            One of the possible capture states, ``"setup"``, ``"call"``, ``"teardown"``.
+        :param str key:
+            Name of the section, can be customized at will. Pytest uses ``"stdout"`` and
+            ``"stderr"`` internally.
+        :param str content:
+            The full contents as a string.
+        """
+        if content:
+            self._report_sections.append((when, key, content))
+
+    def reportinfo(self) -> Tuple[Union[py.path.local, str], Optional[int], str]:
+        return self.fspath, None, ""
+
+    @cached_property
+    def location(self) -> Tuple[str, Optional[int], str]:
+        location = self.reportinfo()
+        fspath = absolutepath(str(location[0]))
+        relfspath = self.session._node_location_to_relpath(fspath)
+        assert type(location[2]) is str
+        return (relfspath, location[1], location[2])
diff --git a/myenv/lib/python3.9/site-packages/_pytest/nose.py b/myenv/lib/python3.9/site-packages/_pytest/nose.py
new file mode 100644
index 0000000..bb8f997
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/nose.py
@@ -0,0 +1,39 @@
+"""Run testsuites written for nose."""
+from _pytest import python
+from _pytest import unittest
+from _pytest.config import hookimpl
+from _pytest.nodes import Item
+
+
+@hookimpl(trylast=True)
+def pytest_runtest_setup(item):
+    if is_potential_nosetest(item):
+        if not call_optional(item.obj, "setup"):
+            # Call module level setup if there is no object level one.
+            call_optional(item.parent.obj, "setup")
+        # XXX This implies we only call teardown when setup worked.
+        item.session._setupstate.addfinalizer((lambda: teardown_nose(item)), item)
+
+
+def teardown_nose(item):
+    if is_potential_nosetest(item):
+        if not call_optional(item.obj, "teardown"):
+            call_optional(item.parent.obj, "teardown")
+
+
+def is_potential_nosetest(item: Item) -> bool:
+    # Extra check needed since we do not do nose style setup/teardown
+    # on direct unittest style classes.
+    return isinstance(item, python.Function) and not isinstance(
+        item, unittest.TestCaseFunction
+    )
+
+
+def call_optional(obj, name):
+    method = getattr(obj, name, None)
+    isfixture = hasattr(method, "_pytestfixturefunction")
+    if method is not None and not isfixture and callable(method):
+        # If there's any problems allow the exception to raise rather than
+        # silently ignoring them.
+        method()
+        return True
diff --git a/myenv/lib/python3.9/site-packages/_pytest/outcomes.py b/myenv/lib/python3.9/site-packages/_pytest/outcomes.py
new file mode 100644
index 0000000..8f6203f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/outcomes.py
@@ -0,0 +1,227 @@
+"""Exception classes and constants handling test outcomes as well as
+functions creating them."""
+import sys
+from typing import Any
+from typing import Callable
+from typing import cast
+from typing import Optional
+from typing import Type
+from typing import TypeVar
+
+TYPE_CHECKING = False  # Avoid circular import through compat.
+
+if TYPE_CHECKING:
+    from typing import NoReturn
+    from typing_extensions import Protocol
+else:
+    # typing.Protocol is only available starting from Python 3.8. It is also
+    # available from typing_extensions, but we don't want a runtime dependency
+    # on that. So use a dummy runtime implementation.
+    from typing import Generic
+
+    Protocol = Generic
+
+
+class OutcomeException(BaseException):
+    """OutcomeException and its subclass instances indicate and contain info
+    about test and collection outcomes."""
+
+    def __init__(self, msg: Optional[str] = None, pytrace: bool = True) -> None:
+        if msg is not None and not isinstance(msg, str):
+            error_msg = (  # type: ignore[unreachable]
+                "{} expected string as 'msg' parameter, got '{}' instead.\n"
+                "Perhaps you meant to use a mark?"
+            )
+            raise TypeError(error_msg.format(type(self).__name__, type(msg).__name__))
+        BaseException.__init__(self, msg)
+        self.msg = msg
+        self.pytrace = pytrace
+
+    def __repr__(self) -> str:
+        if self.msg is not None:
+            return self.msg
+        return f"<{self.__class__.__name__} instance>"
+
+    __str__ = __repr__
+
+
+TEST_OUTCOME = (OutcomeException, Exception)
+
+
+class Skipped(OutcomeException):
+    # XXX hackish: on 3k we fake to live in the builtins
+    # in order to have Skipped exception printing shorter/nicer
+    __module__ = "builtins"
+
+    def __init__(
+        self,
+        msg: Optional[str] = None,
+        pytrace: bool = True,
+        allow_module_level: bool = False,
+    ) -> None:
+        OutcomeException.__init__(self, msg=msg, pytrace=pytrace)
+        self.allow_module_level = allow_module_level
+
+
+class Failed(OutcomeException):
+    """Raised from an explicit call to pytest.fail()."""
+
+    __module__ = "builtins"
+
+
+class Exit(Exception):
+    """Raised for immediate program exits (no tracebacks/summaries)."""
+
+    def __init__(
+        self, msg: str = "unknown reason", returncode: Optional[int] = None
+    ) -> None:
+        self.msg = msg
+        self.returncode = returncode
+        super().__init__(msg)
+
+
+# Elaborate hack to work around https://github.com/python/mypy/issues/2087.
+# Ideally would just be `exit.Exception = Exit` etc.
+
+_F = TypeVar("_F", bound=Callable[..., object])
+_ET = TypeVar("_ET", bound=Type[BaseException])
+
+
+class _WithException(Protocol[_F, _ET]):
+    Exception: _ET
+    __call__: _F
+
+
+def _with_exception(exception_type: _ET) -> Callable[[_F], _WithException[_F, _ET]]:
+    def decorate(func: _F) -> _WithException[_F, _ET]:
+        func_with_exception = cast(_WithException[_F, _ET], func)
+        func_with_exception.Exception = exception_type
+        return func_with_exception
+
+    return decorate
+
+
+# Exposed helper methods.
+
+
+@_with_exception(Exit)
+def exit(msg: str, returncode: Optional[int] = None) -> "NoReturn":
+    """Exit testing process.
+
+    :param str msg: Message to display upon exit.
+    :param int returncode: Return code to be used when exiting pytest.
+    """
+    __tracebackhide__ = True
+    raise Exit(msg, returncode)
+
+
+@_with_exception(Skipped)
+def skip(msg: str = "", *, allow_module_level: bool = False) -> "NoReturn":
+    """Skip an executing test with the given message.
+
+    This function should be called only during testing (setup, call or teardown) or
+    during collection by using the ``allow_module_level`` flag.  This function can
+    be called in doctests as well.
+
+    :param bool allow_module_level:
+        Allows this function to be called at module level, skipping the rest
+        of the module. Defaults to False.
+
+    .. note::
+        It is better to use the :ref:`pytest.mark.skipif ref` marker when
+        possible to declare a test to be skipped under certain conditions
+        like mismatching platforms or dependencies.
+        Similarly, use the ``# doctest: +SKIP`` directive (see `doctest.SKIP
+        <https://docs.python.org/3/library/doctest.html#doctest.SKIP>`_)
+        to skip a doctest statically.
+    """
+    __tracebackhide__ = True
+    raise Skipped(msg=msg, allow_module_level=allow_module_level)
+
+
+@_with_exception(Failed)
+def fail(msg: str = "", pytrace: bool = True) -> "NoReturn":
+    """Explicitly fail an executing test with the given message.
+
+    :param str msg:
+        The message to show the user as reason for the failure.
+    :param bool pytrace:
+        If False, msg represents the full failure information and no
+        python traceback will be reported.
+    """
+    __tracebackhide__ = True
+    raise Failed(msg=msg, pytrace=pytrace)
+
+
+class XFailed(Failed):
+    """Raised from an explicit call to pytest.xfail()."""
+
+
+@_with_exception(XFailed)
+def xfail(reason: str = "") -> "NoReturn":
+    """Imperatively xfail an executing test or setup function with the given reason.
+
+    This function should be called only during testing (setup, call or teardown).
+
+    .. note::
+        It is better to use the :ref:`pytest.mark.xfail ref` marker when
+        possible to declare a test to be xfailed under certain conditions
+        like known bugs or missing features.
+    """
+    __tracebackhide__ = True
+    raise XFailed(reason)
+
+
+def importorskip(
+    modname: str, minversion: Optional[str] = None, reason: Optional[str] = None
+) -> Any:
+    """Import and return the requested module ``modname``, or skip the
+    current test if the module cannot be imported.
+
+    :param str modname:
+        The name of the module to import.
+    :param str minversion:
+        If given, the imported module's ``__version__`` attribute must be at
+        least this minimal version, otherwise the test is still skipped.
+    :param str reason:
+        If given, this reason is shown as the message when the module cannot
+        be imported.
+
+    :returns:
+        The imported module. This should be assigned to its canonical name.
+
+    Example::
+
+        docutils = pytest.importorskip("docutils")
+    """
+    import warnings
+
+    __tracebackhide__ = True
+    compile(modname, "", "eval")  # to catch syntaxerrors
+
+    with warnings.catch_warnings():
+        # Make sure to ignore ImportWarnings that might happen because
+        # of existing directories with the same name we're trying to
+        # import but without a __init__.py file.
+        warnings.simplefilter("ignore")
+        try:
+            __import__(modname)
+        except ImportError as exc:
+            if reason is None:
+                reason = f"could not import {modname!r}: {exc}"
+            raise Skipped(reason, allow_module_level=True) from None
+    mod = sys.modules[modname]
+    if minversion is None:
+        return mod
+    verattr = getattr(mod, "__version__", None)
+    if minversion is not None:
+        # Imported lazily to improve start-up time.
+        from packaging.version import Version
+
+        if verattr is None or Version(verattr) < Version(minversion):
+            raise Skipped(
+                "module %r has __version__ %r, required is: %r"
+                % (modname, verattr, minversion),
+                allow_module_level=True,
+            )
+    return mod
diff --git a/myenv/lib/python3.9/site-packages/_pytest/pastebin.py b/myenv/lib/python3.9/site-packages/_pytest/pastebin.py
new file mode 100644
index 0000000..131873c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/pastebin.py
@@ -0,0 +1,110 @@
+"""Submit failure or test session information to a pastebin service."""
+import tempfile
+from io import StringIO
+from typing import IO
+from typing import Union
+
+import pytest
+from _pytest.config import Config
+from _pytest.config import create_terminal_writer
+from _pytest.config.argparsing import Parser
+from _pytest.store import StoreKey
+from _pytest.terminal import TerminalReporter
+
+
+pastebinfile_key = StoreKey[IO[bytes]]()
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("terminal reporting")
+    group._addoption(
+        "--pastebin",
+        metavar="mode",
+        action="store",
+        dest="pastebin",
+        default=None,
+        choices=["failed", "all"],
+        help="send failed|all info to bpaste.net pastebin service.",
+    )
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_configure(config: Config) -> None:
+    if config.option.pastebin == "all":
+        tr = config.pluginmanager.getplugin("terminalreporter")
+        # If no terminal reporter plugin is present, nothing we can do here;
+        # this can happen when this function executes in a worker node
+        # when using pytest-xdist, for example.
+        if tr is not None:
+            # pastebin file will be UTF-8 encoded binary file.
+            config._store[pastebinfile_key] = tempfile.TemporaryFile("w+b")
+            oldwrite = tr._tw.write
+
+            def tee_write(s, **kwargs):
+                oldwrite(s, **kwargs)
+                if isinstance(s, str):
+                    s = s.encode("utf-8")
+                config._store[pastebinfile_key].write(s)
+
+            tr._tw.write = tee_write
+
+
+def pytest_unconfigure(config: Config) -> None:
+    if pastebinfile_key in config._store:
+        pastebinfile = config._store[pastebinfile_key]
+        # Get terminal contents and delete file.
+        pastebinfile.seek(0)
+        sessionlog = pastebinfile.read()
+        pastebinfile.close()
+        del config._store[pastebinfile_key]
+        # Undo our patching in the terminal reporter.
+        tr = config.pluginmanager.getplugin("terminalreporter")
+        del tr._tw.__dict__["write"]
+        # Write summary.
+        tr.write_sep("=", "Sending information to Paste Service")
+        pastebinurl = create_new_paste(sessionlog)
+        tr.write_line("pastebin session-log: %s\n" % pastebinurl)
+
+
+def create_new_paste(contents: Union[str, bytes]) -> str:
+    """Create a new paste using the bpaste.net service.
+
+    :contents: Paste contents string.
+    :returns: URL to the pasted contents, or an error message.
+    """
+    import re
+    from urllib.request import urlopen
+    from urllib.parse import urlencode
+
+    params = {"code": contents, "lexer": "text", "expiry": "1week"}
+    url = "https://bpaste.net"
+    try:
+        response: str = (
+            urlopen(url, data=urlencode(params).encode("ascii")).read().decode("utf-8")
+        )
+    except OSError as exc_info:  # urllib errors
+        return "bad response: %s" % exc_info
+    m = re.search(r'href="/raw/(\w+)"', response)
+    if m:
+        return "{}/show/{}".format(url, m.group(1))
+    else:
+        return "bad response: invalid format ('" + response + "')"
+
+
+def pytest_terminal_summary(terminalreporter: TerminalReporter) -> None:
+    if terminalreporter.config.option.pastebin != "failed":
+        return
+    if "failed" in terminalreporter.stats:
+        terminalreporter.write_sep("=", "Sending information to Paste Service")
+        for rep in terminalreporter.stats["failed"]:
+            try:
+                msg = rep.longrepr.reprtraceback.reprentries[-1].reprfileloc
+            except AttributeError:
+                msg = terminalreporter._getfailureheadline(rep)
+            file = StringIO()
+            tw = create_terminal_writer(terminalreporter.config, file)
+            rep.toterminal(tw)
+            s = file.getvalue()
+            assert len(s)
+            pastebinurl = create_new_paste(s)
+            terminalreporter.write_line(f"{msg} --> {pastebinurl}")
diff --git a/myenv/lib/python3.9/site-packages/_pytest/pathlib.py b/myenv/lib/python3.9/site-packages/_pytest/pathlib.py
new file mode 100644
index 0000000..7d9269a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/pathlib.py
@@ -0,0 +1,654 @@
+import atexit
+import contextlib
+import fnmatch
+import importlib.util
+import itertools
+import os
+import shutil
+import sys
+import uuid
+import warnings
+from enum import Enum
+from errno import EBADF
+from errno import ELOOP
+from errno import ENOENT
+from errno import ENOTDIR
+from functools import partial
+from os.path import expanduser
+from os.path import expandvars
+from os.path import isabs
+from os.path import sep
+from pathlib import Path
+from pathlib import PurePath
+from posixpath import sep as posix_sep
+from types import ModuleType
+from typing import Callable
+from typing import Iterable
+from typing import Iterator
+from typing import Optional
+from typing import Set
+from typing import TypeVar
+from typing import Union
+
+import py
+
+from _pytest.compat import assert_never
+from _pytest.outcomes import skip
+from _pytest.warning_types import PytestWarning
+
+LOCK_TIMEOUT = 60 * 60 * 24 * 3
+
+
+_AnyPurePath = TypeVar("_AnyPurePath", bound=PurePath)
+
+# The following function, variables and comments were
+# copied from cpython 3.9 Lib/pathlib.py file.
+
+# EBADF - guard against macOS `stat` throwing EBADF
+_IGNORED_ERRORS = (ENOENT, ENOTDIR, EBADF, ELOOP)
+
+_IGNORED_WINERRORS = (
+    21,  # ERROR_NOT_READY - drive exists but is not accessible
+    1921,  # ERROR_CANT_RESOLVE_FILENAME - fix for broken symlink pointing to itself
+)
+
+
+def _ignore_error(exception):
+    return (
+        getattr(exception, "errno", None) in _IGNORED_ERRORS
+        or getattr(exception, "winerror", None) in _IGNORED_WINERRORS
+    )
+
+
+def get_lock_path(path: _AnyPurePath) -> _AnyPurePath:
+    return path.joinpath(".lock")
+
+
+def on_rm_rf_error(func, path: str, exc, *, start_path: Path) -> bool:
+    """Handle known read-only errors during rmtree.
+
+    The returned value is used only by our own tests.
+    """
+    exctype, excvalue = exc[:2]
+
+    # Another process removed the file in the middle of the "rm_rf" (xdist for example).
+    # More context: https://github.com/pytest-dev/pytest/issues/5974#issuecomment-543799018
+    if isinstance(excvalue, FileNotFoundError):
+        return False
+
+    if not isinstance(excvalue, PermissionError):
+        warnings.warn(
+            PytestWarning(f"(rm_rf) error removing {path}\n{exctype}: {excvalue}")
+        )
+        return False
+
+    if func not in (os.rmdir, os.remove, os.unlink):
+        if func not in (os.open,):
+            warnings.warn(
+                PytestWarning(
+                    "(rm_rf) unknown function {} when removing {}:\n{}: {}".format(
+                        func, path, exctype, excvalue
+                    )
+                )
+            )
+        return False
+
+    # Chmod + retry.
+    import stat
+
+    def chmod_rw(p: str) -> None:
+        mode = os.stat(p).st_mode
+        os.chmod(p, mode | stat.S_IRUSR | stat.S_IWUSR)
+
+    # For files, we need to recursively go upwards in the directories to
+    # ensure they all are also writable.
+    p = Path(path)
+    if p.is_file():
+        for parent in p.parents:
+            chmod_rw(str(parent))
+            # Stop when we reach the original path passed to rm_rf.
+            if parent == start_path:
+                break
+    chmod_rw(str(path))
+
+    func(path)
+    return True
+
+
+def ensure_extended_length_path(path: Path) -> Path:
+    """Get the extended-length version of a path (Windows).
+
+    On Windows, by default, the maximum length of a path (MAX_PATH) is 260
+    characters, and operations on paths longer than that fail. But it is possible
+    to overcome this by converting the path to "extended-length" form before
+    performing the operation:
+    https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file#maximum-path-length-limitation
+
+    On Windows, this function returns the extended-length absolute version of path.
+    On other platforms it returns path unchanged.
+    """
+    if sys.platform.startswith("win32"):
+        path = path.resolve()
+        path = Path(get_extended_length_path_str(str(path)))
+    return path
+
+
+def get_extended_length_path_str(path: str) -> str:
+    """Convert a path to a Windows extended length path."""
+    long_path_prefix = "\\\\?\\"
+    unc_long_path_prefix = "\\\\?\\UNC\\"
+    if path.startswith((long_path_prefix, unc_long_path_prefix)):
+        return path
+    # UNC
+    if path.startswith("\\\\"):
+        return unc_long_path_prefix + path[2:]
+    return long_path_prefix + path
+
+
+def rm_rf(path: Path) -> None:
+    """Remove the path contents recursively, even if some elements
+    are read-only."""
+    path = ensure_extended_length_path(path)
+    onerror = partial(on_rm_rf_error, start_path=path)
+    shutil.rmtree(str(path), onerror=onerror)
+
+
+def find_prefixed(root: Path, prefix: str) -> Iterator[Path]:
+    """Find all elements in root that begin with the prefix, case insensitive."""
+    l_prefix = prefix.lower()
+    for x in root.iterdir():
+        if x.name.lower().startswith(l_prefix):
+            yield x
+
+
+def extract_suffixes(iter: Iterable[PurePath], prefix: str) -> Iterator[str]:
+    """Return the parts of the paths following the prefix.
+
+    :param iter: Iterator over path names.
+    :param prefix: Expected prefix of the path names.
+    """
+    p_len = len(prefix)
+    for p in iter:
+        yield p.name[p_len:]
+
+
+def find_suffixes(root: Path, prefix: str) -> Iterator[str]:
+    """Combine find_prefixes and extract_suffixes."""
+    return extract_suffixes(find_prefixed(root, prefix), prefix)
+
+
+def parse_num(maybe_num) -> int:
+    """Parse number path suffixes, returns -1 on error."""
+    try:
+        return int(maybe_num)
+    except ValueError:
+        return -1
+
+
+def _force_symlink(
+    root: Path, target: Union[str, PurePath], link_to: Union[str, Path]
+) -> None:
+    """Helper to create the current symlink.
+
+    It's full of race conditions that are reasonably OK to ignore
+    for the context of best effort linking to the latest test run.
+
+    The presumption being that in case of much parallelism
+    the inaccuracy is going to be acceptable.
+    """
+    current_symlink = root.joinpath(target)
+    try:
+        current_symlink.unlink()
+    except OSError:
+        pass
+    try:
+        current_symlink.symlink_to(link_to)
+    except Exception:
+        pass
+
+
+def make_numbered_dir(root: Path, prefix: str, mode: int = 0o700) -> Path:
+    """Create a directory with an increased number as suffix for the given prefix."""
+    for i in range(10):
+        # try up to 10 times to create the folder
+        max_existing = max(map(parse_num, find_suffixes(root, prefix)), default=-1)
+        new_number = max_existing + 1
+        new_path = root.joinpath(f"{prefix}{new_number}")
+        try:
+            new_path.mkdir(mode=mode)
+        except Exception:
+            pass
+        else:
+            _force_symlink(root, prefix + "current", new_path)
+            return new_path
+    else:
+        raise OSError(
+            "could not create numbered dir with prefix "
+            "{prefix} in {root} after 10 tries".format(prefix=prefix, root=root)
+        )
+
+
+def create_cleanup_lock(p: Path) -> Path:
+    """Create a lock to prevent premature folder cleanup."""
+    lock_path = get_lock_path(p)
+    try:
+        fd = os.open(str(lock_path), os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644)
+    except FileExistsError as e:
+        raise OSError(f"cannot create lockfile in {p}") from e
+    else:
+        pid = os.getpid()
+        spid = str(pid).encode()
+        os.write(fd, spid)
+        os.close(fd)
+        if not lock_path.is_file():
+            raise OSError("lock path got renamed after successful creation")
+        return lock_path
+
+
+def register_cleanup_lock_removal(lock_path: Path, register=atexit.register):
+    """Register a cleanup function for removing a lock, by default on atexit."""
+    pid = os.getpid()
+
+    def cleanup_on_exit(lock_path: Path = lock_path, original_pid: int = pid) -> None:
+        current_pid = os.getpid()
+        if current_pid != original_pid:
+            # fork
+            return
+        try:
+            lock_path.unlink()
+        except OSError:
+            pass
+
+    return register(cleanup_on_exit)
+
+
+def maybe_delete_a_numbered_dir(path: Path) -> None:
+    """Remove a numbered directory if its lock can be obtained and it does
+    not seem to be in use."""
+    path = ensure_extended_length_path(path)
+    lock_path = None
+    try:
+        lock_path = create_cleanup_lock(path)
+        parent = path.parent
+
+        garbage = parent.joinpath(f"garbage-{uuid.uuid4()}")
+        path.rename(garbage)
+        rm_rf(garbage)
+    except OSError:
+        #  known races:
+        #  * other process did a cleanup at the same time
+        #  * deletable folder was found
+        #  * process cwd (Windows)
+        return
+    finally:
+        # If we created the lock, ensure we remove it even if we failed
+        # to properly remove the numbered dir.
+        if lock_path is not None:
+            try:
+                lock_path.unlink()
+            except OSError:
+                pass
+
+
+def ensure_deletable(path: Path, consider_lock_dead_if_created_before: float) -> bool:
+    """Check if `path` is deletable based on whether the lock file is expired."""
+    if path.is_symlink():
+        return False
+    lock = get_lock_path(path)
+    try:
+        if not lock.is_file():
+            return True
+    except OSError:
+        # we might not have access to the lock file at all, in this case assume
+        # we don't have access to the entire directory (#7491).
+        return False
+    try:
+        lock_time = lock.stat().st_mtime
+    except Exception:
+        return False
+    else:
+        if lock_time < consider_lock_dead_if_created_before:
+            # We want to ignore any errors while trying to remove the lock such as:
+            # - PermissionDenied, like the file permissions have changed since the lock creation;
+            # - FileNotFoundError, in case another pytest process got here first;
+            # and any other cause of failure.
+            with contextlib.suppress(OSError):
+                lock.unlink()
+                return True
+        return False
+
+
+def try_cleanup(path: Path, consider_lock_dead_if_created_before: float) -> None:
+    """Try to cleanup a folder if we can ensure it's deletable."""
+    if ensure_deletable(path, consider_lock_dead_if_created_before):
+        maybe_delete_a_numbered_dir(path)
+
+
+def cleanup_candidates(root: Path, prefix: str, keep: int) -> Iterator[Path]:
+    """List candidates for numbered directories to be removed - follows py.path."""
+    max_existing = max(map(parse_num, find_suffixes(root, prefix)), default=-1)
+    max_delete = max_existing - keep
+    paths = find_prefixed(root, prefix)
+    paths, paths2 = itertools.tee(paths)
+    numbers = map(parse_num, extract_suffixes(paths2, prefix))
+    for path, number in zip(paths, numbers):
+        if number <= max_delete:
+            yield path
+
+
+def cleanup_numbered_dir(
+    root: Path, prefix: str, keep: int, consider_lock_dead_if_created_before: float
+) -> None:
+    """Cleanup for lock driven numbered directories."""
+    for path in cleanup_candidates(root, prefix, keep):
+        try_cleanup(path, consider_lock_dead_if_created_before)
+    for path in root.glob("garbage-*"):
+        try_cleanup(path, consider_lock_dead_if_created_before)
+
+
+def make_numbered_dir_with_cleanup(
+    root: Path, prefix: str, keep: int, lock_timeout: float, mode: int,
+) -> Path:
+    """Create a numbered dir with a cleanup lock and remove old ones."""
+    e = None
+    for i in range(10):
+        try:
+            p = make_numbered_dir(root, prefix, mode)
+            lock_path = create_cleanup_lock(p)
+            register_cleanup_lock_removal(lock_path)
+        except Exception as exc:
+            e = exc
+        else:
+            consider_lock_dead_if_created_before = p.stat().st_mtime - lock_timeout
+            # Register a cleanup for program exit
+            atexit.register(
+                cleanup_numbered_dir,
+                root,
+                prefix,
+                keep,
+                consider_lock_dead_if_created_before,
+            )
+            return p
+    assert e is not None
+    raise e
+
+
+def resolve_from_str(input: str, rootpath: Path) -> Path:
+    input = expanduser(input)
+    input = expandvars(input)
+    if isabs(input):
+        return Path(input)
+    else:
+        return rootpath.joinpath(input)
+
+
+def fnmatch_ex(pattern: str, path) -> bool:
+    """A port of FNMatcher from py.path.common which works with PurePath() instances.
+
+    The difference between this algorithm and PurePath.match() is that the
+    latter matches "**" glob expressions for each part of the path, while
+    this algorithm uses the whole path instead.
+
+    For example:
+        "tests/foo/bar/doc/test_foo.py" matches pattern "tests/**/doc/test*.py"
+        with this algorithm, but not with PurePath.match().
+
+    This algorithm was ported to keep backward-compatibility with existing
+    settings which assume paths match according this logic.
+
+    References:
+    * https://bugs.python.org/issue29249
+    * https://bugs.python.org/issue34731
+    """
+    path = PurePath(path)
+    iswin32 = sys.platform.startswith("win")
+
+    if iswin32 and sep not in pattern and posix_sep in pattern:
+        # Running on Windows, the pattern has no Windows path separators,
+        # and the pattern has one or more Posix path separators. Replace
+        # the Posix path separators with the Windows path separator.
+        pattern = pattern.replace(posix_sep, sep)
+
+    if sep not in pattern:
+        name = path.name
+    else:
+        name = str(path)
+        if path.is_absolute() and not os.path.isabs(pattern):
+            pattern = f"*{os.sep}{pattern}"
+    return fnmatch.fnmatch(name, pattern)
+
+
+def parts(s: str) -> Set[str]:
+    parts = s.split(sep)
+    return {sep.join(parts[: i + 1]) or sep for i in range(len(parts))}
+
+
+def symlink_or_skip(src, dst, **kwargs):
+    """Make a symlink, or skip the test in case symlinks are not supported."""
+    try:
+        os.symlink(str(src), str(dst), **kwargs)
+    except OSError as e:
+        skip(f"symlinks not supported: {e}")
+
+
+class ImportMode(Enum):
+    """Possible values for `mode` parameter of `import_path`."""
+
+    prepend = "prepend"
+    append = "append"
+    importlib = "importlib"
+
+
+class ImportPathMismatchError(ImportError):
+    """Raised on import_path() if there is a mismatch of __file__'s.
+
+    This can happen when `import_path` is called multiple times with different filenames that has
+    the same basename but reside in packages
+    (for example "/tests1/test_foo.py" and "/tests2/test_foo.py").
+    """
+
+
+def import_path(
+    p: Union[str, py.path.local, Path],
+    *,
+    mode: Union[str, ImportMode] = ImportMode.prepend,
+) -> ModuleType:
+    """Import and return a module from the given path, which can be a file (a module) or
+    a directory (a package).
+
+    The import mechanism used is controlled by the `mode` parameter:
+
+    * `mode == ImportMode.prepend`: the directory containing the module (or package, taking
+      `__init__.py` files into account) will be put at the *start* of `sys.path` before
+      being imported with `__import__.
+
+    * `mode == ImportMode.append`: same as `prepend`, but the directory will be appended
+      to the end of `sys.path`, if not already in `sys.path`.
+
+    * `mode == ImportMode.importlib`: uses more fine control mechanisms provided by `importlib`
+      to import the module, which avoids having to use `__import__` and muck with `sys.path`
+      at all. It effectively allows having same-named test modules in different places.
+
+    :raises ImportPathMismatchError:
+        If after importing the given `path` and the module `__file__`
+        are different. Only raised in `prepend` and `append` modes.
+    """
+    mode = ImportMode(mode)
+
+    path = Path(str(p))
+
+    if not path.exists():
+        raise ImportError(path)
+
+    if mode is ImportMode.importlib:
+        module_name = path.stem
+
+        for meta_importer in sys.meta_path:
+            spec = meta_importer.find_spec(module_name, [str(path.parent)])
+            if spec is not None:
+                break
+        else:
+            spec = importlib.util.spec_from_file_location(module_name, str(path))
+
+        if spec is None:
+            raise ImportError(
+                "Can't find module {} at location {}".format(module_name, str(path))
+            )
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)  # type: ignore[union-attr]
+        return mod
+
+    pkg_path = resolve_package_path(path)
+    if pkg_path is not None:
+        pkg_root = pkg_path.parent
+        names = list(path.with_suffix("").relative_to(pkg_root).parts)
+        if names[-1] == "__init__":
+            names.pop()
+        module_name = ".".join(names)
+    else:
+        pkg_root = path.parent
+        module_name = path.stem
+
+    # Change sys.path permanently: restoring it at the end of this function would cause surprising
+    # problems because of delayed imports: for example, a conftest.py file imported by this function
+    # might have local imports, which would fail at runtime if we restored sys.path.
+    if mode is ImportMode.append:
+        if str(pkg_root) not in sys.path:
+            sys.path.append(str(pkg_root))
+    elif mode is ImportMode.prepend:
+        if str(pkg_root) != sys.path[0]:
+            sys.path.insert(0, str(pkg_root))
+    else:
+        assert_never(mode)
+
+    importlib.import_module(module_name)
+
+    mod = sys.modules[module_name]
+    if path.name == "__init__.py":
+        return mod
+
+    ignore = os.environ.get("PY_IGNORE_IMPORTMISMATCH", "")
+    if ignore != "1":
+        module_file = mod.__file__
+        if module_file.endswith((".pyc", ".pyo")):
+            module_file = module_file[:-1]
+        if module_file.endswith(os.path.sep + "__init__.py"):
+            module_file = module_file[: -(len(os.path.sep + "__init__.py"))]
+
+        try:
+            is_same = _is_same(str(path), module_file)
+        except FileNotFoundError:
+            is_same = False
+
+        if not is_same:
+            raise ImportPathMismatchError(module_name, module_file, path)
+
+    return mod
+
+
+# Implement a special _is_same function on Windows which returns True if the two filenames
+# compare equal, to circumvent os.path.samefile returning False for mounts in UNC (#7678).
+if sys.platform.startswith("win"):
+
+    def _is_same(f1: str, f2: str) -> bool:
+        return Path(f1) == Path(f2) or os.path.samefile(f1, f2)
+
+
+else:
+
+    def _is_same(f1: str, f2: str) -> bool:
+        return os.path.samefile(f1, f2)
+
+
+def resolve_package_path(path: Path) -> Optional[Path]:
+    """Return the Python package path by looking for the last
+    directory upwards which still contains an __init__.py.
+
+    Returns None if it can not be determined.
+    """
+    result = None
+    for parent in itertools.chain((path,), path.parents):
+        if parent.is_dir():
+            if not parent.joinpath("__init__.py").is_file():
+                break
+            if not parent.name.isidentifier():
+                break
+            result = parent
+    return result
+
+
+def visit(
+    path: str, recurse: Callable[["os.DirEntry[str]"], bool]
+) -> Iterator["os.DirEntry[str]"]:
+    """Walk a directory recursively, in breadth-first order.
+
+    Entries at each directory level are sorted.
+    """
+
+    # Skip entries with symlink loops and other brokenness, so the caller doesn't
+    # have to deal with it.
+    entries = []
+    for entry in os.scandir(path):
+        try:
+            entry.is_file()
+        except OSError as err:
+            if _ignore_error(err):
+                continue
+            raise
+        entries.append(entry)
+
+    entries.sort(key=lambda entry: entry.name)
+
+    yield from entries
+
+    for entry in entries:
+        if entry.is_dir() and recurse(entry):
+            yield from visit(entry.path, recurse)
+
+
+def absolutepath(path: Union[Path, str]) -> Path:
+    """Convert a path to an absolute path using os.path.abspath.
+
+    Prefer this over Path.resolve() (see #6523).
+    Prefer this over Path.absolute() (not public, doesn't normalize).
+    """
+    return Path(os.path.abspath(str(path)))
+
+
+def commonpath(path1: Path, path2: Path) -> Optional[Path]:
+    """Return the common part shared with the other path, or None if there is
+    no common part.
+
+    If one path is relative and one is absolute, returns None.
+    """
+    try:
+        return Path(os.path.commonpath((str(path1), str(path2))))
+    except ValueError:
+        return None
+
+
+def bestrelpath(directory: Path, dest: Path) -> str:
+    """Return a string which is a relative path from directory to dest such
+    that directory/bestrelpath == dest.
+
+    The paths must be either both absolute or both relative.
+
+    If no such path can be determined, returns dest.
+    """
+    if dest == directory:
+        return os.curdir
+    # Find the longest common directory.
+    base = commonpath(directory, dest)
+    # Can be the case on Windows for two absolute paths on different drives.
+    # Can be the case for two relative paths without common prefix.
+    # Can be the case for a relative path and an absolute path.
+    if not base:
+        return str(dest)
+    reldirectory = directory.relative_to(base)
+    reldest = dest.relative_to(base)
+    return os.path.join(
+        # Back from directory to base.
+        *([os.pardir] * len(reldirectory.parts)),
+        # Forward from base to dest.
+        *reldest.parts,
+    )
diff --git a/myenv/lib/python3.9/site-packages/_pytest/py.typed b/myenv/lib/python3.9/site-packages/_pytest/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/_pytest/pytester.py b/myenv/lib/python3.9/site-packages/_pytest/pytester.py
new file mode 100644
index 0000000..31259d1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/pytester.py
@@ -0,0 +1,1922 @@
+"""(Disabled by default) support for testing pytest and pytest plugins.
+
+PYTEST_DONT_REWRITE
+"""
+import collections.abc
+import contextlib
+import gc
+import importlib
+import os
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import traceback
+from fnmatch import fnmatch
+from io import StringIO
+from pathlib import Path
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import Generator
+from typing import Iterable
+from typing import List
+from typing import Optional
+from typing import overload
+from typing import Sequence
+from typing import TextIO
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import Union
+from weakref import WeakKeyDictionary
+
+import attr
+import py
+from iniconfig import IniConfig
+from iniconfig import SectionWrapper
+
+from _pytest import timing
+from _pytest._code import Source
+from _pytest.capture import _get_multicapture
+from _pytest.compat import final
+from _pytest.config import _PluggyPlugin
+from _pytest.config import Config
+from _pytest.config import ExitCode
+from _pytest.config import hookimpl
+from _pytest.config import main
+from _pytest.config import PytestPluginManager
+from _pytest.config.argparsing import Parser
+from _pytest.deprecated import check_ispytest
+from _pytest.fixtures import fixture
+from _pytest.fixtures import FixtureRequest
+from _pytest.main import Session
+from _pytest.monkeypatch import MonkeyPatch
+from _pytest.nodes import Collector
+from _pytest.nodes import Item
+from _pytest.outcomes import fail
+from _pytest.outcomes import importorskip
+from _pytest.outcomes import skip
+from _pytest.pathlib import make_numbered_dir
+from _pytest.reports import CollectReport
+from _pytest.reports import TestReport
+from _pytest.tmpdir import TempPathFactory
+from _pytest.warning_types import PytestWarning
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
+    import pexpect
+
+
+pytest_plugins = ["pytester_assertions"]
+
+
+IGNORE_PAM = [  # filenames added when obtaining details about the current user
+    "/var/lib/sss/mc/passwd"
+]
+
+
+def pytest_addoption(parser: Parser) -> None:
+    parser.addoption(
+        "--lsof",
+        action="store_true",
+        dest="lsof",
+        default=False,
+        help="run FD checks if lsof is available",
+    )
+
+    parser.addoption(
+        "--runpytest",
+        default="inprocess",
+        dest="runpytest",
+        choices=("inprocess", "subprocess"),
+        help=(
+            "run pytest sub runs in tests using an 'inprocess' "
+            "or 'subprocess' (python -m main) method"
+        ),
+    )
+
+    parser.addini(
+        "pytester_example_dir", help="directory to take the pytester example files from"
+    )
+
+
+def pytest_configure(config: Config) -> None:
+    if config.getvalue("lsof"):
+        checker = LsofFdLeakChecker()
+        if checker.matching_platform():
+            config.pluginmanager.register(checker)
+
+    config.addinivalue_line(
+        "markers",
+        "pytester_example_path(*path_segments): join the given path "
+        "segments to `pytester_example_dir` for this test.",
+    )
+
+
+class LsofFdLeakChecker:
+    def get_open_files(self) -> List[Tuple[str, str]]:
+        out = subprocess.run(
+            ("lsof", "-Ffn0", "-p", str(os.getpid())),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            check=True,
+            universal_newlines=True,
+        ).stdout
+
+        def isopen(line: str) -> bool:
+            return line.startswith("f") and (
+                "deleted" not in line
+                and "mem" not in line
+                and "txt" not in line
+                and "cwd" not in line
+            )
+
+        open_files = []
+
+        for line in out.split("\n"):
+            if isopen(line):
+                fields = line.split("\0")
+                fd = fields[0][1:]
+                filename = fields[1][1:]
+                if filename in IGNORE_PAM:
+                    continue
+                if filename.startswith("/"):
+                    open_files.append((fd, filename))
+
+        return open_files
+
+    def matching_platform(self) -> bool:
+        try:
+            subprocess.run(("lsof", "-v"), check=True)
+        except (OSError, subprocess.CalledProcessError):
+            return False
+        else:
+            return True
+
+    @hookimpl(hookwrapper=True, tryfirst=True)
+    def pytest_runtest_protocol(self, item: Item) -> Generator[None, None, None]:
+        lines1 = self.get_open_files()
+        yield
+        if hasattr(sys, "pypy_version_info"):
+            gc.collect()
+        lines2 = self.get_open_files()
+
+        new_fds = {t[0] for t in lines2} - {t[0] for t in lines1}
+        leaked_files = [t for t in lines2 if t[0] in new_fds]
+        if leaked_files:
+            error = [
+                "***** %s FD leakage detected" % len(leaked_files),
+                *(str(f) for f in leaked_files),
+                "*** Before:",
+                *(str(f) for f in lines1),
+                "*** After:",
+                *(str(f) for f in lines2),
+                "***** %s FD leakage detected" % len(leaked_files),
+                "*** function %s:%s: %s " % item.location,
+                "See issue #2366",
+            ]
+            item.warn(PytestWarning("\n".join(error)))
+
+
+# used at least by pytest-xdist plugin
+
+
+@fixture
+def _pytest(request: FixtureRequest) -> "PytestArg":
+    """Return a helper which offers a gethookrecorder(hook) method which
+    returns a HookRecorder instance which helps to make assertions about called
+    hooks."""
+    return PytestArg(request)
+
+
+class PytestArg:
+    def __init__(self, request: FixtureRequest) -> None:
+        self._request = request
+
+    def gethookrecorder(self, hook) -> "HookRecorder":
+        hookrecorder = HookRecorder(hook._pm)
+        self._request.addfinalizer(hookrecorder.finish_recording)
+        return hookrecorder
+
+
+def get_public_names(values: Iterable[str]) -> List[str]:
+    """Only return names from iterator values without a leading underscore."""
+    return [x for x in values if x[0] != "_"]
+
+
+class ParsedCall:
+    def __init__(self, name: str, kwargs) -> None:
+        self.__dict__.update(kwargs)
+        self._name = name
+
+    def __repr__(self) -> str:
+        d = self.__dict__.copy()
+        del d["_name"]
+        return f"<ParsedCall {self._name!r}(**{d!r})>"
+
+    if TYPE_CHECKING:
+        # The class has undetermined attributes, this tells mypy about it.
+        def __getattr__(self, key: str):
+            ...
+
+
+class HookRecorder:
+    """Record all hooks called in a plugin manager.
+
+    This wraps all the hook calls in the plugin manager, recording each call
+    before propagating the normal calls.
+    """
+
+    def __init__(self, pluginmanager: PytestPluginManager) -> None:
+        self._pluginmanager = pluginmanager
+        self.calls: List[ParsedCall] = []
+        self.ret: Optional[Union[int, ExitCode]] = None
+
+        def before(hook_name: str, hook_impls, kwargs) -> None:
+            self.calls.append(ParsedCall(hook_name, kwargs))
+
+        def after(outcome, hook_name: str, hook_impls, kwargs) -> None:
+            pass
+
+        self._undo_wrapping = pluginmanager.add_hookcall_monitoring(before, after)
+
+    def finish_recording(self) -> None:
+        self._undo_wrapping()
+
+    def getcalls(self, names: Union[str, Iterable[str]]) -> List[ParsedCall]:
+        if isinstance(names, str):
+            names = names.split()
+        return [call for call in self.calls if call._name in names]
+
+    def assert_contains(self, entries: Sequence[Tuple[str, str]]) -> None:
+        __tracebackhide__ = True
+        i = 0
+        entries = list(entries)
+        backlocals = sys._getframe(1).f_locals
+        while entries:
+            name, check = entries.pop(0)
+            for ind, call in enumerate(self.calls[i:]):
+                if call._name == name:
+                    print("NAMEMATCH", name, call)
+                    if eval(check, backlocals, call.__dict__):
+                        print("CHECKERMATCH", repr(check), "->", call)
+                    else:
+                        print("NOCHECKERMATCH", repr(check), "-", call)
+                        continue
+                    i += ind + 1
+                    break
+                print("NONAMEMATCH", name, "with", call)
+            else:
+                fail(f"could not find {name!r} check {check!r}")
+
+    def popcall(self, name: str) -> ParsedCall:
+        __tracebackhide__ = True
+        for i, call in enumerate(self.calls):
+            if call._name == name:
+                del self.calls[i]
+                return call
+        lines = [f"could not find call {name!r}, in:"]
+        lines.extend(["  %s" % x for x in self.calls])
+        fail("\n".join(lines))
+
+    def getcall(self, name: str) -> ParsedCall:
+        values = self.getcalls(name)
+        assert len(values) == 1, (name, values)
+        return values[0]
+
+    # functionality for test reports
+
+    @overload
+    def getreports(
+        self, names: "Literal['pytest_collectreport']",
+    ) -> Sequence[CollectReport]:
+        ...
+
+    @overload
+    def getreports(
+        self, names: "Literal['pytest_runtest_logreport']",
+    ) -> Sequence[TestReport]:
+        ...
+
+    @overload
+    def getreports(
+        self,
+        names: Union[str, Iterable[str]] = (
+            "pytest_collectreport",
+            "pytest_runtest_logreport",
+        ),
+    ) -> Sequence[Union[CollectReport, TestReport]]:
+        ...
+
+    def getreports(
+        self,
+        names: Union[str, Iterable[str]] = (
+            "pytest_collectreport",
+            "pytest_runtest_logreport",
+        ),
+    ) -> Sequence[Union[CollectReport, TestReport]]:
+        return [x.report for x in self.getcalls(names)]
+
+    def matchreport(
+        self,
+        inamepart: str = "",
+        names: Union[str, Iterable[str]] = (
+            "pytest_runtest_logreport",
+            "pytest_collectreport",
+        ),
+        when: Optional[str] = None,
+    ) -> Union[CollectReport, TestReport]:
+        """Return a testreport whose dotted import path matches."""
+        values = []
+        for rep in self.getreports(names=names):
+            if not when and rep.when != "call" and rep.passed:
+                # setup/teardown passing reports - let's ignore those
+                continue
+            if when and rep.when != when:
+                continue
+            if not inamepart or inamepart in rep.nodeid.split("::"):
+                values.append(rep)
+        if not values:
+            raise ValueError(
+                "could not find test report matching %r: "
+                "no test reports at all!" % (inamepart,)
+            )
+        if len(values) > 1:
+            raise ValueError(
+                "found 2 or more testreports matching {!r}: {}".format(
+                    inamepart, values
+                )
+            )
+        return values[0]
+
+    @overload
+    def getfailures(
+        self, names: "Literal['pytest_collectreport']",
+    ) -> Sequence[CollectReport]:
+        ...
+
+    @overload
+    def getfailures(
+        self, names: "Literal['pytest_runtest_logreport']",
+    ) -> Sequence[TestReport]:
+        ...
+
+    @overload
+    def getfailures(
+        self,
+        names: Union[str, Iterable[str]] = (
+            "pytest_collectreport",
+            "pytest_runtest_logreport",
+        ),
+    ) -> Sequence[Union[CollectReport, TestReport]]:
+        ...
+
+    def getfailures(
+        self,
+        names: Union[str, Iterable[str]] = (
+            "pytest_collectreport",
+            "pytest_runtest_logreport",
+        ),
+    ) -> Sequence[Union[CollectReport, TestReport]]:
+        return [rep for rep in self.getreports(names) if rep.failed]
+
+    def getfailedcollections(self) -> Sequence[CollectReport]:
+        return self.getfailures("pytest_collectreport")
+
+    def listoutcomes(
+        self,
+    ) -> Tuple[
+        Sequence[TestReport],
+        Sequence[Union[CollectReport, TestReport]],
+        Sequence[Union[CollectReport, TestReport]],
+    ]:
+        passed = []
+        skipped = []
+        failed = []
+        for rep in self.getreports(
+            ("pytest_collectreport", "pytest_runtest_logreport")
+        ):
+            if rep.passed:
+                if rep.when == "call":
+                    assert isinstance(rep, TestReport)
+                    passed.append(rep)
+            elif rep.skipped:
+                skipped.append(rep)
+            else:
+                assert rep.failed, f"Unexpected outcome: {rep!r}"
+                failed.append(rep)
+        return passed, skipped, failed
+
+    def countoutcomes(self) -> List[int]:
+        return [len(x) for x in self.listoutcomes()]
+
+    def assertoutcome(self, passed: int = 0, skipped: int = 0, failed: int = 0) -> None:
+        __tracebackhide__ = True
+        from _pytest.pytester_assertions import assertoutcome
+
+        outcomes = self.listoutcomes()
+        assertoutcome(
+            outcomes, passed=passed, skipped=skipped, failed=failed,
+        )
+
+    def clear(self) -> None:
+        self.calls[:] = []
+
+
+@fixture
+def linecomp() -> "LineComp":
+    """A :class: `LineComp` instance for checking that an input linearly
+    contains a sequence of strings."""
+    return LineComp()
+
+
+@fixture(name="LineMatcher")
+def LineMatcher_fixture(request: FixtureRequest) -> Type["LineMatcher"]:
+    """A reference to the :class: `LineMatcher`.
+
+    This is instantiable with a list of lines (without their trailing newlines).
+    This is useful for testing large texts, such as the output of commands.
+    """
+    return LineMatcher
+
+
+@fixture
+def pytester(request: FixtureRequest, tmp_path_factory: TempPathFactory) -> "Pytester":
+    """
+    Facilities to write tests/configuration files, execute pytest in isolation, and match
+    against expected output, perfect for black-box testing of pytest plugins.
+
+    It attempts to isolate the test run from external factors as much as possible, modifying
+    the current working directory to ``path`` and environment variables during initialization.
+
+    It is particularly useful for testing plugins. It is similar to the :fixture:`tmp_path`
+    fixture but provides methods which aid in testing pytest itself.
+    """
+    return Pytester(request, tmp_path_factory, _ispytest=True)
+
+
+@fixture
+def testdir(pytester: "Pytester") -> "Testdir":
+    """
+    Identical to :fixture:`pytester`, and provides an instance whose methods return
+    legacy ``py.path.local`` objects instead when applicable.
+
+    New code should avoid using :fixture:`testdir` in favor of :fixture:`pytester`.
+    """
+    return Testdir(pytester, _ispytest=True)
+
+
+@fixture
+def _sys_snapshot() -> Generator[None, None, None]:
+    snappaths = SysPathsSnapshot()
+    snapmods = SysModulesSnapshot()
+    yield
+    snapmods.restore()
+    snappaths.restore()
+
+
+@fixture
+def _config_for_test() -> Generator[Config, None, None]:
+    from _pytest.config import get_config
+
+    config = get_config()
+    yield config
+    config._ensure_unconfigure()  # cleanup, e.g. capman closing tmpfiles.
+
+
+# Regex to match the session duration string in the summary: "74.34s".
+rex_session_duration = re.compile(r"\d+\.\d\ds")
+# Regex to match all the counts and phrases in the summary line: "34 passed, 111 skipped".
+rex_outcome = re.compile(r"(\d+) (\w+)")
+
+
+class RunResult:
+    """The result of running a command."""
+
+    def __init__(
+        self,
+        ret: Union[int, ExitCode],
+        outlines: List[str],
+        errlines: List[str],
+        duration: float,
+    ) -> None:
+        try:
+            self.ret: Union[int, ExitCode] = ExitCode(ret)
+            """The return value."""
+        except ValueError:
+            self.ret = ret
+        self.outlines = outlines
+        """List of lines captured from stdout."""
+        self.errlines = errlines
+        """List of lines captured from stderr."""
+        self.stdout = LineMatcher(outlines)
+        """:class:`LineMatcher` of stdout.
+
+        Use e.g. :func:`str(stdout) <LineMatcher.__str__()>` to reconstruct stdout, or the commonly used
+        :func:`stdout.fnmatch_lines() <LineMatcher.fnmatch_lines()>` method.
+        """
+        self.stderr = LineMatcher(errlines)
+        """:class:`LineMatcher` of stderr."""
+        self.duration = duration
+        """Duration in seconds."""
+
+    def __repr__(self) -> str:
+        return (
+            "<RunResult ret=%s len(stdout.lines)=%d len(stderr.lines)=%d duration=%.2fs>"
+            % (self.ret, len(self.stdout.lines), len(self.stderr.lines), self.duration)
+        )
+
+    def parseoutcomes(self) -> Dict[str, int]:
+        """Return a dictionary of outcome noun -> count from parsing the terminal
+        output that the test process produced.
+
+        The returned nouns will always be in plural form::
+
+            ======= 1 failed, 1 passed, 1 warning, 1 error in 0.13s ====
+
+        Will return ``{"failed": 1, "passed": 1, "warnings": 1, "errors": 1}``.
+        """
+        return self.parse_summary_nouns(self.outlines)
+
+    @classmethod
+    def parse_summary_nouns(cls, lines) -> Dict[str, int]:
+        """Extract the nouns from a pytest terminal summary line.
+
+        It always returns the plural noun for consistency::
+
+            ======= 1 failed, 1 passed, 1 warning, 1 error in 0.13s ====
+
+        Will return ``{"failed": 1, "passed": 1, "warnings": 1, "errors": 1}``.
+        """
+        for line in reversed(lines):
+            if rex_session_duration.search(line):
+                outcomes = rex_outcome.findall(line)
+                ret = {noun: int(count) for (count, noun) in outcomes}
+                break
+        else:
+            raise ValueError("Pytest terminal summary report not found")
+
+        to_plural = {
+            "warning": "warnings",
+            "error": "errors",
+        }
+        return {to_plural.get(k, k): v for k, v in ret.items()}
+
+    def assert_outcomes(
+        self,
+        passed: int = 0,
+        skipped: int = 0,
+        failed: int = 0,
+        errors: int = 0,
+        xpassed: int = 0,
+        xfailed: int = 0,
+    ) -> None:
+        """Assert that the specified outcomes appear with the respective
+        numbers (0 means it didn't occur) in the text output from a test run."""
+        __tracebackhide__ = True
+        from _pytest.pytester_assertions import assert_outcomes
+
+        outcomes = self.parseoutcomes()
+        assert_outcomes(
+            outcomes,
+            passed=passed,
+            skipped=skipped,
+            failed=failed,
+            errors=errors,
+            xpassed=xpassed,
+            xfailed=xfailed,
+        )
+
+
+class CwdSnapshot:
+    def __init__(self) -> None:
+        self.__saved = os.getcwd()
+
+    def restore(self) -> None:
+        os.chdir(self.__saved)
+
+
+class SysModulesSnapshot:
+    def __init__(self, preserve: Optional[Callable[[str], bool]] = None) -> None:
+        self.__preserve = preserve
+        self.__saved = dict(sys.modules)
+
+    def restore(self) -> None:
+        if self.__preserve:
+            self.__saved.update(
+                (k, m) for k, m in sys.modules.items() if self.__preserve(k)
+            )
+        sys.modules.clear()
+        sys.modules.update(self.__saved)
+
+
+class SysPathsSnapshot:
+    def __init__(self) -> None:
+        self.__saved = list(sys.path), list(sys.meta_path)
+
+    def restore(self) -> None:
+        sys.path[:], sys.meta_path[:] = self.__saved
+
+
+@final
+class Pytester:
+    """
+    Facilities to write tests/configuration files, execute pytest in isolation, and match
+    against expected output, perfect for black-box testing of pytest plugins.
+
+    It attempts to isolate the test run from external factors as much as possible, modifying
+    the current working directory to ``path`` and environment variables during initialization.
+
+    Attributes:
+
+    :ivar Path path: temporary directory path used to create files/run tests from, etc.
+
+    :ivar plugins:
+       A list of plugins to use with :py:meth:`parseconfig` and
+       :py:meth:`runpytest`.  Initially this is an empty list but plugins can
+       be added to the list.  The type of items to add to the list depends on
+       the method using them so refer to them for details.
+    """
+
+    __test__ = False
+
+    CLOSE_STDIN = object
+
+    class TimeoutExpired(Exception):
+        pass
+
+    def __init__(
+        self,
+        request: FixtureRequest,
+        tmp_path_factory: TempPathFactory,
+        *,
+        _ispytest: bool = False,
+    ) -> None:
+        check_ispytest(_ispytest)
+        self._request = request
+        self._mod_collections: WeakKeyDictionary[
+            Collector, List[Union[Item, Collector]]
+        ] = (WeakKeyDictionary())
+        if request.function:
+            name: str = request.function.__name__
+        else:
+            name = request.node.name
+        self._name = name
+        self._path: Path = tmp_path_factory.mktemp(name, numbered=True)
+        self.plugins: List[Union[str, _PluggyPlugin]] = []
+        self._cwd_snapshot = CwdSnapshot()
+        self._sys_path_snapshot = SysPathsSnapshot()
+        self._sys_modules_snapshot = self.__take_sys_modules_snapshot()
+        self.chdir()
+        self._request.addfinalizer(self._finalize)
+        self._method = self._request.config.getoption("--runpytest")
+        self._test_tmproot = tmp_path_factory.mktemp(f"tmp-{name}", numbered=True)
+
+        self._monkeypatch = mp = MonkeyPatch()
+        mp.setenv("PYTEST_DEBUG_TEMPROOT", str(self._test_tmproot))
+        # Ensure no unexpected caching via tox.
+        mp.delenv("TOX_ENV_DIR", raising=False)
+        # Discard outer pytest options.
+        mp.delenv("PYTEST_ADDOPTS", raising=False)
+        # Ensure no user config is used.
+        tmphome = str(self.path)
+        mp.setenv("HOME", tmphome)
+        mp.setenv("USERPROFILE", tmphome)
+        # Do not use colors for inner runs by default.
+        mp.setenv("PY_COLORS", "0")
+
+    @property
+    def path(self) -> Path:
+        """Temporary directory where files are created and pytest is executed."""
+        return self._path
+
+    def __repr__(self) -> str:
+        return f"<Pytester {self.path!r}>"
+
+    def _finalize(self) -> None:
+        """
+        Clean up global state artifacts.
+
+        Some methods modify the global interpreter state and this tries to
+        clean this up. It does not remove the temporary directory however so
+        it can be looked at after the test run has finished.
+        """
+        self._sys_modules_snapshot.restore()
+        self._sys_path_snapshot.restore()
+        self._cwd_snapshot.restore()
+        self._monkeypatch.undo()
+
+    def __take_sys_modules_snapshot(self) -> SysModulesSnapshot:
+        # Some zope modules used by twisted-related tests keep internal state
+        # and can't be deleted; we had some trouble in the past with
+        # `zope.interface` for example.
+        #
+        # Preserve readline due to https://bugs.python.org/issue41033.
+        # pexpect issues a SIGWINCH.
+        def preserve_module(name):
+            return name.startswith(("zope", "readline"))
+
+        return SysModulesSnapshot(preserve=preserve_module)
+
+    def make_hook_recorder(self, pluginmanager: PytestPluginManager) -> HookRecorder:
+        """Create a new :py:class:`HookRecorder` for a PluginManager."""
+        pluginmanager.reprec = reprec = HookRecorder(pluginmanager)
+        self._request.addfinalizer(reprec.finish_recording)
+        return reprec
+
+    def chdir(self) -> None:
+        """Cd into the temporary directory.
+
+        This is done automatically upon instantiation.
+        """
+        os.chdir(self.path)
+
+    def _makefile(
+        self,
+        ext: str,
+        lines: Sequence[Union[Any, bytes]],
+        files: Dict[str, str],
+        encoding: str = "utf-8",
+    ) -> Path:
+        items = list(files.items())
+
+        def to_text(s: Union[Any, bytes]) -> str:
+            return s.decode(encoding) if isinstance(s, bytes) else str(s)
+
+        if lines:
+            source = "\n".join(to_text(x) for x in lines)
+            basename = self._name
+            items.insert(0, (basename, source))
+
+        ret = None
+        for basename, value in items:
+            p = self.path.joinpath(basename).with_suffix(ext)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            source_ = Source(value)
+            source = "\n".join(to_text(line) for line in source_.lines)
+            p.write_text(source.strip(), encoding=encoding)
+            if ret is None:
+                ret = p
+        assert ret is not None
+        return ret
+
+    def makefile(self, ext: str, *args: str, **kwargs: str) -> Path:
+        r"""Create new file(s) in the test directory.
+
+        :param str ext:
+            The extension the file(s) should use, including the dot, e.g. `.py`.
+        :param args:
+            All args are treated as strings and joined using newlines.
+            The result is written as contents to the file.  The name of the
+            file is based on the test function requesting this fixture.
+        :param kwargs:
+            Each keyword is the name of a file, while the value of it will
+            be written as contents of the file.
+
+        Examples:
+
+        .. code-block:: python
+
+            pytester.makefile(".txt", "line1", "line2")
+
+            pytester.makefile(".ini", pytest="[pytest]\naddopts=-rs\n")
+
+        """
+        return self._makefile(ext, args, kwargs)
+
+    def makeconftest(self, source: str) -> Path:
+        """Write a contest.py file with 'source' as contents."""
+        return self.makepyfile(conftest=source)
+
+    def makeini(self, source: str) -> Path:
+        """Write a tox.ini file with 'source' as contents."""
+        return self.makefile(".ini", tox=source)
+
+    def getinicfg(self, source: str) -> SectionWrapper:
+        """Return the pytest section from the tox.ini config file."""
+        p = self.makeini(source)
+        return IniConfig(str(p))["pytest"]
+
+    def makepyprojecttoml(self, source: str) -> Path:
+        """Write a pyproject.toml file with 'source' as contents.
+
+        .. versionadded:: 6.0
+        """
+        return self.makefile(".toml", pyproject=source)
+
+    def makepyfile(self, *args, **kwargs) -> Path:
+        r"""Shortcut for .makefile() with a .py extension.
+
+        Defaults to the test name with a '.py' extension, e.g test_foobar.py, overwriting
+        existing files.
+
+        Examples:
+
+        .. code-block:: python
+
+            def test_something(pytester):
+                # Initial file is created test_something.py.
+                pytester.makepyfile("foobar")
+                # To create multiple files, pass kwargs accordingly.
+                pytester.makepyfile(custom="foobar")
+                # At this point, both 'test_something.py' & 'custom.py' exist in the test directory.
+
+        """
+        return self._makefile(".py", args, kwargs)
+
+    def maketxtfile(self, *args, **kwargs) -> Path:
+        r"""Shortcut for .makefile() with a .txt extension.
+
+        Defaults to the test name with a '.txt' extension, e.g test_foobar.txt, overwriting
+        existing files.
+
+        Examples:
+
+        .. code-block:: python
+
+            def test_something(pytester):
+                # Initial file is created test_something.txt.
+                pytester.maketxtfile("foobar")
+                # To create multiple files, pass kwargs accordingly.
+                pytester.maketxtfile(custom="foobar")
+                # At this point, both 'test_something.txt' & 'custom.txt' exist in the test directory.
+
+        """
+        return self._makefile(".txt", args, kwargs)
+
+    def syspathinsert(
+        self, path: Optional[Union[str, "os.PathLike[str]"]] = None
+    ) -> None:
+        """Prepend a directory to sys.path, defaults to :py:attr:`tmpdir`.
+
+        This is undone automatically when this object dies at the end of each
+        test.
+        """
+        if path is None:
+            path = self.path
+
+        self._monkeypatch.syspath_prepend(str(path))
+
+    def mkdir(self, name: str) -> Path:
+        """Create a new (sub)directory."""
+        p = self.path / name
+        p.mkdir()
+        return p
+
+    def mkpydir(self, name: str) -> Path:
+        """Create a new python package.
+
+        This creates a (sub)directory with an empty ``__init__.py`` file so it
+        gets recognised as a Python package.
+        """
+        p = self.path / name
+        p.mkdir()
+        p.joinpath("__init__.py").touch()
+        return p
+
+    def copy_example(self, name: Optional[str] = None) -> Path:
+        """Copy file from project's directory into the testdir.
+
+        :param str name: The name of the file to copy.
+        :return: path to the copied directory (inside ``self.path``).
+
+        """
+        example_dir = self._request.config.getini("pytester_example_dir")
+        if example_dir is None:
+            raise ValueError("pytester_example_dir is unset, can't copy examples")
+        example_dir = Path(str(self._request.config.rootdir)) / example_dir
+
+        for extra_element in self._request.node.iter_markers("pytester_example_path"):
+            assert extra_element.args
+            example_dir = example_dir.joinpath(*extra_element.args)
+
+        if name is None:
+            func_name = self._name
+            maybe_dir = example_dir / func_name
+            maybe_file = example_dir / (func_name + ".py")
+
+            if maybe_dir.is_dir():
+                example_path = maybe_dir
+            elif maybe_file.is_file():
+                example_path = maybe_file
+            else:
+                raise LookupError(
+                    f"{func_name} can't be found as module or package in {example_dir}"
+                )
+        else:
+            example_path = example_dir.joinpath(name)
+
+        if example_path.is_dir() and not example_path.joinpath("__init__.py").is_file():
+            # TODO: py.path.local.copy can copy files to existing directories,
+            # while with shutil.copytree the destination directory cannot exist,
+            # we will need to roll our own in order to drop py.path.local completely
+            py.path.local(example_path).copy(py.path.local(self.path))
+            return self.path
+        elif example_path.is_file():
+            result = self.path.joinpath(example_path.name)
+            shutil.copy(example_path, result)
+            return result
+        else:
+            raise LookupError(
+                f'example "{example_path}" is not found as a file or directory'
+            )
+
+    Session = Session
+
+    def getnode(
+        self, config: Config, arg: Union[str, "os.PathLike[str]"]
+    ) -> Optional[Union[Collector, Item]]:
+        """Return the collection node of a file.
+
+        :param _pytest.config.Config config:
+           A pytest config.
+           See :py:meth:`parseconfig` and :py:meth:`parseconfigure` for creating it.
+        :param py.path.local arg:
+            Path to the file.
+        """
+        session = Session.from_config(config)
+        assert "::" not in str(arg)
+        p = py.path.local(arg)
+        config.hook.pytest_sessionstart(session=session)
+        res = session.perform_collect([str(p)], genitems=False)[0]
+        config.hook.pytest_sessionfinish(session=session, exitstatus=ExitCode.OK)
+        return res
+
+    def getpathnode(self, path: Union[str, "os.PathLike[str]"]):
+        """Return the collection node of a file.
+
+        This is like :py:meth:`getnode` but uses :py:meth:`parseconfigure` to
+        create the (configured) pytest Config instance.
+
+        :param py.path.local path: Path to the file.
+        """
+        path = py.path.local(path)
+        config = self.parseconfigure(path)
+        session = Session.from_config(config)
+        x = session.fspath.bestrelpath(path)
+        config.hook.pytest_sessionstart(session=session)
+        res = session.perform_collect([x], genitems=False)[0]
+        config.hook.pytest_sessionfinish(session=session, exitstatus=ExitCode.OK)
+        return res
+
+    def genitems(self, colitems: Sequence[Union[Item, Collector]]) -> List[Item]:
+        """Generate all test items from a collection node.
+
+        This recurses into the collection node and returns a list of all the
+        test items contained within.
+        """
+        session = colitems[0].session
+        result: List[Item] = []
+        for colitem in colitems:
+            result.extend(session.genitems(colitem))
+        return result
+
+    def runitem(self, source: str) -> Any:
+        """Run the "test_func" Item.
+
+        The calling test instance (class containing the test method) must
+        provide a ``.getrunner()`` method which should return a runner which
+        can run the test protocol for a single item, e.g.
+        :py:func:`_pytest.runner.runtestprotocol`.
+        """
+        # used from runner functional tests
+        item = self.getitem(source)
+        # the test class where we are called from wants to provide the runner
+        testclassinstance = self._request.instance
+        runner = testclassinstance.getrunner()
+        return runner(item)
+
+    def inline_runsource(self, source: str, *cmdlineargs) -> HookRecorder:
+        """Run a test module in process using ``pytest.main()``.
+
+        This run writes "source" into a temporary file and runs
+        ``pytest.main()`` on it, returning a :py:class:`HookRecorder` instance
+        for the result.
+
+        :param source: The source code of the test module.
+
+        :param cmdlineargs: Any extra command line arguments to use.
+
+        :returns: :py:class:`HookRecorder` instance of the result.
+        """
+        p = self.makepyfile(source)
+        values = list(cmdlineargs) + [p]
+        return self.inline_run(*values)
+
+    def inline_genitems(self, *args) -> Tuple[List[Item], HookRecorder]:
+        """Run ``pytest.main(['--collectonly'])`` in-process.
+
+        Runs the :py:func:`pytest.main` function to run all of pytest inside
+        the test process itself like :py:meth:`inline_run`, but returns a
+        tuple of the collected items and a :py:class:`HookRecorder` instance.
+        """
+        rec = self.inline_run("--collect-only", *args)
+        items = [x.item for x in rec.getcalls("pytest_itemcollected")]
+        return items, rec
+
+    def inline_run(
+        self,
+        *args: Union[str, "os.PathLike[str]"],
+        plugins=(),
+        no_reraise_ctrlc: bool = False,
+    ) -> HookRecorder:
+        """Run ``pytest.main()`` in-process, returning a HookRecorder.
+
+        Runs the :py:func:`pytest.main` function to run all of pytest inside
+        the test process itself.  This means it can return a
+        :py:class:`HookRecorder` instance which gives more detailed results
+        from that run than can be done by matching stdout/stderr from
+        :py:meth:`runpytest`.
+
+        :param args:
+            Command line arguments to pass to :py:func:`pytest.main`.
+        :param plugins:
+            Extra plugin instances the ``pytest.main()`` instance should use.
+        :param no_reraise_ctrlc:
+            Typically we reraise keyboard interrupts from the child run. If
+            True, the KeyboardInterrupt exception is captured.
+
+        :returns: A :py:class:`HookRecorder` instance.
+        """
+        # (maybe a cpython bug?) the importlib cache sometimes isn't updated
+        # properly between file creation and inline_run (especially if imports
+        # are interspersed with file creation)
+        importlib.invalidate_caches()
+
+        plugins = list(plugins)
+        finalizers = []
+        try:
+            # Any sys.module or sys.path changes done while running pytest
+            # inline should be reverted after the test run completes to avoid
+            # clashing with later inline tests run within the same pytest test,
+            # e.g. just because they use matching test module names.
+            finalizers.append(self.__take_sys_modules_snapshot().restore)
+            finalizers.append(SysPathsSnapshot().restore)
+
+            # Important note:
+            # - our tests should not leave any other references/registrations
+            #   laying around other than possibly loaded test modules
+            #   referenced from sys.modules, as nothing will clean those up
+            #   automatically
+
+            rec = []
+
+            class Collect:
+                def pytest_configure(x, config: Config) -> None:
+                    rec.append(self.make_hook_recorder(config.pluginmanager))
+
+            plugins.append(Collect())
+            ret = main([str(x) for x in args], plugins=plugins)
+            if len(rec) == 1:
+                reprec = rec.pop()
+            else:
+
+                class reprec:  # type: ignore
+                    pass
+
+            reprec.ret = ret  # type: ignore
+
+            # Typically we reraise keyboard interrupts from the child run
+            # because it's our user requesting interruption of the testing.
+            if ret == ExitCode.INTERRUPTED and not no_reraise_ctrlc:
+                calls = reprec.getcalls("pytest_keyboard_interrupt")
+                if calls and calls[-1].excinfo.type == KeyboardInterrupt:
+                    raise KeyboardInterrupt()
+            return reprec
+        finally:
+            for finalizer in finalizers:
+                finalizer()
+
+    def runpytest_inprocess(
+        self, *args: Union[str, "os.PathLike[str]"], **kwargs: Any
+    ) -> RunResult:
+        """Return result of running pytest in-process, providing a similar
+        interface to what self.runpytest() provides."""
+        syspathinsert = kwargs.pop("syspathinsert", False)
+
+        if syspathinsert:
+            self.syspathinsert()
+        now = timing.time()
+        capture = _get_multicapture("sys")
+        capture.start_capturing()
+        try:
+            try:
+                reprec = self.inline_run(*args, **kwargs)
+            except SystemExit as e:
+                ret = e.args[0]
+                try:
+                    ret = ExitCode(e.args[0])
+                except ValueError:
+                    pass
+
+                class reprec:  # type: ignore
+                    ret = ret
+
+            except Exception:
+                traceback.print_exc()
+
+                class reprec:  # type: ignore
+                    ret = ExitCode(3)
+
+        finally:
+            out, err = capture.readouterr()
+            capture.stop_capturing()
+            sys.stdout.write(out)
+            sys.stderr.write(err)
+
+        assert reprec.ret is not None
+        res = RunResult(
+            reprec.ret, out.splitlines(), err.splitlines(), timing.time() - now
+        )
+        res.reprec = reprec  # type: ignore
+        return res
+
+    def runpytest(
+        self, *args: Union[str, "os.PathLike[str]"], **kwargs: Any
+    ) -> RunResult:
+        """Run pytest inline or in a subprocess, depending on the command line
+        option "--runpytest" and return a :py:class:`RunResult`."""
+        new_args = self._ensure_basetemp(args)
+        if self._method == "inprocess":
+            return self.runpytest_inprocess(*new_args, **kwargs)
+        elif self._method == "subprocess":
+            return self.runpytest_subprocess(*new_args, **kwargs)
+        raise RuntimeError(f"Unrecognized runpytest option: {self._method}")
+
+    def _ensure_basetemp(
+        self, args: Sequence[Union[str, "os.PathLike[str]"]]
+    ) -> List[Union[str, "os.PathLike[str]"]]:
+        new_args = list(args)
+        for x in new_args:
+            if str(x).startswith("--basetemp"):
+                break
+        else:
+            new_args.append("--basetemp=%s" % self.path.parent.joinpath("basetemp"))
+        return new_args
+
+    def parseconfig(self, *args: Union[str, "os.PathLike[str]"]) -> Config:
+        """Return a new pytest Config instance from given commandline args.
+
+        This invokes the pytest bootstrapping code in _pytest.config to create
+        a new :py:class:`_pytest.core.PluginManager` and call the
+        pytest_cmdline_parse hook to create a new
+        :py:class:`_pytest.config.Config` instance.
+
+        If :py:attr:`plugins` has been populated they should be plugin modules
+        to be registered with the PluginManager.
+        """
+        import _pytest.config
+
+        new_args = self._ensure_basetemp(args)
+        new_args = [str(x) for x in new_args]
+
+        config = _pytest.config._prepareconfig(new_args, self.plugins)  # type: ignore[arg-type]
+        # we don't know what the test will do with this half-setup config
+        # object and thus we make sure it gets unconfigured properly in any
+        # case (otherwise capturing could still be active, for example)
+        self._request.addfinalizer(config._ensure_unconfigure)
+        return config
+
+    def parseconfigure(self, *args: Union[str, "os.PathLike[str]"]) -> Config:
+        """Return a new pytest configured Config instance.
+
+        Returns a new :py:class:`_pytest.config.Config` instance like
+        :py:meth:`parseconfig`, but also calls the pytest_configure hook.
+        """
+        config = self.parseconfig(*args)
+        config._do_configure()
+        return config
+
+    def getitem(self, source: str, funcname: str = "test_func") -> Item:
+        """Return the test item for a test function.
+
+        Writes the source to a python file and runs pytest's collection on
+        the resulting module, returning the test item for the requested
+        function name.
+
+        :param source:
+            The module source.
+        :param funcname:
+            The name of the test function for which to return a test item.
+        """
+        items = self.getitems(source)
+        for item in items:
+            if item.name == funcname:
+                return item
+        assert 0, "{!r} item not found in module:\n{}\nitems: {}".format(
+            funcname, source, items
+        )
+
+    def getitems(self, source: str) -> List[Item]:
+        """Return all test items collected from the module.
+
+        Writes the source to a Python file and runs pytest's collection on
+        the resulting module, returning all test items contained within.
+        """
+        modcol = self.getmodulecol(source)
+        return self.genitems([modcol])
+
+    def getmodulecol(
+        self, source: Union[str, Path], configargs=(), *, withinit: bool = False
+    ):
+        """Return the module collection node for ``source``.
+
+        Writes ``source`` to a file using :py:meth:`makepyfile` and then
+        runs the pytest collection on it, returning the collection node for the
+        test module.
+
+        :param source:
+            The source code of the module to collect.
+
+        :param configargs:
+            Any extra arguments to pass to :py:meth:`parseconfigure`.
+
+        :param withinit:
+            Whether to also write an ``__init__.py`` file to the same
+            directory to ensure it is a package.
+        """
+        if isinstance(source, Path):
+            path = self.path.joinpath(source)
+            assert not withinit, "not supported for paths"
+        else:
+            kw = {self._name: str(source)}
+            path = self.makepyfile(**kw)
+        if withinit:
+            self.makepyfile(__init__="#")
+        self.config = config = self.parseconfigure(path, *configargs)
+        return self.getnode(config, path)
+
+    def collect_by_name(
+        self, modcol: Collector, name: str
+    ) -> Optional[Union[Item, Collector]]:
+        """Return the collection node for name from the module collection.
+
+        Searchs a module collection node for a collection node matching the
+        given name.
+
+        :param modcol: A module collection node; see :py:meth:`getmodulecol`.
+        :param name: The name of the node to return.
+        """
+        if modcol not in self._mod_collections:
+            self._mod_collections[modcol] = list(modcol.collect())
+        for colitem in self._mod_collections[modcol]:
+            if colitem.name == name:
+                return colitem
+        return None
+
+    def popen(
+        self,
+        cmdargs,
+        stdout: Union[int, TextIO] = subprocess.PIPE,
+        stderr: Union[int, TextIO] = subprocess.PIPE,
+        stdin=CLOSE_STDIN,
+        **kw,
+    ):
+        """Invoke subprocess.Popen.
+
+        Calls subprocess.Popen making sure the current working directory is
+        in the PYTHONPATH.
+
+        You probably want to use :py:meth:`run` instead.
+        """
+        env = os.environ.copy()
+        env["PYTHONPATH"] = os.pathsep.join(
+            filter(None, [os.getcwd(), env.get("PYTHONPATH", "")])
+        )
+        kw["env"] = env
+
+        if stdin is self.CLOSE_STDIN:
+            kw["stdin"] = subprocess.PIPE
+        elif isinstance(stdin, bytes):
+            kw["stdin"] = subprocess.PIPE
+        else:
+            kw["stdin"] = stdin
+
+        popen = subprocess.Popen(cmdargs, stdout=stdout, stderr=stderr, **kw)
+        if stdin is self.CLOSE_STDIN:
+            assert popen.stdin is not None
+            popen.stdin.close()
+        elif isinstance(stdin, bytes):
+            assert popen.stdin is not None
+            popen.stdin.write(stdin)
+
+        return popen
+
+    def run(
+        self,
+        *cmdargs: Union[str, "os.PathLike[str]"],
+        timeout: Optional[float] = None,
+        stdin=CLOSE_STDIN,
+    ) -> RunResult:
+        """Run a command with arguments.
+
+        Run a process using subprocess.Popen saving the stdout and stderr.
+
+        :param cmdargs:
+            The sequence of arguments to pass to `subprocess.Popen()`, with path-like objects
+            being converted to ``str`` automatically.
+        :param timeout:
+            The period in seconds after which to timeout and raise
+            :py:class:`Pytester.TimeoutExpired`.
+        :param stdin:
+            Optional standard input.  Bytes are being send, closing
+            the pipe, otherwise it is passed through to ``popen``.
+            Defaults to ``CLOSE_STDIN``, which translates to using a pipe
+            (``subprocess.PIPE``) that gets closed.
+
+        :rtype: RunResult
+        """
+        __tracebackhide__ = True
+
+        # TODO: Remove type ignore in next mypy release.
+        #       https://github.com/python/typeshed/pull/4582
+        cmdargs = tuple(
+            os.fspath(arg) if isinstance(arg, os.PathLike) else arg for arg in cmdargs  # type: ignore[misc]
+        )
+        p1 = self.path.joinpath("stdout")
+        p2 = self.path.joinpath("stderr")
+        print("running:", *cmdargs)
+        print("     in:", Path.cwd())
+
+        with p1.open("w", encoding="utf8") as f1, p2.open("w", encoding="utf8") as f2:
+            now = timing.time()
+            popen = self.popen(
+                cmdargs,
+                stdin=stdin,
+                stdout=f1,
+                stderr=f2,
+                close_fds=(sys.platform != "win32"),
+            )
+            if popen.stdin is not None:
+                popen.stdin.close()
+
+            def handle_timeout() -> None:
+                __tracebackhide__ = True
+
+                timeout_message = (
+                    "{seconds} second timeout expired running:"
+                    " {command}".format(seconds=timeout, command=cmdargs)
+                )
+
+                popen.kill()
+                popen.wait()
+                raise self.TimeoutExpired(timeout_message)
+
+            if timeout is None:
+                ret = popen.wait()
+            else:
+                try:
+                    ret = popen.wait(timeout)
+                except subprocess.TimeoutExpired:
+                    handle_timeout()
+
+        with p1.open(encoding="utf8") as f1, p2.open(encoding="utf8") as f2:
+            out = f1.read().splitlines()
+            err = f2.read().splitlines()
+
+        self._dump_lines(out, sys.stdout)
+        self._dump_lines(err, sys.stderr)
+
+        with contextlib.suppress(ValueError):
+            ret = ExitCode(ret)
+        return RunResult(ret, out, err, timing.time() - now)
+
+    def _dump_lines(self, lines, fp):
+        try:
+            for line in lines:
+                print(line, file=fp)
+        except UnicodeEncodeError:
+            print(f"couldn't print to {fp} because of encoding")
+
+    def _getpytestargs(self) -> Tuple[str, ...]:
+        return sys.executable, "-mpytest"
+
+    def runpython(self, script) -> RunResult:
+        """Run a python script using sys.executable as interpreter.
+
+        :rtype: RunResult
+        """
+        return self.run(sys.executable, script)
+
+    def runpython_c(self, command):
+        """Run python -c "command".
+
+        :rtype: RunResult
+        """
+        return self.run(sys.executable, "-c", command)
+
+    def runpytest_subprocess(self, *args, timeout: Optional[float] = None) -> RunResult:
+        """Run pytest as a subprocess with given arguments.
+
+        Any plugins added to the :py:attr:`plugins` list will be added using the
+        ``-p`` command line option.  Additionally ``--basetemp`` is used to put
+        any temporary files and directories in a numbered directory prefixed
+        with "runpytest-" to not conflict with the normal numbered pytest
+        location for temporary files and directories.
+
+        :param args:
+            The sequence of arguments to pass to the pytest subprocess.
+        :param timeout:
+            The period in seconds after which to timeout and raise
+            :py:class:`Pytester.TimeoutExpired`.
+
+        :rtype: RunResult
+        """
+        __tracebackhide__ = True
+        p = make_numbered_dir(root=self.path, prefix="runpytest-", mode=0o700)
+        args = ("--basetemp=%s" % p,) + args
+        plugins = [x for x in self.plugins if isinstance(x, str)]
+        if plugins:
+            args = ("-p", plugins[0]) + args
+        args = self._getpytestargs() + args
+        return self.run(*args, timeout=timeout)
+
+    def spawn_pytest(
+        self, string: str, expect_timeout: float = 10.0
+    ) -> "pexpect.spawn":
+        """Run pytest using pexpect.
+
+        This makes sure to use the right pytest and sets up the temporary
+        directory locations.
+
+        The pexpect child is returned.
+        """
+        basetemp = self.path / "temp-pexpect"
+        basetemp.mkdir(mode=0o700)
+        invoke = " ".join(map(str, self._getpytestargs()))
+        cmd = f"{invoke} --basetemp={basetemp} {string}"
+        return self.spawn(cmd, expect_timeout=expect_timeout)
+
+    def spawn(self, cmd: str, expect_timeout: float = 10.0) -> "pexpect.spawn":
+        """Run a command using pexpect.
+
+        The pexpect child is returned.
+        """
+        pexpect = importorskip("pexpect", "3.0")
+        if hasattr(sys, "pypy_version_info") and "64" in platform.machine():
+            skip("pypy-64 bit not supported")
+        if not hasattr(pexpect, "spawn"):
+            skip("pexpect.spawn not available")
+        logfile = self.path.joinpath("spawn.out").open("wb")
+
+        child = pexpect.spawn(cmd, logfile=logfile, timeout=expect_timeout)
+        self._request.addfinalizer(logfile.close)
+        return child
+
+
+class LineComp:
+    def __init__(self) -> None:
+        self.stringio = StringIO()
+        """:class:`python:io.StringIO()` instance used for input."""
+
+    def assert_contains_lines(self, lines2: Sequence[str]) -> None:
+        """Assert that ``lines2`` are contained (linearly) in :attr:`stringio`'s value.
+
+        Lines are matched using :func:`LineMatcher.fnmatch_lines`.
+        """
+        __tracebackhide__ = True
+        val = self.stringio.getvalue()
+        self.stringio.truncate(0)
+        self.stringio.seek(0)
+        lines1 = val.split("\n")
+        LineMatcher(lines1).fnmatch_lines(lines2)
+
+
+@final
+@attr.s(repr=False, str=False, init=False)
+class Testdir:
+    """
+    Similar to :class:`Pytester`, but this class works with legacy py.path.local objects instead.
+
+    All methods just forward to an internal :class:`Pytester` instance, converting results
+    to `py.path.local` objects as necessary.
+    """
+
+    __test__ = False
+
+    CLOSE_STDIN = Pytester.CLOSE_STDIN
+    TimeoutExpired = Pytester.TimeoutExpired
+    Session = Pytester.Session
+
+    def __init__(self, pytester: Pytester, *, _ispytest: bool = False) -> None:
+        check_ispytest(_ispytest)
+        self._pytester = pytester
+
+    @property
+    def tmpdir(self) -> py.path.local:
+        """Temporary directory where tests are executed."""
+        return py.path.local(self._pytester.path)
+
+    @property
+    def test_tmproot(self) -> py.path.local:
+        return py.path.local(self._pytester._test_tmproot)
+
+    @property
+    def request(self):
+        return self._pytester._request
+
+    @property
+    def plugins(self):
+        return self._pytester.plugins
+
+    @plugins.setter
+    def plugins(self, plugins):
+        self._pytester.plugins = plugins
+
+    @property
+    def monkeypatch(self) -> MonkeyPatch:
+        return self._pytester._monkeypatch
+
+    def make_hook_recorder(self, pluginmanager) -> HookRecorder:
+        """See :meth:`Pytester.make_hook_recorder`."""
+        return self._pytester.make_hook_recorder(pluginmanager)
+
+    def chdir(self) -> None:
+        """See :meth:`Pytester.chdir`."""
+        return self._pytester.chdir()
+
+    def finalize(self) -> None:
+        """See :meth:`Pytester._finalize`."""
+        return self._pytester._finalize()
+
+    def makefile(self, ext, *args, **kwargs) -> py.path.local:
+        """See :meth:`Pytester.makefile`."""
+        return py.path.local(str(self._pytester.makefile(ext, *args, **kwargs)))
+
+    def makeconftest(self, source) -> py.path.local:
+        """See :meth:`Pytester.makeconftest`."""
+        return py.path.local(str(self._pytester.makeconftest(source)))
+
+    def makeini(self, source) -> py.path.local:
+        """See :meth:`Pytester.makeini`."""
+        return py.path.local(str(self._pytester.makeini(source)))
+
+    def getinicfg(self, source: str) -> SectionWrapper:
+        """See :meth:`Pytester.getinicfg`."""
+        return self._pytester.getinicfg(source)
+
+    def makepyprojecttoml(self, source) -> py.path.local:
+        """See :meth:`Pytester.makepyprojecttoml`."""
+        return py.path.local(str(self._pytester.makepyprojecttoml(source)))
+
+    def makepyfile(self, *args, **kwargs) -> py.path.local:
+        """See :meth:`Pytester.makepyfile`."""
+        return py.path.local(str(self._pytester.makepyfile(*args, **kwargs)))
+
+    def maketxtfile(self, *args, **kwargs) -> py.path.local:
+        """See :meth:`Pytester.maketxtfile`."""
+        return py.path.local(str(self._pytester.maketxtfile(*args, **kwargs)))
+
+    def syspathinsert(self, path=None) -> None:
+        """See :meth:`Pytester.syspathinsert`."""
+        return self._pytester.syspathinsert(path)
+
+    def mkdir(self, name) -> py.path.local:
+        """See :meth:`Pytester.mkdir`."""
+        return py.path.local(str(self._pytester.mkdir(name)))
+
+    def mkpydir(self, name) -> py.path.local:
+        """See :meth:`Pytester.mkpydir`."""
+        return py.path.local(str(self._pytester.mkpydir(name)))
+
+    def copy_example(self, name=None) -> py.path.local:
+        """See :meth:`Pytester.copy_example`."""
+        return py.path.local(str(self._pytester.copy_example(name)))
+
+    def getnode(self, config: Config, arg) -> Optional[Union[Item, Collector]]:
+        """See :meth:`Pytester.getnode`."""
+        return self._pytester.getnode(config, arg)
+
+    def getpathnode(self, path):
+        """See :meth:`Pytester.getpathnode`."""
+        return self._pytester.getpathnode(path)
+
+    def genitems(self, colitems: List[Union[Item, Collector]]) -> List[Item]:
+        """See :meth:`Pytester.genitems`."""
+        return self._pytester.genitems(colitems)
+
+    def runitem(self, source):
+        """See :meth:`Pytester.runitem`."""
+        return self._pytester.runitem(source)
+
+    def inline_runsource(self, source, *cmdlineargs):
+        """See :meth:`Pytester.inline_runsource`."""
+        return self._pytester.inline_runsource(source, *cmdlineargs)
+
+    def inline_genitems(self, *args):
+        """See :meth:`Pytester.inline_genitems`."""
+        return self._pytester.inline_genitems(*args)
+
+    def inline_run(self, *args, plugins=(), no_reraise_ctrlc: bool = False):
+        """See :meth:`Pytester.inline_run`."""
+        return self._pytester.inline_run(
+            *args, plugins=plugins, no_reraise_ctrlc=no_reraise_ctrlc
+        )
+
+    def runpytest_inprocess(self, *args, **kwargs) -> RunResult:
+        """See :meth:`Pytester.runpytest_inprocess`."""
+        return self._pytester.runpytest_inprocess(*args, **kwargs)
+
+    def runpytest(self, *args, **kwargs) -> RunResult:
+        """See :meth:`Pytester.runpytest`."""
+        return self._pytester.runpytest(*args, **kwargs)
+
+    def parseconfig(self, *args) -> Config:
+        """See :meth:`Pytester.parseconfig`."""
+        return self._pytester.parseconfig(*args)
+
+    def parseconfigure(self, *args) -> Config:
+        """See :meth:`Pytester.parseconfigure`."""
+        return self._pytester.parseconfigure(*args)
+
+    def getitem(self, source, funcname="test_func"):
+        """See :meth:`Pytester.getitem`."""
+        return self._pytester.getitem(source, funcname)
+
+    def getitems(self, source):
+        """See :meth:`Pytester.getitems`."""
+        return self._pytester.getitems(source)
+
+    def getmodulecol(self, source, configargs=(), withinit=False):
+        """See :meth:`Pytester.getmodulecol`."""
+        return self._pytester.getmodulecol(
+            source, configargs=configargs, withinit=withinit
+        )
+
+    def collect_by_name(
+        self, modcol: Collector, name: str
+    ) -> Optional[Union[Item, Collector]]:
+        """See :meth:`Pytester.collect_by_name`."""
+        return self._pytester.collect_by_name(modcol, name)
+
+    def popen(
+        self,
+        cmdargs,
+        stdout: Union[int, TextIO] = subprocess.PIPE,
+        stderr: Union[int, TextIO] = subprocess.PIPE,
+        stdin=CLOSE_STDIN,
+        **kw,
+    ):
+        """See :meth:`Pytester.popen`."""
+        return self._pytester.popen(cmdargs, stdout, stderr, stdin, **kw)
+
+    def run(self, *cmdargs, timeout=None, stdin=CLOSE_STDIN) -> RunResult:
+        """See :meth:`Pytester.run`."""
+        return self._pytester.run(*cmdargs, timeout=timeout, stdin=stdin)
+
+    def runpython(self, script) -> RunResult:
+        """See :meth:`Pytester.runpython`."""
+        return self._pytester.runpython(script)
+
+    def runpython_c(self, command):
+        """See :meth:`Pytester.runpython_c`."""
+        return self._pytester.runpython_c(command)
+
+    def runpytest_subprocess(self, *args, timeout=None) -> RunResult:
+        """See :meth:`Pytester.runpytest_subprocess`."""
+        return self._pytester.runpytest_subprocess(*args, timeout=timeout)
+
+    def spawn_pytest(
+        self, string: str, expect_timeout: float = 10.0
+    ) -> "pexpect.spawn":
+        """See :meth:`Pytester.spawn_pytest`."""
+        return self._pytester.spawn_pytest(string, expect_timeout=expect_timeout)
+
+    def spawn(self, cmd: str, expect_timeout: float = 10.0) -> "pexpect.spawn":
+        """See :meth:`Pytester.spawn`."""
+        return self._pytester.spawn(cmd, expect_timeout=expect_timeout)
+
+    def __repr__(self) -> str:
+        return f"<Testdir {self.tmpdir!r}>"
+
+    def __str__(self) -> str:
+        return str(self.tmpdir)
+
+
+class LineMatcher:
+    """Flexible matching of text.
+
+    This is a convenience class to test large texts like the output of
+    commands.
+
+    The constructor takes a list of lines without their trailing newlines, i.e.
+    ``text.splitlines()``.
+    """
+
+    def __init__(self, lines: List[str]) -> None:
+        self.lines = lines
+        self._log_output: List[str] = []
+
+    def __str__(self) -> str:
+        """Return the entire original text.
+
+        .. versionadded:: 6.2
+            You can use :meth:`str` in older versions.
+        """
+        return "\n".join(self.lines)
+
+    def _getlines(self, lines2: Union[str, Sequence[str], Source]) -> Sequence[str]:
+        if isinstance(lines2, str):
+            lines2 = Source(lines2)
+        if isinstance(lines2, Source):
+            lines2 = lines2.strip().lines
+        return lines2
+
+    def fnmatch_lines_random(self, lines2: Sequence[str]) -> None:
+        """Check lines exist in the output in any order (using :func:`python:fnmatch.fnmatch`)."""
+        __tracebackhide__ = True
+        self._match_lines_random(lines2, fnmatch)
+
+    def re_match_lines_random(self, lines2: Sequence[str]) -> None:
+        """Check lines exist in the output in any order (using :func:`python:re.match`)."""
+        __tracebackhide__ = True
+        self._match_lines_random(lines2, lambda name, pat: bool(re.match(pat, name)))
+
+    def _match_lines_random(
+        self, lines2: Sequence[str], match_func: Callable[[str, str], bool]
+    ) -> None:
+        __tracebackhide__ = True
+        lines2 = self._getlines(lines2)
+        for line in lines2:
+            for x in self.lines:
+                if line == x or match_func(x, line):
+                    self._log("matched: ", repr(line))
+                    break
+            else:
+                msg = "line %r not found in output" % line
+                self._log(msg)
+                self._fail(msg)
+
+    def get_lines_after(self, fnline: str) -> Sequence[str]:
+        """Return all lines following the given line in the text.
+
+        The given line can contain glob wildcards.
+        """
+        for i, line in enumerate(self.lines):
+            if fnline == line or fnmatch(line, fnline):
+                return self.lines[i + 1 :]
+        raise ValueError("line %r not found in output" % fnline)
+
+    def _log(self, *args) -> None:
+        self._log_output.append(" ".join(str(x) for x in args))
+
+    @property
+    def _log_text(self) -> str:
+        return "\n".join(self._log_output)
+
+    def fnmatch_lines(
+        self, lines2: Sequence[str], *, consecutive: bool = False
+    ) -> None:
+        """Check lines exist in the output (using :func:`python:fnmatch.fnmatch`).
+
+        The argument is a list of lines which have to match and can use glob
+        wildcards.  If they do not match a pytest.fail() is called.  The
+        matches and non-matches are also shown as part of the error message.
+
+        :param lines2: String patterns to match.
+        :param consecutive: Match lines consecutively?
+        """
+        __tracebackhide__ = True
+        self._match_lines(lines2, fnmatch, "fnmatch", consecutive=consecutive)
+
+    def re_match_lines(
+        self, lines2: Sequence[str], *, consecutive: bool = False
+    ) -> None:
+        """Check lines exist in the output (using :func:`python:re.match`).
+
+        The argument is a list of lines which have to match using ``re.match``.
+        If they do not match a pytest.fail() is called.
+
+        The matches and non-matches are also shown as part of the error message.
+
+        :param lines2: string patterns to match.
+        :param consecutive: match lines consecutively?
+        """
+        __tracebackhide__ = True
+        self._match_lines(
+            lines2,
+            lambda name, pat: bool(re.match(pat, name)),
+            "re.match",
+            consecutive=consecutive,
+        )
+
+    def _match_lines(
+        self,
+        lines2: Sequence[str],
+        match_func: Callable[[str, str], bool],
+        match_nickname: str,
+        *,
+        consecutive: bool = False,
+    ) -> None:
+        """Underlying implementation of ``fnmatch_lines`` and ``re_match_lines``.
+
+        :param Sequence[str] lines2:
+            List of string patterns to match. The actual format depends on
+            ``match_func``.
+        :param match_func:
+            A callable ``match_func(line, pattern)`` where line is the
+            captured line from stdout/stderr and pattern is the matching
+            pattern.
+        :param str match_nickname:
+            The nickname for the match function that will be logged to stdout
+            when a match occurs.
+        :param consecutive:
+            Match lines consecutively?
+        """
+        if not isinstance(lines2, collections.abc.Sequence):
+            raise TypeError("invalid type for lines2: {}".format(type(lines2).__name__))
+        lines2 = self._getlines(lines2)
+        lines1 = self.lines[:]
+        extralines = []
+        __tracebackhide__ = True
+        wnick = len(match_nickname) + 1
+        started = False
+        for line in lines2:
+            nomatchprinted = False
+            while lines1:
+                nextline = lines1.pop(0)
+                if line == nextline:
+                    self._log("exact match:", repr(line))
+                    started = True
+                    break
+                elif match_func(nextline, line):
+                    self._log("%s:" % match_nickname, repr(line))
+                    self._log(
+                        "{:>{width}}".format("with:", width=wnick), repr(nextline)
+                    )
+                    started = True
+                    break
+                else:
+                    if consecutive and started:
+                        msg = f"no consecutive match: {line!r}"
+                        self._log(msg)
+                        self._log(
+                            "{:>{width}}".format("with:", width=wnick), repr(nextline)
+                        )
+                        self._fail(msg)
+                    if not nomatchprinted:
+                        self._log(
+                            "{:>{width}}".format("nomatch:", width=wnick), repr(line)
+                        )
+                        nomatchprinted = True
+                    self._log("{:>{width}}".format("and:", width=wnick), repr(nextline))
+                extralines.append(nextline)
+            else:
+                msg = f"remains unmatched: {line!r}"
+                self._log(msg)
+                self._fail(msg)
+        self._log_output = []
+
+    def no_fnmatch_line(self, pat: str) -> None:
+        """Ensure captured lines do not match the given pattern, using ``fnmatch.fnmatch``.
+
+        :param str pat: The pattern to match lines.
+        """
+        __tracebackhide__ = True
+        self._no_match_line(pat, fnmatch, "fnmatch")
+
+    def no_re_match_line(self, pat: str) -> None:
+        """Ensure captured lines do not match the given pattern, using ``re.match``.
+
+        :param str pat: The regular expression to match lines.
+        """
+        __tracebackhide__ = True
+        self._no_match_line(
+            pat, lambda name, pat: bool(re.match(pat, name)), "re.match"
+        )
+
+    def _no_match_line(
+        self, pat: str, match_func: Callable[[str, str], bool], match_nickname: str
+    ) -> None:
+        """Ensure captured lines does not have a the given pattern, using ``fnmatch.fnmatch``.
+
+        :param str pat: The pattern to match lines.
+        """
+        __tracebackhide__ = True
+        nomatch_printed = False
+        wnick = len(match_nickname) + 1
+        for line in self.lines:
+            if match_func(line, pat):
+                msg = f"{match_nickname}: {pat!r}"
+                self._log(msg)
+                self._log("{:>{width}}".format("with:", width=wnick), repr(line))
+                self._fail(msg)
+            else:
+                if not nomatch_printed:
+                    self._log("{:>{width}}".format("nomatch:", width=wnick), repr(pat))
+                    nomatch_printed = True
+                self._log("{:>{width}}".format("and:", width=wnick), repr(line))
+        self._log_output = []
+
+    def _fail(self, msg: str) -> None:
+        __tracebackhide__ = True
+        log_text = self._log_text
+        self._log_output = []
+        fail(log_text)
+
+    def str(self) -> str:
+        """Return the entire original text."""
+        return str(self)
diff --git a/myenv/lib/python3.9/site-packages/_pytest/pytester_assertions.py b/myenv/lib/python3.9/site-packages/_pytest/pytester_assertions.py
new file mode 100644
index 0000000..630c1d3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/pytester_assertions.py
@@ -0,0 +1,66 @@
+"""Helper plugin for pytester; should not be loaded on its own."""
+# This plugin contains assertions used by pytester. pytester cannot
+# contain them itself, since it is imported by the `pytest` module,
+# hence cannot be subject to assertion rewriting, which requires a
+# module to not be already imported.
+from typing import Dict
+from typing import Sequence
+from typing import Tuple
+from typing import Union
+
+from _pytest.reports import CollectReport
+from _pytest.reports import TestReport
+
+
+def assertoutcome(
+    outcomes: Tuple[
+        Sequence[TestReport],
+        Sequence[Union[CollectReport, TestReport]],
+        Sequence[Union[CollectReport, TestReport]],
+    ],
+    passed: int = 0,
+    skipped: int = 0,
+    failed: int = 0,
+) -> None:
+    __tracebackhide__ = True
+
+    realpassed, realskipped, realfailed = outcomes
+    obtained = {
+        "passed": len(realpassed),
+        "skipped": len(realskipped),
+        "failed": len(realfailed),
+    }
+    expected = {"passed": passed, "skipped": skipped, "failed": failed}
+    assert obtained == expected, outcomes
+
+
+def assert_outcomes(
+    outcomes: Dict[str, int],
+    passed: int = 0,
+    skipped: int = 0,
+    failed: int = 0,
+    errors: int = 0,
+    xpassed: int = 0,
+    xfailed: int = 0,
+) -> None:
+    """Assert that the specified outcomes appear with the respective
+    numbers (0 means it didn't occur) in the text output from a test run."""
+    __tracebackhide__ = True
+
+    obtained = {
+        "passed": outcomes.get("passed", 0),
+        "skipped": outcomes.get("skipped", 0),
+        "failed": outcomes.get("failed", 0),
+        "errors": outcomes.get("errors", 0),
+        "xpassed": outcomes.get("xpassed", 0),
+        "xfailed": outcomes.get("xfailed", 0),
+    }
+    expected = {
+        "passed": passed,
+        "skipped": skipped,
+        "failed": failed,
+        "errors": errors,
+        "xpassed": xpassed,
+        "xfailed": xfailed,
+    }
+    assert obtained == expected
diff --git a/myenv/lib/python3.9/site-packages/_pytest/python.py b/myenv/lib/python3.9/site-packages/_pytest/python.py
new file mode 100644
index 0000000..e48e753
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/python.py
@@ -0,0 +1,1689 @@
+"""Python test discovery, setup and run of test functions."""
+import enum
+import fnmatch
+import inspect
+import itertools
+import os
+import sys
+import types
+import warnings
+from collections import Counter
+from collections import defaultdict
+from functools import partial
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import Generator
+from typing import Iterable
+from typing import Iterator
+from typing import List
+from typing import Mapping
+from typing import Optional
+from typing import Sequence
+from typing import Set
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import Union
+
+import py
+
+import _pytest
+from _pytest import fixtures
+from _pytest import nodes
+from _pytest._code import filter_traceback
+from _pytest._code import getfslineno
+from _pytest._code.code import ExceptionInfo
+from _pytest._code.code import TerminalRepr
+from _pytest._io import TerminalWriter
+from _pytest._io.saferepr import saferepr
+from _pytest.compat import ascii_escaped
+from _pytest.compat import final
+from _pytest.compat import get_default_arg_names
+from _pytest.compat import get_real_func
+from _pytest.compat import getimfunc
+from _pytest.compat import getlocation
+from _pytest.compat import is_async_function
+from _pytest.compat import is_generator
+from _pytest.compat import NOTSET
+from _pytest.compat import REGEX_TYPE
+from _pytest.compat import safe_getattr
+from _pytest.compat import safe_isclass
+from _pytest.compat import STRING_TYPES
+from _pytest.config import Config
+from _pytest.config import ExitCode
+from _pytest.config import hookimpl
+from _pytest.config.argparsing import Parser
+from _pytest.deprecated import FSCOLLECTOR_GETHOOKPROXY_ISINITPATH
+from _pytest.fixtures import FuncFixtureInfo
+from _pytest.main import Session
+from _pytest.mark import MARK_GEN
+from _pytest.mark import ParameterSet
+from _pytest.mark.structures import get_unpacked_marks
+from _pytest.mark.structures import Mark
+from _pytest.mark.structures import MarkDecorator
+from _pytest.mark.structures import normalize_mark_list
+from _pytest.outcomes import fail
+from _pytest.outcomes import skip
+from _pytest.pathlib import import_path
+from _pytest.pathlib import ImportPathMismatchError
+from _pytest.pathlib import parts
+from _pytest.pathlib import visit
+from _pytest.warning_types import PytestCollectionWarning
+from _pytest.warning_types import PytestUnhandledCoroutineWarning
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+    from _pytest.fixtures import _Scope
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("general")
+    group.addoption(
+        "--fixtures",
+        "--funcargs",
+        action="store_true",
+        dest="showfixtures",
+        default=False,
+        help="show available fixtures, sorted by plugin appearance "
+        "(fixtures with leading '_' are only shown with '-v')",
+    )
+    group.addoption(
+        "--fixtures-per-test",
+        action="store_true",
+        dest="show_fixtures_per_test",
+        default=False,
+        help="show fixtures per test",
+    )
+    parser.addini(
+        "python_files",
+        type="args",
+        # NOTE: default is also used in AssertionRewritingHook.
+        default=["test_*.py", "*_test.py"],
+        help="glob-style file patterns for Python test module discovery",
+    )
+    parser.addini(
+        "python_classes",
+        type="args",
+        default=["Test"],
+        help="prefixes or glob names for Python test class discovery",
+    )
+    parser.addini(
+        "python_functions",
+        type="args",
+        default=["test"],
+        help="prefixes or glob names for Python test function and method discovery",
+    )
+    parser.addini(
+        "disable_test_id_escaping_and_forfeit_all_rights_to_community_support",
+        type="bool",
+        default=False,
+        help="disable string escape non-ascii characters, might cause unwanted "
+        "side effects(use at your own risk)",
+    )
+
+
+def pytest_cmdline_main(config: Config) -> Optional[Union[int, ExitCode]]:
+    if config.option.showfixtures:
+        showfixtures(config)
+        return 0
+    if config.option.show_fixtures_per_test:
+        show_fixtures_per_test(config)
+        return 0
+    return None
+
+
+def pytest_generate_tests(metafunc: "Metafunc") -> None:
+    for marker in metafunc.definition.iter_markers(name="parametrize"):
+        # TODO: Fix this type-ignore (overlapping kwargs).
+        metafunc.parametrize(*marker.args, **marker.kwargs, _param_mark=marker)  # type: ignore[misc]
+
+
+def pytest_configure(config: Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "parametrize(argnames, argvalues): call a test function multiple "
+        "times passing in different arguments in turn. argvalues generally "
+        "needs to be a list of values if argnames specifies only one name "
+        "or a list of tuples of values if argnames specifies multiple names. "
+        "Example: @parametrize('arg1', [1,2]) would lead to two calls of the "
+        "decorated test function, one with arg1=1 and another with arg1=2."
+        "see https://docs.pytest.org/en/stable/parametrize.html for more info "
+        "and examples.",
+    )
+    config.addinivalue_line(
+        "markers",
+        "usefixtures(fixturename1, fixturename2, ...): mark tests as needing "
+        "all of the specified fixtures. see "
+        "https://docs.pytest.org/en/stable/fixture.html#usefixtures ",
+    )
+
+
+def async_warn_and_skip(nodeid: str) -> None:
+    msg = "async def functions are not natively supported and have been skipped.\n"
+    msg += (
+        "You need to install a suitable plugin for your async framework, for example:\n"
+    )
+    msg += "  - anyio\n"
+    msg += "  - pytest-asyncio\n"
+    msg += "  - pytest-tornasync\n"
+    msg += "  - pytest-trio\n"
+    msg += "  - pytest-twisted"
+    warnings.warn(PytestUnhandledCoroutineWarning(msg.format(nodeid)))
+    skip(msg="async def function and no async plugin installed (see warnings)")
+
+
+@hookimpl(trylast=True)
+def pytest_pyfunc_call(pyfuncitem: "Function") -> Optional[object]:
+    testfunction = pyfuncitem.obj
+    if is_async_function(testfunction):
+        async_warn_and_skip(pyfuncitem.nodeid)
+    funcargs = pyfuncitem.funcargs
+    testargs = {arg: funcargs[arg] for arg in pyfuncitem._fixtureinfo.argnames}
+    result = testfunction(**testargs)
+    if hasattr(result, "__await__") or hasattr(result, "__aiter__"):
+        async_warn_and_skip(pyfuncitem.nodeid)
+    return True
+
+
+def pytest_collect_file(
+    path: py.path.local, parent: nodes.Collector
+) -> Optional["Module"]:
+    ext = path.ext
+    if ext == ".py":
+        if not parent.session.isinitpath(path):
+            if not path_matches_patterns(
+                path, parent.config.getini("python_files") + ["__init__.py"]
+            ):
+                return None
+        ihook = parent.session.gethookproxy(path)
+        module: Module = ihook.pytest_pycollect_makemodule(path=path, parent=parent)
+        return module
+    return None
+
+
+def path_matches_patterns(path: py.path.local, patterns: Iterable[str]) -> bool:
+    """Return whether path matches any of the patterns in the list of globs given."""
+    return any(path.fnmatch(pattern) for pattern in patterns)
+
+
+def pytest_pycollect_makemodule(path: py.path.local, parent) -> "Module":
+    if path.basename == "__init__.py":
+        pkg: Package = Package.from_parent(parent, fspath=path)
+        return pkg
+    mod: Module = Module.from_parent(parent, fspath=path)
+    return mod
+
+
+@hookimpl(trylast=True)
+def pytest_pycollect_makeitem(collector: "PyCollector", name: str, obj: object):
+    # Nothing was collected elsewhere, let's do it here.
+    if safe_isclass(obj):
+        if collector.istestclass(obj, name):
+            return Class.from_parent(collector, name=name, obj=obj)
+    elif collector.istestfunction(obj, name):
+        # mock seems to store unbound methods (issue473), normalize it.
+        obj = getattr(obj, "__func__", obj)
+        # We need to try and unwrap the function if it's a functools.partial
+        # or a functools.wrapped.
+        # We mustn't if it's been wrapped with mock.patch (python 2 only).
+        if not (inspect.isfunction(obj) or inspect.isfunction(get_real_func(obj))):
+            filename, lineno = getfslineno(obj)
+            warnings.warn_explicit(
+                message=PytestCollectionWarning(
+                    "cannot collect %r because it is not a function." % name
+                ),
+                category=None,
+                filename=str(filename),
+                lineno=lineno + 1,
+            )
+        elif getattr(obj, "__test__", True):
+            if is_generator(obj):
+                res = Function.from_parent(collector, name=name)
+                reason = "yield tests were removed in pytest 4.0 - {name} will be ignored".format(
+                    name=name
+                )
+                res.add_marker(MARK_GEN.xfail(run=False, reason=reason))
+                res.warn(PytestCollectionWarning(reason))
+            else:
+                res = list(collector._genfunctions(name, obj))
+            return res
+
+
+class PyobjMixin:
+    _ALLOW_MARKERS = True
+
+    # Function and attributes that the mixin needs (for type-checking only).
+    if TYPE_CHECKING:
+        name: str = ""
+        parent: Optional[nodes.Node] = None
+        own_markers: List[Mark] = []
+
+        def getparent(self, cls: Type[nodes._NodeType]) -> Optional[nodes._NodeType]:
+            ...
+
+        def listchain(self) -> List[nodes.Node]:
+            ...
+
+    @property
+    def module(self):
+        """Python module object this node was collected from (can be None)."""
+        node = self.getparent(Module)
+        return node.obj if node is not None else None
+
+    @property
+    def cls(self):
+        """Python class object this node was collected from (can be None)."""
+        node = self.getparent(Class)
+        return node.obj if node is not None else None
+
+    @property
+    def instance(self):
+        """Python instance object this node was collected from (can be None)."""
+        node = self.getparent(Instance)
+        return node.obj if node is not None else None
+
+    @property
+    def obj(self):
+        """Underlying Python object."""
+        obj = getattr(self, "_obj", None)
+        if obj is None:
+            self._obj = obj = self._getobj()
+            # XXX evil hack
+            # used to avoid Instance collector marker duplication
+            if self._ALLOW_MARKERS:
+                self.own_markers.extend(get_unpacked_marks(self.obj))
+        return obj
+
+    @obj.setter
+    def obj(self, value):
+        self._obj = value
+
+    def _getobj(self):
+        """Get the underlying Python object. May be overwritten by subclasses."""
+        # TODO: Improve the type of `parent` such that assert/ignore aren't needed.
+        assert self.parent is not None
+        obj = self.parent.obj  # type: ignore[attr-defined]
+        return getattr(obj, self.name)
+
+    def getmodpath(self, stopatmodule: bool = True, includemodule: bool = False) -> str:
+        """Return Python path relative to the containing module."""
+        chain = self.listchain()
+        chain.reverse()
+        parts = []
+        for node in chain:
+            if isinstance(node, Instance):
+                continue
+            name = node.name
+            if isinstance(node, Module):
+                name = os.path.splitext(name)[0]
+                if stopatmodule:
+                    if includemodule:
+                        parts.append(name)
+                    break
+            parts.append(name)
+        parts.reverse()
+        return ".".join(parts)
+
+    def reportinfo(self) -> Tuple[Union[py.path.local, str], int, str]:
+        # XXX caching?
+        obj = self.obj
+        compat_co_firstlineno = getattr(obj, "compat_co_firstlineno", None)
+        if isinstance(compat_co_firstlineno, int):
+            # nose compatibility
+            file_path = sys.modules[obj.__module__].__file__
+            if file_path.endswith(".pyc"):
+                file_path = file_path[:-1]
+            fspath: Union[py.path.local, str] = file_path
+            lineno = compat_co_firstlineno
+        else:
+            fspath, lineno = getfslineno(obj)
+        modpath = self.getmodpath()
+        assert isinstance(lineno, int)
+        return fspath, lineno, modpath
+
+
+# As an optimization, these builtin attribute names are pre-ignored when
+# iterating over an object during collection -- the pytest_pycollect_makeitem
+# hook is not called for them.
+# fmt: off
+class _EmptyClass: pass  # noqa: E701
+IGNORED_ATTRIBUTES = frozenset.union(  # noqa: E305
+    frozenset(),
+    # Module.
+    dir(types.ModuleType("empty_module")),
+    # Some extra module attributes the above doesn't catch.
+    {"__builtins__", "__file__", "__cached__"},
+    # Class.
+    dir(_EmptyClass),
+    # Instance.
+    dir(_EmptyClass()),
+)
+del _EmptyClass
+# fmt: on
+
+
+class PyCollector(PyobjMixin, nodes.Collector):
+    def funcnamefilter(self, name: str) -> bool:
+        return self._matches_prefix_or_glob_option("python_functions", name)
+
+    def isnosetest(self, obj: object) -> bool:
+        """Look for the __test__ attribute, which is applied by the
+        @nose.tools.istest decorator.
+        """
+        # We explicitly check for "is True" here to not mistakenly treat
+        # classes with a custom __getattr__ returning something truthy (like a
+        # function) as test classes.
+        return safe_getattr(obj, "__test__", False) is True
+
+    def classnamefilter(self, name: str) -> bool:
+        return self._matches_prefix_or_glob_option("python_classes", name)
+
+    def istestfunction(self, obj: object, name: str) -> bool:
+        if self.funcnamefilter(name) or self.isnosetest(obj):
+            if isinstance(obj, staticmethod):
+                # staticmethods need to be unwrapped.
+                obj = safe_getattr(obj, "__func__", False)
+            return (
+                safe_getattr(obj, "__call__", False)
+                and fixtures.getfixturemarker(obj) is None
+            )
+        else:
+            return False
+
+    def istestclass(self, obj: object, name: str) -> bool:
+        return self.classnamefilter(name) or self.isnosetest(obj)
+
+    def _matches_prefix_or_glob_option(self, option_name: str, name: str) -> bool:
+        """Check if the given name matches the prefix or glob-pattern defined
+        in ini configuration."""
+        for option in self.config.getini(option_name):
+            if name.startswith(option):
+                return True
+            # Check that name looks like a glob-string before calling fnmatch
+            # because this is called for every name in each collected module,
+            # and fnmatch is somewhat expensive to call.
+            elif ("*" in option or "?" in option or "[" in option) and fnmatch.fnmatch(
+                name, option
+            ):
+                return True
+        return False
+
+    def collect(self) -> Iterable[Union[nodes.Item, nodes.Collector]]:
+        if not getattr(self.obj, "__test__", True):
+            return []
+
+        # NB. we avoid random getattrs and peek in the __dict__ instead
+        # (XXX originally introduced from a PyPy need, still true?)
+        dicts = [getattr(self.obj, "__dict__", {})]
+        for basecls in self.obj.__class__.__mro__:
+            dicts.append(basecls.__dict__)
+        seen: Set[str] = set()
+        values: List[Union[nodes.Item, nodes.Collector]] = []
+        ihook = self.ihook
+        for dic in dicts:
+            # Note: seems like the dict can change during iteration -
+            # be careful not to remove the list() without consideration.
+            for name, obj in list(dic.items()):
+                if name in IGNORED_ATTRIBUTES:
+                    continue
+                if name in seen:
+                    continue
+                seen.add(name)
+                res = ihook.pytest_pycollect_makeitem(
+                    collector=self, name=name, obj=obj
+                )
+                if res is None:
+                    continue
+                elif isinstance(res, list):
+                    values.extend(res)
+                else:
+                    values.append(res)
+
+        def sort_key(item):
+            fspath, lineno, _ = item.reportinfo()
+            return (str(fspath), lineno)
+
+        values.sort(key=sort_key)
+        return values
+
+    def _genfunctions(self, name: str, funcobj) -> Iterator["Function"]:
+        modulecol = self.getparent(Module)
+        assert modulecol is not None
+        module = modulecol.obj
+        clscol = self.getparent(Class)
+        cls = clscol and clscol.obj or None
+        fm = self.session._fixturemanager
+
+        definition = FunctionDefinition.from_parent(self, name=name, callobj=funcobj)
+        fixtureinfo = definition._fixtureinfo
+
+        metafunc = Metafunc(
+            definition, fixtureinfo, self.config, cls=cls, module=module
+        )
+        methods = []
+        if hasattr(module, "pytest_generate_tests"):
+            methods.append(module.pytest_generate_tests)
+        if cls is not None and hasattr(cls, "pytest_generate_tests"):
+            methods.append(cls().pytest_generate_tests)
+
+        self.ihook.pytest_generate_tests.call_extra(methods, dict(metafunc=metafunc))
+
+        if not metafunc._calls:
+            yield Function.from_parent(self, name=name, fixtureinfo=fixtureinfo)
+        else:
+            # Add funcargs() as fixturedefs to fixtureinfo.arg2fixturedefs.
+            fixtures.add_funcarg_pseudo_fixture_def(self, metafunc, fm)
+
+            # Add_funcarg_pseudo_fixture_def may have shadowed some fixtures
+            # with direct parametrization, so make sure we update what the
+            # function really needs.
+            fixtureinfo.prune_dependency_tree()
+
+            for callspec in metafunc._calls:
+                subname = f"{name}[{callspec.id}]"
+                yield Function.from_parent(
+                    self,
+                    name=subname,
+                    callspec=callspec,
+                    callobj=funcobj,
+                    fixtureinfo=fixtureinfo,
+                    keywords={callspec.id: True},
+                    originalname=name,
+                )
+
+
+class Module(nodes.File, PyCollector):
+    """Collector for test classes and functions."""
+
+    def _getobj(self):
+        return self._importtestmodule()
+
+    def collect(self) -> Iterable[Union[nodes.Item, nodes.Collector]]:
+        self._inject_setup_module_fixture()
+        self._inject_setup_function_fixture()
+        self.session._fixturemanager.parsefactories(self)
+        return super().collect()
+
+    def _inject_setup_module_fixture(self) -> None:
+        """Inject a hidden autouse, module scoped fixture into the collected module object
+        that invokes setUpModule/tearDownModule if either or both are available.
+
+        Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with
+        other fixtures (#517).
+        """
+        setup_module = _get_first_non_fixture_func(
+            self.obj, ("setUpModule", "setup_module")
+        )
+        teardown_module = _get_first_non_fixture_func(
+            self.obj, ("tearDownModule", "teardown_module")
+        )
+
+        if setup_module is None and teardown_module is None:
+            return
+
+        @fixtures.fixture(
+            autouse=True,
+            scope="module",
+            # Use a unique name to speed up lookup.
+            name=f"xunit_setup_module_fixture_{self.obj.__name__}",
+        )
+        def xunit_setup_module_fixture(request) -> Generator[None, None, None]:
+            if setup_module is not None:
+                _call_with_optional_argument(setup_module, request.module)
+            yield
+            if teardown_module is not None:
+                _call_with_optional_argument(teardown_module, request.module)
+
+        self.obj.__pytest_setup_module = xunit_setup_module_fixture
+
+    def _inject_setup_function_fixture(self) -> None:
+        """Inject a hidden autouse, function scoped fixture into the collected module object
+        that invokes setup_function/teardown_function if either or both are available.
+
+        Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with
+        other fixtures (#517).
+        """
+        setup_function = _get_first_non_fixture_func(self.obj, ("setup_function",))
+        teardown_function = _get_first_non_fixture_func(
+            self.obj, ("teardown_function",)
+        )
+        if setup_function is None and teardown_function is None:
+            return
+
+        @fixtures.fixture(
+            autouse=True,
+            scope="function",
+            # Use a unique name to speed up lookup.
+            name=f"xunit_setup_function_fixture_{self.obj.__name__}",
+        )
+        def xunit_setup_function_fixture(request) -> Generator[None, None, None]:
+            if request.instance is not None:
+                # in this case we are bound to an instance, so we need to let
+                # setup_method handle this
+                yield
+                return
+            if setup_function is not None:
+                _call_with_optional_argument(setup_function, request.function)
+            yield
+            if teardown_function is not None:
+                _call_with_optional_argument(teardown_function, request.function)
+
+        self.obj.__pytest_setup_function = xunit_setup_function_fixture
+
+    def _importtestmodule(self):
+        # We assume we are only called once per module.
+        importmode = self.config.getoption("--import-mode")
+        try:
+            mod = import_path(self.fspath, mode=importmode)
+        except SyntaxError as e:
+            raise self.CollectError(
+                ExceptionInfo.from_current().getrepr(style="short")
+            ) from e
+        except ImportPathMismatchError as e:
+            raise self.CollectError(
+                "import file mismatch:\n"
+                "imported module %r has this __file__ attribute:\n"
+                "  %s\n"
+                "which is not the same as the test file we want to collect:\n"
+                "  %s\n"
+                "HINT: remove __pycache__ / .pyc files and/or use a "
+                "unique basename for your test file modules" % e.args
+            ) from e
+        except ImportError as e:
+            exc_info = ExceptionInfo.from_current()
+            if self.config.getoption("verbose") < 2:
+                exc_info.traceback = exc_info.traceback.filter(filter_traceback)
+            exc_repr = (
+                exc_info.getrepr(style="short")
+                if exc_info.traceback
+                else exc_info.exconly()
+            )
+            formatted_tb = str(exc_repr)
+            raise self.CollectError(
+                "ImportError while importing test module '{fspath}'.\n"
+                "Hint: make sure your test modules/packages have valid Python names.\n"
+                "Traceback:\n"
+                "{traceback}".format(fspath=self.fspath, traceback=formatted_tb)
+            ) from e
+        except skip.Exception as e:
+            if e.allow_module_level:
+                raise
+            raise self.CollectError(
+                "Using pytest.skip outside of a test is not allowed. "
+                "To decorate a test function, use the @pytest.mark.skip "
+                "or @pytest.mark.skipif decorators instead, and to skip a "
+                "module use `pytestmark = pytest.mark.{skip,skipif}."
+            ) from e
+        self.config.pluginmanager.consider_module(mod)
+        return mod
+
+
+class Package(Module):
+    def __init__(
+        self,
+        fspath: py.path.local,
+        parent: nodes.Collector,
+        # NOTE: following args are unused:
+        config=None,
+        session=None,
+        nodeid=None,
+    ) -> None:
+        # NOTE: Could be just the following, but kept as-is for compat.
+        # nodes.FSCollector.__init__(self, fspath, parent=parent)
+        session = parent.session
+        nodes.FSCollector.__init__(
+            self, fspath, parent=parent, config=config, session=session, nodeid=nodeid
+        )
+        self.name = os.path.basename(str(fspath.dirname))
+
+    def setup(self) -> None:
+        # Not using fixtures to call setup_module here because autouse fixtures
+        # from packages are not called automatically (#4085).
+        setup_module = _get_first_non_fixture_func(
+            self.obj, ("setUpModule", "setup_module")
+        )
+        if setup_module is not None:
+            _call_with_optional_argument(setup_module, self.obj)
+
+        teardown_module = _get_first_non_fixture_func(
+            self.obj, ("tearDownModule", "teardown_module")
+        )
+        if teardown_module is not None:
+            func = partial(_call_with_optional_argument, teardown_module, self.obj)
+            self.addfinalizer(func)
+
+    def gethookproxy(self, fspath: py.path.local):
+        warnings.warn(FSCOLLECTOR_GETHOOKPROXY_ISINITPATH, stacklevel=2)
+        return self.session.gethookproxy(fspath)
+
+    def isinitpath(self, path: py.path.local) -> bool:
+        warnings.warn(FSCOLLECTOR_GETHOOKPROXY_ISINITPATH, stacklevel=2)
+        return self.session.isinitpath(path)
+
+    def _recurse(self, direntry: "os.DirEntry[str]") -> bool:
+        if direntry.name == "__pycache__":
+            return False
+        path = py.path.local(direntry.path)
+        ihook = self.session.gethookproxy(path.dirpath())
+        if ihook.pytest_ignore_collect(path=path, config=self.config):
+            return False
+        norecursepatterns = self.config.getini("norecursedirs")
+        if any(path.check(fnmatch=pat) for pat in norecursepatterns):
+            return False
+        return True
+
+    def _collectfile(
+        self, path: py.path.local, handle_dupes: bool = True
+    ) -> Sequence[nodes.Collector]:
+        assert (
+            path.isfile()
+        ), "{!r} is not a file (isdir={!r}, exists={!r}, islink={!r})".format(
+            path, path.isdir(), path.exists(), path.islink()
+        )
+        ihook = self.session.gethookproxy(path)
+        if not self.session.isinitpath(path):
+            if ihook.pytest_ignore_collect(path=path, config=self.config):
+                return ()
+
+        if handle_dupes:
+            keepduplicates = self.config.getoption("keepduplicates")
+            if not keepduplicates:
+                duplicate_paths = self.config.pluginmanager._duplicatepaths
+                if path in duplicate_paths:
+                    return ()
+                else:
+                    duplicate_paths.add(path)
+
+        return ihook.pytest_collect_file(path=path, parent=self)  # type: ignore[no-any-return]
+
+    def collect(self) -> Iterable[Union[nodes.Item, nodes.Collector]]:
+        this_path = self.fspath.dirpath()
+        init_module = this_path.join("__init__.py")
+        if init_module.check(file=1) and path_matches_patterns(
+            init_module, self.config.getini("python_files")
+        ):
+            yield Module.from_parent(self, fspath=init_module)
+        pkg_prefixes: Set[py.path.local] = set()
+        for direntry in visit(str(this_path), recurse=self._recurse):
+            path = py.path.local(direntry.path)
+
+            # We will visit our own __init__.py file, in which case we skip it.
+            if direntry.is_file():
+                if direntry.name == "__init__.py" and path.dirpath() == this_path:
+                    continue
+
+            parts_ = parts(direntry.path)
+            if any(
+                str(pkg_prefix) in parts_ and pkg_prefix.join("__init__.py") != path
+                for pkg_prefix in pkg_prefixes
+            ):
+                continue
+
+            if direntry.is_file():
+                yield from self._collectfile(path)
+            elif not direntry.is_dir():
+                # Broken symlink or invalid/missing file.
+                continue
+            elif path.join("__init__.py").check(file=1):
+                pkg_prefixes.add(path)
+
+
+def _call_with_optional_argument(func, arg) -> None:
+    """Call the given function with the given argument if func accepts one argument, otherwise
+    calls func without arguments."""
+    arg_count = func.__code__.co_argcount
+    if inspect.ismethod(func):
+        arg_count -= 1
+    if arg_count:
+        func(arg)
+    else:
+        func()
+
+
+def _get_first_non_fixture_func(obj: object, names: Iterable[str]):
+    """Return the attribute from the given object to be used as a setup/teardown
+    xunit-style function, but only if not marked as a fixture to avoid calling it twice."""
+    for name in names:
+        meth = getattr(obj, name, None)
+        if meth is not None and fixtures.getfixturemarker(meth) is None:
+            return meth
+
+
+class Class(PyCollector):
+    """Collector for test methods."""
+
+    @classmethod
+    def from_parent(cls, parent, *, name, obj=None):
+        """The public constructor."""
+        return super().from_parent(name=name, parent=parent)
+
+    def collect(self) -> Iterable[Union[nodes.Item, nodes.Collector]]:
+        if not safe_getattr(self.obj, "__test__", True):
+            return []
+        if hasinit(self.obj):
+            assert self.parent is not None
+            self.warn(
+                PytestCollectionWarning(
+                    "cannot collect test class %r because it has a "
+                    "__init__ constructor (from: %s)"
+                    % (self.obj.__name__, self.parent.nodeid)
+                )
+            )
+            return []
+        elif hasnew(self.obj):
+            assert self.parent is not None
+            self.warn(
+                PytestCollectionWarning(
+                    "cannot collect test class %r because it has a "
+                    "__new__ constructor (from: %s)"
+                    % (self.obj.__name__, self.parent.nodeid)
+                )
+            )
+            return []
+
+        self._inject_setup_class_fixture()
+        self._inject_setup_method_fixture()
+
+        return [Instance.from_parent(self, name="()")]
+
+    def _inject_setup_class_fixture(self) -> None:
+        """Inject a hidden autouse, class scoped fixture into the collected class object
+        that invokes setup_class/teardown_class if either or both are available.
+
+        Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with
+        other fixtures (#517).
+        """
+        setup_class = _get_first_non_fixture_func(self.obj, ("setup_class",))
+        teardown_class = getattr(self.obj, "teardown_class", None)
+        if setup_class is None and teardown_class is None:
+            return
+
+        @fixtures.fixture(
+            autouse=True,
+            scope="class",
+            # Use a unique name to speed up lookup.
+            name=f"xunit_setup_class_fixture_{self.obj.__qualname__}",
+        )
+        def xunit_setup_class_fixture(cls) -> Generator[None, None, None]:
+            if setup_class is not None:
+                func = getimfunc(setup_class)
+                _call_with_optional_argument(func, self.obj)
+            yield
+            if teardown_class is not None:
+                func = getimfunc(teardown_class)
+                _call_with_optional_argument(func, self.obj)
+
+        self.obj.__pytest_setup_class = xunit_setup_class_fixture
+
+    def _inject_setup_method_fixture(self) -> None:
+        """Inject a hidden autouse, function scoped fixture into the collected class object
+        that invokes setup_method/teardown_method if either or both are available.
+
+        Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with
+        other fixtures (#517).
+        """
+        setup_method = _get_first_non_fixture_func(self.obj, ("setup_method",))
+        teardown_method = getattr(self.obj, "teardown_method", None)
+        if setup_method is None and teardown_method is None:
+            return
+
+        @fixtures.fixture(
+            autouse=True,
+            scope="function",
+            # Use a unique name to speed up lookup.
+            name=f"xunit_setup_method_fixture_{self.obj.__qualname__}",
+        )
+        def xunit_setup_method_fixture(self, request) -> Generator[None, None, None]:
+            method = request.function
+            if setup_method is not None:
+                func = getattr(self, "setup_method")
+                _call_with_optional_argument(func, method)
+            yield
+            if teardown_method is not None:
+                func = getattr(self, "teardown_method")
+                _call_with_optional_argument(func, method)
+
+        self.obj.__pytest_setup_method = xunit_setup_method_fixture
+
+
+class Instance(PyCollector):
+    _ALLOW_MARKERS = False  # hack, destroy later
+    # Instances share the object with their parents in a way
+    # that duplicates markers instances if not taken out
+    # can be removed at node structure reorganization time.
+
+    def _getobj(self):
+        # TODO: Improve the type of `parent` such that assert/ignore aren't needed.
+        assert self.parent is not None
+        obj = self.parent.obj  # type: ignore[attr-defined]
+        return obj()
+
+    def collect(self) -> Iterable[Union[nodes.Item, nodes.Collector]]:
+        self.session._fixturemanager.parsefactories(self)
+        return super().collect()
+
+    def newinstance(self):
+        self.obj = self._getobj()
+        return self.obj
+
+
+def hasinit(obj: object) -> bool:
+    init: object = getattr(obj, "__init__", None)
+    if init:
+        return init != object.__init__
+    return False
+
+
+def hasnew(obj: object) -> bool:
+    new: object = getattr(obj, "__new__", None)
+    if new:
+        return new != object.__new__
+    return False
+
+
+@final
+class CallSpec2:
+    def __init__(self, metafunc: "Metafunc") -> None:
+        self.metafunc = metafunc
+        self.funcargs: Dict[str, object] = {}
+        self._idlist: List[str] = []
+        self.params: Dict[str, object] = {}
+        # Used for sorting parametrized resources.
+        self._arg2scopenum: Dict[str, int] = {}
+        self.marks: List[Mark] = []
+        self.indices: Dict[str, int] = {}
+
+    def copy(self) -> "CallSpec2":
+        cs = CallSpec2(self.metafunc)
+        cs.funcargs.update(self.funcargs)
+        cs.params.update(self.params)
+        cs.marks.extend(self.marks)
+        cs.indices.update(self.indices)
+        cs._arg2scopenum.update(self._arg2scopenum)
+        cs._idlist = list(self._idlist)
+        return cs
+
+    def _checkargnotcontained(self, arg: str) -> None:
+        if arg in self.params or arg in self.funcargs:
+            raise ValueError(f"duplicate {arg!r}")
+
+    def getparam(self, name: str) -> object:
+        try:
+            return self.params[name]
+        except KeyError as e:
+            raise ValueError(name) from e
+
+    @property
+    def id(self) -> str:
+        return "-".join(map(str, self._idlist))
+
+    def setmulti2(
+        self,
+        valtypes: Mapping[str, "Literal['params', 'funcargs']"],
+        argnames: Sequence[str],
+        valset: Iterable[object],
+        id: str,
+        marks: Iterable[Union[Mark, MarkDecorator]],
+        scopenum: int,
+        param_index: int,
+    ) -> None:
+        for arg, val in zip(argnames, valset):
+            self._checkargnotcontained(arg)
+            valtype_for_arg = valtypes[arg]
+            if valtype_for_arg == "params":
+                self.params[arg] = val
+            elif valtype_for_arg == "funcargs":
+                self.funcargs[arg] = val
+            else:  # pragma: no cover
+                assert False, f"Unhandled valtype for arg: {valtype_for_arg}"
+            self.indices[arg] = param_index
+            self._arg2scopenum[arg] = scopenum
+        self._idlist.append(id)
+        self.marks.extend(normalize_mark_list(marks))
+
+
+@final
+class Metafunc:
+    """Objects passed to the :func:`pytest_generate_tests <_pytest.hookspec.pytest_generate_tests>` hook.
+
+    They help to inspect a test function and to generate tests according to
+    test configuration or values specified in the class or module where a
+    test function is defined.
+    """
+
+    def __init__(
+        self,
+        definition: "FunctionDefinition",
+        fixtureinfo: fixtures.FuncFixtureInfo,
+        config: Config,
+        cls=None,
+        module=None,
+    ) -> None:
+        #: Access to the underlying :class:`_pytest.python.FunctionDefinition`.
+        self.definition = definition
+
+        #: Access to the :class:`_pytest.config.Config` object for the test session.
+        self.config = config
+
+        #: The module object where the test function is defined in.
+        self.module = module
+
+        #: Underlying Python test function.
+        self.function = definition.obj
+
+        #: Set of fixture names required by the test function.
+        self.fixturenames = fixtureinfo.names_closure
+
+        #: Class object where the test function is defined in or ``None``.
+        self.cls = cls
+
+        self._calls: List[CallSpec2] = []
+        self._arg2fixturedefs = fixtureinfo.name2fixturedefs
+
+    def parametrize(
+        self,
+        argnames: Union[str, List[str], Tuple[str, ...]],
+        argvalues: Iterable[Union[ParameterSet, Sequence[object], object]],
+        indirect: Union[bool, Sequence[str]] = False,
+        ids: Optional[
+            Union[
+                Iterable[Union[None, str, float, int, bool]],
+                Callable[[Any], Optional[object]],
+            ]
+        ] = None,
+        scope: "Optional[_Scope]" = None,
+        *,
+        _param_mark: Optional[Mark] = None,
+    ) -> None:
+        """Add new invocations to the underlying test function using the list
+        of argvalues for the given argnames.  Parametrization is performed
+        during the collection phase.  If you need to setup expensive resources
+        see about setting indirect to do it rather at test setup time.
+
+        :param argnames:
+            A comma-separated string denoting one or more argument names, or
+            a list/tuple of argument strings.
+
+        :param argvalues:
+            The list of argvalues determines how often a test is invoked with
+            different argument values.
+
+            If only one argname was specified argvalues is a list of values.
+            If N argnames were specified, argvalues must be a list of
+            N-tuples, where each tuple-element specifies a value for its
+            respective argname.
+
+        :param indirect:
+            A list of arguments' names (subset of argnames) or a boolean.
+            If True the list contains all names from the argnames. Each
+            argvalue corresponding to an argname in this list will
+            be passed as request.param to its respective argname fixture
+            function so that it can perform more expensive setups during the
+            setup phase of a test rather than at collection time.
+
+        :param ids:
+            Sequence of (or generator for) ids for ``argvalues``,
+            or a callable to return part of the id for each argvalue.
+
+            With sequences (and generators like ``itertools.count()``) the
+            returned ids should be of type ``string``, ``int``, ``float``,
+            ``bool``, or ``None``.
+            They are mapped to the corresponding index in ``argvalues``.
+            ``None`` means to use the auto-generated id.
+
+            If it is a callable it will be called for each entry in
+            ``argvalues``, and the return value is used as part of the
+            auto-generated id for the whole set (where parts are joined with
+            dashes ("-")).
+            This is useful to provide more specific ids for certain items, e.g.
+            dates.  Returning ``None`` will use an auto-generated id.
+
+            If no ids are provided they will be generated automatically from
+            the argvalues.
+
+        :param scope:
+            If specified it denotes the scope of the parameters.
+            The scope is used for grouping tests by parameter instances.
+            It will also override any fixture-function defined scope, allowing
+            to set a dynamic scope using test context or configuration.
+        """
+        from _pytest.fixtures import scope2index
+
+        argnames, parameters = ParameterSet._for_parametrize(
+            argnames,
+            argvalues,
+            self.function,
+            self.config,
+            nodeid=self.definition.nodeid,
+        )
+        del argvalues
+
+        if "request" in argnames:
+            fail(
+                "'request' is a reserved name and cannot be used in @pytest.mark.parametrize",
+                pytrace=False,
+            )
+
+        if scope is None:
+            scope = _find_parametrized_scope(argnames, self._arg2fixturedefs, indirect)
+
+        self._validate_if_using_arg_names(argnames, indirect)
+
+        arg_values_types = self._resolve_arg_value_types(argnames, indirect)
+
+        # Use any already (possibly) generated ids with parametrize Marks.
+        if _param_mark and _param_mark._param_ids_from:
+            generated_ids = _param_mark._param_ids_from._param_ids_generated
+            if generated_ids is not None:
+                ids = generated_ids
+
+        ids = self._resolve_arg_ids(
+            argnames, ids, parameters, nodeid=self.definition.nodeid
+        )
+
+        # Store used (possibly generated) ids with parametrize Marks.
+        if _param_mark and _param_mark._param_ids_from and generated_ids is None:
+            object.__setattr__(_param_mark._param_ids_from, "_param_ids_generated", ids)
+
+        scopenum = scope2index(
+            scope, descr=f"parametrize() call in {self.function.__name__}"
+        )
+
+        # Create the new calls: if we are parametrize() multiple times (by applying the decorator
+        # more than once) then we accumulate those calls generating the cartesian product
+        # of all calls.
+        newcalls = []
+        for callspec in self._calls or [CallSpec2(self)]:
+            for param_index, (param_id, param_set) in enumerate(zip(ids, parameters)):
+                newcallspec = callspec.copy()
+                newcallspec.setmulti2(
+                    arg_values_types,
+                    argnames,
+                    param_set.values,
+                    param_id,
+                    param_set.marks,
+                    scopenum,
+                    param_index,
+                )
+                newcalls.append(newcallspec)
+        self._calls = newcalls
+
+    def _resolve_arg_ids(
+        self,
+        argnames: Sequence[str],
+        ids: Optional[
+            Union[
+                Iterable[Union[None, str, float, int, bool]],
+                Callable[[Any], Optional[object]],
+            ]
+        ],
+        parameters: Sequence[ParameterSet],
+        nodeid: str,
+    ) -> List[str]:
+        """Resolve the actual ids for the given argnames, based on the ``ids`` parameter given
+        to ``parametrize``.
+
+        :param List[str] argnames: List of argument names passed to ``parametrize()``.
+        :param ids: The ids parameter of the parametrized call (see docs).
+        :param List[ParameterSet] parameters: The list of parameter values, same size as ``argnames``.
+        :param str str: The nodeid of the item that generated this parametrized call.
+        :rtype: List[str]
+        :returns: The list of ids for each argname given.
+        """
+        if ids is None:
+            idfn = None
+            ids_ = None
+        elif callable(ids):
+            idfn = ids
+            ids_ = None
+        else:
+            idfn = None
+            ids_ = self._validate_ids(ids, parameters, self.function.__name__)
+        return idmaker(argnames, parameters, idfn, ids_, self.config, nodeid=nodeid)
+
+    def _validate_ids(
+        self,
+        ids: Iterable[Union[None, str, float, int, bool]],
+        parameters: Sequence[ParameterSet],
+        func_name: str,
+    ) -> List[Union[None, str]]:
+        try:
+            num_ids = len(ids)  # type: ignore[arg-type]
+        except TypeError:
+            try:
+                iter(ids)
+            except TypeError as e:
+                raise TypeError("ids must be a callable or an iterable") from e
+            num_ids = len(parameters)
+
+        # num_ids == 0 is a special case: https://github.com/pytest-dev/pytest/issues/1849
+        if num_ids != len(parameters) and num_ids != 0:
+            msg = "In {}: {} parameter sets specified, with different number of ids: {}"
+            fail(msg.format(func_name, len(parameters), num_ids), pytrace=False)
+
+        new_ids = []
+        for idx, id_value in enumerate(itertools.islice(ids, num_ids)):
+            if id_value is None or isinstance(id_value, str):
+                new_ids.append(id_value)
+            elif isinstance(id_value, (float, int, bool)):
+                new_ids.append(str(id_value))
+            else:
+                msg = (  # type: ignore[unreachable]
+                    "In {}: ids must be list of string/float/int/bool, "
+                    "found: {} (type: {!r}) at index {}"
+                )
+                fail(
+                    msg.format(func_name, saferepr(id_value), type(id_value), idx),
+                    pytrace=False,
+                )
+        return new_ids
+
+    def _resolve_arg_value_types(
+        self, argnames: Sequence[str], indirect: Union[bool, Sequence[str]],
+    ) -> Dict[str, "Literal['params', 'funcargs']"]:
+        """Resolve if each parametrized argument must be considered a
+        parameter to a fixture or a "funcarg" to the function, based on the
+        ``indirect`` parameter of the parametrized() call.
+
+        :param List[str] argnames: List of argument names passed to ``parametrize()``.
+        :param indirect: Same as the ``indirect`` parameter of ``parametrize()``.
+        :rtype: Dict[str, str]
+            A dict mapping each arg name to either:
+            * "params" if the argname should be the parameter of a fixture of the same name.
+            * "funcargs" if the argname should be a parameter to the parametrized test function.
+        """
+        if isinstance(indirect, bool):
+            valtypes: Dict[str, Literal["params", "funcargs"]] = dict.fromkeys(
+                argnames, "params" if indirect else "funcargs"
+            )
+        elif isinstance(indirect, Sequence):
+            valtypes = dict.fromkeys(argnames, "funcargs")
+            for arg in indirect:
+                if arg not in argnames:
+                    fail(
+                        "In {}: indirect fixture '{}' doesn't exist".format(
+                            self.function.__name__, arg
+                        ),
+                        pytrace=False,
+                    )
+                valtypes[arg] = "params"
+        else:
+            fail(
+                "In {func}: expected Sequence or boolean for indirect, got {type}".format(
+                    type=type(indirect).__name__, func=self.function.__name__
+                ),
+                pytrace=False,
+            )
+        return valtypes
+
+    def _validate_if_using_arg_names(
+        self, argnames: Sequence[str], indirect: Union[bool, Sequence[str]],
+    ) -> None:
+        """Check if all argnames are being used, by default values, or directly/indirectly.
+
+        :param List[str] argnames: List of argument names passed to ``parametrize()``.
+        :param indirect: Same as the ``indirect`` parameter of ``parametrize()``.
+        :raises ValueError: If validation fails.
+        """
+        default_arg_names = set(get_default_arg_names(self.function))
+        func_name = self.function.__name__
+        for arg in argnames:
+            if arg not in self.fixturenames:
+                if arg in default_arg_names:
+                    fail(
+                        "In {}: function already takes an argument '{}' with a default value".format(
+                            func_name, arg
+                        ),
+                        pytrace=False,
+                    )
+                else:
+                    if isinstance(indirect, Sequence):
+                        name = "fixture" if arg in indirect else "argument"
+                    else:
+                        name = "fixture" if indirect else "argument"
+                    fail(
+                        f"In {func_name}: function uses no {name} '{arg}'",
+                        pytrace=False,
+                    )
+
+
+def _find_parametrized_scope(
+    argnames: Sequence[str],
+    arg2fixturedefs: Mapping[str, Sequence[fixtures.FixtureDef[object]]],
+    indirect: Union[bool, Sequence[str]],
+) -> "fixtures._Scope":
+    """Find the most appropriate scope for a parametrized call based on its arguments.
+
+    When there's at least one direct argument, always use "function" scope.
+
+    When a test function is parametrized and all its arguments are indirect
+    (e.g. fixtures), return the most narrow scope based on the fixtures used.
+
+    Related to issue #1832, based on code posted by @Kingdread.
+    """
+    if isinstance(indirect, Sequence):
+        all_arguments_are_fixtures = len(indirect) == len(argnames)
+    else:
+        all_arguments_are_fixtures = bool(indirect)
+
+    if all_arguments_are_fixtures:
+        fixturedefs = arg2fixturedefs or {}
+        used_scopes = [
+            fixturedef[0].scope
+            for name, fixturedef in fixturedefs.items()
+            if name in argnames
+        ]
+        if used_scopes:
+            # Takes the most narrow scope from used fixtures.
+            for scope in reversed(fixtures.scopes):
+                if scope in used_scopes:
+                    return scope
+
+    return "function"
+
+
+def _ascii_escaped_by_config(val: Union[str, bytes], config: Optional[Config]) -> str:
+    if config is None:
+        escape_option = False
+    else:
+        escape_option = config.getini(
+            "disable_test_id_escaping_and_forfeit_all_rights_to_community_support"
+        )
+    # TODO: If escaping is turned off and the user passes bytes,
+    #       will return a bytes. For now we ignore this but the
+    #       code *probably* doesn't handle this case.
+    return val if escape_option else ascii_escaped(val)  # type: ignore
+
+
+def _idval(
+    val: object,
+    argname: str,
+    idx: int,
+    idfn: Optional[Callable[[Any], Optional[object]]],
+    nodeid: Optional[str],
+    config: Optional[Config],
+) -> str:
+    if idfn:
+        try:
+            generated_id = idfn(val)
+            if generated_id is not None:
+                val = generated_id
+        except Exception as e:
+            prefix = f"{nodeid}: " if nodeid is not None else ""
+            msg = "error raised while trying to determine id of parameter '{}' at position {}"
+            msg = prefix + msg.format(argname, idx)
+            raise ValueError(msg) from e
+    elif config:
+        hook_id: Optional[str] = config.hook.pytest_make_parametrize_id(
+            config=config, val=val, argname=argname
+        )
+        if hook_id:
+            return hook_id
+
+    if isinstance(val, STRING_TYPES):
+        return _ascii_escaped_by_config(val, config)
+    elif val is None or isinstance(val, (float, int, bool)):
+        return str(val)
+    elif isinstance(val, REGEX_TYPE):
+        return ascii_escaped(val.pattern)
+    elif val is NOTSET:
+        # Fallback to default. Note that NOTSET is an enum.Enum.
+        pass
+    elif isinstance(val, enum.Enum):
+        return str(val)
+    elif isinstance(getattr(val, "__name__", None), str):
+        # Name of a class, function, module, etc.
+        name: str = getattr(val, "__name__")
+        return name
+    return str(argname) + str(idx)
+
+
+def _idvalset(
+    idx: int,
+    parameterset: ParameterSet,
+    argnames: Iterable[str],
+    idfn: Optional[Callable[[Any], Optional[object]]],
+    ids: Optional[List[Union[None, str]]],
+    nodeid: Optional[str],
+    config: Optional[Config],
+) -> str:
+    if parameterset.id is not None:
+        return parameterset.id
+    id = None if ids is None or idx >= len(ids) else ids[idx]
+    if id is None:
+        this_id = [
+            _idval(val, argname, idx, idfn, nodeid=nodeid, config=config)
+            for val, argname in zip(parameterset.values, argnames)
+        ]
+        return "-".join(this_id)
+    else:
+        return _ascii_escaped_by_config(id, config)
+
+
+def idmaker(
+    argnames: Iterable[str],
+    parametersets: Iterable[ParameterSet],
+    idfn: Optional[Callable[[Any], Optional[object]]] = None,
+    ids: Optional[List[Union[None, str]]] = None,
+    config: Optional[Config] = None,
+    nodeid: Optional[str] = None,
+) -> List[str]:
+    resolved_ids = [
+        _idvalset(
+            valindex, parameterset, argnames, idfn, ids, config=config, nodeid=nodeid
+        )
+        for valindex, parameterset in enumerate(parametersets)
+    ]
+
+    # All IDs must be unique!
+    unique_ids = set(resolved_ids)
+    if len(unique_ids) != len(resolved_ids):
+
+        # Record the number of occurrences of each test ID.
+        test_id_counts = Counter(resolved_ids)
+
+        # Map the test ID to its next suffix.
+        test_id_suffixes: Dict[str, int] = defaultdict(int)
+
+        # Suffix non-unique IDs to make them unique.
+        for index, test_id in enumerate(resolved_ids):
+            if test_id_counts[test_id] > 1:
+                resolved_ids[index] = "{}{}".format(test_id, test_id_suffixes[test_id])
+                test_id_suffixes[test_id] += 1
+
+    return resolved_ids
+
+
+def show_fixtures_per_test(config):
+    from _pytest.main import wrap_session
+
+    return wrap_session(config, _show_fixtures_per_test)
+
+
+def _show_fixtures_per_test(config: Config, session: Session) -> None:
+    import _pytest.config
+
+    session.perform_collect()
+    curdir = py.path.local()
+    tw = _pytest.config.create_terminal_writer(config)
+    verbose = config.getvalue("verbose")
+
+    def get_best_relpath(func):
+        loc = getlocation(func, str(curdir))
+        return curdir.bestrelpath(py.path.local(loc))
+
+    def write_fixture(fixture_def: fixtures.FixtureDef[object]) -> None:
+        argname = fixture_def.argname
+        if verbose <= 0 and argname.startswith("_"):
+            return
+        if verbose > 0:
+            bestrel = get_best_relpath(fixture_def.func)
+            funcargspec = f"{argname} -- {bestrel}"
+        else:
+            funcargspec = argname
+        tw.line(funcargspec, green=True)
+        fixture_doc = inspect.getdoc(fixture_def.func)
+        if fixture_doc:
+            write_docstring(tw, fixture_doc)
+        else:
+            tw.line("    no docstring available", red=True)
+
+    def write_item(item: nodes.Item) -> None:
+        # Not all items have _fixtureinfo attribute.
+        info: Optional[FuncFixtureInfo] = getattr(item, "_fixtureinfo", None)
+        if info is None or not info.name2fixturedefs:
+            # This test item does not use any fixtures.
+            return
+        tw.line()
+        tw.sep("-", f"fixtures used by {item.name}")
+        # TODO: Fix this type ignore.
+        tw.sep("-", "({})".format(get_best_relpath(item.function)))  # type: ignore[attr-defined]
+        # dict key not used in loop but needed for sorting.
+        for _, fixturedefs in sorted(info.name2fixturedefs.items()):
+            assert fixturedefs is not None
+            if not fixturedefs:
+                continue
+            # Last item is expected to be the one used by the test item.
+            write_fixture(fixturedefs[-1])
+
+    for session_item in session.items:
+        write_item(session_item)
+
+
+def showfixtures(config: Config) -> Union[int, ExitCode]:
+    from _pytest.main import wrap_session
+
+    return wrap_session(config, _showfixtures_main)
+
+
+def _showfixtures_main(config: Config, session: Session) -> None:
+    import _pytest.config
+
+    session.perform_collect()
+    curdir = py.path.local()
+    tw = _pytest.config.create_terminal_writer(config)
+    verbose = config.getvalue("verbose")
+
+    fm = session._fixturemanager
+
+    available = []
+    seen: Set[Tuple[str, str]] = set()
+
+    for argname, fixturedefs in fm._arg2fixturedefs.items():
+        assert fixturedefs is not None
+        if not fixturedefs:
+            continue
+        for fixturedef in fixturedefs:
+            loc = getlocation(fixturedef.func, str(curdir))
+            if (fixturedef.argname, loc) in seen:
+                continue
+            seen.add((fixturedef.argname, loc))
+            available.append(
+                (
+                    len(fixturedef.baseid),
+                    fixturedef.func.__module__,
+                    curdir.bestrelpath(py.path.local(loc)),
+                    fixturedef.argname,
+                    fixturedef,
+                )
+            )
+
+    available.sort()
+    currentmodule = None
+    for baseid, module, bestrel, argname, fixturedef in available:
+        if currentmodule != module:
+            if not module.startswith("_pytest."):
+                tw.line()
+                tw.sep("-", f"fixtures defined from {module}")
+                currentmodule = module
+        if verbose <= 0 and argname[0] == "_":
+            continue
+        tw.write(argname, green=True)
+        if fixturedef.scope != "function":
+            tw.write(" [%s scope]" % fixturedef.scope, cyan=True)
+        if verbose > 0:
+            tw.write(" -- %s" % bestrel, yellow=True)
+        tw.write("\n")
+        loc = getlocation(fixturedef.func, str(curdir))
+        doc = inspect.getdoc(fixturedef.func)
+        if doc:
+            write_docstring(tw, doc)
+        else:
+            tw.line(f"    {loc}: no docstring available", red=True)
+        tw.line()
+
+
+def write_docstring(tw: TerminalWriter, doc: str, indent: str = "    ") -> None:
+    for line in doc.split("\n"):
+        tw.line(indent + line)
+
+
+class Function(PyobjMixin, nodes.Item):
+    """An Item responsible for setting up and executing a Python test function.
+
+    param name:
+        The full function name, including any decorations like those
+        added by parametrization (``my_func[my_param]``).
+    param parent:
+        The parent Node.
+    param config:
+        The pytest Config object.
+    param callspec:
+        If given, this is function has been parametrized and the callspec contains
+        meta information about the parametrization.
+    param callobj:
+        If given, the object which will be called when the Function is invoked,
+        otherwise the callobj will be obtained from ``parent`` using ``originalname``.
+    param keywords:
+        Keywords bound to the function object for "-k" matching.
+    param session:
+        The pytest Session object.
+    param fixtureinfo:
+        Fixture information already resolved at this fixture node..
+    param originalname:
+        The attribute name to use for accessing the underlying function object.
+        Defaults to ``name``. Set this if name is different from the original name,
+        for example when it contains decorations like those added by parametrization
+        (``my_func[my_param]``).
+    """
+
+    # Disable since functions handle it themselves.
+    _ALLOW_MARKERS = False
+
+    def __init__(
+        self,
+        name: str,
+        parent,
+        config: Optional[Config] = None,
+        callspec: Optional[CallSpec2] = None,
+        callobj=NOTSET,
+        keywords=None,
+        session: Optional[Session] = None,
+        fixtureinfo: Optional[FuncFixtureInfo] = None,
+        originalname: Optional[str] = None,
+    ) -> None:
+        super().__init__(name, parent, config=config, session=session)
+
+        if callobj is not NOTSET:
+            self.obj = callobj
+
+        #: Original function name, without any decorations (for example
+        #: parametrization adds a ``"[...]"`` suffix to function names), used to access
+        #: the underlying function object from ``parent`` (in case ``callobj`` is not given
+        #: explicitly).
+        #:
+        #: .. versionadded:: 3.0
+        self.originalname = originalname or name
+
+        # Note: when FunctionDefinition is introduced, we should change ``originalname``
+        # to a readonly property that returns FunctionDefinition.name.
+
+        self.keywords.update(self.obj.__dict__)
+        self.own_markers.extend(get_unpacked_marks(self.obj))
+        if callspec:
+            self.callspec = callspec
+            # this is total hostile and a mess
+            # keywords are broken by design by now
+            # this will be redeemed later
+            for mark in callspec.marks:
+                # feel free to cry, this was broken for years before
+                # and keywords cant fix it per design
+                self.keywords[mark.name] = mark
+            self.own_markers.extend(normalize_mark_list(callspec.marks))
+        if keywords:
+            self.keywords.update(keywords)
+
+        # todo: this is a hell of a hack
+        # https://github.com/pytest-dev/pytest/issues/4569
+
+        self.keywords.update(
+            {
+                mark.name: True
+                for mark in self.iter_markers()
+                if mark.name not in self.keywords
+            }
+        )
+
+        if fixtureinfo is None:
+            fixtureinfo = self.session._fixturemanager.getfixtureinfo(
+                self, self.obj, self.cls, funcargs=True
+            )
+        self._fixtureinfo: FuncFixtureInfo = fixtureinfo
+        self.fixturenames = fixtureinfo.names_closure
+        self._initrequest()
+
+    @classmethod
+    def from_parent(cls, parent, **kw):  # todo: determine sound type limitations
+        """The public constructor."""
+        return super().from_parent(parent=parent, **kw)
+
+    def _initrequest(self) -> None:
+        self.funcargs: Dict[str, object] = {}
+        self._request = fixtures.FixtureRequest(self, _ispytest=True)
+
+    @property
+    def function(self):
+        """Underlying python 'function' object."""
+        return getimfunc(self.obj)
+
+    def _getobj(self):
+        assert self.parent is not None
+        return getattr(self.parent.obj, self.originalname)  # type: ignore[attr-defined]
+
+    @property
+    def _pyfuncitem(self):
+        """(compatonly) for code expecting pytest-2.2 style request objects."""
+        return self
+
+    def runtest(self) -> None:
+        """Execute the underlying test function."""
+        self.ihook.pytest_pyfunc_call(pyfuncitem=self)
+
+    def setup(self) -> None:
+        if isinstance(self.parent, Instance):
+            self.parent.newinstance()
+            self.obj = self._getobj()
+        self._request._fillfixtures()
+
+    def _prunetraceback(self, excinfo: ExceptionInfo[BaseException]) -> None:
+        if hasattr(self, "_obj") and not self.config.getoption("fulltrace", False):
+            code = _pytest._code.Code.from_function(get_real_func(self.obj))
+            path, firstlineno = code.path, code.firstlineno
+            traceback = excinfo.traceback
+            ntraceback = traceback.cut(path=path, firstlineno=firstlineno)
+            if ntraceback == traceback:
+                ntraceback = ntraceback.cut(path=path)
+                if ntraceback == traceback:
+                    ntraceback = ntraceback.filter(filter_traceback)
+                    if not ntraceback:
+                        ntraceback = traceback
+
+            excinfo.traceback = ntraceback.filter()
+            # issue364: mark all but first and last frames to
+            # only show a single-line message for each frame.
+            if self.config.getoption("tbstyle", "auto") == "auto":
+                if len(excinfo.traceback) > 2:
+                    for entry in excinfo.traceback[1:-1]:
+                        entry.set_repr_style("short")
+
+    # TODO: Type ignored -- breaks Liskov Substitution.
+    def repr_failure(  # type: ignore[override]
+        self, excinfo: ExceptionInfo[BaseException],
+    ) -> Union[str, TerminalRepr]:
+        style = self.config.getoption("tbstyle", "auto")
+        if style == "auto":
+            style = "long"
+        return self._repr_failure_py(excinfo, style=style)
+
+
+class FunctionDefinition(Function):
+    """
+    This class is a step gap solution until we evolve to have actual function definition nodes
+    and manage to get rid of ``metafunc``.
+    """
+
+    def runtest(self) -> None:
+        raise RuntimeError("function definitions are not supposed to be run as tests")
+
+    setup = runtest
diff --git a/myenv/lib/python3.9/site-packages/_pytest/python_api.py b/myenv/lib/python3.9/site-packages/_pytest/python_api.py
new file mode 100644
index 0000000..81ce4f8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/python_api.py
@@ -0,0 +1,786 @@
+import math
+import pprint
+from collections.abc import Iterable
+from collections.abc import Mapping
+from collections.abc import Sized
+from decimal import Decimal
+from numbers import Complex
+from types import TracebackType
+from typing import Any
+from typing import Callable
+from typing import cast
+from typing import Generic
+from typing import Optional
+from typing import overload
+from typing import Pattern
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import TypeVar
+from typing import Union
+
+if TYPE_CHECKING:
+    from numpy import ndarray
+
+
+import _pytest._code
+from _pytest.compat import final
+from _pytest.compat import STRING_TYPES
+from _pytest.outcomes import fail
+
+
+def _non_numeric_type_error(value, at: Optional[str]) -> TypeError:
+    at_str = f" at {at}" if at else ""
+    return TypeError(
+        "cannot make approximate comparisons to non-numeric values: {!r} {}".format(
+            value, at_str
+        )
+    )
+
+
+# builtin pytest.approx helper
+
+
+class ApproxBase:
+    """Provide shared utilities for making approximate comparisons between
+    numbers or sequences of numbers."""
+
+    # Tell numpy to use our `__eq__` operator instead of its.
+    __array_ufunc__ = None
+    __array_priority__ = 100
+
+    def __init__(self, expected, rel=None, abs=None, nan_ok: bool = False) -> None:
+        __tracebackhide__ = True
+        self.expected = expected
+        self.abs = abs
+        self.rel = rel
+        self.nan_ok = nan_ok
+        self._check_type()
+
+    def __repr__(self) -> str:
+        raise NotImplementedError
+
+    def __eq__(self, actual) -> bool:
+        return all(
+            a == self._approx_scalar(x) for a, x in self._yield_comparisons(actual)
+        )
+
+    # Ignore type because of https://github.com/python/mypy/issues/4266.
+    __hash__ = None  # type: ignore
+
+    def __ne__(self, actual) -> bool:
+        return not (actual == self)
+
+    def _approx_scalar(self, x) -> "ApproxScalar":
+        return ApproxScalar(x, rel=self.rel, abs=self.abs, nan_ok=self.nan_ok)
+
+    def _yield_comparisons(self, actual):
+        """Yield all the pairs of numbers to be compared.
+
+        This is used to implement the `__eq__` method.
+        """
+        raise NotImplementedError
+
+    def _check_type(self) -> None:
+        """Raise a TypeError if the expected value is not a valid type."""
+        # This is only a concern if the expected value is a sequence.  In every
+        # other case, the approx() function ensures that the expected value has
+        # a numeric type.  For this reason, the default is to do nothing.  The
+        # classes that deal with sequences should reimplement this method to
+        # raise if there are any non-numeric elements in the sequence.
+        pass
+
+
+def _recursive_list_map(f, x):
+    if isinstance(x, list):
+        return list(_recursive_list_map(f, xi) for xi in x)
+    else:
+        return f(x)
+
+
+class ApproxNumpy(ApproxBase):
+    """Perform approximate comparisons where the expected value is numpy array."""
+
+    def __repr__(self) -> str:
+        list_scalars = _recursive_list_map(self._approx_scalar, self.expected.tolist())
+        return f"approx({list_scalars!r})"
+
+    def __eq__(self, actual) -> bool:
+        import numpy as np
+
+        # self.expected is supposed to always be an array here.
+
+        if not np.isscalar(actual):
+            try:
+                actual = np.asarray(actual)
+            except Exception as e:
+                raise TypeError(f"cannot compare '{actual}' to numpy.ndarray") from e
+
+        if not np.isscalar(actual) and actual.shape != self.expected.shape:
+            return False
+
+        return ApproxBase.__eq__(self, actual)
+
+    def _yield_comparisons(self, actual):
+        import numpy as np
+
+        # `actual` can either be a numpy array or a scalar, it is treated in
+        # `__eq__` before being passed to `ApproxBase.__eq__`, which is the
+        # only method that calls this one.
+
+        if np.isscalar(actual):
+            for i in np.ndindex(self.expected.shape):
+                yield actual, self.expected[i].item()
+        else:
+            for i in np.ndindex(self.expected.shape):
+                yield actual[i].item(), self.expected[i].item()
+
+
+class ApproxMapping(ApproxBase):
+    """Perform approximate comparisons where the expected value is a mapping
+    with numeric values (the keys can be anything)."""
+
+    def __repr__(self) -> str:
+        return "approx({!r})".format(
+            {k: self._approx_scalar(v) for k, v in self.expected.items()}
+        )
+
+    def __eq__(self, actual) -> bool:
+        try:
+            if set(actual.keys()) != set(self.expected.keys()):
+                return False
+        except AttributeError:
+            return False
+
+        return ApproxBase.__eq__(self, actual)
+
+    def _yield_comparisons(self, actual):
+        for k in self.expected.keys():
+            yield actual[k], self.expected[k]
+
+    def _check_type(self) -> None:
+        __tracebackhide__ = True
+        for key, value in self.expected.items():
+            if isinstance(value, type(self.expected)):
+                msg = "pytest.approx() does not support nested dictionaries: key={!r} value={!r}\n  full mapping={}"
+                raise TypeError(msg.format(key, value, pprint.pformat(self.expected)))
+
+
+class ApproxSequencelike(ApproxBase):
+    """Perform approximate comparisons where the expected value is a sequence of numbers."""
+
+    def __repr__(self) -> str:
+        seq_type = type(self.expected)
+        if seq_type not in (tuple, list, set):
+            seq_type = list
+        return "approx({!r})".format(
+            seq_type(self._approx_scalar(x) for x in self.expected)
+        )
+
+    def __eq__(self, actual) -> bool:
+        try:
+            if len(actual) != len(self.expected):
+                return False
+        except TypeError:
+            return False
+        return ApproxBase.__eq__(self, actual)
+
+    def _yield_comparisons(self, actual):
+        return zip(actual, self.expected)
+
+    def _check_type(self) -> None:
+        __tracebackhide__ = True
+        for index, x in enumerate(self.expected):
+            if isinstance(x, type(self.expected)):
+                msg = "pytest.approx() does not support nested data structures: {!r} at index {}\n  full sequence: {}"
+                raise TypeError(msg.format(x, index, pprint.pformat(self.expected)))
+
+
+class ApproxScalar(ApproxBase):
+    """Perform approximate comparisons where the expected value is a single number."""
+
+    # Using Real should be better than this Union, but not possible yet:
+    # https://github.com/python/typeshed/pull/3108
+    DEFAULT_ABSOLUTE_TOLERANCE: Union[float, Decimal] = 1e-12
+    DEFAULT_RELATIVE_TOLERANCE: Union[float, Decimal] = 1e-6
+
+    def __repr__(self) -> str:
+        """Return a string communicating both the expected value and the
+        tolerance for the comparison being made.
+
+        For example, ``1.0 ± 1e-6``, ``(3+4j) ± 5e-6 ∠ ±180°``.
+        """
+
+        # Don't show a tolerance for values that aren't compared using
+        # tolerances, i.e. non-numerics and infinities. Need to call abs to
+        # handle complex numbers, e.g. (inf + 1j).
+        if (not isinstance(self.expected, (Complex, Decimal))) or math.isinf(
+            abs(self.expected)  # type: ignore[arg-type]
+        ):
+            return str(self.expected)
+
+        # If a sensible tolerance can't be calculated, self.tolerance will
+        # raise a ValueError.  In this case, display '???'.
+        try:
+            vetted_tolerance = f"{self.tolerance:.1e}"
+            if (
+                isinstance(self.expected, Complex)
+                and self.expected.imag
+                and not math.isinf(self.tolerance)
+            ):
+                vetted_tolerance += " ∠ ±180°"
+        except ValueError:
+            vetted_tolerance = "???"
+
+        return f"{self.expected} ± {vetted_tolerance}"
+
+    def __eq__(self, actual) -> bool:
+        """Return whether the given value is equal to the expected value
+        within the pre-specified tolerance."""
+        asarray = _as_numpy_array(actual)
+        if asarray is not None:
+            # Call ``__eq__()`` manually to prevent infinite-recursion with
+            # numpy<1.13.  See #3748.
+            return all(self.__eq__(a) for a in asarray.flat)
+
+        # Short-circuit exact equality.
+        if actual == self.expected:
+            return True
+
+        # If either type is non-numeric, fall back to strict equality.
+        # NB: we need Complex, rather than just Number, to ensure that __abs__,
+        # __sub__, and __float__ are defined.
+        if not (
+            isinstance(self.expected, (Complex, Decimal))
+            and isinstance(actual, (Complex, Decimal))
+        ):
+            return False
+
+        # Allow the user to control whether NaNs are considered equal to each
+        # other or not.  The abs() calls are for compatibility with complex
+        # numbers.
+        if math.isnan(abs(self.expected)):  # type: ignore[arg-type]
+            return self.nan_ok and math.isnan(abs(actual))  # type: ignore[arg-type]
+
+        # Infinity shouldn't be approximately equal to anything but itself, but
+        # if there's a relative tolerance, it will be infinite and infinity
+        # will seem approximately equal to everything.  The equal-to-itself
+        # case would have been short circuited above, so here we can just
+        # return false if the expected value is infinite.  The abs() call is
+        # for compatibility with complex numbers.
+        if math.isinf(abs(self.expected)):  # type: ignore[arg-type]
+            return False
+
+        # Return true if the two numbers are within the tolerance.
+        result: bool = abs(self.expected - actual) <= self.tolerance
+        return result
+
+    # Ignore type because of https://github.com/python/mypy/issues/4266.
+    __hash__ = None  # type: ignore
+
+    @property
+    def tolerance(self):
+        """Return the tolerance for the comparison.
+
+        This could be either an absolute tolerance or a relative tolerance,
+        depending on what the user specified or which would be larger.
+        """
+
+        def set_default(x, default):
+            return x if x is not None else default
+
+        # Figure out what the absolute tolerance should be.  ``self.abs`` is
+        # either None or a value specified by the user.
+        absolute_tolerance = set_default(self.abs, self.DEFAULT_ABSOLUTE_TOLERANCE)
+
+        if absolute_tolerance < 0:
+            raise ValueError(
+                f"absolute tolerance can't be negative: {absolute_tolerance}"
+            )
+        if math.isnan(absolute_tolerance):
+            raise ValueError("absolute tolerance can't be NaN.")
+
+        # If the user specified an absolute tolerance but not a relative one,
+        # just return the absolute tolerance.
+        if self.rel is None:
+            if self.abs is not None:
+                return absolute_tolerance
+
+        # Figure out what the relative tolerance should be.  ``self.rel`` is
+        # either None or a value specified by the user.  This is done after
+        # we've made sure the user didn't ask for an absolute tolerance only,
+        # because we don't want to raise errors about the relative tolerance if
+        # we aren't even going to use it.
+        relative_tolerance = set_default(
+            self.rel, self.DEFAULT_RELATIVE_TOLERANCE
+        ) * abs(self.expected)
+
+        if relative_tolerance < 0:
+            raise ValueError(
+                f"relative tolerance can't be negative: {absolute_tolerance}"
+            )
+        if math.isnan(relative_tolerance):
+            raise ValueError("relative tolerance can't be NaN.")
+
+        # Return the larger of the relative and absolute tolerances.
+        return max(relative_tolerance, absolute_tolerance)
+
+
+class ApproxDecimal(ApproxScalar):
+    """Perform approximate comparisons where the expected value is a Decimal."""
+
+    DEFAULT_ABSOLUTE_TOLERANCE = Decimal("1e-12")
+    DEFAULT_RELATIVE_TOLERANCE = Decimal("1e-6")
+
+
+def approx(expected, rel=None, abs=None, nan_ok: bool = False) -> ApproxBase:
+    """Assert that two numbers (or two sets of numbers) are equal to each other
+    within some tolerance.
+
+    Due to the `intricacies of floating-point arithmetic`__, numbers that we
+    would intuitively expect to be equal are not always so::
+
+        >>> 0.1 + 0.2 == 0.3
+        False
+
+    __ https://docs.python.org/3/tutorial/floatingpoint.html
+
+    This problem is commonly encountered when writing tests, e.g. when making
+    sure that floating-point values are what you expect them to be.  One way to
+    deal with this problem is to assert that two floating-point numbers are
+    equal to within some appropriate tolerance::
+
+        >>> abs((0.1 + 0.2) - 0.3) < 1e-6
+        True
+
+    However, comparisons like this are tedious to write and difficult to
+    understand.  Furthermore, absolute comparisons like the one above are
+    usually discouraged because there's no tolerance that works well for all
+    situations.  ``1e-6`` is good for numbers around ``1``, but too small for
+    very big numbers and too big for very small ones.  It's better to express
+    the tolerance as a fraction of the expected value, but relative comparisons
+    like that are even more difficult to write correctly and concisely.
+
+    The ``approx`` class performs floating-point comparisons using a syntax
+    that's as intuitive as possible::
+
+        >>> from pytest import approx
+        >>> 0.1 + 0.2 == approx(0.3)
+        True
+
+    The same syntax also works for sequences of numbers::
+
+        >>> (0.1 + 0.2, 0.2 + 0.4) == approx((0.3, 0.6))
+        True
+
+    Dictionary *values*::
+
+        >>> {'a': 0.1 + 0.2, 'b': 0.2 + 0.4} == approx({'a': 0.3, 'b': 0.6})
+        True
+
+    ``numpy`` arrays::
+
+        >>> import numpy as np                                                          # doctest: +SKIP
+        >>> np.array([0.1, 0.2]) + np.array([0.2, 0.4]) == approx(np.array([0.3, 0.6])) # doctest: +SKIP
+        True
+
+    And for a ``numpy`` array against a scalar::
+
+        >>> import numpy as np                                         # doctest: +SKIP
+        >>> np.array([0.1, 0.2]) + np.array([0.2, 0.1]) == approx(0.3) # doctest: +SKIP
+        True
+
+    By default, ``approx`` considers numbers within a relative tolerance of
+    ``1e-6`` (i.e. one part in a million) of its expected value to be equal.
+    This treatment would lead to surprising results if the expected value was
+    ``0.0``, because nothing but ``0.0`` itself is relatively close to ``0.0``.
+    To handle this case less surprisingly, ``approx`` also considers numbers
+    within an absolute tolerance of ``1e-12`` of its expected value to be
+    equal.  Infinity and NaN are special cases.  Infinity is only considered
+    equal to itself, regardless of the relative tolerance.  NaN is not
+    considered equal to anything by default, but you can make it be equal to
+    itself by setting the ``nan_ok`` argument to True.  (This is meant to
+    facilitate comparing arrays that use NaN to mean "no data".)
+
+    Both the relative and absolute tolerances can be changed by passing
+    arguments to the ``approx`` constructor::
+
+        >>> 1.0001 == approx(1)
+        False
+        >>> 1.0001 == approx(1, rel=1e-3)
+        True
+        >>> 1.0001 == approx(1, abs=1e-3)
+        True
+
+    If you specify ``abs`` but not ``rel``, the comparison will not consider
+    the relative tolerance at all.  In other words, two numbers that are within
+    the default relative tolerance of ``1e-6`` will still be considered unequal
+    if they exceed the specified absolute tolerance.  If you specify both
+    ``abs`` and ``rel``, the numbers will be considered equal if either
+    tolerance is met::
+
+        >>> 1 + 1e-8 == approx(1)
+        True
+        >>> 1 + 1e-8 == approx(1, abs=1e-12)
+        False
+        >>> 1 + 1e-8 == approx(1, rel=1e-6, abs=1e-12)
+        True
+
+    You can also use ``approx`` to compare nonnumeric types, or dicts and
+    sequences containing nonnumeric types, in which case it falls back to
+    strict equality. This can be useful for comparing dicts and sequences that
+    can contain optional values::
+
+        >>> {"required": 1.0000005, "optional": None} == approx({"required": 1, "optional": None})
+        True
+        >>> [None, 1.0000005] == approx([None,1])
+        True
+        >>> ["foo", 1.0000005] == approx([None,1])
+        False
+
+    If you're thinking about using ``approx``, then you might want to know how
+    it compares to other good ways of comparing floating-point numbers.  All of
+    these algorithms are based on relative and absolute tolerances and should
+    agree for the most part, but they do have meaningful differences:
+
+    - ``math.isclose(a, b, rel_tol=1e-9, abs_tol=0.0)``:  True if the relative
+      tolerance is met w.r.t. either ``a`` or ``b`` or if the absolute
+      tolerance is met.  Because the relative tolerance is calculated w.r.t.
+      both ``a`` and ``b``, this test is symmetric (i.e.  neither ``a`` nor
+      ``b`` is a "reference value").  You have to specify an absolute tolerance
+      if you want to compare to ``0.0`` because there is no tolerance by
+      default.  `More information...`__
+
+      __ https://docs.python.org/3/library/math.html#math.isclose
+
+    - ``numpy.isclose(a, b, rtol=1e-5, atol=1e-8)``: True if the difference
+      between ``a`` and ``b`` is less that the sum of the relative tolerance
+      w.r.t. ``b`` and the absolute tolerance.  Because the relative tolerance
+      is only calculated w.r.t. ``b``, this test is asymmetric and you can
+      think of ``b`` as the reference value.  Support for comparing sequences
+      is provided by ``numpy.allclose``.  `More information...`__
+
+      __ https://numpy.org/doc/stable/reference/generated/numpy.isclose.html
+
+    - ``unittest.TestCase.assertAlmostEqual(a, b)``: True if ``a`` and ``b``
+      are within an absolute tolerance of ``1e-7``.  No relative tolerance is
+      considered and the absolute tolerance cannot be changed, so this function
+      is not appropriate for very large or very small numbers.  Also, it's only
+      available in subclasses of ``unittest.TestCase`` and it's ugly because it
+      doesn't follow PEP8.  `More information...`__
+
+      __ https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertAlmostEqual
+
+    - ``a == pytest.approx(b, rel=1e-6, abs=1e-12)``: True if the relative
+      tolerance is met w.r.t. ``b`` or if the absolute tolerance is met.
+      Because the relative tolerance is only calculated w.r.t. ``b``, this test
+      is asymmetric and you can think of ``b`` as the reference value.  In the
+      special case that you explicitly specify an absolute tolerance but not a
+      relative tolerance, only the absolute tolerance is considered.
+
+    .. warning::
+
+       .. versionchanged:: 3.2
+
+       In order to avoid inconsistent behavior, ``TypeError`` is
+       raised for ``>``, ``>=``, ``<`` and ``<=`` comparisons.
+       The example below illustrates the problem::
+
+           assert approx(0.1) > 0.1 + 1e-10  # calls approx(0.1).__gt__(0.1 + 1e-10)
+           assert 0.1 + 1e-10 > approx(0.1)  # calls approx(0.1).__lt__(0.1 + 1e-10)
+
+       In the second example one expects ``approx(0.1).__le__(0.1 + 1e-10)``
+       to be called. But instead, ``approx(0.1).__lt__(0.1 + 1e-10)`` is used to
+       comparison. This is because the call hierarchy of rich comparisons
+       follows a fixed behavior. `More information...`__
+
+       __ https://docs.python.org/3/reference/datamodel.html#object.__ge__
+
+    .. versionchanged:: 3.7.1
+       ``approx`` raises ``TypeError`` when it encounters a dict value or
+       sequence element of nonnumeric type.
+
+    .. versionchanged:: 6.1.0
+       ``approx`` falls back to strict equality for nonnumeric types instead
+       of raising ``TypeError``.
+    """
+
+    # Delegate the comparison to a class that knows how to deal with the type
+    # of the expected value (e.g. int, float, list, dict, numpy.array, etc).
+    #
+    # The primary responsibility of these classes is to implement ``__eq__()``
+    # and ``__repr__()``.  The former is used to actually check if some
+    # "actual" value is equivalent to the given expected value within the
+    # allowed tolerance.  The latter is used to show the user the expected
+    # value and tolerance, in the case that a test failed.
+    #
+    # The actual logic for making approximate comparisons can be found in
+    # ApproxScalar, which is used to compare individual numbers.  All of the
+    # other Approx classes eventually delegate to this class.  The ApproxBase
+    # class provides some convenient methods and overloads, but isn't really
+    # essential.
+
+    __tracebackhide__ = True
+
+    if isinstance(expected, Decimal):
+        cls: Type[ApproxBase] = ApproxDecimal
+    elif isinstance(expected, Mapping):
+        cls = ApproxMapping
+    elif _is_numpy_array(expected):
+        expected = _as_numpy_array(expected)
+        cls = ApproxNumpy
+    elif (
+        isinstance(expected, Iterable)
+        and isinstance(expected, Sized)
+        # Type ignored because the error is wrong -- not unreachable.
+        and not isinstance(expected, STRING_TYPES)  # type: ignore[unreachable]
+    ):
+        cls = ApproxSequencelike
+    else:
+        cls = ApproxScalar
+
+    return cls(expected, rel, abs, nan_ok)
+
+
+def _is_numpy_array(obj: object) -> bool:
+    """
+    Return true if the given object is implicitly convertible to ndarray,
+    and numpy is already imported.
+    """
+    return _as_numpy_array(obj) is not None
+
+
+def _as_numpy_array(obj: object) -> Optional["ndarray"]:
+    """
+    Return an ndarray if the given object is implicitly convertible to ndarray,
+    and numpy is already imported, otherwise None.
+    """
+    import sys
+
+    np: Any = sys.modules.get("numpy")
+    if np is not None:
+        # avoid infinite recursion on numpy scalars, which have __array__
+        if np.isscalar(obj):
+            return None
+        elif isinstance(obj, np.ndarray):
+            return obj
+        elif hasattr(obj, "__array__") or hasattr("obj", "__array_interface__"):
+            return np.asarray(obj)
+    return None
+
+
+# builtin pytest.raises helper
+
+_E = TypeVar("_E", bound=BaseException)
+
+
+@overload
+def raises(
+    expected_exception: Union[Type[_E], Tuple[Type[_E], ...]],
+    *,
+    match: Optional[Union[str, Pattern[str]]] = ...,
+) -> "RaisesContext[_E]":
+    ...
+
+
+@overload
+def raises(
+    expected_exception: Union[Type[_E], Tuple[Type[_E], ...]],
+    func: Callable[..., Any],
+    *args: Any,
+    **kwargs: Any,
+) -> _pytest._code.ExceptionInfo[_E]:
+    ...
+
+
+def raises(
+    expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], *args: Any, **kwargs: Any
+) -> Union["RaisesContext[_E]", _pytest._code.ExceptionInfo[_E]]:
+    r"""Assert that a code block/function call raises ``expected_exception``
+    or raise a failure exception otherwise.
+
+    :kwparam match:
+        If specified, a string containing a regular expression,
+        or a regular expression object, that is tested against the string
+        representation of the exception using ``re.search``. To match a literal
+        string that may contain `special characters`__, the pattern can
+        first be escaped with ``re.escape``.
+
+        (This is only used when ``pytest.raises`` is used as a context manager,
+        and passed through to the function otherwise.
+        When using ``pytest.raises`` as a function, you can use:
+        ``pytest.raises(Exc, func, match="passed on").match("my pattern")``.)
+
+        __ https://docs.python.org/3/library/re.html#regular-expression-syntax
+
+    .. currentmodule:: _pytest._code
+
+    Use ``pytest.raises`` as a context manager, which will capture the exception of the given
+    type::
+
+        >>> import pytest
+        >>> with pytest.raises(ZeroDivisionError):
+        ...    1/0
+
+    If the code block does not raise the expected exception (``ZeroDivisionError`` in the example
+    above), or no exception at all, the check will fail instead.
+
+    You can also use the keyword argument ``match`` to assert that the
+    exception matches a text or regex::
+
+        >>> with pytest.raises(ValueError, match='must be 0 or None'):
+        ...     raise ValueError("value must be 0 or None")
+
+        >>> with pytest.raises(ValueError, match=r'must be \d+$'):
+        ...     raise ValueError("value must be 42")
+
+    The context manager produces an :class:`ExceptionInfo` object which can be used to inspect the
+    details of the captured exception::
+
+        >>> with pytest.raises(ValueError) as exc_info:
+        ...     raise ValueError("value must be 42")
+        >>> assert exc_info.type is ValueError
+        >>> assert exc_info.value.args[0] == "value must be 42"
+
+    .. note::
+
+       When using ``pytest.raises`` as a context manager, it's worthwhile to
+       note that normal context manager rules apply and that the exception
+       raised *must* be the final line in the scope of the context manager.
+       Lines of code after that, within the scope of the context manager will
+       not be executed. For example::
+
+           >>> value = 15
+           >>> with pytest.raises(ValueError) as exc_info:
+           ...     if value > 10:
+           ...         raise ValueError("value must be <= 10")
+           ...     assert exc_info.type is ValueError  # this will not execute
+
+       Instead, the following approach must be taken (note the difference in
+       scope)::
+
+           >>> with pytest.raises(ValueError) as exc_info:
+           ...     if value > 10:
+           ...         raise ValueError("value must be <= 10")
+           ...
+           >>> assert exc_info.type is ValueError
+
+    **Using with** ``pytest.mark.parametrize``
+
+    When using :ref:`pytest.mark.parametrize ref`
+    it is possible to parametrize tests such that
+    some runs raise an exception and others do not.
+
+    See :ref:`parametrizing_conditional_raising` for an example.
+
+    **Legacy form**
+
+    It is possible to specify a callable by passing a to-be-called lambda::
+
+        >>> raises(ZeroDivisionError, lambda: 1/0)
+        <ExceptionInfo ...>
+
+    or you can specify an arbitrary callable with arguments::
+
+        >>> def f(x): return 1/x
+        ...
+        >>> raises(ZeroDivisionError, f, 0)
+        <ExceptionInfo ...>
+        >>> raises(ZeroDivisionError, f, x=0)
+        <ExceptionInfo ...>
+
+    The form above is fully supported but discouraged for new code because the
+    context manager form is regarded as more readable and less error-prone.
+
+    .. note::
+        Similar to caught exception objects in Python, explicitly clearing
+        local references to returned ``ExceptionInfo`` objects can
+        help the Python interpreter speed up its garbage collection.
+
+        Clearing those references breaks a reference cycle
+        (``ExceptionInfo`` --> caught exception --> frame stack raising
+        the exception --> current frame stack --> local variables -->
+        ``ExceptionInfo``) which makes Python keep all objects referenced
+        from that cycle (including all local variables in the current
+        frame) alive until the next cyclic garbage collection run.
+        More detailed information can be found in the official Python
+        documentation for :ref:`the try statement <python:try>`.
+    """
+    __tracebackhide__ = True
+
+    if isinstance(expected_exception, type):
+        excepted_exceptions: Tuple[Type[_E], ...] = (expected_exception,)
+    else:
+        excepted_exceptions = expected_exception
+    for exc in excepted_exceptions:
+        if not isinstance(exc, type) or not issubclass(exc, BaseException):  # type: ignore[unreachable]
+            msg = "expected exception must be a BaseException type, not {}"  # type: ignore[unreachable]
+            not_a = exc.__name__ if isinstance(exc, type) else type(exc).__name__
+            raise TypeError(msg.format(not_a))
+
+    message = f"DID NOT RAISE {expected_exception}"
+
+    if not args:
+        match: Optional[Union[str, Pattern[str]]] = kwargs.pop("match", None)
+        if kwargs:
+            msg = "Unexpected keyword arguments passed to pytest.raises: "
+            msg += ", ".join(sorted(kwargs))
+            msg += "\nUse context-manager form instead?"
+            raise TypeError(msg)
+        return RaisesContext(expected_exception, message, match)
+    else:
+        func = args[0]
+        if not callable(func):
+            raise TypeError(
+                "{!r} object (type: {}) must be callable".format(func, type(func))
+            )
+        try:
+            func(*args[1:], **kwargs)
+        except expected_exception as e:
+            # We just caught the exception - there is a traceback.
+            assert e.__traceback__ is not None
+            return _pytest._code.ExceptionInfo.from_exc_info(
+                (type(e), e, e.__traceback__)
+            )
+    fail(message)
+
+
+# This doesn't work with mypy for now. Use fail.Exception instead.
+raises.Exception = fail.Exception  # type: ignore
+
+
+@final
+class RaisesContext(Generic[_E]):
+    def __init__(
+        self,
+        expected_exception: Union[Type[_E], Tuple[Type[_E], ...]],
+        message: str,
+        match_expr: Optional[Union[str, Pattern[str]]] = None,
+    ) -> None:
+        self.expected_exception = expected_exception
+        self.message = message
+        self.match_expr = match_expr
+        self.excinfo: Optional[_pytest._code.ExceptionInfo[_E]] = None
+
+    def __enter__(self) -> _pytest._code.ExceptionInfo[_E]:
+        self.excinfo = _pytest._code.ExceptionInfo.for_later()
+        return self.excinfo
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> bool:
+        __tracebackhide__ = True
+        if exc_type is None:
+            fail(self.message)
+        assert self.excinfo is not None
+        if not issubclass(exc_type, self.expected_exception):
+            return False
+        # Cast to narrow the exception type now that it's verified.
+        exc_info = cast(Tuple[Type[_E], _E, TracebackType], (exc_type, exc_val, exc_tb))
+        self.excinfo.fill_unfilled(exc_info)
+        if self.match_expr is not None:
+            self.excinfo.match(self.match_expr)
+        return True
diff --git a/myenv/lib/python3.9/site-packages/_pytest/recwarn.py b/myenv/lib/python3.9/site-packages/_pytest/recwarn.py
new file mode 100644
index 0000000..d872d9d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/recwarn.py
@@ -0,0 +1,296 @@
+"""Record warnings during test function execution."""
+import re
+import warnings
+from types import TracebackType
+from typing import Any
+from typing import Callable
+from typing import Generator
+from typing import Iterator
+from typing import List
+from typing import Optional
+from typing import overload
+from typing import Pattern
+from typing import Tuple
+from typing import Type
+from typing import TypeVar
+from typing import Union
+
+from _pytest.compat import final
+from _pytest.deprecated import check_ispytest
+from _pytest.fixtures import fixture
+from _pytest.outcomes import fail
+
+
+T = TypeVar("T")
+
+
+@fixture
+def recwarn() -> Generator["WarningsRecorder", None, None]:
+    """Return a :class:`WarningsRecorder` instance that records all warnings emitted by test functions.
+
+    See http://docs.python.org/library/warnings.html for information
+    on warning categories.
+    """
+    wrec = WarningsRecorder(_ispytest=True)
+    with wrec:
+        warnings.simplefilter("default")
+        yield wrec
+
+
+@overload
+def deprecated_call(
+    *, match: Optional[Union[str, Pattern[str]]] = ...
+) -> "WarningsRecorder":
+    ...
+
+
+@overload
+def deprecated_call(func: Callable[..., T], *args: Any, **kwargs: Any) -> T:
+    ...
+
+
+def deprecated_call(
+    func: Optional[Callable[..., Any]] = None, *args: Any, **kwargs: Any
+) -> Union["WarningsRecorder", Any]:
+    """Assert that code produces a ``DeprecationWarning`` or ``PendingDeprecationWarning``.
+
+    This function can be used as a context manager::
+
+        >>> import warnings
+        >>> def api_call_v2():
+        ...     warnings.warn('use v3 of this api', DeprecationWarning)
+        ...     return 200
+
+        >>> import pytest
+        >>> with pytest.deprecated_call():
+        ...    assert api_call_v2() == 200
+
+    It can also be used by passing a function and ``*args`` and ``**kwargs``,
+    in which case it will ensure calling ``func(*args, **kwargs)`` produces one of
+    the warnings types above. The return value is the return value of the function.
+
+    In the context manager form you may use the keyword argument ``match`` to assert
+    that the warning matches a text or regex.
+
+    The context manager produces a list of :class:`warnings.WarningMessage` objects,
+    one for each warning raised.
+    """
+    __tracebackhide__ = True
+    if func is not None:
+        args = (func,) + args
+    return warns((DeprecationWarning, PendingDeprecationWarning), *args, **kwargs)
+
+
+@overload
+def warns(
+    expected_warning: Optional[Union[Type[Warning], Tuple[Type[Warning], ...]]],
+    *,
+    match: Optional[Union[str, Pattern[str]]] = ...,
+) -> "WarningsChecker":
+    ...
+
+
+@overload
+def warns(
+    expected_warning: Optional[Union[Type[Warning], Tuple[Type[Warning], ...]]],
+    func: Callable[..., T],
+    *args: Any,
+    **kwargs: Any,
+) -> T:
+    ...
+
+
+def warns(
+    expected_warning: Optional[Union[Type[Warning], Tuple[Type[Warning], ...]]],
+    *args: Any,
+    match: Optional[Union[str, Pattern[str]]] = None,
+    **kwargs: Any,
+) -> Union["WarningsChecker", Any]:
+    r"""Assert that code raises a particular class of warning.
+
+    Specifically, the parameter ``expected_warning`` can be a warning class or
+    sequence of warning classes, and the inside the ``with`` block must issue a warning of that class or
+    classes.
+
+    This helper produces a list of :class:`warnings.WarningMessage` objects,
+    one for each warning raised.
+
+    This function can be used as a context manager, or any of the other ways
+    :func:`pytest.raises` can be used::
+
+        >>> import pytest
+        >>> with pytest.warns(RuntimeWarning):
+        ...    warnings.warn("my warning", RuntimeWarning)
+
+    In the context manager form you may use the keyword argument ``match`` to assert
+    that the warning matches a text or regex::
+
+        >>> with pytest.warns(UserWarning, match='must be 0 or None'):
+        ...     warnings.warn("value must be 0 or None", UserWarning)
+
+        >>> with pytest.warns(UserWarning, match=r'must be \d+$'):
+        ...     warnings.warn("value must be 42", UserWarning)
+
+        >>> with pytest.warns(UserWarning, match=r'must be \d+$'):
+        ...     warnings.warn("this is not here", UserWarning)
+        Traceback (most recent call last):
+          ...
+        Failed: DID NOT WARN. No warnings of type ...UserWarning... was emitted...
+
+    """
+    __tracebackhide__ = True
+    if not args:
+        if kwargs:
+            msg = "Unexpected keyword arguments passed to pytest.warns: "
+            msg += ", ".join(sorted(kwargs))
+            msg += "\nUse context-manager form instead?"
+            raise TypeError(msg)
+        return WarningsChecker(expected_warning, match_expr=match, _ispytest=True)
+    else:
+        func = args[0]
+        if not callable(func):
+            raise TypeError(
+                "{!r} object (type: {}) must be callable".format(func, type(func))
+            )
+        with WarningsChecker(expected_warning, _ispytest=True):
+            return func(*args[1:], **kwargs)
+
+
+class WarningsRecorder(warnings.catch_warnings):
+    """A context manager to record raised warnings.
+
+    Adapted from `warnings.catch_warnings`.
+    """
+
+    def __init__(self, *, _ispytest: bool = False) -> None:
+        check_ispytest(_ispytest)
+        # Type ignored due to the way typeshed handles warnings.catch_warnings.
+        super().__init__(record=True)  # type: ignore[call-arg]
+        self._entered = False
+        self._list: List[warnings.WarningMessage] = []
+
+    @property
+    def list(self) -> List["warnings.WarningMessage"]:
+        """The list of recorded warnings."""
+        return self._list
+
+    def __getitem__(self, i: int) -> "warnings.WarningMessage":
+        """Get a recorded warning by index."""
+        return self._list[i]
+
+    def __iter__(self) -> Iterator["warnings.WarningMessage"]:
+        """Iterate through the recorded warnings."""
+        return iter(self._list)
+
+    def __len__(self) -> int:
+        """The number of recorded warnings."""
+        return len(self._list)
+
+    def pop(self, cls: Type[Warning] = Warning) -> "warnings.WarningMessage":
+        """Pop the first recorded warning, raise exception if not exists."""
+        for i, w in enumerate(self._list):
+            if issubclass(w.category, cls):
+                return self._list.pop(i)
+        __tracebackhide__ = True
+        raise AssertionError("%r not found in warning list" % cls)
+
+    def clear(self) -> None:
+        """Clear the list of recorded warnings."""
+        self._list[:] = []
+
+    # Type ignored because it doesn't exactly warnings.catch_warnings.__enter__
+    # -- it returns a List but we only emulate one.
+    def __enter__(self) -> "WarningsRecorder":  # type: ignore
+        if self._entered:
+            __tracebackhide__ = True
+            raise RuntimeError("Cannot enter %r twice" % self)
+        _list = super().__enter__()
+        # record=True means it's None.
+        assert _list is not None
+        self._list = _list
+        warnings.simplefilter("always")
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        if not self._entered:
+            __tracebackhide__ = True
+            raise RuntimeError("Cannot exit %r without entering first" % self)
+
+        super().__exit__(exc_type, exc_val, exc_tb)
+
+        # Built-in catch_warnings does not reset entered state so we do it
+        # manually here for this context manager to become reusable.
+        self._entered = False
+
+
+@final
+class WarningsChecker(WarningsRecorder):
+    def __init__(
+        self,
+        expected_warning: Optional[
+            Union[Type[Warning], Tuple[Type[Warning], ...]]
+        ] = None,
+        match_expr: Optional[Union[str, Pattern[str]]] = None,
+        *,
+        _ispytest: bool = False,
+    ) -> None:
+        check_ispytest(_ispytest)
+        super().__init__(_ispytest=True)
+
+        msg = "exceptions must be derived from Warning, not %s"
+        if expected_warning is None:
+            expected_warning_tup = None
+        elif isinstance(expected_warning, tuple):
+            for exc in expected_warning:
+                if not issubclass(exc, Warning):
+                    raise TypeError(msg % type(exc))
+            expected_warning_tup = expected_warning
+        elif issubclass(expected_warning, Warning):
+            expected_warning_tup = (expected_warning,)
+        else:
+            raise TypeError(msg % type(expected_warning))
+
+        self.expected_warning = expected_warning_tup
+        self.match_expr = match_expr
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        super().__exit__(exc_type, exc_val, exc_tb)
+
+        __tracebackhide__ = True
+
+        # only check if we're not currently handling an exception
+        if exc_type is None and exc_val is None and exc_tb is None:
+            if self.expected_warning is not None:
+                if not any(issubclass(r.category, self.expected_warning) for r in self):
+                    __tracebackhide__ = True
+                    fail(
+                        "DID NOT WARN. No warnings of type {} was emitted. "
+                        "The list of emitted warnings is: {}.".format(
+                            self.expected_warning, [each.message for each in self]
+                        )
+                    )
+                elif self.match_expr is not None:
+                    for r in self:
+                        if issubclass(r.category, self.expected_warning):
+                            if re.compile(self.match_expr).search(str(r.message)):
+                                break
+                    else:
+                        fail(
+                            "DID NOT WARN. No warnings of type {} matching"
+                            " ('{}') was emitted. The list of emitted warnings"
+                            " is: {}.".format(
+                                self.expected_warning,
+                                self.match_expr,
+                                [each.message for each in self],
+                            )
+                        )
diff --git a/myenv/lib/python3.9/site-packages/_pytest/reports.py b/myenv/lib/python3.9/site-packages/_pytest/reports.py
new file mode 100644
index 0000000..58f1251
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/reports.py
@@ -0,0 +1,572 @@
+from io import StringIO
+from pathlib import Path
+from pprint import pprint
+from typing import Any
+from typing import cast
+from typing import Dict
+from typing import Iterable
+from typing import Iterator
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import TypeVar
+from typing import Union
+
+import attr
+import py
+
+from _pytest._code.code import ExceptionChainRepr
+from _pytest._code.code import ExceptionInfo
+from _pytest._code.code import ExceptionRepr
+from _pytest._code.code import ReprEntry
+from _pytest._code.code import ReprEntryNative
+from _pytest._code.code import ReprExceptionInfo
+from _pytest._code.code import ReprFileLocation
+from _pytest._code.code import ReprFuncArgs
+from _pytest._code.code import ReprLocals
+from _pytest._code.code import ReprTraceback
+from _pytest._code.code import TerminalRepr
+from _pytest._io import TerminalWriter
+from _pytest.compat import final
+from _pytest.config import Config
+from _pytest.nodes import Collector
+from _pytest.nodes import Item
+from _pytest.outcomes import skip
+
+if TYPE_CHECKING:
+    from typing import NoReturn
+    from typing_extensions import Literal
+
+    from _pytest.runner import CallInfo
+
+
+def getworkerinfoline(node):
+    try:
+        return node._workerinfocache
+    except AttributeError:
+        d = node.workerinfo
+        ver = "%s.%s.%s" % d["version_info"][:3]
+        node._workerinfocache = s = "[{}] {} -- Python {} {}".format(
+            d["id"], d["sysplatform"], ver, d["executable"]
+        )
+        return s
+
+
+_R = TypeVar("_R", bound="BaseReport")
+
+
+class BaseReport:
+    when: Optional[str]
+    location: Optional[Tuple[str, Optional[int], str]]
+    longrepr: Union[
+        None, ExceptionInfo[BaseException], Tuple[str, int, str], str, TerminalRepr
+    ]
+    sections: List[Tuple[str, str]]
+    nodeid: str
+
+    def __init__(self, **kw: Any) -> None:
+        self.__dict__.update(kw)
+
+    if TYPE_CHECKING:
+        # Can have arbitrary fields given to __init__().
+        def __getattr__(self, key: str) -> Any:
+            ...
+
+    def toterminal(self, out: TerminalWriter) -> None:
+        if hasattr(self, "node"):
+            out.line(getworkerinfoline(self.node))
+
+        longrepr = self.longrepr
+        if longrepr is None:
+            return
+
+        if hasattr(longrepr, "toterminal"):
+            longrepr_terminal = cast(TerminalRepr, longrepr)
+            longrepr_terminal.toterminal(out)
+        else:
+            try:
+                s = str(longrepr)
+            except UnicodeEncodeError:
+                s = "<unprintable longrepr>"
+            out.line(s)
+
+    def get_sections(self, prefix: str) -> Iterator[Tuple[str, str]]:
+        for name, content in self.sections:
+            if name.startswith(prefix):
+                yield prefix, content
+
+    @property
+    def longreprtext(self) -> str:
+        """Read-only property that returns the full string representation of
+        ``longrepr``.
+
+        .. versionadded:: 3.0
+        """
+        file = StringIO()
+        tw = TerminalWriter(file)
+        tw.hasmarkup = False
+        self.toterminal(tw)
+        exc = file.getvalue()
+        return exc.strip()
+
+    @property
+    def caplog(self) -> str:
+        """Return captured log lines, if log capturing is enabled.
+
+        .. versionadded:: 3.5
+        """
+        return "\n".join(
+            content for (prefix, content) in self.get_sections("Captured log")
+        )
+
+    @property
+    def capstdout(self) -> str:
+        """Return captured text from stdout, if capturing is enabled.
+
+        .. versionadded:: 3.0
+        """
+        return "".join(
+            content for (prefix, content) in self.get_sections("Captured stdout")
+        )
+
+    @property
+    def capstderr(self) -> str:
+        """Return captured text from stderr, if capturing is enabled.
+
+        .. versionadded:: 3.0
+        """
+        return "".join(
+            content for (prefix, content) in self.get_sections("Captured stderr")
+        )
+
+    passed = property(lambda x: x.outcome == "passed")
+    failed = property(lambda x: x.outcome == "failed")
+    skipped = property(lambda x: x.outcome == "skipped")
+
+    @property
+    def fspath(self) -> str:
+        return self.nodeid.split("::")[0]
+
+    @property
+    def count_towards_summary(self) -> bool:
+        """**Experimental** Whether this report should be counted towards the
+        totals shown at the end of the test session: "1 passed, 1 failure, etc".
+
+        .. note::
+
+            This function is considered **experimental**, so beware that it is subject to changes
+            even in patch releases.
+        """
+        return True
+
+    @property
+    def head_line(self) -> Optional[str]:
+        """**Experimental** The head line shown with longrepr output for this
+        report, more commonly during traceback representation during
+        failures::
+
+            ________ Test.foo ________
+
+
+        In the example above, the head_line is "Test.foo".
+
+        .. note::
+
+            This function is considered **experimental**, so beware that it is subject to changes
+            even in patch releases.
+        """
+        if self.location is not None:
+            fspath, lineno, domain = self.location
+            return domain
+        return None
+
+    def _get_verbose_word(self, config: Config):
+        _category, _short, verbose = config.hook.pytest_report_teststatus(
+            report=self, config=config
+        )
+        return verbose
+
+    def _to_json(self) -> Dict[str, Any]:
+        """Return the contents of this report as a dict of builtin entries,
+        suitable for serialization.
+
+        This was originally the serialize_report() function from xdist (ca03269).
+
+        Experimental method.
+        """
+        return _report_to_json(self)
+
+    @classmethod
+    def _from_json(cls: Type[_R], reportdict: Dict[str, object]) -> _R:
+        """Create either a TestReport or CollectReport, depending on the calling class.
+
+        It is the callers responsibility to know which class to pass here.
+
+        This was originally the serialize_report() function from xdist (ca03269).
+
+        Experimental method.
+        """
+        kwargs = _report_kwargs_from_json(reportdict)
+        return cls(**kwargs)
+
+
+def _report_unserialization_failure(
+    type_name: str, report_class: Type[BaseReport], reportdict
+) -> "NoReturn":
+    url = "https://github.com/pytest-dev/pytest/issues"
+    stream = StringIO()
+    pprint("-" * 100, stream=stream)
+    pprint("INTERNALERROR: Unknown entry type returned: %s" % type_name, stream=stream)
+    pprint("report_name: %s" % report_class, stream=stream)
+    pprint(reportdict, stream=stream)
+    pprint("Please report this bug at %s" % url, stream=stream)
+    pprint("-" * 100, stream=stream)
+    raise RuntimeError(stream.getvalue())
+
+
+@final
+class TestReport(BaseReport):
+    """Basic test report object (also used for setup and teardown calls if
+    they fail)."""
+
+    __test__ = False
+
+    def __init__(
+        self,
+        nodeid: str,
+        location: Tuple[str, Optional[int], str],
+        keywords,
+        outcome: "Literal['passed', 'failed', 'skipped']",
+        longrepr: Union[
+            None, ExceptionInfo[BaseException], Tuple[str, int, str], str, TerminalRepr
+        ],
+        when: "Literal['setup', 'call', 'teardown']",
+        sections: Iterable[Tuple[str, str]] = (),
+        duration: float = 0,
+        user_properties: Optional[Iterable[Tuple[str, object]]] = None,
+        **extra,
+    ) -> None:
+        #: Normalized collection nodeid.
+        self.nodeid = nodeid
+
+        #: A (filesystempath, lineno, domaininfo) tuple indicating the
+        #: actual location of a test item - it might be different from the
+        #: collected one e.g. if a method is inherited from a different module.
+        self.location: Tuple[str, Optional[int], str] = location
+
+        #: A name -> value dictionary containing all keywords and
+        #: markers associated with a test invocation.
+        self.keywords = keywords
+
+        #: Test outcome, always one of "passed", "failed", "skipped".
+        self.outcome = outcome
+
+        #: None or a failure representation.
+        self.longrepr = longrepr
+
+        #: One of 'setup', 'call', 'teardown' to indicate runtest phase.
+        self.when = when
+
+        #: User properties is a list of tuples (name, value) that holds user
+        #: defined properties of the test.
+        self.user_properties = list(user_properties or [])
+
+        #: List of pairs ``(str, str)`` of extra information which needs to
+        #: marshallable. Used by pytest to add captured text
+        #: from ``stdout`` and ``stderr``, but may be used by other plugins
+        #: to add arbitrary information to reports.
+        self.sections = list(sections)
+
+        #: Time it took to run just the test.
+        self.duration = duration
+
+        self.__dict__.update(extra)
+
+    def __repr__(self) -> str:
+        return "<{} {!r} when={!r} outcome={!r}>".format(
+            self.__class__.__name__, self.nodeid, self.when, self.outcome
+        )
+
+    @classmethod
+    def from_item_and_call(cls, item: Item, call: "CallInfo[None]") -> "TestReport":
+        """Create and fill a TestReport with standard item and call info."""
+        when = call.when
+        # Remove "collect" from the Literal type -- only for collection calls.
+        assert when != "collect"
+        duration = call.duration
+        keywords = {x: 1 for x in item.keywords}
+        excinfo = call.excinfo
+        sections = []
+        if not call.excinfo:
+            outcome: Literal["passed", "failed", "skipped"] = "passed"
+            longrepr: Union[
+                None,
+                ExceptionInfo[BaseException],
+                Tuple[str, int, str],
+                str,
+                TerminalRepr,
+            ] = (None)
+        else:
+            if not isinstance(excinfo, ExceptionInfo):
+                outcome = "failed"
+                longrepr = excinfo
+            elif isinstance(excinfo.value, skip.Exception):
+                outcome = "skipped"
+                r = excinfo._getreprcrash()
+                longrepr = (str(r.path), r.lineno, r.message)
+            else:
+                outcome = "failed"
+                if call.when == "call":
+                    longrepr = item.repr_failure(excinfo)
+                else:  # exception in setup or teardown
+                    longrepr = item._repr_failure_py(
+                        excinfo, style=item.config.getoption("tbstyle", "auto")
+                    )
+        for rwhen, key, content in item._report_sections:
+            sections.append((f"Captured {key} {rwhen}", content))
+        return cls(
+            item.nodeid,
+            item.location,
+            keywords,
+            outcome,
+            longrepr,
+            when,
+            sections,
+            duration,
+            user_properties=item.user_properties,
+        )
+
+
+@final
+class CollectReport(BaseReport):
+    """Collection report object."""
+
+    when = "collect"
+
+    def __init__(
+        self,
+        nodeid: str,
+        outcome: "Literal['passed', 'skipped', 'failed']",
+        longrepr,
+        result: Optional[List[Union[Item, Collector]]],
+        sections: Iterable[Tuple[str, str]] = (),
+        **extra,
+    ) -> None:
+        #: Normalized collection nodeid.
+        self.nodeid = nodeid
+
+        #: Test outcome, always one of "passed", "failed", "skipped".
+        self.outcome = outcome
+
+        #: None or a failure representation.
+        self.longrepr = longrepr
+
+        #: The collected items and collection nodes.
+        self.result = result or []
+
+        #: List of pairs ``(str, str)`` of extra information which needs to
+        #: marshallable.
+        # Used by pytest to add captured text : from ``stdout`` and ``stderr``,
+        # but may be used by other plugins : to add arbitrary information to
+        # reports.
+        self.sections = list(sections)
+
+        self.__dict__.update(extra)
+
+    @property
+    def location(self):
+        return (self.fspath, None, self.fspath)
+
+    def __repr__(self) -> str:
+        return "<CollectReport {!r} lenresult={} outcome={!r}>".format(
+            self.nodeid, len(self.result), self.outcome
+        )
+
+
+class CollectErrorRepr(TerminalRepr):
+    def __init__(self, msg: str) -> None:
+        self.longrepr = msg
+
+    def toterminal(self, out: TerminalWriter) -> None:
+        out.line(self.longrepr, red=True)
+
+
+def pytest_report_to_serializable(
+    report: Union[CollectReport, TestReport]
+) -> Optional[Dict[str, Any]]:
+    if isinstance(report, (TestReport, CollectReport)):
+        data = report._to_json()
+        data["$report_type"] = report.__class__.__name__
+        return data
+    # TODO: Check if this is actually reachable.
+    return None  # type: ignore[unreachable]
+
+
+def pytest_report_from_serializable(
+    data: Dict[str, Any],
+) -> Optional[Union[CollectReport, TestReport]]:
+    if "$report_type" in data:
+        if data["$report_type"] == "TestReport":
+            return TestReport._from_json(data)
+        elif data["$report_type"] == "CollectReport":
+            return CollectReport._from_json(data)
+        assert False, "Unknown report_type unserialize data: {}".format(
+            data["$report_type"]
+        )
+    return None
+
+
+def _report_to_json(report: BaseReport) -> Dict[str, Any]:
+    """Return the contents of this report as a dict of builtin entries,
+    suitable for serialization.
+
+    This was originally the serialize_report() function from xdist (ca03269).
+    """
+
+    def serialize_repr_entry(
+        entry: Union[ReprEntry, ReprEntryNative]
+    ) -> Dict[str, Any]:
+        data = attr.asdict(entry)
+        for key, value in data.items():
+            if hasattr(value, "__dict__"):
+                data[key] = attr.asdict(value)
+        entry_data = {"type": type(entry).__name__, "data": data}
+        return entry_data
+
+    def serialize_repr_traceback(reprtraceback: ReprTraceback) -> Dict[str, Any]:
+        result = attr.asdict(reprtraceback)
+        result["reprentries"] = [
+            serialize_repr_entry(x) for x in reprtraceback.reprentries
+        ]
+        return result
+
+    def serialize_repr_crash(
+        reprcrash: Optional[ReprFileLocation],
+    ) -> Optional[Dict[str, Any]]:
+        if reprcrash is not None:
+            return attr.asdict(reprcrash)
+        else:
+            return None
+
+    def serialize_exception_longrepr(rep: BaseReport) -> Dict[str, Any]:
+        assert rep.longrepr is not None
+        # TODO: Investigate whether the duck typing is really necessary here.
+        longrepr = cast(ExceptionRepr, rep.longrepr)
+        result: Dict[str, Any] = {
+            "reprcrash": serialize_repr_crash(longrepr.reprcrash),
+            "reprtraceback": serialize_repr_traceback(longrepr.reprtraceback),
+            "sections": longrepr.sections,
+        }
+        if isinstance(longrepr, ExceptionChainRepr):
+            result["chain"] = []
+            for repr_traceback, repr_crash, description in longrepr.chain:
+                result["chain"].append(
+                    (
+                        serialize_repr_traceback(repr_traceback),
+                        serialize_repr_crash(repr_crash),
+                        description,
+                    )
+                )
+        else:
+            result["chain"] = None
+        return result
+
+    d = report.__dict__.copy()
+    if hasattr(report.longrepr, "toterminal"):
+        if hasattr(report.longrepr, "reprtraceback") and hasattr(
+            report.longrepr, "reprcrash"
+        ):
+            d["longrepr"] = serialize_exception_longrepr(report)
+        else:
+            d["longrepr"] = str(report.longrepr)
+    else:
+        d["longrepr"] = report.longrepr
+    for name in d:
+        if isinstance(d[name], (py.path.local, Path)):
+            d[name] = str(d[name])
+        elif name == "result":
+            d[name] = None  # for now
+    return d
+
+
+def _report_kwargs_from_json(reportdict: Dict[str, Any]) -> Dict[str, Any]:
+    """Return **kwargs that can be used to construct a TestReport or
+    CollectReport instance.
+
+    This was originally the serialize_report() function from xdist (ca03269).
+    """
+
+    def deserialize_repr_entry(entry_data):
+        data = entry_data["data"]
+        entry_type = entry_data["type"]
+        if entry_type == "ReprEntry":
+            reprfuncargs = None
+            reprfileloc = None
+            reprlocals = None
+            if data["reprfuncargs"]:
+                reprfuncargs = ReprFuncArgs(**data["reprfuncargs"])
+            if data["reprfileloc"]:
+                reprfileloc = ReprFileLocation(**data["reprfileloc"])
+            if data["reprlocals"]:
+                reprlocals = ReprLocals(data["reprlocals"]["lines"])
+
+            reprentry: Union[ReprEntry, ReprEntryNative] = ReprEntry(
+                lines=data["lines"],
+                reprfuncargs=reprfuncargs,
+                reprlocals=reprlocals,
+                reprfileloc=reprfileloc,
+                style=data["style"],
+            )
+        elif entry_type == "ReprEntryNative":
+            reprentry = ReprEntryNative(data["lines"])
+        else:
+            _report_unserialization_failure(entry_type, TestReport, reportdict)
+        return reprentry
+
+    def deserialize_repr_traceback(repr_traceback_dict):
+        repr_traceback_dict["reprentries"] = [
+            deserialize_repr_entry(x) for x in repr_traceback_dict["reprentries"]
+        ]
+        return ReprTraceback(**repr_traceback_dict)
+
+    def deserialize_repr_crash(repr_crash_dict: Optional[Dict[str, Any]]):
+        if repr_crash_dict is not None:
+            return ReprFileLocation(**repr_crash_dict)
+        else:
+            return None
+
+    if (
+        reportdict["longrepr"]
+        and "reprcrash" in reportdict["longrepr"]
+        and "reprtraceback" in reportdict["longrepr"]
+    ):
+
+        reprtraceback = deserialize_repr_traceback(
+            reportdict["longrepr"]["reprtraceback"]
+        )
+        reprcrash = deserialize_repr_crash(reportdict["longrepr"]["reprcrash"])
+        if reportdict["longrepr"]["chain"]:
+            chain = []
+            for repr_traceback_data, repr_crash_data, description in reportdict[
+                "longrepr"
+            ]["chain"]:
+                chain.append(
+                    (
+                        deserialize_repr_traceback(repr_traceback_data),
+                        deserialize_repr_crash(repr_crash_data),
+                        description,
+                    )
+                )
+            exception_info: Union[
+                ExceptionChainRepr, ReprExceptionInfo
+            ] = ExceptionChainRepr(chain)
+        else:
+            exception_info = ReprExceptionInfo(reprtraceback, reprcrash)
+
+        for section in reportdict["longrepr"]["sections"]:
+            exception_info.addsection(*section)
+        reportdict["longrepr"] = exception_info
+
+    return reportdict
diff --git a/myenv/lib/python3.9/site-packages/_pytest/runner.py b/myenv/lib/python3.9/site-packages/_pytest/runner.py
new file mode 100644
index 0000000..794690d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/runner.py
@@ -0,0 +1,462 @@
+"""Basic collect and runtest protocol implementations."""
+import bdb
+import os
+import sys
+from typing import Callable
+from typing import cast
+from typing import Dict
+from typing import Generic
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import TypeVar
+from typing import Union
+
+import attr
+
+from .reports import BaseReport
+from .reports import CollectErrorRepr
+from .reports import CollectReport
+from .reports import TestReport
+from _pytest import timing
+from _pytest._code.code import ExceptionChainRepr
+from _pytest._code.code import ExceptionInfo
+from _pytest._code.code import TerminalRepr
+from _pytest.compat import final
+from _pytest.config.argparsing import Parser
+from _pytest.nodes import Collector
+from _pytest.nodes import Item
+from _pytest.nodes import Node
+from _pytest.outcomes import Exit
+from _pytest.outcomes import Skipped
+from _pytest.outcomes import TEST_OUTCOME
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
+    from _pytest.main import Session
+    from _pytest.terminal import TerminalReporter
+
+#
+# pytest plugin hooks.
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("terminal reporting", "reporting", after="general")
+    group.addoption(
+        "--durations",
+        action="store",
+        type=int,
+        default=None,
+        metavar="N",
+        help="show N slowest setup/test durations (N=0 for all).",
+    )
+    group.addoption(
+        "--durations-min",
+        action="store",
+        type=float,
+        default=0.005,
+        metavar="N",
+        help="Minimal duration in seconds for inclusion in slowest list. Default 0.005",
+    )
+
+
+def pytest_terminal_summary(terminalreporter: "TerminalReporter") -> None:
+    durations = terminalreporter.config.option.durations
+    durations_min = terminalreporter.config.option.durations_min
+    verbose = terminalreporter.config.getvalue("verbose")
+    if durations is None:
+        return
+    tr = terminalreporter
+    dlist = []
+    for replist in tr.stats.values():
+        for rep in replist:
+            if hasattr(rep, "duration"):
+                dlist.append(rep)
+    if not dlist:
+        return
+    dlist.sort(key=lambda x: x.duration, reverse=True)  # type: ignore[no-any-return]
+    if not durations:
+        tr.write_sep("=", "slowest durations")
+    else:
+        tr.write_sep("=", "slowest %s durations" % durations)
+        dlist = dlist[:durations]
+
+    for i, rep in enumerate(dlist):
+        if verbose < 2 and rep.duration < durations_min:
+            tr.write_line("")
+            tr.write_line(
+                "(%s durations < %gs hidden.  Use -vv to show these durations.)"
+                % (len(dlist) - i, durations_min)
+            )
+            break
+        tr.write_line(f"{rep.duration:02.2f}s {rep.when:<8} {rep.nodeid}")
+
+
+def pytest_sessionstart(session: "Session") -> None:
+    session._setupstate = SetupState()
+
+
+def pytest_sessionfinish(session: "Session") -> None:
+    session._setupstate.teardown_all()
+
+
+def pytest_runtest_protocol(item: Item, nextitem: Optional[Item]) -> bool:
+    ihook = item.ihook
+    ihook.pytest_runtest_logstart(nodeid=item.nodeid, location=item.location)
+    runtestprotocol(item, nextitem=nextitem)
+    ihook.pytest_runtest_logfinish(nodeid=item.nodeid, location=item.location)
+    return True
+
+
+def runtestprotocol(
+    item: Item, log: bool = True, nextitem: Optional[Item] = None
+) -> List[TestReport]:
+    hasrequest = hasattr(item, "_request")
+    if hasrequest and not item._request:  # type: ignore[attr-defined]
+        item._initrequest()  # type: ignore[attr-defined]
+    rep = call_and_report(item, "setup", log)
+    reports = [rep]
+    if rep.passed:
+        if item.config.getoption("setupshow", False):
+            show_test_item(item)
+        if not item.config.getoption("setuponly", False):
+            reports.append(call_and_report(item, "call", log))
+    reports.append(call_and_report(item, "teardown", log, nextitem=nextitem))
+    # After all teardown hooks have been called
+    # want funcargs and request info to go away.
+    if hasrequest:
+        item._request = False  # type: ignore[attr-defined]
+        item.funcargs = None  # type: ignore[attr-defined]
+    return reports
+
+
+def show_test_item(item: Item) -> None:
+    """Show test function, parameters and the fixtures of the test item."""
+    tw = item.config.get_terminal_writer()
+    tw.line()
+    tw.write(" " * 8)
+    tw.write(item.nodeid)
+    used_fixtures = sorted(getattr(item, "fixturenames", []))
+    if used_fixtures:
+        tw.write(" (fixtures used: {})".format(", ".join(used_fixtures)))
+    tw.flush()
+
+
+def pytest_runtest_setup(item: Item) -> None:
+    _update_current_test_var(item, "setup")
+    item.session._setupstate.prepare(item)
+
+
+def pytest_runtest_call(item: Item) -> None:
+    _update_current_test_var(item, "call")
+    try:
+        del sys.last_type
+        del sys.last_value
+        del sys.last_traceback
+    except AttributeError:
+        pass
+    try:
+        item.runtest()
+    except Exception as e:
+        # Store trace info to allow postmortem debugging
+        sys.last_type = type(e)
+        sys.last_value = e
+        assert e.__traceback__ is not None
+        # Skip *this* frame
+        sys.last_traceback = e.__traceback__.tb_next
+        raise e
+
+
+def pytest_runtest_teardown(item: Item, nextitem: Optional[Item]) -> None:
+    _update_current_test_var(item, "teardown")
+    item.session._setupstate.teardown_exact(item, nextitem)
+    _update_current_test_var(item, None)
+
+
+def _update_current_test_var(
+    item: Item, when: Optional["Literal['setup', 'call', 'teardown']"]
+) -> None:
+    """Update :envvar:`PYTEST_CURRENT_TEST` to reflect the current item and stage.
+
+    If ``when`` is None, delete ``PYTEST_CURRENT_TEST`` from the environment.
+    """
+    var_name = "PYTEST_CURRENT_TEST"
+    if when:
+        value = f"{item.nodeid} ({when})"
+        # don't allow null bytes on environment variables (see #2644, #2957)
+        value = value.replace("\x00", "(null)")
+        os.environ[var_name] = value
+    else:
+        os.environ.pop(var_name)
+
+
+def pytest_report_teststatus(report: BaseReport) -> Optional[Tuple[str, str, str]]:
+    if report.when in ("setup", "teardown"):
+        if report.failed:
+            #      category, shortletter, verbose-word
+            return "error", "E", "ERROR"
+        elif report.skipped:
+            return "skipped", "s", "SKIPPED"
+        else:
+            return "", "", ""
+    return None
+
+
+#
+# Implementation
+
+
+def call_and_report(
+    item: Item, when: "Literal['setup', 'call', 'teardown']", log: bool = True, **kwds
+) -> TestReport:
+    call = call_runtest_hook(item, when, **kwds)
+    hook = item.ihook
+    report: TestReport = hook.pytest_runtest_makereport(item=item, call=call)
+    if log:
+        hook.pytest_runtest_logreport(report=report)
+    if check_interactive_exception(call, report):
+        hook.pytest_exception_interact(node=item, call=call, report=report)
+    return report
+
+
+def check_interactive_exception(call: "CallInfo[object]", report: BaseReport) -> bool:
+    """Check whether the call raised an exception that should be reported as
+    interactive."""
+    if call.excinfo is None:
+        # Didn't raise.
+        return False
+    if hasattr(report, "wasxfail"):
+        # Exception was expected.
+        return False
+    if isinstance(call.excinfo.value, (Skipped, bdb.BdbQuit)):
+        # Special control flow exception.
+        return False
+    return True
+
+
+def call_runtest_hook(
+    item: Item, when: "Literal['setup', 'call', 'teardown']", **kwds
+) -> "CallInfo[None]":
+    if when == "setup":
+        ihook: Callable[..., None] = item.ihook.pytest_runtest_setup
+    elif when == "call":
+        ihook = item.ihook.pytest_runtest_call
+    elif when == "teardown":
+        ihook = item.ihook.pytest_runtest_teardown
+    else:
+        assert False, f"Unhandled runtest hook case: {when}"
+    reraise: Tuple[Type[BaseException], ...] = (Exit,)
+    if not item.config.getoption("usepdb", False):
+        reraise += (KeyboardInterrupt,)
+    return CallInfo.from_call(
+        lambda: ihook(item=item, **kwds), when=when, reraise=reraise
+    )
+
+
+TResult = TypeVar("TResult", covariant=True)
+
+
+@final
+@attr.s(repr=False)
+class CallInfo(Generic[TResult]):
+    """Result/Exception info a function invocation.
+
+    :param T result:
+        The return value of the call, if it didn't raise. Can only be
+        accessed if excinfo is None.
+    :param Optional[ExceptionInfo] excinfo:
+        The captured exception of the call, if it raised.
+    :param float start:
+        The system time when the call started, in seconds since the epoch.
+    :param float stop:
+        The system time when the call ended, in seconds since the epoch.
+    :param float duration:
+        The call duration, in seconds.
+    :param str when:
+        The context of invocation: "setup", "call", "teardown", ...
+    """
+
+    _result = attr.ib(type="Optional[TResult]")
+    excinfo = attr.ib(type=Optional[ExceptionInfo[BaseException]])
+    start = attr.ib(type=float)
+    stop = attr.ib(type=float)
+    duration = attr.ib(type=float)
+    when = attr.ib(type="Literal['collect', 'setup', 'call', 'teardown']")
+
+    @property
+    def result(self) -> TResult:
+        if self.excinfo is not None:
+            raise AttributeError(f"{self!r} has no valid result")
+        # The cast is safe because an exception wasn't raised, hence
+        # _result has the expected function return type (which may be
+        #  None, that's why a cast and not an assert).
+        return cast(TResult, self._result)
+
+    @classmethod
+    def from_call(
+        cls,
+        func: "Callable[[], TResult]",
+        when: "Literal['collect', 'setup', 'call', 'teardown']",
+        reraise: Optional[
+            Union[Type[BaseException], Tuple[Type[BaseException], ...]]
+        ] = None,
+    ) -> "CallInfo[TResult]":
+        excinfo = None
+        start = timing.time()
+        precise_start = timing.perf_counter()
+        try:
+            result: Optional[TResult] = func()
+        except BaseException:
+            excinfo = ExceptionInfo.from_current()
+            if reraise is not None and isinstance(excinfo.value, reraise):
+                raise
+            result = None
+        # use the perf counter
+        precise_stop = timing.perf_counter()
+        duration = precise_stop - precise_start
+        stop = timing.time()
+        return cls(
+            start=start,
+            stop=stop,
+            duration=duration,
+            when=when,
+            result=result,
+            excinfo=excinfo,
+        )
+
+    def __repr__(self) -> str:
+        if self.excinfo is None:
+            return f"<CallInfo when={self.when!r} result: {self._result!r}>"
+        return f"<CallInfo when={self.when!r} excinfo={self.excinfo!r}>"
+
+
+def pytest_runtest_makereport(item: Item, call: CallInfo[None]) -> TestReport:
+    return TestReport.from_item_and_call(item, call)
+
+
+def pytest_make_collect_report(collector: Collector) -> CollectReport:
+    call = CallInfo.from_call(lambda: list(collector.collect()), "collect")
+    longrepr: Union[None, Tuple[str, int, str], str, TerminalRepr] = None
+    if not call.excinfo:
+        outcome: Literal["passed", "skipped", "failed"] = "passed"
+    else:
+        skip_exceptions = [Skipped]
+        unittest = sys.modules.get("unittest")
+        if unittest is not None:
+            # Type ignored because unittest is loaded dynamically.
+            skip_exceptions.append(unittest.SkipTest)  # type: ignore
+        if isinstance(call.excinfo.value, tuple(skip_exceptions)):
+            outcome = "skipped"
+            r_ = collector._repr_failure_py(call.excinfo, "line")
+            assert isinstance(r_, ExceptionChainRepr), repr(r_)
+            r = r_.reprcrash
+            assert r
+            longrepr = (str(r.path), r.lineno, r.message)
+        else:
+            outcome = "failed"
+            errorinfo = collector.repr_failure(call.excinfo)
+            if not hasattr(errorinfo, "toterminal"):
+                assert isinstance(errorinfo, str)
+                errorinfo = CollectErrorRepr(errorinfo)
+            longrepr = errorinfo
+    result = call.result if not call.excinfo else None
+    rep = CollectReport(collector.nodeid, outcome, longrepr, result)
+    rep.call = call  # type: ignore # see collect_one_node
+    return rep
+
+
+class SetupState:
+    """Shared state for setting up/tearing down test items or collectors."""
+
+    def __init__(self):
+        self.stack: List[Node] = []
+        self._finalizers: Dict[Node, List[Callable[[], object]]] = {}
+
+    def addfinalizer(self, finalizer: Callable[[], object], colitem) -> None:
+        """Attach a finalizer to the given colitem."""
+        assert colitem and not isinstance(colitem, tuple)
+        assert callable(finalizer)
+        # assert colitem in self.stack  # some unit tests don't setup stack :/
+        self._finalizers.setdefault(colitem, []).append(finalizer)
+
+    def _pop_and_teardown(self):
+        colitem = self.stack.pop()
+        self._teardown_with_finalization(colitem)
+
+    def _callfinalizers(self, colitem) -> None:
+        finalizers = self._finalizers.pop(colitem, None)
+        exc = None
+        while finalizers:
+            fin = finalizers.pop()
+            try:
+                fin()
+            except TEST_OUTCOME as e:
+                # XXX Only first exception will be seen by user,
+                #     ideally all should be reported.
+                if exc is None:
+                    exc = e
+        if exc:
+            raise exc
+
+    def _teardown_with_finalization(self, colitem) -> None:
+        self._callfinalizers(colitem)
+        colitem.teardown()
+        for colitem in self._finalizers:
+            assert colitem in self.stack
+
+    def teardown_all(self) -> None:
+        while self.stack:
+            self._pop_and_teardown()
+        for key in list(self._finalizers):
+            self._teardown_with_finalization(key)
+        assert not self._finalizers
+
+    def teardown_exact(self, item, nextitem) -> None:
+        needed_collectors = nextitem and nextitem.listchain() or []
+        self._teardown_towards(needed_collectors)
+
+    def _teardown_towards(self, needed_collectors) -> None:
+        exc = None
+        while self.stack:
+            if self.stack == needed_collectors[: len(self.stack)]:
+                break
+            try:
+                self._pop_and_teardown()
+            except TEST_OUTCOME as e:
+                # XXX Only first exception will be seen by user,
+                #     ideally all should be reported.
+                if exc is None:
+                    exc = e
+        if exc:
+            raise exc
+
+    def prepare(self, colitem) -> None:
+        """Setup objects along the collector chain to the test-method."""
+
+        # Check if the last collection node has raised an error.
+        for col in self.stack:
+            if hasattr(col, "_prepare_exc"):
+                exc = col._prepare_exc  # type: ignore[attr-defined]
+                raise exc
+
+        needed_collectors = colitem.listchain()
+        for col in needed_collectors[len(self.stack) :]:
+            self.stack.append(col)
+            try:
+                col.setup()
+            except TEST_OUTCOME as e:
+                col._prepare_exc = e  # type: ignore[attr-defined]
+                raise e
+
+
+def collect_one_node(collector: Collector) -> CollectReport:
+    ihook = collector.ihook
+    ihook.pytest_collectstart(collector=collector)
+    rep: CollectReport = ihook.pytest_make_collect_report(collector=collector)
+    call = rep.__dict__.pop("call", None)
+    if call and check_interactive_exception(call, rep):
+        ihook.pytest_exception_interact(node=collector, call=call, report=rep)
+    return rep
diff --git a/myenv/lib/python3.9/site-packages/_pytest/setuponly.py b/myenv/lib/python3.9/site-packages/_pytest/setuponly.py
new file mode 100644
index 0000000..44a1094
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/setuponly.py
@@ -0,0 +1,94 @@
+from typing import Generator
+from typing import Optional
+from typing import Union
+
+import pytest
+from _pytest._io.saferepr import saferepr
+from _pytest.config import Config
+from _pytest.config import ExitCode
+from _pytest.config.argparsing import Parser
+from _pytest.fixtures import FixtureDef
+from _pytest.fixtures import SubRequest
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("debugconfig")
+    group.addoption(
+        "--setuponly",
+        "--setup-only",
+        action="store_true",
+        help="only setup fixtures, do not execute tests.",
+    )
+    group.addoption(
+        "--setupshow",
+        "--setup-show",
+        action="store_true",
+        help="show setup of fixtures while executing tests.",
+    )
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_fixture_setup(
+    fixturedef: FixtureDef[object], request: SubRequest
+) -> Generator[None, None, None]:
+    yield
+    if request.config.option.setupshow:
+        if hasattr(request, "param"):
+            # Save the fixture parameter so ._show_fixture_action() can
+            # display it now and during the teardown (in .finish()).
+            if fixturedef.ids:
+                if callable(fixturedef.ids):
+                    param = fixturedef.ids(request.param)
+                else:
+                    param = fixturedef.ids[request.param_index]
+            else:
+                param = request.param
+            fixturedef.cached_param = param  # type: ignore[attr-defined]
+        _show_fixture_action(fixturedef, "SETUP")
+
+
+def pytest_fixture_post_finalizer(fixturedef: FixtureDef[object]) -> None:
+    if fixturedef.cached_result is not None:
+        config = fixturedef._fixturemanager.config
+        if config.option.setupshow:
+            _show_fixture_action(fixturedef, "TEARDOWN")
+            if hasattr(fixturedef, "cached_param"):
+                del fixturedef.cached_param  # type: ignore[attr-defined]
+
+
+def _show_fixture_action(fixturedef: FixtureDef[object], msg: str) -> None:
+    config = fixturedef._fixturemanager.config
+    capman = config.pluginmanager.getplugin("capturemanager")
+    if capman:
+        capman.suspend_global_capture()
+
+    tw = config.get_terminal_writer()
+    tw.line()
+    tw.write(" " * 2 * fixturedef.scopenum)
+    tw.write(
+        "{step} {scope} {fixture}".format(
+            step=msg.ljust(8),  # align the output to TEARDOWN
+            scope=fixturedef.scope[0].upper(),
+            fixture=fixturedef.argname,
+        )
+    )
+
+    if msg == "SETUP":
+        deps = sorted(arg for arg in fixturedef.argnames if arg != "request")
+        if deps:
+            tw.write(" (fixtures used: {})".format(", ".join(deps)))
+
+    if hasattr(fixturedef, "cached_param"):
+        tw.write("[{}]".format(saferepr(fixturedef.cached_param, maxsize=42)))  # type: ignore[attr-defined]
+
+    tw.flush()
+
+    if capman:
+        capman.resume_global_capture()
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_cmdline_main(config: Config) -> Optional[Union[int, ExitCode]]:
+    if config.option.setuponly:
+        config.option.setupshow = True
+    return None
diff --git a/myenv/lib/python3.9/site-packages/_pytest/setupplan.py b/myenv/lib/python3.9/site-packages/_pytest/setupplan.py
new file mode 100644
index 0000000..9ba81cc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/setupplan.py
@@ -0,0 +1,40 @@
+from typing import Optional
+from typing import Union
+
+import pytest
+from _pytest.config import Config
+from _pytest.config import ExitCode
+from _pytest.config.argparsing import Parser
+from _pytest.fixtures import FixtureDef
+from _pytest.fixtures import SubRequest
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("debugconfig")
+    group.addoption(
+        "--setupplan",
+        "--setup-plan",
+        action="store_true",
+        help="show what fixtures and tests would be executed but "
+        "don't execute anything.",
+    )
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_fixture_setup(
+    fixturedef: FixtureDef[object], request: SubRequest
+) -> Optional[object]:
+    # Will return a dummy fixture if the setuponly option is provided.
+    if request.config.option.setupplan:
+        my_cache_key = fixturedef.cache_key(request)
+        fixturedef.cached_result = (None, my_cache_key, None)
+        return fixturedef.cached_result
+    return None
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_cmdline_main(config: Config) -> Optional[Union[int, ExitCode]]:
+    if config.option.setupplan:
+        config.option.setuponly = True
+        config.option.setupshow = True
+    return None
diff --git a/myenv/lib/python3.9/site-packages/_pytest/skipping.py b/myenv/lib/python3.9/site-packages/_pytest/skipping.py
new file mode 100644
index 0000000..9aacfec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/skipping.py
@@ -0,0 +1,324 @@
+"""Support for skip/xfail functions and markers."""
+import os
+import platform
+import sys
+import traceback
+from collections.abc import Mapping
+from typing import Generator
+from typing import Optional
+from typing import Tuple
+from typing import Type
+
+import attr
+
+from _pytest.config import Config
+from _pytest.config import hookimpl
+from _pytest.config.argparsing import Parser
+from _pytest.mark.structures import Mark
+from _pytest.nodes import Item
+from _pytest.outcomes import fail
+from _pytest.outcomes import skip
+from _pytest.outcomes import xfail
+from _pytest.reports import BaseReport
+from _pytest.runner import CallInfo
+from _pytest.store import StoreKey
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("general")
+    group.addoption(
+        "--runxfail",
+        action="store_true",
+        dest="runxfail",
+        default=False,
+        help="report the results of xfail tests as if they were not marked",
+    )
+
+    parser.addini(
+        "xfail_strict",
+        "default for the strict parameter of xfail "
+        "markers when not given explicitly (default: False)",
+        default=False,
+        type="bool",
+    )
+
+
+def pytest_configure(config: Config) -> None:
+    if config.option.runxfail:
+        # yay a hack
+        import pytest
+
+        old = pytest.xfail
+        config._cleanup.append(lambda: setattr(pytest, "xfail", old))
+
+        def nop(*args, **kwargs):
+            pass
+
+        nop.Exception = xfail.Exception  # type: ignore[attr-defined]
+        setattr(pytest, "xfail", nop)
+
+    config.addinivalue_line(
+        "markers",
+        "skip(reason=None): skip the given test function with an optional reason. "
+        'Example: skip(reason="no way of currently testing this") skips the '
+        "test.",
+    )
+    config.addinivalue_line(
+        "markers",
+        "skipif(condition, ..., *, reason=...): "
+        "skip the given test function if any of the conditions evaluate to True. "
+        "Example: skipif(sys.platform == 'win32') skips the test if we are on the win32 platform. "
+        "See https://docs.pytest.org/en/stable/reference.html#pytest-mark-skipif",
+    )
+    config.addinivalue_line(
+        "markers",
+        "xfail(condition, ..., *, reason=..., run=True, raises=None, strict=xfail_strict): "
+        "mark the test function as an expected failure if any of the conditions "
+        "evaluate to True. Optionally specify a reason for better reporting "
+        "and run=False if you don't even want to execute the test function. "
+        "If only specific exception(s) are expected, you can list them in "
+        "raises, and if the test fails in other ways, it will be reported as "
+        "a true failure. See https://docs.pytest.org/en/stable/reference.html#pytest-mark-xfail",
+    )
+
+
+def evaluate_condition(item: Item, mark: Mark, condition: object) -> Tuple[bool, str]:
+    """Evaluate a single skipif/xfail condition.
+
+    If an old-style string condition is given, it is eval()'d, otherwise the
+    condition is bool()'d. If this fails, an appropriately formatted pytest.fail
+    is raised.
+
+    Returns (result, reason). The reason is only relevant if the result is True.
+    """
+    # String condition.
+    if isinstance(condition, str):
+        globals_ = {
+            "os": os,
+            "sys": sys,
+            "platform": platform,
+            "config": item.config,
+        }
+        for dictionary in reversed(
+            item.ihook.pytest_markeval_namespace(config=item.config)
+        ):
+            if not isinstance(dictionary, Mapping):
+                raise ValueError(
+                    "pytest_markeval_namespace() needs to return a dict, got {!r}".format(
+                        dictionary
+                    )
+                )
+            globals_.update(dictionary)
+        if hasattr(item, "obj"):
+            globals_.update(item.obj.__globals__)  # type: ignore[attr-defined]
+        try:
+            filename = f"<{mark.name} condition>"
+            condition_code = compile(condition, filename, "eval")
+            result = eval(condition_code, globals_)
+        except SyntaxError as exc:
+            msglines = [
+                "Error evaluating %r condition" % mark.name,
+                "    " + condition,
+                "    " + " " * (exc.offset or 0) + "^",
+                "SyntaxError: invalid syntax",
+            ]
+            fail("\n".join(msglines), pytrace=False)
+        except Exception as exc:
+            msglines = [
+                "Error evaluating %r condition" % mark.name,
+                "    " + condition,
+                *traceback.format_exception_only(type(exc), exc),
+            ]
+            fail("\n".join(msglines), pytrace=False)
+
+    # Boolean condition.
+    else:
+        try:
+            result = bool(condition)
+        except Exception as exc:
+            msglines = [
+                "Error evaluating %r condition as a boolean" % mark.name,
+                *traceback.format_exception_only(type(exc), exc),
+            ]
+            fail("\n".join(msglines), pytrace=False)
+
+    reason = mark.kwargs.get("reason", None)
+    if reason is None:
+        if isinstance(condition, str):
+            reason = "condition: " + condition
+        else:
+            # XXX better be checked at collection time
+            msg = (
+                "Error evaluating %r: " % mark.name
+                + "you need to specify reason=STRING when using booleans as conditions."
+            )
+            fail(msg, pytrace=False)
+
+    return result, reason
+
+
+@attr.s(slots=True, frozen=True)
+class Skip:
+    """The result of evaluate_skip_marks()."""
+
+    reason = attr.ib(type=str)
+
+
+def evaluate_skip_marks(item: Item) -> Optional[Skip]:
+    """Evaluate skip and skipif marks on item, returning Skip if triggered."""
+    for mark in item.iter_markers(name="skipif"):
+        if "condition" not in mark.kwargs:
+            conditions = mark.args
+        else:
+            conditions = (mark.kwargs["condition"],)
+
+        # Unconditional.
+        if not conditions:
+            reason = mark.kwargs.get("reason", "")
+            return Skip(reason)
+
+        # If any of the conditions are true.
+        for condition in conditions:
+            result, reason = evaluate_condition(item, mark, condition)
+            if result:
+                return Skip(reason)
+
+    for mark in item.iter_markers(name="skip"):
+        if "reason" in mark.kwargs:
+            reason = mark.kwargs["reason"]
+        elif mark.args:
+            reason = mark.args[0]
+        else:
+            reason = "unconditional skip"
+        return Skip(reason)
+
+    return None
+
+
+@attr.s(slots=True, frozen=True)
+class Xfail:
+    """The result of evaluate_xfail_marks()."""
+
+    reason = attr.ib(type=str)
+    run = attr.ib(type=bool)
+    strict = attr.ib(type=bool)
+    raises = attr.ib(type=Optional[Tuple[Type[BaseException], ...]])
+
+
+def evaluate_xfail_marks(item: Item) -> Optional[Xfail]:
+    """Evaluate xfail marks on item, returning Xfail if triggered."""
+    for mark in item.iter_markers(name="xfail"):
+        run = mark.kwargs.get("run", True)
+        strict = mark.kwargs.get("strict", item.config.getini("xfail_strict"))
+        raises = mark.kwargs.get("raises", None)
+        if "condition" not in mark.kwargs:
+            conditions = mark.args
+        else:
+            conditions = (mark.kwargs["condition"],)
+
+        # Unconditional.
+        if not conditions:
+            reason = mark.kwargs.get("reason", "")
+            return Xfail(reason, run, strict, raises)
+
+        # If any of the conditions are true.
+        for condition in conditions:
+            result, reason = evaluate_condition(item, mark, condition)
+            if result:
+                return Xfail(reason, run, strict, raises)
+
+    return None
+
+
+# Whether skipped due to skip or skipif marks.
+skipped_by_mark_key = StoreKey[bool]()
+# Saves the xfail mark evaluation. Can be refreshed during call if None.
+xfailed_key = StoreKey[Optional[Xfail]]()
+unexpectedsuccess_key = StoreKey[str]()
+
+
+@hookimpl(tryfirst=True)
+def pytest_runtest_setup(item: Item) -> None:
+    skipped = evaluate_skip_marks(item)
+    item._store[skipped_by_mark_key] = skipped is not None
+    if skipped:
+        skip(skipped.reason)
+
+    item._store[xfailed_key] = xfailed = evaluate_xfail_marks(item)
+    if xfailed and not item.config.option.runxfail and not xfailed.run:
+        xfail("[NOTRUN] " + xfailed.reason)
+
+
+@hookimpl(hookwrapper=True)
+def pytest_runtest_call(item: Item) -> Generator[None, None, None]:
+    xfailed = item._store.get(xfailed_key, None)
+    if xfailed is None:
+        item._store[xfailed_key] = xfailed = evaluate_xfail_marks(item)
+
+    if xfailed and not item.config.option.runxfail and not xfailed.run:
+        xfail("[NOTRUN] " + xfailed.reason)
+
+    yield
+
+    # The test run may have added an xfail mark dynamically.
+    xfailed = item._store.get(xfailed_key, None)
+    if xfailed is None:
+        item._store[xfailed_key] = xfailed = evaluate_xfail_marks(item)
+
+
+@hookimpl(hookwrapper=True)
+def pytest_runtest_makereport(item: Item, call: CallInfo[None]):
+    outcome = yield
+    rep = outcome.get_result()
+    xfailed = item._store.get(xfailed_key, None)
+    # unittest special case, see setting of unexpectedsuccess_key
+    if unexpectedsuccess_key in item._store and rep.when == "call":
+        reason = item._store[unexpectedsuccess_key]
+        if reason:
+            rep.longrepr = f"Unexpected success: {reason}"
+        else:
+            rep.longrepr = "Unexpected success"
+        rep.outcome = "failed"
+    elif item.config.option.runxfail:
+        pass  # don't interfere
+    elif call.excinfo and isinstance(call.excinfo.value, xfail.Exception):
+        assert call.excinfo.value.msg is not None
+        rep.wasxfail = "reason: " + call.excinfo.value.msg
+        rep.outcome = "skipped"
+    elif not rep.skipped and xfailed:
+        if call.excinfo:
+            raises = xfailed.raises
+            if raises is not None and not isinstance(call.excinfo.value, raises):
+                rep.outcome = "failed"
+            else:
+                rep.outcome = "skipped"
+                rep.wasxfail = xfailed.reason
+        elif call.when == "call":
+            if xfailed.strict:
+                rep.outcome = "failed"
+                rep.longrepr = "[XPASS(strict)] " + xfailed.reason
+            else:
+                rep.outcome = "passed"
+                rep.wasxfail = xfailed.reason
+
+    if (
+        item._store.get(skipped_by_mark_key, True)
+        and rep.skipped
+        and type(rep.longrepr) is tuple
+    ):
+        # Skipped by mark.skipif; change the location of the failure
+        # to point to the item definition, otherwise it will display
+        # the location of where the skip exception was raised within pytest.
+        _, _, reason = rep.longrepr
+        filename, line = item.reportinfo()[:2]
+        assert line is not None
+        rep.longrepr = str(filename), line + 1, reason
+
+
+def pytest_report_teststatus(report: BaseReport) -> Optional[Tuple[str, str, str]]:
+    if hasattr(report, "wasxfail"):
+        if report.skipped:
+            return "xfailed", "x", "XFAIL"
+        elif report.passed:
+            return "xpassed", "X", "XPASS"
+    return None
diff --git a/myenv/lib/python3.9/site-packages/_pytest/stepwise.py b/myenv/lib/python3.9/site-packages/_pytest/stepwise.py
new file mode 100644
index 0000000..197577c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/stepwise.py
@@ -0,0 +1,119 @@
+from typing import List
+from typing import Optional
+from typing import TYPE_CHECKING
+
+import pytest
+from _pytest import nodes
+from _pytest.config import Config
+from _pytest.config.argparsing import Parser
+from _pytest.main import Session
+from _pytest.reports import TestReport
+
+if TYPE_CHECKING:
+    from _pytest.cacheprovider import Cache
+
+STEPWISE_CACHE_DIR = "cache/stepwise"
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("general")
+    group.addoption(
+        "--sw",
+        "--stepwise",
+        action="store_true",
+        default=False,
+        dest="stepwise",
+        help="exit on test failure and continue from last failing test next time",
+    )
+    group.addoption(
+        "--sw-skip",
+        "--stepwise-skip",
+        action="store_true",
+        default=False,
+        dest="stepwise_skip",
+        help="ignore the first failing test but stop on the next failing test",
+    )
+
+
+@pytest.hookimpl
+def pytest_configure(config: Config) -> None:
+    # We should always have a cache as cache provider plugin uses tryfirst=True
+    if config.getoption("stepwise"):
+        config.pluginmanager.register(StepwisePlugin(config), "stepwiseplugin")
+
+
+def pytest_sessionfinish(session: Session) -> None:
+    if not session.config.getoption("stepwise"):
+        assert session.config.cache is not None
+        # Clear the list of failing tests if the plugin is not active.
+        session.config.cache.set(STEPWISE_CACHE_DIR, [])
+
+
+class StepwisePlugin:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        self.session: Optional[Session] = None
+        self.report_status = ""
+        assert config.cache is not None
+        self.cache: Cache = config.cache
+        self.lastfailed: Optional[str] = self.cache.get(STEPWISE_CACHE_DIR, None)
+        self.skip: bool = config.getoption("stepwise_skip")
+
+    def pytest_sessionstart(self, session: Session) -> None:
+        self.session = session
+
+    def pytest_collection_modifyitems(
+        self, config: Config, items: List[nodes.Item]
+    ) -> None:
+        if not self.lastfailed:
+            self.report_status = "no previously failed tests, not skipping."
+            return
+
+        # check all item nodes until we find a match on last failed
+        failed_index = None
+        for index, item in enumerate(items):
+            if item.nodeid == self.lastfailed:
+                failed_index = index
+                break
+
+        # If the previously failed test was not found among the test items,
+        # do not skip any tests.
+        if failed_index is None:
+            self.report_status = "previously failed test not found, not skipping."
+        else:
+            self.report_status = f"skipping {failed_index} already passed items."
+            deselected = items[:failed_index]
+            del items[:failed_index]
+            config.hook.pytest_deselected(items=deselected)
+
+    def pytest_runtest_logreport(self, report: TestReport) -> None:
+        if report.failed:
+            if self.skip:
+                # Remove test from the failed ones (if it exists) and unset the skip option
+                # to make sure the following tests will not be skipped.
+                if report.nodeid == self.lastfailed:
+                    self.lastfailed = None
+
+                self.skip = False
+            else:
+                # Mark test as the last failing and interrupt the test session.
+                self.lastfailed = report.nodeid
+                assert self.session is not None
+                self.session.shouldstop = (
+                    "Test failed, continuing from this test next run."
+                )
+
+        else:
+            # If the test was actually run and did pass.
+            if report.when == "call":
+                # Remove test from the failed ones, if exists.
+                if report.nodeid == self.lastfailed:
+                    self.lastfailed = None
+
+    def pytest_report_collectionfinish(self) -> Optional[str]:
+        if self.config.getoption("verbose") >= 0 and self.report_status:
+            return f"stepwise: {self.report_status}"
+        return None
+
+    def pytest_sessionfinish(self) -> None:
+        self.cache.set(STEPWISE_CACHE_DIR, self.lastfailed)
diff --git a/myenv/lib/python3.9/site-packages/_pytest/store.py b/myenv/lib/python3.9/site-packages/_pytest/store.py
new file mode 100644
index 0000000..e5008cf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/store.py
@@ -0,0 +1,125 @@
+from typing import Any
+from typing import cast
+from typing import Dict
+from typing import Generic
+from typing import TypeVar
+from typing import Union
+
+
+__all__ = ["Store", "StoreKey"]
+
+
+T = TypeVar("T")
+D = TypeVar("D")
+
+
+class StoreKey(Generic[T]):
+    """StoreKey is an object used as a key to a Store.
+
+    A StoreKey is associated with the type T of the value of the key.
+
+    A StoreKey is unique and cannot conflict with another key.
+    """
+
+    __slots__ = ()
+
+
+class Store:
+    """Store is a type-safe heterogenous mutable mapping that
+    allows keys and value types to be defined separately from
+    where it (the Store) is created.
+
+    Usually you will be given an object which has a ``Store``:
+
+    .. code-block:: python
+
+        store: Store = some_object.store
+
+    If a module wants to store data in this Store, it creates StoreKeys
+    for its keys (at the module level):
+
+    .. code-block:: python
+
+        some_str_key = StoreKey[str]()
+        some_bool_key = StoreKey[bool]()
+
+    To store information:
+
+    .. code-block:: python
+
+        # Value type must match the key.
+        store[some_str_key] = "value"
+        store[some_bool_key] = True
+
+    To retrieve the information:
+
+    .. code-block:: python
+
+        # The static type of some_str is str.
+        some_str = store[some_str_key]
+        # The static type of some_bool is bool.
+        some_bool = store[some_bool_key]
+
+    Why use this?
+    -------------
+
+    Problem: module Internal defines an object. Module External, which
+    module Internal doesn't know about, receives the object and wants to
+    attach information to it, to be retrieved later given the object.
+
+    Bad solution 1: Module External assigns private attributes directly on
+    the object. This doesn't work well because the type checker doesn't
+    know about these attributes and it complains about undefined attributes.
+
+    Bad solution 2: module Internal adds a ``Dict[str, Any]`` attribute to
+    the object. Module External stores its data in private keys of this dict.
+    This doesn't work well because retrieved values are untyped.
+
+    Good solution: module Internal adds a ``Store`` to the object. Module
+    External mints StoreKeys for its own keys. Module External stores and
+    retrieves its data using these keys.
+    """
+
+    __slots__ = ("_store",)
+
+    def __init__(self) -> None:
+        self._store: Dict[StoreKey[Any], object] = {}
+
+    def __setitem__(self, key: StoreKey[T], value: T) -> None:
+        """Set a value for key."""
+        self._store[key] = value
+
+    def __getitem__(self, key: StoreKey[T]) -> T:
+        """Get the value for key.
+
+        Raises ``KeyError`` if the key wasn't set before.
+        """
+        return cast(T, self._store[key])
+
+    def get(self, key: StoreKey[T], default: D) -> Union[T, D]:
+        """Get the value for key, or return default if the key wasn't set
+        before."""
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def setdefault(self, key: StoreKey[T], default: T) -> T:
+        """Return the value of key if already set, otherwise set the value
+        of key to default and return default."""
+        try:
+            return self[key]
+        except KeyError:
+            self[key] = default
+            return default
+
+    def __delitem__(self, key: StoreKey[T]) -> None:
+        """Delete the value for key.
+
+        Raises ``KeyError`` if the key wasn't set before.
+        """
+        del self._store[key]
+
+    def __contains__(self, key: StoreKey[T]) -> bool:
+        """Return whether key was set."""
+        return key in self._store
diff --git a/myenv/lib/python3.9/site-packages/_pytest/terminal.py b/myenv/lib/python3.9/site-packages/_pytest/terminal.py
new file mode 100644
index 0000000..fbfb09a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/terminal.py
@@ -0,0 +1,1405 @@
+"""Terminal reporting of the full testing process.
+
+This is a good source for looking at the various reporting hooks.
+"""
+import argparse
+import datetime
+import inspect
+import platform
+import sys
+import warnings
+from collections import Counter
+from functools import partial
+from pathlib import Path
+from typing import Any
+from typing import Callable
+from typing import cast
+from typing import Dict
+from typing import Generator
+from typing import List
+from typing import Mapping
+from typing import Optional
+from typing import Sequence
+from typing import Set
+from typing import TextIO
+from typing import Tuple
+from typing import TYPE_CHECKING
+from typing import Union
+
+import attr
+import pluggy
+import py
+
+import _pytest._version
+from _pytest import nodes
+from _pytest import timing
+from _pytest._code import ExceptionInfo
+from _pytest._code.code import ExceptionRepr
+from _pytest._io.wcwidth import wcswidth
+from _pytest.compat import final
+from _pytest.config import _PluggyPlugin
+from _pytest.config import Config
+from _pytest.config import ExitCode
+from _pytest.config import hookimpl
+from _pytest.config.argparsing import Parser
+from _pytest.nodes import Item
+from _pytest.nodes import Node
+from _pytest.pathlib import absolutepath
+from _pytest.pathlib import bestrelpath
+from _pytest.reports import BaseReport
+from _pytest.reports import CollectReport
+from _pytest.reports import TestReport
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
+    from _pytest.main import Session
+
+
+REPORT_COLLECTING_RESOLUTION = 0.5
+
+KNOWN_TYPES = (
+    "failed",
+    "passed",
+    "skipped",
+    "deselected",
+    "xfailed",
+    "xpassed",
+    "warnings",
+    "error",
+)
+
+_REPORTCHARS_DEFAULT = "fE"
+
+
+class MoreQuietAction(argparse.Action):
+    """A modified copy of the argparse count action which counts down and updates
+    the legacy quiet attribute at the same time.
+
+    Used to unify verbosity handling.
+    """
+
+    def __init__(
+        self,
+        option_strings: Sequence[str],
+        dest: str,
+        default: object = None,
+        required: bool = False,
+        help: Optional[str] = None,
+    ) -> None:
+        super().__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            default=default,
+            required=required,
+            help=help,
+        )
+
+    def __call__(
+        self,
+        parser: argparse.ArgumentParser,
+        namespace: argparse.Namespace,
+        values: Union[str, Sequence[object], None],
+        option_string: Optional[str] = None,
+    ) -> None:
+        new_count = getattr(namespace, self.dest, 0) - 1
+        setattr(namespace, self.dest, new_count)
+        # todo Deprecate config.quiet
+        namespace.quiet = getattr(namespace, "quiet", 0) + 1
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("terminal reporting", "reporting", after="general")
+    group._addoption(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        dest="verbose",
+        help="increase verbosity.",
+    )
+    group._addoption(
+        "--no-header",
+        action="store_true",
+        default=False,
+        dest="no_header",
+        help="disable header",
+    )
+    group._addoption(
+        "--no-summary",
+        action="store_true",
+        default=False,
+        dest="no_summary",
+        help="disable summary",
+    )
+    group._addoption(
+        "-q",
+        "--quiet",
+        action=MoreQuietAction,
+        default=0,
+        dest="verbose",
+        help="decrease verbosity.",
+    )
+    group._addoption(
+        "--verbosity",
+        dest="verbose",
+        type=int,
+        default=0,
+        help="set verbosity. Default is 0.",
+    )
+    group._addoption(
+        "-r",
+        action="store",
+        dest="reportchars",
+        default=_REPORTCHARS_DEFAULT,
+        metavar="chars",
+        help="show extra test summary info as specified by chars: (f)ailed, "
+        "(E)rror, (s)kipped, (x)failed, (X)passed, "
+        "(p)assed, (P)assed with output, (a)ll except passed (p/P), or (A)ll. "
+        "(w)arnings are enabled by default (see --disable-warnings), "
+        "'N' can be used to reset the list. (default: 'fE').",
+    )
+    group._addoption(
+        "--disable-warnings",
+        "--disable-pytest-warnings",
+        default=False,
+        dest="disable_warnings",
+        action="store_true",
+        help="disable warnings summary",
+    )
+    group._addoption(
+        "-l",
+        "--showlocals",
+        action="store_true",
+        dest="showlocals",
+        default=False,
+        help="show locals in tracebacks (disabled by default).",
+    )
+    group._addoption(
+        "--tb",
+        metavar="style",
+        action="store",
+        dest="tbstyle",
+        default="auto",
+        choices=["auto", "long", "short", "no", "line", "native"],
+        help="traceback print mode (auto/long/short/line/native/no).",
+    )
+    group._addoption(
+        "--show-capture",
+        action="store",
+        dest="showcapture",
+        choices=["no", "stdout", "stderr", "log", "all"],
+        default="all",
+        help="Controls how captured stdout/stderr/log is shown on failed tests. "
+        "Default is 'all'.",
+    )
+    group._addoption(
+        "--fulltrace",
+        "--full-trace",
+        action="store_true",
+        default=False,
+        help="don't cut any tracebacks (default is to cut).",
+    )
+    group._addoption(
+        "--color",
+        metavar="color",
+        action="store",
+        dest="color",
+        default="auto",
+        choices=["yes", "no", "auto"],
+        help="color terminal output (yes/no/auto).",
+    )
+    group._addoption(
+        "--code-highlight",
+        default="yes",
+        choices=["yes", "no"],
+        help="Whether code should be highlighted (only if --color is also enabled)",
+    )
+
+    parser.addini(
+        "console_output_style",
+        help='console output: "classic", or with additional progress information ("progress" (percentage) | "count").',
+        default="progress",
+    )
+
+
+def pytest_configure(config: Config) -> None:
+    reporter = TerminalReporter(config, sys.stdout)
+    config.pluginmanager.register(reporter, "terminalreporter")
+    if config.option.debug or config.option.traceconfig:
+
+        def mywriter(tags, args):
+            msg = " ".join(map(str, args))
+            reporter.write_line("[traceconfig] " + msg)
+
+        config.trace.root.setprocessor("pytest:config", mywriter)
+
+
+def getreportopt(config: Config) -> str:
+    reportchars: str = config.option.reportchars
+
+    old_aliases = {"F", "S"}
+    reportopts = ""
+    for char in reportchars:
+        if char in old_aliases:
+            char = char.lower()
+        if char == "a":
+            reportopts = "sxXEf"
+        elif char == "A":
+            reportopts = "PpsxXEf"
+        elif char == "N":
+            reportopts = ""
+        elif char not in reportopts:
+            reportopts += char
+
+    if not config.option.disable_warnings and "w" not in reportopts:
+        reportopts = "w" + reportopts
+    elif config.option.disable_warnings and "w" in reportopts:
+        reportopts = reportopts.replace("w", "")
+
+    return reportopts
+
+
+@hookimpl(trylast=True)  # after _pytest.runner
+def pytest_report_teststatus(report: BaseReport) -> Tuple[str, str, str]:
+    letter = "F"
+    if report.passed:
+        letter = "."
+    elif report.skipped:
+        letter = "s"
+
+    outcome: str = report.outcome
+    if report.when in ("collect", "setup", "teardown") and outcome == "failed":
+        outcome = "error"
+        letter = "E"
+
+    return outcome, letter, outcome.upper()
+
+
+@attr.s
+class WarningReport:
+    """Simple structure to hold warnings information captured by ``pytest_warning_recorded``.
+
+    :ivar str message:
+        User friendly message about the warning.
+    :ivar str|None nodeid:
+        nodeid that generated the warning (see ``get_location``).
+    :ivar tuple|py.path.local fslocation:
+        File system location of the source of the warning (see ``get_location``).
+    """
+
+    message = attr.ib(type=str)
+    nodeid = attr.ib(type=Optional[str], default=None)
+    fslocation = attr.ib(
+        type=Optional[Union[Tuple[str, int], py.path.local]], default=None
+    )
+    count_towards_summary = True
+
+    def get_location(self, config: Config) -> Optional[str]:
+        """Return the more user-friendly information about the location of a warning, or None."""
+        if self.nodeid:
+            return self.nodeid
+        if self.fslocation:
+            if isinstance(self.fslocation, tuple) and len(self.fslocation) >= 2:
+                filename, linenum = self.fslocation[:2]
+                relpath = bestrelpath(
+                    config.invocation_params.dir, absolutepath(filename)
+                )
+                return f"{relpath}:{linenum}"
+            else:
+                return str(self.fslocation)
+        return None
+
+
+@final
+class TerminalReporter:
+    def __init__(self, config: Config, file: Optional[TextIO] = None) -> None:
+        import _pytest.config
+
+        self.config = config
+        self._numcollected = 0
+        self._session: Optional[Session] = None
+        self._showfspath: Optional[bool] = None
+
+        self.stats: Dict[str, List[Any]] = {}
+        self._main_color: Optional[str] = None
+        self._known_types: Optional[List[str]] = None
+        self.startdir = config.invocation_dir
+        self.startpath = config.invocation_params.dir
+        if file is None:
+            file = sys.stdout
+        self._tw = _pytest.config.create_terminal_writer(config, file)
+        self._screen_width = self._tw.fullwidth
+        self.currentfspath: Union[None, Path, str, int] = None
+        self.reportchars = getreportopt(config)
+        self.hasmarkup = self._tw.hasmarkup
+        self.isatty = file.isatty()
+        self._progress_nodeids_reported: Set[str] = set()
+        self._show_progress_info = self._determine_show_progress_info()
+        self._collect_report_last_write: Optional[float] = None
+        self._already_displayed_warnings: Optional[int] = None
+        self._keyboardinterrupt_memo: Optional[ExceptionRepr] = None
+
+    def _determine_show_progress_info(self) -> "Literal['progress', 'count', False]":
+        """Return whether we should display progress information based on the current config."""
+        # do not show progress if we are not capturing output (#3038)
+        if self.config.getoption("capture", "no") == "no":
+            return False
+        # do not show progress if we are showing fixture setup/teardown
+        if self.config.getoption("setupshow", False):
+            return False
+        cfg: str = self.config.getini("console_output_style")
+        if cfg == "progress":
+            return "progress"
+        elif cfg == "count":
+            return "count"
+        else:
+            return False
+
+    @property
+    def verbosity(self) -> int:
+        verbosity: int = self.config.option.verbose
+        return verbosity
+
+    @property
+    def showheader(self) -> bool:
+        return self.verbosity >= 0
+
+    @property
+    def no_header(self) -> bool:
+        return bool(self.config.option.no_header)
+
+    @property
+    def no_summary(self) -> bool:
+        return bool(self.config.option.no_summary)
+
+    @property
+    def showfspath(self) -> bool:
+        if self._showfspath is None:
+            return self.verbosity >= 0
+        return self._showfspath
+
+    @showfspath.setter
+    def showfspath(self, value: Optional[bool]) -> None:
+        self._showfspath = value
+
+    @property
+    def showlongtestinfo(self) -> bool:
+        return self.verbosity > 0
+
+    def hasopt(self, char: str) -> bool:
+        char = {"xfailed": "x", "skipped": "s"}.get(char, char)
+        return char in self.reportchars
+
+    def write_fspath_result(self, nodeid: str, res, **markup: bool) -> None:
+        fspath = self.config.rootpath / nodeid.split("::")[0]
+        if self.currentfspath is None or fspath != self.currentfspath:
+            if self.currentfspath is not None and self._show_progress_info:
+                self._write_progress_information_filling_space()
+            self.currentfspath = fspath
+            relfspath = bestrelpath(self.startpath, fspath)
+            self._tw.line()
+            self._tw.write(relfspath + " ")
+        self._tw.write(res, flush=True, **markup)
+
+    def write_ensure_prefix(self, prefix: str, extra: str = "", **kwargs) -> None:
+        if self.currentfspath != prefix:
+            self._tw.line()
+            self.currentfspath = prefix
+            self._tw.write(prefix)
+        if extra:
+            self._tw.write(extra, **kwargs)
+            self.currentfspath = -2
+
+    def ensure_newline(self) -> None:
+        if self.currentfspath:
+            self._tw.line()
+            self.currentfspath = None
+
+    def write(self, content: str, *, flush: bool = False, **markup: bool) -> None:
+        self._tw.write(content, flush=flush, **markup)
+
+    def flush(self) -> None:
+        self._tw.flush()
+
+    def write_line(self, line: Union[str, bytes], **markup: bool) -> None:
+        if not isinstance(line, str):
+            line = str(line, errors="replace")
+        self.ensure_newline()
+        self._tw.line(line, **markup)
+
+    def rewrite(self, line: str, **markup: bool) -> None:
+        """Rewinds the terminal cursor to the beginning and writes the given line.
+
+        :param erase:
+            If True, will also add spaces until the full terminal width to ensure
+            previous lines are properly erased.
+
+        The rest of the keyword arguments are markup instructions.
+        """
+        erase = markup.pop("erase", False)
+        if erase:
+            fill_count = self._tw.fullwidth - len(line) - 1
+            fill = " " * fill_count
+        else:
+            fill = ""
+        line = str(line)
+        self._tw.write("\r" + line + fill, **markup)
+
+    def write_sep(
+        self,
+        sep: str,
+        title: Optional[str] = None,
+        fullwidth: Optional[int] = None,
+        **markup: bool,
+    ) -> None:
+        self.ensure_newline()
+        self._tw.sep(sep, title, fullwidth, **markup)
+
+    def section(self, title: str, sep: str = "=", **kw: bool) -> None:
+        self._tw.sep(sep, title, **kw)
+
+    def line(self, msg: str, **kw: bool) -> None:
+        self._tw.line(msg, **kw)
+
+    def _add_stats(self, category: str, items: Sequence[Any]) -> None:
+        set_main_color = category not in self.stats
+        self.stats.setdefault(category, []).extend(items)
+        if set_main_color:
+            self._set_main_color()
+
+    def pytest_internalerror(self, excrepr: ExceptionRepr) -> bool:
+        for line in str(excrepr).split("\n"):
+            self.write_line("INTERNALERROR> " + line)
+        return True
+
+    def pytest_warning_recorded(
+        self, warning_message: warnings.WarningMessage, nodeid: str,
+    ) -> None:
+        from _pytest.warnings import warning_record_to_str
+
+        fslocation = warning_message.filename, warning_message.lineno
+        message = warning_record_to_str(warning_message)
+
+        warning_report = WarningReport(
+            fslocation=fslocation, message=message, nodeid=nodeid
+        )
+        self._add_stats("warnings", [warning_report])
+
+    def pytest_plugin_registered(self, plugin: _PluggyPlugin) -> None:
+        if self.config.option.traceconfig:
+            msg = f"PLUGIN registered: {plugin}"
+            # XXX This event may happen during setup/teardown time
+            #     which unfortunately captures our output here
+            #     which garbles our output if we use self.write_line.
+            self.write_line(msg)
+
+    def pytest_deselected(self, items: Sequence[Item]) -> None:
+        self._add_stats("deselected", items)
+
+    def pytest_runtest_logstart(
+        self, nodeid: str, location: Tuple[str, Optional[int], str]
+    ) -> None:
+        # Ensure that the path is printed before the
+        # 1st test of a module starts running.
+        if self.showlongtestinfo:
+            line = self._locationline(nodeid, *location)
+            self.write_ensure_prefix(line, "")
+            self.flush()
+        elif self.showfspath:
+            self.write_fspath_result(nodeid, "")
+            self.flush()
+
+    def pytest_runtest_logreport(self, report: TestReport) -> None:
+        self._tests_ran = True
+        rep = report
+        res: Tuple[
+            str, str, Union[str, Tuple[str, Mapping[str, bool]]]
+        ] = self.config.hook.pytest_report_teststatus(report=rep, config=self.config)
+        category, letter, word = res
+        if not isinstance(word, tuple):
+            markup = None
+        else:
+            word, markup = word
+        self._add_stats(category, [rep])
+        if not letter and not word:
+            # Probably passed setup/teardown.
+            return
+        running_xdist = hasattr(rep, "node")
+        if markup is None:
+            was_xfail = hasattr(report, "wasxfail")
+            if rep.passed and not was_xfail:
+                markup = {"green": True}
+            elif rep.passed and was_xfail:
+                markup = {"yellow": True}
+            elif rep.failed:
+                markup = {"red": True}
+            elif rep.skipped:
+                markup = {"yellow": True}
+            else:
+                markup = {}
+        if self.verbosity <= 0:
+            self._tw.write(letter, **markup)
+        else:
+            self._progress_nodeids_reported.add(rep.nodeid)
+            line = self._locationline(rep.nodeid, *rep.location)
+            if not running_xdist:
+                self.write_ensure_prefix(line, word, **markup)
+                if rep.skipped or hasattr(report, "wasxfail"):
+                    available_width = (
+                        (self._tw.fullwidth - self._tw.width_of_current_line)
+                        - len(" [100%]")
+                        - 1
+                    )
+                    reason = _get_raw_skip_reason(rep)
+                    reason_ = _format_trimmed(" ({})", reason, available_width)
+                    if reason and reason_ is not None:
+                        self._tw.write(reason_)
+                if self._show_progress_info:
+                    self._write_progress_information_filling_space()
+            else:
+                self.ensure_newline()
+                self._tw.write("[%s]" % rep.node.gateway.id)
+                if self._show_progress_info:
+                    self._tw.write(
+                        self._get_progress_information_message() + " ", cyan=True
+                    )
+                else:
+                    self._tw.write(" ")
+                self._tw.write(word, **markup)
+                self._tw.write(" " + line)
+                self.currentfspath = -2
+        self.flush()
+
+    @property
+    def _is_last_item(self) -> bool:
+        assert self._session is not None
+        return len(self._progress_nodeids_reported) == self._session.testscollected
+
+    def pytest_runtest_logfinish(self, nodeid: str) -> None:
+        assert self._session
+        if self.verbosity <= 0 and self._show_progress_info:
+            if self._show_progress_info == "count":
+                num_tests = self._session.testscollected
+                progress_length = len(" [{}/{}]".format(str(num_tests), str(num_tests)))
+            else:
+                progress_length = len(" [100%]")
+
+            self._progress_nodeids_reported.add(nodeid)
+
+            if self._is_last_item:
+                self._write_progress_information_filling_space()
+            else:
+                main_color, _ = self._get_main_color()
+                w = self._width_of_current_line
+                past_edge = w + progress_length + 1 >= self._screen_width
+                if past_edge:
+                    msg = self._get_progress_information_message()
+                    self._tw.write(msg + "\n", **{main_color: True})
+
+    def _get_progress_information_message(self) -> str:
+        assert self._session
+        collected = self._session.testscollected
+        if self._show_progress_info == "count":
+            if collected:
+                progress = self._progress_nodeids_reported
+                counter_format = "{{:{}d}}".format(len(str(collected)))
+                format_string = f" [{counter_format}/{{}}]"
+                return format_string.format(len(progress), collected)
+            return f" [ {collected} / {collected} ]"
+        else:
+            if collected:
+                return " [{:3d}%]".format(
+                    len(self._progress_nodeids_reported) * 100 // collected
+                )
+            return " [100%]"
+
+    def _write_progress_information_filling_space(self) -> None:
+        color, _ = self._get_main_color()
+        msg = self._get_progress_information_message()
+        w = self._width_of_current_line
+        fill = self._tw.fullwidth - w - 1
+        self.write(msg.rjust(fill), flush=True, **{color: True})
+
+    @property
+    def _width_of_current_line(self) -> int:
+        """Return the width of the current line."""
+        return self._tw.width_of_current_line
+
+    def pytest_collection(self) -> None:
+        if self.isatty:
+            if self.config.option.verbose >= 0:
+                self.write("collecting ... ", flush=True, bold=True)
+                self._collect_report_last_write = timing.time()
+        elif self.config.option.verbose >= 1:
+            self.write("collecting ... ", flush=True, bold=True)
+
+    def pytest_collectreport(self, report: CollectReport) -> None:
+        if report.failed:
+            self._add_stats("error", [report])
+        elif report.skipped:
+            self._add_stats("skipped", [report])
+        items = [x for x in report.result if isinstance(x, Item)]
+        self._numcollected += len(items)
+        if self.isatty:
+            self.report_collect()
+
+    def report_collect(self, final: bool = False) -> None:
+        if self.config.option.verbose < 0:
+            return
+
+        if not final:
+            # Only write "collecting" report every 0.5s.
+            t = timing.time()
+            if (
+                self._collect_report_last_write is not None
+                and self._collect_report_last_write > t - REPORT_COLLECTING_RESOLUTION
+            ):
+                return
+            self._collect_report_last_write = t
+
+        errors = len(self.stats.get("error", []))
+        skipped = len(self.stats.get("skipped", []))
+        deselected = len(self.stats.get("deselected", []))
+        selected = self._numcollected - errors - skipped - deselected
+        if final:
+            line = "collected "
+        else:
+            line = "collecting "
+        line += (
+            str(self._numcollected) + " item" + ("" if self._numcollected == 1 else "s")
+        )
+        if errors:
+            line += " / %d error%s" % (errors, "s" if errors != 1 else "")
+        if deselected:
+            line += " / %d deselected" % deselected
+        if skipped:
+            line += " / %d skipped" % skipped
+        if self._numcollected > selected > 0:
+            line += " / %d selected" % selected
+        if self.isatty:
+            self.rewrite(line, bold=True, erase=True)
+            if final:
+                self.write("\n")
+        else:
+            self.write_line(line)
+
+    @hookimpl(trylast=True)
+    def pytest_sessionstart(self, session: "Session") -> None:
+        self._session = session
+        self._sessionstarttime = timing.time()
+        if not self.showheader:
+            return
+        self.write_sep("=", "test session starts", bold=True)
+        verinfo = platform.python_version()
+        if not self.no_header:
+            msg = f"platform {sys.platform} -- Python {verinfo}"
+            pypy_version_info = getattr(sys, "pypy_version_info", None)
+            if pypy_version_info:
+                verinfo = ".".join(map(str, pypy_version_info[:3]))
+                msg += "[pypy-{}-{}]".format(verinfo, pypy_version_info[3])
+            msg += ", pytest-{}, py-{}, pluggy-{}".format(
+                _pytest._version.version, py.__version__, pluggy.__version__
+            )
+            if (
+                self.verbosity > 0
+                or self.config.option.debug
+                or getattr(self.config.option, "pastebin", None)
+            ):
+                msg += " -- " + str(sys.executable)
+            self.write_line(msg)
+            lines = self.config.hook.pytest_report_header(
+                config=self.config, startdir=self.startdir
+            )
+            self._write_report_lines_from_hooks(lines)
+
+    def _write_report_lines_from_hooks(
+        self, lines: Sequence[Union[str, Sequence[str]]]
+    ) -> None:
+        for line_or_lines in reversed(lines):
+            if isinstance(line_or_lines, str):
+                self.write_line(line_or_lines)
+            else:
+                for line in line_or_lines:
+                    self.write_line(line)
+
+    def pytest_report_header(self, config: Config) -> List[str]:
+        line = "rootdir: %s" % config.rootpath
+
+        if config.inipath:
+            line += ", configfile: " + bestrelpath(config.rootpath, config.inipath)
+
+        testpaths: List[str] = config.getini("testpaths")
+        if config.invocation_params.dir == config.rootpath and config.args == testpaths:
+            line += ", testpaths: {}".format(", ".join(testpaths))
+
+        result = [line]
+
+        plugininfo = config.pluginmanager.list_plugin_distinfo()
+        if plugininfo:
+            result.append("plugins: %s" % ", ".join(_plugin_nameversions(plugininfo)))
+        return result
+
+    def pytest_collection_finish(self, session: "Session") -> None:
+        self.report_collect(True)
+
+        lines = self.config.hook.pytest_report_collectionfinish(
+            config=self.config, startdir=self.startdir, items=session.items
+        )
+        self._write_report_lines_from_hooks(lines)
+
+        if self.config.getoption("collectonly"):
+            if session.items:
+                if self.config.option.verbose > -1:
+                    self._tw.line("")
+                self._printcollecteditems(session.items)
+
+            failed = self.stats.get("failed")
+            if failed:
+                self._tw.sep("!", "collection failures")
+                for rep in failed:
+                    rep.toterminal(self._tw)
+
+    def _printcollecteditems(self, items: Sequence[Item]) -> None:
+        # To print out items and their parent collectors
+        # we take care to leave out Instances aka ()
+        # because later versions are going to get rid of them anyway.
+        if self.config.option.verbose < 0:
+            if self.config.option.verbose < -1:
+                counts = Counter(item.nodeid.split("::", 1)[0] for item in items)
+                for name, count in sorted(counts.items()):
+                    self._tw.line("%s: %d" % (name, count))
+            else:
+                for item in items:
+                    self._tw.line(item.nodeid)
+            return
+        stack: List[Node] = []
+        indent = ""
+        for item in items:
+            needed_collectors = item.listchain()[1:]  # strip root node
+            while stack:
+                if stack == needed_collectors[: len(stack)]:
+                    break
+                stack.pop()
+            for col in needed_collectors[len(stack) :]:
+                stack.append(col)
+                if col.name == "()":  # Skip Instances.
+                    continue
+                indent = (len(stack) - 1) * "  "
+                self._tw.line(f"{indent}{col}")
+                if self.config.option.verbose >= 1:
+                    obj = getattr(col, "obj", None)
+                    doc = inspect.getdoc(obj) if obj else None
+                    if doc:
+                        for line in doc.splitlines():
+                            self._tw.line("{}{}".format(indent + "  ", line))
+
+    @hookimpl(hookwrapper=True)
+    def pytest_sessionfinish(
+        self, session: "Session", exitstatus: Union[int, ExitCode]
+    ):
+        outcome = yield
+        outcome.get_result()
+        self._tw.line("")
+        summary_exit_codes = (
+            ExitCode.OK,
+            ExitCode.TESTS_FAILED,
+            ExitCode.INTERRUPTED,
+            ExitCode.USAGE_ERROR,
+            ExitCode.NO_TESTS_COLLECTED,
+        )
+        if exitstatus in summary_exit_codes and not self.no_summary:
+            self.config.hook.pytest_terminal_summary(
+                terminalreporter=self, exitstatus=exitstatus, config=self.config
+            )
+        if session.shouldfail:
+            self.write_sep("!", str(session.shouldfail), red=True)
+        if exitstatus == ExitCode.INTERRUPTED:
+            self._report_keyboardinterrupt()
+            self._keyboardinterrupt_memo = None
+        elif session.shouldstop:
+            self.write_sep("!", str(session.shouldstop), red=True)
+        self.summary_stats()
+
+    @hookimpl(hookwrapper=True)
+    def pytest_terminal_summary(self) -> Generator[None, None, None]:
+        self.summary_errors()
+        self.summary_failures()
+        self.summary_warnings()
+        self.summary_passes()
+        yield
+        self.short_test_summary()
+        # Display any extra warnings from teardown here (if any).
+        self.summary_warnings()
+
+    def pytest_keyboard_interrupt(self, excinfo: ExceptionInfo[BaseException]) -> None:
+        self._keyboardinterrupt_memo = excinfo.getrepr(funcargs=True)
+
+    def pytest_unconfigure(self) -> None:
+        if self._keyboardinterrupt_memo is not None:
+            self._report_keyboardinterrupt()
+
+    def _report_keyboardinterrupt(self) -> None:
+        excrepr = self._keyboardinterrupt_memo
+        assert excrepr is not None
+        assert excrepr.reprcrash is not None
+        msg = excrepr.reprcrash.message
+        self.write_sep("!", msg)
+        if "KeyboardInterrupt" in msg:
+            if self.config.option.fulltrace:
+                excrepr.toterminal(self._tw)
+            else:
+                excrepr.reprcrash.toterminal(self._tw)
+                self._tw.line(
+                    "(to show a full traceback on KeyboardInterrupt use --full-trace)",
+                    yellow=True,
+                )
+
+    def _locationline(self, nodeid, fspath, lineno, domain):
+        def mkrel(nodeid):
+            line = self.config.cwd_relative_nodeid(nodeid)
+            if domain and line.endswith(domain):
+                line = line[: -len(domain)]
+                values = domain.split("[")
+                values[0] = values[0].replace(".", "::")  # don't replace '.' in params
+                line += "[".join(values)
+            return line
+
+        # collect_fspath comes from testid which has a "/"-normalized path.
+
+        if fspath:
+            res = mkrel(nodeid)
+            if self.verbosity >= 2 and nodeid.split("::")[0] != fspath.replace(
+                "\\", nodes.SEP
+            ):
+                res += " <- " + bestrelpath(self.startpath, fspath)
+        else:
+            res = "[location]"
+        return res + " "
+
+    def _getfailureheadline(self, rep):
+        head_line = rep.head_line
+        if head_line:
+            return head_line
+        return "test session"  # XXX?
+
+    def _getcrashline(self, rep):
+        try:
+            return str(rep.longrepr.reprcrash)
+        except AttributeError:
+            try:
+                return str(rep.longrepr)[:50]
+            except AttributeError:
+                return ""
+
+    #
+    # Summaries for sessionfinish.
+    #
+    def getreports(self, name: str):
+        values = []
+        for x in self.stats.get(name, []):
+            if not hasattr(x, "_pdbshown"):
+                values.append(x)
+        return values
+
+    def summary_warnings(self) -> None:
+        if self.hasopt("w"):
+            all_warnings: Optional[List[WarningReport]] = self.stats.get("warnings")
+            if not all_warnings:
+                return
+
+            final = self._already_displayed_warnings is not None
+            if final:
+                warning_reports = all_warnings[self._already_displayed_warnings :]
+            else:
+                warning_reports = all_warnings
+            self._already_displayed_warnings = len(warning_reports)
+            if not warning_reports:
+                return
+
+            reports_grouped_by_message: Dict[str, List[WarningReport]] = {}
+            for wr in warning_reports:
+                reports_grouped_by_message.setdefault(wr.message, []).append(wr)
+
+            def collapsed_location_report(reports: List[WarningReport]) -> str:
+                locations = []
+                for w in reports:
+                    location = w.get_location(self.config)
+                    if location:
+                        locations.append(location)
+
+                if len(locations) < 10:
+                    return "\n".join(map(str, locations))
+
+                counts_by_filename = Counter(
+                    str(loc).split("::", 1)[0] for loc in locations
+                )
+                return "\n".join(
+                    "{}: {} warning{}".format(k, v, "s" if v > 1 else "")
+                    for k, v in counts_by_filename.items()
+                )
+
+            title = "warnings summary (final)" if final else "warnings summary"
+            self.write_sep("=", title, yellow=True, bold=False)
+            for message, message_reports in reports_grouped_by_message.items():
+                maybe_location = collapsed_location_report(message_reports)
+                if maybe_location:
+                    self._tw.line(maybe_location)
+                    lines = message.splitlines()
+                    indented = "\n".join("  " + x for x in lines)
+                    message = indented.rstrip()
+                else:
+                    message = message.rstrip()
+                self._tw.line(message)
+                self._tw.line()
+            self._tw.line("-- Docs: https://docs.pytest.org/en/stable/warnings.html")
+
+    def summary_passes(self) -> None:
+        if self.config.option.tbstyle != "no":
+            if self.hasopt("P"):
+                reports: List[TestReport] = self.getreports("passed")
+                if not reports:
+                    return
+                self.write_sep("=", "PASSES")
+                for rep in reports:
+                    if rep.sections:
+                        msg = self._getfailureheadline(rep)
+                        self.write_sep("_", msg, green=True, bold=True)
+                        self._outrep_summary(rep)
+                    self._handle_teardown_sections(rep.nodeid)
+
+    def _get_teardown_reports(self, nodeid: str) -> List[TestReport]:
+        reports = self.getreports("")
+        return [
+            report
+            for report in reports
+            if report.when == "teardown" and report.nodeid == nodeid
+        ]
+
+    def _handle_teardown_sections(self, nodeid: str) -> None:
+        for report in self._get_teardown_reports(nodeid):
+            self.print_teardown_sections(report)
+
+    def print_teardown_sections(self, rep: TestReport) -> None:
+        showcapture = self.config.option.showcapture
+        if showcapture == "no":
+            return
+        for secname, content in rep.sections:
+            if showcapture != "all" and showcapture not in secname:
+                continue
+            if "teardown" in secname:
+                self._tw.sep("-", secname)
+                if content[-1:] == "\n":
+                    content = content[:-1]
+                self._tw.line(content)
+
+    def summary_failures(self) -> None:
+        if self.config.option.tbstyle != "no":
+            reports: List[BaseReport] = self.getreports("failed")
+            if not reports:
+                return
+            self.write_sep("=", "FAILURES")
+            if self.config.option.tbstyle == "line":
+                for rep in reports:
+                    line = self._getcrashline(rep)
+                    self.write_line(line)
+            else:
+                for rep in reports:
+                    msg = self._getfailureheadline(rep)
+                    self.write_sep("_", msg, red=True, bold=True)
+                    self._outrep_summary(rep)
+                    self._handle_teardown_sections(rep.nodeid)
+
+    def summary_errors(self) -> None:
+        if self.config.option.tbstyle != "no":
+            reports: List[BaseReport] = self.getreports("error")
+            if not reports:
+                return
+            self.write_sep("=", "ERRORS")
+            for rep in self.stats["error"]:
+                msg = self._getfailureheadline(rep)
+                if rep.when == "collect":
+                    msg = "ERROR collecting " + msg
+                else:
+                    msg = f"ERROR at {rep.when} of {msg}"
+                self.write_sep("_", msg, red=True, bold=True)
+                self._outrep_summary(rep)
+
+    def _outrep_summary(self, rep: BaseReport) -> None:
+        rep.toterminal(self._tw)
+        showcapture = self.config.option.showcapture
+        if showcapture == "no":
+            return
+        for secname, content in rep.sections:
+            if showcapture != "all" and showcapture not in secname:
+                continue
+            self._tw.sep("-", secname)
+            if content[-1:] == "\n":
+                content = content[:-1]
+            self._tw.line(content)
+
+    def summary_stats(self) -> None:
+        if self.verbosity < -1:
+            return
+
+        session_duration = timing.time() - self._sessionstarttime
+        (parts, main_color) = self.build_summary_stats_line()
+        line_parts = []
+
+        display_sep = self.verbosity >= 0
+        if display_sep:
+            fullwidth = self._tw.fullwidth
+        for text, markup in parts:
+            with_markup = self._tw.markup(text, **markup)
+            if display_sep:
+                fullwidth += len(with_markup) - len(text)
+            line_parts.append(with_markup)
+        msg = ", ".join(line_parts)
+
+        main_markup = {main_color: True}
+        duration = " in {}".format(format_session_duration(session_duration))
+        duration_with_markup = self._tw.markup(duration, **main_markup)
+        if display_sep:
+            fullwidth += len(duration_with_markup) - len(duration)
+        msg += duration_with_markup
+
+        if display_sep:
+            markup_for_end_sep = self._tw.markup("", **main_markup)
+            if markup_for_end_sep.endswith("\x1b[0m"):
+                markup_for_end_sep = markup_for_end_sep[:-4]
+            fullwidth += len(markup_for_end_sep)
+            msg += markup_for_end_sep
+
+        if display_sep:
+            self.write_sep("=", msg, fullwidth=fullwidth, **main_markup)
+        else:
+            self.write_line(msg, **main_markup)
+
+    def short_test_summary(self) -> None:
+        if not self.reportchars:
+            return
+
+        def show_simple(stat, lines: List[str]) -> None:
+            failed = self.stats.get(stat, [])
+            if not failed:
+                return
+            termwidth = self._tw.fullwidth
+            config = self.config
+            for rep in failed:
+                line = _get_line_with_reprcrash_message(config, rep, termwidth)
+                lines.append(line)
+
+        def show_xfailed(lines: List[str]) -> None:
+            xfailed = self.stats.get("xfailed", [])
+            for rep in xfailed:
+                verbose_word = rep._get_verbose_word(self.config)
+                pos = _get_pos(self.config, rep)
+                lines.append(f"{verbose_word} {pos}")
+                reason = rep.wasxfail
+                if reason:
+                    lines.append("  " + str(reason))
+
+        def show_xpassed(lines: List[str]) -> None:
+            xpassed = self.stats.get("xpassed", [])
+            for rep in xpassed:
+                verbose_word = rep._get_verbose_word(self.config)
+                pos = _get_pos(self.config, rep)
+                reason = rep.wasxfail
+                lines.append(f"{verbose_word} {pos} {reason}")
+
+        def show_skipped(lines: List[str]) -> None:
+            skipped: List[CollectReport] = self.stats.get("skipped", [])
+            fskips = _folded_skips(self.startpath, skipped) if skipped else []
+            if not fskips:
+                return
+            verbose_word = skipped[0]._get_verbose_word(self.config)
+            for num, fspath, lineno, reason in fskips:
+                if reason.startswith("Skipped: "):
+                    reason = reason[9:]
+                if lineno is not None:
+                    lines.append(
+                        "%s [%d] %s:%d: %s"
+                        % (verbose_word, num, fspath, lineno, reason)
+                    )
+                else:
+                    lines.append("%s [%d] %s: %s" % (verbose_word, num, fspath, reason))
+
+        REPORTCHAR_ACTIONS: Mapping[str, Callable[[List[str]], None]] = {
+            "x": show_xfailed,
+            "X": show_xpassed,
+            "f": partial(show_simple, "failed"),
+            "s": show_skipped,
+            "p": partial(show_simple, "passed"),
+            "E": partial(show_simple, "error"),
+        }
+
+        lines: List[str] = []
+        for char in self.reportchars:
+            action = REPORTCHAR_ACTIONS.get(char)
+            if action:  # skipping e.g. "P" (passed with output) here.
+                action(lines)
+
+        if lines:
+            self.write_sep("=", "short test summary info")
+            for line in lines:
+                self.write_line(line)
+
+    def _get_main_color(self) -> Tuple[str, List[str]]:
+        if self._main_color is None or self._known_types is None or self._is_last_item:
+            self._set_main_color()
+            assert self._main_color
+            assert self._known_types
+        return self._main_color, self._known_types
+
+    def _determine_main_color(self, unknown_type_seen: bool) -> str:
+        stats = self.stats
+        if "failed" in stats or "error" in stats:
+            main_color = "red"
+        elif "warnings" in stats or "xpassed" in stats or unknown_type_seen:
+            main_color = "yellow"
+        elif "passed" in stats or not self._is_last_item:
+            main_color = "green"
+        else:
+            main_color = "yellow"
+        return main_color
+
+    def _set_main_color(self) -> None:
+        unknown_types: List[str] = []
+        for found_type in self.stats.keys():
+            if found_type:  # setup/teardown reports have an empty key, ignore them
+                if found_type not in KNOWN_TYPES and found_type not in unknown_types:
+                    unknown_types.append(found_type)
+        self._known_types = list(KNOWN_TYPES) + unknown_types
+        self._main_color = self._determine_main_color(bool(unknown_types))
+
+    def build_summary_stats_line(self) -> Tuple[List[Tuple[str, Dict[str, bool]]], str]:
+        """
+        Build the parts used in the last summary stats line.
+
+        The summary stats line is the line shown at the end, "=== 12 passed, 2 errors in Xs===".
+
+        This function builds a list of the "parts" that make up for the text in that line, in
+        the example above it would be:
+
+            [
+                ("12 passed", {"green": True}),
+                ("2 errors", {"red": True}
+            ]
+
+        That last dict for each line is a "markup dictionary", used by TerminalWriter to
+        color output.
+
+        The final color of the line is also determined by this function, and is the second
+        element of the returned tuple.
+        """
+        if self.config.getoption("collectonly"):
+            return self._build_collect_only_summary_stats_line()
+        else:
+            return self._build_normal_summary_stats_line()
+
+    def _get_reports_to_display(self, key: str) -> List[Any]:
+        """Get test/collection reports for the given status key, such as `passed` or `error`."""
+        reports = self.stats.get(key, [])
+        return [x for x in reports if getattr(x, "count_towards_summary", True)]
+
+    def _build_normal_summary_stats_line(
+        self,
+    ) -> Tuple[List[Tuple[str, Dict[str, bool]]], str]:
+        main_color, known_types = self._get_main_color()
+        parts = []
+
+        for key in known_types:
+            reports = self._get_reports_to_display(key)
+            if reports:
+                count = len(reports)
+                color = _color_for_type.get(key, _color_for_type_default)
+                markup = {color: True, "bold": color == main_color}
+                parts.append(("%d %s" % pluralize(count, key), markup))
+
+        if not parts:
+            parts = [("no tests ran", {_color_for_type_default: True})]
+
+        return parts, main_color
+
+    def _build_collect_only_summary_stats_line(
+        self,
+    ) -> Tuple[List[Tuple[str, Dict[str, bool]]], str]:
+        deselected = len(self._get_reports_to_display("deselected"))
+        errors = len(self._get_reports_to_display("error"))
+
+        if self._numcollected == 0:
+            parts = [("no tests collected", {"yellow": True})]
+            main_color = "yellow"
+
+        elif deselected == 0:
+            main_color = "green"
+            collected_output = "%d %s collected" % pluralize(self._numcollected, "test")
+            parts = [(collected_output, {main_color: True})]
+        else:
+            all_tests_were_deselected = self._numcollected == deselected
+            if all_tests_were_deselected:
+                main_color = "yellow"
+                collected_output = f"no tests collected ({deselected} deselected)"
+            else:
+                main_color = "green"
+                selected = self._numcollected - deselected
+                collected_output = f"{selected}/{self._numcollected} tests collected ({deselected} deselected)"
+
+            parts = [(collected_output, {main_color: True})]
+
+        if errors:
+            main_color = _color_for_type["error"]
+            parts += [("%d %s" % pluralize(errors, "error"), {main_color: True})]
+
+        return parts, main_color
+
+
+def _get_pos(config: Config, rep: BaseReport):
+    nodeid = config.cwd_relative_nodeid(rep.nodeid)
+    return nodeid
+
+
+def _format_trimmed(format: str, msg: str, available_width: int) -> Optional[str]:
+    """Format msg into format, ellipsizing it if doesn't fit in available_width.
+
+    Returns None if even the ellipsis can't fit.
+    """
+    # Only use the first line.
+    i = msg.find("\n")
+    if i != -1:
+        msg = msg[:i]
+
+    ellipsis = "..."
+    format_width = wcswidth(format.format(""))
+    if format_width + len(ellipsis) > available_width:
+        return None
+
+    if format_width + wcswidth(msg) > available_width:
+        available_width -= len(ellipsis)
+        msg = msg[:available_width]
+        while format_width + wcswidth(msg) > available_width:
+            msg = msg[:-1]
+        msg += ellipsis
+
+    return format.format(msg)
+
+
+def _get_line_with_reprcrash_message(
+    config: Config, rep: BaseReport, termwidth: int
+) -> str:
+    """Get summary line for a report, trying to add reprcrash message."""
+    verbose_word = rep._get_verbose_word(config)
+    pos = _get_pos(config, rep)
+
+    line = f"{verbose_word} {pos}"
+    line_width = wcswidth(line)
+
+    try:
+        # Type ignored intentionally -- possible AttributeError expected.
+        msg = rep.longrepr.reprcrash.message  # type: ignore[union-attr]
+    except AttributeError:
+        pass
+    else:
+        available_width = termwidth - line_width
+        msg = _format_trimmed(" - {}", msg, available_width)
+        if msg is not None:
+            line += msg
+
+    return line
+
+
+def _folded_skips(
+    startpath: Path, skipped: Sequence[CollectReport],
+) -> List[Tuple[int, str, Optional[int], str]]:
+    d: Dict[Tuple[str, Optional[int], str], List[CollectReport]] = {}
+    for event in skipped:
+        assert event.longrepr is not None
+        assert isinstance(event.longrepr, tuple), (event, event.longrepr)
+        assert len(event.longrepr) == 3, (event, event.longrepr)
+        fspath, lineno, reason = event.longrepr
+        # For consistency, report all fspaths in relative form.
+        fspath = bestrelpath(startpath, Path(fspath))
+        keywords = getattr(event, "keywords", {})
+        # Folding reports with global pytestmark variable.
+        # This is a workaround, because for now we cannot identify the scope of a skip marker
+        # TODO: Revisit after marks scope would be fixed.
+        if (
+            event.when == "setup"
+            and "skip" in keywords
+            and "pytestmark" not in keywords
+        ):
+            key: Tuple[str, Optional[int], str] = (fspath, None, reason)
+        else:
+            key = (fspath, lineno, reason)
+        d.setdefault(key, []).append(event)
+    values: List[Tuple[int, str, Optional[int], str]] = []
+    for key, events in d.items():
+        values.append((len(events), *key))
+    return values
+
+
+_color_for_type = {
+    "failed": "red",
+    "error": "red",
+    "warnings": "yellow",
+    "passed": "green",
+}
+_color_for_type_default = "yellow"
+
+
+def pluralize(count: int, noun: str) -> Tuple[int, str]:
+    # No need to pluralize words such as `failed` or `passed`.
+    if noun not in ["error", "warnings", "test"]:
+        return count, noun
+
+    # The `warnings` key is plural. To avoid API breakage, we keep it that way but
+    # set it to singular here so we can determine plurality in the same way as we do
+    # for `error`.
+    noun = noun.replace("warnings", "warning")
+
+    return count, noun + "s" if count != 1 else noun
+
+
+def _plugin_nameversions(plugininfo) -> List[str]:
+    values: List[str] = []
+    for plugin, dist in plugininfo:
+        # Gets us name and version!
+        name = "{dist.project_name}-{dist.version}".format(dist=dist)
+        # Questionable convenience, but it keeps things short.
+        if name.startswith("pytest-"):
+            name = name[7:]
+        # We decided to print python package names they can have more than one plugin.
+        if name not in values:
+            values.append(name)
+    return values
+
+
+def format_session_duration(seconds: float) -> str:
+    """Format the given seconds in a human readable manner to show in the final summary."""
+    if seconds < 60:
+        return f"{seconds:.2f}s"
+    else:
+        dt = datetime.timedelta(seconds=int(seconds))
+        return f"{seconds:.2f}s ({dt})"
+
+
+def _get_raw_skip_reason(report: TestReport) -> str:
+    """Get the reason string of a skip/xfail/xpass test report.
+
+    The string is just the part given by the user.
+    """
+    if hasattr(report, "wasxfail"):
+        reason = cast(str, report.wasxfail)
+        if reason.startswith("reason: "):
+            reason = reason[len("reason: ") :]
+        return reason
+    else:
+        assert report.skipped
+        assert isinstance(report.longrepr, tuple)
+        _, _, reason = report.longrepr
+        if reason.startswith("Skipped: "):
+            reason = reason[len("Skipped: ") :]
+        elif reason == "Skipped":
+            reason = ""
+        return reason
diff --git a/myenv/lib/python3.9/site-packages/_pytest/threadexception.py b/myenv/lib/python3.9/site-packages/_pytest/threadexception.py
new file mode 100644
index 0000000..1c1f62f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/threadexception.py
@@ -0,0 +1,90 @@
+import threading
+import traceback
+import warnings
+from types import TracebackType
+from typing import Any
+from typing import Callable
+from typing import Generator
+from typing import Optional
+from typing import Type
+
+import pytest
+
+
+# Copied from cpython/Lib/test/support/threading_helper.py, with modifications.
+class catch_threading_exception:
+    """Context manager catching threading.Thread exception using
+    threading.excepthook.
+
+    Storing exc_value using a custom hook can create a reference cycle. The
+    reference cycle is broken explicitly when the context manager exits.
+
+    Storing thread using a custom hook can resurrect it if it is set to an
+    object which is being finalized. Exiting the context manager clears the
+    stored object.
+
+    Usage:
+        with threading_helper.catch_threading_exception() as cm:
+            # code spawning a thread which raises an exception
+            ...
+            # check the thread exception: use cm.args
+            ...
+        # cm.args attribute no longer exists at this point
+        # (to break a reference cycle)
+    """
+
+    def __init__(self) -> None:
+        # See https://github.com/python/typeshed/issues/4767 regarding the underscore.
+        self.args: Optional["threading._ExceptHookArgs"] = None
+        self._old_hook: Optional[Callable[["threading._ExceptHookArgs"], Any]] = None
+
+    def _hook(self, args: "threading._ExceptHookArgs") -> None:
+        self.args = args
+
+    def __enter__(self) -> "catch_threading_exception":
+        self._old_hook = threading.excepthook
+        threading.excepthook = self._hook
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        assert self._old_hook is not None
+        threading.excepthook = self._old_hook
+        self._old_hook = None
+        del self.args
+
+
+def thread_exception_runtest_hook() -> Generator[None, None, None]:
+    with catch_threading_exception() as cm:
+        yield
+        if cm.args:
+            if cm.args.thread is not None:
+                thread_name = cm.args.thread.name
+            else:
+                thread_name = "<unknown>"
+            msg = f"Exception in thread {thread_name}\n\n"
+            msg += "".join(
+                traceback.format_exception(
+                    cm.args.exc_type, cm.args.exc_value, cm.args.exc_traceback,
+                )
+            )
+            warnings.warn(pytest.PytestUnhandledThreadExceptionWarning(msg))
+
+
+@pytest.hookimpl(hookwrapper=True, trylast=True)
+def pytest_runtest_setup() -> Generator[None, None, None]:
+    yield from thread_exception_runtest_hook()
+
+
+@pytest.hookimpl(hookwrapper=True, tryfirst=True)
+def pytest_runtest_call() -> Generator[None, None, None]:
+    yield from thread_exception_runtest_hook()
+
+
+@pytest.hookimpl(hookwrapper=True, tryfirst=True)
+def pytest_runtest_teardown() -> Generator[None, None, None]:
+    yield from thread_exception_runtest_hook()
diff --git a/myenv/lib/python3.9/site-packages/_pytest/timing.py b/myenv/lib/python3.9/site-packages/_pytest/timing.py
new file mode 100644
index 0000000..925163a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/timing.py
@@ -0,0 +1,12 @@
+"""Indirection for time functions.
+
+We intentionally grab some "time" functions internally to avoid tests mocking "time" to affect
+pytest runtime information (issue #185).
+
+Fixture "mock_timing" also interacts with this module for pytest's own tests.
+"""
+from time import perf_counter
+from time import sleep
+from time import time
+
+__all__ = ["perf_counter", "sleep", "time"]
diff --git a/myenv/lib/python3.9/site-packages/_pytest/tmpdir.py b/myenv/lib/python3.9/site-packages/_pytest/tmpdir.py
new file mode 100644
index 0000000..a6bd383
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/tmpdir.py
@@ -0,0 +1,254 @@
+"""Support for providing temporary directories to test functions."""
+import os
+import re
+import sys
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+import attr
+import py
+
+from .pathlib import LOCK_TIMEOUT
+from .pathlib import make_numbered_dir
+from .pathlib import make_numbered_dir_with_cleanup
+from .pathlib import rm_rf
+from _pytest.compat import final
+from _pytest.config import Config
+from _pytest.deprecated import check_ispytest
+from _pytest.fixtures import fixture
+from _pytest.fixtures import FixtureRequest
+from _pytest.monkeypatch import MonkeyPatch
+
+
+@final
+@attr.s(init=False)
+class TempPathFactory:
+    """Factory for temporary directories under the common base temp directory.
+
+    The base directory can be configured using the ``--basetemp`` option.
+    """
+
+    _given_basetemp = attr.ib(type=Optional[Path])
+    _trace = attr.ib()
+    _basetemp = attr.ib(type=Optional[Path])
+
+    def __init__(
+        self,
+        given_basetemp: Optional[Path],
+        trace,
+        basetemp: Optional[Path] = None,
+        *,
+        _ispytest: bool = False,
+    ) -> None:
+        check_ispytest(_ispytest)
+        if given_basetemp is None:
+            self._given_basetemp = None
+        else:
+            # Use os.path.abspath() to get absolute path instead of resolve() as it
+            # does not work the same in all platforms (see #4427).
+            # Path.absolute() exists, but it is not public (see https://bugs.python.org/issue25012).
+            self._given_basetemp = Path(os.path.abspath(str(given_basetemp)))
+        self._trace = trace
+        self._basetemp = basetemp
+
+    @classmethod
+    def from_config(
+        cls, config: Config, *, _ispytest: bool = False,
+    ) -> "TempPathFactory":
+        """Create a factory according to pytest configuration.
+
+        :meta private:
+        """
+        check_ispytest(_ispytest)
+        return cls(
+            given_basetemp=config.option.basetemp,
+            trace=config.trace.get("tmpdir"),
+            _ispytest=True,
+        )
+
+    def _ensure_relative_to_basetemp(self, basename: str) -> str:
+        basename = os.path.normpath(basename)
+        if (self.getbasetemp() / basename).resolve().parent != self.getbasetemp():
+            raise ValueError(f"{basename} is not a normalized and relative path")
+        return basename
+
+    def mktemp(self, basename: str, numbered: bool = True) -> Path:
+        """Create a new temporary directory managed by the factory.
+
+        :param basename:
+            Directory base name, must be a relative path.
+
+        :param numbered:
+            If ``True``, ensure the directory is unique by adding a numbered
+            suffix greater than any existing one: ``basename="foo-"`` and ``numbered=True``
+            means that this function will create directories named ``"foo-0"``,
+            ``"foo-1"``, ``"foo-2"`` and so on.
+
+        :returns:
+            The path to the new directory.
+        """
+        basename = self._ensure_relative_to_basetemp(basename)
+        if not numbered:
+            p = self.getbasetemp().joinpath(basename)
+            p.mkdir(mode=0o700)
+        else:
+            p = make_numbered_dir(root=self.getbasetemp(), prefix=basename, mode=0o700)
+            self._trace("mktemp", p)
+        return p
+
+    def getbasetemp(self) -> Path:
+        """Return the base temporary directory, creating it if needed."""
+        if self._basetemp is not None:
+            return self._basetemp
+
+        if self._given_basetemp is not None:
+            basetemp = self._given_basetemp
+            if basetemp.exists():
+                rm_rf(basetemp)
+            basetemp.mkdir(mode=0o700)
+            basetemp = basetemp.resolve()
+        else:
+            from_env = os.environ.get("PYTEST_DEBUG_TEMPROOT")
+            temproot = Path(from_env or tempfile.gettempdir()).resolve()
+            user = get_user() or "unknown"
+            # use a sub-directory in the temproot to speed-up
+            # make_numbered_dir() call
+            rootdir = temproot.joinpath(f"pytest-of-{user}")
+            rootdir.mkdir(mode=0o700, exist_ok=True)
+            # Because we use exist_ok=True with a predictable name, make sure
+            # we are the owners, to prevent any funny business (on unix, where
+            # temproot is usually shared).
+            # Also, to keep things private, fixup any world-readable temp
+            # rootdir's permissions. Historically 0o755 was used, so we can't
+            # just error out on this, at least for a while.
+            if sys.platform != "win32":
+                uid = os.getuid()
+                rootdir_stat = rootdir.stat()
+                # getuid shouldn't fail, but cpython defines such a case.
+                # Let's hope for the best.
+                if uid != -1:
+                    if rootdir_stat.st_uid != uid:
+                        raise OSError(
+                            f"The temporary directory {rootdir} is not owned by the current user. "
+                            "Fix this and try again."
+                        )
+                    if (rootdir_stat.st_mode & 0o077) != 0:
+                        os.chmod(rootdir, rootdir_stat.st_mode & ~0o077)
+            basetemp = make_numbered_dir_with_cleanup(
+                prefix="pytest-",
+                root=rootdir,
+                keep=3,
+                lock_timeout=LOCK_TIMEOUT,
+                mode=0o700,
+            )
+        assert basetemp is not None, basetemp
+        self._basetemp = basetemp
+        self._trace("new basetemp", basetemp)
+        return basetemp
+
+
+@final
+@attr.s(init=False)
+class TempdirFactory:
+    """Backward comptibility wrapper that implements :class:``py.path.local``
+    for :class:``TempPathFactory``."""
+
+    _tmppath_factory = attr.ib(type=TempPathFactory)
+
+    def __init__(
+        self, tmppath_factory: TempPathFactory, *, _ispytest: bool = False
+    ) -> None:
+        check_ispytest(_ispytest)
+        self._tmppath_factory = tmppath_factory
+
+    def mktemp(self, basename: str, numbered: bool = True) -> py.path.local:
+        """Same as :meth:`TempPathFactory.mktemp`, but returns a ``py.path.local`` object."""
+        return py.path.local(self._tmppath_factory.mktemp(basename, numbered).resolve())
+
+    def getbasetemp(self) -> py.path.local:
+        """Backward compat wrapper for ``_tmppath_factory.getbasetemp``."""
+        return py.path.local(self._tmppath_factory.getbasetemp().resolve())
+
+
+def get_user() -> Optional[str]:
+    """Return the current user name, or None if getuser() does not work
+    in the current environment (see #1010)."""
+    import getpass
+
+    try:
+        return getpass.getuser()
+    except (ImportError, KeyError):
+        return None
+
+
+def pytest_configure(config: Config) -> None:
+    """Create a TempdirFactory and attach it to the config object.
+
+    This is to comply with existing plugins which expect the handler to be
+    available at pytest_configure time, but ideally should be moved entirely
+    to the tmpdir_factory session fixture.
+    """
+    mp = MonkeyPatch()
+    tmppath_handler = TempPathFactory.from_config(config, _ispytest=True)
+    t = TempdirFactory(tmppath_handler, _ispytest=True)
+    config._cleanup.append(mp.undo)
+    mp.setattr(config, "_tmp_path_factory", tmppath_handler, raising=False)
+    mp.setattr(config, "_tmpdirhandler", t, raising=False)
+
+
+@fixture(scope="session")
+def tmpdir_factory(request: FixtureRequest) -> TempdirFactory:
+    """Return a :class:`_pytest.tmpdir.TempdirFactory` instance for the test session."""
+    # Set dynamically by pytest_configure() above.
+    return request.config._tmpdirhandler  # type: ignore
+
+
+@fixture(scope="session")
+def tmp_path_factory(request: FixtureRequest) -> TempPathFactory:
+    """Return a :class:`_pytest.tmpdir.TempPathFactory` instance for the test session."""
+    # Set dynamically by pytest_configure() above.
+    return request.config._tmp_path_factory  # type: ignore
+
+
+def _mk_tmp(request: FixtureRequest, factory: TempPathFactory) -> Path:
+    name = request.node.name
+    name = re.sub(r"[\W]", "_", name)
+    MAXVAL = 30
+    name = name[:MAXVAL]
+    return factory.mktemp(name, numbered=True)
+
+
+@fixture
+def tmpdir(tmp_path: Path) -> py.path.local:
+    """Return a temporary directory path object which is unique to each test
+    function invocation, created as a sub directory of the base temporary
+    directory.
+
+    By default, a new base temporary directory is created each test session,
+    and old bases are removed after 3 sessions, to aid in debugging. If
+    ``--basetemp`` is used then it is cleared each session. See :ref:`base
+    temporary directory`.
+
+    The returned object is a `py.path.local`_ path object.
+
+    .. _`py.path.local`: https://py.readthedocs.io/en/latest/path.html
+    """
+    return py.path.local(tmp_path)
+
+
+@fixture
+def tmp_path(request: FixtureRequest, tmp_path_factory: TempPathFactory) -> Path:
+    """Return a temporary directory path object which is unique to each test
+    function invocation, created as a sub directory of the base temporary
+    directory.
+
+    By default, a new base temporary directory is created each test session,
+    and old bases are removed after 3 sessions, to aid in debugging. If
+    ``--basetemp`` is used then it is cleared each session. See :ref:`base
+    temporary directory`.
+
+    The returned object is a :class:`pathlib.Path` object.
+    """
+
+    return _mk_tmp(request, tmp_path_factory)
diff --git a/myenv/lib/python3.9/site-packages/_pytest/unittest.py b/myenv/lib/python3.9/site-packages/_pytest/unittest.py
new file mode 100644
index 0000000..55f15ef
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/unittest.py
@@ -0,0 +1,405 @@
+"""Discover and run std-library "unittest" style tests."""
+import sys
+import traceback
+import types
+from typing import Any
+from typing import Callable
+from typing import Generator
+from typing import Iterable
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import Union
+
+import _pytest._code
+import pytest
+from _pytest.compat import getimfunc
+from _pytest.compat import is_async_function
+from _pytest.config import hookimpl
+from _pytest.fixtures import FixtureRequest
+from _pytest.nodes import Collector
+from _pytest.nodes import Item
+from _pytest.outcomes import exit
+from _pytest.outcomes import fail
+from _pytest.outcomes import skip
+from _pytest.outcomes import xfail
+from _pytest.python import Class
+from _pytest.python import Function
+from _pytest.python import PyCollector
+from _pytest.runner import CallInfo
+from _pytest.skipping import skipped_by_mark_key
+from _pytest.skipping import unexpectedsuccess_key
+
+if TYPE_CHECKING:
+    import unittest
+
+    from _pytest.fixtures import _Scope
+
+    _SysExcInfoType = Union[
+        Tuple[Type[BaseException], BaseException, types.TracebackType],
+        Tuple[None, None, None],
+    ]
+
+
+def pytest_pycollect_makeitem(
+    collector: PyCollector, name: str, obj: object
+) -> Optional["UnitTestCase"]:
+    # Has unittest been imported and is obj a subclass of its TestCase?
+    try:
+        ut = sys.modules["unittest"]
+        # Type ignored because `ut` is an opaque module.
+        if not issubclass(obj, ut.TestCase):  # type: ignore
+            return None
+    except Exception:
+        return None
+    # Yes, so let's collect it.
+    item: UnitTestCase = UnitTestCase.from_parent(collector, name=name, obj=obj)
+    return item
+
+
+class UnitTestCase(Class):
+    # Marker for fixturemanger.getfixtureinfo()
+    # to declare that our children do not support funcargs.
+    nofuncargs = True
+
+    def collect(self) -> Iterable[Union[Item, Collector]]:
+        from unittest import TestLoader
+
+        cls = self.obj
+        if not getattr(cls, "__test__", True):
+            return
+
+        skipped = _is_skipped(cls)
+        if not skipped:
+            self._inject_setup_teardown_fixtures(cls)
+            self._inject_setup_class_fixture()
+
+        self.session._fixturemanager.parsefactories(self, unittest=True)
+        loader = TestLoader()
+        foundsomething = False
+        for name in loader.getTestCaseNames(self.obj):
+            x = getattr(self.obj, name)
+            if not getattr(x, "__test__", True):
+                continue
+            funcobj = getimfunc(x)
+            yield TestCaseFunction.from_parent(self, name=name, callobj=funcobj)
+            foundsomething = True
+
+        if not foundsomething:
+            runtest = getattr(self.obj, "runTest", None)
+            if runtest is not None:
+                ut = sys.modules.get("twisted.trial.unittest", None)
+                # Type ignored because `ut` is an opaque module.
+                if ut is None or runtest != ut.TestCase.runTest:  # type: ignore
+                    yield TestCaseFunction.from_parent(self, name="runTest")
+
+    def _inject_setup_teardown_fixtures(self, cls: type) -> None:
+        """Injects a hidden auto-use fixture to invoke setUpClass/setup_method and corresponding
+        teardown functions (#517)."""
+        class_fixture = _make_xunit_fixture(
+            cls,
+            "setUpClass",
+            "tearDownClass",
+            "doClassCleanups",
+            scope="class",
+            pass_self=False,
+        )
+        if class_fixture:
+            cls.__pytest_class_setup = class_fixture  # type: ignore[attr-defined]
+
+        method_fixture = _make_xunit_fixture(
+            cls,
+            "setup_method",
+            "teardown_method",
+            None,
+            scope="function",
+            pass_self=True,
+        )
+        if method_fixture:
+            cls.__pytest_method_setup = method_fixture  # type: ignore[attr-defined]
+
+
+def _make_xunit_fixture(
+    obj: type,
+    setup_name: str,
+    teardown_name: str,
+    cleanup_name: Optional[str],
+    scope: "_Scope",
+    pass_self: bool,
+):
+    setup = getattr(obj, setup_name, None)
+    teardown = getattr(obj, teardown_name, None)
+    if setup is None and teardown is None:
+        return None
+
+    if cleanup_name:
+        cleanup = getattr(obj, cleanup_name, lambda *args: None)
+    else:
+
+        def cleanup(*args):
+            pass
+
+    @pytest.fixture(
+        scope=scope,
+        autouse=True,
+        # Use a unique name to speed up lookup.
+        name=f"unittest_{setup_name}_fixture_{obj.__qualname__}",
+    )
+    def fixture(self, request: FixtureRequest) -> Generator[None, None, None]:
+        if _is_skipped(self):
+            reason = self.__unittest_skip_why__
+            pytest.skip(reason)
+        if setup is not None:
+            try:
+                if pass_self:
+                    setup(self, request.function)
+                else:
+                    setup()
+            # unittest does not call the cleanup function for every BaseException, so we
+            # follow this here.
+            except Exception:
+                if pass_self:
+                    cleanup(self)
+                else:
+                    cleanup()
+
+                raise
+        yield
+        try:
+            if teardown is not None:
+                if pass_self:
+                    teardown(self, request.function)
+                else:
+                    teardown()
+        finally:
+            if pass_self:
+                cleanup(self)
+            else:
+                cleanup()
+
+    return fixture
+
+
+class TestCaseFunction(Function):
+    nofuncargs = True
+    _excinfo: Optional[List[_pytest._code.ExceptionInfo[BaseException]]] = None
+    _testcase: Optional["unittest.TestCase"] = None
+
+    def setup(self) -> None:
+        # A bound method to be called during teardown() if set (see 'runtest()').
+        self._explicit_tearDown: Optional[Callable[[], None]] = None
+        assert self.parent is not None
+        self._testcase = self.parent.obj(self.name)  # type: ignore[attr-defined]
+        self._obj = getattr(self._testcase, self.name)
+        if hasattr(self, "_request"):
+            self._request._fillfixtures()
+
+    def teardown(self) -> None:
+        if self._explicit_tearDown is not None:
+            self._explicit_tearDown()
+            self._explicit_tearDown = None
+        self._testcase = None
+        self._obj = None
+
+    def startTest(self, testcase: "unittest.TestCase") -> None:
+        pass
+
+    def _addexcinfo(self, rawexcinfo: "_SysExcInfoType") -> None:
+        # Unwrap potential exception info (see twisted trial support below).
+        rawexcinfo = getattr(rawexcinfo, "_rawexcinfo", rawexcinfo)
+        try:
+            excinfo = _pytest._code.ExceptionInfo(rawexcinfo)  # type: ignore[arg-type]
+            # Invoke the attributes to trigger storing the traceback
+            # trial causes some issue there.
+            excinfo.value
+            excinfo.traceback
+        except TypeError:
+            try:
+                try:
+                    values = traceback.format_exception(*rawexcinfo)
+                    values.insert(
+                        0,
+                        "NOTE: Incompatible Exception Representation, "
+                        "displaying natively:\n\n",
+                    )
+                    fail("".join(values), pytrace=False)
+                except (fail.Exception, KeyboardInterrupt):
+                    raise
+                except BaseException:
+                    fail(
+                        "ERROR: Unknown Incompatible Exception "
+                        "representation:\n%r" % (rawexcinfo,),
+                        pytrace=False,
+                    )
+            except KeyboardInterrupt:
+                raise
+            except fail.Exception:
+                excinfo = _pytest._code.ExceptionInfo.from_current()
+        self.__dict__.setdefault("_excinfo", []).append(excinfo)
+
+    def addError(
+        self, testcase: "unittest.TestCase", rawexcinfo: "_SysExcInfoType"
+    ) -> None:
+        try:
+            if isinstance(rawexcinfo[1], exit.Exception):
+                exit(rawexcinfo[1].msg)
+        except TypeError:
+            pass
+        self._addexcinfo(rawexcinfo)
+
+    def addFailure(
+        self, testcase: "unittest.TestCase", rawexcinfo: "_SysExcInfoType"
+    ) -> None:
+        self._addexcinfo(rawexcinfo)
+
+    def addSkip(self, testcase: "unittest.TestCase", reason: str) -> None:
+        try:
+            skip(reason)
+        except skip.Exception:
+            self._store[skipped_by_mark_key] = True
+            self._addexcinfo(sys.exc_info())
+
+    def addExpectedFailure(
+        self,
+        testcase: "unittest.TestCase",
+        rawexcinfo: "_SysExcInfoType",
+        reason: str = "",
+    ) -> None:
+        try:
+            xfail(str(reason))
+        except xfail.Exception:
+            self._addexcinfo(sys.exc_info())
+
+    def addUnexpectedSuccess(
+        self, testcase: "unittest.TestCase", reason: str = ""
+    ) -> None:
+        self._store[unexpectedsuccess_key] = reason
+
+    def addSuccess(self, testcase: "unittest.TestCase") -> None:
+        pass
+
+    def stopTest(self, testcase: "unittest.TestCase") -> None:
+        pass
+
+    def _expecting_failure(self, test_method) -> bool:
+        """Return True if the given unittest method (or the entire class) is marked
+        with @expectedFailure."""
+        expecting_failure_method = getattr(
+            test_method, "__unittest_expecting_failure__", False
+        )
+        expecting_failure_class = getattr(self, "__unittest_expecting_failure__", False)
+        return bool(expecting_failure_class or expecting_failure_method)
+
+    def runtest(self) -> None:
+        from _pytest.debugging import maybe_wrap_pytest_function_for_tracing
+
+        assert self._testcase is not None
+
+        maybe_wrap_pytest_function_for_tracing(self)
+
+        # Let the unittest framework handle async functions.
+        if is_async_function(self.obj):
+            # Type ignored because self acts as the TestResult, but is not actually one.
+            self._testcase(result=self)  # type: ignore[arg-type]
+        else:
+            # When --pdb is given, we want to postpone calling tearDown() otherwise
+            # when entering the pdb prompt, tearDown() would have probably cleaned up
+            # instance variables, which makes it difficult to debug.
+            # Arguably we could always postpone tearDown(), but this changes the moment where the
+            # TestCase instance interacts with the results object, so better to only do it
+            # when absolutely needed.
+            if self.config.getoption("usepdb") and not _is_skipped(self.obj):
+                self._explicit_tearDown = self._testcase.tearDown
+                setattr(self._testcase, "tearDown", lambda *args: None)
+
+            # We need to update the actual bound method with self.obj, because
+            # wrap_pytest_function_for_tracing replaces self.obj by a wrapper.
+            setattr(self._testcase, self.name, self.obj)
+            try:
+                self._testcase(result=self)  # type: ignore[arg-type]
+            finally:
+                delattr(self._testcase, self.name)
+
+    def _prunetraceback(
+        self, excinfo: _pytest._code.ExceptionInfo[BaseException]
+    ) -> None:
+        Function._prunetraceback(self, excinfo)
+        traceback = excinfo.traceback.filter(
+            lambda x: not x.frame.f_globals.get("__unittest")
+        )
+        if traceback:
+            excinfo.traceback = traceback
+
+
+@hookimpl(tryfirst=True)
+def pytest_runtest_makereport(item: Item, call: CallInfo[None]) -> None:
+    if isinstance(item, TestCaseFunction):
+        if item._excinfo:
+            call.excinfo = item._excinfo.pop(0)
+            try:
+                del call.result
+            except AttributeError:
+                pass
+
+    unittest = sys.modules.get("unittest")
+    if (
+        unittest
+        and call.excinfo
+        and isinstance(call.excinfo.value, unittest.SkipTest)  # type: ignore[attr-defined]
+    ):
+        excinfo = call.excinfo
+        # Let's substitute the excinfo with a pytest.skip one.
+        call2 = CallInfo[None].from_call(
+            lambda: pytest.skip(str(excinfo.value)), call.when
+        )
+        call.excinfo = call2.excinfo
+
+
+# Twisted trial support.
+
+
+@hookimpl(hookwrapper=True)
+def pytest_runtest_protocol(item: Item) -> Generator[None, None, None]:
+    if isinstance(item, TestCaseFunction) and "twisted.trial.unittest" in sys.modules:
+        ut: Any = sys.modules["twisted.python.failure"]
+        Failure__init__ = ut.Failure.__init__
+        check_testcase_implements_trial_reporter()
+
+        def excstore(
+            self, exc_value=None, exc_type=None, exc_tb=None, captureVars=None
+        ):
+            if exc_value is None:
+                self._rawexcinfo = sys.exc_info()
+            else:
+                if exc_type is None:
+                    exc_type = type(exc_value)
+                self._rawexcinfo = (exc_type, exc_value, exc_tb)
+            try:
+                Failure__init__(
+                    self, exc_value, exc_type, exc_tb, captureVars=captureVars
+                )
+            except TypeError:
+                Failure__init__(self, exc_value, exc_type, exc_tb)
+
+        ut.Failure.__init__ = excstore
+        yield
+        ut.Failure.__init__ = Failure__init__
+    else:
+        yield
+
+
+def check_testcase_implements_trial_reporter(done: List[int] = []) -> None:
+    if done:
+        return
+    from zope.interface import classImplements
+    from twisted.trial.itrial import IReporter
+
+    classImplements(TestCaseFunction, IReporter)
+    done.append(1)
+
+
+def _is_skipped(obj) -> bool:
+    """Return True if the given object has been marked with @unittest.skip."""
+    return bool(getattr(obj, "__unittest_skip__", False))
diff --git a/myenv/lib/python3.9/site-packages/_pytest/unraisableexception.py b/myenv/lib/python3.9/site-packages/_pytest/unraisableexception.py
new file mode 100644
index 0000000..fcb5d82
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/unraisableexception.py
@@ -0,0 +1,93 @@
+import sys
+import traceback
+import warnings
+from types import TracebackType
+from typing import Any
+from typing import Callable
+from typing import Generator
+from typing import Optional
+from typing import Type
+
+import pytest
+
+
+# Copied from cpython/Lib/test/support/__init__.py, with modifications.
+class catch_unraisable_exception:
+    """Context manager catching unraisable exception using sys.unraisablehook.
+
+    Storing the exception value (cm.unraisable.exc_value) creates a reference
+    cycle. The reference cycle is broken explicitly when the context manager
+    exits.
+
+    Storing the object (cm.unraisable.object) can resurrect it if it is set to
+    an object which is being finalized. Exiting the context manager clears the
+    stored object.
+
+    Usage:
+        with catch_unraisable_exception() as cm:
+            # code creating an "unraisable exception"
+            ...
+            # check the unraisable exception: use cm.unraisable
+            ...
+        # cm.unraisable attribute no longer exists at this point
+        # (to break a reference cycle)
+    """
+
+    def __init__(self) -> None:
+        self.unraisable: Optional["sys.UnraisableHookArgs"] = None
+        self._old_hook: Optional[Callable[["sys.UnraisableHookArgs"], Any]] = None
+
+    def _hook(self, unraisable: "sys.UnraisableHookArgs") -> None:
+        # Storing unraisable.object can resurrect an object which is being
+        # finalized. Storing unraisable.exc_value creates a reference cycle.
+        self.unraisable = unraisable
+
+    def __enter__(self) -> "catch_unraisable_exception":
+        self._old_hook = sys.unraisablehook
+        sys.unraisablehook = self._hook
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        assert self._old_hook is not None
+        sys.unraisablehook = self._old_hook
+        self._old_hook = None
+        del self.unraisable
+
+
+def unraisable_exception_runtest_hook() -> Generator[None, None, None]:
+    with catch_unraisable_exception() as cm:
+        yield
+        if cm.unraisable:
+            if cm.unraisable.err_msg is not None:
+                err_msg = cm.unraisable.err_msg
+            else:
+                err_msg = "Exception ignored in"
+            msg = f"{err_msg}: {cm.unraisable.object!r}\n\n"
+            msg += "".join(
+                traceback.format_exception(
+                    cm.unraisable.exc_type,
+                    cm.unraisable.exc_value,
+                    cm.unraisable.exc_traceback,
+                )
+            )
+            warnings.warn(pytest.PytestUnraisableExceptionWarning(msg))
+
+
+@pytest.hookimpl(hookwrapper=True, tryfirst=True)
+def pytest_runtest_setup() -> Generator[None, None, None]:
+    yield from unraisable_exception_runtest_hook()
+
+
+@pytest.hookimpl(hookwrapper=True, tryfirst=True)
+def pytest_runtest_call() -> Generator[None, None, None]:
+    yield from unraisable_exception_runtest_hook()
+
+
+@pytest.hookimpl(hookwrapper=True, tryfirst=True)
+def pytest_runtest_teardown() -> Generator[None, None, None]:
+    yield from unraisable_exception_runtest_hook()
diff --git a/myenv/lib/python3.9/site-packages/_pytest/warning_types.py b/myenv/lib/python3.9/site-packages/_pytest/warning_types.py
new file mode 100644
index 0000000..2eadd9f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/warning_types.py
@@ -0,0 +1,132 @@
+from typing import Any
+from typing import Generic
+from typing import Type
+from typing import TypeVar
+
+import attr
+
+from _pytest.compat import final
+
+
+class PytestWarning(UserWarning):
+    """Base class for all warnings emitted by pytest."""
+
+    __module__ = "pytest"
+
+
+@final
+class PytestAssertRewriteWarning(PytestWarning):
+    """Warning emitted by the pytest assert rewrite module."""
+
+    __module__ = "pytest"
+
+
+@final
+class PytestCacheWarning(PytestWarning):
+    """Warning emitted by the cache plugin in various situations."""
+
+    __module__ = "pytest"
+
+
+@final
+class PytestConfigWarning(PytestWarning):
+    """Warning emitted for configuration issues."""
+
+    __module__ = "pytest"
+
+
+@final
+class PytestCollectionWarning(PytestWarning):
+    """Warning emitted when pytest is not able to collect a file or symbol in a module."""
+
+    __module__ = "pytest"
+
+
+@final
+class PytestDeprecationWarning(PytestWarning, DeprecationWarning):
+    """Warning class for features that will be removed in a future version."""
+
+    __module__ = "pytest"
+
+
+@final
+class PytestExperimentalApiWarning(PytestWarning, FutureWarning):
+    """Warning category used to denote experiments in pytest.
+
+    Use sparingly as the API might change or even be removed completely in a
+    future version.
+    """
+
+    __module__ = "pytest"
+
+    @classmethod
+    def simple(cls, apiname: str) -> "PytestExperimentalApiWarning":
+        return cls(
+            "{apiname} is an experimental api that may change over time".format(
+                apiname=apiname
+            )
+        )
+
+
+@final
+class PytestUnhandledCoroutineWarning(PytestWarning):
+    """Warning emitted for an unhandled coroutine.
+
+    A coroutine was encountered when collecting test functions, but was not
+    handled by any async-aware plugin.
+    Coroutine test functions are not natively supported.
+    """
+
+    __module__ = "pytest"
+
+
+@final
+class PytestUnknownMarkWarning(PytestWarning):
+    """Warning emitted on use of unknown markers.
+
+    See :ref:`mark` for details.
+    """
+
+    __module__ = "pytest"
+
+
+@final
+class PytestUnraisableExceptionWarning(PytestWarning):
+    """An unraisable exception was reported.
+
+    Unraisable exceptions are exceptions raised in :meth:`__del__ <object.__del__>`
+    implementations and similar situations when the exception cannot be raised
+    as normal.
+    """
+
+    __module__ = "pytest"
+
+
+@final
+class PytestUnhandledThreadExceptionWarning(PytestWarning):
+    """An unhandled exception occurred in a :class:`~threading.Thread`.
+
+    Such exceptions don't propagate normally.
+    """
+
+    __module__ = "pytest"
+
+
+_W = TypeVar("_W", bound=PytestWarning)
+
+
+@final
+@attr.s
+class UnformattedWarning(Generic[_W]):
+    """A warning meant to be formatted during runtime.
+
+    This is used to hold warnings that need to format their message at runtime,
+    as opposed to a direct message.
+    """
+
+    category = attr.ib(type=Type["_W"])
+    template = attr.ib(type=str)
+
+    def format(self, **kwargs: Any) -> _W:
+        """Return an instance of the warning category, formatted with given kwargs."""
+        return self.category(self.template.format(**kwargs))
diff --git a/myenv/lib/python3.9/site-packages/_pytest/warnings.py b/myenv/lib/python3.9/site-packages/_pytest/warnings.py
new file mode 100644
index 0000000..35eed96
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_pytest/warnings.py
@@ -0,0 +1,139 @@
+import sys
+import warnings
+from contextlib import contextmanager
+from typing import Generator
+from typing import Optional
+from typing import TYPE_CHECKING
+
+import pytest
+from _pytest.config import apply_warning_filters
+from _pytest.config import Config
+from _pytest.config import parse_warning_filter
+from _pytest.main import Session
+from _pytest.nodes import Item
+from _pytest.terminal import TerminalReporter
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
+
+def pytest_configure(config: Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "filterwarnings(warning): add a warning filter to the given test. "
+        "see https://docs.pytest.org/en/stable/warnings.html#pytest-mark-filterwarnings ",
+    )
+
+
+@contextmanager
+def catch_warnings_for_item(
+    config: Config,
+    ihook,
+    when: "Literal['config', 'collect', 'runtest']",
+    item: Optional[Item],
+) -> Generator[None, None, None]:
+    """Context manager that catches warnings generated in the contained execution block.
+
+    ``item`` can be None if we are not in the context of an item execution.
+
+    Each warning captured triggers the ``pytest_warning_recorded`` hook.
+    """
+    config_filters = config.getini("filterwarnings")
+    cmdline_filters = config.known_args_namespace.pythonwarnings or []
+    with warnings.catch_warnings(record=True) as log:
+        # mypy can't infer that record=True means log is not None; help it.
+        assert log is not None
+
+        if not sys.warnoptions:
+            # If user is not explicitly configuring warning filters, show deprecation warnings by default (#2908).
+            warnings.filterwarnings("always", category=DeprecationWarning)
+            warnings.filterwarnings("always", category=PendingDeprecationWarning)
+
+        apply_warning_filters(config_filters, cmdline_filters)
+
+        # apply filters from "filterwarnings" marks
+        nodeid = "" if item is None else item.nodeid
+        if item is not None:
+            for mark in item.iter_markers(name="filterwarnings"):
+                for arg in mark.args:
+                    warnings.filterwarnings(*parse_warning_filter(arg, escape=False))
+
+        yield
+
+        for warning_message in log:
+            ihook.pytest_warning_captured.call_historic(
+                kwargs=dict(
+                    warning_message=warning_message,
+                    when=when,
+                    item=item,
+                    location=None,
+                )
+            )
+            ihook.pytest_warning_recorded.call_historic(
+                kwargs=dict(
+                    warning_message=warning_message,
+                    nodeid=nodeid,
+                    when=when,
+                    location=None,
+                )
+            )
+
+
+def warning_record_to_str(warning_message: warnings.WarningMessage) -> str:
+    """Convert a warnings.WarningMessage to a string."""
+    warn_msg = warning_message.message
+    msg = warnings.formatwarning(
+        str(warn_msg),
+        warning_message.category,
+        warning_message.filename,
+        warning_message.lineno,
+        warning_message.line,
+    )
+    return msg
+
+
+@pytest.hookimpl(hookwrapper=True, tryfirst=True)
+def pytest_runtest_protocol(item: Item) -> Generator[None, None, None]:
+    with catch_warnings_for_item(
+        config=item.config, ihook=item.ihook, when="runtest", item=item
+    ):
+        yield
+
+
+@pytest.hookimpl(hookwrapper=True, tryfirst=True)
+def pytest_collection(session: Session) -> Generator[None, None, None]:
+    config = session.config
+    with catch_warnings_for_item(
+        config=config, ihook=config.hook, when="collect", item=None
+    ):
+        yield
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_terminal_summary(
+    terminalreporter: TerminalReporter,
+) -> Generator[None, None, None]:
+    config = terminalreporter.config
+    with catch_warnings_for_item(
+        config=config, ihook=config.hook, when="config", item=None
+    ):
+        yield
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_sessionfinish(session: Session) -> Generator[None, None, None]:
+    config = session.config
+    with catch_warnings_for_item(
+        config=config, ihook=config.hook, when="config", item=None
+    ):
+        yield
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_load_initial_conftests(
+    early_config: "Config",
+) -> Generator[None, None, None]:
+    with catch_warnings_for_item(
+        config=early_config, ihook=early_config.hook, when="config", item=None
+    ):
+        yield
diff --git a/myenv/lib/python3.9/site-packages/_yaml/__init__.py b/myenv/lib/python3.9/site-packages/_yaml/__init__.py
new file mode 100644
index 0000000..7baa8c4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/_yaml/__init__.py
@@ -0,0 +1,33 @@
+# This is a stub package designed to roughly emulate the _yaml
+# extension module, which previously existed as a standalone module
+# and has been moved into the `yaml` package namespace.
+# It does not perfectly mimic its old counterpart, but should get
+# close enough for anyone who's relying on it even when they shouldn't.
+import yaml
+
+# in some circumstances, the yaml module we imoprted may be from a different version, so we need
+# to tread carefully when poking at it here (it may not have the attributes we expect)
+if not getattr(yaml, '__with_libyaml__', False):
+    from sys import version_info
+
+    exc = ModuleNotFoundError if version_info >= (3, 6) else ImportError
+    raise exc("No module named '_yaml'")
+else:
+    from yaml._yaml import *
+    import warnings
+    warnings.warn(
+        'The _yaml extension module is now located at yaml._yaml'
+        ' and its location is subject to change.  To use the'
+        ' LibYAML-based parser and emitter, import from `yaml`:'
+        ' `from yaml import CLoader as Loader, CDumper as Dumper`.',
+        DeprecationWarning
+    )
+    del warnings
+    # Don't `del yaml` here because yaml is actually an existing
+    # namespace member of _yaml.
+
+__name__ = '_yaml'
+# If the module is top-level (i.e. not a part of any specific package)
+# then the attribute should be set to ''.
+# https://docs.python.org/3.8/library/types.html
+__package__ = ''
diff --git a/myenv/lib/python3.9/site-packages/aaaaa_future_fstrings.pth b/myenv/lib/python3.9/site-packages/aaaaa_future_fstrings.pth
new file mode 100644
index 0000000..74682bf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/aaaaa_future_fstrings.pth
@@ -0,0 +1,2 @@
+import sys; exec('try:\n    import future_fstrings\nexcept ImportError:\n    pass\nelse:\n    future_fstrings.register()\n')
+
diff --git a/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/LICENSE
new file mode 100644
index 0000000..104eebf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Alex Grönholm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/METADATA
new file mode 100644
index 0000000..600c1fe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/METADATA
@@ -0,0 +1,102 @@
+Metadata-Version: 2.1
+Name: anyio
+Version: 3.6.1
+Summary: High level compatibility layer for multiple asynchronous event loop implementations
+Author: Alex Grönholm
+Author-email: alex.gronholm@nextday.fi
+License: MIT
+Project-URL: Documentation, https://anyio.readthedocs.io/en/latest/
+Project-URL: Source code, https://github.com/agronholm/anyio
+Project-URL: Issue tracker, https://github.com/agronholm/anyio/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Framework :: AnyIO
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.6.2
+License-File: LICENSE
+Requires-Dist: idna (>=2.8)
+Requires-Dist: sniffio (>=1.1)
+Requires-Dist: contextvars ; python_version < "3.7"
+Requires-Dist: dataclasses ; python_version < "3.7"
+Requires-Dist: typing-extensions ; python_version < "3.8"
+Provides-Extra: doc
+Requires-Dist: packaging ; extra == 'doc'
+Requires-Dist: sphinx-rtd-theme ; extra == 'doc'
+Requires-Dist: sphinx-autodoc-typehints (>=1.2.0) ; extra == 'doc'
+Provides-Extra: test
+Requires-Dist: coverage[toml] (>=4.5) ; extra == 'test'
+Requires-Dist: hypothesis (>=4.0) ; extra == 'test'
+Requires-Dist: pytest (>=7.0) ; extra == 'test'
+Requires-Dist: pytest-mock (>=3.6.1) ; extra == 'test'
+Requires-Dist: trustme ; extra == 'test'
+Requires-Dist: contextlib2 ; (python_version < "3.7") and extra == 'test'
+Requires-Dist: uvloop (<0.15) ; (python_version < "3.7" and (platform_python_implementation == "CPython" and platform_system != "Windows")) and extra == 'test'
+Requires-Dist: mock (>=4) ; (python_version < "3.8") and extra == 'test'
+Requires-Dist: uvloop (>=0.15) ; (python_version >= "3.7" and (platform_python_implementation == "CPython" and platform_system != "Windows")) and extra == 'test'
+Provides-Extra: trio
+Requires-Dist: trio (>=0.16) ; extra == 'trio'
+
+.. image:: https://github.com/agronholm/anyio/actions/workflows/test.yml/badge.svg
+  :target: https://github.com/agronholm/anyio/actions/workflows/test.yml
+  :alt: Build Status
+.. image:: https://coveralls.io/repos/github/agronholm/anyio/badge.svg?branch=master
+  :target: https://coveralls.io/github/agronholm/anyio?branch=master
+  :alt: Code Coverage
+.. image:: https://readthedocs.org/projects/anyio/badge/?version=latest
+  :target: https://anyio.readthedocs.io/en/latest/?badge=latest
+  :alt: Documentation
+.. image:: https://badges.gitter.im/gitterHQ/gitter.svg
+  :target: https://gitter.im/python-trio/AnyIO
+  :alt: Gitter chat
+
+AnyIO is an asynchronous networking and concurrency library that works on top of either asyncio_ or
+trio_. It implements trio-like `structured concurrency`_ (SC) on top of asyncio, and works in harmony
+with the native SC of trio itself.
+
+Applications and libraries written against AnyIO's API will run unmodified on either asyncio_ or
+trio_. AnyIO can also be adopted into a library or application incrementally – bit by bit, no full
+refactoring necessary. It will blend in with native libraries of your chosen backend.
+
+Documentation
+-------------
+
+View full documentation at: https://anyio.readthedocs.io/
+
+Features
+--------
+
+AnyIO offers the following functionality:
+
+* Task groups (nurseries_ in trio terminology)
+* High level networking (TCP, UDP and UNIX sockets)
+
+  * `Happy eyeballs`_ algorithm for TCP connections (more robust than that of asyncio on Python
+    3.8)
+  * async/await style UDP sockets (unlike asyncio where you still have to use Transports and
+    Protocols)
+
+* A versatile API for byte streams and object streams
+* Inter-task synchronization and communication (locks, conditions, events, semaphores, object
+  streams)
+* Worker threads
+* Subprocesses
+* Asynchronous file I/O (using worker threads)
+* Signal handling
+
+AnyIO also comes with its own pytest_ plugin which also supports asynchronous fixtures.
+It even works with the popular Hypothesis_ library.
+
+.. _asyncio: https://docs.python.org/3/library/asyncio.html
+.. _trio: https://github.com/python-trio/trio
+.. _structured concurrency: https://en.wikipedia.org/wiki/Structured_concurrency
+.. _nurseries: https://trio.readthedocs.io/en/stable/reference-core.html#nurseries-and-spawning
+.. _Happy eyeballs: https://en.wikipedia.org/wiki/Happy_Eyeballs
+.. _pytest: https://docs.pytest.org/en/latest/
+.. _Hypothesis: https://hypothesis.works/
diff --git a/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/RECORD
new file mode 100644
index 0000000..7864a5f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/RECORD
@@ -0,0 +1,45 @@
+anyio/__init__.py,sha256=M2R8dk6L5gL5lXHArzpSfEn2oH5jMyUKhzyrkRiv2AM,4037
+anyio/from_thread.py,sha256=nSq6mafYMqwxKmzdJyISg8cp-AyBj9rxZPMt_b7klSM,16497
+anyio/lowlevel.py,sha256=W4ydshns7f86YuSESFc2igTf46AWMXnGPQGsY_Esl2E,4679
+anyio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/pytest_plugin.py,sha256=kWj2B8BJehePJd1sztRBmJBRh8O4hk1oGSYQRlX5Gr8,5134
+anyio/to_process.py,sha256=hu0ES3HJC-VEjcdPJMzAzjyTaekaCNToO3coj3jvnus,9247
+anyio/to_thread.py,sha256=VeMQoo8Va2zz0WFk2p123QikDpqk2wYZGw20COC3wqw,2124
+anyio/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_backends/_asyncio.py,sha256=ZJDvRwfS4wv9WWcqWledNJyl8hx8A8-m9-gSKAJ6nBM,69238
+anyio/_backends/_trio.py,sha256=CebCaqr8Szi6uCnUzwtBRLfUitR5OnDT_wfH-KiqvBQ,29696
+anyio/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_core/_compat.py,sha256=X99W70r-O-JLdkKNtbddcIY5H2Nyg3Nk34oUYE9WZRs,5790
+anyio/_core/_eventloop.py,sha256=DRn_hy679LtsJFsPX7dXjDv72bLtSFkTnWY9WVVfgCQ,4108
+anyio/_core/_exceptions.py,sha256=1wqraNldZroYkoyB0HZStAruz_7yDCBaW-4zYwsKj8s,2904
+anyio/_core/_fileio.py,sha256=au82uZXZX4fia8EoZq_E-JDwZFKe6ZtI0J6IkxK8FmQ,18298
+anyio/_core/_resources.py,sha256=M_uN-90N8eSsWuvo-0xluWU_OG2BTyccAgsQ7XtHxzs,399
+anyio/_core/_signals.py,sha256=D4btJN527tAADspKBeNKaCds-ZcEZJP8LWM_MjVuQRA,827
+anyio/_core/_sockets.py,sha256=fW_Cbg6kfw4xgYuVuWbcWrAYspOcDSEjwxVATMzf2fo,19820
+anyio/_core/_streams.py,sha256=gjT5xChJ1OoV8nNinljSv1yW4nqUS-QzZzIydQz3exQ,1494
+anyio/_core/_subprocesses.py,sha256=pcchMI2OII0QSjiVxRiTEz4M0B7TlQPzGurfCuka-xc,5049
+anyio/_core/_synchronization.py,sha256=xOOG4hF9783N6E2IcD3YKiukguA5bPrj6BodDsKNaJY,16822
+anyio/_core/_tasks.py,sha256=ebGLjHvwL6I9aGyPwvCig1drebSVYFzvY3pnN3TsB4o,5273
+anyio/_core/_testing.py,sha256=VZka_yebIhJ6mJ6Vo_ilO3Nbz53ieqg0WBijwciMwdY,2196
+anyio/_core/_typedattr.py,sha256=k5-wBvMlDlKHIpn18INVnXAlGwI3CrAvPmWoceHjnOQ,2534
+anyio/abc/__init__.py,sha256=hMa47CMs5O1twC2bBcSbzwX-3Q08BAgAPTRekQobb3E,2123
+anyio/abc/_resources.py,sha256=js737mWPG6IW0fH8W4Tz9eNWLztse7dKxEC61z934Vk,752
+anyio/abc/_sockets.py,sha256=i1VdcJTLAuRlYeZoL6s5RBSWbX62Cu6ln5YZBL2YrWk,5754
+anyio/abc/_streams.py,sha256=0g70fhKAzbnK0KKmWwRgwmKdApBwduAcVj4TpjSzjzU,6501
+anyio/abc/_subprocesses.py,sha256=iREP_YQ91it88lDU4XIcI3HZ9HUvV5UmjQk_sSPonrw,2071
+anyio/abc/_tasks.py,sha256=mQQd1DANqpySKyehVVPdMfi_UEG49zZUJpt5blunOjg,3119
+anyio/abc/_testing.py,sha256=ifKCUPzcQdHAEGO-weu2GQvzjMQPPIWO24mQ0z6zkdU,1928
+anyio/streams/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/streams/buffered.py,sha256=FegOSO4Xcxa5SaDfU1A3ZkTTxaPrv6G435Y_giZ8k44,4437
+anyio/streams/file.py,sha256=pujJ-m6BX-gOLnVoZwkE5kh-YDs5Vx9eJFVkvliQ0S4,4353
+anyio/streams/memory.py,sha256=3RGeZoevoGIgBWfD2_X1cqxIPOz-BqQkRf6lUcOnBYc,9209
+anyio/streams/stapled.py,sha256=0E0V15v8M5GVelpHe5RT0S33tQ9hGe4ZCXo_KJEjtt4,4258
+anyio/streams/text.py,sha256=WRFyjsRpBjQKdCmR4ZuzYTEAJqGx2s5oTJmGI1C6Ng0,5014
+anyio/streams/tls.py,sha256=-WXGsMV14XHXAxc38WpBvGusjuY7e449g4UCEHIlnWw,12040
+anyio-3.6.1.dist-info/LICENSE,sha256=U2GsncWPLvX9LpsJxoKXwX8ElQkJu8gCO9uC6s8iwrA,1081
+anyio-3.6.1.dist-info/METADATA,sha256=cXu3CLppFqT_rBl4Eo2HOb0J1zm6Ltu_tMFuzjuQnew,4654
+anyio-3.6.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+anyio-3.6.1.dist-info/entry_points.txt,sha256=_d6Yu6uiaZmNe0CydowirE9Cmg7zUL2g08tQpoS3Qvc,39
+anyio-3.6.1.dist-info/top_level.txt,sha256=QglSMiWX8_5dpoVAEIHdEYzvqFMdSYWmCj6tYw2ITkQ,6
+anyio-3.6.1.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+anyio-3.6.1.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/WHEEL
new file mode 100644
index 0000000..becc9a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/entry_points.txt
new file mode 100644
index 0000000..44dd9bd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[pytest11]
+anyio = anyio.pytest_plugin
diff --git a/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/top_level.txt
new file mode 100644
index 0000000..c77c069
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio-3.6.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+anyio
diff --git a/myenv/lib/python3.9/site-packages/anyio/__init__.py b/myenv/lib/python3.9/site-packages/anyio/__init__.py
new file mode 100644
index 0000000..6e81178
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/__init__.py
@@ -0,0 +1,167 @@
+__all__ = (
+    "maybe_async",
+    "maybe_async_cm",
+    "run",
+    "sleep",
+    "sleep_forever",
+    "sleep_until",
+    "current_time",
+    "get_all_backends",
+    "get_cancelled_exc_class",
+    "BrokenResourceError",
+    "BrokenWorkerProcess",
+    "BusyResourceError",
+    "ClosedResourceError",
+    "DelimiterNotFound",
+    "EndOfStream",
+    "ExceptionGroup",
+    "IncompleteRead",
+    "TypedAttributeLookupError",
+    "WouldBlock",
+    "AsyncFile",
+    "Path",
+    "open_file",
+    "wrap_file",
+    "aclose_forcefully",
+    "open_signal_receiver",
+    "connect_tcp",
+    "connect_unix",
+    "create_tcp_listener",
+    "create_unix_listener",
+    "create_udp_socket",
+    "create_connected_udp_socket",
+    "getaddrinfo",
+    "getnameinfo",
+    "wait_socket_readable",
+    "wait_socket_writable",
+    "create_memory_object_stream",
+    "run_process",
+    "open_process",
+    "create_lock",
+    "CapacityLimiter",
+    "CapacityLimiterStatistics",
+    "Condition",
+    "ConditionStatistics",
+    "Event",
+    "EventStatistics",
+    "Lock",
+    "LockStatistics",
+    "Semaphore",
+    "SemaphoreStatistics",
+    "create_condition",
+    "create_event",
+    "create_semaphore",
+    "create_capacity_limiter",
+    "open_cancel_scope",
+    "fail_after",
+    "move_on_after",
+    "current_effective_deadline",
+    "TASK_STATUS_IGNORED",
+    "CancelScope",
+    "create_task_group",
+    "TaskInfo",
+    "get_current_task",
+    "get_running_tasks",
+    "wait_all_tasks_blocked",
+    "run_sync_in_worker_thread",
+    "run_async_from_thread",
+    "run_sync_from_thread",
+    "current_default_worker_thread_limiter",
+    "create_blocking_portal",
+    "start_blocking_portal",
+    "typed_attribute",
+    "TypedAttributeSet",
+    "TypedAttributeProvider",
+)
+
+from typing import Any
+
+from ._core._compat import maybe_async, maybe_async_cm
+from ._core._eventloop import (
+    current_time,
+    get_all_backends,
+    get_cancelled_exc_class,
+    run,
+    sleep,
+    sleep_forever,
+    sleep_until,
+)
+from ._core._exceptions import (
+    BrokenResourceError,
+    BrokenWorkerProcess,
+    BusyResourceError,
+    ClosedResourceError,
+    DelimiterNotFound,
+    EndOfStream,
+    ExceptionGroup,
+    IncompleteRead,
+    TypedAttributeLookupError,
+    WouldBlock,
+)
+from ._core._fileio import AsyncFile, Path, open_file, wrap_file
+from ._core._resources import aclose_forcefully
+from ._core._signals import open_signal_receiver
+from ._core._sockets import (
+    connect_tcp,
+    connect_unix,
+    create_connected_udp_socket,
+    create_tcp_listener,
+    create_udp_socket,
+    create_unix_listener,
+    getaddrinfo,
+    getnameinfo,
+    wait_socket_readable,
+    wait_socket_writable,
+)
+from ._core._streams import create_memory_object_stream
+from ._core._subprocesses import open_process, run_process
+from ._core._synchronization import (
+    CapacityLimiter,
+    CapacityLimiterStatistics,
+    Condition,
+    ConditionStatistics,
+    Event,
+    EventStatistics,
+    Lock,
+    LockStatistics,
+    Semaphore,
+    SemaphoreStatistics,
+    create_capacity_limiter,
+    create_condition,
+    create_event,
+    create_lock,
+    create_semaphore,
+)
+from ._core._tasks import (
+    TASK_STATUS_IGNORED,
+    CancelScope,
+    create_task_group,
+    current_effective_deadline,
+    fail_after,
+    move_on_after,
+    open_cancel_scope,
+)
+from ._core._testing import (
+    TaskInfo,
+    get_current_task,
+    get_running_tasks,
+    wait_all_tasks_blocked,
+)
+from ._core._typedattr import TypedAttributeProvider, TypedAttributeSet, typed_attribute
+
+# Re-exported here, for backwards compatibility
+# isort: off
+from .to_thread import current_default_worker_thread_limiter, run_sync_in_worker_thread
+from .from_thread import (
+    create_blocking_portal,
+    run_async_from_thread,
+    run_sync_from_thread,
+    start_blocking_portal,
+)
+
+# Re-export imports so they look like they live directly in this package
+key: str
+value: Any
+for key, value in list(locals().items()):
+    if getattr(value, "__module__", "").startswith("anyio."):
+        value.__module__ = __name__
diff --git a/myenv/lib/python3.9/site-packages/anyio/_backends/__init__.py b/myenv/lib/python3.9/site-packages/anyio/_backends/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/anyio/_backends/_asyncio.py b/myenv/lib/python3.9/site-packages/anyio/_backends/_asyncio.py
new file mode 100644
index 0000000..d2bbc94
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_backends/_asyncio.py
@@ -0,0 +1,2181 @@
+import array
+import asyncio
+import concurrent.futures
+import math
+import socket
+import sys
+from asyncio.base_events import _run_until_complete_cb  # type: ignore[attr-defined]
+from collections import OrderedDict, deque
+from concurrent.futures import Future
+from contextvars import Context, copy_context
+from dataclasses import dataclass
+from functools import partial, wraps
+from inspect import (
+    CORO_RUNNING,
+    CORO_SUSPENDED,
+    GEN_RUNNING,
+    GEN_SUSPENDED,
+    getcoroutinestate,
+    getgeneratorstate,
+)
+from io import IOBase
+from os import PathLike
+from queue import Queue
+from socket import AddressFamily, SocketKind
+from threading import Thread
+from types import TracebackType
+from typing import (
+    IO,
+    Any,
+    AsyncGenerator,
+    Awaitable,
+    Callable,
+    Collection,
+    Coroutine,
+    Deque,
+    Dict,
+    Generator,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+from weakref import WeakKeyDictionary
+
+import sniffio
+
+from .. import CapacityLimiterStatistics, EventStatistics, TaskInfo, abc
+from .._core._compat import DeprecatedAsyncContextManager, DeprecatedAwaitable
+from .._core._eventloop import claim_worker_thread, threadlocals
+from .._core._exceptions import (
+    BrokenResourceError,
+    BusyResourceError,
+    ClosedResourceError,
+    EndOfStream,
+)
+from .._core._exceptions import ExceptionGroup as BaseExceptionGroup
+from .._core._exceptions import WouldBlock
+from .._core._sockets import GetAddrInfoReturnType, convert_ipv6_sockaddr
+from .._core._synchronization import CapacityLimiter as BaseCapacityLimiter
+from .._core._synchronization import Event as BaseEvent
+from .._core._synchronization import ResourceGuard
+from .._core._tasks import CancelScope as BaseCancelScope
+from ..abc import IPSockAddrType, UDPPacketType
+from ..lowlevel import RunVar
+
+if sys.version_info >= (3, 8):
+
+    def get_coro(task: asyncio.Task) -> Union[Generator, Awaitable[Any]]:
+        return task.get_coro()
+
+else:
+
+    def get_coro(task: asyncio.Task) -> Union[Generator, Awaitable[Any]]:
+        return task._coro
+
+
+if sys.version_info >= (3, 7):
+    from asyncio import all_tasks, create_task, current_task, get_running_loop
+    from asyncio import run as native_run
+
+    def _get_task_callbacks(task: asyncio.Task) -> Iterable[Callable]:
+        return [cb for cb, context in task._callbacks]  # type: ignore[attr-defined]
+
+else:
+    _T = TypeVar("_T")
+
+    def _get_task_callbacks(task: asyncio.Task) -> Iterable[Callable]:
+        return task._callbacks
+
+    def native_run(main, *, debug=False):
+        # Snatched from Python 3.7
+        from asyncio import coroutines, events, tasks
+
+        def _cancel_all_tasks(loop):
+            to_cancel = all_tasks(loop)
+            if not to_cancel:
+                return
+
+            for task in to_cancel:
+                task.cancel()
+
+            loop.run_until_complete(
+                tasks.gather(*to_cancel, loop=loop, return_exceptions=True)
+            )
+
+            for task in to_cancel:
+                if task.cancelled():
+                    continue
+                if task.exception() is not None:
+                    loop.call_exception_handler(
+                        {
+                            "message": "unhandled exception during asyncio.run() shutdown",
+                            "exception": task.exception(),
+                            "task": task,
+                        }
+                    )
+
+        if events._get_running_loop() is not None:
+            raise RuntimeError(
+                "asyncio.run() cannot be called from a running event loop"
+            )
+
+        if not coroutines.iscoroutine(main):
+            raise ValueError(f"a coroutine was expected, got {main!r}")
+
+        loop = events.new_event_loop()
+        try:
+            events.set_event_loop(loop)
+            loop.set_debug(debug)
+            return loop.run_until_complete(main)
+        finally:
+            try:
+                _cancel_all_tasks(loop)
+                loop.run_until_complete(loop.shutdown_asyncgens())
+            finally:
+                events.set_event_loop(None)
+                loop.close()
+
+    def create_task(
+        coro: Union[Generator[Any, None, _T], Awaitable[_T]], *, name: object = None
+    ) -> asyncio.Task:
+        return get_running_loop().create_task(coro)
+
+    def get_running_loop() -> asyncio.AbstractEventLoop:
+        loop = asyncio._get_running_loop()
+        if loop is not None:
+            return loop
+        else:
+            raise RuntimeError("no running event loop")
+
+    def all_tasks(
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+    ) -> Set[asyncio.Task]:
+        """Return a set of all tasks for the loop."""
+        from asyncio import Task
+
+        if loop is None:
+            loop = get_running_loop()
+
+        return {t for t in Task.all_tasks(loop) if not t.done()}
+
+    def current_task(
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+    ) -> Optional[asyncio.Task]:
+        if loop is None:
+            loop = get_running_loop()
+
+        return asyncio.Task.current_task(loop)
+
+
+T_Retval = TypeVar("T_Retval")
+
+# Check whether there is native support for task names in asyncio (3.8+)
+_native_task_names = hasattr(asyncio.Task, "get_name")
+
+
+_root_task: RunVar[Optional[asyncio.Task]] = RunVar("_root_task")
+
+
+def find_root_task() -> asyncio.Task:
+    root_task = _root_task.get(None)
+    if root_task is not None and not root_task.done():
+        return root_task
+
+    # Look for a task that has been started via run_until_complete()
+    for task in all_tasks():
+        if task._callbacks and not task.done():
+            for cb in _get_task_callbacks(task):
+                if (
+                    cb is _run_until_complete_cb
+                    or getattr(cb, "__module__", None) == "uvloop.loop"
+                ):
+                    _root_task.set(task)
+                    return task
+
+    # Look up the topmost task in the AnyIO task tree, if possible
+    task = cast(asyncio.Task, current_task())
+    state = _task_states.get(task)
+    if state:
+        cancel_scope = state.cancel_scope
+        while cancel_scope and cancel_scope._parent_scope is not None:
+            cancel_scope = cancel_scope._parent_scope
+
+        if cancel_scope is not None:
+            return cast(asyncio.Task, cancel_scope._host_task)
+
+    return task
+
+
+def get_callable_name(func: Callable) -> str:
+    module = getattr(func, "__module__", None)
+    qualname = getattr(func, "__qualname__", None)
+    return ".".join([x for x in (module, qualname) if x])
+
+
+#
+# Event loop
+#
+
+_run_vars = (
+    WeakKeyDictionary()
+)  # type: WeakKeyDictionary[asyncio.AbstractEventLoop, Any]
+
+current_token = get_running_loop
+
+
+def _task_started(task: asyncio.Task) -> bool:
+    """Return ``True`` if the task has been started and has not finished."""
+    coro = cast(Coroutine[Any, Any, Any], get_coro(task))
+    try:
+        return getcoroutinestate(coro) in (CORO_RUNNING, CORO_SUSPENDED)
+    except AttributeError:
+        try:
+            return getgeneratorstate(cast(Generator, coro)) in (
+                GEN_RUNNING,
+                GEN_SUSPENDED,
+            )
+        except AttributeError:
+            # task coro is async_genenerator_asend https://bugs.python.org/issue37771
+            raise Exception(f"Cannot determine if task {task} has started or not")
+
+
+def _maybe_set_event_loop_policy(
+    policy: Optional[asyncio.AbstractEventLoopPolicy], use_uvloop: bool
+) -> None:
+    # On CPython, use uvloop when possible if no other policy has been given and if not
+    # explicitly disabled
+    if policy is None and use_uvloop and sys.implementation.name == "cpython":
+        try:
+            import uvloop
+        except ImportError:
+            pass
+        else:
+            # Test for missing shutdown_default_executor() (uvloop 0.14.0 and earlier)
+            if not hasattr(
+                asyncio.AbstractEventLoop, "shutdown_default_executor"
+            ) or hasattr(uvloop.loop.Loop, "shutdown_default_executor"):
+                policy = uvloop.EventLoopPolicy()
+
+    if policy is not None:
+        asyncio.set_event_loop_policy(policy)
+
+
+def run(
+    func: Callable[..., Awaitable[T_Retval]],
+    *args: object,
+    debug: bool = False,
+    use_uvloop: bool = False,
+    policy: Optional[asyncio.AbstractEventLoopPolicy] = None,
+) -> T_Retval:
+    @wraps(func)
+    async def wrapper() -> T_Retval:
+        task = cast(asyncio.Task, current_task())
+        task_state = TaskState(None, get_callable_name(func), None)
+        _task_states[task] = task_state
+        if _native_task_names:
+            task.set_name(task_state.name)
+
+        try:
+            return await func(*args)
+        finally:
+            del _task_states[task]
+
+    _maybe_set_event_loop_policy(policy, use_uvloop)
+    return native_run(wrapper(), debug=debug)
+
+
+#
+# Miscellaneous
+#
+
+sleep = asyncio.sleep
+
+
+#
+# Timeouts and cancellation
+#
+
+CancelledError = asyncio.CancelledError
+
+
+class CancelScope(BaseCancelScope):
+    def __new__(
+        cls, *, deadline: float = math.inf, shield: bool = False
+    ) -> "CancelScope":
+        return object.__new__(cls)
+
+    def __init__(self, deadline: float = math.inf, shield: bool = False):
+        self._deadline = deadline
+        self._shield = shield
+        self._parent_scope: Optional[CancelScope] = None
+        self._cancel_called = False
+        self._active = False
+        self._timeout_handle: Optional[asyncio.TimerHandle] = None
+        self._cancel_handle: Optional[asyncio.Handle] = None
+        self._tasks: Set[asyncio.Task] = set()
+        self._host_task: Optional[asyncio.Task] = None
+        self._timeout_expired = False
+
+    def __enter__(self) -> "CancelScope":
+        if self._active:
+            raise RuntimeError(
+                "Each CancelScope may only be used for a single 'with' block"
+            )
+
+        self._host_task = host_task = cast(asyncio.Task, current_task())
+        self._tasks.add(host_task)
+        try:
+            task_state = _task_states[host_task]
+        except KeyError:
+            task_name = host_task.get_name() if _native_task_names else None
+            task_state = TaskState(None, task_name, self)
+            _task_states[host_task] = task_state
+        else:
+            self._parent_scope = task_state.cancel_scope
+            task_state.cancel_scope = self
+
+        self._timeout()
+        self._active = True
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        if not self._active:
+            raise RuntimeError("This cancel scope is not active")
+        if current_task() is not self._host_task:
+            raise RuntimeError(
+                "Attempted to exit cancel scope in a different task than it was "
+                "entered in"
+            )
+
+        assert self._host_task is not None
+        host_task_state = _task_states.get(self._host_task)
+        if host_task_state is None or host_task_state.cancel_scope is not self:
+            raise RuntimeError(
+                "Attempted to exit a cancel scope that isn't the current tasks's "
+                "current cancel scope"
+            )
+
+        self._active = False
+        if self._timeout_handle:
+            self._timeout_handle.cancel()
+            self._timeout_handle = None
+
+        self._tasks.remove(self._host_task)
+
+        host_task_state.cancel_scope = self._parent_scope
+
+        # Restart the cancellation effort in the farthest directly cancelled parent scope if this
+        # one was shielded
+        if self._shield:
+            self._deliver_cancellation_to_parent()
+
+        if exc_val is not None:
+            exceptions = (
+                exc_val.exceptions if isinstance(exc_val, ExceptionGroup) else [exc_val]
+            )
+            if all(isinstance(exc, CancelledError) for exc in exceptions):
+                if self._timeout_expired:
+                    return True
+                elif not self._cancel_called:
+                    # Task was cancelled natively
+                    return None
+                elif not self._parent_cancelled():
+                    # This scope was directly cancelled
+                    return True
+
+        return None
+
+    def _timeout(self) -> None:
+        if self._deadline != math.inf:
+            loop = get_running_loop()
+            if loop.time() >= self._deadline:
+                self._timeout_expired = True
+                self.cancel()
+            else:
+                self._timeout_handle = loop.call_at(self._deadline, self._timeout)
+
+    def _deliver_cancellation(self) -> None:
+        """
+        Deliver cancellation to directly contained tasks and nested cancel scopes.
+
+        Schedule another run at the end if we still have tasks eligible for cancellation.
+        """
+        should_retry = False
+        current = current_task()
+        for task in self._tasks:
+            if task._must_cancel:  # type: ignore[attr-defined]
+                continue
+
+            # The task is eligible for cancellation if it has started and is not in a cancel
+            # scope shielded from this one
+            cancel_scope = _task_states[task].cancel_scope
+            while cancel_scope is not self:
+                if cancel_scope is None or cancel_scope._shield:
+                    break
+                else:
+                    cancel_scope = cancel_scope._parent_scope
+            else:
+                should_retry = True
+                if task is not current and (
+                    task is self._host_task or _task_started(task)
+                ):
+                    task.cancel()
+
+        # Schedule another callback if there are still tasks left
+        if should_retry:
+            self._cancel_handle = get_running_loop().call_soon(
+                self._deliver_cancellation
+            )
+        else:
+            self._cancel_handle = None
+
+    def _deliver_cancellation_to_parent(self) -> None:
+        """Start cancellation effort in the farthest directly cancelled parent scope"""
+        scope = self._parent_scope
+        scope_to_cancel: Optional[CancelScope] = None
+        while scope is not None:
+            if scope._cancel_called and scope._cancel_handle is None:
+                scope_to_cancel = scope
+
+            # No point in looking beyond any shielded scope
+            if scope._shield:
+                break
+
+            scope = scope._parent_scope
+
+        if scope_to_cancel is not None:
+            scope_to_cancel._deliver_cancellation()
+
+    def _parent_cancelled(self) -> bool:
+        # Check whether any parent has been cancelled
+        cancel_scope = self._parent_scope
+        while cancel_scope is not None and not cancel_scope._shield:
+            if cancel_scope._cancel_called:
+                return True
+            else:
+                cancel_scope = cancel_scope._parent_scope
+
+        return False
+
+    def cancel(self) -> DeprecatedAwaitable:
+        if not self._cancel_called:
+            if self._timeout_handle:
+                self._timeout_handle.cancel()
+                self._timeout_handle = None
+
+            self._cancel_called = True
+            self._deliver_cancellation()
+
+        return DeprecatedAwaitable(self.cancel)
+
+    @property
+    def deadline(self) -> float:
+        return self._deadline
+
+    @deadline.setter
+    def deadline(self, value: float) -> None:
+        self._deadline = float(value)
+        if self._timeout_handle is not None:
+            self._timeout_handle.cancel()
+            self._timeout_handle = None
+
+        if self._active and not self._cancel_called:
+            self._timeout()
+
+    @property
+    def cancel_called(self) -> bool:
+        return self._cancel_called
+
+    @property
+    def shield(self) -> bool:
+        return self._shield
+
+    @shield.setter
+    def shield(self, value: bool) -> None:
+        if self._shield != value:
+            self._shield = value
+            if not value:
+                self._deliver_cancellation_to_parent()
+
+
+async def checkpoint() -> None:
+    await sleep(0)
+
+
+async def checkpoint_if_cancelled() -> None:
+    task = current_task()
+    if task is None:
+        return
+
+    try:
+        cancel_scope = _task_states[task].cancel_scope
+    except KeyError:
+        return
+
+    while cancel_scope:
+        if cancel_scope.cancel_called:
+            await sleep(0)
+        elif cancel_scope.shield:
+            break
+        else:
+            cancel_scope = cancel_scope._parent_scope
+
+
+async def cancel_shielded_checkpoint() -> None:
+    with CancelScope(shield=True):
+        await sleep(0)
+
+
+def current_effective_deadline() -> float:
+    try:
+        cancel_scope = _task_states[current_task()].cancel_scope  # type: ignore[index]
+    except KeyError:
+        return math.inf
+
+    deadline = math.inf
+    while cancel_scope:
+        deadline = min(deadline, cancel_scope.deadline)
+        if cancel_scope.shield:
+            break
+        else:
+            cancel_scope = cancel_scope._parent_scope
+
+    return deadline
+
+
+def current_time() -> float:
+    return get_running_loop().time()
+
+
+#
+# Task states
+#
+
+
+class TaskState:
+    """
+    Encapsulates auxiliary task information that cannot be added to the Task instance itself
+    because there are no guarantees about its implementation.
+    """
+
+    __slots__ = "parent_id", "name", "cancel_scope"
+
+    def __init__(
+        self,
+        parent_id: Optional[int],
+        name: Optional[str],
+        cancel_scope: Optional[CancelScope],
+    ):
+        self.parent_id = parent_id
+        self.name = name
+        self.cancel_scope = cancel_scope
+
+
+_task_states = WeakKeyDictionary()  # type: WeakKeyDictionary[asyncio.Task, TaskState]
+
+
+#
+# Task groups
+#
+
+
+class ExceptionGroup(BaseExceptionGroup):
+    def __init__(self, exceptions: List[BaseException]):
+        super().__init__()
+        self.exceptions = exceptions
+
+
+class _AsyncioTaskStatus(abc.TaskStatus):
+    def __init__(self, future: asyncio.Future, parent_id: int):
+        self._future = future
+        self._parent_id = parent_id
+
+    def started(self, value: object = None) -> None:
+        try:
+            self._future.set_result(value)
+        except asyncio.InvalidStateError:
+            raise RuntimeError(
+                "called 'started' twice on the same task status"
+            ) from None
+
+        task = cast(asyncio.Task, current_task())
+        _task_states[task].parent_id = self._parent_id
+
+
+class TaskGroup(abc.TaskGroup):
+    def __init__(self) -> None:
+        self.cancel_scope: CancelScope = CancelScope()
+        self._active = False
+        self._exceptions: List[BaseException] = []
+
+    async def __aenter__(self) -> "TaskGroup":
+        self.cancel_scope.__enter__()
+        self._active = True
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        ignore_exception = self.cancel_scope.__exit__(exc_type, exc_val, exc_tb)
+        if exc_val is not None:
+            self.cancel_scope.cancel()
+            self._exceptions.append(exc_val)
+
+        while self.cancel_scope._tasks:
+            try:
+                await asyncio.wait(self.cancel_scope._tasks)
+            except asyncio.CancelledError:
+                self.cancel_scope.cancel()
+
+        self._active = False
+        if not self.cancel_scope._parent_cancelled():
+            exceptions = self._filter_cancellation_errors(self._exceptions)
+        else:
+            exceptions = self._exceptions
+
+        try:
+            if len(exceptions) > 1:
+                if all(
+                    isinstance(e, CancelledError) and not e.args for e in exceptions
+                ):
+                    # Tasks were cancelled natively, without a cancellation message
+                    raise CancelledError
+                else:
+                    raise ExceptionGroup(exceptions)
+            elif exceptions and exceptions[0] is not exc_val:
+                raise exceptions[0]
+        except BaseException as exc:
+            # Clear the context here, as it can only be done in-flight.
+            # If the context is not cleared, it can result in recursive tracebacks (see #145).
+            exc.__context__ = None
+            raise
+
+        return ignore_exception
+
+    @staticmethod
+    def _filter_cancellation_errors(
+        exceptions: Sequence[BaseException],
+    ) -> List[BaseException]:
+        filtered_exceptions: List[BaseException] = []
+        for exc in exceptions:
+            if isinstance(exc, ExceptionGroup):
+                new_exceptions = TaskGroup._filter_cancellation_errors(exc.exceptions)
+                if len(new_exceptions) > 1:
+                    filtered_exceptions.append(exc)
+                elif len(new_exceptions) == 1:
+                    filtered_exceptions.append(new_exceptions[0])
+                elif new_exceptions:
+                    new_exc = ExceptionGroup(new_exceptions)
+                    new_exc.__cause__ = exc.__cause__
+                    new_exc.__context__ = exc.__context__
+                    new_exc.__traceback__ = exc.__traceback__
+                    filtered_exceptions.append(new_exc)
+            elif not isinstance(exc, CancelledError) or exc.args:
+                filtered_exceptions.append(exc)
+
+        return filtered_exceptions
+
+    async def _run_wrapped_task(
+        self, coro: Coroutine, task_status_future: Optional[asyncio.Future]
+    ) -> None:
+        # This is the code path for Python 3.6 and 3.7 on which asyncio freaks out if a task raises
+        # a BaseException.
+        __traceback_hide__ = __tracebackhide__ = True  # noqa: F841
+        task = cast(asyncio.Task, current_task())
+        try:
+            await coro
+        except BaseException as exc:
+            if task_status_future is None or task_status_future.done():
+                self._exceptions.append(exc)
+                self.cancel_scope.cancel()
+            else:
+                task_status_future.set_exception(exc)
+        else:
+            if task_status_future is not None and not task_status_future.done():
+                task_status_future.set_exception(
+                    RuntimeError("Child exited without calling task_status.started()")
+                )
+        finally:
+            if task in self.cancel_scope._tasks:
+                self.cancel_scope._tasks.remove(task)
+                del _task_states[task]
+
+    def _spawn(
+        self,
+        func: Callable[..., Coroutine],
+        args: tuple,
+        name: object,
+        task_status_future: Optional[asyncio.Future] = None,
+    ) -> asyncio.Task:
+        def task_done(_task: asyncio.Task) -> None:
+            # This is the code path for Python 3.8+
+            assert _task in self.cancel_scope._tasks
+            self.cancel_scope._tasks.remove(_task)
+            del _task_states[_task]
+
+            try:
+                exc = _task.exception()
+            except CancelledError as e:
+                while isinstance(e.__context__, CancelledError):
+                    e = e.__context__
+
+                exc = e
+
+            if exc is not None:
+                if task_status_future is None or task_status_future.done():
+                    self._exceptions.append(exc)
+                    self.cancel_scope.cancel()
+                else:
+                    task_status_future.set_exception(exc)
+            elif task_status_future is not None and not task_status_future.done():
+                task_status_future.set_exception(
+                    RuntimeError("Child exited without calling task_status.started()")
+                )
+
+        if not self._active:
+            raise RuntimeError(
+                "This task group is not active; no new tasks can be started."
+            )
+
+        options = {}
+        name = get_callable_name(func) if name is None else str(name)
+        if _native_task_names:
+            options["name"] = name
+
+        kwargs = {}
+        if task_status_future:
+            parent_id = id(current_task())
+            kwargs["task_status"] = _AsyncioTaskStatus(
+                task_status_future, id(self.cancel_scope._host_task)
+            )
+        else:
+            parent_id = id(self.cancel_scope._host_task)
+
+        coro = func(*args, **kwargs)
+        if not asyncio.iscoroutine(coro):
+            raise TypeError(
+                f"Expected an async function, but {func} appears to be synchronous"
+            )
+
+        foreign_coro = not hasattr(coro, "cr_frame") and not hasattr(coro, "gi_frame")
+        if foreign_coro or sys.version_info < (3, 8):
+            coro = self._run_wrapped_task(coro, task_status_future)
+
+        task = create_task(coro, **options)
+        if not foreign_coro and sys.version_info >= (3, 8):
+            task.add_done_callback(task_done)
+
+        # Make the spawned task inherit the task group's cancel scope
+        _task_states[task] = TaskState(
+            parent_id=parent_id, name=name, cancel_scope=self.cancel_scope
+        )
+        self.cancel_scope._tasks.add(task)
+        return task
+
+    def start_soon(
+        self, func: Callable[..., Coroutine], *args: object, name: object = None
+    ) -> None:
+        self._spawn(func, args, name)
+
+    async def start(
+        self, func: Callable[..., Coroutine], *args: object, name: object = None
+    ) -> None:
+        future: asyncio.Future = asyncio.Future()
+        task = self._spawn(func, args, name, future)
+
+        # If the task raises an exception after sending a start value without a switch point
+        # between, the task group is cancelled and this method never proceeds to process the
+        # completed future. That's why we have to have a shielded cancel scope here.
+        with CancelScope(shield=True):
+            try:
+                return await future
+            except CancelledError:
+                task.cancel()
+                raise
+
+
+#
+# Threads
+#
+
+_Retval_Queue_Type = Tuple[Optional[T_Retval], Optional[BaseException]]
+
+
+class WorkerThread(Thread):
+    MAX_IDLE_TIME = 10  # seconds
+
+    def __init__(
+        self,
+        root_task: asyncio.Task,
+        workers: Set["WorkerThread"],
+        idle_workers: Deque["WorkerThread"],
+    ):
+        super().__init__(name="AnyIO worker thread")
+        self.root_task = root_task
+        self.workers = workers
+        self.idle_workers = idle_workers
+        self.loop = root_task._loop
+        self.queue: Queue[
+            Union[Tuple[Context, Callable, tuple, asyncio.Future], None]
+        ] = Queue(2)
+        self.idle_since = current_time()
+        self.stopping = False
+
+    def _report_result(
+        self, future: asyncio.Future, result: Any, exc: Optional[BaseException]
+    ) -> None:
+        self.idle_since = current_time()
+        if not self.stopping:
+            self.idle_workers.append(self)
+
+        if not future.cancelled():
+            if exc is not None:
+                future.set_exception(exc)
+            else:
+                future.set_result(result)
+
+    def run(self) -> None:
+        with claim_worker_thread("asyncio"):
+            threadlocals.loop = self.loop
+            while True:
+                item = self.queue.get()
+                if item is None:
+                    # Shutdown command received
+                    return
+
+                context, func, args, future = item
+                if not future.cancelled():
+                    result = None
+                    exception: Optional[BaseException] = None
+                    try:
+                        result = context.run(func, *args)
+                    except BaseException as exc:
+                        exception = exc
+
+                    if not self.loop.is_closed():
+                        self.loop.call_soon_threadsafe(
+                            self._report_result, future, result, exception
+                        )
+
+                self.queue.task_done()
+
+    def stop(self, f: Optional[asyncio.Task] = None) -> None:
+        self.stopping = True
+        self.queue.put_nowait(None)
+        self.workers.discard(self)
+        try:
+            self.idle_workers.remove(self)
+        except ValueError:
+            pass
+
+
+_threadpool_idle_workers: RunVar[Deque[WorkerThread]] = RunVar(
+    "_threadpool_idle_workers"
+)
+_threadpool_workers: RunVar[Set[WorkerThread]] = RunVar("_threadpool_workers")
+
+
+async def run_sync_in_worker_thread(
+    func: Callable[..., T_Retval],
+    *args: object,
+    cancellable: bool = False,
+    limiter: Optional["CapacityLimiter"] = None,
+) -> T_Retval:
+    await checkpoint()
+
+    # If this is the first run in this event loop thread, set up the necessary variables
+    try:
+        idle_workers = _threadpool_idle_workers.get()
+        workers = _threadpool_workers.get()
+    except LookupError:
+        idle_workers = deque()
+        workers = set()
+        _threadpool_idle_workers.set(idle_workers)
+        _threadpool_workers.set(workers)
+
+    async with (limiter or current_default_thread_limiter()):
+        with CancelScope(shield=not cancellable):
+            future: asyncio.Future = asyncio.Future()
+            root_task = find_root_task()
+            if not idle_workers:
+                worker = WorkerThread(root_task, workers, idle_workers)
+                worker.start()
+                workers.add(worker)
+                root_task.add_done_callback(worker.stop)
+            else:
+                worker = idle_workers.pop()
+
+                # Prune any other workers that have been idle for MAX_IDLE_TIME seconds or longer
+                now = current_time()
+                while idle_workers:
+                    if now - idle_workers[0].idle_since < WorkerThread.MAX_IDLE_TIME:
+                        break
+
+                    expired_worker = idle_workers.popleft()
+                    expired_worker.root_task.remove_done_callback(expired_worker.stop)
+                    expired_worker.stop()
+
+            context = copy_context()
+            context.run(sniffio.current_async_library_cvar.set, None)
+            worker.queue.put_nowait((context, func, args, future))
+            return await future
+
+
+def run_sync_from_thread(
+    func: Callable[..., T_Retval],
+    *args: object,
+    loop: Optional[asyncio.AbstractEventLoop] = None,
+) -> T_Retval:
+    @wraps(func)
+    def wrapper() -> None:
+        try:
+            f.set_result(func(*args))
+        except BaseException as exc:
+            f.set_exception(exc)
+            if not isinstance(exc, Exception):
+                raise
+
+    f: concurrent.futures.Future[T_Retval] = Future()
+    loop = loop or threadlocals.loop
+    if sys.version_info < (3, 7):
+        loop.call_soon_threadsafe(copy_context().run, wrapper)
+    else:
+        loop.call_soon_threadsafe(wrapper)
+
+    return f.result()
+
+
+def run_async_from_thread(
+    func: Callable[..., Coroutine[Any, Any, T_Retval]], *args: object
+) -> T_Retval:
+    f: concurrent.futures.Future[T_Retval] = asyncio.run_coroutine_threadsafe(
+        func(*args), threadlocals.loop
+    )
+    return f.result()
+
+
+class BlockingPortal(abc.BlockingPortal):
+    def __new__(cls) -> "BlockingPortal":
+        return object.__new__(cls)
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._loop = get_running_loop()
+
+    def _spawn_task_from_thread(
+        self,
+        func: Callable,
+        args: tuple,
+        kwargs: Dict[str, Any],
+        name: object,
+        future: Future,
+    ) -> None:
+        run_sync_from_thread(
+            partial(self._task_group.start_soon, name=name),
+            self._call_func,
+            func,
+            args,
+            kwargs,
+            future,
+            loop=self._loop,
+        )
+
+
+#
+# Subprocesses
+#
+
+
+@dataclass(eq=False)
+class StreamReaderWrapper(abc.ByteReceiveStream):
+    _stream: asyncio.StreamReader
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        data = await self._stream.read(max_bytes)
+        if data:
+            return data
+        else:
+            raise EndOfStream
+
+    async def aclose(self) -> None:
+        self._stream.feed_eof()
+
+
+@dataclass(eq=False)
+class StreamWriterWrapper(abc.ByteSendStream):
+    _stream: asyncio.StreamWriter
+
+    async def send(self, item: bytes) -> None:
+        self._stream.write(item)
+        await self._stream.drain()
+
+    async def aclose(self) -> None:
+        self._stream.close()
+
+
+@dataclass(eq=False)
+class Process(abc.Process):
+    _process: asyncio.subprocess.Process
+    _stdin: Optional[StreamWriterWrapper]
+    _stdout: Optional[StreamReaderWrapper]
+    _stderr: Optional[StreamReaderWrapper]
+
+    async def aclose(self) -> None:
+        if self._stdin:
+            await self._stdin.aclose()
+        if self._stdout:
+            await self._stdout.aclose()
+        if self._stderr:
+            await self._stderr.aclose()
+
+        await self.wait()
+
+    async def wait(self) -> int:
+        return await self._process.wait()
+
+    def terminate(self) -> None:
+        self._process.terminate()
+
+    def kill(self) -> None:
+        self._process.kill()
+
+    def send_signal(self, signal: int) -> None:
+        self._process.send_signal(signal)
+
+    @property
+    def pid(self) -> int:
+        return self._process.pid
+
+    @property
+    def returncode(self) -> Optional[int]:
+        return self._process.returncode
+
+    @property
+    def stdin(self) -> Optional[abc.ByteSendStream]:
+        return self._stdin
+
+    @property
+    def stdout(self) -> Optional[abc.ByteReceiveStream]:
+        return self._stdout
+
+    @property
+    def stderr(self) -> Optional[abc.ByteReceiveStream]:
+        return self._stderr
+
+
+async def open_process(
+    command: Union[str, bytes, Sequence[Union[str, bytes]]],
+    *,
+    shell: bool,
+    stdin: Union[int, IO[Any], None],
+    stdout: Union[int, IO[Any], None],
+    stderr: Union[int, IO[Any], None],
+    cwd: Union[str, bytes, PathLike, None] = None,
+    env: Optional[Mapping[str, str]] = None,
+    start_new_session: bool = False,
+) -> Process:
+    await checkpoint()
+    if shell:
+        process = await asyncio.create_subprocess_shell(
+            cast(Union[str, bytes], command),
+            stdin=stdin,
+            stdout=stdout,
+            stderr=stderr,
+            cwd=cwd,
+            env=env,
+            start_new_session=start_new_session,
+        )
+    else:
+        process = await asyncio.create_subprocess_exec(
+            *command,
+            stdin=stdin,
+            stdout=stdout,
+            stderr=stderr,
+            cwd=cwd,
+            env=env,
+            start_new_session=start_new_session,
+        )
+
+    stdin_stream = StreamWriterWrapper(process.stdin) if process.stdin else None
+    stdout_stream = StreamReaderWrapper(process.stdout) if process.stdout else None
+    stderr_stream = StreamReaderWrapper(process.stderr) if process.stderr else None
+    return Process(process, stdin_stream, stdout_stream, stderr_stream)
+
+
+def _forcibly_shutdown_process_pool_on_exit(
+    workers: Set[Process], _task: object
+) -> None:
+    """
+    Forcibly shuts down worker processes belonging to this event loop."""
+    child_watcher: Optional[asyncio.AbstractChildWatcher]
+    try:
+        child_watcher = asyncio.get_event_loop_policy().get_child_watcher()
+    except NotImplementedError:
+        child_watcher = None
+
+    # Close as much as possible (w/o async/await) to avoid warnings
+    for process in workers:
+        if process.returncode is None:
+            continue
+
+        process._stdin._stream._transport.close()  # type: ignore[union-attr]
+        process._stdout._stream._transport.close()  # type: ignore[union-attr]
+        process._stderr._stream._transport.close()  # type: ignore[union-attr]
+        process.kill()
+        if child_watcher:
+            child_watcher.remove_child_handler(process.pid)
+
+
+async def _shutdown_process_pool_on_exit(workers: Set[Process]) -> None:
+    """
+    Shuts down worker processes belonging to this event loop.
+
+    NOTE: this only works when the event loop was started using asyncio.run() or anyio.run().
+
+    """
+    process: Process
+    try:
+        await sleep(math.inf)
+    except asyncio.CancelledError:
+        for process in workers:
+            if process.returncode is None:
+                process.kill()
+
+        for process in workers:
+            await process.aclose()
+
+
+def setup_process_pool_exit_at_shutdown(workers: Set[Process]) -> None:
+    kwargs = {"name": "AnyIO process pool shutdown task"} if _native_task_names else {}
+    create_task(_shutdown_process_pool_on_exit(workers), **kwargs)
+    find_root_task().add_done_callback(
+        partial(_forcibly_shutdown_process_pool_on_exit, workers)
+    )
+
+
+#
+# Sockets and networking
+#
+
+
+class StreamProtocol(asyncio.Protocol):
+    read_queue: Deque[bytes]
+    read_event: asyncio.Event
+    write_event: asyncio.Event
+    exception: Optional[Exception] = None
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        self.read_queue = deque()
+        self.read_event = asyncio.Event()
+        self.write_event = asyncio.Event()
+        self.write_event.set()
+        cast(asyncio.Transport, transport).set_write_buffer_limits(0)
+
+    def connection_lost(self, exc: Optional[Exception]) -> None:
+        if exc:
+            self.exception = BrokenResourceError()
+            self.exception.__cause__ = exc
+
+        self.read_event.set()
+        self.write_event.set()
+
+    def data_received(self, data: bytes) -> None:
+        self.read_queue.append(data)
+        self.read_event.set()
+
+    def eof_received(self) -> Optional[bool]:
+        self.read_event.set()
+        return True
+
+    def pause_writing(self) -> None:
+        self.write_event = asyncio.Event()
+
+    def resume_writing(self) -> None:
+        self.write_event.set()
+
+
+class DatagramProtocol(asyncio.DatagramProtocol):
+    read_queue: Deque[Tuple[bytes, IPSockAddrType]]
+    read_event: asyncio.Event
+    write_event: asyncio.Event
+    exception: Optional[Exception] = None
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        self.read_queue = deque(maxlen=100)  # arbitrary value
+        self.read_event = asyncio.Event()
+        self.write_event = asyncio.Event()
+        self.write_event.set()
+
+    def connection_lost(self, exc: Optional[Exception]) -> None:
+        self.read_event.set()
+        self.write_event.set()
+
+    def datagram_received(self, data: bytes, addr: IPSockAddrType) -> None:
+        addr = convert_ipv6_sockaddr(addr)
+        self.read_queue.append((data, addr))
+        self.read_event.set()
+
+    def error_received(self, exc: Exception) -> None:
+        self.exception = exc
+
+    def pause_writing(self) -> None:
+        self.write_event.clear()
+
+    def resume_writing(self) -> None:
+        self.write_event.set()
+
+
+class SocketStream(abc.SocketStream):
+    def __init__(self, transport: asyncio.Transport, protocol: StreamProtocol):
+        self._transport = transport
+        self._protocol = protocol
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+        self._closed = False
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self._transport.get_extra_info("socket")
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        with self._receive_guard:
+            await checkpoint()
+
+            if (
+                not self._protocol.read_event.is_set()
+                and not self._transport.is_closing()
+            ):
+                self._transport.resume_reading()
+                await self._protocol.read_event.wait()
+                self._transport.pause_reading()
+
+            try:
+                chunk = self._protocol.read_queue.popleft()
+            except IndexError:
+                if self._closed:
+                    raise ClosedResourceError from None
+                elif self._protocol.exception:
+                    raise self._protocol.exception
+                else:
+                    raise EndOfStream from None
+
+            if len(chunk) > max_bytes:
+                # Split the oversized chunk
+                chunk, leftover = chunk[:max_bytes], chunk[max_bytes:]
+                self._protocol.read_queue.appendleft(leftover)
+
+            # If the read queue is empty, clear the flag so that the next call will block until
+            # data is available
+            if not self._protocol.read_queue:
+                self._protocol.read_event.clear()
+
+        return chunk
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            await checkpoint()
+
+            if self._closed:
+                raise ClosedResourceError
+            elif self._protocol.exception is not None:
+                raise self._protocol.exception
+
+            try:
+                self._transport.write(item)
+            except RuntimeError as exc:
+                if self._transport.is_closing():
+                    raise BrokenResourceError from exc
+                else:
+                    raise
+
+            await self._protocol.write_event.wait()
+
+    async def send_eof(self) -> None:
+        try:
+            self._transport.write_eof()
+        except OSError:
+            pass
+
+    async def aclose(self) -> None:
+        if not self._transport.is_closing():
+            self._closed = True
+            try:
+                self._transport.write_eof()
+            except OSError:
+                pass
+
+            self._transport.close()
+            await sleep(0)
+            self._transport.abort()
+
+
+class UNIXSocketStream(abc.SocketStream):
+    _receive_future: Optional[asyncio.Future] = None
+    _send_future: Optional[asyncio.Future] = None
+    _closing = False
+
+    def __init__(self, raw_socket: socket.socket):
+        self.__raw_socket = raw_socket
+        self._loop = get_running_loop()
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self.__raw_socket
+
+    def _wait_until_readable(self, loop: asyncio.AbstractEventLoop) -> asyncio.Future:
+        def callback(f: object) -> None:
+            del self._receive_future
+            loop.remove_reader(self.__raw_socket)
+
+        f = self._receive_future = asyncio.Future()
+        self._loop.add_reader(self.__raw_socket, f.set_result, None)
+        f.add_done_callback(callback)
+        return f
+
+    def _wait_until_writable(self, loop: asyncio.AbstractEventLoop) -> asyncio.Future:
+        def callback(f: object) -> None:
+            del self._send_future
+            loop.remove_writer(self.__raw_socket)
+
+        f = self._send_future = asyncio.Future()
+        self._loop.add_writer(self.__raw_socket, f.set_result, None)
+        f.add_done_callback(callback)
+        return f
+
+    async def send_eof(self) -> None:
+        with self._send_guard:
+            self._raw_socket.shutdown(socket.SHUT_WR)
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        loop = get_running_loop()
+        await checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    data = self.__raw_socket.recv(max_bytes)
+                except BlockingIOError:
+                    await self._wait_until_readable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    if not data:
+                        raise EndOfStream
+
+                    return data
+
+    async def send(self, item: bytes) -> None:
+        loop = get_running_loop()
+        await checkpoint()
+        with self._send_guard:
+            view = memoryview(item)
+            while view:
+                try:
+                    bytes_sent = self.__raw_socket.send(item)
+                except BlockingIOError:
+                    await self._wait_until_writable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    view = view[bytes_sent:]
+
+    async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]:
+        if not isinstance(msglen, int) or msglen < 0:
+            raise ValueError("msglen must be a non-negative integer")
+        if not isinstance(maxfds, int) or maxfds < 1:
+            raise ValueError("maxfds must be a positive integer")
+
+        loop = get_running_loop()
+        fds = array.array("i")
+        await checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    message, ancdata, flags, addr = self.__raw_socket.recvmsg(
+                        msglen, socket.CMSG_LEN(maxfds * fds.itemsize)
+                    )
+                except BlockingIOError:
+                    await self._wait_until_readable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    if not message and not ancdata:
+                        raise EndOfStream
+
+                    break
+
+        for cmsg_level, cmsg_type, cmsg_data in ancdata:
+            if cmsg_level != socket.SOL_SOCKET or cmsg_type != socket.SCM_RIGHTS:
+                raise RuntimeError(
+                    f"Received unexpected ancillary data; message = {message!r}, "
+                    f"cmsg_level = {cmsg_level}, cmsg_type = {cmsg_type}"
+                )
+
+            fds.frombytes(cmsg_data[: len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
+
+        return message, list(fds)
+
+    async def send_fds(
+        self, message: bytes, fds: Collection[Union[int, IOBase]]
+    ) -> None:
+        if not message:
+            raise ValueError("message must not be empty")
+        if not fds:
+            raise ValueError("fds must not be empty")
+
+        loop = get_running_loop()
+        filenos: List[int] = []
+        for fd in fds:
+            if isinstance(fd, int):
+                filenos.append(fd)
+            elif isinstance(fd, IOBase):
+                filenos.append(fd.fileno())
+
+        fdarray = array.array("i", filenos)
+        await checkpoint()
+        with self._send_guard:
+            while True:
+                try:
+                    # The ignore can be removed after mypy picks up
+                    # https://github.com/python/typeshed/pull/5545
+                    self.__raw_socket.sendmsg(
+                        [message], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fdarray)]
+                    )
+                    break
+                except BlockingIOError:
+                    await self._wait_until_writable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+
+    async def aclose(self) -> None:
+        if not self._closing:
+            self._closing = True
+            if self.__raw_socket.fileno() != -1:
+                self.__raw_socket.close()
+
+            if self._receive_future:
+                self._receive_future.set_result(None)
+            if self._send_future:
+                self._send_future.set_result(None)
+
+
+class TCPSocketListener(abc.SocketListener):
+    _accept_scope: Optional[CancelScope] = None
+    _closed = False
+
+    def __init__(self, raw_socket: socket.socket):
+        self.__raw_socket = raw_socket
+        self._loop = cast(asyncio.BaseEventLoop, get_running_loop())
+        self._accept_guard = ResourceGuard("accepting connections from")
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self.__raw_socket
+
+    async def accept(self) -> abc.SocketStream:
+        if self._closed:
+            raise ClosedResourceError
+
+        with self._accept_guard:
+            await checkpoint()
+            with CancelScope() as self._accept_scope:
+                try:
+                    client_sock, _addr = await self._loop.sock_accept(self._raw_socket)
+                except asyncio.CancelledError:
+                    # Workaround for https://bugs.python.org/issue41317
+                    try:
+                        self._loop.remove_reader(self._raw_socket)
+                    except (ValueError, NotImplementedError):
+                        pass
+
+                    if self._closed:
+                        raise ClosedResourceError from None
+
+                    raise
+                finally:
+                    self._accept_scope = None
+
+        client_sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        transport, protocol = await self._loop.connect_accepted_socket(
+            StreamProtocol, client_sock
+        )
+        return SocketStream(cast(asyncio.Transport, transport), protocol)
+
+    async def aclose(self) -> None:
+        if self._closed:
+            return
+
+        self._closed = True
+        if self._accept_scope:
+            # Workaround for https://bugs.python.org/issue41317
+            try:
+                self._loop.remove_reader(self._raw_socket)
+            except (ValueError, NotImplementedError):
+                pass
+
+            self._accept_scope.cancel()
+            await sleep(0)
+
+        self._raw_socket.close()
+
+
+class UNIXSocketListener(abc.SocketListener):
+    def __init__(self, raw_socket: socket.socket):
+        self.__raw_socket = raw_socket
+        self._loop = get_running_loop()
+        self._accept_guard = ResourceGuard("accepting connections from")
+        self._closed = False
+
+    async def accept(self) -> abc.SocketStream:
+        await checkpoint()
+        with self._accept_guard:
+            while True:
+                try:
+                    client_sock, _ = self.__raw_socket.accept()
+                    client_sock.setblocking(False)
+                    return UNIXSocketStream(client_sock)
+                except BlockingIOError:
+                    f: asyncio.Future = asyncio.Future()
+                    self._loop.add_reader(self.__raw_socket, f.set_result, None)
+                    f.add_done_callback(
+                        lambda _: self._loop.remove_reader(self.__raw_socket)
+                    )
+                    await f
+                except OSError as exc:
+                    if self._closed:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+
+    async def aclose(self) -> None:
+        self._closed = True
+        self.__raw_socket.close()
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self.__raw_socket
+
+
+class UDPSocket(abc.UDPSocket):
+    def __init__(
+        self, transport: asyncio.DatagramTransport, protocol: DatagramProtocol
+    ):
+        self._transport = transport
+        self._protocol = protocol
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+        self._closed = False
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self._transport.get_extra_info("socket")
+
+    async def aclose(self) -> None:
+        if not self._transport.is_closing():
+            self._closed = True
+            self._transport.close()
+
+    async def receive(self) -> Tuple[bytes, IPSockAddrType]:
+        with self._receive_guard:
+            await checkpoint()
+
+            # If the buffer is empty, ask for more data
+            if not self._protocol.read_queue and not self._transport.is_closing():
+                self._protocol.read_event.clear()
+                await self._protocol.read_event.wait()
+
+            try:
+                return self._protocol.read_queue.popleft()
+            except IndexError:
+                if self._closed:
+                    raise ClosedResourceError from None
+                else:
+                    raise BrokenResourceError from None
+
+    async def send(self, item: UDPPacketType) -> None:
+        with self._send_guard:
+            await checkpoint()
+            await self._protocol.write_event.wait()
+            if self._closed:
+                raise ClosedResourceError
+            elif self._transport.is_closing():
+                raise BrokenResourceError
+            else:
+                self._transport.sendto(*item)
+
+
+class ConnectedUDPSocket(abc.ConnectedUDPSocket):
+    def __init__(
+        self, transport: asyncio.DatagramTransport, protocol: DatagramProtocol
+    ):
+        self._transport = transport
+        self._protocol = protocol
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+        self._closed = False
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self._transport.get_extra_info("socket")
+
+    async def aclose(self) -> None:
+        if not self._transport.is_closing():
+            self._closed = True
+            self._transport.close()
+
+    async def receive(self) -> bytes:
+        with self._receive_guard:
+            await checkpoint()
+
+            # If the buffer is empty, ask for more data
+            if not self._protocol.read_queue and not self._transport.is_closing():
+                self._protocol.read_event.clear()
+                await self._protocol.read_event.wait()
+
+            try:
+                packet = self._protocol.read_queue.popleft()
+            except IndexError:
+                if self._closed:
+                    raise ClosedResourceError from None
+                else:
+                    raise BrokenResourceError from None
+
+            return packet[0]
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            await checkpoint()
+            await self._protocol.write_event.wait()
+            if self._closed:
+                raise ClosedResourceError
+            elif self._transport.is_closing():
+                raise BrokenResourceError
+            else:
+                self._transport.sendto(item)
+
+
+async def connect_tcp(
+    host: str, port: int, local_addr: Optional[Tuple[str, int]] = None
+) -> SocketStream:
+    transport, protocol = cast(
+        Tuple[asyncio.Transport, StreamProtocol],
+        await get_running_loop().create_connection(
+            StreamProtocol, host, port, local_addr=local_addr
+        ),
+    )
+    transport.pause_reading()
+    return SocketStream(transport, protocol)
+
+
+async def connect_unix(path: str) -> UNIXSocketStream:
+    await checkpoint()
+    loop = get_running_loop()
+    raw_socket = socket.socket(socket.AF_UNIX)
+    raw_socket.setblocking(False)
+    while True:
+        try:
+            raw_socket.connect(path)
+        except BlockingIOError:
+            f: asyncio.Future = asyncio.Future()
+            loop.add_writer(raw_socket, f.set_result, None)
+            f.add_done_callback(lambda _: loop.remove_writer(raw_socket))
+            await f
+        except BaseException:
+            raw_socket.close()
+            raise
+        else:
+            return UNIXSocketStream(raw_socket)
+
+
+async def create_udp_socket(
+    family: socket.AddressFamily,
+    local_address: Optional[IPSockAddrType],
+    remote_address: Optional[IPSockAddrType],
+    reuse_port: bool,
+) -> Union[UDPSocket, ConnectedUDPSocket]:
+    result = await get_running_loop().create_datagram_endpoint(
+        DatagramProtocol,
+        local_addr=local_address,
+        remote_addr=remote_address,
+        family=family,
+        reuse_port=reuse_port,
+    )
+    transport = cast(asyncio.DatagramTransport, result[0])
+    protocol = result[1]
+    if protocol.exception:
+        transport.close()
+        raise protocol.exception
+
+    if not remote_address:
+        return UDPSocket(transport, protocol)
+    else:
+        return ConnectedUDPSocket(transport, protocol)
+
+
+async def getaddrinfo(
+    host: Union[bytes, str],
+    port: Union[str, int, None],
+    *,
+    family: Union[int, AddressFamily] = 0,
+    type: Union[int, SocketKind] = 0,
+    proto: int = 0,
+    flags: int = 0,
+) -> GetAddrInfoReturnType:
+    # https://github.com/python/typeshed/pull/4304
+    result = await get_running_loop().getaddrinfo(
+        host, port, family=family, type=type, proto=proto, flags=flags
+    )
+    return cast(GetAddrInfoReturnType, result)
+
+
+async def getnameinfo(sockaddr: IPSockAddrType, flags: int = 0) -> Tuple[str, str]:
+    return await get_running_loop().getnameinfo(sockaddr, flags)
+
+
+_read_events: RunVar[Dict[Any, asyncio.Event]] = RunVar("read_events")
+_write_events: RunVar[Dict[Any, asyncio.Event]] = RunVar("write_events")
+
+
+async def wait_socket_readable(sock: socket.socket) -> None:
+    await checkpoint()
+    try:
+        read_events = _read_events.get()
+    except LookupError:
+        read_events = {}
+        _read_events.set(read_events)
+
+    if read_events.get(sock):
+        raise BusyResourceError("reading from") from None
+
+    loop = get_running_loop()
+    event = read_events[sock] = asyncio.Event()
+    loop.add_reader(sock, event.set)
+    try:
+        await event.wait()
+    finally:
+        if read_events.pop(sock, None) is not None:
+            loop.remove_reader(sock)
+            readable = True
+        else:
+            readable = False
+
+    if not readable:
+        raise ClosedResourceError
+
+
+async def wait_socket_writable(sock: socket.socket) -> None:
+    await checkpoint()
+    try:
+        write_events = _write_events.get()
+    except LookupError:
+        write_events = {}
+        _write_events.set(write_events)
+
+    if write_events.get(sock):
+        raise BusyResourceError("writing to") from None
+
+    loop = get_running_loop()
+    event = write_events[sock] = asyncio.Event()
+    loop.add_writer(sock.fileno(), event.set)
+    try:
+        await event.wait()
+    finally:
+        if write_events.pop(sock, None) is not None:
+            loop.remove_writer(sock)
+            writable = True
+        else:
+            writable = False
+
+    if not writable:
+        raise ClosedResourceError
+
+
+#
+# Synchronization
+#
+
+
+class Event(BaseEvent):
+    def __new__(cls) -> "Event":
+        return object.__new__(cls)
+
+    def __init__(self) -> None:
+        self._event = asyncio.Event()
+
+    def set(self) -> DeprecatedAwaitable:
+        self._event.set()
+        return DeprecatedAwaitable(self.set)
+
+    def is_set(self) -> bool:
+        return self._event.is_set()
+
+    async def wait(self) -> None:
+        if await self._event.wait():
+            await checkpoint()
+
+    def statistics(self) -> EventStatistics:
+        return EventStatistics(len(self._event._waiters))  # type: ignore[attr-defined]
+
+
+class CapacityLimiter(BaseCapacityLimiter):
+    _total_tokens: float = 0
+
+    def __new__(cls, total_tokens: float) -> "CapacityLimiter":
+        return object.__new__(cls)
+
+    def __init__(self, total_tokens: float):
+        self._borrowers: Set[Any] = set()
+        self._wait_queue: Dict[Any, asyncio.Event] = OrderedDict()
+        self.total_tokens = total_tokens
+
+    async def __aenter__(self) -> None:
+        await self.acquire()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.release()
+
+    @property
+    def total_tokens(self) -> float:
+        return self._total_tokens
+
+    @total_tokens.setter
+    def total_tokens(self, value: float) -> None:
+        if not isinstance(value, int) and not math.isinf(value):
+            raise TypeError("total_tokens must be an int or math.inf")
+        if value < 1:
+            raise ValueError("total_tokens must be >= 1")
+
+        old_value = self._total_tokens
+        self._total_tokens = value
+        events = []
+        for event in self._wait_queue.values():
+            if value <= old_value:
+                break
+
+            if not event.is_set():
+                events.append(event)
+                old_value += 1
+
+        for event in events:
+            event.set()
+
+    @property
+    def borrowed_tokens(self) -> int:
+        return len(self._borrowers)
+
+    @property
+    def available_tokens(self) -> float:
+        return self._total_tokens - len(self._borrowers)
+
+    def acquire_nowait(self) -> DeprecatedAwaitable:
+        self.acquire_on_behalf_of_nowait(current_task())
+        return DeprecatedAwaitable(self.acquire_nowait)
+
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> DeprecatedAwaitable:
+        if borrower in self._borrowers:
+            raise RuntimeError(
+                "this borrower is already holding one of this CapacityLimiter's "
+                "tokens"
+            )
+
+        if self._wait_queue or len(self._borrowers) >= self._total_tokens:
+            raise WouldBlock
+
+        self._borrowers.add(borrower)
+        return DeprecatedAwaitable(self.acquire_on_behalf_of_nowait)
+
+    async def acquire(self) -> None:
+        return await self.acquire_on_behalf_of(current_task())
+
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        await checkpoint_if_cancelled()
+        try:
+            self.acquire_on_behalf_of_nowait(borrower)
+        except WouldBlock:
+            event = asyncio.Event()
+            self._wait_queue[borrower] = event
+            try:
+                await event.wait()
+            except BaseException:
+                self._wait_queue.pop(borrower, None)
+                raise
+
+            self._borrowers.add(borrower)
+        else:
+            try:
+                await cancel_shielded_checkpoint()
+            except BaseException:
+                self.release()
+                raise
+
+    def release(self) -> None:
+        self.release_on_behalf_of(current_task())
+
+    def release_on_behalf_of(self, borrower: object) -> None:
+        try:
+            self._borrowers.remove(borrower)
+        except KeyError:
+            raise RuntimeError(
+                "this borrower isn't holding any of this CapacityLimiter's " "tokens"
+            ) from None
+
+        # Notify the next task in line if this limiter has free capacity now
+        if self._wait_queue and len(self._borrowers) < self._total_tokens:
+            event = self._wait_queue.popitem()[1]
+            event.set()
+
+    def statistics(self) -> CapacityLimiterStatistics:
+        return CapacityLimiterStatistics(
+            self.borrowed_tokens,
+            self.total_tokens,
+            tuple(self._borrowers),
+            len(self._wait_queue),
+        )
+
+
+_default_thread_limiter: RunVar[CapacityLimiter] = RunVar("_default_thread_limiter")
+
+
+def current_default_thread_limiter() -> CapacityLimiter:
+    try:
+        return _default_thread_limiter.get()
+    except LookupError:
+        limiter = CapacityLimiter(40)
+        _default_thread_limiter.set(limiter)
+        return limiter
+
+
+#
+# Operating system signals
+#
+
+
+class _SignalReceiver(DeprecatedAsyncContextManager["_SignalReceiver"]):
+    def __init__(self, signals: Tuple[int, ...]):
+        self._signals = signals
+        self._loop = get_running_loop()
+        self._signal_queue: Deque[int] = deque()
+        self._future: asyncio.Future = asyncio.Future()
+        self._handled_signals: Set[int] = set()
+
+    def _deliver(self, signum: int) -> None:
+        self._signal_queue.append(signum)
+        if not self._future.done():
+            self._future.set_result(None)
+
+    def __enter__(self) -> "_SignalReceiver":
+        for sig in set(self._signals):
+            self._loop.add_signal_handler(sig, self._deliver, sig)
+            self._handled_signals.add(sig)
+
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        for sig in self._handled_signals:
+            self._loop.remove_signal_handler(sig)
+        return None
+
+    def __aiter__(self) -> "_SignalReceiver":
+        return self
+
+    async def __anext__(self) -> int:
+        await checkpoint()
+        if not self._signal_queue:
+            self._future = asyncio.Future()
+            await self._future
+
+        return self._signal_queue.popleft()
+
+
+def open_signal_receiver(*signals: int) -> _SignalReceiver:
+    return _SignalReceiver(signals)
+
+
+#
+# Testing and debugging
+#
+
+
+def _create_task_info(task: asyncio.Task) -> TaskInfo:
+    task_state = _task_states.get(task)
+    if task_state is None:
+        name = task.get_name() if _native_task_names else None
+        parent_id = None
+    else:
+        name = task_state.name
+        parent_id = task_state.parent_id
+
+    return TaskInfo(id(task), parent_id, name, get_coro(task))
+
+
+def get_current_task() -> TaskInfo:
+    return _create_task_info(current_task())  # type: ignore[arg-type]
+
+
+def get_running_tasks() -> List[TaskInfo]:
+    return [_create_task_info(task) for task in all_tasks() if not task.done()]
+
+
+async def wait_all_tasks_blocked() -> None:
+    await checkpoint()
+    this_task = current_task()
+    while True:
+        for task in all_tasks():
+            if task is this_task:
+                continue
+
+            if task._fut_waiter is None or task._fut_waiter.done():  # type: ignore[attr-defined]
+                await sleep(0.1)
+                break
+        else:
+            return
+
+
+class TestRunner(abc.TestRunner):
+    def __init__(
+        self,
+        debug: bool = False,
+        use_uvloop: bool = False,
+        policy: Optional[asyncio.AbstractEventLoopPolicy] = None,
+    ):
+        self._exceptions: List[BaseException] = []
+        _maybe_set_event_loop_policy(policy, use_uvloop)
+        self._loop = asyncio.new_event_loop()
+        self._loop.set_debug(debug)
+        self._loop.set_exception_handler(self._exception_handler)
+        asyncio.set_event_loop(self._loop)
+
+    def _cancel_all_tasks(self) -> None:
+        to_cancel = all_tasks(self._loop)
+        if not to_cancel:
+            return
+
+        for task in to_cancel:
+            task.cancel()
+
+        self._loop.run_until_complete(
+            asyncio.gather(*to_cancel, return_exceptions=True)
+        )
+
+        for task in to_cancel:
+            if task.cancelled():
+                continue
+            if task.exception() is not None:
+                raise cast(BaseException, task.exception())
+
+    def _exception_handler(
+        self, loop: asyncio.AbstractEventLoop, context: Dict[str, Any]
+    ) -> None:
+        if isinstance(context.get("exception"), Exception):
+            self._exceptions.append(context["exception"])
+        else:
+            loop.default_exception_handler(context)
+
+    def _raise_async_exceptions(self) -> None:
+        # Re-raise any exceptions raised in asynchronous callbacks
+        if self._exceptions:
+            exceptions, self._exceptions = self._exceptions, []
+            if len(exceptions) == 1:
+                raise exceptions[0]
+            elif exceptions:
+                raise ExceptionGroup(exceptions)
+
+    def close(self) -> None:
+        try:
+            self._cancel_all_tasks()
+            self._loop.run_until_complete(self._loop.shutdown_asyncgens())
+        finally:
+            asyncio.set_event_loop(None)
+            self._loop.close()
+
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]],
+        kwargs: Dict[str, Any],
+    ) -> Iterable[T_Retval]:
+        async def fixture_runner() -> None:
+            agen = fixture_func(**kwargs)
+            try:
+                retval = await agen.asend(None)
+                self._raise_async_exceptions()
+            except BaseException as exc:
+                f.set_exception(exc)
+                return
+            else:
+                f.set_result(retval)
+
+            await event.wait()
+            try:
+                await agen.asend(None)
+            except StopAsyncIteration:
+                pass
+            else:
+                await agen.aclose()
+                raise RuntimeError("Async generator fixture did not stop")
+
+        f = self._loop.create_future()
+        event = asyncio.Event()
+        fixture_task = self._loop.create_task(fixture_runner())
+        self._loop.run_until_complete(f)
+        yield f.result()
+        event.set()
+        self._loop.run_until_complete(fixture_task)
+        self._raise_async_exceptions()
+
+    def run_fixture(
+        self,
+        fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]],
+        kwargs: Dict[str, Any],
+    ) -> T_Retval:
+        retval = self._loop.run_until_complete(fixture_func(**kwargs))
+        self._raise_async_exceptions()
+        return retval
+
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: Dict[str, Any]
+    ) -> None:
+        try:
+            self._loop.run_until_complete(test_func(**kwargs))
+        except Exception as exc:
+            self._exceptions.append(exc)
+
+        self._raise_async_exceptions()
diff --git a/myenv/lib/python3.9/site-packages/anyio/_backends/_trio.py b/myenv/lib/python3.9/site-packages/anyio/_backends/_trio.py
new file mode 100644
index 0000000..cf2aaec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_backends/_trio.py
@@ -0,0 +1,988 @@
+import array
+import math
+import socket
+from concurrent.futures import Future
+from contextvars import copy_context
+from dataclasses import dataclass
+from functools import partial
+from io import IOBase
+from os import PathLike
+from signal import Signals
+from types import TracebackType
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    AsyncGenerator,
+    Awaitable,
+    Callable,
+    Collection,
+    ContextManager,
+    Coroutine,
+    Deque,
+    Dict,
+    Generic,
+    Iterable,
+    List,
+    Mapping,
+    NoReturn,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+import sniffio
+import trio.from_thread
+from outcome import Error, Outcome, Value
+from trio.socket import SocketType as TrioSocketType
+from trio.to_thread import run_sync
+
+from .. import CapacityLimiterStatistics, EventStatistics, TaskInfo, abc
+from .._core._compat import DeprecatedAsyncContextManager, DeprecatedAwaitable, T
+from .._core._eventloop import claim_worker_thread
+from .._core._exceptions import (
+    BrokenResourceError,
+    BusyResourceError,
+    ClosedResourceError,
+    EndOfStream,
+)
+from .._core._exceptions import ExceptionGroup as BaseExceptionGroup
+from .._core._sockets import convert_ipv6_sockaddr
+from .._core._synchronization import CapacityLimiter as BaseCapacityLimiter
+from .._core._synchronization import Event as BaseEvent
+from .._core._synchronization import ResourceGuard
+from .._core._tasks import CancelScope as BaseCancelScope
+from ..abc import IPSockAddrType, UDPPacketType
+
+if TYPE_CHECKING:
+    from trio_typing import TaskStatus
+
+try:
+    from trio import lowlevel as trio_lowlevel
+except ImportError:
+    from trio import hazmat as trio_lowlevel  # type: ignore[no-redef]
+    from trio.hazmat import wait_readable, wait_writable
+else:
+    from trio.lowlevel import wait_readable, wait_writable
+
+try:
+    trio_open_process = trio_lowlevel.open_process  # type: ignore[attr-defined]
+except AttributeError:
+    from trio import open_process as trio_open_process
+
+T_Retval = TypeVar("T_Retval")
+T_SockAddr = TypeVar("T_SockAddr", str, IPSockAddrType)
+
+
+#
+# Event loop
+#
+
+run = trio.run
+current_token = trio.lowlevel.current_trio_token
+RunVar = trio.lowlevel.RunVar
+
+
+#
+# Miscellaneous
+#
+
+sleep = trio.sleep
+
+
+#
+# Timeouts and cancellation
+#
+
+
+class CancelScope(BaseCancelScope):
+    def __new__(
+        cls, original: Optional[trio.CancelScope] = None, **kwargs: object
+    ) -> "CancelScope":
+        return object.__new__(cls)
+
+    def __init__(
+        self, original: Optional[trio.CancelScope] = None, **kwargs: Any
+    ) -> None:
+        self.__original = original or trio.CancelScope(**kwargs)
+
+    def __enter__(self) -> "CancelScope":
+        self.__original.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return self.__original.__exit__(exc_type, exc_val, exc_tb)
+
+    def cancel(self) -> DeprecatedAwaitable:
+        self.__original.cancel()
+        return DeprecatedAwaitable(self.cancel)
+
+    @property
+    def deadline(self) -> float:
+        return self.__original.deadline
+
+    @deadline.setter
+    def deadline(self, value: float) -> None:
+        self.__original.deadline = value
+
+    @property
+    def cancel_called(self) -> bool:
+        return self.__original.cancel_called
+
+    @property
+    def shield(self) -> bool:
+        return self.__original.shield
+
+    @shield.setter
+    def shield(self, value: bool) -> None:
+        self.__original.shield = value
+
+
+CancelledError = trio.Cancelled
+checkpoint = trio.lowlevel.checkpoint
+checkpoint_if_cancelled = trio.lowlevel.checkpoint_if_cancelled
+cancel_shielded_checkpoint = trio.lowlevel.cancel_shielded_checkpoint
+current_effective_deadline = trio.current_effective_deadline
+current_time = trio.current_time
+
+
+#
+# Task groups
+#
+
+
+class ExceptionGroup(BaseExceptionGroup, trio.MultiError):
+    pass
+
+
+class TaskGroup(abc.TaskGroup):
+    def __init__(self) -> None:
+        self._active = False
+        self._nursery_manager = trio.open_nursery()
+        self.cancel_scope = None  # type: ignore[assignment]
+
+    async def __aenter__(self) -> "TaskGroup":
+        self._active = True
+        self._nursery = await self._nursery_manager.__aenter__()
+        self.cancel_scope = CancelScope(self._nursery.cancel_scope)
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        try:
+            return await self._nursery_manager.__aexit__(exc_type, exc_val, exc_tb)
+        except trio.MultiError as exc:
+            raise ExceptionGroup(exc.exceptions) from None
+        finally:
+            self._active = False
+
+    def start_soon(self, func: Callable, *args: object, name: object = None) -> None:
+        if not self._active:
+            raise RuntimeError(
+                "This task group is not active; no new tasks can be started."
+            )
+
+        self._nursery.start_soon(func, *args, name=name)
+
+    async def start(
+        self, func: Callable[..., Coroutine], *args: object, name: object = None
+    ) -> object:
+        if not self._active:
+            raise RuntimeError(
+                "This task group is not active; no new tasks can be started."
+            )
+
+        return await self._nursery.start(func, *args, name=name)
+
+
+#
+# Threads
+#
+
+
+async def run_sync_in_worker_thread(
+    func: Callable[..., T_Retval],
+    *args: object,
+    cancellable: bool = False,
+    limiter: Optional[trio.CapacityLimiter] = None,
+) -> T_Retval:
+    def wrapper() -> T_Retval:
+        with claim_worker_thread("trio"):
+            return func(*args)
+
+    # TODO: remove explicit context copying when trio 0.20 is the minimum requirement
+    context = copy_context()
+    context.run(sniffio.current_async_library_cvar.set, None)
+    return await run_sync(
+        context.run, wrapper, cancellable=cancellable, limiter=limiter
+    )
+
+
+# TODO: remove this workaround when trio 0.20 is the minimum requirement
+def run_async_from_thread(
+    fn: Callable[..., Awaitable[T_Retval]], *args: Any
+) -> T_Retval:
+    async def wrapper() -> T_Retval:
+        retval: T_Retval
+
+        async def inner() -> None:
+            nonlocal retval
+            __tracebackhide__ = True
+            retval = await fn(*args)
+
+        async with trio.open_nursery() as n:
+            context.run(n.start_soon, inner)
+
+        __tracebackhide__ = True
+        return retval
+
+    context = copy_context()
+    context.run(sniffio.current_async_library_cvar.set, "trio")
+    return trio.from_thread.run(wrapper)
+
+
+def run_sync_from_thread(fn: Callable[..., T_Retval], *args: Any) -> T_Retval:
+    # TODO: remove explicit context copying when trio 0.20 is the minimum requirement
+    retval = trio.from_thread.run_sync(copy_context().run, fn, *args)
+    return cast(T_Retval, retval)
+
+
+class BlockingPortal(abc.BlockingPortal):
+    def __new__(cls) -> "BlockingPortal":
+        return object.__new__(cls)
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._token = trio.lowlevel.current_trio_token()
+
+    def _spawn_task_from_thread(
+        self,
+        func: Callable,
+        args: tuple,
+        kwargs: Dict[str, Any],
+        name: object,
+        future: Future,
+    ) -> None:
+        context = copy_context()
+        context.run(sniffio.current_async_library_cvar.set, "trio")
+        trio.from_thread.run_sync(
+            context.run,
+            partial(self._task_group.start_soon, name=name),
+            self._call_func,
+            func,
+            args,
+            kwargs,
+            future,
+            trio_token=self._token,
+        )
+
+
+#
+# Subprocesses
+#
+
+
+@dataclass(eq=False)
+class ReceiveStreamWrapper(abc.ByteReceiveStream):
+    _stream: trio.abc.ReceiveStream
+
+    async def receive(self, max_bytes: Optional[int] = None) -> bytes:
+        try:
+            data = await self._stream.receive_some(max_bytes)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError from exc.__cause__
+        except trio.BrokenResourceError as exc:
+            raise BrokenResourceError from exc.__cause__
+
+        if data:
+            return data
+        else:
+            raise EndOfStream
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+
+@dataclass(eq=False)
+class SendStreamWrapper(abc.ByteSendStream):
+    _stream: trio.abc.SendStream
+
+    async def send(self, item: bytes) -> None:
+        try:
+            await self._stream.send_all(item)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError from exc.__cause__
+        except trio.BrokenResourceError as exc:
+            raise BrokenResourceError from exc.__cause__
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+
+@dataclass(eq=False)
+class Process(abc.Process):
+    _process: trio.Process
+    _stdin: Optional[abc.ByteSendStream]
+    _stdout: Optional[abc.ByteReceiveStream]
+    _stderr: Optional[abc.ByteReceiveStream]
+
+    async def aclose(self) -> None:
+        if self._stdin:
+            await self._stdin.aclose()
+        if self._stdout:
+            await self._stdout.aclose()
+        if self._stderr:
+            await self._stderr.aclose()
+
+        await self.wait()
+
+    async def wait(self) -> int:
+        return await self._process.wait()
+
+    def terminate(self) -> None:
+        self._process.terminate()
+
+    def kill(self) -> None:
+        self._process.kill()
+
+    def send_signal(self, signal: Signals) -> None:
+        self._process.send_signal(signal)
+
+    @property
+    def pid(self) -> int:
+        return self._process.pid
+
+    @property
+    def returncode(self) -> Optional[int]:
+        return self._process.returncode
+
+    @property
+    def stdin(self) -> Optional[abc.ByteSendStream]:
+        return self._stdin
+
+    @property
+    def stdout(self) -> Optional[abc.ByteReceiveStream]:
+        return self._stdout
+
+    @property
+    def stderr(self) -> Optional[abc.ByteReceiveStream]:
+        return self._stderr
+
+
+async def open_process(
+    command: Union[str, bytes, Sequence[Union[str, bytes]]],
+    *,
+    shell: bool,
+    stdin: Union[int, IO[Any], None],
+    stdout: Union[int, IO[Any], None],
+    stderr: Union[int, IO[Any], None],
+    cwd: Union[str, bytes, PathLike, None] = None,
+    env: Optional[Mapping[str, str]] = None,
+    start_new_session: bool = False,
+) -> Process:
+    process = await trio_open_process(
+        command,
+        stdin=stdin,
+        stdout=stdout,
+        stderr=stderr,
+        shell=shell,
+        cwd=cwd,
+        env=env,
+        start_new_session=start_new_session,
+    )
+    stdin_stream = SendStreamWrapper(process.stdin) if process.stdin else None
+    stdout_stream = ReceiveStreamWrapper(process.stdout) if process.stdout else None
+    stderr_stream = ReceiveStreamWrapper(process.stderr) if process.stderr else None
+    return Process(process, stdin_stream, stdout_stream, stderr_stream)
+
+
+class _ProcessPoolShutdownInstrument(trio.abc.Instrument):
+    def after_run(self) -> None:
+        super().after_run()
+
+
+current_default_worker_process_limiter: RunVar = RunVar(
+    "current_default_worker_process_limiter"
+)
+
+
+async def _shutdown_process_pool(workers: Set[Process]) -> None:
+    process: Process
+    try:
+        await sleep(math.inf)
+    except trio.Cancelled:
+        for process in workers:
+            if process.returncode is None:
+                process.kill()
+
+        with CancelScope(shield=True):
+            for process in workers:
+                await process.aclose()
+
+
+def setup_process_pool_exit_at_shutdown(workers: Set[Process]) -> None:
+    trio.lowlevel.spawn_system_task(_shutdown_process_pool, workers)
+
+
+#
+# Sockets and networking
+#
+
+
+class _TrioSocketMixin(Generic[T_SockAddr]):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        self._trio_socket = trio_socket
+        self._closed = False
+
+    def _check_closed(self) -> None:
+        if self._closed:
+            raise ClosedResourceError
+        if self._trio_socket.fileno() < 0:
+            raise BrokenResourceError
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self._trio_socket._sock  # type: ignore[attr-defined]
+
+    async def aclose(self) -> None:
+        if self._trio_socket.fileno() >= 0:
+            self._closed = True
+            self._trio_socket.close()
+
+    def _convert_socket_error(self, exc: BaseException) -> "NoReturn":
+        if isinstance(exc, trio.ClosedResourceError):
+            raise ClosedResourceError from exc
+        elif self._trio_socket.fileno() < 0 and self._closed:
+            raise ClosedResourceError from None
+        elif isinstance(exc, OSError):
+            raise BrokenResourceError from exc
+        else:
+            raise exc
+
+
+class SocketStream(_TrioSocketMixin, abc.SocketStream):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        with self._receive_guard:
+            try:
+                data = await self._trio_socket.recv(max_bytes)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+            if data:
+                return data
+            else:
+                raise EndOfStream
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            view = memoryview(item)
+            while view:
+                try:
+                    bytes_sent = await self._trio_socket.send(view)
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+
+                view = view[bytes_sent:]
+
+    async def send_eof(self) -> None:
+        self._trio_socket.shutdown(socket.SHUT_WR)
+
+
+class UNIXSocketStream(SocketStream, abc.UNIXSocketStream):
+    async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]:
+        if not isinstance(msglen, int) or msglen < 0:
+            raise ValueError("msglen must be a non-negative integer")
+        if not isinstance(maxfds, int) or maxfds < 1:
+            raise ValueError("maxfds must be a positive integer")
+
+        fds = array.array("i")
+        await checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    message, ancdata, flags, addr = await self._trio_socket.recvmsg(
+                        msglen, socket.CMSG_LEN(maxfds * fds.itemsize)
+                    )
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+                else:
+                    if not message and not ancdata:
+                        raise EndOfStream
+
+                    break
+
+        for cmsg_level, cmsg_type, cmsg_data in ancdata:
+            if cmsg_level != socket.SOL_SOCKET or cmsg_type != socket.SCM_RIGHTS:
+                raise RuntimeError(
+                    f"Received unexpected ancillary data; message = {message!r}, "
+                    f"cmsg_level = {cmsg_level}, cmsg_type = {cmsg_type}"
+                )
+
+            fds.frombytes(cmsg_data[: len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
+
+        return message, list(fds)
+
+    async def send_fds(
+        self, message: bytes, fds: Collection[Union[int, IOBase]]
+    ) -> None:
+        if not message:
+            raise ValueError("message must not be empty")
+        if not fds:
+            raise ValueError("fds must not be empty")
+
+        filenos: List[int] = []
+        for fd in fds:
+            if isinstance(fd, int):
+                filenos.append(fd)
+            elif isinstance(fd, IOBase):
+                filenos.append(fd.fileno())
+
+        fdarray = array.array("i", filenos)
+        await checkpoint()
+        with self._send_guard:
+            while True:
+                try:
+                    await self._trio_socket.sendmsg(
+                        [message],
+                        [
+                            (
+                                socket.SOL_SOCKET,
+                                socket.SCM_RIGHTS,  # type: ignore[list-item]
+                                fdarray,
+                            )
+                        ],
+                    )
+                    break
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+
+
+class TCPSocketListener(_TrioSocketMixin, abc.SocketListener):
+    def __init__(self, raw_socket: socket.socket):
+        super().__init__(trio.socket.from_stdlib_socket(raw_socket))
+        self._accept_guard = ResourceGuard("accepting connections from")
+
+    async def accept(self) -> SocketStream:
+        with self._accept_guard:
+            try:
+                trio_socket, _addr = await self._trio_socket.accept()
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+        trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        return SocketStream(trio_socket)
+
+
+class UNIXSocketListener(_TrioSocketMixin, abc.SocketListener):
+    def __init__(self, raw_socket: socket.socket):
+        super().__init__(trio.socket.from_stdlib_socket(raw_socket))
+        self._accept_guard = ResourceGuard("accepting connections from")
+
+    async def accept(self) -> UNIXSocketStream:
+        with self._accept_guard:
+            try:
+                trio_socket, _addr = await self._trio_socket.accept()
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+        return UNIXSocketStream(trio_socket)
+
+
+class UDPSocket(_TrioSocketMixin[IPSockAddrType], abc.UDPSocket):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> Tuple[bytes, IPSockAddrType]:
+        with self._receive_guard:
+            try:
+                data, addr = await self._trio_socket.recvfrom(65536)
+                return data, convert_ipv6_sockaddr(addr)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: UDPPacketType) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.sendto(*item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+class ConnectedUDPSocket(_TrioSocketMixin[IPSockAddrType], abc.ConnectedUDPSocket):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> bytes:
+        with self._receive_guard:
+            try:
+                return await self._trio_socket.recv(65536)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.send(item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+async def connect_tcp(
+    host: str, port: int, local_address: Optional[IPSockAddrType] = None
+) -> SocketStream:
+    family = socket.AF_INET6 if ":" in host else socket.AF_INET
+    trio_socket = trio.socket.socket(family)
+    trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+    if local_address:
+        await trio_socket.bind(local_address)
+
+    try:
+        await trio_socket.connect((host, port))
+    except BaseException:
+        trio_socket.close()
+        raise
+
+    return SocketStream(trio_socket)
+
+
+async def connect_unix(path: str) -> UNIXSocketStream:
+    trio_socket = trio.socket.socket(socket.AF_UNIX)
+    try:
+        await trio_socket.connect(path)
+    except BaseException:
+        trio_socket.close()
+        raise
+
+    return UNIXSocketStream(trio_socket)
+
+
+async def create_udp_socket(
+    family: socket.AddressFamily,
+    local_address: Optional[IPSockAddrType],
+    remote_address: Optional[IPSockAddrType],
+    reuse_port: bool,
+) -> Union[UDPSocket, ConnectedUDPSocket]:
+    trio_socket = trio.socket.socket(family=family, type=socket.SOCK_DGRAM)
+
+    if reuse_port:
+        trio_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+
+    if local_address:
+        await trio_socket.bind(local_address)
+
+    if remote_address:
+        await trio_socket.connect(remote_address)
+        return ConnectedUDPSocket(trio_socket)
+    else:
+        return UDPSocket(trio_socket)
+
+
+getaddrinfo = trio.socket.getaddrinfo
+getnameinfo = trio.socket.getnameinfo
+
+
+async def wait_socket_readable(sock: socket.socket) -> None:
+    try:
+        await wait_readable(sock)
+    except trio.ClosedResourceError as exc:
+        raise ClosedResourceError().with_traceback(exc.__traceback__) from None
+    except trio.BusyResourceError:
+        raise BusyResourceError("reading from") from None
+
+
+async def wait_socket_writable(sock: socket.socket) -> None:
+    try:
+        await wait_writable(sock)
+    except trio.ClosedResourceError as exc:
+        raise ClosedResourceError().with_traceback(exc.__traceback__) from None
+    except trio.BusyResourceError:
+        raise BusyResourceError("writing to") from None
+
+
+#
+# Synchronization
+#
+
+
+class Event(BaseEvent):
+    def __new__(cls) -> "Event":
+        return object.__new__(cls)
+
+    def __init__(self) -> None:
+        self.__original = trio.Event()
+
+    def is_set(self) -> bool:
+        return self.__original.is_set()
+
+    async def wait(self) -> None:
+        return await self.__original.wait()
+
+    def statistics(self) -> EventStatistics:
+        orig_statistics = self.__original.statistics()
+        return EventStatistics(tasks_waiting=orig_statistics.tasks_waiting)
+
+    def set(self) -> DeprecatedAwaitable:
+        self.__original.set()
+        return DeprecatedAwaitable(self.set)
+
+
+class CapacityLimiter(BaseCapacityLimiter):
+    def __new__(cls, *args: object, **kwargs: object) -> "CapacityLimiter":
+        return object.__new__(cls)
+
+    def __init__(
+        self, *args: Any, original: Optional[trio.CapacityLimiter] = None
+    ) -> None:
+        self.__original = original or trio.CapacityLimiter(*args)
+
+    async def __aenter__(self) -> None:
+        return await self.__original.__aenter__()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return await self.__original.__aexit__(exc_type, exc_val, exc_tb)
+
+    @property
+    def total_tokens(self) -> float:
+        return self.__original.total_tokens
+
+    @total_tokens.setter
+    def total_tokens(self, value: float) -> None:
+        self.__original.total_tokens = value
+
+    @property
+    def borrowed_tokens(self) -> int:
+        return self.__original.borrowed_tokens
+
+    @property
+    def available_tokens(self) -> float:
+        return self.__original.available_tokens
+
+    def acquire_nowait(self) -> DeprecatedAwaitable:
+        self.__original.acquire_nowait()
+        return DeprecatedAwaitable(self.acquire_nowait)
+
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> DeprecatedAwaitable:
+        self.__original.acquire_on_behalf_of_nowait(borrower)
+        return DeprecatedAwaitable(self.acquire_on_behalf_of_nowait)
+
+    async def acquire(self) -> None:
+        await self.__original.acquire()
+
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        await self.__original.acquire_on_behalf_of(borrower)
+
+    def release(self) -> None:
+        return self.__original.release()
+
+    def release_on_behalf_of(self, borrower: object) -> None:
+        return self.__original.release_on_behalf_of(borrower)
+
+    def statistics(self) -> CapacityLimiterStatistics:
+        orig = self.__original.statistics()
+        return CapacityLimiterStatistics(
+            borrowed_tokens=orig.borrowed_tokens,
+            total_tokens=orig.total_tokens,
+            borrowers=orig.borrowers,
+            tasks_waiting=orig.tasks_waiting,
+        )
+
+
+_capacity_limiter_wrapper: RunVar = RunVar("_capacity_limiter_wrapper")
+
+
+def current_default_thread_limiter() -> CapacityLimiter:
+    try:
+        return _capacity_limiter_wrapper.get()
+    except LookupError:
+        limiter = CapacityLimiter(
+            original=trio.to_thread.current_default_thread_limiter()
+        )
+        _capacity_limiter_wrapper.set(limiter)
+        return limiter
+
+
+#
+# Signal handling
+#
+
+
+class _SignalReceiver(DeprecatedAsyncContextManager[T]):
+    def __init__(self, cm: ContextManager[T]):
+        self._cm = cm
+
+    def __enter__(self) -> T:
+        return self._cm.__enter__()
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return self._cm.__exit__(exc_type, exc_val, exc_tb)
+
+
+def open_signal_receiver(*signals: Signals) -> _SignalReceiver:
+    cm = trio.open_signal_receiver(*signals)
+    return _SignalReceiver(cm)
+
+
+#
+# Testing and debugging
+#
+
+
+def get_current_task() -> TaskInfo:
+    task = trio_lowlevel.current_task()
+
+    parent_id = None
+    if task.parent_nursery and task.parent_nursery.parent_task:
+        parent_id = id(task.parent_nursery.parent_task)
+
+    return TaskInfo(id(task), parent_id, task.name, task.coro)
+
+
+def get_running_tasks() -> List[TaskInfo]:
+    root_task = trio_lowlevel.current_root_task()
+    task_infos = [TaskInfo(id(root_task), None, root_task.name, root_task.coro)]
+    nurseries = root_task.child_nurseries
+    while nurseries:
+        new_nurseries: List[trio.Nursery] = []
+        for nursery in nurseries:
+            for task in nursery.child_tasks:
+                task_infos.append(
+                    TaskInfo(id(task), id(nursery.parent_task), task.name, task.coro)
+                )
+                new_nurseries.extend(task.child_nurseries)
+
+        nurseries = new_nurseries
+
+    return task_infos
+
+
+def wait_all_tasks_blocked() -> Awaitable[None]:
+    import trio.testing
+
+    return trio.testing.wait_all_tasks_blocked()
+
+
+class TestRunner(abc.TestRunner):
+    def __init__(self, **options: Any) -> None:
+        from collections import deque
+        from queue import Queue
+
+        self._call_queue: "Queue[Callable[..., object]]" = Queue()
+        self._result_queue: Deque[Outcome] = deque()
+        self._stop_event: Optional[trio.Event] = None
+        self._nursery: Optional[trio.Nursery] = None
+        self._options = options
+
+    async def _trio_main(self) -> None:
+        self._stop_event = trio.Event()
+        async with trio.open_nursery() as self._nursery:
+            await self._stop_event.wait()
+
+    async def _call_func(
+        self, func: Callable[..., Awaitable[object]], args: tuple, kwargs: dict
+    ) -> None:
+        try:
+            retval = await func(*args, **kwargs)
+        except BaseException as exc:
+            self._result_queue.append(Error(exc))
+        else:
+            self._result_queue.append(Value(retval))
+
+    def _main_task_finished(self, outcome: object) -> None:
+        self._nursery = None
+
+    def _get_nursery(self) -> trio.Nursery:
+        if self._nursery is None:
+            trio.lowlevel.start_guest_run(
+                self._trio_main,
+                run_sync_soon_threadsafe=self._call_queue.put,
+                done_callback=self._main_task_finished,
+                **self._options,
+            )
+            while self._nursery is None:
+                self._call_queue.get()()
+
+        return self._nursery
+
+    def _call(
+        self, func: Callable[..., Awaitable[T_Retval]], *args: object, **kwargs: object
+    ) -> T_Retval:
+        self._get_nursery().start_soon(self._call_func, func, args, kwargs)
+        while not self._result_queue:
+            self._call_queue.get()()
+
+        outcome = self._result_queue.pop()
+        return outcome.unwrap()
+
+    def close(self) -> None:
+        if self._stop_event:
+            self._stop_event.set()
+            while self._nursery is not None:
+                self._call_queue.get()()
+
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]],
+        kwargs: Dict[str, Any],
+    ) -> Iterable[T_Retval]:
+        async def fixture_runner(*, task_status: "TaskStatus") -> None:
+            agen = fixture_func(**kwargs)
+            retval = await agen.asend(None)
+            task_status.started(retval)
+            await teardown_event.wait()
+            try:
+                await agen.asend(None)
+            except StopAsyncIteration:
+                pass
+            else:
+                await agen.aclose()
+                raise RuntimeError("Async generator fixture did not stop")
+
+        teardown_event = trio.Event()
+        fixture_value = self._call(lambda: self._get_nursery().start(fixture_runner))
+        yield fixture_value
+        teardown_event.set()
+
+    def run_fixture(
+        self,
+        fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]],
+        kwargs: Dict[str, Any],
+    ) -> T_Retval:
+        return self._call(fixture_func, **kwargs)
+
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: Dict[str, Any]
+    ) -> None:
+        self._call(test_func, **kwargs)
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/__init__.py b/myenv/lib/python3.9/site-packages/anyio/_core/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_compat.py b/myenv/lib/python3.9/site-packages/anyio/_core/_compat.py
new file mode 100644
index 0000000..7062be5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_compat.py
@@ -0,0 +1,218 @@
+from abc import ABCMeta, abstractmethod
+from contextlib import AbstractContextManager
+from types import TracebackType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncContextManager,
+    Callable,
+    ContextManager,
+    Generator,
+    Generic,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+from warnings import warn
+
+if TYPE_CHECKING:
+    from ._testing import TaskInfo
+else:
+    TaskInfo = object
+
+T = TypeVar("T")
+AnyDeprecatedAwaitable = Union[
+    "DeprecatedAwaitable",
+    "DeprecatedAwaitableFloat",
+    "DeprecatedAwaitableList[T]",
+    TaskInfo,
+]
+
+
+@overload
+async def maybe_async(__obj: TaskInfo) -> TaskInfo:
+    ...
+
+
+@overload
+async def maybe_async(__obj: "DeprecatedAwaitableFloat") -> float:
+    ...
+
+
+@overload
+async def maybe_async(__obj: "DeprecatedAwaitableList[T]") -> List[T]:
+    ...
+
+
+@overload
+async def maybe_async(__obj: "DeprecatedAwaitable") -> None:
+    ...
+
+
+async def maybe_async(
+    __obj: "AnyDeprecatedAwaitable[T]",
+) -> Union[TaskInfo, float, List[T], None]:
+    """
+    Await on the given object if necessary.
+
+    This function is intended to bridge the gap between AnyIO 2.x and 3.x where some functions and
+    methods were converted from coroutine functions into regular functions.
+
+    Do **not** try to use this for any other purpose!
+
+    :return: the result of awaiting on the object if coroutine, or the object itself otherwise
+
+    .. versionadded:: 2.2
+
+    """
+    return __obj._unwrap()
+
+
+class _ContextManagerWrapper:
+    def __init__(self, cm: ContextManager[T]):
+        self._cm = cm
+
+    async def __aenter__(self) -> T:
+        return self._cm.__enter__()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return self._cm.__exit__(exc_type, exc_val, exc_tb)
+
+
+def maybe_async_cm(
+    cm: Union[ContextManager[T], AsyncContextManager[T]]
+) -> AsyncContextManager[T]:
+    """
+    Wrap a regular context manager as an async one if necessary.
+
+    This function is intended to bridge the gap between AnyIO 2.x and 3.x where some functions and
+    methods were changed to return regular context managers instead of async ones.
+
+    :param cm: a regular or async context manager
+    :return: an async context manager
+
+    .. versionadded:: 2.2
+
+    """
+    if not isinstance(cm, AbstractContextManager):
+        raise TypeError("Given object is not an context manager")
+
+    return _ContextManagerWrapper(cm)
+
+
+def _warn_deprecation(
+    awaitable: "AnyDeprecatedAwaitable[Any]", stacklevel: int = 1
+) -> None:
+    warn(
+        f'Awaiting on {awaitable._name}() is deprecated. Use "await '
+        f"anyio.maybe_async({awaitable._name}(...)) if you have to support both AnyIO 2.x "
+        f'and 3.x, or just remove the "await" if you are completely migrating to AnyIO 3+.',
+        DeprecationWarning,
+        stacklevel=stacklevel + 1,
+    )
+
+
+class DeprecatedAwaitable:
+    def __init__(self, func: Callable[..., "DeprecatedAwaitable"]):
+        self._name = f"{func.__module__}.{func.__qualname__}"
+
+    def __await__(self) -> Generator[None, None, None]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+    def __reduce__(self) -> Tuple[Type[None], Tuple[()]]:
+        return type(None), ()
+
+    def _unwrap(self) -> None:
+        return None
+
+
+class DeprecatedAwaitableFloat(float):
+    def __new__(
+        cls, x: float, func: Callable[..., "DeprecatedAwaitableFloat"]
+    ) -> "DeprecatedAwaitableFloat":
+        return super().__new__(cls, x)
+
+    def __init__(self, x: float, func: Callable[..., "DeprecatedAwaitableFloat"]):
+        self._name = f"{func.__module__}.{func.__qualname__}"
+
+    def __await__(self) -> Generator[None, None, float]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+        return float(self)
+
+    def __reduce__(self) -> Tuple[Type[float], Tuple[float]]:
+        return float, (float(self),)
+
+    def _unwrap(self) -> float:
+        return float(self)
+
+
+class DeprecatedAwaitableList(List[T]):
+    def __init__(
+        self,
+        iterable: Iterable[T] = (),
+        *,
+        func: Callable[..., "DeprecatedAwaitableList[T]"],
+    ):
+        super().__init__(iterable)
+        self._name = f"{func.__module__}.{func.__qualname__}"
+
+    def __await__(self) -> Generator[None, None, List[T]]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+        return list(self)
+
+    def __reduce__(self) -> Tuple[Type[List[T]], Tuple[List[T]]]:
+        return list, (list(self),)
+
+    def _unwrap(self) -> List[T]:
+        return list(self)
+
+
+class DeprecatedAsyncContextManager(Generic[T], metaclass=ABCMeta):
+    @abstractmethod
+    def __enter__(self) -> T:
+        pass
+
+    @abstractmethod
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        pass
+
+    async def __aenter__(self) -> T:
+        warn(
+            f"Using {self.__class__.__name__} as an async context manager has been deprecated. "
+            f'Use "async with anyio.maybe_async_cm(yourcontextmanager) as foo:" if you have to '
+            f'support both AnyIO 2.x and 3.x, or just remove the "async" from "async with" if '
+            f"you are completely migrating to AnyIO 3+.",
+            DeprecationWarning,
+        )
+        return self.__enter__()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return self.__exit__(exc_type, exc_val, exc_tb)
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_eventloop.py b/myenv/lib/python3.9/site-packages/anyio/_core/_eventloop.py
new file mode 100644
index 0000000..f027ae5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_eventloop.py
@@ -0,0 +1,155 @@
+import math
+import sys
+import threading
+from contextlib import contextmanager
+from importlib import import_module
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Generator,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+)
+
+import sniffio
+
+# This must be updated when new backends are introduced
+from ._compat import DeprecatedAwaitableFloat
+
+BACKENDS = "asyncio", "trio"
+
+T_Retval = TypeVar("T_Retval")
+threadlocals = threading.local()
+
+
+def run(
+    func: Callable[..., Coroutine[Any, Any, T_Retval]],
+    *args: object,
+    backend: str = "asyncio",
+    backend_options: Optional[Dict[str, Any]] = None,
+) -> T_Retval:
+    """
+    Run the given coroutine function in an asynchronous event loop.
+
+    The current thread must not be already running an event loop.
+
+    :param func: a coroutine function
+    :param args: positional arguments to ``func``
+    :param backend: name of the asynchronous event loop implementation – currently either
+        ``asyncio`` or ``trio``
+    :param backend_options: keyword arguments to call the backend ``run()`` implementation with
+        (documented :ref:`here <backend options>`)
+    :return: the return value of the coroutine function
+    :raises RuntimeError: if an asynchronous event loop is already running in this thread
+    :raises LookupError: if the named backend is not found
+
+    """
+    try:
+        asynclib_name = sniffio.current_async_library()
+    except sniffio.AsyncLibraryNotFoundError:
+        pass
+    else:
+        raise RuntimeError(f"Already running {asynclib_name} in this thread")
+
+    try:
+        asynclib = import_module(f"..._backends._{backend}", package=__name__)
+    except ImportError as exc:
+        raise LookupError(f"No such backend: {backend}") from exc
+
+    token = None
+    if sniffio.current_async_library_cvar.get(None) is None:
+        # Since we're in control of the event loop, we can cache the name of the async library
+        token = sniffio.current_async_library_cvar.set(backend)
+
+    try:
+        backend_options = backend_options or {}
+        return asynclib.run(func, *args, **backend_options)
+    finally:
+        if token:
+            sniffio.current_async_library_cvar.reset(token)
+
+
+async def sleep(delay: float) -> None:
+    """
+    Pause the current task for the specified duration.
+
+    :param delay: the duration, in seconds
+
+    """
+    return await get_asynclib().sleep(delay)
+
+
+async def sleep_forever() -> None:
+    """
+    Pause the current task until it's cancelled.
+
+    This is a shortcut for ``sleep(math.inf)``.
+
+    .. versionadded:: 3.1
+
+    """
+    await sleep(math.inf)
+
+
+async def sleep_until(deadline: float) -> None:
+    """
+    Pause the current task until the given time.
+
+    :param deadline: the absolute time to wake up at (according to the internal monotonic clock of
+        the event loop)
+
+    .. versionadded:: 3.1
+
+    """
+    now = current_time()
+    await sleep(max(deadline - now, 0))
+
+
+def current_time() -> DeprecatedAwaitableFloat:
+    """
+    Return the current value of the event loop's internal clock.
+
+    :return: the clock value (seconds)
+
+    """
+    return DeprecatedAwaitableFloat(get_asynclib().current_time(), current_time)
+
+
+def get_all_backends() -> Tuple[str, ...]:
+    """Return a tuple of the names of all built-in backends."""
+    return BACKENDS
+
+
+def get_cancelled_exc_class() -> Type[BaseException]:
+    """Return the current async library's cancellation exception class."""
+    return get_asynclib().CancelledError
+
+
+#
+# Private API
+#
+
+
+@contextmanager
+def claim_worker_thread(backend: str) -> Generator[Any, None, None]:
+    module = sys.modules["anyio._backends._" + backend]
+    threadlocals.current_async_module = module
+    try:
+        yield
+    finally:
+        del threadlocals.current_async_module
+
+
+def get_asynclib(asynclib_name: Optional[str] = None) -> Any:
+    if asynclib_name is None:
+        asynclib_name = sniffio.current_async_library()
+
+    modulename = "anyio._backends._" + asynclib_name
+    try:
+        return sys.modules[modulename]
+    except KeyError:
+        return import_module(modulename)
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_exceptions.py b/myenv/lib/python3.9/site-packages/anyio/_core/_exceptions.py
new file mode 100644
index 0000000..db2bbcf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_exceptions.py
@@ -0,0 +1,93 @@
+from traceback import format_exception
+from typing import List
+
+
+class BrokenResourceError(Exception):
+    """
+    Raised when trying to use a resource that has been rendered unusable due to external causes
+    (e.g. a send stream whose peer has disconnected).
+    """
+
+
+class BrokenWorkerProcess(Exception):
+    """
+    Raised by :func:`run_sync_in_process` if the worker process terminates abruptly or otherwise
+    misbehaves.
+    """
+
+
+class BusyResourceError(Exception):
+    """Raised when two tasks are trying to read from or write to the same resource concurrently."""
+
+    def __init__(self, action: str):
+        super().__init__(f"Another task is already {action} this resource")
+
+
+class ClosedResourceError(Exception):
+    """Raised when trying to use a resource that has been closed."""
+
+
+class DelimiterNotFound(Exception):
+    """
+    Raised during :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
+    maximum number of bytes has been read without the delimiter being found.
+    """
+
+    def __init__(self, max_bytes: int) -> None:
+        super().__init__(
+            f"The delimiter was not found among the first {max_bytes} bytes"
+        )
+
+
+class EndOfStream(Exception):
+    """Raised when trying to read from a stream that has been closed from the other end."""
+
+
+class ExceptionGroup(BaseException):
+    """
+    Raised when multiple exceptions have been raised in a task group.
+
+    :var ~typing.Sequence[BaseException] exceptions: the sequence of exceptions raised together
+    """
+
+    SEPARATOR = "----------------------------\n"
+
+    exceptions: List[BaseException]
+
+    def __str__(self) -> str:
+        tracebacks = [
+            "".join(format_exception(type(exc), exc, exc.__traceback__))
+            for exc in self.exceptions
+        ]
+        return (
+            f"{len(self.exceptions)} exceptions were raised in the task group:\n"
+            f"{self.SEPARATOR}{self.SEPARATOR.join(tracebacks)}"
+        )
+
+    def __repr__(self) -> str:
+        exception_reprs = ", ".join(repr(exc) for exc in self.exceptions)
+        return f"<{self.__class__.__name__}: {exception_reprs}>"
+
+
+class IncompleteRead(Exception):
+    """
+    Raised during :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_exactly` or
+    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
+    connection is closed before the requested amount of bytes has been read.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(
+            "The stream was closed before the read operation could be completed"
+        )
+
+
+class TypedAttributeLookupError(LookupError):
+    """
+    Raised by :meth:`~anyio.TypedAttributeProvider.extra` when the given typed attribute is not
+    found and no default value has been given.
+    """
+
+
+class WouldBlock(Exception):
+    """Raised by ``X_nowait`` functions if ``X()`` would block."""
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_fileio.py b/myenv/lib/python3.9/site-packages/anyio/_core/_fileio.py
new file mode 100644
index 0000000..19c1e83
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_fileio.py
@@ -0,0 +1,607 @@
+import os
+import pathlib
+import sys
+from dataclasses import dataclass
+from functools import partial
+from os import PathLike
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    AnyStr,
+    AsyncIterator,
+    Callable,
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+    cast,
+    overload,
+)
+
+from .. import to_thread
+from ..abc import AsyncResource
+
+if sys.version_info >= (3, 8):
+    from typing import Final
+else:
+    from typing_extensions import Final
+
+if TYPE_CHECKING:
+    from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer
+else:
+    ReadableBuffer = OpenBinaryMode = OpenTextMode = WriteableBuffer = object
+
+
+class AsyncFile(AsyncResource, Generic[AnyStr]):
+    """
+    An asynchronous file object.
+
+    This class wraps a standard file object and provides async friendly versions of the following
+    blocking methods (where available on the original file object):
+
+    * read
+    * read1
+    * readline
+    * readlines
+    * readinto
+    * readinto1
+    * write
+    * writelines
+    * truncate
+    * seek
+    * tell
+    * flush
+
+    All other methods are directly passed through.
+
+    This class supports the asynchronous context manager protocol which closes the underlying file
+    at the end of the context block.
+
+    This class also supports asynchronous iteration::
+
+        async with await open_file(...) as f:
+            async for line in f:
+                print(line)
+    """
+
+    def __init__(self, fp: IO[AnyStr]) -> None:
+        self._fp: Any = fp
+
+    def __getattr__(self, name: str) -> object:
+        return getattr(self._fp, name)
+
+    @property
+    def wrapped(self) -> IO[AnyStr]:
+        """The wrapped file object."""
+        return self._fp
+
+    async def __aiter__(self) -> AsyncIterator[AnyStr]:
+        while True:
+            line = await self.readline()
+            if line:
+                yield line
+            else:
+                break
+
+    async def aclose(self) -> None:
+        return await to_thread.run_sync(self._fp.close)
+
+    async def read(self, size: int = -1) -> AnyStr:
+        return await to_thread.run_sync(self._fp.read, size)
+
+    async def read1(self: "AsyncFile[bytes]", size: int = -1) -> bytes:
+        return await to_thread.run_sync(self._fp.read1, size)
+
+    async def readline(self) -> AnyStr:
+        return await to_thread.run_sync(self._fp.readline)
+
+    async def readlines(self) -> List[AnyStr]:
+        return await to_thread.run_sync(self._fp.readlines)
+
+    async def readinto(self: "AsyncFile[bytes]", b: WriteableBuffer) -> bytes:
+        return await to_thread.run_sync(self._fp.readinto, b)
+
+    async def readinto1(self: "AsyncFile[bytes]", b: WriteableBuffer) -> bytes:
+        return await to_thread.run_sync(self._fp.readinto1, b)
+
+    @overload
+    async def write(self: "AsyncFile[bytes]", b: ReadableBuffer) -> int:
+        ...
+
+    @overload
+    async def write(self: "AsyncFile[str]", b: str) -> int:
+        ...
+
+    async def write(self, b: Union[ReadableBuffer, str]) -> int:
+        return await to_thread.run_sync(self._fp.write, b)
+
+    @overload
+    async def writelines(
+        self: "AsyncFile[bytes]", lines: Iterable[ReadableBuffer]
+    ) -> None:
+        ...
+
+    @overload
+    async def writelines(self: "AsyncFile[str]", lines: Iterable[str]) -> None:
+        ...
+
+    async def writelines(
+        self, lines: Union[Iterable[ReadableBuffer], Iterable[str]]
+    ) -> None:
+        return await to_thread.run_sync(self._fp.writelines, lines)
+
+    async def truncate(self, size: Optional[int] = None) -> int:
+        return await to_thread.run_sync(self._fp.truncate, size)
+
+    async def seek(self, offset: int, whence: Optional[int] = os.SEEK_SET) -> int:
+        return await to_thread.run_sync(self._fp.seek, offset, whence)
+
+    async def tell(self) -> int:
+        return await to_thread.run_sync(self._fp.tell)
+
+    async def flush(self) -> None:
+        return await to_thread.run_sync(self._fp.flush)
+
+
+@overload
+async def open_file(
+    file: Union[str, "PathLike[str]", int],
+    mode: OpenBinaryMode,
+    buffering: int = ...,
+    encoding: Optional[str] = ...,
+    errors: Optional[str] = ...,
+    newline: Optional[str] = ...,
+    closefd: bool = ...,
+    opener: Optional[Callable[[str, int], int]] = ...,
+) -> AsyncFile[bytes]:
+    ...
+
+
+@overload
+async def open_file(
+    file: Union[str, "PathLike[str]", int],
+    mode: OpenTextMode = ...,
+    buffering: int = ...,
+    encoding: Optional[str] = ...,
+    errors: Optional[str] = ...,
+    newline: Optional[str] = ...,
+    closefd: bool = ...,
+    opener: Optional[Callable[[str, int], int]] = ...,
+) -> AsyncFile[str]:
+    ...
+
+
+async def open_file(
+    file: Union[str, "PathLike[str]", int],
+    mode: str = "r",
+    buffering: int = -1,
+    encoding: Optional[str] = None,
+    errors: Optional[str] = None,
+    newline: Optional[str] = None,
+    closefd: bool = True,
+    opener: Optional[Callable[[str, int], int]] = None,
+) -> AsyncFile[Any]:
+    """
+    Open a file asynchronously.
+
+    The arguments are exactly the same as for the builtin :func:`open`.
+
+    :return: an asynchronous file object
+
+    """
+    fp = await to_thread.run_sync(
+        open, file, mode, buffering, encoding, errors, newline, closefd, opener
+    )
+    return AsyncFile(fp)
+
+
+def wrap_file(file: IO[AnyStr]) -> AsyncFile[AnyStr]:
+    """
+    Wrap an existing file as an asynchronous file.
+
+    :param file: an existing file-like object
+    :return: an asynchronous file object
+
+    """
+    return AsyncFile(file)
+
+
+@dataclass(eq=False)
+class _PathIterator(AsyncIterator["Path"]):
+    iterator: Iterator["PathLike[str]"]
+
+    async def __anext__(self) -> "Path":
+        nextval = await to_thread.run_sync(next, self.iterator, None, cancellable=True)
+        if nextval is None:
+            raise StopAsyncIteration from None
+
+        return Path(cast("PathLike[str]", nextval))
+
+
+class Path:
+    """
+    An asynchronous version of :class:`pathlib.Path`.
+
+    This class cannot be substituted for :class:`pathlib.Path` or :class:`pathlib.PurePath`, but
+    it is compatible with the :class:`os.PathLike` interface.
+
+    It implements the Python 3.10 version of :class:`pathlib.Path` interface, except for the
+    deprecated :meth:`~pathlib.Path.link_to` method.
+
+    Any methods that do disk I/O need to be awaited on. These methods are:
+
+    * :meth:`~pathlib.Path.absolute`
+    * :meth:`~pathlib.Path.chmod`
+    * :meth:`~pathlib.Path.cwd`
+    * :meth:`~pathlib.Path.exists`
+    * :meth:`~pathlib.Path.expanduser`
+    * :meth:`~pathlib.Path.group`
+    * :meth:`~pathlib.Path.hardlink_to`
+    * :meth:`~pathlib.Path.home`
+    * :meth:`~pathlib.Path.is_block_device`
+    * :meth:`~pathlib.Path.is_char_device`
+    * :meth:`~pathlib.Path.is_dir`
+    * :meth:`~pathlib.Path.is_fifo`
+    * :meth:`~pathlib.Path.is_file`
+    * :meth:`~pathlib.Path.is_mount`
+    * :meth:`~pathlib.Path.lchmod`
+    * :meth:`~pathlib.Path.lstat`
+    * :meth:`~pathlib.Path.mkdir`
+    * :meth:`~pathlib.Path.open`
+    * :meth:`~pathlib.Path.owner`
+    * :meth:`~pathlib.Path.read_bytes`
+    * :meth:`~pathlib.Path.read_text`
+    * :meth:`~pathlib.Path.readlink`
+    * :meth:`~pathlib.Path.rename`
+    * :meth:`~pathlib.Path.replace`
+    * :meth:`~pathlib.Path.rmdir`
+    * :meth:`~pathlib.Path.samefile`
+    * :meth:`~pathlib.Path.stat`
+    * :meth:`~pathlib.Path.touch`
+    * :meth:`~pathlib.Path.unlink`
+    * :meth:`~pathlib.Path.write_bytes`
+    * :meth:`~pathlib.Path.write_text`
+
+    Additionally, the following methods return an async iterator yielding :class:`~.Path` objects:
+
+    * :meth:`~pathlib.Path.glob`
+    * :meth:`~pathlib.Path.iterdir`
+    * :meth:`~pathlib.Path.rglob`
+    """
+
+    __slots__ = "_path", "__weakref__"
+
+    __weakref__: Any
+
+    def __init__(self, *args: Union[str, "PathLike[str]"]) -> None:
+        self._path: Final[pathlib.Path] = pathlib.Path(*args)
+
+    def __fspath__(self) -> str:
+        return self._path.__fspath__()
+
+    def __str__(self) -> str:
+        return self._path.__str__()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.as_posix()!r})"
+
+    def __bytes__(self) -> bytes:
+        return self._path.__bytes__()
+
+    def __hash__(self) -> int:
+        return self._path.__hash__()
+
+    def __eq__(self, other: object) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__eq__(target)
+
+    def __lt__(self, other: "Path") -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__lt__(target)
+
+    def __le__(self, other: "Path") -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__le__(target)
+
+    def __gt__(self, other: "Path") -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__gt__(target)
+
+    def __ge__(self, other: "Path") -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__ge__(target)
+
+    def __truediv__(self, other: Any) -> "Path":
+        return Path(self._path / other)
+
+    def __rtruediv__(self, other: Any) -> "Path":
+        return Path(other) / self
+
+    @property
+    def parts(self) -> Tuple[str, ...]:
+        return self._path.parts
+
+    @property
+    def drive(self) -> str:
+        return self._path.drive
+
+    @property
+    def root(self) -> str:
+        return self._path.root
+
+    @property
+    def anchor(self) -> str:
+        return self._path.anchor
+
+    @property
+    def parents(self) -> Sequence["Path"]:
+        return tuple(Path(p) for p in self._path.parents)
+
+    @property
+    def parent(self) -> "Path":
+        return Path(self._path.parent)
+
+    @property
+    def name(self) -> str:
+        return self._path.name
+
+    @property
+    def suffix(self) -> str:
+        return self._path.suffix
+
+    @property
+    def suffixes(self) -> List[str]:
+        return self._path.suffixes
+
+    @property
+    def stem(self) -> str:
+        return self._path.stem
+
+    async def absolute(self) -> "Path":
+        path = await to_thread.run_sync(self._path.absolute)
+        return Path(path)
+
+    def as_posix(self) -> str:
+        return self._path.as_posix()
+
+    def as_uri(self) -> str:
+        return self._path.as_uri()
+
+    def match(self, path_pattern: str) -> bool:
+        return self._path.match(path_pattern)
+
+    def is_relative_to(self, *other: Union[str, "PathLike[str]"]) -> bool:
+        try:
+            self.relative_to(*other)
+            return True
+        except ValueError:
+            return False
+
+    async def chmod(self, mode: int, *, follow_symlinks: bool = True) -> None:
+        func = partial(os.chmod, follow_symlinks=follow_symlinks)
+        return await to_thread.run_sync(func, self._path, mode)
+
+    @classmethod
+    async def cwd(cls) -> "Path":
+        path = await to_thread.run_sync(pathlib.Path.cwd)
+        return cls(path)
+
+    async def exists(self) -> bool:
+        return await to_thread.run_sync(self._path.exists, cancellable=True)
+
+    async def expanduser(self) -> "Path":
+        return Path(await to_thread.run_sync(self._path.expanduser, cancellable=True))
+
+    def glob(self, pattern: str) -> AsyncIterator["Path"]:
+        gen = self._path.glob(pattern)
+        return _PathIterator(gen)
+
+    async def group(self) -> str:
+        return await to_thread.run_sync(self._path.group, cancellable=True)
+
+    async def hardlink_to(self, target: Union[str, pathlib.Path, "Path"]) -> None:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(os.link, target, self)
+
+    @classmethod
+    async def home(cls) -> "Path":
+        home_path = await to_thread.run_sync(pathlib.Path.home)
+        return cls(home_path)
+
+    def is_absolute(self) -> bool:
+        return self._path.is_absolute()
+
+    async def is_block_device(self) -> bool:
+        return await to_thread.run_sync(self._path.is_block_device, cancellable=True)
+
+    async def is_char_device(self) -> bool:
+        return await to_thread.run_sync(self._path.is_char_device, cancellable=True)
+
+    async def is_dir(self) -> bool:
+        return await to_thread.run_sync(self._path.is_dir, cancellable=True)
+
+    async def is_fifo(self) -> bool:
+        return await to_thread.run_sync(self._path.is_fifo, cancellable=True)
+
+    async def is_file(self) -> bool:
+        return await to_thread.run_sync(self._path.is_file, cancellable=True)
+
+    async def is_mount(self) -> bool:
+        return await to_thread.run_sync(os.path.ismount, self._path, cancellable=True)
+
+    def is_reserved(self) -> bool:
+        return self._path.is_reserved()
+
+    async def is_socket(self) -> bool:
+        return await to_thread.run_sync(self._path.is_socket, cancellable=True)
+
+    async def is_symlink(self) -> bool:
+        return await to_thread.run_sync(self._path.is_symlink, cancellable=True)
+
+    def iterdir(self) -> AsyncIterator["Path"]:
+        gen = self._path.iterdir()
+        return _PathIterator(gen)
+
+    def joinpath(self, *args: Union[str, "PathLike[str]"]) -> "Path":
+        return Path(self._path.joinpath(*args))
+
+    async def lchmod(self, mode: int) -> None:
+        await to_thread.run_sync(self._path.lchmod, mode)
+
+    async def lstat(self) -> os.stat_result:
+        return await to_thread.run_sync(self._path.lstat, cancellable=True)
+
+    async def mkdir(
+        self, mode: int = 0o777, parents: bool = False, exist_ok: bool = False
+    ) -> None:
+        await to_thread.run_sync(self._path.mkdir, mode, parents, exist_ok)
+
+    @overload
+    async def open(
+        self,
+        mode: OpenBinaryMode,
+        buffering: int = ...,
+        encoding: Optional[str] = ...,
+        errors: Optional[str] = ...,
+        newline: Optional[str] = ...,
+    ) -> AsyncFile[bytes]:
+        ...
+
+    @overload
+    async def open(
+        self,
+        mode: OpenTextMode = ...,
+        buffering: int = ...,
+        encoding: Optional[str] = ...,
+        errors: Optional[str] = ...,
+        newline: Optional[str] = ...,
+    ) -> AsyncFile[str]:
+        ...
+
+    async def open(
+        self,
+        mode: str = "r",
+        buffering: int = -1,
+        encoding: Optional[str] = None,
+        errors: Optional[str] = None,
+        newline: Optional[str] = None,
+    ) -> AsyncFile[Any]:
+        fp = await to_thread.run_sync(
+            self._path.open, mode, buffering, encoding, errors, newline
+        )
+        return AsyncFile(fp)
+
+    async def owner(self) -> str:
+        return await to_thread.run_sync(self._path.owner, cancellable=True)
+
+    async def read_bytes(self) -> bytes:
+        return await to_thread.run_sync(self._path.read_bytes)
+
+    async def read_text(
+        self, encoding: Optional[str] = None, errors: Optional[str] = None
+    ) -> str:
+        return await to_thread.run_sync(self._path.read_text, encoding, errors)
+
+    def relative_to(self, *other: Union[str, "PathLike[str]"]) -> "Path":
+        return Path(self._path.relative_to(*other))
+
+    async def readlink(self) -> "Path":
+        target = await to_thread.run_sync(os.readlink, self._path)
+        return Path(cast(str, target))
+
+    async def rename(self, target: Union[str, pathlib.PurePath, "Path"]) -> "Path":
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(self._path.rename, target)
+        return Path(target)
+
+    async def replace(self, target: Union[str, pathlib.PurePath, "Path"]) -> "Path":
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(self._path.replace, target)
+        return Path(target)
+
+    async def resolve(self, strict: bool = False) -> "Path":
+        func = partial(self._path.resolve, strict=strict)
+        return Path(await to_thread.run_sync(func, cancellable=True))
+
+    def rglob(self, pattern: str) -> AsyncIterator["Path"]:
+        gen = self._path.rglob(pattern)
+        return _PathIterator(gen)
+
+    async def rmdir(self) -> None:
+        await to_thread.run_sync(self._path.rmdir)
+
+    async def samefile(
+        self, other_path: Union[str, bytes, int, pathlib.Path, "Path"]
+    ) -> bool:
+        if isinstance(other_path, Path):
+            other_path = other_path._path
+
+        return await to_thread.run_sync(
+            self._path.samefile, other_path, cancellable=True
+        )
+
+    async def stat(self, *, follow_symlinks: bool = True) -> os.stat_result:
+        func = partial(os.stat, follow_symlinks=follow_symlinks)
+        return await to_thread.run_sync(func, self._path, cancellable=True)
+
+    async def symlink_to(
+        self,
+        target: Union[str, pathlib.Path, "Path"],
+        target_is_directory: bool = False,
+    ) -> None:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(self._path.symlink_to, target, target_is_directory)
+
+    async def touch(self, mode: int = 0o666, exist_ok: bool = True) -> None:
+        await to_thread.run_sync(self._path.touch, mode, exist_ok)
+
+    async def unlink(self, missing_ok: bool = False) -> None:
+        try:
+            await to_thread.run_sync(self._path.unlink)
+        except FileNotFoundError:
+            if not missing_ok:
+                raise
+
+    def with_name(self, name: str) -> "Path":
+        return Path(self._path.with_name(name))
+
+    def with_stem(self, stem: str) -> "Path":
+        return Path(self._path.with_name(stem + self._path.suffix))
+
+    def with_suffix(self, suffix: str) -> "Path":
+        return Path(self._path.with_suffix(suffix))
+
+    async def write_bytes(self, data: bytes) -> int:
+        return await to_thread.run_sync(self._path.write_bytes, data)
+
+    async def write_text(
+        self,
+        data: str,
+        encoding: Optional[str] = None,
+        errors: Optional[str] = None,
+        newline: Optional[str] = None,
+    ) -> int:
+        # Path.write_text() does not support the "newline" parameter before Python 3.10
+        def sync_write_text() -> int:
+            with self._path.open(
+                "w", encoding=encoding, errors=errors, newline=newline
+            ) as fp:
+                return fp.write(data)
+
+        return await to_thread.run_sync(sync_write_text)
+
+
+PathLike.register(Path)
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_resources.py b/myenv/lib/python3.9/site-packages/anyio/_core/_resources.py
new file mode 100644
index 0000000..b9414f7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_resources.py
@@ -0,0 +1,16 @@
+from ..abc import AsyncResource
+from ._tasks import CancelScope
+
+
+async def aclose_forcefully(resource: AsyncResource) -> None:
+    """
+    Close an asynchronous resource in a cancelled scope.
+
+    Doing this closes the resource without waiting on anything.
+
+    :param resource: the resource to close
+
+    """
+    with CancelScope() as scope:
+        scope.cancel()
+        await resource.aclose()
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_signals.py b/myenv/lib/python3.9/site-packages/anyio/_core/_signals.py
new file mode 100644
index 0000000..02234fd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_signals.py
@@ -0,0 +1,24 @@
+from typing import AsyncIterator
+
+from ._compat import DeprecatedAsyncContextManager
+from ._eventloop import get_asynclib
+
+
+def open_signal_receiver(
+    *signals: int,
+) -> DeprecatedAsyncContextManager[AsyncIterator[int]]:
+    """
+    Start receiving operating system signals.
+
+    :param signals: signals to receive (e.g. ``signal.SIGINT``)
+    :return: an asynchronous context manager for an asynchronous iterator which yields signal
+        numbers
+
+    .. warning:: Windows does not support signals natively so it is best to avoid relying on this
+        in cross-platform applications.
+
+    .. warning:: On asyncio, this permanently replaces any previous signal handler for the given
+        signals, as set via :meth:`~asyncio.loop.add_signal_handler`.
+
+    """
+    return get_asynclib().open_signal_receiver(*signals)
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_sockets.py b/myenv/lib/python3.9/site-packages/anyio/_core/_sockets.py
new file mode 100644
index 0000000..ca85d30
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_sockets.py
@@ -0,0 +1,587 @@
+import socket
+import ssl
+import sys
+from ipaddress import IPv6Address, ip_address
+from os import PathLike, chmod
+from pathlib import Path
+from socket import AddressFamily, SocketKind
+from typing import Awaitable, List, Optional, Tuple, Union, cast, overload
+
+from .. import to_thread
+from ..abc import (
+    ConnectedUDPSocket,
+    IPAddressType,
+    IPSockAddrType,
+    SocketListener,
+    SocketStream,
+    UDPSocket,
+    UNIXSocketStream,
+)
+from ..streams.stapled import MultiListener
+from ..streams.tls import TLSStream
+from ._eventloop import get_asynclib
+from ._resources import aclose_forcefully
+from ._synchronization import Event
+from ._tasks import create_task_group, move_on_after
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+IPPROTO_IPV6 = getattr(socket, "IPPROTO_IPV6", 41)  # https://bugs.python.org/issue29515
+
+GetAddrInfoReturnType = List[
+    Tuple[AddressFamily, SocketKind, int, str, Tuple[str, int]]
+]
+AnyIPAddressFamily = Literal[
+    AddressFamily.AF_UNSPEC, AddressFamily.AF_INET, AddressFamily.AF_INET6
+]
+IPAddressFamily = Literal[AddressFamily.AF_INET, AddressFamily.AF_INET6]
+
+
+# tls_hostname given
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = ...,
+    ssl_context: Optional[ssl.SSLContext] = ...,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: str,
+    happy_eyeballs_delay: float = ...,
+) -> TLSStream:
+    ...
+
+
+# ssl_context given
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = ...,
+    ssl_context: ssl.SSLContext,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: Optional[str] = ...,
+    happy_eyeballs_delay: float = ...,
+) -> TLSStream:
+    ...
+
+
+# tls=True
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = ...,
+    tls: Literal[True],
+    ssl_context: Optional[ssl.SSLContext] = ...,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: Optional[str] = ...,
+    happy_eyeballs_delay: float = ...,
+) -> TLSStream:
+    ...
+
+
+# tls=False
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = ...,
+    tls: Literal[False],
+    ssl_context: Optional[ssl.SSLContext] = ...,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: Optional[str] = ...,
+    happy_eyeballs_delay: float = ...,
+) -> SocketStream:
+    ...
+
+
+# No TLS arguments
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = ...,
+    happy_eyeballs_delay: float = ...,
+) -> SocketStream:
+    ...
+
+
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = None,
+    tls: bool = False,
+    ssl_context: Optional[ssl.SSLContext] = None,
+    tls_standard_compatible: bool = True,
+    tls_hostname: Optional[str] = None,
+    happy_eyeballs_delay: float = 0.25,
+) -> Union[SocketStream, TLSStream]:
+    """
+    Connect to a host using the TCP protocol.
+
+    This function implements the stateless version of the Happy Eyeballs algorithm (RFC 6555).
+    If ``address`` is a host name that resolves to multiple IP addresses, each one is tried until
+    one connection attempt succeeds. If the first attempt does not connected within 250
+    milliseconds, a second attempt is started using the next address in the list, and so on.
+    On IPv6 enabled systems, an IPv6 address (if available) is tried first.
+
+    When the connection has been established, a TLS handshake will be done if either
+    ``ssl_context`` or ``tls_hostname`` is not ``None``, or if ``tls`` is ``True``.
+
+    :param remote_host: the IP address or host name to connect to
+    :param remote_port: port on the target host to connect to
+    :param local_host: the interface address or name to bind the socket to before connecting
+    :param tls: ``True`` to do a TLS handshake with the connected stream and return a
+        :class:`~anyio.streams.tls.TLSStream` instead
+    :param ssl_context: the SSL context object to use (if omitted, a default context is created)
+    :param tls_standard_compatible: If ``True``, performs the TLS shutdown handshake before closing
+        the stream and requires that the server does this as well. Otherwise,
+        :exc:`~ssl.SSLEOFError` may be raised during reads from the stream.
+        Some protocols, such as HTTP, require this option to be ``False``.
+        See :meth:`~ssl.SSLContext.wrap_socket` for details.
+    :param tls_hostname: host name to check the server certificate against (defaults to the value
+        of ``remote_host``)
+    :param happy_eyeballs_delay: delay (in seconds) before starting the next connection attempt
+    :return: a socket stream object if no TLS handshake was done, otherwise a TLS stream
+    :raises OSError: if the connection attempt fails
+
+    """
+    # Placed here due to https://github.com/python/mypy/issues/7057
+    connected_stream: Optional[SocketStream] = None
+
+    async def try_connect(remote_host: str, event: Event) -> None:
+        nonlocal connected_stream
+        try:
+            stream = await asynclib.connect_tcp(remote_host, remote_port, local_address)
+        except OSError as exc:
+            oserrors.append(exc)
+            return
+        else:
+            if connected_stream is None:
+                connected_stream = stream
+                tg.cancel_scope.cancel()
+            else:
+                await stream.aclose()
+        finally:
+            event.set()
+
+    asynclib = get_asynclib()
+    local_address: Optional[IPSockAddrType] = None
+    family = socket.AF_UNSPEC
+    if local_host:
+        gai_res = await getaddrinfo(str(local_host), None)
+        family, *_, local_address = gai_res[0]
+
+    target_host = str(remote_host)
+    try:
+        addr_obj = ip_address(remote_host)
+    except ValueError:
+        # getaddrinfo() will raise an exception if name resolution fails
+        gai_res = await getaddrinfo(
+            target_host, remote_port, family=family, type=socket.SOCK_STREAM
+        )
+
+        # Organize the list so that the first address is an IPv6 address (if available) and the
+        # second one is an IPv4 addresses. The rest can be in whatever order.
+        v6_found = v4_found = False
+        target_addrs: List[Tuple[socket.AddressFamily, str]] = []
+        for af, *rest, sa in gai_res:
+            if af == socket.AF_INET6 and not v6_found:
+                v6_found = True
+                target_addrs.insert(0, (af, sa[0]))
+            elif af == socket.AF_INET and not v4_found and v6_found:
+                v4_found = True
+                target_addrs.insert(1, (af, sa[0]))
+            else:
+                target_addrs.append((af, sa[0]))
+    else:
+        if isinstance(addr_obj, IPv6Address):
+            target_addrs = [(socket.AF_INET6, addr_obj.compressed)]
+        else:
+            target_addrs = [(socket.AF_INET, addr_obj.compressed)]
+
+    oserrors: List[OSError] = []
+    async with create_task_group() as tg:
+        for i, (af, addr) in enumerate(target_addrs):
+            event = Event()
+            tg.start_soon(try_connect, addr, event)
+            with move_on_after(happy_eyeballs_delay):
+                await event.wait()
+
+    if connected_stream is None:
+        cause = oserrors[0] if len(oserrors) == 1 else asynclib.ExceptionGroup(oserrors)
+        raise OSError("All connection attempts failed") from cause
+
+    if tls or tls_hostname or ssl_context:
+        try:
+            return await TLSStream.wrap(
+                connected_stream,
+                server_side=False,
+                hostname=tls_hostname or str(remote_host),
+                ssl_context=ssl_context,
+                standard_compatible=tls_standard_compatible,
+            )
+        except BaseException:
+            await aclose_forcefully(connected_stream)
+            raise
+
+    return connected_stream
+
+
+async def connect_unix(path: Union[str, "PathLike[str]"]) -> UNIXSocketStream:
+    """
+    Connect to the given UNIX socket.
+
+    Not available on Windows.
+
+    :param path: path to the socket
+    :return: a socket stream object
+
+    """
+    path = str(Path(path))
+    return await get_asynclib().connect_unix(path)
+
+
+async def create_tcp_listener(
+    *,
+    local_host: Optional[IPAddressType] = None,
+    local_port: int = 0,
+    family: AnyIPAddressFamily = socket.AddressFamily.AF_UNSPEC,
+    backlog: int = 65536,
+    reuse_port: bool = False,
+) -> MultiListener[SocketStream]:
+    """
+    Create a TCP socket listener.
+
+    :param local_port: port number to listen on
+    :param local_host: IP address of the interface to listen on. If omitted, listen on all IPv4
+        and IPv6 interfaces. To listen on all interfaces on a specific address family, use
+        ``0.0.0.0`` for IPv4 or ``::`` for IPv6.
+    :param family: address family (used if ``interface`` was omitted)
+    :param backlog: maximum number of queued incoming connections (up to a maximum of 2**16, or
+        65536)
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same address/port
+        (not supported on Windows)
+    :return: a list of listener objects
+
+    """
+    asynclib = get_asynclib()
+    backlog = min(backlog, 65536)
+    local_host = str(local_host) if local_host is not None else None
+    gai_res = await getaddrinfo(
+        local_host,  # type: ignore[arg-type]
+        local_port,
+        family=family,
+        type=socket.SOCK_STREAM,
+        flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG,
+    )
+    listeners: List[SocketListener] = []
+    try:
+        # The set() is here to work around a glibc bug:
+        # https://sourceware.org/bugzilla/show_bug.cgi?id=14969
+        for fam, *_, sockaddr in sorted(set(gai_res)):
+            raw_socket = socket.socket(fam)
+            raw_socket.setblocking(False)
+
+            # For Windows, enable exclusive address use. For others, enable address reuse.
+            if sys.platform == "win32":
+                raw_socket.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
+            else:
+                raw_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+            if reuse_port:
+                raw_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+
+            # If only IPv6 was requested, disable dual stack operation
+            if fam == socket.AF_INET6:
+                raw_socket.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
+
+            raw_socket.bind(sockaddr)
+            raw_socket.listen(backlog)
+            listener = asynclib.TCPSocketListener(raw_socket)
+            listeners.append(listener)
+    except BaseException:
+        for listener in listeners:
+            await listener.aclose()
+
+        raise
+
+    return MultiListener(listeners)
+
+
+async def create_unix_listener(
+    path: Union[str, "PathLike[str]"],
+    *,
+    mode: Optional[int] = None,
+    backlog: int = 65536,
+) -> SocketListener:
+    """
+    Create a UNIX socket listener.
+
+    Not available on Windows.
+
+    :param path: path of the socket
+    :param mode: permissions to set on the socket
+    :param backlog: maximum number of queued incoming connections (up to a maximum of 2**16, or
+        65536)
+    :return: a listener object
+
+    .. versionchanged:: 3.0
+        If a socket already exists on the file system in the given path, it will be removed first.
+
+    """
+    path_str = str(path)
+    path = Path(path)
+    if path.is_socket():
+        path.unlink()
+
+    backlog = min(backlog, 65536)
+    raw_socket = socket.socket(socket.AF_UNIX)
+    raw_socket.setblocking(False)
+    try:
+        await to_thread.run_sync(raw_socket.bind, path_str, cancellable=True)
+        if mode is not None:
+            await to_thread.run_sync(chmod, path_str, mode, cancellable=True)
+
+        raw_socket.listen(backlog)
+        return get_asynclib().UNIXSocketListener(raw_socket)
+    except BaseException:
+        raw_socket.close()
+        raise
+
+
+async def create_udp_socket(
+    family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC,
+    *,
+    local_host: Optional[IPAddressType] = None,
+    local_port: int = 0,
+    reuse_port: bool = False,
+) -> UDPSocket:
+    """
+    Create a UDP socket.
+
+    If ``port`` has been given, the socket will be bound to this port on the local machine,
+    making this socket suitable for providing UDP based services.
+
+    :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically determined from
+        ``local_host`` if omitted
+    :param local_host: IP address or host name of the local interface to bind to
+    :param local_port: local port to bind to
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same address/port
+        (not supported on Windows)
+    :return: a UDP socket
+
+    """
+    if family is AddressFamily.AF_UNSPEC and not local_host:
+        raise ValueError('Either "family" or "local_host" must be given')
+
+    if local_host:
+        gai_res = await getaddrinfo(
+            str(local_host),
+            local_port,
+            family=family,
+            type=socket.SOCK_DGRAM,
+            flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG,
+        )
+        family = cast(AnyIPAddressFamily, gai_res[0][0])
+        local_address = gai_res[0][-1]
+    elif family is AddressFamily.AF_INET6:
+        local_address = ("::", 0)
+    else:
+        local_address = ("0.0.0.0", 0)
+
+    return await get_asynclib().create_udp_socket(
+        family, local_address, None, reuse_port
+    )
+
+
+async def create_connected_udp_socket(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC,
+    local_host: Optional[IPAddressType] = None,
+    local_port: int = 0,
+    reuse_port: bool = False,
+) -> ConnectedUDPSocket:
+    """
+    Create a connected UDP socket.
+
+    Connected UDP sockets can only communicate with the specified remote host/port, and any packets
+    sent from other sources are dropped.
+
+    :param remote_host: remote host to set as the default target
+    :param remote_port: port on the remote host to set as the default target
+    :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically determined from
+        ``local_host`` or ``remote_host`` if omitted
+    :param local_host: IP address or host name of the local interface to bind to
+    :param local_port: local port to bind to
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same address/port
+        (not supported on Windows)
+    :return: a connected UDP socket
+
+    """
+    local_address = None
+    if local_host:
+        gai_res = await getaddrinfo(
+            str(local_host),
+            local_port,
+            family=family,
+            type=socket.SOCK_DGRAM,
+            flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG,
+        )
+        family = cast(AnyIPAddressFamily, gai_res[0][0])
+        local_address = gai_res[0][-1]
+
+    gai_res = await getaddrinfo(
+        str(remote_host), remote_port, family=family, type=socket.SOCK_DGRAM
+    )
+    family = cast(AnyIPAddressFamily, gai_res[0][0])
+    remote_address = gai_res[0][-1]
+
+    return await get_asynclib().create_udp_socket(
+        family, local_address, remote_address, reuse_port
+    )
+
+
+async def getaddrinfo(
+    host: Union[bytearray, bytes, str],
+    port: Union[str, int, None],
+    *,
+    family: Union[int, AddressFamily] = 0,
+    type: Union[int, SocketKind] = 0,
+    proto: int = 0,
+    flags: int = 0,
+) -> GetAddrInfoReturnType:
+    """
+    Look up a numeric IP address given a host name.
+
+    Internationalized domain names are translated according to the (non-transitional) IDNA 2008
+    standard.
+
+    .. note:: 4-tuple IPv6 socket addresses are automatically converted to 2-tuples of
+        (host, port), unlike what :func:`socket.getaddrinfo` does.
+
+    :param host: host name
+    :param port: port number
+    :param family: socket family (`'AF_INET``, ...)
+    :param type: socket type (``SOCK_STREAM``, ...)
+    :param proto: protocol number
+    :param flags: flags to pass to upstream ``getaddrinfo()``
+    :return: list of tuples containing (family, type, proto, canonname, sockaddr)
+
+    .. seealso:: :func:`socket.getaddrinfo`
+
+    """
+    # Handle unicode hostnames
+    if isinstance(host, str):
+        try:
+            encoded_host = host.encode("ascii")
+        except UnicodeEncodeError:
+            import idna
+
+            encoded_host = idna.encode(host, uts46=True)
+    else:
+        encoded_host = host
+
+    gai_res = await get_asynclib().getaddrinfo(
+        encoded_host, port, family=family, type=type, proto=proto, flags=flags
+    )
+    return [
+        (family, type, proto, canonname, convert_ipv6_sockaddr(sockaddr))
+        for family, type, proto, canonname, sockaddr in gai_res
+    ]
+
+
+def getnameinfo(sockaddr: IPSockAddrType, flags: int = 0) -> Awaitable[Tuple[str, str]]:
+    """
+    Look up the host name of an IP address.
+
+    :param sockaddr: socket address (e.g. (ipaddress, port) for IPv4)
+    :param flags: flags to pass to upstream ``getnameinfo()``
+    :return: a tuple of (host name, service name)
+
+    .. seealso:: :func:`socket.getnameinfo`
+
+    """
+    return get_asynclib().getnameinfo(sockaddr, flags)
+
+
+def wait_socket_readable(sock: socket.socket) -> Awaitable[None]:
+    """
+    Wait until the given socket has data to be read.
+
+    This does **NOT** work on Windows when using the asyncio backend with a proactor event loop
+    (default on py3.8+).
+
+    .. warning:: Only use this on raw sockets that have not been wrapped by any higher level
+        constructs like socket streams!
+
+    :param sock: a socket object
+    :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the
+        socket to become readable
+    :raises ~anyio.BusyResourceError: if another task is already waiting for the socket
+        to become readable
+
+    """
+    return get_asynclib().wait_socket_readable(sock)
+
+
+def wait_socket_writable(sock: socket.socket) -> Awaitable[None]:
+    """
+    Wait until the given socket can be written to.
+
+    This does **NOT** work on Windows when using the asyncio backend with a proactor event loop
+    (default on py3.8+).
+
+    .. warning:: Only use this on raw sockets that have not been wrapped by any higher level
+        constructs like socket streams!
+
+    :param sock: a socket object
+    :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the
+        socket to become writable
+    :raises ~anyio.BusyResourceError: if another task is already waiting for the socket
+        to become writable
+
+    """
+    return get_asynclib().wait_socket_writable(sock)
+
+
+#
+# Private API
+#
+
+
+def convert_ipv6_sockaddr(
+    sockaddr: Union[Tuple[str, int, int, int], Tuple[str, int]]
+) -> Tuple[str, int]:
+    """
+    Convert a 4-tuple IPv6 socket address to a 2-tuple (address, port) format.
+
+    If the scope ID is nonzero, it is added to the address, separated with ``%``.
+    Otherwise the flow id and scope id are simply cut off from the tuple.
+    Any other kinds of socket addresses are returned as-is.
+
+    :param sockaddr: the result of :meth:`~socket.socket.getsockname`
+    :return: the converted socket address
+
+    """
+    # This is more complicated than it should be because of MyPy
+    if isinstance(sockaddr, tuple) and len(sockaddr) == 4:
+        host, port, flowinfo, scope_id = cast(Tuple[str, int, int, int], sockaddr)
+        if scope_id:
+            # Add scope_id to the address
+            return f"{host}%{scope_id}", port
+        else:
+            return host, port
+    else:
+        return cast(Tuple[str, int], sockaddr)
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_streams.py b/myenv/lib/python3.9/site-packages/anyio/_core/_streams.py
new file mode 100644
index 0000000..58954a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_streams.py
@@ -0,0 +1,45 @@
+import math
+from typing import Any, Optional, Tuple, Type, TypeVar, overload
+
+from ..streams.memory import (
+    MemoryObjectReceiveStream,
+    MemoryObjectSendStream,
+    MemoryObjectStreamState,
+)
+
+T_Item = TypeVar("T_Item")
+
+
+@overload
+def create_memory_object_stream(
+    max_buffer_size: float, item_type: Type[T_Item]
+) -> Tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]]:
+    ...
+
+
+@overload
+def create_memory_object_stream(
+    max_buffer_size: float = 0,
+) -> Tuple[MemoryObjectSendStream[Any], MemoryObjectReceiveStream[Any]]:
+    ...
+
+
+def create_memory_object_stream(
+    max_buffer_size: float = 0, item_type: Optional[Type[T_Item]] = None
+) -> Tuple[MemoryObjectSendStream[Any], MemoryObjectReceiveStream[Any]]:
+    """
+    Create a memory object stream.
+
+    :param max_buffer_size: number of items held in the buffer until ``send()`` starts blocking
+    :param item_type: type of item, for marking the streams with the right generic type for
+        static typing (not used at run time)
+    :return: a tuple of (send stream, receive stream)
+
+    """
+    if max_buffer_size != math.inf and not isinstance(max_buffer_size, int):
+        raise ValueError("max_buffer_size must be either an integer or math.inf")
+    if max_buffer_size < 0:
+        raise ValueError("max_buffer_size cannot be negative")
+
+    state: MemoryObjectStreamState = MemoryObjectStreamState(max_buffer_size)
+    return MemoryObjectSendStream(state), MemoryObjectReceiveStream(state)
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_subprocesses.py b/myenv/lib/python3.9/site-packages/anyio/_core/_subprocesses.py
new file mode 100644
index 0000000..43fa6b6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_subprocesses.py
@@ -0,0 +1,136 @@
+from io import BytesIO
+from os import PathLike
+from subprocess import DEVNULL, PIPE, CalledProcessError, CompletedProcess
+from typing import (
+    IO,
+    Any,
+    AsyncIterable,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+)
+
+from ..abc import Process
+from ._eventloop import get_asynclib
+from ._tasks import create_task_group
+
+
+async def run_process(
+    command: Union[str, bytes, Sequence[Union[str, bytes]]],
+    *,
+    input: Optional[bytes] = None,
+    stdout: Union[int, IO[Any], None] = PIPE,
+    stderr: Union[int, IO[Any], None] = PIPE,
+    check: bool = True,
+    cwd: Union[str, bytes, "PathLike[str]", None] = None,
+    env: Optional[Mapping[str, str]] = None,
+    start_new_session: bool = False,
+) -> "CompletedProcess[bytes]":
+    """
+    Run an external command in a subprocess and wait until it completes.
+
+    .. seealso:: :func:`subprocess.run`
+
+    :param command: either a string to pass to the shell, or an iterable of strings containing the
+        executable name or path and its arguments
+    :param input: bytes passed to the standard input of the subprocess
+    :param stdout: either :data:`subprocess.PIPE` or :data:`subprocess.DEVNULL`
+    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL` or
+        :data:`subprocess.STDOUT`
+    :param check: if ``True``, raise :exc:`~subprocess.CalledProcessError` if the process
+        terminates with a return code other than 0
+    :param cwd: If not ``None``, change the working directory to this before running the command
+    :param env: if not ``None``, this mapping replaces the inherited environment variables from the
+        parent process
+    :param start_new_session: if ``true`` the setsid() system call will be made in the child
+        process prior to the execution of the subprocess. (POSIX only)
+    :return: an object representing the completed process
+    :raises ~subprocess.CalledProcessError: if ``check`` is ``True`` and the process exits with a
+        nonzero return code
+
+    """
+
+    async def drain_stream(stream: AsyncIterable[bytes], index: int) -> None:
+        buffer = BytesIO()
+        async for chunk in stream:
+            buffer.write(chunk)
+
+        stream_contents[index] = buffer.getvalue()
+
+    async with await open_process(
+        command,
+        stdin=PIPE if input else DEVNULL,
+        stdout=stdout,
+        stderr=stderr,
+        cwd=cwd,
+        env=env,
+        start_new_session=start_new_session,
+    ) as process:
+        stream_contents: List[Optional[bytes]] = [None, None]
+        try:
+            async with create_task_group() as tg:
+                if process.stdout:
+                    tg.start_soon(drain_stream, process.stdout, 0)
+                if process.stderr:
+                    tg.start_soon(drain_stream, process.stderr, 1)
+                if process.stdin and input:
+                    await process.stdin.send(input)
+                    await process.stdin.aclose()
+
+                await process.wait()
+        except BaseException:
+            process.kill()
+            raise
+
+    output, errors = stream_contents
+    if check and process.returncode != 0:
+        raise CalledProcessError(cast(int, process.returncode), command, output, errors)
+
+    return CompletedProcess(command, cast(int, process.returncode), output, errors)
+
+
+async def open_process(
+    command: Union[str, bytes, Sequence[Union[str, bytes]]],
+    *,
+    stdin: Union[int, IO[Any], None] = PIPE,
+    stdout: Union[int, IO[Any], None] = PIPE,
+    stderr: Union[int, IO[Any], None] = PIPE,
+    cwd: Union[str, bytes, "PathLike[str]", None] = None,
+    env: Optional[Mapping[str, str]] = None,
+    start_new_session: bool = False,
+) -> Process:
+    """
+    Start an external command in a subprocess.
+
+    .. seealso:: :class:`subprocess.Popen`
+
+    :param command: either a string to pass to the shell, or an iterable of strings containing the
+        executable name or path and its arguments
+    :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, a
+        file-like object, or ``None``
+    :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        a file-like object, or ``None``
+    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        :data:`subprocess.STDOUT`, a file-like object, or ``None``
+    :param cwd: If not ``None``, the working directory is changed before executing
+    :param env: If env is not ``None``, it must be a mapping that defines the environment
+        variables for the new process
+    :param start_new_session: if ``true`` the setsid() system call will be made in the child
+        process prior to the execution of the subprocess. (POSIX only)
+    :return: an asynchronous process object
+
+    """
+    shell = isinstance(command, str)
+    return await get_asynclib().open_process(
+        command,
+        shell=shell,
+        stdin=stdin,
+        stdout=stdout,
+        stderr=stderr,
+        cwd=cwd,
+        env=env,
+        start_new_session=start_new_session,
+    )
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_synchronization.py b/myenv/lib/python3.9/site-packages/anyio/_core/_synchronization.py
new file mode 100644
index 0000000..15d4afc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_synchronization.py
@@ -0,0 +1,595 @@
+from collections import deque
+from dataclasses import dataclass
+from types import TracebackType
+from typing import Deque, Optional, Tuple, Type
+from warnings import warn
+
+from ..lowlevel import cancel_shielded_checkpoint, checkpoint, checkpoint_if_cancelled
+from ._compat import DeprecatedAwaitable
+from ._eventloop import get_asynclib
+from ._exceptions import BusyResourceError, WouldBlock
+from ._tasks import CancelScope
+from ._testing import TaskInfo, get_current_task
+
+
+@dataclass(frozen=True)
+class EventStatistics:
+    """
+    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Event.wait`
+    """
+
+    tasks_waiting: int
+
+
+@dataclass(frozen=True)
+class CapacityLimiterStatistics:
+    """
+    :ivar int borrowed_tokens: number of tokens currently borrowed by tasks
+    :ivar float total_tokens: total number of available tokens
+    :ivar tuple borrowers: tasks or other objects currently holding tokens borrowed from this
+        limiter
+    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.CapacityLimiter.acquire` or
+        :meth:`~.CapacityLimiter.acquire_on_behalf_of`
+    """
+
+    borrowed_tokens: int
+    total_tokens: float
+    borrowers: Tuple[object, ...]
+    tasks_waiting: int
+
+
+@dataclass(frozen=True)
+class LockStatistics:
+    """
+    :ivar bool locked: flag indicating if this lock is locked or not
+    :ivar ~anyio.TaskInfo owner: task currently holding the lock (or ``None`` if the lock is not
+        held by any task)
+    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Lock.acquire`
+    """
+
+    locked: bool
+    owner: Optional[TaskInfo]
+    tasks_waiting: int
+
+
+@dataclass(frozen=True)
+class ConditionStatistics:
+    """
+    :ivar int tasks_waiting: number of tasks blocked on :meth:`~.Condition.wait`
+    :ivar ~anyio.LockStatistics lock_statistics: statistics of the underlying :class:`~.Lock`
+    """
+
+    tasks_waiting: int
+    lock_statistics: LockStatistics
+
+
+@dataclass(frozen=True)
+class SemaphoreStatistics:
+    """
+    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Semaphore.acquire`
+
+    """
+
+    tasks_waiting: int
+
+
+class Event:
+    def __new__(cls) -> "Event":
+        return get_asynclib().Event()
+
+    def set(self) -> DeprecatedAwaitable:
+        """Set the flag, notifying all listeners."""
+        raise NotImplementedError
+
+    def is_set(self) -> bool:
+        """Return ``True`` if the flag is set, ``False`` if not."""
+        raise NotImplementedError
+
+    async def wait(self) -> None:
+        """
+        Wait until the flag has been set.
+
+        If the flag has already been set when this method is called, it returns immediately.
+
+        """
+        raise NotImplementedError
+
+    def statistics(self) -> EventStatistics:
+        """Return statistics about the current state of this event."""
+        raise NotImplementedError
+
+
+class Lock:
+    _owner_task: Optional[TaskInfo] = None
+
+    def __init__(self) -> None:
+        self._waiters: Deque[Tuple[TaskInfo, Event]] = deque()
+
+    async def __aenter__(self) -> None:
+        await self.acquire()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.release()
+
+    async def acquire(self) -> None:
+        """Acquire the lock."""
+        await checkpoint_if_cancelled()
+        try:
+            self.acquire_nowait()
+        except WouldBlock:
+            task = get_current_task()
+            event = Event()
+            token = task, event
+            self._waiters.append(token)
+            try:
+                await event.wait()
+            except BaseException:
+                if not event.is_set():
+                    self._waiters.remove(token)
+                elif self._owner_task == task:
+                    self.release()
+
+                raise
+
+            assert self._owner_task == task
+        else:
+            try:
+                await cancel_shielded_checkpoint()
+            except BaseException:
+                self.release()
+                raise
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire the lock, without blocking.
+
+        :raises ~WouldBlock: if the operation would block
+
+        """
+        task = get_current_task()
+        if self._owner_task == task:
+            raise RuntimeError("Attempted to acquire an already held Lock")
+
+        if self._owner_task is not None:
+            raise WouldBlock
+
+        self._owner_task = task
+
+    def release(self) -> DeprecatedAwaitable:
+        """Release the lock."""
+        if self._owner_task != get_current_task():
+            raise RuntimeError("The current task is not holding this lock")
+
+        if self._waiters:
+            self._owner_task, event = self._waiters.popleft()
+            event.set()
+        else:
+            del self._owner_task
+
+        return DeprecatedAwaitable(self.release)
+
+    def locked(self) -> bool:
+        """Return True if the lock is currently held."""
+        return self._owner_task is not None
+
+    def statistics(self) -> LockStatistics:
+        """
+        Return statistics about the current state of this lock.
+
+        .. versionadded:: 3.0
+        """
+        return LockStatistics(self.locked(), self._owner_task, len(self._waiters))
+
+
+class Condition:
+    _owner_task: Optional[TaskInfo] = None
+
+    def __init__(self, lock: Optional[Lock] = None):
+        self._lock = lock or Lock()
+        self._waiters: Deque[Event] = deque()
+
+    async def __aenter__(self) -> None:
+        await self.acquire()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.release()
+
+    def _check_acquired(self) -> None:
+        if self._owner_task != get_current_task():
+            raise RuntimeError("The current task is not holding the underlying lock")
+
+    async def acquire(self) -> None:
+        """Acquire the underlying lock."""
+        await self._lock.acquire()
+        self._owner_task = get_current_task()
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire the underlying lock, without blocking.
+
+        :raises ~WouldBlock: if the operation would block
+
+        """
+        self._lock.acquire_nowait()
+        self._owner_task = get_current_task()
+
+    def release(self) -> DeprecatedAwaitable:
+        """Release the underlying lock."""
+        self._lock.release()
+        return DeprecatedAwaitable(self.release)
+
+    def locked(self) -> bool:
+        """Return True if the lock is set."""
+        return self._lock.locked()
+
+    def notify(self, n: int = 1) -> None:
+        """Notify exactly n listeners."""
+        self._check_acquired()
+        for _ in range(n):
+            try:
+                event = self._waiters.popleft()
+            except IndexError:
+                break
+
+            event.set()
+
+    def notify_all(self) -> None:
+        """Notify all the listeners."""
+        self._check_acquired()
+        for event in self._waiters:
+            event.set()
+
+        self._waiters.clear()
+
+    async def wait(self) -> None:
+        """Wait for a notification."""
+        await checkpoint()
+        event = Event()
+        self._waiters.append(event)
+        self.release()
+        try:
+            await event.wait()
+        except BaseException:
+            if not event.is_set():
+                self._waiters.remove(event)
+
+            raise
+        finally:
+            with CancelScope(shield=True):
+                await self.acquire()
+
+    def statistics(self) -> ConditionStatistics:
+        """
+        Return statistics about the current state of this condition.
+
+        .. versionadded:: 3.0
+        """
+        return ConditionStatistics(len(self._waiters), self._lock.statistics())
+
+
+class Semaphore:
+    def __init__(self, initial_value: int, *, max_value: Optional[int] = None):
+        if not isinstance(initial_value, int):
+            raise TypeError("initial_value must be an integer")
+        if initial_value < 0:
+            raise ValueError("initial_value must be >= 0")
+        if max_value is not None:
+            if not isinstance(max_value, int):
+                raise TypeError("max_value must be an integer or None")
+            if max_value < initial_value:
+                raise ValueError(
+                    "max_value must be equal to or higher than initial_value"
+                )
+
+        self._value = initial_value
+        self._max_value = max_value
+        self._waiters: Deque[Event] = deque()
+
+    async def __aenter__(self) -> "Semaphore":
+        await self.acquire()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.release()
+
+    async def acquire(self) -> None:
+        """Decrement the semaphore value, blocking if necessary."""
+        await checkpoint_if_cancelled()
+        try:
+            self.acquire_nowait()
+        except WouldBlock:
+            event = Event()
+            self._waiters.append(event)
+            try:
+                await event.wait()
+            except BaseException:
+                if not event.is_set():
+                    self._waiters.remove(event)
+                else:
+                    self.release()
+
+                raise
+        else:
+            try:
+                await cancel_shielded_checkpoint()
+            except BaseException:
+                self.release()
+                raise
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire the underlying lock, without blocking.
+
+        :raises ~WouldBlock: if the operation would block
+
+        """
+        if self._value == 0:
+            raise WouldBlock
+
+        self._value -= 1
+
+    def release(self) -> DeprecatedAwaitable:
+        """Increment the semaphore value."""
+        if self._max_value is not None and self._value == self._max_value:
+            raise ValueError("semaphore released too many times")
+
+        if self._waiters:
+            self._waiters.popleft().set()
+        else:
+            self._value += 1
+
+        return DeprecatedAwaitable(self.release)
+
+    @property
+    def value(self) -> int:
+        """The current value of the semaphore."""
+        return self._value
+
+    @property
+    def max_value(self) -> Optional[int]:
+        """The maximum value of the semaphore."""
+        return self._max_value
+
+    def statistics(self) -> SemaphoreStatistics:
+        """
+        Return statistics about the current state of this semaphore.
+
+        .. versionadded:: 3.0
+        """
+        return SemaphoreStatistics(len(self._waiters))
+
+
+class CapacityLimiter:
+    def __new__(cls, total_tokens: float) -> "CapacityLimiter":
+        return get_asynclib().CapacityLimiter(total_tokens)
+
+    async def __aenter__(self) -> None:
+        raise NotImplementedError
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        raise NotImplementedError
+
+    @property
+    def total_tokens(self) -> float:
+        """
+        The total number of tokens available for borrowing.
+
+        This is a read-write property. If the total number of tokens is increased, the
+        proportionate number of tasks waiting on this limiter will be granted their tokens.
+
+        .. versionchanged:: 3.0
+            The property is now writable.
+
+        """
+        raise NotImplementedError
+
+    @total_tokens.setter
+    def total_tokens(self, value: float) -> None:
+        raise NotImplementedError
+
+    async def set_total_tokens(self, value: float) -> None:
+        warn(
+            "CapacityLimiter.set_total_tokens has been deprecated. Set the value of the"
+            '"total_tokens" attribute directly.',
+            DeprecationWarning,
+        )
+        self.total_tokens = value
+
+    @property
+    def borrowed_tokens(self) -> int:
+        """The number of tokens that have currently been borrowed."""
+        raise NotImplementedError
+
+    @property
+    def available_tokens(self) -> float:
+        """The number of tokens currently available to be borrowed"""
+        raise NotImplementedError
+
+    def acquire_nowait(self) -> DeprecatedAwaitable:
+        """
+        Acquire a token for the current task without waiting for one to become available.
+
+        :raises ~anyio.WouldBlock: if there are no tokens available for borrowing
+
+        """
+        raise NotImplementedError
+
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> DeprecatedAwaitable:
+        """
+        Acquire a token without waiting for one to become available.
+
+        :param borrower: the entity borrowing a token
+        :raises ~anyio.WouldBlock: if there are no tokens available for borrowing
+
+        """
+        raise NotImplementedError
+
+    async def acquire(self) -> None:
+        """
+        Acquire a token for the current task, waiting if necessary for one to become available.
+
+        """
+        raise NotImplementedError
+
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        """
+        Acquire a token, waiting if necessary for one to become available.
+
+        :param borrower: the entity borrowing a token
+
+        """
+        raise NotImplementedError
+
+    def release(self) -> None:
+        """
+        Release the token held by the current task.
+        :raises RuntimeError: if the current task has not borrowed a token from this limiter.
+
+        """
+        raise NotImplementedError
+
+    def release_on_behalf_of(self, borrower: object) -> None:
+        """
+        Release the token held by the given borrower.
+
+        :raises RuntimeError: if the borrower has not borrowed a token from this limiter.
+
+        """
+        raise NotImplementedError
+
+    def statistics(self) -> CapacityLimiterStatistics:
+        """
+        Return statistics about the current state of this limiter.
+
+        .. versionadded:: 3.0
+
+        """
+        raise NotImplementedError
+
+
+def create_lock() -> Lock:
+    """
+    Create an asynchronous lock.
+
+    :return: a lock object
+
+    .. deprecated:: 3.0
+       Use :class:`~Lock` directly.
+
+    """
+    warn("create_lock() is deprecated -- use Lock() directly", DeprecationWarning)
+    return Lock()
+
+
+def create_condition(lock: Optional[Lock] = None) -> Condition:
+    """
+    Create an asynchronous condition.
+
+    :param lock: the lock to base the condition object on
+    :return: a condition object
+
+    .. deprecated:: 3.0
+       Use :class:`~Condition` directly.
+
+    """
+    warn(
+        "create_condition() is deprecated -- use Condition() directly",
+        DeprecationWarning,
+    )
+    return Condition(lock=lock)
+
+
+def create_event() -> Event:
+    """
+    Create an asynchronous event object.
+
+    :return: an event object
+
+    .. deprecated:: 3.0
+       Use :class:`~Event` directly.
+
+    """
+    warn("create_event() is deprecated -- use Event() directly", DeprecationWarning)
+    return get_asynclib().Event()
+
+
+def create_semaphore(value: int, *, max_value: Optional[int] = None) -> Semaphore:
+    """
+    Create an asynchronous semaphore.
+
+    :param value: the semaphore's initial value
+    :param max_value: if set, makes this a "bounded" semaphore that raises :exc:`ValueError` if the
+        semaphore's value would exceed this number
+    :return: a semaphore object
+
+    .. deprecated:: 3.0
+       Use :class:`~Semaphore` directly.
+
+    """
+    warn(
+        "create_semaphore() is deprecated -- use Semaphore() directly",
+        DeprecationWarning,
+    )
+    return Semaphore(value, max_value=max_value)
+
+
+def create_capacity_limiter(total_tokens: float) -> CapacityLimiter:
+    """
+    Create a capacity limiter.
+
+    :param total_tokens: the total number of tokens available for borrowing (can be an integer or
+        :data:`math.inf`)
+    :return: a capacity limiter object
+
+    .. deprecated:: 3.0
+       Use :class:`~CapacityLimiter` directly.
+
+    """
+    warn(
+        "create_capacity_limiter() is deprecated -- use CapacityLimiter() directly",
+        DeprecationWarning,
+    )
+    return get_asynclib().CapacityLimiter(total_tokens)
+
+
+class ResourceGuard:
+    __slots__ = "action", "_guarded"
+
+    def __init__(self, action: str):
+        self.action = action
+        self._guarded = False
+
+    def __enter__(self) -> None:
+        if self._guarded:
+            raise BusyResourceError(self.action)
+
+        self._guarded = True
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        self._guarded = False
+        return None
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_tasks.py b/myenv/lib/python3.9/site-packages/anyio/_core/_tasks.py
new file mode 100644
index 0000000..f24764c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_tasks.py
@@ -0,0 +1,178 @@
+import math
+from types import TracebackType
+from typing import Optional, Type
+from warnings import warn
+
+from ..abc._tasks import TaskGroup, TaskStatus
+from ._compat import (
+    DeprecatedAsyncContextManager,
+    DeprecatedAwaitable,
+    DeprecatedAwaitableFloat,
+)
+from ._eventloop import get_asynclib
+
+
+class _IgnoredTaskStatus(TaskStatus):
+    def started(self, value: object = None) -> None:
+        pass
+
+
+TASK_STATUS_IGNORED = _IgnoredTaskStatus()
+
+
+class CancelScope(DeprecatedAsyncContextManager["CancelScope"]):
+    """
+    Wraps a unit of work that can be made separately cancellable.
+
+    :param deadline: The time (clock value) when this scope is cancelled automatically
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    """
+
+    def __new__(
+        cls, *, deadline: float = math.inf, shield: bool = False
+    ) -> "CancelScope":
+        return get_asynclib().CancelScope(shield=shield, deadline=deadline)
+
+    def cancel(self) -> DeprecatedAwaitable:
+        """Cancel this scope immediately."""
+        raise NotImplementedError
+
+    @property
+    def deadline(self) -> float:
+        """
+        The time (clock value) when this scope is cancelled automatically.
+
+        Will be ``float('inf')`` if no timeout has been set.
+
+        """
+        raise NotImplementedError
+
+    @deadline.setter
+    def deadline(self, value: float) -> None:
+        raise NotImplementedError
+
+    @property
+    def cancel_called(self) -> bool:
+        """``True`` if :meth:`cancel` has been called."""
+        raise NotImplementedError
+
+    @property
+    def shield(self) -> bool:
+        """
+        ``True`` if this scope is shielded from external cancellation.
+
+        While a scope is shielded, it will not receive cancellations from outside.
+
+        """
+        raise NotImplementedError
+
+    @shield.setter
+    def shield(self, value: bool) -> None:
+        raise NotImplementedError
+
+    def __enter__(self) -> "CancelScope":
+        raise NotImplementedError
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        raise NotImplementedError
+
+
+def open_cancel_scope(*, shield: bool = False) -> CancelScope:
+    """
+    Open a cancel scope.
+
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    :return: a cancel scope
+
+    .. deprecated:: 3.0
+       Use :class:`~CancelScope` directly.
+
+    """
+    warn(
+        "open_cancel_scope() is deprecated -- use CancelScope() directly",
+        DeprecationWarning,
+    )
+    return get_asynclib().CancelScope(shield=shield)
+
+
+class FailAfterContextManager(DeprecatedAsyncContextManager[CancelScope]):
+    def __init__(self, cancel_scope: CancelScope):
+        self._cancel_scope = cancel_scope
+
+    def __enter__(self) -> CancelScope:
+        return self._cancel_scope.__enter__()
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        retval = self._cancel_scope.__exit__(exc_type, exc_val, exc_tb)
+        if self._cancel_scope.cancel_called:
+            raise TimeoutError
+
+        return retval
+
+
+def fail_after(delay: Optional[float], shield: bool = False) -> FailAfterContextManager:
+    """
+    Create a context manager which raises a :class:`TimeoutError` if does not finish in time.
+
+    :param delay: maximum allowed time (in seconds) before raising the exception, or ``None`` to
+        disable the timeout
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    :return: a context manager that yields a cancel scope
+    :rtype: :class:`~typing.ContextManager`\\[:class:`~anyio.abc.CancelScope`\\]
+
+    """
+    deadline = (
+        (get_asynclib().current_time() + delay) if delay is not None else math.inf
+    )
+    cancel_scope = get_asynclib().CancelScope(deadline=deadline, shield=shield)
+    return FailAfterContextManager(cancel_scope)
+
+
+def move_on_after(delay: Optional[float], shield: bool = False) -> CancelScope:
+    """
+    Create a cancel scope with a deadline that expires after the given delay.
+
+    :param delay: maximum allowed time (in seconds) before exiting the context block, or ``None``
+        to disable the timeout
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    :return: a cancel scope
+
+    """
+    deadline = (
+        (get_asynclib().current_time() + delay) if delay is not None else math.inf
+    )
+    return get_asynclib().CancelScope(deadline=deadline, shield=shield)
+
+
+def current_effective_deadline() -> DeprecatedAwaitableFloat:
+    """
+    Return the nearest deadline among all the cancel scopes effective for the current task.
+
+    :return: a clock value from the event loop's internal clock (``float('inf')`` if there is no
+        deadline in effect)
+    :rtype: float
+
+    """
+    return DeprecatedAwaitableFloat(
+        get_asynclib().current_effective_deadline(), current_effective_deadline
+    )
+
+
+def create_task_group() -> "TaskGroup":
+    """
+    Create a task group.
+
+    :return: a task group
+
+    """
+    return get_asynclib().TaskGroup()
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_testing.py b/myenv/lib/python3.9/site-packages/anyio/_core/_testing.py
new file mode 100644
index 0000000..4998753
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_testing.py
@@ -0,0 +1,80 @@
+from typing import Any, Awaitable, Generator, Optional, Union
+
+from ._compat import DeprecatedAwaitableList, _warn_deprecation
+from ._eventloop import get_asynclib
+
+
+class TaskInfo:
+    """
+    Represents an asynchronous task.
+
+    :ivar int id: the unique identifier of the task
+    :ivar parent_id: the identifier of the parent task, if any
+    :vartype parent_id: Optional[int]
+    :ivar str name: the description of the task (if any)
+    :ivar ~collections.abc.Coroutine coro: the coroutine object of the task
+    """
+
+    __slots__ = "_name", "id", "parent_id", "name", "coro"
+
+    def __init__(
+        self,
+        id: int,
+        parent_id: Optional[int],
+        name: Optional[str],
+        coro: Union[Generator, Awaitable[Any]],
+    ):
+        func = get_current_task
+        self._name = f"{func.__module__}.{func.__qualname__}"
+        self.id: int = id
+        self.parent_id: Optional[int] = parent_id
+        self.name: Optional[str] = name
+        self.coro: Union[Generator, Awaitable[Any]] = coro
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, TaskInfo):
+            return self.id == other.id
+
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(id={self.id!r}, name={self.name!r})"
+
+    def __await__(self) -> Generator[None, None, "TaskInfo"]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+        return self
+
+    def _unwrap(self) -> "TaskInfo":
+        return self
+
+
+def get_current_task() -> TaskInfo:
+    """
+    Return the current task.
+
+    :return: a representation of the current task
+
+    """
+    return get_asynclib().get_current_task()
+
+
+def get_running_tasks() -> DeprecatedAwaitableList[TaskInfo]:
+    """
+    Return a list of running tasks in the current event loop.
+
+    :return: a list of task info objects
+
+    """
+    tasks = get_asynclib().get_running_tasks()
+    return DeprecatedAwaitableList(tasks, func=get_running_tasks)
+
+
+async def wait_all_tasks_blocked() -> None:
+    """Wait until all other tasks are waiting for something."""
+    await get_asynclib().wait_all_tasks_blocked()
diff --git a/myenv/lib/python3.9/site-packages/anyio/_core/_typedattr.py b/myenv/lib/python3.9/site-packages/anyio/_core/_typedattr.py
new file mode 100644
index 0000000..424836a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/_core/_typedattr.py
@@ -0,0 +1,81 @@
+import sys
+from typing import Any, Callable, Dict, Mapping, TypeVar, Union, overload
+
+from ._exceptions import TypedAttributeLookupError
+
+if sys.version_info >= (3, 8):
+    from typing import final
+else:
+    from typing_extensions import final
+
+T_Attr = TypeVar("T_Attr")
+T_Default = TypeVar("T_Default")
+undefined = object()
+
+
+def typed_attribute() -> Any:
+    """Return a unique object, used to mark typed attributes."""
+    return object()
+
+
+class TypedAttributeSet:
+    """
+    Superclass for typed attribute collections.
+
+    Checks that every public attribute of every subclass has a type annotation.
+    """
+
+    def __init_subclass__(cls) -> None:
+        annotations: Dict[str, Any] = getattr(cls, "__annotations__", {})
+        for attrname in dir(cls):
+            if not attrname.startswith("_") and attrname not in annotations:
+                raise TypeError(
+                    f"Attribute {attrname!r} is missing its type annotation"
+                )
+
+        super().__init_subclass__()
+
+
+class TypedAttributeProvider:
+    """Base class for classes that wish to provide typed extra attributes."""
+
+    @property
+    def extra_attributes(self) -> Mapping[T_Attr, Callable[[], T_Attr]]:
+        """
+        A mapping of the extra attributes to callables that return the corresponding values.
+
+        If the provider wraps another provider, the attributes from that wrapper should also be
+        included in the returned mapping (but the wrapper may override the callables from the
+        wrapped instance).
+
+        """
+        return {}
+
+    @overload
+    def extra(self, attribute: T_Attr) -> T_Attr:
+        ...
+
+    @overload
+    def extra(self, attribute: T_Attr, default: T_Default) -> Union[T_Attr, T_Default]:
+        ...
+
+    @final
+    def extra(self, attribute: Any, default: object = undefined) -> object:
+        """
+        extra(attribute, default=undefined)
+
+        Return the value of the given typed extra attribute.
+
+        :param attribute: the attribute (member of a :class:`~TypedAttributeSet`) to look for
+        :param default: the value that should be returned if no value is found for the attribute
+        :raises ~anyio.TypedAttributeLookupError: if the search failed and no default value was
+            given
+
+        """
+        try:
+            return self.extra_attributes[attribute]()
+        except KeyError:
+            if default is undefined:
+                raise TypedAttributeLookupError("Attribute not found") from None
+            else:
+                return default
diff --git a/myenv/lib/python3.9/site-packages/anyio/abc/__init__.py b/myenv/lib/python3.9/site-packages/anyio/abc/__init__.py
new file mode 100644
index 0000000..72c4444
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/abc/__init__.py
@@ -0,0 +1,88 @@
+__all__ = (
+    "AsyncResource",
+    "IPAddressType",
+    "IPSockAddrType",
+    "SocketAttribute",
+    "SocketStream",
+    "SocketListener",
+    "UDPSocket",
+    "UNIXSocketStream",
+    "UDPPacketType",
+    "ConnectedUDPSocket",
+    "UnreliableObjectReceiveStream",
+    "UnreliableObjectSendStream",
+    "UnreliableObjectStream",
+    "ObjectReceiveStream",
+    "ObjectSendStream",
+    "ObjectStream",
+    "ByteReceiveStream",
+    "ByteSendStream",
+    "ByteStream",
+    "AnyUnreliableByteReceiveStream",
+    "AnyUnreliableByteSendStream",
+    "AnyUnreliableByteStream",
+    "AnyByteReceiveStream",
+    "AnyByteSendStream",
+    "AnyByteStream",
+    "Listener",
+    "Process",
+    "Event",
+    "Condition",
+    "Lock",
+    "Semaphore",
+    "CapacityLimiter",
+    "CancelScope",
+    "TaskGroup",
+    "TaskStatus",
+    "TestRunner",
+    "BlockingPortal",
+)
+
+from typing import Any
+
+from ._resources import AsyncResource
+from ._sockets import (
+    ConnectedUDPSocket,
+    IPAddressType,
+    IPSockAddrType,
+    SocketAttribute,
+    SocketListener,
+    SocketStream,
+    UDPPacketType,
+    UDPSocket,
+    UNIXSocketStream,
+)
+from ._streams import (
+    AnyByteReceiveStream,
+    AnyByteSendStream,
+    AnyByteStream,
+    AnyUnreliableByteReceiveStream,
+    AnyUnreliableByteSendStream,
+    AnyUnreliableByteStream,
+    ByteReceiveStream,
+    ByteSendStream,
+    ByteStream,
+    Listener,
+    ObjectReceiveStream,
+    ObjectSendStream,
+    ObjectStream,
+    UnreliableObjectReceiveStream,
+    UnreliableObjectSendStream,
+    UnreliableObjectStream,
+)
+from ._subprocesses import Process
+from ._tasks import TaskGroup, TaskStatus
+from ._testing import TestRunner
+
+# Re-exported here, for backwards compatibility
+# isort: off
+from .._core._synchronization import CapacityLimiter, Condition, Event, Lock, Semaphore
+from .._core._tasks import CancelScope
+from ..from_thread import BlockingPortal
+
+# Re-export imports so they look like they live directly in this package
+key: str
+value: Any
+for key, value in list(locals().items()):
+    if getattr(value, "__module__", "").startswith("anyio.abc."):
+        value.__module__ = __name__
diff --git a/myenv/lib/python3.9/site-packages/anyio/abc/_resources.py b/myenv/lib/python3.9/site-packages/anyio/abc/_resources.py
new file mode 100644
index 0000000..4f66c38
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/abc/_resources.py
@@ -0,0 +1,29 @@
+from abc import ABCMeta, abstractmethod
+from types import TracebackType
+from typing import Optional, Type, TypeVar
+
+T = TypeVar("T")
+
+
+class AsyncResource(metaclass=ABCMeta):
+    """
+    Abstract base class for all closeable asynchronous resources.
+
+    Works as an asynchronous context manager which returns the instance itself on enter, and calls
+    :meth:`aclose` on exit.
+    """
+
+    async def __aenter__(self: T) -> T:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        await self.aclose()
+
+    @abstractmethod
+    async def aclose(self) -> None:
+        """Close the resource."""
diff --git a/myenv/lib/python3.9/site-packages/anyio/abc/_sockets.py b/myenv/lib/python3.9/site-packages/anyio/abc/_sockets.py
new file mode 100644
index 0000000..f73e795
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/abc/_sockets.py
@@ -0,0 +1,183 @@
+import socket
+from abc import abstractmethod
+from io import IOBase
+from ipaddress import IPv4Address, IPv6Address
+from socket import AddressFamily
+from types import TracebackType
+from typing import (
+    Any,
+    AsyncContextManager,
+    Callable,
+    Collection,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+from .._core._typedattr import (
+    TypedAttributeProvider,
+    TypedAttributeSet,
+    typed_attribute,
+)
+from ._streams import ByteStream, Listener, T_Stream, UnreliableObjectStream
+from ._tasks import TaskGroup
+
+IPAddressType = Union[str, IPv4Address, IPv6Address]
+IPSockAddrType = Tuple[str, int]
+SockAddrType = Union[IPSockAddrType, str]
+UDPPacketType = Tuple[bytes, IPSockAddrType]
+T_Retval = TypeVar("T_Retval")
+
+
+class _NullAsyncContextManager:
+    async def __aenter__(self) -> None:
+        pass
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return None
+
+
+class SocketAttribute(TypedAttributeSet):
+    #: the address family of the underlying socket
+    family: AddressFamily = typed_attribute()
+    #: the local socket address of the underlying socket
+    local_address: SockAddrType = typed_attribute()
+    #: for IP addresses, the local port the underlying socket is bound to
+    local_port: int = typed_attribute()
+    #: the underlying stdlib socket object
+    raw_socket: socket.socket = typed_attribute()
+    #: the remote address the underlying socket is connected to
+    remote_address: SockAddrType = typed_attribute()
+    #: for IP addresses, the remote port the underlying socket is connected to
+    remote_port: int = typed_attribute()
+
+
+class _SocketProvider(TypedAttributeProvider):
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        from .._core._sockets import convert_ipv6_sockaddr as convert
+
+        attributes: Dict[Any, Callable[[], Any]] = {
+            SocketAttribute.family: lambda: self._raw_socket.family,
+            SocketAttribute.local_address: lambda: convert(
+                self._raw_socket.getsockname()
+            ),
+            SocketAttribute.raw_socket: lambda: self._raw_socket,
+        }
+        try:
+            peername: Optional[Tuple[str, int]] = convert(
+                self._raw_socket.getpeername()
+            )
+        except OSError:
+            peername = None
+
+        # Provide the remote address for connected sockets
+        if peername is not None:
+            attributes[SocketAttribute.remote_address] = lambda: peername
+
+        # Provide local and remote ports for IP based sockets
+        if self._raw_socket.family in (AddressFamily.AF_INET, AddressFamily.AF_INET6):
+            attributes[
+                SocketAttribute.local_port
+            ] = lambda: self._raw_socket.getsockname()[1]
+            if peername is not None:
+                remote_port = peername[1]
+                attributes[SocketAttribute.remote_port] = lambda: remote_port
+
+        return attributes
+
+    @property
+    @abstractmethod
+    def _raw_socket(self) -> socket.socket:
+        pass
+
+
+class SocketStream(ByteStream, _SocketProvider):
+    """
+    Transports bytes over a socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+
+class UNIXSocketStream(SocketStream):
+    @abstractmethod
+    async def send_fds(
+        self, message: bytes, fds: Collection[Union[int, IOBase]]
+    ) -> None:
+        """
+        Send file descriptors along with a message to the peer.
+
+        :param message: a non-empty bytestring
+        :param fds: a collection of files (either numeric file descriptors or open file or socket
+            objects)
+        """
+
+    @abstractmethod
+    async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]:
+        """
+        Receive file descriptors along with a message from the peer.
+
+        :param msglen: length of the message to expect from the peer
+        :param maxfds: maximum number of file descriptors to expect from the peer
+        :return: a tuple of (message, file descriptors)
+        """
+
+
+class SocketListener(Listener[SocketStream], _SocketProvider):
+    """
+    Listens to incoming socket connections.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+    @abstractmethod
+    async def accept(self) -> SocketStream:
+        """Accept an incoming connection."""
+
+    async def serve(
+        self, handler: Callable[[T_Stream], Any], task_group: Optional[TaskGroup] = None
+    ) -> None:
+        from .. import create_task_group
+
+        context_manager: AsyncContextManager
+        if task_group is None:
+            task_group = context_manager = create_task_group()
+        else:
+            # Can be replaced with AsyncExitStack once on py3.7+
+            context_manager = _NullAsyncContextManager()
+
+        async with context_manager:
+            while True:
+                stream = await self.accept()
+                task_group.start_soon(handler, stream)
+
+
+class UDPSocket(UnreliableObjectStream[UDPPacketType], _SocketProvider):
+    """
+    Represents an unconnected UDP socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+    async def sendto(self, data: bytes, host: str, port: int) -> None:
+        """Alias for :meth:`~.UnreliableObjectSendStream.send` ((data, (host, port)))."""
+        return await self.send((data, (host, port)))
+
+
+class ConnectedUDPSocket(UnreliableObjectStream[bytes], _SocketProvider):
+    """
+    Represents an connected UDP socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
diff --git a/myenv/lib/python3.9/site-packages/anyio/abc/_streams.py b/myenv/lib/python3.9/site-packages/anyio/abc/_streams.py
new file mode 100644
index 0000000..4980ef4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/abc/_streams.py
@@ -0,0 +1,198 @@
+from abc import abstractmethod
+from typing import Any, Callable, Generic, Optional, TypeVar, Union
+
+from .._core._exceptions import EndOfStream
+from .._core._typedattr import TypedAttributeProvider
+from ._resources import AsyncResource
+from ._tasks import TaskGroup
+
+T_Item = TypeVar("T_Item")
+T_Stream = TypeVar("T_Stream")
+
+
+class UnreliableObjectReceiveStream(
+    Generic[T_Item], AsyncResource, TypedAttributeProvider
+):
+    """
+    An interface for receiving objects.
+
+    This interface makes no guarantees that the received messages arrive in the order in which they
+    were sent, or that no messages are missed.
+
+    Asynchronously iterating over objects of this type will yield objects matching the given type
+    parameter.
+    """
+
+    def __aiter__(self) -> "UnreliableObjectReceiveStream[T_Item]":
+        return self
+
+    async def __anext__(self) -> T_Item:
+        try:
+            return await self.receive()
+        except EndOfStream:
+            raise StopAsyncIteration
+
+    @abstractmethod
+    async def receive(self) -> T_Item:
+        """
+        Receive the next item.
+
+        :raises ~anyio.ClosedResourceError: if the receive stream has been explicitly
+            closed
+        :raises ~anyio.EndOfStream: if this stream has been closed from the other end
+        :raises ~anyio.BrokenResourceError: if this stream has been rendered unusable
+            due to external causes
+        """
+
+
+class UnreliableObjectSendStream(
+    Generic[T_Item], AsyncResource, TypedAttributeProvider
+):
+    """
+    An interface for sending objects.
+
+    This interface makes no guarantees that the messages sent will reach the recipient(s) in the
+    same order in which they were sent, or at all.
+    """
+
+    @abstractmethod
+    async def send(self, item: T_Item) -> None:
+        """
+        Send an item to the peer(s).
+
+        :param item: the item to send
+        :raises ~anyio.ClosedResourceError: if the send stream has been explicitly
+            closed
+        :raises ~anyio.BrokenResourceError: if this stream has been rendered unusable
+            due to external causes
+        """
+
+
+class UnreliableObjectStream(
+    UnreliableObjectReceiveStream[T_Item], UnreliableObjectSendStream[T_Item]
+):
+    """
+    A bidirectional message stream which does not guarantee the order or reliability of message
+    delivery.
+    """
+
+
+class ObjectReceiveStream(UnreliableObjectReceiveStream[T_Item]):
+    """
+    A receive message stream which guarantees that messages are received in the same order in
+    which they were sent, and that no messages are missed.
+    """
+
+
+class ObjectSendStream(UnreliableObjectSendStream[T_Item]):
+    """
+    A send message stream which guarantees that messages are delivered in the same order in which
+    they were sent, without missing any messages in the middle.
+    """
+
+
+class ObjectStream(
+    ObjectReceiveStream[T_Item],
+    ObjectSendStream[T_Item],
+    UnreliableObjectStream[T_Item],
+):
+    """
+    A bidirectional message stream which guarantees the order and reliability of message delivery.
+    """
+
+    @abstractmethod
+    async def send_eof(self) -> None:
+        """
+        Send an end-of-file indication to the peer.
+
+        You should not try to send any further data to this stream after calling this method.
+        This method is idempotent (does nothing on successive calls).
+        """
+
+
+class ByteReceiveStream(AsyncResource, TypedAttributeProvider):
+    """
+    An interface for receiving bytes from a single peer.
+
+    Iterating this byte stream will yield a byte string of arbitrary length, but no more than
+    65536 bytes.
+    """
+
+    def __aiter__(self) -> "ByteReceiveStream":
+        return self
+
+    async def __anext__(self) -> bytes:
+        try:
+            return await self.receive()
+        except EndOfStream:
+            raise StopAsyncIteration
+
+    @abstractmethod
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        """
+        Receive at most ``max_bytes`` bytes from the peer.
+
+        .. note:: Implementors of this interface should not return an empty :class:`bytes` object,
+            and users should ignore them.
+
+        :param max_bytes: maximum number of bytes to receive
+        :return: the received bytes
+        :raises ~anyio.EndOfStream: if this stream has been closed from the other end
+        """
+
+
+class ByteSendStream(AsyncResource, TypedAttributeProvider):
+    """An interface for sending bytes to a single peer."""
+
+    @abstractmethod
+    async def send(self, item: bytes) -> None:
+        """
+        Send the given bytes to the peer.
+
+        :param item: the bytes to send
+        """
+
+
+class ByteStream(ByteReceiveStream, ByteSendStream):
+    """A bidirectional byte stream."""
+
+    @abstractmethod
+    async def send_eof(self) -> None:
+        """
+        Send an end-of-file indication to the peer.
+
+        You should not try to send any further data to this stream after calling this method.
+        This method is idempotent (does nothing on successive calls).
+        """
+
+
+#: Type alias for all unreliable bytes-oriented receive streams.
+AnyUnreliableByteReceiveStream = Union[
+    UnreliableObjectReceiveStream[bytes], ByteReceiveStream
+]
+#: Type alias for all unreliable bytes-oriented send streams.
+AnyUnreliableByteSendStream = Union[UnreliableObjectSendStream[bytes], ByteSendStream]
+#: Type alias for all unreliable bytes-oriented streams.
+AnyUnreliableByteStream = Union[UnreliableObjectStream[bytes], ByteStream]
+#: Type alias for all bytes-oriented receive streams.
+AnyByteReceiveStream = Union[ObjectReceiveStream[bytes], ByteReceiveStream]
+#: Type alias for all bytes-oriented send streams.
+AnyByteSendStream = Union[ObjectSendStream[bytes], ByteSendStream]
+#: Type alias for all bytes-oriented streams.
+AnyByteStream = Union[ObjectStream[bytes], ByteStream]
+
+
+class Listener(Generic[T_Stream], AsyncResource, TypedAttributeProvider):
+    """An interface for objects that let you accept incoming connections."""
+
+    @abstractmethod
+    async def serve(
+        self, handler: Callable[[T_Stream], Any], task_group: Optional[TaskGroup] = None
+    ) -> None:
+        """
+        Accept incoming connections as they come in and start tasks to handle them.
+
+        :param handler: a callable that will be used to handle each accepted connection
+        :param task_group: the task group that will be used to start tasks for handling each
+            accepted connection (if omitted, an ad-hoc task group will be created)
+        """
diff --git a/myenv/lib/python3.9/site-packages/anyio/abc/_subprocesses.py b/myenv/lib/python3.9/site-packages/anyio/abc/_subprocesses.py
new file mode 100644
index 0000000..1e633fb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/abc/_subprocesses.py
@@ -0,0 +1,78 @@
+from abc import abstractmethod
+from signal import Signals
+from typing import Optional
+
+from ._resources import AsyncResource
+from ._streams import ByteReceiveStream, ByteSendStream
+
+
+class Process(AsyncResource):
+    """An asynchronous version of :class:`subprocess.Popen`."""
+
+    @abstractmethod
+    async def wait(self) -> int:
+        """
+        Wait until the process exits.
+
+        :return: the exit code of the process
+        """
+
+    @abstractmethod
+    def terminate(self) -> None:
+        """
+        Terminates the process, gracefully if possible.
+
+        On Windows, this calls ``TerminateProcess()``.
+        On POSIX systems, this sends ``SIGTERM`` to the process.
+
+        .. seealso:: :meth:`subprocess.Popen.terminate`
+        """
+
+    @abstractmethod
+    def kill(self) -> None:
+        """
+        Kills the process.
+
+        On Windows, this calls ``TerminateProcess()``.
+        On POSIX systems, this sends ``SIGKILL`` to the process.
+
+        .. seealso:: :meth:`subprocess.Popen.kill`
+        """
+
+    @abstractmethod
+    def send_signal(self, signal: Signals) -> None:
+        """
+        Send a signal to the subprocess.
+
+        .. seealso:: :meth:`subprocess.Popen.send_signal`
+
+        :param signal: the signal number (e.g. :data:`signal.SIGHUP`)
+        """
+
+    @property
+    @abstractmethod
+    def pid(self) -> int:
+        """The process ID of the process."""
+
+    @property
+    @abstractmethod
+    def returncode(self) -> Optional[int]:
+        """
+        The return code of the process. If the process has not yet terminated, this will be
+        ``None``.
+        """
+
+    @property
+    @abstractmethod
+    def stdin(self) -> Optional[ByteSendStream]:
+        """The stream for the standard input of the process."""
+
+    @property
+    @abstractmethod
+    def stdout(self) -> Optional[ByteReceiveStream]:
+        """The stream for the standard output of the process."""
+
+    @property
+    @abstractmethod
+    def stderr(self) -> Optional[ByteReceiveStream]:
+        """The stream for the standard error output of the process."""
diff --git a/myenv/lib/python3.9/site-packages/anyio/abc/_tasks.py b/myenv/lib/python3.9/site-packages/anyio/abc/_tasks.py
new file mode 100644
index 0000000..99928a1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/abc/_tasks.py
@@ -0,0 +1,104 @@
+import typing
+from abc import ABCMeta, abstractmethod
+from types import TracebackType
+from typing import Any, Callable, Coroutine, Optional, Type, TypeVar
+from warnings import warn
+
+if typing.TYPE_CHECKING:
+    from anyio._core._tasks import CancelScope
+
+T_Retval = TypeVar("T_Retval")
+
+
+class TaskStatus(metaclass=ABCMeta):
+    @abstractmethod
+    def started(self, value: object = None) -> None:
+        """
+        Signal that the task has started.
+
+        :param value: object passed back to the starter of the task
+        """
+
+
+class TaskGroup(metaclass=ABCMeta):
+    """
+    Groups several asynchronous tasks together.
+
+    :ivar cancel_scope: the cancel scope inherited by all child tasks
+    :vartype cancel_scope: CancelScope
+    """
+
+    cancel_scope: "CancelScope"
+
+    async def spawn(
+        self,
+        func: Callable[..., Coroutine[Any, Any, Any]],
+        *args: object,
+        name: object = None
+    ) -> None:
+        """
+        Start a new task in this task group.
+
+        :param func: a coroutine function
+        :param args: positional arguments to call the function with
+        :param name: name of the task, for the purposes of introspection and debugging
+
+        .. deprecated:: 3.0
+           Use :meth:`start_soon` instead. If your code needs AnyIO 2 compatibility, you
+           can keep using this until AnyIO 4.
+
+        """
+        warn(
+            'spawn() is deprecated -- use start_soon() (without the "await") instead',
+            DeprecationWarning,
+        )
+        self.start_soon(func, *args, name=name)
+
+    @abstractmethod
+    def start_soon(
+        self,
+        func: Callable[..., Coroutine[Any, Any, Any]],
+        *args: object,
+        name: object = None
+    ) -> None:
+        """
+        Start a new task in this task group.
+
+        :param func: a coroutine function
+        :param args: positional arguments to call the function with
+        :param name: name of the task, for the purposes of introspection and debugging
+
+        .. versionadded:: 3.0
+        """
+
+    @abstractmethod
+    async def start(
+        self,
+        func: Callable[..., Coroutine[Any, Any, Any]],
+        *args: object,
+        name: object = None
+    ) -> object:
+        """
+        Start a new task and wait until it signals for readiness.
+
+        :param func: a coroutine function
+        :param args: positional arguments to call the function with
+        :param name: name of the task, for the purposes of introspection and debugging
+        :return: the value passed to ``task_status.started()``
+        :raises RuntimeError: if the task finishes without calling ``task_status.started()``
+
+        .. versionadded:: 3.0
+        """
+
+    @abstractmethod
+    async def __aenter__(self) -> "TaskGroup":
+        """Enter the task group context and allow starting new tasks."""
+
+    @abstractmethod
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        """Exit the task group context waiting for all tasks to finish."""
diff --git a/myenv/lib/python3.9/site-packages/anyio/abc/_testing.py b/myenv/lib/python3.9/site-packages/anyio/abc/_testing.py
new file mode 100644
index 0000000..4e3621d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/abc/_testing.py
@@ -0,0 +1,68 @@
+import types
+from abc import ABCMeta, abstractmethod
+from collections.abc import AsyncGenerator, Iterable
+from typing import Any, Callable, Coroutine, Dict, Optional, Type, TypeVar
+
+_T = TypeVar("_T")
+
+
+class TestRunner(metaclass=ABCMeta):
+    """
+    Encapsulates a running event loop. Every call made through this object will use the same event
+    loop.
+    """
+
+    def __enter__(self) -> "TestRunner":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[types.TracebackType],
+    ) -> Optional[bool]:
+        self.close()
+        return None
+
+    @abstractmethod
+    def close(self) -> None:
+        """Close the event loop."""
+
+    @abstractmethod
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., "AsyncGenerator[_T, Any]"],
+        kwargs: Dict[str, Any],
+    ) -> "Iterable[_T]":
+        """
+        Run an async generator fixture.
+
+        :param fixture_func: the fixture function
+        :param kwargs: keyword arguments to call the fixture function with
+        :return: an iterator yielding the value yielded from the async generator
+        """
+
+    @abstractmethod
+    def run_fixture(
+        self,
+        fixture_func: Callable[..., Coroutine[Any, Any, _T]],
+        kwargs: Dict[str, Any],
+    ) -> _T:
+        """
+        Run an async fixture.
+
+        :param fixture_func: the fixture function
+        :param kwargs: keyword arguments to call the fixture function with
+        :return: the return value of the fixture function
+        """
+
+    @abstractmethod
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: Dict[str, Any]
+    ) -> None:
+        """
+        Run an async test function.
+
+        :param test_func: the test function
+        :param kwargs: keyword arguments to call the test function with
+        """
diff --git a/myenv/lib/python3.9/site-packages/anyio/from_thread.py b/myenv/lib/python3.9/site-packages/anyio/from_thread.py
new file mode 100644
index 0000000..e4f871f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/from_thread.py
@@ -0,0 +1,502 @@
+import threading
+from asyncio import iscoroutine
+from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait
+from contextlib import AbstractContextManager, contextmanager
+from types import TracebackType
+from typing import (
+    Any,
+    AsyncContextManager,
+    Callable,
+    ContextManager,
+    Coroutine,
+    Dict,
+    Generator,
+    Iterable,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+from warnings import warn
+
+from ._core import _eventloop
+from ._core._eventloop import get_asynclib, get_cancelled_exc_class, threadlocals
+from ._core._synchronization import Event
+from ._core._tasks import CancelScope, create_task_group
+from .abc._tasks import TaskStatus
+
+T_Retval = TypeVar("T_Retval")
+T_co = TypeVar("T_co")
+
+
+def run(func: Callable[..., Coroutine[Any, Any, T_Retval]], *args: object) -> T_Retval:
+    """
+    Call a coroutine function from a worker thread.
+
+    :param func: a coroutine function
+    :param args: positional arguments for the callable
+    :return: the return value of the coroutine function
+
+    """
+    try:
+        asynclib = threadlocals.current_async_module
+    except AttributeError:
+        raise RuntimeError("This function can only be run from an AnyIO worker thread")
+
+    return asynclib.run_async_from_thread(func, *args)
+
+
+def run_async_from_thread(
+    func: Callable[..., Coroutine[Any, Any, T_Retval]], *args: object
+) -> T_Retval:
+    warn(
+        "run_async_from_thread() has been deprecated, use anyio.from_thread.run() instead",
+        DeprecationWarning,
+    )
+    return run(func, *args)
+
+
+def run_sync(func: Callable[..., T_Retval], *args: object) -> T_Retval:
+    """
+    Call a function in the event loop thread from a worker thread.
+
+    :param func: a callable
+    :param args: positional arguments for the callable
+    :return: the return value of the callable
+
+    """
+    try:
+        asynclib = threadlocals.current_async_module
+    except AttributeError:
+        raise RuntimeError("This function can only be run from an AnyIO worker thread")
+
+    return asynclib.run_sync_from_thread(func, *args)
+
+
+def run_sync_from_thread(func: Callable[..., T_Retval], *args: object) -> T_Retval:
+    warn(
+        "run_sync_from_thread() has been deprecated, use anyio.from_thread.run_sync() instead",
+        DeprecationWarning,
+    )
+    return run_sync(func, *args)
+
+
+class _BlockingAsyncContextManager(AbstractContextManager):
+    _enter_future: Future
+    _exit_future: Future
+    _exit_event: Event
+    _exit_exc_info: Tuple[
+        Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]
+    ] = (None, None, None)
+
+    def __init__(self, async_cm: AsyncContextManager[T_co], portal: "BlockingPortal"):
+        self._async_cm = async_cm
+        self._portal = portal
+
+    async def run_async_cm(self) -> Optional[bool]:
+        try:
+            self._exit_event = Event()
+            value = await self._async_cm.__aenter__()
+        except BaseException as exc:
+            self._enter_future.set_exception(exc)
+            raise
+        else:
+            self._enter_future.set_result(value)
+
+        try:
+            # Wait for the sync context manager to exit.
+            # This next statement can raise `get_cancelled_exc_class()` if
+            # something went wrong in a task group in this async context
+            # manager.
+            await self._exit_event.wait()
+        finally:
+            # In case of cancellation, it could be that we end up here before
+            # `_BlockingAsyncContextManager.__exit__` is called, and an
+            # `_exit_exc_info` has been set.
+            result = await self._async_cm.__aexit__(*self._exit_exc_info)
+            return result
+
+    def __enter__(self) -> T_co:
+        self._enter_future = Future()
+        self._exit_future = self._portal.start_task_soon(self.run_async_cm)
+        cm = self._enter_future.result()
+        return cast(T_co, cm)
+
+    def __exit__(
+        self,
+        __exc_type: Optional[Type[BaseException]],
+        __exc_value: Optional[BaseException],
+        __traceback: Optional[TracebackType],
+    ) -> Optional[bool]:
+        self._exit_exc_info = __exc_type, __exc_value, __traceback
+        self._portal.call(self._exit_event.set)
+        return self._exit_future.result()
+
+
+class _BlockingPortalTaskStatus(TaskStatus):
+    def __init__(self, future: Future):
+        self._future = future
+
+    def started(self, value: object = None) -> None:
+        self._future.set_result(value)
+
+
+class BlockingPortal:
+    """An object that lets external threads run code in an asynchronous event loop."""
+
+    def __new__(cls) -> "BlockingPortal":
+        return get_asynclib().BlockingPortal()
+
+    def __init__(self) -> None:
+        self._event_loop_thread_id: Optional[int] = threading.get_ident()
+        self._stop_event = Event()
+        self._task_group = create_task_group()
+        self._cancelled_exc_class = get_cancelled_exc_class()
+
+    async def __aenter__(self) -> "BlockingPortal":
+        await self._task_group.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        await self.stop()
+        return await self._task_group.__aexit__(exc_type, exc_val, exc_tb)
+
+    def _check_running(self) -> None:
+        if self._event_loop_thread_id is None:
+            raise RuntimeError("This portal is not running")
+        if self._event_loop_thread_id == threading.get_ident():
+            raise RuntimeError(
+                "This method cannot be called from the event loop thread"
+            )
+
+    async def sleep_until_stopped(self) -> None:
+        """Sleep until :meth:`stop` is called."""
+        await self._stop_event.wait()
+
+    async def stop(self, cancel_remaining: bool = False) -> None:
+        """
+        Signal the portal to shut down.
+
+        This marks the portal as no longer accepting new calls and exits from
+        :meth:`sleep_until_stopped`.
+
+        :param cancel_remaining: ``True`` to cancel all the remaining tasks, ``False`` to let them
+            finish before returning
+
+        """
+        self._event_loop_thread_id = None
+        self._stop_event.set()
+        if cancel_remaining:
+            self._task_group.cancel_scope.cancel()
+
+    async def _call_func(
+        self, func: Callable, args: tuple, kwargs: Dict[str, Any], future: Future
+    ) -> None:
+        def callback(f: Future) -> None:
+            if f.cancelled() and self._event_loop_thread_id not in (
+                None,
+                threading.get_ident(),
+            ):
+                self.call(scope.cancel)
+
+        try:
+            retval = func(*args, **kwargs)
+            if iscoroutine(retval):
+                with CancelScope() as scope:
+                    if future.cancelled():
+                        scope.cancel()
+                    else:
+                        future.add_done_callback(callback)
+
+                    retval = await retval
+        except self._cancelled_exc_class:
+            future.cancel()
+        except BaseException as exc:
+            if not future.cancelled():
+                future.set_exception(exc)
+
+            # Let base exceptions fall through
+            if not isinstance(exc, Exception):
+                raise
+        else:
+            if not future.cancelled():
+                future.set_result(retval)
+        finally:
+            scope = None  # type: ignore[assignment]
+
+    def _spawn_task_from_thread(
+        self,
+        func: Callable,
+        args: tuple,
+        kwargs: Dict[str, Any],
+        name: object,
+        future: Future,
+    ) -> None:
+        """
+        Spawn a new task using the given callable.
+
+        Implementors must ensure that the future is resolved when the task finishes.
+
+        :param func: a callable
+        :param args: positional arguments to be passed to the callable
+        :param kwargs: keyword arguments to be passed to the callable
+        :param name: name of the task (will be coerced to a string if not ``None``)
+        :param future: a future that will resolve to the return value of the callable, or the
+            exception raised during its execution
+
+        """
+        raise NotImplementedError
+
+    @overload
+    def call(
+        self, func: Callable[..., Coroutine[Any, Any, T_Retval]], *args: object
+    ) -> T_Retval:
+        ...
+
+    @overload
+    def call(self, func: Callable[..., T_Retval], *args: object) -> T_Retval:
+        ...
+
+    def call(
+        self,
+        func: Callable[..., Union[Coroutine[Any, Any, T_Retval], T_Retval]],
+        *args: object
+    ) -> T_Retval:
+        """
+        Call the given function in the event loop thread.
+
+        If the callable returns a coroutine object, it is awaited on.
+
+        :param func: any callable
+        :raises RuntimeError: if the portal is not running or if this method is called from within
+            the event loop thread
+
+        """
+        return cast(T_Retval, self.start_task_soon(func, *args).result())
+
+    @overload
+    def spawn_task(
+        self,
+        func: Callable[..., Coroutine[Any, Any, T_Retval]],
+        *args: object,
+        name: object = None
+    ) -> "Future[T_Retval]":
+        ...
+
+    @overload
+    def spawn_task(
+        self, func: Callable[..., T_Retval], *args: object, name: object = None
+    ) -> "Future[T_Retval]":
+        ...
+
+    def spawn_task(
+        self,
+        func: Callable[..., Union[Coroutine[Any, Any, T_Retval], T_Retval]],
+        *args: object,
+        name: object = None
+    ) -> "Future[T_Retval]":
+        """
+        Start a task in the portal's task group.
+
+        :param func: the target coroutine function
+        :param args: positional arguments passed to ``func``
+        :param name: name of the task (will be coerced to a string if not ``None``)
+        :return: a future that resolves with the return value of the callable if the task completes
+            successfully, or with the exception raised in the task
+        :raises RuntimeError: if the portal is not running or if this method is called from within
+            the event loop thread
+
+        .. versionadded:: 2.1
+        .. deprecated:: 3.0
+           Use :meth:`start_task_soon` instead. If your code needs AnyIO 2 compatibility, you
+           can keep using this until AnyIO 4.
+
+        """
+        warn(
+            "spawn_task() is deprecated -- use start_task_soon() instead",
+            DeprecationWarning,
+        )
+        return self.start_task_soon(func, *args, name=name)  # type: ignore[arg-type]
+
+    @overload
+    def start_task_soon(
+        self,
+        func: Callable[..., Coroutine[Any, Any, T_Retval]],
+        *args: object,
+        name: object = None
+    ) -> "Future[T_Retval]":
+        ...
+
+    @overload
+    def start_task_soon(
+        self, func: Callable[..., T_Retval], *args: object, name: object = None
+    ) -> "Future[T_Retval]":
+        ...
+
+    def start_task_soon(
+        self,
+        func: Callable[..., Union[Coroutine[Any, Any, T_Retval], T_Retval]],
+        *args: object,
+        name: object = None
+    ) -> "Future[T_Retval]":
+        """
+        Start a task in the portal's task group.
+
+        The task will be run inside a cancel scope which can be cancelled by cancelling the
+        returned future.
+
+        :param func: the target coroutine function
+        :param args: positional arguments passed to ``func``
+        :param name: name of the task (will be coerced to a string if not ``None``)
+        :return: a future that resolves with the return value of the callable if the task completes
+            successfully, or with the exception raised in the task
+        :raises RuntimeError: if the portal is not running or if this method is called from within
+            the event loop thread
+
+        .. versionadded:: 3.0
+
+        """
+        self._check_running()
+        f: Future = Future()
+        self._spawn_task_from_thread(func, args, {}, name, f)
+        return f
+
+    def start_task(
+        self,
+        func: Callable[..., Coroutine[Any, Any, Any]],
+        *args: object,
+        name: object = None
+    ) -> Tuple["Future[Any]", Any]:
+        """
+        Start a task in the portal's task group and wait until it signals for readiness.
+
+        This method works the same way as :meth:`TaskGroup.start`.
+
+        :param func: the target coroutine function
+        :param args: positional arguments passed to ``func``
+        :param name: name of the task (will be coerced to a string if not ``None``)
+        :return: a tuple of (future, task_status_value) where the ``task_status_value`` is the
+            value passed to ``task_status.started()`` from within the target function
+
+        .. versionadded:: 3.0
+
+        """
+
+        def task_done(future: Future) -> None:
+            if not task_status_future.done():
+                if future.cancelled():
+                    task_status_future.cancel()
+                elif future.exception():
+                    task_status_future.set_exception(future.exception())
+                else:
+                    exc = RuntimeError(
+                        "Task exited without calling task_status.started()"
+                    )
+                    task_status_future.set_exception(exc)
+
+        self._check_running()
+        task_status_future: Future = Future()
+        task_status = _BlockingPortalTaskStatus(task_status_future)
+        f: Future = Future()
+        f.add_done_callback(task_done)
+        self._spawn_task_from_thread(func, args, {"task_status": task_status}, name, f)
+        return f, task_status_future.result()
+
+    def wrap_async_context_manager(
+        self, cm: AsyncContextManager[T_co]
+    ) -> ContextManager[T_co]:
+        """
+        Wrap an async context manager as a synchronous context manager via this portal.
+
+        Spawns a task that will call both ``__aenter__()`` and ``__aexit__()``, stopping in the
+        middle until the synchronous context manager exits.
+
+        :param cm: an asynchronous context manager
+        :return: a synchronous context manager
+
+        .. versionadded:: 2.1
+
+        """
+        return _BlockingAsyncContextManager(cm, self)
+
+
+def create_blocking_portal() -> BlockingPortal:
+    """
+    Create a portal for running functions in the event loop thread from external threads.
+
+    Use this function in asynchronous code when you need to allow external threads access to the
+    event loop where your asynchronous code is currently running.
+
+    .. deprecated:: 3.0
+        Use :class:`.BlockingPortal` directly.
+
+    """
+    warn(
+        "create_blocking_portal() has been deprecated -- use anyio.from_thread.BlockingPortal() "
+        "directly",
+        DeprecationWarning,
+    )
+    return BlockingPortal()
+
+
+@contextmanager
+def start_blocking_portal(
+    backend: str = "asyncio", backend_options: Optional[Dict[str, Any]] = None
+) -> Generator[BlockingPortal, Any, None]:
+    """
+    Start a new event loop in a new thread and run a blocking portal in its main task.
+
+    The parameters are the same as for :func:`~anyio.run`.
+
+    :param backend: name of the backend
+    :param backend_options: backend options
+    :return: a context manager that yields a blocking portal
+
+    .. versionchanged:: 3.0
+        Usage as a context manager is now required.
+
+    """
+
+    async def run_portal() -> None:
+        async with BlockingPortal() as portal_:
+            if future.set_running_or_notify_cancel():
+                future.set_result(portal_)
+                await portal_.sleep_until_stopped()
+
+    future: Future[BlockingPortal] = Future()
+    with ThreadPoolExecutor(1) as executor:
+        run_future = executor.submit(
+            _eventloop.run,
+            run_portal,  # type: ignore[arg-type]
+            backend=backend,
+            backend_options=backend_options,
+        )
+        try:
+            wait(
+                cast(Iterable[Future], [run_future, future]),
+                return_when=FIRST_COMPLETED,
+            )
+        except BaseException:
+            future.cancel()
+            run_future.cancel()
+            raise
+
+        if future.done():
+            portal = future.result()
+            try:
+                yield portal
+            except BaseException:
+                portal.call(portal.stop, True)
+                raise
+
+            portal.call(portal.stop, False)
+
+        run_future.result()
diff --git a/myenv/lib/python3.9/site-packages/anyio/lowlevel.py b/myenv/lib/python3.9/site-packages/anyio/lowlevel.py
new file mode 100644
index 0000000..c1da8fa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/lowlevel.py
@@ -0,0 +1,170 @@
+import enum
+import sys
+from dataclasses import dataclass
+from typing import Any, Dict, Generic, Set, TypeVar, Union, overload
+from weakref import WeakKeyDictionary
+
+from ._core._eventloop import get_asynclib
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+T = TypeVar("T")
+D = TypeVar("D")
+
+
+async def checkpoint() -> None:
+    """
+    Check for cancellation and allow the scheduler to switch to another task.
+
+    Equivalent to (but more efficient than)::
+
+        await checkpoint_if_cancelled()
+        await cancel_shielded_checkpoint()
+
+    .. versionadded:: 3.0
+
+    """
+    await get_asynclib().checkpoint()
+
+
+async def checkpoint_if_cancelled() -> None:
+    """
+    Enter a checkpoint if the enclosing cancel scope has been cancelled.
+
+    This does not allow the scheduler to switch to a different task.
+
+    .. versionadded:: 3.0
+
+    """
+    await get_asynclib().checkpoint_if_cancelled()
+
+
+async def cancel_shielded_checkpoint() -> None:
+    """
+    Allow the scheduler to switch to another task but without checking for cancellation.
+
+    Equivalent to (but potentially more efficient than)::
+
+        with CancelScope(shield=True):
+            await checkpoint()
+
+    .. versionadded:: 3.0
+
+    """
+    await get_asynclib().cancel_shielded_checkpoint()
+
+
+def current_token() -> object:
+    """Return a backend specific token object that can be used to get back to the event loop."""
+    return get_asynclib().current_token()
+
+
+_run_vars = WeakKeyDictionary()  # type: WeakKeyDictionary[Any, Dict[str, Any]]
+_token_wrappers: Dict[Any, "_TokenWrapper"] = {}
+
+
+@dataclass(frozen=True)
+class _TokenWrapper:
+    __slots__ = "_token", "__weakref__"
+    _token: object
+
+
+class _NoValueSet(enum.Enum):
+    NO_VALUE_SET = enum.auto()
+
+
+class RunvarToken(Generic[T]):
+    __slots__ = "_var", "_value", "_redeemed"
+
+    def __init__(
+        self, var: "RunVar[T]", value: Union[T, Literal[_NoValueSet.NO_VALUE_SET]]
+    ):
+        self._var = var
+        self._value: Union[T, Literal[_NoValueSet.NO_VALUE_SET]] = value
+        self._redeemed = False
+
+
+class RunVar(Generic[T]):
+    """Like a :class:`~contextvars.ContextVar`, expect scoped to the running event loop."""
+
+    __slots__ = "_name", "_default"
+
+    NO_VALUE_SET: Literal[_NoValueSet.NO_VALUE_SET] = _NoValueSet.NO_VALUE_SET
+
+    _token_wrappers: Set[_TokenWrapper] = set()
+
+    def __init__(
+        self,
+        name: str,
+        default: Union[T, Literal[_NoValueSet.NO_VALUE_SET]] = NO_VALUE_SET,
+    ):
+        self._name = name
+        self._default = default
+
+    @property
+    def _current_vars(self) -> Dict[str, T]:
+        token = current_token()
+        while True:
+            try:
+                return _run_vars[token]
+            except TypeError:
+                # Happens when token isn't weak referable (TrioToken).
+                # This workaround does mean that some memory will leak on Trio until the problem
+                # is fixed on their end.
+                token = _TokenWrapper(token)
+                self._token_wrappers.add(token)
+            except KeyError:
+                run_vars = _run_vars[token] = {}
+                return run_vars
+
+    @overload
+    def get(self, default: D) -> Union[T, D]:
+        ...
+
+    @overload
+    def get(self) -> T:
+        ...
+
+    def get(
+        self, default: Union[D, Literal[_NoValueSet.NO_VALUE_SET]] = NO_VALUE_SET
+    ) -> Union[T, D]:
+        try:
+            return self._current_vars[self._name]
+        except KeyError:
+            if default is not RunVar.NO_VALUE_SET:
+                return default
+            elif self._default is not RunVar.NO_VALUE_SET:
+                return self._default
+
+        raise LookupError(
+            f'Run variable "{self._name}" has no value and no default set'
+        )
+
+    def set(self, value: T) -> RunvarToken[T]:
+        current_vars = self._current_vars
+        token = RunvarToken(self, current_vars.get(self._name, RunVar.NO_VALUE_SET))
+        current_vars[self._name] = value
+        return token
+
+    def reset(self, token: RunvarToken[T]) -> None:
+        if token._var is not self:
+            raise ValueError("This token does not belong to this RunVar")
+
+        if token._redeemed:
+            raise ValueError("This token has already been used")
+
+        if token._value is _NoValueSet.NO_VALUE_SET:
+            try:
+                del self._current_vars[self._name]
+            except KeyError:
+                pass
+        else:
+            self._current_vars[self._name] = token._value
+
+        token._redeemed = True
+
+    def __repr__(self) -> str:
+        return f"<RunVar name={self._name!r}>"
diff --git a/myenv/lib/python3.9/site-packages/anyio/py.typed b/myenv/lib/python3.9/site-packages/anyio/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/anyio/pytest_plugin.py b/myenv/lib/python3.9/site-packages/anyio/pytest_plugin.py
new file mode 100644
index 0000000..432eee3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/pytest_plugin.py
@@ -0,0 +1,144 @@
+from contextlib import contextmanager
+from inspect import isasyncgenfunction, iscoroutinefunction
+from typing import TYPE_CHECKING, Any, Dict, Generator, Optional, Tuple, cast
+
+import pytest
+import sniffio
+from _pytest.fixtures import FixtureRequest
+
+from ._core._eventloop import get_all_backends, get_asynclib
+from .abc import TestRunner
+
+if TYPE_CHECKING:
+    from _pytest.config import Config
+
+_current_runner: Optional[TestRunner] = None
+
+
+def extract_backend_and_options(backend: object) -> Tuple[str, Dict[str, Any]]:
+    if isinstance(backend, str):
+        return backend, {}
+    elif isinstance(backend, tuple) and len(backend) == 2:
+        if isinstance(backend[0], str) and isinstance(backend[1], dict):
+            return cast(Tuple[str, Dict[str, Any]], backend)
+
+    raise TypeError("anyio_backend must be either a string or tuple of (string, dict)")
+
+
+@contextmanager
+def get_runner(
+    backend_name: str, backend_options: Dict[str, Any]
+) -> Generator[TestRunner, object, None]:
+    global _current_runner
+    if _current_runner:
+        yield _current_runner
+        return
+
+    asynclib = get_asynclib(backend_name)
+    token = None
+    if sniffio.current_async_library_cvar.get(None) is None:
+        # Since we're in control of the event loop, we can cache the name of the async library
+        token = sniffio.current_async_library_cvar.set(backend_name)
+
+    try:
+        backend_options = backend_options or {}
+        with asynclib.TestRunner(**backend_options) as runner:
+            _current_runner = runner
+            yield runner
+    finally:
+        _current_runner = None
+        if token:
+            sniffio.current_async_library_cvar.reset(token)
+
+
+def pytest_configure(config: "Config") -> None:
+    config.addinivalue_line(
+        "markers",
+        "anyio: mark the (coroutine function) test to be run "
+        "asynchronously via anyio.",
+    )
+
+
+def pytest_fixture_setup(fixturedef: Any, request: FixtureRequest) -> None:
+    def wrapper(*args, anyio_backend, **kwargs):  # type: ignore[no-untyped-def]
+        backend_name, backend_options = extract_backend_and_options(anyio_backend)
+        if has_backend_arg:
+            kwargs["anyio_backend"] = anyio_backend
+
+        with get_runner(backend_name, backend_options) as runner:
+            if isasyncgenfunction(func):
+                yield from runner.run_asyncgen_fixture(func, kwargs)
+            else:
+                yield runner.run_fixture(func, kwargs)
+
+    # Only apply this to coroutine functions and async generator functions in requests that involve
+    # the anyio_backend fixture
+    func = fixturedef.func
+    if isasyncgenfunction(func) or iscoroutinefunction(func):
+        if "anyio_backend" in request.fixturenames:
+            has_backend_arg = "anyio_backend" in fixturedef.argnames
+            fixturedef.func = wrapper
+            if not has_backend_arg:
+                fixturedef.argnames += ("anyio_backend",)
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_pycollect_makeitem(collector: Any, name: Any, obj: Any) -> None:
+    if collector.istestfunction(obj, name):
+        inner_func = obj.hypothesis.inner_test if hasattr(obj, "hypothesis") else obj
+        if iscoroutinefunction(inner_func):
+            marker = collector.get_closest_marker("anyio")
+            own_markers = getattr(obj, "pytestmark", ())
+            if marker or any(marker.name == "anyio" for marker in own_markers):
+                pytest.mark.usefixtures("anyio_backend")(obj)
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_pyfunc_call(pyfuncitem: Any) -> Optional[bool]:
+    def run_with_hypothesis(**kwargs: Any) -> None:
+        with get_runner(backend_name, backend_options) as runner:
+            runner.run_test(original_func, kwargs)
+
+    backend = pyfuncitem.funcargs.get("anyio_backend")
+    if backend:
+        backend_name, backend_options = extract_backend_and_options(backend)
+
+        if hasattr(pyfuncitem.obj, "hypothesis"):
+            # Wrap the inner test function unless it's already wrapped
+            original_func = pyfuncitem.obj.hypothesis.inner_test
+            if original_func.__qualname__ != run_with_hypothesis.__qualname__:
+                if iscoroutinefunction(original_func):
+                    pyfuncitem.obj.hypothesis.inner_test = run_with_hypothesis
+
+            return None
+
+        if iscoroutinefunction(pyfuncitem.obj):
+            funcargs = pyfuncitem.funcargs
+            testargs = {arg: funcargs[arg] for arg in pyfuncitem._fixtureinfo.argnames}
+            with get_runner(backend_name, backend_options) as runner:
+                runner.run_test(pyfuncitem.obj, testargs)
+
+            return True
+
+    return None
+
+
+@pytest.fixture(params=get_all_backends())
+def anyio_backend(request: Any) -> Any:
+    return request.param
+
+
+@pytest.fixture
+def anyio_backend_name(anyio_backend: Any) -> str:
+    if isinstance(anyio_backend, str):
+        return anyio_backend
+    else:
+        return anyio_backend[0]
+
+
+@pytest.fixture
+def anyio_backend_options(anyio_backend: Any) -> Dict[str, Any]:
+    if isinstance(anyio_backend, str):
+        return {}
+    else:
+        return anyio_backend[1]
diff --git a/myenv/lib/python3.9/site-packages/anyio/streams/__init__.py b/myenv/lib/python3.9/site-packages/anyio/streams/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/anyio/streams/buffered.py b/myenv/lib/python3.9/site-packages/anyio/streams/buffered.py
new file mode 100644
index 0000000..1503b3e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/streams/buffered.py
@@ -0,0 +1,116 @@
+from dataclasses import dataclass, field
+from typing import Any, Callable, Mapping
+
+from .. import ClosedResourceError, DelimiterNotFound, EndOfStream, IncompleteRead
+from ..abc import AnyByteReceiveStream, ByteReceiveStream
+
+
+@dataclass(eq=False)
+class BufferedByteReceiveStream(ByteReceiveStream):
+    """
+    Wraps any bytes-based receive stream and uses a buffer to provide sophisticated receiving
+    capabilities in the form of a byte stream.
+    """
+
+    receive_stream: AnyByteReceiveStream
+    _buffer: bytearray = field(init=False, default_factory=bytearray)
+    _closed: bool = field(init=False, default=False)
+
+    async def aclose(self) -> None:
+        await self.receive_stream.aclose()
+        self._closed = True
+
+    @property
+    def buffer(self) -> bytes:
+        """The bytes currently in the buffer."""
+        return bytes(self._buffer)
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return self.receive_stream.extra_attributes
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        if self._closed:
+            raise ClosedResourceError
+
+        if self._buffer:
+            chunk = bytes(self._buffer[:max_bytes])
+            del self._buffer[:max_bytes]
+            return chunk
+        elif isinstance(self.receive_stream, ByteReceiveStream):
+            return await self.receive_stream.receive(max_bytes)
+        else:
+            # With a bytes-oriented object stream, we need to handle any surplus bytes we get from
+            # the receive() call
+            chunk = await self.receive_stream.receive()
+            if len(chunk) > max_bytes:
+                # Save the surplus bytes in the buffer
+                self._buffer.extend(chunk[max_bytes:])
+                return chunk[:max_bytes]
+            else:
+                return chunk
+
+    async def receive_exactly(self, nbytes: int) -> bytes:
+        """
+        Read exactly the given amount of bytes from the stream.
+
+        :param nbytes: the number of bytes to read
+        :return: the bytes read
+        :raises ~anyio.IncompleteRead: if the stream was closed before the requested
+            amount of bytes could be read from the stream
+
+        """
+        while True:
+            remaining = nbytes - len(self._buffer)
+            if remaining <= 0:
+                retval = self._buffer[:nbytes]
+                del self._buffer[:nbytes]
+                return bytes(retval)
+
+            try:
+                if isinstance(self.receive_stream, ByteReceiveStream):
+                    chunk = await self.receive_stream.receive(remaining)
+                else:
+                    chunk = await self.receive_stream.receive()
+            except EndOfStream as exc:
+                raise IncompleteRead from exc
+
+            self._buffer.extend(chunk)
+
+    async def receive_until(self, delimiter: bytes, max_bytes: int) -> bytes:
+        """
+        Read from the stream until the delimiter is found or max_bytes have been read.
+
+        :param delimiter: the marker to look for in the stream
+        :param max_bytes: maximum number of bytes that will be read before raising
+            :exc:`~anyio.DelimiterNotFound`
+        :return: the bytes read (not including the delimiter)
+        :raises ~anyio.IncompleteRead: if the stream was closed before the delimiter
+            was found
+        :raises ~anyio.DelimiterNotFound: if the delimiter is not found within the
+            bytes read up to the maximum allowed
+
+        """
+        delimiter_size = len(delimiter)
+        offset = 0
+        while True:
+            # Check if the delimiter can be found in the current buffer
+            index = self._buffer.find(delimiter, offset)
+            if index >= 0:
+                found = self._buffer[:index]
+                del self._buffer[: index + len(delimiter) :]
+                return bytes(found)
+
+            # Check if the buffer is already at or over the limit
+            if len(self._buffer) >= max_bytes:
+                raise DelimiterNotFound(max_bytes)
+
+            # Read more data into the buffer from the socket
+            try:
+                data = await self.receive_stream.receive()
+            except EndOfStream as exc:
+                raise IncompleteRead from exc
+
+            # Move the offset forward and add the new data to the buffer
+            offset = max(len(self._buffer) - delimiter_size + 1, 0)
+            self._buffer.extend(data)
diff --git a/myenv/lib/python3.9/site-packages/anyio/streams/file.py b/myenv/lib/python3.9/site-packages/anyio/streams/file.py
new file mode 100644
index 0000000..938d1da
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/streams/file.py
@@ -0,0 +1,145 @@
+from io import SEEK_SET, UnsupportedOperation
+from os import PathLike
+from pathlib import Path
+from typing import Any, BinaryIO, Callable, Dict, Mapping, Union, cast
+
+from .. import (
+    BrokenResourceError,
+    ClosedResourceError,
+    EndOfStream,
+    TypedAttributeSet,
+    to_thread,
+    typed_attribute,
+)
+from ..abc import ByteReceiveStream, ByteSendStream
+
+
+class FileStreamAttribute(TypedAttributeSet):
+    #: the open file descriptor
+    file: BinaryIO = typed_attribute()
+    #: the path of the file on the file system, if available (file must be a real file)
+    path: Path = typed_attribute()
+    #: the file number, if available (file must be a real file or a TTY)
+    fileno: int = typed_attribute()
+
+
+class _BaseFileStream:
+    def __init__(self, file: BinaryIO):
+        self._file = file
+
+    async def aclose(self) -> None:
+        await to_thread.run_sync(self._file.close)
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        attributes: Dict[Any, Callable[[], Any]] = {
+            FileStreamAttribute.file: lambda: self._file,
+        }
+
+        if hasattr(self._file, "name"):
+            attributes[FileStreamAttribute.path] = lambda: Path(self._file.name)
+
+        try:
+            self._file.fileno()
+        except UnsupportedOperation:
+            pass
+        else:
+            attributes[FileStreamAttribute.fileno] = lambda: self._file.fileno()
+
+        return attributes
+
+
+class FileReadStream(_BaseFileStream, ByteReceiveStream):
+    """
+    A byte stream that reads from a file in the file system.
+
+    :param file: a file that has been opened for reading in binary mode
+
+    .. versionadded:: 3.0
+    """
+
+    @classmethod
+    async def from_path(cls, path: Union[str, "PathLike[str]"]) -> "FileReadStream":
+        """
+        Create a file read stream by opening the given file.
+
+        :param path: path of the file to read from
+
+        """
+        file = await to_thread.run_sync(Path(path).open, "rb")
+        return cls(cast(BinaryIO, file))
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        try:
+            data = await to_thread.run_sync(self._file.read, max_bytes)
+        except ValueError:
+            raise ClosedResourceError from None
+        except OSError as exc:
+            raise BrokenResourceError from exc
+
+        if data:
+            return data
+        else:
+            raise EndOfStream
+
+    async def seek(self, position: int, whence: int = SEEK_SET) -> int:
+        """
+        Seek the file to the given position.
+
+        .. seealso:: :meth:`io.IOBase.seek`
+
+        .. note:: Not all file descriptors are seekable.
+
+        :param position: position to seek the file to
+        :param whence: controls how ``position`` is interpreted
+        :return: the new absolute position
+        :raises OSError: if the file is not seekable
+
+        """
+        return await to_thread.run_sync(self._file.seek, position, whence)
+
+    async def tell(self) -> int:
+        """
+        Return the current stream position.
+
+        .. note:: Not all file descriptors are seekable.
+
+        :return: the current absolute position
+        :raises OSError: if the file is not seekable
+
+        """
+        return await to_thread.run_sync(self._file.tell)
+
+
+class FileWriteStream(_BaseFileStream, ByteSendStream):
+    """
+    A byte stream that writes to a file in the file system.
+
+    :param file: a file that has been opened for writing in binary mode
+
+    .. versionadded:: 3.0
+    """
+
+    @classmethod
+    async def from_path(
+        cls, path: Union[str, "PathLike[str]"], append: bool = False
+    ) -> "FileWriteStream":
+        """
+        Create a file write stream by opening the given file for writing.
+
+        :param path: path of the file to write to
+        :param append: if ``True``, open the file for appending; if ``False``, any existing file
+            at the given path will be truncated
+
+        """
+        mode = "ab" if append else "wb"
+        file = await to_thread.run_sync(Path(path).open, mode)
+        return cls(cast(BinaryIO, file))
+
+    async def send(self, item: bytes) -> None:
+        try:
+            await to_thread.run_sync(self._file.write, item)
+        except ValueError:
+            raise ClosedResourceError from None
+        except OSError as exc:
+            raise BrokenResourceError from exc
diff --git a/myenv/lib/python3.9/site-packages/anyio/streams/memory.py b/myenv/lib/python3.9/site-packages/anyio/streams/memory.py
new file mode 100644
index 0000000..d8a958c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/streams/memory.py
@@ -0,0 +1,275 @@
+from collections import OrderedDict, deque
+from dataclasses import dataclass, field
+from types import TracebackType
+from typing import Deque, Generic, List, NamedTuple, Optional, Type, TypeVar
+
+from .. import (
+    BrokenResourceError,
+    ClosedResourceError,
+    EndOfStream,
+    WouldBlock,
+    get_cancelled_exc_class,
+)
+from .._core._compat import DeprecatedAwaitable
+from ..abc import Event, ObjectReceiveStream, ObjectSendStream
+from ..lowlevel import checkpoint
+
+T_Item = TypeVar("T_Item")
+
+
+class MemoryObjectStreamStatistics(NamedTuple):
+    current_buffer_used: int  #: number of items stored in the buffer
+    #: maximum number of items that can be stored on this stream (or :data:`math.inf`)
+    max_buffer_size: float
+    open_send_streams: int  #: number of unclosed clones of the send stream
+    open_receive_streams: int  #: number of unclosed clones of the receive stream
+    tasks_waiting_send: int  #: number of tasks blocked on :meth:`MemoryObjectSendStream.send`
+    #: number of tasks blocked on :meth:`MemoryObjectReceiveStream.receive`
+    tasks_waiting_receive: int
+
+
+@dataclass(eq=False)
+class MemoryObjectStreamState(Generic[T_Item]):
+    max_buffer_size: float = field()
+    buffer: Deque[T_Item] = field(init=False, default_factory=deque)
+    open_send_channels: int = field(init=False, default=0)
+    open_receive_channels: int = field(init=False, default=0)
+    waiting_receivers: "OrderedDict[Event, List[T_Item]]" = field(
+        init=False, default_factory=OrderedDict
+    )
+    waiting_senders: "OrderedDict[Event, T_Item]" = field(
+        init=False, default_factory=OrderedDict
+    )
+
+    def statistics(self) -> MemoryObjectStreamStatistics:
+        return MemoryObjectStreamStatistics(
+            len(self.buffer),
+            self.max_buffer_size,
+            self.open_send_channels,
+            self.open_receive_channels,
+            len(self.waiting_senders),
+            len(self.waiting_receivers),
+        )
+
+
+@dataclass(eq=False)
+class MemoryObjectReceiveStream(Generic[T_Item], ObjectReceiveStream[T_Item]):
+    _state: MemoryObjectStreamState[T_Item]
+    _closed: bool = field(init=False, default=False)
+
+    def __post_init__(self) -> None:
+        self._state.open_receive_channels += 1
+
+    def receive_nowait(self) -> T_Item:
+        """
+        Receive the next item if it can be done without waiting.
+
+        :return: the received item
+        :raises ~anyio.ClosedResourceError: if this send stream has been closed
+        :raises ~anyio.EndOfStream: if the buffer is empty and this stream has been
+            closed from the sending end
+        :raises ~anyio.WouldBlock: if there are no items in the buffer and no tasks
+            waiting to send
+
+        """
+        if self._closed:
+            raise ClosedResourceError
+
+        if self._state.waiting_senders:
+            # Get the item from the next sender
+            send_event, item = self._state.waiting_senders.popitem(last=False)
+            self._state.buffer.append(item)
+            send_event.set()
+
+        if self._state.buffer:
+            return self._state.buffer.popleft()
+        elif not self._state.open_send_channels:
+            raise EndOfStream
+
+        raise WouldBlock
+
+    async def receive(self) -> T_Item:
+        await checkpoint()
+        try:
+            return self.receive_nowait()
+        except WouldBlock:
+            # Add ourselves in the queue
+            receive_event = Event()
+            container: List[T_Item] = []
+            self._state.waiting_receivers[receive_event] = container
+
+            try:
+                await receive_event.wait()
+            except get_cancelled_exc_class():
+                # Ignore the immediate cancellation if we already received an item, so as not to
+                # lose it
+                if not container:
+                    raise
+            finally:
+                self._state.waiting_receivers.pop(receive_event, None)
+
+            if container:
+                return container[0]
+            else:
+                raise EndOfStream
+
+    def clone(self) -> "MemoryObjectReceiveStream[T_Item]":
+        """
+        Create a clone of this receive stream.
+
+        Each clone can be closed separately. Only when all clones have been closed will the
+        receiving end of the memory stream be considered closed by the sending ends.
+
+        :return: the cloned stream
+
+        """
+        if self._closed:
+            raise ClosedResourceError
+
+        return MemoryObjectReceiveStream(_state=self._state)
+
+    def close(self) -> None:
+        """
+        Close the stream.
+
+        This works the exact same way as :meth:`aclose`, but is provided as a special case for the
+        benefit of synchronous callbacks.
+
+        """
+        if not self._closed:
+            self._closed = True
+            self._state.open_receive_channels -= 1
+            if self._state.open_receive_channels == 0:
+                send_events = list(self._state.waiting_senders.keys())
+                for event in send_events:
+                    event.set()
+
+    async def aclose(self) -> None:
+        self.close()
+
+    def statistics(self) -> MemoryObjectStreamStatistics:
+        """
+        Return statistics about the current state of this stream.
+
+        .. versionadded:: 3.0
+        """
+        return self._state.statistics()
+
+    def __enter__(self) -> "MemoryObjectReceiveStream[T_Item]":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.close()
+
+
+@dataclass(eq=False)
+class MemoryObjectSendStream(Generic[T_Item], ObjectSendStream[T_Item]):
+    _state: MemoryObjectStreamState[T_Item]
+    _closed: bool = field(init=False, default=False)
+
+    def __post_init__(self) -> None:
+        self._state.open_send_channels += 1
+
+    def send_nowait(self, item: T_Item) -> DeprecatedAwaitable:
+        """
+        Send an item immediately if it can be done without waiting.
+
+        :param item: the item to send
+        :raises ~anyio.ClosedResourceError: if this send stream has been closed
+        :raises ~anyio.BrokenResourceError: if the stream has been closed from the
+            receiving end
+        :raises ~anyio.WouldBlock: if the buffer is full and there are no tasks waiting
+            to receive
+
+        """
+        if self._closed:
+            raise ClosedResourceError
+        if not self._state.open_receive_channels:
+            raise BrokenResourceError
+
+        if self._state.waiting_receivers:
+            receive_event, container = self._state.waiting_receivers.popitem(last=False)
+            container.append(item)
+            receive_event.set()
+        elif len(self._state.buffer) < self._state.max_buffer_size:
+            self._state.buffer.append(item)
+        else:
+            raise WouldBlock
+
+        return DeprecatedAwaitable(self.send_nowait)
+
+    async def send(self, item: T_Item) -> None:
+        await checkpoint()
+        try:
+            self.send_nowait(item)
+        except WouldBlock:
+            # Wait until there's someone on the receiving end
+            send_event = Event()
+            self._state.waiting_senders[send_event] = item
+            try:
+                await send_event.wait()
+            except BaseException:
+                self._state.waiting_senders.pop(send_event, None)  # type: ignore[arg-type]
+                raise
+
+            if self._state.waiting_senders.pop(send_event, None):  # type: ignore[arg-type]
+                raise BrokenResourceError
+
+    def clone(self) -> "MemoryObjectSendStream[T_Item]":
+        """
+        Create a clone of this send stream.
+
+        Each clone can be closed separately. Only when all clones have been closed will the
+        sending end of the memory stream be considered closed by the receiving ends.
+
+        :return: the cloned stream
+
+        """
+        if self._closed:
+            raise ClosedResourceError
+
+        return MemoryObjectSendStream(_state=self._state)
+
+    def close(self) -> None:
+        """
+        Close the stream.
+
+        This works the exact same way as :meth:`aclose`, but is provided as a special case for the
+        benefit of synchronous callbacks.
+
+        """
+        if not self._closed:
+            self._closed = True
+            self._state.open_send_channels -= 1
+            if self._state.open_send_channels == 0:
+                receive_events = list(self._state.waiting_receivers.keys())
+                self._state.waiting_receivers.clear()
+                for event in receive_events:
+                    event.set()
+
+    async def aclose(self) -> None:
+        self.close()
+
+    def statistics(self) -> MemoryObjectStreamStatistics:
+        """
+        Return statistics about the current state of this stream.
+
+        .. versionadded:: 3.0
+        """
+        return self._state.statistics()
+
+    def __enter__(self) -> "MemoryObjectSendStream[T_Item]":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.close()
diff --git a/myenv/lib/python3.9/site-packages/anyio/streams/stapled.py b/myenv/lib/python3.9/site-packages/anyio/streams/stapled.py
new file mode 100644
index 0000000..a71ffb0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/streams/stapled.py
@@ -0,0 +1,138 @@
+from dataclasses import dataclass
+from typing import Any, Callable, Generic, List, Mapping, Optional, Sequence, TypeVar
+
+from ..abc import (
+    ByteReceiveStream,
+    ByteSendStream,
+    ByteStream,
+    Listener,
+    ObjectReceiveStream,
+    ObjectSendStream,
+    ObjectStream,
+    TaskGroup,
+)
+
+T_Item = TypeVar("T_Item")
+T_Stream = TypeVar("T_Stream")
+
+
+@dataclass(eq=False)
+class StapledByteStream(ByteStream):
+    """
+    Combines two byte streams into a single, bidirectional byte stream.
+
+    Extra attributes will be provided from both streams, with the receive stream providing the
+    values in case of a conflict.
+
+    :param ByteSendStream send_stream: the sending byte stream
+    :param ByteReceiveStream receive_stream: the receiving byte stream
+    """
+
+    send_stream: ByteSendStream
+    receive_stream: ByteReceiveStream
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        return await self.receive_stream.receive(max_bytes)
+
+    async def send(self, item: bytes) -> None:
+        await self.send_stream.send(item)
+
+    async def send_eof(self) -> None:
+        await self.send_stream.aclose()
+
+    async def aclose(self) -> None:
+        await self.send_stream.aclose()
+        await self.receive_stream.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return {
+            **self.send_stream.extra_attributes,
+            **self.receive_stream.extra_attributes,
+        }
+
+
+@dataclass(eq=False)
+class StapledObjectStream(Generic[T_Item], ObjectStream[T_Item]):
+    """
+    Combines two object streams into a single, bidirectional object stream.
+
+    Extra attributes will be provided from both streams, with the receive stream providing the
+    values in case of a conflict.
+
+    :param ObjectSendStream send_stream: the sending object stream
+    :param ObjectReceiveStream receive_stream: the receiving object stream
+    """
+
+    send_stream: ObjectSendStream[T_Item]
+    receive_stream: ObjectReceiveStream[T_Item]
+
+    async def receive(self) -> T_Item:
+        return await self.receive_stream.receive()
+
+    async def send(self, item: T_Item) -> None:
+        await self.send_stream.send(item)
+
+    async def send_eof(self) -> None:
+        await self.send_stream.aclose()
+
+    async def aclose(self) -> None:
+        await self.send_stream.aclose()
+        await self.receive_stream.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return {
+            **self.send_stream.extra_attributes,
+            **self.receive_stream.extra_attributes,
+        }
+
+
+@dataclass(eq=False)
+class MultiListener(Generic[T_Stream], Listener[T_Stream]):
+    """
+    Combines multiple listeners into one, serving connections from all of them at once.
+
+    Any MultiListeners in the given collection of listeners will have their listeners moved into
+    this one.
+
+    Extra attributes are provided from each listener, with each successive listener overriding any
+    conflicting attributes from the previous one.
+
+    :param listeners: listeners to serve
+    :type listeners: Sequence[Listener[T_Stream]]
+    """
+
+    listeners: Sequence[Listener[T_Stream]]
+
+    def __post_init__(self) -> None:
+        listeners: List[Listener[T_Stream]] = []
+        for listener in self.listeners:
+            if isinstance(listener, MultiListener):
+                listeners.extend(listener.listeners)
+                del listener.listeners[:]  # type: ignore[attr-defined]
+            else:
+                listeners.append(listener)
+
+        self.listeners = listeners
+
+    async def serve(
+        self, handler: Callable[[T_Stream], Any], task_group: Optional[TaskGroup] = None
+    ) -> None:
+        from .. import create_task_group
+
+        async with create_task_group() as tg:
+            for listener in self.listeners:
+                tg.start_soon(listener.serve, handler, task_group)
+
+    async def aclose(self) -> None:
+        for listener in self.listeners:
+            await listener.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        attributes: dict = {}
+        for listener in self.listeners:
+            attributes.update(listener.extra_attributes)
+
+        return attributes
diff --git a/myenv/lib/python3.9/site-packages/anyio/streams/text.py b/myenv/lib/python3.9/site-packages/anyio/streams/text.py
new file mode 100644
index 0000000..ccb683c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/streams/text.py
@@ -0,0 +1,141 @@
+import codecs
+from dataclasses import InitVar, dataclass, field
+from typing import Any, Callable, Mapping, Tuple
+
+from ..abc import (
+    AnyByteReceiveStream,
+    AnyByteSendStream,
+    AnyByteStream,
+    ObjectReceiveStream,
+    ObjectSendStream,
+    ObjectStream,
+)
+
+
+@dataclass(eq=False)
+class TextReceiveStream(ObjectReceiveStream[str]):
+    """
+    Stream wrapper that decodes bytes to strings using the given encoding.
+
+    Decoding is done using :class:`~codecs.IncrementalDecoder` which returns any completely
+    received unicode characters as soon as they come in.
+
+    :param transport_stream: any bytes-based receive stream
+    :param encoding: character encoding to use for decoding bytes to strings (defaults to
+        ``utf-8``)
+    :param errors: handling scheme for decoding errors (defaults to ``strict``; see the
+        `codecs module documentation`_ for a comprehensive list of options)
+
+    .. _codecs module documentation: https://docs.python.org/3/library/codecs.html#codec-objects
+    """
+
+    transport_stream: AnyByteReceiveStream
+    encoding: InitVar[str] = "utf-8"
+    errors: InitVar[str] = "strict"
+    _decoder: codecs.IncrementalDecoder = field(init=False)
+
+    def __post_init__(self, encoding: str, errors: str) -> None:
+        decoder_class = codecs.getincrementaldecoder(encoding)
+        self._decoder = decoder_class(errors=errors)
+
+    async def receive(self) -> str:
+        while True:
+            chunk = await self.transport_stream.receive()
+            decoded = self._decoder.decode(chunk)
+            if decoded:
+                return decoded
+
+    async def aclose(self) -> None:
+        await self.transport_stream.aclose()
+        self._decoder.reset()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return self.transport_stream.extra_attributes
+
+
+@dataclass(eq=False)
+class TextSendStream(ObjectSendStream[str]):
+    """
+    Sends strings to the wrapped stream as bytes using the given encoding.
+
+    :param AnyByteSendStream transport_stream: any bytes-based send stream
+    :param str encoding: character encoding to use for encoding strings to bytes (defaults to
+        ``utf-8``)
+    :param str errors: handling scheme for encoding errors (defaults to ``strict``; see the
+        `codecs module documentation`_ for a comprehensive list of options)
+
+    .. _codecs module documentation: https://docs.python.org/3/library/codecs.html#codec-objects
+    """
+
+    transport_stream: AnyByteSendStream
+    encoding: InitVar[str] = "utf-8"
+    errors: str = "strict"
+    _encoder: Callable[..., Tuple[bytes, int]] = field(init=False)
+
+    def __post_init__(self, encoding: str) -> None:
+        self._encoder = codecs.getencoder(encoding)
+
+    async def send(self, item: str) -> None:
+        encoded = self._encoder(item, self.errors)[0]
+        await self.transport_stream.send(encoded)
+
+    async def aclose(self) -> None:
+        await self.transport_stream.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return self.transport_stream.extra_attributes
+
+
+@dataclass(eq=False)
+class TextStream(ObjectStream[str]):
+    """
+    A bidirectional stream that decodes bytes to strings on receive and encodes strings to bytes on
+    send.
+
+    Extra attributes will be provided from both streams, with the receive stream providing the
+    values in case of a conflict.
+
+    :param AnyByteStream transport_stream: any bytes-based stream
+    :param str encoding: character encoding to use for encoding/decoding strings to/from bytes
+        (defaults to ``utf-8``)
+    :param str errors: handling scheme for encoding errors (defaults to ``strict``; see the
+        `codecs module documentation`_ for a comprehensive list of options)
+
+    .. _codecs module documentation: https://docs.python.org/3/library/codecs.html#codec-objects
+    """
+
+    transport_stream: AnyByteStream
+    encoding: InitVar[str] = "utf-8"
+    errors: InitVar[str] = "strict"
+    _receive_stream: TextReceiveStream = field(init=False)
+    _send_stream: TextSendStream = field(init=False)
+
+    def __post_init__(self, encoding: str, errors: str) -> None:
+        self._receive_stream = TextReceiveStream(
+            self.transport_stream, encoding=encoding, errors=errors
+        )
+        self._send_stream = TextSendStream(
+            self.transport_stream, encoding=encoding, errors=errors
+        )
+
+    async def receive(self) -> str:
+        return await self._receive_stream.receive()
+
+    async def send(self, item: str) -> None:
+        await self._send_stream.send(item)
+
+    async def send_eof(self) -> None:
+        await self.transport_stream.send_eof()
+
+    async def aclose(self) -> None:
+        await self._send_stream.aclose()
+        await self._receive_stream.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return {
+            **self._send_stream.extra_attributes,
+            **self._receive_stream.extra_attributes,
+        }
diff --git a/myenv/lib/python3.9/site-packages/anyio/streams/tls.py b/myenv/lib/python3.9/site-packages/anyio/streams/tls.py
new file mode 100644
index 0000000..c8e19e2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/streams/tls.py
@@ -0,0 +1,317 @@
+import logging
+import re
+import ssl
+from dataclasses import dataclass
+from functools import wraps
+from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple, TypeVar, Union
+
+from .. import (
+    BrokenResourceError,
+    EndOfStream,
+    aclose_forcefully,
+    get_cancelled_exc_class,
+)
+from .._core._typedattr import TypedAttributeSet, typed_attribute
+from ..abc import AnyByteStream, ByteStream, Listener, TaskGroup
+
+T_Retval = TypeVar("T_Retval")
+_PCTRTT = Tuple[Tuple[str, str], ...]
+_PCTRTTT = Tuple[_PCTRTT, ...]
+
+
+class TLSAttribute(TypedAttributeSet):
+    """Contains Transport Layer Security related attributes."""
+
+    #: the selected ALPN protocol
+    alpn_protocol: Optional[str] = typed_attribute()
+    #: the channel binding for type ``tls-unique``
+    channel_binding_tls_unique: bytes = typed_attribute()
+    #: the selected cipher
+    cipher: Tuple[str, str, int] = typed_attribute()
+    #: the peer certificate in dictionary form (see :meth:`ssl.SSLSocket.getpeercert` for more
+    #: information)
+    peer_certificate: Optional[
+        Dict[str, Union[str, _PCTRTTT, _PCTRTT]]
+    ] = typed_attribute()
+    #: the peer certificate in binary form
+    peer_certificate_binary: Optional[bytes] = typed_attribute()
+    #: ``True`` if this is the server side of the connection
+    server_side: bool = typed_attribute()
+    #: ciphers shared between both ends of the TLS connection
+    shared_ciphers: List[Tuple[str, str, int]] = typed_attribute()
+    #: the :class:`~ssl.SSLObject` used for encryption
+    ssl_object: ssl.SSLObject = typed_attribute()
+    #: ``True`` if this stream does (and expects) a closing TLS handshake when the stream is being
+    #: closed
+    standard_compatible: bool = typed_attribute()
+    #: the TLS protocol version (e.g. ``TLSv1.2``)
+    tls_version: str = typed_attribute()
+
+
+@dataclass(eq=False)
+class TLSStream(ByteStream):
+    """
+    A stream wrapper that encrypts all sent data and decrypts received data.
+
+    This class has no public initializer; use :meth:`wrap` instead.
+    All extra attributes from :class:`~TLSAttribute` are supported.
+
+    :var AnyByteStream transport_stream: the wrapped stream
+
+    """
+
+    transport_stream: AnyByteStream
+    standard_compatible: bool
+    _ssl_object: ssl.SSLObject
+    _read_bio: ssl.MemoryBIO
+    _write_bio: ssl.MemoryBIO
+
+    @classmethod
+    async def wrap(
+        cls,
+        transport_stream: AnyByteStream,
+        *,
+        server_side: Optional[bool] = None,
+        hostname: Optional[str] = None,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        standard_compatible: bool = True,
+    ) -> "TLSStream":
+        """
+        Wrap an existing stream with Transport Layer Security.
+
+        This performs a TLS handshake with the peer.
+
+        :param transport_stream: a bytes-transporting stream to wrap
+        :param server_side: ``True`` if this is the server side of the connection, ``False`` if
+            this is the client side (if omitted, will be set to ``False`` if ``hostname`` has been
+            provided, ``False`` otherwise). Used only to create a default context when an explicit
+            context has not been provided.
+        :param hostname: host name of the peer (if host name checking is desired)
+        :param ssl_context: the SSLContext object to use (if not provided, a secure default will be
+            created)
+        :param standard_compatible: if ``False``, skip the closing handshake when closing the
+            connection, and don't raise an exception if the peer does the same
+        :raises ~ssl.SSLError: if the TLS handshake fails
+
+        """
+        if server_side is None:
+            server_side = not hostname
+
+        if not ssl_context:
+            purpose = (
+                ssl.Purpose.CLIENT_AUTH if server_side else ssl.Purpose.SERVER_AUTH
+            )
+            ssl_context = ssl.create_default_context(purpose)
+
+            # Re-enable detection of unexpected EOFs if it was disabled by Python
+            if hasattr(ssl, "OP_IGNORE_UNEXPECTED_EOF"):
+                ssl_context.options ^= ssl.OP_IGNORE_UNEXPECTED_EOF  # type: ignore[attr-defined]
+
+        bio_in = ssl.MemoryBIO()
+        bio_out = ssl.MemoryBIO()
+        ssl_object = ssl_context.wrap_bio(
+            bio_in, bio_out, server_side=server_side, server_hostname=hostname
+        )
+        wrapper = cls(
+            transport_stream=transport_stream,
+            standard_compatible=standard_compatible,
+            _ssl_object=ssl_object,
+            _read_bio=bio_in,
+            _write_bio=bio_out,
+        )
+        await wrapper._call_sslobject_method(ssl_object.do_handshake)
+        return wrapper
+
+    async def _call_sslobject_method(
+        self, func: Callable[..., T_Retval], *args: object
+    ) -> T_Retval:
+        while True:
+            try:
+                result = func(*args)
+            except ssl.SSLWantReadError:
+                try:
+                    # Flush any pending writes first
+                    if self._write_bio.pending:
+                        await self.transport_stream.send(self._write_bio.read())
+
+                    data = await self.transport_stream.receive()
+                except EndOfStream:
+                    self._read_bio.write_eof()
+                except OSError as exc:
+                    self._read_bio.write_eof()
+                    self._write_bio.write_eof()
+                    raise BrokenResourceError from exc
+                else:
+                    self._read_bio.write(data)
+            except ssl.SSLWantWriteError:
+                await self.transport_stream.send(self._write_bio.read())
+            except ssl.SSLSyscallError as exc:
+                self._read_bio.write_eof()
+                self._write_bio.write_eof()
+                raise BrokenResourceError from exc
+            except ssl.SSLError as exc:
+                self._read_bio.write_eof()
+                self._write_bio.write_eof()
+                if (
+                    isinstance(exc, ssl.SSLEOFError)
+                    or "UNEXPECTED_EOF_WHILE_READING" in exc.strerror
+                ):
+                    if self.standard_compatible:
+                        raise BrokenResourceError from exc
+                    else:
+                        raise EndOfStream from None
+
+                raise
+            else:
+                # Flush any pending writes first
+                if self._write_bio.pending:
+                    await self.transport_stream.send(self._write_bio.read())
+
+                return result
+
+    async def unwrap(self) -> Tuple[AnyByteStream, bytes]:
+        """
+        Does the TLS closing handshake.
+
+        :return: a tuple of (wrapped byte stream, bytes left in the read buffer)
+
+        """
+        await self._call_sslobject_method(self._ssl_object.unwrap)
+        self._read_bio.write_eof()
+        self._write_bio.write_eof()
+        return self.transport_stream, self._read_bio.read()
+
+    async def aclose(self) -> None:
+        if self.standard_compatible:
+            try:
+                await self.unwrap()
+            except BaseException:
+                await aclose_forcefully(self.transport_stream)
+                raise
+
+        await self.transport_stream.aclose()
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        data = await self._call_sslobject_method(self._ssl_object.read, max_bytes)
+        if not data:
+            raise EndOfStream
+
+        return data
+
+    async def send(self, item: bytes) -> None:
+        await self._call_sslobject_method(self._ssl_object.write, item)
+
+    async def send_eof(self) -> None:
+        tls_version = self.extra(TLSAttribute.tls_version)
+        match = re.match(r"TLSv(\d+)(?:\.(\d+))?", tls_version)
+        if match:
+            major, minor = int(match.group(1)), int(match.group(2) or 0)
+            if (major, minor) < (1, 3):
+                raise NotImplementedError(
+                    f"send_eof() requires at least TLSv1.3; current "
+                    f"session uses {tls_version}"
+                )
+
+        raise NotImplementedError(
+            "send_eof() has not yet been implemented for TLS streams"
+        )
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return {
+            **self.transport_stream.extra_attributes,
+            TLSAttribute.alpn_protocol: self._ssl_object.selected_alpn_protocol,
+            TLSAttribute.channel_binding_tls_unique: self._ssl_object.get_channel_binding,
+            TLSAttribute.cipher: self._ssl_object.cipher,
+            TLSAttribute.peer_certificate: lambda: self._ssl_object.getpeercert(False),
+            TLSAttribute.peer_certificate_binary: lambda: self._ssl_object.getpeercert(
+                True
+            ),
+            TLSAttribute.server_side: lambda: self._ssl_object.server_side,
+            TLSAttribute.shared_ciphers: lambda: self._ssl_object.shared_ciphers(),
+            TLSAttribute.standard_compatible: lambda: self.standard_compatible,
+            TLSAttribute.ssl_object: lambda: self._ssl_object,
+            TLSAttribute.tls_version: self._ssl_object.version,
+        }
+
+
+@dataclass(eq=False)
+class TLSListener(Listener[TLSStream]):
+    """
+    A convenience listener that wraps another listener and auto-negotiates a TLS session on every
+    accepted connection.
+
+    If the TLS handshake times out or raises an exception, :meth:`handle_handshake_error` is
+    called to do whatever post-mortem processing is deemed necessary.
+
+    Supports only the :attr:`~TLSAttribute.standard_compatible` extra attribute.
+
+    :param Listener listener: the listener to wrap
+    :param ssl_context: the SSL context object
+    :param standard_compatible: a flag passed through to :meth:`TLSStream.wrap`
+    :param handshake_timeout: time limit for the TLS handshake
+        (passed to :func:`~anyio.fail_after`)
+    """
+
+    listener: Listener[Any]
+    ssl_context: ssl.SSLContext
+    standard_compatible: bool = True
+    handshake_timeout: float = 30
+
+    @staticmethod
+    async def handle_handshake_error(exc: BaseException, stream: AnyByteStream) -> None:
+        f"""
+        Handle an exception raised during the TLS handshake.
+
+        This method does 3 things:
+
+        #. Forcefully closes the original stream
+        #. Logs the exception (unless it was a cancellation exception) using the ``{__name__}``
+           logger
+        #. Reraises the exception if it was a base exception or a cancellation exception
+
+        :param exc: the exception
+        :param stream: the original stream
+
+        """
+        await aclose_forcefully(stream)
+
+        # Log all except cancellation exceptions
+        if not isinstance(exc, get_cancelled_exc_class()):
+            logging.getLogger(__name__).exception("Error during TLS handshake")
+
+        # Only reraise base exceptions and cancellation exceptions
+        if not isinstance(exc, Exception) or isinstance(exc, get_cancelled_exc_class()):
+            raise
+
+    async def serve(
+        self,
+        handler: Callable[[TLSStream], Any],
+        task_group: Optional[TaskGroup] = None,
+    ) -> None:
+        @wraps(handler)
+        async def handler_wrapper(stream: AnyByteStream) -> None:
+            from .. import fail_after
+
+            try:
+                with fail_after(self.handshake_timeout):
+                    wrapped_stream = await TLSStream.wrap(
+                        stream,
+                        ssl_context=self.ssl_context,
+                        standard_compatible=self.standard_compatible,
+                    )
+            except BaseException as exc:
+                await self.handle_handshake_error(exc, stream)
+            else:
+                await handler(wrapped_stream)
+
+        await self.listener.serve(handler_wrapper, task_group)
+
+    async def aclose(self) -> None:
+        await self.listener.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return {
+            TLSAttribute.standard_compatible: lambda: self.standard_compatible,
+        }
diff --git a/myenv/lib/python3.9/site-packages/anyio/to_process.py b/myenv/lib/python3.9/site-packages/anyio/to_process.py
new file mode 100644
index 0000000..39a3173
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/to_process.py
@@ -0,0 +1,247 @@
+import os
+import pickle
+import subprocess
+import sys
+from collections import deque
+from importlib.util import module_from_spec, spec_from_file_location
+from typing import Callable, Deque, List, Optional, Set, Tuple, TypeVar, cast
+
+from ._core._eventloop import current_time, get_asynclib, get_cancelled_exc_class
+from ._core._exceptions import BrokenWorkerProcess
+from ._core._subprocesses import open_process
+from ._core._synchronization import CapacityLimiter
+from ._core._tasks import CancelScope, fail_after
+from .abc import ByteReceiveStream, ByteSendStream, Process
+from .lowlevel import RunVar, checkpoint_if_cancelled
+from .streams.buffered import BufferedByteReceiveStream
+
+WORKER_MAX_IDLE_TIME = 300  # 5 minutes
+
+T_Retval = TypeVar("T_Retval")
+_process_pool_workers: RunVar[Set[Process]] = RunVar("_process_pool_workers")
+_process_pool_idle_workers: RunVar[Deque[Tuple[Process, float]]] = RunVar(
+    "_process_pool_idle_workers"
+)
+_default_process_limiter: RunVar[CapacityLimiter] = RunVar("_default_process_limiter")
+
+
+async def run_sync(
+    func: Callable[..., T_Retval],
+    *args: object,
+    cancellable: bool = False,
+    limiter: Optional[CapacityLimiter] = None,
+) -> T_Retval:
+    """
+    Call the given function with the given arguments in a worker process.
+
+    If the ``cancellable`` option is enabled and the task waiting for its completion is cancelled,
+    the worker process running it will be abruptly terminated using SIGKILL (or
+    ``terminateProcess()`` on Windows).
+
+    :param func: a callable
+    :param args: positional arguments for the callable
+    :param cancellable: ``True`` to allow cancellation of the operation while it's running
+    :param limiter: capacity limiter to use to limit the total amount of processes running
+        (if omitted, the default limiter is used)
+    :return: an awaitable that yields the return value of the function.
+
+    """
+
+    async def send_raw_command(pickled_cmd: bytes) -> object:
+        try:
+            await stdin.send(pickled_cmd)
+            response = await buffered.receive_until(b"\n", 50)
+            status, length = response.split(b" ")
+            if status not in (b"RETURN", b"EXCEPTION"):
+                raise RuntimeError(
+                    f"Worker process returned unexpected response: {response!r}"
+                )
+
+            pickled_response = await buffered.receive_exactly(int(length))
+        except BaseException as exc:
+            workers.discard(process)
+            try:
+                process.kill()
+                with CancelScope(shield=True):
+                    await process.aclose()
+            except ProcessLookupError:
+                pass
+
+            if isinstance(exc, get_cancelled_exc_class()):
+                raise
+            else:
+                raise BrokenWorkerProcess from exc
+
+        retval = pickle.loads(pickled_response)
+        if status == b"EXCEPTION":
+            assert isinstance(retval, BaseException)
+            raise retval
+        else:
+            return retval
+
+    # First pickle the request before trying to reserve a worker process
+    await checkpoint_if_cancelled()
+    request = pickle.dumps(("run", func, args), protocol=pickle.HIGHEST_PROTOCOL)
+
+    # If this is the first run in this event loop thread, set up the necessary variables
+    try:
+        workers = _process_pool_workers.get()
+        idle_workers = _process_pool_idle_workers.get()
+    except LookupError:
+        workers = set()
+        idle_workers = deque()
+        _process_pool_workers.set(workers)
+        _process_pool_idle_workers.set(idle_workers)
+        get_asynclib().setup_process_pool_exit_at_shutdown(workers)
+
+    async with (limiter or current_default_process_limiter()):
+        # Pop processes from the pool (starting from the most recently used) until we find one that
+        # hasn't exited yet
+        process: Process
+        while idle_workers:
+            process, idle_since = idle_workers.pop()
+            if process.returncode is None:
+                stdin = cast(ByteSendStream, process.stdin)
+                buffered = BufferedByteReceiveStream(
+                    cast(ByteReceiveStream, process.stdout)
+                )
+
+                # Prune any other workers that have been idle for WORKER_MAX_IDLE_TIME seconds or
+                # longer
+                now = current_time()
+                killed_processes: List[Process] = []
+                while idle_workers:
+                    if now - idle_workers[0][1] < WORKER_MAX_IDLE_TIME:
+                        break
+
+                    process, idle_since = idle_workers.popleft()
+                    process.kill()
+                    workers.remove(process)
+                    killed_processes.append(process)
+
+                with CancelScope(shield=True):
+                    for process in killed_processes:
+                        await process.aclose()
+
+                break
+
+            workers.remove(process)
+        else:
+            command = [sys.executable, "-u", "-m", __name__]
+            process = await open_process(
+                command, stdin=subprocess.PIPE, stdout=subprocess.PIPE
+            )
+            try:
+                stdin = cast(ByteSendStream, process.stdin)
+                buffered = BufferedByteReceiveStream(
+                    cast(ByteReceiveStream, process.stdout)
+                )
+                with fail_after(20):
+                    message = await buffered.receive(6)
+
+                if message != b"READY\n":
+                    raise BrokenWorkerProcess(
+                        f"Worker process returned unexpected response: {message!r}"
+                    )
+
+                main_module_path = getattr(sys.modules["__main__"], "__file__", None)
+                pickled = pickle.dumps(
+                    ("init", sys.path, main_module_path),
+                    protocol=pickle.HIGHEST_PROTOCOL,
+                )
+                await send_raw_command(pickled)
+            except (BrokenWorkerProcess, get_cancelled_exc_class()):
+                raise
+            except BaseException as exc:
+                process.kill()
+                raise BrokenWorkerProcess(
+                    "Error during worker process initialization"
+                ) from exc
+
+            workers.add(process)
+
+        with CancelScope(shield=not cancellable):
+            try:
+                return cast(T_Retval, await send_raw_command(request))
+            finally:
+                if process in workers:
+                    idle_workers.append((process, current_time()))
+
+
+def current_default_process_limiter() -> CapacityLimiter:
+    """
+    Return the capacity limiter that is used by default to limit the number of worker processes.
+
+    :return: a capacity limiter object
+
+    """
+    try:
+        return _default_process_limiter.get()
+    except LookupError:
+        limiter = CapacityLimiter(os.cpu_count() or 2)
+        _default_process_limiter.set(limiter)
+        return limiter
+
+
+def process_worker() -> None:
+    # Redirect standard streams to os.devnull so that user code won't interfere with the
+    # parent-worker communication
+    stdin = sys.stdin
+    stdout = sys.stdout
+    sys.stdin = open(os.devnull)
+    sys.stdout = open(os.devnull, "w")
+
+    stdout.buffer.write(b"READY\n")
+    while True:
+        retval = exception = None
+        try:
+            command, *args = pickle.load(stdin.buffer)
+        except EOFError:
+            return
+        except BaseException as exc:
+            exception = exc
+        else:
+            if command == "run":
+                func, args = args
+                try:
+                    retval = func(*args)
+                except BaseException as exc:
+                    exception = exc
+            elif command == "init":
+                main_module_path: Optional[str]
+                sys.path, main_module_path = args
+                del sys.modules["__main__"]
+                if main_module_path:
+                    # Load the parent's main module but as __mp_main__ instead of __main__
+                    # (like multiprocessing does) to avoid infinite recursion
+                    try:
+                        spec = spec_from_file_location("__mp_main__", main_module_path)
+                        if spec and spec.loader:
+                            main = module_from_spec(spec)
+                            spec.loader.exec_module(main)
+                            sys.modules["__main__"] = main
+                    except BaseException as exc:
+                        exception = exc
+
+        try:
+            if exception is not None:
+                status = b"EXCEPTION"
+                pickled = pickle.dumps(exception, pickle.HIGHEST_PROTOCOL)
+            else:
+                status = b"RETURN"
+                pickled = pickle.dumps(retval, pickle.HIGHEST_PROTOCOL)
+        except BaseException as exc:
+            exception = exc
+            status = b"EXCEPTION"
+            pickled = pickle.dumps(exc, pickle.HIGHEST_PROTOCOL)
+
+        stdout.buffer.write(b"%s %d\n" % (status, len(pickled)))
+        stdout.buffer.write(pickled)
+
+        # Respect SIGTERM
+        if isinstance(exception, SystemExit):
+            raise exception
+
+
+if __name__ == "__main__":
+    process_worker()
diff --git a/myenv/lib/python3.9/site-packages/anyio/to_thread.py b/myenv/lib/python3.9/site-packages/anyio/to_thread.py
new file mode 100644
index 0000000..a2fd42f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/anyio/to_thread.py
@@ -0,0 +1,65 @@
+from typing import Callable, Optional, TypeVar
+from warnings import warn
+
+from ._core._eventloop import get_asynclib
+from .abc import CapacityLimiter
+
+T_Retval = TypeVar("T_Retval")
+
+
+async def run_sync(
+    func: Callable[..., T_Retval],
+    *args: object,
+    cancellable: bool = False,
+    limiter: Optional[CapacityLimiter] = None
+) -> T_Retval:
+    """
+    Call the given function with the given arguments in a worker thread.
+
+    If the ``cancellable`` option is enabled and the task waiting for its completion is cancelled,
+    the thread will still run its course but its return value (or any raised exception) will be
+    ignored.
+
+    :param func: a callable
+    :param args: positional arguments for the callable
+    :param cancellable: ``True`` to allow cancellation of the operation
+    :param limiter: capacity limiter to use to limit the total amount of threads running
+        (if omitted, the default limiter is used)
+    :return: an awaitable that yields the return value of the function.
+
+    """
+    return await get_asynclib().run_sync_in_worker_thread(
+        func, *args, cancellable=cancellable, limiter=limiter
+    )
+
+
+async def run_sync_in_worker_thread(
+    func: Callable[..., T_Retval],
+    *args: object,
+    cancellable: bool = False,
+    limiter: Optional[CapacityLimiter] = None
+) -> T_Retval:
+    warn(
+        "run_sync_in_worker_thread() has been deprecated, use anyio.to_thread.run_sync() instead",
+        DeprecationWarning,
+    )
+    return await run_sync(func, *args, cancellable=cancellable, limiter=limiter)
+
+
+def current_default_thread_limiter() -> CapacityLimiter:
+    """
+    Return the capacity limiter that is used by default to limit the number of concurrent threads.
+
+    :return: a capacity limiter object
+
+    """
+    return get_asynclib().current_default_thread_limiter()
+
+
+def current_default_worker_thread_limiter() -> CapacityLimiter:
+    warn(
+        "current_default_worker_thread_limiter() has been deprecated, "
+        "use anyio.to_thread.current_default_thread_limiter() instead",
+        DeprecationWarning,
+    )
+    return current_default_thread_limiter()
diff --git a/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/LICENSE
new file mode 100644
index 0000000..5f4f225
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) Django Software Foundation and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of Django nor the names of its contributors may be used
+       to endorse or promote products derived from this software without
+       specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/METADATA b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/METADATA
new file mode 100644
index 0000000..48f0b33
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/METADATA
@@ -0,0 +1,245 @@
+Metadata-Version: 2.1
+Name: asgiref
+Version: 3.5.2
+Summary: ASGI specs, helper code, and adapters
+Home-page: https://github.com/django/asgiref/
+Author: Django Software Foundation
+Author-email: foundation@djangoproject.com
+License: BSD
+Project-URL: Documentation, https://asgi.readthedocs.io/
+Project-URL: Further Documentation, https://docs.djangoproject.com/en/stable/topics/async/#async-adapter-functions
+Project-URL: Changelog, https://github.com/django/asgiref/blob/master/CHANGELOG.txt
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: typing-extensions ; python_version < "3.8"
+Provides-Extra: tests
+Requires-Dist: pytest ; extra == 'tests'
+Requires-Dist: pytest-asyncio ; extra == 'tests'
+Requires-Dist: mypy (>=0.800) ; extra == 'tests'
+
+asgiref
+=======
+
+.. image:: https://api.travis-ci.org/django/asgiref.svg
+    :target: https://travis-ci.org/django/asgiref
+
+.. image:: https://img.shields.io/pypi/v/asgiref.svg
+    :target: https://pypi.python.org/pypi/asgiref
+
+ASGI is a standard for Python asynchronous web apps and servers to communicate
+with each other, and positioned as an asynchronous successor to WSGI. You can
+read more at https://asgi.readthedocs.io/en/latest/
+
+This package includes ASGI base libraries, such as:
+
+* Sync-to-async and async-to-sync function wrappers, ``asgiref.sync``
+* Server base classes, ``asgiref.server``
+* A WSGI-to-ASGI adapter, in ``asgiref.wsgi``
+
+
+Function wrappers
+-----------------
+
+These allow you to wrap or decorate async or sync functions to call them from
+the other style (so you can call async functions from a synchronous thread,
+or vice-versa).
+
+In particular:
+
+* AsyncToSync lets a synchronous subthread stop and wait while the async
+  function is called on the main thread's event loop, and then control is
+  returned to the thread when the async function is finished.
+
+* SyncToAsync lets async code call a synchronous function, which is run in
+  a threadpool and control returned to the async coroutine when the synchronous
+  function completes.
+
+The idea is to make it easier to call synchronous APIs from async code and
+asynchronous APIs from synchronous code so it's easier to transition code from
+one style to the other. In the case of Channels, we wrap the (synchronous)
+Django view system with SyncToAsync to allow it to run inside the (asynchronous)
+ASGI server.
+
+Note that exactly what threads things run in is very specific, and aimed to
+keep maximum compatibility with old synchronous code. See
+"Synchronous code & Threads" below for a full explanation. By default,
+``sync_to_async`` will run all synchronous code in the program in the same
+thread for safety reasons; you can disable this for more performance with
+``@sync_to_async(thread_sensitive=False)``, but make sure that your code does
+not rely on anything bound to threads (like database connections) when you do.
+
+
+Threadlocal replacement
+-----------------------
+
+This is a drop-in replacement for ``threading.local`` that works with both
+threads and asyncio Tasks. Even better, it will proxy values through from a
+task-local context to a thread-local context when you use ``sync_to_async``
+to run things in a threadpool, and vice-versa for ``async_to_sync``.
+
+If you instead want true thread- and task-safety, you can set
+``thread_critical`` on the Local object to ensure this instead.
+
+
+Server base classes
+-------------------
+
+Includes a ``StatelessServer`` class which provides all the hard work of
+writing a stateless server (as in, does not handle direct incoming sockets
+but instead consumes external streams or sockets to work out what is happening).
+
+An example of such a server would be a chatbot server that connects out to
+a central chat server and provides a "connection scope" per user chatting to
+it. There's only one actual connection, but the server has to separate things
+into several scopes for easier writing of the code.
+
+You can see an example of this being used in `frequensgi <https://github.com/andrewgodwin/frequensgi>`_.
+
+
+WSGI-to-ASGI adapter
+--------------------
+
+Allows you to wrap a WSGI application so it appears as a valid ASGI application.
+
+Simply wrap it around your WSGI application like so::
+
+    asgi_application = WsgiToAsgi(wsgi_application)
+
+The WSGI application will be run in a synchronous threadpool, and the wrapped
+ASGI application will be one that accepts ``http`` class messages.
+
+Please note that not all extended features of WSGI may be supported (such as
+file handles for incoming POST bodies).
+
+
+Dependencies
+------------
+
+``asgiref`` requires Python 3.7 or higher.
+
+
+Contributing
+------------
+
+Please refer to the
+`main Channels contributing docs <https://github.com/django/channels/blob/master/CONTRIBUTING.rst>`_.
+
+
+Testing
+'''''''
+
+To run tests, make sure you have installed the ``tests`` extra with the package::
+
+    cd asgiref/
+    pip install -e .[tests]
+    pytest
+
+
+Building the documentation
+''''''''''''''''''''''''''
+
+The documentation uses `Sphinx <http://www.sphinx-doc.org>`_::
+
+    cd asgiref/docs/
+    pip install sphinx
+
+To build the docs, you can use the default tools::
+
+    sphinx-build -b html . _build/html  # or `make html`, if you've got make set up
+    cd _build/html
+    python -m http.server
+
+...or you can use ``sphinx-autobuild`` to run a server and rebuild/reload
+your documentation changes automatically::
+
+    pip install sphinx-autobuild
+    sphinx-autobuild . _build/html
+
+
+Releasing
+'''''''''
+
+To release, first add details to CHANGELOG.txt and update the version number in ``asgiref/__init__.py``.
+
+Then, build and push the packages::
+
+    python -m build
+    twine upload dist/*
+    rm -r build/ dist/
+
+
+Implementation Details
+----------------------
+
+Synchronous code & threads
+''''''''''''''''''''''''''
+
+The ``asgiref.sync`` module provides two wrappers that let you go between
+asynchronous and synchronous code at will, while taking care of the rough edges
+for you.
+
+Unfortunately, the rough edges are numerous, and the code has to work especially
+hard to keep things in the same thread as much as possible. Notably, the
+restrictions we are working with are:
+
+* All synchronous code called through ``SyncToAsync`` and marked with
+  ``thread_sensitive`` should run in the same thread as each other (and if the
+  outer layer of the program is synchronous, the main thread)
+
+* If a thread already has a running async loop, ``AsyncToSync`` can't run things
+  on that loop if it's blocked on synchronous code that is above you in the
+  call stack.
+
+The first compromise you get to might be that ``thread_sensitive`` code should
+just run in the same thread and not spawn in a sub-thread, fulfilling the first
+restriction, but that immediately runs you into the second restriction.
+
+The only real solution is to essentially have a variant of ThreadPoolExecutor
+that executes any ``thread_sensitive`` code on the outermost synchronous
+thread - either the main thread, or a single spawned subthread.
+
+This means you now have two basic states:
+
+* If the outermost layer of your program is synchronous, then all async code
+  run through ``AsyncToSync`` will run in a per-call event loop in arbitrary
+  sub-threads, while all ``thread_sensitive`` code will run in the main thread.
+
+* If the outermost layer of your program is asynchronous, then all async code
+  runs on the main thread's event loop, and all ``thread_sensitive`` synchronous
+  code will run in a single shared sub-thread.
+
+Crucially, this means that in both cases there is a thread which is a shared
+resource that all ``thread_sensitive`` code must run on, and there is a chance
+that this thread is currently blocked on its own ``AsyncToSync`` call. Thus,
+``AsyncToSync`` needs to act as an executor for thread code while it's blocking.
+
+The ``CurrentThreadExecutor`` class provides this functionality; rather than
+simply waiting on a Future, you can call its ``run_until_future`` method and
+it will run submitted code until that Future is done. This means that code
+inside the call can then run code on your thread.
+
+
+Maintenance and Security
+------------------------
+
+To report security issues, please contact security@djangoproject.com. For GPG
+signatures and more security process information, see
+https://docs.djangoproject.com/en/dev/internals/security/.
+
+To report bugs or request new features, please open a new GitHub issue.
+
+This repository is part of the Channels project. For the shepherd and maintenance team, please see the
+`main Channels readme <https://github.com/django/channels/blob/master/README.rst>`_.
diff --git a/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/RECORD b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/RECORD
new file mode 100644
index 0000000..83e51b9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/RECORD
@@ -0,0 +1,17 @@
+asgiref/__init__.py,sha256=LtYJ5AVwuiAlsrJUQwzHZMrGMIRn7cuIoIt4OznYy6c,22
+asgiref/compatibility.py,sha256=MVH2bEdiCMMVTLbE-1V6KiU7q4LwqzP7PIufeXa-njM,1598
+asgiref/current_thread_executor.py,sha256=oeH8zv2tTmcbpxdUmOSMzbEXzeY5nJzIMFvzprE95gA,2801
+asgiref/local.py,sha256=nx5RqVFLYgUJVaxzApuQUW7dd9y21sruMYdgISoRs1k,4854
+asgiref/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+asgiref/server.py,sha256=egTQhZo1k4G0F7SSBQNp_VOekpGcjBJZU2kkCoiGC_M,6005
+asgiref/sync.py,sha256=3P813NHl3EHPMtzPEjaBelmjV_JUw97zYbtx-MmLUiw,20185
+asgiref/testing.py,sha256=3byNRV7Oto_Fg8Z-fErQJ3yGf7OQlcUexbN_cDQugzQ,3119
+asgiref/timeout.py,sha256=5Ekbmn3X1HPR55qgx-hPJMPEu_-YoivHqNhFEitiSYE,3440
+asgiref/typing.py,sha256=MZ7vbJY1F7EQqo9gL9pMSFRMw9b_SQrQQsnvlJQ2iP4,5603
+asgiref/wsgi.py,sha256=-L0eo_uK_dq7EPjv1meW1BRGytURaO9NPESxnJc9CtA,6575
+asgiref-3.5.2.dist-info/LICENSE,sha256=uEZBXRtRTpwd_xSiLeuQbXlLxUbKYSn5UKGM0JHipmk,1552
+asgiref-3.5.2.dist-info/METADATA,sha256=3JU5Zw-j9qCKPcuf3cJZ5dVispB_b7UXU0fnQVp9DDA,9143
+asgiref-3.5.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+asgiref-3.5.2.dist-info/top_level.txt,sha256=bokQjCzwwERhdBiPdvYEZa4cHxT4NCeAffQNUqJ8ssg,8
+asgiref-3.5.2.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+asgiref-3.5.2.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/WHEEL
new file mode 100644
index 0000000..becc9a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/top_level.txt
new file mode 100644
index 0000000..ddf99d3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref-3.5.2.dist-info/top_level.txt
@@ -0,0 +1 @@
+asgiref
diff --git a/myenv/lib/python3.9/site-packages/asgiref/__init__.py b/myenv/lib/python3.9/site-packages/asgiref/__init__.py
new file mode 100644
index 0000000..dae42b1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref/__init__.py
@@ -0,0 +1 @@
+__version__ = "3.5.2"
diff --git a/myenv/lib/python3.9/site-packages/asgiref/compatibility.py b/myenv/lib/python3.9/site-packages/asgiref/compatibility.py
new file mode 100644
index 0000000..eccaee0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref/compatibility.py
@@ -0,0 +1,47 @@
+import asyncio
+import inspect
+
+
+def is_double_callable(application):
+    """
+    Tests to see if an application is a legacy-style (double-callable) application.
+    """
+    # Look for a hint on the object first
+    if getattr(application, "_asgi_single_callable", False):
+        return False
+    if getattr(application, "_asgi_double_callable", False):
+        return True
+    # Uninstanted classes are double-callable
+    if inspect.isclass(application):
+        return True
+    # Instanted classes depend on their __call__
+    if hasattr(application, "__call__"):
+        # We only check to see if its __call__ is a coroutine function -
+        # if it's not, it still might be a coroutine function itself.
+        if asyncio.iscoroutinefunction(application.__call__):
+            return False
+    # Non-classes we just check directly
+    return not asyncio.iscoroutinefunction(application)
+
+
+def double_to_single_callable(application):
+    """
+    Transforms a double-callable ASGI application into a single-callable one.
+    """
+
+    async def new_application(scope, receive, send):
+        instance = application(scope)
+        return await instance(receive, send)
+
+    return new_application
+
+
+def guarantee_single_callable(application):
+    """
+    Takes either a single- or double-callable application and always returns it
+    in single-callable style. Use this to add backwards compatibility for ASGI
+    2.0 applications to your server/test harness/etc.
+    """
+    if is_double_callable(application):
+        application = double_to_single_callable(application)
+    return application
diff --git a/myenv/lib/python3.9/site-packages/asgiref/current_thread_executor.py b/myenv/lib/python3.9/site-packages/asgiref/current_thread_executor.py
new file mode 100644
index 0000000..a7898f8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref/current_thread_executor.py
@@ -0,0 +1,81 @@
+import queue
+import threading
+from concurrent.futures import Executor, Future
+
+
+class _WorkItem:
+    """
+    Represents an item needing to be run in the executor.
+    Copied from ThreadPoolExecutor (but it's private, so we're not going to rely on importing it)
+    """
+
+    def __init__(self, future, fn, args, kwargs):
+        self.future = future
+        self.fn = fn
+        self.args = args
+        self.kwargs = kwargs
+
+    def run(self):
+        if not self.future.set_running_or_notify_cancel():
+            return
+        try:
+            result = self.fn(*self.args, **self.kwargs)
+        except BaseException as exc:
+            self.future.set_exception(exc)
+            # Break a reference cycle with the exception 'exc'
+            self = None
+        else:
+            self.future.set_result(result)
+
+
+class CurrentThreadExecutor(Executor):
+    """
+    An Executor that actually runs code in the thread it is instantiated in.
+    Passed to other threads running async code, so they can run sync code in
+    the thread they came from.
+    """
+
+    def __init__(self):
+        self._work_thread = threading.current_thread()
+        self._work_queue = queue.Queue()
+        self._broken = False
+
+    def run_until_future(self, future):
+        """
+        Runs the code in the work queue until a result is available from the future.
+        Should be run from the thread the executor is initialised in.
+        """
+        # Check we're in the right thread
+        if threading.current_thread() != self._work_thread:
+            raise RuntimeError(
+                "You cannot run CurrentThreadExecutor from a different thread"
+            )
+        future.add_done_callback(self._work_queue.put)
+        # Keep getting and running work items until we get the future we're waiting for
+        # back via the future's done callback.
+        try:
+            while True:
+                # Get a work item and run it
+                work_item = self._work_queue.get()
+                if work_item is future:
+                    return
+                work_item.run()
+                del work_item
+        finally:
+            self._broken = True
+
+    def submit(self, fn, *args, **kwargs):
+        # Check they're not submitting from the same thread
+        if threading.current_thread() == self._work_thread:
+            raise RuntimeError(
+                "You cannot submit onto CurrentThreadExecutor from its own thread"
+            )
+        # Check they're not too late or the executor errored
+        if self._broken:
+            raise RuntimeError("CurrentThreadExecutor already quit or is broken")
+        # Add to work queue
+        f = Future()
+        work_item = _WorkItem(f, fn, args, kwargs)
+        self._work_queue.put(work_item)
+        # Return the future
+        return f
diff --git a/myenv/lib/python3.9/site-packages/asgiref/local.py b/myenv/lib/python3.9/site-packages/asgiref/local.py
new file mode 100644
index 0000000..17314d4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref/local.py
@@ -0,0 +1,120 @@
+import random
+import string
+import sys
+import threading
+import weakref
+
+
+class Local:
+    """
+    A drop-in replacement for threading.locals that also works with asyncio
+    Tasks (via the current_task asyncio method), and passes locals through
+    sync_to_async and async_to_sync.
+
+    Specifically:
+     - Locals work per-coroutine on any thread not spawned using asgiref
+     - Locals work per-thread on any thread not spawned using asgiref
+     - Locals are shared with the parent coroutine when using sync_to_async
+     - Locals are shared with the parent thread when using async_to_sync
+       (and if that thread was launched using sync_to_async, with its parent
+       coroutine as well, with this working for indefinite levels of nesting)
+
+    Set thread_critical to True to not allow locals to pass from an async Task
+    to a thread it spawns. This is needed for code that truly needs
+    thread-safety, as opposed to things used for helpful context (e.g. sqlite
+    does not like being called from a different thread to the one it is from).
+    Thread-critical code will still be differentiated per-Task within a thread
+    as it is expected it does not like concurrent access.
+
+    This doesn't use contextvars as it needs to support 3.6. Once it can support
+    3.7 only, we can then reimplement the storage more nicely.
+    """
+
+    def __init__(self, thread_critical: bool = False) -> None:
+        self._thread_critical = thread_critical
+        self._thread_lock = threading.RLock()
+        self._context_refs: "weakref.WeakSet[object]" = weakref.WeakSet()
+        # Random suffixes stop accidental reuse between different Locals,
+        # though we try to force deletion as well.
+        self._attr_name = "_asgiref_local_impl_{}_{}".format(
+            id(self),
+            "".join(random.choice(string.ascii_letters) for i in range(8)),
+        )
+
+    def _get_context_id(self):
+        """
+        Get the ID we should use for looking up variables
+        """
+        # Prevent a circular reference
+        from .sync import AsyncToSync, SyncToAsync
+
+        # First, pull the current task if we can
+        context_id = SyncToAsync.get_current_task()
+        context_is_async = True
+        # OK, let's try for a thread ID
+        if context_id is None:
+            context_id = threading.current_thread()
+            context_is_async = False
+        # If we're thread-critical, we stop here, as we can't share contexts.
+        if self._thread_critical:
+            return context_id
+        # Now, take those and see if we can resolve them through the launch maps
+        for i in range(sys.getrecursionlimit()):
+            try:
+                if context_is_async:
+                    # Tasks have a source thread in AsyncToSync
+                    context_id = AsyncToSync.launch_map[context_id]
+                    context_is_async = False
+                else:
+                    # Threads have a source task in SyncToAsync
+                    context_id = SyncToAsync.launch_map[context_id]
+                    context_is_async = True
+            except KeyError:
+                break
+        else:
+            # Catch infinite loops (they happen if you are screwing around
+            # with AsyncToSync implementations)
+            raise RuntimeError("Infinite launch_map loops")
+        return context_id
+
+    def _get_storage(self):
+        context_obj = self._get_context_id()
+        if not hasattr(context_obj, self._attr_name):
+            setattr(context_obj, self._attr_name, {})
+            self._context_refs.add(context_obj)
+        return getattr(context_obj, self._attr_name)
+
+    def __del__(self):
+        try:
+            for context_obj in self._context_refs:
+                try:
+                    delattr(context_obj, self._attr_name)
+                except AttributeError:
+                    pass
+        except TypeError:
+            # WeakSet.__iter__ can crash when interpreter is shutting down due
+            # to _IterationGuard being None.
+            pass
+
+    def __getattr__(self, key):
+        with self._thread_lock:
+            storage = self._get_storage()
+            if key in storage:
+                return storage[key]
+            else:
+                raise AttributeError(f"{self!r} object has no attribute {key!r}")
+
+    def __setattr__(self, key, value):
+        if key in ("_context_refs", "_thread_critical", "_thread_lock", "_attr_name"):
+            return super().__setattr__(key, value)
+        with self._thread_lock:
+            storage = self._get_storage()
+            storage[key] = value
+
+    def __delattr__(self, key):
+        with self._thread_lock:
+            storage = self._get_storage()
+            if key in storage:
+                del storage[key]
+            else:
+                raise AttributeError(f"{self!r} object has no attribute {key!r}")
diff --git a/myenv/lib/python3.9/site-packages/asgiref/py.typed b/myenv/lib/python3.9/site-packages/asgiref/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/asgiref/server.py b/myenv/lib/python3.9/site-packages/asgiref/server.py
new file mode 100644
index 0000000..43c28c6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref/server.py
@@ -0,0 +1,157 @@
+import asyncio
+import logging
+import time
+import traceback
+
+from .compatibility import guarantee_single_callable
+
+logger = logging.getLogger(__name__)
+
+
+class StatelessServer:
+    """
+    Base server class that handles basic concepts like application instance
+    creation/pooling, exception handling, and similar, for stateless protocols
+    (i.e. ones without actual incoming connections to the process)
+
+    Your code should override the handle() method, doing whatever it needs to,
+    and calling get_or_create_application_instance with a unique `scope_id`
+    and `scope` for the scope it wants to get.
+
+    If an application instance is found with the same `scope_id`, you are
+    given its input queue, otherwise one is made for you with the scope provided
+    and you are given that fresh new input queue. Either way, you should do
+    something like:
+
+    input_queue = self.get_or_create_application_instance(
+        "user-123456",
+        {"type": "testprotocol", "user_id": "123456", "username": "andrew"},
+    )
+    input_queue.put_nowait(message)
+
+    If you try and create an application instance and there are already
+    `max_application` instances, the oldest/least recently used one will be
+    reclaimed and shut down to make space.
+
+    Application coroutines that error will be found periodically (every 100ms
+    by default) and have their exceptions printed to the console. Override
+    application_exception() if you want to do more when this happens.
+
+    If you override run(), make sure you handle things like launching the
+    application checker.
+    """
+
+    application_checker_interval = 0.1
+
+    def __init__(self, application, max_applications=1000):
+        # Parameters
+        self.application = application
+        self.max_applications = max_applications
+        # Initialisation
+        self.application_instances = {}
+
+    ### Mainloop and handling
+
+    def run(self):
+        """
+        Runs the asyncio event loop with our handler loop.
+        """
+        event_loop = asyncio.get_event_loop()
+        asyncio.ensure_future(self.application_checker())
+        try:
+            event_loop.run_until_complete(self.handle())
+        except KeyboardInterrupt:
+            logger.info("Exiting due to Ctrl-C/interrupt")
+
+    async def handle(self):
+        raise NotImplementedError("You must implement handle()")
+
+    async def application_send(self, scope, message):
+        """
+        Receives outbound sends from applications and handles them.
+        """
+        raise NotImplementedError("You must implement application_send()")
+
+    ### Application instance management
+
+    def get_or_create_application_instance(self, scope_id, scope):
+        """
+        Creates an application instance and returns its queue.
+        """
+        if scope_id in self.application_instances:
+            self.application_instances[scope_id]["last_used"] = time.time()
+            return self.application_instances[scope_id]["input_queue"]
+        # See if we need to delete an old one
+        while len(self.application_instances) > self.max_applications:
+            self.delete_oldest_application_instance()
+        # Make an instance of the application
+        input_queue = asyncio.Queue()
+        application_instance = guarantee_single_callable(self.application)
+        # Run it, and stash the future for later checking
+        future = asyncio.ensure_future(
+            application_instance(
+                scope=scope,
+                receive=input_queue.get,
+                send=lambda message: self.application_send(scope, message),
+            ),
+        )
+        self.application_instances[scope_id] = {
+            "input_queue": input_queue,
+            "future": future,
+            "scope": scope,
+            "last_used": time.time(),
+        }
+        return input_queue
+
+    def delete_oldest_application_instance(self):
+        """
+        Finds and deletes the oldest application instance
+        """
+        oldest_time = min(
+            details["last_used"] for details in self.application_instances.values()
+        )
+        for scope_id, details in self.application_instances.items():
+            if details["last_used"] == oldest_time:
+                self.delete_application_instance(scope_id)
+                # Return to make sure we only delete one in case two have
+                # the same oldest time
+                return
+
+    def delete_application_instance(self, scope_id):
+        """
+        Removes an application instance (makes sure its task is stopped,
+        then removes it from the current set)
+        """
+        details = self.application_instances[scope_id]
+        del self.application_instances[scope_id]
+        if not details["future"].done():
+            details["future"].cancel()
+
+    async def application_checker(self):
+        """
+        Goes through the set of current application instance Futures and cleans up
+        any that are done/prints exceptions for any that errored.
+        """
+        while True:
+            await asyncio.sleep(self.application_checker_interval)
+            for scope_id, details in list(self.application_instances.items()):
+                if details["future"].done():
+                    exception = details["future"].exception()
+                    if exception:
+                        await self.application_exception(exception, details)
+                    try:
+                        del self.application_instances[scope_id]
+                    except KeyError:
+                        # Exception handling might have already got here before us. That's fine.
+                        pass
+
+    async def application_exception(self, exception, application_details):
+        """
+        Called whenever an application coroutine has an exception.
+        """
+        logging.error(
+            "Exception inside application: %s\n%s%s",
+            exception,
+            "".join(traceback.format_tb(exception.__traceback__)),
+            f"  {exception}",
+        )
diff --git a/myenv/lib/python3.9/site-packages/asgiref/sync.py b/myenv/lib/python3.9/site-packages/asgiref/sync.py
new file mode 100644
index 0000000..6247043
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref/sync.py
@@ -0,0 +1,532 @@
+import asyncio
+import asyncio.coroutines
+import contextvars
+import functools
+import inspect
+import os
+import sys
+import threading
+import warnings
+import weakref
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Any, Callable, Dict, Optional, overload
+
+from .current_thread_executor import CurrentThreadExecutor
+from .local import Local
+
+
+def _restore_context(context):
+    # Check for changes in contextvars, and set them to the current
+    # context for downstream consumers
+    for cvar in context:
+        try:
+            if cvar.get() != context.get(cvar):
+                cvar.set(context.get(cvar))
+        except LookupError:
+            cvar.set(context.get(cvar))
+
+
+def _iscoroutinefunction_or_partial(func: Any) -> bool:
+    # Python < 3.8 does not correctly determine partially wrapped
+    # coroutine functions are coroutine functions, hence the need for
+    # this to exist. Code taken from CPython.
+    if sys.version_info >= (3, 8):
+        return asyncio.iscoroutinefunction(func)
+    else:
+        while inspect.ismethod(func):
+            func = func.__func__
+        while isinstance(func, functools.partial):
+            func = func.func
+
+        return asyncio.iscoroutinefunction(func)
+
+
+class ThreadSensitiveContext:
+    """Async context manager to manage context for thread sensitive mode
+
+    This context manager controls which thread pool executor is used when in
+    thread sensitive mode. By default, a single thread pool executor is shared
+    within a process.
+
+    In Python 3.7+, the ThreadSensitiveContext() context manager may be used to
+    specify a thread pool per context.
+
+    This context manager is re-entrant, so only the outer-most call to
+    ThreadSensitiveContext will set the context.
+
+    Usage:
+
+    >>> import time
+    >>> async with ThreadSensitiveContext():
+    ...     await sync_to_async(time.sleep, 1)()
+    """
+
+    def __init__(self):
+        self.token = None
+
+    async def __aenter__(self):
+        try:
+            SyncToAsync.thread_sensitive_context.get()
+        except LookupError:
+            self.token = SyncToAsync.thread_sensitive_context.set(self)
+
+        return self
+
+    async def __aexit__(self, exc, value, tb):
+        if not self.token:
+            return
+
+        executor = SyncToAsync.context_to_thread_executor.pop(self, None)
+        if executor:
+            executor.shutdown()
+        SyncToAsync.thread_sensitive_context.reset(self.token)
+
+
+class AsyncToSync:
+    """
+    Utility class which turns an awaitable that only works on the thread with
+    the event loop into a synchronous callable that works in a subthread.
+
+    If the call stack contains an async loop, the code runs there.
+    Otherwise, the code runs in a new loop in a new thread.
+
+    Either way, this thread then pauses and waits to run any thread_sensitive
+    code called from further down the call stack using SyncToAsync, before
+    finally exiting once the async task returns.
+    """
+
+    # Maps launched Tasks to the threads that launched them (for locals impl)
+    launch_map: "Dict[asyncio.Task[object], threading.Thread]" = {}
+
+    # Keeps track of which CurrentThreadExecutor to use. This uses an asgiref
+    # Local, not a threadlocal, so that tasks can work out what their parent used.
+    executors = Local()
+
+    # When we can't find a CurrentThreadExecutor from the context, such as
+    # inside create_task, we'll look it up here from the running event loop.
+    loop_thread_executors: "Dict[asyncio.AbstractEventLoop, CurrentThreadExecutor]" = {}
+
+    def __init__(self, awaitable, force_new_loop=False):
+        if not callable(awaitable) or (
+            not _iscoroutinefunction_or_partial(awaitable)
+            and not _iscoroutinefunction_or_partial(
+                getattr(awaitable, "__call__", awaitable)
+            )
+        ):
+            # Python does not have very reliable detection of async functions
+            # (lots of false negatives) so this is just a warning.
+            warnings.warn(
+                "async_to_sync was passed a non-async-marked callable", stacklevel=2
+            )
+        self.awaitable = awaitable
+        try:
+            self.__self__ = self.awaitable.__self__
+        except AttributeError:
+            pass
+        if force_new_loop:
+            # They have asked that we always run in a new sub-loop.
+            self.main_event_loop = None
+        else:
+            try:
+                self.main_event_loop = asyncio.get_running_loop()
+            except RuntimeError:
+                # There's no event loop in this thread. Look for the threadlocal if
+                # we're inside SyncToAsync
+                main_event_loop_pid = getattr(
+                    SyncToAsync.threadlocal, "main_event_loop_pid", None
+                )
+                # We make sure the parent loop is from the same process - if
+                # they've forked, this is not going to be valid any more (#194)
+                if main_event_loop_pid and main_event_loop_pid == os.getpid():
+                    self.main_event_loop = getattr(
+                        SyncToAsync.threadlocal, "main_event_loop", None
+                    )
+                else:
+                    self.main_event_loop = None
+
+    def __call__(self, *args, **kwargs):
+        # You can't call AsyncToSync from a thread with a running event loop
+        try:
+            event_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            pass
+        else:
+            if event_loop.is_running():
+                raise RuntimeError(
+                    "You cannot use AsyncToSync in the same thread as an async event loop - "
+                    "just await the async function directly."
+                )
+
+        # Wrapping context in list so it can be reassigned from within
+        # `main_wrap`.
+        context = [contextvars.copy_context()]
+
+        # Make a future for the return information
+        call_result = Future()
+        # Get the source thread
+        source_thread = threading.current_thread()
+        # Make a CurrentThreadExecutor we'll use to idle in this thread - we
+        # need one for every sync frame, even if there's one above us in the
+        # same thread.
+        if hasattr(self.executors, "current"):
+            old_current_executor = self.executors.current
+        else:
+            old_current_executor = None
+        current_executor = CurrentThreadExecutor()
+        self.executors.current = current_executor
+        loop = None
+        # Use call_soon_threadsafe to schedule a synchronous callback on the
+        # main event loop's thread if it's there, otherwise make a new loop
+        # in this thread.
+        try:
+            awaitable = self.main_wrap(
+                args, kwargs, call_result, source_thread, sys.exc_info(), context
+            )
+
+            if not (self.main_event_loop and self.main_event_loop.is_running()):
+                # Make our own event loop - in a new thread - and run inside that.
+                loop = asyncio.new_event_loop()
+                self.loop_thread_executors[loop] = current_executor
+                loop_executor = ThreadPoolExecutor(max_workers=1)
+                loop_future = loop_executor.submit(
+                    self._run_event_loop, loop, awaitable
+                )
+                if current_executor:
+                    # Run the CurrentThreadExecutor until the future is done
+                    current_executor.run_until_future(loop_future)
+                # Wait for future and/or allow for exception propagation
+                loop_future.result()
+            else:
+                # Call it inside the existing loop
+                self.main_event_loop.call_soon_threadsafe(
+                    self.main_event_loop.create_task, awaitable
+                )
+                if current_executor:
+                    # Run the CurrentThreadExecutor until the future is done
+                    current_executor.run_until_future(call_result)
+        finally:
+            # Clean up any executor we were running
+            if loop is not None:
+                del self.loop_thread_executors[loop]
+            if hasattr(self.executors, "current"):
+                del self.executors.current
+            if old_current_executor:
+                self.executors.current = old_current_executor
+            _restore_context(context[0])
+
+        # Wait for results from the future.
+        return call_result.result()
+
+    def _run_event_loop(self, loop, coro):
+        """
+        Runs the given event loop (designed to be called in a thread).
+        """
+        asyncio.set_event_loop(loop)
+        try:
+            loop.run_until_complete(coro)
+        finally:
+            try:
+                # mimic asyncio.run() behavior
+                # cancel unexhausted async generators
+                tasks = asyncio.all_tasks(loop)
+                for task in tasks:
+                    task.cancel()
+
+                async def gather():
+                    await asyncio.gather(*tasks, return_exceptions=True)
+
+                loop.run_until_complete(gather())
+                for task in tasks:
+                    if task.cancelled():
+                        continue
+                    if task.exception() is not None:
+                        loop.call_exception_handler(
+                            {
+                                "message": "unhandled exception during loop shutdown",
+                                "exception": task.exception(),
+                                "task": task,
+                            }
+                        )
+                if hasattr(loop, "shutdown_asyncgens"):
+                    loop.run_until_complete(loop.shutdown_asyncgens())
+            finally:
+                loop.close()
+                asyncio.set_event_loop(self.main_event_loop)
+
+    def __get__(self, parent, objtype):
+        """
+        Include self for methods
+        """
+        func = functools.partial(self.__call__, parent)
+        return functools.update_wrapper(func, self.awaitable)
+
+    async def main_wrap(
+        self, args, kwargs, call_result, source_thread, exc_info, context
+    ):
+        """
+        Wraps the awaitable with something that puts the result into the
+        result/exception future.
+        """
+        if context is not None:
+            _restore_context(context[0])
+
+        current_task = SyncToAsync.get_current_task()
+        self.launch_map[current_task] = source_thread
+        try:
+            # If we have an exception, run the function inside the except block
+            # after raising it so exc_info is correctly populated.
+            if exc_info[1]:
+                try:
+                    raise exc_info[1]
+                except BaseException:
+                    result = await self.awaitable(*args, **kwargs)
+            else:
+                result = await self.awaitable(*args, **kwargs)
+        except BaseException as e:
+            call_result.set_exception(e)
+        else:
+            call_result.set_result(result)
+        finally:
+            del self.launch_map[current_task]
+
+            context[0] = contextvars.copy_context()
+
+
+class SyncToAsync:
+    """
+    Utility class which turns a synchronous callable into an awaitable that
+    runs in a threadpool. It also sets a threadlocal inside the thread so
+    calls to AsyncToSync can escape it.
+
+    If thread_sensitive is passed, the code will run in the same thread as any
+    outer code. This is needed for underlying Python code that is not
+    threadsafe (for example, code which handles SQLite database connections).
+
+    If the outermost program is async (i.e. SyncToAsync is outermost), then
+    this will be a dedicated single sub-thread that all sync code runs in,
+    one after the other. If the outermost program is sync (i.e. AsyncToSync is
+    outermost), this will just be the main thread. This is achieved by idling
+    with a CurrentThreadExecutor while AsyncToSync is blocking its sync parent,
+    rather than just blocking.
+
+    If executor is passed in, that will be used instead of the loop's default executor.
+    In order to pass in an executor, thread_sensitive must be set to False, otherwise
+    a TypeError will be raised.
+    """
+
+    # If they've set ASGI_THREADS, update the default asyncio executor for now
+    if "ASGI_THREADS" in os.environ:
+        # We use get_event_loop here - not get_running_loop - as this will
+        # be run at import time, and we want to update the main thread's loop.
+        loop = asyncio.get_event_loop()
+        loop.set_default_executor(
+            ThreadPoolExecutor(max_workers=int(os.environ["ASGI_THREADS"]))
+        )
+
+    # Maps launched threads to the coroutines that spawned them
+    launch_map: "Dict[threading.Thread, asyncio.Task[object]]" = {}
+
+    # Storage for main event loop references
+    threadlocal = threading.local()
+
+    # Single-thread executor for thread-sensitive code
+    single_thread_executor = ThreadPoolExecutor(max_workers=1)
+
+    # Maintain a contextvar for the current execution context. Optionally used
+    # for thread sensitive mode.
+    thread_sensitive_context: "contextvars.ContextVar[str]" = contextvars.ContextVar(
+        "thread_sensitive_context"
+    )
+
+    # Contextvar that is used to detect if the single thread executor
+    # would be awaited on while already being used in the same context
+    deadlock_context: "contextvars.ContextVar[bool]" = contextvars.ContextVar(
+        "deadlock_context"
+    )
+
+    # Maintaining a weak reference to the context ensures that thread pools are
+    # erased once the context goes out of scope. This terminates the thread pool.
+    context_to_thread_executor: "weakref.WeakKeyDictionary[object, ThreadPoolExecutor]" = (
+        weakref.WeakKeyDictionary()
+    )
+
+    def __init__(
+        self,
+        func: Callable[..., Any],
+        thread_sensitive: bool = True,
+        executor: Optional["ThreadPoolExecutor"] = None,
+    ) -> None:
+        if (
+            not callable(func)
+            or _iscoroutinefunction_or_partial(func)
+            or _iscoroutinefunction_or_partial(getattr(func, "__call__", func))
+        ):
+            raise TypeError("sync_to_async can only be applied to sync functions.")
+        self.func = func
+        functools.update_wrapper(self, func)
+        self._thread_sensitive = thread_sensitive
+        self._is_coroutine = asyncio.coroutines._is_coroutine  # type: ignore
+        if thread_sensitive and executor is not None:
+            raise TypeError("executor must not be set when thread_sensitive is True")
+        self._executor = executor
+        try:
+            self.__self__ = func.__self__  # type: ignore
+        except AttributeError:
+            pass
+
+    async def __call__(self, *args, **kwargs):
+        loop = asyncio.get_running_loop()
+
+        # Work out what thread to run the code in
+        if self._thread_sensitive:
+            if hasattr(AsyncToSync.executors, "current"):
+                # If we have a parent sync thread above somewhere, use that
+                executor = AsyncToSync.executors.current
+            elif self.thread_sensitive_context and self.thread_sensitive_context.get(
+                None
+            ):
+                # If we have a way of retrieving the current context, attempt
+                # to use a per-context thread pool executor
+                thread_sensitive_context = self.thread_sensitive_context.get()
+
+                if thread_sensitive_context in self.context_to_thread_executor:
+                    # Re-use thread executor in current context
+                    executor = self.context_to_thread_executor[thread_sensitive_context]
+                else:
+                    # Create new thread executor in current context
+                    executor = ThreadPoolExecutor(max_workers=1)
+                    self.context_to_thread_executor[thread_sensitive_context] = executor
+            elif loop in AsyncToSync.loop_thread_executors:
+                # Re-use thread executor for running loop
+                executor = AsyncToSync.loop_thread_executors[loop]
+            elif self.deadlock_context and self.deadlock_context.get(False):
+                raise RuntimeError(
+                    "Single thread executor already being used, would deadlock"
+                )
+            else:
+                # Otherwise, we run it in a fixed single thread
+                executor = self.single_thread_executor
+                if self.deadlock_context:
+                    self.deadlock_context.set(True)
+        else:
+            # Use the passed in executor, or the loop's default if it is None
+            executor = self._executor
+
+        context = contextvars.copy_context()
+        child = functools.partial(self.func, *args, **kwargs)
+        func = context.run
+        args = (child,)
+        kwargs = {}
+
+        try:
+            # Run the code in the right thread
+            future = loop.run_in_executor(
+                executor,
+                functools.partial(
+                    self.thread_handler,
+                    loop,
+                    self.get_current_task(),
+                    sys.exc_info(),
+                    func,
+                    *args,
+                    **kwargs,
+                ),
+            )
+            ret = await asyncio.wait_for(future, timeout=None)
+
+        finally:
+            _restore_context(context)
+            if self.deadlock_context:
+                self.deadlock_context.set(False)
+
+        return ret
+
+    def __get__(self, parent, objtype):
+        """
+        Include self for methods
+        """
+        return functools.partial(self.__call__, parent)
+
+    def thread_handler(self, loop, source_task, exc_info, func, *args, **kwargs):
+        """
+        Wraps the sync application with exception handling.
+        """
+        # Set the threadlocal for AsyncToSync
+        self.threadlocal.main_event_loop = loop
+        self.threadlocal.main_event_loop_pid = os.getpid()
+        # Set the task mapping (used for the locals module)
+        current_thread = threading.current_thread()
+        if AsyncToSync.launch_map.get(source_task) == current_thread:
+            # Our parent task was launched from this same thread, so don't make
+            # a launch map entry - let it shortcut over us! (and stop infinite loops)
+            parent_set = False
+        else:
+            self.launch_map[current_thread] = source_task
+            parent_set = True
+        # Run the function
+        try:
+            # If we have an exception, run the function inside the except block
+            # after raising it so exc_info is correctly populated.
+            if exc_info[1]:
+                try:
+                    raise exc_info[1]
+                except BaseException:
+                    return func(*args, **kwargs)
+            else:
+                return func(*args, **kwargs)
+        finally:
+            # Only delete the launch_map parent if we set it, otherwise it is
+            # from someone else.
+            if parent_set:
+                del self.launch_map[current_thread]
+
+    @staticmethod
+    def get_current_task():
+        """
+        Implementation of asyncio.current_task()
+        that returns None if there is no task.
+        """
+        try:
+            return asyncio.current_task()
+        except RuntimeError:
+            return None
+
+
+# Lowercase aliases (and decorator friendliness)
+async_to_sync = AsyncToSync
+
+
+@overload
+def sync_to_async(
+    func: None = None,
+    thread_sensitive: bool = True,
+    executor: Optional["ThreadPoolExecutor"] = None,
+) -> Callable[[Callable[..., Any]], SyncToAsync]:
+    ...
+
+
+@overload
+def sync_to_async(
+    func: Callable[..., Any],
+    thread_sensitive: bool = True,
+    executor: Optional["ThreadPoolExecutor"] = None,
+) -> SyncToAsync:
+    ...
+
+
+def sync_to_async(
+    func=None,
+    thread_sensitive=True,
+    executor=None,
+):
+    if func is None:
+        return lambda f: SyncToAsync(
+            f,
+            thread_sensitive=thread_sensitive,
+            executor=executor,
+        )
+    return SyncToAsync(
+        func,
+        thread_sensitive=thread_sensitive,
+        executor=executor,
+    )
diff --git a/myenv/lib/python3.9/site-packages/asgiref/testing.py b/myenv/lib/python3.9/site-packages/asgiref/testing.py
new file mode 100644
index 0000000..6624317
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref/testing.py
@@ -0,0 +1,97 @@
+import asyncio
+import time
+
+from .compatibility import guarantee_single_callable
+from .timeout import timeout as async_timeout
+
+
+class ApplicationCommunicator:
+    """
+    Runs an ASGI application in a test mode, allowing sending of
+    messages to it and retrieval of messages it sends.
+    """
+
+    def __init__(self, application, scope):
+        self.application = guarantee_single_callable(application)
+        self.scope = scope
+        self.input_queue = asyncio.Queue()
+        self.output_queue = asyncio.Queue()
+        self.future = asyncio.ensure_future(
+            self.application(scope, self.input_queue.get, self.output_queue.put)
+        )
+
+    async def wait(self, timeout=1):
+        """
+        Waits for the application to stop itself and returns any exceptions.
+        """
+        try:
+            async with async_timeout(timeout):
+                try:
+                    await self.future
+                    self.future.result()
+                except asyncio.CancelledError:
+                    pass
+        finally:
+            if not self.future.done():
+                self.future.cancel()
+                try:
+                    await self.future
+                except asyncio.CancelledError:
+                    pass
+
+    def stop(self, exceptions=True):
+        if not self.future.done():
+            self.future.cancel()
+        elif exceptions:
+            # Give a chance to raise any exceptions
+            self.future.result()
+
+    def __del__(self):
+        # Clean up on deletion
+        try:
+            self.stop(exceptions=False)
+        except RuntimeError:
+            # Event loop already stopped
+            pass
+
+    async def send_input(self, message):
+        """
+        Sends a single message to the application
+        """
+        # Give it the message
+        await self.input_queue.put(message)
+
+    async def receive_output(self, timeout=1):
+        """
+        Receives a single message from the application, with optional timeout.
+        """
+        # Make sure there's not an exception to raise from the task
+        if self.future.done():
+            self.future.result()
+        # Wait and receive the message
+        try:
+            async with async_timeout(timeout):
+                return await self.output_queue.get()
+        except asyncio.TimeoutError as e:
+            # See if we have another error to raise inside
+            if self.future.done():
+                self.future.result()
+            else:
+                self.future.cancel()
+                try:
+                    await self.future
+                except asyncio.CancelledError:
+                    pass
+            raise e
+
+    async def receive_nothing(self, timeout=0.1, interval=0.01):
+        """
+        Checks that there is no message to receive in the given time.
+        """
+        # `interval` has precedence over `timeout`
+        start = time.monotonic()
+        while time.monotonic() - start < timeout:
+            if not self.output_queue.empty():
+                return False
+            await asyncio.sleep(interval)
+        return self.output_queue.empty()
diff --git a/myenv/lib/python3.9/site-packages/asgiref/timeout.py b/myenv/lib/python3.9/site-packages/asgiref/timeout.py
new file mode 100644
index 0000000..65932d1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref/timeout.py
@@ -0,0 +1,112 @@
+# This code is originally sourced from the aio-libs project "async_timeout",
+# under the Apache 2.0 license. You may see the original project at
+# https://github.com/aio-libs/async-timeout
+
+# It is vendored here to reduce chain-dependencies on this library, and
+# modified slightly to remove some features we don't use.
+
+
+import asyncio
+from types import TracebackType
+from typing import Any, Optional, Type
+
+
+class timeout:
+    """timeout context manager.
+
+    Useful in cases when you want to apply timeout logic around block
+    of code or in cases when asyncio.wait_for is not suitable. For example:
+
+    >>> with timeout(0.001):
+    ...     async with aiohttp.get('https://github.com') as r:
+    ...         await r.text()
+
+
+    timeout - value in seconds or None to disable timeout logic
+    loop - asyncio compatible event loop
+    """
+
+    def __init__(
+        self,
+        timeout: Optional[float],
+        *,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+    ) -> None:
+        self._timeout = timeout
+        if loop is None:
+            loop = asyncio.get_event_loop()
+        self._loop = loop
+        self._task = None  # type: Optional[asyncio.Task[Any]]
+        self._cancelled = False
+        self._cancel_handler = None  # type: Optional[asyncio.Handle]
+        self._cancel_at = None  # type: Optional[float]
+
+    def __enter__(self) -> "timeout":
+        return self._do_enter()
+
+    def __exit__(
+        self,
+        exc_type: Type[BaseException],
+        exc_val: BaseException,
+        exc_tb: TracebackType,
+    ) -> Optional[bool]:
+        self._do_exit(exc_type)
+        return None
+
+    async def __aenter__(self) -> "timeout":
+        return self._do_enter()
+
+    async def __aexit__(
+        self,
+        exc_type: Type[BaseException],
+        exc_val: BaseException,
+        exc_tb: TracebackType,
+    ) -> None:
+        self._do_exit(exc_type)
+
+    @property
+    def expired(self) -> bool:
+        return self._cancelled
+
+    @property
+    def remaining(self) -> Optional[float]:
+        if self._cancel_at is not None:
+            return max(self._cancel_at - self._loop.time(), 0.0)
+        else:
+            return None
+
+    def _do_enter(self) -> "timeout":
+        # Support Tornado 5- without timeout
+        # Details: https://github.com/python/asyncio/issues/392
+        if self._timeout is None:
+            return self
+
+        self._task = asyncio.current_task(self._loop)
+        if self._task is None:
+            raise RuntimeError(
+                "Timeout context manager should be used " "inside a task"
+            )
+
+        if self._timeout <= 0:
+            self._loop.call_soon(self._cancel_task)
+            return self
+
+        self._cancel_at = self._loop.time() + self._timeout
+        self._cancel_handler = self._loop.call_at(self._cancel_at, self._cancel_task)
+        return self
+
+    def _do_exit(self, exc_type: Type[BaseException]) -> None:
+        if exc_type is asyncio.CancelledError and self._cancelled:
+            self._cancel_handler = None
+            self._task = None
+            raise asyncio.TimeoutError
+        if self._timeout is not None and self._cancel_handler is not None:
+            self._cancel_handler.cancel()
+            self._cancel_handler = None
+        self._task = None
+        return None
+
+    def _cancel_task(self) -> None:
+        if self._task is not None:
+            self._task.cancel()
+            self._cancelled = True
diff --git a/myenv/lib/python3.9/site-packages/asgiref/typing.py b/myenv/lib/python3.9/site-packages/asgiref/typing.py
new file mode 100644
index 0000000..c7d7576
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref/typing.py
@@ -0,0 +1,242 @@
+import sys
+from typing import Awaitable, Callable, Dict, Iterable, Optional, Tuple, Type, Union
+
+if sys.version_info >= (3, 8):
+    from typing import Literal, Protocol, TypedDict
+else:
+    from typing_extensions import Literal, Protocol, TypedDict
+
+__all__ = (
+    "ASGIVersions",
+    "HTTPScope",
+    "WebSocketScope",
+    "LifespanScope",
+    "WWWScope",
+    "Scope",
+    "HTTPRequestEvent",
+    "HTTPResponseStartEvent",
+    "HTTPResponseBodyEvent",
+    "HTTPServerPushEvent",
+    "HTTPDisconnectEvent",
+    "WebSocketConnectEvent",
+    "WebSocketAcceptEvent",
+    "WebSocketReceiveEvent",
+    "WebSocketSendEvent",
+    "WebSocketResponseStartEvent",
+    "WebSocketResponseBodyEvent",
+    "WebSocketDisconnectEvent",
+    "WebSocketCloseEvent",
+    "LifespanStartupEvent",
+    "LifespanShutdownEvent",
+    "LifespanStartupCompleteEvent",
+    "LifespanStartupFailedEvent",
+    "LifespanShutdownCompleteEvent",
+    "LifespanShutdownFailedEvent",
+    "ASGIReceiveEvent",
+    "ASGISendEvent",
+    "ASGIReceiveCallable",
+    "ASGISendCallable",
+    "ASGI2Protocol",
+    "ASGI2Application",
+    "ASGI3Application",
+    "ASGIApplication",
+)
+
+
+class ASGIVersions(TypedDict):
+    spec_version: str
+    version: Union[Literal["2.0"], Literal["3.0"]]
+
+
+class HTTPScope(TypedDict):
+    type: Literal["http"]
+    asgi: ASGIVersions
+    http_version: str
+    method: str
+    scheme: str
+    path: str
+    raw_path: bytes
+    query_string: bytes
+    root_path: str
+    headers: Iterable[Tuple[bytes, bytes]]
+    client: Optional[Tuple[str, int]]
+    server: Optional[Tuple[str, Optional[int]]]
+    extensions: Optional[Dict[str, Dict[object, object]]]
+
+
+class WebSocketScope(TypedDict):
+    type: Literal["websocket"]
+    asgi: ASGIVersions
+    http_version: str
+    scheme: str
+    path: str
+    raw_path: bytes
+    query_string: bytes
+    root_path: str
+    headers: Iterable[Tuple[bytes, bytes]]
+    client: Optional[Tuple[str, int]]
+    server: Optional[Tuple[str, Optional[int]]]
+    subprotocols: Iterable[str]
+    extensions: Optional[Dict[str, Dict[object, object]]]
+
+
+class LifespanScope(TypedDict):
+    type: Literal["lifespan"]
+    asgi: ASGIVersions
+
+
+WWWScope = Union[HTTPScope, WebSocketScope]
+Scope = Union[HTTPScope, WebSocketScope, LifespanScope]
+
+
+class HTTPRequestEvent(TypedDict):
+    type: Literal["http.request"]
+    body: bytes
+    more_body: bool
+
+
+class HTTPResponseStartEvent(TypedDict):
+    type: Literal["http.response.start"]
+    status: int
+    headers: Iterable[Tuple[bytes, bytes]]
+
+
+class HTTPResponseBodyEvent(TypedDict):
+    type: Literal["http.response.body"]
+    body: bytes
+    more_body: bool
+
+
+class HTTPServerPushEvent(TypedDict):
+    type: Literal["http.response.push"]
+    path: str
+    headers: Iterable[Tuple[bytes, bytes]]
+
+
+class HTTPDisconnectEvent(TypedDict):
+    type: Literal["http.disconnect"]
+
+
+class WebSocketConnectEvent(TypedDict):
+    type: Literal["websocket.connect"]
+
+
+class WebSocketAcceptEvent(TypedDict):
+    type: Literal["websocket.accept"]
+    subprotocol: Optional[str]
+    headers: Iterable[Tuple[bytes, bytes]]
+
+
+class WebSocketReceiveEvent(TypedDict):
+    type: Literal["websocket.receive"]
+    bytes: Optional[bytes]
+    text: Optional[str]
+
+
+class WebSocketSendEvent(TypedDict):
+    type: Literal["websocket.send"]
+    bytes: Optional[bytes]
+    text: Optional[str]
+
+
+class WebSocketResponseStartEvent(TypedDict):
+    type: Literal["websocket.http.response.start"]
+    status: int
+    headers: Iterable[Tuple[bytes, bytes]]
+
+
+class WebSocketResponseBodyEvent(TypedDict):
+    type: Literal["websocket.http.response.body"]
+    body: bytes
+    more_body: bool
+
+
+class WebSocketDisconnectEvent(TypedDict):
+    type: Literal["websocket.disconnect"]
+    code: int
+
+
+class WebSocketCloseEvent(TypedDict):
+    type: Literal["websocket.close"]
+    code: int
+    reason: Optional[str]
+
+
+class LifespanStartupEvent(TypedDict):
+    type: Literal["lifespan.startup"]
+
+
+class LifespanShutdownEvent(TypedDict):
+    type: Literal["lifespan.shutdown"]
+
+
+class LifespanStartupCompleteEvent(TypedDict):
+    type: Literal["lifespan.startup.complete"]
+
+
+class LifespanStartupFailedEvent(TypedDict):
+    type: Literal["lifespan.startup.failed"]
+    message: str
+
+
+class LifespanShutdownCompleteEvent(TypedDict):
+    type: Literal["lifespan.shutdown.complete"]
+
+
+class LifespanShutdownFailedEvent(TypedDict):
+    type: Literal["lifespan.shutdown.failed"]
+    message: str
+
+
+ASGIReceiveEvent = Union[
+    HTTPRequestEvent,
+    HTTPDisconnectEvent,
+    WebSocketConnectEvent,
+    WebSocketReceiveEvent,
+    WebSocketDisconnectEvent,
+    LifespanStartupEvent,
+    LifespanShutdownEvent,
+]
+
+
+ASGISendEvent = Union[
+    HTTPResponseStartEvent,
+    HTTPResponseBodyEvent,
+    HTTPServerPushEvent,
+    HTTPDisconnectEvent,
+    WebSocketAcceptEvent,
+    WebSocketSendEvent,
+    WebSocketResponseStartEvent,
+    WebSocketResponseBodyEvent,
+    WebSocketCloseEvent,
+    LifespanStartupCompleteEvent,
+    LifespanStartupFailedEvent,
+    LifespanShutdownCompleteEvent,
+    LifespanShutdownFailedEvent,
+]
+
+
+ASGIReceiveCallable = Callable[[], Awaitable[ASGIReceiveEvent]]
+ASGISendCallable = Callable[[ASGISendEvent], Awaitable[None]]
+
+
+class ASGI2Protocol(Protocol):
+    def __init__(self, scope: Scope) -> None:
+        ...
+
+    async def __call__(
+        self, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        ...
+
+
+ASGI2Application = Type[ASGI2Protocol]
+ASGI3Application = Callable[
+    [
+        Scope,
+        ASGIReceiveCallable,
+        ASGISendCallable,
+    ],
+    Awaitable[None],
+]
+ASGIApplication = Union[ASGI2Application, ASGI3Application]
diff --git a/myenv/lib/python3.9/site-packages/asgiref/wsgi.py b/myenv/lib/python3.9/site-packages/asgiref/wsgi.py
new file mode 100644
index 0000000..40fba20
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/asgiref/wsgi.py
@@ -0,0 +1,162 @@
+from io import BytesIO
+from tempfile import SpooledTemporaryFile
+
+from asgiref.sync import AsyncToSync, sync_to_async
+
+
+class WsgiToAsgi:
+    """
+    Wraps a WSGI application to make it into an ASGI application.
+    """
+
+    def __init__(self, wsgi_application):
+        self.wsgi_application = wsgi_application
+
+    async def __call__(self, scope, receive, send):
+        """
+        ASGI application instantiation point.
+        We return a new WsgiToAsgiInstance here with the WSGI app
+        and the scope, ready to respond when it is __call__ed.
+        """
+        await WsgiToAsgiInstance(self.wsgi_application)(scope, receive, send)
+
+
+class WsgiToAsgiInstance:
+    """
+    Per-socket instance of a wrapped WSGI application
+    """
+
+    def __init__(self, wsgi_application):
+        self.wsgi_application = wsgi_application
+        self.response_started = False
+        self.response_content_length = None
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] != "http":
+            raise ValueError("WSGI wrapper received a non-HTTP scope")
+        self.scope = scope
+        with SpooledTemporaryFile(max_size=65536) as body:
+            # Alright, wait for the http.request messages
+            while True:
+                message = await receive()
+                if message["type"] != "http.request":
+                    raise ValueError("WSGI wrapper received a non-HTTP-request message")
+                body.write(message.get("body", b""))
+                if not message.get("more_body"):
+                    break
+            body.seek(0)
+            # Wrap send so it can be called from the subthread
+            self.sync_send = AsyncToSync(send)
+            # Call the WSGI app
+            await self.run_wsgi_app(body)
+
+    def build_environ(self, scope, body):
+        """
+        Builds a scope and request body into a WSGI environ object.
+        """
+        environ = {
+            "REQUEST_METHOD": scope["method"],
+            "SCRIPT_NAME": scope.get("root_path", "").encode("utf8").decode("latin1"),
+            "PATH_INFO": scope["path"].encode("utf8").decode("latin1"),
+            "QUERY_STRING": scope["query_string"].decode("ascii"),
+            "SERVER_PROTOCOL": "HTTP/%s" % scope["http_version"],
+            "wsgi.version": (1, 0),
+            "wsgi.url_scheme": scope.get("scheme", "http"),
+            "wsgi.input": body,
+            "wsgi.errors": BytesIO(),
+            "wsgi.multithread": True,
+            "wsgi.multiprocess": True,
+            "wsgi.run_once": False,
+        }
+        # Get server name and port - required in WSGI, not in ASGI
+        if "server" in scope:
+            environ["SERVER_NAME"] = scope["server"][0]
+            environ["SERVER_PORT"] = str(scope["server"][1])
+        else:
+            environ["SERVER_NAME"] = "localhost"
+            environ["SERVER_PORT"] = "80"
+
+        if "client" in scope:
+            environ["REMOTE_ADDR"] = scope["client"][0]
+
+        # Go through headers and make them into environ entries
+        for name, value in self.scope.get("headers", []):
+            name = name.decode("latin1")
+            if name == "content-length":
+                corrected_name = "CONTENT_LENGTH"
+            elif name == "content-type":
+                corrected_name = "CONTENT_TYPE"
+            else:
+                corrected_name = "HTTP_%s" % name.upper().replace("-", "_")
+            # HTTPbis say only ASCII chars are allowed in headers, but we latin1 just in case
+            value = value.decode("latin1")
+            if corrected_name in environ:
+                value = environ[corrected_name] + "," + value
+            environ[corrected_name] = value
+        return environ
+
+    def start_response(self, status, response_headers, exc_info=None):
+        """
+        WSGI start_response callable.
+        """
+        # Don't allow re-calling once response has begun
+        if self.response_started:
+            raise exc_info[1].with_traceback(exc_info[2])
+        # Don't allow re-calling without exc_info
+        if hasattr(self, "response_start") and exc_info is None:
+            raise ValueError(
+                "You cannot call start_response a second time without exc_info"
+            )
+        # Extract status code
+        status_code, _ = status.split(" ", 1)
+        status_code = int(status_code)
+        # Extract headers
+        headers = [
+            (name.lower().encode("ascii"), value.encode("ascii"))
+            for name, value in response_headers
+        ]
+        # Extract content-length
+        self.response_content_length = None
+        for name, value in response_headers:
+            if name.lower() == "content-length":
+                self.response_content_length = int(value)
+        # Build and send response start message.
+        self.response_start = {
+            "type": "http.response.start",
+            "status": status_code,
+            "headers": headers,
+        }
+
+    @sync_to_async
+    def run_wsgi_app(self, body):
+        """
+        Called in a subthread to run the WSGI app. We encapsulate like
+        this so that the start_response callable is called in the same thread.
+        """
+        # Translate the scope and incoming request body into a WSGI environ
+        environ = self.build_environ(self.scope, body)
+        # Run the WSGI app
+        bytes_sent = 0
+        for output in self.wsgi_application(environ, self.start_response):
+            # If this is the first response, include the response headers
+            if not self.response_started:
+                self.response_started = True
+                self.sync_send(self.response_start)
+            # If the application supplies a Content-Length header
+            if self.response_content_length is not None:
+                # The server should not transmit more bytes to the client than the header allows
+                bytes_allowed = self.response_content_length - bytes_sent
+                if len(output) > bytes_allowed:
+                    output = output[:bytes_allowed]
+            self.sync_send(
+                {"type": "http.response.body", "body": output, "more_body": True}
+            )
+            bytes_sent += len(output)
+            # The server should stop iterating over the response when enough data has been sent
+            if bytes_sent == self.response_content_length:
+                break
+        # Close connection
+        if not self.response_started:
+            self.response_started = True
+            self.sync_send(self.response_start)
+        self.sync_send({"type": "http.response.body"})
diff --git a/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/CONTRIBUTORS.txt b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/CONTRIBUTORS.txt
new file mode 100644
index 0000000..0fb15ad
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/CONTRIBUTORS.txt
@@ -0,0 +1,175 @@
+# This file is autocompleted by 'contributors-txt',
+# using the configuration in 'script/.contributors_aliases.json'.
+# Do not add new persons manually and only add information without
+# using '-' as the line first character.
+# Please verify that your change are stable if you modify manually.
+
+Ex-maintainers
+--------------
+- Claudiu Popa <pcmanticore@gmail.com>
+- Sylvain Thénault <thenault@gmail.com>
+- Torsten Marek <shlomme@gmail.com>
+
+
+Maintainers
+-----------
+- Pierre Sassoulas <pierre.sassoulas@gmail.com>
+- Hippo91 <guillaume.peillex@gmail.com>
+- Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+- Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+- Bryce Guinta <bryce.paul.guinta@gmail.com>
+- Ceridwen <ceridwenv@gmail.com>
+- Łukasz Rogalski <rogalski.91@gmail.com>
+- Florian Bruhin <me@the-compiler.org>
+- Ashley Whetter <ashley@awhetter.co.uk>
+- Jacob Walls <jacobtylerwalls@gmail.com>
+- Dimitri Prybysh <dmand@yandex.ru>
+- Areveny <areveny@protonmail.com>
+
+
+Contributors
+------------
+- LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+- Nick Drozd <nicholasdrozd@gmail.com>
+- Andrew Haigh <hello@nelf.in>
+- David Liu <david@cs.toronto.edu>
+- Eevee (Alex Munroe) <amunroe@yelp.com>
+- David Gilman <davidgilman1@gmail.com>
+- Julien Jehannet <julien.jehannet@logilab.fr>
+- Calen Pennington <calen.pennington@gmail.com>
+- Phil Schaf <flying-sheep@web.de>
+- Hugo van Kemenade <hugovk@users.noreply.github.com>
+- Alex Hall <alex.mojaki@gmail.com>
+- Tushar Sadhwani <86737547+tushar-deepsource@users.noreply.github.com>
+- Tim Martin <tim@asymptotic.co.uk>
+- Raphael Gaschignard <raphael@makeleaps.com>
+- Radosław Ganczarek <radoslaw@ganczarek.in>
+- Paligot Gérard <androwiiid@gmail.com>
+- Ioana Tagirta <ioana.tagirta@gmail.com>
+- Derek Gustafson <degustaf@gmail.com>
+- David Shea <dshea@redhat.com>
+- Daniel Harding <dharding@gmail.com>
+- Ville Skyttä <ville.skytta@iki.fi>
+- Rene Zhang <rz99@cornell.edu>
+- Philip Lorenz <philip@bithub.de>
+- Mario Corchero <mariocj89@gmail.com>
+- Marien Zwart <marienz@gentoo.org>
+- FELD Boris <lothiraldan@gmail.com>
+- Enji Cooper <yaneurabeya@gmail.com>
+- doranid <ddandd@gmail.com>
+- brendanator <brendan.maginnis@gmail.com>
+- Tomas Gavenciak <gavento@ucw.cz>
+- Thomas Hisch <t.hisch@gmail.com>
+- Stefan Scherfke <stefan@sofa-rockers.org>
+- Sergei Lebedev <185856+superbobry@users.noreply.github.com>
+- Ram Rachum <ram@rachum.com>
+- Peter Pentchev <roam@ringlet.net>
+- Peter Kolbus <peter.kolbus@gmail.com>
+- Omer Katz <omer.drow@gmail.com>
+- Moises Lopez <moylop260@vauxoo.com>
+- Keichi Takahashi <keichi.t@me.com>
+- Kavins Singh <kavinsingh@hotmail.com>
+- Karthikeyan Singaravelan <tir.karthi@gmail.com>
+- Joshua Cannon <joshdcannon@gmail.com>
+- John Vandenberg <jayvdb@gmail.com>
+- Jacob Bogdanov <jacob@bogdanov.dev>
+- Google, Inc. <no-reply@google.com>
+- David Euresti <github@euresti.com>
+- David Cain <davidjosephcain@gmail.com>
+- Anthony Sottile <asottile@umich.edu>
+- Alexander Shadchin <alexandr.shadchin@gmail.com>
+- wgehalo <wgehalo@gmail.com>
+- tristanlatr <19967168+tristanlatr@users.noreply.github.com>
+- rr- <rr-@sakuya.pl>
+- raylu <lurayl@gmail.com>
+- mathieui <mathieui@users.noreply.github.com>
+- markmcclain <markmcclain@users.noreply.github.com>
+- ioanatia <ioanatia@users.noreply.github.com>
+- grayjk <grayjk@gmail.com>
+- Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl>
+- Zac Hatfield-Dodds <Zac-HD@users.noreply.github.com>
+- Vilnis Termanis <vilnis.termanis@iotics.com>
+- Valentin Valls <valentin.valls@esrf.fr>
+- Uilian Ries <uilianries@gmail.com>
+- Tomas Novak <ext.Tomas.Novak@skoda-auto.cz>
+- Thirumal Venkat <me@thirumal.in>
+- SupImDos <62866982+SupImDos@users.noreply.github.com>
+- Stanislav Levin <slev@altlinux.org>
+- Simon Hewitt <si@sjhewitt.co.uk>
+- Serhiy Storchaka <storchaka@gmail.com>
+- Roy Wright <roy@wright.org>
+- Robin Jarry <robin.jarry@6wind.com>
+- René Fritze <47802+renefritze@users.noreply.github.com>
+- Redoubts <Redoubts@users.noreply.github.com>
+- Philipp Hörist <philipp@hoerist.com>
+- Peter de Blanc <peter@standard.ai>
+- Peter Talley <peterctalley@gmail.com>
+- Ovidiu Sabou <ovidiu@sabou.org>
+- Nicolas Noirbent <nicolas@noirbent.fr>
+- Neil Girdhar <mistersheik@gmail.com>
+- Michał Masłowski <m.maslowski@clearcode.cc>
+- Michael K <michael-k@users.noreply.github.com>
+- Mateusz Bysiek <mb@mbdev.pl>
+- Mark Byrne <31762852+mbyrnepr2@users.noreply.github.com>
+- Leandro T. C. Melo <ltcmelo@gmail.com>
+- Konrad Weihmann <kweihmann@outlook.com>
+- Kian Meng, Ang <kianmeng.ang@gmail.com>
+- Kai Mueller <15907922+kasium@users.noreply.github.com>
+- Jörg Thalheim <Mic92@users.noreply.github.com>
+- Jonathan Striebel <jstriebel@users.noreply.github.com>
+- John Belmonte <john@neggie.net>
+- Jeff Widman <jeff@jeffwidman.com>
+- Jeff Quast <contact@jeffquast.com>
+- Jarrad Hope <me@jarradhope.com>
+- Jared Garst <jgarst@users.noreply.github.com>
+- Jakub Wilk <jwilk@jwilk.net>
+- Iva Miholic <ivamiho@gmail.com>
+- Ionel Maries Cristian <contact@ionelmc.ro>
+- HoverHell <hoverhell@gmail.com>
+- HQupgradeHQ <18361586+HQupgradeHQ@users.noreply.github.com>
+- Grygorii Iermolenko <gyermolenko@gmail.com>
+- Gregory P. Smith <greg@krypto.org>
+- Giuseppe Scrivano <gscrivan@redhat.com>
+- Frédéric Chapoton <fchapoton2@gmail.com>
+- Francis Charette Migneault <francis.charette.migneault@gmail.com>
+- Felix Mölder <felix.moelder@uni-due.de>
+- Federico Bond <federicobond@gmail.com>
+- DudeNr33 <3929834+DudeNr33@users.noreply.github.com>
+- Dmitry Shachnev <mitya57@users.noreply.github.com>
+- Denis Laxalde <denis.laxalde@logilab.fr>
+- David Poirier <david-poirier-csn@users.noreply.github.com>
+- Dave Hirschfeld <dave.hirschfeld@gmail.com>
+- Dave Baum <dbaum@google.com>
+- Daniel Martin <daniel.martin@crowdstrike.com>
+- Daniel Colascione <dancol@dancol.org>
+- Damien Baty <damien@damienbaty.com>
+- Craig Franklin <craigjfranklin@gmail.com>
+- Colin Kennedy <colinvfx@gmail.com>
+- Cole Robinson <crobinso@redhat.com>
+- Christoph Reiter <reiter.christoph@gmail.com>
+- Chris Philip <chrisp533@gmail.com>
+- BioGeek <jeroen.vangoey@gmail.com>
+- Bianca Power <30207144+biancapower@users.noreply.github.com>
+- Benjamin Elven <25181435+S3ntinelX@users.noreply.github.com>
+- Becker Awqatty <bawqatty@mide.com>
+- BasPH <BasPH@users.noreply.github.com>
+- Azeem Bande-Ali <A.BandeAli@gmail.com>
+- Aru Sahni <arusahni@gmail.com>
+- Artsiom Kaval <lezeroq@gmail.com>
+- Anubhav <35621759+anubh-v@users.noreply.github.com>
+- Antoine Boellinger <aboellinger@hotmail.com>
+- Alphadelta14 <alpha@alphaservcomputing.solutions>
+- Alexander Presnyakov <flagist0@gmail.com>
+- Ahmed Azzaoui <ahmed.azzaoui@engie.com>
+
+Co-Author
+---------
+The following persons were credited manually but did not commit themselves
+under this name, or we did not manage to find their commits in the history.
+
+- François Mockers
+- platings
+- carl
+- alain lefroy
+- Mark Gius
+- jarradhope
diff --git a/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/LICENSE
new file mode 100644
index 0000000..182e0fb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/LICENSE
@@ -0,0 +1,508 @@
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+	51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations
+below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it
+becomes a de-facto standard.  To achieve this, non-free programs must
+be allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control
+compilation and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at least
+    three years, to give the same user the materials specified in
+    Subsection 6a, above, for a charge no more than the cost of
+    performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply, and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License
+may add an explicit geographical distribution limitation excluding those
+countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms
+of the ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.
+It is safest to attach them to the start of each source file to most
+effectively convey the exclusion of warranty; and each file should
+have at least the "copyright" line and a pointer to where the full
+notice is found.
+
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    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 St, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or
+your school, if any, to sign a "copyright disclaimer" for the library,
+if necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James
+  Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/METADATA b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/METADATA
new file mode 100644
index 0000000..4096b32
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/METADATA
@@ -0,0 +1,129 @@
+Metadata-Version: 2.1
+Name: astroid
+Version: 2.11.7
+Summary: An abstract syntax tree for Python with inference support.
+Home-page: https://github.com/PyCQA/astroid
+Author: Python Code Quality Authority
+Author-email: code-quality@python.org
+License: LGPL-2.1-or-later
+Project-URL: Bug tracker, https://github.com/PyCQA/astroid/issues
+Project-URL: Discord server, https://discord.gg/Egy6P8AMB5
+Keywords: static code analysis,python,abstract syntax tree
+Classifier: Development Status :: 6 - Mature
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 (LGPLv2)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.6.2
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: CONTRIBUTORS.txt
+Requires-Dist: lazy-object-proxy (>=1.4.0)
+Requires-Dist: wrapt (<2,>=1.11)
+Requires-Dist: setuptools (>=20.0)
+Requires-Dist: typed-ast (<2.0,>=1.4.0) ; implementation_name == "cpython" and python_version < "3.8"
+Requires-Dist: typing-extensions (>=3.10) ; python_version < "3.10"
+
+Astroid
+=======
+
+.. image:: https://coveralls.io/repos/github/PyCQA/astroid/badge.svg?branch=main
+    :target: https://coveralls.io/github/PyCQA/astroid?branch=main
+    :alt: Coverage badge from coveralls.io
+
+.. image:: https://readthedocs.org/projects/astroid/badge/?version=latest
+    :target: http://astroid.readthedocs.io/en/latest/?badge=latest
+    :alt: Documentation Status
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/ambv/black
+
+.. image:: https://results.pre-commit.ci/badge/github/PyCQA/astroid/main.svg
+   :target: https://results.pre-commit.ci/latest/github/PyCQA/astroid/main
+   :alt: pre-commit.ci status
+
+.. |tidelift_logo| image:: https://raw.githubusercontent.com/PyCQA/astroid/main/doc/media/Tidelift_Logos_RGB_Tidelift_Shorthand_On-White.png
+   :width: 75
+   :height: 60
+   :alt: Tidelift
+
+.. list-table::
+   :widths: 10 100
+
+   * - |tidelift_logo|
+     - Professional support for astroid is available as part of the
+       `Tidelift Subscription`_.  Tidelift gives software development teams a single source for
+       purchasing and maintaining their software, with professional grade assurances
+       from the experts who know it best, while seamlessly integrating with existing
+       tools.
+
+.. _Tidelift Subscription: https://tidelift.com/subscription/pkg/pypi-astroid?utm_source=pypi-astroid&utm_medium=referral&utm_campaign=readme
+
+
+
+What's this?
+------------
+
+The aim of this module is to provide a common base representation of
+python source code. It is currently the library powering pylint's capabilities.
+
+It provides a compatible representation which comes from the `_ast`
+module.  It rebuilds the tree generated by the builtin _ast module by
+recursively walking down the AST and building an extended ast. The new
+node classes have additional methods and attributes for different
+usages. They include some support for static inference and local name
+scopes. Furthermore, astroid can also build partial trees by inspecting living
+objects.
+
+
+Installation
+------------
+
+Extract the tarball, jump into the created directory and run::
+
+    pip install .
+
+
+If you want to do an editable installation, you can run::
+
+    pip install -e .
+
+
+If you have any questions, please mail the code-quality@python.org
+mailing list for support. See
+http://mail.python.org/mailman/listinfo/code-quality for subscription
+information and archives.
+
+Documentation
+-------------
+http://astroid.readthedocs.io/en/latest/
+
+
+Python Versions
+---------------
+
+astroid 2.0 is currently available for Python 3 only. If you want Python 2
+support, use an older version of astroid (though note that these versions
+are no longer supported).
+
+Test
+----
+
+Tests are in the 'test' subdirectory. To launch the whole tests suite, you can use
+either `tox` or `pytest`::
+
+    tox
+    pytest astroid
diff --git a/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/RECORD b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/RECORD
new file mode 100644
index 0000000..8ded6ee
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/RECORD
@@ -0,0 +1,101 @@
+astroid/__init__.py,sha256=PZRnmbvNyyztzoep3TNq10RnlnWgtWC3d-ntvmXettQ,5202
+astroid/__pkginfo__.py,sha256=B7AH_irTjoDqJDLb8H2GFcWt80is9hliU-R1XmszI3A,274
+astroid/_ast.py,sha256=GHCb1UhQYAdYq4FIWj4grPMEkCkGzgPtq9I-3546C1g,3713
+astroid/arguments.py,sha256=ioNM-KU0UQQw0Ji3cplijDRKMo3wKRYofr8JG071IlM,12772
+astroid/astroid_manager.py,sha256=0kHpLsw88YEdjEf11pHZV0Ru7u1sM3TkjKE64VJ6MAU,568
+astroid/bases.py,sha256=bL5597ATkiEYWvNlSLCATArt7Egd8234_ffq7YLNimc,20003
+astroid/builder.py,sha256=tRGbSQbB8B6hLNg347ylD5__1Awqf2DHgMj1tSt-y5Y,17317
+astroid/const.py,sha256=fLUo3VgP8jFaL9gw1HqHpsp1YdMfSksQXuJzvRqyghQ,868
+astroid/context.py,sha256=YPPvoNA8pHirJEyX3DHbKLDMALsNKPnNAuDlcnf4gSc,5688
+astroid/decorators.py,sha256=1opjj_aJdpKZfsVqT3_Ix6uCtVci4Lv9jvMHfP3xcfM,9503
+astroid/exceptions.py,sha256=9M4aj1kwg4kGzK4Q51eLOaYMQESsql1I4928s1oUC-c,8538
+astroid/filter_statements.py,sha256=1_xfnZHCrNyCKtwDwiVXhHXM977jXmRJ5VeXk44q7R0,9644
+astroid/helpers.py,sha256=hcAXP11C3a7J0jwOYudwCHTgajq7RcRAPTHmKpcqzSw,10276
+astroid/inference.py,sha256=jaiatB037N2KlCjcY62psVdY_LuLz1OlM9esZs9yawA,36351
+astroid/inference_tip.py,sha256=6fChETD0XKh7khW6DDXEgnnsShlHIAhRjYIWbxl8juY,2969
+astroid/manager.py,sha256=ekgbq49QWWPk4p-2lladUnHhjwv-xcnamx0hspHzWME,13558
+astroid/mixins.py,sha256=uLpgScOzCa1pIHk3D3aDQqT2gFEWvJA63ZJemClmI7s,5510
+astroid/modutils.py,sha256=psXAsy-YDA2k_8imNaN_wylQuc8mglgdgIYMEyhpu08,20773
+astroid/node_classes.py,sha256=OnYVG9E21mFM7R-xXO_Bn8Bn1UFYwM4GSwLDg8JwwLM,1802
+astroid/objects.py,sha256=G-MjRjqi8w-fmC1WmHvpC8tiBdhG7FpPrSV2fBaSFgc,11769
+astroid/protocols.py,sha256=ezS37nv-11NHq4Kn1nvRoWIu-GJbbwctvrxL0AJp6fE,30095
+astroid/raw_building.py,sha256=0PXzpGytJaQPqNA3T0V3K-FrOniCRHkGuxFImFf4TLc,18027
+astroid/rebuilder.py,sha256=MPgqHUf8p-B5aWr0P8L407_zBdXPJg0F8j2s3Q55mj4,79052
+astroid/scoped_nodes.py,sha256=rELeS8rKUxNcJZxHlKERD3im6HGKae4wbcx51VCiZmI,933
+astroid/test_utils.py,sha256=tRsndWUiEwr29S7Bf6Ej5x-Ooph2byfCTEf-pheLhjM,2397
+astroid/transforms.py,sha256=Gnm2oXDE7SrSNsh6Ks6e3ycqSWWNlNljhXTxkZvW4wg,3264
+astroid/typing.py,sha256=hEiny9JQuETF5eAyXrYE7wG8c_DO_4mc39027WRXrqM,737
+astroid/util.py,sha256=F5bbf33-dgaEaeSbkdNYnRBJSGJ39eWJFrZOT7q2EPk,4256
+astroid/brain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astroid/brain/brain_argparse.py,sha256=WdKRrkd4--tdZtJzNI1nJAmA_-gdkz8KNguPUTe6jis,1441
+astroid/brain/brain_attrs.py,sha256=dwMHH4ou5jNq33hlXVW3e9QYB-BC_os41RgG2QNyMR4,2853
+astroid/brain/brain_boto3.py,sha256=-Ntjxs3fneXCwYWBMxjeKS6gKRYf609nNAdf_Fv5LQs,997
+astroid/brain/brain_builtin_inference.py,sha256=DLYc0S72TN7nEft1tunET5psSk_W5kThtop2QGnYWro,30630
+astroid/brain/brain_collections.py,sha256=3xGVDVZIG5RTydq-lda7GWViXqN506L1wDb6eKvIUIE,4307
+astroid/brain/brain_crypt.py,sha256=q-4C5kA8qEwk822Fi4KkbyVz5zq8UG2DUAKGFyXkpVI,1044
+astroid/brain/brain_ctypes.py,sha256=Zl6XWUMx852uwIGi8EeLywmhDOqzpRnWaPjD5hVshjA,2655
+astroid/brain/brain_curses.py,sha256=XXyCeLASFFksO2zSbrZgB_AImGBlIGZ7Pgjdm04x-jg,3477
+astroid/brain/brain_dataclasses.py,sha256=8PI0XKyeJO0sE9RMQUAHxSKgM_Ss4cm1A29AH8b_NaE,14992
+astroid/brain/brain_dateutil.py,sha256=ajM8Xkn6WrrPGQBleEM_XIb0SnAozIfaHpDbG8e5vyo,766
+astroid/brain/brain_fstrings.py,sha256=fxeEYe37aEHg5zTuAR3J1QP5fUNJLY-0ATB7jAxVof4,2175
+astroid/brain/brain_functools.py,sha256=I6SDzNjBGFqB33nAA9icvnL0hCa4CJhcI46CWESBQKw,5842
+astroid/brain/brain_gi.py,sha256=q_gfHJKL9IHGk0TnC7kvDISSVNMkCl-mn7ed1t-U1H8,7540
+astroid/brain/brain_hashlib.py,sha256=0wd-TK0BsMiAwVhrfZAm6_ACxRJYxix0WHw4ItZgnfo,2189
+astroid/brain/brain_http.py,sha256=OgqOSkOqctysaPycz9SOmF3NxpJ4OPg5nZ-PqYwUgow,10602
+astroid/brain/brain_hypothesis.py,sha256=ZypkmriFkll04Hkx_4wZH6xe1myMqjtmcOcr70kldvw,1725
+astroid/brain/brain_io.py,sha256=Rh84qonOdMIS_Z3zEFGvmyObPs4vjO3WzYV5V7LYTEM,1517
+astroid/brain/brain_mechanize.py,sha256=EyBHLek513PHyCE7NDW-dlkJ8gdJbjxwLMtKMbE0YGA,2530
+astroid/brain/brain_multiprocessing.py,sha256=5LlHw5efq01VUV-vUWpH8u7vHhk3SPp1tf4N-BZSmzU,3181
+astroid/brain/brain_namedtuple_enum.py,sha256=hzj09nO4N61wy-5TrYtzeL08aGZRSzdYwVOOnigNGYM,20516
+astroid/brain/brain_nose.py,sha256=DCUwKzR14Se5tF-s54AMwFoRvhsHH_nf6agrh966VpQ,2320
+astroid/brain/brain_numpy_core_fromnumeric.py,sha256=3UFRtK5U51AVQNxawf9ElhFv2tizhj5RfyCSnPT3u54,732
+astroid/brain/brain_numpy_core_function_base.py,sha256=_k-WRQ_x0QEHhvr9IwuTLnpGoCYOVO0GAH7e3DyoHNQ,1298
+astroid/brain/brain_numpy_core_multiarray.py,sha256=YPY78fKkr0pFimDu9hW1o9kytivAeylNsgbVvXs7xV8,4210
+astroid/brain/brain_numpy_core_numeric.py,sha256=VAc51Ud8QDujsh29e-RQK5SBcKW_jzjZIFmntCslCKU,1629
+astroid/brain/brain_numpy_core_numerictypes.py,sha256=HVJ_paQwjh2V8qz0Juei6b2ZRm_dmDJodiDKfAcE-mE,8546
+astroid/brain/brain_numpy_core_umath.py,sha256=2EhXmtiw8wQcdUtbnlLLTjHAOHpQ1c9BXHdc6kHJGbA,4893
+astroid/brain/brain_numpy_ma.py,sha256=Wb4CZAo6WzprymYTxWrF_IlhbKPzcJ_cmw5npSeq1mo,805
+astroid/brain/brain_numpy_ndarray.py,sha256=dAH8wFR7sjQF3pcUINlp6WkBQy4tSBTU_m6Emb0E9mE,8882
+astroid/brain/brain_numpy_random_mtrand.py,sha256=Wrpm9SX8kH0Xsk9b3qpR0rhs-MEb0I5aN4E-66wkLkM,3436
+astroid/brain/brain_numpy_utils.py,sha256=BOH-BYMYUrTLAsBf8VFumKDwcH_82AsCjtOqZbnqMWU,2543
+astroid/brain/brain_pkg_resources.py,sha256=W3Q4G6mYTYtJY9iWQv3vEO8_lpmLFAin9aQLtBRLxAc,2200
+astroid/brain/brain_pytest.py,sha256=suTDBHCJ_p4F7TGXjwVJAFtiAP-VlkFE2gncXjLRQKM,2223
+astroid/brain/brain_qt.py,sha256=dE30a8e7aeQlMss5Nn1OobZpdhn-nzn3ylOllbSlMxI,2505
+astroid/brain/brain_random.py,sha256=CqjCq2IIVspVcMGk43cn_RB7y5iHLaMjCP4mCWf-3tE,2692
+astroid/brain/brain_re.py,sha256=NzMzyUvRTMI3LqMFqMFEWAdzIxGcKSVjZnP55s5cDXk,2669
+astroid/brain/brain_responses.py,sha256=qI7BWS_fWS5c_PcMnLgqABJRlwn8j9IRlq-XOdKnAWs,1869
+astroid/brain/brain_scipy_signal.py,sha256=Mi93D6-j94tqhqDHCbabVs3_eDAhti88CL1_rOvnG_I,2276
+astroid/brain/brain_signal.py,sha256=MJCkmWmUTVEqVKwQfE8FzVh-x0XLzJpBdVjjeJynQbg,3859
+astroid/brain/brain_six.py,sha256=JNtmuokvVod0-mwSb4yU0Zhm_Qts4daSp__yvU3RnFM,7569
+astroid/brain/brain_sqlalchemy.py,sha256=onKAxgKY-GYLe2v6PVK3APBn_z8txokEZfDcXt33GuE,1009
+astroid/brain/brain_ssl.py,sha256=gUTdzoUVlA8ehtwCjyJ3o6omG1PqoBPs2cXDDDmGI3M,3578
+astroid/brain/brain_subprocess.py,sha256=mBC5ulUUt5JcPiZu1ZAeGDn_Y3vAgqMOrsz9HGwVAWo,3768
+astroid/brain/brain_threading.py,sha256=N7F9UUe9lsDYtySrC1pKn_etxYmJ13tWzfom5q7l54s,855
+astroid/brain/brain_type.py,sha256=4mQWbJBqwviXx2Rdul_3Gu4FVTXxMGD4vHxKHm43CjQ,2472
+astroid/brain/brain_typing.py,sha256=87RT9F5EJYxyj2-__L6IgxEUBsGszrKBWNsi3Mhaxyo,14380
+astroid/brain/brain_unittest.py,sha256=O8acdDUPDb21ytB8EJ-3UCU6cIZ1pegs-EiPvKzEutw,1136
+astroid/brain/brain_uuid.py,sha256=fztFKPbRbrZzbvrzp5LCvYU4cE_WLmfVo0ws_Uc9FSw,649
+astroid/brain/helpers.py,sha256=OQLzWcxOg1K8eOxXHKOKUxF1HkpNyZQCjWyEvqnSHdk,718
+astroid/interpreter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astroid/interpreter/dunder_lookup.py,sha256=cDcopHXRrJRxPZ19698HwO5p5gIIdc4posLG3VHF6Bo,2139
+astroid/interpreter/objectmodel.py,sha256=TP7RewfIrYGyFrIHuJC_ig9KgS6teMa5di5gDsIZjqc,27766
+astroid/interpreter/_import/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astroid/interpreter/_import/spec.py,sha256=WGAlH5e5xNaRgx22usKO13z3eD5wRD2kDMwgGWOBfvo,13329
+astroid/interpreter/_import/util.py,sha256=Rl7gWekrSdm3Nk3F2oVFmutA4HlSepHA5PAqEg44eOw,529
+astroid/nodes/__init__.py,sha256=8fyupLEs0pKqbWu_3iMQcOlC7QQYHmiLv7P52eT2fqE,4836
+astroid/nodes/as_string.py,sha256=_JYz5qTcbGqZUZ40sc_rllJzp7S4n_6kqN9XZYuspC8,23797
+astroid/nodes/const.py,sha256=iyQn_v-wEzK6uXc-dEMoliPVSRy0NZ8T3XmvvPXLuP4,797
+astroid/nodes/node_classes.py,sha256=N2gWXwBO8m8KWYINaoBsGKEr5mnbzoMUOvGdxMouePo,164847
+astroid/nodes/node_ng.py,sha256=CcKOGv6eu_hHMbM71ZU1Hm1yeIEiIMeTEqDZOtQL-YI,28103
+astroid/nodes/utils.py,sha256=Uy6xoownLyWwDtuZ5qUpjbq19P2pUIcj0J04khbH5HY,423
+astroid/nodes/scoped_nodes/__init__.py,sha256=S8pX4zg73KzuCIawKmdgj-BuvXAh29atqUm23z0zI6U,1218
+astroid/nodes/scoped_nodes/mixin.py,sha256=9_dyepx-vfwvhyxLd5S6nSnbdRvTPfYhWdwztdhHYfM,5819
+astroid/nodes/scoped_nodes/scoped_nodes.py,sha256=Oh9dJoTuweiSrp4umO048gedlLs1axaFc8kdlpNu_2Y,105931
+astroid/nodes/scoped_nodes/utils.py,sha256=k7XSCSLC-S5L-puGQM4mv0e4N5-qMfo7UhDO3dswhcQ,1112
+astroid-2.11.7.dist-info/CONTRIBUTORS.txt,sha256=2I_w7LagIB19_12quxx9uYsoY0OoPPtZ9fYzVxSK_io,6858
+astroid-2.11.7.dist-info/LICENSE,sha256=_qFr2p5zTeoNnI2fW5CYeO9BcWJjVDKWCf_889tCyyQ,26516
+astroid-2.11.7.dist-info/METADATA,sha256=MBjTQH1_yiEYoFgYWhTQb9_3Vu75UMQqnrPirG_rO-Q,4681
+astroid-2.11.7.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+astroid-2.11.7.dist-info/top_level.txt,sha256=HsdW4O2x7ZXRj6k-agi3RaQybGLobI3VSE-jt4vQUXM,8
+astroid-2.11.7.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+astroid-2.11.7.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/WHEEL
new file mode 100644
index 0000000..becc9a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/top_level.txt
new file mode 100644
index 0000000..450d4fe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid-2.11.7.dist-info/top_level.txt
@@ -0,0 +1 @@
+astroid
diff --git a/myenv/lib/python3.9/site-packages/astroid/__init__.py b/myenv/lib/python3.9/site-packages/astroid/__init__.py
new file mode 100644
index 0000000..14a61c2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/__init__.py
@@ -0,0 +1,200 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Python Abstract Syntax Tree New Generation
+
+The aim of this module is to provide a common base representation of
+python source code for projects such as pychecker, pyreverse,
+pylint... Well, actually the development of this library is essentially
+governed by pylint's needs.
+
+It mimics the class defined in the python's _ast module with some
+additional methods and attributes. New nodes instances are not fully
+compatible with python's _ast.
+
+Instance attributes are added by a
+builder object, which can either generate extended ast (let's call
+them astroid ;) by visiting an existent ast tree or by inspecting living
+object. Methods are added by monkey patching ast classes.
+
+Main modules are:
+
+* nodes and scoped_nodes for more information about methods and
+  attributes added to different node classes
+
+* the manager contains a high level object to get astroid trees from
+  source files and living objects. It maintains a cache of previously
+  constructed tree for quick access
+
+* builder contains the class responsible to build astroid trees
+"""
+
+import functools
+import tokenize
+from importlib import import_module
+from pathlib import Path
+
+# isort: off
+# We have an isort: off on '__version__' because the packaging need to access
+# the version before the dependencies are installed (in particular 'wrapt'
+# that is imported in astroid.inference)
+from astroid.__pkginfo__ import __version__, version
+from astroid.nodes import node_classes, scoped_nodes
+
+# isort: on
+
+from astroid import inference, raw_building
+from astroid.astroid_manager import MANAGER
+from astroid.bases import BaseInstance, BoundMethod, Instance, UnboundMethod
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import extract_node, parse
+from astroid.const import PY310_PLUS, Context, Del, Load, Store
+from astroid.exceptions import (
+    AstroidBuildingError,
+    AstroidBuildingException,
+    AstroidError,
+    AstroidImportError,
+    AstroidIndexError,
+    AstroidSyntaxError,
+    AstroidTypeError,
+    AstroidValueError,
+    AttributeInferenceError,
+    BinaryOperationError,
+    DuplicateBasesError,
+    InconsistentMroError,
+    InferenceError,
+    InferenceOverwriteError,
+    MroError,
+    NameInferenceError,
+    NoDefault,
+    NotFoundError,
+    OperationError,
+    ParentMissingError,
+    ResolveError,
+    StatementMissing,
+    SuperArgumentTypeError,
+    SuperError,
+    TooManyLevelsError,
+    UnaryOperationError,
+    UnresolvableName,
+    UseInferenceDefault,
+)
+from astroid.inference_tip import _inference_tip_cached, inference_tip
+from astroid.objects import ExceptionInstance
+
+# isort: off
+# It's impossible to import from astroid.nodes with a wildcard, because
+# there is a cyclic import that prevent creating an __all__ in astroid/nodes
+# and we need astroid/scoped_nodes and astroid/node_classes to work. So
+# importing with a wildcard would clash with astroid/nodes/scoped_nodes
+# and astroid/nodes/node_classes.
+from astroid.nodes import (  # pylint: disable=redefined-builtin (Ellipsis)
+    CONST_CLS,
+    AnnAssign,
+    Arguments,
+    Assert,
+    Assign,
+    AssignAttr,
+    AssignName,
+    AsyncFor,
+    AsyncFunctionDef,
+    AsyncWith,
+    Attribute,
+    AugAssign,
+    Await,
+    BinOp,
+    BoolOp,
+    Break,
+    Call,
+    ClassDef,
+    Compare,
+    Comprehension,
+    ComprehensionScope,
+    Const,
+    Continue,
+    Decorators,
+    DelAttr,
+    Delete,
+    DelName,
+    Dict,
+    DictComp,
+    DictUnpack,
+    Ellipsis,
+    EmptyNode,
+    EvaluatedObject,
+    ExceptHandler,
+    Expr,
+    ExtSlice,
+    For,
+    FormattedValue,
+    FunctionDef,
+    GeneratorExp,
+    Global,
+    If,
+    IfExp,
+    Import,
+    ImportFrom,
+    Index,
+    JoinedStr,
+    Keyword,
+    Lambda,
+    List,
+    ListComp,
+    Match,
+    MatchAs,
+    MatchCase,
+    MatchClass,
+    MatchMapping,
+    MatchOr,
+    MatchSequence,
+    MatchSingleton,
+    MatchStar,
+    MatchValue,
+    Module,
+    Name,
+    NamedExpr,
+    NodeNG,
+    Nonlocal,
+    Pass,
+    Raise,
+    Return,
+    Set,
+    SetComp,
+    Slice,
+    Starred,
+    Subscript,
+    TryExcept,
+    TryFinally,
+    Tuple,
+    UnaryOp,
+    Unknown,
+    While,
+    With,
+    Yield,
+    YieldFrom,
+    are_exclusive,
+    builtin_lookup,
+    unpack_infer,
+    function_to_method,
+)
+
+# isort: on
+
+from astroid.util import Uninferable
+
+# Performance hack for tokenize. See https://bugs.python.org/issue43014
+# Adapted from https://github.com/PyCQA/pycodestyle/pull/993
+if (
+    not PY310_PLUS
+    and callable(getattr(tokenize, "_compile", None))
+    and getattr(tokenize._compile, "__wrapped__", None) is None  # type: ignore[attr-defined]
+):
+    tokenize._compile = functools.lru_cache()(tokenize._compile)  # type: ignore[attr-defined]
+
+# load brain plugins
+ASTROID_INSTALL_DIRECTORY = Path(__file__).parent
+BRAIN_MODULES_DIRECTORY = ASTROID_INSTALL_DIRECTORY / "brain"
+for module in BRAIN_MODULES_DIRECTORY.iterdir():
+    if module.suffix == ".py":
+        import_module(f"astroid.brain.{module.stem}")
diff --git a/myenv/lib/python3.9/site-packages/astroid/__pkginfo__.py b/myenv/lib/python3.9/site-packages/astroid/__pkginfo__.py
new file mode 100644
index 0000000..459314b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/__pkginfo__.py
@@ -0,0 +1,6 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+__version__ = "2.11.7"
+version = __version__
diff --git a/myenv/lib/python3.9/site-packages/astroid/_ast.py b/myenv/lib/python3.9/site-packages/astroid/_ast.py
new file mode 100644
index 0000000..1c4da43
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/_ast.py
@@ -0,0 +1,130 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+import ast
+import sys
+import types
+from collections import namedtuple
+from functools import partial
+from typing import Dict, Optional
+
+from astroid.const import PY38_PLUS, Context
+
+if sys.version_info >= (3, 8):
+    # On Python 3.8, typed_ast was merged back into `ast`
+    _ast_py3: Optional[types.ModuleType] = ast
+else:
+    try:
+        import typed_ast.ast3 as _ast_py3
+    except ImportError:
+        _ast_py3 = None
+
+FunctionType = namedtuple("FunctionType", ["argtypes", "returns"])
+
+
+class ParserModule(
+    namedtuple(
+        "ParserModule",
+        [
+            "module",
+            "unary_op_classes",
+            "cmp_op_classes",
+            "bool_op_classes",
+            "bin_op_classes",
+            "context_classes",
+        ],
+    )
+):
+    def parse(self, string: str, type_comments=True):
+        if self.module is _ast_py3:
+            if PY38_PLUS:
+                parse_func = partial(self.module.parse, type_comments=type_comments)
+            else:
+                parse_func = partial(
+                    self.module.parse, feature_version=sys.version_info.minor
+                )
+        else:
+            parse_func = self.module.parse
+        return parse_func(string)
+
+
+def parse_function_type_comment(type_comment: str) -> Optional[FunctionType]:
+    """Given a correct type comment, obtain a FunctionType object"""
+    if _ast_py3 is None:
+        return None
+
+    func_type = _ast_py3.parse(type_comment, "<type_comment>", "func_type")  # type: ignore[attr-defined]
+    return FunctionType(argtypes=func_type.argtypes, returns=func_type.returns)
+
+
+def get_parser_module(type_comments=True) -> ParserModule:
+    parser_module = ast
+    if type_comments and _ast_py3:
+        parser_module = _ast_py3
+
+    unary_op_classes = _unary_operators_from_module(parser_module)
+    cmp_op_classes = _compare_operators_from_module(parser_module)
+    bool_op_classes = _bool_operators_from_module(parser_module)
+    bin_op_classes = _binary_operators_from_module(parser_module)
+    context_classes = _contexts_from_module(parser_module)
+
+    return ParserModule(
+        parser_module,
+        unary_op_classes,
+        cmp_op_classes,
+        bool_op_classes,
+        bin_op_classes,
+        context_classes,
+    )
+
+
+def _unary_operators_from_module(module):
+    return {module.UAdd: "+", module.USub: "-", module.Not: "not", module.Invert: "~"}
+
+
+def _binary_operators_from_module(module):
+    binary_operators = {
+        module.Add: "+",
+        module.BitAnd: "&",
+        module.BitOr: "|",
+        module.BitXor: "^",
+        module.Div: "/",
+        module.FloorDiv: "//",
+        module.MatMult: "@",
+        module.Mod: "%",
+        module.Mult: "*",
+        module.Pow: "**",
+        module.Sub: "-",
+        module.LShift: "<<",
+        module.RShift: ">>",
+    }
+    return binary_operators
+
+
+def _bool_operators_from_module(module):
+    return {module.And: "and", module.Or: "or"}
+
+
+def _compare_operators_from_module(module):
+    return {
+        module.Eq: "==",
+        module.Gt: ">",
+        module.GtE: ">=",
+        module.In: "in",
+        module.Is: "is",
+        module.IsNot: "is not",
+        module.Lt: "<",
+        module.LtE: "<=",
+        module.NotEq: "!=",
+        module.NotIn: "not in",
+    }
+
+
+def _contexts_from_module(module) -> Dict[ast.expr_context, Context]:
+    return {
+        module.Load: Context.Load,
+        module.Store: Context.Store,
+        module.Del: Context.Del,
+        module.Param: Context.Store,
+    }
diff --git a/myenv/lib/python3.9/site-packages/astroid/arguments.py b/myenv/lib/python3.9/site-packages/astroid/arguments.py
new file mode 100644
index 0000000..40061d0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/arguments.py
@@ -0,0 +1,306 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from typing import Optional, Set
+
+from astroid import nodes
+from astroid.bases import Instance
+from astroid.context import CallContext, InferenceContext
+from astroid.exceptions import InferenceError, NoDefault
+from astroid.util import Uninferable
+
+
+class CallSite:
+    """Class for understanding arguments passed into a call site
+
+    It needs a call context, which contains the arguments and the
+    keyword arguments that were passed into a given call site.
+    In order to infer what an argument represents, call :meth:`infer_argument`
+    with the corresponding function node and the argument name.
+
+    :param callcontext:
+        An instance of :class:`astroid.context.CallContext`, that holds
+        the arguments for the call site.
+    :param argument_context_map:
+        Additional contexts per node, passed in from :attr:`astroid.context.Context.extra_context`
+    :param context:
+        An instance of :class:`astroid.context.Context`.
+    """
+
+    def __init__(
+        self, callcontext: CallContext, argument_context_map=None, context=None
+    ):
+        if argument_context_map is None:
+            argument_context_map = {}
+        self.argument_context_map = argument_context_map
+        args = callcontext.args
+        keywords = callcontext.keywords
+        self.duplicated_keywords: Set[str] = set()
+        self._unpacked_args = self._unpack_args(args, context=context)
+        self._unpacked_kwargs = self._unpack_keywords(keywords, context=context)
+
+        self.positional_arguments = [
+            arg for arg in self._unpacked_args if arg is not Uninferable
+        ]
+        self.keyword_arguments = {
+            key: value
+            for key, value in self._unpacked_kwargs.items()
+            if value is not Uninferable
+        }
+
+    @classmethod
+    def from_call(cls, call_node, context: Optional[InferenceContext] = None):
+        """Get a CallSite object from the given Call node.
+
+        context will be used to force a single inference path.
+        """
+
+        # Determine the callcontext from the given `context` object if any.
+        context = context or InferenceContext()
+        callcontext = CallContext(call_node.args, call_node.keywords)
+        return cls(callcontext, context=context)
+
+    def has_invalid_arguments(self):
+        """Check if in the current CallSite were passed *invalid* arguments
+
+        This can mean multiple things. For instance, if an unpacking
+        of an invalid object was passed, then this method will return True.
+        Other cases can be when the arguments can't be inferred by astroid,
+        for example, by passing objects which aren't known statically.
+        """
+        return len(self.positional_arguments) != len(self._unpacked_args)
+
+    def has_invalid_keywords(self):
+        """Check if in the current CallSite were passed *invalid* keyword arguments
+
+        For instance, unpacking a dictionary with integer keys is invalid
+        (**{1:2}), because the keys must be strings, which will make this
+        method to return True. Other cases where this might return True if
+        objects which can't be inferred were passed.
+        """
+        return len(self.keyword_arguments) != len(self._unpacked_kwargs)
+
+    def _unpack_keywords(self, keywords, context=None):
+        values = {}
+        context = context or InferenceContext()
+        context.extra_context = self.argument_context_map
+        for name, value in keywords:
+            if name is None:
+                # Then it's an unpacking operation (**)
+                try:
+                    inferred = next(value.infer(context=context))
+                except InferenceError:
+                    values[name] = Uninferable
+                    continue
+                except StopIteration:
+                    continue
+
+                if not isinstance(inferred, nodes.Dict):
+                    # Not something we can work with.
+                    values[name] = Uninferable
+                    continue
+
+                for dict_key, dict_value in inferred.items:
+                    try:
+                        dict_key = next(dict_key.infer(context=context))
+                    except InferenceError:
+                        values[name] = Uninferable
+                        continue
+                    except StopIteration:
+                        continue
+                    if not isinstance(dict_key, nodes.Const):
+                        values[name] = Uninferable
+                        continue
+                    if not isinstance(dict_key.value, str):
+                        values[name] = Uninferable
+                        continue
+                    if dict_key.value in values:
+                        # The name is already in the dictionary
+                        values[dict_key.value] = Uninferable
+                        self.duplicated_keywords.add(dict_key.value)
+                        continue
+                    values[dict_key.value] = dict_value
+            else:
+                values[name] = value
+        return values
+
+    def _unpack_args(self, args, context=None):
+        values = []
+        context = context or InferenceContext()
+        context.extra_context = self.argument_context_map
+        for arg in args:
+            if isinstance(arg, nodes.Starred):
+                try:
+                    inferred = next(arg.value.infer(context=context))
+                except InferenceError:
+                    values.append(Uninferable)
+                    continue
+                except StopIteration:
+                    continue
+
+                if inferred is Uninferable:
+                    values.append(Uninferable)
+                    continue
+                if not hasattr(inferred, "elts"):
+                    values.append(Uninferable)
+                    continue
+                values.extend(inferred.elts)
+            else:
+                values.append(arg)
+        return values
+
+    def infer_argument(self, funcnode, name, context):
+        """infer a function argument value according to the call context
+
+        Arguments:
+            funcnode: The function being called.
+            name: The name of the argument whose value is being inferred.
+            context: Inference context object
+        """
+        if name in self.duplicated_keywords:
+            raise InferenceError(
+                "The arguments passed to {func!r} " " have duplicate keywords.",
+                call_site=self,
+                func=funcnode,
+                arg=name,
+                context=context,
+            )
+
+        # Look into the keywords first, maybe it's already there.
+        try:
+            return self.keyword_arguments[name].infer(context)
+        except KeyError:
+            pass
+
+        # Too many arguments given and no variable arguments.
+        if len(self.positional_arguments) > len(funcnode.args.args):
+            if not funcnode.args.vararg and not funcnode.args.posonlyargs:
+                raise InferenceError(
+                    "Too many positional arguments "
+                    "passed to {func!r} that does "
+                    "not have *args.",
+                    call_site=self,
+                    func=funcnode,
+                    arg=name,
+                    context=context,
+                )
+
+        positional = self.positional_arguments[: len(funcnode.args.args)]
+        vararg = self.positional_arguments[len(funcnode.args.args) :]
+        argindex = funcnode.args.find_argname(name)[0]
+        kwonlyargs = {arg.name for arg in funcnode.args.kwonlyargs}
+        kwargs = {
+            key: value
+            for key, value in self.keyword_arguments.items()
+            if key not in kwonlyargs
+        }
+        # If there are too few positionals compared to
+        # what the function expects to receive, check to see
+        # if the missing positional arguments were passed
+        # as keyword arguments and if so, place them into the
+        # positional args list.
+        if len(positional) < len(funcnode.args.args):
+            for func_arg in funcnode.args.args:
+                if func_arg.name in kwargs:
+                    arg = kwargs.pop(func_arg.name)
+                    positional.append(arg)
+
+        if argindex is not None:
+            boundnode = getattr(context, "boundnode", None)
+            # 2. first argument of instance/class method
+            if argindex == 0 and funcnode.type in {"method", "classmethod"}:
+                # context.boundnode is None when an instance method is called with
+                # the class, e.g. MyClass.method(obj, ...). In this case, self
+                # is the first argument.
+                if boundnode is None and funcnode.type == "method" and positional:
+                    return positional[0].infer(context=context)
+                if boundnode is None:
+                    # XXX can do better ?
+                    boundnode = funcnode.parent.frame(future=True)
+
+                if isinstance(boundnode, nodes.ClassDef):
+                    # Verify that we're accessing a method
+                    # of the metaclass through a class, as in
+                    # `cls.metaclass_method`. In this case, the
+                    # first argument is always the class.
+                    method_scope = funcnode.parent.scope()
+                    if method_scope is boundnode.metaclass():
+                        return iter((boundnode,))
+
+                if funcnode.type == "method":
+                    if not isinstance(boundnode, Instance):
+                        boundnode = boundnode.instantiate_class()
+                    return iter((boundnode,))
+                if funcnode.type == "classmethod":
+                    return iter((boundnode,))
+            # if we have a method, extract one position
+            # from the index, so we'll take in account
+            # the extra parameter represented by `self` or `cls`
+            if funcnode.type in {"method", "classmethod"} and boundnode:
+                argindex -= 1
+            # 2. search arg index
+            try:
+                return self.positional_arguments[argindex].infer(context)
+            except IndexError:
+                pass
+
+        if funcnode.args.kwarg == name:
+            # It wants all the keywords that were passed into
+            # the call site.
+            if self.has_invalid_keywords():
+                raise InferenceError(
+                    "Inference failed to find values for all keyword arguments "
+                    "to {func!r}: {unpacked_kwargs!r} doesn't correspond to "
+                    "{keyword_arguments!r}.",
+                    keyword_arguments=self.keyword_arguments,
+                    unpacked_kwargs=self._unpacked_kwargs,
+                    call_site=self,
+                    func=funcnode,
+                    arg=name,
+                    context=context,
+                )
+            kwarg = nodes.Dict(
+                lineno=funcnode.args.lineno,
+                col_offset=funcnode.args.col_offset,
+                parent=funcnode.args,
+            )
+            kwarg.postinit(
+                [(nodes.const_factory(key), value) for key, value in kwargs.items()]
+            )
+            return iter((kwarg,))
+        if funcnode.args.vararg == name:
+            # It wants all the args that were passed into
+            # the call site.
+            if self.has_invalid_arguments():
+                raise InferenceError(
+                    "Inference failed to find values for all positional "
+                    "arguments to {func!r}: {unpacked_args!r} doesn't "
+                    "correspond to {positional_arguments!r}.",
+                    positional_arguments=self.positional_arguments,
+                    unpacked_args=self._unpacked_args,
+                    call_site=self,
+                    func=funcnode,
+                    arg=name,
+                    context=context,
+                )
+            args = nodes.Tuple(
+                lineno=funcnode.args.lineno,
+                col_offset=funcnode.args.col_offset,
+                parent=funcnode.args,
+            )
+            args.postinit(vararg)
+            return iter((args,))
+
+        # Check if it's a default parameter.
+        try:
+            return funcnode.args.default_value(name).infer(context)
+        except NoDefault:
+            pass
+        raise InferenceError(
+            "No value found for argument {arg} to {func!r}",
+            call_site=self,
+            func=funcnode,
+            arg=name,
+            context=context,
+        )
diff --git a/myenv/lib/python3.9/site-packages/astroid/astroid_manager.py b/myenv/lib/python3.9/site-packages/astroid/astroid_manager.py
new file mode 100644
index 0000000..da51de7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/astroid_manager.py
@@ -0,0 +1,15 @@
+"""
+This file contain the global astroid MANAGER, to prevent circular import that happened
+when the only possibility to import it was from astroid.__init__.py.
+
+This AstroidManager is a singleton/borg so it's possible to instantiate an
+AstroidManager() directly.
+"""
+
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid.manager import AstroidManager
+
+MANAGER = AstroidManager()
diff --git a/myenv/lib/python3.9/site-packages/astroid/bases.py b/myenv/lib/python3.9/site-packages/astroid/bases.py
new file mode 100644
index 0000000..5adaf51
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/bases.py
@@ -0,0 +1,577 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""This module contains base classes and functions for the nodes and some
+inference utils.
+"""
+
+import collections
+
+from astroid import decorators
+from astroid.const import PY310_PLUS
+from astroid.context import (
+    CallContext,
+    InferenceContext,
+    bind_context_to_node,
+    copy_context,
+)
+from astroid.exceptions import (
+    AstroidTypeError,
+    AttributeInferenceError,
+    InferenceError,
+    NameInferenceError,
+)
+from astroid.util import Uninferable, lazy_descriptor, lazy_import
+
+objectmodel = lazy_import("interpreter.objectmodel")
+helpers = lazy_import("helpers")
+manager = lazy_import("manager")
+
+
+# TODO: check if needs special treatment
+BOOL_SPECIAL_METHOD = "__bool__"
+BUILTINS = "builtins"  # TODO Remove in 2.8
+
+PROPERTIES = {"builtins.property", "abc.abstractproperty"}
+if PY310_PLUS:
+    PROPERTIES.add("enum.property")
+
+# List of possible property names. We use this list in order
+# to see if a method is a property or not. This should be
+# pretty reliable and fast, the alternative being to check each
+# decorator to see if its a real property-like descriptor, which
+# can be too complicated.
+# Also, these aren't qualified, because each project can
+# define them, we shouldn't expect to know every possible
+# property-like decorator!
+POSSIBLE_PROPERTIES = {
+    "cached_property",
+    "cachedproperty",
+    "lazyproperty",
+    "lazy_property",
+    "reify",
+    "lazyattribute",
+    "lazy_attribute",
+    "LazyProperty",
+    "lazy",
+    "cache_readonly",
+    "DynamicClassAttribute",
+}
+
+
+def _is_property(meth, context=None):
+    decoratornames = meth.decoratornames(context=context)
+    if PROPERTIES.intersection(decoratornames):
+        return True
+    stripped = {
+        name.split(".")[-1] for name in decoratornames if name is not Uninferable
+    }
+    if any(name in stripped for name in POSSIBLE_PROPERTIES):
+        return True
+
+    # Lookup for subclasses of *property*
+    if not meth.decorators:
+        return False
+    for decorator in meth.decorators.nodes or ():
+        inferred = helpers.safe_infer(decorator, context=context)
+        if inferred is None or inferred is Uninferable:
+            continue
+        if inferred.__class__.__name__ == "ClassDef":
+            for base_class in inferred.bases:
+                if base_class.__class__.__name__ != "Name":
+                    continue
+                module, _ = base_class.lookup(base_class.name)
+                if module.name == "builtins" and base_class.name == "property":
+                    return True
+
+    return False
+
+
+class Proxy:
+    """a simple proxy object
+
+    Note:
+
+    Subclasses of this object will need a custom __getattr__
+    if new instance attributes are created. See the Const class
+    """
+
+    _proxied = None  # proxied object may be set by class or by instance
+
+    def __init__(self, proxied=None):
+        if proxied is not None:
+            self._proxied = proxied
+
+    def __getattr__(self, name):
+        if name == "_proxied":
+            return self.__class__._proxied
+        if name in self.__dict__:
+            return self.__dict__[name]
+        return getattr(self._proxied, name)
+
+    def infer(self, context=None):
+        yield self
+
+
+def _infer_stmts(stmts, context, frame=None):
+    """Return an iterator on statements inferred by each statement in *stmts*."""
+    inferred = False
+    if context is not None:
+        name = context.lookupname
+        context = context.clone()
+    else:
+        name = None
+        context = InferenceContext()
+
+    for stmt in stmts:
+        if stmt is Uninferable:
+            yield stmt
+            inferred = True
+            continue
+        context.lookupname = stmt._infer_name(frame, name)
+        try:
+            for inf in stmt.infer(context=context):
+                yield inf
+                inferred = True
+        except NameInferenceError:
+            continue
+        except InferenceError:
+            yield Uninferable
+            inferred = True
+    if not inferred:
+        raise InferenceError(
+            "Inference failed for all members of {stmts!r}.",
+            stmts=stmts,
+            frame=frame,
+            context=context,
+        )
+
+
+def _infer_method_result_truth(instance, method_name, context):
+    # Get the method from the instance and try to infer
+    # its return's truth value.
+    meth = next(instance.igetattr(method_name, context=context), None)
+    if meth and hasattr(meth, "infer_call_result"):
+        if not meth.callable():
+            return Uninferable
+        try:
+            context.callcontext = CallContext(args=[], callee=meth)
+            for value in meth.infer_call_result(instance, context=context):
+                if value is Uninferable:
+                    return value
+                try:
+                    inferred = next(value.infer(context=context))
+                except StopIteration as e:
+                    raise InferenceError(context=context) from e
+                return inferred.bool_value()
+        except InferenceError:
+            pass
+    return Uninferable
+
+
+class BaseInstance(Proxy):
+    """An instance base class, which provides lookup methods for potential instances."""
+
+    special_attributes = None
+
+    def display_type(self):
+        return "Instance of"
+
+    def getattr(self, name, context=None, lookupclass=True):
+        try:
+            values = self._proxied.instance_attr(name, context)
+        except AttributeInferenceError as exc:
+            if self.special_attributes and name in self.special_attributes:
+                return [self.special_attributes.lookup(name)]
+
+            if lookupclass:
+                # Class attributes not available through the instance
+                # unless they are explicitly defined.
+                return self._proxied.getattr(name, context, class_context=False)
+
+            raise AttributeInferenceError(
+                target=self, attribute=name, context=context
+            ) from exc
+        # since we've no context information, return matching class members as
+        # well
+        if lookupclass:
+            try:
+                return values + self._proxied.getattr(
+                    name, context, class_context=False
+                )
+            except AttributeInferenceError:
+                pass
+        return values
+
+    def igetattr(self, name, context=None):
+        """inferred getattr"""
+        if not context:
+            context = InferenceContext()
+        try:
+            context.lookupname = name
+            # avoid recursively inferring the same attr on the same class
+            if context.push(self._proxied):
+                raise InferenceError(
+                    message="Cannot infer the same attribute again",
+                    node=self,
+                    context=context,
+                )
+
+            # XXX frame should be self._proxied, or not ?
+            get_attr = self.getattr(name, context, lookupclass=False)
+            yield from _infer_stmts(
+                self._wrap_attr(get_attr, context), context, frame=self
+            )
+        except AttributeInferenceError:
+            try:
+                # fallback to class.igetattr since it has some logic to handle
+                # descriptors
+                # But only if the _proxied is the Class.
+                if self._proxied.__class__.__name__ != "ClassDef":
+                    raise
+                attrs = self._proxied.igetattr(name, context, class_context=False)
+                yield from self._wrap_attr(attrs, context)
+            except AttributeInferenceError as error:
+                raise InferenceError(**vars(error)) from error
+
+    def _wrap_attr(self, attrs, context=None):
+        """wrap bound methods of attrs in a InstanceMethod proxies"""
+        for attr in attrs:
+            if isinstance(attr, UnboundMethod):
+                if _is_property(attr):
+                    yield from attr.infer_call_result(self, context)
+                else:
+                    yield BoundMethod(attr, self)
+            elif hasattr(attr, "name") and attr.name == "<lambda>":
+                if attr.args.arguments and attr.args.arguments[0].name == "self":
+                    yield BoundMethod(attr, self)
+                    continue
+                yield attr
+            else:
+                yield attr
+
+    def infer_call_result(self, caller, context=None):
+        """infer what a class instance is returning when called"""
+        context = bind_context_to_node(context, self)
+        inferred = False
+        for node in self._proxied.igetattr("__call__", context):
+            if node is Uninferable or not node.callable():
+                continue
+            for res in node.infer_call_result(caller, context):
+                inferred = True
+                yield res
+        if not inferred:
+            raise InferenceError(node=self, caller=caller, context=context)
+
+
+class Instance(BaseInstance):
+    """A special node representing a class instance."""
+
+    # pylint: disable=unnecessary-lambda
+    special_attributes = lazy_descriptor(lambda: objectmodel.InstanceModel())
+
+    def __repr__(self):
+        return "<Instance of {}.{} at 0x{}>".format(
+            self._proxied.root().name, self._proxied.name, id(self)
+        )
+
+    def __str__(self):
+        return f"Instance of {self._proxied.root().name}.{self._proxied.name}"
+
+    def callable(self):
+        try:
+            self._proxied.getattr("__call__", class_context=False)
+            return True
+        except AttributeInferenceError:
+            return False
+
+    def pytype(self):
+        return self._proxied.qname()
+
+    def display_type(self):
+        return "Instance of"
+
+    def bool_value(self, context=None):
+        """Infer the truth value for an Instance
+
+        The truth value of an instance is determined by these conditions:
+
+           * if it implements __bool__ on Python 3 or __nonzero__
+             on Python 2, then its bool value will be determined by
+             calling this special method and checking its result.
+           * when this method is not defined, __len__() is called, if it
+             is defined, and the object is considered true if its result is
+             nonzero. If a class defines neither __len__() nor __bool__(),
+             all its instances are considered true.
+        """
+        context = context or InferenceContext()
+        context.boundnode = self
+
+        try:
+            result = _infer_method_result_truth(self, BOOL_SPECIAL_METHOD, context)
+        except (InferenceError, AttributeInferenceError):
+            # Fallback to __len__.
+            try:
+                result = _infer_method_result_truth(self, "__len__", context)
+            except (AttributeInferenceError, InferenceError):
+                return True
+        return result
+
+    def getitem(self, index, context=None):
+        # TODO: Rewrap index to Const for this case
+        new_context = bind_context_to_node(context, self)
+        if not context:
+            context = new_context
+        method = next(self.igetattr("__getitem__", context=context), None)
+        # Create a new CallContext for providing index as an argument.
+        new_context.callcontext = CallContext(args=[index], callee=method)
+        if not isinstance(method, BoundMethod):
+            raise InferenceError(
+                "Could not find __getitem__ for {node!r}.", node=self, context=context
+            )
+        if len(method.args.arguments) != 2:  # (self, index)
+            raise AstroidTypeError(
+                "__getitem__ for {node!r} does not have correct signature",
+                node=self,
+                context=context,
+            )
+        return next(method.infer_call_result(self, new_context), None)
+
+
+class UnboundMethod(Proxy):
+    """a special node representing a method not bound to an instance"""
+
+    # pylint: disable=unnecessary-lambda
+    special_attributes = lazy_descriptor(lambda: objectmodel.UnboundMethodModel())
+
+    def __repr__(self):
+        frame = self._proxied.parent.frame(future=True)
+        return "<{} {} of {} at 0x{}".format(
+            self.__class__.__name__, self._proxied.name, frame.qname(), id(self)
+        )
+
+    def implicit_parameters(self):
+        return 0
+
+    def is_bound(self):
+        return False
+
+    def getattr(self, name, context=None):
+        if name in self.special_attributes:
+            return [self.special_attributes.lookup(name)]
+        return self._proxied.getattr(name, context)
+
+    def igetattr(self, name, context=None):
+        if name in self.special_attributes:
+            return iter((self.special_attributes.lookup(name),))
+        return self._proxied.igetattr(name, context)
+
+    def infer_call_result(self, caller, context):
+        """
+        The boundnode of the regular context with a function called
+        on ``object.__new__`` will be of type ``object``,
+        which is incorrect for the argument in general.
+        If no context is given the ``object.__new__`` call argument will
+        correctly inferred except when inside a call that requires
+        the additional context (such as a classmethod) of the boundnode
+        to determine which class the method was called from
+        """
+
+        # If we're unbound method __new__ of builtin object, the result is an
+        # instance of the class given as first argument.
+        if (
+            self._proxied.name == "__new__"
+            and self._proxied.parent.frame(future=True).qname() == "builtins.object"
+        ):
+            if caller.args:
+                node_context = context.extra_context.get(caller.args[0])
+                infer = caller.args[0].infer(context=node_context)
+            else:
+                infer = []
+            return (Instance(x) if x is not Uninferable else x for x in infer)
+        return self._proxied.infer_call_result(caller, context)
+
+    def bool_value(self, context=None):
+        return True
+
+
+class BoundMethod(UnboundMethod):
+    """a special node representing a method bound to an instance"""
+
+    # pylint: disable=unnecessary-lambda
+    special_attributes = lazy_descriptor(lambda: objectmodel.BoundMethodModel())
+
+    def __init__(self, proxy, bound):
+        super().__init__(proxy)
+        self.bound = bound
+
+    def implicit_parameters(self):
+        if self.name == "__new__":
+            # __new__ acts as a classmethod but the class argument is not implicit.
+            return 0
+        return 1
+
+    def is_bound(self):
+        return True
+
+    def _infer_type_new_call(self, caller, context):
+        """Try to infer what type.__new__(mcs, name, bases, attrs) returns.
+
+        In order for such call to be valid, the metaclass needs to be
+        a subtype of ``type``, the name needs to be a string, the bases
+        needs to be a tuple of classes
+        """
+        # pylint: disable=import-outside-toplevel; circular import
+        from astroid.nodes import Pass
+
+        # Verify the metaclass
+        try:
+            mcs = next(caller.args[0].infer(context=context))
+        except StopIteration as e:
+            raise InferenceError(context=context) from e
+        if mcs.__class__.__name__ != "ClassDef":
+            # Not a valid first argument.
+            return None
+        if not mcs.is_subtype_of("builtins.type"):
+            # Not a valid metaclass.
+            return None
+
+        # Verify the name
+        try:
+            name = next(caller.args[1].infer(context=context))
+        except StopIteration as e:
+            raise InferenceError(context=context) from e
+        if name.__class__.__name__ != "Const":
+            # Not a valid name, needs to be a const.
+            return None
+        if not isinstance(name.value, str):
+            # Needs to be a string.
+            return None
+
+        # Verify the bases
+        try:
+            bases = next(caller.args[2].infer(context=context))
+        except StopIteration as e:
+            raise InferenceError(context=context) from e
+        if bases.__class__.__name__ != "Tuple":
+            # Needs to be a tuple.
+            return None
+        try:
+            inferred_bases = [next(elt.infer(context=context)) for elt in bases.elts]
+        except StopIteration as e:
+            raise InferenceError(context=context) from e
+        if any(base.__class__.__name__ != "ClassDef" for base in inferred_bases):
+            # All the bases needs to be Classes
+            return None
+
+        # Verify the attributes.
+        try:
+            attrs = next(caller.args[3].infer(context=context))
+        except StopIteration as e:
+            raise InferenceError(context=context) from e
+        if attrs.__class__.__name__ != "Dict":
+            # Needs to be a dictionary.
+            return None
+        cls_locals = collections.defaultdict(list)
+        for key, value in attrs.items:
+            try:
+                key = next(key.infer(context=context))
+            except StopIteration as e:
+                raise InferenceError(context=context) from e
+            try:
+                value = next(value.infer(context=context))
+            except StopIteration as e:
+                raise InferenceError(context=context) from e
+            # Ignore non string keys
+            if key.__class__.__name__ == "Const" and isinstance(key.value, str):
+                cls_locals[key.value].append(value)
+
+        # Build the class from now.
+        cls = mcs.__class__(
+            name=name.value,
+            lineno=caller.lineno,
+            col_offset=caller.col_offset,
+            parent=caller,
+        )
+        empty = Pass()
+        cls.postinit(
+            bases=bases.elts,
+            body=[empty],
+            decorators=[],
+            newstyle=True,
+            metaclass=mcs,
+            keywords=[],
+        )
+        cls.locals = cls_locals
+        return cls
+
+    def infer_call_result(self, caller, context=None):
+        context = bind_context_to_node(context, self.bound)
+        if (
+            self.bound.__class__.__name__ == "ClassDef"
+            and self.bound.name == "type"
+            and self.name == "__new__"
+            and len(caller.args) == 4
+        ):
+            # Check if we have a ``type.__new__(mcs, name, bases, attrs)`` call.
+            new_cls = self._infer_type_new_call(caller, context)
+            if new_cls:
+                return iter((new_cls,))
+
+        return super().infer_call_result(caller, context)
+
+    def bool_value(self, context=None):
+        return True
+
+
+class Generator(BaseInstance):
+    """a special node representing a generator.
+
+    Proxied class is set once for all in raw_building.
+    """
+
+    special_attributes = lazy_descriptor(objectmodel.GeneratorModel)
+
+    def __init__(self, parent=None, generator_initial_context=None):
+        super().__init__()
+        self.parent = parent
+        self._call_context = copy_context(generator_initial_context)
+
+    @decorators.cached
+    def infer_yield_types(self):
+        yield from self.parent.infer_yield_result(self._call_context)
+
+    def callable(self):
+        return False
+
+    def pytype(self):
+        return "builtins.generator"
+
+    def display_type(self):
+        return "Generator"
+
+    def bool_value(self, context=None):
+        return True
+
+    def __repr__(self):
+        return f"<Generator({self._proxied.name}) l.{self.lineno} at 0x{id(self)}>"
+
+    def __str__(self):
+        return f"Generator({self._proxied.name})"
+
+
+class AsyncGenerator(Generator):
+    """Special node representing an async generator"""
+
+    def pytype(self):
+        return "builtins.async_generator"
+
+    def display_type(self):
+        return "AsyncGenerator"
+
+    def __repr__(self):
+        return f"<AsyncGenerator({self._proxied.name}) l.{self.lineno} at 0x{id(self)}>"
+
+    def __str__(self):
+        return f"AsyncGenerator({self._proxied.name})"
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/__init__.py b/myenv/lib/python3.9/site-packages/astroid/brain/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_argparse.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_argparse.py
new file mode 100644
index 0000000..ea97179
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_argparse.py
@@ -0,0 +1,41 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid import arguments, inference_tip, nodes
+from astroid.exceptions import UseInferenceDefault
+from astroid.manager import AstroidManager
+
+
+def infer_namespace(node, context=None):
+    callsite = arguments.CallSite.from_call(node, context=context)
+    if not callsite.keyword_arguments:
+        # Cannot make sense of it.
+        raise UseInferenceDefault()
+
+    class_node = nodes.ClassDef("Namespace")
+    # Set parent manually until ClassDef constructor fixed:
+    # https://github.com/PyCQA/astroid/issues/1490
+    class_node.parent = node.parent
+    for attr in set(callsite.keyword_arguments):
+        fake_node = nodes.EmptyNode()
+        fake_node.parent = class_node
+        fake_node.attrname = attr
+        class_node.instance_attrs[attr] = [fake_node]
+    return iter((class_node.instantiate_class(),))
+
+
+def _looks_like_namespace(node):
+    func = node.func
+    if isinstance(func, nodes.Attribute):
+        return (
+            func.attrname == "Namespace"
+            and isinstance(func.expr, nodes.Name)
+            and func.expr.name == "argparse"
+        )
+    return False
+
+
+AstroidManager().register_transform(
+    nodes.Call, inference_tip(infer_namespace), _looks_like_namespace
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_attrs.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_attrs.py
new file mode 100644
index 0000000..32b8ce0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_attrs.py
@@ -0,0 +1,84 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""
+Astroid hook for the attrs library
+
+Without this hook pylint reports unsupported-assignment-operation
+for attrs classes
+"""
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import AnnAssign, Assign, AssignName, Call, Unknown
+from astroid.nodes.scoped_nodes import ClassDef
+
+ATTRIB_NAMES = frozenset(
+    ("attr.ib", "attrib", "attr.attrib", "attr.field", "attrs.field", "field")
+)
+ATTRS_NAMES = frozenset(
+    (
+        "attr.s",
+        "attrs",
+        "attr.attrs",
+        "attr.attributes",
+        "attr.define",
+        "attr.mutable",
+        "attr.frozen",
+        "attrs.define",
+        "attrs.mutable",
+        "attrs.frozen",
+    )
+)
+
+
+def is_decorated_with_attrs(node, decorator_names=ATTRS_NAMES):
+    """Return True if a decorated node has
+    an attr decorator applied."""
+    if not node.decorators:
+        return False
+    for decorator_attribute in node.decorators.nodes:
+        if isinstance(decorator_attribute, Call):  # decorator with arguments
+            decorator_attribute = decorator_attribute.func
+        if decorator_attribute.as_string() in decorator_names:
+            return True
+    return False
+
+
+def attr_attributes_transform(node: ClassDef) -> None:
+    """Given that the ClassNode has an attr decorator,
+    rewrite class attributes as instance attributes
+    """
+    # Astroid can't infer this attribute properly
+    # Prevents https://github.com/PyCQA/pylint/issues/1884
+    node.locals["__attrs_attrs__"] = [Unknown(parent=node)]
+
+    for cdef_body_node in node.body:
+        if not isinstance(cdef_body_node, (Assign, AnnAssign)):
+            continue
+        if isinstance(cdef_body_node.value, Call):
+            if cdef_body_node.value.func.as_string() not in ATTRIB_NAMES:
+                continue
+        else:
+            continue
+        targets = (
+            cdef_body_node.targets
+            if hasattr(cdef_body_node, "targets")
+            else [cdef_body_node.target]
+        )
+        for target in targets:
+            rhs_node = Unknown(
+                lineno=cdef_body_node.lineno,
+                col_offset=cdef_body_node.col_offset,
+                parent=cdef_body_node,
+            )
+            if isinstance(target, AssignName):
+                # Could be a subscript if the code analysed is
+                # i = Optional[str] = ""
+                # See https://github.com/PyCQA/pylint/issues/4439
+                node.locals[target.name] = [rhs_node]
+                node.instance_attrs[target.name] = [rhs_node]
+
+
+AstroidManager().register_transform(
+    ClassDef, attr_attributes_transform, is_decorated_with_attrs
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_boto3.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_boto3.py
new file mode 100644
index 0000000..54faa64
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_boto3.py
@@ -0,0 +1,30 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for understanding boto3.ServiceRequest()"""
+from astroid import extract_node
+from astroid.manager import AstroidManager
+from astroid.nodes.scoped_nodes import ClassDef
+
+BOTO_SERVICE_FACTORY_QUALIFIED_NAME = "boto3.resources.base.ServiceResource"
+
+
+def service_request_transform(node):
+    """Transform ServiceResource to look like dynamic classes"""
+    code = """
+    def __getattr__(self, attr):
+        return 0
+    """
+    func_getattr = extract_node(code)
+    node.locals["__getattr__"] = [func_getattr]
+    return node
+
+
+def _looks_like_boto3_service_request(node):
+    return node.qname() == BOTO_SERVICE_FACTORY_QUALIFIED_NAME
+
+
+AstroidManager().register_transform(
+    ClassDef, service_request_transform, _looks_like_boto3_service_request
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_builtin_inference.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_builtin_inference.py
new file mode 100644
index 0000000..5d7040a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_builtin_inference.py
@@ -0,0 +1,922 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for various builtins."""
+
+from functools import partial
+from typing import Optional
+
+from astroid import arguments, helpers, inference_tip, nodes, objects, util
+from astroid.builder import AstroidBuilder
+from astroid.context import InferenceContext
+from astroid.exceptions import (
+    AstroidTypeError,
+    AttributeInferenceError,
+    InferenceError,
+    MroError,
+    UseInferenceDefault,
+)
+from astroid.manager import AstroidManager
+from astroid.nodes import scoped_nodes
+
+OBJECT_DUNDER_NEW = "object.__new__"
+
+STR_CLASS = """
+class whatever(object):
+    def join(self, iterable):
+        return {rvalue}
+    def replace(self, old, new, count=None):
+        return {rvalue}
+    def format(self, *args, **kwargs):
+        return {rvalue}
+    def encode(self, encoding='ascii', errors=None):
+        return b''
+    def decode(self, encoding='ascii', errors=None):
+        return u''
+    def capitalize(self):
+        return {rvalue}
+    def title(self):
+        return {rvalue}
+    def lower(self):
+        return {rvalue}
+    def upper(self):
+        return {rvalue}
+    def swapcase(self):
+        return {rvalue}
+    def index(self, sub, start=None, end=None):
+        return 0
+    def find(self, sub, start=None, end=None):
+        return 0
+    def count(self, sub, start=None, end=None):
+        return 0
+    def strip(self, chars=None):
+        return {rvalue}
+    def lstrip(self, chars=None):
+        return {rvalue}
+    def rstrip(self, chars=None):
+        return {rvalue}
+    def rjust(self, width, fillchar=None):
+        return {rvalue}
+    def center(self, width, fillchar=None):
+        return {rvalue}
+    def ljust(self, width, fillchar=None):
+        return {rvalue}
+"""
+
+
+BYTES_CLASS = """
+class whatever(object):
+    def join(self, iterable):
+        return {rvalue}
+    def replace(self, old, new, count=None):
+        return {rvalue}
+    def decode(self, encoding='ascii', errors=None):
+        return u''
+    def capitalize(self):
+        return {rvalue}
+    def title(self):
+        return {rvalue}
+    def lower(self):
+        return {rvalue}
+    def upper(self):
+        return {rvalue}
+    def swapcase(self):
+        return {rvalue}
+    def index(self, sub, start=None, end=None):
+        return 0
+    def find(self, sub, start=None, end=None):
+        return 0
+    def count(self, sub, start=None, end=None):
+        return 0
+    def strip(self, chars=None):
+        return {rvalue}
+    def lstrip(self, chars=None):
+        return {rvalue}
+    def rstrip(self, chars=None):
+        return {rvalue}
+    def rjust(self, width, fillchar=None):
+        return {rvalue}
+    def center(self, width, fillchar=None):
+        return {rvalue}
+    def ljust(self, width, fillchar=None):
+        return {rvalue}
+"""
+
+
+def _extend_string_class(class_node, code, rvalue):
+    """function to extend builtin str/unicode class"""
+    code = code.format(rvalue=rvalue)
+    fake = AstroidBuilder(AstroidManager()).string_build(code)["whatever"]
+    for method in fake.mymethods():
+        method.parent = class_node
+        method.lineno = None
+        method.col_offset = None
+        if "__class__" in method.locals:
+            method.locals["__class__"] = [class_node]
+        class_node.locals[method.name] = [method]
+        method.parent = class_node
+
+
+def _extend_builtins(class_transforms):
+    builtin_ast = AstroidManager().builtins_module
+    for class_name, transform in class_transforms.items():
+        transform(builtin_ast[class_name])
+
+
+_extend_builtins(
+    {
+        "bytes": partial(_extend_string_class, code=BYTES_CLASS, rvalue="b''"),
+        "str": partial(_extend_string_class, code=STR_CLASS, rvalue="''"),
+    }
+)
+
+
+def _builtin_filter_predicate(node, builtin_name):
+    if (
+        builtin_name == "type"
+        and node.root().name == "re"
+        and isinstance(node.func, nodes.Name)
+        and node.func.name == "type"
+        and isinstance(node.parent, nodes.Assign)
+        and len(node.parent.targets) == 1
+        and isinstance(node.parent.targets[0], nodes.AssignName)
+        and node.parent.targets[0].name in {"Pattern", "Match"}
+    ):
+        # Handle re.Pattern and re.Match in brain_re
+        # Match these patterns from stdlib/re.py
+        # ```py
+        # Pattern = type(...)
+        # Match = type(...)
+        # ```
+        return False
+    if isinstance(node.func, nodes.Name) and node.func.name == builtin_name:
+        return True
+    if isinstance(node.func, nodes.Attribute):
+        return (
+            node.func.attrname == "fromkeys"
+            and isinstance(node.func.expr, nodes.Name)
+            and node.func.expr.name == "dict"
+        )
+    return False
+
+
+def register_builtin_transform(transform, builtin_name):
+    """Register a new transform function for the given *builtin_name*.
+
+    The transform function must accept two parameters, a node and
+    an optional context.
+    """
+
+    def _transform_wrapper(node, context=None):
+        result = transform(node, context=context)
+        if result:
+            if not result.parent:
+                # Let the transformation function determine
+                # the parent for its result. Otherwise,
+                # we set it to be the node we transformed from.
+                result.parent = node
+
+            if result.lineno is None:
+                result.lineno = node.lineno
+            # Can be a 'Module' see https://github.com/PyCQA/pylint/issues/4671
+            # We don't have a regression test on this one: tread carefully
+            if hasattr(result, "col_offset") and result.col_offset is None:
+                result.col_offset = node.col_offset
+        return iter([result])
+
+    AstroidManager().register_transform(
+        nodes.Call,
+        inference_tip(_transform_wrapper),
+        partial(_builtin_filter_predicate, builtin_name=builtin_name),
+    )
+
+
+def _container_generic_inference(node, context, node_type, transform):
+    args = node.args
+    if not args:
+        return node_type()
+    if len(node.args) > 1:
+        raise UseInferenceDefault()
+
+    (arg,) = args
+    transformed = transform(arg)
+    if not transformed:
+        try:
+            inferred = next(arg.infer(context=context))
+        except (InferenceError, StopIteration) as exc:
+            raise UseInferenceDefault from exc
+        if inferred is util.Uninferable:
+            raise UseInferenceDefault
+        transformed = transform(inferred)
+    if not transformed or transformed is util.Uninferable:
+        raise UseInferenceDefault
+    return transformed
+
+
+def _container_generic_transform(  # pylint: disable=inconsistent-return-statements
+    arg, context, klass, iterables, build_elts
+):
+    if isinstance(arg, klass):
+        return arg
+    if isinstance(arg, iterables):
+        if all(isinstance(elt, nodes.Const) for elt in arg.elts):
+            elts = [elt.value for elt in arg.elts]
+        else:
+            # TODO: Does not handle deduplication for sets.
+            elts = []
+            for element in arg.elts:
+                if not element:
+                    continue
+                inferred = helpers.safe_infer(element, context=context)
+                if inferred:
+                    evaluated_object = nodes.EvaluatedObject(
+                        original=element, value=inferred
+                    )
+                    elts.append(evaluated_object)
+    elif isinstance(arg, nodes.Dict):
+        # Dicts need to have consts as strings already.
+        if not all(isinstance(elt[0], nodes.Const) for elt in arg.items):
+            raise UseInferenceDefault()
+        elts = [item[0].value for item in arg.items]
+    elif isinstance(arg, nodes.Const) and isinstance(arg.value, (str, bytes)):
+        elts = arg.value
+    else:
+        return
+    return klass.from_elements(elts=build_elts(elts))
+
+
+def _infer_builtin_container(
+    node, context, klass=None, iterables=None, build_elts=None
+):
+    transform_func = partial(
+        _container_generic_transform,
+        context=context,
+        klass=klass,
+        iterables=iterables,
+        build_elts=build_elts,
+    )
+
+    return _container_generic_inference(node, context, klass, transform_func)
+
+
+# pylint: disable=invalid-name
+infer_tuple = partial(
+    _infer_builtin_container,
+    klass=nodes.Tuple,
+    iterables=(
+        nodes.List,
+        nodes.Set,
+        objects.FrozenSet,
+        objects.DictItems,
+        objects.DictKeys,
+        objects.DictValues,
+    ),
+    build_elts=tuple,
+)
+
+infer_list = partial(
+    _infer_builtin_container,
+    klass=nodes.List,
+    iterables=(
+        nodes.Tuple,
+        nodes.Set,
+        objects.FrozenSet,
+        objects.DictItems,
+        objects.DictKeys,
+        objects.DictValues,
+    ),
+    build_elts=list,
+)
+
+infer_set = partial(
+    _infer_builtin_container,
+    klass=nodes.Set,
+    iterables=(nodes.List, nodes.Tuple, objects.FrozenSet, objects.DictKeys),
+    build_elts=set,
+)
+
+infer_frozenset = partial(
+    _infer_builtin_container,
+    klass=objects.FrozenSet,
+    iterables=(nodes.List, nodes.Tuple, nodes.Set, objects.FrozenSet, objects.DictKeys),
+    build_elts=frozenset,
+)
+
+
+def _get_elts(arg, context):
+    def is_iterable(n):
+        return isinstance(n, (nodes.List, nodes.Tuple, nodes.Set))
+
+    try:
+        inferred = next(arg.infer(context))
+    except (InferenceError, StopIteration) as exc:
+        raise UseInferenceDefault from exc
+    if isinstance(inferred, nodes.Dict):
+        items = inferred.items
+    elif is_iterable(inferred):
+        items = []
+        for elt in inferred.elts:
+            # If an item is not a pair of two items,
+            # then fallback to the default inference.
+            # Also, take in consideration only hashable items,
+            # tuples and consts. We are choosing Names as well.
+            if not is_iterable(elt):
+                raise UseInferenceDefault()
+            if len(elt.elts) != 2:
+                raise UseInferenceDefault()
+            if not isinstance(elt.elts[0], (nodes.Tuple, nodes.Const, nodes.Name)):
+                raise UseInferenceDefault()
+            items.append(tuple(elt.elts))
+    else:
+        raise UseInferenceDefault()
+    return items
+
+
+def infer_dict(node, context=None):
+    """Try to infer a dict call to a Dict node.
+
+    The function treats the following cases:
+
+        * dict()
+        * dict(mapping)
+        * dict(iterable)
+        * dict(iterable, **kwargs)
+        * dict(mapping, **kwargs)
+        * dict(**kwargs)
+
+    If a case can't be inferred, we'll fallback to default inference.
+    """
+    call = arguments.CallSite.from_call(node, context=context)
+    if call.has_invalid_arguments() or call.has_invalid_keywords():
+        raise UseInferenceDefault
+
+    args = call.positional_arguments
+    kwargs = list(call.keyword_arguments.items())
+
+    if not args and not kwargs:
+        # dict()
+        return nodes.Dict()
+    if kwargs and not args:
+        # dict(a=1, b=2, c=4)
+        items = [(nodes.Const(key), value) for key, value in kwargs]
+    elif len(args) == 1 and kwargs:
+        # dict(some_iterable, b=2, c=4)
+        elts = _get_elts(args[0], context)
+        keys = [(nodes.Const(key), value) for key, value in kwargs]
+        items = elts + keys
+    elif len(args) == 1:
+        items = _get_elts(args[0], context)
+    else:
+        raise UseInferenceDefault()
+    value = nodes.Dict(
+        col_offset=node.col_offset, lineno=node.lineno, parent=node.parent
+    )
+    value.postinit(items)
+    return value
+
+
+def infer_super(node, context=None):
+    """Understand super calls.
+
+    There are some restrictions for what can be understood:
+
+        * unbounded super (one argument form) is not understood.
+
+        * if the super call is not inside a function (classmethod or method),
+          then the default inference will be used.
+
+        * if the super arguments can't be inferred, the default inference
+          will be used.
+    """
+    if len(node.args) == 1:
+        # Ignore unbounded super.
+        raise UseInferenceDefault
+
+    scope = node.scope()
+    if not isinstance(scope, nodes.FunctionDef):
+        # Ignore non-method uses of super.
+        raise UseInferenceDefault
+    if scope.type not in ("classmethod", "method"):
+        # Not interested in staticmethods.
+        raise UseInferenceDefault
+
+    cls = scoped_nodes.get_wrapping_class(scope)
+    if not node.args:
+        mro_pointer = cls
+        # In we are in a classmethod, the interpreter will fill
+        # automatically the class as the second argument, not an instance.
+        if scope.type == "classmethod":
+            mro_type = cls
+        else:
+            mro_type = cls.instantiate_class()
+    else:
+        try:
+            mro_pointer = next(node.args[0].infer(context=context))
+        except (InferenceError, StopIteration) as exc:
+            raise UseInferenceDefault from exc
+        try:
+            mro_type = next(node.args[1].infer(context=context))
+        except (InferenceError, StopIteration) as exc:
+            raise UseInferenceDefault from exc
+
+    if mro_pointer is util.Uninferable or mro_type is util.Uninferable:
+        # No way we could understand this.
+        raise UseInferenceDefault
+
+    super_obj = objects.Super(
+        mro_pointer=mro_pointer, mro_type=mro_type, self_class=cls, scope=scope
+    )
+    super_obj.parent = node
+    return super_obj
+
+
+def _infer_getattr_args(node, context):
+    if len(node.args) not in (2, 3):
+        # Not a valid getattr call.
+        raise UseInferenceDefault
+
+    try:
+        obj = next(node.args[0].infer(context=context))
+        attr = next(node.args[1].infer(context=context))
+    except (InferenceError, StopIteration) as exc:
+        raise UseInferenceDefault from exc
+
+    if obj is util.Uninferable or attr is util.Uninferable:
+        # If one of the arguments is something we can't infer,
+        # then also make the result of the getattr call something
+        # which is unknown.
+        return util.Uninferable, util.Uninferable
+
+    is_string = isinstance(attr, nodes.Const) and isinstance(attr.value, str)
+    if not is_string:
+        raise UseInferenceDefault
+
+    return obj, attr.value
+
+
+def infer_getattr(node, context=None):
+    """Understand getattr calls
+
+    If one of the arguments is an Uninferable object, then the
+    result will be an Uninferable object. Otherwise, the normal attribute
+    lookup will be done.
+    """
+    obj, attr = _infer_getattr_args(node, context)
+    if (
+        obj is util.Uninferable
+        or attr is util.Uninferable
+        or not hasattr(obj, "igetattr")
+    ):
+        return util.Uninferable
+
+    try:
+        return next(obj.igetattr(attr, context=context))
+    except (StopIteration, InferenceError, AttributeInferenceError):
+        if len(node.args) == 3:
+            # Try to infer the default and return it instead.
+            try:
+                return next(node.args[2].infer(context=context))
+            except (StopIteration, InferenceError) as exc:
+                raise UseInferenceDefault from exc
+
+    raise UseInferenceDefault
+
+
+def infer_hasattr(node, context=None):
+    """Understand hasattr calls
+
+    This always guarantees three possible outcomes for calling
+    hasattr: Const(False) when we are sure that the object
+    doesn't have the intended attribute, Const(True) when
+    we know that the object has the attribute and Uninferable
+    when we are unsure of the outcome of the function call.
+    """
+    try:
+        obj, attr = _infer_getattr_args(node, context)
+        if (
+            obj is util.Uninferable
+            or attr is util.Uninferable
+            or not hasattr(obj, "getattr")
+        ):
+            return util.Uninferable
+        obj.getattr(attr, context=context)
+    except UseInferenceDefault:
+        # Can't infer something from this function call.
+        return util.Uninferable
+    except AttributeInferenceError:
+        # Doesn't have it.
+        return nodes.Const(False)
+    return nodes.Const(True)
+
+
+def infer_callable(node, context=None):
+    """Understand callable calls
+
+    This follows Python's semantics, where an object
+    is callable if it provides an attribute __call__,
+    even though that attribute is something which can't be
+    called.
+    """
+    if len(node.args) != 1:
+        # Invalid callable call.
+        raise UseInferenceDefault
+
+    argument = node.args[0]
+    try:
+        inferred = next(argument.infer(context=context))
+    except (InferenceError, StopIteration):
+        return util.Uninferable
+    if inferred is util.Uninferable:
+        return util.Uninferable
+    return nodes.Const(inferred.callable())
+
+
+def infer_property(
+    node: nodes.Call, context: Optional[InferenceContext] = None
+) -> objects.Property:
+    """Understand `property` class
+
+    This only infers the output of `property`
+    call, not the arguments themselves.
+    """
+    if len(node.args) < 1:
+        # Invalid property call.
+        raise UseInferenceDefault
+
+    getter = node.args[0]
+    try:
+        inferred = next(getter.infer(context=context))
+    except (InferenceError, StopIteration) as exc:
+        raise UseInferenceDefault from exc
+
+    if not isinstance(inferred, (nodes.FunctionDef, nodes.Lambda)):
+        raise UseInferenceDefault
+
+    prop_func = objects.Property(
+        function=inferred,
+        name=inferred.name,
+        lineno=node.lineno,
+        parent=node,
+        col_offset=node.col_offset,
+    )
+    prop_func.postinit(
+        body=[],
+        args=inferred.args,
+        doc_node=getattr(inferred, "doc_node", None),
+    )
+    return prop_func
+
+
+def infer_bool(node, context=None):
+    """Understand bool calls."""
+    if len(node.args) > 1:
+        # Invalid bool call.
+        raise UseInferenceDefault
+
+    if not node.args:
+        return nodes.Const(False)
+
+    argument = node.args[0]
+    try:
+        inferred = next(argument.infer(context=context))
+    except (InferenceError, StopIteration):
+        return util.Uninferable
+    if inferred is util.Uninferable:
+        return util.Uninferable
+
+    bool_value = inferred.bool_value(context=context)
+    if bool_value is util.Uninferable:
+        return util.Uninferable
+    return nodes.Const(bool_value)
+
+
+def infer_type(node, context=None):
+    """Understand the one-argument form of *type*."""
+    if len(node.args) != 1:
+        raise UseInferenceDefault
+
+    return helpers.object_type(node.args[0], context)
+
+
+def infer_slice(node, context=None):
+    """Understand `slice` calls."""
+    args = node.args
+    if not 0 < len(args) <= 3:
+        raise UseInferenceDefault
+
+    infer_func = partial(helpers.safe_infer, context=context)
+    args = [infer_func(arg) for arg in args]
+    for arg in args:
+        if not arg or arg is util.Uninferable:
+            raise UseInferenceDefault
+        if not isinstance(arg, nodes.Const):
+            raise UseInferenceDefault
+        if not isinstance(arg.value, (type(None), int)):
+            raise UseInferenceDefault
+
+    if len(args) < 3:
+        # Make sure we have 3 arguments.
+        args.extend([None] * (3 - len(args)))
+
+    slice_node = nodes.Slice(
+        lineno=node.lineno, col_offset=node.col_offset, parent=node.parent
+    )
+    slice_node.postinit(*args)
+    return slice_node
+
+
+def _infer_object__new__decorator(node, context=None):
+    # Instantiate class immediately
+    # since that's what @object.__new__ does
+    return iter((node.instantiate_class(),))
+
+
+def _infer_object__new__decorator_check(node):
+    """Predicate before inference_tip
+
+    Check if the given ClassDef has an @object.__new__ decorator
+    """
+    if not node.decorators:
+        return False
+
+    for decorator in node.decorators.nodes:
+        if isinstance(decorator, nodes.Attribute):
+            if decorator.as_string() == OBJECT_DUNDER_NEW:
+                return True
+    return False
+
+
+def infer_issubclass(callnode, context=None):
+    """Infer issubclass() calls
+
+    :param nodes.Call callnode: an `issubclass` call
+    :param InferenceContext context: the context for the inference
+    :rtype nodes.Const: Boolean Const value of the `issubclass` call
+    :raises UseInferenceDefault: If the node cannot be inferred
+    """
+    call = arguments.CallSite.from_call(callnode, context=context)
+    if call.keyword_arguments:
+        # issubclass doesn't support keyword arguments
+        raise UseInferenceDefault("TypeError: issubclass() takes no keyword arguments")
+    if len(call.positional_arguments) != 2:
+        raise UseInferenceDefault(
+            f"Expected two arguments, got {len(call.positional_arguments)}"
+        )
+    # The left hand argument is the obj to be checked
+    obj_node, class_or_tuple_node = call.positional_arguments
+
+    try:
+        obj_type = next(obj_node.infer(context=context))
+    except (InferenceError, StopIteration) as exc:
+        raise UseInferenceDefault from exc
+    if not isinstance(obj_type, nodes.ClassDef):
+        raise UseInferenceDefault("TypeError: arg 1 must be class")
+
+    # The right hand argument is the class(es) that the given
+    # object is to be checked against.
+    try:
+        class_container = _class_or_tuple_to_container(
+            class_or_tuple_node, context=context
+        )
+    except InferenceError as exc:
+        raise UseInferenceDefault from exc
+    try:
+        issubclass_bool = helpers.object_issubclass(obj_type, class_container, context)
+    except AstroidTypeError as exc:
+        raise UseInferenceDefault("TypeError: " + str(exc)) from exc
+    except MroError as exc:
+        raise UseInferenceDefault from exc
+    return nodes.Const(issubclass_bool)
+
+
+def infer_isinstance(callnode, context=None):
+    """Infer isinstance calls
+
+    :param nodes.Call callnode: an isinstance call
+    :param InferenceContext context: context for call
+        (currently unused but is a common interface for inference)
+    :rtype nodes.Const: Boolean Const value of isinstance call
+
+    :raises UseInferenceDefault: If the node cannot be inferred
+    """
+    call = arguments.CallSite.from_call(callnode, context=context)
+    if call.keyword_arguments:
+        # isinstance doesn't support keyword arguments
+        raise UseInferenceDefault("TypeError: isinstance() takes no keyword arguments")
+    if len(call.positional_arguments) != 2:
+        raise UseInferenceDefault(
+            f"Expected two arguments, got {len(call.positional_arguments)}"
+        )
+    # The left hand argument is the obj to be checked
+    obj_node, class_or_tuple_node = call.positional_arguments
+    # The right hand argument is the class(es) that the given
+    # obj is to be check is an instance of
+    try:
+        class_container = _class_or_tuple_to_container(
+            class_or_tuple_node, context=context
+        )
+    except InferenceError as exc:
+        raise UseInferenceDefault from exc
+    try:
+        isinstance_bool = helpers.object_isinstance(obj_node, class_container, context)
+    except AstroidTypeError as exc:
+        raise UseInferenceDefault("TypeError: " + str(exc)) from exc
+    except MroError as exc:
+        raise UseInferenceDefault from exc
+    if isinstance_bool is util.Uninferable:
+        raise UseInferenceDefault
+    return nodes.Const(isinstance_bool)
+
+
+def _class_or_tuple_to_container(node, context=None):
+    # Move inferences results into container
+    # to simplify later logic
+    # raises InferenceError if any of the inferences fall through
+    try:
+        node_infer = next(node.infer(context=context))
+    except StopIteration as e:
+        raise InferenceError(node=node, context=context) from e
+    # arg2 MUST be a type or a TUPLE of types
+    # for isinstance
+    if isinstance(node_infer, nodes.Tuple):
+        try:
+            class_container = [
+                next(node.infer(context=context)) for node in node_infer.elts
+            ]
+        except StopIteration as e:
+            raise InferenceError(node=node, context=context) from e
+        class_container = [
+            klass_node for klass_node in class_container if klass_node is not None
+        ]
+    else:
+        class_container = [node_infer]
+    return class_container
+
+
+def infer_len(node, context=None):
+    """Infer length calls
+
+    :param nodes.Call node: len call to infer
+    :param context.InferenceContext: node context
+    :rtype nodes.Const: a Const node with the inferred length, if possible
+    """
+    call = arguments.CallSite.from_call(node, context=context)
+    if call.keyword_arguments:
+        raise UseInferenceDefault("TypeError: len() must take no keyword arguments")
+    if len(call.positional_arguments) != 1:
+        raise UseInferenceDefault(
+            "TypeError: len() must take exactly one argument "
+            "({len}) given".format(len=len(call.positional_arguments))
+        )
+    [argument_node] = call.positional_arguments
+
+    try:
+        return nodes.Const(helpers.object_len(argument_node, context=context))
+    except (AstroidTypeError, InferenceError) as exc:
+        raise UseInferenceDefault(str(exc)) from exc
+
+
+def infer_str(node, context=None):
+    """Infer str() calls
+
+    :param nodes.Call node: str() call to infer
+    :param context.InferenceContext: node context
+    :rtype nodes.Const: a Const containing an empty string
+    """
+    call = arguments.CallSite.from_call(node, context=context)
+    if call.keyword_arguments:
+        raise UseInferenceDefault("TypeError: str() must take no keyword arguments")
+    try:
+        return nodes.Const("")
+    except (AstroidTypeError, InferenceError) as exc:
+        raise UseInferenceDefault(str(exc)) from exc
+
+
+def infer_int(node, context=None):
+    """Infer int() calls
+
+    :param nodes.Call node: int() call to infer
+    :param context.InferenceContext: node context
+    :rtype nodes.Const: a Const containing the integer value of the int() call
+    """
+    call = arguments.CallSite.from_call(node, context=context)
+    if call.keyword_arguments:
+        raise UseInferenceDefault("TypeError: int() must take no keyword arguments")
+
+    if call.positional_arguments:
+        try:
+            first_value = next(call.positional_arguments[0].infer(context=context))
+        except (InferenceError, StopIteration) as exc:
+            raise UseInferenceDefault(str(exc)) from exc
+
+        if first_value is util.Uninferable:
+            raise UseInferenceDefault
+
+        if isinstance(first_value, nodes.Const) and isinstance(
+            first_value.value, (int, str)
+        ):
+            try:
+                actual_value = int(first_value.value)
+            except ValueError:
+                return nodes.Const(0)
+            return nodes.Const(actual_value)
+
+    return nodes.Const(0)
+
+
+def infer_dict_fromkeys(node, context=None):
+    """Infer dict.fromkeys
+
+    :param nodes.Call node: dict.fromkeys() call to infer
+    :param context.InferenceContext context: node context
+    :rtype nodes.Dict:
+        a Dictionary containing the values that astroid was able to infer.
+        In case the inference failed for any reason, an empty dictionary
+        will be inferred instead.
+    """
+
+    def _build_dict_with_elements(elements):
+        new_node = nodes.Dict(
+            col_offset=node.col_offset, lineno=node.lineno, parent=node.parent
+        )
+        new_node.postinit(elements)
+        return new_node
+
+    call = arguments.CallSite.from_call(node, context=context)
+    if call.keyword_arguments:
+        raise UseInferenceDefault("TypeError: int() must take no keyword arguments")
+    if len(call.positional_arguments) not in {1, 2}:
+        raise UseInferenceDefault(
+            "TypeError: Needs between 1 and 2 positional arguments"
+        )
+
+    default = nodes.Const(None)
+    values = call.positional_arguments[0]
+    try:
+        inferred_values = next(values.infer(context=context))
+    except (InferenceError, StopIteration):
+        return _build_dict_with_elements([])
+    if inferred_values is util.Uninferable:
+        return _build_dict_with_elements([])
+
+    # Limit to a couple of potential values, as this can become pretty complicated
+    accepted_iterable_elements = (nodes.Const,)
+    if isinstance(inferred_values, (nodes.List, nodes.Set, nodes.Tuple)):
+        elements = inferred_values.elts
+        for element in elements:
+            if not isinstance(element, accepted_iterable_elements):
+                # Fallback to an empty dict
+                return _build_dict_with_elements([])
+
+        elements_with_value = [(element, default) for element in elements]
+        return _build_dict_with_elements(elements_with_value)
+    if isinstance(inferred_values, nodes.Const) and isinstance(
+        inferred_values.value, (str, bytes)
+    ):
+        elements = [
+            (nodes.Const(element), default) for element in inferred_values.value
+        ]
+        return _build_dict_with_elements(elements)
+    if isinstance(inferred_values, nodes.Dict):
+        keys = inferred_values.itered()
+        for key in keys:
+            if not isinstance(key, accepted_iterable_elements):
+                # Fallback to an empty dict
+                return _build_dict_with_elements([])
+
+        elements_with_value = [(element, default) for element in keys]
+        return _build_dict_with_elements(elements_with_value)
+
+    # Fallback to an empty dictionary
+    return _build_dict_with_elements([])
+
+
+# Builtins inference
+register_builtin_transform(infer_bool, "bool")
+register_builtin_transform(infer_super, "super")
+register_builtin_transform(infer_callable, "callable")
+register_builtin_transform(infer_property, "property")
+register_builtin_transform(infer_getattr, "getattr")
+register_builtin_transform(infer_hasattr, "hasattr")
+register_builtin_transform(infer_tuple, "tuple")
+register_builtin_transform(infer_set, "set")
+register_builtin_transform(infer_list, "list")
+register_builtin_transform(infer_dict, "dict")
+register_builtin_transform(infer_frozenset, "frozenset")
+register_builtin_transform(infer_type, "type")
+register_builtin_transform(infer_slice, "slice")
+register_builtin_transform(infer_isinstance, "isinstance")
+register_builtin_transform(infer_issubclass, "issubclass")
+register_builtin_transform(infer_len, "len")
+register_builtin_transform(infer_str, "str")
+register_builtin_transform(infer_int, "int")
+register_builtin_transform(infer_dict_fromkeys, "dict.fromkeys")
+
+
+# Infer object.__new__ calls
+AstroidManager().register_transform(
+    nodes.ClassDef,
+    inference_tip(_infer_object__new__decorator),
+    _infer_object__new__decorator_check,
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_collections.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_collections.py
new file mode 100644
index 0000000..43304ec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_collections.py
@@ -0,0 +1,123 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import extract_node, parse
+from astroid.const import PY39_PLUS
+from astroid.exceptions import AttributeInferenceError
+from astroid.manager import AstroidManager
+from astroid.nodes.scoped_nodes import ClassDef
+
+
+def _collections_transform():
+    return parse(
+        """
+    class defaultdict(dict):
+        default_factory = None
+        def __missing__(self, key): pass
+        def __getitem__(self, key): return default_factory
+
+    """
+        + _deque_mock()
+        + _ordered_dict_mock()
+    )
+
+
+def _deque_mock():
+    base_deque_class = """
+    class deque(object):
+        maxlen = 0
+        def __init__(self, iterable=None, maxlen=None):
+            self.iterable = iterable or []
+        def append(self, x): pass
+        def appendleft(self, x): pass
+        def clear(self): pass
+        def count(self, x): return 0
+        def extend(self, iterable): pass
+        def extendleft(self, iterable): pass
+        def pop(self): return self.iterable[0]
+        def popleft(self): return self.iterable[0]
+        def remove(self, value): pass
+        def reverse(self): return reversed(self.iterable)
+        def rotate(self, n=1): return self
+        def __iter__(self): return self
+        def __reversed__(self): return self.iterable[::-1]
+        def __getitem__(self, index): return self.iterable[index]
+        def __setitem__(self, index, value): pass
+        def __delitem__(self, index): pass
+        def __bool__(self): return bool(self.iterable)
+        def __nonzero__(self): return bool(self.iterable)
+        def __contains__(self, o): return o in self.iterable
+        def __len__(self): return len(self.iterable)
+        def __copy__(self): return deque(self.iterable)
+        def copy(self): return deque(self.iterable)
+        def index(self, x, start=0, end=0): return 0
+        def insert(self, i, x): pass
+        def __add__(self, other): pass
+        def __iadd__(self, other): pass
+        def __mul__(self, other): pass
+        def __imul__(self, other): pass
+        def __rmul__(self, other): pass"""
+    if PY39_PLUS:
+        base_deque_class += """
+        @classmethod
+        def __class_getitem__(self, item): return cls"""
+    return base_deque_class
+
+
+def _ordered_dict_mock():
+    base_ordered_dict_class = """
+    class OrderedDict(dict):
+        def __reversed__(self): return self[::-1]
+        def move_to_end(self, key, last=False): pass"""
+    if PY39_PLUS:
+        base_ordered_dict_class += """
+        @classmethod
+        def __class_getitem__(cls, item): return cls"""
+    return base_ordered_dict_class
+
+
+register_module_extender(AstroidManager(), "collections", _collections_transform)
+
+
+def _looks_like_subscriptable(node: ClassDef) -> bool:
+    """
+    Returns True if the node corresponds to a ClassDef of the Collections.abc module that
+    supports subscripting
+
+    :param node: ClassDef node
+    """
+    if node.qname().startswith("_collections") or node.qname().startswith(
+        "collections"
+    ):
+        try:
+            node.getattr("__class_getitem__")
+            return True
+        except AttributeInferenceError:
+            pass
+    return False
+
+
+CLASS_GET_ITEM_TEMPLATE = """
+@classmethod
+def __class_getitem__(cls, item):
+    return cls
+"""
+
+
+def easy_class_getitem_inference(node, context=None):
+    # Here __class_getitem__ exists but is quite a mess to infer thus
+    # put an easy inference tip
+    func_to_add = extract_node(CLASS_GET_ITEM_TEMPLATE)
+    node.locals["__class_getitem__"] = [func_to_add]
+
+
+if PY39_PLUS:
+    # Starting with Python39 some objects of the collection module are subscriptable
+    # thanks to the __class_getitem__ method but the way it is implemented in
+    # _collection_abc makes it difficult to infer. (We would have to handle AssignName inference in the
+    # getitem method of the ClassDef class) Instead we put here a mock of the __class_getitem__ method
+    AstroidManager().register_transform(
+        ClassDef, easy_class_getitem_inference, _looks_like_subscriptable
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_crypt.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_crypt.py
new file mode 100644
index 0000000..45c3055
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_crypt.py
@@ -0,0 +1,28 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.const import PY37_PLUS
+from astroid.manager import AstroidManager
+
+if PY37_PLUS:
+    # Since Python 3.7 Hashing Methods are added
+    # dynamically to globals()
+
+    def _re_transform():
+        return parse(
+            """
+        from collections import namedtuple
+        _Method = namedtuple('_Method', 'name ident salt_chars total_size')
+
+        METHOD_SHA512 = _Method('SHA512', '6', 16, 106)
+        METHOD_SHA256 = _Method('SHA256', '5', 16, 63)
+        METHOD_BLOWFISH = _Method('BLOWFISH', 2, 'b', 22)
+        METHOD_MD5 = _Method('MD5', '1', 8, 34)
+        METHOD_CRYPT = _Method('CRYPT', None, 2, 13)
+        """
+        )
+
+    register_module_extender(AstroidManager(), "crypt", _re_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_ctypes.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_ctypes.py
new file mode 100644
index 0000000..323b19c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_ctypes.py
@@ -0,0 +1,82 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""
+Astroid hooks for ctypes module.
+
+Inside the ctypes module, the value class is defined inside
+the C coded module _ctypes.
+Thus astroid doesn't know that the value member is a builtin type
+among float, int, bytes or str.
+"""
+import sys
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def enrich_ctypes_redefined_types():
+    """
+    For each ctypes redefined types, overload 'value' and '_type_' members definition.
+    Overloading 'value' is mandatory otherwise astroid cannot infer the correct type for it.
+    Overloading '_type_' is necessary because the class definition made here replaces the original
+    one, in which '_type_' member is defined. Luckily those original class definitions are very short
+    and contain only the '_type_' member definition.
+    """
+    c_class_to_type = (
+        ("c_byte", "int", "b"),
+        ("c_char", "bytes", "c"),
+        ("c_double", "float", "d"),
+        ("c_float", "float", "f"),
+        ("c_int", "int", "i"),
+        ("c_int16", "int", "h"),
+        ("c_int32", "int", "i"),
+        ("c_int64", "int", "l"),
+        ("c_int8", "int", "b"),
+        ("c_long", "int", "l"),
+        ("c_longdouble", "float", "g"),
+        ("c_longlong", "int", "l"),
+        ("c_short", "int", "h"),
+        ("c_size_t", "int", "L"),
+        ("c_ssize_t", "int", "l"),
+        ("c_ubyte", "int", "B"),
+        ("c_uint", "int", "I"),
+        ("c_uint16", "int", "H"),
+        ("c_uint32", "int", "I"),
+        ("c_uint64", "int", "L"),
+        ("c_uint8", "int", "B"),
+        ("c_ulong", "int", "L"),
+        ("c_ulonglong", "int", "L"),
+        ("c_ushort", "int", "H"),
+        ("c_wchar", "str", "u"),
+    )
+
+    src = [
+        """
+from _ctypes import _SimpleCData
+
+class c_bool(_SimpleCData):
+    def __init__(self, value):
+        self.value = True
+        self._type_ = '?'
+    """
+    ]
+
+    for c_type, builtin_type, type_code in c_class_to_type:
+        src.append(
+            f"""
+class {c_type}(_SimpleCData):
+    def __init__(self, value):
+        self.value = {builtin_type}(value)
+        self._type_ = '{type_code}'
+        """
+        )
+
+    return parse("\n".join(src))
+
+
+if not hasattr(sys, "pypy_version_info"):
+    # No need of this module in pypy where everything is written in python
+    register_module_extender(AstroidManager(), "ctypes", enrich_ctypes_redefined_types)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_curses.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_curses.py
new file mode 100644
index 0000000..66cd5b2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_curses.py
@@ -0,0 +1,183 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def _curses_transform():
+    return parse(
+        """
+    A_ALTCHARSET = 1
+    A_BLINK = 1
+    A_BOLD = 1
+    A_DIM = 1
+    A_INVIS = 1
+    A_ITALIC = 1
+    A_NORMAL = 1
+    A_PROTECT = 1
+    A_REVERSE = 1
+    A_STANDOUT = 1
+    A_UNDERLINE = 1
+    A_HORIZONTAL = 1
+    A_LEFT = 1
+    A_LOW = 1
+    A_RIGHT = 1
+    A_TOP = 1
+    A_VERTICAL = 1
+    A_CHARTEXT = 1
+    A_ATTRIBUTES = 1
+    A_CHARTEXT = 1
+    A_COLOR = 1
+    KEY_MIN = 1
+    KEY_BREAK = 1
+    KEY_DOWN = 1
+    KEY_UP = 1
+    KEY_LEFT = 1
+    KEY_RIGHT = 1
+    KEY_HOME = 1
+    KEY_BACKSPACE = 1
+    KEY_F0 = 1
+    KEY_Fn = 1
+    KEY_DL = 1
+    KEY_IL = 1
+    KEY_DC = 1
+    KEY_IC = 1
+    KEY_EIC = 1
+    KEY_CLEAR = 1
+    KEY_EOS = 1
+    KEY_EOL = 1
+    KEY_SF = 1
+    KEY_SR = 1
+    KEY_NPAGE = 1
+    KEY_PPAGE = 1
+    KEY_STAB = 1
+    KEY_CTAB = 1
+    KEY_CATAB = 1
+    KEY_ENTER = 1
+    KEY_SRESET = 1
+    KEY_RESET = 1
+    KEY_PRINT = 1
+    KEY_LL = 1
+    KEY_A1 = 1
+    KEY_A3 = 1
+    KEY_B2 = 1
+    KEY_C1 = 1
+    KEY_C3 = 1
+    KEY_BTAB = 1
+    KEY_BEG = 1
+    KEY_CANCEL = 1
+    KEY_CLOSE = 1
+    KEY_COMMAND = 1
+    KEY_COPY = 1
+    KEY_CREATE = 1
+    KEY_END = 1
+    KEY_EXIT = 1
+    KEY_FIND = 1
+    KEY_HELP = 1
+    KEY_MARK = 1
+    KEY_MESSAGE = 1
+    KEY_MOVE = 1
+    KEY_NEXT = 1
+    KEY_OPEN = 1
+    KEY_OPTIONS = 1
+    KEY_PREVIOUS = 1
+    KEY_REDO = 1
+    KEY_REFERENCE = 1
+    KEY_REFRESH = 1
+    KEY_REPLACE = 1
+    KEY_RESTART = 1
+    KEY_RESUME = 1
+    KEY_SAVE = 1
+    KEY_SBEG = 1
+    KEY_SCANCEL = 1
+    KEY_SCOMMAND = 1
+    KEY_SCOPY = 1
+    KEY_SCREATE = 1
+    KEY_SDC = 1
+    KEY_SDL = 1
+    KEY_SELECT = 1
+    KEY_SEND = 1
+    KEY_SEOL = 1
+    KEY_SEXIT = 1
+    KEY_SFIND = 1
+    KEY_SHELP = 1
+    KEY_SHOME = 1
+    KEY_SIC = 1
+    KEY_SLEFT = 1
+    KEY_SMESSAGE = 1
+    KEY_SMOVE = 1
+    KEY_SNEXT = 1
+    KEY_SOPTIONS = 1
+    KEY_SPREVIOUS = 1
+    KEY_SPRINT = 1
+    KEY_SREDO = 1
+    KEY_SREPLACE = 1
+    KEY_SRIGHT = 1
+    KEY_SRSUME = 1
+    KEY_SSAVE = 1
+    KEY_SSUSPEND = 1
+    KEY_SUNDO = 1
+    KEY_SUSPEND = 1
+    KEY_UNDO = 1
+    KEY_MOUSE = 1
+    KEY_RESIZE = 1
+    KEY_MAX = 1
+    ACS_BBSS = 1
+    ACS_BLOCK = 1
+    ACS_BOARD = 1
+    ACS_BSBS = 1
+    ACS_BSSB = 1
+    ACS_BSSS = 1
+    ACS_BTEE = 1
+    ACS_BULLET = 1
+    ACS_CKBOARD = 1
+    ACS_DARROW = 1
+    ACS_DEGREE = 1
+    ACS_DIAMOND = 1
+    ACS_GEQUAL = 1
+    ACS_HLINE = 1
+    ACS_LANTERN = 1
+    ACS_LARROW = 1
+    ACS_LEQUAL = 1
+    ACS_LLCORNER = 1
+    ACS_LRCORNER = 1
+    ACS_LTEE = 1
+    ACS_NEQUAL = 1
+    ACS_PI = 1
+    ACS_PLMINUS = 1
+    ACS_PLUS = 1
+    ACS_RARROW = 1
+    ACS_RTEE = 1
+    ACS_S1 = 1
+    ACS_S3 = 1
+    ACS_S7 = 1
+    ACS_S9 = 1
+    ACS_SBBS = 1
+    ACS_SBSB = 1
+    ACS_SBSS = 1
+    ACS_SSBB = 1
+    ACS_SSBS = 1
+    ACS_SSSB = 1
+    ACS_SSSS = 1
+    ACS_STERLING = 1
+    ACS_TTEE = 1
+    ACS_UARROW = 1
+    ACS_ULCORNER = 1
+    ACS_URCORNER = 1
+    ACS_VLINE = 1
+    COLOR_BLACK = 1
+    COLOR_BLUE = 1
+    COLOR_CYAN = 1
+    COLOR_GREEN = 1
+    COLOR_MAGENTA = 1
+    COLOR_RED = 1
+    COLOR_WHITE = 1
+    COLOR_YELLOW = 1
+        """
+    )
+
+
+register_module_extender(AstroidManager(), "curses", _curses_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_dataclasses.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_dataclasses.py
new file mode 100644
index 0000000..769d9ee
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_dataclasses.py
@@ -0,0 +1,467 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""
+Astroid hook for the dataclasses library
+
+Support built-in dataclasses, pydantic.dataclasses, and marshmallow_dataclass-annotated
+dataclasses. References:
+- https://docs.python.org/3/library/dataclasses.html
+- https://pydantic-docs.helpmanual.io/usage/dataclasses/
+- https://lovasoa.github.io/marshmallow_dataclass/
+
+"""
+import sys
+from typing import FrozenSet, Generator, List, Optional, Tuple, Union
+
+from astroid import context, inference_tip
+from astroid.builder import parse
+from astroid.const import PY37_PLUS, PY39_PLUS
+from astroid.exceptions import (
+    AstroidSyntaxError,
+    InferenceError,
+    MroError,
+    UseInferenceDefault,
+)
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import (
+    AnnAssign,
+    Assign,
+    AssignName,
+    Attribute,
+    Call,
+    Name,
+    NodeNG,
+    Subscript,
+    Unknown,
+)
+from astroid.nodes.scoped_nodes import ClassDef, FunctionDef
+from astroid.util import Uninferable
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+_FieldDefaultReturn = Union[
+    None, Tuple[Literal["default"], NodeNG], Tuple[Literal["default_factory"], Call]
+]
+
+DATACLASSES_DECORATORS = frozenset(("dataclass",))
+FIELD_NAME = "field"
+DATACLASS_MODULES = frozenset(
+    ("dataclasses", "marshmallow_dataclass", "pydantic.dataclasses")
+)
+DEFAULT_FACTORY = "_HAS_DEFAULT_FACTORY"  # based on typing.py
+
+
+def is_decorated_with_dataclass(node, decorator_names=DATACLASSES_DECORATORS):
+    """Return True if a decorated node has a `dataclass` decorator applied."""
+    if not isinstance(node, ClassDef) or not node.decorators:
+        return False
+
+    return any(
+        _looks_like_dataclass_decorator(decorator_attribute, decorator_names)
+        for decorator_attribute in node.decorators.nodes
+    )
+
+
+def dataclass_transform(node: ClassDef) -> None:
+    """Rewrite a dataclass to be easily understood by pylint"""
+    node.is_dataclass = True
+
+    for assign_node in _get_dataclass_attributes(node):
+        name = assign_node.target.name
+
+        rhs_node = Unknown(
+            lineno=assign_node.lineno,
+            col_offset=assign_node.col_offset,
+            parent=assign_node,
+        )
+        rhs_node = AstroidManager().visit_transforms(rhs_node)
+        node.instance_attrs[name] = [rhs_node]
+
+    if not _check_generate_dataclass_init(node):
+        return
+
+    try:
+        reversed_mro = list(reversed(node.mro()))
+    except MroError:
+        reversed_mro = [node]
+
+    field_assigns = {}
+    field_order = []
+    for klass in (k for k in reversed_mro if is_decorated_with_dataclass(k)):
+        for assign_node in _get_dataclass_attributes(klass, init=True):
+            name = assign_node.target.name
+            if name not in field_assigns:
+                field_order.append(name)
+            field_assigns[name] = assign_node
+
+    init_str = _generate_dataclass_init([field_assigns[name] for name in field_order])
+    try:
+        init_node = parse(init_str)["__init__"]
+    except AstroidSyntaxError:
+        pass
+    else:
+        init_node.parent = node
+        init_node.lineno, init_node.col_offset = None, None
+        node.locals["__init__"] = [init_node]
+
+        root = node.root()
+        if DEFAULT_FACTORY not in root.locals:
+            new_assign = parse(f"{DEFAULT_FACTORY} = object()").body[0]
+            new_assign.parent = root
+            root.locals[DEFAULT_FACTORY] = [new_assign.targets[0]]
+
+
+def _get_dataclass_attributes(node: ClassDef, init: bool = False) -> Generator:
+    """Yield the AnnAssign nodes of dataclass attributes for the node.
+
+    If init is True, also include InitVars, but exclude attributes from calls to
+    field where init=False.
+    """
+    for assign_node in node.body:
+        if not isinstance(assign_node, AnnAssign) or not isinstance(
+            assign_node.target, AssignName
+        ):
+            continue
+
+        if _is_class_var(assign_node.annotation):  # type: ignore[arg-type] # annotation is never None
+            continue
+
+        if init:
+            value = assign_node.value
+            if (
+                isinstance(value, Call)
+                and _looks_like_dataclass_field_call(value, check_scope=False)
+                and any(
+                    keyword.arg == "init"
+                    and not keyword.value.bool_value()  # type: ignore[union-attr] # value is never None
+                    for keyword in value.keywords
+                )
+            ):
+                continue
+        elif _is_init_var(assign_node.annotation):  # type: ignore[arg-type] # annotation is never None
+            continue
+
+        yield assign_node
+
+
+def _check_generate_dataclass_init(node: ClassDef) -> bool:
+    """Return True if we should generate an __init__ method for node.
+
+    This is True when:
+        - node doesn't define its own __init__ method
+        - the dataclass decorator was called *without* the keyword argument init=False
+    """
+    if "__init__" in node.locals:
+        return False
+
+    found = None
+
+    for decorator_attribute in node.decorators.nodes:
+        if not isinstance(decorator_attribute, Call):
+            continue
+
+        if _looks_like_dataclass_decorator(decorator_attribute):
+            found = decorator_attribute
+
+    if found is None:
+        return True
+
+    # Check for keyword arguments of the form init=False
+    return all(
+        keyword.arg != "init"
+        and keyword.value.bool_value()  # type: ignore[union-attr] # value is never None
+        for keyword in found.keywords
+    )
+
+
+def _generate_dataclass_init(assigns: List[AnnAssign]) -> str:
+    """Return an init method for a dataclass given the targets."""
+    target_names = []
+    params = []
+    assignments = []
+
+    for assign in assigns:
+        name, annotation, value = assign.target.name, assign.annotation, assign.value
+        target_names.append(name)
+
+        if _is_init_var(annotation):  # type: ignore[arg-type] # annotation is never None
+            init_var = True
+            if isinstance(annotation, Subscript):
+                annotation = annotation.slice
+            else:
+                # Cannot determine type annotation for parameter from InitVar
+                annotation = None
+            assignment_str = ""
+        else:
+            init_var = False
+            assignment_str = f"self.{name} = {name}"
+
+        if annotation:
+            param_str = f"{name}: {annotation.as_string()}"
+        else:
+            param_str = name
+
+        if value:
+            if isinstance(value, Call) and _looks_like_dataclass_field_call(
+                value, check_scope=False
+            ):
+                result = _get_field_default(value)
+                if result:
+                    default_type, default_node = result
+                    if default_type == "default":
+                        param_str += f" = {default_node.as_string()}"
+                    elif default_type == "default_factory":
+                        param_str += f" = {DEFAULT_FACTORY}"
+                        assignment_str = (
+                            f"self.{name} = {default_node.as_string()} "
+                            f"if {name} is {DEFAULT_FACTORY} else {name}"
+                        )
+            else:
+                param_str += f" = {value.as_string()}"
+
+        params.append(param_str)
+        if not init_var:
+            assignments.append(assignment_str)
+
+    params_string = ", ".join(["self"] + params)
+    assignments_string = "\n    ".join(assignments) if assignments else "pass"
+    return f"def __init__({params_string}) -> None:\n    {assignments_string}"
+
+
+def infer_dataclass_attribute(
+    node: Unknown, ctx: Optional[context.InferenceContext] = None
+) -> Generator:
+    """Inference tip for an Unknown node that was dynamically generated to
+    represent a dataclass attribute.
+
+    In the case that a default value is provided, that is inferred first.
+    Then, an Instance of the annotated class is yielded.
+    """
+    assign = node.parent
+    if not isinstance(assign, AnnAssign):
+        yield Uninferable
+        return
+
+    annotation, value = assign.annotation, assign.value
+    if value is not None:
+        yield from value.infer(context=ctx)
+    if annotation is not None:
+        yield from _infer_instance_from_annotation(annotation, ctx=ctx)
+    else:
+        yield Uninferable
+
+
+def infer_dataclass_field_call(
+    node: Call, ctx: Optional[context.InferenceContext] = None
+) -> Generator:
+    """Inference tip for dataclass field calls."""
+    if not isinstance(node.parent, (AnnAssign, Assign)):
+        raise UseInferenceDefault
+    result = _get_field_default(node)
+    if not result:
+        yield Uninferable
+    else:
+        default_type, default = result
+        if default_type == "default":
+            yield from default.infer(context=ctx)
+        else:
+            new_call = parse(default.as_string()).body[0].value
+            new_call.parent = node.parent
+            yield from new_call.infer(context=ctx)
+
+
+def _looks_like_dataclass_decorator(
+    node: NodeNG, decorator_names: FrozenSet[str] = DATACLASSES_DECORATORS
+) -> bool:
+    """Return True if node looks like a dataclass decorator.
+
+    Uses inference to lookup the value of the node, and if that fails,
+    matches against specific names.
+    """
+    if isinstance(node, Call):  # decorator with arguments
+        node = node.func
+    try:
+        inferred = next(node.infer())
+    except (InferenceError, StopIteration):
+        inferred = Uninferable
+
+    if inferred is Uninferable:
+        if isinstance(node, Name):
+            return node.name in decorator_names
+        if isinstance(node, Attribute):
+            return node.attrname in decorator_names
+
+        return False
+
+    return (
+        isinstance(inferred, FunctionDef)
+        and inferred.name in decorator_names
+        and inferred.root().name in DATACLASS_MODULES
+    )
+
+
+def _looks_like_dataclass_attribute(node: Unknown) -> bool:
+    """Return True if node was dynamically generated as the child of an AnnAssign
+    statement.
+    """
+    parent = node.parent
+    if not parent:
+        return False
+
+    scope = parent.scope()
+    return (
+        isinstance(parent, AnnAssign)
+        and isinstance(scope, ClassDef)
+        and is_decorated_with_dataclass(scope)
+    )
+
+
+def _looks_like_dataclass_field_call(node: Call, check_scope: bool = True) -> bool:
+    """Return True if node is calling dataclasses field or Field
+    from an AnnAssign statement directly in the body of a ClassDef.
+
+    If check_scope is False, skips checking the statement and body.
+    """
+    if check_scope:
+        stmt = node.statement(future=True)
+        scope = stmt.scope()
+        if not (
+            isinstance(stmt, AnnAssign)
+            and stmt.value is not None
+            and isinstance(scope, ClassDef)
+            and is_decorated_with_dataclass(scope)
+        ):
+            return False
+
+    try:
+        inferred = next(node.func.infer())
+    except (InferenceError, StopIteration):
+        return False
+
+    if not isinstance(inferred, FunctionDef):
+        return False
+
+    return inferred.name == FIELD_NAME and inferred.root().name in DATACLASS_MODULES
+
+
+def _get_field_default(field_call: Call) -> _FieldDefaultReturn:
+    """Return a the default value of a field call, and the corresponding keyword argument name.
+
+    field(default=...) results in the ... node
+    field(default_factory=...) results in a Call node with func ... and no arguments
+
+    If neither or both arguments are present, return ("", None) instead,
+    indicating that there is not a valid default value.
+    """
+    default, default_factory = None, None
+    for keyword in field_call.keywords:
+        if keyword.arg == "default":
+            default = keyword.value
+        elif keyword.arg == "default_factory":
+            default_factory = keyword.value
+
+    if default is not None and default_factory is None:
+        return "default", default
+
+    if default is None and default_factory is not None:
+        new_call = Call(
+            lineno=field_call.lineno,
+            col_offset=field_call.col_offset,
+            parent=field_call.parent,
+        )
+        new_call.postinit(func=default_factory)
+        return "default_factory", new_call
+
+    return None
+
+
+def _is_class_var(node: NodeNG) -> bool:
+    """Return True if node is a ClassVar, with or without subscripting."""
+    if PY39_PLUS:
+        try:
+            inferred = next(node.infer())
+        except (InferenceError, StopIteration):
+            return False
+
+        return getattr(inferred, "name", "") == "ClassVar"
+
+    # Before Python 3.9, inference returns typing._SpecialForm instead of ClassVar.
+    # Our backup is to inspect the node's structure.
+    return isinstance(node, Subscript) and (
+        isinstance(node.value, Name)
+        and node.value.name == "ClassVar"
+        or isinstance(node.value, Attribute)
+        and node.value.attrname == "ClassVar"
+    )
+
+
+def _is_init_var(node: NodeNG) -> bool:
+    """Return True if node is an InitVar, with or without subscripting."""
+    try:
+        inferred = next(node.infer())
+    except (InferenceError, StopIteration):
+        return False
+
+    return getattr(inferred, "name", "") == "InitVar"
+
+
+# Allowed typing classes for which we support inferring instances
+_INFERABLE_TYPING_TYPES = frozenset(
+    (
+        "Dict",
+        "FrozenSet",
+        "List",
+        "Set",
+        "Tuple",
+    )
+)
+
+
+def _infer_instance_from_annotation(
+    node: NodeNG, ctx: Optional[context.InferenceContext] = None
+) -> Generator:
+    """Infer an instance corresponding to the type annotation represented by node.
+
+    Currently has limited support for the typing module.
+    """
+    klass = None
+    try:
+        klass = next(node.infer(context=ctx))
+    except (InferenceError, StopIteration):
+        yield Uninferable
+    if not isinstance(klass, ClassDef):
+        yield Uninferable
+    elif klass.root().name in {
+        "typing",
+        "_collections_abc",
+        "",
+    }:  # "" because of synthetic nodes in brain_typing.py
+        if klass.name in _INFERABLE_TYPING_TYPES:
+            yield klass.instantiate_class()
+        else:
+            yield Uninferable
+    else:
+        yield klass.instantiate_class()
+
+
+if PY37_PLUS:
+    AstroidManager().register_transform(
+        ClassDef, dataclass_transform, is_decorated_with_dataclass
+    )
+
+    AstroidManager().register_transform(
+        Call,
+        inference_tip(infer_dataclass_field_call, raise_on_overwrite=True),
+        _looks_like_dataclass_field_call,
+    )
+
+    AstroidManager().register_transform(
+        Unknown,
+        inference_tip(infer_dataclass_attribute, raise_on_overwrite=True),
+        _looks_like_dataclass_attribute,
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_dateutil.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_dateutil.py
new file mode 100644
index 0000000..0d27135
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_dateutil.py
@@ -0,0 +1,26 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for dateutil"""
+
+import textwrap
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import AstroidBuilder
+from astroid.manager import AstroidManager
+
+
+def dateutil_transform():
+    return AstroidBuilder(AstroidManager()).string_build(
+        textwrap.dedent(
+            """
+    import datetime
+    def parse(timestr, parserinfo=None, **kwargs):
+        return datetime.datetime()
+    """
+        )
+    )
+
+
+register_module_extender(AstroidManager(), "dateutil.parser", dateutil_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_fstrings.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_fstrings.py
new file mode 100644
index 0000000..db7dd95
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_fstrings.py
@@ -0,0 +1,48 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+import collections.abc
+
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import FormattedValue
+
+
+def _clone_node_with_lineno(node, parent, lineno):
+    cls = node.__class__
+    other_fields = node._other_fields
+    _astroid_fields = node._astroid_fields
+    init_params = {"lineno": lineno, "col_offset": node.col_offset, "parent": parent}
+    postinit_params = {param: getattr(node, param) for param in _astroid_fields}
+    if other_fields:
+        init_params.update({param: getattr(node, param) for param in other_fields})
+    new_node = cls(**init_params)
+    if hasattr(node, "postinit") and _astroid_fields:
+        for param, child in postinit_params.items():
+            if child and not isinstance(child, collections.abc.Sequence):
+                cloned_child = _clone_node_with_lineno(
+                    node=child, lineno=new_node.lineno, parent=new_node
+                )
+                postinit_params[param] = cloned_child
+        new_node.postinit(**postinit_params)
+    return new_node
+
+
+def _transform_formatted_value(node):  # pylint: disable=inconsistent-return-statements
+    if node.value and node.value.lineno == 1:
+        if node.lineno != node.value.lineno:
+            new_node = FormattedValue(
+                lineno=node.lineno, col_offset=node.col_offset, parent=node.parent
+            )
+            new_value = _clone_node_with_lineno(
+                node=node.value, lineno=node.lineno, parent=new_node
+            )
+            new_node.postinit(value=new_value, format_spec=node.format_spec)
+            return new_node
+
+
+# TODO: this fix tries to *patch* http://bugs.python.org/issue29051
+# The problem is that FormattedValue.value, which is a Name node,
+# has wrong line numbers, usually 1. This creates problems for pylint,
+# which expects correct line numbers for things such as message control.
+AstroidManager().register_transform(FormattedValue, _transform_formatted_value)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_functools.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_functools.py
new file mode 100644
index 0000000..63333dc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_functools.py
@@ -0,0 +1,159 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for understanding functools library module."""
+from functools import partial
+from itertools import chain
+from typing import Iterator, Optional
+
+from astroid import BoundMethod, arguments, extract_node, helpers, nodes, objects
+from astroid.context import InferenceContext
+from astroid.exceptions import InferenceError, UseInferenceDefault
+from astroid.inference_tip import inference_tip
+from astroid.interpreter import objectmodel
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import AssignName, Attribute, Call, Name
+from astroid.nodes.scoped_nodes import FunctionDef
+from astroid.util import Uninferable
+
+LRU_CACHE = "functools.lru_cache"
+
+
+class LruWrappedModel(objectmodel.FunctionModel):
+    """Special attribute model for functions decorated with functools.lru_cache.
+
+    The said decorators patches at decoration time some functions onto
+    the decorated function.
+    """
+
+    @property
+    def attr___wrapped__(self):
+        return self._instance
+
+    @property
+    def attr_cache_info(self):
+        cache_info = extract_node(
+            """
+        from functools import _CacheInfo
+        _CacheInfo(0, 0, 0, 0)
+        """
+        )
+
+        class CacheInfoBoundMethod(BoundMethod):
+            def infer_call_result(self, caller, context=None):
+                yield helpers.safe_infer(cache_info)
+
+        return CacheInfoBoundMethod(proxy=self._instance, bound=self._instance)
+
+    @property
+    def attr_cache_clear(self):
+        node = extract_node("""def cache_clear(self): pass""")
+        return BoundMethod(proxy=node, bound=self._instance.parent.scope())
+
+
+def _transform_lru_cache(node, context=None) -> None:
+    # TODO: this is not ideal, since the node should be immutable,
+    # but due to https://github.com/PyCQA/astroid/issues/354,
+    # there's not much we can do now.
+    # Replacing the node would work partially, because,
+    # in pylint, the old node would still be available, leading
+    # to spurious false positives.
+    node.special_attributes = LruWrappedModel()(node)
+
+
+def _functools_partial_inference(
+    node: nodes.Call, context: Optional[InferenceContext] = None
+) -> Iterator[objects.PartialFunction]:
+    call = arguments.CallSite.from_call(node, context=context)
+    number_of_positional = len(call.positional_arguments)
+    if number_of_positional < 1:
+        raise UseInferenceDefault("functools.partial takes at least one argument")
+    if number_of_positional == 1 and not call.keyword_arguments:
+        raise UseInferenceDefault(
+            "functools.partial needs at least to have some filled arguments"
+        )
+
+    partial_function = call.positional_arguments[0]
+    try:
+        inferred_wrapped_function = next(partial_function.infer(context=context))
+    except (InferenceError, StopIteration) as exc:
+        raise UseInferenceDefault from exc
+    if inferred_wrapped_function is Uninferable:
+        raise UseInferenceDefault("Cannot infer the wrapped function")
+    if not isinstance(inferred_wrapped_function, FunctionDef):
+        raise UseInferenceDefault("The wrapped function is not a function")
+
+    # Determine if the passed keywords into the callsite are supported
+    # by the wrapped function.
+    if not inferred_wrapped_function.args:
+        function_parameters = []
+    else:
+        function_parameters = chain(
+            inferred_wrapped_function.args.args or (),
+            inferred_wrapped_function.args.posonlyargs or (),
+            inferred_wrapped_function.args.kwonlyargs or (),
+        )
+    parameter_names = {
+        param.name for param in function_parameters if isinstance(param, AssignName)
+    }
+    if set(call.keyword_arguments) - parameter_names:
+        raise UseInferenceDefault("wrapped function received unknown parameters")
+
+    partial_function = objects.PartialFunction(
+        call,
+        name=inferred_wrapped_function.name,
+        lineno=inferred_wrapped_function.lineno,
+        col_offset=inferred_wrapped_function.col_offset,
+        parent=node.parent,
+    )
+    partial_function.postinit(
+        args=inferred_wrapped_function.args,
+        body=inferred_wrapped_function.body,
+        decorators=inferred_wrapped_function.decorators,
+        returns=inferred_wrapped_function.returns,
+        type_comment_returns=inferred_wrapped_function.type_comment_returns,
+        type_comment_args=inferred_wrapped_function.type_comment_args,
+        doc_node=inferred_wrapped_function.doc_node,
+    )
+    return iter((partial_function,))
+
+
+def _looks_like_lru_cache(node):
+    """Check if the given function node is decorated with lru_cache."""
+    if not node.decorators:
+        return False
+    for decorator in node.decorators.nodes:
+        if not isinstance(decorator, Call):
+            continue
+        if _looks_like_functools_member(decorator, "lru_cache"):
+            return True
+    return False
+
+
+def _looks_like_functools_member(node, member) -> bool:
+    """Check if the given Call node is a functools.partial call"""
+    if isinstance(node.func, Name):
+        return node.func.name == member
+    if isinstance(node.func, Attribute):
+        return (
+            node.func.attrname == member
+            and isinstance(node.func.expr, Name)
+            and node.func.expr.name == "functools"
+        )
+    return False
+
+
+_looks_like_partial = partial(_looks_like_functools_member, member="partial")
+
+
+AstroidManager().register_transform(
+    FunctionDef, _transform_lru_cache, _looks_like_lru_cache
+)
+
+
+AstroidManager().register_transform(
+    Call,
+    inference_tip(_functools_partial_inference),
+    _looks_like_partial,
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_gi.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_gi.py
new file mode 100644
index 0000000..5728e2d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_gi.py
@@ -0,0 +1,250 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for the Python 2 GObject introspection bindings.
+
+Helps with understanding everything imported from 'gi.repository'
+"""
+
+# pylint:disable=import-error,import-outside-toplevel
+
+import inspect
+import itertools
+import re
+import sys
+import warnings
+
+from astroid import nodes
+from astroid.builder import AstroidBuilder
+from astroid.exceptions import AstroidBuildingError
+from astroid.manager import AstroidManager
+
+_inspected_modules = {}
+
+_identifier_re = r"^[A-Za-z_]\w*$"
+
+_special_methods = frozenset(
+    {
+        "__lt__",
+        "__le__",
+        "__eq__",
+        "__ne__",
+        "__ge__",
+        "__gt__",
+        "__iter__",
+        "__getitem__",
+        "__setitem__",
+        "__delitem__",
+        "__len__",
+        "__bool__",
+        "__nonzero__",
+        "__next__",
+        "__str__",
+        "__len__",
+        "__contains__",
+        "__enter__",
+        "__exit__",
+        "__repr__",
+        "__getattr__",
+        "__setattr__",
+        "__delattr__",
+        "__del__",
+        "__hash__",
+    }
+)
+
+
+def _gi_build_stub(parent):
+    """
+    Inspect the passed module recursively and build stubs for functions,
+    classes, etc.
+    """
+    classes = {}
+    functions = {}
+    constants = {}
+    methods = {}
+    for name in dir(parent):
+        if name.startswith("__") and name not in _special_methods:
+            continue
+
+        # Check if this is a valid name in python
+        if not re.match(_identifier_re, name):
+            continue
+
+        try:
+            obj = getattr(parent, name)
+        except Exception:  # pylint: disable=broad-except
+            # gi.module.IntrospectionModule.__getattr__() can raise all kinds of things
+            # like ValueError, TypeError, NotImplementedError, RepositoryError, etc
+            continue
+
+        if inspect.isclass(obj):
+            classes[name] = obj
+        elif inspect.isfunction(obj) or inspect.isbuiltin(obj):
+            functions[name] = obj
+        elif inspect.ismethod(obj) or inspect.ismethoddescriptor(obj):
+            methods[name] = obj
+        elif (
+            str(obj).startswith("<flags")
+            or str(obj).startswith("<enum ")
+            or str(obj).startswith("<GType ")
+            or inspect.isdatadescriptor(obj)
+        ):
+            constants[name] = 0
+        elif isinstance(obj, (int, str)):
+            constants[name] = obj
+        elif callable(obj):
+            # Fall back to a function for anything callable
+            functions[name] = obj
+        else:
+            # Assume everything else is some manner of constant
+            constants[name] = 0
+
+    ret = ""
+
+    if constants:
+        ret += f"# {parent.__name__} constants\n\n"
+    for name in sorted(constants):
+        if name[0].isdigit():
+            # GDK has some busted constant names like
+            # Gdk.EventType.2BUTTON_PRESS
+            continue
+
+        val = constants[name]
+
+        strval = str(val)
+        if isinstance(val, str):
+            strval = '"%s"' % str(val).replace("\\", "\\\\")
+        ret += f"{name} = {strval}\n"
+
+    if ret:
+        ret += "\n\n"
+    if functions:
+        ret += f"# {parent.__name__} functions\n\n"
+    for name in sorted(functions):
+        ret += f"def {name}(*args, **kwargs):\n"
+        ret += "    pass\n"
+
+    if ret:
+        ret += "\n\n"
+    if methods:
+        ret += f"# {parent.__name__} methods\n\n"
+    for name in sorted(methods):
+        ret += f"def {name}(self, *args, **kwargs):\n"
+        ret += "    pass\n"
+
+    if ret:
+        ret += "\n\n"
+    if classes:
+        ret += f"# {parent.__name__} classes\n\n"
+    for name, obj in sorted(classes.items()):
+        base = "object"
+        if issubclass(obj, Exception):
+            base = "Exception"
+        ret += f"class {name}({base}):\n"
+
+        classret = _gi_build_stub(obj)
+        if not classret:
+            classret = "pass\n"
+
+        for line in classret.splitlines():
+            ret += "    " + line + "\n"
+        ret += "\n"
+
+    return ret
+
+
+def _import_gi_module(modname):
+    # we only consider gi.repository submodules
+    if not modname.startswith("gi.repository."):
+        raise AstroidBuildingError(modname=modname)
+    # build astroid representation unless we already tried so
+    if modname not in _inspected_modules:
+        modnames = [modname]
+        optional_modnames = []
+
+        # GLib and GObject may have some special case handling
+        # in pygobject that we need to cope with. However at
+        # least as of pygobject3-3.13.91 the _glib module doesn't
+        # exist anymore, so if treat these modules as optional.
+        if modname == "gi.repository.GLib":
+            optional_modnames.append("gi._glib")
+        elif modname == "gi.repository.GObject":
+            optional_modnames.append("gi._gobject")
+
+        try:
+            modcode = ""
+            for m in itertools.chain(modnames, optional_modnames):
+                try:
+                    with warnings.catch_warnings():
+                        # Just inspecting the code can raise gi deprecation
+                        # warnings, so ignore them.
+                        try:
+                            from gi import (  # pylint:disable=import-error
+                                PyGIDeprecationWarning,
+                                PyGIWarning,
+                            )
+
+                            warnings.simplefilter("ignore", PyGIDeprecationWarning)
+                            warnings.simplefilter("ignore", PyGIWarning)
+                        except Exception:  # pylint:disable=broad-except
+                            pass
+
+                        __import__(m)
+                        modcode += _gi_build_stub(sys.modules[m])
+                except ImportError:
+                    if m not in optional_modnames:
+                        raise
+        except ImportError:
+            astng = _inspected_modules[modname] = None
+        else:
+            astng = AstroidBuilder(AstroidManager()).string_build(modcode, modname)
+            _inspected_modules[modname] = astng
+    else:
+        astng = _inspected_modules[modname]
+    if astng is None:
+        raise AstroidBuildingError(modname=modname)
+    return astng
+
+
+def _looks_like_require_version(node):
+    # Return whether this looks like a call to gi.require_version(<name>, <version>)
+    # Only accept function calls with two constant arguments
+    if len(node.args) != 2:
+        return False
+
+    if not all(isinstance(arg, nodes.Const) for arg in node.args):
+        return False
+
+    func = node.func
+    if isinstance(func, nodes.Attribute):
+        if func.attrname != "require_version":
+            return False
+        if isinstance(func.expr, nodes.Name) and func.expr.name == "gi":
+            return True
+
+        return False
+
+    if isinstance(func, nodes.Name):
+        return func.name == "require_version"
+
+    return False
+
+
+def _register_require_version(node):
+    # Load the gi.require_version locally
+    try:
+        import gi
+
+        gi.require_version(node.args[0].value, node.args[1].value)
+    except Exception:  # pylint:disable=broad-except
+        pass
+
+    return node
+
+
+AstroidManager().register_failed_import_hook(_import_gi_module)
+AstroidManager().register_transform(
+    nodes.Call, _register_require_version, _looks_like_require_version
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_hashlib.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_hashlib.py
new file mode 100644
index 0000000..b628361
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_hashlib.py
@@ -0,0 +1,58 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.const import PY39_PLUS
+from astroid.manager import AstroidManager
+
+
+def _hashlib_transform():
+    maybe_usedforsecurity = ", usedforsecurity=True" if PY39_PLUS else ""
+    signature = f"value=''{maybe_usedforsecurity}"
+    template = """
+    class %(name)s(object):
+      def __init__(self, %(signature)s): pass
+      def digest(self):
+        return %(digest)s
+      def copy(self):
+        return self
+      def update(self, value): pass
+      def hexdigest(self):
+        return ''
+      @property
+      def name(self):
+        return %(name)r
+      @property
+      def block_size(self):
+        return 1
+      @property
+      def digest_size(self):
+        return 1
+    """
+    algorithms_with_signature = dict.fromkeys(
+        ["md5", "sha1", "sha224", "sha256", "sha384", "sha512"], signature
+    )
+    blake2b_signature = f"data=b'', *, digest_size=64, key=b'', salt=b'', \
+            person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, \
+            node_depth=0, inner_size=0, last_node=False{maybe_usedforsecurity}"
+    blake2s_signature = f"data=b'', *, digest_size=32, key=b'', salt=b'', \
+            person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, \
+            node_depth=0, inner_size=0, last_node=False{maybe_usedforsecurity}"
+    new_algorithms = dict.fromkeys(
+        ["sha3_224", "sha3_256", "sha3_384", "sha3_512", "shake_128", "shake_256"],
+        signature,
+    )
+    algorithms_with_signature.update(new_algorithms)
+    algorithms_with_signature.update(
+        {"blake2b": blake2b_signature, "blake2s": blake2s_signature}
+    )
+    classes = "".join(
+        template % {"name": hashfunc, "digest": 'b""', "signature": signature}
+        for hashfunc, signature in algorithms_with_signature.items()
+    )
+    return parse(classes)
+
+
+register_module_extender(AstroidManager(), "hashlib", _hashlib_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_http.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_http.py
new file mode 100644
index 0000000..acf07bd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_http.py
@@ -0,0 +1,211 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid brain hints for some of the `http` module."""
+import textwrap
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import AstroidBuilder
+from astroid.manager import AstroidManager
+
+
+def _http_transform():
+    code = textwrap.dedent(
+        """
+    from collections import namedtuple
+    _HTTPStatus = namedtuple('_HTTPStatus', 'value phrase description')
+
+    class HTTPStatus:
+
+        @property
+        def phrase(self):
+            return ""
+        @property
+        def value(self):
+            return 0
+        @property
+        def description(self):
+            return ""
+
+        # informational
+        CONTINUE = _HTTPStatus(100, 'Continue', 'Request received, please continue')
+        SWITCHING_PROTOCOLS = _HTTPStatus(101, 'Switching Protocols',
+                'Switching to new protocol; obey Upgrade header')
+        PROCESSING = _HTTPStatus(102, 'Processing', '')
+        OK = _HTTPStatus(200, 'OK', 'Request fulfilled, document follows')
+        CREATED = _HTTPStatus(201, 'Created', 'Document created, URL follows')
+        ACCEPTED = _HTTPStatus(202, 'Accepted',
+            'Request accepted, processing continues off-line')
+        NON_AUTHORITATIVE_INFORMATION = _HTTPStatus(203,
+            'Non-Authoritative Information', 'Request fulfilled from cache')
+        NO_CONTENT = _HTTPStatus(204, 'No Content', 'Request fulfilled, nothing follows')
+        RESET_CONTENT =_HTTPStatus(205, 'Reset Content', 'Clear input form for further input')
+        PARTIAL_CONTENT = _HTTPStatus(206, 'Partial Content', 'Partial content follows')
+        MULTI_STATUS = _HTTPStatus(207, 'Multi-Status', '')
+        ALREADY_REPORTED = _HTTPStatus(208, 'Already Reported', '')
+        IM_USED = _HTTPStatus(226, 'IM Used', '')
+        MULTIPLE_CHOICES = _HTTPStatus(300, 'Multiple Choices',
+            'Object has several resources -- see URI list')
+        MOVED_PERMANENTLY = _HTTPStatus(301, 'Moved Permanently',
+            'Object moved permanently -- see URI list')
+        FOUND = _HTTPStatus(302, 'Found', 'Object moved temporarily -- see URI list')
+        SEE_OTHER = _HTTPStatus(303, 'See Other', 'Object moved -- see Method and URL list')
+        NOT_MODIFIED = _HTTPStatus(304, 'Not Modified',
+            'Document has not changed since given time')
+        USE_PROXY = _HTTPStatus(305, 'Use Proxy',
+            'You must use proxy specified in Location to access this resource')
+        TEMPORARY_REDIRECT = _HTTPStatus(307, 'Temporary Redirect',
+            'Object moved temporarily -- see URI list')
+        PERMANENT_REDIRECT = _HTTPStatus(308, 'Permanent Redirect',
+            'Object moved permanently -- see URI list')
+        BAD_REQUEST = _HTTPStatus(400, 'Bad Request',
+            'Bad request syntax or unsupported method')
+        UNAUTHORIZED = _HTTPStatus(401, 'Unauthorized',
+            'No permission -- see authorization schemes')
+        PAYMENT_REQUIRED = _HTTPStatus(402, 'Payment Required',
+            'No payment -- see charging schemes')
+        FORBIDDEN = _HTTPStatus(403, 'Forbidden',
+            'Request forbidden -- authorization will not help')
+        NOT_FOUND = _HTTPStatus(404, 'Not Found',
+            'Nothing matches the given URI')
+        METHOD_NOT_ALLOWED = _HTTPStatus(405, 'Method Not Allowed',
+            'Specified method is invalid for this resource')
+        NOT_ACCEPTABLE = _HTTPStatus(406, 'Not Acceptable',
+            'URI not available in preferred format')
+        PROXY_AUTHENTICATION_REQUIRED = _HTTPStatus(407,
+            'Proxy Authentication Required',
+            'You must authenticate with this proxy before proceeding')
+        REQUEST_TIMEOUT = _HTTPStatus(408, 'Request Timeout',
+            'Request timed out; try again later')
+        CONFLICT = _HTTPStatus(409, 'Conflict', 'Request conflict')
+        GONE = _HTTPStatus(410, 'Gone',
+            'URI no longer exists and has been permanently removed')
+        LENGTH_REQUIRED = _HTTPStatus(411, 'Length Required',
+            'Client must specify Content-Length')
+        PRECONDITION_FAILED = _HTTPStatus(412, 'Precondition Failed',
+            'Precondition in headers is false')
+        REQUEST_ENTITY_TOO_LARGE = _HTTPStatus(413, 'Request Entity Too Large',
+            'Entity is too large')
+        REQUEST_URI_TOO_LONG = _HTTPStatus(414, 'Request-URI Too Long',
+            'URI is too long')
+        UNSUPPORTED_MEDIA_TYPE = _HTTPStatus(415, 'Unsupported Media Type',
+            'Entity body in unsupported format')
+        REQUESTED_RANGE_NOT_SATISFIABLE = _HTTPStatus(416,
+            'Requested Range Not Satisfiable',
+            'Cannot satisfy request range')
+        EXPECTATION_FAILED = _HTTPStatus(417, 'Expectation Failed',
+            'Expect condition could not be satisfied')
+        MISDIRECTED_REQUEST = _HTTPStatus(421, 'Misdirected Request',
+            'Server is not able to produce a response')
+        UNPROCESSABLE_ENTITY = _HTTPStatus(422, 'Unprocessable Entity')
+        LOCKED = _HTTPStatus(423, 'Locked')
+        FAILED_DEPENDENCY = _HTTPStatus(424, 'Failed Dependency')
+        UPGRADE_REQUIRED = _HTTPStatus(426, 'Upgrade Required')
+        PRECONDITION_REQUIRED = _HTTPStatus(428, 'Precondition Required',
+            'The origin server requires the request to be conditional')
+        TOO_MANY_REQUESTS = _HTTPStatus(429, 'Too Many Requests',
+            'The user has sent too many requests in '
+            'a given amount of time ("rate limiting")')
+        REQUEST_HEADER_FIELDS_TOO_LARGE = _HTTPStatus(431,
+            'Request Header Fields Too Large',
+            'The server is unwilling to process the request because its header '
+            'fields are too large')
+        UNAVAILABLE_FOR_LEGAL_REASONS = _HTTPStatus(451,
+            'Unavailable For Legal Reasons',
+            'The server is denying access to the '
+            'resource as a consequence of a legal demand')
+        INTERNAL_SERVER_ERROR = _HTTPStatus(500, 'Internal Server Error',
+            'Server got itself in trouble')
+        NOT_IMPLEMENTED = _HTTPStatus(501, 'Not Implemented',
+            'Server does not support this operation')
+        BAD_GATEWAY = _HTTPStatus(502, 'Bad Gateway',
+            'Invalid responses from another server/proxy')
+        SERVICE_UNAVAILABLE = _HTTPStatus(503, 'Service Unavailable',
+            'The server cannot process the request due to a high load')
+        GATEWAY_TIMEOUT = _HTTPStatus(504, 'Gateway Timeout',
+            'The gateway server did not receive a timely response')
+        HTTP_VERSION_NOT_SUPPORTED = _HTTPStatus(505, 'HTTP Version Not Supported',
+            'Cannot fulfill request')
+        VARIANT_ALSO_NEGOTIATES = _HTTPStatus(506, 'Variant Also Negotiates')
+        INSUFFICIENT_STORAGE = _HTTPStatus(507, 'Insufficient Storage')
+        LOOP_DETECTED = _HTTPStatus(508, 'Loop Detected')
+        NOT_EXTENDED = _HTTPStatus(510, 'Not Extended')
+        NETWORK_AUTHENTICATION_REQUIRED = _HTTPStatus(511,
+            'Network Authentication Required',
+            'The client needs to authenticate to gain network access')
+    """
+    )
+    return AstroidBuilder(AstroidManager()).string_build(code)
+
+
+def _http_client_transform():
+    return AstroidBuilder(AstroidManager()).string_build(
+        textwrap.dedent(
+            """
+    from http import HTTPStatus
+
+    CONTINUE = HTTPStatus.CONTINUE
+    SWITCHING_PROTOCOLS = HTTPStatus.SWITCHING_PROTOCOLS
+    PROCESSING = HTTPStatus.PROCESSING
+    OK = HTTPStatus.OK
+    CREATED = HTTPStatus.CREATED
+    ACCEPTED = HTTPStatus.ACCEPTED
+    NON_AUTHORITATIVE_INFORMATION = HTTPStatus.NON_AUTHORITATIVE_INFORMATION
+    NO_CONTENT = HTTPStatus.NO_CONTENT
+    RESET_CONTENT = HTTPStatus.RESET_CONTENT
+    PARTIAL_CONTENT = HTTPStatus.PARTIAL_CONTENT
+    MULTI_STATUS = HTTPStatus.MULTI_STATUS
+    ALREADY_REPORTED = HTTPStatus.ALREADY_REPORTED
+    IM_USED = HTTPStatus.IM_USED
+    MULTIPLE_CHOICES = HTTPStatus.MULTIPLE_CHOICES
+    MOVED_PERMANENTLY = HTTPStatus.MOVED_PERMANENTLY
+    FOUND = HTTPStatus.FOUND
+    SEE_OTHER = HTTPStatus.SEE_OTHER
+    NOT_MODIFIED = HTTPStatus.NOT_MODIFIED
+    USE_PROXY = HTTPStatus.USE_PROXY
+    TEMPORARY_REDIRECT = HTTPStatus.TEMPORARY_REDIRECT
+    PERMANENT_REDIRECT = HTTPStatus.PERMANENT_REDIRECT
+    BAD_REQUEST = HTTPStatus.BAD_REQUEST
+    UNAUTHORIZED = HTTPStatus.UNAUTHORIZED
+    PAYMENT_REQUIRED = HTTPStatus.PAYMENT_REQUIRED
+    FORBIDDEN = HTTPStatus.FORBIDDEN
+    NOT_FOUND = HTTPStatus.NOT_FOUND
+    METHOD_NOT_ALLOWED = HTTPStatus.METHOD_NOT_ALLOWED
+    NOT_ACCEPTABLE = HTTPStatus.NOT_ACCEPTABLE
+    PROXY_AUTHENTICATION_REQUIRED = HTTPStatus.PROXY_AUTHENTICATION_REQUIRED
+    REQUEST_TIMEOUT = HTTPStatus.REQUEST_TIMEOUT
+    CONFLICT = HTTPStatus.CONFLICT
+    GONE = HTTPStatus.GONE
+    LENGTH_REQUIRED = HTTPStatus.LENGTH_REQUIRED
+    PRECONDITION_FAILED = HTTPStatus.PRECONDITION_FAILED
+    REQUEST_ENTITY_TOO_LARGE = HTTPStatus.REQUEST_ENTITY_TOO_LARGE
+    REQUEST_URI_TOO_LONG = HTTPStatus.REQUEST_URI_TOO_LONG
+    UNSUPPORTED_MEDIA_TYPE = HTTPStatus.UNSUPPORTED_MEDIA_TYPE
+    REQUESTED_RANGE_NOT_SATISFIABLE = HTTPStatus.REQUESTED_RANGE_NOT_SATISFIABLE
+    EXPECTATION_FAILED = HTTPStatus.EXPECTATION_FAILED
+    UNPROCESSABLE_ENTITY = HTTPStatus.UNPROCESSABLE_ENTITY
+    LOCKED = HTTPStatus.LOCKED
+    FAILED_DEPENDENCY = HTTPStatus.FAILED_DEPENDENCY
+    UPGRADE_REQUIRED = HTTPStatus.UPGRADE_REQUIRED
+    PRECONDITION_REQUIRED = HTTPStatus.PRECONDITION_REQUIRED
+    TOO_MANY_REQUESTS = HTTPStatus.TOO_MANY_REQUESTS
+    REQUEST_HEADER_FIELDS_TOO_LARGE = HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE
+    INTERNAL_SERVER_ERROR = HTTPStatus.INTERNAL_SERVER_ERROR
+    NOT_IMPLEMENTED = HTTPStatus.NOT_IMPLEMENTED
+    BAD_GATEWAY = HTTPStatus.BAD_GATEWAY
+    SERVICE_UNAVAILABLE = HTTPStatus.SERVICE_UNAVAILABLE
+    GATEWAY_TIMEOUT = HTTPStatus.GATEWAY_TIMEOUT
+    HTTP_VERSION_NOT_SUPPORTED = HTTPStatus.HTTP_VERSION_NOT_SUPPORTED
+    VARIANT_ALSO_NEGOTIATES = HTTPStatus.VARIANT_ALSO_NEGOTIATES
+    INSUFFICIENT_STORAGE = HTTPStatus.INSUFFICIENT_STORAGE
+    LOOP_DETECTED = HTTPStatus.LOOP_DETECTED
+    NOT_EXTENDED = HTTPStatus.NOT_EXTENDED
+    NETWORK_AUTHENTICATION_REQUIRED = HTTPStatus.NETWORK_AUTHENTICATION_REQUIRED
+    """
+        )
+    )
+
+
+register_module_extender(AstroidManager(), "http", _http_transform)
+register_module_extender(AstroidManager(), "http.client", _http_client_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_hypothesis.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_hypothesis.py
new file mode 100644
index 0000000..dae8361
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_hypothesis.py
@@ -0,0 +1,55 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""
+Astroid hook for the Hypothesis library.
+
+Without this hook pylint reports no-value-for-parameter for use of strategies
+defined using the `@hypothesis.strategies.composite` decorator.  For example:
+
+    from hypothesis import strategies as st
+
+    @st.composite
+    def a_strategy(draw):
+        return draw(st.integers())
+
+    a_strategy()
+
+"""
+from astroid.manager import AstroidManager
+from astroid.nodes.scoped_nodes import FunctionDef
+
+COMPOSITE_NAMES = (
+    "composite",
+    "st.composite",
+    "strategies.composite",
+    "hypothesis.strategies.composite",
+)
+
+
+def is_decorated_with_st_composite(node):
+    """Return True if a decorated node has @st.composite applied."""
+    if node.decorators and node.args.args and node.args.args[0].name == "draw":
+        for decorator_attribute in node.decorators.nodes:
+            if decorator_attribute.as_string() in COMPOSITE_NAMES:
+                return True
+    return False
+
+
+def remove_draw_parameter_from_composite_strategy(node):
+    """Given that the FunctionDef is decorated with @st.composite, remove the
+    first argument (`draw`) - it's always supplied by Hypothesis so we don't
+    need to emit the no-value-for-parameter lint.
+    """
+    del node.args.args[0]
+    del node.args.annotations[0]
+    del node.args.type_comment_args[0]
+    return node
+
+
+AstroidManager().register_transform(
+    node_class=FunctionDef,
+    transform=remove_draw_parameter_from_composite_strategy,
+    predicate=is_decorated_with_st_composite,
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_io.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_io.py
new file mode 100644
index 0000000..9957ce9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_io.py
@@ -0,0 +1,41 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid brain hints for some of the _io C objects."""
+from astroid.manager import AstroidManager
+from astroid.nodes import ClassDef
+
+BUFFERED = {"BufferedWriter", "BufferedReader"}
+TextIOWrapper = "TextIOWrapper"
+FileIO = "FileIO"
+BufferedWriter = "BufferedWriter"
+
+
+def _generic_io_transform(node, name, cls):
+    """Transform the given name, by adding the given *class* as a member of the node."""
+
+    io_module = AstroidManager().ast_from_module_name("_io")
+    attribute_object = io_module[cls]
+    instance = attribute_object.instantiate_class()
+    node.locals[name] = [instance]
+
+
+def _transform_text_io_wrapper(node):
+    # This is not always correct, since it can vary with the type of the descriptor,
+    # being stdout, stderr or stdin. But we cannot get access to the name of the
+    # stream, which is why we are using the BufferedWriter class as a default
+    # value
+    return _generic_io_transform(node, name="buffer", cls=BufferedWriter)
+
+
+def _transform_buffered(node):
+    return _generic_io_transform(node, name="raw", cls=FileIO)
+
+
+AstroidManager().register_transform(
+    ClassDef, _transform_buffered, lambda node: node.name in BUFFERED
+)
+AstroidManager().register_transform(
+    ClassDef, _transform_text_io_wrapper, lambda node: node.name == TextIOWrapper
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_mechanize.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_mechanize.py
new file mode 100644
index 0000000..4c86fd9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_mechanize.py
@@ -0,0 +1,83 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import AstroidBuilder
+from astroid.manager import AstroidManager
+
+
+def mechanize_transform():
+    return AstroidBuilder(AstroidManager()).string_build(
+        """
+
+class Browser(object):
+    def __getattr__(self, name):
+        return None
+    def __getitem__(self, name):
+        return None
+    def __setitem__(self, name, val):
+        return None
+    def back(self, n=1):
+        return None
+    def clear_history(self):
+        return None
+    def click(self, *args, **kwds):
+        return None
+    def click_link(self, link=None, **kwds):
+        return None
+    def close(self):
+        return None
+    def encoding(self):
+        return None
+    def find_link(self, text=None, text_regex=None, name=None, name_regex=None, url=None, url_regex=None, tag=None, predicate=None, nr=0):
+        return None
+    def follow_link(self, link=None, **kwds):
+        return None
+    def forms(self):
+        return None
+    def geturl(self):
+        return None
+    def global_form(self):
+        return None
+    def links(self, **kwds):
+        return None
+    def open_local_file(self, filename):
+        return None
+    def open(self, url, data=None, timeout=None):
+        return None
+    def open_novisit(self, url, data=None, timeout=None):
+        return None
+    def open_local_file(self, filename):
+        return None
+    def reload(self):
+        return None
+    def response(self):
+        return None
+    def select_form(self, name=None, predicate=None, nr=None, **attrs):
+        return None
+    def set_cookie(self, cookie_string):
+        return None
+    def set_handle_referer(self, handle):
+        return None
+    def set_header(self, header, value=None):
+        return None
+    def set_html(self, html, url="http://example.com/"):
+        return None
+    def set_response(self, response):
+        return None
+    def set_simple_cookie(self, name, value, domain, path='/'):
+        return None
+    def submit(self, *args, **kwds):
+        return None
+    def title(self):
+        return None
+    def viewing_html(self):
+        return None
+    def visit_response(self, response, request=None):
+        return None
+"""
+    )
+
+
+register_module_extender(AstroidManager(), "mechanize", mechanize_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_multiprocessing.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_multiprocessing.py
new file mode 100644
index 0000000..fc98a06
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_multiprocessing.py
@@ -0,0 +1,106 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid.bases import BoundMethod
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.exceptions import InferenceError
+from astroid.manager import AstroidManager
+from astroid.nodes.scoped_nodes import FunctionDef
+
+
+def _multiprocessing_transform():
+    module = parse(
+        """
+    from multiprocessing.managers import SyncManager
+    def Manager():
+        return SyncManager()
+    """
+    )
+    # Multiprocessing uses a getattr lookup inside contexts,
+    # in order to get the attributes they need. Since it's extremely
+    # dynamic, we use this approach to fake it.
+    node = parse(
+        """
+    from multiprocessing.context import DefaultContext, BaseContext
+    default = DefaultContext()
+    base = BaseContext()
+    """
+    )
+    try:
+        context = next(node["default"].infer())
+        base = next(node["base"].infer())
+    except (InferenceError, StopIteration):
+        return module
+
+    for node in (context, base):
+        for key, value in node.locals.items():
+            if key.startswith("_"):
+                continue
+
+            value = value[0]
+            if isinstance(value, FunctionDef):
+                # We need to rebound this, since otherwise
+                # it will have an extra argument (self).
+                value = BoundMethod(value, node)
+            module[key] = value
+    return module
+
+
+def _multiprocessing_managers_transform():
+    return parse(
+        """
+    import array
+    import threading
+    import multiprocessing.pool as pool
+    import queue
+
+    class Namespace(object):
+        pass
+
+    class Value(object):
+        def __init__(self, typecode, value, lock=True):
+            self._typecode = typecode
+            self._value = value
+        def get(self):
+            return self._value
+        def set(self, value):
+            self._value = value
+        def __repr__(self):
+            return '%s(%r, %r)'%(type(self).__name__, self._typecode, self._value)
+        value = property(get, set)
+
+    def Array(typecode, sequence, lock=True):
+        return array.array(typecode, sequence)
+
+    class SyncManager(object):
+        Queue = JoinableQueue = queue.Queue
+        Event = threading.Event
+        RLock = threading.RLock
+        BoundedSemaphore = threading.BoundedSemaphore
+        Condition = threading.Condition
+        Barrier = threading.Barrier
+        Pool = pool.Pool
+        list = list
+        dict = dict
+        Value = Value
+        Array = Array
+        Namespace = Namespace
+        __enter__ = lambda self: self
+        __exit__ = lambda *args: args
+
+        def start(self, initializer=None, initargs=None):
+            pass
+        def shutdown(self):
+            pass
+    """
+    )
+
+
+register_module_extender(
+    AstroidManager(), "multiprocessing.managers", _multiprocessing_managers_transform
+)
+register_module_extender(
+    AstroidManager(), "multiprocessing", _multiprocessing_transform
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_namedtuple_enum.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_namedtuple_enum.py
new file mode 100644
index 0000000..dbd9667
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_namedtuple_enum.py
@@ -0,0 +1,574 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for the Python standard library."""
+
+import functools
+import keyword
+from textwrap import dedent
+from typing import Iterator, List, Optional, Tuple
+
+import astroid
+from astroid import arguments, inference_tip, nodes, util
+from astroid.builder import AstroidBuilder, extract_node
+from astroid.context import InferenceContext
+from astroid.exceptions import (
+    AstroidTypeError,
+    AstroidValueError,
+    InferenceError,
+    MroError,
+    UseInferenceDefault,
+)
+from astroid.manager import AstroidManager
+
+TYPING_NAMEDTUPLE_BASENAMES = {"NamedTuple", "typing.NamedTuple"}
+ENUM_BASE_NAMES = {
+    "Enum",
+    "IntEnum",
+    "enum.Enum",
+    "enum.IntEnum",
+    "IntFlag",
+    "enum.IntFlag",
+}
+
+
+def _infer_first(node, context):
+    if node is util.Uninferable:
+        raise UseInferenceDefault
+    try:
+        value = next(node.infer(context=context))
+    except StopIteration as exc:
+        raise InferenceError from exc
+    if value is util.Uninferable:
+        raise UseInferenceDefault()
+    return value
+
+
+def _find_func_form_arguments(node, context):
+    def _extract_namedtuple_arg_or_keyword(  # pylint: disable=inconsistent-return-statements
+        position, key_name=None
+    ):
+        if len(args) > position:
+            return _infer_first(args[position], context)
+        if key_name and key_name in found_keywords:
+            return _infer_first(found_keywords[key_name], context)
+
+    args = node.args
+    keywords = node.keywords
+    found_keywords = (
+        {keyword.arg: keyword.value for keyword in keywords} if keywords else {}
+    )
+
+    name = _extract_namedtuple_arg_or_keyword(position=0, key_name="typename")
+    names = _extract_namedtuple_arg_or_keyword(position=1, key_name="field_names")
+    if name and names:
+        return name.value, names
+
+    raise UseInferenceDefault()
+
+
+def infer_func_form(
+    node: nodes.Call,
+    base_type: nodes.NodeNG,
+    context: Optional[InferenceContext] = None,
+    enum: bool = False,
+) -> Tuple[nodes.ClassDef, str, List[str]]:
+    """Specific inference function for namedtuple or Python 3 enum."""
+    # node is a Call node, class name as first argument and generated class
+    # attributes as second argument
+
+    # namedtuple or enums list of attributes can be a list of strings or a
+    # whitespace-separate string
+    try:
+        name, names = _find_func_form_arguments(node, context)
+        try:
+            attributes = names.value.replace(",", " ").split()
+        except AttributeError as exc:
+            # Handle attributes of NamedTuples
+            if not enum:
+                attributes = [
+                    _infer_first(const, context).value for const in names.elts
+                ]
+
+            # Handle attributes of Enums
+            else:
+                # Enums supports either iterator of (name, value) pairs
+                # or mappings.
+                if hasattr(names, "items") and isinstance(names.items, list):
+                    attributes = [
+                        _infer_first(const[0], context).value
+                        for const in names.items
+                        if isinstance(const[0], nodes.Const)
+                    ]
+                elif hasattr(names, "elts"):
+                    # Enums can support either ["a", "b", "c"]
+                    # or [("a", 1), ("b", 2), ...], but they can't
+                    # be mixed.
+                    if all(isinstance(const, nodes.Tuple) for const in names.elts):
+                        attributes = [
+                            _infer_first(const.elts[0], context).value
+                            for const in names.elts
+                            if isinstance(const, nodes.Tuple)
+                        ]
+                    else:
+                        attributes = [
+                            _infer_first(const, context).value for const in names.elts
+                        ]
+                else:
+                    raise AttributeError from exc
+                if not attributes:
+                    raise AttributeError from exc
+    except (AttributeError, InferenceError) as exc:
+        raise UseInferenceDefault from exc
+
+    if not enum:
+        # namedtuple maps sys.intern(str()) over over field_names
+        attributes = [str(attr) for attr in attributes]
+        # XXX this should succeed *unless* __str__/__repr__ is incorrect or throws
+        # in which case we should not have inferred these values and raised earlier
+    attributes = [attr for attr in attributes if " " not in attr]
+
+    # If we can't infer the name of the class, don't crash, up to this point
+    # we know it is a namedtuple anyway.
+    name = name or "Uninferable"
+    # we want to return a Class node instance with proper attributes set
+    class_node = nodes.ClassDef(name)
+    # A typical ClassDef automatically adds its name to the parent scope,
+    # but doing so causes problems, so defer setting parent until after init
+    # see: https://github.com/PyCQA/pylint/issues/5982
+    class_node.parent = node.parent
+    class_node.postinit(
+        # set base class=tuple
+        bases=[base_type],
+        body=[],
+        decorators=None,
+    )
+    # XXX add __init__(*attributes) method
+    for attr in attributes:
+        fake_node = nodes.EmptyNode()
+        fake_node.parent = class_node
+        fake_node.attrname = attr
+        class_node.instance_attrs[attr] = [fake_node]
+    return class_node, name, attributes
+
+
+def _has_namedtuple_base(node):
+    """Predicate for class inference tip
+
+    :type node: ClassDef
+    :rtype: bool
+    """
+    return set(node.basenames) & TYPING_NAMEDTUPLE_BASENAMES
+
+
+def _looks_like(node, name):
+    func = node.func
+    if isinstance(func, nodes.Attribute):
+        return func.attrname == name
+    if isinstance(func, nodes.Name):
+        return func.name == name
+    return False
+
+
+_looks_like_namedtuple = functools.partial(_looks_like, name="namedtuple")
+_looks_like_enum = functools.partial(_looks_like, name="Enum")
+_looks_like_typing_namedtuple = functools.partial(_looks_like, name="NamedTuple")
+
+
+def infer_named_tuple(
+    node: nodes.Call, context: Optional[InferenceContext] = None
+) -> Iterator[nodes.ClassDef]:
+    """Specific inference function for namedtuple Call node"""
+    tuple_base_name = nodes.Name(name="tuple", parent=node.root())
+    class_node, name, attributes = infer_func_form(
+        node, tuple_base_name, context=context
+    )
+    call_site = arguments.CallSite.from_call(node, context=context)
+    node = extract_node("import collections; collections.namedtuple")
+    try:
+
+        func = next(node.infer())
+    except StopIteration as e:
+        raise InferenceError(node=node) from e
+    try:
+        rename = next(call_site.infer_argument(func, "rename", context)).bool_value()
+    except (InferenceError, StopIteration):
+        rename = False
+
+    try:
+        attributes = _check_namedtuple_attributes(name, attributes, rename)
+    except AstroidTypeError as exc:
+        raise UseInferenceDefault("TypeError: " + str(exc)) from exc
+    except AstroidValueError as exc:
+        raise UseInferenceDefault("ValueError: " + str(exc)) from exc
+
+    replace_args = ", ".join(f"{arg}=None" for arg in attributes)
+    field_def = (
+        "    {name} = property(lambda self: self[{index:d}], "
+        "doc='Alias for field number {index:d}')"
+    )
+    field_defs = "\n".join(
+        field_def.format(name=name, index=index)
+        for index, name in enumerate(attributes)
+    )
+    fake = AstroidBuilder(AstroidManager()).string_build(
+        f"""
+class {name}(tuple):
+    __slots__ = ()
+    _fields = {attributes!r}
+    def _asdict(self):
+        return self.__dict__
+    @classmethod
+    def _make(cls, iterable, new=tuple.__new__, len=len):
+        return new(cls, iterable)
+    def _replace(self, {replace_args}):
+        return self
+    def __getnewargs__(self):
+        return tuple(self)
+{field_defs}
+    """
+    )
+    class_node.locals["_asdict"] = fake.body[0].locals["_asdict"]
+    class_node.locals["_make"] = fake.body[0].locals["_make"]
+    class_node.locals["_replace"] = fake.body[0].locals["_replace"]
+    class_node.locals["_fields"] = fake.body[0].locals["_fields"]
+    for attr in attributes:
+        class_node.locals[attr] = fake.body[0].locals[attr]
+    # we use UseInferenceDefault, we can't be a generator so return an iterator
+    return iter([class_node])
+
+
+def _get_renamed_namedtuple_attributes(field_names):
+    names = list(field_names)
+    seen = set()
+    for i, name in enumerate(field_names):
+        if (
+            not all(c.isalnum() or c == "_" for c in name)
+            or keyword.iskeyword(name)
+            or not name
+            or name[0].isdigit()
+            or name.startswith("_")
+            or name in seen
+        ):
+            names[i] = "_%d" % i
+        seen.add(name)
+    return tuple(names)
+
+
+def _check_namedtuple_attributes(typename, attributes, rename=False):
+    attributes = tuple(attributes)
+    if rename:
+        attributes = _get_renamed_namedtuple_attributes(attributes)
+
+    # The following snippet is derived from the CPython Lib/collections/__init__.py sources
+    # <snippet>
+    for name in (typename,) + attributes:
+        if not isinstance(name, str):
+            raise AstroidTypeError("Type names and field names must be strings")
+        if not name.isidentifier():
+            raise AstroidValueError(
+                "Type names and field names must be valid" + f"identifiers: {name!r}"
+            )
+        if keyword.iskeyword(name):
+            raise AstroidValueError(
+                f"Type names and field names cannot be a keyword: {name!r}"
+            )
+
+    seen = set()
+    for name in attributes:
+        if name.startswith("_") and not rename:
+            raise AstroidValueError(
+                f"Field names cannot start with an underscore: {name!r}"
+            )
+        if name in seen:
+            raise AstroidValueError(f"Encountered duplicate field name: {name!r}")
+        seen.add(name)
+    # </snippet>
+
+    return attributes
+
+
+def infer_enum(node, context=None):
+    """Specific inference function for enum Call node."""
+    enum_meta = extract_node(
+        """
+    class EnumMeta(object):
+        'docstring'
+        def __call__(self, node):
+            class EnumAttribute(object):
+                name = ''
+                value = 0
+            return EnumAttribute()
+        def __iter__(self):
+            class EnumAttribute(object):
+                name = ''
+                value = 0
+            return [EnumAttribute()]
+        def __reversed__(self):
+            class EnumAttribute(object):
+                name = ''
+                value = 0
+            return (EnumAttribute, )
+        def __next__(self):
+            return next(iter(self))
+        def __getitem__(self, attr):
+            class Value(object):
+                @property
+                def name(self):
+                    return ''
+                @property
+                def value(self):
+                    return attr
+
+            return Value()
+        __members__ = ['']
+    """
+    )
+    class_node = infer_func_form(node, enum_meta, context=context, enum=True)[0]
+    return iter([class_node.instantiate_class()])
+
+
+INT_FLAG_ADDITION_METHODS = """
+    def __or__(self, other):
+        return {name}(self.value | other.value)
+    def __and__(self, other):
+        return {name}(self.value & other.value)
+    def __xor__(self, other):
+        return {name}(self.value ^ other.value)
+    def __add__(self, other):
+        return {name}(self.value + other.value)
+    def __div__(self, other):
+        return {name}(self.value / other.value)
+    def __invert__(self):
+        return {name}(~self.value)
+    def __mul__(self, other):
+        return {name}(self.value * other.value)
+"""
+
+
+def infer_enum_class(node):
+    """Specific inference for enums."""
+    for basename in (b for cls in node.mro() for b in cls.basenames):
+        if basename not in ENUM_BASE_NAMES:
+            continue
+        if node.root().name == "enum":
+            # Skip if the class is directly from enum module.
+            break
+        dunder_members = {}
+        target_names = set()
+        for local, values in node.locals.items():
+            if any(not isinstance(value, nodes.AssignName) for value in values):
+                continue
+
+            stmt = values[0].statement(future=True)
+            if isinstance(stmt, nodes.Assign):
+                if isinstance(stmt.targets[0], nodes.Tuple):
+                    targets = stmt.targets[0].itered()
+                else:
+                    targets = stmt.targets
+            elif isinstance(stmt, nodes.AnnAssign):
+                targets = [stmt.target]
+            else:
+                continue
+
+            inferred_return_value = None
+            if isinstance(stmt, nodes.Assign):
+                if isinstance(stmt.value, nodes.Const):
+                    if isinstance(stmt.value.value, str):
+                        inferred_return_value = repr(stmt.value.value)
+                    else:
+                        inferred_return_value = stmt.value.value
+                else:
+                    inferred_return_value = stmt.value.as_string()
+
+            new_targets = []
+            for target in targets:
+                if isinstance(target, nodes.Starred):
+                    continue
+                target_names.add(target.name)
+                # Replace all the assignments with our mocked class.
+                classdef = dedent(
+                    """
+                class {name}({types}):
+                    @property
+                    def value(self):
+                        return {return_value}
+                    @property
+                    def name(self):
+                        return "{name}"
+                """.format(
+                        name=target.name,
+                        types=", ".join(node.basenames),
+                        return_value=inferred_return_value,
+                    )
+                )
+                if "IntFlag" in basename:
+                    # Alright, we need to add some additional methods.
+                    # Unfortunately we still can't infer the resulting objects as
+                    # Enum members, but once we'll be able to do that, the following
+                    # should result in some nice symbolic execution
+                    classdef += INT_FLAG_ADDITION_METHODS.format(name=target.name)
+
+                fake = AstroidBuilder(
+                    AstroidManager(), apply_transforms=False
+                ).string_build(classdef)[target.name]
+                fake.parent = target.parent
+                for method in node.mymethods():
+                    fake.locals[method.name] = [method]
+                new_targets.append(fake.instantiate_class())
+                dunder_members[local] = fake
+            node.locals[local] = new_targets
+        members = nodes.Dict(parent=node)
+        members.postinit(
+            [
+                (nodes.Const(k, parent=members), nodes.Name(v.name, parent=members))
+                for k, v in dunder_members.items()
+            ]
+        )
+        node.locals["__members__"] = [members]
+        # The enum.Enum class itself defines two @DynamicClassAttribute data-descriptors
+        # "name" and "value" (which we override in the mocked class for each enum member
+        # above). When dealing with inference of an arbitrary instance of the enum
+        # class, e.g. in a method defined in the class body like:
+        #     class SomeEnum(enum.Enum):
+        #         def method(self):
+        #             self.name  # <- here
+        # In the absence of an enum member called "name" or "value", these attributes
+        # should resolve to the descriptor on that particular instance, i.e. enum member.
+        # For "value", we have no idea what that should be, but for "name", we at least
+        # know that it should be a string, so infer that as a guess.
+        if "name" not in target_names:
+            code = dedent(
+                """
+            @property
+            def name(self):
+                return ''
+            """
+            )
+            name_dynamicclassattr = AstroidBuilder(AstroidManager()).string_build(code)[
+                "name"
+            ]
+            node.locals["name"] = [name_dynamicclassattr]
+        break
+    return node
+
+
+def infer_typing_namedtuple_class(class_node, context=None):
+    """Infer a subclass of typing.NamedTuple"""
+    # Check if it has the corresponding bases
+    annassigns_fields = [
+        annassign.target.name
+        for annassign in class_node.body
+        if isinstance(annassign, nodes.AnnAssign)
+    ]
+    code = dedent(
+        """
+    from collections import namedtuple
+    namedtuple({typename!r}, {fields!r})
+    """
+    ).format(typename=class_node.name, fields=",".join(annassigns_fields))
+    node = extract_node(code)
+    try:
+        generated_class_node = next(infer_named_tuple(node, context))
+    except StopIteration as e:
+        raise InferenceError(node=node, context=context) from e
+    for method in class_node.mymethods():
+        generated_class_node.locals[method.name] = [method]
+
+    for body_node in class_node.body:
+        if isinstance(body_node, nodes.Assign):
+            for target in body_node.targets:
+                attr = target.name
+                generated_class_node.locals[attr] = class_node.locals[attr]
+        elif isinstance(body_node, nodes.ClassDef):
+            generated_class_node.locals[body_node.name] = [body_node]
+
+    return iter((generated_class_node,))
+
+
+def infer_typing_namedtuple_function(node, context=None):
+    """
+    Starting with python3.9, NamedTuple is a function of the typing module.
+    The class NamedTuple is build dynamically through a call to `type` during
+    initialization of the `_NamedTuple` variable.
+    """
+    klass = extract_node(
+        """
+        from typing import _NamedTuple
+        _NamedTuple
+        """
+    )
+    return klass.infer(context)
+
+
+def infer_typing_namedtuple(
+    node: nodes.Call, context: Optional[InferenceContext] = None
+) -> Iterator[nodes.ClassDef]:
+    """Infer a typing.NamedTuple(...) call."""
+    # This is essentially a namedtuple with different arguments
+    # so we extract the args and infer a named tuple.
+    try:
+        func = next(node.func.infer())
+    except (InferenceError, StopIteration) as exc:
+        raise UseInferenceDefault from exc
+
+    if func.qname() != "typing.NamedTuple":
+        raise UseInferenceDefault
+
+    if len(node.args) != 2:
+        raise UseInferenceDefault
+
+    if not isinstance(node.args[1], (nodes.List, nodes.Tuple)):
+        raise UseInferenceDefault
+
+    names = []
+    for elt in node.args[1].elts:
+        if not isinstance(elt, (nodes.List, nodes.Tuple)):
+            raise UseInferenceDefault
+        if len(elt.elts) != 2:
+            raise UseInferenceDefault
+        names.append(elt.elts[0].as_string())
+
+    typename = node.args[0].as_string()
+    if names:
+        field_names = f"({','.join(names)},)"
+    else:
+        field_names = "''"
+    node = extract_node(f"namedtuple({typename}, {field_names})")
+    return infer_named_tuple(node, context)
+
+
+def _is_enum_subclass(cls: astroid.ClassDef) -> bool:
+    """Return whether cls is a subclass of an Enum."""
+    try:
+        return any(
+            klass.name in ENUM_BASE_NAMES
+            and getattr(klass.root(), "name", None) == "enum"
+            for klass in cls.mro()
+        )
+    except MroError:
+        return False
+
+
+AstroidManager().register_transform(
+    nodes.Call, inference_tip(infer_named_tuple), _looks_like_namedtuple
+)
+AstroidManager().register_transform(
+    nodes.Call, inference_tip(infer_enum), _looks_like_enum
+)
+AstroidManager().register_transform(
+    nodes.ClassDef, infer_enum_class, predicate=_is_enum_subclass
+)
+AstroidManager().register_transform(
+    nodes.ClassDef, inference_tip(infer_typing_namedtuple_class), _has_namedtuple_base
+)
+AstroidManager().register_transform(
+    nodes.FunctionDef,
+    inference_tip(infer_typing_namedtuple_function),
+    lambda node: node.name == "NamedTuple"
+    and getattr(node.root(), "name", None) == "typing",
+)
+AstroidManager().register_transform(
+    nodes.Call, inference_tip(infer_typing_namedtuple), _looks_like_typing_namedtuple
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_nose.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_nose.py
new file mode 100644
index 0000000..38e2229
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_nose.py
@@ -0,0 +1,79 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Hooks for nose library."""
+
+import re
+import textwrap
+
+import astroid.builder
+from astroid.brain.helpers import register_module_extender
+from astroid.exceptions import InferenceError
+from astroid.manager import AstroidManager
+
+_BUILDER = astroid.builder.AstroidBuilder(AstroidManager())
+
+
+CAPITALS = re.compile("([A-Z])")
+
+
+def _pep8(name, caps=CAPITALS):
+    return caps.sub(lambda m: "_" + m.groups()[0].lower(), name)
+
+
+def _nose_tools_functions():
+    """Get an iterator of names and bound methods."""
+    module = _BUILDER.string_build(
+        textwrap.dedent(
+            """
+    import unittest
+
+    class Test(unittest.TestCase):
+        pass
+    a = Test()
+    """
+        )
+    )
+    try:
+        case = next(module["a"].infer())
+    except (InferenceError, StopIteration):
+        return
+    for method in case.methods():
+        if method.name.startswith("assert") and "_" not in method.name:
+            pep8_name = _pep8(method.name)
+            yield pep8_name, astroid.BoundMethod(method, case)
+        if method.name == "assertEqual":
+            # nose also exports assert_equals.
+            yield "assert_equals", astroid.BoundMethod(method, case)
+
+
+def _nose_tools_transform(node):
+    for method_name, method in _nose_tools_functions():
+        node.locals[method_name] = [method]
+
+
+def _nose_tools_trivial_transform():
+    """Custom transform for the nose.tools module."""
+    stub = _BUILDER.string_build("""__all__ = []""")
+    all_entries = ["ok_", "eq_"]
+
+    for pep8_name, method in _nose_tools_functions():
+        all_entries.append(pep8_name)
+        stub[pep8_name] = method
+
+    # Update the __all__ variable, since nose.tools
+    # does this manually with .append.
+    all_assign = stub["__all__"].parent
+    all_object = astroid.List(all_entries)
+    all_object.parent = all_assign
+    all_assign.value = all_object
+    return stub
+
+
+register_module_extender(
+    AstroidManager(), "nose.tools.trivial", _nose_tools_trivial_transform
+)
+AstroidManager().register_transform(
+    astroid.Module, _nose_tools_transform, lambda n: n.name == "nose.tools"
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_fromnumeric.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_fromnumeric.py
new file mode 100644
index 0000000..19d4822
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_fromnumeric.py
@@ -0,0 +1,22 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for numpy.core.fromnumeric module."""
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def numpy_core_fromnumeric_transform():
+    return parse(
+        """
+    def sum(a, axis=None, dtype=None, out=None, keepdims=None, initial=None):
+        return numpy.ndarray([0, 0])
+    """
+    )
+
+
+register_module_extender(
+    AstroidManager(), "numpy.core.fromnumeric", numpy_core_fromnumeric_transform
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_function_base.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_function_base.py
new file mode 100644
index 0000000..31d53cb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_function_base.py
@@ -0,0 +1,29 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for numpy.core.function_base module."""
+
+import functools
+
+from astroid.brain.brain_numpy_utils import infer_numpy_member, looks_like_numpy_member
+from astroid.inference_tip import inference_tip
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import Attribute
+
+METHODS_TO_BE_INFERRED = {
+    "linspace": """def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0):
+            return numpy.ndarray([0, 0])""",
+    "logspace": """def logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0):
+            return numpy.ndarray([0, 0])""",
+    "geomspace": """def geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0):
+            return numpy.ndarray([0, 0])""",
+}
+
+for func_name, func_src in METHODS_TO_BE_INFERRED.items():
+    inference_function = functools.partial(infer_numpy_member, func_src)
+    AstroidManager().register_transform(
+        Attribute,
+        inference_tip(inference_function),
+        functools.partial(looks_like_numpy_member, func_name),
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_multiarray.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_multiarray.py
new file mode 100644
index 0000000..487ec47
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_multiarray.py
@@ -0,0 +1,95 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for numpy.core.multiarray module."""
+
+import functools
+
+from astroid.brain.brain_numpy_utils import infer_numpy_member, looks_like_numpy_member
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.inference_tip import inference_tip
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import Attribute, Name
+
+
+def numpy_core_multiarray_transform():
+    return parse(
+        """
+    # different functions defined in multiarray.py
+    def inner(a, b):
+        return numpy.ndarray([0, 0])
+
+    def vdot(a, b):
+        return numpy.ndarray([0, 0])
+        """
+    )
+
+
+register_module_extender(
+    AstroidManager(), "numpy.core.multiarray", numpy_core_multiarray_transform
+)
+
+
+METHODS_TO_BE_INFERRED = {
+    "array": """def array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0):
+            return numpy.ndarray([0, 0])""",
+    "dot": """def dot(a, b, out=None):
+            return numpy.ndarray([0, 0])""",
+    "empty_like": """def empty_like(a, dtype=None, order='K', subok=True):
+            return numpy.ndarray((0, 0))""",
+    "concatenate": """def concatenate(arrays, axis=None, out=None):
+            return numpy.ndarray((0, 0))""",
+    "where": """def where(condition, x=None, y=None):
+            return numpy.ndarray([0, 0])""",
+    "empty": """def empty(shape, dtype=float, order='C'):
+            return numpy.ndarray([0, 0])""",
+    "bincount": """def bincount(x, weights=None, minlength=0):
+            return numpy.ndarray([0, 0])""",
+    "busday_count": """def busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None):
+            return numpy.ndarray([0, 0])""",
+    "busday_offset": """def busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None):
+            return numpy.ndarray([0, 0])""",
+    "can_cast": """def can_cast(from_, to, casting='safe'):
+            return True""",
+    "copyto": """def copyto(dst, src, casting='same_kind', where=True):
+            return None""",
+    "datetime_as_string": """def datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind'):
+            return numpy.ndarray([0, 0])""",
+    "is_busday": """def is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None):
+            return numpy.ndarray([0, 0])""",
+    "lexsort": """def lexsort(keys, axis=-1):
+            return numpy.ndarray([0, 0])""",
+    "may_share_memory": """def may_share_memory(a, b, max_work=None):
+            return True""",
+    # Not yet available because dtype is not yet present in those brains
+    #     "min_scalar_type": """def min_scalar_type(a):
+    #             return numpy.dtype('int16')""",
+    "packbits": """def packbits(a, axis=None, bitorder='big'):
+            return numpy.ndarray([0, 0])""",
+    # Not yet available because dtype is not yet present in those brains
+    #     "result_type": """def result_type(*arrays_and_dtypes):
+    #             return numpy.dtype('int16')""",
+    "shares_memory": """def shares_memory(a, b, max_work=None):
+            return True""",
+    "unpackbits": """def unpackbits(a, axis=None, count=None, bitorder='big'):
+            return numpy.ndarray([0, 0])""",
+    "unravel_index": """def unravel_index(indices, shape, order='C'):
+            return (numpy.ndarray([0, 0]),)""",
+    "zeros": """def zeros(shape, dtype=float, order='C'):
+            return numpy.ndarray([0, 0])""",
+}
+
+for method_name, function_src in METHODS_TO_BE_INFERRED.items():
+    inference_function = functools.partial(infer_numpy_member, function_src)
+    AstroidManager().register_transform(
+        Attribute,
+        inference_tip(inference_function),
+        functools.partial(looks_like_numpy_member, method_name),
+    )
+    AstroidManager().register_transform(
+        Name,
+        inference_tip(inference_function),
+        functools.partial(looks_like_numpy_member, method_name),
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_numeric.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_numeric.py
new file mode 100644
index 0000000..140d81a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_numeric.py
@@ -0,0 +1,46 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for numpy.core.numeric module."""
+
+import functools
+
+from astroid.brain.brain_numpy_utils import infer_numpy_member, looks_like_numpy_member
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.inference_tip import inference_tip
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import Attribute
+
+
+def numpy_core_numeric_transform():
+    return parse(
+        """
+    # different functions defined in numeric.py
+    import numpy
+    def zeros_like(a, dtype=None, order='K', subok=True, shape=None): return numpy.ndarray((0, 0))
+    def ones_like(a, dtype=None, order='K', subok=True, shape=None): return numpy.ndarray((0, 0))
+    def full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None): return numpy.ndarray((0, 0))
+        """
+    )
+
+
+register_module_extender(
+    AstroidManager(), "numpy.core.numeric", numpy_core_numeric_transform
+)
+
+
+METHODS_TO_BE_INFERRED = {
+    "ones": """def ones(shape, dtype=None, order='C'):
+            return numpy.ndarray([0, 0])"""
+}
+
+
+for method_name, function_src in METHODS_TO_BE_INFERRED.items():
+    inference_function = functools.partial(infer_numpy_member, function_src)
+    AstroidManager().register_transform(
+        Attribute,
+        inference_tip(inference_function),
+        functools.partial(looks_like_numpy_member, method_name),
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_numerictypes.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_numerictypes.py
new file mode 100644
index 0000000..245296e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_numerictypes.py
@@ -0,0 +1,263 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+# TODO(hippo91) : correct the methods signature.
+
+"""Astroid hooks for numpy.core.numerictypes module."""
+from astroid.brain.brain_numpy_utils import numpy_supports_type_hints
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def numpy_core_numerictypes_transform():
+    # TODO: Uniformize the generic API with the ndarray one.
+    #       According to numpy doc the generic object should expose
+    #       the same API than ndarray. This has been done here partially
+    #       through the astype method.
+    generic_src = """
+    class generic(object):
+        def __init__(self, value):
+            self.T = np.ndarray([0, 0])
+            self.base = None
+            self.data = None
+            self.dtype = None
+            self.flags = None
+            # Should be a numpy.flatiter instance but not available for now
+            # Putting an array instead so that iteration and indexing are authorized
+            self.flat = np.ndarray([0, 0])
+            self.imag = None
+            self.itemsize = None
+            self.nbytes = None
+            self.ndim = None
+            self.real = None
+            self.size = None
+            self.strides = None
+
+        def all(self): return uninferable
+        def any(self): return uninferable
+        def argmax(self): return uninferable
+        def argmin(self): return uninferable
+        def argsort(self): return uninferable
+        def astype(self, dtype, order='K', casting='unsafe', subok=True, copy=True): return np.ndarray([0, 0])
+        def base(self): return uninferable
+        def byteswap(self): return uninferable
+        def choose(self): return uninferable
+        def clip(self): return uninferable
+        def compress(self): return uninferable
+        def conj(self): return uninferable
+        def conjugate(self): return uninferable
+        def copy(self): return uninferable
+        def cumprod(self): return uninferable
+        def cumsum(self): return uninferable
+        def data(self): return uninferable
+        def diagonal(self): return uninferable
+        def dtype(self): return uninferable
+        def dump(self): return uninferable
+        def dumps(self): return uninferable
+        def fill(self): return uninferable
+        def flags(self): return uninferable
+        def flat(self): return uninferable
+        def flatten(self): return uninferable
+        def getfield(self): return uninferable
+        def imag(self): return uninferable
+        def item(self): return uninferable
+        def itemset(self): return uninferable
+        def itemsize(self): return uninferable
+        def max(self): return uninferable
+        def mean(self): return uninferable
+        def min(self): return uninferable
+        def nbytes(self): return uninferable
+        def ndim(self): return uninferable
+        def newbyteorder(self): return uninferable
+        def nonzero(self): return uninferable
+        def prod(self): return uninferable
+        def ptp(self): return uninferable
+        def put(self): return uninferable
+        def ravel(self): return uninferable
+        def real(self): return uninferable
+        def repeat(self): return uninferable
+        def reshape(self): return uninferable
+        def resize(self): return uninferable
+        def round(self): return uninferable
+        def searchsorted(self): return uninferable
+        def setfield(self): return uninferable
+        def setflags(self): return uninferable
+        def shape(self): return uninferable
+        def size(self): return uninferable
+        def sort(self): return uninferable
+        def squeeze(self): return uninferable
+        def std(self): return uninferable
+        def strides(self): return uninferable
+        def sum(self): return uninferable
+        def swapaxes(self): return uninferable
+        def take(self): return uninferable
+        def tobytes(self): return uninferable
+        def tofile(self): return uninferable
+        def tolist(self): return uninferable
+        def tostring(self): return uninferable
+        def trace(self): return uninferable
+        def transpose(self): return uninferable
+        def var(self): return uninferable
+        def view(self): return uninferable
+        """
+    if numpy_supports_type_hints():
+        generic_src += """
+        @classmethod
+        def __class_getitem__(cls, value):
+            return cls
+        """
+    return parse(
+        generic_src
+        + """
+    class dtype(object):
+        def __init__(self, obj, align=False, copy=False):
+            self.alignment = None
+            self.base = None
+            self.byteorder = None
+            self.char = None
+            self.descr = None
+            self.fields = None
+            self.flags = None
+            self.hasobject = None
+            self.isalignedstruct = None
+            self.isbuiltin = None
+            self.isnative = None
+            self.itemsize = None
+            self.kind = None
+            self.metadata = None
+            self.name = None
+            self.names = None
+            self.num = None
+            self.shape = None
+            self.str = None
+            self.subdtype = None
+            self.type = None
+
+        def newbyteorder(self, new_order='S'): return uninferable
+        def __neg__(self): return uninferable
+
+    class busdaycalendar(object):
+        def __init__(self, weekmask='1111100', holidays=None):
+            self.holidays = None
+            self.weekmask = None
+
+    class flexible(generic): pass
+    class bool_(generic): pass
+    class number(generic):
+        def __neg__(self): return uninferable
+    class datetime64(generic):
+        def __init__(self, nb, unit=None): pass
+
+
+    class void(flexible):
+        def __init__(self, *args, **kwargs):
+            self.base = None
+            self.dtype = None
+            self.flags = None
+        def getfield(self): return uninferable
+        def setfield(self): return uninferable
+
+
+    class character(flexible): pass
+
+
+    class integer(number):
+        def __init__(self, value):
+           self.denominator = None
+           self.numerator = None
+
+
+    class inexact(number): pass
+
+
+    class str_(str, character):
+        def maketrans(self, x, y=None, z=None): return uninferable
+
+
+    class bytes_(bytes, character):
+        def fromhex(self, string): return uninferable
+        def maketrans(self, frm, to): return uninferable
+
+
+    class signedinteger(integer): pass
+
+
+    class unsignedinteger(integer): pass
+
+
+    class complexfloating(inexact): pass
+
+
+    class floating(inexact): pass
+
+
+    class float64(floating, float):
+        def fromhex(self, string): return uninferable
+
+
+    class uint64(unsignedinteger): pass
+    class complex64(complexfloating): pass
+    class int16(signedinteger): pass
+    class float96(floating): pass
+    class int8(signedinteger): pass
+    class uint32(unsignedinteger): pass
+    class uint8(unsignedinteger): pass
+    class _typedict(dict): pass
+    class complex192(complexfloating): pass
+    class timedelta64(signedinteger):
+        def __init__(self, nb, unit=None): pass
+    class int32(signedinteger): pass
+    class uint16(unsignedinteger): pass
+    class float32(floating): pass
+    class complex128(complexfloating, complex): pass
+    class float16(floating): pass
+    class int64(signedinteger): pass
+
+    buffer_type = memoryview
+    bool8 = bool_
+    byte = int8
+    bytes0 = bytes_
+    cdouble = complex128
+    cfloat = complex128
+    clongdouble = complex192
+    clongfloat = complex192
+    complex_ = complex128
+    csingle = complex64
+    double = float64
+    float_ = float64
+    half = float16
+    int0 = int32
+    int_ = int32
+    intc = int32
+    intp = int32
+    long = int32
+    longcomplex = complex192
+    longdouble = float96
+    longfloat = float96
+    longlong = int64
+    object0 = object_
+    object_ = object_
+    short = int16
+    single = float32
+    singlecomplex = complex64
+    str0 = str_
+    string_ = bytes_
+    ubyte = uint8
+    uint = uint32
+    uint0 = uint32
+    uintc = uint32
+    uintp = uint32
+    ulonglong = uint64
+    unicode = str_
+    unicode_ = str_
+    ushort = uint16
+    void0 = void
+    """
+    )
+
+
+register_module_extender(
+    AstroidManager(), "numpy.core.numerictypes", numpy_core_numerictypes_transform
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_umath.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_umath.py
new file mode 100644
index 0000000..42dfdfa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_core_umath.py
@@ -0,0 +1,154 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+# Note: starting with version 1.18 numpy module has `__getattr__` method which prevent
+# `pylint` to emit `no-member` message for all numpy's attributes. (see pylint's module
+# typecheck in `_emit_no_member` function)
+
+"""Astroid hooks for numpy.core.umath module."""
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def numpy_core_umath_transform():
+    ufunc_optional_keyword_arguments = (
+        """out=None, where=True, casting='same_kind', order='K', """
+        """dtype=None, subok=True"""
+    )
+    return parse(
+        """
+    class FakeUfunc:
+        def __init__(self):
+            self.__doc__ = str()
+            self.__name__ = str()
+            self.nin = 0
+            self.nout = 0
+            self.nargs = 0
+            self.ntypes = 0
+            self.types = None
+            self.identity = None
+            self.signature = None
+
+        @classmethod
+        def reduce(cls, a, axis=None, dtype=None, out=None):
+            return numpy.ndarray([0, 0])
+
+        @classmethod
+        def accumulate(cls, array, axis=None, dtype=None, out=None):
+            return numpy.ndarray([0, 0])
+
+        @classmethod
+        def reduceat(cls, a, indices, axis=None, dtype=None, out=None):
+            return numpy.ndarray([0, 0])
+
+        @classmethod
+        def outer(cls, A, B, **kwargs):
+            return numpy.ndarray([0, 0])
+
+        @classmethod
+        def at(cls, a, indices, b=None):
+            return numpy.ndarray([0, 0])
+
+    class FakeUfuncOneArg(FakeUfunc):
+        def __call__(self, x, {opt_args:s}):
+            return numpy.ndarray([0, 0])
+
+    class FakeUfuncOneArgBis(FakeUfunc):
+        def __call__(self, x, {opt_args:s}):
+            return numpy.ndarray([0, 0]), numpy.ndarray([0, 0])
+
+    class FakeUfuncTwoArgs(FakeUfunc):
+        def __call__(self, x1, x2, {opt_args:s}):
+            return numpy.ndarray([0, 0])
+
+    # Constants
+    e = 2.718281828459045
+    euler_gamma = 0.5772156649015329
+
+    # One arg functions with optional kwargs
+    arccos = FakeUfuncOneArg()
+    arccosh = FakeUfuncOneArg()
+    arcsin = FakeUfuncOneArg()
+    arcsinh = FakeUfuncOneArg()
+    arctan = FakeUfuncOneArg()
+    arctanh = FakeUfuncOneArg()
+    cbrt = FakeUfuncOneArg()
+    conj = FakeUfuncOneArg()
+    conjugate = FakeUfuncOneArg()
+    cosh = FakeUfuncOneArg()
+    deg2rad = FakeUfuncOneArg()
+    degrees = FakeUfuncOneArg()
+    exp2 = FakeUfuncOneArg()
+    expm1 = FakeUfuncOneArg()
+    fabs = FakeUfuncOneArg()
+    frexp = FakeUfuncOneArgBis()
+    isfinite = FakeUfuncOneArg()
+    isinf = FakeUfuncOneArg()
+    log = FakeUfuncOneArg()
+    log1p = FakeUfuncOneArg()
+    log2 = FakeUfuncOneArg()
+    logical_not = FakeUfuncOneArg()
+    modf = FakeUfuncOneArgBis()
+    negative = FakeUfuncOneArg()
+    positive = FakeUfuncOneArg()
+    rad2deg = FakeUfuncOneArg()
+    radians = FakeUfuncOneArg()
+    reciprocal = FakeUfuncOneArg()
+    rint = FakeUfuncOneArg()
+    sign = FakeUfuncOneArg()
+    signbit = FakeUfuncOneArg()
+    sinh = FakeUfuncOneArg()
+    spacing = FakeUfuncOneArg()
+    square = FakeUfuncOneArg()
+    tan = FakeUfuncOneArg()
+    tanh = FakeUfuncOneArg()
+    trunc = FakeUfuncOneArg()
+
+    # Two args functions with optional kwargs
+    add = FakeUfuncTwoArgs()
+    bitwise_and = FakeUfuncTwoArgs()
+    bitwise_or = FakeUfuncTwoArgs()
+    bitwise_xor = FakeUfuncTwoArgs()
+    copysign = FakeUfuncTwoArgs()
+    divide = FakeUfuncTwoArgs()
+    divmod = FakeUfuncTwoArgs()
+    equal = FakeUfuncTwoArgs()
+    float_power = FakeUfuncTwoArgs()
+    floor_divide = FakeUfuncTwoArgs()
+    fmax = FakeUfuncTwoArgs()
+    fmin = FakeUfuncTwoArgs()
+    fmod = FakeUfuncTwoArgs()
+    greater = FakeUfuncTwoArgs()
+    gcd = FakeUfuncTwoArgs()
+    hypot = FakeUfuncTwoArgs()
+    heaviside = FakeUfuncTwoArgs()
+    lcm = FakeUfuncTwoArgs()
+    ldexp = FakeUfuncTwoArgs()
+    left_shift = FakeUfuncTwoArgs()
+    less = FakeUfuncTwoArgs()
+    logaddexp = FakeUfuncTwoArgs()
+    logaddexp2 = FakeUfuncTwoArgs()
+    logical_and = FakeUfuncTwoArgs()
+    logical_or = FakeUfuncTwoArgs()
+    logical_xor = FakeUfuncTwoArgs()
+    maximum = FakeUfuncTwoArgs()
+    minimum = FakeUfuncTwoArgs()
+    multiply = FakeUfuncTwoArgs()
+    nextafter = FakeUfuncTwoArgs()
+    not_equal = FakeUfuncTwoArgs()
+    power = FakeUfuncTwoArgs()
+    remainder = FakeUfuncTwoArgs()
+    right_shift = FakeUfuncTwoArgs()
+    subtract = FakeUfuncTwoArgs()
+    true_divide = FakeUfuncTwoArgs()
+    """.format(
+            opt_args=ufunc_optional_keyword_arguments
+        )
+    )
+
+
+register_module_extender(
+    AstroidManager(), "numpy.core.umath", numpy_core_umath_transform
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_ma.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_ma.py
new file mode 100644
index 0000000..241665c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_ma.py
@@ -0,0 +1,28 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for numpy ma module"""
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def numpy_ma_transform():
+    """
+    Infer the call of the masked_where function
+
+    :param node: node to infer
+    :param context: inference context
+    """
+    return parse(
+        """
+    import numpy.ma
+    def masked_where(condition, a, copy=True):
+        return numpy.ma.masked_array(a, mask=[])
+    """
+    )
+
+
+register_module_extender(AstroidManager(), "numpy.ma", numpy_ma_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_ndarray.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_ndarray.py
new file mode 100644
index 0000000..f9b611e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_ndarray.py
@@ -0,0 +1,159 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for numpy ndarray class."""
+from astroid.brain.brain_numpy_utils import numpy_supports_type_hints
+from astroid.builder import extract_node
+from astroid.inference_tip import inference_tip
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import Attribute
+
+
+def infer_numpy_ndarray(node, context=None):
+    ndarray = """
+    class ndarray(object):
+        def __init__(self, shape, dtype=float, buffer=None, offset=0,
+                     strides=None, order=None):
+            self.T = numpy.ndarray([0, 0])
+            self.base = None
+            self.ctypes = None
+            self.data = None
+            self.dtype = None
+            self.flags = None
+            # Should be a numpy.flatiter instance but not available for now
+            # Putting an array instead so that iteration and indexing are authorized
+            self.flat = np.ndarray([0, 0])
+            self.imag = np.ndarray([0, 0])
+            self.itemsize = None
+            self.nbytes = None
+            self.ndim = None
+            self.real = np.ndarray([0, 0])
+            self.shape = numpy.ndarray([0, 0])
+            self.size = None
+            self.strides = None
+
+        def __abs__(self): return numpy.ndarray([0, 0])
+        def __add__(self, value): return numpy.ndarray([0, 0])
+        def __and__(self, value): return numpy.ndarray([0, 0])
+        def __array__(self, dtype=None): return numpy.ndarray([0, 0])
+        def __array_wrap__(self, obj): return numpy.ndarray([0, 0])
+        def __contains__(self, key): return True
+        def __copy__(self): return numpy.ndarray([0, 0])
+        def __deepcopy__(self, memo): return numpy.ndarray([0, 0])
+        def __divmod__(self, value): return (numpy.ndarray([0, 0]), numpy.ndarray([0, 0]))
+        def __eq__(self, value): return numpy.ndarray([0, 0])
+        def __float__(self): return 0.
+        def __floordiv__(self): return numpy.ndarray([0, 0])
+        def __ge__(self, value): return numpy.ndarray([0, 0])
+        def __getitem__(self, key): return uninferable
+        def __gt__(self, value): return numpy.ndarray([0, 0])
+        def __iadd__(self, value): return numpy.ndarray([0, 0])
+        def __iand__(self, value): return numpy.ndarray([0, 0])
+        def __ifloordiv__(self, value): return numpy.ndarray([0, 0])
+        def __ilshift__(self, value): return numpy.ndarray([0, 0])
+        def __imod__(self, value): return numpy.ndarray([0, 0])
+        def __imul__(self, value): return numpy.ndarray([0, 0])
+        def __int__(self): return 0
+        def __invert__(self): return numpy.ndarray([0, 0])
+        def __ior__(self, value): return numpy.ndarray([0, 0])
+        def __ipow__(self, value): return numpy.ndarray([0, 0])
+        def __irshift__(self, value): return numpy.ndarray([0, 0])
+        def __isub__(self, value): return numpy.ndarray([0, 0])
+        def __itruediv__(self, value): return numpy.ndarray([0, 0])
+        def __ixor__(self, value): return numpy.ndarray([0, 0])
+        def __le__(self, value): return numpy.ndarray([0, 0])
+        def __len__(self): return 1
+        def __lshift__(self, value): return numpy.ndarray([0, 0])
+        def __lt__(self, value): return numpy.ndarray([0, 0])
+        def __matmul__(self, value): return numpy.ndarray([0, 0])
+        def __mod__(self, value): return numpy.ndarray([0, 0])
+        def __mul__(self, value): return numpy.ndarray([0, 0])
+        def __ne__(self, value): return numpy.ndarray([0, 0])
+        def __neg__(self): return numpy.ndarray([0, 0])
+        def __or__(self, value): return numpy.ndarray([0, 0])
+        def __pos__(self): return numpy.ndarray([0, 0])
+        def __pow__(self): return numpy.ndarray([0, 0])
+        def __repr__(self): return str()
+        def __rshift__(self): return numpy.ndarray([0, 0])
+        def __setitem__(self, key, value): return uninferable
+        def __str__(self): return str()
+        def __sub__(self, value): return numpy.ndarray([0, 0])
+        def __truediv__(self, value): return numpy.ndarray([0, 0])
+        def __xor__(self, value): return numpy.ndarray([0, 0])
+        def all(self, axis=None, out=None, keepdims=False): return np.ndarray([0, 0])
+        def any(self, axis=None, out=None, keepdims=False): return np.ndarray([0, 0])
+        def argmax(self, axis=None, out=None): return np.ndarray([0, 0])
+        def argmin(self, axis=None, out=None): return np.ndarray([0, 0])
+        def argpartition(self, kth, axis=-1, kind='introselect', order=None): return np.ndarray([0, 0])
+        def argsort(self, axis=-1, kind='quicksort', order=None): return np.ndarray([0, 0])
+        def astype(self, dtype, order='K', casting='unsafe', subok=True, copy=True): return np.ndarray([0, 0])
+        def byteswap(self, inplace=False): return np.ndarray([0, 0])
+        def choose(self, choices, out=None, mode='raise'): return np.ndarray([0, 0])
+        def clip(self, min=None, max=None, out=None): return np.ndarray([0, 0])
+        def compress(self, condition, axis=None, out=None): return np.ndarray([0, 0])
+        def conj(self): return np.ndarray([0, 0])
+        def conjugate(self): return np.ndarray([0, 0])
+        def copy(self, order='C'): return np.ndarray([0, 0])
+        def cumprod(self, axis=None, dtype=None, out=None): return np.ndarray([0, 0])
+        def cumsum(self, axis=None, dtype=None, out=None): return np.ndarray([0, 0])
+        def diagonal(self, offset=0, axis1=0, axis2=1): return np.ndarray([0, 0])
+        def dot(self, b, out=None): return np.ndarray([0, 0])
+        def dump(self, file): return None
+        def dumps(self): return str()
+        def fill(self, value): return None
+        def flatten(self, order='C'): return np.ndarray([0, 0])
+        def getfield(self, dtype, offset=0): return np.ndarray([0, 0])
+        def item(self, *args): return uninferable
+        def itemset(self, *args): return None
+        def max(self, axis=None, out=None): return np.ndarray([0, 0])
+        def mean(self, axis=None, dtype=None, out=None, keepdims=False): return np.ndarray([0, 0])
+        def min(self, axis=None, out=None, keepdims=False): return np.ndarray([0, 0])
+        def newbyteorder(self, new_order='S'): return np.ndarray([0, 0])
+        def nonzero(self): return (1,)
+        def partition(self, kth, axis=-1, kind='introselect', order=None): return None
+        def prod(self, axis=None, dtype=None, out=None, keepdims=False): return np.ndarray([0, 0])
+        def ptp(self, axis=None, out=None): return np.ndarray([0, 0])
+        def put(self, indices, values, mode='raise'): return None
+        def ravel(self, order='C'): return np.ndarray([0, 0])
+        def repeat(self, repeats, axis=None): return np.ndarray([0, 0])
+        def reshape(self, shape, order='C'): return np.ndarray([0, 0])
+        def resize(self, new_shape, refcheck=True): return None
+        def round(self, decimals=0, out=None): return np.ndarray([0, 0])
+        def searchsorted(self, v, side='left', sorter=None): return np.ndarray([0, 0])
+        def setfield(self, val, dtype, offset=0): return None
+        def setflags(self, write=None, align=None, uic=None): return None
+        def sort(self, axis=-1, kind='quicksort', order=None): return None
+        def squeeze(self, axis=None): return np.ndarray([0, 0])
+        def std(self, axis=None, dtype=None, out=None, ddof=0, keepdims=False): return np.ndarray([0, 0])
+        def sum(self, axis=None, dtype=None, out=None, keepdims=False): return np.ndarray([0, 0])
+        def swapaxes(self, axis1, axis2): return np.ndarray([0, 0])
+        def take(self, indices, axis=None, out=None, mode='raise'): return np.ndarray([0, 0])
+        def tobytes(self, order='C'): return b''
+        def tofile(self, fid, sep="", format="%s"): return None
+        def tolist(self, ): return []
+        def tostring(self, order='C'): return b''
+        def trace(self, offset=0, axis1=0, axis2=1, dtype=None, out=None): return np.ndarray([0, 0])
+        def transpose(self, *axes): return np.ndarray([0, 0])
+        def var(self, axis=None, dtype=None, out=None, ddof=0, keepdims=False): return np.ndarray([0, 0])
+        def view(self, dtype=None, type=None): return np.ndarray([0, 0])
+    """
+    if numpy_supports_type_hints():
+        ndarray += """
+        @classmethod
+        def __class_getitem__(cls, value):
+            return cls
+        """
+    node = extract_node(ndarray)
+    return node.infer(context=context)
+
+
+def _looks_like_numpy_ndarray(node):
+    return isinstance(node, Attribute) and node.attrname == "ndarray"
+
+
+AstroidManager().register_transform(
+    Attribute,
+    inference_tip(infer_numpy_ndarray),
+    _looks_like_numpy_ndarray,
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_random_mtrand.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_random_mtrand.py
new file mode 100644
index 0000000..b1f0d45
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_random_mtrand.py
@@ -0,0 +1,71 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+# TODO(hippo91) : correct the functions return types
+"""Astroid hooks for numpy.random.mtrand module."""
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def numpy_random_mtrand_transform():
+    return parse(
+        """
+    def beta(a, b, size=None): return uninferable
+    def binomial(n, p, size=None): return uninferable
+    def bytes(length): return uninferable
+    def chisquare(df, size=None): return uninferable
+    def choice(a, size=None, replace=True, p=None): return uninferable
+    def dirichlet(alpha, size=None): return uninferable
+    def exponential(scale=1.0, size=None): return uninferable
+    def f(dfnum, dfden, size=None): return uninferable
+    def gamma(shape, scale=1.0, size=None): return uninferable
+    def geometric(p, size=None): return uninferable
+    def get_state(): return uninferable
+    def gumbel(loc=0.0, scale=1.0, size=None): return uninferable
+    def hypergeometric(ngood, nbad, nsample, size=None): return uninferable
+    def laplace(loc=0.0, scale=1.0, size=None): return uninferable
+    def logistic(loc=0.0, scale=1.0, size=None): return uninferable
+    def lognormal(mean=0.0, sigma=1.0, size=None): return uninferable
+    def logseries(p, size=None): return uninferable
+    def multinomial(n, pvals, size=None): return uninferable
+    def multivariate_normal(mean, cov, size=None): return uninferable
+    def negative_binomial(n, p, size=None): return uninferable
+    def noncentral_chisquare(df, nonc, size=None): return uninferable
+    def noncentral_f(dfnum, dfden, nonc, size=None): return uninferable
+    def normal(loc=0.0, scale=1.0, size=None): return uninferable
+    def pareto(a, size=None): return uninferable
+    def permutation(x): return uninferable
+    def poisson(lam=1.0, size=None): return uninferable
+    def power(a, size=None): return uninferable
+    def rand(*args): return uninferable
+    def randint(low, high=None, size=None, dtype='l'):
+        import numpy
+        return numpy.ndarray((1,1))
+    def randn(*args): return uninferable
+    def random(size=None): return uninferable
+    def random_integers(low, high=None, size=None): return uninferable
+    def random_sample(size=None): return uninferable
+    def rayleigh(scale=1.0, size=None): return uninferable
+    def seed(seed=None): return uninferable
+    def set_state(state): return uninferable
+    def shuffle(x): return uninferable
+    def standard_cauchy(size=None): return uninferable
+    def standard_exponential(size=None): return uninferable
+    def standard_gamma(shape, size=None): return uninferable
+    def standard_normal(size=None): return uninferable
+    def standard_t(df, size=None): return uninferable
+    def triangular(left, mode, right, size=None): return uninferable
+    def uniform(low=0.0, high=1.0, size=None): return uninferable
+    def vonmises(mu, kappa, size=None): return uninferable
+    def wald(mean, scale, size=None): return uninferable
+    def weibull(a, size=None): return uninferable
+    def zipf(a, size=None): return uninferable
+    """
+    )
+
+
+register_module_extender(
+    AstroidManager(), "numpy.random.mtrand", numpy_random_mtrand_transform
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_utils.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_utils.py
new file mode 100644
index 0000000..c32d6d6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_numpy_utils.py
@@ -0,0 +1,85 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Different utilities for the numpy brains"""
+from typing import Tuple
+
+from astroid.builder import extract_node
+from astroid.nodes.node_classes import Attribute, Import, Name, NodeNG
+
+# Class subscript is available in numpy starting with version 1.20.0
+NUMPY_VERSION_TYPE_HINTS_SUPPORT = ("1", "20", "0")
+
+
+def numpy_supports_type_hints() -> bool:
+    """
+    Returns True if numpy supports type hints
+    """
+    np_ver = _get_numpy_version()
+    return np_ver and np_ver > NUMPY_VERSION_TYPE_HINTS_SUPPORT
+
+
+def _get_numpy_version() -> Tuple[str, str, str]:
+    """
+    Return the numpy version number if numpy can be imported. Otherwise returns
+    ('0', '0', '0')
+    """
+    try:
+        import numpy  # pylint: disable=import-outside-toplevel
+
+        return tuple(numpy.version.version.split("."))
+    except ImportError:
+        return ("0", "0", "0")
+
+
+def infer_numpy_member(src, node, context=None):
+    node = extract_node(src)
+    return node.infer(context=context)
+
+
+def _is_a_numpy_module(node: Name) -> bool:
+    """
+    Returns True if the node is a representation of a numpy module.
+
+    For example in :
+        import numpy as np
+        x = np.linspace(1, 2)
+    The node <Name.np> is a representation of the numpy module.
+
+    :param node: node to test
+    :return: True if the node is a representation of the numpy module.
+    """
+    module_nickname = node.name
+    potential_import_target = [
+        x for x in node.lookup(module_nickname)[1] if isinstance(x, Import)
+    ]
+    return any(
+        ("numpy", module_nickname) in target.names or ("numpy", None) in target.names
+        for target in potential_import_target
+    )
+
+
+def looks_like_numpy_member(member_name: str, node: NodeNG) -> bool:
+    """
+    Returns True if the node is a member of numpy whose
+    name is member_name.
+
+    :param member_name: name of the member
+    :param node: node to test
+    :return: True if the node is a member of numpy
+    """
+    if (
+        isinstance(node, Attribute)
+        and node.attrname == member_name
+        and isinstance(node.expr, Name)
+        and _is_a_numpy_module(node.expr)
+    ):
+        return True
+    if (
+        isinstance(node, Name)
+        and node.name == member_name
+        and node.root().name.startswith("numpy")
+    ):
+        return True
+    return False
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_pkg_resources.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_pkg_resources.py
new file mode 100644
index 0000000..689dd74
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_pkg_resources.py
@@ -0,0 +1,70 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid import parse
+from astroid.brain.helpers import register_module_extender
+from astroid.manager import AstroidManager
+
+
+def pkg_resources_transform():
+    return parse(
+        """
+def require(*requirements):
+    return pkg_resources.working_set.require(*requirements)
+
+def run_script(requires, script_name):
+    return pkg_resources.working_set.run_script(requires, script_name)
+
+def iter_entry_points(group, name=None):
+    return pkg_resources.working_set.iter_entry_points(group, name)
+
+def resource_exists(package_or_requirement, resource_name):
+    return get_provider(package_or_requirement).has_resource(resource_name)
+
+def resource_isdir(package_or_requirement, resource_name):
+    return get_provider(package_or_requirement).resource_isdir(
+        resource_name)
+
+def resource_filename(package_or_requirement, resource_name):
+    return get_provider(package_or_requirement).get_resource_filename(
+        self, resource_name)
+
+def resource_stream(package_or_requirement, resource_name):
+    return get_provider(package_or_requirement).get_resource_stream(
+        self, resource_name)
+
+def resource_string(package_or_requirement, resource_name):
+    return get_provider(package_or_requirement).get_resource_string(
+        self, resource_name)
+
+def resource_listdir(package_or_requirement, resource_name):
+    return get_provider(package_or_requirement).resource_listdir(
+        resource_name)
+
+def extraction_error():
+    pass
+
+def get_cache_path(archive_name, names=()):
+    extract_path = self.extraction_path or get_default_cache()
+    target_path = os.path.join(extract_path, archive_name+'-tmp', *names)
+    return target_path
+
+def postprocess(tempname, filename):
+    pass
+
+def set_extraction_path(path):
+    pass
+
+def cleanup_resources(force=False):
+    pass
+
+def get_distribution(dist):
+    return Distribution(dist)
+
+_namespace_packages = {}
+"""
+    )
+
+
+register_module_extender(AstroidManager(), "pkg_resources", pkg_resources_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_pytest.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_pytest.py
new file mode 100644
index 0000000..78c9779
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_pytest.py
@@ -0,0 +1,83 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for pytest."""
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import AstroidBuilder
+from astroid.manager import AstroidManager
+
+
+def pytest_transform():
+    return AstroidBuilder(AstroidManager()).string_build(
+        """
+
+try:
+    import _pytest.mark
+    import _pytest.recwarn
+    import _pytest.runner
+    import _pytest.python
+    import _pytest.skipping
+    import _pytest.assertion
+except ImportError:
+    pass
+else:
+    deprecated_call = _pytest.recwarn.deprecated_call
+    warns = _pytest.recwarn.warns
+
+    exit = _pytest.runner.exit
+    fail = _pytest.runner.fail
+    skip = _pytest.runner.skip
+    importorskip = _pytest.runner.importorskip
+
+    xfail = _pytest.skipping.xfail
+    mark = _pytest.mark.MarkGenerator()
+    raises = _pytest.python.raises
+
+    # New in pytest 3.0
+    try:
+        approx = _pytest.python.approx
+        register_assert_rewrite = _pytest.assertion.register_assert_rewrite
+    except AttributeError:
+        pass
+
+
+# Moved in pytest 3.0
+
+try:
+    import _pytest.freeze_support
+    freeze_includes = _pytest.freeze_support.freeze_includes
+except ImportError:
+    try:
+        import _pytest.genscript
+        freeze_includes = _pytest.genscript.freeze_includes
+    except ImportError:
+        pass
+
+try:
+    import _pytest.debugging
+    set_trace = _pytest.debugging.pytestPDB().set_trace
+except ImportError:
+    try:
+        import _pytest.pdb
+        set_trace = _pytest.pdb.pytestPDB().set_trace
+    except ImportError:
+        pass
+
+try:
+    import _pytest.fixtures
+    fixture = _pytest.fixtures.fixture
+    yield_fixture = _pytest.fixtures.yield_fixture
+except ImportError:
+    try:
+        import _pytest.python
+        fixture = _pytest.python.fixture
+        yield_fixture = _pytest.python.yield_fixture
+    except ImportError:
+        pass
+"""
+    )
+
+
+register_module_extender(AstroidManager(), "pytest", pytest_transform)
+register_module_extender(AstroidManager(), "py.test", pytest_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_qt.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_qt.py
new file mode 100644
index 0000000..6b97bf6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_qt.py
@@ -0,0 +1,82 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for the PyQT library."""
+
+from astroid import nodes, parse
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import AstroidBuilder
+from astroid.manager import AstroidManager
+
+
+def _looks_like_signal(node, signal_name="pyqtSignal"):
+    if "__class__" in node.instance_attrs:
+        try:
+            cls = node.instance_attrs["__class__"][0]
+            return cls.name == signal_name
+        except AttributeError:
+            # return False if the cls does not have a name attribute
+            pass
+    return False
+
+
+def transform_pyqt_signal(node: nodes.FunctionDef) -> None:
+    module = parse(
+        """
+    _UNSET = object()
+
+    class pyqtSignal(object):
+        def connect(self, slot, type=None, no_receiver_check=False):
+            pass
+        def disconnect(self, slot=_UNSET):
+            pass
+        def emit(self, *args):
+            pass
+    """
+    )
+    signal_cls: nodes.ClassDef = module["pyqtSignal"]
+    node.instance_attrs["emit"] = [signal_cls["emit"]]
+    node.instance_attrs["disconnect"] = [signal_cls["disconnect"]]
+    node.instance_attrs["connect"] = [signal_cls["connect"]]
+
+
+def transform_pyside_signal(node: nodes.FunctionDef) -> None:
+    module = parse(
+        """
+    class NotPySideSignal(object):
+        def connect(self, receiver, type=None):
+            pass
+        def disconnect(self, receiver):
+            pass
+        def emit(self, *args):
+            pass
+    """
+    )
+    signal_cls: nodes.ClassDef = module["NotPySideSignal"]
+    node.instance_attrs["connect"] = [signal_cls["connect"]]
+    node.instance_attrs["disconnect"] = [signal_cls["disconnect"]]
+    node.instance_attrs["emit"] = [signal_cls["emit"]]
+
+
+def pyqt4_qtcore_transform():
+    return AstroidBuilder(AstroidManager()).string_build(
+        """
+
+def SIGNAL(signal_name): pass
+
+class QObject(object):
+    def emit(self, signal): pass
+"""
+    )
+
+
+register_module_extender(AstroidManager(), "PyQt4.QtCore", pyqt4_qtcore_transform)
+AstroidManager().register_transform(
+    nodes.FunctionDef, transform_pyqt_signal, _looks_like_signal
+)
+AstroidManager().register_transform(
+    nodes.ClassDef,
+    transform_pyside_signal,
+    lambda node: node.qname() in {"PySide.QtCore.Signal", "PySide2.QtCore.Signal"},
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_random.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_random.py
new file mode 100644
index 0000000..e66aa81
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_random.py
@@ -0,0 +1,87 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+import random
+
+from astroid import helpers
+from astroid.exceptions import UseInferenceDefault
+from astroid.inference_tip import inference_tip
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import (
+    Attribute,
+    Call,
+    Const,
+    EvaluatedObject,
+    List,
+    Name,
+    Set,
+    Tuple,
+)
+
+ACCEPTED_ITERABLES_FOR_SAMPLE = (List, Set, Tuple)
+
+
+def _clone_node_with_lineno(node, parent, lineno):
+    if isinstance(node, EvaluatedObject):
+        node = node.original
+    cls = node.__class__
+    other_fields = node._other_fields
+    _astroid_fields = node._astroid_fields
+    init_params = {"lineno": lineno, "col_offset": node.col_offset, "parent": parent}
+    postinit_params = {param: getattr(node, param) for param in _astroid_fields}
+    if other_fields:
+        init_params.update({param: getattr(node, param) for param in other_fields})
+    new_node = cls(**init_params)
+    if hasattr(node, "postinit") and _astroid_fields:
+        new_node.postinit(**postinit_params)
+    return new_node
+
+
+def infer_random_sample(node, context=None):
+    if len(node.args) != 2:
+        raise UseInferenceDefault
+
+    length = node.args[1]
+    if not isinstance(length, Const):
+        raise UseInferenceDefault
+    if not isinstance(length.value, int):
+        raise UseInferenceDefault
+
+    inferred_sequence = helpers.safe_infer(node.args[0], context=context)
+    if not inferred_sequence:
+        raise UseInferenceDefault
+
+    if not isinstance(inferred_sequence, ACCEPTED_ITERABLES_FOR_SAMPLE):
+        raise UseInferenceDefault
+
+    if length.value > len(inferred_sequence.elts):
+        # In this case, this will raise a ValueError
+        raise UseInferenceDefault
+
+    try:
+        elts = random.sample(inferred_sequence.elts, length.value)
+    except ValueError as exc:
+        raise UseInferenceDefault from exc
+
+    new_node = List(lineno=node.lineno, col_offset=node.col_offset, parent=node.scope())
+    new_elts = [
+        _clone_node_with_lineno(elt, parent=new_node, lineno=new_node.lineno)
+        for elt in elts
+    ]
+    new_node.postinit(new_elts)
+    return iter((new_node,))
+
+
+def _looks_like_random_sample(node):
+    func = node.func
+    if isinstance(func, Attribute):
+        return func.attrname == "sample"
+    if isinstance(func, Name):
+        return func.name == "sample"
+    return False
+
+
+AstroidManager().register_transform(
+    Call, inference_tip(infer_random_sample), _looks_like_random_sample
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_re.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_re.py
new file mode 100644
index 0000000..0dd346a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_re.py
@@ -0,0 +1,90 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from typing import Optional
+
+from astroid import context, inference_tip, nodes
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import _extract_single_node, parse
+from astroid.const import PY37_PLUS, PY39_PLUS
+from astroid.manager import AstroidManager
+
+
+def _re_transform():
+    # Since Python 3.6 there is the RegexFlag enum
+    # where every entry will be exposed via updating globals()
+    return parse(
+        """
+    import sre_compile
+    ASCII = sre_compile.SRE_FLAG_ASCII
+    IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE
+    LOCALE = sre_compile.SRE_FLAG_LOCALE
+    UNICODE = sre_compile.SRE_FLAG_UNICODE
+    MULTILINE = sre_compile.SRE_FLAG_MULTILINE
+    DOTALL = sre_compile.SRE_FLAG_DOTALL
+    VERBOSE = sre_compile.SRE_FLAG_VERBOSE
+    A = ASCII
+    I = IGNORECASE
+    L = LOCALE
+    U = UNICODE
+    M = MULTILINE
+    S = DOTALL
+    X = VERBOSE
+    TEMPLATE = sre_compile.SRE_FLAG_TEMPLATE
+    T = TEMPLATE
+    DEBUG = sre_compile.SRE_FLAG_DEBUG
+    """
+    )
+
+
+register_module_extender(AstroidManager(), "re", _re_transform)
+
+
+CLASS_GETITEM_TEMPLATE = """
+@classmethod
+def __class_getitem__(cls, item):
+    return cls
+"""
+
+
+def _looks_like_pattern_or_match(node: nodes.Call) -> bool:
+    """Check for re.Pattern or re.Match call in stdlib.
+
+    Match these patterns from stdlib/re.py
+    ```py
+    Pattern = type(...)
+    Match = type(...)
+    ```
+    """
+    return (
+        node.root().name == "re"
+        and isinstance(node.func, nodes.Name)
+        and node.func.name == "type"
+        and isinstance(node.parent, nodes.Assign)
+        and len(node.parent.targets) == 1
+        and isinstance(node.parent.targets[0], nodes.AssignName)
+        and node.parent.targets[0].name in {"Pattern", "Match"}
+    )
+
+
+def infer_pattern_match(
+    node: nodes.Call, ctx: Optional[context.InferenceContext] = None
+):
+    """Infer re.Pattern and re.Match as classes. For PY39+ add `__class_getitem__`."""
+    class_def = nodes.ClassDef(
+        name=node.parent.targets[0].name,
+        lineno=node.lineno,
+        col_offset=node.col_offset,
+        parent=node.parent,
+    )
+    if PY39_PLUS:
+        func_to_add = _extract_single_node(CLASS_GETITEM_TEMPLATE)
+        class_def.locals["__class_getitem__"] = [func_to_add]
+    return iter([class_def])
+
+
+if PY37_PLUS:
+    AstroidManager().register_transform(
+        nodes.Call, inference_tip(infer_pattern_match), _looks_like_pattern_or_match
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_responses.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_responses.py
new file mode 100644
index 0000000..0fb0e42
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_responses.py
@@ -0,0 +1,79 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""
+Astroid hooks for responses.
+
+It might need to be manually updated from the public methods of
+:class:`responses.RequestsMock`.
+
+See: https://github.com/getsentry/responses/blob/master/responses.py
+
+"""
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def responses_funcs():
+    return parse(
+        """
+        DELETE = "DELETE"
+        GET = "GET"
+        HEAD = "HEAD"
+        OPTIONS = "OPTIONS"
+        PATCH = "PATCH"
+        POST = "POST"
+        PUT = "PUT"
+        response_callback = None
+
+        def reset():
+            return
+
+        def add(
+            method=None,  # method or ``Response``
+            url=None,
+            body="",
+            adding_headers=None,
+            *args,
+            **kwargs
+        ):
+            return
+
+        def add_passthru(prefix):
+            return
+
+        def remove(method_or_response=None, url=None):
+            return
+
+        def replace(method_or_response=None, url=None, body="", *args, **kwargs):
+            return
+
+        def add_callback(
+            method, url, callback, match_querystring=False, content_type="text/plain"
+        ):
+            return
+
+        calls = []
+
+        def __enter__():
+            return
+
+        def __exit__(type, value, traceback):
+            success = type is None
+            return success
+
+        def activate(func):
+            return func
+
+        def start():
+            return
+
+        def stop(allow_assert=True):
+            return
+        """
+    )
+
+
+register_module_extender(AstroidManager(), "responses", responses_funcs)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_scipy_signal.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_scipy_signal.py
new file mode 100644
index 0000000..578022f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_scipy_signal.py
@@ -0,0 +1,88 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for scipy.signal module."""
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def scipy_signal():
+    return parse(
+        """
+    # different functions defined in scipy.signals
+
+    def barthann(M, sym=True):
+        return numpy.ndarray([0])
+
+    def bartlett(M, sym=True):
+        return numpy.ndarray([0])
+
+    def blackman(M, sym=True):
+        return numpy.ndarray([0])
+
+    def blackmanharris(M, sym=True):
+        return numpy.ndarray([0])
+
+    def bohman(M, sym=True):
+        return numpy.ndarray([0])
+
+    def boxcar(M, sym=True):
+        return numpy.ndarray([0])
+
+    def chebwin(M, at, sym=True):
+        return numpy.ndarray([0])
+
+    def cosine(M, sym=True):
+        return numpy.ndarray([0])
+
+    def exponential(M, center=None, tau=1.0, sym=True):
+        return numpy.ndarray([0])
+
+    def flattop(M, sym=True):
+        return numpy.ndarray([0])
+
+    def gaussian(M, std, sym=True):
+        return numpy.ndarray([0])
+
+    def general_gaussian(M, p, sig, sym=True):
+        return numpy.ndarray([0])
+
+    def hamming(M, sym=True):
+        return numpy.ndarray([0])
+
+    def hann(M, sym=True):
+        return numpy.ndarray([0])
+
+    def hanning(M, sym=True):
+        return numpy.ndarray([0])
+
+    def impulse2(system, X0=None, T=None, N=None, **kwargs):
+        return numpy.ndarray([0]), numpy.ndarray([0])
+
+    def kaiser(M, beta, sym=True):
+        return numpy.ndarray([0])
+
+    def nuttall(M, sym=True):
+        return numpy.ndarray([0])
+
+    def parzen(M, sym=True):
+        return numpy.ndarray([0])
+
+    def slepian(M, width, sym=True):
+        return numpy.ndarray([0])
+
+    def step2(system, X0=None, T=None, N=None, **kwargs):
+        return numpy.ndarray([0]), numpy.ndarray([0])
+
+    def triang(M, sym=True):
+        return numpy.ndarray([0])
+
+    def tukey(M, alpha=0.5, sym=True):
+        return numpy.ndarray([0])
+        """
+    )
+
+
+register_module_extender(AstroidManager(), "scipy.signal", scipy_signal)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_signal.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_signal.py
new file mode 100644
index 0000000..5eee7f6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_signal.py
@@ -0,0 +1,119 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for the signal library.
+
+The signal module generates the 'Signals', 'Handlers' and 'Sigmasks' IntEnums
+dynamically using the IntEnum._convert() classmethod, which modifies the module
+globals. Astroid is unable to handle this type of code.
+
+Without these hooks, the following are erroneously triggered by Pylint:
+    * E1101: Module 'signal' has no 'Signals' member (no-member)
+    * E1101: Module 'signal' has no 'Handlers' member (no-member)
+    * E1101: Module 'signal' has no 'Sigmasks' member (no-member)
+
+These enums are defined slightly differently depending on the user's operating
+system and platform. These platform differences should follow the current
+Python typeshed stdlib `signal.pyi` stub file, available at:
+
+* https://github.com/python/typeshed/blob/master/stdlib/signal.pyi
+
+Note that the enum.auto() values defined here for the Signals, Handlers and
+Sigmasks IntEnums are just dummy integer values, and do not correspond to the
+actual standard signal numbers - which may vary depending on the system.
+"""
+
+
+import sys
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def _signals_enums_transform():
+    """Generates the AST for 'Signals', 'Handlers' and 'Sigmasks' IntEnums."""
+    return parse(_signals_enum() + _handlers_enum() + _sigmasks_enum())
+
+
+def _signals_enum():
+    """Generates the source code for the Signals int enum."""
+    signals_enum = """
+    import enum
+    class Signals(enum.IntEnum):
+        SIGABRT   = enum.auto()
+        SIGEMT    = enum.auto()
+        SIGFPE    = enum.auto()
+        SIGILL    = enum.auto()
+        SIGINFO   = enum.auto()
+        SIGINT    = enum.auto()
+        SIGSEGV   = enum.auto()
+        SIGTERM   = enum.auto()
+    """
+    if sys.platform != "win32":
+        signals_enum += """
+        SIGALRM   = enum.auto()
+        SIGBUS    = enum.auto()
+        SIGCHLD   = enum.auto()
+        SIGCONT   = enum.auto()
+        SIGHUP    = enum.auto()
+        SIGIO     = enum.auto()
+        SIGIOT    = enum.auto()
+        SIGKILL   = enum.auto()
+        SIGPIPE   = enum.auto()
+        SIGPROF   = enum.auto()
+        SIGQUIT   = enum.auto()
+        SIGSTOP   = enum.auto()
+        SIGSYS    = enum.auto()
+        SIGTRAP   = enum.auto()
+        SIGTSTP   = enum.auto()
+        SIGTTIN   = enum.auto()
+        SIGTTOU   = enum.auto()
+        SIGURG    = enum.auto()
+        SIGUSR1   = enum.auto()
+        SIGUSR2   = enum.auto()
+        SIGVTALRM = enum.auto()
+        SIGWINCH  = enum.auto()
+        SIGXCPU   = enum.auto()
+        SIGXFSZ   = enum.auto()
+        """
+    if sys.platform == "win32":
+        signals_enum += """
+        SIGBREAK  = enum.auto()
+        """
+    if sys.platform not in ("darwin", "win32"):
+        signals_enum += """
+        SIGCLD    = enum.auto()
+        SIGPOLL   = enum.auto()
+        SIGPWR    = enum.auto()
+        SIGRTMAX  = enum.auto()
+        SIGRTMIN  = enum.auto()
+        """
+    return signals_enum
+
+
+def _handlers_enum():
+    """Generates the source code for the Handlers int enum."""
+    return """
+    import enum
+    class Handlers(enum.IntEnum):
+        SIG_DFL = enum.auto()
+        SIG_IGN = eunm.auto()
+    """
+
+
+def _sigmasks_enum():
+    """Generates the source code for the Sigmasks int enum."""
+    if sys.platform != "win32":
+        return """
+    import enum
+    class Sigmasks(enum.IntEnum):
+        SIG_BLOCK   = enum.auto()
+        SIG_UNBLOCK = enum.auto()
+        SIG_SETMASK = enum.auto()
+        """
+    return ""
+
+
+register_module_extender(AstroidManager(), "signal", _signals_enums_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_six.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_six.py
new file mode 100644
index 0000000..022fcf2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_six.py
@@ -0,0 +1,239 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for six module."""
+
+from textwrap import dedent
+
+from astroid import nodes
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import AstroidBuilder
+from astroid.exceptions import (
+    AstroidBuildingError,
+    AttributeInferenceError,
+    InferenceError,
+)
+from astroid.manager import AstroidManager
+
+SIX_ADD_METACLASS = "six.add_metaclass"
+SIX_WITH_METACLASS = "six.with_metaclass"
+
+
+def default_predicate(line):
+    return line.strip()
+
+
+def _indent(text, prefix, predicate=default_predicate):
+    """Adds 'prefix' to the beginning of selected lines in 'text'.
+
+    If 'predicate' is provided, 'prefix' will only be added to the lines
+    where 'predicate(line)' is True. If 'predicate' is not provided,
+    it will default to adding 'prefix' to all non-empty lines that do not
+    consist solely of whitespace characters.
+    """
+
+    def prefixed_lines():
+        for line in text.splitlines(True):
+            yield prefix + line if predicate(line) else line
+
+    return "".join(prefixed_lines())
+
+
+_IMPORTS = """
+import _io
+cStringIO = _io.StringIO
+filter = filter
+from itertools import filterfalse
+input = input
+from sys import intern
+map = map
+range = range
+from importlib import reload
+reload_module = lambda module: reload(module)
+from functools import reduce
+from shlex import quote as shlex_quote
+from io import StringIO
+from collections import UserDict, UserList, UserString
+xrange = range
+zip = zip
+from itertools import zip_longest
+import builtins
+import configparser
+import copyreg
+import _dummy_thread
+import http.cookiejar as http_cookiejar
+import http.cookies as http_cookies
+import html.entities as html_entities
+import html.parser as html_parser
+import http.client as http_client
+import http.server as http_server
+BaseHTTPServer = CGIHTTPServer = SimpleHTTPServer = http.server
+import pickle as cPickle
+import queue
+import reprlib
+import socketserver
+import _thread
+import winreg
+import xmlrpc.server as xmlrpc_server
+import xmlrpc.client as xmlrpc_client
+import urllib.robotparser as urllib_robotparser
+import email.mime.multipart as email_mime_multipart
+import email.mime.nonmultipart as email_mime_nonmultipart
+import email.mime.text as email_mime_text
+import email.mime.base as email_mime_base
+import urllib.parse as urllib_parse
+import urllib.error as urllib_error
+import tkinter
+import tkinter.dialog as tkinter_dialog
+import tkinter.filedialog as tkinter_filedialog
+import tkinter.scrolledtext as tkinter_scrolledtext
+import tkinter.simpledialog as tkinder_simpledialog
+import tkinter.tix as tkinter_tix
+import tkinter.ttk as tkinter_ttk
+import tkinter.constants as tkinter_constants
+import tkinter.dnd as tkinter_dnd
+import tkinter.colorchooser as tkinter_colorchooser
+import tkinter.commondialog as tkinter_commondialog
+import tkinter.filedialog as tkinter_tkfiledialog
+import tkinter.font as tkinter_font
+import tkinter.messagebox as tkinter_messagebox
+import urllib
+import urllib.request as urllib_request
+import urllib.robotparser as urllib_robotparser
+import urllib.parse as urllib_parse
+import urllib.error as urllib_error
+"""
+
+
+def six_moves_transform():
+    code = dedent(
+        """
+    class Moves(object):
+    {}
+    moves = Moves()
+    """
+    ).format(_indent(_IMPORTS, "    "))
+    module = AstroidBuilder(AstroidManager()).string_build(code)
+    module.name = "six.moves"
+    return module
+
+
+def _six_fail_hook(modname):
+    """Fix six.moves imports due to the dynamic nature of this
+    class.
+
+    Construct a pseudo-module which contains all the necessary imports
+    for six
+
+    :param modname: Name of failed module
+    :type modname: str
+
+    :return: An astroid module
+    :rtype: nodes.Module
+    """
+
+    attribute_of = modname != "six.moves" and modname.startswith("six.moves")
+    if modname != "six.moves" and not attribute_of:
+        raise AstroidBuildingError(modname=modname)
+    module = AstroidBuilder(AstroidManager()).string_build(_IMPORTS)
+    module.name = "six.moves"
+    if attribute_of:
+        # Facilitate import of submodules in Moves
+        start_index = len(module.name)
+        attribute = modname[start_index:].lstrip(".").replace(".", "_")
+        try:
+            import_attr = module.getattr(attribute)[0]
+        except AttributeInferenceError as exc:
+            raise AstroidBuildingError(modname=modname) from exc
+        if isinstance(import_attr, nodes.Import):
+            submodule = AstroidManager().ast_from_module_name(import_attr.names[0][0])
+            return submodule
+    # Let dummy submodule imports pass through
+    # This will cause an Uninferable result, which is okay
+    return module
+
+
+def _looks_like_decorated_with_six_add_metaclass(node):
+    if not node.decorators:
+        return False
+
+    for decorator in node.decorators.nodes:
+        if not isinstance(decorator, nodes.Call):
+            continue
+        if decorator.func.as_string() == SIX_ADD_METACLASS:
+            return True
+    return False
+
+
+def transform_six_add_metaclass(node):  # pylint: disable=inconsistent-return-statements
+    """Check if the given class node is decorated with *six.add_metaclass*
+
+    If so, inject its argument as the metaclass of the underlying class.
+    """
+    if not node.decorators:
+        return
+
+    for decorator in node.decorators.nodes:
+        if not isinstance(decorator, nodes.Call):
+            continue
+
+        try:
+            func = next(decorator.func.infer())
+        except (InferenceError, StopIteration):
+            continue
+        if func.qname() == SIX_ADD_METACLASS and decorator.args:
+            metaclass = decorator.args[0]
+            node._metaclass = metaclass
+            return node
+    return
+
+
+def _looks_like_nested_from_six_with_metaclass(node):
+    if len(node.bases) != 1:
+        return False
+    base = node.bases[0]
+    if not isinstance(base, nodes.Call):
+        return False
+    try:
+        if hasattr(base.func, "expr"):
+            # format when explicit 'six.with_metaclass' is used
+            mod = base.func.expr.name
+            func = base.func.attrname
+            func = f"{mod}.{func}"
+        else:
+            # format when 'with_metaclass' is used directly (local import from six)
+            # check reference module to avoid 'with_metaclass' name clashes
+            mod = base.parent.parent
+            import_from = mod.locals["with_metaclass"][0]
+            func = f"{import_from.modname}.{base.func.name}"
+    except (AttributeError, KeyError, IndexError):
+        return False
+    return func == SIX_WITH_METACLASS
+
+
+def transform_six_with_metaclass(node):
+    """Check if the given class node is defined with *six.with_metaclass*
+
+    If so, inject its argument as the metaclass of the underlying class.
+    """
+    call = node.bases[0]
+    node._metaclass = call.args[0]
+    return node
+
+
+register_module_extender(AstroidManager(), "six", six_moves_transform)
+register_module_extender(
+    AstroidManager(), "requests.packages.urllib3.packages.six", six_moves_transform
+)
+AstroidManager().register_failed_import_hook(_six_fail_hook)
+AstroidManager().register_transform(
+    nodes.ClassDef,
+    transform_six_add_metaclass,
+    _looks_like_decorated_with_six_add_metaclass,
+)
+AstroidManager().register_transform(
+    nodes.ClassDef,
+    transform_six_with_metaclass,
+    _looks_like_nested_from_six_with_metaclass,
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_sqlalchemy.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_sqlalchemy.py
new file mode 100644
index 0000000..f3695de
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_sqlalchemy.py
@@ -0,0 +1,39 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def _session_transform():
+    return parse(
+        """
+    from sqlalchemy.orm.session import Session
+
+    class sessionmaker:
+        def __init__(
+            self,
+            bind=None,
+            class_=Session,
+            autoflush=True,
+            autocommit=False,
+            expire_on_commit=True,
+            info=None,
+            **kw
+        ):
+            return
+
+        def __call__(self, **local_kw):
+            return Session()
+
+        def configure(self, **new_kw):
+            return
+
+        return Session()
+    """
+    )
+
+
+register_module_extender(AstroidManager(), "sqlalchemy.orm.session", _session_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_ssl.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_ssl.py
new file mode 100644
index 0000000..6ca0d5a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_ssl.py
@@ -0,0 +1,71 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for the ssl library."""
+
+from astroid import parse
+from astroid.brain.helpers import register_module_extender
+from astroid.manager import AstroidManager
+
+
+def ssl_transform():
+    return parse(
+        """
+    from _ssl import OPENSSL_VERSION_NUMBER, OPENSSL_VERSION_INFO, OPENSSL_VERSION
+    from _ssl import _SSLContext, MemoryBIO
+    from _ssl import (
+        SSLError, SSLZeroReturnError, SSLWantReadError, SSLWantWriteError,
+        SSLSyscallError, SSLEOFError,
+        )
+    from _ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED
+    from _ssl import txt2obj as _txt2obj, nid2obj as _nid2obj
+    from _ssl import RAND_status, RAND_add, RAND_bytes, RAND_pseudo_bytes
+    try:
+        from _ssl import RAND_egd
+    except ImportError:
+        # LibreSSL does not provide RAND_egd
+        pass
+    from _ssl import (OP_ALL, OP_CIPHER_SERVER_PREFERENCE,
+                      OP_NO_COMPRESSION, OP_NO_SSLv2, OP_NO_SSLv3,
+                      OP_NO_TLSv1, OP_NO_TLSv1_1, OP_NO_TLSv1_2,
+                      OP_SINGLE_DH_USE, OP_SINGLE_ECDH_USE)
+
+    from _ssl import (ALERT_DESCRIPTION_ACCESS_DENIED, ALERT_DESCRIPTION_BAD_CERTIFICATE,
+                      ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE,
+                      ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE,
+                      ALERT_DESCRIPTION_BAD_RECORD_MAC,
+                      ALERT_DESCRIPTION_CERTIFICATE_EXPIRED,
+                      ALERT_DESCRIPTION_CERTIFICATE_REVOKED,
+                      ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN,
+                      ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE,
+                      ALERT_DESCRIPTION_CLOSE_NOTIFY, ALERT_DESCRIPTION_DECODE_ERROR,
+                      ALERT_DESCRIPTION_DECOMPRESSION_FAILURE,
+                      ALERT_DESCRIPTION_DECRYPT_ERROR,
+                      ALERT_DESCRIPTION_HANDSHAKE_FAILURE,
+                      ALERT_DESCRIPTION_ILLEGAL_PARAMETER,
+                      ALERT_DESCRIPTION_INSUFFICIENT_SECURITY,
+                      ALERT_DESCRIPTION_INTERNAL_ERROR,
+                      ALERT_DESCRIPTION_NO_RENEGOTIATION,
+                      ALERT_DESCRIPTION_PROTOCOL_VERSION,
+                      ALERT_DESCRIPTION_RECORD_OVERFLOW,
+                      ALERT_DESCRIPTION_UNEXPECTED_MESSAGE,
+                      ALERT_DESCRIPTION_UNKNOWN_CA,
+                      ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY,
+                      ALERT_DESCRIPTION_UNRECOGNIZED_NAME,
+                      ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE,
+                      ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION,
+                      ALERT_DESCRIPTION_USER_CANCELLED)
+    from _ssl import (SSL_ERROR_EOF, SSL_ERROR_INVALID_ERROR_CODE, SSL_ERROR_SSL,
+                      SSL_ERROR_SYSCALL, SSL_ERROR_WANT_CONNECT, SSL_ERROR_WANT_READ,
+                      SSL_ERROR_WANT_WRITE, SSL_ERROR_WANT_X509_LOOKUP, SSL_ERROR_ZERO_RETURN)
+    from _ssl import VERIFY_CRL_CHECK_CHAIN, VERIFY_CRL_CHECK_LEAF, VERIFY_DEFAULT, VERIFY_X509_STRICT
+    from _ssl import HAS_SNI, HAS_ECDH, HAS_NPN, HAS_ALPN
+    from _ssl import _OPENSSL_API_VERSION
+    from _ssl import PROTOCOL_SSLv23, PROTOCOL_TLSv1, PROTOCOL_TLSv1_1, PROTOCOL_TLSv1_2
+    from _ssl import PROTOCOL_TLS, PROTOCOL_TLS_CLIENT, PROTOCOL_TLS_SERVER
+    """
+    )
+
+
+register_module_extender(AstroidManager(), "ssl", ssl_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_subprocess.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_subprocess.py
new file mode 100644
index 0000000..f296ab4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_subprocess.py
@@ -0,0 +1,131 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+import textwrap
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.const import PY37_PLUS, PY39_PLUS, PY310_PLUS, PY311_PLUS
+from astroid.manager import AstroidManager
+
+
+def _subprocess_transform():
+    communicate = (bytes("string", "ascii"), bytes("string", "ascii"))
+    communicate_signature = "def communicate(self, input=None, timeout=None)"
+    args = """\
+        self, args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None,
+        preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None,
+        universal_newlines=None, startupinfo=None, creationflags=0, restore_signals=True,
+        start_new_session=False, pass_fds=(), *, encoding=None, errors=None, text=None"""
+
+    if PY39_PLUS:
+        args += ", user=None, group=None, extra_groups=None, umask=-1"
+    if PY310_PLUS:
+        args += ", pipesize=-1"
+    if PY311_PLUS:
+        args += ", process_group=None"
+
+    init = f"""
+        def __init__({args}):
+            pass"""
+    wait_signature = "def wait(self, timeout=None)"
+    ctx_manager = """
+        def __enter__(self): return self
+        def __exit__(self, *args): pass
+    """
+    py3_args = "args = []"
+
+    if PY37_PLUS:
+        check_output_signature = """
+        check_output(
+            args, *,
+            stdin=None,
+            stderr=None,
+            shell=False,
+            cwd=None,
+            encoding=None,
+            errors=None,
+            universal_newlines=False,
+            timeout=None,
+            env=None,
+            text=None,
+            restore_signals=True,
+            preexec_fn=None,
+            pass_fds=(),
+            input=None,
+            bufsize=0,
+            executable=None,
+            close_fds=False,
+            startupinfo=None,
+            creationflags=0,
+            start_new_session=False
+        ):
+        """.strip()
+    else:
+        check_output_signature = """
+        check_output(
+            args, *,
+            stdin=None,
+            stderr=None,
+            shell=False,
+            cwd=None,
+            encoding=None,
+            errors=None,
+            universal_newlines=False,
+            timeout=None,
+            env=None,
+            restore_signals=True,
+            preexec_fn=None,
+            pass_fds=(),
+            input=None,
+            bufsize=0,
+            executable=None,
+            close_fds=False,
+            startupinfo=None,
+            creationflags=0,
+            start_new_session=False
+        ):
+        """.strip()
+
+    code = textwrap.dedent(
+        f"""
+    def {check_output_signature}
+        if universal_newlines:
+            return ""
+        return b""
+
+    class Popen(object):
+        returncode = pid = 0
+        stdin = stdout = stderr = file()
+        {py3_args}
+
+        {communicate_signature}:
+            return {communicate!r}
+        {wait_signature}:
+            return self.returncode
+        def poll(self):
+            return self.returncode
+        def send_signal(self, signal):
+            pass
+        def terminate(self):
+            pass
+        def kill(self):
+            pass
+        {ctx_manager}
+       """
+    )
+    if PY39_PLUS:
+        code += """
+    @classmethod
+    def __class_getitem__(cls, item):
+        pass
+        """
+
+    init_lines = textwrap.dedent(init).splitlines()
+    indented_init = "\n".join(" " * 4 + line for line in init_lines)
+    code += indented_init
+    return parse(code)
+
+
+register_module_extender(AstroidManager(), "subprocess", _subprocess_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_threading.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_threading.py
new file mode 100644
index 0000000..a85055d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_threading.py
@@ -0,0 +1,31 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.manager import AstroidManager
+
+
+def _thread_transform():
+    return parse(
+        """
+    class lock(object):
+        def acquire(self, blocking=True, timeout=-1):
+            return False
+        def release(self):
+            pass
+        def __enter__(self):
+            return True
+        def __exit__(self, *args):
+            pass
+        def locked(self):
+            return False
+
+    def Lock():
+        return lock()
+    """
+    )
+
+
+register_module_extender(AstroidManager(), "threading", _thread_transform)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_type.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_type.py
new file mode 100644
index 0000000..f9c3ff4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_type.py
@@ -0,0 +1,69 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""
+Astroid hooks for type support.
+
+Starting from python3.9, type object behaves as it had __class_getitem__ method.
+However it was not possible to simply add this method inside type's body, otherwise
+all types would also have this method. In this case it would have been possible
+to write str[int].
+Guido Van Rossum proposed a hack to handle this in the interpreter:
+https://github.com/python/cpython/blob/67e394562d67cbcd0ac8114e5439494e7645b8f5/Objects/abstract.c#L181-L184
+
+This brain follows the same logic. It is no wise to add permanently the __class_getitem__ method
+to the type object. Instead we choose to add it only in the case of a subscript node
+which inside name node is type.
+Doing this type[int] is allowed whereas str[int] is not.
+
+Thanks to Lukasz Langa for fruitful discussion.
+"""
+
+from astroid import extract_node, inference_tip, nodes
+from astroid.const import PY39_PLUS
+from astroid.exceptions import UseInferenceDefault
+from astroid.manager import AstroidManager
+
+
+def _looks_like_type_subscript(node):
+    """
+    Try to figure out if a Name node is used inside a type related subscript
+
+    :param node: node to check
+    :type node: astroid.nodes.node_classes.NodeNG
+    :return: true if the node is a Name node inside a type related subscript
+    :rtype: bool
+    """
+    if isinstance(node, nodes.Name) and isinstance(node.parent, nodes.Subscript):
+        return node.name == "type"
+    return False
+
+
+def infer_type_sub(node, context=None):
+    """
+    Infer a type[...] subscript
+
+    :param node: node to infer
+    :type node: astroid.nodes.node_classes.NodeNG
+    :param context: inference context
+    :type context: astroid.context.InferenceContext
+    :return: the inferred node
+    :rtype: nodes.NodeNG
+    """
+    node_scope, _ = node.scope().lookup("type")
+    if not isinstance(node_scope, nodes.Module) or node_scope.qname() != "builtins":
+        raise UseInferenceDefault()
+    class_src = """
+    class type:
+        def __class_getitem__(cls, key):
+            return cls
+     """
+    node = extract_node(class_src)
+    return node.infer(context=context)
+
+
+if PY39_PLUS:
+    AstroidManager().register_transform(
+        nodes.Name, inference_tip(infer_type_sub), _looks_like_type_subscript
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_typing.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_typing.py
new file mode 100644
index 0000000..6077773
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_typing.py
@@ -0,0 +1,433 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for typing.py support."""
+import typing
+from functools import partial
+
+from astroid import context, extract_node, inference_tip
+from astroid.builder import _extract_single_node
+from astroid.const import PY37_PLUS, PY38_PLUS, PY39_PLUS
+from astroid.exceptions import (
+    AttributeInferenceError,
+    InferenceError,
+    UseInferenceDefault,
+)
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import (
+    Assign,
+    AssignName,
+    Attribute,
+    Call,
+    Const,
+    JoinedStr,
+    Name,
+    NodeNG,
+    Subscript,
+    Tuple,
+)
+from astroid.nodes.scoped_nodes import ClassDef, FunctionDef
+from astroid.util import Uninferable
+
+TYPING_NAMEDTUPLE_BASENAMES = {"NamedTuple", "typing.NamedTuple"}
+TYPING_TYPEVARS = {"TypeVar", "NewType"}
+TYPING_TYPEVARS_QUALIFIED = {"typing.TypeVar", "typing.NewType"}
+TYPING_TYPE_TEMPLATE = """
+class Meta(type):
+    def __getitem__(self, item):
+        return self
+
+    @property
+    def __args__(self):
+        return ()
+
+class {0}(metaclass=Meta):
+    pass
+"""
+TYPING_MEMBERS = set(getattr(typing, "__all__", []))
+
+TYPING_ALIAS = frozenset(
+    (
+        "typing.Hashable",
+        "typing.Awaitable",
+        "typing.Coroutine",
+        "typing.AsyncIterable",
+        "typing.AsyncIterator",
+        "typing.Iterable",
+        "typing.Iterator",
+        "typing.Reversible",
+        "typing.Sized",
+        "typing.Container",
+        "typing.Collection",
+        "typing.Callable",
+        "typing.AbstractSet",
+        "typing.MutableSet",
+        "typing.Mapping",
+        "typing.MutableMapping",
+        "typing.Sequence",
+        "typing.MutableSequence",
+        "typing.ByteString",
+        "typing.Tuple",
+        "typing.List",
+        "typing.Deque",
+        "typing.Set",
+        "typing.FrozenSet",
+        "typing.MappingView",
+        "typing.KeysView",
+        "typing.ItemsView",
+        "typing.ValuesView",
+        "typing.ContextManager",
+        "typing.AsyncContextManager",
+        "typing.Dict",
+        "typing.DefaultDict",
+        "typing.OrderedDict",
+        "typing.Counter",
+        "typing.ChainMap",
+        "typing.Generator",
+        "typing.AsyncGenerator",
+        "typing.Type",
+        "typing.Pattern",
+        "typing.Match",
+    )
+)
+
+CLASS_GETITEM_TEMPLATE = """
+@classmethod
+def __class_getitem__(cls, item):
+    return cls
+"""
+
+
+def looks_like_typing_typevar_or_newtype(node):
+    func = node.func
+    if isinstance(func, Attribute):
+        return func.attrname in TYPING_TYPEVARS
+    if isinstance(func, Name):
+        return func.name in TYPING_TYPEVARS
+    return False
+
+
+def infer_typing_typevar_or_newtype(node, context_itton=None):
+    """Infer a typing.TypeVar(...) or typing.NewType(...) call"""
+    try:
+        func = next(node.func.infer(context=context_itton))
+    except (InferenceError, StopIteration) as exc:
+        raise UseInferenceDefault from exc
+
+    if func.qname() not in TYPING_TYPEVARS_QUALIFIED:
+        raise UseInferenceDefault
+    if not node.args:
+        raise UseInferenceDefault
+    # Cannot infer from a dynamic class name (f-string)
+    if isinstance(node.args[0], JoinedStr):
+        raise UseInferenceDefault
+
+    typename = node.args[0].as_string().strip("'")
+    node = extract_node(TYPING_TYPE_TEMPLATE.format(typename))
+    return node.infer(context=context_itton)
+
+
+def _looks_like_typing_subscript(node):
+    """Try to figure out if a Subscript node *might* be a typing-related subscript"""
+    if isinstance(node, Name):
+        return node.name in TYPING_MEMBERS
+    if isinstance(node, Attribute):
+        return node.attrname in TYPING_MEMBERS
+    if isinstance(node, Subscript):
+        return _looks_like_typing_subscript(node.value)
+    return False
+
+
+def infer_typing_attr(
+    node: Subscript, ctx: typing.Optional[context.InferenceContext] = None
+) -> typing.Iterator[ClassDef]:
+    """Infer a typing.X[...] subscript"""
+    try:
+        value = next(node.value.infer())  # type: ignore[union-attr] # value shouldn't be None for Subscript.
+    except (InferenceError, StopIteration) as exc:
+        raise UseInferenceDefault from exc
+
+    if (
+        not value.qname().startswith("typing.")
+        or PY37_PLUS
+        and value.qname() in TYPING_ALIAS
+    ):
+        # If typing subscript belongs to an alias
+        # (PY37+) handle it separately.
+        raise UseInferenceDefault
+
+    if (
+        PY37_PLUS
+        and isinstance(value, ClassDef)
+        and value.qname()
+        in {"typing.Generic", "typing.Annotated", "typing_extensions.Annotated"}
+    ):
+        # With PY37+ typing.Generic and typing.Annotated (PY39) are subscriptable
+        # through __class_getitem__. Since astroid can't easily
+        # infer the native methods, replace them for an easy inference tip
+        func_to_add = _extract_single_node(CLASS_GETITEM_TEMPLATE)
+        value.locals["__class_getitem__"] = [func_to_add]
+        if (
+            isinstance(node.parent, ClassDef)
+            and node in node.parent.bases
+            and getattr(node.parent, "__cache", None)
+        ):
+            # node.parent.slots is evaluated and cached before the inference tip
+            # is first applied. Remove the last result to allow a recalculation of slots
+            cache = node.parent.__cache  # type: ignore[attr-defined] # Unrecognized getattr
+            if cache.get(node.parent.slots) is not None:
+                del cache[node.parent.slots]
+        return iter([value])
+
+    node = extract_node(TYPING_TYPE_TEMPLATE.format(value.qname().split(".")[-1]))
+    return node.infer(context=ctx)
+
+
+def _looks_like_typedDict(  # pylint: disable=invalid-name
+    node: typing.Union[FunctionDef, ClassDef],
+) -> bool:
+    """Check if node is TypedDict FunctionDef."""
+    return node.qname() in {"typing.TypedDict", "typing_extensions.TypedDict"}
+
+
+def infer_old_typedDict(  # pylint: disable=invalid-name
+    node: ClassDef, ctx: typing.Optional[context.InferenceContext] = None
+) -> typing.Iterator[ClassDef]:
+    func_to_add = _extract_single_node("dict")
+    node.locals["__call__"] = [func_to_add]
+    return iter([node])
+
+
+def infer_typedDict(  # pylint: disable=invalid-name
+    node: FunctionDef, ctx: typing.Optional[context.InferenceContext] = None
+) -> typing.Iterator[ClassDef]:
+    """Replace TypedDict FunctionDef with ClassDef."""
+    class_def = ClassDef(
+        name="TypedDict",
+        lineno=node.lineno,
+        col_offset=node.col_offset,
+        parent=node.parent,
+    )
+    class_def.postinit(bases=[extract_node("dict")], body=[], decorators=None)
+    func_to_add = _extract_single_node("dict")
+    class_def.locals["__call__"] = [func_to_add]
+    return iter([class_def])
+
+
+def _looks_like_typing_alias(node: Call) -> bool:
+    """
+    Returns True if the node corresponds to a call to _alias function.
+    For example :
+
+    MutableSet = _alias(collections.abc.MutableSet, T)
+
+    :param node: call node
+    """
+    return (
+        isinstance(node.func, Name)
+        and node.func.name == "_alias"
+        and (
+            # _alias function works also for builtins object such as list and dict
+            isinstance(node.args[0], (Attribute, Name))
+        )
+    )
+
+
+def _forbid_class_getitem_access(node: ClassDef) -> None:
+    """
+    Disable the access to __class_getitem__ method for the node in parameters
+    """
+
+    def full_raiser(origin_func, attr, *args, **kwargs):
+        """
+        Raises an AttributeInferenceError in case of access to __class_getitem__ method.
+        Otherwise just call origin_func.
+        """
+        if attr == "__class_getitem__":
+            raise AttributeInferenceError("__class_getitem__ access is not allowed")
+        return origin_func(attr, *args, **kwargs)
+
+    try:
+        node.getattr("__class_getitem__")
+        # If we are here, then we are sure to modify object that do have __class_getitem__ method (which origin is one the
+        # protocol defined in collections module) whereas the typing module consider it should not
+        # We do not want __class_getitem__ to be found in the classdef
+        partial_raiser = partial(full_raiser, node.getattr)
+        node.getattr = partial_raiser
+    except AttributeInferenceError:
+        pass
+
+
+def infer_typing_alias(
+    node: Call, ctx: typing.Optional[context.InferenceContext] = None
+) -> typing.Iterator[ClassDef]:
+    """
+    Infers the call to _alias function
+    Insert ClassDef, with same name as aliased class,
+    in mro to simulate _GenericAlias.
+
+    :param node: call node
+    :param context: inference context
+    """
+    if (
+        not isinstance(node.parent, Assign)
+        or not len(node.parent.targets) == 1
+        or not isinstance(node.parent.targets[0], AssignName)
+    ):
+        raise UseInferenceDefault
+    try:
+        res = next(node.args[0].infer(context=ctx))
+    except StopIteration as e:
+        raise InferenceError(node=node.args[0], context=context) from e
+
+    assign_name = node.parent.targets[0]
+
+    class_def = ClassDef(
+        name=assign_name.name,
+        lineno=assign_name.lineno,
+        col_offset=assign_name.col_offset,
+        parent=node.parent,
+    )
+    if res != Uninferable and isinstance(res, ClassDef):
+        # Only add `res` as base if it's a `ClassDef`
+        # This isn't the case for `typing.Pattern` and `typing.Match`
+        class_def.postinit(bases=[res], body=[], decorators=None)
+
+    maybe_type_var = node.args[1]
+    if (
+        not PY39_PLUS
+        and not (isinstance(maybe_type_var, Tuple) and not maybe_type_var.elts)
+        or PY39_PLUS
+        and isinstance(maybe_type_var, Const)
+        and maybe_type_var.value > 0
+    ):
+        # If typing alias is subscriptable, add `__class_getitem__` to ClassDef
+        func_to_add = _extract_single_node(CLASS_GETITEM_TEMPLATE)
+        class_def.locals["__class_getitem__"] = [func_to_add]
+    else:
+        # If not, make sure that `__class_getitem__` access is forbidden.
+        # This is an issue in cases where the aliased class implements it,
+        # but the typing alias isn't subscriptable. E.g., `typing.ByteString` for PY39+
+        _forbid_class_getitem_access(class_def)
+    return iter([class_def])
+
+
+def _looks_like_special_alias(node: Call) -> bool:
+    """Return True if call is for Tuple or Callable alias.
+
+    In PY37 and PY38 the call is to '_VariadicGenericAlias' with 'tuple' as
+    first argument. In PY39+ it is replaced by a call to '_TupleType'.
+
+    PY37: Tuple = _VariadicGenericAlias(tuple, (), inst=False, special=True)
+    PY39: Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
+
+
+    PY37: Callable = _VariadicGenericAlias(collections.abc.Callable, (), special=True)
+    PY39: Callable = _CallableType(collections.abc.Callable, 2)
+    """
+    return isinstance(node.func, Name) and (
+        not PY39_PLUS
+        and node.func.name == "_VariadicGenericAlias"
+        and (
+            isinstance(node.args[0], Name)
+            and node.args[0].name == "tuple"
+            or isinstance(node.args[0], Attribute)
+            and node.args[0].as_string() == "collections.abc.Callable"
+        )
+        or PY39_PLUS
+        and (
+            node.func.name == "_TupleType"
+            and isinstance(node.args[0], Name)
+            and node.args[0].name == "tuple"
+            or node.func.name == "_CallableType"
+            and isinstance(node.args[0], Attribute)
+            and node.args[0].as_string() == "collections.abc.Callable"
+        )
+    )
+
+
+def infer_special_alias(
+    node: Call, ctx: typing.Optional[context.InferenceContext] = None
+) -> typing.Iterator[ClassDef]:
+    """Infer call to tuple alias as new subscriptable class typing.Tuple."""
+    if not (
+        isinstance(node.parent, Assign)
+        and len(node.parent.targets) == 1
+        and isinstance(node.parent.targets[0], AssignName)
+    ):
+        raise UseInferenceDefault
+    try:
+        res = next(node.args[0].infer(context=ctx))
+    except StopIteration as e:
+        raise InferenceError(node=node.args[0], context=context) from e
+
+    assign_name = node.parent.targets[0]
+    class_def = ClassDef(
+        name=assign_name.name,
+        parent=node.parent,
+    )
+    class_def.postinit(bases=[res], body=[], decorators=None)
+    func_to_add = _extract_single_node(CLASS_GETITEM_TEMPLATE)
+    class_def.locals["__class_getitem__"] = [func_to_add]
+    return iter([class_def])
+
+
+def _looks_like_typing_cast(node: Call) -> bool:
+    return isinstance(node, Call) and (
+        isinstance(node.func, Name)
+        and node.func.name == "cast"
+        or isinstance(node.func, Attribute)
+        and node.func.attrname == "cast"
+    )
+
+
+def infer_typing_cast(
+    node: Call, ctx: typing.Optional[context.InferenceContext] = None
+) -> typing.Iterator[NodeNG]:
+    """Infer call to cast() returning same type as casted-from var"""
+    if not isinstance(node.func, (Name, Attribute)):
+        raise UseInferenceDefault
+
+    try:
+        func = next(node.func.infer(context=ctx))
+    except (InferenceError, StopIteration) as exc:
+        raise UseInferenceDefault from exc
+    if (
+        not isinstance(func, FunctionDef)
+        or func.qname() != "typing.cast"
+        or len(node.args) != 2
+    ):
+        raise UseInferenceDefault
+
+    return node.args[1].infer(context=ctx)
+
+
+AstroidManager().register_transform(
+    Call,
+    inference_tip(infer_typing_typevar_or_newtype),
+    looks_like_typing_typevar_or_newtype,
+)
+AstroidManager().register_transform(
+    Subscript, inference_tip(infer_typing_attr), _looks_like_typing_subscript
+)
+AstroidManager().register_transform(
+    Call, inference_tip(infer_typing_cast), _looks_like_typing_cast
+)
+
+if PY39_PLUS:
+    AstroidManager().register_transform(
+        FunctionDef, inference_tip(infer_typedDict), _looks_like_typedDict
+    )
+elif PY38_PLUS:
+    AstroidManager().register_transform(
+        ClassDef, inference_tip(infer_old_typedDict), _looks_like_typedDict
+    )
+
+if PY37_PLUS:
+    AstroidManager().register_transform(
+        Call, inference_tip(infer_typing_alias), _looks_like_typing_alias
+    )
+    AstroidManager().register_transform(
+        Call, inference_tip(infer_special_alias), _looks_like_special_alias
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_unittest.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_unittest.py
new file mode 100644
index 0000000..b34e1cf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_unittest.py
@@ -0,0 +1,31 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for unittest module"""
+from astroid.brain.helpers import register_module_extender
+from astroid.builder import parse
+from astroid.const import PY38_PLUS
+from astroid.manager import AstroidManager
+
+
+def IsolatedAsyncioTestCaseImport():
+    """
+    In the unittest package, the IsolatedAsyncioTestCase class is imported lazily, i.e only
+    when the __getattr__ method of the unittest module is called with 'IsolatedAsyncioTestCase' as
+    argument. Thus the IsolatedAsyncioTestCase is not imported statically (during import time).
+    This function mocks a classical static import of the IsolatedAsyncioTestCase.
+
+    (see https://github.com/PyCQA/pylint/issues/4060)
+    """
+    return parse(
+        """
+    from .async_case import IsolatedAsyncioTestCase
+    """
+    )
+
+
+if PY38_PLUS:
+    register_module_extender(
+        AstroidManager(), "unittest", IsolatedAsyncioTestCaseImport
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/brain_uuid.py b/myenv/lib/python3.9/site-packages/astroid/brain/brain_uuid.py
new file mode 100644
index 0000000..f6ba888
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/brain_uuid.py
@@ -0,0 +1,18 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Astroid hooks for the UUID module."""
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import Const
+from astroid.nodes.scoped_nodes import ClassDef
+
+
+def _patch_uuid_class(node):
+    # The .int member is patched using __dict__
+    node.locals["int"] = [Const(0, parent=node)]
+
+
+AstroidManager().register_transform(
+    ClassDef, _patch_uuid_class, lambda node: node.qname() == "uuid.UUID"
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/brain/helpers.py b/myenv/lib/python3.9/site-packages/astroid/brain/helpers.py
new file mode 100644
index 0000000..d74f595
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/brain/helpers.py
@@ -0,0 +1,17 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from astroid.nodes.scoped_nodes import Module
+
+
+def register_module_extender(manager, module_name, get_extension_mod):
+    def transform(node):
+        extension_module = get_extension_mod()
+        for name, objs in extension_module.locals.items():
+            node.locals[name] = objs
+            for obj in objs:
+                if obj.parent is extension_module:
+                    obj.parent = node
+
+    manager.register_transform(Module, transform, lambda n: n.name == module_name)
diff --git a/myenv/lib/python3.9/site-packages/astroid/builder.py b/myenv/lib/python3.9/site-packages/astroid/builder.py
new file mode 100644
index 0000000..1cdb963
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/builder.py
@@ -0,0 +1,464 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""The AstroidBuilder makes astroid from living object and / or from _ast
+
+The builder is not thread safe and can't be used to parse different sources
+at the same time.
+"""
+import os
+import textwrap
+import types
+from tokenize import detect_encoding
+from typing import List, Optional, Tuple, Union
+
+from astroid import bases, modutils, nodes, raw_building, rebuilder, util
+from astroid._ast import get_parser_module
+from astroid.exceptions import AstroidBuildingError, AstroidSyntaxError, InferenceError
+from astroid.manager import AstroidManager
+from astroid.nodes.node_classes import NodeNG
+
+objects = util.lazy_import("objects")
+
+# The name of the transient function that is used to
+# wrap expressions to be extracted when calling
+# extract_node.
+_TRANSIENT_FUNCTION = "__"
+
+# The comment used to select a statement to be extracted
+# when calling extract_node.
+_STATEMENT_SELECTOR = "#@"
+MISPLACED_TYPE_ANNOTATION_ERROR = "misplaced type annotation"
+
+
+def open_source_file(filename):
+    # pylint: disable=consider-using-with
+    with open(filename, "rb") as byte_stream:
+        encoding = detect_encoding(byte_stream.readline)[0]
+    stream = open(filename, newline=None, encoding=encoding)
+    data = stream.read()
+    return stream, encoding, data
+
+
+def _can_assign_attr(node, attrname):
+    try:
+        slots = node.slots()
+    except NotImplementedError:
+        pass
+    else:
+        if slots and attrname not in {slot.value for slot in slots}:
+            return False
+    return node.qname() != "builtins.object"
+
+
+class AstroidBuilder(raw_building.InspectBuilder):
+    """Class for building an astroid tree from source code or from a live module.
+
+    The param *manager* specifies the manager class which should be used.
+    If no manager is given, then the default one will be used. The
+    param *apply_transforms* determines if the transforms should be
+    applied after the tree was built from source or from a live object,
+    by default being True.
+    """
+
+    # pylint: disable=redefined-outer-name
+    def __init__(self, manager=None, apply_transforms=True):
+        super().__init__(manager)
+        self._apply_transforms = apply_transforms
+
+    def module_build(
+        self, module: types.ModuleType, modname: Optional[str] = None
+    ) -> nodes.Module:
+        """Build an astroid from a living module instance."""
+        node = None
+        path = getattr(module, "__file__", None)
+        loader = getattr(module, "__loader__", None)
+        # Prefer the loader to get the source rather than assuming we have a
+        # filesystem to read the source file from ourselves.
+        if loader:
+            modname = modname or module.__name__
+            source = loader.get_source(modname)
+            if source:
+                node = self.string_build(source, modname, path=path)
+        if node is None and path is not None:
+            path_, ext = os.path.splitext(modutils._path_from_filename(path))
+            if ext in {".py", ".pyc", ".pyo"} and os.path.exists(path_ + ".py"):
+                node = self.file_build(path_ + ".py", modname)
+        if node is None:
+            # this is a built-in module
+            # get a partial representation by introspection
+            node = self.inspect_build(module, modname=modname, path=path)
+            if self._apply_transforms:
+                # We have to handle transformation by ourselves since the
+                # rebuilder isn't called for builtin nodes
+                node = self._manager.visit_transforms(node)
+        return node
+
+    def file_build(self, path, modname=None):
+        """Build astroid from a source code file (i.e. from an ast)
+
+        *path* is expected to be a python source file
+        """
+        try:
+            stream, encoding, data = open_source_file(path)
+        except OSError as exc:
+            raise AstroidBuildingError(
+                "Unable to load file {path}:\n{error}",
+                modname=modname,
+                path=path,
+                error=exc,
+            ) from exc
+        except (SyntaxError, LookupError) as exc:
+            raise AstroidSyntaxError(
+                "Python 3 encoding specification error or unknown encoding:\n"
+                "{error}",
+                modname=modname,
+                path=path,
+                error=exc,
+            ) from exc
+        except UnicodeError as exc:  # wrong encoding
+            # detect_encoding returns utf-8 if no encoding specified
+            raise AstroidBuildingError(
+                "Wrong or no encoding specified for {filename}.", filename=path
+            ) from exc
+        with stream:
+            # get module name if necessary
+            if modname is None:
+                try:
+                    modname = ".".join(modutils.modpath_from_file(path))
+                except ImportError:
+                    modname = os.path.splitext(os.path.basename(path))[0]
+            # build astroid representation
+            module, builder = self._data_build(data, modname, path)
+            return self._post_build(module, builder, encoding)
+
+    def string_build(self, data, modname="", path=None):
+        """Build astroid from source code string."""
+        module, builder = self._data_build(data, modname, path)
+        module.file_bytes = data.encode("utf-8")
+        return self._post_build(module, builder, "utf-8")
+
+    def _post_build(
+        self, module: nodes.Module, builder: rebuilder.TreeRebuilder, encoding: str
+    ) -> nodes.Module:
+        """Handles encoding and delayed nodes after a module has been built"""
+        module.file_encoding = encoding
+        self._manager.cache_module(module)
+        # post tree building steps after we stored the module in the cache:
+        for from_node in builder._import_from_nodes:
+            if from_node.modname == "__future__":
+                for symbol, _ in from_node.names:
+                    module.future_imports.add(symbol)
+            self.add_from_names_to_locals(from_node)
+        # handle delayed assattr nodes
+        for delayed in builder._delayed_assattr:
+            self.delayed_assattr(delayed)
+
+        # Visit the transforms
+        if self._apply_transforms:
+            module = self._manager.visit_transforms(module)
+        return module
+
+    def _data_build(
+        self, data: str, modname, path
+    ) -> Tuple[nodes.Module, rebuilder.TreeRebuilder]:
+        """Build tree node from data and add some informations"""
+        try:
+            node, parser_module = _parse_string(data, type_comments=True)
+        except (TypeError, ValueError, SyntaxError) as exc:
+            raise AstroidSyntaxError(
+                "Parsing Python code failed:\n{error}",
+                source=data,
+                modname=modname,
+                path=path,
+                error=exc,
+            ) from exc
+
+        if path is not None:
+            node_file = os.path.abspath(path)
+        else:
+            node_file = "<?>"
+        if modname.endswith(".__init__"):
+            modname = modname[:-9]
+            package = True
+        else:
+            package = (
+                path is not None
+                and os.path.splitext(os.path.basename(path))[0] == "__init__"
+            )
+        builder = rebuilder.TreeRebuilder(self._manager, parser_module, data)
+        module = builder.visit_module(node, modname, node_file, package)
+        return module, builder
+
+    def add_from_names_to_locals(self, node):
+        """Store imported names to the locals
+
+        Resort the locals if coming from a delayed node
+        """
+
+        def _key_func(node):
+            return node.fromlineno
+
+        def sort_locals(my_list):
+            my_list.sort(key=_key_func)
+
+        for (name, asname) in node.names:
+            if name == "*":
+                try:
+                    imported = node.do_import_module()
+                except AstroidBuildingError:
+                    continue
+                for name in imported.public_names():
+                    node.parent.set_local(name, node)
+                    sort_locals(node.parent.scope().locals[name])
+            else:
+                node.parent.set_local(asname or name, node)
+                sort_locals(node.parent.scope().locals[asname or name])
+
+    def delayed_assattr(self, node):
+        """Visit a AssAttr node
+
+        This adds name to locals and handle members definition.
+        """
+        try:
+            frame = node.frame(future=True)
+            for inferred in node.expr.infer():
+                if inferred is util.Uninferable:
+                    continue
+                try:
+                    cls = inferred.__class__
+                    if cls is bases.Instance or cls is objects.ExceptionInstance:
+                        inferred = inferred._proxied
+                        iattrs = inferred.instance_attrs
+                        if not _can_assign_attr(inferred, node.attrname):
+                            continue
+                    elif isinstance(inferred, bases.Instance):
+                        # Const, Tuple or other containers that inherit from
+                        # `Instance`
+                        continue
+                    elif inferred.is_function:
+                        iattrs = inferred.instance_attrs
+                    else:
+                        iattrs = inferred.locals
+                except AttributeError:
+                    # XXX log error
+                    continue
+                values = iattrs.setdefault(node.attrname, [])
+                if node in values:
+                    continue
+                # get assign in __init__ first XXX useful ?
+                if (
+                    frame.name == "__init__"
+                    and values
+                    and values[0].frame(future=True).name != "__init__"
+                ):
+                    values.insert(0, node)
+                else:
+                    values.append(node)
+        except InferenceError:
+            pass
+
+
+def build_namespace_package_module(name: str, path: List[str]) -> nodes.Module:
+    return nodes.Module(name, path=path, package=True)
+
+
+def parse(code, module_name="", path=None, apply_transforms=True):
+    """Parses a source string in order to obtain an astroid AST from it
+
+    :param str code: The code for the module.
+    :param str module_name: The name for the module, if any
+    :param str path: The path for the module
+    :param bool apply_transforms:
+        Apply the transforms for the give code. Use it if you
+        don't want the default transforms to be applied.
+    """
+    code = textwrap.dedent(code)
+    builder = AstroidBuilder(
+        manager=AstroidManager(), apply_transforms=apply_transforms
+    )
+    return builder.string_build(code, modname=module_name, path=path)
+
+
+def _extract_expressions(node):
+    """Find expressions in a call to _TRANSIENT_FUNCTION and extract them.
+
+    The function walks the AST recursively to search for expressions that
+    are wrapped into a call to _TRANSIENT_FUNCTION. If it finds such an
+    expression, it completely removes the function call node from the tree,
+    replacing it by the wrapped expression inside the parent.
+
+    :param node: An astroid node.
+    :type node:  astroid.bases.NodeNG
+    :yields: The sequence of wrapped expressions on the modified tree
+    expression can be found.
+    """
+    if (
+        isinstance(node, nodes.Call)
+        and isinstance(node.func, nodes.Name)
+        and node.func.name == _TRANSIENT_FUNCTION
+    ):
+        real_expr = node.args[0]
+        real_expr.parent = node.parent
+        # Search for node in all _astng_fields (the fields checked when
+        # get_children is called) of its parent. Some of those fields may
+        # be lists or tuples, in which case the elements need to be checked.
+        # When we find it, replace it by real_expr, so that the AST looks
+        # like no call to _TRANSIENT_FUNCTION ever took place.
+        for name in node.parent._astroid_fields:
+            child = getattr(node.parent, name)
+            if isinstance(child, (list, tuple)):
+                for idx, compound_child in enumerate(child):
+                    if compound_child is node:
+                        child[idx] = real_expr
+            elif child is node:
+                setattr(node.parent, name, real_expr)
+        yield real_expr
+    else:
+        for child in node.get_children():
+            yield from _extract_expressions(child)
+
+
+def _find_statement_by_line(node, line):
+    """Extracts the statement on a specific line from an AST.
+
+    If the line number of node matches line, it will be returned;
+    otherwise its children are iterated and the function is called
+    recursively.
+
+    :param node: An astroid node.
+    :type node: astroid.bases.NodeNG
+    :param line: The line number of the statement to extract.
+    :type line: int
+    :returns: The statement on the line, or None if no statement for the line
+      can be found.
+    :rtype:  astroid.bases.NodeNG or None
+    """
+    if isinstance(node, (nodes.ClassDef, nodes.FunctionDef, nodes.MatchCase)):
+        # This is an inaccuracy in the AST: the nodes that can be
+        # decorated do not carry explicit information on which line
+        # the actual definition (class/def), but .fromline seems to
+        # be close enough.
+        node_line = node.fromlineno
+    else:
+        node_line = node.lineno
+
+    if node_line == line:
+        return node
+
+    for child in node.get_children():
+        result = _find_statement_by_line(child, line)
+        if result:
+            return result
+
+    return None
+
+
+def extract_node(code: str, module_name: str = "") -> Union[NodeNG, List[NodeNG]]:
+    """Parses some Python code as a module and extracts a designated AST node.
+
+    Statements:
+     To extract one or more statement nodes, append #@ to the end of the line
+
+     Examples:
+       >>> def x():
+       >>>   def y():
+       >>>     return 1 #@
+
+       The return statement will be extracted.
+
+       >>> class X(object):
+       >>>   def meth(self): #@
+       >>>     pass
+
+      The function object 'meth' will be extracted.
+
+    Expressions:
+     To extract arbitrary expressions, surround them with the fake
+     function call __(...). After parsing, the surrounded expression
+     will be returned and the whole AST (accessible via the returned
+     node's parent attribute) will look like the function call was
+     never there in the first place.
+
+     Examples:
+       >>> a = __(1)
+
+       The const node will be extracted.
+
+       >>> def x(d=__(foo.bar)): pass
+
+       The node containing the default argument will be extracted.
+
+       >>> def foo(a, b):
+       >>>   return 0 < __(len(a)) < b
+
+       The node containing the function call 'len' will be extracted.
+
+    If no statements or expressions are selected, the last toplevel
+    statement will be returned.
+
+    If the selected statement is a discard statement, (i.e. an expression
+    turned into a statement), the wrapped expression is returned instead.
+
+    For convenience, singleton lists are unpacked.
+
+    :param str code: A piece of Python code that is parsed as
+    a module. Will be passed through textwrap.dedent first.
+    :param str module_name: The name of the module.
+    :returns: The designated node from the parse tree, or a list of nodes.
+    """
+
+    def _extract(node):
+        if isinstance(node, nodes.Expr):
+            return node.value
+
+        return node
+
+    requested_lines = []
+    for idx, line in enumerate(code.splitlines()):
+        if line.strip().endswith(_STATEMENT_SELECTOR):
+            requested_lines.append(idx + 1)
+
+    tree = parse(code, module_name=module_name)
+    if not tree.body:
+        raise ValueError("Empty tree, cannot extract from it")
+
+    extracted = []
+    if requested_lines:
+        extracted = [_find_statement_by_line(tree, line) for line in requested_lines]
+
+    # Modifies the tree.
+    extracted.extend(_extract_expressions(tree))
+
+    if not extracted:
+        extracted.append(tree.body[-1])
+
+    extracted = [_extract(node) for node in extracted]
+    if len(extracted) == 1:
+        return extracted[0]
+    return extracted
+
+
+def _extract_single_node(code: str, module_name: str = "") -> NodeNG:
+    """Call extract_node while making sure that only one value is returned."""
+    ret = extract_node(code, module_name)
+    if isinstance(ret, list):
+        return ret[0]
+    return ret
+
+
+def _parse_string(data, type_comments=True):
+    parser_module = get_parser_module(type_comments=type_comments)
+    try:
+        parsed = parser_module.parse(data + "\n", type_comments=type_comments)
+    except SyntaxError as exc:
+        # If the type annotations are misplaced for some reason, we do not want
+        # to fail the entire parsing of the file, so we need to retry the parsing without
+        # type comment support.
+        if exc.args[0] != MISPLACED_TYPE_ANNOTATION_ERROR or not type_comments:
+            raise
+
+        parser_module = get_parser_module(type_comments=False)
+        parsed = parser_module.parse(data + "\n", type_comments=False)
+    return parsed, parser_module
diff --git a/myenv/lib/python3.9/site-packages/astroid/const.py b/myenv/lib/python3.9/site-packages/astroid/const.py
new file mode 100644
index 0000000..0cb2d09
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/const.py
@@ -0,0 +1,32 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+import enum
+import sys
+
+PY36 = sys.version_info[:2] == (3, 6)
+PY38 = sys.version_info[:2] == (3, 8)
+PY37_PLUS = sys.version_info >= (3, 7)
+PY38_PLUS = sys.version_info >= (3, 8)
+PY39_PLUS = sys.version_info >= (3, 9)
+PY310_PLUS = sys.version_info >= (3, 10)
+PY311_PLUS = sys.version_info >= (3, 11)
+BUILTINS = "builtins"  # TODO Remove in 2.8
+
+WIN32 = sys.platform == "win32"
+
+IS_PYPY = sys.implementation.name == "pypy"
+IS_JYTHON = sys.implementation.name == "jython"
+
+
+class Context(enum.Enum):
+    Load = 1
+    Store = 2
+    Del = 3
+
+
+# TODO Remove in 3.0 in favor of Context
+Load = Context.Load
+Store = Context.Store
+Del = Context.Del
diff --git a/myenv/lib/python3.9/site-packages/astroid/context.py b/myenv/lib/python3.9/site-packages/astroid/context.py
new file mode 100644
index 0000000..a04996e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/context.py
@@ -0,0 +1,201 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Various context related utilities, including inference and call contexts."""
+import contextlib
+import pprint
+from typing import TYPE_CHECKING, List, MutableMapping, Optional, Sequence, Tuple
+
+if TYPE_CHECKING:
+    from astroid.nodes.node_classes import Keyword, NodeNG
+
+
+_INFERENCE_CACHE = {}
+
+
+def _invalidate_cache():
+    _INFERENCE_CACHE.clear()
+
+
+class InferenceContext:
+    """Provide context for inference
+
+    Store already inferred nodes to save time
+    Account for already visited nodes to stop infinite recursion
+    """
+
+    __slots__ = (
+        "path",
+        "lookupname",
+        "callcontext",
+        "boundnode",
+        "extra_context",
+        "_nodes_inferred",
+    )
+
+    max_inferred = 100
+
+    def __init__(self, path=None, nodes_inferred=None):
+        if nodes_inferred is None:
+            self._nodes_inferred = [0]
+        else:
+            self._nodes_inferred = nodes_inferred
+        self.path = path or set()
+        """
+        :type: set(tuple(NodeNG, optional(str)))
+
+        Path of visited nodes and their lookupname
+
+        Currently this key is ``(node, context.lookupname)``
+        """
+        self.lookupname = None
+        """
+        :type: optional[str]
+
+        The original name of the node
+
+        e.g.
+        foo = 1
+        The inference of 'foo' is nodes.Const(1) but the lookup name is 'foo'
+        """
+        self.callcontext = None
+        """
+        :type: optional[CallContext]
+
+        The call arguments and keywords for the given context
+        """
+        self.boundnode = None
+        """
+        :type: optional[NodeNG]
+
+        The bound node of the given context
+
+        e.g. the bound node of object.__new__(cls) is the object node
+        """
+        self.extra_context = {}
+        """
+        :type: dict(NodeNG, Context)
+
+        Context that needs to be passed down through call stacks
+        for call arguments
+        """
+
+    @property
+    def nodes_inferred(self):
+        """
+        Number of nodes inferred in this context and all its clones/descendents
+
+        Wrap inner value in a mutable cell to allow for mutating a class
+        variable in the presence of __slots__
+        """
+        return self._nodes_inferred[0]
+
+    @nodes_inferred.setter
+    def nodes_inferred(self, value):
+        self._nodes_inferred[0] = value
+
+    @property
+    def inferred(
+        self,
+    ) -> MutableMapping[
+        Tuple["NodeNG", Optional[str], Optional[str], Optional[str]], Sequence["NodeNG"]
+    ]:
+        """
+        Inferred node contexts to their mapped results
+
+        Currently the key is ``(node, lookupname, callcontext, boundnode)``
+        and the value is tuple of the inferred results
+        """
+        return _INFERENCE_CACHE
+
+    def push(self, node):
+        """Push node into inference path
+
+        :return: True if node is already in context path else False
+        :rtype: bool
+
+        Allows one to see if the given node has already
+        been looked at for this inference context"""
+        name = self.lookupname
+        if (node, name) in self.path:
+            return True
+
+        self.path.add((node, name))
+        return False
+
+    def clone(self):
+        """Clone inference path
+
+        For example, each side of a binary operation (BinOp)
+        starts with the same context but diverge as each side is inferred
+        so the InferenceContext will need be cloned"""
+        # XXX copy lookupname/callcontext ?
+        clone = InferenceContext(self.path.copy(), nodes_inferred=self._nodes_inferred)
+        clone.callcontext = self.callcontext
+        clone.boundnode = self.boundnode
+        clone.extra_context = self.extra_context
+        return clone
+
+    @contextlib.contextmanager
+    def restore_path(self):
+        path = set(self.path)
+        yield
+        self.path = path
+
+    def __str__(self):
+        state = (
+            f"{field}={pprint.pformat(getattr(self, field), width=80 - len(field))}"
+            for field in self.__slots__
+        )
+        return "{}({})".format(type(self).__name__, ",\n    ".join(state))
+
+
+class CallContext:
+    """Holds information for a call site."""
+
+    __slots__ = ("args", "keywords", "callee")
+
+    def __init__(
+        self,
+        args: List["NodeNG"],
+        keywords: Optional[List["Keyword"]] = None,
+        callee: Optional["NodeNG"] = None,
+    ):
+        self.args = args  # Call positional arguments
+        if keywords:
+            keywords = [(arg.arg, arg.value) for arg in keywords]
+        else:
+            keywords = []
+        self.keywords = keywords  # Call keyword arguments
+        self.callee = callee  # Function being called
+
+
+def copy_context(context: Optional[InferenceContext]) -> InferenceContext:
+    """Clone a context if given, or return a fresh contexxt"""
+    if context is not None:
+        return context.clone()
+
+    return InferenceContext()
+
+
+def bind_context_to_node(context, node):
+    """Give a context a boundnode
+    to retrieve the correct function name or attribute value
+    with from further inference.
+
+    Do not use an existing context since the boundnode could then
+    be incorrectly propagated higher up in the call stack.
+
+    :param context: Context to use
+    :type context: Optional(context)
+
+    :param node: Node to do name lookups from
+    :type node NodeNG:
+
+    :returns: A new context
+    :rtype: InferenceContext
+    """
+    context = copy_context(context)
+    context.boundnode = node
+    return context
diff --git a/myenv/lib/python3.9/site-packages/astroid/decorators.py b/myenv/lib/python3.9/site-packages/astroid/decorators.py
new file mode 100644
index 0000000..ec16fea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/decorators.py
@@ -0,0 +1,273 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+""" A few useful function/method decorators."""
+
+import functools
+import inspect
+import sys
+import warnings
+from typing import Callable, TypeVar
+
+import wrapt
+
+from astroid import util
+from astroid.context import InferenceContext
+from astroid.exceptions import InferenceError
+
+if sys.version_info >= (3, 10):
+    from typing import ParamSpec
+else:
+    from typing_extensions import ParamSpec
+
+R = TypeVar("R")
+P = ParamSpec("P")
+
+
+@wrapt.decorator
+def cached(func, instance, args, kwargs):
+    """Simple decorator to cache result of method calls without args."""
+    cache = getattr(instance, "__cache", None)
+    if cache is None:
+        instance.__cache = cache = {}
+    try:
+        return cache[func]
+    except KeyError:
+        cache[func] = result = func(*args, **kwargs)
+        return result
+
+
+# TODO: Remove when support for 3.7 is dropped
+# TODO: astroid 3.0 -> move class behind sys.version_info < (3, 8) guard
+class cachedproperty:
+    """Provides a cached property equivalent to the stacking of
+    @cached and @property, but more efficient.
+
+    After first usage, the <property_name> becomes part of the object's
+    __dict__. Doing:
+
+      del obj.<property_name> empties the cache.
+
+    Idea taken from the pyramid_ framework and the mercurial_ project.
+
+    .. _pyramid: http://pypi.python.org/pypi/pyramid
+    .. _mercurial: http://pypi.python.org/pypi/Mercurial
+    """
+
+    __slots__ = ("wrapped",)
+
+    def __init__(self, wrapped):
+        if sys.version_info >= (3, 8):
+            warnings.warn(
+                "cachedproperty has been deprecated and will be removed in astroid 3.0 for Python 3.8+. "
+                "Use functools.cached_property instead.",
+                DeprecationWarning,
+            )
+        try:
+            wrapped.__name__
+        except AttributeError as exc:
+            raise TypeError(f"{wrapped} must have a __name__ attribute") from exc
+        self.wrapped = wrapped
+
+    @property
+    def __doc__(self):
+        doc = getattr(self.wrapped, "__doc__", None)
+        return "<wrapped by the cachedproperty decorator>%s" % (
+            "\n%s" % doc if doc else ""
+        )
+
+    def __get__(self, inst, objtype=None):
+        if inst is None:
+            return self
+        val = self.wrapped(inst)
+        setattr(inst, self.wrapped.__name__, val)
+        return val
+
+
+def path_wrapper(func):
+    """return the given infer function wrapped to handle the path
+
+    Used to stop inference if the node has already been looked
+    at for a given `InferenceContext` to prevent infinite recursion
+    """
+
+    @functools.wraps(func)
+    def wrapped(node, context=None, _func=func, **kwargs):
+        """wrapper function handling context"""
+        if context is None:
+            context = InferenceContext()
+        if context.push(node):
+            return
+
+        yielded = set()
+
+        for res in _func(node, context, **kwargs):
+            # unproxy only true instance, not const, tuple, dict...
+            if res.__class__.__name__ == "Instance":
+                ares = res._proxied
+            else:
+                ares = res
+            if ares not in yielded:
+                yield res
+                yielded.add(ares)
+
+    return wrapped
+
+
+@wrapt.decorator
+def yes_if_nothing_inferred(func, instance, args, kwargs):
+    generator = func(*args, **kwargs)
+
+    try:
+        yield next(generator)
+    except StopIteration:
+        # generator is empty
+        yield util.Uninferable
+        return
+
+    yield from generator
+
+
+@wrapt.decorator
+def raise_if_nothing_inferred(func, instance, args, kwargs):
+    generator = func(*args, **kwargs)
+    try:
+        yield next(generator)
+    except StopIteration as error:
+        # generator is empty
+        if error.args:
+            # pylint: disable=not-a-mapping
+            raise InferenceError(**error.args[0]) from error
+        raise InferenceError(
+            "StopIteration raised without any error information."
+        ) from error
+
+    yield from generator
+
+
+# Expensive decorators only used to emit Deprecation warnings.
+# If no other than the default DeprecationWarning are enabled,
+# fall back to passthrough implementations.
+if util.check_warnings_filter():
+
+    def deprecate_default_argument_values(
+        astroid_version: str = "3.0", **arguments: str
+    ) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """Decorator which emits a DeprecationWarning if any arguments specified
+        are None or not passed at all.
+
+        Arguments should be a key-value mapping, with the key being the argument to check
+        and the value being a type annotation as string for the value of the argument.
+
+        To improve performance, only used when DeprecationWarnings other than
+        the default one are enabled.
+        """
+        # Helpful links
+        # Decorator for DeprecationWarning: https://stackoverflow.com/a/49802489
+        # Typing of stacked decorators: https://stackoverflow.com/a/68290080
+
+        def deco(func: Callable[P, R]) -> Callable[P, R]:
+            """Decorator function."""
+
+            @functools.wraps(func)
+            def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+                """Emit DeprecationWarnings if conditions are met."""
+
+                keys = list(inspect.signature(func).parameters.keys())
+                for arg, type_annotation in arguments.items():
+                    try:
+                        index = keys.index(arg)
+                    except ValueError:
+                        raise Exception(
+                            f"Can't find argument '{arg}' for '{args[0].__class__.__qualname__}'"
+                        ) from None
+                    if (
+                        # Check kwargs
+                        # - if found, check it's not None
+                        (arg in kwargs and kwargs[arg] is None)
+                        # Check args
+                        # - make sure not in kwargs
+                        # - len(args) needs to be long enough, if too short
+                        #   arg can't be in args either
+                        # - args[index] should not be None
+                        or arg not in kwargs
+                        and (
+                            index == -1
+                            or len(args) <= index
+                            or (len(args) > index and args[index] is None)
+                        )
+                    ):
+                        warnings.warn(
+                            f"'{arg}' will be a required argument for "
+                            f"'{args[0].__class__.__qualname__}.{func.__name__}' in astroid {astroid_version} "
+                            f"('{arg}' should be of type: '{type_annotation}')",
+                            DeprecationWarning,
+                        )
+                return func(*args, **kwargs)
+
+            return wrapper
+
+        return deco
+
+    def deprecate_arguments(
+        astroid_version: str = "3.0", **arguments: str
+    ) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """Decorator which emits a DeprecationWarning if any arguments specified
+        are passed.
+
+        Arguments should be a key-value mapping, with the key being the argument to check
+        and the value being a string that explains what to do instead of passing the argument.
+
+        To improve performance, only used when DeprecationWarnings other than
+        the default one are enabled.
+        """
+
+        def deco(func: Callable[P, R]) -> Callable[P, R]:
+            @functools.wraps(func)
+            def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+
+                keys = list(inspect.signature(func).parameters.keys())
+                for arg, note in arguments.items():
+                    try:
+                        index = keys.index(arg)
+                    except ValueError:
+                        raise Exception(
+                            f"Can't find argument '{arg}' for '{args[0].__class__.__qualname__}'"
+                        ) from None
+                    if arg in kwargs or len(args) > index:
+                        warnings.warn(
+                            f"The argument '{arg}' for "
+                            f"'{args[0].__class__.__qualname__}.{func.__name__}' is deprecated "
+                            f"and will be removed in astroid {astroid_version} ({note})",
+                            DeprecationWarning,
+                        )
+                return func(*args, **kwargs)
+
+            return wrapper
+
+        return deco
+
+else:
+
+    def deprecate_default_argument_values(
+        astroid_version: str = "3.0", **arguments: str
+    ) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """Passthrough decorator to improve performance if DeprecationWarnings are disabled."""
+
+        def deco(func: Callable[P, R]) -> Callable[P, R]:
+            """Decorator function."""
+            return func
+
+        return deco
+
+    def deprecate_arguments(
+        astroid_version: str = "3.0", **arguments: str
+    ) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """Passthrough decorator to improve performance if DeprecationWarnings are disabled."""
+
+        def deco(func: Callable[P, R]) -> Callable[P, R]:
+            """Decorator function."""
+            return func
+
+        return deco
diff --git a/myenv/lib/python3.9/site-packages/astroid/exceptions.py b/myenv/lib/python3.9/site-packages/astroid/exceptions.py
new file mode 100644
index 0000000..c3909b2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/exceptions.py
@@ -0,0 +1,292 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""this module contains exceptions used in the astroid library
+"""
+from typing import TYPE_CHECKING
+
+from astroid import util
+
+if TYPE_CHECKING:
+    from astroid import nodes
+
+__all__ = (
+    "AstroidBuildingError",
+    "AstroidBuildingException",
+    "AstroidError",
+    "AstroidImportError",
+    "AstroidIndexError",
+    "AstroidSyntaxError",
+    "AstroidTypeError",
+    "AstroidValueError",
+    "AttributeInferenceError",
+    "BinaryOperationError",
+    "DuplicateBasesError",
+    "InconsistentMroError",
+    "InferenceError",
+    "InferenceOverwriteError",
+    "MroError",
+    "NameInferenceError",
+    "NoDefault",
+    "NotFoundError",
+    "OperationError",
+    "ParentMissingError",
+    "ResolveError",
+    "StatementMissing",
+    "SuperArgumentTypeError",
+    "SuperError",
+    "TooManyLevelsError",
+    "UnaryOperationError",
+    "UnresolvableName",
+    "UseInferenceDefault",
+)
+
+
+class AstroidError(Exception):
+    """base exception class for all astroid related exceptions
+
+    AstroidError and its subclasses are structured, intended to hold
+    objects representing state when the exception is thrown.  Field
+    values are passed to the constructor as keyword-only arguments.
+    Each subclass has its own set of standard fields, but use your
+    best judgment to decide whether a specific exception instance
+    needs more or fewer fields for debugging.  Field values may be
+    used to lazily generate the error message: self.message.format()
+    will be called with the field names and values supplied as keyword
+    arguments.
+    """
+
+    def __init__(self, message="", **kws):
+        super().__init__(message)
+        self.message = message
+        for key, value in kws.items():
+            setattr(self, key, value)
+
+    def __str__(self):
+        return self.message.format(**vars(self))
+
+
+class AstroidBuildingError(AstroidError):
+    """exception class when we are unable to build an astroid representation
+
+    Standard attributes:
+        modname: Name of the module that AST construction failed for.
+        error: Exception raised during construction.
+    """
+
+    def __init__(self, message="Failed to import module {modname}.", **kws):
+        super().__init__(message, **kws)
+
+
+class AstroidImportError(AstroidBuildingError):
+    """Exception class used when a module can't be imported by astroid."""
+
+
+class TooManyLevelsError(AstroidImportError):
+    """Exception class which is raised when a relative import was beyond the top-level.
+
+    Standard attributes:
+        level: The level which was attempted.
+        name: the name of the module on which the relative import was attempted.
+    """
+
+    level = None
+    name = None
+
+    def __init__(
+        self,
+        message="Relative import with too many levels " "({level}) for module {name!r}",
+        **kws,
+    ):
+        super().__init__(message, **kws)
+
+
+class AstroidSyntaxError(AstroidBuildingError):
+    """Exception class used when a module can't be parsed."""
+
+
+class NoDefault(AstroidError):
+    """raised by function's `default_value` method when an argument has
+    no default value
+
+    Standard attributes:
+        func: Function node.
+        name: Name of argument without a default.
+    """
+
+    func = None
+    name = None
+
+    def __init__(self, message="{func!r} has no default for {name!r}.", **kws):
+        super().__init__(message, **kws)
+
+
+class ResolveError(AstroidError):
+    """Base class of astroid resolution/inference error.
+
+    ResolveError is not intended to be raised.
+
+    Standard attributes:
+        context: InferenceContext object.
+    """
+
+    context = None
+
+
+class MroError(ResolveError):
+    """Error raised when there is a problem with method resolution of a class.
+
+    Standard attributes:
+        mros: A sequence of sequences containing ClassDef nodes.
+        cls: ClassDef node whose MRO resolution failed.
+        context: InferenceContext object.
+    """
+
+    mros = ()
+    cls = None
+
+    def __str__(self):
+        mro_names = ", ".join(f"({', '.join(b.name for b in m)})" for m in self.mros)
+        return self.message.format(mros=mro_names, cls=self.cls)
+
+
+class DuplicateBasesError(MroError):
+    """Error raised when there are duplicate bases in the same class bases."""
+
+
+class InconsistentMroError(MroError):
+    """Error raised when a class's MRO is inconsistent."""
+
+
+class SuperError(ResolveError):
+    """Error raised when there is a problem with a *super* call.
+
+    Standard attributes:
+        *super_*: The Super instance that raised the exception.
+        context: InferenceContext object.
+    """
+
+    super_ = None
+
+    def __str__(self):
+        return self.message.format(**vars(self.super_))
+
+
+class InferenceError(ResolveError):
+    """raised when we are unable to infer a node
+
+    Standard attributes:
+        node: The node inference was called on.
+        context: InferenceContext object.
+    """
+
+    node = None
+    context = None
+
+    def __init__(self, message="Inference failed for {node!r}.", **kws):
+        super().__init__(message, **kws)
+
+
+# Why does this inherit from InferenceError rather than ResolveError?
+# Changing it causes some inference tests to fail.
+class NameInferenceError(InferenceError):
+    """Raised when a name lookup fails, corresponds to NameError.
+
+    Standard attributes:
+        name: The name for which lookup failed, as a string.
+        scope: The node representing the scope in which the lookup occurred.
+        context: InferenceContext object.
+    """
+
+    name = None
+    scope = None
+
+    def __init__(self, message="{name!r} not found in {scope!r}.", **kws):
+        super().__init__(message, **kws)
+
+
+class AttributeInferenceError(ResolveError):
+    """Raised when an attribute lookup fails, corresponds to AttributeError.
+
+    Standard attributes:
+        target: The node for which lookup failed.
+        attribute: The attribute for which lookup failed, as a string.
+        context: InferenceContext object.
+    """
+
+    target = None
+    attribute = None
+
+    def __init__(self, message="{attribute!r} not found on {target!r}.", **kws):
+        super().__init__(message, **kws)
+
+
+class UseInferenceDefault(Exception):
+    """exception to be raised in custom inference function to indicate that it
+    should go back to the default behaviour
+    """
+
+
+class _NonDeducibleTypeHierarchy(Exception):
+    """Raised when is_subtype / is_supertype can't deduce the relation between two types."""
+
+
+class AstroidIndexError(AstroidError):
+    """Raised when an Indexable / Mapping does not have an index / key."""
+
+
+class AstroidTypeError(AstroidError):
+    """Raised when a TypeError would be expected in Python code."""
+
+
+class AstroidValueError(AstroidError):
+    """Raised when a ValueError would be expected in Python code."""
+
+
+class InferenceOverwriteError(AstroidError):
+    """Raised when an inference tip is overwritten
+
+    Currently only used for debugging.
+    """
+
+
+class ParentMissingError(AstroidError):
+    """Raised when a node which is expected to have a parent attribute is missing one
+
+    Standard attributes:
+        target: The node for which the parent lookup failed.
+    """
+
+    def __init__(self, target: "nodes.NodeNG") -> None:
+        self.target = target
+        super().__init__(message=f"Parent not found on {target!r}.")
+
+
+class StatementMissing(ParentMissingError):
+    """Raised when a call to node.statement() does not return a node. This is because
+    a node in the chain does not have a parent attribute and therefore does not
+    return a node for statement().
+
+    Standard attributes:
+        target: The node for which the parent lookup failed.
+    """
+
+    def __init__(self, target: "nodes.NodeNG") -> None:
+        # pylint: disable-next=bad-super-call
+        # https://github.com/PyCQA/pylint/issues/2903
+        # https://github.com/PyCQA/astroid/pull/1217#discussion_r744149027
+        super(ParentMissingError, self).__init__(
+            message=f"Statement not found on {target!r}"
+        )
+
+
+# Backwards-compatibility aliases
+OperationError = util.BadOperationMessage
+UnaryOperationError = util.BadUnaryOperationMessage
+BinaryOperationError = util.BadBinaryOperationMessage
+
+SuperArgumentTypeError = SuperError
+UnresolvableName = NameInferenceError
+NotFoundError = AttributeInferenceError
+AstroidBuildingException = AstroidBuildingError
diff --git a/myenv/lib/python3.9/site-packages/astroid/filter_statements.py b/myenv/lib/python3.9/site-packages/astroid/filter_statements.py
new file mode 100644
index 0000000..86a63f3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/filter_statements.py
@@ -0,0 +1,239 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""_filter_stmts and helper functions. This method gets used in LocalsDictnodes.NodeNG._scope_lookup.
+It is not considered public.
+"""
+
+from typing import List, Optional, Tuple
+
+from astroid import nodes
+
+
+def _get_filtered_node_statements(
+    base_node: nodes.NodeNG, stmt_nodes: List[nodes.NodeNG]
+) -> List[Tuple[nodes.NodeNG, nodes.Statement]]:
+    statements = [(node, node.statement(future=True)) for node in stmt_nodes]
+    # Next we check if we have ExceptHandlers that are parent
+    # of the underlying variable, in which case the last one survives
+    if len(statements) > 1 and all(
+        isinstance(stmt, nodes.ExceptHandler) for _, stmt in statements
+    ):
+        statements = [
+            (node, stmt) for node, stmt in statements if stmt.parent_of(base_node)
+        ]
+    return statements
+
+
+def _is_from_decorator(node):
+    """Return True if the given node is the child of a decorator"""
+    return any(isinstance(parent, nodes.Decorators) for parent in node.node_ancestors())
+
+
+def _get_if_statement_ancestor(node: nodes.NodeNG) -> Optional[nodes.If]:
+    """Return the first parent node that is an If node (or None)"""
+    for parent in node.node_ancestors():
+        if isinstance(parent, nodes.If):
+            return parent
+    return None
+
+
+def _filter_stmts(base_node: nodes.NodeNG, stmts, frame, offset):
+    """Filter the given list of statements to remove ignorable statements.
+
+    If base_node is not a frame itself and the name is found in the inner
+    frame locals, statements will be filtered to remove ignorable
+    statements according to base_node's location.
+
+    :param stmts: The statements to filter.
+    :type stmts: list(nodes.NodeNG)
+
+    :param frame: The frame that all of the given statements belong to.
+    :type frame: nodes.NodeNG
+
+    :param offset: The line offset to filter statements up to.
+    :type offset: int
+
+    :returns: The filtered statements.
+    :rtype: list(nodes.NodeNG)
+    """
+    # if offset == -1, my actual frame is not the inner frame but its parent
+    #
+    # class A(B): pass
+    #
+    # we need this to resolve B correctly
+    if offset == -1:
+        myframe = base_node.frame().parent.frame()
+    else:
+        myframe = base_node.frame()
+        # If the frame of this node is the same as the statement
+        # of this node, then the node is part of a class or
+        # a function definition and the frame of this node should be the
+        # the upper frame, not the frame of the definition.
+        # For more information why this is important,
+        # see Pylint issue #295.
+        # For example, for 'b', the statement is the same
+        # as the frame / scope:
+        #
+        # def test(b=1):
+        #     ...
+        if (
+            base_node.parent
+            and base_node.statement(future=True) is myframe
+            and myframe.parent
+        ):
+            myframe = myframe.parent.frame()
+
+    mystmt: Optional[nodes.Statement] = None
+    if base_node.parent:
+        mystmt = base_node.statement(future=True)
+
+    # line filtering if we are in the same frame
+    #
+    # take care node may be missing lineno information (this is the case for
+    # nodes inserted for living objects)
+    if myframe is frame and mystmt and mystmt.fromlineno is not None:
+        assert mystmt.fromlineno is not None, mystmt
+        mylineno = mystmt.fromlineno + offset
+    else:
+        # disabling lineno filtering
+        mylineno = 0
+
+    _stmts = []
+    _stmt_parents = []
+    statements = _get_filtered_node_statements(base_node, stmts)
+    for node, stmt in statements:
+        # line filtering is on and we have reached our location, break
+        if stmt.fromlineno and stmt.fromlineno > mylineno > 0:
+            break
+        # Ignore decorators with the same name as the
+        # decorated function
+        # Fixes issue #375
+        if mystmt is stmt and _is_from_decorator(base_node):
+            continue
+        if node.has_base(base_node):
+            break
+
+        if isinstance(node, nodes.EmptyNode):
+            # EmptyNode does not have assign_type(), so just add it and move on
+            _stmts.append(node)
+            continue
+
+        assign_type = node.assign_type()
+        _stmts, done = assign_type._get_filtered_stmts(base_node, node, _stmts, mystmt)
+        if done:
+            break
+
+        optional_assign = assign_type.optional_assign
+        if optional_assign and assign_type.parent_of(base_node):
+            # we are inside a loop, loop var assignment is hiding previous
+            # assignment
+            _stmts = [node]
+            _stmt_parents = [stmt.parent]
+            continue
+
+        if isinstance(assign_type, nodes.NamedExpr):
+            # If the NamedExpr is in an if statement we do some basic control flow inference
+            if_parent = _get_if_statement_ancestor(assign_type)
+            if if_parent:
+                # If the if statement is within another if statement we append the node
+                # to possible statements
+                if _get_if_statement_ancestor(if_parent):
+                    optional_assign = False
+                    _stmts.append(node)
+                    _stmt_parents.append(stmt.parent)
+                # If the if statement is first-level and not within an orelse block
+                # we know that it will be evaluated
+                elif not if_parent.is_orelse:
+                    _stmts = [node]
+                    _stmt_parents = [stmt.parent]
+                # Else we do not known enough about the control flow to be 100% certain
+                # and we append to possible statements
+                else:
+                    _stmts.append(node)
+                    _stmt_parents.append(stmt.parent)
+            else:
+                _stmts = [node]
+                _stmt_parents = [stmt.parent]
+
+        # XXX comment various branches below!!!
+        try:
+            pindex = _stmt_parents.index(stmt.parent)
+        except ValueError:
+            pass
+        else:
+            # we got a parent index, this means the currently visited node
+            # is at the same block level as a previously visited node
+            if _stmts[pindex].assign_type().parent_of(assign_type):
+                # both statements are not at the same block level
+                continue
+            # if currently visited node is following previously considered
+            # assignment and both are not exclusive, we can drop the
+            # previous one. For instance in the following code ::
+            #
+            #   if a:
+            #     x = 1
+            #   else:
+            #     x = 2
+            #   print x
+            #
+            # we can't remove neither x = 1 nor x = 2 when looking for 'x'
+            # of 'print x'; while in the following ::
+            #
+            #   x = 1
+            #   x = 2
+            #   print x
+            #
+            # we can remove x = 1 when we see x = 2
+            #
+            # moreover, on loop assignment types, assignment won't
+            # necessarily be done if the loop has no iteration, so we don't
+            # want to clear previous assignments if any (hence the test on
+            # optional_assign)
+            if not (optional_assign or nodes.are_exclusive(_stmts[pindex], node)):
+                del _stmt_parents[pindex]
+                del _stmts[pindex]
+
+        # If base_node and node are exclusive, then we can ignore node
+        if nodes.are_exclusive(base_node, node):
+            continue
+
+        # An AssignName node overrides previous assignments if:
+        #   1. node's statement always assigns
+        #   2. node and base_node are in the same block (i.e., has the same parent as base_node)
+        if isinstance(node, (nodes.NamedExpr, nodes.AssignName)):
+            if isinstance(stmt, nodes.ExceptHandler):
+                # If node's statement is an ExceptHandler, then it is the variable
+                # bound to the caught exception. If base_node is not contained within
+                # the exception handler block, node should override previous assignments;
+                # otherwise, node should be ignored, as an exception variable
+                # is local to the handler block.
+                if stmt.parent_of(base_node):
+                    _stmts = []
+                    _stmt_parents = []
+                else:
+                    continue
+            elif not optional_assign and mystmt and stmt.parent is mystmt.parent:
+                _stmts = []
+                _stmt_parents = []
+        elif isinstance(node, nodes.DelName):
+            # Remove all previously stored assignments
+            _stmts = []
+            _stmt_parents = []
+            continue
+        # Add the new assignment
+        _stmts.append(node)
+        if isinstance(node, nodes.Arguments) or isinstance(
+            node.parent, nodes.Arguments
+        ):
+            # Special case for _stmt_parents when node is a function parameter;
+            # in this case, stmt is the enclosing FunctionDef, which is what we
+            # want to add to _stmt_parents, not stmt.parent. This case occurs when
+            # node is an Arguments node (representing varargs or kwargs parameter),
+            # and when node.parent is an Arguments node (other parameters).
+            # See issue #180.
+            _stmt_parents.append(stmt)
+        else:
+            _stmt_parents.append(stmt.parent)
+    return _stmts
diff --git a/myenv/lib/python3.9/site-packages/astroid/helpers.py b/myenv/lib/python3.9/site-packages/astroid/helpers.py
new file mode 100644
index 0000000..8462f87
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/helpers.py
@@ -0,0 +1,304 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""
+Various helper utilities.
+"""
+
+
+from astroid import bases, manager, nodes, raw_building, util
+from astroid.context import CallContext, InferenceContext
+from astroid.exceptions import (
+    AstroidTypeError,
+    AttributeInferenceError,
+    InferenceError,
+    MroError,
+    _NonDeducibleTypeHierarchy,
+)
+from astroid.nodes import scoped_nodes
+
+
+def _build_proxy_class(cls_name, builtins):
+    proxy = raw_building.build_class(cls_name)
+    proxy.parent = builtins
+    return proxy
+
+
+def _function_type(function, builtins):
+    if isinstance(function, scoped_nodes.Lambda):
+        if function.root().name == "builtins":
+            cls_name = "builtin_function_or_method"
+        else:
+            cls_name = "function"
+    elif isinstance(function, bases.BoundMethod):
+        cls_name = "method"
+    elif isinstance(function, bases.UnboundMethod):
+        cls_name = "function"
+    return _build_proxy_class(cls_name, builtins)
+
+
+def _object_type(node, context=None):
+    astroid_manager = manager.AstroidManager()
+    builtins = astroid_manager.builtins_module
+    context = context or InferenceContext()
+
+    for inferred in node.infer(context=context):
+        if isinstance(inferred, scoped_nodes.ClassDef):
+            if inferred.newstyle:
+                metaclass = inferred.metaclass(context=context)
+                if metaclass:
+                    yield metaclass
+                    continue
+            yield builtins.getattr("type")[0]
+        elif isinstance(inferred, (scoped_nodes.Lambda, bases.UnboundMethod)):
+            yield _function_type(inferred, builtins)
+        elif isinstance(inferred, scoped_nodes.Module):
+            yield _build_proxy_class("module", builtins)
+        elif isinstance(inferred, nodes.Unknown):
+            raise InferenceError
+        else:
+            yield inferred._proxied
+
+
+def object_type(node, context=None):
+    """Obtain the type of the given node
+
+    This is used to implement the ``type`` builtin, which means that it's
+    used for inferring type calls, as well as used in a couple of other places
+    in the inference.
+    The node will be inferred first, so this function can support all
+    sorts of objects, as long as they support inference.
+    """
+
+    try:
+        types = set(_object_type(node, context))
+    except InferenceError:
+        return util.Uninferable
+    if len(types) > 1 or not types:
+        return util.Uninferable
+    return list(types)[0]
+
+
+def _object_type_is_subclass(obj_type, class_or_seq, context=None):
+    if not isinstance(class_or_seq, (tuple, list)):
+        class_seq = (class_or_seq,)
+    else:
+        class_seq = class_or_seq
+
+    if obj_type is util.Uninferable:
+        return util.Uninferable
+
+    # Instances are not types
+    class_seq = [
+        item if not isinstance(item, bases.Instance) else util.Uninferable
+        for item in class_seq
+    ]
+    # strict compatibility with issubclass
+    # issubclass(type, (object, 1)) evaluates to true
+    # issubclass(object, (1, type)) raises TypeError
+    for klass in class_seq:
+        if klass is util.Uninferable:
+            raise AstroidTypeError("arg 2 must be a type or tuple of types")
+
+        for obj_subclass in obj_type.mro():
+            if obj_subclass == klass:
+                return True
+    return False
+
+
+def object_isinstance(node, class_or_seq, context=None):
+    """Check if a node 'isinstance' any node in class_or_seq
+
+    :param node: A given node
+    :param class_or_seq: Union[nodes.NodeNG, Sequence[nodes.NodeNG]]
+    :rtype: bool
+
+    :raises AstroidTypeError: if the given ``classes_or_seq`` are not types
+    """
+    obj_type = object_type(node, context)
+    if obj_type is util.Uninferable:
+        return util.Uninferable
+    return _object_type_is_subclass(obj_type, class_or_seq, context=context)
+
+
+def object_issubclass(node, class_or_seq, context=None):
+    """Check if a type is a subclass of any node in class_or_seq
+
+    :param node: A given node
+    :param class_or_seq: Union[Nodes.NodeNG, Sequence[nodes.NodeNG]]
+    :rtype: bool
+
+    :raises AstroidTypeError: if the given ``classes_or_seq`` are not types
+    :raises AstroidError: if the type of the given node cannot be inferred
+        or its type's mro doesn't work
+    """
+    if not isinstance(node, nodes.ClassDef):
+        raise TypeError(f"{node} needs to be a ClassDef node")
+    return _object_type_is_subclass(node, class_or_seq, context=context)
+
+
+def safe_infer(node, context=None):
+    """Return the inferred value for the given node.
+
+    Return None if inference failed or if there is some ambiguity (more than
+    one node has been inferred).
+    """
+    try:
+        inferit = node.infer(context=context)
+        value = next(inferit)
+    except (InferenceError, StopIteration):
+        return None
+    try:
+        next(inferit)
+        return None  # None if there is ambiguity on the inferred node
+    except InferenceError:
+        return None  # there is some kind of ambiguity
+    except StopIteration:
+        return value
+
+
+def has_known_bases(klass, context=None):
+    """Return true if all base classes of a class could be inferred."""
+    try:
+        return klass._all_bases_known
+    except AttributeError:
+        pass
+    for base in klass.bases:
+        result = safe_infer(base, context=context)
+        # TODO: check for A->B->A->B pattern in class structure too?
+        if (
+            not isinstance(result, scoped_nodes.ClassDef)
+            or result is klass
+            or not has_known_bases(result, context=context)
+        ):
+            klass._all_bases_known = False
+            return False
+    klass._all_bases_known = True
+    return True
+
+
+def _type_check(type1, type2):
+    if not all(map(has_known_bases, (type1, type2))):
+        raise _NonDeducibleTypeHierarchy
+
+    if not all([type1.newstyle, type2.newstyle]):
+        return False
+    try:
+        return type1 in type2.mro()[:-1]
+    except MroError as e:
+        # The MRO is invalid.
+        raise _NonDeducibleTypeHierarchy from e
+
+
+def is_subtype(type1, type2):
+    """Check if *type1* is a subtype of *type2*."""
+    return _type_check(type1=type2, type2=type1)
+
+
+def is_supertype(type1, type2):
+    """Check if *type2* is a supertype of *type1*."""
+    return _type_check(type1, type2)
+
+
+def class_instance_as_index(node):
+    """Get the value as an index for the given instance.
+
+    If an instance provides an __index__ method, then it can
+    be used in some scenarios where an integer is expected,
+    for instance when multiplying or subscripting a list.
+    """
+    context = InferenceContext()
+    try:
+        for inferred in node.igetattr("__index__", context=context):
+            if not isinstance(inferred, bases.BoundMethod):
+                continue
+
+            context.boundnode = node
+            context.callcontext = CallContext(args=[], callee=inferred)
+            for result in inferred.infer_call_result(node, context=context):
+                if isinstance(result, nodes.Const) and isinstance(result.value, int):
+                    return result
+    except InferenceError:
+        pass
+    return None
+
+
+def object_len(node, context=None):
+    """Infer length of given node object
+
+    :param Union[nodes.ClassDef, nodes.Instance] node:
+    :param node: Node to infer length of
+
+    :raises AstroidTypeError: If an invalid node is returned
+        from __len__ method or no __len__ method exists
+    :raises InferenceError: If the given node cannot be inferred
+        or if multiple nodes are inferred or if the code executed in python
+        would result in a infinite recursive check for length
+    :rtype int: Integer length of node
+    """
+    # pylint: disable=import-outside-toplevel; circular import
+    from astroid.objects import FrozenSet
+
+    inferred_node = safe_infer(node, context=context)
+
+    # prevent self referential length calls from causing a recursion error
+    # see https://github.com/PyCQA/astroid/issues/777
+    node_frame = node.frame(future=True)
+    if (
+        isinstance(node_frame, scoped_nodes.FunctionDef)
+        and node_frame.name == "__len__"
+        and hasattr(inferred_node, "_proxied")
+        and inferred_node._proxied == node_frame.parent
+    ):
+        message = (
+            "Self referential __len__ function will "
+            "cause a RecursionError on line {} of {}".format(
+                node.lineno, node.root().file
+            )
+        )
+        raise InferenceError(message)
+
+    if inferred_node is None or inferred_node is util.Uninferable:
+        raise InferenceError(node=node)
+    if isinstance(inferred_node, nodes.Const) and isinstance(
+        inferred_node.value, (bytes, str)
+    ):
+        return len(inferred_node.value)
+    if isinstance(inferred_node, (nodes.List, nodes.Set, nodes.Tuple, FrozenSet)):
+        return len(inferred_node.elts)
+    if isinstance(inferred_node, nodes.Dict):
+        return len(inferred_node.items)
+
+    node_type = object_type(inferred_node, context=context)
+    if not node_type:
+        raise InferenceError(node=node)
+
+    try:
+        len_call = next(node_type.igetattr("__len__", context=context))
+    except StopIteration as e:
+        raise AstroidTypeError(str(e)) from e
+    except AttributeInferenceError as e:
+        raise AstroidTypeError(
+            f"object of type '{node_type.pytype()}' has no len()"
+        ) from e
+
+    inferred = len_call.infer_call_result(node, context)
+    if inferred is util.Uninferable:
+        raise InferenceError(node=node, context=context)
+    result_of_len = next(inferred, None)
+    if (
+        isinstance(result_of_len, nodes.Const)
+        and result_of_len.pytype() == "builtins.int"
+    ):
+        return result_of_len.value
+    if (
+        result_of_len is None
+        or isinstance(result_of_len, bases.Instance)
+        and result_of_len.is_subtype_of("builtins.int")
+    ):
+        # Fake a result as we don't know the arguments of the instance call.
+        return 0
+    raise AstroidTypeError(
+        f"'{result_of_len}' object cannot be interpreted as an integer"
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/inference.py b/myenv/lib/python3.9/site-packages/astroid/inference.py
new file mode 100644
index 0000000..d220300
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/inference.py
@@ -0,0 +1,1081 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""this module contains a set of functions to handle inference on astroid trees
+"""
+
+import ast
+import functools
+import itertools
+import operator
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    Iterable,
+    Iterator,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+)
+
+import wrapt
+
+from astroid import bases, decorators, helpers, nodes, protocols, util
+from astroid.context import (
+    CallContext,
+    InferenceContext,
+    bind_context_to_node,
+    copy_context,
+)
+from astroid.exceptions import (
+    AstroidBuildingError,
+    AstroidError,
+    AstroidIndexError,
+    AstroidTypeError,
+    AttributeInferenceError,
+    InferenceError,
+    NameInferenceError,
+    _NonDeducibleTypeHierarchy,
+)
+from astroid.interpreter import dunder_lookup
+from astroid.manager import AstroidManager
+from astroid.typing import InferenceErrorInfo
+
+if TYPE_CHECKING:
+    from astroid.objects import Property
+
+# Prevents circular imports
+objects = util.lazy_import("objects")
+
+
+_FunctionDefT = TypeVar("_FunctionDefT", bound=nodes.FunctionDef)
+
+
+# .infer method ###############################################################
+
+
+def infer_end(self, context=None):
+    """Inference's end for nodes that yield themselves on inference
+
+    These are objects for which inference does not have any semantic,
+    such as Module or Consts.
+    """
+    yield self
+
+
+# We add ignores to all these assignments in this file
+# See https://github.com/python/mypy/issues/2427
+nodes.Module._infer = infer_end  # type: ignore[assignment]
+nodes.ClassDef._infer = infer_end  # type: ignore[assignment]
+nodes.Lambda._infer = infer_end  # type: ignore[assignment]
+nodes.Const._infer = infer_end  # type: ignore[assignment]
+nodes.Slice._infer = infer_end  # type: ignore[assignment]
+
+
+def _infer_sequence_helper(node, context=None):
+    """Infer all values based on _BaseContainer.elts"""
+    values = []
+
+    for elt in node.elts:
+        if isinstance(elt, nodes.Starred):
+            starred = helpers.safe_infer(elt.value, context)
+            if not starred:
+                raise InferenceError(node=node, context=context)
+            if not hasattr(starred, "elts"):
+                raise InferenceError(node=node, context=context)
+            values.extend(_infer_sequence_helper(starred))
+        elif isinstance(elt, nodes.NamedExpr):
+            value = helpers.safe_infer(elt.value, context)
+            if not value:
+                raise InferenceError(node=node, context=context)
+            values.append(value)
+        else:
+            values.append(elt)
+    return values
+
+
+@decorators.raise_if_nothing_inferred
+def infer_sequence(self, context=None):
+    has_starred_named_expr = any(
+        isinstance(e, (nodes.Starred, nodes.NamedExpr)) for e in self.elts
+    )
+    if has_starred_named_expr:
+        values = _infer_sequence_helper(self, context)
+        new_seq = type(self)(
+            lineno=self.lineno, col_offset=self.col_offset, parent=self.parent
+        )
+        new_seq.postinit(values)
+
+        yield new_seq
+    else:
+        yield self
+
+
+nodes.List._infer = infer_sequence  # type: ignore[assignment]
+nodes.Tuple._infer = infer_sequence  # type: ignore[assignment]
+nodes.Set._infer = infer_sequence  # type: ignore[assignment]
+
+
+def infer_map(self, context=None):
+    if not any(isinstance(k, nodes.DictUnpack) for k, _ in self.items):
+        yield self
+    else:
+        items = _infer_map(self, context)
+        new_seq = type(self)(self.lineno, self.col_offset, self.parent)
+        new_seq.postinit(list(items.items()))
+        yield new_seq
+
+
+def _update_with_replacement(lhs_dict, rhs_dict):
+    """Delete nodes that equate to duplicate keys
+
+    Since an astroid node doesn't 'equal' another node with the same value,
+    this function uses the as_string method to make sure duplicate keys
+    don't get through
+
+    Note that both the key and the value are astroid nodes
+
+    Fixes issue with DictUnpack causing duplicte keys
+    in inferred Dict items
+
+    :param dict(nodes.NodeNG, nodes.NodeNG) lhs_dict: Dictionary to 'merge' nodes into
+    :param dict(nodes.NodeNG, nodes.NodeNG) rhs_dict: Dictionary with nodes to pull from
+    :return dict(nodes.NodeNG, nodes.NodeNG): merged dictionary of nodes
+    """
+    combined_dict = itertools.chain(lhs_dict.items(), rhs_dict.items())
+    # Overwrite keys which have the same string values
+    string_map = {key.as_string(): (key, value) for key, value in combined_dict}
+    # Return to dictionary
+    return dict(string_map.values())
+
+
+def _infer_map(node, context):
+    """Infer all values based on Dict.items"""
+    values = {}
+    for name, value in node.items:
+        if isinstance(name, nodes.DictUnpack):
+            double_starred = helpers.safe_infer(value, context)
+            if not double_starred:
+                raise InferenceError
+            if not isinstance(double_starred, nodes.Dict):
+                raise InferenceError(node=node, context=context)
+            unpack_items = _infer_map(double_starred, context)
+            values = _update_with_replacement(values, unpack_items)
+        else:
+            key = helpers.safe_infer(name, context=context)
+            value = helpers.safe_infer(value, context=context)
+            if any(not elem for elem in (key, value)):
+                raise InferenceError(node=node, context=context)
+            values = _update_with_replacement(values, {key: value})
+    return values
+
+
+nodes.Dict._infer = infer_map  # type: ignore[assignment]
+
+
+def _higher_function_scope(node):
+    """Search for the first function which encloses the given
+    scope. This can be used for looking up in that function's
+    scope, in case looking up in a lower scope for a particular
+    name fails.
+
+    :param node: A scope node.
+    :returns:
+        ``None``, if no parent function scope was found,
+        otherwise an instance of :class:`astroid.nodes.scoped_nodes.Function`,
+        which encloses the given node.
+    """
+    current = node
+    while current.parent and not isinstance(current.parent, nodes.FunctionDef):
+        current = current.parent
+    if current and current.parent:
+        return current.parent
+    return None
+
+
+def infer_name(self, context=None):
+    """infer a Name: use name lookup rules"""
+    frame, stmts = self.lookup(self.name)
+    if not stmts:
+        # Try to see if the name is enclosed in a nested function
+        # and use the higher (first function) scope for searching.
+        parent_function = _higher_function_scope(self.scope())
+        if parent_function:
+            _, stmts = parent_function.lookup(self.name)
+
+        if not stmts:
+            raise NameInferenceError(
+                name=self.name, scope=self.scope(), context=context
+            )
+    context = copy_context(context)
+    context.lookupname = self.name
+    return bases._infer_stmts(stmts, context, frame)
+
+
+# pylint: disable=no-value-for-parameter
+nodes.Name._infer = decorators.raise_if_nothing_inferred(
+    decorators.path_wrapper(infer_name)
+)
+nodes.AssignName.infer_lhs = infer_name  # won't work with a path wrapper
+
+
+@decorators.raise_if_nothing_inferred
+@decorators.path_wrapper
+def infer_call(self, context=None):
+    """infer a Call node by trying to guess what the function returns"""
+    callcontext = copy_context(context)
+    callcontext.boundnode = None
+    if context is not None:
+        callcontext.extra_context = _populate_context_lookup(self, context.clone())
+
+    for callee in self.func.infer(context):
+        if callee is util.Uninferable:
+            yield callee
+            continue
+        try:
+            if hasattr(callee, "infer_call_result"):
+                callcontext.callcontext = CallContext(
+                    args=self.args, keywords=self.keywords, callee=callee
+                )
+                yield from callee.infer_call_result(caller=self, context=callcontext)
+        except InferenceError:
+            continue
+    return dict(node=self, context=context)
+
+
+nodes.Call._infer = infer_call  # type: ignore[assignment]
+
+
+@decorators.raise_if_nothing_inferred
+@decorators.path_wrapper
+def infer_import(self, context=None, asname=True):
+    """infer an Import node: return the imported module/object"""
+    name = context.lookupname
+    if name is None:
+        raise InferenceError(node=self, context=context)
+
+    try:
+        if asname:
+            yield self.do_import_module(self.real_name(name))
+        else:
+            yield self.do_import_module(name)
+    except AstroidBuildingError as exc:
+        raise InferenceError(node=self, context=context) from exc
+
+
+nodes.Import._infer = infer_import
+
+
+@decorators.raise_if_nothing_inferred
+@decorators.path_wrapper
+def infer_import_from(self, context=None, asname=True):
+    """infer a ImportFrom node: return the imported module/object"""
+    name = context.lookupname
+    if name is None:
+        raise InferenceError(node=self, context=context)
+    if asname:
+        try:
+            name = self.real_name(name)
+        except AttributeInferenceError as exc:
+            # See https://github.com/PyCQA/pylint/issues/4692
+            raise InferenceError(node=self, context=context) from exc
+    try:
+        module = self.do_import_module()
+    except AstroidBuildingError as exc:
+        raise InferenceError(node=self, context=context) from exc
+
+    try:
+        context = copy_context(context)
+        context.lookupname = name
+        stmts = module.getattr(name, ignore_locals=module is self.root())
+        return bases._infer_stmts(stmts, context)
+    except AttributeInferenceError as error:
+        raise InferenceError(
+            str(error), target=self, attribute=name, context=context
+        ) from error
+
+
+nodes.ImportFrom._infer = infer_import_from  # type: ignore[assignment]
+
+
+def infer_attribute(self, context=None):
+    """infer an Attribute node by using getattr on the associated object"""
+    for owner in self.expr.infer(context):
+        if owner is util.Uninferable:
+            yield owner
+            continue
+
+        if not context:
+            context = InferenceContext()
+        else:
+            context = copy_context(context)
+
+        old_boundnode = context.boundnode
+        try:
+            context.boundnode = owner
+            yield from owner.igetattr(self.attrname, context)
+        except (
+            AttributeInferenceError,
+            InferenceError,
+            AttributeError,
+        ):
+            pass
+        finally:
+            context.boundnode = old_boundnode
+    return dict(node=self, context=context)
+
+
+nodes.Attribute._infer = decorators.raise_if_nothing_inferred(
+    decorators.path_wrapper(infer_attribute)
+)
+# won't work with a path wrapper
+nodes.AssignAttr.infer_lhs = decorators.raise_if_nothing_inferred(infer_attribute)
+
+
+@decorators.raise_if_nothing_inferred
+@decorators.path_wrapper
+def infer_global(self, context=None):
+    if context.lookupname is None:
+        raise InferenceError(node=self, context=context)
+    try:
+        return bases._infer_stmts(self.root().getattr(context.lookupname), context)
+    except AttributeInferenceError as error:
+        raise InferenceError(
+            str(error), target=self, attribute=context.lookupname, context=context
+        ) from error
+
+
+nodes.Global._infer = infer_global  # type: ignore[assignment]
+
+
+_SUBSCRIPT_SENTINEL = object()
+
+
+def infer_subscript(self, context=None):
+    """Inference for subscripts
+
+    We're understanding if the index is a Const
+    or a slice, passing the result of inference
+    to the value's `getitem` method, which should
+    handle each supported index type accordingly.
+    """
+
+    found_one = False
+    for value in self.value.infer(context):
+        if value is util.Uninferable:
+            yield util.Uninferable
+            return None
+        for index in self.slice.infer(context):
+            if index is util.Uninferable:
+                yield util.Uninferable
+                return None
+
+            # Try to deduce the index value.
+            index_value = _SUBSCRIPT_SENTINEL
+            if value.__class__ == bases.Instance:
+                index_value = index
+            elif index.__class__ == bases.Instance:
+                instance_as_index = helpers.class_instance_as_index(index)
+                if instance_as_index:
+                    index_value = instance_as_index
+            else:
+                index_value = index
+
+            if index_value is _SUBSCRIPT_SENTINEL:
+                raise InferenceError(node=self, context=context)
+
+            try:
+                assigned = value.getitem(index_value, context)
+            except (
+                AstroidTypeError,
+                AstroidIndexError,
+                AttributeInferenceError,
+                AttributeError,
+            ) as exc:
+                raise InferenceError(node=self, context=context) from exc
+
+            # Prevent inferring if the inferred subscript
+            # is the same as the original subscripted object.
+            if self is assigned or assigned is util.Uninferable:
+                yield util.Uninferable
+                return None
+            yield from assigned.infer(context)
+            found_one = True
+
+    if found_one:
+        return dict(node=self, context=context)
+    return None
+
+
+nodes.Subscript._infer = decorators.raise_if_nothing_inferred(  # type: ignore[assignment]
+    decorators.path_wrapper(infer_subscript)
+)
+nodes.Subscript.infer_lhs = decorators.raise_if_nothing_inferred(infer_subscript)
+
+
+@decorators.raise_if_nothing_inferred
+@decorators.path_wrapper
+def _infer_boolop(self, context=None):
+    """Infer a boolean operation (and / or / not).
+
+    The function will calculate the boolean operation
+    for all pairs generated through inference for each component
+    node.
+    """
+    values = self.values
+    if self.op == "or":
+        predicate = operator.truth
+    else:
+        predicate = operator.not_
+
+    try:
+        values = [value.infer(context=context) for value in values]
+    except InferenceError:
+        yield util.Uninferable
+        return None
+
+    for pair in itertools.product(*values):
+        if any(item is util.Uninferable for item in pair):
+            # Can't infer the final result, just yield Uninferable.
+            yield util.Uninferable
+            continue
+
+        bool_values = [item.bool_value() for item in pair]
+        if any(item is util.Uninferable for item in bool_values):
+            # Can't infer the final result, just yield Uninferable.
+            yield util.Uninferable
+            continue
+
+        # Since the boolean operations are short circuited operations,
+        # this code yields the first value for which the predicate is True
+        # and if no value respected the predicate, then the last value will
+        # be returned (or Uninferable if there was no last value).
+        # This is conforming to the semantics of `and` and `or`:
+        #   1 and 0 -> 1
+        #   0 and 1 -> 0
+        #   1 or 0 -> 1
+        #   0 or 1 -> 1
+        value = util.Uninferable
+        for value, bool_value in zip(pair, bool_values):
+            if predicate(bool_value):
+                yield value
+                break
+        else:
+            yield value
+
+    return dict(node=self, context=context)
+
+
+nodes.BoolOp._infer = _infer_boolop
+
+
+# UnaryOp, BinOp and AugAssign inferences
+
+
+def _filter_operation_errors(self, infer_callable, context, error):
+    for result in infer_callable(self, context):
+        if isinstance(result, error):
+            # For the sake of .infer(), we don't care about operation
+            # errors, which is the job of pylint. So return something
+            # which shows that we can't infer the result.
+            yield util.Uninferable
+        else:
+            yield result
+
+
+def _infer_unaryop(self, context=None):
+    """Infer what an UnaryOp should return when evaluated."""
+    for operand in self.operand.infer(context):
+        try:
+            yield operand.infer_unary_op(self.op)
+        except TypeError as exc:
+            # The operand doesn't support this operation.
+            yield util.BadUnaryOperationMessage(operand, self.op, exc)
+        except AttributeError as exc:
+            meth = protocols.UNARY_OP_METHOD[self.op]
+            if meth is None:
+                # `not node`. Determine node's boolean
+                # value and negate its result, unless it is
+                # Uninferable, which will be returned as is.
+                bool_value = operand.bool_value()
+                if bool_value is not util.Uninferable:
+                    yield nodes.const_factory(not bool_value)
+                else:
+                    yield util.Uninferable
+            else:
+                if not isinstance(operand, (bases.Instance, nodes.ClassDef)):
+                    # The operation was used on something which
+                    # doesn't support it.
+                    yield util.BadUnaryOperationMessage(operand, self.op, exc)
+                    continue
+
+                try:
+                    try:
+                        methods = dunder_lookup.lookup(operand, meth)
+                    except AttributeInferenceError:
+                        yield util.BadUnaryOperationMessage(operand, self.op, exc)
+                        continue
+
+                    meth = methods[0]
+                    inferred = next(meth.infer(context=context), None)
+                    if inferred is util.Uninferable or not inferred.callable():
+                        continue
+
+                    context = copy_context(context)
+                    context.boundnode = operand
+                    context.callcontext = CallContext(args=[], callee=inferred)
+
+                    call_results = inferred.infer_call_result(self, context=context)
+                    result = next(call_results, None)
+                    if result is None:
+                        # Failed to infer, return the same type.
+                        yield operand
+                    else:
+                        yield result
+                except AttributeInferenceError as exc:
+                    # The unary operation special method was not found.
+                    yield util.BadUnaryOperationMessage(operand, self.op, exc)
+                except InferenceError:
+                    yield util.Uninferable
+
+
+@decorators.raise_if_nothing_inferred
+@decorators.path_wrapper
+def infer_unaryop(self, context=None):
+    """Infer what an UnaryOp should return when evaluated."""
+    yield from _filter_operation_errors(
+        self, _infer_unaryop, context, util.BadUnaryOperationMessage
+    )
+    return dict(node=self, context=context)
+
+
+nodes.UnaryOp._infer_unaryop = _infer_unaryop
+nodes.UnaryOp._infer = infer_unaryop
+
+
+def _is_not_implemented(const):
+    """Check if the given const node is NotImplemented."""
+    return isinstance(const, nodes.Const) and const.value is NotImplemented
+
+
+def _invoke_binop_inference(instance, opnode, op, other, context, method_name):
+    """Invoke binary operation inference on the given instance."""
+    methods = dunder_lookup.lookup(instance, method_name)
+    context = bind_context_to_node(context, instance)
+    method = methods[0]
+    context.callcontext.callee = method
+    try:
+        inferred = next(method.infer(context=context))
+    except StopIteration as e:
+        raise InferenceError(node=method, context=context) from e
+    if inferred is util.Uninferable:
+        raise InferenceError
+    return instance.infer_binary_op(opnode, op, other, context, inferred)
+
+
+def _aug_op(instance, opnode, op, other, context, reverse=False):
+    """Get an inference callable for an augmented binary operation."""
+    method_name = protocols.AUGMENTED_OP_METHOD[op]
+    return functools.partial(
+        _invoke_binop_inference,
+        instance=instance,
+        op=op,
+        opnode=opnode,
+        other=other,
+        context=context,
+        method_name=method_name,
+    )
+
+
+def _bin_op(instance, opnode, op, other, context, reverse=False):
+    """Get an inference callable for a normal binary operation.
+
+    If *reverse* is True, then the reflected method will be used instead.
+    """
+    if reverse:
+        method_name = protocols.REFLECTED_BIN_OP_METHOD[op]
+    else:
+        method_name = protocols.BIN_OP_METHOD[op]
+    return functools.partial(
+        _invoke_binop_inference,
+        instance=instance,
+        op=op,
+        opnode=opnode,
+        other=other,
+        context=context,
+        method_name=method_name,
+    )
+
+
+def _get_binop_contexts(context, left, right):
+    """Get contexts for binary operations.
+
+    This will return two inference contexts, the first one
+    for x.__op__(y), the other one for y.__rop__(x), where
+    only the arguments are inversed.
+    """
+    # The order is important, since the first one should be
+    # left.__op__(right).
+    for arg in (right, left):
+        new_context = context.clone()
+        new_context.callcontext = CallContext(args=[arg])
+        new_context.boundnode = None
+        yield new_context
+
+
+def _same_type(type1, type2):
+    """Check if type1 is the same as type2."""
+    return type1.qname() == type2.qname()
+
+
+def _get_binop_flow(
+    left, left_type, binary_opnode, right, right_type, context, reverse_context
+):
+    """Get the flow for binary operations.
+
+    The rules are a bit messy:
+
+        * if left and right have the same type, then only one
+          method will be called, left.__op__(right)
+        * if left and right are unrelated typewise, then first
+          left.__op__(right) is tried and if this does not exist
+          or returns NotImplemented, then right.__rop__(left) is tried.
+        * if left is a subtype of right, then only left.__op__(right)
+          is tried.
+        * if left is a supertype of right, then right.__rop__(left)
+          is first tried and then left.__op__(right)
+    """
+    op = binary_opnode.op
+    if _same_type(left_type, right_type):
+        methods = [_bin_op(left, binary_opnode, op, right, context)]
+    elif helpers.is_subtype(left_type, right_type):
+        methods = [_bin_op(left, binary_opnode, op, right, context)]
+    elif helpers.is_supertype(left_type, right_type):
+        methods = [
+            _bin_op(right, binary_opnode, op, left, reverse_context, reverse=True),
+            _bin_op(left, binary_opnode, op, right, context),
+        ]
+    else:
+        methods = [
+            _bin_op(left, binary_opnode, op, right, context),
+            _bin_op(right, binary_opnode, op, left, reverse_context, reverse=True),
+        ]
+    return methods
+
+
+def _get_aug_flow(
+    left, left_type, aug_opnode, right, right_type, context, reverse_context
+):
+    """Get the flow for augmented binary operations.
+
+    The rules are a bit messy:
+
+        * if left and right have the same type, then left.__augop__(right)
+          is first tried and then left.__op__(right).
+        * if left and right are unrelated typewise, then
+          left.__augop__(right) is tried, then left.__op__(right)
+          is tried and then right.__rop__(left) is tried.
+        * if left is a subtype of right, then left.__augop__(right)
+          is tried and then left.__op__(right).
+        * if left is a supertype of right, then left.__augop__(right)
+          is tried, then right.__rop__(left) and then
+          left.__op__(right)
+    """
+    bin_op = aug_opnode.op.strip("=")
+    aug_op = aug_opnode.op
+    if _same_type(left_type, right_type):
+        methods = [
+            _aug_op(left, aug_opnode, aug_op, right, context),
+            _bin_op(left, aug_opnode, bin_op, right, context),
+        ]
+    elif helpers.is_subtype(left_type, right_type):
+        methods = [
+            _aug_op(left, aug_opnode, aug_op, right, context),
+            _bin_op(left, aug_opnode, bin_op, right, context),
+        ]
+    elif helpers.is_supertype(left_type, right_type):
+        methods = [
+            _aug_op(left, aug_opnode, aug_op, right, context),
+            _bin_op(right, aug_opnode, bin_op, left, reverse_context, reverse=True),
+            _bin_op(left, aug_opnode, bin_op, right, context),
+        ]
+    else:
+        methods = [
+            _aug_op(left, aug_opnode, aug_op, right, context),
+            _bin_op(left, aug_opnode, bin_op, right, context),
+            _bin_op(right, aug_opnode, bin_op, left, reverse_context, reverse=True),
+        ]
+    return methods
+
+
+def _infer_binary_operation(left, right, binary_opnode, context, flow_factory):
+    """Infer a binary operation between a left operand and a right operand
+
+    This is used by both normal binary operations and augmented binary
+    operations, the only difference is the flow factory used.
+    """
+
+    context, reverse_context = _get_binop_contexts(context, left, right)
+    left_type = helpers.object_type(left)
+    right_type = helpers.object_type(right)
+    methods = flow_factory(
+        left, left_type, binary_opnode, right, right_type, context, reverse_context
+    )
+    for method in methods:
+        try:
+            results = list(method())
+        except AttributeError:
+            continue
+        except AttributeInferenceError:
+            continue
+        except InferenceError:
+            yield util.Uninferable
+            return
+        else:
+            if any(result is util.Uninferable for result in results):
+                yield util.Uninferable
+                return
+
+            if all(map(_is_not_implemented, results)):
+                continue
+            not_implemented = sum(
+                1 for result in results if _is_not_implemented(result)
+            )
+            if not_implemented and not_implemented != len(results):
+                # Can't infer yet what this is.
+                yield util.Uninferable
+                return
+
+            yield from results
+            return
+    # The operation doesn't seem to be supported so let the caller know about it
+    yield util.BadBinaryOperationMessage(left_type, binary_opnode.op, right_type)
+
+
+def _infer_binop(self, context):
+    """Binary operation inference logic."""
+    left = self.left
+    right = self.right
+
+    # we use two separate contexts for evaluating lhs and rhs because
+    # 1. evaluating lhs may leave some undesired entries in context.path
+    #    which may not let us infer right value of rhs
+    context = context or InferenceContext()
+    lhs_context = copy_context(context)
+    rhs_context = copy_context(context)
+    lhs_iter = left.infer(context=lhs_context)
+    rhs_iter = right.infer(context=rhs_context)
+    for lhs, rhs in itertools.product(lhs_iter, rhs_iter):
+        if any(value is util.Uninferable for value in (rhs, lhs)):
+            # Don't know how to process this.
+            yield util.Uninferable
+            return
+
+        try:
+            yield from _infer_binary_operation(lhs, rhs, self, context, _get_binop_flow)
+        except _NonDeducibleTypeHierarchy:
+            yield util.Uninferable
+
+
+@decorators.yes_if_nothing_inferred
+@decorators.path_wrapper
+def infer_binop(self, context=None):
+    return _filter_operation_errors(
+        self, _infer_binop, context, util.BadBinaryOperationMessage
+    )
+
+
+nodes.BinOp._infer_binop = _infer_binop
+nodes.BinOp._infer = infer_binop
+
+COMPARE_OPS: Dict[str, Callable[[Any, Any], bool]] = {
+    "==": operator.eq,
+    "!=": operator.ne,
+    "<": operator.lt,
+    "<=": operator.le,
+    ">": operator.gt,
+    ">=": operator.ge,
+    "in": lambda a, b: a in b,
+    "not in": lambda a, b: a not in b,
+}
+UNINFERABLE_OPS = {
+    "is",
+    "is not",
+}
+
+
+def _to_literal(node: nodes.NodeNG) -> Any:
+    # Can raise SyntaxError or ValueError from ast.literal_eval
+    # Can raise AttributeError from node.as_string() as not all nodes have a visitor
+    # Is this the stupidest idea or the simplest idea?
+    return ast.literal_eval(node.as_string())
+
+
+def _do_compare(
+    left_iter: Iterable[nodes.NodeNG], op: str, right_iter: Iterable[nodes.NodeNG]
+) -> "bool | type[util.Uninferable]":
+    """
+    If all possible combinations are either True or False, return that:
+    >>> _do_compare([1, 2], '<=', [3, 4])
+    True
+    >>> _do_compare([1, 2], '==', [3, 4])
+    False
+
+    If any item is uninferable, or if some combinations are True and some
+    are False, return Uninferable:
+    >>> _do_compare([1, 3], '<=', [2, 4])
+    util.Uninferable
+    """
+    retval: Union[None, bool] = None
+    if op in UNINFERABLE_OPS:
+        return util.Uninferable
+    op_func = COMPARE_OPS[op]
+
+    for left, right in itertools.product(left_iter, right_iter):
+        if left is util.Uninferable or right is util.Uninferable:
+            return util.Uninferable
+
+        try:
+            left, right = _to_literal(left), _to_literal(right)
+        except (SyntaxError, ValueError, AttributeError):
+            return util.Uninferable
+
+        try:
+            expr = op_func(left, right)
+        except TypeError as exc:
+            raise AstroidTypeError from exc
+
+        if retval is None:
+            retval = expr
+        elif retval != expr:
+            return util.Uninferable
+            # (or both, but "True | False" is basically the same)
+
+    assert retval is not None
+    return retval  # it was all the same value
+
+
+def _infer_compare(
+    self: nodes.Compare, context: Optional[InferenceContext] = None
+) -> Iterator[Union[nodes.Const, Type[util.Uninferable]]]:
+    """Chained comparison inference logic."""
+    retval: Union[bool, Type[util.Uninferable]] = True
+
+    ops = self.ops
+    left_node = self.left
+    lhs = list(left_node.infer(context=context))
+    # should we break early if first element is uninferable?
+    for op, right_node in ops:
+        # eagerly evaluate rhs so that values can be re-used as lhs
+        rhs = list(right_node.infer(context=context))
+        try:
+            retval = _do_compare(lhs, op, rhs)
+        except AstroidTypeError:
+            retval = util.Uninferable
+            break
+        if retval is not True:
+            break  # short-circuit
+        lhs = rhs  # continue
+    if retval is util.Uninferable:
+        yield retval  # type: ignore[misc]
+    else:
+        yield nodes.Const(retval)
+
+
+nodes.Compare._infer = _infer_compare  # type: ignore[assignment]
+
+
+def _infer_augassign(self, context=None):
+    """Inference logic for augmented binary operations."""
+    if context is None:
+        context = InferenceContext()
+
+    rhs_context = context.clone()
+
+    lhs_iter = self.target.infer_lhs(context=context)
+    rhs_iter = self.value.infer(context=rhs_context)
+    for lhs, rhs in itertools.product(lhs_iter, rhs_iter):
+        if any(value is util.Uninferable for value in (rhs, lhs)):
+            # Don't know how to process this.
+            yield util.Uninferable
+            return
+
+        try:
+            yield from _infer_binary_operation(
+                left=lhs,
+                right=rhs,
+                binary_opnode=self,
+                context=context,
+                flow_factory=_get_aug_flow,
+            )
+        except _NonDeducibleTypeHierarchy:
+            yield util.Uninferable
+
+
+@decorators.raise_if_nothing_inferred
+@decorators.path_wrapper
+def infer_augassign(self, context=None):
+    return _filter_operation_errors(
+        self, _infer_augassign, context, util.BadBinaryOperationMessage
+    )
+
+
+nodes.AugAssign._infer_augassign = _infer_augassign
+nodes.AugAssign._infer = infer_augassign
+
+# End of binary operation inference.
+
+
+@decorators.raise_if_nothing_inferred
+def infer_arguments(self, context=None):
+    name = context.lookupname
+    if name is None:
+        raise InferenceError(node=self, context=context)
+    return protocols._arguments_infer_argname(self, name, context)
+
+
+nodes.Arguments._infer = infer_arguments  # type: ignore[assignment]
+
+
+@decorators.raise_if_nothing_inferred
+@decorators.path_wrapper
+def infer_assign(self, context=None):
+    """infer a AssignName/AssignAttr: need to inspect the RHS part of the
+    assign node
+    """
+    if isinstance(self.parent, nodes.AugAssign):
+        return self.parent.infer(context)
+
+    stmts = list(self.assigned_stmts(context=context))
+    return bases._infer_stmts(stmts, context)
+
+
+nodes.AssignName._infer = infer_assign
+nodes.AssignAttr._infer = infer_assign
+
+
+@decorators.raise_if_nothing_inferred
+@decorators.path_wrapper
+def infer_empty_node(self, context=None):
+    if not self.has_underlying_object():
+        yield util.Uninferable
+    else:
+        try:
+            yield from AstroidManager().infer_ast_from_something(
+                self.object, context=context
+            )
+        except AstroidError:
+            yield util.Uninferable
+
+
+nodes.EmptyNode._infer = infer_empty_node  # type: ignore[assignment]
+
+
+@decorators.raise_if_nothing_inferred
+def infer_index(self, context=None):
+    return self.value.infer(context)
+
+
+nodes.Index._infer = infer_index  # type: ignore[assignment]
+
+
+def _populate_context_lookup(call, context):
+    # Allows context to be saved for later
+    # for inference inside a function
+    context_lookup = {}
+    if context is None:
+        return context_lookup
+    for arg in call.args:
+        if isinstance(arg, nodes.Starred):
+            context_lookup[arg.value] = context
+        else:
+            context_lookup[arg] = context
+    keywords = call.keywords if call.keywords is not None else []
+    for keyword in keywords:
+        context_lookup[keyword.value] = context
+    return context_lookup
+
+
+@decorators.raise_if_nothing_inferred
+def infer_ifexp(self, context=None):
+    """Support IfExp inference
+
+    If we can't infer the truthiness of the condition, we default
+    to inferring both branches. Otherwise, we infer either branch
+    depending on the condition.
+    """
+    both_branches = False
+    # We use two separate contexts for evaluating lhs and rhs because
+    # evaluating lhs may leave some undesired entries in context.path
+    # which may not let us infer right value of rhs.
+
+    context = context or InferenceContext()
+    lhs_context = copy_context(context)
+    rhs_context = copy_context(context)
+    try:
+        test = next(self.test.infer(context=context.clone()))
+    except (InferenceError, StopIteration):
+        both_branches = True
+    else:
+        if test is not util.Uninferable:
+            if test.bool_value():
+                yield from self.body.infer(context=lhs_context)
+            else:
+                yield from self.orelse.infer(context=rhs_context)
+        else:
+            both_branches = True
+    if both_branches:
+        yield from self.body.infer(context=lhs_context)
+        yield from self.orelse.infer(context=rhs_context)
+
+
+nodes.IfExp._infer = infer_ifexp  # type: ignore[assignment]
+
+
+# pylint: disable=dangerous-default-value
+@wrapt.decorator
+def _cached_generator(
+    func, instance: _FunctionDefT, args, kwargs, _cache={}  # noqa: B006
+):
+    node = instance
+    try:
+        return iter(_cache[func, id(node)])
+    except KeyError:
+        result = func(*args, **kwargs)
+        # Need to keep an iterator around
+        original, copy = itertools.tee(result)
+        _cache[func, id(node)] = list(copy)
+        return original
+
+
+# When inferring a property, we instantiate a new `objects.Property` object,
+# which in turn, because it inherits from `FunctionDef`, sets itself in the locals
+# of the wrapping frame. This means that every time we infer a property, the locals
+# are mutated with a new instance of the property. This is why we cache the result
+# of the function's inference.
+@_cached_generator
+def infer_functiondef(
+    self: _FunctionDefT, context: Optional[InferenceContext] = None
+) -> Generator[Union["Property", _FunctionDefT], None, InferenceErrorInfo]:
+    if not self.decorators or not bases._is_property(self):
+        yield self
+        return InferenceErrorInfo(node=self, context=context)
+
+    prop_func = objects.Property(
+        function=self,
+        name=self.name,
+        lineno=self.lineno,
+        parent=self.parent,
+        col_offset=self.col_offset,
+    )
+    prop_func.postinit(body=[], args=self.args, doc_node=self.doc_node)
+    yield prop_func
+    return InferenceErrorInfo(node=self, context=context)
+
+
+nodes.FunctionDef._infer = infer_functiondef  # type: ignore[assignment]
diff --git a/myenv/lib/python3.9/site-packages/astroid/inference_tip.py b/myenv/lib/python3.9/site-packages/astroid/inference_tip.py
new file mode 100644
index 0000000..f74ff23
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/inference_tip.py
@@ -0,0 +1,89 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Transform utilities (filters and decorator)"""
+
+import typing
+
+import wrapt
+
+from astroid import bases, util
+from astroid.exceptions import InferenceOverwriteError, UseInferenceDefault
+from astroid.nodes import NodeNG
+from astroid.typing import InferFn
+
+InferOptions = typing.Union[
+    NodeNG, bases.Instance, bases.UnboundMethod, typing.Type[util.Uninferable]
+]
+
+_cache: typing.Dict[
+    typing.Tuple[InferFn, NodeNG], typing.Optional[typing.List[InferOptions]]
+] = {}
+
+
+def clear_inference_tip_cache():
+    """Clear the inference tips cache."""
+    _cache.clear()
+
+
+@wrapt.decorator
+def _inference_tip_cached(
+    func: InferFn, instance: None, args: typing.Any, kwargs: typing.Any
+) -> typing.Iterator[InferOptions]:
+    """Cache decorator used for inference tips"""
+    node = args[0]
+    try:
+        result = _cache[func, node]
+        # If through recursion we end up trying to infer the same
+        # func + node we raise here.
+        if result is None:
+            raise UseInferenceDefault()
+    except KeyError:
+        _cache[func, node] = None
+        result = _cache[func, node] = list(func(*args, **kwargs))
+        assert result
+    return iter(result)
+
+
+def inference_tip(infer_function: InferFn, raise_on_overwrite: bool = False) -> InferFn:
+    """Given an instance specific inference function, return a function to be
+    given to AstroidManager().register_transform to set this inference function.
+
+    :param bool raise_on_overwrite: Raise an `InferenceOverwriteError`
+        if the inference tip will overwrite another. Used for debugging
+
+    Typical usage
+
+    .. sourcecode:: python
+
+       AstroidManager().register_transform(Call, inference_tip(infer_named_tuple),
+                                  predicate)
+
+    .. Note::
+
+        Using an inference tip will override
+        any previously set inference tip for the given
+        node. Use a predicate in the transform to prevent
+        excess overwrites.
+    """
+
+    def transform(node: NodeNG, infer_function: InferFn = infer_function) -> NodeNG:
+        if (
+            raise_on_overwrite
+            and node._explicit_inference is not None
+            and node._explicit_inference is not infer_function
+        ):
+            raise InferenceOverwriteError(
+                "Inference already set to {existing_inference}. "
+                "Trying to overwrite with {new_inference} for {node}".format(
+                    existing_inference=infer_function,
+                    new_inference=node._explicit_inference,
+                    node=node,
+                )
+            )
+        # pylint: disable=no-value-for-parameter
+        node._explicit_inference = _inference_tip_cached(infer_function)
+        return node
+
+    return transform
diff --git a/myenv/lib/python3.9/site-packages/astroid/interpreter/__init__.py b/myenv/lib/python3.9/site-packages/astroid/interpreter/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/astroid/interpreter/_import/__init__.py b/myenv/lib/python3.9/site-packages/astroid/interpreter/_import/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/astroid/interpreter/_import/spec.py b/myenv/lib/python3.9/site-packages/astroid/interpreter/_import/spec.py
new file mode 100644
index 0000000..73192ef
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/interpreter/_import/spec.py
@@ -0,0 +1,378 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+import abc
+import collections
+import enum
+import importlib.machinery
+import importlib.util
+import os
+import sys
+import zipimport
+from functools import lru_cache
+from pathlib import Path
+
+from astroid.modutils import EXT_LIB_DIRS
+
+from . import util
+
+ModuleType = enum.Enum(
+    "ModuleType",
+    "C_BUILTIN C_EXTENSION PKG_DIRECTORY "
+    "PY_CODERESOURCE PY_COMPILED PY_FROZEN PY_RESOURCE "
+    "PY_SOURCE PY_ZIPMODULE PY_NAMESPACE",
+)
+
+
+_ModuleSpec = collections.namedtuple(
+    "_ModuleSpec", "name type location " "origin submodule_search_locations"
+)
+
+
+class ModuleSpec(_ModuleSpec):
+    """Defines a class similar to PEP 420's ModuleSpec
+
+    A module spec defines a name of a module, its type, location
+    and where submodules can be found, if the module is a package.
+    """
+
+    def __new__(
+        cls,
+        name,
+        module_type,
+        location=None,
+        origin=None,
+        submodule_search_locations=None,
+    ):
+        return _ModuleSpec.__new__(
+            cls,
+            name=name,
+            type=module_type,
+            location=location,
+            origin=origin,
+            submodule_search_locations=submodule_search_locations,
+        )
+
+
+class Finder:
+    """A finder is a class which knows how to find a particular module."""
+
+    def __init__(self, path=None):
+        self._path = path or sys.path
+
+    @abc.abstractmethod
+    def find_module(self, modname, module_parts, processed, submodule_path):
+        """Find the given module
+
+        Each finder is responsible for each protocol of finding, as long as
+        they all return a ModuleSpec.
+
+        :param str modname: The module which needs to be searched.
+        :param list module_parts: It should be a list of strings,
+                                  where each part contributes to the module's
+                                  namespace.
+        :param list processed: What parts from the module parts were processed
+                               so far.
+        :param list submodule_path: A list of paths where the module
+                                    can be looked into.
+        :returns: A ModuleSpec, describing how and where the module was found,
+                  None, otherwise.
+        """
+
+    def contribute_to_path(self, spec, processed):
+        """Get a list of extra paths where this finder can search."""
+
+
+class ImportlibFinder(Finder):
+    """A finder based on the importlib module."""
+
+    _SUFFIXES = (
+        [(s, ModuleType.C_EXTENSION) for s in importlib.machinery.EXTENSION_SUFFIXES]
+        + [(s, ModuleType.PY_SOURCE) for s in importlib.machinery.SOURCE_SUFFIXES]
+        + [(s, ModuleType.PY_COMPILED) for s in importlib.machinery.BYTECODE_SUFFIXES]
+    )
+
+    def find_module(self, modname, module_parts, processed, submodule_path):
+        if not isinstance(modname, str):
+            raise TypeError(f"'modname' must be a str, not {type(modname)}")
+        if submodule_path is not None:
+            submodule_path = list(submodule_path)
+        else:
+            try:
+                spec = importlib.util.find_spec(modname)
+                if spec:
+                    if spec.loader is importlib.machinery.BuiltinImporter:
+                        return ModuleSpec(
+                            name=modname,
+                            location=None,
+                            module_type=ModuleType.C_BUILTIN,
+                        )
+                    if spec.loader is importlib.machinery.FrozenImporter:
+                        return ModuleSpec(
+                            name=modname,
+                            location=None,
+                            module_type=ModuleType.PY_FROZEN,
+                        )
+            except ValueError:
+                pass
+            submodule_path = sys.path
+
+        for entry in submodule_path:
+            package_directory = os.path.join(entry, modname)
+            for suffix in (".py", importlib.machinery.BYTECODE_SUFFIXES[0]):
+                package_file_name = "__init__" + suffix
+                file_path = os.path.join(package_directory, package_file_name)
+                if os.path.isfile(file_path):
+                    return ModuleSpec(
+                        name=modname,
+                        location=package_directory,
+                        module_type=ModuleType.PKG_DIRECTORY,
+                    )
+            for suffix, type_ in ImportlibFinder._SUFFIXES:
+                file_name = modname + suffix
+                file_path = os.path.join(entry, file_name)
+                if os.path.isfile(file_path):
+                    return ModuleSpec(
+                        name=modname, location=file_path, module_type=type_
+                    )
+        return None
+
+    def contribute_to_path(self, spec, processed):
+        if spec.location is None:
+            # Builtin.
+            return None
+
+        if _is_setuptools_namespace(spec.location):
+            # extend_path is called, search sys.path for module/packages
+            # of this name see pkgutil.extend_path documentation
+            path = [
+                os.path.join(p, *processed)
+                for p in sys.path
+                if os.path.isdir(os.path.join(p, *processed))
+            ]
+        elif spec.name == "distutils" and not any(
+            spec.location.lower().startswith(ext_lib_dir.lower())
+            for ext_lib_dir in EXT_LIB_DIRS
+        ):
+            # virtualenv below 20.0 patches distutils in an unexpected way
+            # so we just find the location of distutils that will be
+            # imported to avoid spurious import-error messages
+            # https://github.com/PyCQA/pylint/issues/5645
+            # A regression test to create this scenario exists in release-tests.yml
+            # and can be triggered manually from GitHub Actions
+            distutils_spec = importlib.util.find_spec("distutils")
+            if distutils_spec and distutils_spec.origin:
+                origin_path = Path(
+                    distutils_spec.origin
+                )  # e.g. .../distutils/__init__.py
+                path = [str(origin_path.parent)]  # e.g. .../distutils
+            else:
+                path = [spec.location]
+        else:
+            path = [spec.location]
+        return path
+
+
+class ExplicitNamespacePackageFinder(ImportlibFinder):
+    """A finder for the explicit namespace packages, generated through pkg_resources."""
+
+    def find_module(self, modname, module_parts, processed, submodule_path):
+        if processed:
+            modname = ".".join(processed + [modname])
+        if util.is_namespace(modname) and modname in sys.modules:
+            submodule_path = sys.modules[modname].__path__
+            return ModuleSpec(
+                name=modname,
+                location="",
+                origin="namespace",
+                module_type=ModuleType.PY_NAMESPACE,
+                submodule_search_locations=submodule_path,
+            )
+        return None
+
+    def contribute_to_path(self, spec, processed):
+        return spec.submodule_search_locations
+
+
+class ZipFinder(Finder):
+    """Finder that knows how to find a module inside zip files."""
+
+    def __init__(self, path):
+        super().__init__(path)
+        self._zipimporters = _precache_zipimporters(path)
+
+    def find_module(self, modname, module_parts, processed, submodule_path):
+        try:
+            file_type, filename, path = _search_zip(module_parts, self._zipimporters)
+        except ImportError:
+            return None
+
+        return ModuleSpec(
+            name=modname,
+            location=filename,
+            origin="egg",
+            module_type=file_type,
+            submodule_search_locations=path,
+        )
+
+
+class PathSpecFinder(Finder):
+    """Finder based on importlib.machinery.PathFinder."""
+
+    def find_module(self, modname, module_parts, processed, submodule_path):
+        spec = importlib.machinery.PathFinder.find_spec(modname, path=submodule_path)
+        if spec:
+            # origin can be either a string on older Python versions
+            # or None in case it is a namespace package:
+            # https://github.com/python/cpython/pull/5481
+            is_namespace_pkg = spec.origin in {"namespace", None}
+            location = spec.origin if not is_namespace_pkg else None
+            module_type = ModuleType.PY_NAMESPACE if is_namespace_pkg else None
+            spec = ModuleSpec(
+                name=spec.name,
+                location=location,
+                origin=spec.origin,
+                module_type=module_type,
+                submodule_search_locations=list(spec.submodule_search_locations or []),
+            )
+        return spec
+
+    def contribute_to_path(self, spec, processed):
+        if spec.type == ModuleType.PY_NAMESPACE:
+            return spec.submodule_search_locations
+        return None
+
+
+_SPEC_FINDERS = (
+    ImportlibFinder,
+    ZipFinder,
+    PathSpecFinder,
+    ExplicitNamespacePackageFinder,
+)
+
+
+def _is_setuptools_namespace(location):
+    try:
+        with open(os.path.join(location, "__init__.py"), "rb") as stream:
+            data = stream.read(4096)
+    except OSError:
+        return None
+    else:
+        extend_path = b"pkgutil" in data and b"extend_path" in data
+        declare_namespace = (
+            b"pkg_resources" in data and b"declare_namespace(__name__)" in data
+        )
+        return extend_path or declare_namespace
+
+
+@lru_cache()
+def _cached_set_diff(left, right):
+    result = set(left)
+    result.difference_update(right)
+    return result
+
+
+def _precache_zipimporters(path=None):
+    """
+    For each path that has not been already cached
+    in the sys.path_importer_cache, create a new zipimporter
+    instance and add it into the cache.
+    Return a dict associating all paths, stored in the cache, to corresponding
+    zipimporter instances.
+
+    :param path: paths that has to be added into the cache
+    :return: association between paths stored in the cache and zipimporter instances
+    """
+    pic = sys.path_importer_cache
+
+    # When measured, despite having the same complexity (O(n)),
+    # converting to tuples and then caching the conversion to sets
+    # and the set difference is faster than converting to sets
+    # and then only caching the set difference.
+
+    req_paths = tuple(path or sys.path)
+    cached_paths = tuple(pic)
+    new_paths = _cached_set_diff(req_paths, cached_paths)
+    # pylint: disable=no-member
+    for entry_path in new_paths:
+        try:
+            pic[entry_path] = zipimport.zipimporter(entry_path)
+        except zipimport.ZipImportError:
+            continue
+    return {
+        key: value
+        for key, value in pic.items()
+        if isinstance(value, zipimport.zipimporter)
+    }
+
+
+def _search_zip(modpath, pic):
+    for filepath, importer in list(pic.items()):
+        if importer is not None:
+            found = importer.find_module(modpath[0])
+            if found:
+                if not importer.find_module(os.path.sep.join(modpath)):
+                    raise ImportError(
+                        "No module named %s in %s/%s"
+                        % (".".join(modpath[1:]), filepath, modpath)
+                    )
+                # import code; code.interact(local=locals())
+                return (
+                    ModuleType.PY_ZIPMODULE,
+                    os.path.abspath(filepath) + os.path.sep + os.path.sep.join(modpath),
+                    filepath,
+                )
+    raise ImportError(f"No module named {'.'.join(modpath)}")
+
+
+def _find_spec_with_path(search_path, modname, module_parts, processed, submodule_path):
+    finders = [finder(search_path) for finder in _SPEC_FINDERS]
+    for finder in finders:
+        spec = finder.find_module(modname, module_parts, processed, submodule_path)
+        if spec is None:
+            continue
+        return finder, spec
+
+    raise ImportError(f"No module named {'.'.join(module_parts)}")
+
+
+def find_spec(modpath, path=None):
+    """Find a spec for the given module.
+
+    :type modpath: list or tuple
+    :param modpath:
+      split module's name (i.e name of a module or package split
+      on '.'), with leading empty strings for explicit relative import
+
+    :type path: list or None
+    :param path:
+      optional list of path where the module or package should be
+      searched (use sys.path if nothing or None is given)
+
+    :rtype: ModuleSpec
+    :return: A module spec, which describes how the module was
+             found and where.
+    """
+    _path = path or sys.path
+
+    # Need a copy for not mutating the argument.
+    modpath = modpath[:]
+
+    submodule_path = None
+    module_parts = modpath[:]
+    processed = []
+
+    while modpath:
+        modname = modpath.pop(0)
+        finder, spec = _find_spec_with_path(
+            _path, modname, module_parts, processed, submodule_path or path
+        )
+        processed.append(modname)
+        if modpath:
+            submodule_path = finder.contribute_to_path(spec, processed)
+
+        if spec.type == ModuleType.PKG_DIRECTORY:
+            spec = spec._replace(submodule_search_locations=submodule_path)
+
+    return spec
diff --git a/myenv/lib/python3.9/site-packages/astroid/interpreter/_import/util.py b/myenv/lib/python3.9/site-packages/astroid/interpreter/_import/util.py
new file mode 100644
index 0000000..ce3da7e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/interpreter/_import/util.py
@@ -0,0 +1,16 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+try:
+    import pkg_resources
+except ImportError:
+    pkg_resources = None  # type: ignore[assignment]
+
+
+def is_namespace(modname):
+    return (
+        pkg_resources is not None
+        and hasattr(pkg_resources, "_namespace_packages")
+        and modname in pkg_resources._namespace_packages
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/interpreter/dunder_lookup.py b/myenv/lib/python3.9/site-packages/astroid/interpreter/dunder_lookup.py
new file mode 100644
index 0000000..b0c7ae5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/interpreter/dunder_lookup.py
@@ -0,0 +1,66 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Contains logic for retrieving special methods.
+
+This implementation does not rely on the dot attribute access
+logic, found in ``.getattr()``. The difference between these two
+is that the dunder methods are looked with the type slots
+(you can find more about these here
+http://lucumr.pocoo.org/2014/8/16/the-python-i-would-like-to-see/)
+As such, the lookup for the special methods is actually simpler than
+the dot attribute access.
+"""
+import itertools
+
+import astroid
+from astroid.exceptions import AttributeInferenceError
+
+
+def _lookup_in_mro(node, name):
+    attrs = node.locals.get(name, [])
+
+    nodes = itertools.chain.from_iterable(
+        ancestor.locals.get(name, []) for ancestor in node.ancestors(recurs=True)
+    )
+    values = list(itertools.chain(attrs, nodes))
+    if not values:
+        raise AttributeInferenceError(attribute=name, target=node)
+
+    return values
+
+
+def lookup(node, name):
+    """Lookup the given special method name in the given *node*
+
+    If the special method was found, then a list of attributes
+    will be returned. Otherwise, `astroid.AttributeInferenceError`
+    is going to be raised.
+    """
+    if isinstance(
+        node, (astroid.List, astroid.Tuple, astroid.Const, astroid.Dict, astroid.Set)
+    ):
+        return _builtin_lookup(node, name)
+    if isinstance(node, astroid.Instance):
+        return _lookup_in_mro(node, name)
+    if isinstance(node, astroid.ClassDef):
+        return _class_lookup(node, name)
+
+    raise AttributeInferenceError(attribute=name, target=node)
+
+
+def _class_lookup(node, name):
+    metaclass = node.metaclass()
+    if metaclass is None:
+        raise AttributeInferenceError(attribute=name, target=node)
+
+    return _lookup_in_mro(metaclass, name)
+
+
+def _builtin_lookup(node, name):
+    values = node.locals.get(name, [])
+    if not values:
+        raise AttributeInferenceError(attribute=name, target=node)
+
+    return values
diff --git a/myenv/lib/python3.9/site-packages/astroid/interpreter/objectmodel.py b/myenv/lib/python3.9/site-packages/astroid/interpreter/objectmodel.py
new file mode 100644
index 0000000..cf9227b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/interpreter/objectmodel.py
@@ -0,0 +1,856 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""
+Data object model, as per https://docs.python.org/3/reference/datamodel.html.
+
+This module describes, at least partially, a data object model for some
+of astroid's nodes. The model contains special attributes that nodes such
+as functions, classes, modules etc have, such as __doc__, __class__,
+__module__ etc, being used when doing attribute lookups over nodes.
+
+For instance, inferring `obj.__class__` will first trigger an inference
+of the `obj` variable. If it was successfully inferred, then an attribute
+`__class__ will be looked for in the inferred object. This is the part
+where the data model occurs. The model is attached to those nodes
+and the lookup mechanism will try to see if attributes such as
+`__class__` are defined by the model or not. If they are defined,
+the model will be requested to return the corresponding value of that
+attribute. Thus the model can be viewed as a special part of the lookup
+mechanism.
+"""
+
+import itertools
+import os
+import pprint
+import types
+from typing import TYPE_CHECKING, List, Optional
+
+import astroid
+from astroid import util
+from astroid.context import InferenceContext, copy_context
+from astroid.exceptions import AttributeInferenceError, InferenceError, NoDefault
+from astroid.manager import AstroidManager
+from astroid.nodes import node_classes
+
+objects = util.lazy_import("objects")
+
+if TYPE_CHECKING:
+    from astroid.objects import Property
+
+IMPL_PREFIX = "attr_"
+LEN_OF_IMPL_PREFIX = len(IMPL_PREFIX)
+
+
+def _dunder_dict(instance, attributes):
+    obj = node_classes.Dict(parent=instance)
+
+    # Convert the keys to node strings
+    keys = [
+        node_classes.Const(value=value, parent=obj) for value in list(attributes.keys())
+    ]
+
+    # The original attribute has a list of elements for each key,
+    # but that is not useful for retrieving the special attribute's value.
+    # In this case, we're picking the last value from each list.
+    values = [elem[-1] for elem in attributes.values()]
+
+    obj.postinit(list(zip(keys, values)))
+    return obj
+
+
+class ObjectModel:
+    def __init__(self):
+        self._instance = None
+
+    def __repr__(self):
+        result = []
+        cname = type(self).__name__
+        string = "%(cname)s(%(fields)s)"
+        alignment = len(cname) + 1
+        for field in sorted(self.attributes()):
+            width = 80 - len(field) - alignment
+            lines = pprint.pformat(field, indent=2, width=width).splitlines(True)
+
+            inner = [lines[0]]
+            for line in lines[1:]:
+                inner.append(" " * alignment + line)
+            result.append(field)
+
+        return string % {
+            "cname": cname,
+            "fields": (",\n" + " " * alignment).join(result),
+        }
+
+    def __call__(self, instance):
+        self._instance = instance
+        return self
+
+    def __get__(self, instance, cls=None):
+        # ObjectModel needs to be a descriptor so that just doing
+        # `special_attributes = SomeObjectModel` should be enough in the body of a node.
+        # But at the same time, node.special_attributes should return an object
+        # which can be used for manipulating the special attributes. That's the reason
+        # we pass the instance through which it got accessed to ObjectModel.__call__,
+        # returning itself afterwards, so we can still have access to the
+        # underlying data model and to the instance for which it got accessed.
+        return self(instance)
+
+    def __contains__(self, name):
+        return name in self.attributes()
+
+    def attributes(self) -> List[str]:
+        """Get the attributes which are exported by this object model."""
+        return [o[LEN_OF_IMPL_PREFIX:] for o in dir(self) if o.startswith(IMPL_PREFIX)]
+
+    def lookup(self, name):
+        """Look up the given *name* in the current model
+
+        It should return an AST or an interpreter object,
+        but if the name is not found, then an AttributeInferenceError will be raised.
+        """
+        if name in self.attributes():
+            return getattr(self, IMPL_PREFIX + name)
+        raise AttributeInferenceError(target=self._instance, attribute=name)
+
+
+class ModuleModel(ObjectModel):
+    def _builtins(self):
+        builtins_ast_module = AstroidManager().builtins_module
+        return builtins_ast_module.special_attributes.lookup("__dict__")
+
+    @property
+    def attr_builtins(self):
+        return self._builtins()
+
+    @property
+    def attr___path__(self):
+        if not self._instance.package:
+            raise AttributeInferenceError(target=self._instance, attribute="__path__")
+
+        path_objs = [
+            node_classes.Const(
+                value=path
+                if not path.endswith("__init__.py")
+                else os.path.dirname(path),
+                parent=self._instance,
+            )
+            for path in self._instance.path
+        ]
+
+        container = node_classes.List(parent=self._instance)
+        container.postinit(path_objs)
+
+        return container
+
+    @property
+    def attr___name__(self):
+        return node_classes.Const(value=self._instance.name, parent=self._instance)
+
+    @property
+    def attr___doc__(self):
+        return node_classes.Const(
+            value=getattr(self._instance.doc_node, "value", None),
+            parent=self._instance,
+        )
+
+    @property
+    def attr___file__(self):
+        return node_classes.Const(value=self._instance.file, parent=self._instance)
+
+    @property
+    def attr___dict__(self):
+        return _dunder_dict(self._instance, self._instance.globals)
+
+    @property
+    def attr___package__(self):
+        if not self._instance.package:
+            value = ""
+        else:
+            value = self._instance.name
+
+        return node_classes.Const(value=value, parent=self._instance)
+
+    # These are related to the Python 3 implementation of the
+    # import system,
+    # https://docs.python.org/3/reference/import.html#import-related-module-attributes
+
+    @property
+    def attr___spec__(self):
+        # No handling for now.
+        return node_classes.Unknown()
+
+    @property
+    def attr___loader__(self):
+        # No handling for now.
+        return node_classes.Unknown()
+
+    @property
+    def attr___cached__(self):
+        # No handling for now.
+        return node_classes.Unknown()
+
+
+class FunctionModel(ObjectModel):
+    @property
+    def attr___name__(self):
+        return node_classes.Const(value=self._instance.name, parent=self._instance)
+
+    @property
+    def attr___doc__(self):
+        return node_classes.Const(
+            value=getattr(self._instance.doc_node, "value", None),
+            parent=self._instance,
+        )
+
+    @property
+    def attr___qualname__(self):
+        return node_classes.Const(value=self._instance.qname(), parent=self._instance)
+
+    @property
+    def attr___defaults__(self):
+        func = self._instance
+        if not func.args.defaults:
+            return node_classes.Const(value=None, parent=func)
+
+        defaults_obj = node_classes.Tuple(parent=func)
+        defaults_obj.postinit(func.args.defaults)
+        return defaults_obj
+
+    @property
+    def attr___annotations__(self):
+        obj = node_classes.Dict(parent=self._instance)
+
+        if not self._instance.returns:
+            returns = None
+        else:
+            returns = self._instance.returns
+
+        args = self._instance.args
+        pair_annotations = itertools.chain(
+            zip(args.args or [], args.annotations),
+            zip(args.kwonlyargs, args.kwonlyargs_annotations),
+            zip(args.posonlyargs or [], args.posonlyargs_annotations),
+        )
+
+        annotations = {
+            arg.name: annotation for (arg, annotation) in pair_annotations if annotation
+        }
+        if args.varargannotation:
+            annotations[args.vararg] = args.varargannotation
+        if args.kwargannotation:
+            annotations[args.kwarg] = args.kwargannotation
+        if returns:
+            annotations["return"] = returns
+
+        items = [
+            (node_classes.Const(key, parent=obj), value)
+            for (key, value) in annotations.items()
+        ]
+
+        obj.postinit(items)
+        return obj
+
+    @property
+    def attr___dict__(self):
+        return node_classes.Dict(parent=self._instance)
+
+    attr___globals__ = attr___dict__
+
+    @property
+    def attr___kwdefaults__(self):
+        def _default_args(args, parent):
+            for arg in args.kwonlyargs:
+                try:
+                    default = args.default_value(arg.name)
+                except NoDefault:
+                    continue
+
+                name = node_classes.Const(arg.name, parent=parent)
+                yield name, default
+
+        args = self._instance.args
+        obj = node_classes.Dict(parent=self._instance)
+        defaults = dict(_default_args(args, obj))
+
+        obj.postinit(list(defaults.items()))
+        return obj
+
+    @property
+    def attr___module__(self):
+        return node_classes.Const(self._instance.root().qname())
+
+    @property
+    def attr___get__(self):
+        # pylint: disable=import-outside-toplevel; circular import
+        from astroid import bases
+
+        func = self._instance
+
+        class DescriptorBoundMethod(bases.BoundMethod):
+            """Bound method which knows how to understand calling descriptor binding."""
+
+            def implicit_parameters(self):
+                # Different than BoundMethod since the signature
+                # is different.
+                return 0
+
+            def infer_call_result(self, caller, context=None):
+                if len(caller.args) > 2 or len(caller.args) < 1:
+                    raise InferenceError(
+                        "Invalid arguments for descriptor binding",
+                        target=self,
+                        context=context,
+                    )
+
+                context = copy_context(context)
+                try:
+                    cls = next(caller.args[0].infer(context=context))
+                except StopIteration as e:
+                    raise InferenceError(context=context, node=caller.args[0]) from e
+
+                if cls is astroid.Uninferable:
+                    raise InferenceError(
+                        "Invalid class inferred", target=self, context=context
+                    )
+
+                # For some reason func is a Node that the below
+                # code is not expecting
+                if isinstance(func, bases.BoundMethod):
+                    yield func
+                    return
+
+                # Rebuild the original value, but with the parent set as the
+                # class where it will be bound.
+                new_func = func.__class__(
+                    name=func.name,
+                    lineno=func.lineno,
+                    col_offset=func.col_offset,
+                    parent=func.parent,
+                )
+                # pylint: disable=no-member
+                new_func.postinit(
+                    func.args,
+                    func.body,
+                    func.decorators,
+                    func.returns,
+                    doc_node=func.doc_node,
+                )
+
+                # Build a proper bound method that points to our newly built function.
+                proxy = bases.UnboundMethod(new_func)
+                yield bases.BoundMethod(proxy=proxy, bound=cls)
+
+            @property
+            def args(self):
+                """Overwrite the underlying args to match those of the underlying func
+
+                Usually the underlying *func* is a function/method, as in:
+
+                    def test(self):
+                        pass
+
+                This has only the *self* parameter but when we access test.__get__
+                we get a new object which has two parameters, *self* and *type*.
+                """
+                nonlocal func
+                positional_or_keyword_params = func.args.args.copy()
+                positional_or_keyword_params.append(astroid.AssignName(name="type"))
+
+                positional_only_params = func.args.posonlyargs.copy()
+
+                arguments = astroid.Arguments(parent=func.args.parent)
+                arguments.postinit(
+                    args=positional_or_keyword_params,
+                    posonlyargs=positional_only_params,
+                    defaults=[],
+                    kwonlyargs=[],
+                    kw_defaults=[],
+                    annotations=[],
+                )
+                return arguments
+
+        return DescriptorBoundMethod(proxy=self._instance, bound=self._instance)
+
+    # These are here just for completion.
+    @property
+    def attr___ne__(self):
+        return node_classes.Unknown()
+
+    attr___subclasshook__ = attr___ne__
+    attr___str__ = attr___ne__
+    attr___sizeof__ = attr___ne__
+    attr___setattr___ = attr___ne__
+    attr___repr__ = attr___ne__
+    attr___reduce__ = attr___ne__
+    attr___reduce_ex__ = attr___ne__
+    attr___new__ = attr___ne__
+    attr___lt__ = attr___ne__
+    attr___eq__ = attr___ne__
+    attr___gt__ = attr___ne__
+    attr___format__ = attr___ne__
+    attr___delattr___ = attr___ne__
+    attr___getattribute__ = attr___ne__
+    attr___hash__ = attr___ne__
+    attr___init__ = attr___ne__
+    attr___dir__ = attr___ne__
+    attr___call__ = attr___ne__
+    attr___class__ = attr___ne__
+    attr___closure__ = attr___ne__
+    attr___code__ = attr___ne__
+
+
+class ClassModel(ObjectModel):
+    def __init__(self):
+        # Add a context so that inferences called from an instance don't recurse endlessly
+        self.context = InferenceContext()
+
+        super().__init__()
+
+    @property
+    def attr___module__(self):
+        return node_classes.Const(self._instance.root().qname())
+
+    @property
+    def attr___name__(self):
+        return node_classes.Const(self._instance.name)
+
+    @property
+    def attr___qualname__(self):
+        return node_classes.Const(self._instance.qname())
+
+    @property
+    def attr___doc__(self):
+        return node_classes.Const(getattr(self._instance.doc_node, "value", None))
+
+    @property
+    def attr___mro__(self):
+        if not self._instance.newstyle:
+            raise AttributeInferenceError(target=self._instance, attribute="__mro__")
+
+        mro = self._instance.mro()
+        obj = node_classes.Tuple(parent=self._instance)
+        obj.postinit(mro)
+        return obj
+
+    @property
+    def attr_mro(self):
+        if not self._instance.newstyle:
+            raise AttributeInferenceError(target=self._instance, attribute="mro")
+
+        # pylint: disable=import-outside-toplevel; circular import
+        from astroid import bases
+
+        other_self = self
+
+        # Cls.mro is a method and we need to return one in order to have a proper inference.
+        # The method we're returning is capable of inferring the underlying MRO though.
+        class MroBoundMethod(bases.BoundMethod):
+            def infer_call_result(self, caller, context=None):
+                yield other_self.attr___mro__
+
+        implicit_metaclass = self._instance.implicit_metaclass()
+        mro_method = implicit_metaclass.locals["mro"][0]
+        return MroBoundMethod(proxy=mro_method, bound=implicit_metaclass)
+
+    @property
+    def attr___bases__(self):
+        obj = node_classes.Tuple()
+        context = InferenceContext()
+        elts = list(self._instance._inferred_bases(context))
+        obj.postinit(elts=elts)
+        return obj
+
+    @property
+    def attr___class__(self):
+        # pylint: disable=import-outside-toplevel; circular import
+        from astroid import helpers
+
+        return helpers.object_type(self._instance)
+
+    @property
+    def attr___subclasses__(self):
+        """Get the subclasses of the underlying class
+
+        This looks only in the current module for retrieving the subclasses,
+        thus it might miss a couple of them.
+        """
+        # pylint: disable=import-outside-toplevel; circular import
+        from astroid import bases
+        from astroid.nodes import scoped_nodes
+
+        if not self._instance.newstyle:
+            raise AttributeInferenceError(
+                target=self._instance, attribute="__subclasses__"
+            )
+
+        qname = self._instance.qname()
+        root = self._instance.root()
+        classes = [
+            cls
+            for cls in root.nodes_of_class(scoped_nodes.ClassDef)
+            if cls != self._instance and cls.is_subtype_of(qname, context=self.context)
+        ]
+
+        obj = node_classes.List(parent=self._instance)
+        obj.postinit(classes)
+
+        class SubclassesBoundMethod(bases.BoundMethod):
+            def infer_call_result(self, caller, context=None):
+                yield obj
+
+        implicit_metaclass = self._instance.implicit_metaclass()
+        subclasses_method = implicit_metaclass.locals["__subclasses__"][0]
+        return SubclassesBoundMethod(proxy=subclasses_method, bound=implicit_metaclass)
+
+    @property
+    def attr___dict__(self):
+        return node_classes.Dict(parent=self._instance)
+
+
+class SuperModel(ObjectModel):
+    @property
+    def attr___thisclass__(self):
+        return self._instance.mro_pointer
+
+    @property
+    def attr___self_class__(self):
+        return self._instance._self_class
+
+    @property
+    def attr___self__(self):
+        return self._instance.type
+
+    @property
+    def attr___class__(self):
+        return self._instance._proxied
+
+
+class UnboundMethodModel(ObjectModel):
+    @property
+    def attr___class__(self):
+        # pylint: disable=import-outside-toplevel; circular import
+        from astroid import helpers
+
+        return helpers.object_type(self._instance)
+
+    @property
+    def attr___func__(self):
+        return self._instance._proxied
+
+    @property
+    def attr___self__(self):
+        return node_classes.Const(value=None, parent=self._instance)
+
+    attr_im_func = attr___func__
+    attr_im_class = attr___class__
+    attr_im_self = attr___self__
+
+
+class BoundMethodModel(FunctionModel):
+    @property
+    def attr___func__(self):
+        return self._instance._proxied._proxied
+
+    @property
+    def attr___self__(self):
+        return self._instance.bound
+
+
+class GeneratorModel(FunctionModel):
+    def __new__(cls, *args, **kwargs):
+        # Append the values from the GeneratorType unto this object.
+        ret = super().__new__(cls, *args, **kwargs)
+        generator = AstroidManager().builtins_module["generator"]
+        for name, values in generator.locals.items():
+            method = values[0]
+
+            def patched(cls, meth=method):
+                return meth
+
+            setattr(type(ret), IMPL_PREFIX + name, property(patched))
+
+        return ret
+
+    @property
+    def attr___name__(self):
+        return node_classes.Const(
+            value=self._instance.parent.name, parent=self._instance
+        )
+
+    @property
+    def attr___doc__(self):
+        return node_classes.Const(
+            value=getattr(self._instance.parent.doc_node, "value", None),
+            parent=self._instance,
+        )
+
+
+class AsyncGeneratorModel(GeneratorModel):
+    def __new__(cls, *args, **kwargs):
+        # Append the values from the AGeneratorType unto this object.
+        ret = super().__new__(cls, *args, **kwargs)
+        astroid_builtins = AstroidManager().builtins_module
+        generator = astroid_builtins.get("async_generator")
+        if generator is None:
+            # Make it backward compatible.
+            generator = astroid_builtins.get("generator")
+
+        for name, values in generator.locals.items():
+            method = values[0]
+
+            def patched(cls, meth=method):
+                return meth
+
+            setattr(type(ret), IMPL_PREFIX + name, property(patched))
+
+        return ret
+
+
+class InstanceModel(ObjectModel):
+    @property
+    def attr___class__(self):
+        return self._instance._proxied
+
+    @property
+    def attr___module__(self):
+        return node_classes.Const(self._instance.root().qname())
+
+    @property
+    def attr___doc__(self):
+        return node_classes.Const(getattr(self._instance.doc_node, "value", None))
+
+    @property
+    def attr___dict__(self):
+        return _dunder_dict(self._instance, self._instance.instance_attrs)
+
+
+# Exception instances
+
+
+class ExceptionInstanceModel(InstanceModel):
+    @property
+    def attr_args(self):
+        message = node_classes.Const("")
+        args = node_classes.Tuple(parent=self._instance)
+        args.postinit((message,))
+        return args
+
+    @property
+    def attr___traceback__(self):
+        builtins_ast_module = AstroidManager().builtins_module
+        traceback_type = builtins_ast_module[types.TracebackType.__name__]
+        return traceback_type.instantiate_class()
+
+
+class SyntaxErrorInstanceModel(ExceptionInstanceModel):
+    @property
+    def attr_text(self):
+        return node_classes.Const("")
+
+
+class OSErrorInstanceModel(ExceptionInstanceModel):
+    @property
+    def attr_filename(self):
+        return node_classes.Const("")
+
+    @property
+    def attr_errno(self):
+        return node_classes.Const(0)
+
+    @property
+    def attr_strerror(self):
+        return node_classes.Const("")
+
+    attr_filename2 = attr_filename
+
+
+class ImportErrorInstanceModel(ExceptionInstanceModel):
+    @property
+    def attr_name(self):
+        return node_classes.Const("")
+
+    @property
+    def attr_path(self):
+        return node_classes.Const("")
+
+
+class UnicodeDecodeErrorInstanceModel(ExceptionInstanceModel):
+    @property
+    def attr_object(self):
+        return node_classes.Const("")
+
+
+BUILTIN_EXCEPTIONS = {
+    "builtins.SyntaxError": SyntaxErrorInstanceModel,
+    "builtins.ImportError": ImportErrorInstanceModel,
+    "builtins.UnicodeDecodeError": UnicodeDecodeErrorInstanceModel,
+    # These are all similar to OSError in terms of attributes
+    "builtins.OSError": OSErrorInstanceModel,
+    "builtins.BlockingIOError": OSErrorInstanceModel,
+    "builtins.BrokenPipeError": OSErrorInstanceModel,
+    "builtins.ChildProcessError": OSErrorInstanceModel,
+    "builtins.ConnectionAbortedError": OSErrorInstanceModel,
+    "builtins.ConnectionError": OSErrorInstanceModel,
+    "builtins.ConnectionRefusedError": OSErrorInstanceModel,
+    "builtins.ConnectionResetError": OSErrorInstanceModel,
+    "builtins.FileExistsError": OSErrorInstanceModel,
+    "builtins.FileNotFoundError": OSErrorInstanceModel,
+    "builtins.InterruptedError": OSErrorInstanceModel,
+    "builtins.IsADirectoryError": OSErrorInstanceModel,
+    "builtins.NotADirectoryError": OSErrorInstanceModel,
+    "builtins.PermissionError": OSErrorInstanceModel,
+    "builtins.ProcessLookupError": OSErrorInstanceModel,
+    "builtins.TimeoutError": OSErrorInstanceModel,
+}
+
+
+class DictModel(ObjectModel):
+    @property
+    def attr___class__(self):
+        return self._instance._proxied
+
+    def _generic_dict_attribute(self, obj, name):
+        """Generate a bound method that can infer the given *obj*."""
+
+        class DictMethodBoundMethod(astroid.BoundMethod):
+            def infer_call_result(self, caller, context=None):
+                yield obj
+
+        meth = next(self._instance._proxied.igetattr(name), None)
+        return DictMethodBoundMethod(proxy=meth, bound=self._instance)
+
+    @property
+    def attr_items(self):
+        elems = []
+        obj = node_classes.List(parent=self._instance)
+        for key, value in self._instance.items:
+            elem = node_classes.Tuple(parent=obj)
+            elem.postinit((key, value))
+            elems.append(elem)
+        obj.postinit(elts=elems)
+
+        obj = objects.DictItems(obj)
+        return self._generic_dict_attribute(obj, "items")
+
+    @property
+    def attr_keys(self):
+        keys = [key for (key, _) in self._instance.items]
+        obj = node_classes.List(parent=self._instance)
+        obj.postinit(elts=keys)
+
+        obj = objects.DictKeys(obj)
+        return self._generic_dict_attribute(obj, "keys")
+
+    @property
+    def attr_values(self):
+
+        values = [value for (_, value) in self._instance.items]
+        obj = node_classes.List(parent=self._instance)
+        obj.postinit(values)
+
+        obj = objects.DictValues(obj)
+        return self._generic_dict_attribute(obj, "values")
+
+
+class PropertyModel(ObjectModel):
+    """Model for a builtin property"""
+
+    # pylint: disable=import-outside-toplevel
+    def _init_function(self, name):
+        from astroid.nodes.node_classes import Arguments
+        from astroid.nodes.scoped_nodes import FunctionDef
+
+        args = Arguments()
+        args.postinit(
+            args=[],
+            defaults=[],
+            kwonlyargs=[],
+            kw_defaults=[],
+            annotations=[],
+            posonlyargs=[],
+            posonlyargs_annotations=[],
+            kwonlyargs_annotations=[],
+        )
+
+        function = FunctionDef(name=name, parent=self._instance)
+
+        function.postinit(args=args, body=[])
+        return function
+
+    @property
+    def attr_fget(self):
+        from astroid.nodes.scoped_nodes import FunctionDef
+
+        func = self._instance
+
+        class PropertyFuncAccessor(FunctionDef):
+            def infer_call_result(self, caller=None, context=None):
+                nonlocal func
+                if caller and len(caller.args) != 1:
+                    raise InferenceError(
+                        "fget() needs a single argument", target=self, context=context
+                    )
+
+                yield from func.function.infer_call_result(
+                    caller=caller, context=context
+                )
+
+        property_accessor = PropertyFuncAccessor(name="fget", parent=self._instance)
+        property_accessor.postinit(args=func.args, body=func.body)
+        return property_accessor
+
+    @property
+    def attr_fset(self):
+        from astroid.nodes.scoped_nodes import FunctionDef
+
+        func = self._instance
+
+        def find_setter(func: "Property") -> Optional[astroid.FunctionDef]:
+            """
+            Given a property, find the corresponding setter function and returns it.
+
+            :param func: property for which the setter has to be found
+            :return: the setter function or None
+            """
+            for target in [
+                t for t in func.parent.get_children() if t.name == func.function.name
+            ]:
+                for dec_name in target.decoratornames():
+                    if dec_name.endswith(func.function.name + ".setter"):
+                        return target
+            return None
+
+        func_setter = find_setter(func)
+        if not func_setter:
+            raise InferenceError(
+                f"Unable to find the setter of property {func.function.name}"
+            )
+
+        class PropertyFuncAccessor(FunctionDef):
+            def infer_call_result(self, caller=None, context=None):
+                nonlocal func_setter
+                if caller and len(caller.args) != 2:
+                    raise InferenceError(
+                        "fset() needs two arguments", target=self, context=context
+                    )
+                yield from func_setter.infer_call_result(caller=caller, context=context)
+
+        property_accessor = PropertyFuncAccessor(name="fset", parent=self._instance)
+        property_accessor.postinit(args=func_setter.args, body=func_setter.body)
+        return property_accessor
+
+    @property
+    def attr_setter(self):
+        return self._init_function("setter")
+
+    @property
+    def attr_deleter(self):
+        return self._init_function("deleter")
+
+    @property
+    def attr_getter(self):
+        return self._init_function("getter")
+
+    # pylint: enable=import-outside-toplevel
diff --git a/myenv/lib/python3.9/site-packages/astroid/manager.py b/myenv/lib/python3.9/site-packages/astroid/manager.py
new file mode 100644
index 0000000..950842e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/manager.py
@@ -0,0 +1,353 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""astroid manager: avoid multiple astroid build of a same module when
+possible by providing a class responsible to get astroid representation
+from various source and using a cache of built modules)
+"""
+
+import os
+import types
+import zipimport
+from typing import TYPE_CHECKING, ClassVar, List, Optional
+
+from astroid.exceptions import AstroidBuildingError, AstroidImportError
+from astroid.interpreter._import import spec
+from astroid.modutils import (
+    NoSourceFile,
+    file_info_from_modpath,
+    get_source_file,
+    is_module_name_part_of_extension_package_whitelist,
+    is_python_source,
+    is_standard_module,
+    load_module_from_name,
+    modpath_from_file,
+)
+from astroid.transforms import TransformVisitor
+
+if TYPE_CHECKING:
+    from astroid import nodes
+
+ZIP_IMPORT_EXTS = (".zip", ".egg", ".whl", ".pyz", ".pyzw")
+
+
+def safe_repr(obj):
+    try:
+        return repr(obj)
+    except Exception:  # pylint: disable=broad-except
+        return "???"
+
+
+class AstroidManager:
+    """Responsible to build astroid from files or modules.
+
+    Use the Borg (singleton) pattern.
+    """
+
+    name = "astroid loader"
+    brain = {}
+    max_inferable_values: ClassVar[int] = 100
+
+    def __init__(self):
+        self.__dict__ = AstroidManager.brain
+        if not self.__dict__:
+            # NOTE: cache entries are added by the [re]builder
+            self.astroid_cache = {}
+            self._mod_file_cache = {}
+            self._failed_import_hooks = []
+            self.always_load_extensions = False
+            self.optimize_ast = False
+            self.extension_package_whitelist = set()
+            self._transform = TransformVisitor()
+
+    @property
+    def register_transform(self):
+        # This and unregister_transform below are exported for convenience
+        return self._transform.register_transform
+
+    @property
+    def unregister_transform(self):
+        return self._transform.unregister_transform
+
+    @property
+    def builtins_module(self):
+        return self.astroid_cache["builtins"]
+
+    def visit_transforms(self, node):
+        """Visit the transforms and apply them to the given *node*."""
+        return self._transform.visit(node)
+
+    def ast_from_file(self, filepath, modname=None, fallback=True, source=False):
+        """given a module name, return the astroid object"""
+        try:
+            filepath = get_source_file(filepath, include_no_ext=True)
+            source = True
+        except NoSourceFile:
+            pass
+        if modname is None:
+            try:
+                modname = ".".join(modpath_from_file(filepath))
+            except ImportError:
+                modname = filepath
+        if (
+            modname in self.astroid_cache
+            and self.astroid_cache[modname].file == filepath
+        ):
+            return self.astroid_cache[modname]
+        if source:
+            # pylint: disable=import-outside-toplevel; circular import
+            from astroid.builder import AstroidBuilder
+
+            return AstroidBuilder(self).file_build(filepath, modname)
+        if fallback and modname:
+            return self.ast_from_module_name(modname)
+        raise AstroidBuildingError("Unable to build an AST for {path}.", path=filepath)
+
+    def ast_from_string(self, data, modname="", filepath=None):
+        """Given some source code as a string, return its corresponding astroid object"""
+        # pylint: disable=import-outside-toplevel; circular import
+        from astroid.builder import AstroidBuilder
+
+        return AstroidBuilder(self).string_build(data, modname, filepath)
+
+    def _build_stub_module(self, modname):
+        # pylint: disable=import-outside-toplevel; circular import
+        from astroid.builder import AstroidBuilder
+
+        return AstroidBuilder(self).string_build("", modname)
+
+    def _build_namespace_module(self, modname: str, path: List[str]) -> "nodes.Module":
+        # pylint: disable=import-outside-toplevel; circular import
+        from astroid.builder import build_namespace_package_module
+
+        return build_namespace_package_module(modname, path)
+
+    def _can_load_extension(self, modname: str) -> bool:
+        if self.always_load_extensions:
+            return True
+        if is_standard_module(modname):
+            return True
+        return is_module_name_part_of_extension_package_whitelist(
+            modname, self.extension_package_whitelist
+        )
+
+    def ast_from_module_name(self, modname, context_file=None):
+        """given a module name, return the astroid object"""
+        if modname in self.astroid_cache:
+            return self.astroid_cache[modname]
+        if modname == "__main__":
+            return self._build_stub_module(modname)
+        if context_file:
+            old_cwd = os.getcwd()
+            os.chdir(os.path.dirname(context_file))
+        try:
+            found_spec = self.file_from_module_name(modname, context_file)
+            if found_spec.type == spec.ModuleType.PY_ZIPMODULE:
+                module = self.zip_import_data(found_spec.location)
+                if module is not None:
+                    return module
+
+            elif found_spec.type in (
+                spec.ModuleType.C_BUILTIN,
+                spec.ModuleType.C_EXTENSION,
+            ):
+                if (
+                    found_spec.type == spec.ModuleType.C_EXTENSION
+                    and not self._can_load_extension(modname)
+                ):
+                    return self._build_stub_module(modname)
+                try:
+                    module = load_module_from_name(modname)
+                except Exception as e:
+                    raise AstroidImportError(
+                        "Loading {modname} failed with:\n{error}",
+                        modname=modname,
+                        path=found_spec.location,
+                    ) from e
+                return self.ast_from_module(module, modname)
+
+            elif found_spec.type == spec.ModuleType.PY_COMPILED:
+                raise AstroidImportError(
+                    "Unable to load compiled module {modname}.",
+                    modname=modname,
+                    path=found_spec.location,
+                )
+
+            elif found_spec.type == spec.ModuleType.PY_NAMESPACE:
+                return self._build_namespace_module(
+                    modname, found_spec.submodule_search_locations
+                )
+            elif found_spec.type == spec.ModuleType.PY_FROZEN:
+                return self._build_stub_module(modname)
+
+            if found_spec.location is None:
+                raise AstroidImportError(
+                    "Can't find a file for module {modname}.", modname=modname
+                )
+
+            return self.ast_from_file(found_spec.location, modname, fallback=False)
+        except AstroidBuildingError as e:
+            for hook in self._failed_import_hooks:
+                try:
+                    return hook(modname)
+                except AstroidBuildingError:
+                    pass
+            raise e
+        finally:
+            if context_file:
+                os.chdir(old_cwd)
+
+    def zip_import_data(self, filepath):
+        if zipimport is None:
+            return None
+
+        # pylint: disable=import-outside-toplevel; circular import
+        from astroid.builder import AstroidBuilder
+
+        builder = AstroidBuilder(self)
+        for ext in ZIP_IMPORT_EXTS:
+            try:
+                eggpath, resource = filepath.rsplit(ext + os.path.sep, 1)
+            except ValueError:
+                continue
+            try:
+                # pylint: disable-next=no-member
+                importer = zipimport.zipimporter(eggpath + ext)
+                zmodname = resource.replace(os.path.sep, ".")
+                if importer.is_package(resource):
+                    zmodname = zmodname + ".__init__"
+                module = builder.string_build(
+                    importer.get_source(resource), zmodname, filepath
+                )
+                return module
+            except Exception:  # pylint: disable=broad-except
+                continue
+        return None
+
+    def file_from_module_name(self, modname, contextfile):
+        try:
+            value = self._mod_file_cache[(modname, contextfile)]
+        except KeyError:
+            try:
+                value = file_info_from_modpath(
+                    modname.split("."), context_file=contextfile
+                )
+            except ImportError as e:
+                value = AstroidImportError(
+                    "Failed to import module {modname} with error:\n{error}.",
+                    modname=modname,
+                    # we remove the traceback here to save on memory usage (since these exceptions are cached)
+                    error=e.with_traceback(None),
+                )
+            self._mod_file_cache[(modname, contextfile)] = value
+        if isinstance(value, AstroidBuildingError):
+            # we remove the traceback here to save on memory usage (since these exceptions are cached)
+            raise value.with_traceback(None)
+        return value
+
+    def ast_from_module(self, module: types.ModuleType, modname: Optional[str] = None):
+        """given an imported module, return the astroid object"""
+        modname = modname or module.__name__
+        if modname in self.astroid_cache:
+            return self.astroid_cache[modname]
+        try:
+            # some builtin modules don't have __file__ attribute
+            filepath = module.__file__
+            if is_python_source(filepath):
+                return self.ast_from_file(filepath, modname)
+        except AttributeError:
+            pass
+
+        # pylint: disable=import-outside-toplevel; circular import
+        from astroid.builder import AstroidBuilder
+
+        return AstroidBuilder(self).module_build(module, modname)
+
+    def ast_from_class(self, klass, modname=None):
+        """get astroid for the given class"""
+        if modname is None:
+            try:
+                modname = klass.__module__
+            except AttributeError as exc:
+                raise AstroidBuildingError(
+                    "Unable to get module for class {class_name}.",
+                    cls=klass,
+                    class_repr=safe_repr(klass),
+                    modname=modname,
+                ) from exc
+        modastroid = self.ast_from_module_name(modname)
+        return modastroid.getattr(klass.__name__)[0]  # XXX
+
+    def infer_ast_from_something(self, obj, context=None):
+        """infer astroid for the given class"""
+        if hasattr(obj, "__class__") and not isinstance(obj, type):
+            klass = obj.__class__
+        else:
+            klass = obj
+        try:
+            modname = klass.__module__
+        except AttributeError as exc:
+            raise AstroidBuildingError(
+                "Unable to get module for {class_repr}.",
+                cls=klass,
+                class_repr=safe_repr(klass),
+            ) from exc
+        except Exception as exc:
+            raise AstroidImportError(
+                "Unexpected error while retrieving module for {class_repr}:\n"
+                "{error}",
+                cls=klass,
+                class_repr=safe_repr(klass),
+            ) from exc
+        try:
+            name = klass.__name__
+        except AttributeError as exc:
+            raise AstroidBuildingError(
+                "Unable to get name for {class_repr}:\n",
+                cls=klass,
+                class_repr=safe_repr(klass),
+            ) from exc
+        except Exception as exc:
+            raise AstroidImportError(
+                "Unexpected error while retrieving name for {class_repr}:\n" "{error}",
+                cls=klass,
+                class_repr=safe_repr(klass),
+            ) from exc
+        # take care, on living object __module__ is regularly wrong :(
+        modastroid = self.ast_from_module_name(modname)
+        if klass is obj:
+            for inferred in modastroid.igetattr(name, context):
+                yield inferred
+        else:
+            for inferred in modastroid.igetattr(name, context):
+                yield inferred.instantiate_class()
+
+    def register_failed_import_hook(self, hook):
+        """Registers a hook to resolve imports that cannot be found otherwise.
+
+        `hook` must be a function that accepts a single argument `modname` which
+        contains the name of the module or package that could not be imported.
+        If `hook` can resolve the import, must return a node of type `astroid.Module`,
+        otherwise, it must raise `AstroidBuildingError`.
+        """
+        self._failed_import_hooks.append(hook)
+
+    def cache_module(self, module):
+        """Cache a module if no module with the same name is known yet."""
+        self.astroid_cache.setdefault(module.name, module)
+
+    def bootstrap(self):
+        """Bootstrap the required AST modules needed for the manager to work
+
+        The bootstrap usually involves building the AST for the builtins
+        module, which is required by the rest of astroid to work correctly.
+        """
+        from astroid import raw_building  # pylint: disable=import-outside-toplevel
+
+        raw_building._astroid_bootstrapping()
+
+    def clear_cache(self):
+        """Clear the underlying cache. Also bootstraps the builtins module."""
+        self.astroid_cache.clear()
+        self.bootstrap()
diff --git a/myenv/lib/python3.9/site-packages/astroid/mixins.py b/myenv/lib/python3.9/site-packages/astroid/mixins.py
new file mode 100644
index 0000000..ea68aff
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/mixins.py
@@ -0,0 +1,163 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""This module contains some mixins for the different nodes.
+"""
+import itertools
+import sys
+from typing import TYPE_CHECKING, Optional
+
+from astroid import decorators
+from astroid.exceptions import AttributeInferenceError
+
+if TYPE_CHECKING:
+    from astroid import nodes
+
+if sys.version_info >= (3, 8) or TYPE_CHECKING:
+    from functools import cached_property
+else:
+    from astroid.decorators import cachedproperty as cached_property
+
+
+class BlockRangeMixIn:
+    """override block range"""
+
+    @cached_property
+    def blockstart_tolineno(self):
+        return self.lineno
+
+    def _elsed_block_range(self, lineno, orelse, last=None):
+        """handle block line numbers range for try/finally, for, if and while
+        statements
+        """
+        if lineno == self.fromlineno:
+            return lineno, lineno
+        if orelse:
+            if lineno >= orelse[0].fromlineno:
+                return lineno, orelse[-1].tolineno
+            return lineno, orelse[0].fromlineno - 1
+        return lineno, last or self.tolineno
+
+
+class FilterStmtsMixin:
+    """Mixin for statement filtering and assignment type"""
+
+    def _get_filtered_stmts(self, _, node, _stmts, mystmt: Optional["nodes.Statement"]):
+        """method used in _filter_stmts to get statements and trigger break"""
+        if self.statement(future=True) is mystmt:
+            # original node's statement is the assignment, only keep
+            # current node (gen exp, list comp)
+            return [node], True
+        return _stmts, False
+
+    def assign_type(self):
+        return self
+
+
+class AssignTypeMixin:
+    def assign_type(self):
+        return self
+
+    def _get_filtered_stmts(
+        self, lookup_node, node, _stmts, mystmt: Optional["nodes.Statement"]
+    ):
+        """method used in filter_stmts"""
+        if self is mystmt:
+            return _stmts, True
+        if self.statement(future=True) is mystmt:
+            # original node's statement is the assignment, only keep
+            # current node (gen exp, list comp)
+            return [node], True
+        return _stmts, False
+
+
+class ParentAssignTypeMixin(AssignTypeMixin):
+    def assign_type(self):
+        return self.parent.assign_type()
+
+
+class ImportFromMixin(FilterStmtsMixin):
+    """MixIn for From and Import Nodes"""
+
+    def _infer_name(self, frame, name):
+        return name
+
+    def do_import_module(self, modname=None):
+        """return the ast for a module whose name is <modname> imported by <self>"""
+        # handle special case where we are on a package node importing a module
+        # using the same name as the package, which may end in an infinite loop
+        # on relative imports
+        # XXX: no more needed ?
+        mymodule = self.root()
+        level = getattr(self, "level", None)  # Import as no level
+        if modname is None:
+            modname = self.modname
+        # XXX we should investigate deeper if we really want to check
+        # importing itself: modname and mymodule.name be relative or absolute
+        if mymodule.relative_to_absolute_name(modname, level) == mymodule.name:
+            # FIXME: we used to raise InferenceError here, but why ?
+            return mymodule
+
+        return mymodule.import_module(
+            modname, level=level, relative_only=level and level >= 1
+        )
+
+    def real_name(self, asname):
+        """get name from 'as' name"""
+        for name, _asname in self.names:
+            if name == "*":
+                return asname
+            if not _asname:
+                name = name.split(".", 1)[0]
+                _asname = name
+            if asname == _asname:
+                return name
+        raise AttributeInferenceError(
+            "Could not find original name for {attribute} in {target!r}",
+            target=self,
+            attribute=asname,
+        )
+
+
+class MultiLineBlockMixin:
+    """Mixin for nodes with multi-line blocks, e.g. For and FunctionDef.
+    Note that this does not apply to every node with a `body` field.
+    For instance, an If node has a multi-line body, but the body of an
+    IfExpr is not multi-line, and hence cannot contain Return nodes,
+    Assign nodes, etc.
+    """
+
+    @cached_property
+    def _multi_line_blocks(self):
+        return tuple(getattr(self, field) for field in self._multi_line_block_fields)
+
+    def _get_return_nodes_skip_functions(self):
+        for block in self._multi_line_blocks:
+            for child_node in block:
+                if child_node.is_function:
+                    continue
+                yield from child_node._get_return_nodes_skip_functions()
+
+    def _get_yield_nodes_skip_lambdas(self):
+        for block in self._multi_line_blocks:
+            for child_node in block:
+                if child_node.is_lambda:
+                    continue
+                yield from child_node._get_yield_nodes_skip_lambdas()
+
+    @decorators.cached
+    def _get_assign_nodes(self):
+        children_assign_nodes = (
+            child_node._get_assign_nodes()
+            for block in self._multi_line_blocks
+            for child_node in block
+        )
+        return list(itertools.chain.from_iterable(children_assign_nodes))
+
+
+class NoChildrenMixin:
+    """Mixin for nodes with no children, e.g. Pass."""
+
+    def get_children(self):
+        yield from ()
diff --git a/myenv/lib/python3.9/site-packages/astroid/modutils.py b/myenv/lib/python3.9/site-packages/astroid/modutils.py
new file mode 100644
index 0000000..01135ef
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/modutils.py
@@ -0,0 +1,626 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Python modules manipulation utility functions.
+
+:type PY_SOURCE_EXTS: tuple(str)
+:var PY_SOURCE_EXTS: list of possible python source file extension
+
+:type STD_LIB_DIRS: set of str
+:var STD_LIB_DIRS: directories where standard modules are located
+
+:type BUILTIN_MODULES: dict
+:var BUILTIN_MODULES: dictionary with builtin module names has key
+"""
+
+import importlib
+import importlib.machinery
+import importlib.util
+import itertools
+import os
+import sys
+import sysconfig
+import types
+from pathlib import Path
+from typing import Dict, Set
+
+from astroid.const import IS_JYTHON, IS_PYPY
+from astroid.interpreter._import import spec, util
+
+if sys.platform.startswith("win"):
+    PY_SOURCE_EXTS = ("py", "pyw")
+    PY_COMPILED_EXTS = ("dll", "pyd")
+else:
+    PY_SOURCE_EXTS = ("py",)
+    PY_COMPILED_EXTS = ("so",)
+
+
+# TODO: Adding `platstdlib` is a fix for a workaround in virtualenv. At some point we should
+# revisit whether this is still necessary. See https://github.com/PyCQA/astroid/pull/1323.
+STD_LIB_DIRS = {sysconfig.get_path("stdlib"), sysconfig.get_path("platstdlib")}
+
+if os.name == "nt":
+    STD_LIB_DIRS.add(os.path.join(sys.prefix, "dlls"))
+    try:
+        # real_prefix is defined when running inside virtual environments,
+        # created with the **virtualenv** library.
+        # Deprecated in virtualenv==16.7.9
+        # See: https://github.com/pypa/virtualenv/issues/1622
+        STD_LIB_DIRS.add(os.path.join(sys.real_prefix, "dlls"))  # type: ignore[attr-defined]
+    except AttributeError:
+        # sys.base_exec_prefix is always defined, but in a virtual environment
+        # created with the stdlib **venv** module, it points to the original
+        # installation, if the virtual env is activated.
+        try:
+            STD_LIB_DIRS.add(os.path.join(sys.base_exec_prefix, "dlls"))
+        except AttributeError:
+            pass
+
+if IS_PYPY and sys.version_info < (3, 8):
+    # PyPy stores the stdlib in two places: sys.prefix/lib_pypy and sys.prefix/lib-python/3
+    # sysconfig.get_path on PyPy returns the first, but without an underscore so we patch this manually.
+    # Beginning with 3.8 the stdlib is only stored in: sys.prefix/pypy{py_version_short}
+    STD_LIB_DIRS.add(str(Path(sysconfig.get_path("stdlib")).parent / "lib_pypy"))
+    STD_LIB_DIRS.add(str(Path(sysconfig.get_path("stdlib")).parent / "lib-python/3"))
+
+    # TODO: This is a fix for a workaround in virtualenv. At some point we should revisit
+    # whether this is still necessary. See https://github.com/PyCQA/astroid/pull/1324.
+    STD_LIB_DIRS.add(str(Path(sysconfig.get_path("platstdlib")).parent / "lib_pypy"))
+    STD_LIB_DIRS.add(
+        str(Path(sysconfig.get_path("platstdlib")).parent / "lib-python/3")
+    )
+
+if os.name == "posix":
+    # Need the real prefix if we're in a virtualenv, otherwise
+    # the usual one will do.
+    # Deprecated in virtualenv==16.7.9
+    # See: https://github.com/pypa/virtualenv/issues/1622
+    try:
+        prefix = sys.real_prefix  # type: ignore[attr-defined]
+    except AttributeError:
+        prefix = sys.prefix
+
+    def _posix_path(path):
+        base_python = "python%d.%d" % sys.version_info[:2]
+        return os.path.join(prefix, path, base_python)
+
+    STD_LIB_DIRS.add(_posix_path("lib"))
+    if sys.maxsize > 2**32:
+        # This tries to fix a problem with /usr/lib64 builds,
+        # where systems are running both 32-bit and 64-bit code
+        # on the same machine, which reflects into the places where
+        # standard library could be found. More details can be found
+        # here http://bugs.python.org/issue1294959.
+        # An easy reproducing case would be
+        # https://github.com/PyCQA/pylint/issues/712#issuecomment-163178753
+        STD_LIB_DIRS.add(_posix_path("lib64"))
+
+EXT_LIB_DIRS = {sysconfig.get_path("purelib"), sysconfig.get_path("platlib")}
+BUILTIN_MODULES = dict.fromkeys(sys.builtin_module_names, True)
+
+
+class NoSourceFile(Exception):
+    """exception raised when we are not able to get a python
+    source file for a precompiled file
+    """
+
+
+def _normalize_path(path: str) -> str:
+    """Resolve symlinks in path and convert to absolute path.
+
+    Note that environment variables and ~ in the path need to be expanded in
+    advance.
+
+    This can be cached by using _cache_normalize_path.
+    """
+    return os.path.normcase(os.path.realpath(path))
+
+
+def _path_from_filename(filename, is_jython=IS_JYTHON):
+    if not is_jython:
+        return filename
+    head, has_pyclass, _ = filename.partition("$py.class")
+    if has_pyclass:
+        return head + ".py"
+    return filename
+
+
+def _handle_blacklist(blacklist, dirnames, filenames):
+    """remove files/directories in the black list
+
+    dirnames/filenames are usually from os.walk
+    """
+    for norecurs in blacklist:
+        if norecurs in dirnames:
+            dirnames.remove(norecurs)
+        elif norecurs in filenames:
+            filenames.remove(norecurs)
+
+
+_NORM_PATH_CACHE: Dict[str, str] = {}
+
+
+def _cache_normalize_path(path: str) -> str:
+    """Normalize path with caching."""
+    # _module_file calls abspath on every path in sys.path every time it's
+    # called; on a larger codebase this easily adds up to half a second just
+    # assembling path components. This cache alleviates that.
+    try:
+        return _NORM_PATH_CACHE[path]
+    except KeyError:
+        if not path:  # don't cache result for ''
+            return _normalize_path(path)
+        result = _NORM_PATH_CACHE[path] = _normalize_path(path)
+        return result
+
+
+def load_module_from_name(dotted_name: str) -> types.ModuleType:
+    """Load a Python module from its name.
+
+    :type dotted_name: str
+    :param dotted_name: python name of a module or package
+
+    :raise ImportError: if the module or package is not found
+
+    :rtype: module
+    :return: the loaded module
+    """
+    try:
+        return sys.modules[dotted_name]
+    except KeyError:
+        pass
+
+    return importlib.import_module(dotted_name)
+
+
+def load_module_from_modpath(parts):
+    """Load a python module from its split name.
+
+    :type parts: list(str) or tuple(str)
+    :param parts:
+      python name of a module or package split on '.'
+
+    :raise ImportError: if the module or package is not found
+
+    :rtype: module
+    :return: the loaded module
+    """
+    return load_module_from_name(".".join(parts))
+
+
+def load_module_from_file(filepath: str):
+    """Load a Python module from it's path.
+
+    :type filepath: str
+    :param filepath: path to the python module or package
+
+    :raise ImportError: if the module or package is not found
+
+    :rtype: module
+    :return: the loaded module
+    """
+    modpath = modpath_from_file(filepath)
+    return load_module_from_modpath(modpath)
+
+
+def check_modpath_has_init(path, mod_path):
+    """check there are some __init__.py all along the way"""
+    modpath = []
+    for part in mod_path:
+        modpath.append(part)
+        path = os.path.join(path, part)
+        if not _has_init(path):
+            old_namespace = util.is_namespace(".".join(modpath))
+            if not old_namespace:
+                return False
+    return True
+
+
+def _get_relative_base_path(filename, path_to_check):
+    """Extracts the relative mod path of the file to import from
+
+    Check if a file is within the passed in path and if so, returns the
+    relative mod path from the one passed in.
+
+    If the filename is no in path_to_check, returns None
+
+    Note this function will look for both abs and realpath of the file,
+    this allows to find the relative base path even if the file is a
+    symlink of a file in the passed in path
+
+    Examples:
+        _get_relative_base_path("/a/b/c/d.py", "/a/b") ->  ["c","d"]
+        _get_relative_base_path("/a/b/c/d.py", "/dev") ->  None
+    """
+    importable_path = None
+    path_to_check = os.path.normcase(path_to_check)
+    abs_filename = os.path.abspath(filename)
+    if os.path.normcase(abs_filename).startswith(path_to_check):
+        importable_path = abs_filename
+
+    real_filename = os.path.realpath(filename)
+    if os.path.normcase(real_filename).startswith(path_to_check):
+        importable_path = real_filename
+
+    # if "var" in path_to_check:
+    #     breakpoint()
+
+    if importable_path:
+        base_path = os.path.splitext(importable_path)[0]
+        relative_base_path = base_path[len(path_to_check) :]
+        return [pkg for pkg in relative_base_path.split(os.sep) if pkg]
+
+    return None
+
+
+def modpath_from_file_with_callback(filename, path=None, is_package_cb=None):
+    filename = os.path.expanduser(_path_from_filename(filename))
+    paths_to_check = sys.path.copy()
+    if path:
+        paths_to_check += path
+    for pathname in itertools.chain(
+        paths_to_check, map(_cache_normalize_path, paths_to_check)
+    ):
+        if not pathname:
+            continue
+        modpath = _get_relative_base_path(filename, pathname)
+        if not modpath:
+            continue
+        if is_package_cb(pathname, modpath[:-1]):
+            return modpath
+
+    raise ImportError(
+        "Unable to find module for {} in {}".format(filename, ", \n".join(sys.path))
+    )
+
+
+def modpath_from_file(filename, path=None):
+    """Get the corresponding split module's name from a filename
+
+    This function will return the name of a module or package split on `.`.
+
+    :type filename: str
+    :param filename: file's path for which we want the module's name
+
+    :type Optional[List[str]] path:
+      Optional list of path where the module or package should be
+      searched (use sys.path if nothing or None is given)
+
+    :raise ImportError:
+      if the corresponding module's name has not been found
+
+    :rtype: list(str)
+    :return: the corresponding split module's name
+    """
+    return modpath_from_file_with_callback(filename, path, check_modpath_has_init)
+
+
+def file_from_modpath(modpath, path=None, context_file=None):
+    return file_info_from_modpath(modpath, path, context_file).location
+
+
+def file_info_from_modpath(modpath, path=None, context_file=None):
+    """given a mod path (i.e. split module / package name), return the
+    corresponding file, giving priority to source file over precompiled
+    file if it exists
+
+    :type modpath: list or tuple
+    :param modpath:
+      split module's name (i.e name of a module or package split
+      on '.')
+      (this means explicit relative imports that start with dots have
+      empty strings in this list!)
+
+    :type path: list or None
+    :param path:
+      optional list of path where the module or package should be
+      searched (use sys.path if nothing or None is given)
+
+    :type context_file: str or None
+    :param context_file:
+      context file to consider, necessary if the identifier has been
+      introduced using a relative import unresolvable in the actual
+      context (i.e. modutils)
+
+    :raise ImportError: if there is no such module in the directory
+
+    :rtype: (str or None, import type)
+    :return:
+      the path to the module's file or None if it's an integrated
+      builtin module such as 'sys'
+    """
+    if context_file is not None:
+        context = os.path.dirname(context_file)
+    else:
+        context = context_file
+    if modpath[0] == "xml":
+        # handle _xmlplus
+        try:
+            return _spec_from_modpath(["_xmlplus"] + modpath[1:], path, context)
+        except ImportError:
+            return _spec_from_modpath(modpath, path, context)
+    elif modpath == ["os", "path"]:
+        # FIXME: currently ignoring search_path...
+        return spec.ModuleSpec(
+            name="os.path",
+            location=os.path.__file__,
+            module_type=spec.ModuleType.PY_SOURCE,
+        )
+    return _spec_from_modpath(modpath, path, context)
+
+
+def get_module_part(dotted_name, context_file=None):
+    """given a dotted name return the module part of the name :
+
+    >>> get_module_part('astroid.as_string.dump')
+    'astroid.as_string'
+
+    :type dotted_name: str
+    :param dotted_name: full name of the identifier we are interested in
+
+    :type context_file: str or None
+    :param context_file:
+      context file to consider, necessary if the identifier has been
+      introduced using a relative import unresolvable in the actual
+      context (i.e. modutils)
+
+
+    :raise ImportError: if there is no such module in the directory
+
+    :rtype: str or None
+    :return:
+      the module part of the name or None if we have not been able at
+      all to import the given name
+
+    XXX: deprecated, since it doesn't handle package precedence over module
+    (see #10066)
+    """
+    # os.path trick
+    if dotted_name.startswith("os.path"):
+        return "os.path"
+    parts = dotted_name.split(".")
+    if context_file is not None:
+        # first check for builtin module which won't be considered latter
+        # in that case (path != None)
+        if parts[0] in BUILTIN_MODULES:
+            if len(parts) > 2:
+                raise ImportError(dotted_name)
+            return parts[0]
+        # don't use += or insert, we want a new list to be created !
+    path = None
+    starti = 0
+    if parts[0] == "":
+        assert (
+            context_file is not None
+        ), "explicit relative import, but no context_file?"
+        path = []  # prevent resolving the import non-relatively
+        starti = 1
+    while parts[starti] == "":  # for all further dots: change context
+        starti += 1
+        context_file = os.path.dirname(context_file)
+    for i in range(starti, len(parts)):
+        try:
+            file_from_modpath(
+                parts[starti : i + 1], path=path, context_file=context_file
+            )
+        except ImportError:
+            if i < max(1, len(parts) - 2):
+                raise
+            return ".".join(parts[:i])
+    return dotted_name
+
+
+def get_module_files(src_directory, blacklist, list_all=False):
+    """given a package directory return a list of all available python
+    module's files in the package and its subpackages
+
+    :type src_directory: str
+    :param src_directory:
+      path of the directory corresponding to the package
+
+    :type blacklist: list or tuple
+    :param blacklist: iterable
+      list of files or directories to ignore.
+
+    :type list_all: bool
+    :param list_all:
+        get files from all paths, including ones without __init__.py
+
+    :rtype: list
+    :return:
+      the list of all available python module's files in the package and
+      its subpackages
+    """
+    files = []
+    for directory, dirnames, filenames in os.walk(src_directory):
+        if directory in blacklist:
+            continue
+        _handle_blacklist(blacklist, dirnames, filenames)
+        # check for __init__.py
+        if not list_all and "__init__.py" not in filenames:
+            dirnames[:] = ()
+            continue
+        for filename in filenames:
+            if _is_python_file(filename):
+                src = os.path.join(directory, filename)
+                files.append(src)
+    return files
+
+
+def get_source_file(filename, include_no_ext=False):
+    """given a python module's file name return the matching source file
+    name (the filename will be returned identically if it's already an
+    absolute path to a python source file...)
+
+    :type filename: str
+    :param filename: python module's file name
+
+
+    :raise NoSourceFile: if no source file exists on the file system
+
+    :rtype: str
+    :return: the absolute path of the source file if it exists
+    """
+    filename = os.path.abspath(_path_from_filename(filename))
+    base, orig_ext = os.path.splitext(filename)
+    for ext in PY_SOURCE_EXTS:
+        source_path = f"{base}.{ext}"
+        if os.path.exists(source_path):
+            return source_path
+    if include_no_ext and not orig_ext and os.path.exists(base):
+        return base
+    raise NoSourceFile(filename)
+
+
+def is_python_source(filename):
+    """
+    rtype: bool
+    return: True if the filename is a python source file
+    """
+    return os.path.splitext(filename)[1][1:] in PY_SOURCE_EXTS
+
+
+def is_standard_module(modname, std_path=None):
+    """try to guess if a module is a standard python module (by default,
+    see `std_path` parameter's description)
+
+    :type modname: str
+    :param modname: name of the module we are interested in
+
+    :type std_path: list(str) or tuple(str)
+    :param std_path: list of path considered has standard
+
+
+    :rtype: bool
+    :return:
+      true if the module:
+      - is located on the path listed in one of the directory in `std_path`
+      - is a built-in module
+    """
+    modname = modname.split(".")[0]
+    try:
+        filename = file_from_modpath([modname])
+    except ImportError:
+        # import failed, i'm probably not so wrong by supposing it's
+        # not standard...
+        return False
+    # modules which are not living in a file are considered standard
+    # (sys and __builtin__ for instance)
+    if filename is None:
+        # we assume there are no namespaces in stdlib
+        return not util.is_namespace(modname)
+    filename = _normalize_path(filename)
+    for path in EXT_LIB_DIRS:
+        if filename.startswith(_cache_normalize_path(path)):
+            return False
+    if std_path is None:
+        std_path = STD_LIB_DIRS
+
+    return any(filename.startswith(_cache_normalize_path(path)) for path in std_path)
+
+
+def is_relative(modname, from_file):
+    """return true if the given module name is relative to the given
+    file name
+
+    :type modname: str
+    :param modname: name of the module we are interested in
+
+    :type from_file: str
+    :param from_file:
+      path of the module from which modname has been imported
+
+    :rtype: bool
+    :return:
+      true if the module has been imported relatively to `from_file`
+    """
+    if not os.path.isdir(from_file):
+        from_file = os.path.dirname(from_file)
+    if from_file in sys.path:
+        return False
+    return bool(
+        importlib.machinery.PathFinder.find_spec(
+            modname.split(".", maxsplit=1)[0], [from_file]
+        )
+    )
+
+
+# internal only functions #####################################################
+
+
+def _spec_from_modpath(modpath, path=None, context=None):
+    """given a mod path (i.e. split module / package name), return the
+    corresponding spec
+
+    this function is used internally, see `file_from_modpath`'s
+    documentation for more information
+    """
+    assert modpath
+    location = None
+    if context is not None:
+        try:
+            found_spec = spec.find_spec(modpath, [context])
+            location = found_spec.location
+        except ImportError:
+            found_spec = spec.find_spec(modpath, path)
+            location = found_spec.location
+    else:
+        found_spec = spec.find_spec(modpath, path)
+    if found_spec.type == spec.ModuleType.PY_COMPILED:
+        try:
+            location = get_source_file(found_spec.location)
+            return found_spec._replace(
+                location=location, type=spec.ModuleType.PY_SOURCE
+            )
+        except NoSourceFile:
+            return found_spec._replace(location=location)
+    elif found_spec.type == spec.ModuleType.C_BUILTIN:
+        # integrated builtin module
+        return found_spec._replace(location=None)
+    elif found_spec.type == spec.ModuleType.PKG_DIRECTORY:
+        location = _has_init(found_spec.location)
+        return found_spec._replace(location=location, type=spec.ModuleType.PY_SOURCE)
+    return found_spec
+
+
+def _is_python_file(filename):
+    """return true if the given filename should be considered as a python file
+
+    .pyc and .pyo are ignored
+    """
+    return filename.endswith((".py", ".so", ".pyd", ".pyw"))
+
+
+def _has_init(directory):
+    """if the given directory has a valid __init__ file, return its path,
+    else return None
+    """
+    mod_or_pack = os.path.join(directory, "__init__")
+    for ext in PY_SOURCE_EXTS + ("pyc", "pyo"):
+        if os.path.exists(mod_or_pack + "." + ext):
+            return mod_or_pack + "." + ext
+    return None
+
+
+def is_namespace(specobj):
+    return specobj.type == spec.ModuleType.PY_NAMESPACE
+
+
+def is_directory(specobj):
+    return specobj.type == spec.ModuleType.PKG_DIRECTORY
+
+
+def is_module_name_part_of_extension_package_whitelist(
+    module_name: str, package_whitelist: Set[str]
+) -> bool:
+    """
+    Returns True if one part of the module name is in the package whitelist
+
+    >>> is_module_name_part_of_extension_package_whitelist('numpy.core.umath', {'numpy'})
+    True
+    """
+    parts = module_name.split(".")
+    return any(
+        ".".join(parts[:x]) in package_whitelist for x in range(1, len(parts) + 1)
+    )
diff --git a/myenv/lib/python3.9/site-packages/astroid/node_classes.py b/myenv/lib/python3.9/site-packages/astroid/node_classes.py
new file mode 100644
index 0000000..3711309
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/node_classes.py
@@ -0,0 +1,97 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+# pylint: disable=unused-import
+
+import warnings
+
+from astroid.nodes.node_classes import (  # pylint: disable=redefined-builtin (Ellipsis)
+    CONST_CLS,
+    AnnAssign,
+    Arguments,
+    Assert,
+    Assign,
+    AssignAttr,
+    AssignName,
+    AsyncFor,
+    AsyncWith,
+    Attribute,
+    AugAssign,
+    Await,
+    BaseContainer,
+    BinOp,
+    BoolOp,
+    Break,
+    Call,
+    Compare,
+    Comprehension,
+    Const,
+    Continue,
+    Decorators,
+    DelAttr,
+    Delete,
+    DelName,
+    Dict,
+    DictUnpack,
+    Ellipsis,
+    EmptyNode,
+    EvaluatedObject,
+    ExceptHandler,
+    Expr,
+    ExtSlice,
+    For,
+    FormattedValue,
+    Global,
+    If,
+    IfExp,
+    Import,
+    ImportFrom,
+    Index,
+    JoinedStr,
+    Keyword,
+    List,
+    LookupMixIn,
+    Match,
+    MatchAs,
+    MatchCase,
+    MatchClass,
+    MatchMapping,
+    MatchOr,
+    MatchSequence,
+    MatchSingleton,
+    MatchStar,
+    MatchValue,
+    Name,
+    NamedExpr,
+    NodeNG,
+    Nonlocal,
+    Pass,
+    Pattern,
+    Raise,
+    Return,
+    Set,
+    Slice,
+    Starred,
+    Subscript,
+    TryExcept,
+    TryFinally,
+    Tuple,
+    UnaryOp,
+    Unknown,
+    While,
+    With,
+    Yield,
+    YieldFrom,
+    are_exclusive,
+    const_factory,
+    unpack_infer,
+)
+
+# We cannot create a __all__ here because it would create a circular import
+# Please remove astroid/scoped_nodes.py|astroid/node_classes.py in autoflake
+# exclude when removing this file.
+warnings.warn(
+    "The 'astroid.node_classes' module is deprecated and will be replaced by 'astroid.nodes' in astroid 3.0.0",
+    DeprecationWarning,
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/nodes/__init__.py b/myenv/lib/python3.9/site-packages/astroid/nodes/__init__.py
new file mode 100644
index 0000000..0a98ed1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/nodes/__init__.py
@@ -0,0 +1,299 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Every available node class.
+
+.. seealso::
+    :doc:`ast documentation <green_tree_snakes:nodes>`
+
+All nodes inherit from :class:`~astroid.nodes.node_classes.NodeNG`.
+"""
+
+# Nodes not present in the builtin ast module:  DictUnpack, Unknown, and EvaluatedObject.
+
+from astroid.nodes.node_classes import (  # pylint: disable=redefined-builtin (Ellipsis)
+    CONST_CLS,
+    AnnAssign,
+    Arguments,
+    Assert,
+    Assign,
+    AssignAttr,
+    AssignName,
+    AsyncFor,
+    AsyncWith,
+    Attribute,
+    AugAssign,
+    Await,
+    BaseContainer,
+    BinOp,
+    BoolOp,
+    Break,
+    Call,
+    Compare,
+    Comprehension,
+    Const,
+    Continue,
+    Decorators,
+    DelAttr,
+    Delete,
+    DelName,
+    Dict,
+    DictUnpack,
+    Ellipsis,
+    EmptyNode,
+    EvaluatedObject,
+    ExceptHandler,
+    Expr,
+    ExtSlice,
+    For,
+    FormattedValue,
+    Global,
+    If,
+    IfExp,
+    Import,
+    ImportFrom,
+    Index,
+    JoinedStr,
+    Keyword,
+    List,
+    Match,
+    MatchAs,
+    MatchCase,
+    MatchClass,
+    MatchMapping,
+    MatchOr,
+    MatchSequence,
+    MatchSingleton,
+    MatchStar,
+    MatchValue,
+    Name,
+    NamedExpr,
+    NodeNG,
+    Nonlocal,
+    Pass,
+    Pattern,
+    Raise,
+    Return,
+    Set,
+    Slice,
+    Starred,
+    Statement,
+    Subscript,
+    TryExcept,
+    TryFinally,
+    Tuple,
+    UnaryOp,
+    Unknown,
+    While,
+    With,
+    Yield,
+    YieldFrom,
+    are_exclusive,
+    const_factory,
+    unpack_infer,
+)
+from astroid.nodes.scoped_nodes import (
+    AsyncFunctionDef,
+    ClassDef,
+    ComprehensionScope,
+    DictComp,
+    FunctionDef,
+    GeneratorExp,
+    Lambda,
+    ListComp,
+    LocalsDictNodeNG,
+    Module,
+    SetComp,
+    builtin_lookup,
+    function_to_method,
+    get_wrapping_class,
+)
+from astroid.nodes.utils import Position
+
+_BaseContainer = BaseContainer  # TODO Remove for astroid 3.0
+
+ALL_NODE_CLASSES = (
+    _BaseContainer,
+    BaseContainer,
+    AnnAssign,
+    Arguments,
+    Assert,
+    Assign,
+    AssignAttr,
+    AssignName,
+    AsyncFor,
+    AsyncFunctionDef,
+    AsyncWith,
+    Attribute,
+    AugAssign,
+    Await,
+    BinOp,
+    BoolOp,
+    Break,
+    Call,
+    ClassDef,
+    Compare,
+    Comprehension,
+    ComprehensionScope,
+    Const,
+    const_factory,
+    Continue,
+    Decorators,
+    DelAttr,
+    Delete,
+    DelName,
+    Dict,
+    DictComp,
+    DictUnpack,
+    Ellipsis,
+    EmptyNode,
+    EvaluatedObject,
+    ExceptHandler,
+    Expr,
+    ExtSlice,
+    For,
+    FormattedValue,
+    FunctionDef,
+    GeneratorExp,
+    Global,
+    If,
+    IfExp,
+    Import,
+    ImportFrom,
+    Index,
+    JoinedStr,
+    Keyword,
+    Lambda,
+    List,
+    ListComp,
+    LocalsDictNodeNG,
+    Match,
+    MatchAs,
+    MatchCase,
+    MatchClass,
+    MatchMapping,
+    MatchOr,
+    MatchSequence,
+    MatchSingleton,
+    MatchStar,
+    MatchValue,
+    Module,
+    Name,
+    NamedExpr,
+    NodeNG,
+    Nonlocal,
+    Pass,
+    Pattern,
+    Raise,
+    Return,
+    Set,
+    SetComp,
+    Slice,
+    Starred,
+    Subscript,
+    TryExcept,
+    TryFinally,
+    Tuple,
+    UnaryOp,
+    Unknown,
+    While,
+    With,
+    Yield,
+    YieldFrom,
+)
+
+__all__ = (
+    "AnnAssign",
+    "are_exclusive",
+    "Arguments",
+    "Assert",
+    "Assign",
+    "AssignAttr",
+    "AssignName",
+    "AsyncFor",
+    "AsyncFunctionDef",
+    "AsyncWith",
+    "Attribute",
+    "AugAssign",
+    "Await",
+    "BinOp",
+    "BoolOp",
+    "Break",
+    "builtin_lookup",
+    "Call",
+    "ClassDef",
+    "CONST_CLS",
+    "Compare",
+    "Comprehension",
+    "ComprehensionScope",
+    "Const",
+    "const_factory",
+    "Continue",
+    "Decorators",
+    "DelAttr",
+    "Delete",
+    "DelName",
+    "Dict",
+    "DictComp",
+    "DictUnpack",
+    "Ellipsis",
+    "EmptyNode",
+    "EvaluatedObject",
+    "ExceptHandler",
+    "Expr",
+    "ExtSlice",
+    "For",
+    "FormattedValue",
+    "FunctionDef",
+    "function_to_method",
+    "GeneratorExp",
+    "get_wrapping_class",
+    "Global",
+    "If",
+    "IfExp",
+    "Import",
+    "ImportFrom",
+    "Index",
+    "JoinedStr",
+    "Keyword",
+    "Lambda",
+    "List",
+    "ListComp",
+    "LocalsDictNodeNG",
+    "Match",
+    "MatchAs",
+    "MatchCase",
+    "MatchClass",
+    "MatchMapping",
+    "MatchOr",
+    "MatchSequence",
+    "MatchSingleton",
+    "MatchStar",
+    "MatchValue",
+    "Module",
+    "Name",
+    "NamedExpr",
+    "NodeNG",
+    "Nonlocal",
+    "Pass",
+    "Position",
+    "Raise",
+    "Return",
+    "Set",
+    "SetComp",
+    "Slice",
+    "Starred",
+    "Statement",
+    "Subscript",
+    "TryExcept",
+    "TryFinally",
+    "Tuple",
+    "UnaryOp",
+    "Unknown",
+    "unpack_infer",
+    "While",
+    "With",
+    "Yield",
+    "YieldFrom",
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/nodes/as_string.py b/myenv/lib/python3.9/site-packages/astroid/nodes/as_string.py
new file mode 100644
index 0000000..2e2bdcf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/nodes/as_string.py
@@ -0,0 +1,650 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""This module renders Astroid nodes as string"""
+from typing import TYPE_CHECKING, List, Optional
+
+if TYPE_CHECKING:
+    from astroid.nodes import Const
+    from astroid.nodes.node_classes import (
+        Match,
+        MatchAs,
+        MatchCase,
+        MatchClass,
+        MatchMapping,
+        MatchOr,
+        MatchSequence,
+        MatchSingleton,
+        MatchStar,
+        MatchValue,
+        Unknown,
+    )
+
+# pylint: disable=unused-argument
+
+DOC_NEWLINE = "\0"
+
+
+# Visitor pattern require argument all the time and is not better with staticmethod
+# noinspection PyUnusedLocal,PyMethodMayBeStatic
+class AsStringVisitor:
+    """Visitor to render an Astroid node as a valid python code string"""
+
+    def __init__(self, indent="    "):
+        self.indent = indent
+
+    def __call__(self, node):
+        """Makes this visitor behave as a simple function"""
+        return node.accept(self).replace(DOC_NEWLINE, "\n")
+
+    def _docs_dedent(self, doc_node: Optional["Const"]) -> str:
+        """Stop newlines in docs being indented by self._stmt_list"""
+        if not doc_node:
+            return ""
+
+        return '\n{}"""{}"""'.format(
+            self.indent, doc_node.value.replace("\n", DOC_NEWLINE)
+        )
+
+    def _stmt_list(self, stmts, indent=True):
+        """return a list of nodes to string"""
+        stmts = "\n".join(nstr for nstr in [n.accept(self) for n in stmts] if nstr)
+        if indent:
+            return self.indent + stmts.replace("\n", "\n" + self.indent)
+
+        return stmts
+
+    def _precedence_parens(self, node, child, is_left=True):
+        """Wrap child in parens only if required to keep same semantics"""
+        if self._should_wrap(node, child, is_left):
+            return f"({child.accept(self)})"
+
+        return child.accept(self)
+
+    def _should_wrap(self, node, child, is_left):
+        """Wrap child if:
+        - it has lower precedence
+        - same precedence with position opposite to associativity direction
+        """
+        node_precedence = node.op_precedence()
+        child_precedence = child.op_precedence()
+
+        if node_precedence > child_precedence:
+            # 3 * (4 + 5)
+            return True
+
+        if (
+            node_precedence == child_precedence
+            and is_left != node.op_left_associative()
+        ):
+            # 3 - (4 - 5)
+            # (2**3)**4
+            return True
+
+        return False
+
+    # visit_<node> methods ###########################################
+
+    def visit_await(self, node):
+        return f"await {node.value.accept(self)}"
+
+    def visit_asyncwith(self, node):
+        return f"async {self.visit_with(node)}"
+
+    def visit_asyncfor(self, node):
+        return f"async {self.visit_for(node)}"
+
+    def visit_arguments(self, node):
+        """return an astroid.Function node as string"""
+        return node.format_args()
+
+    def visit_assignattr(self, node):
+        """return an astroid.AssAttr node as string"""
+        return self.visit_attribute(node)
+
+    def visit_assert(self, node):
+        """return an astroid.Assert node as string"""
+        if node.fail:
+            return f"assert {node.test.accept(self)}, {node.fail.accept(self)}"
+        return f"assert {node.test.accept(self)}"
+
+    def visit_assignname(self, node):
+        """return an astroid.AssName node as string"""
+        return node.name
+
+    def visit_assign(self, node):
+        """return an astroid.Assign node as string"""
+        lhs = " = ".join(n.accept(self) for n in node.targets)
+        return f"{lhs} = {node.value.accept(self)}"
+
+    def visit_augassign(self, node):
+        """return an astroid.AugAssign node as string"""
+        return f"{node.target.accept(self)} {node.op} {node.value.accept(self)}"
+
+    def visit_annassign(self, node):
+        """Return an astroid.AugAssign node as string"""
+
+        target = node.target.accept(self)
+        annotation = node.annotation.accept(self)
+        if node.value is None:
+            return f"{target}: {annotation}"
+        return f"{target}: {annotation} = {node.value.accept(self)}"
+
+    def visit_binop(self, node):
+        """return an astroid.BinOp node as string"""
+        left = self._precedence_parens(node, node.left)
+        right = self._precedence_parens(node, node.right, is_left=False)
+        if node.op == "**":
+            return f"{left}{node.op}{right}"
+
+        return f"{left} {node.op} {right}"
+
+    def visit_boolop(self, node):
+        """return an astroid.BoolOp node as string"""
+        values = [f"{self._precedence_parens(node, n)}" for n in node.values]
+        return (f" {node.op} ").join(values)
+
+    def visit_break(self, node):
+        """return an astroid.Break node as string"""
+        return "break"
+
+    def visit_call(self, node):
+        """return an astroid.Call node as string"""
+        expr_str = self._precedence_parens(node, node.func)
+        args = [arg.accept(self) for arg in node.args]
+        if node.keywords:
+            keywords = [kwarg.accept(self) for kwarg in node.keywords]
+        else:
+            keywords = []
+
+        args.extend(keywords)
+        return f"{expr_str}({', '.join(args)})"
+
+    def visit_classdef(self, node):
+        """return an astroid.ClassDef node as string"""
+        decorate = node.decorators.accept(self) if node.decorators else ""
+        args = [n.accept(self) for n in node.bases]
+        if node._metaclass and not node.has_metaclass_hack():
+            args.append("metaclass=" + node._metaclass.accept(self))
+        args += [n.accept(self) for n in node.keywords]
+        args = f"({', '.join(args)})" if args else ""
+        docs = self._docs_dedent(node.doc_node)
+        return "\n\n{}class {}{}:{}\n{}\n".format(
+            decorate, node.name, args, docs, self._stmt_list(node.body)
+        )
+
+    def visit_compare(self, node):
+        """return an astroid.Compare node as string"""
+        rhs_str = " ".join(
+            f"{op} {self._precedence_parens(node, expr, is_left=False)}"
+            for op, expr in node.ops
+        )
+        return f"{self._precedence_parens(node, node.left)} {rhs_str}"
+
+    def visit_comprehension(self, node):
+        """return an astroid.Comprehension node as string"""
+        ifs = "".join(f" if {n.accept(self)}" for n in node.ifs)
+        generated = f"for {node.target.accept(self)} in {node.iter.accept(self)}{ifs}"
+        return f"{'async ' if node.is_async else ''}{generated}"
+
+    def visit_const(self, node):
+        """return an astroid.Const node as string"""
+        if node.value is Ellipsis:
+            return "..."
+        return repr(node.value)
+
+    def visit_continue(self, node):
+        """return an astroid.Continue node as string"""
+        return "continue"
+
+    def visit_delete(self, node):  # XXX check if correct
+        """return an astroid.Delete node as string"""
+        return f"del {', '.join(child.accept(self) for child in node.targets)}"
+
+    def visit_delattr(self, node):
+        """return an astroid.DelAttr node as string"""
+        return self.visit_attribute(node)
+
+    def visit_delname(self, node):
+        """return an astroid.DelName node as string"""
+        return node.name
+
+    def visit_decorators(self, node):
+        """return an astroid.Decorators node as string"""
+        return "@%s\n" % "\n@".join(item.accept(self) for item in node.nodes)
+
+    def visit_dict(self, node):
+        """return an astroid.Dict node as string"""
+        return "{%s}" % ", ".join(self._visit_dict(node))
+
+    def _visit_dict(self, node):
+        for key, value in node.items:
+            key = key.accept(self)
+            value = value.accept(self)
+            if key == "**":
+                # It can only be a DictUnpack node.
+                yield key + value
+            else:
+                yield f"{key}: {value}"
+
+    def visit_dictunpack(self, node):
+        return "**"
+
+    def visit_dictcomp(self, node):
+        """return an astroid.DictComp node as string"""
+        return "{{{}: {} {}}}".format(
+            node.key.accept(self),
+            node.value.accept(self),
+            " ".join(n.accept(self) for n in node.generators),
+        )
+
+    def visit_expr(self, node):
+        """return an astroid.Discard node as string"""
+        return node.value.accept(self)
+
+    def visit_emptynode(self, node):
+        """dummy method for visiting an Empty node"""
+        return ""
+
+    def visit_excepthandler(self, node):
+        if node.type:
+            if node.name:
+                excs = f"except {node.type.accept(self)} as {node.name.accept(self)}"
+            else:
+                excs = f"except {node.type.accept(self)}"
+        else:
+            excs = "except"
+        return f"{excs}:\n{self._stmt_list(node.body)}"
+
+    def visit_empty(self, node):
+        """return an Empty node as string"""
+        return ""
+
+    def visit_for(self, node):
+        """return an astroid.For node as string"""
+        fors = "for {} in {}:\n{}".format(
+            node.target.accept(self), node.iter.accept(self), self._stmt_list(node.body)
+        )
+        if node.orelse:
+            fors = f"{fors}\nelse:\n{self._stmt_list(node.orelse)}"
+        return fors
+
+    def visit_importfrom(self, node):
+        """return an astroid.ImportFrom node as string"""
+        return "from {} import {}".format(
+            "." * (node.level or 0) + node.modname, _import_string(node.names)
+        )
+
+    def visit_joinedstr(self, node):
+        string = "".join(
+            # Use repr on the string literal parts
+            # to get proper escapes, e.g. \n, \\, \"
+            # But strip the quotes off the ends
+            # (they will always be one character: ' or ")
+            repr(value.value)[1:-1]
+            # Literal braces must be doubled to escape them
+            .replace("{", "{{").replace("}", "}}")
+            # Each value in values is either a string literal (Const)
+            # or a FormattedValue
+            if type(value).__name__ == "Const" else value.accept(self)
+            for value in node.values
+        )
+
+        # Try to find surrounding quotes that don't appear at all in the string.
+        # Because the formatted values inside {} can't contain backslash (\)
+        # using a triple quote is sometimes necessary
+        for quote in ("'", '"', '"""', "'''"):
+            if quote not in string:
+                break
+
+        return "f" + quote + string + quote
+
+    def visit_formattedvalue(self, node):
+        result = node.value.accept(self)
+        if node.conversion and node.conversion >= 0:
+            # e.g. if node.conversion == 114: result += "!r"
+            result += "!" + chr(node.conversion)
+        if node.format_spec:
+            # The format spec is itself a JoinedString, i.e. an f-string
+            # We strip the f and quotes of the ends
+            result += ":" + node.format_spec.accept(self)[2:-1]
+        return "{%s}" % result
+
+    def handle_functiondef(self, node, keyword):
+        """return a (possibly async) function definition node as string"""
+        decorate = node.decorators.accept(self) if node.decorators else ""
+        docs = self._docs_dedent(node.doc_node)
+        trailer = ":"
+        if node.returns:
+            return_annotation = " -> " + node.returns.as_string()
+            trailer = return_annotation + ":"
+        def_format = "\n%s%s %s(%s)%s%s\n%s"
+        return def_format % (
+            decorate,
+            keyword,
+            node.name,
+            node.args.accept(self),
+            trailer,
+            docs,
+            self._stmt_list(node.body),
+        )
+
+    def visit_functiondef(self, node):
+        """return an astroid.FunctionDef node as string"""
+        return self.handle_functiondef(node, "def")
+
+    def visit_asyncfunctiondef(self, node):
+        """return an astroid.AsyncFunction node as string"""
+        return self.handle_functiondef(node, "async def")
+
+    def visit_generatorexp(self, node):
+        """return an astroid.GeneratorExp node as string"""
+        return "({} {})".format(
+            node.elt.accept(self), " ".join(n.accept(self) for n in node.generators)
+        )
+
+    def visit_attribute(self, node):
+        """return an astroid.Getattr node as string"""
+        left = self._precedence_parens(node, node.expr)
+        if left.isdigit():
+            left = f"({left})"
+        return f"{left}.{node.attrname}"
+
+    def visit_global(self, node):
+        """return an astroid.Global node as string"""
+        return f"global {', '.join(node.names)}"
+
+    def visit_if(self, node):
+        """return an astroid.If node as string"""
+        ifs = [f"if {node.test.accept(self)}:\n{self._stmt_list(node.body)}"]
+        if node.has_elif_block():
+            ifs.append(f"el{self._stmt_list(node.orelse, indent=False)}")
+        elif node.orelse:
+            ifs.append(f"else:\n{self._stmt_list(node.orelse)}")
+        return "\n".join(ifs)
+
+    def visit_ifexp(self, node):
+        """return an astroid.IfExp node as string"""
+        return "{} if {} else {}".format(
+            self._precedence_parens(node, node.body, is_left=True),
+            self._precedence_parens(node, node.test, is_left=True),
+            self._precedence_parens(node, node.orelse, is_left=False),
+        )
+
+    def visit_import(self, node):
+        """return an astroid.Import node as string"""
+        return f"import {_import_string(node.names)}"
+
+    def visit_keyword(self, node):
+        """return an astroid.Keyword node as string"""
+        if node.arg is None:
+            return f"**{node.value.accept(self)}"
+        return f"{node.arg}={node.value.accept(self)}"
+
+    def visit_lambda(self, node):
+        """return an astroid.Lambda node as string"""
+        args = node.args.accept(self)
+        body = node.body.accept(self)
+        if args:
+            return f"lambda {args}: {body}"
+
+        return f"lambda: {body}"
+
+    def visit_list(self, node):
+        """return an astroid.List node as string"""
+        return f"[{', '.join(child.accept(self) for child in node.elts)}]"
+
+    def visit_listcomp(self, node):
+        """return an astroid.ListComp node as string"""
+        return "[{} {}]".format(
+            node.elt.accept(self), " ".join(n.accept(self) for n in node.generators)
+        )
+
+    def visit_module(self, node):
+        """return an astroid.Module node as string"""
+        docs = f'"""{node.doc_node.value}"""\n\n' if node.doc_node else ""
+        return docs + "\n".join(n.accept(self) for n in node.body) + "\n\n"
+
+    def visit_name(self, node):
+        """return an astroid.Name node as string"""
+        return node.name
+
+    def visit_namedexpr(self, node):
+        """Return an assignment expression node as string"""
+        target = node.target.accept(self)
+        value = node.value.accept(self)
+        return f"{target} := {value}"
+
+    def visit_nonlocal(self, node):
+        """return an astroid.Nonlocal node as string"""
+        return f"nonlocal {', '.join(node.names)}"
+
+    def visit_pass(self, node):
+        """return an astroid.Pass node as string"""
+        return "pass"
+
+    def visit_raise(self, node):
+        """return an astroid.Raise node as string"""
+        if node.exc:
+            if node.cause:
+                return f"raise {node.exc.accept(self)} from {node.cause.accept(self)}"
+            return f"raise {node.exc.accept(self)}"
+        return "raise"
+
+    def visit_return(self, node):
+        """return an astroid.Return node as string"""
+        if node.is_tuple_return() and len(node.value.elts) > 1:
+            elts = [child.accept(self) for child in node.value.elts]
+            return f"return {', '.join(elts)}"
+
+        if node.value:
+            return f"return {node.value.accept(self)}"
+
+        return "return"
+
+    def visit_set(self, node):
+        """return an astroid.Set node as string"""
+        return "{%s}" % ", ".join(child.accept(self) for child in node.elts)
+
+    def visit_setcomp(self, node):
+        """return an astroid.SetComp node as string"""
+        return "{{{} {}}}".format(
+            node.elt.accept(self), " ".join(n.accept(self) for n in node.generators)
+        )
+
+    def visit_slice(self, node):
+        """return an astroid.Slice node as string"""
+        lower = node.lower.accept(self) if node.lower else ""
+        upper = node.upper.accept(self) if node.upper else ""
+        step = node.step.accept(self) if node.step else ""
+        if step:
+            return f"{lower}:{upper}:{step}"
+        return f"{lower}:{upper}"
+
+    def visit_subscript(self, node):
+        """return an astroid.Subscript node as string"""
+        idx = node.slice
+        if idx.__class__.__name__.lower() == "index":
+            idx = idx.value
+        idxstr = idx.accept(self)
+        if idx.__class__.__name__.lower() == "tuple" and idx.elts:
+            # Remove parenthesis in tuple and extended slice.
+            # a[(::1, 1:)] is not valid syntax.
+            idxstr = idxstr[1:-1]
+        return f"{self._precedence_parens(node, node.value)}[{idxstr}]"
+
+    def visit_tryexcept(self, node):
+        """return an astroid.TryExcept node as string"""
+        trys = [f"try:\n{self._stmt_list(node.body)}"]
+        for handler in node.handlers:
+            trys.append(handler.accept(self))
+        if node.orelse:
+            trys.append(f"else:\n{self._stmt_list(node.orelse)}")
+        return "\n".join(trys)
+
+    def visit_tryfinally(self, node):
+        """return an astroid.TryFinally node as string"""
+        return "try:\n{}\nfinally:\n{}".format(
+            self._stmt_list(node.body), self._stmt_list(node.finalbody)
+        )
+
+    def visit_tuple(self, node):
+        """return an astroid.Tuple node as string"""
+        if len(node.elts) == 1:
+            return f"({node.elts[0].accept(self)}, )"
+        return f"({', '.join(child.accept(self) for child in node.elts)})"
+
+    def visit_unaryop(self, node):
+        """return an astroid.UnaryOp node as string"""
+        if node.op == "not":
+            operator = "not "
+        else:
+            operator = node.op
+        return f"{operator}{self._precedence_parens(node, node.operand)}"
+
+    def visit_while(self, node):
+        """return an astroid.While node as string"""
+        whiles = f"while {node.test.accept(self)}:\n{self._stmt_list(node.body)}"
+        if node.orelse:
+            whiles = f"{whiles}\nelse:\n{self._stmt_list(node.orelse)}"
+        return whiles
+
+    def visit_with(self, node):  # 'with' without 'as' is possible
+        """return an astroid.With node as string"""
+        items = ", ".join(
+            f"{expr.accept(self)}" + (v and f" as {v.accept(self)}" or "")
+            for expr, v in node.items
+        )
+        return f"with {items}:\n{self._stmt_list(node.body)}"
+
+    def visit_yield(self, node):
+        """yield an ast.Yield node as string"""
+        yi_val = (" " + node.value.accept(self)) if node.value else ""
+        expr = "yield" + yi_val
+        if node.parent.is_statement:
+            return expr
+
+        return f"({expr})"
+
+    def visit_yieldfrom(self, node):
+        """Return an astroid.YieldFrom node as string."""
+        yi_val = (" " + node.value.accept(self)) if node.value else ""
+        expr = "yield from" + yi_val
+        if node.parent.is_statement:
+            return expr
+
+        return f"({expr})"
+
+    def visit_starred(self, node):
+        """return Starred node as string"""
+        return "*" + node.value.accept(self)
+
+    def visit_match(self, node: "Match") -> str:
+        """Return an astroid.Match node as string."""
+        return f"match {node.subject.accept(self)}:\n{self._stmt_list(node.cases)}"
+
+    def visit_matchcase(self, node: "MatchCase") -> str:
+        """Return an astroid.MatchCase node as string."""
+        guard_str = f" if {node.guard.accept(self)}" if node.guard else ""
+        return (
+            f"case {node.pattern.accept(self)}{guard_str}:\n"
+            f"{self._stmt_list(node.body)}"
+        )
+
+    def visit_matchvalue(self, node: "MatchValue") -> str:
+        """Return an astroid.MatchValue node as string."""
+        return node.value.accept(self)
+
+    @staticmethod
+    def visit_matchsingleton(node: "MatchSingleton") -> str:
+        """Return an astroid.MatchSingleton node as string."""
+        return str(node.value)
+
+    def visit_matchsequence(self, node: "MatchSequence") -> str:
+        """Return an astroid.MatchSequence node as string."""
+        if node.patterns is None:
+            return "[]"
+        return f"[{', '.join(p.accept(self) for p in node.patterns)}]"
+
+    def visit_matchmapping(self, node: "MatchMapping") -> str:
+        """Return an astroid.MatchMapping node as string."""
+        mapping_strings: List[str] = []
+        if node.keys and node.patterns:
+            mapping_strings.extend(
+                f"{key.accept(self)}: {p.accept(self)}"
+                for key, p in zip(node.keys, node.patterns)
+            )
+        if node.rest:
+            mapping_strings.append(f"**{node.rest.accept(self)}")
+        return f"{'{'}{', '.join(mapping_strings)}{'}'}"
+
+    def visit_matchclass(self, node: "MatchClass") -> str:
+        """Return an astroid.MatchClass node as string."""
+        if node.cls is None:
+            raise Exception(f"{node} does not have a 'cls' node")
+        class_strings: List[str] = []
+        if node.patterns:
+            class_strings.extend(p.accept(self) for p in node.patterns)
+        if node.kwd_attrs and node.kwd_patterns:
+            for attr, pattern in zip(node.kwd_attrs, node.kwd_patterns):
+                class_strings.append(f"{attr}={pattern.accept(self)}")
+        return f"{node.cls.accept(self)}({', '.join(class_strings)})"
+
+    def visit_matchstar(self, node: "MatchStar") -> str:
+        """Return an astroid.MatchStar node as string."""
+        return f"*{node.name.accept(self) if node.name else '_'}"
+
+    def visit_matchas(self, node: "MatchAs") -> str:
+        """Return an astroid.MatchAs node as string."""
+        # pylint: disable=import-outside-toplevel
+        # Prevent circular dependency
+        from astroid.nodes.node_classes import MatchClass, MatchMapping, MatchSequence
+
+        if isinstance(node.parent, (MatchSequence, MatchMapping, MatchClass)):
+            return node.name.accept(self) if node.name else "_"
+        return (
+            f"{node.pattern.accept(self) if node.pattern else '_'}"
+            f"{f' as {node.name.accept(self)}' if node.name else ''}"
+        )
+
+    def visit_matchor(self, node: "MatchOr") -> str:
+        """Return an astroid.MatchOr node as string."""
+        if node.patterns is None:
+            raise Exception(f"{node} does not have pattern nodes")
+        return " | ".join(p.accept(self) for p in node.patterns)
+
+    # These aren't for real AST nodes, but for inference objects.
+
+    def visit_frozenset(self, node):
+        return node.parent.accept(self)
+
+    def visit_super(self, node):
+        return node.parent.accept(self)
+
+    def visit_uninferable(self, node):
+        return str(node)
+
+    def visit_property(self, node):
+        return node.function.accept(self)
+
+    def visit_evaluatedobject(self, node):
+        return node.original.accept(self)
+
+    def visit_unknown(self, node: "Unknown") -> str:
+        return str(node)
+
+
+def _import_string(names):
+    """return a list of (name, asname) formatted as a string"""
+    _names = []
+    for name, asname in names:
+        if asname is not None:
+            _names.append(f"{name} as {asname}")
+        else:
+            _names.append(name)
+    return ", ".join(_names)
+
+
+# This sets the default indent to 4 spaces.
+to_code = AsStringVisitor("    ")
diff --git a/myenv/lib/python3.9/site-packages/astroid/nodes/const.py b/myenv/lib/python3.9/site-packages/astroid/nodes/const.py
new file mode 100644
index 0000000..6782cc3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/nodes/const.py
@@ -0,0 +1,27 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+OP_PRECEDENCE = {
+    op: precedence
+    for precedence, ops in enumerate(
+        [
+            ["Lambda"],  # lambda x: x + 1
+            ["IfExp"],  # 1 if True else 2
+            ["or"],
+            ["and"],
+            ["not"],
+            ["Compare"],  # in, not in, is, is not, <, <=, >, >=, !=, ==
+            ["|"],
+            ["^"],
+            ["&"],
+            ["<<", ">>"],
+            ["+", "-"],
+            ["*", "@", "/", "//", "%"],
+            ["UnaryOp"],  # +, -, ~
+            ["**"],
+            ["Await"],
+        ]
+    )
+    for op in ops
+}
diff --git a/myenv/lib/python3.9/site-packages/astroid/nodes/node_classes.py b/myenv/lib/python3.9/site-packages/astroid/nodes/node_classes.py
new file mode 100644
index 0000000..c941690
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/nodes/node_classes.py
@@ -0,0 +1,5443 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Module for some node classes. More nodes in scoped_nodes.py"""
+
+import abc
+import itertools
+import sys
+import typing
+import warnings
+from functools import lru_cache
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Generator,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+)
+
+from astroid import decorators, mixins, util
+from astroid.bases import Instance, _infer_stmts
+from astroid.const import Context
+from astroid.context import InferenceContext
+from astroid.exceptions import (
+    AstroidIndexError,
+    AstroidTypeError,
+    InferenceError,
+    NoDefault,
+    ParentMissingError,
+)
+from astroid.manager import AstroidManager
+from astroid.nodes.const import OP_PRECEDENCE
+from astroid.nodes.node_ng import NodeNG
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+if TYPE_CHECKING:
+    from astroid import nodes
+    from astroid.nodes import LocalsDictNodeNG
+
+if sys.version_info >= (3, 8) or TYPE_CHECKING:
+    # pylint: disable-next=ungrouped-imports
+    from functools import cached_property
+else:
+    from astroid.decorators import cachedproperty as cached_property
+
+
+def _is_const(value):
+    return isinstance(value, tuple(CONST_CLS))
+
+
+T_Nodes = TypeVar("T_Nodes", bound=NodeNG)
+
+AssignedStmtsPossibleNode = Union["List", "Tuple", "AssignName", "AssignAttr", None]
+AssignedStmtsCall = Callable[
+    [
+        T_Nodes,
+        AssignedStmtsPossibleNode,
+        Optional[InferenceContext],
+        Optional[typing.List[int]],
+    ],
+    Any,
+]
+
+
+@decorators.raise_if_nothing_inferred
+def unpack_infer(stmt, context=None):
+    """recursively generate nodes inferred by the given statement.
+    If the inferred value is a list or a tuple, recurse on the elements
+    """
+    if isinstance(stmt, (List, Tuple)):
+        for elt in stmt.elts:
+            if elt is util.Uninferable:
+                yield elt
+                continue
+            yield from unpack_infer(elt, context)
+        return dict(node=stmt, context=context)
+    # if inferred is a final node, return it and stop
+    inferred = next(stmt.infer(context), util.Uninferable)
+    if inferred is stmt:
+        yield inferred
+        return dict(node=stmt, context=context)
+    # else, infer recursively, except Uninferable object that should be returned as is
+    for inferred in stmt.infer(context):
+        if inferred is util.Uninferable:
+            yield inferred
+        else:
+            yield from unpack_infer(inferred, context)
+
+    return dict(node=stmt, context=context)
+
+
+def are_exclusive(stmt1, stmt2, exceptions: Optional[typing.List[str]] = None) -> bool:
+    """return true if the two given statements are mutually exclusive
+
+    `exceptions` may be a list of exception names. If specified, discard If
+    branches and check one of the statement is in an exception handler catching
+    one of the given exceptions.
+
+    algorithm :
+     1) index stmt1's parents
+     2) climb among stmt2's parents until we find a common parent
+     3) if the common parent is a If or TryExcept statement, look if nodes are
+        in exclusive branches
+    """
+    # index stmt1's parents
+    stmt1_parents = {}
+    children = {}
+    previous = stmt1
+    for node in stmt1.node_ancestors():
+        stmt1_parents[node] = 1
+        children[node] = previous
+        previous = node
+    # climb among stmt2's parents until we find a common parent
+    previous = stmt2
+    for node in stmt2.node_ancestors():
+        if node in stmt1_parents:
+            # if the common parent is a If or TryExcept statement, look if
+            # nodes are in exclusive branches
+            if isinstance(node, If) and exceptions is None:
+                if (
+                    node.locate_child(previous)[1]
+                    is not node.locate_child(children[node])[1]
+                ):
+                    return True
+            elif isinstance(node, TryExcept):
+                c2attr, c2node = node.locate_child(previous)
+                c1attr, c1node = node.locate_child(children[node])
+                if c1node is not c2node:
+                    first_in_body_caught_by_handlers = (
+                        c2attr == "handlers"
+                        and c1attr == "body"
+                        and previous.catch(exceptions)
+                    )
+                    second_in_body_caught_by_handlers = (
+                        c2attr == "body"
+                        and c1attr == "handlers"
+                        and children[node].catch(exceptions)
+                    )
+                    first_in_else_other_in_handlers = (
+                        c2attr == "handlers" and c1attr == "orelse"
+                    )
+                    second_in_else_other_in_handlers = (
+                        c2attr == "orelse" and c1attr == "handlers"
+                    )
+                    if any(
+                        (
+                            first_in_body_caught_by_handlers,
+                            second_in_body_caught_by_handlers,
+                            first_in_else_other_in_handlers,
+                            second_in_else_other_in_handlers,
+                        )
+                    ):
+                        return True
+                elif c2attr == "handlers" and c1attr == "handlers":
+                    return previous is not children[node]
+            return False
+        previous = node
+    return False
+
+
+# getitem() helpers.
+
+_SLICE_SENTINEL = object()
+
+
+def _slice_value(index, context=None):
+    """Get the value of the given slice index."""
+
+    if isinstance(index, Const):
+        if isinstance(index.value, (int, type(None))):
+            return index.value
+    elif index is None:
+        return None
+    else:
+        # Try to infer what the index actually is.
+        # Since we can't return all the possible values,
+        # we'll stop at the first possible value.
+        try:
+            inferred = next(index.infer(context=context))
+        except (InferenceError, StopIteration):
+            pass
+        else:
+            if isinstance(inferred, Const):
+                if isinstance(inferred.value, (int, type(None))):
+                    return inferred.value
+
+    # Use a sentinel, because None can be a valid
+    # value that this function can return,
+    # as it is the case for unspecified bounds.
+    return _SLICE_SENTINEL
+
+
+def _infer_slice(node, context=None):
+    lower = _slice_value(node.lower, context)
+    upper = _slice_value(node.upper, context)
+    step = _slice_value(node.step, context)
+    if all(elem is not _SLICE_SENTINEL for elem in (lower, upper, step)):
+        return slice(lower, upper, step)
+
+    raise AstroidTypeError(
+        message="Could not infer slice used in subscript",
+        node=node,
+        index=node.parent,
+        context=context,
+    )
+
+
+def _container_getitem(instance, elts, index, context=None):
+    """Get a slice or an item, using the given *index*, for the given sequence."""
+    try:
+        if isinstance(index, Slice):
+            index_slice = _infer_slice(index, context=context)
+            new_cls = instance.__class__()
+            new_cls.elts = elts[index_slice]
+            new_cls.parent = instance.parent
+            return new_cls
+        if isinstance(index, Const):
+            return elts[index.value]
+    except IndexError as exc:
+        raise AstroidIndexError(
+            message="Index {index!s} out of range",
+            node=instance,
+            index=index,
+            context=context,
+        ) from exc
+    except TypeError as exc:
+        raise AstroidTypeError(
+            message="Type error {error!r}", node=instance, index=index, context=context
+        ) from exc
+
+    raise AstroidTypeError(f"Could not use {index} as subscript index")
+
+
+class Statement(NodeNG):
+    """Statement node adding a few attributes"""
+
+    is_statement = True
+    """Whether this node indicates a statement."""
+
+    def next_sibling(self):
+        """The next sibling statement node.
+
+        :returns: The next sibling statement node.
+        :rtype: NodeNG or None
+        """
+        stmts = self.parent.child_sequence(self)
+        index = stmts.index(self)
+        try:
+            return stmts[index + 1]
+        except IndexError:
+            return None
+
+    def previous_sibling(self):
+        """The previous sibling statement.
+
+        :returns: The previous sibling statement node.
+        :rtype: NodeNG or None
+        """
+        stmts = self.parent.child_sequence(self)
+        index = stmts.index(self)
+        if index >= 1:
+            return stmts[index - 1]
+        return None
+
+
+class BaseContainer(
+    mixins.ParentAssignTypeMixin, NodeNG, Instance, metaclass=abc.ABCMeta
+):
+    """Base class for Set, FrozenSet, Tuple and List."""
+
+    _astroid_fields = ("elts",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.elts: typing.List[NodeNG] = []
+        """The elements in the node."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, elts: typing.List[NodeNG]) -> None:
+        """Do some setup after initialisation.
+
+        :param elts: The list of elements the that node contains.
+        """
+        self.elts = elts
+
+    @classmethod
+    def from_elements(cls, elts=None):
+        """Create a node of this type from the given list of elements.
+
+        :param elts: The list of elements that the node should contain.
+        :type elts: list(NodeNG)
+
+        :returns: A new node containing the given elements.
+        :rtype: NodeNG
+        """
+        node = cls()
+        if elts is None:
+            node.elts = []
+        else:
+            node.elts = [const_factory(e) if _is_const(e) else e for e in elts]
+        return node
+
+    def itered(self):
+        """An iterator over the elements this node contains.
+
+        :returns: The contents of this node.
+        :rtype: iterable(NodeNG)
+        """
+        return self.elts
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        :returns: The boolean value of this node.
+        :rtype: bool or Uninferable
+        """
+        return bool(self.elts)
+
+    @abc.abstractmethod
+    def pytype(self):
+        """Get the name of the type that this node represents.
+
+        :returns: The name of the type.
+        :rtype: str
+        """
+
+    def get_children(self):
+        yield from self.elts
+
+
+class LookupMixIn:
+    """Mixin to look up a name in the right scope."""
+
+    @lru_cache(maxsize=None)  # pylint: disable=cache-max-size-none  # noqa
+    def lookup(self, name: str) -> typing.Tuple[str, typing.List[NodeNG]]:
+        """Lookup where the given variable is assigned.
+
+        The lookup starts from self's scope. If self is not a frame itself
+        and the name is found in the inner frame locals, statements will be
+        filtered to remove ignorable statements according to self's location.
+
+        :param name: The name of the variable to find assignments for.
+
+        :returns: The scope node and the list of assignments associated to the
+            given name according to the scope where it has been found (locals,
+            globals or builtin).
+        """
+        return self.scope().scope_lookup(self, name)
+
+    def ilookup(self, name):
+        """Lookup the inferred values of the given variable.
+
+        :param name: The variable name to find values for.
+        :type name: str
+
+        :returns: The inferred values of the statements returned from
+            :meth:`lookup`.
+        :rtype: iterable
+        """
+        frame, stmts = self.lookup(name)
+        context = InferenceContext()
+        return _infer_stmts(stmts, context, frame)
+
+
+# Name classes
+
+
+class AssignName(
+    mixins.NoChildrenMixin, LookupMixIn, mixins.ParentAssignTypeMixin, NodeNG
+):
+    """Variation of :class:`ast.Assign` representing assignment to a name.
+
+    An :class:`AssignName` is the name of something that is assigned to.
+    This includes variables defined in a function signature or in a loop.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('variable = range(10)')
+    >>> node
+    <Assign l.1 at 0x7effe1db8550>
+    >>> list(node.get_children())
+    [<AssignName.variable l.1 at 0x7effe1db8748>, <Call l.1 at 0x7effe1db8630>]
+    >>> list(node.get_children())[0].as_string()
+    'variable'
+    """
+
+    _other_fields = ("name",)
+
+    @decorators.deprecate_default_argument_values(name="str")
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param name: The name that is assigned to.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.name: Optional[str] = name
+        """The name that is assigned to."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["AssignName"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+
+class DelName(
+    mixins.NoChildrenMixin, LookupMixIn, mixins.ParentAssignTypeMixin, NodeNG
+):
+    """Variation of :class:`ast.Delete` representing deletion of a name.
+
+    A :class:`DelName` is the name of something that is deleted.
+
+    >>> import astroid
+    >>> node = astroid.extract_node("del variable #@")
+    >>> list(node.get_children())
+    [<DelName.variable l.1 at 0x7effe1da4d30>]
+    >>> list(node.get_children())[0].as_string()
+    'variable'
+    """
+
+    _other_fields = ("name",)
+
+    @decorators.deprecate_default_argument_values(name="str")
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param name: The name that is being deleted.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.name: Optional[str] = name
+        """The name that is being deleted."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+
+class Name(mixins.NoChildrenMixin, LookupMixIn, NodeNG):
+    """Class representing an :class:`ast.Name` node.
+
+    A :class:`Name` node is something that is named, but not covered by
+    :class:`AssignName` or :class:`DelName`.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('range(10)')
+    >>> node
+    <Call l.1 at 0x7effe1db8710>
+    >>> list(node.get_children())
+    [<Name.range l.1 at 0x7effe1db86a0>, <Const.int l.1 at 0x7effe1db8518>]
+    >>> list(node.get_children())[0].as_string()
+    'range'
+    """
+
+    _other_fields = ("name",)
+
+    @decorators.deprecate_default_argument_values(name="str")
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param name: The name that this node refers to.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.name: Optional[str] = name
+        """The name that this node refers to."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def _get_name_nodes(self):
+        yield self
+
+        for child_node in self.get_children():
+            yield from child_node._get_name_nodes()
+
+
+class Arguments(mixins.AssignTypeMixin, NodeNG):
+    """Class representing an :class:`ast.arguments` node.
+
+    An :class:`Arguments` node represents that arguments in a
+    function definition.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('def foo(bar): pass')
+    >>> node
+    <FunctionDef.foo l.1 at 0x7effe1db8198>
+    >>> node.args
+    <Arguments l.1 at 0x7effe1db82e8>
+    """
+
+    # Python 3.4+ uses a different approach regarding annotations,
+    # each argument is a new class, _ast.arg, which exposes an
+    # 'annotation' attribute. In astroid though, arguments are exposed
+    # as is in the Arguments node and the only way to expose annotations
+    # is by using something similar with Python 3.3:
+    #  - we expose 'varargannotation' and 'kwargannotation' of annotations
+    #    of varargs and kwargs.
+    #  - we expose 'annotation', a list with annotations for
+    #    for each normal argument. If an argument doesn't have an
+    #    annotation, its value will be None.
+    _astroid_fields = (
+        "args",
+        "defaults",
+        "kwonlyargs",
+        "posonlyargs",
+        "posonlyargs_annotations",
+        "kw_defaults",
+        "annotations",
+        "varargannotation",
+        "kwargannotation",
+        "kwonlyargs_annotations",
+        "type_comment_args",
+        "type_comment_kwonlyargs",
+        "type_comment_posonlyargs",
+    )
+
+    _other_fields = ("vararg", "kwarg")
+
+    lineno: None
+    col_offset: None
+    end_lineno: None
+    end_col_offset: None
+
+    def __init__(
+        self,
+        vararg: Optional[str] = None,
+        kwarg: Optional[str] = None,
+        parent: Optional[NodeNG] = None,
+    ) -> None:
+        """
+        :param vararg: The name of the variable length arguments.
+
+        :param kwarg: The name of the variable length keyword arguments.
+
+        :param parent: The parent node in the syntax tree.
+        """
+        super().__init__(parent=parent)
+
+        self.vararg: Optional[str] = vararg  # can be None
+        """The name of the variable length arguments."""
+
+        self.kwarg: Optional[str] = kwarg  # can be None
+        """The name of the variable length keyword arguments."""
+
+        self.args: Optional[typing.List[AssignName]]
+        """The names of the required arguments.
+
+        Can be None if the associated function does not have a retrievable
+        signature and the arguments are therefore unknown.
+        This happens with builtin functions implemented in C.
+        """
+
+        self.defaults: typing.List[NodeNG]
+        """The default values for arguments that can be passed positionally."""
+
+        self.kwonlyargs: typing.List[AssignName]
+        """The keyword arguments that cannot be passed positionally."""
+
+        self.posonlyargs: typing.List[AssignName] = []
+        """The arguments that can only be passed positionally."""
+
+        self.kw_defaults: typing.List[Optional[NodeNG]]
+        """The default values for keyword arguments that cannot be passed positionally."""
+
+        self.annotations: typing.List[Optional[NodeNG]]
+        """The type annotations of arguments that can be passed positionally."""
+
+        self.posonlyargs_annotations: typing.List[Optional[NodeNG]] = []
+        """The type annotations of arguments that can only be passed positionally."""
+
+        self.kwonlyargs_annotations: typing.List[Optional[NodeNG]] = []
+        """The type annotations of arguments that cannot be passed positionally."""
+
+        self.type_comment_args: typing.List[Optional[NodeNG]] = []
+        """The type annotation, passed by a type comment, of each argument.
+
+        If an argument does not have a type comment,
+        the value for that argument will be None.
+        """
+
+        self.type_comment_kwonlyargs: typing.List[Optional[NodeNG]] = []
+        """The type annotation, passed by a type comment, of each keyword only argument.
+
+        If an argument does not have a type comment,
+        the value for that argument will be None.
+        """
+
+        self.type_comment_posonlyargs: typing.List[Optional[NodeNG]] = []
+        """The type annotation, passed by a type comment, of each positional argument.
+
+        If an argument does not have a type comment,
+        the value for that argument will be None.
+        """
+
+        self.varargannotation: Optional[NodeNG] = None  # can be None
+        """The type annotation for the variable length arguments."""
+
+        self.kwargannotation: Optional[NodeNG] = None  # can be None
+        """The type annotation for the variable length keyword arguments."""
+
+    # pylint: disable=too-many-arguments
+    def postinit(
+        self,
+        args: typing.List[AssignName],
+        defaults: typing.List[NodeNG],
+        kwonlyargs: typing.List[AssignName],
+        kw_defaults: typing.List[Optional[NodeNG]],
+        annotations: typing.List[Optional[NodeNG]],
+        posonlyargs: Optional[typing.List[AssignName]] = None,
+        kwonlyargs_annotations: Optional[typing.List[Optional[NodeNG]]] = None,
+        posonlyargs_annotations: Optional[typing.List[Optional[NodeNG]]] = None,
+        varargannotation: Optional[NodeNG] = None,
+        kwargannotation: Optional[NodeNG] = None,
+        type_comment_args: Optional[typing.List[Optional[NodeNG]]] = None,
+        type_comment_kwonlyargs: Optional[typing.List[Optional[NodeNG]]] = None,
+        type_comment_posonlyargs: Optional[typing.List[Optional[NodeNG]]] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param args: The names of the required arguments.
+
+        :param defaults: The default values for arguments that can be passed
+            positionally.
+
+        :param kwonlyargs: The keyword arguments that cannot be passed
+            positionally.
+
+        :param posonlyargs: The arguments that can only be passed
+            positionally.
+
+        :param kw_defaults: The default values for keyword arguments that
+            cannot be passed positionally.
+
+        :param annotations: The type annotations of arguments that can be
+            passed positionally.
+
+        :param kwonlyargs_annotations: The type annotations of arguments that
+            cannot be passed positionally. This should always be passed in
+            Python 3.
+
+        :param posonlyargs_annotations: The type annotations of arguments that
+            can only be passed positionally. This should always be passed in
+            Python 3.
+
+        :param varargannotation: The type annotation for the variable length
+            arguments.
+
+        :param kwargannotation: The type annotation for the variable length
+            keyword arguments.
+
+        :param type_comment_args: The type annotation,
+            passed by a type comment, of each argument.
+
+        :param type_comment_args: The type annotation,
+            passed by a type comment, of each keyword only argument.
+
+        :param type_comment_args: The type annotation,
+            passed by a type comment, of each positional argument.
+        """
+        self.args = args
+        self.defaults = defaults
+        self.kwonlyargs = kwonlyargs
+        if posonlyargs is not None:
+            self.posonlyargs = posonlyargs
+        self.kw_defaults = kw_defaults
+        self.annotations = annotations
+        if kwonlyargs_annotations is not None:
+            self.kwonlyargs_annotations = kwonlyargs_annotations
+        if posonlyargs_annotations is not None:
+            self.posonlyargs_annotations = posonlyargs_annotations
+        self.varargannotation = varargannotation
+        self.kwargannotation = kwargannotation
+        if type_comment_args is not None:
+            self.type_comment_args = type_comment_args
+        if type_comment_kwonlyargs is not None:
+            self.type_comment_kwonlyargs = type_comment_kwonlyargs
+        if type_comment_posonlyargs is not None:
+            self.type_comment_posonlyargs = type_comment_posonlyargs
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["Arguments"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    def _infer_name(self, frame, name):
+        if self.parent is frame:
+            return name
+        return None
+
+    @cached_property
+    def fromlineno(self):
+        """The first line that this node appears on in the source code.
+
+        :type: int or None
+        """
+        lineno = super().fromlineno
+        return max(lineno, self.parent.fromlineno or 0)
+
+    @cached_property
+    def arguments(self):
+        """Get all the arguments for this node, including positional only and positional and keyword"""
+        return list(itertools.chain((self.posonlyargs or ()), self.args or ()))
+
+    def format_args(self):
+        """Get the arguments formatted as string.
+
+        :returns: The formatted arguments.
+        :rtype: str
+        """
+        result = []
+        positional_only_defaults = []
+        positional_or_keyword_defaults = self.defaults
+        if self.defaults:
+            args = self.args or []
+            positional_or_keyword_defaults = self.defaults[-len(args) :]
+            positional_only_defaults = self.defaults[: len(self.defaults) - len(args)]
+
+        if self.posonlyargs:
+            result.append(
+                _format_args(
+                    self.posonlyargs,
+                    positional_only_defaults,
+                    self.posonlyargs_annotations,
+                )
+            )
+            result.append("/")
+        if self.args:
+            result.append(
+                _format_args(
+                    self.args,
+                    positional_or_keyword_defaults,
+                    getattr(self, "annotations", None),
+                )
+            )
+        if self.vararg:
+            result.append(f"*{self.vararg}")
+        if self.kwonlyargs:
+            if not self.vararg:
+                result.append("*")
+            result.append(
+                _format_args(
+                    self.kwonlyargs, self.kw_defaults, self.kwonlyargs_annotations
+                )
+            )
+        if self.kwarg:
+            result.append(f"**{self.kwarg}")
+        return ", ".join(result)
+
+    def default_value(self, argname):
+        """Get the default value for an argument.
+
+        :param argname: The name of the argument to get the default value for.
+        :type argname: str
+
+        :raises NoDefault: If there is no default value defined for the
+            given argument.
+        """
+        args = self.arguments
+        index = _find_arg(argname, args)[0]
+        if index is not None:
+            idx = index - (len(args) - len(self.defaults))
+            if idx >= 0:
+                return self.defaults[idx]
+        index = _find_arg(argname, self.kwonlyargs)[0]
+        if index is not None and self.kw_defaults[index] is not None:
+            return self.kw_defaults[index]
+        raise NoDefault(func=self.parent, name=argname)
+
+    def is_argument(self, name):
+        """Check if the given name is defined in the arguments.
+
+        :param name: The name to check for.
+        :type name: str
+
+        :returns: True if the given name is defined in the arguments,
+            False otherwise.
+        :rtype: bool
+        """
+        if name == self.vararg:
+            return True
+        if name == self.kwarg:
+            return True
+        return (
+            self.find_argname(name, rec=True)[1] is not None
+            or self.kwonlyargs
+            and _find_arg(name, self.kwonlyargs, rec=True)[1] is not None
+        )
+
+    def find_argname(self, argname, rec=False):
+        """Get the index and :class:`AssignName` node for given name.
+
+        :param argname: The name of the argument to search for.
+        :type argname: str
+
+        :param rec: Whether or not to include arguments in unpacked tuples
+            in the search.
+        :type rec: bool
+
+        :returns: The index and node for the argument.
+        :rtype: tuple(str or None, AssignName or None)
+        """
+        if self.arguments:
+            return _find_arg(argname, self.arguments, rec)
+        return None, None
+
+    def get_children(self):
+        yield from self.posonlyargs or ()
+
+        for elt in self.posonlyargs_annotations:
+            if elt is not None:
+                yield elt
+
+        yield from self.args or ()
+
+        yield from self.defaults
+        yield from self.kwonlyargs
+
+        for elt in self.kw_defaults:
+            if elt is not None:
+                yield elt
+
+        for elt in self.annotations:
+            if elt is not None:
+                yield elt
+
+        if self.varargannotation is not None:
+            yield self.varargannotation
+
+        if self.kwargannotation is not None:
+            yield self.kwargannotation
+
+        for elt in self.kwonlyargs_annotations:
+            if elt is not None:
+                yield elt
+
+
+def _find_arg(argname, args, rec=False):
+    for i, arg in enumerate(args):
+        if isinstance(arg, Tuple):
+            if rec:
+                found = _find_arg(argname, arg.elts)
+                if found[0] is not None:
+                    return found
+        elif arg.name == argname:
+            return i, arg
+    return None, None
+
+
+def _format_args(args, defaults=None, annotations=None):
+    values = []
+    if args is None:
+        return ""
+    if annotations is None:
+        annotations = []
+    if defaults is not None:
+        default_offset = len(args) - len(defaults)
+    packed = itertools.zip_longest(args, annotations)
+    for i, (arg, annotation) in enumerate(packed):
+        if isinstance(arg, Tuple):
+            values.append(f"({_format_args(arg.elts)})")
+        else:
+            argname = arg.name
+            default_sep = "="
+            if annotation is not None:
+                argname += ": " + annotation.as_string()
+                default_sep = " = "
+            values.append(argname)
+
+            if defaults is not None and i >= default_offset:
+                if defaults[i - default_offset] is not None:
+                    values[-1] += default_sep + defaults[i - default_offset].as_string()
+    return ", ".join(values)
+
+
+class AssignAttr(mixins.ParentAssignTypeMixin, NodeNG):
+    """Variation of :class:`ast.Assign` representing assignment to an attribute.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('self.attribute = range(10)')
+    >>> node
+    <Assign l.1 at 0x7effe1d521d0>
+    >>> list(node.get_children())
+    [<AssignAttr.attribute l.1 at 0x7effe1d52320>, <Call l.1 at 0x7effe1d522e8>]
+    >>> list(node.get_children())[0].as_string()
+    'self.attribute'
+    """
+
+    _astroid_fields = ("expr",)
+    _other_fields = ("attrname",)
+
+    @decorators.deprecate_default_argument_values(attrname="str")
+    def __init__(
+        self,
+        attrname: Optional[str] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param attrname: The name of the attribute being assigned to.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.expr: Optional[NodeNG] = None
+        """What has the attribute that is being assigned to."""
+
+        self.attrname: Optional[str] = attrname
+        """The name of the attribute being assigned to."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, expr: Optional[NodeNG] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param expr: What has the attribute that is being assigned to.
+        """
+        self.expr = expr
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["AssignAttr"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    def get_children(self):
+        yield self.expr
+
+
+class Assert(Statement):
+    """Class representing an :class:`ast.Assert` node.
+
+    An :class:`Assert` node represents an assert statement.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('assert len(things) == 10, "Not enough things"')
+    >>> node
+    <Assert l.1 at 0x7effe1d527b8>
+    """
+
+    _astroid_fields = ("test", "fail")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.test: Optional[NodeNG] = None
+        """The test that passes or fails the assertion."""
+
+        self.fail: Optional[NodeNG] = None  # can be None
+        """The message shown when the assertion fails."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self, test: Optional[NodeNG] = None, fail: Optional[NodeNG] = None
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param test: The test that passes or fails the assertion.
+
+        :param fail: The message shown when the assertion fails.
+        """
+        self.fail = fail
+        self.test = test
+
+    def get_children(self):
+        yield self.test
+
+        if self.fail is not None:
+            yield self.fail
+
+
+class Assign(mixins.AssignTypeMixin, Statement):
+    """Class representing an :class:`ast.Assign` node.
+
+    An :class:`Assign` is a statement where something is explicitly
+    asssigned to.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('variable = range(10)')
+    >>> node
+    <Assign l.1 at 0x7effe1db8550>
+    """
+
+    _astroid_fields = ("targets", "value")
+    _other_other_fields = ("type_annotation",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.targets: typing.List[NodeNG] = []
+        """What is being assigned to."""
+
+        self.value: Optional[NodeNG] = None
+        """The value being assigned to the variables."""
+
+        self.type_annotation: Optional[NodeNG] = None  # can be None
+        """If present, this will contain the type annotation passed by a type comment"""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        targets: Optional[typing.List[NodeNG]] = None,
+        value: Optional[NodeNG] = None,
+        type_annotation: Optional[NodeNG] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param targets: What is being assigned to.
+        :param value: The value being assigned to the variables.
+        :param type_annotation:
+        """
+        if targets is not None:
+            self.targets = targets
+        self.value = value
+        self.type_annotation = type_annotation
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["Assign"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    def get_children(self):
+        yield from self.targets
+
+        yield self.value
+
+    @decorators.cached
+    def _get_assign_nodes(self):
+        return [self] + list(self.value._get_assign_nodes())
+
+    def _get_yield_nodes_skip_lambdas(self):
+        yield from self.value._get_yield_nodes_skip_lambdas()
+
+
+class AnnAssign(mixins.AssignTypeMixin, Statement):
+    """Class representing an :class:`ast.AnnAssign` node.
+
+    An :class:`AnnAssign` is an assignment with a type annotation.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('variable: List[int] = range(10)')
+    >>> node
+    <AnnAssign l.1 at 0x7effe1d4c630>
+    """
+
+    _astroid_fields = ("target", "annotation", "value")
+    _other_fields = ("simple",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.target: Optional[NodeNG] = None
+        """What is being assigned to."""
+
+        self.annotation: Optional[NodeNG] = None
+        """The type annotation of what is being assigned to."""
+
+        self.value: Optional[NodeNG] = None  # can be None
+        """The value being assigned to the variables."""
+
+        self.simple: Optional[int] = None
+        """Whether :attr:`target` is a pure name or a complex statement."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        target: NodeNG,
+        annotation: NodeNG,
+        simple: int,
+        value: Optional[NodeNG] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param target: What is being assigned to.
+
+        :param annotation: The type annotation of what is being assigned to.
+
+        :param simple: Whether :attr:`target` is a pure name
+            or a complex statement.
+
+        :param value: The value being assigned to the variables.
+        """
+        self.target = target
+        self.annotation = annotation
+        self.value = value
+        self.simple = simple
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["AnnAssign"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    def get_children(self):
+        yield self.target
+        yield self.annotation
+
+        if self.value is not None:
+            yield self.value
+
+
+class AugAssign(mixins.AssignTypeMixin, Statement):
+    """Class representing an :class:`ast.AugAssign` node.
+
+    An :class:`AugAssign` is an assignment paired with an operator.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('variable += 1')
+    >>> node
+    <AugAssign l.1 at 0x7effe1db4d68>
+    """
+
+    _astroid_fields = ("target", "value")
+    _other_fields = ("op",)
+
+    @decorators.deprecate_default_argument_values(op="str")
+    def __init__(
+        self,
+        op: Optional[str] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param op: The operator that is being combined with the assignment.
+            This includes the equals sign.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.target: Optional[NodeNG] = None
+        """What is being assigned to."""
+
+        self.op: Optional[str] = op
+        """The operator that is being combined with the assignment.
+
+        This includes the equals sign.
+        """
+
+        self.value: Optional[NodeNG] = None
+        """The value being assigned to the variable."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self, target: Optional[NodeNG] = None, value: Optional[NodeNG] = None
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param target: What is being assigned to.
+
+        :param value: The value being assigned to the variable.
+        """
+        self.target = target
+        self.value = value
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["AugAssign"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    # This is set by inference.py
+    def _infer_augassign(self, context=None):
+        raise NotImplementedError
+
+    def type_errors(self, context=None):
+        """Get a list of type errors which can occur during inference.
+
+        Each TypeError is represented by a :class:`BadBinaryOperationMessage` ,
+        which holds the original exception.
+
+        :returns: The list of possible type errors.
+        :rtype: list(BadBinaryOperationMessage)
+        """
+        try:
+            results = self._infer_augassign(context=context)
+            return [
+                result
+                for result in results
+                if isinstance(result, util.BadBinaryOperationMessage)
+            ]
+        except InferenceError:
+            return []
+
+    def get_children(self):
+        yield self.target
+        yield self.value
+
+    def _get_yield_nodes_skip_lambdas(self):
+        """An AugAssign node can contain a Yield node in the value"""
+        yield from self.value._get_yield_nodes_skip_lambdas()
+        yield from super()._get_yield_nodes_skip_lambdas()
+
+
+class BinOp(NodeNG):
+    """Class representing an :class:`ast.BinOp` node.
+
+    A :class:`BinOp` node is an application of a binary operator.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('a + b')
+    >>> node
+    <BinOp l.1 at 0x7f23b2e8cfd0>
+    """
+
+    _astroid_fields = ("left", "right")
+    _other_fields = ("op",)
+
+    @decorators.deprecate_default_argument_values(op="str")
+    def __init__(
+        self,
+        op: Optional[str] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param op: The operator.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.left: Optional[NodeNG] = None
+        """What is being applied to the operator on the left side."""
+
+        self.op: Optional[str] = op
+        """The operator."""
+
+        self.right: Optional[NodeNG] = None
+        """What is being applied to the operator on the right side."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self, left: Optional[NodeNG] = None, right: Optional[NodeNG] = None
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param left: What is being applied to the operator on the left side.
+
+        :param right: What is being applied to the operator on the right side.
+        """
+        self.left = left
+        self.right = right
+
+    # This is set by inference.py
+    def _infer_binop(self, context=None):
+        raise NotImplementedError
+
+    def type_errors(self, context=None):
+        """Get a list of type errors which can occur during inference.
+
+        Each TypeError is represented by a :class:`BadBinaryOperationMessage`,
+        which holds the original exception.
+
+        :returns: The list of possible type errors.
+        :rtype: list(BadBinaryOperationMessage)
+        """
+        try:
+            results = self._infer_binop(context=context)
+            return [
+                result
+                for result in results
+                if isinstance(result, util.BadBinaryOperationMessage)
+            ]
+        except InferenceError:
+            return []
+
+    def get_children(self):
+        yield self.left
+        yield self.right
+
+    def op_precedence(self):
+        return OP_PRECEDENCE[self.op]
+
+    def op_left_associative(self):
+        # 2**3**4 == 2**(3**4)
+        return self.op != "**"
+
+
+class BoolOp(NodeNG):
+    """Class representing an :class:`ast.BoolOp` node.
+
+    A :class:`BoolOp` is an application of a boolean operator.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('a and b')
+    >>> node
+    <BinOp l.1 at 0x7f23b2e71c50>
+    """
+
+    _astroid_fields = ("values",)
+    _other_fields = ("op",)
+
+    @decorators.deprecate_default_argument_values(op="str")
+    def __init__(
+        self,
+        op: Optional[str] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param op: The operator.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.op: Optional[str] = op
+        """The operator."""
+
+        self.values: typing.List[NodeNG] = []
+        """The values being applied to the operator."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, values: Optional[typing.List[NodeNG]] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param values: The values being applied to the operator.
+        """
+        if values is not None:
+            self.values = values
+
+    def get_children(self):
+        yield from self.values
+
+    def op_precedence(self):
+        return OP_PRECEDENCE[self.op]
+
+
+class Break(mixins.NoChildrenMixin, Statement):
+    """Class representing an :class:`ast.Break` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('break')
+    >>> node
+    <Break l.1 at 0x7f23b2e9e5c0>
+    """
+
+
+class Call(NodeNG):
+    """Class representing an :class:`ast.Call` node.
+
+    A :class:`Call` node is a call to a function, method, etc.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('function()')
+    >>> node
+    <Call l.1 at 0x7f23b2e71eb8>
+    """
+
+    _astroid_fields = ("func", "args", "keywords")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.func: Optional[NodeNG] = None
+        """What is being called."""
+
+        self.args: typing.List[NodeNG] = []
+        """The positional arguments being given to the call."""
+
+        self.keywords: typing.List["Keyword"] = []
+        """The keyword arguments being given to the call."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        func: Optional[NodeNG] = None,
+        args: Optional[typing.List[NodeNG]] = None,
+        keywords: Optional[typing.List["Keyword"]] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param func: What is being called.
+
+        :param args: The positional arguments being given to the call.
+
+        :param keywords: The keyword arguments being given to the call.
+        """
+        self.func = func
+        if args is not None:
+            self.args = args
+        if keywords is not None:
+            self.keywords = keywords
+
+    @property
+    def starargs(self) -> typing.List["Starred"]:
+        """The positional arguments that unpack something."""
+        return [arg for arg in self.args if isinstance(arg, Starred)]
+
+    @property
+    def kwargs(self) -> typing.List["Keyword"]:
+        """The keyword arguments that unpack something."""
+        return [keyword for keyword in self.keywords if keyword.arg is None]
+
+    def get_children(self):
+        yield self.func
+
+        yield from self.args
+
+        yield from self.keywords
+
+
+class Compare(NodeNG):
+    """Class representing an :class:`ast.Compare` node.
+
+    A :class:`Compare` node indicates a comparison.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('a <= b <= c')
+    >>> node
+    <Compare l.1 at 0x7f23b2e9e6d8>
+    >>> node.ops
+    [('<=', <Name.b l.1 at 0x7f23b2e9e2b0>), ('<=', <Name.c l.1 at 0x7f23b2e9e390>)]
+    """
+
+    _astroid_fields = ("left", "ops")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.left: Optional[NodeNG] = None
+        """The value at the left being applied to a comparison operator."""
+
+        self.ops: typing.List[typing.Tuple[str, NodeNG]] = []
+        """The remainder of the operators and their relevant right hand value."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        left: Optional[NodeNG] = None,
+        ops: Optional[typing.List[typing.Tuple[str, NodeNG]]] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param left: The value at the left being applied to a comparison
+            operator.
+
+        :param ops: The remainder of the operators
+            and their relevant right hand value.
+        """
+        self.left = left
+        if ops is not None:
+            self.ops = ops
+
+    def get_children(self):
+        """Get the child nodes below this node.
+
+        Overridden to handle the tuple fields and skip returning the operator
+        strings.
+
+        :returns: The children.
+        :rtype: iterable(NodeNG)
+        """
+        yield self.left
+        for _, comparator in self.ops:
+            yield comparator  # we don't want the 'op'
+
+    def last_child(self):
+        """An optimized version of list(get_children())[-1]
+
+        :returns: The last child.
+        :rtype: NodeNG
+        """
+        # XXX maybe if self.ops:
+        return self.ops[-1][1]
+        # return self.left
+
+
+class Comprehension(NodeNG):
+    """Class representing an :class:`ast.comprehension` node.
+
+    A :class:`Comprehension` indicates the loop inside any type of
+    comprehension including generator expressions.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('[x for x in some_values]')
+    >>> list(node.get_children())
+    [<Name.x l.1 at 0x7f23b2e352b0>, <Comprehension l.1 at 0x7f23b2e35320>]
+    >>> list(node.get_children())[1].as_string()
+    'for x in some_values'
+    """
+
+    _astroid_fields = ("target", "iter", "ifs")
+    _other_fields = ("is_async",)
+
+    optional_assign = True
+    """Whether this node optionally assigns a variable."""
+
+    lineno: None
+    col_offset: None
+    end_lineno: None
+    end_col_offset: None
+
+    def __init__(self, parent: Optional[NodeNG] = None) -> None:
+        """
+        :param parent: The parent node in the syntax tree.
+        """
+        self.target: Optional[NodeNG] = None
+        """What is assigned to by the comprehension."""
+
+        self.iter: Optional[NodeNG] = None
+        """What is iterated over by the comprehension."""
+
+        self.ifs: typing.List[NodeNG] = []
+        """The contents of any if statements that filter the comprehension."""
+
+        self.is_async: Optional[bool] = None
+        """Whether this is an asynchronous comprehension or not."""
+
+        super().__init__(parent=parent)
+
+    # pylint: disable=redefined-builtin; same name as builtin ast module.
+    def postinit(
+        self,
+        target: Optional[NodeNG] = None,
+        iter: Optional[NodeNG] = None,
+        ifs: Optional[typing.List[NodeNG]] = None,
+        is_async: Optional[bool] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param target: What is assigned to by the comprehension.
+
+        :param iter: What is iterated over by the comprehension.
+
+        :param ifs: The contents of any if statements that filter
+            the comprehension.
+
+        :param is_async: Whether this is an asynchronous comprehension or not.
+        """
+        self.target = target
+        self.iter = iter
+        if ifs is not None:
+            self.ifs = ifs
+        self.is_async = is_async
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["Comprehension"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    def assign_type(self):
+        """The type of assignment that this node performs.
+
+        :returns: The assignment type.
+        :rtype: NodeNG
+        """
+        return self
+
+    def _get_filtered_stmts(
+        self, lookup_node, node, stmts, mystmt: Optional[Statement]
+    ):
+        """method used in filter_stmts"""
+        if self is mystmt:
+            if isinstance(lookup_node, (Const, Name)):
+                return [lookup_node], True
+
+        elif self.statement(future=True) is mystmt:
+            # original node's statement is the assignment, only keeps
+            # current node (gen exp, list comp)
+
+            return [node], True
+
+        return stmts, False
+
+    def get_children(self):
+        yield self.target
+        yield self.iter
+
+        yield from self.ifs
+
+
+class Const(mixins.NoChildrenMixin, NodeNG, Instance):
+    """Class representing any constant including num, str, bool, None, bytes.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('(5, "This is a string.", True, None, b"bytes")')
+    >>> node
+    <Tuple.tuple l.1 at 0x7f23b2e358d0>
+    >>> list(node.get_children())
+    [<Const.int l.1 at 0x7f23b2e35940>,
+    <Const.str l.1 at 0x7f23b2e35978>,
+    <Const.bool l.1 at 0x7f23b2e359b0>,
+    <Const.NoneType l.1 at 0x7f23b2e359e8>,
+    <Const.bytes l.1 at 0x7f23b2e35a20>]
+    """
+
+    _other_fields = ("value", "kind")
+
+    def __init__(
+        self,
+        value: Any,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        kind: Optional[str] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param value: The value that the constant represents.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param kind: The string prefix. "u" for u-prefixed strings and ``None`` otherwise. Python 3.8+ only.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.value: Any = value
+        """The value that the constant represents."""
+
+        self.kind: Optional[str] = kind  # can be None
+        """"The string prefix. "u" for u-prefixed strings and ``None`` otherwise. Python 3.8+ only."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def __getattr__(self, name):
+        # This is needed because of Proxy's __getattr__ method.
+        # Calling object.__new__ on this class without calling
+        # __init__ would result in an infinite loop otherwise
+        # since __getattr__ is called when an attribute doesn't
+        # exist and self._proxied indirectly calls self.value
+        # and Proxy __getattr__ calls self.value
+        if name == "value":
+            raise AttributeError
+        return super().__getattr__(name)
+
+    def getitem(self, index, context=None):
+        """Get an item from this node if subscriptable.
+
+        :param index: The node to use as a subscript index.
+        :type index: Const or Slice
+
+        :raises AstroidTypeError: When the given index cannot be used as a
+            subscript index, or if this node is not subscriptable.
+        """
+        if isinstance(index, Const):
+            index_value = index.value
+        elif isinstance(index, Slice):
+            index_value = _infer_slice(index, context=context)
+
+        else:
+            raise AstroidTypeError(
+                f"Could not use type {type(index)} as subscript index"
+            )
+
+        try:
+            if isinstance(self.value, (str, bytes)):
+                return Const(self.value[index_value])
+        except IndexError as exc:
+            raise AstroidIndexError(
+                message="Index {index!r} out of range",
+                node=self,
+                index=index,
+                context=context,
+            ) from exc
+        except TypeError as exc:
+            raise AstroidTypeError(
+                message="Type error {error!r}", node=self, index=index, context=context
+            ) from exc
+
+        raise AstroidTypeError(f"{self!r} (value={self.value})")
+
+    def has_dynamic_getattr(self):
+        """Check if the node has a custom __getattr__ or __getattribute__.
+
+        :returns: True if the class has a custom
+            __getattr__ or __getattribute__, False otherwise.
+            For a :class:`Const` this is always ``False``.
+        :rtype: bool
+        """
+        return False
+
+    def itered(self):
+        """An iterator over the elements this node contains.
+
+        :returns: The contents of this node.
+        :rtype: iterable(Const)
+
+        :raises TypeError: If this node does not represent something that is iterable.
+        """
+        if isinstance(self.value, str):
+            return [const_factory(elem) for elem in self.value]
+        raise TypeError(f"Cannot iterate over type {type(self.value)!r}")
+
+    def pytype(self):
+        """Get the name of the type that this node represents.
+
+        :returns: The name of the type.
+        :rtype: str
+        """
+        return self._proxied.qname()
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        :returns: The boolean value of this node.
+        :rtype: bool
+        """
+        return bool(self.value)
+
+
+class Continue(mixins.NoChildrenMixin, Statement):
+    """Class representing an :class:`ast.Continue` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('continue')
+    >>> node
+    <Continue l.1 at 0x7f23b2e35588>
+    """
+
+
+class Decorators(NodeNG):
+    """A node representing a list of decorators.
+
+    A :class:`Decorators` is the decorators that are applied to
+    a method or function.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    @property
+    def my_property(self):
+        return 3
+    ''')
+    >>> node
+    <FunctionDef.my_property l.2 at 0x7f23b2e35d30>
+    >>> list(node.get_children())[0]
+    <Decorators l.1 at 0x7f23b2e35d68>
+    """
+
+    _astroid_fields = ("nodes",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.nodes: typing.List[NodeNG]
+        """The decorators that this node contains.
+
+        :type: list(Name or Call) or None
+        """
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, nodes: typing.List[NodeNG]) -> None:
+        """Do some setup after initialisation.
+
+        :param nodes: The decorators that this node contains.
+        :type nodes: list(Name or Call)
+        """
+        self.nodes = nodes
+
+    def scope(self) -> "LocalsDictNodeNG":
+        """The first parent node defining a new scope.
+        These can be Module, FunctionDef, ClassDef, Lambda, or GeneratorExp nodes.
+
+        :returns: The first parent scope node.
+        """
+        # skip the function node to go directly to the upper level scope
+        if not self.parent:
+            raise ParentMissingError(target=self)
+        if not self.parent.parent:
+            raise ParentMissingError(target=self.parent)
+        return self.parent.parent.scope()
+
+    def get_children(self):
+        yield from self.nodes
+
+
+class DelAttr(mixins.ParentAssignTypeMixin, NodeNG):
+    """Variation of :class:`ast.Delete` representing deletion of an attribute.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('del self.attr')
+    >>> node
+    <Delete l.1 at 0x7f23b2e35f60>
+    >>> list(node.get_children())[0]
+    <DelAttr.attr l.1 at 0x7f23b2e411d0>
+    """
+
+    _astroid_fields = ("expr",)
+    _other_fields = ("attrname",)
+
+    @decorators.deprecate_default_argument_values(attrname="str")
+    def __init__(
+        self,
+        attrname: Optional[str] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param attrname: The name of the attribute that is being deleted.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.expr: Optional[NodeNG] = None
+        """The name that this node represents.
+
+        :type: Name or None
+        """
+
+        self.attrname: Optional[str] = attrname
+        """The name of the attribute that is being deleted."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, expr: Optional[NodeNG] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param expr: The name that this node represents.
+        :type expr: Name or None
+        """
+        self.expr = expr
+
+    def get_children(self):
+        yield self.expr
+
+
+class Delete(mixins.AssignTypeMixin, Statement):
+    """Class representing an :class:`ast.Delete` node.
+
+    A :class:`Delete` is a ``del`` statement this is deleting something.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('del self.attr')
+    >>> node
+    <Delete l.1 at 0x7f23b2e35f60>
+    """
+
+    _astroid_fields = ("targets",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.targets: typing.List[NodeNG] = []
+        """What is being deleted."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, targets: Optional[typing.List[NodeNG]] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param targets: What is being deleted.
+        """
+        if targets is not None:
+            self.targets = targets
+
+    def get_children(self):
+        yield from self.targets
+
+
+class Dict(NodeNG, Instance):
+    """Class representing an :class:`ast.Dict` node.
+
+    A :class:`Dict` is a dictionary that is created with ``{}`` syntax.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('{1: "1"}')
+    >>> node
+    <Dict.dict l.1 at 0x7f23b2e35cc0>
+    """
+
+    _astroid_fields = ("items",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.items: typing.List[typing.Tuple[NodeNG, NodeNG]] = []
+        """The key-value pairs contained in the dictionary."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, items: typing.List[typing.Tuple[NodeNG, NodeNG]]) -> None:
+        """Do some setup after initialisation.
+
+        :param items: The key-value pairs contained in the dictionary.
+        """
+        self.items = items
+
+    @classmethod
+    def from_elements(cls, items=None):
+        """Create a :class:`Dict` of constants from a live dictionary.
+
+        :param items: The items to store in the node.
+        :type items: dict
+
+        :returns: The created dictionary node.
+        :rtype: Dict
+        """
+        node = cls()
+        if items is None:
+            node.items = []
+        else:
+            node.items = [
+                (const_factory(k), const_factory(v) if _is_const(v) else v)
+                for k, v in items.items()
+                # The keys need to be constants
+                if _is_const(k)
+            ]
+        return node
+
+    def pytype(self):
+        """Get the name of the type that this node represents.
+
+        :returns: The name of the type.
+        :rtype: str
+        """
+        return "builtins.dict"
+
+    def get_children(self):
+        """Get the key and value nodes below this node.
+
+        Children are returned in the order that they are defined in the source
+        code, key first then the value.
+
+        :returns: The children.
+        :rtype: iterable(NodeNG)
+        """
+        for key, value in self.items:
+            yield key
+            yield value
+
+    def last_child(self):
+        """An optimized version of list(get_children())[-1]
+
+        :returns: The last child, or None if no children exist.
+        :rtype: NodeNG or None
+        """
+        if self.items:
+            return self.items[-1][1]
+        return None
+
+    def itered(self):
+        """An iterator over the keys this node contains.
+
+        :returns: The keys of this node.
+        :rtype: iterable(NodeNG)
+        """
+        return [key for (key, _) in self.items]
+
+    def getitem(self, index, context=None):
+        """Get an item from this node.
+
+        :param index: The node to use as a subscript index.
+        :type index: Const or Slice
+
+        :raises AstroidTypeError: When the given index cannot be used as a
+            subscript index, or if this node is not subscriptable.
+        :raises AstroidIndexError: If the given index does not exist in the
+            dictionary.
+        """
+        for key, value in self.items:
+            # TODO(cpopa): no support for overriding yet, {1:2, **{1: 3}}.
+            if isinstance(key, DictUnpack):
+                try:
+                    return value.getitem(index, context)
+                except (AstroidTypeError, AstroidIndexError):
+                    continue
+            for inferredkey in key.infer(context):
+                if inferredkey is util.Uninferable:
+                    continue
+                if isinstance(inferredkey, Const) and isinstance(index, Const):
+                    if inferredkey.value == index.value:
+                        return value
+
+        raise AstroidIndexError(index)
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        :returns: The boolean value of this node.
+        :rtype: bool
+        """
+        return bool(self.items)
+
+
+class Expr(Statement):
+    """Class representing an :class:`ast.Expr` node.
+
+    An :class:`Expr` is any expression that does not have its value used or
+    stored.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('method()')
+    >>> node
+    <Call l.1 at 0x7f23b2e352b0>
+    >>> node.parent
+    <Expr l.1 at 0x7f23b2e35278>
+    """
+
+    _astroid_fields = ("value",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.value: Optional[NodeNG] = None
+        """What the expression does."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, value: Optional[NodeNG] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param value: What the expression does.
+        """
+        self.value = value
+
+    def get_children(self):
+        yield self.value
+
+    def _get_yield_nodes_skip_lambdas(self):
+        if not self.value.is_lambda:
+            yield from self.value._get_yield_nodes_skip_lambdas()
+
+
+class Ellipsis(mixins.NoChildrenMixin, NodeNG):  # pylint: disable=redefined-builtin
+    """Class representing an :class:`ast.Ellipsis` node.
+
+    An :class:`Ellipsis` is the ``...`` syntax.
+
+    Deprecated since v2.6.0 - Use :class:`Const` instead.
+    Will be removed with the release v2.7.0
+    """
+
+
+class EmptyNode(mixins.NoChildrenMixin, NodeNG):
+    """Holds an arbitrary object in the :attr:`LocalsDictNodeNG.locals`."""
+
+    object = None
+
+
+class ExceptHandler(mixins.MultiLineBlockMixin, mixins.AssignTypeMixin, Statement):
+    """Class representing an :class:`ast.ExceptHandler`. node.
+
+    An :class:`ExceptHandler` is an ``except`` block on a try-except.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+        try:
+            do_something()
+        except Exception as error:
+            print("Error!")
+        ''')
+    >>> node
+    <TryExcept l.2 at 0x7f23b2e9d908>
+    >>> node.handlers
+    [<ExceptHandler l.4 at 0x7f23b2e9e860>]
+    """
+
+    _astroid_fields = ("type", "name", "body")
+    _multi_line_block_fields = ("body",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.type: Optional[NodeNG] = None  # can be None
+        """The types that the block handles.
+
+        :type: Tuple or NodeNG or None
+        """
+
+        self.name: Optional[AssignName] = None  # can be None
+        """The name that the caught exception is assigned to."""
+
+        self.body: typing.List[NodeNG] = []
+        """The contents of the block."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["ExceptHandler"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    def get_children(self):
+        if self.type is not None:
+            yield self.type
+
+        if self.name is not None:
+            yield self.name
+
+        yield from self.body
+
+    # pylint: disable=redefined-builtin; had to use the same name as builtin ast module.
+    def postinit(
+        self,
+        type: Optional[NodeNG] = None,
+        name: Optional[AssignName] = None,
+        body: Optional[typing.List[NodeNG]] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param type: The types that the block handles.
+        :type type: Tuple or NodeNG or None
+
+        :param name: The name that the caught exception is assigned to.
+
+        :param body:The contents of the block.
+        """
+        self.type = type
+        self.name = name
+        if body is not None:
+            self.body = body
+
+    @cached_property
+    def blockstart_tolineno(self):
+        """The line on which the beginning of this block ends.
+
+        :type: int
+        """
+        if self.name:
+            return self.name.tolineno
+        if self.type:
+            return self.type.tolineno
+        return self.lineno
+
+    def catch(self, exceptions: Optional[typing.List[str]]) -> bool:
+        """Check if this node handles any of the given
+
+        :param exceptions: The names of the exceptions to check for.
+        """
+        if self.type is None or exceptions is None:
+            return True
+        return any(node.name in exceptions for node in self.type._get_name_nodes())
+
+
+class ExtSlice(NodeNG):
+    """Class representing an :class:`ast.ExtSlice` node.
+
+    An :class:`ExtSlice` is a complex slice expression.
+
+    Deprecated since v2.6.0 - Now part of the :class:`Subscript` node.
+    Will be removed with the release of v2.7.0
+    """
+
+
+class For(
+    mixins.MultiLineBlockMixin,
+    mixins.BlockRangeMixIn,
+    mixins.AssignTypeMixin,
+    Statement,
+):
+    """Class representing an :class:`ast.For` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('for thing in things: print(thing)')
+    >>> node
+    <For l.1 at 0x7f23b2e8cf28>
+    """
+
+    _astroid_fields = ("target", "iter", "body", "orelse")
+    _other_other_fields = ("type_annotation",)
+    _multi_line_block_fields = ("body", "orelse")
+
+    optional_assign = True
+    """Whether this node optionally assigns a variable.
+
+    This is always ``True`` for :class:`For` nodes.
+    """
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.target: Optional[NodeNG] = None
+        """What the loop assigns to."""
+
+        self.iter: Optional[NodeNG] = None
+        """What the loop iterates over."""
+
+        self.body: typing.List[NodeNG] = []
+        """The contents of the body of the loop."""
+
+        self.orelse: typing.List[NodeNG] = []
+        """The contents of the ``else`` block of the loop."""
+
+        self.type_annotation: Optional[NodeNG] = None  # can be None
+        """If present, this will contain the type annotation passed by a type comment"""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    # pylint: disable=redefined-builtin; had to use the same name as builtin ast module.
+    def postinit(
+        self,
+        target: Optional[NodeNG] = None,
+        iter: Optional[NodeNG] = None,
+        body: Optional[typing.List[NodeNG]] = None,
+        orelse: Optional[typing.List[NodeNG]] = None,
+        type_annotation: Optional[NodeNG] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param target: What the loop assigns to.
+
+        :param iter: What the loop iterates over.
+
+        :param body: The contents of the body of the loop.
+
+        :param orelse: The contents of the ``else`` block of the loop.
+        """
+        self.target = target
+        self.iter = iter
+        if body is not None:
+            self.body = body
+        if orelse is not None:
+            self.orelse = orelse
+        self.type_annotation = type_annotation
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["For"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    @cached_property
+    def blockstart_tolineno(self):
+        """The line on which the beginning of this block ends.
+
+        :type: int
+        """
+        return self.iter.tolineno
+
+    def get_children(self):
+        yield self.target
+        yield self.iter
+
+        yield from self.body
+        yield from self.orelse
+
+
+class AsyncFor(For):
+    """Class representing an :class:`ast.AsyncFor` node.
+
+    An :class:`AsyncFor` is an asynchronous :class:`For` built with
+    the ``async`` keyword.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    async def func(things):
+        async for thing in things:
+            print(thing)
+    ''')
+    >>> node
+    <AsyncFunctionDef.func l.2 at 0x7f23b2e416d8>
+    >>> node.body[0]
+    <AsyncFor l.3 at 0x7f23b2e417b8>
+    """
+
+
+class Await(NodeNG):
+    """Class representing an :class:`ast.Await` node.
+
+    An :class:`Await` is the ``await`` keyword.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    async def func(things):
+        await other_func()
+    ''')
+    >>> node
+    <AsyncFunctionDef.func l.2 at 0x7f23b2e41748>
+    >>> node.body[0]
+    <Expr l.3 at 0x7f23b2e419e8>
+    >>> list(node.body[0].get_children())[0]
+    <Await l.3 at 0x7f23b2e41a20>
+    """
+
+    _astroid_fields = ("value",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.value: Optional[NodeNG] = None
+        """What to wait for."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, value: Optional[NodeNG] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param value: What to wait for.
+        """
+        self.value = value
+
+    def get_children(self):
+        yield self.value
+
+
+class ImportFrom(mixins.NoChildrenMixin, mixins.ImportFromMixin, Statement):
+    """Class representing an :class:`ast.ImportFrom` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('from my_package import my_module')
+    >>> node
+    <ImportFrom l.1 at 0x7f23b2e415c0>
+    """
+
+    _other_fields = ("modname", "names", "level")
+
+    def __init__(
+        self,
+        fromname: Optional[str],
+        names: typing.List[typing.Tuple[str, Optional[str]]],
+        level: Optional[int] = 0,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param fromname: The module that is being imported from.
+
+        :param names: What is being imported from the module.
+
+        :param level: The level of relative import.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.modname: Optional[str] = fromname  # can be None
+        """The module that is being imported from.
+
+        This is ``None`` for relative imports.
+        """
+
+        self.names: typing.List[typing.Tuple[str, Optional[str]]] = names
+        """What is being imported from the module.
+
+        Each entry is a :class:`tuple` of the name being imported,
+        and the alias that the name is assigned to (if any).
+        """
+
+        # TODO When is 'level' None?
+        self.level: Optional[int] = level  # can be None
+        """The level of relative import.
+
+        Essentially this is the number of dots in the import.
+        This is always 0 for absolute imports.
+        """
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+
+class Attribute(NodeNG):
+    """Class representing an :class:`ast.Attribute` node."""
+
+    _astroid_fields = ("expr",)
+    _other_fields = ("attrname",)
+
+    @decorators.deprecate_default_argument_values(attrname="str")
+    def __init__(
+        self,
+        attrname: Optional[str] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param attrname: The name of the attribute.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.expr: Optional[NodeNG] = None
+        """The name that this node represents.
+
+        :type: Name or None
+        """
+
+        self.attrname: Optional[str] = attrname
+        """The name of the attribute."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, expr: Optional[NodeNG] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param expr: The name that this node represents.
+        :type expr: Name or None
+        """
+        self.expr = expr
+
+    def get_children(self):
+        yield self.expr
+
+
+class Global(mixins.NoChildrenMixin, Statement):
+    """Class representing an :class:`ast.Global` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('global a_global')
+    >>> node
+    <Global l.1 at 0x7f23b2e9de10>
+    """
+
+    _other_fields = ("names",)
+
+    def __init__(
+        self,
+        names: typing.List[str],
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param names: The names being declared as global.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.names: typing.List[str] = names
+        """The names being declared as global."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def _infer_name(self, frame, name):
+        return name
+
+
+class If(mixins.MultiLineBlockMixin, mixins.BlockRangeMixIn, Statement):
+    """Class representing an :class:`ast.If` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('if condition: print(True)')
+    >>> node
+    <If l.1 at 0x7f23b2e9dd30>
+    """
+
+    _astroid_fields = ("test", "body", "orelse")
+    _multi_line_block_fields = ("body", "orelse")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.test: Optional[NodeNG] = None
+        """The condition that the statement tests."""
+
+        self.body: typing.List[NodeNG] = []
+        """The contents of the block."""
+
+        self.orelse: typing.List[NodeNG] = []
+        """The contents of the ``else`` block."""
+
+        self.is_orelse: bool = False
+        """Whether the if-statement is the orelse-block of another if statement."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        test: Optional[NodeNG] = None,
+        body: Optional[typing.List[NodeNG]] = None,
+        orelse: Optional[typing.List[NodeNG]] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param test: The condition that the statement tests.
+
+        :param body: The contents of the block.
+
+        :param orelse: The contents of the ``else`` block.
+        """
+        self.test = test
+        if body is not None:
+            self.body = body
+        if orelse is not None:
+            self.orelse = orelse
+        if isinstance(self.parent, If) and self in self.parent.orelse:
+            self.is_orelse = True
+
+    @cached_property
+    def blockstart_tolineno(self):
+        """The line on which the beginning of this block ends.
+
+        :type: int
+        """
+        return self.test.tolineno
+
+    def block_range(self, lineno):
+        """Get a range from the given line number to where this node ends.
+
+        :param lineno: The line number to start the range at.
+        :type lineno: int
+
+        :returns: The range of line numbers that this node belongs to,
+            starting at the given line number.
+        :rtype: tuple(int, int)
+        """
+        if lineno == self.body[0].fromlineno:
+            return lineno, lineno
+        if lineno <= self.body[-1].tolineno:
+            return lineno, self.body[-1].tolineno
+        return self._elsed_block_range(lineno, self.orelse, self.body[0].fromlineno - 1)
+
+    def get_children(self):
+        yield self.test
+
+        yield from self.body
+        yield from self.orelse
+
+    def has_elif_block(self):
+        return len(self.orelse) == 1 and isinstance(self.orelse[0], If)
+
+    def _get_yield_nodes_skip_lambdas(self):
+        """An If node can contain a Yield node in the test"""
+        yield from self.test._get_yield_nodes_skip_lambdas()
+        yield from super()._get_yield_nodes_skip_lambdas()
+
+    def is_sys_guard(self) -> bool:
+        """Return True if IF stmt is a sys.version_info guard.
+
+        >>> import astroid
+        >>> node = astroid.extract_node('''
+        import sys
+        if sys.version_info > (3, 8):
+            from typing import Literal
+        else:
+            from typing_extensions import Literal
+        ''')
+        >>> node.is_sys_guard()
+        True
+        """
+        warnings.warn(
+            "The 'is_sys_guard' function is deprecated and will be removed in astroid 3.0.0 "
+            "It has been moved to pylint and can be imported from 'pylint.checkers.utils' "
+            "starting with pylint 2.12",
+            DeprecationWarning,
+        )
+        if isinstance(self.test, Compare):
+            value = self.test.left
+            if isinstance(value, Subscript):
+                value = value.value
+            if isinstance(value, Attribute) and value.as_string() == "sys.version_info":
+                return True
+
+        return False
+
+    def is_typing_guard(self) -> bool:
+        """Return True if IF stmt is a typing guard.
+
+        >>> import astroid
+        >>> node = astroid.extract_node('''
+        from typing import TYPE_CHECKING
+        if TYPE_CHECKING:
+            from xyz import a
+        ''')
+        >>> node.is_typing_guard()
+        True
+        """
+        warnings.warn(
+            "The 'is_typing_guard' function is deprecated and will be removed in astroid 3.0.0 "
+            "It has been moved to pylint and can be imported from 'pylint.checkers.utils' "
+            "starting with pylint 2.12",
+            DeprecationWarning,
+        )
+        return isinstance(
+            self.test, (Name, Attribute)
+        ) and self.test.as_string().endswith("TYPE_CHECKING")
+
+
+class IfExp(NodeNG):
+    """Class representing an :class:`ast.IfExp` node.
+    >>> import astroid
+    >>> node = astroid.extract_node('value if condition else other')
+    >>> node
+    <IfExp l.1 at 0x7f23b2e9dbe0>
+    """
+
+    _astroid_fields = ("test", "body", "orelse")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.test: Optional[NodeNG] = None
+        """The condition that the statement tests."""
+
+        self.body: Optional[NodeNG] = None
+        """The contents of the block."""
+
+        self.orelse: Optional[NodeNG] = None
+        """The contents of the ``else`` block."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        test: Optional[NodeNG] = None,
+        body: Optional[NodeNG] = None,
+        orelse: Optional[NodeNG] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param test: The condition that the statement tests.
+
+        :param body: The contents of the block.
+
+        :param orelse: The contents of the ``else`` block.
+        """
+        self.test = test
+        self.body = body
+        self.orelse = orelse
+
+    def get_children(self):
+        yield self.test
+        yield self.body
+        yield self.orelse
+
+    def op_left_associative(self):
+        # `1 if True else 2 if False else 3` is parsed as
+        # `1 if True else (2 if False else 3)`
+        return False
+
+
+class Import(mixins.NoChildrenMixin, mixins.ImportFromMixin, Statement):
+    """Class representing an :class:`ast.Import` node.
+    >>> import astroid
+    >>> node = astroid.extract_node('import astroid')
+    >>> node
+    <Import l.1 at 0x7f23b2e4e5c0>
+    """
+
+    _other_fields = ("names",)
+
+    @decorators.deprecate_default_argument_values(names="list[tuple[str, str | None]]")
+    def __init__(
+        self,
+        names: Optional[typing.List[typing.Tuple[str, Optional[str]]]] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param names: The names being imported.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.names: typing.List[typing.Tuple[str, Optional[str]]] = names or []
+        """The names being imported.
+
+        Each entry is a :class:`tuple` of the name being imported,
+        and the alias that the name is assigned to (if any).
+        """
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+
+class Index(NodeNG):
+    """Class representing an :class:`ast.Index` node.
+
+    An :class:`Index` is a simple subscript.
+
+    Deprecated since v2.6.0 - Now part of the :class:`Subscript` node.
+    Will be removed with the release of v2.7.0
+    """
+
+
+class Keyword(NodeNG):
+    """Class representing an :class:`ast.keyword` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('function(a_kwarg=True)')
+    >>> node
+    <Call l.1 at 0x7f23b2e9e320>
+    >>> node.keywords
+    [<Keyword l.1 at 0x7f23b2e9e9b0>]
+    """
+
+    _astroid_fields = ("value",)
+    _other_fields = ("arg",)
+
+    def __init__(
+        self,
+        arg: Optional[str] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param arg: The argument being assigned to.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.arg: Optional[str] = arg  # can be None
+        """The argument being assigned to."""
+
+        self.value: Optional[NodeNG] = None
+        """The value being assigned to the keyword argument."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, value: Optional[NodeNG] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param value: The value being assigned to the keyword argument.
+        """
+        self.value = value
+
+    def get_children(self):
+        yield self.value
+
+
+class List(BaseContainer):
+    """Class representing an :class:`ast.List` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('[1, 2, 3]')
+    >>> node
+    <List.list l.1 at 0x7f23b2e9e128>
+    """
+
+    _other_fields = ("ctx",)
+
+    def __init__(
+        self,
+        ctx: Optional[Context] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param ctx: Whether the list is assigned to or loaded from.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.ctx: Optional[Context] = ctx
+        """Whether the list is assigned to or loaded from."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["List"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    def pytype(self):
+        """Get the name of the type that this node represents.
+
+        :returns: The name of the type.
+        :rtype: str
+        """
+        return "builtins.list"
+
+    def getitem(self, index, context=None):
+        """Get an item from this node.
+
+        :param index: The node to use as a subscript index.
+        :type index: Const or Slice
+        """
+        return _container_getitem(self, self.elts, index, context=context)
+
+
+class Nonlocal(mixins.NoChildrenMixin, Statement):
+    """Class representing an :class:`ast.Nonlocal` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    def function():
+        nonlocal var
+    ''')
+    >>> node
+    <FunctionDef.function l.2 at 0x7f23b2e9e208>
+    >>> node.body[0]
+    <Nonlocal l.3 at 0x7f23b2e9e908>
+    """
+
+    _other_fields = ("names",)
+
+    def __init__(
+        self,
+        names: typing.List[str],
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param names: The names being declared as not local.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.names: typing.List[str] = names
+        """The names being declared as not local."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def _infer_name(self, frame, name):
+        return name
+
+
+class Pass(mixins.NoChildrenMixin, Statement):
+    """Class representing an :class:`ast.Pass` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('pass')
+    >>> node
+    <Pass l.1 at 0x7f23b2e9e748>
+    """
+
+
+class Raise(Statement):
+    """Class representing an :class:`ast.Raise` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('raise RuntimeError("Something bad happened!")')
+    >>> node
+    <Raise l.1 at 0x7f23b2e9e828>
+    """
+
+    _astroid_fields = ("exc", "cause")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.exc: Optional[NodeNG] = None  # can be None
+        """What is being raised."""
+
+        self.cause: Optional[NodeNG] = None  # can be None
+        """The exception being used to raise this one."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        exc: Optional[NodeNG] = None,
+        cause: Optional[NodeNG] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param exc: What is being raised.
+
+        :param cause: The exception being used to raise this one.
+        """
+        self.exc = exc
+        self.cause = cause
+
+    def raises_not_implemented(self):
+        """Check if this node raises a :class:`NotImplementedError`.
+
+        :returns: True if this node raises a :class:`NotImplementedError`,
+            False otherwise.
+        :rtype: bool
+        """
+        if not self.exc:
+            return False
+        return any(
+            name.name == "NotImplementedError" for name in self.exc._get_name_nodes()
+        )
+
+    def get_children(self):
+        if self.exc is not None:
+            yield self.exc
+
+        if self.cause is not None:
+            yield self.cause
+
+
+class Return(Statement):
+    """Class representing an :class:`ast.Return` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('return True')
+    >>> node
+    <Return l.1 at 0x7f23b8211908>
+    """
+
+    _astroid_fields = ("value",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.value: Optional[NodeNG] = None  # can be None
+        """The value being returned."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, value: Optional[NodeNG] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param value: The value being returned.
+        """
+        self.value = value
+
+    def get_children(self):
+        if self.value is not None:
+            yield self.value
+
+    def is_tuple_return(self):
+        return isinstance(self.value, Tuple)
+
+    def _get_return_nodes_skip_functions(self):
+        yield self
+
+
+class Set(BaseContainer):
+    """Class representing an :class:`ast.Set` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('{1, 2, 3}')
+    >>> node
+    <Set.set l.1 at 0x7f23b2e71d68>
+    """
+
+    def pytype(self):
+        """Get the name of the type that this node represents.
+
+        :returns: The name of the type.
+        :rtype: str
+        """
+        return "builtins.set"
+
+
+class Slice(NodeNG):
+    """Class representing an :class:`ast.Slice` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('things[1:3]')
+    >>> node
+    <Subscript l.1 at 0x7f23b2e71f60>
+    >>> node.slice
+    <Slice l.1 at 0x7f23b2e71e80>
+    """
+
+    _astroid_fields = ("lower", "upper", "step")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.lower: Optional[NodeNG] = None  # can be None
+        """The lower index in the slice."""
+
+        self.upper: Optional[NodeNG] = None  # can be None
+        """The upper index in the slice."""
+
+        self.step: Optional[NodeNG] = None  # can be None
+        """The step to take between indexes."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        lower: Optional[NodeNG] = None,
+        upper: Optional[NodeNG] = None,
+        step: Optional[NodeNG] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param lower: The lower index in the slice.
+
+        :param upper: The upper index in the slice.
+
+        :param step: The step to take between index.
+        """
+        self.lower = lower
+        self.upper = upper
+        self.step = step
+
+    def _wrap_attribute(self, attr):
+        """Wrap the empty attributes of the Slice in a Const node."""
+        if not attr:
+            const = const_factory(attr)
+            const.parent = self
+            return const
+        return attr
+
+    @cached_property
+    def _proxied(self):
+        builtins = AstroidManager().builtins_module
+        return builtins.getattr("slice")[0]
+
+    def pytype(self):
+        """Get the name of the type that this node represents.
+
+        :returns: The name of the type.
+        :rtype: str
+        """
+        return "builtins.slice"
+
+    def igetattr(self, attrname, context=None):
+        """Infer the possible values of the given attribute on the slice.
+
+        :param attrname: The name of the attribute to infer.
+        :type attrname: str
+
+        :returns: The inferred possible values.
+        :rtype: iterable(NodeNG)
+        """
+        if attrname == "start":
+            yield self._wrap_attribute(self.lower)
+        elif attrname == "stop":
+            yield self._wrap_attribute(self.upper)
+        elif attrname == "step":
+            yield self._wrap_attribute(self.step)
+        else:
+            yield from self.getattr(attrname, context=context)
+
+    def getattr(self, attrname, context=None):
+        return self._proxied.getattr(attrname, context)
+
+    def get_children(self):
+        if self.lower is not None:
+            yield self.lower
+
+        if self.upper is not None:
+            yield self.upper
+
+        if self.step is not None:
+            yield self.step
+
+
+class Starred(mixins.ParentAssignTypeMixin, NodeNG):
+    """Class representing an :class:`ast.Starred` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('*args')
+    >>> node
+    <Starred l.1 at 0x7f23b2e41978>
+    """
+
+    _astroid_fields = ("value",)
+    _other_fields = ("ctx",)
+
+    def __init__(
+        self,
+        ctx: Optional[Context] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param ctx: Whether the list is assigned to or loaded from.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.value: Optional[NodeNG] = None
+        """What is being unpacked."""
+
+        self.ctx: Optional[Context] = ctx
+        """Whether the starred item is assigned to or loaded from."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, value: Optional[NodeNG] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param value: What is being unpacked.
+        """
+        self.value = value
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["Starred"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    def get_children(self):
+        yield self.value
+
+
+class Subscript(NodeNG):
+    """Class representing an :class:`ast.Subscript` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('things[1:3]')
+    >>> node
+    <Subscript l.1 at 0x7f23b2e71f60>
+    """
+
+    _astroid_fields = ("value", "slice")
+    _other_fields = ("ctx",)
+
+    def __init__(
+        self,
+        ctx: Optional[Context] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param ctx: Whether the subscripted item is assigned to or loaded from.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.value: Optional[NodeNG] = None
+        """What is being indexed."""
+
+        self.slice: Optional[NodeNG] = None
+        """The slice being used to lookup."""
+
+        self.ctx: Optional[Context] = ctx
+        """Whether the subscripted item is assigned to or loaded from."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    # pylint: disable=redefined-builtin; had to use the same name as builtin ast module.
+    def postinit(
+        self, value: Optional[NodeNG] = None, slice: Optional[NodeNG] = None
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param value: What is being indexed.
+
+        :param slice: The slice being used to lookup.
+        """
+        self.value = value
+        self.slice = slice
+
+    def get_children(self):
+        yield self.value
+        yield self.slice
+
+
+class TryExcept(mixins.MultiLineBlockMixin, mixins.BlockRangeMixIn, Statement):
+    """Class representing an :class:`ast.TryExcept` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+        try:
+            do_something()
+        except Exception as error:
+            print("Error!")
+        ''')
+    >>> node
+    <TryExcept l.2 at 0x7f23b2e9d908>
+    """
+
+    _astroid_fields = ("body", "handlers", "orelse")
+    _multi_line_block_fields = ("body", "handlers", "orelse")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.body: typing.List[NodeNG] = []
+        """The contents of the block to catch exceptions from."""
+
+        self.handlers: typing.List[ExceptHandler] = []
+        """The exception handlers."""
+
+        self.orelse: typing.List[NodeNG] = []
+        """The contents of the ``else`` block."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        body: Optional[typing.List[NodeNG]] = None,
+        handlers: Optional[typing.List[ExceptHandler]] = None,
+        orelse: Optional[typing.List[NodeNG]] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param body: The contents of the block to catch exceptions from.
+
+        :param handlers: The exception handlers.
+
+        :param orelse: The contents of the ``else`` block.
+        """
+        if body is not None:
+            self.body = body
+        if handlers is not None:
+            self.handlers = handlers
+        if orelse is not None:
+            self.orelse = orelse
+
+    def _infer_name(self, frame, name):
+        return name
+
+    def block_range(self, lineno):
+        """Get a range from the given line number to where this node ends.
+
+        :param lineno: The line number to start the range at.
+        :type lineno: int
+
+        :returns: The range of line numbers that this node belongs to,
+            starting at the given line number.
+        :rtype: tuple(int, int)
+        """
+        last = None
+        for exhandler in self.handlers:
+            if exhandler.type and lineno == exhandler.type.fromlineno:
+                return lineno, lineno
+            if exhandler.body[0].fromlineno <= lineno <= exhandler.body[-1].tolineno:
+                return lineno, exhandler.body[-1].tolineno
+            if last is None:
+                last = exhandler.body[0].fromlineno - 1
+        return self._elsed_block_range(lineno, self.orelse, last)
+
+    def get_children(self):
+        yield from self.body
+
+        yield from self.handlers or ()
+        yield from self.orelse or ()
+
+
+class TryFinally(mixins.MultiLineBlockMixin, mixins.BlockRangeMixIn, Statement):
+    """Class representing an :class:`ast.TryFinally` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    try:
+        do_something()
+    except Exception as error:
+        print("Error!")
+    finally:
+        print("Cleanup!")
+    ''')
+    >>> node
+    <TryFinally l.2 at 0x7f23b2e41d68>
+    """
+
+    _astroid_fields = ("body", "finalbody")
+    _multi_line_block_fields = ("body", "finalbody")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.body: typing.List[Union[NodeNG, TryExcept]] = []
+        """The try-except that the finally is attached to."""
+
+        self.finalbody: typing.List[NodeNG] = []
+        """The contents of the ``finally`` block."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        body: Optional[typing.List[Union[NodeNG, TryExcept]]] = None,
+        finalbody: Optional[typing.List[NodeNG]] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param body: The try-except that the finally is attached to.
+
+        :param finalbody: The contents of the ``finally`` block.
+        """
+        if body is not None:
+            self.body = body
+        if finalbody is not None:
+            self.finalbody = finalbody
+
+    def block_range(self, lineno):
+        """Get a range from the given line number to where this node ends.
+
+        :param lineno: The line number to start the range at.
+        :type lineno: int
+
+        :returns: The range of line numbers that this node belongs to,
+            starting at the given line number.
+        :rtype: tuple(int, int)
+        """
+        child = self.body[0]
+        # py2.5 try: except: finally:
+        if (
+            isinstance(child, TryExcept)
+            and child.fromlineno == self.fromlineno
+            and child.tolineno >= lineno > self.fromlineno
+        ):
+            return child.block_range(lineno)
+        return self._elsed_block_range(lineno, self.finalbody)
+
+    def get_children(self):
+        yield from self.body
+        yield from self.finalbody
+
+
+class Tuple(BaseContainer):
+    """Class representing an :class:`ast.Tuple` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('(1, 2, 3)')
+    >>> node
+    <Tuple.tuple l.1 at 0x7f23b2e41780>
+    """
+
+    _other_fields = ("ctx",)
+
+    def __init__(
+        self,
+        ctx: Optional[Context] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param ctx: Whether the tuple is assigned to or loaded from.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.ctx: Optional[Context] = ctx
+        """Whether the tuple is assigned to or loaded from."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["Tuple"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    def pytype(self):
+        """Get the name of the type that this node represents.
+
+        :returns: The name of the type.
+        :rtype: str
+        """
+        return "builtins.tuple"
+
+    def getitem(self, index, context=None):
+        """Get an item from this node.
+
+        :param index: The node to use as a subscript index.
+        :type index: Const or Slice
+        """
+        return _container_getitem(self, self.elts, index, context=context)
+
+
+class UnaryOp(NodeNG):
+    """Class representing an :class:`ast.UnaryOp` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('-5')
+    >>> node
+    <UnaryOp l.1 at 0x7f23b2e4e198>
+    """
+
+    _astroid_fields = ("operand",)
+    _other_fields = ("op",)
+
+    @decorators.deprecate_default_argument_values(op="str")
+    def __init__(
+        self,
+        op: Optional[str] = None,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param op: The operator.
+
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.op: Optional[str] = op
+        """The operator."""
+
+        self.operand: Optional[NodeNG] = None
+        """What the unary operator is applied to."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, operand: Optional[NodeNG] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param operand: What the unary operator is applied to.
+        """
+        self.operand = operand
+
+    # This is set by inference.py
+    def _infer_unaryop(self, context=None):
+        raise NotImplementedError
+
+    def type_errors(self, context=None):
+        """Get a list of type errors which can occur during inference.
+
+        Each TypeError is represented by a :class:`BadBinaryOperationMessage`,
+        which holds the original exception.
+
+        :returns: The list of possible type errors.
+        :rtype: list(BadBinaryOperationMessage)
+        """
+        try:
+            results = self._infer_unaryop(context=context)
+            return [
+                result
+                for result in results
+                if isinstance(result, util.BadUnaryOperationMessage)
+            ]
+        except InferenceError:
+            return []
+
+    def get_children(self):
+        yield self.operand
+
+    def op_precedence(self):
+        if self.op == "not":
+            return OP_PRECEDENCE[self.op]
+
+        return super().op_precedence()
+
+
+class While(mixins.MultiLineBlockMixin, mixins.BlockRangeMixIn, Statement):
+    """Class representing an :class:`ast.While` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    while condition():
+        print("True")
+    ''')
+    >>> node
+    <While l.2 at 0x7f23b2e4e390>
+    """
+
+    _astroid_fields = ("test", "body", "orelse")
+    _multi_line_block_fields = ("body", "orelse")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.test: Optional[NodeNG] = None
+        """The condition that the loop tests."""
+
+        self.body: typing.List[NodeNG] = []
+        """The contents of the loop."""
+
+        self.orelse: typing.List[NodeNG] = []
+        """The contents of the ``else`` block."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        test: Optional[NodeNG] = None,
+        body: Optional[typing.List[NodeNG]] = None,
+        orelse: Optional[typing.List[NodeNG]] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param test: The condition that the loop tests.
+
+        :param body: The contents of the loop.
+
+        :param orelse: The contents of the ``else`` block.
+        """
+        self.test = test
+        if body is not None:
+            self.body = body
+        if orelse is not None:
+            self.orelse = orelse
+
+    @cached_property
+    def blockstart_tolineno(self):
+        """The line on which the beginning of this block ends.
+
+        :type: int
+        """
+        return self.test.tolineno
+
+    def block_range(self, lineno):
+        """Get a range from the given line number to where this node ends.
+
+        :param lineno: The line number to start the range at.
+        :type lineno: int
+
+        :returns: The range of line numbers that this node belongs to,
+            starting at the given line number.
+        :rtype: tuple(int, int)
+        """
+        return self._elsed_block_range(lineno, self.orelse)
+
+    def get_children(self):
+        yield self.test
+
+        yield from self.body
+        yield from self.orelse
+
+    def _get_yield_nodes_skip_lambdas(self):
+        """A While node can contain a Yield node in the test"""
+        yield from self.test._get_yield_nodes_skip_lambdas()
+        yield from super()._get_yield_nodes_skip_lambdas()
+
+
+class With(
+    mixins.MultiLineBlockMixin,
+    mixins.BlockRangeMixIn,
+    mixins.AssignTypeMixin,
+    Statement,
+):
+    """Class representing an :class:`ast.With` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    with open(file_path) as file_:
+        print(file_.read())
+    ''')
+    >>> node
+    <With l.2 at 0x7f23b2e4e710>
+    """
+
+    _astroid_fields = ("items", "body")
+    _other_other_fields = ("type_annotation",)
+    _multi_line_block_fields = ("body",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.items: typing.List[typing.Tuple[NodeNG, Optional[NodeNG]]] = []
+        """The pairs of context managers and the names they are assigned to."""
+
+        self.body: typing.List[NodeNG] = []
+        """The contents of the ``with`` block."""
+
+        self.type_annotation: Optional[NodeNG] = None  # can be None
+        """If present, this will contain the type annotation passed by a type comment"""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        items: Optional[typing.List[typing.Tuple[NodeNG, Optional[NodeNG]]]] = None,
+        body: Optional[typing.List[NodeNG]] = None,
+        type_annotation: Optional[NodeNG] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param items: The pairs of context managers and the names
+            they are assigned to.
+
+        :param body: The contents of the ``with`` block.
+        """
+        if items is not None:
+            self.items = items
+        if body is not None:
+            self.body = body
+        self.type_annotation = type_annotation
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["With"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    @cached_property
+    def blockstart_tolineno(self):
+        """The line on which the beginning of this block ends.
+
+        :type: int
+        """
+        return self.items[-1][0].tolineno
+
+    def get_children(self):
+        """Get the child nodes below this node.
+
+        :returns: The children.
+        :rtype: iterable(NodeNG)
+        """
+        for expr, var in self.items:
+            yield expr
+            if var:
+                yield var
+        yield from self.body
+
+
+class AsyncWith(With):
+    """Asynchronous ``with`` built with the ``async`` keyword."""
+
+
+class Yield(NodeNG):
+    """Class representing an :class:`ast.Yield` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('yield True')
+    >>> node
+    <Yield l.1 at 0x7f23b2e4e5f8>
+    """
+
+    _astroid_fields = ("value",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.value: Optional[NodeNG] = None  # can be None
+        """The value to yield."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, value: Optional[NodeNG] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param value: The value to yield.
+        """
+        self.value = value
+
+    def get_children(self):
+        if self.value is not None:
+            yield self.value
+
+    def _get_yield_nodes_skip_lambdas(self):
+        yield self
+
+
+class YieldFrom(Yield):  # TODO value is required, not optional
+    """Class representing an :class:`ast.YieldFrom` node."""
+
+
+class DictUnpack(mixins.NoChildrenMixin, NodeNG):
+    """Represents the unpacking of dicts into dicts using :pep:`448`."""
+
+
+class FormattedValue(NodeNG):
+    """Class representing an :class:`ast.FormattedValue` node.
+
+    Represents a :pep:`498` format string.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('f"Format {type_}"')
+    >>> node
+    <JoinedStr l.1 at 0x7f23b2e4ed30>
+    >>> node.values
+    [<Const.str l.1 at 0x7f23b2e4eda0>, <FormattedValue l.1 at 0x7f23b2e4edd8>]
+    """
+
+    _astroid_fields = ("value", "format_spec")
+    _other_fields = ("conversion",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.value: NodeNG
+        """The value to be formatted into the string."""
+
+        self.conversion: Optional[int] = None  # can be None
+        """The type of formatting to be applied to the value.
+
+        .. seealso::
+            :class:`ast.FormattedValue`
+        """
+
+        self.format_spec: Optional[NodeNG] = None  # can be None
+        """The formatting to be applied to the value.
+
+        .. seealso::
+            :class:`ast.FormattedValue`
+
+        :type: JoinedStr or None
+        """
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        value: NodeNG,
+        conversion: Optional[int] = None,
+        format_spec: Optional[NodeNG] = None,
+    ) -> None:
+        """Do some setup after initialisation.
+
+        :param value: The value to be formatted into the string.
+
+        :param conversion: The type of formatting to be applied to the value.
+
+        :param format_spec: The formatting to be applied to the value.
+        :type format_spec: JoinedStr or None
+        """
+        self.value = value
+        self.conversion = conversion
+        self.format_spec = format_spec
+
+    def get_children(self):
+        yield self.value
+
+        if self.format_spec is not None:
+            yield self.format_spec
+
+
+class JoinedStr(NodeNG):
+    """Represents a list of string expressions to be joined.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('f"Format {type_}"')
+    >>> node
+    <JoinedStr l.1 at 0x7f23b2e4ed30>
+    """
+
+    _astroid_fields = ("values",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.values: typing.List[NodeNG] = []
+        """The string expressions to be joined.
+
+        :type: list(FormattedValue or Const)
+        """
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, values: Optional[typing.List[NodeNG]] = None) -> None:
+        """Do some setup after initialisation.
+
+        :param value: The string expressions to be joined.
+
+        :type: list(FormattedValue or Const)
+        """
+        if values is not None:
+            self.values = values
+
+    def get_children(self):
+        yield from self.values
+
+
+class NamedExpr(mixins.AssignTypeMixin, NodeNG):
+    """Represents the assignment from the assignment expression
+
+    >>> import astroid
+    >>> module = astroid.parse('if a := 1: pass')
+    >>> module.body[0].test
+    <NamedExpr l.1 at 0x7f23b2e4ed30>
+    """
+
+    _astroid_fields = ("target", "value")
+
+    optional_assign = True
+    """Whether this node optionally assigns a variable.
+
+    Since NamedExpr are not always called they do not always assign."""
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.target: NodeNG
+        """The assignment target
+
+        :type: Name
+        """
+
+        self.value: NodeNG
+        """The value that gets assigned in the expression"""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, target: NodeNG, value: NodeNG) -> None:
+        self.target = target
+        self.value = value
+
+    assigned_stmts: ClassVar[AssignedStmtsCall["NamedExpr"]]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+    def frame(
+        self, *, future: Literal[None, True] = None
+    ) -> Union["nodes.FunctionDef", "nodes.Module", "nodes.ClassDef", "nodes.Lambda"]:
+        """The first parent frame node.
+
+        A frame node is a :class:`Module`, :class:`FunctionDef`,
+        or :class:`ClassDef`.
+
+        :returns: The first parent frame node.
+        """
+        if not self.parent:
+            raise ParentMissingError(target=self)
+
+        # For certain parents NamedExpr evaluate to the scope of the parent
+        if isinstance(self.parent, (Arguments, Keyword, Comprehension)):
+            if not self.parent.parent:
+                raise ParentMissingError(target=self.parent)
+            if not self.parent.parent.parent:
+                raise ParentMissingError(target=self.parent.parent)
+            return self.parent.parent.parent.frame(future=True)
+
+        return self.parent.frame(future=True)
+
+    def scope(self) -> "LocalsDictNodeNG":
+        """The first parent node defining a new scope.
+        These can be Module, FunctionDef, ClassDef, Lambda, or GeneratorExp nodes.
+
+        :returns: The first parent scope node.
+        """
+        if not self.parent:
+            raise ParentMissingError(target=self)
+
+        # For certain parents NamedExpr evaluate to the scope of the parent
+        if isinstance(self.parent, (Arguments, Keyword, Comprehension)):
+            if not self.parent.parent:
+                raise ParentMissingError(target=self.parent)
+            if not self.parent.parent.parent:
+                raise ParentMissingError(target=self.parent.parent)
+            return self.parent.parent.parent.scope()
+
+        return self.parent.scope()
+
+    def set_local(self, name: str, stmt: AssignName) -> None:
+        """Define that the given name is declared in the given statement node.
+        NamedExpr's in Arguments, Keyword or Comprehension are evaluated in their
+        parent's parent scope. So we add to their frame's locals.
+
+        .. seealso:: :meth:`scope`
+
+        :param name: The name that is being defined.
+
+        :param stmt: The statement that defines the given name.
+        """
+        self.frame(future=True).set_local(name, stmt)
+
+
+class Unknown(mixins.AssignTypeMixin, NodeNG):
+    """This node represents a node in a constructed AST where
+    introspection is not possible.  At the moment, it's only used in
+    the args attribute of FunctionDef nodes where function signature
+    introspection failed.
+    """
+
+    name = "Unknown"
+
+    def qname(self):
+        return "Unknown"
+
+    def _infer(self, context=None, **kwargs):
+        """Inference on an Unknown node immediately terminates."""
+        yield util.Uninferable
+
+
+class EvaluatedObject(NodeNG):
+    """Contains an object that has already been inferred
+
+    This class is useful to pre-evaluate a particular node,
+    with the resulting class acting as the non-evaluated node.
+    """
+
+    name = "EvaluatedObject"
+    _astroid_fields = ("original",)
+    _other_fields = ("value",)
+
+    def __init__(
+        self, original: NodeNG, value: Union[NodeNG, Type[util.Uninferable]]
+    ) -> None:
+        self.original: NodeNG = original
+        """The original node that has already been evaluated"""
+
+        self.value: Union[NodeNG, Type[util.Uninferable]] = value
+        """The inferred value"""
+
+        super().__init__(
+            lineno=self.original.lineno,
+            col_offset=self.original.col_offset,
+            parent=self.original.parent,
+        )
+
+    def infer(self, context=None, **kwargs):
+        yield self.value
+
+
+# Pattern matching #######################################################
+
+
+class Match(Statement):
+    """Class representing a :class:`ast.Match` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    match x:
+        case 200:
+            ...
+        case _:
+            ...
+    ''')
+    >>> node
+    <Match l.2 at 0x10c24e170>
+    """
+
+    _astroid_fields = ("subject", "cases")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        self.subject: NodeNG
+        self.cases: typing.List["MatchCase"]
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        *,
+        subject: NodeNG,
+        cases: typing.List["MatchCase"],
+    ) -> None:
+        self.subject = subject
+        self.cases = cases
+
+
+class Pattern(NodeNG):
+    """Base class for all Pattern nodes."""
+
+
+class MatchCase(mixins.MultiLineBlockMixin, NodeNG):
+    """Class representing a :class:`ast.match_case` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    match x:
+        case 200:
+            ...
+    ''')
+    >>> node.cases[0]
+    <MatchCase l.3 at 0x10c24e590>
+    """
+
+    _astroid_fields = ("pattern", "guard", "body")
+    _multi_line_block_fields = ("body",)
+
+    lineno: None
+    col_offset: None
+    end_lineno: None
+    end_col_offset: None
+
+    def __init__(self, *, parent: Optional[NodeNG] = None) -> None:
+        self.pattern: Pattern
+        self.guard: Optional[NodeNG]
+        self.body: typing.List[NodeNG]
+        super().__init__(parent=parent)
+
+    def postinit(
+        self,
+        *,
+        pattern: Pattern,
+        guard: Optional[NodeNG],
+        body: typing.List[NodeNG],
+    ) -> None:
+        self.pattern = pattern
+        self.guard = guard
+        self.body = body
+
+
+class MatchValue(Pattern):
+    """Class representing a :class:`ast.MatchValue` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    match x:
+        case 200:
+            ...
+    ''')
+    >>> node.cases[0].pattern
+    <MatchValue l.3 at 0x10c24e200>
+    """
+
+    _astroid_fields = ("value",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        self.value: NodeNG
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, *, value: NodeNG) -> None:
+        self.value = value
+
+
+class MatchSingleton(Pattern):
+    """Class representing a :class:`ast.MatchSingleton` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    match x:
+        case True:
+            ...
+        case False:
+            ...
+        case None:
+            ...
+    ''')
+    >>> node.cases[0].pattern
+    <MatchSingleton l.3 at 0x10c2282e0>
+    >>> node.cases[1].pattern
+    <MatchSingleton l.5 at 0x10c228af0>
+    >>> node.cases[2].pattern
+    <MatchSingleton l.7 at 0x10c229f90>
+    """
+
+    _other_fields = ("value",)
+
+    def __init__(
+        self,
+        *,
+        value: Literal[True, False, None],
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+    ) -> None:
+        self.value = value
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+
+class MatchSequence(Pattern):
+    """Class representing a :class:`ast.MatchSequence` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    match x:
+        case [1, 2]:
+            ...
+        case (1, 2, *_):
+            ...
+    ''')
+    >>> node.cases[0].pattern
+    <MatchSequence l.3 at 0x10ca80d00>
+    >>> node.cases[1].pattern
+    <MatchSequence l.5 at 0x10ca80b20>
+    """
+
+    _astroid_fields = ("patterns",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        self.patterns: typing.List[Pattern]
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, *, patterns: typing.List[Pattern]) -> None:
+        self.patterns = patterns
+
+
+class MatchMapping(mixins.AssignTypeMixin, Pattern):
+    """Class representing a :class:`ast.MatchMapping` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    match x:
+        case {1: "Hello", 2: "World", 3: _, **rest}:
+            ...
+    ''')
+    >>> node.cases[0].pattern
+    <MatchMapping l.3 at 0x10c8a8850>
+    """
+
+    _astroid_fields = ("keys", "patterns", "rest")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        self.keys: typing.List[NodeNG]
+        self.patterns: typing.List[Pattern]
+        self.rest: Optional[AssignName]
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        *,
+        keys: typing.List[NodeNG],
+        patterns: typing.List[Pattern],
+        rest: Optional[AssignName],
+    ) -> None:
+        self.keys = keys
+        self.patterns = patterns
+        self.rest = rest
+
+    assigned_stmts: ClassVar[
+        Callable[
+            [
+                "MatchMapping",
+                AssignName,
+                Optional[InferenceContext],
+                None,
+            ],
+            Generator[NodeNG, None, None],
+        ]
+    ]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+
+class MatchClass(Pattern):
+    """Class representing a :class:`ast.MatchClass` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    match x:
+        case Point2D(0, 0):
+            ...
+        case Point3D(x=0, y=0, z=0):
+            ...
+    ''')
+    >>> node.cases[0].pattern
+    <MatchClass l.3 at 0x10ca83940>
+    >>> node.cases[1].pattern
+    <MatchClass l.5 at 0x10ca80880>
+    """
+
+    _astroid_fields = ("cls", "patterns", "kwd_patterns")
+    _other_fields = ("kwd_attrs",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        self.cls: NodeNG
+        self.patterns: typing.List[Pattern]
+        self.kwd_attrs: typing.List[str]
+        self.kwd_patterns: typing.List[Pattern]
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        *,
+        cls: NodeNG,
+        patterns: typing.List[Pattern],
+        kwd_attrs: typing.List[str],
+        kwd_patterns: typing.List[Pattern],
+    ) -> None:
+        self.cls = cls
+        self.patterns = patterns
+        self.kwd_attrs = kwd_attrs
+        self.kwd_patterns = kwd_patterns
+
+
+class MatchStar(mixins.AssignTypeMixin, Pattern):
+    """Class representing a :class:`ast.MatchStar` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    match x:
+        case [1, *_]:
+            ...
+    ''')
+    >>> node.cases[0].pattern.patterns[1]
+    <MatchStar l.3 at 0x10ca809a0>
+    """
+
+    _astroid_fields = ("name",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        self.name: Optional[AssignName]
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, *, name: Optional[AssignName]) -> None:
+        self.name = name
+
+    assigned_stmts: ClassVar[
+        Callable[
+            [
+                "MatchStar",
+                AssignName,
+                Optional[InferenceContext],
+                None,
+            ],
+            Generator[NodeNG, None, None],
+        ]
+    ]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+
+class MatchAs(mixins.AssignTypeMixin, Pattern):
+    """Class representing a :class:`ast.MatchAs` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    match x:
+        case [1, a]:
+            ...
+        case {'key': b}:
+            ...
+        case Point2D(0, 0) as c:
+            ...
+        case d:
+            ...
+    ''')
+    >>> node.cases[0].pattern.patterns[1]
+    <MatchAs l.3 at 0x10d0b2da0>
+    >>> node.cases[1].pattern.patterns[0]
+    <MatchAs l.5 at 0x10d0b2920>
+    >>> node.cases[2].pattern
+    <MatchAs l.7 at 0x10d0b06a0>
+    >>> node.cases[3].pattern
+    <MatchAs l.9 at 0x10d09b880>
+    """
+
+    _astroid_fields = ("pattern", "name")
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        self.pattern: Optional[Pattern]
+        self.name: Optional[AssignName]
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(
+        self,
+        *,
+        pattern: Optional[Pattern],
+        name: Optional[AssignName],
+    ) -> None:
+        self.pattern = pattern
+        self.name = name
+
+    assigned_stmts: ClassVar[
+        Callable[
+            [
+                "MatchAs",
+                AssignName,
+                Optional[InferenceContext],
+                None,
+            ],
+            Generator[NodeNG, None, None],
+        ]
+    ]
+    """Returns the assigned statement (non inferred) according to the assignment type.
+    See astroid/protocols.py for actual implementation.
+    """
+
+
+class MatchOr(Pattern):
+    """Class representing a :class:`ast.MatchOr` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    match x:
+        case 400 | 401 | 402:
+            ...
+    ''')
+    >>> node.cases[0].pattern
+    <MatchOr l.3 at 0x10d0b0b50>
+    """
+
+    _astroid_fields = ("patterns",)
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional[NodeNG] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        self.patterns: typing.List[Pattern]
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, *, patterns: typing.List[Pattern]) -> None:
+        self.patterns = patterns
+
+
+# constants ##############################################################
+
+CONST_CLS = {
+    list: List,
+    tuple: Tuple,
+    dict: Dict,
+    set: Set,
+    type(None): Const,
+    type(NotImplemented): Const,
+    type(...): Const,
+}
+
+
+def _update_const_classes():
+    """update constant classes, so the keys of CONST_CLS can be reused"""
+    klasses = (bool, int, float, complex, str, bytes)
+    for kls in klasses:
+        CONST_CLS[kls] = Const
+
+
+_update_const_classes()
+
+
+def _two_step_initialization(cls, value):
+    instance = cls()
+    instance.postinit(value)
+    return instance
+
+
+def _dict_initialization(cls, value):
+    if isinstance(value, dict):
+        value = tuple(value.items())
+    return _two_step_initialization(cls, value)
+
+
+_CONST_CLS_CONSTRUCTORS = {
+    List: _two_step_initialization,
+    Tuple: _two_step_initialization,
+    Dict: _dict_initialization,
+    Set: _two_step_initialization,
+    Const: lambda cls, value: cls(value),
+}
+
+
+def const_factory(value):
+    """return an astroid node for a python value"""
+    # XXX we should probably be stricter here and only consider stuff in
+    # CONST_CLS or do better treatment: in case where value is not in CONST_CLS,
+    # we should rather recall the builder on this value than returning an empty
+    # node (another option being that const_factory shouldn't be called with something
+    # not in CONST_CLS)
+    assert not isinstance(value, NodeNG)
+
+    # Hack for ignoring elements of a sequence
+    # or a mapping, in order to avoid transforming
+    # each element to an AST. This is fixed in 2.0
+    # and this approach is a temporary hack.
+    if isinstance(value, (list, set, tuple, dict)):
+        elts = []
+    else:
+        elts = value
+
+    try:
+        initializer_cls = CONST_CLS[value.__class__]
+        initializer = _CONST_CLS_CONSTRUCTORS[initializer_cls]
+        return initializer(initializer_cls, elts)
+    except (KeyError, AttributeError):
+        node = EmptyNode()
+        node.object = value
+        return node
diff --git a/myenv/lib/python3.9/site-packages/astroid/nodes/node_ng.py b/myenv/lib/python3.9/site-packages/astroid/nodes/node_ng.py
new file mode 100644
index 0000000..db249af
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/nodes/node_ng.py
@@ -0,0 +1,814 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+import pprint
+import sys
+import typing
+import warnings
+from functools import singledispatch as _singledispatch
+from typing import (
+    TYPE_CHECKING,
+    ClassVar,
+    Iterator,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+
+from astroid import decorators, util
+from astroid.exceptions import (
+    AstroidError,
+    InferenceError,
+    ParentMissingError,
+    StatementMissing,
+    UseInferenceDefault,
+)
+from astroid.manager import AstroidManager
+from astroid.nodes.as_string import AsStringVisitor
+from astroid.nodes.const import OP_PRECEDENCE
+from astroid.nodes.utils import Position
+from astroid.typing import InferFn
+
+if TYPE_CHECKING:
+    from astroid import nodes
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+if sys.version_info >= (3, 8) or TYPE_CHECKING:
+    # pylint: disable-next=ungrouped-imports
+    from functools import cached_property
+else:
+    # pylint: disable-next=ungrouped-imports
+    from astroid.decorators import cachedproperty as cached_property
+
+# Types for 'NodeNG.nodes_of_class()'
+T_Nodes = TypeVar("T_Nodes", bound="NodeNG")
+T_Nodes2 = TypeVar("T_Nodes2", bound="NodeNG")
+T_Nodes3 = TypeVar("T_Nodes3", bound="NodeNG")
+SkipKlassT = Union[None, Type["NodeNG"], Tuple[Type["NodeNG"], ...]]
+
+
+class NodeNG:
+    """A node of the new Abstract Syntax Tree (AST).
+
+    This is the base class for all Astroid node classes.
+    """
+
+    is_statement: ClassVar[bool] = False
+    """Whether this node indicates a statement."""
+    optional_assign: ClassVar[
+        bool
+    ] = False  # True for For (and for Comprehension if py <3.0)
+    """Whether this node optionally assigns a variable.
+
+    This is for loop assignments because loop won't necessarily perform an
+    assignment if the loop has no iterations.
+    This is also the case from comprehensions in Python 2.
+    """
+    is_function: ClassVar[bool] = False  # True for FunctionDef nodes
+    """Whether this node indicates a function."""
+    is_lambda: ClassVar[bool] = False
+
+    # Attributes below are set by the builder module or by raw factories
+    _astroid_fields: ClassVar[typing.Tuple[str, ...]] = ()
+    """Node attributes that contain child nodes.
+
+    This is redefined in most concrete classes.
+    """
+    _other_fields: ClassVar[typing.Tuple[str, ...]] = ()
+    """Node attributes that do not contain child nodes."""
+    _other_other_fields: ClassVar[typing.Tuple[str, ...]] = ()
+    """Attributes that contain AST-dependent fields."""
+    # instance specific inference function infer(node, context)
+    _explicit_inference: Optional[InferFn] = None
+
+    def __init__(
+        self,
+        lineno: Optional[int] = None,
+        col_offset: Optional[int] = None,
+        parent: Optional["NodeNG"] = None,
+        *,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """
+        :param lineno: The line that this node appears on in the source code.
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param end_lineno: The last line this node appears on in the source code.
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        """
+        self.lineno: Optional[int] = lineno
+        """The line that this node appears on in the source code."""
+
+        self.col_offset: Optional[int] = col_offset
+        """The column that this node appears on in the source code."""
+
+        self.parent: Optional["NodeNG"] = parent
+        """The parent node in the syntax tree."""
+
+        self.end_lineno: Optional[int] = end_lineno
+        """The last line this node appears on in the source code."""
+
+        self.end_col_offset: Optional[int] = end_col_offset
+        """The end column this node appears on in the source code.
+        Note: This is after the last symbol.
+        """
+
+        self.position: Optional[Position] = None
+        """Position of keyword(s) and name. Used as fallback for block nodes
+        which might not provide good enough positional information.
+        E.g. ClassDef, FunctionDef.
+        """
+
+    def infer(self, context=None, **kwargs):
+        """Get a generator of the inferred values.
+
+        This is the main entry point to the inference system.
+
+        .. seealso:: :ref:`inference`
+
+        If the instance has some explicit inference function set, it will be
+        called instead of the default interface.
+
+        :returns: The inferred values.
+        :rtype: iterable
+        """
+        if context is not None:
+            context = context.extra_context.get(self, context)
+        if self._explicit_inference is not None:
+            # explicit_inference is not bound, give it self explicitly
+            try:
+                # pylint: disable=not-callable
+                results = list(self._explicit_inference(self, context, **kwargs))
+                if context is not None:
+                    context.nodes_inferred += len(results)
+                yield from results
+                return
+            except UseInferenceDefault:
+                pass
+
+        if not context:
+            # nodes_inferred?
+            yield from self._infer(context=context, **kwargs)
+            return
+
+        key = (self, context.lookupname, context.callcontext, context.boundnode)
+        if key in context.inferred:
+            yield from context.inferred[key]
+            return
+
+        generator = self._infer(context=context, **kwargs)
+        results = []
+
+        # Limit inference amount to help with performance issues with
+        # exponentially exploding possible results.
+        limit = AstroidManager().max_inferable_values
+        for i, result in enumerate(generator):
+            if i >= limit or (context.nodes_inferred > context.max_inferred):
+                uninferable = util.Uninferable
+                results.append(uninferable)
+                yield uninferable
+                break
+            results.append(result)
+            yield result
+            context.nodes_inferred += 1
+
+        # Cache generated results for subsequent inferences of the
+        # same node using the same context
+        context.inferred[key] = tuple(results)
+        return
+
+    def _repr_name(self) -> str:
+        """Get a name for nice representation.
+
+        This is either :attr:`name`, :attr:`attrname`, or the empty string.
+
+        :returns: The nice name.
+        :rtype: str
+        """
+        if all(name not in self._astroid_fields for name in ("name", "attrname")):
+            return getattr(self, "name", "") or getattr(self, "attrname", "")
+        return ""
+
+    def __str__(self) -> str:
+        rname = self._repr_name()
+        cname = type(self).__name__
+        if rname:
+            string = "%(cname)s.%(rname)s(%(fields)s)"
+            alignment = len(cname) + len(rname) + 2
+        else:
+            string = "%(cname)s(%(fields)s)"
+            alignment = len(cname) + 1
+        result = []
+        for field in self._other_fields + self._astroid_fields:
+            value = getattr(self, field)
+            width = 80 - len(field) - alignment
+            lines = pprint.pformat(value, indent=2, width=width).splitlines(True)
+
+            inner = [lines[0]]
+            for line in lines[1:]:
+                inner.append(" " * alignment + line)
+            result.append(f"{field}={''.join(inner)}")
+
+        return string % {
+            "cname": cname,
+            "rname": rname,
+            "fields": (",\n" + " " * alignment).join(result),
+        }
+
+    def __repr__(self) -> str:
+        rname = self._repr_name()
+        if rname:
+            string = "<%(cname)s.%(rname)s l.%(lineno)s at 0x%(id)x>"
+        else:
+            string = "<%(cname)s l.%(lineno)s at 0x%(id)x>"
+        return string % {
+            "cname": type(self).__name__,
+            "rname": rname,
+            "lineno": self.fromlineno,
+            "id": id(self),
+        }
+
+    def accept(self, visitor):
+        """Visit this node using the given visitor."""
+        func = getattr(visitor, "visit_" + self.__class__.__name__.lower())
+        return func(self)
+
+    def get_children(self) -> Iterator["NodeNG"]:
+        """Get the child nodes below this node."""
+        for field in self._astroid_fields:
+            attr = getattr(self, field)
+            if attr is None:
+                continue
+            if isinstance(attr, (list, tuple)):
+                yield from attr
+            else:
+                yield attr
+        yield from ()
+
+    def last_child(self) -> Optional["NodeNG"]:
+        """An optimized version of list(get_children())[-1]"""
+        for field in self._astroid_fields[::-1]:
+            attr = getattr(self, field)
+            if not attr:  # None or empty list / tuple
+                continue
+            if isinstance(attr, (list, tuple)):
+                return attr[-1]
+            return attr
+        return None
+
+    def node_ancestors(self) -> Iterator["NodeNG"]:
+        """Yield parent, grandparent, etc until there are no more."""
+        parent = self.parent
+        while parent is not None:
+            yield parent
+            parent = parent.parent
+
+    def parent_of(self, node):
+        """Check if this node is the parent of the given node.
+
+        :param node: The node to check if it is the child.
+        :type node: NodeNG
+
+        :returns: True if this node is the parent of the given node,
+            False otherwise.
+        :rtype: bool
+        """
+        return any(self is parent for parent in node.node_ancestors())
+
+    @overload
+    def statement(
+        self, *, future: None = ...
+    ) -> Union["nodes.Statement", "nodes.Module"]:
+        ...
+
+    @overload
+    def statement(self, *, future: Literal[True]) -> "nodes.Statement":
+        ...
+
+    def statement(
+        self, *, future: Literal[None, True] = None
+    ) -> Union["nodes.Statement", "nodes.Module"]:
+        """The first parent node, including self, marked as statement node.
+
+        TODO: Deprecate the future parameter and only raise StatementMissing and return
+        nodes.Statement
+
+        :raises AttributeError: If self has no parent attribute
+        :raises StatementMissing: If self has no parent attribute and future is True
+        """
+        if self.is_statement:
+            return cast("nodes.Statement", self)
+        if not self.parent:
+            if future:
+                raise StatementMissing(target=self)
+            warnings.warn(
+                "In astroid 3.0.0 NodeNG.statement() will return either a nodes.Statement "
+                "or raise a StatementMissing exception. AttributeError will no longer be raised. "
+                "This behaviour can already be triggered "
+                "by passing 'future=True' to a statement() call.",
+                DeprecationWarning,
+            )
+            raise AttributeError(f"{self} object has no attribute 'parent'")
+        return self.parent.statement(future=future)
+
+    def frame(
+        self, *, future: Literal[None, True] = None
+    ) -> Union["nodes.FunctionDef", "nodes.Module", "nodes.ClassDef", "nodes.Lambda"]:
+        """The first parent frame node.
+
+        A frame node is a :class:`Module`, :class:`FunctionDef`,
+        :class:`ClassDef` or :class:`Lambda`.
+
+        :returns: The first parent frame node.
+        """
+        if self.parent is None:
+            if future:
+                raise ParentMissingError(target=self)
+            warnings.warn(
+                "In astroid 3.0.0 NodeNG.frame() will return either a Frame node, "
+                "or raise ParentMissingError. AttributeError will no longer be raised. "
+                "This behaviour can already be triggered "
+                "by passing 'future=True' to a frame() call.",
+                DeprecationWarning,
+            )
+            raise AttributeError(f"{self} object has no attribute 'parent'")
+
+        return self.parent.frame(future=future)
+
+    def scope(self) -> "nodes.LocalsDictNodeNG":
+        """The first parent node defining a new scope.
+        These can be Module, FunctionDef, ClassDef, Lambda, or GeneratorExp nodes.
+
+        :returns: The first parent scope node.
+        """
+        if not self.parent:
+            raise ParentMissingError(target=self)
+        return self.parent.scope()
+
+    def root(self):
+        """Return the root node of the syntax tree.
+
+        :returns: The root node.
+        :rtype: Module
+        """
+        if self.parent:
+            return self.parent.root()
+        return self
+
+    def child_sequence(self, child):
+        """Search for the sequence that contains this child.
+
+        :param child: The child node to search sequences for.
+        :type child: NodeNG
+
+        :returns: The sequence containing the given child node.
+        :rtype: iterable(NodeNG)
+
+        :raises AstroidError: If no sequence could be found that contains
+            the given child.
+        """
+        for field in self._astroid_fields:
+            node_or_sequence = getattr(self, field)
+            if node_or_sequence is child:
+                return [node_or_sequence]
+            # /!\ compiler.ast Nodes have an __iter__ walking over child nodes
+            if (
+                isinstance(node_or_sequence, (tuple, list))
+                and child in node_or_sequence
+            ):
+                return node_or_sequence
+
+        msg = "Could not find %s in %s's children"
+        raise AstroidError(msg % (repr(child), repr(self)))
+
+    def locate_child(self, child):
+        """Find the field of this node that contains the given child.
+
+        :param child: The child node to search fields for.
+        :type child: NodeNG
+
+        :returns: A tuple of the name of the field that contains the child,
+            and the sequence or node that contains the child node.
+        :rtype: tuple(str, iterable(NodeNG) or NodeNG)
+
+        :raises AstroidError: If no field could be found that contains
+            the given child.
+        """
+        for field in self._astroid_fields:
+            node_or_sequence = getattr(self, field)
+            # /!\ compiler.ast Nodes have an __iter__ walking over child nodes
+            if child is node_or_sequence:
+                return field, child
+            if (
+                isinstance(node_or_sequence, (tuple, list))
+                and child in node_or_sequence
+            ):
+                return field, node_or_sequence
+        msg = "Could not find %s in %s's children"
+        raise AstroidError(msg % (repr(child), repr(self)))
+
+    # FIXME : should we merge child_sequence and locate_child ? locate_child
+    # is only used in are_exclusive, child_sequence one time in pylint.
+
+    def next_sibling(self):
+        """The next sibling statement node.
+
+        :returns: The next sibling statement node.
+        :rtype: NodeNG or None
+        """
+        return self.parent.next_sibling()
+
+    def previous_sibling(self):
+        """The previous sibling statement.
+
+        :returns: The previous sibling statement node.
+        :rtype: NodeNG or None
+        """
+        return self.parent.previous_sibling()
+
+    # these are lazy because they're relatively expensive to compute for every
+    # single node, and they rarely get looked at
+
+    @cached_property
+    def fromlineno(self) -> Optional[int]:
+        """The first line that this node appears on in the source code."""
+        if self.lineno is None:
+            return self._fixed_source_line()
+        return self.lineno
+
+    @cached_property
+    def tolineno(self) -> Optional[int]:
+        """The last line that this node appears on in the source code."""
+        if self.end_lineno is not None:
+            return self.end_lineno
+        if not self._astroid_fields:
+            # can't have children
+            last_child = None
+        else:
+            last_child = self.last_child()
+        if last_child is None:
+            return self.fromlineno
+        return last_child.tolineno
+
+    def _fixed_source_line(self) -> Optional[int]:
+        """Attempt to find the line that this node appears on.
+
+        We need this method since not all nodes have :attr:`lineno` set.
+        """
+        line = self.lineno
+        _node: Optional[NodeNG] = self
+        try:
+            while line is None:
+                _node = next(_node.get_children())
+                line = _node.lineno
+        except StopIteration:
+            _node = self.parent
+            while _node and line is None:
+                line = _node.lineno
+                _node = _node.parent
+        return line
+
+    def block_range(self, lineno):
+        """Get a range from the given line number to where this node ends.
+
+        :param lineno: The line number to start the range at.
+        :type lineno: int
+
+        :returns: The range of line numbers that this node belongs to,
+            starting at the given line number.
+        :rtype: tuple(int, int or None)
+        """
+        return lineno, self.tolineno
+
+    def set_local(self, name, stmt):
+        """Define that the given name is declared in the given statement node.
+
+        This definition is stored on the parent scope node.
+
+        .. seealso:: :meth:`scope`
+
+        :param name: The name that is being defined.
+        :type name: str
+
+        :param stmt: The statement that defines the given name.
+        :type stmt: NodeNG
+        """
+        self.parent.set_local(name, stmt)
+
+    @overload
+    def nodes_of_class(
+        self,
+        klass: Type[T_Nodes],
+        skip_klass: SkipKlassT = None,
+    ) -> Iterator[T_Nodes]:
+        ...
+
+    @overload
+    def nodes_of_class(
+        self,
+        klass: Tuple[Type[T_Nodes], Type[T_Nodes2]],
+        skip_klass: SkipKlassT = None,
+    ) -> Union[Iterator[T_Nodes], Iterator[T_Nodes2]]:
+        ...
+
+    @overload
+    def nodes_of_class(
+        self,
+        klass: Tuple[Type[T_Nodes], Type[T_Nodes2], Type[T_Nodes3]],
+        skip_klass: SkipKlassT = None,
+    ) -> Union[Iterator[T_Nodes], Iterator[T_Nodes2], Iterator[T_Nodes3]]:
+        ...
+
+    @overload
+    def nodes_of_class(
+        self,
+        klass: Tuple[Type[T_Nodes], ...],
+        skip_klass: SkipKlassT = None,
+    ) -> Iterator[T_Nodes]:
+        ...
+
+    def nodes_of_class(  # type: ignore[misc] # mypy doesn't correctly recognize the overloads
+        self,
+        klass: Union[
+            Type[T_Nodes],
+            Tuple[Type[T_Nodes], Type[T_Nodes2]],
+            Tuple[Type[T_Nodes], Type[T_Nodes2], Type[T_Nodes3]],
+            Tuple[Type[T_Nodes], ...],
+        ],
+        skip_klass: SkipKlassT = None,
+    ) -> Union[Iterator[T_Nodes], Iterator[T_Nodes2], Iterator[T_Nodes3]]:
+        """Get the nodes (including this one or below) of the given types.
+
+        :param klass: The types of node to search for.
+
+        :param skip_klass: The types of node to ignore. This is useful to ignore
+            subclasses of :attr:`klass`.
+
+        :returns: The node of the given types.
+        """
+        if isinstance(self, klass):
+            yield self
+
+        if skip_klass is None:
+            for child_node in self.get_children():
+                yield from child_node.nodes_of_class(klass, skip_klass)
+
+            return
+
+        for child_node in self.get_children():
+            if isinstance(child_node, skip_klass):
+                continue
+            yield from child_node.nodes_of_class(klass, skip_klass)
+
+    @decorators.cached
+    def _get_assign_nodes(self):
+        return []
+
+    def _get_name_nodes(self):
+        for child_node in self.get_children():
+            yield from child_node._get_name_nodes()
+
+    def _get_return_nodes_skip_functions(self):
+        yield from ()
+
+    def _get_yield_nodes_skip_lambdas(self):
+        yield from ()
+
+    def _infer_name(self, frame, name):
+        # overridden for ImportFrom, Import, Global, TryExcept and Arguments
+        pass
+
+    def _infer(self, context=None):
+        """we don't know how to resolve a statement by default"""
+        # this method is overridden by most concrete classes
+        raise InferenceError(
+            "No inference function for {node!r}.", node=self, context=context
+        )
+
+    def inferred(self):
+        """Get a list of the inferred values.
+
+        .. seealso:: :ref:`inference`
+
+        :returns: The inferred values.
+        :rtype: list
+        """
+        return list(self.infer())
+
+    def instantiate_class(self):
+        """Instantiate an instance of the defined class.
+
+        .. note::
+
+            On anything other than a :class:`ClassDef` this will return self.
+
+        :returns: An instance of the defined class.
+        :rtype: object
+        """
+        return self
+
+    def has_base(self, node):
+        """Check if this node inherits from the given type.
+
+        :param node: The node defining the base to look for.
+            Usually this is a :class:`Name` node.
+        :type node: NodeNG
+        """
+        return False
+
+    def callable(self):
+        """Whether this node defines something that is callable.
+
+        :returns: True if this defines something that is callable,
+            False otherwise.
+        :rtype: bool
+        """
+        return False
+
+    def eq(self, value):
+        return False
+
+    def as_string(self) -> str:
+        """Get the source code that this node represents."""
+        return AsStringVisitor()(self)
+
+    def repr_tree(
+        self,
+        ids=False,
+        include_linenos=False,
+        ast_state=False,
+        indent="   ",
+        max_depth=0,
+        max_width=80,
+    ) -> str:
+        """Get a string representation of the AST from this node.
+
+        :param ids: If true, includes the ids with the node type names.
+        :type ids: bool
+
+        :param include_linenos: If true, includes the line numbers and
+            column offsets.
+        :type include_linenos: bool
+
+        :param ast_state: If true, includes information derived from
+            the whole AST like local and global variables.
+        :type ast_state: bool
+
+        :param indent: A string to use to indent the output string.
+        :type indent: str
+
+        :param max_depth: If set to a positive integer, won't return
+            nodes deeper than max_depth in the string.
+        :type max_depth: int
+
+        :param max_width: Attempt to format the output string to stay
+            within this number of characters, but can exceed it under some
+            circumstances. Only positive integer values are valid, the default is 80.
+        :type max_width: int
+
+        :returns: The string representation of the AST.
+        :rtype: str
+        """
+
+        @_singledispatch
+        def _repr_tree(node, result, done, cur_indent="", depth=1):
+            """Outputs a representation of a non-tuple/list, non-node that's
+            contained within an AST, including strings.
+            """
+            lines = pprint.pformat(
+                node, width=max(max_width - len(cur_indent), 1)
+            ).splitlines(True)
+            result.append(lines[0])
+            result.extend([cur_indent + line for line in lines[1:]])
+            return len(lines) != 1
+
+        # pylint: disable=unused-variable,useless-suppression; doesn't understand singledispatch
+        @_repr_tree.register(tuple)
+        @_repr_tree.register(list)
+        def _repr_seq(node, result, done, cur_indent="", depth=1):
+            """Outputs a representation of a sequence that's contained within an AST."""
+            cur_indent += indent
+            result.append("[")
+            if not node:
+                broken = False
+            elif len(node) == 1:
+                broken = _repr_tree(node[0], result, done, cur_indent, depth)
+            elif len(node) == 2:
+                broken = _repr_tree(node[0], result, done, cur_indent, depth)
+                if not broken:
+                    result.append(", ")
+                else:
+                    result.append(",\n")
+                    result.append(cur_indent)
+                broken = _repr_tree(node[1], result, done, cur_indent, depth) or broken
+            else:
+                result.append("\n")
+                result.append(cur_indent)
+                for child in node[:-1]:
+                    _repr_tree(child, result, done, cur_indent, depth)
+                    result.append(",\n")
+                    result.append(cur_indent)
+                _repr_tree(node[-1], result, done, cur_indent, depth)
+                broken = True
+            result.append("]")
+            return broken
+
+        # pylint: disable=unused-variable,useless-suppression; doesn't understand singledispatch
+        @_repr_tree.register(NodeNG)
+        def _repr_node(node, result, done, cur_indent="", depth=1):
+            """Outputs a strings representation of an astroid node."""
+            if node in done:
+                result.append(
+                    indent + f"<Recursion on {type(node).__name__} with id={id(node)}"
+                )
+                return False
+            done.add(node)
+
+            if max_depth and depth > max_depth:
+                result.append("...")
+                return False
+            depth += 1
+            cur_indent += indent
+            if ids:
+                result.append(f"{type(node).__name__}<0x{id(node):x}>(\n")
+            else:
+                result.append(f"{type(node).__name__}(")
+            fields = []
+            if include_linenos:
+                fields.extend(("lineno", "col_offset"))
+            fields.extend(node._other_fields)
+            fields.extend(node._astroid_fields)
+            if ast_state:
+                fields.extend(node._other_other_fields)
+            if not fields:
+                broken = False
+            elif len(fields) == 1:
+                result.append(f"{fields[0]}=")
+                broken = _repr_tree(
+                    getattr(node, fields[0]), result, done, cur_indent, depth
+                )
+            else:
+                result.append("\n")
+                result.append(cur_indent)
+                for field in fields[:-1]:
+                    # TODO: Remove this after removal of the 'doc' attribute
+                    if field == "doc":
+                        continue
+                    result.append(f"{field}=")
+                    _repr_tree(getattr(node, field), result, done, cur_indent, depth)
+                    result.append(",\n")
+                    result.append(cur_indent)
+                result.append(f"{fields[-1]}=")
+                _repr_tree(getattr(node, fields[-1]), result, done, cur_indent, depth)
+                broken = True
+            result.append(")")
+            return broken
+
+        result: List[str] = []
+        _repr_tree(self, result, set())
+        return "".join(result)
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        The boolean value of a node can have three
+        possible values:
+
+            * False: For instance, empty data structures,
+              False, empty strings, instances which return
+              explicitly False from the __nonzero__ / __bool__
+              method.
+            * True: Most of constructs are True by default:
+              classes, functions, modules etc
+            * Uninferable: The inference engine is uncertain of the
+              node's value.
+
+        :returns: The boolean value of this node.
+        :rtype: bool or Uninferable
+        """
+        return util.Uninferable
+
+    def op_precedence(self):
+        # Look up by class name or default to highest precedence
+        return OP_PRECEDENCE.get(self.__class__.__name__, len(OP_PRECEDENCE))
+
+    def op_left_associative(self):
+        # Everything is left associative except `**` and IfExp
+        return True
diff --git a/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/__init__.py b/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/__init__.py
new file mode 100644
index 0000000..816bd83
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/__init__.py
@@ -0,0 +1,43 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""This module contains all classes that are considered a "scoped" node and anything related.
+A scope node is a node that opens a new local scope in the language definition:
+Module, ClassDef, FunctionDef (and Lambda, GeneratorExp, DictComp and SetComp to some extent).
+"""
+
+from astroid.nodes.scoped_nodes.mixin import ComprehensionScope, LocalsDictNodeNG
+from astroid.nodes.scoped_nodes.scoped_nodes import (
+    AsyncFunctionDef,
+    ClassDef,
+    DictComp,
+    FunctionDef,
+    GeneratorExp,
+    Lambda,
+    ListComp,
+    Module,
+    SetComp,
+    _is_metaclass,
+    function_to_method,
+    get_wrapping_class,
+)
+from astroid.nodes.scoped_nodes.utils import builtin_lookup
+
+__all__ = (
+    "AsyncFunctionDef",
+    "ClassDef",
+    "ComprehensionScope",
+    "DictComp",
+    "FunctionDef",
+    "GeneratorExp",
+    "Lambda",
+    "ListComp",
+    "LocalsDictNodeNG",
+    "Module",
+    "SetComp",
+    "builtin_lookup",
+    "function_to_method",
+    "get_wrapping_class",
+    "_is_metaclass",
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/mixin.py b/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/mixin.py
new file mode 100644
index 0000000..bb1e76f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/mixin.py
@@ -0,0 +1,171 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""This module contains mixin classes for scoped nodes."""
+
+from typing import TYPE_CHECKING, Dict, List, TypeVar
+
+from astroid.filter_statements import _filter_stmts
+from astroid.nodes import node_classes, scoped_nodes
+from astroid.nodes.scoped_nodes.utils import builtin_lookup
+
+if TYPE_CHECKING:
+    from astroid import nodes
+
+_T = TypeVar("_T")
+
+
+class LocalsDictNodeNG(node_classes.LookupMixIn, node_classes.NodeNG):
+    """this class provides locals handling common to Module, FunctionDef
+    and ClassDef nodes, including a dict like interface for direct access
+    to locals information
+    """
+
+    # attributes below are set by the builder module or by raw factories
+
+    locals: Dict[str, List["nodes.NodeNG"]] = {}
+    """A map of the name of a local variable to the node defining the local."""
+
+    def qname(self):
+        """Get the 'qualified' name of the node.
+
+        For example: module.name, module.class.name ...
+
+        :returns: The qualified name.
+        :rtype: str
+        """
+        # pylint: disable=no-member; github.com/pycqa/astroid/issues/278
+        if self.parent is None:
+            return self.name
+        return f"{self.parent.frame(future=True).qname()}.{self.name}"
+
+    def scope(self: _T) -> _T:
+        """The first parent node defining a new scope.
+
+        :returns: The first parent scope node.
+        :rtype: Module or FunctionDef or ClassDef or Lambda or GenExpr
+        """
+        return self
+
+    def _scope_lookup(self, node, name, offset=0):
+        """XXX method for interfacing the scope lookup"""
+        try:
+            stmts = _filter_stmts(node, self.locals[name], self, offset)
+        except KeyError:
+            stmts = ()
+        if stmts:
+            return self, stmts
+
+        # Handle nested scopes: since class names do not extend to nested
+        # scopes (e.g., methods), we find the next enclosing non-class scope
+        pscope = self.parent and self.parent.scope()
+        while pscope is not None:
+            if not isinstance(pscope, scoped_nodes.ClassDef):
+                return pscope.scope_lookup(node, name)
+            pscope = pscope.parent and pscope.parent.scope()
+
+        # self is at the top level of a module, or is enclosed only by ClassDefs
+        return builtin_lookup(name)
+
+    def set_local(self, name, stmt):
+        """Define that the given name is declared in the given statement node.
+
+        .. seealso:: :meth:`scope`
+
+        :param name: The name that is being defined.
+        :type name: str
+
+        :param stmt: The statement that defines the given name.
+        :type stmt: NodeNG
+        """
+        # assert not stmt in self.locals.get(name, ()), (self, stmt)
+        self.locals.setdefault(name, []).append(stmt)
+
+    __setitem__ = set_local
+
+    def _append_node(self, child):
+        """append a child, linking it in the tree"""
+        # pylint: disable=no-member; depending by the class
+        # which uses the current class as a mixin or base class.
+        # It's rewritten in 2.0, so it makes no sense for now
+        # to spend development time on it.
+        self.body.append(child)
+        child.parent = self
+
+    def add_local_node(self, child_node, name=None):
+        """Append a child that should alter the locals of this scope node.
+
+        :param child_node: The child node that will alter locals.
+        :type child_node: NodeNG
+
+        :param name: The name of the local that will be altered by
+            the given child node.
+        :type name: str or None
+        """
+        if name != "__class__":
+            # add __class__ node as a child will cause infinite recursion later!
+            self._append_node(child_node)
+        self.set_local(name or child_node.name, child_node)
+
+    def __getitem__(self, item: str) -> "nodes.NodeNG":
+        """The first node the defines the given local.
+
+        :param item: The name of the locally defined object.
+
+        :raises KeyError: If the name is not defined.
+        """
+        return self.locals[item][0]
+
+    def __iter__(self):
+        """Iterate over the names of locals defined in this scoped node.
+
+        :returns: The names of the defined locals.
+        :rtype: iterable(str)
+        """
+        return iter(self.keys())
+
+    def keys(self):
+        """The names of locals defined in this scoped node.
+
+        :returns: The names of the defined locals.
+        :rtype: list(str)
+        """
+        return list(self.locals.keys())
+
+    def values(self):
+        """The nodes that define the locals in this scoped node.
+
+        :returns: The nodes that define locals.
+        :rtype: list(NodeNG)
+        """
+        # pylint: disable=consider-using-dict-items
+        # It look like this class override items/keys/values,
+        # probably not worth the headache
+        return [self[key] for key in self.keys()]
+
+    def items(self):
+        """Get the names of the locals and the node that defines the local.
+
+        :returns: The names of locals and their associated node.
+        :rtype: list(tuple(str, NodeNG))
+        """
+        return list(zip(self.keys(), self.values()))
+
+    def __contains__(self, name):
+        """Check if a local is defined in this scope.
+
+        :param name: The name of the local to check for.
+        :type name: str
+
+        :returns: True if this node has a local of the given name,
+            False otherwise.
+        :rtype: bool
+        """
+        return name in self.locals
+
+
+class ComprehensionScope(LocalsDictNodeNG):
+    """Scoping for different types of comprehensions."""
+
+    scope_lookup = LocalsDictNodeNG._scope_lookup
diff --git a/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/scoped_nodes.py b/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/scoped_nodes.py
new file mode 100644
index 0000000..b3358d9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/scoped_nodes.py
@@ -0,0 +1,3122 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""
+This module contains the classes for "scoped" node, i.e. which are opening a
+new local scope in the language definition : Module, ClassDef, FunctionDef (and
+Lambda, GeneratorExp, DictComp and SetComp to some extent).
+"""
+import io
+import itertools
+import os
+import sys
+import typing
+import warnings
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, TypeVar, Union, overload
+
+from astroid import bases
+from astroid import decorators as decorators_mod
+from astroid import mixins, util
+from astroid.const import IS_PYPY, PY38, PY38_PLUS, PY39_PLUS
+from astroid.context import (
+    CallContext,
+    InferenceContext,
+    bind_context_to_node,
+    copy_context,
+)
+from astroid.exceptions import (
+    AstroidBuildingError,
+    AstroidTypeError,
+    AttributeInferenceError,
+    DuplicateBasesError,
+    InconsistentMroError,
+    InferenceError,
+    MroError,
+    StatementMissing,
+    TooManyLevelsError,
+)
+from astroid.interpreter.dunder_lookup import lookup
+from astroid.interpreter.objectmodel import ClassModel, FunctionModel, ModuleModel
+from astroid.manager import AstroidManager
+from astroid.nodes import Arguments, Const, NodeNG, node_classes
+from astroid.nodes.scoped_nodes.mixin import ComprehensionScope, LocalsDictNodeNG
+from astroid.nodes.scoped_nodes.utils import builtin_lookup
+from astroid.nodes.utils import Position
+
+if sys.version_info >= (3, 6, 2):
+    from typing import NoReturn
+else:
+    from typing_extensions import NoReturn
+
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+if sys.version_info >= (3, 8) or TYPE_CHECKING:
+    from functools import cached_property
+else:
+    # pylint: disable-next=ungrouped-imports
+    from astroid.decorators import cachedproperty as cached_property
+
+
+ITER_METHODS = ("__iter__", "__getitem__")
+EXCEPTION_BASE_CLASSES = frozenset({"Exception", "BaseException"})
+objects = util.lazy_import("objects")
+BUILTIN_DESCRIPTORS = frozenset(
+    {"classmethod", "staticmethod", "builtins.classmethod", "builtins.staticmethod"}
+)
+
+T = TypeVar("T")
+
+
+def _c3_merge(sequences, cls, context):
+    """Merges MROs in *sequences* to a single MRO using the C3 algorithm.
+
+    Adapted from http://www.python.org/download/releases/2.3/mro/.
+
+    """
+    result = []
+    while True:
+        sequences = [s for s in sequences if s]  # purge empty sequences
+        if not sequences:
+            return result
+        for s1 in sequences:  # find merge candidates among seq heads
+            candidate = s1[0]
+            for s2 in sequences:
+                if candidate in s2[1:]:
+                    candidate = None
+                    break  # reject the current head, it appears later
+            else:
+                break
+        if not candidate:
+            # Show all the remaining bases, which were considered as
+            # candidates for the next mro sequence.
+            raise InconsistentMroError(
+                message="Cannot create a consistent method resolution order "
+                "for MROs {mros} of class {cls!r}.",
+                mros=sequences,
+                cls=cls,
+                context=context,
+            )
+
+        result.append(candidate)
+        # remove the chosen candidate
+        for seq in sequences:
+            if seq[0] == candidate:
+                del seq[0]
+    return None
+
+
+def clean_typing_generic_mro(sequences: List[List["ClassDef"]]) -> None:
+    """A class can inherit from typing.Generic directly, as base,
+    and as base of bases. The merged MRO must however only contain the last entry.
+    To prepare for _c3_merge, remove some typing.Generic entries from
+    sequences if multiple are present.
+
+    This method will check if Generic is in inferred_bases and also
+    part of bases_mro. If true, remove it from inferred_bases
+    as well as its entry the bases_mro.
+
+    Format sequences: [[self]] + bases_mro + [inferred_bases]
+    """
+    bases_mro = sequences[1:-1]
+    inferred_bases = sequences[-1]
+    # Check if Generic is part of inferred_bases
+    for i, base in enumerate(inferred_bases):
+        if base.qname() == "typing.Generic":
+            position_in_inferred_bases = i
+            break
+    else:
+        return
+    # Check if also part of bases_mro
+    # Ignore entry for typing.Generic
+    for i, seq in enumerate(bases_mro):
+        if i == position_in_inferred_bases:
+            continue
+        if any(base.qname() == "typing.Generic" for base in seq):
+            break
+    else:
+        return
+    # Found multiple Generics in mro, remove entry from inferred_bases
+    # and the corresponding one from bases_mro
+    inferred_bases.pop(position_in_inferred_bases)
+    bases_mro.pop(position_in_inferred_bases)
+
+
+def clean_duplicates_mro(sequences, cls, context):
+    for sequence in sequences:
+        names = [
+            (node.lineno, node.qname()) if node.name else None for node in sequence
+        ]
+        last_index = dict(map(reversed, enumerate(names)))
+        if names and names[0] is not None and last_index[names[0]] != 0:
+            raise DuplicateBasesError(
+                message="Duplicates found in MROs {mros} for {cls!r}.",
+                mros=sequences,
+                cls=cls,
+                context=context,
+            )
+        yield [
+            node
+            for i, (node, name) in enumerate(zip(sequence, names))
+            if name is None or last_index[name] == i
+        ]
+
+
+def function_to_method(n, klass):
+    if isinstance(n, FunctionDef):
+        if n.type == "classmethod":
+            return bases.BoundMethod(n, klass)
+        if n.type == "property":
+            return n
+        if n.type != "staticmethod":
+            return bases.UnboundMethod(n)
+    return n
+
+
+class Module(LocalsDictNodeNG):
+    """Class representing an :class:`ast.Module` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('import astroid')
+    >>> node
+    <Import l.1 at 0x7f23b2e4e5c0>
+    >>> node.parent
+    <Module l.0 at 0x7f23b2e4eda0>
+    """
+
+    _astroid_fields = ("doc_node", "body")
+
+    fromlineno: Literal[0] = 0
+    """The first line that this node appears on in the source code."""
+
+    lineno: Literal[0] = 0
+    """The line that this node appears on in the source code."""
+
+    # attributes below are set by the builder module or by raw factories
+
+    file_bytes: Union[str, bytes, None] = None
+    """The string/bytes that this ast was built from."""
+
+    file_encoding: Optional[str] = None
+    """The encoding of the source file.
+
+    This is used to get unicode out of a source file.
+    Python 2 only.
+    """
+
+    special_attributes = ModuleModel()
+    """The names of special attributes that this module has."""
+
+    # names of module attributes available through the global scope
+    scope_attrs = {"__name__", "__doc__", "__file__", "__path__", "__package__"}
+    """The names of module attributes available through the global scope."""
+
+    _other_fields = (
+        "name",
+        "doc",
+        "file",
+        "path",
+        "package",
+        "pure_python",
+        "future_imports",
+    )
+    _other_other_fields = ("locals", "globals")
+
+    col_offset: None
+    end_lineno: None
+    end_col_offset: None
+    parent: None
+
+    @decorators_mod.deprecate_arguments(doc="Use the postinit arg 'doc_node' instead")
+    def __init__(
+        self,
+        name: str,
+        doc: Optional[str] = None,
+        file: Optional[str] = None,
+        path: Optional[List[str]] = None,
+        package: Optional[bool] = None,
+        parent: None = None,
+        pure_python: Optional[bool] = True,
+    ) -> None:
+        """
+        :param name: The name of the module.
+
+        :param doc: The module docstring.
+
+        :param file: The path to the file that this ast has been extracted from.
+
+        :param path:
+
+        :param package: Whether the node represents a package or a module.
+
+        :param parent: The parent node in the syntax tree.
+
+        :param pure_python: Whether the ast was built from source.
+        """
+        self.name = name
+        """The name of the module."""
+
+        self._doc = doc
+        """The module docstring."""
+
+        self.file = file
+        """The path to the file that this ast has been extracted from.
+
+        This will be ``None`` when the representation has been built from a
+        built-in module.
+        """
+
+        self.path = path
+
+        self.package = package
+        """Whether the node represents a package or a module."""
+
+        self.pure_python = pure_python
+        """Whether the ast was built from source."""
+
+        self.globals: Dict[str, List[node_classes.NodeNG]]
+        """A map of the name of a global variable to the node defining the global."""
+
+        self.locals = self.globals = {}
+        """A map of the name of a local variable to the node defining the local."""
+
+        self.body: Optional[List[node_classes.NodeNG]] = []
+        """The contents of the module."""
+
+        self.doc_node: Optional[Const] = None
+        """The doc node associated with this node."""
+
+        self.future_imports: Set[str] = set()
+        """The imports from ``__future__``."""
+
+        super().__init__(lineno=0, parent=parent)
+
+    # pylint: enable=redefined-builtin
+
+    def postinit(self, body=None, *, doc_node: Optional[Const] = None):
+        """Do some setup after initialisation.
+
+        :param body: The contents of the module.
+        :type body: list(NodeNG) or None
+        :param doc_node: The doc node associated with this node.
+        """
+        self.body = body
+        self.doc_node = doc_node
+        if doc_node:
+            self._doc = doc_node.value
+
+    @property
+    def doc(self) -> Optional[str]:
+        """The module docstring."""
+        warnings.warn(
+            "The 'Module.doc' attribute is deprecated, "
+            "use 'Module.doc_node' instead.",
+            DeprecationWarning,
+        )
+        return self._doc
+
+    @doc.setter
+    def doc(self, value: Optional[str]) -> None:
+        warnings.warn(
+            "Setting the 'Module.doc' attribute is deprecated, "
+            "use 'Module.doc_node' instead.",
+            DeprecationWarning,
+        )
+        self._doc = value
+
+    def _get_stream(self):
+        if self.file_bytes is not None:
+            return io.BytesIO(self.file_bytes)
+        if self.file is not None:
+            # pylint: disable=consider-using-with
+            stream = open(self.file, "rb")
+            return stream
+        return None
+
+    def stream(self):
+        """Get a stream to the underlying file or bytes.
+
+        :type: file or io.BytesIO or None
+        """
+        return self._get_stream()
+
+    def block_range(self, lineno):
+        """Get a range from where this node starts to where this node ends.
+
+        :param lineno: Unused.
+        :type lineno: int
+
+        :returns: The range of line numbers that this node belongs to.
+        :rtype: tuple(int, int)
+        """
+        return self.fromlineno, self.tolineno
+
+    def scope_lookup(self, node, name, offset=0):
+        """Lookup where the given variable is assigned.
+
+        :param node: The node to look for assignments up to.
+            Any assignments after the given node are ignored.
+        :type node: NodeNG
+
+        :param name: The name of the variable to find assignments for.
+        :type name: str
+
+        :param offset: The line offset to filter statements up to.
+        :type offset: int
+
+        :returns: This scope node and the list of assignments associated to the
+            given name according to the scope where it has been found (locals,
+            globals or builtin).
+        :rtype: tuple(str, list(NodeNG))
+        """
+        if name in self.scope_attrs and name not in self.locals:
+            try:
+                return self, self.getattr(name)
+            except AttributeInferenceError:
+                return self, ()
+        return self._scope_lookup(node, name, offset)
+
+    def pytype(self):
+        """Get the name of the type that this node represents.
+
+        :returns: The name of the type.
+        :rtype: str
+        """
+        return "builtins.module"
+
+    def display_type(self):
+        """A human readable type of this node.
+
+        :returns: The type of this node.
+        :rtype: str
+        """
+        return "Module"
+
+    def getattr(self, name, context=None, ignore_locals=False):
+        if not name:
+            raise AttributeInferenceError(target=self, attribute=name, context=context)
+
+        result = []
+        name_in_locals = name in self.locals
+
+        if name in self.special_attributes and not ignore_locals and not name_in_locals:
+            result = [self.special_attributes.lookup(name)]
+        elif not ignore_locals and name_in_locals:
+            result = self.locals[name]
+        elif self.package:
+            try:
+                result = [self.import_module(name, relative_only=True)]
+            except (AstroidBuildingError, SyntaxError) as exc:
+                raise AttributeInferenceError(
+                    target=self, attribute=name, context=context
+                ) from exc
+        result = [n for n in result if not isinstance(n, node_classes.DelName)]
+        if result:
+            return result
+        raise AttributeInferenceError(target=self, attribute=name, context=context)
+
+    def igetattr(self, name, context=None):
+        """Infer the possible values of the given variable.
+
+        :param name: The name of the variable to infer.
+        :type name: str
+
+        :returns: The inferred possible values.
+        :rtype: iterable(NodeNG) or None
+        """
+        # set lookup name since this is necessary to infer on import nodes for
+        # instance
+        context = copy_context(context)
+        context.lookupname = name
+        try:
+            return bases._infer_stmts(self.getattr(name, context), context, frame=self)
+        except AttributeInferenceError as error:
+            raise InferenceError(
+                str(error), target=self, attribute=name, context=context
+            ) from error
+
+    def fully_defined(self):
+        """Check if this module has been build from a .py file.
+
+        If so, the module contains a complete representation,
+        including the code.
+
+        :returns: True if the module has been built from a .py file.
+        :rtype: bool
+        """
+        return self.file is not None and self.file.endswith(".py")
+
+    @overload
+    def statement(self, *, future: None = ...) -> "Module":
+        ...
+
+    @overload
+    def statement(self, *, future: Literal[True]) -> NoReturn:
+        ...
+
+    def statement(
+        self, *, future: Literal[None, True] = None
+    ) -> Union["NoReturn", "Module"]:
+        """The first parent node, including self, marked as statement node.
+
+        When called on a :class:`Module` with the future parameter this raises an error.
+
+        TODO: Deprecate the future parameter and only raise StatementMissing
+
+        :raises StatementMissing: If no self has no parent attribute and future is True
+        """
+        if future:
+            raise StatementMissing(target=self)
+        warnings.warn(
+            "In astroid 3.0.0 NodeNG.statement() will return either a nodes.Statement "
+            "or raise a StatementMissing exception. nodes.Module will no longer be "
+            "considered a statement. This behaviour can already be triggered "
+            "by passing 'future=True' to a statement() call.",
+            DeprecationWarning,
+        )
+        return self
+
+    def previous_sibling(self):
+        """The previous sibling statement.
+
+        :returns: The previous sibling statement node.
+        :rtype: NodeNG or None
+        """
+
+    def next_sibling(self):
+        """The next sibling statement node.
+
+        :returns: The next sibling statement node.
+        :rtype: NodeNG or None
+        """
+
+    _absolute_import_activated = True
+
+    def absolute_import_activated(self):
+        """Whether :pep:`328` absolute import behaviour has been enabled.
+
+        :returns: True if :pep:`328` has been enabled, False otherwise.
+        :rtype: bool
+        """
+        return self._absolute_import_activated
+
+    def import_module(self, modname, relative_only=False, level=None):
+        """Get the ast for a given module as if imported from this module.
+
+        :param modname: The name of the module to "import".
+        :type modname: str
+
+        :param relative_only: Whether to only consider relative imports.
+        :type relative_only: bool
+
+        :param level: The level of relative import.
+        :type level: int or None
+
+        :returns: The imported module ast.
+        :rtype: NodeNG
+        """
+        if relative_only and level is None:
+            level = 0
+        absmodname = self.relative_to_absolute_name(modname, level)
+
+        try:
+            return AstroidManager().ast_from_module_name(absmodname)
+        except AstroidBuildingError:
+            # we only want to import a sub module or package of this module,
+            # skip here
+            if relative_only:
+                raise
+        return AstroidManager().ast_from_module_name(modname)
+
+    def relative_to_absolute_name(self, modname: str, level: int) -> str:
+        """Get the absolute module name for a relative import.
+
+        The relative import can be implicit or explicit.
+
+        :param modname: The module name to convert.
+
+        :param level: The level of relative import.
+
+        :returns: The absolute module name.
+
+        :raises TooManyLevelsError: When the relative import refers to a
+            module too far above this one.
+        """
+        # XXX this returns non sens when called on an absolute import
+        # like 'pylint.checkers.astroid.utils'
+        # XXX doesn't return absolute name if self.name isn't absolute name
+        if self.absolute_import_activated() and level is None:
+            return modname
+        if level:
+            if self.package:
+                level = level - 1
+                package_name = self.name.rsplit(".", level)[0]
+            elif (
+                self.path
+                and not os.path.exists(os.path.dirname(self.path[0]) + "/__init__.py")
+                and os.path.exists(
+                    os.path.dirname(self.path[0]) + "/" + modname.split(".")[0]
+                )
+            ):
+                level = level - 1
+                package_name = ""
+            else:
+                package_name = self.name.rsplit(".", level)[0]
+            if level and self.name.count(".") < level:
+                raise TooManyLevelsError(level=level, name=self.name)
+
+        elif self.package:
+            package_name = self.name
+        else:
+            package_name = self.name.rsplit(".", 1)[0]
+
+        if package_name:
+            if not modname:
+                return package_name
+            return f"{package_name}.{modname}"
+        return modname
+
+    def wildcard_import_names(self):
+        """The list of imported names when this module is 'wildcard imported'.
+
+        It doesn't include the '__builtins__' name which is added by the
+        current CPython implementation of wildcard imports.
+
+        :returns: The list of imported names.
+        :rtype: list(str)
+        """
+        # We separate the different steps of lookup in try/excepts
+        # to avoid catching too many Exceptions
+        default = [name for name in self.keys() if not name.startswith("_")]
+        try:
+            all_values = self["__all__"]
+        except KeyError:
+            return default
+
+        try:
+            explicit = next(all_values.assigned_stmts())
+        except (InferenceError, StopIteration):
+            return default
+        except AttributeError:
+            # not an assignment node
+            # XXX infer?
+            return default
+
+        # Try our best to detect the exported name.
+        inferred = []
+        try:
+            explicit = next(explicit.infer())
+        except (InferenceError, StopIteration):
+            return default
+        if not isinstance(explicit, (node_classes.Tuple, node_classes.List)):
+            return default
+
+        def str_const(node):
+            return isinstance(node, node_classes.Const) and isinstance(node.value, str)
+
+        for node in explicit.elts:
+            if str_const(node):
+                inferred.append(node.value)
+            else:
+                try:
+                    inferred_node = next(node.infer())
+                except (InferenceError, StopIteration):
+                    continue
+                if str_const(inferred_node):
+                    inferred.append(inferred_node.value)
+        return inferred
+
+    def public_names(self):
+        """The list of the names that are publicly available in this module.
+
+        :returns: The list of public names.
+        :rtype: list(str)
+        """
+        return [name for name in self.keys() if not name.startswith("_")]
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        :returns: The boolean value of this node.
+            For a :class:`Module` this is always ``True``.
+        :rtype: bool
+        """
+        return True
+
+    def get_children(self):
+        yield from self.body
+
+    def frame(self: T, *, future: Literal[None, True] = None) -> T:
+        """The node's frame node.
+
+        A frame node is a :class:`Module`, :class:`FunctionDef`,
+        :class:`ClassDef` or :class:`Lambda`.
+
+        :returns: The node itself.
+        """
+        return self
+
+
+class GeneratorExp(ComprehensionScope):
+    """Class representing an :class:`ast.GeneratorExp` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('(thing for thing in things if thing)')
+    >>> node
+    <GeneratorExp l.1 at 0x7f23b2e4e400>
+    """
+
+    _astroid_fields = ("elt", "generators")
+    _other_other_fields = ("locals",)
+    elt = None
+    """The element that forms the output of the expression.
+
+    :type: NodeNG or None
+    """
+    generators = None
+    """The generators that are looped through.
+
+    :type: list(Comprehension) or None
+    """
+
+    def __init__(
+        self,
+        lineno=None,
+        col_offset=None,
+        parent=None,
+        *,
+        end_lineno=None,
+        end_col_offset=None,
+    ):
+        """
+        :param lineno: The line that this node appears on in the source code.
+        :type lineno: int or None
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+        :type col_offset: int or None
+
+        :param parent: The parent node in the syntax tree.
+        :type parent: NodeNG or None
+
+        :param end_lineno: The last line this node appears on in the source code.
+        :type end_lineno: Optional[int]
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        :type end_col_offset: Optional[int]
+        """
+        self.locals = {}
+        """A map of the name of a local variable to the node defining the local.
+
+        :type: dict(str, NodeNG)
+        """
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, elt=None, generators=None):
+        """Do some setup after initialisation.
+
+        :param elt: The element that forms the output of the expression.
+        :type elt: NodeNG or None
+
+        :param generators: The generators that are looped through.
+        :type generators: list(Comprehension) or None
+        """
+        self.elt = elt
+        if generators is None:
+            self.generators = []
+        else:
+            self.generators = generators
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        :returns: The boolean value of this node.
+            For a :class:`GeneratorExp` this is always ``True``.
+        :rtype: bool
+        """
+        return True
+
+    def get_children(self):
+        yield self.elt
+
+        yield from self.generators
+
+
+class DictComp(ComprehensionScope):
+    """Class representing an :class:`ast.DictComp` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('{k:v for k, v in things if k > v}')
+    >>> node
+    <DictComp l.1 at 0x7f23b2e41d68>
+    """
+
+    _astroid_fields = ("key", "value", "generators")
+    _other_other_fields = ("locals",)
+    key = None
+    """What produces the keys.
+
+    :type: NodeNG or None
+    """
+    value = None
+    """What produces the values.
+
+    :type: NodeNG or None
+    """
+    generators = None
+    """The generators that are looped through.
+
+    :type: list(Comprehension) or None
+    """
+
+    def __init__(
+        self,
+        lineno=None,
+        col_offset=None,
+        parent=None,
+        *,
+        end_lineno=None,
+        end_col_offset=None,
+    ):
+        """
+        :param lineno: The line that this node appears on in the source code.
+        :type lineno: int or None
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+        :type col_offset: int or None
+
+        :param parent: The parent node in the syntax tree.
+        :type parent: NodeNG or None
+
+        :param end_lineno: The last line this node appears on in the source code.
+        :type end_lineno: Optional[int]
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        :type end_col_offset: Optional[int]
+        """
+        self.locals = {}
+        """A map of the name of a local variable to the node defining the local.
+
+        :type: dict(str, NodeNG)
+        """
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, key=None, value=None, generators=None):
+        """Do some setup after initialisation.
+
+        :param key: What produces the keys.
+        :type key: NodeNG or None
+
+        :param value: What produces the values.
+        :type value: NodeNG or None
+
+        :param generators: The generators that are looped through.
+        :type generators: list(Comprehension) or None
+        """
+        self.key = key
+        self.value = value
+        if generators is None:
+            self.generators = []
+        else:
+            self.generators = generators
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        :returns: The boolean value of this node.
+            For a :class:`DictComp` this is always :class:`Uninferable`.
+        :rtype: Uninferable
+        """
+        return util.Uninferable
+
+    def get_children(self):
+        yield self.key
+        yield self.value
+
+        yield from self.generators
+
+
+class SetComp(ComprehensionScope):
+    """Class representing an :class:`ast.SetComp` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('{thing for thing in things if thing}')
+    >>> node
+    <SetComp l.1 at 0x7f23b2e41898>
+    """
+
+    _astroid_fields = ("elt", "generators")
+    _other_other_fields = ("locals",)
+    elt = None
+    """The element that forms the output of the expression.
+
+    :type: NodeNG or None
+    """
+    generators = None
+    """The generators that are looped through.
+
+    :type: list(Comprehension) or None
+    """
+
+    def __init__(
+        self,
+        lineno=None,
+        col_offset=None,
+        parent=None,
+        *,
+        end_lineno=None,
+        end_col_offset=None,
+    ):
+        """
+        :param lineno: The line that this node appears on in the source code.
+        :type lineno: int or None
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+        :type col_offset: int or None
+
+        :param parent: The parent node in the syntax tree.
+        :type parent: NodeNG or None
+
+        :param end_lineno: The last line this node appears on in the source code.
+        :type end_lineno: Optional[int]
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        :type end_col_offset: Optional[int]
+        """
+        self.locals = {}
+        """A map of the name of a local variable to the node defining the local.
+
+        :type: dict(str, NodeNG)
+        """
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, elt=None, generators=None):
+        """Do some setup after initialisation.
+
+        :param elt: The element that forms the output of the expression.
+        :type elt: NodeNG or None
+
+        :param generators: The generators that are looped through.
+        :type generators: list(Comprehension) or None
+        """
+        self.elt = elt
+        if generators is None:
+            self.generators = []
+        else:
+            self.generators = generators
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        :returns: The boolean value of this node.
+            For a :class:`SetComp` this is always :class:`Uninferable`.
+        :rtype: Uninferable
+        """
+        return util.Uninferable
+
+    def get_children(self):
+        yield self.elt
+
+        yield from self.generators
+
+
+class ListComp(ComprehensionScope):
+    """Class representing an :class:`ast.ListComp` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('[thing for thing in things if thing]')
+    >>> node
+    <ListComp l.1 at 0x7f23b2e418d0>
+    """
+
+    _astroid_fields = ("elt", "generators")
+    _other_other_fields = ("locals",)
+
+    elt = None
+    """The element that forms the output of the expression.
+
+    :type: NodeNG or None
+    """
+
+    generators = None
+    """The generators that are looped through.
+
+    :type: list(Comprehension) or None
+    """
+
+    def __init__(
+        self,
+        lineno=None,
+        col_offset=None,
+        parent=None,
+        *,
+        end_lineno=None,
+        end_col_offset=None,
+    ):
+        self.locals = {}
+        """A map of the name of a local variable to the node defining it.
+
+        :type: dict(str, NodeNG)
+        """
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, elt=None, generators=None):
+        """Do some setup after initialisation.
+
+        :param elt: The element that forms the output of the expression.
+        :type elt: NodeNG or None
+
+        :param generators: The generators that are looped through.
+        :type generators: list(Comprehension) or None
+        """
+        self.elt = elt
+        self.generators = generators
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        :returns: The boolean value of this node.
+            For a :class:`ListComp` this is always :class:`Uninferable`.
+        :rtype: Uninferable
+        """
+        return util.Uninferable
+
+    def get_children(self):
+        yield self.elt
+
+        yield from self.generators
+
+
+def _infer_decorator_callchain(node):
+    """Detect decorator call chaining and see if the end result is a
+    static or a classmethod.
+    """
+    if not isinstance(node, FunctionDef):
+        return None
+    if not node.parent:
+        return None
+    try:
+        result = next(node.infer_call_result(node.parent), None)
+    except InferenceError:
+        return None
+    if isinstance(result, bases.Instance):
+        result = result._proxied
+    if isinstance(result, ClassDef):
+        if result.is_subtype_of("builtins.classmethod"):
+            return "classmethod"
+        if result.is_subtype_of("builtins.staticmethod"):
+            return "staticmethod"
+    if isinstance(result, FunctionDef):
+        if not result.decorators:
+            return None
+        # Determine if this function is decorated with one of the builtin descriptors we want.
+        for decorator in result.decorators.nodes:
+            if isinstance(decorator, node_classes.Name):
+                if decorator.name in BUILTIN_DESCRIPTORS:
+                    return decorator.name
+            if (
+                isinstance(decorator, node_classes.Attribute)
+                and isinstance(decorator.expr, node_classes.Name)
+                and decorator.expr.name == "builtins"
+                and decorator.attrname in BUILTIN_DESCRIPTORS
+            ):
+                return decorator.attrname
+    return None
+
+
+class Lambda(mixins.FilterStmtsMixin, LocalsDictNodeNG):
+    """Class representing an :class:`ast.Lambda` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('lambda arg: arg + 1')
+    >>> node
+    <Lambda.<lambda> l.1 at 0x7f23b2e41518>
+    """
+
+    _astroid_fields = ("args", "body")
+    _other_other_fields = ("locals",)
+    name = "<lambda>"
+    is_lambda = True
+    special_attributes = FunctionModel()
+    """The names of special attributes that this function has."""
+
+    def implicit_parameters(self):
+        return 0
+
+    # function's type, 'function' | 'method' | 'staticmethod' | 'classmethod'
+    @property
+    def type(self):
+        """Whether this is a method or function.
+
+        :returns: 'method' if this is a method, 'function' otherwise.
+        :rtype: str
+        """
+        if self.args.arguments and self.args.arguments[0].name == "self":
+            if isinstance(self.parent.scope(), ClassDef):
+                return "method"
+        return "function"
+
+    def __init__(
+        self,
+        lineno=None,
+        col_offset=None,
+        parent=None,
+        *,
+        end_lineno=None,
+        end_col_offset=None,
+    ):
+        """
+        :param lineno: The line that this node appears on in the source code.
+        :type lineno: int or None
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+        :type col_offset: int or None
+
+        :param parent: The parent node in the syntax tree.
+        :type parent: NodeNG or None
+
+        :param end_lineno: The last line this node appears on in the source code.
+        :type end_lineno: Optional[int]
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        :type end_col_offset: Optional[int]
+        """
+        self.locals = {}
+        """A map of the name of a local variable to the node defining it.
+
+        :type: dict(str, NodeNG)
+        """
+
+        self.args: Arguments
+        """The arguments that the function takes."""
+
+        self.body = []
+        """The contents of the function body.
+
+        :type: list(NodeNG)
+        """
+
+        self.instance_attrs: Dict[str, List[NodeNG]] = {}
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+
+    def postinit(self, args: Arguments, body):
+        """Do some setup after initialisation.
+
+        :param args: The arguments that the function takes.
+
+        :param body: The contents of the function body.
+        :type body: list(NodeNG)
+        """
+        self.args = args
+        self.body = body
+
+    def pytype(self):
+        """Get the name of the type that this node represents.
+
+        :returns: The name of the type.
+        :rtype: str
+        """
+        if "method" in self.type:
+            return "builtins.instancemethod"
+        return "builtins.function"
+
+    def display_type(self):
+        """A human readable type of this node.
+
+        :returns: The type of this node.
+        :rtype: str
+        """
+        if "method" in self.type:
+            return "Method"
+        return "Function"
+
+    def callable(self):
+        """Whether this node defines something that is callable.
+
+        :returns: True if this defines something that is callable,
+            False otherwise.
+            For a :class:`Lambda` this is always ``True``.
+        :rtype: bool
+        """
+        return True
+
+    def argnames(self) -> List[str]:
+        """Get the names of each of the arguments, including that
+        of the collections of variable-length arguments ("args", "kwargs",
+        etc.), as well as positional-only and keyword-only arguments.
+
+        :returns: The names of the arguments.
+        :rtype: list(str)
+        """
+        if self.args.arguments:  # maybe None with builtin functions
+            names = _rec_get_names(self.args.arguments)
+        else:
+            names = []
+        if self.args.vararg:
+            names.append(self.args.vararg)
+        names += [elt.name for elt in self.args.kwonlyargs]
+        if self.args.kwarg:
+            names.append(self.args.kwarg)
+        return names
+
+    def infer_call_result(self, caller, context=None):
+        """Infer what the function returns when called.
+
+        :param caller: Unused
+        :type caller: object
+        """
+        # pylint: disable=no-member; github.com/pycqa/astroid/issues/291
+        # args is in fact redefined later on by postinit. Can't be changed
+        # to None due to a strong interaction between Lambda and FunctionDef.
+        return self.body.infer(context)
+
+    def scope_lookup(self, node, name, offset=0):
+        """Lookup where the given names is assigned.
+
+        :param node: The node to look for assignments up to.
+            Any assignments after the given node are ignored.
+        :type node: NodeNG
+
+        :param name: The name to find assignments for.
+        :type name: str
+
+        :param offset: The line offset to filter statements up to.
+        :type offset: int
+
+        :returns: This scope node and the list of assignments associated to the
+            given name according to the scope where it has been found (locals,
+            globals or builtin).
+        :rtype: tuple(str, list(NodeNG))
+        """
+        if node in self.args.defaults or node in self.args.kw_defaults:
+            frame = self.parent.frame(future=True)
+            # line offset to avoid that def func(f=func) resolve the default
+            # value to the defined function
+            offset = -1
+        else:
+            # check this is not used in function decorators
+            frame = self
+        return frame._scope_lookup(node, name, offset)
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        :returns: The boolean value of this node.
+            For a :class:`Lambda` this is always ``True``.
+        :rtype: bool
+        """
+        return True
+
+    def get_children(self):
+        yield self.args
+        yield self.body
+
+    def frame(self: T, *, future: Literal[None, True] = None) -> T:
+        """The node's frame node.
+
+        A frame node is a :class:`Module`, :class:`FunctionDef`,
+        :class:`ClassDef` or :class:`Lambda`.
+
+        :returns: The node itself.
+        """
+        return self
+
+    def getattr(
+        self, name: str, context: Optional[InferenceContext] = None
+    ) -> List[NodeNG]:
+        if not name:
+            raise AttributeInferenceError(target=self, attribute=name, context=context)
+
+        found_attrs = []
+        if name in self.instance_attrs:
+            found_attrs = self.instance_attrs[name]
+        if name in self.special_attributes:
+            found_attrs.append(self.special_attributes.lookup(name))
+        if found_attrs:
+            return found_attrs
+        raise AttributeInferenceError(target=self, attribute=name)
+
+
+class FunctionDef(mixins.MultiLineBlockMixin, node_classes.Statement, Lambda):
+    """Class representing an :class:`ast.FunctionDef`.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    ... def my_func(arg):
+    ...     return arg + 1
+    ... ''')
+    >>> node
+    <FunctionDef.my_func l.2 at 0x7f23b2e71e10>
+    """
+
+    _astroid_fields = ("decorators", "args", "returns", "doc_node", "body")
+    _multi_line_block_fields = ("body",)
+    returns = None
+    decorators: Optional[node_classes.Decorators] = None
+    """The decorators that are applied to this method or function."""
+
+    is_function = True
+    """Whether this node indicates a function.
+
+    For a :class:`FunctionDef` this is always ``True``.
+
+    :type: bool
+    """
+    type_annotation = None
+    """If present, this will contain the type annotation passed by a type comment
+
+    :type: NodeNG or None
+    """
+    type_comment_args = None
+    """
+    If present, this will contain the type annotation for arguments
+    passed by a type comment
+    """
+    type_comment_returns = None
+    """If present, this will contain the return type annotation, passed by a type comment"""
+    # attributes below are set by the builder module or by raw factories
+    _other_fields = ("name", "doc", "position")
+    _other_other_fields = (
+        "locals",
+        "_type",
+        "type_comment_returns",
+        "type_comment_args",
+    )
+    _type = None
+
+    @decorators_mod.deprecate_arguments(doc="Use the postinit arg 'doc_node' instead")
+    def __init__(
+        self,
+        name=None,
+        doc: Optional[str] = None,
+        lineno=None,
+        col_offset=None,
+        parent=None,
+        *,
+        end_lineno=None,
+        end_col_offset=None,
+    ):
+        """
+        :param name: The name of the function.
+        :type name: str or None
+
+        :param doc: The function docstring.
+
+        :param lineno: The line that this node appears on in the source code.
+        :type lineno: int or None
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+        :type col_offset: int or None
+
+        :param parent: The parent node in the syntax tree.
+        :type parent: NodeNG or None
+
+        :param end_lineno: The last line this node appears on in the source code.
+        :type end_lineno: Optional[int]
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        :type end_col_offset: Optional[int]
+        """
+        self.name = name
+        """The name of the function.
+
+        :type name: str or None
+        """
+
+        self._doc = doc
+        """The function docstring."""
+
+        self.doc_node: Optional[Const] = None
+        """The doc node associated with this node."""
+
+        self.instance_attrs = {}
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+        if parent:
+            frame = parent.frame(future=True)
+            frame.set_local(name, self)
+
+    # pylint: disable=arguments-differ; different than Lambdas
+    def postinit(
+        self,
+        args: Arguments,
+        body,
+        decorators: Optional[node_classes.Decorators] = None,
+        returns=None,
+        type_comment_returns=None,
+        type_comment_args=None,
+        *,
+        position: Optional[Position] = None,
+        doc_node: Optional[Const] = None,
+    ):
+        """Do some setup after initialisation.
+
+        :param args: The arguments that the function takes.
+
+        :param body: The contents of the function body.
+        :type body: list(NodeNG)
+
+        :param decorators: The decorators that are applied to this
+            method or function.
+        :type decorators: Decorators or None
+        :params type_comment_returns:
+            The return type annotation passed via a type comment.
+        :params type_comment_args:
+            The args type annotation passed via a type comment.
+        :params position:
+            Position of function keyword(s) and name.
+        :param doc_node:
+            The doc node associated with this node.
+        """
+        self.args = args
+        self.body = body
+        self.decorators = decorators
+        self.returns = returns
+        self.type_comment_returns = type_comment_returns
+        self.type_comment_args = type_comment_args
+        self.position = position
+        self.doc_node = doc_node
+        if doc_node:
+            self._doc = doc_node.value
+
+    @property
+    def doc(self) -> Optional[str]:
+        """The function docstring."""
+        warnings.warn(
+            "The 'FunctionDef.doc' attribute is deprecated, "
+            "use 'FunctionDef.doc_node' instead.",
+            DeprecationWarning,
+        )
+        return self._doc
+
+    @doc.setter
+    def doc(self, value: Optional[str]) -> None:
+        warnings.warn(
+            "Setting the 'FunctionDef.doc' attribute is deprecated, "
+            "use 'FunctionDef.doc_node' instead.",
+            DeprecationWarning,
+        )
+        self._doc = value
+
+    @cached_property
+    def extra_decorators(self) -> List[node_classes.Call]:
+        """The extra decorators that this function can have.
+
+        Additional decorators are considered when they are used as
+        assignments, as in ``method = staticmethod(method)``.
+        The property will return all the callables that are used for
+        decoration.
+        """
+        frame = self.parent.frame(future=True)
+        if not isinstance(frame, ClassDef):
+            return []
+
+        decorators: List[node_classes.Call] = []
+        for assign in frame._get_assign_nodes():
+            if isinstance(assign.value, node_classes.Call) and isinstance(
+                assign.value.func, node_classes.Name
+            ):
+                for assign_node in assign.targets:
+                    if not isinstance(assign_node, node_classes.AssignName):
+                        # Support only `name = callable(name)`
+                        continue
+
+                    if assign_node.name != self.name:
+                        # Interested only in the assignment nodes that
+                        # decorates the current method.
+                        continue
+                    try:
+                        meth = frame[self.name]
+                    except KeyError:
+                        continue
+                    else:
+                        # Must be a function and in the same frame as the
+                        # original method.
+                        if (
+                            isinstance(meth, FunctionDef)
+                            and assign_node.frame(future=True) == frame
+                        ):
+                            decorators.append(assign.value)
+        return decorators
+
+    @cached_property
+    def type(
+        self,
+    ):  # pylint: disable=invalid-overridden-method,too-many-return-statements
+        """The function type for this node.
+
+        Possible values are: method, function, staticmethod, classmethod.
+
+        :type: str
+        """
+        for decorator in self.extra_decorators:
+            if decorator.func.name in BUILTIN_DESCRIPTORS:
+                return decorator.func.name
+
+        frame = self.parent.frame(future=True)
+        type_name = "function"
+        if isinstance(frame, ClassDef):
+            if self.name == "__new__":
+                return "classmethod"
+            if self.name == "__init_subclass__":
+                return "classmethod"
+            if self.name == "__class_getitem__":
+                return "classmethod"
+
+            type_name = "method"
+
+        if not self.decorators:
+            return type_name
+
+        for node in self.decorators.nodes:
+            if isinstance(node, node_classes.Name):
+                if node.name in BUILTIN_DESCRIPTORS:
+                    return node.name
+            if (
+                isinstance(node, node_classes.Attribute)
+                and isinstance(node.expr, node_classes.Name)
+                and node.expr.name == "builtins"
+                and node.attrname in BUILTIN_DESCRIPTORS
+            ):
+                return node.attrname
+
+            if isinstance(node, node_classes.Call):
+                # Handle the following case:
+                # @some_decorator(arg1, arg2)
+                # def func(...)
+                #
+                try:
+                    current = next(node.func.infer())
+                except (InferenceError, StopIteration):
+                    continue
+                _type = _infer_decorator_callchain(current)
+                if _type is not None:
+                    return _type
+
+            try:
+                for inferred in node.infer():
+                    # Check to see if this returns a static or a class method.
+                    _type = _infer_decorator_callchain(inferred)
+                    if _type is not None:
+                        return _type
+
+                    if not isinstance(inferred, ClassDef):
+                        continue
+                    for ancestor in inferred.ancestors():
+                        if not isinstance(ancestor, ClassDef):
+                            continue
+                        if ancestor.is_subtype_of("builtins.classmethod"):
+                            return "classmethod"
+                        if ancestor.is_subtype_of("builtins.staticmethod"):
+                            return "staticmethod"
+            except InferenceError:
+                pass
+        return type_name
+
+    @cached_property
+    def fromlineno(self) -> Optional[int]:
+        """The first line that this node appears on in the source code."""
+        # lineno is the line number of the first decorator, we want the def
+        # statement lineno. Similar to 'ClassDef.fromlineno'
+        lineno = self.lineno
+        if self.decorators is not None:
+            lineno += sum(
+                node.tolineno - node.lineno + 1 for node in self.decorators.nodes
+            )
+
+        return lineno
+
+    @cached_property
+    def blockstart_tolineno(self):
+        """The line on which the beginning of this block ends.
+
+        :type: int
+        """
+        return self.args.tolineno
+
+    def implicit_parameters(self) -> Literal[0, 1]:
+        return 1 if self.is_bound() else 0
+
+    def block_range(self, lineno):
+        """Get a range from the given line number to where this node ends.
+
+        :param lineno: Unused.
+        :type lineno: int
+
+        :returns: The range of line numbers that this node belongs to,
+        :rtype: tuple(int, int)
+        """
+        return self.fromlineno, self.tolineno
+
+    def igetattr(self, name, context=None):
+        """Inferred getattr, which returns an iterator of inferred statements."""
+        try:
+            return bases._infer_stmts(self.getattr(name, context), context, frame=self)
+        except AttributeInferenceError as error:
+            raise InferenceError(
+                str(error), target=self, attribute=name, context=context
+            ) from error
+
+    def is_method(self):
+        """Check if this function node represents a method.
+
+        :returns: True if this is a method, False otherwise.
+        :rtype: bool
+        """
+        # check we are defined in a ClassDef, because this is usually expected
+        # (e.g. pylint...) when is_method() return True
+        return self.type != "function" and isinstance(
+            self.parent.frame(future=True), ClassDef
+        )
+
+    @decorators_mod.cached
+    def decoratornames(self, context=None):
+        """Get the qualified names of each of the decorators on this function.
+
+        :param context:
+            An inference context that can be passed to inference functions
+        :returns: The names of the decorators.
+        :rtype: set(str)
+        """
+        result = set()
+        decoratornodes = []
+        if self.decorators is not None:
+            decoratornodes += self.decorators.nodes
+        decoratornodes += self.extra_decorators
+        for decnode in decoratornodes:
+            try:
+                for infnode in decnode.infer(context=context):
+                    result.add(infnode.qname())
+            except InferenceError:
+                continue
+        return result
+
+    def is_bound(self):
+        """Check if the function is bound to an instance or class.
+
+        :returns: True if the function is bound to an instance or class,
+            False otherwise.
+        :rtype: bool
+        """
+        return self.type in {"method", "classmethod"}
+
+    def is_abstract(self, pass_is_abstract=True, any_raise_is_abstract=False):
+        """Check if the method is abstract.
+
+        A method is considered abstract if any of the following is true:
+        * The only statement is 'raise NotImplementedError'
+        * The only statement is 'raise <SomeException>' and any_raise_is_abstract is True
+        * The only statement is 'pass' and pass_is_abstract is True
+        * The method is annotated with abc.astractproperty/abc.abstractmethod
+
+        :returns: True if the method is abstract, False otherwise.
+        :rtype: bool
+        """
+        if self.decorators:
+            for node in self.decorators.nodes:
+                try:
+                    inferred = next(node.infer())
+                except (InferenceError, StopIteration):
+                    continue
+                if inferred and inferred.qname() in {
+                    "abc.abstractproperty",
+                    "abc.abstractmethod",
+                }:
+                    return True
+
+        for child_node in self.body:
+            if isinstance(child_node, node_classes.Raise):
+                if any_raise_is_abstract:
+                    return True
+                if child_node.raises_not_implemented():
+                    return True
+            return pass_is_abstract and isinstance(child_node, node_classes.Pass)
+        # empty function is the same as function with a single "pass" statement
+        if pass_is_abstract:
+            return True
+
+    def is_generator(self):
+        """Check if this is a generator function.
+
+        :returns: True is this is a generator function, False otherwise.
+        :rtype: bool
+        """
+        return bool(next(self._get_yield_nodes_skip_lambdas(), False))
+
+    def infer_yield_result(self, context=None):
+        """Infer what the function yields when called
+
+        :returns: What the function yields
+        :rtype: iterable(NodeNG or Uninferable) or None
+        """
+        # pylint: disable=not-an-iterable
+        # https://github.com/PyCQA/astroid/issues/1015
+        for yield_ in self.nodes_of_class(node_classes.Yield):
+            if yield_.value is None:
+                const = node_classes.Const(None)
+                const.parent = yield_
+                const.lineno = yield_.lineno
+                yield const
+            elif yield_.scope() == self:
+                yield from yield_.value.infer(context=context)
+
+    def infer_call_result(self, caller=None, context=None):
+        """Infer what the function returns when called.
+
+        :returns: What the function returns.
+        :rtype: iterable(NodeNG or Uninferable) or None
+        """
+        if self.is_generator():
+            if isinstance(self, AsyncFunctionDef):
+                generator_cls = bases.AsyncGenerator
+            else:
+                generator_cls = bases.Generator
+            result = generator_cls(self, generator_initial_context=context)
+            yield result
+            return
+        # This is really a gigantic hack to work around metaclass generators
+        # that return transient class-generating functions. Pylint's AST structure
+        # cannot handle a base class object that is only used for calling __new__,
+        # but does not contribute to the inheritance structure itself. We inject
+        # a fake class into the hierarchy here for several well-known metaclass
+        # generators, and filter it out later.
+        if (
+            self.name == "with_metaclass"
+            and len(self.args.args) == 1
+            and self.args.vararg is not None
+        ):
+            metaclass = next(caller.args[0].infer(context), None)
+            if isinstance(metaclass, ClassDef):
+                try:
+                    class_bases = [next(arg.infer(context)) for arg in caller.args[1:]]
+                except StopIteration as e:
+                    raise InferenceError(node=caller.args[1:], context=context) from e
+                new_class = ClassDef(name="temporary_class")
+                new_class.hide = True
+                new_class.parent = self
+                new_class.postinit(
+                    bases=[base for base in class_bases if base != util.Uninferable],
+                    body=[],
+                    decorators=[],
+                    metaclass=metaclass,
+                )
+                yield new_class
+                return
+        returns = self._get_return_nodes_skip_functions()
+
+        first_return = next(returns, None)
+        if not first_return:
+            if self.body:
+                if self.is_abstract(pass_is_abstract=True, any_raise_is_abstract=True):
+                    yield util.Uninferable
+                else:
+                    yield node_classes.Const(None)
+                return
+
+            raise InferenceError("The function does not have any return statements")
+
+        for returnnode in itertools.chain((first_return,), returns):
+            if returnnode.value is None:
+                yield node_classes.Const(None)
+            else:
+                try:
+                    yield from returnnode.value.infer(context)
+                except InferenceError:
+                    yield util.Uninferable
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        :returns: The boolean value of this node.
+            For a :class:`FunctionDef` this is always ``True``.
+        :rtype: bool
+        """
+        return True
+
+    def get_children(self):
+        if self.decorators is not None:
+            yield self.decorators
+
+        yield self.args
+
+        if self.returns is not None:
+            yield self.returns
+
+        yield from self.body
+
+    def scope_lookup(self, node, name, offset=0):
+        """Lookup where the given name is assigned."""
+        if name == "__class__":
+            # __class__ is an implicit closure reference created by the compiler
+            # if any methods in a class body refer to either __class__ or super.
+            # In our case, we want to be able to look it up in the current scope
+            # when `__class__` is being used.
+            frame = self.parent.frame(future=True)
+            if isinstance(frame, ClassDef):
+                return self, [frame]
+        return super().scope_lookup(node, name, offset)
+
+    def frame(self: T, *, future: Literal[None, True] = None) -> T:
+        """The node's frame node.
+
+        A frame node is a :class:`Module`, :class:`FunctionDef`,
+        :class:`ClassDef` or :class:`Lambda`.
+
+        :returns: The node itself.
+        """
+        return self
+
+
+class AsyncFunctionDef(FunctionDef):
+    """Class representing an :class:`ast.FunctionDef` node.
+
+    A :class:`AsyncFunctionDef` is an asynchronous function
+    created with the `async` keyword.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    async def func(things):
+        async for thing in things:
+            print(thing)
+    ''')
+    >>> node
+    <AsyncFunctionDef.func l.2 at 0x7f23b2e416d8>
+    >>> node.body[0]
+    <AsyncFor l.3 at 0x7f23b2e417b8>
+    """
+
+
+def _rec_get_names(args, names: Optional[List[str]] = None) -> List[str]:
+    """return a list of all argument names"""
+    if names is None:
+        names = []
+    for arg in args:
+        if isinstance(arg, node_classes.Tuple):
+            _rec_get_names(arg.elts, names)
+        else:
+            names.append(arg.name)
+    return names
+
+
+def _is_metaclass(klass, seen=None):
+    """Return if the given class can be
+    used as a metaclass.
+    """
+    if klass.name == "type":
+        return True
+    if seen is None:
+        seen = set()
+    for base in klass.bases:
+        try:
+            for baseobj in base.infer():
+                baseobj_name = baseobj.qname()
+                if baseobj_name in seen:
+                    continue
+
+                seen.add(baseobj_name)
+                if isinstance(baseobj, bases.Instance):
+                    # not abstract
+                    return False
+                if baseobj is util.Uninferable:
+                    continue
+                if baseobj is klass:
+                    continue
+                if not isinstance(baseobj, ClassDef):
+                    continue
+                if baseobj._type == "metaclass":
+                    return True
+                if _is_metaclass(baseobj, seen):
+                    return True
+        except InferenceError:
+            continue
+    return False
+
+
+def _class_type(klass, ancestors=None):
+    """return a ClassDef node type to differ metaclass and exception
+    from 'regular' classes
+    """
+    # XXX we have to store ancestors in case we have an ancestor loop
+    if klass._type is not None:
+        return klass._type
+    if _is_metaclass(klass):
+        klass._type = "metaclass"
+    elif klass.name.endswith("Exception"):
+        klass._type = "exception"
+    else:
+        if ancestors is None:
+            ancestors = set()
+        klass_name = klass.qname()
+        if klass_name in ancestors:
+            # XXX we are in loop ancestors, and have found no type
+            klass._type = "class"
+            return "class"
+        ancestors.add(klass_name)
+        for base in klass.ancestors(recurs=False):
+            name = _class_type(base, ancestors)
+            if name != "class":
+                if name == "metaclass" and not _is_metaclass(klass):
+                    # don't propagate it if the current class
+                    # can't be a metaclass
+                    continue
+                klass._type = base.type
+                break
+    if klass._type is None:
+        klass._type = "class"
+    return klass._type
+
+
+def get_wrapping_class(node):
+    """Get the class that wraps the given node.
+
+    We consider that a class wraps a node if the class
+    is a parent for the said node.
+
+    :returns: The class that wraps the given node
+    :rtype: ClassDef or None
+    """
+
+    klass = node.frame(future=True)
+    while klass is not None and not isinstance(klass, ClassDef):
+        if klass.parent is None:
+            klass = None
+        else:
+            klass = klass.parent.frame(future=True)
+    return klass
+
+
+# pylint: disable=too-many-instance-attributes
+class ClassDef(mixins.FilterStmtsMixin, LocalsDictNodeNG, node_classes.Statement):
+    """Class representing an :class:`ast.ClassDef` node.
+
+    >>> import astroid
+    >>> node = astroid.extract_node('''
+    class Thing:
+        def my_meth(self, arg):
+            return arg + self.offset
+    ''')
+    >>> node
+    <ClassDef.Thing l.2 at 0x7f23b2e9e748>
+    """
+
+    # some of the attributes below are set by the builder module or
+    # by a raw factories
+
+    # a dictionary of class instances attributes
+    _astroid_fields = ("decorators", "bases", "keywords", "doc_node", "body")  # name
+
+    decorators = None
+    """The decorators that are applied to this class.
+
+    :type: Decorators or None
+    """
+    special_attributes = ClassModel()
+    """The names of special attributes that this class has.
+
+    :type: objectmodel.ClassModel
+    """
+
+    _type = None
+    _metaclass_hack = False
+    hide = False
+    type = property(
+        _class_type,
+        doc=(
+            "The class type for this node.\n\n"
+            "Possible values are: class, metaclass, exception.\n\n"
+            ":type: str"
+        ),
+    )
+    _other_fields = ("name", "doc", "is_dataclass", "position")
+    _other_other_fields = ("locals", "_newstyle")
+    _newstyle = None
+
+    @decorators_mod.deprecate_arguments(doc="Use the postinit arg 'doc_node' instead")
+    def __init__(
+        self,
+        name=None,
+        doc: Optional[str] = None,
+        lineno=None,
+        col_offset=None,
+        parent=None,
+        *,
+        end_lineno=None,
+        end_col_offset=None,
+    ):
+        """
+        :param name: The name of the class.
+        :type name: str or None
+
+        :param doc: The class docstring.
+
+        :param lineno: The line that this node appears on in the source code.
+        :type lineno: int or None
+
+        :param col_offset: The column that this node appears on in the
+            source code.
+        :type col_offset: int or None
+
+        :param parent: The parent node in the syntax tree.
+        :type parent: NodeNG or None
+
+        :param end_lineno: The last line this node appears on in the source code.
+        :type end_lineno: Optional[int]
+
+        :param end_col_offset: The end column this node appears on in the
+            source code. Note: This is after the last symbol.
+        :type end_col_offset: Optional[int]
+        """
+        self.instance_attrs = {}
+        self.locals = {}
+        """A map of the name of a local variable to the node defining it.
+
+        :type: dict(str, NodeNG)
+        """
+
+        self.keywords = []
+        """The keywords given to the class definition.
+
+        This is usually for :pep:`3115` style metaclass declaration.
+
+        :type: list(Keyword) or None
+        """
+
+        self.bases = []
+        """What the class inherits from.
+
+        :type: list(NodeNG)
+        """
+
+        self.body = []
+        """The contents of the class body.
+
+        :type: list(NodeNG)
+        """
+
+        self.name = name
+        """The name of the class.
+
+        :type name: str or None
+        """
+
+        self._doc = doc
+        """The class docstring."""
+
+        self.doc_node: Optional[Const] = None
+        """The doc node associated with this node."""
+
+        self.is_dataclass: bool = False
+        """Whether this class is a dataclass."""
+
+        super().__init__(
+            lineno=lineno,
+            col_offset=col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+        if parent is not None:
+            parent.frame(future=True).set_local(name, self)
+
+        for local_name, node in self.implicit_locals():
+            self.add_local_node(node, local_name)
+
+    @property
+    def doc(self) -> Optional[str]:
+        """The class docstring."""
+        warnings.warn(
+            "The 'ClassDef.doc' attribute is deprecated, "
+            "use 'ClassDef.doc_node' instead.",
+            DeprecationWarning,
+        )
+        return self._doc
+
+    @doc.setter
+    def doc(self, value: Optional[str]) -> None:
+        warnings.warn(
+            "Setting the 'ClassDef.doc' attribute is deprecated, "
+            "use 'ClassDef.doc_node.value' instead.",
+            DeprecationWarning,
+        )
+        self._doc = value
+
+    def implicit_parameters(self):
+        return 1
+
+    def implicit_locals(self):
+        """Get implicitly defined class definition locals.
+
+        :returns: the the name and Const pair for each local
+        :rtype: tuple(tuple(str, node_classes.Const), ...)
+        """
+        locals_ = (("__module__", self.special_attributes.attr___module__),)
+        # __qualname__ is defined in PEP3155
+        locals_ += (("__qualname__", self.special_attributes.attr___qualname__),)
+        return locals_
+
+    # pylint: disable=redefined-outer-name
+    def postinit(
+        self,
+        bases,
+        body,
+        decorators,
+        newstyle=None,
+        metaclass=None,
+        keywords=None,
+        *,
+        position: Optional[Position] = None,
+        doc_node: Optional[Const] = None,
+    ):
+        """Do some setup after initialisation.
+
+        :param bases: What the class inherits from.
+        :type bases: list(NodeNG)
+
+        :param body: The contents of the class body.
+        :type body: list(NodeNG)
+
+        :param decorators: The decorators that are applied to this class.
+        :type decorators: Decorators or None
+
+        :param newstyle: Whether this is a new style class or not.
+        :type newstyle: bool or None
+
+        :param metaclass: The metaclass of this class.
+        :type metaclass: NodeNG or None
+
+        :param keywords: The keywords given to the class definition.
+        :type keywords: list(Keyword) or None
+
+        :param position: Position of class keyword and name.
+
+        :param doc_node: The doc node associated with this node.
+        """
+        if keywords is not None:
+            self.keywords = keywords
+        self.bases = bases
+        self.body = body
+        self.decorators = decorators
+        if newstyle is not None:
+            self._newstyle = newstyle
+        if metaclass is not None:
+            self._metaclass = metaclass
+        self.position = position
+        self.doc_node = doc_node
+        if doc_node:
+            self._doc = doc_node.value
+
+    def _newstyle_impl(self, context=None):
+        if context is None:
+            context = InferenceContext()
+        if self._newstyle is not None:
+            return self._newstyle
+        for base in self.ancestors(recurs=False, context=context):
+            if base._newstyle_impl(context):
+                self._newstyle = True
+                break
+        klass = self.declared_metaclass()
+        # could be any callable, we'd need to infer the result of klass(name,
+        # bases, dict).  punt if it's not a class node.
+        if klass is not None and isinstance(klass, ClassDef):
+            self._newstyle = klass._newstyle_impl(context)
+        if self._newstyle is None:
+            self._newstyle = False
+        return self._newstyle
+
+    _newstyle = None
+    newstyle = property(
+        _newstyle_impl,
+        doc=("Whether this is a new style class or not\n\n" ":type: bool or None"),
+    )
+
+    @cached_property
+    def fromlineno(self) -> Optional[int]:
+        """The first line that this node appears on in the source code."""
+        if not PY38_PLUS or PY38 and IS_PYPY:
+            # For Python < 3.8 the lineno is the line number of the first decorator.
+            # We want the class statement lineno. Similar to 'FunctionDef.fromlineno'
+            lineno = self.lineno
+            if self.decorators is not None:
+                lineno += sum(
+                    node.tolineno - node.lineno + 1 for node in self.decorators.nodes
+                )
+
+            return lineno
+        return super().fromlineno
+
+    @cached_property
+    def blockstart_tolineno(self):
+        """The line on which the beginning of this block ends.
+
+        :type: int
+        """
+        if self.bases:
+            return self.bases[-1].tolineno
+
+        return self.fromlineno
+
+    def block_range(self, lineno):
+        """Get a range from the given line number to where this node ends.
+
+        :param lineno: Unused.
+        :type lineno: int
+
+        :returns: The range of line numbers that this node belongs to,
+        :rtype: tuple(int, int)
+        """
+        return self.fromlineno, self.tolineno
+
+    def pytype(self):
+        """Get the name of the type that this node represents.
+
+        :returns: The name of the type.
+        :rtype: str
+        """
+        if self.newstyle:
+            return "builtins.type"
+        return "builtins.classobj"
+
+    def display_type(self):
+        """A human readable type of this node.
+
+        :returns: The type of this node.
+        :rtype: str
+        """
+        return "Class"
+
+    def callable(self):
+        """Whether this node defines something that is callable.
+
+        :returns: True if this defines something that is callable,
+            False otherwise.
+            For a :class:`ClassDef` this is always ``True``.
+        :rtype: bool
+        """
+        return True
+
+    def is_subtype_of(self, type_name, context=None):
+        """Whether this class is a subtype of the given type.
+
+        :param type_name: The name of the type of check against.
+        :type type_name: str
+
+        :returns: True if this class is a subtype of the given type,
+            False otherwise.
+        :rtype: bool
+        """
+        if self.qname() == type_name:
+            return True
+
+        return any(anc.qname() == type_name for anc in self.ancestors(context=context))
+
+    def _infer_type_call(self, caller, context):
+        try:
+            name_node = next(caller.args[0].infer(context))
+        except StopIteration as e:
+            raise InferenceError(node=caller.args[0], context=context) from e
+        if isinstance(name_node, node_classes.Const) and isinstance(
+            name_node.value, str
+        ):
+            name = name_node.value
+        else:
+            return util.Uninferable
+
+        result = ClassDef(name)
+
+        # Get the bases of the class.
+        try:
+            class_bases = next(caller.args[1].infer(context))
+        except StopIteration as e:
+            raise InferenceError(node=caller.args[1], context=context) from e
+        if isinstance(class_bases, (node_classes.Tuple, node_classes.List)):
+            bases = []
+            for base in class_bases.itered():
+                inferred = next(base.infer(context=context), None)
+                if inferred:
+                    bases.append(
+                        node_classes.EvaluatedObject(original=base, value=inferred)
+                    )
+            result.bases = bases
+        else:
+            # There is currently no AST node that can represent an 'unknown'
+            # node (Uninferable is not an AST node), therefore we simply return Uninferable here
+            # although we know at least the name of the class.
+            return util.Uninferable
+
+        # Get the members of the class
+        try:
+            members = next(caller.args[2].infer(context))
+        except (InferenceError, StopIteration):
+            members = None
+
+        if members and isinstance(members, node_classes.Dict):
+            for attr, value in members.items:
+                if isinstance(attr, node_classes.Const) and isinstance(attr.value, str):
+                    result.locals[attr.value] = [value]
+
+        result.parent = caller.parent
+        return result
+
+    def infer_call_result(self, caller, context=None):
+        """infer what a class is returning when called"""
+        if self.is_subtype_of("builtins.type", context) and len(caller.args) == 3:
+            result = self._infer_type_call(caller, context)
+            yield result
+            return
+
+        dunder_call = None
+        try:
+            metaclass = self.metaclass(context=context)
+            if metaclass is not None:
+                dunder_call = next(metaclass.igetattr("__call__", context))
+        except (AttributeInferenceError, StopIteration):
+            pass
+
+        if dunder_call and dunder_call.qname() != "builtins.type.__call__":
+            # Call type.__call__ if not set metaclass
+            # (since type is the default metaclass)
+            context = bind_context_to_node(context, self)
+            context.callcontext.callee = dunder_call
+            yield from dunder_call.infer_call_result(caller, context)
+        else:
+            yield self.instantiate_class()
+
+    def scope_lookup(self, node, name, offset=0):
+        """Lookup where the given name is assigned.
+
+        :param node: The node to look for assignments up to.
+            Any assignments after the given node are ignored.
+        :type node: NodeNG
+
+        :param name: The name to find assignments for.
+        :type name: str
+
+        :param offset: The line offset to filter statements up to.
+        :type offset: int
+
+        :returns: This scope node and the list of assignments associated to the
+            given name according to the scope where it has been found (locals,
+            globals or builtin).
+        :rtype: tuple(str, list(NodeNG))
+        """
+        # If the name looks like a builtin name, just try to look
+        # into the upper scope of this class. We might have a
+        # decorator that it's poorly named after a builtin object
+        # inside this class.
+        lookup_upper_frame = (
+            isinstance(node.parent, node_classes.Decorators)
+            and name in AstroidManager().builtins_module
+        )
+        if (
+            any(node == base or base.parent_of(node) for base in self.bases)
+            or lookup_upper_frame
+        ):
+            # Handle the case where we have either a name
+            # in the bases of a class, which exists before
+            # the actual definition or the case where we have
+            # a Getattr node, with that name.
+            #
+            # name = ...
+            # class A(name):
+            #     def name(self): ...
+            #
+            # import name
+            # class A(name.Name):
+            #     def name(self): ...
+
+            frame = self.parent.frame(future=True)
+            # line offset to avoid that class A(A) resolve the ancestor to
+            # the defined class
+            offset = -1
+        else:
+            frame = self
+        return frame._scope_lookup(node, name, offset)
+
+    @property
+    def basenames(self):
+        """The names of the parent classes
+
+        Names are given in the order they appear in the class definition.
+
+        :type: list(str)
+        """
+        return [bnode.as_string() for bnode in self.bases]
+
+    def ancestors(self, recurs=True, context=None):
+        """Iterate over the base classes in prefixed depth first order.
+
+        :param recurs: Whether to recurse or return direct ancestors only.
+        :type recurs: bool
+
+        :returns: The base classes
+        :rtype: iterable(NodeNG)
+        """
+        # FIXME: should be possible to choose the resolution order
+        # FIXME: inference make infinite loops possible here
+        yielded = {self}
+        if context is None:
+            context = InferenceContext()
+        if not self.bases and self.qname() != "builtins.object":
+            yield builtin_lookup("object")[1][0]
+            return
+
+        for stmt in self.bases:
+            with context.restore_path():
+                try:
+                    for baseobj in stmt.infer(context):
+                        if not isinstance(baseobj, ClassDef):
+                            if isinstance(baseobj, bases.Instance):
+                                baseobj = baseobj._proxied
+                            else:
+                                continue
+                        if not baseobj.hide:
+                            if baseobj in yielded:
+                                continue
+                            yielded.add(baseobj)
+                            yield baseobj
+                        if not recurs:
+                            continue
+                        for grandpa in baseobj.ancestors(recurs=True, context=context):
+                            if grandpa is self:
+                                # This class is the ancestor of itself.
+                                break
+                            if grandpa in yielded:
+                                continue
+                            yielded.add(grandpa)
+                            yield grandpa
+                except InferenceError:
+                    continue
+
+    def local_attr_ancestors(self, name, context=None):
+        """Iterate over the parents that define the given name.
+
+        :param name: The name to find definitions for.
+        :type name: str
+
+        :returns: The parents that define the given name.
+        :rtype: iterable(NodeNG)
+        """
+        # Look up in the mro if we can. This will result in the
+        # attribute being looked up just as Python does it.
+        try:
+            ancestors = self.mro(context)[1:]
+        except MroError:
+            # Fallback to use ancestors, we can't determine
+            # a sane MRO.
+            ancestors = self.ancestors(context=context)
+        for astroid in ancestors:
+            if name in astroid:
+                yield astroid
+
+    def instance_attr_ancestors(self, name, context=None):
+        """Iterate over the parents that define the given name as an attribute.
+
+        :param name: The name to find definitions for.
+        :type name: str
+
+        :returns: The parents that define the given name as
+            an instance attribute.
+        :rtype: iterable(NodeNG)
+        """
+        for astroid in self.ancestors(context=context):
+            if name in astroid.instance_attrs:
+                yield astroid
+
+    def has_base(self, node):
+        """Whether this class directly inherits from the given node.
+
+        :param node: The node to check for.
+        :type node: NodeNG
+
+        :returns: True if this class directly inherits from the given node.
+        :rtype: bool
+        """
+        return node in self.bases
+
+    def local_attr(self, name, context=None):
+        """Get the list of assign nodes associated to the given name.
+
+        Assignments are looked for in both this class and in parents.
+
+        :returns: The list of assignments to the given name.
+        :rtype: list(NodeNG)
+
+        :raises AttributeInferenceError: If no attribute with this name
+            can be found in this class or parent classes.
+        """
+        result = []
+        if name in self.locals:
+            result = self.locals[name]
+        else:
+            class_node = next(self.local_attr_ancestors(name, context), None)
+            if class_node:
+                result = class_node.locals[name]
+        result = [n for n in result if not isinstance(n, node_classes.DelAttr)]
+        if result:
+            return result
+        raise AttributeInferenceError(target=self, attribute=name, context=context)
+
+    def instance_attr(self, name, context=None):
+        """Get the list of nodes associated to the given attribute name.
+
+        Assignments are looked for in both this class and in parents.
+
+        :returns: The list of assignments to the given name.
+        :rtype: list(NodeNG)
+
+        :raises AttributeInferenceError: If no attribute with this name
+            can be found in this class or parent classes.
+        """
+        # Return a copy, so we don't modify self.instance_attrs,
+        # which could lead to infinite loop.
+        values = list(self.instance_attrs.get(name, []))
+        # get all values from parents
+        for class_node in self.instance_attr_ancestors(name, context):
+            values += class_node.instance_attrs[name]
+        values = [n for n in values if not isinstance(n, node_classes.DelAttr)]
+        if values:
+            return values
+        raise AttributeInferenceError(target=self, attribute=name, context=context)
+
+    def instantiate_class(self):
+        """Get an :class:`Instance` of the :class:`ClassDef` node.
+
+        :returns: An :class:`Instance` of the :class:`ClassDef` node,
+            or self if this is not possible.
+        :rtype: Instance or ClassDef
+        """
+        try:
+            if any(cls.name in EXCEPTION_BASE_CLASSES for cls in self.mro()):
+                # Subclasses of exceptions can be exception instances
+                return objects.ExceptionInstance(self)
+        except MroError:
+            pass
+        return bases.Instance(self)
+
+    def getattr(self, name, context=None, class_context=True):
+        """Get an attribute from this class, using Python's attribute semantic.
+
+        This method doesn't look in the :attr:`instance_attrs` dictionary
+        since it is done by an :class:`Instance` proxy at inference time.
+        It may return an :class:`Uninferable` object if
+        the attribute has not been
+        found, but a ``__getattr__`` or ``__getattribute__`` method is defined.
+        If ``class_context`` is given, then it is considered that the
+        attribute is accessed from a class context,
+        e.g. ClassDef.attribute, otherwise it might have been accessed
+        from an instance as well. If ``class_context`` is used in that
+        case, then a lookup in the implicit metaclass and the explicit
+        metaclass will be done.
+
+        :param name: The attribute to look for.
+        :type name: str
+
+        :param class_context: Whether the attribute can be accessed statically.
+        :type class_context: bool
+
+        :returns: The attribute.
+        :rtype: list(NodeNG)
+
+        :raises AttributeInferenceError: If the attribute cannot be inferred.
+        """
+        if not name:
+            raise AttributeInferenceError(target=self, attribute=name, context=context)
+
+        values = self.locals.get(name, [])
+        if name in self.special_attributes and class_context and not values:
+            result = [self.special_attributes.lookup(name)]
+            if name == "__bases__":
+                # Need special treatment, since they are mutable
+                # and we need to return all the values.
+                result += values
+            return result
+
+        # don't modify the list in self.locals!
+        values = list(values)
+        for classnode in self.ancestors(recurs=True, context=context):
+            values += classnode.locals.get(name, [])
+
+        if class_context:
+            values += self._metaclass_lookup_attribute(name, context)
+
+        if not values:
+            raise AttributeInferenceError(target=self, attribute=name, context=context)
+
+        # Look for AnnAssigns, which are not attributes in the purest sense.
+        for value in values:
+            if isinstance(value, node_classes.AssignName):
+                stmt = value.statement(future=True)
+                if isinstance(stmt, node_classes.AnnAssign) and stmt.value is None:
+                    raise AttributeInferenceError(
+                        target=self, attribute=name, context=context
+                    )
+        return values
+
+    def _metaclass_lookup_attribute(self, name, context):
+        """Search the given name in the implicit and the explicit metaclass."""
+        attrs = set()
+        implicit_meta = self.implicit_metaclass()
+        context = copy_context(context)
+        metaclass = self.metaclass(context=context)
+        for cls in (implicit_meta, metaclass):
+            if cls and cls != self and isinstance(cls, ClassDef):
+                cls_attributes = self._get_attribute_from_metaclass(cls, name, context)
+                attrs.update(set(cls_attributes))
+        return attrs
+
+    def _get_attribute_from_metaclass(self, cls, name, context):
+        try:
+            attrs = cls.getattr(name, context=context, class_context=True)
+        except AttributeInferenceError:
+            return
+
+        for attr in bases._infer_stmts(attrs, context, frame=cls):
+            if not isinstance(attr, FunctionDef):
+                yield attr
+                continue
+
+            if isinstance(attr, objects.Property):
+                yield attr
+                continue
+            if attr.type == "classmethod":
+                # If the method is a classmethod, then it will
+                # be bound to the metaclass, not to the class
+                # from where the attribute is retrieved.
+                # get_wrapping_class could return None, so just
+                # default to the current class.
+                frame = get_wrapping_class(attr) or self
+                yield bases.BoundMethod(attr, frame)
+            elif attr.type == "staticmethod":
+                yield attr
+            else:
+                yield bases.BoundMethod(attr, self)
+
+    def igetattr(self, name, context=None, class_context=True):
+        """Infer the possible values of the given variable.
+
+        :param name: The name of the variable to infer.
+        :type name: str
+
+        :returns: The inferred possible values.
+        :rtype: iterable(NodeNG or Uninferable)
+        """
+        # set lookup name since this is necessary to infer on import nodes for
+        # instance
+        context = copy_context(context)
+        context.lookupname = name
+
+        metaclass = self.metaclass(context=context)
+        try:
+            attributes = self.getattr(name, context, class_context=class_context)
+            # If we have more than one attribute, make sure that those starting from
+            # the second one are from the same scope. This is to account for modifications
+            # to the attribute happening *after* the attribute's definition (e.g. AugAssigns on lists)
+            if len(attributes) > 1:
+                first_attr, attributes = attributes[0], attributes[1:]
+                first_scope = first_attr.scope()
+                attributes = [first_attr] + [
+                    attr
+                    for attr in attributes
+                    if attr.parent and attr.parent.scope() == first_scope
+                ]
+
+            for inferred in bases._infer_stmts(attributes, context, frame=self):
+                # yield Uninferable object instead of descriptors when necessary
+                if not isinstance(inferred, node_classes.Const) and isinstance(
+                    inferred, bases.Instance
+                ):
+                    try:
+                        inferred._proxied.getattr("__get__", context)
+                    except AttributeInferenceError:
+                        yield inferred
+                    else:
+                        yield util.Uninferable
+                elif isinstance(inferred, objects.Property):
+                    function = inferred.function
+                    if not class_context:
+                        # Through an instance so we can solve the property
+                        yield from function.infer_call_result(
+                            caller=self, context=context
+                        )
+                    # If we're in a class context, we need to determine if the property
+                    # was defined in the metaclass (a derived class must be a subclass of
+                    # the metaclass of all its bases), in which case we can resolve the
+                    # property. If not, i.e. the property is defined in some base class
+                    # instead, then we return the property object
+                    elif metaclass and function.parent.scope() is metaclass:
+                        # Resolve a property as long as it is not accessed through
+                        # the class itself.
+                        yield from function.infer_call_result(
+                            caller=self, context=context
+                        )
+                    else:
+                        yield inferred
+                else:
+                    yield function_to_method(inferred, self)
+        except AttributeInferenceError as error:
+            if not name.startswith("__") and self.has_dynamic_getattr(context):
+                # class handle some dynamic attributes, return a Uninferable object
+                yield util.Uninferable
+            else:
+                raise InferenceError(
+                    str(error), target=self, attribute=name, context=context
+                ) from error
+
+    def has_dynamic_getattr(self, context=None):
+        """Check if the class has a custom __getattr__ or __getattribute__.
+
+        If any such method is found and it is not from
+        builtins, nor from an extension module, then the function
+        will return True.
+
+        :returns: True if the class has a custom
+            __getattr__ or __getattribute__, False otherwise.
+        :rtype: bool
+        """
+
+        def _valid_getattr(node):
+            root = node.root()
+            return root.name != "builtins" and getattr(root, "pure_python", None)
+
+        try:
+            return _valid_getattr(self.getattr("__getattr__", context)[0])
+        except AttributeInferenceError:
+            # if self.newstyle: XXX cause an infinite recursion error
+            try:
+                getattribute = self.getattr("__getattribute__", context)[0]
+                return _valid_getattr(getattribute)
+            except AttributeInferenceError:
+                pass
+        return False
+
+    def getitem(self, index, context=None):
+        """Return the inference of a subscript.
+
+        This is basically looking up the method in the metaclass and calling it.
+
+        :returns: The inferred value of a subscript to this class.
+        :rtype: NodeNG
+
+        :raises AstroidTypeError: If this class does not define a
+            ``__getitem__`` method.
+        """
+        try:
+            methods = lookup(self, "__getitem__")
+        except AttributeInferenceError as exc:
+            if isinstance(self, ClassDef):
+                # subscripting a class definition may be
+                # achieved thanks to __class_getitem__ method
+                # which is a classmethod defined in the class
+                # that supports subscript and not in the metaclass
+                try:
+                    methods = self.getattr("__class_getitem__")
+                    # Here it is assumed that the __class_getitem__ node is
+                    # a FunctionDef. One possible improvement would be to deal
+                    # with more generic inference.
+                except AttributeInferenceError:
+                    raise AstroidTypeError(node=self, context=context) from exc
+            else:
+                raise AstroidTypeError(node=self, context=context) from exc
+
+        method = methods[0]
+
+        # Create a new callcontext for providing index as an argument.
+        new_context = bind_context_to_node(context, self)
+        new_context.callcontext = CallContext(args=[index], callee=method)
+
+        try:
+            return next(method.infer_call_result(self, new_context), util.Uninferable)
+        except AttributeError:
+            # Starting with python3.9, builtin types list, dict etc...
+            # are subscriptable thanks to __class_getitem___ classmethod.
+            # However in such case the method is bound to an EmptyNode and
+            # EmptyNode doesn't have infer_call_result method yielding to
+            # AttributeError
+            if (
+                isinstance(method, node_classes.EmptyNode)
+                and self.name in {"list", "dict", "set", "tuple", "frozenset"}
+                and PY39_PLUS
+            ):
+                return self
+            raise
+        except InferenceError:
+            return util.Uninferable
+
+    def methods(self):
+        """Iterate over all of the method defined in this class and its parents.
+
+        :returns: The methods defined on the class.
+        :rtype: iterable(FunctionDef)
+        """
+        done = {}
+        for astroid in itertools.chain(iter((self,)), self.ancestors()):
+            for meth in astroid.mymethods():
+                if meth.name in done:
+                    continue
+                done[meth.name] = None
+                yield meth
+
+    def mymethods(self):
+        """Iterate over all of the method defined in this class only.
+
+        :returns: The methods defined on the class.
+        :rtype: iterable(FunctionDef)
+        """
+        for member in self.values():
+            if isinstance(member, FunctionDef):
+                yield member
+
+    def implicit_metaclass(self):
+        """Get the implicit metaclass of the current class.
+
+        For newstyle classes, this will return an instance of builtins.type.
+        For oldstyle classes, it will simply return None, since there's
+        no implicit metaclass there.
+
+        :returns: The metaclass.
+        :rtype: builtins.type or None
+        """
+        if self.newstyle:
+            return builtin_lookup("type")[1][0]
+        return None
+
+    _metaclass = None
+
+    def declared_metaclass(self, context=None):
+        """Return the explicit declared metaclass for the current class.
+
+        An explicit declared metaclass is defined
+        either by passing the ``metaclass`` keyword argument
+        in the class definition line (Python 3) or (Python 2) by
+        having a ``__metaclass__`` class attribute, or if there are
+        no explicit bases but there is a global ``__metaclass__`` variable.
+
+        :returns: The metaclass of this class,
+            or None if one could not be found.
+        :rtype: NodeNG or None
+        """
+        for base in self.bases:
+            try:
+                for baseobj in base.infer(context=context):
+                    if isinstance(baseobj, ClassDef) and baseobj.hide:
+                        self._metaclass = baseobj._metaclass
+                        self._metaclass_hack = True
+                        break
+            except InferenceError:
+                pass
+
+        if self._metaclass:
+            # Expects this from Py3k TreeRebuilder
+            try:
+                return next(
+                    node
+                    for node in self._metaclass.infer(context=context)
+                    if node is not util.Uninferable
+                )
+            except (InferenceError, StopIteration):
+                return None
+
+        return None
+
+    def _find_metaclass(self, seen=None, context=None):
+        if seen is None:
+            seen = set()
+        seen.add(self)
+
+        klass = self.declared_metaclass(context=context)
+        if klass is None:
+            for parent in self.ancestors(context=context):
+                if parent not in seen:
+                    klass = parent._find_metaclass(seen)
+                    if klass is not None:
+                        break
+        return klass
+
+    def metaclass(self, context=None):
+        """Get the metaclass of this class.
+
+        If this class does not define explicitly a metaclass,
+        then the first defined metaclass in ancestors will be used
+        instead.
+
+        :returns: The metaclass of this class.
+        :rtype: NodeNG or None
+        """
+        return self._find_metaclass(context=context)
+
+    def has_metaclass_hack(self):
+        return self._metaclass_hack
+
+    def _islots(self):
+        """Return an iterator with the inferred slots."""
+        if "__slots__" not in self.locals:
+            return None
+        for slots in self.igetattr("__slots__"):
+            # check if __slots__ is a valid type
+            for meth in ITER_METHODS:
+                try:
+                    slots.getattr(meth)
+                    break
+                except AttributeInferenceError:
+                    continue
+            else:
+                continue
+
+            if isinstance(slots, node_classes.Const):
+                # a string. Ignore the following checks,
+                # but yield the node, only if it has a value
+                if slots.value:
+                    yield slots
+                continue
+            if not hasattr(slots, "itered"):
+                # we can't obtain the values, maybe a .deque?
+                continue
+
+            if isinstance(slots, node_classes.Dict):
+                values = [item[0] for item in slots.items]
+            else:
+                values = slots.itered()
+            if values is util.Uninferable:
+                continue
+            if not values:
+                # Stop the iteration, because the class
+                # has an empty list of slots.
+                return values
+
+            for elt in values:
+                try:
+                    for inferred in elt.infer():
+                        if inferred is util.Uninferable:
+                            continue
+                        if not isinstance(
+                            inferred, node_classes.Const
+                        ) or not isinstance(inferred.value, str):
+                            continue
+                        if not inferred.value:
+                            continue
+                        yield inferred
+                except InferenceError:
+                    continue
+
+        return None
+
+    def _slots(self):
+        if not self.newstyle:
+            raise NotImplementedError(
+                "The concept of slots is undefined for old-style classes."
+            )
+
+        slots = self._islots()
+        try:
+            first = next(slots)
+        except StopIteration as exc:
+            # The class doesn't have a __slots__ definition or empty slots.
+            if exc.args and exc.args[0] not in ("", None):
+                return exc.args[0]
+            return None
+        return [first] + list(slots)
+
+    # Cached, because inferring them all the time is expensive
+    @decorators_mod.cached
+    def slots(self):
+        """Get all the slots for this node.
+
+        :returns: The names of slots for this class.
+            If the class doesn't define any slot, through the ``__slots__``
+            variable, then this function will return a None.
+            Also, it will return None in the case the slots were not inferred.
+        :rtype: list(str) or None
+        """
+
+        def grouped_slots(
+            mro: List["ClassDef"],
+        ) -> typing.Iterator[Optional[node_classes.NodeNG]]:
+            # Not interested in object, since it can't have slots.
+            for cls in mro[:-1]:
+                try:
+                    cls_slots = cls._slots()
+                except NotImplementedError:
+                    continue
+                if cls_slots is not None:
+                    yield from cls_slots
+                else:
+                    yield None
+
+        if not self.newstyle:
+            raise NotImplementedError(
+                "The concept of slots is undefined for old-style classes."
+            )
+
+        try:
+            mro = self.mro()
+        except MroError as e:
+            raise NotImplementedError(
+                "Cannot get slots while parsing mro fails."
+            ) from e
+
+        slots = list(grouped_slots(mro))
+        if not all(slot is not None for slot in slots):
+            return None
+
+        return sorted(set(slots), key=lambda item: item.value)
+
+    def _inferred_bases(self, context=None):
+        # Similar with .ancestors, but the difference is when one base is inferred,
+        # only the first object is wanted. That's because
+        # we aren't interested in superclasses, as in the following
+        # example:
+        #
+        # class SomeSuperClass(object): pass
+        # class SomeClass(SomeSuperClass): pass
+        # class Test(SomeClass): pass
+        #
+        # Inferring SomeClass from the Test's bases will give
+        # us both SomeClass and SomeSuperClass, but we are interested
+        # only in SomeClass.
+
+        if context is None:
+            context = InferenceContext()
+        if not self.bases and self.qname() != "builtins.object":
+            yield builtin_lookup("object")[1][0]
+            return
+
+        for stmt in self.bases:
+            try:
+                # Find the first non-None inferred base value
+                baseobj = next(
+                    b
+                    for b in stmt.infer(context=context.clone())
+                    if not (isinstance(b, Const) and b.value is None)
+                )
+            except (InferenceError, StopIteration):
+                continue
+            if isinstance(baseobj, bases.Instance):
+                baseobj = baseobj._proxied
+            if not isinstance(baseobj, ClassDef):
+                continue
+            if not baseobj.hide:
+                yield baseobj
+            else:
+                yield from baseobj.bases
+
+    def _compute_mro(self, context=None):
+        inferred_bases = list(self._inferred_bases(context=context))
+        bases_mro = []
+        for base in inferred_bases:
+            if base is self:
+                continue
+
+            try:
+                mro = base._compute_mro(context=context)
+                bases_mro.append(mro)
+            except NotImplementedError:
+                # Some classes have in their ancestors both newstyle and
+                # old style classes. For these we can't retrieve the .mro,
+                # although in Python it's possible, since the class we are
+                # currently working is in fact new style.
+                # So, we fallback to ancestors here.
+                ancestors = list(base.ancestors(context=context))
+                bases_mro.append(ancestors)
+
+        unmerged_mro = [[self]] + bases_mro + [inferred_bases]
+        unmerged_mro = list(clean_duplicates_mro(unmerged_mro, self, context))
+        clean_typing_generic_mro(unmerged_mro)
+        return _c3_merge(unmerged_mro, self, context)
+
+    def mro(self, context=None) -> List["ClassDef"]:
+        """Get the method resolution order, using C3 linearization.
+
+        :returns: The list of ancestors, sorted by the mro.
+        :rtype: list(NodeNG)
+        :raises DuplicateBasesError: Duplicate bases in the same class base
+        :raises InconsistentMroError: A class' MRO is inconsistent
+        """
+        return self._compute_mro(context=context)
+
+    def bool_value(self, context=None):
+        """Determine the boolean value of this node.
+
+        :returns: The boolean value of this node.
+            For a :class:`ClassDef` this is always ``True``.
+        :rtype: bool
+        """
+        return True
+
+    def get_children(self):
+        if self.decorators is not None:
+            yield self.decorators
+
+        yield from self.bases
+        if self.keywords is not None:
+            yield from self.keywords
+        yield from self.body
+
+    @decorators_mod.cached
+    def _get_assign_nodes(self):
+        children_assign_nodes = (
+            child_node._get_assign_nodes() for child_node in self.body
+        )
+        return list(itertools.chain.from_iterable(children_assign_nodes))
+
+    def frame(self: T, *, future: Literal[None, True] = None) -> T:
+        """The node's frame node.
+
+        A frame node is a :class:`Module`, :class:`FunctionDef`,
+        :class:`ClassDef` or :class:`Lambda`.
+
+        :returns: The node itself.
+        """
+        return self
diff --git a/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/utils.py b/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/utils.py
new file mode 100644
index 0000000..272bdad
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/nodes/scoped_nodes/utils.py
@@ -0,0 +1,36 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""
+This module contains utility functions for scoped nodes.
+"""
+
+import builtins
+from typing import TYPE_CHECKING, Sequence, Tuple
+
+from astroid.manager import AstroidManager
+
+if TYPE_CHECKING:
+    from astroid import nodes
+
+
+_builtin_astroid: "nodes.Module | None" = None
+
+
+def builtin_lookup(name: str) -> Tuple["nodes.Module", Sequence["nodes.NodeNG"]]:
+    """Lookup a name in the builtin module.
+
+    Return the list of matching statements and the ast for the builtin module
+    """
+    # pylint: disable-next=global-statement
+    global _builtin_astroid
+    if _builtin_astroid is None:
+        _builtin_astroid = AstroidManager().ast_from_module(builtins)
+    if name == "__dict__":
+        return _builtin_astroid, ()
+    try:
+        stmts: Sequence["nodes.NodeNG"] = _builtin_astroid.locals[name]
+    except KeyError:
+        stmts = ()
+    return _builtin_astroid, stmts
diff --git a/myenv/lib/python3.9/site-packages/astroid/nodes/utils.py b/myenv/lib/python3.9/site-packages/astroid/nodes/utils.py
new file mode 100644
index 0000000..5afa718
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/nodes/utils.py
@@ -0,0 +1,14 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from typing import NamedTuple
+
+
+class Position(NamedTuple):
+    """Position with line and column information."""
+
+    lineno: int
+    col_offset: int
+    end_lineno: int
+    end_col_offset: int
diff --git a/myenv/lib/python3.9/site-packages/astroid/objects.py b/myenv/lib/python3.9/site-packages/astroid/objects.py
new file mode 100644
index 0000000..416602e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/objects.py
@@ -0,0 +1,329 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""
+Inference objects are a way to represent composite AST nodes,
+which are used only as inference results, so they can't be found in the
+original AST tree. For instance, inferring the following frozenset use,
+leads to an inferred FrozenSet:
+
+    Call(func=Name('frozenset'), args=Tuple(...))
+"""
+
+import sys
+from typing import TYPE_CHECKING
+
+from astroid import bases, decorators, util
+from astroid.exceptions import (
+    AttributeInferenceError,
+    InferenceError,
+    MroError,
+    SuperError,
+)
+from astroid.manager import AstroidManager
+from astroid.nodes import node_classes, scoped_nodes
+
+objectmodel = util.lazy_import("interpreter.objectmodel")
+
+if sys.version_info >= (3, 8) or TYPE_CHECKING:
+    from functools import cached_property
+else:
+    from astroid.decorators import cachedproperty as cached_property
+
+
+class FrozenSet(node_classes.BaseContainer):
+    """class representing a FrozenSet composite node"""
+
+    def pytype(self):
+        return "builtins.frozenset"
+
+    def _infer(self, context=None):
+        yield self
+
+    @cached_property
+    def _proxied(self):  # pylint: disable=method-hidden
+        ast_builtins = AstroidManager().builtins_module
+        return ast_builtins.getattr("frozenset")[0]
+
+
+class Super(node_classes.NodeNG):
+    """Proxy class over a super call.
+
+    This class offers almost the same behaviour as Python's super,
+    which is MRO lookups for retrieving attributes from the parents.
+
+    The *mro_pointer* is the place in the MRO from where we should
+    start looking, not counting it. *mro_type* is the object which
+    provides the MRO, it can be both a type or an instance.
+    *self_class* is the class where the super call is, while
+    *scope* is the function where the super call is.
+    """
+
+    # pylint: disable=unnecessary-lambda
+    special_attributes = util.lazy_descriptor(lambda: objectmodel.SuperModel())
+
+    def __init__(self, mro_pointer, mro_type, self_class, scope):
+        self.type = mro_type
+        self.mro_pointer = mro_pointer
+        self._class_based = False
+        self._self_class = self_class
+        self._scope = scope
+        super().__init__()
+
+    def _infer(self, context=None):
+        yield self
+
+    def super_mro(self):
+        """Get the MRO which will be used to lookup attributes in this super."""
+        if not isinstance(self.mro_pointer, scoped_nodes.ClassDef):
+            raise SuperError(
+                "The first argument to super must be a subtype of "
+                "type, not {mro_pointer}.",
+                super_=self,
+            )
+
+        if isinstance(self.type, scoped_nodes.ClassDef):
+            # `super(type, type)`, most likely in a class method.
+            self._class_based = True
+            mro_type = self.type
+        else:
+            mro_type = getattr(self.type, "_proxied", None)
+            if not isinstance(mro_type, (bases.Instance, scoped_nodes.ClassDef)):
+                raise SuperError(
+                    "The second argument to super must be an "
+                    "instance or subtype of type, not {type}.",
+                    super_=self,
+                )
+
+        if not mro_type.newstyle:
+            raise SuperError("Unable to call super on old-style classes.", super_=self)
+
+        mro = mro_type.mro()
+        if self.mro_pointer not in mro:
+            raise SuperError(
+                "The second argument to super must be an "
+                "instance or subtype of type, not {type}.",
+                super_=self,
+            )
+
+        index = mro.index(self.mro_pointer)
+        return mro[index + 1 :]
+
+    @cached_property
+    def _proxied(self):
+        ast_builtins = AstroidManager().builtins_module
+        return ast_builtins.getattr("super")[0]
+
+    def pytype(self):
+        return "builtins.super"
+
+    def display_type(self):
+        return "Super of"
+
+    @property
+    def name(self):
+        """Get the name of the MRO pointer."""
+        return self.mro_pointer.name
+
+    def qname(self):
+        return "super"
+
+    def igetattr(self, name, context=None):
+        """Retrieve the inferred values of the given attribute name."""
+
+        if name in self.special_attributes:
+            yield self.special_attributes.lookup(name)
+            return
+
+        try:
+            mro = self.super_mro()
+        # Don't let invalid MROs or invalid super calls
+        # leak out as is from this function.
+        except SuperError as exc:
+            raise AttributeInferenceError(
+                (
+                    "Lookup for {name} on {target!r} because super call {super!r} "
+                    "is invalid."
+                ),
+                target=self,
+                attribute=name,
+                context=context,
+                super_=exc.super_,
+            ) from exc
+        except MroError as exc:
+            raise AttributeInferenceError(
+                (
+                    "Lookup for {name} on {target!r} failed because {cls!r} has an "
+                    "invalid MRO."
+                ),
+                target=self,
+                attribute=name,
+                context=context,
+                mros=exc.mros,
+                cls=exc.cls,
+            ) from exc
+        found = False
+        for cls in mro:
+            if name not in cls.locals:
+                continue
+
+            found = True
+            for inferred in bases._infer_stmts([cls[name]], context, frame=self):
+                if not isinstance(inferred, scoped_nodes.FunctionDef):
+                    yield inferred
+                    continue
+
+                # We can obtain different descriptors from a super depending
+                # on what we are accessing and where the super call is.
+                if inferred.type == "classmethod":
+                    yield bases.BoundMethod(inferred, cls)
+                elif self._scope.type == "classmethod" and inferred.type == "method":
+                    yield inferred
+                elif self._class_based or inferred.type == "staticmethod":
+                    yield inferred
+                elif isinstance(inferred, Property):
+                    function = inferred.function
+                    try:
+                        yield from function.infer_call_result(
+                            caller=self, context=context
+                        )
+                    except InferenceError:
+                        yield util.Uninferable
+                elif bases._is_property(inferred):
+                    # TODO: support other descriptors as well.
+                    try:
+                        yield from inferred.infer_call_result(self, context)
+                    except InferenceError:
+                        yield util.Uninferable
+                else:
+                    yield bases.BoundMethod(inferred, cls)
+
+        if not found:
+            raise AttributeInferenceError(target=self, attribute=name, context=context)
+
+    def getattr(self, name, context=None):
+        return list(self.igetattr(name, context=context))
+
+
+class ExceptionInstance(bases.Instance):
+    """Class for instances of exceptions
+
+    It has special treatment for some of the exceptions's attributes,
+    which are transformed at runtime into certain concrete objects, such as
+    the case of .args.
+    """
+
+    @cached_property
+    def special_attributes(self):
+        qname = self.qname()
+        instance = objectmodel.BUILTIN_EXCEPTIONS.get(
+            qname, objectmodel.ExceptionInstanceModel
+        )
+        return instance()(self)
+
+
+class DictInstance(bases.Instance):
+    """Special kind of instances for dictionaries
+
+    This instance knows the underlying object model of the dictionaries, which means
+    that methods such as .values or .items can be properly inferred.
+    """
+
+    # pylint: disable=unnecessary-lambda
+    special_attributes = util.lazy_descriptor(lambda: objectmodel.DictModel())
+
+
+# Custom objects tailored for dictionaries, which are used to
+# disambiguate between the types of Python 2 dict's method returns
+# and Python 3 (where they return set like objects).
+class DictItems(bases.Proxy):
+    __str__ = node_classes.NodeNG.__str__
+    __repr__ = node_classes.NodeNG.__repr__
+
+
+class DictKeys(bases.Proxy):
+    __str__ = node_classes.NodeNG.__str__
+    __repr__ = node_classes.NodeNG.__repr__
+
+
+class DictValues(bases.Proxy):
+    __str__ = node_classes.NodeNG.__str__
+    __repr__ = node_classes.NodeNG.__repr__
+
+
+class PartialFunction(scoped_nodes.FunctionDef):
+    """A class representing partial function obtained via functools.partial"""
+
+    @decorators.deprecate_arguments(doc="Use the postinit arg 'doc_node' instead")
+    def __init__(
+        self, call, name=None, doc=None, lineno=None, col_offset=None, parent=None
+    ):
+        # TODO: Pass end_lineno and end_col_offset as well
+        super().__init__(name, lineno=lineno, col_offset=col_offset, parent=None)
+        # Assigned directly to prevent triggering the DeprecationWarning.
+        self._doc = doc
+        # A typical FunctionDef automatically adds its name to the parent scope,
+        # but a partial should not, so defer setting parent until after init
+        self.parent = parent
+        self.filled_args = call.positional_arguments[1:]
+        self.filled_keywords = call.keyword_arguments
+
+        wrapped_function = call.positional_arguments[0]
+        inferred_wrapped_function = next(wrapped_function.infer())
+        if isinstance(inferred_wrapped_function, PartialFunction):
+            self.filled_args = inferred_wrapped_function.filled_args + self.filled_args
+            self.filled_keywords = {
+                **inferred_wrapped_function.filled_keywords,
+                **self.filled_keywords,
+            }
+
+        self.filled_positionals = len(self.filled_args)
+
+    def infer_call_result(self, caller=None, context=None):
+        if context:
+            current_passed_keywords = {
+                keyword for (keyword, _) in context.callcontext.keywords
+            }
+            for keyword, value in self.filled_keywords.items():
+                if keyword not in current_passed_keywords:
+                    context.callcontext.keywords.append((keyword, value))
+
+            call_context_args = context.callcontext.args or []
+            context.callcontext.args = self.filled_args + call_context_args
+
+        return super().infer_call_result(caller=caller, context=context)
+
+    def qname(self):
+        return self.__class__.__name__
+
+
+# TODO: Hack to solve the circular import problem between node_classes and objects
+# This is not needed in 2.0, which has a cleaner design overall
+node_classes.Dict.__bases__ = (node_classes.NodeNG, DictInstance)
+
+
+class Property(scoped_nodes.FunctionDef):
+    """Class representing a Python property"""
+
+    @decorators.deprecate_arguments(doc="Use the postinit arg 'doc_node' instead")
+    def __init__(
+        self, function, name=None, doc=None, lineno=None, col_offset=None, parent=None
+    ):
+        self.function = function
+        super().__init__(name, lineno=lineno, col_offset=col_offset, parent=parent)
+        # Assigned directly to prevent triggering the DeprecationWarning.
+        self._doc = doc
+
+    # pylint: disable=unnecessary-lambda
+    special_attributes = util.lazy_descriptor(lambda: objectmodel.PropertyModel())
+    type = "property"
+
+    def pytype(self):
+        return "builtins.property"
+
+    def infer_call_result(self, caller=None, context=None):
+        raise InferenceError("Properties are not callable")
+
+    def infer(self, context=None, **kwargs):
+        return iter((self,))
diff --git a/myenv/lib/python3.9/site-packages/astroid/protocols.py b/myenv/lib/python3.9/site-packages/astroid/protocols.py
new file mode 100644
index 0000000..f1fcec0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/protocols.py
@@ -0,0 +1,894 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""this module contains a set of functions to handle python protocols for nodes
+where it makes sense.
+"""
+
+import collections
+import itertools
+import operator as operator_mod
+from typing import Any, Generator, List, Optional, Union
+
+from astroid import arguments, bases, decorators, helpers, nodes, util
+from astroid.const import Context
+from astroid.context import InferenceContext, copy_context
+from astroid.exceptions import (
+    AstroidIndexError,
+    AstroidTypeError,
+    AttributeInferenceError,
+    InferenceError,
+    NoDefault,
+)
+from astroid.nodes import node_classes
+
+raw_building = util.lazy_import("raw_building")
+objects = util.lazy_import("objects")
+
+
+def _reflected_name(name):
+    return "__r" + name[2:]
+
+
+def _augmented_name(name):
+    return "__i" + name[2:]
+
+
+_CONTEXTLIB_MGR = "contextlib.contextmanager"
+BIN_OP_METHOD = {
+    "+": "__add__",
+    "-": "__sub__",
+    "/": "__truediv__",
+    "//": "__floordiv__",
+    "*": "__mul__",
+    "**": "__pow__",
+    "%": "__mod__",
+    "&": "__and__",
+    "|": "__or__",
+    "^": "__xor__",
+    "<<": "__lshift__",
+    ">>": "__rshift__",
+    "@": "__matmul__",
+}
+
+REFLECTED_BIN_OP_METHOD = {
+    key: _reflected_name(value) for (key, value) in BIN_OP_METHOD.items()
+}
+AUGMENTED_OP_METHOD = {
+    key + "=": _augmented_name(value) for (key, value) in BIN_OP_METHOD.items()
+}
+
+UNARY_OP_METHOD = {
+    "+": "__pos__",
+    "-": "__neg__",
+    "~": "__invert__",
+    "not": None,  # XXX not '__nonzero__'
+}
+_UNARY_OPERATORS = {
+    "+": operator_mod.pos,
+    "-": operator_mod.neg,
+    "~": operator_mod.invert,
+    "not": operator_mod.not_,
+}
+
+
+def _infer_unary_op(obj, op):
+    func = _UNARY_OPERATORS[op]
+    value = func(obj)
+    return nodes.const_factory(value)
+
+
+nodes.Tuple.infer_unary_op = lambda self, op: _infer_unary_op(tuple(self.elts), op)
+nodes.List.infer_unary_op = lambda self, op: _infer_unary_op(self.elts, op)
+nodes.Set.infer_unary_op = lambda self, op: _infer_unary_op(set(self.elts), op)
+nodes.Const.infer_unary_op = lambda self, op: _infer_unary_op(self.value, op)
+nodes.Dict.infer_unary_op = lambda self, op: _infer_unary_op(dict(self.items), op)
+
+# Binary operations
+
+BIN_OP_IMPL = {
+    "+": lambda a, b: a + b,
+    "-": lambda a, b: a - b,
+    "/": lambda a, b: a / b,
+    "//": lambda a, b: a // b,
+    "*": lambda a, b: a * b,
+    "**": lambda a, b: a**b,
+    "%": lambda a, b: a % b,
+    "&": lambda a, b: a & b,
+    "|": lambda a, b: a | b,
+    "^": lambda a, b: a ^ b,
+    "<<": lambda a, b: a << b,
+    ">>": lambda a, b: a >> b,
+    "@": operator_mod.matmul,
+}
+for _KEY, _IMPL in list(BIN_OP_IMPL.items()):
+    BIN_OP_IMPL[_KEY + "="] = _IMPL
+
+
+@decorators.yes_if_nothing_inferred
+def const_infer_binary_op(self, opnode, operator, other, context, _):
+    not_implemented = nodes.Const(NotImplemented)
+    if isinstance(other, nodes.Const):
+        try:
+            impl = BIN_OP_IMPL[operator]
+            try:
+                yield nodes.const_factory(impl(self.value, other.value))
+            except TypeError:
+                # ArithmeticError is not enough: float >> float is a TypeError
+                yield not_implemented
+            except Exception:  # pylint: disable=broad-except
+                yield util.Uninferable
+        except TypeError:
+            yield not_implemented
+    elif isinstance(self.value, str) and operator == "%":
+        # TODO(cpopa): implement string interpolation later on.
+        yield util.Uninferable
+    else:
+        yield not_implemented
+
+
+nodes.Const.infer_binary_op = const_infer_binary_op
+
+
+def _multiply_seq_by_int(self, opnode, other, context):
+    node = self.__class__(parent=opnode)
+    filtered_elts = (
+        helpers.safe_infer(elt, context) or util.Uninferable
+        for elt in self.elts
+        if elt is not util.Uninferable
+    )
+    node.elts = list(filtered_elts) * other.value
+    return node
+
+
+def _filter_uninferable_nodes(elts, context):
+    for elt in elts:
+        if elt is util.Uninferable:
+            yield nodes.Unknown()
+        else:
+            for inferred in elt.infer(context):
+                if inferred is not util.Uninferable:
+                    yield inferred
+                else:
+                    yield nodes.Unknown()
+
+
+@decorators.yes_if_nothing_inferred
+def tl_infer_binary_op(
+    self,
+    opnode: nodes.BinOp,
+    operator: str,
+    other: nodes.NodeNG,
+    context: InferenceContext,
+    method: nodes.FunctionDef,
+) -> Generator[nodes.NodeNG, None, None]:
+    """Infer a binary operation on a tuple or list.
+
+    The instance on which the binary operation is performed is a tuple
+    or list. This refers to the left-hand side of the operation, so:
+    'tuple() + 1' or '[] + A()'
+    """
+    # For tuples and list the boundnode is no longer the tuple or list instance
+    context.boundnode = None
+    not_implemented = nodes.Const(NotImplemented)
+    if isinstance(other, self.__class__) and operator == "+":
+        node = self.__class__(parent=opnode)
+        node.elts = list(
+            itertools.chain(
+                _filter_uninferable_nodes(self.elts, context),
+                _filter_uninferable_nodes(other.elts, context),
+            )
+        )
+        yield node
+    elif isinstance(other, nodes.Const) and operator == "*":
+        if not isinstance(other.value, int):
+            yield not_implemented
+            return
+        yield _multiply_seq_by_int(self, opnode, other, context)
+    elif isinstance(other, bases.Instance) and operator == "*":
+        # Verify if the instance supports __index__.
+        as_index = helpers.class_instance_as_index(other)
+        if not as_index:
+            yield util.Uninferable
+        else:
+            yield _multiply_seq_by_int(self, opnode, as_index, context)
+    else:
+        yield not_implemented
+
+
+nodes.Tuple.infer_binary_op = tl_infer_binary_op
+nodes.List.infer_binary_op = tl_infer_binary_op
+
+
+@decorators.yes_if_nothing_inferred
+def instance_class_infer_binary_op(self, opnode, operator, other, context, method):
+    return method.infer_call_result(self, context)
+
+
+bases.Instance.infer_binary_op = instance_class_infer_binary_op
+nodes.ClassDef.infer_binary_op = instance_class_infer_binary_op
+
+
+# assignment ##################################################################
+
+"""the assigned_stmts method is responsible to return the assigned statement
+(e.g. not inferred) according to the assignment type.
+
+The `assign_path` argument is used to record the lhs path of the original node.
+For instance if we want assigned statements for 'c' in 'a, (b,c)', assign_path
+will be [1, 1] once arrived to the Assign node.
+
+The `context` argument is the current inference context which should be given
+to any intermediary inference necessary.
+"""
+
+
+def _resolve_looppart(parts, assign_path, context):
+    """recursive function to resolve multiple assignments on loops"""
+    assign_path = assign_path[:]
+    index = assign_path.pop(0)
+    for part in parts:
+        if part is util.Uninferable:
+            continue
+        if not hasattr(part, "itered"):
+            continue
+        try:
+            itered = part.itered()
+        except TypeError:
+            continue
+        for stmt in itered:
+            index_node = nodes.Const(index)
+            try:
+                assigned = stmt.getitem(index_node, context)
+            except (AttributeError, AstroidTypeError, AstroidIndexError):
+                continue
+            if not assign_path:
+                # we achieved to resolved the assignment path,
+                # don't infer the last part
+                yield assigned
+            elif assigned is util.Uninferable:
+                break
+            else:
+                # we are not yet on the last part of the path
+                # search on each possibly inferred value
+                try:
+                    yield from _resolve_looppart(
+                        assigned.infer(context), assign_path, context
+                    )
+                except InferenceError:
+                    break
+
+
+@decorators.raise_if_nothing_inferred
+def for_assigned_stmts(
+    self: Union[nodes.For, nodes.Comprehension],
+    node: node_classes.AssignedStmtsPossibleNode = None,
+    context: Optional[InferenceContext] = None,
+    assign_path: Optional[List[int]] = None,
+) -> Any:
+    if isinstance(self, nodes.AsyncFor) or getattr(self, "is_async", False):
+        # Skip inferring of async code for now
+        return dict(node=self, unknown=node, assign_path=assign_path, context=context)
+    if assign_path is None:
+        for lst in self.iter.infer(context):
+            if isinstance(lst, (nodes.Tuple, nodes.List)):
+                yield from lst.elts
+    else:
+        yield from _resolve_looppart(self.iter.infer(context), assign_path, context)
+    return dict(node=self, unknown=node, assign_path=assign_path, context=context)
+
+
+nodes.For.assigned_stmts = for_assigned_stmts
+nodes.Comprehension.assigned_stmts = for_assigned_stmts
+
+
+def sequence_assigned_stmts(
+    self: Union[nodes.Tuple, nodes.List],
+    node: node_classes.AssignedStmtsPossibleNode = None,
+    context: Optional[InferenceContext] = None,
+    assign_path: Optional[List[int]] = None,
+) -> Any:
+    if assign_path is None:
+        assign_path = []
+    try:
+        index = self.elts.index(node)
+    except ValueError as exc:
+        raise InferenceError(
+            "Tried to retrieve a node {node!r} which does not exist",
+            node=self,
+            assign_path=assign_path,
+            context=context,
+        ) from exc
+
+    assign_path.insert(0, index)
+    return self.parent.assigned_stmts(
+        node=self, context=context, assign_path=assign_path
+    )
+
+
+nodes.Tuple.assigned_stmts = sequence_assigned_stmts
+nodes.List.assigned_stmts = sequence_assigned_stmts
+
+
+def assend_assigned_stmts(
+    self: Union[nodes.AssignName, nodes.AssignAttr],
+    node: node_classes.AssignedStmtsPossibleNode = None,
+    context: Optional[InferenceContext] = None,
+    assign_path: Optional[List[int]] = None,
+) -> Any:
+    return self.parent.assigned_stmts(node=self, context=context)
+
+
+nodes.AssignName.assigned_stmts = assend_assigned_stmts
+nodes.AssignAttr.assigned_stmts = assend_assigned_stmts
+
+
+def _arguments_infer_argname(self, name, context):
+    # arguments information may be missing, in which case we can't do anything
+    # more
+    if not (self.arguments or self.vararg or self.kwarg):
+        yield util.Uninferable
+        return
+
+    functype = self.parent.type
+    # first argument of instance/class method
+    if (
+        self.arguments
+        and getattr(self.arguments[0], "name", None) == name
+        and functype != "staticmethod"
+    ):
+        cls = self.parent.parent.scope()
+        is_metaclass = isinstance(cls, nodes.ClassDef) and cls.type == "metaclass"
+        # If this is a metaclass, then the first argument will always
+        # be the class, not an instance.
+        if context.boundnode and isinstance(context.boundnode, bases.Instance):
+            cls = context.boundnode._proxied
+        if is_metaclass or functype == "classmethod":
+            yield cls
+            return
+        if functype == "method":
+            yield cls.instantiate_class()
+            return
+
+    if context and context.callcontext:
+        callee = context.callcontext.callee
+        while hasattr(callee, "_proxied"):
+            callee = callee._proxied
+        if getattr(callee, "name", None) == self.parent.name:
+            call_site = arguments.CallSite(context.callcontext, context.extra_context)
+            yield from call_site.infer_argument(self.parent, name, context)
+            return
+
+    if name == self.vararg:
+        vararg = nodes.const_factory(())
+        vararg.parent = self
+        if not self.arguments and self.parent.name == "__init__":
+            cls = self.parent.parent.scope()
+            vararg.elts = [cls.instantiate_class()]
+        yield vararg
+        return
+    if name == self.kwarg:
+        kwarg = nodes.const_factory({})
+        kwarg.parent = self
+        yield kwarg
+        return
+    # if there is a default value, yield it. And then yield Uninferable to reflect
+    # we can't guess given argument value
+    try:
+        context = copy_context(context)
+        yield from self.default_value(name).infer(context)
+        yield util.Uninferable
+    except NoDefault:
+        yield util.Uninferable
+
+
+def arguments_assigned_stmts(
+    self: nodes.Arguments,
+    node: node_classes.AssignedStmtsPossibleNode = None,
+    context: Optional[InferenceContext] = None,
+    assign_path: Optional[List[int]] = None,
+) -> Any:
+    if context.callcontext:
+        callee = context.callcontext.callee
+        while hasattr(callee, "_proxied"):
+            callee = callee._proxied
+    else:
+        callee = None
+    if (
+        context.callcontext
+        and node
+        and getattr(callee, "name", None) == node.frame(future=True).name
+    ):
+        # reset call context/name
+        callcontext = context.callcontext
+        context = copy_context(context)
+        context.callcontext = None
+        args = arguments.CallSite(callcontext, context=context)
+        return args.infer_argument(self.parent, node.name, context)
+    return _arguments_infer_argname(self, node.name, context)
+
+
+nodes.Arguments.assigned_stmts = arguments_assigned_stmts
+
+
+@decorators.raise_if_nothing_inferred
+def assign_assigned_stmts(
+    self: Union[nodes.AugAssign, nodes.Assign, nodes.AnnAssign],
+    node: node_classes.AssignedStmtsPossibleNode = None,
+    context: Optional[InferenceContext] = None,
+    assign_path: Optional[List[int]] = None,
+) -> Any:
+    if not assign_path:
+        yield self.value
+        return None
+    yield from _resolve_assignment_parts(
+        self.value.infer(context), assign_path, context
+    )
+
+    return dict(node=self, unknown=node, assign_path=assign_path, context=context)
+
+
+def assign_annassigned_stmts(
+    self: nodes.AnnAssign,
+    node: node_classes.AssignedStmtsPossibleNode = None,
+    context: Optional[InferenceContext] = None,
+    assign_path: Optional[List[int]] = None,
+) -> Any:
+    for inferred in assign_assigned_stmts(self, node, context, assign_path):
+        if inferred is None:
+            yield util.Uninferable
+        else:
+            yield inferred
+
+
+nodes.Assign.assigned_stmts = assign_assigned_stmts
+nodes.AnnAssign.assigned_stmts = assign_annassigned_stmts
+nodes.AugAssign.assigned_stmts = assign_assigned_stmts
+
+
+def _resolve_assignment_parts(parts, assign_path, context):
+    """recursive function to resolve multiple assignments"""
+    assign_path = assign_path[:]
+    index = assign_path.pop(0)
+    for part in parts:
+        assigned = None
+        if isinstance(part, nodes.Dict):
+            # A dictionary in an iterating context
+            try:
+                assigned, _ = part.items[index]
+            except IndexError:
+                return
+
+        elif hasattr(part, "getitem"):
+            index_node = nodes.Const(index)
+            try:
+                assigned = part.getitem(index_node, context)
+            except (AstroidTypeError, AstroidIndexError):
+                return
+
+        if not assigned:
+            return
+
+        if not assign_path:
+            # we achieved to resolved the assignment path, don't infer the
+            # last part
+            yield assigned
+        elif assigned is util.Uninferable:
+            return
+        else:
+            # we are not yet on the last part of the path search on each
+            # possibly inferred value
+            try:
+                yield from _resolve_assignment_parts(
+                    assigned.infer(context), assign_path, context
+                )
+            except InferenceError:
+                return
+
+
+@decorators.raise_if_nothing_inferred
+def excepthandler_assigned_stmts(
+    self: nodes.ExceptHandler,
+    node: node_classes.AssignedStmtsPossibleNode = None,
+    context: Optional[InferenceContext] = None,
+    assign_path: Optional[List[int]] = None,
+) -> Any:
+    for assigned in node_classes.unpack_infer(self.type):
+        if isinstance(assigned, nodes.ClassDef):
+            assigned = objects.ExceptionInstance(assigned)
+
+        yield assigned
+    return dict(node=self, unknown=node, assign_path=assign_path, context=context)
+
+
+nodes.ExceptHandler.assigned_stmts = excepthandler_assigned_stmts
+
+
+def _infer_context_manager(self, mgr, context):
+    try:
+        inferred = next(mgr.infer(context=context))
+    except StopIteration as e:
+        raise InferenceError(node=mgr) from e
+    if isinstance(inferred, bases.Generator):
+        # Check if it is decorated with contextlib.contextmanager.
+        func = inferred.parent
+        if not func.decorators:
+            raise InferenceError(
+                "No decorators found on inferred generator %s", node=func
+            )
+
+        for decorator_node in func.decorators.nodes:
+            decorator = next(decorator_node.infer(context=context), None)
+            if isinstance(decorator, nodes.FunctionDef):
+                if decorator.qname() == _CONTEXTLIB_MGR:
+                    break
+        else:
+            # It doesn't interest us.
+            raise InferenceError(node=func)
+        try:
+            yield next(inferred.infer_yield_types())
+        except StopIteration as e:
+            raise InferenceError(node=func) from e
+
+    elif isinstance(inferred, bases.Instance):
+        try:
+            enter = next(inferred.igetattr("__enter__", context=context))
+        except (InferenceError, AttributeInferenceError, StopIteration) as exc:
+            raise InferenceError(node=inferred) from exc
+        if not isinstance(enter, bases.BoundMethod):
+            raise InferenceError(node=enter)
+        yield from enter.infer_call_result(self, context)
+    else:
+        raise InferenceError(node=mgr)
+
+
+@decorators.raise_if_nothing_inferred
+def with_assigned_stmts(
+    self: nodes.With,
+    node: node_classes.AssignedStmtsPossibleNode = None,
+    context: Optional[InferenceContext] = None,
+    assign_path: Optional[List[int]] = None,
+) -> Any:
+    """Infer names and other nodes from a *with* statement.
+
+    This enables only inference for name binding in a *with* statement.
+    For instance, in the following code, inferring `func` will return
+    the `ContextManager` class, not whatever ``__enter__`` returns.
+    We are doing this intentionally, because we consider that the context
+    manager result is whatever __enter__ returns and what it is binded
+    using the ``as`` keyword.
+
+        class ContextManager(object):
+            def __enter__(self):
+                return 42
+        with ContextManager() as f:
+            pass
+
+        # ContextManager().infer() will return ContextManager
+        # f.infer() will return 42.
+
+    Arguments:
+        self: nodes.With
+        node: The target of the assignment, `as (a, b)` in `with foo as (a, b)`.
+        context: Inference context used for caching already inferred objects
+        assign_path:
+            A list of indices, where each index specifies what item to fetch from
+            the inference results.
+    """
+    try:
+        mgr = next(mgr for (mgr, vars) in self.items if vars == node)
+    except StopIteration:
+        return None
+    if assign_path is None:
+        yield from _infer_context_manager(self, mgr, context)
+    else:
+        for result in _infer_context_manager(self, mgr, context):
+            # Walk the assign_path and get the item at the final index.
+            obj = result
+            for index in assign_path:
+                if not hasattr(obj, "elts"):
+                    raise InferenceError(
+                        "Wrong type ({targets!r}) for {node!r} assignment",
+                        node=self,
+                        targets=node,
+                        assign_path=assign_path,
+                        context=context,
+                    )
+                try:
+                    obj = obj.elts[index]
+                except IndexError as exc:
+                    raise InferenceError(
+                        "Tried to infer a nonexistent target with index {index} "
+                        "in {node!r}.",
+                        node=self,
+                        targets=node,
+                        assign_path=assign_path,
+                        context=context,
+                    ) from exc
+                except TypeError as exc:
+                    raise InferenceError(
+                        "Tried to unpack a non-iterable value " "in {node!r}.",
+                        node=self,
+                        targets=node,
+                        assign_path=assign_path,
+                        context=context,
+                    ) from exc
+            yield obj
+    return dict(node=self, unknown=node, assign_path=assign_path, context=context)
+
+
+nodes.With.assigned_stmts = with_assigned_stmts
+
+
+@decorators.raise_if_nothing_inferred
+def named_expr_assigned_stmts(
+    self: nodes.NamedExpr,
+    node: node_classes.AssignedStmtsPossibleNode,
+    context: Optional[InferenceContext] = None,
+    assign_path: Optional[List[int]] = None,
+) -> Any:
+    """Infer names and other nodes from an assignment expression"""
+    if self.target == node:
+        yield from self.value.infer(context=context)
+    else:
+        raise InferenceError(
+            "Cannot infer NamedExpr node {node!r}",
+            node=self,
+            assign_path=assign_path,
+            context=context,
+        )
+
+
+nodes.NamedExpr.assigned_stmts = named_expr_assigned_stmts
+
+
+@decorators.yes_if_nothing_inferred
+def starred_assigned_stmts(
+    self: nodes.Starred,
+    node: node_classes.AssignedStmtsPossibleNode = None,
+    context: Optional[InferenceContext] = None,
+    assign_path: Optional[List[int]] = None,
+) -> Any:
+    """
+    Arguments:
+        self: nodes.Starred
+        node: a node related to the current underlying Node.
+        context: Inference context used for caching already inferred objects
+        assign_path:
+            A list of indices, where each index specifies what item to fetch from
+            the inference results.
+    """
+    # pylint: disable=too-many-locals,too-many-statements
+    def _determine_starred_iteration_lookups(starred, target, lookups):
+        # Determine the lookups for the rhs of the iteration
+        itered = target.itered()
+        for index, element in enumerate(itered):
+            if (
+                isinstance(element, nodes.Starred)
+                and element.value.name == starred.value.name
+            ):
+                lookups.append((index, len(itered)))
+                break
+            if isinstance(element, nodes.Tuple):
+                lookups.append((index, len(element.itered())))
+                _determine_starred_iteration_lookups(starred, element, lookups)
+
+    stmt = self.statement(future=True)
+    if not isinstance(stmt, (nodes.Assign, nodes.For)):
+        raise InferenceError(
+            "Statement {stmt!r} enclosing {node!r} " "must be an Assign or For node.",
+            node=self,
+            stmt=stmt,
+            unknown=node,
+            context=context,
+        )
+
+    if context is None:
+        context = InferenceContext()
+
+    if isinstance(stmt, nodes.Assign):
+        value = stmt.value
+        lhs = stmt.targets[0]
+        if not isinstance(lhs, nodes.BaseContainer):
+            yield util.Uninferable
+            return
+
+        if sum(1 for _ in lhs.nodes_of_class(nodes.Starred)) > 1:
+            raise InferenceError(
+                "Too many starred arguments in the " " assignment targets {lhs!r}.",
+                node=self,
+                targets=lhs,
+                unknown=node,
+                context=context,
+            )
+
+        try:
+            rhs = next(value.infer(context))
+        except (InferenceError, StopIteration):
+            yield util.Uninferable
+            return
+        if rhs is util.Uninferable or not hasattr(rhs, "itered"):
+            yield util.Uninferable
+            return
+
+        try:
+            elts = collections.deque(rhs.itered())
+        except TypeError:
+            yield util.Uninferable
+            return
+
+        # Unpack iteratively the values from the rhs of the assignment,
+        # until the find the starred node. What will remain will
+        # be the list of values which the Starred node will represent
+        # This is done in two steps, from left to right to remove
+        # anything before the starred node and from right to left
+        # to remove anything after the starred node.
+
+        for index, left_node in enumerate(lhs.elts):
+            if not isinstance(left_node, nodes.Starred):
+                if not elts:
+                    break
+                elts.popleft()
+                continue
+            lhs_elts = collections.deque(reversed(lhs.elts[index:]))
+            for right_node in lhs_elts:
+                if not isinstance(right_node, nodes.Starred):
+                    if not elts:
+                        break
+                    elts.pop()
+                    continue
+
+                # We're done unpacking.
+                packed = nodes.List(
+                    ctx=Context.Store,
+                    parent=self,
+                    lineno=lhs.lineno,
+                    col_offset=lhs.col_offset,
+                )
+                packed.postinit(elts=list(elts))
+                yield packed
+                break
+
+    if isinstance(stmt, nodes.For):
+        try:
+            inferred_iterable = next(stmt.iter.infer(context=context))
+        except (InferenceError, StopIteration):
+            yield util.Uninferable
+            return
+        if inferred_iterable is util.Uninferable or not hasattr(
+            inferred_iterable, "itered"
+        ):
+            yield util.Uninferable
+            return
+        try:
+            itered = inferred_iterable.itered()
+        except TypeError:
+            yield util.Uninferable
+            return
+
+        target = stmt.target
+
+        if not isinstance(target, nodes.Tuple):
+            raise InferenceError(
+                "Could not make sense of this, the target must be a tuple",
+                context=context,
+            )
+
+        lookups = []
+        _determine_starred_iteration_lookups(self, target, lookups)
+        if not lookups:
+            raise InferenceError(
+                "Could not make sense of this, needs at least a lookup", context=context
+            )
+
+        # Make the last lookup a slice, since that what we want for a Starred node
+        last_element_index, last_element_length = lookups[-1]
+        is_starred_last = last_element_index == (last_element_length - 1)
+
+        lookup_slice = slice(
+            last_element_index,
+            None if is_starred_last else (last_element_length - last_element_index),
+        )
+        lookups[-1] = lookup_slice
+
+        for element in itered:
+
+            # We probably want to infer the potential values *for each* element in an
+            # iterable, but we can't infer a list of all values, when only a list of
+            # step values are expected:
+            #
+            # for a, *b in [...]:
+            #   b
+            #
+            # *b* should now point to just the elements at that particular iteration step,
+            # which astroid can't know about.
+
+            found_element = None
+            for lookup in lookups:
+                if not hasattr(element, "itered"):
+                    break
+                if not isinstance(lookup, slice):
+                    # Grab just the index, not the whole length
+                    lookup = lookup[0]
+                try:
+                    itered_inner_element = element.itered()
+                    element = itered_inner_element[lookup]
+                except IndexError:
+                    break
+                except TypeError:
+                    # Most likely the itered() call failed, cannot make sense of this
+                    yield util.Uninferable
+                    return
+                else:
+                    found_element = element
+
+            unpacked = nodes.List(
+                ctx=Context.Store,
+                parent=self,
+                lineno=self.lineno,
+                col_offset=self.col_offset,
+            )
+            unpacked.postinit(elts=found_element or [])
+            yield unpacked
+            return
+
+        yield util.Uninferable
+
+
+nodes.Starred.assigned_stmts = starred_assigned_stmts
+
+
+@decorators.yes_if_nothing_inferred
+def match_mapping_assigned_stmts(
+    self: nodes.MatchMapping,
+    node: nodes.AssignName,
+    context: Optional[InferenceContext] = None,
+    assign_path: None = None,
+) -> Generator[nodes.NodeNG, None, None]:
+    """Return empty generator (return -> raises StopIteration) so inferred value
+    is Uninferable.
+    """
+    return
+    yield
+
+
+nodes.MatchMapping.assigned_stmts = match_mapping_assigned_stmts
+
+
+@decorators.yes_if_nothing_inferred
+def match_star_assigned_stmts(
+    self: nodes.MatchStar,
+    node: nodes.AssignName,
+    context: Optional[InferenceContext] = None,
+    assign_path: None = None,
+) -> Generator[nodes.NodeNG, None, None]:
+    """Return empty generator (return -> raises StopIteration) so inferred value
+    is Uninferable.
+    """
+    return
+    yield
+
+
+nodes.MatchStar.assigned_stmts = match_star_assigned_stmts
+
+
+@decorators.yes_if_nothing_inferred
+def match_as_assigned_stmts(
+    self: nodes.MatchAs,
+    node: nodes.AssignName,
+    context: Optional[InferenceContext] = None,
+    assign_path: None = None,
+) -> Generator[nodes.NodeNG, None, None]:
+    """Infer MatchAs as the Match subject if it's the only MatchCase pattern
+    else raise StopIteration to yield Uninferable.
+    """
+    if (
+        isinstance(self.parent, nodes.MatchCase)
+        and isinstance(self.parent.parent, nodes.Match)
+        and self.pattern is None
+    ):
+        yield self.parent.parent.subject
+
+
+nodes.MatchAs.assigned_stmts = match_as_assigned_stmts
diff --git a/myenv/lib/python3.9/site-packages/astroid/raw_building.py b/myenv/lib/python3.9/site-packages/astroid/raw_building.py
new file mode 100644
index 0000000..bcc414b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/raw_building.py
@@ -0,0 +1,508 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""this module contains a set of functions to create astroid trees from scratch
+(build_* functions) or from living object (object_build_* functions)
+"""
+
+import builtins
+import inspect
+import os
+import sys
+import types
+import warnings
+from typing import Iterable, List, Optional
+
+from astroid import bases, nodes
+from astroid.manager import AstroidManager
+from astroid.nodes import node_classes
+
+# the keys of CONST_CLS eg python builtin types
+_CONSTANTS = tuple(node_classes.CONST_CLS)
+_BUILTINS = vars(builtins)
+TYPE_NONE = type(None)
+TYPE_NOTIMPLEMENTED = type(NotImplemented)
+TYPE_ELLIPSIS = type(...)
+
+
+def _attach_local_node(parent, node, name):
+    node.name = name  # needed by add_local_node
+    parent.add_local_node(node)
+
+
+def _add_dunder_class(func, member):
+    """Add a __class__ member to the given func node, if we can determine it."""
+    python_cls = member.__class__
+    cls_name = getattr(python_cls, "__name__", None)
+    if not cls_name:
+        return
+    cls_bases = [ancestor.__name__ for ancestor in python_cls.__bases__]
+    ast_klass = build_class(cls_name, cls_bases, python_cls.__doc__)
+    func.instance_attrs["__class__"] = [ast_klass]
+
+
+_marker = object()
+
+
+def attach_dummy_node(node, name, runtime_object=_marker):
+    """create a dummy node and register it in the locals of the given
+    node with the specified name
+    """
+    enode = nodes.EmptyNode()
+    enode.object = runtime_object
+    _attach_local_node(node, enode, name)
+
+
+def _has_underlying_object(self):
+    return self.object is not None and self.object is not _marker
+
+
+nodes.EmptyNode.has_underlying_object = _has_underlying_object
+
+
+def attach_const_node(node, name, value):
+    """create a Const node and register it in the locals of the given
+    node with the specified name
+    """
+    if name not in node.special_attributes:
+        _attach_local_node(node, nodes.const_factory(value), name)
+
+
+def attach_import_node(node, modname, membername):
+    """create a ImportFrom node and register it in the locals of the given
+    node with the specified name
+    """
+    from_node = nodes.ImportFrom(modname, [(membername, None)])
+    _attach_local_node(node, from_node, membername)
+
+
+def build_module(name: str, doc: Optional[str] = None) -> nodes.Module:
+    """create and initialize an astroid Module node"""
+    node = nodes.Module(name, pure_python=False, package=False)
+    node.postinit(
+        body=[],
+        doc_node=nodes.Const(value=doc) if doc else None,
+    )
+    return node
+
+
+def build_class(
+    name: str, basenames: Iterable[str] = (), doc: Optional[str] = None
+) -> nodes.ClassDef:
+    """Create and initialize an astroid ClassDef node."""
+    node = nodes.ClassDef(name)
+    node.postinit(
+        bases=[nodes.Name(name=base, parent=node) for base in basenames],
+        body=[],
+        decorators=None,
+        doc_node=nodes.Const(value=doc) if doc else None,
+    )
+    return node
+
+
+def build_function(
+    name,
+    args: Optional[List[str]] = None,
+    posonlyargs: Optional[List[str]] = None,
+    defaults=None,
+    doc: Optional[str] = None,
+    kwonlyargs: Optional[List[str]] = None,
+) -> nodes.FunctionDef:
+    """create and initialize an astroid FunctionDef node"""
+    # first argument is now a list of decorators
+    func = nodes.FunctionDef(name)
+    argsnode = nodes.Arguments(parent=func)
+    argsnode.postinit(
+        args=[nodes.AssignName(name=arg, parent=argsnode) for arg in args or ()],
+        defaults=[],
+        kwonlyargs=[
+            nodes.AssignName(name=arg, parent=argsnode) for arg in kwonlyargs or ()
+        ],
+        kw_defaults=[],
+        annotations=[],
+        posonlyargs=[
+            nodes.AssignName(name=arg, parent=argsnode) for arg in posonlyargs or ()
+        ],
+    )
+    func.postinit(
+        args=argsnode,
+        body=[],
+        doc_node=nodes.Const(value=doc) if doc else None,
+    )
+    for default in defaults or ():
+        argsnode.defaults.append(nodes.const_factory(default))
+        argsnode.defaults[-1].parent = argsnode
+    if args:
+        register_arguments(func)
+    return func
+
+
+def build_from_import(fromname, names):
+    """create and initialize an astroid ImportFrom import statement"""
+    return nodes.ImportFrom(fromname, [(name, None) for name in names])
+
+
+def register_arguments(func, args=None):
+    """add given arguments to local
+
+    args is a list that may contains nested lists
+    (i.e. def func(a, (b, c, d)): ...)
+    """
+    if args is None:
+        args = func.args.args
+        if func.args.vararg:
+            func.set_local(func.args.vararg, func.args)
+        if func.args.kwarg:
+            func.set_local(func.args.kwarg, func.args)
+    for arg in args:
+        if isinstance(arg, nodes.AssignName):
+            func.set_local(arg.name, arg)
+        else:
+            register_arguments(func, arg.elts)
+
+
+def object_build_class(node, member, localname):
+    """create astroid for a living class object"""
+    basenames = [base.__name__ for base in member.__bases__]
+    return _base_class_object_build(node, member, basenames, localname=localname)
+
+
+def object_build_function(node, member, localname):
+    """create astroid for a living function object"""
+    signature = inspect.signature(member)
+    args = []
+    defaults = []
+    posonlyargs = []
+    kwonlyargs = []
+    for param_name, param in signature.parameters.items():
+        if param.kind == inspect.Parameter.POSITIONAL_ONLY:
+            posonlyargs.append(param_name)
+        elif param.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD:
+            args.append(param_name)
+        elif param.kind == inspect.Parameter.VAR_POSITIONAL:
+            args.append(param_name)
+        elif param.kind == inspect.Parameter.VAR_KEYWORD:
+            args.append(param_name)
+        elif param.kind == inspect.Parameter.KEYWORD_ONLY:
+            kwonlyargs.append(param_name)
+        if param.default is not inspect._empty:
+            defaults.append(param.default)
+    func = build_function(
+        getattr(member, "__name__", None) or localname,
+        args,
+        posonlyargs,
+        defaults,
+        member.__doc__,
+    )
+    node.add_local_node(func, localname)
+
+
+def object_build_datadescriptor(node, member, name):
+    """create astroid for a living data descriptor object"""
+    return _base_class_object_build(node, member, [], name)
+
+
+def object_build_methoddescriptor(node, member, localname):
+    """create astroid for a living method descriptor object"""
+    # FIXME get arguments ?
+    func = build_function(
+        getattr(member, "__name__", None) or localname, doc=member.__doc__
+    )
+    # set node's arguments to None to notice that we have no information, not
+    # and empty argument list
+    func.args.args = None
+    node.add_local_node(func, localname)
+    _add_dunder_class(func, member)
+
+
+def _base_class_object_build(node, member, basenames, name=None, localname=None):
+    """create astroid for a living class object, with a given set of base names
+    (e.g. ancestors)
+    """
+    klass = build_class(
+        name or getattr(member, "__name__", None) or localname,
+        basenames,
+        member.__doc__,
+    )
+    klass._newstyle = isinstance(member, type)
+    node.add_local_node(klass, localname)
+    try:
+        # limit the instantiation trick since it's too dangerous
+        # (such as infinite test execution...)
+        # this at least resolves common case such as Exception.args,
+        # OSError.errno
+        if issubclass(member, Exception):
+            instdict = member().__dict__
+        else:
+            raise TypeError
+    except TypeError:
+        pass
+    else:
+        for item_name, obj in instdict.items():
+            valnode = nodes.EmptyNode()
+            valnode.object = obj
+            valnode.parent = klass
+            valnode.lineno = 1
+            klass.instance_attrs[item_name] = [valnode]
+    return klass
+
+
+def _build_from_function(node, name, member, module):
+    # verify this is not an imported function
+    try:
+        code = member.__code__
+    except AttributeError:
+        # Some implementations don't provide the code object,
+        # such as Jython.
+        code = None
+    filename = getattr(code, "co_filename", None)
+    if filename is None:
+        assert isinstance(member, object)
+        object_build_methoddescriptor(node, member, name)
+    elif filename != getattr(module, "__file__", None):
+        attach_dummy_node(node, name, member)
+    else:
+        object_build_function(node, member, name)
+
+
+def _safe_has_attribute(obj, member):
+    try:
+        return hasattr(obj, member)
+    except Exception:  # pylint: disable=broad-except
+        return False
+
+
+class InspectBuilder:
+    """class for building nodes from living object
+
+    this is actually a really minimal representation, including only Module,
+    FunctionDef and ClassDef nodes and some others as guessed.
+    """
+
+    def __init__(self, manager_instance=None):
+        self._manager = manager_instance or AstroidManager()
+        self._done = {}
+        self._module = None
+
+    def inspect_build(
+        self,
+        module: types.ModuleType,
+        modname: Optional[str] = None,
+        path: Optional[str] = None,
+    ) -> nodes.Module:
+        """build astroid from a living module (i.e. using inspect)
+        this is used when there is no python source code available (either
+        because it's a built-in module or because the .py is not available)
+        """
+        self._module = module
+        if modname is None:
+            modname = module.__name__
+        try:
+            node = build_module(modname, module.__doc__)
+        except AttributeError:
+            # in jython, java modules have no __doc__ (see #109562)
+            node = build_module(modname)
+        node.file = node.path = os.path.abspath(path) if path else path
+        node.name = modname
+        self._manager.cache_module(node)
+        node.package = hasattr(module, "__path__")
+        self._done = {}
+        self.object_build(node, module)
+        return node
+
+    def object_build(self, node, obj):
+        """recursive method which create a partial ast from real objects
+        (only function, class, and method are handled)
+        """
+        if obj in self._done:
+            return self._done[obj]
+        self._done[obj] = node
+        for name in dir(obj):
+            try:
+                with warnings.catch_warnings():
+                    warnings.simplefilter("error")
+                    member = getattr(obj, name)
+            except (AttributeError, DeprecationWarning):
+                # damned ExtensionClass.Base, I know you're there !
+                attach_dummy_node(node, name)
+                continue
+            if inspect.ismethod(member):
+                member = member.__func__
+            if inspect.isfunction(member):
+                _build_from_function(node, name, member, self._module)
+            elif inspect.isbuiltin(member):
+                if self.imported_member(node, member, name):
+                    continue
+                object_build_methoddescriptor(node, member, name)
+            elif inspect.isclass(member):
+                if self.imported_member(node, member, name):
+                    continue
+                if member in self._done:
+                    class_node = self._done[member]
+                    if class_node not in node.locals.get(name, ()):
+                        node.add_local_node(class_node, name)
+                else:
+                    class_node = object_build_class(node, member, name)
+                    # recursion
+                    self.object_build(class_node, member)
+                if name == "__class__" and class_node.parent is None:
+                    class_node.parent = self._done[self._module]
+            elif inspect.ismethoddescriptor(member):
+                assert isinstance(member, object)
+                object_build_methoddescriptor(node, member, name)
+            elif inspect.isdatadescriptor(member):
+                assert isinstance(member, object)
+                object_build_datadescriptor(node, member, name)
+            elif isinstance(member, _CONSTANTS):
+                attach_const_node(node, name, member)
+            elif inspect.isroutine(member):
+                # This should be called for Jython, where some builtin
+                # methods aren't caught by isbuiltin branch.
+                _build_from_function(node, name, member, self._module)
+            elif _safe_has_attribute(member, "__all__"):
+                module = build_module(name)
+                _attach_local_node(node, module, name)
+                # recursion
+                self.object_build(module, member)
+            else:
+                # create an empty node so that the name is actually defined
+                attach_dummy_node(node, name, member)
+        return None
+
+    def imported_member(self, node, member, name: str) -> bool:
+        """verify this is not an imported class or handle it"""
+        # /!\ some classes like ExtensionClass doesn't have a __module__
+        # attribute ! Also, this may trigger an exception on badly built module
+        # (see http://www.logilab.org/ticket/57299 for instance)
+        try:
+            modname = getattr(member, "__module__", None)
+        except TypeError:
+            modname = None
+        if modname is None:
+            if name in {"__new__", "__subclasshook__"}:
+                # Python 2.5.1 (r251:54863, Sep  1 2010, 22:03:14)
+                # >>> print object.__new__.__module__
+                # None
+                modname = builtins.__name__
+            else:
+                attach_dummy_node(node, name, member)
+                return True
+
+        # On PyPy during bootstrapping we infer _io while _module is
+        # builtins. In CPython _io names itself io, see http://bugs.python.org/issue18602
+        # Therefore, this basically checks whether we are not in PyPy.
+        if modname == "_io" and not self._module.__name__ == "builtins":
+            return False
+
+        real_name = {"gtk": "gtk_gtk"}.get(modname, modname)
+
+        if real_name != self._module.__name__:
+            # check if it sounds valid and then add an import node, else use a
+            # dummy node
+            try:
+                getattr(sys.modules[modname], name)
+            except (KeyError, AttributeError):
+                attach_dummy_node(node, name, member)
+            else:
+                attach_import_node(node, modname, name)
+            return True
+        return False
+
+
+# astroid bootstrapping ######################################################
+
+_CONST_PROXY = {}
+
+
+def _set_proxied(const):
+    # TODO : find a nicer way to handle this situation;
+    return _CONST_PROXY[const.value.__class__]
+
+
+def _astroid_bootstrapping():
+    """astroid bootstrapping the builtins module"""
+    # this boot strapping is necessary since we need the Const nodes to
+    # inspect_build builtins, and then we can proxy Const
+    builder = InspectBuilder()
+    astroid_builtin = builder.inspect_build(builtins)
+
+    for cls, node_cls in node_classes.CONST_CLS.items():
+        if cls is TYPE_NONE:
+            proxy = build_class("NoneType")
+            proxy.parent = astroid_builtin
+        elif cls is TYPE_NOTIMPLEMENTED:
+            proxy = build_class("NotImplementedType")
+            proxy.parent = astroid_builtin
+        elif cls is TYPE_ELLIPSIS:
+            proxy = build_class("Ellipsis")
+            proxy.parent = astroid_builtin
+        else:
+            proxy = astroid_builtin.getattr(cls.__name__)[0]
+        if cls in (dict, list, set, tuple):
+            node_cls._proxied = proxy
+        else:
+            _CONST_PROXY[cls] = proxy
+
+    # Set the builtin module as parent for some builtins.
+    nodes.Const._proxied = property(_set_proxied)
+
+    _GeneratorType = nodes.ClassDef(types.GeneratorType.__name__)
+    _GeneratorType.parent = astroid_builtin
+    generator_doc_node = (
+        nodes.Const(value=types.GeneratorType.__doc__)
+        if types.GeneratorType.__doc__
+        else None
+    )
+    _GeneratorType.postinit(
+        bases=[],
+        body=[],
+        decorators=None,
+        doc_node=generator_doc_node,
+    )
+    bases.Generator._proxied = _GeneratorType
+    builder.object_build(bases.Generator._proxied, types.GeneratorType)
+
+    if hasattr(types, "AsyncGeneratorType"):
+        _AsyncGeneratorType = nodes.ClassDef(types.AsyncGeneratorType.__name__)
+        _AsyncGeneratorType.parent = astroid_builtin
+        async_generator_doc_node = (
+            nodes.Const(value=types.AsyncGeneratorType.__doc__)
+            if types.AsyncGeneratorType.__doc__
+            else None
+        )
+        _AsyncGeneratorType.postinit(
+            bases=[],
+            body=[],
+            decorators=None,
+            doc_node=async_generator_doc_node,
+        )
+        bases.AsyncGenerator._proxied = _AsyncGeneratorType
+        builder.object_build(bases.AsyncGenerator._proxied, types.AsyncGeneratorType)
+    builtin_types = (
+        types.GetSetDescriptorType,
+        types.GeneratorType,
+        types.MemberDescriptorType,
+        TYPE_NONE,
+        TYPE_NOTIMPLEMENTED,
+        types.FunctionType,
+        types.MethodType,
+        types.BuiltinFunctionType,
+        types.ModuleType,
+        types.TracebackType,
+    )
+    for _type in builtin_types:
+        if _type.__name__ not in astroid_builtin:
+            klass = nodes.ClassDef(_type.__name__)
+            klass.parent = astroid_builtin
+            klass.postinit(
+                bases=[],
+                body=[],
+                decorators=None,
+                doc_node=nodes.Const(value=_type.__doc__) if _type.__doc__ else None,
+            )
+            builder.object_build(klass, _type)
+            astroid_builtin[_type.__name__] = klass
+
+
+_astroid_bootstrapping()
diff --git a/myenv/lib/python3.9/site-packages/astroid/rebuilder.py b/myenv/lib/python3.9/site-packages/astroid/rebuilder.py
new file mode 100644
index 0000000..a04d973
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/rebuilder.py
@@ -0,0 +1,2119 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""this module contains utilities for rebuilding an _ast tree in
+order to get a single Astroid representation
+"""
+
+import ast
+import sys
+import token
+import tokenize
+from io import StringIO
+from tokenize import TokenInfo, generate_tokens
+from typing import (
+    Callable,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+
+from astroid import nodes
+from astroid._ast import ParserModule, get_parser_module, parse_function_type_comment
+from astroid.const import IS_PYPY, PY36, PY38, PY38_PLUS, PY39_PLUS, Context
+from astroid.manager import AstroidManager
+from astroid.nodes import NodeNG
+from astroid.nodes.utils import Position
+
+if sys.version_info >= (3, 8):
+    from typing import Final
+else:
+    from typing_extensions import Final
+
+
+REDIRECT: Final[Dict[str, str]] = {
+    "arguments": "Arguments",
+    "comprehension": "Comprehension",
+    "ListCompFor": "Comprehension",
+    "GenExprFor": "Comprehension",
+    "excepthandler": "ExceptHandler",
+    "keyword": "Keyword",
+    "match_case": "MatchCase",
+}
+
+
+T_Doc = TypeVar(
+    "T_Doc",
+    "ast.Module",
+    "ast.ClassDef",
+    Union["ast.FunctionDef", "ast.AsyncFunctionDef"],
+)
+T_Function = TypeVar("T_Function", nodes.FunctionDef, nodes.AsyncFunctionDef)
+T_For = TypeVar("T_For", nodes.For, nodes.AsyncFor)
+T_With = TypeVar("T_With", nodes.With, nodes.AsyncWith)
+NodesWithDocsType = Union[nodes.Module, nodes.ClassDef, nodes.FunctionDef]
+
+
+# noinspection PyMethodMayBeStatic
+class TreeRebuilder:
+    """Rebuilds the _ast tree to become an Astroid tree"""
+
+    def __init__(
+        self,
+        manager: AstroidManager,
+        parser_module: Optional[ParserModule] = None,
+        data: Optional[str] = None,
+    ) -> None:
+        self._manager = manager
+        self._data = data.split("\n") if data else None
+        self._global_names: List[Dict[str, List[nodes.Global]]] = []
+        self._import_from_nodes: List[nodes.ImportFrom] = []
+        self._delayed_assattr: List[nodes.AssignAttr] = []
+        self._visit_meths: Dict[
+            Type["ast.AST"], Callable[["ast.AST", NodeNG], NodeNG]
+        ] = {}
+
+        if parser_module is None:
+            self._parser_module = get_parser_module()
+        else:
+            self._parser_module = parser_module
+        self._module = self._parser_module.module
+
+    def _get_doc(self, node: T_Doc) -> Tuple[T_Doc, Optional["ast.Constant | ast.Str"]]:
+        """Return the doc ast node."""
+        try:
+            if node.body and isinstance(node.body[0], self._module.Expr):
+                first_value = node.body[0].value
+                if isinstance(first_value, self._module.Str) or (
+                    PY38_PLUS
+                    and isinstance(first_value, self._module.Constant)
+                    and isinstance(first_value.value, str)
+                ):
+                    doc_ast_node = first_value
+                    node.body = node.body[1:]
+                    # The ast parser of python < 3.8 sets col_offset of multi-line strings to -1
+                    # as it is unable to determine the value correctly. We reset this to None.
+                    if doc_ast_node.col_offset == -1:
+                        doc_ast_node.col_offset = None
+                    return node, doc_ast_node
+        except IndexError:
+            pass  # ast built from scratch
+        return node, None
+
+    def _get_context(
+        self,
+        node: Union[
+            "ast.Attribute",
+            "ast.List",
+            "ast.Name",
+            "ast.Subscript",
+            "ast.Starred",
+            "ast.Tuple",
+        ],
+    ) -> Context:
+        return self._parser_module.context_classes.get(type(node.ctx), Context.Load)
+
+    def _get_position_info(
+        self,
+        node: Union["ast.ClassDef", "ast.FunctionDef", "ast.AsyncFunctionDef"],
+        parent: Union[nodes.ClassDef, nodes.FunctionDef, nodes.AsyncFunctionDef],
+    ) -> Optional[Position]:
+        """Return position information for ClassDef and FunctionDef nodes.
+
+        In contrast to AST positions, these only include the actual keyword(s)
+        and the class / function name.
+
+        >>> @decorator
+        >>> async def some_func(var: int) -> None:
+        >>> ^^^^^^^^^^^^^^^^^^^
+        """
+        if not self._data:
+            return None
+        end_lineno: Optional[int] = getattr(node, "end_lineno", None)
+        if node.body:
+            end_lineno = node.body[0].lineno
+        # pylint: disable-next=unsubscriptable-object
+        data = "\n".join(self._data[node.lineno - 1 : end_lineno])
+
+        start_token: Optional[TokenInfo] = None
+        keyword_tokens: Tuple[int, ...] = (token.NAME,)
+        if isinstance(parent, nodes.AsyncFunctionDef):
+            search_token = "async"
+            if PY36:
+                # In Python 3.6, the token type for 'async' was 'ASYNC'
+                # In Python 3.7, the type was changed to 'NAME' and 'ASYNC' removed
+                # Python 3.8 added it back. However, if we use it unconditionally
+                # we would break 3.7.
+                keyword_tokens = (token.NAME, token.ASYNC)
+        elif isinstance(parent, nodes.FunctionDef):
+            search_token = "def"
+        else:
+            search_token = "class"
+
+        for t in generate_tokens(StringIO(data).readline):
+            if (
+                start_token is not None
+                and t.type == token.NAME
+                and t.string == node.name
+            ):
+                break
+            if t.type in keyword_tokens:
+                if t.string == search_token:
+                    start_token = t
+                    continue
+                if t.string in {"def"}:
+                    continue
+            start_token = None
+        else:
+            return None
+
+        # pylint: disable=undefined-loop-variable
+        return Position(
+            lineno=node.lineno + start_token.start[0] - 1,
+            col_offset=start_token.start[1],
+            end_lineno=node.lineno + t.end[0] - 1,
+            end_col_offset=t.end[1],
+        )
+
+    def _fix_doc_node_position(self, node: NodesWithDocsType) -> None:
+        """Fix start and end position of doc nodes for Python < 3.8."""
+        if not self._data or not node.doc_node or node.lineno is None:
+            return
+        if PY38_PLUS:
+            return
+
+        lineno = node.lineno or 1  # lineno of modules is 0
+        end_range: Optional[int] = node.doc_node.lineno
+        if IS_PYPY and not PY39_PLUS:
+            end_range = None
+        # pylint: disable-next=unsubscriptable-object
+        data = "\n".join(self._data[lineno - 1 : end_range])
+
+        found_start, found_end = False, False
+        open_brackets = 0
+        skip_token: Set[int] = {token.NEWLINE, token.INDENT}
+        if PY36:
+            skip_token.update((tokenize.NL, tokenize.COMMENT))
+        else:
+            # token.NL and token.COMMENT were added in 3.7
+            skip_token.update((token.NL, token.COMMENT))
+
+        if isinstance(node, nodes.Module):
+            found_end = True
+
+        for t in generate_tokens(StringIO(data).readline):
+            if found_end is False:
+                if (
+                    found_start is False
+                    and t.type == token.NAME
+                    and t.string in {"def", "class"}
+                ):
+                    found_start = True
+                elif found_start is True and t.type == token.OP:
+                    if t.exact_type == token.COLON and open_brackets == 0:
+                        found_end = True
+                    elif t.exact_type == token.LPAR:
+                        open_brackets += 1
+                    elif t.exact_type == token.RPAR:
+                        open_brackets -= 1
+                continue
+            if t.type in skip_token:
+                continue
+            if t.type == token.STRING:
+                break
+            return
+        else:
+            return
+
+        # pylint: disable=undefined-loop-variable
+        node.doc_node.lineno = lineno + t.start[0] - 1
+        node.doc_node.col_offset = t.start[1]
+        node.doc_node.end_lineno = lineno + t.end[0] - 1
+        node.doc_node.end_col_offset = t.end[1]
+
+    def _reset_end_lineno(self, newnode: nodes.NodeNG) -> None:
+        """Reset end_lineno and end_col_offset attributes for PyPy 3.8.
+
+        For some nodes, these are either set to -1 or only partially assigned.
+        To keep consistency across astroid and pylint, reset all.
+
+        This has been fixed in PyPy 3.9.
+        For reference, an (incomplete) list of nodes with issues:
+            - ClassDef          - For
+            - FunctionDef       - While
+            - Call              - If
+            - Decorators        - TryExcept
+            - With              - TryFinally
+            - Assign
+        """
+        newnode.end_lineno = None
+        newnode.end_col_offset = None
+        for child_node in newnode.get_children():
+            self._reset_end_lineno(child_node)
+
+    def visit_module(
+        self, node: "ast.Module", modname: str, modpath: str, package: bool
+    ) -> nodes.Module:
+        """visit a Module node by returning a fresh instance of it
+
+        Note: Method not called by 'visit'
+        """
+        node, doc_ast_node = self._get_doc(node)
+        newnode = nodes.Module(
+            name=modname,
+            file=modpath,
+            path=[modpath],
+            package=package,
+            parent=None,
+        )
+        newnode.postinit(
+            [self.visit(child, newnode) for child in node.body],
+            doc_node=self.visit(doc_ast_node, newnode),
+        )
+        self._fix_doc_node_position(newnode)
+        if IS_PYPY and PY38:
+            self._reset_end_lineno(newnode)
+        return newnode
+
+    @overload
+    def visit(self, node: "ast.arg", parent: NodeNG) -> nodes.AssignName:
+        ...
+
+    @overload
+    def visit(self, node: "ast.arguments", parent: NodeNG) -> nodes.Arguments:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Assert", parent: NodeNG) -> nodes.Assert:
+        ...
+
+    @overload
+    def visit(
+        self, node: "ast.AsyncFunctionDef", parent: NodeNG
+    ) -> nodes.AsyncFunctionDef:
+        ...
+
+    @overload
+    def visit(self, node: "ast.AsyncFor", parent: NodeNG) -> nodes.AsyncFor:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Await", parent: NodeNG) -> nodes.Await:
+        ...
+
+    @overload
+    def visit(self, node: "ast.AsyncWith", parent: NodeNG) -> nodes.AsyncWith:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Assign", parent: NodeNG) -> nodes.Assign:
+        ...
+
+    @overload
+    def visit(self, node: "ast.AnnAssign", parent: NodeNG) -> nodes.AnnAssign:
+        ...
+
+    @overload
+    def visit(self, node: "ast.AugAssign", parent: NodeNG) -> nodes.AugAssign:
+        ...
+
+    @overload
+    def visit(self, node: "ast.BinOp", parent: NodeNG) -> nodes.BinOp:
+        ...
+
+    @overload
+    def visit(self, node: "ast.BoolOp", parent: NodeNG) -> nodes.BoolOp:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Break", parent: NodeNG) -> nodes.Break:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Call", parent: NodeNG) -> nodes.Call:
+        ...
+
+    @overload
+    def visit(self, node: "ast.ClassDef", parent: NodeNG) -> nodes.ClassDef:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Continue", parent: NodeNG) -> nodes.Continue:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Compare", parent: NodeNG) -> nodes.Compare:
+        ...
+
+    @overload
+    def visit(self, node: "ast.comprehension", parent: NodeNG) -> nodes.Comprehension:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Delete", parent: NodeNG) -> nodes.Delete:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Dict", parent: NodeNG) -> nodes.Dict:
+        ...
+
+    @overload
+    def visit(self, node: "ast.DictComp", parent: NodeNG) -> nodes.DictComp:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Expr", parent: NodeNG) -> nodes.Expr:
+        ...
+
+    @overload
+    def visit(self, node: "ast.ExceptHandler", parent: NodeNG) -> nodes.ExceptHandler:
+        ...
+
+    @overload
+    def visit(self, node: "ast.For", parent: NodeNG) -> nodes.For:
+        ...
+
+    @overload
+    def visit(self, node: "ast.ImportFrom", parent: NodeNG) -> nodes.ImportFrom:
+        ...
+
+    @overload
+    def visit(self, node: "ast.FunctionDef", parent: NodeNG) -> nodes.FunctionDef:
+        ...
+
+    @overload
+    def visit(self, node: "ast.GeneratorExp", parent: NodeNG) -> nodes.GeneratorExp:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Attribute", parent: NodeNG) -> nodes.Attribute:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Global", parent: NodeNG) -> nodes.Global:
+        ...
+
+    @overload
+    def visit(self, node: "ast.If", parent: NodeNG) -> nodes.If:
+        ...
+
+    @overload
+    def visit(self, node: "ast.IfExp", parent: NodeNG) -> nodes.IfExp:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Import", parent: NodeNG) -> nodes.Import:
+        ...
+
+    @overload
+    def visit(self, node: "ast.JoinedStr", parent: NodeNG) -> nodes.JoinedStr:
+        ...
+
+    @overload
+    def visit(self, node: "ast.FormattedValue", parent: NodeNG) -> nodes.FormattedValue:
+        ...
+
+    if sys.version_info >= (3, 8):
+
+        @overload
+        def visit(self, node: "ast.NamedExpr", parent: NodeNG) -> nodes.NamedExpr:
+            ...
+
+    if sys.version_info < (3, 9):
+        # Not used in Python 3.9+
+        @overload
+        def visit(self, node: "ast.ExtSlice", parent: nodes.Subscript) -> nodes.Tuple:
+            ...
+
+        @overload
+        def visit(self, node: "ast.Index", parent: nodes.Subscript) -> NodeNG:
+            ...
+
+    @overload
+    def visit(self, node: "ast.keyword", parent: NodeNG) -> nodes.Keyword:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Lambda", parent: NodeNG) -> nodes.Lambda:
+        ...
+
+    @overload
+    def visit(self, node: "ast.List", parent: NodeNG) -> nodes.List:
+        ...
+
+    @overload
+    def visit(self, node: "ast.ListComp", parent: NodeNG) -> nodes.ListComp:
+        ...
+
+    @overload
+    def visit(
+        self, node: "ast.Name", parent: NodeNG
+    ) -> Union[nodes.Name, nodes.Const, nodes.AssignName, nodes.DelName]:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Nonlocal", parent: NodeNG) -> nodes.Nonlocal:
+        ...
+
+    if sys.version_info < (3, 8):
+        # Not used in Python 3.8+
+        @overload
+        def visit(self, node: "ast.Ellipsis", parent: NodeNG) -> nodes.Const:
+            ...
+
+        @overload
+        def visit(self, node: "ast.NameConstant", parent: NodeNG) -> nodes.Const:
+            ...
+
+        @overload
+        def visit(self, node: "ast.Str", parent: NodeNG) -> nodes.Const:
+            ...
+
+        @overload
+        def visit(self, node: "ast.Bytes", parent: NodeNG) -> nodes.Const:
+            ...
+
+        @overload
+        def visit(self, node: "ast.Num", parent: NodeNG) -> nodes.Const:
+            ...
+
+    @overload
+    def visit(self, node: "ast.Constant", parent: NodeNG) -> nodes.Const:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Pass", parent: NodeNG) -> nodes.Pass:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Raise", parent: NodeNG) -> nodes.Raise:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Return", parent: NodeNG) -> nodes.Return:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Set", parent: NodeNG) -> nodes.Set:
+        ...
+
+    @overload
+    def visit(self, node: "ast.SetComp", parent: NodeNG) -> nodes.SetComp:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Slice", parent: nodes.Subscript) -> nodes.Slice:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Subscript", parent: NodeNG) -> nodes.Subscript:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Starred", parent: NodeNG) -> nodes.Starred:
+        ...
+
+    @overload
+    def visit(
+        self, node: "ast.Try", parent: NodeNG
+    ) -> Union[nodes.TryExcept, nodes.TryFinally]:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Tuple", parent: NodeNG) -> nodes.Tuple:
+        ...
+
+    @overload
+    def visit(self, node: "ast.UnaryOp", parent: NodeNG) -> nodes.UnaryOp:
+        ...
+
+    @overload
+    def visit(self, node: "ast.While", parent: NodeNG) -> nodes.While:
+        ...
+
+    @overload
+    def visit(self, node: "ast.With", parent: NodeNG) -> nodes.With:
+        ...
+
+    @overload
+    def visit(self, node: "ast.Yield", parent: NodeNG) -> nodes.Yield:
+        ...
+
+    @overload
+    def visit(self, node: "ast.YieldFrom", parent: NodeNG) -> nodes.YieldFrom:
+        ...
+
+    if sys.version_info >= (3, 10):
+
+        @overload
+        def visit(self, node: "ast.Match", parent: NodeNG) -> nodes.Match:
+            ...
+
+        @overload
+        def visit(self, node: "ast.match_case", parent: NodeNG) -> nodes.MatchCase:
+            ...
+
+        @overload
+        def visit(self, node: "ast.MatchValue", parent: NodeNG) -> nodes.MatchValue:
+            ...
+
+        @overload
+        def visit(
+            self, node: "ast.MatchSingleton", parent: NodeNG
+        ) -> nodes.MatchSingleton:
+            ...
+
+        @overload
+        def visit(
+            self, node: "ast.MatchSequence", parent: NodeNG
+        ) -> nodes.MatchSequence:
+            ...
+
+        @overload
+        def visit(self, node: "ast.MatchMapping", parent: NodeNG) -> nodes.MatchMapping:
+            ...
+
+        @overload
+        def visit(self, node: "ast.MatchClass", parent: NodeNG) -> nodes.MatchClass:
+            ...
+
+        @overload
+        def visit(self, node: "ast.MatchStar", parent: NodeNG) -> nodes.MatchStar:
+            ...
+
+        @overload
+        def visit(self, node: "ast.MatchAs", parent: NodeNG) -> nodes.MatchAs:
+            ...
+
+        @overload
+        def visit(self, node: "ast.MatchOr", parent: NodeNG) -> nodes.MatchOr:
+            ...
+
+        @overload
+        def visit(self, node: "ast.pattern", parent: NodeNG) -> nodes.Pattern:
+            ...
+
+    @overload
+    def visit(self, node: "ast.AST", parent: NodeNG) -> NodeNG:
+        ...
+
+    @overload
+    def visit(self, node: None, parent: NodeNG) -> None:
+        ...
+
+    def visit(self, node: Optional["ast.AST"], parent: NodeNG) -> Optional[NodeNG]:
+        if node is None:
+            return None
+        cls = node.__class__
+        if cls in self._visit_meths:
+            visit_method = self._visit_meths[cls]
+        else:
+            cls_name = cls.__name__
+            visit_name = "visit_" + REDIRECT.get(cls_name, cls_name).lower()
+            visit_method = getattr(self, visit_name)
+            self._visit_meths[cls] = visit_method
+        return visit_method(node, parent)
+
+    def _save_assignment(self, node: Union[nodes.AssignName, nodes.DelName]) -> None:
+        """save assignment situation since node.parent is not available yet"""
+        if self._global_names and node.name in self._global_names[-1]:
+            node.root().set_local(node.name, node)
+        else:
+            assert node.parent
+            node.parent.set_local(node.name, node)
+
+    def visit_arg(self, node: "ast.arg", parent: NodeNG) -> nodes.AssignName:
+        """visit an arg node by returning a fresh AssName instance"""
+        return self.visit_assignname(node, parent, node.arg)
+
+    def visit_arguments(self, node: "ast.arguments", parent: NodeNG) -> nodes.Arguments:
+        """visit an Arguments node by returning a fresh instance of it"""
+        vararg: Optional[str] = None
+        kwarg: Optional[str] = None
+        newnode = nodes.Arguments(
+            node.vararg.arg if node.vararg else None,
+            node.kwarg.arg if node.kwarg else None,
+            parent,
+        )
+        args = [self.visit(child, newnode) for child in node.args]
+        defaults = [self.visit(child, newnode) for child in node.defaults]
+        varargannotation: Optional[NodeNG] = None
+        kwargannotation: Optional[NodeNG] = None
+        posonlyargs: List[nodes.AssignName] = []
+        if node.vararg:
+            vararg = node.vararg.arg
+            varargannotation = self.visit(node.vararg.annotation, newnode)
+        if node.kwarg:
+            kwarg = node.kwarg.arg
+            kwargannotation = self.visit(node.kwarg.annotation, newnode)
+
+        if PY38:
+            # In Python 3.8 'end_lineno' and 'end_col_offset'
+            # for 'kwonlyargs' don't include the annotation.
+            for arg in node.kwonlyargs:
+                if arg.annotation is not None:
+                    arg.end_lineno = arg.annotation.end_lineno
+                    arg.end_col_offset = arg.annotation.end_col_offset
+
+        kwonlyargs = [self.visit(child, newnode) for child in node.kwonlyargs]
+        kw_defaults = [self.visit(child, newnode) for child in node.kw_defaults]
+        annotations = [self.visit(arg.annotation, newnode) for arg in node.args]
+        kwonlyargs_annotations = [
+            self.visit(arg.annotation, newnode) for arg in node.kwonlyargs
+        ]
+
+        posonlyargs_annotations: List[Optional[NodeNG]] = []
+        if PY38_PLUS:
+            posonlyargs = [self.visit(child, newnode) for child in node.posonlyargs]
+            posonlyargs_annotations = [
+                self.visit(arg.annotation, newnode) for arg in node.posonlyargs
+            ]
+        type_comment_args = [
+            self.check_type_comment(child, parent=newnode) for child in node.args
+        ]
+        type_comment_kwonlyargs = [
+            self.check_type_comment(child, parent=newnode) for child in node.kwonlyargs
+        ]
+        type_comment_posonlyargs: List[Optional[NodeNG]] = []
+        if PY38_PLUS:
+            type_comment_posonlyargs = [
+                self.check_type_comment(child, parent=newnode)
+                for child in node.posonlyargs
+            ]
+
+        newnode.postinit(
+            args=args,
+            defaults=defaults,
+            kwonlyargs=kwonlyargs,
+            posonlyargs=posonlyargs,
+            kw_defaults=kw_defaults,
+            annotations=annotations,
+            kwonlyargs_annotations=kwonlyargs_annotations,
+            posonlyargs_annotations=posonlyargs_annotations,
+            varargannotation=varargannotation,
+            kwargannotation=kwargannotation,
+            type_comment_args=type_comment_args,
+            type_comment_kwonlyargs=type_comment_kwonlyargs,
+            type_comment_posonlyargs=type_comment_posonlyargs,
+        )
+        # save argument names in locals:
+        assert newnode.parent
+        if vararg:
+            newnode.parent.set_local(vararg, newnode)
+        if kwarg:
+            newnode.parent.set_local(kwarg, newnode)
+        return newnode
+
+    def visit_assert(self, node: "ast.Assert", parent: NodeNG) -> nodes.Assert:
+        """visit a Assert node by returning a fresh instance of it"""
+        newnode = nodes.Assert(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        msg: Optional[NodeNG] = None
+        if node.msg:
+            msg = self.visit(node.msg, newnode)
+        newnode.postinit(self.visit(node.test, newnode), msg)
+        return newnode
+
+    def check_type_comment(
+        self,
+        node: Union[
+            "ast.Assign",
+            "ast.arg",
+            "ast.For",
+            "ast.AsyncFor",
+            "ast.With",
+            "ast.AsyncWith",
+        ],
+        parent: Union[
+            nodes.Assign,
+            nodes.Arguments,
+            nodes.For,
+            nodes.AsyncFor,
+            nodes.With,
+            nodes.AsyncWith,
+        ],
+    ) -> Optional[NodeNG]:
+        type_comment = getattr(node, "type_comment", None)  # Added in Python 3.8
+        if not type_comment:
+            return None
+
+        try:
+            type_comment_ast = self._parser_module.parse(type_comment)
+        except SyntaxError:
+            # Invalid type comment, just skip it.
+            return None
+
+        type_object = self.visit(type_comment_ast.body[0], parent=parent)
+        if not isinstance(type_object, nodes.Expr):
+            return None
+
+        return type_object.value
+
+    def check_function_type_comment(
+        self, node: Union["ast.FunctionDef", "ast.AsyncFunctionDef"], parent: NodeNG
+    ) -> Optional[Tuple[Optional[NodeNG], List[NodeNG]]]:
+        type_comment = getattr(node, "type_comment", None)  # Added in Python 3.8
+        if not type_comment:
+            return None
+
+        try:
+            type_comment_ast = parse_function_type_comment(type_comment)
+        except SyntaxError:
+            # Invalid type comment, just skip it.
+            return None
+
+        if not type_comment_ast:
+            return None
+
+        returns: Optional[NodeNG] = None
+        argtypes: List[NodeNG] = [
+            self.visit(elem, parent) for elem in (type_comment_ast.argtypes or [])
+        ]
+        if type_comment_ast.returns:
+            returns = self.visit(type_comment_ast.returns, parent)
+
+        return returns, argtypes
+
+    def visit_asyncfunctiondef(
+        self, node: "ast.AsyncFunctionDef", parent: NodeNG
+    ) -> nodes.AsyncFunctionDef:
+        return self._visit_functiondef(nodes.AsyncFunctionDef, node, parent)
+
+    def visit_asyncfor(self, node: "ast.AsyncFor", parent: NodeNG) -> nodes.AsyncFor:
+        return self._visit_for(nodes.AsyncFor, node, parent)
+
+    def visit_await(self, node: "ast.Await", parent: NodeNG) -> nodes.Await:
+        newnode = nodes.Await(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(value=self.visit(node.value, newnode))
+        return newnode
+
+    def visit_asyncwith(self, node: "ast.AsyncWith", parent: NodeNG) -> nodes.AsyncWith:
+        return self._visit_with(nodes.AsyncWith, node, parent)
+
+    def visit_assign(self, node: "ast.Assign", parent: NodeNG) -> nodes.Assign:
+        """visit a Assign node by returning a fresh instance of it"""
+        newnode = nodes.Assign(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        type_annotation = self.check_type_comment(node, parent=newnode)
+        newnode.postinit(
+            targets=[self.visit(child, newnode) for child in node.targets],
+            value=self.visit(node.value, newnode),
+            type_annotation=type_annotation,
+        )
+        return newnode
+
+    def visit_annassign(self, node: "ast.AnnAssign", parent: NodeNG) -> nodes.AnnAssign:
+        """visit an AnnAssign node by returning a fresh instance of it"""
+        newnode = nodes.AnnAssign(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            target=self.visit(node.target, newnode),
+            annotation=self.visit(node.annotation, newnode),
+            simple=node.simple,
+            value=self.visit(node.value, newnode),
+        )
+        return newnode
+
+    @overload
+    def visit_assignname(
+        self, node: "ast.AST", parent: NodeNG, node_name: str
+    ) -> nodes.AssignName:
+        ...
+
+    @overload
+    def visit_assignname(
+        self, node: "ast.AST", parent: NodeNG, node_name: None
+    ) -> None:
+        ...
+
+    def visit_assignname(
+        self, node: "ast.AST", parent: NodeNG, node_name: Optional[str]
+    ) -> Optional[nodes.AssignName]:
+        """visit a node and return a AssignName node
+
+        Note: Method not called by 'visit'
+        """
+        if node_name is None:
+            return None
+        newnode = nodes.AssignName(
+            name=node_name,
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        self._save_assignment(newnode)
+        return newnode
+
+    def visit_augassign(self, node: "ast.AugAssign", parent: NodeNG) -> nodes.AugAssign:
+        """visit a AugAssign node by returning a fresh instance of it"""
+        newnode = nodes.AugAssign(
+            op=self._parser_module.bin_op_classes[type(node.op)] + "=",
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.target, newnode), self.visit(node.value, newnode)
+        )
+        return newnode
+
+    def visit_binop(self, node: "ast.BinOp", parent: NodeNG) -> nodes.BinOp:
+        """visit a BinOp node by returning a fresh instance of it"""
+        newnode = nodes.BinOp(
+            op=self._parser_module.bin_op_classes[type(node.op)],
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.left, newnode), self.visit(node.right, newnode)
+        )
+        return newnode
+
+    def visit_boolop(self, node: "ast.BoolOp", parent: NodeNG) -> nodes.BoolOp:
+        """visit a BoolOp node by returning a fresh instance of it"""
+        newnode = nodes.BoolOp(
+            op=self._parser_module.bool_op_classes[type(node.op)],
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit([self.visit(child, newnode) for child in node.values])
+        return newnode
+
+    def visit_break(self, node: "ast.Break", parent: NodeNG) -> nodes.Break:
+        """visit a Break node by returning a fresh instance of it"""
+        return nodes.Break(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+
+    def visit_call(self, node: "ast.Call", parent: NodeNG) -> nodes.Call:
+        """visit a CallFunc node by returning a fresh instance of it"""
+        newnode = nodes.Call(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            func=self.visit(node.func, newnode),
+            args=[self.visit(child, newnode) for child in node.args],
+            keywords=[self.visit(child, newnode) for child in node.keywords],
+        )
+        return newnode
+
+    def visit_classdef(
+        self, node: "ast.ClassDef", parent: NodeNG, newstyle: bool = True
+    ) -> nodes.ClassDef:
+        """visit a ClassDef node to become astroid"""
+        node, doc_ast_node = self._get_doc(node)
+        newnode = nodes.ClassDef(
+            name=node.name,
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        metaclass = None
+        for keyword in node.keywords:
+            if keyword.arg == "metaclass":
+                metaclass = self.visit(keyword, newnode).value
+                break
+        decorators = self.visit_decorators(node, newnode)
+        newnode.postinit(
+            [self.visit(child, newnode) for child in node.bases],
+            [self.visit(child, newnode) for child in node.body],
+            decorators,
+            newstyle,
+            metaclass,
+            [
+                self.visit(kwd, newnode)
+                for kwd in node.keywords
+                if kwd.arg != "metaclass"
+            ],
+            position=self._get_position_info(node, newnode),
+            doc_node=self.visit(doc_ast_node, newnode),
+        )
+        self._fix_doc_node_position(newnode)
+        return newnode
+
+    def visit_continue(self, node: "ast.Continue", parent: NodeNG) -> nodes.Continue:
+        """visit a Continue node by returning a fresh instance of it"""
+        return nodes.Continue(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+
+    def visit_compare(self, node: "ast.Compare", parent: NodeNG) -> nodes.Compare:
+        """visit a Compare node by returning a fresh instance of it"""
+        newnode = nodes.Compare(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.left, newnode),
+            [
+                (
+                    self._parser_module.cmp_op_classes[op.__class__],
+                    self.visit(expr, newnode),
+                )
+                for (op, expr) in zip(node.ops, node.comparators)
+            ],
+        )
+        return newnode
+
+    def visit_comprehension(
+        self, node: "ast.comprehension", parent: NodeNG
+    ) -> nodes.Comprehension:
+        """visit a Comprehension node by returning a fresh instance of it"""
+        newnode = nodes.Comprehension(parent)
+        newnode.postinit(
+            self.visit(node.target, newnode),
+            self.visit(node.iter, newnode),
+            [self.visit(child, newnode) for child in node.ifs],
+            bool(node.is_async),
+        )
+        return newnode
+
+    def visit_decorators(
+        self,
+        node: Union["ast.ClassDef", "ast.FunctionDef", "ast.AsyncFunctionDef"],
+        parent: NodeNG,
+    ) -> Optional[nodes.Decorators]:
+        """visit a Decorators node by returning a fresh instance of it
+
+        Note: Method not called by 'visit'
+        """
+        if not node.decorator_list:
+            return None
+        # /!\ node is actually an _ast.FunctionDef node while
+        # parent is an astroid.nodes.FunctionDef node
+        if sys.version_info >= (3, 8):
+            # Set the line number of the first decorator for Python 3.8+.
+            lineno = node.decorator_list[0].lineno
+            end_lineno = node.decorator_list[-1].end_lineno
+            end_col_offset = node.decorator_list[-1].end_col_offset
+        else:
+            lineno = node.lineno
+            end_lineno = None
+            end_col_offset = None
+        newnode = nodes.Decorators(
+            lineno=lineno,
+            col_offset=node.col_offset,
+            end_lineno=end_lineno,
+            end_col_offset=end_col_offset,
+            parent=parent,
+        )
+        newnode.postinit([self.visit(child, newnode) for child in node.decorator_list])
+        return newnode
+
+    def visit_delete(self, node: "ast.Delete", parent: NodeNG) -> nodes.Delete:
+        """visit a Delete node by returning a fresh instance of it"""
+        newnode = nodes.Delete(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit([self.visit(child, newnode) for child in node.targets])
+        return newnode
+
+    def _visit_dict_items(
+        self, node: "ast.Dict", parent: NodeNG, newnode: nodes.Dict
+    ) -> Generator[Tuple[NodeNG, NodeNG], None, None]:
+        for key, value in zip(node.keys, node.values):
+            rebuilt_key: NodeNG
+            rebuilt_value = self.visit(value, newnode)
+            if not key:
+                # Extended unpacking
+                rebuilt_key = nodes.DictUnpack(
+                    lineno=rebuilt_value.lineno,
+                    col_offset=rebuilt_value.col_offset,
+                    # end_lineno and end_col_offset added in 3.8
+                    end_lineno=getattr(rebuilt_value, "end_lineno", None),
+                    end_col_offset=getattr(rebuilt_value, "end_col_offset", None),
+                    parent=parent,
+                )
+            else:
+                rebuilt_key = self.visit(key, newnode)
+            yield rebuilt_key, rebuilt_value
+
+    def visit_dict(self, node: "ast.Dict", parent: NodeNG) -> nodes.Dict:
+        """visit a Dict node by returning a fresh instance of it"""
+        newnode = nodes.Dict(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        items = list(self._visit_dict_items(node, parent, newnode))
+        newnode.postinit(items)
+        return newnode
+
+    def visit_dictcomp(self, node: "ast.DictComp", parent: NodeNG) -> nodes.DictComp:
+        """visit a DictComp node by returning a fresh instance of it"""
+        newnode = nodes.DictComp(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.key, newnode),
+            self.visit(node.value, newnode),
+            [self.visit(child, newnode) for child in node.generators],
+        )
+        return newnode
+
+    def visit_expr(self, node: "ast.Expr", parent: NodeNG) -> nodes.Expr:
+        """visit a Expr node by returning a fresh instance of it"""
+        newnode = nodes.Expr(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(self.visit(node.value, newnode))
+        return newnode
+
+    def visit_excepthandler(
+        self, node: "ast.ExceptHandler", parent: NodeNG
+    ) -> nodes.ExceptHandler:
+        """visit an ExceptHandler node by returning a fresh instance of it"""
+        newnode = nodes.ExceptHandler(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.type, newnode),
+            self.visit_assignname(node, newnode, node.name),
+            [self.visit(child, newnode) for child in node.body],
+        )
+        return newnode
+
+    @overload
+    def _visit_for(
+        self, cls: Type[nodes.For], node: "ast.For", parent: NodeNG
+    ) -> nodes.For:
+        ...
+
+    @overload
+    def _visit_for(
+        self, cls: Type[nodes.AsyncFor], node: "ast.AsyncFor", parent: NodeNG
+    ) -> nodes.AsyncFor:
+        ...
+
+    def _visit_for(
+        self, cls: Type[T_For], node: Union["ast.For", "ast.AsyncFor"], parent: NodeNG
+    ) -> T_For:
+        """visit a For node by returning a fresh instance of it"""
+        col_offset = node.col_offset
+        if IS_PYPY and not PY39_PLUS and isinstance(node, ast.AsyncFor) and self._data:
+            # pylint: disable-next=unsubscriptable-object
+            col_offset = self._data[node.lineno - 1].index("async")
+
+        newnode = cls(
+            lineno=node.lineno,
+            col_offset=col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        type_annotation = self.check_type_comment(node, parent=newnode)
+        newnode.postinit(
+            target=self.visit(node.target, newnode),
+            iter=self.visit(node.iter, newnode),
+            body=[self.visit(child, newnode) for child in node.body],
+            orelse=[self.visit(child, newnode) for child in node.orelse],
+            type_annotation=type_annotation,
+        )
+        return newnode
+
+    def visit_for(self, node: "ast.For", parent: NodeNG) -> nodes.For:
+        return self._visit_for(nodes.For, node, parent)
+
+    def visit_importfrom(
+        self, node: "ast.ImportFrom", parent: NodeNG
+    ) -> nodes.ImportFrom:
+        """visit an ImportFrom node by returning a fresh instance of it"""
+        names = [(alias.name, alias.asname) for alias in node.names]
+        newnode = nodes.ImportFrom(
+            fromname=node.module or "",
+            names=names,
+            level=node.level or None,
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        # store From names to add them to locals after building
+        self._import_from_nodes.append(newnode)
+        return newnode
+
+    @overload
+    def _visit_functiondef(
+        self, cls: Type[nodes.FunctionDef], node: "ast.FunctionDef", parent: NodeNG
+    ) -> nodes.FunctionDef:
+        ...
+
+    @overload
+    def _visit_functiondef(
+        self,
+        cls: Type[nodes.AsyncFunctionDef],
+        node: "ast.AsyncFunctionDef",
+        parent: NodeNG,
+    ) -> nodes.AsyncFunctionDef:
+        ...
+
+    def _visit_functiondef(
+        self,
+        cls: Type[T_Function],
+        node: Union["ast.FunctionDef", "ast.AsyncFunctionDef"],
+        parent: NodeNG,
+    ) -> T_Function:
+        """visit an FunctionDef node to become astroid"""
+        self._global_names.append({})
+        node, doc_ast_node = self._get_doc(node)
+
+        lineno = node.lineno
+        if PY38_PLUS and node.decorator_list:
+            # Python 3.8 sets the line number of a decorated function
+            # to be the actual line number of the function, but the
+            # previous versions expected the decorator's line number instead.
+            # We reset the function's line number to that of the
+            # first decorator to maintain backward compatibility.
+            # It's not ideal but this discrepancy was baked into
+            # the framework for *years*.
+            lineno = node.decorator_list[0].lineno
+
+        newnode = cls(
+            name=node.name,
+            lineno=lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        decorators = self.visit_decorators(node, newnode)
+        returns: Optional[NodeNG]
+        if node.returns:
+            returns = self.visit(node.returns, newnode)
+        else:
+            returns = None
+
+        type_comment_args = type_comment_returns = None
+        type_comment_annotation = self.check_function_type_comment(node, newnode)
+        if type_comment_annotation:
+            type_comment_returns, type_comment_args = type_comment_annotation
+        newnode.postinit(
+            args=self.visit(node.args, newnode),
+            body=[self.visit(child, newnode) for child in node.body],
+            decorators=decorators,
+            returns=returns,
+            type_comment_returns=type_comment_returns,
+            type_comment_args=type_comment_args,
+            position=self._get_position_info(node, newnode),
+            doc_node=self.visit(doc_ast_node, newnode),
+        )
+        if IS_PYPY and PY36 and newnode.position:
+            # PyPy: col_offset in Python 3.6 doesn't include 'async',
+            # use position.col_offset instead.
+            newnode.col_offset = newnode.position.col_offset
+        self._fix_doc_node_position(newnode)
+        self._global_names.pop()
+        return newnode
+
+    def visit_functiondef(
+        self, node: "ast.FunctionDef", parent: NodeNG
+    ) -> nodes.FunctionDef:
+        return self._visit_functiondef(nodes.FunctionDef, node, parent)
+
+    def visit_generatorexp(
+        self, node: "ast.GeneratorExp", parent: NodeNG
+    ) -> nodes.GeneratorExp:
+        """visit a GeneratorExp node by returning a fresh instance of it"""
+        newnode = nodes.GeneratorExp(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.elt, newnode),
+            [self.visit(child, newnode) for child in node.generators],
+        )
+        return newnode
+
+    def visit_attribute(
+        self, node: "ast.Attribute", parent: NodeNG
+    ) -> Union[nodes.Attribute, nodes.AssignAttr, nodes.DelAttr]:
+        """visit an Attribute node by returning a fresh instance of it"""
+        context = self._get_context(node)
+        newnode: Union[nodes.Attribute, nodes.AssignAttr, nodes.DelAttr]
+        if context == Context.Del:
+            # FIXME : maybe we should reintroduce and visit_delattr ?
+            # for instance, deactivating assign_ctx
+            newnode = nodes.DelAttr(
+                attrname=node.attr,
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                # end_lineno and end_col_offset added in 3.8
+                end_lineno=getattr(node, "end_lineno", None),
+                end_col_offset=getattr(node, "end_col_offset", None),
+                parent=parent,
+            )
+        elif context == Context.Store:
+            # pylint: disable=redefined-variable-type
+            newnode = nodes.AssignAttr(
+                attrname=node.attr,
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                # end_lineno and end_col_offset added in 3.8
+                end_lineno=getattr(node, "end_lineno", None),
+                end_col_offset=getattr(node, "end_col_offset", None),
+                parent=parent,
+            )
+            # Prohibit a local save if we are in an ExceptHandler.
+            if not isinstance(parent, nodes.ExceptHandler):
+                # mypy doesn't recognize that newnode has to be AssignAttr because it doesn't support ParamSpec
+                # See https://github.com/python/mypy/issues/8645
+                self._delayed_assattr.append(newnode)  # type: ignore[arg-type]
+        else:
+            newnode = nodes.Attribute(
+                attrname=node.attr,
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                # end_lineno and end_col_offset added in 3.8
+                end_lineno=getattr(node, "end_lineno", None),
+                end_col_offset=getattr(node, "end_col_offset", None),
+                parent=parent,
+            )
+        newnode.postinit(self.visit(node.value, newnode))
+        return newnode
+
+    def visit_global(self, node: "ast.Global", parent: NodeNG) -> nodes.Global:
+        """visit a Global node to become astroid"""
+        newnode = nodes.Global(
+            names=node.names,
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        if self._global_names:  # global at the module level, no effect
+            for name in node.names:
+                self._global_names[-1].setdefault(name, []).append(newnode)
+        return newnode
+
+    def visit_if(self, node: "ast.If", parent: NodeNG) -> nodes.If:
+        """visit an If node by returning a fresh instance of it"""
+        newnode = nodes.If(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.test, newnode),
+            [self.visit(child, newnode) for child in node.body],
+            [self.visit(child, newnode) for child in node.orelse],
+        )
+        return newnode
+
+    def visit_ifexp(self, node: "ast.IfExp", parent: NodeNG) -> nodes.IfExp:
+        """visit a IfExp node by returning a fresh instance of it"""
+        newnode = nodes.IfExp(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.test, newnode),
+            self.visit(node.body, newnode),
+            self.visit(node.orelse, newnode),
+        )
+        return newnode
+
+    def visit_import(self, node: "ast.Import", parent: NodeNG) -> nodes.Import:
+        """visit a Import node by returning a fresh instance of it"""
+        names = [(alias.name, alias.asname) for alias in node.names]
+        newnode = nodes.Import(
+            names=names,
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        # save import names in parent's locals:
+        for (name, asname) in newnode.names:
+            name = asname or name
+            parent.set_local(name.split(".")[0], newnode)
+        return newnode
+
+    def visit_joinedstr(self, node: "ast.JoinedStr", parent: NodeNG) -> nodes.JoinedStr:
+        newnode = nodes.JoinedStr(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit([self.visit(child, newnode) for child in node.values])
+        return newnode
+
+    def visit_formattedvalue(
+        self, node: "ast.FormattedValue", parent: NodeNG
+    ) -> nodes.FormattedValue:
+        newnode = nodes.FormattedValue(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.value, newnode),
+            node.conversion,
+            self.visit(node.format_spec, newnode),
+        )
+        return newnode
+
+    if sys.version_info >= (3, 8):
+
+        def visit_namedexpr(
+            self, node: "ast.NamedExpr", parent: NodeNG
+        ) -> nodes.NamedExpr:
+            newnode = nodes.NamedExpr(
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                # end_lineno and end_col_offset added in 3.8
+                end_lineno=getattr(node, "end_lineno", None),
+                end_col_offset=getattr(node, "end_col_offset", None),
+                parent=parent,
+            )
+            newnode.postinit(
+                self.visit(node.target, newnode), self.visit(node.value, newnode)
+            )
+            return newnode
+
+    if sys.version_info < (3, 9):
+        # Not used in Python 3.9+.
+        def visit_extslice(
+            self, node: "ast.ExtSlice", parent: nodes.Subscript
+        ) -> nodes.Tuple:
+            """visit an ExtSlice node by returning a fresh instance of Tuple"""
+            # ExtSlice doesn't have lineno or col_offset information
+            newnode = nodes.Tuple(ctx=Context.Load, parent=parent)
+            newnode.postinit([self.visit(dim, newnode) for dim in node.dims])
+            return newnode
+
+        def visit_index(self, node: "ast.Index", parent: nodes.Subscript) -> NodeNG:
+            """visit a Index node by returning a fresh instance of NodeNG"""
+            return self.visit(node.value, parent)
+
+    def visit_keyword(self, node: "ast.keyword", parent: NodeNG) -> nodes.Keyword:
+        """visit a Keyword node by returning a fresh instance of it"""
+        newnode = nodes.Keyword(
+            arg=node.arg,
+            # position attributes added in 3.9
+            lineno=getattr(node, "lineno", None),
+            col_offset=getattr(node, "col_offset", None),
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(self.visit(node.value, newnode))
+        return newnode
+
+    def visit_lambda(self, node: "ast.Lambda", parent: NodeNG) -> nodes.Lambda:
+        """visit a Lambda node by returning a fresh instance of it"""
+        newnode = nodes.Lambda(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(self.visit(node.args, newnode), self.visit(node.body, newnode))
+        return newnode
+
+    def visit_list(self, node: "ast.List", parent: NodeNG) -> nodes.List:
+        """visit a List node by returning a fresh instance of it"""
+        context = self._get_context(node)
+        newnode = nodes.List(
+            ctx=context,
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit([self.visit(child, newnode) for child in node.elts])
+        return newnode
+
+    def visit_listcomp(self, node: "ast.ListComp", parent: NodeNG) -> nodes.ListComp:
+        """visit a ListComp node by returning a fresh instance of it"""
+        newnode = nodes.ListComp(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.elt, newnode),
+            [self.visit(child, newnode) for child in node.generators],
+        )
+        return newnode
+
+    def visit_name(
+        self, node: "ast.Name", parent: NodeNG
+    ) -> Union[nodes.Name, nodes.AssignName, nodes.DelName]:
+        """visit a Name node by returning a fresh instance of it"""
+        context = self._get_context(node)
+        newnode: Union[nodes.Name, nodes.AssignName, nodes.DelName]
+        if context == Context.Del:
+            newnode = nodes.DelName(
+                name=node.id,
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                # end_lineno and end_col_offset added in 3.8
+                end_lineno=getattr(node, "end_lineno", None),
+                end_col_offset=getattr(node, "end_col_offset", None),
+                parent=parent,
+            )
+        elif context == Context.Store:
+            # pylint: disable=redefined-variable-type
+            newnode = nodes.AssignName(
+                name=node.id,
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                # end_lineno and end_col_offset added in 3.8
+                end_lineno=getattr(node, "end_lineno", None),
+                end_col_offset=getattr(node, "end_col_offset", None),
+                parent=parent,
+            )
+        else:
+            newnode = nodes.Name(
+                name=node.id,
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                # end_lineno and end_col_offset added in 3.8
+                end_lineno=getattr(node, "end_lineno", None),
+                end_col_offset=getattr(node, "end_col_offset", None),
+                parent=parent,
+            )
+        # XXX REMOVE me :
+        if context in (Context.Del, Context.Store):  # 'Aug' ??
+            newnode = cast(Union[nodes.AssignName, nodes.DelName], newnode)
+            self._save_assignment(newnode)
+        return newnode
+
+    def visit_nonlocal(self, node: "ast.Nonlocal", parent: NodeNG) -> nodes.Nonlocal:
+        """visit a Nonlocal node and return a new instance of it"""
+        return nodes.Nonlocal(
+            names=node.names,
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+
+    def visit_constant(self, node: "ast.Constant", parent: NodeNG) -> nodes.Const:
+        """visit a Constant node by returning a fresh instance of Const"""
+        return nodes.Const(
+            value=node.value,
+            kind=node.kind,
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+
+    if sys.version_info < (3, 8):
+        # Not used in Python 3.8+.
+        def visit_ellipsis(self, node: "ast.Ellipsis", parent: NodeNG) -> nodes.Const:
+            """visit an Ellipsis node by returning a fresh instance of Const"""
+            return nodes.Const(
+                value=Ellipsis,
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                parent=parent,
+            )
+
+        def visit_nameconstant(
+            self, node: "ast.NameConstant", parent: NodeNG
+        ) -> nodes.Const:
+            # For singleton values True / False / None
+            return nodes.Const(
+                node.value,
+                node.lineno,
+                node.col_offset,
+                parent,
+            )
+
+        def visit_str(
+            self, node: Union["ast.Str", "ast.Bytes"], parent: NodeNG
+        ) -> nodes.Const:
+            """visit a String/Bytes node by returning a fresh instance of Const"""
+            return nodes.Const(
+                node.s,
+                node.lineno,
+                node.col_offset,
+                parent,
+            )
+
+        visit_bytes = visit_str
+
+        def visit_num(self, node: "ast.Num", parent: NodeNG) -> nodes.Const:
+            """visit a Num node by returning a fresh instance of Const"""
+            return nodes.Const(
+                node.n,
+                node.lineno,
+                node.col_offset,
+                parent,
+            )
+
+    def visit_pass(self, node: "ast.Pass", parent: NodeNG) -> nodes.Pass:
+        """visit a Pass node by returning a fresh instance of it"""
+        return nodes.Pass(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+
+    def visit_raise(self, node: "ast.Raise", parent: NodeNG) -> nodes.Raise:
+        """visit a Raise node by returning a fresh instance of it"""
+        newnode = nodes.Raise(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        # no traceback; anyway it is not used in Pylint
+        newnode.postinit(
+            exc=self.visit(node.exc, newnode),
+            cause=self.visit(node.cause, newnode),
+        )
+        return newnode
+
+    def visit_return(self, node: "ast.Return", parent: NodeNG) -> nodes.Return:
+        """visit a Return node by returning a fresh instance of it"""
+        newnode = nodes.Return(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        if node.value is not None:
+            newnode.postinit(self.visit(node.value, newnode))
+        return newnode
+
+    def visit_set(self, node: "ast.Set", parent: NodeNG) -> nodes.Set:
+        """visit a Set node by returning a fresh instance of it"""
+        newnode = nodes.Set(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit([self.visit(child, newnode) for child in node.elts])
+        return newnode
+
+    def visit_setcomp(self, node: "ast.SetComp", parent: NodeNG) -> nodes.SetComp:
+        """visit a SetComp node by returning a fresh instance of it"""
+        newnode = nodes.SetComp(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.elt, newnode),
+            [self.visit(child, newnode) for child in node.generators],
+        )
+        return newnode
+
+    def visit_slice(self, node: "ast.Slice", parent: nodes.Subscript) -> nodes.Slice:
+        """visit a Slice node by returning a fresh instance of it"""
+        newnode = nodes.Slice(
+            # position attributes added in 3.9
+            lineno=getattr(node, "lineno", None),
+            col_offset=getattr(node, "col_offset", None),
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            lower=self.visit(node.lower, newnode),
+            upper=self.visit(node.upper, newnode),
+            step=self.visit(node.step, newnode),
+        )
+        return newnode
+
+    def visit_subscript(self, node: "ast.Subscript", parent: NodeNG) -> nodes.Subscript:
+        """visit a Subscript node by returning a fresh instance of it"""
+        context = self._get_context(node)
+        newnode = nodes.Subscript(
+            ctx=context,
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.value, newnode), self.visit(node.slice, newnode)
+        )
+        return newnode
+
+    def visit_starred(self, node: "ast.Starred", parent: NodeNG) -> nodes.Starred:
+        """visit a Starred node and return a new instance of it"""
+        context = self._get_context(node)
+        newnode = nodes.Starred(
+            ctx=context,
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(self.visit(node.value, newnode))
+        return newnode
+
+    def visit_tryexcept(self, node: "ast.Try", parent: NodeNG) -> nodes.TryExcept:
+        """visit a TryExcept node by returning a fresh instance of it"""
+        if sys.version_info >= (3, 8):
+            # TryExcept excludes the 'finally' but that will be included in the
+            # end_lineno from 'node'. Therefore, we check all non 'finally'
+            # children to find the correct end_lineno and column.
+            end_lineno = node.end_lineno
+            end_col_offset = node.end_col_offset
+            all_children: List["ast.AST"] = [*node.body, *node.handlers, *node.orelse]
+            for child in reversed(all_children):
+                end_lineno = child.end_lineno
+                end_col_offset = child.end_col_offset
+                break
+            newnode = nodes.TryExcept(
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                end_lineno=end_lineno,
+                end_col_offset=end_col_offset,
+                parent=parent,
+            )
+        else:
+            newnode = nodes.TryExcept(node.lineno, node.col_offset, parent)
+        newnode.postinit(
+            [self.visit(child, newnode) for child in node.body],
+            [self.visit(child, newnode) for child in node.handlers],
+            [self.visit(child, newnode) for child in node.orelse],
+        )
+        return newnode
+
+    def visit_try(
+        self, node: "ast.Try", parent: NodeNG
+    ) -> Union[nodes.TryExcept, nodes.TryFinally, None]:
+        # python 3.3 introduce a new Try node replacing
+        # TryFinally/TryExcept nodes
+        if node.finalbody:
+            newnode = nodes.TryFinally(
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                # end_lineno and end_col_offset added in 3.8
+                end_lineno=getattr(node, "end_lineno", None),
+                end_col_offset=getattr(node, "end_col_offset", None),
+                parent=parent,
+            )
+            body: List[Union[NodeNG, nodes.TryExcept]]
+            if node.handlers:
+                body = [self.visit_tryexcept(node, newnode)]
+            else:
+                body = [self.visit(child, newnode) for child in node.body]
+            newnode.postinit(body, [self.visit(n, newnode) for n in node.finalbody])
+            return newnode
+        if node.handlers:
+            return self.visit_tryexcept(node, parent)
+        return None
+
+    def visit_tuple(self, node: "ast.Tuple", parent: NodeNG) -> nodes.Tuple:
+        """visit a Tuple node by returning a fresh instance of it"""
+        context = self._get_context(node)
+        newnode = nodes.Tuple(
+            ctx=context,
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit([self.visit(child, newnode) for child in node.elts])
+        return newnode
+
+    def visit_unaryop(self, node: "ast.UnaryOp", parent: NodeNG) -> nodes.UnaryOp:
+        """visit a UnaryOp node by returning a fresh instance of it"""
+        newnode = nodes.UnaryOp(
+            op=self._parser_module.unary_op_classes[node.op.__class__],
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(self.visit(node.operand, newnode))
+        return newnode
+
+    def visit_while(self, node: "ast.While", parent: NodeNG) -> nodes.While:
+        """visit a While node by returning a fresh instance of it"""
+        newnode = nodes.While(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        newnode.postinit(
+            self.visit(node.test, newnode),
+            [self.visit(child, newnode) for child in node.body],
+            [self.visit(child, newnode) for child in node.orelse],
+        )
+        return newnode
+
+    @overload
+    def _visit_with(
+        self, cls: Type[nodes.With], node: "ast.With", parent: NodeNG
+    ) -> nodes.With:
+        ...
+
+    @overload
+    def _visit_with(
+        self, cls: Type[nodes.AsyncWith], node: "ast.AsyncWith", parent: NodeNG
+    ) -> nodes.AsyncWith:
+        ...
+
+    def _visit_with(
+        self,
+        cls: Type[T_With],
+        node: Union["ast.With", "ast.AsyncWith"],
+        parent: NodeNG,
+    ) -> T_With:
+        col_offset = node.col_offset
+        if IS_PYPY and not PY39_PLUS and isinstance(node, ast.AsyncWith) and self._data:
+            # pylint: disable-next=unsubscriptable-object
+            col_offset = self._data[node.lineno - 1].index("async")
+
+        newnode = cls(
+            lineno=node.lineno,
+            col_offset=col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+
+        def visit_child(child: "ast.withitem") -> Tuple[NodeNG, Optional[NodeNG]]:
+            expr = self.visit(child.context_expr, newnode)
+            var = self.visit(child.optional_vars, newnode)
+            return expr, var
+
+        type_annotation = self.check_type_comment(node, parent=newnode)
+        newnode.postinit(
+            items=[visit_child(child) for child in node.items],
+            body=[self.visit(child, newnode) for child in node.body],
+            type_annotation=type_annotation,
+        )
+        return newnode
+
+    def visit_with(self, node: "ast.With", parent: NodeNG) -> NodeNG:
+        return self._visit_with(nodes.With, node, parent)
+
+    def visit_yield(self, node: "ast.Yield", parent: NodeNG) -> NodeNG:
+        """visit a Yield node by returning a fresh instance of it"""
+        newnode = nodes.Yield(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        if node.value is not None:
+            newnode.postinit(self.visit(node.value, newnode))
+        return newnode
+
+    def visit_yieldfrom(self, node: "ast.YieldFrom", parent: NodeNG) -> NodeNG:
+        newnode = nodes.YieldFrom(
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+            # end_lineno and end_col_offset added in 3.8
+            end_lineno=getattr(node, "end_lineno", None),
+            end_col_offset=getattr(node, "end_col_offset", None),
+            parent=parent,
+        )
+        if node.value is not None:
+            newnode.postinit(self.visit(node.value, newnode))
+        return newnode
+
+    if sys.version_info >= (3, 10):
+
+        def visit_match(self, node: "ast.Match", parent: NodeNG) -> nodes.Match:
+            newnode = nodes.Match(
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                end_lineno=node.end_lineno,
+                end_col_offset=node.end_col_offset,
+                parent=parent,
+            )
+            newnode.postinit(
+                subject=self.visit(node.subject, newnode),
+                cases=[self.visit(case, newnode) for case in node.cases],
+            )
+            return newnode
+
+        def visit_matchcase(
+            self, node: "ast.match_case", parent: NodeNG
+        ) -> nodes.MatchCase:
+            newnode = nodes.MatchCase(parent=parent)
+            newnode.postinit(
+                pattern=self.visit(node.pattern, newnode),
+                guard=self.visit(node.guard, newnode),
+                body=[self.visit(child, newnode) for child in node.body],
+            )
+            return newnode
+
+        def visit_matchvalue(
+            self, node: "ast.MatchValue", parent: NodeNG
+        ) -> nodes.MatchValue:
+            newnode = nodes.MatchValue(
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                end_lineno=node.end_lineno,
+                end_col_offset=node.end_col_offset,
+                parent=parent,
+            )
+            newnode.postinit(value=self.visit(node.value, newnode))
+            return newnode
+
+        def visit_matchsingleton(
+            self, node: "ast.MatchSingleton", parent: NodeNG
+        ) -> nodes.MatchSingleton:
+            return nodes.MatchSingleton(
+                value=node.value,
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                end_lineno=node.end_lineno,
+                end_col_offset=node.end_col_offset,
+                parent=parent,
+            )
+
+        def visit_matchsequence(
+            self, node: "ast.MatchSequence", parent: NodeNG
+        ) -> nodes.MatchSequence:
+            newnode = nodes.MatchSequence(
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                end_lineno=node.end_lineno,
+                end_col_offset=node.end_col_offset,
+                parent=parent,
+            )
+            newnode.postinit(
+                patterns=[self.visit(pattern, newnode) for pattern in node.patterns]
+            )
+            return newnode
+
+        def visit_matchmapping(
+            self, node: "ast.MatchMapping", parent: NodeNG
+        ) -> nodes.MatchMapping:
+            newnode = nodes.MatchMapping(
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                end_lineno=node.end_lineno,
+                end_col_offset=node.end_col_offset,
+                parent=parent,
+            )
+            # Add AssignName node for 'node.name'
+            # https://bugs.python.org/issue43994
+            newnode.postinit(
+                keys=[self.visit(child, newnode) for child in node.keys],
+                patterns=[self.visit(pattern, newnode) for pattern in node.patterns],
+                rest=self.visit_assignname(node, newnode, node.rest),
+            )
+            return newnode
+
+        def visit_matchclass(
+            self, node: "ast.MatchClass", parent: NodeNG
+        ) -> nodes.MatchClass:
+            newnode = nodes.MatchClass(
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                end_lineno=node.end_lineno,
+                end_col_offset=node.end_col_offset,
+                parent=parent,
+            )
+            newnode.postinit(
+                cls=self.visit(node.cls, newnode),
+                patterns=[self.visit(pattern, newnode) for pattern in node.patterns],
+                kwd_attrs=node.kwd_attrs,
+                kwd_patterns=[
+                    self.visit(pattern, newnode) for pattern in node.kwd_patterns
+                ],
+            )
+            return newnode
+
+        def visit_matchstar(
+            self, node: "ast.MatchStar", parent: NodeNG
+        ) -> nodes.MatchStar:
+            newnode = nodes.MatchStar(
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                end_lineno=node.end_lineno,
+                end_col_offset=node.end_col_offset,
+                parent=parent,
+            )
+            # Add AssignName node for 'node.name'
+            # https://bugs.python.org/issue43994
+            newnode.postinit(name=self.visit_assignname(node, newnode, node.name))
+            return newnode
+
+        def visit_matchas(self, node: "ast.MatchAs", parent: NodeNG) -> nodes.MatchAs:
+            newnode = nodes.MatchAs(
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                end_lineno=node.end_lineno,
+                end_col_offset=node.end_col_offset,
+                parent=parent,
+            )
+            # Add AssignName node for 'node.name'
+            # https://bugs.python.org/issue43994
+            newnode.postinit(
+                pattern=self.visit(node.pattern, newnode),
+                name=self.visit_assignname(node, newnode, node.name),
+            )
+            return newnode
+
+        def visit_matchor(self, node: "ast.MatchOr", parent: NodeNG) -> nodes.MatchOr:
+            newnode = nodes.MatchOr(
+                lineno=node.lineno,
+                col_offset=node.col_offset,
+                end_lineno=node.end_lineno,
+                end_col_offset=node.end_col_offset,
+                parent=parent,
+            )
+            newnode.postinit(
+                patterns=[self.visit(pattern, newnode) for pattern in node.patterns]
+            )
+            return newnode
diff --git a/myenv/lib/python3.9/site-packages/astroid/scoped_nodes.py b/myenv/lib/python3.9/site-packages/astroid/scoped_nodes.py
new file mode 100644
index 0000000..677f892
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/scoped_nodes.py
@@ -0,0 +1,33 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+# pylint: disable=unused-import
+
+import warnings
+
+from astroid.nodes.scoped_nodes import (
+    AsyncFunctionDef,
+    ClassDef,
+    ComprehensionScope,
+    DictComp,
+    FunctionDef,
+    GeneratorExp,
+    Lambda,
+    ListComp,
+    LocalsDictNodeNG,
+    Module,
+    SetComp,
+    _is_metaclass,
+    builtin_lookup,
+    function_to_method,
+    get_wrapping_class,
+)
+
+# We cannot create a __all__ here because it would create a circular import
+# Please remove astroid/scoped_nodes.py|astroid/node_classes.py in autoflake
+# exclude when removing this file.
+warnings.warn(
+    "The 'astroid.scoped_nodes' module is deprecated and will be replaced by 'astroid.nodes' in astroid 3.0.0",
+    DeprecationWarning,
+)
diff --git a/myenv/lib/python3.9/site-packages/astroid/test_utils.py b/myenv/lib/python3.9/site-packages/astroid/test_utils.py
new file mode 100644
index 0000000..2ab7383
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/test_utils.py
@@ -0,0 +1,76 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Utility functions for test code that uses astroid ASTs as input."""
+import contextlib
+import functools
+import sys
+import warnings
+from typing import Callable, Tuple
+
+import pytest
+
+from astroid import manager, nodes, transforms
+
+
+def require_version(minver: str = "0.0.0", maxver: str = "4.0.0") -> Callable:
+    """Compare version of python interpreter to the given one.
+    Skip the test if older.
+    """
+
+    def parse(python_version: str) -> Tuple[int, ...]:
+        try:
+            return tuple(int(v) for v in python_version.split("."))
+        except ValueError as e:
+            msg = f"{python_version} is not a correct version : should be X.Y[.Z]."
+            raise ValueError(msg) from e
+
+    min_version = parse(minver)
+    max_version = parse(maxver)
+
+    def check_require_version(f):
+        current: Tuple[int, int, int] = sys.version_info[:3]
+        if min_version < current <= max_version:
+            return f
+
+        version: str = ".".join(str(v) for v in sys.version_info)
+
+        @functools.wraps(f)
+        def new_f(*args, **kwargs):
+            if current <= min_version:
+                pytest.skip(f"Needs Python > {minver}. Current version is {version}.")
+            elif current > max_version:
+                pytest.skip(f"Needs Python <= {maxver}. Current version is {version}.")
+
+        return new_f
+
+    return check_require_version
+
+
+def get_name_node(start_from, name, index=0):
+    return [n for n in start_from.nodes_of_class(nodes.Name) if n.name == name][index]
+
+
+@contextlib.contextmanager
+def enable_warning(warning):
+    warnings.simplefilter("always", warning)
+    try:
+        yield
+    finally:
+        # Reset it to default value, so it will take
+        # into account the values from the -W flag.
+        warnings.simplefilter("default", warning)
+
+
+def brainless_manager():
+    m = manager.AstroidManager()
+    # avoid caching into the AstroidManager borg since we get problems
+    # with other tests :
+    m.__dict__ = {}
+    m._failed_import_hooks = []
+    m.astroid_cache = {}
+    m._mod_file_cache = {}
+    m._transform = transforms.TransformVisitor()
+    m.extension_package_whitelist = {}
+    return m
diff --git a/myenv/lib/python3.9/site-packages/astroid/transforms.py b/myenv/lib/python3.9/site-packages/astroid/transforms.py
new file mode 100644
index 0000000..2fc8935
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/transforms.py
@@ -0,0 +1,88 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+import collections
+from typing import TYPE_CHECKING
+
+from astroid.context import _invalidate_cache
+
+if TYPE_CHECKING:
+    from astroid import NodeNG
+
+
+class TransformVisitor:
+    """A visitor for handling transforms.
+
+    The standard approach of using it is to call
+    :meth:`~visit` with an *astroid* module and the class
+    will take care of the rest, walking the tree and running the
+    transforms for each encountered node.
+    """
+
+    def __init__(self):
+        self.transforms = collections.defaultdict(list)
+
+    def _transform(self, node: "NodeNG") -> "NodeNG":
+        """Call matching transforms for the given node if any and return the
+        transformed node.
+        """
+        cls = node.__class__
+        if cls not in self.transforms:
+            # no transform registered for this class of node
+            return node
+
+        transforms = self.transforms[cls]
+        for transform_func, predicate in transforms:
+            if predicate is None or predicate(node):
+                ret = transform_func(node)
+                # if the transformation function returns something, it's
+                # expected to be a replacement for the node
+                if ret is not None:
+                    _invalidate_cache()
+                    node = ret
+                if ret.__class__ != cls:
+                    # Can no longer apply the rest of the transforms.
+                    break
+        return node
+
+    def _visit(self, node):
+        if hasattr(node, "_astroid_fields"):
+            for name in node._astroid_fields:
+                value = getattr(node, name)
+                visited = self._visit_generic(value)
+                if visited != value:
+                    setattr(node, name, visited)
+        return self._transform(node)
+
+    def _visit_generic(self, node):
+        if isinstance(node, list):
+            return [self._visit_generic(child) for child in node]
+        if isinstance(node, tuple):
+            return tuple(self._visit_generic(child) for child in node)
+        if not node or isinstance(node, str):
+            return node
+
+        return self._visit(node)
+
+    def register_transform(self, node_class, transform, predicate=None):
+        """Register `transform(node)` function to be applied on the given
+        astroid's `node_class` if `predicate` is None or returns true
+        when called with the node as argument.
+
+        The transform function may return a value which is then used to
+        substitute the original node in the tree.
+        """
+        self.transforms[node_class].append((transform, predicate))
+
+    def unregister_transform(self, node_class, transform, predicate=None):
+        """Unregister the given transform."""
+        self.transforms[node_class].remove((transform, predicate))
+
+    def visit(self, module):
+        """Walk the given astroid *tree* and transform each encountered node
+
+        Only the nodes which have transforms registered will actually
+        be replaced or changed.
+        """
+        return self._visit(module)
diff --git a/myenv/lib/python3.9/site-packages/astroid/typing.py b/myenv/lib/python3.9/site-packages/astroid/typing.py
new file mode 100644
index 0000000..32d01dd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/typing.py
@@ -0,0 +1,27 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+import sys
+from typing import TYPE_CHECKING, Any, Callable
+
+if TYPE_CHECKING:
+    from astroid import nodes
+    from astroid.context import InferenceContext
+
+if sys.version_info >= (3, 8):
+    from typing import TypedDict
+else:
+    from typing_extensions import TypedDict
+
+
+class InferenceErrorInfo(TypedDict):
+    """Store additional Inference error information
+    raised with StopIteration exception.
+    """
+
+    node: "nodes.NodeNG"
+    context: "InferenceContext | None"
+
+
+InferFn = Callable[..., Any]
diff --git a/myenv/lib/python3.9/site-packages/astroid/util.py b/myenv/lib/python3.9/site-packages/astroid/util.py
new file mode 100644
index 0000000..b071285
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/astroid/util.py
@@ -0,0 +1,147 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+import importlib
+import warnings
+
+import lazy_object_proxy
+
+
+def lazy_descriptor(obj):
+    class DescriptorProxy(lazy_object_proxy.Proxy):
+        def __get__(self, instance, owner=None):
+            return self.__class__.__get__(self, instance)
+
+    return DescriptorProxy(obj)
+
+
+def lazy_import(module_name):
+    return lazy_object_proxy.Proxy(
+        lambda: importlib.import_module("." + module_name, "astroid")
+    )
+
+
+@object.__new__
+class Uninferable:
+    """Special inference object, which is returned when inference fails."""
+
+    def __repr__(self):
+        return "Uninferable"
+
+    __str__ = __repr__
+
+    def __getattribute__(self, name):
+        if name == "next":
+            raise AttributeError("next method should not be called")
+        if name.startswith("__") and name.endswith("__"):
+            return object.__getattribute__(self, name)
+        if name == "accept":
+            return object.__getattribute__(self, name)
+        return self
+
+    def __call__(self, *args, **kwargs):
+        return self
+
+    def __bool__(self):
+        return False
+
+    __nonzero__ = __bool__
+
+    def accept(self, visitor):
+        return visitor.visit_uninferable(self)
+
+
+class BadOperationMessage:
+    """Object which describes a TypeError occurred somewhere in the inference chain
+
+    This is not an exception, but a container object which holds the types and
+    the error which occurred.
+    """
+
+
+class BadUnaryOperationMessage(BadOperationMessage):
+    """Object which describes operational failures on UnaryOps."""
+
+    def __init__(self, operand, op, error):
+        self.operand = operand
+        self.op = op
+        self.error = error
+
+    @property
+    def _object_type_helper(self):
+        helpers = lazy_import("helpers")
+        return helpers.object_type
+
+    def _object_type(self, obj):
+        objtype = self._object_type_helper(obj)
+        if objtype is Uninferable:
+            return None
+
+        return objtype
+
+    def __str__(self):
+        if hasattr(self.operand, "name"):
+            operand_type = self.operand.name
+        else:
+            object_type = self._object_type(self.operand)
+            if hasattr(object_type, "name"):
+                operand_type = object_type.name
+            else:
+                # Just fallback to as_string
+                operand_type = object_type.as_string()
+
+        msg = "bad operand type for unary {}: {}"
+        return msg.format(self.op, operand_type)
+
+
+class BadBinaryOperationMessage(BadOperationMessage):
+    """Object which describes type errors for BinOps."""
+
+    def __init__(self, left_type, op, right_type):
+        self.left_type = left_type
+        self.right_type = right_type
+        self.op = op
+
+    def __str__(self):
+        msg = "unsupported operand type(s) for {}: {!r} and {!r}"
+        return msg.format(self.op, self.left_type.name, self.right_type.name)
+
+
+def _instancecheck(cls, other):
+    wrapped = cls.__wrapped__
+    other_cls = other.__class__
+    is_instance_of = wrapped is other_cls or issubclass(other_cls, wrapped)
+    warnings.warn(
+        "%r is deprecated and slated for removal in astroid "
+        "2.0, use %r instead" % (cls.__class__.__name__, wrapped.__name__),
+        PendingDeprecationWarning,
+        stacklevel=2,
+    )
+    return is_instance_of
+
+
+def proxy_alias(alias_name, node_type):
+    """Get a Proxy from the given name to the given node type."""
+    proxy = type(
+        alias_name,
+        (lazy_object_proxy.Proxy,),
+        {
+            "__class__": object.__dict__["__class__"],
+            "__instancecheck__": _instancecheck,
+        },
+    )
+    return proxy(lambda: node_type)
+
+
+def check_warnings_filter() -> bool:
+    """Return True if any other than the default DeprecationWarning filter is enabled.
+
+    https://docs.python.org/3/library/warnings.html#default-warning-filter
+    """
+    return any(
+        issubclass(DeprecationWarning, filter[2])
+        and filter[0] != "ignore"
+        and filter[3] != "__main__"
+        for filter in warnings.filters
+    )
diff --git a/myenv/lib/python3.9/site-packages/attr/__init__.py b/myenv/lib/python3.9/site-packages/attr/__init__.py
new file mode 100644
index 0000000..f95c96d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/__init__.py
@@ -0,0 +1,80 @@
+# SPDX-License-Identifier: MIT
+
+from __future__ import absolute_import, division, print_function
+
+import sys
+
+from functools import partial
+
+from . import converters, exceptions, filters, setters, validators
+from ._cmp import cmp_using
+from ._config import get_run_validators, set_run_validators
+from ._funcs import asdict, assoc, astuple, evolve, has, resolve_types
+from ._make import (
+    NOTHING,
+    Attribute,
+    Factory,
+    attrib,
+    attrs,
+    fields,
+    fields_dict,
+    make_class,
+    validate,
+)
+from ._version_info import VersionInfo
+
+
+__version__ = "21.4.0"
+__version_info__ = VersionInfo._from_version_string(__version__)
+
+__title__ = "attrs"
+__description__ = "Classes Without Boilerplate"
+__url__ = "https://www.attrs.org/"
+__uri__ = __url__
+__doc__ = __description__ + " <" + __uri__ + ">"
+
+__author__ = "Hynek Schlawack"
+__email__ = "hs@ox.cx"
+
+__license__ = "MIT"
+__copyright__ = "Copyright (c) 2015 Hynek Schlawack"
+
+
+s = attributes = attrs
+ib = attr = attrib
+dataclass = partial(attrs, auto_attribs=True)  # happy Easter ;)
+
+__all__ = [
+    "Attribute",
+    "Factory",
+    "NOTHING",
+    "asdict",
+    "assoc",
+    "astuple",
+    "attr",
+    "attrib",
+    "attributes",
+    "attrs",
+    "cmp_using",
+    "converters",
+    "evolve",
+    "exceptions",
+    "fields",
+    "fields_dict",
+    "filters",
+    "get_run_validators",
+    "has",
+    "ib",
+    "make_class",
+    "resolve_types",
+    "s",
+    "set_run_validators",
+    "setters",
+    "validate",
+    "validators",
+]
+
+if sys.version_info[:2] >= (3, 6):
+    from ._next_gen import define, field, frozen, mutable  # noqa: F401
+
+    __all__.extend(("define", "field", "frozen", "mutable"))
diff --git a/myenv/lib/python3.9/site-packages/attr/__init__.pyi b/myenv/lib/python3.9/site-packages/attr/__init__.pyi
new file mode 100644
index 0000000..c0a2126
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/__init__.pyi
@@ -0,0 +1,484 @@
+import sys
+
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+# `import X as X` is required to make these public
+from . import converters as converters
+from . import exceptions as exceptions
+from . import filters as filters
+from . import setters as setters
+from . import validators as validators
+from ._version_info import VersionInfo
+
+__version__: str
+__version_info__: VersionInfo
+__title__: str
+__description__: str
+__url__: str
+__uri__: str
+__author__: str
+__email__: str
+__license__: str
+__copyright__: str
+
+_T = TypeVar("_T")
+_C = TypeVar("_C", bound=type)
+
+_EqOrderType = Union[bool, Callable[[Any], Any]]
+_ValidatorType = Callable[[Any, Attribute[_T], _T], Any]
+_ConverterType = Callable[[Any], Any]
+_FilterType = Callable[[Attribute[_T], _T], bool]
+_ReprType = Callable[[Any], str]
+_ReprArgType = Union[bool, _ReprType]
+_OnSetAttrType = Callable[[Any, Attribute[Any], Any], Any]
+_OnSetAttrArgType = Union[
+    _OnSetAttrType, List[_OnSetAttrType], setters._NoOpType
+]
+_FieldTransformer = Callable[
+    [type, List[Attribute[Any]]], List[Attribute[Any]]
+]
+_CompareWithType = Callable[[Any, Any], bool]
+# FIXME: in reality, if multiple validators are passed they must be in a list
+# or tuple, but those are invariant and so would prevent subtypes of
+# _ValidatorType from working when passed in a list or tuple.
+_ValidatorArgType = Union[_ValidatorType[_T], Sequence[_ValidatorType[_T]]]
+
+# _make --
+
+NOTHING: object
+
+# NOTE: Factory lies about its return type to make this possible:
+# `x: List[int] # = Factory(list)`
+# Work around mypy issue #4554 in the common case by using an overload.
+if sys.version_info >= (3, 8):
+    from typing import Literal
+    @overload
+    def Factory(factory: Callable[[], _T]) -> _T: ...
+    @overload
+    def Factory(
+        factory: Callable[[Any], _T],
+        takes_self: Literal[True],
+    ) -> _T: ...
+    @overload
+    def Factory(
+        factory: Callable[[], _T],
+        takes_self: Literal[False],
+    ) -> _T: ...
+
+else:
+    @overload
+    def Factory(factory: Callable[[], _T]) -> _T: ...
+    @overload
+    def Factory(
+        factory: Union[Callable[[Any], _T], Callable[[], _T]],
+        takes_self: bool = ...,
+    ) -> _T: ...
+
+# Static type inference support via __dataclass_transform__ implemented as per:
+# https://github.com/microsoft/pyright/blob/1.1.135/specs/dataclass_transforms.md
+# This annotation must be applied to all overloads of "define" and "attrs"
+#
+# NOTE: This is a typing construct and does not exist at runtime.  Extensions
+# wrapping attrs decorators should declare a separate __dataclass_transform__
+# signature in the extension module using the specification linked above to
+# provide pyright support.
+def __dataclass_transform__(
+    *,
+    eq_default: bool = True,
+    order_default: bool = False,
+    kw_only_default: bool = False,
+    field_descriptors: Tuple[Union[type, Callable[..., Any]], ...] = (()),
+) -> Callable[[_T], _T]: ...
+
+class Attribute(Generic[_T]):
+    name: str
+    default: Optional[_T]
+    validator: Optional[_ValidatorType[_T]]
+    repr: _ReprArgType
+    cmp: _EqOrderType
+    eq: _EqOrderType
+    order: _EqOrderType
+    hash: Optional[bool]
+    init: bool
+    converter: Optional[_ConverterType]
+    metadata: Dict[Any, Any]
+    type: Optional[Type[_T]]
+    kw_only: bool
+    on_setattr: _OnSetAttrType
+    def evolve(self, **changes: Any) -> "Attribute[Any]": ...
+
+# NOTE: We had several choices for the annotation to use for type arg:
+# 1) Type[_T]
+#   - Pros: Handles simple cases correctly
+#   - Cons: Might produce less informative errors in the case of conflicting
+#     TypeVars e.g. `attr.ib(default='bad', type=int)`
+# 2) Callable[..., _T]
+#   - Pros: Better error messages than #1 for conflicting TypeVars
+#   - Cons: Terrible error messages for validator checks.
+#   e.g. attr.ib(type=int, validator=validate_str)
+#        -> error: Cannot infer function type argument
+# 3) type (and do all of the work in the mypy plugin)
+#   - Pros: Simple here, and we could customize the plugin with our own errors.
+#   - Cons: Would need to write mypy plugin code to handle all the cases.
+# We chose option #1.
+
+# `attr` lies about its return type to make the following possible:
+#     attr()    -> Any
+#     attr(8)   -> int
+#     attr(validator=<some callable>)  -> Whatever the callable expects.
+# This makes this type of assignments possible:
+#     x: int = attr(8)
+#
+# This form catches explicit None or no default but with no other arguments
+# returns Any.
+@overload
+def attrib(
+    default: None = ...,
+    validator: None = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: None = ...,
+    converter: None = ...,
+    factory: None = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+
+# This form catches an explicit None or no default and infers the type from the
+# other arguments.
+@overload
+def attrib(
+    default: None = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: Optional[Type[_T]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form catches an explicit default argument.
+@overload
+def attrib(
+    default: _T,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: Optional[Type[_T]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form covers type=non-Type: e.g. forward references (str), Any
+@overload
+def attrib(
+    default: Optional[_T] = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: object = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+@overload
+def field(
+    *,
+    default: None = ...,
+    validator: None = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: None = ...,
+    factory: None = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+
+# This form catches an explicit None or no default and infers the type from the
+# other arguments.
+@overload
+def field(
+    *,
+    default: None = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form catches an explicit default argument.
+@overload
+def field(
+    *,
+    default: _T,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form covers type=non-Type: e.g. forward references (str), Any
+@overload
+def field(
+    *,
+    default: Optional[_T] = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+@overload
+@__dataclass_transform__(order_default=True, field_descriptors=(attrib, field))
+def attrs(
+    maybe_cls: _C,
+    these: Optional[Dict[str, Any]] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    auto_detect: bool = ...,
+    collect_by_mro: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+    match_args: bool = ...,
+) -> _C: ...
+@overload
+@__dataclass_transform__(order_default=True, field_descriptors=(attrib, field))
+def attrs(
+    maybe_cls: None = ...,
+    these: Optional[Dict[str, Any]] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    auto_detect: bool = ...,
+    collect_by_mro: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+    match_args: bool = ...,
+) -> Callable[[_C], _C]: ...
+@overload
+@__dataclass_transform__(field_descriptors=(attrib, field))
+def define(
+    maybe_cls: _C,
+    *,
+    these: Optional[Dict[str, Any]] = ...,
+    repr: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    auto_detect: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+    match_args: bool = ...,
+) -> _C: ...
+@overload
+@__dataclass_transform__(field_descriptors=(attrib, field))
+def define(
+    maybe_cls: None = ...,
+    *,
+    these: Optional[Dict[str, Any]] = ...,
+    repr: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    auto_detect: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+    match_args: bool = ...,
+) -> Callable[[_C], _C]: ...
+
+mutable = define
+frozen = define  # they differ only in their defaults
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+class _Fields(Tuple[Attribute[Any], ...]):
+    def __getattr__(self, name: str) -> Attribute[Any]: ...
+
+def fields(cls: type) -> _Fields: ...
+def fields_dict(cls: type) -> Dict[str, Attribute[Any]]: ...
+def validate(inst: Any) -> None: ...
+def resolve_types(
+    cls: _C,
+    globalns: Optional[Dict[str, Any]] = ...,
+    localns: Optional[Dict[str, Any]] = ...,
+    attribs: Optional[List[Attribute[Any]]] = ...,
+) -> _C: ...
+
+# TODO: add support for returning a proper attrs class from the mypy plugin
+# we use Any instead of _CountingAttr so that e.g. `make_class('Foo',
+# [attr.ib()])` is valid
+def make_class(
+    name: str,
+    attrs: Union[List[str], Tuple[str, ...], Dict[str, Any]],
+    bases: Tuple[type, ...] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    collect_by_mro: bool = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+) -> type: ...
+
+# _funcs --
+
+# TODO: add support for returning TypedDict from the mypy plugin
+# FIXME: asdict/astuple do not honor their factory args. Waiting on one of
+# these:
+# https://github.com/python/mypy/issues/4236
+# https://github.com/python/typing/issues/253
+# XXX: remember to fix attrs.asdict/astuple too!
+def asdict(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType[Any]] = ...,
+    dict_factory: Type[Mapping[Any, Any]] = ...,
+    retain_collection_types: bool = ...,
+    value_serializer: Optional[
+        Callable[[type, Attribute[Any], Any], Any]
+    ] = ...,
+    tuple_keys: Optional[bool] = ...,
+) -> Dict[str, Any]: ...
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+def astuple(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType[Any]] = ...,
+    tuple_factory: Type[Sequence[Any]] = ...,
+    retain_collection_types: bool = ...,
+) -> Tuple[Any, ...]: ...
+def has(cls: type) -> bool: ...
+def assoc(inst: _T, **changes: Any) -> _T: ...
+def evolve(inst: _T, **changes: Any) -> _T: ...
+
+# _config --
+
+def set_run_validators(run: bool) -> None: ...
+def get_run_validators() -> bool: ...
+
+# aliases --
+
+s = attributes = attrs
+ib = attr = attrib
+dataclass = attrs  # Technically, partial(attrs, auto_attribs=True) ;)
diff --git a/myenv/lib/python3.9/site-packages/attr/_cmp.py b/myenv/lib/python3.9/site-packages/attr/_cmp.py
new file mode 100644
index 0000000..6cffa4d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/_cmp.py
@@ -0,0 +1,154 @@
+# SPDX-License-Identifier: MIT
+
+from __future__ import absolute_import, division, print_function
+
+import functools
+
+from ._compat import new_class
+from ._make import _make_ne
+
+
+_operation_names = {"eq": "==", "lt": "<", "le": "<=", "gt": ">", "ge": ">="}
+
+
+def cmp_using(
+    eq=None,
+    lt=None,
+    le=None,
+    gt=None,
+    ge=None,
+    require_same_type=True,
+    class_name="Comparable",
+):
+    """
+    Create a class that can be passed into `attr.ib`'s ``eq``, ``order``, and
+    ``cmp`` arguments to customize field comparison.
+
+    The resulting class will have a full set of ordering methods if
+    at least one of ``{lt, le, gt, ge}`` and ``eq``  are provided.
+
+    :param Optional[callable] eq: `callable` used to evaluate equality
+        of two objects.
+    :param Optional[callable] lt: `callable` used to evaluate whether
+        one object is less than another object.
+    :param Optional[callable] le: `callable` used to evaluate whether
+        one object is less than or equal to another object.
+    :param Optional[callable] gt: `callable` used to evaluate whether
+        one object is greater than another object.
+    :param Optional[callable] ge: `callable` used to evaluate whether
+        one object is greater than or equal to another object.
+
+    :param bool require_same_type: When `True`, equality and ordering methods
+        will return `NotImplemented` if objects are not of the same type.
+
+    :param Optional[str] class_name: Name of class. Defaults to 'Comparable'.
+
+    See `comparison` for more details.
+
+    .. versionadded:: 21.1.0
+    """
+
+    body = {
+        "__slots__": ["value"],
+        "__init__": _make_init(),
+        "_requirements": [],
+        "_is_comparable_to": _is_comparable_to,
+    }
+
+    # Add operations.
+    num_order_functions = 0
+    has_eq_function = False
+
+    if eq is not None:
+        has_eq_function = True
+        body["__eq__"] = _make_operator("eq", eq)
+        body["__ne__"] = _make_ne()
+
+    if lt is not None:
+        num_order_functions += 1
+        body["__lt__"] = _make_operator("lt", lt)
+
+    if le is not None:
+        num_order_functions += 1
+        body["__le__"] = _make_operator("le", le)
+
+    if gt is not None:
+        num_order_functions += 1
+        body["__gt__"] = _make_operator("gt", gt)
+
+    if ge is not None:
+        num_order_functions += 1
+        body["__ge__"] = _make_operator("ge", ge)
+
+    type_ = new_class(class_name, (object,), {}, lambda ns: ns.update(body))
+
+    # Add same type requirement.
+    if require_same_type:
+        type_._requirements.append(_check_same_type)
+
+    # Add total ordering if at least one operation was defined.
+    if 0 < num_order_functions < 4:
+        if not has_eq_function:
+            # functools.total_ordering requires __eq__ to be defined,
+            # so raise early error here to keep a nice stack.
+            raise ValueError(
+                "eq must be define is order to complete ordering from "
+                "lt, le, gt, ge."
+            )
+        type_ = functools.total_ordering(type_)
+
+    return type_
+
+
+def _make_init():
+    """
+    Create __init__ method.
+    """
+
+    def __init__(self, value):
+        """
+        Initialize object with *value*.
+        """
+        self.value = value
+
+    return __init__
+
+
+def _make_operator(name, func):
+    """
+    Create operator method.
+    """
+
+    def method(self, other):
+        if not self._is_comparable_to(other):
+            return NotImplemented
+
+        result = func(self.value, other.value)
+        if result is NotImplemented:
+            return NotImplemented
+
+        return result
+
+    method.__name__ = "__%s__" % (name,)
+    method.__doc__ = "Return a %s b.  Computed by attrs." % (
+        _operation_names[name],
+    )
+
+    return method
+
+
+def _is_comparable_to(self, other):
+    """
+    Check whether `other` is comparable to `self`.
+    """
+    for func in self._requirements:
+        if not func(self, other):
+            return False
+    return True
+
+
+def _check_same_type(self, other):
+    """
+    Return True if *self* and *other* are of the same type, False otherwise.
+    """
+    return other.value.__class__ is self.value.__class__
diff --git a/myenv/lib/python3.9/site-packages/attr/_cmp.pyi b/myenv/lib/python3.9/site-packages/attr/_cmp.pyi
new file mode 100644
index 0000000..e71aaff
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/_cmp.pyi
@@ -0,0 +1,13 @@
+from typing import Type
+
+from . import _CompareWithType
+
+def cmp_using(
+    eq: Optional[_CompareWithType],
+    lt: Optional[_CompareWithType],
+    le: Optional[_CompareWithType],
+    gt: Optional[_CompareWithType],
+    ge: Optional[_CompareWithType],
+    require_same_type: bool,
+    class_name: str,
+) -> Type: ...
diff --git a/myenv/lib/python3.9/site-packages/attr/_compat.py b/myenv/lib/python3.9/site-packages/attr/_compat.py
new file mode 100644
index 0000000..dc0cb02
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/_compat.py
@@ -0,0 +1,261 @@
+# SPDX-License-Identifier: MIT
+
+from __future__ import absolute_import, division, print_function
+
+import platform
+import sys
+import threading
+import types
+import warnings
+
+
+PY2 = sys.version_info[0] == 2
+PYPY = platform.python_implementation() == "PyPy"
+PY36 = sys.version_info[:2] >= (3, 6)
+HAS_F_STRINGS = PY36
+PY310 = sys.version_info[:2] >= (3, 10)
+
+
+if PYPY or PY36:
+    ordered_dict = dict
+else:
+    from collections import OrderedDict
+
+    ordered_dict = OrderedDict
+
+
+if PY2:
+    from collections import Mapping, Sequence
+
+    from UserDict import IterableUserDict
+
+    # We 'bundle' isclass instead of using inspect as importing inspect is
+    # fairly expensive (order of 10-15 ms for a modern machine in 2016)
+    def isclass(klass):
+        return isinstance(klass, (type, types.ClassType))
+
+    def new_class(name, bases, kwds, exec_body):
+        """
+        A minimal stub of types.new_class that we need for make_class.
+        """
+        ns = {}
+        exec_body(ns)
+
+        return type(name, bases, ns)
+
+    # TYPE is used in exceptions, repr(int) is different on Python 2 and 3.
+    TYPE = "type"
+
+    def iteritems(d):
+        return d.iteritems()
+
+    # Python 2 is bereft of a read-only dict proxy, so we make one!
+    class ReadOnlyDict(IterableUserDict):
+        """
+        Best-effort read-only dict wrapper.
+        """
+
+        def __setitem__(self, key, val):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise TypeError(
+                "'mappingproxy' object does not support item assignment"
+            )
+
+        def update(self, _):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'update'"
+            )
+
+        def __delitem__(self, _):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise TypeError(
+                "'mappingproxy' object does not support item deletion"
+            )
+
+        def clear(self):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'clear'"
+            )
+
+        def pop(self, key, default=None):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'pop'"
+            )
+
+        def popitem(self):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'popitem'"
+            )
+
+        def setdefault(self, key, default=None):
+            # We gently pretend we're a Python 3 mappingproxy.
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'setdefault'"
+            )
+
+        def __repr__(self):
+            # Override to be identical to the Python 3 version.
+            return "mappingproxy(" + repr(self.data) + ")"
+
+    def metadata_proxy(d):
+        res = ReadOnlyDict()
+        res.data.update(d)  # We blocked update, so we have to do it like this.
+        return res
+
+    def just_warn(*args, **kw):  # pragma: no cover
+        """
+        We only warn on Python 3 because we are not aware of any concrete
+        consequences of not setting the cell on Python 2.
+        """
+
+else:  # Python 3 and later.
+    from collections.abc import Mapping, Sequence  # noqa
+
+    def just_warn(*args, **kw):
+        """
+        We only warn on Python 3 because we are not aware of any concrete
+        consequences of not setting the cell on Python 2.
+        """
+        warnings.warn(
+            "Running interpreter doesn't sufficiently support code object "
+            "introspection.  Some features like bare super() or accessing "
+            "__class__ will not work with slotted classes.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+
+    def isclass(klass):
+        return isinstance(klass, type)
+
+    TYPE = "class"
+
+    def iteritems(d):
+        return d.items()
+
+    new_class = types.new_class
+
+    def metadata_proxy(d):
+        return types.MappingProxyType(dict(d))
+
+
+def make_set_closure_cell():
+    """Return a function of two arguments (cell, value) which sets
+    the value stored in the closure cell `cell` to `value`.
+    """
+    # pypy makes this easy. (It also supports the logic below, but
+    # why not do the easy/fast thing?)
+    if PYPY:
+
+        def set_closure_cell(cell, value):
+            cell.__setstate__((value,))
+
+        return set_closure_cell
+
+    # Otherwise gotta do it the hard way.
+
+    # Create a function that will set its first cellvar to `value`.
+    def set_first_cellvar_to(value):
+        x = value
+        return
+
+        # This function will be eliminated as dead code, but
+        # not before its reference to `x` forces `x` to be
+        # represented as a closure cell rather than a local.
+        def force_x_to_be_a_cell():  # pragma: no cover
+            return x
+
+    try:
+        # Extract the code object and make sure our assumptions about
+        # the closure behavior are correct.
+        if PY2:
+            co = set_first_cellvar_to.func_code
+        else:
+            co = set_first_cellvar_to.__code__
+        if co.co_cellvars != ("x",) or co.co_freevars != ():
+            raise AssertionError  # pragma: no cover
+
+        # Convert this code object to a code object that sets the
+        # function's first _freevar_ (not cellvar) to the argument.
+        if sys.version_info >= (3, 8):
+            # CPython 3.8+ has an incompatible CodeType signature
+            # (added a posonlyargcount argument) but also added
+            # CodeType.replace() to do this without counting parameters.
+            set_first_freevar_code = co.replace(
+                co_cellvars=co.co_freevars, co_freevars=co.co_cellvars
+            )
+        else:
+            args = [co.co_argcount]
+            if not PY2:
+                args.append(co.co_kwonlyargcount)
+            args.extend(
+                [
+                    co.co_nlocals,
+                    co.co_stacksize,
+                    co.co_flags,
+                    co.co_code,
+                    co.co_consts,
+                    co.co_names,
+                    co.co_varnames,
+                    co.co_filename,
+                    co.co_name,
+                    co.co_firstlineno,
+                    co.co_lnotab,
+                    # These two arguments are reversed:
+                    co.co_cellvars,
+                    co.co_freevars,
+                ]
+            )
+            set_first_freevar_code = types.CodeType(*args)
+
+        def set_closure_cell(cell, value):
+            # Create a function using the set_first_freevar_code,
+            # whose first closure cell is `cell`. Calling it will
+            # change the value of that cell.
+            setter = types.FunctionType(
+                set_first_freevar_code, {}, "setter", (), (cell,)
+            )
+            # And call it to set the cell.
+            setter(value)
+
+        # Make sure it works on this interpreter:
+        def make_func_with_cell():
+            x = None
+
+            def func():
+                return x  # pragma: no cover
+
+            return func
+
+        if PY2:
+            cell = make_func_with_cell().func_closure[0]
+        else:
+            cell = make_func_with_cell().__closure__[0]
+        set_closure_cell(cell, 100)
+        if cell.cell_contents != 100:
+            raise AssertionError  # pragma: no cover
+
+    except Exception:
+        return just_warn
+    else:
+        return set_closure_cell
+
+
+set_closure_cell = make_set_closure_cell()
+
+# Thread-local global to track attrs instances which are already being repr'd.
+# This is needed because there is no other (thread-safe) way to pass info
+# about the instances that are already being repr'd through the call stack
+# in order to ensure we don't perform infinite recursion.
+#
+# For instance, if an instance contains a dict which contains that instance,
+# we need to know that we're already repr'ing the outside instance from within
+# the dict's repr() call.
+#
+# This lives here rather than in _make.py so that the functions in _make.py
+# don't have a direct reference to the thread-local in their globals dict.
+# If they have such a reference, it breaks cloudpickle.
+repr_context = threading.local()
diff --git a/myenv/lib/python3.9/site-packages/attr/_config.py b/myenv/lib/python3.9/site-packages/attr/_config.py
new file mode 100644
index 0000000..fc9be29
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/_config.py
@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: MIT
+
+from __future__ import absolute_import, division, print_function
+
+
+__all__ = ["set_run_validators", "get_run_validators"]
+
+_run_validators = True
+
+
+def set_run_validators(run):
+    """
+    Set whether or not validators are run.  By default, they are run.
+
+    .. deprecated:: 21.3.0 It will not be removed, but it also will not be
+        moved to new ``attrs`` namespace. Use `attrs.validators.set_disabled()`
+        instead.
+    """
+    if not isinstance(run, bool):
+        raise TypeError("'run' must be bool.")
+    global _run_validators
+    _run_validators = run
+
+
+def get_run_validators():
+    """
+    Return whether or not validators are run.
+
+    .. deprecated:: 21.3.0 It will not be removed, but it also will not be
+        moved to new ``attrs`` namespace. Use `attrs.validators.get_disabled()`
+        instead.
+    """
+    return _run_validators
diff --git a/myenv/lib/python3.9/site-packages/attr/_funcs.py b/myenv/lib/python3.9/site-packages/attr/_funcs.py
new file mode 100644
index 0000000..4c90085
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/_funcs.py
@@ -0,0 +1,422 @@
+# SPDX-License-Identifier: MIT
+
+from __future__ import absolute_import, division, print_function
+
+import copy
+
+from ._compat import iteritems
+from ._make import NOTHING, _obj_setattr, fields
+from .exceptions import AttrsAttributeNotFoundError
+
+
+def asdict(
+    inst,
+    recurse=True,
+    filter=None,
+    dict_factory=dict,
+    retain_collection_types=False,
+    value_serializer=None,
+):
+    """
+    Return the ``attrs`` attribute values of *inst* as a dict.
+
+    Optionally recurse into other ``attrs``-decorated classes.
+
+    :param inst: Instance of an ``attrs``-decorated class.
+    :param bool recurse: Recurse into classes that are also
+        ``attrs``-decorated.
+    :param callable filter: A callable whose return code determines whether an
+        attribute or element is included (``True``) or dropped (``False``).  Is
+        called with the `attrs.Attribute` as the first argument and the
+        value as the second argument.
+    :param callable dict_factory: A callable to produce dictionaries from.  For
+        example, to produce ordered dictionaries instead of normal Python
+        dictionaries, pass in ``collections.OrderedDict``.
+    :param bool retain_collection_types: Do not convert to ``list`` when
+        encountering an attribute whose type is ``tuple`` or ``set``.  Only
+        meaningful if ``recurse`` is ``True``.
+    :param Optional[callable] value_serializer: A hook that is called for every
+        attribute or dict key/value.  It receives the current instance, field
+        and value and must return the (updated) value.  The hook is run *after*
+        the optional *filter* has been applied.
+
+    :rtype: return type of *dict_factory*
+
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    ..  versionadded:: 16.0.0 *dict_factory*
+    ..  versionadded:: 16.1.0 *retain_collection_types*
+    ..  versionadded:: 20.3.0 *value_serializer*
+    ..  versionadded:: 21.3.0 If a dict has a collection for a key, it is
+        serialized as a tuple.
+    """
+    attrs = fields(inst.__class__)
+    rv = dict_factory()
+    for a in attrs:
+        v = getattr(inst, a.name)
+        if filter is not None and not filter(a, v):
+            continue
+
+        if value_serializer is not None:
+            v = value_serializer(inst, a, v)
+
+        if recurse is True:
+            if has(v.__class__):
+                rv[a.name] = asdict(
+                    v,
+                    recurse=True,
+                    filter=filter,
+                    dict_factory=dict_factory,
+                    retain_collection_types=retain_collection_types,
+                    value_serializer=value_serializer,
+                )
+            elif isinstance(v, (tuple, list, set, frozenset)):
+                cf = v.__class__ if retain_collection_types is True else list
+                rv[a.name] = cf(
+                    [
+                        _asdict_anything(
+                            i,
+                            is_key=False,
+                            filter=filter,
+                            dict_factory=dict_factory,
+                            retain_collection_types=retain_collection_types,
+                            value_serializer=value_serializer,
+                        )
+                        for i in v
+                    ]
+                )
+            elif isinstance(v, dict):
+                df = dict_factory
+                rv[a.name] = df(
+                    (
+                        _asdict_anything(
+                            kk,
+                            is_key=True,
+                            filter=filter,
+                            dict_factory=df,
+                            retain_collection_types=retain_collection_types,
+                            value_serializer=value_serializer,
+                        ),
+                        _asdict_anything(
+                            vv,
+                            is_key=False,
+                            filter=filter,
+                            dict_factory=df,
+                            retain_collection_types=retain_collection_types,
+                            value_serializer=value_serializer,
+                        ),
+                    )
+                    for kk, vv in iteritems(v)
+                )
+            else:
+                rv[a.name] = v
+        else:
+            rv[a.name] = v
+    return rv
+
+
+def _asdict_anything(
+    val,
+    is_key,
+    filter,
+    dict_factory,
+    retain_collection_types,
+    value_serializer,
+):
+    """
+    ``asdict`` only works on attrs instances, this works on anything.
+    """
+    if getattr(val.__class__, "__attrs_attrs__", None) is not None:
+        # Attrs class.
+        rv = asdict(
+            val,
+            recurse=True,
+            filter=filter,
+            dict_factory=dict_factory,
+            retain_collection_types=retain_collection_types,
+            value_serializer=value_serializer,
+        )
+    elif isinstance(val, (tuple, list, set, frozenset)):
+        if retain_collection_types is True:
+            cf = val.__class__
+        elif is_key:
+            cf = tuple
+        else:
+            cf = list
+
+        rv = cf(
+            [
+                _asdict_anything(
+                    i,
+                    is_key=False,
+                    filter=filter,
+                    dict_factory=dict_factory,
+                    retain_collection_types=retain_collection_types,
+                    value_serializer=value_serializer,
+                )
+                for i in val
+            ]
+        )
+    elif isinstance(val, dict):
+        df = dict_factory
+        rv = df(
+            (
+                _asdict_anything(
+                    kk,
+                    is_key=True,
+                    filter=filter,
+                    dict_factory=df,
+                    retain_collection_types=retain_collection_types,
+                    value_serializer=value_serializer,
+                ),
+                _asdict_anything(
+                    vv,
+                    is_key=False,
+                    filter=filter,
+                    dict_factory=df,
+                    retain_collection_types=retain_collection_types,
+                    value_serializer=value_serializer,
+                ),
+            )
+            for kk, vv in iteritems(val)
+        )
+    else:
+        rv = val
+        if value_serializer is not None:
+            rv = value_serializer(None, None, rv)
+
+    return rv
+
+
+def astuple(
+    inst,
+    recurse=True,
+    filter=None,
+    tuple_factory=tuple,
+    retain_collection_types=False,
+):
+    """
+    Return the ``attrs`` attribute values of *inst* as a tuple.
+
+    Optionally recurse into other ``attrs``-decorated classes.
+
+    :param inst: Instance of an ``attrs``-decorated class.
+    :param bool recurse: Recurse into classes that are also
+        ``attrs``-decorated.
+    :param callable filter: A callable whose return code determines whether an
+        attribute or element is included (``True``) or dropped (``False``).  Is
+        called with the `attrs.Attribute` as the first argument and the
+        value as the second argument.
+    :param callable tuple_factory: A callable to produce tuples from.  For
+        example, to produce lists instead of tuples.
+    :param bool retain_collection_types: Do not convert to ``list``
+        or ``dict`` when encountering an attribute which type is
+        ``tuple``, ``dict`` or ``set``.  Only meaningful if ``recurse`` is
+        ``True``.
+
+    :rtype: return type of *tuple_factory*
+
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    ..  versionadded:: 16.2.0
+    """
+    attrs = fields(inst.__class__)
+    rv = []
+    retain = retain_collection_types  # Very long. :/
+    for a in attrs:
+        v = getattr(inst, a.name)
+        if filter is not None and not filter(a, v):
+            continue
+        if recurse is True:
+            if has(v.__class__):
+                rv.append(
+                    astuple(
+                        v,
+                        recurse=True,
+                        filter=filter,
+                        tuple_factory=tuple_factory,
+                        retain_collection_types=retain,
+                    )
+                )
+            elif isinstance(v, (tuple, list, set, frozenset)):
+                cf = v.__class__ if retain is True else list
+                rv.append(
+                    cf(
+                        [
+                            astuple(
+                                j,
+                                recurse=True,
+                                filter=filter,
+                                tuple_factory=tuple_factory,
+                                retain_collection_types=retain,
+                            )
+                            if has(j.__class__)
+                            else j
+                            for j in v
+                        ]
+                    )
+                )
+            elif isinstance(v, dict):
+                df = v.__class__ if retain is True else dict
+                rv.append(
+                    df(
+                        (
+                            astuple(
+                                kk,
+                                tuple_factory=tuple_factory,
+                                retain_collection_types=retain,
+                            )
+                            if has(kk.__class__)
+                            else kk,
+                            astuple(
+                                vv,
+                                tuple_factory=tuple_factory,
+                                retain_collection_types=retain,
+                            )
+                            if has(vv.__class__)
+                            else vv,
+                        )
+                        for kk, vv in iteritems(v)
+                    )
+                )
+            else:
+                rv.append(v)
+        else:
+            rv.append(v)
+
+    return rv if tuple_factory is list else tuple_factory(rv)
+
+
+def has(cls):
+    """
+    Check whether *cls* is a class with ``attrs`` attributes.
+
+    :param type cls: Class to introspect.
+    :raise TypeError: If *cls* is not a class.
+
+    :rtype: bool
+    """
+    return getattr(cls, "__attrs_attrs__", None) is not None
+
+
+def assoc(inst, **changes):
+    """
+    Copy *inst* and apply *changes*.
+
+    :param inst: Instance of a class with ``attrs`` attributes.
+    :param changes: Keyword changes in the new copy.
+
+    :return: A copy of inst with *changes* incorporated.
+
+    :raise attr.exceptions.AttrsAttributeNotFoundError: If *attr_name* couldn't
+        be found on *cls*.
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    ..  deprecated:: 17.1.0
+        Use `attrs.evolve` instead if you can.
+        This function will not be removed du to the slightly different approach
+        compared to `attrs.evolve`.
+    """
+    import warnings
+
+    warnings.warn(
+        "assoc is deprecated and will be removed after 2018/01.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    new = copy.copy(inst)
+    attrs = fields(inst.__class__)
+    for k, v in iteritems(changes):
+        a = getattr(attrs, k, NOTHING)
+        if a is NOTHING:
+            raise AttrsAttributeNotFoundError(
+                "{k} is not an attrs attribute on {cl}.".format(
+                    k=k, cl=new.__class__
+                )
+            )
+        _obj_setattr(new, k, v)
+    return new
+
+
+def evolve(inst, **changes):
+    """
+    Create a new instance, based on *inst* with *changes* applied.
+
+    :param inst: Instance of a class with ``attrs`` attributes.
+    :param changes: Keyword changes in the new copy.
+
+    :return: A copy of inst with *changes* incorporated.
+
+    :raise TypeError: If *attr_name* couldn't be found in the class
+        ``__init__``.
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    ..  versionadded:: 17.1.0
+    """
+    cls = inst.__class__
+    attrs = fields(cls)
+    for a in attrs:
+        if not a.init:
+            continue
+        attr_name = a.name  # To deal with private attributes.
+        init_name = attr_name if attr_name[0] != "_" else attr_name[1:]
+        if init_name not in changes:
+            changes[init_name] = getattr(inst, attr_name)
+
+    return cls(**changes)
+
+
+def resolve_types(cls, globalns=None, localns=None, attribs=None):
+    """
+    Resolve any strings and forward annotations in type annotations.
+
+    This is only required if you need concrete types in `Attribute`'s *type*
+    field. In other words, you don't need to resolve your types if you only
+    use them for static type checking.
+
+    With no arguments, names will be looked up in the module in which the class
+    was created. If this is not what you want, e.g. if the name only exists
+    inside a method, you may pass *globalns* or *localns* to specify other
+    dictionaries in which to look up these names. See the docs of
+    `typing.get_type_hints` for more details.
+
+    :param type cls: Class to resolve.
+    :param Optional[dict] globalns: Dictionary containing global variables.
+    :param Optional[dict] localns: Dictionary containing local variables.
+    :param Optional[list] attribs: List of attribs for the given class.
+        This is necessary when calling from inside a ``field_transformer``
+        since *cls* is not an ``attrs`` class yet.
+
+    :raise TypeError: If *cls* is not a class.
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class and you didn't pass any attribs.
+    :raise NameError: If types cannot be resolved because of missing variables.
+
+    :returns: *cls* so you can use this function also as a class decorator.
+        Please note that you have to apply it **after** `attrs.define`. That
+        means the decorator has to come in the line **before** `attrs.define`.
+
+    ..  versionadded:: 20.1.0
+    ..  versionadded:: 21.1.0 *attribs*
+
+    """
+    # Since calling get_type_hints is expensive we cache whether we've
+    # done it already.
+    if getattr(cls, "__attrs_types_resolved__", None) != cls:
+        import typing
+
+        hints = typing.get_type_hints(cls, globalns=globalns, localns=localns)
+        for field in fields(cls) if attribs is None else attribs:
+            if field.name in hints:
+                # Since fields have been frozen we must work around it.
+                _obj_setattr(field, "type", hints[field.name])
+        # We store the class we resolved so that subclasses know they haven't
+        # been resolved.
+        cls.__attrs_types_resolved__ = cls
+
+    # Return the class so you can use it as a decorator too.
+    return cls
diff --git a/myenv/lib/python3.9/site-packages/attr/_make.py b/myenv/lib/python3.9/site-packages/attr/_make.py
new file mode 100644
index 0000000..d46f8a3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/_make.py
@@ -0,0 +1,3173 @@
+# SPDX-License-Identifier: MIT
+
+from __future__ import absolute_import, division, print_function
+
+import copy
+import inspect
+import linecache
+import sys
+import warnings
+
+from operator import itemgetter
+
+# We need to import _compat itself in addition to the _compat members to avoid
+# having the thread-local in the globals here.
+from . import _compat, _config, setters
+from ._compat import (
+    HAS_F_STRINGS,
+    PY2,
+    PY310,
+    PYPY,
+    isclass,
+    iteritems,
+    metadata_proxy,
+    new_class,
+    ordered_dict,
+    set_closure_cell,
+)
+from .exceptions import (
+    DefaultAlreadySetError,
+    FrozenInstanceError,
+    NotAnAttrsClassError,
+    PythonTooOldError,
+    UnannotatedAttributeError,
+)
+
+
+if not PY2:
+    import typing
+
+
+# This is used at least twice, so cache it here.
+_obj_setattr = object.__setattr__
+_init_converter_pat = "__attr_converter_%s"
+_init_factory_pat = "__attr_factory_{}"
+_tuple_property_pat = (
+    "    {attr_name} = _attrs_property(_attrs_itemgetter({index}))"
+)
+_classvar_prefixes = (
+    "typing.ClassVar",
+    "t.ClassVar",
+    "ClassVar",
+    "typing_extensions.ClassVar",
+)
+# we don't use a double-underscore prefix because that triggers
+# name mangling when trying to create a slot for the field
+# (when slots=True)
+_hash_cache_field = "_attrs_cached_hash"
+
+_empty_metadata_singleton = metadata_proxy({})
+
+# Unique object for unequivocal getattr() defaults.
+_sentinel = object()
+
+_ng_default_on_setattr = setters.pipe(setters.convert, setters.validate)
+
+
+class _Nothing(object):
+    """
+    Sentinel class to indicate the lack of a value when ``None`` is ambiguous.
+
+    ``_Nothing`` is a singleton. There is only ever one of it.
+
+    .. versionchanged:: 21.1.0 ``bool(NOTHING)`` is now False.
+    """
+
+    _singleton = None
+
+    def __new__(cls):
+        if _Nothing._singleton is None:
+            _Nothing._singleton = super(_Nothing, cls).__new__(cls)
+        return _Nothing._singleton
+
+    def __repr__(self):
+        return "NOTHING"
+
+    def __bool__(self):
+        return False
+
+    def __len__(self):
+        return 0  # __bool__ for Python 2
+
+
+NOTHING = _Nothing()
+"""
+Sentinel to indicate the lack of a value when ``None`` is ambiguous.
+"""
+
+
+class _CacheHashWrapper(int):
+    """
+    An integer subclass that pickles / copies as None
+
+    This is used for non-slots classes with ``cache_hash=True``, to avoid
+    serializing a potentially (even likely) invalid hash value. Since ``None``
+    is the default value for uncalculated hashes, whenever this is copied,
+    the copy's value for the hash should automatically reset.
+
+    See GH #613 for more details.
+    """
+
+    if PY2:
+        # For some reason `type(None)` isn't callable in Python 2, but we don't
+        # actually need a constructor for None objects, we just need any
+        # available function that returns None.
+        def __reduce__(self, _none_constructor=getattr, _args=(0, "", None)):
+            return _none_constructor, _args
+
+    else:
+
+        def __reduce__(self, _none_constructor=type(None), _args=()):
+            return _none_constructor, _args
+
+
+def attrib(
+    default=NOTHING,
+    validator=None,
+    repr=True,
+    cmp=None,
+    hash=None,
+    init=True,
+    metadata=None,
+    type=None,
+    converter=None,
+    factory=None,
+    kw_only=False,
+    eq=None,
+    order=None,
+    on_setattr=None,
+):
+    """
+    Create a new attribute on a class.
+
+    ..  warning::
+
+        Does *not* do anything unless the class is also decorated with
+        `attr.s`!
+
+    :param default: A value that is used if an ``attrs``-generated ``__init__``
+        is used and no value is passed while instantiating or the attribute is
+        excluded using ``init=False``.
+
+        If the value is an instance of `attrs.Factory`, its callable will be
+        used to construct a new value (useful for mutable data types like lists
+        or dicts).
+
+        If a default is not set (or set manually to `attrs.NOTHING`), a value
+        *must* be supplied when instantiating; otherwise a `TypeError`
+        will be raised.
+
+        The default can also be set using decorator notation as shown below.
+
+    :type default: Any value
+
+    :param callable factory: Syntactic sugar for
+        ``default=attr.Factory(factory)``.
+
+    :param validator: `callable` that is called by ``attrs``-generated
+        ``__init__`` methods after the instance has been initialized.  They
+        receive the initialized instance, the :func:`~attrs.Attribute`, and the
+        passed value.
+
+        The return value is *not* inspected so the validator has to throw an
+        exception itself.
+
+        If a `list` is passed, its items are treated as validators and must
+        all pass.
+
+        Validators can be globally disabled and re-enabled using
+        `get_run_validators`.
+
+        The validator can also be set using decorator notation as shown below.
+
+    :type validator: `callable` or a `list` of `callable`\\ s.
+
+    :param repr: Include this attribute in the generated ``__repr__``
+        method. If ``True``, include the attribute; if ``False``, omit it. By
+        default, the built-in ``repr()`` function is used. To override how the
+        attribute value is formatted, pass a ``callable`` that takes a single
+        value and returns a string. Note that the resulting string is used
+        as-is, i.e. it will be used directly *instead* of calling ``repr()``
+        (the default).
+    :type repr: a `bool` or a `callable` to use a custom function.
+
+    :param eq: If ``True`` (default), include this attribute in the
+        generated ``__eq__`` and ``__ne__`` methods that check two instances
+        for equality. To override how the attribute value is compared,
+        pass a ``callable`` that takes a single value and returns the value
+        to be compared.
+    :type eq: a `bool` or a `callable`.
+
+    :param order: If ``True`` (default), include this attributes in the
+        generated ``__lt__``, ``__le__``, ``__gt__`` and ``__ge__`` methods.
+        To override how the attribute value is ordered,
+        pass a ``callable`` that takes a single value and returns the value
+        to be ordered.
+    :type order: a `bool` or a `callable`.
+
+    :param cmp: Setting *cmp* is equivalent to setting *eq* and *order* to the
+        same value. Must not be mixed with *eq* or *order*.
+    :type cmp: a `bool` or a `callable`.
+
+    :param Optional[bool] hash: Include this attribute in the generated
+        ``__hash__`` method.  If ``None`` (default), mirror *eq*'s value.  This
+        is the correct behavior according the Python spec.  Setting this value
+        to anything else than ``None`` is *discouraged*.
+    :param bool init: Include this attribute in the generated ``__init__``
+        method.  It is possible to set this to ``False`` and set a default
+        value.  In that case this attributed is unconditionally initialized
+        with the specified default value or factory.
+    :param callable converter: `callable` that is called by
+        ``attrs``-generated ``__init__`` methods to convert attribute's value
+        to the desired format.  It is given the passed-in value, and the
+        returned value will be used as the new value of the attribute.  The
+        value is converted before being passed to the validator, if any.
+    :param metadata: An arbitrary mapping, to be used by third-party
+        components.  See `extending_metadata`.
+    :param type: The type of the attribute.  In Python 3.6 or greater, the
+        preferred method to specify the type is using a variable annotation
+        (see `PEP 526 <https://www.python.org/dev/peps/pep-0526/>`_).
+        This argument is provided for backward compatibility.
+        Regardless of the approach used, the type will be stored on
+        ``Attribute.type``.
+
+        Please note that ``attrs`` doesn't do anything with this metadata by
+        itself. You can use it as part of your own code or for
+        `static type checking <types>`.
+    :param kw_only: Make this attribute keyword-only (Python 3+)
+        in the generated ``__init__`` (if ``init`` is ``False``, this
+        parameter is ignored).
+    :param on_setattr: Allows to overwrite the *on_setattr* setting from
+        `attr.s`. If left `None`, the *on_setattr* value from `attr.s` is used.
+        Set to `attrs.setters.NO_OP` to run **no** `setattr` hooks for this
+        attribute -- regardless of the setting in `attr.s`.
+    :type on_setattr: `callable`, or a list of callables, or `None`, or
+        `attrs.setters.NO_OP`
+
+    .. versionadded:: 15.2.0 *convert*
+    .. versionadded:: 16.3.0 *metadata*
+    .. versionchanged:: 17.1.0 *validator* can be a ``list`` now.
+    .. versionchanged:: 17.1.0
+       *hash* is ``None`` and therefore mirrors *eq* by default.
+    .. versionadded:: 17.3.0 *type*
+    .. deprecated:: 17.4.0 *convert*
+    .. versionadded:: 17.4.0 *converter* as a replacement for the deprecated
+       *convert* to achieve consistency with other noun-based arguments.
+    .. versionadded:: 18.1.0
+       ``factory=f`` is syntactic sugar for ``default=attr.Factory(f)``.
+    .. versionadded:: 18.2.0 *kw_only*
+    .. versionchanged:: 19.2.0 *convert* keyword argument removed.
+    .. versionchanged:: 19.2.0 *repr* also accepts a custom callable.
+    .. deprecated:: 19.2.0 *cmp* Removal on or after 2021-06-01.
+    .. versionadded:: 19.2.0 *eq* and *order*
+    .. versionadded:: 20.1.0 *on_setattr*
+    .. versionchanged:: 20.3.0 *kw_only* backported to Python 2
+    .. versionchanged:: 21.1.0
+       *eq*, *order*, and *cmp* also accept a custom callable
+    .. versionchanged:: 21.1.0 *cmp* undeprecated
+    """
+    eq, eq_key, order, order_key = _determine_attrib_eq_order(
+        cmp, eq, order, True
+    )
+
+    if hash is not None and hash is not True and hash is not False:
+        raise TypeError(
+            "Invalid value for hash.  Must be True, False, or None."
+        )
+
+    if factory is not None:
+        if default is not NOTHING:
+            raise ValueError(
+                "The `default` and `factory` arguments are mutually "
+                "exclusive."
+            )
+        if not callable(factory):
+            raise ValueError("The `factory` argument must be a callable.")
+        default = Factory(factory)
+
+    if metadata is None:
+        metadata = {}
+
+    # Apply syntactic sugar by auto-wrapping.
+    if isinstance(on_setattr, (list, tuple)):
+        on_setattr = setters.pipe(*on_setattr)
+
+    if validator and isinstance(validator, (list, tuple)):
+        validator = and_(*validator)
+
+    if converter and isinstance(converter, (list, tuple)):
+        converter = pipe(*converter)
+
+    return _CountingAttr(
+        default=default,
+        validator=validator,
+        repr=repr,
+        cmp=None,
+        hash=hash,
+        init=init,
+        converter=converter,
+        metadata=metadata,
+        type=type,
+        kw_only=kw_only,
+        eq=eq,
+        eq_key=eq_key,
+        order=order,
+        order_key=order_key,
+        on_setattr=on_setattr,
+    )
+
+
+def _compile_and_eval(script, globs, locs=None, filename=""):
+    """
+    "Exec" the script with the given global (globs) and local (locs) variables.
+    """
+    bytecode = compile(script, filename, "exec")
+    eval(bytecode, globs, locs)
+
+
+def _make_method(name, script, filename, globs=None):
+    """
+    Create the method with the script given and return the method object.
+    """
+    locs = {}
+    if globs is None:
+        globs = {}
+
+    # In order of debuggers like PDB being able to step through the code,
+    # we add a fake linecache entry.
+    count = 1
+    base_filename = filename
+    while True:
+        linecache_tuple = (
+            len(script),
+            None,
+            script.splitlines(True),
+            filename,
+        )
+        old_val = linecache.cache.setdefault(filename, linecache_tuple)
+        if old_val == linecache_tuple:
+            break
+        else:
+            filename = "{}-{}>".format(base_filename[:-1], count)
+            count += 1
+
+    _compile_and_eval(script, globs, locs, filename)
+
+    return locs[name]
+
+
+def _make_attr_tuple_class(cls_name, attr_names):
+    """
+    Create a tuple subclass to hold `Attribute`s for an `attrs` class.
+
+    The subclass is a bare tuple with properties for names.
+
+    class MyClassAttributes(tuple):
+        __slots__ = ()
+        x = property(itemgetter(0))
+    """
+    attr_class_name = "{}Attributes".format(cls_name)
+    attr_class_template = [
+        "class {}(tuple):".format(attr_class_name),
+        "    __slots__ = ()",
+    ]
+    if attr_names:
+        for i, attr_name in enumerate(attr_names):
+            attr_class_template.append(
+                _tuple_property_pat.format(index=i, attr_name=attr_name)
+            )
+    else:
+        attr_class_template.append("    pass")
+    globs = {"_attrs_itemgetter": itemgetter, "_attrs_property": property}
+    _compile_and_eval("\n".join(attr_class_template), globs)
+    return globs[attr_class_name]
+
+
+# Tuple class for extracted attributes from a class definition.
+# `base_attrs` is a subset of `attrs`.
+_Attributes = _make_attr_tuple_class(
+    "_Attributes",
+    [
+        # all attributes to build dunder methods for
+        "attrs",
+        # attributes that have been inherited
+        "base_attrs",
+        # map inherited attributes to their originating classes
+        "base_attrs_map",
+    ],
+)
+
+
+def _is_class_var(annot):
+    """
+    Check whether *annot* is a typing.ClassVar.
+
+    The string comparison hack is used to avoid evaluating all string
+    annotations which would put attrs-based classes at a performance
+    disadvantage compared to plain old classes.
+    """
+    annot = str(annot)
+
+    # Annotation can be quoted.
+    if annot.startswith(("'", '"')) and annot.endswith(("'", '"')):
+        annot = annot[1:-1]
+
+    return annot.startswith(_classvar_prefixes)
+
+
+def _has_own_attribute(cls, attrib_name):
+    """
+    Check whether *cls* defines *attrib_name* (and doesn't just inherit it).
+
+    Requires Python 3.
+    """
+    attr = getattr(cls, attrib_name, _sentinel)
+    if attr is _sentinel:
+        return False
+
+    for base_cls in cls.__mro__[1:]:
+        a = getattr(base_cls, attrib_name, None)
+        if attr is a:
+            return False
+
+    return True
+
+
+def _get_annotations(cls):
+    """
+    Get annotations for *cls*.
+    """
+    if _has_own_attribute(cls, "__annotations__"):
+        return cls.__annotations__
+
+    return {}
+
+
+def _counter_getter(e):
+    """
+    Key function for sorting to avoid re-creating a lambda for every class.
+    """
+    return e[1].counter
+
+
+def _collect_base_attrs(cls, taken_attr_names):
+    """
+    Collect attr.ibs from base classes of *cls*, except *taken_attr_names*.
+    """
+    base_attrs = []
+    base_attr_map = {}  # A dictionary of base attrs to their classes.
+
+    # Traverse the MRO and collect attributes.
+    for base_cls in reversed(cls.__mro__[1:-1]):
+        for a in getattr(base_cls, "__attrs_attrs__", []):
+            if a.inherited or a.name in taken_attr_names:
+                continue
+
+            a = a.evolve(inherited=True)
+            base_attrs.append(a)
+            base_attr_map[a.name] = base_cls
+
+    # For each name, only keep the freshest definition i.e. the furthest at the
+    # back.  base_attr_map is fine because it gets overwritten with every new
+    # instance.
+    filtered = []
+    seen = set()
+    for a in reversed(base_attrs):
+        if a.name in seen:
+            continue
+        filtered.insert(0, a)
+        seen.add(a.name)
+
+    return filtered, base_attr_map
+
+
+def _collect_base_attrs_broken(cls, taken_attr_names):
+    """
+    Collect attr.ibs from base classes of *cls*, except *taken_attr_names*.
+
+    N.B. *taken_attr_names* will be mutated.
+
+    Adhere to the old incorrect behavior.
+
+    Notably it collects from the front and considers inherited attributes which
+    leads to the buggy behavior reported in #428.
+    """
+    base_attrs = []
+    base_attr_map = {}  # A dictionary of base attrs to their classes.
+
+    # Traverse the MRO and collect attributes.
+    for base_cls in cls.__mro__[1:-1]:
+        for a in getattr(base_cls, "__attrs_attrs__", []):
+            if a.name in taken_attr_names:
+                continue
+
+            a = a.evolve(inherited=True)
+            taken_attr_names.add(a.name)
+            base_attrs.append(a)
+            base_attr_map[a.name] = base_cls
+
+    return base_attrs, base_attr_map
+
+
+def _transform_attrs(
+    cls, these, auto_attribs, kw_only, collect_by_mro, field_transformer
+):
+    """
+    Transform all `_CountingAttr`s on a class into `Attribute`s.
+
+    If *these* is passed, use that and don't look for them on the class.
+
+    *collect_by_mro* is True, collect them in the correct MRO order, otherwise
+    use the old -- incorrect -- order.  See #428.
+
+    Return an `_Attributes`.
+    """
+    cd = cls.__dict__
+    anns = _get_annotations(cls)
+
+    if these is not None:
+        ca_list = [(name, ca) for name, ca in iteritems(these)]
+
+        if not isinstance(these, ordered_dict):
+            ca_list.sort(key=_counter_getter)
+    elif auto_attribs is True:
+        ca_names = {
+            name
+            for name, attr in cd.items()
+            if isinstance(attr, _CountingAttr)
+        }
+        ca_list = []
+        annot_names = set()
+        for attr_name, type in anns.items():
+            if _is_class_var(type):
+                continue
+            annot_names.add(attr_name)
+            a = cd.get(attr_name, NOTHING)
+
+            if not isinstance(a, _CountingAttr):
+                if a is NOTHING:
+                    a = attrib()
+                else:
+                    a = attrib(default=a)
+            ca_list.append((attr_name, a))
+
+        unannotated = ca_names - annot_names
+        if len(unannotated) > 0:
+            raise UnannotatedAttributeError(
+                "The following `attr.ib`s lack a type annotation: "
+                + ", ".join(
+                    sorted(unannotated, key=lambda n: cd.get(n).counter)
+                )
+                + "."
+            )
+    else:
+        ca_list = sorted(
+            (
+                (name, attr)
+                for name, attr in cd.items()
+                if isinstance(attr, _CountingAttr)
+            ),
+            key=lambda e: e[1].counter,
+        )
+
+    own_attrs = [
+        Attribute.from_counting_attr(
+            name=attr_name, ca=ca, type=anns.get(attr_name)
+        )
+        for attr_name, ca in ca_list
+    ]
+
+    if collect_by_mro:
+        base_attrs, base_attr_map = _collect_base_attrs(
+            cls, {a.name for a in own_attrs}
+        )
+    else:
+        base_attrs, base_attr_map = _collect_base_attrs_broken(
+            cls, {a.name for a in own_attrs}
+        )
+
+    if kw_only:
+        own_attrs = [a.evolve(kw_only=True) for a in own_attrs]
+        base_attrs = [a.evolve(kw_only=True) for a in base_attrs]
+
+    attrs = base_attrs + own_attrs
+
+    # Mandatory vs non-mandatory attr order only matters when they are part of
+    # the __init__ signature and when they aren't kw_only (which are moved to
+    # the end and can be mandatory or non-mandatory in any order, as they will
+    # be specified as keyword args anyway). Check the order of those attrs:
+    had_default = False
+    for a in (a for a in attrs if a.init is not False and a.kw_only is False):
+        if had_default is True and a.default is NOTHING:
+            raise ValueError(
+                "No mandatory attributes allowed after an attribute with a "
+                "default value or factory.  Attribute in question: %r" % (a,)
+            )
+
+        if had_default is False and a.default is not NOTHING:
+            had_default = True
+
+    if field_transformer is not None:
+        attrs = field_transformer(cls, attrs)
+
+    # Create AttrsClass *after* applying the field_transformer since it may
+    # add or remove attributes!
+    attr_names = [a.name for a in attrs]
+    AttrsClass = _make_attr_tuple_class(cls.__name__, attr_names)
+
+    return _Attributes((AttrsClass(attrs), base_attrs, base_attr_map))
+
+
+if PYPY:
+
+    def _frozen_setattrs(self, name, value):
+        """
+        Attached to frozen classes as __setattr__.
+        """
+        if isinstance(self, BaseException) and name in (
+            "__cause__",
+            "__context__",
+        ):
+            BaseException.__setattr__(self, name, value)
+            return
+
+        raise FrozenInstanceError()
+
+else:
+
+    def _frozen_setattrs(self, name, value):
+        """
+        Attached to frozen classes as __setattr__.
+        """
+        raise FrozenInstanceError()
+
+
+def _frozen_delattrs(self, name):
+    """
+    Attached to frozen classes as __delattr__.
+    """
+    raise FrozenInstanceError()
+
+
+class _ClassBuilder(object):
+    """
+    Iteratively build *one* class.
+    """
+
+    __slots__ = (
+        "_attr_names",
+        "_attrs",
+        "_base_attr_map",
+        "_base_names",
+        "_cache_hash",
+        "_cls",
+        "_cls_dict",
+        "_delete_attribs",
+        "_frozen",
+        "_has_pre_init",
+        "_has_post_init",
+        "_is_exc",
+        "_on_setattr",
+        "_slots",
+        "_weakref_slot",
+        "_wrote_own_setattr",
+        "_has_custom_setattr",
+    )
+
+    def __init__(
+        self,
+        cls,
+        these,
+        slots,
+        frozen,
+        weakref_slot,
+        getstate_setstate,
+        auto_attribs,
+        kw_only,
+        cache_hash,
+        is_exc,
+        collect_by_mro,
+        on_setattr,
+        has_custom_setattr,
+        field_transformer,
+    ):
+        attrs, base_attrs, base_map = _transform_attrs(
+            cls,
+            these,
+            auto_attribs,
+            kw_only,
+            collect_by_mro,
+            field_transformer,
+        )
+
+        self._cls = cls
+        self._cls_dict = dict(cls.__dict__) if slots else {}
+        self._attrs = attrs
+        self._base_names = set(a.name for a in base_attrs)
+        self._base_attr_map = base_map
+        self._attr_names = tuple(a.name for a in attrs)
+        self._slots = slots
+        self._frozen = frozen
+        self._weakref_slot = weakref_slot
+        self._cache_hash = cache_hash
+        self._has_pre_init = bool(getattr(cls, "__attrs_pre_init__", False))
+        self._has_post_init = bool(getattr(cls, "__attrs_post_init__", False))
+        self._delete_attribs = not bool(these)
+        self._is_exc = is_exc
+        self._on_setattr = on_setattr
+
+        self._has_custom_setattr = has_custom_setattr
+        self._wrote_own_setattr = False
+
+        self._cls_dict["__attrs_attrs__"] = self._attrs
+
+        if frozen:
+            self._cls_dict["__setattr__"] = _frozen_setattrs
+            self._cls_dict["__delattr__"] = _frozen_delattrs
+
+            self._wrote_own_setattr = True
+        elif on_setattr in (
+            _ng_default_on_setattr,
+            setters.validate,
+            setters.convert,
+        ):
+            has_validator = has_converter = False
+            for a in attrs:
+                if a.validator is not None:
+                    has_validator = True
+                if a.converter is not None:
+                    has_converter = True
+
+                if has_validator and has_converter:
+                    break
+            if (
+                (
+                    on_setattr == _ng_default_on_setattr
+                    and not (has_validator or has_converter)
+                )
+                or (on_setattr == setters.validate and not has_validator)
+                or (on_setattr == setters.convert and not has_converter)
+            ):
+                # If class-level on_setattr is set to convert + validate, but
+                # there's no field to convert or validate, pretend like there's
+                # no on_setattr.
+                self._on_setattr = None
+
+        if getstate_setstate:
+            (
+                self._cls_dict["__getstate__"],
+                self._cls_dict["__setstate__"],
+            ) = self._make_getstate_setstate()
+
+    def __repr__(self):
+        return "<_ClassBuilder(cls={cls})>".format(cls=self._cls.__name__)
+
+    def build_class(self):
+        """
+        Finalize class based on the accumulated configuration.
+
+        Builder cannot be used after calling this method.
+        """
+        if self._slots is True:
+            return self._create_slots_class()
+        else:
+            return self._patch_original_class()
+
+    def _patch_original_class(self):
+        """
+        Apply accumulated methods and return the class.
+        """
+        cls = self._cls
+        base_names = self._base_names
+
+        # Clean class of attribute definitions (`attr.ib()`s).
+        if self._delete_attribs:
+            for name in self._attr_names:
+                if (
+                    name not in base_names
+                    and getattr(cls, name, _sentinel) is not _sentinel
+                ):
+                    try:
+                        delattr(cls, name)
+                    except AttributeError:
+                        # This can happen if a base class defines a class
+                        # variable and we want to set an attribute with the
+                        # same name by using only a type annotation.
+                        pass
+
+        # Attach our dunder methods.
+        for name, value in self._cls_dict.items():
+            setattr(cls, name, value)
+
+        # If we've inherited an attrs __setattr__ and don't write our own,
+        # reset it to object's.
+        if not self._wrote_own_setattr and getattr(
+            cls, "__attrs_own_setattr__", False
+        ):
+            cls.__attrs_own_setattr__ = False
+
+            if not self._has_custom_setattr:
+                cls.__setattr__ = object.__setattr__
+
+        return cls
+
+    def _create_slots_class(self):
+        """
+        Build and return a new class with a `__slots__` attribute.
+        """
+        cd = {
+            k: v
+            for k, v in iteritems(self._cls_dict)
+            if k not in tuple(self._attr_names) + ("__dict__", "__weakref__")
+        }
+
+        # If our class doesn't have its own implementation of __setattr__
+        # (either from the user or by us), check the bases, if one of them has
+        # an attrs-made __setattr__, that needs to be reset. We don't walk the
+        # MRO because we only care about our immediate base classes.
+        # XXX: This can be confused by subclassing a slotted attrs class with
+        # XXX: a non-attrs class and subclass the resulting class with an attrs
+        # XXX: class.  See `test_slotted_confused` for details.  For now that's
+        # XXX: OK with us.
+        if not self._wrote_own_setattr:
+            cd["__attrs_own_setattr__"] = False
+
+            if not self._has_custom_setattr:
+                for base_cls in self._cls.__bases__:
+                    if base_cls.__dict__.get("__attrs_own_setattr__", False):
+                        cd["__setattr__"] = object.__setattr__
+                        break
+
+        # Traverse the MRO to collect existing slots
+        # and check for an existing __weakref__.
+        existing_slots = dict()
+        weakref_inherited = False
+        for base_cls in self._cls.__mro__[1:-1]:
+            if base_cls.__dict__.get("__weakref__", None) is not None:
+                weakref_inherited = True
+            existing_slots.update(
+                {
+                    name: getattr(base_cls, name)
+                    for name in getattr(base_cls, "__slots__", [])
+                }
+            )
+
+        base_names = set(self._base_names)
+
+        names = self._attr_names
+        if (
+            self._weakref_slot
+            and "__weakref__" not in getattr(self._cls, "__slots__", ())
+            and "__weakref__" not in names
+            and not weakref_inherited
+        ):
+            names += ("__weakref__",)
+
+        # We only add the names of attributes that aren't inherited.
+        # Setting __slots__ to inherited attributes wastes memory.
+        slot_names = [name for name in names if name not in base_names]
+        # There are slots for attributes from current class
+        # that are defined in parent classes.
+        # As their descriptors may be overriden by a child class,
+        # we collect them here and update the class dict
+        reused_slots = {
+            slot: slot_descriptor
+            for slot, slot_descriptor in iteritems(existing_slots)
+            if slot in slot_names
+        }
+        slot_names = [name for name in slot_names if name not in reused_slots]
+        cd.update(reused_slots)
+        if self._cache_hash:
+            slot_names.append(_hash_cache_field)
+        cd["__slots__"] = tuple(slot_names)
+
+        qualname = getattr(self._cls, "__qualname__", None)
+        if qualname is not None:
+            cd["__qualname__"] = qualname
+
+        # Create new class based on old class and our methods.
+        cls = type(self._cls)(self._cls.__name__, self._cls.__bases__, cd)
+
+        # The following is a fix for
+        # <https://github.com/python-attrs/attrs/issues/102>.  On Python 3,
+        # if a method mentions `__class__` or uses the no-arg super(), the
+        # compiler will bake a reference to the class in the method itself
+        # as `method.__closure__`.  Since we replace the class with a
+        # clone, we rewrite these references so it keeps working.
+        for item in cls.__dict__.values():
+            if isinstance(item, (classmethod, staticmethod)):
+                # Class- and staticmethods hide their functions inside.
+                # These might need to be rewritten as well.
+                closure_cells = getattr(item.__func__, "__closure__", None)
+            elif isinstance(item, property):
+                # Workaround for property `super()` shortcut (PY3-only).
+                # There is no universal way for other descriptors.
+                closure_cells = getattr(item.fget, "__closure__", None)
+            else:
+                closure_cells = getattr(item, "__closure__", None)
+
+            if not closure_cells:  # Catch None or the empty list.
+                continue
+            for cell in closure_cells:
+                try:
+                    match = cell.cell_contents is self._cls
+                except ValueError:  # ValueError: Cell is empty
+                    pass
+                else:
+                    if match:
+                        set_closure_cell(cell, cls)
+
+        return cls
+
+    def add_repr(self, ns):
+        self._cls_dict["__repr__"] = self._add_method_dunders(
+            _make_repr(self._attrs, ns, self._cls)
+        )
+        return self
+
+    def add_str(self):
+        repr = self._cls_dict.get("__repr__")
+        if repr is None:
+            raise ValueError(
+                "__str__ can only be generated if a __repr__ exists."
+            )
+
+        def __str__(self):
+            return self.__repr__()
+
+        self._cls_dict["__str__"] = self._add_method_dunders(__str__)
+        return self
+
+    def _make_getstate_setstate(self):
+        """
+        Create custom __setstate__ and __getstate__ methods.
+        """
+        # __weakref__ is not writable.
+        state_attr_names = tuple(
+            an for an in self._attr_names if an != "__weakref__"
+        )
+
+        def slots_getstate(self):
+            """
+            Automatically created by attrs.
+            """
+            return tuple(getattr(self, name) for name in state_attr_names)
+
+        hash_caching_enabled = self._cache_hash
+
+        def slots_setstate(self, state):
+            """
+            Automatically created by attrs.
+            """
+            __bound_setattr = _obj_setattr.__get__(self, Attribute)
+            for name, value in zip(state_attr_names, state):
+                __bound_setattr(name, value)
+
+            # The hash code cache is not included when the object is
+            # serialized, but it still needs to be initialized to None to
+            # indicate that the first call to __hash__ should be a cache
+            # miss.
+            if hash_caching_enabled:
+                __bound_setattr(_hash_cache_field, None)
+
+        return slots_getstate, slots_setstate
+
+    def make_unhashable(self):
+        self._cls_dict["__hash__"] = None
+        return self
+
+    def add_hash(self):
+        self._cls_dict["__hash__"] = self._add_method_dunders(
+            _make_hash(
+                self._cls,
+                self._attrs,
+                frozen=self._frozen,
+                cache_hash=self._cache_hash,
+            )
+        )
+
+        return self
+
+    def add_init(self):
+        self._cls_dict["__init__"] = self._add_method_dunders(
+            _make_init(
+                self._cls,
+                self._attrs,
+                self._has_pre_init,
+                self._has_post_init,
+                self._frozen,
+                self._slots,
+                self._cache_hash,
+                self._base_attr_map,
+                self._is_exc,
+                self._on_setattr,
+                attrs_init=False,
+            )
+        )
+
+        return self
+
+    def add_match_args(self):
+        self._cls_dict["__match_args__"] = tuple(
+            field.name
+            for field in self._attrs
+            if field.init and not field.kw_only
+        )
+
+    def add_attrs_init(self):
+        self._cls_dict["__attrs_init__"] = self._add_method_dunders(
+            _make_init(
+                self._cls,
+                self._attrs,
+                self._has_pre_init,
+                self._has_post_init,
+                self._frozen,
+                self._slots,
+                self._cache_hash,
+                self._base_attr_map,
+                self._is_exc,
+                self._on_setattr,
+                attrs_init=True,
+            )
+        )
+
+        return self
+
+    def add_eq(self):
+        cd = self._cls_dict
+
+        cd["__eq__"] = self._add_method_dunders(
+            _make_eq(self._cls, self._attrs)
+        )
+        cd["__ne__"] = self._add_method_dunders(_make_ne())
+
+        return self
+
+    def add_order(self):
+        cd = self._cls_dict
+
+        cd["__lt__"], cd["__le__"], cd["__gt__"], cd["__ge__"] = (
+            self._add_method_dunders(meth)
+            for meth in _make_order(self._cls, self._attrs)
+        )
+
+        return self
+
+    def add_setattr(self):
+        if self._frozen:
+            return self
+
+        sa_attrs = {}
+        for a in self._attrs:
+            on_setattr = a.on_setattr or self._on_setattr
+            if on_setattr and on_setattr is not setters.NO_OP:
+                sa_attrs[a.name] = a, on_setattr
+
+        if not sa_attrs:
+            return self
+
+        if self._has_custom_setattr:
+            # We need to write a __setattr__ but there already is one!
+            raise ValueError(
+                "Can't combine custom __setattr__ with on_setattr hooks."
+            )
+
+        # docstring comes from _add_method_dunders
+        def __setattr__(self, name, val):
+            try:
+                a, hook = sa_attrs[name]
+            except KeyError:
+                nval = val
+            else:
+                nval = hook(self, a, val)
+
+            _obj_setattr(self, name, nval)
+
+        self._cls_dict["__attrs_own_setattr__"] = True
+        self._cls_dict["__setattr__"] = self._add_method_dunders(__setattr__)
+        self._wrote_own_setattr = True
+
+        return self
+
+    def _add_method_dunders(self, method):
+        """
+        Add __module__ and __qualname__ to a *method* if possible.
+        """
+        try:
+            method.__module__ = self._cls.__module__
+        except AttributeError:
+            pass
+
+        try:
+            method.__qualname__ = ".".join(
+                (self._cls.__qualname__, method.__name__)
+            )
+        except AttributeError:
+            pass
+
+        try:
+            method.__doc__ = "Method generated by attrs for class %s." % (
+                self._cls.__qualname__,
+            )
+        except AttributeError:
+            pass
+
+        return method
+
+
+_CMP_DEPRECATION = (
+    "The usage of `cmp` is deprecated and will be removed on or after "
+    "2021-06-01.  Please use `eq` and `order` instead."
+)
+
+
+def _determine_attrs_eq_order(cmp, eq, order, default_eq):
+    """
+    Validate the combination of *cmp*, *eq*, and *order*. Derive the effective
+    values of eq and order.  If *eq* is None, set it to *default_eq*.
+    """
+    if cmp is not None and any((eq is not None, order is not None)):
+        raise ValueError("Don't mix `cmp` with `eq' and `order`.")
+
+    # cmp takes precedence due to bw-compatibility.
+    if cmp is not None:
+        return cmp, cmp
+
+    # If left None, equality is set to the specified default and ordering
+    # mirrors equality.
+    if eq is None:
+        eq = default_eq
+
+    if order is None:
+        order = eq
+
+    if eq is False and order is True:
+        raise ValueError("`order` can only be True if `eq` is True too.")
+
+    return eq, order
+
+
+def _determine_attrib_eq_order(cmp, eq, order, default_eq):
+    """
+    Validate the combination of *cmp*, *eq*, and *order*. Derive the effective
+    values of eq and order.  If *eq* is None, set it to *default_eq*.
+    """
+    if cmp is not None and any((eq is not None, order is not None)):
+        raise ValueError("Don't mix `cmp` with `eq' and `order`.")
+
+    def decide_callable_or_boolean(value):
+        """
+        Decide whether a key function is used.
+        """
+        if callable(value):
+            value, key = True, value
+        else:
+            key = None
+        return value, key
+
+    # cmp takes precedence due to bw-compatibility.
+    if cmp is not None:
+        cmp, cmp_key = decide_callable_or_boolean(cmp)
+        return cmp, cmp_key, cmp, cmp_key
+
+    # If left None, equality is set to the specified default and ordering
+    # mirrors equality.
+    if eq is None:
+        eq, eq_key = default_eq, None
+    else:
+        eq, eq_key = decide_callable_or_boolean(eq)
+
+    if order is None:
+        order, order_key = eq, eq_key
+    else:
+        order, order_key = decide_callable_or_boolean(order)
+
+    if eq is False and order is True:
+        raise ValueError("`order` can only be True if `eq` is True too.")
+
+    return eq, eq_key, order, order_key
+
+
+def _determine_whether_to_implement(
+    cls, flag, auto_detect, dunders, default=True
+):
+    """
+    Check whether we should implement a set of methods for *cls*.
+
+    *flag* is the argument passed into @attr.s like 'init', *auto_detect* the
+    same as passed into @attr.s and *dunders* is a tuple of attribute names
+    whose presence signal that the user has implemented it themselves.
+
+    Return *default* if no reason for either for or against is found.
+
+    auto_detect must be False on Python 2.
+    """
+    if flag is True or flag is False:
+        return flag
+
+    if flag is None and auto_detect is False:
+        return default
+
+    # Logically, flag is None and auto_detect is True here.
+    for dunder in dunders:
+        if _has_own_attribute(cls, dunder):
+            return False
+
+    return default
+
+
+def attrs(
+    maybe_cls=None,
+    these=None,
+    repr_ns=None,
+    repr=None,
+    cmp=None,
+    hash=None,
+    init=None,
+    slots=False,
+    frozen=False,
+    weakref_slot=True,
+    str=False,
+    auto_attribs=False,
+    kw_only=False,
+    cache_hash=False,
+    auto_exc=False,
+    eq=None,
+    order=None,
+    auto_detect=False,
+    collect_by_mro=False,
+    getstate_setstate=None,
+    on_setattr=None,
+    field_transformer=None,
+    match_args=True,
+):
+    r"""
+    A class decorator that adds `dunder
+    <https://wiki.python.org/moin/DunderAlias>`_\ -methods according to the
+    specified attributes using `attr.ib` or the *these* argument.
+
+    :param these: A dictionary of name to `attr.ib` mappings.  This is
+        useful to avoid the definition of your attributes within the class body
+        because you can't (e.g. if you want to add ``__repr__`` methods to
+        Django models) or don't want to.
+
+        If *these* is not ``None``, ``attrs`` will *not* search the class body
+        for attributes and will *not* remove any attributes from it.
+
+        If *these* is an ordered dict (`dict` on Python 3.6+,
+        `collections.OrderedDict` otherwise), the order is deduced from
+        the order of the attributes inside *these*.  Otherwise the order
+        of the definition of the attributes is used.
+
+    :type these: `dict` of `str` to `attr.ib`
+
+    :param str repr_ns: When using nested classes, there's no way in Python 2
+        to automatically detect that.  Therefore it's possible to set the
+        namespace explicitly for a more meaningful ``repr`` output.
+    :param bool auto_detect: Instead of setting the *init*, *repr*, *eq*,
+        *order*, and *hash* arguments explicitly, assume they are set to
+        ``True`` **unless any** of the involved methods for one of the
+        arguments is implemented in the *current* class (i.e. it is *not*
+        inherited from some base class).
+
+        So for example by implementing ``__eq__`` on a class yourself,
+        ``attrs`` will deduce ``eq=False`` and will create *neither*
+        ``__eq__`` *nor* ``__ne__`` (but Python classes come with a sensible
+        ``__ne__`` by default, so it *should* be enough to only implement
+        ``__eq__`` in most cases).
+
+        .. warning::
+
+           If you prevent ``attrs`` from creating the ordering methods for you
+           (``order=False``, e.g. by implementing ``__le__``), it becomes
+           *your* responsibility to make sure its ordering is sound. The best
+           way is to use the `functools.total_ordering` decorator.
+
+
+        Passing ``True`` or ``False`` to *init*, *repr*, *eq*, *order*,
+        *cmp*, or *hash* overrides whatever *auto_detect* would determine.
+
+        *auto_detect* requires Python 3. Setting it ``True`` on Python 2 raises
+        an `attrs.exceptions.PythonTooOldError`.
+
+    :param bool repr: Create a ``__repr__`` method with a human readable
+        representation of ``attrs`` attributes..
+    :param bool str: Create a ``__str__`` method that is identical to
+        ``__repr__``.  This is usually not necessary except for
+        `Exception`\ s.
+    :param Optional[bool] eq: If ``True`` or ``None`` (default), add ``__eq__``
+        and ``__ne__`` methods that check two instances for equality.
+
+        They compare the instances as if they were tuples of their ``attrs``
+        attributes if and only if the types of both classes are *identical*!
+    :param Optional[bool] order: If ``True``, add ``__lt__``, ``__le__``,
+        ``__gt__``, and ``__ge__`` methods that behave like *eq* above and
+        allow instances to be ordered. If ``None`` (default) mirror value of
+        *eq*.
+    :param Optional[bool] cmp: Setting *cmp* is equivalent to setting *eq*
+        and *order* to the same value. Must not be mixed with *eq* or *order*.
+    :param Optional[bool] hash: If ``None`` (default), the ``__hash__`` method
+        is generated according how *eq* and *frozen* are set.
+
+        1. If *both* are True, ``attrs`` will generate a ``__hash__`` for you.
+        2. If *eq* is True and *frozen* is False, ``__hash__`` will be set to
+           None, marking it unhashable (which it is).
+        3. If *eq* is False, ``__hash__`` will be left untouched meaning the
+           ``__hash__`` method of the base class will be used (if base class is
+           ``object``, this means it will fall back to id-based hashing.).
+
+        Although not recommended, you can decide for yourself and force
+        ``attrs`` to create one (e.g. if the class is immutable even though you
+        didn't freeze it programmatically) by passing ``True`` or not.  Both of
+        these cases are rather special and should be used carefully.
+
+        See our documentation on `hashing`, Python's documentation on
+        `object.__hash__`, and the `GitHub issue that led to the default \
+        behavior <https://github.com/python-attrs/attrs/issues/136>`_ for more
+        details.
+    :param bool init: Create a ``__init__`` method that initializes the
+        ``attrs`` attributes. Leading underscores are stripped for the argument
+        name. If a ``__attrs_pre_init__`` method exists on the class, it will
+        be called before the class is initialized. If a ``__attrs_post_init__``
+        method exists on the class, it will be called after the class is fully
+        initialized.
+
+        If ``init`` is ``False``, an ``__attrs_init__`` method will be
+        injected instead. This allows you to define a custom ``__init__``
+        method that can do pre-init work such as ``super().__init__()``,
+        and then call ``__attrs_init__()`` and ``__attrs_post_init__()``.
+    :param bool slots: Create a `slotted class <slotted classes>` that's more
+        memory-efficient. Slotted classes are generally superior to the default
+        dict classes, but have some gotchas you should know about, so we
+        encourage you to read the `glossary entry <slotted classes>`.
+    :param bool frozen: Make instances immutable after initialization.  If
+        someone attempts to modify a frozen instance,
+        `attr.exceptions.FrozenInstanceError` is raised.
+
+        .. note::
+
+            1. This is achieved by installing a custom ``__setattr__`` method
+               on your class, so you can't implement your own.
+
+            2. True immutability is impossible in Python.
+
+            3. This *does* have a minor a runtime performance `impact
+               <how-frozen>` when initializing new instances.  In other words:
+               ``__init__`` is slightly slower with ``frozen=True``.
+
+            4. If a class is frozen, you cannot modify ``self`` in
+               ``__attrs_post_init__`` or a self-written ``__init__``. You can
+               circumvent that limitation by using
+               ``object.__setattr__(self, "attribute_name", value)``.
+
+            5. Subclasses of a frozen class are frozen too.
+
+    :param bool weakref_slot: Make instances weak-referenceable.  This has no
+        effect unless ``slots`` is also enabled.
+    :param bool auto_attribs: If ``True``, collect `PEP 526`_-annotated
+        attributes (Python 3.6 and later only) from the class body.
+
+        In this case, you **must** annotate every field.  If ``attrs``
+        encounters a field that is set to an `attr.ib` but lacks a type
+        annotation, an `attr.exceptions.UnannotatedAttributeError` is
+        raised.  Use ``field_name: typing.Any = attr.ib(...)`` if you don't
+        want to set a type.
+
+        If you assign a value to those attributes (e.g. ``x: int = 42``), that
+        value becomes the default value like if it were passed using
+        ``attr.ib(default=42)``.  Passing an instance of `attrs.Factory` also
+        works as expected in most cases (see warning below).
+
+        Attributes annotated as `typing.ClassVar`, and attributes that are
+        neither annotated nor set to an `attr.ib` are **ignored**.
+
+        .. warning::
+           For features that use the attribute name to create decorators (e.g.
+           `validators <validators>`), you still *must* assign `attr.ib` to
+           them. Otherwise Python will either not find the name or try to use
+           the default value to call e.g. ``validator`` on it.
+
+           These errors can be quite confusing and probably the most common bug
+           report on our bug tracker.
+
+        .. _`PEP 526`: https://www.python.org/dev/peps/pep-0526/
+    :param bool kw_only: Make all attributes keyword-only (Python 3+)
+        in the generated ``__init__`` (if ``init`` is ``False``, this
+        parameter is ignored).
+    :param bool cache_hash: Ensure that the object's hash code is computed
+        only once and stored on the object.  If this is set to ``True``,
+        hashing must be either explicitly or implicitly enabled for this
+        class.  If the hash code is cached, avoid any reassignments of
+        fields involved in hash code computation or mutations of the objects
+        those fields point to after object creation.  If such changes occur,
+        the behavior of the object's hash code is undefined.
+    :param bool auto_exc: If the class subclasses `BaseException`
+        (which implicitly includes any subclass of any exception), the
+        following happens to behave like a well-behaved Python exceptions
+        class:
+
+        - the values for *eq*, *order*, and *hash* are ignored and the
+          instances compare and hash by the instance's ids (N.B. ``attrs`` will
+          *not* remove existing implementations of ``__hash__`` or the equality
+          methods. It just won't add own ones.),
+        - all attributes that are either passed into ``__init__`` or have a
+          default value are additionally available as a tuple in the ``args``
+          attribute,
+        - the value of *str* is ignored leaving ``__str__`` to base classes.
+    :param bool collect_by_mro: Setting this to `True` fixes the way ``attrs``
+       collects attributes from base classes.  The default behavior is
+       incorrect in certain cases of multiple inheritance.  It should be on by
+       default but is kept off for backward-compatibility.
+
+       See issue `#428 <https://github.com/python-attrs/attrs/issues/428>`_ for
+       more details.
+
+    :param Optional[bool] getstate_setstate:
+       .. note::
+          This is usually only interesting for slotted classes and you should
+          probably just set *auto_detect* to `True`.
+
+       If `True`, ``__getstate__`` and
+       ``__setstate__`` are generated and attached to the class. This is
+       necessary for slotted classes to be pickleable. If left `None`, it's
+       `True` by default for slotted classes and ``False`` for dict classes.
+
+       If *auto_detect* is `True`, and *getstate_setstate* is left `None`,
+       and **either** ``__getstate__`` or ``__setstate__`` is detected directly
+       on the class (i.e. not inherited), it is set to `False` (this is usually
+       what you want).
+
+    :param on_setattr: A callable that is run whenever the user attempts to set
+        an attribute (either by assignment like ``i.x = 42`` or by using
+        `setattr` like ``setattr(i, "x", 42)``). It receives the same arguments
+        as validators: the instance, the attribute that is being modified, and
+        the new value.
+
+        If no exception is raised, the attribute is set to the return value of
+        the callable.
+
+        If a list of callables is passed, they're automatically wrapped in an
+        `attrs.setters.pipe`.
+
+    :param Optional[callable] field_transformer:
+        A function that is called with the original class object and all
+        fields right before ``attrs`` finalizes the class.  You can use
+        this, e.g., to automatically add converters or validators to
+        fields based on their types.  See `transform-fields` for more details.
+
+    :param bool match_args:
+        If `True` (default), set ``__match_args__`` on the class to support
+        `PEP 634 <https://www.python.org/dev/peps/pep-0634/>`_ (Structural
+        Pattern Matching). It is a tuple of all positional-only ``__init__``
+        parameter names on Python 3.10 and later. Ignored on older Python
+        versions.
+
+    .. versionadded:: 16.0.0 *slots*
+    .. versionadded:: 16.1.0 *frozen*
+    .. versionadded:: 16.3.0 *str*
+    .. versionadded:: 16.3.0 Support for ``__attrs_post_init__``.
+    .. versionchanged:: 17.1.0
+       *hash* supports ``None`` as value which is also the default now.
+    .. versionadded:: 17.3.0 *auto_attribs*
+    .. versionchanged:: 18.1.0
+       If *these* is passed, no attributes are deleted from the class body.
+    .. versionchanged:: 18.1.0 If *these* is ordered, the order is retained.
+    .. versionadded:: 18.2.0 *weakref_slot*
+    .. deprecated:: 18.2.0
+       ``__lt__``, ``__le__``, ``__gt__``, and ``__ge__`` now raise a
+       `DeprecationWarning` if the classes compared are subclasses of
+       each other. ``__eq`` and ``__ne__`` never tried to compared subclasses
+       to each other.
+    .. versionchanged:: 19.2.0
+       ``__lt__``, ``__le__``, ``__gt__``, and ``__ge__`` now do not consider
+       subclasses comparable anymore.
+    .. versionadded:: 18.2.0 *kw_only*
+    .. versionadded:: 18.2.0 *cache_hash*
+    .. versionadded:: 19.1.0 *auto_exc*
+    .. deprecated:: 19.2.0 *cmp* Removal on or after 2021-06-01.
+    .. versionadded:: 19.2.0 *eq* and *order*
+    .. versionadded:: 20.1.0 *auto_detect*
+    .. versionadded:: 20.1.0 *collect_by_mro*
+    .. versionadded:: 20.1.0 *getstate_setstate*
+    .. versionadded:: 20.1.0 *on_setattr*
+    .. versionadded:: 20.3.0 *field_transformer*
+    .. versionchanged:: 21.1.0
+       ``init=False`` injects ``__attrs_init__``
+    .. versionchanged:: 21.1.0 Support for ``__attrs_pre_init__``
+    .. versionchanged:: 21.1.0 *cmp* undeprecated
+    .. versionadded:: 21.3.0 *match_args*
+    """
+    if auto_detect and PY2:
+        raise PythonTooOldError(
+            "auto_detect only works on Python 3 and later."
+        )
+
+    eq_, order_ = _determine_attrs_eq_order(cmp, eq, order, None)
+    hash_ = hash  # work around the lack of nonlocal
+
+    if isinstance(on_setattr, (list, tuple)):
+        on_setattr = setters.pipe(*on_setattr)
+
+    def wrap(cls):
+
+        if getattr(cls, "__class__", None) is None:
+            raise TypeError("attrs only works with new-style classes.")
+
+        is_frozen = frozen or _has_frozen_base_class(cls)
+        is_exc = auto_exc is True and issubclass(cls, BaseException)
+        has_own_setattr = auto_detect and _has_own_attribute(
+            cls, "__setattr__"
+        )
+
+        if has_own_setattr and is_frozen:
+            raise ValueError("Can't freeze a class with a custom __setattr__.")
+
+        builder = _ClassBuilder(
+            cls,
+            these,
+            slots,
+            is_frozen,
+            weakref_slot,
+            _determine_whether_to_implement(
+                cls,
+                getstate_setstate,
+                auto_detect,
+                ("__getstate__", "__setstate__"),
+                default=slots,
+            ),
+            auto_attribs,
+            kw_only,
+            cache_hash,
+            is_exc,
+            collect_by_mro,
+            on_setattr,
+            has_own_setattr,
+            field_transformer,
+        )
+        if _determine_whether_to_implement(
+            cls, repr, auto_detect, ("__repr__",)
+        ):
+            builder.add_repr(repr_ns)
+        if str is True:
+            builder.add_str()
+
+        eq = _determine_whether_to_implement(
+            cls, eq_, auto_detect, ("__eq__", "__ne__")
+        )
+        if not is_exc and eq is True:
+            builder.add_eq()
+        if not is_exc and _determine_whether_to_implement(
+            cls, order_, auto_detect, ("__lt__", "__le__", "__gt__", "__ge__")
+        ):
+            builder.add_order()
+
+        builder.add_setattr()
+
+        if (
+            hash_ is None
+            and auto_detect is True
+            and _has_own_attribute(cls, "__hash__")
+        ):
+            hash = False
+        else:
+            hash = hash_
+        if hash is not True and hash is not False and hash is not None:
+            # Can't use `hash in` because 1 == True for example.
+            raise TypeError(
+                "Invalid value for hash.  Must be True, False, or None."
+            )
+        elif hash is False or (hash is None and eq is False) or is_exc:
+            # Don't do anything. Should fall back to __object__'s __hash__
+            # which is by id.
+            if cache_hash:
+                raise TypeError(
+                    "Invalid value for cache_hash.  To use hash caching,"
+                    " hashing must be either explicitly or implicitly "
+                    "enabled."
+                )
+        elif hash is True or (
+            hash is None and eq is True and is_frozen is True
+        ):
+            # Build a __hash__ if told so, or if it's safe.
+            builder.add_hash()
+        else:
+            # Raise TypeError on attempts to hash.
+            if cache_hash:
+                raise TypeError(
+                    "Invalid value for cache_hash.  To use hash caching,"
+                    " hashing must be either explicitly or implicitly "
+                    "enabled."
+                )
+            builder.make_unhashable()
+
+        if _determine_whether_to_implement(
+            cls, init, auto_detect, ("__init__",)
+        ):
+            builder.add_init()
+        else:
+            builder.add_attrs_init()
+            if cache_hash:
+                raise TypeError(
+                    "Invalid value for cache_hash.  To use hash caching,"
+                    " init must be True."
+                )
+
+        if (
+            PY310
+            and match_args
+            and not _has_own_attribute(cls, "__match_args__")
+        ):
+            builder.add_match_args()
+
+        return builder.build_class()
+
+    # maybe_cls's type depends on the usage of the decorator.  It's a class
+    # if it's used as `@attrs` but ``None`` if used as `@attrs()`.
+    if maybe_cls is None:
+        return wrap
+    else:
+        return wrap(maybe_cls)
+
+
+_attrs = attrs
+"""
+Internal alias so we can use it in functions that take an argument called
+*attrs*.
+"""
+
+
+if PY2:
+
+    def _has_frozen_base_class(cls):
+        """
+        Check whether *cls* has a frozen ancestor by looking at its
+        __setattr__.
+        """
+        return (
+            getattr(cls.__setattr__, "__module__", None)
+            == _frozen_setattrs.__module__
+            and cls.__setattr__.__name__ == _frozen_setattrs.__name__
+        )
+
+else:
+
+    def _has_frozen_base_class(cls):
+        """
+        Check whether *cls* has a frozen ancestor by looking at its
+        __setattr__.
+        """
+        return cls.__setattr__ == _frozen_setattrs
+
+
+def _generate_unique_filename(cls, func_name):
+    """
+    Create a "filename" suitable for a function being generated.
+    """
+    unique_filename = "<attrs generated {0} {1}.{2}>".format(
+        func_name,
+        cls.__module__,
+        getattr(cls, "__qualname__", cls.__name__),
+    )
+    return unique_filename
+
+
+def _make_hash(cls, attrs, frozen, cache_hash):
+    attrs = tuple(
+        a for a in attrs if a.hash is True or (a.hash is None and a.eq is True)
+    )
+
+    tab = "        "
+
+    unique_filename = _generate_unique_filename(cls, "hash")
+    type_hash = hash(unique_filename)
+
+    hash_def = "def __hash__(self"
+    hash_func = "hash(("
+    closing_braces = "))"
+    if not cache_hash:
+        hash_def += "):"
+    else:
+        if not PY2:
+            hash_def += ", *"
+
+        hash_def += (
+            ", _cache_wrapper="
+            + "__import__('attr._make')._make._CacheHashWrapper):"
+        )
+        hash_func = "_cache_wrapper(" + hash_func
+        closing_braces += ")"
+
+    method_lines = [hash_def]
+
+    def append_hash_computation_lines(prefix, indent):
+        """
+        Generate the code for actually computing the hash code.
+        Below this will either be returned directly or used to compute
+        a value which is then cached, depending on the value of cache_hash
+        """
+
+        method_lines.extend(
+            [
+                indent + prefix + hash_func,
+                indent + "        %d," % (type_hash,),
+            ]
+        )
+
+        for a in attrs:
+            method_lines.append(indent + "        self.%s," % a.name)
+
+        method_lines.append(indent + "    " + closing_braces)
+
+    if cache_hash:
+        method_lines.append(tab + "if self.%s is None:" % _hash_cache_field)
+        if frozen:
+            append_hash_computation_lines(
+                "object.__setattr__(self, '%s', " % _hash_cache_field, tab * 2
+            )
+            method_lines.append(tab * 2 + ")")  # close __setattr__
+        else:
+            append_hash_computation_lines(
+                "self.%s = " % _hash_cache_field, tab * 2
+            )
+        method_lines.append(tab + "return self.%s" % _hash_cache_field)
+    else:
+        append_hash_computation_lines("return ", tab)
+
+    script = "\n".join(method_lines)
+    return _make_method("__hash__", script, unique_filename)
+
+
+def _add_hash(cls, attrs):
+    """
+    Add a hash method to *cls*.
+    """
+    cls.__hash__ = _make_hash(cls, attrs, frozen=False, cache_hash=False)
+    return cls
+
+
+def _make_ne():
+    """
+    Create __ne__ method.
+    """
+
+    def __ne__(self, other):
+        """
+        Check equality and either forward a NotImplemented or
+        return the result negated.
+        """
+        result = self.__eq__(other)
+        if result is NotImplemented:
+            return NotImplemented
+
+        return not result
+
+    return __ne__
+
+
+def _make_eq(cls, attrs):
+    """
+    Create __eq__ method for *cls* with *attrs*.
+    """
+    attrs = [a for a in attrs if a.eq]
+
+    unique_filename = _generate_unique_filename(cls, "eq")
+    lines = [
+        "def __eq__(self, other):",
+        "    if other.__class__ is not self.__class__:",
+        "        return NotImplemented",
+    ]
+
+    # We can't just do a big self.x = other.x and... clause due to
+    # irregularities like nan == nan is false but (nan,) == (nan,) is true.
+    globs = {}
+    if attrs:
+        lines.append("    return  (")
+        others = ["    ) == ("]
+        for a in attrs:
+            if a.eq_key:
+                cmp_name = "_%s_key" % (a.name,)
+                # Add the key function to the global namespace
+                # of the evaluated function.
+                globs[cmp_name] = a.eq_key
+                lines.append(
+                    "        %s(self.%s),"
+                    % (
+                        cmp_name,
+                        a.name,
+                    )
+                )
+                others.append(
+                    "        %s(other.%s),"
+                    % (
+                        cmp_name,
+                        a.name,
+                    )
+                )
+            else:
+                lines.append("        self.%s," % (a.name,))
+                others.append("        other.%s," % (a.name,))
+
+        lines += others + ["    )"]
+    else:
+        lines.append("    return True")
+
+    script = "\n".join(lines)
+
+    return _make_method("__eq__", script, unique_filename, globs)
+
+
+def _make_order(cls, attrs):
+    """
+    Create ordering methods for *cls* with *attrs*.
+    """
+    attrs = [a for a in attrs if a.order]
+
+    def attrs_to_tuple(obj):
+        """
+        Save us some typing.
+        """
+        return tuple(
+            key(value) if key else value
+            for value, key in (
+                (getattr(obj, a.name), a.order_key) for a in attrs
+            )
+        )
+
+    def __lt__(self, other):
+        """
+        Automatically created by attrs.
+        """
+        if other.__class__ is self.__class__:
+            return attrs_to_tuple(self) < attrs_to_tuple(other)
+
+        return NotImplemented
+
+    def __le__(self, other):
+        """
+        Automatically created by attrs.
+        """
+        if other.__class__ is self.__class__:
+            return attrs_to_tuple(self) <= attrs_to_tuple(other)
+
+        return NotImplemented
+
+    def __gt__(self, other):
+        """
+        Automatically created by attrs.
+        """
+        if other.__class__ is self.__class__:
+            return attrs_to_tuple(self) > attrs_to_tuple(other)
+
+        return NotImplemented
+
+    def __ge__(self, other):
+        """
+        Automatically created by attrs.
+        """
+        if other.__class__ is self.__class__:
+            return attrs_to_tuple(self) >= attrs_to_tuple(other)
+
+        return NotImplemented
+
+    return __lt__, __le__, __gt__, __ge__
+
+
+def _add_eq(cls, attrs=None):
+    """
+    Add equality methods to *cls* with *attrs*.
+    """
+    if attrs is None:
+        attrs = cls.__attrs_attrs__
+
+    cls.__eq__ = _make_eq(cls, attrs)
+    cls.__ne__ = _make_ne()
+
+    return cls
+
+
+if HAS_F_STRINGS:
+
+    def _make_repr(attrs, ns, cls):
+        unique_filename = _generate_unique_filename(cls, "repr")
+        # Figure out which attributes to include, and which function to use to
+        # format them. The a.repr value can be either bool or a custom
+        # callable.
+        attr_names_with_reprs = tuple(
+            (a.name, (repr if a.repr is True else a.repr), a.init)
+            for a in attrs
+            if a.repr is not False
+        )
+        globs = {
+            name + "_repr": r
+            for name, r, _ in attr_names_with_reprs
+            if r != repr
+        }
+        globs["_compat"] = _compat
+        globs["AttributeError"] = AttributeError
+        globs["NOTHING"] = NOTHING
+        attribute_fragments = []
+        for name, r, i in attr_names_with_reprs:
+            accessor = (
+                "self." + name
+                if i
+                else 'getattr(self, "' + name + '", NOTHING)'
+            )
+            fragment = (
+                "%s={%s!r}" % (name, accessor)
+                if r == repr
+                else "%s={%s_repr(%s)}" % (name, name, accessor)
+            )
+            attribute_fragments.append(fragment)
+        repr_fragment = ", ".join(attribute_fragments)
+
+        if ns is None:
+            cls_name_fragment = (
+                '{self.__class__.__qualname__.rsplit(">.", 1)[-1]}'
+            )
+        else:
+            cls_name_fragment = ns + ".{self.__class__.__name__}"
+
+        lines = [
+            "def __repr__(self):",
+            "  try:",
+            "    already_repring = _compat.repr_context.already_repring",
+            "  except AttributeError:",
+            "    already_repring = {id(self),}",
+            "    _compat.repr_context.already_repring = already_repring",
+            "  else:",
+            "    if id(self) in already_repring:",
+            "      return '...'",
+            "    else:",
+            "      already_repring.add(id(self))",
+            "  try:",
+            "    return f'%s(%s)'" % (cls_name_fragment, repr_fragment),
+            "  finally:",
+            "    already_repring.remove(id(self))",
+        ]
+
+        return _make_method(
+            "__repr__", "\n".join(lines), unique_filename, globs=globs
+        )
+
+else:
+
+    def _make_repr(attrs, ns, _):
+        """
+        Make a repr method that includes relevant *attrs*, adding *ns* to the
+        full name.
+        """
+
+        # Figure out which attributes to include, and which function to use to
+        # format them. The a.repr value can be either bool or a custom
+        # callable.
+        attr_names_with_reprs = tuple(
+            (a.name, repr if a.repr is True else a.repr)
+            for a in attrs
+            if a.repr is not False
+        )
+
+        def __repr__(self):
+            """
+            Automatically created by attrs.
+            """
+            try:
+                already_repring = _compat.repr_context.already_repring
+            except AttributeError:
+                already_repring = set()
+                _compat.repr_context.already_repring = already_repring
+
+            if id(self) in already_repring:
+                return "..."
+            real_cls = self.__class__
+            if ns is None:
+                qualname = getattr(real_cls, "__qualname__", None)
+                if qualname is not None:  # pragma: no cover
+                    # This case only happens on Python 3.5 and 3.6. We exclude
+                    # it from coverage, because we don't want to slow down our
+                    # test suite by running them under coverage too for this
+                    # one line.
+                    class_name = qualname.rsplit(">.", 1)[-1]
+                else:
+                    class_name = real_cls.__name__
+            else:
+                class_name = ns + "." + real_cls.__name__
+
+            # Since 'self' remains on the stack (i.e.: strongly referenced)
+            # for the duration of this call, it's safe to depend on id(...)
+            # stability, and not need to track the instance and therefore
+            # worry about properties like weakref- or hash-ability.
+            already_repring.add(id(self))
+            try:
+                result = [class_name, "("]
+                first = True
+                for name, attr_repr in attr_names_with_reprs:
+                    if first:
+                        first = False
+                    else:
+                        result.append(", ")
+                    result.extend(
+                        (name, "=", attr_repr(getattr(self, name, NOTHING)))
+                    )
+                return "".join(result) + ")"
+            finally:
+                already_repring.remove(id(self))
+
+        return __repr__
+
+
+def _add_repr(cls, ns=None, attrs=None):
+    """
+    Add a repr method to *cls*.
+    """
+    if attrs is None:
+        attrs = cls.__attrs_attrs__
+
+    cls.__repr__ = _make_repr(attrs, ns, cls)
+    return cls
+
+
+def fields(cls):
+    """
+    Return the tuple of ``attrs`` attributes for a class.
+
+    The tuple also allows accessing the fields by their names (see below for
+    examples).
+
+    :param type cls: Class to introspect.
+
+    :raise TypeError: If *cls* is not a class.
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    :rtype: tuple (with name accessors) of `attrs.Attribute`
+
+    ..  versionchanged:: 16.2.0 Returned tuple allows accessing the fields
+        by name.
+    """
+    if not isclass(cls):
+        raise TypeError("Passed object must be a class.")
+    attrs = getattr(cls, "__attrs_attrs__", None)
+    if attrs is None:
+        raise NotAnAttrsClassError(
+            "{cls!r} is not an attrs-decorated class.".format(cls=cls)
+        )
+    return attrs
+
+
+def fields_dict(cls):
+    """
+    Return an ordered dictionary of ``attrs`` attributes for a class, whose
+    keys are the attribute names.
+
+    :param type cls: Class to introspect.
+
+    :raise TypeError: If *cls* is not a class.
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+        class.
+
+    :rtype: an ordered dict where keys are attribute names and values are
+        `attrs.Attribute`\\ s. This will be a `dict` if it's
+        naturally ordered like on Python 3.6+ or an
+        :class:`~collections.OrderedDict` otherwise.
+
+    .. versionadded:: 18.1.0
+    """
+    if not isclass(cls):
+        raise TypeError("Passed object must be a class.")
+    attrs = getattr(cls, "__attrs_attrs__", None)
+    if attrs is None:
+        raise NotAnAttrsClassError(
+            "{cls!r} is not an attrs-decorated class.".format(cls=cls)
+        )
+    return ordered_dict(((a.name, a) for a in attrs))
+
+
+def validate(inst):
+    """
+    Validate all attributes on *inst* that have a validator.
+
+    Leaves all exceptions through.
+
+    :param inst: Instance of a class with ``attrs`` attributes.
+    """
+    if _config._run_validators is False:
+        return
+
+    for a in fields(inst.__class__):
+        v = a.validator
+        if v is not None:
+            v(inst, a, getattr(inst, a.name))
+
+
+def _is_slot_cls(cls):
+    return "__slots__" in cls.__dict__
+
+
+def _is_slot_attr(a_name, base_attr_map):
+    """
+    Check if the attribute name comes from a slot class.
+    """
+    return a_name in base_attr_map and _is_slot_cls(base_attr_map[a_name])
+
+
+def _make_init(
+    cls,
+    attrs,
+    pre_init,
+    post_init,
+    frozen,
+    slots,
+    cache_hash,
+    base_attr_map,
+    is_exc,
+    cls_on_setattr,
+    attrs_init,
+):
+    has_cls_on_setattr = (
+        cls_on_setattr is not None and cls_on_setattr is not setters.NO_OP
+    )
+
+    if frozen and has_cls_on_setattr:
+        raise ValueError("Frozen classes can't use on_setattr.")
+
+    needs_cached_setattr = cache_hash or frozen
+    filtered_attrs = []
+    attr_dict = {}
+    for a in attrs:
+        if not a.init and a.default is NOTHING:
+            continue
+
+        filtered_attrs.append(a)
+        attr_dict[a.name] = a
+
+        if a.on_setattr is not None:
+            if frozen is True:
+                raise ValueError("Frozen classes can't use on_setattr.")
+
+            needs_cached_setattr = True
+        elif has_cls_on_setattr and a.on_setattr is not setters.NO_OP:
+            needs_cached_setattr = True
+
+    unique_filename = _generate_unique_filename(cls, "init")
+
+    script, globs, annotations = _attrs_to_init_script(
+        filtered_attrs,
+        frozen,
+        slots,
+        pre_init,
+        post_init,
+        cache_hash,
+        base_attr_map,
+        is_exc,
+        needs_cached_setattr,
+        has_cls_on_setattr,
+        attrs_init,
+    )
+    if cls.__module__ in sys.modules:
+        # This makes typing.get_type_hints(CLS.__init__) resolve string types.
+        globs.update(sys.modules[cls.__module__].__dict__)
+
+    globs.update({"NOTHING": NOTHING, "attr_dict": attr_dict})
+
+    if needs_cached_setattr:
+        # Save the lookup overhead in __init__ if we need to circumvent
+        # setattr hooks.
+        globs["_cached_setattr"] = _obj_setattr
+
+    init = _make_method(
+        "__attrs_init__" if attrs_init else "__init__",
+        script,
+        unique_filename,
+        globs,
+    )
+    init.__annotations__ = annotations
+
+    return init
+
+
+def _setattr(attr_name, value_var, has_on_setattr):
+    """
+    Use the cached object.setattr to set *attr_name* to *value_var*.
+    """
+    return "_setattr('%s', %s)" % (attr_name, value_var)
+
+
+def _setattr_with_converter(attr_name, value_var, has_on_setattr):
+    """
+    Use the cached object.setattr to set *attr_name* to *value_var*, but run
+    its converter first.
+    """
+    return "_setattr('%s', %s(%s))" % (
+        attr_name,
+        _init_converter_pat % (attr_name,),
+        value_var,
+    )
+
+
+def _assign(attr_name, value, has_on_setattr):
+    """
+    Unless *attr_name* has an on_setattr hook, use normal assignment. Otherwise
+    relegate to _setattr.
+    """
+    if has_on_setattr:
+        return _setattr(attr_name, value, True)
+
+    return "self.%s = %s" % (attr_name, value)
+
+
+def _assign_with_converter(attr_name, value_var, has_on_setattr):
+    """
+    Unless *attr_name* has an on_setattr hook, use normal assignment after
+    conversion. Otherwise relegate to _setattr_with_converter.
+    """
+    if has_on_setattr:
+        return _setattr_with_converter(attr_name, value_var, True)
+
+    return "self.%s = %s(%s)" % (
+        attr_name,
+        _init_converter_pat % (attr_name,),
+        value_var,
+    )
+
+
+if PY2:
+
+    def _unpack_kw_only_py2(attr_name, default=None):
+        """
+        Unpack *attr_name* from _kw_only dict.
+        """
+        if default is not None:
+            arg_default = ", %s" % default
+        else:
+            arg_default = ""
+        return "%s = _kw_only.pop('%s'%s)" % (
+            attr_name,
+            attr_name,
+            arg_default,
+        )
+
+    def _unpack_kw_only_lines_py2(kw_only_args):
+        """
+        Unpack all *kw_only_args* from _kw_only dict and handle errors.
+
+        Given a list of strings "{attr_name}" and "{attr_name}={default}"
+        generates list of lines of code that pop attrs from _kw_only dict and
+        raise TypeError similar to builtin if required attr is missing or
+        extra key is passed.
+
+        >>> print("\n".join(_unpack_kw_only_lines_py2(["a", "b=42"])))
+        try:
+            a = _kw_only.pop('a')
+            b = _kw_only.pop('b', 42)
+        except KeyError as _key_error:
+            raise TypeError(
+                ...
+        if _kw_only:
+            raise TypeError(
+                ...
+        """
+        lines = ["try:"]
+        lines.extend(
+            "    " + _unpack_kw_only_py2(*arg.split("="))
+            for arg in kw_only_args
+        )
+        lines += """\
+except KeyError as _key_error:
+    raise TypeError(
+        '__init__() missing required keyword-only argument: %s' % _key_error
+    )
+if _kw_only:
+    raise TypeError(
+        '__init__() got an unexpected keyword argument %r'
+        % next(iter(_kw_only))
+    )
+""".split(
+            "\n"
+        )
+        return lines
+
+
+def _attrs_to_init_script(
+    attrs,
+    frozen,
+    slots,
+    pre_init,
+    post_init,
+    cache_hash,
+    base_attr_map,
+    is_exc,
+    needs_cached_setattr,
+    has_cls_on_setattr,
+    attrs_init,
+):
+    """
+    Return a script of an initializer for *attrs* and a dict of globals.
+
+    The globals are expected by the generated script.
+
+    If *frozen* is True, we cannot set the attributes directly so we use
+    a cached ``object.__setattr__``.
+    """
+    lines = []
+    if pre_init:
+        lines.append("self.__attrs_pre_init__()")
+
+    if needs_cached_setattr:
+        lines.append(
+            # Circumvent the __setattr__ descriptor to save one lookup per
+            # assignment.
+            # Note _setattr will be used again below if cache_hash is True
+            "_setattr = _cached_setattr.__get__(self, self.__class__)"
+        )
+
+    if frozen is True:
+        if slots is True:
+            fmt_setter = _setattr
+            fmt_setter_with_converter = _setattr_with_converter
+        else:
+            # Dict frozen classes assign directly to __dict__.
+            # But only if the attribute doesn't come from an ancestor slot
+            # class.
+            # Note _inst_dict will be used again below if cache_hash is True
+            lines.append("_inst_dict = self.__dict__")
+
+            def fmt_setter(attr_name, value_var, has_on_setattr):
+                if _is_slot_attr(attr_name, base_attr_map):
+                    return _setattr(attr_name, value_var, has_on_setattr)
+
+                return "_inst_dict['%s'] = %s" % (attr_name, value_var)
+
+            def fmt_setter_with_converter(
+                attr_name, value_var, has_on_setattr
+            ):
+                if has_on_setattr or _is_slot_attr(attr_name, base_attr_map):
+                    return _setattr_with_converter(
+                        attr_name, value_var, has_on_setattr
+                    )
+
+                return "_inst_dict['%s'] = %s(%s)" % (
+                    attr_name,
+                    _init_converter_pat % (attr_name,),
+                    value_var,
+                )
+
+    else:
+        # Not frozen.
+        fmt_setter = _assign
+        fmt_setter_with_converter = _assign_with_converter
+
+    args = []
+    kw_only_args = []
+    attrs_to_validate = []
+
+    # This is a dictionary of names to validator and converter callables.
+    # Injecting this into __init__ globals lets us avoid lookups.
+    names_for_globals = {}
+    annotations = {"return": None}
+
+    for a in attrs:
+        if a.validator:
+            attrs_to_validate.append(a)
+
+        attr_name = a.name
+        has_on_setattr = a.on_setattr is not None or (
+            a.on_setattr is not setters.NO_OP and has_cls_on_setattr
+        )
+        arg_name = a.name.lstrip("_")
+
+        has_factory = isinstance(a.default, Factory)
+        if has_factory and a.default.takes_self:
+            maybe_self = "self"
+        else:
+            maybe_self = ""
+
+        if a.init is False:
+            if has_factory:
+                init_factory_name = _init_factory_pat.format(a.name)
+                if a.converter is not None:
+                    lines.append(
+                        fmt_setter_with_converter(
+                            attr_name,
+                            init_factory_name + "(%s)" % (maybe_self,),
+                            has_on_setattr,
+                        )
+                    )
+                    conv_name = _init_converter_pat % (a.name,)
+                    names_for_globals[conv_name] = a.converter
+                else:
+                    lines.append(
+                        fmt_setter(
+                            attr_name,
+                            init_factory_name + "(%s)" % (maybe_self,),
+                            has_on_setattr,
+                        )
+                    )
+                names_for_globals[init_factory_name] = a.default.factory
+            else:
+                if a.converter is not None:
+                    lines.append(
+                        fmt_setter_with_converter(
+                            attr_name,
+                            "attr_dict['%s'].default" % (attr_name,),
+                            has_on_setattr,
+                        )
+                    )
+                    conv_name = _init_converter_pat % (a.name,)
+                    names_for_globals[conv_name] = a.converter
+                else:
+                    lines.append(
+                        fmt_setter(
+                            attr_name,
+                            "attr_dict['%s'].default" % (attr_name,),
+                            has_on_setattr,
+                        )
+                    )
+        elif a.default is not NOTHING and not has_factory:
+            arg = "%s=attr_dict['%s'].default" % (arg_name, attr_name)
+            if a.kw_only:
+                kw_only_args.append(arg)
+            else:
+                args.append(arg)
+
+            if a.converter is not None:
+                lines.append(
+                    fmt_setter_with_converter(
+                        attr_name, arg_name, has_on_setattr
+                    )
+                )
+                names_for_globals[
+                    _init_converter_pat % (a.name,)
+                ] = a.converter
+            else:
+                lines.append(fmt_setter(attr_name, arg_name, has_on_setattr))
+
+        elif has_factory:
+            arg = "%s=NOTHING" % (arg_name,)
+            if a.kw_only:
+                kw_only_args.append(arg)
+            else:
+                args.append(arg)
+            lines.append("if %s is not NOTHING:" % (arg_name,))
+
+            init_factory_name = _init_factory_pat.format(a.name)
+            if a.converter is not None:
+                lines.append(
+                    "    "
+                    + fmt_setter_with_converter(
+                        attr_name, arg_name, has_on_setattr
+                    )
+                )
+                lines.append("else:")
+                lines.append(
+                    "    "
+                    + fmt_setter_with_converter(
+                        attr_name,
+                        init_factory_name + "(" + maybe_self + ")",
+                        has_on_setattr,
+                    )
+                )
+                names_for_globals[
+                    _init_converter_pat % (a.name,)
+                ] = a.converter
+            else:
+                lines.append(
+                    "    " + fmt_setter(attr_name, arg_name, has_on_setattr)
+                )
+                lines.append("else:")
+                lines.append(
+                    "    "
+                    + fmt_setter(
+                        attr_name,
+                        init_factory_name + "(" + maybe_self + ")",
+                        has_on_setattr,
+                    )
+                )
+            names_for_globals[init_factory_name] = a.default.factory
+        else:
+            if a.kw_only:
+                kw_only_args.append(arg_name)
+            else:
+                args.append(arg_name)
+
+            if a.converter is not None:
+                lines.append(
+                    fmt_setter_with_converter(
+                        attr_name, arg_name, has_on_setattr
+                    )
+                )
+                names_for_globals[
+                    _init_converter_pat % (a.name,)
+                ] = a.converter
+            else:
+                lines.append(fmt_setter(attr_name, arg_name, has_on_setattr))
+
+        if a.init is True:
+            if a.type is not None and a.converter is None:
+                annotations[arg_name] = a.type
+            elif a.converter is not None and not PY2:
+                # Try to get the type from the converter.
+                sig = None
+                try:
+                    sig = inspect.signature(a.converter)
+                except (ValueError, TypeError):  # inspect failed
+                    pass
+                if sig:
+                    sig_params = list(sig.parameters.values())
+                    if (
+                        sig_params
+                        and sig_params[0].annotation
+                        is not inspect.Parameter.empty
+                    ):
+                        annotations[arg_name] = sig_params[0].annotation
+
+    if attrs_to_validate:  # we can skip this if there are no validators.
+        names_for_globals["_config"] = _config
+        lines.append("if _config._run_validators is True:")
+        for a in attrs_to_validate:
+            val_name = "__attr_validator_" + a.name
+            attr_name = "__attr_" + a.name
+            lines.append(
+                "    %s(self, %s, self.%s)" % (val_name, attr_name, a.name)
+            )
+            names_for_globals[val_name] = a.validator
+            names_for_globals[attr_name] = a
+
+    if post_init:
+        lines.append("self.__attrs_post_init__()")
+
+    # because this is set only after __attrs_post_init is called, a crash
+    # will result if post-init tries to access the hash code.  This seemed
+    # preferable to setting this beforehand, in which case alteration to
+    # field values during post-init combined with post-init accessing the
+    # hash code would result in silent bugs.
+    if cache_hash:
+        if frozen:
+            if slots:
+                # if frozen and slots, then _setattr defined above
+                init_hash_cache = "_setattr('%s', %s)"
+            else:
+                # if frozen and not slots, then _inst_dict defined above
+                init_hash_cache = "_inst_dict['%s'] = %s"
+        else:
+            init_hash_cache = "self.%s = %s"
+        lines.append(init_hash_cache % (_hash_cache_field, "None"))
+
+    # For exceptions we rely on BaseException.__init__ for proper
+    # initialization.
+    if is_exc:
+        vals = ",".join("self." + a.name for a in attrs if a.init)
+
+        lines.append("BaseException.__init__(self, %s)" % (vals,))
+
+    args = ", ".join(args)
+    if kw_only_args:
+        if PY2:
+            lines = _unpack_kw_only_lines_py2(kw_only_args) + lines
+
+            args += "%s**_kw_only" % (", " if args else "",)  # leading comma
+        else:
+            args += "%s*, %s" % (
+                ", " if args else "",  # leading comma
+                ", ".join(kw_only_args),  # kw_only args
+            )
+    return (
+        """\
+def {init_name}(self, {args}):
+    {lines}
+""".format(
+            init_name=("__attrs_init__" if attrs_init else "__init__"),
+            args=args,
+            lines="\n    ".join(lines) if lines else "pass",
+        ),
+        names_for_globals,
+        annotations,
+    )
+
+
+class Attribute(object):
+    """
+    *Read-only* representation of an attribute.
+
+    The class has *all* arguments of `attr.ib` (except for ``factory``
+    which is only syntactic sugar for ``default=Factory(...)`` plus the
+    following:
+
+    - ``name`` (`str`): The name of the attribute.
+    - ``inherited`` (`bool`): Whether or not that attribute has been inherited
+      from a base class.
+    - ``eq_key`` and ``order_key`` (`typing.Callable` or `None`): The callables
+      that are used for comparing and ordering objects by this attribute,
+      respectively. These are set by passing a callable to `attr.ib`'s ``eq``,
+      ``order``, or ``cmp`` arguments. See also :ref:`comparison customization
+      <custom-comparison>`.
+
+    Instances of this class are frequently used for introspection purposes
+    like:
+
+    - `fields` returns a tuple of them.
+    - Validators get them passed as the first argument.
+    - The :ref:`field transformer <transform-fields>` hook receives a list of
+      them.
+
+    .. versionadded:: 20.1.0 *inherited*
+    .. versionadded:: 20.1.0 *on_setattr*
+    .. versionchanged:: 20.2.0 *inherited* is not taken into account for
+        equality checks and hashing anymore.
+    .. versionadded:: 21.1.0 *eq_key* and *order_key*
+
+    For the full version history of the fields, see `attr.ib`.
+    """
+
+    __slots__ = (
+        "name",
+        "default",
+        "validator",
+        "repr",
+        "eq",
+        "eq_key",
+        "order",
+        "order_key",
+        "hash",
+        "init",
+        "metadata",
+        "type",
+        "converter",
+        "kw_only",
+        "inherited",
+        "on_setattr",
+    )
+
+    def __init__(
+        self,
+        name,
+        default,
+        validator,
+        repr,
+        cmp,  # XXX: unused, remove along with other cmp code.
+        hash,
+        init,
+        inherited,
+        metadata=None,
+        type=None,
+        converter=None,
+        kw_only=False,
+        eq=None,
+        eq_key=None,
+        order=None,
+        order_key=None,
+        on_setattr=None,
+    ):
+        eq, eq_key, order, order_key = _determine_attrib_eq_order(
+            cmp, eq_key or eq, order_key or order, True
+        )
+
+        # Cache this descriptor here to speed things up later.
+        bound_setattr = _obj_setattr.__get__(self, Attribute)
+
+        # Despite the big red warning, people *do* instantiate `Attribute`
+        # themselves.
+        bound_setattr("name", name)
+        bound_setattr("default", default)
+        bound_setattr("validator", validator)
+        bound_setattr("repr", repr)
+        bound_setattr("eq", eq)
+        bound_setattr("eq_key", eq_key)
+        bound_setattr("order", order)
+        bound_setattr("order_key", order_key)
+        bound_setattr("hash", hash)
+        bound_setattr("init", init)
+        bound_setattr("converter", converter)
+        bound_setattr(
+            "metadata",
+            (
+                metadata_proxy(metadata)
+                if metadata
+                else _empty_metadata_singleton
+            ),
+        )
+        bound_setattr("type", type)
+        bound_setattr("kw_only", kw_only)
+        bound_setattr("inherited", inherited)
+        bound_setattr("on_setattr", on_setattr)
+
+    def __setattr__(self, name, value):
+        raise FrozenInstanceError()
+
+    @classmethod
+    def from_counting_attr(cls, name, ca, type=None):
+        # type holds the annotated value. deal with conflicts:
+        if type is None:
+            type = ca.type
+        elif ca.type is not None:
+            raise ValueError(
+                "Type annotation and type argument cannot both be present"
+            )
+        inst_dict = {
+            k: getattr(ca, k)
+            for k in Attribute.__slots__
+            if k
+            not in (
+                "name",
+                "validator",
+                "default",
+                "type",
+                "inherited",
+            )  # exclude methods and deprecated alias
+        }
+        return cls(
+            name=name,
+            validator=ca._validator,
+            default=ca._default,
+            type=type,
+            cmp=None,
+            inherited=False,
+            **inst_dict
+        )
+
+    @property
+    def cmp(self):
+        """
+        Simulate the presence of a cmp attribute and warn.
+        """
+        warnings.warn(_CMP_DEPRECATION, DeprecationWarning, stacklevel=2)
+
+        return self.eq and self.order
+
+    # Don't use attr.evolve since fields(Attribute) doesn't work
+    def evolve(self, **changes):
+        """
+        Copy *self* and apply *changes*.
+
+        This works similarly to `attr.evolve` but that function does not work
+        with ``Attribute``.
+
+        It is mainly meant to be used for `transform-fields`.
+
+        .. versionadded:: 20.3.0
+        """
+        new = copy.copy(self)
+
+        new._setattrs(changes.items())
+
+        return new
+
+    # Don't use _add_pickle since fields(Attribute) doesn't work
+    def __getstate__(self):
+        """
+        Play nice with pickle.
+        """
+        return tuple(
+            getattr(self, name) if name != "metadata" else dict(self.metadata)
+            for name in self.__slots__
+        )
+
+    def __setstate__(self, state):
+        """
+        Play nice with pickle.
+        """
+        self._setattrs(zip(self.__slots__, state))
+
+    def _setattrs(self, name_values_pairs):
+        bound_setattr = _obj_setattr.__get__(self, Attribute)
+        for name, value in name_values_pairs:
+            if name != "metadata":
+                bound_setattr(name, value)
+            else:
+                bound_setattr(
+                    name,
+                    metadata_proxy(value)
+                    if value
+                    else _empty_metadata_singleton,
+                )
+
+
+_a = [
+    Attribute(
+        name=name,
+        default=NOTHING,
+        validator=None,
+        repr=True,
+        cmp=None,
+        eq=True,
+        order=False,
+        hash=(name != "metadata"),
+        init=True,
+        inherited=False,
+    )
+    for name in Attribute.__slots__
+]
+
+Attribute = _add_hash(
+    _add_eq(
+        _add_repr(Attribute, attrs=_a),
+        attrs=[a for a in _a if a.name != "inherited"],
+    ),
+    attrs=[a for a in _a if a.hash and a.name != "inherited"],
+)
+
+
+class _CountingAttr(object):
+    """
+    Intermediate representation of attributes that uses a counter to preserve
+    the order in which the attributes have been defined.
+
+    *Internal* data structure of the attrs library.  Running into is most
+    likely the result of a bug like a forgotten `@attr.s` decorator.
+    """
+
+    __slots__ = (
+        "counter",
+        "_default",
+        "repr",
+        "eq",
+        "eq_key",
+        "order",
+        "order_key",
+        "hash",
+        "init",
+        "metadata",
+        "_validator",
+        "converter",
+        "type",
+        "kw_only",
+        "on_setattr",
+    )
+    __attrs_attrs__ = tuple(
+        Attribute(
+            name=name,
+            default=NOTHING,
+            validator=None,
+            repr=True,
+            cmp=None,
+            hash=True,
+            init=True,
+            kw_only=False,
+            eq=True,
+            eq_key=None,
+            order=False,
+            order_key=None,
+            inherited=False,
+            on_setattr=None,
+        )
+        for name in (
+            "counter",
+            "_default",
+            "repr",
+            "eq",
+            "order",
+            "hash",
+            "init",
+            "on_setattr",
+        )
+    ) + (
+        Attribute(
+            name="metadata",
+            default=None,
+            validator=None,
+            repr=True,
+            cmp=None,
+            hash=False,
+            init=True,
+            kw_only=False,
+            eq=True,
+            eq_key=None,
+            order=False,
+            order_key=None,
+            inherited=False,
+            on_setattr=None,
+        ),
+    )
+    cls_counter = 0
+
+    def __init__(
+        self,
+        default,
+        validator,
+        repr,
+        cmp,
+        hash,
+        init,
+        converter,
+        metadata,
+        type,
+        kw_only,
+        eq,
+        eq_key,
+        order,
+        order_key,
+        on_setattr,
+    ):
+        _CountingAttr.cls_counter += 1
+        self.counter = _CountingAttr.cls_counter
+        self._default = default
+        self._validator = validator
+        self.converter = converter
+        self.repr = repr
+        self.eq = eq
+        self.eq_key = eq_key
+        self.order = order
+        self.order_key = order_key
+        self.hash = hash
+        self.init = init
+        self.metadata = metadata
+        self.type = type
+        self.kw_only = kw_only
+        self.on_setattr = on_setattr
+
+    def validator(self, meth):
+        """
+        Decorator that adds *meth* to the list of validators.
+
+        Returns *meth* unchanged.
+
+        .. versionadded:: 17.1.0
+        """
+        if self._validator is None:
+            self._validator = meth
+        else:
+            self._validator = and_(self._validator, meth)
+        return meth
+
+    def default(self, meth):
+        """
+        Decorator that allows to set the default for an attribute.
+
+        Returns *meth* unchanged.
+
+        :raises DefaultAlreadySetError: If default has been set before.
+
+        .. versionadded:: 17.1.0
+        """
+        if self._default is not NOTHING:
+            raise DefaultAlreadySetError()
+
+        self._default = Factory(meth, takes_self=True)
+
+        return meth
+
+
+_CountingAttr = _add_eq(_add_repr(_CountingAttr))
+
+
+class Factory(object):
+    """
+    Stores a factory callable.
+
+    If passed as the default value to `attrs.field`, the factory is used to
+    generate a new value.
+
+    :param callable factory: A callable that takes either none or exactly one
+        mandatory positional argument depending on *takes_self*.
+    :param bool takes_self: Pass the partially initialized instance that is
+        being initialized as a positional argument.
+
+    .. versionadded:: 17.1.0  *takes_self*
+    """
+
+    __slots__ = ("factory", "takes_self")
+
+    def __init__(self, factory, takes_self=False):
+        """
+        `Factory` is part of the default machinery so if we want a default
+        value here, we have to implement it ourselves.
+        """
+        self.factory = factory
+        self.takes_self = takes_self
+
+    def __getstate__(self):
+        """
+        Play nice with pickle.
+        """
+        return tuple(getattr(self, name) for name in self.__slots__)
+
+    def __setstate__(self, state):
+        """
+        Play nice with pickle.
+        """
+        for name, value in zip(self.__slots__, state):
+            setattr(self, name, value)
+
+
+_f = [
+    Attribute(
+        name=name,
+        default=NOTHING,
+        validator=None,
+        repr=True,
+        cmp=None,
+        eq=True,
+        order=False,
+        hash=True,
+        init=True,
+        inherited=False,
+    )
+    for name in Factory.__slots__
+]
+
+Factory = _add_hash(_add_eq(_add_repr(Factory, attrs=_f), attrs=_f), attrs=_f)
+
+
+def make_class(name, attrs, bases=(object,), **attributes_arguments):
+    """
+    A quick way to create a new class called *name* with *attrs*.
+
+    :param str name: The name for the new class.
+
+    :param attrs: A list of names or a dictionary of mappings of names to
+        attributes.
+
+        If *attrs* is a list or an ordered dict (`dict` on Python 3.6+,
+        `collections.OrderedDict` otherwise), the order is deduced from
+        the order of the names or attributes inside *attrs*.  Otherwise the
+        order of the definition of the attributes is used.
+    :type attrs: `list` or `dict`
+
+    :param tuple bases: Classes that the new class will subclass.
+
+    :param attributes_arguments: Passed unmodified to `attr.s`.
+
+    :return: A new class with *attrs*.
+    :rtype: type
+
+    .. versionadded:: 17.1.0 *bases*
+    .. versionchanged:: 18.1.0 If *attrs* is ordered, the order is retained.
+    """
+    if isinstance(attrs, dict):
+        cls_dict = attrs
+    elif isinstance(attrs, (list, tuple)):
+        cls_dict = dict((a, attrib()) for a in attrs)
+    else:
+        raise TypeError("attrs argument must be a dict or a list.")
+
+    pre_init = cls_dict.pop("__attrs_pre_init__", None)
+    post_init = cls_dict.pop("__attrs_post_init__", None)
+    user_init = cls_dict.pop("__init__", None)
+
+    body = {}
+    if pre_init is not None:
+        body["__attrs_pre_init__"] = pre_init
+    if post_init is not None:
+        body["__attrs_post_init__"] = post_init
+    if user_init is not None:
+        body["__init__"] = user_init
+
+    type_ = new_class(name, bases, {}, lambda ns: ns.update(body))
+
+    # For pickling to work, the __module__ variable needs to be set to the
+    # frame where the class is created.  Bypass this step in environments where
+    # sys._getframe is not defined (Jython for example) or sys._getframe is not
+    # defined for arguments greater than 0 (IronPython).
+    try:
+        type_.__module__ = sys._getframe(1).f_globals.get(
+            "__name__", "__main__"
+        )
+    except (AttributeError, ValueError):
+        pass
+
+    # We do it here for proper warnings with meaningful stacklevel.
+    cmp = attributes_arguments.pop("cmp", None)
+    (
+        attributes_arguments["eq"],
+        attributes_arguments["order"],
+    ) = _determine_attrs_eq_order(
+        cmp,
+        attributes_arguments.get("eq"),
+        attributes_arguments.get("order"),
+        True,
+    )
+
+    return _attrs(these=cls_dict, **attributes_arguments)(type_)
+
+
+# These are required by within this module so we define them here and merely
+# import into .validators / .converters.
+
+
+@attrs(slots=True, hash=True)
+class _AndValidator(object):
+    """
+    Compose many validators to a single one.
+    """
+
+    _validators = attrib()
+
+    def __call__(self, inst, attr, value):
+        for v in self._validators:
+            v(inst, attr, value)
+
+
+def and_(*validators):
+    """
+    A validator that composes multiple validators into one.
+
+    When called on a value, it runs all wrapped validators.
+
+    :param callables validators: Arbitrary number of validators.
+
+    .. versionadded:: 17.1.0
+    """
+    vals = []
+    for validator in validators:
+        vals.extend(
+            validator._validators
+            if isinstance(validator, _AndValidator)
+            else [validator]
+        )
+
+    return _AndValidator(tuple(vals))
+
+
+def pipe(*converters):
+    """
+    A converter that composes multiple converters into one.
+
+    When called on a value, it runs all wrapped converters, returning the
+    *last* value.
+
+    Type annotations will be inferred from the wrapped converters', if
+    they have any.
+
+    :param callables converters: Arbitrary number of converters.
+
+    .. versionadded:: 20.1.0
+    """
+
+    def pipe_converter(val):
+        for converter in converters:
+            val = converter(val)
+
+        return val
+
+    if not PY2:
+        if not converters:
+            # If the converter list is empty, pipe_converter is the identity.
+            A = typing.TypeVar("A")
+            pipe_converter.__annotations__ = {"val": A, "return": A}
+        else:
+            # Get parameter type.
+            sig = None
+            try:
+                sig = inspect.signature(converters[0])
+            except (ValueError, TypeError):  # inspect failed
+                pass
+            if sig:
+                params = list(sig.parameters.values())
+                if (
+                    params
+                    and params[0].annotation is not inspect.Parameter.empty
+                ):
+                    pipe_converter.__annotations__["val"] = params[
+                        0
+                    ].annotation
+            # Get return type.
+            sig = None
+            try:
+                sig = inspect.signature(converters[-1])
+            except (ValueError, TypeError):  # inspect failed
+                pass
+            if sig and sig.return_annotation is not inspect.Signature().empty:
+                pipe_converter.__annotations__[
+                    "return"
+                ] = sig.return_annotation
+
+    return pipe_converter
diff --git a/myenv/lib/python3.9/site-packages/attr/_next_gen.py b/myenv/lib/python3.9/site-packages/attr/_next_gen.py
new file mode 100644
index 0000000..0682536
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/_next_gen.py
@@ -0,0 +1,216 @@
+# SPDX-License-Identifier: MIT
+
+"""
+These are Python 3.6+-only and keyword-only APIs that call `attr.s` and
+`attr.ib` with different default values.
+"""
+
+
+from functools import partial
+
+from . import setters
+from ._funcs import asdict as _asdict
+from ._funcs import astuple as _astuple
+from ._make import (
+    NOTHING,
+    _frozen_setattrs,
+    _ng_default_on_setattr,
+    attrib,
+    attrs,
+)
+from .exceptions import UnannotatedAttributeError
+
+
+def define(
+    maybe_cls=None,
+    *,
+    these=None,
+    repr=None,
+    hash=None,
+    init=None,
+    slots=True,
+    frozen=False,
+    weakref_slot=True,
+    str=False,
+    auto_attribs=None,
+    kw_only=False,
+    cache_hash=False,
+    auto_exc=True,
+    eq=None,
+    order=False,
+    auto_detect=True,
+    getstate_setstate=None,
+    on_setattr=None,
+    field_transformer=None,
+    match_args=True,
+):
+    r"""
+    Define an ``attrs`` class.
+
+    Differences to the classic `attr.s` that it uses underneath:
+
+    - Automatically detect whether or not *auto_attribs* should be `True`
+      (c.f. *auto_attribs* parameter).
+    - If *frozen* is `False`, run converters and validators when setting an
+      attribute by default.
+    - *slots=True* (see :term:`slotted classes` for potentially surprising
+      behaviors)
+    - *auto_exc=True*
+    - *auto_detect=True*
+    - *order=False*
+    - *match_args=True*
+    - Some options that were only relevant on Python 2 or were kept around for
+      backwards-compatibility have been removed.
+
+    Please note that these are all defaults and you can change them as you
+    wish.
+
+    :param Optional[bool] auto_attribs: If set to `True` or `False`, it behaves
+       exactly like `attr.s`. If left `None`, `attr.s` will try to guess:
+
+       1. If any attributes are annotated and no unannotated `attrs.fields`\ s
+          are found, it assumes *auto_attribs=True*.
+       2. Otherwise it assumes *auto_attribs=False* and tries to collect
+          `attrs.fields`\ s.
+
+    For now, please refer to `attr.s` for the rest of the parameters.
+
+    .. versionadded:: 20.1.0
+    .. versionchanged:: 21.3.0 Converters are also run ``on_setattr``.
+    """
+
+    def do_it(cls, auto_attribs):
+        return attrs(
+            maybe_cls=cls,
+            these=these,
+            repr=repr,
+            hash=hash,
+            init=init,
+            slots=slots,
+            frozen=frozen,
+            weakref_slot=weakref_slot,
+            str=str,
+            auto_attribs=auto_attribs,
+            kw_only=kw_only,
+            cache_hash=cache_hash,
+            auto_exc=auto_exc,
+            eq=eq,
+            order=order,
+            auto_detect=auto_detect,
+            collect_by_mro=True,
+            getstate_setstate=getstate_setstate,
+            on_setattr=on_setattr,
+            field_transformer=field_transformer,
+            match_args=match_args,
+        )
+
+    def wrap(cls):
+        """
+        Making this a wrapper ensures this code runs during class creation.
+
+        We also ensure that frozen-ness of classes is inherited.
+        """
+        nonlocal frozen, on_setattr
+
+        had_on_setattr = on_setattr not in (None, setters.NO_OP)
+
+        # By default, mutable classes convert & validate on setattr.
+        if frozen is False and on_setattr is None:
+            on_setattr = _ng_default_on_setattr
+
+        # However, if we subclass a frozen class, we inherit the immutability
+        # and disable on_setattr.
+        for base_cls in cls.__bases__:
+            if base_cls.__setattr__ is _frozen_setattrs:
+                if had_on_setattr:
+                    raise ValueError(
+                        "Frozen classes can't use on_setattr "
+                        "(frozen-ness was inherited)."
+                    )
+
+                on_setattr = setters.NO_OP
+                break
+
+        if auto_attribs is not None:
+            return do_it(cls, auto_attribs)
+
+        try:
+            return do_it(cls, True)
+        except UnannotatedAttributeError:
+            return do_it(cls, False)
+
+    # maybe_cls's type depends on the usage of the decorator.  It's a class
+    # if it's used as `@attrs` but ``None`` if used as `@attrs()`.
+    if maybe_cls is None:
+        return wrap
+    else:
+        return wrap(maybe_cls)
+
+
+mutable = define
+frozen = partial(define, frozen=True, on_setattr=None)
+
+
+def field(
+    *,
+    default=NOTHING,
+    validator=None,
+    repr=True,
+    hash=None,
+    init=True,
+    metadata=None,
+    converter=None,
+    factory=None,
+    kw_only=False,
+    eq=None,
+    order=None,
+    on_setattr=None,
+):
+    """
+    Identical to `attr.ib`, except keyword-only and with some arguments
+    removed.
+
+    .. versionadded:: 20.1.0
+    """
+    return attrib(
+        default=default,
+        validator=validator,
+        repr=repr,
+        hash=hash,
+        init=init,
+        metadata=metadata,
+        converter=converter,
+        factory=factory,
+        kw_only=kw_only,
+        eq=eq,
+        order=order,
+        on_setattr=on_setattr,
+    )
+
+
+def asdict(inst, *, recurse=True, filter=None, value_serializer=None):
+    """
+    Same as `attr.asdict`, except that collections types are always retained
+    and dict is always used as *dict_factory*.
+
+    .. versionadded:: 21.3.0
+    """
+    return _asdict(
+        inst=inst,
+        recurse=recurse,
+        filter=filter,
+        value_serializer=value_serializer,
+        retain_collection_types=True,
+    )
+
+
+def astuple(inst, *, recurse=True, filter=None):
+    """
+    Same as `attr.astuple`, except that collections types are always retained
+    and `tuple` is always used as the *tuple_factory*.
+
+    .. versionadded:: 21.3.0
+    """
+    return _astuple(
+        inst=inst, recurse=recurse, filter=filter, retain_collection_types=True
+    )
diff --git a/myenv/lib/python3.9/site-packages/attr/_version_info.py b/myenv/lib/python3.9/site-packages/attr/_version_info.py
new file mode 100644
index 0000000..cdaeec3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/_version_info.py
@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: MIT
+
+from __future__ import absolute_import, division, print_function
+
+from functools import total_ordering
+
+from ._funcs import astuple
+from ._make import attrib, attrs
+
+
+@total_ordering
+@attrs(eq=False, order=False, slots=True, frozen=True)
+class VersionInfo(object):
+    """
+    A version object that can be compared to tuple of length 1--4:
+
+    >>> attr.VersionInfo(19, 1, 0, "final")  <= (19, 2)
+    True
+    >>> attr.VersionInfo(19, 1, 0, "final") < (19, 1, 1)
+    True
+    >>> vi = attr.VersionInfo(19, 2, 0, "final")
+    >>> vi < (19, 1, 1)
+    False
+    >>> vi < (19,)
+    False
+    >>> vi == (19, 2,)
+    True
+    >>> vi == (19, 2, 1)
+    False
+
+    .. versionadded:: 19.2
+    """
+
+    year = attrib(type=int)
+    minor = attrib(type=int)
+    micro = attrib(type=int)
+    releaselevel = attrib(type=str)
+
+    @classmethod
+    def _from_version_string(cls, s):
+        """
+        Parse *s* and return a _VersionInfo.
+        """
+        v = s.split(".")
+        if len(v) == 3:
+            v.append("final")
+
+        return cls(
+            year=int(v[0]), minor=int(v[1]), micro=int(v[2]), releaselevel=v[3]
+        )
+
+    def _ensure_tuple(self, other):
+        """
+        Ensure *other* is a tuple of a valid length.
+
+        Returns a possibly transformed *other* and ourselves as a tuple of
+        the same length as *other*.
+        """
+
+        if self.__class__ is other.__class__:
+            other = astuple(other)
+
+        if not isinstance(other, tuple):
+            raise NotImplementedError
+
+        if not (1 <= len(other) <= 4):
+            raise NotImplementedError
+
+        return astuple(self)[: len(other)], other
+
+    def __eq__(self, other):
+        try:
+            us, them = self._ensure_tuple(other)
+        except NotImplementedError:
+            return NotImplemented
+
+        return us == them
+
+    def __lt__(self, other):
+        try:
+            us, them = self._ensure_tuple(other)
+        except NotImplementedError:
+            return NotImplemented
+
+        # Since alphabetically "dev0" < "final" < "post1" < "post2", we don't
+        # have to do anything special with releaselevel for now.
+        return us < them
diff --git a/myenv/lib/python3.9/site-packages/attr/_version_info.pyi b/myenv/lib/python3.9/site-packages/attr/_version_info.pyi
new file mode 100644
index 0000000..45ced08
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/_version_info.pyi
@@ -0,0 +1,9 @@
+class VersionInfo:
+    @property
+    def year(self) -> int: ...
+    @property
+    def minor(self) -> int: ...
+    @property
+    def micro(self) -> int: ...
+    @property
+    def releaselevel(self) -> str: ...
diff --git a/myenv/lib/python3.9/site-packages/attr/converters.py b/myenv/lib/python3.9/site-packages/attr/converters.py
new file mode 100644
index 0000000..1fb6c05
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/converters.py
@@ -0,0 +1,155 @@
+# SPDX-License-Identifier: MIT
+
+"""
+Commonly useful converters.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+from ._compat import PY2
+from ._make import NOTHING, Factory, pipe
+
+
+if not PY2:
+    import inspect
+    import typing
+
+
+__all__ = [
+    "default_if_none",
+    "optional",
+    "pipe",
+    "to_bool",
+]
+
+
+def optional(converter):
+    """
+    A converter that allows an attribute to be optional. An optional attribute
+    is one which can be set to ``None``.
+
+    Type annotations will be inferred from the wrapped converter's, if it
+    has any.
+
+    :param callable converter: the converter that is used for non-``None``
+        values.
+
+    .. versionadded:: 17.1.0
+    """
+
+    def optional_converter(val):
+        if val is None:
+            return None
+        return converter(val)
+
+    if not PY2:
+        sig = None
+        try:
+            sig = inspect.signature(converter)
+        except (ValueError, TypeError):  # inspect failed
+            pass
+        if sig:
+            params = list(sig.parameters.values())
+            if params and params[0].annotation is not inspect.Parameter.empty:
+                optional_converter.__annotations__["val"] = typing.Optional[
+                    params[0].annotation
+                ]
+            if sig.return_annotation is not inspect.Signature.empty:
+                optional_converter.__annotations__["return"] = typing.Optional[
+                    sig.return_annotation
+                ]
+
+    return optional_converter
+
+
+def default_if_none(default=NOTHING, factory=None):
+    """
+    A converter that allows to replace ``None`` values by *default* or the
+    result of *factory*.
+
+    :param default: Value to be used if ``None`` is passed. Passing an instance
+       of `attrs.Factory` is supported, however the ``takes_self`` option
+       is *not*.
+    :param callable factory: A callable that takes no parameters whose result
+       is used if ``None`` is passed.
+
+    :raises TypeError: If **neither** *default* or *factory* is passed.
+    :raises TypeError: If **both** *default* and *factory* are passed.
+    :raises ValueError: If an instance of `attrs.Factory` is passed with
+       ``takes_self=True``.
+
+    .. versionadded:: 18.2.0
+    """
+    if default is NOTHING and factory is None:
+        raise TypeError("Must pass either `default` or `factory`.")
+
+    if default is not NOTHING and factory is not None:
+        raise TypeError(
+            "Must pass either `default` or `factory` but not both."
+        )
+
+    if factory is not None:
+        default = Factory(factory)
+
+    if isinstance(default, Factory):
+        if default.takes_self:
+            raise ValueError(
+                "`takes_self` is not supported by default_if_none."
+            )
+
+        def default_if_none_converter(val):
+            if val is not None:
+                return val
+
+            return default.factory()
+
+    else:
+
+        def default_if_none_converter(val):
+            if val is not None:
+                return val
+
+            return default
+
+    return default_if_none_converter
+
+
+def to_bool(val):
+    """
+    Convert "boolean" strings (e.g., from env. vars.) to real booleans.
+
+    Values mapping to :code:`True`:
+
+    - :code:`True`
+    - :code:`"true"` / :code:`"t"`
+    - :code:`"yes"` / :code:`"y"`
+    - :code:`"on"`
+    - :code:`"1"`
+    - :code:`1`
+
+    Values mapping to :code:`False`:
+
+    - :code:`False`
+    - :code:`"false"` / :code:`"f"`
+    - :code:`"no"` / :code:`"n"`
+    - :code:`"off"`
+    - :code:`"0"`
+    - :code:`0`
+
+    :raises ValueError: for any other value.
+
+    .. versionadded:: 21.3.0
+    """
+    if isinstance(val, str):
+        val = val.lower()
+    truthy = {True, "true", "t", "yes", "y", "on", "1", 1}
+    falsy = {False, "false", "f", "no", "n", "off", "0", 0}
+    try:
+        if val in truthy:
+            return True
+        if val in falsy:
+            return False
+    except TypeError:
+        # Raised when "val" is not hashable (e.g., lists)
+        pass
+    raise ValueError("Cannot convert value to bool: {}".format(val))
diff --git a/myenv/lib/python3.9/site-packages/attr/converters.pyi b/myenv/lib/python3.9/site-packages/attr/converters.pyi
new file mode 100644
index 0000000..0f58088
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/converters.pyi
@@ -0,0 +1,13 @@
+from typing import Callable, Optional, TypeVar, overload
+
+from . import _ConverterType
+
+_T = TypeVar("_T")
+
+def pipe(*validators: _ConverterType) -> _ConverterType: ...
+def optional(converter: _ConverterType) -> _ConverterType: ...
+@overload
+def default_if_none(default: _T) -> _ConverterType: ...
+@overload
+def default_if_none(*, factory: Callable[[], _T]) -> _ConverterType: ...
+def to_bool(val: str) -> bool: ...
diff --git a/myenv/lib/python3.9/site-packages/attr/exceptions.py b/myenv/lib/python3.9/site-packages/attr/exceptions.py
new file mode 100644
index 0000000..b2f1edc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/exceptions.py
@@ -0,0 +1,94 @@
+# SPDX-License-Identifier: MIT
+
+from __future__ import absolute_import, division, print_function
+
+
+class FrozenError(AttributeError):
+    """
+    A frozen/immutable instance or attribute have been attempted to be
+    modified.
+
+    It mirrors the behavior of ``namedtuples`` by using the same error message
+    and subclassing `AttributeError`.
+
+    .. versionadded:: 20.1.0
+    """
+
+    msg = "can't set attribute"
+    args = [msg]
+
+
+class FrozenInstanceError(FrozenError):
+    """
+    A frozen instance has been attempted to be modified.
+
+    .. versionadded:: 16.1.0
+    """
+
+
+class FrozenAttributeError(FrozenError):
+    """
+    A frozen attribute has been attempted to be modified.
+
+    .. versionadded:: 20.1.0
+    """
+
+
+class AttrsAttributeNotFoundError(ValueError):
+    """
+    An ``attrs`` function couldn't find an attribute that the user asked for.
+
+    .. versionadded:: 16.2.0
+    """
+
+
+class NotAnAttrsClassError(ValueError):
+    """
+    A non-``attrs`` class has been passed into an ``attrs`` function.
+
+    .. versionadded:: 16.2.0
+    """
+
+
+class DefaultAlreadySetError(RuntimeError):
+    """
+    A default has been set using ``attr.ib()`` and is attempted to be reset
+    using the decorator.
+
+    .. versionadded:: 17.1.0
+    """
+
+
+class UnannotatedAttributeError(RuntimeError):
+    """
+    A class with ``auto_attribs=True`` has an ``attr.ib()`` without a type
+    annotation.
+
+    .. versionadded:: 17.3.0
+    """
+
+
+class PythonTooOldError(RuntimeError):
+    """
+    It was attempted to use an ``attrs`` feature that requires a newer Python
+    version.
+
+    .. versionadded:: 18.2.0
+    """
+
+
+class NotCallableError(TypeError):
+    """
+    A ``attr.ib()`` requiring a callable has been set with a value
+    that is not callable.
+
+    .. versionadded:: 19.2.0
+    """
+
+    def __init__(self, msg, value):
+        super(TypeError, self).__init__(msg, value)
+        self.msg = msg
+        self.value = value
+
+    def __str__(self):
+        return str(self.msg)
diff --git a/myenv/lib/python3.9/site-packages/attr/exceptions.pyi b/myenv/lib/python3.9/site-packages/attr/exceptions.pyi
new file mode 100644
index 0000000..f268011
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/exceptions.pyi
@@ -0,0 +1,17 @@
+from typing import Any
+
+class FrozenError(AttributeError):
+    msg: str = ...
+
+class FrozenInstanceError(FrozenError): ...
+class FrozenAttributeError(FrozenError): ...
+class AttrsAttributeNotFoundError(ValueError): ...
+class NotAnAttrsClassError(ValueError): ...
+class DefaultAlreadySetError(RuntimeError): ...
+class UnannotatedAttributeError(RuntimeError): ...
+class PythonTooOldError(RuntimeError): ...
+
+class NotCallableError(TypeError):
+    msg: str = ...
+    value: Any = ...
+    def __init__(self, msg: str, value: Any) -> None: ...
diff --git a/myenv/lib/python3.9/site-packages/attr/filters.py b/myenv/lib/python3.9/site-packages/attr/filters.py
new file mode 100644
index 0000000..a1978a8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/filters.py
@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: MIT
+
+"""
+Commonly useful filters for `attr.asdict`.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+from ._compat import isclass
+from ._make import Attribute
+
+
+def _split_what(what):
+    """
+    Returns a tuple of `frozenset`s of classes and attributes.
+    """
+    return (
+        frozenset(cls for cls in what if isclass(cls)),
+        frozenset(cls for cls in what if isinstance(cls, Attribute)),
+    )
+
+
+def include(*what):
+    """
+    Include *what*.
+
+    :param what: What to include.
+    :type what: `list` of `type` or `attrs.Attribute`\\ s
+
+    :rtype: `callable`
+    """
+    cls, attrs = _split_what(what)
+
+    def include_(attribute, value):
+        return value.__class__ in cls or attribute in attrs
+
+    return include_
+
+
+def exclude(*what):
+    """
+    Exclude *what*.
+
+    :param what: What to exclude.
+    :type what: `list` of classes or `attrs.Attribute`\\ s.
+
+    :rtype: `callable`
+    """
+    cls, attrs = _split_what(what)
+
+    def exclude_(attribute, value):
+        return value.__class__ not in cls and attribute not in attrs
+
+    return exclude_
diff --git a/myenv/lib/python3.9/site-packages/attr/filters.pyi b/myenv/lib/python3.9/site-packages/attr/filters.pyi
new file mode 100644
index 0000000..9938668
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/filters.pyi
@@ -0,0 +1,6 @@
+from typing import Any, Union
+
+from . import Attribute, _FilterType
+
+def include(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...
+def exclude(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...
diff --git a/myenv/lib/python3.9/site-packages/attr/py.typed b/myenv/lib/python3.9/site-packages/attr/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/attr/setters.py b/myenv/lib/python3.9/site-packages/attr/setters.py
new file mode 100644
index 0000000..b1cbb5d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/setters.py
@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: MIT
+
+"""
+Commonly used hooks for on_setattr.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+from . import _config
+from .exceptions import FrozenAttributeError
+
+
+def pipe(*setters):
+    """
+    Run all *setters* and return the return value of the last one.
+
+    .. versionadded:: 20.1.0
+    """
+
+    def wrapped_pipe(instance, attrib, new_value):
+        rv = new_value
+
+        for setter in setters:
+            rv = setter(instance, attrib, rv)
+
+        return rv
+
+    return wrapped_pipe
+
+
+def frozen(_, __, ___):
+    """
+    Prevent an attribute to be modified.
+
+    .. versionadded:: 20.1.0
+    """
+    raise FrozenAttributeError()
+
+
+def validate(instance, attrib, new_value):
+    """
+    Run *attrib*'s validator on *new_value* if it has one.
+
+    .. versionadded:: 20.1.0
+    """
+    if _config._run_validators is False:
+        return new_value
+
+    v = attrib.validator
+    if not v:
+        return new_value
+
+    v(instance, attrib, new_value)
+
+    return new_value
+
+
+def convert(instance, attrib, new_value):
+    """
+    Run *attrib*'s converter -- if it has one --  on *new_value* and return the
+    result.
+
+    .. versionadded:: 20.1.0
+    """
+    c = attrib.converter
+    if c:
+        return c(new_value)
+
+    return new_value
+
+
+NO_OP = object()
+"""
+Sentinel for disabling class-wide *on_setattr* hooks for certain attributes.
+
+Does not work in `pipe` or within lists.
+
+.. versionadded:: 20.1.0
+"""
diff --git a/myenv/lib/python3.9/site-packages/attr/setters.pyi b/myenv/lib/python3.9/site-packages/attr/setters.pyi
new file mode 100644
index 0000000..3f5603c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/setters.pyi
@@ -0,0 +1,19 @@
+from typing import Any, NewType, NoReturn, TypeVar, cast
+
+from . import Attribute, _OnSetAttrType
+
+_T = TypeVar("_T")
+
+def frozen(
+    instance: Any, attribute: Attribute[Any], new_value: Any
+) -> NoReturn: ...
+def pipe(*setters: _OnSetAttrType) -> _OnSetAttrType: ...
+def validate(instance: Any, attribute: Attribute[_T], new_value: _T) -> _T: ...
+
+# convert is allowed to return Any, because they can be chained using pipe.
+def convert(
+    instance: Any, attribute: Attribute[Any], new_value: Any
+) -> Any: ...
+
+_NoOpType = NewType("_NoOpType", object)
+NO_OP: _NoOpType
diff --git a/myenv/lib/python3.9/site-packages/attr/validators.py b/myenv/lib/python3.9/site-packages/attr/validators.py
new file mode 100644
index 0000000..0b0c834
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/validators.py
@@ -0,0 +1,561 @@
+# SPDX-License-Identifier: MIT
+
+"""
+Commonly useful validators.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+import operator
+import re
+
+from contextlib import contextmanager
+
+from ._config import get_run_validators, set_run_validators
+from ._make import _AndValidator, and_, attrib, attrs
+from .exceptions import NotCallableError
+
+
+try:
+    Pattern = re.Pattern
+except AttributeError:  # Python <3.7 lacks a Pattern type.
+    Pattern = type(re.compile(""))
+
+
+__all__ = [
+    "and_",
+    "deep_iterable",
+    "deep_mapping",
+    "disabled",
+    "ge",
+    "get_disabled",
+    "gt",
+    "in_",
+    "instance_of",
+    "is_callable",
+    "le",
+    "lt",
+    "matches_re",
+    "max_len",
+    "optional",
+    "provides",
+    "set_disabled",
+]
+
+
+def set_disabled(disabled):
+    """
+    Globally disable or enable running validators.
+
+    By default, they are run.
+
+    :param disabled: If ``True``, disable running all validators.
+    :type disabled: bool
+
+    .. warning::
+
+        This function is not thread-safe!
+
+    .. versionadded:: 21.3.0
+    """
+    set_run_validators(not disabled)
+
+
+def get_disabled():
+    """
+    Return a bool indicating whether validators are currently disabled or not.
+
+    :return: ``True`` if validators are currently disabled.
+    :rtype: bool
+
+    .. versionadded:: 21.3.0
+    """
+    return not get_run_validators()
+
+
+@contextmanager
+def disabled():
+    """
+    Context manager that disables running validators within its context.
+
+    .. warning::
+
+        This context manager is not thread-safe!
+
+    .. versionadded:: 21.3.0
+    """
+    set_run_validators(False)
+    try:
+        yield
+    finally:
+        set_run_validators(True)
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _InstanceOfValidator(object):
+    type = attrib()
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if not isinstance(value, self.type):
+            raise TypeError(
+                "'{name}' must be {type!r} (got {value!r} that is a "
+                "{actual!r}).".format(
+                    name=attr.name,
+                    type=self.type,
+                    actual=value.__class__,
+                    value=value,
+                ),
+                attr,
+                self.type,
+                value,
+            )
+
+    def __repr__(self):
+        return "<instance_of validator for type {type!r}>".format(
+            type=self.type
+        )
+
+
+def instance_of(type):
+    """
+    A validator that raises a `TypeError` if the initializer is called
+    with a wrong type for this particular attribute (checks are performed using
+    `isinstance` therefore it's also valid to pass a tuple of types).
+
+    :param type: The type to check for.
+    :type type: type or tuple of types
+
+    :raises TypeError: With a human readable error message, the attribute
+        (of type `attrs.Attribute`), the expected type, and the value it
+        got.
+    """
+    return _InstanceOfValidator(type)
+
+
+@attrs(repr=False, frozen=True, slots=True)
+class _MatchesReValidator(object):
+    pattern = attrib()
+    match_func = attrib()
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if not self.match_func(value):
+            raise ValueError(
+                "'{name}' must match regex {pattern!r}"
+                " ({value!r} doesn't)".format(
+                    name=attr.name, pattern=self.pattern.pattern, value=value
+                ),
+                attr,
+                self.pattern,
+                value,
+            )
+
+    def __repr__(self):
+        return "<matches_re validator for pattern {pattern!r}>".format(
+            pattern=self.pattern
+        )
+
+
+def matches_re(regex, flags=0, func=None):
+    r"""
+    A validator that raises `ValueError` if the initializer is called
+    with a string that doesn't match *regex*.
+
+    :param regex: a regex string or precompiled pattern to match against
+    :param int flags: flags that will be passed to the underlying re function
+        (default 0)
+    :param callable func: which underlying `re` function to call (options
+        are `re.fullmatch`, `re.search`, `re.match`, default
+        is ``None`` which means either `re.fullmatch` or an emulation of
+        it on Python 2). For performance reasons, they won't be used directly
+        but on a pre-`re.compile`\ ed pattern.
+
+    .. versionadded:: 19.2.0
+    .. versionchanged:: 21.3.0 *regex* can be a pre-compiled pattern.
+    """
+    fullmatch = getattr(re, "fullmatch", None)
+    valid_funcs = (fullmatch, None, re.search, re.match)
+    if func not in valid_funcs:
+        raise ValueError(
+            "'func' must be one of {}.".format(
+                ", ".join(
+                    sorted(
+                        e and e.__name__ or "None" for e in set(valid_funcs)
+                    )
+                )
+            )
+        )
+
+    if isinstance(regex, Pattern):
+        if flags:
+            raise TypeError(
+                "'flags' can only be used with a string pattern; "
+                "pass flags to re.compile() instead"
+            )
+        pattern = regex
+    else:
+        pattern = re.compile(regex, flags)
+
+    if func is re.match:
+        match_func = pattern.match
+    elif func is re.search:
+        match_func = pattern.search
+    elif fullmatch:
+        match_func = pattern.fullmatch
+    else:  # Python 2 fullmatch emulation (https://bugs.python.org/issue16203)
+        pattern = re.compile(
+            r"(?:{})\Z".format(pattern.pattern), pattern.flags
+        )
+        match_func = pattern.match
+
+    return _MatchesReValidator(pattern, match_func)
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _ProvidesValidator(object):
+    interface = attrib()
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if not self.interface.providedBy(value):
+            raise TypeError(
+                "'{name}' must provide {interface!r} which {value!r} "
+                "doesn't.".format(
+                    name=attr.name, interface=self.interface, value=value
+                ),
+                attr,
+                self.interface,
+                value,
+            )
+
+    def __repr__(self):
+        return "<provides validator for interface {interface!r}>".format(
+            interface=self.interface
+        )
+
+
+def provides(interface):
+    """
+    A validator that raises a `TypeError` if the initializer is called
+    with an object that does not provide the requested *interface* (checks are
+    performed using ``interface.providedBy(value)`` (see `zope.interface
+    <https://zopeinterface.readthedocs.io/en/latest/>`_).
+
+    :param interface: The interface to check for.
+    :type interface: ``zope.interface.Interface``
+
+    :raises TypeError: With a human readable error message, the attribute
+        (of type `attrs.Attribute`), the expected interface, and the
+        value it got.
+    """
+    return _ProvidesValidator(interface)
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _OptionalValidator(object):
+    validator = attrib()
+
+    def __call__(self, inst, attr, value):
+        if value is None:
+            return
+
+        self.validator(inst, attr, value)
+
+    def __repr__(self):
+        return "<optional validator for {what} or None>".format(
+            what=repr(self.validator)
+        )
+
+
+def optional(validator):
+    """
+    A validator that makes an attribute optional.  An optional attribute is one
+    which can be set to ``None`` in addition to satisfying the requirements of
+    the sub-validator.
+
+    :param validator: A validator (or a list of validators) that is used for
+        non-``None`` values.
+    :type validator: callable or `list` of callables.
+
+    .. versionadded:: 15.1.0
+    .. versionchanged:: 17.1.0 *validator* can be a list of validators.
+    """
+    if isinstance(validator, list):
+        return _OptionalValidator(_AndValidator(validator))
+    return _OptionalValidator(validator)
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _InValidator(object):
+    options = attrib()
+
+    def __call__(self, inst, attr, value):
+        try:
+            in_options = value in self.options
+        except TypeError:  # e.g. `1 in "abc"`
+            in_options = False
+
+        if not in_options:
+            raise ValueError(
+                "'{name}' must be in {options!r} (got {value!r})".format(
+                    name=attr.name, options=self.options, value=value
+                )
+            )
+
+    def __repr__(self):
+        return "<in_ validator with options {options!r}>".format(
+            options=self.options
+        )
+
+
+def in_(options):
+    """
+    A validator that raises a `ValueError` if the initializer is called
+    with a value that does not belong in the options provided.  The check is
+    performed using ``value in options``.
+
+    :param options: Allowed options.
+    :type options: list, tuple, `enum.Enum`, ...
+
+    :raises ValueError: With a human readable error message, the attribute (of
+       type `attrs.Attribute`), the expected options, and the value it
+       got.
+
+    .. versionadded:: 17.1.0
+    """
+    return _InValidator(options)
+
+
+@attrs(repr=False, slots=False, hash=True)
+class _IsCallableValidator(object):
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if not callable(value):
+            message = (
+                "'{name}' must be callable "
+                "(got {value!r} that is a {actual!r})."
+            )
+            raise NotCallableError(
+                msg=message.format(
+                    name=attr.name, value=value, actual=value.__class__
+                ),
+                value=value,
+            )
+
+    def __repr__(self):
+        return "<is_callable validator>"
+
+
+def is_callable():
+    """
+    A validator that raises a `attr.exceptions.NotCallableError` if the
+    initializer is called with a value for this particular attribute
+    that is not callable.
+
+    .. versionadded:: 19.1.0
+
+    :raises `attr.exceptions.NotCallableError`: With a human readable error
+        message containing the attribute (`attrs.Attribute`) name,
+        and the value it got.
+    """
+    return _IsCallableValidator()
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _DeepIterable(object):
+    member_validator = attrib(validator=is_callable())
+    iterable_validator = attrib(
+        default=None, validator=optional(is_callable())
+    )
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if self.iterable_validator is not None:
+            self.iterable_validator(inst, attr, value)
+
+        for member in value:
+            self.member_validator(inst, attr, member)
+
+    def __repr__(self):
+        iterable_identifier = (
+            ""
+            if self.iterable_validator is None
+            else " {iterable!r}".format(iterable=self.iterable_validator)
+        )
+        return (
+            "<deep_iterable validator for{iterable_identifier}"
+            " iterables of {member!r}>"
+        ).format(
+            iterable_identifier=iterable_identifier,
+            member=self.member_validator,
+        )
+
+
+def deep_iterable(member_validator, iterable_validator=None):
+    """
+    A validator that performs deep validation of an iterable.
+
+    :param member_validator: Validator to apply to iterable members
+    :param iterable_validator: Validator to apply to iterable itself
+        (optional)
+
+    .. versionadded:: 19.1.0
+
+    :raises TypeError: if any sub-validators fail
+    """
+    return _DeepIterable(member_validator, iterable_validator)
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _DeepMapping(object):
+    key_validator = attrib(validator=is_callable())
+    value_validator = attrib(validator=is_callable())
+    mapping_validator = attrib(default=None, validator=optional(is_callable()))
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if self.mapping_validator is not None:
+            self.mapping_validator(inst, attr, value)
+
+        for key in value:
+            self.key_validator(inst, attr, key)
+            self.value_validator(inst, attr, value[key])
+
+    def __repr__(self):
+        return (
+            "<deep_mapping validator for objects mapping {key!r} to {value!r}>"
+        ).format(key=self.key_validator, value=self.value_validator)
+
+
+def deep_mapping(key_validator, value_validator, mapping_validator=None):
+    """
+    A validator that performs deep validation of a dictionary.
+
+    :param key_validator: Validator to apply to dictionary keys
+    :param value_validator: Validator to apply to dictionary values
+    :param mapping_validator: Validator to apply to top-level mapping
+        attribute (optional)
+
+    .. versionadded:: 19.1.0
+
+    :raises TypeError: if any sub-validators fail
+    """
+    return _DeepMapping(key_validator, value_validator, mapping_validator)
+
+
+@attrs(repr=False, frozen=True, slots=True)
+class _NumberValidator(object):
+    bound = attrib()
+    compare_op = attrib()
+    compare_func = attrib()
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if not self.compare_func(value, self.bound):
+            raise ValueError(
+                "'{name}' must be {op} {bound}: {value}".format(
+                    name=attr.name,
+                    op=self.compare_op,
+                    bound=self.bound,
+                    value=value,
+                )
+            )
+
+    def __repr__(self):
+        return "<Validator for x {op} {bound}>".format(
+            op=self.compare_op, bound=self.bound
+        )
+
+
+def lt(val):
+    """
+    A validator that raises `ValueError` if the initializer is called
+    with a number larger or equal to *val*.
+
+    :param val: Exclusive upper bound for values
+
+    .. versionadded:: 21.3.0
+    """
+    return _NumberValidator(val, "<", operator.lt)
+
+
+def le(val):
+    """
+    A validator that raises `ValueError` if the initializer is called
+    with a number greater than *val*.
+
+    :param val: Inclusive upper bound for values
+
+    .. versionadded:: 21.3.0
+    """
+    return _NumberValidator(val, "<=", operator.le)
+
+
+def ge(val):
+    """
+    A validator that raises `ValueError` if the initializer is called
+    with a number smaller than *val*.
+
+    :param val: Inclusive lower bound for values
+
+    .. versionadded:: 21.3.0
+    """
+    return _NumberValidator(val, ">=", operator.ge)
+
+
+def gt(val):
+    """
+    A validator that raises `ValueError` if the initializer is called
+    with a number smaller or equal to *val*.
+
+    :param val: Exclusive lower bound for values
+
+    .. versionadded:: 21.3.0
+    """
+    return _NumberValidator(val, ">", operator.gt)
+
+
+@attrs(repr=False, frozen=True, slots=True)
+class _MaxLengthValidator(object):
+    max_length = attrib()
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if len(value) > self.max_length:
+            raise ValueError(
+                "Length of '{name}' must be <= {max}: {len}".format(
+                    name=attr.name, max=self.max_length, len=len(value)
+                )
+            )
+
+    def __repr__(self):
+        return "<max_len validator for {max}>".format(max=self.max_length)
+
+
+def max_len(length):
+    """
+    A validator that raises `ValueError` if the initializer is called
+    with a string or iterable that is longer than *length*.
+
+    :param int length: Maximum length of the string or iterable
+
+    .. versionadded:: 21.3.0
+    """
+    return _MaxLengthValidator(length)
diff --git a/myenv/lib/python3.9/site-packages/attr/validators.pyi b/myenv/lib/python3.9/site-packages/attr/validators.pyi
new file mode 100644
index 0000000..5e00b85
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attr/validators.pyi
@@ -0,0 +1,78 @@
+from typing import (
+    Any,
+    AnyStr,
+    Callable,
+    Container,
+    ContextManager,
+    Iterable,
+    List,
+    Mapping,
+    Match,
+    Optional,
+    Pattern,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from . import _ValidatorType
+
+_T = TypeVar("_T")
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_T3 = TypeVar("_T3")
+_I = TypeVar("_I", bound=Iterable)
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+_M = TypeVar("_M", bound=Mapping)
+
+def set_disabled(run: bool) -> None: ...
+def get_disabled() -> bool: ...
+def disabled() -> ContextManager[None]: ...
+
+# To be more precise on instance_of use some overloads.
+# If there are more than 3 items in the tuple then we fall back to Any
+@overload
+def instance_of(type: Type[_T]) -> _ValidatorType[_T]: ...
+@overload
+def instance_of(type: Tuple[Type[_T]]) -> _ValidatorType[_T]: ...
+@overload
+def instance_of(
+    type: Tuple[Type[_T1], Type[_T2]]
+) -> _ValidatorType[Union[_T1, _T2]]: ...
+@overload
+def instance_of(
+    type: Tuple[Type[_T1], Type[_T2], Type[_T3]]
+) -> _ValidatorType[Union[_T1, _T2, _T3]]: ...
+@overload
+def instance_of(type: Tuple[type, ...]) -> _ValidatorType[Any]: ...
+def provides(interface: Any) -> _ValidatorType[Any]: ...
+def optional(
+    validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]]
+) -> _ValidatorType[Optional[_T]]: ...
+def in_(options: Container[_T]) -> _ValidatorType[_T]: ...
+def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ...
+def matches_re(
+    regex: Union[Pattern[AnyStr], AnyStr],
+    flags: int = ...,
+    func: Optional[
+        Callable[[AnyStr, AnyStr, int], Optional[Match[AnyStr]]]
+    ] = ...,
+) -> _ValidatorType[AnyStr]: ...
+def deep_iterable(
+    member_validator: _ValidatorType[_T],
+    iterable_validator: Optional[_ValidatorType[_I]] = ...,
+) -> _ValidatorType[_I]: ...
+def deep_mapping(
+    key_validator: _ValidatorType[_K],
+    value_validator: _ValidatorType[_V],
+    mapping_validator: Optional[_ValidatorType[_M]] = ...,
+) -> _ValidatorType[_M]: ...
+def is_callable() -> _ValidatorType[_T]: ...
+def lt(val: _T) -> _ValidatorType[_T]: ...
+def le(val: _T) -> _ValidatorType[_T]: ...
+def ge(val: _T) -> _ValidatorType[_T]: ...
+def gt(val: _T) -> _ValidatorType[_T]: ...
+def max_len(length: int) -> _ValidatorType[_T]: ...
diff --git a/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/AUTHORS.rst b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/AUTHORS.rst
new file mode 100644
index 0000000..f14ef6c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/AUTHORS.rst
@@ -0,0 +1,11 @@
+Credits
+=======
+
+``attrs`` is written and maintained by `Hynek Schlawack <https://hynek.me/>`_.
+
+The development is kindly supported by `Variomedia AG <https://www.variomedia.de/>`_.
+
+A full list of contributors can be found in `GitHub's overview <https://github.com/python-attrs/attrs/graphs/contributors>`_.
+
+It’s the spiritual successor of `characteristic <https://characteristic.readthedocs.io/>`_ and aspires to fix some of it clunkiness and unfortunate decisions.
+Both were inspired by Twisted’s `FancyEqMixin <https://twistedmatrix.com/documents/current/api/twisted.python.util.FancyEqMixin.html>`_ but both are implemented using class decorators because `subclassing is bad for you <https://www.youtube.com/watch?v=3MNVP9-hglc>`_, m’kay?
diff --git a/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/LICENSE
new file mode 100644
index 0000000..7ae3df9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Hynek Schlawack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/METADATA
new file mode 100644
index 0000000..aa327d5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/METADATA
@@ -0,0 +1,232 @@
+Metadata-Version: 2.1
+Name: attrs
+Version: 21.4.0
+Summary: Classes Without Boilerplate
+Home-page: https://www.attrs.org/
+Author: Hynek Schlawack
+Author-email: hs@ox.cx
+Maintainer: Hynek Schlawack
+Maintainer-email: hs@ox.cx
+License: MIT
+Project-URL: Documentation, https://www.attrs.org/
+Project-URL: Changelog, https://www.attrs.org/en/stable/changelog.html
+Project-URL: Bug Tracker, https://github.com/python-attrs/attrs/issues
+Project-URL: Source Code, https://github.com/python-attrs/attrs
+Project-URL: Funding, https://github.com/sponsors/hynek
+Project-URL: Tidelift, https://tidelift.com/subscription/pkg/pypi-attrs?utm_source=pypi-attrs&utm_medium=pypi
+Project-URL: Ko-fi, https://ko-fi.com/the_hynek
+Keywords: class,attribute,boilerplate
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: AUTHORS.rst
+Provides-Extra: dev
+Requires-Dist: coverage[toml] (>=5.0.2) ; extra == 'dev'
+Requires-Dist: hypothesis ; extra == 'dev'
+Requires-Dist: pympler ; extra == 'dev'
+Requires-Dist: pytest (>=4.3.0) ; extra == 'dev'
+Requires-Dist: six ; extra == 'dev'
+Requires-Dist: mypy ; extra == 'dev'
+Requires-Dist: pytest-mypy-plugins ; extra == 'dev'
+Requires-Dist: zope.interface ; extra == 'dev'
+Requires-Dist: furo ; extra == 'dev'
+Requires-Dist: sphinx ; extra == 'dev'
+Requires-Dist: sphinx-notfound-page ; extra == 'dev'
+Requires-Dist: pre-commit ; extra == 'dev'
+Requires-Dist: cloudpickle ; (platform_python_implementation == "CPython") and extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: furo ; extra == 'docs'
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: zope.interface ; extra == 'docs'
+Requires-Dist: sphinx-notfound-page ; extra == 'docs'
+Provides-Extra: tests
+Requires-Dist: coverage[toml] (>=5.0.2) ; extra == 'tests'
+Requires-Dist: hypothesis ; extra == 'tests'
+Requires-Dist: pympler ; extra == 'tests'
+Requires-Dist: pytest (>=4.3.0) ; extra == 'tests'
+Requires-Dist: six ; extra == 'tests'
+Requires-Dist: mypy ; extra == 'tests'
+Requires-Dist: pytest-mypy-plugins ; extra == 'tests'
+Requires-Dist: zope.interface ; extra == 'tests'
+Requires-Dist: cloudpickle ; (platform_python_implementation == "CPython") and extra == 'tests'
+Provides-Extra: tests_no_zope
+Requires-Dist: coverage[toml] (>=5.0.2) ; extra == 'tests_no_zope'
+Requires-Dist: hypothesis ; extra == 'tests_no_zope'
+Requires-Dist: pympler ; extra == 'tests_no_zope'
+Requires-Dist: pytest (>=4.3.0) ; extra == 'tests_no_zope'
+Requires-Dist: six ; extra == 'tests_no_zope'
+Requires-Dist: mypy ; extra == 'tests_no_zope'
+Requires-Dist: pytest-mypy-plugins ; extra == 'tests_no_zope'
+Requires-Dist: cloudpickle ; (platform_python_implementation == "CPython") and extra == 'tests_no_zope'
+
+
+.. image:: https://www.attrs.org/en/stable/_static/attrs_logo.png
+   :alt: attrs logo
+   :align: center
+
+
+``attrs`` is the Python package that will bring back the **joy** of **writing classes** by relieving you from the drudgery of implementing object protocols (aka `dunder methods <https://www.attrs.org/en/latest/glossary.html#term-dunder-methods>`_).
+`Trusted by NASA <https://docs.github.com/en/account-and-profile/setting-up-and-managing-your-github-profile/customizing-your-profile/personalizing-your-profile#list-of-qualifying-repositories-for-mars-2020-helicopter-contributor-badge>`_ for Mars missions since 2020!
+
+Its main goal is to help you to write **concise** and **correct** software without slowing down your code.
+
+.. teaser-end
+
+For that, it gives you a class decorator and a way to declaratively define the attributes on that class:
+
+.. -code-begin-
+
+.. code-block:: pycon
+
+   >>> from attrs import asdict, define, make_class, Factory
+
+   >>> @define
+   ... class SomeClass:
+   ...     a_number: int = 42
+   ...     list_of_numbers: list[int] = Factory(list)
+   ...
+   ...     def hard_math(self, another_number):
+   ...         return self.a_number + sum(self.list_of_numbers) * another_number
+
+
+   >>> sc = SomeClass(1, [1, 2, 3])
+   >>> sc
+   SomeClass(a_number=1, list_of_numbers=[1, 2, 3])
+
+   >>> sc.hard_math(3)
+   19
+   >>> sc == SomeClass(1, [1, 2, 3])
+   True
+   >>> sc != SomeClass(2, [3, 2, 1])
+   True
+
+   >>> asdict(sc)
+   {'a_number': 1, 'list_of_numbers': [1, 2, 3]}
+
+   >>> SomeClass()
+   SomeClass(a_number=42, list_of_numbers=[])
+
+   >>> C = make_class("C", ["a", "b"])
+   >>> C("foo", "bar")
+   C(a='foo', b='bar')
+
+
+After *declaring* your attributes ``attrs`` gives you:
+
+- a concise and explicit overview of the class's attributes,
+- a nice human-readable ``__repr__``,
+- a equality-checking methods,
+- an initializer,
+- and much more,
+
+*without* writing dull boilerplate code again and again and *without* runtime performance penalties.
+
+**Hate type annotations**!?
+No problem!
+Types are entirely **optional** with ``attrs``.
+Simply assign ``attrs.field()`` to the attributes instead of annotating them with types.
+
+----
+
+This example uses ``attrs``'s modern APIs that have been introduced in version 20.1.0, and the ``attrs`` package import name that has been added in version 21.3.0.
+The classic APIs (``@attr.s``, ``attr.ib``, plus their serious business aliases) and the ``attr`` package import name will remain **indefinitely**.
+
+Please check out `On The Core API Names <https://www.attrs.org/en/latest/names.html>`_ for a more in-depth explanation.
+
+
+Data Classes
+============
+
+On the tin, ``attrs`` might remind you of ``dataclasses`` (and indeed, ``dataclasses`` are a descendant of ``attrs``).
+In practice it does a lot more and is more flexible.
+For instance it allows you to define `special handling of NumPy arrays for equality checks <https://www.attrs.org/en/stable/comparison.html#customization>`_, or allows more ways to `plug into the initialization process <https://www.attrs.org/en/stable/init.html#hooking-yourself-into-initialization>`_.
+
+For more details, please refer to our `comparison page <https://www.attrs.org/en/stable/why.html#data-classes>`_.
+
+
+.. -getting-help-
+
+Getting Help
+============
+
+Please use the ``python-attrs`` tag on `Stack Overflow <https://stackoverflow.com/questions/tagged/python-attrs>`_ to get help.
+
+Answering questions of your fellow developers is also a great way to help the project!
+
+
+.. -project-information-
+
+Project Information
+===================
+
+``attrs`` is released under the `MIT <https://choosealicense.com/licenses/mit/>`_ license,
+its documentation lives at `Read the Docs <https://www.attrs.org/>`_,
+the code on `GitHub <https://github.com/python-attrs/attrs>`_,
+and the latest release on `PyPI <https://pypi.org/project/attrs/>`_.
+It’s rigorously tested on Python 2.7, 3.5+, and PyPy.
+
+We collect information on **third-party extensions** in our `wiki <https://github.com/python-attrs/attrs/wiki/Extensions-to-attrs>`_.
+Feel free to browse and add your own!
+
+If you'd like to contribute to ``attrs`` you're most welcome and we've written `a little guide <https://github.com/python-attrs/attrs/blob/main/.github/CONTRIBUTING.md>`_ to get you started!
+
+
+``attrs`` for Enterprise
+------------------------
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of ``attrs`` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source packages you use to build your applications.
+Save time, reduce risk, and improve code health, while paying the maintainers of the exact packages you use.
+`Learn more. <https://tidelift.com/subscription/pkg/pypi-attrs?utm_source=pypi-attrs&utm_medium=referral&utm_campaign=enterprise&utm_term=repo>`_
+
+
+Release Information
+===================
+
+21.4.0 (2021-12-29)
+-------------------
+
+Changes
+^^^^^^^
+
+- Fixed the test suite on PyPy3.8 where ``cloudpickle`` does not work.
+  `#892 <https://github.com/python-attrs/attrs/issues/892>`_
+- Fixed ``coverage report`` for projects that use ``attrs`` and don't set a ``--source``.
+  `#895 <https://github.com/python-attrs/attrs/issues/895>`_,
+  `#896 <https://github.com/python-attrs/attrs/issues/896>`_
+
+`Full changelog <https://www.attrs.org/en/stable/changelog.html>`_.
+
+Credits
+=======
+
+``attrs`` is written and maintained by `Hynek Schlawack <https://hynek.me/>`_.
+
+The development is kindly supported by `Variomedia AG <https://www.variomedia.de/>`_.
+
+A full list of contributors can be found in `GitHub's overview <https://github.com/python-attrs/attrs/graphs/contributors>`_.
+
+It’s the spiritual successor of `characteristic <https://characteristic.readthedocs.io/>`_ and aspires to fix some of it clunkiness and unfortunate decisions.
+Both were inspired by Twisted’s `FancyEqMixin <https://twistedmatrix.com/documents/current/api/twisted.python.util.FancyEqMixin.html>`_ but both are implemented using class decorators because `subclassing is bad for you <https://www.youtube.com/watch?v=3MNVP9-hglc>`_, m’kay?
+
+
diff --git a/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/RECORD
new file mode 100644
index 0000000..896e259
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/RECORD
@@ -0,0 +1,37 @@
+attr/__init__.py,sha256=_zhJ4O8Q5KR5gaIrjX73vkR5nA6NjfpMGXQChEdNljI,1667
+attr/__init__.pyi,sha256=ubRkstoRHPpQN17iA0OCh8waIwZ5NeJgbz0lwI8XUjY,15100
+attr/_cmp.py,sha256=JP0N7OIyTqIR3prUDfMZOR4DV4tlV_xXf39-bQg7xOo,4165
+attr/_cmp.pyi,sha256=oyjJVytrwwkUJOoe332IiYzp6pCVZEKKcKveH-ev604,317
+attr/_compat.py,sha256=i8u27AAK_4SzQnmTf3aliGV27UdYbJxdZ-O0tOHbLU8,8396
+attr/_config.py,sha256=aj1Lh8t2CuVa5nSxgCrLQtg_ZSdO8ZKeNJQd6RvpIp8,892
+attr/_funcs.py,sha256=sm_D12y2IyRW_bCnR7M-O7U5qHaieXr0BzINwJ7_K38,14753
+attr/_make.py,sha256=D05j0_ckcVIRFn2xHch5SPUCwh3t7WpeFj-3Ku9SocQ,102736
+attr/_next_gen.py,sha256=s5jCsVEQ4IhOjAykP4N0ETaWpg0RsgQttMvEZErUrhQ,5752
+attr/_version_info.py,sha256=sxD9yNai0jGbur_-RGEQHbgV2YX5_5G9PhrhBA5pA54,2194
+attr/_version_info.pyi,sha256=x_M3L3WuB7r_ULXAWjx959udKQ4HLB8l-hsc1FDGNvk,209
+attr/converters.py,sha256=uiiWTz8GLJe8I1Ty7UICK1DegVUnqHTXbOSnar7g7Nk,4078
+attr/converters.pyi,sha256=MQo7iEzPNVoFpKqD30sVwgVpdNoIeSCF2nsXvoxLZ-Y,416
+attr/exceptions.py,sha256=BMg7AljkJnvG-irMwL2TBHYlaLBXhSKnzoEWo4e42Zw,1981
+attr/exceptions.pyi,sha256=zZq8bCUnKAy9mDtBEw42ZhPhAUIHoTKedDQInJD883M,539
+attr/filters.py,sha256=JGZgvPGkdOfttkoL6XhXS6ZCoaVV5nZ8GCYeZNUN_mE,1124
+attr/filters.pyi,sha256=_Sm80jGySETX_Clzdkon5NHVjQWRl3Y3liQKZX1czXc,215
+attr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+attr/setters.py,sha256=rH_UtQuHgQEC7hfZyMO_SJW0R1Gus7-a83U8igZfqs8,1466
+attr/setters.pyi,sha256=7dM10rqpQVDW0y-iJUnq8rabdO5Wx2Sbo5LwNa0IXl0,573
+attr/validators.py,sha256=jVE9roaSOmTf0dJNSLHNaQNilkrlzc3pNNBKmv0g7pk,15966
+attr/validators.pyi,sha256=adn6rNbIXmRXlg_FKrTmWj0dOX0vKTsGG82Jd3YcJbQ,2268
+attrs/__init__.py,sha256=CeyxLGVViAEKKsLOLaif8vF3vs1a28vsrRVLv7eMEgM,1109
+attrs/__init__.pyi,sha256=57aCxUJukK9lZlrUgk9RuWiBiPY5DzDKJAJkhbrStYw,1982
+attrs/converters.py,sha256=fCBEdlYWcmI3sCnpUk2pz22GYtXzqTkp6NeOpdI64PY,70
+attrs/exceptions.py,sha256=SlDli6AY77f6ny-H7oy98OkQjsrw-D_supEuErIVYkE,70
+attrs/filters.py,sha256=dc_dNey29kH6KLU1mT2Dakq7tZ3kBfzEGwzOmDzw1F8,67
+attrs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+attrs/setters.py,sha256=oKw51C72Hh45wTwYvDHJP9kbicxiMhMR4Y5GvdpKdHQ,67
+attrs/validators.py,sha256=4ag1SyVD2Hm3PYKiNG_NOtR_e7f81Hr6GiNl4YvXo4Q,70
+attrs-21.4.0.dist-info/AUTHORS.rst,sha256=wsqCNbGz_mklcJrt54APIZHZpoTIJLkXqEhhn4Nd8hc,752
+attrs-21.4.0.dist-info/LICENSE,sha256=v2WaKLSSQGAvVrvfSQy-LsUJsVuY-Z17GaUsdA4yeGM,1082
+attrs-21.4.0.dist-info/METADATA,sha256=WwgR4MfxE55PpGGv21UOEOEtXZGCqwekfXYg-JgA5HY,9810
+attrs-21.4.0.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
+attrs-21.4.0.dist-info/top_level.txt,sha256=AGbmKnOtYpdkLRsDRQVSBIwfL32pAQ6BSo1mt-BxI7M,11
+attrs-21.4.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+attrs-21.4.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/WHEEL
new file mode 100644
index 0000000..0b18a28
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/top_level.txt
new file mode 100644
index 0000000..eca8ba9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs-21.4.0.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+attr
+attrs
diff --git a/myenv/lib/python3.9/site-packages/attrs/__init__.py b/myenv/lib/python3.9/site-packages/attrs/__init__.py
new file mode 100644
index 0000000..a704b8b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs/__init__.py
@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: MIT
+
+from attr import (
+    NOTHING,
+    Attribute,
+    Factory,
+    __author__,
+    __copyright__,
+    __description__,
+    __doc__,
+    __email__,
+    __license__,
+    __title__,
+    __url__,
+    __version__,
+    __version_info__,
+    assoc,
+    cmp_using,
+    define,
+    evolve,
+    field,
+    fields,
+    fields_dict,
+    frozen,
+    has,
+    make_class,
+    mutable,
+    resolve_types,
+    validate,
+)
+from attr._next_gen import asdict, astuple
+
+from . import converters, exceptions, filters, setters, validators
+
+
+__all__ = [
+    "__author__",
+    "__copyright__",
+    "__description__",
+    "__doc__",
+    "__email__",
+    "__license__",
+    "__title__",
+    "__url__",
+    "__version__",
+    "__version_info__",
+    "asdict",
+    "assoc",
+    "astuple",
+    "Attribute",
+    "cmp_using",
+    "converters",
+    "define",
+    "evolve",
+    "exceptions",
+    "Factory",
+    "field",
+    "fields_dict",
+    "fields",
+    "filters",
+    "frozen",
+    "has",
+    "make_class",
+    "mutable",
+    "NOTHING",
+    "resolve_types",
+    "setters",
+    "validate",
+    "validators",
+]
diff --git a/myenv/lib/python3.9/site-packages/attrs/__init__.pyi b/myenv/lib/python3.9/site-packages/attrs/__init__.pyi
new file mode 100644
index 0000000..7426fa5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs/__init__.pyi
@@ -0,0 +1,63 @@
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+)
+
+# Because we need to type our own stuff, we have to make everything from
+# attr explicitly public too.
+from attr import __author__ as __author__
+from attr import __copyright__ as __copyright__
+from attr import __description__ as __description__
+from attr import __email__ as __email__
+from attr import __license__ as __license__
+from attr import __title__ as __title__
+from attr import __url__ as __url__
+from attr import __version__ as __version__
+from attr import __version_info__ as __version_info__
+from attr import _FilterType
+from attr import assoc as assoc
+from attr import Attribute as Attribute
+from attr import define as define
+from attr import evolve as evolve
+from attr import Factory as Factory
+from attr import exceptions as exceptions
+from attr import field as field
+from attr import fields as fields
+from attr import fields_dict as fields_dict
+from attr import frozen as frozen
+from attr import has as has
+from attr import make_class as make_class
+from attr import mutable as mutable
+from attr import NOTHING as NOTHING
+from attr import resolve_types as resolve_types
+from attr import setters as setters
+from attr import validate as validate
+from attr import validators as validators
+
+# TODO: see definition of attr.asdict/astuple
+def asdict(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType[Any]] = ...,
+    dict_factory: Type[Mapping[Any, Any]] = ...,
+    retain_collection_types: bool = ...,
+    value_serializer: Optional[
+        Callable[[type, Attribute[Any], Any], Any]
+    ] = ...,
+    tuple_keys: bool = ...,
+) -> Dict[str, Any]: ...
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+def astuple(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType[Any]] = ...,
+    tuple_factory: Type[Sequence[Any]] = ...,
+    retain_collection_types: bool = ...,
+) -> Tuple[Any, ...]: ...
diff --git a/myenv/lib/python3.9/site-packages/attrs/converters.py b/myenv/lib/python3.9/site-packages/attrs/converters.py
new file mode 100644
index 0000000..edfa8d3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs/converters.py
@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: MIT
+
+from attr.converters import *  # noqa
diff --git a/myenv/lib/python3.9/site-packages/attrs/exceptions.py b/myenv/lib/python3.9/site-packages/attrs/exceptions.py
new file mode 100644
index 0000000..bd9efed
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs/exceptions.py
@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: MIT
+
+from attr.exceptions import *  # noqa
diff --git a/myenv/lib/python3.9/site-packages/attrs/filters.py b/myenv/lib/python3.9/site-packages/attrs/filters.py
new file mode 100644
index 0000000..5295900
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs/filters.py
@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: MIT
+
+from attr.filters import *  # noqa
diff --git a/myenv/lib/python3.9/site-packages/attrs/py.typed b/myenv/lib/python3.9/site-packages/attrs/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/attrs/setters.py b/myenv/lib/python3.9/site-packages/attrs/setters.py
new file mode 100644
index 0000000..9b50770
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs/setters.py
@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: MIT
+
+from attr.setters import *  # noqa
diff --git a/myenv/lib/python3.9/site-packages/attrs/validators.py b/myenv/lib/python3.9/site-packages/attrs/validators.py
new file mode 100644
index 0000000..ab2c9b3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/attrs/validators.py
@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: MIT
+
+from attr.validators import *  # noqa
diff --git a/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/LICENSE
new file mode 100644
index 0000000..11069ed
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/LICENSE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/METADATA b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/METADATA
new file mode 100644
index 0000000..1322efb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/METADATA
@@ -0,0 +1,272 @@
+Metadata-Version: 2.1
+Name: bcrypt
+Version: 3.2.2
+Summary: Modern password hashing for your software and your servers
+Home-page: https://github.com/pyca/bcrypt/
+Author: The Python Cryptographic Authority developers
+Author-email: cryptography-dev@python.org
+License: Apache License, Version 2.0
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.6
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: cffi (>=1.1)
+Provides-Extra: tests
+Requires-Dist: pytest (!=3.3.0,>=3.2.1) ; extra == 'tests'
+Provides-Extra: typecheck
+Requires-Dist: mypy ; extra == 'typecheck'
+
+bcrypt
+======
+
+.. image:: https://img.shields.io/pypi/v/bcrypt.svg
+    :target: https://pypi.org/project/bcrypt/
+    :alt: Latest Version
+
+.. image:: https://github.com/pyca/bcrypt/workflows/CI/badge.svg?branch=main
+    :target: https://github.com/pyca/bcrypt/actions?query=workflow%3ACI+branch%3Amain
+
+Good password hashing for your software and your servers
+
+
+Installation
+============
+
+To install bcrypt, simply:
+
+.. code:: bash
+
+    $ pip install bcrypt
+
+Note that bcrypt should build very easily on Linux provided you have a C compiler, headers for Python (if you're not using pypy), and headers for the libffi libraries available on your system.
+
+For Debian and Ubuntu, the following command will ensure that the required dependencies are installed:
+
+.. code:: bash
+
+    $ sudo apt-get install build-essential libffi-dev python-dev
+
+For Fedora and RHEL-derivatives, the following command will ensure that the required dependencies are installed:
+
+.. code:: bash
+
+    $ sudo yum install gcc libffi-devel python-devel
+
+For Alpine, the following command will ensure that the required dependencies are installed:
+
+.. code:: bash
+
+    $ apk add --update musl-dev gcc libffi-dev
+
+
+Alternatives
+============
+
+While bcrypt remains a good choice for password storage depending on your specific use case you may also want to consider using scrypt (either via `standard library`_ or `cryptography`_) or argon2id via `argon2_cffi`_.
+
+Changelog
+=========
+
+3.2.2
+-----
+
+* Fixed packaging of ``py.typed`` files in wheels so that ``mypy`` works.
+
+3.2.1
+-----
+
+* Added support for compilation on z/OS
+* The next release of ``bcrypt`` with be 4.0 and it will require Rust at
+  compile time, for users building from source. There will be no additional
+  requirement for users who are installing from wheels. Users on most
+  platforms will be able to obtain a wheel by making sure they have an up to
+  date ``pip``. The minimum supported Rust version will be 1.56.0.
+* This will be the final release for which we ship ``manylinux2010`` wheels.
+  Going forward the minimum supported manylinux ABI for our wheels will be
+  ``manylinux2014``. The vast majority of users will continue to receive
+  ``manylinux`` wheels provided they have an up to date ``pip``.
+
+
+3.2.0
+-----
+
+* Added typehints for library functions.
+* Dropped support for Python versions less than 3.6 (2.7, 3.4, 3.5).
+* Shipped ``abi3`` Windows wheels (requires pip >= 20).
+
+3.1.7
+-----
+
+* Set a ``setuptools`` lower bound for PEP517 wheel building.
+* We no longer distribute 32-bit ``manylinux1`` wheels. Continuing to produce
+  them was a maintenance burden.
+
+3.1.6
+-----
+
+* Added support for compilation on Haiku.
+
+3.1.5
+-----
+
+* Added support for compilation on AIX.
+* Dropped Python 2.6 and 3.3 support.
+* Switched to using ``abi3`` wheels for Python 3. If you are not getting a
+  wheel on a compatible platform please upgrade your ``pip`` version.
+
+3.1.4
+-----
+
+* Fixed compilation with mingw and on illumos.
+
+3.1.3
+-----
+* Fixed a compilation issue on Solaris.
+* Added a warning when using too few rounds with ``kdf``.
+
+3.1.2
+-----
+* Fixed a compile issue affecting big endian platforms.
+* Fixed invalid escape sequence warnings on Python 3.6.
+* Fixed building in non-UTF8 environments on Python 2.
+
+3.1.1
+-----
+* Resolved a ``UserWarning`` when used with ``cffi`` 1.8.3.
+
+3.1.0
+-----
+* Added support for ``checkpw``, a convenience method for verifying a password.
+* Ensure that you get a ``$2y$`` hash when you input a ``$2y$`` salt.
+* Fixed a regression where ``$2a`` hashes were vulnerable to a wraparound bug.
+* Fixed compilation under Alpine Linux.
+
+3.0.0
+-----
+* Switched the C backend to code obtained from the OpenBSD project rather than
+  openwall.
+* Added support for ``bcrypt_pbkdf`` via the ``kdf`` function.
+
+2.0.0
+-----
+* Added support for an adjustible prefix when calling ``gensalt``.
+* Switched to CFFI 1.0+
+
+Usage
+-----
+
+Password Hashing
+~~~~~~~~~~~~~~~~
+
+Hashing and then later checking that a password matches the previous hashed
+password is very simple:
+
+.. code:: pycon
+
+    >>> import bcrypt
+    >>> password = b"super secret password"
+    >>> # Hash a password for the first time, with a randomly-generated salt
+    >>> hashed = bcrypt.hashpw(password, bcrypt.gensalt())
+    >>> # Check that an unhashed password matches one that has previously been
+    >>> # hashed
+    >>> if bcrypt.checkpw(password, hashed):
+    ...     print("It Matches!")
+    ... else:
+    ...     print("It Does not Match :(")
+
+KDF
+~~~
+
+As of 3.0.0 ``bcrypt`` now offers a ``kdf`` function which does ``bcrypt_pbkdf``.
+This KDF is used in OpenSSH's newer encrypted private key format.
+
+.. code:: pycon
+
+    >>> import bcrypt
+    >>> key = bcrypt.kdf(
+    ...     password=b'password',
+    ...     salt=b'salt',
+    ...     desired_key_bytes=32,
+    ...     rounds=100)
+
+
+Adjustable Work Factor
+~~~~~~~~~~~~~~~~~~~~~~
+One of bcrypt's features is an adjustable logarithmic work factor. To adjust
+the work factor merely pass the desired number of rounds to
+``bcrypt.gensalt(rounds=12)`` which defaults to 12):
+
+.. code:: pycon
+
+    >>> import bcrypt
+    >>> password = b"super secret password"
+    >>> # Hash a password for the first time, with a certain number of rounds
+    >>> hashed = bcrypt.hashpw(password, bcrypt.gensalt(14))
+    >>> # Check that a unhashed password matches one that has previously been
+    >>> #   hashed
+    >>> if bcrypt.checkpw(password, hashed):
+    ...     print("It Matches!")
+    ... else:
+    ...     print("It Does not Match :(")
+
+
+Adjustable Prefix
+~~~~~~~~~~~~~~~~~
+
+Another one of bcrypt's features is an adjustable prefix to let you define what
+libraries you'll remain compatible with. To adjust this, pass either ``2a`` or
+``2b`` (the default) to ``bcrypt.gensalt(prefix=b"2b")`` as a bytes object.
+
+As of 3.0.0 the ``$2y$`` prefix is still supported in ``hashpw`` but deprecated.
+
+Maximum Password Length
+~~~~~~~~~~~~~~~~~~~~~~~
+
+The bcrypt algorithm only handles passwords up to 72 characters, any characters
+beyond that are ignored. To work around this, a common approach is to hash a
+password with a cryptographic hash (such as ``sha256``) and then base64
+encode it to prevent NULL byte problems before hashing the result with
+``bcrypt``:
+
+.. code:: pycon
+
+    >>> password = b"an incredibly long password" * 10
+    >>> hashed = bcrypt.hashpw(
+    ...     base64.b64encode(hashlib.sha256(password).digest()),
+    ...     bcrypt.gensalt()
+    ... )
+
+Compatibility
+-------------
+
+This library should be compatible with py-bcrypt and it will run on Python
+3.6+, and PyPy 3.
+
+C Code
+------
+
+This library uses code from OpenBSD.
+
+Security
+--------
+
+``bcrypt`` follows the `same security policy as cryptography`_, if you
+identify a vulnerability, we ask you to contact us privately.
+
+.. _`same security policy as cryptography`: https://cryptography.io/en/latest/security.html
+.. _`standard library`: https://docs.python.org/3/library/hashlib.html#hashlib.scrypt
+.. _`argon2_cffi`: https://argon2-cffi.readthedocs.io
+.. _`cryptography`: https://cryptography.io/en/latest/hazmat/primitives/key-derivation-functions/#cryptography.hazmat.primitives.kdf.scrypt.Scrypt
+
+
diff --git a/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/RECORD b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/RECORD
new file mode 100644
index 0000000..eb0ddf5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/RECORD
@@ -0,0 +1,11 @@
+bcrypt/__about__.py,sha256=y3-LY1hqQ1KAVagHmhL_-VDEDf4r3LWt4HnGi6OCGmk,1320
+bcrypt/__init__.py,sha256=tr7xBv0w9ajqIHf8537qirLqM_bGOGM_lIQMjFd1PfI,5587
+bcrypt/_bcrypt.abi3.so,sha256=dSpfL4RVrKuQDWuXmWOuWIJrU5kgFnBZl8l1j1_78d8,156671
+bcrypt/_bcrypt.pyi,sha256=TGNrzZD1NWdyeWGGJ2i3tj_HWg_YovqF-WdI7otmiIg,47
+bcrypt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bcrypt-3.2.2.dist-info/LICENSE,sha256=gXPVwptPlW1TJ4HSuG5OMPg-a3h43OGMkZRR1rpwfJA,10850
+bcrypt-3.2.2.dist-info/METADATA,sha256=cTPRtd-8x91DRNDRQwvtj4_cic98Cqx4qTgCCS29NGc,8342
+bcrypt-3.2.2.dist-info/WHEEL,sha256=4Pc_qD0VhjiuSiOgv99UcgTmp8ljuSMnWHBjm4-tsjo,114
+bcrypt-3.2.2.dist-info/top_level.txt,sha256=igJttN6fNWPEzk4lnCMzlitVT_1PlLVJzxzogMWGARU,15
+bcrypt-3.2.2.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+bcrypt-3.2.2.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/WHEEL
new file mode 100644
index 0000000..b254a18
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp36-abi3-macosx_10_10_universal2
+
diff --git a/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/top_level.txt
new file mode 100644
index 0000000..9fd6492
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/bcrypt-3.2.2.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+_bcrypt
+bcrypt
diff --git a/myenv/lib/python3.9/site-packages/bcrypt/__about__.py b/myenv/lib/python3.9/site-packages/bcrypt/__about__.py
new file mode 100644
index 0000000..8bcee8d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/bcrypt/__about__.py
@@ -0,0 +1,41 @@
+# Author:: Donald Stufft (<donald@stufft.io>)
+# Copyright:: Copyright (c) 2013 Donald Stufft
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
+
+__title__ = "bcrypt"
+__summary__ = "Modern password hashing for your software and your servers"
+__uri__ = "https://github.com/pyca/bcrypt/"
+
+__version__ = "3.2.2"
+
+__author__ = "The Python Cryptographic Authority developers"
+__email__ = "cryptography-dev@python.org"
+
+__license__ = "Apache License, Version 2.0"
+__copyright__ = "Copyright 2013-2022 {0}".format(__author__)
diff --git a/myenv/lib/python3.9/site-packages/bcrypt/__init__.py b/myenv/lib/python3.9/site-packages/bcrypt/__init__.py
new file mode 100644
index 0000000..a9aae84
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/bcrypt/__init__.py
@@ -0,0 +1,171 @@
+# Author:: Donald Stufft (<donald@stufft.io>)
+# Copyright:: Copyright (c) 2013 Donald Stufft
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import absolute_import
+from __future__ import division
+
+import hmac
+import os
+import re
+import warnings
+
+from .__about__ import (
+    __author__,
+    __copyright__,
+    __email__,
+    __license__,
+    __summary__,
+    __title__,
+    __uri__,
+    __version__,
+)
+from . import _bcrypt  # noqa: I100
+
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+    "gensalt",
+    "hashpw",
+    "kdf",
+    "checkpw",
+]
+
+
+_normalize_re = re.compile(rb"^\$2y\$")
+
+
+def gensalt(rounds: int = 12, prefix: bytes = b"2b") -> bytes:
+    if prefix not in (b"2a", b"2b"):
+        raise ValueError("Supported prefixes are b'2a' or b'2b'")
+
+    if rounds < 4 or rounds > 31:
+        raise ValueError("Invalid rounds")
+
+    salt = os.urandom(16)
+    output = _bcrypt.ffi.new("char[]", 30)
+    _bcrypt.lib.encode_base64(output, salt, len(salt))
+
+    return (
+        b"$"
+        + prefix
+        + b"$"
+        + ("%2.2u" % rounds).encode("ascii")
+        + b"$"
+        + _bcrypt.ffi.string(output)
+    )
+
+
+def hashpw(password: bytes, salt: bytes) -> bytes:
+    if isinstance(password, str) or isinstance(salt, str):
+        raise TypeError("Strings must be encoded before hashing")
+
+    if b"\x00" in password:
+        raise ValueError("password may not contain NUL bytes")
+
+    # bcrypt originally suffered from a wraparound bug:
+    # http://www.openwall.com/lists/oss-security/2012/01/02/4
+    # This bug was corrected in the OpenBSD source by truncating inputs to 72
+    # bytes on the updated prefix $2b$, but leaving $2a$ unchanged for
+    # compatibility. However, pyca/bcrypt 2.0.0 *did* correctly truncate inputs
+    # on $2a$, so we do it here to preserve compatibility with 2.0.0
+    password = password[:72]
+
+    # When the original 8bit bug was found the original library we supported
+    # added a new prefix, $2y$, that fixes it. This prefix is exactly the same
+    # as the $2b$ prefix added by OpenBSD other than the name. Since the
+    # OpenBSD library does not support the $2y$ prefix, if the salt given to us
+    # is for the $2y$ prefix, we'll just mugne it so that it's a $2b$ prior to
+    # passing it into the C library.
+    original_salt, salt = salt, _normalize_re.sub(b"$2b$", salt)
+
+    hashed = _bcrypt.ffi.new("char[]", 128)
+    retval = _bcrypt.lib.bcrypt_hashpass(password, salt, hashed, len(hashed))
+
+    if retval != 0:
+        raise ValueError("Invalid salt")
+
+    # Now that we've gotten our hashed password, we want to ensure that the
+    # prefix we return is the one that was passed in, so we'll use the prefix
+    # from the original salt and concatenate that with the return value (minus
+    # the return value's prefix). This will ensure that if someone passed in a
+    # salt with a $2y$ prefix, that they get back a hash with a $2y$ prefix
+    # even though we munged it to $2b$.
+    return original_salt[:4] + _bcrypt.ffi.string(hashed)[4:]
+
+
+def checkpw(password: bytes, hashed_password: bytes) -> bool:
+    if isinstance(password, str) or isinstance(hashed_password, str):
+        raise TypeError("Strings must be encoded before checking")
+
+    if b"\x00" in password or b"\x00" in hashed_password:
+        raise ValueError(
+            "password and hashed_password may not contain NUL bytes"
+        )
+
+    ret = hashpw(password, hashed_password)
+    return hmac.compare_digest(ret, hashed_password)
+
+
+def kdf(
+    password: bytes,
+    salt: bytes,
+    desired_key_bytes: int,
+    rounds: int,
+    ignore_few_rounds: bool = False,
+) -> bytes:
+    if isinstance(password, str) or isinstance(salt, str):
+        raise TypeError("Strings must be encoded before hashing")
+
+    if len(password) == 0 or len(salt) == 0:
+        raise ValueError("password and salt must not be empty")
+
+    if desired_key_bytes <= 0 or desired_key_bytes > 512:
+        raise ValueError("desired_key_bytes must be 1-512")
+
+    if rounds < 1:
+        raise ValueError("rounds must be 1 or more")
+
+    if rounds < 50 and not ignore_few_rounds:
+        # They probably think bcrypt.kdf()'s rounds parameter is logarithmic,
+        # expecting this value to be slow enough (it probably would be if this
+        # were bcrypt). Emit a warning.
+        warnings.warn(
+            (
+                "Warning: bcrypt.kdf() called with only {0} round(s). "
+                "This few is not secure: the parameter is linear, like PBKDF2."
+            ).format(rounds),
+            UserWarning,
+            stacklevel=2,
+        )
+
+    key = _bcrypt.ffi.new("uint8_t[]", desired_key_bytes)
+    res = _bcrypt.lib.bcrypt_pbkdf(
+        password, len(password), salt, len(salt), key, len(key), rounds
+    )
+    _bcrypt_assert(res == 0)
+
+    return _bcrypt.ffi.buffer(key, desired_key_bytes)[:]
+
+
+def _bcrypt_assert(ok: bool) -> None:
+    if not ok:
+        raise SystemError("bcrypt assertion failed")
diff --git a/myenv/lib/python3.9/site-packages/bcrypt/_bcrypt.abi3.so b/myenv/lib/python3.9/site-packages/bcrypt/_bcrypt.abi3.so
new file mode 100755
index 0000000..5712368
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/bcrypt/_bcrypt.abi3.so differ
diff --git a/myenv/lib/python3.9/site-packages/bcrypt/_bcrypt.pyi b/myenv/lib/python3.9/site-packages/bcrypt/_bcrypt.pyi
new file mode 100644
index 0000000..329382a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/bcrypt/_bcrypt.pyi
@@ -0,0 +1,4 @@
+import typing
+
+ffi: typing.Any
+lib: typing.Any
diff --git a/myenv/lib/python3.9/site-packages/bcrypt/py.typed b/myenv/lib/python3.9/site-packages/bcrypt/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/AUTHORS.md b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/AUTHORS.md
new file mode 100644
index 0000000..8d112ea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/AUTHORS.md
@@ -0,0 +1,185 @@
+# Authors
+
+Glued together by [Łukasz Langa](mailto:lukasz@langa.pl).
+
+Maintained with [Carol Willing](mailto:carolcode@willingconsulting.com),
+[Carl Meyer](mailto:carl@oddbird.net),
+[Jelle Zijlstra](mailto:jelle.zijlstra@gmail.com),
+[Mika Naylor](mailto:mail@autophagy.io),
+[Zsolt Dollenstein](mailto:zsol.zsol@gmail.com),
+[Cooper Lees](mailto:me@cooperlees.com), and Richard Si.
+
+Multiple contributions by:
+
+- [Abdur-Rahmaan Janhangeer](mailto:arj.python@gmail.com)
+- [Adam Johnson](mailto:me@adamj.eu)
+- [Adam Williamson](mailto:adamw@happyassassin.net)
+- [Alexander Huynh](mailto:github@grande.coffee)
+- [Alex Vandiver](mailto:github@chmrr.net)
+- [Allan Simon](mailto:allan.simon@supinfo.com)
+- Anders-Petter Ljungquist
+- [Andrew Thorp](mailto:andrew.thorp.dev@gmail.com)
+- [Andrew Zhou](mailto:andrewfzhou@gmail.com)
+- [Andrey](mailto:dyuuus@yandex.ru)
+- [Andy Freeland](mailto:andy@andyfreeland.net)
+- [Anthony Sottile](mailto:asottile@umich.edu)
+- [Arjaan Buijk](mailto:arjaan.buijk@gmail.com)
+- [Arnav Borbornah](mailto:arnavborborah11@gmail.com)
+- [Artem Malyshev](mailto:proofit404@gmail.com)
+- [Asger Hautop Drewsen](mailto:asgerdrewsen@gmail.com)
+- [Augie Fackler](mailto:raf@durin42.com)
+- [Aviskar KC](mailto:aviskarkc10@gmail.com)
+- Batuhan Taşkaya
+- [Benjamin Wohlwend](mailto:bw@piquadrat.ch)
+- [Benjamin Woodruff](mailto:github@benjam.info)
+- [Bharat Raghunathan](mailto:bharatraghunthan9767@gmail.com)
+- [Brandt Bucher](mailto:brandtbucher@gmail.com)
+- [Brett Cannon](mailto:brett@python.org)
+- [Bryan Bugyi](mailto:bryan.bugyi@rutgers.edu)
+- [Bryan Forbes](mailto:bryan@reigndropsfall.net)
+- [Calum Lind](mailto:calumlind@gmail.com)
+- [Charles](mailto:peacech@gmail.com)
+- Charles Reid
+- [Christian Clauss](mailto:cclauss@bluewin.ch)
+- [Christian Heimes](mailto:christian@python.org)
+- [Chuck Wooters](mailto:chuck.wooters@microsoft.com)
+- [Chris Rose](mailto:offline@offby1.net)
+- Codey Oxley
+- [Cong](mailto:congusbongus@gmail.com)
+- [Cooper Ry Lees](mailto:me@cooperlees.com)
+- [Dan Davison](mailto:dandavison7@gmail.com)
+- [Daniel Hahler](mailto:github@thequod.de)
+- [Daniel M. Capella](mailto:polycitizen@gmail.com)
+- Daniele Esposti
+- [David Hotham](mailto:david.hotham@metaswitch.com)
+- [David Lukes](mailto:dafydd.lukes@gmail.com)
+- [David Szotten](mailto:davidszotten@gmail.com)
+- [Denis Laxalde](mailto:denis@laxalde.org)
+- [Douglas Thor](mailto:dthor@transphormusa.com)
+- dylanjblack
+- [Eli Treuherz](mailto:eli@treuherz.com)
+- [Emil Hessman](mailto:emil@hessman.se)
+- [Felix Kohlgrüber](mailto:felix.kohlgrueber@gmail.com)
+- [Florent Thiery](mailto:fthiery@gmail.com)
+- Francisco
+- [Giacomo Tagliabue](mailto:giacomo.tag@gmail.com)
+- [Greg Gandenberger](mailto:ggandenberger@shoprunner.com)
+- [Gregory P. Smith](mailto:greg@krypto.org)
+- Gustavo Camargo
+- hauntsaninja
+- [Hadi Alqattan](mailto:alqattanhadizaki@gmail.com)
+- [Hassan Abouelela](mailto:hassan@hassanamr.com)
+- [Heaford](mailto:dan@heaford.com)
+- [Hugo Barrera](mailto::hugo@barrera.io)
+- Hugo van Kemenade
+- [Hynek Schlawack](mailto:hs@ox.cx)
+- [Ivan Katanić](mailto:ivan.katanic@gmail.com)
+- [Jakub Kadlubiec](mailto:jakub.kadlubiec@skyscanner.net)
+- [Jakub Warczarek](mailto:jakub.warczarek@gmail.com)
+- [Jan Hnátek](mailto:jan.hnatek@gmail.com)
+- [Jason Fried](mailto:me@jasonfried.info)
+- [Jason Friedland](mailto:jason@friedland.id.au)
+- [jgirardet](mailto:ijkl@netc.fr)
+- Jim Brännlund
+- [Jimmy Jia](mailto:tesrin@gmail.com)
+- [Joe Antonakakis](mailto:jma353@cornell.edu)
+- [Jon Dufresne](mailto:jon.dufresne@gmail.com)
+- [Jonas Obrist](mailto:ojiidotch@gmail.com)
+- [Jonty Wareing](mailto:jonty@jonty.co.uk)
+- [Jose Nazario](mailto:jose.monkey.org@gmail.com)
+- [Joseph Larson](mailto:larson.joseph@gmail.com)
+- [Josh Bode](mailto:joshbode@fastmail.com)
+- [Josh Holland](mailto:anowlcalledjosh@gmail.com)
+- [Joshua Cannon](mailto:joshdcannon@gmail.com)
+- [José Padilla](mailto:jpadilla@webapplicate.com)
+- [Juan Luis Cano Rodríguez](mailto:hello@juanlu.space)
+- [kaiix](mailto:kvn.hou@gmail.com)
+- [Katie McLaughlin](mailto:katie@glasnt.com)
+- Katrin Leinweber
+- [Keith Smiley](mailto:keithbsmiley@gmail.com)
+- [Kenyon Ralph](mailto:kenyon@kenyonralph.com)
+- [Kevin Kirsche](mailto:Kev.Kirsche+GitHub@gmail.com)
+- [Kyle Hausmann](mailto:kyle.hausmann@gmail.com)
+- [Kyle Sunden](mailto:sunden@wisc.edu)
+- Lawrence Chan
+- [Linus Groh](mailto:mail@linusgroh.de)
+- [Loren Carvalho](mailto:comradeloren@gmail.com)
+- [Luka Sterbic](mailto:luka.sterbic@gmail.com)
+- [LukasDrude](mailto:mail@lukas-drude.de)
+- Mahmoud Hossam
+- Mariatta
+- [Matt VanEseltine](mailto:vaneseltine@gmail.com)
+- [Matthew Clapp](mailto:itsayellow+dev@gmail.com)
+- [Matthew Walster](mailto:matthew@walster.org)
+- Max Smolens
+- [Michael Aquilina](mailto:michaelaquilina@gmail.com)
+- [Michael Flaxman](mailto:michael.flaxman@gmail.com)
+- [Michael J. Sullivan](mailto:sully@msully.net)
+- [Michael McClimon](mailto:michael@mcclimon.org)
+- [Miguel Gaiowski](mailto:miggaiowski@gmail.com)
+- [Mike](mailto:roshi@fedoraproject.org)
+- [mikehoyio](mailto:mikehoy@gmail.com)
+- [Min ho Kim](mailto:minho42@gmail.com)
+- [Miroslav Shubernetskiy](mailto:miroslav@miki725.com)
+- MomIsBestFriend
+- [Nathan Goldbaum](mailto:ngoldbau@illinois.edu)
+- [Nathan Hunt](mailto:neighthan.hunt@gmail.com)
+- [Neraste](mailto:neraste.herr10@gmail.com)
+- [Nikolaus Waxweiler](mailto:madigens@gmail.com)
+- [Ofek Lev](mailto:ofekmeister@gmail.com)
+- [Osaetin Daniel](mailto:osaetindaniel@gmail.com)
+- [otstrel](mailto:otstrel@gmail.com)
+- [Pablo Galindo](mailto:Pablogsal@gmail.com)
+- [Paul Ganssle](mailto:p.ganssle@gmail.com)
+- [Paul Meinhardt](mailto:mnhrdt@gmail.com)
+- [Peter Bengtsson](mailto:mail@peterbe.com)
+- [Peter Grayson](mailto:pete@jpgrayson.net)
+- [Peter Stensmyr](mailto:peter.stensmyr@gmail.com)
+- pmacosta
+- [Quentin Pradet](mailto:quentin@pradet.me)
+- [Ralf Schmitt](mailto:ralf@systemexit.de)
+- [Ramón Valles](mailto:mroutis@protonmail.com)
+- [Richard Fearn](mailto:richardfearn@gmail.com)
+- [Rishikesh Jha](mailto:rishijha424@gmail.com)
+- [Rupert Bedford](mailto:rupert@rupertb.com)
+- Russell Davis
+- [Rémi Verschelde](mailto:rverschelde@gmail.com)
+- [Sami Salonen](mailto:sakki@iki.fi)
+- [Samuel Cormier-Iijima](mailto:samuel@cormier-iijima.com)
+- [Sanket Dasgupta](mailto:sanketdasgupta@gmail.com)
+- Sergi
+- [Scott Stevenson](mailto:scott@stevenson.io)
+- Shantanu
+- [shaoran](mailto:shaoran@sakuranohana.org)
+- [Shinya Fujino](mailto:shf0811@gmail.com)
+- springstan
+- [Stavros Korokithakis](mailto:hi@stavros.io)
+- [Stephen Rosen](mailto:sirosen@globus.org)
+- [Steven M. Vascellaro](mailto:S.Vascellaro@gmail.com)
+- [Sunil Kapil](mailto:snlkapil@gmail.com)
+- [Sébastien Eustace](mailto:sebastien.eustace@gmail.com)
+- [Tal Amuyal](mailto:TalAmuyal@gmail.com)
+- [Terrance](mailto:git@terrance.allofti.me)
+- [Thom Lu](mailto:thomas.c.lu@gmail.com)
+- [Thomas Grainger](mailto:tagrain@gmail.com)
+- [Tim Gates](mailto:tim.gates@iress.com)
+- [Tim Swast](mailto:swast@google.com)
+- [Timo](mailto:timo_tk@hotmail.com)
+- Toby Fleming
+- [Tom Christie](mailto:tom@tomchristie.com)
+- [Tony Narlock](mailto:tony@git-pull.com)
+- [Tsuyoshi Hombashi](mailto:tsuyoshi.hombashi@gmail.com)
+- [Tushar Chandra](mailto:tusharchandra2018@u.northwestern.edu)
+- [Tzu-ping Chung](mailto:uranusjr@gmail.com)
+- [Utsav Shah](mailto:ukshah2@illinois.edu)
+- utsav-dbx
+- vezeli
+- [Ville Skyttä](mailto:ville.skytta@iki.fi)
+- [Vishwas B Sharma](mailto:sharma.vishwas88@gmail.com)
+- [Vlad Emelianov](mailto:volshebnyi@gmail.com)
+- [williamfzc](mailto:178894043@qq.com)
+- [wouter bolsterlee](mailto:wouter@bolsterl.ee)
+- Yazdan
+- [Yngve Høiseth](mailto:yngve@hoiseth.net)
+- [Yurii Karabas](mailto:1998uriyyo@gmail.com)
+- [Zac Hatfield-Dodds](mailto:zac@zhd.dev)
diff --git a/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/LICENSE
new file mode 100644
index 0000000..7a9b891
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Łukasz Langa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/METADATA
new file mode 100644
index 0000000..7a2127f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/METADATA
@@ -0,0 +1,1112 @@
+Metadata-Version: 2.1
+Name: black
+Version: 21.12b0
+Summary: The uncompromising code formatter.
+Home-page: https://github.com/psf/black
+Author: Łukasz Langa
+Author-email: lukasz@langa.pl
+License: MIT
+Project-URL: Changelog, https://github.com/psf/black/blob/main/CHANGES.md
+Keywords: automation formatter yapf autopep8 pyfmt gofmt rustfmt
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.6.2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS.md
+Requires-Dist: click (>=7.1.2)
+Requires-Dist: platformdirs (>=2)
+Requires-Dist: tomli (<2.0.0,>=0.2.6)
+Requires-Dist: pathspec (<1,>=0.9.0)
+Requires-Dist: typing-extensions (>=3.10.0.0)
+Requires-Dist: mypy-extensions (>=0.4.3)
+Requires-Dist: dataclasses (>=0.6) ; python_version < "3.7"
+Requires-Dist: typed-ast (>=1.4.2) ; python_version < "3.8" and implementation_name == "cpython"
+Requires-Dist: typing-extensions (!=3.10.0.1) ; python_version >= "3.10"
+Provides-Extra: colorama
+Requires-Dist: colorama (>=0.4.3) ; extra == 'colorama'
+Provides-Extra: d
+Requires-Dist: aiohttp (>=3.7.4) ; extra == 'd'
+Provides-Extra: jupyter
+Requires-Dist: ipython (>=7.8.0) ; extra == 'jupyter'
+Requires-Dist: tokenize-rt (>=3.2.0) ; extra == 'jupyter'
+Provides-Extra: python2
+Requires-Dist: typed-ast (>=1.4.3) ; extra == 'python2'
+Provides-Extra: uvloop
+Requires-Dist: uvloop (>=0.15.2) ; extra == 'uvloop'
+
+![Black Logo](https://raw.githubusercontent.com/psf/black/main/docs/_static/logo2-readme.png)
+
+<h2 align="center">The Uncompromising Code Formatter</h2>
+
+<p align="center">
+<a href="https://github.com/psf/black/actions"><img alt="Actions Status" src="https://github.com/psf/black/workflows/Test/badge.svg"></a>
+<a href="https://github.com/psf/black/actions"><img alt="Actions Status" src="https://github.com/psf/black/workflows/Primer/badge.svg"></a>
+<a href="https://black.readthedocs.io/en/stable/?badge=stable"><img alt="Documentation Status" src="https://readthedocs.org/projects/black/badge/?version=stable"></a>
+<a href="https://coveralls.io/github/psf/black?branch=main"><img alt="Coverage Status" src="https://coveralls.io/repos/github/psf/black/badge.svg?branch=main"></a>
+<a href="https://github.com/psf/black/blob/main/LICENSE"><img alt="License: MIT" src="https://black.readthedocs.io/en/stable/_static/license.svg"></a>
+<a href="https://pypi.org/project/black/"><img alt="PyPI" src="https://img.shields.io/pypi/v/black"></a>
+<a href="https://pepy.tech/project/black"><img alt="Downloads" src="https://pepy.tech/badge/black"></a>
+<a href="https://anaconda.org/conda-forge/black/"><img alt="conda-forge" src="https://img.shields.io/conda/dn/conda-forge/black.svg?label=conda-forge"></a>
+<a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
+</p>
+
+> “Any color you like.”
+
+_Black_ is the uncompromising Python code formatter. By using it, you agree to cede
+control over minutiae of hand-formatting. In return, _Black_ gives you speed,
+determinism, and freedom from `pycodestyle` nagging about formatting. You will save time
+and mental energy for more important matters.
+
+Blackened code looks the same regardless of the project you're reading. Formatting
+becomes transparent after a while and you can focus on the content instead.
+
+_Black_ makes code review faster by producing the smallest diffs possible.
+
+Try it out now using the [Black Playground](https://black.vercel.app). Watch the
+[PyCon 2019 talk](https://youtu.be/esZLCuWs_2Y) to learn more.
+
+---
+
+**[Read the documentation on ReadTheDocs!](https://black.readthedocs.io/en/stable)**
+
+---
+
+## Installation and usage
+
+### Installation
+
+_Black_ can be installed by running `pip install black`. It requires Python 3.6.2+ to
+run. If you want to format Python 2 code as well, install with
+`pip install black[python2]`. If you want to format Jupyter Notebooks, install with
+`pip install black[jupyter]`.
+
+If you can't wait for the latest _hotness_ and want to install from GitHub, use:
+
+`pip install git+git://github.com/psf/black`
+
+### Usage
+
+To get started right away with sensible defaults:
+
+```sh
+black {source_file_or_directory}
+```
+
+You can run _Black_ as a package if running it as a script doesn't work:
+
+```sh
+python -m black {source_file_or_directory}
+```
+
+Further information can be found in our docs:
+
+- [Usage and Configuration](https://black.readthedocs.io/en/stable/usage_and_configuration/index.html)
+
+### NOTE: This is a beta product
+
+_Black_ is already [successfully used](https://github.com/psf/black#used-by) by many
+projects, small and big. Black has a comprehensive test suite, with efficient parallel
+tests, and our own auto formatting and parallel Continuous Integration runner. However,
+_Black_ is still beta. Things will probably be wonky for a while. This is made explicit
+by the "Beta" trove classifier, as well as by the "b" in the version number. What this
+means for you is that **until the formatter becomes stable, you should expect some
+formatting to change in the future**. That being said, no drastic stylistic changes are
+planned, mostly responses to bug reports.
+
+Also, as a safety measure which slows down processing, _Black_ will check that the
+reformatted code still produces a valid AST that is effectively equivalent to the
+original (see the
+[Pragmatism](https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#ast-before-and-after-formatting)
+section for details). If you're feeling confident, use `--fast`.
+
+## The _Black_ code style
+
+_Black_ is a PEP 8 compliant opinionated formatter. _Black_ reformats entire files in
+place. Style configuration options are deliberately limited and rarely added. It doesn't
+take previous formatting into account (see [Pragmatism](#pragmatism) for exceptions).
+
+Our documentation covers the current _Black_ code style, but planned changes to it are
+also documented. They're both worth taking a look:
+
+- [The _Black_ Code Style: Current style](https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html)
+- [The _Black_ Code Style: Future style](https://black.readthedocs.io/en/stable/the_black_code_style/future_style.html)
+
+Please refer to this document before submitting an issue. What seems like a bug might be
+intended behaviour.
+
+### Pragmatism
+
+Early versions of _Black_ used to be absolutist in some respects. They took after its
+initial author. This was fine at the time as it made the implementation simpler and
+there were not many users anyway. Not many edge cases were reported. As a mature tool,
+_Black_ does make some exceptions to rules it otherwise holds.
+
+- [The _Black_ code style: Pragmatism](https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#pragmatism)
+
+Please refer to this document before submitting an issue just like with the document
+above. What seems like a bug might be intended behaviour.
+
+## Configuration
+
+_Black_ is able to read project-specific default values for its command line options
+from a `pyproject.toml` file. This is especially useful for specifying custom
+`--include` and `--exclude`/`--force-exclude`/`--extend-exclude` patterns for your
+project.
+
+You can find more details in our documentation:
+
+- [The basics: Configuration via a file](https://black.readthedocs.io/en/stable/usage_and_configuration/the_basics.html#configuration-via-a-file)
+
+And if you're looking for more general configuration documentation:
+
+- [Usage and Configuration](https://black.readthedocs.io/en/stable/usage_and_configuration/index.html)
+
+**Pro-tip**: If you're asking yourself "Do I need to configure anything?" the answer is
+"No". _Black_ is all about sensible defaults. Applying those defaults will have your
+code in compliance with many other _Black_ formatted projects.
+
+## Used by
+
+The following notable open-source projects trust _Black_ with enforcing a consistent
+code style: pytest, tox, Pyramid, Django Channels, Hypothesis, attrs, SQLAlchemy,
+Poetry, PyPA applications (Warehouse, Bandersnatch, Pipenv, virtualenv), pandas, Pillow,
+Twisted, LocalStack, every Datadog Agent Integration, Home Assistant, Zulip, Kedro, and
+many more.
+
+The following organizations use _Black_: Facebook, Dropbox, KeepTruckin, Mozilla, Quora,
+Duolingo, QuantumBlack, Tesla.
+
+Are we missing anyone? Let us know.
+
+## Testimonials
+
+**Mike Bayer**, [author of `SQLAlchemy`](https://www.sqlalchemy.org/):
+
+> I can't think of any single tool in my entire programming career that has given me a
+> bigger productivity increase by its introduction. I can now do refactorings in about
+> 1% of the keystrokes that it would have taken me previously when we had no way for
+> code to format itself.
+
+**Dusty Phillips**,
+[writer](https://smile.amazon.com/s/ref=nb_sb_noss?url=search-alias%3Daps&field-keywords=dusty+phillips):
+
+> _Black_ is opinionated so you don't have to be.
+
+**Hynek Schlawack**, [creator of `attrs`](https://www.attrs.org/), core developer of
+Twisted and CPython:
+
+> An auto-formatter that doesn't suck is all I want for Xmas!
+
+**Carl Meyer**, [Django](https://www.djangoproject.com/) core developer:
+
+> At least the name is good.
+
+**Kenneth Reitz**, creator of [`requests`](http://python-requests.org/) and
+[`pipenv`](https://readthedocs.org/projects/pipenv/):
+
+> This vastly improves the formatting of our code. Thanks a ton!
+
+## Show your style
+
+Use the badge in your project's README.md:
+
+```md
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+```
+
+Using the badge in README.rst:
+
+```
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/psf/black
+```
+
+Looks like this:
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+## License
+
+MIT
+
+## Contributing
+
+Welcome! Happy to see you willing to make the project better. You can get started by
+reading this:
+
+- [Contributing: The basics](https://black.readthedocs.io/en/latest/contributing/the_basics.html)
+
+You can also take a look at the rest of the contributing docs or talk with the
+developers:
+
+- [Contributing documentation](https://black.readthedocs.io/en/latest/contributing/index.html)
+- [Chat on Discord](https://discord.gg/RtVdv86PrH)
+
+## Change log
+
+The log has become rather long. It moved to its own file.
+
+See [CHANGES](https://black.readthedocs.io/en/latest/change_log.html).
+
+## Authors
+
+The author list is quite long nowadays, so it lives in its own file.
+
+See [AUTHORS.md](./AUTHORS.md)
+
+## Code of Conduct
+
+Everyone participating in the _Black_ project, and in particular in the issue tracker,
+pull requests, and social media activity, is expected to treat other people with respect
+and more generally to follow the guidelines articulated in the
+[Python Community Code of Conduct](https://www.python.org/psf/codeofconduct/).
+
+At the same time, humor is encouraged. In fact, basic familiarity with Monty Python's
+Flying Circus is expected. We are not savages.
+
+And if you _really_ need to slap somebody, do it with a fish while dancing.
+
+
+# Change Log
+
+## 21.12b0
+
+### _Black_
+
+- Fix determination of f-string expression spans (#2654)
+- Fix bad formatting of error messages about EOF in multi-line statements (#2343)
+- Functions and classes in blocks now have more consistent surrounding spacing (#2472)
+
+#### Jupyter Notebook support
+
+- Cell magics are now only processed if they are known Python cell magics. Earlier, all
+  cell magics were tokenized, leading to possible indentation errors e.g. with
+  `%%writefile`. (#2630)
+- Fix assignment to environment variables in Jupyter Notebooks (#2642)
+
+#### Python 3.10 support
+
+- Point users to using `--target-version py310` if we detect 3.10-only syntax (#2668)
+- Fix `match` statements with open sequence subjects, like `match a, b:` or
+  `match a, *b:` (#2639) (#2659)
+- Fix `match`/`case` statements that contain `match`/`case` soft keywords multiple
+  times, like `match re.match()` (#2661)
+- Fix `case` statements with an inline body (#2665)
+- Fix styling of starred expressions inside `match` subject (#2667)
+- Fix parser error location on invalid syntax in a `match` statement (#2649)
+- Fix Python 3.10 support on platforms without ProcessPoolExecutor (#2631)
+- Improve parsing performance on code that uses `match` under `--target-version py310`
+  up to ~50% (#2670)
+
+### Packaging
+
+- Remove dependency on `regex` (#2644) (#2663)
+
+## 21.11b1
+
+### _Black_
+
+- Bumped regex version minimum to 2021.4.4 to fix Pattern class usage (#2621)
+
+## 21.11b0
+
+### _Black_
+
+- Warn about Python 2 deprecation in more cases by improving Python 2 only syntax
+  detection (#2592)
+- Add experimental PyPy support (#2559)
+- Add partial support for the match statement. As it's experimental, it's only enabled
+  when `--target-version py310` is explicitly specified (#2586)
+- Add support for parenthesized with (#2586)
+- Declare support for Python 3.10 for running Black (#2562)
+
+### Integrations
+
+- Fixed vim plugin with Python 3.10 by removing deprecated distutils import (#2610)
+- The vim plugin now parses `skip_magic_trailing_comma` from pyproject.toml (#2613)
+
+## 21.10b0
+
+### _Black_
+
+- Document stability policy, that will apply for non-beta releases (#2529)
+- Add new `--workers` parameter (#2514)
+- Fixed feature detection for positional-only arguments in lambdas (#2532)
+- Bumped typed-ast version minimum to 1.4.3 for 3.10 compatibility (#2519)
+- Fixed a Python 3.10 compatibility issue where the loop argument was still being passed
+  even though it has been removed (#2580)
+- Deprecate Python 2 formatting support (#2523)
+
+### _Blackd_
+
+- Remove dependency on aiohttp-cors (#2500)
+- Bump required aiohttp version to 3.7.4 (#2509)
+
+### _Black-Primer_
+
+- Add primer support for --projects (#2555)
+- Print primer summary after individual failures (#2570)
+
+### Integrations
+
+- Allow to pass `target_version` in the vim plugin (#1319)
+- Install build tools in docker file and use multi-stage build to keep the image size
+  down (#2582)
+
+## 21.9b0
+
+### Packaging
+
+- Fix missing modules in self-contained binaries (#2466)
+- Fix missing toml extra used during installation (#2475)
+
+## 21.8b0
+
+### _Black_
+
+- Add support for formatting Jupyter Notebook files (#2357)
+- Move from `appdirs` dependency to `platformdirs` (#2375)
+- Present a more user-friendly error if .gitignore is invalid (#2414)
+- The failsafe for accidentally added backslashes in f-string expressions has been
+  hardened to handle more edge cases during quote normalization (#2437)
+- Avoid changing a function return type annotation's type to a tuple by adding a
+  trailing comma (#2384)
+- Parsing support has been added for unparenthesized walruses in set literals, set
+  comprehensions, and indices (#2447).
+- Pin `setuptools-scm` build-time dependency version (#2457)
+- Exclude typing-extensions version 3.10.0.1 due to it being broken on Python 3.10
+  (#2460)
+
+### _Blackd_
+
+- Replace sys.exit(-1) with raise ImportError as it plays more nicely with tools that
+  scan installed packages (#2440)
+
+### Integrations
+
+- The provided pre-commit hooks no longer specify `language_version` to avoid overriding
+  `default_language_version` (#2430)
+
+## 21.7b0
+
+### _Black_
+
+- Configuration files using TOML features higher than spec v0.5.0 are now supported
+  (#2301)
+- Add primer support and test for code piped into black via STDIN (#2315)
+- Fix internal error when `FORCE_OPTIONAL_PARENTHESES` feature is enabled (#2332)
+- Accept empty stdin (#2346)
+- Provide a more useful error when parsing fails during AST safety checks (#2304)
+
+### Docker
+
+- Add new `latest_release` tag automation to follow latest black release on docker
+  images (#2374)
+
+### Integrations
+
+- The vim plugin now searches upwards from the directory containing the current buffer
+  instead of the current working directory for pyproject.toml. (#1871)
+- The vim plugin now reads the correct string normalization option in pyproject.toml
+  (#1869)
+- The vim plugin no longer crashes Black when there's boolean values in pyproject.toml
+  (#1869)
+
+## 21.6b0
+
+### _Black_
+
+- Fix failure caused by `fmt: skip` and indentation (#2281)
+- Account for += assignment when deciding whether to split string (#2312)
+- Correct max string length calculation when there are string operators (#2292)
+- Fixed option usage when using the `--code` flag (#2259)
+- Do not call `uvloop.install()` when _Black_ is used as a library (#2303)
+- Added `--required-version` option to require a specific version to be running (#2300)
+- Fix incorrect custom breakpoint indices when string group contains fake f-strings
+  (#2311)
+- Fix regression where `R` prefixes would be lowercased for docstrings (#2285)
+- Fix handling of named escapes (`\N{...}`) when `--experimental-string-processing` is
+  used (#2319)
+
+### Integrations
+
+- The official Black action now supports choosing what version to use, and supports the
+  major 3 OSes. (#1940)
+
+## 21.5b2
+
+### _Black_
+
+- A space is no longer inserted into empty docstrings (#2249)
+- Fix handling of .gitignore files containing non-ASCII characters on Windows (#2229)
+- Respect `.gitignore` files in all levels, not only `root/.gitignore` file (apply
+  `.gitignore` rules like `git` does) (#2225)
+- Restored compatibility with Click 8.0 on Python 3.6 when LANG=C used (#2227)
+- Add extra uvloop install + import support if in python env (#2258)
+- Fix --experimental-string-processing crash when matching parens are not found (#2283)
+- Make sure to split lines that start with a string operator (#2286)
+- Fix regular expression that black uses to identify f-expressions (#2287)
+
+### _Blackd_
+
+- Add a lower bound for the `aiohttp-cors` dependency. Only 0.4.0 or higher is
+  supported. (#2231)
+
+### Packaging
+
+- Release self-contained x86_64 MacOS binaries as part of the GitHub release pipeline
+  (#2198)
+- Always build binaries with the latest available Python (#2260)
+
+### Documentation
+
+- Add discussion of magic comments to FAQ page (#2272)
+- `--experimental-string-processing` will be enabled by default in the future (#2273)
+- Fix typos discovered by codespell (#2228)
+- Fix Vim plugin installation instructions. (#2235)
+- Add new Frequently Asked Questions page (#2247)
+- Fix encoding + symlink issues preventing proper build on Windows (#2262)
+
+## 21.5b1
+
+### _Black_
+
+- Refactor `src/black/__init__.py` into many files (#2206)
+
+### Documentation
+
+- Replaced all remaining references to the
+  [`master`](https://github.com/psf/black/tree/main) branch with the
+  [`main`](https://github.com/psf/black/tree/main) branch. Some additional changes in
+  the source code were also made. (#2210)
+- Sigificantly reorganized the documentation to make much more sense. Check them out by
+  heading over to [the stable docs on RTD](https://black.readthedocs.io/en/stable/).
+  (#2174)
+
+## 21.5b0
+
+### _Black_
+
+- Set `--pyi` mode if `--stdin-filename` ends in `.pyi` (#2169)
+- Stop detecting target version as Python 3.9+ with pre-PEP-614 decorators that are
+  being called but with no arguments (#2182)
+
+### _Black-Primer_
+
+- Add `--no-diff` to black-primer to suppress formatting changes (#2187)
+
+## 21.4b2
+
+### _Black_
+
+- Fix crash if the user configuration directory is inaccessible. (#2158)
+
+- Clarify
+  [circumstances](https://github.com/psf/black/blob/master/docs/the_black_code_style.md#pragmatism)
+  in which _Black_ may change the AST (#2159)
+
+- Allow `.gitignore` rules to be overridden by specifying `exclude` in `pyproject.toml`
+  or on the command line. (#2170)
+
+### _Packaging_
+
+- Install `primer.json` (used by `black-primer` by default) with black. (#2154)
+
+## 21.4b1
+
+### _Black_
+
+- Fix crash on docstrings ending with "\\ ". (#2142)
+
+- Fix crash when atypical whitespace is cleaned out of dostrings (#2120)
+
+- Reflect the `--skip-magic-trailing-comma` and `--experimental-string-processing` flags
+  in the name of the cache file. Without this fix, changes in these flags would not take
+  effect if the cache had already been populated. (#2131)
+
+- Don't remove necessary parentheses from assignment expression containing assert /
+  return statements. (#2143)
+
+### _Packaging_
+
+- Bump pathspec to >= 0.8.1 to solve invalid .gitignore exclusion handling
+
+## 21.4b0
+
+### _Black_
+
+- Fixed a rare but annoying formatting instability created by the combination of
+  optional trailing commas inserted by `Black` and optional parentheses looking at
+  pre-existing "magic" trailing commas. This fixes issue #1629 and all of its many many
+  duplicates. (#2126)
+
+- `Black` now processes one-line docstrings by stripping leading and trailing spaces,
+  and adding a padding space when needed to break up """". (#1740)
+
+- `Black` now cleans up leading non-breaking spaces in comments (#2092)
+
+- `Black` now respects `--skip-string-normalization` when normalizing multiline
+  docstring quotes (#1637)
+
+- `Black` no longer removes all empty lines between non-function code and decorators
+  when formatting typing stubs. Now `Black` enforces a single empty line. (#1646)
+
+- `Black` no longer adds an incorrect space after a parenthesized assignment expression
+  in if/while statements (#1655)
+
+- Added `--skip-magic-trailing-comma` / `-C` to avoid using trailing commas as a reason
+  to split lines (#1824)
+
+- fixed a crash when PWD=/ on POSIX (#1631)
+
+- fixed "I/O operation on closed file" when using --diff (#1664)
+
+- Prevent coloured diff output being interleaved with multiple files (#1673)
+
+- Added support for PEP 614 relaxed decorator syntax on python 3.9 (#1711)
+
+- Added parsing support for unparenthesized tuples and yield expressions in annotated
+  assignments (#1835)
+
+- added `--extend-exclude` argument (PR #2005)
+
+- speed up caching by avoiding pathlib (#1950)
+
+- `--diff` correctly indicates when a file doesn't end in a newline (#1662)
+
+- Added `--stdin-filename` argument to allow stdin to respect `--force-exclude` rules
+  (#1780)
+
+- Lines ending with `fmt: skip` will now be not formatted (#1800)
+
+- PR #2053: Black no longer relies on typed-ast for Python 3.8 and higher
+
+- PR #2053: Python 2 support is now optional, install with
+  `python3 -m pip install black[python2]` to maintain support.
+
+- Exclude `venv` directory by default (#1683)
+
+- Fixed "Black produced code that is not equivalent to the source" when formatting
+  Python 2 docstrings (#2037)
+
+### _Packaging_
+
+- Self-contained native _Black_ binaries are now provided for releases via GitHub
+  Releases (#1743)
+
+## 20.8b1
+
+### _Packaging_
+
+- explicitly depend on Click 7.1.2 or newer as `Black` no longer works with versions
+  older than 7.0
+
+## 20.8b0
+
+### _Black_
+
+- re-implemented support for explicit trailing commas: now it works consistently within
+  any bracket pair, including nested structures (#1288 and duplicates)
+
+- `Black` now reindents docstrings when reindenting code around it (#1053)
+
+- `Black` now shows colored diffs (#1266)
+
+- `Black` is now packaged using 'py3' tagged wheels (#1388)
+
+- `Black` now supports Python 3.8 code, e.g. star expressions in return statements
+  (#1121)
+
+- `Black` no longer normalizes capital R-string prefixes as those have a
+  community-accepted meaning (#1244)
+
+- `Black` now uses exit code 2 when specified configuration file doesn't exit (#1361)
+
+- `Black` now works on AWS Lambda (#1141)
+
+- added `--force-exclude` argument (#1032)
+
+- removed deprecated `--py36` option (#1236)
+
+- fixed `--diff` output when EOF is encountered (#526)
+
+- fixed `# fmt: off` handling around decorators (#560)
+
+- fixed unstable formatting with some `# type: ignore` comments (#1113)
+
+- fixed invalid removal on organizing brackets followed by indexing (#1575)
+
+- introduced `black-primer`, a CI tool that allows us to run regression tests against
+  existing open source users of Black (#1402)
+
+- introduced property-based fuzzing to our test suite based on Hypothesis and
+  Hypothersmith (#1566)
+
+- implemented experimental and disabled by default long string rewrapping (#1132),
+  hidden under a `--experimental-string-processing` flag while it's being worked on;
+  this is an undocumented and unsupported feature, you lose Internet points for
+  depending on it (#1609)
+
+### Vim plugin
+
+- prefer virtualenv packages over global packages (#1383)
+
+## 19.10b0
+
+- added support for PEP 572 assignment expressions (#711)
+
+- added support for PEP 570 positional-only arguments (#943)
+
+- added support for async generators (#593)
+
+- added support for pre-splitting collections by putting an explicit trailing comma
+  inside (#826)
+
+- added `black -c` as a way to format code passed from the command line (#761)
+
+- --safe now works with Python 2 code (#840)
+
+- fixed grammar selection for Python 2-specific code (#765)
+
+- fixed feature detection for trailing commas in function definitions and call sites
+  (#763)
+
+- `# fmt: off`/`# fmt: on` comment pairs placed multiple times within the same block of
+  code now behave correctly (#1005)
+
+- _Black_ no longer crashes on Windows machines with more than 61 cores (#838)
+
+- _Black_ no longer crashes on standalone comments prepended with a backslash (#767)
+
+- _Black_ no longer crashes on `from` ... `import` blocks with comments (#829)
+
+- _Black_ no longer crashes on Python 3.7 on some platform configurations (#494)
+
+- _Black_ no longer fails on comments in from-imports (#671)
+
+- _Black_ no longer fails when the file starts with a backslash (#922)
+
+- _Black_ no longer merges regular comments with type comments (#1027)
+
+- _Black_ no longer splits long lines that contain type comments (#997)
+
+- removed unnecessary parentheses around `yield` expressions (#834)
+
+- added parentheses around long tuples in unpacking assignments (#832)
+
+- added parentheses around complex powers when they are prefixed by a unary operator
+  (#646)
+
+- fixed bug that led _Black_ format some code with a line length target of 1 (#762)
+
+- _Black_ no longer introduces quotes in f-string subexpressions on string boundaries
+  (#863)
+
+- if _Black_ puts parenthesis around a single expression, it moves comments to the
+  wrapped expression instead of after the brackets (#872)
+
+- `blackd` now returns the version of _Black_ in the response headers (#1013)
+
+- `blackd` can now output the diff of formats on source code when the `X-Diff` header is
+  provided (#969)
+
+## 19.3b0
+
+- new option `--target-version` to control which Python versions _Black_-formatted code
+  should target (#618)
+
+- deprecated `--py36` (use `--target-version=py36` instead) (#724)
+
+- _Black_ no longer normalizes numeric literals to include `_` separators (#696)
+
+- long `del` statements are now split into multiple lines (#698)
+
+- type comments are no longer mangled in function signatures
+
+- improved performance of formatting deeply nested data structures (#509)
+
+- _Black_ now properly formats multiple files in parallel on Windows (#632)
+
+- _Black_ now creates cache files atomically which allows it to be used in parallel
+  pipelines (like `xargs -P8`) (#673)
+
+- _Black_ now correctly indents comments in files that were previously formatted with
+  tabs (#262)
+
+- `blackd` now supports CORS (#622)
+
+## 18.9b0
+
+- numeric literals are now formatted by _Black_ (#452, #461, #464, #469):
+
+  - numeric literals are normalized to include `_` separators on Python 3.6+ code
+
+  - added `--skip-numeric-underscore-normalization` to disable the above behavior and
+    leave numeric underscores as they were in the input
+
+  - code with `_` in numeric literals is recognized as Python 3.6+
+
+  - most letters in numeric literals are lowercased (e.g., in `1e10`, `0x01`)
+
+  - hexadecimal digits are always uppercased (e.g. `0xBADC0DE`)
+
+- added `blackd`, see
+  [its documentation](https://github.com/psf/black/blob/18.9b0/README.md#blackd) for
+  more info (#349)
+
+- adjacent string literals are now correctly split into multiple lines (#463)
+
+- trailing comma is now added to single imports that don't fit on a line (#250)
+
+- cache is now populated when `--check` is successful for a file which speeds up
+  consecutive checks of properly formatted unmodified files (#448)
+
+- whitespace at the beginning of the file is now removed (#399)
+
+- fixed mangling [pweave](http://mpastell.com/pweave/) and
+  [Spyder IDE](https://www.spyder-ide.org/) special comments (#532)
+
+- fixed unstable formatting when unpacking big tuples (#267)
+
+- fixed parsing of `__future__` imports with renames (#389)
+
+- fixed scope of `# fmt: off` when directly preceding `yield` and other nodes (#385)
+
+- fixed formatting of lambda expressions with default arguments (#468)
+
+- fixed `async for` statements: _Black_ no longer breaks them into separate lines (#372)
+
+- note: the Vim plugin stopped registering `,=` as a default chord as it turned out to
+  be a bad idea (#415)
+
+## 18.6b4
+
+- hotfix: don't freeze when multiple comments directly precede `# fmt: off` (#371)
+
+## 18.6b3
+
+- typing stub files (`.pyi`) now have blank lines added after constants (#340)
+
+- `# fmt: off` and `# fmt: on` are now much more dependable:
+
+  - they now work also within bracket pairs (#329)
+
+  - they now correctly work across function/class boundaries (#335)
+
+  - they now work when an indentation block starts with empty lines or misaligned
+    comments (#334)
+
+- made Click not fail on invalid environments; note that Click is right but the
+  likelihood we'll need to access non-ASCII file paths when dealing with Python source
+  code is low (#277)
+
+- fixed improper formatting of f-strings with quotes inside interpolated expressions
+  (#322)
+
+- fixed unnecessary slowdown when long list literals where found in a file
+
+- fixed unnecessary slowdown on AST nodes with very many siblings
+
+- fixed cannibalizing backslashes during string normalization
+
+- fixed a crash due to symbolic links pointing outside of the project directory (#338)
+
+## 18.6b2
+
+- added `--config` (#65)
+
+- added `-h` equivalent to `--help` (#316)
+
+- fixed improper unmodified file caching when `-S` was used
+
+- fixed extra space in string unpacking (#305)
+
+- fixed formatting of empty triple quoted strings (#313)
+
+- fixed unnecessary slowdown in comment placement calculation on lines without comments
+
+## 18.6b1
+
+- hotfix: don't output human-facing information on stdout (#299)
+
+- hotfix: don't output cake emoji on non-zero return code (#300)
+
+## 18.6b0
+
+- added `--include` and `--exclude` (#270)
+
+- added `--skip-string-normalization` (#118)
+
+- added `--verbose` (#283)
+
+- the header output in `--diff` now actually conforms to the unified diff spec
+
+- fixed long trivial assignments being wrapped in unnecessary parentheses (#273)
+
+- fixed unnecessary parentheses when a line contained multiline strings (#232)
+
+- fixed stdin handling not working correctly if an old version of Click was used (#276)
+
+- _Black_ now preserves line endings when formatting a file in place (#258)
+
+## 18.5b1
+
+- added `--pyi` (#249)
+
+- added `--py36` (#249)
+
+- Python grammar pickle caches are stored with the formatting caches, making _Black_
+  work in environments where site-packages is not user-writable (#192)
+
+- _Black_ now enforces a PEP 257 empty line after a class-level docstring (and/or
+  fields) and the first method
+
+- fixed invalid code produced when standalone comments were present in a trailer that
+  was omitted from line splitting on a large expression (#237)
+
+- fixed optional parentheses being removed within `# fmt: off` sections (#224)
+
+- fixed invalid code produced when stars in very long imports were incorrectly wrapped
+  in optional parentheses (#234)
+
+- fixed unstable formatting when inline comments were moved around in a trailer that was
+  omitted from line splitting on a large expression (#238)
+
+- fixed extra empty line between a class declaration and the first method if no class
+  docstring or fields are present (#219)
+
+- fixed extra empty line between a function signature and an inner function or inner
+  class (#196)
+
+## 18.5b0
+
+- call chains are now formatted according to the
+  [fluent interfaces](https://en.wikipedia.org/wiki/Fluent_interface) style (#67)
+
+- data structure literals (tuples, lists, dictionaries, and sets) are now also always
+  exploded like imports when they don't fit in a single line (#152)
+
+- slices are now formatted according to PEP 8 (#178)
+
+- parentheses are now also managed automatically on the right-hand side of assignments
+  and return statements (#140)
+
+- math operators now use their respective priorities for delimiting multiline
+  expressions (#148)
+
+- optional parentheses are now omitted on expressions that start or end with a bracket
+  and only contain a single operator (#177)
+
+- empty parentheses in a class definition are now removed (#145, #180)
+
+- string prefixes are now standardized to lowercase and `u` is removed on Python 3.6+
+  only code and Python 2.7+ code with the `unicode_literals` future import (#188, #198,
+  #199)
+
+- typing stub files (`.pyi`) are now formatted in a style that is consistent with PEP
+  484 (#207, #210)
+
+- progress when reformatting many files is now reported incrementally
+
+- fixed trailers (content with brackets) being unnecessarily exploded into their own
+  lines after a dedented closing bracket (#119)
+
+- fixed an invalid trailing comma sometimes left in imports (#185)
+
+- fixed non-deterministic formatting when multiple pairs of removable parentheses were
+  used (#183)
+
+- fixed multiline strings being unnecessarily wrapped in optional parentheses in long
+  assignments (#215)
+
+- fixed not splitting long from-imports with only a single name
+
+- fixed Python 3.6+ file discovery by also looking at function calls with unpacking.
+  This fixed non-deterministic formatting if trailing commas where used both in function
+  signatures with stars and function calls with stars but the former would be
+  reformatted to a single line.
+
+- fixed crash on dealing with optional parentheses (#193)
+
+- fixed "is", "is not", "in", and "not in" not considered operators for splitting
+  purposes
+
+- fixed crash when dead symlinks where encountered
+
+## 18.4a4
+
+- don't populate the cache on `--check` (#175)
+
+## 18.4a3
+
+- added a "cache"; files already reformatted that haven't changed on disk won't be
+  reformatted again (#109)
+
+- `--check` and `--diff` are no longer mutually exclusive (#149)
+
+- generalized star expression handling, including double stars; this fixes
+  multiplication making expressions "unsafe" for trailing commas (#132)
+
+- _Black_ no longer enforces putting empty lines behind control flow statements (#90)
+
+- _Black_ now splits imports like "Mode 3 + trailing comma" of isort (#127)
+
+- fixed comment indentation when a standalone comment closes a block (#16, #32)
+
+- fixed standalone comments receiving extra empty lines if immediately preceding a
+  class, def, or decorator (#56, #154)
+
+- fixed `--diff` not showing entire path (#130)
+
+- fixed parsing of complex expressions after star and double stars in function calls
+  (#2)
+
+- fixed invalid splitting on comma in lambda arguments (#133)
+
+- fixed missing splits of ternary expressions (#141)
+
+## 18.4a2
+
+- fixed parsing of unaligned standalone comments (#99, #112)
+
+- fixed placement of dictionary unpacking inside dictionary literals (#111)
+
+- Vim plugin now works on Windows, too
+
+- fixed unstable formatting when encountering unnecessarily escaped quotes in a string
+  (#120)
+
+## 18.4a1
+
+- added `--quiet` (#78)
+
+- added automatic parentheses management (#4)
+
+- added [pre-commit](https://pre-commit.com) integration (#103, #104)
+
+- fixed reporting on `--check` with multiple files (#101, #102)
+
+- fixed removing backslash escapes from raw strings (#100, #105)
+
+## 18.4a0
+
+- added `--diff` (#87)
+
+- add line breaks before all delimiters, except in cases like commas, to better comply
+  with PEP 8 (#73)
+
+- standardize string literals to use double quotes (almost) everywhere (#75)
+
+- fixed handling of standalone comments within nested bracketed expressions; _Black_
+  will no longer produce super long lines or put all standalone comments at the end of
+  the expression (#22)
+
+- fixed 18.3a4 regression: don't crash and burn on empty lines with trailing whitespace
+  (#80)
+
+- fixed 18.3a4 regression: `# yapf: disable` usage as trailing comment would cause
+  _Black_ to not emit the rest of the file (#95)
+
+- when CTRL+C is pressed while formatting many files, _Black_ no longer freaks out with
+  a flurry of asyncio-related exceptions
+
+- only allow up to two empty lines on module level and only single empty lines within
+  functions (#74)
+
+## 18.3a4
+
+- `# fmt: off` and `# fmt: on` are implemented (#5)
+
+- automatic detection of deprecated Python 2 forms of print statements and exec
+  statements in the formatted file (#49)
+
+- use proper spaces for complex expressions in default values of typed function
+  arguments (#60)
+
+- only return exit code 1 when --check is used (#50)
+
+- don't remove single trailing commas from square bracket indexing (#59)
+
+- don't omit whitespace if the previous factor leaf wasn't a math operator (#55)
+
+- omit extra space in kwarg unpacking if it's the first argument (#46)
+
+- omit extra space in
+  [Sphinx auto-attribute comments](http://www.sphinx-doc.org/en/stable/ext/autodoc.html#directive-autoattribute)
+  (#68)
+
+## 18.3a3
+
+- don't remove single empty lines outside of bracketed expressions (#19)
+
+- added ability to pipe formatting from stdin to stdin (#25)
+
+- restored ability to format code with legacy usage of `async` as a name (#20, #42)
+
+- even better handling of numpy-style array indexing (#33, again)
+
+## 18.3a2
+
+- changed positioning of binary operators to occur at beginning of lines instead of at
+  the end, following
+  [a recent change to PEP 8](https://github.com/python/peps/commit/c59c4376ad233a62ca4b3a6060c81368bd21e85b)
+  (#21)
+
+- ignore empty bracket pairs while splitting. This avoids very weirdly looking
+  formattings (#34, #35)
+
+- remove a trailing comma if there is a single argument to a call
+
+- if top level functions were separated by a comment, don't put four empty lines after
+  the upper function
+
+- fixed unstable formatting of newlines with imports
+
+- fixed unintentional folding of post scriptum standalone comments into last statement
+  if it was a simple statement (#18, #28)
+
+- fixed missing space in numpy-style array indexing (#33)
+
+- fixed spurious space after star-based unary expressions (#31)
+
+## 18.3a1
+
+- added `--check`
+
+- only put trailing commas in function signatures and calls if it's safe to do so. If
+  the file is Python 3.6+ it's always safe, otherwise only safe if there are no `*args`
+  or `**kwargs` used in the signature or call. (#8)
+
+- fixed invalid spacing of dots in relative imports (#6, #13)
+
+- fixed invalid splitting after comma on unpacked variables in for-loops (#23)
+
+- fixed spurious space in parenthesized set expressions (#7)
+
+- fixed spurious space after opening parentheses and in default arguments (#14, #17)
+
+- fixed spurious space after unary operators when the operand was a complex expression
+  (#15)
+
+## 18.3a0
+
+- first published version, Happy 🍰 Day 2018!
+
+- alpha quality
+
+- date-versioned (see: <https://calver.org/>)
+
+
diff --git a/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/RECORD
new file mode 100644
index 0000000..53b0b4f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/RECORD
@@ -0,0 +1,54 @@
+../../../bin/black,sha256=OxSf28OqvHfdamdUy6uj720fnq5YrNowAKX6rxRn1zo,261
+../../../bin/black-primer,sha256=83JdAPbcZRtxyDvx62xZ8PXPONS3ARcT1QGohKYEIZc,256
+../../../bin/blackd,sha256=4Ql34teLrKgP_I07BOQpKyMdTOKTbk8sTD19Js_CEZY,262
+_black_version.py,sha256=J13gsXjkb0PeiRMcxI_ff48THu--ndPguUjbwdQKirA,20
+black/__init__.py,sha256=WfrijLeAboMaGIz1VvQoxg3K0925OS3EjtNGedtQesg,44979
+black/__main__.py,sha256=mogeA4o9zt4w-ufKvaQjSEhtSgQkcMVLK9ChvdB5wH8,47
+black/brackets.py,sha256=4YGgFwSDk2hdzHaJTPF_JWoo_hdmnTGTwN7aQMWjogo,10761
+black/cache.py,sha256=fG6R1gIB7laUKJmJGGDLbvGyXV-mVV6d8OyY7sN4YnY,2342
+black/comments.py,sha256=6ybPXvmmQ7pcbNInMuUKjiP8zZlMOis5O-uUC_hMAxI,10197
+black/concurrency.py,sha256=MDDmc2LKcbai2scV2vYIas4eBmLhoThFqo4mPQcAuew,1829
+black/const.py,sha256=5jQVHjBmOqRai7fDheI-16JruvI4Nj6_7yBa6GCHMoM,249
+black/debug.py,sha256=BblF9L88hNGbuVo-EH6SzHo5jgBbFgWHyLL14zhlO3Y,1595
+black/files.py,sha256=BphFBRqiyN_l0evZZoDqjhvRTkJWB_Z3MzGGJdomceY,8448
+black/handle_ipynb_magics.py,sha256=s40Co89epSnHVz9MfdloZqWCmUiKKU7Buma9j-E5yss,13534
+black/linegen.py,sha256=znJY9M7CUF7HPacQUcnGDW6j2CNLDgVhhVSypoHEZGQ,41093
+black/lines.py,sha256=rPVcLxYuQVNeb-VOiB13QBJP04Qno6KghQuBPnv-yVY,26879
+black/mode.py,sha256=990qXazXHjHIsX33oin5Ps7K3mVQP9yqMIuzJLhW0bs,4699
+black/nodes.py,sha256=06hQf4EX3yRhnz5wvDfZN6vRPSlNCOtlxe_IZj2IkEE,24373
+black/numerics.py,sha256=zg7l1_XOtFNfcWnEd12sTsQsilAEtI3o7Rt6osdK3m4,1843
+black/output.py,sha256=sg1AEcMQ0kcS0gyD9jPESo34wpfKAd074NfcTdvNLkc,3495
+black/parsing.py,sha256=Ixr_gXf0AEC5BENp_rU4euewJ2sqO-njhwqVrJFtP6Q,10410
+black/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+black/report.py,sha256=iq4YS8A_F5zBp-HyohzNGL0w5PEJJrAnOUvOg7ddx0s,3380
+black/rusty.py,sha256=JAZPP4tU8U_WyRMQerygQ65Zthb4dM10yvtX8vjHUK4,557
+black/strings.py,sha256=ogWmRbtiIbnSwTlfIxNg3UxWYer06Y45exBFN7S_1r0,7924
+black/trans.py,sha256=v3Yj0TNSabiUbS9C6uGq7mDeAPHC2hzmsC3mvE8MXd0,76431
+black_primer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+black_primer/cli.py,sha256=V7y_LxYRWHwMWj00bqhXVeRkv97uJcO3OU-3yxO6iys,4847
+black_primer/lib.py,sha256=1IH7o7nLKlnXxRUSQ2Y0SIlqkBd9NF-3pEZb57SHGUg,13941
+black_primer/primer.json,sha256=9DFXpSGbEQNx9lUk6vnYJR3nvzwv9ImeIWfL3WRD3as,6783
+blackd/__init__.py,sha256=S_AGDXsgGUN9ZdhDx-6pPxOimtqlb2x6gpXwADEJ3OQ,7104
+blackd/middlewares.py,sha256=FDA9ve5O1YptredJmHODWa0FPElVRSUkuI-LXlqtmqQ,1207
+blib2to3/Grammar.txt,sha256=Ek2B-mvc4uoMstW1GvYcYlqXLsVo0ianhfZ-L6121Q0,11163
+blib2to3/PatternGrammar.txt,sha256=7lul2ztnIqDi--JWDrwciD5yMo75w7TaHHxdHMZJvOM,793
+blib2to3/__init__.py,sha256=9_8wL9Scv8_Cs8HJyJHGvx1vwXErsuvlsAqNZLcJQR0,8
+blib2to3/pygram.py,sha256=aY7mifSN3ddqJXtEHg0oQC-nf1b87gxuht9wrVbOaiI,5463
+blib2to3/pytree.py,sha256=jaHZDtPnUQMPmTagt26xuJ8BPGqg0lFslQHgXrOogFE,31964
+blib2to3/pgen2/__init__.py,sha256=hY6w9QUzvTvRb-MoFfd_q_7ZLt6IUHC2yxWCfsZupQA,143
+blib2to3/pgen2/conv.py,sha256=wGS0vapMV81PvxisAentOrXCZX1IlCFulQDW5Ha9Ueo,9607
+blib2to3/pgen2/driver.py,sha256=ysH9xh3jCM-K0UBiZoZIOz8E-wvgTHPnO_SCOH3r2wA,10774
+blib2to3/pgen2/grammar.py,sha256=ohZ3ZwaIGTfVz90fWRKazCYxJWVq-ZB-Ht3hItar31k,6791
+blib2to3/pgen2/literals.py,sha256=vbzw1RX0NvATBR971WwRNtp68fsXky4-pV4cBZ02_9E,1628
+blib2to3/pgen2/parse.py,sha256=RderMwR6uCnMI395EAgeCUW6Fw-gHrF7c3UVE-p_r88,13083
+blib2to3/pgen2/pgen.py,sha256=8gkqFARDLVp8tdpjxjJEP1YytCZvNrLl5tuK6SdM_nc,15491
+blib2to3/pgen2/token.py,sha256=eDZWhONvSUNGsWYzHhgBd1pIQ2HlVPP7aon0S1CLuKE,1919
+blib2to3/pgen2/tokenize.py,sha256=P41EcFKYe0bH-EaaQY2KzsWkbz-wIqSUvoUA5kgobBI,22842
+black-21.12b0.dist-info/AUTHORS.md,sha256=QkFLz3GyG9FOsxzCSs5dFyRO8VfNZ4MooKSQtK-tIgU,7699
+black-21.12b0.dist-info/LICENSE,sha256=nAQo8MO0d5hQz1vZbhGqqK_HLUqG1KNiI9erouWNbgA,1080
+black-21.12b0.dist-info/METADATA,sha256=sP67E_PJhjq7Fc4i-Guw9qfDJflioPMn8FFwqIhS468,39684
+black-21.12b0.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+black-21.12b0.dist-info/entry_points.txt,sha256=YLrV9zqlrKNpCDWkEerYGVwQlNq0Ib4g9LHgGcaqBww,116
+black-21.12b0.dist-info/top_level.txt,sha256=jGkYA_03ZBzJOsfB7YnyswRCARxXZRcCbzc3pugKwew,50
+black-21.12b0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+black-21.12b0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/WHEEL
new file mode 100644
index 0000000..5bad85f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/entry_points.txt
new file mode 100644
index 0000000..faa86e5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/entry_points.txt
@@ -0,0 +1,5 @@
+[console_scripts]
+black = black:patched_main
+black-primer = black_primer.cli:main
+blackd = blackd:patched_main [d]
+
diff --git a/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/top_level.txt
new file mode 100644
index 0000000..edff6bd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black-21.12b0.dist-info/top_level.txt
@@ -0,0 +1,5 @@
+_black_version
+black
+black_primer
+blackd
+blib2to3
diff --git a/myenv/lib/python3.9/site-packages/black/__init__.py b/myenv/lib/python3.9/site-packages/black/__init__.py
new file mode 100644
index 0000000..1923c06
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/__init__.py
@@ -0,0 +1,1377 @@
+import asyncio
+from json.decoder import JSONDecodeError
+import json
+from concurrent.futures import Executor, ThreadPoolExecutor, ProcessPoolExecutor
+from contextlib import contextmanager
+from datetime import datetime
+from enum import Enum
+import io
+from multiprocessing import Manager, freeze_support
+import os
+from pathlib import Path
+from pathspec.patterns.gitwildmatch import GitWildMatchPatternError
+import re
+import signal
+import sys
+import tokenize
+import traceback
+from typing import (
+    Any,
+    Dict,
+    Generator,
+    Iterator,
+    List,
+    MutableMapping,
+    Optional,
+    Pattern,
+    Set,
+    Sized,
+    Tuple,
+    Union,
+)
+
+import click
+from dataclasses import replace
+from mypy_extensions import mypyc_attr
+
+from black.const import DEFAULT_LINE_LENGTH, DEFAULT_INCLUDES, DEFAULT_EXCLUDES
+from black.const import STDIN_PLACEHOLDER
+from black.nodes import STARS, syms, is_simple_decorator_expression
+from black.lines import Line, EmptyLineTracker
+from black.linegen import transform_line, LineGenerator, LN
+from black.comments import normalize_fmt_off
+from black.mode import Mode, TargetVersion
+from black.mode import Feature, supports_feature, VERSION_TO_FEATURES
+from black.cache import read_cache, write_cache, get_cache_info, filter_cached, Cache
+from black.concurrency import cancel, shutdown, maybe_install_uvloop
+from black.output import dump_to_file, ipynb_diff, diff, color_diff, out, err
+from black.report import Report, Changed, NothingChanged
+from black.files import find_project_root, find_pyproject_toml, parse_pyproject_toml
+from black.files import gen_python_files, get_gitignore, normalize_path_maybe_ignore
+from black.files import wrap_stream_for_windows
+from black.parsing import InvalidInput  # noqa F401
+from black.parsing import lib2to3_parse, parse_ast, stringify_ast
+from black.handle_ipynb_magics import (
+    mask_cell,
+    unmask_cell,
+    remove_trailing_semicolon,
+    put_trailing_semicolon_back,
+    TRANSFORMED_MAGICS,
+    PYTHON_CELL_MAGICS,
+    jupyter_dependencies_are_installed,
+)
+
+
+# lib2to3 fork
+from blib2to3.pytree import Node, Leaf
+from blib2to3.pgen2 import token
+
+from _black_version import version as __version__
+
+COMPILED = Path(__file__).suffix in (".pyd", ".so")
+
+# types
+FileContent = str
+Encoding = str
+NewLine = str
+
+
+class WriteBack(Enum):
+    NO = 0
+    YES = 1
+    DIFF = 2
+    CHECK = 3
+    COLOR_DIFF = 4
+
+    @classmethod
+    def from_configuration(
+        cls, *, check: bool, diff: bool, color: bool = False
+    ) -> "WriteBack":
+        if check and not diff:
+            return cls.CHECK
+
+        if diff and color:
+            return cls.COLOR_DIFF
+
+        return cls.DIFF if diff else cls.YES
+
+
+# Legacy name, left for integrations.
+FileMode = Mode
+
+DEFAULT_WORKERS = os.cpu_count()
+
+
+def read_pyproject_toml(
+    ctx: click.Context, param: click.Parameter, value: Optional[str]
+) -> Optional[str]:
+    """Inject Black configuration from "pyproject.toml" into defaults in `ctx`.
+
+    Returns the path to a successfully found and read configuration file, None
+    otherwise.
+    """
+    if not value:
+        value = find_pyproject_toml(ctx.params.get("src", ()))
+        if value is None:
+            return None
+
+    try:
+        config = parse_pyproject_toml(value)
+    except (OSError, ValueError) as e:
+        raise click.FileError(
+            filename=value, hint=f"Error reading configuration file: {e}"
+        ) from None
+
+    if not config:
+        return None
+    else:
+        # Sanitize the values to be Click friendly. For more information please see:
+        # https://github.com/psf/black/issues/1458
+        # https://github.com/pallets/click/issues/1567
+        config = {
+            k: str(v) if not isinstance(v, (list, dict)) else v
+            for k, v in config.items()
+        }
+
+    target_version = config.get("target_version")
+    if target_version is not None and not isinstance(target_version, list):
+        raise click.BadOptionUsage(
+            "target-version", "Config key target-version must be a list"
+        )
+
+    default_map: Dict[str, Any] = {}
+    if ctx.default_map:
+        default_map.update(ctx.default_map)
+    default_map.update(config)
+
+    ctx.default_map = default_map
+    return value
+
+
+def target_version_option_callback(
+    c: click.Context, p: Union[click.Option, click.Parameter], v: Tuple[str, ...]
+) -> List[TargetVersion]:
+    """Compute the target versions from a --target-version flag.
+
+    This is its own function because mypy couldn't infer the type correctly
+    when it was a lambda, causing mypyc trouble.
+    """
+    return [TargetVersion[val.upper()] for val in v]
+
+
+def re_compile_maybe_verbose(regex: str) -> Pattern[str]:
+    """Compile a regular expression string in `regex`.
+
+    If it contains newlines, use verbose mode.
+    """
+    if "\n" in regex:
+        regex = "(?x)" + regex
+    compiled: Pattern[str] = re.compile(regex)
+    return compiled
+
+
+def validate_regex(
+    ctx: click.Context,
+    param: click.Parameter,
+    value: Optional[str],
+) -> Optional[Pattern[str]]:
+    try:
+        return re_compile_maybe_verbose(value) if value is not None else None
+    except re.error:
+        raise click.BadParameter("Not a valid regular expression") from None
+
+
+@click.command(
+    context_settings={"help_option_names": ["-h", "--help"]},
+    # While Click does set this field automatically using the docstring, mypyc
+    # (annoyingly) strips 'em so we need to set it here too.
+    help="The uncompromising code formatter.",
+)
+@click.option("-c", "--code", type=str, help="Format the code passed in as a string.")
+@click.option(
+    "-l",
+    "--line-length",
+    type=int,
+    default=DEFAULT_LINE_LENGTH,
+    help="How many characters per line to allow.",
+    show_default=True,
+)
+@click.option(
+    "-t",
+    "--target-version",
+    type=click.Choice([v.name.lower() for v in TargetVersion]),
+    callback=target_version_option_callback,
+    multiple=True,
+    help=(
+        "Python versions that should be supported by Black's output. [default: per-file"
+        " auto-detection]"
+    ),
+)
+@click.option(
+    "--pyi",
+    is_flag=True,
+    help=(
+        "Format all input files like typing stubs regardless of file extension (useful"
+        " when piping source on standard input)."
+    ),
+)
+@click.option(
+    "--ipynb",
+    is_flag=True,
+    help=(
+        "Format all input files like Jupyter Notebooks regardless of file extension "
+        "(useful when piping source on standard input)."
+    ),
+)
+@click.option(
+    "-S",
+    "--skip-string-normalization",
+    is_flag=True,
+    help="Don't normalize string quotes or prefixes.",
+)
+@click.option(
+    "-C",
+    "--skip-magic-trailing-comma",
+    is_flag=True,
+    help="Don't use trailing commas as a reason to split lines.",
+)
+@click.option(
+    "--experimental-string-processing",
+    is_flag=True,
+    hidden=True,
+    help=(
+        "Experimental option that performs more normalization on string literals."
+        " Currently disabled because it leads to some crashes."
+    ),
+)
+@click.option(
+    "--check",
+    is_flag=True,
+    help=(
+        "Don't write the files back, just return the status. Return code 0 means"
+        " nothing would change. Return code 1 means some files would be reformatted."
+        " Return code 123 means there was an internal error."
+    ),
+)
+@click.option(
+    "--diff",
+    is_flag=True,
+    help="Don't write the files back, just output a diff for each file on stdout.",
+)
+@click.option(
+    "--color/--no-color",
+    is_flag=True,
+    help="Show colored diff. Only applies when `--diff` is given.",
+)
+@click.option(
+    "--fast/--safe",
+    is_flag=True,
+    help="If --fast given, skip temporary sanity checks. [default: --safe]",
+)
+@click.option(
+    "--required-version",
+    type=str,
+    help=(
+        "Require a specific version of Black to be running (useful for unifying results"
+        " across many environments e.g. with a pyproject.toml file)."
+    ),
+)
+@click.option(
+    "--include",
+    type=str,
+    default=DEFAULT_INCLUDES,
+    callback=validate_regex,
+    help=(
+        "A regular expression that matches files and directories that should be"
+        " included on recursive searches. An empty value means all files are included"
+        " regardless of the name. Use forward slashes for directories on all platforms"
+        " (Windows, too). Exclusions are calculated first, inclusions later."
+    ),
+    show_default=True,
+)
+@click.option(
+    "--exclude",
+    type=str,
+    callback=validate_regex,
+    help=(
+        "A regular expression that matches files and directories that should be"
+        " excluded on recursive searches. An empty value means no paths are excluded."
+        " Use forward slashes for directories on all platforms (Windows, too)."
+        " Exclusions are calculated first, inclusions later. [default:"
+        f" {DEFAULT_EXCLUDES}]"
+    ),
+    show_default=False,
+)
+@click.option(
+    "--extend-exclude",
+    type=str,
+    callback=validate_regex,
+    help=(
+        "Like --exclude, but adds additional files and directories on top of the"
+        " excluded ones. (Useful if you simply want to add to the default)"
+    ),
+)
+@click.option(
+    "--force-exclude",
+    type=str,
+    callback=validate_regex,
+    help=(
+        "Like --exclude, but files and directories matching this regex will be "
+        "excluded even when they are passed explicitly as arguments."
+    ),
+)
+@click.option(
+    "--stdin-filename",
+    type=str,
+    help=(
+        "The name of the file when passing it through stdin. Useful to make "
+        "sure Black will respect --force-exclude option on some "
+        "editors that rely on using stdin."
+    ),
+)
+@click.option(
+    "-W",
+    "--workers",
+    type=click.IntRange(min=1),
+    default=DEFAULT_WORKERS,
+    show_default=True,
+    help="Number of parallel workers",
+)
+@click.option(
+    "-q",
+    "--quiet",
+    is_flag=True,
+    help=(
+        "Don't emit non-error messages to stderr. Errors are still emitted; silence"
+        " those with 2>/dev/null."
+    ),
+)
+@click.option(
+    "-v",
+    "--verbose",
+    is_flag=True,
+    help=(
+        "Also emit messages to stderr about files that were not changed or were ignored"
+        " due to exclusion patterns."
+    ),
+)
+@click.version_option(
+    version=__version__,
+    message=f"%(prog)s, %(version)s (compiled: {'yes' if COMPILED else 'no'})",
+)
+@click.argument(
+    "src",
+    nargs=-1,
+    type=click.Path(
+        exists=True, file_okay=True, dir_okay=True, readable=True, allow_dash=True
+    ),
+    is_eager=True,
+    metavar="SRC ...",
+)
+@click.option(
+    "--config",
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+        allow_dash=False,
+        path_type=str,
+    ),
+    is_eager=True,
+    callback=read_pyproject_toml,
+    help="Read configuration from FILE path.",
+)
+@click.pass_context
+def main(
+    ctx: click.Context,
+    code: Optional[str],
+    line_length: int,
+    target_version: List[TargetVersion],
+    check: bool,
+    diff: bool,
+    color: bool,
+    fast: bool,
+    pyi: bool,
+    ipynb: bool,
+    skip_string_normalization: bool,
+    skip_magic_trailing_comma: bool,
+    experimental_string_processing: bool,
+    quiet: bool,
+    verbose: bool,
+    required_version: Optional[str],
+    include: Pattern[str],
+    exclude: Optional[Pattern[str]],
+    extend_exclude: Optional[Pattern[str]],
+    force_exclude: Optional[Pattern[str]],
+    stdin_filename: Optional[str],
+    workers: int,
+    src: Tuple[str, ...],
+    config: Optional[str],
+) -> None:
+    """The uncompromising code formatter."""
+    if config and verbose:
+        out(f"Using configuration from {config}.", bold=False, fg="blue")
+
+    error_msg = "Oh no! 💥 💔 💥"
+    if required_version and required_version != __version__:
+        err(
+            f"{error_msg} The required version `{required_version}` does not match"
+            f" the running version `{__version__}`!"
+        )
+        ctx.exit(1)
+    if ipynb and pyi:
+        err("Cannot pass both `pyi` and `ipynb` flags!")
+        ctx.exit(1)
+
+    write_back = WriteBack.from_configuration(check=check, diff=diff, color=color)
+    if target_version:
+        versions = set(target_version)
+    else:
+        # We'll autodetect later.
+        versions = set()
+    mode = Mode(
+        target_versions=versions,
+        line_length=line_length,
+        is_pyi=pyi,
+        is_ipynb=ipynb,
+        string_normalization=not skip_string_normalization,
+        magic_trailing_comma=not skip_magic_trailing_comma,
+        experimental_string_processing=experimental_string_processing,
+    )
+
+    if code is not None:
+        # Run in quiet mode by default with -c; the extra output isn't useful.
+        # You can still pass -v to get verbose output.
+        quiet = True
+
+    report = Report(check=check, diff=diff, quiet=quiet, verbose=verbose)
+
+    if code is not None:
+        reformat_code(
+            content=code, fast=fast, write_back=write_back, mode=mode, report=report
+        )
+    else:
+        try:
+            sources = get_sources(
+                ctx=ctx,
+                src=src,
+                quiet=quiet,
+                verbose=verbose,
+                include=include,
+                exclude=exclude,
+                extend_exclude=extend_exclude,
+                force_exclude=force_exclude,
+                report=report,
+                stdin_filename=stdin_filename,
+            )
+        except GitWildMatchPatternError:
+            ctx.exit(1)
+
+        path_empty(
+            sources,
+            "No Python files are present to be formatted. Nothing to do 😴",
+            quiet,
+            verbose,
+            ctx,
+        )
+
+        if len(sources) == 1:
+            reformat_one(
+                src=sources.pop(),
+                fast=fast,
+                write_back=write_back,
+                mode=mode,
+                report=report,
+            )
+        else:
+            reformat_many(
+                sources=sources,
+                fast=fast,
+                write_back=write_back,
+                mode=mode,
+                report=report,
+                workers=workers,
+            )
+
+    if verbose or not quiet:
+        out(error_msg if report.return_code else "All done! ✨ 🍰 ✨")
+        if code is None:
+            click.echo(str(report), err=True)
+    ctx.exit(report.return_code)
+
+
+def get_sources(
+    *,
+    ctx: click.Context,
+    src: Tuple[str, ...],
+    quiet: bool,
+    verbose: bool,
+    include: Pattern[str],
+    exclude: Optional[Pattern[str]],
+    extend_exclude: Optional[Pattern[str]],
+    force_exclude: Optional[Pattern[str]],
+    report: "Report",
+    stdin_filename: Optional[str],
+) -> Set[Path]:
+    """Compute the set of files to be formatted."""
+
+    root = find_project_root(src)
+    sources: Set[Path] = set()
+    path_empty(src, "No Path provided. Nothing to do 😴", quiet, verbose, ctx)
+
+    if exclude is None:
+        exclude = re_compile_maybe_verbose(DEFAULT_EXCLUDES)
+        gitignore = get_gitignore(root)
+    else:
+        gitignore = None
+
+    for s in src:
+        if s == "-" and stdin_filename:
+            p = Path(stdin_filename)
+            is_stdin = True
+        else:
+            p = Path(s)
+            is_stdin = False
+
+        if is_stdin or p.is_file():
+            normalized_path = normalize_path_maybe_ignore(p, root, report)
+            if normalized_path is None:
+                continue
+
+            normalized_path = "/" + normalized_path
+            # Hard-exclude any files that matches the `--force-exclude` regex.
+            if force_exclude:
+                force_exclude_match = force_exclude.search(normalized_path)
+            else:
+                force_exclude_match = None
+            if force_exclude_match and force_exclude_match.group(0):
+                report.path_ignored(p, "matches the --force-exclude regular expression")
+                continue
+
+            if is_stdin:
+                p = Path(f"{STDIN_PLACEHOLDER}{str(p)}")
+
+            if p.suffix == ".ipynb" and not jupyter_dependencies_are_installed(
+                verbose=verbose, quiet=quiet
+            ):
+                continue
+
+            sources.add(p)
+        elif p.is_dir():
+            sources.update(
+                gen_python_files(
+                    p.iterdir(),
+                    root,
+                    include,
+                    exclude,
+                    extend_exclude,
+                    force_exclude,
+                    report,
+                    gitignore,
+                    verbose=verbose,
+                    quiet=quiet,
+                )
+            )
+        elif s == "-":
+            sources.add(p)
+        else:
+            err(f"invalid path: {s}")
+    return sources
+
+
+def path_empty(
+    src: Sized, msg: str, quiet: bool, verbose: bool, ctx: click.Context
+) -> None:
+    """
+    Exit if there is no `src` provided for formatting
+    """
+    if not src:
+        if verbose or not quiet:
+            out(msg)
+        ctx.exit(0)
+
+
+def reformat_code(
+    content: str, fast: bool, write_back: WriteBack, mode: Mode, report: Report
+) -> None:
+    """
+    Reformat and print out `content` without spawning child processes.
+    Similar to `reformat_one`, but for string content.
+
+    `fast`, `write_back`, and `mode` options are passed to
+    :func:`format_file_in_place` or :func:`format_stdin_to_stdout`.
+    """
+    path = Path("<string>")
+    try:
+        changed = Changed.NO
+        if format_stdin_to_stdout(
+            content=content, fast=fast, write_back=write_back, mode=mode
+        ):
+            changed = Changed.YES
+        report.done(path, changed)
+    except Exception as exc:
+        if report.verbose:
+            traceback.print_exc()
+        report.failed(path, str(exc))
+
+
+def reformat_one(
+    src: Path, fast: bool, write_back: WriteBack, mode: Mode, report: "Report"
+) -> None:
+    """Reformat a single file under `src` without spawning child processes.
+
+    `fast`, `write_back`, and `mode` options are passed to
+    :func:`format_file_in_place` or :func:`format_stdin_to_stdout`.
+    """
+    try:
+        changed = Changed.NO
+
+        if str(src) == "-":
+            is_stdin = True
+        elif str(src).startswith(STDIN_PLACEHOLDER):
+            is_stdin = True
+            # Use the original name again in case we want to print something
+            # to the user
+            src = Path(str(src)[len(STDIN_PLACEHOLDER) :])
+        else:
+            is_stdin = False
+
+        if is_stdin:
+            if src.suffix == ".pyi":
+                mode = replace(mode, is_pyi=True)
+            elif src.suffix == ".ipynb":
+                mode = replace(mode, is_ipynb=True)
+            if format_stdin_to_stdout(fast=fast, write_back=write_back, mode=mode):
+                changed = Changed.YES
+        else:
+            cache: Cache = {}
+            if write_back not in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
+                cache = read_cache(mode)
+                res_src = src.resolve()
+                res_src_s = str(res_src)
+                if res_src_s in cache and cache[res_src_s] == get_cache_info(res_src):
+                    changed = Changed.CACHED
+            if changed is not Changed.CACHED and format_file_in_place(
+                src, fast=fast, write_back=write_back, mode=mode
+            ):
+                changed = Changed.YES
+            if (write_back is WriteBack.YES and changed is not Changed.CACHED) or (
+                write_back is WriteBack.CHECK and changed is Changed.NO
+            ):
+                write_cache(cache, [src], mode)
+        report.done(src, changed)
+    except Exception as exc:
+        if report.verbose:
+            traceback.print_exc()
+        report.failed(src, str(exc))
+
+
+# diff-shades depends on being to monkeypatch this function to operate. I know it's
+# not ideal, but this shouldn't cause any issues ... hopefully. ~ichard26
+@mypyc_attr(patchable=True)
+def reformat_many(
+    sources: Set[Path],
+    fast: bool,
+    write_back: WriteBack,
+    mode: Mode,
+    report: "Report",
+    workers: Optional[int],
+) -> None:
+    """Reformat multiple files using a ProcessPoolExecutor."""
+    executor: Executor
+    loop = asyncio.get_event_loop()
+    worker_count = workers if workers is not None else DEFAULT_WORKERS
+    if sys.platform == "win32":
+        # Work around https://bugs.python.org/issue26903
+        assert worker_count is not None
+        worker_count = min(worker_count, 60)
+    try:
+        executor = ProcessPoolExecutor(max_workers=worker_count)
+    except (ImportError, NotImplementedError, OSError):
+        # we arrive here if the underlying system does not support multi-processing
+        # like in AWS Lambda or Termux, in which case we gracefully fallback to
+        # a ThreadPoolExecutor with just a single worker (more workers would not do us
+        # any good due to the Global Interpreter Lock)
+        executor = ThreadPoolExecutor(max_workers=1)
+
+    try:
+        loop.run_until_complete(
+            schedule_formatting(
+                sources=sources,
+                fast=fast,
+                write_back=write_back,
+                mode=mode,
+                report=report,
+                loop=loop,
+                executor=executor,
+            )
+        )
+    finally:
+        shutdown(loop)
+        if executor is not None:
+            executor.shutdown()
+
+
+async def schedule_formatting(
+    sources: Set[Path],
+    fast: bool,
+    write_back: WriteBack,
+    mode: Mode,
+    report: "Report",
+    loop: asyncio.AbstractEventLoop,
+    executor: Executor,
+) -> None:
+    """Run formatting of `sources` in parallel using the provided `executor`.
+
+    (Use ProcessPoolExecutors for actual parallelism.)
+
+    `write_back`, `fast`, and `mode` options are passed to
+    :func:`format_file_in_place`.
+    """
+    cache: Cache = {}
+    if write_back not in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
+        cache = read_cache(mode)
+        sources, cached = filter_cached(cache, sources)
+        for src in sorted(cached):
+            report.done(src, Changed.CACHED)
+    if not sources:
+        return
+
+    cancelled = []
+    sources_to_cache = []
+    lock = None
+    if write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
+        # For diff output, we need locks to ensure we don't interleave output
+        # from different processes.
+        manager = Manager()
+        lock = manager.Lock()
+    tasks = {
+        asyncio.ensure_future(
+            loop.run_in_executor(
+                executor, format_file_in_place, src, fast, mode, write_back, lock
+            )
+        ): src
+        for src in sorted(sources)
+    }
+    pending = tasks.keys()
+    try:
+        loop.add_signal_handler(signal.SIGINT, cancel, pending)
+        loop.add_signal_handler(signal.SIGTERM, cancel, pending)
+    except NotImplementedError:
+        # There are no good alternatives for these on Windows.
+        pass
+    while pending:
+        done, _ = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
+        for task in done:
+            src = tasks.pop(task)
+            if task.cancelled():
+                cancelled.append(task)
+            elif task.exception():
+                report.failed(src, str(task.exception()))
+            else:
+                changed = Changed.YES if task.result() else Changed.NO
+                # If the file was written back or was successfully checked as
+                # well-formatted, store this information in the cache.
+                if write_back is WriteBack.YES or (
+                    write_back is WriteBack.CHECK and changed is Changed.NO
+                ):
+                    sources_to_cache.append(src)
+                report.done(src, changed)
+    if cancelled:
+        if sys.version_info >= (3, 7):
+            await asyncio.gather(*cancelled, return_exceptions=True)
+        else:
+            await asyncio.gather(*cancelled, loop=loop, return_exceptions=True)
+    if sources_to_cache:
+        write_cache(cache, sources_to_cache, mode)
+
+
+def format_file_in_place(
+    src: Path,
+    fast: bool,
+    mode: Mode,
+    write_back: WriteBack = WriteBack.NO,
+    lock: Any = None,  # multiprocessing.Manager().Lock() is some crazy proxy
+) -> bool:
+    """Format file under `src` path. Return True if changed.
+
+    If `write_back` is DIFF, write a diff to stdout. If it is YES, write reformatted
+    code to the file.
+    `mode` and `fast` options are passed to :func:`format_file_contents`.
+    """
+    if src.suffix == ".pyi":
+        mode = replace(mode, is_pyi=True)
+    elif src.suffix == ".ipynb":
+        mode = replace(mode, is_ipynb=True)
+
+    then = datetime.utcfromtimestamp(src.stat().st_mtime)
+    with open(src, "rb") as buf:
+        src_contents, encoding, newline = decode_bytes(buf.read())
+    try:
+        dst_contents = format_file_contents(src_contents, fast=fast, mode=mode)
+    except NothingChanged:
+        return False
+    except JSONDecodeError:
+        raise ValueError(
+            f"File '{src}' cannot be parsed as valid Jupyter notebook."
+        ) from None
+
+    if write_back == WriteBack.YES:
+        with open(src, "w", encoding=encoding, newline=newline) as f:
+            f.write(dst_contents)
+    elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
+        now = datetime.utcnow()
+        src_name = f"{src}\t{then} +0000"
+        dst_name = f"{src}\t{now} +0000"
+        if mode.is_ipynb:
+            diff_contents = ipynb_diff(src_contents, dst_contents, src_name, dst_name)
+        else:
+            diff_contents = diff(src_contents, dst_contents, src_name, dst_name)
+
+        if write_back == WriteBack.COLOR_DIFF:
+            diff_contents = color_diff(diff_contents)
+
+        with lock or nullcontext():
+            f = io.TextIOWrapper(
+                sys.stdout.buffer,
+                encoding=encoding,
+                newline=newline,
+                write_through=True,
+            )
+            f = wrap_stream_for_windows(f)
+            f.write(diff_contents)
+            f.detach()
+
+    return True
+
+
+def format_stdin_to_stdout(
+    fast: bool,
+    *,
+    content: Optional[str] = None,
+    write_back: WriteBack = WriteBack.NO,
+    mode: Mode,
+) -> bool:
+    """Format file on stdin. Return True if changed.
+
+    If content is None, it's read from sys.stdin.
+
+    If `write_back` is YES, write reformatted code back to stdout. If it is DIFF,
+    write a diff to stdout. The `mode` argument is passed to
+    :func:`format_file_contents`.
+    """
+    then = datetime.utcnow()
+
+    if content is None:
+        src, encoding, newline = decode_bytes(sys.stdin.buffer.read())
+    else:
+        src, encoding, newline = content, "utf-8", ""
+
+    dst = src
+    try:
+        dst = format_file_contents(src, fast=fast, mode=mode)
+        return True
+
+    except NothingChanged:
+        return False
+
+    finally:
+        f = io.TextIOWrapper(
+            sys.stdout.buffer, encoding=encoding, newline=newline, write_through=True
+        )
+        if write_back == WriteBack.YES:
+            # Make sure there's a newline after the content
+            if dst and dst[-1] != "\n":
+                dst += "\n"
+            f.write(dst)
+        elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
+            now = datetime.utcnow()
+            src_name = f"STDIN\t{then} +0000"
+            dst_name = f"STDOUT\t{now} +0000"
+            d = diff(src, dst, src_name, dst_name)
+            if write_back == WriteBack.COLOR_DIFF:
+                d = color_diff(d)
+                f = wrap_stream_for_windows(f)
+            f.write(d)
+        f.detach()
+
+
+def check_stability_and_equivalence(
+    src_contents: str, dst_contents: str, *, mode: Mode
+) -> None:
+    """Perform stability and equivalence checks.
+
+    Raise AssertionError if source and destination contents are not
+    equivalent, or if a second pass of the formatter would format the
+    content differently.
+    """
+    assert_equivalent(src_contents, dst_contents)
+
+    # Forced second pass to work around optional trailing commas (becoming
+    # forced trailing commas on pass 2) interacting differently with optional
+    # parentheses.  Admittedly ugly.
+    dst_contents_pass2 = format_str(dst_contents, mode=mode)
+    if dst_contents != dst_contents_pass2:
+        dst_contents = dst_contents_pass2
+        assert_equivalent(src_contents, dst_contents, pass_num=2)
+        assert_stable(src_contents, dst_contents, mode=mode)
+    # Note: no need to explicitly call `assert_stable` if `dst_contents` was
+    # the same as `dst_contents_pass2`.
+
+
+def format_file_contents(src_contents: str, *, fast: bool, mode: Mode) -> FileContent:
+    """Reformat contents of a file and return new contents.
+
+    If `fast` is False, additionally confirm that the reformatted code is
+    valid by calling :func:`assert_equivalent` and :func:`assert_stable` on it.
+    `mode` is passed to :func:`format_str`.
+    """
+    if not src_contents.strip():
+        raise NothingChanged
+
+    if mode.is_ipynb:
+        dst_contents = format_ipynb_string(src_contents, fast=fast, mode=mode)
+    else:
+        dst_contents = format_str(src_contents, mode=mode)
+    if src_contents == dst_contents:
+        raise NothingChanged
+
+    if not fast and not mode.is_ipynb:
+        # Jupyter notebooks will already have been checked above.
+        check_stability_and_equivalence(src_contents, dst_contents, mode=mode)
+    return dst_contents
+
+
+def validate_cell(src: str) -> None:
+    """Check that cell does not already contain TransformerManager transformations,
+    or non-Python cell magics, which might cause tokenizer_rt to break because of
+    indentations.
+
+    If a cell contains ``!ls``, then it'll be transformed to
+    ``get_ipython().system('ls')``. However, if the cell originally contained
+    ``get_ipython().system('ls')``, then it would get transformed in the same way:
+
+        >>> TransformerManager().transform_cell("get_ipython().system('ls')")
+        "get_ipython().system('ls')\n"
+        >>> TransformerManager().transform_cell("!ls")
+        "get_ipython().system('ls')\n"
+
+    Due to the impossibility of safely roundtripping in such situations, cells
+    containing transformed magics will be ignored.
+    """
+    if any(transformed_magic in src for transformed_magic in TRANSFORMED_MAGICS):
+        raise NothingChanged
+    if src[:2] == "%%" and src.split()[0][2:] not in PYTHON_CELL_MAGICS:
+        raise NothingChanged
+
+
+def format_cell(src: str, *, fast: bool, mode: Mode) -> str:
+    """Format code in given cell of Jupyter notebook.
+
+    General idea is:
+
+      - if cell has trailing semicolon, remove it;
+      - if cell has IPython magics, mask them;
+      - format cell;
+      - reinstate IPython magics;
+      - reinstate trailing semicolon (if originally present);
+      - strip trailing newlines.
+
+    Cells with syntax errors will not be processed, as they
+    could potentially be automagics or multi-line magics, which
+    are currently not supported.
+    """
+    validate_cell(src)
+    src_without_trailing_semicolon, has_trailing_semicolon = remove_trailing_semicolon(
+        src
+    )
+    try:
+        masked_src, replacements = mask_cell(src_without_trailing_semicolon)
+    except SyntaxError:
+        raise NothingChanged from None
+    masked_dst = format_str(masked_src, mode=mode)
+    if not fast:
+        check_stability_and_equivalence(masked_src, masked_dst, mode=mode)
+    dst_without_trailing_semicolon = unmask_cell(masked_dst, replacements)
+    dst = put_trailing_semicolon_back(
+        dst_without_trailing_semicolon, has_trailing_semicolon
+    )
+    dst = dst.rstrip("\n")
+    if dst == src:
+        raise NothingChanged from None
+    return dst
+
+
+def validate_metadata(nb: MutableMapping[str, Any]) -> None:
+    """If notebook is marked as non-Python, don't format it.
+
+    All notebook metadata fields are optional, see
+    https://nbformat.readthedocs.io/en/latest/format_description.html. So
+    if a notebook has empty metadata, we will try to parse it anyway.
+    """
+    language = nb.get("metadata", {}).get("language_info", {}).get("name", None)
+    if language is not None and language != "python":
+        raise NothingChanged from None
+
+
+def format_ipynb_string(src_contents: str, *, fast: bool, mode: Mode) -> FileContent:
+    """Format Jupyter notebook.
+
+    Operate cell-by-cell, only on code cells, only for Python notebooks.
+    If the ``.ipynb`` originally had a trailing newline, it'll be preserved.
+    """
+    trailing_newline = src_contents[-1] == "\n"
+    modified = False
+    nb = json.loads(src_contents)
+    validate_metadata(nb)
+    for cell in nb["cells"]:
+        if cell.get("cell_type", None) == "code":
+            try:
+                src = "".join(cell["source"])
+                dst = format_cell(src, fast=fast, mode=mode)
+            except NothingChanged:
+                pass
+            else:
+                cell["source"] = dst.splitlines(keepends=True)
+                modified = True
+    if modified:
+        dst_contents = json.dumps(nb, indent=1, ensure_ascii=False)
+        if trailing_newline:
+            dst_contents = dst_contents + "\n"
+        return dst_contents
+    else:
+        raise NothingChanged
+
+
+def format_str(src_contents: str, *, mode: Mode) -> FileContent:
+    """Reformat a string and return new contents.
+
+    `mode` determines formatting options, such as how many characters per line are
+    allowed.  Example:
+
+    >>> import black
+    >>> print(black.format_str("def f(arg:str='')->None:...", mode=black.Mode()))
+    def f(arg: str = "") -> None:
+        ...
+
+    A more complex example:
+
+    >>> print(
+    ...   black.format_str(
+    ...     "def f(arg:str='')->None: hey",
+    ...     mode=black.Mode(
+    ...       target_versions={black.TargetVersion.PY36},
+    ...       line_length=10,
+    ...       string_normalization=False,
+    ...       is_pyi=False,
+    ...     ),
+    ...   ),
+    ... )
+    def f(
+        arg: str = '',
+    ) -> None:
+        hey
+
+    """
+    src_node = lib2to3_parse(src_contents.lstrip(), mode.target_versions)
+    dst_contents = []
+    future_imports = get_future_imports(src_node)
+    if mode.target_versions:
+        versions = mode.target_versions
+    else:
+        versions = detect_target_versions(src_node)
+
+    # TODO: fully drop support and this code hopefully in January 2022 :D
+    if TargetVersion.PY27 in mode.target_versions or versions == {TargetVersion.PY27}:
+        msg = (
+            "DEPRECATION: Python 2 support will be removed in the first stable release "
+            "expected in January 2022."
+        )
+        err(msg, fg="yellow", bold=True)
+
+    normalize_fmt_off(src_node)
+    lines = LineGenerator(
+        mode=mode,
+        remove_u_prefix="unicode_literals" in future_imports
+        or supports_feature(versions, Feature.UNICODE_LITERALS),
+    )
+    elt = EmptyLineTracker(is_pyi=mode.is_pyi)
+    empty_line = Line(mode=mode)
+    after = 0
+    split_line_features = {
+        feature
+        for feature in {Feature.TRAILING_COMMA_IN_CALL, Feature.TRAILING_COMMA_IN_DEF}
+        if supports_feature(versions, feature)
+    }
+    for current_line in lines.visit(src_node):
+        dst_contents.append(str(empty_line) * after)
+        before, after = elt.maybe_empty_lines(current_line)
+        dst_contents.append(str(empty_line) * before)
+        for line in transform_line(
+            current_line, mode=mode, features=split_line_features
+        ):
+            dst_contents.append(str(line))
+    return "".join(dst_contents)
+
+
+def decode_bytes(src: bytes) -> Tuple[FileContent, Encoding, NewLine]:
+    """Return a tuple of (decoded_contents, encoding, newline).
+
+    `newline` is either CRLF or LF but `decoded_contents` is decoded with
+    universal newlines (i.e. only contains LF).
+    """
+    srcbuf = io.BytesIO(src)
+    encoding, lines = tokenize.detect_encoding(srcbuf.readline)
+    if not lines:
+        return "", encoding, "\n"
+
+    newline = "\r\n" if b"\r\n" == lines[0][-2:] else "\n"
+    srcbuf.seek(0)
+    with io.TextIOWrapper(srcbuf, encoding) as tiow:
+        return tiow.read(), encoding, newline
+
+
+def get_features_used(node: Node) -> Set[Feature]:  # noqa: C901
+    """Return a set of (relatively) new Python features used in this file.
+
+    Currently looking for:
+    - f-strings;
+    - underscores in numeric literals;
+    - trailing commas after * or ** in function signatures and calls;
+    - positional only arguments in function signatures and lambdas;
+    - assignment expression;
+    - relaxed decorator syntax;
+    - print / exec statements;
+    """
+    features: Set[Feature] = set()
+    for n in node.pre_order():
+        if n.type == token.STRING:
+            value_head = n.value[:2]  # type: ignore
+            if value_head in {'f"', 'F"', "f'", "F'", "rf", "fr", "RF", "FR"}:
+                features.add(Feature.F_STRINGS)
+
+        elif n.type == token.NUMBER:
+            assert isinstance(n, Leaf)
+            if "_" in n.value:
+                features.add(Feature.NUMERIC_UNDERSCORES)
+            elif n.value.endswith(("L", "l")):
+                # Python 2: 10L
+                features.add(Feature.LONG_INT_LITERAL)
+            elif len(n.value) >= 2 and n.value[0] == "0" and n.value[1].isdigit():
+                # Python 2: 0123; 00123; ...
+                if not all(char == "0" for char in n.value):
+                    # although we don't want to match 0000 or similar
+                    features.add(Feature.OCTAL_INT_LITERAL)
+
+        elif n.type == token.SLASH:
+            if n.parent and n.parent.type in {
+                syms.typedargslist,
+                syms.arglist,
+                syms.varargslist,
+            }:
+                features.add(Feature.POS_ONLY_ARGUMENTS)
+
+        elif n.type == token.COLONEQUAL:
+            features.add(Feature.ASSIGNMENT_EXPRESSIONS)
+
+        elif n.type == syms.decorator:
+            if len(n.children) > 1 and not is_simple_decorator_expression(
+                n.children[1]
+            ):
+                features.add(Feature.RELAXED_DECORATORS)
+
+        elif (
+            n.type in {syms.typedargslist, syms.arglist}
+            and n.children
+            and n.children[-1].type == token.COMMA
+        ):
+            if n.type == syms.typedargslist:
+                feature = Feature.TRAILING_COMMA_IN_DEF
+            else:
+                feature = Feature.TRAILING_COMMA_IN_CALL
+
+            for ch in n.children:
+                if ch.type in STARS:
+                    features.add(feature)
+
+                if ch.type == syms.argument:
+                    for argch in ch.children:
+                        if argch.type in STARS:
+                            features.add(feature)
+
+        # Python 2 only features (for its deprecation) except for integers, see above
+        elif n.type == syms.print_stmt:
+            features.add(Feature.PRINT_STMT)
+        elif n.type == syms.exec_stmt:
+            features.add(Feature.EXEC_STMT)
+        elif n.type == syms.tfpdef:
+            # def set_position((x, y), value):
+            #     ...
+            features.add(Feature.AUTOMATIC_PARAMETER_UNPACKING)
+        elif n.type == syms.except_clause:
+            # try:
+            #     ...
+            # except Exception, err:
+            #     ...
+            if len(n.children) >= 4:
+                if n.children[-2].type == token.COMMA:
+                    features.add(Feature.COMMA_STYLE_EXCEPT)
+        elif n.type == syms.raise_stmt:
+            # raise Exception, "msg"
+            if len(n.children) >= 4:
+                if n.children[-2].type == token.COMMA:
+                    features.add(Feature.COMMA_STYLE_RAISE)
+        elif n.type == token.BACKQUOTE:
+            # `i'm surprised this ever existed`
+            features.add(Feature.BACKQUOTE_REPR)
+
+    return features
+
+
+def detect_target_versions(node: Node) -> Set[TargetVersion]:
+    """Detect the version to target based on the nodes used."""
+    features = get_features_used(node)
+    return {
+        version for version in TargetVersion if features <= VERSION_TO_FEATURES[version]
+    }
+
+
+def get_future_imports(node: Node) -> Set[str]:
+    """Return a set of __future__ imports in the file."""
+    imports: Set[str] = set()
+
+    def get_imports_from_children(children: List[LN]) -> Generator[str, None, None]:
+        for child in children:
+            if isinstance(child, Leaf):
+                if child.type == token.NAME:
+                    yield child.value
+
+            elif child.type == syms.import_as_name:
+                orig_name = child.children[0]
+                assert isinstance(orig_name, Leaf), "Invalid syntax parsing imports"
+                assert orig_name.type == token.NAME, "Invalid syntax parsing imports"
+                yield orig_name.value
+
+            elif child.type == syms.import_as_names:
+                yield from get_imports_from_children(child.children)
+
+            else:
+                raise AssertionError("Invalid syntax parsing imports")
+
+    for child in node.children:
+        if child.type != syms.simple_stmt:
+            break
+
+        first_child = child.children[0]
+        if isinstance(first_child, Leaf):
+            # Continue looking if we see a docstring; otherwise stop.
+            if (
+                len(child.children) == 2
+                and first_child.type == token.STRING
+                and child.children[1].type == token.NEWLINE
+            ):
+                continue
+
+            break
+
+        elif first_child.type == syms.import_from:
+            module_name = first_child.children[1]
+            if not isinstance(module_name, Leaf) or module_name.value != "__future__":
+                break
+
+            imports |= set(get_imports_from_children(first_child.children[3:]))
+        else:
+            break
+
+    return imports
+
+
+def assert_equivalent(src: str, dst: str, *, pass_num: int = 1) -> None:
+    """Raise AssertionError if `src` and `dst` aren't equivalent."""
+    try:
+        src_ast = parse_ast(src)
+    except Exception as exc:
+        raise AssertionError(
+            "cannot use --safe with this file; failed to parse source file."
+        ) from exc
+
+    try:
+        dst_ast = parse_ast(dst)
+    except Exception as exc:
+        log = dump_to_file("".join(traceback.format_tb(exc.__traceback__)), dst)
+        raise AssertionError(
+            f"INTERNAL ERROR: Black produced invalid code on pass {pass_num}: {exc}. "
+            "Please report a bug on https://github.com/psf/black/issues.  "
+            f"This invalid output might be helpful: {log}"
+        ) from None
+
+    src_ast_str = "\n".join(stringify_ast(src_ast))
+    dst_ast_str = "\n".join(stringify_ast(dst_ast))
+    if src_ast_str != dst_ast_str:
+        log = dump_to_file(diff(src_ast_str, dst_ast_str, "src", "dst"))
+        raise AssertionError(
+            "INTERNAL ERROR: Black produced code that is not equivalent to the"
+            f" source on pass {pass_num}.  Please report a bug on "
+            f"https://github.com/psf/black/issues.  This diff might be helpful: {log}"
+        ) from None
+
+
+def assert_stable(src: str, dst: str, mode: Mode) -> None:
+    """Raise AssertionError if `dst` reformats differently the second time."""
+    newdst = format_str(dst, mode=mode)
+    if dst != newdst:
+        log = dump_to_file(
+            str(mode),
+            diff(src, dst, "source", "first pass"),
+            diff(dst, newdst, "first pass", "second pass"),
+        )
+        raise AssertionError(
+            "INTERNAL ERROR: Black produced different code on the second pass of the"
+            " formatter.  Please report a bug on https://github.com/psf/black/issues."
+            f"  This diff might be helpful: {log}"
+        ) from None
+
+
+@contextmanager
+def nullcontext() -> Iterator[None]:
+    """Return an empty context manager.
+
+    To be used like `nullcontext` in Python 3.7.
+    """
+    yield
+
+
+def patch_click() -> None:
+    """Make Click not crash on Python 3.6 with LANG=C.
+
+    On certain misconfigured environments, Python 3 selects the ASCII encoding as the
+    default which restricts paths that it can access during the lifetime of the
+    application.  Click refuses to work in this scenario by raising a RuntimeError.
+
+    In case of Black the likelihood that non-ASCII characters are going to be used in
+    file paths is minimal since it's Python source code.  Moreover, this crash was
+    spurious on Python 3.7 thanks to PEP 538 and PEP 540.
+    """
+    try:
+        from click import core
+        from click import _unicodefun
+    except ModuleNotFoundError:
+        return
+
+    for module in (core, _unicodefun):
+        if hasattr(module, "_verify_python3_env"):
+            module._verify_python3_env = lambda: None  # type: ignore
+        if hasattr(module, "_verify_python_env"):
+            module._verify_python_env = lambda: None  # type: ignore
+
+
+def patched_main() -> None:
+    maybe_install_uvloop()
+    freeze_support()
+    patch_click()
+    main()
+
+
+if __name__ == "__main__":
+    patched_main()
diff --git a/myenv/lib/python3.9/site-packages/black/__main__.py b/myenv/lib/python3.9/site-packages/black/__main__.py
new file mode 100644
index 0000000..19b810b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/__main__.py
@@ -0,0 +1,3 @@
+from black import patched_main
+
+patched_main()
diff --git a/myenv/lib/python3.9/site-packages/black/brackets.py b/myenv/lib/python3.9/site-packages/black/brackets.py
new file mode 100644
index 0000000..c5ed4bf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/brackets.py
@@ -0,0 +1,334 @@
+"""Builds on top of nodes.py to track brackets."""
+
+from dataclasses import dataclass, field
+import sys
+from typing import Dict, Iterable, List, Optional, Tuple, Union
+
+if sys.version_info < (3, 8):
+    from typing_extensions import Final
+else:
+    from typing import Final
+
+from blib2to3.pytree import Leaf, Node
+from blib2to3.pgen2 import token
+
+from black.nodes import syms, is_vararg, VARARGS_PARENTS, UNPACKING_PARENTS
+from black.nodes import BRACKET, OPENING_BRACKETS, CLOSING_BRACKETS
+from black.nodes import MATH_OPERATORS, COMPARATORS, LOGIC_OPERATORS
+
+# types
+LN = Union[Leaf, Node]
+Depth = int
+LeafID = int
+NodeType = int
+Priority = int
+
+
+COMPREHENSION_PRIORITY: Final = 20
+COMMA_PRIORITY: Final = 18
+TERNARY_PRIORITY: Final = 16
+LOGIC_PRIORITY: Final = 14
+STRING_PRIORITY: Final = 12
+COMPARATOR_PRIORITY: Final = 10
+MATH_PRIORITIES: Final = {
+    token.VBAR: 9,
+    token.CIRCUMFLEX: 8,
+    token.AMPER: 7,
+    token.LEFTSHIFT: 6,
+    token.RIGHTSHIFT: 6,
+    token.PLUS: 5,
+    token.MINUS: 5,
+    token.STAR: 4,
+    token.SLASH: 4,
+    token.DOUBLESLASH: 4,
+    token.PERCENT: 4,
+    token.AT: 4,
+    token.TILDE: 3,
+    token.DOUBLESTAR: 2,
+}
+DOT_PRIORITY: Final = 1
+
+
+class BracketMatchError(Exception):
+    """Raised when an opening bracket is unable to be matched to a closing bracket."""
+
+
+@dataclass
+class BracketTracker:
+    """Keeps track of brackets on a line."""
+
+    depth: int = 0
+    bracket_match: Dict[Tuple[Depth, NodeType], Leaf] = field(default_factory=dict)
+    delimiters: Dict[LeafID, Priority] = field(default_factory=dict)
+    previous: Optional[Leaf] = None
+    _for_loop_depths: List[int] = field(default_factory=list)
+    _lambda_argument_depths: List[int] = field(default_factory=list)
+    invisible: List[Leaf] = field(default_factory=list)
+
+    def mark(self, leaf: Leaf) -> None:
+        """Mark `leaf` with bracket-related metadata. Keep track of delimiters.
+
+        All leaves receive an int `bracket_depth` field that stores how deep
+        within brackets a given leaf is. 0 means there are no enclosing brackets
+        that started on this line.
+
+        If a leaf is itself a closing bracket, it receives an `opening_bracket`
+        field that it forms a pair with. This is a one-directional link to
+        avoid reference cycles.
+
+        If a leaf is a delimiter (a token on which Black can split the line if
+        needed) and it's on depth 0, its `id()` is stored in the tracker's
+        `delimiters` field.
+        """
+        if leaf.type == token.COMMENT:
+            return
+
+        self.maybe_decrement_after_for_loop_variable(leaf)
+        self.maybe_decrement_after_lambda_arguments(leaf)
+        if leaf.type in CLOSING_BRACKETS:
+            self.depth -= 1
+            try:
+                opening_bracket = self.bracket_match.pop((self.depth, leaf.type))
+            except KeyError as e:
+                raise BracketMatchError(
+                    "Unable to match a closing bracket to the following opening"
+                    f" bracket: {leaf}"
+                ) from e
+            leaf.opening_bracket = opening_bracket
+            if not leaf.value:
+                self.invisible.append(leaf)
+        leaf.bracket_depth = self.depth
+        if self.depth == 0:
+            delim = is_split_before_delimiter(leaf, self.previous)
+            if delim and self.previous is not None:
+                self.delimiters[id(self.previous)] = delim
+            else:
+                delim = is_split_after_delimiter(leaf, self.previous)
+                if delim:
+                    self.delimiters[id(leaf)] = delim
+        if leaf.type in OPENING_BRACKETS:
+            self.bracket_match[self.depth, BRACKET[leaf.type]] = leaf
+            self.depth += 1
+            if not leaf.value:
+                self.invisible.append(leaf)
+        self.previous = leaf
+        self.maybe_increment_lambda_arguments(leaf)
+        self.maybe_increment_for_loop_variable(leaf)
+
+    def any_open_brackets(self) -> bool:
+        """Return True if there is an yet unmatched open bracket on the line."""
+        return bool(self.bracket_match)
+
+    def max_delimiter_priority(self, exclude: Iterable[LeafID] = ()) -> Priority:
+        """Return the highest priority of a delimiter found on the line.
+
+        Values are consistent with what `is_split_*_delimiter()` return.
+        Raises ValueError on no delimiters.
+        """
+        return max(v for k, v in self.delimiters.items() if k not in exclude)
+
+    def delimiter_count_with_priority(self, priority: Priority = 0) -> int:
+        """Return the number of delimiters with the given `priority`.
+
+        If no `priority` is passed, defaults to max priority on the line.
+        """
+        if not self.delimiters:
+            return 0
+
+        priority = priority or self.max_delimiter_priority()
+        return sum(1 for p in self.delimiters.values() if p == priority)
+
+    def maybe_increment_for_loop_variable(self, leaf: Leaf) -> bool:
+        """In a for loop, or comprehension, the variables are often unpacks.
+
+        To avoid splitting on the comma in this situation, increase the depth of
+        tokens between `for` and `in`.
+        """
+        if leaf.type == token.NAME and leaf.value == "for":
+            self.depth += 1
+            self._for_loop_depths.append(self.depth)
+            return True
+
+        return False
+
+    def maybe_decrement_after_for_loop_variable(self, leaf: Leaf) -> bool:
+        """See `maybe_increment_for_loop_variable` above for explanation."""
+        if (
+            self._for_loop_depths
+            and self._for_loop_depths[-1] == self.depth
+            and leaf.type == token.NAME
+            and leaf.value == "in"
+        ):
+            self.depth -= 1
+            self._for_loop_depths.pop()
+            return True
+
+        return False
+
+    def maybe_increment_lambda_arguments(self, leaf: Leaf) -> bool:
+        """In a lambda expression, there might be more than one argument.
+
+        To avoid splitting on the comma in this situation, increase the depth of
+        tokens between `lambda` and `:`.
+        """
+        if leaf.type == token.NAME and leaf.value == "lambda":
+            self.depth += 1
+            self._lambda_argument_depths.append(self.depth)
+            return True
+
+        return False
+
+    def maybe_decrement_after_lambda_arguments(self, leaf: Leaf) -> bool:
+        """See `maybe_increment_lambda_arguments` above for explanation."""
+        if (
+            self._lambda_argument_depths
+            and self._lambda_argument_depths[-1] == self.depth
+            and leaf.type == token.COLON
+        ):
+            self.depth -= 1
+            self._lambda_argument_depths.pop()
+            return True
+
+        return False
+
+    def get_open_lsqb(self) -> Optional[Leaf]:
+        """Return the most recent opening square bracket (if any)."""
+        return self.bracket_match.get((self.depth - 1, token.RSQB))
+
+
+def is_split_after_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
+    """Return the priority of the `leaf` delimiter, given a line break after it.
+
+    The delimiter priorities returned here are from those delimiters that would
+    cause a line break after themselves.
+
+    Higher numbers are higher priority.
+    """
+    if leaf.type == token.COMMA:
+        return COMMA_PRIORITY
+
+    return 0
+
+
+def is_split_before_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
+    """Return the priority of the `leaf` delimiter, given a line break before it.
+
+    The delimiter priorities returned here are from those delimiters that would
+    cause a line break before themselves.
+
+    Higher numbers are higher priority.
+    """
+    if is_vararg(leaf, within=VARARGS_PARENTS | UNPACKING_PARENTS):
+        # * and ** might also be MATH_OPERATORS but in this case they are not.
+        # Don't treat them as a delimiter.
+        return 0
+
+    if (
+        leaf.type == token.DOT
+        and leaf.parent
+        and leaf.parent.type not in {syms.import_from, syms.dotted_name}
+        and (previous is None or previous.type in CLOSING_BRACKETS)
+    ):
+        return DOT_PRIORITY
+
+    if (
+        leaf.type in MATH_OPERATORS
+        and leaf.parent
+        and leaf.parent.type not in {syms.factor, syms.star_expr}
+    ):
+        return MATH_PRIORITIES[leaf.type]
+
+    if leaf.type in COMPARATORS:
+        return COMPARATOR_PRIORITY
+
+    if (
+        leaf.type == token.STRING
+        and previous is not None
+        and previous.type == token.STRING
+    ):
+        return STRING_PRIORITY
+
+    if leaf.type not in {token.NAME, token.ASYNC}:
+        return 0
+
+    if (
+        leaf.value == "for"
+        and leaf.parent
+        and leaf.parent.type in {syms.comp_for, syms.old_comp_for}
+        or leaf.type == token.ASYNC
+    ):
+        if (
+            not isinstance(leaf.prev_sibling, Leaf)
+            or leaf.prev_sibling.value != "async"
+        ):
+            return COMPREHENSION_PRIORITY
+
+    if (
+        leaf.value == "if"
+        and leaf.parent
+        and leaf.parent.type in {syms.comp_if, syms.old_comp_if}
+    ):
+        return COMPREHENSION_PRIORITY
+
+    if leaf.value in {"if", "else"} and leaf.parent and leaf.parent.type == syms.test:
+        return TERNARY_PRIORITY
+
+    if leaf.value == "is":
+        return COMPARATOR_PRIORITY
+
+    if (
+        leaf.value == "in"
+        and leaf.parent
+        and leaf.parent.type in {syms.comp_op, syms.comparison}
+        and not (
+            previous is not None
+            and previous.type == token.NAME
+            and previous.value == "not"
+        )
+    ):
+        return COMPARATOR_PRIORITY
+
+    if (
+        leaf.value == "not"
+        and leaf.parent
+        and leaf.parent.type == syms.comp_op
+        and not (
+            previous is not None
+            and previous.type == token.NAME
+            and previous.value == "is"
+        )
+    ):
+        return COMPARATOR_PRIORITY
+
+    if leaf.value in LOGIC_OPERATORS and leaf.parent:
+        return LOGIC_PRIORITY
+
+    return 0
+
+
+def max_delimiter_priority_in_atom(node: LN) -> Priority:
+    """Return maximum delimiter priority inside `node`.
+
+    This is specific to atoms with contents contained in a pair of parentheses.
+    If `node` isn't an atom or there are no enclosing parentheses, returns 0.
+    """
+    if node.type != syms.atom:
+        return 0
+
+    first = node.children[0]
+    last = node.children[-1]
+    if not (first.type == token.LPAR and last.type == token.RPAR):
+        return 0
+
+    bt = BracketTracker()
+    for c in node.children[1:-1]:
+        if isinstance(c, Leaf):
+            bt.mark(c)
+        else:
+            for leaf in c.leaves():
+                bt.mark(leaf)
+    try:
+        return bt.max_delimiter_priority()
+
+    except ValueError:
+        return 0
diff --git a/myenv/lib/python3.9/site-packages/black/cache.py b/myenv/lib/python3.9/site-packages/black/cache.py
new file mode 100644
index 0000000..bca7279
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/cache.py
@@ -0,0 +1,83 @@
+"""Caching of formatted files with feature-based invalidation."""
+
+import os
+import pickle
+from pathlib import Path
+import tempfile
+from typing import Dict, Iterable, Set, Tuple
+
+from platformdirs import user_cache_dir
+
+from black.mode import Mode
+
+from _black_version import version as __version__
+
+
+# types
+Timestamp = float
+FileSize = int
+CacheInfo = Tuple[Timestamp, FileSize]
+Cache = Dict[str, CacheInfo]
+
+
+CACHE_DIR = Path(user_cache_dir("black", version=__version__))
+
+
+def read_cache(mode: Mode) -> Cache:
+    """Read the cache if it exists and is well formed.
+
+    If it is not well formed, the call to write_cache later should resolve the issue.
+    """
+    cache_file = get_cache_file(mode)
+    if not cache_file.exists():
+        return {}
+
+    with cache_file.open("rb") as fobj:
+        try:
+            cache: Cache = pickle.load(fobj)
+        except (pickle.UnpicklingError, ValueError, IndexError):
+            return {}
+
+    return cache
+
+
+def get_cache_file(mode: Mode) -> Path:
+    return CACHE_DIR / f"cache.{mode.get_cache_key()}.pickle"
+
+
+def get_cache_info(path: Path) -> CacheInfo:
+    """Return the information used to check if a file is already formatted or not."""
+    stat = path.stat()
+    return stat.st_mtime, stat.st_size
+
+
+def filter_cached(cache: Cache, sources: Iterable[Path]) -> Tuple[Set[Path], Set[Path]]:
+    """Split an iterable of paths in `sources` into two sets.
+
+    The first contains paths of files that modified on disk or are not in the
+    cache. The other contains paths to non-modified files.
+    """
+    todo, done = set(), set()
+    for src in sources:
+        res_src = src.resolve()
+        if cache.get(str(res_src)) != get_cache_info(res_src):
+            todo.add(src)
+        else:
+            done.add(src)
+    return todo, done
+
+
+def write_cache(cache: Cache, sources: Iterable[Path], mode: Mode) -> None:
+    """Update the cache file."""
+    cache_file = get_cache_file(mode)
+    try:
+        CACHE_DIR.mkdir(parents=True, exist_ok=True)
+        new_cache = {
+            **cache,
+            **{str(src.resolve()): get_cache_info(src) for src in sources},
+        }
+        with tempfile.NamedTemporaryFile(dir=str(cache_file.parent), delete=False) as f:
+            pickle.dump(new_cache, f, protocol=4)
+        os.replace(f.name, cache_file)
+    except OSError:
+        pass
diff --git a/myenv/lib/python3.9/site-packages/black/comments.py b/myenv/lib/python3.9/site-packages/black/comments.py
new file mode 100644
index 0000000..28b9117
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/comments.py
@@ -0,0 +1,277 @@
+import sys
+from dataclasses import dataclass
+from functools import lru_cache
+import re
+from typing import Iterator, List, Optional, Union
+
+if sys.version_info >= (3, 8):
+    from typing import Final
+else:
+    from typing_extensions import Final
+
+from blib2to3.pytree import Node, Leaf
+from blib2to3.pgen2 import token
+
+from black.nodes import first_leaf_column, preceding_leaf, container_of
+from black.nodes import STANDALONE_COMMENT, WHITESPACE
+
+# types
+LN = Union[Leaf, Node]
+
+FMT_OFF: Final = {"# fmt: off", "# fmt:off", "# yapf: disable"}
+FMT_SKIP: Final = {"# fmt: skip", "# fmt:skip"}
+FMT_PASS: Final = {*FMT_OFF, *FMT_SKIP}
+FMT_ON: Final = {"# fmt: on", "# fmt:on", "# yapf: enable"}
+
+
+@dataclass
+class ProtoComment:
+    """Describes a piece of syntax that is a comment.
+
+    It's not a :class:`blib2to3.pytree.Leaf` so that:
+
+    * it can be cached (`Leaf` objects should not be reused more than once as
+      they store their lineno, column, prefix, and parent information);
+    * `newlines` and `consumed` fields are kept separate from the `value`. This
+      simplifies handling of special marker comments like ``# fmt: off/on``.
+    """
+
+    type: int  # token.COMMENT or STANDALONE_COMMENT
+    value: str  # content of the comment
+    newlines: int  # how many newlines before the comment
+    consumed: int  # how many characters of the original leaf's prefix did we consume
+
+
+def generate_comments(leaf: LN) -> Iterator[Leaf]:
+    """Clean the prefix of the `leaf` and generate comments from it, if any.
+
+    Comments in lib2to3 are shoved into the whitespace prefix.  This happens
+    in `pgen2/driver.py:Driver.parse_tokens()`.  This was a brilliant implementation
+    move because it does away with modifying the grammar to include all the
+    possible places in which comments can be placed.
+
+    The sad consequence for us though is that comments don't "belong" anywhere.
+    This is why this function generates simple parentless Leaf objects for
+    comments.  We simply don't know what the correct parent should be.
+
+    No matter though, we can live without this.  We really only need to
+    differentiate between inline and standalone comments.  The latter don't
+    share the line with any code.
+
+    Inline comments are emitted as regular token.COMMENT leaves.  Standalone
+    are emitted with a fake STANDALONE_COMMENT token identifier.
+    """
+    for pc in list_comments(leaf.prefix, is_endmarker=leaf.type == token.ENDMARKER):
+        yield Leaf(pc.type, pc.value, prefix="\n" * pc.newlines)
+
+
+@lru_cache(maxsize=4096)
+def list_comments(prefix: str, *, is_endmarker: bool) -> List[ProtoComment]:
+    """Return a list of :class:`ProtoComment` objects parsed from the given `prefix`."""
+    result: List[ProtoComment] = []
+    if not prefix or "#" not in prefix:
+        return result
+
+    consumed = 0
+    nlines = 0
+    ignored_lines = 0
+    for index, line in enumerate(re.split("\r?\n", prefix)):
+        consumed += len(line) + 1  # adding the length of the split '\n'
+        line = line.lstrip()
+        if not line:
+            nlines += 1
+        if not line.startswith("#"):
+            # Escaped newlines outside of a comment are not really newlines at
+            # all. We treat a single-line comment following an escaped newline
+            # as a simple trailing comment.
+            if line.endswith("\\"):
+                ignored_lines += 1
+            continue
+
+        if index == ignored_lines and not is_endmarker:
+            comment_type = token.COMMENT  # simple trailing comment
+        else:
+            comment_type = STANDALONE_COMMENT
+        comment = make_comment(line)
+        result.append(
+            ProtoComment(
+                type=comment_type, value=comment, newlines=nlines, consumed=consumed
+            )
+        )
+        nlines = 0
+    return result
+
+
+def make_comment(content: str) -> str:
+    """Return a consistently formatted comment from the given `content` string.
+
+    All comments (except for "##", "#!", "#:", '#'", "#%%") should have a single
+    space between the hash sign and the content.
+
+    If `content` didn't start with a hash sign, one is provided.
+    """
+    content = content.rstrip()
+    if not content:
+        return "#"
+
+    if content[0] == "#":
+        content = content[1:]
+    NON_BREAKING_SPACE = " "
+    if (
+        content
+        and content[0] == NON_BREAKING_SPACE
+        and not content.lstrip().startswith("type:")
+    ):
+        content = " " + content[1:]  # Replace NBSP by a simple space
+    if content and content[0] not in " !:#'%":
+        content = " " + content
+    return "#" + content
+
+
+def normalize_fmt_off(node: Node) -> None:
+    """Convert content between `# fmt: off`/`# fmt: on` into standalone comments."""
+    try_again = True
+    while try_again:
+        try_again = convert_one_fmt_off_pair(node)
+
+
+def convert_one_fmt_off_pair(node: Node) -> bool:
+    """Convert content of a single `# fmt: off`/`# fmt: on` into a standalone comment.
+
+    Returns True if a pair was converted.
+    """
+    for leaf in node.leaves():
+        previous_consumed = 0
+        for comment in list_comments(leaf.prefix, is_endmarker=False):
+            if comment.value not in FMT_PASS:
+                previous_consumed = comment.consumed
+                continue
+            # We only want standalone comments. If there's no previous leaf or
+            # the previous leaf is indentation, it's a standalone comment in
+            # disguise.
+            if comment.value in FMT_PASS and comment.type != STANDALONE_COMMENT:
+                prev = preceding_leaf(leaf)
+                if prev:
+                    if comment.value in FMT_OFF and prev.type not in WHITESPACE:
+                        continue
+                    if comment.value in FMT_SKIP and prev.type in WHITESPACE:
+                        continue
+
+            ignored_nodes = list(generate_ignored_nodes(leaf, comment))
+            if not ignored_nodes:
+                continue
+
+            first = ignored_nodes[0]  # Can be a container node with the `leaf`.
+            parent = first.parent
+            prefix = first.prefix
+            if comment.value in FMT_OFF:
+                first.prefix = prefix[comment.consumed :]
+            if comment.value in FMT_SKIP:
+                first.prefix = ""
+            hidden_value = "".join(str(n) for n in ignored_nodes)
+            if comment.value in FMT_OFF:
+                hidden_value = comment.value + "\n" + hidden_value
+            if comment.value in FMT_SKIP:
+                hidden_value += "  " + comment.value
+            if hidden_value.endswith("\n"):
+                # That happens when one of the `ignored_nodes` ended with a NEWLINE
+                # leaf (possibly followed by a DEDENT).
+                hidden_value = hidden_value[:-1]
+            first_idx: Optional[int] = None
+            for ignored in ignored_nodes:
+                index = ignored.remove()
+                if first_idx is None:
+                    first_idx = index
+            assert parent is not None, "INTERNAL ERROR: fmt: on/off handling (1)"
+            assert first_idx is not None, "INTERNAL ERROR: fmt: on/off handling (2)"
+            parent.insert_child(
+                first_idx,
+                Leaf(
+                    STANDALONE_COMMENT,
+                    hidden_value,
+                    prefix=prefix[:previous_consumed] + "\n" * comment.newlines,
+                ),
+            )
+            return True
+
+    return False
+
+
+def generate_ignored_nodes(leaf: Leaf, comment: ProtoComment) -> Iterator[LN]:
+    """Starting from the container of `leaf`, generate all leaves until `# fmt: on`.
+
+    If comment is skip, returns leaf only.
+    Stops at the end of the block.
+    """
+    container: Optional[LN] = container_of(leaf)
+    if comment.value in FMT_SKIP:
+        prev_sibling = leaf.prev_sibling
+        if comment.value in leaf.prefix and prev_sibling is not None:
+            leaf.prefix = leaf.prefix.replace(comment.value, "")
+            siblings = [prev_sibling]
+            while (
+                "\n" not in prev_sibling.prefix
+                and prev_sibling.prev_sibling is not None
+            ):
+                prev_sibling = prev_sibling.prev_sibling
+                siblings.insert(0, prev_sibling)
+            for sibling in siblings:
+                yield sibling
+        elif leaf.parent is not None:
+            yield leaf.parent
+        return
+    while container is not None and container.type != token.ENDMARKER:
+        if is_fmt_on(container):
+            return
+
+        # fix for fmt: on in children
+        if contains_fmt_on_at_column(container, leaf.column):
+            for child in container.children:
+                if contains_fmt_on_at_column(child, leaf.column):
+                    return
+                yield child
+        else:
+            yield container
+            container = container.next_sibling
+
+
+def is_fmt_on(container: LN) -> bool:
+    """Determine whether formatting is switched on within a container.
+    Determined by whether the last `# fmt:` comment is `on` or `off`.
+    """
+    fmt_on = False
+    for comment in list_comments(container.prefix, is_endmarker=False):
+        if comment.value in FMT_ON:
+            fmt_on = True
+        elif comment.value in FMT_OFF:
+            fmt_on = False
+    return fmt_on
+
+
+def contains_fmt_on_at_column(container: LN, column: int) -> bool:
+    """Determine if children at a given column have formatting switched on."""
+    for child in container.children:
+        if (
+            isinstance(child, Node)
+            and first_leaf_column(child) == column
+            or isinstance(child, Leaf)
+            and child.column == column
+        ):
+            if is_fmt_on(child):
+                return True
+
+    return False
+
+
+def contains_pragma_comment(comment_list: List[Leaf]) -> bool:
+    """
+    Returns:
+        True iff one of the comments in @comment_list is a pragma used by one
+        of the more common static analysis tools for python (e.g. mypy, flake8,
+        pylint).
+    """
+    for comment in comment_list:
+        if comment.value.startswith(("# type:", "# noqa", "# pylint:")):
+            return True
+
+    return False
diff --git a/myenv/lib/python3.9/site-packages/black/concurrency.py b/myenv/lib/python3.9/site-packages/black/concurrency.py
new file mode 100644
index 0000000..24f67b6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/concurrency.py
@@ -0,0 +1,57 @@
+import asyncio
+import logging
+import sys
+from typing import Any, Iterable
+
+from black.output import err
+
+
+def maybe_install_uvloop() -> None:
+    """If our environment has uvloop installed we use it.
+
+    This is called only from command-line entry points to avoid
+    interfering with the parent process if Black is used as a library.
+
+    """
+    try:
+        import uvloop
+
+        uvloop.install()
+    except ImportError:
+        pass
+
+
+def cancel(tasks: Iterable["asyncio.Task[Any]"]) -> None:
+    """asyncio signal handler that cancels all `tasks` and reports to stderr."""
+    err("Aborted!")
+    for task in tasks:
+        task.cancel()
+
+
+def shutdown(loop: asyncio.AbstractEventLoop) -> None:
+    """Cancel all pending tasks on `loop`, wait for them, and close the loop."""
+    try:
+        if sys.version_info[:2] >= (3, 7):
+            all_tasks = asyncio.all_tasks
+        else:
+            all_tasks = asyncio.Task.all_tasks
+        # This part is borrowed from asyncio/runners.py in Python 3.7b2.
+        to_cancel = [task for task in all_tasks(loop) if not task.done()]
+        if not to_cancel:
+            return
+
+        for task in to_cancel:
+            task.cancel()
+        if sys.version_info >= (3, 7):
+            loop.run_until_complete(asyncio.gather(*to_cancel, return_exceptions=True))
+        else:
+            loop.run_until_complete(
+                asyncio.gather(*to_cancel, loop=loop, return_exceptions=True)
+            )
+    finally:
+        # `concurrent.futures.Future` objects cannot be cancelled once they
+        # are already running. There might be some when the `shutdown()` happened.
+        # Silence their logger's spew about the event loop being closed.
+        cf_logger = logging.getLogger("concurrent.futures")
+        cf_logger.setLevel(logging.CRITICAL)
+        loop.close()
diff --git a/myenv/lib/python3.9/site-packages/black/const.py b/myenv/lib/python3.9/site-packages/black/const.py
new file mode 100644
index 0000000..dbb4826
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/const.py
@@ -0,0 +1,4 @@
+DEFAULT_LINE_LENGTH = 88
+DEFAULT_EXCLUDES = r"/(\.direnv|\.eggs|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|venv|\.svn|_build|buck-out|build|dist)/"  # noqa: B950
+DEFAULT_INCLUDES = r"(\.pyi?|\.ipynb)$"
+STDIN_PLACEHOLDER = "__BLACK_STDIN_FILENAME__"
diff --git a/myenv/lib/python3.9/site-packages/black/debug.py b/myenv/lib/python3.9/site-packages/black/debug.py
new file mode 100644
index 0000000..5143076
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/debug.py
@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+from typing import Iterator, TypeVar, Union
+
+from blib2to3.pytree import Node, Leaf, type_repr
+from blib2to3.pgen2 import token
+
+from black.nodes import Visitor
+from black.output import out
+from black.parsing import lib2to3_parse
+
+LN = Union[Leaf, Node]
+T = TypeVar("T")
+
+
+@dataclass
+class DebugVisitor(Visitor[T]):
+    tree_depth: int = 0
+
+    def visit_default(self, node: LN) -> Iterator[T]:
+        indent = " " * (2 * self.tree_depth)
+        if isinstance(node, Node):
+            _type = type_repr(node.type)
+            out(f"{indent}{_type}", fg="yellow")
+            self.tree_depth += 1
+            for child in node.children:
+                yield from self.visit(child)
+
+            self.tree_depth -= 1
+            out(f"{indent}/{_type}", fg="yellow", bold=False)
+        else:
+            _type = token.tok_name.get(node.type, str(node.type))
+            out(f"{indent}{_type}", fg="blue", nl=False)
+            if node.prefix:
+                # We don't have to handle prefixes for `Node` objects since
+                # that delegates to the first child anyway.
+                out(f" {node.prefix!r}", fg="green", bold=False, nl=False)
+            out(f" {node.value!r}", fg="blue", bold=False)
+
+    @classmethod
+    def show(cls, code: Union[str, Leaf, Node]) -> None:
+        """Pretty-print the lib2to3 AST of a given string of `code`.
+
+        Convenience method for debugging.
+        """
+        v: DebugVisitor[None] = DebugVisitor()
+        if isinstance(code, str):
+            code = lib2to3_parse(code)
+        list(v.visit(code))
diff --git a/myenv/lib/python3.9/site-packages/black/files.py b/myenv/lib/python3.9/site-packages/black/files.py
new file mode 100644
index 0000000..560aa05
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/files.py
@@ -0,0 +1,261 @@
+from functools import lru_cache
+import io
+import os
+from pathlib import Path
+import sys
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Pattern,
+    Sequence,
+    Tuple,
+    Union,
+    TYPE_CHECKING,
+)
+
+from mypy_extensions import mypyc_attr
+from pathspec import PathSpec
+from pathspec.patterns.gitwildmatch import GitWildMatchPatternError
+import tomli
+
+from black.output import err
+from black.report import Report
+from black.handle_ipynb_magics import jupyter_dependencies_are_installed
+
+if TYPE_CHECKING:
+    import colorama  # noqa: F401
+
+
+@lru_cache()
+def find_project_root(srcs: Sequence[str]) -> Path:
+    """Return a directory containing .git, .hg, or pyproject.toml.
+
+    That directory will be a common parent of all files and directories
+    passed in `srcs`.
+
+    If no directory in the tree contains a marker that would specify it's the
+    project root, the root of the file system is returned.
+    """
+    if not srcs:
+        srcs = [str(Path.cwd().resolve())]
+
+    path_srcs = [Path(Path.cwd(), src).resolve() for src in srcs]
+
+    # A list of lists of parents for each 'src'. 'src' is included as a
+    # "parent" of itself if it is a directory
+    src_parents = [
+        list(path.parents) + ([path] if path.is_dir() else []) for path in path_srcs
+    ]
+
+    common_base = max(
+        set.intersection(*(set(parents) for parents in src_parents)),
+        key=lambda path: path.parts,
+    )
+
+    for directory in (common_base, *common_base.parents):
+        if (directory / ".git").exists():
+            return directory
+
+        if (directory / ".hg").is_dir():
+            return directory
+
+        if (directory / "pyproject.toml").is_file():
+            return directory
+
+    return directory
+
+
+def find_pyproject_toml(path_search_start: Tuple[str, ...]) -> Optional[str]:
+    """Find the absolute filepath to a pyproject.toml if it exists"""
+    path_project_root = find_project_root(path_search_start)
+    path_pyproject_toml = path_project_root / "pyproject.toml"
+    if path_pyproject_toml.is_file():
+        return str(path_pyproject_toml)
+
+    try:
+        path_user_pyproject_toml = find_user_pyproject_toml()
+        return (
+            str(path_user_pyproject_toml)
+            if path_user_pyproject_toml.is_file()
+            else None
+        )
+    except PermissionError as e:
+        # We do not have access to the user-level config directory, so ignore it.
+        err(f"Ignoring user configuration directory due to {e!r}")
+        return None
+
+
+@mypyc_attr(patchable=True)
+def parse_pyproject_toml(path_config: str) -> Dict[str, Any]:
+    """Parse a pyproject toml file, pulling out relevant parts for Black
+
+    If parsing fails, will raise a tomli.TOMLDecodeError
+    """
+    with open(path_config, encoding="utf8") as f:
+        pyproject_toml = tomli.loads(f.read())
+    config = pyproject_toml.get("tool", {}).get("black", {})
+    return {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}
+
+
+@lru_cache()
+def find_user_pyproject_toml() -> Path:
+    r"""Return the path to the top-level user configuration for black.
+
+    This looks for ~\.black on Windows and ~/.config/black on Linux and other
+    Unix systems.
+    """
+    if sys.platform == "win32":
+        # Windows
+        user_config_path = Path.home() / ".black"
+    else:
+        config_root = os.environ.get("XDG_CONFIG_HOME", "~/.config")
+        user_config_path = Path(config_root).expanduser() / "black"
+    return user_config_path.resolve()
+
+
+@lru_cache()
+def get_gitignore(root: Path) -> PathSpec:
+    """Return a PathSpec matching gitignore content if present."""
+    gitignore = root / ".gitignore"
+    lines: List[str] = []
+    if gitignore.is_file():
+        with gitignore.open(encoding="utf-8") as gf:
+            lines = gf.readlines()
+    try:
+        return PathSpec.from_lines("gitwildmatch", lines)
+    except GitWildMatchPatternError as e:
+        err(f"Could not parse {gitignore}: {e}")
+        raise
+
+
+def normalize_path_maybe_ignore(
+    path: Path, root: Path, report: Report
+) -> Optional[str]:
+    """Normalize `path`. May return `None` if `path` was ignored.
+
+    `report` is where "path ignored" output goes.
+    """
+    try:
+        abspath = path if path.is_absolute() else Path.cwd() / path
+        normalized_path = abspath.resolve().relative_to(root).as_posix()
+    except OSError as e:
+        report.path_ignored(path, f"cannot be read because {e}")
+        return None
+
+    except ValueError:
+        if path.is_symlink():
+            report.path_ignored(path, f"is a symbolic link that points outside {root}")
+            return None
+
+        raise
+
+    return normalized_path
+
+
+def path_is_excluded(
+    normalized_path: str,
+    pattern: Optional[Pattern[str]],
+) -> bool:
+    match = pattern.search(normalized_path) if pattern else None
+    return bool(match and match.group(0))
+
+
+def gen_python_files(
+    paths: Iterable[Path],
+    root: Path,
+    include: Pattern[str],
+    exclude: Pattern[str],
+    extend_exclude: Optional[Pattern[str]],
+    force_exclude: Optional[Pattern[str]],
+    report: Report,
+    gitignore: Optional[PathSpec],
+    *,
+    verbose: bool,
+    quiet: bool,
+) -> Iterator[Path]:
+    """Generate all files under `path` whose paths are not excluded by the
+    `exclude_regex`, `extend_exclude`, or `force_exclude` regexes,
+    but are included by the `include` regex.
+
+    Symbolic links pointing outside of the `root` directory are ignored.
+
+    `report` is where output about exclusions goes.
+    """
+    assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"
+    for child in paths:
+        normalized_path = normalize_path_maybe_ignore(child, root, report)
+        if normalized_path is None:
+            continue
+
+        # First ignore files matching .gitignore, if passed
+        if gitignore is not None and gitignore.match_file(normalized_path):
+            report.path_ignored(child, "matches the .gitignore file content")
+            continue
+
+        # Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options.
+        normalized_path = "/" + normalized_path
+        if child.is_dir():
+            normalized_path += "/"
+
+        if path_is_excluded(normalized_path, exclude):
+            report.path_ignored(child, "matches the --exclude regular expression")
+            continue
+
+        if path_is_excluded(normalized_path, extend_exclude):
+            report.path_ignored(
+                child, "matches the --extend-exclude regular expression"
+            )
+            continue
+
+        if path_is_excluded(normalized_path, force_exclude):
+            report.path_ignored(child, "matches the --force-exclude regular expression")
+            continue
+
+        if child.is_dir():
+            # If gitignore is None, gitignore usage is disabled, while a Falsey
+            # gitignore is when the directory doesn't have a .gitignore file.
+            yield from gen_python_files(
+                child.iterdir(),
+                root,
+                include,
+                exclude,
+                extend_exclude,
+                force_exclude,
+                report,
+                gitignore + get_gitignore(child) if gitignore is not None else None,
+                verbose=verbose,
+                quiet=quiet,
+            )
+
+        elif child.is_file():
+            if child.suffix == ".ipynb" and not jupyter_dependencies_are_installed(
+                verbose=verbose, quiet=quiet
+            ):
+                continue
+            include_match = include.search(normalized_path) if include else True
+            if include_match:
+                yield child
+
+
+def wrap_stream_for_windows(
+    f: io.TextIOWrapper,
+) -> Union[io.TextIOWrapper, "colorama.AnsiToWin32"]:
+    """
+    Wrap stream with colorama's wrap_stream so colors are shown on Windows.
+
+    If `colorama` is unavailable, the original stream is returned unmodified.
+    Otherwise, the `wrap_stream()` function determines whether the stream needs
+    to be wrapped for a Windows environment and will accordingly either return
+    an `AnsiToWin32` wrapper or the original stream.
+    """
+    try:
+        from colorama.initialise import wrap_stream
+    except ImportError:
+        return f
+    else:
+        # Set `strip=False` to avoid needing to modify test_express_diff_with_color.
+        return wrap_stream(f, convert=None, strip=False, autoreset=False, wrap=True)
diff --git a/myenv/lib/python3.9/site-packages/black/handle_ipynb_magics.py b/myenv/lib/python3.9/site-packages/black/handle_ipynb_magics.py
new file mode 100644
index 0000000..a0ed56b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/handle_ipynb_magics.py
@@ -0,0 +1,465 @@
+"""Functions to process IPython magics with."""
+
+from functools import lru_cache
+import dataclasses
+import ast
+from typing import Dict, List, Tuple, Optional
+
+import secrets
+import sys
+import collections
+
+if sys.version_info >= (3, 10):
+    from typing import TypeGuard
+else:
+    from typing_extensions import TypeGuard
+
+from black.report import NothingChanged
+from black.output import out
+
+
+TRANSFORMED_MAGICS = frozenset(
+    (
+        "get_ipython().run_cell_magic",
+        "get_ipython().system",
+        "get_ipython().getoutput",
+        "get_ipython().run_line_magic",
+    )
+)
+TOKENS_TO_IGNORE = frozenset(
+    (
+        "ENDMARKER",
+        "NL",
+        "NEWLINE",
+        "COMMENT",
+        "DEDENT",
+        "UNIMPORTANT_WS",
+        "ESCAPED_NL",
+    )
+)
+PYTHON_CELL_MAGICS = frozenset(
+    (
+        "capture",
+        "prun",
+        "pypy",
+        "python",
+        "python3",
+        "time",
+        "timeit",
+    )
+)
+TOKEN_HEX = secrets.token_hex
+
+
+@dataclasses.dataclass(frozen=True)
+class Replacement:
+    mask: str
+    src: str
+
+
+@lru_cache()
+def jupyter_dependencies_are_installed(*, verbose: bool, quiet: bool) -> bool:
+    try:
+        import IPython  # noqa:F401
+        import tokenize_rt  # noqa:F401
+    except ModuleNotFoundError:
+        if verbose or not quiet:
+            msg = (
+                "Skipping .ipynb files as Jupyter dependencies are not installed.\n"
+                "You can fix this by running ``pip install black[jupyter]``"
+            )
+            out(msg)
+        return False
+    else:
+        return True
+
+
+def remove_trailing_semicolon(src: str) -> Tuple[str, bool]:
+    """Remove trailing semicolon from Jupyter notebook cell.
+
+    For example,
+
+        fig, ax = plt.subplots()
+        ax.plot(x_data, y_data);  # plot data
+
+    would become
+
+        fig, ax = plt.subplots()
+        ax.plot(x_data, y_data)  # plot data
+
+    Mirrors the logic in `quiet` from `IPython.core.displayhook`, but uses
+    ``tokenize_rt`` so that round-tripping works fine.
+    """
+    from tokenize_rt import (
+        src_to_tokens,
+        tokens_to_src,
+        reversed_enumerate,
+    )
+
+    tokens = src_to_tokens(src)
+    trailing_semicolon = False
+    for idx, token in reversed_enumerate(tokens):
+        if token.name in TOKENS_TO_IGNORE:
+            continue
+        if token.name == "OP" and token.src == ";":
+            del tokens[idx]
+            trailing_semicolon = True
+        break
+    if not trailing_semicolon:
+        return src, False
+    return tokens_to_src(tokens), True
+
+
+def put_trailing_semicolon_back(src: str, has_trailing_semicolon: bool) -> str:
+    """Put trailing semicolon back if cell originally had it.
+
+    Mirrors the logic in `quiet` from `IPython.core.displayhook`, but uses
+    ``tokenize_rt`` so that round-tripping works fine.
+    """
+    if not has_trailing_semicolon:
+        return src
+    from tokenize_rt import src_to_tokens, tokens_to_src, reversed_enumerate
+
+    tokens = src_to_tokens(src)
+    for idx, token in reversed_enumerate(tokens):
+        if token.name in TOKENS_TO_IGNORE:
+            continue
+        tokens[idx] = token._replace(src=token.src + ";")
+        break
+    else:  # pragma: nocover
+        raise AssertionError(
+            "INTERNAL ERROR: Was not able to reinstate trailing semicolon. "
+            "Please report a bug on https://github.com/psf/black/issues.  "
+        ) from None
+    return str(tokens_to_src(tokens))
+
+
+def mask_cell(src: str) -> Tuple[str, List[Replacement]]:
+    """Mask IPython magics so content becomes parseable Python code.
+
+    For example,
+
+        %matplotlib inline
+        'foo'
+
+    becomes
+
+        "25716f358c32750e"
+        'foo'
+
+    The replacements are returned, along with the transformed code.
+    """
+    replacements: List[Replacement] = []
+    try:
+        ast.parse(src)
+    except SyntaxError:
+        # Might have IPython magics, will process below.
+        pass
+    else:
+        # Syntax is fine, nothing to mask, early return.
+        return src, replacements
+
+    from IPython.core.inputtransformer2 import TransformerManager
+
+    transformer_manager = TransformerManager()
+    transformed = transformer_manager.transform_cell(src)
+    transformed, cell_magic_replacements = replace_cell_magics(transformed)
+    replacements += cell_magic_replacements
+    transformed = transformer_manager.transform_cell(transformed)
+    transformed, magic_replacements = replace_magics(transformed)
+    if len(transformed.splitlines()) != len(src.splitlines()):
+        # Multi-line magic, not supported.
+        raise NothingChanged
+    replacements += magic_replacements
+    return transformed, replacements
+
+
+def get_token(src: str, magic: str) -> str:
+    """Return randomly generated token to mask IPython magic with.
+
+    For example, if 'magic' was `%matplotlib inline`, then a possible
+    token to mask it with would be `"43fdd17f7e5ddc83"`. The token
+    will be the same length as the magic, and we make sure that it was
+    not already present anywhere else in the cell.
+    """
+    assert magic
+    nbytes = max(len(magic) // 2 - 1, 1)
+    token = TOKEN_HEX(nbytes)
+    counter = 0
+    while token in src:
+        token = TOKEN_HEX(nbytes)
+        counter += 1
+        if counter > 100:
+            raise AssertionError(
+                "INTERNAL ERROR: Black was not able to replace IPython magic. "
+                "Please report a bug on https://github.com/psf/black/issues.  "
+                f"The magic might be helpful: {magic}"
+            ) from None
+    if len(token) + 2 < len(magic):
+        token = f"{token}."
+    return f'"{token}"'
+
+
+def replace_cell_magics(src: str) -> Tuple[str, List[Replacement]]:
+    """Replace cell magic with token.
+
+    Note that 'src' will already have been processed by IPython's
+    TransformerManager().transform_cell.
+
+    Example,
+
+        get_ipython().run_cell_magic('t', '-n1', 'ls =!ls\\n')
+
+    becomes
+
+        "a794."
+        ls =!ls
+
+    The replacement, along with the transformed code, is returned.
+    """
+    replacements: List[Replacement] = []
+
+    tree = ast.parse(src)
+
+    cell_magic_finder = CellMagicFinder()
+    cell_magic_finder.visit(tree)
+    if cell_magic_finder.cell_magic is None:
+        return src, replacements
+    header = cell_magic_finder.cell_magic.header
+    mask = get_token(src, header)
+    replacements.append(Replacement(mask=mask, src=header))
+    return f"{mask}\n{cell_magic_finder.cell_magic.body}", replacements
+
+
+def replace_magics(src: str) -> Tuple[str, List[Replacement]]:
+    """Replace magics within body of cell.
+
+    Note that 'src' will already have been processed by IPython's
+    TransformerManager().transform_cell.
+
+    Example, this
+
+        get_ipython().run_line_magic('matplotlib', 'inline')
+        'foo'
+
+    becomes
+
+        "5e67db56d490fd39"
+        'foo'
+
+    The replacement, along with the transformed code, are returned.
+    """
+    replacements = []
+    magic_finder = MagicFinder()
+    magic_finder.visit(ast.parse(src))
+    new_srcs = []
+    for i, line in enumerate(src.splitlines(), start=1):
+        if i in magic_finder.magics:
+            offsets_and_magics = magic_finder.magics[i]
+            if len(offsets_and_magics) != 1:  # pragma: nocover
+                raise AssertionError(
+                    f"Expecting one magic per line, got: {offsets_and_magics}\n"
+                    "Please report a bug on https://github.com/psf/black/issues."
+                )
+            col_offset, magic = (
+                offsets_and_magics[0].col_offset,
+                offsets_and_magics[0].magic,
+            )
+            mask = get_token(src, magic)
+            replacements.append(Replacement(mask=mask, src=magic))
+            line = line[:col_offset] + mask
+        new_srcs.append(line)
+    return "\n".join(new_srcs), replacements
+
+
+def unmask_cell(src: str, replacements: List[Replacement]) -> str:
+    """Remove replacements from cell.
+
+    For example
+
+        "9b20"
+        foo = bar
+
+    becomes
+
+        %%time
+        foo = bar
+    """
+    for replacement in replacements:
+        src = src.replace(replacement.mask, replacement.src)
+    return src
+
+
+def _is_ipython_magic(node: ast.expr) -> TypeGuard[ast.Attribute]:
+    """Check if attribute is IPython magic.
+
+    Note that the source of the abstract syntax tree
+    will already have been processed by IPython's
+    TransformerManager().transform_cell.
+    """
+    return (
+        isinstance(node, ast.Attribute)
+        and isinstance(node.value, ast.Call)
+        and isinstance(node.value.func, ast.Name)
+        and node.value.func.id == "get_ipython"
+    )
+
+
+def _get_str_args(args: List[ast.expr]) -> List[str]:
+    str_args = []
+    for arg in args:
+        assert isinstance(arg, ast.Str)
+        str_args.append(arg.s)
+    return str_args
+
+
+@dataclasses.dataclass(frozen=True)
+class CellMagic:
+    name: str
+    params: Optional[str]
+    body: str
+
+    @property
+    def header(self) -> str:
+        if self.params:
+            return f"%%{self.name} {self.params}"
+        return f"%%{self.name}"
+
+
+# ast.NodeVisitor + dataclass = breakage under mypyc.
+class CellMagicFinder(ast.NodeVisitor):
+    """Find cell magics.
+
+    Note that the source of the abstract syntax tree
+    will already have been processed by IPython's
+    TransformerManager().transform_cell.
+
+    For example,
+
+        %%time\nfoo()
+
+    would have been transformed to
+
+        get_ipython().run_cell_magic('time', '', 'foo()\\n')
+
+    and we look for instances of the latter.
+    """
+
+    def __init__(self, cell_magic: Optional[CellMagic] = None) -> None:
+        self.cell_magic = cell_magic
+
+    def visit_Expr(self, node: ast.Expr) -> None:
+        """Find cell magic, extract header and body."""
+        if (
+            isinstance(node.value, ast.Call)
+            and _is_ipython_magic(node.value.func)
+            and node.value.func.attr == "run_cell_magic"
+        ):
+            args = _get_str_args(node.value.args)
+            self.cell_magic = CellMagic(name=args[0], params=args[1], body=args[2])
+        self.generic_visit(node)
+
+
+@dataclasses.dataclass(frozen=True)
+class OffsetAndMagic:
+    col_offset: int
+    magic: str
+
+
+# Unsurprisingly, subclassing ast.NodeVisitor means we can't use dataclasses here
+# as mypyc will generate broken code.
+class MagicFinder(ast.NodeVisitor):
+    """Visit cell to look for get_ipython calls.
+
+    Note that the source of the abstract syntax tree
+    will already have been processed by IPython's
+    TransformerManager().transform_cell.
+
+    For example,
+
+        %matplotlib inline
+
+    would have been transformed to
+
+        get_ipython().run_line_magic('matplotlib', 'inline')
+
+    and we look for instances of the latter (and likewise for other
+    types of magics).
+    """
+
+    def __init__(self) -> None:
+        self.magics: Dict[int, List[OffsetAndMagic]] = collections.defaultdict(list)
+
+    def visit_Assign(self, node: ast.Assign) -> None:
+        """Look for system assign magics.
+
+        For example,
+
+            black_version = !black --version
+            env = %env var
+
+        would have been (respectively) transformed to
+
+            black_version = get_ipython().getoutput('black --version')
+            env = get_ipython().run_line_magic('env', 'var')
+
+        and we look for instances of any of the latter.
+        """
+        if isinstance(node.value, ast.Call) and _is_ipython_magic(node.value.func):
+            args = _get_str_args(node.value.args)
+            if node.value.func.attr == "getoutput":
+                src = f"!{args[0]}"
+            elif node.value.func.attr == "run_line_magic":
+                src = f"%{args[0]}"
+                if args[1]:
+                    src += f" {args[1]}"
+            else:
+                raise AssertionError(
+                    f"Unexpected IPython magic {node.value.func.attr!r} found. "
+                    "Please report a bug on https://github.com/psf/black/issues."
+                ) from None
+            self.magics[node.value.lineno].append(
+                OffsetAndMagic(node.value.col_offset, src)
+            )
+        self.generic_visit(node)
+
+    def visit_Expr(self, node: ast.Expr) -> None:
+        """Look for magics in body of cell.
+
+        For examples,
+
+            !ls
+            !!ls
+            ?ls
+            ??ls
+
+        would (respectively) get transformed to
+
+            get_ipython().system('ls')
+            get_ipython().getoutput('ls')
+            get_ipython().run_line_magic('pinfo', 'ls')
+            get_ipython().run_line_magic('pinfo2', 'ls')
+
+        and we look for instances of any of the latter.
+        """
+        if isinstance(node.value, ast.Call) and _is_ipython_magic(node.value.func):
+            args = _get_str_args(node.value.args)
+            if node.value.func.attr == "run_line_magic":
+                if args[0] == "pinfo":
+                    src = f"?{args[1]}"
+                elif args[0] == "pinfo2":
+                    src = f"??{args[1]}"
+                else:
+                    src = f"%{args[0]}"
+                    if args[1]:
+                        src += f" {args[1]}"
+            elif node.value.func.attr == "system":
+                src = f"!{args[0]}"
+            elif node.value.func.attr == "getoutput":
+                src = f"!!{args[0]}"
+            else:
+                raise NothingChanged  # unsupported magic.
+            self.magics[node.value.lineno].append(
+                OffsetAndMagic(node.value.col_offset, src)
+            )
+        self.generic_visit(node)
diff --git a/myenv/lib/python3.9/site-packages/black/linegen.py b/myenv/lib/python3.9/site-packages/black/linegen.py
new file mode 100644
index 0000000..f234913
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/linegen.py
@@ -0,0 +1,1025 @@
+"""
+Generating lines of code.
+"""
+from functools import partial, wraps
+import sys
+from typing import Collection, Iterator, List, Optional, Set, Union
+
+from black.nodes import WHITESPACE, RARROW, STATEMENT, STANDALONE_COMMENT
+from black.nodes import ASSIGNMENTS, OPENING_BRACKETS, CLOSING_BRACKETS
+from black.nodes import Visitor, syms, first_child_is_arith, ensure_visible
+from black.nodes import is_docstring, is_empty_tuple, is_one_tuple, is_one_tuple_between
+from black.nodes import is_walrus_assignment, is_yield, is_vararg, is_multiline_string
+from black.nodes import is_stub_suite, is_stub_body, is_atom_with_invisible_parens
+from black.nodes import wrap_in_parentheses
+from black.brackets import max_delimiter_priority_in_atom
+from black.brackets import DOT_PRIORITY, COMMA_PRIORITY
+from black.lines import Line, line_to_string, is_line_short_enough
+from black.lines import can_omit_invisible_parens, can_be_split, append_leaves
+from black.comments import generate_comments, list_comments, FMT_OFF
+from black.numerics import normalize_numeric_literal
+from black.strings import get_string_prefix, fix_docstring
+from black.strings import normalize_string_prefix, normalize_string_quotes
+from black.trans import Transformer, CannotTransform, StringMerger
+from black.trans import StringSplitter, StringParenWrapper, StringParenStripper
+from black.mode import Mode
+from black.mode import Feature
+
+from blib2to3.pytree import Node, Leaf
+from blib2to3.pgen2 import token
+
+
+# types
+LeafID = int
+LN = Union[Leaf, Node]
+
+
+class CannotSplit(CannotTransform):
+    """A readable split that fits the allotted line length is impossible."""
+
+
+# This isn't a dataclass because @dataclass + Generic breaks mypyc.
+# See also https://github.com/mypyc/mypyc/issues/827.
+class LineGenerator(Visitor[Line]):
+    """Generates reformatted Line objects.  Empty lines are not emitted.
+
+    Note: destroys the tree it's visiting by mutating prefixes of its leaves
+    in ways that will no longer stringify to valid Python code on the tree.
+    """
+
+    def __init__(self, mode: Mode, remove_u_prefix: bool = False) -> None:
+        self.mode = mode
+        self.remove_u_prefix = remove_u_prefix
+        self.current_line: Line
+        self.__post_init__()
+
+    def line(self, indent: int = 0) -> Iterator[Line]:
+        """Generate a line.
+
+        If the line is empty, only emit if it makes sense.
+        If the line is too long, split it first and then generate.
+
+        If any lines were generated, set up a new current_line.
+        """
+        if not self.current_line:
+            self.current_line.depth += indent
+            return  # Line is empty, don't emit. Creating a new one unnecessary.
+
+        complete_line = self.current_line
+        self.current_line = Line(mode=self.mode, depth=complete_line.depth + indent)
+        yield complete_line
+
+    def visit_default(self, node: LN) -> Iterator[Line]:
+        """Default `visit_*()` implementation. Recurses to children of `node`."""
+        if isinstance(node, Leaf):
+            any_open_brackets = self.current_line.bracket_tracker.any_open_brackets()
+            for comment in generate_comments(node):
+                if any_open_brackets:
+                    # any comment within brackets is subject to splitting
+                    self.current_line.append(comment)
+                elif comment.type == token.COMMENT:
+                    # regular trailing comment
+                    self.current_line.append(comment)
+                    yield from self.line()
+
+                else:
+                    # regular standalone comment
+                    yield from self.line()
+
+                    self.current_line.append(comment)
+                    yield from self.line()
+
+            normalize_prefix(node, inside_brackets=any_open_brackets)
+            if self.mode.string_normalization and node.type == token.STRING:
+                node.value = normalize_string_prefix(
+                    node.value, remove_u_prefix=self.remove_u_prefix
+                )
+                node.value = normalize_string_quotes(node.value)
+            if node.type == token.NUMBER:
+                normalize_numeric_literal(node)
+            if node.type not in WHITESPACE:
+                self.current_line.append(node)
+        yield from super().visit_default(node)
+
+    def visit_INDENT(self, node: Leaf) -> Iterator[Line]:
+        """Increase indentation level, maybe yield a line."""
+        # In blib2to3 INDENT never holds comments.
+        yield from self.line(+1)
+        yield from self.visit_default(node)
+
+    def visit_DEDENT(self, node: Leaf) -> Iterator[Line]:
+        """Decrease indentation level, maybe yield a line."""
+        # The current line might still wait for trailing comments.  At DEDENT time
+        # there won't be any (they would be prefixes on the preceding NEWLINE).
+        # Emit the line then.
+        yield from self.line()
+
+        # While DEDENT has no value, its prefix may contain standalone comments
+        # that belong to the current indentation level.  Get 'em.
+        yield from self.visit_default(node)
+
+        # Finally, emit the dedent.
+        yield from self.line(-1)
+
+    def visit_stmt(
+        self, node: Node, keywords: Set[str], parens: Set[str]
+    ) -> Iterator[Line]:
+        """Visit a statement.
+
+        This implementation is shared for `if`, `while`, `for`, `try`, `except`,
+        `def`, `with`, `class`, `assert`, and assignments.
+
+        The relevant Python language `keywords` for a given statement will be
+        NAME leaves within it. This methods puts those on a separate line.
+
+        `parens` holds a set of string leaf values immediately after which
+        invisible parens should be put.
+        """
+        normalize_invisible_parens(node, parens_after=parens)
+        for child in node.children:
+            if child.type == token.NAME and child.value in keywords:  # type: ignore
+                yield from self.line()
+
+            yield from self.visit(child)
+
+    def visit_match_case(self, node: Node) -> Iterator[Line]:
+        """Visit either a match or case statement."""
+        normalize_invisible_parens(node, parens_after=set())
+
+        yield from self.line()
+        for child in node.children:
+            yield from self.visit(child)
+
+    def visit_suite(self, node: Node) -> Iterator[Line]:
+        """Visit a suite."""
+        if self.mode.is_pyi and is_stub_suite(node):
+            yield from self.visit(node.children[2])
+        else:
+            yield from self.visit_default(node)
+
+    def visit_simple_stmt(self, node: Node) -> Iterator[Line]:
+        """Visit a statement without nested statements."""
+        if first_child_is_arith(node):
+            wrap_in_parentheses(node, node.children[0], visible=False)
+        is_suite_like = node.parent and node.parent.type in STATEMENT
+        if is_suite_like:
+            if self.mode.is_pyi and is_stub_body(node):
+                yield from self.visit_default(node)
+            else:
+                yield from self.line(+1)
+                yield from self.visit_default(node)
+                yield from self.line(-1)
+
+        else:
+            if (
+                not self.mode.is_pyi
+                or not node.parent
+                or not is_stub_suite(node.parent)
+            ):
+                yield from self.line()
+            yield from self.visit_default(node)
+
+    def visit_async_stmt(self, node: Node) -> Iterator[Line]:
+        """Visit `async def`, `async for`, `async with`."""
+        yield from self.line()
+
+        children = iter(node.children)
+        for child in children:
+            yield from self.visit(child)
+
+            if child.type == token.ASYNC:
+                break
+
+        internal_stmt = next(children)
+        for child in internal_stmt.children:
+            yield from self.visit(child)
+
+    def visit_decorators(self, node: Node) -> Iterator[Line]:
+        """Visit decorators."""
+        for child in node.children:
+            yield from self.line()
+            yield from self.visit(child)
+
+    def visit_SEMI(self, leaf: Leaf) -> Iterator[Line]:
+        """Remove a semicolon and put the other statement on a separate line."""
+        yield from self.line()
+
+    def visit_ENDMARKER(self, leaf: Leaf) -> Iterator[Line]:
+        """End of file. Process outstanding comments and end with a newline."""
+        yield from self.visit_default(leaf)
+        yield from self.line()
+
+    def visit_STANDALONE_COMMENT(self, leaf: Leaf) -> Iterator[Line]:
+        if not self.current_line.bracket_tracker.any_open_brackets():
+            yield from self.line()
+        yield from self.visit_default(leaf)
+
+    def visit_factor(self, node: Node) -> Iterator[Line]:
+        """Force parentheses between a unary op and a binary power:
+
+        -2 ** 8 -> -(2 ** 8)
+        """
+        _operator, operand = node.children
+        if (
+            operand.type == syms.power
+            and len(operand.children) == 3
+            and operand.children[1].type == token.DOUBLESTAR
+        ):
+            lpar = Leaf(token.LPAR, "(")
+            rpar = Leaf(token.RPAR, ")")
+            index = operand.remove() or 0
+            node.insert_child(index, Node(syms.atom, [lpar, operand, rpar]))
+        yield from self.visit_default(node)
+
+    def visit_STRING(self, leaf: Leaf) -> Iterator[Line]:
+        if is_docstring(leaf) and "\\\n" not in leaf.value:
+            # We're ignoring docstrings with backslash newline escapes because changing
+            # indentation of those changes the AST representation of the code.
+            docstring = normalize_string_prefix(leaf.value, self.remove_u_prefix)
+            prefix = get_string_prefix(docstring)
+            docstring = docstring[len(prefix) :]  # Remove the prefix
+            quote_char = docstring[0]
+            # A natural way to remove the outer quotes is to do:
+            #   docstring = docstring.strip(quote_char)
+            # but that breaks on """""x""" (which is '""x').
+            # So we actually need to remove the first character and the next two
+            # characters but only if they are the same as the first.
+            quote_len = 1 if docstring[1] != quote_char else 3
+            docstring = docstring[quote_len:-quote_len]
+            docstring_started_empty = not docstring
+
+            if is_multiline_string(leaf):
+                indent = " " * 4 * self.current_line.depth
+                docstring = fix_docstring(docstring, indent)
+            else:
+                docstring = docstring.strip()
+
+            if docstring:
+                # Add some padding if the docstring starts / ends with a quote mark.
+                if docstring[0] == quote_char:
+                    docstring = " " + docstring
+                if docstring[-1] == quote_char:
+                    docstring += " "
+                if docstring[-1] == "\\":
+                    backslash_count = len(docstring) - len(docstring.rstrip("\\"))
+                    if backslash_count % 2:
+                        # Odd number of tailing backslashes, add some padding to
+                        # avoid escaping the closing string quote.
+                        docstring += " "
+            elif not docstring_started_empty:
+                docstring = " "
+
+            # We could enforce triple quotes at this point.
+            quote = quote_char * quote_len
+            leaf.value = prefix + quote + docstring + quote
+
+        yield from self.visit_default(leaf)
+
+    def __post_init__(self) -> None:
+        """You are in a twisty little maze of passages."""
+        self.current_line = Line(mode=self.mode)
+
+        v = self.visit_stmt
+        Ø: Set[str] = set()
+        self.visit_assert_stmt = partial(v, keywords={"assert"}, parens={"assert", ","})
+        self.visit_if_stmt = partial(
+            v, keywords={"if", "else", "elif"}, parens={"if", "elif"}
+        )
+        self.visit_while_stmt = partial(v, keywords={"while", "else"}, parens={"while"})
+        self.visit_for_stmt = partial(v, keywords={"for", "else"}, parens={"for", "in"})
+        self.visit_try_stmt = partial(
+            v, keywords={"try", "except", "else", "finally"}, parens=Ø
+        )
+        self.visit_except_clause = partial(v, keywords={"except"}, parens=Ø)
+        self.visit_with_stmt = partial(v, keywords={"with"}, parens=Ø)
+        self.visit_funcdef = partial(v, keywords={"def"}, parens=Ø)
+        self.visit_classdef = partial(v, keywords={"class"}, parens=Ø)
+        self.visit_expr_stmt = partial(v, keywords=Ø, parens=ASSIGNMENTS)
+        self.visit_return_stmt = partial(v, keywords={"return"}, parens={"return"})
+        self.visit_import_from = partial(v, keywords=Ø, parens={"import"})
+        self.visit_del_stmt = partial(v, keywords=Ø, parens={"del"})
+        self.visit_async_funcdef = self.visit_async_stmt
+        self.visit_decorated = self.visit_decorators
+
+        # PEP 634
+        self.visit_match_stmt = self.visit_match_case
+        self.visit_case_block = self.visit_match_case
+
+
+def transform_line(
+    line: Line, mode: Mode, features: Collection[Feature] = ()
+) -> Iterator[Line]:
+    """Transform a `line`, potentially splitting it into many lines.
+
+    They should fit in the allotted `line_length` but might not be able to.
+
+    `features` are syntactical features that may be used in the output.
+    """
+    if line.is_comment:
+        yield line
+        return
+
+    line_str = line_to_string(line)
+
+    ll = mode.line_length
+    sn = mode.string_normalization
+    string_merge = StringMerger(ll, sn)
+    string_paren_strip = StringParenStripper(ll, sn)
+    string_split = StringSplitter(ll, sn)
+    string_paren_wrap = StringParenWrapper(ll, sn)
+
+    transformers: List[Transformer]
+    if (
+        not line.contains_uncollapsable_type_comments()
+        and not line.should_split_rhs
+        and not line.magic_trailing_comma
+        and (
+            is_line_short_enough(line, line_length=mode.line_length, line_str=line_str)
+            or line.contains_unsplittable_type_ignore()
+        )
+        and not (line.inside_brackets and line.contains_standalone_comments())
+    ):
+        # Only apply basic string preprocessing, since lines shouldn't be split here.
+        if mode.experimental_string_processing:
+            transformers = [string_merge, string_paren_strip]
+        else:
+            transformers = []
+    elif line.is_def:
+        transformers = [left_hand_split]
+    else:
+
+        def _rhs(
+            self: object, line: Line, features: Collection[Feature]
+        ) -> Iterator[Line]:
+            """Wraps calls to `right_hand_split`.
+
+            The calls increasingly `omit` right-hand trailers (bracket pairs with
+            content), meaning the trailers get glued together to split on another
+            bracket pair instead.
+            """
+            for omit in generate_trailers_to_omit(line, mode.line_length):
+                lines = list(
+                    right_hand_split(line, mode.line_length, features, omit=omit)
+                )
+                # Note: this check is only able to figure out if the first line of the
+                # *current* transformation fits in the line length.  This is true only
+                # for simple cases.  All others require running more transforms via
+                # `transform_line()`.  This check doesn't know if those would succeed.
+                if is_line_short_enough(lines[0], line_length=mode.line_length):
+                    yield from lines
+                    return
+
+            # All splits failed, best effort split with no omits.
+            # This mostly happens to multiline strings that are by definition
+            # reported as not fitting a single line, as well as lines that contain
+            # trailing commas (those have to be exploded).
+            yield from right_hand_split(
+                line, line_length=mode.line_length, features=features
+            )
+
+        # HACK: nested functions (like _rhs) compiled by mypyc don't retain their
+        # __name__ attribute which is needed in `run_transformer` further down.
+        # Unfortunately a nested class breaks mypyc too. So a class must be created
+        # via type ... https://github.com/mypyc/mypyc/issues/884
+        rhs = type("rhs", (), {"__call__": _rhs})()
+
+        if mode.experimental_string_processing:
+            if line.inside_brackets:
+                transformers = [
+                    string_merge,
+                    string_paren_strip,
+                    string_split,
+                    delimiter_split,
+                    standalone_comment_split,
+                    string_paren_wrap,
+                    rhs,
+                ]
+            else:
+                transformers = [
+                    string_merge,
+                    string_paren_strip,
+                    string_split,
+                    string_paren_wrap,
+                    rhs,
+                ]
+        else:
+            if line.inside_brackets:
+                transformers = [delimiter_split, standalone_comment_split, rhs]
+            else:
+                transformers = [rhs]
+
+    for transform in transformers:
+        # We are accumulating lines in `result` because we might want to abort
+        # mission and return the original line in the end, or attempt a different
+        # split altogether.
+        try:
+            result = run_transformer(line, transform, mode, features, line_str=line_str)
+        except CannotTransform:
+            continue
+        else:
+            yield from result
+            break
+
+    else:
+        yield line
+
+
+def left_hand_split(line: Line, _features: Collection[Feature] = ()) -> Iterator[Line]:
+    """Split line into many lines, starting with the first matching bracket pair.
+
+    Note: this usually looks weird, only use this for function definitions.
+    Prefer RHS otherwise.  This is why this function is not symmetrical with
+    :func:`right_hand_split` which also handles optional parentheses.
+    """
+    tail_leaves: List[Leaf] = []
+    body_leaves: List[Leaf] = []
+    head_leaves: List[Leaf] = []
+    current_leaves = head_leaves
+    matching_bracket: Optional[Leaf] = None
+    for leaf in line.leaves:
+        if (
+            current_leaves is body_leaves
+            and leaf.type in CLOSING_BRACKETS
+            and leaf.opening_bracket is matching_bracket
+        ):
+            current_leaves = tail_leaves if body_leaves else head_leaves
+        current_leaves.append(leaf)
+        if current_leaves is head_leaves:
+            if leaf.type in OPENING_BRACKETS:
+                matching_bracket = leaf
+                current_leaves = body_leaves
+    if not matching_bracket:
+        raise CannotSplit("No brackets found")
+
+    head = bracket_split_build_line(head_leaves, line, matching_bracket)
+    body = bracket_split_build_line(body_leaves, line, matching_bracket, is_body=True)
+    tail = bracket_split_build_line(tail_leaves, line, matching_bracket)
+    bracket_split_succeeded_or_raise(head, body, tail)
+    for result in (head, body, tail):
+        if result:
+            yield result
+
+
+def right_hand_split(
+    line: Line,
+    line_length: int,
+    features: Collection[Feature] = (),
+    omit: Collection[LeafID] = (),
+) -> Iterator[Line]:
+    """Split line into many lines, starting with the last matching bracket pair.
+
+    If the split was by optional parentheses, attempt splitting without them, too.
+    `omit` is a collection of closing bracket IDs that shouldn't be considered for
+    this split.
+
+    Note: running this function modifies `bracket_depth` on the leaves of `line`.
+    """
+    tail_leaves: List[Leaf] = []
+    body_leaves: List[Leaf] = []
+    head_leaves: List[Leaf] = []
+    current_leaves = tail_leaves
+    opening_bracket: Optional[Leaf] = None
+    closing_bracket: Optional[Leaf] = None
+    for leaf in reversed(line.leaves):
+        if current_leaves is body_leaves:
+            if leaf is opening_bracket:
+                current_leaves = head_leaves if body_leaves else tail_leaves
+        current_leaves.append(leaf)
+        if current_leaves is tail_leaves:
+            if leaf.type in CLOSING_BRACKETS and id(leaf) not in omit:
+                opening_bracket = leaf.opening_bracket
+                closing_bracket = leaf
+                current_leaves = body_leaves
+    if not (opening_bracket and closing_bracket and head_leaves):
+        # If there is no opening or closing_bracket that means the split failed and
+        # all content is in the tail.  Otherwise, if `head_leaves` are empty, it means
+        # the matching `opening_bracket` wasn't available on `line` anymore.
+        raise CannotSplit("No brackets found")
+
+    tail_leaves.reverse()
+    body_leaves.reverse()
+    head_leaves.reverse()
+    head = bracket_split_build_line(head_leaves, line, opening_bracket)
+    body = bracket_split_build_line(body_leaves, line, opening_bracket, is_body=True)
+    tail = bracket_split_build_line(tail_leaves, line, opening_bracket)
+    bracket_split_succeeded_or_raise(head, body, tail)
+    if (
+        Feature.FORCE_OPTIONAL_PARENTHESES not in features
+        # the opening bracket is an optional paren
+        and opening_bracket.type == token.LPAR
+        and not opening_bracket.value
+        # the closing bracket is an optional paren
+        and closing_bracket.type == token.RPAR
+        and not closing_bracket.value
+        # it's not an import (optional parens are the only thing we can split on
+        # in this case; attempting a split without them is a waste of time)
+        and not line.is_import
+        # there are no standalone comments in the body
+        and not body.contains_standalone_comments(0)
+        # and we can actually remove the parens
+        and can_omit_invisible_parens(body, line_length, omit_on_explode=omit)
+    ):
+        omit = {id(closing_bracket), *omit}
+        try:
+            yield from right_hand_split(line, line_length, features=features, omit=omit)
+            return
+
+        except CannotSplit as e:
+            if not (
+                can_be_split(body)
+                or is_line_short_enough(body, line_length=line_length)
+            ):
+                raise CannotSplit(
+                    "Splitting failed, body is still too long and can't be split."
+                ) from e
+
+            elif head.contains_multiline_strings() or tail.contains_multiline_strings():
+                raise CannotSplit(
+                    "The current optional pair of parentheses is bound to fail to"
+                    " satisfy the splitting algorithm because the head or the tail"
+                    " contains multiline strings which by definition never fit one"
+                    " line."
+                ) from e
+
+    ensure_visible(opening_bracket)
+    ensure_visible(closing_bracket)
+    for result in (head, body, tail):
+        if result:
+            yield result
+
+
+def bracket_split_succeeded_or_raise(head: Line, body: Line, tail: Line) -> None:
+    """Raise :exc:`CannotSplit` if the last left- or right-hand split failed.
+
+    Do nothing otherwise.
+
+    A left- or right-hand split is based on a pair of brackets. Content before
+    (and including) the opening bracket is left on one line, content inside the
+    brackets is put on a separate line, and finally content starting with and
+    following the closing bracket is put on a separate line.
+
+    Those are called `head`, `body`, and `tail`, respectively. If the split
+    produced the same line (all content in `head`) or ended up with an empty `body`
+    and the `tail` is just the closing bracket, then it's considered failed.
+    """
+    tail_len = len(str(tail).strip())
+    if not body:
+        if tail_len == 0:
+            raise CannotSplit("Splitting brackets produced the same line")
+
+        elif tail_len < 3:
+            raise CannotSplit(
+                f"Splitting brackets on an empty body to save {tail_len} characters is"
+                " not worth it"
+            )
+
+
+def bracket_split_build_line(
+    leaves: List[Leaf], original: Line, opening_bracket: Leaf, *, is_body: bool = False
+) -> Line:
+    """Return a new line with given `leaves` and respective comments from `original`.
+
+    If `is_body` is True, the result line is one-indented inside brackets and as such
+    has its first leaf's prefix normalized and a trailing comma added when expected.
+    """
+    result = Line(mode=original.mode, depth=original.depth)
+    if is_body:
+        result.inside_brackets = True
+        result.depth += 1
+        if leaves:
+            # Since body is a new indent level, remove spurious leading whitespace.
+            normalize_prefix(leaves[0], inside_brackets=True)
+            # Ensure a trailing comma for imports and standalone function arguments, but
+            # be careful not to add one after any comments or within type annotations.
+            no_commas = (
+                original.is_def
+                and opening_bracket.value == "("
+                and not any(leaf.type == token.COMMA for leaf in leaves)
+                # In particular, don't add one within a parenthesized return annotation.
+                # Unfortunately the indicator we're in a return annotation (RARROW) may
+                # be defined directly in the parent node, the parent of the parent ...
+                # and so on depending on how complex the return annotation is.
+                # This isn't perfect and there's some false negatives but they are in
+                # contexts were a comma is actually fine.
+                and not any(
+                    node.prev_sibling.type == RARROW
+                    for node in (
+                        leaves[0].parent,
+                        getattr(leaves[0].parent, "parent", None),
+                    )
+                    if isinstance(node, Node) and isinstance(node.prev_sibling, Leaf)
+                )
+            )
+
+            if original.is_import or no_commas:
+                for i in range(len(leaves) - 1, -1, -1):
+                    if leaves[i].type == STANDALONE_COMMENT:
+                        continue
+
+                    if leaves[i].type != token.COMMA:
+                        new_comma = Leaf(token.COMMA, ",")
+                        leaves.insert(i + 1, new_comma)
+                    break
+
+    # Populate the line
+    for leaf in leaves:
+        result.append(leaf, preformatted=True)
+        for comment_after in original.comments_after(leaf):
+            result.append(comment_after, preformatted=True)
+    if is_body and should_split_line(result, opening_bracket):
+        result.should_split_rhs = True
+    return result
+
+
+def dont_increase_indentation(split_func: Transformer) -> Transformer:
+    """Normalize prefix of the first leaf in every line returned by `split_func`.
+
+    This is a decorator over relevant split functions.
+    """
+
+    @wraps(split_func)
+    def split_wrapper(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
+        for line in split_func(line, features):
+            normalize_prefix(line.leaves[0], inside_brackets=True)
+            yield line
+
+    return split_wrapper
+
+
+@dont_increase_indentation
+def delimiter_split(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
+    """Split according to delimiters of the highest priority.
+
+    If the appropriate Features are given, the split will add trailing commas
+    also in function signatures and calls that contain `*` and `**`.
+    """
+    try:
+        last_leaf = line.leaves[-1]
+    except IndexError:
+        raise CannotSplit("Line empty") from None
+
+    bt = line.bracket_tracker
+    try:
+        delimiter_priority = bt.max_delimiter_priority(exclude={id(last_leaf)})
+    except ValueError:
+        raise CannotSplit("No delimiters found") from None
+
+    if delimiter_priority == DOT_PRIORITY:
+        if bt.delimiter_count_with_priority(delimiter_priority) == 1:
+            raise CannotSplit("Splitting a single attribute from its owner looks wrong")
+
+    current_line = Line(
+        mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
+    )
+    lowest_depth = sys.maxsize
+    trailing_comma_safe = True
+
+    def append_to_line(leaf: Leaf) -> Iterator[Line]:
+        """Append `leaf` to current line or to new line if appending impossible."""
+        nonlocal current_line
+        try:
+            current_line.append_safe(leaf, preformatted=True)
+        except ValueError:
+            yield current_line
+
+            current_line = Line(
+                mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
+            )
+            current_line.append(leaf)
+
+    for leaf in line.leaves:
+        yield from append_to_line(leaf)
+
+        for comment_after in line.comments_after(leaf):
+            yield from append_to_line(comment_after)
+
+        lowest_depth = min(lowest_depth, leaf.bracket_depth)
+        if leaf.bracket_depth == lowest_depth:
+            if is_vararg(leaf, within={syms.typedargslist}):
+                trailing_comma_safe = (
+                    trailing_comma_safe and Feature.TRAILING_COMMA_IN_DEF in features
+                )
+            elif is_vararg(leaf, within={syms.arglist, syms.argument}):
+                trailing_comma_safe = (
+                    trailing_comma_safe and Feature.TRAILING_COMMA_IN_CALL in features
+                )
+
+        leaf_priority = bt.delimiters.get(id(leaf))
+        if leaf_priority == delimiter_priority:
+            yield current_line
+
+            current_line = Line(
+                mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
+            )
+    if current_line:
+        if (
+            trailing_comma_safe
+            and delimiter_priority == COMMA_PRIORITY
+            and current_line.leaves[-1].type != token.COMMA
+            and current_line.leaves[-1].type != STANDALONE_COMMENT
+        ):
+            new_comma = Leaf(token.COMMA, ",")
+            current_line.append(new_comma)
+        yield current_line
+
+
+@dont_increase_indentation
+def standalone_comment_split(
+    line: Line, features: Collection[Feature] = ()
+) -> Iterator[Line]:
+    """Split standalone comments from the rest of the line."""
+    if not line.contains_standalone_comments(0):
+        raise CannotSplit("Line does not have any standalone comments")
+
+    current_line = Line(
+        mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
+    )
+
+    def append_to_line(leaf: Leaf) -> Iterator[Line]:
+        """Append `leaf` to current line or to new line if appending impossible."""
+        nonlocal current_line
+        try:
+            current_line.append_safe(leaf, preformatted=True)
+        except ValueError:
+            yield current_line
+
+            current_line = Line(
+                line.mode, depth=line.depth, inside_brackets=line.inside_brackets
+            )
+            current_line.append(leaf)
+
+    for leaf in line.leaves:
+        yield from append_to_line(leaf)
+
+        for comment_after in line.comments_after(leaf):
+            yield from append_to_line(comment_after)
+
+    if current_line:
+        yield current_line
+
+
+def normalize_prefix(leaf: Leaf, *, inside_brackets: bool) -> None:
+    """Leave existing extra newlines if not `inside_brackets`. Remove everything
+    else.
+
+    Note: don't use backslashes for formatting or you'll lose your voting rights.
+    """
+    if not inside_brackets:
+        spl = leaf.prefix.split("#")
+        if "\\" not in spl[0]:
+            nl_count = spl[-1].count("\n")
+            if len(spl) > 1:
+                nl_count -= 1
+            leaf.prefix = "\n" * nl_count
+            return
+
+    leaf.prefix = ""
+
+
+def normalize_invisible_parens(node: Node, parens_after: Set[str]) -> None:
+    """Make existing optional parentheses invisible or create new ones.
+
+    `parens_after` is a set of string leaf values immediately after which parens
+    should be put.
+
+    Standardizes on visible parentheses for single-element tuples, and keeps
+    existing visible parentheses for other tuples and generator expressions.
+    """
+    for pc in list_comments(node.prefix, is_endmarker=False):
+        if pc.value in FMT_OFF:
+            # This `node` has a prefix with `# fmt: off`, don't mess with parens.
+            return
+    check_lpar = False
+    for index, child in enumerate(list(node.children)):
+        # Fixes a bug where invisible parens are not properly stripped from
+        # assignment statements that contain type annotations.
+        if isinstance(child, Node) and child.type == syms.annassign:
+            normalize_invisible_parens(child, parens_after=parens_after)
+
+        # Add parentheses around long tuple unpacking in assignments.
+        if (
+            index == 0
+            and isinstance(child, Node)
+            and child.type == syms.testlist_star_expr
+        ):
+            check_lpar = True
+
+        if check_lpar:
+            if child.type == syms.atom:
+                if maybe_make_parens_invisible_in_atom(child, parent=node):
+                    wrap_in_parentheses(node, child, visible=False)
+            elif is_one_tuple(child):
+                wrap_in_parentheses(node, child, visible=True)
+            elif node.type == syms.import_from:
+                # "import from" nodes store parentheses directly as part of
+                # the statement
+                if child.type == token.LPAR:
+                    # make parentheses invisible
+                    child.value = ""  # type: ignore
+                    node.children[-1].value = ""  # type: ignore
+                elif child.type != token.STAR:
+                    # insert invisible parentheses
+                    node.insert_child(index, Leaf(token.LPAR, ""))
+                    node.append_child(Leaf(token.RPAR, ""))
+                break
+
+            elif not (isinstance(child, Leaf) and is_multiline_string(child)):
+                wrap_in_parentheses(node, child, visible=False)
+
+        check_lpar = isinstance(child, Leaf) and child.value in parens_after
+
+
+def maybe_make_parens_invisible_in_atom(node: LN, parent: LN) -> bool:
+    """If it's safe, make the parens in the atom `node` invisible, recursively.
+    Additionally, remove repeated, adjacent invisible parens from the atom `node`
+    as they are redundant.
+
+    Returns whether the node should itself be wrapped in invisible parentheses.
+
+    """
+
+    if (
+        node.type != syms.atom
+        or is_empty_tuple(node)
+        or is_one_tuple(node)
+        or (is_yield(node) and parent.type != syms.expr_stmt)
+        or max_delimiter_priority_in_atom(node) >= COMMA_PRIORITY
+    ):
+        return False
+
+    if is_walrus_assignment(node):
+        if parent.type in [
+            syms.annassign,
+            syms.expr_stmt,
+            syms.assert_stmt,
+            syms.return_stmt,
+            # these ones aren't useful to end users, but they do please fuzzers
+            syms.for_stmt,
+            syms.del_stmt,
+        ]:
+            return False
+
+    first = node.children[0]
+    last = node.children[-1]
+    if first.type == token.LPAR and last.type == token.RPAR:
+        middle = node.children[1]
+        # make parentheses invisible
+        first.value = ""  # type: ignore
+        last.value = ""  # type: ignore
+        maybe_make_parens_invisible_in_atom(middle, parent=parent)
+
+        if is_atom_with_invisible_parens(middle):
+            # Strip the invisible parens from `middle` by replacing
+            # it with the child in-between the invisible parens
+            middle.replace(middle.children[1])
+
+        return False
+
+    return True
+
+
+def should_split_line(line: Line, opening_bracket: Leaf) -> bool:
+    """Should `line` be immediately split with `delimiter_split()` after RHS?"""
+
+    if not (opening_bracket.parent and opening_bracket.value in "[{("):
+        return False
+
+    # We're essentially checking if the body is delimited by commas and there's more
+    # than one of them (we're excluding the trailing comma and if the delimiter priority
+    # is still commas, that means there's more).
+    exclude = set()
+    trailing_comma = False
+    try:
+        last_leaf = line.leaves[-1]
+        if last_leaf.type == token.COMMA:
+            trailing_comma = True
+            exclude.add(id(last_leaf))
+        max_priority = line.bracket_tracker.max_delimiter_priority(exclude=exclude)
+    except (IndexError, ValueError):
+        return False
+
+    return max_priority == COMMA_PRIORITY and (
+        (line.mode.magic_trailing_comma and trailing_comma)
+        # always explode imports
+        or opening_bracket.parent.type in {syms.atom, syms.import_from}
+    )
+
+
+def generate_trailers_to_omit(line: Line, line_length: int) -> Iterator[Set[LeafID]]:
+    """Generate sets of closing bracket IDs that should be omitted in a RHS.
+
+    Brackets can be omitted if the entire trailer up to and including
+    a preceding closing bracket fits in one line.
+
+    Yielded sets are cumulative (contain results of previous yields, too).  First
+    set is empty, unless the line should explode, in which case bracket pairs until
+    the one that needs to explode are omitted.
+    """
+
+    omit: Set[LeafID] = set()
+    if not line.magic_trailing_comma:
+        yield omit
+
+    length = 4 * line.depth
+    opening_bracket: Optional[Leaf] = None
+    closing_bracket: Optional[Leaf] = None
+    inner_brackets: Set[LeafID] = set()
+    for index, leaf, leaf_length in line.enumerate_with_length(reversed=True):
+        length += leaf_length
+        if length > line_length:
+            break
+
+        has_inline_comment = leaf_length > len(leaf.value) + len(leaf.prefix)
+        if leaf.type == STANDALONE_COMMENT or has_inline_comment:
+            break
+
+        if opening_bracket:
+            if leaf is opening_bracket:
+                opening_bracket = None
+            elif leaf.type in CLOSING_BRACKETS:
+                prev = line.leaves[index - 1] if index > 0 else None
+                if (
+                    prev
+                    and prev.type == token.COMMA
+                    and not is_one_tuple_between(
+                        leaf.opening_bracket, leaf, line.leaves
+                    )
+                ):
+                    # Never omit bracket pairs with trailing commas.
+                    # We need to explode on those.
+                    break
+
+                inner_brackets.add(id(leaf))
+        elif leaf.type in CLOSING_BRACKETS:
+            prev = line.leaves[index - 1] if index > 0 else None
+            if prev and prev.type in OPENING_BRACKETS:
+                # Empty brackets would fail a split so treat them as "inner"
+                # brackets (e.g. only add them to the `omit` set if another
+                # pair of brackets was good enough.
+                inner_brackets.add(id(leaf))
+                continue
+
+            if closing_bracket:
+                omit.add(id(closing_bracket))
+                omit.update(inner_brackets)
+                inner_brackets.clear()
+                yield omit
+
+            if (
+                prev
+                and prev.type == token.COMMA
+                and not is_one_tuple_between(leaf.opening_bracket, leaf, line.leaves)
+            ):
+                # Never omit bracket pairs with trailing commas.
+                # We need to explode on those.
+                break
+
+            if leaf.value:
+                opening_bracket = leaf.opening_bracket
+                closing_bracket = leaf
+
+
+def run_transformer(
+    line: Line,
+    transform: Transformer,
+    mode: Mode,
+    features: Collection[Feature],
+    *,
+    line_str: str = "",
+) -> List[Line]:
+    if not line_str:
+        line_str = line_to_string(line)
+    result: List[Line] = []
+    for transformed_line in transform(line, features):
+        if str(transformed_line).strip("\n") == line_str:
+            raise CannotTransform("Line transformer returned an unchanged result")
+
+        result.extend(transform_line(transformed_line, mode=mode, features=features))
+
+    if (
+        transform.__class__.__name__ != "rhs"
+        or not line.bracket_tracker.invisible
+        or any(bracket.value for bracket in line.bracket_tracker.invisible)
+        or line.contains_multiline_strings()
+        or result[0].contains_uncollapsable_type_comments()
+        or result[0].contains_unsplittable_type_ignore()
+        or is_line_short_enough(result[0], line_length=mode.line_length)
+        # If any leaves have no parents (which _can_ occur since
+        # `transform(line)` potentially destroys the line's underlying node
+        # structure), then we can't proceed. Doing so would cause the below
+        # call to `append_leaves()` to fail.
+        or any(leaf.parent is None for leaf in line.leaves)
+    ):
+        return result
+
+    line_copy = line.clone()
+    append_leaves(line_copy, line, line.leaves)
+    features_fop = set(features) | {Feature.FORCE_OPTIONAL_PARENTHESES}
+    second_opinion = run_transformer(
+        line_copy, transform, mode, features_fop, line_str=line_str
+    )
+    if all(
+        is_line_short_enough(ln, line_length=mode.line_length) for ln in second_opinion
+    ):
+        result = second_opinion
+    return result
diff --git a/myenv/lib/python3.9/site-packages/black/lines.py b/myenv/lib/python3.9/site-packages/black/lines.py
new file mode 100644
index 0000000..f2bdada
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/lines.py
@@ -0,0 +1,754 @@
+from dataclasses import dataclass, field
+import itertools
+import sys
+from typing import (
+    Callable,
+    Collection,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    cast,
+)
+
+from blib2to3.pytree import Node, Leaf
+from blib2to3.pgen2 import token
+
+from black.brackets import BracketTracker, DOT_PRIORITY
+from black.mode import Mode
+from black.nodes import STANDALONE_COMMENT, TEST_DESCENDANTS
+from black.nodes import BRACKETS, OPENING_BRACKETS, CLOSING_BRACKETS
+from black.nodes import syms, whitespace, replace_child, child_towards
+from black.nodes import is_multiline_string, is_import, is_type_comment, last_two_except
+from black.nodes import is_one_tuple_between
+
+# types
+T = TypeVar("T")
+Index = int
+LeafID = int
+
+
+@dataclass
+class Line:
+    """Holds leaves and comments. Can be printed with `str(line)`."""
+
+    mode: Mode
+    depth: int = 0
+    leaves: List[Leaf] = field(default_factory=list)
+    # keys ordered like `leaves`
+    comments: Dict[LeafID, List[Leaf]] = field(default_factory=dict)
+    bracket_tracker: BracketTracker = field(default_factory=BracketTracker)
+    inside_brackets: bool = False
+    should_split_rhs: bool = False
+    magic_trailing_comma: Optional[Leaf] = None
+
+    def append(self, leaf: Leaf, preformatted: bool = False) -> None:
+        """Add a new `leaf` to the end of the line.
+
+        Unless `preformatted` is True, the `leaf` will receive a new consistent
+        whitespace prefix and metadata applied by :class:`BracketTracker`.
+        Trailing commas are maybe removed, unpacked for loop variables are
+        demoted from being delimiters.
+
+        Inline comments are put aside.
+        """
+        has_value = leaf.type in BRACKETS or bool(leaf.value.strip())
+        if not has_value:
+            return
+
+        if token.COLON == leaf.type and self.is_class_paren_empty:
+            del self.leaves[-2:]
+        if self.leaves and not preformatted:
+            # Note: at this point leaf.prefix should be empty except for
+            # imports, for which we only preserve newlines.
+            leaf.prefix += whitespace(
+                leaf, complex_subscript=self.is_complex_subscript(leaf)
+            )
+        if self.inside_brackets or not preformatted:
+            self.bracket_tracker.mark(leaf)
+            if self.mode.magic_trailing_comma:
+                if self.has_magic_trailing_comma(leaf):
+                    self.magic_trailing_comma = leaf
+            elif self.has_magic_trailing_comma(leaf, ensure_removable=True):
+                self.remove_trailing_comma()
+        if not self.append_comment(leaf):
+            self.leaves.append(leaf)
+
+    def append_safe(self, leaf: Leaf, preformatted: bool = False) -> None:
+        """Like :func:`append()` but disallow invalid standalone comment structure.
+
+        Raises ValueError when any `leaf` is appended after a standalone comment
+        or when a standalone comment is not the first leaf on the line.
+        """
+        if self.bracket_tracker.depth == 0:
+            if self.is_comment:
+                raise ValueError("cannot append to standalone comments")
+
+            if self.leaves and leaf.type == STANDALONE_COMMENT:
+                raise ValueError(
+                    "cannot append standalone comments to a populated line"
+                )
+
+        self.append(leaf, preformatted=preformatted)
+
+    @property
+    def is_comment(self) -> bool:
+        """Is this line a standalone comment?"""
+        return len(self.leaves) == 1 and self.leaves[0].type == STANDALONE_COMMENT
+
+    @property
+    def is_decorator(self) -> bool:
+        """Is this line a decorator?"""
+        return bool(self) and self.leaves[0].type == token.AT
+
+    @property
+    def is_import(self) -> bool:
+        """Is this an import line?"""
+        return bool(self) and is_import(self.leaves[0])
+
+    @property
+    def is_class(self) -> bool:
+        """Is this line a class definition?"""
+        return (
+            bool(self)
+            and self.leaves[0].type == token.NAME
+            and self.leaves[0].value == "class"
+        )
+
+    @property
+    def is_stub_class(self) -> bool:
+        """Is this line a class definition with a body consisting only of "..."?"""
+        return self.is_class and self.leaves[-3:] == [
+            Leaf(token.DOT, ".") for _ in range(3)
+        ]
+
+    @property
+    def is_def(self) -> bool:
+        """Is this a function definition? (Also returns True for async defs.)"""
+        try:
+            first_leaf = self.leaves[0]
+        except IndexError:
+            return False
+
+        try:
+            second_leaf: Optional[Leaf] = self.leaves[1]
+        except IndexError:
+            second_leaf = None
+        return (first_leaf.type == token.NAME and first_leaf.value == "def") or (
+            first_leaf.type == token.ASYNC
+            and second_leaf is not None
+            and second_leaf.type == token.NAME
+            and second_leaf.value == "def"
+        )
+
+    @property
+    def is_class_paren_empty(self) -> bool:
+        """Is this a class with no base classes but using parentheses?
+
+        Those are unnecessary and should be removed.
+        """
+        return (
+            bool(self)
+            and len(self.leaves) == 4
+            and self.is_class
+            and self.leaves[2].type == token.LPAR
+            and self.leaves[2].value == "("
+            and self.leaves[3].type == token.RPAR
+            and self.leaves[3].value == ")"
+        )
+
+    @property
+    def is_triple_quoted_string(self) -> bool:
+        """Is the line a triple quoted string?"""
+        return (
+            bool(self)
+            and self.leaves[0].type == token.STRING
+            and self.leaves[0].value.startswith(('"""', "'''"))
+        )
+
+    def contains_standalone_comments(self, depth_limit: int = sys.maxsize) -> bool:
+        """If so, needs to be split before emitting."""
+        for leaf in self.leaves:
+            if leaf.type == STANDALONE_COMMENT and leaf.bracket_depth <= depth_limit:
+                return True
+
+        return False
+
+    def contains_uncollapsable_type_comments(self) -> bool:
+        ignored_ids = set()
+        try:
+            last_leaf = self.leaves[-1]
+            ignored_ids.add(id(last_leaf))
+            if last_leaf.type == token.COMMA or (
+                last_leaf.type == token.RPAR and not last_leaf.value
+            ):
+                # When trailing commas or optional parens are inserted by Black for
+                # consistency, comments after the previous last element are not moved
+                # (they don't have to, rendering will still be correct).  So we ignore
+                # trailing commas and invisible.
+                last_leaf = self.leaves[-2]
+                ignored_ids.add(id(last_leaf))
+        except IndexError:
+            return False
+
+        # A type comment is uncollapsable if it is attached to a leaf
+        # that isn't at the end of the line (since that could cause it
+        # to get associated to a different argument) or if there are
+        # comments before it (since that could cause it to get hidden
+        # behind a comment.
+        comment_seen = False
+        for leaf_id, comments in self.comments.items():
+            for comment in comments:
+                if is_type_comment(comment):
+                    if comment_seen or (
+                        not is_type_comment(comment, " ignore")
+                        and leaf_id not in ignored_ids
+                    ):
+                        return True
+
+                comment_seen = True
+
+        return False
+
+    def contains_unsplittable_type_ignore(self) -> bool:
+        if not self.leaves:
+            return False
+
+        # If a 'type: ignore' is attached to the end of a line, we
+        # can't split the line, because we can't know which of the
+        # subexpressions the ignore was meant to apply to.
+        #
+        # We only want this to apply to actual physical lines from the
+        # original source, though: we don't want the presence of a
+        # 'type: ignore' at the end of a multiline expression to
+        # justify pushing it all onto one line. Thus we
+        # (unfortunately) need to check the actual source lines and
+        # only report an unsplittable 'type: ignore' if this line was
+        # one line in the original code.
+
+        # Grab the first and last line numbers, skipping generated leaves
+        first_line = next((leaf.lineno for leaf in self.leaves if leaf.lineno != 0), 0)
+        last_line = next(
+            (leaf.lineno for leaf in reversed(self.leaves) if leaf.lineno != 0), 0
+        )
+
+        if first_line == last_line:
+            # We look at the last two leaves since a comma or an
+            # invisible paren could have been added at the end of the
+            # line.
+            for node in self.leaves[-2:]:
+                for comment in self.comments.get(id(node), []):
+                    if is_type_comment(comment, " ignore"):
+                        return True
+
+        return False
+
+    def contains_multiline_strings(self) -> bool:
+        return any(is_multiline_string(leaf) for leaf in self.leaves)
+
+    def has_magic_trailing_comma(
+        self, closing: Leaf, ensure_removable: bool = False
+    ) -> bool:
+        """Return True if we have a magic trailing comma, that is when:
+        - there's a trailing comma here
+        - it's not a one-tuple
+        Additionally, if ensure_removable:
+        - it's not from square bracket indexing
+        """
+        if not (
+            closing.type in CLOSING_BRACKETS
+            and self.leaves
+            and self.leaves[-1].type == token.COMMA
+        ):
+            return False
+
+        if closing.type == token.RBRACE:
+            return True
+
+        if closing.type == token.RSQB:
+            if not ensure_removable:
+                return True
+            comma = self.leaves[-1]
+            return bool(comma.parent and comma.parent.type == syms.listmaker)
+
+        if self.is_import:
+            return True
+
+        if not is_one_tuple_between(closing.opening_bracket, closing, self.leaves):
+            return True
+
+        return False
+
+    def append_comment(self, comment: Leaf) -> bool:
+        """Add an inline or standalone comment to the line."""
+        if (
+            comment.type == STANDALONE_COMMENT
+            and self.bracket_tracker.any_open_brackets()
+        ):
+            comment.prefix = ""
+            return False
+
+        if comment.type != token.COMMENT:
+            return False
+
+        if not self.leaves:
+            comment.type = STANDALONE_COMMENT
+            comment.prefix = ""
+            return False
+
+        last_leaf = self.leaves[-1]
+        if (
+            last_leaf.type == token.RPAR
+            and not last_leaf.value
+            and last_leaf.parent
+            and len(list(last_leaf.parent.leaves())) <= 3
+            and not is_type_comment(comment)
+        ):
+            # Comments on an optional parens wrapping a single leaf should belong to
+            # the wrapped node except if it's a type comment. Pinning the comment like
+            # this avoids unstable formatting caused by comment migration.
+            if len(self.leaves) < 2:
+                comment.type = STANDALONE_COMMENT
+                comment.prefix = ""
+                return False
+
+            last_leaf = self.leaves[-2]
+        self.comments.setdefault(id(last_leaf), []).append(comment)
+        return True
+
+    def comments_after(self, leaf: Leaf) -> List[Leaf]:
+        """Generate comments that should appear directly after `leaf`."""
+        return self.comments.get(id(leaf), [])
+
+    def remove_trailing_comma(self) -> None:
+        """Remove the trailing comma and moves the comments attached to it."""
+        trailing_comma = self.leaves.pop()
+        trailing_comma_comments = self.comments.pop(id(trailing_comma), [])
+        self.comments.setdefault(id(self.leaves[-1]), []).extend(
+            trailing_comma_comments
+        )
+
+    def is_complex_subscript(self, leaf: Leaf) -> bool:
+        """Return True iff `leaf` is part of a slice with non-trivial exprs."""
+        open_lsqb = self.bracket_tracker.get_open_lsqb()
+        if open_lsqb is None:
+            return False
+
+        subscript_start = open_lsqb.next_sibling
+
+        if isinstance(subscript_start, Node):
+            if subscript_start.type == syms.listmaker:
+                return False
+
+            if subscript_start.type == syms.subscriptlist:
+                subscript_start = child_towards(subscript_start, leaf)
+        return subscript_start is not None and any(
+            n.type in TEST_DESCENDANTS for n in subscript_start.pre_order()
+        )
+
+    def enumerate_with_length(
+        self, reversed: bool = False
+    ) -> Iterator[Tuple[Index, Leaf, int]]:
+        """Return an enumeration of leaves with their length.
+
+        Stops prematurely on multiline strings and standalone comments.
+        """
+        op = cast(
+            Callable[[Sequence[Leaf]], Iterator[Tuple[Index, Leaf]]],
+            enumerate_reversed if reversed else enumerate,
+        )
+        for index, leaf in op(self.leaves):
+            length = len(leaf.prefix) + len(leaf.value)
+            if "\n" in leaf.value:
+                return  # Multiline strings, we can't continue.
+
+            for comment in self.comments_after(leaf):
+                length += len(comment.value)
+
+            yield index, leaf, length
+
+    def clone(self) -> "Line":
+        return Line(
+            mode=self.mode,
+            depth=self.depth,
+            inside_brackets=self.inside_brackets,
+            should_split_rhs=self.should_split_rhs,
+            magic_trailing_comma=self.magic_trailing_comma,
+        )
+
+    def __str__(self) -> str:
+        """Render the line."""
+        if not self:
+            return "\n"
+
+        indent = "    " * self.depth
+        leaves = iter(self.leaves)
+        first = next(leaves)
+        res = f"{first.prefix}{indent}{first.value}"
+        for leaf in leaves:
+            res += str(leaf)
+        for comment in itertools.chain.from_iterable(self.comments.values()):
+            res += str(comment)
+
+        return res + "\n"
+
+    def __bool__(self) -> bool:
+        """Return True if the line has leaves or comments."""
+        return bool(self.leaves or self.comments)
+
+
+@dataclass
+class EmptyLineTracker:
+    """Provides a stateful method that returns the number of potential extra
+    empty lines needed before and after the currently processed line.
+
+    Note: this tracker works on lines that haven't been split yet.  It assumes
+    the prefix of the first leaf consists of optional newlines.  Those newlines
+    are consumed by `maybe_empty_lines()` and included in the computation.
+    """
+
+    is_pyi: bool = False
+    previous_line: Optional[Line] = None
+    previous_after: int = 0
+    previous_defs: List[int] = field(default_factory=list)
+
+    def maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
+        """Return the number of extra empty lines before and after the `current_line`.
+
+        This is for separating `def`, `async def` and `class` with extra empty
+        lines (two on module-level).
+        """
+        before, after = self._maybe_empty_lines(current_line)
+        before = (
+            # Black should not insert empty lines at the beginning
+            # of the file
+            0
+            if self.previous_line is None
+            else before - self.previous_after
+        )
+        self.previous_after = after
+        self.previous_line = current_line
+        return before, after
+
+    def _maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
+        max_allowed = 1
+        if current_line.depth == 0:
+            max_allowed = 1 if self.is_pyi else 2
+        if current_line.leaves:
+            # Consume the first leaf's extra newlines.
+            first_leaf = current_line.leaves[0]
+            before = first_leaf.prefix.count("\n")
+            before = min(before, max_allowed)
+            first_leaf.prefix = ""
+        else:
+            before = 0
+        depth = current_line.depth
+        while self.previous_defs and self.previous_defs[-1] >= depth:
+            if self.is_pyi:
+                before = 0 if depth else 1
+            else:
+                if depth:
+                    before = 1
+                elif (
+                    not depth
+                    and self.previous_defs[-1]
+                    and current_line.leaves[-1].type == token.COLON
+                    and (
+                        current_line.leaves[0].value
+                        not in ("with", "try", "for", "while", "if", "match")
+                    )
+                ):
+                    # We shouldn't add two newlines between an indented function and
+                    # a dependent non-indented clause. This is to avoid issues with
+                    # conditional function definitions that are technically top-level
+                    # and therefore get two trailing newlines, but look weird and
+                    # inconsistent when they're followed by elif, else, etc. This is
+                    # worse because these functions only get *one* preceding newline
+                    # already.
+                    before = 1
+                else:
+                    before = 2
+            self.previous_defs.pop()
+        if current_line.is_decorator or current_line.is_def or current_line.is_class:
+            return self._maybe_empty_lines_for_class_or_def(current_line, before)
+
+        if (
+            self.previous_line
+            and self.previous_line.is_import
+            and not current_line.is_import
+            and depth == self.previous_line.depth
+        ):
+            return (before or 1), 0
+
+        if (
+            self.previous_line
+            and self.previous_line.is_class
+            and current_line.is_triple_quoted_string
+        ):
+            return before, 1
+
+        return before, 0
+
+    def _maybe_empty_lines_for_class_or_def(
+        self, current_line: Line, before: int
+    ) -> Tuple[int, int]:
+        if not current_line.is_decorator:
+            self.previous_defs.append(current_line.depth)
+        if self.previous_line is None:
+            # Don't insert empty lines before the first line in the file.
+            return 0, 0
+
+        if self.previous_line.is_decorator:
+            if self.is_pyi and current_line.is_stub_class:
+                # Insert an empty line after a decorated stub class
+                return 0, 1
+
+            return 0, 0
+
+        if self.previous_line.depth < current_line.depth and (
+            self.previous_line.is_class or self.previous_line.is_def
+        ):
+            return 0, 0
+
+        if (
+            self.previous_line.is_comment
+            and self.previous_line.depth == current_line.depth
+            and before == 0
+        ):
+            return 0, 0
+
+        if self.is_pyi:
+            if self.previous_line.depth > current_line.depth:
+                newlines = 1
+            elif current_line.is_class or self.previous_line.is_class:
+                if current_line.is_stub_class and self.previous_line.is_stub_class:
+                    # No blank line between classes with an empty body
+                    newlines = 0
+                else:
+                    newlines = 1
+            elif (
+                current_line.is_def or current_line.is_decorator
+            ) and not self.previous_line.is_def:
+                # Blank line between a block of functions (maybe with preceding
+                # decorators) and a block of non-functions
+                newlines = 1
+            else:
+                newlines = 0
+        else:
+            newlines = 2
+        if current_line.depth and newlines:
+            newlines -= 1
+        return newlines, 0
+
+
+def enumerate_reversed(sequence: Sequence[T]) -> Iterator[Tuple[Index, T]]:
+    """Like `reversed(enumerate(sequence))` if that were possible."""
+    index = len(sequence) - 1
+    for element in reversed(sequence):
+        yield (index, element)
+        index -= 1
+
+
+def append_leaves(
+    new_line: Line, old_line: Line, leaves: List[Leaf], preformatted: bool = False
+) -> None:
+    """
+    Append leaves (taken from @old_line) to @new_line, making sure to fix the
+    underlying Node structure where appropriate.
+
+    All of the leaves in @leaves are duplicated. The duplicates are then
+    appended to @new_line and used to replace their originals in the underlying
+    Node structure. Any comments attached to the old leaves are reattached to
+    the new leaves.
+
+    Pre-conditions:
+        set(@leaves) is a subset of set(@old_line.leaves).
+    """
+    for old_leaf in leaves:
+        new_leaf = Leaf(old_leaf.type, old_leaf.value)
+        replace_child(old_leaf, new_leaf)
+        new_line.append(new_leaf, preformatted=preformatted)
+
+        for comment_leaf in old_line.comments_after(old_leaf):
+            new_line.append(comment_leaf, preformatted=True)
+
+
+def is_line_short_enough(line: Line, *, line_length: int, line_str: str = "") -> bool:
+    """Return True if `line` is no longer than `line_length`.
+
+    Uses the provided `line_str` rendering, if any, otherwise computes a new one.
+    """
+    if not line_str:
+        line_str = line_to_string(line)
+    return (
+        len(line_str) <= line_length
+        and "\n" not in line_str  # multiline strings
+        and not line.contains_standalone_comments()
+    )
+
+
+def can_be_split(line: Line) -> bool:
+    """Return False if the line cannot be split *for sure*.
+
+    This is not an exhaustive search but a cheap heuristic that we can use to
+    avoid some unfortunate formattings (mostly around wrapping unsplittable code
+    in unnecessary parentheses).
+    """
+    leaves = line.leaves
+    if len(leaves) < 2:
+        return False
+
+    if leaves[0].type == token.STRING and leaves[1].type == token.DOT:
+        call_count = 0
+        dot_count = 0
+        next = leaves[-1]
+        for leaf in leaves[-2::-1]:
+            if leaf.type in OPENING_BRACKETS:
+                if next.type not in CLOSING_BRACKETS:
+                    return False
+
+                call_count += 1
+            elif leaf.type == token.DOT:
+                dot_count += 1
+            elif leaf.type == token.NAME:
+                if not (next.type == token.DOT or next.type in OPENING_BRACKETS):
+                    return False
+
+            elif leaf.type not in CLOSING_BRACKETS:
+                return False
+
+            if dot_count > 1 and call_count > 1:
+                return False
+
+    return True
+
+
+def can_omit_invisible_parens(
+    line: Line,
+    line_length: int,
+    omit_on_explode: Collection[LeafID] = (),
+) -> bool:
+    """Does `line` have a shape safe to reformat without optional parens around it?
+
+    Returns True for only a subset of potentially nice looking formattings but
+    the point is to not return false positives that end up producing lines that
+    are too long.
+    """
+    bt = line.bracket_tracker
+    if not bt.delimiters:
+        # Without delimiters the optional parentheses are useless.
+        return True
+
+    max_priority = bt.max_delimiter_priority()
+    if bt.delimiter_count_with_priority(max_priority) > 1:
+        # With more than one delimiter of a kind the optional parentheses read better.
+        return False
+
+    if max_priority == DOT_PRIORITY:
+        # A single stranded method call doesn't require optional parentheses.
+        return True
+
+    assert len(line.leaves) >= 2, "Stranded delimiter"
+
+    # With a single delimiter, omit if the expression starts or ends with
+    # a bracket.
+    first = line.leaves[0]
+    second = line.leaves[1]
+    if first.type in OPENING_BRACKETS and second.type not in CLOSING_BRACKETS:
+        if _can_omit_opening_paren(line, first=first, line_length=line_length):
+            return True
+
+        # Note: we are not returning False here because a line might have *both*
+        # a leading opening bracket and a trailing closing bracket.  If the
+        # opening bracket doesn't match our rule, maybe the closing will.
+
+    penultimate = line.leaves[-2]
+    last = line.leaves[-1]
+    if line.magic_trailing_comma:
+        try:
+            penultimate, last = last_two_except(line.leaves, omit=omit_on_explode)
+        except LookupError:
+            # Turns out we'd omit everything.  We cannot skip the optional parentheses.
+            return False
+
+    if (
+        last.type == token.RPAR
+        or last.type == token.RBRACE
+        or (
+            # don't use indexing for omitting optional parentheses;
+            # it looks weird
+            last.type == token.RSQB
+            and last.parent
+            and last.parent.type != syms.trailer
+        )
+    ):
+        if penultimate.type in OPENING_BRACKETS:
+            # Empty brackets don't help.
+            return False
+
+        if is_multiline_string(first):
+            # Additional wrapping of a multiline string in this situation is
+            # unnecessary.
+            return True
+
+        if line.magic_trailing_comma and penultimate.type == token.COMMA:
+            # The rightmost non-omitted bracket pair is the one we want to explode on.
+            return True
+
+        if _can_omit_closing_paren(line, last=last, line_length=line_length):
+            return True
+
+    return False
+
+
+def _can_omit_opening_paren(line: Line, *, first: Leaf, line_length: int) -> bool:
+    """See `can_omit_invisible_parens`."""
+    remainder = False
+    length = 4 * line.depth
+    _index = -1
+    for _index, leaf, leaf_length in line.enumerate_with_length():
+        if leaf.type in CLOSING_BRACKETS and leaf.opening_bracket is first:
+            remainder = True
+        if remainder:
+            length += leaf_length
+            if length > line_length:
+                break
+
+            if leaf.type in OPENING_BRACKETS:
+                # There are brackets we can further split on.
+                remainder = False
+
+    else:
+        # checked the entire string and line length wasn't exceeded
+        if len(line.leaves) == _index + 1:
+            return True
+
+    return False
+
+
+def _can_omit_closing_paren(line: Line, *, last: Leaf, line_length: int) -> bool:
+    """See `can_omit_invisible_parens`."""
+    length = 4 * line.depth
+    seen_other_brackets = False
+    for _index, leaf, leaf_length in line.enumerate_with_length():
+        length += leaf_length
+        if leaf is last.opening_bracket:
+            if seen_other_brackets or length <= line_length:
+                return True
+
+        elif leaf.type in OPENING_BRACKETS:
+            # There are brackets we can further split on.
+            seen_other_brackets = True
+
+    return False
+
+
+def line_to_string(line: Line) -> str:
+    """Returns the string representation of @line.
+
+    WARNING: This is known to be computationally expensive.
+    """
+    return str(line).strip("\n")
diff --git a/myenv/lib/python3.9/site-packages/black/mode.py b/myenv/lib/python3.9/site-packages/black/mode.py
new file mode 100644
index 0000000..e241753
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/mode.py
@@ -0,0 +1,160 @@
+"""Data structures configuring Black behavior.
+
+Mostly around Python language feature support per version and Black configuration
+chosen by the user.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from operator import attrgetter
+from typing import Dict, Set
+
+from black.const import DEFAULT_LINE_LENGTH
+
+
+class TargetVersion(Enum):
+    PY27 = 2
+    PY33 = 3
+    PY34 = 4
+    PY35 = 5
+    PY36 = 6
+    PY37 = 7
+    PY38 = 8
+    PY39 = 9
+    PY310 = 10
+
+    def is_python2(self) -> bool:
+        return self is TargetVersion.PY27
+
+
+class Feature(Enum):
+    # All string literals are unicode
+    UNICODE_LITERALS = 1
+    F_STRINGS = 2
+    NUMERIC_UNDERSCORES = 3
+    TRAILING_COMMA_IN_CALL = 4
+    TRAILING_COMMA_IN_DEF = 5
+    # The following two feature-flags are mutually exclusive, and exactly one should be
+    # set for every version of python.
+    ASYNC_IDENTIFIERS = 6
+    ASYNC_KEYWORDS = 7
+    ASSIGNMENT_EXPRESSIONS = 8
+    POS_ONLY_ARGUMENTS = 9
+    RELAXED_DECORATORS = 10
+    PATTERN_MATCHING = 11
+    FORCE_OPTIONAL_PARENTHESES = 50
+
+    # temporary for Python 2 deprecation
+    PRINT_STMT = 200
+    EXEC_STMT = 201
+    AUTOMATIC_PARAMETER_UNPACKING = 202
+    COMMA_STYLE_EXCEPT = 203
+    COMMA_STYLE_RAISE = 204
+    LONG_INT_LITERAL = 205
+    OCTAL_INT_LITERAL = 206
+    BACKQUOTE_REPR = 207
+
+
+VERSION_TO_FEATURES: Dict[TargetVersion, Set[Feature]] = {
+    TargetVersion.PY27: {
+        Feature.ASYNC_IDENTIFIERS,
+        Feature.PRINT_STMT,
+        Feature.EXEC_STMT,
+        Feature.AUTOMATIC_PARAMETER_UNPACKING,
+        Feature.COMMA_STYLE_EXCEPT,
+        Feature.COMMA_STYLE_RAISE,
+        Feature.LONG_INT_LITERAL,
+        Feature.OCTAL_INT_LITERAL,
+        Feature.BACKQUOTE_REPR,
+    },
+    TargetVersion.PY33: {Feature.UNICODE_LITERALS, Feature.ASYNC_IDENTIFIERS},
+    TargetVersion.PY34: {Feature.UNICODE_LITERALS, Feature.ASYNC_IDENTIFIERS},
+    TargetVersion.PY35: {
+        Feature.UNICODE_LITERALS,
+        Feature.TRAILING_COMMA_IN_CALL,
+        Feature.ASYNC_IDENTIFIERS,
+    },
+    TargetVersion.PY36: {
+        Feature.UNICODE_LITERALS,
+        Feature.F_STRINGS,
+        Feature.NUMERIC_UNDERSCORES,
+        Feature.TRAILING_COMMA_IN_CALL,
+        Feature.TRAILING_COMMA_IN_DEF,
+        Feature.ASYNC_IDENTIFIERS,
+    },
+    TargetVersion.PY37: {
+        Feature.UNICODE_LITERALS,
+        Feature.F_STRINGS,
+        Feature.NUMERIC_UNDERSCORES,
+        Feature.TRAILING_COMMA_IN_CALL,
+        Feature.TRAILING_COMMA_IN_DEF,
+        Feature.ASYNC_KEYWORDS,
+    },
+    TargetVersion.PY38: {
+        Feature.UNICODE_LITERALS,
+        Feature.F_STRINGS,
+        Feature.NUMERIC_UNDERSCORES,
+        Feature.TRAILING_COMMA_IN_CALL,
+        Feature.TRAILING_COMMA_IN_DEF,
+        Feature.ASYNC_KEYWORDS,
+        Feature.ASSIGNMENT_EXPRESSIONS,
+        Feature.POS_ONLY_ARGUMENTS,
+    },
+    TargetVersion.PY39: {
+        Feature.UNICODE_LITERALS,
+        Feature.F_STRINGS,
+        Feature.NUMERIC_UNDERSCORES,
+        Feature.TRAILING_COMMA_IN_CALL,
+        Feature.TRAILING_COMMA_IN_DEF,
+        Feature.ASYNC_KEYWORDS,
+        Feature.ASSIGNMENT_EXPRESSIONS,
+        Feature.RELAXED_DECORATORS,
+        Feature.POS_ONLY_ARGUMENTS,
+    },
+    TargetVersion.PY310: {
+        Feature.UNICODE_LITERALS,
+        Feature.F_STRINGS,
+        Feature.NUMERIC_UNDERSCORES,
+        Feature.TRAILING_COMMA_IN_CALL,
+        Feature.TRAILING_COMMA_IN_DEF,
+        Feature.ASYNC_KEYWORDS,
+        Feature.ASSIGNMENT_EXPRESSIONS,
+        Feature.RELAXED_DECORATORS,
+        Feature.POS_ONLY_ARGUMENTS,
+        Feature.PATTERN_MATCHING,
+    },
+}
+
+
+def supports_feature(target_versions: Set[TargetVersion], feature: Feature) -> bool:
+    return all(feature in VERSION_TO_FEATURES[version] for version in target_versions)
+
+
+@dataclass
+class Mode:
+    target_versions: Set[TargetVersion] = field(default_factory=set)
+    line_length: int = DEFAULT_LINE_LENGTH
+    string_normalization: bool = True
+    is_pyi: bool = False
+    is_ipynb: bool = False
+    magic_trailing_comma: bool = True
+    experimental_string_processing: bool = False
+
+    def get_cache_key(self) -> str:
+        if self.target_versions:
+            version_str = ",".join(
+                str(version.value)
+                for version in sorted(self.target_versions, key=attrgetter("value"))
+            )
+        else:
+            version_str = "-"
+        parts = [
+            version_str,
+            str(self.line_length),
+            str(int(self.string_normalization)),
+            str(int(self.is_pyi)),
+            str(int(self.is_ipynb)),
+            str(int(self.magic_trailing_comma)),
+            str(int(self.experimental_string_processing)),
+        ]
+        return ".".join(parts)
diff --git a/myenv/lib/python3.9/site-packages/black/nodes.py b/myenv/lib/python3.9/site-packages/black/nodes.py
new file mode 100644
index 0000000..8bf1934
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/nodes.py
@@ -0,0 +1,856 @@
+"""
+blib2to3 Node/Leaf transformation-related utility functions.
+"""
+
+import sys
+from typing import (
+    Collection,
+    Generic,
+    Iterator,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    TypeVar,
+    Union,
+)
+
+if sys.version_info >= (3, 8):
+    from typing import Final
+else:
+    from typing_extensions import Final
+
+from mypy_extensions import mypyc_attr
+
+# lib2to3 fork
+from blib2to3.pytree import Node, Leaf, type_repr
+from blib2to3 import pygram
+from blib2to3.pgen2 import token
+
+from black.cache import CACHE_DIR
+from black.strings import has_triple_quotes
+
+
+pygram.initialize(CACHE_DIR)
+syms: Final = pygram.python_symbols
+
+
+# types
+T = TypeVar("T")
+LN = Union[Leaf, Node]
+LeafID = int
+NodeType = int
+
+
+WHITESPACE: Final = {token.DEDENT, token.INDENT, token.NEWLINE}
+STATEMENT: Final = {
+    syms.if_stmt,
+    syms.while_stmt,
+    syms.for_stmt,
+    syms.try_stmt,
+    syms.except_clause,
+    syms.with_stmt,
+    syms.funcdef,
+    syms.classdef,
+    syms.match_stmt,
+    syms.case_block,
+}
+STANDALONE_COMMENT: Final = 153
+token.tok_name[STANDALONE_COMMENT] = "STANDALONE_COMMENT"
+LOGIC_OPERATORS: Final = {"and", "or"}
+COMPARATORS: Final = {
+    token.LESS,
+    token.GREATER,
+    token.EQEQUAL,
+    token.NOTEQUAL,
+    token.LESSEQUAL,
+    token.GREATEREQUAL,
+}
+MATH_OPERATORS: Final = {
+    token.VBAR,
+    token.CIRCUMFLEX,
+    token.AMPER,
+    token.LEFTSHIFT,
+    token.RIGHTSHIFT,
+    token.PLUS,
+    token.MINUS,
+    token.STAR,
+    token.SLASH,
+    token.DOUBLESLASH,
+    token.PERCENT,
+    token.AT,
+    token.TILDE,
+    token.DOUBLESTAR,
+}
+STARS: Final = {token.STAR, token.DOUBLESTAR}
+VARARGS_SPECIALS: Final = STARS | {token.SLASH}
+VARARGS_PARENTS: Final = {
+    syms.arglist,
+    syms.argument,  # double star in arglist
+    syms.trailer,  # single argument to call
+    syms.typedargslist,
+    syms.varargslist,  # lambdas
+}
+UNPACKING_PARENTS: Final = {
+    syms.atom,  # single element of a list or set literal
+    syms.dictsetmaker,
+    syms.listmaker,
+    syms.testlist_gexp,
+    syms.testlist_star_expr,
+    syms.subject_expr,
+    syms.pattern,
+}
+TEST_DESCENDANTS: Final = {
+    syms.test,
+    syms.lambdef,
+    syms.or_test,
+    syms.and_test,
+    syms.not_test,
+    syms.comparison,
+    syms.star_expr,
+    syms.expr,
+    syms.xor_expr,
+    syms.and_expr,
+    syms.shift_expr,
+    syms.arith_expr,
+    syms.trailer,
+    syms.term,
+    syms.power,
+}
+ASSIGNMENTS: Final = {
+    "=",
+    "+=",
+    "-=",
+    "*=",
+    "@=",
+    "/=",
+    "%=",
+    "&=",
+    "|=",
+    "^=",
+    "<<=",
+    ">>=",
+    "**=",
+    "//=",
+}
+
+IMPLICIT_TUPLE: Final = {syms.testlist, syms.testlist_star_expr, syms.exprlist}
+BRACKET: Final = {
+    token.LPAR: token.RPAR,
+    token.LSQB: token.RSQB,
+    token.LBRACE: token.RBRACE,
+}
+OPENING_BRACKETS: Final = set(BRACKET.keys())
+CLOSING_BRACKETS: Final = set(BRACKET.values())
+BRACKETS: Final = OPENING_BRACKETS | CLOSING_BRACKETS
+ALWAYS_NO_SPACE: Final = CLOSING_BRACKETS | {token.COMMA, STANDALONE_COMMENT}
+
+RARROW = 55
+
+
+@mypyc_attr(allow_interpreted_subclasses=True)
+class Visitor(Generic[T]):
+    """Basic lib2to3 visitor that yields things of type `T` on `visit()`."""
+
+    def visit(self, node: LN) -> Iterator[T]:
+        """Main method to visit `node` and its children.
+
+        It tries to find a `visit_*()` method for the given `node.type`, like
+        `visit_simple_stmt` for Node objects or `visit_INDENT` for Leaf objects.
+        If no dedicated `visit_*()` method is found, chooses `visit_default()`
+        instead.
+
+        Then yields objects of type `T` from the selected visitor.
+        """
+        if node.type < 256:
+            name = token.tok_name[node.type]
+        else:
+            name = str(type_repr(node.type))
+        # We explicitly branch on whether a visitor exists (instead of
+        # using self.visit_default as the default arg to getattr) in order
+        # to save needing to create a bound method object and so mypyc can
+        # generate a native call to visit_default.
+        visitf = getattr(self, f"visit_{name}", None)
+        if visitf:
+            yield from visitf(node)
+        else:
+            yield from self.visit_default(node)
+
+    def visit_default(self, node: LN) -> Iterator[T]:
+        """Default `visit_*()` implementation. Recurses to children of `node`."""
+        if isinstance(node, Node):
+            for child in node.children:
+                yield from self.visit(child)
+
+
+def whitespace(leaf: Leaf, *, complex_subscript: bool) -> str:  # noqa: C901
+    """Return whitespace prefix if needed for the given `leaf`.
+
+    `complex_subscript` signals whether the given leaf is part of a subscription
+    which has non-trivial arguments, like arithmetic expressions or function calls.
+    """
+    NO: Final = ""
+    SPACE: Final = " "
+    DOUBLESPACE: Final = "  "
+    t = leaf.type
+    p = leaf.parent
+    v = leaf.value
+    if t in ALWAYS_NO_SPACE:
+        return NO
+
+    if t == token.COMMENT:
+        return DOUBLESPACE
+
+    assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
+    if t == token.COLON and p.type not in {
+        syms.subscript,
+        syms.subscriptlist,
+        syms.sliceop,
+    }:
+        return NO
+
+    prev = leaf.prev_sibling
+    if not prev:
+        prevp = preceding_leaf(p)
+        if not prevp or prevp.type in OPENING_BRACKETS:
+            return NO
+
+        if t == token.COLON:
+            if prevp.type == token.COLON:
+                return NO
+
+            elif prevp.type != token.COMMA and not complex_subscript:
+                return NO
+
+            return SPACE
+
+        if prevp.type == token.EQUAL:
+            if prevp.parent:
+                if prevp.parent.type in {
+                    syms.arglist,
+                    syms.argument,
+                    syms.parameters,
+                    syms.varargslist,
+                }:
+                    return NO
+
+                elif prevp.parent.type == syms.typedargslist:
+                    # A bit hacky: if the equal sign has whitespace, it means we
+                    # previously found it's a typed argument.  So, we're using
+                    # that, too.
+                    return prevp.prefix
+
+        elif prevp.type in VARARGS_SPECIALS:
+            if is_vararg(prevp, within=VARARGS_PARENTS | UNPACKING_PARENTS):
+                return NO
+
+        elif prevp.type == token.COLON:
+            if prevp.parent and prevp.parent.type in {syms.subscript, syms.sliceop}:
+                return SPACE if complex_subscript else NO
+
+        elif (
+            prevp.parent
+            and prevp.parent.type == syms.factor
+            and prevp.type in MATH_OPERATORS
+        ):
+            return NO
+
+        elif (
+            prevp.type == token.RIGHTSHIFT
+            and prevp.parent
+            and prevp.parent.type == syms.shift_expr
+            and prevp.prev_sibling
+            and prevp.prev_sibling.type == token.NAME
+            and prevp.prev_sibling.value == "print"  # type: ignore
+        ):
+            # Python 2 print chevron
+            return NO
+        elif prevp.type == token.AT and p.parent and p.parent.type == syms.decorator:
+            # no space in decorators
+            return NO
+
+    elif prev.type in OPENING_BRACKETS:
+        return NO
+
+    if p.type in {syms.parameters, syms.arglist}:
+        # untyped function signatures or calls
+        if not prev or prev.type != token.COMMA:
+            return NO
+
+    elif p.type == syms.varargslist:
+        # lambdas
+        if prev and prev.type != token.COMMA:
+            return NO
+
+    elif p.type == syms.typedargslist:
+        # typed function signatures
+        if not prev:
+            return NO
+
+        if t == token.EQUAL:
+            if prev.type != syms.tname:
+                return NO
+
+        elif prev.type == token.EQUAL:
+            # A bit hacky: if the equal sign has whitespace, it means we
+            # previously found it's a typed argument.  So, we're using that, too.
+            return prev.prefix
+
+        elif prev.type != token.COMMA:
+            return NO
+
+    elif p.type == syms.tname:
+        # type names
+        if not prev:
+            prevp = preceding_leaf(p)
+            if not prevp or prevp.type != token.COMMA:
+                return NO
+
+    elif p.type == syms.trailer:
+        # attributes and calls
+        if t == token.LPAR or t == token.RPAR:
+            return NO
+
+        if not prev:
+            if t == token.DOT:
+                prevp = preceding_leaf(p)
+                if not prevp or prevp.type != token.NUMBER:
+                    return NO
+
+            elif t == token.LSQB:
+                return NO
+
+        elif prev.type != token.COMMA:
+            return NO
+
+    elif p.type == syms.argument:
+        # single argument
+        if t == token.EQUAL:
+            return NO
+
+        if not prev:
+            prevp = preceding_leaf(p)
+            if not prevp or prevp.type == token.LPAR:
+                return NO
+
+        elif prev.type in {token.EQUAL} | VARARGS_SPECIALS:
+            return NO
+
+    elif p.type == syms.decorator:
+        # decorators
+        return NO
+
+    elif p.type == syms.dotted_name:
+        if prev:
+            return NO
+
+        prevp = preceding_leaf(p)
+        if not prevp or prevp.type == token.AT or prevp.type == token.DOT:
+            return NO
+
+    elif p.type == syms.classdef:
+        if t == token.LPAR:
+            return NO
+
+        if prev and prev.type == token.LPAR:
+            return NO
+
+    elif p.type in {syms.subscript, syms.sliceop}:
+        # indexing
+        if not prev:
+            assert p.parent is not None, "subscripts are always parented"
+            if p.parent.type == syms.subscriptlist:
+                return SPACE
+
+            return NO
+
+        elif not complex_subscript:
+            return NO
+
+    elif p.type == syms.atom:
+        if prev and t == token.DOT:
+            # dots, but not the first one.
+            return NO
+
+    elif p.type == syms.dictsetmaker:
+        # dict unpacking
+        if prev and prev.type == token.DOUBLESTAR:
+            return NO
+
+    elif p.type in {syms.factor, syms.star_expr}:
+        # unary ops
+        if not prev:
+            prevp = preceding_leaf(p)
+            if not prevp or prevp.type in OPENING_BRACKETS:
+                return NO
+
+            prevp_parent = prevp.parent
+            assert prevp_parent is not None
+            if prevp.type == token.COLON and prevp_parent.type in {
+                syms.subscript,
+                syms.sliceop,
+            }:
+                return NO
+
+            elif prevp.type == token.EQUAL and prevp_parent.type == syms.argument:
+                return NO
+
+        elif t in {token.NAME, token.NUMBER, token.STRING}:
+            return NO
+
+    elif p.type == syms.import_from:
+        if t == token.DOT:
+            if prev and prev.type == token.DOT:
+                return NO
+
+        elif t == token.NAME:
+            if v == "import":
+                return SPACE
+
+            if prev and prev.type == token.DOT:
+                return NO
+
+    elif p.type == syms.sliceop:
+        return NO
+
+    return SPACE
+
+
+def preceding_leaf(node: Optional[LN]) -> Optional[Leaf]:
+    """Return the first leaf that precedes `node`, if any."""
+    while node:
+        res = node.prev_sibling
+        if res:
+            if isinstance(res, Leaf):
+                return res
+
+            try:
+                return list(res.leaves())[-1]
+
+            except IndexError:
+                return None
+
+        node = node.parent
+    return None
+
+
+def prev_siblings_are(node: Optional[LN], tokens: List[Optional[NodeType]]) -> bool:
+    """Return if the `node` and its previous siblings match types against the provided
+    list of tokens; the provided `node`has its type matched against the last element in
+    the list.  `None` can be used as the first element to declare that the start of the
+    list is anchored at the start of its parent's children."""
+    if not tokens:
+        return True
+    if tokens[-1] is None:
+        return node is None
+    if not node:
+        return False
+    if node.type != tokens[-1]:
+        return False
+    return prev_siblings_are(node.prev_sibling, tokens[:-1])
+
+
+def last_two_except(leaves: List[Leaf], omit: Collection[LeafID]) -> Tuple[Leaf, Leaf]:
+    """Return (penultimate, last) leaves skipping brackets in `omit` and contents."""
+    stop_after: Optional[Leaf] = None
+    last: Optional[Leaf] = None
+    for leaf in reversed(leaves):
+        if stop_after:
+            if leaf is stop_after:
+                stop_after = None
+            continue
+
+        if last:
+            return leaf, last
+
+        if id(leaf) in omit:
+            stop_after = leaf.opening_bracket
+        else:
+            last = leaf
+    else:
+        raise LookupError("Last two leaves were also skipped")
+
+
+def parent_type(node: Optional[LN]) -> Optional[NodeType]:
+    """
+    Returns:
+        @node.parent.type, if @node is not None and has a parent.
+            OR
+        None, otherwise.
+    """
+    if node is None or node.parent is None:
+        return None
+
+    return node.parent.type
+
+
+def child_towards(ancestor: Node, descendant: LN) -> Optional[LN]:
+    """Return the child of `ancestor` that contains `descendant`."""
+    node: Optional[LN] = descendant
+    while node and node.parent != ancestor:
+        node = node.parent
+    return node
+
+
+def replace_child(old_child: LN, new_child: LN) -> None:
+    """
+    Side Effects:
+        * If @old_child.parent is set, replace @old_child with @new_child in
+        @old_child's underlying Node structure.
+            OR
+        * Otherwise, this function does nothing.
+    """
+    parent = old_child.parent
+    if not parent:
+        return
+
+    child_idx = old_child.remove()
+    if child_idx is not None:
+        parent.insert_child(child_idx, new_child)
+
+
+def container_of(leaf: Leaf) -> LN:
+    """Return `leaf` or one of its ancestors that is the topmost container of it.
+
+    By "container" we mean a node where `leaf` is the very first child.
+    """
+    same_prefix = leaf.prefix
+    container: LN = leaf
+    while container:
+        parent = container.parent
+        if parent is None:
+            break
+
+        if parent.children[0].prefix != same_prefix:
+            break
+
+        if parent.type == syms.file_input:
+            break
+
+        if parent.prev_sibling is not None and parent.prev_sibling.type in BRACKETS:
+            break
+
+        container = parent
+    return container
+
+
+def first_leaf_column(node: Node) -> Optional[int]:
+    """Returns the column of the first leaf child of a node."""
+    for child in node.children:
+        if isinstance(child, Leaf):
+            return child.column
+    return None
+
+
+def first_child_is_arith(node: Node) -> bool:
+    """Whether first child is an arithmetic or a binary arithmetic expression"""
+    expr_types = {
+        syms.arith_expr,
+        syms.shift_expr,
+        syms.xor_expr,
+        syms.and_expr,
+    }
+    return bool(node.children and node.children[0].type in expr_types)
+
+
+def is_docstring(leaf: Leaf) -> bool:
+    if prev_siblings_are(
+        leaf.parent, [None, token.NEWLINE, token.INDENT, syms.simple_stmt]
+    ):
+        return True
+
+    # Multiline docstring on the same line as the `def`.
+    if prev_siblings_are(leaf.parent, [syms.parameters, token.COLON, syms.simple_stmt]):
+        # `syms.parameters` is only used in funcdefs and async_funcdefs in the Python
+        # grammar. We're safe to return True without further checks.
+        return True
+
+    return False
+
+
+def is_empty_tuple(node: LN) -> bool:
+    """Return True if `node` holds an empty tuple."""
+    return (
+        node.type == syms.atom
+        and len(node.children) == 2
+        and node.children[0].type == token.LPAR
+        and node.children[1].type == token.RPAR
+    )
+
+
+def is_one_tuple(node: LN) -> bool:
+    """Return True if `node` holds a tuple with one element, with or without parens."""
+    if node.type == syms.atom:
+        gexp = unwrap_singleton_parenthesis(node)
+        if gexp is None or gexp.type != syms.testlist_gexp:
+            return False
+
+        return len(gexp.children) == 2 and gexp.children[1].type == token.COMMA
+
+    return (
+        node.type in IMPLICIT_TUPLE
+        and len(node.children) == 2
+        and node.children[1].type == token.COMMA
+    )
+
+
+def is_one_tuple_between(opening: Leaf, closing: Leaf, leaves: List[Leaf]) -> bool:
+    """Return True if content between `opening` and `closing` looks like a one-tuple."""
+    if opening.type != token.LPAR and closing.type != token.RPAR:
+        return False
+
+    depth = closing.bracket_depth + 1
+    for _opening_index, leaf in enumerate(leaves):
+        if leaf is opening:
+            break
+
+    else:
+        raise LookupError("Opening paren not found in `leaves`")
+
+    commas = 0
+    _opening_index += 1
+    for leaf in leaves[_opening_index:]:
+        if leaf is closing:
+            break
+
+        bracket_depth = leaf.bracket_depth
+        if bracket_depth == depth and leaf.type == token.COMMA:
+            commas += 1
+            if leaf.parent and leaf.parent.type in {
+                syms.arglist,
+                syms.typedargslist,
+            }:
+                commas += 1
+                break
+
+    return commas < 2
+
+
+def is_walrus_assignment(node: LN) -> bool:
+    """Return True iff `node` is of the shape ( test := test )"""
+    inner = unwrap_singleton_parenthesis(node)
+    return inner is not None and inner.type == syms.namedexpr_test
+
+
+def is_simple_decorator_trailer(node: LN, last: bool = False) -> bool:
+    """Return True iff `node` is a trailer valid in a simple decorator"""
+    return node.type == syms.trailer and (
+        (
+            len(node.children) == 2
+            and node.children[0].type == token.DOT
+            and node.children[1].type == token.NAME
+        )
+        # last trailer can be an argument-less parentheses pair
+        or (
+            last
+            and len(node.children) == 2
+            and node.children[0].type == token.LPAR
+            and node.children[1].type == token.RPAR
+        )
+        # last trailer can be arguments
+        or (
+            last
+            and len(node.children) == 3
+            and node.children[0].type == token.LPAR
+            # and node.children[1].type == syms.argument
+            and node.children[2].type == token.RPAR
+        )
+    )
+
+
+def is_simple_decorator_expression(node: LN) -> bool:
+    """Return True iff `node` could be a 'dotted name' decorator
+
+    This function takes the node of the 'namedexpr_test' of the new decorator
+    grammar and test if it would be valid under the old decorator grammar.
+
+    The old grammar was: decorator: @ dotted_name [arguments] NEWLINE
+    The new grammar is : decorator: @ namedexpr_test NEWLINE
+    """
+    if node.type == token.NAME:
+        return True
+    if node.type == syms.power:
+        if node.children:
+            return (
+                node.children[0].type == token.NAME
+                and all(map(is_simple_decorator_trailer, node.children[1:-1]))
+                and (
+                    len(node.children) < 2
+                    or is_simple_decorator_trailer(node.children[-1], last=True)
+                )
+            )
+    return False
+
+
+def is_yield(node: LN) -> bool:
+    """Return True if `node` holds a `yield` or `yield from` expression."""
+    if node.type == syms.yield_expr:
+        return True
+
+    if node.type == token.NAME and node.value == "yield":  # type: ignore
+        return True
+
+    if node.type != syms.atom:
+        return False
+
+    if len(node.children) != 3:
+        return False
+
+    lpar, expr, rpar = node.children
+    if lpar.type == token.LPAR and rpar.type == token.RPAR:
+        return is_yield(expr)
+
+    return False
+
+
+def is_vararg(leaf: Leaf, within: Set[NodeType]) -> bool:
+    """Return True if `leaf` is a star or double star in a vararg or kwarg.
+
+    If `within` includes VARARGS_PARENTS, this applies to function signatures.
+    If `within` includes UNPACKING_PARENTS, it applies to right hand-side
+    extended iterable unpacking (PEP 3132) and additional unpacking
+    generalizations (PEP 448).
+    """
+    if leaf.type not in VARARGS_SPECIALS or not leaf.parent:
+        return False
+
+    p = leaf.parent
+    if p.type == syms.star_expr:
+        # Star expressions are also used as assignment targets in extended
+        # iterable unpacking (PEP 3132).  See what its parent is instead.
+        if not p.parent:
+            return False
+
+        p = p.parent
+
+    return p.type in within
+
+
+def is_multiline_string(leaf: Leaf) -> bool:
+    """Return True if `leaf` is a multiline string that actually spans many lines."""
+    return has_triple_quotes(leaf.value) and "\n" in leaf.value
+
+
+def is_stub_suite(node: Node) -> bool:
+    """Return True if `node` is a suite with a stub body."""
+    if (
+        len(node.children) != 4
+        or node.children[0].type != token.NEWLINE
+        or node.children[1].type != token.INDENT
+        or node.children[3].type != token.DEDENT
+    ):
+        return False
+
+    return is_stub_body(node.children[2])
+
+
+def is_stub_body(node: LN) -> bool:
+    """Return True if `node` is a simple statement containing an ellipsis."""
+    if not isinstance(node, Node) or node.type != syms.simple_stmt:
+        return False
+
+    if len(node.children) != 2:
+        return False
+
+    child = node.children[0]
+    return (
+        child.type == syms.atom
+        and len(child.children) == 3
+        and all(leaf == Leaf(token.DOT, ".") for leaf in child.children)
+    )
+
+
+def is_atom_with_invisible_parens(node: LN) -> bool:
+    """Given a `LN`, determines whether it's an atom `node` with invisible
+    parens. Useful in dedupe-ing and normalizing parens.
+    """
+    if isinstance(node, Leaf) or node.type != syms.atom:
+        return False
+
+    first, last = node.children[0], node.children[-1]
+    return (
+        isinstance(first, Leaf)
+        and first.type == token.LPAR
+        and first.value == ""
+        and isinstance(last, Leaf)
+        and last.type == token.RPAR
+        and last.value == ""
+    )
+
+
+def is_empty_par(leaf: Leaf) -> bool:
+    return is_empty_lpar(leaf) or is_empty_rpar(leaf)
+
+
+def is_empty_lpar(leaf: Leaf) -> bool:
+    return leaf.type == token.LPAR and leaf.value == ""
+
+
+def is_empty_rpar(leaf: Leaf) -> bool:
+    return leaf.type == token.RPAR and leaf.value == ""
+
+
+def is_import(leaf: Leaf) -> bool:
+    """Return True if the given leaf starts an import statement."""
+    p = leaf.parent
+    t = leaf.type
+    v = leaf.value
+    return bool(
+        t == token.NAME
+        and (
+            (v == "import" and p and p.type == syms.import_name)
+            or (v == "from" and p and p.type == syms.import_from)
+        )
+    )
+
+
+def is_type_comment(leaf: Leaf, suffix: str = "") -> bool:
+    """Return True if the given leaf is a special comment.
+    Only returns true for type comments for now."""
+    t = leaf.type
+    v = leaf.value
+    return t in {token.COMMENT, STANDALONE_COMMENT} and v.startswith("# type:" + suffix)
+
+
+def wrap_in_parentheses(parent: Node, child: LN, *, visible: bool = True) -> None:
+    """Wrap `child` in parentheses.
+
+    This replaces `child` with an atom holding the parentheses and the old
+    child.  That requires moving the prefix.
+
+    If `visible` is False, the leaves will be valueless (and thus invisible).
+    """
+    lpar = Leaf(token.LPAR, "(" if visible else "")
+    rpar = Leaf(token.RPAR, ")" if visible else "")
+    prefix = child.prefix
+    child.prefix = ""
+    index = child.remove() or 0
+    new_child = Node(syms.atom, [lpar, child, rpar])
+    new_child.prefix = prefix
+    parent.insert_child(index, new_child)
+
+
+def unwrap_singleton_parenthesis(node: LN) -> Optional[LN]:
+    """Returns `wrapped` if `node` is of the shape ( wrapped ).
+
+    Parenthesis can be optional. Returns None otherwise"""
+    if len(node.children) != 3:
+        return None
+
+    lpar, wrapped, rpar = node.children
+    if not (lpar.type == token.LPAR and rpar.type == token.RPAR):
+        return None
+
+    return wrapped
+
+
+def ensure_visible(leaf: Leaf) -> None:
+    """Make sure parentheses are visible.
+
+    They could be invisible as part of some statements (see
+    :func:`normalize_invisible_parens` and :func:`visit_import_from`).
+    """
+    if leaf.type == token.LPAR:
+        leaf.value = "("
+    elif leaf.type == token.RPAR:
+        leaf.value = ")"
diff --git a/myenv/lib/python3.9/site-packages/black/numerics.py b/myenv/lib/python3.9/site-packages/black/numerics.py
new file mode 100644
index 0000000..cb1c83e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/numerics.py
@@ -0,0 +1,65 @@
+"""
+Formatting numeric literals.
+"""
+from blib2to3.pytree import Leaf
+
+
+def format_hex(text: str) -> str:
+    """
+    Formats a hexadecimal string like "0x12B3"
+    """
+    before, after = text[:2], text[2:]
+    return f"{before}{after.upper()}"
+
+
+def format_scientific_notation(text: str) -> str:
+    """Formats a numeric string utilizing scentific notation"""
+    before, after = text.split("e")
+    sign = ""
+    if after.startswith("-"):
+        after = after[1:]
+        sign = "-"
+    elif after.startswith("+"):
+        after = after[1:]
+    before = format_float_or_int_string(before)
+    return f"{before}e{sign}{after}"
+
+
+def format_long_or_complex_number(text: str) -> str:
+    """Formats a long or complex string like `10L` or `10j`"""
+    number = text[:-1]
+    suffix = text[-1]
+    # Capitalize in "2L" because "l" looks too similar to "1".
+    if suffix == "l":
+        suffix = "L"
+    return f"{format_float_or_int_string(number)}{suffix}"
+
+
+def format_float_or_int_string(text: str) -> str:
+    """Formats a float string like "1.0"."""
+    if "." not in text:
+        return text
+
+    before, after = text.split(".")
+    return f"{before or 0}.{after or 0}"
+
+
+def normalize_numeric_literal(leaf: Leaf) -> None:
+    """Normalizes numeric (float, int, and complex) literals.
+
+    All letters used in the representation are normalized to lowercase (except
+    in Python 2 long literals).
+    """
+    text = leaf.value.lower()
+    if text.startswith(("0o", "0b")):
+        # Leave octal and binary literals alone.
+        pass
+    elif text.startswith("0x"):
+        text = format_hex(text)
+    elif "e" in text:
+        text = format_scientific_notation(text)
+    elif text.endswith(("j", "l")):
+        text = format_long_or_complex_number(text)
+    else:
+        text = format_float_or_int_string(text)
+    leaf.value = text
diff --git a/myenv/lib/python3.9/site-packages/black/output.py b/myenv/lib/python3.9/site-packages/black/output.py
new file mode 100644
index 0000000..f030d0a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/output.py
@@ -0,0 +1,105 @@
+"""Nice output for Black.
+
+The double calls are for patching purposes in tests.
+"""
+
+import json
+from typing import Any, Optional
+from mypy_extensions import mypyc_attr
+import tempfile
+
+from click import echo, style
+
+
+@mypyc_attr(patchable=True)
+def _out(message: Optional[str] = None, nl: bool = True, **styles: Any) -> None:
+    if message is not None:
+        if "bold" not in styles:
+            styles["bold"] = True
+        message = style(message, **styles)
+    echo(message, nl=nl, err=True)
+
+
+@mypyc_attr(patchable=True)
+def _err(message: Optional[str] = None, nl: bool = True, **styles: Any) -> None:
+    if message is not None:
+        if "fg" not in styles:
+            styles["fg"] = "red"
+        message = style(message, **styles)
+    echo(message, nl=nl, err=True)
+
+
+@mypyc_attr(patchable=True)
+def out(message: Optional[str] = None, nl: bool = True, **styles: Any) -> None:
+    _out(message, nl=nl, **styles)
+
+
+def err(message: Optional[str] = None, nl: bool = True, **styles: Any) -> None:
+    _err(message, nl=nl, **styles)
+
+
+def ipynb_diff(a: str, b: str, a_name: str, b_name: str) -> str:
+    """Return a unified diff string between each cell in notebooks `a` and `b`."""
+    a_nb = json.loads(a)
+    b_nb = json.loads(b)
+    diff_lines = [
+        diff(
+            "".join(a_nb["cells"][cell_number]["source"]) + "\n",
+            "".join(b_nb["cells"][cell_number]["source"]) + "\n",
+            f"{a_name}:cell_{cell_number}",
+            f"{b_name}:cell_{cell_number}",
+        )
+        for cell_number, cell in enumerate(a_nb["cells"])
+        if cell["cell_type"] == "code"
+    ]
+    return "".join(diff_lines)
+
+
+def diff(a: str, b: str, a_name: str, b_name: str) -> str:
+    """Return a unified diff string between strings `a` and `b`."""
+    import difflib
+
+    a_lines = a.splitlines(keepends=True)
+    b_lines = b.splitlines(keepends=True)
+    diff_lines = []
+    for line in difflib.unified_diff(
+        a_lines, b_lines, fromfile=a_name, tofile=b_name, n=5
+    ):
+        # Work around https://bugs.python.org/issue2142
+        # See:
+        # https://www.gnu.org/software/diffutils/manual/html_node/Incomplete-Lines.html
+        if line[-1] == "\n":
+            diff_lines.append(line)
+        else:
+            diff_lines.append(line + "\n")
+            diff_lines.append("\\ No newline at end of file\n")
+    return "".join(diff_lines)
+
+
+def color_diff(contents: str) -> str:
+    """Inject the ANSI color codes to the diff."""
+    lines = contents.split("\n")
+    for i, line in enumerate(lines):
+        if line.startswith("+++") or line.startswith("---"):
+            line = "\033[1;37m" + line + "\033[0m"  # bold white, reset
+        elif line.startswith("@@"):
+            line = "\033[36m" + line + "\033[0m"  # cyan, reset
+        elif line.startswith("+"):
+            line = "\033[32m" + line + "\033[0m"  # green, reset
+        elif line.startswith("-"):
+            line = "\033[31m" + line + "\033[0m"  # red, reset
+        lines[i] = line
+    return "\n".join(lines)
+
+
+@mypyc_attr(patchable=True)
+def dump_to_file(*output: str, ensure_final_newline: bool = True) -> str:
+    """Dump `output` to a temporary file. Return path to the file."""
+    with tempfile.NamedTemporaryFile(
+        mode="w", prefix="blk_", suffix=".log", delete=False, encoding="utf8"
+    ) as f:
+        for lines in output:
+            f.write(lines)
+            if ensure_final_newline and lines and lines[-1] != "\n":
+                f.write("\n")
+    return f.name
diff --git a/myenv/lib/python3.9/site-packages/black/parsing.py b/myenv/lib/python3.9/site-packages/black/parsing.py
new file mode 100644
index 0000000..c101643
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/parsing.py
@@ -0,0 +1,285 @@
+"""
+Parse Python code and perform AST validation.
+"""
+import ast
+import platform
+import sys
+from typing import Any, Iterable, Iterator, List, Set, Tuple, Type, Union
+
+if sys.version_info < (3, 8):
+    from typing_extensions import Final
+else:
+    from typing import Final
+
+# lib2to3 fork
+from blib2to3.pytree import Node, Leaf
+from blib2to3 import pygram
+from blib2to3.pgen2 import driver
+from blib2to3.pgen2.grammar import Grammar
+from blib2to3.pgen2.parse import ParseError
+from blib2to3.pgen2.tokenize import TokenError
+
+from black.mode import TargetVersion, Feature, supports_feature
+from black.nodes import syms
+
+ast3: Any
+ast27: Any
+
+_IS_PYPY = platform.python_implementation() == "PyPy"
+
+try:
+    from typed_ast import ast3, ast27
+except ImportError:
+    # Either our python version is too low, or we're on pypy
+    if sys.version_info < (3, 7) or (sys.version_info < (3, 8) and not _IS_PYPY):
+        print(
+            "The typed_ast package is required but not installed.\n"
+            "You can upgrade to Python 3.8+ or install typed_ast with\n"
+            "`python3 -m pip install typed-ast`.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    else:
+        ast3 = ast27 = ast
+
+
+PY310_HINT: Final[
+    str
+] = "Consider using --target-version py310 to parse Python 3.10 code."
+
+
+class InvalidInput(ValueError):
+    """Raised when input source code fails all parse attempts."""
+
+
+def get_grammars(target_versions: Set[TargetVersion]) -> List[Grammar]:
+    if not target_versions:
+        # No target_version specified, so try all grammars.
+        return [
+            # Python 3.7+
+            pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords,
+            # Python 3.0-3.6
+            pygram.python_grammar_no_print_statement_no_exec_statement,
+            # Python 2.7 with future print_function import
+            pygram.python_grammar_no_print_statement,
+            # Python 2.7
+            pygram.python_grammar,
+        ]
+
+    if all(version.is_python2() for version in target_versions):
+        # Python 2-only code, so try Python 2 grammars.
+        return [
+            # Python 2.7 with future print_function import
+            pygram.python_grammar_no_print_statement,
+            # Python 2.7
+            pygram.python_grammar,
+        ]
+
+    # Python 3-compatible code, so only try Python 3 grammar.
+    grammars = []
+    if supports_feature(target_versions, Feature.PATTERN_MATCHING):
+        # Python 3.10+
+        grammars.append(pygram.python_grammar_soft_keywords)
+    # If we have to parse both, try to parse async as a keyword first
+    if not supports_feature(
+        target_versions, Feature.ASYNC_IDENTIFIERS
+    ) and not supports_feature(target_versions, Feature.PATTERN_MATCHING):
+        # Python 3.7-3.9
+        grammars.append(
+            pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords
+        )
+    if not supports_feature(target_versions, Feature.ASYNC_KEYWORDS):
+        # Python 3.0-3.6
+        grammars.append(pygram.python_grammar_no_print_statement_no_exec_statement)
+    # At least one of the above branches must have been taken, because every Python
+    # version has exactly one of the two 'ASYNC_*' flags
+    return grammars
+
+
+def lib2to3_parse(src_txt: str, target_versions: Iterable[TargetVersion] = ()) -> Node:
+    """Given a string with source, return the lib2to3 Node."""
+    if not src_txt.endswith("\n"):
+        src_txt += "\n"
+
+    grammars = get_grammars(set(target_versions))
+    for grammar in grammars:
+        drv = driver.Driver(grammar)
+        try:
+            result = drv.parse_string(src_txt, True)
+            break
+
+        except ParseError as pe:
+            lineno, column = pe.context[1]
+            lines = src_txt.splitlines()
+            try:
+                faulty_line = lines[lineno - 1]
+            except IndexError:
+                faulty_line = "<line number missing in source>"
+            exc = InvalidInput(f"Cannot parse: {lineno}:{column}: {faulty_line}")
+
+        except TokenError as te:
+            # In edge cases these are raised; and typically don't have a "faulty_line".
+            lineno, column = te.args[1]
+            exc = InvalidInput(f"Cannot parse: {lineno}:{column}: {te.args[0]}")
+
+    else:
+        if pygram.python_grammar_soft_keywords not in grammars and matches_grammar(
+            src_txt, pygram.python_grammar_soft_keywords
+        ):
+            original_msg = exc.args[0]
+            msg = f"{original_msg}\n{PY310_HINT}"
+            raise InvalidInput(msg) from None
+        raise exc from None
+
+    if isinstance(result, Leaf):
+        result = Node(syms.file_input, [result])
+    return result
+
+
+def matches_grammar(src_txt: str, grammar: Grammar) -> bool:
+    drv = driver.Driver(grammar)
+    try:
+        drv.parse_string(src_txt, True)
+    except (ParseError, TokenError, IndentationError):
+        return False
+    else:
+        return True
+
+
+def lib2to3_unparse(node: Node) -> str:
+    """Given a lib2to3 node, return its string representation."""
+    code = str(node)
+    return code
+
+
+def parse_single_version(
+    src: str, version: Tuple[int, int]
+) -> Union[ast.AST, ast3.AST, ast27.AST]:
+    filename = "<unknown>"
+    # typed_ast is needed because of feature version limitations in the builtin ast
+    if sys.version_info >= (3, 8) and version >= (3,):
+        return ast.parse(src, filename, feature_version=version)
+    elif version >= (3,):
+        if _IS_PYPY:
+            return ast3.parse(src, filename)
+        else:
+            return ast3.parse(src, filename, feature_version=version[1])
+    elif version == (2, 7):
+        return ast27.parse(src)
+    raise AssertionError("INTERNAL ERROR: Tried parsing unsupported Python version!")
+
+
+def parse_ast(src: str) -> Union[ast.AST, ast3.AST, ast27.AST]:
+    # TODO: support Python 4+ ;)
+    versions = [(3, minor) for minor in range(3, sys.version_info[1] + 1)]
+
+    if ast27.__name__ != "ast":
+        versions.append((2, 7))
+
+    first_error = ""
+    for version in sorted(versions, reverse=True):
+        try:
+            return parse_single_version(src, version)
+        except SyntaxError as e:
+            if not first_error:
+                first_error = str(e)
+
+    raise SyntaxError(first_error)
+
+
+ast3_AST: Final[Type[ast3.AST]] = ast3.AST
+ast27_AST: Final[Type[ast27.AST]] = ast27.AST
+
+
+def stringify_ast(
+    node: Union[ast.AST, ast3.AST, ast27.AST], depth: int = 0
+) -> Iterator[str]:
+    """Simple visitor generating strings to compare ASTs by content."""
+
+    node = fixup_ast_constants(node)
+
+    yield f"{'  ' * depth}{node.__class__.__name__}("
+
+    type_ignore_classes: Tuple[Type[Any], ...]
+    for field in sorted(node._fields):  # noqa: F402
+        # TypeIgnore will not be present using pypy < 3.8, so need for this
+        if not (_IS_PYPY and sys.version_info < (3, 8)):
+            # TypeIgnore has only one field 'lineno' which breaks this comparison
+            type_ignore_classes = (ast3.TypeIgnore, ast27.TypeIgnore)
+            if sys.version_info >= (3, 8):
+                type_ignore_classes += (ast.TypeIgnore,)
+            if isinstance(node, type_ignore_classes):
+                break
+
+        try:
+            value = getattr(node, field)
+        except AttributeError:
+            continue
+
+        yield f"{'  ' * (depth+1)}{field}="
+
+        if isinstance(value, list):
+            for item in value:
+                # Ignore nested tuples within del statements, because we may insert
+                # parentheses and they change the AST.
+                if (
+                    field == "targets"
+                    and isinstance(node, (ast.Delete, ast3.Delete, ast27.Delete))
+                    and isinstance(item, (ast.Tuple, ast3.Tuple, ast27.Tuple))
+                ):
+                    for item in item.elts:
+                        yield from stringify_ast(item, depth + 2)
+
+                elif isinstance(item, (ast.AST, ast3.AST, ast27.AST)):
+                    yield from stringify_ast(item, depth + 2)
+
+        # Note that we are referencing the typed-ast ASTs via global variables and not
+        # direct module attribute accesses because that breaks mypyc. It's probably
+        # something to do with the ast3 / ast27 variables being marked as Any leading
+        # mypy to think this branch is always taken, leaving the rest of the code
+        # unanalyzed. Tighting up the types for the typed-ast AST types avoids the
+        # mypyc crash.
+        elif isinstance(value, (ast.AST, ast3_AST, ast27_AST)):
+            yield from stringify_ast(value, depth + 2)
+
+        else:
+            # Constant strings may be indented across newlines, if they are
+            # docstrings; fold spaces after newlines when comparing. Similarly,
+            # trailing and leading space may be removed.
+            # Note that when formatting Python 2 code, at least with Windows
+            # line-endings, docstrings can end up here as bytes instead of
+            # str so make sure that we handle both cases.
+            if (
+                isinstance(node, ast.Constant)
+                and field == "value"
+                and isinstance(value, (str, bytes))
+            ):
+                lineend = "\n" if isinstance(value, str) else b"\n"
+                # To normalize, we strip any leading and trailing space from
+                # each line...
+                stripped = [line.strip() for line in value.splitlines()]
+                normalized = lineend.join(stripped)  # type: ignore[attr-defined]
+                # ...and remove any blank lines at the beginning and end of
+                # the whole string
+                normalized = normalized.strip()
+            else:
+                normalized = value
+            yield f"{'  ' * (depth+2)}{normalized!r},  # {value.__class__.__name__}"
+
+    yield f"{'  ' * depth})  # /{node.__class__.__name__}"
+
+
+def fixup_ast_constants(
+    node: Union[ast.AST, ast3.AST, ast27.AST]
+) -> Union[ast.AST, ast3.AST, ast27.AST]:
+    """Map ast nodes deprecated in 3.8 to Constant."""
+    if isinstance(node, (ast.Str, ast3.Str, ast27.Str, ast.Bytes, ast3.Bytes)):
+        return ast.Constant(value=node.s)
+
+    if isinstance(node, (ast.Num, ast3.Num, ast27.Num)):
+        return ast.Constant(value=node.n)
+
+    if isinstance(node, (ast.NameConstant, ast3.NameConstant)):
+        return ast.Constant(value=node.value)
+
+    return node
diff --git a/myenv/lib/python3.9/site-packages/black/py.typed b/myenv/lib/python3.9/site-packages/black/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/black/report.py b/myenv/lib/python3.9/site-packages/black/report.py
new file mode 100644
index 0000000..7e1c8b4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/report.py
@@ -0,0 +1,104 @@
+"""
+Summarize Black runs to users.
+"""
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+from click import style
+
+from black.output import out, err
+
+
+class Changed(Enum):
+    NO = 0
+    CACHED = 1
+    YES = 2
+
+
+class NothingChanged(UserWarning):
+    """Raised when reformatted code is the same as source."""
+
+
+@dataclass
+class Report:
+    """Provides a reformatting counter. Can be rendered with `str(report)`."""
+
+    check: bool = False
+    diff: bool = False
+    quiet: bool = False
+    verbose: bool = False
+    change_count: int = 0
+    same_count: int = 0
+    failure_count: int = 0
+
+    def done(self, src: Path, changed: Changed) -> None:
+        """Increment the counter for successful reformatting. Write out a message."""
+        if changed is Changed.YES:
+            reformatted = "would reformat" if self.check or self.diff else "reformatted"
+            if self.verbose or not self.quiet:
+                out(f"{reformatted} {src}")
+            self.change_count += 1
+        else:
+            if self.verbose:
+                if changed is Changed.NO:
+                    msg = f"{src} already well formatted, good job."
+                else:
+                    msg = f"{src} wasn't modified on disk since last run."
+                out(msg, bold=False)
+            self.same_count += 1
+
+    def failed(self, src: Path, message: str) -> None:
+        """Increment the counter for failed reformatting. Write out a message."""
+        err(f"error: cannot format {src}: {message}")
+        self.failure_count += 1
+
+    def path_ignored(self, path: Path, message: str) -> None:
+        if self.verbose:
+            out(f"{path} ignored: {message}", bold=False)
+
+    @property
+    def return_code(self) -> int:
+        """Return the exit code that the app should use.
+
+        This considers the current state of changed files and failures:
+        - if there were any failures, return 123;
+        - if any files were changed and --check is being used, return 1;
+        - otherwise return 0.
+        """
+        # According to http://tldp.org/LDP/abs/html/exitcodes.html starting with
+        # 126 we have special return codes reserved by the shell.
+        if self.failure_count:
+            return 123
+
+        elif self.change_count and self.check:
+            return 1
+
+        return 0
+
+    def __str__(self) -> str:
+        """Render a color report of the current state.
+
+        Use `click.unstyle` to remove colors.
+        """
+        if self.check or self.diff:
+            reformatted = "would be reformatted"
+            unchanged = "would be left unchanged"
+            failed = "would fail to reformat"
+        else:
+            reformatted = "reformatted"
+            unchanged = "left unchanged"
+            failed = "failed to reformat"
+        report = []
+        if self.change_count:
+            s = "s" if self.change_count > 1 else ""
+            report.append(
+                style(f"{self.change_count} file{s} {reformatted}", bold=True)
+            )
+        if self.same_count:
+            s = "s" if self.same_count > 1 else ""
+            report.append(f"{self.same_count} file{s} {unchanged}")
+        if self.failure_count:
+            s = "s" if self.failure_count > 1 else ""
+            report.append(style(f"{self.failure_count} file{s} {failed}", fg="red"))
+        return ", ".join(report) + "."
diff --git a/myenv/lib/python3.9/site-packages/black/rusty.py b/myenv/lib/python3.9/site-packages/black/rusty.py
new file mode 100644
index 0000000..822e3d7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/rusty.py
@@ -0,0 +1,28 @@
+"""An error-handling model influenced by that used by the Rust programming language
+
+See https://doc.rust-lang.org/book/ch09-00-error-handling.html.
+"""
+from typing import Generic, TypeVar, Union
+
+
+T = TypeVar("T")
+E = TypeVar("E", bound=Exception)
+
+
+class Ok(Generic[T]):
+    def __init__(self, value: T) -> None:
+        self._value = value
+
+    def ok(self) -> T:
+        return self._value
+
+
+class Err(Generic[E]):
+    def __init__(self, e: E) -> None:
+        self._e = e
+
+    def err(self) -> E:
+        return self._e
+
+
+Result = Union[Ok[T], Err[E]]
diff --git a/myenv/lib/python3.9/site-packages/black/strings.py b/myenv/lib/python3.9/site-packages/black/strings.py
new file mode 100644
index 0000000..06a5da0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/strings.py
@@ -0,0 +1,234 @@
+"""
+Simple formatting on strings. Further string formatting code is in trans.py.
+"""
+
+import re
+import sys
+from functools import lru_cache
+from typing import List, Pattern
+
+if sys.version_info < (3, 8):
+    from typing_extensions import Final
+else:
+    from typing import Final
+
+
+STRING_PREFIX_CHARS: Final = "furbFURB"  # All possible string prefix characters.
+STRING_PREFIX_RE: Final = re.compile(
+    r"^([" + STRING_PREFIX_CHARS + r"]*)(.*)$", re.DOTALL
+)
+FIRST_NON_WHITESPACE_RE: Final = re.compile(r"\s*\t+\s*(\S)")
+
+
+def sub_twice(regex: Pattern[str], replacement: str, original: str) -> str:
+    """Replace `regex` with `replacement` twice on `original`.
+
+    This is used by string normalization to perform replaces on
+    overlapping matches.
+    """
+    return regex.sub(replacement, regex.sub(replacement, original))
+
+
+def has_triple_quotes(string: str) -> bool:
+    """
+    Returns:
+        True iff @string starts with three quotation characters.
+    """
+    raw_string = string.lstrip(STRING_PREFIX_CHARS)
+    return raw_string[:3] in {'"""', "'''"}
+
+
+def lines_with_leading_tabs_expanded(s: str) -> List[str]:
+    """
+    Splits string into lines and expands only leading tabs (following the normal
+    Python rules)
+    """
+    lines = []
+    for line in s.splitlines():
+        # Find the index of the first non-whitespace character after a string of
+        # whitespace that includes at least one tab
+        match = FIRST_NON_WHITESPACE_RE.match(line)
+        if match:
+            first_non_whitespace_idx = match.start(1)
+
+            lines.append(
+                line[:first_non_whitespace_idx].expandtabs()
+                + line[first_non_whitespace_idx:]
+            )
+        else:
+            lines.append(line)
+    return lines
+
+
+def fix_docstring(docstring: str, prefix: str) -> str:
+    # https://www.python.org/dev/peps/pep-0257/#handling-docstring-indentation
+    if not docstring:
+        return ""
+    lines = lines_with_leading_tabs_expanded(docstring)
+    # Determine minimum indentation (first line doesn't count):
+    indent = sys.maxsize
+    for line in lines[1:]:
+        stripped = line.lstrip()
+        if stripped:
+            indent = min(indent, len(line) - len(stripped))
+    # Remove indentation (first line is special):
+    trimmed = [lines[0].strip()]
+    if indent < sys.maxsize:
+        last_line_idx = len(lines) - 2
+        for i, line in enumerate(lines[1:]):
+            stripped_line = line[indent:].rstrip()
+            if stripped_line or i == last_line_idx:
+                trimmed.append(prefix + stripped_line)
+            else:
+                trimmed.append("")
+    return "\n".join(trimmed)
+
+
+def get_string_prefix(string: str) -> str:
+    """
+    Pre-conditions:
+        * assert_is_leaf_string(@string)
+
+    Returns:
+        @string's prefix (e.g. '', 'r', 'f', or 'rf').
+    """
+    assert_is_leaf_string(string)
+
+    prefix = ""
+    prefix_idx = 0
+    while string[prefix_idx] in STRING_PREFIX_CHARS:
+        prefix += string[prefix_idx]
+        prefix_idx += 1
+
+    return prefix
+
+
+def assert_is_leaf_string(string: str) -> None:
+    """
+    Checks the pre-condition that @string has the format that you would expect
+    of `leaf.value` where `leaf` is some Leaf such that `leaf.type ==
+    token.STRING`. A more precise description of the pre-conditions that are
+    checked are listed below.
+
+    Pre-conditions:
+        * @string starts with either ', ", <prefix>', or <prefix>" where
+        `set(<prefix>)` is some subset of `set(STRING_PREFIX_CHARS)`.
+        * @string ends with a quote character (' or ").
+
+    Raises:
+        AssertionError(...) if the pre-conditions listed above are not
+        satisfied.
+    """
+    dquote_idx = string.find('"')
+    squote_idx = string.find("'")
+    if -1 in [dquote_idx, squote_idx]:
+        quote_idx = max(dquote_idx, squote_idx)
+    else:
+        quote_idx = min(squote_idx, dquote_idx)
+
+    assert (
+        0 <= quote_idx < len(string) - 1
+    ), f"{string!r} is missing a starting quote character (' or \")."
+    assert string[-1] in (
+        "'",
+        '"',
+    ), f"{string!r} is missing an ending quote character (' or \")."
+    assert set(string[:quote_idx]).issubset(
+        set(STRING_PREFIX_CHARS)
+    ), f"{set(string[:quote_idx])} is NOT a subset of {set(STRING_PREFIX_CHARS)}."
+
+
+def normalize_string_prefix(s: str, remove_u_prefix: bool = False) -> str:
+    """Make all string prefixes lowercase.
+
+    If remove_u_prefix is given, also removes any u prefix from the string.
+    """
+    match = STRING_PREFIX_RE.match(s)
+    assert match is not None, f"failed to match string {s!r}"
+    orig_prefix = match.group(1)
+    new_prefix = orig_prefix.replace("F", "f").replace("B", "b").replace("U", "u")
+    if remove_u_prefix:
+        new_prefix = new_prefix.replace("u", "")
+    return f"{new_prefix}{match.group(2)}"
+
+
+# Re(gex) does actually cache patterns internally but this still improves
+# performance on a long list literal of strings by 5-9% since lru_cache's
+# caching overhead is much lower.
+@lru_cache(maxsize=64)
+def _cached_compile(pattern: str) -> Pattern[str]:
+    return re.compile(pattern)
+
+
+def normalize_string_quotes(s: str) -> str:
+    """Prefer double quotes but only if it doesn't cause more escaping.
+
+    Adds or removes backslashes as appropriate. Doesn't parse and fix
+    strings nested in f-strings.
+    """
+    value = s.lstrip(STRING_PREFIX_CHARS)
+    if value[:3] == '"""':
+        return s
+
+    elif value[:3] == "'''":
+        orig_quote = "'''"
+        new_quote = '"""'
+    elif value[0] == '"':
+        orig_quote = '"'
+        new_quote = "'"
+    else:
+        orig_quote = "'"
+        new_quote = '"'
+    first_quote_pos = s.find(orig_quote)
+    if first_quote_pos == -1:
+        return s  # There's an internal error
+
+    prefix = s[:first_quote_pos]
+    unescaped_new_quote = _cached_compile(rf"(([^\\]|^)(\\\\)*){new_quote}")
+    escaped_new_quote = _cached_compile(rf"([^\\]|^)\\((?:\\\\)*){new_quote}")
+    escaped_orig_quote = _cached_compile(rf"([^\\]|^)\\((?:\\\\)*){orig_quote}")
+    body = s[first_quote_pos + len(orig_quote) : -len(orig_quote)]
+    if "r" in prefix.casefold():
+        if unescaped_new_quote.search(body):
+            # There's at least one unescaped new_quote in this raw string
+            # so converting is impossible
+            return s
+
+        # Do not introduce or remove backslashes in raw strings
+        new_body = body
+    else:
+        # remove unnecessary escapes
+        new_body = sub_twice(escaped_new_quote, rf"\1\2{new_quote}", body)
+        if body != new_body:
+            # Consider the string without unnecessary escapes as the original
+            body = new_body
+            s = f"{prefix}{orig_quote}{body}{orig_quote}"
+        new_body = sub_twice(escaped_orig_quote, rf"\1\2{orig_quote}", new_body)
+        new_body = sub_twice(unescaped_new_quote, rf"\1\\{new_quote}", new_body)
+    if "f" in prefix.casefold():
+        matches = re.findall(
+            r"""
+            (?:(?<!\{)|^)\{  # start of the string or a non-{ followed by a single {
+                ([^{].*?)  # contents of the brackets except if begins with {{
+            \}(?:(?!\})|$)  # A } followed by end of the string or a non-}
+            """,
+            new_body,
+            re.VERBOSE,
+        )
+        for m in matches:
+            if "\\" in str(m):
+                # Do not introduce backslashes in interpolated expressions
+                return s
+
+    if new_quote == '"""' and new_body[-1:] == '"':
+        # edge case:
+        new_body = new_body[:-1] + '\\"'
+    orig_escape_count = body.count("\\")
+    new_escape_count = new_body.count("\\")
+    if new_escape_count > orig_escape_count:
+        return s  # Do not introduce more escaping
+
+    if new_escape_count == orig_escape_count and orig_quote == '"':
+        return s  # Prefer double quotes
+
+    return f"{prefix}{new_quote}{new_body}{new_quote}"
diff --git a/myenv/lib/python3.9/site-packages/black/trans.py b/myenv/lib/python3.9/site-packages/black/trans.py
new file mode 100644
index 0000000..cb41c1b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black/trans.py
@@ -0,0 +1,2064 @@
+"""
+String transformers that can split and merge strings.
+"""
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from dataclasses import dataclass
+import re
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Collection,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    TypeVar,
+    Union,
+)
+import sys
+
+if sys.version_info < (3, 8):
+    from typing_extensions import Final
+else:
+    from typing import Final
+
+from mypy_extensions import trait
+
+from black.rusty import Result, Ok, Err
+
+from black.mode import Feature
+from black.nodes import syms, replace_child, parent_type
+from black.nodes import is_empty_par, is_empty_lpar, is_empty_rpar
+from black.nodes import OPENING_BRACKETS, CLOSING_BRACKETS, STANDALONE_COMMENT
+from black.lines import Line, append_leaves
+from black.brackets import BracketMatchError
+from black.comments import contains_pragma_comment
+from black.strings import has_triple_quotes, get_string_prefix, assert_is_leaf_string
+from black.strings import normalize_string_quotes
+
+from blib2to3.pytree import Leaf, Node
+from blib2to3.pgen2 import token
+
+
+class CannotTransform(Exception):
+    """Base class for errors raised by Transformers."""
+
+
+# types
+T = TypeVar("T")
+LN = Union[Leaf, Node]
+Transformer = Callable[[Line, Collection[Feature]], Iterator[Line]]
+Index = int
+NodeType = int
+ParserState = int
+StringID = int
+TResult = Result[T, CannotTransform]  # (T)ransform Result
+TMatchResult = TResult[Index]
+
+
+def TErr(err_msg: str) -> Err[CannotTransform]:
+    """(T)ransform Err
+
+    Convenience function used when working with the TResult type.
+    """
+    cant_transform = CannotTransform(err_msg)
+    return Err(cant_transform)
+
+
+class StringTransformer(ABC):
+    """
+    An implementation of the Transformer protocol that relies on its
+    subclasses overriding the template methods `do_match(...)` and
+    `do_transform(...)`.
+
+    This Transformer works exclusively on strings (for example, by merging
+    or splitting them).
+
+    The following sections can be found among the docstrings of each concrete
+    StringTransformer subclass.
+
+    Requirements:
+        Which requirements must be met of the given Line for this
+        StringTransformer to be applied?
+
+    Transformations:
+        If the given Line meets all of the above requirements, which string
+        transformations can you expect to be applied to it by this
+        StringTransformer?
+
+    Collaborations:
+        What contractual agreements does this StringTransformer have with other
+        StringTransfomers? Such collaborations should be eliminated/minimized
+        as much as possible.
+    """
+
+    __name__: Final = "StringTransformer"
+
+    # Ideally this would be a dataclass, but unfortunately mypyc breaks when used with
+    # `abc.ABC`.
+    def __init__(self, line_length: int, normalize_strings: bool) -> None:
+        self.line_length = line_length
+        self.normalize_strings = normalize_strings
+
+    @abstractmethod
+    def do_match(self, line: Line) -> TMatchResult:
+        """
+        Returns:
+            * Ok(string_idx) such that `line.leaves[string_idx]` is our target
+            string, if a match was able to be made.
+                OR
+            * Err(CannotTransform), if a match was not able to be made.
+        """
+
+    @abstractmethod
+    def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
+        """
+        Yields:
+            * Ok(new_line) where new_line is the new transformed line.
+                OR
+            * Err(CannotTransform) if the transformation failed for some reason. The
+            `do_match(...)` template method should usually be used to reject
+            the form of the given Line, but in some cases it is difficult to
+            know whether or not a Line meets the StringTransformer's
+            requirements until the transformation is already midway.
+
+        Side Effects:
+            This method should NOT mutate @line directly, but it MAY mutate the
+            Line's underlying Node structure. (WARNING: If the underlying Node
+            structure IS altered, then this method should NOT be allowed to
+            yield an CannotTransform after that point.)
+        """
+
+    def __call__(self, line: Line, _features: Collection[Feature]) -> Iterator[Line]:
+        """
+        StringTransformer instances have a call signature that mirrors that of
+        the Transformer type.
+
+        Raises:
+            CannotTransform(...) if the concrete StringTransformer class is unable
+            to transform @line.
+        """
+        # Optimization to avoid calling `self.do_match(...)` when the line does
+        # not contain any string.
+        if not any(leaf.type == token.STRING for leaf in line.leaves):
+            raise CannotTransform("There are no strings in this line.")
+
+        match_result = self.do_match(line)
+
+        if isinstance(match_result, Err):
+            cant_transform = match_result.err()
+            raise CannotTransform(
+                f"The string transformer {self.__class__.__name__} does not recognize"
+                " this line as one that it can transform."
+            ) from cant_transform
+
+        string_idx = match_result.ok()
+
+        for line_result in self.do_transform(line, string_idx):
+            if isinstance(line_result, Err):
+                cant_transform = line_result.err()
+                raise CannotTransform(
+                    "StringTransformer failed while attempting to transform string."
+                ) from cant_transform
+            line = line_result.ok()
+            yield line
+
+
+@dataclass
+class CustomSplit:
+    """A custom (i.e. manual) string split.
+
+    A single CustomSplit instance represents a single substring.
+
+    Examples:
+        Consider the following string:
+        ```
+        "Hi there friend."
+        " This is a custom"
+        f" string {split}."
+        ```
+
+        This string will correspond to the following three CustomSplit instances:
+        ```
+        CustomSplit(False, 16)
+        CustomSplit(False, 17)
+        CustomSplit(True, 16)
+        ```
+    """
+
+    has_prefix: bool
+    break_idx: int
+
+
+@trait
+class CustomSplitMapMixin:
+    """
+    This mixin class is used to map merged strings to a sequence of
+    CustomSplits, which will then be used to re-split the strings iff none of
+    the resultant substrings go over the configured max line length.
+    """
+
+    _Key: ClassVar = Tuple[StringID, str]
+    _CUSTOM_SPLIT_MAP: ClassVar[Dict[_Key, Tuple[CustomSplit, ...]]] = defaultdict(
+        tuple
+    )
+
+    @staticmethod
+    def _get_key(string: str) -> "CustomSplitMapMixin._Key":
+        """
+        Returns:
+            A unique identifier that is used internally to map @string to a
+            group of custom splits.
+        """
+        return (id(string), string)
+
+    def add_custom_splits(
+        self, string: str, custom_splits: Iterable[CustomSplit]
+    ) -> None:
+        """Custom Split Map Setter Method
+
+        Side Effects:
+            Adds a mapping from @string to the custom splits @custom_splits.
+        """
+        key = self._get_key(string)
+        self._CUSTOM_SPLIT_MAP[key] = tuple(custom_splits)
+
+    def pop_custom_splits(self, string: str) -> List[CustomSplit]:
+        """Custom Split Map Getter Method
+
+        Returns:
+            * A list of the custom splits that are mapped to @string, if any
+            exist.
+                OR
+            * [], otherwise.
+
+        Side Effects:
+            Deletes the mapping between @string and its associated custom
+            splits (which are returned to the caller).
+        """
+        key = self._get_key(string)
+
+        custom_splits = self._CUSTOM_SPLIT_MAP[key]
+        del self._CUSTOM_SPLIT_MAP[key]
+
+        return list(custom_splits)
+
+    def has_custom_splits(self, string: str) -> bool:
+        """
+        Returns:
+            True iff @string is associated with a set of custom splits.
+        """
+        key = self._get_key(string)
+        return key in self._CUSTOM_SPLIT_MAP
+
+
+class StringMerger(StringTransformer, CustomSplitMapMixin):
+    """StringTransformer that merges strings together.
+
+    Requirements:
+        (A) The line contains adjacent strings such that ALL of the validation checks
+        listed in StringMerger.__validate_msg(...)'s docstring pass.
+            OR
+        (B) The line contains a string which uses line continuation backslashes.
+
+    Transformations:
+        Depending on which of the two requirements above where met, either:
+
+        (A) The string group associated with the target string is merged.
+            OR
+        (B) All line-continuation backslashes are removed from the target string.
+
+    Collaborations:
+        StringMerger provides custom split information to StringSplitter.
+    """
+
+    def do_match(self, line: Line) -> TMatchResult:
+        LL = line.leaves
+
+        is_valid_index = is_valid_index_factory(LL)
+
+        for (i, leaf) in enumerate(LL):
+            if (
+                leaf.type == token.STRING
+                and is_valid_index(i + 1)
+                and LL[i + 1].type == token.STRING
+            ):
+                return Ok(i)
+
+            if leaf.type == token.STRING and "\\\n" in leaf.value:
+                return Ok(i)
+
+        return TErr("This line has no strings that need merging.")
+
+    def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
+        new_line = line
+        rblc_result = self._remove_backslash_line_continuation_chars(
+            new_line, string_idx
+        )
+        if isinstance(rblc_result, Ok):
+            new_line = rblc_result.ok()
+
+        msg_result = self._merge_string_group(new_line, string_idx)
+        if isinstance(msg_result, Ok):
+            new_line = msg_result.ok()
+
+        if isinstance(rblc_result, Err) and isinstance(msg_result, Err):
+            msg_cant_transform = msg_result.err()
+            rblc_cant_transform = rblc_result.err()
+            cant_transform = CannotTransform(
+                "StringMerger failed to merge any strings in this line."
+            )
+
+            # Chain the errors together using `__cause__`.
+            msg_cant_transform.__cause__ = rblc_cant_transform
+            cant_transform.__cause__ = msg_cant_transform
+
+            yield Err(cant_transform)
+        else:
+            yield Ok(new_line)
+
+    @staticmethod
+    def _remove_backslash_line_continuation_chars(
+        line: Line, string_idx: int
+    ) -> TResult[Line]:
+        """
+        Merge strings that were split across multiple lines using
+        line-continuation backslashes.
+
+        Returns:
+            Ok(new_line), if @line contains backslash line-continuation
+            characters.
+                OR
+            Err(CannotTransform), otherwise.
+        """
+        LL = line.leaves
+
+        string_leaf = LL[string_idx]
+        if not (
+            string_leaf.type == token.STRING
+            and "\\\n" in string_leaf.value
+            and not has_triple_quotes(string_leaf.value)
+        ):
+            return TErr(
+                f"String leaf {string_leaf} does not contain any backslash line"
+                " continuation characters."
+            )
+
+        new_line = line.clone()
+        new_line.comments = line.comments.copy()
+        append_leaves(new_line, line, LL)
+
+        new_string_leaf = new_line.leaves[string_idx]
+        new_string_leaf.value = new_string_leaf.value.replace("\\\n", "")
+
+        return Ok(new_line)
+
+    def _merge_string_group(self, line: Line, string_idx: int) -> TResult[Line]:
+        """
+        Merges string group (i.e. set of adjacent strings) where the first
+        string in the group is `line.leaves[string_idx]`.
+
+        Returns:
+            Ok(new_line), if ALL of the validation checks found in
+            __validate_msg(...) pass.
+                OR
+            Err(CannotTransform), otherwise.
+        """
+        LL = line.leaves
+
+        is_valid_index = is_valid_index_factory(LL)
+
+        vresult = self._validate_msg(line, string_idx)
+        if isinstance(vresult, Err):
+            return vresult
+
+        # If the string group is wrapped inside an Atom node, we must make sure
+        # to later replace that Atom with our new (merged) string leaf.
+        atom_node = LL[string_idx].parent
+
+        # We will place BREAK_MARK in between every two substrings that we
+        # merge. We will then later go through our final result and use the
+        # various instances of BREAK_MARK we find to add the right values to
+        # the custom split map.
+        BREAK_MARK = "@@@@@ BLACK BREAKPOINT MARKER @@@@@"
+
+        QUOTE = LL[string_idx].value[-1]
+
+        def make_naked(string: str, string_prefix: str) -> str:
+            """Strip @string (i.e. make it a "naked" string)
+
+            Pre-conditions:
+                * assert_is_leaf_string(@string)
+
+            Returns:
+                A string that is identical to @string except that
+                @string_prefix has been stripped, the surrounding QUOTE
+                characters have been removed, and any remaining QUOTE
+                characters have been escaped.
+            """
+            assert_is_leaf_string(string)
+
+            RE_EVEN_BACKSLASHES = r"(?:(?<!\\)(?:\\\\)*)"
+            naked_string = string[len(string_prefix) + 1 : -1]
+            naked_string = re.sub(
+                "(" + RE_EVEN_BACKSLASHES + ")" + QUOTE, r"\1\\" + QUOTE, naked_string
+            )
+            return naked_string
+
+        # Holds the CustomSplit objects that will later be added to the custom
+        # split map.
+        custom_splits = []
+
+        # Temporary storage for the 'has_prefix' part of the CustomSplit objects.
+        prefix_tracker = []
+
+        # Sets the 'prefix' variable. This is the prefix that the final merged
+        # string will have.
+        next_str_idx = string_idx
+        prefix = ""
+        while (
+            not prefix
+            and is_valid_index(next_str_idx)
+            and LL[next_str_idx].type == token.STRING
+        ):
+            prefix = get_string_prefix(LL[next_str_idx].value).lower()
+            next_str_idx += 1
+
+        # The next loop merges the string group. The final string will be
+        # contained in 'S'.
+        #
+        # The following convenience variables are used:
+        #
+        #   S: string
+        #   NS: naked string
+        #   SS: next string
+        #   NSS: naked next string
+        S = ""
+        NS = ""
+        num_of_strings = 0
+        next_str_idx = string_idx
+        while is_valid_index(next_str_idx) and LL[next_str_idx].type == token.STRING:
+            num_of_strings += 1
+
+            SS = LL[next_str_idx].value
+            next_prefix = get_string_prefix(SS).lower()
+
+            # If this is an f-string group but this substring is not prefixed
+            # with 'f'...
+            if "f" in prefix and "f" not in next_prefix:
+                # Then we must escape any braces contained in this substring.
+                SS = re.sub(r"(\{|\})", r"\1\1", SS)
+
+            NSS = make_naked(SS, next_prefix)
+
+            has_prefix = bool(next_prefix)
+            prefix_tracker.append(has_prefix)
+
+            S = prefix + QUOTE + NS + NSS + BREAK_MARK + QUOTE
+            NS = make_naked(S, prefix)
+
+            next_str_idx += 1
+
+        S_leaf = Leaf(token.STRING, S)
+        if self.normalize_strings:
+            S_leaf.value = normalize_string_quotes(S_leaf.value)
+
+        # Fill the 'custom_splits' list with the appropriate CustomSplit objects.
+        temp_string = S_leaf.value[len(prefix) + 1 : -1]
+        for has_prefix in prefix_tracker:
+            mark_idx = temp_string.find(BREAK_MARK)
+            assert (
+                mark_idx >= 0
+            ), "Logic error while filling the custom string breakpoint cache."
+
+            temp_string = temp_string[mark_idx + len(BREAK_MARK) :]
+            breakpoint_idx = mark_idx + (len(prefix) if has_prefix else 0) + 1
+            custom_splits.append(CustomSplit(has_prefix, breakpoint_idx))
+
+        string_leaf = Leaf(token.STRING, S_leaf.value.replace(BREAK_MARK, ""))
+
+        if atom_node is not None:
+            replace_child(atom_node, string_leaf)
+
+        # Build the final line ('new_line') that this method will later return.
+        new_line = line.clone()
+        for (i, leaf) in enumerate(LL):
+            if i == string_idx:
+                new_line.append(string_leaf)
+
+            if string_idx <= i < string_idx + num_of_strings:
+                for comment_leaf in line.comments_after(LL[i]):
+                    new_line.append(comment_leaf, preformatted=True)
+                continue
+
+            append_leaves(new_line, line, [leaf])
+
+        self.add_custom_splits(string_leaf.value, custom_splits)
+        return Ok(new_line)
+
+    @staticmethod
+    def _validate_msg(line: Line, string_idx: int) -> TResult[None]:
+        """Validate (M)erge (S)tring (G)roup
+
+        Transform-time string validation logic for __merge_string_group(...).
+
+        Returns:
+            * Ok(None), if ALL validation checks (listed below) pass.
+                OR
+            * Err(CannotTransform), if any of the following are true:
+                - The target string group does not contain ANY stand-alone comments.
+                - The target string is not in a string group (i.e. it has no
+                  adjacent strings).
+                - The string group has more than one inline comment.
+                - The string group has an inline comment that appears to be a pragma.
+                - The set of all string prefixes in the string group is of
+                  length greater than one and is not equal to {"", "f"}.
+                - The string group consists of raw strings.
+        """
+        # We first check for "inner" stand-alone comments (i.e. stand-alone
+        # comments that have a string leaf before them AND after them).
+        for inc in [1, -1]:
+            i = string_idx
+            found_sa_comment = False
+            is_valid_index = is_valid_index_factory(line.leaves)
+            while is_valid_index(i) and line.leaves[i].type in [
+                token.STRING,
+                STANDALONE_COMMENT,
+            ]:
+                if line.leaves[i].type == STANDALONE_COMMENT:
+                    found_sa_comment = True
+                elif found_sa_comment:
+                    return TErr(
+                        "StringMerger does NOT merge string groups which contain "
+                        "stand-alone comments."
+                    )
+
+                i += inc
+
+        num_of_inline_string_comments = 0
+        set_of_prefixes = set()
+        num_of_strings = 0
+        for leaf in line.leaves[string_idx:]:
+            if leaf.type != token.STRING:
+                # If the string group is trailed by a comma, we count the
+                # comments trailing the comma to be one of the string group's
+                # comments.
+                if leaf.type == token.COMMA and id(leaf) in line.comments:
+                    num_of_inline_string_comments += 1
+                break
+
+            if has_triple_quotes(leaf.value):
+                return TErr("StringMerger does NOT merge multiline strings.")
+
+            num_of_strings += 1
+            prefix = get_string_prefix(leaf.value).lower()
+            if "r" in prefix:
+                return TErr("StringMerger does NOT merge raw strings.")
+
+            set_of_prefixes.add(prefix)
+
+            if id(leaf) in line.comments:
+                num_of_inline_string_comments += 1
+                if contains_pragma_comment(line.comments[id(leaf)]):
+                    return TErr("Cannot merge strings which have pragma comments.")
+
+        if num_of_strings < 2:
+            return TErr(
+                f"Not enough strings to merge (num_of_strings={num_of_strings})."
+            )
+
+        if num_of_inline_string_comments > 1:
+            return TErr(
+                f"Too many inline string comments ({num_of_inline_string_comments})."
+            )
+
+        if len(set_of_prefixes) > 1 and set_of_prefixes != {"", "f"}:
+            return TErr(f"Too many different prefixes ({set_of_prefixes}).")
+
+        return Ok(None)
+
+
+class StringParenStripper(StringTransformer):
+    """StringTransformer that strips surrounding parentheses from strings.
+
+    Requirements:
+        The line contains a string which is surrounded by parentheses and:
+            - The target string is NOT the only argument to a function call.
+            - The target string is NOT a "pointless" string.
+            - If the target string contains a PERCENT, the brackets are not
+              preceded or followed by an operator with higher precedence than
+              PERCENT.
+
+    Transformations:
+        The parentheses mentioned in the 'Requirements' section are stripped.
+
+    Collaborations:
+        StringParenStripper has its own inherent usefulness, but it is also
+        relied on to clean up the parentheses created by StringParenWrapper (in
+        the event that they are no longer needed).
+    """
+
+    def do_match(self, line: Line) -> TMatchResult:
+        LL = line.leaves
+
+        is_valid_index = is_valid_index_factory(LL)
+
+        for (idx, leaf) in enumerate(LL):
+            # Should be a string...
+            if leaf.type != token.STRING:
+                continue
+
+            # If this is a "pointless" string...
+            if (
+                leaf.parent
+                and leaf.parent.parent
+                and leaf.parent.parent.type == syms.simple_stmt
+            ):
+                continue
+
+            # Should be preceded by a non-empty LPAR...
+            if (
+                not is_valid_index(idx - 1)
+                or LL[idx - 1].type != token.LPAR
+                or is_empty_lpar(LL[idx - 1])
+            ):
+                continue
+
+            # That LPAR should NOT be preceded by a function name or a closing
+            # bracket (which could be a function which returns a function or a
+            # list/dictionary that contains a function)...
+            if is_valid_index(idx - 2) and (
+                LL[idx - 2].type == token.NAME or LL[idx - 2].type in CLOSING_BRACKETS
+            ):
+                continue
+
+            string_idx = idx
+
+            # Skip the string trailer, if one exists.
+            string_parser = StringParser()
+            next_idx = string_parser.parse(LL, string_idx)
+
+            # if the leaves in the parsed string include a PERCENT, we need to
+            # make sure the initial LPAR is NOT preceded by an operator with
+            # higher or equal precedence to PERCENT
+            if is_valid_index(idx - 2):
+                # mypy can't quite follow unless we name this
+                before_lpar = LL[idx - 2]
+                if token.PERCENT in {leaf.type for leaf in LL[idx - 1 : next_idx]} and (
+                    (
+                        before_lpar.type
+                        in {
+                            token.STAR,
+                            token.AT,
+                            token.SLASH,
+                            token.DOUBLESLASH,
+                            token.PERCENT,
+                            token.TILDE,
+                            token.DOUBLESTAR,
+                            token.AWAIT,
+                            token.LSQB,
+                            token.LPAR,
+                        }
+                    )
+                    or (
+                        # only unary PLUS/MINUS
+                        before_lpar.parent
+                        and before_lpar.parent.type == syms.factor
+                        and (before_lpar.type in {token.PLUS, token.MINUS})
+                    )
+                ):
+                    continue
+
+            # Should be followed by a non-empty RPAR...
+            if (
+                is_valid_index(next_idx)
+                and LL[next_idx].type == token.RPAR
+                and not is_empty_rpar(LL[next_idx])
+            ):
+                # That RPAR should NOT be followed by anything with higher
+                # precedence than PERCENT
+                if is_valid_index(next_idx + 1) and LL[next_idx + 1].type in {
+                    token.DOUBLESTAR,
+                    token.LSQB,
+                    token.LPAR,
+                    token.DOT,
+                }:
+                    continue
+
+                return Ok(string_idx)
+
+        return TErr("This line has no strings wrapped in parens.")
+
+    def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
+        LL = line.leaves
+
+        string_parser = StringParser()
+        rpar_idx = string_parser.parse(LL, string_idx)
+
+        for leaf in (LL[string_idx - 1], LL[rpar_idx]):
+            if line.comments_after(leaf):
+                yield TErr(
+                    "Will not strip parentheses which have comments attached to them."
+                )
+                return
+
+        new_line = line.clone()
+        new_line.comments = line.comments.copy()
+        try:
+            append_leaves(new_line, line, LL[: string_idx - 1])
+        except BracketMatchError:
+            # HACK: I believe there is currently a bug somewhere in
+            # right_hand_split() that is causing brackets to not be tracked
+            # properly by a shared BracketTracker.
+            append_leaves(new_line, line, LL[: string_idx - 1], preformatted=True)
+
+        string_leaf = Leaf(token.STRING, LL[string_idx].value)
+        LL[string_idx - 1].remove()
+        replace_child(LL[string_idx], string_leaf)
+        new_line.append(string_leaf)
+
+        append_leaves(
+            new_line, line, LL[string_idx + 1 : rpar_idx] + LL[rpar_idx + 1 :]
+        )
+
+        LL[rpar_idx].remove()
+
+        yield Ok(new_line)
+
+
+class BaseStringSplitter(StringTransformer):
+    """
+    Abstract class for StringTransformers which transform a Line's strings by splitting
+    them or placing them on their own lines where necessary to avoid going over
+    the configured line length.
+
+    Requirements:
+        * The target string value is responsible for the line going over the
+        line length limit. It follows that after all of black's other line
+        split methods have been exhausted, this line (or one of the resulting
+        lines after all line splits are performed) would still be over the
+        line_length limit unless we split this string.
+            AND
+        * The target string is NOT a "pointless" string (i.e. a string that has
+        no parent or siblings).
+            AND
+        * The target string is not followed by an inline comment that appears
+        to be a pragma.
+            AND
+        * The target string is not a multiline (i.e. triple-quote) string.
+    """
+
+    STRING_OPERATORS: Final = [
+        token.EQEQUAL,
+        token.GREATER,
+        token.GREATEREQUAL,
+        token.LESS,
+        token.LESSEQUAL,
+        token.NOTEQUAL,
+        token.PERCENT,
+        token.PLUS,
+        token.STAR,
+    ]
+
+    @abstractmethod
+    def do_splitter_match(self, line: Line) -> TMatchResult:
+        """
+        BaseStringSplitter asks its clients to override this method instead of
+        `StringTransformer.do_match(...)`.
+
+        Follows the same protocol as `StringTransformer.do_match(...)`.
+
+        Refer to `help(StringTransformer.do_match)` for more information.
+        """
+
+    def do_match(self, line: Line) -> TMatchResult:
+        match_result = self.do_splitter_match(line)
+        if isinstance(match_result, Err):
+            return match_result
+
+        string_idx = match_result.ok()
+        vresult = self._validate(line, string_idx)
+        if isinstance(vresult, Err):
+            return vresult
+
+        return match_result
+
+    def _validate(self, line: Line, string_idx: int) -> TResult[None]:
+        """
+        Checks that @line meets all of the requirements listed in this classes'
+        docstring. Refer to `help(BaseStringSplitter)` for a detailed
+        description of those requirements.
+
+        Returns:
+            * Ok(None), if ALL of the requirements are met.
+                OR
+            * Err(CannotTransform), if ANY of the requirements are NOT met.
+        """
+        LL = line.leaves
+
+        string_leaf = LL[string_idx]
+
+        max_string_length = self._get_max_string_length(line, string_idx)
+        if len(string_leaf.value) <= max_string_length:
+            return TErr(
+                "The string itself is not what is causing this line to be too long."
+            )
+
+        if not string_leaf.parent or [L.type for L in string_leaf.parent.children] == [
+            token.STRING,
+            token.NEWLINE,
+        ]:
+            return TErr(
+                f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
+                " no parent)."
+            )
+
+        if id(line.leaves[string_idx]) in line.comments and contains_pragma_comment(
+            line.comments[id(line.leaves[string_idx])]
+        ):
+            return TErr(
+                "Line appears to end with an inline pragma comment. Splitting the line"
+                " could modify the pragma's behavior."
+            )
+
+        if has_triple_quotes(string_leaf.value):
+            return TErr("We cannot split multiline strings.")
+
+        return Ok(None)
+
+    def _get_max_string_length(self, line: Line, string_idx: int) -> int:
+        """
+        Calculates the max string length used when attempting to determine
+        whether or not the target string is responsible for causing the line to
+        go over the line length limit.
+
+        WARNING: This method is tightly coupled to both StringSplitter and
+        (especially) StringParenWrapper. There is probably a better way to
+        accomplish what is being done here.
+
+        Returns:
+            max_string_length: such that `line.leaves[string_idx].value >
+            max_string_length` implies that the target string IS responsible
+            for causing this line to exceed the line length limit.
+        """
+        LL = line.leaves
+
+        is_valid_index = is_valid_index_factory(LL)
+
+        # We use the shorthand "WMA4" in comments to abbreviate "We must
+        # account for". When giving examples, we use STRING to mean some/any
+        # valid string.
+        #
+        # Finally, we use the following convenience variables:
+        #
+        #   P:  The leaf that is before the target string leaf.
+        #   N:  The leaf that is after the target string leaf.
+        #   NN: The leaf that is after N.
+
+        # WMA4 the whitespace at the beginning of the line.
+        offset = line.depth * 4
+
+        if is_valid_index(string_idx - 1):
+            p_idx = string_idx - 1
+            if (
+                LL[string_idx - 1].type == token.LPAR
+                and LL[string_idx - 1].value == ""
+                and string_idx >= 2
+            ):
+                # If the previous leaf is an empty LPAR placeholder, we should skip it.
+                p_idx -= 1
+
+            P = LL[p_idx]
+            if P.type in self.STRING_OPERATORS:
+                # WMA4 a space and a string operator (e.g. `+ STRING` or `== STRING`).
+                offset += len(str(P)) + 1
+
+            if P.type == token.COMMA:
+                # WMA4 a space, a comma, and a closing bracket [e.g. `), STRING`].
+                offset += 3
+
+            if P.type in [token.COLON, token.EQUAL, token.PLUSEQUAL, token.NAME]:
+                # This conditional branch is meant to handle dictionary keys,
+                # variable assignments, 'return STRING' statement lines, and
+                # 'else STRING' ternary expression lines.
+
+                # WMA4 a single space.
+                offset += 1
+
+                # WMA4 the lengths of any leaves that came before that space,
+                # but after any closing bracket before that space.
+                for leaf in reversed(LL[: p_idx + 1]):
+                    offset += len(str(leaf))
+                    if leaf.type in CLOSING_BRACKETS:
+                        break
+
+        if is_valid_index(string_idx + 1):
+            N = LL[string_idx + 1]
+            if N.type == token.RPAR and N.value == "" and len(LL) > string_idx + 2:
+                # If the next leaf is an empty RPAR placeholder, we should skip it.
+                N = LL[string_idx + 2]
+
+            if N.type == token.COMMA:
+                # WMA4 a single comma at the end of the string (e.g `STRING,`).
+                offset += 1
+
+            if is_valid_index(string_idx + 2):
+                NN = LL[string_idx + 2]
+
+                if N.type == token.DOT and NN.type == token.NAME:
+                    # This conditional branch is meant to handle method calls invoked
+                    # off of a string literal up to and including the LPAR character.
+
+                    # WMA4 the '.' character.
+                    offset += 1
+
+                    if (
+                        is_valid_index(string_idx + 3)
+                        and LL[string_idx + 3].type == token.LPAR
+                    ):
+                        # WMA4 the left parenthesis character.
+                        offset += 1
+
+                    # WMA4 the length of the method's name.
+                    offset += len(NN.value)
+
+        has_comments = False
+        for comment_leaf in line.comments_after(LL[string_idx]):
+            if not has_comments:
+                has_comments = True
+                # WMA4 two spaces before the '#' character.
+                offset += 2
+
+            # WMA4 the length of the inline comment.
+            offset += len(comment_leaf.value)
+
+        max_string_length = self.line_length - offset
+        return max_string_length
+
+
+def iter_fexpr_spans(s: str) -> Iterator[Tuple[int, int]]:
+    """
+    Yields spans corresponding to expressions in a given f-string.
+    Spans are half-open ranges (left inclusive, right exclusive).
+    Assumes the input string is a valid f-string, but will not crash if the input
+    string is invalid.
+    """
+    stack: List[int] = []  # our curly paren stack
+    i = 0
+    while i < len(s):
+        if s[i] == "{":
+            # if we're in a string part of the f-string, ignore escaped curly braces
+            if not stack and i + 1 < len(s) and s[i + 1] == "{":
+                i += 2
+                continue
+            stack.append(i)
+            i += 1
+            continue
+
+        if s[i] == "}":
+            if not stack:
+                i += 1
+                continue
+            j = stack.pop()
+            # we've made it back out of the expression! yield the span
+            if not stack:
+                yield (j, i + 1)
+            i += 1
+            continue
+
+        # if we're in an expression part of the f-string, fast forward through strings
+        # note that backslashes are not legal in the expression portion of f-strings
+        if stack:
+            delim = None
+            if s[i : i + 3] in ("'''", '"""'):
+                delim = s[i : i + 3]
+            elif s[i] in ("'", '"'):
+                delim = s[i]
+            if delim:
+                i += len(delim)
+                while i < len(s) and s[i : i + len(delim)] != delim:
+                    i += 1
+                i += len(delim)
+                continue
+        i += 1
+
+
+def fstring_contains_expr(s: str) -> bool:
+    return any(iter_fexpr_spans(s))
+
+
+class StringSplitter(BaseStringSplitter, CustomSplitMapMixin):
+    """
+    StringTransformer that splits "atom" strings (i.e. strings which exist on
+    lines by themselves).
+
+    Requirements:
+        * The line consists ONLY of a single string (possibly prefixed by a
+        string operator [e.g. '+' or '==']), MAYBE a string trailer, and MAYBE
+        a trailing comma.
+            AND
+        * All of the requirements listed in BaseStringSplitter's docstring.
+
+    Transformations:
+        The string mentioned in the 'Requirements' section is split into as
+        many substrings as necessary to adhere to the configured line length.
+
+        In the final set of substrings, no substring should be smaller than
+        MIN_SUBSTR_SIZE characters.
+
+        The string will ONLY be split on spaces (i.e. each new substring should
+        start with a space). Note that the string will NOT be split on a space
+        which is escaped with a backslash.
+
+        If the string is an f-string, it will NOT be split in the middle of an
+        f-expression (e.g. in f"FooBar: {foo() if x else bar()}", {foo() if x
+        else bar()} is an f-expression).
+
+        If the string that is being split has an associated set of custom split
+        records and those custom splits will NOT result in any line going over
+        the configured line length, those custom splits are used. Otherwise the
+        string is split as late as possible (from left-to-right) while still
+        adhering to the transformation rules listed above.
+
+    Collaborations:
+        StringSplitter relies on StringMerger to construct the appropriate
+        CustomSplit objects and add them to the custom split map.
+    """
+
+    MIN_SUBSTR_SIZE: Final = 6
+
+    def do_splitter_match(self, line: Line) -> TMatchResult:
+        LL = line.leaves
+
+        is_valid_index = is_valid_index_factory(LL)
+
+        idx = 0
+
+        # The first two leaves MAY be the 'not in' keywords...
+        if (
+            is_valid_index(idx)
+            and is_valid_index(idx + 1)
+            and [LL[idx].type, LL[idx + 1].type] == [token.NAME, token.NAME]
+            and str(LL[idx]) + str(LL[idx + 1]) == "not in"
+        ):
+            idx += 2
+        # Else the first leaf MAY be a string operator symbol or the 'in' keyword...
+        elif is_valid_index(idx) and (
+            LL[idx].type in self.STRING_OPERATORS
+            or LL[idx].type == token.NAME
+            and str(LL[idx]) == "in"
+        ):
+            idx += 1
+
+        # The next/first leaf MAY be an empty LPAR...
+        if is_valid_index(idx) and is_empty_lpar(LL[idx]):
+            idx += 1
+
+        # The next/first leaf MUST be a string...
+        if not is_valid_index(idx) or LL[idx].type != token.STRING:
+            return TErr("Line does not start with a string.")
+
+        string_idx = idx
+
+        # Skip the string trailer, if one exists.
+        string_parser = StringParser()
+        idx = string_parser.parse(LL, string_idx)
+
+        # That string MAY be followed by an empty RPAR...
+        if is_valid_index(idx) and is_empty_rpar(LL[idx]):
+            idx += 1
+
+        # That string / empty RPAR leaf MAY be followed by a comma...
+        if is_valid_index(idx) and LL[idx].type == token.COMMA:
+            idx += 1
+
+        # But no more leaves are allowed...
+        if is_valid_index(idx):
+            return TErr("This line does not end with a string.")
+
+        return Ok(string_idx)
+
+    def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
+        LL = line.leaves
+
+        QUOTE = LL[string_idx].value[-1]
+
+        is_valid_index = is_valid_index_factory(LL)
+        insert_str_child = insert_str_child_factory(LL[string_idx])
+
+        prefix = get_string_prefix(LL[string_idx].value).lower()
+
+        # We MAY choose to drop the 'f' prefix from substrings that don't
+        # contain any f-expressions, but ONLY if the original f-string
+        # contains at least one f-expression. Otherwise, we will alter the AST
+        # of the program.
+        drop_pointless_f_prefix = ("f" in prefix) and fstring_contains_expr(
+            LL[string_idx].value
+        )
+
+        first_string_line = True
+
+        string_op_leaves = self._get_string_operator_leaves(LL)
+        string_op_leaves_length = (
+            sum([len(str(prefix_leaf)) for prefix_leaf in string_op_leaves]) + 1
+            if string_op_leaves
+            else 0
+        )
+
+        def maybe_append_string_operators(new_line: Line) -> None:
+            """
+            Side Effects:
+                If @line starts with a string operator and this is the first
+                line we are constructing, this function appends the string
+                operator to @new_line and replaces the old string operator leaf
+                in the node structure. Otherwise this function does nothing.
+            """
+            maybe_prefix_leaves = string_op_leaves if first_string_line else []
+            for i, prefix_leaf in enumerate(maybe_prefix_leaves):
+                replace_child(LL[i], prefix_leaf)
+                new_line.append(prefix_leaf)
+
+        ends_with_comma = (
+            is_valid_index(string_idx + 1) and LL[string_idx + 1].type == token.COMMA
+        )
+
+        def max_last_string() -> int:
+            """
+            Returns:
+                The max allowed length of the string value used for the last
+                line we will construct.
+            """
+            result = self.line_length
+            result -= line.depth * 4
+            result -= 1 if ends_with_comma else 0
+            result -= string_op_leaves_length
+            return result
+
+        # --- Calculate Max Break Index (for string value)
+        # We start with the line length limit
+        max_break_idx = self.line_length
+        # The last index of a string of length N is N-1.
+        max_break_idx -= 1
+        # Leading whitespace is not present in the string value (e.g. Leaf.value).
+        max_break_idx -= line.depth * 4
+        if max_break_idx < 0:
+            yield TErr(
+                f"Unable to split {LL[string_idx].value} at such high of a line depth:"
+                f" {line.depth}"
+            )
+            return
+
+        # Check if StringMerger registered any custom splits.
+        custom_splits = self.pop_custom_splits(LL[string_idx].value)
+        # We use them ONLY if none of them would produce lines that exceed the
+        # line limit.
+        use_custom_breakpoints = bool(
+            custom_splits
+            and all(csplit.break_idx <= max_break_idx for csplit in custom_splits)
+        )
+
+        # Temporary storage for the remaining chunk of the string line that
+        # can't fit onto the line currently being constructed.
+        rest_value = LL[string_idx].value
+
+        def more_splits_should_be_made() -> bool:
+            """
+            Returns:
+                True iff `rest_value` (the remaining string value from the last
+                split), should be split again.
+            """
+            if use_custom_breakpoints:
+                return len(custom_splits) > 1
+            else:
+                return len(rest_value) > max_last_string()
+
+        string_line_results: List[Ok[Line]] = []
+        while more_splits_should_be_made():
+            if use_custom_breakpoints:
+                # Custom User Split (manual)
+                csplit = custom_splits.pop(0)
+                break_idx = csplit.break_idx
+            else:
+                # Algorithmic Split (automatic)
+                max_bidx = max_break_idx - string_op_leaves_length
+                maybe_break_idx = self._get_break_idx(rest_value, max_bidx)
+                if maybe_break_idx is None:
+                    # If we are unable to algorithmically determine a good split
+                    # and this string has custom splits registered to it, we
+                    # fall back to using them--which means we have to start
+                    # over from the beginning.
+                    if custom_splits:
+                        rest_value = LL[string_idx].value
+                        string_line_results = []
+                        first_string_line = True
+                        use_custom_breakpoints = True
+                        continue
+
+                    # Otherwise, we stop splitting here.
+                    break
+
+                break_idx = maybe_break_idx
+
+            # --- Construct `next_value`
+            next_value = rest_value[:break_idx] + QUOTE
+
+            # HACK: The following 'if' statement is a hack to fix the custom
+            # breakpoint index in the case of either: (a) substrings that were
+            # f-strings but will have the 'f' prefix removed OR (b) substrings
+            # that were not f-strings but will now become f-strings because of
+            # redundant use of the 'f' prefix (i.e. none of the substrings
+            # contain f-expressions but one or more of them had the 'f' prefix
+            # anyway; in which case, we will prepend 'f' to _all_ substrings).
+            #
+            # There is probably a better way to accomplish what is being done
+            # here...
+            #
+            # If this substring is an f-string, we _could_ remove the 'f'
+            # prefix, and the current custom split did NOT originally use a
+            # prefix...
+            if (
+                next_value != self._normalize_f_string(next_value, prefix)
+                and use_custom_breakpoints
+                and not csplit.has_prefix
+            ):
+                # Then `csplit.break_idx` will be off by one after removing
+                # the 'f' prefix.
+                break_idx += 1
+                next_value = rest_value[:break_idx] + QUOTE
+
+            if drop_pointless_f_prefix:
+                next_value = self._normalize_f_string(next_value, prefix)
+
+            # --- Construct `next_leaf`
+            next_leaf = Leaf(token.STRING, next_value)
+            insert_str_child(next_leaf)
+            self._maybe_normalize_string_quotes(next_leaf)
+
+            # --- Construct `next_line`
+            next_line = line.clone()
+            maybe_append_string_operators(next_line)
+            next_line.append(next_leaf)
+            string_line_results.append(Ok(next_line))
+
+            rest_value = prefix + QUOTE + rest_value[break_idx:]
+            first_string_line = False
+
+        yield from string_line_results
+
+        if drop_pointless_f_prefix:
+            rest_value = self._normalize_f_string(rest_value, prefix)
+
+        rest_leaf = Leaf(token.STRING, rest_value)
+        insert_str_child(rest_leaf)
+
+        # NOTE: I could not find a test case that verifies that the following
+        # line is actually necessary, but it seems to be. Otherwise we risk
+        # not normalizing the last substring, right?
+        self._maybe_normalize_string_quotes(rest_leaf)
+
+        last_line = line.clone()
+        maybe_append_string_operators(last_line)
+
+        # If there are any leaves to the right of the target string...
+        if is_valid_index(string_idx + 1):
+            # We use `temp_value` here to determine how long the last line
+            # would be if we were to append all the leaves to the right of the
+            # target string to the last string line.
+            temp_value = rest_value
+            for leaf in LL[string_idx + 1 :]:
+                temp_value += str(leaf)
+                if leaf.type == token.LPAR:
+                    break
+
+            # Try to fit them all on the same line with the last substring...
+            if (
+                len(temp_value) <= max_last_string()
+                or LL[string_idx + 1].type == token.COMMA
+            ):
+                last_line.append(rest_leaf)
+                append_leaves(last_line, line, LL[string_idx + 1 :])
+                yield Ok(last_line)
+            # Otherwise, place the last substring on one line and everything
+            # else on a line below that...
+            else:
+                last_line.append(rest_leaf)
+                yield Ok(last_line)
+
+                non_string_line = line.clone()
+                append_leaves(non_string_line, line, LL[string_idx + 1 :])
+                yield Ok(non_string_line)
+        # Else the target string was the last leaf...
+        else:
+            last_line.append(rest_leaf)
+            last_line.comments = line.comments.copy()
+            yield Ok(last_line)
+
+    def _iter_nameescape_slices(self, string: str) -> Iterator[Tuple[Index, Index]]:
+        """
+        Yields:
+            All ranges of @string which, if @string were to be split there,
+            would result in the splitting of an \\N{...} expression (which is NOT
+            allowed).
+        """
+        # True - the previous backslash was unescaped
+        # False - the previous backslash was escaped *or* there was no backslash
+        previous_was_unescaped_backslash = False
+        it = iter(enumerate(string))
+        for idx, c in it:
+            if c == "\\":
+                previous_was_unescaped_backslash = not previous_was_unescaped_backslash
+                continue
+            if not previous_was_unescaped_backslash or c != "N":
+                previous_was_unescaped_backslash = False
+                continue
+            previous_was_unescaped_backslash = False
+
+            begin = idx - 1  # the position of backslash before \N{...}
+            for idx, c in it:
+                if c == "}":
+                    end = idx
+                    break
+            else:
+                # malformed nameescape expression?
+                # should have been detected by AST parsing earlier...
+                raise RuntimeError(f"{self.__class__.__name__} LOGIC ERROR!")
+            yield begin, end
+
+    def _iter_fexpr_slices(self, string: str) -> Iterator[Tuple[Index, Index]]:
+        """
+        Yields:
+            All ranges of @string which, if @string were to be split there,
+            would result in the splitting of an f-expression (which is NOT
+            allowed).
+        """
+        if "f" not in get_string_prefix(string).lower():
+            return
+        yield from iter_fexpr_spans(string)
+
+    def _get_illegal_split_indices(self, string: str) -> Set[Index]:
+        illegal_indices: Set[Index] = set()
+        iterators = [
+            self._iter_fexpr_slices(string),
+            self._iter_nameescape_slices(string),
+        ]
+        for it in iterators:
+            for begin, end in it:
+                illegal_indices.update(range(begin, end + 1))
+        return illegal_indices
+
+    def _get_break_idx(self, string: str, max_break_idx: int) -> Optional[int]:
+        """
+        This method contains the algorithm that StringSplitter uses to
+        determine which character to split each string at.
+
+        Args:
+            @string: The substring that we are attempting to split.
+            @max_break_idx: The ideal break index. We will return this value if it
+            meets all the necessary conditions. In the likely event that it
+            doesn't we will try to find the closest index BELOW @max_break_idx
+            that does. If that fails, we will expand our search by also
+            considering all valid indices ABOVE @max_break_idx.
+
+        Pre-Conditions:
+            * assert_is_leaf_string(@string)
+            * 0 <= @max_break_idx < len(@string)
+
+        Returns:
+            break_idx, if an index is able to be found that meets all of the
+            conditions listed in the 'Transformations' section of this classes'
+            docstring.
+                OR
+            None, otherwise.
+        """
+        is_valid_index = is_valid_index_factory(string)
+
+        assert is_valid_index(max_break_idx)
+        assert_is_leaf_string(string)
+
+        _illegal_split_indices = self._get_illegal_split_indices(string)
+
+        def breaks_unsplittable_expression(i: Index) -> bool:
+            """
+            Returns:
+                True iff returning @i would result in the splitting of an
+                unsplittable expression (which is NOT allowed).
+            """
+            return i in _illegal_split_indices
+
+        def passes_all_checks(i: Index) -> bool:
+            """
+            Returns:
+                True iff ALL of the conditions listed in the 'Transformations'
+                section of this classes' docstring would be be met by returning @i.
+            """
+            is_space = string[i] == " "
+
+            is_not_escaped = True
+            j = i - 1
+            while is_valid_index(j) and string[j] == "\\":
+                is_not_escaped = not is_not_escaped
+                j -= 1
+
+            is_big_enough = (
+                len(string[i:]) >= self.MIN_SUBSTR_SIZE
+                and len(string[:i]) >= self.MIN_SUBSTR_SIZE
+            )
+            return (
+                is_space
+                and is_not_escaped
+                and is_big_enough
+                and not breaks_unsplittable_expression(i)
+            )
+
+        # First, we check all indices BELOW @max_break_idx.
+        break_idx = max_break_idx
+        while is_valid_index(break_idx - 1) and not passes_all_checks(break_idx):
+            break_idx -= 1
+
+        if not passes_all_checks(break_idx):
+            # If that fails, we check all indices ABOVE @max_break_idx.
+            #
+            # If we are able to find a valid index here, the next line is going
+            # to be longer than the specified line length, but it's probably
+            # better than doing nothing at all.
+            break_idx = max_break_idx + 1
+            while is_valid_index(break_idx + 1) and not passes_all_checks(break_idx):
+                break_idx += 1
+
+            if not is_valid_index(break_idx) or not passes_all_checks(break_idx):
+                return None
+
+        return break_idx
+
+    def _maybe_normalize_string_quotes(self, leaf: Leaf) -> None:
+        if self.normalize_strings:
+            leaf.value = normalize_string_quotes(leaf.value)
+
+    def _normalize_f_string(self, string: str, prefix: str) -> str:
+        """
+        Pre-Conditions:
+            * assert_is_leaf_string(@string)
+
+        Returns:
+            * If @string is an f-string that contains no f-expressions, we
+            return a string identical to @string except that the 'f' prefix
+            has been stripped and all double braces (i.e. '{{' or '}}') have
+            been normalized (i.e. turned into '{' or '}').
+                OR
+            * Otherwise, we return @string.
+        """
+        assert_is_leaf_string(string)
+
+        if "f" in prefix and not fstring_contains_expr(string):
+            new_prefix = prefix.replace("f", "")
+
+            temp = string[len(prefix) :]
+            temp = re.sub(r"\{\{", "{", temp)
+            temp = re.sub(r"\}\}", "}", temp)
+            new_string = temp
+
+            return f"{new_prefix}{new_string}"
+        else:
+            return string
+
+    def _get_string_operator_leaves(self, leaves: Iterable[Leaf]) -> List[Leaf]:
+        LL = list(leaves)
+
+        string_op_leaves = []
+        i = 0
+        while LL[i].type in self.STRING_OPERATORS + [token.NAME]:
+            prefix_leaf = Leaf(LL[i].type, str(LL[i]).strip())
+            string_op_leaves.append(prefix_leaf)
+            i += 1
+        return string_op_leaves
+
+
+class StringParenWrapper(BaseStringSplitter, CustomSplitMapMixin):
+    """
+    StringTransformer that splits non-"atom" strings (i.e. strings that do not
+    exist on lines by themselves).
+
+    Requirements:
+        All of the requirements listed in BaseStringSplitter's docstring in
+        addition to the requirements listed below:
+
+        * The line is a return/yield statement, which returns/yields a string.
+            OR
+        * The line is part of a ternary expression (e.g. `x = y if cond else
+        z`) such that the line starts with `else <string>`, where <string> is
+        some string.
+            OR
+        * The line is an assert statement, which ends with a string.
+            OR
+        * The line is an assignment statement (e.g. `x = <string>` or `x +=
+        <string>`) such that the variable is being assigned the value of some
+        string.
+            OR
+        * The line is a dictionary key assignment where some valid key is being
+        assigned the value of some string.
+
+    Transformations:
+        The chosen string is wrapped in parentheses and then split at the LPAR.
+
+        We then have one line which ends with an LPAR and another line that
+        starts with the chosen string. The latter line is then split again at
+        the RPAR. This results in the RPAR (and possibly a trailing comma)
+        being placed on its own line.
+
+        NOTE: If any leaves exist to the right of the chosen string (except
+        for a trailing comma, which would be placed after the RPAR), those
+        leaves are placed inside the parentheses.  In effect, the chosen
+        string is not necessarily being "wrapped" by parentheses. We can,
+        however, count on the LPAR being placed directly before the chosen
+        string.
+
+        In other words, StringParenWrapper creates "atom" strings. These
+        can then be split again by StringSplitter, if necessary.
+
+    Collaborations:
+        In the event that a string line split by StringParenWrapper is
+        changed such that it no longer needs to be given its own line,
+        StringParenWrapper relies on StringParenStripper to clean up the
+        parentheses it created.
+    """
+
+    def do_splitter_match(self, line: Line) -> TMatchResult:
+        LL = line.leaves
+
+        if line.leaves[-1].type in OPENING_BRACKETS:
+            return TErr(
+                "Cannot wrap parens around a line that ends in an opening bracket."
+            )
+
+        string_idx = (
+            self._return_match(LL)
+            or self._else_match(LL)
+            or self._assert_match(LL)
+            or self._assign_match(LL)
+            or self._dict_match(LL)
+        )
+
+        if string_idx is not None:
+            string_value = line.leaves[string_idx].value
+            # If the string has no spaces...
+            if " " not in string_value:
+                # And will still violate the line length limit when split...
+                max_string_length = self.line_length - ((line.depth + 1) * 4)
+                if len(string_value) > max_string_length:
+                    # And has no associated custom splits...
+                    if not self.has_custom_splits(string_value):
+                        # Then we should NOT put this string on its own line.
+                        return TErr(
+                            "We do not wrap long strings in parentheses when the"
+                            " resultant line would still be over the specified line"
+                            " length and can't be split further by StringSplitter."
+                        )
+            return Ok(string_idx)
+
+        return TErr("This line does not contain any non-atomic strings.")
+
+    @staticmethod
+    def _return_match(LL: List[Leaf]) -> Optional[int]:
+        """
+        Returns:
+            string_idx such that @LL[string_idx] is equal to our target (i.e.
+            matched) string, if this line matches the return/yield statement
+            requirements listed in the 'Requirements' section of this classes'
+            docstring.
+                OR
+            None, otherwise.
+        """
+        # If this line is apart of a return/yield statement and the first leaf
+        # contains either the "return" or "yield" keywords...
+        if parent_type(LL[0]) in [syms.return_stmt, syms.yield_expr] and LL[
+            0
+        ].value in ["return", "yield"]:
+            is_valid_index = is_valid_index_factory(LL)
+
+            idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
+            # The next visible leaf MUST contain a string...
+            if is_valid_index(idx) and LL[idx].type == token.STRING:
+                return idx
+
+        return None
+
+    @staticmethod
+    def _else_match(LL: List[Leaf]) -> Optional[int]:
+        """
+        Returns:
+            string_idx such that @LL[string_idx] is equal to our target (i.e.
+            matched) string, if this line matches the ternary expression
+            requirements listed in the 'Requirements' section of this classes'
+            docstring.
+                OR
+            None, otherwise.
+        """
+        # If this line is apart of a ternary expression and the first leaf
+        # contains the "else" keyword...
+        if (
+            parent_type(LL[0]) == syms.test
+            and LL[0].type == token.NAME
+            and LL[0].value == "else"
+        ):
+            is_valid_index = is_valid_index_factory(LL)
+
+            idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
+            # The next visible leaf MUST contain a string...
+            if is_valid_index(idx) and LL[idx].type == token.STRING:
+                return idx
+
+        return None
+
+    @staticmethod
+    def _assert_match(LL: List[Leaf]) -> Optional[int]:
+        """
+        Returns:
+            string_idx such that @LL[string_idx] is equal to our target (i.e.
+            matched) string, if this line matches the assert statement
+            requirements listed in the 'Requirements' section of this classes'
+            docstring.
+                OR
+            None, otherwise.
+        """
+        # If this line is apart of an assert statement and the first leaf
+        # contains the "assert" keyword...
+        if parent_type(LL[0]) == syms.assert_stmt and LL[0].value == "assert":
+            is_valid_index = is_valid_index_factory(LL)
+
+            for (i, leaf) in enumerate(LL):
+                # We MUST find a comma...
+                if leaf.type == token.COMMA:
+                    idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
+
+                    # That comma MUST be followed by a string...
+                    if is_valid_index(idx) and LL[idx].type == token.STRING:
+                        string_idx = idx
+
+                        # Skip the string trailer, if one exists.
+                        string_parser = StringParser()
+                        idx = string_parser.parse(LL, string_idx)
+
+                        # But no more leaves are allowed...
+                        if not is_valid_index(idx):
+                            return string_idx
+
+        return None
+
+    @staticmethod
+    def _assign_match(LL: List[Leaf]) -> Optional[int]:
+        """
+        Returns:
+            string_idx such that @LL[string_idx] is equal to our target (i.e.
+            matched) string, if this line matches the assignment statement
+            requirements listed in the 'Requirements' section of this classes'
+            docstring.
+                OR
+            None, otherwise.
+        """
+        # If this line is apart of an expression statement or is a function
+        # argument AND the first leaf contains a variable name...
+        if (
+            parent_type(LL[0]) in [syms.expr_stmt, syms.argument, syms.power]
+            and LL[0].type == token.NAME
+        ):
+            is_valid_index = is_valid_index_factory(LL)
+
+            for (i, leaf) in enumerate(LL):
+                # We MUST find either an '=' or '+=' symbol...
+                if leaf.type in [token.EQUAL, token.PLUSEQUAL]:
+                    idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
+
+                    # That symbol MUST be followed by a string...
+                    if is_valid_index(idx) and LL[idx].type == token.STRING:
+                        string_idx = idx
+
+                        # Skip the string trailer, if one exists.
+                        string_parser = StringParser()
+                        idx = string_parser.parse(LL, string_idx)
+
+                        # The next leaf MAY be a comma iff this line is apart
+                        # of a function argument...
+                        if (
+                            parent_type(LL[0]) == syms.argument
+                            and is_valid_index(idx)
+                            and LL[idx].type == token.COMMA
+                        ):
+                            idx += 1
+
+                        # But no more leaves are allowed...
+                        if not is_valid_index(idx):
+                            return string_idx
+
+        return None
+
+    @staticmethod
+    def _dict_match(LL: List[Leaf]) -> Optional[int]:
+        """
+        Returns:
+            string_idx such that @LL[string_idx] is equal to our target (i.e.
+            matched) string, if this line matches the dictionary key assignment
+            statement requirements listed in the 'Requirements' section of this
+            classes' docstring.
+                OR
+            None, otherwise.
+        """
+        # If this line is apart of a dictionary key assignment...
+        if syms.dictsetmaker in [parent_type(LL[0]), parent_type(LL[0].parent)]:
+            is_valid_index = is_valid_index_factory(LL)
+
+            for (i, leaf) in enumerate(LL):
+                # We MUST find a colon...
+                if leaf.type == token.COLON:
+                    idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
+
+                    # That colon MUST be followed by a string...
+                    if is_valid_index(idx) and LL[idx].type == token.STRING:
+                        string_idx = idx
+
+                        # Skip the string trailer, if one exists.
+                        string_parser = StringParser()
+                        idx = string_parser.parse(LL, string_idx)
+
+                        # That string MAY be followed by a comma...
+                        if is_valid_index(idx) and LL[idx].type == token.COMMA:
+                            idx += 1
+
+                        # But no more leaves are allowed...
+                        if not is_valid_index(idx):
+                            return string_idx
+
+        return None
+
+    def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
+        LL = line.leaves
+
+        is_valid_index = is_valid_index_factory(LL)
+        insert_str_child = insert_str_child_factory(LL[string_idx])
+
+        comma_idx = -1
+        ends_with_comma = False
+        if LL[comma_idx].type == token.COMMA:
+            ends_with_comma = True
+
+        leaves_to_steal_comments_from = [LL[string_idx]]
+        if ends_with_comma:
+            leaves_to_steal_comments_from.append(LL[comma_idx])
+
+        # --- First Line
+        first_line = line.clone()
+        left_leaves = LL[:string_idx]
+
+        # We have to remember to account for (possibly invisible) LPAR and RPAR
+        # leaves that already wrapped the target string. If these leaves do
+        # exist, we will replace them with our own LPAR and RPAR leaves.
+        old_parens_exist = False
+        if left_leaves and left_leaves[-1].type == token.LPAR:
+            old_parens_exist = True
+            leaves_to_steal_comments_from.append(left_leaves[-1])
+            left_leaves.pop()
+
+        append_leaves(first_line, line, left_leaves)
+
+        lpar_leaf = Leaf(token.LPAR, "(")
+        if old_parens_exist:
+            replace_child(LL[string_idx - 1], lpar_leaf)
+        else:
+            insert_str_child(lpar_leaf)
+        first_line.append(lpar_leaf)
+
+        # We throw inline comments that were originally to the right of the
+        # target string to the top line. They will now be shown to the right of
+        # the LPAR.
+        for leaf in leaves_to_steal_comments_from:
+            for comment_leaf in line.comments_after(leaf):
+                first_line.append(comment_leaf, preformatted=True)
+
+        yield Ok(first_line)
+
+        # --- Middle (String) Line
+        # We only need to yield one (possibly too long) string line, since the
+        # `StringSplitter` will break it down further if necessary.
+        string_value = LL[string_idx].value
+        string_line = Line(
+            mode=line.mode,
+            depth=line.depth + 1,
+            inside_brackets=True,
+            should_split_rhs=line.should_split_rhs,
+            magic_trailing_comma=line.magic_trailing_comma,
+        )
+        string_leaf = Leaf(token.STRING, string_value)
+        insert_str_child(string_leaf)
+        string_line.append(string_leaf)
+
+        old_rpar_leaf = None
+        if is_valid_index(string_idx + 1):
+            right_leaves = LL[string_idx + 1 :]
+            if ends_with_comma:
+                right_leaves.pop()
+
+            if old_parens_exist:
+                assert right_leaves and right_leaves[-1].type == token.RPAR, (
+                    "Apparently, old parentheses do NOT exist?!"
+                    f" (left_leaves={left_leaves}, right_leaves={right_leaves})"
+                )
+                old_rpar_leaf = right_leaves.pop()
+
+            append_leaves(string_line, line, right_leaves)
+
+        yield Ok(string_line)
+
+        # --- Last Line
+        last_line = line.clone()
+        last_line.bracket_tracker = first_line.bracket_tracker
+
+        new_rpar_leaf = Leaf(token.RPAR, ")")
+        if old_rpar_leaf is not None:
+            replace_child(old_rpar_leaf, new_rpar_leaf)
+        else:
+            insert_str_child(new_rpar_leaf)
+        last_line.append(new_rpar_leaf)
+
+        # If the target string ended with a comma, we place this comma to the
+        # right of the RPAR on the last line.
+        if ends_with_comma:
+            comma_leaf = Leaf(token.COMMA, ",")
+            replace_child(LL[comma_idx], comma_leaf)
+            last_line.append(comma_leaf)
+
+        yield Ok(last_line)
+
+
+class StringParser:
+    """
+    A state machine that aids in parsing a string's "trailer", which can be
+    either non-existent, an old-style formatting sequence (e.g. `% varX` or `%
+    (varX, varY)`), or a method-call / attribute access (e.g. `.format(varX,
+    varY)`).
+
+    NOTE: A new StringParser object MUST be instantiated for each string
+    trailer we need to parse.
+
+    Examples:
+        We shall assume that `line` equals the `Line` object that corresponds
+        to the following line of python code:
+        ```
+        x = "Some {}.".format("String") + some_other_string
+        ```
+
+        Furthermore, we will assume that `string_idx` is some index such that:
+        ```
+        assert line.leaves[string_idx].value == "Some {}."
+        ```
+
+        The following code snippet then holds:
+        ```
+        string_parser = StringParser()
+        idx = string_parser.parse(line.leaves, string_idx)
+        assert line.leaves[idx].type == token.PLUS
+        ```
+    """
+
+    DEFAULT_TOKEN: Final = 20210605
+
+    # String Parser States
+    START: Final = 1
+    DOT: Final = 2
+    NAME: Final = 3
+    PERCENT: Final = 4
+    SINGLE_FMT_ARG: Final = 5
+    LPAR: Final = 6
+    RPAR: Final = 7
+    DONE: Final = 8
+
+    # Lookup Table for Next State
+    _goto: Final[Dict[Tuple[ParserState, NodeType], ParserState]] = {
+        # A string trailer may start with '.' OR '%'.
+        (START, token.DOT): DOT,
+        (START, token.PERCENT): PERCENT,
+        (START, DEFAULT_TOKEN): DONE,
+        # A '.' MUST be followed by an attribute or method name.
+        (DOT, token.NAME): NAME,
+        # A method name MUST be followed by an '(', whereas an attribute name
+        # is the last symbol in the string trailer.
+        (NAME, token.LPAR): LPAR,
+        (NAME, DEFAULT_TOKEN): DONE,
+        # A '%' symbol can be followed by an '(' or a single argument (e.g. a
+        # string or variable name).
+        (PERCENT, token.LPAR): LPAR,
+        (PERCENT, DEFAULT_TOKEN): SINGLE_FMT_ARG,
+        # If a '%' symbol is followed by a single argument, that argument is
+        # the last leaf in the string trailer.
+        (SINGLE_FMT_ARG, DEFAULT_TOKEN): DONE,
+        # If present, a ')' symbol is the last symbol in a string trailer.
+        # (NOTE: LPARS and nested RPARS are not included in this lookup table,
+        # since they are treated as a special case by the parsing logic in this
+        # classes' implementation.)
+        (RPAR, DEFAULT_TOKEN): DONE,
+    }
+
+    def __init__(self) -> None:
+        self._state = self.START
+        self._unmatched_lpars = 0
+
+    def parse(self, leaves: List[Leaf], string_idx: int) -> int:
+        """
+        Pre-conditions:
+            * @leaves[@string_idx].type == token.STRING
+
+        Returns:
+            The index directly after the last leaf which is apart of the string
+            trailer, if a "trailer" exists.
+                OR
+            @string_idx + 1, if no string "trailer" exists.
+        """
+        assert leaves[string_idx].type == token.STRING
+
+        idx = string_idx + 1
+        while idx < len(leaves) and self._next_state(leaves[idx]):
+            idx += 1
+        return idx
+
+    def _next_state(self, leaf: Leaf) -> bool:
+        """
+        Pre-conditions:
+            * On the first call to this function, @leaf MUST be the leaf that
+            was directly after the string leaf in question (e.g. if our target
+            string is `line.leaves[i]` then the first call to this method must
+            be `line.leaves[i + 1]`).
+            * On the next call to this function, the leaf parameter passed in
+            MUST be the leaf directly following @leaf.
+
+        Returns:
+            True iff @leaf is apart of the string's trailer.
+        """
+        # We ignore empty LPAR or RPAR leaves.
+        if is_empty_par(leaf):
+            return True
+
+        next_token = leaf.type
+        if next_token == token.LPAR:
+            self._unmatched_lpars += 1
+
+        current_state = self._state
+
+        # The LPAR parser state is a special case. We will return True until we
+        # find the matching RPAR token.
+        if current_state == self.LPAR:
+            if next_token == token.RPAR:
+                self._unmatched_lpars -= 1
+                if self._unmatched_lpars == 0:
+                    self._state = self.RPAR
+        # Otherwise, we use a lookup table to determine the next state.
+        else:
+            # If the lookup table matches the current state to the next
+            # token, we use the lookup table.
+            if (current_state, next_token) in self._goto:
+                self._state = self._goto[current_state, next_token]
+            else:
+                # Otherwise, we check if a the current state was assigned a
+                # default.
+                if (current_state, self.DEFAULT_TOKEN) in self._goto:
+                    self._state = self._goto[current_state, self.DEFAULT_TOKEN]
+                # If no default has been assigned, then this parser has a logic
+                # error.
+                else:
+                    raise RuntimeError(f"{self.__class__.__name__} LOGIC ERROR!")
+
+            if self._state == self.DONE:
+                return False
+
+        return True
+
+
+def insert_str_child_factory(string_leaf: Leaf) -> Callable[[LN], None]:
+    """
+    Factory for a convenience function that is used to orphan @string_leaf
+    and then insert multiple new leaves into the same part of the node
+    structure that @string_leaf had originally occupied.
+
+    Examples:
+        Let `string_leaf = Leaf(token.STRING, '"foo"')` and `N =
+        string_leaf.parent`. Assume the node `N` has the following
+        original structure:
+
+        Node(
+            expr_stmt, [
+                Leaf(NAME, 'x'),
+                Leaf(EQUAL, '='),
+                Leaf(STRING, '"foo"'),
+            ]
+        )
+
+        We then run the code snippet shown below.
+        ```
+        insert_str_child = insert_str_child_factory(string_leaf)
+
+        lpar = Leaf(token.LPAR, '(')
+        insert_str_child(lpar)
+
+        bar = Leaf(token.STRING, '"bar"')
+        insert_str_child(bar)
+
+        rpar = Leaf(token.RPAR, ')')
+        insert_str_child(rpar)
+        ```
+
+        After which point, it follows that `string_leaf.parent is None` and
+        the node `N` now has the following structure:
+
+        Node(
+            expr_stmt, [
+                Leaf(NAME, 'x'),
+                Leaf(EQUAL, '='),
+                Leaf(LPAR, '('),
+                Leaf(STRING, '"bar"'),
+                Leaf(RPAR, ')'),
+            ]
+        )
+    """
+    string_parent = string_leaf.parent
+    string_child_idx = string_leaf.remove()
+
+    def insert_str_child(child: LN) -> None:
+        nonlocal string_child_idx
+
+        assert string_parent is not None
+        assert string_child_idx is not None
+
+        string_parent.insert_child(string_child_idx, child)
+        string_child_idx += 1
+
+    return insert_str_child
+
+
+def is_valid_index_factory(seq: Sequence[Any]) -> Callable[[int], bool]:
+    """
+    Examples:
+        ```
+        my_list = [1, 2, 3]
+
+        is_valid_index = is_valid_index_factory(my_list)
+
+        assert is_valid_index(0)
+        assert is_valid_index(2)
+
+        assert not is_valid_index(3)
+        assert not is_valid_index(-1)
+        ```
+    """
+
+    def is_valid_index(idx: int) -> bool:
+        """
+        Returns:
+            True iff @idx is positive AND seq[@idx] does NOT raise an
+            IndexError.
+        """
+        return 0 <= idx < len(seq)
+
+    return is_valid_index
diff --git a/myenv/lib/python3.9/site-packages/black_primer/__init__.py b/myenv/lib/python3.9/site-packages/black_primer/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/black_primer/cli.py b/myenv/lib/python3.9/site-packages/black_primer/cli.py
new file mode 100644
index 0000000..8524b59
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black_primer/cli.py
@@ -0,0 +1,195 @@
+# coding=utf8
+
+import asyncio
+import json
+import logging
+import sys
+from datetime import datetime
+from pathlib import Path
+from shutil import rmtree, which
+from tempfile import gettempdir
+from typing import Any, List, Optional, Union
+
+import click
+
+from black_primer import lib
+
+# If our environment has uvloop installed lets use it
+try:
+    import uvloop
+
+    uvloop.install()
+except ImportError:
+    pass
+
+
+DEFAULT_CONFIG = Path(__file__).parent / "primer.json"
+_timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+DEFAULT_WORKDIR = Path(gettempdir()) / f"primer.{_timestamp}"
+LOG = logging.getLogger(__name__)
+
+
+def _handle_debug(
+    ctx: Optional[click.core.Context],
+    param: Optional[Union[click.core.Option, click.core.Parameter]],
+    debug: Union[bool, int, str],
+) -> Union[bool, int, str]:
+    """Turn on debugging if asked otherwise INFO default"""
+    log_level = logging.DEBUG if debug else logging.INFO
+    logging.basicConfig(
+        format="[%(asctime)s] %(levelname)s: %(message)s (%(filename)s:%(lineno)d)",
+        level=log_level,
+    )
+    return debug
+
+
+def load_projects(config_path: Path) -> List[str]:
+    with open(config_path) as config:
+        return sorted(json.load(config)["projects"].keys())
+
+
+# Unfortunately does import time file IO - but appears to be the only
+# way to get `black-primer --help` to show projects list
+DEFAULT_PROJECTS = load_projects(DEFAULT_CONFIG)
+
+
+def _projects_callback(
+    ctx: click.core.Context,
+    param: Optional[Union[click.core.Option, click.core.Parameter]],
+    projects: str,
+) -> List[str]:
+    requested_projects = set(projects.split(","))
+    available_projects = set(
+        DEFAULT_PROJECTS
+        if str(DEFAULT_CONFIG) == ctx.params["config"]
+        else load_projects(ctx.params["config"])
+    )
+
+    unavailable = requested_projects - available_projects
+    if unavailable:
+        LOG.error(f"Projects not found: {unavailable}. Available: {available_projects}")
+
+    return sorted(requested_projects & available_projects)
+
+
+async def async_main(
+    config: str,
+    debug: bool,
+    keep: bool,
+    long_checkouts: bool,
+    no_diff: bool,
+    projects: List[str],
+    rebase: bool,
+    workdir: str,
+    workers: int,
+) -> int:
+    work_path = Path(workdir)
+    if not work_path.exists():
+        LOG.debug(f"Creating {work_path}")
+        work_path.mkdir()
+
+    if not which("black"):
+        LOG.error("Can not find 'black' executable in PATH. No point in running")
+        return -1
+
+    try:
+        ret_val = await lib.process_queue(
+            config,
+            work_path,
+            workers,
+            projects,
+            keep,
+            long_checkouts,
+            rebase,
+            no_diff,
+        )
+        return int(ret_val)
+
+    finally:
+        if not keep and work_path.exists():
+            LOG.debug(f"Removing {work_path}")
+            rmtree(work_path, onerror=lib.handle_PermissionError)
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.option(
+    "-c",
+    "--config",
+    default=str(DEFAULT_CONFIG),
+    type=click.Path(exists=True),
+    show_default=True,
+    help="JSON config file path",
+    # Eager - because config path is used by other callback options
+    is_eager=True,
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    callback=_handle_debug,
+    show_default=True,
+    help="Turn on debug logging",
+)
+@click.option(
+    "-k",
+    "--keep",
+    is_flag=True,
+    show_default=True,
+    help="Keep workdir + repos post run",
+)
+@click.option(
+    "-L",
+    "--long-checkouts",
+    is_flag=True,
+    show_default=True,
+    help="Pull big projects to test",
+)
+@click.option(
+    "--no-diff",
+    is_flag=True,
+    show_default=True,
+    help="Disable showing source file changes in black output",
+)
+@click.option(
+    "--projects",
+    default=",".join(DEFAULT_PROJECTS),
+    callback=_projects_callback,
+    show_default=True,
+    help="Comma separated list of projects to run",
+)
+@click.option(
+    "-R",
+    "--rebase",
+    is_flag=True,
+    show_default=True,
+    help="Rebase project if already checked out",
+)
+@click.option(
+    "-w",
+    "--workdir",
+    default=str(DEFAULT_WORKDIR),
+    type=click.Path(exists=False),
+    show_default=True,
+    help="Directory path for repo checkouts",
+)
+@click.option(
+    "-W",
+    "--workers",
+    default=2,
+    type=int,
+    show_default=True,
+    help="Number of parallel worker coroutines",
+)
+@click.pass_context
+def main(ctx: click.core.Context, **kwargs: Any) -> None:
+    """primer - prime projects for blackening... 🏴"""
+    LOG.debug(f"Starting {sys.argv[0]}")
+    # TODO: Change to asyncio.run when Black >= 3.7 only
+    loop = asyncio.get_event_loop()
+    try:
+        ctx.exit(loop.run_until_complete(async_main(**kwargs)))
+    finally:
+        loop.close()
+
+
+if __name__ == "__main__":  # pragma: nocover
+    main()
diff --git a/myenv/lib/python3.9/site-packages/black_primer/lib.py b/myenv/lib/python3.9/site-packages/black_primer/lib.py
new file mode 100644
index 0000000..13724f4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black_primer/lib.py
@@ -0,0 +1,423 @@
+import asyncio
+import errno
+import json
+import logging
+import os
+import stat
+import sys
+from functools import partial
+from pathlib import Path
+from platform import system
+from shutil import rmtree, which
+from subprocess import CalledProcessError
+from sys import version_info
+from tempfile import TemporaryDirectory
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    NamedTuple,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
+from urllib.parse import urlparse
+
+import click
+
+
+TEN_MINUTES_SECONDS = 600
+WINDOWS = system() == "Windows"
+BLACK_BINARY = "black.exe" if WINDOWS else "black"
+GIT_BINARY = "git.exe" if WINDOWS else "git"
+LOG = logging.getLogger(__name__)
+
+
+# Windows needs a ProactorEventLoop if you want to exec subprocesses
+# Starting with 3.8 this is the default - can remove when Black >= 3.8
+# mypy only respects sys.platform if directly in the evaluation
+# https://mypy.readthedocs.io/en/latest/common_issues.html#python-version-and-system-platform-checks  # noqa: B950
+if sys.platform == "win32":
+    asyncio.set_event_loop(asyncio.ProactorEventLoop())
+
+
+class Results(NamedTuple):
+    stats: Dict[str, int] = {}
+    failed_projects: Dict[str, CalledProcessError] = {}
+
+
+async def _gen_check_output(
+    cmd: Sequence[str],
+    timeout: float = TEN_MINUTES_SECONDS,
+    env: Optional[Dict[str, str]] = None,
+    cwd: Optional[Path] = None,
+    stdin: Optional[bytes] = None,
+) -> Tuple[bytes, bytes]:
+    process = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+        env=env,
+        cwd=cwd,
+    )
+    try:
+        (stdout, stderr) = await asyncio.wait_for(process.communicate(stdin), timeout)
+    except asyncio.TimeoutError:
+        process.kill()
+        await process.wait()
+        raise
+
+    # A non-optional timeout was supplied to asyncio.wait_for, guaranteeing
+    # a timeout or completed process.  A terminated Python process will have a
+    # non-empty returncode value.
+    assert process.returncode is not None
+
+    if process.returncode != 0:
+        cmd_str = " ".join(cmd)
+        raise CalledProcessError(
+            process.returncode, cmd_str, output=stdout, stderr=stderr
+        )
+
+    return (stdout, stderr)
+
+
+def analyze_results(project_count: int, results: Results) -> int:
+    failed_pct = round(((results.stats["failed"] / project_count) * 100), 2)
+    success_pct = round(((results.stats["success"] / project_count) * 100), 2)
+
+    if results.failed_projects:
+        click.secho("\nFailed projects:\n", bold=True)
+
+    for project_name, project_cpe in results.failed_projects.items():
+        print(f"## {project_name}:")
+        print(f" - Returned {project_cpe.returncode}")
+        if project_cpe.stderr:
+            print(f" - stderr:\n{project_cpe.stderr.decode('utf8')}")
+        if project_cpe.stdout:
+            print(f" - stdout:\n{project_cpe.stdout.decode('utf8')}")
+        print("")
+
+    click.secho("-- primer results 📊 --\n", bold=True)
+    click.secho(
+        f"{results.stats['success']} / {project_count} succeeded ({success_pct}%) ✅",
+        bold=True,
+        fg="green",
+    )
+    click.secho(
+        f"{results.stats['failed']} / {project_count} FAILED ({failed_pct}%) 💩",
+        bold=bool(results.stats["failed"]),
+        fg="red",
+    )
+    s = "" if results.stats["disabled"] == 1 else "s"
+    click.echo(f" - {results.stats['disabled']} project{s} disabled by config")
+    s = "" if results.stats["wrong_py_ver"] == 1 else "s"
+    click.echo(
+        f" - {results.stats['wrong_py_ver']} project{s} skipped due to Python version"
+    )
+    click.echo(
+        f" - {results.stats['skipped_long_checkout']} skipped due to long checkout"
+    )
+
+    if results.failed_projects:
+        failed = ", ".join(results.failed_projects.keys())
+        click.secho(f"\nFailed projects: {failed}\n", bold=True)
+
+    return results.stats["failed"]
+
+
+def _flatten_cli_args(cli_args: List[Union[Sequence[str], str]]) -> List[str]:
+    """Allow a user to put long arguments into a list of strs
+    to make the JSON human readable"""
+    flat_args = []
+    for arg in cli_args:
+        if isinstance(arg, str):
+            flat_args.append(arg)
+            continue
+
+        args_as_str = "".join(arg)
+        flat_args.append(args_as_str)
+
+    return flat_args
+
+
+async def black_run(
+    project_name: str,
+    repo_path: Optional[Path],
+    project_config: Dict[str, Any],
+    results: Results,
+    no_diff: bool = False,
+) -> None:
+    """Run Black and record failures"""
+    if not repo_path:
+        results.stats["failed"] += 1
+        results.failed_projects[project_name] = CalledProcessError(
+            69, [], f"{project_name} has no repo_path: {repo_path}".encode(), b""
+        )
+        return
+
+    stdin_test = project_name.upper() == "STDIN"
+    cmd = [str(which(BLACK_BINARY))]
+    if "cli_arguments" in project_config and project_config["cli_arguments"]:
+        cmd.extend(_flatten_cli_args(project_config["cli_arguments"]))
+    cmd.append("--check")
+    if not no_diff:
+        cmd.append("--diff")
+
+    # Workout if we should read in a python file or search from cwd
+    stdin = None
+    if stdin_test:
+        cmd.append("-")
+        stdin = repo_path.read_bytes()
+    elif "base_path" in project_config:
+        cmd.append(project_config["base_path"])
+    else:
+        cmd.append(".")
+
+    timeout = (
+        project_config["timeout_seconds"]
+        if "timeout_seconds" in project_config
+        else TEN_MINUTES_SECONDS
+    )
+    with TemporaryDirectory() as tmp_path:
+        # Prevent reading top-level user configs by manipulating environment variables
+        env = {
+            **os.environ,
+            "XDG_CONFIG_HOME": tmp_path,  # Unix-like
+            "USERPROFILE": tmp_path,  # Windows (changes `Path.home()` output)
+        }
+
+        cwd_path = repo_path.parent if stdin_test else repo_path
+        try:
+            LOG.debug(f"Running black for {project_name}: {' '.join(cmd)}")
+            _stdout, _stderr = await _gen_check_output(
+                cmd, cwd=cwd_path, env=env, stdin=stdin, timeout=timeout
+            )
+        except asyncio.TimeoutError:
+            results.stats["failed"] += 1
+            LOG.error(f"Running black for {repo_path} timed out ({cmd})")
+        except CalledProcessError as cpe:
+            # TODO: Tune for smarter for higher signal
+            # If any other return value than 1 we raise - can disable project in config
+            if cpe.returncode == 1:
+                if not project_config["expect_formatting_changes"]:
+                    results.stats["failed"] += 1
+                    results.failed_projects[repo_path.name] = cpe
+                else:
+                    results.stats["success"] += 1
+                return
+            elif cpe.returncode > 1:
+                results.stats["failed"] += 1
+                results.failed_projects[repo_path.name] = cpe
+                return
+
+            LOG.error(f"Unknown error with {repo_path}")
+            raise
+
+    # If we get here and expect formatting changes something is up
+    if project_config["expect_formatting_changes"]:
+        results.stats["failed"] += 1
+        results.failed_projects[repo_path.name] = CalledProcessError(
+            0, cmd, b"Expected formatting changes but didn't get any!", b""
+        )
+        return
+
+    results.stats["success"] += 1
+
+
+async def git_checkout_or_rebase(
+    work_path: Path,
+    project_config: Dict[str, Any],
+    rebase: bool = False,
+    *,
+    depth: int = 1,
+) -> Optional[Path]:
+    """git Clone project or rebase"""
+    git_bin = str(which(GIT_BINARY))
+    if not git_bin:
+        LOG.error("No git binary found")
+        return None
+
+    repo_url_parts = urlparse(project_config["git_clone_url"])
+    path_parts = repo_url_parts.path[1:].split("/", maxsplit=1)
+
+    repo_path: Path = work_path / path_parts[1].replace(".git", "")
+    cmd = [git_bin, "clone", "--depth", str(depth), project_config["git_clone_url"]]
+    cwd = work_path
+    if repo_path.exists() and rebase:
+        cmd = [git_bin, "pull", "--rebase"]
+        cwd = repo_path
+    elif repo_path.exists():
+        return repo_path
+
+    try:
+        _stdout, _stderr = await _gen_check_output(cmd, cwd=cwd)
+    except (asyncio.TimeoutError, CalledProcessError) as e:
+        LOG.error(f"Unable to git clone / pull {project_config['git_clone_url']}: {e}")
+        return None
+
+    return repo_path
+
+
+def handle_PermissionError(
+    func: Callable[..., None], path: Path, exc: Tuple[Any, Any, Any]
+) -> None:
+    """
+    Handle PermissionError during shutil.rmtree.
+
+    This checks if the erroring function is either 'os.rmdir' or 'os.unlink', and that
+    the error was EACCES (i.e. Permission denied). If true, the path is set writable,
+    readable, and executable by everyone. Finally, it tries the error causing delete
+    operation again.
+
+    If the check is false, then the original error will be reraised as this function
+    can't handle it.
+    """
+    excvalue = exc[1]
+    LOG.debug(f"Handling {excvalue} from {func.__name__}... ")
+    if func in (os.rmdir, os.unlink) and excvalue.errno == errno.EACCES:
+        LOG.debug(f"Setting {path} writable, readable, and executable by everyone... ")
+        os.chmod(path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)  # chmod 0777
+        func(path)  # Try the error causing delete operation again
+    else:
+        raise
+
+
+async def load_projects_queue(
+    config_path: Path,
+    projects_to_run: List[str],
+) -> Tuple[Dict[str, Any], asyncio.Queue]:
+    """Load project config and fill queue with all the project names"""
+    with config_path.open("r") as cfp:
+        config = json.load(cfp)
+
+    # TODO: Offer more options here
+    # e.g. Run on X random packages etc.
+    queue: asyncio.Queue = asyncio.Queue(maxsize=len(projects_to_run))
+    for project in projects_to_run:
+        await queue.put(project)
+
+    return config, queue
+
+
+async def project_runner(
+    idx: int,
+    config: Dict[str, Any],
+    queue: asyncio.Queue,
+    work_path: Path,
+    results: Results,
+    long_checkouts: bool = False,
+    rebase: bool = False,
+    keep: bool = False,
+    no_diff: bool = False,
+) -> None:
+    """Check out project and run Black on it + record result"""
+    loop = asyncio.get_event_loop()
+    py_version = f"{version_info[0]}.{version_info[1]}"
+    while True:
+        try:
+            project_name = queue.get_nowait()
+        except asyncio.QueueEmpty:
+            LOG.debug(f"project_runner {idx} exiting")
+            return
+        LOG.debug(f"worker {idx} working on {project_name}")
+
+        project_config = config["projects"][project_name]
+
+        # Check if disabled by config
+        if "disabled" in project_config and project_config["disabled"]:
+            results.stats["disabled"] += 1
+            LOG.info(f"Skipping {project_name} as it's disabled via config")
+            continue
+
+        # Check if we should run on this version of Python
+        if (
+            "all" not in project_config["py_versions"]
+            and py_version not in project_config["py_versions"]
+        ):
+            results.stats["wrong_py_ver"] += 1
+            LOG.debug(f"Skipping {project_name} as it's not enabled for {py_version}")
+            continue
+
+        # Check if we're doing big projects / long checkouts
+        if not long_checkouts and project_config["long_checkout"]:
+            results.stats["skipped_long_checkout"] += 1
+            LOG.debug(f"Skipping {project_name} as it's configured as a long checkout")
+            continue
+
+        repo_path: Optional[Path] = Path(__file__)
+        stdin_project = project_name.upper() == "STDIN"
+        if not stdin_project:
+            repo_path = await git_checkout_or_rebase(work_path, project_config, rebase)
+            if not repo_path:
+                continue
+        await black_run(project_name, repo_path, project_config, results, no_diff)
+
+        if not keep and not stdin_project:
+            LOG.debug(f"Removing {repo_path}")
+            rmtree_partial = partial(
+                rmtree, path=repo_path, onerror=handle_PermissionError
+            )
+            await loop.run_in_executor(None, rmtree_partial)
+
+        LOG.info(f"Finished {project_name}")
+
+
+async def process_queue(
+    config_file: str,
+    work_path: Path,
+    workers: int,
+    projects_to_run: List[str],
+    keep: bool = False,
+    long_checkouts: bool = False,
+    rebase: bool = False,
+    no_diff: bool = False,
+) -> int:
+    """
+    Process the queue with X workers and evaluate results
+    - Success is guaged via the config "expect_formatting_changes"
+
+    Integer return equals the number of failed projects
+    """
+    results = Results()
+    results.stats["disabled"] = 0
+    results.stats["failed"] = 0
+    results.stats["skipped_long_checkout"] = 0
+    results.stats["success"] = 0
+    results.stats["wrong_py_ver"] = 0
+
+    config, queue = await load_projects_queue(Path(config_file), projects_to_run)
+    project_count = queue.qsize()
+    s = "" if project_count == 1 else "s"
+    LOG.info(f"{project_count} project{s} to run Black over")
+    if project_count < 1:
+        return -1
+
+    s = "" if workers == 1 else "s"
+    LOG.debug(f"Using {workers} parallel worker{s} to run Black")
+    # Wait until we finish running all the projects before analyzing
+    await asyncio.gather(
+        *[
+            project_runner(
+                i,
+                config,
+                queue,
+                work_path,
+                results,
+                long_checkouts,
+                rebase,
+                keep,
+                no_diff,
+            )
+            for i in range(workers)
+        ]
+    )
+
+    LOG.info("Analyzing results")
+    return analyze_results(project_count, results)
+
+
+if __name__ == "__main__":  # pragma: nocover
+    raise NotImplementedError("lib is a library, funnily enough.")
diff --git a/myenv/lib/python3.9/site-packages/black_primer/primer.json b/myenv/lib/python3.9/site-packages/black_primer/primer.json
new file mode 100644
index 0000000..8fe61e8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/black_primer/primer.json
@@ -0,0 +1,188 @@
+{
+  "configuration_format_version": 20210815,
+  "projects": {
+    "STDIN": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": false,
+      "git_clone_url": "",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "aioexabgp": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": false,
+      "git_clone_url": "https://github.com/cooperlees/aioexabgp.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "attrs": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/python-attrs/attrs.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "bandersnatch": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/pypa/bandersnatch.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "channels": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/django/channels.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "cpython": {
+      "disabled": true,
+      "disabled_reason": "To big / slow for GitHub Actions but handy to keep config to use manually or in some other CI in the future",
+      "base_path": "Lib",
+      "cli_arguments": [
+        "--experimental-string-processing",
+        "--extend-exclude",
+        [
+          "Lib/lib2to3/tests/data/different_encoding.py",
+          "|Lib/lib2to3/tests/data/false_encoding.py",
+          "|Lib/lib2to3/tests/data/py2_test_grammar.py",
+          "|Lib/test/bad_coding.py",
+          "|Lib/test/bad_coding2.py",
+          "|Lib/test/badsyntax_3131.py",
+          "|Lib/test/badsyntax_pep3120.py",
+          "|Lib/test/test_base64.py",
+          "|Lib/test/test_exceptions.py",
+          "|Lib/test/test_grammar.py",
+          "|Lib/test/test_named_expressions.py",
+          "|Lib/test/test_patma.py",
+          "|Lib/test/test_tokenize.py",
+          "|Lib/test/test_xml_etree.py",
+          "|Lib/traceback.py"
+        ]
+      ],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/python/cpython.git",
+      "long_checkout": false,
+      "py_versions": ["3.9", "3.10"],
+      "timeout_seconds": 900
+    },
+    "django": {
+      "cli_arguments": [
+        "--experimental-string-processing",
+        "--skip-string-normalization",
+        "--extend-exclude",
+        "/((docs|scripts)/|django/forms/models.py|tests/gis_tests/test_spatialrefsys.py|tests/test_runner_apps/tagged/tests_syntax_error.py)"
+      ],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/django/django.git",
+      "long_checkout": false,
+      "py_versions": ["3.8", "3.9", "3.10"]
+    },
+    "flake8-bugbear": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": false,
+      "git_clone_url": "https://github.com/PyCQA/flake8-bugbear.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "hypothesis": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/HypothesisWorks/hypothesis.git",
+      "long_checkout": false,
+      "py_versions": ["3.8", "3.9", "3.10"]
+    },
+    "pandas": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/pandas-dev/pandas.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "pillow": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/python-pillow/Pillow.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "poetry": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/python-poetry/poetry.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "pyanalyze": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/quora/pyanalyze.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "pyramid": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/Pylons/pyramid.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "ptr": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": false,
+      "git_clone_url": "https://github.com/facebookincubator/ptr.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "pytest": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/pytest-dev/pytest.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "scikit-lego": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/koaning/scikit-lego",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "sqlalchemy": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/sqlalchemy/sqlalchemy.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "tox": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/tox-dev/tox.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "typeshed": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/python/typeshed.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "virtualenv": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/pypa/virtualenv.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    },
+    "warehouse": {
+      "cli_arguments": ["--experimental-string-processing"],
+      "expect_formatting_changes": true,
+      "git_clone_url": "https://github.com/pypa/warehouse.git",
+      "long_checkout": false,
+      "py_versions": ["all"]
+    }
+  }
+}
diff --git a/myenv/lib/python3.9/site-packages/blackd/__init__.py b/myenv/lib/python3.9/site-packages/blackd/__init__.py
new file mode 100644
index 0000000..cc96640
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blackd/__init__.py
@@ -0,0 +1,201 @@
+import asyncio
+import logging
+from concurrent.futures import Executor, ProcessPoolExecutor
+from datetime import datetime
+from functools import partial
+from multiprocessing import freeze_support
+from typing import Set, Tuple
+
+try:
+    from aiohttp import web
+    from .middlewares import cors
+except ImportError as ie:
+    raise ImportError(
+        f"aiohttp dependency is not installed: {ie}. "
+        + "Please re-install black with the '[d]' extra install "
+        + "to obtain aiohttp_cors: `pip install black[d]`"
+    ) from None
+
+import black
+from black.concurrency import maybe_install_uvloop
+import click
+
+from _black_version import version as __version__
+
+# This is used internally by tests to shut down the server prematurely
+_stop_signal = asyncio.Event()
+
+# Request headers
+PROTOCOL_VERSION_HEADER = "X-Protocol-Version"
+LINE_LENGTH_HEADER = "X-Line-Length"
+PYTHON_VARIANT_HEADER = "X-Python-Variant"
+SKIP_STRING_NORMALIZATION_HEADER = "X-Skip-String-Normalization"
+SKIP_MAGIC_TRAILING_COMMA = "X-Skip-Magic-Trailing-Comma"
+FAST_OR_SAFE_HEADER = "X-Fast-Or-Safe"
+DIFF_HEADER = "X-Diff"
+
+BLACK_HEADERS = [
+    PROTOCOL_VERSION_HEADER,
+    LINE_LENGTH_HEADER,
+    PYTHON_VARIANT_HEADER,
+    SKIP_STRING_NORMALIZATION_HEADER,
+    SKIP_MAGIC_TRAILING_COMMA,
+    FAST_OR_SAFE_HEADER,
+    DIFF_HEADER,
+]
+
+# Response headers
+BLACK_VERSION_HEADER = "X-Black-Version"
+
+
+class InvalidVariantHeader(Exception):
+    pass
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.option(
+    "--bind-host", type=str, help="Address to bind the server to.", default="localhost"
+)
+@click.option("--bind-port", type=int, help="Port to listen on", default=45484)
+@click.version_option(version=black.__version__)
+def main(bind_host: str, bind_port: int) -> None:
+    logging.basicConfig(level=logging.INFO)
+    app = make_app()
+    ver = black.__version__
+    black.out(f"blackd version {ver} listening on {bind_host} port {bind_port}")
+    web.run_app(app, host=bind_host, port=bind_port, handle_signals=True, print=None)
+
+
+def make_app() -> web.Application:
+    app = web.Application(
+        middlewares=[cors(allow_headers=(*BLACK_HEADERS, "Content-Type"))]
+    )
+    executor = ProcessPoolExecutor()
+    app.add_routes([web.post("/", partial(handle, executor=executor))])
+    return app
+
+
+async def handle(request: web.Request, executor: Executor) -> web.Response:
+    headers = {BLACK_VERSION_HEADER: __version__}
+    try:
+        if request.headers.get(PROTOCOL_VERSION_HEADER, "1") != "1":
+            return web.Response(
+                status=501, text="This server only supports protocol version 1"
+            )
+        try:
+            line_length = int(
+                request.headers.get(LINE_LENGTH_HEADER, black.DEFAULT_LINE_LENGTH)
+            )
+        except ValueError:
+            return web.Response(status=400, text="Invalid line length header value")
+
+        if PYTHON_VARIANT_HEADER in request.headers:
+            value = request.headers[PYTHON_VARIANT_HEADER]
+            try:
+                pyi, versions = parse_python_variant_header(value)
+            except InvalidVariantHeader as e:
+                return web.Response(
+                    status=400,
+                    text=f"Invalid value for {PYTHON_VARIANT_HEADER}: {e.args[0]}",
+                )
+        else:
+            pyi = False
+            versions = set()
+
+        skip_string_normalization = bool(
+            request.headers.get(SKIP_STRING_NORMALIZATION_HEADER, False)
+        )
+        skip_magic_trailing_comma = bool(
+            request.headers.get(SKIP_MAGIC_TRAILING_COMMA, False)
+        )
+        fast = False
+        if request.headers.get(FAST_OR_SAFE_HEADER, "safe") == "fast":
+            fast = True
+        mode = black.FileMode(
+            target_versions=versions,
+            is_pyi=pyi,
+            line_length=line_length,
+            string_normalization=not skip_string_normalization,
+            magic_trailing_comma=not skip_magic_trailing_comma,
+        )
+        req_bytes = await request.content.read()
+        charset = request.charset if request.charset is not None else "utf8"
+        req_str = req_bytes.decode(charset)
+        then = datetime.utcnow()
+
+        loop = asyncio.get_event_loop()
+        formatted_str = await loop.run_in_executor(
+            executor, partial(black.format_file_contents, req_str, fast=fast, mode=mode)
+        )
+
+        # Only output the diff in the HTTP response
+        only_diff = bool(request.headers.get(DIFF_HEADER, False))
+        if only_diff:
+            now = datetime.utcnow()
+            src_name = f"In\t{then} +0000"
+            dst_name = f"Out\t{now} +0000"
+            loop = asyncio.get_event_loop()
+            formatted_str = await loop.run_in_executor(
+                executor,
+                partial(black.diff, req_str, formatted_str, src_name, dst_name),
+            )
+
+        return web.Response(
+            content_type=request.content_type,
+            charset=charset,
+            headers=headers,
+            text=formatted_str,
+        )
+    except black.NothingChanged:
+        return web.Response(status=204, headers=headers)
+    except black.InvalidInput as e:
+        return web.Response(status=400, headers=headers, text=str(e))
+    except Exception as e:
+        logging.exception("Exception during handling a request")
+        return web.Response(status=500, headers=headers, text=str(e))
+
+
+def parse_python_variant_header(value: str) -> Tuple[bool, Set[black.TargetVersion]]:
+    if value == "pyi":
+        return True, set()
+    else:
+        versions = set()
+        for version in value.split(","):
+            if version.startswith("py"):
+                version = version[len("py") :]
+            if "." in version:
+                major_str, *rest = version.split(".")
+            else:
+                major_str = version[0]
+                rest = [version[1:]] if len(version) > 1 else []
+            try:
+                major = int(major_str)
+                if major not in (2, 3):
+                    raise InvalidVariantHeader("major version must be 2 or 3")
+                if len(rest) > 0:
+                    minor = int(rest[0])
+                    if major == 2 and minor != 7:
+                        raise InvalidVariantHeader(
+                            "minor version must be 7 for Python 2"
+                        )
+                else:
+                    # Default to lowest supported minor version.
+                    minor = 7 if major == 2 else 3
+                version_str = f"PY{major}{minor}"
+                if major == 3 and not hasattr(black.TargetVersion, version_str):
+                    raise InvalidVariantHeader(f"3.{minor} is not supported")
+                versions.add(black.TargetVersion[version_str])
+            except (KeyError, ValueError):
+                raise InvalidVariantHeader("expected e.g. '3.7', 'py3.5'") from None
+        return False, versions
+
+
+def patched_main() -> None:
+    maybe_install_uvloop()
+    freeze_support()
+    black.patch_click()
+    main()
+
+
+if __name__ == "__main__":
+    patched_main()
diff --git a/myenv/lib/python3.9/site-packages/blackd/middlewares.py b/myenv/lib/python3.9/site-packages/blackd/middlewares.py
new file mode 100644
index 0000000..97994ec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blackd/middlewares.py
@@ -0,0 +1,34 @@
+from typing import Iterable, Awaitable, Callable
+from aiohttp.web_response import StreamResponse
+from aiohttp.web_request import Request
+from aiohttp.web_middlewares import middleware
+
+Handler = Callable[[Request], Awaitable[StreamResponse]]
+Middleware = Callable[[Request, Handler], Awaitable[StreamResponse]]
+
+
+def cors(allow_headers: Iterable[str]) -> Middleware:
+    @middleware
+    async def impl(request: Request, handler: Handler) -> StreamResponse:
+        is_options = request.method == "OPTIONS"
+        is_preflight = is_options and "Access-Control-Request-Method" in request.headers
+        if is_preflight:
+            resp = StreamResponse()
+        else:
+            resp = await handler(request)
+
+        origin = request.headers.get("Origin")
+        if not origin:
+            return resp
+
+        resp.headers["Access-Control-Allow-Origin"] = "*"
+        resp.headers["Access-Control-Expose-Headers"] = "*"
+        if is_options:
+            resp.headers["Access-Control-Allow-Headers"] = ", ".join(allow_headers)
+            resp.headers["Access-Control-Allow-Methods"] = ", ".join(
+                ("OPTIONS", "POST")
+            )
+
+        return resp
+
+    return impl  # type: ignore
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/Grammar.txt b/myenv/lib/python3.9/site-packages/blib2to3/Grammar.txt
new file mode 100644
index 0000000..c3001e8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/Grammar.txt
@@ -0,0 +1,251 @@
+# Grammar for 2to3. This grammar supports Python 2.x and 3.x.
+
+# NOTE WELL: You should also follow all the steps listed at
+# https://devguide.python.org/grammar/
+
+# Start symbols for the grammar:
+#	file_input is a module or sequence of commands read from an input file;
+#	single_input is a single interactive statement;
+#	eval_input is the input for the eval() and input() functions.
+# NB: compound_stmt in single_input is followed by extra NEWLINE!
+file_input: (NEWLINE | stmt)* ENDMARKER
+single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE
+eval_input: testlist NEWLINE* ENDMARKER
+
+decorator: '@' namedexpr_test NEWLINE
+decorators: decorator+
+decorated: decorators (classdef | funcdef | async_funcdef)
+async_funcdef: ASYNC funcdef
+funcdef: 'def' NAME parameters ['->' test] ':' suite
+parameters: '(' [typedargslist] ')'
+
+# The following definition for typedarglist is equivalent to this set of rules:
+#
+#     arguments = argument (',' argument)*
+#     argument = tfpdef ['=' test]
+#     kwargs = '**' tname [',']
+#     args = '*' [tname]
+#     kwonly_kwargs = (',' argument)* [',' [kwargs]]
+#     args_kwonly_kwargs = args kwonly_kwargs | kwargs
+#     poskeyword_args_kwonly_kwargs = arguments [',' [args_kwonly_kwargs]]
+#     typedargslist_no_posonly  = poskeyword_args_kwonly_kwargs | args_kwonly_kwargs
+#     typedarglist = arguments ',' '/' [',' [typedargslist_no_posonly]])|(typedargslist_no_posonly)"
+#
+# It needs to be fully expanded to allow our LL(1) parser to work on it.
+
+typedargslist: tfpdef ['=' test] (',' tfpdef ['=' test])* ',' '/' [
+                     ',' [((tfpdef ['=' test] ',')* ('*' [tname] (',' tname ['=' test])*
+                            [',' ['**' tname [',']]] | '**' tname [','])
+                     | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])]
+                ] | ((tfpdef ['=' test] ',')* ('*' [tname] (',' tname ['=' test])*
+                     [',' ['**' tname [',']]] | '**' tname [','])
+                     | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
+
+tname: NAME [':' test]
+tfpdef: tname | '(' tfplist ')'
+tfplist: tfpdef (',' tfpdef)* [',']
+
+# The following definition for varargslist is equivalent to this set of rules:
+#
+#     arguments = argument (',' argument )*
+#     argument = vfpdef ['=' test]
+#     kwargs = '**' vname [',']
+#     args = '*' [vname]
+#     kwonly_kwargs = (',' argument )* [',' [kwargs]]
+#     args_kwonly_kwargs = args kwonly_kwargs | kwargs
+#     poskeyword_args_kwonly_kwargs = arguments [',' [args_kwonly_kwargs]]
+#     vararglist_no_posonly = poskeyword_args_kwonly_kwargs | args_kwonly_kwargs
+#     varargslist = arguments ',' '/' [','[(vararglist_no_posonly)]] | (vararglist_no_posonly)
+#
+# It needs to be fully expanded to allow our LL(1) parser to work on it.
+
+varargslist: vfpdef ['=' test ](',' vfpdef ['=' test])* ',' '/' [',' [
+                     ((vfpdef ['=' test] ',')* ('*' [vname] (',' vname ['=' test])*
+                            [',' ['**' vname [',']]] | '**' vname [','])
+                            | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
+                     ]] | ((vfpdef ['=' test] ',')*
+                     ('*' [vname] (',' vname ['=' test])*  [',' ['**' vname [',']]]| '**' vname [','])
+                     | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
+
+vname: NAME
+vfpdef: vname | '(' vfplist ')'
+vfplist: vfpdef (',' vfpdef)* [',']
+
+stmt: simple_stmt | compound_stmt
+simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
+small_stmt: (expr_stmt | print_stmt  | del_stmt | pass_stmt | flow_stmt |
+             import_stmt | global_stmt | exec_stmt | assert_stmt)
+expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) |
+                     ('=' (yield_expr|testlist_star_expr))*)
+annassign: ':' test ['=' (yield_expr|testlist_star_expr)]
+testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [',']
+augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' |
+            '<<=' | '>>=' | '**=' | '//=')
+# For normal and annotated assignments, additional restrictions enforced by the interpreter
+print_stmt: 'print' ( [ test (',' test)* [','] ] |
+                      '>>' test [ (',' test)+ [','] ] )
+del_stmt: 'del' exprlist
+pass_stmt: 'pass'
+flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
+break_stmt: 'break'
+continue_stmt: 'continue'
+return_stmt: 'return' [testlist_star_expr]
+yield_stmt: yield_expr
+raise_stmt: 'raise' [test ['from' test | ',' test [',' test]]]
+import_stmt: import_name | import_from
+import_name: 'import' dotted_as_names
+import_from: ('from' ('.'* dotted_name | '.'+)
+              'import' ('*' | '(' import_as_names ')' | import_as_names))
+import_as_name: NAME ['as' NAME]
+dotted_as_name: dotted_name ['as' NAME]
+import_as_names: import_as_name (',' import_as_name)* [',']
+dotted_as_names: dotted_as_name (',' dotted_as_name)*
+dotted_name: NAME ('.' NAME)*
+global_stmt: ('global' | 'nonlocal') NAME (',' NAME)*
+exec_stmt: 'exec' expr ['in' test [',' test]]
+assert_stmt: 'assert' test [',' test]
+
+compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt | match_stmt
+async_stmt: ASYNC (funcdef | with_stmt | for_stmt)
+if_stmt: 'if' namedexpr_test ':' suite ('elif' namedexpr_test ':' suite)* ['else' ':' suite]
+while_stmt: 'while' namedexpr_test ':' suite ['else' ':' suite]
+for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+try_stmt: ('try' ':' suite
+           ((except_clause ':' suite)+
+	    ['else' ':' suite]
+	    ['finally' ':' suite] |
+	   'finally' ':' suite))
+with_stmt: 'with' asexpr_test (',' asexpr_test)*  ':' suite
+
+# NB compile.c makes sure that the default except clause is last
+except_clause: 'except' [test [(',' | 'as') test]]
+suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
+
+# Backward compatibility cruft to support:
+# [ x for x in lambda: True, lambda: False if x() ]
+# even while also allowing:
+# lambda x: 5 if x else 2
+# (But not a mix of the two)
+testlist_safe: old_test [(',' old_test)+ [',']]
+old_test: or_test | old_lambdef
+old_lambdef: 'lambda' [varargslist] ':' old_test
+
+namedexpr_test: asexpr_test [':=' asexpr_test]
+
+# This is actually not a real rule, though since the parser is very
+# limited in terms of the strategy about match/case rules, we are inserting
+# a virtual case (<expr> as <expr>) as a valid expression. Unless a better
+# approach is thought, the only side effect of this seem to be just allowing
+# more stuff to be parser (which would fail on the ast).
+asexpr_test: test ['as' test]
+
+test: or_test ['if' or_test 'else' test] | lambdef
+or_test: and_test ('or' and_test)*
+and_test: not_test ('and' not_test)*
+not_test: 'not' not_test | comparison
+comparison: expr (comp_op expr)*
+comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
+star_expr: '*' expr
+expr: xor_expr ('|' xor_expr)*
+xor_expr: and_expr ('^' and_expr)*
+and_expr: shift_expr ('&' shift_expr)*
+shift_expr: arith_expr (('<<'|'>>') arith_expr)*
+arith_expr: term (('+'|'-') term)*
+term: factor (('*'|'@'|'/'|'%'|'//') factor)*
+factor: ('+'|'-'|'~') factor | power
+power: [AWAIT] atom trailer* ['**' factor]
+atom: ('(' [yield_expr|testlist_gexp] ')' |
+       '[' [listmaker] ']' |
+       '{' [dictsetmaker] '}' |
+       '`' testlist1 '`' |
+       NAME | NUMBER | STRING+ | '.' '.' '.')
+listmaker: (namedexpr_test|star_expr) ( old_comp_for | (',' (namedexpr_test|star_expr))* [','] )
+testlist_gexp: (namedexpr_test|star_expr) ( old_comp_for | (',' (namedexpr_test|star_expr))* [','] )
+lambdef: 'lambda' [varargslist] ':' test
+trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
+subscriptlist: subscript (',' subscript)* [',']
+subscript: test [':=' test] | [test] ':' [test] [sliceop]
+sliceop: ':' [test]
+exprlist: (expr|star_expr) (',' (expr|star_expr))* [',']
+testlist: test (',' test)* [',']
+dictsetmaker: ( ((test ':' test | '**' expr)
+                 (comp_for | (',' (test ':' test | '**' expr))* [','])) |
+                ((test [':=' test] | star_expr)
+		 (comp_for | (',' (test [':=' test] | star_expr))* [','])) )
+
+classdef: 'class' NAME ['(' [arglist] ')'] ':' suite
+
+arglist: argument (',' argument)* [',']
+
+# "test '=' test" is really "keyword '=' test", but we have no such token.
+# These need to be in a single rule to avoid grammar that is ambiguous
+# to our LL(1) parser. Even though 'test' includes '*expr' in star_expr,
+# we explicitly match '*' here, too, to give it proper precedence.
+# Illegal combinations and orderings are blocked in ast.c:
+# multiple (test comp_for) arguments are blocked; keyword unpackings
+# that precede iterable unpackings are blocked; etc.
+argument: ( test [comp_for] |
+            test ':=' test |
+            test 'as' test |
+            test '=' test |
+	    '**' test |
+            '*' test )
+
+comp_iter: comp_for | comp_if
+comp_for: [ASYNC] 'for' exprlist 'in' or_test [comp_iter]
+comp_if: 'if' old_test [comp_iter]
+
+# As noted above, testlist_safe extends the syntax allowed in list
+# comprehensions and generators. We can't use it indiscriminately in all
+# derivations using a comp_for-like pattern because the testlist_safe derivation
+# contains comma which clashes with trailing comma in arglist.
+#
+# This was an issue because the parser would not follow the correct derivation
+# when parsing syntactically valid Python code. Since testlist_safe was created
+# specifically to handle list comprehensions and generator expressions enclosed
+# with parentheses, it's safe to only use it in those. That avoids the issue; we
+# can parse code like set(x for x in [],).
+#
+# The syntax supported by this set of rules is not a valid Python 3 syntax,
+# hence the prefix "old".
+#
+# See https://bugs.python.org/issue27494
+old_comp_iter: old_comp_for | old_comp_if
+old_comp_for: [ASYNC] 'for' exprlist 'in' testlist_safe [old_comp_iter]
+old_comp_if: 'if' old_test [old_comp_iter]
+
+testlist1: test (',' test)*
+
+# not used in grammar, but may appear in "node" passed from Parser to Compiler
+encoding_decl: NAME
+
+yield_expr: 'yield' [yield_arg]
+yield_arg: 'from' test | testlist_star_expr
+
+
+# 3.10 match statement definition
+
+# PS: normally the grammar is much much more restricted, but
+# at this moment for not trying to bother much with encoding the
+# exact same DSL in a LL(1) parser, we will just accept an expression
+# and let the ast.parse() step of the safe mode to reject invalid
+# grammar.
+
+# The reason why it is more restricted is that, patterns are some
+# sort of a DSL (more advanced than our LHS on assignments, but
+# still in a very limited python subset). They are not really
+# expressions, but who cares. If we can parse them, that is enough
+# to reformat them.
+
+match_stmt: "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT
+
+# This is more permissive than the actual version. For example it
+# accepts `match *something:`, even though single-item starred expressions
+# are forbidden.
+subject_expr: (namedexpr_test|star_expr) (',' (namedexpr_test|star_expr))* [',']
+
+# cases
+case_block: "case" patterns [guard] ':' suite
+guard: 'if' namedexpr_test
+patterns: pattern ['as' pattern]
+pattern: (expr|star_expr) (',' (expr|star_expr))* [',']
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/PatternGrammar.txt b/myenv/lib/python3.9/site-packages/blib2to3/PatternGrammar.txt
new file mode 100644
index 0000000..36bf814
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/PatternGrammar.txt
@@ -0,0 +1,28 @@
+# Copyright 2006 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+# A grammar to describe tree matching patterns.
+# Not shown here:
+# - 'TOKEN' stands for any token (leaf node)
+# - 'any' stands for any node (leaf or interior)
+# With 'any' we can still specify the sub-structure.
+
+# The start symbol is 'Matcher'.
+
+Matcher: Alternatives ENDMARKER
+
+Alternatives: Alternative ('|' Alternative)*
+
+Alternative: (Unit | NegatedUnit)+
+
+Unit: [NAME '='] ( STRING [Repeater]
+                 | NAME [Details] [Repeater]
+                 | '(' Alternatives ')' [Repeater]
+                 | '[' Alternatives ']'
+		 )
+
+NegatedUnit: 'not' (STRING | NAME [Details] | '(' Alternatives ')')
+
+Repeater: '*' | '+' | '{' NUMBER [',' NUMBER] '}'
+
+Details: '<' Alternatives '>'
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/__init__.py b/myenv/lib/python3.9/site-packages/blib2to3/__init__.py
new file mode 100644
index 0000000..1bb8bf6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/__init__.py
@@ -0,0 +1 @@
+# empty
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/pgen2/__init__.py b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/__init__.py
new file mode 100644
index 0000000..af39048
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/__init__.py
@@ -0,0 +1,4 @@
+# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""The pgen2 package."""
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/pgen2/conv.py b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/conv.py
new file mode 100644
index 0000000..fa9825e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/conv.py
@@ -0,0 +1,256 @@
+# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+# mypy: ignore-errors
+
+"""Convert graminit.[ch] spit out by pgen to Python code.
+
+Pgen is the Python parser generator.  It is useful to quickly create a
+parser from a grammar file in Python's grammar notation.  But I don't
+want my parsers to be written in C (yet), so I'm translating the
+parsing tables to Python data structures and writing a Python parse
+engine.
+
+Note that the token numbers are constants determined by the standard
+Python tokenizer.  The standard token module defines these numbers and
+their names (the names are not used much).  The token numbers are
+hardcoded into the Python tokenizer and into pgen.  A Python
+implementation of the Python tokenizer is also available, in the
+standard tokenize module.
+
+On the other hand, symbol numbers (representing the grammar's
+non-terminals) are assigned by pgen based on the actual grammar
+input.
+
+Note: this module is pretty much obsolete; the pgen module generates
+equivalent grammar tables directly from the Grammar.txt input file
+without having to invoke the Python pgen C program.
+
+"""
+
+# Python imports
+import re
+
+# Local imports
+from pgen2 import grammar, token
+
+
+class Converter(grammar.Grammar):
+    """Grammar subclass that reads classic pgen output files.
+
+    The run() method reads the tables as produced by the pgen parser
+    generator, typically contained in two C files, graminit.h and
+    graminit.c.  The other methods are for internal use only.
+
+    See the base class for more documentation.
+
+    """
+
+    def run(self, graminit_h, graminit_c):
+        """Load the grammar tables from the text files written by pgen."""
+        self.parse_graminit_h(graminit_h)
+        self.parse_graminit_c(graminit_c)
+        self.finish_off()
+
+    def parse_graminit_h(self, filename):
+        """Parse the .h file written by pgen.  (Internal)
+
+        This file is a sequence of #define statements defining the
+        nonterminals of the grammar as numbers.  We build two tables
+        mapping the numbers to names and back.
+
+        """
+        try:
+            f = open(filename)
+        except OSError as err:
+            print("Can't open %s: %s" % (filename, err))
+            return False
+        self.symbol2number = {}
+        self.number2symbol = {}
+        lineno = 0
+        for line in f:
+            lineno += 1
+            mo = re.match(r"^#define\s+(\w+)\s+(\d+)$", line)
+            if not mo and line.strip():
+                print("%s(%s): can't parse %s" % (filename, lineno, line.strip()))
+            else:
+                symbol, number = mo.groups()
+                number = int(number)
+                assert symbol not in self.symbol2number
+                assert number not in self.number2symbol
+                self.symbol2number[symbol] = number
+                self.number2symbol[number] = symbol
+        return True
+
+    def parse_graminit_c(self, filename):
+        """Parse the .c file written by pgen.  (Internal)
+
+        The file looks as follows.  The first two lines are always this:
+
+        #include "pgenheaders.h"
+        #include "grammar.h"
+
+        After that come four blocks:
+
+        1) one or more state definitions
+        2) a table defining dfas
+        3) a table defining labels
+        4) a struct defining the grammar
+
+        A state definition has the following form:
+        - one or more arc arrays, each of the form:
+          static arc arcs_<n>_<m>[<k>] = {
+                  {<i>, <j>},
+                  ...
+          };
+        - followed by a state array, of the form:
+          static state states_<s>[<t>] = {
+                  {<k>, arcs_<n>_<m>},
+                  ...
+          };
+
+        """
+        try:
+            f = open(filename)
+        except OSError as err:
+            print("Can't open %s: %s" % (filename, err))
+            return False
+        # The code below essentially uses f's iterator-ness!
+        lineno = 0
+
+        # Expect the two #include lines
+        lineno, line = lineno + 1, next(f)
+        assert line == '#include "pgenheaders.h"\n', (lineno, line)
+        lineno, line = lineno + 1, next(f)
+        assert line == '#include "grammar.h"\n', (lineno, line)
+
+        # Parse the state definitions
+        lineno, line = lineno + 1, next(f)
+        allarcs = {}
+        states = []
+        while line.startswith("static arc "):
+            while line.startswith("static arc "):
+                mo = re.match(r"static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$", line)
+                assert mo, (lineno, line)
+                n, m, k = list(map(int, mo.groups()))
+                arcs = []
+                for _ in range(k):
+                    lineno, line = lineno + 1, next(f)
+                    mo = re.match(r"\s+{(\d+), (\d+)},$", line)
+                    assert mo, (lineno, line)
+                    i, j = list(map(int, mo.groups()))
+                    arcs.append((i, j))
+                lineno, line = lineno + 1, next(f)
+                assert line == "};\n", (lineno, line)
+                allarcs[(n, m)] = arcs
+                lineno, line = lineno + 1, next(f)
+            mo = re.match(r"static state states_(\d+)\[(\d+)\] = {$", line)
+            assert mo, (lineno, line)
+            s, t = list(map(int, mo.groups()))
+            assert s == len(states), (lineno, line)
+            state = []
+            for _ in range(t):
+                lineno, line = lineno + 1, next(f)
+                mo = re.match(r"\s+{(\d+), arcs_(\d+)_(\d+)},$", line)
+                assert mo, (lineno, line)
+                k, n, m = list(map(int, mo.groups()))
+                arcs = allarcs[n, m]
+                assert k == len(arcs), (lineno, line)
+                state.append(arcs)
+            states.append(state)
+            lineno, line = lineno + 1, next(f)
+            assert line == "};\n", (lineno, line)
+            lineno, line = lineno + 1, next(f)
+        self.states = states
+
+        # Parse the dfas
+        dfas = {}
+        mo = re.match(r"static dfa dfas\[(\d+)\] = {$", line)
+        assert mo, (lineno, line)
+        ndfas = int(mo.group(1))
+        for i in range(ndfas):
+            lineno, line = lineno + 1, next(f)
+            mo = re.match(r'\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$', line)
+            assert mo, (lineno, line)
+            symbol = mo.group(2)
+            number, x, y, z = list(map(int, mo.group(1, 3, 4, 5)))
+            assert self.symbol2number[symbol] == number, (lineno, line)
+            assert self.number2symbol[number] == symbol, (lineno, line)
+            assert x == 0, (lineno, line)
+            state = states[z]
+            assert y == len(state), (lineno, line)
+            lineno, line = lineno + 1, next(f)
+            mo = re.match(r'\s+("(?:\\\d\d\d)*")},$', line)
+            assert mo, (lineno, line)
+            first = {}
+            rawbitset = eval(mo.group(1))
+            for i, c in enumerate(rawbitset):
+                byte = ord(c)
+                for j in range(8):
+                    if byte & (1 << j):
+                        first[i * 8 + j] = 1
+            dfas[number] = (state, first)
+        lineno, line = lineno + 1, next(f)
+        assert line == "};\n", (lineno, line)
+        self.dfas = dfas
+
+        # Parse the labels
+        labels = []
+        lineno, line = lineno + 1, next(f)
+        mo = re.match(r"static label labels\[(\d+)\] = {$", line)
+        assert mo, (lineno, line)
+        nlabels = int(mo.group(1))
+        for i in range(nlabels):
+            lineno, line = lineno + 1, next(f)
+            mo = re.match(r'\s+{(\d+), (0|"\w+")},$', line)
+            assert mo, (lineno, line)
+            x, y = mo.groups()
+            x = int(x)
+            if y == "0":
+                y = None
+            else:
+                y = eval(y)
+            labels.append((x, y))
+        lineno, line = lineno + 1, next(f)
+        assert line == "};\n", (lineno, line)
+        self.labels = labels
+
+        # Parse the grammar struct
+        lineno, line = lineno + 1, next(f)
+        assert line == "grammar _PyParser_Grammar = {\n", (lineno, line)
+        lineno, line = lineno + 1, next(f)
+        mo = re.match(r"\s+(\d+),$", line)
+        assert mo, (lineno, line)
+        ndfas = int(mo.group(1))
+        assert ndfas == len(self.dfas)
+        lineno, line = lineno + 1, next(f)
+        assert line == "\tdfas,\n", (lineno, line)
+        lineno, line = lineno + 1, next(f)
+        mo = re.match(r"\s+{(\d+), labels},$", line)
+        assert mo, (lineno, line)
+        nlabels = int(mo.group(1))
+        assert nlabels == len(self.labels), (lineno, line)
+        lineno, line = lineno + 1, next(f)
+        mo = re.match(r"\s+(\d+)$", line)
+        assert mo, (lineno, line)
+        start = int(mo.group(1))
+        assert start in self.number2symbol, (lineno, line)
+        self.start = start
+        lineno, line = lineno + 1, next(f)
+        assert line == "};\n", (lineno, line)
+        try:
+            lineno, line = lineno + 1, next(f)
+        except StopIteration:
+            pass
+        else:
+            assert 0, (lineno, line)
+
+    def finish_off(self):
+        """Create additional useful structures.  (Internal)."""
+        self.keywords = {}  # map from keyword strings to arc labels
+        self.tokens = {}  # map from numeric token values to arc labels
+        for ilabel, (type, value) in enumerate(self.labels):
+            if type == token.NAME and value is not None:
+                self.keywords[value] = ilabel
+            elif value is None:
+                self.tokens[type] = ilabel
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/pgen2/driver.py b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/driver.py
new file mode 100644
index 0000000..8fe8206
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/driver.py
@@ -0,0 +1,327 @@
+# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+# Modifications:
+# Copyright 2006 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Parser driver.
+
+This provides a high-level interface to parse a file into a syntax tree.
+
+"""
+
+__author__ = "Guido van Rossum <guido@python.org>"
+
+__all__ = ["Driver", "load_grammar"]
+
+# Python imports
+import io
+import os
+import logging
+import pkgutil
+import sys
+from typing import (
+    Any,
+    cast,
+    IO,
+    Iterable,
+    List,
+    Optional,
+    Text,
+    Iterator,
+    Tuple,
+    TypeVar,
+    Generic,
+    Union,
+)
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+
+# Pgen imports
+from . import grammar, parse, token, tokenize, pgen
+from logging import Logger
+from blib2to3.pytree import NL
+from blib2to3.pgen2.grammar import Grammar
+from blib2to3.pgen2.tokenize import GoodTokenInfo
+
+Path = Union[str, "os.PathLike[str]"]
+
+
+@dataclass
+class ReleaseRange:
+    start: int
+    end: Optional[int] = None
+    tokens: List[Any] = field(default_factory=list)
+
+    def lock(self) -> None:
+        total_eaten = len(self.tokens)
+        self.end = self.start + total_eaten
+
+
+class TokenProxy:
+    def __init__(self, generator: Any) -> None:
+        self._tokens = generator
+        self._counter = 0
+        self._release_ranges: List[ReleaseRange] = []
+
+    @contextmanager
+    def release(self) -> Iterator["TokenProxy"]:
+        release_range = ReleaseRange(self._counter)
+        self._release_ranges.append(release_range)
+        try:
+            yield self
+        finally:
+            # Lock the last release range to the final position that
+            # has been eaten.
+            release_range.lock()
+
+    def eat(self, point: int) -> Any:
+        eaten_tokens = self._release_ranges[-1].tokens
+        if point < len(eaten_tokens):
+            return eaten_tokens[point]
+        else:
+            while point >= len(eaten_tokens):
+                token = next(self._tokens)
+                eaten_tokens.append(token)
+            return token
+
+    def __iter__(self) -> "TokenProxy":
+        return self
+
+    def __next__(self) -> Any:
+        # If the current position is already compromised (looked up)
+        # return the eaten token, if not just go further on the given
+        # token producer.
+        for release_range in self._release_ranges:
+            assert release_range.end is not None
+
+            start, end = release_range.start, release_range.end
+            if start <= self._counter < end:
+                token = release_range.tokens[self._counter - start]
+                break
+        else:
+            token = next(self._tokens)
+        self._counter += 1
+        return token
+
+    def can_advance(self, to: int) -> bool:
+        # Try to eat, fail if it can't. The eat operation is cached
+        # so there wont be any additional cost of eating here
+        try:
+            self.eat(to)
+        except StopIteration:
+            return False
+        else:
+            return True
+
+
+class Driver(object):
+    def __init__(self, grammar: Grammar, logger: Optional[Logger] = None) -> None:
+        self.grammar = grammar
+        if logger is None:
+            logger = logging.getLogger(__name__)
+        self.logger = logger
+
+    def parse_tokens(self, tokens: Iterable[GoodTokenInfo], debug: bool = False) -> NL:
+        """Parse a series of tokens and return the syntax tree."""
+        # XXX Move the prefix computation into a wrapper around tokenize.
+        proxy = TokenProxy(tokens)
+
+        p = parse.Parser(self.grammar)
+        p.setup(proxy=proxy)
+
+        lineno = 1
+        column = 0
+        indent_columns: List[int] = []
+        type = value = start = end = line_text = None
+        prefix = ""
+
+        for quintuple in proxy:
+            type, value, start, end, line_text = quintuple
+            if start != (lineno, column):
+                assert (lineno, column) <= start, ((lineno, column), start)
+                s_lineno, s_column = start
+                if lineno < s_lineno:
+                    prefix += "\n" * (s_lineno - lineno)
+                    lineno = s_lineno
+                    column = 0
+                if column < s_column:
+                    prefix += line_text[column:s_column]
+                    column = s_column
+            if type in (tokenize.COMMENT, tokenize.NL):
+                prefix += value
+                lineno, column = end
+                if value.endswith("\n"):
+                    lineno += 1
+                    column = 0
+                continue
+            if type == token.OP:
+                type = grammar.opmap[value]
+            if debug:
+                assert type is not None
+                self.logger.debug(
+                    "%s %r (prefix=%r)", token.tok_name[type], value, prefix
+                )
+            if type == token.INDENT:
+                indent_columns.append(len(value))
+                _prefix = prefix + value
+                prefix = ""
+                value = ""
+            elif type == token.DEDENT:
+                _indent_col = indent_columns.pop()
+                prefix, _prefix = self._partially_consume_prefix(prefix, _indent_col)
+            if p.addtoken(cast(int, type), value, (prefix, start)):
+                if debug:
+                    self.logger.debug("Stop.")
+                break
+            prefix = ""
+            if type in {token.INDENT, token.DEDENT}:
+                prefix = _prefix
+            lineno, column = end
+            if value.endswith("\n"):
+                lineno += 1
+                column = 0
+        else:
+            # We never broke out -- EOF is too soon (how can this happen???)
+            assert start is not None
+            raise parse.ParseError("incomplete input", type, value, (prefix, start))
+        assert p.rootnode is not None
+        return p.rootnode
+
+    def parse_stream_raw(self, stream: IO[Text], debug: bool = False) -> NL:
+        """Parse a stream and return the syntax tree."""
+        tokens = tokenize.generate_tokens(stream.readline, grammar=self.grammar)
+        return self.parse_tokens(tokens, debug)
+
+    def parse_stream(self, stream: IO[Text], debug: bool = False) -> NL:
+        """Parse a stream and return the syntax tree."""
+        return self.parse_stream_raw(stream, debug)
+
+    def parse_file(
+        self, filename: Path, encoding: Optional[Text] = None, debug: bool = False
+    ) -> NL:
+        """Parse a file and return the syntax tree."""
+        with io.open(filename, "r", encoding=encoding) as stream:
+            return self.parse_stream(stream, debug)
+
+    def parse_string(self, text: Text, debug: bool = False) -> NL:
+        """Parse a string and return the syntax tree."""
+        tokens = tokenize.generate_tokens(
+            io.StringIO(text).readline, grammar=self.grammar
+        )
+        return self.parse_tokens(tokens, debug)
+
+    def _partially_consume_prefix(self, prefix: Text, column: int) -> Tuple[Text, Text]:
+        lines: List[str] = []
+        current_line = ""
+        current_column = 0
+        wait_for_nl = False
+        for char in prefix:
+            current_line += char
+            if wait_for_nl:
+                if char == "\n":
+                    if current_line.strip() and current_column < column:
+                        res = "".join(lines)
+                        return res, prefix[len(res) :]
+
+                    lines.append(current_line)
+                    current_line = ""
+                    current_column = 0
+                    wait_for_nl = False
+            elif char in " \t":
+                current_column += 1
+            elif char == "\n":
+                # unexpected empty line
+                current_column = 0
+            else:
+                # indent is finished
+                wait_for_nl = True
+        return "".join(lines), current_line
+
+
+def _generate_pickle_name(gt: Path, cache_dir: Optional[Path] = None) -> Text:
+    head, tail = os.path.splitext(gt)
+    if tail == ".txt":
+        tail = ""
+    name = head + tail + ".".join(map(str, sys.version_info)) + ".pickle"
+    if cache_dir:
+        return os.path.join(cache_dir, os.path.basename(name))
+    else:
+        return name
+
+
+def load_grammar(
+    gt: Text = "Grammar.txt",
+    gp: Optional[Text] = None,
+    save: bool = True,
+    force: bool = False,
+    logger: Optional[Logger] = None,
+) -> Grammar:
+    """Load the grammar (maybe from a pickle)."""
+    if logger is None:
+        logger = logging.getLogger(__name__)
+    gp = _generate_pickle_name(gt) if gp is None else gp
+    if force or not _newer(gp, gt):
+        logger.info("Generating grammar tables from %s", gt)
+        g: grammar.Grammar = pgen.generate_grammar(gt)
+        if save:
+            logger.info("Writing grammar tables to %s", gp)
+            try:
+                g.dump(gp)
+            except OSError as e:
+                logger.info("Writing failed: %s", e)
+    else:
+        g = grammar.Grammar()
+        g.load(gp)
+    return g
+
+
+def _newer(a: Text, b: Text) -> bool:
+    """Inquire whether file a was written since file b."""
+    if not os.path.exists(a):
+        return False
+    if not os.path.exists(b):
+        return True
+    return os.path.getmtime(a) >= os.path.getmtime(b)
+
+
+def load_packaged_grammar(
+    package: str, grammar_source: Text, cache_dir: Optional[Path] = None
+) -> grammar.Grammar:
+    """Normally, loads a pickled grammar by doing
+        pkgutil.get_data(package, pickled_grammar)
+    where *pickled_grammar* is computed from *grammar_source* by adding the
+    Python version and using a ``.pickle`` extension.
+
+    However, if *grammar_source* is an extant file, load_grammar(grammar_source)
+    is called instead. This facilitates using a packaged grammar file when needed
+    but preserves load_grammar's automatic regeneration behavior when possible.
+
+    """
+    if os.path.isfile(grammar_source):
+        gp = _generate_pickle_name(grammar_source, cache_dir) if cache_dir else None
+        return load_grammar(grammar_source, gp=gp)
+    pickled_name = _generate_pickle_name(os.path.basename(grammar_source), cache_dir)
+    data = pkgutil.get_data(package, pickled_name)
+    assert data is not None
+    g = grammar.Grammar()
+    g.loads(data)
+    return g
+
+
+def main(*args: Text) -> bool:
+    """Main program, when run as a script: produce grammar pickle files.
+
+    Calls load_grammar for each argument, a path to a grammar text file.
+    """
+    if not args:
+        args = tuple(sys.argv[1:])
+    logging.basicConfig(level=logging.INFO, stream=sys.stdout, format="%(message)s")
+    for gt in args:
+        load_grammar(gt, save=True, force=True)
+    return True
+
+
+if __name__ == "__main__":
+    sys.exit(int(not main()))
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/pgen2/grammar.py b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/grammar.py
new file mode 100644
index 0000000..5685107
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/grammar.py
@@ -0,0 +1,225 @@
+# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""This module defines the data structures used to represent a grammar.
+
+These are a bit arcane because they are derived from the data
+structures used by Python's 'pgen' parser generator.
+
+There's also a table here mapping operators to their names in the
+token module; the Python tokenize module reports all operators as the
+fallback token code OP, but the parser needs the actual token code.
+
+"""
+
+# Python imports
+import os
+import pickle
+import tempfile
+from typing import Any, Dict, List, Optional, Text, Tuple, TypeVar, Union
+
+# Local imports
+from . import token
+
+_P = TypeVar("_P", bound="Grammar")
+Label = Tuple[int, Optional[Text]]
+DFA = List[List[Tuple[int, int]]]
+DFAS = Tuple[DFA, Dict[int, int]]
+Path = Union[str, "os.PathLike[str]"]
+
+
+class Grammar(object):
+    """Pgen parsing tables conversion class.
+
+    Once initialized, this class supplies the grammar tables for the
+    parsing engine implemented by parse.py.  The parsing engine
+    accesses the instance variables directly.  The class here does not
+    provide initialization of the tables; several subclasses exist to
+    do this (see the conv and pgen modules).
+
+    The load() method reads the tables from a pickle file, which is
+    much faster than the other ways offered by subclasses.  The pickle
+    file is written by calling dump() (after loading the grammar
+    tables using a subclass).  The report() method prints a readable
+    representation of the tables to stdout, for debugging.
+
+    The instance variables are as follows:
+
+    symbol2number -- a dict mapping symbol names to numbers.  Symbol
+                     numbers are always 256 or higher, to distinguish
+                     them from token numbers, which are between 0 and
+                     255 (inclusive).
+
+    number2symbol -- a dict mapping numbers to symbol names;
+                     these two are each other's inverse.
+
+    states        -- a list of DFAs, where each DFA is a list of
+                     states, each state is a list of arcs, and each
+                     arc is a (i, j) pair where i is a label and j is
+                     a state number.  The DFA number is the index into
+                     this list.  (This name is slightly confusing.)
+                     Final states are represented by a special arc of
+                     the form (0, j) where j is its own state number.
+
+    dfas          -- a dict mapping symbol numbers to (DFA, first)
+                     pairs, where DFA is an item from the states list
+                     above, and first is a set of tokens that can
+                     begin this grammar rule (represented by a dict
+                     whose values are always 1).
+
+    labels        -- a list of (x, y) pairs where x is either a token
+                     number or a symbol number, and y is either None
+                     or a string; the strings are keywords.  The label
+                     number is the index in this list; label numbers
+                     are used to mark state transitions (arcs) in the
+                     DFAs.
+
+    start         -- the number of the grammar's start symbol.
+
+    keywords      -- a dict mapping keyword strings to arc labels.
+
+    tokens        -- a dict mapping token numbers to arc labels.
+
+    """
+
+    def __init__(self) -> None:
+        self.symbol2number: Dict[str, int] = {}
+        self.number2symbol: Dict[int, str] = {}
+        self.states: List[DFA] = []
+        self.dfas: Dict[int, DFAS] = {}
+        self.labels: List[Label] = [(0, "EMPTY")]
+        self.keywords: Dict[str, int] = {}
+        self.soft_keywords: Dict[str, int] = {}
+        self.tokens: Dict[int, int] = {}
+        self.symbol2label: Dict[str, int] = {}
+        self.start = 256
+        # Python 3.7+ parses async as a keyword, not an identifier
+        self.async_keywords = False
+
+    def dump(self, filename: Path) -> None:
+        """Dump the grammar tables to a pickle file."""
+
+        # mypyc generates objects that don't have a __dict__, but they
+        # do have __getstate__ methods that will return an equivalent
+        # dictionary
+        if hasattr(self, "__dict__"):
+            d = self.__dict__
+        else:
+            d = self.__getstate__()  # type: ignore
+
+        with tempfile.NamedTemporaryFile(
+            dir=os.path.dirname(filename), delete=False
+        ) as f:
+            pickle.dump(d, f, pickle.HIGHEST_PROTOCOL)
+        os.replace(f.name, filename)
+
+    def _update(self, attrs: Dict[str, Any]) -> None:
+        for k, v in attrs.items():
+            setattr(self, k, v)
+
+    def load(self, filename: Path) -> None:
+        """Load the grammar tables from a pickle file."""
+        with open(filename, "rb") as f:
+            d = pickle.load(f)
+        self._update(d)
+
+    def loads(self, pkl: bytes) -> None:
+        """Load the grammar tables from a pickle bytes object."""
+        self._update(pickle.loads(pkl))
+
+    def copy(self: _P) -> _P:
+        """
+        Copy the grammar.
+        """
+        new = self.__class__()
+        for dict_attr in (
+            "symbol2number",
+            "number2symbol",
+            "dfas",
+            "keywords",
+            "soft_keywords",
+            "tokens",
+            "symbol2label",
+        ):
+            setattr(new, dict_attr, getattr(self, dict_attr).copy())
+        new.labels = self.labels[:]
+        new.states = self.states[:]
+        new.start = self.start
+        new.async_keywords = self.async_keywords
+        return new
+
+    def report(self) -> None:
+        """Dump the grammar tables to standard output, for debugging."""
+        from pprint import pprint
+
+        print("s2n")
+        pprint(self.symbol2number)
+        print("n2s")
+        pprint(self.number2symbol)
+        print("states")
+        pprint(self.states)
+        print("dfas")
+        pprint(self.dfas)
+        print("labels")
+        pprint(self.labels)
+        print("start", self.start)
+
+
+# Map from operator to number (since tokenize doesn't do this)
+
+opmap_raw = """
+( LPAR
+) RPAR
+[ LSQB
+] RSQB
+: COLON
+, COMMA
+; SEMI
++ PLUS
+- MINUS
+* STAR
+/ SLASH
+| VBAR
+& AMPER
+< LESS
+> GREATER
+= EQUAL
+. DOT
+% PERCENT
+` BACKQUOTE
+{ LBRACE
+} RBRACE
+@ AT
+@= ATEQUAL
+== EQEQUAL
+!= NOTEQUAL
+<> NOTEQUAL
+<= LESSEQUAL
+>= GREATEREQUAL
+~ TILDE
+^ CIRCUMFLEX
+<< LEFTSHIFT
+>> RIGHTSHIFT
+** DOUBLESTAR
++= PLUSEQUAL
+-= MINEQUAL
+*= STAREQUAL
+/= SLASHEQUAL
+%= PERCENTEQUAL
+&= AMPEREQUAL
+|= VBAREQUAL
+^= CIRCUMFLEXEQUAL
+<<= LEFTSHIFTEQUAL
+>>= RIGHTSHIFTEQUAL
+**= DOUBLESTAREQUAL
+// DOUBLESLASH
+//= DOUBLESLASHEQUAL
+-> RARROW
+:= COLONEQUAL
+"""
+
+opmap = {}
+for line in opmap_raw.splitlines():
+    if line:
+        op, name = line.split()
+        opmap[op] = getattr(token, name)
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/pgen2/literals.py b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/literals.py
new file mode 100644
index 0000000..b5fe428
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/literals.py
@@ -0,0 +1,68 @@
+# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Safely evaluate Python string literals without using eval()."""
+
+import re
+
+from typing import Dict, Match, Text
+
+
+simple_escapes: Dict[Text, Text] = {
+    "a": "\a",
+    "b": "\b",
+    "f": "\f",
+    "n": "\n",
+    "r": "\r",
+    "t": "\t",
+    "v": "\v",
+    "'": "'",
+    '"': '"',
+    "\\": "\\",
+}
+
+
+def escape(m: Match[Text]) -> Text:
+    all, tail = m.group(0, 1)
+    assert all.startswith("\\")
+    esc = simple_escapes.get(tail)
+    if esc is not None:
+        return esc
+    if tail.startswith("x"):
+        hexes = tail[1:]
+        if len(hexes) < 2:
+            raise ValueError("invalid hex string escape ('\\%s')" % tail)
+        try:
+            i = int(hexes, 16)
+        except ValueError:
+            raise ValueError("invalid hex string escape ('\\%s')" % tail) from None
+    else:
+        try:
+            i = int(tail, 8)
+        except ValueError:
+            raise ValueError("invalid octal string escape ('\\%s')" % tail) from None
+    return chr(i)
+
+
+def evalString(s: Text) -> Text:
+    assert s.startswith("'") or s.startswith('"'), repr(s[:1])
+    q = s[0]
+    if s[:3] == q * 3:
+        q = q * 3
+    assert s.endswith(q), repr(s[-len(q) :])
+    assert len(s) >= 2 * len(q)
+    s = s[len(q) : -len(q)]
+    return re.sub(r"\\(\'|\"|\\|[abfnrtv]|x.{0,2}|[0-7]{1,3})", escape, s)
+
+
+def test() -> None:
+    for i in range(256):
+        c = chr(i)
+        s = repr(c)
+        e = evalString(s)
+        if e != c:
+            print(i, c, s, e)
+
+
+if __name__ == "__main__":
+    test()
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/pgen2/parse.py b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/parse.py
new file mode 100644
index 0000000..e5dad3a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/parse.py
@@ -0,0 +1,346 @@
+# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Parser engine for the grammar tables generated by pgen.
+
+The grammar table must be loaded first.
+
+See Parser/parser.c in the Python distribution for additional info on
+how this parsing engine works.
+
+"""
+import copy
+from contextlib import contextmanager
+
+# Local imports
+from . import grammar, token, tokenize
+from typing import (
+    cast,
+    Any,
+    Optional,
+    Text,
+    Union,
+    Tuple,
+    Dict,
+    List,
+    Iterator,
+    Callable,
+    Set,
+    TYPE_CHECKING,
+)
+from blib2to3.pgen2.grammar import Grammar
+from blib2to3.pytree import convert, NL, Context, RawNode, Leaf, Node
+
+if TYPE_CHECKING:
+    from blib2to3.driver import TokenProxy
+
+
+Results = Dict[Text, NL]
+Convert = Callable[[Grammar, RawNode], Union[Node, Leaf]]
+DFA = List[List[Tuple[int, int]]]
+DFAS = Tuple[DFA, Dict[int, int]]
+
+
+def lam_sub(grammar: Grammar, node: RawNode) -> NL:
+    assert node[3] is not None
+    return Node(type=node[0], children=node[3], context=node[2])
+
+
+class Recorder:
+    def __init__(self, parser: "Parser", ilabels: List[int], context: Context) -> None:
+        self.parser = parser
+        self._ilabels = ilabels
+        self.context = context  # not really matter
+
+        self._dead_ilabels: Set[int] = set()
+        self._start_point = self.parser.stack
+        self._points = {ilabel: copy.deepcopy(self._start_point) for ilabel in ilabels}
+
+    @property
+    def ilabels(self) -> Set[int]:
+        return self._dead_ilabels.symmetric_difference(self._ilabels)
+
+    @contextmanager
+    def switch_to(self, ilabel: int) -> Iterator[None]:
+        self.parser.stack = self._points[ilabel]
+        try:
+            yield
+        except ParseError:
+            self._dead_ilabels.add(ilabel)
+        finally:
+            self.parser.stack = self._start_point
+
+    def add_token(self, tok_type: int, tok_val: Text, raw: bool = False) -> None:
+        func: Callable[..., Any]
+        if raw:
+            func = self.parser._addtoken
+        else:
+            func = self.parser.addtoken
+
+        for ilabel in self.ilabels:
+            with self.switch_to(ilabel):
+                args = [tok_type, tok_val, self.context]
+                if raw:
+                    args.insert(0, ilabel)
+                func(*args)
+
+    def determine_route(self, value: Text = None, force: bool = False) -> Optional[int]:
+        alive_ilabels = self.ilabels
+        if len(alive_ilabels) == 0:
+            *_, most_successful_ilabel = self._dead_ilabels
+            raise ParseError("bad input", most_successful_ilabel, value, self.context)
+
+        ilabel, *rest = alive_ilabels
+        if force or not rest:
+            return ilabel
+        else:
+            return None
+
+
+class ParseError(Exception):
+    """Exception to signal the parser is stuck."""
+
+    def __init__(
+        self, msg: Text, type: Optional[int], value: Optional[Text], context: Context
+    ) -> None:
+        Exception.__init__(
+            self, "%s: type=%r, value=%r, context=%r" % (msg, type, value, context)
+        )
+        self.msg = msg
+        self.type = type
+        self.value = value
+        self.context = context
+
+
+class Parser(object):
+    """Parser engine.
+
+    The proper usage sequence is:
+
+    p = Parser(grammar, [converter])  # create instance
+    p.setup([start])                  # prepare for parsing
+    <for each input token>:
+        if p.addtoken(...):           # parse a token; may raise ParseError
+            break
+    root = p.rootnode                 # root of abstract syntax tree
+
+    A Parser instance may be reused by calling setup() repeatedly.
+
+    A Parser instance contains state pertaining to the current token
+    sequence, and should not be used concurrently by different threads
+    to parse separate token sequences.
+
+    See driver.py for how to get input tokens by tokenizing a file or
+    string.
+
+    Parsing is complete when addtoken() returns True; the root of the
+    abstract syntax tree can then be retrieved from the rootnode
+    instance variable.  When a syntax error occurs, addtoken() raises
+    the ParseError exception.  There is no error recovery; the parser
+    cannot be used after a syntax error was reported (but it can be
+    reinitialized by calling setup()).
+
+    """
+
+    def __init__(self, grammar: Grammar, convert: Optional[Convert] = None) -> None:
+        """Constructor.
+
+        The grammar argument is a grammar.Grammar instance; see the
+        grammar module for more information.
+
+        The parser is not ready yet for parsing; you must call the
+        setup() method to get it started.
+
+        The optional convert argument is a function mapping concrete
+        syntax tree nodes to abstract syntax tree nodes.  If not
+        given, no conversion is done and the syntax tree produced is
+        the concrete syntax tree.  If given, it must be a function of
+        two arguments, the first being the grammar (a grammar.Grammar
+        instance), and the second being the concrete syntax tree node
+        to be converted.  The syntax tree is converted from the bottom
+        up.
+
+        **post-note: the convert argument is ignored since for Black's
+        usage, convert will always be blib2to3.pytree.convert. Allowing
+        this to be dynamic hurts mypyc's ability to use early binding.
+        These docs are left for historical and informational value.
+
+        A concrete syntax tree node is a (type, value, context, nodes)
+        tuple, where type is the node type (a token or symbol number),
+        value is None for symbols and a string for tokens, context is
+        None or an opaque value used for error reporting (typically a
+        (lineno, offset) pair), and nodes is a list of children for
+        symbols, and None for tokens.
+
+        An abstract syntax tree node may be anything; this is entirely
+        up to the converter function.
+
+        """
+        self.grammar = grammar
+        # See note in docstring above. TL;DR this is ignored.
+        self.convert = convert or lam_sub
+
+    def setup(self, proxy: "TokenProxy", start: Optional[int] = None) -> None:
+        """Prepare for parsing.
+
+        This *must* be called before starting to parse.
+
+        The optional argument is an alternative start symbol; it
+        defaults to the grammar's start symbol.
+
+        You can use a Parser instance to parse any number of programs;
+        each time you call setup() the parser is reset to an initial
+        state determined by the (implicit or explicit) start symbol.
+
+        """
+        if start is None:
+            start = self.grammar.start
+        # Each stack entry is a tuple: (dfa, state, node).
+        # A node is a tuple: (type, value, context, children),
+        # where children is a list of nodes or None, and context may be None.
+        newnode: RawNode = (start, None, None, [])
+        stackentry = (self.grammar.dfas[start], 0, newnode)
+        self.stack: List[Tuple[DFAS, int, RawNode]] = [stackentry]
+        self.rootnode: Optional[NL] = None
+        self.used_names: Set[str] = set()
+        self.proxy = proxy
+
+    def addtoken(self, type: int, value: Text, context: Context) -> bool:
+        """Add a token; return True iff this is the end of the program."""
+        # Map from token to label
+        ilabels = self.classify(type, value, context)
+        assert len(ilabels) >= 1
+
+        # If we have only one state to advance, we'll directly
+        # take it as is.
+        if len(ilabels) == 1:
+            [ilabel] = ilabels
+            return self._addtoken(ilabel, type, value, context)
+
+        # If there are multiple states which we can advance (only
+        # happen under soft-keywords), then we will try all of them
+        # in parallel and as soon as one state can reach further than
+        # the rest, we'll choose that one. This is a pretty hacky
+        # and hopefully temporary algorithm.
+        #
+        # For a more detailed explanation, check out this post:
+        # https://tree.science/what-the-backtracking.html
+
+        with self.proxy.release() as proxy:
+            counter, force = 0, False
+            recorder = Recorder(self, ilabels, context)
+            recorder.add_token(type, value, raw=True)
+
+            next_token_value = value
+            while recorder.determine_route(next_token_value) is None:
+                if not proxy.can_advance(counter):
+                    force = True
+                    break
+
+                next_token_type, next_token_value, *_ = proxy.eat(counter)
+                if next_token_type == tokenize.OP:
+                    next_token_type = grammar.opmap[next_token_value]
+
+                recorder.add_token(next_token_type, next_token_value)
+                counter += 1
+
+            ilabel = cast(int, recorder.determine_route(next_token_value, force=force))
+            assert ilabel is not None
+
+        return self._addtoken(ilabel, type, value, context)
+
+    def _addtoken(self, ilabel: int, type: int, value: Text, context: Context) -> bool:
+        # Loop until the token is shifted; may raise exceptions
+        while True:
+            dfa, state, node = self.stack[-1]
+            states, first = dfa
+            arcs = states[state]
+            # Look for a state with this label
+            for i, newstate in arcs:
+                t = self.grammar.labels[i][0]
+                if t >= 256:
+                    # See if it's a symbol and if we're in its first set
+                    itsdfa = self.grammar.dfas[t]
+                    itsstates, itsfirst = itsdfa
+                    if ilabel in itsfirst:
+                        # Push a symbol
+                        self.push(t, itsdfa, newstate, context)
+                        break  # To continue the outer while loop
+
+                elif ilabel == i:
+                    # Look it up in the list of labels
+                    # Shift a token; we're done with it
+                    self.shift(type, value, newstate, context)
+                    # Pop while we are in an accept-only state
+                    state = newstate
+                    while states[state] == [(0, state)]:
+                        self.pop()
+                        if not self.stack:
+                            # Done parsing!
+                            return True
+                        dfa, state, node = self.stack[-1]
+                        states, first = dfa
+                    # Done with this token
+                    return False
+
+            else:
+                if (0, state) in arcs:
+                    # An accepting state, pop it and try something else
+                    self.pop()
+                    if not self.stack:
+                        # Done parsing, but another token is input
+                        raise ParseError("too much input", type, value, context)
+                else:
+                    # No success finding a transition
+                    raise ParseError("bad input", type, value, context)
+
+    def classify(self, type: int, value: Text, context: Context) -> List[int]:
+        """Turn a token into a label.  (Internal)
+
+        Depending on whether the value is a soft-keyword or not,
+        this function may return multiple labels to choose from."""
+        if type == token.NAME:
+            # Keep a listing of all used names
+            self.used_names.add(value)
+            # Check for reserved words
+            if value in self.grammar.keywords:
+                return [self.grammar.keywords[value]]
+            elif value in self.grammar.soft_keywords:
+                assert type in self.grammar.tokens
+                return [
+                    self.grammar.soft_keywords[value],
+                    self.grammar.tokens[type],
+                ]
+
+        ilabel = self.grammar.tokens.get(type)
+        if ilabel is None:
+            raise ParseError("bad token", type, value, context)
+        return [ilabel]
+
+    def shift(self, type: int, value: Text, newstate: int, context: Context) -> None:
+        """Shift a token.  (Internal)"""
+        dfa, state, node = self.stack[-1]
+        rawnode: RawNode = (type, value, context, None)
+        newnode = convert(self.grammar, rawnode)
+        assert node[-1] is not None
+        node[-1].append(newnode)
+        self.stack[-1] = (dfa, newstate, node)
+
+    def push(self, type: int, newdfa: DFAS, newstate: int, context: Context) -> None:
+        """Push a nonterminal.  (Internal)"""
+        dfa, state, node = self.stack[-1]
+        newnode: RawNode = (type, None, context, [])
+        self.stack[-1] = (dfa, newstate, node)
+        self.stack.append((newdfa, 0, newnode))
+
+    def pop(self) -> None:
+        """Pop a nonterminal.  (Internal)"""
+        popdfa, popstate, popnode = self.stack.pop()
+        newnode = convert(self.grammar, popnode)
+        if self.stack:
+            dfa, state, node = self.stack[-1]
+            assert node[-1] is not None
+            node[-1].append(newnode)
+        else:
+            self.rootnode = newnode
+            self.rootnode.used_names = self.used_names
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/pgen2/pgen.py b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/pgen.py
new file mode 100644
index 0000000..631682a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/pgen.py
@@ -0,0 +1,433 @@
+# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+# Pgen imports
+from . import grammar, token, tokenize
+
+from typing import (
+    Any,
+    Dict,
+    IO,
+    Iterator,
+    List,
+    Optional,
+    Text,
+    Tuple,
+    Union,
+    Sequence,
+    NoReturn,
+)
+from blib2to3.pgen2 import grammar
+from blib2to3.pgen2.tokenize import GoodTokenInfo
+import os
+
+
+Path = Union[str, "os.PathLike[str]"]
+
+
+class PgenGrammar(grammar.Grammar):
+    pass
+
+
+class ParserGenerator(object):
+
+    filename: Path
+    stream: IO[Text]
+    generator: Iterator[GoodTokenInfo]
+    first: Dict[Text, Optional[Dict[Text, int]]]
+
+    def __init__(self, filename: Path, stream: Optional[IO[Text]] = None) -> None:
+        close_stream = None
+        if stream is None:
+            stream = open(filename)
+            close_stream = stream.close
+        self.filename = filename
+        self.stream = stream
+        self.generator = tokenize.generate_tokens(stream.readline)
+        self.gettoken()  # Initialize lookahead
+        self.dfas, self.startsymbol = self.parse()
+        if close_stream is not None:
+            close_stream()
+        self.first = {}  # map from symbol name to set of tokens
+        self.addfirstsets()
+
+    def make_grammar(self) -> PgenGrammar:
+        c = PgenGrammar()
+        names = list(self.dfas.keys())
+        names.sort()
+        names.remove(self.startsymbol)
+        names.insert(0, self.startsymbol)
+        for name in names:
+            i = 256 + len(c.symbol2number)
+            c.symbol2number[name] = i
+            c.number2symbol[i] = name
+        for name in names:
+            dfa = self.dfas[name]
+            states = []
+            for state in dfa:
+                arcs = []
+                for label, next in sorted(state.arcs.items()):
+                    arcs.append((self.make_label(c, label), dfa.index(next)))
+                if state.isfinal:
+                    arcs.append((0, dfa.index(state)))
+                states.append(arcs)
+            c.states.append(states)
+            c.dfas[c.symbol2number[name]] = (states, self.make_first(c, name))
+        c.start = c.symbol2number[self.startsymbol]
+        return c
+
+    def make_first(self, c: PgenGrammar, name: Text) -> Dict[int, int]:
+        rawfirst = self.first[name]
+        assert rawfirst is not None
+        first = {}
+        for label in sorted(rawfirst):
+            ilabel = self.make_label(c, label)
+            ##assert ilabel not in first # XXX failed on <> ... !=
+            first[ilabel] = 1
+        return first
+
+    def make_label(self, c: PgenGrammar, label: Text) -> int:
+        # XXX Maybe this should be a method on a subclass of converter?
+        ilabel = len(c.labels)
+        if label[0].isalpha():
+            # Either a symbol name or a named token
+            if label in c.symbol2number:
+                # A symbol name (a non-terminal)
+                if label in c.symbol2label:
+                    return c.symbol2label[label]
+                else:
+                    c.labels.append((c.symbol2number[label], None))
+                    c.symbol2label[label] = ilabel
+                    return ilabel
+            else:
+                # A named token (NAME, NUMBER, STRING)
+                itoken = getattr(token, label, None)
+                assert isinstance(itoken, int), label
+                assert itoken in token.tok_name, label
+                if itoken in c.tokens:
+                    return c.tokens[itoken]
+                else:
+                    c.labels.append((itoken, None))
+                    c.tokens[itoken] = ilabel
+                    return ilabel
+        else:
+            # Either a keyword or an operator
+            assert label[0] in ('"', "'"), label
+            value = eval(label)
+            if value[0].isalpha():
+                if label[0] == '"':
+                    keywords = c.soft_keywords
+                else:
+                    keywords = c.keywords
+
+                # A keyword
+                if value in keywords:
+                    return keywords[value]
+                else:
+                    c.labels.append((token.NAME, value))
+                    keywords[value] = ilabel
+                    return ilabel
+            else:
+                # An operator (any non-numeric token)
+                itoken = grammar.opmap[value]  # Fails if unknown token
+                if itoken in c.tokens:
+                    return c.tokens[itoken]
+                else:
+                    c.labels.append((itoken, None))
+                    c.tokens[itoken] = ilabel
+                    return ilabel
+
+    def addfirstsets(self) -> None:
+        names = list(self.dfas.keys())
+        names.sort()
+        for name in names:
+            if name not in self.first:
+                self.calcfirst(name)
+            # print name, self.first[name].keys()
+
+    def calcfirst(self, name: Text) -> None:
+        dfa = self.dfas[name]
+        self.first[name] = None  # dummy to detect left recursion
+        state = dfa[0]
+        totalset: Dict[str, int] = {}
+        overlapcheck = {}
+        for label, next in state.arcs.items():
+            if label in self.dfas:
+                if label in self.first:
+                    fset = self.first[label]
+                    if fset is None:
+                        raise ValueError("recursion for rule %r" % name)
+                else:
+                    self.calcfirst(label)
+                    fset = self.first[label]
+                    assert fset is not None
+                totalset.update(fset)
+                overlapcheck[label] = fset
+            else:
+                totalset[label] = 1
+                overlapcheck[label] = {label: 1}
+        inverse: Dict[str, str] = {}
+        for label, itsfirst in overlapcheck.items():
+            for symbol in itsfirst:
+                if symbol in inverse:
+                    raise ValueError(
+                        "rule %s is ambiguous; %s is in the first sets of %s as well"
+                        " as %s" % (name, symbol, label, inverse[symbol])
+                    )
+                inverse[symbol] = label
+        self.first[name] = totalset
+
+    def parse(self) -> Tuple[Dict[Text, List["DFAState"]], Text]:
+        dfas = {}
+        startsymbol: Optional[str] = None
+        # MSTART: (NEWLINE | RULE)* ENDMARKER
+        while self.type != token.ENDMARKER:
+            while self.type == token.NEWLINE:
+                self.gettoken()
+            # RULE: NAME ':' RHS NEWLINE
+            name = self.expect(token.NAME)
+            self.expect(token.OP, ":")
+            a, z = self.parse_rhs()
+            self.expect(token.NEWLINE)
+            # self.dump_nfa(name, a, z)
+            dfa = self.make_dfa(a, z)
+            # self.dump_dfa(name, dfa)
+            oldlen = len(dfa)
+            self.simplify_dfa(dfa)
+            newlen = len(dfa)
+            dfas[name] = dfa
+            # print name, oldlen, newlen
+            if startsymbol is None:
+                startsymbol = name
+        assert startsymbol is not None
+        return dfas, startsymbol
+
+    def make_dfa(self, start: "NFAState", finish: "NFAState") -> List["DFAState"]:
+        # To turn an NFA into a DFA, we define the states of the DFA
+        # to correspond to *sets* of states of the NFA.  Then do some
+        # state reduction.  Let's represent sets as dicts with 1 for
+        # values.
+        assert isinstance(start, NFAState)
+        assert isinstance(finish, NFAState)
+
+        def closure(state: NFAState) -> Dict[NFAState, int]:
+            base: Dict[NFAState, int] = {}
+            addclosure(state, base)
+            return base
+
+        def addclosure(state: NFAState, base: Dict[NFAState, int]) -> None:
+            assert isinstance(state, NFAState)
+            if state in base:
+                return
+            base[state] = 1
+            for label, next in state.arcs:
+                if label is None:
+                    addclosure(next, base)
+
+        states = [DFAState(closure(start), finish)]
+        for state in states:  # NB states grows while we're iterating
+            arcs: Dict[str, Dict[NFAState, int]] = {}
+            for nfastate in state.nfaset:
+                for label, next in nfastate.arcs:
+                    if label is not None:
+                        addclosure(next, arcs.setdefault(label, {}))
+            for label, nfaset in sorted(arcs.items()):
+                for st in states:
+                    if st.nfaset == nfaset:
+                        break
+                else:
+                    st = DFAState(nfaset, finish)
+                    states.append(st)
+                state.addarc(st, label)
+        return states  # List of DFAState instances; first one is start
+
+    def dump_nfa(self, name: Text, start: "NFAState", finish: "NFAState") -> None:
+        print("Dump of NFA for", name)
+        todo = [start]
+        for i, state in enumerate(todo):
+            print("  State", i, state is finish and "(final)" or "")
+            for label, next in state.arcs:
+                if next in todo:
+                    j = todo.index(next)
+                else:
+                    j = len(todo)
+                    todo.append(next)
+                if label is None:
+                    print("    -> %d" % j)
+                else:
+                    print("    %s -> %d" % (label, j))
+
+    def dump_dfa(self, name: Text, dfa: Sequence["DFAState"]) -> None:
+        print("Dump of DFA for", name)
+        for i, state in enumerate(dfa):
+            print("  State", i, state.isfinal and "(final)" or "")
+            for label, next in sorted(state.arcs.items()):
+                print("    %s -> %d" % (label, dfa.index(next)))
+
+    def simplify_dfa(self, dfa: List["DFAState"]) -> None:
+        # This is not theoretically optimal, but works well enough.
+        # Algorithm: repeatedly look for two states that have the same
+        # set of arcs (same labels pointing to the same nodes) and
+        # unify them, until things stop changing.
+
+        # dfa is a list of DFAState instances
+        changes = True
+        while changes:
+            changes = False
+            for i, state_i in enumerate(dfa):
+                for j in range(i + 1, len(dfa)):
+                    state_j = dfa[j]
+                    if state_i == state_j:
+                        # print "  unify", i, j
+                        del dfa[j]
+                        for state in dfa:
+                            state.unifystate(state_j, state_i)
+                        changes = True
+                        break
+
+    def parse_rhs(self) -> Tuple["NFAState", "NFAState"]:
+        # RHS: ALT ('|' ALT)*
+        a, z = self.parse_alt()
+        if self.value != "|":
+            return a, z
+        else:
+            aa = NFAState()
+            zz = NFAState()
+            aa.addarc(a)
+            z.addarc(zz)
+            while self.value == "|":
+                self.gettoken()
+                a, z = self.parse_alt()
+                aa.addarc(a)
+                z.addarc(zz)
+            return aa, zz
+
+    def parse_alt(self) -> Tuple["NFAState", "NFAState"]:
+        # ALT: ITEM+
+        a, b = self.parse_item()
+        while self.value in ("(", "[") or self.type in (token.NAME, token.STRING):
+            c, d = self.parse_item()
+            b.addarc(c)
+            b = d
+        return a, b
+
+    def parse_item(self) -> Tuple["NFAState", "NFAState"]:
+        # ITEM: '[' RHS ']' | ATOM ['+' | '*']
+        if self.value == "[":
+            self.gettoken()
+            a, z = self.parse_rhs()
+            self.expect(token.OP, "]")
+            a.addarc(z)
+            return a, z
+        else:
+            a, z = self.parse_atom()
+            value = self.value
+            if value not in ("+", "*"):
+                return a, z
+            self.gettoken()
+            z.addarc(a)
+            if value == "+":
+                return a, z
+            else:
+                return a, a
+
+    def parse_atom(self) -> Tuple["NFAState", "NFAState"]:
+        # ATOM: '(' RHS ')' | NAME | STRING
+        if self.value == "(":
+            self.gettoken()
+            a, z = self.parse_rhs()
+            self.expect(token.OP, ")")
+            return a, z
+        elif self.type in (token.NAME, token.STRING):
+            a = NFAState()
+            z = NFAState()
+            a.addarc(z, self.value)
+            self.gettoken()
+            return a, z
+        else:
+            self.raise_error(
+                "expected (...) or NAME or STRING, got %s/%s", self.type, self.value
+            )
+            assert False
+
+    def expect(self, type: int, value: Optional[Any] = None) -> Text:
+        if self.type != type or (value is not None and self.value != value):
+            self.raise_error(
+                "expected %s/%s, got %s/%s", type, value, self.type, self.value
+            )
+        value = self.value
+        self.gettoken()
+        return value
+
+    def gettoken(self) -> None:
+        tup = next(self.generator)
+        while tup[0] in (tokenize.COMMENT, tokenize.NL):
+            tup = next(self.generator)
+        self.type, self.value, self.begin, self.end, self.line = tup
+        # print token.tok_name[self.type], repr(self.value)
+
+    def raise_error(self, msg: str, *args: Any) -> NoReturn:
+        if args:
+            try:
+                msg = msg % args
+            except:
+                msg = " ".join([msg] + list(map(str, args)))
+        raise SyntaxError(msg, (self.filename, self.end[0], self.end[1], self.line))
+
+
+class NFAState(object):
+    arcs: List[Tuple[Optional[Text], "NFAState"]]
+
+    def __init__(self) -> None:
+        self.arcs = []  # list of (label, NFAState) pairs
+
+    def addarc(self, next: "NFAState", label: Optional[Text] = None) -> None:
+        assert label is None or isinstance(label, str)
+        assert isinstance(next, NFAState)
+        self.arcs.append((label, next))
+
+
+class DFAState(object):
+    nfaset: Dict[NFAState, Any]
+    isfinal: bool
+    arcs: Dict[Text, "DFAState"]
+
+    def __init__(self, nfaset: Dict[NFAState, Any], final: NFAState) -> None:
+        assert isinstance(nfaset, dict)
+        assert isinstance(next(iter(nfaset)), NFAState)
+        assert isinstance(final, NFAState)
+        self.nfaset = nfaset
+        self.isfinal = final in nfaset
+        self.arcs = {}  # map from label to DFAState
+
+    def addarc(self, next: "DFAState", label: Text) -> None:
+        assert isinstance(label, str)
+        assert label not in self.arcs
+        assert isinstance(next, DFAState)
+        self.arcs[label] = next
+
+    def unifystate(self, old: "DFAState", new: "DFAState") -> None:
+        for label, next in self.arcs.items():
+            if next is old:
+                self.arcs[label] = new
+
+    def __eq__(self, other: Any) -> bool:
+        # Equality test -- ignore the nfaset instance variable
+        assert isinstance(other, DFAState)
+        if self.isfinal != other.isfinal:
+            return False
+        # Can't just return self.arcs == other.arcs, because that
+        # would invoke this method recursively, with cycles...
+        if len(self.arcs) != len(other.arcs):
+            return False
+        for label, next in self.arcs.items():
+            if next is not other.arcs.get(label):
+                return False
+        return True
+
+    __hash__: Any = None  # For Py3 compatibility.
+
+
+def generate_grammar(filename: Path = "Grammar.txt") -> PgenGrammar:
+    p = ParserGenerator(filename)
+    return p.make_grammar()
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/pgen2/token.py b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/token.py
new file mode 100644
index 0000000..1e0dec9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/token.py
@@ -0,0 +1,94 @@
+"""Token constants (from "token.h")."""
+
+import sys
+from typing import Dict
+
+if sys.version_info < (3, 8):
+    from typing_extensions import Final
+else:
+    from typing import Final
+
+#  Taken from Python (r53757) and modified to include some tokens
+#   originally monkeypatched in by pgen2.tokenize
+
+# --start constants--
+ENDMARKER: Final = 0
+NAME: Final = 1
+NUMBER: Final = 2
+STRING: Final = 3
+NEWLINE: Final = 4
+INDENT: Final = 5
+DEDENT: Final = 6
+LPAR: Final = 7
+RPAR: Final = 8
+LSQB: Final = 9
+RSQB: Final = 10
+COLON: Final = 11
+COMMA: Final = 12
+SEMI: Final = 13
+PLUS: Final = 14
+MINUS: Final = 15
+STAR: Final = 16
+SLASH: Final = 17
+VBAR: Final = 18
+AMPER: Final = 19
+LESS: Final = 20
+GREATER: Final = 21
+EQUAL: Final = 22
+DOT: Final = 23
+PERCENT: Final = 24
+BACKQUOTE: Final = 25
+LBRACE: Final = 26
+RBRACE: Final = 27
+EQEQUAL: Final = 28
+NOTEQUAL: Final = 29
+LESSEQUAL: Final = 30
+GREATEREQUAL: Final = 31
+TILDE: Final = 32
+CIRCUMFLEX: Final = 33
+LEFTSHIFT: Final = 34
+RIGHTSHIFT: Final = 35
+DOUBLESTAR: Final = 36
+PLUSEQUAL: Final = 37
+MINEQUAL: Final = 38
+STAREQUAL: Final = 39
+SLASHEQUAL: Final = 40
+PERCENTEQUAL: Final = 41
+AMPEREQUAL: Final = 42
+VBAREQUAL: Final = 43
+CIRCUMFLEXEQUAL: Final = 44
+LEFTSHIFTEQUAL: Final = 45
+RIGHTSHIFTEQUAL: Final = 46
+DOUBLESTAREQUAL: Final = 47
+DOUBLESLASH: Final = 48
+DOUBLESLASHEQUAL: Final = 49
+AT: Final = 50
+ATEQUAL: Final = 51
+OP: Final = 52
+COMMENT: Final = 53
+NL: Final = 54
+RARROW: Final = 55
+AWAIT: Final = 56
+ASYNC: Final = 57
+ERRORTOKEN: Final = 58
+COLONEQUAL: Final = 59
+N_TOKENS: Final = 60
+NT_OFFSET: Final = 256
+# --end constants--
+
+tok_name: Final[Dict[int, str]] = {}
+for _name, _value in list(globals().items()):
+    if type(_value) is type(0):
+        tok_name[_value] = _name
+
+
+def ISTERMINAL(x: int) -> bool:
+    return x < NT_OFFSET
+
+
+def ISNONTERMINAL(x: int) -> bool:
+    return x >= NT_OFFSET
+
+
+def ISEOF(x: int) -> bool:
+    return x == ENDMARKER
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/pgen2/tokenize.py b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/tokenize.py
new file mode 100644
index 0000000..a7e17df
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/pgen2/tokenize.py
@@ -0,0 +1,688 @@
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation.
+# All rights reserved.
+
+# mypy: allow-untyped-defs, allow-untyped-calls
+
+"""Tokenization help for Python programs.
+
+generate_tokens(readline) is a generator that breaks a stream of
+text into Python tokens.  It accepts a readline-like method which is called
+repeatedly to get the next line of input (or "" for EOF).  It generates
+5-tuples with these members:
+
+    the token type (see token.py)
+    the token (a string)
+    the starting (row, column) indices of the token (a 2-tuple of ints)
+    the ending (row, column) indices of the token (a 2-tuple of ints)
+    the original line (string)
+
+It is designed to match the working of the Python tokenizer exactly, except
+that it produces COMMENT tokens for comments and gives type OP for all
+operators
+
+Older entry points
+    tokenize_loop(readline, tokeneater)
+    tokenize(readline, tokeneater=printtoken)
+are the same, except instead of generating tokens, tokeneater is a callback
+function to which the 5 fields described above are passed as 5 arguments,
+each time a new token is found."""
+
+import sys
+from typing import (
+    Callable,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Text,
+    Tuple,
+    Pattern,
+    Union,
+    cast,
+)
+
+if sys.version_info >= (3, 8):
+    from typing import Final
+else:
+    from typing_extensions import Final
+
+from blib2to3.pgen2.token import *
+from blib2to3.pgen2.grammar import Grammar
+
+__author__ = "Ka-Ping Yee <ping@lfw.org>"
+__credits__ = "GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip Montanaro"
+
+import re
+from codecs import BOM_UTF8, lookup
+from blib2to3.pgen2.token import *
+
+from . import token
+
+__all__ = [x for x in dir(token) if x[0] != "_"] + [
+    "tokenize",
+    "generate_tokens",
+    "untokenize",
+]
+del token
+
+
+def group(*choices):
+    return "(" + "|".join(choices) + ")"
+
+
+def any(*choices):
+    return group(*choices) + "*"
+
+
+def maybe(*choices):
+    return group(*choices) + "?"
+
+
+def _combinations(*l):
+    return set(x + y for x in l for y in l + ("",) if x.casefold() != y.casefold())
+
+
+Whitespace = r"[ \f\t]*"
+Comment = r"#[^\r\n]*"
+Ignore = Whitespace + any(r"\\\r?\n" + Whitespace) + maybe(Comment)
+Name = (  # this is invalid but it's fine because Name comes after Number in all groups
+    r"[^\s#\(\)\[\]\{\}+\-*/!@$%^&=|;:'\",\.<>/?`~\\]+"
+)
+
+Binnumber = r"0[bB]_?[01]+(?:_[01]+)*"
+Hexnumber = r"0[xX]_?[\da-fA-F]+(?:_[\da-fA-F]+)*[lL]?"
+Octnumber = r"0[oO]?_?[0-7]+(?:_[0-7]+)*[lL]?"
+Decnumber = group(r"[1-9]\d*(?:_\d+)*[lL]?", "0[lL]?")
+Intnumber = group(Binnumber, Hexnumber, Octnumber, Decnumber)
+Exponent = r"[eE][-+]?\d+(?:_\d+)*"
+Pointfloat = group(r"\d+(?:_\d+)*\.(?:\d+(?:_\d+)*)?", r"\.\d+(?:_\d+)*") + maybe(
+    Exponent
+)
+Expfloat = r"\d+(?:_\d+)*" + Exponent
+Floatnumber = group(Pointfloat, Expfloat)
+Imagnumber = group(r"\d+(?:_\d+)*[jJ]", Floatnumber + r"[jJ]")
+Number = group(Imagnumber, Floatnumber, Intnumber)
+
+# Tail end of ' string.
+Single = r"[^'\\]*(?:\\.[^'\\]*)*'"
+# Tail end of " string.
+Double = r'[^"\\]*(?:\\.[^"\\]*)*"'
+# Tail end of ''' string.
+Single3 = r"[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''"
+# Tail end of """ string.
+Double3 = r'[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""'
+_litprefix = r"(?:[uUrRbBfF]|[rR][fFbB]|[fFbBuU][rR])?"
+Triple = group(_litprefix + "'''", _litprefix + '"""')
+# Single-line ' or " string.
+String = group(
+    _litprefix + r"'[^\n'\\]*(?:\\.[^\n'\\]*)*'",
+    _litprefix + r'"[^\n"\\]*(?:\\.[^\n"\\]*)*"',
+)
+
+# Because of leftmost-then-longest match semantics, be sure to put the
+# longest operators first (e.g., if = came before ==, == would get
+# recognized as two instances of =).
+Operator = group(
+    r"\*\*=?",
+    r">>=?",
+    r"<<=?",
+    r"<>",
+    r"!=",
+    r"//=?",
+    r"->",
+    r"[+\-*/%&@|^=<>:]=?",
+    r"~",
+)
+
+Bracket = "[][(){}]"
+Special = group(r"\r?\n", r"[:;.,`@]")
+Funny = group(Operator, Bracket, Special)
+
+# First (or only) line of ' or " string.
+ContStr = group(
+    _litprefix + r"'[^\n'\\]*(?:\\.[^\n'\\]*)*" + group("'", r"\\\r?\n"),
+    _litprefix + r'"[^\n"\\]*(?:\\.[^\n"\\]*)*' + group('"', r"\\\r?\n"),
+)
+PseudoExtras = group(r"\\\r?\n", Comment, Triple)
+PseudoToken = Whitespace + group(PseudoExtras, Number, Funny, ContStr, Name)
+
+pseudoprog: Final = re.compile(PseudoToken, re.UNICODE)
+single3prog = re.compile(Single3)
+double3prog = re.compile(Double3)
+
+_strprefixes = (
+    _combinations("r", "R", "f", "F")
+    | _combinations("r", "R", "b", "B")
+    | {"u", "U", "ur", "uR", "Ur", "UR"}
+)
+
+endprogs: Final = {
+    "'": re.compile(Single),
+    '"': re.compile(Double),
+    "'''": single3prog,
+    '"""': double3prog,
+    **{f"{prefix}'''": single3prog for prefix in _strprefixes},
+    **{f'{prefix}"""': double3prog for prefix in _strprefixes},
+    **{prefix: None for prefix in _strprefixes},
+}
+
+triple_quoted: Final = (
+    {"'''", '"""'}
+    | {f"{prefix}'''" for prefix in _strprefixes}
+    | {f'{prefix}"""' for prefix in _strprefixes}
+)
+single_quoted: Final = (
+    {"'", '"'}
+    | {f"{prefix}'" for prefix in _strprefixes}
+    | {f'{prefix}"' for prefix in _strprefixes}
+)
+
+tabsize = 8
+
+
+class TokenError(Exception):
+    pass
+
+
+class StopTokenizing(Exception):
+    pass
+
+
+def printtoken(type, token, xxx_todo_changeme, xxx_todo_changeme1, line):  # for testing
+    (srow, scol) = xxx_todo_changeme
+    (erow, ecol) = xxx_todo_changeme1
+    print(
+        "%d,%d-%d,%d:\t%s\t%s" % (srow, scol, erow, ecol, tok_name[type], repr(token))
+    )
+
+
+Coord = Tuple[int, int]
+TokenEater = Callable[[int, Text, Coord, Coord, Text], None]
+
+
+def tokenize(readline: Callable[[], Text], tokeneater: TokenEater = printtoken) -> None:
+    """
+    The tokenize() function accepts two parameters: one representing the
+    input stream, and one providing an output mechanism for tokenize().
+
+    The first parameter, readline, must be a callable object which provides
+    the same interface as the readline() method of built-in file objects.
+    Each call to the function should return one line of input as a string.
+
+    The second parameter, tokeneater, must also be a callable object. It is
+    called once for each token, with five arguments, corresponding to the
+    tuples generated by generate_tokens().
+    """
+    try:
+        tokenize_loop(readline, tokeneater)
+    except StopTokenizing:
+        pass
+
+
+# backwards compatible interface
+def tokenize_loop(readline, tokeneater):
+    for token_info in generate_tokens(readline):
+        tokeneater(*token_info)
+
+
+GoodTokenInfo = Tuple[int, Text, Coord, Coord, Text]
+TokenInfo = Union[Tuple[int, str], GoodTokenInfo]
+
+
+class Untokenizer:
+
+    tokens: List[Text]
+    prev_row: int
+    prev_col: int
+
+    def __init__(self) -> None:
+        self.tokens = []
+        self.prev_row = 1
+        self.prev_col = 0
+
+    def add_whitespace(self, start: Coord) -> None:
+        row, col = start
+        assert row <= self.prev_row
+        col_offset = col - self.prev_col
+        if col_offset:
+            self.tokens.append(" " * col_offset)
+
+    def untokenize(self, iterable: Iterable[TokenInfo]) -> Text:
+        for t in iterable:
+            if len(t) == 2:
+                self.compat(cast(Tuple[int, str], t), iterable)
+                break
+            tok_type, token, start, end, line = cast(
+                Tuple[int, Text, Coord, Coord, Text], t
+            )
+            self.add_whitespace(start)
+            self.tokens.append(token)
+            self.prev_row, self.prev_col = end
+            if tok_type in (NEWLINE, NL):
+                self.prev_row += 1
+                self.prev_col = 0
+        return "".join(self.tokens)
+
+    def compat(self, token: Tuple[int, Text], iterable: Iterable[TokenInfo]) -> None:
+        startline = False
+        indents = []
+        toks_append = self.tokens.append
+        toknum, tokval = token
+        if toknum in (NAME, NUMBER):
+            tokval += " "
+        if toknum in (NEWLINE, NL):
+            startline = True
+        for tok in iterable:
+            toknum, tokval = tok[:2]
+
+            if toknum in (NAME, NUMBER, ASYNC, AWAIT):
+                tokval += " "
+
+            if toknum == INDENT:
+                indents.append(tokval)
+                continue
+            elif toknum == DEDENT:
+                indents.pop()
+                continue
+            elif toknum in (NEWLINE, NL):
+                startline = True
+            elif startline and indents:
+                toks_append(indents[-1])
+                startline = False
+            toks_append(tokval)
+
+
+cookie_re = re.compile(r"^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)", re.ASCII)
+blank_re = re.compile(br"^[ \t\f]*(?:[#\r\n]|$)", re.ASCII)
+
+
+def _get_normal_name(orig_enc: str) -> str:
+    """Imitates get_normal_name in tokenizer.c."""
+    # Only care about the first 12 characters.
+    enc = orig_enc[:12].lower().replace("_", "-")
+    if enc == "utf-8" or enc.startswith("utf-8-"):
+        return "utf-8"
+    if enc in ("latin-1", "iso-8859-1", "iso-latin-1") or enc.startswith(
+        ("latin-1-", "iso-8859-1-", "iso-latin-1-")
+    ):
+        return "iso-8859-1"
+    return orig_enc
+
+
+def detect_encoding(readline: Callable[[], bytes]) -> Tuple[str, List[bytes]]:
+    """
+    The detect_encoding() function is used to detect the encoding that should
+    be used to decode a Python source file. It requires one argument, readline,
+    in the same way as the tokenize() generator.
+
+    It will call readline a maximum of twice, and return the encoding used
+    (as a string) and a list of any lines (left as bytes) it has read
+    in.
+
+    It detects the encoding from the presence of a utf-8 bom or an encoding
+    cookie as specified in pep-0263. If both a bom and a cookie are present, but
+    disagree, a SyntaxError will be raised. If the encoding cookie is an invalid
+    charset, raise a SyntaxError.  Note that if a utf-8 bom is found,
+    'utf-8-sig' is returned.
+
+    If no encoding is specified, then the default of 'utf-8' will be returned.
+    """
+    bom_found = False
+    encoding = None
+    default = "utf-8"
+
+    def read_or_stop() -> bytes:
+        try:
+            return readline()
+        except StopIteration:
+            return bytes()
+
+    def find_cookie(line: bytes) -> Optional[str]:
+        try:
+            line_string = line.decode("ascii")
+        except UnicodeDecodeError:
+            return None
+        match = cookie_re.match(line_string)
+        if not match:
+            return None
+        encoding = _get_normal_name(match.group(1))
+        try:
+            codec = lookup(encoding)
+        except LookupError:
+            # This behaviour mimics the Python interpreter
+            raise SyntaxError("unknown encoding: " + encoding)
+
+        if bom_found:
+            if codec.name != "utf-8":
+                # This behaviour mimics the Python interpreter
+                raise SyntaxError("encoding problem: utf-8")
+            encoding += "-sig"
+        return encoding
+
+    first = read_or_stop()
+    if first.startswith(BOM_UTF8):
+        bom_found = True
+        first = first[3:]
+        default = "utf-8-sig"
+    if not first:
+        return default, []
+
+    encoding = find_cookie(first)
+    if encoding:
+        return encoding, [first]
+    if not blank_re.match(first):
+        return default, [first]
+
+    second = read_or_stop()
+    if not second:
+        return default, [first]
+
+    encoding = find_cookie(second)
+    if encoding:
+        return encoding, [first, second]
+
+    return default, [first, second]
+
+
+def untokenize(iterable: Iterable[TokenInfo]) -> Text:
+    """Transform tokens back into Python source code.
+
+    Each element returned by the iterable must be a token sequence
+    with at least two elements, a token number and token value.  If
+    only two tokens are passed, the resulting output is poor.
+
+    Round-trip invariant for full input:
+        Untokenized source will match input source exactly
+
+    Round-trip invariant for limited input:
+        # Output text will tokenize the back to the input
+        t1 = [tok[:2] for tok in generate_tokens(f.readline)]
+        newcode = untokenize(t1)
+        readline = iter(newcode.splitlines(1)).next
+        t2 = [tok[:2] for tokin generate_tokens(readline)]
+        assert t1 == t2
+    """
+    ut = Untokenizer()
+    return ut.untokenize(iterable)
+
+
+def generate_tokens(
+    readline: Callable[[], Text], grammar: Optional[Grammar] = None
+) -> Iterator[GoodTokenInfo]:
+    """
+    The generate_tokens() generator requires one argument, readline, which
+    must be a callable object which provides the same interface as the
+    readline() method of built-in file objects. Each call to the function
+    should return one line of input as a string.  Alternately, readline
+    can be a callable function terminating with StopIteration:
+        readline = open(myfile).next    # Example of alternate readline
+
+    The generator produces 5-tuples with these members: the token type; the
+    token string; a 2-tuple (srow, scol) of ints specifying the row and
+    column where the token begins in the source; a 2-tuple (erow, ecol) of
+    ints specifying the row and column where the token ends in the source;
+    and the line on which the token was found. The line passed is the
+    logical line; continuation lines are included.
+    """
+    lnum = parenlev = continued = 0
+    numchars: Final = "0123456789"
+    contstr, needcont = "", 0
+    contline: Optional[str] = None
+    indents = [0]
+
+    # If we know we're parsing 3.7+, we can unconditionally parse `async` and
+    # `await` as keywords.
+    async_keywords = False if grammar is None else grammar.async_keywords
+    # 'stashed' and 'async_*' are used for async/await parsing
+    stashed: Optional[GoodTokenInfo] = None
+    async_def = False
+    async_def_indent = 0
+    async_def_nl = False
+
+    strstart: Tuple[int, int]
+    endprog: Pattern[str]
+
+    while 1:  # loop over lines in stream
+        try:
+            line = readline()
+        except StopIteration:
+            line = ""
+        lnum += 1
+        pos, max = 0, len(line)
+
+        if contstr:  # continued string
+            assert contline is not None
+            if not line:
+                raise TokenError("EOF in multi-line string", strstart)
+            endmatch = endprog.match(line)
+            if endmatch:
+                pos = end = endmatch.end(0)
+                yield (
+                    STRING,
+                    contstr + line[:end],
+                    strstart,
+                    (lnum, end),
+                    contline + line,
+                )
+                contstr, needcont = "", 0
+                contline = None
+            elif needcont and line[-2:] != "\\\n" and line[-3:] != "\\\r\n":
+                yield (
+                    ERRORTOKEN,
+                    contstr + line,
+                    strstart,
+                    (lnum, len(line)),
+                    contline,
+                )
+                contstr = ""
+                contline = None
+                continue
+            else:
+                contstr = contstr + line
+                contline = contline + line
+                continue
+
+        elif parenlev == 0 and not continued:  # new statement
+            if not line:
+                break
+            column = 0
+            while pos < max:  # measure leading whitespace
+                if line[pos] == " ":
+                    column += 1
+                elif line[pos] == "\t":
+                    column = (column // tabsize + 1) * tabsize
+                elif line[pos] == "\f":
+                    column = 0
+                else:
+                    break
+                pos += 1
+            if pos == max:
+                break
+
+            if stashed:
+                yield stashed
+                stashed = None
+
+            if line[pos] in "\r\n":  # skip blank lines
+                yield (NL, line[pos:], (lnum, pos), (lnum, len(line)), line)
+                continue
+
+            if line[pos] == "#":  # skip comments
+                comment_token = line[pos:].rstrip("\r\n")
+                nl_pos = pos + len(comment_token)
+                yield (
+                    COMMENT,
+                    comment_token,
+                    (lnum, pos),
+                    (lnum, nl_pos),
+                    line,
+                )
+                yield (NL, line[nl_pos:], (lnum, nl_pos), (lnum, len(line)), line)
+                continue
+
+            if column > indents[-1]:  # count indents
+                indents.append(column)
+                yield (INDENT, line[:pos], (lnum, 0), (lnum, pos), line)
+
+            while column < indents[-1]:  # count dedents
+                if column not in indents:
+                    raise IndentationError(
+                        "unindent does not match any outer indentation level",
+                        ("<tokenize>", lnum, pos, line),
+                    )
+                indents = indents[:-1]
+
+                if async_def and async_def_indent >= indents[-1]:
+                    async_def = False
+                    async_def_nl = False
+                    async_def_indent = 0
+
+                yield (DEDENT, "", (lnum, pos), (lnum, pos), line)
+
+            if async_def and async_def_nl and async_def_indent >= indents[-1]:
+                async_def = False
+                async_def_nl = False
+                async_def_indent = 0
+
+        else:  # continued statement
+            if not line:
+                raise TokenError("EOF in multi-line statement", (lnum, 0))
+            continued = 0
+
+        while pos < max:
+            pseudomatch = pseudoprog.match(line, pos)
+            if pseudomatch:  # scan for tokens
+                start, end = pseudomatch.span(1)
+                spos, epos, pos = (lnum, start), (lnum, end), end
+                token, initial = line[start:end], line[start]
+
+                if initial in numchars or (
+                    initial == "." and token != "."
+                ):  # ordinary number
+                    yield (NUMBER, token, spos, epos, line)
+                elif initial in "\r\n":
+                    newline = NEWLINE
+                    if parenlev > 0:
+                        newline = NL
+                    elif async_def:
+                        async_def_nl = True
+                    if stashed:
+                        yield stashed
+                        stashed = None
+                    yield (newline, token, spos, epos, line)
+
+                elif initial == "#":
+                    assert not token.endswith("\n")
+                    if stashed:
+                        yield stashed
+                        stashed = None
+                    yield (COMMENT, token, spos, epos, line)
+                elif token in triple_quoted:
+                    endprog = endprogs[token]
+                    endmatch = endprog.match(line, pos)
+                    if endmatch:  # all on one line
+                        pos = endmatch.end(0)
+                        token = line[start:pos]
+                        if stashed:
+                            yield stashed
+                            stashed = None
+                        yield (STRING, token, spos, (lnum, pos), line)
+                    else:
+                        strstart = (lnum, start)  # multiple lines
+                        contstr = line[start:]
+                        contline = line
+                        break
+                elif (
+                    initial in single_quoted
+                    or token[:2] in single_quoted
+                    or token[:3] in single_quoted
+                ):
+                    if token[-1] == "\n":  # continued string
+                        strstart = (lnum, start)
+                        endprog = (
+                            endprogs[initial]
+                            or endprogs[token[1]]
+                            or endprogs[token[2]]
+                        )
+                        contstr, needcont = line[start:], 1
+                        contline = line
+                        break
+                    else:  # ordinary string
+                        if stashed:
+                            yield stashed
+                            stashed = None
+                        yield (STRING, token, spos, epos, line)
+                elif initial.isidentifier():  # ordinary name
+                    if token in ("async", "await"):
+                        if async_keywords or async_def:
+                            yield (
+                                ASYNC if token == "async" else AWAIT,
+                                token,
+                                spos,
+                                epos,
+                                line,
+                            )
+                            continue
+
+                    tok = (NAME, token, spos, epos, line)
+                    if token == "async" and not stashed:
+                        stashed = tok
+                        continue
+
+                    if token in ("def", "for"):
+                        if stashed and stashed[0] == NAME and stashed[1] == "async":
+
+                            if token == "def":
+                                async_def = True
+                                async_def_indent = indents[-1]
+
+                            yield (
+                                ASYNC,
+                                stashed[1],
+                                stashed[2],
+                                stashed[3],
+                                stashed[4],
+                            )
+                            stashed = None
+
+                    if stashed:
+                        yield stashed
+                        stashed = None
+
+                    yield tok
+                elif initial == "\\":  # continued stmt
+                    # This yield is new; needed for better idempotency:
+                    if stashed:
+                        yield stashed
+                        stashed = None
+                    yield (NL, token, spos, (lnum, pos), line)
+                    continued = 1
+                else:
+                    if initial in "([{":
+                        parenlev += 1
+                    elif initial in ")]}":
+                        parenlev -= 1
+                    if stashed:
+                        yield stashed
+                        stashed = None
+                    yield (OP, token, spos, epos, line)
+            else:
+                yield (ERRORTOKEN, line[pos], (lnum, pos), (lnum, pos + 1), line)
+                pos += 1
+
+    if stashed:
+        yield stashed
+        stashed = None
+
+    for indent in indents[1:]:  # pop remaining indent levels
+        yield (DEDENT, "", (lnum, 0), (lnum, 0), "")
+    yield (ENDMARKER, "", (lnum, 0), (lnum, 0), "")
+
+
+if __name__ == "__main__":  # testing
+    import sys
+
+    if len(sys.argv) > 1:
+        tokenize(open(sys.argv[1]).readline)
+    else:
+        tokenize(sys.stdin.readline)
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/pygram.py b/myenv/lib/python3.9/site-packages/blib2to3/pygram.py
new file mode 100644
index 0000000..aa20b81
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/pygram.py
@@ -0,0 +1,212 @@
+# Copyright 2006 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Export the Python grammar and symbols."""
+
+# Python imports
+import os
+
+from typing import Union
+
+# Local imports
+from .pgen2 import token
+from .pgen2 import driver
+
+from .pgen2.grammar import Grammar
+
+# Moved into initialize because mypyc can't handle __file__ (XXX bug)
+# # The grammar file
+# _GRAMMAR_FILE = os.path.join(os.path.dirname(__file__), "Grammar.txt")
+# _PATTERN_GRAMMAR_FILE = os.path.join(os.path.dirname(__file__),
+#                                      "PatternGrammar.txt")
+
+
+class Symbols(object):
+    def __init__(self, grammar: Grammar) -> None:
+        """Initializer.
+
+        Creates an attribute for each grammar symbol (nonterminal),
+        whose value is the symbol's type (an int >= 256).
+        """
+        for name, symbol in grammar.symbol2number.items():
+            setattr(self, name, symbol)
+
+
+class _python_symbols(Symbols):
+    and_expr: int
+    and_test: int
+    annassign: int
+    arglist: int
+    argument: int
+    arith_expr: int
+    asexpr_test: int
+    assert_stmt: int
+    async_funcdef: int
+    async_stmt: int
+    atom: int
+    augassign: int
+    break_stmt: int
+    case_block: int
+    classdef: int
+    comp_for: int
+    comp_if: int
+    comp_iter: int
+    comp_op: int
+    comparison: int
+    compound_stmt: int
+    continue_stmt: int
+    decorated: int
+    decorator: int
+    decorators: int
+    del_stmt: int
+    dictsetmaker: int
+    dotted_as_name: int
+    dotted_as_names: int
+    dotted_name: int
+    encoding_decl: int
+    eval_input: int
+    except_clause: int
+    exec_stmt: int
+    expr: int
+    expr_stmt: int
+    exprlist: int
+    factor: int
+    file_input: int
+    flow_stmt: int
+    for_stmt: int
+    funcdef: int
+    global_stmt: int
+    guard: int
+    if_stmt: int
+    import_as_name: int
+    import_as_names: int
+    import_from: int
+    import_name: int
+    import_stmt: int
+    lambdef: int
+    listmaker: int
+    match_stmt: int
+    namedexpr_test: int
+    not_test: int
+    old_comp_for: int
+    old_comp_if: int
+    old_comp_iter: int
+    old_lambdef: int
+    old_test: int
+    or_test: int
+    parameters: int
+    pass_stmt: int
+    pattern: int
+    patterns: int
+    power: int
+    print_stmt: int
+    raise_stmt: int
+    return_stmt: int
+    shift_expr: int
+    simple_stmt: int
+    single_input: int
+    sliceop: int
+    small_stmt: int
+    subject_expr: int
+    star_expr: int
+    stmt: int
+    subscript: int
+    subscriptlist: int
+    suite: int
+    term: int
+    test: int
+    testlist: int
+    testlist1: int
+    testlist_gexp: int
+    testlist_safe: int
+    testlist_star_expr: int
+    tfpdef: int
+    tfplist: int
+    tname: int
+    trailer: int
+    try_stmt: int
+    typedargslist: int
+    varargslist: int
+    vfpdef: int
+    vfplist: int
+    vname: int
+    while_stmt: int
+    with_stmt: int
+    xor_expr: int
+    yield_arg: int
+    yield_expr: int
+    yield_stmt: int
+
+
+class _pattern_symbols(Symbols):
+    Alternative: int
+    Alternatives: int
+    Details: int
+    Matcher: int
+    NegatedUnit: int
+    Repeater: int
+    Unit: int
+
+
+python_grammar: Grammar
+python_grammar_no_print_statement: Grammar
+python_grammar_no_print_statement_no_exec_statement: Grammar
+python_grammar_no_print_statement_no_exec_statement_async_keywords: Grammar
+python_grammar_no_exec_statement: Grammar
+pattern_grammar: Grammar
+python_grammar_soft_keywords: Grammar
+
+python_symbols: _python_symbols
+pattern_symbols: _pattern_symbols
+
+
+def initialize(cache_dir: Union[str, "os.PathLike[str]", None] = None) -> None:
+    global python_grammar
+    global python_grammar_no_print_statement
+    global python_grammar_no_print_statement_no_exec_statement
+    global python_grammar_no_print_statement_no_exec_statement_async_keywords
+    global python_grammar_soft_keywords
+    global python_symbols
+    global pattern_grammar
+    global pattern_symbols
+
+    # The grammar file
+    _GRAMMAR_FILE = os.path.join(os.path.dirname(__file__), "Grammar.txt")
+    _PATTERN_GRAMMAR_FILE = os.path.join(
+        os.path.dirname(__file__), "PatternGrammar.txt"
+    )
+
+    # Python 2
+    python_grammar = driver.load_packaged_grammar("blib2to3", _GRAMMAR_FILE, cache_dir)
+    soft_keywords = python_grammar.soft_keywords.copy()
+    python_grammar.soft_keywords.clear()
+
+    python_symbols = _python_symbols(python_grammar)
+
+    # Python 2 + from __future__ import print_function
+    python_grammar_no_print_statement = python_grammar.copy()
+    del python_grammar_no_print_statement.keywords["print"]
+
+    # Python 3.0-3.6
+    python_grammar_no_print_statement_no_exec_statement = python_grammar.copy()
+    del python_grammar_no_print_statement_no_exec_statement.keywords["print"]
+    del python_grammar_no_print_statement_no_exec_statement.keywords["exec"]
+
+    # Python 3.7+
+    python_grammar_no_print_statement_no_exec_statement_async_keywords = (
+        python_grammar_no_print_statement_no_exec_statement.copy()
+    )
+    python_grammar_no_print_statement_no_exec_statement_async_keywords.async_keywords = (
+        True
+    )
+
+    # Python 3.10+
+    python_grammar_soft_keywords = (
+        python_grammar_no_print_statement_no_exec_statement_async_keywords.copy()
+    )
+    python_grammar_soft_keywords.soft_keywords = soft_keywords
+
+    pattern_grammar = driver.load_packaged_grammar(
+        "blib2to3", _PATTERN_GRAMMAR_FILE, cache_dir
+    )
+    pattern_symbols = _pattern_symbols(pattern_grammar)
diff --git a/myenv/lib/python3.9/site-packages/blib2to3/pytree.py b/myenv/lib/python3.9/site-packages/blib2to3/pytree.py
new file mode 100644
index 0000000..bd86270
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/blib2to3/pytree.py
@@ -0,0 +1,980 @@
+# Copyright 2006 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""
+Python parse tree definitions.
+
+This is a very concrete parse tree; we need to keep every token and
+even the comments and whitespace between tokens.
+
+There's also a pattern matching implementation here.
+"""
+
+# mypy: allow-untyped-defs
+
+from typing import (
+    Any,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Text,
+    Tuple,
+    TypeVar,
+    Union,
+    Set,
+    Iterable,
+)
+from blib2to3.pgen2.grammar import Grammar
+
+__author__ = "Guido van Rossum <guido@python.org>"
+
+import sys
+from io import StringIO
+
+HUGE: int = 0x7FFFFFFF  # maximum repeat count, default max
+
+_type_reprs: Dict[int, Union[Text, int]] = {}
+
+
+def type_repr(type_num: int) -> Union[Text, int]:
+    global _type_reprs
+    if not _type_reprs:
+        from .pygram import python_symbols
+
+        # printing tokens is possible but not as useful
+        # from .pgen2 import token // token.__dict__.items():
+        for name in dir(python_symbols):
+            val = getattr(python_symbols, name)
+            if type(val) == int:
+                _type_reprs[val] = name
+    return _type_reprs.setdefault(type_num, type_num)
+
+
+_P = TypeVar("_P", bound="Base")
+
+NL = Union["Node", "Leaf"]
+Context = Tuple[Text, Tuple[int, int]]
+RawNode = Tuple[int, Optional[Text], Optional[Context], Optional[List[NL]]]
+
+
+class Base(object):
+
+    """
+    Abstract base class for Node and Leaf.
+
+    This provides some default functionality and boilerplate using the
+    template pattern.
+
+    A node may be a subnode of at most one parent.
+    """
+
+    # Default values for instance variables
+    type: int  # int: token number (< 256) or symbol number (>= 256)
+    parent: Optional["Node"] = None  # Parent node pointer, or None
+    children: List[NL]  # List of subnodes
+    was_changed: bool = False
+    was_checked: bool = False
+
+    def __new__(cls, *args, **kwds):
+        """Constructor that prevents Base from being instantiated."""
+        assert cls is not Base, "Cannot instantiate Base"
+        return object.__new__(cls)
+
+    def __eq__(self, other: Any) -> bool:
+        """
+        Compare two nodes for equality.
+
+        This calls the method _eq().
+        """
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return self._eq(other)
+
+    @property
+    def prefix(self) -> Text:
+        raise NotImplementedError
+
+    def _eq(self: _P, other: _P) -> bool:
+        """
+        Compare two nodes for equality.
+
+        This is called by __eq__ and __ne__.  It is only called if the two nodes
+        have the same type.  This must be implemented by the concrete subclass.
+        Nodes should be considered equal if they have the same structure,
+        ignoring the prefix string and other context information.
+        """
+        raise NotImplementedError
+
+    def __deepcopy__(self: _P, memo: Any) -> _P:
+        return self.clone()
+
+    def clone(self: _P) -> _P:
+        """
+        Return a cloned (deep) copy of self.
+
+        This must be implemented by the concrete subclass.
+        """
+        raise NotImplementedError
+
+    def post_order(self) -> Iterator[NL]:
+        """
+        Return a post-order iterator for the tree.
+
+        This must be implemented by the concrete subclass.
+        """
+        raise NotImplementedError
+
+    def pre_order(self) -> Iterator[NL]:
+        """
+        Return a pre-order iterator for the tree.
+
+        This must be implemented by the concrete subclass.
+        """
+        raise NotImplementedError
+
+    def replace(self, new: Union[NL, List[NL]]) -> None:
+        """Replace this node with a new one in the parent."""
+        assert self.parent is not None, str(self)
+        assert new is not None
+        if not isinstance(new, list):
+            new = [new]
+        l_children = []
+        found = False
+        for ch in self.parent.children:
+            if ch is self:
+                assert not found, (self.parent.children, self, new)
+                if new is not None:
+                    l_children.extend(new)
+                found = True
+            else:
+                l_children.append(ch)
+        assert found, (self.children, self, new)
+        self.parent.children = l_children
+        self.parent.changed()
+        self.parent.invalidate_sibling_maps()
+        for x in new:
+            x.parent = self.parent
+        self.parent = None
+
+    def get_lineno(self) -> Optional[int]:
+        """Return the line number which generated the invocant node."""
+        node = self
+        while not isinstance(node, Leaf):
+            if not node.children:
+                return None
+            node = node.children[0]
+        return node.lineno
+
+    def changed(self) -> None:
+        if self.was_changed:
+            return
+        if self.parent:
+            self.parent.changed()
+        self.was_changed = True
+
+    def remove(self) -> Optional[int]:
+        """
+        Remove the node from the tree. Returns the position of the node in its
+        parent's children before it was removed.
+        """
+        if self.parent:
+            for i, node in enumerate(self.parent.children):
+                if node is self:
+                    del self.parent.children[i]
+                    self.parent.changed()
+                    self.parent.invalidate_sibling_maps()
+                    self.parent = None
+                    return i
+        return None
+
+    @property
+    def next_sibling(self) -> Optional[NL]:
+        """
+        The node immediately following the invocant in their parent's children
+        list. If the invocant does not have a next sibling, it is None
+        """
+        if self.parent is None:
+            return None
+
+        if self.parent.next_sibling_map is None:
+            self.parent.update_sibling_maps()
+        assert self.parent.next_sibling_map is not None
+        return self.parent.next_sibling_map[id(self)]
+
+    @property
+    def prev_sibling(self) -> Optional[NL]:
+        """
+        The node immediately preceding the invocant in their parent's children
+        list. If the invocant does not have a previous sibling, it is None.
+        """
+        if self.parent is None:
+            return None
+
+        if self.parent.prev_sibling_map is None:
+            self.parent.update_sibling_maps()
+        assert self.parent.prev_sibling_map is not None
+        return self.parent.prev_sibling_map[id(self)]
+
+    def leaves(self) -> Iterator["Leaf"]:
+        for child in self.children:
+            yield from child.leaves()
+
+    def depth(self) -> int:
+        if self.parent is None:
+            return 0
+        return 1 + self.parent.depth()
+
+    def get_suffix(self) -> Text:
+        """
+        Return the string immediately following the invocant node. This is
+        effectively equivalent to node.next_sibling.prefix
+        """
+        next_sib = self.next_sibling
+        if next_sib is None:
+            return ""
+        prefix = next_sib.prefix
+        return prefix
+
+
+class Node(Base):
+
+    """Concrete implementation for interior nodes."""
+
+    fixers_applied: Optional[List[Any]]
+    used_names: Optional[Set[Text]]
+
+    def __init__(
+        self,
+        type: int,
+        children: List[NL],
+        context: Optional[Any] = None,
+        prefix: Optional[Text] = None,
+        fixers_applied: Optional[List[Any]] = None,
+    ) -> None:
+        """
+        Initializer.
+
+        Takes a type constant (a symbol number >= 256), a sequence of
+        child nodes, and an optional context keyword argument.
+
+        As a side effect, the parent pointers of the children are updated.
+        """
+        assert type >= 256, type
+        self.type = type
+        self.children = list(children)
+        for ch in self.children:
+            assert ch.parent is None, repr(ch)
+            ch.parent = self
+        self.invalidate_sibling_maps()
+        if prefix is not None:
+            self.prefix = prefix
+        if fixers_applied:
+            self.fixers_applied = fixers_applied[:]
+        else:
+            self.fixers_applied = None
+
+    def __repr__(self) -> Text:
+        """Return a canonical string representation."""
+        assert self.type is not None
+        return "%s(%s, %r)" % (
+            self.__class__.__name__,
+            type_repr(self.type),
+            self.children,
+        )
+
+    def __str__(self) -> Text:
+        """
+        Return a pretty string representation.
+
+        This reproduces the input source exactly.
+        """
+        return "".join(map(str, self.children))
+
+    def _eq(self, other) -> bool:
+        """Compare two nodes for equality."""
+        return (self.type, self.children) == (other.type, other.children)
+
+    def clone(self) -> "Node":
+        assert self.type is not None
+        """Return a cloned (deep) copy of self."""
+        return Node(
+            self.type,
+            [ch.clone() for ch in self.children],
+            fixers_applied=self.fixers_applied,
+        )
+
+    def post_order(self) -> Iterator[NL]:
+        """Return a post-order iterator for the tree."""
+        for child in self.children:
+            yield from child.post_order()
+        yield self
+
+    def pre_order(self) -> Iterator[NL]:
+        """Return a pre-order iterator for the tree."""
+        yield self
+        for child in self.children:
+            yield from child.pre_order()
+
+    @property
+    def prefix(self) -> Text:
+        """
+        The whitespace and comments preceding this node in the input.
+        """
+        if not self.children:
+            return ""
+        return self.children[0].prefix
+
+    @prefix.setter
+    def prefix(self, prefix) -> None:
+        if self.children:
+            self.children[0].prefix = prefix
+
+    def set_child(self, i: int, child: NL) -> None:
+        """
+        Equivalent to 'node.children[i] = child'. This method also sets the
+        child's parent attribute appropriately.
+        """
+        child.parent = self
+        self.children[i].parent = None
+        self.children[i] = child
+        self.changed()
+        self.invalidate_sibling_maps()
+
+    def insert_child(self, i: int, child: NL) -> None:
+        """
+        Equivalent to 'node.children.insert(i, child)'. This method also sets
+        the child's parent attribute appropriately.
+        """
+        child.parent = self
+        self.children.insert(i, child)
+        self.changed()
+        self.invalidate_sibling_maps()
+
+    def append_child(self, child: NL) -> None:
+        """
+        Equivalent to 'node.children.append(child)'. This method also sets the
+        child's parent attribute appropriately.
+        """
+        child.parent = self
+        self.children.append(child)
+        self.changed()
+        self.invalidate_sibling_maps()
+
+    def invalidate_sibling_maps(self) -> None:
+        self.prev_sibling_map: Optional[Dict[int, Optional[NL]]] = None
+        self.next_sibling_map: Optional[Dict[int, Optional[NL]]] = None
+
+    def update_sibling_maps(self) -> None:
+        _prev: Dict[int, Optional[NL]] = {}
+        _next: Dict[int, Optional[NL]] = {}
+        self.prev_sibling_map = _prev
+        self.next_sibling_map = _next
+        previous: Optional[NL] = None
+        for current in self.children:
+            _prev[id(current)] = previous
+            _next[id(previous)] = current
+            previous = current
+        _next[id(current)] = None
+
+
+class Leaf(Base):
+
+    """Concrete implementation for leaf nodes."""
+
+    # Default values for instance variables
+    value: Text
+    fixers_applied: List[Any]
+    bracket_depth: int
+    opening_bracket: "Leaf"
+    used_names: Optional[Set[Text]]
+    _prefix = ""  # Whitespace and comments preceding this token in the input
+    lineno: int = 0  # Line where this token starts in the input
+    column: int = 0  # Column where this token starts in the input
+
+    def __init__(
+        self,
+        type: int,
+        value: Text,
+        context: Optional[Context] = None,
+        prefix: Optional[Text] = None,
+        fixers_applied: List[Any] = [],
+    ) -> None:
+        """
+        Initializer.
+
+        Takes a type constant (a token number < 256), a string value, and an
+        optional context keyword argument.
+        """
+
+        assert 0 <= type < 256, type
+        if context is not None:
+            self._prefix, (self.lineno, self.column) = context
+        self.type = type
+        self.value = value
+        if prefix is not None:
+            self._prefix = prefix
+        self.fixers_applied: Optional[List[Any]] = fixers_applied[:]
+        self.children = []
+
+    def __repr__(self) -> str:
+        """Return a canonical string representation."""
+        from .pgen2.token import tok_name
+
+        assert self.type is not None
+        return "%s(%s, %r)" % (
+            self.__class__.__name__,
+            tok_name.get(self.type, self.type),
+            self.value,
+        )
+
+    def __str__(self) -> Text:
+        """
+        Return a pretty string representation.
+
+        This reproduces the input source exactly.
+        """
+        return self._prefix + str(self.value)
+
+    def _eq(self, other) -> bool:
+        """Compare two nodes for equality."""
+        return (self.type, self.value) == (other.type, other.value)
+
+    def clone(self) -> "Leaf":
+        assert self.type is not None
+        """Return a cloned (deep) copy of self."""
+        return Leaf(
+            self.type,
+            self.value,
+            (self.prefix, (self.lineno, self.column)),
+            fixers_applied=self.fixers_applied,
+        )
+
+    def leaves(self) -> Iterator["Leaf"]:
+        yield self
+
+    def post_order(self) -> Iterator["Leaf"]:
+        """Return a post-order iterator for the tree."""
+        yield self
+
+    def pre_order(self) -> Iterator["Leaf"]:
+        """Return a pre-order iterator for the tree."""
+        yield self
+
+    @property
+    def prefix(self) -> Text:
+        """
+        The whitespace and comments preceding this token in the input.
+        """
+        return self._prefix
+
+    @prefix.setter
+    def prefix(self, prefix) -> None:
+        self.changed()
+        self._prefix = prefix
+
+
+def convert(gr: Grammar, raw_node: RawNode) -> NL:
+    """
+    Convert raw node information to a Node or Leaf instance.
+
+    This is passed to the parser driver which calls it whenever a reduction of a
+    grammar rule produces a new complete node, so that the tree is build
+    strictly bottom-up.
+    """
+    type, value, context, children = raw_node
+    if children or type in gr.number2symbol:
+        # If there's exactly one child, return that child instead of
+        # creating a new node.
+        assert children is not None
+        if len(children) == 1:
+            return children[0]
+        return Node(type, children, context=context)
+    else:
+        return Leaf(type, value or "", context=context)
+
+
+_Results = Dict[Text, NL]
+
+
+class BasePattern(object):
+
+    """
+    A pattern is a tree matching pattern.
+
+    It looks for a specific node type (token or symbol), and
+    optionally for a specific content.
+
+    This is an abstract base class.  There are three concrete
+    subclasses:
+
+    - LeafPattern matches a single leaf node;
+    - NodePattern matches a single node (usually non-leaf);
+    - WildcardPattern matches a sequence of nodes of variable length.
+    """
+
+    # Defaults for instance variables
+    type: Optional[int]
+    type = None  # Node type (token if < 256, symbol if >= 256)
+    content: Any = None  # Optional content matching pattern
+    name: Optional[Text] = None  # Optional name used to store match in results dict
+
+    def __new__(cls, *args, **kwds):
+        """Constructor that prevents BasePattern from being instantiated."""
+        assert cls is not BasePattern, "Cannot instantiate BasePattern"
+        return object.__new__(cls)
+
+    def __repr__(self) -> Text:
+        assert self.type is not None
+        args = [type_repr(self.type), self.content, self.name]
+        while args and args[-1] is None:
+            del args[-1]
+        return "%s(%s)" % (self.__class__.__name__, ", ".join(map(repr, args)))
+
+    def _submatch(self, node, results=None) -> bool:
+        raise NotImplementedError
+
+    def optimize(self) -> "BasePattern":
+        """
+        A subclass can define this as a hook for optimizations.
+
+        Returns either self or another node with the same effect.
+        """
+        return self
+
+    def match(self, node: NL, results: Optional[_Results] = None) -> bool:
+        """
+        Does this pattern exactly match a node?
+
+        Returns True if it matches, False if not.
+
+        If results is not None, it must be a dict which will be
+        updated with the nodes matching named subpatterns.
+
+        Default implementation for non-wildcard patterns.
+        """
+        if self.type is not None and node.type != self.type:
+            return False
+        if self.content is not None:
+            r: Optional[_Results] = None
+            if results is not None:
+                r = {}
+            if not self._submatch(node, r):
+                return False
+            if r:
+                assert results is not None
+                results.update(r)
+        if results is not None and self.name:
+            results[self.name] = node
+        return True
+
+    def match_seq(self, nodes: List[NL], results: Optional[_Results] = None) -> bool:
+        """
+        Does this pattern exactly match a sequence of nodes?
+
+        Default implementation for non-wildcard patterns.
+        """
+        if len(nodes) != 1:
+            return False
+        return self.match(nodes[0], results)
+
+    def generate_matches(self, nodes: List[NL]) -> Iterator[Tuple[int, _Results]]:
+        """
+        Generator yielding all matches for this pattern.
+
+        Default implementation for non-wildcard patterns.
+        """
+        r: _Results = {}
+        if nodes and self.match(nodes[0], r):
+            yield 1, r
+
+
+class LeafPattern(BasePattern):
+    def __init__(
+        self,
+        type: Optional[int] = None,
+        content: Optional[Text] = None,
+        name: Optional[Text] = None,
+    ) -> None:
+        """
+        Initializer.  Takes optional type, content, and name.
+
+        The type, if given must be a token type (< 256).  If not given,
+        this matches any *leaf* node; the content may still be required.
+
+        The content, if given, must be a string.
+
+        If a name is given, the matching node is stored in the results
+        dict under that key.
+        """
+        if type is not None:
+            assert 0 <= type < 256, type
+        if content is not None:
+            assert isinstance(content, str), repr(content)
+        self.type = type
+        self.content = content
+        self.name = name
+
+    def match(self, node: NL, results=None):
+        """Override match() to insist on a leaf node."""
+        if not isinstance(node, Leaf):
+            return False
+        return BasePattern.match(self, node, results)
+
+    def _submatch(self, node, results=None):
+        """
+        Match the pattern's content to the node's children.
+
+        This assumes the node type matches and self.content is not None.
+
+        Returns True if it matches, False if not.
+
+        If results is not None, it must be a dict which will be
+        updated with the nodes matching named subpatterns.
+
+        When returning False, the results dict may still be updated.
+        """
+        return self.content == node.value
+
+
+class NodePattern(BasePattern):
+
+    wildcards: bool = False
+
+    def __init__(
+        self,
+        type: Optional[int] = None,
+        content: Optional[Iterable[Text]] = None,
+        name: Optional[Text] = None,
+    ) -> None:
+        """
+        Initializer.  Takes optional type, content, and name.
+
+        The type, if given, must be a symbol type (>= 256).  If the
+        type is None this matches *any* single node (leaf or not),
+        except if content is not None, in which it only matches
+        non-leaf nodes that also match the content pattern.
+
+        The content, if not None, must be a sequence of Patterns that
+        must match the node's children exactly.  If the content is
+        given, the type must not be None.
+
+        If a name is given, the matching node is stored in the results
+        dict under that key.
+        """
+        if type is not None:
+            assert type >= 256, type
+        if content is not None:
+            assert not isinstance(content, str), repr(content)
+            newcontent = list(content)
+            for i, item in enumerate(newcontent):
+                assert isinstance(item, BasePattern), (i, item)
+                # I don't even think this code is used anywhere, but it does cause
+                # unreachable errors from mypy. This function's signature does look
+                # odd though *shrug*.
+                if isinstance(item, WildcardPattern):  # type: ignore[unreachable]
+                    self.wildcards = True  # type: ignore[unreachable]
+        self.type = type
+        self.content = newcontent
+        self.name = name
+
+    def _submatch(self, node, results=None) -> bool:
+        """
+        Match the pattern's content to the node's children.
+
+        This assumes the node type matches and self.content is not None.
+
+        Returns True if it matches, False if not.
+
+        If results is not None, it must be a dict which will be
+        updated with the nodes matching named subpatterns.
+
+        When returning False, the results dict may still be updated.
+        """
+        if self.wildcards:
+            for c, r in generate_matches(self.content, node.children):
+                if c == len(node.children):
+                    if results is not None:
+                        results.update(r)
+                    return True
+            return False
+        if len(self.content) != len(node.children):
+            return False
+        for subpattern, child in zip(self.content, node.children):
+            if not subpattern.match(child, results):
+                return False
+        return True
+
+
+class WildcardPattern(BasePattern):
+
+    """
+    A wildcard pattern can match zero or more nodes.
+
+    This has all the flexibility needed to implement patterns like:
+
+    .*      .+      .?      .{m,n}
+    (a b c | d e | f)
+    (...)*  (...)+  (...)?  (...){m,n}
+
+    except it always uses non-greedy matching.
+    """
+
+    min: int
+    max: int
+
+    def __init__(
+        self,
+        content: Optional[Text] = None,
+        min: int = 0,
+        max: int = HUGE,
+        name: Optional[Text] = None,
+    ) -> None:
+        """
+        Initializer.
+
+        Args:
+            content: optional sequence of subsequences of patterns;
+                     if absent, matches one node;
+                     if present, each subsequence is an alternative [*]
+            min: optional minimum number of times to match, default 0
+            max: optional maximum number of times to match, default HUGE
+            name: optional name assigned to this match
+
+        [*] Thus, if content is [[a, b, c], [d, e], [f, g, h]] this is
+            equivalent to (a b c | d e | f g h); if content is None,
+            this is equivalent to '.' in regular expression terms.
+            The min and max parameters work as follows:
+                min=0, max=maxint: .*
+                min=1, max=maxint: .+
+                min=0, max=1: .?
+                min=1, max=1: .
+            If content is not None, replace the dot with the parenthesized
+            list of alternatives, e.g. (a b c | d e | f g h)*
+        """
+        assert 0 <= min <= max <= HUGE, (min, max)
+        if content is not None:
+            f = lambda s: tuple(s)
+            wrapped_content = tuple(map(f, content))  # Protect against alterations
+            # Check sanity of alternatives
+            assert len(wrapped_content), repr(
+                wrapped_content
+            )  # Can't have zero alternatives
+            for alt in wrapped_content:
+                assert len(alt), repr(alt)  # Can have empty alternatives
+        self.content = wrapped_content
+        self.min = min
+        self.max = max
+        self.name = name
+
+    def optimize(self) -> Any:
+        """Optimize certain stacked wildcard patterns."""
+        subpattern = None
+        if (
+            self.content is not None
+            and len(self.content) == 1
+            and len(self.content[0]) == 1
+        ):
+            subpattern = self.content[0][0]
+        if self.min == 1 and self.max == 1:
+            if self.content is None:
+                return NodePattern(name=self.name)
+            if subpattern is not None and self.name == subpattern.name:
+                return subpattern.optimize()
+        if (
+            self.min <= 1
+            and isinstance(subpattern, WildcardPattern)
+            and subpattern.min <= 1
+            and self.name == subpattern.name
+        ):
+            return WildcardPattern(
+                subpattern.content,
+                self.min * subpattern.min,
+                self.max * subpattern.max,
+                subpattern.name,
+            )
+        return self
+
+    def match(self, node, results=None) -> bool:
+        """Does this pattern exactly match a node?"""
+        return self.match_seq([node], results)
+
+    def match_seq(self, nodes, results=None) -> bool:
+        """Does this pattern exactly match a sequence of nodes?"""
+        for c, r in self.generate_matches(nodes):
+            if c == len(nodes):
+                if results is not None:
+                    results.update(r)
+                    if self.name:
+                        results[self.name] = list(nodes)
+                return True
+        return False
+
+    def generate_matches(self, nodes) -> Iterator[Tuple[int, _Results]]:
+        """
+        Generator yielding matches for a sequence of nodes.
+
+        Args:
+            nodes: sequence of nodes
+
+        Yields:
+            (count, results) tuples where:
+            count: the match comprises nodes[:count];
+            results: dict containing named submatches.
+        """
+        if self.content is None:
+            # Shortcut for special case (see __init__.__doc__)
+            for count in range(self.min, 1 + min(len(nodes), self.max)):
+                r = {}
+                if self.name:
+                    r[self.name] = nodes[:count]
+                yield count, r
+        elif self.name == "bare_name":
+            yield self._bare_name_matches(nodes)
+        else:
+            # The reason for this is that hitting the recursion limit usually
+            # results in some ugly messages about how RuntimeErrors are being
+            # ignored. We only have to do this on CPython, though, because other
+            # implementations don't have this nasty bug in the first place.
+            if hasattr(sys, "getrefcount"):
+                save_stderr = sys.stderr
+                sys.stderr = StringIO()
+            try:
+                for count, r in self._recursive_matches(nodes, 0):
+                    if self.name:
+                        r[self.name] = nodes[:count]
+                    yield count, r
+            except RuntimeError:
+                # We fall back to the iterative pattern matching scheme if the recursive
+                # scheme hits the recursion limit.
+                for count, r in self._iterative_matches(nodes):
+                    if self.name:
+                        r[self.name] = nodes[:count]
+                    yield count, r
+            finally:
+                if hasattr(sys, "getrefcount"):
+                    sys.stderr = save_stderr
+
+    def _iterative_matches(self, nodes) -> Iterator[Tuple[int, _Results]]:
+        """Helper to iteratively yield the matches."""
+        nodelen = len(nodes)
+        if 0 >= self.min:
+            yield 0, {}
+
+        results = []
+        # generate matches that use just one alt from self.content
+        for alt in self.content:
+            for c, r in generate_matches(alt, nodes):
+                yield c, r
+                results.append((c, r))
+
+        # for each match, iterate down the nodes
+        while results:
+            new_results = []
+            for c0, r0 in results:
+                # stop if the entire set of nodes has been matched
+                if c0 < nodelen and c0 <= self.max:
+                    for alt in self.content:
+                        for c1, r1 in generate_matches(alt, nodes[c0:]):
+                            if c1 > 0:
+                                r = {}
+                                r.update(r0)
+                                r.update(r1)
+                                yield c0 + c1, r
+                                new_results.append((c0 + c1, r))
+            results = new_results
+
+    def _bare_name_matches(self, nodes) -> Tuple[int, _Results]:
+        """Special optimized matcher for bare_name."""
+        count = 0
+        r = {}  # type: _Results
+        done = False
+        max = len(nodes)
+        while not done and count < max:
+            done = True
+            for leaf in self.content:
+                if leaf[0].match(nodes[count], r):
+                    count += 1
+                    done = False
+                    break
+        assert self.name is not None
+        r[self.name] = nodes[:count]
+        return count, r
+
+    def _recursive_matches(self, nodes, count) -> Iterator[Tuple[int, _Results]]:
+        """Helper to recursively yield the matches."""
+        assert self.content is not None
+        if count >= self.min:
+            yield 0, {}
+        if count < self.max:
+            for alt in self.content:
+                for c0, r0 in generate_matches(alt, nodes):
+                    for c1, r1 in self._recursive_matches(nodes[c0:], count + 1):
+                        r = {}
+                        r.update(r0)
+                        r.update(r1)
+                        yield c0 + c1, r
+
+
+class NegatedPattern(BasePattern):
+    def __init__(self, content: Optional[Any] = None) -> None:
+        """
+        Initializer.
+
+        The argument is either a pattern or None.  If it is None, this
+        only matches an empty sequence (effectively '$' in regex
+        lingo).  If it is not None, this matches whenever the argument
+        pattern doesn't have any matches.
+        """
+        if content is not None:
+            assert isinstance(content, BasePattern), repr(content)
+        self.content = content
+
+    def match(self, node, results=None) -> bool:
+        # We never match a node in its entirety
+        return False
+
+    def match_seq(self, nodes, results=None) -> bool:
+        # We only match an empty sequence of nodes in its entirety
+        return len(nodes) == 0
+
+    def generate_matches(self, nodes) -> Iterator[Tuple[int, _Results]]:
+        if self.content is None:
+            # Return a match if there is an empty sequence
+            if len(nodes) == 0:
+                yield 0, {}
+        else:
+            # Return a match if the argument pattern has no matches
+            for c, r in self.content.generate_matches(nodes):
+                return
+            yield 0, {}
+
+
+def generate_matches(
+    patterns: List[BasePattern], nodes: List[NL]
+) -> Iterator[Tuple[int, _Results]]:
+    """
+    Generator yielding matches for a sequence of patterns and nodes.
+
+    Args:
+        patterns: a sequence of patterns
+        nodes: a sequence of nodes
+
+    Yields:
+        (count, results) tuples where:
+        count: the entire sequence of patterns matches nodes[:count];
+        results: dict containing named submatches.
+    """
+    if not patterns:
+        yield 0, {}
+    else:
+        p, rest = patterns[0], patterns[1:]
+        for c0, r0 in p.generate_matches(nodes):
+            if not rest:
+                yield c0, r0
+            else:
+                for c1, r1 in generate_matches(rest, nodes[c0:]):
+                    r = {}
+                    r.update(r0)
+                    r.update(r1)
+                    yield c0 + c1, r
diff --git a/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/LICENSE
new file mode 100644
index 0000000..c2fda9a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/LICENSE
@@ -0,0 +1,21 @@
+This package contains a modified version of ca-bundle.crt:
+
+ca-bundle.crt -- Bundle of CA Root Certificates
+
+Certificate data from Mozilla as of: Thu Nov  3 19:04:19 2011#
+This is a bundle of X.509 certificates of public Certificate Authorities
+(CA). These were automatically extracted from Mozilla's root certificates
+file (certdata.txt).  This file can be found in the mozilla source tree:
+http://mxr.mozilla.org/mozilla/source/security/nss/lib/ckfw/builtins/certdata.txt?raw=1#
+It contains the certificates in PEM format and therefore
+can be directly used with curl / libcurl / php_curl, or with
+an Apache+mod_ssl webserver for SSL client authentication.
+Just configure this file as the SSLCACertificateFile.#
+
+***** BEGIN LICENSE BLOCK *****
+This Source Code Form is subject to the terms of the Mozilla Public License,
+v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain
+one at http://mozilla.org/MPL/2.0/.
+
+***** END LICENSE BLOCK *****
+@(#) $RCSfile: certdata.txt,v $ $Revision: 1.80 $ $Date: 2011/11/03 15:11:58 $
diff --git a/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/METADATA b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/METADATA
new file mode 100644
index 0000000..6f8de5d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/METADATA
@@ -0,0 +1,81 @@
+Metadata-Version: 2.1
+Name: certifi
+Version: 2022.6.15
+Summary: Python package for providing Mozilla's CA Bundle.
+Home-page: https://github.com/certifi/python-certifi
+Author: Kenneth Reitz
+Author-email: me@kennethreitz.com
+License: MPL-2.0
+Project-URL: Source, https://github.com/certifi/python-certifi
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.6
+License-File: LICENSE
+
+Certifi: Python SSL Certificates
+================================
+
+Certifi provides Mozilla's carefully curated collection of Root Certificates for
+validating the trustworthiness of SSL certificates while verifying the identity
+of TLS hosts. It has been extracted from the `Requests`_ project.
+
+Installation
+------------
+
+``certifi`` is available on PyPI. Simply install it with ``pip``::
+
+    $ pip install certifi
+
+Usage
+-----
+
+To reference the installed certificate authority (CA) bundle, you can use the
+built-in function::
+
+    >>> import certifi
+
+    >>> certifi.where()
+    '/usr/local/lib/python3.7/site-packages/certifi/cacert.pem'
+
+Or from the command line::
+
+    $ python -m certifi
+    /usr/local/lib/python3.7/site-packages/certifi/cacert.pem
+
+Enjoy!
+
+1024-bit Root Certificates
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Browsers and certificate authorities have concluded that 1024-bit keys are
+unacceptably weak for certificates, particularly root certificates. For this
+reason, Mozilla has removed any weak (i.e. 1024-bit key) certificate from its
+bundle, replacing it with an equivalent strong (i.e. 2048-bit or greater key)
+certificate from the same CA. Because Mozilla removed these certificates from
+its bundle, ``certifi`` removed them as well.
+
+In previous versions, ``certifi`` provided the ``certifi.old_where()`` function
+to intentionally re-add the 1024-bit roots back into your bundle. This was not
+recommended in production and therefore was removed at the end of 2018.
+
+.. _`Requests`: https://requests.readthedocs.io/en/master/
+
+Addition/Removal of Certificates
+--------------------------------
+
+Certifi does not support any addition/removal or other modification of the
+CA trust store content. This project is intended to provide a reliable and
+highly portable root of trust to python deployments. Look to upstream projects
+for methods to use alternate trust.
+
+
diff --git a/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/RECORD b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/RECORD
new file mode 100644
index 0000000..df832c3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/RECORD
@@ -0,0 +1,11 @@
+certifi/__init__.py,sha256=SuZ3iYmzdRyUv-PiaZkquUgXtWZ16ICUKgymlEBspx0,94
+certifi/__main__.py,sha256=xBBoj905TUWBLRGANOcf7oi6e-3dMP4cEoG9OyMs11g,243
+certifi/cacert.pem,sha256=pZ_eiDoO-ddKudrQCWieABc9KFlbV0FsmLLugygMbkw,285222
+certifi/core.py,sha256=G5LqCBr4o8bozzzlYBE8nsd_ziB6XcxJiuMV4llFeYY,2515
+certifi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+certifi-2022.6.15.dist-info/LICENSE,sha256=vp2C82ES-Hp_HXTs1Ih-FGe7roh4qEAEoAEXseR1o-I,1049
+certifi-2022.6.15.dist-info/METADATA,sha256=1sLjV7SjXkcGhJr631JUqCLCDnqgTyFoFe-tRLxakTE,2804
+certifi-2022.6.15.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+certifi-2022.6.15.dist-info/top_level.txt,sha256=KMu4vUCfsjLrkPbSNdgdekS-pVJzBAJFO__nI8NF6-U,8
+certifi-2022.6.15.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+certifi-2022.6.15.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/WHEEL
new file mode 100644
index 0000000..5bad85f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/top_level.txt
new file mode 100644
index 0000000..963eac5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/certifi-2022.6.15.dist-info/top_level.txt
@@ -0,0 +1 @@
+certifi
diff --git a/myenv/lib/python3.9/site-packages/certifi/__init__.py b/myenv/lib/python3.9/site-packages/certifi/__init__.py
new file mode 100644
index 0000000..bdeb06b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/certifi/__init__.py
@@ -0,0 +1,4 @@
+from .core import contents, where
+
+__all__ = ["contents", "where"]
+__version__ = "2022.06.15"
diff --git a/myenv/lib/python3.9/site-packages/certifi/__main__.py b/myenv/lib/python3.9/site-packages/certifi/__main__.py
new file mode 100644
index 0000000..8945b5d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/certifi/__main__.py
@@ -0,0 +1,12 @@
+import argparse
+
+from certifi import contents, where
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-c", "--contents", action="store_true")
+args = parser.parse_args()
+
+if args.contents:
+    print(contents())
+else:
+    print(where())
diff --git a/myenv/lib/python3.9/site-packages/certifi/cacert.pem b/myenv/lib/python3.9/site-packages/certifi/cacert.pem
new file mode 100644
index 0000000..ee9be4c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/certifi/cacert.pem
@@ -0,0 +1,4685 @@
+
+# Issuer: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
+# Subject: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
+# Label: "GlobalSign Root CA"
+# Serial: 4835703278459707669005204
+# MD5 Fingerprint: 3e:45:52:15:09:51:92:e1:b7:5d:37:9f:b1:87:29:8a
+# SHA1 Fingerprint: b1:bc:96:8b:d4:f4:9d:62:2a:a8:9a:81:f2:15:01:52:a4:1d:82:9c
+# SHA256 Fingerprint: eb:d4:10:40:e4:bb:3e:c7:42:c9:e3:81:d3:1e:f2:a4:1a:48:b6:68:5c:96:e7:ce:f3:c1:df:6c:d4:33:1c:99
+-----BEGIN CERTIFICATE-----
+MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG
+A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv
+b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw
+MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i
+YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT
+aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ
+jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp
+xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp
+1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG
+snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ
+U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8
+9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B
+AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz
+yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE
+38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP
+AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad
+DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME
+HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
+# Subject: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
+# Label: "Entrust.net Premium 2048 Secure Server CA"
+# Serial: 946069240
+# MD5 Fingerprint: ee:29:31:bc:32:7e:9a:e6:e8:b5:f7:51:b4:34:71:90
+# SHA1 Fingerprint: 50:30:06:09:1d:97:d4:f5:ae:39:f7:cb:e7:92:7d:7d:65:2d:34:31
+# SHA256 Fingerprint: 6d:c4:71:72:e0:1c:bc:b0:bf:62:58:0d:89:5f:e2:b8:ac:9a:d4:f8:73:80:1e:0c:10:b9:c8:37:d2:1e:b1:77
+-----BEGIN CERTIFICATE-----
+MIIEKjCCAxKgAwIBAgIEOGPe+DANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML
+RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp
+bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5
+IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp
+ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0yOTA3
+MjQxNDE1MTJaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3
+LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp
+YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG
+A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq
+K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe
+sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX
+MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT
+XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/
+HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH
+4QIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQUVeSB0RGAvtiJuQijMfmhJAkWuXAwDQYJKoZIhvcNAQEFBQADggEBADub
+j1abMOdTmXx6eadNl9cZlZD7Bh/KM3xGY4+WZiT6QBshJ8rmcnPyT/4xmf3IDExo
+U8aAghOY+rat2l098c5u9hURlIIM7j+VrxGrD9cv3h8Dj1csHsm7mhpElesYT6Yf
+zX1XEC+bBAlahLVu2B064dae0Wx5XnkcFMXj0EyTO2U87d89vqbllRrDtRnDvV5b
+u/8j72gZyxKTJ1wDLW8w0B62GqzeWvfRqqgnpv55gcR5mTNXuhKwqeBCbJPKVt7+
+bYQLCIt+jerXmCHG8+c8eS9enNFMFY3h7CI3zJpDC5fcgJCNs2ebb0gIFVbPv/Er
+fF6adulZkMV8gzURZVE=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
+# Subject: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
+# Label: "Baltimore CyberTrust Root"
+# Serial: 33554617
+# MD5 Fingerprint: ac:b6:94:a5:9c:17:e0:d7:91:52:9b:b1:97:06:a6:e4
+# SHA1 Fingerprint: d4:de:20:d0:5e:66:fc:53:fe:1a:50:88:2c:78:db:28:52:ca:e4:74
+# SHA256 Fingerprint: 16:af:57:a9:f6:76:b0:ab:12:60:95:aa:5e:ba:de:f2:2a:b3:11:19:d6:44:ac:95:cd:4b:93:db:f3:f2:6a:eb
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ
+RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD
+VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX
+DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y
+ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy
+VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr
+mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr
+IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK
+mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu
+XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy
+dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye
+jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1
+BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3
+DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92
+9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx
+jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0
+Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz
+ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS
+R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
+# Subject: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
+# Label: "Entrust Root Certification Authority"
+# Serial: 1164660820
+# MD5 Fingerprint: d6:a5:c3:ed:5d:dd:3e:00:c1:3d:87:92:1f:1d:3f:e4
+# SHA1 Fingerprint: b3:1e:b1:b7:40:e3:6c:84:02:da:dc:37:d4:4d:f5:d4:67:49:52:f9
+# SHA256 Fingerprint: 73:c1:76:43:4f:1b:c6:d5:ad:f4:5b:0e:76:e7:27:28:7c:8d:e5:76:16:c1:e6:e6:14:1a:2b:2c:bc:7d:8e:4c
+-----BEGIN CERTIFICATE-----
+MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC
+VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0
+Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW
+KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl
+cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw
+NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw
+NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy
+ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV
+BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ
+KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo
+Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4
+4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9
+KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI
+rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi
+94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB
+sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi
+gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo
+kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE
+vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA
+A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t
+O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua
+AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP
+9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/
+eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m
+0vdXcDazv/wor3ElhVsT/h5/WrQ8
+-----END CERTIFICATE-----
+
+# Issuer: CN=AAA Certificate Services O=Comodo CA Limited
+# Subject: CN=AAA Certificate Services O=Comodo CA Limited
+# Label: "Comodo AAA Services root"
+# Serial: 1
+# MD5 Fingerprint: 49:79:04:b0:eb:87:19:ac:47:b0:bc:11:51:9b:74:d0
+# SHA1 Fingerprint: d1:eb:23:a4:6d:17:d6:8f:d9:25:64:c2:f1:f1:60:17:64:d8:e3:49
+# SHA256 Fingerprint: d7:a7:a0:fb:5d:7e:27:31:d7:71:e9:48:4e:bc:de:f7:1d:5f:0c:3e:0a:29:48:78:2b:c8:3e:e0:ea:69:9e:f4
+-----BEGIN CERTIFICATE-----
+MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb
+MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
+GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj
+YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL
+MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
+BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM
+GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP
+ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua
+BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe
+3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4
+YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR
+rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm
+ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU
+oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF
+MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v
+QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t
+b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF
+AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q
+GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz
+Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2
+G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi
+l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3
+smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 2 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 2 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 2"
+# Serial: 1289
+# MD5 Fingerprint: 5e:39:7b:dd:f8:ba:ec:82:e9:ac:62:ba:0c:54:00:2b
+# SHA1 Fingerprint: ca:3a:fb:cf:12:40:36:4b:44:b2:16:20:88:80:48:39:19:93:7c:f7
+# SHA256 Fingerprint: 85:a0:dd:7d:d7:20:ad:b7:ff:05:f8:3d:54:2b:20:9d:c7:ff:45:28:f7:d6:77:b1:83:89:fe:a5:e5:c4:9e:86
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 3"
+# Serial: 1478
+# MD5 Fingerprint: 31:85:3c:62:94:97:63:b9:aa:fd:89:4e:af:6f:e0:cf
+# SHA1 Fingerprint: 1f:49:14:f7:d8:74:95:1d:dd:ae:02:c0:be:fd:3a:2d:82:75:51:85
+# SHA256 Fingerprint: 18:f1:fc:7f:20:5d:f8:ad:dd:eb:7f:e0:07:dd:57:e3:af:37:5a:9c:4d:8d:73:54:6b:f4:f1:fe:d1:e1:8d:35
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: O=SECOM Trust.net OU=Security Communication RootCA1
+# Subject: O=SECOM Trust.net OU=Security Communication RootCA1
+# Label: "Security Communication Root CA"
+# Serial: 0
+# MD5 Fingerprint: f1:bc:63:6a:54:e0:b5:27:f5:cd:e7:1a:e3:4d:6e:4a
+# SHA1 Fingerprint: 36:b1:2b:49:f9:81:9e:d7:4c:9e:bc:38:0f:c6:56:8f:5d:ac:b2:f7
+# SHA256 Fingerprint: e7:5e:72:ed:9f:56:0e:ec:6e:b4:80:00:73:a4:3f:c3:ad:19:19:5a:39:22:82:01:78:95:97:4a:99:02:6b:6c
+-----BEGIN CERTIFICATE-----
+MIIDWjCCAkKgAwIBAgIBADANBgkqhkiG9w0BAQUFADBQMQswCQYDVQQGEwJKUDEY
+MBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYDVQQLEx5TZWN1cml0eSBDb21t
+dW5pY2F0aW9uIFJvb3RDQTEwHhcNMDMwOTMwMDQyMDQ5WhcNMjMwOTMwMDQyMDQ5
+WjBQMQswCQYDVQQGEwJKUDEYMBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYD
+VQQLEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTEwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQCzs/5/022x7xZ8V6UMbXaKL0u/ZPtM7orw8yl8
+9f/uKuDp6bpbZCKamm8sOiZpUQWZJtzVHGpxxpp9Hp3dfGzGjGdnSj74cbAZJ6kJ
+DKaVv0uMDPpVmDvY6CKhS3E4eayXkmmziX7qIWgGmBSWh9JhNrxtJ1aeV+7AwFb9
+Ms+k2Y7CI9eNqPPYJayX5HA49LY6tJ07lyZDo6G8SVlyTCMwhwFY9k6+HGhWZq/N
+QV3Is00qVUarH9oe4kA92819uZKAnDfdDJZkndwi92SL32HeFZRSFaB9UslLqCHJ
+xrHty8OVYNEP8Ktw+N/LTX7s1vqr2b1/VPKl6Xn62dZ2JChzAgMBAAGjPzA9MB0G
+A1UdDgQWBBSgc0mZaNyFW2XjmygvV5+9M7wHSDALBgNVHQ8EBAMCAQYwDwYDVR0T
+AQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAaECpqLvkT115swW1F7NgE+vG
+kl3g0dNq/vu+m22/xwVtWSDEHPC32oRYAmP6SBbvT6UL90qY8j+eG61Ha2POCEfr
+Uj94nK9NrvjVT8+amCoQQTlSxN3Zmw7vkwGusi7KaEIkQmywszo+zenaSMQVy+n5
+Bw+SUEmK3TGXX8npN6o7WWWXlDLJs58+OmJYxUmtYg5xpTKqL8aJdkNAExNnPaJU
+JRDL8Try2frbSVa7pv6nQTXD4IhhyYjH3zYQIphZ6rBK+1YWc26sTfcioU+tHXot
+RSflMMFe8toTyyVCUZVHA4xsIcx0Qu1T/zOLjw9XARYvz6buyXAiFL39vmwLAw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
+# Subject: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
+# Label: "XRamp Global CA Root"
+# Serial: 107108908803651509692980124233745014957
+# MD5 Fingerprint: a1:0b:44:b3:ca:10:d8:00:6e:9d:0f:d8:0f:92:0a:d1
+# SHA1 Fingerprint: b8:01:86:d1:eb:9c:86:a5:41:04:cf:30:54:f3:4c:52:b7:e5:58:c6
+# SHA256 Fingerprint: ce:cd:dc:90:50:99:d8:da:df:c5:b1:d2:09:b7:37:cb:e2:c1:8c:fb:2c:10:c0:ff:0b:cf:0d:32:86:fc:1a:a2
+-----BEGIN CERTIFICATE-----
+MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB
+gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk
+MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY
+UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx
+NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3
+dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy
+dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB
+dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6
+38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP
+KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q
+DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4
+qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa
+JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi
+PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P
+BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs
+jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0
+eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD
+ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR
+vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt
+qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa
+IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy
+i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ
+O+7ETPTsJ3xCwnR8gooJybQDJbw=
+-----END CERTIFICATE-----
+
+# Issuer: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
+# Subject: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
+# Label: "Go Daddy Class 2 CA"
+# Serial: 0
+# MD5 Fingerprint: 91:de:06:25:ab:da:fd:32:17:0c:bb:25:17:2a:84:67
+# SHA1 Fingerprint: 27:96:ba:e6:3f:18:01:e2:77:26:1b:a0:d7:77:70:02:8f:20:ee:e4
+# SHA256 Fingerprint: c3:84:6b:f2:4b:9e:93:ca:64:27:4c:0e:c6:7c:1e:cc:5e:02:4f:fc:ac:d2:d7:40:19:35:0e:81:fe:54:6a:e4
+-----BEGIN CERTIFICATE-----
+MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh
+MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE
+YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3
+MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo
+ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg
+MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN
+ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA
+PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w
+wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi
+EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY
+avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+
+YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE
+sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h
+/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5
+IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj
+YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD
+ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy
+OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P
+TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ
+HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER
+dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf
+ReYNnyicsbkqWletNw+vHX/bvZ8=
+-----END CERTIFICATE-----
+
+# Issuer: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
+# Subject: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
+# Label: "Starfield Class 2 CA"
+# Serial: 0
+# MD5 Fingerprint: 32:4a:4b:bb:c8:63:69:9b:be:74:9a:c6:dd:1d:46:24
+# SHA1 Fingerprint: ad:7e:1c:28:b0:64:ef:8f:60:03:40:20:14:c3:d0:e3:37:0e:b5:8a
+# SHA256 Fingerprint: 14:65:fa:20:53:97:b8:76:fa:a6:f0:a9:95:8e:55:90:e4:0f:cc:7f:aa:4f:b7:c2:c8:67:75:21:fb:5f:b6:58
+-----BEGIN CERTIFICATE-----
+MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl
+MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp
+U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw
+NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE
+ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp
+ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3
+DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf
+8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN
++lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0
+X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa
+K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA
+1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G
+A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR
+zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0
+YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD
+bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w
+DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3
+L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D
+eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl
+xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp
+VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY
+WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q=
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root CA"
+# Serial: 17154717934120587862167794914071425081
+# MD5 Fingerprint: 87:ce:0b:7b:2a:0e:49:00:e1:58:71:9b:37:a8:93:72
+# SHA1 Fingerprint: 05:63:b8:63:0d:62:d7:5a:bb:c8:ab:1e:4b:df:b5:a8:99:b2:4d:43
+# SHA256 Fingerprint: 3e:90:99:b5:01:5e:8f:48:6c:00:bc:ea:9d:11:1e:e7:21:fa:ba:35:5a:89:bc:f1:df:69:56:1e:3d:c6:32:5c
+-----BEGIN CERTIFICATE-----
+MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
+b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
+cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi
+MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c
+JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP
+mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+
+wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4
+VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/
+AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB
+AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
+BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun
+pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC
+dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf
+fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm
+NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx
+H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe
++o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root CA"
+# Serial: 10944719598952040374951832963794454346
+# MD5 Fingerprint: 79:e4:a9:84:0d:7d:3a:96:d7:c0:4f:e2:43:4c:89:2e
+# SHA1 Fingerprint: a8:98:5d:3a:65:e5:e5:c4:b2:d7:d6:6d:40:c6:dd:2f:b1:9c:54:36
+# SHA256 Fingerprint: 43:48:a0:e9:44:4c:78:cb:26:5e:05:8d:5e:89:44:b4:d8:4f:96:62:bd:26:db:25:7f:89:34:a4:43:c7:01:61
+-----BEGIN CERTIFICATE-----
+MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD
+QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT
+MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
+b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB
+CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97
+nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt
+43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P
+T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4
+gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO
+BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR
+TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw
+DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr
+hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg
+06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF
+PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls
+YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk
+CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert High Assurance EV Root CA"
+# Serial: 3553400076410547919724730734378100087
+# MD5 Fingerprint: d4:74:de:57:5c:39:b2:d3:9c:85:83:c5:c0:65:49:8a
+# SHA1 Fingerprint: 5f:b7:ee:06:33:e2:59:db:ad:0c:4c:9a:e6:d3:8f:1a:61:c7:dc:25
+# SHA256 Fingerprint: 74:31:e5:f4:c3:c1:ce:46:90:77:4f:0b:61:e0:54:40:88:3b:a9:a0:1e:d0:0b:a6:ab:d7:80:6e:d3:b1:18:cf
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j
+ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL
+MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3
+LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug
+RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm
++9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW
+PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM
+xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB
+Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3
+hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg
+EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA
+FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec
+nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z
+eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF
+hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2
+Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe
+vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep
++OkuE6N36B9K
+-----END CERTIFICATE-----
+
+# Issuer: CN=SwissSign Gold CA - G2 O=SwissSign AG
+# Subject: CN=SwissSign Gold CA - G2 O=SwissSign AG
+# Label: "SwissSign Gold CA - G2"
+# Serial: 13492815561806991280
+# MD5 Fingerprint: 24:77:d9:a8:91:d1:3b:fa:88:2d:c2:ff:f8:cd:33:93
+# SHA1 Fingerprint: d8:c5:38:8a:b7:30:1b:1b:6e:d4:7a:e6:45:25:3a:6f:9f:1a:27:61
+# SHA256 Fingerprint: 62:dd:0b:e9:b9:f5:0a:16:3e:a0:f8:e7:5c:05:3b:1e:ca:57:ea:55:c8:68:8f:64:7c:68:81:f2:c8:35:7b:95
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SwissSign Silver CA - G2 O=SwissSign AG
+# Subject: CN=SwissSign Silver CA - G2 O=SwissSign AG
+# Label: "SwissSign Silver CA - G2"
+# Serial: 5700383053117599563
+# MD5 Fingerprint: e0:06:a1:c9:7d:cf:c9:fc:0d:c0:56:75:96:d8:62:13
+# SHA1 Fingerprint: 9b:aa:e5:9f:56:ee:21:cb:43:5a:be:25:93:df:a7:f0:40:d1:1d:cb
+# SHA256 Fingerprint: be:6c:4d:a2:bb:b9:ba:59:b6:f3:93:97:68:37:42:46:c3:c0:05:99:3f:a9:8f:02:0d:1d:ed:be:d4:8a:81:d5
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SecureTrust CA O=SecureTrust Corporation
+# Subject: CN=SecureTrust CA O=SecureTrust Corporation
+# Label: "SecureTrust CA"
+# Serial: 17199774589125277788362757014266862032
+# MD5 Fingerprint: dc:32:c3:a7:6d:25:57:c7:68:09:9d:ea:2d:a9:a2:d1
+# SHA1 Fingerprint: 87:82:c6:c3:04:35:3b:cf:d2:96:92:d2:59:3e:7d:44:d9:34:ff:11
+# SHA256 Fingerprint: f1:c1:b5:0a:e5:a2:0d:d8:03:0e:c9:f6:bc:24:82:3d:d3:67:b5:25:57:59:b4:e7:1b:61:fc:e9:f7:37:5d:73
+-----BEGIN CERTIFICATE-----
+MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI
+MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
+FzAVBgNVBAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIz
+MTE5NDA1NVowSDELMAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENv
+cnBvcmF0aW9uMRcwFQYDVQQDEw5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcN
+AQEBBQADggEPADCCAQoCggEBAKukgeWVzfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEz
+Zum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6pkjGnx29vo6pQT64lO0pGtSO
+0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgUXPLIXgGZbf2IzIao
+wW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPeZqx2pHGj
+7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS
+8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjAT
+BgkrBgEEAYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQUQjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCeg
+JYYjaHR0cDovL2NybC5zZWN1cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGC
+NxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBADDtT0rhWDpSclu1pqNlGKa7UTt3
+6Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+DCMh/bwQf2AQWnL1mA6s7Ll/
+3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr5Fiiu1cprp6poxkm
+D5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUFdAvnZyPS
+CPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR
+3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jE=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Secure Global CA O=SecureTrust Corporation
+# Subject: CN=Secure Global CA O=SecureTrust Corporation
+# Label: "Secure Global CA"
+# Serial: 9751836167731051554232119481456978597
+# MD5 Fingerprint: cf:f4:27:0d:d4:ed:dc:65:16:49:6d:3d:da:bf:6e:de
+# SHA1 Fingerprint: 3a:44:73:5a:e5:81:90:1f:24:86:61:46:1e:3b:9c:c4:5f:f5:3a:1b
+# SHA256 Fingerprint: 42:00:f5:04:3a:c8:59:0e:bb:52:7d:20:9e:d1:50:30:29:fb:cb:d4:1c:a1:b5:06:ec:27:f1:5a:de:7d:ac:69
+-----BEGIN CERTIFICATE-----
+MIIDvDCCAqSgAwIBAgIQB1YipOjUiolN9BPI8PjqpTANBgkqhkiG9w0BAQUFADBK
+MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
+GTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwHhcNMDYxMTA3MTk0MjI4WhcNMjkx
+MjMxMTk1MjA2WjBKMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3Qg
+Q29ycG9yYXRpb24xGTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvNS7YrGxVaQZx5RNoJLNP2MwhR/jxYDiJ
+iQPpvepeRlMJ3Fz1Wuj3RSoC6zFh1ykzTM7HfAo3fg+6MpjhHZevj8fcyTiW89sa
+/FHtaMbQbqR8JNGuQsiWUGMu4P51/pinX0kuleM5M2SOHqRfkNJnPLLZ/kG5VacJ
+jnIFHovdRIWCQtBJwB1g8NEXLJXr9qXBkqPFwqcIYA1gBBCWeZ4WNOaptvolRTnI
+HmX5k/Wq8VLcmZg9pYYaDDUz+kulBAYVHDGA76oYa8J719rO+TMg1fW9ajMtgQT7
+sFzUnKPiXB3jqUJ1XnvUd+85VLrJChgbEplJL4hL/VBi0XPnj3pDAgMBAAGjgZ0w
+gZowEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFK9EBMJBfkiD2045AuzshHrmzsmkMDQGA1UdHwQtMCsw
+KaAnoCWGI2h0dHA6Ly9jcmwuc2VjdXJldHJ1c3QuY29tL1NHQ0EuY3JsMBAGCSsG
+AQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IBAQBjGghAfaReUw132HquHw0L
+URYD7xh8yOOvaliTFGCRsoTciE6+OYo68+aCiV0BN7OrJKQVDpI1WkpEXk5X+nXO
+H0jOZvQ8QCaSmGwb7iRGDBezUqXbpZGRzzfTb+cnCDpOGR86p1hcF895P4vkp9Mm
+I50mD1hp/Ed+stCNi5O/KU9DaXR2Z0vPB4zmAve14bRDtUstFJ/53CYNv6ZHdAbY
+iNE6KTCEztI5gGIbqMdXSbxqVVFnFUq+NQfk1XWYN3kwFNspnWzFacxHVaIw98xc
+f8LDmBxrThaA63p4ZUWiABqvDA1VZDRIuJK58bRQKfJPIx/abKwfROHdI3hRW8cW
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO Certification Authority O=COMODO CA Limited
+# Label: "COMODO Certification Authority"
+# Serial: 104350513648249232941998508985834464573
+# MD5 Fingerprint: 5c:48:dc:f7:42:72:ec:56:94:6d:1c:cc:71:35:80:75
+# SHA1 Fingerprint: 66:31:bf:9e:f7:4f:9e:b6:c9:d5:a6:0c:ba:6a:be:d1:f7:bd:ef:7b
+# SHA256 Fingerprint: 0c:2c:d6:3d:f7:80:6f:a3:99:ed:e8:09:11:6b:57:5b:f8:79:89:f0:65:18:f9:80:8c:86:05:03:17:8b:af:66
+-----BEGIN CERTIFICATE-----
+MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB
+gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G
+A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV
+BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw
+MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl
+YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P
+RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0
+aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3
+UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI
+2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8
+Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp
++2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+
+DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O
+nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW
+/zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g
+PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u
+QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY
+SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv
+IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/
+RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4
+zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd
+BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB
+ZQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C.
+# Subject: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C.
+# Label: "Network Solutions Certificate Authority"
+# Serial: 116697915152937497490437556386812487904
+# MD5 Fingerprint: d3:f3:a6:16:c0:fa:6b:1d:59:b1:2d:96:4d:0e:11:2e
+# SHA1 Fingerprint: 74:f8:a3:c3:ef:e7:b3:90:06:4b:83:90:3c:21:64:60:20:e5:df:ce
+# SHA256 Fingerprint: 15:f0:ba:00:a3:ac:7a:f3:ac:88:4c:07:2b:10:11:a0:77:bd:77:c0:97:f4:01:64:b2:f8:59:8a:bd:83:86:0c
+-----BEGIN CERTIFICATE-----
+MIID5jCCAs6gAwIBAgIQV8szb8JcFuZHFhfjkDFo4DANBgkqhkiG9w0BAQUFADBi
+MQswCQYDVQQGEwJVUzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMu
+MTAwLgYDVQQDEydOZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3Jp
+dHkwHhcNMDYxMjAxMDAwMDAwWhcNMjkxMjMxMjM1OTU5WjBiMQswCQYDVQQGEwJV
+UzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMuMTAwLgYDVQQDEydO
+ZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDkvH6SMG3G2I4rC7xGzuAnlt7e+foS0zwz
+c7MEL7xxjOWftiJgPl9dzgn/ggwbmlFQGiaJ3dVhXRncEg8tCqJDXRfQNJIg6nPP
+OCwGJgl6cvf6UDL4wpPTaaIjzkGxzOTVHzbRijr4jGPiFFlp7Q3Tf2vouAPlT2rl
+mGNpSAW+Lv8ztumXWWn4Zxmuk2GWRBXTcrA/vGp97Eh/jcOrqnErU2lBUzS1sLnF
+BgrEsEX1QV1uiUV7PTsmjHTC5dLRfbIR1PtYMiKagMnc/Qzpf14Dl847ABSHJ3A4
+qY5usyd2mFHgBeMhqxrVhSI8KbWaFsWAqPS7azCPL0YCorEMIuDTAgMBAAGjgZcw
+gZQwHQYDVR0OBBYEFCEwyfsA106Y2oeqKtCnLrFAMadMMA4GA1UdDwEB/wQEAwIB
+BjAPBgNVHRMBAf8EBTADAQH/MFIGA1UdHwRLMEkwR6BFoEOGQWh0dHA6Ly9jcmwu
+bmV0c29sc3NsLmNvbS9OZXR3b3JrU29sdXRpb25zQ2VydGlmaWNhdGVBdXRob3Jp
+dHkuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQC7rkvnt1frf6ott3NHhWrB5KUd5Oc8
+6fRZZXe1eltajSU24HqXLjjAV2CDmAaDn7l2em5Q4LqILPxFzBiwmZVRDuwduIj/
+h1AcgsLj4DKAv6ALR8jDMe+ZZzKATxcheQxpXN5eNK4CtSbqUN9/GGUsyfJj4akH
+/nxxH2szJGoeBfcFaMBqEssuXmHLrijTfsK0ZpEmXzwuJF/LWA/rKOyvEZbz3Htv
+wKeI8lN3s2Berq4o2jUsbzRF0ybh3uxbTydrFny9RAQYgrOJeRcQcT16ohZO9QHN
+pGxlaKFJdlxDydi8NmdspZS11My5vWo1ViHe2MPr+8ukYEywVaCge1ey
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO ECC Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO ECC Certification Authority O=COMODO CA Limited
+# Label: "COMODO ECC Certification Authority"
+# Serial: 41578283867086692638256921589707938090
+# MD5 Fingerprint: 7c:62:ff:74:9d:31:53:5e:68:4a:d5:78:aa:1e:bf:23
+# SHA1 Fingerprint: 9f:74:4e:9f:2b:4d:ba:ec:0f:31:2c:50:b6:56:3b:8e:2d:93:c3:11
+# SHA256 Fingerprint: 17:93:92:7a:06:14:54:97:89:ad:ce:2f:8f:34:f7:f0:b6:6d:0f:3a:e3:a3:b8:4d:21:ec:15:db:ba:4f:ad:c7
+-----BEGIN CERTIFICATE-----
+MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL
+MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
+BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT
+IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw
+MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy
+ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N
+T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv
+biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR
+FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J
+cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW
+BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
+BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm
+fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv
+GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certigna O=Dhimyotis
+# Subject: CN=Certigna O=Dhimyotis
+# Label: "Certigna"
+# Serial: 18364802974209362175
+# MD5 Fingerprint: ab:57:a6:5b:7d:42:82:19:b5:d8:58:26:28:5e:fd:ff
+# SHA1 Fingerprint: b1:2e:13:63:45:86:a4:6f:1a:b2:60:68:37:58:2d:c4:ac:fd:94:97
+# SHA256 Fingerprint: e3:b6:a2:db:2e:d7:ce:48:84:2f:7a:c5:32:41:c7:b7:1d:54:14:4b:fb:40:c1:1f:3f:1d:0b:42:f5:ee:a1:2d
+-----BEGIN CERTIFICATE-----
+MIIDqDCCApCgAwIBAgIJAP7c4wEPyUj/MA0GCSqGSIb3DQEBBQUAMDQxCzAJBgNV
+BAYTAkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hMB4X
+DTA3MDYyOTE1MTMwNVoXDTI3MDYyOTE1MTMwNVowNDELMAkGA1UEBhMCRlIxEjAQ
+BgNVBAoMCURoaW15b3RpczERMA8GA1UEAwwIQ2VydGlnbmEwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQDIaPHJ1tazNHUmgh7stL7qXOEm7RFHYeGifBZ4
+QCHkYJ5ayGPhxLGWkv8YbWkj4Sti993iNi+RB7lIzw7sebYs5zRLcAglozyHGxny
+gQcPOJAZ0xH+hrTy0V4eHpbNgGzOOzGTtvKg0KmVEn2lmsxryIRWijOp5yIVUxbw
+zBfsV1/pogqYCd7jX5xv3EjjhQsVWqa6n6xI4wmy9/Qy3l40vhx4XUJbzg4ij02Q
+130yGLMLLGq/jj8UEYkgDncUtT2UCIf3JR7VsmAA7G8qKCVuKj4YYxclPz5EIBb2
+JsglrgVKtOdjLPOMFlN+XPsRGgjBRmKfIrjxwo1p3Po6WAbfAgMBAAGjgbwwgbkw
+DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGu3+QTmQtCRZvgHyUtVF9lo53BEw
+ZAYDVR0jBF0wW4AUGu3+QTmQtCRZvgHyUtVF9lo53BGhOKQ2MDQxCzAJBgNVBAYT
+AkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hggkA/tzj
+AQ/JSP8wDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIABzANBgkqhkiG
+9w0BAQUFAAOCAQEAhQMeknH2Qq/ho2Ge6/PAD/Kl1NqV5ta+aDY9fm4fTIrv0Q8h
+bV6lUmPOEvjvKtpv6zf+EwLHyzs+ImvaYS5/1HI93TDhHkxAGYwP15zRgzB7mFnc
+fca5DClMoTOi62c6ZYTTluLtdkVwj7Ur3vkj1kluPBS1xp81HlDQwY9qcEQCYsuu
+HWhBp6pX6FOqB9IG9tUUBguRA3UsbHK1YZWaDYu5Def131TN3ubY1gkIl2PlwS6w
+t0QmwCbAr1UwnjvVNioZBPRcHv/PLLf/0P2HQBHVESO7SMAhqaQoLf0V+LBOK/Qw
+WyH8EZE0vkHve52Xdf+XlcCWWC/qu0bXu+TZLg==
+-----END CERTIFICATE-----
+
+# Issuer: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority
+# Subject: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority
+# Label: "ePKI Root Certification Authority"
+# Serial: 28956088682735189655030529057352760477
+# MD5 Fingerprint: 1b:2e:00:ca:26:06:90:3d:ad:fe:6f:15:68:d3:6b:b3
+# SHA1 Fingerprint: 67:65:0d:f1:7e:8e:7e:5b:82:40:a4:f4:56:4b:cf:e2:3d:69:c6:f0
+# SHA256 Fingerprint: c0:a6:f4:dc:63:a2:4b:fd:cf:54:ef:2a:6a:08:2a:0a:72:de:35:80:3e:2f:f5:ff:52:7a:e5:d8:72:06:df:d5
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: O=certSIGN OU=certSIGN ROOT CA
+# Subject: O=certSIGN OU=certSIGN ROOT CA
+# Label: "certSIGN ROOT CA"
+# Serial: 35210227249154
+# MD5 Fingerprint: 18:98:c0:d6:e9:3a:fc:f9:b0:f5:0c:f7:4b:01:44:17
+# SHA1 Fingerprint: fa:b7:ee:36:97:26:62:fb:2d:b0:2a:f6:bf:03:fd:e8:7c:4b:2f:9b
+# SHA256 Fingerprint: ea:a9:62:c4:fa:4a:6b:af:eb:e4:15:19:6d:35:1c:cd:88:8d:4f:53:f3:fa:8a:e6:d7:c4:66:a9:4e:60:42:bb
+-----BEGIN CERTIFICATE-----
+MIIDODCCAiCgAwIBAgIGIAYFFnACMA0GCSqGSIb3DQEBBQUAMDsxCzAJBgNVBAYT
+AlJPMREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBD
+QTAeFw0wNjA3MDQxNzIwMDRaFw0zMTA3MDQxNzIwMDRaMDsxCzAJBgNVBAYTAlJP
+MREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBDQTCC
+ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALczuX7IJUqOtdu0KBuqV5Do
+0SLTZLrTk+jUrIZhQGpgV2hUhE28alQCBf/fm5oqrl0Hj0rDKH/v+yv6efHHrfAQ
+UySQi2bJqIirr1qjAOm+ukbuW3N7LBeCgV5iLKECZbO9xSsAfsT8AzNXDe3i+s5d
+RdY4zTW2ssHQnIFKquSyAVwdj1+ZxLGt24gh65AIgoDzMKND5pCCrlUoSe1b16kQ
+OA7+j0xbm0bqQfWwCHTD0IgztnzXdN/chNFDDnU5oSVAKOp4yw4sLjmdjItuFhwv
+JoIQ4uNllAoEwF73XVv4EOLQunpL+943AAAaWyjj0pxzPjKHmKHJUS/X3qwzs08C
+AwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0O
+BBYEFOCMm9slSbPxfIbWskKHC9BroNnkMA0GCSqGSIb3DQEBBQUAA4IBAQA+0hyJ
+LjX8+HXd5n9liPRyTMks1zJO890ZeUe9jjtbkw9QSSQTaxQGcu8J06Gh40CEyecY
+MnQ8SG4Pn0vU9x7Tk4ZkVJdjclDVVc/6IJMCopvDI5NOFlV2oHB5bc0hH88vLbwZ
+44gx+FkagQnIl6Z0x2DEW8xXjrJ1/RsCCdtZb3KTafcxQdaIOL+Hsr0Wefmq5L6I
+Jd1hJyMctTEHBDa0GpC9oHRxUIltvBTjD4au8as+x6AJzKNI0eDbZOeStc+vckNw
+i/nDhDwTqn6Sm1dTk/pwwpEOMfmbZ13pljheX7NzTogVZ96edhBiIL5VaZVDADlN
+9u6wWk5JRFRYX0KD
+-----END CERTIFICATE-----
+
+# Issuer: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services)
+# Subject: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services)
+# Label: "NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny"
+# Serial: 80544274841616
+# MD5 Fingerprint: c5:a1:b7:ff:73:dd:d6:d7:34:32:18:df:fc:3c:ad:88
+# SHA1 Fingerprint: 06:08:3f:59:3f:15:a1:04:a0:69:a4:6b:a9:03:d0:06:b7:97:09:91
+# SHA256 Fingerprint: 6c:61:da:c3:a2:de:f0:31:50:6b:e0:36:d2:a6:fe:40:19:94:fb:d1:3d:f9:c8:d4:66:59:92:74:c4:46:ec:98
+-----BEGIN CERTIFICATE-----
+MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQG
+EwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3
+MDUGA1UECwwuVGFuw7pzw610dsOhbnlraWFkw7NrIChDZXJ0aWZpY2F0aW9uIFNl
+cnZpY2VzKTE1MDMGA1UEAwwsTmV0TG9jayBBcmFueSAoQ2xhc3MgR29sZCkgRsWR
+dGFuw7pzw610dsOhbnkwHhcNMDgxMjExMTUwODIxWhcNMjgxMjA2MTUwODIxWjCB
+pzELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRUwEwYDVQQKDAxOZXRM
+b2NrIEtmdC4xNzA1BgNVBAsMLlRhbsO6c8OtdHbDoW55a2lhZMOzayAoQ2VydGlm
+aWNhdGlvbiBTZXJ2aWNlcykxNTAzBgNVBAMMLE5ldExvY2sgQXJhbnkgKENsYXNz
+IEdvbGQpIEbFkXRhbsO6c8OtdHbDoW55MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
+MIIBCgKCAQEAxCRec75LbRTDofTjl5Bu0jBFHjzuZ9lk4BqKf8owyoPjIMHj9DrT
+lF8afFttvzBPhCf2nx9JvMaZCpDyD/V/Q4Q3Y1GLeqVw/HpYzY6b7cNGbIRwXdrz
+AZAj/E4wqX7hJ2Pn7WQ8oLjJM2P+FpD/sLj916jAwJRDC7bVWaaeVtAkH3B5r9s5
+VA1lddkVQZQBr17s9o3x/61k/iCa11zr/qYfCGSji3ZVrR47KGAuhyXoqq8fxmRG
+ILdwfzzeSNuWU7c5d+Qa4scWhHaXWy+7GRWF+GmF9ZmnqfI0p6m2pgP8b4Y9VHx2
+BJtr+UBdADTHLpl1neWIA6pN+APSQnbAGwIDAKiLo0UwQzASBgNVHRMBAf8ECDAG
+AQH/AgEEMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUzPpnk/C2uNClwB7zU/2M
+U9+D15YwDQYJKoZIhvcNAQELBQADggEBAKt/7hwWqZw8UQCgwBEIBaeZ5m8BiFRh
+bvG5GK1Krf6BQCOUL/t1fC8oS2IkgYIL9WHxHG64YTjrgfpioTtaYtOUZcTh5m2C
++C8lcLIhJsFyUR+MLMOEkMNaj7rP9KdlpeuY0fsFskZ1FSNqb4VjMIDw1Z4fKRzC
+bLBQWV2QWzuoDTDPv31/zvGdg73JRm4gpvlhUbohL3u+pRVjodSVh/GeufOJ8z2F
+uLjbvrW5KfnaNwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2
+XjG4Kvte9nHfRCaexOYNkbQudZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Hongkong Post Root CA 1 O=Hongkong Post
+# Subject: CN=Hongkong Post Root CA 1 O=Hongkong Post
+# Label: "Hongkong Post Root CA 1"
+# Serial: 1000
+# MD5 Fingerprint: a8:0d:6f:39:78:b9:43:6d:77:42:6d:98:5a:cc:23:ca
+# SHA1 Fingerprint: d6:da:a8:20:8d:09:d2:15:4d:24:b5:2f:cb:34:6e:b2:58:b2:8a:58
+# SHA256 Fingerprint: f9:e6:7d:33:6c:51:00:2a:c0:54:c6:32:02:2d:66:dd:a2:e7:e3:ff:f1:0a:d0:61:ed:31:d8:bb:b4:10:cf:b2
+-----BEGIN CERTIFICATE-----
+MIIDMDCCAhigAwIBAgICA+gwDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UEBhMCSEsx
+FjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdrb25nIFBvc3Qg
+Um9vdCBDQSAxMB4XDTAzMDUxNTA1MTMxNFoXDTIzMDUxNTA0NTIyOVowRzELMAkG
+A1UEBhMCSEsxFjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdr
+b25nIFBvc3QgUm9vdCBDQSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEArP84tulmAknjorThkPlAj3n54r15/gK97iSSHSL22oVyaf7XPwnU3ZG1ApzQ
+jVrhVcNQhrkpJsLj2aDxaQMoIIBFIi1WpztUlVYiWR8o3x8gPW2iNr4joLFutbEn
+PzlTCeqrauh0ssJlXI6/fMN4hM2eFvz1Lk8gKgifd/PFHsSaUmYeSF7jEAaPIpjh
+ZY4bXSNmO7ilMlHIhqqhqZ5/dpTCpmy3QfDVyAY45tQM4vM7TG1QjMSDJ8EThFk9
+nnV0ttgCXjqQesBCNnLsak3c78QA3xMYV18meMjWCnl3v/evt3a5pQuEF10Q6m/h
+q5URX208o1xNg1vysxmKgIsLhwIDAQABoyYwJDASBgNVHRMBAf8ECDAGAQH/AgED
+MA4GA1UdDwEB/wQEAwIBxjANBgkqhkiG9w0BAQUFAAOCAQEADkbVPK7ih9legYsC
+mEEIjEy82tvuJxuC52pF7BaLT4Wg87JwvVqWuspube5Gi27nKi6Wsxkz67SfqLI3
+7piol7Yutmcn1KZJ/RyTZXaeQi/cImyaT/JaFTmxcdcrUehtHJjA2Sr0oYJ71clB
+oiMBdDhViw+5LmeiIAQ32pwL0xch4I+XeTRvhEgCIDMb5jREn5Fw9IBehEPCKdJs
+EhTkYY2sEJCehFC78JZvRZ+K88psT/oROhUVRsPNH4NbLUES7VBnQRM9IauUiqpO
+fMGx+6fWtScvl6tu4B3i0RwsH0Ti/L6RoZz71ilTc4afU9hDDl3WY4JxHYB0yvbi
+AmvZWg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=SecureSign RootCA11 O=Japan Certification Services, Inc.
+# Subject: CN=SecureSign RootCA11 O=Japan Certification Services, Inc.
+# Label: "SecureSign RootCA11"
+# Serial: 1
+# MD5 Fingerprint: b7:52:74:e2:92:b4:80:93:f2:75:e4:cc:d7:f2:ea:26
+# SHA1 Fingerprint: 3b:c4:9f:48:f8:f3:73:a0:9c:1e:bd:f8:5b:b1:c3:65:c7:d8:11:b3
+# SHA256 Fingerprint: bf:0f:ee:fb:9e:3a:58:1a:d5:f9:e9:db:75:89:98:57:43:d2:61:08:5c:4d:31:4f:6f:5d:72:59:aa:42:16:12
+-----BEGIN CERTIFICATE-----
+MIIDbTCCAlWgAwIBAgIBATANBgkqhkiG9w0BAQUFADBYMQswCQYDVQQGEwJKUDEr
+MCkGA1UEChMiSmFwYW4gQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcywgSW5jLjEcMBoG
+A1UEAxMTU2VjdXJlU2lnbiBSb290Q0ExMTAeFw0wOTA0MDgwNDU2NDdaFw0yOTA0
+MDgwNDU2NDdaMFgxCzAJBgNVBAYTAkpQMSswKQYDVQQKEyJKYXBhbiBDZXJ0aWZp
+Y2F0aW9uIFNlcnZpY2VzLCBJbmMuMRwwGgYDVQQDExNTZWN1cmVTaWduIFJvb3RD
+QTExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/XeqpRyQBTvLTJsz
+i1oURaTnkBbR31fSIRCkF/3frNYfp+TbfPfs37gD2pRY/V1yfIw/XwFndBWW4wI8
+h9uuywGOwvNmxoVF9ALGOrVisq/6nL+k5tSAMJjzDbaTj6nU2DbysPyKyiyhFTOV
+MdrAG/LuYpmGYz+/3ZMqg6h2uRMft85OQoWPIucuGvKVCbIFtUROd6EgvanyTgp9
+UK31BQ1FT0Zx/Sg+U/sE2C3XZR1KG/rPO7AxmjVuyIsG0wCR8pQIZUyxNAYAeoni
+8McDWc/V1uinMrPmmECGxc0nEovMe863ETxiYAcjPitAbpSACW22s293bzUIUPsC
+h8U+iQIDAQABo0IwQDAdBgNVHQ4EFgQUW/hNT7KlhtQ60vFjmqC+CfZXt94wDgYD
+VR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEB
+AKChOBZmLqdWHyGcBvod7bkixTgm2E5P7KN/ed5GIaGHd48HCJqypMWvDzKYC3xm
+KbabfSVSSUOrTC4rbnpwrxYO4wJs+0LmGJ1F2FXI6Dvd5+H0LgscNFxsWEr7jIhQ
+X5Ucv+2rIrVls4W6ng+4reV6G4pQOh29Dbx7VFALuUKvVaAYga1lme++5Jy/xIWr
+QbJUb9wlze144o4MjQlJ3WN7WmmWAiGovVJZ6X01y8hSyn+B/tlr0/cR7SXf+Of5
+pPpyl4RTDaXQMhhRdlkUbA/r7F+AjHVDg8OFmP9Mni0N5HeDk061lgeLKBObjBmN
+QSdJQO7e5iNEOdyhIta6A/I=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd.
+# Subject: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd.
+# Label: "Microsec e-Szigno Root CA 2009"
+# Serial: 14014712776195784473
+# MD5 Fingerprint: f8:49:f4:03:bc:44:2d:83:be:48:69:7d:29:64:fc:b1
+# SHA1 Fingerprint: 89:df:74:fe:5c:f4:0f:4a:80:f9:e3:37:7d:54:da:91:e1:01:31:8e
+# SHA256 Fingerprint: 3c:5f:81:fe:a5:fa:b8:2c:64:bf:a2:ea:ec:af:cd:e8:e0:77:fc:86:20:a7:ca:e5:37:16:3d:f3:6e:db:f3:78
+-----BEGIN CERTIFICATE-----
+MIIECjCCAvKgAwIBAgIJAMJ+QwRORz8ZMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD
+VQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFjAUBgNVBAoMDU1pY3Jvc2VjIEx0
+ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EgMjAwOTEfMB0G
+CSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5odTAeFw0wOTA2MTYxMTMwMThaFw0y
+OTEyMzAxMTMwMThaMIGCMQswCQYDVQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3Qx
+FjAUBgNVBAoMDU1pY3Jvc2VjIEx0ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3pp
+Z25vIFJvb3QgQ0EgMjAwOTEfMB0GCSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5o
+dTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOn4j/NjrdqG2KfgQvvP
+kd6mJviZpWNwrZuuyjNAfW2WbqEORO7hE52UQlKavXWFdCyoDh2Tthi3jCyoz/tc
+cbna7P7ofo/kLx2yqHWH2Leh5TvPmUpG0IMZfcChEhyVbUr02MelTTMuhTlAdX4U
+fIASmFDHQWe4oIBhVKZsTh/gnQ4H6cm6M+f+wFUoLAKApxn1ntxVUwOXewdI/5n7
+N4okxFnMUBBjjqqpGrCEGob5X7uxUG6k0QrM1XF+H6cbfPVTbiJfyyvm1HxdrtbC
+xkzlBQHZ7Vf8wSN5/PrIJIOV87VqUQHQd9bpEqH5GoP7ghu5sJf0dgYzQ0mg/wu1
++rUCAwEAAaOBgDB+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G
+A1UdDgQWBBTLD8bfQkPMPcu1SCOhGnqmKrs0aDAfBgNVHSMEGDAWgBTLD8bfQkPM
+Pcu1SCOhGnqmKrs0aDAbBgNVHREEFDASgRBpbmZvQGUtc3ppZ25vLmh1MA0GCSqG
+SIb3DQEBCwUAA4IBAQDJ0Q5eLtXMs3w+y/w9/w0olZMEyL/azXm4Q5DwpL7v8u8h
+mLzU1F0G9u5C7DBsoKqpyvGvivo/C3NqPuouQH4frlRheesuCDfXI/OMn74dseGk
+ddug4lQUsbocKaQY9hK6ohQU4zE1yED/t+AFdlfBHFny+L/k7SViXITwfn4fs775
+tyERzAMBVnCnEJIeGzSBHq2cGsMEPO0CYdYeBvNfOofyK/FFh+U9rNHHV4S9a67c
+2Pm2G2JwCz02yULyMtd6YebS2z3PyKnJm9zbWETXbzivf3jTo60adbocwTZ8jx5t
+HMN1Rq41Bab2XD0h7lbwyYIiLXpUq3DDfSJlgnCW
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
+# Label: "GlobalSign Root CA - R3"
+# Serial: 4835703278459759426209954
+# MD5 Fingerprint: c5:df:b8:49:ca:05:13:55:ee:2d:ba:1a:c3:3e:b0:28
+# SHA1 Fingerprint: d6:9b:56:11:48:f0:1c:77:c5:45:78:c1:09:26:df:5b:85:69:76:ad
+# SHA256 Fingerprint: cb:b5:22:d7:b7:f1:27:ad:6a:01:13:86:5b:df:1c:d4:10:2e:7d:07:59:af:63:5a:7c:f4:72:0d:c9:63:c5:3b
+-----BEGIN CERTIFICATE-----
+MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G
+A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp
+Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4
+MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG
+A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8
+RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT
+gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm
+KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd
+QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ
+XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw
+DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o
+LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU
+RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp
+jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK
+6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX
+mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs
+Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH
+WD9f
+-----END CERTIFICATE-----
+
+# Issuer: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
+# Subject: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
+# Label: "Autoridad de Certificacion Firmaprofesional CIF A62634068"
+# Serial: 6047274297262753887
+# MD5 Fingerprint: 73:3a:74:7a:ec:bb:a3:96:a6:c2:e4:e2:c8:9b:c0:c3
+# SHA1 Fingerprint: ae:c5:fb:3f:c8:e1:bf:c4:e5:4f:03:07:5a:9a:e8:00:b7:f7:b6:fa
+# SHA256 Fingerprint: 04:04:80:28:bf:1f:28:64:d4:8f:9a:d4:d8:32:94:36:6a:82:88:56:55:3f:3b:14:30:3f:90:14:7f:5d:40:ef
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Izenpe.com O=IZENPE S.A.
+# Subject: CN=Izenpe.com O=IZENPE S.A.
+# Label: "Izenpe.com"
+# Serial: 917563065490389241595536686991402621
+# MD5 Fingerprint: a6:b0:cd:85:80:da:5c:50:34:a3:39:90:2f:55:67:73
+# SHA1 Fingerprint: 2f:78:3d:25:52:18:a7:4a:65:39:71:b5:2c:a2:9c:45:15:6f:e9:19
+# SHA256 Fingerprint: 25:30:cc:8e:98:32:15:02:ba:d9:6f:9b:1f:ba:1b:09:9e:2d:29:9e:0f:45:48:bb:91:4f:36:3b:c0:d4:53:1f
+-----BEGIN CERTIFICATE-----
+MIIF8TCCA9mgAwIBAgIQALC3WhZIX7/hy/WL1xnmfTANBgkqhkiG9w0BAQsFADA4
+MQswCQYDVQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6
+ZW5wZS5jb20wHhcNMDcxMjEzMTMwODI4WhcNMzcxMjEzMDgyNzI1WjA4MQswCQYD
+VQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6ZW5wZS5j
+b20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ03rKDx6sp4boFmVq
+scIbRTJxldn+EFvMr+eleQGPicPK8lVx93e+d5TzcqQsRNiekpsUOqHnJJAKClaO
+xdgmlOHZSOEtPtoKct2jmRXagaKH9HtuJneJWK3W6wyyQXpzbm3benhB6QiIEn6H
+LmYRY2xU+zydcsC8Lv/Ct90NduM61/e0aL6i9eOBbsFGb12N4E3GVFWJGjMxCrFX
+uaOKmMPsOzTFlUFpfnXCPCDFYbpRR6AgkJOhkEvzTnyFRVSa0QUmQbC1TR0zvsQD
+yCV8wXDbO/QJLVQnSKwv4cSsPsjLkkxTOTcj7NMB+eAJRE1NZMDhDVqHIrytG6P+
+JrUV86f8hBnp7KGItERphIPzidF0BqnMC9bC3ieFUCbKF7jJeodWLBoBHmy+E60Q
+rLUk9TiRodZL2vG70t5HtfG8gfZZa88ZU+mNFctKy6lvROUbQc/hhqfK0GqfvEyN
+BjNaooXlkDWgYlwWTvDjovoDGrQscbNYLN57C9saD+veIR8GdwYDsMnvmfzAuU8L
+hij+0rnq49qlw0dpEuDb8PYZi+17cNcC1u2HGCgsBCRMd+RIihrGO5rUD8r6ddIB
+QFqNeb+Lz0vPqhbBleStTIo+F5HUsWLlguWABKQDfo2/2n+iD5dPDNMN+9fR5XJ+
+HMh3/1uaD7euBUbl8agW7EekFwIDAQABo4H2MIHzMIGwBgNVHREEgagwgaWBD2lu
+Zm9AaXplbnBlLmNvbaSBkTCBjjFHMEUGA1UECgw+SVpFTlBFIFMuQS4gLSBDSUYg
+QTAxMzM3MjYwLVJNZXJjLlZpdG9yaWEtR2FzdGVpeiBUMTA1NSBGNjIgUzgxQzBB
+BgNVBAkMOkF2ZGEgZGVsIE1lZGl0ZXJyYW5lbyBFdG9yYmlkZWEgMTQgLSAwMTAx
+MCBWaXRvcmlhLUdhc3RlaXowDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
+AQYwHQYDVR0OBBYEFB0cZQ6o8iV7tJHP5LGx5r1VdGwFMA0GCSqGSIb3DQEBCwUA
+A4ICAQB4pgwWSp9MiDrAyw6lFn2fuUhfGI8NYjb2zRlrrKvV9pF9rnHzP7MOeIWb
+laQnIUdCSnxIOvVFfLMMjlF4rJUT3sb9fbgakEyrkgPH7UIBzg/YsfqikuFgba56
+awmqxinuaElnMIAkejEWOVt+8Rwu3WwJrfIxwYJOubv5vr8qhT/AQKM6WfxZSzwo
+JNu0FXWuDYi6LnPAvViH5ULy617uHjAimcs30cQhbIHsvm0m5hzkQiCeR7Csg1lw
+LDXWrzY0tM07+DKo7+N4ifuNRSzanLh+QBxh5z6ikixL8s36mLYp//Pye6kfLqCT
+VyvehQP5aTfLnnhqBbTFMXiJ7HqnheG5ezzevh55hM6fcA5ZwjUukCox2eRFekGk
+LhObNA5me0mrZJfQRsN5nXJQY6aYWwa9SG3YOYNw6DXwBdGqvOPbyALqfP2C2sJb
+UjWumDqtujWTI6cfSN01RpiyEGjkpTHCClguGYEQyVB1/OpaFs4R1+7vUIgtYf8/
+QnMFlEPVjjxOAToZpR9GTnfQXeWBIiGH/pR9hNiTrdZoQ0iy2+tzJOeRf1SktoA+
+naM8THLCV8Sg1Mw4J87VBp6iSNnpn86CcDaTmjvfliHjWbcM2pE38P1ZWrOZyGls
+QyYBNWNgVYkDOnXYukrZVP/u3oDYLdE41V4tC5h9Pmzb/CaIxw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
+# Subject: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
+# Label: "Go Daddy Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: 80:3a:bc:22:c1:e6:fb:8d:9b:3b:27:4a:32:1b:9a:01
+# SHA1 Fingerprint: 47:be:ab:c9:22:ea:e8:0e:78:78:34:62:a7:9f:45:c2:54:fd:e6:8b
+# SHA256 Fingerprint: 45:14:0b:32:47:eb:9c:c8:c5:b4:f0:d7:b5:30:91:f7:32:92:08:9e:6e:5a:63:e2:74:9d:d3:ac:a9:19:8e:da
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT
+EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp
+ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz
+NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH
+EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE
+AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD
+E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH
+/PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy
+DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh
+GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR
+tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA
+AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE
+FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX
+WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu
+9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr
+gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo
+2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO
+LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI
+4uJEvlz36hz1
+-----END CERTIFICATE-----
+
+# Issuer: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Subject: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Label: "Starfield Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: d6:39:81:c6:52:7e:96:69:fc:fc:ca:66:ed:05:f2:96
+# SHA1 Fingerprint: b5:1c:06:7c:ee:2b:0c:3d:f8:55:ab:2d:92:f4:fe:39:d4:e7:0f:0e
+# SHA256 Fingerprint: 2c:e1:cb:0b:f9:d2:f9:e1:02:99:3f:be:21:51:52:c3:b2:dd:0c:ab:de:1c:68:e5:31:9b:83:91:54:db:b7:f5
+-----BEGIN CERTIFICATE-----
+MIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
+HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs
+ZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw
+MFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6
+b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj
+aG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp
+Y2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+ggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg
+nLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1
+HOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N
+Hwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN
+dloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0
+HZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO
+BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G
+CSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU
+sHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3
+4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg
+8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K
+pL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1
+mMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0
+-----END CERTIFICATE-----
+
+# Issuer: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Subject: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Label: "Starfield Services Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: 17:35:74:af:7b:61:1c:eb:f4:f9:3c:e2:ee:40:f9:a2
+# SHA1 Fingerprint: 92:5a:8f:8d:2c:6d:04:e0:66:5f:59:6a:ff:22:d8:63:e8:25:6f:3f
+# SHA256 Fingerprint: 56:8d:69:05:a2:c8:87:08:a4:b3:02:51:90:ed:cf:ed:b1:97:4a:60:6a:13:c6:e5:29:0f:cb:2a:e6:3e:da:b5
+-----BEGIN CERTIFICATE-----
+MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
+HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs
+ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5
+MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD
+VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy
+ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy
+dmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p
+OsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2
+8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K
+Ts9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe
+hRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk
+6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw
+DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q
+AdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI
+bw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB
+ve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z
+qwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd
+iEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn
+0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN
+sSi6
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Commercial O=AffirmTrust
+# Subject: CN=AffirmTrust Commercial O=AffirmTrust
+# Label: "AffirmTrust Commercial"
+# Serial: 8608355977964138876
+# MD5 Fingerprint: 82:92:ba:5b:ef:cd:8a:6f:a6:3d:55:f9:84:f6:d6:b7
+# SHA1 Fingerprint: f9:b5:b6:32:45:5f:9c:be:ec:57:5f:80:dc:e9:6e:2c:c7:b2:78:b7
+# SHA256 Fingerprint: 03:76:ab:1d:54:c5:f9:80:3c:e4:b2:e2:01:a0:ee:7e:ef:7b:57:b6:36:e8:a9:3c:9b:8d:48:60:c9:6f:5f:a7
+-----BEGIN CERTIFICATE-----
+MIIDTDCCAjSgAwIBAgIId3cGJyapsXwwDQYJKoZIhvcNAQELBQAwRDELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
+dCBDb21tZXJjaWFsMB4XDTEwMDEyOTE0MDYwNloXDTMwMTIzMTE0MDYwNlowRDEL
+MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
+cm1UcnVzdCBDb21tZXJjaWFsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEA9htPZwcroRX1BiLLHwGy43NFBkRJLLtJJRTWzsO3qyxPxkEylFf6EqdbDuKP
+Hx6GGaeqtS25Xw2Kwq+FNXkyLbscYjfysVtKPcrNcV/pQr6U6Mje+SJIZMblq8Yr
+ba0F8PrVC8+a5fBQpIs7R6UjW3p6+DM/uO+Zl+MgwdYoic+U+7lF7eNAFxHUdPAL
+MeIrJmqbTFeurCA+ukV6BfO9m2kVrn1OIGPENXY6BwLJN/3HR+7o8XYdcxXyl6S1
+yHp52UKqK39c/s4mT6NmgTWvRLpUHhwwMmWd5jyTXlBOeuM61G7MGvv50jeuJCqr
+VwMiKA1JdX+3KNp1v47j3A55MQIDAQABo0IwQDAdBgNVHQ4EFgQUnZPGU4teyq8/
+nx4P5ZmVvCT2lI8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
+KoZIhvcNAQELBQADggEBAFis9AQOzcAN/wr91LoWXym9e2iZWEnStB03TX8nfUYG
+XUPGhi4+c7ImfU+TqbbEKpqrIZcUsd6M06uJFdhrJNTxFq7YpFzUf1GO7RgBsZNj
+vbz4YYCanrHOQnDiqX0GJX0nof5v7LMeJNrjS1UaADs1tDvZ110w/YETifLCBivt
+Z8SOyUOyXGsViQK8YvxO8rUzqrJv0wqiUOP2O+guRMLbZjipM1ZI8W0bM40NjD9g
+N53Tym1+NH4Nn3J2ixufcv1SNUFFApYvHLKac0khsUlHRUe072o0EclNmsxZt9YC
+nlpOZbWUrhvfKbAW8b8Angc6F2S1BLUjIZkKlTuXfO8=
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Networking O=AffirmTrust
+# Subject: CN=AffirmTrust Networking O=AffirmTrust
+# Label: "AffirmTrust Networking"
+# Serial: 8957382827206547757
+# MD5 Fingerprint: 42:65:ca:be:01:9a:9a:4c:a9:8c:41:49:cd:c0:d5:7f
+# SHA1 Fingerprint: 29:36:21:02:8b:20:ed:02:f5:66:c5:32:d1:d6:ed:90:9f:45:00:2f
+# SHA256 Fingerprint: 0a:81:ec:5a:92:97:77:f1:45:90:4a:f3:8d:5d:50:9f:66:b5:e2:c5:8f:cd:b5:31:05:8b:0e:17:f3:f0:b4:1b
+-----BEGIN CERTIFICATE-----
+MIIDTDCCAjSgAwIBAgIIfE8EORzUmS0wDQYJKoZIhvcNAQEFBQAwRDELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
+dCBOZXR3b3JraW5nMB4XDTEwMDEyOTE0MDgyNFoXDTMwMTIzMTE0MDgyNFowRDEL
+MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
+cm1UcnVzdCBOZXR3b3JraW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEAtITMMxcua5Rsa2FSoOujz3mUTOWUgJnLVWREZY9nZOIG41w3SfYvm4SEHi3y
+YJ0wTsyEheIszx6e/jarM3c1RNg1lho9Nuh6DtjVR6FqaYvZ/Ls6rnla1fTWcbua
+kCNrmreIdIcMHl+5ni36q1Mr3Lt2PpNMCAiMHqIjHNRqrSK6mQEubWXLviRmVSRL
+QESxG9fhwoXA3hA/Pe24/PHxI1Pcv2WXb9n5QHGNfb2V1M6+oF4nI979ptAmDgAp
+6zxG8D1gvz9Q0twmQVGeFDdCBKNwV6gbh+0t+nvujArjqWaJGctB+d1ENmHP4ndG
+yH329JKBNv3bNPFyfvMMFr20FQIDAQABo0IwQDAdBgNVHQ4EFgQUBx/S55zawm6i
+QLSwelAQUHTEyL0wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
+KoZIhvcNAQEFBQADggEBAIlXshZ6qML91tmbmzTCnLQyFE2npN/svqe++EPbkTfO
+tDIuUFUaNU52Q3Eg75N3ThVwLofDwR1t3Mu1J9QsVtFSUzpE0nPIxBsFZVpikpzu
+QY0x2+c06lkh1QF612S4ZDnNye2v7UsDSKegmQGA3GWjNq5lWUhPgkvIZfFXHeVZ
+Lgo/bNjR9eUJtGxUAArgFU2HdW23WJZa3W3SAKD0m0i+wzekujbgfIeFlxoVot4u
+olu9rxj5kFDNcFn4J2dHy8egBzp90SxdbBk6ZrV9/ZFvgrG+CJPbFEfxojfHRZ48
+x3evZKiT3/Zpg4Jg8klCNO1aAFSFHBY2kgxc+qatv9s=
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Premium O=AffirmTrust
+# Subject: CN=AffirmTrust Premium O=AffirmTrust
+# Label: "AffirmTrust Premium"
+# Serial: 7893706540734352110
+# MD5 Fingerprint: c4:5d:0e:48:b6:ac:28:30:4e:0a:bc:f9:38:16:87:57
+# SHA1 Fingerprint: d8:a6:33:2c:e0:03:6f:b1:85:f6:63:4f:7d:6a:06:65:26:32:28:27
+# SHA256 Fingerprint: 70:a7:3f:7f:37:6b:60:07:42:48:90:45:34:b1:14:82:d5:bf:0e:69:8e:cc:49:8d:f5:25:77:eb:f2:e9:3b:9a
+-----BEGIN CERTIFICATE-----
+MIIFRjCCAy6gAwIBAgIIbYwURrGmCu4wDQYJKoZIhvcNAQEMBQAwQTELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1UcnVz
+dCBQcmVtaXVtMB4XDTEwMDEyOTE0MTAzNloXDTQwMTIzMTE0MTAzNlowQTELMAkG
+A1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1U
+cnVzdCBQcmVtaXVtMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBLf
+qV/+Qd3d9Z+K4/as4Tx4mrzY8H96oDMq3I0gW64tb+eT2TZwamjPjlGjhVtnBKAQ
+JG9dKILBl1fYSCkTtuG+kU3fhQxTGJoeJKJPj/CihQvL9Cl/0qRY7iZNyaqoe5rZ
++jjeRFcV5fiMyNlI4g0WJx0eyIOFJbe6qlVBzAMiSy2RjYvmia9mx+n/K+k8rNrS
+s8PhaJyJ+HoAVt70VZVs+7pk3WKL3wt3MutizCaam7uqYoNMtAZ6MMgpv+0GTZe5
+HMQxK9VfvFMSF5yZVylmd2EhMQcuJUmdGPLu8ytxjLW6OQdJd/zvLpKQBY0tL3d7
+70O/Nbua2Plzpyzy0FfuKE4mX4+QaAkvuPjcBukumj5Rp9EixAqnOEhss/n/fauG
+V+O61oV4d7pD6kh/9ti+I20ev9E2bFhc8e6kGVQa9QPSdubhjL08s9NIS+LI+H+S
+qHZGnEJlPqQewQcDWkYtuJfzt9WyVSHvutxMAJf7FJUnM7/oQ0dG0giZFmA7mn7S
+5u046uwBHjxIVkkJx0w3AJ6IDsBz4W9m6XJHMD4Q5QsDyZpCAGzFlH5hxIrff4Ia
+C1nEWTJ3s7xgaVY5/bQGeyzWZDbZvUjthB9+pSKPKrhC9IK31FOQeE4tGv2Bb0TX
+OwF0lkLgAOIua+rF7nKsu7/+6qqo+Nz2snmKtmcCAwEAAaNCMEAwHQYDVR0OBBYE
+FJ3AZ6YMItkm9UWrpmVSESfYRaxjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
+BAQDAgEGMA0GCSqGSIb3DQEBDAUAA4ICAQCzV00QYk465KzquByvMiPIs0laUZx2
+KI15qldGF9X1Uva3ROgIRL8YhNILgM3FEv0AVQVhh0HctSSePMTYyPtwni94loMg
+Nt58D2kTiKV1NpgIpsbfrM7jWNa3Pt668+s0QNiigfV4Py/VpfzZotReBA4Xrf5B
+8OWycvpEgjNC6C1Y91aMYj+6QrCcDFx+LmUmXFNPALJ4fqENmS2NuB2OosSw/WDQ
+MKSOyARiqcTtNd56l+0OOF6SL5Nwpamcb6d9Ex1+xghIsV5n61EIJenmJWtSKZGc
+0jlzCFfemQa0W50QBuHCAKi4HEoCChTQwUHK+4w1IX2COPKpVJEZNZOUbWo6xbLQ
+u4mGk+ibyQ86p3q4ofB4Rvr8Ny/lioTz3/4E2aFooC8k4gmVBtWVyuEklut89pMF
+u+1z6S3RdTnX5yTb2E5fQ4+e0BQ5v1VwSJlXMbSc7kqYA5YwH2AG7hsj/oFgIxpH
+YoWlzBk0gG+zrBrjn/B7SK3VAdlntqlyk+otZrWyuOQ9PLLvTIzq6we/qzWaVYa8
+GKa1qF60g2xraUDTn9zxw2lrueFtCfTxqlB2Cnp9ehehVZZCmTEJ3WARjQUwfuaO
+RtGdFNrHF+QFlozEJLUbzxQHskD4o55BhrwE0GuWyCqANP2/7waj3VjFhT0+j/6e
+KeC2uAloGRwYQw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Premium ECC O=AffirmTrust
+# Subject: CN=AffirmTrust Premium ECC O=AffirmTrust
+# Label: "AffirmTrust Premium ECC"
+# Serial: 8401224907861490260
+# MD5 Fingerprint: 64:b0:09:55:cf:b1:d5:99:e2:be:13:ab:a6:5d:ea:4d
+# SHA1 Fingerprint: b8:23:6b:00:2f:1d:16:86:53:01:55:6c:11:a4:37:ca:eb:ff:c3:bb
+# SHA256 Fingerprint: bd:71:fd:f6:da:97:e4:cf:62:d1:64:7a:dd:25:81:b0:7d:79:ad:f8:39:7e:b4:ec:ba:9c:5e:84:88:82:14:23
+-----BEGIN CERTIFICATE-----
+MIIB/jCCAYWgAwIBAgIIdJclisc/elQwCgYIKoZIzj0EAwMwRTELMAkGA1UEBhMC
+VVMxFDASBgNVBAoMC0FmZmlybVRydXN0MSAwHgYDVQQDDBdBZmZpcm1UcnVzdCBQ
+cmVtaXVtIEVDQzAeFw0xMDAxMjkxNDIwMjRaFw00MDEyMzExNDIwMjRaMEUxCzAJ
+BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJt
+VHJ1c3QgUHJlbWl1bSBFQ0MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQNMF4bFZ0D
+0KF5Nbc6PJJ6yhUczWLznCZcBz3lVPqj1swS6vQUX+iOGasvLkjmrBhDeKzQN8O9
+ss0s5kfiGuZjuD0uL3jET9v0D6RoTFVya5UdThhClXjMNzyR4ptlKymjQjBAMB0G
+A1UdDgQWBBSaryl6wBE1NSZRMADDav5A1a7WPDAPBgNVHRMBAf8EBTADAQH/MA4G
+A1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNnADBkAjAXCfOHiFBar8jAQr9HX/Vs
+aobgxCd05DhT1wV/GzTjxi+zygk8N53X57hG8f2h4nECMEJZh0PUUd+60wkyWs6I
+flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Subject: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Label: "Certum Trusted Network CA"
+# Serial: 279744
+# MD5 Fingerprint: d5:e9:81:40:c5:18:69:fc:46:2c:89:75:62:0f:aa:78
+# SHA1 Fingerprint: 07:e0:32:e0:20:b7:2c:3f:19:2f:06:28:a2:59:3a:19:a7:0f:06:9e
+# SHA256 Fingerprint: 5c:58:46:8d:55:f5:8e:49:7e:74:39:82:d2:b5:00:10:b6:d1:65:37:4a:cf:83:a7:d4:a3:2d:b7:68:c4:40:8e
+-----BEGIN CERTIFICATE-----
+MIIDuzCCAqOgAwIBAgIDBETAMA0GCSqGSIb3DQEBBQUAMH4xCzAJBgNVBAYTAlBM
+MSIwIAYDVQQKExlVbml6ZXRvIFRlY2hub2xvZ2llcyBTLkEuMScwJQYDVQQLEx5D
+ZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxIjAgBgNVBAMTGUNlcnR1bSBU
+cnVzdGVkIE5ldHdvcmsgQ0EwHhcNMDgxMDIyMTIwNzM3WhcNMjkxMjMxMTIwNzM3
+WjB+MQswCQYDVQQGEwJQTDEiMCAGA1UEChMZVW5pemV0byBUZWNobm9sb2dpZXMg
+Uy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MSIw
+IAYDVQQDExlDZXJ0dW0gVHJ1c3RlZCBOZXR3b3JrIENBMIIBIjANBgkqhkiG9w0B
+AQEFAAOCAQ8AMIIBCgKCAQEA4/t9o3K6wvDJFIf1awFO4W5AB7ptJ11/91sts1rH
+UV+rpDKmYYe2bg+G0jACl/jXaVehGDldamR5xgFZrDwxSjh80gTSSyjoIF87B6LM
+TXPb865Px1bVWqeWifrzq2jUI4ZZJ88JJ7ysbnKDHDBy3+Ci6dLhdHUZvSqeexVU
+BBvXQzmtVSjF4hq79MDkrjhJM8x2hZ85RdKknvISjFH4fOQtf/WsX+sWn7Et0brM
+kUJ3TCXJkDhv2/DM+44el1k+1WBO5gUo7Ul5E0u6SNsv+XLTOcr+H9g0cvW0QM8x
+AcPs3hEtF10fuFDRXhmnad4HMyjKUJX5p1TLVIZQRan5SQIDAQABo0IwQDAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBQIds3LB/8k9sXN7buQvOKEN0Z19zAOBgNV
+HQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQEFBQADggEBAKaorSLOAT2mo/9i0Eidi15y
+sHhE49wcrwn9I0j6vSrEuVUEtRCjjSfeC4Jj0O7eDDd5QVsisrCaQVymcODU0HfL
+I9MA4GxWL+FpDQ3Zqr8hgVDZBqWo/5U30Kr+4rP1mS1FhIrlQgnXdAIv94nYmem8
+J9RHjboNRhx3zxSkHLmkMcScKHQDNP8zGSal6Q10tz6XxnboJ5ajZt3hrvJBW8qY
+VoNzcOSGGtIxQbovvi0TWnZvTuhOgQ4/WwMioBK+ZlgRSssDxLQqKi2WF+A5VLxI
+03YnnZotBqbJ7DnSq9ufmgsnAjUpsUCV5/nonFWIGUbWtzT1fs45mtk48VH3Tyw=
+-----END CERTIFICATE-----
+
+# Issuer: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA
+# Subject: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA
+# Label: "TWCA Root Certification Authority"
+# Serial: 1
+# MD5 Fingerprint: aa:08:8f:f6:f9:7b:b7:f2:b1:a7:1e:9b:ea:ea:bd:79
+# SHA1 Fingerprint: cf:9e:87:6d:d3:eb:fc:42:26:97:a3:b5:a3:7a:a0:76:a9:06:23:48
+# SHA256 Fingerprint: bf:d8:8f:e1:10:1c:41:ae:3e:80:1b:f8:be:56:35:0e:e9:ba:d1:a6:b9:bd:51:5e:dc:5c:6d:5b:87:11:ac:44
+-----BEGIN CERTIFICATE-----
+MIIDezCCAmOgAwIBAgIBATANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJUVzES
+MBAGA1UECgwJVEFJV0FOLUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFU
+V0NBIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwODI4MDcyNDMz
+WhcNMzAxMjMxMTU1OTU5WjBfMQswCQYDVQQGEwJUVzESMBAGA1UECgwJVEFJV0FO
+LUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFUV0NBIFJvb3QgQ2VydGlm
+aWNhdGlvbiBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
+AQCwfnK4pAOU5qfeCTiRShFAh6d8WWQUe7UREN3+v9XAu1bihSX0NXIP+FPQQeFE
+AcK0HMMxQhZHhTMidrIKbw/lJVBPhYa+v5guEGcevhEFhgWQxFnQfHgQsIBct+HH
+K3XLfJ+utdGdIzdjp9xCoi2SBBtQwXu4PhvJVgSLL1KbralW6cH/ralYhzC2gfeX
+RfwZVzsrb+RH9JlF/h3x+JejiB03HFyP4HYlmlD4oFT/RJB2I9IyxsOrBr/8+7/z
+rX2SYgJbKdM1o5OaQ2RgXbL6Mv87BK9NQGr5x+PvI/1ry+UPizgN7gr8/g+YnzAx
+3WxSZfmLgb4i4RxYA7qRG4kHAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqOFsmjd6LWvJPelSDGRjjCDWmujANBgkq
+hkiG9w0BAQUFAAOCAQEAPNV3PdrfibqHDAhUaiBQkr6wQT25JmSDCi/oQMCXKCeC
+MErJk/9q56YAf4lCmtYR5VPOL8zy2gXE/uJQxDqGfczafhAJO5I1KlOy/usrBdls
+XebQ79NqZp4VKIV66IIArB6nCWlWQtNoURi+VJq/REG6Sb4gumlc7rh3zc5sH62D
+lhh9DrUUOYTxKOkto557HnpyWoOzeW/vtPzQCqVYT0bf+215WfKEIlKuD8z7fDvn
+aspHYcN6+NOSBB+4IIThNlQWx0DeO4pz3N/GCUzf7Nr/1FNCocnyYh0igzyXxfkZ
+YiesZSLX0zzG5Y6yU8xJzrww/nsOM5D77dIUkR8Hrw==
+-----END CERTIFICATE-----
+
+# Issuer: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2
+# Subject: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2
+# Label: "Security Communication RootCA2"
+# Serial: 0
+# MD5 Fingerprint: 6c:39:7d:a4:0e:55:59:b2:3f:d6:41:b1:12:50:de:43
+# SHA1 Fingerprint: 5f:3b:8c:f2:f8:10:b3:7d:78:b4:ce:ec:19:19:c3:73:34:b9:c7:74
+# SHA256 Fingerprint: 51:3b:2c:ec:b8:10:d4:cd:e5:dd:85:39:1a:df:c6:c2:dd:60:d8:7b:b7:36:d2:b5:21:48:4a:a4:7a:0e:be:f6
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIBADANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJKUDEl
+MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEnMCUGA1UECxMe
+U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBSb290Q0EyMB4XDTA5MDUyOTA1MDAzOVoX
+DTI5MDUyOTA1MDAzOVowXTELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09NIFRy
+dXN0IFN5c3RlbXMgQ08uLExURC4xJzAlBgNVBAsTHlNlY3VyaXR5IENvbW11bmlj
+YXRpb24gUm9vdENBMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANAV
+OVKxUrO6xVmCxF1SrjpDZYBLx/KWvNs2l9amZIyoXvDjChz335c9S672XewhtUGr
+zbl+dp+++T42NKA7wfYxEUV0kz1XgMX5iZnK5atq1LXaQZAQwdbWQonCv/Q4EpVM
+VAX3NuRFg3sUZdbcDE3R3n4MqzvEFb46VqZab3ZpUql6ucjrappdUtAtCms1FgkQ
+hNBqyjoGADdH5H5XTz+L62e4iKrFvlNVspHEfbmwhRkGeC7bYRr6hfVKkaHnFtWO
+ojnflLhwHyg/i/xAXmODPIMqGplrz95Zajv8bxbXH/1KEOtOghY6rCcMU/Gt1SSw
+awNQwS08Ft1ENCcadfsCAwEAAaNCMEAwHQYDVR0OBBYEFAqFqXdlBZh8QIH4D5cs
+OPEK7DzPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3
+DQEBCwUAA4IBAQBMOqNErLlFsceTfsgLCkLfZOoc7llsCLqJX2rKSpWeeo8HxdpF
+coJxDjrSzG+ntKEju/Ykn8sX/oymzsLS28yN/HH8AynBbF0zX2S2ZTuJbxh2ePXc
+okgfGT+Ok+vx+hfuzU7jBBJV1uXk3fs+BXziHV7Gp7yXT2g69ekuCkO2r1dcYmh8
+t/2jioSgrGK+KwmHNPBqAbubKVY8/gA3zyNs8U6qtnRGEmyR7jTV7JqR50S+kDFy
+1UkC9gLl9B/rfNmWVan/7Ir5mUf/NVoCqgTLiluHcSmRvaS0eg29mvVXIwAHIRc/
+SjnRBUkLp7Y3gaVdjKozXoEofKd9J+sAro03
+-----END CERTIFICATE-----
+
+# Issuer: CN=EC-ACC O=Agencia Catalana de Certificacio (NIF Q-0801176-I) OU=Serveis Publics de Certificacio/Vegeu https://www.catcert.net/verarrel (c)03/Jerarquia Entitats de Certificacio Catalanes
+# Subject: CN=EC-ACC O=Agencia Catalana de Certificacio (NIF Q-0801176-I) OU=Serveis Publics de Certificacio/Vegeu https://www.catcert.net/verarrel (c)03/Jerarquia Entitats de Certificacio Catalanes
+# Label: "EC-ACC"
+# Serial: -23701579247955709139626555126524820479
+# MD5 Fingerprint: eb:f5:9d:29:0d:61:f9:42:1f:7c:c2:ba:6d:e3:15:09
+# SHA1 Fingerprint: 28:90:3a:63:5b:52:80:fa:e6:77:4c:0b:6d:a7:d6:ba:a6:4a:f2:e8
+# SHA256 Fingerprint: 88:49:7f:01:60:2f:31:54:24:6a:e2:8c:4d:5a:ef:10:f1:d8:7e:bb:76:62:6f:4a:e0:b7:f9:5b:a7:96:87:99
+-----BEGIN CERTIFICATE-----
+MIIFVjCCBD6gAwIBAgIQ7is969Qh3hSoYqwE893EATANBgkqhkiG9w0BAQUFADCB
+8zELMAkGA1UEBhMCRVMxOzA5BgNVBAoTMkFnZW5jaWEgQ2F0YWxhbmEgZGUgQ2Vy
+dGlmaWNhY2lvIChOSUYgUS0wODAxMTc2LUkpMSgwJgYDVQQLEx9TZXJ2ZWlzIFB1
+YmxpY3MgZGUgQ2VydGlmaWNhY2lvMTUwMwYDVQQLEyxWZWdldSBodHRwczovL3d3
+dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAoYykwMzE1MDMGA1UECxMsSmVyYXJxdWlh
+IEVudGl0YXRzIGRlIENlcnRpZmljYWNpbyBDYXRhbGFuZXMxDzANBgNVBAMTBkVD
+LUFDQzAeFw0wMzAxMDcyMzAwMDBaFw0zMTAxMDcyMjU5NTlaMIHzMQswCQYDVQQG
+EwJFUzE7MDkGA1UEChMyQWdlbmNpYSBDYXRhbGFuYSBkZSBDZXJ0aWZpY2FjaW8g
+KE5JRiBRLTA4MDExNzYtSSkxKDAmBgNVBAsTH1NlcnZlaXMgUHVibGljcyBkZSBD
+ZXJ0aWZpY2FjaW8xNTAzBgNVBAsTLFZlZ2V1IGh0dHBzOi8vd3d3LmNhdGNlcnQu
+bmV0L3ZlcmFycmVsIChjKTAzMTUwMwYDVQQLEyxKZXJhcnF1aWEgRW50aXRhdHMg
+ZGUgQ2VydGlmaWNhY2lvIENhdGFsYW5lczEPMA0GA1UEAxMGRUMtQUNDMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsyLHT+KXQpWIR4NA9h0X84NzJB5R
+85iKw5K4/0CQBXCHYMkAqbWUZRkiFRfCQ2xmRJoNBD45b6VLeqpjt4pEndljkYRm
+4CgPukLjbo73FCeTae6RDqNfDrHrZqJyTxIThmV6PttPB/SnCWDaOkKZx7J/sxaV
+HMf5NLWUhdWZXqBIoH7nF2W4onW4HvPlQn2v7fOKSGRdghST2MDk/7NQcvJ29rNd
+QlB50JQ+awwAvthrDk4q7D7SzIKiGGUzE3eeml0aE9jD2z3Il3rucO2n5nzbcc8t
+lGLfbdb1OL4/pYUKGbio2Al1QnDE6u/LDsg0qBIimAy4E5S2S+zw0JDnJwIDAQAB
+o4HjMIHgMB0GA1UdEQQWMBSBEmVjX2FjY0BjYXRjZXJ0Lm5ldDAPBgNVHRMBAf8E
+BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUoMOLRKo3pUW/l4Ba0fF4
+opvpXY0wfwYDVR0gBHgwdjB0BgsrBgEEAfV4AQMBCjBlMCwGCCsGAQUFBwIBFiBo
+dHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbDA1BggrBgEFBQcCAjApGidW
+ZWdldSBodHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAwDQYJKoZIhvcN
+AQEFBQADggEBAKBIW4IB9k1IuDlVNZyAelOZ1Vr/sXE7zDkJlF7W2u++AVtd0x7Y
+/X1PzaBB4DSTv8vihpw3kpBWHNzrKQXlxJ7HNd+KDM3FIUPpqojlNcAZQmNaAl6k
+SBg6hW/cnbw/nZzBh7h6YQjpdwt/cKt63dmXLGQehb+8dJahw3oS7AwaboMMPOhy
+Rp/7SNVel+axofjk70YllJyJ22k4vuxcDlbHZVHlUIiIv0LVKz3l+bqeLrPK9HOS
+Agu+TGbrIP65y7WZf+a2E/rKS03Z7lNGBjvGTq2TWoF+bCpLagVFjPIhpDGQh2xl
+nJ2lYJU6Un/10asIbvPuW/mIPX64b24D5EI=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967
+# Subject: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967
+# Label: "Actalis Authentication Root CA"
+# Serial: 6271844772424770508
+# MD5 Fingerprint: 69:c1:0d:4f:07:a3:1b:c3:fe:56:3d:04:bc:11:f6:a6
+# SHA1 Fingerprint: f3:73:b3:87:06:5a:28:84:8a:f2:f3:4a:ce:19:2b:dd:c7:8e:9c:ac
+# SHA256 Fingerprint: 55:92:60:84:ec:96:3a:64:b9:6e:2a:be:01:ce:0b:a8:6a:64:fb:fe:bc:c7:aa:b5:af:c1:55:b3:7f:d7:60:66
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Buypass Class 2 Root CA O=Buypass AS-983163327
+# Subject: CN=Buypass Class 2 Root CA O=Buypass AS-983163327
+# Label: "Buypass Class 2 Root CA"
+# Serial: 2
+# MD5 Fingerprint: 46:a7:d2:fe:45:fb:64:5a:a8:59:90:9b:78:44:9b:29
+# SHA1 Fingerprint: 49:0a:75:74:de:87:0a:47:fe:58:ee:f6:c7:6b:eb:c6:0b:12:40:99
+# SHA256 Fingerprint: 9a:11:40:25:19:7c:5b:b9:5d:94:e6:3d:55:cd:43:79:08:47:b6:46:b2:3c:df:11:ad:a4:a0:0e:ff:15:fb:48
+-----BEGIN CERTIFICATE-----
+MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd
+MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg
+Q2xhc3MgMiBSb290IENBMB4XDTEwMTAyNjA4MzgwM1oXDTQwMTAyNjA4MzgwM1ow
+TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw
+HgYDVQQDDBdCdXlwYXNzIENsYXNzIDIgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB
+BQADggIPADCCAgoCggIBANfHXvfBB9R3+0Mh9PT1aeTuMgHbo4Yf5FkNuud1g1Lr
+6hxhFUi7HQfKjK6w3Jad6sNgkoaCKHOcVgb/S2TwDCo3SbXlzwx87vFKu3MwZfPV
+L4O2fuPn9Z6rYPnT8Z2SdIrkHJasW4DptfQxh6NR/Md+oW+OU3fUl8FVM5I+GC91
+1K2GScuVr1QGbNgGE41b/+EmGVnAJLqBcXmQRFBoJJRfuLMR8SlBYaNByyM21cHx
+MlAQTn/0hpPshNOOvEu/XAFOBz3cFIqUCqTqc/sLUegTBxj6DvEr0VQVfTzh97QZ
+QmdiXnfgolXsttlpF9U6r0TtSsWe5HonfOV116rLJeffawrbD02TTqigzXsu8lkB
+arcNuAeBfos4GzjmCleZPe4h6KP1DBbdi+w0jpwqHAAVF41og9JwnxgIzRFo1clr
+Us3ERo/ctfPYV3Me6ZQ5BL/T3jjetFPsaRyifsSP5BtwrfKi+fv3FmRmaZ9JUaLi
+FRhnBkp/1Wy1TbMz4GHrXb7pmA8y1x1LPC5aAVKRCfLf6o3YBkBjqhHk/sM3nhRS
+P/TizPJhk9H9Z2vXUq6/aKtAQ6BXNVN48FP4YUIHZMbXb5tMOA1jrGKvNouicwoN
+9SG9dKpN6nIDSdvHXx1iY8f93ZHsM+71bbRuMGjeyNYmsHVee7QHIJihdjK4TWxP
+AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMmAd+BikoL1Rpzz
+uvdMw964o605MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAU18h
+9bqwOlI5LJKwbADJ784g7wbylp7ppHR/ehb8t/W2+xUbP6umwHJdELFx7rxP462s
+A20ucS6vxOOto70MEae0/0qyexAQH6dXQbLArvQsWdZHEIjzIVEpMMpghq9Gqx3t
+OluwlN5E40EIosHsHdb9T7bWR9AUC8rmyrV7d35BH16Dx7aMOZawP5aBQW9gkOLo
++fsicdl9sz1Gv7SEr5AcD48Saq/v7h56rgJKihcrdv6sVIkkLE8/trKnToyokZf7
+KcZ7XC25y2a2t6hbElGFtQl+Ynhw/qlqYLYdDnkM/crqJIByw5c/8nerQyIKx+u2
+DISCLIBrQYoIwOula9+ZEsuK1V6ADJHgJgg2SMX6OBE1/yWDLfJ6v9r9jv6ly0Us
+H8SIU653DtmadsWOLB2jutXsMq7Aqqz30XpN69QH4kj3Io6wpJ9qzo6ysmD0oyLQ
+I+uUWnpp3Q+/QFesa1lQ2aOZ4W7+jQF5JyMV3pKdewlNWudLSDBaGOYKbeaP4NK7
+5t98biGCwWg5TbSYWGZizEqQXsP6JwSxeRV0mcy+rSDeJmAc61ZRpqPq5KM/p/9h
+3PFaTWwyI0PurKju7koSCTxdccK+efrCh2gdC/1cacwG0Jp9VJkqyTkaGa9LKkPz
+Y11aWOIv4x3kqdbQCtCev9eBCfHJxyYNrJgWVqA=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Buypass Class 3 Root CA O=Buypass AS-983163327
+# Subject: CN=Buypass Class 3 Root CA O=Buypass AS-983163327
+# Label: "Buypass Class 3 Root CA"
+# Serial: 2
+# MD5 Fingerprint: 3d:3b:18:9e:2c:64:5a:e8:d5:88:ce:0e:f9:37:c2:ec
+# SHA1 Fingerprint: da:fa:f7:fa:66:84:ec:06:8f:14:50:bd:c7:c2:81:a5:bc:a9:64:57
+# SHA256 Fingerprint: ed:f7:eb:bc:a2:7a:2a:38:4d:38:7b:7d:40:10:c6:66:e2:ed:b4:84:3e:4c:29:b4:ae:1d:5b:93:32:e6:b2:4d
+-----BEGIN CERTIFICATE-----
+MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd
+MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg
+Q2xhc3MgMyBSb290IENBMB4XDTEwMTAyNjA4Mjg1OFoXDTQwMTAyNjA4Mjg1OFow
+TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw
+HgYDVQQDDBdCdXlwYXNzIENsYXNzIDMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB
+BQADggIPADCCAgoCggIBAKXaCpUWUOOV8l6ddjEGMnqb8RB2uACatVI2zSRHsJ8Y
+ZLya9vrVediQYkwiL944PdbgqOkcLNt4EemOaFEVcsfzM4fkoF0LXOBXByow9c3E
+N3coTRiR5r/VUv1xLXA+58bEiuPwKAv0dpihi4dVsjoT/Lc+JzeOIuOoTyrvYLs9
+tznDDgFHmV0ST9tD+leh7fmdvhFHJlsTmKtdFoqwNxxXnUX/iJY2v7vKB3tvh2PX
+0DJq1l1sDPGzbjniazEuOQAnFN44wOwZZoYS6J1yFhNkUsepNxz9gjDthBgd9K5c
+/3ATAOux9TN6S9ZV+AWNS2mw9bMoNlwUxFFzTWsL8TQH2xc519woe2v1n/MuwU8X
+KhDzzMro6/1rqy6any2CbgTUUgGTLT2G/H783+9CHaZr77kgxve9oKeV/afmiSTY
+zIw0bOIjL9kSGiG5VZFvC5F5GQytQIgLcOJ60g7YaEi7ghM5EFjp2CoHxhLbWNvS
+O1UQRwUVZ2J+GGOmRj8JDlQyXr8NYnon74Do29lLBlo3WiXQCBJ31G8JUJc9yB3D
+34xFMFbG02SrZvPAXpacw8Tvw3xrizp5f7NJzz3iiZ+gMEuFuZyUJHmPfWupRWgP
+K9Dx2hzLabjKSWJtyNBjYt1gD1iqj6G8BaVmos8bdrKEZLFMOVLAMLrwjEsCsLa3
+AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEe4zf/lb+74suwv
+Tg75JbCOPGvDMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAACAj
+QTUEkMJAYmDv4jVM1z+s4jSQuKFvdvoWFqRINyzpkMLyPPgKn9iB5btb2iUspKdV
+cSQy9sgL8rxq+JOssgfCX5/bzMiKqr5qb+FJEMwx14C7u8jYog5kV+qi9cKpMRXS
+IGrs/CIBKM+GuIAeqcwRpTzyFrNHnfzSgCHEy9BHcEGhyoMZCCxt8l13nIoUE9Q2
+HJLw5QY33KbmkJs4j1xrG0aGQ0JfPgEHU1RdZX33inOhmlRaHylDFCfChQ+1iHsa
+O5S3HWCntZznKWlXWpuTekMwGwPXYshApqr8ZORK15FTAaggiG6cX0S5y2CBNOxv
+033aSF/rtJC8LakcC6wc1aJoIIAE1vyxjy+7SjENSoYc6+I2KSb12tjE8nVhz36u
+dmNKekBlk4f4HoCMhuWG1o8O/FMsYOgWYRqiPkN7zTlgVGr18okmAWiDSKIz6MkE
+kbIRNBE+6tBDGR8Dk5AM/1E9V/RBbuHLoL7ryWPNbczk+DaqaJ3tvV2XcEQNtg41
+3OEMXbugUZTLfhbrES+jkkXITHHZvMmZUldGL1DPvTVp9D0VzgalLA8+9oG6lLvD
+u79leNKGef9JOxqDDPDeeOzI8k1MGt6CKfjBWtrt7uYnXuhF0J0cUahoq0Tj0Itq
+4/g7u9xN12TyUb7mqqta6THuBrxzvxNiCp/HuZc=
+-----END CERTIFICATE-----
+
+# Issuer: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Subject: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Label: "T-TeleSec GlobalRoot Class 3"
+# Serial: 1
+# MD5 Fingerprint: ca:fb:40:a8:4e:39:92:8a:1d:fe:8e:2f:c4:27:ea:ef
+# SHA1 Fingerprint: 55:a6:72:3e:cb:f2:ec:cd:c3:23:74:70:19:9d:2a:be:11:e3:81:d1
+# SHA256 Fingerprint: fd:73:da:d3:1c:64:4f:f1:b4:3b:ef:0c:cd:da:96:71:0b:9c:d9:87:5e:ca:7e:31:70:7a:f3:e9:6d:52:2b:bd
+-----BEGIN CERTIFICATE-----
+MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
+KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
+BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
+YyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1
+OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
+aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
+ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN
+8ELg63iIVl6bmlQdTQyK9tPPcPRStdiTBONGhnFBSivwKixVA9ZIw+A5OO3yXDw/
+RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuhdfsaa3Ox+M6pCSzyU9XDFES4
+hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Zf3WHHx+xGwpzJFu5
+ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W0eDrXltM
+EnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1
+A/d2O2GCahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOy
+WL6ukK2YJ5f+AbGwUgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ
+1GSFS5mvJQQeyUapl96Cshtwn5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW30
+6gmv7PO15wWeph6KU1HWk4HMdJP2udqmJQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT
+91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMivgkeGj5asuRrDFR6fUNOuIml
+e9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7PHi4b6HQDWSieB4p
+TpPDpFQUWw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH
+# Subject: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH
+# Label: "D-TRUST Root Class 3 CA 2 2009"
+# Serial: 623603
+# MD5 Fingerprint: cd:e0:25:69:8d:47:ac:9c:89:35:90:f7:fd:51:3d:2f
+# SHA1 Fingerprint: 58:e8:ab:b0:36:15:33:fb:80:f7:9b:1b:6d:29:d3:ff:8d:5f:00:f0
+# SHA256 Fingerprint: 49:e7:a4:42:ac:f0:ea:62:87:05:00:54:b5:25:64:b6:50:e4:f4:9e:42:e3:48:d6:aa:38:e0:39:e9:57:b1:c1
+-----BEGIN CERTIFICATE-----
+MIIEMzCCAxugAwIBAgIDCYPzMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNVBAYTAkRF
+MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMMHkQtVFJVU1QgUm9vdCBD
+bGFzcyAzIENBIDIgMjAwOTAeFw0wOTExMDUwODM1NThaFw0yOTExMDUwODM1NTha
+ME0xCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMM
+HkQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgMjAwOTCCASIwDQYJKoZIhvcNAQEB
+BQADggEPADCCAQoCggEBANOySs96R+91myP6Oi/WUEWJNTrGa9v+2wBoqOADER03
+UAifTUpolDWzU9GUY6cgVq/eUXjsKj3zSEhQPgrfRlWLJ23DEE0NkVJD2IfgXU42
+tSHKXzlABF9bfsyjxiupQB7ZNoTWSPOSHjRGICTBpFGOShrvUD9pXRl/RcPHAY9R
+ySPocq60vFYJfxLLHLGvKZAKyVXMD9O0Gu1HNVpK7ZxzBCHQqr0ME7UAyiZsxGsM
+lFqVlNpQmvH/pStmMaTJOKDfHR+4CS7zp+hnUquVH+BGPtikw8paxTGA6Eian5Rp
+/hnd2HN8gcqW3o7tszIFZYQ05ub9VxC1X3a/L7AQDcUCAwEAAaOCARowggEWMA8G
+A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFP3aFMSfMN4hvR5COfyrYyNJ4PGEMA4G
+A1UdDwEB/wQEAwIBBjCB0wYDVR0fBIHLMIHIMIGAoH6gfIZ6bGRhcDovL2RpcmVj
+dG9yeS5kLXRydXN0Lm5ldC9DTj1ELVRSVVNUJTIwUm9vdCUyMENsYXNzJTIwMyUy
+MENBJTIwMiUyMDIwMDksTz1ELVRydXN0JTIwR21iSCxDPURFP2NlcnRpZmljYXRl
+cmV2b2NhdGlvbmxpc3QwQ6BBoD+GPWh0dHA6Ly93d3cuZC10cnVzdC5uZXQvY3Js
+L2QtdHJ1c3Rfcm9vdF9jbGFzc18zX2NhXzJfMjAwOS5jcmwwDQYJKoZIhvcNAQEL
+BQADggEBAH+X2zDI36ScfSF6gHDOFBJpiBSVYEQBrLLpME+bUMJm2H6NMLVwMeni
+acfzcNsgFYbQDfC+rAF1hM5+n02/t2A7nPPKHeJeaNijnZflQGDSNiH+0LS4F9p0
+o3/U37CYAqxva2ssJSRyoWXuJVrl5jLn8t+rSfrzkGkj2wTZ51xY/GXUl77M/C4K
+zCUqNQT4YJEVdT1B/yMfGchs64JTBKbkTCJNjYy6zltz7GRUUG3RnFX7acM2w4y8
+PIWmawomDeCTmGCufsYkl4phX5GOZpIJhzbNi5stPvZR1FDUWSi9g/LMKHtThm3Y
+Johw1+qRzT65ysCQblrGXnRl11z+o+I=
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH
+# Subject: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH
+# Label: "D-TRUST Root Class 3 CA 2 EV 2009"
+# Serial: 623604
+# MD5 Fingerprint: aa:c6:43:2c:5e:2d:cd:c4:34:c0:50:4f:11:02:4f:b6
+# SHA1 Fingerprint: 96:c9:1b:0b:95:b4:10:98:42:fa:d0:d8:22:79:fe:60:fa:b9:16:83
+# SHA256 Fingerprint: ee:c5:49:6b:98:8c:e9:86:25:b9:34:09:2e:ec:29:08:be:d0:b0:f3:16:c2:d4:73:0c:84:ea:f1:f3:d3:48:81
+-----BEGIN CERTIFICATE-----
+MIIEQzCCAyugAwIBAgIDCYP0MA0GCSqGSIb3DQEBCwUAMFAxCzAJBgNVBAYTAkRF
+MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNVBAMMIUQtVFJVU1QgUm9vdCBD
+bGFzcyAzIENBIDIgRVYgMjAwOTAeFw0wOTExMDUwODUwNDZaFw0yOTExMDUwODUw
+NDZaMFAxCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNV
+BAMMIUQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgRVYgMjAwOTCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBAJnxhDRwui+3MKCOvXwEz75ivJn9gpfSegpn
+ljgJ9hBOlSJzmY3aFS3nBfwZcyK3jpgAvDw9rKFs+9Z5JUut8Mxk2og+KbgPCdM0
+3TP1YtHhzRnp7hhPTFiu4h7WDFsVWtg6uMQYZB7jM7K1iXdODL/ZlGsTl28So/6Z
+qQTMFexgaDbtCHu39b+T7WYxg4zGcTSHThfqr4uRjRxWQa4iN1438h3Z0S0NL2lR
+p75mpoo6Kr3HGrHhFPC+Oh25z1uxav60sUYgovseO3Dvk5h9jHOW8sXvhXCtKSb8
+HgQ+HKDYD8tSg2J87otTlZCpV6LqYQXY+U3EJ/pure3511H3a6UCAwEAAaOCASQw
+ggEgMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNOUikxiEyoZLsyvcop9Ntea
+HNxnMA4GA1UdDwEB/wQEAwIBBjCB3QYDVR0fBIHVMIHSMIGHoIGEoIGBhn9sZGFw
+Oi8vZGlyZWN0b3J5LmQtdHJ1c3QubmV0L0NOPUQtVFJVU1QlMjBSb290JTIwQ2xh
+c3MlMjAzJTIwQ0ElMjAyJTIwRVYlMjAyMDA5LE89RC1UcnVzdCUyMEdtYkgsQz1E
+RT9jZXJ0aWZpY2F0ZXJldm9jYXRpb25saXN0MEagRKBChkBodHRwOi8vd3d3LmQt
+dHJ1c3QubmV0L2NybC9kLXRydXN0X3Jvb3RfY2xhc3NfM19jYV8yX2V2XzIwMDku
+Y3JsMA0GCSqGSIb3DQEBCwUAA4IBAQA07XtaPKSUiO8aEXUHL7P+PPoeUSbrh/Yp
+3uDx1MYkCenBz1UbtDDZzhr+BlGmFaQt77JLvyAoJUnRpjZ3NOhk31KxEcdzes05
+nsKtjHEh8lprr988TlWvsoRlFIm5d8sqMb7Po23Pb0iUMkZv53GMoKaEGTcH8gNF
+CSuGdXzfX2lXANtu2KZyIktQ1HWYVt+3GP9DQ1CuekR78HlR10M9p9OB0/DJT7na
+xpeG0ILD5EJt/rDiZE4OJudANCa1CInXCGNjOCd1HjPqbqjdn5lPdE2BiYBL3ZqX
+KVwvvoFBuYz/6n1gBp7N1z3TLqMVvKjmJuVvw9y4AyHqnxbxLFS1
+-----END CERTIFICATE-----
+
+# Issuer: CN=CA Disig Root R2 O=Disig a.s.
+# Subject: CN=CA Disig Root R2 O=Disig a.s.
+# Label: "CA Disig Root R2"
+# Serial: 10572350602393338211
+# MD5 Fingerprint: 26:01:fb:d8:27:a7:17:9a:45:54:38:1a:43:01:3b:03
+# SHA1 Fingerprint: b5:61:eb:ea:a4:de:e4:25:4b:69:1a:98:a5:57:47:c2:34:c7:d9:71
+# SHA256 Fingerprint: e2:3d:4a:03:6d:7b:70:e9:f5:95:b1:42:20:79:d2:b9:1e:df:bb:1f:b6:51:a0:63:3e:aa:8a:9d:c5:f8:07:03
+-----BEGIN CERTIFICATE-----
+MIIFaTCCA1GgAwIBAgIJAJK4iNuwisFjMA0GCSqGSIb3DQEBCwUAMFIxCzAJBgNV
+BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu
+MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIyMB4XDTEyMDcxOTA5MTUzMFoXDTQy
+MDcxOTA5MTUzMFowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx
+EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjIw
+ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCio8QACdaFXS1tFPbCw3Oe
+NcJxVX6B+6tGUODBfEl45qt5WDza/3wcn9iXAng+a0EE6UG9vgMsRfYvZNSrXaNH
+PWSb6WiaxswbP7q+sos0Ai6YVRn8jG+qX9pMzk0DIaPY0jSTVpbLTAwAFjxfGs3I
+x2ymrdMxp7zo5eFm1tL7A7RBZckQrg4FY8aAamkw/dLukO8NJ9+flXP04SXabBbe
+QTg06ov80egEFGEtQX6sx3dOy1FU+16SGBsEWmjGycT6txOgmLcRK7fWV8x8nhfR
+yyX+hk4kLlYMeE2eARKmK6cBZW58Yh2EhN/qwGu1pSqVg8NTEQxzHQuyRpDRQjrO
+QG6Vrf/GlK1ul4SOfW+eioANSW1z4nuSHsPzwfPrLgVv2RvPN3YEyLRa5Beny912
+H9AZdugsBbPWnDTYltxhh5EF5EQIM8HauQhl1K6yNg3ruji6DOWbnuuNZt2Zz9aJ
+QfYEkoopKW1rOhzndX0CcQ7zwOe9yxndnWCywmZgtrEE7snmhrmaZkCo5xHtgUUD
+i/ZnWejBBhG93c+AAk9lQHhcR1DIm+YfgXvkRKhbhZri3lrVx/k6RGZL5DJUfORs
+nLMOPReisjQS1n6yqEm70XooQL6iFh/f5DcfEXP7kAplQ6INfPgGAVUzfbANuPT1
+rqVCV3w2EYx7XsQDnYx5nQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud
+DwEB/wQEAwIBBjAdBgNVHQ4EFgQUtZn4r7CU9eMg1gqtzk5WpC5uQu0wDQYJKoZI
+hvcNAQELBQADggIBACYGXnDnZTPIgm7ZnBc6G3pmsgH2eDtpXi/q/075KMOYKmFM
+tCQSin1tERT3nLXK5ryeJ45MGcipvXrA1zYObYVybqjGom32+nNjf7xueQgcnYqf
+GopTpti72TVVsRHFqQOzVju5hJMiXn7B9hJSi+osZ7z+Nkz1uM/Rs0mSO9MpDpkb
+lvdhuDvEK7Z4bLQjb/D907JedR+Zlais9trhxTF7+9FGs9K8Z7RiVLoJ92Owk6Ka
++elSLotgEqv89WBW7xBci8QaQtyDW2QOy7W81k/BfDxujRNt+3vrMNDcTa/F1bal
+TFtxyegxvug4BkihGuLq0t4SOVga/4AOgnXmt8kHbA7v/zjxmHHEt38OFdAlab0i
+nSvtBfZGR6ztwPDUO+Ls7pZbkBNOHlY667DvlruWIxG68kOGdGSVyCh13x01utI3
+gzhTODY7z2zp+WsO0PsE6E9312UBeIYMej4hYvF/Y3EMyZ9E26gnonW+boE+18Dr
+G5gPcFw0sorMwIUY6256s/daoQe/qUKS82Ail+QUoQebTnbAjn39pCXHR+3/H3Os
+zMOl6W8KjptlwlCFtaOgUxLMVYdh84GuEEZhvUQhuMI9dM9+JDX6HAcOmz0iyu8x
+L4ysEr3vQCj8KWefshNPZiTEUxnpHikV7+ZtsH8tZ/3zbBt1RqPlShfppNcL
+-----END CERTIFICATE-----
+
+# Issuer: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV
+# Subject: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV
+# Label: "ACCVRAIZ1"
+# Serial: 6828503384748696800
+# MD5 Fingerprint: d0:a0:5a:ee:05:b6:09:94:21:a1:7d:f1:b2:29:82:02
+# SHA1 Fingerprint: 93:05:7a:88:15:c6:4f:ce:88:2f:fa:91:16:52:28:78:bc:53:64:17
+# SHA256 Fingerprint: 9a:6e:c0:12:e1:a7:da:9d:be:34:19:4d:47:8a:d7:c0:db:18:22:fb:07:1d:f1:29:81:49:6e:d1:04:38:41:13
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA
+# Subject: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA
+# Label: "TWCA Global Root CA"
+# Serial: 3262
+# MD5 Fingerprint: f9:03:7e:cf:e6:9e:3c:73:7a:2a:90:07:69:ff:2b:96
+# SHA1 Fingerprint: 9c:bb:48:53:f6:a4:f6:d3:52:a4:e8:32:52:55:60:13:f5:ad:af:65
+# SHA256 Fingerprint: 59:76:90:07:f7:68:5d:0f:cd:50:87:2f:9f:95:d5:75:5a:5b:2b:45:7d:81:f3:69:2b:61:0a:98:67:2f:0e:1b
+-----BEGIN CERTIFICATE-----
+MIIFQTCCAymgAwIBAgICDL4wDQYJKoZIhvcNAQELBQAwUTELMAkGA1UEBhMCVFcx
+EjAQBgNVBAoTCVRBSVdBTi1DQTEQMA4GA1UECxMHUm9vdCBDQTEcMBoGA1UEAxMT
+VFdDQSBHbG9iYWwgUm9vdCBDQTAeFw0xMjA2MjcwNjI4MzNaFw0zMDEyMzExNTU5
+NTlaMFExCzAJBgNVBAYTAlRXMRIwEAYDVQQKEwlUQUlXQU4tQ0ExEDAOBgNVBAsT
+B1Jvb3QgQ0ExHDAaBgNVBAMTE1RXQ0EgR2xvYmFsIFJvb3QgQ0EwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCwBdvI64zEbooh745NnHEKH1Jw7W2CnJfF
+10xORUnLQEK1EjRsGcJ0pDFfhQKX7EMzClPSnIyOt7h52yvVavKOZsTuKwEHktSz
+0ALfUPZVr2YOy+BHYC8rMjk1Ujoog/h7FsYYuGLWRyWRzvAZEk2tY/XTP3VfKfCh
+MBwqoJimFb3u/Rk28OKRQ4/6ytYQJ0lM793B8YVwm8rqqFpD/G2Gb3PpN0Wp8DbH
+zIh1HrtsBv+baz4X7GGqcXzGHaL3SekVtTzWoWH1EfcFbx39Eb7QMAfCKbAJTibc
+46KokWofwpFFiFzlmLhxpRUZyXx1EcxwdE8tmx2RRP1WKKD+u4ZqyPpcC1jcxkt2
+yKsi2XMPpfRaAok/T54igu6idFMqPVMnaR1sjjIsZAAmY2E2TqNGtz99sy2sbZCi
+laLOz9qC5wc0GZbpuCGqKX6mOL6OKUohZnkfs8O1CWfe1tQHRvMq2uYiN2DLgbYP
+oA/pyJV/v1WRBXrPPRXAb94JlAGD1zQbzECl8LibZ9WYkTunhHiVJqRaCPgrdLQA
+BDzfuBSO6N+pjWxnkjMdwLfS7JLIvgm/LCkFbwJrnu+8vyq8W8BQj0FwcYeyTbcE
+qYSjMq+u7msXi7Kx/mzhkIyIqJdIzshNy/MGz19qCkKxHh53L46g5pIOBvwFItIm
+4TFRfTLcDwIDAQABoyMwITAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB
+/zANBgkqhkiG9w0BAQsFAAOCAgEAXzSBdu+WHdXltdkCY4QWwa6gcFGn90xHNcgL
+1yg9iXHZqjNB6hQbbCEAwGxCGX6faVsgQt+i0trEfJdLjbDorMjupWkEmQqSpqsn
+LhpNgb+E1HAerUf+/UqdM+DyucRFCCEK2mlpc3INvjT+lIutwx4116KD7+U4x6WF
+H6vPNOw/KP4M8VeGTslV9xzU2KV9Bnpv1d8Q34FOIWWxtuEXeZVFBs5fzNxGiWNo
+RI2T9GRwoD2dKAXDOXC4Ynsg/eTb6QihuJ49CcdP+yz4k3ZB3lLg4VfSnQO8d57+
+nile98FRYB/e2guyLXW3Q0iT5/Z5xoRdgFlglPx4mI88k1HtQJAH32RjJMtOcQWh
+15QaiDLxInQirqWm2BJpTGCjAu4r7NRjkgtevi92a6O2JryPA9gK8kxkRr05YuWW
+6zRjESjMlfGt7+/cgFhI6Uu46mWs6fyAtbXIRfmswZ/ZuepiiI7E8UuDEq3mi4TW
+nsLrgxifarsbJGAzcMzs9zLzXNl5fe+epP7JI8Mk7hWSsT2RTyaGvWZzJBPqpK5j
+wa19hAM8EHiGG3njxPPyBJUgriOCxLM6AGK/5jYk4Ve6xx6QddVfP5VhK8E7zeWz
+aGHQRiapIVJpLesux+t3zqY6tQMzT3bR51xUAV3LePTJDL/PEo4XLSNolOer/qmy
+KwbQBM0=
+-----END CERTIFICATE-----
+
+# Issuer: CN=TeliaSonera Root CA v1 O=TeliaSonera
+# Subject: CN=TeliaSonera Root CA v1 O=TeliaSonera
+# Label: "TeliaSonera Root CA v1"
+# Serial: 199041966741090107964904287217786801558
+# MD5 Fingerprint: 37:41:49:1b:18:56:9a:26:f5:ad:c2:66:fb:40:a5:4c
+# SHA1 Fingerprint: 43:13:bb:96:f1:d5:86:9b:c1:4e:6a:92:f6:cf:f6:34:69:87:82:37
+# SHA256 Fingerprint: dd:69:36:fe:21:f8:f0:77:c1:23:a1:a5:21:c1:22:24:f7:22:55:b7:3e:03:a7:26:06:93:e8:a2:4b:0f:a3:89
+-----BEGIN CERTIFICATE-----
+MIIFODCCAyCgAwIBAgIRAJW+FqD3LkbxezmCcvqLzZYwDQYJKoZIhvcNAQEFBQAw
+NzEUMBIGA1UECgwLVGVsaWFTb25lcmExHzAdBgNVBAMMFlRlbGlhU29uZXJhIFJv
+b3QgQ0EgdjEwHhcNMDcxMDE4MTIwMDUwWhcNMzIxMDE4MTIwMDUwWjA3MRQwEgYD
+VQQKDAtUZWxpYVNvbmVyYTEfMB0GA1UEAwwWVGVsaWFTb25lcmEgUm9vdCBDQSB2
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMK+6yfwIaPzaSZVfp3F
+VRaRXP3vIb9TgHot0pGMYzHw7CTww6XScnwQbfQ3t+XmfHnqjLWCi65ItqwA3GV1
+7CpNX8GH9SBlK4GoRz6JI5UwFpB/6FcHSOcZrr9FZ7E3GwYq/t75rH2D+1665I+X
+Z75Ljo1kB1c4VWk0Nj0TSO9P4tNmHqTPGrdeNjPUtAa9GAH9d4RQAEX1jF3oI7x+
+/jXh7VB7qTCNGdMJjmhnXb88lxhTuylixcpecsHHltTbLaC0H2kD7OriUPEMPPCs
+81Mt8Bz17Ww5OXOAFshSsCPN4D7c3TxHoLs1iuKYaIu+5b9y7tL6pe0S7fyYGKkm
+dtwoSxAgHNN/Fnct7W+A90m7UwW7XWjH1Mh1Fj+JWov3F0fUTPHSiXk+TT2YqGHe
+Oh7S+F4D4MHJHIzTjU3TlTazN19jY5szFPAtJmtTfImMMsJu7D0hADnJoWjiUIMu
+sDor8zagrC/kb2HCUQk5PotTubtn2txTuXZZNp1D5SDgPTJghSJRt8czu90VL6R4
+pgd7gUY2BIbdeTXHlSw7sKMXNeVzH7RcWe/a6hBle3rQf5+ztCo3O3CLm1u5K7fs
+slESl1MpWtTwEhDcTwK7EpIvYtQ/aUN8Ddb8WHUBiJ1YFkveupD/RwGJBmr2X7KQ
+arMCpgKIv7NHfirZ1fpoeDVNAgMBAAGjPzA9MA8GA1UdEwEB/wQFMAMBAf8wCwYD
+VR0PBAQDAgEGMB0GA1UdDgQWBBTwj1k4ALP1j5qWDNXr+nuqF+gTEjANBgkqhkiG
+9w0BAQUFAAOCAgEAvuRcYk4k9AwI//DTDGjkk0kiP0Qnb7tt3oNmzqjMDfz1mgbl
+dxSR651Be5kqhOX//CHBXfDkH1e3damhXwIm/9fH907eT/j3HEbAek9ALCI18Bmx
+0GtnLLCo4MBANzX2hFxc469CeP6nyQ1Q6g2EdvZR74NTxnr/DlZJLo961gzmJ1Tj
+TQpgcmLNkQfWpb/ImWvtxBnmq0wROMVvMeJuScg/doAmAyYp4Db29iBT4xdwNBed
+Y2gea+zDTYa4EzAvXUYNR0PVG6pZDrlcjQZIrXSHX8f8MVRBE+LHIQ6e4B4N4cB7
+Q4WQxYpYxmUKeFfyxiMPAdkgS94P+5KFdSpcc41teyWRyu5FrgZLAMzTsVlQ2jqI
+OylDRl6XK1TOU2+NSueW+r9xDkKLfP0ooNBIytrEgUy7onOTJsjrDNYmiLbAJM+7
+vVvrdX3pCI6GMyx5dwlppYn8s3CQh3aP0yK7Qs69cwsgJirQmz1wHiRszYd2qReW
+t88NkvuOGKmYSdGe/mBEciG5Ge3C9THxOUiIkCR1VBatzvT4aRRkOfujuLpwQMcn
+HL/EVlP6Y2XQ8xwOFvVrhlhNGNTkDY6lnVuR3HYkUD/GKvvZt5y11ubQ2egZixVx
+SK236thZiNSQvxaz2emsWWFUyBy6ysHK4bkgTI86k4mloMy/0/Z1pHWWbVY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=E-Tugra Certification Authority O=E-Tu\u011fra EBG Bili\u015fim Teknolojileri ve Hizmetleri A.\u015e. OU=E-Tugra Sertifikasyon Merkezi
+# Subject: CN=E-Tugra Certification Authority O=E-Tu\u011fra EBG Bili\u015fim Teknolojileri ve Hizmetleri A.\u015e. OU=E-Tugra Sertifikasyon Merkezi
+# Label: "E-Tugra Certification Authority"
+# Serial: 7667447206703254355
+# MD5 Fingerprint: b8:a1:03:63:b0:bd:21:71:70:8a:6f:13:3a:bb:79:49
+# SHA1 Fingerprint: 51:c6:e7:08:49:06:6e:f3:92:d4:5c:a0:0d:6d:a3:62:8f:c3:52:39
+# SHA256 Fingerprint: b0:bf:d5:2b:b0:d7:d9:bd:92:bf:5d:4d:c1:3d:a2:55:c0:2c:54:2f:37:83:65:ea:89:39:11:f5:5e:55:f2:3c
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Subject: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Label: "T-TeleSec GlobalRoot Class 2"
+# Serial: 1
+# MD5 Fingerprint: 2b:9b:9e:e4:7b:6c:1f:00:72:1a:cc:c1:77:79:df:6a
+# SHA1 Fingerprint: 59:0d:2d:7d:88:4f:40:2e:61:7e:a5:62:32:17:65:cf:17:d8:94:e9
+# SHA256 Fingerprint: 91:e2:f5:78:8d:58:10:eb:a7:ba:58:73:7d:e1:54:8a:8e:ca:cd:01:45:98:bc:0b:14:3e:04:1b:17:05:25:52
+-----BEGIN CERTIFICATE-----
+MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
+KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
+BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
+YyBHbG9iYWxSb290IENsYXNzIDIwHhcNMDgxMDAxMTA0MDE0WhcNMzMxMDAxMjM1
+OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
+aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
+ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDIwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqX9obX+hzkeXaXPSi5kfl82hVYAUd
+AqSzm1nzHoqvNK38DcLZSBnuaY/JIPwhqgcZ7bBcrGXHX+0CfHt8LRvWurmAwhiC
+FoT6ZrAIxlQjgeTNuUk/9k9uN0goOA/FvudocP05l03Sx5iRUKrERLMjfTlH6VJi
+1hKTXrcxlkIF+3anHqP1wvzpesVsqXFP6st4vGCvx9702cu+fjOlbpSD8DT6Iavq
+jnKgP6TeMFvvhk1qlVtDRKgQFRzlAVfFmPHmBiiRqiDFt1MmUUOyCxGVWOHAD3bZ
+wI18gfNycJ5v/hqO2V81xrJvNHy+SE/iWjnX2J14np+GPgNeGYtEotXHAgMBAAGj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS/
+WSA2AHmgoCJrjNXyYdK4LMuCSjANBgkqhkiG9w0BAQsFAAOCAQEAMQOiYQsfdOhy
+NsZt+U2e+iKo4YFWz827n+qrkRk4r6p8FU3ztqONpfSO9kSpp+ghla0+AGIWiPAC
+uvxhI+YzmzB6azZie60EI4RYZeLbK4rnJVM3YlNfvNoBYimipidx5joifsFvHZVw
+IEoHNN/q/xWA5brXethbdXwFeilHfkCoMRN3zUA7tFFHei4R40cR3p1m0IvVVGb6
+g1XqfMIpiRvpb7PO4gWEyS8+eIVibslfwXhjdFjASBgMmTnrpMwatXlajRWc2BQN
+9noHV8cigwUtPJslJj0Ys6lDfMjIq2SPDqO/nBudMNva0Bkuqjzx+zOAduTNrRlP
+BSeOE6Fuwg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Atos TrustedRoot 2011 O=Atos
+# Subject: CN=Atos TrustedRoot 2011 O=Atos
+# Label: "Atos TrustedRoot 2011"
+# Serial: 6643877497813316402
+# MD5 Fingerprint: ae:b9:c4:32:4b:ac:7f:5d:66:cc:77:94:bb:2a:77:56
+# SHA1 Fingerprint: 2b:b1:f5:3e:55:0c:1d:c5:f1:d4:e6:b7:6a:46:4b:55:06:02:ac:21
+# SHA256 Fingerprint: f3:56:be:a2:44:b7:a9:1e:b3:5d:53:ca:9a:d7:86:4a:ce:01:8e:2d:35:d5:f8:f9:6d:df:68:a6:f4:1a:a4:74
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIIXDPLYixfszIwDQYJKoZIhvcNAQELBQAwPDEeMBwGA1UE
+AwwVQXRvcyBUcnVzdGVkUm9vdCAyMDExMQ0wCwYDVQQKDARBdG9zMQswCQYDVQQG
+EwJERTAeFw0xMTA3MDcxNDU4MzBaFw0zMDEyMzEyMzU5NTlaMDwxHjAcBgNVBAMM
+FUF0b3MgVHJ1c3RlZFJvb3QgMjAxMTENMAsGA1UECgwEQXRvczELMAkGA1UEBhMC
+REUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCVhTuXbyo7LjvPpvMp
+Nb7PGKw+qtn4TaA+Gke5vJrf8v7MPkfoepbCJI419KkM/IL9bcFyYie96mvr54rM
+VD6QUM+A1JX76LWC1BTFtqlVJVfbsVD2sGBkWXppzwO3bw2+yj5vdHLqqjAqc2K+
+SZFhyBH+DgMq92og3AIVDV4VavzjgsG1xZ1kCWyjWZgHJ8cblithdHFsQ/H3NYkQ
+4J7sVaE3IqKHBAUsR320HLliKWYoyrfhk/WklAOZuXCFteZI6o1Q/NnezG8HDt0L
+cp2AMBYHlT8oDv3FdU9T1nSatCQujgKRz3bFmx5VdJx4IbHwLfELn8LVlhgf8FQi
+eowHAgMBAAGjfTB7MB0GA1UdDgQWBBSnpQaxLKYJYO7Rl+lwrrw7GWzbITAPBgNV
+HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKelBrEspglg7tGX6XCuvDsZbNshMBgG
+A1UdIAQRMA8wDQYLKwYBBAGwLQMEAQEwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3
+DQEBCwUAA4IBAQAmdzTblEiGKkGdLD4GkGDEjKwLVLgfuXvTBznk+j57sj1O7Z8j
+vZfza1zv7v1Apt+hk6EKhqzvINB5Ab149xnYJDE0BAGmuhWawyfc2E8PzBhj/5kP
+DpFrdRbhIfzYJsdHt6bPWHJxfrrhTZVHO8mvbaG0weyJ9rQPOLXiZNwlz6bb65pc
+maHFCN795trV1lpFDMS3wrUU77QR/w4VtfX128a961qn8FYiqTxlVMYVqL2Gns2D
+lmh6cYGJ4Qvh6hEbaAjMaZ7snkGeRDImeuKHCnE96+RapNLbxc3G3mB/ufNPRJLv
+KrcYPqcZ2Qt9sTdBQrC6YB3y/gkRsPCHe6ed
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 1 G3"
+# Serial: 687049649626669250736271037606554624078720034195
+# MD5 Fingerprint: a4:bc:5b:3f:fe:37:9a:fa:64:f0:e2:fa:05:3d:0b:ab
+# SHA1 Fingerprint: 1b:8e:ea:57:96:29:1a:c9:39:ea:b8:0a:81:1a:73:73:c0:93:79:67
+# SHA256 Fingerprint: 8a:86:6f:d1:b2:76:b5:7e:57:8e:92:1c:65:82:8a:2b:ed:58:e9:f2:f2:88:05:41:34:b7:f1:f4:bf:c9:cc:74
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIUeFhfLq0sGUvjNwc1NBMotZbUZZMwDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMSBHMzAeFw0xMjAxMTIxNzI3NDRaFw00
+MjAxMTIxNzI3NDRaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDEgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvlAQjunybEC0BJyFuTHK3C3kEakEPBtV
+wedYMB0ktMPvhd6MLOHBPd+C5k+tR4ds7FtJwUrVu4/sh6x/gpqG7D0DmVIB0jWe
+rNrwU8lmPNSsAgHaJNM7qAJGr6Qc4/hzWHa39g6QDbXwz8z6+cZM5cOGMAqNF341
+68Xfuw6cwI2H44g4hWf6Pser4BOcBRiYz5P1sZK0/CPTz9XEJ0ngnjybCKOLXSoh
+4Pw5qlPafX7PGglTvF0FBM+hSo+LdoINofjSxxR3W5A2B4GbPgb6Ul5jxaYA/qXp
+UhtStZI5cgMJYr2wYBZupt0lwgNm3fME0UDiTouG9G/lg6AnhF4EwfWQvTA9xO+o
+abw4m6SkltFi2mnAAZauy8RRNOoMqv8hjlmPSlzkYZqn0ukqeI1RPToV7qJZjqlc
+3sX5kCLliEVx3ZGZbHqfPT2YfF72vhZooF6uCyP8Wg+qInYtyaEQHeTTRCOQiJ/G
+KubX9ZqzWB4vMIkIG1SitZgj7Ah3HJVdYdHLiZxfokqRmu8hqkkWCKi9YSgxyXSt
+hfbZxbGL0eUQMk1fiyA6PEkfM4VZDdvLCXVDaXP7a3F98N/ETH3Goy7IlXnLc6KO
+Tk0k+17kBL5yG6YnLUlamXrXXAkgt3+UuU/xDRxeiEIbEbfnkduebPRq34wGmAOt
+zCjvpUfzUwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQUo5fW816iEOGrRZ88F2Q87gFwnMwwDQYJKoZIhvcNAQELBQAD
+ggIBABj6W3X8PnrHX3fHyt/PX8MSxEBd1DKquGrX1RUVRpgjpeaQWxiZTOOtQqOC
+MTaIzen7xASWSIsBx40Bz1szBpZGZnQdT+3Btrm0DWHMY37XLneMlhwqI2hrhVd2
+cDMT/uFPpiN3GPoajOi9ZcnPP/TJF9zrx7zABC4tRi9pZsMbj/7sPtPKlL92CiUN
+qXsCHKnQO18LwIE6PWThv6ctTr1NxNgpxiIY0MWscgKCP6o6ojoilzHdCGPDdRS5
+YCgtW2jgFqlmgiNR9etT2DGbe+m3nUvriBbP+V04ikkwj+3x6xn0dxoxGE1nVGwv
+b2X52z3sIexe9PSLymBlVNFxZPT5pqOBMzYzcfCkeF9OrYMh3jRJjehZrJ3ydlo2
+8hP0r+AJx2EqbPfgna67hkooby7utHnNkDPDs3b69fBsnQGQ+p6Q9pxyz0fawx/k
+NSBT8lTR32GDpgLiJTjehTItXnOQUl1CxM49S+H5GYQd1aJQzEH7QRTDvdbJWqNj
+ZgKAvQU6O0ec7AAmTPWIUb+oI38YB7AL7YsmoWTTYUrrXJ/es69nA7Mf3W1daWhp
+q1467HxpvMc7hU6eFbm0FU/DlXpY18ls6Wy58yljXrQs8C097Vpl4KlbQMJImYFt
+nh8GKjwStIsPm6Ik8KaN1nrgS7ZklmOVhMJKzRwuJIczYOXD
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 2 G3"
+# Serial: 390156079458959257446133169266079962026824725800
+# MD5 Fingerprint: af:0c:86:6e:bf:40:2d:7f:0b:3e:12:50:ba:12:3d:06
+# SHA1 Fingerprint: 09:3c:61:f3:8b:8b:dc:7d:55:df:75:38:02:05:00:e1:25:f5:c8:36
+# SHA256 Fingerprint: 8f:e4:fb:0a:f9:3a:4d:0d:67:db:0b:eb:b2:3e:37:c7:1b:f3:25:dc:bc:dd:24:0e:a0:4d:af:58:b4:7e:18:40
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIURFc0JFuBiZs18s64KztbpybwdSgwDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMiBHMzAeFw0xMjAxMTIxODU5MzJaFw00
+MjAxMTIxODU5MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDIgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQChriWyARjcV4g/Ruv5r+LrI3HimtFhZiFf
+qq8nUeVuGxbULX1QsFN3vXg6YOJkApt8hpvWGo6t/x8Vf9WVHhLL5hSEBMHfNrMW
+n4rjyduYNM7YMxcoRvynyfDStNVNCXJJ+fKH46nafaF9a7I6JaltUkSs+L5u+9ym
+c5GQYaYDFCDy54ejiK2toIz/pgslUiXnFgHVy7g1gQyjO/Dh4fxaXc6AcW34Sas+
+O7q414AB+6XrW7PFXmAqMaCvN+ggOp+oMiwMzAkd056OXbxMmO7FGmh77FOm6RQ1
+o9/NgJ8MSPsc9PG/Srj61YxxSscfrf5BmrODXfKEVu+lV0POKa2Mq1W/xPtbAd0j
+IaFYAI7D0GoT7RPjEiuA3GfmlbLNHiJuKvhB1PLKFAeNilUSxmn1uIZoL1NesNKq
+IcGY5jDjZ1XHm26sGahVpkUG0CM62+tlXSoREfA7T8pt9DTEceT/AFr2XK4jYIVz
+8eQQsSWu1ZK7E8EM4DnatDlXtas1qnIhO4M15zHfeiFuuDIIfR0ykRVKYnLP43eh
+vNURG3YBZwjgQQvD6xVu+KQZ2aKrr+InUlYrAoosFCT5v0ICvybIxo/gbjh9Uy3l
+7ZizlWNof/k19N+IxWA1ksB8aRxhlRbQ694Lrz4EEEVlWFA4r0jyWbYW8jwNkALG
+cC4BrTwV1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQU7edvdlq/YOxJW8ald7tyFnGbxD0wDQYJKoZIhvcNAQELBQAD
+ggIBAJHfgD9DCX5xwvfrs4iP4VGyvD11+ShdyLyZm3tdquXK4Qr36LLTn91nMX66
+AarHakE7kNQIXLJgapDwyM4DYvmL7ftuKtwGTTwpD4kWilhMSA/ohGHqPHKmd+RC
+roijQ1h5fq7KpVMNqT1wvSAZYaRsOPxDMuHBR//47PERIjKWnML2W2mWeyAMQ0Ga
+W/ZZGYjeVYg3UQt4XAoeo0L9x52ID8DyeAIkVJOviYeIyUqAHerQbj5hLja7NQ4n
+lv1mNDthcnPxFlxHBlRJAHpYErAK74X9sbgzdWqTHBLmYF5vHX/JHyPLhGGfHoJE
++V+tYlUkmlKY7VHnoX6XOuYvHxHaU4AshZ6rNRDbIl9qxV6XU/IyAgkwo1jwDQHV
+csaxfGl7w/U2Rcxhbl5MlMVerugOXou/983g7aEOGzPuVBj+D77vfoRrQ+NwmNtd
+dbINWQeFFSM51vHfqSYP1kjHs6Yi9TM3WpVHn3u6GBVv/9YUZINJ0gpnIdsPNWNg
+KCLjsZWDzYWm3S8P52dSbrsvhXz1SnPnxT7AvSESBT/8twNJAlvIJebiVDj1eYeM
+HVOyToV7BjjHLPj4sHKNJeV3UvQDHEimUF+IIDBu8oJDqz2XhOdT+yHBTw8imoa4
+WSr2Rz0ZiC3oheGe7IUIarFsNMkd7EgrO3jtZsSOeWmD3n+M
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 3 G3"
+# Serial: 268090761170461462463995952157327242137089239581
+# MD5 Fingerprint: df:7d:b9:ad:54:6f:68:a1:df:89:57:03:97:43:b0:d7
+# SHA1 Fingerprint: 48:12:bd:92:3c:a8:c4:39:06:e7:30:6d:27:96:e6:a4:cf:22:2e:7d
+# SHA256 Fingerprint: 88:ef:81:de:20:2e:b0:18:45:2e:43:f8:64:72:5c:ea:5f:bd:1f:c2:d9:d2:05:73:07:09:c5:d8:b8:69:0f:46
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIULvWbAiin23r/1aOp7r0DoM8Sah0wDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMyBHMzAeFw0xMjAxMTIyMDI2MzJaFw00
+MjAxMTIyMDI2MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDMgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCzyw4QZ47qFJenMioKVjZ/aEzHs286IxSR
+/xl/pcqs7rN2nXrpixurazHb+gtTTK/FpRp5PIpM/6zfJd5O2YIyC0TeytuMrKNu
+FoM7pmRLMon7FhY4futD4tN0SsJiCnMK3UmzV9KwCoWdcTzeo8vAMvMBOSBDGzXR
+U7Ox7sWTaYI+FrUoRqHe6okJ7UO4BUaKhvVZR74bbwEhELn9qdIoyhA5CcoTNs+c
+ra1AdHkrAj80//ogaX3T7mH1urPnMNA3I4ZyYUUpSFlob3emLoG+B01vr87ERROR
+FHAGjx+f+IdpsQ7vw4kZ6+ocYfx6bIrc1gMLnia6Et3UVDmrJqMz6nWB2i3ND0/k
+A9HvFZcba5DFApCTZgIhsUfei5pKgLlVj7WiL8DWM2fafsSntARE60f75li59wzw
+eyuxwHApw0BiLTtIadwjPEjrewl5qW3aqDCYz4ByA4imW0aucnl8CAMhZa634Ryl
+sSqiMd5mBPfAdOhx3v89WcyWJhKLhZVXGqtrdQtEPREoPHtht+KPZ0/l7DxMYIBp
+VzgeAVuNVejH38DMdyM0SXV89pgR6y3e7UEuFAUCf+D+IOs15xGsIs5XPd7JMG0Q
+A4XN8f+MFrXBsj6IbGB/kE+V9/YtrQE5BwT6dYB9v0lQ7e/JxHwc64B+27bQ3RP+
+ydOc17KXqQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQUxhfQvKjqAkPyGwaZXSuQILnXnOQwDQYJKoZIhvcNAQELBQAD
+ggIBADRh2Va1EodVTd2jNTFGu6QHcrxfYWLopfsLN7E8trP6KZ1/AvWkyaiTt3px
+KGmPc+FSkNrVvjrlt3ZqVoAh313m6Tqe5T72omnHKgqwGEfcIHB9UqM+WXzBusnI
+FUBhynLWcKzSt/Ac5IYp8M7vaGPQtSCKFWGafoaYtMnCdvvMujAWzKNhxnQT5Wvv
+oxXqA/4Ti2Tk08HS6IT7SdEQTXlm66r99I0xHnAUrdzeZxNMgRVhvLfZkXdxGYFg
+u/BYpbWcC/ePIlUnwEsBbTuZDdQdm2NnL9DuDcpmvJRPpq3t/O5jrFc/ZSXPsoaP
+0Aj/uHYUbt7lJ+yreLVTubY/6CD50qi+YUbKh4yE8/nxoGibIh6BJpsQBJFxwAYf
+3KDTuVan45gtf4Od34wrnDKOMpTwATwiKp9Dwi7DmDkHOHv8XgBCH/MyJnmDhPbl
+8MFREsALHgQjDFSlTC9JxUrRtm5gDWv8a4uFJGS3iQ6rJUdbPM9+Sb3H6QrG2vd+
+DhcI00iX0HGS8A85PjRqHH3Y8iKuu2n0M7SmSFXRDw4m6Oy2Cy2nhTXN/VnIn9HN
+PlopNLk9hM6xZdRZkZFWdSHBd575euFgndOtBBj0fOtek49TSiIp+EgrPk2GrFt/
+ywaZWWDYWGWVjUTR939+J399roD1B0y2PpxxVJkES/1Y+Zj0
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root G2"
+# Serial: 15385348160840213938643033620894905419
+# MD5 Fingerprint: 92:38:b9:f8:63:24:82:65:2c:57:33:e6:fe:81:8f:9d
+# SHA1 Fingerprint: a1:4b:48:d9:43:ee:0a:0e:40:90:4f:3c:e0:a4:c0:91:93:51:5d:3f
+# SHA256 Fingerprint: 7d:05:eb:b6:82:33:9f:8c:94:51:ee:09:4e:eb:fe:fa:79:53:a1:14:ed:b2:f4:49:49:45:2f:ab:7d:2f:c1:85
+-----BEGIN CERTIFICATE-----
+MIIDljCCAn6gAwIBAgIQC5McOtY5Z+pnI7/Dr5r0SzANBgkqhkiG9w0BAQsFADBl
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
+b3QgRzIwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
+cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzIwggEi
+MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZ5ygvUj82ckmIkzTz+GoeMVSA
+n61UQbVH35ao1K+ALbkKz3X9iaV9JPrjIgwrvJUXCzO/GU1BBpAAvQxNEP4Htecc
+biJVMWWXvdMX0h5i89vqbFCMP4QMls+3ywPgym2hFEwbid3tALBSfK+RbLE4E9Hp
+EgjAALAcKxHad3A2m67OeYfcgnDmCXRwVWmvo2ifv922ebPynXApVfSr/5Vh88lA
+bx3RvpO704gqu52/clpWcTs/1PPRCv4o76Pu2ZmvA9OPYLfykqGxvYmJHzDNw6Yu
+YjOuFgJ3RFrngQo8p0Quebg/BLxcoIfhG69Rjs3sLPr4/m3wOnyqi+RnlTGNAgMB
+AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQW
+BBTOw0q5mVXyuNtgv6l+vVa1lzan1jANBgkqhkiG9w0BAQsFAAOCAQEAyqVVjOPI
+QW5pJ6d1Ee88hjZv0p3GeDgdaZaikmkuOGybfQTUiaWxMTeKySHMq2zNixya1r9I
+0jJmwYrA8y8678Dj1JGG0VDjA9tzd29KOVPt3ibHtX2vK0LRdWLjSisCx1BL4Gni
+lmwORGYQRI+tBev4eaymG+g3NJ1TyWGqolKvSnAWhsI6yLETcDbYz+70CjTVW0z9
+B5yiutkBclzzTcHdDrEcDcRjvq30FPuJ7KJBDkzMyFdA0G4Dqs0MjomZmWzwPDCv
+ON9vvKO+KSAnq3T/EyJ43pdSVR6DtVQgA+6uwE9W3jfMw3+qBCe703e4YtsXfJwo
+IhNzbM8m9Yop5w==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root G3"
+# Serial: 15459312981008553731928384953135426796
+# MD5 Fingerprint: 7c:7f:65:31:0c:81:df:8d:ba:3e:99:e2:5c:ad:6e:fb
+# SHA1 Fingerprint: f5:17:a2:4f:9a:48:c6:c9:f8:a2:00:26:9f:dc:0f:48:2c:ab:30:89
+# SHA256 Fingerprint: 7e:37:cb:8b:4c:47:09:0c:ab:36:55:1b:a6:f4:5d:b8:40:68:0f:ba:16:6a:95:2d:b1:00:71:7f:43:05:3f:c2
+-----BEGIN CERTIFICATE-----
+MIICRjCCAc2gAwIBAgIQC6Fa+h3foLVJRK/NJKBs7DAKBggqhkjOPQQDAzBlMQsw
+CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu
+ZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3Qg
+RzMwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQGEwJV
+UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu
+Y29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzMwdjAQBgcq
+hkjOPQIBBgUrgQQAIgNiAAQZ57ysRGXtzbg/WPuNsVepRC0FFfLvC/8QdJ+1YlJf
+Zn4f5dwbRXkLzMZTCp2NXQLZqVneAlr2lSoOjThKiknGvMYDOAdfVdp+CW7if17Q
+RSAPWXYQ1qAk8C3eNvJsKTmjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
+BAQDAgGGMB0GA1UdDgQWBBTL0L2p4ZgFUaFNN6KDec6NHSrkhDAKBggqhkjOPQQD
+AwNnADBkAjAlpIFFAmsSS3V0T8gj43DydXLefInwz5FyYZ5eEJJZVrmDxxDnOOlY
+JjZ91eQ0hjkCMHw2U/Aw5WJjOpnitqM7mzT6HtoQknFekROn3aRukswy1vUhZscv
+6pZjamVFkpUBtA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root G2"
+# Serial: 4293743540046975378534879503202253541
+# MD5 Fingerprint: e4:a6:8a:c8:54:ac:52:42:46:0a:fd:72:48:1b:2a:44
+# SHA1 Fingerprint: df:3c:24:f9:bf:d6:66:76:1b:26:80:73:fe:06:d1:cc:8d:4f:82:a4
+# SHA256 Fingerprint: cb:3c:cb:b7:60:31:e5:e0:13:8f:8d:d3:9a:23:f9:de:47:ff:c3:5e:43:c1:14:4c:ea:27:d4:6a:5a:b1:cb:5f
+-----BEGIN CERTIFICATE-----
+MIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH
+MjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT
+MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
+b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI
+2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx
+1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ
+q2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz
+tCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ
+vIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP
+BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV
+5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY
+1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4
+NeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG
+Fdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91
+8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe
+pLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl
+MrY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root G3"
+# Serial: 7089244469030293291760083333884364146
+# MD5 Fingerprint: f5:5d:a4:50:a5:fb:28:7e:1e:0f:0d:cc:96:57:56:ca
+# SHA1 Fingerprint: 7e:04:de:89:6a:3e:66:6d:00:e6:87:d3:3f:fa:d9:3b:e8:3d:34:9e
+# SHA256 Fingerprint: 31:ad:66:48:f8:10:41:38:c7:38:f3:9e:a4:32:01:33:39:3e:3a:18:cc:02:29:6e:f9:7c:2a:c9:ef:67:31:d0
+-----BEGIN CERTIFICATE-----
+MIICPzCCAcWgAwIBAgIQBVVWvPJepDU1w6QP1atFcjAKBggqhkjOPQQDAzBhMQsw
+CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu
+ZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe
+Fw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVTMRUw
+EwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x
+IDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYF
+K4EEACIDYgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FG
+fp4tn+6OYwwX7Adw9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPO
+Z9wj/wMco+I+o0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAd
+BgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNpYim8S8YwCgYIKoZIzj0EAwMDaAAwZQIx
+AK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj+Z4y3maTD/HMsQmP3Wyr+mt/
+oAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqpisXRAL34VOKa5Vt8
+sycX
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Trusted Root G4"
+# Serial: 7451500558977370777930084869016614236
+# MD5 Fingerprint: 78:f2:fc:aa:60:1f:2f:b4:eb:c9:37:ba:53:2e:75:49
+# SHA1 Fingerprint: dd:fb:16:cd:49:31:c9:73:a2:03:7d:3f:c8:3a:4d:7d:77:5d:05:e4
+# SHA256 Fingerprint: 55:2f:7b:dc:f1:a7:af:9e:6c:e6:72:01:7f:4f:12:ab:f7:72:40:c7:8e:76:1a:c2:03:d1:d9:d2:0a:c8:99:88
+-----BEGIN CERTIFICATE-----
+MIIFkDCCA3igAwIBAgIQBZsbV56OITLiOQe9p3d1XDANBgkqhkiG9w0BAQwFADBi
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3Qg
+RzQwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBiMQswCQYDVQQGEwJV
+UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu
+Y29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3QgRzQwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1KPDAiMGkz7MKnJS7JIT3y
+ithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2rsnnyyhHS5F/WBTxSD1If
+xp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C8weE5nQ7bXHiLQwb7iDV
+ySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBfsXpm7nfISKhmV1efVFiO
+DCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGYQJB5w3jHtrHEtWoYOAMQ
+jdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8rhsDdV14Ztk6MUSaM0C/
+CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaYdj1ZXUJ2h4mXaXpI8OCi
+EhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+wJS00mFt6zPZxd9LBADM
+fRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw++hkpjPRiQfhvbfmQ6QY
+uKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+NP8m800ERElvlEFDrMcXK
+chYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7FwI+isX4KJpn15GkvmB0t
+9dmpsh3lGwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+hjAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wDQYJKoZIhvcNAQEMBQAD
+ggIBALth2X2pbL4XxJEbw6GiAI3jZGgPVs93rnD5/ZpKmbnJeFwMDF/k5hQpVgs2
+SV1EY+CtnJYYZhsjDT156W1r1lT40jzBQ0CuHVD1UvyQO7uYmWlrx8GnqGikJ9yd
++SeuMIW59mdNOj6PWTkiU0TryF0Dyu1Qen1iIQqAyHNm0aAFYF/opbSnr6j3bTWc
+fFqK1qI4mfN4i/RN0iAL3gTujJtHgXINwBQy7zBZLq7gcfJW5GqXb5JQbZaNaHqa
+sjYUegbyJLkJEVDXCLG4iXqEI2FCKeWjzaIgQdfRnGTZ6iahixTXTBmyUEFxPT9N
+cCOGDErcgdLMMpSEDQgJlxxPwO5rIHQw0uA5NBCFIRUBCOhVMt5xSdkoF1BN5r5N
+0XWs0Mr7QbhDparTwwVETyw2m+L64kW4I1NsBm9nVX9GtUw/bihaeSbSpKhil9Ie
+4u1Ki7wb/UdKDd9nZn6yW0HQO+T0O/QEY+nvwlQAUaCKKsnOeMzV6ocEGLPOr0mI
+r/OSmbaz5mEP0oUA51Aa5BuVnRmhuZyxm7EAHu/QD09CbMkKvO5D+jpxpchNJqU1
+/YldvIViHTLSoCtU7ZpXwdv6EM8Zt4tKG48BtieVU+i2iW1bvGjUI+iLUaJW+fCm
+gKDWHrO8Dw9TdSmq6hN35N6MgSGtBxBHEa2HPQfRdbzP82Z+
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO RSA Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO RSA Certification Authority O=COMODO CA Limited
+# Label: "COMODO RSA Certification Authority"
+# Serial: 101909084537582093308941363524873193117
+# MD5 Fingerprint: 1b:31:b0:71:40:36:cc:14:36:91:ad:c4:3e:fd:ec:18
+# SHA1 Fingerprint: af:e5:d2:44:a8:d1:19:42:30:ff:47:9f:e2:f8:97:bb:cd:7a:8c:b4
+# SHA256 Fingerprint: 52:f0:e1:c4:e5:8e:c6:29:29:1b:60:31:7f:07:46:71:b8:5d:7e:a8:0d:5b:07:27:34:63:53:4b:32:b4:02:34
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=USERTrust RSA Certification Authority O=The USERTRUST Network
+# Subject: CN=USERTrust RSA Certification Authority O=The USERTRUST Network
+# Label: "USERTrust RSA Certification Authority"
+# Serial: 2645093764781058787591871645665788717
+# MD5 Fingerprint: 1b:fe:69:d1:91:b7:19:33:a3:72:a8:0f:e1:55:e5:b5
+# SHA1 Fingerprint: 2b:8f:1b:57:33:0d:bb:a2:d0:7a:6c:51:f7:0e:e9:0d:da:b9:ad:8e
+# SHA256 Fingerprint: e7:93:c9:b0:2f:d8:aa:13:e2:1c:31:22:8a:cc:b0:81:19:64:3b:74:9c:89:89:64:b1:74:6d:46:c3:d4:cb:d2
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=USERTrust ECC Certification Authority O=The USERTRUST Network
+# Subject: CN=USERTrust ECC Certification Authority O=The USERTRUST Network
+# Label: "USERTrust ECC Certification Authority"
+# Serial: 123013823720199481456569720443997572134
+# MD5 Fingerprint: fa:68:bc:d9:b5:7f:ad:fd:c9:1d:06:83:28:cc:24:c1
+# SHA1 Fingerprint: d1:cb:ca:5d:b2:d5:2a:7f:69:3b:67:4d:e5:f0:5a:1d:0c:95:7d:f0
+# SHA256 Fingerprint: 4f:f4:60:d5:4b:9c:86:da:bf:bc:fc:57:12:e0:40:0d:2b:ed:3f:bc:4d:4f:bd:aa:86:e0:6a:dc:d2:a9:ad:7a
+-----BEGIN CERTIFICATE-----
+MIICjzCCAhWgAwIBAgIQXIuZxVqUxdJxVt7NiYDMJjAKBggqhkjOPQQDAzCBiDEL
+MAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNl
+eSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMT
+JVVTRVJUcnVzdCBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMjAx
+MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgT
+Ck5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVUaGUg
+VVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBFQ0MgQ2VydGlm
+aWNhdGlvbiBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQarFRaqflo
+I+d61SRvU8Za2EurxtW20eZzca7dnNYMYf3boIkDuAUU7FfO7l0/4iGzzvfUinng
+o4N+LZfQYcTxmdwlkWOrfzCjtHDix6EznPO/LlxTsV+zfTJ/ijTjeXmjQjBAMB0G
+A1UdDgQWBBQ64QmG1M8ZwpZ2dEl23OA1xmNjmjAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjA2Z6EWCNzklwBBHU6+4WMB
+zzuqQhFkoJ2UOQIReVx7Hfpkue4WQrO/isIJxOzksU0CMQDpKmFHjFJKS04YcPbW
+RNZu9YO6bVi9JNlWSOrvxKJGgYhqOkbRqZtNyWHa0V1Xahg=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5
+# Label: "GlobalSign ECC Root CA - R5"
+# Serial: 32785792099990507226680698011560947931244
+# MD5 Fingerprint: 9f:ad:3b:1c:02:1e:8a:ba:17:74:38:81:0c:a2:bc:08
+# SHA1 Fingerprint: 1f:24:c6:30:cd:a4:18:ef:20:69:ff:ad:4f:dd:5f:46:3a:1b:69:aa
+# SHA256 Fingerprint: 17:9f:bc:14:8a:3d:d0:0f:d2:4e:a1:34:58:cc:43:bf:a7:f5:9c:81:82:d7:83:a5:13:f6:eb:ec:10:0c:89:24
+-----BEGIN CERTIFICATE-----
+MIICHjCCAaSgAwIBAgIRYFlJ4CYuu1X5CneKcflK2GwwCgYIKoZIzj0EAwMwUDEk
+MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI1MRMwEQYDVQQKEwpH
+bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX
+DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD
+QSAtIFI1MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu
+MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAER0UOlvt9Xb/pOdEh+J8LttV7HpI6SFkc
+8GIxLcB6KP4ap1yztsyX50XUWPrRd21DosCHZTQKH3rd6zwzocWdTaRvQZU4f8ke
+hOvRnkmSh5SHDDqFSmafnVmTTZdhBoZKo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPeYpSJvqB8ohREom3m7e0oPQn1kwCgYI
+KoZIzj0EAwMDaAAwZQIxAOVpEslu28YxuglB4Zf4+/2a4n0Sye18ZNPLBSWLVtmg
+515dTguDnFt2KaAJJiFqYgIwcdK1j1zqO+F4CYWodZI7yFz9SO8NdCKoCOJuxUnO
+xwy8p2Fp8fc74SrL+SvzZpA3
+-----END CERTIFICATE-----
+
+# Issuer: CN=Staat der Nederlanden EV Root CA O=Staat der Nederlanden
+# Subject: CN=Staat der Nederlanden EV Root CA O=Staat der Nederlanden
+# Label: "Staat der Nederlanden EV Root CA"
+# Serial: 10000013
+# MD5 Fingerprint: fc:06:af:7b:e8:1a:f1:9a:b4:e8:d2:70:1f:c0:f5:ba
+# SHA1 Fingerprint: 76:e2:7e:c1:4f:db:82:c1:c0:a6:75:b5:05:be:3d:29:b4:ed:db:bb
+# SHA256 Fingerprint: 4d:24:91:41:4c:fe:95:67:46:ec:4c:ef:a6:cf:6f:72:e2:8a:13:29:43:2f:9d:8a:90:7a:c4:cb:5d:ad:c1:5a
+-----BEGIN CERTIFICATE-----
+MIIFcDCCA1igAwIBAgIEAJiWjTANBgkqhkiG9w0BAQsFADBYMQswCQYDVQQGEwJO
+TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSkwJwYDVQQDDCBTdGFh
+dCBkZXIgTmVkZXJsYW5kZW4gRVYgUm9vdCBDQTAeFw0xMDEyMDgxMTE5MjlaFw0y
+MjEyMDgxMTEwMjhaMFgxCzAJBgNVBAYTAk5MMR4wHAYDVQQKDBVTdGFhdCBkZXIg
+TmVkZXJsYW5kZW4xKTAnBgNVBAMMIFN0YWF0IGRlciBOZWRlcmxhbmRlbiBFViBS
+b290IENBMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA48d+ifkkSzrS
+M4M1LGns3Amk41GoJSt5uAg94JG6hIXGhaTK5skuU6TJJB79VWZxXSzFYGgEt9nC
+UiY4iKTWO0Cmws0/zZiTs1QUWJZV1VD+hq2kY39ch/aO5ieSZxeSAgMs3NZmdO3d
+Z//BYY1jTw+bbRcwJu+r0h8QoPnFfxZpgQNH7R5ojXKhTbImxrpsX23Wr9GxE46p
+rfNeaXUmGD5BKyF/7otdBwadQ8QpCiv8Kj6GyzyDOvnJDdrFmeK8eEEzduG/L13l
+pJhQDBXd4Pqcfzho0LKmeqfRMb1+ilgnQ7O6M5HTp5gVXJrm0w912fxBmJc+qiXb
+j5IusHsMX/FjqTf5m3VpTCgmJdrV8hJwRVXj33NeN/UhbJCONVrJ0yPr08C+eKxC
+KFhmpUZtcALXEPlLVPxdhkqHz3/KRawRWrUgUY0viEeXOcDPusBCAUCZSCELa6fS
+/ZbV0b5GnUngC6agIk440ME8MLxwjyx1zNDFjFE7PZQIZCZhfbnDZY8UnCHQqv0X
+cgOPvZuM5l5Tnrmd74K74bzickFbIZTTRTeU0d8JOV3nI6qaHcptqAqGhYqCvkIH
+1vI4gnPah1vlPNOePqc7nvQDs/nxfRN0Av+7oeX6AHkcpmZBiFxgV6YuCcS6/ZrP
+px9Aw7vMWgpVSzs4dlG4Y4uElBbmVvMCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB
+/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFP6rAJCYniT8qcwaivsnuL8wbqg7
+MA0GCSqGSIb3DQEBCwUAA4ICAQDPdyxuVr5Os7aEAJSrR8kN0nbHhp8dB9O2tLsI
+eK9p0gtJ3jPFrK3CiAJ9Brc1AsFgyb/E6JTe1NOpEyVa/m6irn0F3H3zbPB+po3u
+2dfOWBfoqSmuc0iH55vKbimhZF8ZE/euBhD/UcabTVUlT5OZEAFTdfETzsemQUHS
+v4ilf0X8rLiltTMMgsT7B/Zq5SWEXwbKwYY5EdtYzXc7LMJMD16a4/CrPmEbUCTC
+wPTxGfARKbalGAKb12NMcIxHowNDXLldRqANb/9Zjr7dn3LDWyvfjFvO5QxGbJKy
+CqNMVEIYFRIYvdr8unRu/8G2oGTYqV9Vrp9canaW2HNnh/tNf1zuacpzEPuKqf2e
+vTY4SUmH9A4U8OmHuD+nT3pajnnUk+S7aFKErGzp85hwVXIy+TSrK0m1zSBi5Dp6
+Z2Orltxtrpfs/J92VoguZs9btsmksNcFuuEnL5O7Jiqik7Ab846+HUCjuTaPPoIa
+Gl6I6lD4WeKDRikL40Rc4ZW2aZCaFG+XroHPaO+Zmr615+F/+PoTRxZMzG0IQOeL
+eG9QgkRQP2YGiqtDhFZKDyAthg710tvSeopLzaXoTvFeJiUBWSOgftL2fiFX1ye8
+FVdMpEbB4IMeDExNH08GGeL5qPQ6gqGyeUN51q1veieQA6TqJIc/2b3Z6fJfUEkc
+7uzXLg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=IdenTrust Commercial Root CA 1 O=IdenTrust
+# Subject: CN=IdenTrust Commercial Root CA 1 O=IdenTrust
+# Label: "IdenTrust Commercial Root CA 1"
+# Serial: 13298821034946342390520003877796839426
+# MD5 Fingerprint: b3:3e:77:73:75:ee:a0:d3:e3:7e:49:63:49:59:bb:c7
+# SHA1 Fingerprint: df:71:7e:aa:4a:d9:4e:c9:55:84:99:60:2d:48:de:5f:bc:f0:3a:25
+# SHA256 Fingerprint: 5d:56:49:9b:e4:d2:e0:8b:cf:ca:d0:8a:3e:38:72:3d:50:50:3b:de:70:69:48:e4:2f:55:60:30:19:e5:28:ae
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIQCgFCgAAAAUUjyES1AAAAAjANBgkqhkiG9w0BAQsFADBK
+MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScwJQYDVQQDEx5JZGVu
+VHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwHhcNMTQwMTE2MTgxMjIzWhcNMzQw
+MTE2MTgxMjIzWjBKMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScw
+JQYDVQQDEx5JZGVuVHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCnUBneP5k91DNG8W9RYYKyqU+PZ4ldhNlT
+3Qwo2dfw/66VQ3KZ+bVdfIrBQuExUHTRgQ18zZshq0PirK1ehm7zCYofWjK9ouuU
++ehcCuz/mNKvcbO0U59Oh++SvL3sTzIwiEsXXlfEU8L2ApeN2WIrvyQfYo3fw7gp
+S0l4PJNgiCL8mdo2yMKi1CxUAGc1bnO/AljwpN3lsKImesrgNqUZFvX9t++uP0D1
+bVoE/c40yiTcdCMbXTMTEl3EASX2MN0CXZ/g1Ue9tOsbobtJSdifWwLziuQkkORi
+T0/Br4sOdBeo0XKIanoBScy0RnnGF7HamB4HWfp1IYVl3ZBWzvurpWCdxJ35UrCL
+vYf5jysjCiN2O/cz4ckA82n5S6LgTrx+kzmEB/dEcH7+B1rlsazRGMzyNeVJSQjK
+Vsk9+w8YfYs7wRPCTY/JTw436R+hDmrfYi7LNQZReSzIJTj0+kuniVyc0uMNOYZK
+dHzVWYfCP04MXFL0PfdSgvHqo6z9STQaKPNBiDoT7uje/5kdX7rL6B7yuVBgwDHT
+c+XvvqDtMwt0viAgxGds8AgDelWAf0ZOlqf0Hj7h9tgJ4TNkK2PXMl6f+cB7D3hv
+l7yTmvmcEpB4eoCHFddydJxVdHixuuFucAS6T6C6aMN7/zHwcz09lCqxC0EOoP5N
+iGVreTO01wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQU7UQZwNPwBovupHu+QucmVMiONnYwDQYJKoZIhvcNAQELBQAD
+ggIBAA2ukDL2pkt8RHYZYR4nKM1eVO8lvOMIkPkp165oCOGUAFjvLi5+U1KMtlwH
+6oi6mYtQlNeCgN9hCQCTrQ0U5s7B8jeUeLBfnLOic7iPBZM4zY0+sLj7wM+x8uwt
+LRvM7Kqas6pgghstO8OEPVeKlh6cdbjTMM1gCIOQ045U8U1mwF10A0Cj7oV+wh93
+nAbowacYXVKV7cndJZ5t+qntozo00Fl72u1Q8zW/7esUTTHHYPTa8Yec4kjixsU3
++wYQ+nVZZjFHKdp2mhzpgq7vmrlR94gjmmmVYjzlVYA211QC//G5Xc7UI2/YRYRK
+W2XviQzdFKcgyxilJbQN+QHwotL0AMh0jqEqSI5l2xPE4iUXfeu+h1sXIFRRk0pT
+AwvsXcoz7WL9RccvW9xYoIA55vrX/hMUpu09lEpCdNTDd1lzzY9GvlU47/rokTLq
+l1gEIt44w8y8bckzOmoKaT+gyOpyj4xjhiO9bTyWnpXgSUyqorkqG5w2gXjtw+hG
+4iZZRHUe2XWJUc0QhJ1hYMtd+ZciTY6Y5uN/9lu7rs3KSoFrXgvzUeF0K+l+J6fZ
+mUlO+KWA2yUPHGNiiskzZ2s8EIPGrd6ozRaOjfAHN3Gf8qv8QfXBi+wAN10J5U6A
+7/qxXDgGpRtK4dw4LTzcqx+QGtVKnO7RcGzM7vRX+Bi6hG6H
+-----END CERTIFICATE-----
+
+# Issuer: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust
+# Subject: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust
+# Label: "IdenTrust Public Sector Root CA 1"
+# Serial: 13298821034946342390521976156843933698
+# MD5 Fingerprint: 37:06:a5:b0:fc:89:9d:ba:f4:6b:8c:1a:64:cd:d5:ba
+# SHA1 Fingerprint: ba:29:41:60:77:98:3f:f4:f3:ef:f2:31:05:3b:2e:ea:6d:4d:45:fd
+# SHA256 Fingerprint: 30:d0:89:5a:9a:44:8a:26:20:91:63:55:22:d1:f5:20:10:b5:86:7a:ca:e1:2c:78:ef:95:8f:d4:f4:38:9f:2f
+-----BEGIN CERTIFICATE-----
+MIIFZjCCA06gAwIBAgIQCgFCgAAAAUUjz0Z8AAAAAjANBgkqhkiG9w0BAQsFADBN
+MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MSowKAYDVQQDEyFJZGVu
+VHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwHhcNMTQwMTE2MTc1MzMyWhcN
+MzQwMTE2MTc1MzMyWjBNMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0
+MSowKAYDVQQDEyFJZGVuVHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2IpT8pEiv6EdrCvsnduTyP4o7
+ekosMSqMjbCpwzFrqHd2hCa2rIFCDQjrVVi7evi8ZX3yoG2LqEfpYnYeEe4IFNGy
+RBb06tD6Hi9e28tzQa68ALBKK0CyrOE7S8ItneShm+waOh7wCLPQ5CQ1B5+ctMlS
+bdsHyo+1W/CD80/HLaXIrcuVIKQxKFdYWuSNG5qrng0M8gozOSI5Cpcu81N3uURF
+/YTLNiCBWS2ab21ISGHKTN9T0a9SvESfqy9rg3LvdYDaBjMbXcjaY8ZNzaxmMc3R
+3j6HEDbhuaR672BQssvKplbgN6+rNBM5Jeg5ZuSYeqoSmJxZZoY+rfGwyj4GD3vw
+EUs3oERte8uojHH01bWRNszwFcYr3lEXsZdMUD2xlVl8BX0tIdUAvwFnol57plzy
+9yLxkA2T26pEUWbMfXYD62qoKjgZl3YNa4ph+bz27nb9cCvdKTz4Ch5bQhyLVi9V
+GxyhLrXHFub4qjySjmm2AcG1hp2JDws4lFTo6tyePSW8Uybt1as5qsVATFSrsrTZ
+2fjXctscvG29ZV/viDUqZi/u9rNl8DONfJhBaUYPQxxp+pu10GFqzcpL2UyQRqsV
+WaFHVCkugyhfHMKiq3IXAAaOReyL4jM9f9oZRORicsPfIsbyVtTdX5Vy7W1f90gD
+W/3FKqD2cyOEEBsB5wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
+BAUwAwEB/zAdBgNVHQ4EFgQU43HgntinQtnbcZFrlJPrw6PRFKMwDQYJKoZIhvcN
+AQELBQADggIBAEf63QqwEZE4rU1d9+UOl1QZgkiHVIyqZJnYWv6IAcVYpZmxI1Qj
+t2odIFflAWJBF9MJ23XLblSQdf4an4EKwt3X9wnQW3IV5B4Jaj0z8yGa5hV+rVHV
+DRDtfULAj+7AmgjVQdZcDiFpboBhDhXAuM/FSRJSzL46zNQuOAXeNf0fb7iAaJg9
+TaDKQGXSc3z1i9kKlT/YPyNtGtEqJBnZhbMX73huqVjRI9PHE+1yJX9dsXNw0H8G
+lwmEKYBhHfpe/3OsoOOJuBxxFcbeMX8S3OFtm6/n6J91eEyrRjuazr8FGF1NFTwW
+mhlQBJqymm9li1JfPFgEKCXAZmExfrngdbkaqIHWchezxQMxNRF4eKLg6TCMf4Df
+WN88uieW4oA0beOY02QnrEh+KHdcxiVhJfiFDGX6xDIvpZgF5PgLZxYWxoK4Mhn5
++bl53B/N66+rDt0b20XkeucC4pVd/GnwU2lhlXV5C15V5jgclKlZM57IcXR5f1GJ
+tshquDDIajjDbp7hNxbqBWJMWxJH7ae0s1hWx0nzfxJoCTFx8G34Tkf71oXuxVhA
+GaQdp/lLQzfcaFpPz+vCZHTetBXZ9FRUGi8c15dxVJCO2SCdUyt/q4/i6jC8UDfv
+8Ue1fXwsBOxonbRJRBD0ckscZOf85muQ3Wl9af0AVqW3rLatt8o+Ae+c
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - G2"
+# Serial: 1246989352
+# MD5 Fingerprint: 4b:e2:c9:91:96:65:0c:f4:0e:5a:93:92:a0:0a:fe:b2
+# SHA1 Fingerprint: 8c:f4:27:fd:79:0c:3a:d1:66:06:8d:e8:1e:57:ef:bb:93:22:72:d4
+# SHA256 Fingerprint: 43:df:57:74:b0:3e:7f:ef:5f:e4:0d:93:1a:7b:ed:f1:bb:2e:6b:42:73:8c:4e:6d:38:41:10:3d:3a:a7:f3:39
+-----BEGIN CERTIFICATE-----
+MIIEPjCCAyagAwIBAgIESlOMKDANBgkqhkiG9w0BAQsFADCBvjELMAkGA1UEBhMC
+VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50
+cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3Qs
+IEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVz
+dCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzIwHhcNMDkwNzA3MTcy
+NTU0WhcNMzAxMjA3MTc1NTU0WjCBvjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUVu
+dHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50cnVzdC5uZXQvbGVnYWwt
+dGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3QsIEluYy4gLSBmb3IgYXV0
+aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVzdCBSb290IENlcnRpZmlj
+YXRpb24gQXV0aG9yaXR5IC0gRzIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
+AoIBAQC6hLZy254Ma+KZ6TABp3bqMriVQRrJ2mFOWHLP/vaCeb9zYQYKpSfYs1/T
+RU4cctZOMvJyig/3gxnQaoCAAEUesMfnmr8SVycco2gvCoe9amsOXmXzHHfV1IWN
+cCG0szLni6LVhjkCsbjSR87kyUnEO6fe+1R9V77w6G7CebI6C1XiUJgWMhNcL3hW
+wcKUs/Ja5CeanyTXxuzQmyWC48zCxEXFjJd6BmsqEZ+pCm5IO2/b1BEZQvePB7/1
+U1+cPvQXLOZprE4yTGJ36rfo5bs0vBmLrpxR57d+tVOxMyLlbc9wPBr64ptntoP0
+jaWvYkxN4FisZDQSA/i2jZRjJKRxAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAP
+BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqciZ60B7vfec7aVHUbI2fkBJmqzAN
+BgkqhkiG9w0BAQsFAAOCAQEAeZ8dlsa2eT8ijYfThwMEYGprmi5ZiXMRrEPR9RP/
+jTkrwPK9T3CMqS/qF8QLVJ7UG5aYMzyorWKiAHarWWluBh1+xLlEjZivEtRh2woZ
+Rkfz6/djwUAFQKXSt/S1mja/qYh2iARVBCuch38aNzx+LaUa2NSJXsq9rD1s2G2v
+1fN2D807iDginWyTmsQ9v4IbZT+mD12q/OWyFcq1rca8PdCE6OoGcrBNOTJ4vz4R
+nAuknZoh8/CbCzB428Hch0P+vGOaysXCHMnHjf87ElgI5rY97HosTvuDls4MPGmH
+VHOkc8KT/1EQrBVUAdj8BbGJoX90g5pJ19xOe4pIb4tF9g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - EC1"
+# Serial: 51543124481930649114116133369
+# MD5 Fingerprint: b6:7e:1d:f0:58:c5:49:6c:24:3b:3d:ed:98:18:ed:bc
+# SHA1 Fingerprint: 20:d8:06:40:df:9b:25:f5:12:25:3a:11:ea:f7:59:8a:eb:14:b5:47
+# SHA256 Fingerprint: 02:ed:0e:b2:8c:14:da:45:16:5c:56:67:91:70:0d:64:51:d7:fb:56:f0:b2:ab:1d:3b:8e:b0:70:e5:6e:df:f5
+-----BEGIN CERTIFICATE-----
+MIIC+TCCAoCgAwIBAgINAKaLeSkAAAAAUNCR+TAKBggqhkjOPQQDAzCBvzELMAkG
+A1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3
+d3cuZW50cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDEyIEVu
+dHJ1c3QsIEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEzMDEGA1UEAxMq
+RW50cnVzdCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRUMxMB4XDTEy
+MTIxODE1MjUzNloXDTM3MTIxODE1NTUzNlowgb8xCzAJBgNVBAYTAlVTMRYwFAYD
+VQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1c3QubmV0
+L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxMiBFbnRydXN0LCBJbmMuIC0g
+Zm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMzAxBgNVBAMTKkVudHJ1c3QgUm9vdCBD
+ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEVDMTB2MBAGByqGSM49AgEGBSuBBAAi
+A2IABIQTydC6bUF74mzQ61VfZgIaJPRbiWlH47jCffHyAsWfoPZb1YsGGYZPUxBt
+ByQnoaD41UcZYUx9ypMn6nQM72+WCf5j7HBdNq1nd67JnXxVRDqiY1Ef9eNi1KlH
+Bz7MIKNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O
+BBYEFLdj5xrdjekIplWDpOBqUEFlEUJJMAoGCCqGSM49BAMDA2cAMGQCMGF52OVC
+R98crlOZF7ZvHH3hvxGU0QOIdeSNiaSKd0bebWHvAvX7td/M/k7//qnmpwIwW5nX
+hTcGtXsI/esni0qU+eH6p44mCOh8kmhtc9hvJqwhAriZtyZBWyVgrtBIGu4G
+-----END CERTIFICATE-----
+
+# Issuer: CN=CFCA EV ROOT O=China Financial Certification Authority
+# Subject: CN=CFCA EV ROOT O=China Financial Certification Authority
+# Label: "CFCA EV ROOT"
+# Serial: 407555286
+# MD5 Fingerprint: 74:e1:b6:ed:26:7a:7a:44:30:33:94:ab:7b:27:81:30
+# SHA1 Fingerprint: e2:b8:29:4b:55:84:ab:6b:58:c2:90:46:6c:ac:3f:b8:39:8f:84:83
+# SHA256 Fingerprint: 5c:c3:d7:8e:4e:1d:5e:45:54:7a:04:e6:87:3e:64:f9:0c:f9:53:6d:1c:cc:2e:f8:00:f3:55:c4:c5:fd:70:fd
+-----BEGIN CERTIFICATE-----
+MIIFjTCCA3WgAwIBAgIEGErM1jANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJD
+TjEwMC4GA1UECgwnQ2hpbmEgRmluYW5jaWFsIENlcnRpZmljYXRpb24gQXV0aG9y
+aXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJPT1QwHhcNMTIwODA4MDMwNzAxWhcNMjkx
+MjMxMDMwNzAxWjBWMQswCQYDVQQGEwJDTjEwMC4GA1UECgwnQ2hpbmEgRmluYW5j
+aWFsIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJP
+T1QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDXXWvNED8fBVnVBU03
+sQ7smCuOFR36k0sXgiFxEFLXUWRwFsJVaU2OFW2fvwwbwuCjZ9YMrM8irq93VCpL
+TIpTUnrD7i7es3ElweldPe6hL6P3KjzJIx1qqx2hp/Hz7KDVRM8Vz3IvHWOX6Jn5
+/ZOkVIBMUtRSqy5J35DNuF++P96hyk0g1CXohClTt7GIH//62pCfCqktQT+x8Rgp
+7hZZLDRJGqgG16iI0gNyejLi6mhNbiyWZXvKWfry4t3uMCz7zEasxGPrb382KzRz
+EpR/38wmnvFyXVBlWY9ps4deMm/DGIq1lY+wejfeWkU7xzbh72fROdOXW3NiGUgt
+hxwG+3SYIElz8AXSG7Ggo7cbcNOIabla1jj0Ytwli3i/+Oh+uFzJlU9fpy25IGvP
+a931DfSCt/SyZi4QKPaXWnuWFo8BGS1sbn85WAZkgwGDg8NNkt0yxoekN+kWzqot
+aK8KgWU6cMGbrU1tVMoqLUuFG7OA5nBFDWteNfB/O7ic5ARwiRIlk9oKmSJgamNg
+TnYGmE69g60dWIolhdLHZR4tjsbftsbhf4oEIRUpdPA+nJCdDC7xij5aqgwJHsfV
+PKPtl8MeNPo4+QgO48BdK4PRVmrJtqhUUy54Mmc9gn900PvhtgVguXDbjgv5E1hv
+cWAQUhC5wUEJ73IfZzF4/5YFjQIDAQABo2MwYTAfBgNVHSMEGDAWgBTj/i39KNAL
+tbq2osS/BqoFjJP7LzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAd
+BgNVHQ4EFgQU4/4t/SjQC7W6tqLEvwaqBYyT+y8wDQYJKoZIhvcNAQELBQADggIB
+ACXGumvrh8vegjmWPfBEp2uEcwPenStPuiB/vHiyz5ewG5zz13ku9Ui20vsXiObT
+ej/tUxPQ4i9qecsAIyjmHjdXNYmEwnZPNDatZ8POQQaIxffu2Bq41gt/UP+TqhdL
+jOztUmCypAbqTuv0axn96/Ua4CUqmtzHQTb3yHQFhDmVOdYLO6Qn+gjYXB74BGBS
+ESgoA//vU2YApUo0FmZ8/Qmkrp5nGm9BC2sGE5uPhnEFtC+NiWYzKXZUmhH4J/qy
+P5Hgzg0b8zAarb8iXRvTvyUFTeGSGn+ZnzxEk8rUQElsgIfXBDrDMlI1Dlb4pd19
+xIsNER9Tyx6yF7Zod1rg1MvIB671Oi6ON7fQAUtDKXeMOZePglr4UeWJoBjnaH9d
+Ci77o0cOPaYjesYBx4/IXr9tgFa+iiS6M+qf4TIRnvHST4D2G0CvOJ4RUHlzEhLN
+5mydLIhyPDCBBpEi6lmt2hkuIsKNuYyH4Ga8cyNfIWRjgEj1oDwYPZTISEEdQLpe
+/v5WOaHIz16eGWRGENoXkbcFgKyLmZJ956LYBws2J+dIeWCKw9cTXPhyQN9Ky8+Z
+AAoACxGV2lZFA4gKn2fQ1XmxqI1AbQ3CekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ
+5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su
+-----END CERTIFICATE-----
+
+# Issuer: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
+# Subject: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
+# Label: "OISTE WISeKey Global Root GB CA"
+# Serial: 157768595616588414422159278966750757568
+# MD5 Fingerprint: a4:eb:b9:61:28:2e:b7:2f:98:b0:35:26:90:99:51:1d
+# SHA1 Fingerprint: 0f:f9:40:76:18:d3:d7:6a:4b:98:f0:a8:35:9e:0c:fd:27:ac:cc:ed
+# SHA256 Fingerprint: 6b:9c:08:e8:6e:b0:f7:67:cf:ad:65:cd:98:b6:21:49:e5:49:4a:67:f5:84:5e:7b:d1:ed:01:9f:27:b8:6b:d6
+-----BEGIN CERTIFICATE-----
+MIIDtTCCAp2gAwIBAgIQdrEgUnTwhYdGs/gjGvbCwDANBgkqhkiG9w0BAQsFADBt
+MQswCQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUg
+Rm91bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9i
+YWwgUm9vdCBHQiBDQTAeFw0xNDEyMDExNTAwMzJaFw0zOTEyMDExNTEwMzFaMG0x
+CzAJBgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBG
+b3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2Jh
+bCBSb290IEdCIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2Be3
+HEokKtaXscriHvt9OO+Y9bI5mE4nuBFde9IllIiCFSZqGzG7qFshISvYD06fWvGx
+WuR51jIjK+FTzJlFXHtPrby/h0oLS5daqPZI7H17Dc0hBt+eFf1Biki3IPShehtX
+1F1Q/7pn2COZH8g/497/b1t3sWtuuMlk9+HKQUYOKXHQuSP8yYFfTvdv37+ErXNk
+u7dCjmn21HYdfp2nuFeKUWdy19SouJVUQHMD9ur06/4oQnc/nSMbsrY9gBQHTC5P
+99UKFg29ZkM3fiNDecNAhvVMKdqOmq0NpQSHiB6F4+lT1ZvIiwNjeOvgGUpuuy9r
+M2RYk61pv48b74JIxwIDAQABo1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUw
+AwEB/zAdBgNVHQ4EFgQUNQ/INmNe4qPs+TtmFc5RUuORmj0wEAYJKwYBBAGCNxUB
+BAMCAQAwDQYJKoZIhvcNAQELBQADggEBAEBM+4eymYGQfp3FsLAmzYh7KzKNbrgh
+cViXfa43FK8+5/ea4n32cZiZBKpDdHij40lhPnOMTZTg+XHEthYOU3gf1qKHLwI5
+gSk8rxWYITD+KJAAjNHhy/peyP34EEY7onhCkRd0VQreUGdNZtGn//3ZwLWoo4rO
+ZvUPQ82nK1d7Y0Zqqi5S2PTt4W2tKZB4SLrhI6qjiey1q5bAtEuiHZeeevJuQHHf
+aPFlTc58Bd9TZaml8LGXBHAVRgOY1NK/VLSgWH1Sb9pWJmLU2NuJMW8c8CLC02Ic
+Nc1MaRVUGpCY3useX8p3x8uOPUNpnJpY0CQ73xtAln41rYHHTnG6iBM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A.
+# Subject: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A.
+# Label: "SZAFIR ROOT CA2"
+# Serial: 357043034767186914217277344587386743377558296292
+# MD5 Fingerprint: 11:64:c1:89:b0:24:b1:8c:b1:07:7e:89:9e:51:9e:99
+# SHA1 Fingerprint: e2:52:fa:95:3f:ed:db:24:60:bd:6e:28:f3:9c:cc:cf:5e:b3:3f:de
+# SHA256 Fingerprint: a1:33:9d:33:28:1a:0b:56:e5:57:d3:d3:2b:1c:e7:f9:36:7e:b0:94:bd:5f:a7:2a:7e:50:04:c8:de:d7:ca:fe
+-----BEGIN CERTIFICATE-----
+MIIDcjCCAlqgAwIBAgIUPopdB+xV0jLVt+O2XwHrLdzk1uQwDQYJKoZIhvcNAQEL
+BQAwUTELMAkGA1UEBhMCUEwxKDAmBgNVBAoMH0tyYWpvd2EgSXpiYSBSb3psaWN6
+ZW5pb3dhIFMuQS4xGDAWBgNVBAMMD1NaQUZJUiBST09UIENBMjAeFw0xNTEwMTkw
+NzQzMzBaFw0zNTEwMTkwNzQzMzBaMFExCzAJBgNVBAYTAlBMMSgwJgYDVQQKDB9L
+cmFqb3dhIEl6YmEgUm96bGljemVuaW93YSBTLkEuMRgwFgYDVQQDDA9TWkFGSVIg
+Uk9PVCBDQTIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC3vD5QqEvN
+QLXOYeeWyrSh2gwisPq1e3YAd4wLz32ohswmUeQgPYUM1ljj5/QqGJ3a0a4m7utT
+3PSQ1hNKDJA8w/Ta0o4NkjrcsbH/ON7Dui1fgLkCvUqdGw+0w8LBZwPd3BucPbOw
+3gAeqDRHu5rr/gsUvTaE2g0gv/pby6kWIK05YO4vdbbnl5z5Pv1+TW9NL++IDWr6
+3fE9biCloBK0TXC5ztdyO4mTp4CEHCdJckm1/zuVnsHMyAHs6A6KCpbns6aH5db5
+BSsNl0BwPLqsdVqc1U2dAgrSS5tmS0YHF2Wtn2yIANwiieDhZNRnvDF5YTy7ykHN
+XGoAyDw4jlivAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD
+AgEGMB0GA1UdDgQWBBQuFqlKGLXLzPVvUPMjX/hd56zwyDANBgkqhkiG9w0BAQsF
+AAOCAQEAtXP4A9xZWx126aMqe5Aosk3AM0+qmrHUuOQn/6mWmc5G4G18TKI4pAZw
+8PRBEew/R40/cof5O/2kbytTAOD/OblqBw7rHRz2onKQy4I9EYKL0rufKq8h5mOG
+nXkZ7/e7DDWQw4rtTw/1zBLZpD67oPwglV9PJi8RI4NOdQcPv5vRtB3pEAT+ymCP
+oky4rc/hkA/NrgrHXXu3UNLUYfrVFdvXn4dRVOul4+vJhaAlIDf7js4MNIThPIGy
+d05DpYhfhmehPea0XGG2Ptv+tyjFogeutcrKjSoS75ftwjCkySp6+/NNIxuZMzSg
+LvWpCz/UXeHPhJ/iGcJfitYgHuNztw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Subject: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Label: "Certum Trusted Network CA 2"
+# Serial: 44979900017204383099463764357512596969
+# MD5 Fingerprint: 6d:46:9e:d9:25:6d:08:23:5b:5e:74:7d:1e:27:db:f2
+# SHA1 Fingerprint: d3:dd:48:3e:2b:bf:4c:05:e8:af:10:f5:fa:76:26:cf:d3:dc:30:92
+# SHA256 Fingerprint: b6:76:f2:ed:da:e8:77:5c:d3:6c:b0:f6:3c:d1:d4:60:39:61:f4:9e:62:65:ba:01:3a:2f:03:07:b6:d0:b8:04
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Subject: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Label: "Hellenic Academic and Research Institutions RootCA 2015"
+# Serial: 0
+# MD5 Fingerprint: ca:ff:e2:db:03:d9:cb:4b:e9:0f:ad:84:fd:7b:18:ce
+# SHA1 Fingerprint: 01:0c:06:95:a6:98:19:14:ff:bf:5f:c6:b0:b6:95:ea:29:e9:12:a6
+# SHA256 Fingerprint: a0:40:92:9a:02:ce:53:b4:ac:f4:f2:ff:c6:98:1c:e4:49:6f:75:5e:6d:45:fe:0b:2a:69:2b:cd:52:52:3f:36
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Subject: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Label: "Hellenic Academic and Research Institutions ECC RootCA 2015"
+# Serial: 0
+# MD5 Fingerprint: 81:e5:b4:17:eb:c2:f5:e1:4b:0d:41:7b:49:92:fe:ef
+# SHA1 Fingerprint: 9f:f1:71:8d:92:d5:9a:f3:7d:74:97:b4:bc:6f:84:68:0b:ba:b6:66
+# SHA256 Fingerprint: 44:b5:45:aa:8a:25:e6:5a:73:ca:15:dc:27:fc:36:d2:4c:1c:b9:95:3a:06:65:39:b1:15:82:dc:48:7b:48:33
+-----BEGIN CERTIFICATE-----
+MIICwzCCAkqgAwIBAgIBADAKBggqhkjOPQQDAjCBqjELMAkGA1UEBhMCR1IxDzAN
+BgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl
+c2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkxRDBCBgNVBAMTO0hl
+bGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgRUNDIFJv
+b3RDQSAyMDE1MB4XDTE1MDcwNzEwMzcxMloXDTQwMDYzMDEwMzcxMlowgaoxCzAJ
+BgNVBAYTAkdSMQ8wDQYDVQQHEwZBdGhlbnMxRDBCBgNVBAoTO0hlbGxlbmljIEFj
+YWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgQ2VydC4gQXV0aG9yaXR5
+MUQwQgYDVQQDEztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0
+dXRpb25zIEVDQyBSb290Q0EgMjAxNTB2MBAGByqGSM49AgEGBSuBBAAiA2IABJKg
+QehLgoRc4vgxEZmGZE4JJS+dQS8KrjVPdJWyUWRrjWvmP3CV8AVER6ZyOFB2lQJa
+jq4onvktTpnvLEhvTCUp6NFxW98dwXU3tNf6e3pCnGoKVlp8aQuqgAkkbH7BRqNC
+MEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFLQi
+C4KZJAEOnLvkDv2/+5cgk5kqMAoGCCqGSM49BAMCA2cAMGQCMGfOFmI4oqxiRaep
+lSTAGiecMjvAwNW6qef4BENThe5SId6d9SWDPp5YSy/XZxMOIQIwBeF1Ad5o7Sof
+TUwJCA3sS61kFyjndc5FZXIhF8siQQ6ME5g4mlRtm8rifOoCWCKR
+-----END CERTIFICATE-----
+
+# Issuer: CN=ISRG Root X1 O=Internet Security Research Group
+# Subject: CN=ISRG Root X1 O=Internet Security Research Group
+# Label: "ISRG Root X1"
+# Serial: 172886928669790476064670243504169061120
+# MD5 Fingerprint: 0c:d2:f9:e0:da:17:73:e9:ed:86:4d:a5:e3:70:e7:4e
+# SHA1 Fingerprint: ca:bd:2a:79:a1:07:6a:31:f2:1d:25:36:35:cb:03:9d:43:29:a5:e8
+# SHA256 Fingerprint: 96:bc:ec:06:26:49:76:f3:74:60:77:9a:cf:28:c5:a7:cf:e8:a3:c0:aa:e1:1a:8f:fc:ee:05:c0:bd:df:08:c6
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----
+
+# Issuer: O=FNMT-RCM OU=AC RAIZ FNMT-RCM
+# Subject: O=FNMT-RCM OU=AC RAIZ FNMT-RCM
+# Label: "AC RAIZ FNMT-RCM"
+# Serial: 485876308206448804701554682760554759
+# MD5 Fingerprint: e2:09:04:b4:d3:bd:d1:a0:14:fd:1a:d2:47:c4:57:1d
+# SHA1 Fingerprint: ec:50:35:07:b2:15:c4:95:62:19:e2:a8:9a:5b:42:99:2c:4c:2c:20
+# SHA256 Fingerprint: eb:c5:57:0c:29:01:8c:4d:67:b1:aa:12:7b:af:12:f7:03:b4:61:1e:bc:17:b7:da:b5:57:38:94:17:9b:93:fa
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIPXZONMGc2yAYdGsdUhGkHMA0GCSqGSIb3DQEBCwUAMDsx
+CzAJBgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJ
+WiBGTk1ULVJDTTAeFw0wODEwMjkxNTU5NTZaFw0zMDAxMDEwMDAwMDBaMDsxCzAJ
+BgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJWiBG
+Tk1ULVJDTTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBALpxgHpMhm5/
+yBNtwMZ9HACXjywMI7sQmkCpGreHiPibVmr75nuOi5KOpyVdWRHbNi63URcfqQgf
+BBckWKo3Shjf5TnUV/3XwSyRAZHiItQDwFj8d0fsjz50Q7qsNI1NOHZnjrDIbzAz
+WHFctPVrbtQBULgTfmxKo0nRIBnuvMApGGWn3v7v3QqQIecaZ5JCEJhfTzC8PhxF
+tBDXaEAUwED653cXeuYLj2VbPNmaUtu1vZ5Gzz3rkQUCwJaydkxNEJY7kvqcfw+Z
+374jNUUeAlz+taibmSXaXvMiwzn15Cou08YfxGyqxRxqAQVKL9LFwag0Jl1mpdIC
+IfkYtwb1TplvqKtMUejPUBjFd8g5CSxJkjKZqLsXF3mwWsXmo8RZZUc1g16p6DUL
+mbvkzSDGm0oGObVo/CK67lWMK07q87Hj/LaZmtVC+nFNCM+HHmpxffnTtOmlcYF7
+wk5HlqX2doWjKI/pgG6BU6VtX7hI+cL5NqYuSf+4lsKMB7ObiFj86xsc3i1w4peS
+MKGJ47xVqCfWS+2QrYv6YyVZLag13cqXM7zlzced0ezvXg5KkAYmY6252TUtB7p2
+ZSysV4999AeU14ECll2jB0nVetBX+RvnU0Z1qrB5QstocQjpYL05ac70r8NWQMet
+UqIJ5G+GR4of6ygnXYMgrwTJbFaai0b1AgMBAAGjgYMwgYAwDwYDVR0TAQH/BAUw
+AwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFPd9xf3E6Jobd2Sn9R2gzL+H
+YJptMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vd3d3
+LmNlcnQuZm5tdC5lcy9kcGNzLzANBgkqhkiG9w0BAQsFAAOCAgEAB5BK3/MjTvDD
+nFFlm5wioooMhfNzKWtN/gHiqQxjAb8EZ6WdmF/9ARP67Jpi6Yb+tmLSbkyU+8B1
+RXxlDPiyN8+sD8+Nb/kZ94/sHvJwnvDKuO+3/3Y3dlv2bojzr2IyIpMNOmqOFGYM
+LVN0V2Ue1bLdI4E7pWYjJ2cJj+F3qkPNZVEI7VFY/uY5+ctHhKQV8Xa7pO6kO8Rf
+77IzlhEYt8llvhjho6Tc+hj507wTmzl6NLrTQfv6MooqtyuGC2mDOL7Nii4LcK2N
+JpLuHvUBKwrZ1pebbuCoGRw6IYsMHkCtA+fdZn71uSANA+iW+YJF1DngoABd15jm
+fZ5nc8OaKveri6E6FO80vFIOiZiaBECEHX5FaZNXzuvO+FB8TxxuBEOb+dY7Ixjp
+6o7RTUaN8Tvkasq6+yO3m/qZASlaWFot4/nUbQ4mrcFuNLwy+AwF+mWj2zs3gyLp
+1txyM/1d8iC9djwj2ij3+RvrWWTV3F9yfiD8zYm1kGdNYno/Tq0dwzn+evQoFt9B
+9kiABdcPUXmsEKvU7ANm5mqwujGSQkBqvjrTcuFqN1W8rB2Vt2lh8kORdOag0wok
+RqEIr9baRRmW1FMdW4R58MD3R++Lj8UGrp1MYp3/RgT408m2ECVAdf4WqslKYIYv
+uu8wd+RU4riEmViAqhOLUTpPSPaLtrM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 1 O=Amazon
+# Subject: CN=Amazon Root CA 1 O=Amazon
+# Label: "Amazon Root CA 1"
+# Serial: 143266978916655856878034712317230054538369994
+# MD5 Fingerprint: 43:c6:bf:ae:ec:fe:ad:2f:18:c6:88:68:30:fc:c8:e6
+# SHA1 Fingerprint: 8d:a7:f9:65:ec:5e:fc:37:91:0f:1c:6e:59:fd:c1:cc:6a:6e:de:16
+# SHA256 Fingerprint: 8e:cd:e6:88:4f:3d:87:b1:12:5b:a3:1a:c3:fc:b1:3d:70:16:de:7f:57:cc:90:4f:e1:cb:97:c6:ae:98:19:6e
+-----BEGIN CERTIFICATE-----
+MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF
+ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
+b24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
+b3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj
+ca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM
+9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw
+IFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6
+VOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L
+93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm
+jgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
+AYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA
+A4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI
+U5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs
+N+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv
+o/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU
+5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy
+rqXRfboQnoZsG4q5WTP468SQvvG5
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 2 O=Amazon
+# Subject: CN=Amazon Root CA 2 O=Amazon
+# Label: "Amazon Root CA 2"
+# Serial: 143266982885963551818349160658925006970653239
+# MD5 Fingerprint: c8:e5:8d:ce:a8:42:e2:7a:c0:2a:5c:7c:9e:26:bf:66
+# SHA1 Fingerprint: 5a:8c:ef:45:d7:a6:98:59:76:7a:8c:8b:44:96:b5:78:cf:47:4b:1a
+# SHA256 Fingerprint: 1b:a5:b2:aa:8c:65:40:1a:82:96:01:18:f8:0b:ec:4f:62:30:4d:83:ce:c4:71:3a:19:c3:9c:01:1e:a4:6d:b4
+-----BEGIN CERTIFICATE-----
+MIIFQTCCAymgAwIBAgITBmyf0pY1hp8KD+WGePhbJruKNzANBgkqhkiG9w0BAQwF
+ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
+b24gUm9vdCBDQSAyMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
+b3QgQ0EgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK2Wny2cSkxK
+gXlRmeyKy2tgURO8TW0G/LAIjd0ZEGrHJgw12MBvIITplLGbhQPDW9tK6Mj4kHbZ
+W0/jTOgGNk3Mmqw9DJArktQGGWCsN0R5hYGCrVo34A3MnaZMUnbqQ523BNFQ9lXg
+1dKmSYXpN+nKfq5clU1Imj+uIFptiJXZNLhSGkOQsL9sBbm2eLfq0OQ6PBJTYv9K
+8nu+NQWpEjTj82R0Yiw9AElaKP4yRLuH3WUnAnE72kr3H9rN9yFVkE8P7K6C4Z9r
+2UXTu/Bfh+08LDmG2j/e7HJV63mjrdvdfLC6HM783k81ds8P+HgfajZRRidhW+me
+z/CiVX18JYpvL7TFz4QuK/0NURBs+18bvBt+xa47mAExkv8LV/SasrlX6avvDXbR
+8O70zoan4G7ptGmh32n2M8ZpLpcTnqWHsFcQgTfJU7O7f/aS0ZzQGPSSbtqDT6Zj
+mUyl+17vIWR6IF9sZIUVyzfpYgwLKhbcAS4y2j5L9Z469hdAlO+ekQiG+r5jqFoz
+7Mt0Q5X5bGlSNscpb/xVA1wf+5+9R+vnSUeVC06JIglJ4PVhHvG/LopyboBZ/1c6
++XUyo05f7O0oYtlNc/LMgRdg7c3r3NunysV+Ar3yVAhU/bQtCSwXVEqY0VThUWcI
+0u1ufm8/0i2BWSlmy5A5lREedCf+3euvAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMB
+Af8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSwDPBMMPQFWAJI/TPlUq9LhONm
+UjANBgkqhkiG9w0BAQwFAAOCAgEAqqiAjw54o+Ci1M3m9Zh6O+oAA7CXDpO8Wqj2
+LIxyh6mx/H9z/WNxeKWHWc8w4Q0QshNabYL1auaAn6AFC2jkR2vHat+2/XcycuUY
++gn0oJMsXdKMdYV2ZZAMA3m3MSNjrXiDCYZohMr/+c8mmpJ5581LxedhpxfL86kS
+k5Nrp+gvU5LEYFiwzAJRGFuFjWJZY7attN6a+yb3ACfAXVU3dJnJUH/jWS5E4ywl
+7uxMMne0nxrpS10gxdr9HIcWxkPo1LsmmkVwXqkLN1PiRnsn/eBG8om3zEK2yygm
+btmlyTrIQRNg91CMFa6ybRoVGld45pIq2WWQgj9sAq+uEjonljYE1x2igGOpm/Hl
+urR8FLBOybEfdF849lHqm/osohHUqS0nGkWxr7JOcQ3AWEbWaQbLU8uz/mtBzUF+
+fUwPfHJ5elnNXkoOrJupmHN5fLT0zLm4BwyydFy4x2+IoZCn9Kr5v2c69BoVYh63
+n749sSmvZ6ES8lgQGVMDMBu4Gon2nL2XA46jCfMdiyHxtN/kHNGfZQIG6lzWE7OE
+76KlXIx3KadowGuuQNKotOrN8I1LOJwZmhsoVLiJkO/KdYE+HvJkJMcYr07/R54H
+9jVlpNMKVv/1F2Rs76giJUmTtt8AF9pYfl3uxRuw0dFfIRDH+fO6AgonB8Xx1sfT
+4PsJYGw=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 3 O=Amazon
+# Subject: CN=Amazon Root CA 3 O=Amazon
+# Label: "Amazon Root CA 3"
+# Serial: 143266986699090766294700635381230934788665930
+# MD5 Fingerprint: a0:d4:ef:0b:f7:b5:d8:49:95:2a:ec:f5:c4:fc:81:87
+# SHA1 Fingerprint: 0d:44:dd:8c:3c:8c:1a:1a:58:75:64:81:e9:0f:2e:2a:ff:b3:d2:6e
+# SHA256 Fingerprint: 18:ce:6c:fe:7b:f1:4e:60:b2:e3:47:b8:df:e8:68:cb:31:d0:2e:bb:3a:da:27:15:69:f5:03:43:b4:6d:b3:a4
+-----BEGIN CERTIFICATE-----
+MIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5
+MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g
+Um9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG
+A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg
+Q0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl
+ui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr
+ttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr
+BqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM
+YyRIHN8wfdVoOw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 4 O=Amazon
+# Subject: CN=Amazon Root CA 4 O=Amazon
+# Label: "Amazon Root CA 4"
+# Serial: 143266989758080763974105200630763877849284878
+# MD5 Fingerprint: 89:bc:27:d5:eb:17:8d:06:6a:69:d5:fd:89:47:b4:cd
+# SHA1 Fingerprint: f6:10:84:07:d6:f8:bb:67:98:0c:c2:e2:44:c2:eb:ae:1c:ef:63:be
+# SHA256 Fingerprint: e3:5d:28:41:9e:d0:20:25:cf:a6:90:38:cd:62:39:62:45:8d:a5:c6:95:fb:de:a3:c2:2b:0b:fb:25:89:70:92
+-----BEGIN CERTIFICATE-----
+MIIB8jCCAXigAwIBAgITBmyf18G7EEwpQ+Vxe3ssyBrBDjAKBggqhkjOPQQDAzA5
+MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g
+Um9vdCBDQSA0MB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG
+A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg
+Q0EgNDB2MBAGByqGSM49AgEGBSuBBAAiA2IABNKrijdPo1MN/sGKe0uoe0ZLY7Bi
+9i0b2whxIdIA6GO9mif78DluXeo9pcmBqqNbIJhFXRbb/egQbeOc4OO9X4Ri83Bk
+M6DLJC9wuoihKqB1+IGuYgbEgds5bimwHvouXKNCMEAwDwYDVR0TAQH/BAUwAwEB
+/zAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFNPsxzplbszh2naaVvuc84ZtV+WB
+MAoGCCqGSM49BAMDA2gAMGUCMDqLIfG9fhGt0O9Yli/W651+kI0rz2ZVwyzjKKlw
+CkcO8DdZEv8tmZQoTipPNU0zWgIxAOp1AE47xDqUEpHJWEadIRNyp4iciuRMStuW
+1KyLa2tJElMzrdfkviT8tQp21KW8EA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
+# Subject: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
+# Label: "TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1"
+# Serial: 1
+# MD5 Fingerprint: dc:00:81:dc:69:2f:3e:2f:b0:3b:f6:3d:5a:91:8e:49
+# SHA1 Fingerprint: 31:43:64:9b:ec:ce:27:ec:ed:3a:3f:0b:8f:0d:e4:e8:91:dd:ee:ca
+# SHA256 Fingerprint: 46:ed:c3:68:90:46:d5:3a:45:3f:b3:10:4a:b8:0d:ca:ec:65:8b:26:60:ea:16:29:dd:7e:86:79:90:64:87:16
+-----BEGIN CERTIFICATE-----
+MIIEYzCCA0ugAwIBAgIBATANBgkqhkiG9w0BAQsFADCB0jELMAkGA1UEBhMCVFIx
+GDAWBgNVBAcTD0dlYnplIC0gS29jYWVsaTFCMEAGA1UEChM5VHVya2l5ZSBCaWxp
+bXNlbCB2ZSBUZWtub2xvamlrIEFyYXN0aXJtYSBLdXJ1bXUgLSBUVUJJVEFLMS0w
+KwYDVQQLEyRLYW11IFNlcnRpZmlrYXN5b24gTWVya2V6aSAtIEthbXUgU00xNjA0
+BgNVBAMTLVRVQklUQUsgS2FtdSBTTSBTU0wgS29rIFNlcnRpZmlrYXNpIC0gU3Vy
+dW0gMTAeFw0xMzExMjUwODI1NTVaFw00MzEwMjUwODI1NTVaMIHSMQswCQYDVQQG
+EwJUUjEYMBYGA1UEBxMPR2ViemUgLSBLb2NhZWxpMUIwQAYDVQQKEzlUdXJraXll
+IEJpbGltc2VsIHZlIFRla25vbG9qaWsgQXJhc3Rpcm1hIEt1cnVtdSAtIFRVQklU
+QUsxLTArBgNVBAsTJEthbXUgU2VydGlmaWthc3lvbiBNZXJrZXppIC0gS2FtdSBT
+TTE2MDQGA1UEAxMtVFVCSVRBSyBLYW11IFNNIFNTTCBLb2sgU2VydGlmaWthc2kg
+LSBTdXJ1bSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAr3UwM6q7
+a9OZLBI3hNmNe5eA027n/5tQlT6QlVZC1xl8JoSNkvoBHToP4mQ4t4y86Ij5iySr
+LqP1N+RAjhgleYN1Hzv/bKjFxlb4tO2KRKOrbEz8HdDc72i9z+SqzvBV96I01INr
+N3wcwv61A+xXzry0tcXtAA9TNypN9E8Mg/uGz8v+jE69h/mniyFXnHrfA2eJLJ2X
+YacQuFWQfw4tJzh03+f92k4S400VIgLI4OD8D62K18lUUMw7D8oWgITQUVbDjlZ/
+iSIzL+aFCr2lqBs23tPcLG07xxO9WSMs5uWk99gL7eqQQESolbuT1dCANLZGeA4f
+AJNG4e7p+exPFwIDAQABo0IwQDAdBgNVHQ4EFgQUZT/HiobGPN08VFw1+DrtUgxH
+V8gwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
+BQADggEBACo/4fEyjq7hmFxLXs9rHmoJ0iKpEsdeV31zVmSAhHqT5Am5EM2fKifh
+AHe+SMg1qIGf5LgsyX8OsNJLN13qudULXjS99HMpw+0mFZx+CFOKWI3QSyjfwbPf
+IPP54+M638yclNhOT8NrF7f3cuitZjO1JVOr4PhMqZ398g26rrnZqsZr+ZO7rqu4
+lzwDGrpDxpa5RXI4s6ehlj2Re37AIVNMh+3yC1SVUZPVIqUNivGTDj5UDrDYyU7c
+8jEyVupk+eq1nRZmQnLzf9OxMUP8pI4X8W0jq5Rm+K37DwhuJi1/FwcJsoz7UMCf
+lo3Ptv0AnVoUmr8CRPXBwp8iXqIPoeM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD.
+# Subject: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD.
+# Label: "GDCA TrustAUTH R5 ROOT"
+# Serial: 9009899650740120186
+# MD5 Fingerprint: 63:cc:d9:3d:34:35:5c:6f:53:a3:e2:08:70:48:1f:b4
+# SHA1 Fingerprint: 0f:36:38:5b:81:1a:25:c3:9b:31:4e:83:ca:e9:34:66:70:cc:74:b4
+# SHA256 Fingerprint: bf:ff:8f:d0:44:33:48:7d:6a:8a:a6:0c:1a:29:76:7a:9f:c2:bb:b0:5e:42:0f:71:3a:13:b9:92:89:1d:38:93
+-----BEGIN CERTIFICATE-----
+MIIFiDCCA3CgAwIBAgIIfQmX/vBH6nowDQYJKoZIhvcNAQELBQAwYjELMAkGA1UE
+BhMCQ04xMjAwBgNVBAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZ
+IENPLixMVEQuMR8wHQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMB4XDTE0
+MTEyNjA1MTMxNVoXDTQwMTIzMTE1NTk1OVowYjELMAkGA1UEBhMCQ04xMjAwBgNV
+BAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZIENPLixMVEQuMR8w
+HQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMIICIjANBgkqhkiG9w0BAQEF
+AAOCAg8AMIICCgKCAgEA2aMW8Mh0dHeb7zMNOwZ+Vfy1YI92hhJCfVZmPoiC7XJj
+Dp6L3TQsAlFRwxn9WVSEyfFrs0yw6ehGXTjGoqcuEVe6ghWinI9tsJlKCvLriXBj
+TnnEt1u9ol2x8kECK62pOqPseQrsXzrj/e+APK00mxqriCZ7VqKChh/rNYmDf1+u
+KU49tm7srsHwJ5uu4/Ts765/94Y9cnrrpftZTqfrlYwiOXnhLQiPzLyRuEH3FMEj
+qcOtmkVEs7LXLM3GKeJQEK5cy4KOFxg2fZfmiJqwTTQJ9Cy5WmYqsBebnh52nUpm
+MUHfP/vFBu8btn4aRjb3ZGM74zkYI+dndRTVdVeSN72+ahsmUPI2JgaQxXABZG12
+ZuGR224HwGGALrIuL4xwp9E7PLOR5G62xDtw8mySlwnNR30YwPO7ng/Wi64HtloP
+zgsMR6flPri9fcebNaBhlzpBdRfMK5Z3KpIhHtmVdiBnaM8Nvd/WHwlqmuLMc3Gk
+L30SgLdTMEZeS1SZD2fJpcjyIMGC7J0R38IC+xo70e0gmu9lZJIQDSri3nDxGGeC
+jGHeuLzRL5z7D9Ar7Rt2ueQ5Vfj4oR24qoAATILnsn8JuLwwoC8N9VKejveSswoA
+HQBUlwbgsQfZxw9cZX08bVlX5O2ljelAU58VS6Bx9hoh49pwBiFYFIeFd3mqgnkC
+AwEAAaNCMEAwHQYDVR0OBBYEFOLJQJ9NzuiaoXzPDj9lxSmIahlRMA8GA1UdEwEB
+/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQDRSVfg
+p8xoWLoBDysZzY2wYUWsEe1jUGn4H3++Fo/9nesLqjJHdtJnJO29fDMylyrHBYZm
+DRd9FBUb1Ov9H5r2XpdptxolpAqzkT9fNqyL7FeoPueBihhXOYV0GkLH6VsTX4/5
+COmSdI31R9KrO9b7eGZONn356ZLpBN79SWP8bfsUcZNnL0dKt7n/HipzcEYwv1ry
+L3ml4Y0M2fmyYzeMN2WFcGpcWwlyua1jPLHd+PwyvzeG5LuOmCd+uh8W4XAR8gPf
+JWIyJyYYMoSf/wA6E7qaTfRPuBRwIrHKK5DOKcFw9C+df/KQHtZa37dG/OaG+svg
+IHZ6uqbL9XzeYqWxi+7egmaKTjowHz+Ay60nugxe19CxVsp3cbK1daFQqUBDF8Io
+2c9Si1vIY9RCPqAzekYu9wogRlR+ak8x8YF+QnQ4ZXMn7sZ8uI7XpTrXmKGcjBBV
+09tL7ECQ8s1uV9JiDnxXk7Gnbc2dg7sq5+W2O3FYrf3RRbxake5TFW/TRQl1brqQ
+XR4EzzffHqhmsYzmIGrv/EhOdJhCrylvLmrH+33RZjEizIYAfmaDDEL0vTSSwxrq
+T8p+ck0LcIymSLumoRT2+1hEmRSuqguTaaApJUqlyyvdimYHFngVV3Eb7PVHhPOe
+MTd61X8kreS8/f3MboPoDKi3QWwH3b08hpcv0g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=TrustCor RootCert CA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Subject: CN=TrustCor RootCert CA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Label: "TrustCor RootCert CA-1"
+# Serial: 15752444095811006489
+# MD5 Fingerprint: 6e:85:f1:dc:1a:00:d3:22:d5:b2:b2:ac:6b:37:05:45
+# SHA1 Fingerprint: ff:bd:cd:e7:82:c8:43:5e:3c:6f:26:86:5c:ca:a8:3a:45:5b:c3:0a
+# SHA256 Fingerprint: d4:0e:9c:86:cd:8f:e4:68:c1:77:69:59:f4:9e:a7:74:fa:54:86:84:b6:c4:06:f3:90:92:61:f4:dc:e2:57:5c
+-----BEGIN CERTIFICATE-----
+MIIEMDCCAxigAwIBAgIJANqb7HHzA7AZMA0GCSqGSIb3DQEBCwUAMIGkMQswCQYD
+VQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEgQ2l0eTEk
+MCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYDVQQLDB5U
+cnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxHzAdBgNVBAMMFlRydXN0Q29y
+IFJvb3RDZXJ0IENBLTEwHhcNMTYwMjA0MTIzMjE2WhcNMjkxMjMxMTcyMzE2WjCB
+pDELMAkGA1UEBhMCUEExDzANBgNVBAgMBlBhbmFtYTEUMBIGA1UEBwwLUGFuYW1h
+IENpdHkxJDAiBgNVBAoMG1RydXN0Q29yIFN5c3RlbXMgUy4gZGUgUi5MLjEnMCUG
+A1UECwweVHJ1c3RDb3IgQ2VydGlmaWNhdGUgQXV0aG9yaXR5MR8wHQYDVQQDDBZU
+cnVzdENvciBSb290Q2VydCBDQS0xMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEAv463leLCJhJrMxnHQFgKq1mqjQCj/IDHUHuO1CAmujIS2CNUSSUQIpid
+RtLByZ5OGy4sDjjzGiVoHKZaBeYei0i/mJZ0PmnK6bV4pQa81QBeCQryJ3pS/C3V
+seq0iWEk8xoT26nPUu0MJLq5nux+AHT6k61sKZKuUbS701e/s/OojZz0JEsq1pme
+9J7+wH5COucLlVPat2gOkEz7cD+PSiyU8ybdY2mplNgQTsVHCJCZGxdNuWxu72CV
+EY4hgLW9oHPY0LJ3xEXqWib7ZnZ2+AYfYW0PVcWDtxBWcgYHpfOxGgMFZA6dWorW
+hnAbJN7+KIor0Gqw/Hqi3LJ5DotlDwIDAQABo2MwYTAdBgNVHQ4EFgQU7mtJPHo/
+DeOxCbeKyKsZn3MzUOcwHwYDVR0jBBgwFoAU7mtJPHo/DeOxCbeKyKsZn3MzUOcw
+DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD
+ggEBACUY1JGPE+6PHh0RU9otRCkZoB5rMZ5NDp6tPVxBb5UrJKF5mDo4Nvu7Zp5I
+/5CQ7z3UuJu0h3U/IJvOcs+hVcFNZKIZBqEHMwwLKeXx6quj7LUKdJDHfXLy11yf
+ke+Ri7fc7Waiz45mO7yfOgLgJ90WmMCV1Aqk5IGadZQ1nJBfiDcGrVmVCrDRZ9MZ
+yonnMlo2HD6CqFqTvsbQZJG2z9m2GM/bftJlo6bEjhcxwft+dtvTheNYsnd6djts
+L1Ac59v2Z3kf9YKVmgenFK+P3CghZwnS1k1aHBkcjndcw5QkPTJrS37UeJSDvjdN
+zl/HHk484IkzlQsPpTLWPFp5LBk=
+-----END CERTIFICATE-----
+
+# Issuer: CN=TrustCor RootCert CA-2 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Subject: CN=TrustCor RootCert CA-2 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Label: "TrustCor RootCert CA-2"
+# Serial: 2711694510199101698
+# MD5 Fingerprint: a2:e1:f8:18:0b:ba:45:d5:c7:41:2a:bb:37:52:45:64
+# SHA1 Fingerprint: b8:be:6d:cb:56:f1:55:b9:63:d4:12:ca:4e:06:34:c7:94:b2:1c:c0
+# SHA256 Fingerprint: 07:53:e9:40:37:8c:1b:d5:e3:83:6e:39:5d:ae:a5:cb:83:9e:50:46:f1:bd:0e:ae:19:51:cf:10:fe:c7:c9:65
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=TrustCor ECA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Subject: CN=TrustCor ECA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Label: "TrustCor ECA-1"
+# Serial: 9548242946988625984
+# MD5 Fingerprint: 27:92:23:1d:0a:f5:40:7c:e9:e6:6b:9d:d8:f5:e7:6c
+# SHA1 Fingerprint: 58:d1:df:95:95:67:6b:63:c0:f0:5b:1c:17:4d:8b:84:0b:c8:78:bd
+# SHA256 Fingerprint: 5a:88:5d:b1:9c:01:d9:12:c5:75:93:88:93:8c:af:bb:df:03:1a:b2:d4:8e:91:ee:15:58:9b:42:97:1d:03:9c
+-----BEGIN CERTIFICATE-----
+MIIEIDCCAwigAwIBAgIJAISCLF8cYtBAMA0GCSqGSIb3DQEBCwUAMIGcMQswCQYD
+VQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEgQ2l0eTEk
+MCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYDVQQLDB5U
+cnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxFzAVBgNVBAMMDlRydXN0Q29y
+IEVDQS0xMB4XDTE2MDIwNDEyMzIzM1oXDTI5MTIzMTE3MjgwN1owgZwxCzAJBgNV
+BAYTAlBBMQ8wDQYDVQQIDAZQYW5hbWExFDASBgNVBAcMC1BhbmFtYSBDaXR5MSQw
+IgYDVQQKDBtUcnVzdENvciBTeXN0ZW1zIFMuIGRlIFIuTC4xJzAlBgNVBAsMHlRy
+dXN0Q29yIENlcnRpZmljYXRlIEF1dGhvcml0eTEXMBUGA1UEAwwOVHJ1c3RDb3Ig
+RUNBLTEwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDPj+ARtZ+odnbb
+3w9U73NjKYKtR8aja+3+XzP4Q1HpGjORMRegdMTUpwHmspI+ap3tDvl0mEDTPwOA
+BoJA6LHip1GnHYMma6ve+heRK9jGrB6xnhkB1Zem6g23xFUfJ3zSCNV2HykVh0A5
+3ThFEXXQmqc04L/NyFIduUd+Dbi7xgz2c1cWWn5DkR9VOsZtRASqnKmcp0yJF4Ou
+owReUoCLHhIlERnXDH19MURB6tuvsBzvgdAsxZohmz3tQjtQJvLsznFhBmIhVE5/
+wZ0+fyCMgMsq2JdiyIMzkX2woloPV+g7zPIlstR8L+xNxqE6FXrntl019fZISjZF
+ZtS6mFjBAgMBAAGjYzBhMB0GA1UdDgQWBBREnkj1zG1I1KBLf/5ZJC+Dl5mahjAf
+BgNVHSMEGDAWgBREnkj1zG1I1KBLf/5ZJC+Dl5mahjAPBgNVHRMBAf8EBTADAQH/
+MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAQEABT41XBVwm8nHc2Fv
+civUwo/yQ10CzsSUuZQRg2dd4mdsdXa/uwyqNsatR5Nj3B5+1t4u/ukZMjgDfxT2
+AHMsWbEhBuH7rBiVDKP/mZb3Kyeb1STMHd3BOuCYRLDE5D53sXOpZCz2HAF8P11F
+hcCF5yWPldwX8zyfGm6wyuMdKulMY/okYWLW2n62HGz1Ah3UKt1VkOsqEUc8Ll50
+soIipX1TH0XsJ5F95yIW6MBoNtjG8U+ARDL54dHRHareqKucBK+tIA5kmE2la8BI
+WJZpTdwHjFGTot+fDz2LYLSCjaoITmJF4PkL0uDgPFveXHEnJcLmA4GLEFPjx1Wi
+tJ/X5g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com Root Certification Authority RSA O=SSL Corporation
+# Subject: CN=SSL.com Root Certification Authority RSA O=SSL Corporation
+# Label: "SSL.com Root Certification Authority RSA"
+# Serial: 8875640296558310041
+# MD5 Fingerprint: 86:69:12:c0:70:f1:ec:ac:ac:c2:d5:bc:a5:5b:a1:29
+# SHA1 Fingerprint: b7:ab:33:08:d1:ea:44:77:ba:14:80:12:5a:6f:bd:a9:36:49:0c:bb
+# SHA256 Fingerprint: 85:66:6a:56:2e:e0:be:5c:e9:25:c1:d8:89:0a:6f:76:a8:7e:c1:6d:4d:7d:5f:29:ea:74:19:cf:20:12:3b:69
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com Root Certification Authority ECC O=SSL Corporation
+# Subject: CN=SSL.com Root Certification Authority ECC O=SSL Corporation
+# Label: "SSL.com Root Certification Authority ECC"
+# Serial: 8495723813297216424
+# MD5 Fingerprint: 2e:da:e4:39:7f:9c:8f:37:d1:70:9f:26:17:51:3a:8e
+# SHA1 Fingerprint: c3:19:7c:39:24:e6:54:af:1b:c4:ab:20:95:7a:e2:c3:0e:13:02:6a
+# SHA256 Fingerprint: 34:17:bb:06:cc:60:07:da:1b:96:1c:92:0b:8a:b4:ce:3f:ad:82:0e:4a:a3:0b:9a:cb:c4:a7:4e:bd:ce:bc:65
+-----BEGIN CERTIFICATE-----
+MIICjTCCAhSgAwIBAgIIdebfy8FoW6gwCgYIKoZIzj0EAwIwfDELMAkGA1UEBhMC
+VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T
+U0wgQ29ycG9yYXRpb24xMTAvBgNVBAMMKFNTTC5jb20gUm9vdCBDZXJ0aWZpY2F0
+aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNDAzWhcNNDEwMjEyMTgxNDAz
+WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hvdXN0
+b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjExMC8GA1UEAwwoU1NMLmNvbSBS
+b290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABEVuqVDEpiM2nl8ojRfLliJkP9x6jh3MCLOicSS6jkm5BBtHllirLZXI
+7Z4INcgn64mMU1jrYor+8FsPazFSY0E7ic3s7LaNGdM0B9y7xgZ/wkWV7Mt/qCPg
+CemB+vNH06NjMGEwHQYDVR0OBBYEFILRhXMw5zUE044CkvvlpNHEIejNMA8GA1Ud
+EwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUgtGFczDnNQTTjgKS++Wk0cQh6M0wDgYD
+VR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2cAMGQCMG/n61kRpGDPYbCWe+0F+S8T
+kdzt5fxQaxFGRrMcIQBiu77D5+jNB5n5DQtdcj7EqgIwH7y6C+IwJPt8bYBVCpk+
+gA0z5Wajs6O7pdWLjwkspl1+4vAHCGht0nxpbl/f5Wpl
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation
+# Subject: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation
+# Label: "SSL.com EV Root Certification Authority RSA R2"
+# Serial: 6248227494352943350
+# MD5 Fingerprint: e1:1e:31:58:1a:ae:54:53:02:f6:17:6a:11:7b:4d:95
+# SHA1 Fingerprint: 74:3a:f0:52:9b:d0:32:a0:f4:4a:83:cd:d4:ba:a9:7b:7c:2e:c4:9a
+# SHA256 Fingerprint: 2e:7b:f1:6c:c2:24:85:a7:bb:e2:aa:86:96:75:07:61:b0:ae:39:be:3b:2f:e9:d0:cc:6d:4e:f7:34:91:42:5c
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation
+# Subject: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation
+# Label: "SSL.com EV Root Certification Authority ECC"
+# Serial: 3182246526754555285
+# MD5 Fingerprint: 59:53:22:65:83:42:01:54:c0:ce:42:b9:5a:7c:f2:90
+# SHA1 Fingerprint: 4c:dd:51:a3:d1:f5:20:32:14:b0:c6:c5:32:23:03:91:c7:46:42:6d
+# SHA256 Fingerprint: 22:a2:c1:f7:bd:ed:70:4c:c1:e7:01:b5:f4:08:c3:10:88:0f:e9:56:b5:de:2a:4a:44:f9:9c:87:3a:25:a7:c8
+-----BEGIN CERTIFICATE-----
+MIIClDCCAhqgAwIBAgIILCmcWxbtBZUwCgYIKoZIzj0EAwIwfzELMAkGA1UEBhMC
+VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T
+U0wgQ29ycG9yYXRpb24xNDAyBgNVBAMMK1NTTC5jb20gRVYgUm9vdCBDZXJ0aWZp
+Y2F0aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNTIzWhcNNDEwMjEyMTgx
+NTIzWjB/MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hv
+dXN0b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjE0MDIGA1UEAwwrU1NMLmNv
+bSBFViBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49
+AgEGBSuBBAAiA2IABKoSR5CYG/vvw0AHgyBO8TCCogbR8pKGYfL2IWjKAMTH6kMA
+VIbc/R/fALhBYlzccBYy3h+Z1MzFB8gIH2EWB1E9fVwHU+M1OIzfzZ/ZLg1Kthku
+WnBaBu2+8KGwytAJKaNjMGEwHQYDVR0OBBYEFFvKXuXe0oGqzagtZFG22XKbl+ZP
+MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUW8pe5d7SgarNqC1kUbbZcpuX
+5k8wDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2gAMGUCMQCK5kCJN+vp1RPZ
+ytRrJPOwPYdGWBrssd9v+1a6cGvHOMzosYxPD/fxZ3YOg9AeUY8CMD32IygmTMZg
+h5Mmm7I1HrrW9zzRHM76JTymGoEVW/MSD2zuZYrJh6j5B+BimoxcSg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
+# Label: "GlobalSign Root CA - R6"
+# Serial: 1417766617973444989252670301619537
+# MD5 Fingerprint: 4f:dd:07:e4:d4:22:64:39:1e:0c:37:42:ea:d1:c6:ae
+# SHA1 Fingerprint: 80:94:64:0e:b5:a7:a1:ca:11:9c:1f:dd:d5:9f:81:02:63:a7:fb:d1
+# SHA256 Fingerprint: 2c:ab:ea:fe:37:d0:6c:a2:2a:ba:73:91:c0:03:3d:25:98:29:52:c4:53:64:73:49:76:3a:3a:b5:ad:6c:cf:69
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIORea7A4Mzw4VlSOb/RVEwDQYJKoZIhvcNAQEMBQAwTDEg
+MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjYxEzARBgNVBAoTCkdsb2Jh
+bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTQxMjEwMDAwMDAwWhcNMzQx
+MjEwMDAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSNjET
+MBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCAiIwDQYJ
+KoZIhvcNAQEBBQADggIPADCCAgoCggIBAJUH6HPKZvnsFMp7PPcNCPG0RQssgrRI
+xutbPK6DuEGSMxSkb3/pKszGsIhrxbaJ0cay/xTOURQh7ErdG1rG1ofuTToVBu1k
+ZguSgMpE3nOUTvOniX9PeGMIyBJQbUJmL025eShNUhqKGoC3GYEOfsSKvGRMIRxD
+aNc9PIrFsmbVkJq3MQbFvuJtMgamHvm566qjuL++gmNQ0PAYid/kD3n16qIfKtJw
+LnvnvJO7bVPiSHyMEAc4/2ayd2F+4OqMPKq0pPbzlUoSB239jLKJz9CgYXfIWHSw
+1CM69106yqLbnQneXUQtkPGBzVeS+n68UARjNN9rkxi+azayOeSsJDa38O+2HBNX
+k7besvjihbdzorg1qkXy4J02oW9UivFyVm4uiMVRQkQVlO6jxTiWm05OWgtH8wY2
+SXcwvHE35absIQh1/OZhFj931dmRl4QKbNQCTXTAFO39OfuD8l4UoQSwC+n+7o/h
+bguyCLNhZglqsQY6ZZZZwPA1/cnaKI0aEYdwgQqomnUdnjqGBQCe24DWJfncBZ4n
+WUx2OVvq+aWh2IMP0f/fMBH5hc8zSPXKbWQULHpYT9NLCEnFlWQaYw55PfWzjMpY
+rZxCRXluDocZXFSxZba/jJvcE+kNb7gu3GduyYsRtYQUigAZcIN5kZeR1Bonvzce
+MgfYFGM8KEyvAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTAD
+AQH/MB0GA1UdDgQWBBSubAWjkxPioufi1xzWx/B/yGdToDAfBgNVHSMEGDAWgBSu
+bAWjkxPioufi1xzWx/B/yGdToDANBgkqhkiG9w0BAQwFAAOCAgEAgyXt6NH9lVLN
+nsAEoJFp5lzQhN7craJP6Ed41mWYqVuoPId8AorRbrcWc+ZfwFSY1XS+wc3iEZGt
+Ixg93eFyRJa0lV7Ae46ZeBZDE1ZXs6KzO7V33EByrKPrmzU+sQghoefEQzd5Mr61
+55wsTLxDKZmOMNOsIeDjHfrYBzN2VAAiKrlNIC5waNrlU/yDXNOd8v9EDERm8tLj
+vUYAGm0CuiVdjaExUd1URhxN25mW7xocBFymFe944Hn+Xds+qkxV/ZoVqW/hpvvf
+cDDpw+5CRu3CkwWJ+n1jez/QcYF8AOiYrg54NMMl+68KnyBr3TsTjxKM4kEaSHpz
+oHdpx7Zcf4LIHv5YGygrqGytXm3ABdJ7t+uA/iU3/gKbaKxCXcPu9czc8FB10jZp
+nOZ7BN9uBmm23goJSFmH63sUYHpkqmlD75HHTOwY3WzvUy2MmeFe8nI+z1TIvWfs
+pA9MRf/TuTAjB0yPEL+GltmZWrSZVxykzLsViVO6LAUP5MSeGbEYNNVMnbrt9x+v
+JJUEeKgDu+6B5dpffItKoZB0JaezPkvILFa9x8jvOOJckvB595yEunQtYQEgfn7R
+8k8HWV+LLUNS60YMlOH1Zkd5d9VUWx+tJDfLRVpOoERIyNiwmcUVhAn21klJwGW4
+5hpxbqCo8YLoRT5s1gLXCmeDBVrJpBA=
+-----END CERTIFICATE-----
+
+# Issuer: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
+# Subject: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
+# Label: "OISTE WISeKey Global Root GC CA"
+# Serial: 44084345621038548146064804565436152554
+# MD5 Fingerprint: a9:d6:b9:2d:2f:93:64:f8:a5:69:ca:91:e9:68:07:23
+# SHA1 Fingerprint: e0:11:84:5e:34:de:be:88:81:b9:9c:f6:16:26:d1:96:1f:c3:b9:31
+# SHA256 Fingerprint: 85:60:f9:1c:36:24:da:ba:95:70:b5:fe:a0:db:e3:6f:f1:1a:83:23:be:94:86:85:4f:b3:f3:4a:55:71:19:8d
+-----BEGIN CERTIFICATE-----
+MIICaTCCAe+gAwIBAgIQISpWDK7aDKtARb8roi066jAKBggqhkjOPQQDAzBtMQsw
+CQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUgRm91
+bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwg
+Um9vdCBHQyBDQTAeFw0xNzA1MDkwOTQ4MzRaFw00MjA1MDkwOTU4MzNaMG0xCzAJ
+BgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBGb3Vu
+ZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2JhbCBS
+b290IEdDIENBMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAETOlQwMYPchi82PG6s4ni
+eUqjFqdrVCTbUf/q9Akkwwsin8tqJ4KBDdLArzHkdIJuyiXZjHWd8dvQmqJLIX4W
+p2OQ0jnUsYd4XxiWD1AbNTcPasbc2RNNpI6QN+a9WzGRo1QwUjAOBgNVHQ8BAf8E
+BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSIcUrOPDnpBgOtfKie7T
+rYy0UGYwEAYJKwYBBAGCNxUBBAMCAQAwCgYIKoZIzj0EAwMDaAAwZQIwJsdpW9zV
+57LnyAyMjMPdeYwbY9XJUpROTYJKcx6ygISpJcBMWm1JKWB4E+J+SOtkAjEA2zQg
+Mgj/mkkCtojeFK9dbJlxjRo/i9fgojaGHAeCOnZT/cKi7e97sIBPWA9LUzm9
+-----END CERTIFICATE-----
+
+# Issuer: CN=UCA Global G2 Root O=UniTrust
+# Subject: CN=UCA Global G2 Root O=UniTrust
+# Label: "UCA Global G2 Root"
+# Serial: 124779693093741543919145257850076631279
+# MD5 Fingerprint: 80:fe:f0:c4:4a:f0:5c:62:32:9f:1c:ba:78:a9:50:f8
+# SHA1 Fingerprint: 28:f9:78:16:19:7a:ff:18:25:18:aa:44:fe:c1:a0:ce:5c:b6:4c:8a
+# SHA256 Fingerprint: 9b:ea:11:c9:76:fe:01:47:64:c1:be:56:a6:f9:14:b5:a5:60:31:7a:bd:99:88:39:33:82:e5:16:1a:a0:49:3c
+-----BEGIN CERTIFICATE-----
+MIIFRjCCAy6gAwIBAgIQXd+x2lqj7V2+WmUgZQOQ7zANBgkqhkiG9w0BAQsFADA9
+MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxGzAZBgNVBAMMElVDQSBH
+bG9iYWwgRzIgUm9vdDAeFw0xNjAzMTEwMDAwMDBaFw00MDEyMzEwMDAwMDBaMD0x
+CzAJBgNVBAYTAkNOMREwDwYDVQQKDAhVbmlUcnVzdDEbMBkGA1UEAwwSVUNBIEds
+b2JhbCBHMiBSb290MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxeYr
+b3zvJgUno4Ek2m/LAfmZmqkywiKHYUGRO8vDaBsGxUypK8FnFyIdK+35KYmToni9
+kmugow2ifsqTs6bRjDXVdfkX9s9FxeV67HeToI8jrg4aA3++1NDtLnurRiNb/yzm
+VHqUwCoV8MmNsHo7JOHXaOIxPAYzRrZUEaalLyJUKlgNAQLx+hVRZ2zA+te2G3/R
+VogvGjqNO7uCEeBHANBSh6v7hn4PJGtAnTRnvI3HLYZveT6OqTwXS3+wmeOwcWDc
+C/Vkw85DvG1xudLeJ1uK6NjGruFZfc8oLTW4lVYa8bJYS7cSN8h8s+1LgOGN+jIj
+tm+3SJUIsUROhYw6AlQgL9+/V087OpAh18EmNVQg7Mc/R+zvWr9LesGtOxdQXGLY
+D0tK3Cv6brxzks3sx1DoQZbXqX5t2Okdj4q1uViSukqSKwxW/YDrCPBeKW4bHAyv
+j5OJrdu9o54hyokZ7N+1wxrrFv54NkzWbtA+FxyQF2smuvt6L78RHBgOLXMDj6Dl
+NaBa4kx1HXHhOThTeEDMg5PXCp6dW4+K5OXgSORIskfNTip1KnvyIvbJvgmRlld6
+iIis7nCs+dwp4wwcOxJORNanTrAmyPPZGpeRaOrvjUYG0lZFWJo8DA+DuAUlwznP
+O6Q0ibd5Ei9Hxeepl2n8pndntd978XplFeRhVmUCAwEAAaNCMEAwDgYDVR0PAQH/
+BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFIHEjMz15DD/pQwIX4wV
+ZyF0Ad/fMA0GCSqGSIb3DQEBCwUAA4ICAQATZSL1jiutROTL/7lo5sOASD0Ee/oj
+L3rtNtqyzm325p7lX1iPyzcyochltq44PTUbPrw7tgTQvPlJ9Zv3hcU2tsu8+Mg5
+1eRfB70VVJd0ysrtT7q6ZHafgbiERUlMjW+i67HM0cOU2kTC5uLqGOiiHycFutfl
+1qnN3e92mI0ADs0b+gO3joBYDic/UvuUospeZcnWhNq5NXHzJsBPd+aBJ9J3O5oU
+b3n09tDh05S60FdRvScFDcH9yBIw7m+NESsIndTUv4BFFJqIRNow6rSn4+7vW4LV
+PtateJLbXDzz2K36uGt/xDYotgIVilQsnLAXc47QN6MUPJiVAAwpBVueSUmxX8fj
+y88nZY41F7dXyDDZQVu5FLbowg+UMaeUmMxq67XhJ/UQqAHojhJi6IjMtX9Gl8Cb
+EGY4GjZGXyJoPd/JxhMnq1MGrKI8hgZlb7F+sSlEmqO6SWkoaY/X5V+tBIZkbxqg
+DMUIYs6Ao9Dz7GjevjPHF1t/gMRMTLGmhIrDO7gJzRSBuhjjVFc2/tsvfEehOjPI
++Vg7RE+xygKJBJYoaMVLuCaJu9YzL1DV/pqJuhgyklTGW+Cd+V7lDSKb9triyCGy
+YiGqhkCyLmTTX8jjfhFnRR8F/uOi77Oos/N9j/gMHyIfLXC0uAE0djAA5SN4p1bX
+UB+K+wb1whnw0A==
+-----END CERTIFICATE-----
+
+# Issuer: CN=UCA Extended Validation Root O=UniTrust
+# Subject: CN=UCA Extended Validation Root O=UniTrust
+# Label: "UCA Extended Validation Root"
+# Serial: 106100277556486529736699587978573607008
+# MD5 Fingerprint: a1:f3:5f:43:c6:34:9b:da:bf:8c:7e:05:53:ad:96:e2
+# SHA1 Fingerprint: a3:a1:b0:6f:24:61:23:4a:e3:36:a5:c2:37:fc:a6:ff:dd:f0:d7:3a
+# SHA256 Fingerprint: d4:3a:f9:b3:54:73:75:5c:96:84:fc:06:d7:d8:cb:70:ee:5c:28:e7:73:fb:29:4e:b4:1e:e7:17:22:92:4d:24
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgIQT9Irj/VkyDOeTzRYZiNwYDANBgkqhkiG9w0BAQsFADBH
+MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNVBAMMHFVDQSBF
+eHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwHhcNMTUwMzEzMDAwMDAwWhcNMzgxMjMx
+MDAwMDAwWjBHMQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNV
+BAMMHFVDQSBFeHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCpCQcoEwKwmeBkqh5DFnpzsZGgdT6o+uM4AHrsiWog
+D4vFsJszA1qGxliG1cGFu0/GnEBNyr7uaZa4rYEwmnySBesFK5pI0Lh2PpbIILvS
+sPGP2KxFRv+qZ2C0d35qHzwaUnoEPQc8hQ2E0B92CvdqFN9y4zR8V05WAT558aop
+O2z6+I9tTcg1367r3CTueUWnhbYFiN6IXSV8l2RnCdm/WhUFhvMJHuxYMjMR83dk
+sHYf5BA1FxvyDrFspCqjc/wJHx4yGVMR59mzLC52LqGj3n5qiAno8geK+LLNEOfi
+c0CTuwjRP+H8C5SzJe98ptfRr5//lpr1kXuYC3fUfugH0mK1lTnj8/FtDw5lhIpj
+VMWAtuCeS31HJqcBCF3RiJ7XwzJE+oJKCmhUfzhTA8ykADNkUVkLo4KRel7sFsLz
+KuZi2irbWWIQJUoqgQtHB0MGcIfS+pMRKXpITeuUx3BNr2fVUbGAIAEBtHoIppB/
+TuDvB0GHr2qlXov7z1CymlSvw4m6WC31MJixNnI5fkkE/SmnTHnkBVfblLkWU41G
+sx2VYVdWf6/wFlthWG82UBEL2KwrlRYaDh8IzTY0ZRBiZtWAXxQgXy0MoHgKaNYs
+1+lvK9JKBZP8nm9rZ/+I8U6laUpSNwXqxhaN0sSZ0YIrO7o1dfdRUVjzyAfd5LQD
+fwIDAQABo0IwQDAdBgNVHQ4EFgQU2XQ65DA9DfcS3H5aBZ8eNJr34RQwDwYDVR0T
+AQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQADggIBADaN
+l8xCFWQpN5smLNb7rhVpLGsaGvdftvkHTFnq88nIua7Mui563MD1sC3AO6+fcAUR
+ap8lTwEpcOPlDOHqWnzcSbvBHiqB9RZLcpHIojG5qtr8nR/zXUACE/xOHAbKsxSQ
+VBcZEhrxH9cMaVr2cXj0lH2RC47skFSOvG+hTKv8dGT9cZr4QQehzZHkPJrgmzI5
+c6sq1WnIeJEmMX3ixzDx/BR4dxIOE/TdFpS/S2d7cFOFyrC78zhNLJA5wA3CXWvp
+4uXViI3WLL+rG761KIcSF3Ru/H38j9CHJrAb+7lsq+KePRXBOy5nAliRn+/4Qh8s
+t2j1da3Ptfb/EX3C8CSlrdP6oDyp+l3cpaDvRKS+1ujl5BOWF3sGPjLtx7dCvHaj
+2GU4Kzg1USEODm8uNBNA4StnDG1KQTAYI1oyVZnJF+A83vbsea0rWBmirSwiGpWO
+vpaQXUJXxPkUAzUrHC1RVwinOt4/5Mi0A3PCwSaAuwtCH60NryZy2sy+s6ODWA2C
+xR9GUeOcGMyNm43sSet1UNWMKFnKdDTajAshqx7qG+XH/RU+wBeq+yNuJkbL+vmx
+cmtpzyKEC2IPrNkZAJSidjzULZrtBJ4tBmIQN1IchXIbJ+XMxjHsN+xjWZsLHXbM
+fjKaiJUINlK73nZfdklJrX+9ZSCyycErdhh2n1ax
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
+# Subject: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
+# Label: "Certigna Root CA"
+# Serial: 269714418870597844693661054334862075617
+# MD5 Fingerprint: 0e:5c:30:62:27:eb:5b:bc:d7:ae:62:ba:e9:d5:df:77
+# SHA1 Fingerprint: 2d:0d:52:14:ff:9e:ad:99:24:01:74:20:47:6e:6c:85:27:27:f5:43
+# SHA256 Fingerprint: d4:8d:3d:23:ee:db:50:a4:59:e5:51:97:60:1c:27:77:4b:9d:7b:18:c9:4d:5a:05:95:11:a1:02:50:b9:31:68
+-----BEGIN CERTIFICATE-----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=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
+# Subject: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
+# Label: "emSign Root CA - G1"
+# Serial: 235931866688319308814040
+# MD5 Fingerprint: 9c:42:84:57:dd:cb:0b:a7:2e:95:ad:b6:f3:da:bc:ac
+# SHA1 Fingerprint: 8a:c7:ad:8f:73:ac:4e:c1:b5:75:4d:a5:40:f4:fc:cf:7c:b5:8e:8c
+# SHA256 Fingerprint: 40:f6:af:03:46:a9:9a:a1:cd:1d:55:5a:4e:9c:ce:62:c7:f9:63:46:03:ee:40:66:15:83:3d:c8:c8:d0:03:67
+-----BEGIN CERTIFICATE-----
+MIIDlDCCAnygAwIBAgIKMfXkYgxsWO3W2DANBgkqhkiG9w0BAQsFADBnMQswCQYD
+VQQGEwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBU
+ZWNobm9sb2dpZXMgTGltaXRlZDEcMBoGA1UEAxMTZW1TaWduIFJvb3QgQ0EgLSBH
+MTAeFw0xODAyMTgxODMwMDBaFw00MzAyMTgxODMwMDBaMGcxCzAJBgNVBAYTAklO
+MRMwEQYDVQQLEwplbVNpZ24gUEtJMSUwIwYDVQQKExxlTXVkaHJhIFRlY2hub2xv
+Z2llcyBMaW1pdGVkMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEcxMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAk0u76WaK7p1b1TST0Bsew+eeuGQz
+f2N4aLTNLnF115sgxk0pvLZoYIr3IZpWNVrzdr3YzZr/k1ZLpVkGoZM0Kd0WNHVO
+8oG0x5ZOrRkVUkr+PHB1cM2vK6sVmjM8qrOLqs1D/fXqcP/tzxE7lM5OMhbTI0Aq
+d7OvPAEsbO2ZLIvZTmmYsvePQbAyeGHWDV/D+qJAkh1cF+ZwPjXnorfCYuKrpDhM
+tTk1b+oDafo6VGiFbdbyL0NVHpENDtjVaqSW0RM8LHhQ6DqS0hdW5TUaQBw+jSzt
+Od9C4INBdN+jzcKGYEho42kLVACL5HZpIQ15TjQIXhTCzLG3rdd8cIrHhQIDAQAB
+o0IwQDAdBgNVHQ4EFgQU++8Nhp6w492pufEhF38+/PB3KxowDgYDVR0PAQH/BAQD
+AgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAFn/8oz1h31x
+PaOfG1vR2vjTnGs2vZupYeveFix0PZ7mddrXuqe8QhfnPZHr5X3dPpzxz5KsbEjM
+wiI/aTvFthUvozXGaCocV685743QNcMYDHsAVhzNixl03r4PEuDQqqE/AjSxcM6d
+GNYIAwlG7mDgfrbESQRRfXBgvKqy/3lyeqYdPV8q+Mri/Tm3R7nrft8EI6/6nAYH
+6ftjk4BAtcZsCjEozgyfz7MjNYBBjWzEN3uBL4ChQEKF6dk4jeihU80Bv2noWgby
+RQuQ+q7hv53yrlc8pa6yVvSLZUDp/TGBLPQ5Cdjua6e0ph0VpZj3AYHYhX3zUVxx
+iN66zB+Afko=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
+# Subject: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
+# Label: "emSign ECC Root CA - G3"
+# Serial: 287880440101571086945156
+# MD5 Fingerprint: ce:0b:72:d1:9f:88:8e:d0:50:03:e8:e3:b8:8b:67:40
+# SHA1 Fingerprint: 30:43:fa:4f:f2:57:dc:a0:c3:80:ee:2e:58:ea:78:b2:3f:e6:bb:c1
+# SHA256 Fingerprint: 86:a1:ec:ba:08:9c:4a:8d:3b:be:27:34:c6:12:ba:34:1d:81:3e:04:3c:f9:e8:a8:62:cd:5c:57:a3:6b:be:6b
+-----BEGIN CERTIFICATE-----
+MIICTjCCAdOgAwIBAgIKPPYHqWhwDtqLhDAKBggqhkjOPQQDAzBrMQswCQYDVQQG
+EwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNo
+bm9sb2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0g
+RzMwHhcNMTgwMjE4MTgzMDAwWhcNNDMwMjE4MTgzMDAwWjBrMQswCQYDVQQGEwJJ
+TjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNobm9s
+b2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0gRzMw
+djAQBgcqhkjOPQIBBgUrgQQAIgNiAAQjpQy4LRL1KPOxst3iAhKAnjlfSU2fySU0
+WXTsuwYc58Byr+iuL+FBVIcUqEqy6HyC5ltqtdyzdc6LBtCGI79G1Y4PPwT01xyS
+fvalY8L1X44uT6EYGQIrMgqCZH0Wk9GjQjBAMB0GA1UdDgQWBBR8XQKEE9TMipuB
+zhccLikenEhjQjAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAKBggq
+hkjOPQQDAwNpADBmAjEAvvNhzwIQHWSVB7gYboiFBS+DCBeQyh+KTOgNG3qxrdWB
+CUfvO6wIBHxcmbHtRwfSAjEAnbpV/KlK6O3t5nYBQnvI+GDZjVGLVTv7jHvrZQnD
++JbNR6iC8hZVdyR+EhCVBCyj
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
+# Subject: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
+# Label: "emSign Root CA - C1"
+# Serial: 825510296613316004955058
+# MD5 Fingerprint: d8:e3:5d:01:21:fa:78:5a:b0:df:ba:d2:ee:2a:5f:68
+# SHA1 Fingerprint: e7:2e:f1:df:fc:b2:09:28:cf:5d:d4:d5:67:37:b1:51:cb:86:4f:01
+# SHA256 Fingerprint: 12:56:09:aa:30:1d:a0:a2:49:b9:7a:82:39:cb:6a:34:21:6f:44:dc:ac:9f:39:54:b1:42:92:f2:e8:c8:60:8f
+-----BEGIN CERTIFICATE-----
+MIIDczCCAlugAwIBAgILAK7PALrEzzL4Q7IwDQYJKoZIhvcNAQELBQAwVjELMAkG
+A1UEBhMCVVMxEzARBgNVBAsTCmVtU2lnbiBQS0kxFDASBgNVBAoTC2VNdWRocmEg
+SW5jMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEMxMB4XDTE4MDIxODE4MzAw
+MFoXDTQzMDIxODE4MzAwMFowVjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
+biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMRwwGgYDVQQDExNlbVNpZ24gUm9v
+dCBDQSAtIEMxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz+upufGZ
+BczYKCFK83M0UYRWEPWgTywS4/oTmifQz/l5GnRfHXk5/Fv4cI7gklL35CX5VIPZ
+HdPIWoU/Xse2B+4+wM6ar6xWQio5JXDWv7V7Nq2s9nPczdcdioOl+yuQFTdrHCZH
+3DspVpNqs8FqOp099cGXOFgFixwR4+S0uF2FHYP+eF8LRWgYSKVGczQ7/g/IdrvH
+GPMF0Ybzhe3nudkyrVWIzqa2kbBPrH4VI5b2P/AgNBbeCsbEBEV5f6f9vtKppa+c
+xSMq9zwhbL2vj07FOrLzNBL834AaSaTUqZX3noleoomslMuoaJuvimUnzYnu3Yy1
+aylwQ6BpC+S5DwIDAQABo0IwQDAdBgNVHQ4EFgQU/qHgcB4qAzlSWkK+XJGFehiq
+TbUwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
+BQADggEBAMJKVvoVIXsoounlHfv4LcQ5lkFMOycsxGwYFYDGrK9HWS8mC+M2sO87
+/kOXSTKZEhVb3xEp/6tT+LvBeA+snFOvV71ojD1pM/CjoCNjO2RnIkSt1XHLVip4
+kqNPEjE2NuLe/gDEo2APJ62gsIq1NnpSob0n9CAnYuhNlCQT5AoE6TyrLshDCUrG
+YQTlSTR+08TI9Q/Aqum6VF7zYytPT1DU/rl7mYw9wC68AivTxEDkigcxHpvOJpkT
++xHqmiIMERnHXhuBUDDIlhJu58tBf5E7oke3VIAb3ADMmpDqw8NQBmIMMMAVSKeo
+WXzhriKi4gp6D/piq1JM4fHfyr6DDUI=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
+# Subject: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
+# Label: "emSign ECC Root CA - C3"
+# Serial: 582948710642506000014504
+# MD5 Fingerprint: 3e:53:b3:a3:81:ee:d7:10:f8:d3:b0:1d:17:92:f5:d5
+# SHA1 Fingerprint: b6:af:43:c2:9b:81:53:7d:f6:ef:6b:c3:1f:1f:60:15:0c:ee:48:66
+# SHA256 Fingerprint: bc:4d:80:9b:15:18:9d:78:db:3e:1d:8c:f4:f9:72:6a:79:5d:a1:64:3c:a5:f1:35:8e:1d:db:0e:dc:0d:7e:b3
+-----BEGIN CERTIFICATE-----
+MIICKzCCAbGgAwIBAgIKe3G2gla4EnycqDAKBggqhkjOPQQDAzBaMQswCQYDVQQG
+EwJVUzETMBEGA1UECxMKZW1TaWduIFBLSTEUMBIGA1UEChMLZU11ZGhyYSBJbmMx
+IDAeBgNVBAMTF2VtU2lnbiBFQ0MgUm9vdCBDQSAtIEMzMB4XDTE4MDIxODE4MzAw
+MFoXDTQzMDIxODE4MzAwMFowWjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
+biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMSAwHgYDVQQDExdlbVNpZ24gRUND
+IFJvb3QgQ0EgLSBDMzB2MBAGByqGSM49AgEGBSuBBAAiA2IABP2lYa57JhAd6bci
+MK4G9IGzsUJxlTm801Ljr6/58pc1kjZGDoeVjbk5Wum739D+yAdBPLtVb4Ojavti
+sIGJAnB9SMVK4+kiVCJNk7tCDK93nCOmfddhEc5lx/h//vXyqaNCMEAwHQYDVR0O
+BBYEFPtaSNCAIEDyqOkAB2kZd6fmw/TPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMB
+Af8EBTADAQH/MAoGCCqGSM49BAMDA2gAMGUCMQC02C8Cif22TGK6Q04ThHK1rt0c
+3ta13FaPWEBaLd4gTCKDypOofu4SQMfWh0/434UCMBwUZOR8loMRnLDRWmFLpg9J
+0wD8ofzkpf9/rdcw0Md3f76BB1UwUCAU9Vc4CqgxUQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Hongkong Post Root CA 3 O=Hongkong Post
+# Subject: CN=Hongkong Post Root CA 3 O=Hongkong Post
+# Label: "Hongkong Post Root CA 3"
+# Serial: 46170865288971385588281144162979347873371282084
+# MD5 Fingerprint: 11:fc:9f:bd:73:30:02:8a:fd:3f:f3:58:b9:cb:20:f0
+# SHA1 Fingerprint: 58:a2:d0:ec:20:52:81:5b:c1:f3:f8:64:02:24:4e:c2:8e:02:4b:02
+# SHA256 Fingerprint: 5a:2f:c0:3f:0c:83:b0:90:bb:fa:40:60:4b:09:88:44:6c:76:36:18:3d:f9:84:6e:17:10:1a:44:7f:b8:ef:d6
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - G4"
+# Serial: 289383649854506086828220374796556676440
+# MD5 Fingerprint: 89:53:f1:83:23:b7:7c:8e:05:f1:8c:71:38:4e:1f:88
+# SHA1 Fingerprint: 14:88:4e:86:26:37:b0:26:af:59:62:5c:40:77:ec:35:29:ba:96:01
+# SHA256 Fingerprint: db:35:17:d1:f6:73:2a:2d:5a:b9:7c:53:3e:c7:07:79:ee:32:70:a6:2f:b4:ac:42:38:37:24:60:e6:f0:1e:88
+-----BEGIN CERTIFICATE-----
+MIIGSzCCBDOgAwIBAgIRANm1Q3+vqTkPAAAAAFVlrVgwDQYJKoZIhvcNAQELBQAw
+gb4xCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQL
+Ex9TZWUgd3d3LmVudHJ1c3QubmV0L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykg
+MjAxNSBFbnRydXN0LCBJbmMuIC0gZm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMjAw
+BgNVBAMTKUVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEc0
+MB4XDTE1MDUyNzExMTExNloXDTM3MTIyNzExNDExNlowgb4xCzAJBgNVBAYTAlVT
+MRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1
+c3QubmV0L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxNSBFbnRydXN0LCBJ
+bmMuIC0gZm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMjAwBgNVBAMTKUVudHJ1c3Qg
+Um9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEc0MIICIjANBgkqhkiG9w0B
+AQEFAAOCAg8AMIICCgKCAgEAsewsQu7i0TD/pZJH4i3DumSXbcr3DbVZwbPLqGgZ
+2K+EbTBwXX7zLtJTmeH+H17ZSK9dE43b/2MzTdMAArzE+NEGCJR5WIoV3imz/f3E
+T+iq4qA7ec2/a0My3dl0ELn39GjUu9CH1apLiipvKgS1sqbHoHrmSKvS0VnM1n4j
+5pds8ELl3FFLFUHtSUrJ3hCX1nbB76W1NhSXNdh4IjVS70O92yfbYVaCNNzLiGAM
+C1rlLAHGVK/XqsEQe9IFWrhAnoanw5CGAlZSCXqc0ieCU0plUmr1POeo8pyvi73T
+DtTUXm6Hnmo9RR3RXRv06QqsYJn7ibT/mCzPfB3pAqoEmh643IhuJbNsZvc8kPNX
+wbMv9W3y+8qh+CmdRouzavbmZwe+LGcKKh9asj5XxNMhIWNlUpEbsZmOeX7m640A
+2Vqq6nPopIICR5b+W45UYaPrL0swsIsjdXJ8ITzI9vF01Bx7owVV7rtNOzK+mndm
+nqxpkCIHH2E6lr7lmk/MBTwoWdPBDFSoWWG9yHJM6Nyfh3+9nEg2XpWjDrk4JFX8
+dWbrAuMINClKxuMrLzOg2qOGpRKX/YAr2hRC45K9PvJdXmd0LhyIRyk0X+IyqJwl
+N4y6mACXi0mWHv0liqzc2thddG5msP9E36EYxr5ILzeUePiVSj9/E15dWf10hkNj
+c0kCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD
+VR0OBBYEFJ84xFYjwznooHFs6FRM5Og6sb9nMA0GCSqGSIb3DQEBCwUAA4ICAQAS
+5UKme4sPDORGpbZgQIeMJX6tuGguW8ZAdjwD+MlZ9POrYs4QjbRaZIxowLByQzTS
+Gwv2LFPSypBLhmb8qoMi9IsabyZIrHZ3CL/FmFz0Jomee8O5ZDIBf9PD3Vht7LGr
+hFV0d4QEJ1JrhkzO3bll/9bGXp+aEJlLdWr+aumXIOTkdnrG0CSqkM0gkLpHZPt/
+B7NTeLUKYvJzQ85BK4FqLoUWlFPUa19yIqtRLULVAJyZv967lDtX/Zr1hstWO1uI
+AeV8KEsD+UmDfLJ/fOPtjqF/YFOOVZ1QNBIPt5d7bIdKROf1beyAN/BYGW5KaHbw
+H5Lk6rWS02FREAutp9lfx1/cH6NcjKF+m7ee01ZvZl4HliDtC3T7Zk6LERXpgUl+
+b7DUUH8i119lAg2m9IUe2K4GS0qn0jFmwvjO5QimpAKWRGhXxNUzzxkvFMSUHHuk
+2fCfDrGA4tGeEWSpiBE6doLlYsKA2KSD7ZPvfC+QsDJMlhVoSFLUmQjAJOgc47Ol
+IQ6SwJAfzyBfyjs4x7dtOvPmRLgOMWuIjnDrnBdSqEGULoe256YSxXXfW8AKbnuk
+5F6G+TaU33fD6Q3AOfF5u0aOq0NZJ7cguyPpVkAh7DE9ZapD8j3fcEThuk0mEDuY
+n/PIjhs4ViFqUZPTkcpG2om3PVODLAgfi49T3f+sHw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
+# Subject: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
+# Label: "Microsoft ECC Root Certificate Authority 2017"
+# Serial: 136839042543790627607696632466672567020
+# MD5 Fingerprint: dd:a1:03:e6:4a:93:10:d1:bf:f0:19:42:cb:fe:ed:67
+# SHA1 Fingerprint: 99:9a:64:c3:7f:f4:7d:9f:ab:95:f1:47:69:89:14:60:ee:c4:c3:c5
+# SHA256 Fingerprint: 35:8d:f3:9d:76:4a:f9:e1:b7:66:e9:c9:72:df:35:2e:e1:5c:fa:c2:27:af:6a:d1:d7:0e:8e:4a:6e:dc:ba:02
+-----BEGIN CERTIFICATE-----
+MIICWTCCAd+gAwIBAgIQZvI9r4fei7FK6gxXMQHC7DAKBggqhkjOPQQDAzBlMQsw
+CQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYD
+VQQDEy1NaWNyb3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIw
+MTcwHhcNMTkxMjE4MjMwNjQ1WhcNNDIwNzE4MjMxNjA0WjBlMQswCQYDVQQGEwJV
+UzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1NaWNy
+b3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwdjAQBgcq
+hkjOPQIBBgUrgQQAIgNiAATUvD0CQnVBEyPNgASGAlEvaqiBYgtlzPbKnR5vSmZR
+ogPZnZH6thaxjG7efM3beaYvzrvOcS/lpaso7GMEZpn4+vKTEAXhgShC48Zo9OYb
+hGBKia/teQ87zvH2RPUBeMCjVDBSMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBTIy5lycFIM+Oa+sgRXKSrPQhDtNTAQBgkrBgEEAYI3
+FQEEAwIBADAKBggqhkjOPQQDAwNoADBlAjBY8k3qDPlfXu5gKcs68tvWMoQZP3zV
+L8KxzJOuULsJMsbG7X7JNpQS5GiFBqIb0C8CMQCZ6Ra0DvpWSNSkMBaReNtUjGUB
+iudQZsIxtzm6uBoiB078a1QWIP8rtedMDE2mT3M=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
+# Subject: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
+# Label: "Microsoft RSA Root Certificate Authority 2017"
+# Serial: 40975477897264996090493496164228220339
+# MD5 Fingerprint: 10:ff:00:ff:cf:c9:f8:c7:7a:c0:ee:35:8e:c9:0f:47
+# SHA1 Fingerprint: 73:a5:e6:4a:3b:ff:83:16:ff:0e:dc:cc:61:8a:90:6e:4e:ae:4d:74
+# SHA256 Fingerprint: c7:41:f7:0f:4b:2a:8d:88:bf:2e:71:c1:41:22:ef:53:ef:10:eb:a0:cf:a5:e6:4c:fa:20:f4:18:85:30:73:e0
+-----BEGIN CERTIFICATE-----
+MIIFqDCCA5CgAwIBAgIQHtOXCV/YtLNHcB6qvn9FszANBgkqhkiG9w0BAQwFADBl
+MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYw
+NAYDVQQDEy1NaWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5
+IDIwMTcwHhcNMTkxMjE4MjI1MTIyWhcNNDIwNzE4MjMwMDIzWjBlMQswCQYDVQQG
+EwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1N
+aWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKW76UM4wplZEWCpW9R2LBifOZ
+Nt9GkMml7Xhqb0eRaPgnZ1AzHaGm++DlQ6OEAlcBXZxIQIJTELy/xztokLaCLeX0
+ZdDMbRnMlfl7rEqUrQ7eS0MdhweSE5CAg2Q1OQT85elss7YfUJQ4ZVBcF0a5toW1
+HLUX6NZFndiyJrDKxHBKrmCk3bPZ7Pw71VdyvD/IybLeS2v4I2wDwAW9lcfNcztm
+gGTjGqwu+UcF8ga2m3P1eDNbx6H7JyqhtJqRjJHTOoI+dkC0zVJhUXAoP8XFWvLJ
+jEm7FFtNyP9nTUwSlq31/niol4fX/V4ggNyhSyL71Imtus5Hl0dVe49FyGcohJUc
+aDDv70ngNXtk55iwlNpNhTs+VcQor1fznhPbRiefHqJeRIOkpcrVE7NLP8TjwuaG
+YaRSMLl6IE9vDzhTyzMMEyuP1pq9KsgtsRx9S1HKR9FIJ3Jdh+vVReZIZZ2vUpC6
+W6IYZVcSn2i51BVrlMRpIpj0M+Dt+VGOQVDJNE92kKz8OMHY4Xu54+OU4UZpyw4K
+UGsTuqwPN1q3ErWQgR5WrlcihtnJ0tHXUeOrO8ZV/R4O03QK0dqq6mm4lyiPSMQH
++FJDOvTKVTUssKZqwJz58oHhEmrARdlns87/I6KJClTUFLkqqNfs+avNJVgyeY+Q
+W5g5xAgGwax/Dj0ApQIDAQABo1QwUjAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/
+BAUwAwEB/zAdBgNVHQ4EFgQUCctZf4aycI8awznjwNnpv7tNsiMwEAYJKwYBBAGC
+NxUBBAMCAQAwDQYJKoZIhvcNAQEMBQADggIBAKyvPl3CEZaJjqPnktaXFbgToqZC
+LgLNFgVZJ8og6Lq46BrsTaiXVq5lQ7GPAJtSzVXNUzltYkyLDVt8LkS/gxCP81OC
+gMNPOsduET/m4xaRhPtthH80dK2Jp86519efhGSSvpWhrQlTM93uCupKUY5vVau6
+tZRGrox/2KJQJWVggEbbMwSubLWYdFQl3JPk+ONVFT24bcMKpBLBaYVu32TxU5nh
+SnUgnZUP5NbcA/FZGOhHibJXWpS2qdgXKxdJ5XbLwVaZOjex/2kskZGT4d9Mozd2
+TaGf+G0eHdP67Pv0RR0Tbc/3WeUiJ3IrhvNXuzDtJE3cfVa7o7P4NHmJweDyAmH3
+pvwPuxwXC65B2Xy9J6P9LjrRk5Sxcx0ki69bIImtt2dmefU6xqaWM/5TkshGsRGR
+xpl/j8nWZjEgQRCHLQzWwa80mMpkg/sTV9HB8Dx6jKXB/ZUhoHHBk2dxEuqPiApp
+GWSZI1b7rCoucL5mxAyE7+WL85MB+GqQk2dLsmijtWKP6T+MejteD+eMuMZ87zf9
+dOLITzNy4ZQ5bb0Sr74MTnB8G2+NszKTc0QWbej09+CVgI+WXTik9KveCjCHk9hN
+AHFiRSdLOkKEW39lt2c0Ui2cFmuqqNh7o0JMcccMyj6D5KbvtwEwXlGjefVwaaZB
+RA+GsCyRxj3qrg+E
+-----END CERTIFICATE-----
+
+# Issuer: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
+# Subject: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
+# Label: "e-Szigno Root CA 2017"
+# Serial: 411379200276854331539784714
+# MD5 Fingerprint: de:1f:f6:9e:84:ae:a7:b4:21:ce:1e:58:7d:d1:84:98
+# SHA1 Fingerprint: 89:d4:83:03:4f:9e:9a:48:80:5f:72:37:d4:a9:a6:ef:cb:7c:1f:d1
+# SHA256 Fingerprint: be:b0:0b:30:83:9b:9b:c3:2c:32:e4:44:79:05:95:06:41:f2:64:21:b1:5e:d0:89:19:8b:51:8a:e2:ea:1b:99
+-----BEGIN CERTIFICATE-----
+MIICQDCCAeWgAwIBAgIMAVRI7yH9l1kN9QQKMAoGCCqGSM49BAMCMHExCzAJBgNV
+BAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRk
+LjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25vIFJv
+b3QgQ0EgMjAxNzAeFw0xNzA4MjIxMjA3MDZaFw00MjA4MjIxMjA3MDZaMHExCzAJ
+BgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMg
+THRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25v
+IFJvb3QgQ0EgMjAxNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJbcPYrYsHtv
+xie+RJCxs1YVe45DJH0ahFnuY2iyxl6H0BVIHqiQrb1TotreOpCmYF9oMrWGQd+H
+Wyx7xf58etqjYzBhMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G
+A1UdDgQWBBSHERUI0arBeAyxr87GyZDvvzAEwDAfBgNVHSMEGDAWgBSHERUI0arB
+eAyxr87GyZDvvzAEwDAKBggqhkjOPQQDAgNJADBGAiEAtVfd14pVCzbhhkT61Nlo
+jbjcI4qKDdQvfepz7L9NbKgCIQDLpbQS+ue16M9+k/zzNY9vTlp8tLxOsvxyqltZ
++efcMQ==
+-----END CERTIFICATE-----
+
+# Issuer: O=CERTSIGN SA OU=certSIGN ROOT CA G2
+# Subject: O=CERTSIGN SA OU=certSIGN ROOT CA G2
+# Label: "certSIGN Root CA G2"
+# Serial: 313609486401300475190
+# MD5 Fingerprint: 8c:f1:75:8a:c6:19:cf:94:b7:f7:65:20:87:c3:97:c7
+# SHA1 Fingerprint: 26:f9:93:b4:ed:3d:28:27:b0:b9:4b:a7:e9:15:1d:a3:8d:92:e5:32
+# SHA256 Fingerprint: 65:7c:fe:2f:a7:3f:aa:38:46:25:71:f3:32:a2:36:3a:46:fc:e7:02:09:51:71:07:02:cd:fb:b6:ee:da:33:05
+-----BEGIN CERTIFICATE-----
+MIIFRzCCAy+gAwIBAgIJEQA0tk7GNi02MA0GCSqGSIb3DQEBCwUAMEExCzAJBgNV
+BAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJR04g
+Uk9PVCBDQSBHMjAeFw0xNzAyMDYwOTI3MzVaFw00MjAyMDYwOTI3MzVaMEExCzAJ
+BgNVBAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJ
+R04gUk9PVCBDQSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMDF
+dRmRfUR0dIf+DjuW3NgBFszuY5HnC2/OOwppGnzC46+CjobXXo9X69MhWf05N0Iw
+vlDqtg+piNguLWkh59E3GE59kdUWX2tbAMI5Qw02hVK5U2UPHULlj88F0+7cDBrZ
+uIt4ImfkabBoxTzkbFpG583H+u/E7Eu9aqSs/cwoUe+StCmrqzWaTOTECMYmzPhp
+n+Sc8CnTXPnGFiWeI8MgwT0PPzhAsP6CRDiqWhqKa2NYOLQV07YRaXseVO6MGiKs
+cpc/I1mbySKEwQdPzH/iV8oScLumZfNpdWO9lfsbl83kqK/20U6o2YpxJM02PbyW
+xPFsqa7lzw1uKA2wDrXKUXt4FMMgL3/7FFXhEZn91QqhngLjYl/rNUssuHLoPj1P
+rCy7Lobio3aP5ZMqz6WryFyNSwb/EkaseMsUBzXgqd+L6a8VTxaJW732jcZZroiF
+DsGJ6x9nxUWO/203Nit4ZoORUSs9/1F3dmKh7Gc+PoGD4FapUB8fepmrY7+EF3fx
+DTvf95xhszWYijqy7DwaNz9+j5LP2RIUZNoQAhVB/0/E6xyjyfqZ90bp4RjZsbgy
+LcsUDFDYg2WD7rlcz8sFWkz6GZdr1l0T08JcVLwyc6B49fFtHsufpaafItzRUZ6C
+eWRgKRM+o/1Pcmqr4tTluCRVLERLiohEnMqE0yo7AgMBAAGjQjBAMA8GA1UdEwEB
+/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSCIS1mxteg4BXrzkwJ
+d8RgnlRuAzANBgkqhkiG9w0BAQsFAAOCAgEAYN4auOfyYILVAzOBywaK8SJJ6ejq
+kX/GM15oGQOGO0MBzwdw5AgeZYWR5hEit/UCI46uuR59H35s5r0l1ZUa8gWmr4UC
+b6741jH/JclKyMeKqdmfS0mbEVeZkkMR3rYzpMzXjWR91M08KCy0mpbqTfXERMQl
+qiCA2ClV9+BB/AYm/7k29UMUA2Z44RGx2iBfRgB4ACGlHgAoYXhvqAEBj500mv/0
+OJD7uNGzcgbJceaBxXntC6Z58hMLnPddDnskk7RI24Zf3lCGeOdA5jGokHZwYa+c
+NywRtYK3qq4kNFtyDGkNzVmf9nGvnAvRCjj5BiKDUyUM/FHE5r7iOZULJK2v0ZXk
+ltd0ZGtxTgI8qoXzIKNDOXZbbFD+mpwUHmUUihW9o4JFWklWatKcsWMy5WHgUyIO
+pwpJ6st+H6jiYoD2EEVSmAYY3qXNL3+q1Ok+CHLsIwMCPKaq2LxndD0UF/tUSxfj
+03k9bWtJySgOLnRQvwzZRjoQhsmnP+mg7H/rpXdYaXHmgwo38oZJar55CJD2AhZk
+PuXaTH4MNMn5X7azKFGnpyuqSfqNZSlO42sTp5SjLVFteAxEy9/eCG/Oo2Sr05WE
+1LlSVHJ7liXMvGnjSG4N0MedJ5qq+BOS3R7fY581qRY27Iy4g/Q9iY/NtBde17MX
+QRBdJ3NghVdJIgc=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Trustwave Global Certification Authority O=Trustwave Holdings, Inc.
+# Subject: CN=Trustwave Global Certification Authority O=Trustwave Holdings, Inc.
+# Label: "Trustwave Global Certification Authority"
+# Serial: 1846098327275375458322922162
+# MD5 Fingerprint: f8:1c:18:2d:2f:ba:5f:6d:a1:6c:bc:c7:ab:91:c7:0e
+# SHA1 Fingerprint: 2f:8f:36:4f:e1:58:97:44:21:59:87:a5:2a:9a:d0:69:95:26:7f:b5
+# SHA256 Fingerprint: 97:55:20:15:f5:dd:fc:3c:87:88:c0:06:94:45:55:40:88:94:45:00:84:f1:00:86:70:86:bc:1a:2b:b5:8d:c8
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Trustwave Global ECC P256 Certification Authority O=Trustwave Holdings, Inc.
+# Subject: CN=Trustwave Global ECC P256 Certification Authority O=Trustwave Holdings, Inc.
+# Label: "Trustwave Global ECC P256 Certification Authority"
+# Serial: 4151900041497450638097112925
+# MD5 Fingerprint: 5b:44:e3:8d:5d:36:86:26:e8:0d:05:d2:59:a7:83:54
+# SHA1 Fingerprint: b4:90:82:dd:45:0c:be:8b:5b:b1:66:d3:e2:a4:08:26:cd:ed:42:cf
+# SHA256 Fingerprint: 94:5b:bc:82:5e:a5:54:f4:89:d1:fd:51:a7:3d:df:2e:a6:24:ac:70:19:a0:52:05:22:5c:22:a7:8c:cf:a8:b4
+-----BEGIN CERTIFICATE-----
+MIICYDCCAgegAwIBAgIMDWpfCD8oXD5Rld9dMAoGCCqGSM49BAMCMIGRMQswCQYD
+VQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAf
+BgNVBAoTGFRydXN0d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3
+YXZlIEdsb2JhbCBFQ0MgUDI1NiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0x
+NzA4MjMxOTM1MTBaFw00MjA4MjMxOTM1MTBaMIGRMQswCQYDVQQGEwJVUzERMA8G
+A1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAfBgNVBAoTGFRydXN0
+d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3YXZlIEdsb2JhbCBF
+Q0MgUDI1NiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTBZMBMGByqGSM49AgEGCCqG
+SM49AwEHA0IABH77bOYj43MyCMpg5lOcunSNGLB4kFKA3TjASh3RqMyTpJcGOMoN
+FWLGjgEqZZ2q3zSRLoHB5DOSMcT9CTqmP62jQzBBMA8GA1UdEwEB/wQFMAMBAf8w
+DwYDVR0PAQH/BAUDAwcGADAdBgNVHQ4EFgQUo0EGrJBt0UrrdaVKEJmzsaGLSvcw
+CgYIKoZIzj0EAwIDRwAwRAIgB+ZU2g6gWrKuEZ+Hxbb/ad4lvvigtwjzRM4q3wgh
+DDcCIC0mA6AFvWvR9lz4ZcyGbbOcNEhjhAnFjXca4syc4XR7
+-----END CERTIFICATE-----
+
+# Issuer: CN=Trustwave Global ECC P384 Certification Authority O=Trustwave Holdings, Inc.
+# Subject: CN=Trustwave Global ECC P384 Certification Authority O=Trustwave Holdings, Inc.
+# Label: "Trustwave Global ECC P384 Certification Authority"
+# Serial: 2704997926503831671788816187
+# MD5 Fingerprint: ea:cf:60:c4:3b:b9:15:29:40:a1:97:ed:78:27:93:d6
+# SHA1 Fingerprint: e7:f3:a3:c8:cf:6f:c3:04:2e:6d:0e:67:32:c5:9e:68:95:0d:5e:d2
+# SHA256 Fingerprint: 55:90:38:59:c8:c0:c3:eb:b8:75:9e:ce:4e:25:57:22:5f:f5:75:8b:bd:38:eb:d4:82:76:60:1e:1b:d5:80:97
+-----BEGIN CERTIFICATE-----
+MIICnTCCAiSgAwIBAgIMCL2Fl2yZJ6SAaEc7MAoGCCqGSM49BAMDMIGRMQswCQYD
+VQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAf
+BgNVBAoTGFRydXN0d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3
+YXZlIEdsb2JhbCBFQ0MgUDM4NCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0x
+NzA4MjMxOTM2NDNaFw00MjA4MjMxOTM2NDNaMIGRMQswCQYDVQQGEwJVUzERMA8G
+A1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAfBgNVBAoTGFRydXN0
+d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3YXZlIEdsb2JhbCBF
+Q0MgUDM4NCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABGvaDXU1CDFHBa5FmVXxERMuSvgQMSOjfoPTfygIOiYaOs+Xgh+AtycJ
+j9GOMMQKmw6sWASr9zZ9lCOkmwqKi6vr/TklZvFe/oyujUF5nQlgziip04pt89ZF
+1PKYhDhloKNDMEEwDwYDVR0TAQH/BAUwAwEB/zAPBgNVHQ8BAf8EBQMDBwYAMB0G
+A1UdDgQWBBRVqYSJ0sEyvRjLbKYHTsjnnb6CkDAKBggqhkjOPQQDAwNnADBkAjA3
+AZKXRRJ+oPM+rRk6ct30UJMDEr5E0k9BpIycnR+j9sKS50gU/k6bpZFXrsY3crsC
+MGclCrEMXu6pY5Jv5ZAL/mYiykf9ijH3g/56vxC+GCsej/YpHpRZ744hN8tRmKVu
+Sw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=NAVER Global Root Certification Authority O=NAVER BUSINESS PLATFORM Corp.
+# Subject: CN=NAVER Global Root Certification Authority O=NAVER BUSINESS PLATFORM Corp.
+# Label: "NAVER Global Root Certification Authority"
+# Serial: 9013692873798656336226253319739695165984492813
+# MD5 Fingerprint: c8:7e:41:f6:25:3b:f5:09:b3:17:e8:46:3d:bf:d0:9b
+# SHA1 Fingerprint: 8f:6b:f2:a9:27:4a:da:14:a0:c4:f4:8e:61:27:f9:c0:1e:78:5d:d1
+# SHA256 Fingerprint: 88:f4:38:dc:f8:ff:d1:fa:8f:42:91:15:ff:e5:f8:2a:e1:e0:6e:0c:70:c3:75:fa:ad:71:7b:34:a4:9e:72:65
+-----BEGIN CERTIFICATE-----
+MIIFojCCA4qgAwIBAgIUAZQwHqIL3fXFMyqxQ0Rx+NZQTQ0wDQYJKoZIhvcNAQEM
+BQAwaTELMAkGA1UEBhMCS1IxJjAkBgNVBAoMHU5BVkVSIEJVU0lORVNTIFBMQVRG
+T1JNIENvcnAuMTIwMAYDVQQDDClOQVZFUiBHbG9iYWwgUm9vdCBDZXJ0aWZpY2F0
+aW9uIEF1dGhvcml0eTAeFw0xNzA4MTgwODU4NDJaFw0zNzA4MTgyMzU5NTlaMGkx
+CzAJBgNVBAYTAktSMSYwJAYDVQQKDB1OQVZFUiBCVVNJTkVTUyBQTEFURk9STSBD
+b3JwLjEyMDAGA1UEAwwpTkFWRVIgR2xvYmFsIFJvb3QgQ2VydGlmaWNhdGlvbiBB
+dXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC21PGTXLVA
+iQqrDZBbUGOukJR0F0Vy1ntlWilLp1agS7gvQnXp2XskWjFlqxcX0TM62RHcQDaH
+38dq6SZeWYp34+hInDEW+j6RscrJo+KfziFTowI2MMtSAuXaMl3Dxeb57hHHi8lE
+HoSTGEq0n+USZGnQJoViAbbJAh2+g1G7XNr4rRVqmfeSVPc0W+m/6imBEtRTkZaz
+kVrd/pBzKPswRrXKCAfHcXLJZtM0l/aM9BhK4dA9WkW2aacp+yPOiNgSnABIqKYP
+szuSjXEOdMWLyEz59JuOuDxp7W87UC9Y7cSw0BwbagzivESq2M0UXZR4Yb8Obtoq
+vC8MC3GmsxY/nOb5zJ9TNeIDoKAYv7vxvvTWjIcNQvcGufFt7QSUqP620wbGQGHf
+nZ3zVHbOUzoBppJB7ASjjw2i1QnK1sua8e9DXcCrpUHPXFNwcMmIpi3Ua2FzUCaG
+YQ5fG8Ir4ozVu53BA0K6lNpfqbDKzE0K70dpAy8i+/Eozr9dUGWokG2zdLAIx6yo
+0es+nPxdGoMuK8u180SdOqcXYZaicdNwlhVNt0xz7hlcxVs+Qf6sdWA7G2POAN3a
+CJBitOUt7kinaxeZVL6HSuOpXgRM6xBtVNbv8ejyYhbLgGvtPe31HzClrkvJE+2K
+AQHJuFFYwGY6sWZLxNUxAmLpdIQM201GLQIDAQABo0IwQDAdBgNVHQ4EFgQU0p+I
+36HNLL3s9TsBAZMzJ7LrYEswDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMB
+Af8wDQYJKoZIhvcNAQEMBQADggIBADLKgLOdPVQG3dLSLvCkASELZ0jKbY7gyKoN
+qo0hV4/GPnrK21HUUrPUloSlWGB/5QuOH/XcChWB5Tu2tyIvCZwTFrFsDDUIbatj
+cu3cvuzHV+YwIHHW1xDBE1UBjCpD5EHxzzp6U5LOogMFDTjfArsQLtk70pt6wKGm
++LUx5vR1yblTmXVHIloUFcd4G7ad6Qz4G3bxhYTeodoS76TiEJd6eN4MUZeoIUCL
+hr0N8F5OSza7OyAfikJW4Qsav3vQIkMsRIz75Sq0bBwcupTgE34h5prCy8VCZLQe
+lHsIJchxzIdFV4XTnyliIoNRlwAYl3dqmJLJfGBs32x9SuRwTMKeuB330DTHD8z7
+p/8Dvq1wkNoL3chtl1+afwkyQf3NosxabUzyqkn+Zvjp2DXrDige7kgvOtB5CTh8
+piKCk5XQA76+AqAF3SAi428diDRgxuYKuQl1C/AH6GmWNcf7I4GOODm4RStDeKLR
+LBT/DShycpWbXgnbiUSYqqFJu3FS8r/2/yehNq+4tneI3TqkbZs0kNwUXTC/t+sX
+5Ie3cdCh13cV1ELX8vMxmV2b3RZtP+oGI/hGoiLtk/bdmuYqh7GYVPEi92tF4+KO
+dh2ajcQGjTa3FPOdVGm3jjzVpG2Tgbet9r1ke8LJaDmgkpzNNIaRkPpkUZ3+/uul
+9XXeifdy
+-----END CERTIFICATE-----
+
+# Issuer: CN=AC RAIZ FNMT-RCM SERVIDORES SEGUROS O=FNMT-RCM OU=Ceres
+# Subject: CN=AC RAIZ FNMT-RCM SERVIDORES SEGUROS O=FNMT-RCM OU=Ceres
+# Label: "AC RAIZ FNMT-RCM SERVIDORES SEGUROS"
+# Serial: 131542671362353147877283741781055151509
+# MD5 Fingerprint: 19:36:9c:52:03:2f:d2:d1:bb:23:cc:dd:1e:12:55:bb
+# SHA1 Fingerprint: 62:ff:d9:9e:c0:65:0d:03:ce:75:93:d2:ed:3f:2d:32:c9:e3:e5:4a
+# SHA256 Fingerprint: 55:41:53:b1:3d:2c:f9:dd:b7:53:bf:be:1a:4e:0a:e0:8d:0a:a4:18:70:58:fe:60:a2:b8:62:b2:e4:b8:7b:cb
+-----BEGIN CERTIFICATE-----
+MIICbjCCAfOgAwIBAgIQYvYybOXE42hcG2LdnC6dlTAKBggqhkjOPQQDAzB4MQsw
+CQYDVQQGEwJFUzERMA8GA1UECgwIRk5NVC1SQ00xDjAMBgNVBAsMBUNlcmVzMRgw
+FgYDVQRhDA9WQVRFUy1RMjgyNjAwNEoxLDAqBgNVBAMMI0FDIFJBSVogRk5NVC1S
+Q00gU0VSVklET1JFUyBTRUdVUk9TMB4XDTE4MTIyMDA5MzczM1oXDTQzMTIyMDA5
+MzczM1oweDELMAkGA1UEBhMCRVMxETAPBgNVBAoMCEZOTVQtUkNNMQ4wDAYDVQQL
+DAVDZXJlczEYMBYGA1UEYQwPVkFURVMtUTI4MjYwMDRKMSwwKgYDVQQDDCNBQyBS
+QUlaIEZOTVQtUkNNIFNFUlZJRE9SRVMgU0VHVVJPUzB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABPa6V1PIyqvfNkpSIeSX0oNnnvBlUdBeh8dHsVnyV0ebAAKTRBdp20LH
+sbI6GA60XYyzZl2hNPk2LEnb80b8s0RpRBNm/dfF/a82Tc4DTQdxz69qBdKiQ1oK
+Um8BA06Oi6NCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD
+VR0OBBYEFAG5L++/EYZg8k/QQW6rcx/n0m5JMAoGCCqGSM49BAMDA2kAMGYCMQCu
+SuMrQMN0EfKVrRYj3k4MGuZdpSRea0R7/DjiT8ucRRcRTBQnJlU5dUoDzBOQn5IC
+MQD6SmxgiHPz7riYYqnOK8LZiqZwMR2vsJRM60/G49HzYqc8/5MuB1xJAWdpEgJy
+v+c=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign Root R46 O=GlobalSign nv-sa
+# Subject: CN=GlobalSign Root R46 O=GlobalSign nv-sa
+# Label: "GlobalSign Root R46"
+# Serial: 1552617688466950547958867513931858518042577
+# MD5 Fingerprint: c4:14:30:e4:fa:66:43:94:2a:6a:1b:24:5f:19:d0:ef
+# SHA1 Fingerprint: 53:a2:b0:4b:ca:6b:d6:45:e6:39:8a:8e:c4:0d:d2:bf:77:c3:a2:90
+# SHA256 Fingerprint: 4f:a3:12:6d:8d:3a:11:d1:c4:85:5a:4f:80:7c:ba:d6:cf:91:9d:3a:5a:88:b0:3b:ea:2c:63:72:d9:3c:40:c9
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgISEdK7udcjGJ5AXwqdLdDfJWfRMA0GCSqGSIb3DQEBDAUA
+MEYxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMRwwGgYD
+VQQDExNHbG9iYWxTaWduIFJvb3QgUjQ2MB4XDTE5MDMyMDAwMDAwMFoXDTQ2MDMy
+MDAwMDAwMFowRjELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYt
+c2ExHDAaBgNVBAMTE0dsb2JhbFNpZ24gUm9vdCBSNDYwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCsrHQy6LNl5brtQyYdpokNRbopiLKkHWPd08EsCVeJ
+OaFV6Wc0dwxu5FUdUiXSE2te4R2pt32JMl8Nnp8semNgQB+msLZ4j5lUlghYruQG
+vGIFAha/r6gjA7aUD7xubMLL1aa7DOn2wQL7Id5m3RerdELv8HQvJfTqa1VbkNud
+316HCkD7rRlr+/fKYIje2sGP1q7Vf9Q8g+7XFkyDRTNrJ9CG0Bwta/OrffGFqfUo
+0q3v84RLHIf8E6M6cqJaESvWJ3En7YEtbWaBkoe0G1h6zD8K+kZPTXhc+CtI4wSE
+y132tGqzZfxCnlEmIyDLPRT5ge1lFgBPGmSXZgjPjHvjK8Cd+RTyG/FWaha/LIWF
+zXg4mutCagI0GIMXTpRW+LaCtfOW3T3zvn8gdz57GSNrLNRyc0NXfeD412lPFzYE
++cCQYDdF3uYM2HSNrpyibXRdQr4G9dlkbgIQrImwTDsHTUB+JMWKmIJ5jqSngiCN
+I/onccnfxkF0oE32kRbcRoxfKWMxWXEM2G/CtjJ9++ZdU6Z+Ffy7dXxd7Pj2Fxzs
+x2sZy/N78CsHpdlseVR2bJ0cpm4O6XkMqCNqo98bMDGfsVR7/mrLZqrcZdCinkqa
+ByFrgY/bxFn63iLABJzjqls2k+g9vXqhnQt2sQvHnf3PmKgGwvgqo6GDoLclcqUC
+4wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQUA1yrc4GHqMywptWU4jaWSf8FmSwwDQYJKoZIhvcNAQEMBQADggIBAHx4
+7PYCLLtbfpIrXTncvtgdokIzTfnvpCo7RGkerNlFo048p9gkUbJUHJNOxO97k4Vg
+JuoJSOD1u8fpaNK7ajFxzHmuEajwmf3lH7wvqMxX63bEIaZHU1VNaL8FpO7XJqti
+2kM3S+LGteWygxk6x9PbTZ4IevPuzz5i+6zoYMzRx6Fcg0XERczzF2sUyQQCPtIk
+pnnpHs6i58FZFZ8d4kuaPp92CC1r2LpXFNqD6v6MVenQTqnMdzGxRBF6XLE+0xRF
+FRhiJBPSy03OXIPBNvIQtQ6IbbjhVp+J3pZmOUdkLG5NrmJ7v2B0GbhWrJKsFjLt
+rWhV/pi60zTe9Mlhww6G9kuEYO4Ne7UyWHmRVSyBQ7N0H3qqJZ4d16GLuc1CLgSk
+ZoNNiTW2bKg2SnkheCLQQrzRQDGQob4Ez8pn7fXwgNNgyYMqIgXQBztSvwyeqiv5
+u+YfjyW6hY0XHgL+XVAEV8/+LbzvXMAaq7afJMbfc2hIkCwU9D9SGuTSyxTDYWnP
+4vkYxboznxSjBF25cfe1lNj2M8FawTSLfJvdkzrnE6JwYZ+vj+vYxXX4M2bUdGc6
+N3ec592kD3ZDZopD8p/7DEJ4Y9HiD2971KE9dJeFt0g5QdYg/NA6s/rob8SKunE3
+vouXsXgxT7PntgMTzlSdriVZzH81Xwj3QEUxeCp6
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign Root E46 O=GlobalSign nv-sa
+# Subject: CN=GlobalSign Root E46 O=GlobalSign nv-sa
+# Label: "GlobalSign Root E46"
+# Serial: 1552617690338932563915843282459653771421763
+# MD5 Fingerprint: b5:b8:66:ed:de:08:83:e3:c9:e2:01:34:06:ac:51:6f
+# SHA1 Fingerprint: 39:b4:6c:d5:fe:80:06:eb:e2:2f:4a:bb:08:33:a0:af:db:b9:dd:84
+# SHA256 Fingerprint: cb:b9:c4:4d:84:b8:04:3e:10:50:ea:31:a6:9f:51:49:55:d7:bf:d2:e2:c6:b4:93:01:01:9a:d6:1d:9f:50:58
+-----BEGIN CERTIFICATE-----
+MIICCzCCAZGgAwIBAgISEdK7ujNu1LzmJGjFDYQdmOhDMAoGCCqGSM49BAMDMEYx
+CzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMRwwGgYDVQQD
+ExNHbG9iYWxTaWduIFJvb3QgRTQ2MB4XDTE5MDMyMDAwMDAwMFoXDTQ2MDMyMDAw
+MDAwMFowRjELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2Ex
+HDAaBgNVBAMTE0dsb2JhbFNpZ24gUm9vdCBFNDYwdjAQBgcqhkjOPQIBBgUrgQQA
+IgNiAAScDrHPt+ieUnd1NPqlRqetMhkytAepJ8qUuwzSChDH2omwlwxwEwkBjtjq
+R+q+soArzfwoDdusvKSGN+1wCAB16pMLey5SnCNoIwZD7JIvU4Tb+0cUB+hflGdd
+yXqBPCCjQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
+DgQWBBQxCpCPtsad0kRLgLWi5h+xEk8blTAKBggqhkjOPQQDAwNoADBlAjEA31SQ
+7Zvvi5QCkxeCmb6zniz2C5GMn0oUsfZkvLtoURMMA/cVi4RguYv/Uo7njLwcAjA8
++RHUjE7AwWHCFUyqqx0LMV87HOIAl0Qx5v5zli/altP+CAezNIm8BZ/3Hobui3A=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GLOBALTRUST 2020 O=e-commerce monitoring GmbH
+# Subject: CN=GLOBALTRUST 2020 O=e-commerce monitoring GmbH
+# Label: "GLOBALTRUST 2020"
+# Serial: 109160994242082918454945253
+# MD5 Fingerprint: 8a:c7:6f:cb:6d:e3:cc:a2:f1:7c:83:fa:0e:78:d7:e8
+# SHA1 Fingerprint: d0:67:c1:13:51:01:0c:aa:d0:c7:6a:65:37:31:16:26:4f:53:71:a2
+# SHA256 Fingerprint: 9a:29:6a:51:82:d1:d4:51:a2:e3:7f:43:9b:74:da:af:a2:67:52:33:29:f9:0f:9a:0d:20:07:c3:34:e2:3c:9a
+-----BEGIN CERTIFICATE-----
+MIIFgjCCA2qgAwIBAgILWku9WvtPilv6ZeUwDQYJKoZIhvcNAQELBQAwTTELMAkG
+A1UEBhMCQVQxIzAhBgNVBAoTGmUtY29tbWVyY2UgbW9uaXRvcmluZyBHbWJIMRkw
+FwYDVQQDExBHTE9CQUxUUlVTVCAyMDIwMB4XDTIwMDIxMDAwMDAwMFoXDTQwMDYx
+MDAwMDAwMFowTTELMAkGA1UEBhMCQVQxIzAhBgNVBAoTGmUtY29tbWVyY2UgbW9u
+aXRvcmluZyBHbWJIMRkwFwYDVQQDExBHTE9CQUxUUlVTVCAyMDIwMIICIjANBgkq
+hkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAri5WrRsc7/aVj6B3GyvTY4+ETUWiD59b
+RatZe1E0+eyLinjF3WuvvcTfk0Uev5E4C64OFudBc/jbu9G4UeDLgztzOG53ig9Z
+YybNpyrOVPu44sB8R85gfD+yc/LAGbaKkoc1DZAoouQVBGM+uq/ufF7MpotQsjj3
+QWPKzv9pj2gOlTblzLmMCcpL3TGQlsjMH/1WljTbjhzqLL6FLmPdqqmV0/0plRPw
+yJiT2S0WR5ARg6I6IqIoV6Lr/sCMKKCmfecqQjuCgGOlYx8ZzHyyZqjC0203b+J+
+BlHZRYQfEs4kUmSFC0iAToexIiIwquuuvuAC4EDosEKAA1GqtH6qRNdDYfOiaxaJ
+SaSjpCuKAsR49GiKweR6NrFvG5Ybd0mN1MkGco/PU+PcF4UgStyYJ9ORJitHHmkH
+r96i5OTUawuzXnzUJIBHKWk7buis/UDr2O1xcSvy6Fgd60GXIsUf1DnQJ4+H4xj0
+4KlGDfV0OoIu0G4skaMxXDtG6nsEEFZegB31pWXogvziB4xiRfUg3kZwhqG8k9Me
+dKZssCz3AwyIDMvUclOGvGBG85hqwvG/Q/lwIHfKN0F5VVJjjVsSn8VoxIidrPIw
+q7ejMZdnrY8XD2zHc+0klGvIg5rQmjdJBKuxFshsSUktq6HQjJLyQUp5ISXbY9e2
+nKd+Qmn7OmMCAwEAAaNjMGEwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
+AQYwHQYDVR0OBBYEFNwuH9FhN3nkq9XVsxJxaD1qaJwiMB8GA1UdIwQYMBaAFNwu
+H9FhN3nkq9XVsxJxaD1qaJwiMA0GCSqGSIb3DQEBCwUAA4ICAQCR8EICaEDuw2jA
+VC/f7GLDw56KoDEoqoOOpFaWEhCGVrqXctJUMHytGdUdaG/7FELYjQ7ztdGl4wJC
+XtzoRlgHNQIw4Lx0SsFDKv/bGtCwr2zD/cuz9X9tAy5ZVp0tLTWMstZDFyySCstd
+6IwPS3BD0IL/qMy/pJTAvoe9iuOTe8aPmxadJ2W8esVCgmxcB9CpwYhgROmYhRZf
++I/KARDOJcP5YBugxZfD0yyIMaK9MOzQ0MAS8cE54+X1+NZK3TTN+2/BT+MAi1bi
+kvcoskJ3ciNnxz8RFbLEAwW+uxF7Cr+obuf/WEPPm2eggAe2HcqtbepBEX4tdJP7
+wry+UUTF72glJ4DjyKDUEuzZpTcdN3y0kcra1LGWge9oXHYQSa9+pTeAsRxSvTOB
+TI/53WXZFM2KJVj04sWDpQmQ1GwUY7VA3+vA/MRYfg0UFodUJ25W5HCEuGwyEn6C
+MUO+1918oa2u1qsgEu8KwxCMSZY13At1XrFP1U80DhEgB3VDRemjEdqso5nCtnkn
+4rnvyOL2NSl6dPrFf4IFYqYK6miyeUcGbvJXqBUzxvd4Sj1Ce2t+/vdG6tHrju+I
+aFvowdlxfv1k7/9nR4hYJS8+hge9+6jlgqispdNpQ80xiEmEU5LAsTkbOYMBMMTy
+qfrQA71yN2BWHzZ8vTmR9W0Nv3vXkg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=ANF Secure Server Root CA O=ANF Autoridad de Certificacion OU=ANF CA Raiz
+# Subject: CN=ANF Secure Server Root CA O=ANF Autoridad de Certificacion OU=ANF CA Raiz
+# Label: "ANF Secure Server Root CA"
+# Serial: 996390341000653745
+# MD5 Fingerprint: 26:a6:44:5a:d9:af:4e:2f:b2:1d:b6:65:b0:4e:e8:96
+# SHA1 Fingerprint: 5b:6e:68:d0:cc:15:b6:a0:5f:1e:c1:5f:ae:02:fc:6b:2f:5d:6f:74
+# SHA256 Fingerprint: fb:8f:ec:75:91:69:b9:10:6b:1e:51:16:44:c6:18:c5:13:04:37:3f:6c:06:43:08:8d:8b:ef:fd:1b:99:75:99
+-----BEGIN CERTIFICATE-----
+MIIF7zCCA9egAwIBAgIIDdPjvGz5a7EwDQYJKoZIhvcNAQELBQAwgYQxEjAQBgNV
+BAUTCUc2MzI4NzUxMDELMAkGA1UEBhMCRVMxJzAlBgNVBAoTHkFORiBBdXRvcmlk
+YWQgZGUgQ2VydGlmaWNhY2lvbjEUMBIGA1UECxMLQU5GIENBIFJhaXoxIjAgBgNV
+BAMTGUFORiBTZWN1cmUgU2VydmVyIFJvb3QgQ0EwHhcNMTkwOTA0MTAwMDM4WhcN
+MzkwODMwMTAwMDM4WjCBhDESMBAGA1UEBRMJRzYzMjg3NTEwMQswCQYDVQQGEwJF
+UzEnMCUGA1UEChMeQU5GIEF1dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uMRQwEgYD
+VQQLEwtBTkYgQ0EgUmFpejEiMCAGA1UEAxMZQU5GIFNlY3VyZSBTZXJ2ZXIgUm9v
+dCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANvrayvmZFSVgpCj
+cqQZAZ2cC4Ffc0m6p6zzBE57lgvsEeBbphzOG9INgxwruJ4dfkUyYA8H6XdYfp9q
+yGFOtibBTI3/TO80sh9l2Ll49a2pcbnvT1gdpd50IJeh7WhM3pIXS7yr/2WanvtH
+2Vdy8wmhrnZEE26cLUQ5vPnHO6RYPUG9tMJJo8gN0pcvB2VSAKduyK9o7PQUlrZX
+H1bDOZ8rbeTzPvY1ZNoMHKGESy9LS+IsJJ1tk0DrtSOOMspvRdOoiXsezx76W0OL
+zc2oD2rKDF65nkeP8Nm2CgtYZRczuSPkdxl9y0oukntPLxB3sY0vaJxizOBQ+OyR
+p1RMVwnVdmPF6GUe7m1qzwmd+nxPrWAI/VaZDxUse6mAq4xhj0oHdkLePfTdsiQz
+W7i1o0TJrH93PB0j7IKppuLIBkwC/qxcmZkLLxCKpvR/1Yd0DVlJRfbwcVw5Kda/
+SiOL9V8BY9KHcyi1Swr1+KuCLH5zJTIdC2MKF4EA/7Z2Xue0sUDKIbvVgFHlSFJn
+LNJhiQcND85Cd8BEc5xEUKDbEAotlRyBr+Qc5RQe8TZBAQIvfXOn3kLMTOmJDVb3
+n5HUA8ZsyY/b2BzgQJhdZpmYgG4t/wHFzstGH6wCxkPmrqKEPMVOHj1tyRRM4y5B
+u8o5vzY8KhmqQYdOpc5LMnndkEl/AgMBAAGjYzBhMB8GA1UdIwQYMBaAFJxf0Gxj
+o1+TypOYCK2Mh6UsXME3MB0GA1UdDgQWBBScX9BsY6Nfk8qTmAitjIelLFzBNzAO
+BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOC
+AgEATh65isagmD9uw2nAalxJUqzLK114OMHVVISfk/CHGT0sZonrDUL8zPB1hT+L
+9IBdeeUXZ701guLyPI59WzbLWoAAKfLOKyzxj6ptBZNscsdW699QIyjlRRA96Gej
+rw5VD5AJYu9LWaL2U/HANeQvwSS9eS9OICI7/RogsKQOLHDtdD+4E5UGUcjohybK
+pFtqFiGS3XNgnhAY3jyB6ugYw3yJ8otQPr0R4hUDqDZ9MwFsSBXXiJCZBMXM5gf0
+vPSQ7RPi6ovDj6MzD8EpTBNO2hVWcXNyglD2mjN8orGoGjR0ZVzO0eurU+AagNjq
+OknkJjCb5RyKqKkVMoaZkgoQI1YS4PbOTOK7vtuNknMBZi9iPrJyJ0U27U1W45eZ
+/zo1PqVUSlJZS2Db7v54EX9K3BR5YLZrZAPbFYPhor72I5dQ8AkzNqdxliXzuUJ9
+2zg/LFis6ELhDtjTO0wugumDLmsx2d1Hhk9tl5EuT+IocTUW0fJz/iUrB0ckYyfI
++PbZa/wSMVYIwFNCr5zQM378BvAxRAMU8Vjq8moNqRGyg77FGr8H6lnco4g175x2
+MjxNBiLOFeXdntiP2t7SxDnlF4HPOEfrf4htWRvfn0IUrn7PqLBmZdo3r5+qPeoo
+tt7VMVgWglvquxl1AnMaykgaIZOQCo6ThKd9OyMYkomgjaw=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum EC-384 CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Subject: CN=Certum EC-384 CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Label: "Certum EC-384 CA"
+# Serial: 160250656287871593594747141429395092468
+# MD5 Fingerprint: b6:65:b3:96:60:97:12:a1:ec:4e:e1:3d:a3:c6:c9:f1
+# SHA1 Fingerprint: f3:3e:78:3c:ac:df:f4:a2:cc:ac:67:55:69:56:d7:e5:16:3c:e1:ed
+# SHA256 Fingerprint: 6b:32:80:85:62:53:18:aa:50:d1:73:c9:8d:8b:da:09:d5:7e:27:41:3d:11:4c:f7:87:a0:f5:d0:6c:03:0c:f6
+-----BEGIN CERTIFICATE-----
+MIICZTCCAeugAwIBAgIQeI8nXIESUiClBNAt3bpz9DAKBggqhkjOPQQDAzB0MQsw
+CQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEgU3lzdGVtcyBTLkEuMScw
+JQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxGTAXBgNVBAMT
+EENlcnR1bSBFQy0zODQgQ0EwHhcNMTgwMzI2MDcyNDU0WhcNNDMwMzI2MDcyNDU0
+WjB0MQswCQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEgU3lzdGVtcyBT
+LkEuMScwJQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxGTAX
+BgNVBAMTEENlcnR1bSBFQy0zODQgQ0EwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATE
+KI6rGFtqvm5kN2PkzeyrOvfMobgOgknXhimfoZTy42B4mIF4Bk3y7JoOV2CDn7Tm
+Fy8as10CW4kjPMIRBSqniBMY81CE1700LCeJVf/OTOffph8oxPBUw7l8t1Ot68Kj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI0GZnQkdjrzife81r1HfS+8
+EF9LMA4GA1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNoADBlAjADVS2m5hjEfO/J
+UG7BJw+ch69u1RsIGL2SKcHvlJF40jocVYli5RsJHrpka/F2tNQCMQC0QoSZ/6vn
+nvuRlydd3LBbMHHOXjgaatkl5+r3YZJW+OraNsKHZZYuciUvf9/DE8k=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum Trusted Root CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Subject: CN=Certum Trusted Root CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Label: "Certum Trusted Root CA"
+# Serial: 40870380103424195783807378461123655149
+# MD5 Fingerprint: 51:e1:c2:e7:fe:4c:84:af:59:0e:2f:f4:54:6f:ea:29
+# SHA1 Fingerprint: c8:83:44:c0:18:ae:9f:cc:f1:87:b7:8f:22:d1:c5:d7:45:84:ba:e5
+# SHA256 Fingerprint: fe:76:96:57:38:55:77:3e:37:a9:5e:7a:d4:d9:cc:96:c3:01:57:c1:5d:31:76:5b:a9:b1:57:04:e1:ae:78:fd
+-----BEGIN CERTIFICATE-----
+MIIFwDCCA6igAwIBAgIQHr9ZULjJgDdMBvfrVU+17TANBgkqhkiG9w0BAQ0FADB6
+MQswCQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEgU3lzdGVtcyBTLkEu
+MScwJQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxHzAdBgNV
+BAMTFkNlcnR1bSBUcnVzdGVkIFJvb3QgQ0EwHhcNMTgwMzE2MTIxMDEzWhcNNDMw
+MzE2MTIxMDEzWjB6MQswCQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEg
+U3lzdGVtcyBTLkEuMScwJQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRo
+b3JpdHkxHzAdBgNVBAMTFkNlcnR1bSBUcnVzdGVkIFJvb3QgQ0EwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQDRLY67tzbqbTeRn06TpwXkKQMlzhyC93yZ
+n0EGze2jusDbCSzBfN8pfktlL5On1AFrAygYo9idBcEq2EXxkd7fO9CAAozPOA/q
+p1x4EaTByIVcJdPTsuclzxFUl6s1wB52HO8AU5853BSlLCIls3Jy/I2z5T4IHhQq
+NwuIPMqw9MjCoa68wb4pZ1Xi/K1ZXP69VyywkI3C7Te2fJmItdUDmj0VDT06qKhF
+8JVOJVkdzZhpu9PMMsmN74H+rX2Ju7pgE8pllWeg8xn2A1bUatMn4qGtg/BKEiJ3
+HAVz4hlxQsDsdUaakFjgao4rpUYwBI4Zshfjvqm6f1bxJAPXsiEodg42MEx51UGa
+mqi4NboMOvJEGyCI98Ul1z3G4z5D3Yf+xOr1Uz5MZf87Sst4WmsXXw3Hw09Omiqi
+7VdNIuJGmj8PkTQkfVXjjJU30xrwCSss0smNtA0Aq2cpKNgB9RkEth2+dv5yXMSF
+ytKAQd8FqKPVhJBPC/PgP5sZ0jeJP/J7UhyM9uH3PAeXjA6iWYEMspA90+NZRu0P
+qafegGtaqge2Gcu8V/OXIXoMsSt0Puvap2ctTMSYnjYJdmZm/Bo/6khUHL4wvYBQ
+v3y1zgD2DGHZ5yQD4OMBgQ692IU0iL2yNqh7XAjlRICMb/gv1SHKHRzQ+8S1h9E6
+Tsd2tTVItQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSM+xx1
+vALTn04uSNn5YFSqxLNP+jAOBgNVHQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQENBQAD
+ggIBAEii1QALLtA/vBzVtVRJHlpr9OTy4EA34MwUe7nJ+jW1dReTagVphZzNTxl4
+WxmB82M+w85bj/UvXgF2Ez8sALnNllI5SW0ETsXpD4YN4fqzX4IS8TrOZgYkNCvo
+zMrnadyHncI013nR03e4qllY/p0m+jiGPp2Kh2RX5Rc64vmNueMzeMGQ2Ljdt4NR
+5MTMI9UGfOZR0800McD2RrsLrfw9EAUqO0qRJe6M1ISHgCq8CYyqOhNf6DR5UMEQ
+GfnTKB7U0VEwKbOukGfWHwpjscWpxkIxYxeU72nLL/qMFH3EQxiJ2fAyQOaA4kZf
+5ePBAFmo+eggvIksDkc0C+pXwlM2/KfUrzHN/gLldfq5Jwn58/U7yn2fqSLLiMmq
+0Uc9NneoWWRrJ8/vJ8HjJLWG965+Mk2weWjROeiQWMODvA8s1pfrzgzhIMfatz7D
+P78v3DSk+yshzWePS/Tj6tQ/50+6uaWTRRxmHyH6ZF5v4HaUMst19W7l9o/HuKTM
+qJZ9ZPskWkoDbGs4xugDQ5r3V7mzKWmTOPQD8rv7gmsHINFSH5pkAnuYZttcTVoP
+0ISVoDwUQwbKytu4QTbaakRnh6+v40URFWkIsr4WOZckbxJF0WddCajJFdr60qZf
+E2Efv4WstK2tBZQIgx51F9NxO5NQI1mg7TyRVJ12AMXDuDjb
+-----END CERTIFICATE-----
+
+# Issuer: CN=TunTrust Root CA O=Agence Nationale de Certification Electronique
+# Subject: CN=TunTrust Root CA O=Agence Nationale de Certification Electronique
+# Label: "TunTrust Root CA"
+# Serial: 108534058042236574382096126452369648152337120275
+# MD5 Fingerprint: 85:13:b9:90:5b:36:5c:b6:5e:b8:5a:f8:e0:31:57:b4
+# SHA1 Fingerprint: cf:e9:70:84:0f:e0:73:0f:9d:f6:0c:7f:2c:4b:ee:20:46:34:9c:bb
+# SHA256 Fingerprint: 2e:44:10:2a:b5:8c:b8:54:19:45:1c:8e:19:d9:ac:f3:66:2c:af:bc:61:4b:6a:53:96:0a:30:f7:d0:e2:eb:41
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=HARICA TLS RSA Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Subject: CN=HARICA TLS RSA Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Label: "HARICA TLS RSA Root CA 2021"
+# Serial: 76817823531813593706434026085292783742
+# MD5 Fingerprint: 65:47:9b:58:86:dd:2c:f0:fc:a2:84:1f:1e:96:c4:91
+# SHA1 Fingerprint: 02:2d:05:82:fa:88:ce:14:0c:06:79:de:7f:14:10:e9:45:d7:a5:6d
+# SHA256 Fingerprint: d9:5d:0e:8e:da:79:52:5b:f9:be:b1:1b:14:d2:10:0d:32:94:98:5f:0c:62:d9:fa:bd:9c:d9:99:ec:cb:7b:1d
+-----BEGIN CERTIFICATE-----
+MIIFpDCCA4ygAwIBAgIQOcqTHO9D88aOk8f0ZIk4fjANBgkqhkiG9w0BAQsFADBs
+MQswCQYDVQQGEwJHUjE3MDUGA1UECgwuSGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl
+c2VhcmNoIEluc3RpdHV0aW9ucyBDQTEkMCIGA1UEAwwbSEFSSUNBIFRMUyBSU0Eg
+Um9vdCBDQSAyMDIxMB4XDTIxMDIxOTEwNTUzOFoXDTQ1MDIxMzEwNTUzN1owbDEL
+MAkGA1UEBhMCR1IxNzA1BgNVBAoMLkhlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNl
+YXJjaCBJbnN0aXR1dGlvbnMgQ0ExJDAiBgNVBAMMG0hBUklDQSBUTFMgUlNBIFJv
+b3QgQ0EgMjAyMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAIvC569l
+mwVnlskNJLnQDmT8zuIkGCyEf3dRywQRNrhe7Wlxp57kJQmXZ8FHws+RFjZiPTgE
+4VGC/6zStGndLuwRo0Xua2s7TL+MjaQenRG56Tj5eg4MmOIjHdFOY9TnuEFE+2uv
+a9of08WRiFukiZLRgeaMOVig1mlDqa2YUlhu2wr7a89o+uOkXjpFc5gH6l8Cct4M
+pbOfrqkdtx2z/IpZ525yZa31MJQjB/OCFks1mJxTuy/K5FrZx40d/JiZ+yykgmvw
+Kh+OC19xXFyuQnspiYHLA6OZyoieC0AJQTPb5lh6/a6ZcMBaD9YThnEvdmn8kN3b
+LW7R8pv1GmuebxWMevBLKKAiOIAkbDakO/IwkfN4E8/BPzWr8R0RI7VDIp4BkrcY
+AuUR0YLbFQDMYTfBKnya4dC6s1BG7oKsnTH4+yPiAwBIcKMJJnkVU2DzOFytOOqB
+AGMUuTNe3QvboEUHGjMJ+E20pwKmafTCWQWIZYVWrkvL4N48fS0ayOn7H6NhStYq
+E613TBoYm5EPWNgGVMWX+Ko/IIqmhaZ39qb8HOLubpQzKoNQhArlT4b4UEV4AIHr
+W2jjJo3Me1xR9BQsQL4aYB16cmEdH2MtiKrOokWQCPxrvrNQKlr9qEgYRtaQQJKQ
+CoReaDH46+0N0x3GfZkYVVYnZS6NRcUk7M7jAgMBAAGjQjBAMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFApII6ZgpJIKM+qTW8VX6iVNvRLuMA4GA1UdDwEB/wQE
+AwIBhjANBgkqhkiG9w0BAQsFAAOCAgEAPpBIqm5iFSVmewzVjIuJndftTgfvnNAU
+X15QvWiWkKQUEapobQk1OUAJ2vQJLDSle1mESSmXdMgHHkdt8s4cUCbjnj1AUz/3
+f5Z2EMVGpdAgS1D0NTsY9FVqQRtHBmg8uwkIYtlfVUKqrFOFrJVWNlar5AWMxaja
+H6NpvVMPxP/cyuN+8kyIhkdGGvMA9YCRotxDQpSbIPDRzbLrLFPCU3hKTwSUQZqP
+JzLB5UkZv/HywouoCjkxKLR9YjYsTewfM7Z+d21+UPCfDtcRj88YxeMn/ibvBZ3P
+zzfF0HvaO7AWhAw6k9a+F9sPPg4ZeAnHqQJyIkv3N3a6dcSFA1pj1bF1BcK5vZSt
+jBWZp5N99sXzqnTPBIWUmAD04vnKJGW/4GKvyMX6ssmeVkjaef2WdhW+o45WxLM0
+/L5H9MG0qPzVMIho7suuyWPEdr6sOBjhXlzPrjoiUevRi7PzKzMHVIf6tLITe7pT
+BGIBnfHAT+7hOtSLIBD6Alfm78ELt5BGnBkpjNxvoEppaZS3JGWg/6w/zgH7IS79
+aPib8qXPMThcFarmlwDB31qlpzmq6YR/PFGoOtmUW4y/Twhx5duoXNTSpv4Ao8YW
+xw/ogM4cKGR0GQjTQuPOAF1/sdwTsOEFy9EgqoZ0njnnkf3/W9b3raYvAwtt41dU
+63ZTGI0RmLo=
+-----END CERTIFICATE-----
+
+# Issuer: CN=HARICA TLS ECC Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Subject: CN=HARICA TLS ECC Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Label: "HARICA TLS ECC Root CA 2021"
+# Serial: 137515985548005187474074462014555733966
+# MD5 Fingerprint: ae:f7:4c:e5:66:35:d1:b7:9b:8c:22:93:74:d3:4b:b0
+# SHA1 Fingerprint: bc:b0:c1:9d:e9:98:92:70:19:38:57:e9:8d:a7:b4:5d:6e:ee:01:48
+# SHA256 Fingerprint: 3f:99:cc:47:4a:cf:ce:4d:fe:d5:87:94:66:5e:47:8d:15:47:73:9f:2e:78:0f:1b:b4:ca:9b:13:30:97:d4:01
+-----BEGIN CERTIFICATE-----
+MIICVDCCAdugAwIBAgIQZ3SdjXfYO2rbIvT/WeK/zjAKBggqhkjOPQQDAzBsMQsw
+CQYDVQQGEwJHUjE3MDUGA1UECgwuSGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJlc2Vh
+cmNoIEluc3RpdHV0aW9ucyBDQTEkMCIGA1UEAwwbSEFSSUNBIFRMUyBFQ0MgUm9v
+dCBDQSAyMDIxMB4XDTIxMDIxOTExMDExMFoXDTQ1MDIxMzExMDEwOVowbDELMAkG
+A1UEBhMCR1IxNzA1BgNVBAoMLkhlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJj
+aCBJbnN0aXR1dGlvbnMgQ0ExJDAiBgNVBAMMG0hBUklDQSBUTFMgRUNDIFJvb3Qg
+Q0EgMjAyMTB2MBAGByqGSM49AgEGBSuBBAAiA2IABDgI/rGgltJ6rK9JOtDA4MM7
+KKrxcm1lAEeIhPyaJmuqS7psBAqIXhfyVYf8MLA04jRYVxqEU+kw2anylnTDUR9Y
+STHMmE5gEYd103KUkE+bECUqqHgtvpBBWJAVcqeht6NCMEAwDwYDVR0TAQH/BAUw
+AwEB/zAdBgNVHQ4EFgQUyRtTgRL+BNUW0aq8mm+3oJUZbsowDgYDVR0PAQH/BAQD
+AgGGMAoGCCqGSM49BAMDA2cAMGQCMBHervjcToiwqfAircJRQO9gcS3ujwLEXQNw
+SaSS6sUUiHCm0w2wqsosQJz76YJumgIwK0eaB8bRwoF8yguWGEEbo/QwCZ61IygN
+nxS2PFOiTAZpffpskcYqSUXm7LcT4Tps
+-----END CERTIFICATE-----
+
+# Issuer: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
+# Subject: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
+# Label: "Autoridad de Certificacion Firmaprofesional CIF A62634068"
+# Serial: 1977337328857672817
+# MD5 Fingerprint: 4e:6e:9b:54:4c:ca:b7:fa:48:e4:90:b1:15:4b:1c:a3
+# SHA1 Fingerprint: 0b:be:c2:27:22:49:cb:39:aa:db:35:5c:53:e3:8c:ae:78:ff:b6:fe
+# SHA256 Fingerprint: 57:de:05:83:ef:d2:b2:6e:03:61:da:99:da:9d:f4:64:8d:ef:7e:e8:44:1c:3b:72:8a:fa:9b:cd:e0:f9:b2:6a
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=vTrus ECC Root CA O=iTrusChina Co.,Ltd.
+# Subject: CN=vTrus ECC Root CA O=iTrusChina Co.,Ltd.
+# Label: "vTrus ECC Root CA"
+# Serial: 630369271402956006249506845124680065938238527194
+# MD5 Fingerprint: de:4b:c1:f5:52:8c:9b:43:e1:3e:8f:55:54:17:8d:85
+# SHA1 Fingerprint: f6:9c:db:b0:fc:f6:02:13:b6:52:32:a6:a3:91:3f:16:70:da:c3:e1
+# SHA256 Fingerprint: 30:fb:ba:2c:32:23:8e:2a:98:54:7a:f9:79:31:e5:50:42:8b:9b:3f:1c:8e:eb:66:33:dc:fa:86:c5:b2:7d:d3
+-----BEGIN CERTIFICATE-----
+MIICDzCCAZWgAwIBAgIUbmq8WapTvpg5Z6LSa6Q75m0c1towCgYIKoZIzj0EAwMw
+RzELMAkGA1UEBhMCQ04xHDAaBgNVBAoTE2lUcnVzQ2hpbmEgQ28uLEx0ZC4xGjAY
+BgNVBAMTEXZUcnVzIEVDQyBSb290IENBMB4XDTE4MDczMTA3MjY0NFoXDTQzMDcz
+MTA3MjY0NFowRzELMAkGA1UEBhMCQ04xHDAaBgNVBAoTE2lUcnVzQ2hpbmEgQ28u
+LEx0ZC4xGjAYBgNVBAMTEXZUcnVzIEVDQyBSb290IENBMHYwEAYHKoZIzj0CAQYF
+K4EEACIDYgAEZVBKrox5lkqqHAjDo6LN/llWQXf9JpRCux3NCNtzslt188+cToL0
+v/hhJoVs1oVbcnDS/dtitN9Ti72xRFhiQgnH+n9bEOf+QP3A2MMrMudwpremIFUd
+e4BdS49nTPEQo0IwQDAdBgNVHQ4EFgQUmDnNvtiyjPeyq+GtJK97fKHbH88wDwYD
+VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwCgYIKoZIzj0EAwMDaAAwZQIw
+V53dVvHH4+m4SVBrm2nDb+zDfSXkV5UTQJtS0zvzQBm8JsctBp61ezaf9SXUY2sA
+AjEA6dPGnlaaKsyh2j/IZivTWJwghfqrkYpwcBE4YGQLYgmRWAD5Tfs0aNoJrSEG
+GJTO
+-----END CERTIFICATE-----
+
+# Issuer: CN=vTrus Root CA O=iTrusChina Co.,Ltd.
+# Subject: CN=vTrus Root CA O=iTrusChina Co.,Ltd.
+# Label: "vTrus Root CA"
+# Serial: 387574501246983434957692974888460947164905180485
+# MD5 Fingerprint: b8:c9:37:df:fa:6b:31:84:64:c5:ea:11:6a:1b:75:fc
+# SHA1 Fingerprint: 84:1a:69:fb:f5:cd:1a:25:34:13:3d:e3:f8:fc:b8:99:d0:c9:14:b7
+# SHA256 Fingerprint: 8a:71:de:65:59:33:6f:42:6c:26:e5:38:80:d0:0d:88:a1:8d:a4:c6:a9:1f:0d:cb:61:94:e2:06:c5:c9:63:87
+-----BEGIN CERTIFICATE-----
+MIIFVjCCAz6gAwIBAgIUQ+NxE9izWRRdt86M/TX9b7wFjUUwDQYJKoZIhvcNAQEL
+BQAwQzELMAkGA1UEBhMCQ04xHDAaBgNVBAoTE2lUcnVzQ2hpbmEgQ28uLEx0ZC4x
+FjAUBgNVBAMTDXZUcnVzIFJvb3QgQ0EwHhcNMTgwNzMxMDcyNDA1WhcNNDMwNzMx
+MDcyNDA1WjBDMQswCQYDVQQGEwJDTjEcMBoGA1UEChMTaVRydXNDaGluYSBDby4s
+THRkLjEWMBQGA1UEAxMNdlRydXMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEBBQAD
+ggIPADCCAgoCggIBAL1VfGHTuB0EYgWgrmy3cLRB6ksDXhA/kFocizuwZotsSKYc
+IrrVQJLuM7IjWcmOvFjai57QGfIvWcaMY1q6n6MLsLOaXLoRuBLpDLvPbmyAhykU
+AyyNJJrIZIO1aqwTLDPxn9wsYTwaP3BVm60AUn/PBLn+NvqcwBauYv6WTEN+VRS+
+GrPSbcKvdmaVayqwlHeFXgQPYh1jdfdr58tbmnDsPmcF8P4HCIDPKNsFxhQnL4Z9
+8Cfe/+Z+M0jnCx5Y0ScrUw5XSmXX+6KAYPxMvDVTAWqXcoKv8R1w6Jz1717CbMdH
+flqUhSZNO7rrTOiwCcJlwp2dCZtOtZcFrPUGoPc2BX70kLJrxLT5ZOrpGgrIDajt
+J8nU57O5q4IikCc9Kuh8kO+8T/3iCiSn3mUkpF3qwHYw03dQ+A0Em5Q2AXPKBlim
+0zvc+gRGE1WKyURHuFE5Gi7oNOJ5y1lKCn+8pu8fA2dqWSslYpPZUxlmPCdiKYZN
+pGvu/9ROutW04o5IWgAZCfEF2c6Rsffr6TlP9m8EQ5pV9T4FFL2/s1m02I4zhKOQ
+UqqzApVg+QxMaPnu1RcN+HFXtSXkKe5lXa/R7jwXC1pDxaWG6iSe4gUH3DRCEpHW
+OXSuTEGC2/KmSNGzm/MzqvOmwMVO9fSddmPmAsYiS8GVP1BkLFTltvA8Kc9XAgMB
+AAGjQjBAMB0GA1UdDgQWBBRUYnBj8XWEQ1iO0RYgscasGrz2iTAPBgNVHRMBAf8E
+BTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAKbqSSaet
+8PFww+SX8J+pJdVrnjT+5hpk9jprUrIQeBqfTNqK2uwcN1LgQkv7bHbKJAs5EhWd
+nxEt/Hlk3ODg9d3gV8mlsnZwUKT+twpw1aA08XXXTUm6EdGz2OyC/+sOxL9kLX1j
+bhd47F18iMjrjld22VkE+rxSH0Ws8HqA7Oxvdq6R2xCOBNyS36D25q5J08FsEhvM
+Kar5CKXiNxTKsbhm7xqC5PD48acWabfbqWE8n/Uxy+QARsIvdLGx14HuqCaVvIiv
+TDUHKgLKeBRtRytAVunLKmChZwOgzoy8sHJnxDHO2zTlJQNgJXtxmOTAGytfdELS
+S8VZCAeHvsXDf+eW2eHcKJfWjwXj9ZtOyh1QRwVTsMo554WgicEFOwE30z9J4nfr
+I8iIZjs9OXYhRvHsXyO466JmdXTBQPfYaJqT4i2pLr0cox7IdMakLXogqzu4sEb9
+b91fUlV1YvCXoHzXOP0l382gmxDPi7g4Xl7FtKYCNqEeXxzP4padKar9mK5S4fNB
+UvupLnKWnyfjqnN9+BojZns7q2WwMgFLFT49ok8MKzWixtlnEjUwzXYuFrOZnk1P
+Ti07NEPhmg4NpGaXutIcSkwsKouLgU9xGqndXHt7CMUADTdA43x7VF8vhV929ven
+sBxXVsFy6K2ir40zSbofitzmdHxghm+Hl3s=
+-----END CERTIFICATE-----
+
+# Issuer: CN=ISRG Root X2 O=Internet Security Research Group
+# Subject: CN=ISRG Root X2 O=Internet Security Research Group
+# Label: "ISRG Root X2"
+# Serial: 87493402998870891108772069816698636114
+# MD5 Fingerprint: d3:9e:c4:1e:23:3c:a6:df:cf:a3:7e:6d:e0:14:e6:e5
+# SHA1 Fingerprint: bd:b1:b9:3c:d5:97:8d:45:c6:26:14:55:f8:db:95:c7:5a:d1:53:af
+# SHA256 Fingerprint: 69:72:9b:8e:15:a8:6e:fc:17:7a:57:af:b7:17:1d:fc:64:ad:d2:8c:2f:ca:8c:f1:50:7e:34:45:3c:cb:14:70
+-----BEGIN CERTIFICATE-----
+MIICGzCCAaGgAwIBAgIQQdKd0XLq7qeAwSxs6S+HUjAKBggqhkjOPQQDAzBPMQsw
+CQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJuZXQgU2VjdXJpdHkgUmVzZWFyY2gg
+R3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBYMjAeFw0yMDA5MDQwMDAwMDBaFw00
+MDA5MTcxNjAwMDBaME8xCzAJBgNVBAYTAlVTMSkwJwYDVQQKEyBJbnRlcm5ldCBT
+ZWN1cml0eSBSZXNlYXJjaCBHcm91cDEVMBMGA1UEAxMMSVNSRyBSb290IFgyMHYw
+EAYHKoZIzj0CAQYFK4EEACIDYgAEzZvVn4CDCuwJSvMWSj5cz3es3mcFDR0HttwW
++1qLFNvicWDEukWVEYmO6gbf9yoWHKS5xcUy4APgHoIYOIvXRdgKam7mAHf7AlF9
+ItgKbppbd9/w+kHsOdx1ymgHDB/qo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0T
+AQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEKWrt5LSDv6kviejM9ti6lyN5UwCgYIKoZI
+zj0EAwMDaAAwZQIwe3lORlCEwkSHRhtFcP9Ymd70/aTSVaYgLXTWNLxBo1BfASdW
+tL4ndQavEi51mI38AjEAi/V3bNTIZargCyzuFJ0nN6T5U6VR5CmD1/iQMVtCnwr1
+/q4AaOeMSQ+2b1tbFfLn
+-----END CERTIFICATE-----
+
+# Issuer: CN=HiPKI Root CA - G1 O=Chunghwa Telecom Co., Ltd.
+# Subject: CN=HiPKI Root CA - G1 O=Chunghwa Telecom Co., Ltd.
+# Label: "HiPKI Root CA - G1"
+# Serial: 60966262342023497858655262305426234976
+# MD5 Fingerprint: 69:45:df:16:65:4b:e8:68:9a:8f:76:5f:ff:80:9e:d3
+# SHA1 Fingerprint: 6a:92:e4:a8:ee:1b:ec:96:45:37:e3:29:57:49:cd:96:e3:e5:d2:60
+# SHA256 Fingerprint: f0:15:ce:3c:c2:39:bf:ef:06:4b:e9:f1:d2:c4:17:e1:a0:26:4a:0a:94:be:1f:0c:8d:12:18:64:eb:69:49:cc
+-----BEGIN CERTIFICATE-----
+MIIFajCCA1KgAwIBAgIQLd2szmKXlKFD6LDNdmpeYDANBgkqhkiG9w0BAQsFADBP
+MQswCQYDVQQGEwJUVzEjMCEGA1UECgwaQ2h1bmdod2EgVGVsZWNvbSBDby4sIEx0
+ZC4xGzAZBgNVBAMMEkhpUEtJIFJvb3QgQ0EgLSBHMTAeFw0xOTAyMjIwOTQ2MDRa
+Fw0zNzEyMzExNTU5NTlaME8xCzAJBgNVBAYTAlRXMSMwIQYDVQQKDBpDaHVuZ2h3
+YSBUZWxlY29tIENvLiwgTHRkLjEbMBkGA1UEAwwSSGlQS0kgUm9vdCBDQSAtIEcx
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA9B5/UnMyDHPkvRN0o9Qw
+qNCuS9i233VHZvR85zkEHmpwINJaR3JnVfSl6J3VHiGh8Ge6zCFovkRTv4354twv
+Vcg3Px+kwJyz5HdcoEb+d/oaoDjq7Zpy3iu9lFc6uux55199QmQ5eiY29yTw1S+6
+lZgRZq2XNdZ1AYDgr/SEYYwNHl98h5ZeQa/rh+r4XfEuiAU+TCK72h8q3VJGZDnz
+Qs7ZngyzsHeXZJzA9KMuH5UHsBffMNsAGJZMoYFL3QRtU6M9/Aes1MU3guvklQgZ
+KILSQjqj2FPseYlgSGDIcpJQ3AOPgz+yQlda22rpEZfdhSi8MEyr48KxRURHH+CK
+FgeW0iEPU8DtqX7UTuybCeyvQqww1r/REEXgphaypcXTT3OUM3ECoWqj1jOXTyFj
+HluP2cFeRXF3D4FdXyGarYPM+l7WjSNfGz1BryB1ZlpK9p/7qxj3ccC2HTHsOyDr
+y+K49a6SsvfhhEvyovKTmiKe0xRvNlS9H15ZFblzqMF8b3ti6RZsR1pl8w4Rm0bZ
+/W3c1pzAtH2lsN0/Vm+h+fbkEkj9Bn8SV7apI09bA8PgcSojt/ewsTu8mL3WmKgM
+a/aOEmem8rJY5AIJEzypuxC00jBF8ez3ABHfZfjcK0NVvxaXxA/VLGGEqnKG/uY6
+fsI/fe78LxQ+5oXdUG+3Se0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQU8ncX+l6o/vY9cdVouslGDDjYr7AwDgYDVR0PAQH/BAQDAgGGMA0GCSqG
+SIb3DQEBCwUAA4ICAQBQUfB13HAE4/+qddRxosuej6ip0691x1TPOhwEmSKsxBHi
+7zNKpiMdDg1H2DfHb680f0+BazVP6XKlMeJ45/dOlBhbQH3PayFUhuaVevvGyuqc
+SE5XCV0vrPSltJczWNWseanMX/mF+lLFjfiRFOs6DRfQUsJ748JzjkZ4Bjgs6Fza
+ZsT0pPBWGTMpWmWSBUdGSquEwx4noR8RkpkndZMPvDY7l1ePJlsMu5wP1G4wB9Tc
+XzZoZjmDlicmisjEOf6aIW/Vcobpf2Lll07QJNBAsNB1CI69aO4I1258EHBGG3zg
+iLKecoaZAeO/n0kZtCW+VmWuF2PlHt/o/0elv+EmBYTksMCv5wiZqAxeJoBF1Pho
+L5aPruJKHJwWDBNvOIf2u8g0X5IDUXlwpt/L9ZlNec1OvFefQ05rLisY+GpzjLrF
+Ne85akEez3GoorKGB1s6yeHvP2UEgEcyRHCVTjFnanRbEEV16rCf0OY1/k6fi8wr
+kkVbbiVghUbN0aqwdmaTd5a+g744tiROJgvM7XpWGuDpWsZkrUx6AEhEL7lAuxM+
+vhV4nYWBSipX3tUZQ9rbyltHhoMLP7YNdnhzeSJesYAfz77RP1YQmCuVh6EfnWQU
+YDksswBVLuT1sw5XxJFBAJw/6KXf6vb/yPCtbVKoF6ubYfwSUTXkJf2vqmqGOQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4
+# Label: "GlobalSign ECC Root CA - R4"
+# Serial: 159662223612894884239637590694
+# MD5 Fingerprint: 26:29:f8:6d:e1:88:bf:a2:65:7f:aa:c4:cd:0f:7f:fc
+# SHA1 Fingerprint: 6b:a0:b0:98:e1:71:ef:5a:ad:fe:48:15:80:77:10:f4:bd:6f:0b:28
+# SHA256 Fingerprint: b0:85:d7:0b:96:4f:19:1a:73:e4:af:0d:54:ae:7a:0e:07:aa:fd:af:9b:71:dd:08:62:13:8a:b7:32:5a:24:a2
+-----BEGIN CERTIFICATE-----
+MIIB3DCCAYOgAwIBAgINAgPlfvU/k/2lCSGypjAKBggqhkjOPQQDAjBQMSQwIgYD
+VQQLExtHbG9iYWxTaWduIEVDQyBSb290IENBIC0gUjQxEzARBgNVBAoTCkdsb2Jh
+bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTIxMTEzMDAwMDAwWhcNMzgw
+MTE5MDMxNDA3WjBQMSQwIgYDVQQLExtHbG9iYWxTaWduIEVDQyBSb290IENBIC0g
+UjQxEzARBgNVBAoTCkdsb2JhbFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wWTAT
+BgcqhkjOPQIBBggqhkjOPQMBBwNCAAS4xnnTj2wlDp8uORkcA6SumuU5BwkWymOx
+uYb4ilfBV85C+nOh92VC/x7BALJucw7/xyHlGKSq2XE/qNS5zowdo0IwQDAOBgNV
+HQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVLB7rUW44kB/
++wpu+74zyTyjhNUwCgYIKoZIzj0EAwIDRwAwRAIgIk90crlgr/HmnKAWBVBfw147
+bmF0774BxL4YSFlhgjICICadVGNA3jdgUM/I2O2dgq43mLyjj0xMqTQrbO/7lZsm
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R1 O=Google Trust Services LLC
+# Subject: CN=GTS Root R1 O=Google Trust Services LLC
+# Label: "GTS Root R1"
+# Serial: 159662320309726417404178440727
+# MD5 Fingerprint: 05:fe:d0:bf:71:a8:a3:76:63:da:01:e0:d8:52:dc:40
+# SHA1 Fingerprint: e5:8c:1c:c4:91:3b:38:63:4b:e9:10:6e:e3:ad:8e:6b:9d:d9:81:4a
+# SHA256 Fingerprint: d9:47:43:2a:bd:e7:b7:fa:90:fc:2e:6b:59:10:1b:12:80:e0:e1:c7:e4:e4:0f:a3:c6:88:7f:ff:57:a7:f4:cf
+-----BEGIN CERTIFICATE-----
+MIIFVzCCAz+gAwIBAgINAgPlk28xsBNJiGuiFzANBgkqhkiG9w0BAQwFADBHMQsw
+CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
+MBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
+MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
+Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwggIiMA0GCSqGSIb3DQEBAQUA
+A4ICDwAwggIKAoICAQC2EQKLHuOhd5s73L+UPreVp0A8of2C+X0yBoJx9vaMf/vo
+27xqLpeXo4xL+Sv2sfnOhB2x+cWX3u+58qPpvBKJXqeqUqv4IyfLpLGcY9vXmX7w
+Cl7raKb0xlpHDU0QM+NOsROjyBhsS+z8CZDfnWQpJSMHobTSPS5g4M/SCYe7zUjw
+TcLCeoiKu7rPWRnWr4+wB7CeMfGCwcDfLqZtbBkOtdh+JhpFAz2weaSUKK0Pfybl
+qAj+lug8aJRT7oM6iCsVlgmy4HqMLnXWnOunVmSPlk9orj2XwoSPwLxAwAtcvfaH
+szVsrBhQf4TgTM2S0yDpM7xSma8ytSmzJSq0SPly4cpk9+aCEI3oncKKiPo4Zor8
+Y/kB+Xj9e1x3+naH+uzfsQ55lVe0vSbv1gHR6xYKu44LtcXFilWr06zqkUspzBmk
+MiVOKvFlRNACzqrOSbTqn3yDsEB750Orp2yjj32JgfpMpf/VjsPOS+C12LOORc92
+wO1AK/1TD7Cn1TsNsYqiA94xrcx36m97PtbfkSIS5r762DL8EGMUUXLeXdYWk70p
+aDPvOmbsB4om3xPXV2V4J95eSRQAogB/mqghtqmxlbCluQ0WEdrHbEg8QOB+DVrN
+VjzRlwW5y0vtOUucxD/SVRNuJLDWcfr0wbrM7Rv1/oFB2ACYPTrIrnqYNxgFlQID
+AQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E
+FgQU5K8rJnEaK0gnhS9SZizv8IkTcT4wDQYJKoZIhvcNAQEMBQADggIBAJ+qQibb
+C5u+/x6Wki4+omVKapi6Ist9wTrYggoGxval3sBOh2Z5ofmmWJyq+bXmYOfg6LEe
+QkEzCzc9zolwFcq1JKjPa7XSQCGYzyI0zzvFIoTgxQ6KfF2I5DUkzps+GlQebtuy
+h6f88/qBVRRiClmpIgUxPoLW7ttXNLwzldMXG+gnoot7TiYaelpkttGsN/H9oPM4
+7HLwEXWdyzRSjeZ2axfG34arJ45JK3VmgRAhpuo+9K4l/3wV3s6MJT/KYnAK9y8J
+ZgfIPxz88NtFMN9iiMG1D53Dn0reWVlHxYciNuaCp+0KueIHoI17eko8cdLiA6Ef
+MgfdG+RCzgwARWGAtQsgWSl4vflVy2PFPEz0tv/bal8xa5meLMFrUKTX5hgUvYU/
+Z6tGn6D/Qqc6f1zLXbBwHSs09dR2CQzreExZBfMzQsNhFRAbd03OIozUhfJFfbdT
+6u9AWpQKXCBfTkBdYiJ23//OYb2MI3jSNwLgjt7RETeJ9r/tSQdirpLsQBqvFAnZ
+0E6yove+7u7Y/9waLd64NnHi/Hm3lCXRSHNboTXns5lndcEZOitHTtNCjv0xyBZm
+2tIMPNuzjsmhDYAPexZ3FL//2wmUspO8IFgV6dtxQ/PeEMMA3KgqlbbC1j+Qa3bb
+bP6MvPJwNQzcmRk13NfIRmPVNnGuV/u3gm3c
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R2 O=Google Trust Services LLC
+# Subject: CN=GTS Root R2 O=Google Trust Services LLC
+# Label: "GTS Root R2"
+# Serial: 159662449406622349769042896298
+# MD5 Fingerprint: 1e:39:c0:53:e6:1e:29:82:0b:ca:52:55:36:5d:57:dc
+# SHA1 Fingerprint: 9a:44:49:76:32:db:de:fa:d0:bc:fb:5a:7b:17:bd:9e:56:09:24:94
+# SHA256 Fingerprint: 8d:25:cd:97:22:9d:bf:70:35:6b:da:4e:b3:cc:73:40:31:e2:4c:f0:0f:af:cf:d3:2d:c7:6e:b5:84:1c:7e:a8
+-----BEGIN CERTIFICATE-----
+MIIFVzCCAz+gAwIBAgINAgPlrsWNBCUaqxElqjANBgkqhkiG9w0BAQwFADBHMQsw
+CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
+MBIGA1UEAxMLR1RTIFJvb3QgUjIwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
+MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
+Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwggIiMA0GCSqGSIb3DQEBAQUA
+A4ICDwAwggIKAoICAQDO3v2m++zsFDQ8BwZabFn3GTXd98GdVarTzTukk3LvCvpt
+nfbwhYBboUhSnznFt+4orO/LdmgUud+tAWyZH8QiHZ/+cnfgLFuv5AS/T3KgGjSY
+6Dlo7JUle3ah5mm5hRm9iYz+re026nO8/4Piy33B0s5Ks40FnotJk9/BW9BuXvAu
+MC6C/Pq8tBcKSOWIm8Wba96wyrQD8Nr0kLhlZPdcTK3ofmZemde4wj7I0BOdre7k
+RXuJVfeKH2JShBKzwkCX44ofR5GmdFrS+LFjKBC4swm4VndAoiaYecb+3yXuPuWg
+f9RhD1FLPD+M2uFwdNjCaKH5wQzpoeJ/u1U8dgbuak7MkogwTZq9TwtImoS1mKPV
++3PBV2HdKFZ1E66HjucMUQkQdYhMvI35ezzUIkgfKtzra7tEscszcTJGr61K8Yzo
+dDqs5xoic4DSMPclQsciOzsSrZYuxsN2B6ogtzVJV+mSSeh2FnIxZyuWfoqjx5RW
+Ir9qS34BIbIjMt/kmkRtWVtd9QCgHJvGeJeNkP+byKq0rxFROV7Z+2et1VsRnTKa
+G73VululycslaVNVJ1zgyjbLiGH7HrfQy+4W+9OmTN6SpdTi3/UGVN4unUu0kzCq
+gc7dGtxRcw1PcOnlthYhGXmy5okLdWTK1au8CcEYof/UVKGFPP0UJAOyh9OktwID
+AQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E
+FgQUu//KjiOfT5nK2+JopqUVJxce2Q4wDQYJKoZIhvcNAQEMBQADggIBAB/Kzt3H
+vqGf2SdMC9wXmBFqiN495nFWcrKeGk6c1SuYJF2ba3uwM4IJvd8lRuqYnrYb/oM8
+0mJhwQTtzuDFycgTE1XnqGOtjHsB/ncw4c5omwX4Eu55MaBBRTUoCnGkJE+M3DyC
+B19m3H0Q/gxhswWV7uGugQ+o+MePTagjAiZrHYNSVc61LwDKgEDg4XSsYPWHgJ2u
+NmSRXbBoGOqKYcl3qJfEycel/FVL8/B/uWU9J2jQzGv6U53hkRrJXRqWbTKH7QMg
+yALOWr7Z6v2yTcQvG99fevX4i8buMTolUVVnjWQye+mew4K6Ki3pHrTgSAai/Gev
+HyICc/sgCq+dVEuhzf9gR7A/Xe8bVr2XIZYtCtFenTgCR2y59PYjJbigapordwj6
+xLEokCZYCDzifqrXPW+6MYgKBesntaFJ7qBFVHvmJ2WZICGoo7z7GJa7Um8M7YNR
+TOlZ4iBgxcJlkoKM8xAfDoqXvneCbT+PHV28SSe9zE8P4c52hgQjxcCMElv924Sg
+JPFI/2R80L5cFtHvma3AH/vLrrw4IgYmZNralw4/KBVEqE8AyvCazM90arQ+POuV
+7LXTWtiBmelDGDfrs7vRWGJB82bSj6p4lVQgw1oudCvV0b4YacCs1aTPObpRhANl
+6WLAYv7YTVWW4tAR+kg0Eeye7QUd5MjWHYbL
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R3 O=Google Trust Services LLC
+# Subject: CN=GTS Root R3 O=Google Trust Services LLC
+# Label: "GTS Root R3"
+# Serial: 159662495401136852707857743206
+# MD5 Fingerprint: 3e:e7:9d:58:02:94:46:51:94:e5:e0:22:4a:8b:e7:73
+# SHA1 Fingerprint: ed:e5:71:80:2b:c8:92:b9:5b:83:3c:d2:32:68:3f:09:cd:a0:1e:46
+# SHA256 Fingerprint: 34:d8:a7:3e:e2:08:d9:bc:db:0d:95:65:20:93:4b:4e:40:e6:94:82:59:6e:8b:6f:73:c8:42:6b:01:0a:6f:48
+-----BEGIN CERTIFICATE-----
+MIICCTCCAY6gAwIBAgINAgPluILrIPglJ209ZjAKBggqhkjOPQQDAzBHMQswCQYD
+VQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEUMBIG
+A1UEAxMLR1RTIFJvb3QgUjMwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAwMDAw
+WjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2Vz
+IExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjMwdjAQBgcqhkjOPQIBBgUrgQQAIgNi
+AAQfTzOHMymKoYTey8chWEGJ6ladK0uFxh1MJ7x/JlFyb+Kf1qPKzEUURout736G
+jOyxfi//qXGdGIRFBEFVbivqJn+7kAHjSxm65FSWRQmx1WyRRK2EE46ajA2ADDL2
+4CejQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
+BBTB8Sa6oC2uhYHP0/EqEr24Cmf9vDAKBggqhkjOPQQDAwNpADBmAjEA9uEglRR7
+VKOQFhG/hMjqb2sXnh5GmCCbn9MN2azTL818+FsuVbu/3ZL3pAzcMeGiAjEA/Jdm
+ZuVDFhOD3cffL74UOO0BzrEXGhF16b0DjyZ+hOXJYKaV11RZt+cRLInUue4X
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R4 O=Google Trust Services LLC
+# Subject: CN=GTS Root R4 O=Google Trust Services LLC
+# Label: "GTS Root R4"
+# Serial: 159662532700760215368942768210
+# MD5 Fingerprint: 43:96:83:77:19:4d:76:b3:9d:65:52:e4:1d:22:a5:e8
+# SHA1 Fingerprint: 77:d3:03:67:b5:e0:0c:15:f6:0c:38:61:df:7c:e1:3b:92:46:4d:47
+# SHA256 Fingerprint: 34:9d:fa:40:58:c5:e2:63:12:3b:39:8a:e7:95:57:3c:4e:13:13:c8:3f:e6:8f:93:55:6c:d5:e8:03:1b:3c:7d
+-----BEGIN CERTIFICATE-----
+MIICCTCCAY6gAwIBAgINAgPlwGjvYxqccpBQUjAKBggqhkjOPQQDAzBHMQswCQYD
+VQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEUMBIG
+A1UEAxMLR1RTIFJvb3QgUjQwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAwMDAw
+WjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2Vz
+IExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjQwdjAQBgcqhkjOPQIBBgUrgQQAIgNi
+AATzdHOnaItgrkO4NcWBMHtLSZ37wWHO5t5GvWvVYRg1rkDdc/eJkTBa6zzuhXyi
+QHY7qca4R9gq55KRanPpsXI5nymfopjTX15YhmUPoYRlBtHci8nHc8iMai/lxKvR
+HYqjQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
+BBSATNbrdP9JNqPV2Py1PsVq8JQdjDAKBggqhkjOPQQDAwNpADBmAjEA6ED/g94D
+9J+uHXqnLrmvT/aDHQ4thQEd0dlq7A/Cr8deVl5c1RxYIigL9zC2L7F8AjEA8GE8
+p/SgguMh1YQdc4acLa/KNJvxn7kjNuK8YAOdgLOaVsjh4rsUecrNIdSUtUlD
+-----END CERTIFICATE-----
+
+# Issuer: CN=Telia Root CA v2 O=Telia Finland Oyj
+# Subject: CN=Telia Root CA v2 O=Telia Finland Oyj
+# Label: "Telia Root CA v2"
+# Serial: 7288924052977061235122729490515358
+# MD5 Fingerprint: 0e:8f:ac:aa:82:df:85:b1:f4:dc:10:1c:fc:99:d9:48
+# SHA1 Fingerprint: b9:99:cd:d1:73:50:8a:c4:47:05:08:9c:8c:88:fb:be:a0:2b:40:cd
+# SHA256 Fingerprint: 24:2b:69:74:2f:cb:1e:5b:2a:bf:98:89:8b:94:57:21:87:54:4e:5b:4d:99:11:78:65:73:62:1f:6a:74:b8:2c
+-----BEGIN CERTIFICATE-----
+MIIFdDCCA1ygAwIBAgIPAWdfJ9b+euPkrL4JWwWeMA0GCSqGSIb3DQEBCwUAMEQx
+CzAJBgNVBAYTAkZJMRowGAYDVQQKDBFUZWxpYSBGaW5sYW5kIE95ajEZMBcGA1UE
+AwwQVGVsaWEgUm9vdCBDQSB2MjAeFw0xODExMjkxMTU1NTRaFw00MzExMjkxMTU1
+NTRaMEQxCzAJBgNVBAYTAkZJMRowGAYDVQQKDBFUZWxpYSBGaW5sYW5kIE95ajEZ
+MBcGA1UEAwwQVGVsaWEgUm9vdCBDQSB2MjCCAiIwDQYJKoZIhvcNAQEBBQADggIP
+ADCCAgoCggIBALLQPwe84nvQa5n44ndp586dpAO8gm2h/oFlH0wnrI4AuhZ76zBq
+AMCzdGh+sq/H1WKzej9Qyow2RCRj0jbpDIX2Q3bVTKFgcmfiKDOlyzG4OiIjNLh9
+vVYiQJ3q9HsDrWj8soFPmNB06o3lfc1jw6P23pLCWBnglrvFxKk9pXSW/q/5iaq9
+lRdU2HhE8Qx3FZLgmEKnpNaqIJLNwaCzlrI6hEKNfdWV5Nbb6WLEWLN5xYzTNTOD
+n3WhUidhOPFZPY5Q4L15POdslv5e2QJltI5c0BE0312/UqeBAMN/mUWZFdUXyApT
+7GPzmX3MaRKGwhfwAZ6/hLzRUssbkmbOpFPlob/E2wnW5olWK8jjfN7j/4nlNW4o
+6GwLI1GpJQXrSPjdscr6bAhR77cYbETKJuFzxokGgeWKrLDiKca5JLNrRBH0pUPC
+TEPlcDaMtjNXepUugqD0XBCzYYP2AgWGLnwtbNwDRm41k9V6lS/eINhbfpSQBGq6
+WT0EBXWdN6IOLj3rwaRSg/7Qa9RmjtzG6RJOHSpXqhC8fF6CfaamyfItufUXJ63R
+DolUK5X6wK0dmBR4M0KGCqlztft0DbcbMBnEWg4cJ7faGND/isgFuvGqHKI3t+ZI
+pEYslOqodmJHixBTB0hXbOKSTbauBcvcwUpej6w9GU7C7WB1K9vBykLVAgMBAAGj
+YzBhMB8GA1UdIwQYMBaAFHKs5DN5qkWH9v2sHZ7Wxy+G2CQ5MB0GA1UdDgQWBBRy
+rOQzeapFh/b9rB2e1scvhtgkOTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUw
+AwEB/zANBgkqhkiG9w0BAQsFAAOCAgEAoDtZpwmUPjaE0n4vOaWWl/oRrfxn83EJ
+8rKJhGdEr7nv7ZbsnGTbMjBvZ5qsfl+yqwE2foH65IRe0qw24GtixX1LDoJt0nZi
+0f6X+J8wfBj5tFJ3gh1229MdqfDBmgC9bXXYfef6xzijnHDoRnkDry5023X4blMM
+A8iZGok1GTzTyVR8qPAs5m4HeW9q4ebqkYJpCh3DflminmtGFZhb069GHWLIzoBS
+SRE/yQQSwxN8PzuKlts8oB4KtItUsiRnDe+Cy748fdHif64W1lZYudogsYMVoe+K
+TTJvQS8TUoKU1xrBeKJR3Stwbbca+few4GeXVtt8YVMJAygCQMez2P2ccGrGKMOF
+6eLtGpOg3kuYooQ+BXcBlj37tCAPnHICehIv1aO6UXivKitEZU61/Qrowc15h2Er
+3oBXRb9n8ZuRXqWk7FlIEA04x7D6w0RtBPV4UBySllva9bguulvP5fBqnUsvWHMt
+Ty3EHD70sz+rFQ47GUGKpMFXEmZxTPpT41frYpUJnlTd0cI8Vzy9OK2YZLe4A5pT
+VmBds9hCG1xLEooc6+t9xnppxyd/pPiL8uSUZodL6ZQHCRJ5irLrdATczvREWeAW
+ysUsWNc8e89ihmpQfTU2Zqf7N+cox9jQraVplI/owd8k+BsHMYeB2F326CjYSlKA
+rBPuUBQemMc=
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST BR Root CA 1 2020 O=D-Trust GmbH
+# Subject: CN=D-TRUST BR Root CA 1 2020 O=D-Trust GmbH
+# Label: "D-TRUST BR Root CA 1 2020"
+# Serial: 165870826978392376648679885835942448534
+# MD5 Fingerprint: b5:aa:4b:d5:ed:f7:e3:55:2e:8f:72:0a:f3:75:b8:ed
+# SHA1 Fingerprint: 1f:5b:98:f0:e3:b5:f7:74:3c:ed:e6:b0:36:7d:32:cd:f4:09:41:67
+# SHA256 Fingerprint: e5:9a:aa:81:60:09:c2:2b:ff:5b:25:ba:d3:7d:f3:06:f0:49:79:7c:1f:81:d8:5a:b0:89:e6:57:bd:8f:00:44
+-----BEGIN CERTIFICATE-----
+MIIC2zCCAmCgAwIBAgIQfMmPK4TX3+oPyWWa00tNljAKBggqhkjOPQQDAzBIMQsw
+CQYDVQQGEwJERTEVMBMGA1UEChMMRC1UcnVzdCBHbWJIMSIwIAYDVQQDExlELVRS
+VVNUIEJSIFJvb3QgQ0EgMSAyMDIwMB4XDTIwMDIxMTA5NDUwMFoXDTM1MDIxMTA5
+NDQ1OVowSDELMAkGA1UEBhMCREUxFTATBgNVBAoTDEQtVHJ1c3QgR21iSDEiMCAG
+A1UEAxMZRC1UUlVTVCBCUiBSb290IENBIDEgMjAyMDB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABMbLxyjR+4T1mu9CFCDhQ2tuda38KwOE1HaTJddZO0Flax7mNCq7dPYS
+zuht56vkPE4/RAiLzRZxy7+SmfSk1zxQVFKQhYN4lGdnoxwJGT11NIXe7WB9xwy0
+QVK5buXuQqOCAQ0wggEJMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFHOREKv/
+VbNafAkl1bK6CKBrqx9tMA4GA1UdDwEB/wQEAwIBBjCBxgYDVR0fBIG+MIG7MD6g
+PKA6hjhodHRwOi8vY3JsLmQtdHJ1c3QubmV0L2NybC9kLXRydXN0X2JyX3Jvb3Rf
+Y2FfMV8yMDIwLmNybDB5oHegdYZzbGRhcDovL2RpcmVjdG9yeS5kLXRydXN0Lm5l
+dC9DTj1ELVRSVVNUJTIwQlIlMjBSb290JTIwQ0ElMjAxJTIwMjAyMCxPPUQtVHJ1
+c3QlMjBHbWJILEM9REU/Y2VydGlmaWNhdGVyZXZvY2F0aW9ubGlzdDAKBggqhkjO
+PQQDAwNpADBmAjEAlJAtE/rhY/hhY+ithXhUkZy4kzg+GkHaQBZTQgjKL47xPoFW
+wKrY7RjEsK70PvomAjEA8yjixtsrmfu3Ubgko6SUeho/5jbiA1czijDLgsfWFBHV
+dWNbFJWcHwHP2NVypw87
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST EV Root CA 1 2020 O=D-Trust GmbH
+# Subject: CN=D-TRUST EV Root CA 1 2020 O=D-Trust GmbH
+# Label: "D-TRUST EV Root CA 1 2020"
+# Serial: 126288379621884218666039612629459926992
+# MD5 Fingerprint: 8c:2d:9d:70:9f:48:99:11:06:11:fb:e9:cb:30:c0:6e
+# SHA1 Fingerprint: 61:db:8c:21:59:69:03:90:d8:7c:9c:12:86:54:cf:9d:3d:f4:dd:07
+# SHA256 Fingerprint: 08:17:0d:1a:a3:64:53:90:1a:2f:95:92:45:e3:47:db:0c:8d:37:ab:aa:bc:56:b8:1a:a1:00:dc:95:89:70:db
+-----BEGIN CERTIFICATE-----
+MIIC2zCCAmCgAwIBAgIQXwJB13qHfEwDo6yWjfv/0DAKBggqhkjOPQQDAzBIMQsw
+CQYDVQQGEwJERTEVMBMGA1UEChMMRC1UcnVzdCBHbWJIMSIwIAYDVQQDExlELVRS
+VVNUIEVWIFJvb3QgQ0EgMSAyMDIwMB4XDTIwMDIxMTEwMDAwMFoXDTM1MDIxMTA5
+NTk1OVowSDELMAkGA1UEBhMCREUxFTATBgNVBAoTDEQtVHJ1c3QgR21iSDEiMCAG
+A1UEAxMZRC1UUlVTVCBFViBSb290IENBIDEgMjAyMDB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABPEL3YZDIBnfl4XoIkqbz52Yv7QFJsnL46bSj8WeeHsxiamJrSc8ZRCC
+/N/DnU7wMyPE0jL1HLDfMxddxfCxivnvubcUyilKwg+pf3VlSSowZ/Rk99Yad9rD
+wpdhQntJraOCAQ0wggEJMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFH8QARY3
+OqQo5FD4pPfsazK2/umLMA4GA1UdDwEB/wQEAwIBBjCBxgYDVR0fBIG+MIG7MD6g
+PKA6hjhodHRwOi8vY3JsLmQtdHJ1c3QubmV0L2NybC9kLXRydXN0X2V2X3Jvb3Rf
+Y2FfMV8yMDIwLmNybDB5oHegdYZzbGRhcDovL2RpcmVjdG9yeS5kLXRydXN0Lm5l
+dC9DTj1ELVRSVVNUJTIwRVYlMjBSb290JTIwQ0ElMjAxJTIwMjAyMCxPPUQtVHJ1
+c3QlMjBHbWJILEM9REU/Y2VydGlmaWNhdGVyZXZvY2F0aW9ubGlzdDAKBggqhkjO
+PQQDAwNpADBmAjEAyjzGKnXCXnViOTYAYFqLwZOZzNnbQTs7h5kXO9XMT8oi96CA
+y/m0sRtW9XLS/BnRAjEAkfcwkz8QRitxpNA7RJvAKQIFskF3UfN5Wp6OFKBOQtJb
+gfM0agPnIjhQW+0ZT0MW
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert TLS ECC P384 Root G5 O=DigiCert, Inc.
+# Subject: CN=DigiCert TLS ECC P384 Root G5 O=DigiCert, Inc.
+# Label: "DigiCert TLS ECC P384 Root G5"
+# Serial: 13129116028163249804115411775095713523
+# MD5 Fingerprint: d3:71:04:6a:43:1c:db:a6:59:e1:a8:a3:aa:c5:71:ed
+# SHA1 Fingerprint: 17:f3:de:5e:9f:0f:19:e9:8e:f6:1f:32:26:6e:20:c4:07:ae:30:ee
+# SHA256 Fingerprint: 01:8e:13:f0:77:25:32:cf:80:9b:d1:b1:72:81:86:72:83:fc:48:c6:e1:3b:e9:c6:98:12:85:4a:49:0c:1b:05
+-----BEGIN CERTIFICATE-----
+MIICGTCCAZ+gAwIBAgIQCeCTZaz32ci5PhwLBCou8zAKBggqhkjOPQQDAzBOMQsw
+CQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xJjAkBgNVBAMTHURp
+Z2lDZXJ0IFRMUyBFQ0MgUDM4NCBSb290IEc1MB4XDTIxMDExNTAwMDAwMFoXDTQ2
+MDExNDIzNTk1OVowTjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDkRpZ2lDZXJ0LCBJ
+bmMuMSYwJAYDVQQDEx1EaWdpQ2VydCBUTFMgRUNDIFAzODQgUm9vdCBHNTB2MBAG
+ByqGSM49AgEGBSuBBAAiA2IABMFEoc8Rl1Ca3iOCNQfN0MsYndLxf3c1TzvdlHJS
+7cI7+Oz6e2tYIOyZrsn8aLN1udsJ7MgT9U7GCh1mMEy7H0cKPGEQQil8pQgO4CLp
+0zVozptjn4S1mU1YoI71VOeVyaNCMEAwHQYDVR0OBBYEFMFRRVBZqz7nLFr6ICIS
+B4CIfBFqMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MAoGCCqGSM49
+BAMDA2gAMGUCMQCJao1H5+z8blUD2WdsJk6Dxv3J+ysTvLd6jLRl0mlpYxNjOyZQ
+LgGheQaRnUi/wr4CMEfDFXuxoJGZSZOoPHzoRgaLLPIxAJSdYsiJvRmEFOml+wG4
+DXZDjC5Ty3zfDBeWUA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert TLS RSA4096 Root G5 O=DigiCert, Inc.
+# Subject: CN=DigiCert TLS RSA4096 Root G5 O=DigiCert, Inc.
+# Label: "DigiCert TLS RSA4096 Root G5"
+# Serial: 11930366277458970227240571539258396554
+# MD5 Fingerprint: ac:fe:f7:34:96:a9:f2:b3:b4:12:4b:e4:27:41:6f:e1
+# SHA1 Fingerprint: a7:88:49:dc:5d:7c:75:8c:8c:de:39:98:56:b3:aa:d0:b2:a5:71:35
+# SHA256 Fingerprint: 37:1a:00:dc:05:33:b3:72:1a:7e:eb:40:e8:41:9e:70:79:9d:2b:0a:0f:2c:1d:80:69:31:65:f7:ce:c4:ad:75
+-----BEGIN CERTIFICATE-----
+MIIFZjCCA06gAwIBAgIQCPm0eKj6ftpqMzeJ3nzPijANBgkqhkiG9w0BAQwFADBN
+MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xJTAjBgNVBAMT
+HERpZ2lDZXJ0IFRMUyBSU0E0MDk2IFJvb3QgRzUwHhcNMjEwMTE1MDAwMDAwWhcN
+NDYwMTE0MjM1OTU5WjBNMQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQs
+IEluYy4xJTAjBgNVBAMTHERpZ2lDZXJ0IFRMUyBSU0E0MDk2IFJvb3QgRzUwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCz0PTJeRGd/fxmgefM1eS87IE+
+ajWOLrfn3q/5B03PMJ3qCQuZvWxX2hhKuHisOjmopkisLnLlvevxGs3npAOpPxG0
+2C+JFvuUAT27L/gTBaF4HI4o4EXgg/RZG5Wzrn4DReW+wkL+7vI8toUTmDKdFqgp
+wgscONyfMXdcvyej/Cestyu9dJsXLfKB2l2w4SMXPohKEiPQ6s+d3gMXsUJKoBZM
+pG2T6T867jp8nVid9E6P/DsjyG244gXazOvswzH016cpVIDPRFtMbzCe88zdH5RD
+nU1/cHAN1DrRN/BsnZvAFJNY781BOHW8EwOVfH/jXOnVDdXifBBiqmvwPXbzP6Po
+sMH976pXTayGpxi0KcEsDr9kvimM2AItzVwv8n/vFfQMFawKsPHTDU9qTXeXAaDx
+Zre3zu/O7Oyldcqs4+Fj97ihBMi8ez9dLRYiVu1ISf6nL3kwJZu6ay0/nTvEF+cd
+Lvvyz6b84xQslpghjLSR6Rlgg/IwKwZzUNWYOwbpx4oMYIwo+FKbbuH2TbsGJJvX
+KyY//SovcfXWJL5/MZ4PbeiPT02jP/816t9JXkGPhvnxd3lLG7SjXi/7RgLQZhNe
+XoVPzthwiHvOAbWWl9fNff2C+MIkwcoBOU+NosEUQB+cZtUMCUbW8tDRSHZWOkPL
+tgoRObqME2wGtZ7P6wIDAQABo0IwQDAdBgNVHQ4EFgQUUTMc7TZArxfTJc1paPKv
+TiM+s0EwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcN
+AQEMBQADggIBAGCmr1tfV9qJ20tQqcQjNSH/0GEwhJG3PxDPJY7Jv0Y02cEhJhxw
+GXIeo8mH/qlDZJY6yFMECrZBu8RHANmfGBg7sg7zNOok992vIGCukihfNudd5N7H
+PNtQOa27PShNlnx2xlv0wdsUpasZYgcYQF+Xkdycx6u1UQ3maVNVzDl92sURVXLF
+O4uJ+DQtpBflF+aZfTCIITfNMBc9uPK8qHWgQ9w+iUuQrm0D4ByjoJYJu32jtyoQ
+REtGBzRj7TG5BO6jm5qu5jF49OokYTurWGT/u4cnYiWB39yhL/btp/96j1EuMPik
+AdKFOV8BmZZvWltwGUb+hmA+rYAQCd05JS9Yf7vSdPD3Rh9GOUrYU9DzLjtxpdRv
+/PNn5AeP3SYZ4Y1b+qOTEZvpyDrDVWiakuFSdjjo4bq9+0/V77PnSIMx8IIh47a+
+p6tv75/fTM8BuGJqIz3nCU2AG3swpMPdB380vqQmsvZB6Akd4yCYqjdP//fx4ilw
+MUc/dNAUFvohigLVigmUdy7yWSiLfFCSCmZ4OIN1xLVaqBHG5cGdZlXPU8Sv13WF
+qUITVuwhd4GTWgzqltlJyqEI8pc7bZsEGCREjnwB8twl2F6GmrE52/WRMmrRpnCK
+ovfepEWFJqgejF0pW8hL2JpqA15w8oVPbEtoL8pU9ozaMv7Da4M/OMZ+
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certainly Root R1 O=Certainly
+# Subject: CN=Certainly Root R1 O=Certainly
+# Label: "Certainly Root R1"
+# Serial: 188833316161142517227353805653483829216
+# MD5 Fingerprint: 07:70:d4:3e:82:87:a0:fa:33:36:13:f4:fa:33:e7:12
+# SHA1 Fingerprint: a0:50:ee:0f:28:71:f4:27:b2:12:6d:6f:50:96:25:ba:cc:86:42:af
+# SHA256 Fingerprint: 77:b8:2c:d8:64:4c:43:05:f7:ac:c5:cb:15:6b:45:67:50:04:03:3d:51:c6:0c:62:02:a8:e0:c3:34:67:d3:a0
+-----BEGIN CERTIFICATE-----
+MIIFRzCCAy+gAwIBAgIRAI4P+UuQcWhlM1T01EQ5t+AwDQYJKoZIhvcNAQELBQAw
+PTELMAkGA1UEBhMCVVMxEjAQBgNVBAoTCUNlcnRhaW5seTEaMBgGA1UEAxMRQ2Vy
+dGFpbmx5IFJvb3QgUjEwHhcNMjEwNDAxMDAwMDAwWhcNNDYwNDAxMDAwMDAwWjA9
+MQswCQYDVQQGEwJVUzESMBAGA1UEChMJQ2VydGFpbmx5MRowGAYDVQQDExFDZXJ0
+YWlubHkgUm9vdCBSMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANA2
+1B/q3avk0bbm+yLA3RMNansiExyXPGhjZjKcA7WNpIGD2ngwEc/csiu+kr+O5MQT
+vqRoTNoCaBZ0vrLdBORrKt03H2As2/X3oXyVtwxwhi7xOu9S98zTm/mLvg7fMbed
+aFySpvXl8wo0tf97ouSHocavFwDvA5HtqRxOcT3Si2yJ9HiG5mpJoM610rCrm/b0
+1C7jcvk2xusVtyWMOvwlDbMicyF0yEqWYZL1LwsYpfSt4u5BvQF5+paMjRcCMLT5
+r3gajLQ2EBAHBXDQ9DGQilHFhiZ5shGIXsXwClTNSaa/ApzSRKft43jvRl5tcdF5
+cBxGX1HpyTfcX35pe0HfNEXgO4T0oYoKNp43zGJS4YkNKPl6I7ENPT2a/Z2B7yyQ
+wHtETrtJ4A5KVpK8y7XdeReJkd5hiXSSqOMyhb5OhaRLWcsrxXiOcVTQAjeZjOVJ
+6uBUcqQRBi8LjMFbvrWhsFNunLhgkR9Za/kt9JQKl7XsxXYDVBtlUrpMklZRNaBA
+2CnbrlJ2Oy0wQJuK0EJWtLeIAaSHO1OWzaMWj/Nmqhexx2DgwUMFDO6bW2BvBlyH
+Wyf5QBGenDPBt+U1VwV/J84XIIwc/PH72jEpSe31C4SnT8H2TsIonPru4K8H+zMR
+eiFPCyEQtkA6qyI6BJyLm4SGcprSp6XEtHWRqSsjAgMBAAGjQjBAMA4GA1UdDwEB
+/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTgqj8ljZ9EXME66C6u
+d0yEPmcM9DANBgkqhkiG9w0BAQsFAAOCAgEAuVevuBLaV4OPaAszHQNTVfSVcOQr
+PbA56/qJYv331hgELyE03fFo8NWWWt7CgKPBjcZq91l3rhVkz1t5BXdm6ozTaw3d
+8VkswTOlMIAVRQdFGjEitpIAq5lNOo93r6kiyi9jyhXWx8bwPWz8HA2YEGGeEaIi
+1wrykXprOQ4vMMM2SZ/g6Q8CRFA3lFV96p/2O7qUpUzpvD5RtOjKkjZUbVwlKNrd
+rRT90+7iIgXr0PK3aBLXWopBGsaSpVo7Y0VPv+E6dyIvXL9G+VoDhRNCX8reU9di
+taY1BMJH/5n9hN9czulegChB8n3nHpDYT3Y+gjwN/KUD+nsa2UUeYNrEjvn8K8l7
+lcUq/6qJ34IxD3L/DCfXCh5WAFAeDJDBlrXYFIW7pw0WwfgHJBu6haEaBQmAupVj
+yTrsJZ9/nbqkRxWbRHDxakvWOF5D8xh+UG7pWijmZeZ3Gzr9Hb4DJqPb1OG7fpYn
+Kx3upPvaJVQTA945xsMfTZDsjxtK0hzthZU4UHlG1sGQUDGpXJpuHfUzVounmdLy
+yCwzk5Iwx06MZTMQZBf9JBeW0Y3COmor6xOLRPIh80oat3df1+2IpHLlOR+Vnb5n
+wXARPbv0+Em34yaXOp/SX3z7wJl8OSngex2/DaeP0ik0biQVy96QXr8axGbqwua6
+OV+KmalBWQewLK8=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certainly Root E1 O=Certainly
+# Subject: CN=Certainly Root E1 O=Certainly
+# Label: "Certainly Root E1"
+# Serial: 8168531406727139161245376702891150584
+# MD5 Fingerprint: 0a:9e:ca:cd:3e:52:50:c6:36:f3:4b:a3:ed:a7:53:e9
+# SHA1 Fingerprint: f9:e1:6d:dc:01:89:cf:d5:82:45:63:3e:c5:37:7d:c2:eb:93:6f:2b
+# SHA256 Fingerprint: b4:58:5f:22:e4:ac:75:6a:4e:86:12:a1:36:1c:5d:9d:03:1a:93:fd:84:fe:bb:77:8f:a3:06:8b:0f:c4:2d:c2
+-----BEGIN CERTIFICATE-----
+MIIB9zCCAX2gAwIBAgIQBiUzsUcDMydc+Y2aub/M+DAKBggqhkjOPQQDAzA9MQsw
+CQYDVQQGEwJVUzESMBAGA1UEChMJQ2VydGFpbmx5MRowGAYDVQQDExFDZXJ0YWlu
+bHkgUm9vdCBFMTAeFw0yMTA0MDEwMDAwMDBaFw00NjA0MDEwMDAwMDBaMD0xCzAJ
+BgNVBAYTAlVTMRIwEAYDVQQKEwlDZXJ0YWlubHkxGjAYBgNVBAMTEUNlcnRhaW5s
+eSBSb290IEUxMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE3m/4fxzf7flHh4axpMCK
++IKXgOqPyEpeKn2IaKcBYhSRJHpcnqMXfYqGITQYUBsQ3tA3SybHGWCA6TS9YBk2
+QNYphwk8kXr2vBMj3VlOBF7PyAIcGFPBMdjaIOlEjeR2o0IwQDAOBgNVHQ8BAf8E
+BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8ygYy2R17ikq6+2uI1g4
+hevIIgcwCgYIKoZIzj0EAwMDaAAwZQIxALGOWiDDshliTd6wT99u0nCK8Z9+aozm
+ut6Dacpps6kFtZaSF4fC0urQe87YQVt8rgIwRt7qy12a7DLCZRawTDBcMPPaTnOG
+BtjOiQRINzf43TNRnXCve1XYAS59BWQOhriR
+-----END CERTIFICATE-----
+
+# Issuer: CN=E-Tugra Global Root CA RSA v3 O=E-Tugra EBG A.S. OU=E-Tugra Trust Center
+# Subject: CN=E-Tugra Global Root CA RSA v3 O=E-Tugra EBG A.S. OU=E-Tugra Trust Center
+# Label: "E-Tugra Global Root CA RSA v3"
+# Serial: 75951268308633135324246244059508261641472512052
+# MD5 Fingerprint: 22:be:10:f6:c2:f8:03:88:73:5f:33:29:47:28:47:a4
+# SHA1 Fingerprint: e9:a8:5d:22:14:52:1c:5b:aa:0a:b4:be:24:6a:23:8a:c9:ba:e2:a9
+# SHA256 Fingerprint: ef:66:b0:b1:0a:3c:db:9f:2e:36:48:c7:6b:d2:af:18:ea:d2:bf:e6:f1:17:65:5e:28:c4:06:0d:a1:a3:f4:c2
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=E-Tugra Global Root CA ECC v3 O=E-Tugra EBG A.S. OU=E-Tugra Trust Center
+# Subject: CN=E-Tugra Global Root CA ECC v3 O=E-Tugra EBG A.S. OU=E-Tugra Trust Center
+# Label: "E-Tugra Global Root CA ECC v3"
+# Serial: 218504919822255052842371958738296604628416471745
+# MD5 Fingerprint: 46:bc:81:bb:f1:b5:1e:f7:4b:96:bc:14:e2:e7:27:64
+# SHA1 Fingerprint: 8a:2f:af:57:53:b1:b0:e6:a1:04:ec:5b:6a:69:71:6d:f6:1c:e2:84
+# SHA256 Fingerprint: 87:3f:46:85:fa:7f:56:36:25:25:2e:6d:36:bc:d7:f1:6f:c2:49:51:f2:64:e4:7e:1b:95:4f:49:08:cd:ca:13
+-----BEGIN CERTIFICATE-----
+MIICpTCCAiqgAwIBAgIUJkYZdzHhT28oNt45UYbm1JeIIsEwCgYIKoZIzj0EAwMw
+gYAxCzAJBgNVBAYTAlRSMQ8wDQYDVQQHEwZBbmthcmExGTAXBgNVBAoTEEUtVHVn
+cmEgRUJHIEEuUy4xHTAbBgNVBAsTFEUtVHVncmEgVHJ1c3QgQ2VudGVyMSYwJAYD
+VQQDEx1FLVR1Z3JhIEdsb2JhbCBSb290IENBIEVDQyB2MzAeFw0yMDAzMTgwOTQ2
+NThaFw00NTAzMTIwOTQ2NThaMIGAMQswCQYDVQQGEwJUUjEPMA0GA1UEBxMGQW5r
+YXJhMRkwFwYDVQQKExBFLVR1Z3JhIEVCRyBBLlMuMR0wGwYDVQQLExRFLVR1Z3Jh
+IFRydXN0IENlbnRlcjEmMCQGA1UEAxMdRS1UdWdyYSBHbG9iYWwgUm9vdCBDQSBF
+Q0MgdjMwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASOmCm/xxAeJ9urA8woLNheSBkQ
+KczLWYHMjLiSF4mDKpL2w6QdTGLVn9agRtwcvHbB40fQWxPa56WzZkjnIZpKT4YK
+fWzqTTKACrJ6CZtpS5iB4i7sAnCWH/31Rs7K3IKjYzBhMA8GA1UdEwEB/wQFMAMB
+Af8wHwYDVR0jBBgwFoAU/4Ixcj75xGZsrTie0bBRiKWQzPUwHQYDVR0OBBYEFP+C
+MXI++cRmbK04ntGwUYilkMz1MA4GA1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNp
+ADBmAjEA5gVYaWHlLcoNy/EZCL3W/VGSGn5jVASQkZo1kTmZ+gepZpO6yGjUij/6
+7W4WAie3AjEA3VoXK3YdZUKWpqxdinlW2Iob35reX8dQj7FbcQwm32pAAOwzkSFx
+vmjkI6TZraE3
+-----END CERTIFICATE-----
diff --git a/myenv/lib/python3.9/site-packages/certifi/core.py b/myenv/lib/python3.9/site-packages/certifi/core.py
new file mode 100644
index 0000000..497d938
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/certifi/core.py
@@ -0,0 +1,68 @@
+"""
+certifi.py
+~~~~~~~~~~
+
+This module returns the installation location of cacert.pem or its contents.
+"""
+import os
+import types
+from typing import Union
+
+try:
+    from importlib.resources import path as get_path, read_text
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the file
+        # in cases where we're inside of a zipimport situation until someone
+        # actually calls where(), but we don't want to re-extract the file
+        # on every call of where(), so we'll do it once then store it in a
+        # global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you to
+            # manage the cleanup of this file, so it doesn't actually return a
+            # path, it returns a context manager that will give you the path
+            # when you enter it and will do any cleanup when you leave it. In
+            # the common case of not needing a temporary file, it will just
+            # return the file system location and the __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = get_path("certifi", "cacert.pem")
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+
+        return _CACERT_PATH
+
+
+except ImportError:
+    Package = Union[types.ModuleType, str]
+    Resource = Union[str, "os.PathLike"]
+
+    # This fallback will work for Python versions prior to 3.7 that lack the
+    # importlib.resources module but relies on the existing `where` function
+    # so won't address issues with environments like PyOxidizer that don't set
+    # __file__ on modules.
+    def read_text(
+        package: Package,
+        resource: Resource,
+        encoding: str = 'utf-8',
+        errors: str = 'strict'
+    ) -> str:
+        with open(where(), encoding=encoding) as data:
+            return data.read()
+
+    # If we don't have importlib.resources, then we will just do the old logic
+    # of assuming we're on the filesystem and munge the path directly.
+    def where() -> str:
+        f = os.path.dirname(__file__)
+
+        return os.path.join(f, "cacert.pem")
+
+
+def contents() -> str:
+    return read_text("certifi", "cacert.pem", encoding="ascii")
diff --git a/myenv/lib/python3.9/site-packages/certifi/py.typed b/myenv/lib/python3.9/site-packages/certifi/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/LICENSE
new file mode 100644
index 0000000..29225ee
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/LICENSE
@@ -0,0 +1,26 @@
+
+Except when otherwise stated (look for LICENSE files in directories or
+information at the beginning of each file) all software and
+documentation is licensed as follows: 
+
+    The MIT License
+
+    Permission is hereby granted, free of charge, to any person 
+    obtaining a copy of this software and associated documentation 
+    files (the "Software"), to deal in the Software without 
+    restriction, including without limitation the rights to use, 
+    copy, modify, merge, publish, distribute, sublicense, and/or 
+    sell copies of the Software, and to permit persons to whom the 
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included 
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+    DEALINGS IN THE SOFTWARE.
+
diff --git a/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/METADATA
new file mode 100644
index 0000000..538e679
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/METADATA
@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: cffi
+Version: 1.15.1
+Summary: Foreign Function Interface for Python calling C code.
+Home-page: http://cffi.readthedocs.org
+Author: Armin Rigo, Maciej Fijalkowski
+Author-email: python-cffi@googlegroups.com
+License: MIT
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: License :: OSI Approved :: MIT License
+License-File: LICENSE
+Requires-Dist: pycparser
+
+
+CFFI
+====
+
+Foreign Function Interface for Python calling C code.
+Please see the `Documentation <http://cffi.readthedocs.org/>`_.
+
+Contact
+-------
+
+`Mailing list <https://groups.google.com/forum/#!forum/python-cffi>`_
diff --git a/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/RECORD
new file mode 100644
index 0000000..e19bbf9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/RECORD
@@ -0,0 +1,28 @@
+_cffi_backend.cpython-39-darwin.so,sha256=g3b3EkJ_bteITLFqq1CQ04r_H2TV6SWbw3OcmnViTU0,202424
+cffi/_cffi_include.h,sha256=tKnA1rdSoPHp23FnDL1mDGwFo-Uj6fXfA6vA6kcoEUc,14800
+cffi/backend_ctypes.py,sha256=h5ZIzLc6BFVXnGyc9xPqZWUS7qGy7yFSDqXe68Sa8z4,42454
+cffi/error.py,sha256=v6xTiS4U0kvDcy4h_BDRo5v39ZQuj-IMRYLv5ETddZs,877
+cffi/setuptools_ext.py,sha256=RUR17N5f8gpiQBBlXL34P9FtOu1mhHIaAf3WJlg5S4I,8931
+cffi/_cffi_errors.h,sha256=zQXt7uR_m8gUW-fI2hJg0KoSkJFwXv8RGUkEDZ177dQ,3908
+cffi/__init__.py,sha256=6xB_tafGvhhM5Xvj0Ova3oPC2SEhVlLTEObVLnazeiM,513
+cffi/cffi_opcode.py,sha256=v9RdD_ovA8rCtqsC95Ivki5V667rAOhGgs3fb2q9xpM,5724
+cffi/vengine_gen.py,sha256=5dX7s1DU6pTBOMI6oTVn_8Bnmru_lj932B6b4v29Hlg,26684
+cffi/pkgconfig.py,sha256=LP1w7vmWvmKwyqLaU1Z243FOWGNQMrgMUZrvgFuOlco,4374
+cffi/model.py,sha256=_GH_UF1Rn9vC4AvmgJm6qj7RUXXG3eqKPc8bPxxyBKE,21768
+cffi/ffiplatform.py,sha256=HMXqR8ks2wtdsNxGaWpQ_PyqIvtiuos_vf1qKCy-cwg,4046
+cffi/api.py,sha256=yxJalIePbr1mz_WxAHokSwyP5CVYde44m-nolHnbJNo,42064
+cffi/vengine_cpy.py,sha256=YglN8YS-UaHEv2k2cxgotNWE87dHX20-68EyKoiKUYA,43320
+cffi/_embedding.h,sha256=9tnjF44QRobR8z0FGqAmAZY-wMSBOae1SUPqHccowqc,17680
+cffi/commontypes.py,sha256=QS4uxCDI7JhtTyjh1hlnCA-gynmaszWxJaRRLGkJa1A,2689
+cffi/lock.py,sha256=l9TTdwMIMpi6jDkJGnQgE9cvTIR7CAntIJr8EGHt3pY,747
+cffi/recompiler.py,sha256=YgVYTh2CrXIobo-vMk7_K9mwAXdd_LqB4-IbYABQ488,64598
+cffi/cparser.py,sha256=rO_1pELRw1gI1DE1m4gi2ik5JMfpxouAACLXpRPlVEA,44231
+cffi/verifier.py,sha256=ESwuXWXtXrKEagCKveLRDjFzLNCyaKdqAgAlKREcyhY,11253
+cffi/parse_c_type.h,sha256=OdwQfwM9ktq6vlCB43exFQmxDBtj2MBNdK8LYl15tjw,5976
+cffi-1.15.1.dist-info/LICENSE,sha256=BLgPWwd7vtaICM_rreteNSPyqMmpZJXFh72W3x6sKjM,1294
+cffi-1.15.1.dist-info/WHEEL,sha256=pfjXB0CCNW4PSSqQc2t4Up6p3o0jxBnHy_2o38FQkyE,109
+cffi-1.15.1.dist-info/entry_points.txt,sha256=y6jTxnyeuLnL-XJcDv8uML3n6wyYiGRg8MTp_QGJ9Ho,75
+cffi-1.15.1.dist-info/top_level.txt,sha256=rE7WR3rZfNKxWI9-jn6hsHCAl7MDkB-FmuQbxWjFehQ,19
+cffi-1.15.1.dist-info/METADATA,sha256=KP4G3WmavRgDGwD2b8Y_eDsM1YeV6ckcG6Alz3-D8VY,1144
+cffi-1.15.1.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+cffi-1.15.1.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/WHEEL
new file mode 100644
index 0000000..ef5e11a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_9_x86_64
+
diff --git a/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/entry_points.txt
new file mode 100644
index 0000000..4b0274f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[distutils.setup_keywords]
+cffi_modules = cffi.setuptools_ext:cffi_modules
diff --git a/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/top_level.txt
new file mode 100644
index 0000000..f645779
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi-1.15.1.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+_cffi_backend
+cffi
diff --git a/myenv/lib/python3.9/site-packages/cffi/__init__.py b/myenv/lib/python3.9/site-packages/cffi/__init__.py
new file mode 100644
index 0000000..90e2e65
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/__init__.py
@@ -0,0 +1,14 @@
+__all__ = ['FFI', 'VerificationError', 'VerificationMissing', 'CDefError',
+           'FFIError']
+
+from .api import FFI
+from .error import CDefError, FFIError, VerificationError, VerificationMissing
+from .error import PkgConfigError
+
+__version__ = "1.15.1"
+__version_info__ = (1, 15, 1)
+
+# The verifier module file names are based on the CRC32 of a string that
+# contains the following version number.  It may be older than __version__
+# if nothing is clearly incompatible.
+__version_verifier_modules__ = "0.8.6"
diff --git a/myenv/lib/python3.9/site-packages/cffi/_cffi_errors.h b/myenv/lib/python3.9/site-packages/cffi/_cffi_errors.h
new file mode 100644
index 0000000..158e059
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/_cffi_errors.h
@@ -0,0 +1,149 @@
+#ifndef CFFI_MESSAGEBOX
+# ifdef _MSC_VER
+#  define CFFI_MESSAGEBOX  1
+# else
+#  define CFFI_MESSAGEBOX  0
+# endif
+#endif
+
+
+#if CFFI_MESSAGEBOX
+/* Windows only: logic to take the Python-CFFI embedding logic
+   initialization errors and display them in a background thread
+   with MessageBox.  The idea is that if the whole program closes
+   as a result of this problem, then likely it is already a console
+   program and you can read the stderr output in the console too.
+   If it is not a console program, then it will likely show its own
+   dialog to complain, or generally not abruptly close, and for this
+   case the background thread should stay alive.
+*/
+static void *volatile _cffi_bootstrap_text;
+
+static PyObject *_cffi_start_error_capture(void)
+{
+    PyObject *result = NULL;
+    PyObject *x, *m, *bi;
+
+    if (InterlockedCompareExchangePointer(&_cffi_bootstrap_text,
+            (void *)1, NULL) != NULL)
+        return (PyObject *)1;
+
+    m = PyImport_AddModule("_cffi_error_capture");
+    if (m == NULL)
+        goto error;
+
+    result = PyModule_GetDict(m);
+    if (result == NULL)
+        goto error;
+
+#if PY_MAJOR_VERSION >= 3
+    bi = PyImport_ImportModule("builtins");
+#else
+    bi = PyImport_ImportModule("__builtin__");
+#endif
+    if (bi == NULL)
+        goto error;
+    PyDict_SetItemString(result, "__builtins__", bi);
+    Py_DECREF(bi);
+
+    x = PyRun_String(
+        "import sys\n"
+        "class FileLike:\n"
+        "  def write(self, x):\n"
+        "    try:\n"
+        "      of.write(x)\n"
+        "    except: pass\n"
+        "    self.buf += x\n"
+        "  def flush(self):\n"
+        "    pass\n"
+        "fl = FileLike()\n"
+        "fl.buf = ''\n"
+        "of = sys.stderr\n"
+        "sys.stderr = fl\n"
+        "def done():\n"
+        "  sys.stderr = of\n"
+        "  return fl.buf\n",   /* make sure the returned value stays alive */
+        Py_file_input,
+        result, result);
+    Py_XDECREF(x);
+
+ error:
+    if (PyErr_Occurred())
+    {
+        PyErr_WriteUnraisable(Py_None);
+        PyErr_Clear();
+    }
+    return result;
+}
+
+#pragma comment(lib, "user32.lib")
+
+static DWORD WINAPI _cffi_bootstrap_dialog(LPVOID ignored)
+{
+    Sleep(666);    /* may be interrupted if the whole process is closing */
+#if PY_MAJOR_VERSION >= 3
+    MessageBoxW(NULL, (wchar_t *)_cffi_bootstrap_text,
+                L"Python-CFFI error",
+                MB_OK | MB_ICONERROR);
+#else
+    MessageBoxA(NULL, (char *)_cffi_bootstrap_text,
+                "Python-CFFI error",
+                MB_OK | MB_ICONERROR);
+#endif
+    _cffi_bootstrap_text = NULL;
+    return 0;
+}
+
+static void _cffi_stop_error_capture(PyObject *ecap)
+{
+    PyObject *s;
+    void *text;
+
+    if (ecap == (PyObject *)1)
+        return;
+
+    if (ecap == NULL)
+        goto error;
+
+    s = PyRun_String("done()", Py_eval_input, ecap, ecap);
+    if (s == NULL)
+        goto error;
+
+    /* Show a dialog box, but in a background thread, and
+       never show multiple dialog boxes at once. */
+#if PY_MAJOR_VERSION >= 3
+    text = PyUnicode_AsWideCharString(s, NULL);
+#else
+    text = PyString_AsString(s);
+#endif
+
+    _cffi_bootstrap_text = text;
+
+    if (text != NULL)
+    {
+        HANDLE h;
+        h = CreateThread(NULL, 0, _cffi_bootstrap_dialog,
+                         NULL, 0, NULL);
+        if (h != NULL)
+            CloseHandle(h);
+    }
+    /* decref the string, but it should stay alive as 'fl.buf'
+       in the small module above.  It will really be freed only if
+       we later get another similar error.  So it's a leak of at
+       most one copy of the small module.  That's fine for this
+       situation which is usually a "fatal error" anyway. */
+    Py_DECREF(s);
+    PyErr_Clear();
+    return;
+
+  error:
+    _cffi_bootstrap_text = NULL;
+    PyErr_Clear();
+}
+
+#else
+
+static PyObject *_cffi_start_error_capture(void) { return NULL; }
+static void _cffi_stop_error_capture(PyObject *ecap) { }
+
+#endif
diff --git a/myenv/lib/python3.9/site-packages/cffi/_cffi_include.h b/myenv/lib/python3.9/site-packages/cffi/_cffi_include.h
new file mode 100644
index 0000000..e4c0a67
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/_cffi_include.h
@@ -0,0 +1,385 @@
+#define _CFFI_
+
+/* We try to define Py_LIMITED_API before including Python.h.
+
+   Mess: we can only define it if Py_DEBUG, Py_TRACE_REFS and
+   Py_REF_DEBUG are not defined.  This is a best-effort approximation:
+   we can learn about Py_DEBUG from pyconfig.h, but it is unclear if
+   the same works for the other two macros.  Py_DEBUG implies them,
+   but not the other way around.
+
+   The implementation is messy (issue #350): on Windows, with _MSC_VER,
+   we have to define Py_LIMITED_API even before including pyconfig.h.
+   In that case, we guess what pyconfig.h will do to the macros above,
+   and check our guess after the #include.
+
+   Note that on Windows, with CPython 3.x, you need >= 3.5 and virtualenv
+   version >= 16.0.0.  With older versions of either, you don't get a
+   copy of PYTHON3.DLL in the virtualenv.  We can't check the version of
+   CPython *before* we even include pyconfig.h.  ffi.set_source() puts
+   a ``#define _CFFI_NO_LIMITED_API'' at the start of this file if it is
+   running on Windows < 3.5, as an attempt at fixing it, but that's
+   arguably wrong because it may not be the target version of Python.
+   Still better than nothing I guess.  As another workaround, you can
+   remove the definition of Py_LIMITED_API here.
+
+   See also 'py_limited_api' in cffi/setuptools_ext.py.
+*/
+#if !defined(_CFFI_USE_EMBEDDING) && !defined(Py_LIMITED_API)
+#  ifdef _MSC_VER
+#    if !defined(_DEBUG) && !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) && !defined(_CFFI_NO_LIMITED_API)
+#      define Py_LIMITED_API
+#    endif
+#    include <pyconfig.h>
+     /* sanity-check: Py_LIMITED_API will cause crashes if any of these
+        are also defined.  Normally, the Python file PC/pyconfig.h does not
+        cause any of these to be defined, with the exception that _DEBUG
+        causes Py_DEBUG.  Double-check that. */
+#    ifdef Py_LIMITED_API
+#      if defined(Py_DEBUG)
+#        error "pyconfig.h unexpectedly defines Py_DEBUG, but Py_LIMITED_API is set"
+#      endif
+#      if defined(Py_TRACE_REFS)
+#        error "pyconfig.h unexpectedly defines Py_TRACE_REFS, but Py_LIMITED_API is set"
+#      endif
+#      if defined(Py_REF_DEBUG)
+#        error "pyconfig.h unexpectedly defines Py_REF_DEBUG, but Py_LIMITED_API is set"
+#      endif
+#    endif
+#  else
+#    include <pyconfig.h>
+#    if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) && !defined(_CFFI_NO_LIMITED_API)
+#      define Py_LIMITED_API
+#    endif
+#  endif
+#endif
+
+#include <Python.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <stddef.h>
+#include "parse_c_type.h"
+
+/* this block of #ifs should be kept exactly identical between
+   c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py
+   and cffi/_cffi_include.h */
+#if defined(_MSC_VER)
+# include <malloc.h>   /* for alloca() */
+# if _MSC_VER < 1600   /* MSVC < 2010 */
+   typedef __int8 int8_t;
+   typedef __int16 int16_t;
+   typedef __int32 int32_t;
+   typedef __int64 int64_t;
+   typedef unsigned __int8 uint8_t;
+   typedef unsigned __int16 uint16_t;
+   typedef unsigned __int32 uint32_t;
+   typedef unsigned __int64 uint64_t;
+   typedef __int8 int_least8_t;
+   typedef __int16 int_least16_t;
+   typedef __int32 int_least32_t;
+   typedef __int64 int_least64_t;
+   typedef unsigned __int8 uint_least8_t;
+   typedef unsigned __int16 uint_least16_t;
+   typedef unsigned __int32 uint_least32_t;
+   typedef unsigned __int64 uint_least64_t;
+   typedef __int8 int_fast8_t;
+   typedef __int16 int_fast16_t;
+   typedef __int32 int_fast32_t;
+   typedef __int64 int_fast64_t;
+   typedef unsigned __int8 uint_fast8_t;
+   typedef unsigned __int16 uint_fast16_t;
+   typedef unsigned __int32 uint_fast32_t;
+   typedef unsigned __int64 uint_fast64_t;
+   typedef __int64 intmax_t;
+   typedef unsigned __int64 uintmax_t;
+# else
+#  include <stdint.h>
+# endif
+# if _MSC_VER < 1800   /* MSVC < 2013 */
+#  ifndef __cplusplus
+    typedef unsigned char _Bool;
+#  endif
+# endif
+#else
+# include <stdint.h>
+# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux)
+#  include <alloca.h>
+# endif
+#endif
+
+#ifdef __GNUC__
+# define _CFFI_UNUSED_FN  __attribute__((unused))
+#else
+# define _CFFI_UNUSED_FN  /* nothing */
+#endif
+
+#ifdef __cplusplus
+# ifndef _Bool
+   typedef bool _Bool;   /* semi-hackish: C++ has no _Bool; bool is builtin */
+# endif
+#endif
+
+/**********  CPython-specific section  **********/
+#ifndef PYPY_VERSION
+
+
+#if PY_MAJOR_VERSION >= 3
+# define PyInt_FromLong PyLong_FromLong
+#endif
+
+#define _cffi_from_c_double PyFloat_FromDouble
+#define _cffi_from_c_float PyFloat_FromDouble
+#define _cffi_from_c_long PyInt_FromLong
+#define _cffi_from_c_ulong PyLong_FromUnsignedLong
+#define _cffi_from_c_longlong PyLong_FromLongLong
+#define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong
+#define _cffi_from_c__Bool PyBool_FromLong
+
+#define _cffi_to_c_double PyFloat_AsDouble
+#define _cffi_to_c_float PyFloat_AsDouble
+
+#define _cffi_from_c_int(x, type)                                        \
+    (((type)-1) > 0 ? /* unsigned */                                     \
+        (sizeof(type) < sizeof(long) ?                                   \
+            PyInt_FromLong((long)x) :                                    \
+         sizeof(type) == sizeof(long) ?                                  \
+            PyLong_FromUnsignedLong((unsigned long)x) :                  \
+            PyLong_FromUnsignedLongLong((unsigned long long)x)) :        \
+        (sizeof(type) <= sizeof(long) ?                                  \
+            PyInt_FromLong((long)x) :                                    \
+            PyLong_FromLongLong((long long)x)))
+
+#define _cffi_to_c_int(o, type)                                          \
+    ((type)(                                                             \
+     sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o)        \
+                                         : (type)_cffi_to_c_i8(o)) :     \
+     sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o)       \
+                                         : (type)_cffi_to_c_i16(o)) :    \
+     sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o)       \
+                                         : (type)_cffi_to_c_i32(o)) :    \
+     sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o)       \
+                                         : (type)_cffi_to_c_i64(o)) :    \
+     (Py_FatalError("unsupported size for type " #type), (type)0)))
+
+#define _cffi_to_c_i8                                                    \
+                 ((int(*)(PyObject *))_cffi_exports[1])
+#define _cffi_to_c_u8                                                    \
+                 ((int(*)(PyObject *))_cffi_exports[2])
+#define _cffi_to_c_i16                                                   \
+                 ((int(*)(PyObject *))_cffi_exports[3])
+#define _cffi_to_c_u16                                                   \
+                 ((int(*)(PyObject *))_cffi_exports[4])
+#define _cffi_to_c_i32                                                   \
+                 ((int(*)(PyObject *))_cffi_exports[5])
+#define _cffi_to_c_u32                                                   \
+                 ((unsigned int(*)(PyObject *))_cffi_exports[6])
+#define _cffi_to_c_i64                                                   \
+                 ((long long(*)(PyObject *))_cffi_exports[7])
+#define _cffi_to_c_u64                                                   \
+                 ((unsigned long long(*)(PyObject *))_cffi_exports[8])
+#define _cffi_to_c_char                                                  \
+                 ((int(*)(PyObject *))_cffi_exports[9])
+#define _cffi_from_c_pointer                                             \
+    ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[10])
+#define _cffi_to_c_pointer                                               \
+    ((char *(*)(PyObject *, struct _cffi_ctypedescr *))_cffi_exports[11])
+#define _cffi_get_struct_layout                                          \
+    not used any more
+#define _cffi_restore_errno                                              \
+    ((void(*)(void))_cffi_exports[13])
+#define _cffi_save_errno                                                 \
+    ((void(*)(void))_cffi_exports[14])
+#define _cffi_from_c_char                                                \
+    ((PyObject *(*)(char))_cffi_exports[15])
+#define _cffi_from_c_deref                                               \
+    ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[16])
+#define _cffi_to_c                                                       \
+    ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[17])
+#define _cffi_from_c_struct                                              \
+    ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[18])
+#define _cffi_to_c_wchar_t                                               \
+    ((_cffi_wchar_t(*)(PyObject *))_cffi_exports[19])
+#define _cffi_from_c_wchar_t                                             \
+    ((PyObject *(*)(_cffi_wchar_t))_cffi_exports[20])
+#define _cffi_to_c_long_double                                           \
+    ((long double(*)(PyObject *))_cffi_exports[21])
+#define _cffi_to_c__Bool                                                 \
+    ((_Bool(*)(PyObject *))_cffi_exports[22])
+#define _cffi_prepare_pointer_call_argument                              \
+    ((Py_ssize_t(*)(struct _cffi_ctypedescr *,                           \
+                    PyObject *, char **))_cffi_exports[23])
+#define _cffi_convert_array_from_object                                  \
+    ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[24])
+#define _CFFI_CPIDX  25
+#define _cffi_call_python                                                \
+    ((void(*)(struct _cffi_externpy_s *, char *))_cffi_exports[_CFFI_CPIDX])
+#define _cffi_to_c_wchar3216_t                                           \
+    ((int(*)(PyObject *))_cffi_exports[26])
+#define _cffi_from_c_wchar3216_t                                         \
+    ((PyObject *(*)(int))_cffi_exports[27])
+#define _CFFI_NUM_EXPORTS 28
+
+struct _cffi_ctypedescr;
+
+static void *_cffi_exports[_CFFI_NUM_EXPORTS];
+
+#define _cffi_type(index)   (                           \
+    assert((((uintptr_t)_cffi_types[index]) & 1) == 0), \
+    (struct _cffi_ctypedescr *)_cffi_types[index])
+
+static PyObject *_cffi_init(const char *module_name, Py_ssize_t version,
+                            const struct _cffi_type_context_s *ctx)
+{
+    PyObject *module, *o_arg, *new_module;
+    void *raw[] = {
+        (void *)module_name,
+        (void *)version,
+        (void *)_cffi_exports,
+        (void *)ctx,
+    };
+
+    module = PyImport_ImportModule("_cffi_backend");
+    if (module == NULL)
+        goto failure;
+
+    o_arg = PyLong_FromVoidPtr((void *)raw);
+    if (o_arg == NULL)
+        goto failure;
+
+    new_module = PyObject_CallMethod(
+        module, (char *)"_init_cffi_1_0_external_module", (char *)"O", o_arg);
+
+    Py_DECREF(o_arg);
+    Py_DECREF(module);
+    return new_module;
+
+  failure:
+    Py_XDECREF(module);
+    return NULL;
+}
+
+
+#ifdef HAVE_WCHAR_H
+typedef wchar_t _cffi_wchar_t;
+#else
+typedef uint16_t _cffi_wchar_t;   /* same random pick as _cffi_backend.c */
+#endif
+
+_CFFI_UNUSED_FN static uint16_t _cffi_to_c_char16_t(PyObject *o)
+{
+    if (sizeof(_cffi_wchar_t) == 2)
+        return (uint16_t)_cffi_to_c_wchar_t(o);
+    else
+        return (uint16_t)_cffi_to_c_wchar3216_t(o);
+}
+
+_CFFI_UNUSED_FN static PyObject *_cffi_from_c_char16_t(uint16_t x)
+{
+    if (sizeof(_cffi_wchar_t) == 2)
+        return _cffi_from_c_wchar_t((_cffi_wchar_t)x);
+    else
+        return _cffi_from_c_wchar3216_t((int)x);
+}
+
+_CFFI_UNUSED_FN static int _cffi_to_c_char32_t(PyObject *o)
+{
+    if (sizeof(_cffi_wchar_t) == 4)
+        return (int)_cffi_to_c_wchar_t(o);
+    else
+        return (int)_cffi_to_c_wchar3216_t(o);
+}
+
+_CFFI_UNUSED_FN static PyObject *_cffi_from_c_char32_t(unsigned int x)
+{
+    if (sizeof(_cffi_wchar_t) == 4)
+        return _cffi_from_c_wchar_t((_cffi_wchar_t)x);
+    else
+        return _cffi_from_c_wchar3216_t((int)x);
+}
+
+union _cffi_union_alignment_u {
+    unsigned char m_char;
+    unsigned short m_short;
+    unsigned int m_int;
+    unsigned long m_long;
+    unsigned long long m_longlong;
+    float m_float;
+    double m_double;
+    long double m_longdouble;
+};
+
+struct _cffi_freeme_s {
+    struct _cffi_freeme_s *next;
+    union _cffi_union_alignment_u alignment;
+};
+
+_CFFI_UNUSED_FN static int
+_cffi_convert_array_argument(struct _cffi_ctypedescr *ctptr, PyObject *arg,
+                             char **output_data, Py_ssize_t datasize,
+                             struct _cffi_freeme_s **freeme)
+{
+    char *p;
+    if (datasize < 0)
+        return -1;
+
+    p = *output_data;
+    if (p == NULL) {
+        struct _cffi_freeme_s *fp = (struct _cffi_freeme_s *)PyObject_Malloc(
+            offsetof(struct _cffi_freeme_s, alignment) + (size_t)datasize);
+        if (fp == NULL)
+            return -1;
+        fp->next = *freeme;
+        *freeme = fp;
+        p = *output_data = (char *)&fp->alignment;
+    }
+    memset((void *)p, 0, (size_t)datasize);
+    return _cffi_convert_array_from_object(p, ctptr, arg);
+}
+
+_CFFI_UNUSED_FN static void
+_cffi_free_array_arguments(struct _cffi_freeme_s *freeme)
+{
+    do {
+        void *p = (void *)freeme;
+        freeme = freeme->next;
+        PyObject_Free(p);
+    } while (freeme != NULL);
+}
+
+/**********  end CPython-specific section  **********/
+#else
+_CFFI_UNUSED_FN
+static void (*_cffi_call_python_org)(struct _cffi_externpy_s *, char *);
+# define _cffi_call_python  _cffi_call_python_org
+#endif
+
+
+#define _cffi_array_len(array)   (sizeof(array) / sizeof((array)[0]))
+
+#define _cffi_prim_int(size, sign)                                      \
+    ((size) == 1 ? ((sign) ? _CFFI_PRIM_INT8  : _CFFI_PRIM_UINT8)  :    \
+     (size) == 2 ? ((sign) ? _CFFI_PRIM_INT16 : _CFFI_PRIM_UINT16) :    \
+     (size) == 4 ? ((sign) ? _CFFI_PRIM_INT32 : _CFFI_PRIM_UINT32) :    \
+     (size) == 8 ? ((sign) ? _CFFI_PRIM_INT64 : _CFFI_PRIM_UINT64) :    \
+     _CFFI__UNKNOWN_PRIM)
+
+#define _cffi_prim_float(size)                                          \
+    ((size) == sizeof(float) ? _CFFI_PRIM_FLOAT :                       \
+     (size) == sizeof(double) ? _CFFI_PRIM_DOUBLE :                     \
+     (size) == sizeof(long double) ? _CFFI__UNKNOWN_LONG_DOUBLE :       \
+     _CFFI__UNKNOWN_FLOAT_PRIM)
+
+#define _cffi_check_int(got, got_nonpos, expected)      \
+    ((got_nonpos) == (expected <= 0) &&                 \
+     (got) == (unsigned long long)expected)
+
+#ifdef MS_WIN32
+# define _cffi_stdcall  __stdcall
+#else
+# define _cffi_stdcall  /* nothing */
+#endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/myenv/lib/python3.9/site-packages/cffi/_embedding.h b/myenv/lib/python3.9/site-packages/cffi/_embedding.h
new file mode 100644
index 0000000..8e8df88
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/_embedding.h
@@ -0,0 +1,528 @@
+
+/***** Support code for embedding *****/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if defined(_WIN32)
+#  define CFFI_DLLEXPORT  __declspec(dllexport)
+#elif defined(__GNUC__)
+#  define CFFI_DLLEXPORT  __attribute__((visibility("default")))
+#else
+#  define CFFI_DLLEXPORT  /* nothing */
+#endif
+
+
+/* There are two global variables of type _cffi_call_python_fnptr:
+
+   * _cffi_call_python, which we declare just below, is the one called
+     by ``extern "Python"`` implementations.
+
+   * _cffi_call_python_org, which on CPython is actually part of the
+     _cffi_exports[] array, is the function pointer copied from
+     _cffi_backend.  If _cffi_start_python() fails, then this is set
+     to NULL; otherwise, it should never be NULL.
+
+   After initialization is complete, both are equal.  However, the
+   first one remains equal to &_cffi_start_and_call_python until the
+   very end of initialization, when we are (or should be) sure that
+   concurrent threads also see a completely initialized world, and
+   only then is it changed.
+*/
+#undef _cffi_call_python
+typedef void (*_cffi_call_python_fnptr)(struct _cffi_externpy_s *, char *);
+static void _cffi_start_and_call_python(struct _cffi_externpy_s *, char *);
+static _cffi_call_python_fnptr _cffi_call_python = &_cffi_start_and_call_python;
+
+
+#ifndef _MSC_VER
+   /* --- Assuming a GCC not infinitely old --- */
+# define cffi_compare_and_swap(l,o,n)  __sync_bool_compare_and_swap(l,o,n)
+# define cffi_write_barrier()          __sync_synchronize()
+# if !defined(__amd64__) && !defined(__x86_64__) &&   \
+     !defined(__i386__) && !defined(__i386)
+#   define cffi_read_barrier()         __sync_synchronize()
+# else
+#   define cffi_read_barrier()         (void)0
+# endif
+#else
+   /* --- Windows threads version --- */
+# include <Windows.h>
+# define cffi_compare_and_swap(l,o,n) \
+                               (InterlockedCompareExchangePointer(l,n,o) == (o))
+# define cffi_write_barrier()       InterlockedCompareExchange(&_cffi_dummy,0,0)
+# define cffi_read_barrier()           (void)0
+static volatile LONG _cffi_dummy;
+#endif
+
+#ifdef WITH_THREAD
+# ifndef _MSC_VER
+#  include <pthread.h>
+   static pthread_mutex_t _cffi_embed_startup_lock;
+# else
+   static CRITICAL_SECTION _cffi_embed_startup_lock;
+# endif
+  static char _cffi_embed_startup_lock_ready = 0;
+#endif
+
+static void _cffi_acquire_reentrant_mutex(void)
+{
+    static void *volatile lock = NULL;
+
+    while (!cffi_compare_and_swap(&lock, NULL, (void *)1)) {
+        /* should ideally do a spin loop instruction here, but
+           hard to do it portably and doesn't really matter I
+           think: pthread_mutex_init() should be very fast, and
+           this is only run at start-up anyway. */
+    }
+
+#ifdef WITH_THREAD
+    if (!_cffi_embed_startup_lock_ready) {
+# ifndef _MSC_VER
+        pthread_mutexattr_t attr;
+        pthread_mutexattr_init(&attr);
+        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+        pthread_mutex_init(&_cffi_embed_startup_lock, &attr);
+# else
+        InitializeCriticalSection(&_cffi_embed_startup_lock);
+# endif
+        _cffi_embed_startup_lock_ready = 1;
+    }
+#endif
+
+    while (!cffi_compare_and_swap(&lock, (void *)1, NULL))
+        ;
+
+#ifndef _MSC_VER
+    pthread_mutex_lock(&_cffi_embed_startup_lock);
+#else
+    EnterCriticalSection(&_cffi_embed_startup_lock);
+#endif
+}
+
+static void _cffi_release_reentrant_mutex(void)
+{
+#ifndef _MSC_VER
+    pthread_mutex_unlock(&_cffi_embed_startup_lock);
+#else
+    LeaveCriticalSection(&_cffi_embed_startup_lock);
+#endif
+}
+
+
+/**********  CPython-specific section  **********/
+#ifndef PYPY_VERSION
+
+#include "_cffi_errors.h"
+
+
+#define _cffi_call_python_org  _cffi_exports[_CFFI_CPIDX]
+
+PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(void);   /* forward */
+
+static void _cffi_py_initialize(void)
+{
+    /* XXX use initsigs=0, which "skips initialization registration of
+       signal handlers, which might be useful when Python is
+       embedded" according to the Python docs.  But review and think
+       if it should be a user-controllable setting.
+
+       XXX we should also give a way to write errors to a buffer
+       instead of to stderr.
+
+       XXX if importing 'site' fails, CPython (any version) calls
+       exit().  Should we try to work around this behavior here?
+    */
+    Py_InitializeEx(0);
+}
+
+static int _cffi_initialize_python(void)
+{
+    /* This initializes Python, imports _cffi_backend, and then the
+       present .dll/.so is set up as a CPython C extension module.
+    */
+    int result;
+    PyGILState_STATE state;
+    PyObject *pycode=NULL, *global_dict=NULL, *x;
+    PyObject *builtins;
+
+    state = PyGILState_Ensure();
+
+    /* Call the initxxx() function from the present module.  It will
+       create and initialize us as a CPython extension module, instead
+       of letting the startup Python code do it---it might reimport
+       the same .dll/.so and get maybe confused on some platforms.
+       It might also have troubles locating the .dll/.so again for all
+       I know.
+    */
+    (void)_CFFI_PYTHON_STARTUP_FUNC();
+    if (PyErr_Occurred())
+        goto error;
+
+    /* Now run the Python code provided to ffi.embedding_init_code().
+     */
+    pycode = Py_CompileString(_CFFI_PYTHON_STARTUP_CODE,
+                              "<init code for '" _CFFI_MODULE_NAME "'>",
+                              Py_file_input);
+    if (pycode == NULL)
+        goto error;
+    global_dict = PyDict_New();
+    if (global_dict == NULL)
+        goto error;
+    builtins = PyEval_GetBuiltins();
+    if (builtins == NULL)
+        goto error;
+    if (PyDict_SetItemString(global_dict, "__builtins__", builtins) < 0)
+        goto error;
+    x = PyEval_EvalCode(
+#if PY_MAJOR_VERSION < 3
+                        (PyCodeObject *)
+#endif
+                        pycode, global_dict, global_dict);
+    if (x == NULL)
+        goto error;
+    Py_DECREF(x);
+
+    /* Done!  Now if we've been called from
+       _cffi_start_and_call_python() in an ``extern "Python"``, we can
+       only hope that the Python code did correctly set up the
+       corresponding @ffi.def_extern() function.  Otherwise, the
+       general logic of ``extern "Python"`` functions (inside the
+       _cffi_backend module) will find that the reference is still
+       missing and print an error.
+     */
+    result = 0;
+ done:
+    Py_XDECREF(pycode);
+    Py_XDECREF(global_dict);
+    PyGILState_Release(state);
+    return result;
+
+ error:;
+    {
+        /* Print as much information as potentially useful.
+           Debugging load-time failures with embedding is not fun
+        */
+        PyObject *ecap;
+        PyObject *exception, *v, *tb, *f, *modules, *mod;
+        PyErr_Fetch(&exception, &v, &tb);
+        ecap = _cffi_start_error_capture();
+        f = PySys_GetObject((char *)"stderr");
+        if (f != NULL && f != Py_None) {
+            PyFile_WriteString(
+                "Failed to initialize the Python-CFFI embedding logic:\n\n", f);
+        }
+
+        if (exception != NULL) {
+            PyErr_NormalizeException(&exception, &v, &tb);
+            PyErr_Display(exception, v, tb);
+        }
+        Py_XDECREF(exception);
+        Py_XDECREF(v);
+        Py_XDECREF(tb);
+
+        if (f != NULL && f != Py_None) {
+            PyFile_WriteString("\nFrom: " _CFFI_MODULE_NAME
+                               "\ncompiled with cffi version: 1.15.1"
+                               "\n_cffi_backend module: ", f);
+            modules = PyImport_GetModuleDict();
+            mod = PyDict_GetItemString(modules, "_cffi_backend");
+            if (mod == NULL) {
+                PyFile_WriteString("not loaded", f);
+            }
+            else {
+                v = PyObject_GetAttrString(mod, "__file__");
+                PyFile_WriteObject(v, f, 0);
+                Py_XDECREF(v);
+            }
+            PyFile_WriteString("\nsys.path: ", f);
+            PyFile_WriteObject(PySys_GetObject((char *)"path"), f, 0);
+            PyFile_WriteString("\n\n", f);
+        }
+        _cffi_stop_error_capture(ecap);
+    }
+    result = -1;
+    goto done;
+}
+
+#if PY_VERSION_HEX < 0x03080000
+PyAPI_DATA(char *) _PyParser_TokenNames[];  /* from CPython */
+#endif
+
+static int _cffi_carefully_make_gil(void)
+{
+    /* This does the basic initialization of Python.  It can be called
+       completely concurrently from unrelated threads.  It assumes
+       that we don't hold the GIL before (if it exists), and we don't
+       hold it afterwards.
+
+       (What it really does used to be completely different in Python 2
+       and Python 3, with the Python 2 solution avoiding the spin-lock
+       around the Py_InitializeEx() call.  However, after recent changes
+       to CPython 2.7 (issue #358) it no longer works.  So we use the
+       Python 3 solution everywhere.)
+
+       This initializes Python by calling Py_InitializeEx().
+       Important: this must not be called concurrently at all.
+       So we use a global variable as a simple spin lock.  This global
+       variable must be from 'libpythonX.Y.so', not from this
+       cffi-based extension module, because it must be shared from
+       different cffi-based extension modules.
+
+       In Python < 3.8, we choose
+       _PyParser_TokenNames[0] as a completely arbitrary pointer value
+       that is never written to.  The default is to point to the
+       string "ENDMARKER".  We change it temporarily to point to the
+       next character in that string.  (Yes, I know it's REALLY
+       obscure.)
+
+       In Python >= 3.8, this string array is no longer writable, so
+       instead we pick PyCapsuleType.tp_version_tag.  We can't change
+       Python < 3.8 because someone might use a mixture of cffi
+       embedded modules, some of which were compiled before this file
+       changed.
+    */
+
+#ifdef WITH_THREAD
+# if PY_VERSION_HEX < 0x03080000
+    char *volatile *lock = (char *volatile *)_PyParser_TokenNames;
+    char *old_value, *locked_value;
+
+    while (1) {    /* spin loop */
+        old_value = *lock;
+        locked_value = old_value + 1;
+        if (old_value[0] == 'E') {
+            assert(old_value[1] == 'N');
+            if (cffi_compare_and_swap(lock, old_value, locked_value))
+                break;
+        }
+        else {
+            assert(old_value[0] == 'N');
+            /* should ideally do a spin loop instruction here, but
+               hard to do it portably and doesn't really matter I
+               think: PyEval_InitThreads() should be very fast, and
+               this is only run at start-up anyway. */
+        }
+    }
+# else
+    int volatile *lock = (int volatile *)&PyCapsule_Type.tp_version_tag;
+    int old_value, locked_value;
+    assert(!(PyCapsule_Type.tp_flags & Py_TPFLAGS_HAVE_VERSION_TAG));
+
+    while (1) {    /* spin loop */
+        old_value = *lock;
+        locked_value = -42;
+        if (old_value == 0) {
+            if (cffi_compare_and_swap(lock, old_value, locked_value))
+                break;
+        }
+        else {
+            assert(old_value == locked_value);
+            /* should ideally do a spin loop instruction here, but
+               hard to do it portably and doesn't really matter I
+               think: PyEval_InitThreads() should be very fast, and
+               this is only run at start-up anyway. */
+        }
+    }
+# endif
+#endif
+
+    /* call Py_InitializeEx() */
+    if (!Py_IsInitialized()) {
+        _cffi_py_initialize();
+#if PY_VERSION_HEX < 0x03070000
+        PyEval_InitThreads();
+#endif
+        PyEval_SaveThread();  /* release the GIL */
+        /* the returned tstate must be the one that has been stored into the
+           autoTLSkey by _PyGILState_Init() called from Py_Initialize(). */
+    }
+    else {
+#if PY_VERSION_HEX < 0x03070000
+        /* PyEval_InitThreads() is always a no-op from CPython 3.7 */
+        PyGILState_STATE state = PyGILState_Ensure();
+        PyEval_InitThreads();
+        PyGILState_Release(state);
+#endif
+    }
+
+#ifdef WITH_THREAD
+    /* release the lock */
+    while (!cffi_compare_and_swap(lock, locked_value, old_value))
+        ;
+#endif
+
+    return 0;
+}
+
+/**********  end CPython-specific section  **********/
+
+
+#else
+
+
+/**********  PyPy-specific section  **********/
+
+PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(const void *[]);   /* forward */
+
+static struct _cffi_pypy_init_s {
+    const char *name;
+    void *func;    /* function pointer */
+    const char *code;
+} _cffi_pypy_init = {
+    _CFFI_MODULE_NAME,
+    _CFFI_PYTHON_STARTUP_FUNC,
+    _CFFI_PYTHON_STARTUP_CODE,
+};
+
+extern int pypy_carefully_make_gil(const char *);
+extern int pypy_init_embedded_cffi_module(int, struct _cffi_pypy_init_s *);
+
+static int _cffi_carefully_make_gil(void)
+{
+    return pypy_carefully_make_gil(_CFFI_MODULE_NAME);
+}
+
+static int _cffi_initialize_python(void)
+{
+    return pypy_init_embedded_cffi_module(0xB011, &_cffi_pypy_init);
+}
+
+/**********  end PyPy-specific section  **********/
+
+
+#endif
+
+
+#ifdef __GNUC__
+__attribute__((noinline))
+#endif
+static _cffi_call_python_fnptr _cffi_start_python(void)
+{
+    /* Delicate logic to initialize Python.  This function can be
+       called multiple times concurrently, e.g. when the process calls
+       its first ``extern "Python"`` functions in multiple threads at
+       once.  It can also be called recursively, in which case we must
+       ignore it.  We also have to consider what occurs if several
+       different cffi-based extensions reach this code in parallel
+       threads---it is a different copy of the code, then, and we
+       can't have any shared global variable unless it comes from
+       'libpythonX.Y.so'.
+
+       Idea:
+
+       * _cffi_carefully_make_gil(): "carefully" call
+         PyEval_InitThreads() (possibly with Py_InitializeEx() first).
+
+       * then we use a (local) custom lock to make sure that a call to this
+         cffi-based extension will wait if another call to the *same*
+         extension is running the initialization in another thread.
+         It is reentrant, so that a recursive call will not block, but
+         only one from a different thread.
+
+       * then we grab the GIL and (Python 2) we call Py_InitializeEx().
+         At this point, concurrent calls to Py_InitializeEx() are not
+         possible: we have the GIL.
+
+       * do the rest of the specific initialization, which may
+         temporarily release the GIL but not the custom lock.
+         Only release the custom lock when we are done.
+    */
+    static char called = 0;
+
+    if (_cffi_carefully_make_gil() != 0)
+        return NULL;
+
+    _cffi_acquire_reentrant_mutex();
+
+    /* Here the GIL exists, but we don't have it.  We're only protected
+       from concurrency by the reentrant mutex. */
+
+    /* This file only initializes the embedded module once, the first
+       time this is called, even if there are subinterpreters. */
+    if (!called) {
+        called = 1;  /* invoke _cffi_initialize_python() only once,
+                        but don't set '_cffi_call_python' right now,
+                        otherwise concurrent threads won't call
+                        this function at all (we need them to wait) */
+        if (_cffi_initialize_python() == 0) {
+            /* now initialization is finished.  Switch to the fast-path. */
+
+            /* We would like nobody to see the new value of
+               '_cffi_call_python' without also seeing the rest of the
+               data initialized.  However, this is not possible.  But
+               the new value of '_cffi_call_python' is the function
+               'cffi_call_python()' from _cffi_backend.  So:  */
+            cffi_write_barrier();
+            /* ^^^ we put a write barrier here, and a corresponding
+               read barrier at the start of cffi_call_python().  This
+               ensures that after that read barrier, we see everything
+               done here before the write barrier.
+            */
+
+            assert(_cffi_call_python_org != NULL);
+            _cffi_call_python = (_cffi_call_python_fnptr)_cffi_call_python_org;
+        }
+        else {
+            /* initialization failed.  Reset this to NULL, even if it was
+               already set to some other value.  Future calls to
+               _cffi_start_python() are still forced to occur, and will
+               always return NULL from now on. */
+            _cffi_call_python_org = NULL;
+        }
+    }
+
+    _cffi_release_reentrant_mutex();
+
+    return (_cffi_call_python_fnptr)_cffi_call_python_org;
+}
+
+static
+void _cffi_start_and_call_python(struct _cffi_externpy_s *externpy, char *args)
+{
+    _cffi_call_python_fnptr fnptr;
+    int current_err = errno;
+#ifdef _MSC_VER
+    int current_lasterr = GetLastError();
+#endif
+    fnptr = _cffi_start_python();
+    if (fnptr == NULL) {
+        fprintf(stderr, "function %s() called, but initialization code "
+                        "failed.  Returning 0.\n", externpy->name);
+        memset(args, 0, externpy->size_of_result);
+    }
+#ifdef _MSC_VER
+    SetLastError(current_lasterr);
+#endif
+    errno = current_err;
+
+    if (fnptr != NULL)
+        fnptr(externpy, args);
+}
+
+
+/* The cffi_start_python() function makes sure Python is initialized
+   and our cffi module is set up.  It can be called manually from the
+   user C code.  The same effect is obtained automatically from any
+   dll-exported ``extern "Python"`` function.  This function returns
+   -1 if initialization failed, 0 if all is OK.  */
+_CFFI_UNUSED_FN
+static int cffi_start_python(void)
+{
+    if (_cffi_call_python == &_cffi_start_and_call_python) {
+        if (_cffi_start_python() == NULL)
+            return -1;
+    }
+    cffi_read_barrier();
+    return 0;
+}
+
+#undef cffi_compare_and_swap
+#undef cffi_write_barrier
+#undef cffi_read_barrier
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/myenv/lib/python3.9/site-packages/cffi/api.py b/myenv/lib/python3.9/site-packages/cffi/api.py
new file mode 100644
index 0000000..999a8ae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/api.py
@@ -0,0 +1,965 @@
+import sys, types
+from .lock import allocate_lock
+from .error import CDefError
+from . import model
+
+try:
+    callable
+except NameError:
+    # Python 3.1
+    from collections import Callable
+    callable = lambda x: isinstance(x, Callable)
+
+try:
+    basestring
+except NameError:
+    # Python 3.x
+    basestring = str
+
+_unspecified = object()
+
+
+
+class FFI(object):
+    r'''
+    The main top-level class that you instantiate once, or once per module.
+
+    Example usage:
+
+        ffi = FFI()
+        ffi.cdef("""
+            int printf(const char *, ...);
+        """)
+
+        C = ffi.dlopen(None)   # standard library
+        -or-
+        C = ffi.verify()  # use a C compiler: verify the decl above is right
+
+        C.printf("hello, %s!\n", ffi.new("char[]", "world"))
+    '''
+
+    def __init__(self, backend=None):
+        """Create an FFI instance.  The 'backend' argument is used to
+        select a non-default backend, mostly for tests.
+        """
+        if backend is None:
+            # You need PyPy (>= 2.0 beta), or a CPython (>= 2.6) with
+            # _cffi_backend.so compiled.
+            import _cffi_backend as backend
+            from . import __version__
+            if backend.__version__ != __version__:
+                # bad version!  Try to be as explicit as possible.
+                if hasattr(backend, '__file__'):
+                    # CPython
+                    raise Exception("Version mismatch: this is the 'cffi' package version %s, located in %r.  When we import the top-level '_cffi_backend' extension module, we get version %s, located in %r.  The two versions should be equal; check your installation." % (
+                        __version__, __file__,
+                        backend.__version__, backend.__file__))
+                else:
+                    # PyPy
+                    raise Exception("Version mismatch: this is the 'cffi' package version %s, located in %r.  This interpreter comes with a built-in '_cffi_backend' module, which is version %s.  The two versions should be equal; check your installation." % (
+                        __version__, __file__, backend.__version__))
+            # (If you insist you can also try to pass the option
+            # 'backend=backend_ctypes.CTypesBackend()', but don't
+            # rely on it!  It's probably not going to work well.)
+
+        from . import cparser
+        self._backend = backend
+        self._lock = allocate_lock()
+        self._parser = cparser.Parser()
+        self._cached_btypes = {}
+        self._parsed_types = types.ModuleType('parsed_types').__dict__
+        self._new_types = types.ModuleType('new_types').__dict__
+        self._function_caches = []
+        self._libraries = []
+        self._cdefsources = []
+        self._included_ffis = []
+        self._windows_unicode = None
+        self._init_once_cache = {}
+        self._cdef_version = None
+        self._embedding = None
+        self._typecache = model.get_typecache(backend)
+        if hasattr(backend, 'set_ffi'):
+            backend.set_ffi(self)
+        for name in list(backend.__dict__):
+            if name.startswith('RTLD_'):
+                setattr(self, name, getattr(backend, name))
+        #
+        with self._lock:
+            self.BVoidP = self._get_cached_btype(model.voidp_type)
+            self.BCharA = self._get_cached_btype(model.char_array_type)
+        if isinstance(backend, types.ModuleType):
+            # _cffi_backend: attach these constants to the class
+            if not hasattr(FFI, 'NULL'):
+                FFI.NULL = self.cast(self.BVoidP, 0)
+                FFI.CData, FFI.CType = backend._get_types()
+        else:
+            # ctypes backend: attach these constants to the instance
+            self.NULL = self.cast(self.BVoidP, 0)
+            self.CData, self.CType = backend._get_types()
+        self.buffer = backend.buffer
+
+    def cdef(self, csource, override=False, packed=False, pack=None):
+        """Parse the given C source.  This registers all declared functions,
+        types, and global variables.  The functions and global variables can
+        then be accessed via either 'ffi.dlopen()' or 'ffi.verify()'.
+        The types can be used in 'ffi.new()' and other functions.
+        If 'packed' is specified as True, all structs declared inside this
+        cdef are packed, i.e. laid out without any field alignment at all.
+        Alternatively, 'pack' can be a small integer, and requests for
+        alignment greater than that are ignored (pack=1 is equivalent to
+        packed=True).
+        """
+        self._cdef(csource, override=override, packed=packed, pack=pack)
+
+    def embedding_api(self, csource, packed=False, pack=None):
+        self._cdef(csource, packed=packed, pack=pack, dllexport=True)
+        if self._embedding is None:
+            self._embedding = ''
+
+    def _cdef(self, csource, override=False, **options):
+        if not isinstance(csource, str):    # unicode, on Python 2
+            if not isinstance(csource, basestring):
+                raise TypeError("cdef() argument must be a string")
+            csource = csource.encode('ascii')
+        with self._lock:
+            self._cdef_version = object()
+            self._parser.parse(csource, override=override, **options)
+            self._cdefsources.append(csource)
+            if override:
+                for cache in self._function_caches:
+                    cache.clear()
+            finishlist = self._parser._recomplete
+            if finishlist:
+                self._parser._recomplete = []
+                for tp in finishlist:
+                    tp.finish_backend_type(self, finishlist)
+
+    def dlopen(self, name, flags=0):
+        """Load and return a dynamic library identified by 'name'.
+        The standard C library can be loaded by passing None.
+        Note that functions and types declared by 'ffi.cdef()' are not
+        linked to a particular library, just like C headers; in the
+        library we only look for the actual (untyped) symbols.
+        """
+        if not (isinstance(name, basestring) or
+                name is None or
+                isinstance(name, self.CData)):
+            raise TypeError("dlopen(name): name must be a file name, None, "
+                            "or an already-opened 'void *' handle")
+        with self._lock:
+            lib, function_cache = _make_ffi_library(self, name, flags)
+            self._function_caches.append(function_cache)
+            self._libraries.append(lib)
+        return lib
+
+    def dlclose(self, lib):
+        """Close a library obtained with ffi.dlopen().  After this call,
+        access to functions or variables from the library will fail
+        (possibly with a segmentation fault).
+        """
+        type(lib).__cffi_close__(lib)
+
+    def _typeof_locked(self, cdecl):
+        # call me with the lock!
+        key = cdecl
+        if key in self._parsed_types:
+            return self._parsed_types[key]
+        #
+        if not isinstance(cdecl, str):    # unicode, on Python 2
+            cdecl = cdecl.encode('ascii')
+        #
+        type = self._parser.parse_type(cdecl)
+        really_a_function_type = type.is_raw_function
+        if really_a_function_type:
+            type = type.as_function_pointer()
+        btype = self._get_cached_btype(type)
+        result = btype, really_a_function_type
+        self._parsed_types[key] = result
+        return result
+
+    def _typeof(self, cdecl, consider_function_as_funcptr=False):
+        # string -> ctype object
+        try:
+            result = self._parsed_types[cdecl]
+        except KeyError:
+            with self._lock:
+                result = self._typeof_locked(cdecl)
+        #
+        btype, really_a_function_type = result
+        if really_a_function_type and not consider_function_as_funcptr:
+            raise CDefError("the type %r is a function type, not a "
+                            "pointer-to-function type" % (cdecl,))
+        return btype
+
+    def typeof(self, cdecl):
+        """Parse the C type given as a string and return the
+        corresponding <ctype> object.
+        It can also be used on 'cdata' instance to get its C type.
+        """
+        if isinstance(cdecl, basestring):
+            return self._typeof(cdecl)
+        if isinstance(cdecl, self.CData):
+            return self._backend.typeof(cdecl)
+        if isinstance(cdecl, types.BuiltinFunctionType):
+            res = _builtin_function_type(cdecl)
+            if res is not None:
+                return res
+        if (isinstance(cdecl, types.FunctionType)
+                and hasattr(cdecl, '_cffi_base_type')):
+            with self._lock:
+                return self._get_cached_btype(cdecl._cffi_base_type)
+        raise TypeError(type(cdecl))
+
+    def sizeof(self, cdecl):
+        """Return the size in bytes of the argument.  It can be a
+        string naming a C type, or a 'cdata' instance.
+        """
+        if isinstance(cdecl, basestring):
+            BType = self._typeof(cdecl)
+            return self._backend.sizeof(BType)
+        else:
+            return self._backend.sizeof(cdecl)
+
+    def alignof(self, cdecl):
+        """Return the natural alignment size in bytes of the C type
+        given as a string.
+        """
+        if isinstance(cdecl, basestring):
+            cdecl = self._typeof(cdecl)
+        return self._backend.alignof(cdecl)
+
+    def offsetof(self, cdecl, *fields_or_indexes):
+        """Return the offset of the named field inside the given
+        structure or array, which must be given as a C type name.
+        You can give several field names in case of nested structures.
+        You can also give numeric values which correspond to array
+        items, in case of an array type.
+        """
+        if isinstance(cdecl, basestring):
+            cdecl = self._typeof(cdecl)
+        return self._typeoffsetof(cdecl, *fields_or_indexes)[1]
+
+    def new(self, cdecl, init=None):
+        """Allocate an instance according to the specified C type and
+        return a pointer to it.  The specified C type must be either a
+        pointer or an array: ``new('X *')`` allocates an X and returns
+        a pointer to it, whereas ``new('X[n]')`` allocates an array of
+        n X'es and returns an array referencing it (which works
+        mostly like a pointer, like in C).  You can also use
+        ``new('X[]', n)`` to allocate an array of a non-constant
+        length n.
+
+        The memory is initialized following the rules of declaring a
+        global variable in C: by default it is zero-initialized, but
+        an explicit initializer can be given which can be used to
+        fill all or part of the memory.
+
+        When the returned <cdata> object goes out of scope, the memory
+        is freed.  In other words the returned <cdata> object has
+        ownership of the value of type 'cdecl' that it points to.  This
+        means that the raw data can be used as long as this object is
+        kept alive, but must not be used for a longer time.  Be careful
+        about that when copying the pointer to the memory somewhere
+        else, e.g. into another structure.
+        """
+        if isinstance(cdecl, basestring):
+            cdecl = self._typeof(cdecl)
+        return self._backend.newp(cdecl, init)
+
+    def new_allocator(self, alloc=None, free=None,
+                      should_clear_after_alloc=True):
+        """Return a new allocator, i.e. a function that behaves like ffi.new()
+        but uses the provided low-level 'alloc' and 'free' functions.
+
+        'alloc' is called with the size as argument.  If it returns NULL, a
+        MemoryError is raised.  'free' is called with the result of 'alloc'
+        as argument.  Both can be either Python function or directly C
+        functions.  If 'free' is None, then no free function is called.
+        If both 'alloc' and 'free' are None, the default is used.
+
+        If 'should_clear_after_alloc' is set to False, then the memory
+        returned by 'alloc' is assumed to be already cleared (or you are
+        fine with garbage); otherwise CFFI will clear it.
+        """
+        compiled_ffi = self._backend.FFI()
+        allocator = compiled_ffi.new_allocator(alloc, free,
+                                               should_clear_after_alloc)
+        def allocate(cdecl, init=None):
+            if isinstance(cdecl, basestring):
+                cdecl = self._typeof(cdecl)
+            return allocator(cdecl, init)
+        return allocate
+
+    def cast(self, cdecl, source):
+        """Similar to a C cast: returns an instance of the named C
+        type initialized with the given 'source'.  The source is
+        casted between integers or pointers of any type.
+        """
+        if isinstance(cdecl, basestring):
+            cdecl = self._typeof(cdecl)
+        return self._backend.cast(cdecl, source)
+
+    def string(self, cdata, maxlen=-1):
+        """Return a Python string (or unicode string) from the 'cdata'.
+        If 'cdata' is a pointer or array of characters or bytes, returns
+        the null-terminated string.  The returned string extends until
+        the first null character, or at most 'maxlen' characters.  If
+        'cdata' is an array then 'maxlen' defaults to its length.
+
+        If 'cdata' is a pointer or array of wchar_t, returns a unicode
+        string following the same rules.
+
+        If 'cdata' is a single character or byte or a wchar_t, returns
+        it as a string or unicode string.
+
+        If 'cdata' is an enum, returns the value of the enumerator as a
+        string, or 'NUMBER' if the value is out of range.
+        """
+        return self._backend.string(cdata, maxlen)
+
+    def unpack(self, cdata, length):
+        """Unpack an array of C data of the given length,
+        returning a Python string/unicode/list.
+
+        If 'cdata' is a pointer to 'char', returns a byte string.
+        It does not stop at the first null.  This is equivalent to:
+        ffi.buffer(cdata, length)[:]
+
+        If 'cdata' is a pointer to 'wchar_t', returns a unicode string.
+        'length' is measured in wchar_t's; it is not the size in bytes.
+
+        If 'cdata' is a pointer to anything else, returns a list of
+        'length' items.  This is a faster equivalent to:
+        [cdata[i] for i in range(length)]
+        """
+        return self._backend.unpack(cdata, length)
+
+   #def buffer(self, cdata, size=-1):
+   #    """Return a read-write buffer object that references the raw C data
+   #    pointed to by the given 'cdata'.  The 'cdata' must be a pointer or
+   #    an array.  Can be passed to functions expecting a buffer, or directly
+   #    manipulated with:
+   #
+   #        buf[:]          get a copy of it in a regular string, or
+   #        buf[idx]        as a single character
+   #        buf[:] = ...
+   #        buf[idx] = ...  change the content
+   #    """
+   #    note that 'buffer' is a type, set on this instance by __init__
+
+    def from_buffer(self, cdecl, python_buffer=_unspecified,
+                    require_writable=False):
+        """Return a cdata of the given type pointing to the data of the
+        given Python object, which must support the buffer interface.
+        Note that this is not meant to be used on the built-in types
+        str or unicode (you can build 'char[]' arrays explicitly)
+        but only on objects containing large quantities of raw data
+        in some other format, like 'array.array' or numpy arrays.
+
+        The first argument is optional and default to 'char[]'.
+        """
+        if python_buffer is _unspecified:
+            cdecl, python_buffer = self.BCharA, cdecl
+        elif isinstance(cdecl, basestring):
+            cdecl = self._typeof(cdecl)
+        return self._backend.from_buffer(cdecl, python_buffer,
+                                         require_writable)
+
+    def memmove(self, dest, src, n):
+        """ffi.memmove(dest, src, n) copies n bytes of memory from src to dest.
+
+        Like the C function memmove(), the memory areas may overlap;
+        apart from that it behaves like the C function memcpy().
+
+        'src' can be any cdata ptr or array, or any Python buffer object.
+        'dest' can be any cdata ptr or array, or a writable Python buffer
+        object.  The size to copy, 'n', is always measured in bytes.
+
+        Unlike other methods, this one supports all Python buffer including
+        byte strings and bytearrays---but it still does not support
+        non-contiguous buffers.
+        """
+        return self._backend.memmove(dest, src, n)
+
+    def callback(self, cdecl, python_callable=None, error=None, onerror=None):
+        """Return a callback object or a decorator making such a
+        callback object.  'cdecl' must name a C function pointer type.
+        The callback invokes the specified 'python_callable' (which may
+        be provided either directly or via a decorator).  Important: the
+        callback object must be manually kept alive for as long as the
+        callback may be invoked from the C level.
+        """
+        def callback_decorator_wrap(python_callable):
+            if not callable(python_callable):
+                raise TypeError("the 'python_callable' argument "
+                                "is not callable")
+            return self._backend.callback(cdecl, python_callable,
+                                          error, onerror)
+        if isinstance(cdecl, basestring):
+            cdecl = self._typeof(cdecl, consider_function_as_funcptr=True)
+        if python_callable is None:
+            return callback_decorator_wrap                # decorator mode
+        else:
+            return callback_decorator_wrap(python_callable)  # direct mode
+
+    def getctype(self, cdecl, replace_with=''):
+        """Return a string giving the C type 'cdecl', which may be itself
+        a string or a <ctype> object.  If 'replace_with' is given, it gives
+        extra text to append (or insert for more complicated C types), like
+        a variable name, or '*' to get actually the C type 'pointer-to-cdecl'.
+        """
+        if isinstance(cdecl, basestring):
+            cdecl = self._typeof(cdecl)
+        replace_with = replace_with.strip()
+        if (replace_with.startswith('*')
+                and '&[' in self._backend.getcname(cdecl, '&')):
+            replace_with = '(%s)' % replace_with
+        elif replace_with and not replace_with[0] in '[(':
+            replace_with = ' ' + replace_with
+        return self._backend.getcname(cdecl, replace_with)
+
+    def gc(self, cdata, destructor, size=0):
+        """Return a new cdata object that points to the same
+        data.  Later, when this new cdata object is garbage-collected,
+        'destructor(old_cdata_object)' will be called.
+
+        The optional 'size' gives an estimate of the size, used to
+        trigger the garbage collection more eagerly.  So far only used
+        on PyPy.  It tells the GC that the returned object keeps alive
+        roughly 'size' bytes of external memory.
+        """
+        return self._backend.gcp(cdata, destructor, size)
+
+    def _get_cached_btype(self, type):
+        assert self._lock.acquire(False) is False
+        # call me with the lock!
+        try:
+            BType = self._cached_btypes[type]
+        except KeyError:
+            finishlist = []
+            BType = type.get_cached_btype(self, finishlist)
+            for type in finishlist:
+                type.finish_backend_type(self, finishlist)
+        return BType
+
+    def verify(self, source='', tmpdir=None, **kwargs):
+        """Verify that the current ffi signatures compile on this
+        machine, and return a dynamic library object.  The dynamic
+        library can be used to call functions and access global
+        variables declared in this 'ffi'.  The library is compiled
+        by the C compiler: it gives you C-level API compatibility
+        (including calling macros).  This is unlike 'ffi.dlopen()',
+        which requires binary compatibility in the signatures.
+        """
+        from .verifier import Verifier, _caller_dir_pycache
+        #
+        # If set_unicode(True) was called, insert the UNICODE and
+        # _UNICODE macro declarations
+        if self._windows_unicode:
+            self._apply_windows_unicode(kwargs)
+        #
+        # Set the tmpdir here, and not in Verifier.__init__: it picks
+        # up the caller's directory, which we want to be the caller of
+        # ffi.verify(), as opposed to the caller of Veritier().
+        tmpdir = tmpdir or _caller_dir_pycache()
+        #
+        # Make a Verifier() and use it to load the library.
+        self.verifier = Verifier(self, source, tmpdir, **kwargs)
+        lib = self.verifier.load_library()
+        #
+        # Save the loaded library for keep-alive purposes, even
+        # if the caller doesn't keep it alive itself (it should).
+        self._libraries.append(lib)
+        return lib
+
+    def _get_errno(self):
+        return self._backend.get_errno()
+    def _set_errno(self, errno):
+        self._backend.set_errno(errno)
+    errno = property(_get_errno, _set_errno, None,
+                     "the value of 'errno' from/to the C calls")
+
+    def getwinerror(self, code=-1):
+        return self._backend.getwinerror(code)
+
+    def _pointer_to(self, ctype):
+        with self._lock:
+            return model.pointer_cache(self, ctype)
+
+    def addressof(self, cdata, *fields_or_indexes):
+        """Return the address of a <cdata 'struct-or-union'>.
+        If 'fields_or_indexes' are given, returns the address of that
+        field or array item in the structure or array, recursively in
+        case of nested structures.
+        """
+        try:
+            ctype = self._backend.typeof(cdata)
+        except TypeError:
+            if '__addressof__' in type(cdata).__dict__:
+                return type(cdata).__addressof__(cdata, *fields_or_indexes)
+            raise
+        if fields_or_indexes:
+            ctype, offset = self._typeoffsetof(ctype, *fields_or_indexes)
+        else:
+            if ctype.kind == "pointer":
+                raise TypeError("addressof(pointer)")
+            offset = 0
+        ctypeptr = self._pointer_to(ctype)
+        return self._backend.rawaddressof(ctypeptr, cdata, offset)
+
+    def _typeoffsetof(self, ctype, field_or_index, *fields_or_indexes):
+        ctype, offset = self._backend.typeoffsetof(ctype, field_or_index)
+        for field1 in fields_or_indexes:
+            ctype, offset1 = self._backend.typeoffsetof(ctype, field1, 1)
+            offset += offset1
+        return ctype, offset
+
+    def include(self, ffi_to_include):
+        """Includes the typedefs, structs, unions and enums defined
+        in another FFI instance.  Usage is similar to a #include in C,
+        where a part of the program might include types defined in
+        another part for its own usage.  Note that the include()
+        method has no effect on functions, constants and global
+        variables, which must anyway be accessed directly from the
+        lib object returned by the original FFI instance.
+        """
+        if not isinstance(ffi_to_include, FFI):
+            raise TypeError("ffi.include() expects an argument that is also of"
+                            " type cffi.FFI, not %r" % (
+                                type(ffi_to_include).__name__,))
+        if ffi_to_include is self:
+            raise ValueError("self.include(self)")
+        with ffi_to_include._lock:
+            with self._lock:
+                self._parser.include(ffi_to_include._parser)
+                self._cdefsources.append('[')
+                self._cdefsources.extend(ffi_to_include._cdefsources)
+                self._cdefsources.append(']')
+                self._included_ffis.append(ffi_to_include)
+
+    def new_handle(self, x):
+        return self._backend.newp_handle(self.BVoidP, x)
+
+    def from_handle(self, x):
+        return self._backend.from_handle(x)
+
+    def release(self, x):
+        self._backend.release(x)
+
+    def set_unicode(self, enabled_flag):
+        """Windows: if 'enabled_flag' is True, enable the UNICODE and
+        _UNICODE defines in C, and declare the types like TCHAR and LPTCSTR
+        to be (pointers to) wchar_t.  If 'enabled_flag' is False,
+        declare these types to be (pointers to) plain 8-bit characters.
+        This is mostly for backward compatibility; you usually want True.
+        """
+        if self._windows_unicode is not None:
+            raise ValueError("set_unicode() can only be called once")
+        enabled_flag = bool(enabled_flag)
+        if enabled_flag:
+            self.cdef("typedef wchar_t TBYTE;"
+                      "typedef wchar_t TCHAR;"
+                      "typedef const wchar_t *LPCTSTR;"
+                      "typedef const wchar_t *PCTSTR;"
+                      "typedef wchar_t *LPTSTR;"
+                      "typedef wchar_t *PTSTR;"
+                      "typedef TBYTE *PTBYTE;"
+                      "typedef TCHAR *PTCHAR;")
+        else:
+            self.cdef("typedef char TBYTE;"
+                      "typedef char TCHAR;"
+                      "typedef const char *LPCTSTR;"
+                      "typedef const char *PCTSTR;"
+                      "typedef char *LPTSTR;"
+                      "typedef char *PTSTR;"
+                      "typedef TBYTE *PTBYTE;"
+                      "typedef TCHAR *PTCHAR;")
+        self._windows_unicode = enabled_flag
+
+    def _apply_windows_unicode(self, kwds):
+        defmacros = kwds.get('define_macros', ())
+        if not isinstance(defmacros, (list, tuple)):
+            raise TypeError("'define_macros' must be a list or tuple")
+        defmacros = list(defmacros) + [('UNICODE', '1'),
+                                       ('_UNICODE', '1')]
+        kwds['define_macros'] = defmacros
+
+    def _apply_embedding_fix(self, kwds):
+        # must include an argument like "-lpython2.7" for the compiler
+        def ensure(key, value):
+            lst = kwds.setdefault(key, [])
+            if value not in lst:
+                lst.append(value)
+        #
+        if '__pypy__' in sys.builtin_module_names:
+            import os
+            if sys.platform == "win32":
+                # we need 'libpypy-c.lib'.  Current distributions of
+                # pypy (>= 4.1) contain it as 'libs/python27.lib'.
+                pythonlib = "python{0[0]}{0[1]}".format(sys.version_info)
+                if hasattr(sys, 'prefix'):
+                    ensure('library_dirs', os.path.join(sys.prefix, 'libs'))
+            else:
+                # we need 'libpypy-c.{so,dylib}', which should be by
+                # default located in 'sys.prefix/bin' for installed
+                # systems.
+                if sys.version_info < (3,):
+                    pythonlib = "pypy-c"
+                else:
+                    pythonlib = "pypy3-c"
+                if hasattr(sys, 'prefix'):
+                    ensure('library_dirs', os.path.join(sys.prefix, 'bin'))
+            # On uninstalled pypy's, the libpypy-c is typically found in
+            # .../pypy/goal/.
+            if hasattr(sys, 'prefix'):
+                ensure('library_dirs', os.path.join(sys.prefix, 'pypy', 'goal'))
+        else:
+            if sys.platform == "win32":
+                template = "python%d%d"
+                if hasattr(sys, 'gettotalrefcount'):
+                    template += '_d'
+            else:
+                try:
+                    import sysconfig
+                except ImportError:    # 2.6
+                    from distutils import sysconfig
+                template = "python%d.%d"
+                if sysconfig.get_config_var('DEBUG_EXT'):
+                    template += sysconfig.get_config_var('DEBUG_EXT')
+            pythonlib = (template %
+                    (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
+            if hasattr(sys, 'abiflags'):
+                pythonlib += sys.abiflags
+        ensure('libraries', pythonlib)
+        if sys.platform == "win32":
+            ensure('extra_link_args', '/MANIFEST')
+
+    def set_source(self, module_name, source, source_extension='.c', **kwds):
+        import os
+        if hasattr(self, '_assigned_source'):
+            raise ValueError("set_source() cannot be called several times "
+                             "per ffi object")
+        if not isinstance(module_name, basestring):
+            raise TypeError("'module_name' must be a string")
+        if os.sep in module_name or (os.altsep and os.altsep in module_name):
+            raise ValueError("'module_name' must not contain '/': use a dotted "
+                             "name to make a 'package.module' location")
+        self._assigned_source = (str(module_name), source,
+                                 source_extension, kwds)
+
+    def set_source_pkgconfig(self, module_name, pkgconfig_libs, source,
+                             source_extension='.c', **kwds):
+        from . import pkgconfig
+        if not isinstance(pkgconfig_libs, list):
+            raise TypeError("the pkgconfig_libs argument must be a list "
+                            "of package names")
+        kwds2 = pkgconfig.flags_from_pkgconfig(pkgconfig_libs)
+        pkgconfig.merge_flags(kwds, kwds2)
+        self.set_source(module_name, source, source_extension, **kwds)
+
+    def distutils_extension(self, tmpdir='build', verbose=True):
+        from distutils.dir_util import mkpath
+        from .recompiler import recompile
+        #
+        if not hasattr(self, '_assigned_source'):
+            if hasattr(self, 'verifier'):     # fallback, 'tmpdir' ignored
+                return self.verifier.get_extension()
+            raise ValueError("set_source() must be called before"
+                             " distutils_extension()")
+        module_name, source, source_extension, kwds = self._assigned_source
+        if source is None:
+            raise TypeError("distutils_extension() is only for C extension "
+                            "modules, not for dlopen()-style pure Python "
+                            "modules")
+        mkpath(tmpdir)
+        ext, updated = recompile(self, module_name,
+                                 source, tmpdir=tmpdir, extradir=tmpdir,
+                                 source_extension=source_extension,
+                                 call_c_compiler=False, **kwds)
+        if verbose:
+            if updated:
+                sys.stderr.write("regenerated: %r\n" % (ext.sources[0],))
+            else:
+                sys.stderr.write("not modified: %r\n" % (ext.sources[0],))
+        return ext
+
+    def emit_c_code(self, filename):
+        from .recompiler import recompile
+        #
+        if not hasattr(self, '_assigned_source'):
+            raise ValueError("set_source() must be called before emit_c_code()")
+        module_name, source, source_extension, kwds = self._assigned_source
+        if source is None:
+            raise TypeError("emit_c_code() is only for C extension modules, "
+                            "not for dlopen()-style pure Python modules")
+        recompile(self, module_name, source,
+                  c_file=filename, call_c_compiler=False, **kwds)
+
+    def emit_python_code(self, filename):
+        from .recompiler import recompile
+        #
+        if not hasattr(self, '_assigned_source'):
+            raise ValueError("set_source() must be called before emit_c_code()")
+        module_name, source, source_extension, kwds = self._assigned_source
+        if source is not None:
+            raise TypeError("emit_python_code() is only for dlopen()-style "
+                            "pure Python modules, not for C extension modules")
+        recompile(self, module_name, source,
+                  c_file=filename, call_c_compiler=False, **kwds)
+
+    def compile(self, tmpdir='.', verbose=0, target=None, debug=None):
+        """The 'target' argument gives the final file name of the
+        compiled DLL.  Use '*' to force distutils' choice, suitable for
+        regular CPython C API modules.  Use a file name ending in '.*'
+        to ask for the system's default extension for dynamic libraries
+        (.so/.dll/.dylib).
+
+        The default is '*' when building a non-embedded C API extension,
+        and (module_name + '.*') when building an embedded library.
+        """
+        from .recompiler import recompile
+        #
+        if not hasattr(self, '_assigned_source'):
+            raise ValueError("set_source() must be called before compile()")
+        module_name, source, source_extension, kwds = self._assigned_source
+        return recompile(self, module_name, source, tmpdir=tmpdir,
+                         target=target, source_extension=source_extension,
+                         compiler_verbose=verbose, debug=debug, **kwds)
+
+    def init_once(self, func, tag):
+        # Read _init_once_cache[tag], which is either (False, lock) if
+        # we're calling the function now in some thread, or (True, result).
+        # Don't call setdefault() in most cases, to avoid allocating and
+        # immediately freeing a lock; but still use setdefaut() to avoid
+        # races.
+        try:
+            x = self._init_once_cache[tag]
+        except KeyError:
+            x = self._init_once_cache.setdefault(tag, (False, allocate_lock()))
+        # Common case: we got (True, result), so we return the result.
+        if x[0]:
+            return x[1]
+        # Else, it's a lock.  Acquire it to serialize the following tests.
+        with x[1]:
+            # Read again from _init_once_cache the current status.
+            x = self._init_once_cache[tag]
+            if x[0]:
+                return x[1]
+            # Call the function and store the result back.
+            result = func()
+            self._init_once_cache[tag] = (True, result)
+        return result
+
+    def embedding_init_code(self, pysource):
+        if self._embedding:
+            raise ValueError("embedding_init_code() can only be called once")
+        # fix 'pysource' before it gets dumped into the C file:
+        # - remove empty lines at the beginning, so it starts at "line 1"
+        # - dedent, if all non-empty lines are indented
+        # - check for SyntaxErrors
+        import re
+        match = re.match(r'\s*\n', pysource)
+        if match:
+            pysource = pysource[match.end():]
+        lines = pysource.splitlines() or ['']
+        prefix = re.match(r'\s*', lines[0]).group()
+        for i in range(1, len(lines)):
+            line = lines[i]
+            if line.rstrip():
+                while not line.startswith(prefix):
+                    prefix = prefix[:-1]
+        i = len(prefix)
+        lines = [line[i:]+'\n' for line in lines]
+        pysource = ''.join(lines)
+        #
+        compile(pysource, "cffi_init", "exec")
+        #
+        self._embedding = pysource
+
+    def def_extern(self, *args, **kwds):
+        raise ValueError("ffi.def_extern() is only available on API-mode FFI "
+                         "objects")
+
+    def list_types(self):
+        """Returns the user type names known to this FFI instance.
+        This returns a tuple containing three lists of names:
+        (typedef_names, names_of_structs, names_of_unions)
+        """
+        typedefs = []
+        structs = []
+        unions = []
+        for key in self._parser._declarations:
+            if key.startswith('typedef '):
+                typedefs.append(key[8:])
+            elif key.startswith('struct '):
+                structs.append(key[7:])
+            elif key.startswith('union '):
+                unions.append(key[6:])
+        typedefs.sort()
+        structs.sort()
+        unions.sort()
+        return (typedefs, structs, unions)
+
+
+def _load_backend_lib(backend, name, flags):
+    import os
+    if not isinstance(name, basestring):
+        if sys.platform != "win32" or name is not None:
+            return backend.load_library(name, flags)
+        name = "c"    # Windows: load_library(None) fails, but this works
+                      # on Python 2 (backward compatibility hack only)
+    first_error = None
+    if '.' in name or '/' in name or os.sep in name:
+        try:
+            return backend.load_library(name, flags)
+        except OSError as e:
+            first_error = e
+    import ctypes.util
+    path = ctypes.util.find_library(name)
+    if path is None:
+        if name == "c" and sys.platform == "win32" and sys.version_info >= (3,):
+            raise OSError("dlopen(None) cannot work on Windows for Python 3 "
+                          "(see http://bugs.python.org/issue23606)")
+        msg = ("ctypes.util.find_library() did not manage "
+               "to locate a library called %r" % (name,))
+        if first_error is not None:
+            msg = "%s.  Additionally, %s" % (first_error, msg)
+        raise OSError(msg)
+    return backend.load_library(path, flags)
+
+def _make_ffi_library(ffi, libname, flags):
+    backend = ffi._backend
+    backendlib = _load_backend_lib(backend, libname, flags)
+    #
+    def accessor_function(name):
+        key = 'function ' + name
+        tp, _ = ffi._parser._declarations[key]
+        BType = ffi._get_cached_btype(tp)
+        value = backendlib.load_function(BType, name)
+        library.__dict__[name] = value
+    #
+    def accessor_variable(name):
+        key = 'variable ' + name
+        tp, _ = ffi._parser._declarations[key]
+        BType = ffi._get_cached_btype(tp)
+        read_variable = backendlib.read_variable
+        write_variable = backendlib.write_variable
+        setattr(FFILibrary, name, property(
+            lambda self: read_variable(BType, name),
+            lambda self, value: write_variable(BType, name, value)))
+    #
+    def addressof_var(name):
+        try:
+            return addr_variables[name]
+        except KeyError:
+            with ffi._lock:
+                if name not in addr_variables:
+                    key = 'variable ' + name
+                    tp, _ = ffi._parser._declarations[key]
+                    BType = ffi._get_cached_btype(tp)
+                    if BType.kind != 'array':
+                        BType = model.pointer_cache(ffi, BType)
+                    p = backendlib.load_function(BType, name)
+                    addr_variables[name] = p
+            return addr_variables[name]
+    #
+    def accessor_constant(name):
+        raise NotImplementedError("non-integer constant '%s' cannot be "
+                                  "accessed from a dlopen() library" % (name,))
+    #
+    def accessor_int_constant(name):
+        library.__dict__[name] = ffi._parser._int_constants[name]
+    #
+    accessors = {}
+    accessors_version = [False]
+    addr_variables = {}
+    #
+    def update_accessors():
+        if accessors_version[0] is ffi._cdef_version:
+            return
+        #
+        for key, (tp, _) in ffi._parser._declarations.items():
+            if not isinstance(tp, model.EnumType):
+                tag, name = key.split(' ', 1)
+                if tag == 'function':
+                    accessors[name] = accessor_function
+                elif tag == 'variable':
+                    accessors[name] = accessor_variable
+                elif tag == 'constant':
+                    accessors[name] = accessor_constant
+            else:
+                for i, enumname in enumerate(tp.enumerators):
+                    def accessor_enum(name, tp=tp, i=i):
+                        tp.check_not_partial()
+                        library.__dict__[name] = tp.enumvalues[i]
+                    accessors[enumname] = accessor_enum
+        for name in ffi._parser._int_constants:
+            accessors.setdefault(name, accessor_int_constant)
+        accessors_version[0] = ffi._cdef_version
+    #
+    def make_accessor(name):
+        with ffi._lock:
+            if name in library.__dict__ or name in FFILibrary.__dict__:
+                return    # added by another thread while waiting for the lock
+            if name not in accessors:
+                update_accessors()
+                if name not in accessors:
+                    raise AttributeError(name)
+            accessors[name](name)
+    #
+    class FFILibrary(object):
+        def __getattr__(self, name):
+            make_accessor(name)
+            return getattr(self, name)
+        def __setattr__(self, name, value):
+            try:
+                property = getattr(self.__class__, name)
+            except AttributeError:
+                make_accessor(name)
+                setattr(self, name, value)
+            else:
+                property.__set__(self, value)
+        def __dir__(self):
+            with ffi._lock:
+                update_accessors()
+                return accessors.keys()
+        def __addressof__(self, name):
+            if name in library.__dict__:
+                return library.__dict__[name]
+            if name in FFILibrary.__dict__:
+                return addressof_var(name)
+            make_accessor(name)
+            if name in library.__dict__:
+                return library.__dict__[name]
+            if name in FFILibrary.__dict__:
+                return addressof_var(name)
+            raise AttributeError("cffi library has no function or "
+                                 "global variable named '%s'" % (name,))
+        def __cffi_close__(self):
+            backendlib.close_lib()
+            self.__dict__.clear()
+    #
+    if isinstance(libname, basestring):
+        try:
+            if not isinstance(libname, str):    # unicode, on Python 2
+                libname = libname.encode('utf-8')
+            FFILibrary.__name__ = 'FFILibrary_%s' % libname
+        except UnicodeError:
+            pass
+    library = FFILibrary()
+    return library, library.__dict__
+
+def _builtin_function_type(func):
+    # a hack to make at least ffi.typeof(builtin_function) work,
+    # if the builtin function was obtained by 'vengine_cpy'.
+    import sys
+    try:
+        module = sys.modules[func.__module__]
+        ffi = module._cffi_original_ffi
+        types_of_builtin_funcs = module._cffi_types_of_builtin_funcs
+        tp = types_of_builtin_funcs[func]
+    except (KeyError, AttributeError, TypeError):
+        return None
+    else:
+        with ffi._lock:
+            return ffi._get_cached_btype(tp)
diff --git a/myenv/lib/python3.9/site-packages/cffi/backend_ctypes.py b/myenv/lib/python3.9/site-packages/cffi/backend_ctypes.py
new file mode 100644
index 0000000..e7956a7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/backend_ctypes.py
@@ -0,0 +1,1121 @@
+import ctypes, ctypes.util, operator, sys
+from . import model
+
+if sys.version_info < (3,):
+    bytechr = chr
+else:
+    unicode = str
+    long = int
+    xrange = range
+    bytechr = lambda num: bytes([num])
+
+class CTypesType(type):
+    pass
+
+class CTypesData(object):
+    __metaclass__ = CTypesType
+    __slots__ = ['__weakref__']
+    __name__ = '<cdata>'
+
+    def __init__(self, *args):
+        raise TypeError("cannot instantiate %r" % (self.__class__,))
+
+    @classmethod
+    def _newp(cls, init):
+        raise TypeError("expected a pointer or array ctype, got '%s'"
+                        % (cls._get_c_name(),))
+
+    @staticmethod
+    def _to_ctypes(value):
+        raise TypeError
+
+    @classmethod
+    def _arg_to_ctypes(cls, *value):
+        try:
+            ctype = cls._ctype
+        except AttributeError:
+            raise TypeError("cannot create an instance of %r" % (cls,))
+        if value:
+            res = cls._to_ctypes(*value)
+            if not isinstance(res, ctype):
+                res = cls._ctype(res)
+        else:
+            res = cls._ctype()
+        return res
+
+    @classmethod
+    def _create_ctype_obj(cls, init):
+        if init is None:
+            return cls._arg_to_ctypes()
+        else:
+            return cls._arg_to_ctypes(init)
+
+    @staticmethod
+    def _from_ctypes(ctypes_value):
+        raise TypeError
+
+    @classmethod
+    def _get_c_name(cls, replace_with=''):
+        return cls._reftypename.replace(' &', replace_with)
+
+    @classmethod
+    def _fix_class(cls):
+        cls.__name__ = 'CData<%s>' % (cls._get_c_name(),)
+        cls.__qualname__ = 'CData<%s>' % (cls._get_c_name(),)
+        cls.__module__ = 'ffi'
+
+    def _get_own_repr(self):
+        raise NotImplementedError
+
+    def _addr_repr(self, address):
+        if address == 0:
+            return 'NULL'
+        else:
+            if address < 0:
+                address += 1 << (8*ctypes.sizeof(ctypes.c_void_p))
+            return '0x%x' % address
+
+    def __repr__(self, c_name=None):
+        own = self._get_own_repr()
+        return '<cdata %r %s>' % (c_name or self._get_c_name(), own)
+
+    def _convert_to_address(self, BClass):
+        if BClass is None:
+            raise TypeError("cannot convert %r to an address" % (
+                self._get_c_name(),))
+        else:
+            raise TypeError("cannot convert %r to %r" % (
+                self._get_c_name(), BClass._get_c_name()))
+
+    @classmethod
+    def _get_size(cls):
+        return ctypes.sizeof(cls._ctype)
+
+    def _get_size_of_instance(self):
+        return ctypes.sizeof(self._ctype)
+
+    @classmethod
+    def _cast_from(cls, source):
+        raise TypeError("cannot cast to %r" % (cls._get_c_name(),))
+
+    def _cast_to_integer(self):
+        return self._convert_to_address(None)
+
+    @classmethod
+    def _alignment(cls):
+        return ctypes.alignment(cls._ctype)
+
+    def __iter__(self):
+        raise TypeError("cdata %r does not support iteration" % (
+            self._get_c_name()),)
+
+    def _make_cmp(name):
+        cmpfunc = getattr(operator, name)
+        def cmp(self, other):
+            v_is_ptr = not isinstance(self, CTypesGenericPrimitive)
+            w_is_ptr = (isinstance(other, CTypesData) and
+                           not isinstance(other, CTypesGenericPrimitive))
+            if v_is_ptr and w_is_ptr:
+                return cmpfunc(self._convert_to_address(None),
+                               other._convert_to_address(None))
+            elif v_is_ptr or w_is_ptr:
+                return NotImplemented
+            else:
+                if isinstance(self, CTypesGenericPrimitive):
+                    self = self._value
+                if isinstance(other, CTypesGenericPrimitive):
+                    other = other._value
+                return cmpfunc(self, other)
+        cmp.func_name = name
+        return cmp
+
+    __eq__ = _make_cmp('__eq__')
+    __ne__ = _make_cmp('__ne__')
+    __lt__ = _make_cmp('__lt__')
+    __le__ = _make_cmp('__le__')
+    __gt__ = _make_cmp('__gt__')
+    __ge__ = _make_cmp('__ge__')
+
+    def __hash__(self):
+        return hash(self._convert_to_address(None))
+
+    def _to_string(self, maxlen):
+        raise TypeError("string(): %r" % (self,))
+
+
+class CTypesGenericPrimitive(CTypesData):
+    __slots__ = []
+
+    def __hash__(self):
+        return hash(self._value)
+
+    def _get_own_repr(self):
+        return repr(self._from_ctypes(self._value))
+
+
+class CTypesGenericArray(CTypesData):
+    __slots__ = []
+
+    @classmethod
+    def _newp(cls, init):
+        return cls(init)
+
+    def __iter__(self):
+        for i in xrange(len(self)):
+            yield self[i]
+
+    def _get_own_repr(self):
+        return self._addr_repr(ctypes.addressof(self._blob))
+
+
+class CTypesGenericPtr(CTypesData):
+    __slots__ = ['_address', '_as_ctype_ptr']
+    _automatic_casts = False
+    kind = "pointer"
+
+    @classmethod
+    def _newp(cls, init):
+        return cls(init)
+
+    @classmethod
+    def _cast_from(cls, source):
+        if source is None:
+            address = 0
+        elif isinstance(source, CTypesData):
+            address = source._cast_to_integer()
+        elif isinstance(source, (int, long)):
+            address = source
+        else:
+            raise TypeError("bad type for cast to %r: %r" %
+                            (cls, type(source).__name__))
+        return cls._new_pointer_at(address)
+
+    @classmethod
+    def _new_pointer_at(cls, address):
+        self = cls.__new__(cls)
+        self._address = address
+        self._as_ctype_ptr = ctypes.cast(address, cls._ctype)
+        return self
+
+    def _get_own_repr(self):
+        try:
+            return self._addr_repr(self._address)
+        except AttributeError:
+            return '???'
+
+    def _cast_to_integer(self):
+        return self._address
+
+    def __nonzero__(self):
+        return bool(self._address)
+    __bool__ = __nonzero__
+
+    @classmethod
+    def _to_ctypes(cls, value):
+        if not isinstance(value, CTypesData):
+            raise TypeError("unexpected %s object" % type(value).__name__)
+        address = value._convert_to_address(cls)
+        return ctypes.cast(address, cls._ctype)
+
+    @classmethod
+    def _from_ctypes(cls, ctypes_ptr):
+        address = ctypes.cast(ctypes_ptr, ctypes.c_void_p).value or 0
+        return cls._new_pointer_at(address)
+
+    @classmethod
+    def _initialize(cls, ctypes_ptr, value):
+        if value:
+            ctypes_ptr.contents = cls._to_ctypes(value).contents
+
+    def _convert_to_address(self, BClass):
+        if (BClass in (self.__class__, None) or BClass._automatic_casts
+            or self._automatic_casts):
+            return self._address
+        else:
+            return CTypesData._convert_to_address(self, BClass)
+
+
+class CTypesBaseStructOrUnion(CTypesData):
+    __slots__ = ['_blob']
+
+    @classmethod
+    def _create_ctype_obj(cls, init):
+        # may be overridden
+        raise TypeError("cannot instantiate opaque type %s" % (cls,))
+
+    def _get_own_repr(self):
+        return self._addr_repr(ctypes.addressof(self._blob))
+
+    @classmethod
+    def _offsetof(cls, fieldname):
+        return getattr(cls._ctype, fieldname).offset
+
+    def _convert_to_address(self, BClass):
+        if getattr(BClass, '_BItem', None) is self.__class__:
+            return ctypes.addressof(self._blob)
+        else:
+            return CTypesData._convert_to_address(self, BClass)
+
+    @classmethod
+    def _from_ctypes(cls, ctypes_struct_or_union):
+        self = cls.__new__(cls)
+        self._blob = ctypes_struct_or_union
+        return self
+
+    @classmethod
+    def _to_ctypes(cls, value):
+        return value._blob
+
+    def __repr__(self, c_name=None):
+        return CTypesData.__repr__(self, c_name or self._get_c_name(' &'))
+
+
+class CTypesBackend(object):
+
+    PRIMITIVE_TYPES = {
+        'char': ctypes.c_char,
+        'short': ctypes.c_short,
+        'int': ctypes.c_int,
+        'long': ctypes.c_long,
+        'long long': ctypes.c_longlong,
+        'signed char': ctypes.c_byte,
+        'unsigned char': ctypes.c_ubyte,
+        'unsigned short': ctypes.c_ushort,
+        'unsigned int': ctypes.c_uint,
+        'unsigned long': ctypes.c_ulong,
+        'unsigned long long': ctypes.c_ulonglong,
+        'float': ctypes.c_float,
+        'double': ctypes.c_double,
+        '_Bool': ctypes.c_bool,
+        }
+
+    for _name in ['unsigned long long', 'unsigned long',
+                  'unsigned int', 'unsigned short', 'unsigned char']:
+        _size = ctypes.sizeof(PRIMITIVE_TYPES[_name])
+        PRIMITIVE_TYPES['uint%d_t' % (8*_size)] = PRIMITIVE_TYPES[_name]
+        if _size == ctypes.sizeof(ctypes.c_void_p):
+            PRIMITIVE_TYPES['uintptr_t'] = PRIMITIVE_TYPES[_name]
+        if _size == ctypes.sizeof(ctypes.c_size_t):
+            PRIMITIVE_TYPES['size_t'] = PRIMITIVE_TYPES[_name]
+
+    for _name in ['long long', 'long', 'int', 'short', 'signed char']:
+        _size = ctypes.sizeof(PRIMITIVE_TYPES[_name])
+        PRIMITIVE_TYPES['int%d_t' % (8*_size)] = PRIMITIVE_TYPES[_name]
+        if _size == ctypes.sizeof(ctypes.c_void_p):
+            PRIMITIVE_TYPES['intptr_t'] = PRIMITIVE_TYPES[_name]
+            PRIMITIVE_TYPES['ptrdiff_t'] = PRIMITIVE_TYPES[_name]
+        if _size == ctypes.sizeof(ctypes.c_size_t):
+            PRIMITIVE_TYPES['ssize_t'] = PRIMITIVE_TYPES[_name]
+
+
+    def __init__(self):
+        self.RTLD_LAZY = 0   # not supported anyway by ctypes
+        self.RTLD_NOW  = 0
+        self.RTLD_GLOBAL = ctypes.RTLD_GLOBAL
+        self.RTLD_LOCAL = ctypes.RTLD_LOCAL
+
+    def set_ffi(self, ffi):
+        self.ffi = ffi
+
+    def _get_types(self):
+        return CTypesData, CTypesType
+
+    def load_library(self, path, flags=0):
+        cdll = ctypes.CDLL(path, flags)
+        return CTypesLibrary(self, cdll)
+
+    def new_void_type(self):
+        class CTypesVoid(CTypesData):
+            __slots__ = []
+            _reftypename = 'void &'
+            @staticmethod
+            def _from_ctypes(novalue):
+                return None
+            @staticmethod
+            def _to_ctypes(novalue):
+                if novalue is not None:
+                    raise TypeError("None expected, got %s object" %
+                                    (type(novalue).__name__,))
+                return None
+        CTypesVoid._fix_class()
+        return CTypesVoid
+
+    def new_primitive_type(self, name):
+        if name == 'wchar_t':
+            raise NotImplementedError(name)
+        ctype = self.PRIMITIVE_TYPES[name]
+        if name == 'char':
+            kind = 'char'
+        elif name in ('float', 'double'):
+            kind = 'float'
+        else:
+            if name in ('signed char', 'unsigned char'):
+                kind = 'byte'
+            elif name == '_Bool':
+                kind = 'bool'
+            else:
+                kind = 'int'
+            is_signed = (ctype(-1).value == -1)
+        #
+        def _cast_source_to_int(source):
+            if isinstance(source, (int, long, float)):
+                source = int(source)
+            elif isinstance(source, CTypesData):
+                source = source._cast_to_integer()
+            elif isinstance(source, bytes):
+                source = ord(source)
+            elif source is None:
+                source = 0
+            else:
+                raise TypeError("bad type for cast to %r: %r" %
+                                (CTypesPrimitive, type(source).__name__))
+            return source
+        #
+        kind1 = kind
+        class CTypesPrimitive(CTypesGenericPrimitive):
+            __slots__ = ['_value']
+            _ctype = ctype
+            _reftypename = '%s &' % name
+            kind = kind1
+
+            def __init__(self, value):
+                self._value = value
+
+            @staticmethod
+            def _create_ctype_obj(init):
+                if init is None:
+                    return ctype()
+                return ctype(CTypesPrimitive._to_ctypes(init))
+
+            if kind == 'int' or kind == 'byte':
+                @classmethod
+                def _cast_from(cls, source):
+                    source = _cast_source_to_int(source)
+                    source = ctype(source).value     # cast within range
+                    return cls(source)
+                def __int__(self):
+                    return self._value
+
+            if kind == 'bool':
+                @classmethod
+                def _cast_from(cls, source):
+                    if not isinstance(source, (int, long, float)):
+                        source = _cast_source_to_int(source)
+                    return cls(bool(source))
+                def __int__(self):
+                    return int(self._value)
+
+            if kind == 'char':
+                @classmethod
+                def _cast_from(cls, source):
+                    source = _cast_source_to_int(source)
+                    source = bytechr(source & 0xFF)
+                    return cls(source)
+                def __int__(self):
+                    return ord(self._value)
+
+            if kind == 'float':
+                @classmethod
+                def _cast_from(cls, source):
+                    if isinstance(source, float):
+                        pass
+                    elif isinstance(source, CTypesGenericPrimitive):
+                        if hasattr(source, '__float__'):
+                            source = float(source)
+                        else:
+                            source = int(source)
+                    else:
+                        source = _cast_source_to_int(source)
+                    source = ctype(source).value     # fix precision
+                    return cls(source)
+                def __int__(self):
+                    return int(self._value)
+                def __float__(self):
+                    return self._value
+
+            _cast_to_integer = __int__
+
+            if kind == 'int' or kind == 'byte' or kind == 'bool':
+                @staticmethod
+                def _to_ctypes(x):
+                    if not isinstance(x, (int, long)):
+                        if isinstance(x, CTypesData):
+                            x = int(x)
+                        else:
+                            raise TypeError("integer expected, got %s" %
+                                            type(x).__name__)
+                    if ctype(x).value != x:
+                        if not is_signed and x < 0:
+                            raise OverflowError("%s: negative integer" % name)
+                        else:
+                            raise OverflowError("%s: integer out of bounds"
+                                                % name)
+                    return x
+
+            if kind == 'char':
+                @staticmethod
+                def _to_ctypes(x):
+                    if isinstance(x, bytes) and len(x) == 1:
+                        return x
+                    if isinstance(x, CTypesPrimitive):    # <CData <char>>
+                        return x._value
+                    raise TypeError("character expected, got %s" %
+                                    type(x).__name__)
+                def __nonzero__(self):
+                    return ord(self._value) != 0
+            else:
+                def __nonzero__(self):
+                    return self._value != 0
+            __bool__ = __nonzero__
+
+            if kind == 'float':
+                @staticmethod
+                def _to_ctypes(x):
+                    if not isinstance(x, (int, long, float, CTypesData)):
+                        raise TypeError("float expected, got %s" %
+                                        type(x).__name__)
+                    return ctype(x).value
+
+            @staticmethod
+            def _from_ctypes(value):
+                return getattr(value, 'value', value)
+
+            @staticmethod
+            def _initialize(blob, init):
+                blob.value = CTypesPrimitive._to_ctypes(init)
+
+            if kind == 'char':
+                def _to_string(self, maxlen):
+                    return self._value
+            if kind == 'byte':
+                def _to_string(self, maxlen):
+                    return chr(self._value & 0xff)
+        #
+        CTypesPrimitive._fix_class()
+        return CTypesPrimitive
+
+    def new_pointer_type(self, BItem):
+        getbtype = self.ffi._get_cached_btype
+        if BItem is getbtype(model.PrimitiveType('char')):
+            kind = 'charp'
+        elif BItem in (getbtype(model.PrimitiveType('signed char')),
+                       getbtype(model.PrimitiveType('unsigned char'))):
+            kind = 'bytep'
+        elif BItem is getbtype(model.void_type):
+            kind = 'voidp'
+        else:
+            kind = 'generic'
+        #
+        class CTypesPtr(CTypesGenericPtr):
+            __slots__ = ['_own']
+            if kind == 'charp':
+                __slots__ += ['__as_strbuf']
+            _BItem = BItem
+            if hasattr(BItem, '_ctype'):
+                _ctype = ctypes.POINTER(BItem._ctype)
+                _bitem_size = ctypes.sizeof(BItem._ctype)
+            else:
+                _ctype = ctypes.c_void_p
+            if issubclass(BItem, CTypesGenericArray):
+                _reftypename = BItem._get_c_name('(* &)')
+            else:
+                _reftypename = BItem._get_c_name(' * &')
+
+            def __init__(self, init):
+                ctypeobj = BItem._create_ctype_obj(init)
+                if kind == 'charp':
+                    self.__as_strbuf = ctypes.create_string_buffer(
+                        ctypeobj.value + b'\x00')
+                    self._as_ctype_ptr = ctypes.cast(
+                        self.__as_strbuf, self._ctype)
+                else:
+                    self._as_ctype_ptr = ctypes.pointer(ctypeobj)
+                self._address = ctypes.cast(self._as_ctype_ptr,
+                                            ctypes.c_void_p).value
+                self._own = True
+
+            def __add__(self, other):
+                if isinstance(other, (int, long)):
+                    return self._new_pointer_at(self._address +
+                                                other * self._bitem_size)
+                else:
+                    return NotImplemented
+
+            def __sub__(self, other):
+                if isinstance(other, (int, long)):
+                    return self._new_pointer_at(self._address -
+                                                other * self._bitem_size)
+                elif type(self) is type(other):
+                    return (self._address - other._address) // self._bitem_size
+                else:
+                    return NotImplemented
+
+            def __getitem__(self, index):
+                if getattr(self, '_own', False) and index != 0:
+                    raise IndexError
+                return BItem._from_ctypes(self._as_ctype_ptr[index])
+
+            def __setitem__(self, index, value):
+                self._as_ctype_ptr[index] = BItem._to_ctypes(value)
+
+            if kind == 'charp' or kind == 'voidp':
+                @classmethod
+                def _arg_to_ctypes(cls, *value):
+                    if value and isinstance(value[0], bytes):
+                        return ctypes.c_char_p(value[0])
+                    else:
+                        return super(CTypesPtr, cls)._arg_to_ctypes(*value)
+
+            if kind == 'charp' or kind == 'bytep':
+                def _to_string(self, maxlen):
+                    if maxlen < 0:
+                        maxlen = sys.maxsize
+                    p = ctypes.cast(self._as_ctype_ptr,
+                                    ctypes.POINTER(ctypes.c_char))
+                    n = 0
+                    while n < maxlen and p[n] != b'\x00':
+                        n += 1
+                    return b''.join([p[i] for i in range(n)])
+
+            def _get_own_repr(self):
+                if getattr(self, '_own', False):
+                    return 'owning %d bytes' % (
+                        ctypes.sizeof(self._as_ctype_ptr.contents),)
+                return super(CTypesPtr, self)._get_own_repr()
+        #
+        if (BItem is self.ffi._get_cached_btype(model.void_type) or
+            BItem is self.ffi._get_cached_btype(model.PrimitiveType('char'))):
+            CTypesPtr._automatic_casts = True
+        #
+        CTypesPtr._fix_class()
+        return CTypesPtr
+
+    def new_array_type(self, CTypesPtr, length):
+        if length is None:
+            brackets = ' &[]'
+        else:
+            brackets = ' &[%d]' % length
+        BItem = CTypesPtr._BItem
+        getbtype = self.ffi._get_cached_btype
+        if BItem is getbtype(model.PrimitiveType('char')):
+            kind = 'char'
+        elif BItem in (getbtype(model.PrimitiveType('signed char')),
+                       getbtype(model.PrimitiveType('unsigned char'))):
+            kind = 'byte'
+        else:
+            kind = 'generic'
+        #
+        class CTypesArray(CTypesGenericArray):
+            __slots__ = ['_blob', '_own']
+            if length is not None:
+                _ctype = BItem._ctype * length
+            else:
+                __slots__.append('_ctype')
+            _reftypename = BItem._get_c_name(brackets)
+            _declared_length = length
+            _CTPtr = CTypesPtr
+
+            def __init__(self, init):
+                if length is None:
+                    if isinstance(init, (int, long)):
+                        len1 = init
+                        init = None
+                    elif kind == 'char' and isinstance(init, bytes):
+                        len1 = len(init) + 1    # extra null
+                    else:
+                        init = tuple(init)
+                        len1 = len(init)
+                    self._ctype = BItem._ctype * len1
+                self._blob = self._ctype()
+                self._own = True
+                if init is not None:
+                    self._initialize(self._blob, init)
+
+            @staticmethod
+            def _initialize(blob, init):
+                if isinstance(init, bytes):
+                    init = [init[i:i+1] for i in range(len(init))]
+                else:
+                    if isinstance(init, CTypesGenericArray):
+                        if (len(init) != len(blob) or
+                            not isinstance(init, CTypesArray)):
+                            raise TypeError("length/type mismatch: %s" % (init,))
+                    init = tuple(init)
+                if len(init) > len(blob):
+                    raise IndexError("too many initializers")
+                addr = ctypes.cast(blob, ctypes.c_void_p).value
+                PTR = ctypes.POINTER(BItem._ctype)
+                itemsize = ctypes.sizeof(BItem._ctype)
+                for i, value in enumerate(init):
+                    p = ctypes.cast(addr + i * itemsize, PTR)
+                    BItem._initialize(p.contents, value)
+
+            def __len__(self):
+                return len(self._blob)
+
+            def __getitem__(self, index):
+                if not (0 <= index < len(self._blob)):
+                    raise IndexError
+                return BItem._from_ctypes(self._blob[index])
+
+            def __setitem__(self, index, value):
+                if not (0 <= index < len(self._blob)):
+                    raise IndexError
+                self._blob[index] = BItem._to_ctypes(value)
+
+            if kind == 'char' or kind == 'byte':
+                def _to_string(self, maxlen):
+                    if maxlen < 0:
+                        maxlen = len(self._blob)
+                    p = ctypes.cast(self._blob,
+                                    ctypes.POINTER(ctypes.c_char))
+                    n = 0
+                    while n < maxlen and p[n] != b'\x00':
+                        n += 1
+                    return b''.join([p[i] for i in range(n)])
+
+            def _get_own_repr(self):
+                if getattr(self, '_own', False):
+                    return 'owning %d bytes' % (ctypes.sizeof(self._blob),)
+                return super(CTypesArray, self)._get_own_repr()
+
+            def _convert_to_address(self, BClass):
+                if BClass in (CTypesPtr, None) or BClass._automatic_casts:
+                    return ctypes.addressof(self._blob)
+                else:
+                    return CTypesData._convert_to_address(self, BClass)
+
+            @staticmethod
+            def _from_ctypes(ctypes_array):
+                self = CTypesArray.__new__(CTypesArray)
+                self._blob = ctypes_array
+                return self
+
+            @staticmethod
+            def _arg_to_ctypes(value):
+                return CTypesPtr._arg_to_ctypes(value)
+
+            def __add__(self, other):
+                if isinstance(other, (int, long)):
+                    return CTypesPtr._new_pointer_at(
+                        ctypes.addressof(self._blob) +
+                        other * ctypes.sizeof(BItem._ctype))
+                else:
+                    return NotImplemented
+
+            @classmethod
+            def _cast_from(cls, source):
+                raise NotImplementedError("casting to %r" % (
+                    cls._get_c_name(),))
+        #
+        CTypesArray._fix_class()
+        return CTypesArray
+
+    def _new_struct_or_union(self, kind, name, base_ctypes_class):
+        #
+        class struct_or_union(base_ctypes_class):
+            pass
+        struct_or_union.__name__ = '%s_%s' % (kind, name)
+        kind1 = kind
+        #
+        class CTypesStructOrUnion(CTypesBaseStructOrUnion):
+            __slots__ = ['_blob']
+            _ctype = struct_or_union
+            _reftypename = '%s &' % (name,)
+            _kind = kind = kind1
+        #
+        CTypesStructOrUnion._fix_class()
+        return CTypesStructOrUnion
+
+    def new_struct_type(self, name):
+        return self._new_struct_or_union('struct', name, ctypes.Structure)
+
+    def new_union_type(self, name):
+        return self._new_struct_or_union('union', name, ctypes.Union)
+
+    def complete_struct_or_union(self, CTypesStructOrUnion, fields, tp,
+                                 totalsize=-1, totalalignment=-1, sflags=0,
+                                 pack=0):
+        if totalsize >= 0 or totalalignment >= 0:
+            raise NotImplementedError("the ctypes backend of CFFI does not support "
+                                      "structures completed by verify(); please "
+                                      "compile and install the _cffi_backend module.")
+        struct_or_union = CTypesStructOrUnion._ctype
+        fnames = [fname for (fname, BField, bitsize) in fields]
+        btypes = [BField for (fname, BField, bitsize) in fields]
+        bitfields = [bitsize for (fname, BField, bitsize) in fields]
+        #
+        bfield_types = {}
+        cfields = []
+        for (fname, BField, bitsize) in fields:
+            if bitsize < 0:
+                cfields.append((fname, BField._ctype))
+                bfield_types[fname] = BField
+            else:
+                cfields.append((fname, BField._ctype, bitsize))
+                bfield_types[fname] = Ellipsis
+        if sflags & 8:
+            struct_or_union._pack_ = 1
+        elif pack:
+            struct_or_union._pack_ = pack
+        struct_or_union._fields_ = cfields
+        CTypesStructOrUnion._bfield_types = bfield_types
+        #
+        @staticmethod
+        def _create_ctype_obj(init):
+            result = struct_or_union()
+            if init is not None:
+                initialize(result, init)
+            return result
+        CTypesStructOrUnion._create_ctype_obj = _create_ctype_obj
+        #
+        def initialize(blob, init):
+            if is_union:
+                if len(init) > 1:
+                    raise ValueError("union initializer: %d items given, but "
+                                    "only one supported (use a dict if needed)"
+                                     % (len(init),))
+            if not isinstance(init, dict):
+                if isinstance(init, (bytes, unicode)):
+                    raise TypeError("union initializer: got a str")
+                init = tuple(init)
+                if len(init) > len(fnames):
+                    raise ValueError("too many values for %s initializer" %
+                                     CTypesStructOrUnion._get_c_name())
+                init = dict(zip(fnames, init))
+            addr = ctypes.addressof(blob)
+            for fname, value in init.items():
+                BField, bitsize = name2fieldtype[fname]
+                assert bitsize < 0, \
+                       "not implemented: initializer with bit fields"
+                offset = CTypesStructOrUnion._offsetof(fname)
+                PTR = ctypes.POINTER(BField._ctype)
+                p = ctypes.cast(addr + offset, PTR)
+                BField._initialize(p.contents, value)
+        is_union = CTypesStructOrUnion._kind == 'union'
+        name2fieldtype = dict(zip(fnames, zip(btypes, bitfields)))
+        #
+        for fname, BField, bitsize in fields:
+            if fname == '':
+                raise NotImplementedError("nested anonymous structs/unions")
+            if hasattr(CTypesStructOrUnion, fname):
+                raise ValueError("the field name %r conflicts in "
+                                 "the ctypes backend" % fname)
+            if bitsize < 0:
+                def getter(self, fname=fname, BField=BField,
+                           offset=CTypesStructOrUnion._offsetof(fname),
+                           PTR=ctypes.POINTER(BField._ctype)):
+                    addr = ctypes.addressof(self._blob)
+                    p = ctypes.cast(addr + offset, PTR)
+                    return BField._from_ctypes(p.contents)
+                def setter(self, value, fname=fname, BField=BField):
+                    setattr(self._blob, fname, BField._to_ctypes(value))
+                #
+                if issubclass(BField, CTypesGenericArray):
+                    setter = None
+                    if BField._declared_length == 0:
+                        def getter(self, fname=fname, BFieldPtr=BField._CTPtr,
+                                   offset=CTypesStructOrUnion._offsetof(fname),
+                                   PTR=ctypes.POINTER(BField._ctype)):
+                            addr = ctypes.addressof(self._blob)
+                            p = ctypes.cast(addr + offset, PTR)
+                            return BFieldPtr._from_ctypes(p)
+                #
+            else:
+                def getter(self, fname=fname, BField=BField):
+                    return BField._from_ctypes(getattr(self._blob, fname))
+                def setter(self, value, fname=fname, BField=BField):
+                    # xxx obscure workaround
+                    value = BField._to_ctypes(value)
+                    oldvalue = getattr(self._blob, fname)
+                    setattr(self._blob, fname, value)
+                    if value != getattr(self._blob, fname):
+                        setattr(self._blob, fname, oldvalue)
+                        raise OverflowError("value too large for bitfield")
+            setattr(CTypesStructOrUnion, fname, property(getter, setter))
+        #
+        CTypesPtr = self.ffi._get_cached_btype(model.PointerType(tp))
+        for fname in fnames:
+            if hasattr(CTypesPtr, fname):
+                raise ValueError("the field name %r conflicts in "
+                                 "the ctypes backend" % fname)
+            def getter(self, fname=fname):
+                return getattr(self[0], fname)
+            def setter(self, value, fname=fname):
+                setattr(self[0], fname, value)
+            setattr(CTypesPtr, fname, property(getter, setter))
+
+    def new_function_type(self, BArgs, BResult, has_varargs):
+        nameargs = [BArg._get_c_name() for BArg in BArgs]
+        if has_varargs:
+            nameargs.append('...')
+        nameargs = ', '.join(nameargs)
+        #
+        class CTypesFunctionPtr(CTypesGenericPtr):
+            __slots__ = ['_own_callback', '_name']
+            _ctype = ctypes.CFUNCTYPE(getattr(BResult, '_ctype', None),
+                                      *[BArg._ctype for BArg in BArgs],
+                                      use_errno=True)
+            _reftypename = BResult._get_c_name('(* &)(%s)' % (nameargs,))
+
+            def __init__(self, init, error=None):
+                # create a callback to the Python callable init()
+                import traceback
+                assert not has_varargs, "varargs not supported for callbacks"
+                if getattr(BResult, '_ctype', None) is not None:
+                    error = BResult._from_ctypes(
+                        BResult._create_ctype_obj(error))
+                else:
+                    error = None
+                def callback(*args):
+                    args2 = []
+                    for arg, BArg in zip(args, BArgs):
+                        args2.append(BArg._from_ctypes(arg))
+                    try:
+                        res2 = init(*args2)
+                        res2 = BResult._to_ctypes(res2)
+                    except:
+                        traceback.print_exc()
+                        res2 = error
+                    if issubclass(BResult, CTypesGenericPtr):
+                        if res2:
+                            res2 = ctypes.cast(res2, ctypes.c_void_p).value
+                                # .value: http://bugs.python.org/issue1574593
+                        else:
+                            res2 = None
+                    #print repr(res2)
+                    return res2
+                if issubclass(BResult, CTypesGenericPtr):
+                    # The only pointers callbacks can return are void*s:
+                    # http://bugs.python.org/issue5710
+                    callback_ctype = ctypes.CFUNCTYPE(
+                        ctypes.c_void_p,
+                        *[BArg._ctype for BArg in BArgs],
+                        use_errno=True)
+                else:
+                    callback_ctype = CTypesFunctionPtr._ctype
+                self._as_ctype_ptr = callback_ctype(callback)
+                self._address = ctypes.cast(self._as_ctype_ptr,
+                                            ctypes.c_void_p).value
+                self._own_callback = init
+
+            @staticmethod
+            def _initialize(ctypes_ptr, value):
+                if value:
+                    raise NotImplementedError("ctypes backend: not supported: "
+                                          "initializers for function pointers")
+
+            def __repr__(self):
+                c_name = getattr(self, '_name', None)
+                if c_name:
+                    i = self._reftypename.index('(* &)')
+                    if self._reftypename[i-1] not in ' )*':
+                        c_name = ' ' + c_name
+                    c_name = self._reftypename.replace('(* &)', c_name)
+                return CTypesData.__repr__(self, c_name)
+
+            def _get_own_repr(self):
+                if getattr(self, '_own_callback', None) is not None:
+                    return 'calling %r' % (self._own_callback,)
+                return super(CTypesFunctionPtr, self)._get_own_repr()
+
+            def __call__(self, *args):
+                if has_varargs:
+                    assert len(args) >= len(BArgs)
+                    extraargs = args[len(BArgs):]
+                    args = args[:len(BArgs)]
+                else:
+                    assert len(args) == len(BArgs)
+                ctypes_args = []
+                for arg, BArg in zip(args, BArgs):
+                    ctypes_args.append(BArg._arg_to_ctypes(arg))
+                if has_varargs:
+                    for i, arg in enumerate(extraargs):
+                        if arg is None:
+                            ctypes_args.append(ctypes.c_void_p(0))  # NULL
+                            continue
+                        if not isinstance(arg, CTypesData):
+                            raise TypeError(
+                                "argument %d passed in the variadic part "
+                                "needs to be a cdata object (got %s)" %
+                                (1 + len(BArgs) + i, type(arg).__name__))
+                        ctypes_args.append(arg._arg_to_ctypes(arg))
+                result = self._as_ctype_ptr(*ctypes_args)
+                return BResult._from_ctypes(result)
+        #
+        CTypesFunctionPtr._fix_class()
+        return CTypesFunctionPtr
+
+    def new_enum_type(self, name, enumerators, enumvalues, CTypesInt):
+        assert isinstance(name, str)
+        reverse_mapping = dict(zip(reversed(enumvalues),
+                                   reversed(enumerators)))
+        #
+        class CTypesEnum(CTypesInt):
+            __slots__ = []
+            _reftypename = '%s &' % name
+
+            def _get_own_repr(self):
+                value = self._value
+                try:
+                    return '%d: %s' % (value, reverse_mapping[value])
+                except KeyError:
+                    return str(value)
+
+            def _to_string(self, maxlen):
+                value = self._value
+                try:
+                    return reverse_mapping[value]
+                except KeyError:
+                    return str(value)
+        #
+        CTypesEnum._fix_class()
+        return CTypesEnum
+
+    def get_errno(self):
+        return ctypes.get_errno()
+
+    def set_errno(self, value):
+        ctypes.set_errno(value)
+
+    def string(self, b, maxlen=-1):
+        return b._to_string(maxlen)
+
+    def buffer(self, bptr, size=-1):
+        raise NotImplementedError("buffer() with ctypes backend")
+
+    def sizeof(self, cdata_or_BType):
+        if isinstance(cdata_or_BType, CTypesData):
+            return cdata_or_BType._get_size_of_instance()
+        else:
+            assert issubclass(cdata_or_BType, CTypesData)
+            return cdata_or_BType._get_size()
+
+    def alignof(self, BType):
+        assert issubclass(BType, CTypesData)
+        return BType._alignment()
+
+    def newp(self, BType, source):
+        if not issubclass(BType, CTypesData):
+            raise TypeError
+        return BType._newp(source)
+
+    def cast(self, BType, source):
+        return BType._cast_from(source)
+
+    def callback(self, BType, source, error, onerror):
+        assert onerror is None   # XXX not implemented
+        return BType(source, error)
+
+    _weakref_cache_ref = None
+
+    def gcp(self, cdata, destructor, size=0):
+        if self._weakref_cache_ref is None:
+            import weakref
+            class MyRef(weakref.ref):
+                def __eq__(self, other):
+                    myref = self()
+                    return self is other or (
+                        myref is not None and myref is other())
+                def __ne__(self, other):
+                    return not (self == other)
+                def __hash__(self):
+                    try:
+                        return self._hash
+                    except AttributeError:
+                        self._hash = hash(self())
+                        return self._hash
+            self._weakref_cache_ref = {}, MyRef
+        weak_cache, MyRef = self._weakref_cache_ref
+
+        if destructor is None:
+            try:
+                del weak_cache[MyRef(cdata)]
+            except KeyError:
+                raise TypeError("Can remove destructor only on a object "
+                                "previously returned by ffi.gc()")
+            return None
+
+        def remove(k):
+            cdata, destructor = weak_cache.pop(k, (None, None))
+            if destructor is not None:
+                destructor(cdata)
+
+        new_cdata = self.cast(self.typeof(cdata), cdata)
+        assert new_cdata is not cdata
+        weak_cache[MyRef(new_cdata, remove)] = (cdata, destructor)
+        return new_cdata
+
+    typeof = type
+
+    def getcname(self, BType, replace_with):
+        return BType._get_c_name(replace_with)
+
+    def typeoffsetof(self, BType, fieldname, num=0):
+        if isinstance(fieldname, str):
+            if num == 0 and issubclass(BType, CTypesGenericPtr):
+                BType = BType._BItem
+            if not issubclass(BType, CTypesBaseStructOrUnion):
+                raise TypeError("expected a struct or union ctype")
+            BField = BType._bfield_types[fieldname]
+            if BField is Ellipsis:
+                raise TypeError("not supported for bitfields")
+            return (BField, BType._offsetof(fieldname))
+        elif isinstance(fieldname, (int, long)):
+            if issubclass(BType, CTypesGenericArray):
+                BType = BType._CTPtr
+            if not issubclass(BType, CTypesGenericPtr):
+                raise TypeError("expected an array or ptr ctype")
+            BItem = BType._BItem
+            offset = BItem._get_size() * fieldname
+            if offset > sys.maxsize:
+                raise OverflowError
+            return (BItem, offset)
+        else:
+            raise TypeError(type(fieldname))
+
+    def rawaddressof(self, BTypePtr, cdata, offset=None):
+        if isinstance(cdata, CTypesBaseStructOrUnion):
+            ptr = ctypes.pointer(type(cdata)._to_ctypes(cdata))
+        elif isinstance(cdata, CTypesGenericPtr):
+            if offset is None or not issubclass(type(cdata)._BItem,
+                                                CTypesBaseStructOrUnion):
+                raise TypeError("unexpected cdata type")
+            ptr = type(cdata)._to_ctypes(cdata)
+        elif isinstance(cdata, CTypesGenericArray):
+            ptr = type(cdata)._to_ctypes(cdata)
+        else:
+            raise TypeError("expected a <cdata 'struct-or-union'>")
+        if offset:
+            ptr = ctypes.cast(
+                ctypes.c_void_p(
+                    ctypes.cast(ptr, ctypes.c_void_p).value + offset),
+                type(ptr))
+        return BTypePtr._from_ctypes(ptr)
+
+
+class CTypesLibrary(object):
+
+    def __init__(self, backend, cdll):
+        self.backend = backend
+        self.cdll = cdll
+
+    def load_function(self, BType, name):
+        c_func = getattr(self.cdll, name)
+        funcobj = BType._from_ctypes(c_func)
+        funcobj._name = name
+        return funcobj
+
+    def read_variable(self, BType, name):
+        try:
+            ctypes_obj = BType._ctype.in_dll(self.cdll, name)
+        except AttributeError as e:
+            raise NotImplementedError(e)
+        return BType._from_ctypes(ctypes_obj)
+
+    def write_variable(self, BType, name, value):
+        new_ctypes_obj = BType._to_ctypes(value)
+        ctypes_obj = BType._ctype.in_dll(self.cdll, name)
+        ctypes.memmove(ctypes.addressof(ctypes_obj),
+                       ctypes.addressof(new_ctypes_obj),
+                       ctypes.sizeof(BType._ctype))
diff --git a/myenv/lib/python3.9/site-packages/cffi/cffi_opcode.py b/myenv/lib/python3.9/site-packages/cffi/cffi_opcode.py
new file mode 100644
index 0000000..a0df98d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/cffi_opcode.py
@@ -0,0 +1,187 @@
+from .error import VerificationError
+
+class CffiOp(object):
+    def __init__(self, op, arg):
+        self.op = op
+        self.arg = arg
+
+    def as_c_expr(self):
+        if self.op is None:
+            assert isinstance(self.arg, str)
+            return '(_cffi_opcode_t)(%s)' % (self.arg,)
+        classname = CLASS_NAME[self.op]
+        return '_CFFI_OP(_CFFI_OP_%s, %s)' % (classname, self.arg)
+
+    def as_python_bytes(self):
+        if self.op is None and self.arg.isdigit():
+            value = int(self.arg)     # non-negative: '-' not in self.arg
+            if value >= 2**31:
+                raise OverflowError("cannot emit %r: limited to 2**31-1"
+                                    % (self.arg,))
+            return format_four_bytes(value)
+        if isinstance(self.arg, str):
+            raise VerificationError("cannot emit to Python: %r" % (self.arg,))
+        return format_four_bytes((self.arg << 8) | self.op)
+
+    def __str__(self):
+        classname = CLASS_NAME.get(self.op, self.op)
+        return '(%s %s)' % (classname, self.arg)
+
+def format_four_bytes(num):
+    return '\\x%02X\\x%02X\\x%02X\\x%02X' % (
+        (num >> 24) & 0xFF,
+        (num >> 16) & 0xFF,
+        (num >>  8) & 0xFF,
+        (num      ) & 0xFF)
+
+OP_PRIMITIVE       = 1
+OP_POINTER         = 3
+OP_ARRAY           = 5
+OP_OPEN_ARRAY      = 7
+OP_STRUCT_UNION    = 9
+OP_ENUM            = 11
+OP_FUNCTION        = 13
+OP_FUNCTION_END    = 15
+OP_NOOP            = 17
+OP_BITFIELD        = 19
+OP_TYPENAME        = 21
+OP_CPYTHON_BLTN_V  = 23   # varargs
+OP_CPYTHON_BLTN_N  = 25   # noargs
+OP_CPYTHON_BLTN_O  = 27   # O  (i.e. a single arg)
+OP_CONSTANT        = 29
+OP_CONSTANT_INT    = 31
+OP_GLOBAL_VAR      = 33
+OP_DLOPEN_FUNC     = 35
+OP_DLOPEN_CONST    = 37
+OP_GLOBAL_VAR_F    = 39
+OP_EXTERN_PYTHON   = 41
+
+PRIM_VOID          = 0
+PRIM_BOOL          = 1
+PRIM_CHAR          = 2
+PRIM_SCHAR         = 3
+PRIM_UCHAR         = 4
+PRIM_SHORT         = 5
+PRIM_USHORT        = 6
+PRIM_INT           = 7
+PRIM_UINT          = 8
+PRIM_LONG          = 9
+PRIM_ULONG         = 10
+PRIM_LONGLONG      = 11
+PRIM_ULONGLONG     = 12
+PRIM_FLOAT         = 13
+PRIM_DOUBLE        = 14
+PRIM_LONGDOUBLE    = 15
+
+PRIM_WCHAR         = 16
+PRIM_INT8          = 17
+PRIM_UINT8         = 18
+PRIM_INT16         = 19
+PRIM_UINT16        = 20
+PRIM_INT32         = 21
+PRIM_UINT32        = 22
+PRIM_INT64         = 23
+PRIM_UINT64        = 24
+PRIM_INTPTR        = 25
+PRIM_UINTPTR       = 26
+PRIM_PTRDIFF       = 27
+PRIM_SIZE          = 28
+PRIM_SSIZE         = 29
+PRIM_INT_LEAST8    = 30
+PRIM_UINT_LEAST8   = 31
+PRIM_INT_LEAST16   = 32
+PRIM_UINT_LEAST16  = 33
+PRIM_INT_LEAST32   = 34
+PRIM_UINT_LEAST32  = 35
+PRIM_INT_LEAST64   = 36
+PRIM_UINT_LEAST64  = 37
+PRIM_INT_FAST8     = 38
+PRIM_UINT_FAST8    = 39
+PRIM_INT_FAST16    = 40
+PRIM_UINT_FAST16   = 41
+PRIM_INT_FAST32    = 42
+PRIM_UINT_FAST32   = 43
+PRIM_INT_FAST64    = 44
+PRIM_UINT_FAST64   = 45
+PRIM_INTMAX        = 46
+PRIM_UINTMAX       = 47
+PRIM_FLOATCOMPLEX  = 48
+PRIM_DOUBLECOMPLEX = 49
+PRIM_CHAR16        = 50
+PRIM_CHAR32        = 51
+
+_NUM_PRIM          = 52
+_UNKNOWN_PRIM          = -1
+_UNKNOWN_FLOAT_PRIM    = -2
+_UNKNOWN_LONG_DOUBLE   = -3
+
+_IO_FILE_STRUCT        = -1
+
+PRIMITIVE_TO_INDEX = {
+    'char':               PRIM_CHAR,
+    'short':              PRIM_SHORT,
+    'int':                PRIM_INT,
+    'long':               PRIM_LONG,
+    'long long':          PRIM_LONGLONG,
+    'signed char':        PRIM_SCHAR,
+    'unsigned char':      PRIM_UCHAR,
+    'unsigned short':     PRIM_USHORT,
+    'unsigned int':       PRIM_UINT,
+    'unsigned long':      PRIM_ULONG,
+    'unsigned long long': PRIM_ULONGLONG,
+    'float':              PRIM_FLOAT,
+    'double':             PRIM_DOUBLE,
+    'long double':        PRIM_LONGDOUBLE,
+    'float _Complex':     PRIM_FLOATCOMPLEX,
+    'double _Complex':    PRIM_DOUBLECOMPLEX,
+    '_Bool':              PRIM_BOOL,
+    'wchar_t':            PRIM_WCHAR,
+    'char16_t':           PRIM_CHAR16,
+    'char32_t':           PRIM_CHAR32,
+    'int8_t':             PRIM_INT8,
+    'uint8_t':            PRIM_UINT8,
+    'int16_t':            PRIM_INT16,
+    'uint16_t':           PRIM_UINT16,
+    'int32_t':            PRIM_INT32,
+    'uint32_t':           PRIM_UINT32,
+    'int64_t':            PRIM_INT64,
+    'uint64_t':           PRIM_UINT64,
+    'intptr_t':           PRIM_INTPTR,
+    'uintptr_t':          PRIM_UINTPTR,
+    'ptrdiff_t':          PRIM_PTRDIFF,
+    'size_t':             PRIM_SIZE,
+    'ssize_t':            PRIM_SSIZE,
+    'int_least8_t':       PRIM_INT_LEAST8,
+    'uint_least8_t':      PRIM_UINT_LEAST8,
+    'int_least16_t':      PRIM_INT_LEAST16,
+    'uint_least16_t':     PRIM_UINT_LEAST16,
+    'int_least32_t':      PRIM_INT_LEAST32,
+    'uint_least32_t':     PRIM_UINT_LEAST32,
+    'int_least64_t':      PRIM_INT_LEAST64,
+    'uint_least64_t':     PRIM_UINT_LEAST64,
+    'int_fast8_t':        PRIM_INT_FAST8,
+    'uint_fast8_t':       PRIM_UINT_FAST8,
+    'int_fast16_t':       PRIM_INT_FAST16,
+    'uint_fast16_t':      PRIM_UINT_FAST16,
+    'int_fast32_t':       PRIM_INT_FAST32,
+    'uint_fast32_t':      PRIM_UINT_FAST32,
+    'int_fast64_t':       PRIM_INT_FAST64,
+    'uint_fast64_t':      PRIM_UINT_FAST64,
+    'intmax_t':           PRIM_INTMAX,
+    'uintmax_t':          PRIM_UINTMAX,
+    }
+
+F_UNION         = 0x01
+F_CHECK_FIELDS  = 0x02
+F_PACKED        = 0x04
+F_EXTERNAL      = 0x08
+F_OPAQUE        = 0x10
+
+G_FLAGS = dict([('_CFFI_' + _key, globals()[_key])
+                for _key in ['F_UNION', 'F_CHECK_FIELDS', 'F_PACKED',
+                             'F_EXTERNAL', 'F_OPAQUE']])
+
+CLASS_NAME = {}
+for _name, _value in list(globals().items()):
+    if _name.startswith('OP_') and isinstance(_value, int):
+        CLASS_NAME[_value] = _name[3:]
diff --git a/myenv/lib/python3.9/site-packages/cffi/commontypes.py b/myenv/lib/python3.9/site-packages/cffi/commontypes.py
new file mode 100644
index 0000000..8ec97c7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/commontypes.py
@@ -0,0 +1,80 @@
+import sys
+from . import model
+from .error import FFIError
+
+
+COMMON_TYPES = {}
+
+try:
+    # fetch "bool" and all simple Windows types
+    from _cffi_backend import _get_common_types
+    _get_common_types(COMMON_TYPES)
+except ImportError:
+    pass
+
+COMMON_TYPES['FILE'] = model.unknown_type('FILE', '_IO_FILE')
+COMMON_TYPES['bool'] = '_Bool'    # in case we got ImportError above
+
+for _type in model.PrimitiveType.ALL_PRIMITIVE_TYPES:
+    if _type.endswith('_t'):
+        COMMON_TYPES[_type] = _type
+del _type
+
+_CACHE = {}
+
+def resolve_common_type(parser, commontype):
+    try:
+        return _CACHE[commontype]
+    except KeyError:
+        cdecl = COMMON_TYPES.get(commontype, commontype)
+        if not isinstance(cdecl, str):
+            result, quals = cdecl, 0    # cdecl is already a BaseType
+        elif cdecl in model.PrimitiveType.ALL_PRIMITIVE_TYPES:
+            result, quals = model.PrimitiveType(cdecl), 0
+        elif cdecl == 'set-unicode-needed':
+            raise FFIError("The Windows type %r is only available after "
+                           "you call ffi.set_unicode()" % (commontype,))
+        else:
+            if commontype == cdecl:
+                raise FFIError(
+                    "Unsupported type: %r.  Please look at "
+        "http://cffi.readthedocs.io/en/latest/cdef.html#ffi-cdef-limitations "
+                    "and file an issue if you think this type should really "
+                    "be supported." % (commontype,))
+            result, quals = parser.parse_type_and_quals(cdecl)   # recursive
+
+        assert isinstance(result, model.BaseTypeByIdentity)
+        _CACHE[commontype] = result, quals
+        return result, quals
+
+
+# ____________________________________________________________
+# extra types for Windows (most of them are in commontypes.c)
+
+
+def win_common_types():
+    return {
+        "UNICODE_STRING": model.StructType(
+            "_UNICODE_STRING",
+            ["Length",
+             "MaximumLength",
+             "Buffer"],
+            [model.PrimitiveType("unsigned short"),
+             model.PrimitiveType("unsigned short"),
+             model.PointerType(model.PrimitiveType("wchar_t"))],
+            [-1, -1, -1]),
+        "PUNICODE_STRING": "UNICODE_STRING *",
+        "PCUNICODE_STRING": "const UNICODE_STRING *",
+
+        "TBYTE": "set-unicode-needed",
+        "TCHAR": "set-unicode-needed",
+        "LPCTSTR": "set-unicode-needed",
+        "PCTSTR": "set-unicode-needed",
+        "LPTSTR": "set-unicode-needed",
+        "PTSTR": "set-unicode-needed",
+        "PTBYTE": "set-unicode-needed",
+        "PTCHAR": "set-unicode-needed",
+        }
+
+if sys.platform == 'win32':
+    COMMON_TYPES.update(win_common_types())
diff --git a/myenv/lib/python3.9/site-packages/cffi/cparser.py b/myenv/lib/python3.9/site-packages/cffi/cparser.py
new file mode 100644
index 0000000..74830e9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/cparser.py
@@ -0,0 +1,1006 @@
+from . import model
+from .commontypes import COMMON_TYPES, resolve_common_type
+from .error import FFIError, CDefError
+try:
+    from . import _pycparser as pycparser
+except ImportError:
+    import pycparser
+import weakref, re, sys
+
+try:
+    if sys.version_info < (3,):
+        import thread as _thread
+    else:
+        import _thread
+    lock = _thread.allocate_lock()
+except ImportError:
+    lock = None
+
+def _workaround_for_static_import_finders():
+    # Issue #392: packaging tools like cx_Freeze can not find these
+    # because pycparser uses exec dynamic import.  This is an obscure
+    # workaround.  This function is never called.
+    import pycparser.yacctab
+    import pycparser.lextab
+
+CDEF_SOURCE_STRING = "<cdef source string>"
+_r_comment = re.compile(r"/\*.*?\*/|//([^\n\\]|\\.)*?$",
+                        re.DOTALL | re.MULTILINE)
+_r_define  = re.compile(r"^\s*#\s*define\s+([A-Za-z_][A-Za-z_0-9]*)"
+                        r"\b((?:[^\n\\]|\\.)*?)$",
+                        re.DOTALL | re.MULTILINE)
+_r_line_directive = re.compile(r"^[ \t]*#[ \t]*(?:line|\d+)\b.*$", re.MULTILINE)
+_r_partial_enum = re.compile(r"=\s*\.\.\.\s*[,}]|\.\.\.\s*\}")
+_r_enum_dotdotdot = re.compile(r"__dotdotdot\d+__$")
+_r_partial_array = re.compile(r"\[\s*\.\.\.\s*\]")
+_r_words = re.compile(r"\w+|\S")
+_parser_cache = None
+_r_int_literal = re.compile(r"-?0?x?[0-9a-f]+[lu]*$", re.IGNORECASE)
+_r_stdcall1 = re.compile(r"\b(__stdcall|WINAPI)\b")
+_r_stdcall2 = re.compile(r"[(]\s*(__stdcall|WINAPI)\b")
+_r_cdecl = re.compile(r"\b__cdecl\b")
+_r_extern_python = re.compile(r'\bextern\s*"'
+                              r'(Python|Python\s*\+\s*C|C\s*\+\s*Python)"\s*.')
+_r_star_const_space = re.compile(       # matches "* const "
+    r"[*]\s*((const|volatile|restrict)\b\s*)+")
+_r_int_dotdotdot = re.compile(r"(\b(int|long|short|signed|unsigned|char)\s*)+"
+                              r"\.\.\.")
+_r_float_dotdotdot = re.compile(r"\b(double|float)\s*\.\.\.")
+
+def _get_parser():
+    global _parser_cache
+    if _parser_cache is None:
+        _parser_cache = pycparser.CParser()
+    return _parser_cache
+
+def _workaround_for_old_pycparser(csource):
+    # Workaround for a pycparser issue (fixed between pycparser 2.10 and
+    # 2.14): "char*const***" gives us a wrong syntax tree, the same as
+    # for "char***(*const)".  This means we can't tell the difference
+    # afterwards.  But "char(*const(***))" gives us the right syntax
+    # tree.  The issue only occurs if there are several stars in
+    # sequence with no parenthesis inbetween, just possibly qualifiers.
+    # Attempt to fix it by adding some parentheses in the source: each
+    # time we see "* const" or "* const *", we add an opening
+    # parenthesis before each star---the hard part is figuring out where
+    # to close them.
+    parts = []
+    while True:
+        match = _r_star_const_space.search(csource)
+        if not match:
+            break
+        #print repr(''.join(parts)+csource), '=>',
+        parts.append(csource[:match.start()])
+        parts.append('('); closing = ')'
+        parts.append(match.group())   # e.g. "* const "
+        endpos = match.end()
+        if csource.startswith('*', endpos):
+            parts.append('('); closing += ')'
+        level = 0
+        i = endpos
+        while i < len(csource):
+            c = csource[i]
+            if c == '(':
+                level += 1
+            elif c == ')':
+                if level == 0:
+                    break
+                level -= 1
+            elif c in ',;=':
+                if level == 0:
+                    break
+            i += 1
+        csource = csource[endpos:i] + closing + csource[i:]
+        #print repr(''.join(parts)+csource)
+    parts.append(csource)
+    return ''.join(parts)
+
+def _preprocess_extern_python(csource):
+    # input: `extern "Python" int foo(int);` or
+    #        `extern "Python" { int foo(int); }`
+    # output:
+    #     void __cffi_extern_python_start;
+    #     int foo(int);
+    #     void __cffi_extern_python_stop;
+    #
+    # input: `extern "Python+C" int foo(int);`
+    # output:
+    #     void __cffi_extern_python_plus_c_start;
+    #     int foo(int);
+    #     void __cffi_extern_python_stop;
+    parts = []
+    while True:
+        match = _r_extern_python.search(csource)
+        if not match:
+            break
+        endpos = match.end() - 1
+        #print
+        #print ''.join(parts)+csource
+        #print '=>'
+        parts.append(csource[:match.start()])
+        if 'C' in match.group(1):
+            parts.append('void __cffi_extern_python_plus_c_start; ')
+        else:
+            parts.append('void __cffi_extern_python_start; ')
+        if csource[endpos] == '{':
+            # grouping variant
+            closing = csource.find('}', endpos)
+            if closing < 0:
+                raise CDefError("'extern \"Python\" {': no '}' found")
+            if csource.find('{', endpos + 1, closing) >= 0:
+                raise NotImplementedError("cannot use { } inside a block "
+                                          "'extern \"Python\" { ... }'")
+            parts.append(csource[endpos+1:closing])
+            csource = csource[closing+1:]
+        else:
+            # non-grouping variant
+            semicolon = csource.find(';', endpos)
+            if semicolon < 0:
+                raise CDefError("'extern \"Python\": no ';' found")
+            parts.append(csource[endpos:semicolon+1])
+            csource = csource[semicolon+1:]
+        parts.append(' void __cffi_extern_python_stop;')
+        #print ''.join(parts)+csource
+        #print
+    parts.append(csource)
+    return ''.join(parts)
+
+def _warn_for_string_literal(csource):
+    if '"' not in csource:
+        return
+    for line in csource.splitlines():
+        if '"' in line and not line.lstrip().startswith('#'):
+            import warnings
+            warnings.warn("String literal found in cdef() or type source. "
+                          "String literals are ignored here, but you should "
+                          "remove them anyway because some character sequences "
+                          "confuse pre-parsing.")
+            break
+
+def _warn_for_non_extern_non_static_global_variable(decl):
+    if not decl.storage:
+        import warnings
+        warnings.warn("Global variable '%s' in cdef(): for consistency "
+                      "with C it should have a storage class specifier "
+                      "(usually 'extern')" % (decl.name,))
+
+def _remove_line_directives(csource):
+    # _r_line_directive matches whole lines, without the final \n, if they
+    # start with '#line' with some spacing allowed, or '#NUMBER'.  This
+    # function stores them away and replaces them with exactly the string
+    # '#line@N', where N is the index in the list 'line_directives'.
+    line_directives = []
+    def replace(m):
+        i = len(line_directives)
+        line_directives.append(m.group())
+        return '#line@%d' % i
+    csource = _r_line_directive.sub(replace, csource)
+    return csource, line_directives
+
+def _put_back_line_directives(csource, line_directives):
+    def replace(m):
+        s = m.group()
+        if not s.startswith('#line@'):
+            raise AssertionError("unexpected #line directive "
+                                 "(should have been processed and removed")
+        return line_directives[int(s[6:])]
+    return _r_line_directive.sub(replace, csource)
+
+def _preprocess(csource):
+    # First, remove the lines of the form '#line N "filename"' because
+    # the "filename" part could confuse the rest
+    csource, line_directives = _remove_line_directives(csource)
+    # Remove comments.  NOTE: this only work because the cdef() section
+    # should not contain any string literals (except in line directives)!
+    def replace_keeping_newlines(m):
+        return ' ' + m.group().count('\n') * '\n'
+    csource = _r_comment.sub(replace_keeping_newlines, csource)
+    # Remove the "#define FOO x" lines
+    macros = {}
+    for match in _r_define.finditer(csource):
+        macroname, macrovalue = match.groups()
+        macrovalue = macrovalue.replace('\\\n', '').strip()
+        macros[macroname] = macrovalue
+    csource = _r_define.sub('', csource)
+    #
+    if pycparser.__version__ < '2.14':
+        csource = _workaround_for_old_pycparser(csource)
+    #
+    # BIG HACK: replace WINAPI or __stdcall with "volatile const".
+    # It doesn't make sense for the return type of a function to be
+    # "volatile volatile const", so we abuse it to detect __stdcall...
+    # Hack number 2 is that "int(volatile *fptr)();" is not valid C
+    # syntax, so we place the "volatile" before the opening parenthesis.
+    csource = _r_stdcall2.sub(' volatile volatile const(', csource)
+    csource = _r_stdcall1.sub(' volatile volatile const ', csource)
+    csource = _r_cdecl.sub(' ', csource)
+    #
+    # Replace `extern "Python"` with start/end markers
+    csource = _preprocess_extern_python(csource)
+    #
+    # Now there should not be any string literal left; warn if we get one
+    _warn_for_string_literal(csource)
+    #
+    # Replace "[...]" with "[__dotdotdotarray__]"
+    csource = _r_partial_array.sub('[__dotdotdotarray__]', csource)
+    #
+    # Replace "...}" with "__dotdotdotNUM__}".  This construction should
+    # occur only at the end of enums; at the end of structs we have "...;}"
+    # and at the end of vararg functions "...);".  Also replace "=...[,}]"
+    # with ",__dotdotdotNUM__[,}]": this occurs in the enums too, when
+    # giving an unknown value.
+    matches = list(_r_partial_enum.finditer(csource))
+    for number, match in enumerate(reversed(matches)):
+        p = match.start()
+        if csource[p] == '=':
+            p2 = csource.find('...', p, match.end())
+            assert p2 > p
+            csource = '%s,__dotdotdot%d__ %s' % (csource[:p], number,
+                                                 csource[p2+3:])
+        else:
+            assert csource[p:p+3] == '...'
+            csource = '%s __dotdotdot%d__ %s' % (csource[:p], number,
+                                                 csource[p+3:])
+    # Replace "int ..." or "unsigned long int..." with "__dotdotdotint__"
+    csource = _r_int_dotdotdot.sub(' __dotdotdotint__ ', csource)
+    # Replace "float ..." or "double..." with "__dotdotdotfloat__"
+    csource = _r_float_dotdotdot.sub(' __dotdotdotfloat__ ', csource)
+    # Replace all remaining "..." with the same name, "__dotdotdot__",
+    # which is declared with a typedef for the purpose of C parsing.
+    csource = csource.replace('...', ' __dotdotdot__ ')
+    # Finally, put back the line directives
+    csource = _put_back_line_directives(csource, line_directives)
+    return csource, macros
+
+def _common_type_names(csource):
+    # Look in the source for what looks like usages of types from the
+    # list of common types.  A "usage" is approximated here as the
+    # appearance of the word, minus a "definition" of the type, which
+    # is the last word in a "typedef" statement.  Approximative only
+    # but should be fine for all the common types.
+    look_for_words = set(COMMON_TYPES)
+    look_for_words.add(';')
+    look_for_words.add(',')
+    look_for_words.add('(')
+    look_for_words.add(')')
+    look_for_words.add('typedef')
+    words_used = set()
+    is_typedef = False
+    paren = 0
+    previous_word = ''
+    for word in _r_words.findall(csource):
+        if word in look_for_words:
+            if word == ';':
+                if is_typedef:
+                    words_used.discard(previous_word)
+                    look_for_words.discard(previous_word)
+                    is_typedef = False
+            elif word == 'typedef':
+                is_typedef = True
+                paren = 0
+            elif word == '(':
+                paren += 1
+            elif word == ')':
+                paren -= 1
+            elif word == ',':
+                if is_typedef and paren == 0:
+                    words_used.discard(previous_word)
+                    look_for_words.discard(previous_word)
+            else:   # word in COMMON_TYPES
+                words_used.add(word)
+        previous_word = word
+    return words_used
+
+
+class Parser(object):
+
+    def __init__(self):
+        self._declarations = {}
+        self._included_declarations = set()
+        self._anonymous_counter = 0
+        self._structnode2type = weakref.WeakKeyDictionary()
+        self._options = {}
+        self._int_constants = {}
+        self._recomplete = []
+        self._uses_new_feature = None
+
+    def _parse(self, csource):
+        csource, macros = _preprocess(csource)
+        # XXX: for more efficiency we would need to poke into the
+        # internals of CParser...  the following registers the
+        # typedefs, because their presence or absence influences the
+        # parsing itself (but what they are typedef'ed to plays no role)
+        ctn = _common_type_names(csource)
+        typenames = []
+        for name in sorted(self._declarations):
+            if name.startswith('typedef '):
+                name = name[8:]
+                typenames.append(name)
+                ctn.discard(name)
+        typenames += sorted(ctn)
+        #
+        csourcelines = []
+        csourcelines.append('# 1 "<cdef automatic initialization code>"')
+        for typename in typenames:
+            csourcelines.append('typedef int %s;' % typename)
+        csourcelines.append('typedef int __dotdotdotint__, __dotdotdotfloat__,'
+                            ' __dotdotdot__;')
+        # this forces pycparser to consider the following in the file
+        # called <cdef source string> from line 1
+        csourcelines.append('# 1 "%s"' % (CDEF_SOURCE_STRING,))
+        csourcelines.append(csource)
+        fullcsource = '\n'.join(csourcelines)
+        if lock is not None:
+            lock.acquire()     # pycparser is not thread-safe...
+        try:
+            ast = _get_parser().parse(fullcsource)
+        except pycparser.c_parser.ParseError as e:
+            self.convert_pycparser_error(e, csource)
+        finally:
+            if lock is not None:
+                lock.release()
+        # csource will be used to find buggy source text
+        return ast, macros, csource
+
+    def _convert_pycparser_error(self, e, csource):
+        # xxx look for "<cdef source string>:NUM:" at the start of str(e)
+        # and interpret that as a line number.  This will not work if
+        # the user gives explicit ``# NUM "FILE"`` directives.
+        line = None
+        msg = str(e)
+        match = re.match(r"%s:(\d+):" % (CDEF_SOURCE_STRING,), msg)
+        if match:
+            linenum = int(match.group(1), 10)
+            csourcelines = csource.splitlines()
+            if 1 <= linenum <= len(csourcelines):
+                line = csourcelines[linenum-1]
+        return line
+
+    def convert_pycparser_error(self, e, csource):
+        line = self._convert_pycparser_error(e, csource)
+
+        msg = str(e)
+        if line:
+            msg = 'cannot parse "%s"\n%s' % (line.strip(), msg)
+        else:
+            msg = 'parse error\n%s' % (msg,)
+        raise CDefError(msg)
+
+    def parse(self, csource, override=False, packed=False, pack=None,
+                    dllexport=False):
+        if packed:
+            if packed != True:
+                raise ValueError("'packed' should be False or True; use "
+                                 "'pack' to give another value")
+            if pack:
+                raise ValueError("cannot give both 'pack' and 'packed'")
+            pack = 1
+        elif pack:
+            if pack & (pack - 1):
+                raise ValueError("'pack' must be a power of two, not %r" %
+                    (pack,))
+        else:
+            pack = 0
+        prev_options = self._options
+        try:
+            self._options = {'override': override,
+                             'packed': pack,
+                             'dllexport': dllexport}
+            self._internal_parse(csource)
+        finally:
+            self._options = prev_options
+
+    def _internal_parse(self, csource):
+        ast, macros, csource = self._parse(csource)
+        # add the macros
+        self._process_macros(macros)
+        # find the first "__dotdotdot__" and use that as a separator
+        # between the repeated typedefs and the real csource
+        iterator = iter(ast.ext)
+        for decl in iterator:
+            if decl.name == '__dotdotdot__':
+                break
+        else:
+            assert 0
+        current_decl = None
+        #
+        try:
+            self._inside_extern_python = '__cffi_extern_python_stop'
+            for decl in iterator:
+                current_decl = decl
+                if isinstance(decl, pycparser.c_ast.Decl):
+                    self._parse_decl(decl)
+                elif isinstance(decl, pycparser.c_ast.Typedef):
+                    if not decl.name:
+                        raise CDefError("typedef does not declare any name",
+                                        decl)
+                    quals = 0
+                    if (isinstance(decl.type.type, pycparser.c_ast.IdentifierType) and
+                            decl.type.type.names[-1].startswith('__dotdotdot')):
+                        realtype = self._get_unknown_type(decl)
+                    elif (isinstance(decl.type, pycparser.c_ast.PtrDecl) and
+                          isinstance(decl.type.type, pycparser.c_ast.TypeDecl) and
+                          isinstance(decl.type.type.type,
+                                     pycparser.c_ast.IdentifierType) and
+                          decl.type.type.type.names[-1].startswith('__dotdotdot')):
+                        realtype = self._get_unknown_ptr_type(decl)
+                    else:
+                        realtype, quals = self._get_type_and_quals(
+                            decl.type, name=decl.name, partial_length_ok=True,
+                            typedef_example="*(%s *)0" % (decl.name,))
+                    self._declare('typedef ' + decl.name, realtype, quals=quals)
+                elif decl.__class__.__name__ == 'Pragma':
+                    pass    # skip pragma, only in pycparser 2.15
+                else:
+                    raise CDefError("unexpected <%s>: this construct is valid "
+                                    "C but not valid in cdef()" %
+                                    decl.__class__.__name__, decl)
+        except CDefError as e:
+            if len(e.args) == 1:
+                e.args = e.args + (current_decl,)
+            raise
+        except FFIError as e:
+            msg = self._convert_pycparser_error(e, csource)
+            if msg:
+                e.args = (e.args[0] + "\n    *** Err: %s" % msg,)
+            raise
+
+    def _add_constants(self, key, val):
+        if key in self._int_constants:
+            if self._int_constants[key] == val:
+                return     # ignore identical double declarations
+            raise FFIError(
+                "multiple declarations of constant: %s" % (key,))
+        self._int_constants[key] = val
+
+    def _add_integer_constant(self, name, int_str):
+        int_str = int_str.lower().rstrip("ul")
+        neg = int_str.startswith('-')
+        if neg:
+            int_str = int_str[1:]
+        # "010" is not valid oct in py3
+        if (int_str.startswith("0") and int_str != '0'
+                and not int_str.startswith("0x")):
+            int_str = "0o" + int_str[1:]
+        pyvalue = int(int_str, 0)
+        if neg:
+            pyvalue = -pyvalue
+        self._add_constants(name, pyvalue)
+        self._declare('macro ' + name, pyvalue)
+
+    def _process_macros(self, macros):
+        for key, value in macros.items():
+            value = value.strip()
+            if _r_int_literal.match(value):
+                self._add_integer_constant(key, value)
+            elif value == '...':
+                self._declare('macro ' + key, value)
+            else:
+                raise CDefError(
+                    'only supports one of the following syntax:\n'
+                    '  #define %s ...     (literally dot-dot-dot)\n'
+                    '  #define %s NUMBER  (with NUMBER an integer'
+                                    ' constant, decimal/hex/octal)\n'
+                    'got:\n'
+                    '  #define %s %s'
+                    % (key, key, key, value))
+
+    def _declare_function(self, tp, quals, decl):
+        tp = self._get_type_pointer(tp, quals)
+        if self._options.get('dllexport'):
+            tag = 'dllexport_python '
+        elif self._inside_extern_python == '__cffi_extern_python_start':
+            tag = 'extern_python '
+        elif self._inside_extern_python == '__cffi_extern_python_plus_c_start':
+            tag = 'extern_python_plus_c '
+        else:
+            tag = 'function '
+        self._declare(tag + decl.name, tp)
+
+    def _parse_decl(self, decl):
+        node = decl.type
+        if isinstance(node, pycparser.c_ast.FuncDecl):
+            tp, quals = self._get_type_and_quals(node, name=decl.name)
+            assert isinstance(tp, model.RawFunctionType)
+            self._declare_function(tp, quals, decl)
+        else:
+            if isinstance(node, pycparser.c_ast.Struct):
+                self._get_struct_union_enum_type('struct', node)
+            elif isinstance(node, pycparser.c_ast.Union):
+                self._get_struct_union_enum_type('union', node)
+            elif isinstance(node, pycparser.c_ast.Enum):
+                self._get_struct_union_enum_type('enum', node)
+            elif not decl.name:
+                raise CDefError("construct does not declare any variable",
+                                decl)
+            #
+            if decl.name:
+                tp, quals = self._get_type_and_quals(node,
+                                                     partial_length_ok=True)
+                if tp.is_raw_function:
+                    self._declare_function(tp, quals, decl)
+                elif (tp.is_integer_type() and
+                        hasattr(decl, 'init') and
+                        hasattr(decl.init, 'value') and
+                        _r_int_literal.match(decl.init.value)):
+                    self._add_integer_constant(decl.name, decl.init.value)
+                elif (tp.is_integer_type() and
+                        isinstance(decl.init, pycparser.c_ast.UnaryOp) and
+                        decl.init.op == '-' and
+                        hasattr(decl.init.expr, 'value') and
+                        _r_int_literal.match(decl.init.expr.value)):
+                    self._add_integer_constant(decl.name,
+                                               '-' + decl.init.expr.value)
+                elif (tp is model.void_type and
+                      decl.name.startswith('__cffi_extern_python_')):
+                    # hack: `extern "Python"` in the C source is replaced
+                    # with "void __cffi_extern_python_start;" and
+                    # "void __cffi_extern_python_stop;"
+                    self._inside_extern_python = decl.name
+                else:
+                    if self._inside_extern_python !='__cffi_extern_python_stop':
+                        raise CDefError(
+                            "cannot declare constants or "
+                            "variables with 'extern \"Python\"'")
+                    if (quals & model.Q_CONST) and not tp.is_array_type:
+                        self._declare('constant ' + decl.name, tp, quals=quals)
+                    else:
+                        _warn_for_non_extern_non_static_global_variable(decl)
+                        self._declare('variable ' + decl.name, tp, quals=quals)
+
+    def parse_type(self, cdecl):
+        return self.parse_type_and_quals(cdecl)[0]
+
+    def parse_type_and_quals(self, cdecl):
+        ast, macros = self._parse('void __dummy(\n%s\n);' % cdecl)[:2]
+        assert not macros
+        exprnode = ast.ext[-1].type.args.params[0]
+        if isinstance(exprnode, pycparser.c_ast.ID):
+            raise CDefError("unknown identifier '%s'" % (exprnode.name,))
+        return self._get_type_and_quals(exprnode.type)
+
+    def _declare(self, name, obj, included=False, quals=0):
+        if name in self._declarations:
+            prevobj, prevquals = self._declarations[name]
+            if prevobj is obj and prevquals == quals:
+                return
+            if not self._options.get('override'):
+                raise FFIError(
+                    "multiple declarations of %s (for interactive usage, "
+                    "try cdef(xx, override=True))" % (name,))
+        assert '__dotdotdot__' not in name.split()
+        self._declarations[name] = (obj, quals)
+        if included:
+            self._included_declarations.add(obj)
+
+    def _extract_quals(self, type):
+        quals = 0
+        if isinstance(type, (pycparser.c_ast.TypeDecl,
+                             pycparser.c_ast.PtrDecl)):
+            if 'const' in type.quals:
+                quals |= model.Q_CONST
+            if 'volatile' in type.quals:
+                quals |= model.Q_VOLATILE
+            if 'restrict' in type.quals:
+                quals |= model.Q_RESTRICT
+        return quals
+
+    def _get_type_pointer(self, type, quals, declname=None):
+        if isinstance(type, model.RawFunctionType):
+            return type.as_function_pointer()
+        if (isinstance(type, model.StructOrUnionOrEnum) and
+                type.name.startswith('$') and type.name[1:].isdigit() and
+                type.forcename is None and declname is not None):
+            return model.NamedPointerType(type, declname, quals)
+        return model.PointerType(type, quals)
+
+    def _get_type_and_quals(self, typenode, name=None, partial_length_ok=False,
+                            typedef_example=None):
+        # first, dereference typedefs, if we have it already parsed, we're good
+        if (isinstance(typenode, pycparser.c_ast.TypeDecl) and
+            isinstance(typenode.type, pycparser.c_ast.IdentifierType) and
+            len(typenode.type.names) == 1 and
+            ('typedef ' + typenode.type.names[0]) in self._declarations):
+            tp, quals = self._declarations['typedef ' + typenode.type.names[0]]
+            quals |= self._extract_quals(typenode)
+            return tp, quals
+        #
+        if isinstance(typenode, pycparser.c_ast.ArrayDecl):
+            # array type
+            if typenode.dim is None:
+                length = None
+            else:
+                length = self._parse_constant(
+                    typenode.dim, partial_length_ok=partial_length_ok)
+            # a hack: in 'typedef int foo_t[...][...];', don't use '...' as
+            # the length but use directly the C expression that would be
+            # generated by recompiler.py.  This lets the typedef be used in
+            # many more places within recompiler.py
+            if typedef_example is not None:
+                if length == '...':
+                    length = '_cffi_array_len(%s)' % (typedef_example,)
+                typedef_example = "*" + typedef_example
+            #
+            tp, quals = self._get_type_and_quals(typenode.type,
+                                partial_length_ok=partial_length_ok,
+                                typedef_example=typedef_example)
+            return model.ArrayType(tp, length), quals
+        #
+        if isinstance(typenode, pycparser.c_ast.PtrDecl):
+            # pointer type
+            itemtype, itemquals = self._get_type_and_quals(typenode.type)
+            tp = self._get_type_pointer(itemtype, itemquals, declname=name)
+            quals = self._extract_quals(typenode)
+            return tp, quals
+        #
+        if isinstance(typenode, pycparser.c_ast.TypeDecl):
+            quals = self._extract_quals(typenode)
+            type = typenode.type
+            if isinstance(type, pycparser.c_ast.IdentifierType):
+                # assume a primitive type.  get it from .names, but reduce
+                # synonyms to a single chosen combination
+                names = list(type.names)
+                if names != ['signed', 'char']:    # keep this unmodified
+                    prefixes = {}
+                    while names:
+                        name = names[0]
+                        if name in ('short', 'long', 'signed', 'unsigned'):
+                            prefixes[name] = prefixes.get(name, 0) + 1
+                            del names[0]
+                        else:
+                            break
+                    # ignore the 'signed' prefix below, and reorder the others
+                    newnames = []
+                    for prefix in ('unsigned', 'short', 'long'):
+                        for i in range(prefixes.get(prefix, 0)):
+                            newnames.append(prefix)
+                    if not names:
+                        names = ['int']    # implicitly
+                    if names == ['int']:   # but kill it if 'short' or 'long'
+                        if 'short' in prefixes or 'long' in prefixes:
+                            names = []
+                    names = newnames + names
+                ident = ' '.join(names)
+                if ident == 'void':
+                    return model.void_type, quals
+                if ident == '__dotdotdot__':
+                    raise FFIError(':%d: bad usage of "..."' %
+                            typenode.coord.line)
+                tp0, quals0 = resolve_common_type(self, ident)
+                return tp0, (quals | quals0)
+            #
+            if isinstance(type, pycparser.c_ast.Struct):
+                # 'struct foobar'
+                tp = self._get_struct_union_enum_type('struct', type, name)
+                return tp, quals
+            #
+            if isinstance(type, pycparser.c_ast.Union):
+                # 'union foobar'
+                tp = self._get_struct_union_enum_type('union', type, name)
+                return tp, quals
+            #
+            if isinstance(type, pycparser.c_ast.Enum):
+                # 'enum foobar'
+                tp = self._get_struct_union_enum_type('enum', type, name)
+                return tp, quals
+        #
+        if isinstance(typenode, pycparser.c_ast.FuncDecl):
+            # a function type
+            return self._parse_function_type(typenode, name), 0
+        #
+        # nested anonymous structs or unions end up here
+        if isinstance(typenode, pycparser.c_ast.Struct):
+            return self._get_struct_union_enum_type('struct', typenode, name,
+                                                    nested=True), 0
+        if isinstance(typenode, pycparser.c_ast.Union):
+            return self._get_struct_union_enum_type('union', typenode, name,
+                                                    nested=True), 0
+        #
+        raise FFIError(":%d: bad or unsupported type declaration" %
+                typenode.coord.line)
+
+    def _parse_function_type(self, typenode, funcname=None):
+        params = list(getattr(typenode.args, 'params', []))
+        for i, arg in enumerate(params):
+            if not hasattr(arg, 'type'):
+                raise CDefError("%s arg %d: unknown type '%s'"
+                    " (if you meant to use the old C syntax of giving"
+                    " untyped arguments, it is not supported)"
+                    % (funcname or 'in expression', i + 1,
+                       getattr(arg, 'name', '?')))
+        ellipsis = (
+            len(params) > 0 and
+            isinstance(params[-1].type, pycparser.c_ast.TypeDecl) and
+            isinstance(params[-1].type.type,
+                       pycparser.c_ast.IdentifierType) and
+            params[-1].type.type.names == ['__dotdotdot__'])
+        if ellipsis:
+            params.pop()
+            if not params:
+                raise CDefError(
+                    "%s: a function with only '(...)' as argument"
+                    " is not correct C" % (funcname or 'in expression'))
+        args = [self._as_func_arg(*self._get_type_and_quals(argdeclnode.type))
+                for argdeclnode in params]
+        if not ellipsis and args == [model.void_type]:
+            args = []
+        result, quals = self._get_type_and_quals(typenode.type)
+        # the 'quals' on the result type are ignored.  HACK: we absure them
+        # to detect __stdcall functions: we textually replace "__stdcall"
+        # with "volatile volatile const" above.
+        abi = None
+        if hasattr(typenode.type, 'quals'): # else, probable syntax error anyway
+            if typenode.type.quals[-3:] == ['volatile', 'volatile', 'const']:
+                abi = '__stdcall'
+        return model.RawFunctionType(tuple(args), result, ellipsis, abi)
+
+    def _as_func_arg(self, type, quals):
+        if isinstance(type, model.ArrayType):
+            return model.PointerType(type.item, quals)
+        elif isinstance(type, model.RawFunctionType):
+            return type.as_function_pointer()
+        else:
+            return type
+
+    def _get_struct_union_enum_type(self, kind, type, name=None, nested=False):
+        # First, a level of caching on the exact 'type' node of the AST.
+        # This is obscure, but needed because pycparser "unrolls" declarations
+        # such as "typedef struct { } foo_t, *foo_p" and we end up with
+        # an AST that is not a tree, but a DAG, with the "type" node of the
+        # two branches foo_t and foo_p of the trees being the same node.
+        # It's a bit silly but detecting "DAG-ness" in the AST tree seems
+        # to be the only way to distinguish this case from two independent
+        # structs.  See test_struct_with_two_usages.
+        try:
+            return self._structnode2type[type]
+        except KeyError:
+            pass
+        #
+        # Note that this must handle parsing "struct foo" any number of
+        # times and always return the same StructType object.  Additionally,
+        # one of these times (not necessarily the first), the fields of
+        # the struct can be specified with "struct foo { ...fields... }".
+        # If no name is given, then we have to create a new anonymous struct
+        # with no caching; in this case, the fields are either specified
+        # right now or never.
+        #
+        force_name = name
+        name = type.name
+        #
+        # get the type or create it if needed
+        if name is None:
+            # 'force_name' is used to guess a more readable name for
+            # anonymous structs, for the common case "typedef struct { } foo".
+            if force_name is not None:
+                explicit_name = '$%s' % force_name
+            else:
+                self._anonymous_counter += 1
+                explicit_name = '$%d' % self._anonymous_counter
+            tp = None
+        else:
+            explicit_name = name
+            key = '%s %s' % (kind, name)
+            tp, _ = self._declarations.get(key, (None, None))
+        #
+        if tp is None:
+            if kind == 'struct':
+                tp = model.StructType(explicit_name, None, None, None)
+            elif kind == 'union':
+                tp = model.UnionType(explicit_name, None, None, None)
+            elif kind == 'enum':
+                if explicit_name == '__dotdotdot__':
+                    raise CDefError("Enums cannot be declared with ...")
+                tp = self._build_enum_type(explicit_name, type.values)
+            else:
+                raise AssertionError("kind = %r" % (kind,))
+            if name is not None:
+                self._declare(key, tp)
+        else:
+            if kind == 'enum' and type.values is not None:
+                raise NotImplementedError(
+                    "enum %s: the '{}' declaration should appear on the first "
+                    "time the enum is mentioned, not later" % explicit_name)
+        if not tp.forcename:
+            tp.force_the_name(force_name)
+        if tp.forcename and '$' in tp.name:
+            self._declare('anonymous %s' % tp.forcename, tp)
+        #
+        self._structnode2type[type] = tp
+        #
+        # enums: done here
+        if kind == 'enum':
+            return tp
+        #
+        # is there a 'type.decls'?  If yes, then this is the place in the
+        # C sources that declare the fields.  If no, then just return the
+        # existing type, possibly still incomplete.
+        if type.decls is None:
+            return tp
+        #
+        if tp.fldnames is not None:
+            raise CDefError("duplicate declaration of struct %s" % name)
+        fldnames = []
+        fldtypes = []
+        fldbitsize = []
+        fldquals = []
+        for decl in type.decls:
+            if (isinstance(decl.type, pycparser.c_ast.IdentifierType) and
+                    ''.join(decl.type.names) == '__dotdotdot__'):
+                # XXX pycparser is inconsistent: 'names' should be a list
+                # of strings, but is sometimes just one string.  Use
+                # str.join() as a way to cope with both.
+                self._make_partial(tp, nested)
+                continue
+            if decl.bitsize is None:
+                bitsize = -1
+            else:
+                bitsize = self._parse_constant(decl.bitsize)
+            self._partial_length = False
+            type, fqual = self._get_type_and_quals(decl.type,
+                                                   partial_length_ok=True)
+            if self._partial_length:
+                self._make_partial(tp, nested)
+            if isinstance(type, model.StructType) and type.partial:
+                self._make_partial(tp, nested)
+            fldnames.append(decl.name or '')
+            fldtypes.append(type)
+            fldbitsize.append(bitsize)
+            fldquals.append(fqual)
+        tp.fldnames = tuple(fldnames)
+        tp.fldtypes = tuple(fldtypes)
+        tp.fldbitsize = tuple(fldbitsize)
+        tp.fldquals = tuple(fldquals)
+        if fldbitsize != [-1] * len(fldbitsize):
+            if isinstance(tp, model.StructType) and tp.partial:
+                raise NotImplementedError("%s: using both bitfields and '...;'"
+                                          % (tp,))
+        tp.packed = self._options.get('packed')
+        if tp.completed:    # must be re-completed: it is not opaque any more
+            tp.completed = 0
+            self._recomplete.append(tp)
+        return tp
+
+    def _make_partial(self, tp, nested):
+        if not isinstance(tp, model.StructOrUnion):
+            raise CDefError("%s cannot be partial" % (tp,))
+        if not tp.has_c_name() and not nested:
+            raise NotImplementedError("%s is partial but has no C name" %(tp,))
+        tp.partial = True
+
+    def _parse_constant(self, exprnode, partial_length_ok=False):
+        # for now, limited to expressions that are an immediate number
+        # or positive/negative number
+        if isinstance(exprnode, pycparser.c_ast.Constant):
+            s = exprnode.value
+            if '0' <= s[0] <= '9':
+                s = s.rstrip('uUlL')
+                try:
+                    if s.startswith('0'):
+                        return int(s, 8)
+                    else:
+                        return int(s, 10)
+                except ValueError:
+                    if len(s) > 1:
+                        if s.lower()[0:2] == '0x':
+                            return int(s, 16)
+                        elif s.lower()[0:2] == '0b':
+                            return int(s, 2)
+                raise CDefError("invalid constant %r" % (s,))
+            elif s[0] == "'" and s[-1] == "'" and (
+                    len(s) == 3 or (len(s) == 4 and s[1] == "\\")):
+                return ord(s[-2])
+            else:
+                raise CDefError("invalid constant %r" % (s,))
+        #
+        if (isinstance(exprnode, pycparser.c_ast.UnaryOp) and
+                exprnode.op == '+'):
+            return self._parse_constant(exprnode.expr)
+        #
+        if (isinstance(exprnode, pycparser.c_ast.UnaryOp) and
+                exprnode.op == '-'):
+            return -self._parse_constant(exprnode.expr)
+        # load previously defined int constant
+        if (isinstance(exprnode, pycparser.c_ast.ID) and
+                exprnode.name in self._int_constants):
+            return self._int_constants[exprnode.name]
+        #
+        if (isinstance(exprnode, pycparser.c_ast.ID) and
+                    exprnode.name == '__dotdotdotarray__'):
+            if partial_length_ok:
+                self._partial_length = True
+                return '...'
+            raise FFIError(":%d: unsupported '[...]' here, cannot derive "
+                           "the actual array length in this context"
+                           % exprnode.coord.line)
+        #
+        if isinstance(exprnode, pycparser.c_ast.BinaryOp):
+            left = self._parse_constant(exprnode.left)
+            right = self._parse_constant(exprnode.right)
+            if exprnode.op == '+':
+                return left + right
+            elif exprnode.op == '-':
+                return left - right
+            elif exprnode.op == '*':
+                return left * right
+            elif exprnode.op == '/':
+                return self._c_div(left, right)
+            elif exprnode.op == '%':
+                return left - self._c_div(left, right) * right
+            elif exprnode.op == '<<':
+                return left << right
+            elif exprnode.op == '>>':
+                return left >> right
+            elif exprnode.op == '&':
+                return left & right
+            elif exprnode.op == '|':
+                return left | right
+            elif exprnode.op == '^':
+                return left ^ right
+        #
+        raise FFIError(":%d: unsupported expression: expected a "
+                       "simple numeric constant" % exprnode.coord.line)
+
+    def _c_div(self, a, b):
+        result = a // b
+        if ((a < 0) ^ (b < 0)) and (a % b) != 0:
+            result += 1
+        return result
+
+    def _build_enum_type(self, explicit_name, decls):
+        if decls is not None:
+            partial = False
+            enumerators = []
+            enumvalues = []
+            nextenumvalue = 0
+            for enum in decls.enumerators:
+                if _r_enum_dotdotdot.match(enum.name):
+                    partial = True
+                    continue
+                if enum.value is not None:
+                    nextenumvalue = self._parse_constant(enum.value)
+                enumerators.append(enum.name)
+                enumvalues.append(nextenumvalue)
+                self._add_constants(enum.name, nextenumvalue)
+                nextenumvalue += 1
+            enumerators = tuple(enumerators)
+            enumvalues = tuple(enumvalues)
+            tp = model.EnumType(explicit_name, enumerators, enumvalues)
+            tp.partial = partial
+        else:   # opaque enum
+            tp = model.EnumType(explicit_name, (), ())
+        return tp
+
+    def include(self, other):
+        for name, (tp, quals) in other._declarations.items():
+            if name.startswith('anonymous $enum_$'):
+                continue   # fix for test_anonymous_enum_include
+            kind = name.split(' ', 1)[0]
+            if kind in ('struct', 'union', 'enum', 'anonymous', 'typedef'):
+                self._declare(name, tp, included=True, quals=quals)
+        for k, v in other._int_constants.items():
+            self._add_constants(k, v)
+
+    def _get_unknown_type(self, decl):
+        typenames = decl.type.type.names
+        if typenames == ['__dotdotdot__']:
+            return model.unknown_type(decl.name)
+
+        if typenames == ['__dotdotdotint__']:
+            if self._uses_new_feature is None:
+                self._uses_new_feature = "'typedef int... %s'" % decl.name
+            return model.UnknownIntegerType(decl.name)
+
+        if typenames == ['__dotdotdotfloat__']:
+            # note: not for 'long double' so far
+            if self._uses_new_feature is None:
+                self._uses_new_feature = "'typedef float... %s'" % decl.name
+            return model.UnknownFloatType(decl.name)
+
+        raise FFIError(':%d: unsupported usage of "..." in typedef'
+                       % decl.coord.line)
+
+    def _get_unknown_ptr_type(self, decl):
+        if decl.type.type.type.names == ['__dotdotdot__']:
+            return model.unknown_ptr_type(decl.name)
+        raise FFIError(':%d: unsupported usage of "..." in typedef'
+                       % decl.coord.line)
diff --git a/myenv/lib/python3.9/site-packages/cffi/error.py b/myenv/lib/python3.9/site-packages/cffi/error.py
new file mode 100644
index 0000000..0a27247
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/error.py
@@ -0,0 +1,31 @@
+
+class FFIError(Exception):
+    __module__ = 'cffi'
+
+class CDefError(Exception):
+    __module__ = 'cffi'
+    def __str__(self):
+        try:
+            current_decl = self.args[1]
+            filename = current_decl.coord.file
+            linenum = current_decl.coord.line
+            prefix = '%s:%d: ' % (filename, linenum)
+        except (AttributeError, TypeError, IndexError):
+            prefix = ''
+        return '%s%s' % (prefix, self.args[0])
+
+class VerificationError(Exception):
+    """ An error raised when verification fails
+    """
+    __module__ = 'cffi'
+
+class VerificationMissing(Exception):
+    """ An error raised when incomplete structures are passed into
+    cdef, but no verification has been done
+    """
+    __module__ = 'cffi'
+
+class PkgConfigError(Exception):
+    """ An error raised for missing modules in pkg-config
+    """
+    __module__ = 'cffi'
diff --git a/myenv/lib/python3.9/site-packages/cffi/ffiplatform.py b/myenv/lib/python3.9/site-packages/cffi/ffiplatform.py
new file mode 100644
index 0000000..8531346
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/ffiplatform.py
@@ -0,0 +1,127 @@
+import sys, os
+from .error import VerificationError
+
+
+LIST_OF_FILE_NAMES = ['sources', 'include_dirs', 'library_dirs',
+                      'extra_objects', 'depends']
+
+def get_extension(srcfilename, modname, sources=(), **kwds):
+    _hack_at_distutils()
+    from distutils.core import Extension
+    allsources = [srcfilename]
+    for src in sources:
+        allsources.append(os.path.normpath(src))
+    return Extension(name=modname, sources=allsources, **kwds)
+
+def compile(tmpdir, ext, compiler_verbose=0, debug=None):
+    """Compile a C extension module using distutils."""
+
+    _hack_at_distutils()
+    saved_environ = os.environ.copy()
+    try:
+        outputfilename = _build(tmpdir, ext, compiler_verbose, debug)
+        outputfilename = os.path.abspath(outputfilename)
+    finally:
+        # workaround for a distutils bugs where some env vars can
+        # become longer and longer every time it is used
+        for key, value in saved_environ.items():
+            if os.environ.get(key) != value:
+                os.environ[key] = value
+    return outputfilename
+
+def _build(tmpdir, ext, compiler_verbose=0, debug=None):
+    # XXX compact but horrible :-(
+    from distutils.core import Distribution
+    import distutils.errors, distutils.log
+    #
+    dist = Distribution({'ext_modules': [ext]})
+    dist.parse_config_files()
+    options = dist.get_option_dict('build_ext')
+    if debug is None:
+        debug = sys.flags.debug
+    options['debug'] = ('ffiplatform', debug)
+    options['force'] = ('ffiplatform', True)
+    options['build_lib'] = ('ffiplatform', tmpdir)
+    options['build_temp'] = ('ffiplatform', tmpdir)
+    #
+    try:
+        old_level = distutils.log.set_threshold(0) or 0
+        try:
+            distutils.log.set_verbosity(compiler_verbose)
+            dist.run_command('build_ext')
+            cmd_obj = dist.get_command_obj('build_ext')
+            [soname] = cmd_obj.get_outputs()
+        finally:
+            distutils.log.set_threshold(old_level)
+    except (distutils.errors.CompileError,
+            distutils.errors.LinkError) as e:
+        raise VerificationError('%s: %s' % (e.__class__.__name__, e))
+    #
+    return soname
+
+try:
+    from os.path import samefile
+except ImportError:
+    def samefile(f1, f2):
+        return os.path.abspath(f1) == os.path.abspath(f2)
+
+def maybe_relative_path(path):
+    if not os.path.isabs(path):
+        return path      # already relative
+    dir = path
+    names = []
+    while True:
+        prevdir = dir
+        dir, name = os.path.split(prevdir)
+        if dir == prevdir or not dir:
+            return path     # failed to make it relative
+        names.append(name)
+        try:
+            if samefile(dir, os.curdir):
+                names.reverse()
+                return os.path.join(*names)
+        except OSError:
+            pass
+
+# ____________________________________________________________
+
+try:
+    int_or_long = (int, long)
+    import cStringIO
+except NameError:
+    int_or_long = int      # Python 3
+    import io as cStringIO
+
+def _flatten(x, f):
+    if isinstance(x, str):
+        f.write('%ds%s' % (len(x), x))
+    elif isinstance(x, dict):
+        keys = sorted(x.keys())
+        f.write('%dd' % len(keys))
+        for key in keys:
+            _flatten(key, f)
+            _flatten(x[key], f)
+    elif isinstance(x, (list, tuple)):
+        f.write('%dl' % len(x))
+        for value in x:
+            _flatten(value, f)
+    elif isinstance(x, int_or_long):
+        f.write('%di' % (x,))
+    else:
+        raise TypeError(
+            "the keywords to verify() contains unsupported object %r" % (x,))
+
+def flatten(x):
+    f = cStringIO.StringIO()
+    _flatten(x, f)
+    return f.getvalue()
+
+def _hack_at_distutils():
+    # Windows-only workaround for some configurations: see
+    # https://bugs.python.org/issue23246 (Python 2.7 with 
+    # a specific MS compiler suite download)
+    if sys.platform == "win32":
+        try:
+            import setuptools    # for side-effects, patches distutils
+        except ImportError:
+            pass
diff --git a/myenv/lib/python3.9/site-packages/cffi/lock.py b/myenv/lib/python3.9/site-packages/cffi/lock.py
new file mode 100644
index 0000000..db91b71
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/lock.py
@@ -0,0 +1,30 @@
+import sys
+
+if sys.version_info < (3,):
+    try:
+        from thread import allocate_lock
+    except ImportError:
+        from dummy_thread import allocate_lock
+else:
+    try:
+        from _thread import allocate_lock
+    except ImportError:
+        from _dummy_thread import allocate_lock
+
+
+##import sys
+##l1 = allocate_lock
+
+##class allocate_lock(object):
+##    def __init__(self):
+##        self._real = l1()
+##    def __enter__(self):
+##        for i in range(4, 0, -1):
+##            print sys._getframe(i).f_code
+##        print
+##        return self._real.__enter__()
+##    def __exit__(self, *args):
+##        return self._real.__exit__(*args)
+##    def acquire(self, f):
+##        assert f is False
+##        return self._real.acquire(f)
diff --git a/myenv/lib/python3.9/site-packages/cffi/model.py b/myenv/lib/python3.9/site-packages/cffi/model.py
new file mode 100644
index 0000000..ad1c176
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/model.py
@@ -0,0 +1,617 @@
+import types
+import weakref
+
+from .lock import allocate_lock
+from .error import CDefError, VerificationError, VerificationMissing
+
+# type qualifiers
+Q_CONST    = 0x01
+Q_RESTRICT = 0x02
+Q_VOLATILE = 0x04
+
+def qualify(quals, replace_with):
+    if quals & Q_CONST:
+        replace_with = ' const ' + replace_with.lstrip()
+    if quals & Q_VOLATILE:
+        replace_with = ' volatile ' + replace_with.lstrip()
+    if quals & Q_RESTRICT:
+        # It seems that __restrict is supported by gcc and msvc.
+        # If you hit some different compiler, add a #define in
+        # _cffi_include.h for it (and in its copies, documented there)
+        replace_with = ' __restrict ' + replace_with.lstrip()
+    return replace_with
+
+
+class BaseTypeByIdentity(object):
+    is_array_type = False
+    is_raw_function = False
+
+    def get_c_name(self, replace_with='', context='a C file', quals=0):
+        result = self.c_name_with_marker
+        assert result.count('&') == 1
+        # some logic duplication with ffi.getctype()... :-(
+        replace_with = replace_with.strip()
+        if replace_with:
+            if replace_with.startswith('*') and '&[' in result:
+                replace_with = '(%s)' % replace_with
+            elif not replace_with[0] in '[(':
+                replace_with = ' ' + replace_with
+        replace_with = qualify(quals, replace_with)
+        result = result.replace('&', replace_with)
+        if '$' in result:
+            raise VerificationError(
+                "cannot generate '%s' in %s: unknown type name"
+                % (self._get_c_name(), context))
+        return result
+
+    def _get_c_name(self):
+        return self.c_name_with_marker.replace('&', '')
+
+    def has_c_name(self):
+        return '$' not in self._get_c_name()
+
+    def is_integer_type(self):
+        return False
+
+    def get_cached_btype(self, ffi, finishlist, can_delay=False):
+        try:
+            BType = ffi._cached_btypes[self]
+        except KeyError:
+            BType = self.build_backend_type(ffi, finishlist)
+            BType2 = ffi._cached_btypes.setdefault(self, BType)
+            assert BType2 is BType
+        return BType
+
+    def __repr__(self):
+        return '<%s>' % (self._get_c_name(),)
+
+    def _get_items(self):
+        return [(name, getattr(self, name)) for name in self._attrs_]
+
+
+class BaseType(BaseTypeByIdentity):
+
+    def __eq__(self, other):
+        return (self.__class__ == other.__class__ and
+                self._get_items() == other._get_items())
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return hash((self.__class__, tuple(self._get_items())))
+
+
+class VoidType(BaseType):
+    _attrs_ = ()
+
+    def __init__(self):
+        self.c_name_with_marker = 'void&'
+
+    def build_backend_type(self, ffi, finishlist):
+        return global_cache(self, ffi, 'new_void_type')
+
+void_type = VoidType()
+
+
+class BasePrimitiveType(BaseType):
+    def is_complex_type(self):
+        return False
+
+
+class PrimitiveType(BasePrimitiveType):
+    _attrs_ = ('name',)
+
+    ALL_PRIMITIVE_TYPES = {
+        'char':               'c',
+        'short':              'i',
+        'int':                'i',
+        'long':               'i',
+        'long long':          'i',
+        'signed char':        'i',
+        'unsigned char':      'i',
+        'unsigned short':     'i',
+        'unsigned int':       'i',
+        'unsigned long':      'i',
+        'unsigned long long': 'i',
+        'float':              'f',
+        'double':             'f',
+        'long double':        'f',
+        'float _Complex':     'j',
+        'double _Complex':    'j',
+        '_Bool':              'i',
+        # the following types are not primitive in the C sense
+        'wchar_t':            'c',
+        'char16_t':           'c',
+        'char32_t':           'c',
+        'int8_t':             'i',
+        'uint8_t':            'i',
+        'int16_t':            'i',
+        'uint16_t':           'i',
+        'int32_t':            'i',
+        'uint32_t':           'i',
+        'int64_t':            'i',
+        'uint64_t':           'i',
+        'int_least8_t':       'i',
+        'uint_least8_t':      'i',
+        'int_least16_t':      'i',
+        'uint_least16_t':     'i',
+        'int_least32_t':      'i',
+        'uint_least32_t':     'i',
+        'int_least64_t':      'i',
+        'uint_least64_t':     'i',
+        'int_fast8_t':        'i',
+        'uint_fast8_t':       'i',
+        'int_fast16_t':       'i',
+        'uint_fast16_t':      'i',
+        'int_fast32_t':       'i',
+        'uint_fast32_t':      'i',
+        'int_fast64_t':       'i',
+        'uint_fast64_t':      'i',
+        'intptr_t':           'i',
+        'uintptr_t':          'i',
+        'intmax_t':           'i',
+        'uintmax_t':          'i',
+        'ptrdiff_t':          'i',
+        'size_t':             'i',
+        'ssize_t':            'i',
+        }
+
+    def __init__(self, name):
+        assert name in self.ALL_PRIMITIVE_TYPES
+        self.name = name
+        self.c_name_with_marker = name + '&'
+
+    def is_char_type(self):
+        return self.ALL_PRIMITIVE_TYPES[self.name] == 'c'
+    def is_integer_type(self):
+        return self.ALL_PRIMITIVE_TYPES[self.name] == 'i'
+    def is_float_type(self):
+        return self.ALL_PRIMITIVE_TYPES[self.name] == 'f'
+    def is_complex_type(self):
+        return self.ALL_PRIMITIVE_TYPES[self.name] == 'j'
+
+    def build_backend_type(self, ffi, finishlist):
+        return global_cache(self, ffi, 'new_primitive_type', self.name)
+
+
+class UnknownIntegerType(BasePrimitiveType):
+    _attrs_ = ('name',)
+
+    def __init__(self, name):
+        self.name = name
+        self.c_name_with_marker = name + '&'
+
+    def is_integer_type(self):
+        return True
+
+    def build_backend_type(self, ffi, finishlist):
+        raise NotImplementedError("integer type '%s' can only be used after "
+                                  "compilation" % self.name)
+
+class UnknownFloatType(BasePrimitiveType):
+    _attrs_ = ('name', )
+
+    def __init__(self, name):
+        self.name = name
+        self.c_name_with_marker = name + '&'
+
+    def build_backend_type(self, ffi, finishlist):
+        raise NotImplementedError("float type '%s' can only be used after "
+                                  "compilation" % self.name)
+
+
+class BaseFunctionType(BaseType):
+    _attrs_ = ('args', 'result', 'ellipsis', 'abi')
+
+    def __init__(self, args, result, ellipsis, abi=None):
+        self.args = args
+        self.result = result
+        self.ellipsis = ellipsis
+        self.abi = abi
+        #
+        reprargs = [arg._get_c_name() for arg in self.args]
+        if self.ellipsis:
+            reprargs.append('...')
+        reprargs = reprargs or ['void']
+        replace_with = self._base_pattern % (', '.join(reprargs),)
+        if abi is not None:
+            replace_with = replace_with[:1] + abi + ' ' + replace_with[1:]
+        self.c_name_with_marker = (
+            self.result.c_name_with_marker.replace('&', replace_with))
+
+
+class RawFunctionType(BaseFunctionType):
+    # Corresponds to a C type like 'int(int)', which is the C type of
+    # a function, but not a pointer-to-function.  The backend has no
+    # notion of such a type; it's used temporarily by parsing.
+    _base_pattern = '(&)(%s)'
+    is_raw_function = True
+
+    def build_backend_type(self, ffi, finishlist):
+        raise CDefError("cannot render the type %r: it is a function "
+                        "type, not a pointer-to-function type" % (self,))
+
+    def as_function_pointer(self):
+        return FunctionPtrType(self.args, self.result, self.ellipsis, self.abi)
+
+
+class FunctionPtrType(BaseFunctionType):
+    _base_pattern = '(*&)(%s)'
+
+    def build_backend_type(self, ffi, finishlist):
+        result = self.result.get_cached_btype(ffi, finishlist)
+        args = []
+        for tp in self.args:
+            args.append(tp.get_cached_btype(ffi, finishlist))
+        abi_args = ()
+        if self.abi == "__stdcall":
+            if not self.ellipsis:    # __stdcall ignored for variadic funcs
+                try:
+                    abi_args = (ffi._backend.FFI_STDCALL,)
+                except AttributeError:
+                    pass
+        return global_cache(self, ffi, 'new_function_type',
+                            tuple(args), result, self.ellipsis, *abi_args)
+
+    def as_raw_function(self):
+        return RawFunctionType(self.args, self.result, self.ellipsis, self.abi)
+
+
+class PointerType(BaseType):
+    _attrs_ = ('totype', 'quals')
+
+    def __init__(self, totype, quals=0):
+        self.totype = totype
+        self.quals = quals
+        extra = qualify(quals, " *&")
+        if totype.is_array_type:
+            extra = "(%s)" % (extra.lstrip(),)
+        self.c_name_with_marker = totype.c_name_with_marker.replace('&', extra)
+
+    def build_backend_type(self, ffi, finishlist):
+        BItem = self.totype.get_cached_btype(ffi, finishlist, can_delay=True)
+        return global_cache(self, ffi, 'new_pointer_type', BItem)
+
+voidp_type = PointerType(void_type)
+
+def ConstPointerType(totype):
+    return PointerType(totype, Q_CONST)
+
+const_voidp_type = ConstPointerType(void_type)
+
+
+class NamedPointerType(PointerType):
+    _attrs_ = ('totype', 'name')
+
+    def __init__(self, totype, name, quals=0):
+        PointerType.__init__(self, totype, quals)
+        self.name = name
+        self.c_name_with_marker = name + '&'
+
+
+class ArrayType(BaseType):
+    _attrs_ = ('item', 'length')
+    is_array_type = True
+
+    def __init__(self, item, length):
+        self.item = item
+        self.length = length
+        #
+        if length is None:
+            brackets = '&[]'
+        elif length == '...':
+            brackets = '&[/*...*/]'
+        else:
+            brackets = '&[%s]' % length
+        self.c_name_with_marker = (
+            self.item.c_name_with_marker.replace('&', brackets))
+
+    def length_is_unknown(self):
+        return isinstance(self.length, str)
+
+    def resolve_length(self, newlength):
+        return ArrayType(self.item, newlength)
+
+    def build_backend_type(self, ffi, finishlist):
+        if self.length_is_unknown():
+            raise CDefError("cannot render the type %r: unknown length" %
+                            (self,))
+        self.item.get_cached_btype(ffi, finishlist)   # force the item BType
+        BPtrItem = PointerType(self.item).get_cached_btype(ffi, finishlist)
+        return global_cache(self, ffi, 'new_array_type', BPtrItem, self.length)
+
+char_array_type = ArrayType(PrimitiveType('char'), None)
+
+
+class StructOrUnionOrEnum(BaseTypeByIdentity):
+    _attrs_ = ('name',)
+    forcename = None
+
+    def build_c_name_with_marker(self):
+        name = self.forcename or '%s %s' % (self.kind, self.name)
+        self.c_name_with_marker = name + '&'
+
+    def force_the_name(self, forcename):
+        self.forcename = forcename
+        self.build_c_name_with_marker()
+
+    def get_official_name(self):
+        assert self.c_name_with_marker.endswith('&')
+        return self.c_name_with_marker[:-1]
+
+
+class StructOrUnion(StructOrUnionOrEnum):
+    fixedlayout = None
+    completed = 0
+    partial = False
+    packed = 0
+
+    def __init__(self, name, fldnames, fldtypes, fldbitsize, fldquals=None):
+        self.name = name
+        self.fldnames = fldnames
+        self.fldtypes = fldtypes
+        self.fldbitsize = fldbitsize
+        self.fldquals = fldquals
+        self.build_c_name_with_marker()
+
+    def anonymous_struct_fields(self):
+        if self.fldtypes is not None:
+            for name, type in zip(self.fldnames, self.fldtypes):
+                if name == '' and isinstance(type, StructOrUnion):
+                    yield type
+
+    def enumfields(self, expand_anonymous_struct_union=True):
+        fldquals = self.fldquals
+        if fldquals is None:
+            fldquals = (0,) * len(self.fldnames)
+        for name, type, bitsize, quals in zip(self.fldnames, self.fldtypes,
+                                              self.fldbitsize, fldquals):
+            if (name == '' and isinstance(type, StructOrUnion)
+                    and expand_anonymous_struct_union):
+                # nested anonymous struct/union
+                for result in type.enumfields():
+                    yield result
+            else:
+                yield (name, type, bitsize, quals)
+
+    def force_flatten(self):
+        # force the struct or union to have a declaration that lists
+        # directly all fields returned by enumfields(), flattening
+        # nested anonymous structs/unions.
+        names = []
+        types = []
+        bitsizes = []
+        fldquals = []
+        for name, type, bitsize, quals in self.enumfields():
+            names.append(name)
+            types.append(type)
+            bitsizes.append(bitsize)
+            fldquals.append(quals)
+        self.fldnames = tuple(names)
+        self.fldtypes = tuple(types)
+        self.fldbitsize = tuple(bitsizes)
+        self.fldquals = tuple(fldquals)
+
+    def get_cached_btype(self, ffi, finishlist, can_delay=False):
+        BType = StructOrUnionOrEnum.get_cached_btype(self, ffi, finishlist,
+                                                     can_delay)
+        if not can_delay:
+            self.finish_backend_type(ffi, finishlist)
+        return BType
+
+    def finish_backend_type(self, ffi, finishlist):
+        if self.completed:
+            if self.completed != 2:
+                raise NotImplementedError("recursive structure declaration "
+                                          "for '%s'" % (self.name,))
+            return
+        BType = ffi._cached_btypes[self]
+        #
+        self.completed = 1
+        #
+        if self.fldtypes is None:
+            pass    # not completing it: it's an opaque struct
+            #
+        elif self.fixedlayout is None:
+            fldtypes = [tp.get_cached_btype(ffi, finishlist)
+                        for tp in self.fldtypes]
+            lst = list(zip(self.fldnames, fldtypes, self.fldbitsize))
+            extra_flags = ()
+            if self.packed:
+                if self.packed == 1:
+                    extra_flags = (8,)    # SF_PACKED
+                else:
+                    extra_flags = (0, self.packed)
+            ffi._backend.complete_struct_or_union(BType, lst, self,
+                                                  -1, -1, *extra_flags)
+            #
+        else:
+            fldtypes = []
+            fieldofs, fieldsize, totalsize, totalalignment = self.fixedlayout
+            for i in range(len(self.fldnames)):
+                fsize = fieldsize[i]
+                ftype = self.fldtypes[i]
+                #
+                if isinstance(ftype, ArrayType) and ftype.length_is_unknown():
+                    # fix the length to match the total size
+                    BItemType = ftype.item.get_cached_btype(ffi, finishlist)
+                    nlen, nrest = divmod(fsize, ffi.sizeof(BItemType))
+                    if nrest != 0:
+                        self._verification_error(
+                            "field '%s.%s' has a bogus size?" % (
+                            self.name, self.fldnames[i] or '{}'))
+                    ftype = ftype.resolve_length(nlen)
+                    self.fldtypes = (self.fldtypes[:i] + (ftype,) +
+                                     self.fldtypes[i+1:])
+                #
+                BFieldType = ftype.get_cached_btype(ffi, finishlist)
+                if isinstance(ftype, ArrayType) and ftype.length is None:
+                    assert fsize == 0
+                else:
+                    bitemsize = ffi.sizeof(BFieldType)
+                    if bitemsize != fsize:
+                        self._verification_error(
+                            "field '%s.%s' is declared as %d bytes, but is "
+                            "really %d bytes" % (self.name,
+                                                 self.fldnames[i] or '{}',
+                                                 bitemsize, fsize))
+                fldtypes.append(BFieldType)
+            #
+            lst = list(zip(self.fldnames, fldtypes, self.fldbitsize, fieldofs))
+            ffi._backend.complete_struct_or_union(BType, lst, self,
+                                                  totalsize, totalalignment)
+        self.completed = 2
+
+    def _verification_error(self, msg):
+        raise VerificationError(msg)
+
+    def check_not_partial(self):
+        if self.partial and self.fixedlayout is None:
+            raise VerificationMissing(self._get_c_name())
+
+    def build_backend_type(self, ffi, finishlist):
+        self.check_not_partial()
+        finishlist.append(self)
+        #
+        return global_cache(self, ffi, 'new_%s_type' % self.kind,
+                            self.get_official_name(), key=self)
+
+
+class StructType(StructOrUnion):
+    kind = 'struct'
+
+
+class UnionType(StructOrUnion):
+    kind = 'union'
+
+
+class EnumType(StructOrUnionOrEnum):
+    kind = 'enum'
+    partial = False
+    partial_resolved = False
+
+    def __init__(self, name, enumerators, enumvalues, baseinttype=None):
+        self.name = name
+        self.enumerators = enumerators
+        self.enumvalues = enumvalues
+        self.baseinttype = baseinttype
+        self.build_c_name_with_marker()
+
+    def force_the_name(self, forcename):
+        StructOrUnionOrEnum.force_the_name(self, forcename)
+        if self.forcename is None:
+            name = self.get_official_name()
+            self.forcename = '$' + name.replace(' ', '_')
+
+    def check_not_partial(self):
+        if self.partial and not self.partial_resolved:
+            raise VerificationMissing(self._get_c_name())
+
+    def build_backend_type(self, ffi, finishlist):
+        self.check_not_partial()
+        base_btype = self.build_baseinttype(ffi, finishlist)
+        return global_cache(self, ffi, 'new_enum_type',
+                            self.get_official_name(),
+                            self.enumerators, self.enumvalues,
+                            base_btype, key=self)
+
+    def build_baseinttype(self, ffi, finishlist):
+        if self.baseinttype is not None:
+            return self.baseinttype.get_cached_btype(ffi, finishlist)
+        #
+        if self.enumvalues:
+            smallest_value = min(self.enumvalues)
+            largest_value = max(self.enumvalues)
+        else:
+            import warnings
+            try:
+                # XXX!  The goal is to ensure that the warnings.warn()
+                # will not suppress the warning.  We want to get it
+                # several times if we reach this point several times.
+                __warningregistry__.clear()
+            except NameError:
+                pass
+            warnings.warn("%r has no values explicitly defined; "
+                          "guessing that it is equivalent to 'unsigned int'"
+                          % self._get_c_name())
+            smallest_value = largest_value = 0
+        if smallest_value < 0:   # needs a signed type
+            sign = 1
+            candidate1 = PrimitiveType("int")
+            candidate2 = PrimitiveType("long")
+        else:
+            sign = 0
+            candidate1 = PrimitiveType("unsigned int")
+            candidate2 = PrimitiveType("unsigned long")
+        btype1 = candidate1.get_cached_btype(ffi, finishlist)
+        btype2 = candidate2.get_cached_btype(ffi, finishlist)
+        size1 = ffi.sizeof(btype1)
+        size2 = ffi.sizeof(btype2)
+        if (smallest_value >= ((-1) << (8*size1-1)) and
+            largest_value < (1 << (8*size1-sign))):
+            return btype1
+        if (smallest_value >= ((-1) << (8*size2-1)) and
+            largest_value < (1 << (8*size2-sign))):
+            return btype2
+        raise CDefError("%s values don't all fit into either 'long' "
+                        "or 'unsigned long'" % self._get_c_name())
+
+def unknown_type(name, structname=None):
+    if structname is None:
+        structname = '$%s' % name
+    tp = StructType(structname, None, None, None)
+    tp.force_the_name(name)
+    tp.origin = "unknown_type"
+    return tp
+
+def unknown_ptr_type(name, structname=None):
+    if structname is None:
+        structname = '$$%s' % name
+    tp = StructType(structname, None, None, None)
+    return NamedPointerType(tp, name)
+
+
+global_lock = allocate_lock()
+_typecache_cffi_backend = weakref.WeakValueDictionary()
+
+def get_typecache(backend):
+    # returns _typecache_cffi_backend if backend is the _cffi_backend
+    # module, or type(backend).__typecache if backend is an instance of
+    # CTypesBackend (or some FakeBackend class during tests)
+    if isinstance(backend, types.ModuleType):
+        return _typecache_cffi_backend
+    with global_lock:
+        if not hasattr(type(backend), '__typecache'):
+            type(backend).__typecache = weakref.WeakValueDictionary()
+        return type(backend).__typecache
+
+def global_cache(srctype, ffi, funcname, *args, **kwds):
+    key = kwds.pop('key', (funcname, args))
+    assert not kwds
+    try:
+        return ffi._typecache[key]
+    except KeyError:
+        pass
+    try:
+        res = getattr(ffi._backend, funcname)(*args)
+    except NotImplementedError as e:
+        raise NotImplementedError("%s: %r: %s" % (funcname, srctype, e))
+    # note that setdefault() on WeakValueDictionary is not atomic
+    # and contains a rare bug (http://bugs.python.org/issue19542);
+    # we have to use a lock and do it ourselves
+    cache = ffi._typecache
+    with global_lock:
+        res1 = cache.get(key)
+        if res1 is None:
+            cache[key] = res
+            return res
+        else:
+            return res1
+
+def pointer_cache(ffi, BType):
+    return global_cache('?', ffi, 'new_pointer_type', BType)
+
+def attach_exception_info(e, name):
+    if e.args and type(e.args[0]) is str:
+        e.args = ('%s: %s' % (name, e.args[0]),) + e.args[1:]
diff --git a/myenv/lib/python3.9/site-packages/cffi/parse_c_type.h b/myenv/lib/python3.9/site-packages/cffi/parse_c_type.h
new file mode 100644
index 0000000..84e4ef8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/parse_c_type.h
@@ -0,0 +1,181 @@
+
+/* This part is from file 'cffi/parse_c_type.h'.  It is copied at the
+   beginning of C sources generated by CFFI's ffi.set_source(). */
+
+typedef void *_cffi_opcode_t;
+
+#define _CFFI_OP(opcode, arg)   (_cffi_opcode_t)(opcode | (((uintptr_t)(arg)) << 8))
+#define _CFFI_GETOP(cffi_opcode)    ((unsigned char)(uintptr_t)cffi_opcode)
+#define _CFFI_GETARG(cffi_opcode)   (((intptr_t)cffi_opcode) >> 8)
+
+#define _CFFI_OP_PRIMITIVE       1
+#define _CFFI_OP_POINTER         3
+#define _CFFI_OP_ARRAY           5
+#define _CFFI_OP_OPEN_ARRAY      7
+#define _CFFI_OP_STRUCT_UNION    9
+#define _CFFI_OP_ENUM           11
+#define _CFFI_OP_FUNCTION       13
+#define _CFFI_OP_FUNCTION_END   15
+#define _CFFI_OP_NOOP           17
+#define _CFFI_OP_BITFIELD       19
+#define _CFFI_OP_TYPENAME       21
+#define _CFFI_OP_CPYTHON_BLTN_V 23   // varargs
+#define _CFFI_OP_CPYTHON_BLTN_N 25   // noargs
+#define _CFFI_OP_CPYTHON_BLTN_O 27   // O  (i.e. a single arg)
+#define _CFFI_OP_CONSTANT       29
+#define _CFFI_OP_CONSTANT_INT   31
+#define _CFFI_OP_GLOBAL_VAR     33
+#define _CFFI_OP_DLOPEN_FUNC    35
+#define _CFFI_OP_DLOPEN_CONST   37
+#define _CFFI_OP_GLOBAL_VAR_F   39
+#define _CFFI_OP_EXTERN_PYTHON  41
+
+#define _CFFI_PRIM_VOID          0
+#define _CFFI_PRIM_BOOL          1
+#define _CFFI_PRIM_CHAR          2
+#define _CFFI_PRIM_SCHAR         3
+#define _CFFI_PRIM_UCHAR         4
+#define _CFFI_PRIM_SHORT         5
+#define _CFFI_PRIM_USHORT        6
+#define _CFFI_PRIM_INT           7
+#define _CFFI_PRIM_UINT          8
+#define _CFFI_PRIM_LONG          9
+#define _CFFI_PRIM_ULONG        10
+#define _CFFI_PRIM_LONGLONG     11
+#define _CFFI_PRIM_ULONGLONG    12
+#define _CFFI_PRIM_FLOAT        13
+#define _CFFI_PRIM_DOUBLE       14
+#define _CFFI_PRIM_LONGDOUBLE   15
+
+#define _CFFI_PRIM_WCHAR        16
+#define _CFFI_PRIM_INT8         17
+#define _CFFI_PRIM_UINT8        18
+#define _CFFI_PRIM_INT16        19
+#define _CFFI_PRIM_UINT16       20
+#define _CFFI_PRIM_INT32        21
+#define _CFFI_PRIM_UINT32       22
+#define _CFFI_PRIM_INT64        23
+#define _CFFI_PRIM_UINT64       24
+#define _CFFI_PRIM_INTPTR       25
+#define _CFFI_PRIM_UINTPTR      26
+#define _CFFI_PRIM_PTRDIFF      27
+#define _CFFI_PRIM_SIZE         28
+#define _CFFI_PRIM_SSIZE        29
+#define _CFFI_PRIM_INT_LEAST8   30
+#define _CFFI_PRIM_UINT_LEAST8  31
+#define _CFFI_PRIM_INT_LEAST16  32
+#define _CFFI_PRIM_UINT_LEAST16 33
+#define _CFFI_PRIM_INT_LEAST32  34
+#define _CFFI_PRIM_UINT_LEAST32 35
+#define _CFFI_PRIM_INT_LEAST64  36
+#define _CFFI_PRIM_UINT_LEAST64 37
+#define _CFFI_PRIM_INT_FAST8    38
+#define _CFFI_PRIM_UINT_FAST8   39
+#define _CFFI_PRIM_INT_FAST16   40
+#define _CFFI_PRIM_UINT_FAST16  41
+#define _CFFI_PRIM_INT_FAST32   42
+#define _CFFI_PRIM_UINT_FAST32  43
+#define _CFFI_PRIM_INT_FAST64   44
+#define _CFFI_PRIM_UINT_FAST64  45
+#define _CFFI_PRIM_INTMAX       46
+#define _CFFI_PRIM_UINTMAX      47
+#define _CFFI_PRIM_FLOATCOMPLEX 48
+#define _CFFI_PRIM_DOUBLECOMPLEX 49
+#define _CFFI_PRIM_CHAR16       50
+#define _CFFI_PRIM_CHAR32       51
+
+#define _CFFI__NUM_PRIM         52
+#define _CFFI__UNKNOWN_PRIM           (-1)
+#define _CFFI__UNKNOWN_FLOAT_PRIM     (-2)
+#define _CFFI__UNKNOWN_LONG_DOUBLE    (-3)
+
+#define _CFFI__IO_FILE_STRUCT         (-1)
+
+
+struct _cffi_global_s {
+    const char *name;
+    void *address;
+    _cffi_opcode_t type_op;
+    void *size_or_direct_fn;  // OP_GLOBAL_VAR: size, or 0 if unknown
+                              // OP_CPYTHON_BLTN_*: addr of direct function
+};
+
+struct _cffi_getconst_s {
+    unsigned long long value;
+    const struct _cffi_type_context_s *ctx;
+    int gindex;
+};
+
+struct _cffi_struct_union_s {
+    const char *name;
+    int type_index;          // -> _cffi_types, on a OP_STRUCT_UNION
+    int flags;               // _CFFI_F_* flags below
+    size_t size;
+    int alignment;
+    int first_field_index;   // -> _cffi_fields array
+    int num_fields;
+};
+#define _CFFI_F_UNION         0x01   // is a union, not a struct
+#define _CFFI_F_CHECK_FIELDS  0x02   // complain if fields are not in the
+                                     // "standard layout" or if some are missing
+#define _CFFI_F_PACKED        0x04   // for CHECK_FIELDS, assume a packed struct
+#define _CFFI_F_EXTERNAL      0x08   // in some other ffi.include()
+#define _CFFI_F_OPAQUE        0x10   // opaque
+
+struct _cffi_field_s {
+    const char *name;
+    size_t field_offset;
+    size_t field_size;
+    _cffi_opcode_t field_type_op;
+};
+
+struct _cffi_enum_s {
+    const char *name;
+    int type_index;          // -> _cffi_types, on a OP_ENUM
+    int type_prim;           // _CFFI_PRIM_xxx
+    const char *enumerators; // comma-delimited string
+};
+
+struct _cffi_typename_s {
+    const char *name;
+    int type_index;   /* if opaque, points to a possibly artificial
+                         OP_STRUCT which is itself opaque */
+};
+
+struct _cffi_type_context_s {
+    _cffi_opcode_t *types;
+    const struct _cffi_global_s *globals;
+    const struct _cffi_field_s *fields;
+    const struct _cffi_struct_union_s *struct_unions;
+    const struct _cffi_enum_s *enums;
+    const struct _cffi_typename_s *typenames;
+    int num_globals;
+    int num_struct_unions;
+    int num_enums;
+    int num_typenames;
+    const char *const *includes;
+    int num_types;
+    int flags;      /* future extension */
+};
+
+struct _cffi_parse_info_s {
+    const struct _cffi_type_context_s *ctx;
+    _cffi_opcode_t *output;
+    unsigned int output_size;
+    size_t error_location;
+    const char *error_message;
+};
+
+struct _cffi_externpy_s {
+    const char *name;
+    size_t size_of_result;
+    void *reserved1, *reserved2;
+};
+
+#ifdef _CFFI_INTERNAL
+static int parse_c_type(struct _cffi_parse_info_s *info, const char *input);
+static int search_in_globals(const struct _cffi_type_context_s *ctx,
+                             const char *search, size_t search_len);
+static int search_in_struct_unions(const struct _cffi_type_context_s *ctx,
+                                   const char *search, size_t search_len);
+#endif
diff --git a/myenv/lib/python3.9/site-packages/cffi/pkgconfig.py b/myenv/lib/python3.9/site-packages/cffi/pkgconfig.py
new file mode 100644
index 0000000..5c93f15
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/pkgconfig.py
@@ -0,0 +1,121 @@
+# pkg-config, https://www.freedesktop.org/wiki/Software/pkg-config/ integration for cffi
+import sys, os, subprocess
+
+from .error import PkgConfigError
+
+
+def merge_flags(cfg1, cfg2):
+    """Merge values from cffi config flags cfg2 to cf1
+
+    Example:
+        merge_flags({"libraries": ["one"]}, {"libraries": ["two"]})
+        {"libraries": ["one", "two"]}
+    """
+    for key, value in cfg2.items():
+        if key not in cfg1:
+            cfg1[key] = value
+        else:
+            if not isinstance(cfg1[key], list):
+                raise TypeError("cfg1[%r] should be a list of strings" % (key,))
+            if not isinstance(value, list):
+                raise TypeError("cfg2[%r] should be a list of strings" % (key,))
+            cfg1[key].extend(value)
+    return cfg1
+
+
+def call(libname, flag, encoding=sys.getfilesystemencoding()):
+    """Calls pkg-config and returns the output if found
+    """
+    a = ["pkg-config", "--print-errors"]
+    a.append(flag)
+    a.append(libname)
+    try:
+        pc = subprocess.Popen(a, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    except EnvironmentError as e:
+        raise PkgConfigError("cannot run pkg-config: %s" % (str(e).strip(),))
+
+    bout, berr = pc.communicate()
+    if pc.returncode != 0:
+        try:
+            berr = berr.decode(encoding)
+        except Exception:
+            pass
+        raise PkgConfigError(berr.strip())
+
+    if sys.version_info >= (3,) and not isinstance(bout, str):   # Python 3.x
+        try:
+            bout = bout.decode(encoding)
+        except UnicodeDecodeError:
+            raise PkgConfigError("pkg-config %s %s returned bytes that cannot "
+                                 "be decoded with encoding %r:\n%r" %
+                                 (flag, libname, encoding, bout))
+
+    if os.altsep != '\\' and '\\' in bout:
+        raise PkgConfigError("pkg-config %s %s returned an unsupported "
+                             "backslash-escaped output:\n%r" %
+                             (flag, libname, bout))
+    return bout
+
+
+def flags_from_pkgconfig(libs):
+    r"""Return compiler line flags for FFI.set_source based on pkg-config output
+
+    Usage
+        ...
+        ffibuilder.set_source("_foo", pkgconfig = ["libfoo", "libbar >= 1.8.3"])
+
+    If pkg-config is installed on build machine, then arguments include_dirs,
+    library_dirs, libraries, define_macros, extra_compile_args and
+    extra_link_args are extended with an output of pkg-config for libfoo and
+    libbar.
+
+    Raises PkgConfigError in case the pkg-config call fails.
+    """
+
+    def get_include_dirs(string):
+        return [x[2:] for x in string.split() if x.startswith("-I")]
+
+    def get_library_dirs(string):
+        return [x[2:] for x in string.split() if x.startswith("-L")]
+
+    def get_libraries(string):
+        return [x[2:] for x in string.split() if x.startswith("-l")]
+
+    # convert -Dfoo=bar to list of tuples [("foo", "bar")] expected by distutils
+    def get_macros(string):
+        def _macro(x):
+            x = x[2:]    # drop "-D"
+            if '=' in x:
+                return tuple(x.split("=", 1))  # "-Dfoo=bar" => ("foo", "bar")
+            else:
+                return (x, None)               # "-Dfoo" => ("foo", None)
+        return [_macro(x) for x in string.split() if x.startswith("-D")]
+
+    def get_other_cflags(string):
+        return [x for x in string.split() if not x.startswith("-I") and
+                                             not x.startswith("-D")]
+
+    def get_other_libs(string):
+        return [x for x in string.split() if not x.startswith("-L") and
+                                             not x.startswith("-l")]
+
+    # return kwargs for given libname
+    def kwargs(libname):
+        fse = sys.getfilesystemencoding()
+        all_cflags = call(libname, "--cflags")
+        all_libs = call(libname, "--libs")
+        return {
+            "include_dirs": get_include_dirs(all_cflags),
+            "library_dirs": get_library_dirs(all_libs),
+            "libraries": get_libraries(all_libs),
+            "define_macros": get_macros(all_cflags),
+            "extra_compile_args": get_other_cflags(all_cflags),
+            "extra_link_args": get_other_libs(all_libs),
+            }
+
+    # merge all arguments together
+    ret = {}
+    for libname in libs:
+        lib_flags = kwargs(libname)
+        merge_flags(ret, lib_flags)
+    return ret
diff --git a/myenv/lib/python3.9/site-packages/cffi/recompiler.py b/myenv/lib/python3.9/site-packages/cffi/recompiler.py
new file mode 100644
index 0000000..5d9d32d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/recompiler.py
@@ -0,0 +1,1581 @@
+import os, sys, io
+from . import ffiplatform, model
+from .error import VerificationError
+from .cffi_opcode import *
+
+VERSION_BASE = 0x2601
+VERSION_EMBEDDED = 0x2701
+VERSION_CHAR16CHAR32 = 0x2801
+
+USE_LIMITED_API = (sys.platform != 'win32' or sys.version_info < (3, 0) or
+                   sys.version_info >= (3, 5))
+
+
+class GlobalExpr:
+    def __init__(self, name, address, type_op, size=0, check_value=0):
+        self.name = name
+        self.address = address
+        self.type_op = type_op
+        self.size = size
+        self.check_value = check_value
+
+    def as_c_expr(self):
+        return '  { "%s", (void *)%s, %s, (void *)%s },' % (
+            self.name, self.address, self.type_op.as_c_expr(), self.size)
+
+    def as_python_expr(self):
+        return "b'%s%s',%d" % (self.type_op.as_python_bytes(), self.name,
+                               self.check_value)
+
+class FieldExpr:
+    def __init__(self, name, field_offset, field_size, fbitsize, field_type_op):
+        self.name = name
+        self.field_offset = field_offset
+        self.field_size = field_size
+        self.fbitsize = fbitsize
+        self.field_type_op = field_type_op
+
+    def as_c_expr(self):
+        spaces = " " * len(self.name)
+        return ('  { "%s", %s,\n' % (self.name, self.field_offset) +
+                '     %s   %s,\n' % (spaces, self.field_size) +
+                '     %s   %s },' % (spaces, self.field_type_op.as_c_expr()))
+
+    def as_python_expr(self):
+        raise NotImplementedError
+
+    def as_field_python_expr(self):
+        if self.field_type_op.op == OP_NOOP:
+            size_expr = ''
+        elif self.field_type_op.op == OP_BITFIELD:
+            size_expr = format_four_bytes(self.fbitsize)
+        else:
+            raise NotImplementedError
+        return "b'%s%s%s'" % (self.field_type_op.as_python_bytes(),
+                              size_expr,
+                              self.name)
+
+class StructUnionExpr:
+    def __init__(self, name, type_index, flags, size, alignment, comment,
+                 first_field_index, c_fields):
+        self.name = name
+        self.type_index = type_index
+        self.flags = flags
+        self.size = size
+        self.alignment = alignment
+        self.comment = comment
+        self.first_field_index = first_field_index
+        self.c_fields = c_fields
+
+    def as_c_expr(self):
+        return ('  { "%s", %d, %s,' % (self.name, self.type_index, self.flags)
+                + '\n    %s, %s, ' % (self.size, self.alignment)
+                + '%d, %d ' % (self.first_field_index, len(self.c_fields))
+                + ('/* %s */ ' % self.comment if self.comment else '')
+                + '},')
+
+    def as_python_expr(self):
+        flags = eval(self.flags, G_FLAGS)
+        fields_expr = [c_field.as_field_python_expr()
+                       for c_field in self.c_fields]
+        return "(b'%s%s%s',%s)" % (
+            format_four_bytes(self.type_index),
+            format_four_bytes(flags),
+            self.name,
+            ','.join(fields_expr))
+
+class EnumExpr:
+    def __init__(self, name, type_index, size, signed, allenums):
+        self.name = name
+        self.type_index = type_index
+        self.size = size
+        self.signed = signed
+        self.allenums = allenums
+
+    def as_c_expr(self):
+        return ('  { "%s", %d, _cffi_prim_int(%s, %s),\n'
+                '    "%s" },' % (self.name, self.type_index,
+                                 self.size, self.signed, self.allenums))
+
+    def as_python_expr(self):
+        prim_index = {
+            (1, 0): PRIM_UINT8,  (1, 1):  PRIM_INT8,
+            (2, 0): PRIM_UINT16, (2, 1):  PRIM_INT16,
+            (4, 0): PRIM_UINT32, (4, 1):  PRIM_INT32,
+            (8, 0): PRIM_UINT64, (8, 1):  PRIM_INT64,
+            }[self.size, self.signed]
+        return "b'%s%s%s\\x00%s'" % (format_four_bytes(self.type_index),
+                                     format_four_bytes(prim_index),
+                                     self.name, self.allenums)
+
+class TypenameExpr:
+    def __init__(self, name, type_index):
+        self.name = name
+        self.type_index = type_index
+
+    def as_c_expr(self):
+        return '  { "%s", %d },' % (self.name, self.type_index)
+
+    def as_python_expr(self):
+        return "b'%s%s'" % (format_four_bytes(self.type_index), self.name)
+
+
+# ____________________________________________________________
+
+
+class Recompiler:
+    _num_externpy = 0
+
+    def __init__(self, ffi, module_name, target_is_python=False):
+        self.ffi = ffi
+        self.module_name = module_name
+        self.target_is_python = target_is_python
+        self._version = VERSION_BASE
+
+    def needs_version(self, ver):
+        self._version = max(self._version, ver)
+
+    def collect_type_table(self):
+        self._typesdict = {}
+        self._generate("collecttype")
+        #
+        all_decls = sorted(self._typesdict, key=str)
+        #
+        # prepare all FUNCTION bytecode sequences first
+        self.cffi_types = []
+        for tp in all_decls:
+            if tp.is_raw_function:
+                assert self._typesdict[tp] is None
+                self._typesdict[tp] = len(self.cffi_types)
+                self.cffi_types.append(tp)     # placeholder
+                for tp1 in tp.args:
+                    assert isinstance(tp1, (model.VoidType,
+                                            model.BasePrimitiveType,
+                                            model.PointerType,
+                                            model.StructOrUnionOrEnum,
+                                            model.FunctionPtrType))
+                    if self._typesdict[tp1] is None:
+                        self._typesdict[tp1] = len(self.cffi_types)
+                    self.cffi_types.append(tp1)   # placeholder
+                self.cffi_types.append('END')     # placeholder
+        #
+        # prepare all OTHER bytecode sequences
+        for tp in all_decls:
+            if not tp.is_raw_function and self._typesdict[tp] is None:
+                self._typesdict[tp] = len(self.cffi_types)
+                self.cffi_types.append(tp)        # placeholder
+                if tp.is_array_type and tp.length is not None:
+                    self.cffi_types.append('LEN') # placeholder
+        assert None not in self._typesdict.values()
+        #
+        # collect all structs and unions and enums
+        self._struct_unions = {}
+        self._enums = {}
+        for tp in all_decls:
+            if isinstance(tp, model.StructOrUnion):
+                self._struct_unions[tp] = None
+            elif isinstance(tp, model.EnumType):
+                self._enums[tp] = None
+        for i, tp in enumerate(sorted(self._struct_unions,
+                                      key=lambda tp: tp.name)):
+            self._struct_unions[tp] = i
+        for i, tp in enumerate(sorted(self._enums,
+                                      key=lambda tp: tp.name)):
+            self._enums[tp] = i
+        #
+        # emit all bytecode sequences now
+        for tp in all_decls:
+            method = getattr(self, '_emit_bytecode_' + tp.__class__.__name__)
+            method(tp, self._typesdict[tp])
+        #
+        # consistency check
+        for op in self.cffi_types:
+            assert isinstance(op, CffiOp)
+        self.cffi_types = tuple(self.cffi_types)    # don't change any more
+
+    def _enum_fields(self, tp):
+        # When producing C, expand all anonymous struct/union fields.
+        # That's necessary to have C code checking the offsets of the
+        # individual fields contained in them.  When producing Python,
+        # don't do it and instead write it like it is, with the
+        # corresponding fields having an empty name.  Empty names are
+        # recognized at runtime when we import the generated Python
+        # file.
+        expand_anonymous_struct_union = not self.target_is_python
+        return tp.enumfields(expand_anonymous_struct_union)
+
+    def _do_collect_type(self, tp):
+        if not isinstance(tp, model.BaseTypeByIdentity):
+            if isinstance(tp, tuple):
+                for x in tp:
+                    self._do_collect_type(x)
+            return
+        if tp not in self._typesdict:
+            self._typesdict[tp] = None
+            if isinstance(tp, model.FunctionPtrType):
+                self._do_collect_type(tp.as_raw_function())
+            elif isinstance(tp, model.StructOrUnion):
+                if tp.fldtypes is not None and (
+                        tp not in self.ffi._parser._included_declarations):
+                    for name1, tp1, _, _ in self._enum_fields(tp):
+                        self._do_collect_type(self._field_type(tp, name1, tp1))
+            else:
+                for _, x in tp._get_items():
+                    self._do_collect_type(x)
+
+    def _generate(self, step_name):
+        lst = self.ffi._parser._declarations.items()
+        for name, (tp, quals) in sorted(lst):
+            kind, realname = name.split(' ', 1)
+            try:
+                method = getattr(self, '_generate_cpy_%s_%s' % (kind,
+                                                                step_name))
+            except AttributeError:
+                raise VerificationError(
+                    "not implemented in recompile(): %r" % name)
+            try:
+                self._current_quals = quals
+                method(tp, realname)
+            except Exception as e:
+                model.attach_exception_info(e, name)
+                raise
+
+    # ----------
+
+    ALL_STEPS = ["global", "field", "struct_union", "enum", "typename"]
+
+    def collect_step_tables(self):
+        # collect the declarations for '_cffi_globals', '_cffi_typenames', etc.
+        self._lsts = {}
+        for step_name in self.ALL_STEPS:
+            self._lsts[step_name] = []
+        self._seen_struct_unions = set()
+        self._generate("ctx")
+        self._add_missing_struct_unions()
+        #
+        for step_name in self.ALL_STEPS:
+            lst = self._lsts[step_name]
+            if step_name != "field":
+                lst.sort(key=lambda entry: entry.name)
+            self._lsts[step_name] = tuple(lst)    # don't change any more
+        #
+        # check for a possible internal inconsistency: _cffi_struct_unions
+        # should have been generated with exactly self._struct_unions
+        lst = self._lsts["struct_union"]
+        for tp, i in self._struct_unions.items():
+            assert i < len(lst)
+            assert lst[i].name == tp.name
+        assert len(lst) == len(self._struct_unions)
+        # same with enums
+        lst = self._lsts["enum"]
+        for tp, i in self._enums.items():
+            assert i < len(lst)
+            assert lst[i].name == tp.name
+        assert len(lst) == len(self._enums)
+
+    # ----------
+
+    def _prnt(self, what=''):
+        self._f.write(what + '\n')
+
+    def write_source_to_f(self, f, preamble):
+        if self.target_is_python:
+            assert preamble is None
+            self.write_py_source_to_f(f)
+        else:
+            assert preamble is not None
+            self.write_c_source_to_f(f, preamble)
+
+    def _rel_readlines(self, filename):
+        g = open(os.path.join(os.path.dirname(__file__), filename), 'r')
+        lines = g.readlines()
+        g.close()
+        return lines
+
+    def write_c_source_to_f(self, f, preamble):
+        self._f = f
+        prnt = self._prnt
+        if self.ffi._embedding is not None:
+            prnt('#define _CFFI_USE_EMBEDDING')
+        if not USE_LIMITED_API:
+            prnt('#define _CFFI_NO_LIMITED_API')
+        #
+        # first the '#include' (actually done by inlining the file's content)
+        lines = self._rel_readlines('_cffi_include.h')
+        i = lines.index('#include "parse_c_type.h"\n')
+        lines[i:i+1] = self._rel_readlines('parse_c_type.h')
+        prnt(''.join(lines))
+        #
+        # if we have ffi._embedding != None, we give it here as a macro
+        # and include an extra file
+        base_module_name = self.module_name.split('.')[-1]
+        if self.ffi._embedding is not None:
+            prnt('#define _CFFI_MODULE_NAME  "%s"' % (self.module_name,))
+            prnt('static const char _CFFI_PYTHON_STARTUP_CODE[] = {')
+            self._print_string_literal_in_array(self.ffi._embedding)
+            prnt('0 };')
+            prnt('#ifdef PYPY_VERSION')
+            prnt('# define _CFFI_PYTHON_STARTUP_FUNC  _cffi_pypyinit_%s' % (
+                base_module_name,))
+            prnt('#elif PY_MAJOR_VERSION >= 3')
+            prnt('# define _CFFI_PYTHON_STARTUP_FUNC  PyInit_%s' % (
+                base_module_name,))
+            prnt('#else')
+            prnt('# define _CFFI_PYTHON_STARTUP_FUNC  init%s' % (
+                base_module_name,))
+            prnt('#endif')
+            lines = self._rel_readlines('_embedding.h')
+            i = lines.index('#include "_cffi_errors.h"\n')
+            lines[i:i+1] = self._rel_readlines('_cffi_errors.h')
+            prnt(''.join(lines))
+            self.needs_version(VERSION_EMBEDDED)
+        #
+        # then paste the C source given by the user, verbatim.
+        prnt('/************************************************************/')
+        prnt()
+        prnt(preamble)
+        prnt()
+        prnt('/************************************************************/')
+        prnt()
+        #
+        # the declaration of '_cffi_types'
+        prnt('static void *_cffi_types[] = {')
+        typeindex2type = dict([(i, tp) for (tp, i) in self._typesdict.items()])
+        for i, op in enumerate(self.cffi_types):
+            comment = ''
+            if i in typeindex2type:
+                comment = ' // ' + typeindex2type[i]._get_c_name()
+            prnt('/* %2d */ %s,%s' % (i, op.as_c_expr(), comment))
+        if not self.cffi_types:
+            prnt('  0')
+        prnt('};')
+        prnt()
+        #
+        # call generate_cpy_xxx_decl(), for every xxx found from
+        # ffi._parser._declarations.  This generates all the functions.
+        self._seen_constants = set()
+        self._generate("decl")
+        #
+        # the declaration of '_cffi_globals' and '_cffi_typenames'
+        nums = {}
+        for step_name in self.ALL_STEPS:
+            lst = self._lsts[step_name]
+            nums[step_name] = len(lst)
+            if nums[step_name] > 0:
+                prnt('static const struct _cffi_%s_s _cffi_%ss[] = {' % (
+                    step_name, step_name))
+                for entry in lst:
+                    prnt(entry.as_c_expr())
+                prnt('};')
+                prnt()
+        #
+        # the declaration of '_cffi_includes'
+        if self.ffi._included_ffis:
+            prnt('static const char * const _cffi_includes[] = {')
+            for ffi_to_include in self.ffi._included_ffis:
+                try:
+                    included_module_name, included_source = (
+                        ffi_to_include._assigned_source[:2])
+                except AttributeError:
+                    raise VerificationError(
+                        "ffi object %r includes %r, but the latter has not "
+                        "been prepared with set_source()" % (
+                            self.ffi, ffi_to_include,))
+                if included_source is None:
+                    raise VerificationError(
+                        "not implemented yet: ffi.include() of a Python-based "
+                        "ffi inside a C-based ffi")
+                prnt('  "%s",' % (included_module_name,))
+            prnt('  NULL')
+            prnt('};')
+            prnt()
+        #
+        # the declaration of '_cffi_type_context'
+        prnt('static const struct _cffi_type_context_s _cffi_type_context = {')
+        prnt('  _cffi_types,')
+        for step_name in self.ALL_STEPS:
+            if nums[step_name] > 0:
+                prnt('  _cffi_%ss,' % step_name)
+            else:
+                prnt('  NULL,  /* no %ss */' % step_name)
+        for step_name in self.ALL_STEPS:
+            if step_name != "field":
+                prnt('  %d,  /* num_%ss */' % (nums[step_name], step_name))
+        if self.ffi._included_ffis:
+            prnt('  _cffi_includes,')
+        else:
+            prnt('  NULL,  /* no includes */')
+        prnt('  %d,  /* num_types */' % (len(self.cffi_types),))
+        flags = 0
+        if self._num_externpy > 0 or self.ffi._embedding is not None:
+            flags |= 1     # set to mean that we use extern "Python"
+        prnt('  %d,  /* flags */' % flags)
+        prnt('};')
+        prnt()
+        #
+        # the init function
+        prnt('#ifdef __GNUC__')
+        prnt('#  pragma GCC visibility push(default)  /* for -fvisibility= */')
+        prnt('#endif')
+        prnt()
+        prnt('#ifdef PYPY_VERSION')
+        prnt('PyMODINIT_FUNC')
+        prnt('_cffi_pypyinit_%s(const void *p[])' % (base_module_name,))
+        prnt('{')
+        if flags & 1:
+            prnt('    if (((intptr_t)p[0]) >= 0x0A03) {')
+            prnt('        _cffi_call_python_org = '
+                 '(void(*)(struct _cffi_externpy_s *, char *))p[1];')
+            prnt('    }')
+        prnt('    p[0] = (const void *)0x%x;' % self._version)
+        prnt('    p[1] = &_cffi_type_context;')
+        prnt('#if PY_MAJOR_VERSION >= 3')
+        prnt('    return NULL;')
+        prnt('#endif')
+        prnt('}')
+        # on Windows, distutils insists on putting init_cffi_xyz in
+        # 'export_symbols', so instead of fighting it, just give up and
+        # give it one
+        prnt('#  ifdef _MSC_VER')
+        prnt('     PyMODINIT_FUNC')
+        prnt('#  if PY_MAJOR_VERSION >= 3')
+        prnt('     PyInit_%s(void) { return NULL; }' % (base_module_name,))
+        prnt('#  else')
+        prnt('     init%s(void) { }' % (base_module_name,))
+        prnt('#  endif')
+        prnt('#  endif')
+        prnt('#elif PY_MAJOR_VERSION >= 3')
+        prnt('PyMODINIT_FUNC')
+        prnt('PyInit_%s(void)' % (base_module_name,))
+        prnt('{')
+        prnt('  return _cffi_init("%s", 0x%x, &_cffi_type_context);' % (
+            self.module_name, self._version))
+        prnt('}')
+        prnt('#else')
+        prnt('PyMODINIT_FUNC')
+        prnt('init%s(void)' % (base_module_name,))
+        prnt('{')
+        prnt('  _cffi_init("%s", 0x%x, &_cffi_type_context);' % (
+            self.module_name, self._version))
+        prnt('}')
+        prnt('#endif')
+        prnt()
+        prnt('#ifdef __GNUC__')
+        prnt('#  pragma GCC visibility pop')
+        prnt('#endif')
+        self._version = None
+
+    def _to_py(self, x):
+        if isinstance(x, str):
+            return "b'%s'" % (x,)
+        if isinstance(x, (list, tuple)):
+            rep = [self._to_py(item) for item in x]
+            if len(rep) == 1:
+                rep.append('')
+            return "(%s)" % (','.join(rep),)
+        return x.as_python_expr()  # Py2: unicode unexpected; Py3: bytes unexp.
+
+    def write_py_source_to_f(self, f):
+        self._f = f
+        prnt = self._prnt
+        #
+        # header
+        prnt("# auto-generated file")
+        prnt("import _cffi_backend")
+        #
+        # the 'import' of the included ffis
+        num_includes = len(self.ffi._included_ffis or ())
+        for i in range(num_includes):
+            ffi_to_include = self.ffi._included_ffis[i]
+            try:
+                included_module_name, included_source = (
+                    ffi_to_include._assigned_source[:2])
+            except AttributeError:
+                raise VerificationError(
+                    "ffi object %r includes %r, but the latter has not "
+                    "been prepared with set_source()" % (
+                        self.ffi, ffi_to_include,))
+            if included_source is not None:
+                raise VerificationError(
+                    "not implemented yet: ffi.include() of a C-based "
+                    "ffi inside a Python-based ffi")
+            prnt('from %s import ffi as _ffi%d' % (included_module_name, i))
+        prnt()
+        prnt("ffi = _cffi_backend.FFI('%s'," % (self.module_name,))
+        prnt("    _version = 0x%x," % (self._version,))
+        self._version = None
+        #
+        # the '_types' keyword argument
+        self.cffi_types = tuple(self.cffi_types)    # don't change any more
+        types_lst = [op.as_python_bytes() for op in self.cffi_types]
+        prnt('    _types = %s,' % (self._to_py(''.join(types_lst)),))
+        typeindex2type = dict([(i, tp) for (tp, i) in self._typesdict.items()])
+        #
+        # the keyword arguments from ALL_STEPS
+        for step_name in self.ALL_STEPS:
+            lst = self._lsts[step_name]
+            if len(lst) > 0 and step_name != "field":
+                prnt('    _%ss = %s,' % (step_name, self._to_py(lst)))
+        #
+        # the '_includes' keyword argument
+        if num_includes > 0:
+            prnt('    _includes = (%s,),' % (
+                ', '.join(['_ffi%d' % i for i in range(num_includes)]),))
+        #
+        # the footer
+        prnt(')')
+
+    # ----------
+
+    def _gettypenum(self, type):
+        # a KeyError here is a bug.  please report it! :-)
+        return self._typesdict[type]
+
+    def _convert_funcarg_to_c(self, tp, fromvar, tovar, errcode):
+        extraarg = ''
+        if isinstance(tp, model.BasePrimitiveType) and not tp.is_complex_type():
+            if tp.is_integer_type() and tp.name != '_Bool':
+                converter = '_cffi_to_c_int'
+                extraarg = ', %s' % tp.name
+            elif isinstance(tp, model.UnknownFloatType):
+                # don't check with is_float_type(): it may be a 'long
+                # double' here, and _cffi_to_c_double would loose precision
+                converter = '(%s)_cffi_to_c_double' % (tp.get_c_name(''),)
+            else:
+                cname = tp.get_c_name('')
+                converter = '(%s)_cffi_to_c_%s' % (cname,
+                                                   tp.name.replace(' ', '_'))
+                if cname in ('char16_t', 'char32_t'):
+                    self.needs_version(VERSION_CHAR16CHAR32)
+            errvalue = '-1'
+        #
+        elif isinstance(tp, model.PointerType):
+            self._convert_funcarg_to_c_ptr_or_array(tp, fromvar,
+                                                    tovar, errcode)
+            return
+        #
+        elif (isinstance(tp, model.StructOrUnionOrEnum) or
+              isinstance(tp, model.BasePrimitiveType)):
+            # a struct (not a struct pointer) as a function argument;
+            # or, a complex (the same code works)
+            self._prnt('  if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)'
+                      % (tovar, self._gettypenum(tp), fromvar))
+            self._prnt('    %s;' % errcode)
+            return
+        #
+        elif isinstance(tp, model.FunctionPtrType):
+            converter = '(%s)_cffi_to_c_pointer' % tp.get_c_name('')
+            extraarg = ', _cffi_type(%d)' % self._gettypenum(tp)
+            errvalue = 'NULL'
+        #
+        else:
+            raise NotImplementedError(tp)
+        #
+        self._prnt('  %s = %s(%s%s);' % (tovar, converter, fromvar, extraarg))
+        self._prnt('  if (%s == (%s)%s && PyErr_Occurred())' % (
+            tovar, tp.get_c_name(''), errvalue))
+        self._prnt('    %s;' % errcode)
+
+    def _extra_local_variables(self, tp, localvars, freelines):
+        if isinstance(tp, model.PointerType):
+            localvars.add('Py_ssize_t datasize')
+            localvars.add('struct _cffi_freeme_s *large_args_free = NULL')
+            freelines.add('if (large_args_free != NULL)'
+                          ' _cffi_free_array_arguments(large_args_free);')
+
+    def _convert_funcarg_to_c_ptr_or_array(self, tp, fromvar, tovar, errcode):
+        self._prnt('  datasize = _cffi_prepare_pointer_call_argument(')
+        self._prnt('      _cffi_type(%d), %s, (char **)&%s);' % (
+            self._gettypenum(tp), fromvar, tovar))
+        self._prnt('  if (datasize != 0) {')
+        self._prnt('    %s = ((size_t)datasize) <= 640 ? '
+                   '(%s)alloca((size_t)datasize) : NULL;' % (
+            tovar, tp.get_c_name('')))
+        self._prnt('    if (_cffi_convert_array_argument(_cffi_type(%d), %s, '
+                   '(char **)&%s,' % (self._gettypenum(tp), fromvar, tovar))
+        self._prnt('            datasize, &large_args_free) < 0)')
+        self._prnt('      %s;' % errcode)
+        self._prnt('  }')
+
+    def _convert_expr_from_c(self, tp, var, context):
+        if isinstance(tp, model.BasePrimitiveType):
+            if tp.is_integer_type() and tp.name != '_Bool':
+                return '_cffi_from_c_int(%s, %s)' % (var, tp.name)
+            elif isinstance(tp, model.UnknownFloatType):
+                return '_cffi_from_c_double(%s)' % (var,)
+            elif tp.name != 'long double' and not tp.is_complex_type():
+                cname = tp.name.replace(' ', '_')
+                if cname in ('char16_t', 'char32_t'):
+                    self.needs_version(VERSION_CHAR16CHAR32)
+                return '_cffi_from_c_%s(%s)' % (cname, var)
+            else:
+                return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % (
+                    var, self._gettypenum(tp))
+        elif isinstance(tp, (model.PointerType, model.FunctionPtrType)):
+            return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % (
+                var, self._gettypenum(tp))
+        elif isinstance(tp, model.ArrayType):
+            return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % (
+                var, self._gettypenum(model.PointerType(tp.item)))
+        elif isinstance(tp, model.StructOrUnion):
+            if tp.fldnames is None:
+                raise TypeError("'%s' is used as %s, but is opaque" % (
+                    tp._get_c_name(), context))
+            return '_cffi_from_c_struct((char *)&%s, _cffi_type(%d))' % (
+                var, self._gettypenum(tp))
+        elif isinstance(tp, model.EnumType):
+            return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % (
+                var, self._gettypenum(tp))
+        else:
+            raise NotImplementedError(tp)
+
+    # ----------
+    # typedefs
+
+    def _typedef_type(self, tp, name):
+        return self._global_type(tp, "(*(%s *)0)" % (name,))
+
+    def _generate_cpy_typedef_collecttype(self, tp, name):
+        self._do_collect_type(self._typedef_type(tp, name))
+
+    def _generate_cpy_typedef_decl(self, tp, name):
+        pass
+
+    def _typedef_ctx(self, tp, name):
+        type_index = self._typesdict[tp]
+        self._lsts["typename"].append(TypenameExpr(name, type_index))
+
+    def _generate_cpy_typedef_ctx(self, tp, name):
+        tp = self._typedef_type(tp, name)
+        self._typedef_ctx(tp, name)
+        if getattr(tp, "origin", None) == "unknown_type":
+            self._struct_ctx(tp, tp.name, approxname=None)
+        elif isinstance(tp, model.NamedPointerType):
+            self._struct_ctx(tp.totype, tp.totype.name, approxname=tp.name,
+                             named_ptr=tp)
+
+    # ----------
+    # function declarations
+
+    def _generate_cpy_function_collecttype(self, tp, name):
+        self._do_collect_type(tp.as_raw_function())
+        if tp.ellipsis and not self.target_is_python:
+            self._do_collect_type(tp)
+
+    def _generate_cpy_function_decl(self, tp, name):
+        assert not self.target_is_python
+        assert isinstance(tp, model.FunctionPtrType)
+        if tp.ellipsis:
+            # cannot support vararg functions better than this: check for its
+            # exact type (including the fixed arguments), and build it as a
+            # constant function pointer (no CPython wrapper)
+            self._generate_cpy_constant_decl(tp, name)
+            return
+        prnt = self._prnt
+        numargs = len(tp.args)
+        if numargs == 0:
+            argname = 'noarg'
+        elif numargs == 1:
+            argname = 'arg0'
+        else:
+            argname = 'args'
+        #
+        # ------------------------------
+        # the 'd' version of the function, only for addressof(lib, 'func')
+        arguments = []
+        call_arguments = []
+        context = 'argument of %s' % name
+        for i, type in enumerate(tp.args):
+            arguments.append(type.get_c_name(' x%d' % i, context))
+            call_arguments.append('x%d' % i)
+        repr_arguments = ', '.join(arguments)
+        repr_arguments = repr_arguments or 'void'
+        if tp.abi:
+            abi = tp.abi + ' '
+        else:
+            abi = ''
+        name_and_arguments = '%s_cffi_d_%s(%s)' % (abi, name, repr_arguments)
+        prnt('static %s' % (tp.result.get_c_name(name_and_arguments),))
+        prnt('{')
+        call_arguments = ', '.join(call_arguments)
+        result_code = 'return '
+        if isinstance(tp.result, model.VoidType):
+            result_code = ''
+        prnt('  %s%s(%s);' % (result_code, name, call_arguments))
+        prnt('}')
+        #
+        prnt('#ifndef PYPY_VERSION')        # ------------------------------
+        #
+        prnt('static PyObject *')
+        prnt('_cffi_f_%s(PyObject *self, PyObject *%s)' % (name, argname))
+        prnt('{')
+        #
+        context = 'argument of %s' % name
+        for i, type in enumerate(tp.args):
+            arg = type.get_c_name(' x%d' % i, context)
+            prnt('  %s;' % arg)
+        #
+        localvars = set()
+        freelines = set()
+        for type in tp.args:
+            self._extra_local_variables(type, localvars, freelines)
+        for decl in sorted(localvars):
+            prnt('  %s;' % (decl,))
+        #
+        if not isinstance(tp.result, model.VoidType):
+            result_code = 'result = '
+            context = 'result of %s' % name
+            result_decl = '  %s;' % tp.result.get_c_name(' result', context)
+            prnt(result_decl)
+            prnt('  PyObject *pyresult;')
+        else:
+            result_decl = None
+            result_code = ''
+        #
+        if len(tp.args) > 1:
+            rng = range(len(tp.args))
+            for i in rng:
+                prnt('  PyObject *arg%d;' % i)
+            prnt()
+            prnt('  if (!PyArg_UnpackTuple(args, "%s", %d, %d, %s))' % (
+                name, len(rng), len(rng),
+                ', '.join(['&arg%d' % i for i in rng])))
+            prnt('    return NULL;')
+        prnt()
+        #
+        for i, type in enumerate(tp.args):
+            self._convert_funcarg_to_c(type, 'arg%d' % i, 'x%d' % i,
+                                       'return NULL')
+            prnt()
+        #
+        prnt('  Py_BEGIN_ALLOW_THREADS')
+        prnt('  _cffi_restore_errno();')
+        call_arguments = ['x%d' % i for i in range(len(tp.args))]
+        call_arguments = ', '.join(call_arguments)
+        prnt('  { %s%s(%s); }' % (result_code, name, call_arguments))
+        prnt('  _cffi_save_errno();')
+        prnt('  Py_END_ALLOW_THREADS')
+        prnt()
+        #
+        prnt('  (void)self; /* unused */')
+        if numargs == 0:
+            prnt('  (void)noarg; /* unused */')
+        if result_code:
+            prnt('  pyresult = %s;' %
+                 self._convert_expr_from_c(tp.result, 'result', 'result type'))
+            for freeline in freelines:
+                prnt('  ' + freeline)
+            prnt('  return pyresult;')
+        else:
+            for freeline in freelines:
+                prnt('  ' + freeline)
+            prnt('  Py_INCREF(Py_None);')
+            prnt('  return Py_None;')
+        prnt('}')
+        #
+        prnt('#else')        # ------------------------------
+        #
+        # the PyPy version: need to replace struct/union arguments with
+        # pointers, and if the result is a struct/union, insert a first
+        # arg that is a pointer to the result.  We also do that for
+        # complex args and return type.
+        def need_indirection(type):
+            return (isinstance(type, model.StructOrUnion) or
+                    (isinstance(type, model.PrimitiveType) and
+                     type.is_complex_type()))
+        difference = False
+        arguments = []
+        call_arguments = []
+        context = 'argument of %s' % name
+        for i, type in enumerate(tp.args):
+            indirection = ''
+            if need_indirection(type):
+                indirection = '*'
+                difference = True
+            arg = type.get_c_name(' %sx%d' % (indirection, i), context)
+            arguments.append(arg)
+            call_arguments.append('%sx%d' % (indirection, i))
+        tp_result = tp.result
+        if need_indirection(tp_result):
+            context = 'result of %s' % name
+            arg = tp_result.get_c_name(' *result', context)
+            arguments.insert(0, arg)
+            tp_result = model.void_type
+            result_decl = None
+            result_code = '*result = '
+            difference = True
+        if difference:
+            repr_arguments = ', '.join(arguments)
+            repr_arguments = repr_arguments or 'void'
+            name_and_arguments = '%s_cffi_f_%s(%s)' % (abi, name,
+                                                       repr_arguments)
+            prnt('static %s' % (tp_result.get_c_name(name_and_arguments),))
+            prnt('{')
+            if result_decl:
+                prnt(result_decl)
+            call_arguments = ', '.join(call_arguments)
+            prnt('  { %s%s(%s); }' % (result_code, name, call_arguments))
+            if result_decl:
+                prnt('  return result;')
+            prnt('}')
+        else:
+            prnt('#  define _cffi_f_%s _cffi_d_%s' % (name, name))
+        #
+        prnt('#endif')        # ------------------------------
+        prnt()
+
+    def _generate_cpy_function_ctx(self, tp, name):
+        if tp.ellipsis and not self.target_is_python:
+            self._generate_cpy_constant_ctx(tp, name)
+            return
+        type_index = self._typesdict[tp.as_raw_function()]
+        numargs = len(tp.args)
+        if self.target_is_python:
+            meth_kind = OP_DLOPEN_FUNC
+        elif numargs == 0:
+            meth_kind = OP_CPYTHON_BLTN_N   # 'METH_NOARGS'
+        elif numargs == 1:
+            meth_kind = OP_CPYTHON_BLTN_O   # 'METH_O'
+        else:
+            meth_kind = OP_CPYTHON_BLTN_V   # 'METH_VARARGS'
+        self._lsts["global"].append(
+            GlobalExpr(name, '_cffi_f_%s' % name,
+                       CffiOp(meth_kind, type_index),
+                       size='_cffi_d_%s' % name))
+
+    # ----------
+    # named structs or unions
+
+    def _field_type(self, tp_struct, field_name, tp_field):
+        if isinstance(tp_field, model.ArrayType):
+            actual_length = tp_field.length
+            if actual_length == '...':
+                ptr_struct_name = tp_struct.get_c_name('*')
+                actual_length = '_cffi_array_len(((%s)0)->%s)' % (
+                    ptr_struct_name, field_name)
+            tp_item = self._field_type(tp_struct, '%s[0]' % field_name,
+                                       tp_field.item)
+            tp_field = model.ArrayType(tp_item, actual_length)
+        return tp_field
+
+    def _struct_collecttype(self, tp):
+        self._do_collect_type(tp)
+        if self.target_is_python:
+            # also requires nested anon struct/unions in ABI mode, recursively
+            for fldtype in tp.anonymous_struct_fields():
+                self._struct_collecttype(fldtype)
+
+    def _struct_decl(self, tp, cname, approxname):
+        if tp.fldtypes is None:
+            return
+        prnt = self._prnt
+        checkfuncname = '_cffi_checkfld_%s' % (approxname,)
+        prnt('_CFFI_UNUSED_FN')
+        prnt('static void %s(%s *p)' % (checkfuncname, cname))
+        prnt('{')
+        prnt('  /* only to generate compile-time warnings or errors */')
+        prnt('  (void)p;')
+        for fname, ftype, fbitsize, fqual in self._enum_fields(tp):
+            try:
+                if ftype.is_integer_type() or fbitsize >= 0:
+                    # accept all integers, but complain on float or double
+                    if fname != '':
+                        prnt("  (void)((p->%s) | 0);  /* check that '%s.%s' is "
+                             "an integer */" % (fname, cname, fname))
+                    continue
+                # only accept exactly the type declared, except that '[]'
+                # is interpreted as a '*' and so will match any array length.
+                # (It would also match '*', but that's harder to detect...)
+                while (isinstance(ftype, model.ArrayType)
+                       and (ftype.length is None or ftype.length == '...')):
+                    ftype = ftype.item
+                    fname = fname + '[0]'
+                prnt('  { %s = &p->%s; (void)tmp; }' % (
+                    ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual),
+                    fname))
+            except VerificationError as e:
+                prnt('  /* %s */' % str(e))   # cannot verify it, ignore
+        prnt('}')
+        prnt('struct _cffi_align_%s { char x; %s y; };' % (approxname, cname))
+        prnt()
+
+    def _struct_ctx(self, tp, cname, approxname, named_ptr=None):
+        type_index = self._typesdict[tp]
+        reason_for_not_expanding = None
+        flags = []
+        if isinstance(tp, model.UnionType):
+            flags.append("_CFFI_F_UNION")
+        if tp.fldtypes is None:
+            flags.append("_CFFI_F_OPAQUE")
+            reason_for_not_expanding = "opaque"
+        if (tp not in self.ffi._parser._included_declarations and
+                (named_ptr is None or
+                 named_ptr not in self.ffi._parser._included_declarations)):
+            if tp.fldtypes is None:
+                pass    # opaque
+            elif tp.partial or any(tp.anonymous_struct_fields()):
+                pass    # field layout obtained silently from the C compiler
+            else:
+                flags.append("_CFFI_F_CHECK_FIELDS")
+            if tp.packed:
+                if tp.packed > 1:
+                    raise NotImplementedError(
+                        "%r is declared with 'pack=%r'; only 0 or 1 are "
+                        "supported in API mode (try to use \"...;\", which "
+                        "does not require a 'pack' declaration)" %
+                        (tp, tp.packed))
+                flags.append("_CFFI_F_PACKED")
+        else:
+            flags.append("_CFFI_F_EXTERNAL")
+            reason_for_not_expanding = "external"
+        flags = '|'.join(flags) or '0'
+        c_fields = []
+        if reason_for_not_expanding is None:
+            enumfields = list(self._enum_fields(tp))
+            for fldname, fldtype, fbitsize, fqual in enumfields:
+                fldtype = self._field_type(tp, fldname, fldtype)
+                self._check_not_opaque(fldtype,
+                                       "field '%s.%s'" % (tp.name, fldname))
+                # cname is None for _add_missing_struct_unions() only
+                op = OP_NOOP
+                if fbitsize >= 0:
+                    op = OP_BITFIELD
+                    size = '%d /* bits */' % fbitsize
+                elif cname is None or (
+                        isinstance(fldtype, model.ArrayType) and
+                        fldtype.length is None):
+                    size = '(size_t)-1'
+                else:
+                    size = 'sizeof(((%s)0)->%s)' % (
+                        tp.get_c_name('*') if named_ptr is None
+                                           else named_ptr.name,
+                        fldname)
+                if cname is None or fbitsize >= 0:
+                    offset = '(size_t)-1'
+                elif named_ptr is not None:
+                    offset = '((char *)&((%s)0)->%s) - (char *)0' % (
+                        named_ptr.name, fldname)
+                else:
+                    offset = 'offsetof(%s, %s)' % (tp.get_c_name(''), fldname)
+                c_fields.append(
+                    FieldExpr(fldname, offset, size, fbitsize,
+                              CffiOp(op, self._typesdict[fldtype])))
+            first_field_index = len(self._lsts["field"])
+            self._lsts["field"].extend(c_fields)
+            #
+            if cname is None:  # unknown name, for _add_missing_struct_unions
+                size = '(size_t)-2'
+                align = -2
+                comment = "unnamed"
+            else:
+                if named_ptr is not None:
+                    size = 'sizeof(*(%s)0)' % (named_ptr.name,)
+                    align = '-1 /* unknown alignment */'
+                else:
+                    size = 'sizeof(%s)' % (cname,)
+                    align = 'offsetof(struct _cffi_align_%s, y)' % (approxname,)
+                comment = None
+        else:
+            size = '(size_t)-1'
+            align = -1
+            first_field_index = -1
+            comment = reason_for_not_expanding
+        self._lsts["struct_union"].append(
+            StructUnionExpr(tp.name, type_index, flags, size, align, comment,
+                            first_field_index, c_fields))
+        self._seen_struct_unions.add(tp)
+
+    def _check_not_opaque(self, tp, location):
+        while isinstance(tp, model.ArrayType):
+            tp = tp.item
+        if isinstance(tp, model.StructOrUnion) and tp.fldtypes is None:
+            raise TypeError(
+                "%s is of an opaque type (not declared in cdef())" % location)
+
+    def _add_missing_struct_unions(self):
+        # not very nice, but some struct declarations might be missing
+        # because they don't have any known C name.  Check that they are
+        # not partial (we can't complete or verify them!) and emit them
+        # anonymously.
+        lst = list(self._struct_unions.items())
+        lst.sort(key=lambda tp_order: tp_order[1])
+        for tp, order in lst:
+            if tp not in self._seen_struct_unions:
+                if tp.partial:
+                    raise NotImplementedError("internal inconsistency: %r is "
+                                              "partial but was not seen at "
+                                              "this point" % (tp,))
+                if tp.name.startswith('$') and tp.name[1:].isdigit():
+                    approxname = tp.name[1:]
+                elif tp.name == '_IO_FILE' and tp.forcename == 'FILE':
+                    approxname = 'FILE'
+                    self._typedef_ctx(tp, 'FILE')
+                else:
+                    raise NotImplementedError("internal inconsistency: %r" %
+                                              (tp,))
+                self._struct_ctx(tp, None, approxname)
+
+    def _generate_cpy_struct_collecttype(self, tp, name):
+        self._struct_collecttype(tp)
+    _generate_cpy_union_collecttype = _generate_cpy_struct_collecttype
+
+    def _struct_names(self, tp):
+        cname = tp.get_c_name('')
+        if ' ' in cname:
+            return cname, cname.replace(' ', '_')
+        else:
+            return cname, '_' + cname
+
+    def _generate_cpy_struct_decl(self, tp, name):
+        self._struct_decl(tp, *self._struct_names(tp))
+    _generate_cpy_union_decl = _generate_cpy_struct_decl
+
+    def _generate_cpy_struct_ctx(self, tp, name):
+        self._struct_ctx(tp, *self._struct_names(tp))
+    _generate_cpy_union_ctx = _generate_cpy_struct_ctx
+
+    # ----------
+    # 'anonymous' declarations.  These are produced for anonymous structs
+    # or unions; the 'name' is obtained by a typedef.
+
+    def _generate_cpy_anonymous_collecttype(self, tp, name):
+        if isinstance(tp, model.EnumType):
+            self._generate_cpy_enum_collecttype(tp, name)
+        else:
+            self._struct_collecttype(tp)
+
+    def _generate_cpy_anonymous_decl(self, tp, name):
+        if isinstance(tp, model.EnumType):
+            self._generate_cpy_enum_decl(tp)
+        else:
+            self._struct_decl(tp, name, 'typedef_' + name)
+
+    def _generate_cpy_anonymous_ctx(self, tp, name):
+        if isinstance(tp, model.EnumType):
+            self._enum_ctx(tp, name)
+        else:
+            self._struct_ctx(tp, name, 'typedef_' + name)
+
+    # ----------
+    # constants, declared with "static const ..."
+
+    def _generate_cpy_const(self, is_int, name, tp=None, category='const',
+                            check_value=None):
+        if (category, name) in self._seen_constants:
+            raise VerificationError(
+                "duplicate declaration of %s '%s'" % (category, name))
+        self._seen_constants.add((category, name))
+        #
+        prnt = self._prnt
+        funcname = '_cffi_%s_%s' % (category, name)
+        if is_int:
+            prnt('static int %s(unsigned long long *o)' % funcname)
+            prnt('{')
+            prnt('  int n = (%s) <= 0;' % (name,))
+            prnt('  *o = (unsigned long long)((%s) | 0);'
+                 '  /* check that %s is an integer */' % (name, name))
+            if check_value is not None:
+                if check_value > 0:
+                    check_value = '%dU' % (check_value,)
+                prnt('  if (!_cffi_check_int(*o, n, %s))' % (check_value,))
+                prnt('    n |= 2;')
+            prnt('  return n;')
+            prnt('}')
+        else:
+            assert check_value is None
+            prnt('static void %s(char *o)' % funcname)
+            prnt('{')
+            prnt('  *(%s)o = %s;' % (tp.get_c_name('*'), name))
+            prnt('}')
+        prnt()
+
+    def _generate_cpy_constant_collecttype(self, tp, name):
+        is_int = tp.is_integer_type()
+        if not is_int or self.target_is_python:
+            self._do_collect_type(tp)
+
+    def _generate_cpy_constant_decl(self, tp, name):
+        is_int = tp.is_integer_type()
+        self._generate_cpy_const(is_int, name, tp)
+
+    def _generate_cpy_constant_ctx(self, tp, name):
+        if not self.target_is_python and tp.is_integer_type():
+            type_op = CffiOp(OP_CONSTANT_INT, -1)
+        else:
+            if self.target_is_python:
+                const_kind = OP_DLOPEN_CONST
+            else:
+                const_kind = OP_CONSTANT
+            type_index = self._typesdict[tp]
+            type_op = CffiOp(const_kind, type_index)
+        self._lsts["global"].append(
+            GlobalExpr(name, '_cffi_const_%s' % name, type_op))
+
+    # ----------
+    # enums
+
+    def _generate_cpy_enum_collecttype(self, tp, name):
+        self._do_collect_type(tp)
+
+    def _generate_cpy_enum_decl(self, tp, name=None):
+        for enumerator in tp.enumerators:
+            self._generate_cpy_const(True, enumerator)
+
+    def _enum_ctx(self, tp, cname):
+        type_index = self._typesdict[tp]
+        type_op = CffiOp(OP_ENUM, -1)
+        if self.target_is_python:
+            tp.check_not_partial()
+        for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues):
+            self._lsts["global"].append(
+                GlobalExpr(enumerator, '_cffi_const_%s' % enumerator, type_op,
+                           check_value=enumvalue))
+        #
+        if cname is not None and '$' not in cname and not self.target_is_python:
+            size = "sizeof(%s)" % cname
+            signed = "((%s)-1) <= 0" % cname
+        else:
+            basetp = tp.build_baseinttype(self.ffi, [])
+            size = self.ffi.sizeof(basetp)
+            signed = int(int(self.ffi.cast(basetp, -1)) < 0)
+        allenums = ",".join(tp.enumerators)
+        self._lsts["enum"].append(
+            EnumExpr(tp.name, type_index, size, signed, allenums))
+
+    def _generate_cpy_enum_ctx(self, tp, name):
+        self._enum_ctx(tp, tp._get_c_name())
+
+    # ----------
+    # macros: for now only for integers
+
+    def _generate_cpy_macro_collecttype(self, tp, name):
+        pass
+
+    def _generate_cpy_macro_decl(self, tp, name):
+        if tp == '...':
+            check_value = None
+        else:
+            check_value = tp     # an integer
+        self._generate_cpy_const(True, name, check_value=check_value)
+
+    def _generate_cpy_macro_ctx(self, tp, name):
+        if tp == '...':
+            if self.target_is_python:
+                raise VerificationError(
+                    "cannot use the syntax '...' in '#define %s ...' when "
+                    "using the ABI mode" % (name,))
+            check_value = None
+        else:
+            check_value = tp     # an integer
+        type_op = CffiOp(OP_CONSTANT_INT, -1)
+        self._lsts["global"].append(
+            GlobalExpr(name, '_cffi_const_%s' % name, type_op,
+                       check_value=check_value))
+
+    # ----------
+    # global variables
+
+    def _global_type(self, tp, global_name):
+        if isinstance(tp, model.ArrayType):
+            actual_length = tp.length
+            if actual_length == '...':
+                actual_length = '_cffi_array_len(%s)' % (global_name,)
+            tp_item = self._global_type(tp.item, '%s[0]' % global_name)
+            tp = model.ArrayType(tp_item, actual_length)
+        return tp
+
+    def _generate_cpy_variable_collecttype(self, tp, name):
+        self._do_collect_type(self._global_type(tp, name))
+
+    def _generate_cpy_variable_decl(self, tp, name):
+        prnt = self._prnt
+        tp = self._global_type(tp, name)
+        if isinstance(tp, model.ArrayType) and tp.length is None:
+            tp = tp.item
+            ampersand = ''
+        else:
+            ampersand = '&'
+        # This code assumes that casts from "tp *" to "void *" is a
+        # no-op, i.e. a function that returns a "tp *" can be called
+        # as if it returned a "void *".  This should be generally true
+        # on any modern machine.  The only exception to that rule (on
+        # uncommon architectures, and as far as I can tell) might be
+        # if 'tp' were a function type, but that is not possible here.
+        # (If 'tp' is a function _pointer_ type, then casts from "fn_t
+        # **" to "void *" are again no-ops, as far as I can tell.)
+        decl = '*_cffi_var_%s(void)' % (name,)
+        prnt('static ' + tp.get_c_name(decl, quals=self._current_quals))
+        prnt('{')
+        prnt('  return %s(%s);' % (ampersand, name))
+        prnt('}')
+        prnt()
+
+    def _generate_cpy_variable_ctx(self, tp, name):
+        tp = self._global_type(tp, name)
+        type_index = self._typesdict[tp]
+        if self.target_is_python:
+            op = OP_GLOBAL_VAR
+        else:
+            op = OP_GLOBAL_VAR_F
+        self._lsts["global"].append(
+            GlobalExpr(name, '_cffi_var_%s' % name, CffiOp(op, type_index)))
+
+    # ----------
+    # extern "Python"
+
+    def _generate_cpy_extern_python_collecttype(self, tp, name):
+        assert isinstance(tp, model.FunctionPtrType)
+        self._do_collect_type(tp)
+    _generate_cpy_dllexport_python_collecttype = \
+      _generate_cpy_extern_python_plus_c_collecttype = \
+      _generate_cpy_extern_python_collecttype
+
+    def _extern_python_decl(self, tp, name, tag_and_space):
+        prnt = self._prnt
+        if isinstance(tp.result, model.VoidType):
+            size_of_result = '0'
+        else:
+            context = 'result of %s' % name
+            size_of_result = '(int)sizeof(%s)' % (
+                tp.result.get_c_name('', context),)
+        prnt('static struct _cffi_externpy_s _cffi_externpy__%s =' % name)
+        prnt('  { "%s.%s", %s, 0, 0 };' % (
+            self.module_name, name, size_of_result))
+        prnt()
+        #
+        arguments = []
+        context = 'argument of %s' % name
+        for i, type in enumerate(tp.args):
+            arg = type.get_c_name(' a%d' % i, context)
+            arguments.append(arg)
+        #
+        repr_arguments = ', '.join(arguments)
+        repr_arguments = repr_arguments or 'void'
+        name_and_arguments = '%s(%s)' % (name, repr_arguments)
+        if tp.abi == "__stdcall":
+            name_and_arguments = '_cffi_stdcall ' + name_and_arguments
+        #
+        def may_need_128_bits(tp):
+            return (isinstance(tp, model.PrimitiveType) and
+                    tp.name == 'long double')
+        #
+        size_of_a = max(len(tp.args)*8, 8)
+        if may_need_128_bits(tp.result):
+            size_of_a = max(size_of_a, 16)
+        if isinstance(tp.result, model.StructOrUnion):
+            size_of_a = 'sizeof(%s) > %d ? sizeof(%s) : %d' % (
+                tp.result.get_c_name(''), size_of_a,
+                tp.result.get_c_name(''), size_of_a)
+        prnt('%s%s' % (tag_and_space, tp.result.get_c_name(name_and_arguments)))
+        prnt('{')
+        prnt('  char a[%s];' % size_of_a)
+        prnt('  char *p = a;')
+        for i, type in enumerate(tp.args):
+            arg = 'a%d' % i
+            if (isinstance(type, model.StructOrUnion) or
+                    may_need_128_bits(type)):
+                arg = '&' + arg
+                type = model.PointerType(type)
+            prnt('  *(%s)(p + %d) = %s;' % (type.get_c_name('*'), i*8, arg))
+        prnt('  _cffi_call_python(&_cffi_externpy__%s, p);' % name)
+        if not isinstance(tp.result, model.VoidType):
+            prnt('  return *(%s)p;' % (tp.result.get_c_name('*'),))
+        prnt('}')
+        prnt()
+        self._num_externpy += 1
+
+    def _generate_cpy_extern_python_decl(self, tp, name):
+        self._extern_python_decl(tp, name, 'static ')
+
+    def _generate_cpy_dllexport_python_decl(self, tp, name):
+        self._extern_python_decl(tp, name, 'CFFI_DLLEXPORT ')
+
+    def _generate_cpy_extern_python_plus_c_decl(self, tp, name):
+        self._extern_python_decl(tp, name, '')
+
+    def _generate_cpy_extern_python_ctx(self, tp, name):
+        if self.target_is_python:
+            raise VerificationError(
+                "cannot use 'extern \"Python\"' in the ABI mode")
+        if tp.ellipsis:
+            raise NotImplementedError("a vararg function is extern \"Python\"")
+        type_index = self._typesdict[tp]
+        type_op = CffiOp(OP_EXTERN_PYTHON, type_index)
+        self._lsts["global"].append(
+            GlobalExpr(name, '&_cffi_externpy__%s' % name, type_op, name))
+
+    _generate_cpy_dllexport_python_ctx = \
+      _generate_cpy_extern_python_plus_c_ctx = \
+      _generate_cpy_extern_python_ctx
+
+    def _print_string_literal_in_array(self, s):
+        prnt = self._prnt
+        prnt('// # NB. this is not a string because of a size limit in MSVC')
+        if not isinstance(s, bytes):    # unicode
+            s = s.encode('utf-8')       # -> bytes
+        else:
+            s.decode('utf-8')           # got bytes, check for valid utf-8
+        try:
+            s.decode('ascii')
+        except UnicodeDecodeError:
+            s = b'# -*- encoding: utf8 -*-\n' + s
+        for line in s.splitlines(True):
+            comment = line
+            if type('//') is bytes:     # python2
+                line = map(ord, line)   #     make a list of integers
+            else:                       # python3
+                # type(line) is bytes, which enumerates like a list of integers
+                comment = ascii(comment)[1:-1]
+            prnt(('// ' + comment).rstrip())
+            printed_line = ''
+            for c in line:
+                if len(printed_line) >= 76:
+                    prnt(printed_line)
+                    printed_line = ''
+                printed_line += '%d,' % (c,)
+            prnt(printed_line)
+
+    # ----------
+    # emitting the opcodes for individual types
+
+    def _emit_bytecode_VoidType(self, tp, index):
+        self.cffi_types[index] = CffiOp(OP_PRIMITIVE, PRIM_VOID)
+
+    def _emit_bytecode_PrimitiveType(self, tp, index):
+        prim_index = PRIMITIVE_TO_INDEX[tp.name]
+        self.cffi_types[index] = CffiOp(OP_PRIMITIVE, prim_index)
+
+    def _emit_bytecode_UnknownIntegerType(self, tp, index):
+        s = ('_cffi_prim_int(sizeof(%s), (\n'
+             '           ((%s)-1) | 0 /* check that %s is an integer type */\n'
+             '         ) <= 0)' % (tp.name, tp.name, tp.name))
+        self.cffi_types[index] = CffiOp(OP_PRIMITIVE, s)
+
+    def _emit_bytecode_UnknownFloatType(self, tp, index):
+        s = ('_cffi_prim_float(sizeof(%s) *\n'
+             '           (((%s)1) / 2) * 2 /* integer => 0, float => 1 */\n'
+             '         )' % (tp.name, tp.name))
+        self.cffi_types[index] = CffiOp(OP_PRIMITIVE, s)
+
+    def _emit_bytecode_RawFunctionType(self, tp, index):
+        self.cffi_types[index] = CffiOp(OP_FUNCTION, self._typesdict[tp.result])
+        index += 1
+        for tp1 in tp.args:
+            realindex = self._typesdict[tp1]
+            if index != realindex:
+                if isinstance(tp1, model.PrimitiveType):
+                    self._emit_bytecode_PrimitiveType(tp1, index)
+                else:
+                    self.cffi_types[index] = CffiOp(OP_NOOP, realindex)
+            index += 1
+        flags = int(tp.ellipsis)
+        if tp.abi is not None:
+            if tp.abi == '__stdcall':
+                flags |= 2
+            else:
+                raise NotImplementedError("abi=%r" % (tp.abi,))
+        self.cffi_types[index] = CffiOp(OP_FUNCTION_END, flags)
+
+    def _emit_bytecode_PointerType(self, tp, index):
+        self.cffi_types[index] = CffiOp(OP_POINTER, self._typesdict[tp.totype])
+
+    _emit_bytecode_ConstPointerType = _emit_bytecode_PointerType
+    _emit_bytecode_NamedPointerType = _emit_bytecode_PointerType
+
+    def _emit_bytecode_FunctionPtrType(self, tp, index):
+        raw = tp.as_raw_function()
+        self.cffi_types[index] = CffiOp(OP_POINTER, self._typesdict[raw])
+
+    def _emit_bytecode_ArrayType(self, tp, index):
+        item_index = self._typesdict[tp.item]
+        if tp.length is None:
+            self.cffi_types[index] = CffiOp(OP_OPEN_ARRAY, item_index)
+        elif tp.length == '...':
+            raise VerificationError(
+                "type %s badly placed: the '...' array length can only be "
+                "used on global arrays or on fields of structures" % (
+                    str(tp).replace('/*...*/', '...'),))
+        else:
+            assert self.cffi_types[index + 1] == 'LEN'
+            self.cffi_types[index] = CffiOp(OP_ARRAY, item_index)
+            self.cffi_types[index + 1] = CffiOp(None, str(tp.length))
+
+    def _emit_bytecode_StructType(self, tp, index):
+        struct_index = self._struct_unions[tp]
+        self.cffi_types[index] = CffiOp(OP_STRUCT_UNION, struct_index)
+    _emit_bytecode_UnionType = _emit_bytecode_StructType
+
+    def _emit_bytecode_EnumType(self, tp, index):
+        enum_index = self._enums[tp]
+        self.cffi_types[index] = CffiOp(OP_ENUM, enum_index)
+
+
+if sys.version_info >= (3,):
+    NativeIO = io.StringIO
+else:
+    class NativeIO(io.BytesIO):
+        def write(self, s):
+            if isinstance(s, unicode):
+                s = s.encode('ascii')
+            super(NativeIO, self).write(s)
+
+def _make_c_or_py_source(ffi, module_name, preamble, target_file, verbose):
+    if verbose:
+        print("generating %s" % (target_file,))
+    recompiler = Recompiler(ffi, module_name,
+                            target_is_python=(preamble is None))
+    recompiler.collect_type_table()
+    recompiler.collect_step_tables()
+    f = NativeIO()
+    recompiler.write_source_to_f(f, preamble)
+    output = f.getvalue()
+    try:
+        with open(target_file, 'r') as f1:
+            if f1.read(len(output) + 1) != output:
+                raise IOError
+        if verbose:
+            print("(already up-to-date)")
+        return False     # already up-to-date
+    except IOError:
+        tmp_file = '%s.~%d' % (target_file, os.getpid())
+        with open(tmp_file, 'w') as f1:
+            f1.write(output)
+        try:
+            os.rename(tmp_file, target_file)
+        except OSError:
+            os.unlink(target_file)
+            os.rename(tmp_file, target_file)
+        return True
+
+def make_c_source(ffi, module_name, preamble, target_c_file, verbose=False):
+    assert preamble is not None
+    return _make_c_or_py_source(ffi, module_name, preamble, target_c_file,
+                                verbose)
+
+def make_py_source(ffi, module_name, target_py_file, verbose=False):
+    return _make_c_or_py_source(ffi, module_name, None, target_py_file,
+                                verbose)
+
+def _modname_to_file(outputdir, modname, extension):
+    parts = modname.split('.')
+    try:
+        os.makedirs(os.path.join(outputdir, *parts[:-1]))
+    except OSError:
+        pass
+    parts[-1] += extension
+    return os.path.join(outputdir, *parts), parts
+
+
+# Aaargh.  Distutils is not tested at all for the purpose of compiling
+# DLLs that are not extension modules.  Here are some hacks to work
+# around that, in the _patch_for_*() functions...
+
+def _patch_meth(patchlist, cls, name, new_meth):
+    old = getattr(cls, name)
+    patchlist.append((cls, name, old))
+    setattr(cls, name, new_meth)
+    return old
+
+def _unpatch_meths(patchlist):
+    for cls, name, old_meth in reversed(patchlist):
+        setattr(cls, name, old_meth)
+
+def _patch_for_embedding(patchlist):
+    if sys.platform == 'win32':
+        # we must not remove the manifest when building for embedding!
+        from distutils.msvc9compiler import MSVCCompiler
+        _patch_meth(patchlist, MSVCCompiler, '_remove_visual_c_ref',
+                    lambda self, manifest_file: manifest_file)
+
+    if sys.platform == 'darwin':
+        # we must not make a '-bundle', but a '-dynamiclib' instead
+        from distutils.ccompiler import CCompiler
+        def my_link_shared_object(self, *args, **kwds):
+            if '-bundle' in self.linker_so:
+                self.linker_so = list(self.linker_so)
+                i = self.linker_so.index('-bundle')
+                self.linker_so[i] = '-dynamiclib'
+            return old_link_shared_object(self, *args, **kwds)
+        old_link_shared_object = _patch_meth(patchlist, CCompiler,
+                                             'link_shared_object',
+                                             my_link_shared_object)
+
+def _patch_for_target(patchlist, target):
+    from distutils.command.build_ext import build_ext
+    # if 'target' is different from '*', we need to patch some internal
+    # method to just return this 'target' value, instead of having it
+    # built from module_name
+    if target.endswith('.*'):
+        target = target[:-2]
+        if sys.platform == 'win32':
+            target += '.dll'
+        elif sys.platform == 'darwin':
+            target += '.dylib'
+        else:
+            target += '.so'
+    _patch_meth(patchlist, build_ext, 'get_ext_filename',
+                lambda self, ext_name: target)
+
+
+def recompile(ffi, module_name, preamble, tmpdir='.', call_c_compiler=True,
+              c_file=None, source_extension='.c', extradir=None,
+              compiler_verbose=1, target=None, debug=None, **kwds):
+    if not isinstance(module_name, str):
+        module_name = module_name.encode('ascii')
+    if ffi._windows_unicode:
+        ffi._apply_windows_unicode(kwds)
+    if preamble is not None:
+        embedding = (ffi._embedding is not None)
+        if embedding:
+            ffi._apply_embedding_fix(kwds)
+        if c_file is None:
+            c_file, parts = _modname_to_file(tmpdir, module_name,
+                                             source_extension)
+            if extradir:
+                parts = [extradir] + parts
+            ext_c_file = os.path.join(*parts)
+        else:
+            ext_c_file = c_file
+        #
+        if target is None:
+            if embedding:
+                target = '%s.*' % module_name
+            else:
+                target = '*'
+        #
+        ext = ffiplatform.get_extension(ext_c_file, module_name, **kwds)
+        updated = make_c_source(ffi, module_name, preamble, c_file,
+                                verbose=compiler_verbose)
+        if call_c_compiler:
+            patchlist = []
+            cwd = os.getcwd()
+            try:
+                if embedding:
+                    _patch_for_embedding(patchlist)
+                if target != '*':
+                    _patch_for_target(patchlist, target)
+                if compiler_verbose:
+                    if tmpdir == '.':
+                        msg = 'the current directory is'
+                    else:
+                        msg = 'setting the current directory to'
+                    print('%s %r' % (msg, os.path.abspath(tmpdir)))
+                os.chdir(tmpdir)
+                outputfilename = ffiplatform.compile('.', ext,
+                                                     compiler_verbose, debug)
+            finally:
+                os.chdir(cwd)
+                _unpatch_meths(patchlist)
+            return outputfilename
+        else:
+            return ext, updated
+    else:
+        if c_file is None:
+            c_file, _ = _modname_to_file(tmpdir, module_name, '.py')
+        updated = make_py_source(ffi, module_name, c_file,
+                                 verbose=compiler_verbose)
+        if call_c_compiler:
+            return c_file
+        else:
+            return None, updated
+
diff --git a/myenv/lib/python3.9/site-packages/cffi/setuptools_ext.py b/myenv/lib/python3.9/site-packages/cffi/setuptools_ext.py
new file mode 100644
index 0000000..8fe3614
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/setuptools_ext.py
@@ -0,0 +1,219 @@
+import os
+import sys
+
+try:
+    basestring
+except NameError:
+    # Python 3.x
+    basestring = str
+
+def error(msg):
+    from distutils.errors import DistutilsSetupError
+    raise DistutilsSetupError(msg)
+
+
+def execfile(filename, glob):
+    # We use execfile() (here rewritten for Python 3) instead of
+    # __import__() to load the build script.  The problem with
+    # a normal import is that in some packages, the intermediate
+    # __init__.py files may already try to import the file that
+    # we are generating.
+    with open(filename) as f:
+        src = f.read()
+    src += '\n'      # Python 2.6 compatibility
+    code = compile(src, filename, 'exec')
+    exec(code, glob, glob)
+
+
+def add_cffi_module(dist, mod_spec):
+    from cffi.api import FFI
+
+    if not isinstance(mod_spec, basestring):
+        error("argument to 'cffi_modules=...' must be a str or a list of str,"
+              " not %r" % (type(mod_spec).__name__,))
+    mod_spec = str(mod_spec)
+    try:
+        build_file_name, ffi_var_name = mod_spec.split(':')
+    except ValueError:
+        error("%r must be of the form 'path/build.py:ffi_variable'" %
+              (mod_spec,))
+    if not os.path.exists(build_file_name):
+        ext = ''
+        rewritten = build_file_name.replace('.', '/') + '.py'
+        if os.path.exists(rewritten):
+            ext = ' (rewrite cffi_modules to [%r])' % (
+                rewritten + ':' + ffi_var_name,)
+        error("%r does not name an existing file%s" % (build_file_name, ext))
+
+    mod_vars = {'__name__': '__cffi__', '__file__': build_file_name}
+    execfile(build_file_name, mod_vars)
+
+    try:
+        ffi = mod_vars[ffi_var_name]
+    except KeyError:
+        error("%r: object %r not found in module" % (mod_spec,
+                                                     ffi_var_name))
+    if not isinstance(ffi, FFI):
+        ffi = ffi()      # maybe it's a function instead of directly an ffi
+    if not isinstance(ffi, FFI):
+        error("%r is not an FFI instance (got %r)" % (mod_spec,
+                                                      type(ffi).__name__))
+    if not hasattr(ffi, '_assigned_source'):
+        error("%r: the set_source() method was not called" % (mod_spec,))
+    module_name, source, source_extension, kwds = ffi._assigned_source
+    if ffi._windows_unicode:
+        kwds = kwds.copy()
+        ffi._apply_windows_unicode(kwds)
+
+    if source is None:
+        _add_py_module(dist, ffi, module_name)
+    else:
+        _add_c_module(dist, ffi, module_name, source, source_extension, kwds)
+
+def _set_py_limited_api(Extension, kwds):
+    """
+    Add py_limited_api to kwds if setuptools >= 26 is in use.
+    Do not alter the setting if it already exists.
+    Setuptools takes care of ignoring the flag on Python 2 and PyPy.
+
+    CPython itself should ignore the flag in a debugging version
+    (by not listing .abi3.so in the extensions it supports), but
+    it doesn't so far, creating troubles.  That's why we check
+    for "not hasattr(sys, 'gettotalrefcount')" (the 2.7 compatible equivalent
+    of 'd' not in sys.abiflags). (http://bugs.python.org/issue28401)
+
+    On Windows, with CPython <= 3.4, it's better not to use py_limited_api
+    because virtualenv *still* doesn't copy PYTHON3.DLL on these versions.
+    Recently (2020) we started shipping only >= 3.5 wheels, though.  So
+    we'll give it another try and set py_limited_api on Windows >= 3.5.
+    """
+    from cffi import recompiler
+
+    if ('py_limited_api' not in kwds and not hasattr(sys, 'gettotalrefcount')
+            and recompiler.USE_LIMITED_API):
+        import setuptools
+        try:
+            setuptools_major_version = int(setuptools.__version__.partition('.')[0])
+            if setuptools_major_version >= 26:
+                kwds['py_limited_api'] = True
+        except ValueError:  # certain development versions of setuptools
+            # If we don't know the version number of setuptools, we
+            # try to set 'py_limited_api' anyway.  At worst, we get a
+            # warning.
+            kwds['py_limited_api'] = True
+    return kwds
+
+def _add_c_module(dist, ffi, module_name, source, source_extension, kwds):
+    from distutils.core import Extension
+    # We are a setuptools extension. Need this build_ext for py_limited_api.
+    from setuptools.command.build_ext import build_ext
+    from distutils.dir_util import mkpath
+    from distutils import log
+    from cffi import recompiler
+
+    allsources = ['$PLACEHOLDER']
+    allsources.extend(kwds.pop('sources', []))
+    kwds = _set_py_limited_api(Extension, kwds)
+    ext = Extension(name=module_name, sources=allsources, **kwds)
+
+    def make_mod(tmpdir, pre_run=None):
+        c_file = os.path.join(tmpdir, module_name + source_extension)
+        log.info("generating cffi module %r" % c_file)
+        mkpath(tmpdir)
+        # a setuptools-only, API-only hook: called with the "ext" and "ffi"
+        # arguments just before we turn the ffi into C code.  To use it,
+        # subclass the 'distutils.command.build_ext.build_ext' class and
+        # add a method 'def pre_run(self, ext, ffi)'.
+        if pre_run is not None:
+            pre_run(ext, ffi)
+        updated = recompiler.make_c_source(ffi, module_name, source, c_file)
+        if not updated:
+            log.info("already up-to-date")
+        return c_file
+
+    if dist.ext_modules is None:
+        dist.ext_modules = []
+    dist.ext_modules.append(ext)
+
+    base_class = dist.cmdclass.get('build_ext', build_ext)
+    class build_ext_make_mod(base_class):
+        def run(self):
+            if ext.sources[0] == '$PLACEHOLDER':
+                pre_run = getattr(self, 'pre_run', None)
+                ext.sources[0] = make_mod(self.build_temp, pre_run)
+            base_class.run(self)
+    dist.cmdclass['build_ext'] = build_ext_make_mod
+    # NB. multiple runs here will create multiple 'build_ext_make_mod'
+    # classes.  Even in this case the 'build_ext' command should be
+    # run once; but just in case, the logic above does nothing if
+    # called again.
+
+
+def _add_py_module(dist, ffi, module_name):
+    from distutils.dir_util import mkpath
+    from setuptools.command.build_py import build_py
+    from setuptools.command.build_ext import build_ext
+    from distutils import log
+    from cffi import recompiler
+
+    def generate_mod(py_file):
+        log.info("generating cffi module %r" % py_file)
+        mkpath(os.path.dirname(py_file))
+        updated = recompiler.make_py_source(ffi, module_name, py_file)
+        if not updated:
+            log.info("already up-to-date")
+
+    base_class = dist.cmdclass.get('build_py', build_py)
+    class build_py_make_mod(base_class):
+        def run(self):
+            base_class.run(self)
+            module_path = module_name.split('.')
+            module_path[-1] += '.py'
+            generate_mod(os.path.join(self.build_lib, *module_path))
+        def get_source_files(self):
+            # This is called from 'setup.py sdist' only.  Exclude
+            # the generate .py module in this case.
+            saved_py_modules = self.py_modules
+            try:
+                if saved_py_modules:
+                    self.py_modules = [m for m in saved_py_modules
+                                         if m != module_name]
+                return base_class.get_source_files(self)
+            finally:
+                self.py_modules = saved_py_modules
+    dist.cmdclass['build_py'] = build_py_make_mod
+
+    # distutils and setuptools have no notion I could find of a
+    # generated python module.  If we don't add module_name to
+    # dist.py_modules, then things mostly work but there are some
+    # combination of options (--root and --record) that will miss
+    # the module.  So we add it here, which gives a few apparently
+    # harmless warnings about not finding the file outside the
+    # build directory.
+    # Then we need to hack more in get_source_files(); see above.
+    if dist.py_modules is None:
+        dist.py_modules = []
+    dist.py_modules.append(module_name)
+
+    # the following is only for "build_ext -i"
+    base_class_2 = dist.cmdclass.get('build_ext', build_ext)
+    class build_ext_make_mod(base_class_2):
+        def run(self):
+            base_class_2.run(self)
+            if self.inplace:
+                # from get_ext_fullpath() in distutils/command/build_ext.py
+                module_path = module_name.split('.')
+                package = '.'.join(module_path[:-1])
+                build_py = self.get_finalized_command('build_py')
+                package_dir = build_py.get_package_dir(package)
+                file_name = module_path[-1] + '.py'
+                generate_mod(os.path.join(package_dir, file_name))
+    dist.cmdclass['build_ext'] = build_ext_make_mod
+
+def cffi_modules(dist, attr, value):
+    assert attr == 'cffi_modules'
+    if isinstance(value, basestring):
+        value = [value]
+
+    for cffi_module in value:
+        add_cffi_module(dist, cffi_module)
diff --git a/myenv/lib/python3.9/site-packages/cffi/vengine_cpy.py b/myenv/lib/python3.9/site-packages/cffi/vengine_cpy.py
new file mode 100644
index 0000000..6de0df0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/vengine_cpy.py
@@ -0,0 +1,1076 @@
+#
+# DEPRECATED: implementation for ffi.verify()
+#
+import sys, imp
+from . import model
+from .error import VerificationError
+
+
+class VCPythonEngine(object):
+    _class_key = 'x'
+    _gen_python_module = True
+
+    def __init__(self, verifier):
+        self.verifier = verifier
+        self.ffi = verifier.ffi
+        self._struct_pending_verification = {}
+        self._types_of_builtin_functions = {}
+
+    def patch_extension_kwds(self, kwds):
+        pass
+
+    def find_module(self, module_name, path, so_suffixes):
+        try:
+            f, filename, descr = imp.find_module(module_name, path)
+        except ImportError:
+            return None
+        if f is not None:
+            f.close()
+        # Note that after a setuptools installation, there are both .py
+        # and .so files with the same basename.  The code here relies on
+        # imp.find_module() locating the .so in priority.
+        if descr[0] not in so_suffixes:
+            return None
+        return filename
+
+    def collect_types(self):
+        self._typesdict = {}
+        self._generate("collecttype")
+
+    def _prnt(self, what=''):
+        self._f.write(what + '\n')
+
+    def _gettypenum(self, type):
+        # a KeyError here is a bug.  please report it! :-)
+        return self._typesdict[type]
+
+    def _do_collect_type(self, tp):
+        if ((not isinstance(tp, model.PrimitiveType)
+             or tp.name == 'long double')
+                and tp not in self._typesdict):
+            num = len(self._typesdict)
+            self._typesdict[tp] = num
+
+    def write_source_to_f(self):
+        self.collect_types()
+        #
+        # The new module will have a _cffi_setup() function that receives
+        # objects from the ffi world, and that calls some setup code in
+        # the module.  This setup code is split in several independent
+        # functions, e.g. one per constant.  The functions are "chained"
+        # by ending in a tail call to each other.
+        #
+        # This is further split in two chained lists, depending on if we
+        # can do it at import-time or if we must wait for _cffi_setup() to
+        # provide us with the <ctype> objects.  This is needed because we
+        # need the values of the enum constants in order to build the
+        # <ctype 'enum'> that we may have to pass to _cffi_setup().
+        #
+        # The following two 'chained_list_constants' items contains
+        # the head of these two chained lists, as a string that gives the
+        # call to do, if any.
+        self._chained_list_constants = ['((void)lib,0)', '((void)lib,0)']
+        #
+        prnt = self._prnt
+        # first paste some standard set of lines that are mostly '#define'
+        prnt(cffimod_header)
+        prnt()
+        # then paste the C source given by the user, verbatim.
+        prnt(self.verifier.preamble)
+        prnt()
+        #
+        # call generate_cpy_xxx_decl(), for every xxx found from
+        # ffi._parser._declarations.  This generates all the functions.
+        self._generate("decl")
+        #
+        # implement the function _cffi_setup_custom() as calling the
+        # head of the chained list.
+        self._generate_setup_custom()
+        prnt()
+        #
+        # produce the method table, including the entries for the
+        # generated Python->C function wrappers, which are done
+        # by generate_cpy_function_method().
+        prnt('static PyMethodDef _cffi_methods[] = {')
+        self._generate("method")
+        prnt('  {"_cffi_setup", _cffi_setup, METH_VARARGS, NULL},')
+        prnt('  {NULL, NULL, 0, NULL}    /* Sentinel */')
+        prnt('};')
+        prnt()
+        #
+        # standard init.
+        modname = self.verifier.get_module_name()
+        constants = self._chained_list_constants[False]
+        prnt('#if PY_MAJOR_VERSION >= 3')
+        prnt()
+        prnt('static struct PyModuleDef _cffi_module_def = {')
+        prnt('  PyModuleDef_HEAD_INIT,')
+        prnt('  "%s",' % modname)
+        prnt('  NULL,')
+        prnt('  -1,')
+        prnt('  _cffi_methods,')
+        prnt('  NULL, NULL, NULL, NULL')
+        prnt('};')
+        prnt()
+        prnt('PyMODINIT_FUNC')
+        prnt('PyInit_%s(void)' % modname)
+        prnt('{')
+        prnt('  PyObject *lib;')
+        prnt('  lib = PyModule_Create(&_cffi_module_def);')
+        prnt('  if (lib == NULL)')
+        prnt('    return NULL;')
+        prnt('  if (%s < 0 || _cffi_init() < 0) {' % (constants,))
+        prnt('    Py_DECREF(lib);')
+        prnt('    return NULL;')
+        prnt('  }')
+        prnt('  return lib;')
+        prnt('}')
+        prnt()
+        prnt('#else')
+        prnt()
+        prnt('PyMODINIT_FUNC')
+        prnt('init%s(void)' % modname)
+        prnt('{')
+        prnt('  PyObject *lib;')
+        prnt('  lib = Py_InitModule("%s", _cffi_methods);' % modname)
+        prnt('  if (lib == NULL)')
+        prnt('    return;')
+        prnt('  if (%s < 0 || _cffi_init() < 0)' % (constants,))
+        prnt('    return;')
+        prnt('  return;')
+        prnt('}')
+        prnt()
+        prnt('#endif')
+
+    def load_library(self, flags=None):
+        # XXX review all usages of 'self' here!
+        # import it as a new extension module
+        imp.acquire_lock()
+        try:
+            if hasattr(sys, "getdlopenflags"):
+                previous_flags = sys.getdlopenflags()
+            try:
+                if hasattr(sys, "setdlopenflags") and flags is not None:
+                    sys.setdlopenflags(flags)
+                module = imp.load_dynamic(self.verifier.get_module_name(),
+                                          self.verifier.modulefilename)
+            except ImportError as e:
+                error = "importing %r: %s" % (self.verifier.modulefilename, e)
+                raise VerificationError(error)
+            finally:
+                if hasattr(sys, "setdlopenflags"):
+                    sys.setdlopenflags(previous_flags)
+        finally:
+            imp.release_lock()
+        #
+        # call loading_cpy_struct() to get the struct layout inferred by
+        # the C compiler
+        self._load(module, 'loading')
+        #
+        # the C code will need the <ctype> objects.  Collect them in
+        # order in a list.
+        revmapping = dict([(value, key)
+                           for (key, value) in self._typesdict.items()])
+        lst = [revmapping[i] for i in range(len(revmapping))]
+        lst = list(map(self.ffi._get_cached_btype, lst))
+        #
+        # build the FFILibrary class and instance and call _cffi_setup().
+        # this will set up some fields like '_cffi_types', and only then
+        # it will invoke the chained list of functions that will really
+        # build (notably) the constant objects, as <cdata> if they are
+        # pointers, and store them as attributes on the 'library' object.
+        class FFILibrary(object):
+            _cffi_python_module = module
+            _cffi_ffi = self.ffi
+            _cffi_dir = []
+            def __dir__(self):
+                return FFILibrary._cffi_dir + list(self.__dict__)
+        library = FFILibrary()
+        if module._cffi_setup(lst, VerificationError, library):
+            import warnings
+            warnings.warn("reimporting %r might overwrite older definitions"
+                          % (self.verifier.get_module_name()))
+        #
+        # finally, call the loaded_cpy_xxx() functions.  This will perform
+        # the final adjustments, like copying the Python->C wrapper
+        # functions from the module to the 'library' object, and setting
+        # up the FFILibrary class with properties for the global C variables.
+        self._load(module, 'loaded', library=library)
+        module._cffi_original_ffi = self.ffi
+        module._cffi_types_of_builtin_funcs = self._types_of_builtin_functions
+        return library
+
+    def _get_declarations(self):
+        lst = [(key, tp) for (key, (tp, qual)) in
+                                self.ffi._parser._declarations.items()]
+        lst.sort()
+        return lst
+
+    def _generate(self, step_name):
+        for name, tp in self._get_declarations():
+            kind, realname = name.split(' ', 1)
+            try:
+                method = getattr(self, '_generate_cpy_%s_%s' % (kind,
+                                                                step_name))
+            except AttributeError:
+                raise VerificationError(
+                    "not implemented in verify(): %r" % name)
+            try:
+                method(tp, realname)
+            except Exception as e:
+                model.attach_exception_info(e, name)
+                raise
+
+    def _load(self, module, step_name, **kwds):
+        for name, tp in self._get_declarations():
+            kind, realname = name.split(' ', 1)
+            method = getattr(self, '_%s_cpy_%s' % (step_name, kind))
+            try:
+                method(tp, realname, module, **kwds)
+            except Exception as e:
+                model.attach_exception_info(e, name)
+                raise
+
+    def _generate_nothing(self, tp, name):
+        pass
+
+    def _loaded_noop(self, tp, name, module, **kwds):
+        pass
+
+    # ----------
+
+    def _convert_funcarg_to_c(self, tp, fromvar, tovar, errcode):
+        extraarg = ''
+        if isinstance(tp, model.PrimitiveType):
+            if tp.is_integer_type() and tp.name != '_Bool':
+                converter = '_cffi_to_c_int'
+                extraarg = ', %s' % tp.name
+            else:
+                converter = '(%s)_cffi_to_c_%s' % (tp.get_c_name(''),
+                                                   tp.name.replace(' ', '_'))
+            errvalue = '-1'
+        #
+        elif isinstance(tp, model.PointerType):
+            self._convert_funcarg_to_c_ptr_or_array(tp, fromvar,
+                                                    tovar, errcode)
+            return
+        #
+        elif isinstance(tp, (model.StructOrUnion, model.EnumType)):
+            # a struct (not a struct pointer) as a function argument
+            self._prnt('  if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)'
+                      % (tovar, self._gettypenum(tp), fromvar))
+            self._prnt('    %s;' % errcode)
+            return
+        #
+        elif isinstance(tp, model.FunctionPtrType):
+            converter = '(%s)_cffi_to_c_pointer' % tp.get_c_name('')
+            extraarg = ', _cffi_type(%d)' % self._gettypenum(tp)
+            errvalue = 'NULL'
+        #
+        else:
+            raise NotImplementedError(tp)
+        #
+        self._prnt('  %s = %s(%s%s);' % (tovar, converter, fromvar, extraarg))
+        self._prnt('  if (%s == (%s)%s && PyErr_Occurred())' % (
+            tovar, tp.get_c_name(''), errvalue))
+        self._prnt('    %s;' % errcode)
+
+    def _extra_local_variables(self, tp, localvars, freelines):
+        if isinstance(tp, model.PointerType):
+            localvars.add('Py_ssize_t datasize')
+            localvars.add('struct _cffi_freeme_s *large_args_free = NULL')
+            freelines.add('if (large_args_free != NULL)'
+                          ' _cffi_free_array_arguments(large_args_free);')
+
+    def _convert_funcarg_to_c_ptr_or_array(self, tp, fromvar, tovar, errcode):
+        self._prnt('  datasize = _cffi_prepare_pointer_call_argument(')
+        self._prnt('      _cffi_type(%d), %s, (char **)&%s);' % (
+            self._gettypenum(tp), fromvar, tovar))
+        self._prnt('  if (datasize != 0) {')
+        self._prnt('    %s = ((size_t)datasize) <= 640 ? '
+                   'alloca((size_t)datasize) : NULL;' % (tovar,))
+        self._prnt('    if (_cffi_convert_array_argument(_cffi_type(%d), %s, '
+                   '(char **)&%s,' % (self._gettypenum(tp), fromvar, tovar))
+        self._prnt('            datasize, &large_args_free) < 0)')
+        self._prnt('      %s;' % errcode)
+        self._prnt('  }')
+
+    def _convert_expr_from_c(self, tp, var, context):
+        if isinstance(tp, model.PrimitiveType):
+            if tp.is_integer_type() and tp.name != '_Bool':
+                return '_cffi_from_c_int(%s, %s)' % (var, tp.name)
+            elif tp.name != 'long double':
+                return '_cffi_from_c_%s(%s)' % (tp.name.replace(' ', '_'), var)
+            else:
+                return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % (
+                    var, self._gettypenum(tp))
+        elif isinstance(tp, (model.PointerType, model.FunctionPtrType)):
+            return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % (
+                var, self._gettypenum(tp))
+        elif isinstance(tp, model.ArrayType):
+            return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % (
+                var, self._gettypenum(model.PointerType(tp.item)))
+        elif isinstance(tp, model.StructOrUnion):
+            if tp.fldnames is None:
+                raise TypeError("'%s' is used as %s, but is opaque" % (
+                    tp._get_c_name(), context))
+            return '_cffi_from_c_struct((char *)&%s, _cffi_type(%d))' % (
+                var, self._gettypenum(tp))
+        elif isinstance(tp, model.EnumType):
+            return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % (
+                var, self._gettypenum(tp))
+        else:
+            raise NotImplementedError(tp)
+
+    # ----------
+    # typedefs: generates no code so far
+
+    _generate_cpy_typedef_collecttype = _generate_nothing
+    _generate_cpy_typedef_decl   = _generate_nothing
+    _generate_cpy_typedef_method = _generate_nothing
+    _loading_cpy_typedef         = _loaded_noop
+    _loaded_cpy_typedef          = _loaded_noop
+
+    # ----------
+    # function declarations
+
+    def _generate_cpy_function_collecttype(self, tp, name):
+        assert isinstance(tp, model.FunctionPtrType)
+        if tp.ellipsis:
+            self._do_collect_type(tp)
+        else:
+            # don't call _do_collect_type(tp) in this common case,
+            # otherwise test_autofilled_struct_as_argument fails
+            for type in tp.args:
+                self._do_collect_type(type)
+            self._do_collect_type(tp.result)
+
+    def _generate_cpy_function_decl(self, tp, name):
+        assert isinstance(tp, model.FunctionPtrType)
+        if tp.ellipsis:
+            # cannot support vararg functions better than this: check for its
+            # exact type (including the fixed arguments), and build it as a
+            # constant function pointer (no CPython wrapper)
+            self._generate_cpy_const(False, name, tp)
+            return
+        prnt = self._prnt
+        numargs = len(tp.args)
+        if numargs == 0:
+            argname = 'noarg'
+        elif numargs == 1:
+            argname = 'arg0'
+        else:
+            argname = 'args'
+        prnt('static PyObject *')
+        prnt('_cffi_f_%s(PyObject *self, PyObject *%s)' % (name, argname))
+        prnt('{')
+        #
+        context = 'argument of %s' % name
+        for i, type in enumerate(tp.args):
+            prnt('  %s;' % type.get_c_name(' x%d' % i, context))
+        #
+        localvars = set()
+        freelines = set()
+        for type in tp.args:
+            self._extra_local_variables(type, localvars, freelines)
+        for decl in sorted(localvars):
+            prnt('  %s;' % (decl,))
+        #
+        if not isinstance(tp.result, model.VoidType):
+            result_code = 'result = '
+            context = 'result of %s' % name
+            prnt('  %s;' % tp.result.get_c_name(' result', context))
+            prnt('  PyObject *pyresult;')
+        else:
+            result_code = ''
+        #
+        if len(tp.args) > 1:
+            rng = range(len(tp.args))
+            for i in rng:
+                prnt('  PyObject *arg%d;' % i)
+            prnt()
+            prnt('  if (!PyArg_ParseTuple(args, "%s:%s", %s))' % (
+                'O' * numargs, name, ', '.join(['&arg%d' % i for i in rng])))
+            prnt('    return NULL;')
+        prnt()
+        #
+        for i, type in enumerate(tp.args):
+            self._convert_funcarg_to_c(type, 'arg%d' % i, 'x%d' % i,
+                                       'return NULL')
+            prnt()
+        #
+        prnt('  Py_BEGIN_ALLOW_THREADS')
+        prnt('  _cffi_restore_errno();')
+        prnt('  { %s%s(%s); }' % (
+            result_code, name,
+            ', '.join(['x%d' % i for i in range(len(tp.args))])))
+        prnt('  _cffi_save_errno();')
+        prnt('  Py_END_ALLOW_THREADS')
+        prnt()
+        #
+        prnt('  (void)self; /* unused */')
+        if numargs == 0:
+            prnt('  (void)noarg; /* unused */')
+        if result_code:
+            prnt('  pyresult = %s;' %
+                 self._convert_expr_from_c(tp.result, 'result', 'result type'))
+            for freeline in freelines:
+                prnt('  ' + freeline)
+            prnt('  return pyresult;')
+        else:
+            for freeline in freelines:
+                prnt('  ' + freeline)
+            prnt('  Py_INCREF(Py_None);')
+            prnt('  return Py_None;')
+        prnt('}')
+        prnt()
+
+    def _generate_cpy_function_method(self, tp, name):
+        if tp.ellipsis:
+            return
+        numargs = len(tp.args)
+        if numargs == 0:
+            meth = 'METH_NOARGS'
+        elif numargs == 1:
+            meth = 'METH_O'
+        else:
+            meth = 'METH_VARARGS'
+        self._prnt('  {"%s", _cffi_f_%s, %s, NULL},' % (name, name, meth))
+
+    _loading_cpy_function = _loaded_noop
+
+    def _loaded_cpy_function(self, tp, name, module, library):
+        if tp.ellipsis:
+            return
+        func = getattr(module, name)
+        setattr(library, name, func)
+        self._types_of_builtin_functions[func] = tp
+
+    # ----------
+    # named structs
+
+    _generate_cpy_struct_collecttype = _generate_nothing
+    def _generate_cpy_struct_decl(self, tp, name):
+        assert name == tp.name
+        self._generate_struct_or_union_decl(tp, 'struct', name)
+    def _generate_cpy_struct_method(self, tp, name):
+        self._generate_struct_or_union_method(tp, 'struct', name)
+    def _loading_cpy_struct(self, tp, name, module):
+        self._loading_struct_or_union(tp, 'struct', name, module)
+    def _loaded_cpy_struct(self, tp, name, module, **kwds):
+        self._loaded_struct_or_union(tp)
+
+    _generate_cpy_union_collecttype = _generate_nothing
+    def _generate_cpy_union_decl(self, tp, name):
+        assert name == tp.name
+        self._generate_struct_or_union_decl(tp, 'union', name)
+    def _generate_cpy_union_method(self, tp, name):
+        self._generate_struct_or_union_method(tp, 'union', name)
+    def _loading_cpy_union(self, tp, name, module):
+        self._loading_struct_or_union(tp, 'union', name, module)
+    def _loaded_cpy_union(self, tp, name, module, **kwds):
+        self._loaded_struct_or_union(tp)
+
+    def _generate_struct_or_union_decl(self, tp, prefix, name):
+        if tp.fldnames is None:
+            return     # nothing to do with opaque structs
+        checkfuncname = '_cffi_check_%s_%s' % (prefix, name)
+        layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name)
+        cname = ('%s %s' % (prefix, name)).strip()
+        #
+        prnt = self._prnt
+        prnt('static void %s(%s *p)' % (checkfuncname, cname))
+        prnt('{')
+        prnt('  /* only to generate compile-time warnings or errors */')
+        prnt('  (void)p;')
+        for fname, ftype, fbitsize, fqual in tp.enumfields():
+            if (isinstance(ftype, model.PrimitiveType)
+                and ftype.is_integer_type()) or fbitsize >= 0:
+                # accept all integers, but complain on float or double
+                prnt('  (void)((p->%s) << 1);' % fname)
+            else:
+                # only accept exactly the type declared.
+                try:
+                    prnt('  { %s = &p->%s; (void)tmp; }' % (
+                        ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual),
+                        fname))
+                except VerificationError as e:
+                    prnt('  /* %s */' % str(e))   # cannot verify it, ignore
+        prnt('}')
+        prnt('static PyObject *')
+        prnt('%s(PyObject *self, PyObject *noarg)' % (layoutfuncname,))
+        prnt('{')
+        prnt('  struct _cffi_aligncheck { char x; %s y; };' % cname)
+        prnt('  static Py_ssize_t nums[] = {')
+        prnt('    sizeof(%s),' % cname)
+        prnt('    offsetof(struct _cffi_aligncheck, y),')
+        for fname, ftype, fbitsize, fqual in tp.enumfields():
+            if fbitsize >= 0:
+                continue      # xxx ignore fbitsize for now
+            prnt('    offsetof(%s, %s),' % (cname, fname))
+            if isinstance(ftype, model.ArrayType) and ftype.length is None:
+                prnt('    0,  /* %s */' % ftype._get_c_name())
+            else:
+                prnt('    sizeof(((%s *)0)->%s),' % (cname, fname))
+        prnt('    -1')
+        prnt('  };')
+        prnt('  (void)self; /* unused */')
+        prnt('  (void)noarg; /* unused */')
+        prnt('  return _cffi_get_struct_layout(nums);')
+        prnt('  /* the next line is not executed, but compiled */')
+        prnt('  %s(0);' % (checkfuncname,))
+        prnt('}')
+        prnt()
+
+    def _generate_struct_or_union_method(self, tp, prefix, name):
+        if tp.fldnames is None:
+            return     # nothing to do with opaque structs
+        layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name)
+        self._prnt('  {"%s", %s, METH_NOARGS, NULL},' % (layoutfuncname,
+                                                         layoutfuncname))
+
+    def _loading_struct_or_union(self, tp, prefix, name, module):
+        if tp.fldnames is None:
+            return     # nothing to do with opaque structs
+        layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name)
+        #
+        function = getattr(module, layoutfuncname)
+        layout = function()
+        if isinstance(tp, model.StructOrUnion) and tp.partial:
+            # use the function()'s sizes and offsets to guide the
+            # layout of the struct
+            totalsize = layout[0]
+            totalalignment = layout[1]
+            fieldofs = layout[2::2]
+            fieldsize = layout[3::2]
+            tp.force_flatten()
+            assert len(fieldofs) == len(fieldsize) == len(tp.fldnames)
+            tp.fixedlayout = fieldofs, fieldsize, totalsize, totalalignment
+        else:
+            cname = ('%s %s' % (prefix, name)).strip()
+            self._struct_pending_verification[tp] = layout, cname
+
+    def _loaded_struct_or_union(self, tp):
+        if tp.fldnames is None:
+            return     # nothing to do with opaque structs
+        self.ffi._get_cached_btype(tp)   # force 'fixedlayout' to be considered
+
+        if tp in self._struct_pending_verification:
+            # check that the layout sizes and offsets match the real ones
+            def check(realvalue, expectedvalue, msg):
+                if realvalue != expectedvalue:
+                    raise VerificationError(
+                        "%s (we have %d, but C compiler says %d)"
+                        % (msg, expectedvalue, realvalue))
+            ffi = self.ffi
+            BStruct = ffi._get_cached_btype(tp)
+            layout, cname = self._struct_pending_verification.pop(tp)
+            check(layout[0], ffi.sizeof(BStruct), "wrong total size")
+            check(layout[1], ffi.alignof(BStruct), "wrong total alignment")
+            i = 2
+            for fname, ftype, fbitsize, fqual in tp.enumfields():
+                if fbitsize >= 0:
+                    continue        # xxx ignore fbitsize for now
+                check(layout[i], ffi.offsetof(BStruct, fname),
+                      "wrong offset for field %r" % (fname,))
+                if layout[i+1] != 0:
+                    BField = ffi._get_cached_btype(ftype)
+                    check(layout[i+1], ffi.sizeof(BField),
+                          "wrong size for field %r" % (fname,))
+                i += 2
+            assert i == len(layout)
+
+    # ----------
+    # 'anonymous' declarations.  These are produced for anonymous structs
+    # or unions; the 'name' is obtained by a typedef.
+
+    _generate_cpy_anonymous_collecttype = _generate_nothing
+
+    def _generate_cpy_anonymous_decl(self, tp, name):
+        if isinstance(tp, model.EnumType):
+            self._generate_cpy_enum_decl(tp, name, '')
+        else:
+            self._generate_struct_or_union_decl(tp, '', name)
+
+    def _generate_cpy_anonymous_method(self, tp, name):
+        if not isinstance(tp, model.EnumType):
+            self._generate_struct_or_union_method(tp, '', name)
+
+    def _loading_cpy_anonymous(self, tp, name, module):
+        if isinstance(tp, model.EnumType):
+            self._loading_cpy_enum(tp, name, module)
+        else:
+            self._loading_struct_or_union(tp, '', name, module)
+
+    def _loaded_cpy_anonymous(self, tp, name, module, **kwds):
+        if isinstance(tp, model.EnumType):
+            self._loaded_cpy_enum(tp, name, module, **kwds)
+        else:
+            self._loaded_struct_or_union(tp)
+
+    # ----------
+    # constants, likely declared with '#define'
+
+    def _generate_cpy_const(self, is_int, name, tp=None, category='const',
+                            vartp=None, delayed=True, size_too=False,
+                            check_value=None):
+        prnt = self._prnt
+        funcname = '_cffi_%s_%s' % (category, name)
+        prnt('static int %s(PyObject *lib)' % funcname)
+        prnt('{')
+        prnt('  PyObject *o;')
+        prnt('  int res;')
+        if not is_int:
+            prnt('  %s;' % (vartp or tp).get_c_name(' i', name))
+        else:
+            assert category == 'const'
+        #
+        if check_value is not None:
+            self._check_int_constant_value(name, check_value)
+        #
+        if not is_int:
+            if category == 'var':
+                realexpr = '&' + name
+            else:
+                realexpr = name
+            prnt('  i = (%s);' % (realexpr,))
+            prnt('  o = %s;' % (self._convert_expr_from_c(tp, 'i',
+                                                          'variable type'),))
+            assert delayed
+        else:
+            prnt('  o = _cffi_from_c_int_const(%s);' % name)
+        prnt('  if (o == NULL)')
+        prnt('    return -1;')
+        if size_too:
+            prnt('  {')
+            prnt('    PyObject *o1 = o;')
+            prnt('    o = Py_BuildValue("On", o1, (Py_ssize_t)sizeof(%s));'
+                 % (name,))
+            prnt('    Py_DECREF(o1);')
+            prnt('    if (o == NULL)')
+            prnt('      return -1;')
+            prnt('  }')
+        prnt('  res = PyObject_SetAttrString(lib, "%s", o);' % name)
+        prnt('  Py_DECREF(o);')
+        prnt('  if (res < 0)')
+        prnt('    return -1;')
+        prnt('  return %s;' % self._chained_list_constants[delayed])
+        self._chained_list_constants[delayed] = funcname + '(lib)'
+        prnt('}')
+        prnt()
+
+    def _generate_cpy_constant_collecttype(self, tp, name):
+        is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type()
+        if not is_int:
+            self._do_collect_type(tp)
+
+    def _generate_cpy_constant_decl(self, tp, name):
+        is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type()
+        self._generate_cpy_const(is_int, name, tp)
+
+    _generate_cpy_constant_method = _generate_nothing
+    _loading_cpy_constant = _loaded_noop
+    _loaded_cpy_constant  = _loaded_noop
+
+    # ----------
+    # enums
+
+    def _check_int_constant_value(self, name, value, err_prefix=''):
+        prnt = self._prnt
+        if value <= 0:
+            prnt('  if ((%s) > 0 || (long)(%s) != %dL) {' % (
+                name, name, value))
+        else:
+            prnt('  if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {' % (
+                name, name, value))
+        prnt('    char buf[64];')
+        prnt('    if ((%s) <= 0)' % name)
+        prnt('        snprintf(buf, 63, "%%ld", (long)(%s));' % name)
+        prnt('    else')
+        prnt('        snprintf(buf, 63, "%%lu", (unsigned long)(%s));' %
+             name)
+        prnt('    PyErr_Format(_cffi_VerificationError,')
+        prnt('                 "%s%s has the real value %s, not %s",')
+        prnt('                 "%s", "%s", buf, "%d");' % (
+            err_prefix, name, value))
+        prnt('    return -1;')
+        prnt('  }')
+
+    def _enum_funcname(self, prefix, name):
+        # "$enum_$1" => "___D_enum____D_1"
+        name = name.replace('$', '___D_')
+        return '_cffi_e_%s_%s' % (prefix, name)
+
+    def _generate_cpy_enum_decl(self, tp, name, prefix='enum'):
+        if tp.partial:
+            for enumerator in tp.enumerators:
+                self._generate_cpy_const(True, enumerator, delayed=False)
+            return
+        #
+        funcname = self._enum_funcname(prefix, name)
+        prnt = self._prnt
+        prnt('static int %s(PyObject *lib)' % funcname)
+        prnt('{')
+        for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues):
+            self._check_int_constant_value(enumerator, enumvalue,
+                                           "enum %s: " % name)
+        prnt('  return %s;' % self._chained_list_constants[True])
+        self._chained_list_constants[True] = funcname + '(lib)'
+        prnt('}')
+        prnt()
+
+    _generate_cpy_enum_collecttype = _generate_nothing
+    _generate_cpy_enum_method = _generate_nothing
+
+    def _loading_cpy_enum(self, tp, name, module):
+        if tp.partial:
+            enumvalues = [getattr(module, enumerator)
+                          for enumerator in tp.enumerators]
+            tp.enumvalues = tuple(enumvalues)
+            tp.partial_resolved = True
+
+    def _loaded_cpy_enum(self, tp, name, module, library):
+        for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues):
+            setattr(library, enumerator, enumvalue)
+
+    # ----------
+    # macros: for now only for integers
+
+    def _generate_cpy_macro_decl(self, tp, name):
+        if tp == '...':
+            check_value = None
+        else:
+            check_value = tp     # an integer
+        self._generate_cpy_const(True, name, check_value=check_value)
+
+    _generate_cpy_macro_collecttype = _generate_nothing
+    _generate_cpy_macro_method = _generate_nothing
+    _loading_cpy_macro = _loaded_noop
+    _loaded_cpy_macro  = _loaded_noop
+
+    # ----------
+    # global variables
+
+    def _generate_cpy_variable_collecttype(self, tp, name):
+        if isinstance(tp, model.ArrayType):
+            tp_ptr = model.PointerType(tp.item)
+        else:
+            tp_ptr = model.PointerType(tp)
+        self._do_collect_type(tp_ptr)
+
+    def _generate_cpy_variable_decl(self, tp, name):
+        if isinstance(tp, model.ArrayType):
+            tp_ptr = model.PointerType(tp.item)
+            self._generate_cpy_const(False, name, tp, vartp=tp_ptr,
+                                     size_too = tp.length_is_unknown())
+        else:
+            tp_ptr = model.PointerType(tp)
+            self._generate_cpy_const(False, name, tp_ptr, category='var')
+
+    _generate_cpy_variable_method = _generate_nothing
+    _loading_cpy_variable = _loaded_noop
+
+    def _loaded_cpy_variable(self, tp, name, module, library):
+        value = getattr(library, name)
+        if isinstance(tp, model.ArrayType):   # int a[5] is "constant" in the
+                                              # sense that "a=..." is forbidden
+            if tp.length_is_unknown():
+                assert isinstance(value, tuple)
+                (value, size) = value
+                BItemType = self.ffi._get_cached_btype(tp.item)
+                length, rest = divmod(size, self.ffi.sizeof(BItemType))
+                if rest != 0:
+                    raise VerificationError(
+                        "bad size: %r does not seem to be an array of %s" %
+                        (name, tp.item))
+                tp = tp.resolve_length(length)
+            # 'value' is a <cdata 'type *'> which we have to replace with
+            # a <cdata 'type[N]'> if the N is actually known
+            if tp.length is not None:
+                BArray = self.ffi._get_cached_btype(tp)
+                value = self.ffi.cast(BArray, value)
+                setattr(library, name, value)
+            return
+        # remove ptr=<cdata 'int *'> from the library instance, and replace
+        # it by a property on the class, which reads/writes into ptr[0].
+        ptr = value
+        delattr(library, name)
+        def getter(library):
+            return ptr[0]
+        def setter(library, value):
+            ptr[0] = value
+        setattr(type(library), name, property(getter, setter))
+        type(library)._cffi_dir.append(name)
+
+    # ----------
+
+    def _generate_setup_custom(self):
+        prnt = self._prnt
+        prnt('static int _cffi_setup_custom(PyObject *lib)')
+        prnt('{')
+        prnt('  return %s;' % self._chained_list_constants[True])
+        prnt('}')
+
+cffimod_header = r'''
+#include <Python.h>
+#include <stddef.h>
+
+/* this block of #ifs should be kept exactly identical between
+   c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py
+   and cffi/_cffi_include.h */
+#if defined(_MSC_VER)
+# include <malloc.h>   /* for alloca() */
+# if _MSC_VER < 1600   /* MSVC < 2010 */
+   typedef __int8 int8_t;
+   typedef __int16 int16_t;
+   typedef __int32 int32_t;
+   typedef __int64 int64_t;
+   typedef unsigned __int8 uint8_t;
+   typedef unsigned __int16 uint16_t;
+   typedef unsigned __int32 uint32_t;
+   typedef unsigned __int64 uint64_t;
+   typedef __int8 int_least8_t;
+   typedef __int16 int_least16_t;
+   typedef __int32 int_least32_t;
+   typedef __int64 int_least64_t;
+   typedef unsigned __int8 uint_least8_t;
+   typedef unsigned __int16 uint_least16_t;
+   typedef unsigned __int32 uint_least32_t;
+   typedef unsigned __int64 uint_least64_t;
+   typedef __int8 int_fast8_t;
+   typedef __int16 int_fast16_t;
+   typedef __int32 int_fast32_t;
+   typedef __int64 int_fast64_t;
+   typedef unsigned __int8 uint_fast8_t;
+   typedef unsigned __int16 uint_fast16_t;
+   typedef unsigned __int32 uint_fast32_t;
+   typedef unsigned __int64 uint_fast64_t;
+   typedef __int64 intmax_t;
+   typedef unsigned __int64 uintmax_t;
+# else
+#  include <stdint.h>
+# endif
+# if _MSC_VER < 1800   /* MSVC < 2013 */
+#  ifndef __cplusplus
+    typedef unsigned char _Bool;
+#  endif
+# endif
+#else
+# include <stdint.h>
+# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux)
+#  include <alloca.h>
+# endif
+#endif
+
+#if PY_MAJOR_VERSION < 3
+# undef PyCapsule_CheckExact
+# undef PyCapsule_GetPointer
+# define PyCapsule_CheckExact(capsule) (PyCObject_Check(capsule))
+# define PyCapsule_GetPointer(capsule, name) \
+    (PyCObject_AsVoidPtr(capsule))
+#endif
+
+#if PY_MAJOR_VERSION >= 3
+# define PyInt_FromLong PyLong_FromLong
+#endif
+
+#define _cffi_from_c_double PyFloat_FromDouble
+#define _cffi_from_c_float PyFloat_FromDouble
+#define _cffi_from_c_long PyInt_FromLong
+#define _cffi_from_c_ulong PyLong_FromUnsignedLong
+#define _cffi_from_c_longlong PyLong_FromLongLong
+#define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong
+#define _cffi_from_c__Bool PyBool_FromLong
+
+#define _cffi_to_c_double PyFloat_AsDouble
+#define _cffi_to_c_float PyFloat_AsDouble
+
+#define _cffi_from_c_int_const(x)                                        \
+    (((x) > 0) ?                                                         \
+        ((unsigned long long)(x) <= (unsigned long long)LONG_MAX) ?      \
+            PyInt_FromLong((long)(x)) :                                  \
+            PyLong_FromUnsignedLongLong((unsigned long long)(x)) :       \
+        ((long long)(x) >= (long long)LONG_MIN) ?                        \
+            PyInt_FromLong((long)(x)) :                                  \
+            PyLong_FromLongLong((long long)(x)))
+
+#define _cffi_from_c_int(x, type)                                        \
+    (((type)-1) > 0 ? /* unsigned */                                     \
+        (sizeof(type) < sizeof(long) ?                                   \
+            PyInt_FromLong((long)x) :                                    \
+         sizeof(type) == sizeof(long) ?                                  \
+            PyLong_FromUnsignedLong((unsigned long)x) :                  \
+            PyLong_FromUnsignedLongLong((unsigned long long)x)) :        \
+        (sizeof(type) <= sizeof(long) ?                                  \
+            PyInt_FromLong((long)x) :                                    \
+            PyLong_FromLongLong((long long)x)))
+
+#define _cffi_to_c_int(o, type)                                          \
+    ((type)(                                                             \
+     sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o)        \
+                                         : (type)_cffi_to_c_i8(o)) :     \
+     sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o)       \
+                                         : (type)_cffi_to_c_i16(o)) :    \
+     sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o)       \
+                                         : (type)_cffi_to_c_i32(o)) :    \
+     sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o)       \
+                                         : (type)_cffi_to_c_i64(o)) :    \
+     (Py_FatalError("unsupported size for type " #type), (type)0)))
+
+#define _cffi_to_c_i8                                                    \
+                 ((int(*)(PyObject *))_cffi_exports[1])
+#define _cffi_to_c_u8                                                    \
+                 ((int(*)(PyObject *))_cffi_exports[2])
+#define _cffi_to_c_i16                                                   \
+                 ((int(*)(PyObject *))_cffi_exports[3])
+#define _cffi_to_c_u16                                                   \
+                 ((int(*)(PyObject *))_cffi_exports[4])
+#define _cffi_to_c_i32                                                   \
+                 ((int(*)(PyObject *))_cffi_exports[5])
+#define _cffi_to_c_u32                                                   \
+                 ((unsigned int(*)(PyObject *))_cffi_exports[6])
+#define _cffi_to_c_i64                                                   \
+                 ((long long(*)(PyObject *))_cffi_exports[7])
+#define _cffi_to_c_u64                                                   \
+                 ((unsigned long long(*)(PyObject *))_cffi_exports[8])
+#define _cffi_to_c_char                                                  \
+                 ((int(*)(PyObject *))_cffi_exports[9])
+#define _cffi_from_c_pointer                                             \
+    ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[10])
+#define _cffi_to_c_pointer                                               \
+    ((char *(*)(PyObject *, CTypeDescrObject *))_cffi_exports[11])
+#define _cffi_get_struct_layout                                          \
+    ((PyObject *(*)(Py_ssize_t[]))_cffi_exports[12])
+#define _cffi_restore_errno                                              \
+    ((void(*)(void))_cffi_exports[13])
+#define _cffi_save_errno                                                 \
+    ((void(*)(void))_cffi_exports[14])
+#define _cffi_from_c_char                                                \
+    ((PyObject *(*)(char))_cffi_exports[15])
+#define _cffi_from_c_deref                                               \
+    ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[16])
+#define _cffi_to_c                                                       \
+    ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[17])
+#define _cffi_from_c_struct                                              \
+    ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[18])
+#define _cffi_to_c_wchar_t                                               \
+    ((wchar_t(*)(PyObject *))_cffi_exports[19])
+#define _cffi_from_c_wchar_t                                             \
+    ((PyObject *(*)(wchar_t))_cffi_exports[20])
+#define _cffi_to_c_long_double                                           \
+    ((long double(*)(PyObject *))_cffi_exports[21])
+#define _cffi_to_c__Bool                                                 \
+    ((_Bool(*)(PyObject *))_cffi_exports[22])
+#define _cffi_prepare_pointer_call_argument                              \
+    ((Py_ssize_t(*)(CTypeDescrObject *, PyObject *, char **))_cffi_exports[23])
+#define _cffi_convert_array_from_object                                  \
+    ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[24])
+#define _CFFI_NUM_EXPORTS 25
+
+typedef struct _ctypedescr CTypeDescrObject;
+
+static void *_cffi_exports[_CFFI_NUM_EXPORTS];
+static PyObject *_cffi_types, *_cffi_VerificationError;
+
+static int _cffi_setup_custom(PyObject *lib);   /* forward */
+
+static PyObject *_cffi_setup(PyObject *self, PyObject *args)
+{
+    PyObject *library;
+    int was_alive = (_cffi_types != NULL);
+    (void)self; /* unused */
+    if (!PyArg_ParseTuple(args, "OOO", &_cffi_types, &_cffi_VerificationError,
+                                       &library))
+        return NULL;
+    Py_INCREF(_cffi_types);
+    Py_INCREF(_cffi_VerificationError);
+    if (_cffi_setup_custom(library) < 0)
+        return NULL;
+    return PyBool_FromLong(was_alive);
+}
+
+union _cffi_union_alignment_u {
+    unsigned char m_char;
+    unsigned short m_short;
+    unsigned int m_int;
+    unsigned long m_long;
+    unsigned long long m_longlong;
+    float m_float;
+    double m_double;
+    long double m_longdouble;
+};
+
+struct _cffi_freeme_s {
+    struct _cffi_freeme_s *next;
+    union _cffi_union_alignment_u alignment;
+};
+
+#ifdef __GNUC__
+  __attribute__((unused))
+#endif
+static int _cffi_convert_array_argument(CTypeDescrObject *ctptr, PyObject *arg,
+                                        char **output_data, Py_ssize_t datasize,
+                                        struct _cffi_freeme_s **freeme)
+{
+    char *p;
+    if (datasize < 0)
+        return -1;
+
+    p = *output_data;
+    if (p == NULL) {
+        struct _cffi_freeme_s *fp = (struct _cffi_freeme_s *)PyObject_Malloc(
+            offsetof(struct _cffi_freeme_s, alignment) + (size_t)datasize);
+        if (fp == NULL)
+            return -1;
+        fp->next = *freeme;
+        *freeme = fp;
+        p = *output_data = (char *)&fp->alignment;
+    }
+    memset((void *)p, 0, (size_t)datasize);
+    return _cffi_convert_array_from_object(p, ctptr, arg);
+}
+
+#ifdef __GNUC__
+  __attribute__((unused))
+#endif
+static void _cffi_free_array_arguments(struct _cffi_freeme_s *freeme)
+{
+    do {
+        void *p = (void *)freeme;
+        freeme = freeme->next;
+        PyObject_Free(p);
+    } while (freeme != NULL);
+}
+
+static int _cffi_init(void)
+{
+    PyObject *module, *c_api_object = NULL;
+
+    module = PyImport_ImportModule("_cffi_backend");
+    if (module == NULL)
+        goto failure;
+
+    c_api_object = PyObject_GetAttrString(module, "_C_API");
+    if (c_api_object == NULL)
+        goto failure;
+    if (!PyCapsule_CheckExact(c_api_object)) {
+        PyErr_SetNone(PyExc_ImportError);
+        goto failure;
+    }
+    memcpy(_cffi_exports, PyCapsule_GetPointer(c_api_object, "cffi"),
+           _CFFI_NUM_EXPORTS * sizeof(void *));
+
+    Py_DECREF(module);
+    Py_DECREF(c_api_object);
+    return 0;
+
+  failure:
+    Py_XDECREF(module);
+    Py_XDECREF(c_api_object);
+    return -1;
+}
+
+#define _cffi_type(num) ((CTypeDescrObject *)PyList_GET_ITEM(_cffi_types, num))
+
+/**********/
+'''
diff --git a/myenv/lib/python3.9/site-packages/cffi/vengine_gen.py b/myenv/lib/python3.9/site-packages/cffi/vengine_gen.py
new file mode 100644
index 0000000..2642152
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/vengine_gen.py
@@ -0,0 +1,675 @@
+#
+# DEPRECATED: implementation for ffi.verify()
+#
+import sys, os
+import types
+
+from . import model
+from .error import VerificationError
+
+
+class VGenericEngine(object):
+    _class_key = 'g'
+    _gen_python_module = False
+
+    def __init__(self, verifier):
+        self.verifier = verifier
+        self.ffi = verifier.ffi
+        self.export_symbols = []
+        self._struct_pending_verification = {}
+
+    def patch_extension_kwds(self, kwds):
+        # add 'export_symbols' to the dictionary.  Note that we add the
+        # list before filling it.  When we fill it, it will thus also show
+        # up in kwds['export_symbols'].
+        kwds.setdefault('export_symbols', self.export_symbols)
+
+    def find_module(self, module_name, path, so_suffixes):
+        for so_suffix in so_suffixes:
+            basename = module_name + so_suffix
+            if path is None:
+                path = sys.path
+            for dirname in path:
+                filename = os.path.join(dirname, basename)
+                if os.path.isfile(filename):
+                    return filename
+
+    def collect_types(self):
+        pass      # not needed in the generic engine
+
+    def _prnt(self, what=''):
+        self._f.write(what + '\n')
+
+    def write_source_to_f(self):
+        prnt = self._prnt
+        # first paste some standard set of lines that are mostly '#include'
+        prnt(cffimod_header)
+        # then paste the C source given by the user, verbatim.
+        prnt(self.verifier.preamble)
+        #
+        # call generate_gen_xxx_decl(), for every xxx found from
+        # ffi._parser._declarations.  This generates all the functions.
+        self._generate('decl')
+        #
+        # on Windows, distutils insists on putting init_cffi_xyz in
+        # 'export_symbols', so instead of fighting it, just give up and
+        # give it one
+        if sys.platform == 'win32':
+            if sys.version_info >= (3,):
+                prefix = 'PyInit_'
+            else:
+                prefix = 'init'
+            modname = self.verifier.get_module_name()
+            prnt("void %s%s(void) { }\n" % (prefix, modname))
+
+    def load_library(self, flags=0):
+        # import it with the CFFI backend
+        backend = self.ffi._backend
+        # needs to make a path that contains '/', on Posix
+        filename = os.path.join(os.curdir, self.verifier.modulefilename)
+        module = backend.load_library(filename, flags)
+        #
+        # call loading_gen_struct() to get the struct layout inferred by
+        # the C compiler
+        self._load(module, 'loading')
+
+        # build the FFILibrary class and instance, this is a module subclass
+        # because modules are expected to have usually-constant-attributes and
+        # in PyPy this means the JIT is able to treat attributes as constant,
+        # which we want.
+        class FFILibrary(types.ModuleType):
+            _cffi_generic_module = module
+            _cffi_ffi = self.ffi
+            _cffi_dir = []
+            def __dir__(self):
+                return FFILibrary._cffi_dir
+        library = FFILibrary("")
+        #
+        # finally, call the loaded_gen_xxx() functions.  This will set
+        # up the 'library' object.
+        self._load(module, 'loaded', library=library)
+        return library
+
+    def _get_declarations(self):
+        lst = [(key, tp) for (key, (tp, qual)) in
+                                self.ffi._parser._declarations.items()]
+        lst.sort()
+        return lst
+
+    def _generate(self, step_name):
+        for name, tp in self._get_declarations():
+            kind, realname = name.split(' ', 1)
+            try:
+                method = getattr(self, '_generate_gen_%s_%s' % (kind,
+                                                                step_name))
+            except AttributeError:
+                raise VerificationError(
+                    "not implemented in verify(): %r" % name)
+            try:
+                method(tp, realname)
+            except Exception as e:
+                model.attach_exception_info(e, name)
+                raise
+
+    def _load(self, module, step_name, **kwds):
+        for name, tp in self._get_declarations():
+            kind, realname = name.split(' ', 1)
+            method = getattr(self, '_%s_gen_%s' % (step_name, kind))
+            try:
+                method(tp, realname, module, **kwds)
+            except Exception as e:
+                model.attach_exception_info(e, name)
+                raise
+
+    def _generate_nothing(self, tp, name):
+        pass
+
+    def _loaded_noop(self, tp, name, module, **kwds):
+        pass
+
+    # ----------
+    # typedefs: generates no code so far
+
+    _generate_gen_typedef_decl   = _generate_nothing
+    _loading_gen_typedef         = _loaded_noop
+    _loaded_gen_typedef          = _loaded_noop
+
+    # ----------
+    # function declarations
+
+    def _generate_gen_function_decl(self, tp, name):
+        assert isinstance(tp, model.FunctionPtrType)
+        if tp.ellipsis:
+            # cannot support vararg functions better than this: check for its
+            # exact type (including the fixed arguments), and build it as a
+            # constant function pointer (no _cffi_f_%s wrapper)
+            self._generate_gen_const(False, name, tp)
+            return
+        prnt = self._prnt
+        numargs = len(tp.args)
+        argnames = []
+        for i, type in enumerate(tp.args):
+            indirection = ''
+            if isinstance(type, model.StructOrUnion):
+                indirection = '*'
+            argnames.append('%sx%d' % (indirection, i))
+        context = 'argument of %s' % name
+        arglist = [type.get_c_name(' %s' % arg, context)
+                   for type, arg in zip(tp.args, argnames)]
+        tpresult = tp.result
+        if isinstance(tpresult, model.StructOrUnion):
+            arglist.insert(0, tpresult.get_c_name(' *r', context))
+            tpresult = model.void_type
+        arglist = ', '.join(arglist) or 'void'
+        wrappername = '_cffi_f_%s' % name
+        self.export_symbols.append(wrappername)
+        if tp.abi:
+            abi = tp.abi + ' '
+        else:
+            abi = ''
+        funcdecl = ' %s%s(%s)' % (abi, wrappername, arglist)
+        context = 'result of %s' % name
+        prnt(tpresult.get_c_name(funcdecl, context))
+        prnt('{')
+        #
+        if isinstance(tp.result, model.StructOrUnion):
+            result_code = '*r = '
+        elif not isinstance(tp.result, model.VoidType):
+            result_code = 'return '
+        else:
+            result_code = ''
+        prnt('  %s%s(%s);' % (result_code, name, ', '.join(argnames)))
+        prnt('}')
+        prnt()
+
+    _loading_gen_function = _loaded_noop
+
+    def _loaded_gen_function(self, tp, name, module, library):
+        assert isinstance(tp, model.FunctionPtrType)
+        if tp.ellipsis:
+            newfunction = self._load_constant(False, tp, name, module)
+        else:
+            indirections = []
+            base_tp = tp
+            if (any(isinstance(typ, model.StructOrUnion) for typ in tp.args)
+                    or isinstance(tp.result, model.StructOrUnion)):
+                indirect_args = []
+                for i, typ in enumerate(tp.args):
+                    if isinstance(typ, model.StructOrUnion):
+                        typ = model.PointerType(typ)
+                        indirections.append((i, typ))
+                    indirect_args.append(typ)
+                indirect_result = tp.result
+                if isinstance(indirect_result, model.StructOrUnion):
+                    if indirect_result.fldtypes is None:
+                        raise TypeError("'%s' is used as result type, "
+                                        "but is opaque" % (
+                                            indirect_result._get_c_name(),))
+                    indirect_result = model.PointerType(indirect_result)
+                    indirect_args.insert(0, indirect_result)
+                    indirections.insert(0, ("result", indirect_result))
+                    indirect_result = model.void_type
+                tp = model.FunctionPtrType(tuple(indirect_args),
+                                           indirect_result, tp.ellipsis)
+            BFunc = self.ffi._get_cached_btype(tp)
+            wrappername = '_cffi_f_%s' % name
+            newfunction = module.load_function(BFunc, wrappername)
+            for i, typ in indirections:
+                newfunction = self._make_struct_wrapper(newfunction, i, typ,
+                                                        base_tp)
+        setattr(library, name, newfunction)
+        type(library)._cffi_dir.append(name)
+
+    def _make_struct_wrapper(self, oldfunc, i, tp, base_tp):
+        backend = self.ffi._backend
+        BType = self.ffi._get_cached_btype(tp)
+        if i == "result":
+            ffi = self.ffi
+            def newfunc(*args):
+                res = ffi.new(BType)
+                oldfunc(res, *args)
+                return res[0]
+        else:
+            def newfunc(*args):
+                args = args[:i] + (backend.newp(BType, args[i]),) + args[i+1:]
+                return oldfunc(*args)
+        newfunc._cffi_base_type = base_tp
+        return newfunc
+
+    # ----------
+    # named structs
+
+    def _generate_gen_struct_decl(self, tp, name):
+        assert name == tp.name
+        self._generate_struct_or_union_decl(tp, 'struct', name)
+
+    def _loading_gen_struct(self, tp, name, module):
+        self._loading_struct_or_union(tp, 'struct', name, module)
+
+    def _loaded_gen_struct(self, tp, name, module, **kwds):
+        self._loaded_struct_or_union(tp)
+
+    def _generate_gen_union_decl(self, tp, name):
+        assert name == tp.name
+        self._generate_struct_or_union_decl(tp, 'union', name)
+
+    def _loading_gen_union(self, tp, name, module):
+        self._loading_struct_or_union(tp, 'union', name, module)
+
+    def _loaded_gen_union(self, tp, name, module, **kwds):
+        self._loaded_struct_or_union(tp)
+
+    def _generate_struct_or_union_decl(self, tp, prefix, name):
+        if tp.fldnames is None:
+            return     # nothing to do with opaque structs
+        checkfuncname = '_cffi_check_%s_%s' % (prefix, name)
+        layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name)
+        cname = ('%s %s' % (prefix, name)).strip()
+        #
+        prnt = self._prnt
+        prnt('static void %s(%s *p)' % (checkfuncname, cname))
+        prnt('{')
+        prnt('  /* only to generate compile-time warnings or errors */')
+        prnt('  (void)p;')
+        for fname, ftype, fbitsize, fqual in tp.enumfields():
+            if (isinstance(ftype, model.PrimitiveType)
+                and ftype.is_integer_type()) or fbitsize >= 0:
+                # accept all integers, but complain on float or double
+                prnt('  (void)((p->%s) << 1);' % fname)
+            else:
+                # only accept exactly the type declared.
+                try:
+                    prnt('  { %s = &p->%s; (void)tmp; }' % (
+                        ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual),
+                        fname))
+                except VerificationError as e:
+                    prnt('  /* %s */' % str(e))   # cannot verify it, ignore
+        prnt('}')
+        self.export_symbols.append(layoutfuncname)
+        prnt('intptr_t %s(intptr_t i)' % (layoutfuncname,))
+        prnt('{')
+        prnt('  struct _cffi_aligncheck { char x; %s y; };' % cname)
+        prnt('  static intptr_t nums[] = {')
+        prnt('    sizeof(%s),' % cname)
+        prnt('    offsetof(struct _cffi_aligncheck, y),')
+        for fname, ftype, fbitsize, fqual in tp.enumfields():
+            if fbitsize >= 0:
+                continue      # xxx ignore fbitsize for now
+            prnt('    offsetof(%s, %s),' % (cname, fname))
+            if isinstance(ftype, model.ArrayType) and ftype.length is None:
+                prnt('    0,  /* %s */' % ftype._get_c_name())
+            else:
+                prnt('    sizeof(((%s *)0)->%s),' % (cname, fname))
+        prnt('    -1')
+        prnt('  };')
+        prnt('  return nums[i];')
+        prnt('  /* the next line is not executed, but compiled */')
+        prnt('  %s(0);' % (checkfuncname,))
+        prnt('}')
+        prnt()
+
+    def _loading_struct_or_union(self, tp, prefix, name, module):
+        if tp.fldnames is None:
+            return     # nothing to do with opaque structs
+        layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name)
+        #
+        BFunc = self.ffi._typeof_locked("intptr_t(*)(intptr_t)")[0]
+        function = module.load_function(BFunc, layoutfuncname)
+        layout = []
+        num = 0
+        while True:
+            x = function(num)
+            if x < 0: break
+            layout.append(x)
+            num += 1
+        if isinstance(tp, model.StructOrUnion) and tp.partial:
+            # use the function()'s sizes and offsets to guide the
+            # layout of the struct
+            totalsize = layout[0]
+            totalalignment = layout[1]
+            fieldofs = layout[2::2]
+            fieldsize = layout[3::2]
+            tp.force_flatten()
+            assert len(fieldofs) == len(fieldsize) == len(tp.fldnames)
+            tp.fixedlayout = fieldofs, fieldsize, totalsize, totalalignment
+        else:
+            cname = ('%s %s' % (prefix, name)).strip()
+            self._struct_pending_verification[tp] = layout, cname
+
+    def _loaded_struct_or_union(self, tp):
+        if tp.fldnames is None:
+            return     # nothing to do with opaque structs
+        self.ffi._get_cached_btype(tp)   # force 'fixedlayout' to be considered
+
+        if tp in self._struct_pending_verification:
+            # check that the layout sizes and offsets match the real ones
+            def check(realvalue, expectedvalue, msg):
+                if realvalue != expectedvalue:
+                    raise VerificationError(
+                        "%s (we have %d, but C compiler says %d)"
+                        % (msg, expectedvalue, realvalue))
+            ffi = self.ffi
+            BStruct = ffi._get_cached_btype(tp)
+            layout, cname = self._struct_pending_verification.pop(tp)
+            check(layout[0], ffi.sizeof(BStruct), "wrong total size")
+            check(layout[1], ffi.alignof(BStruct), "wrong total alignment")
+            i = 2
+            for fname, ftype, fbitsize, fqual in tp.enumfields():
+                if fbitsize >= 0:
+                    continue        # xxx ignore fbitsize for now
+                check(layout[i], ffi.offsetof(BStruct, fname),
+                      "wrong offset for field %r" % (fname,))
+                if layout[i+1] != 0:
+                    BField = ffi._get_cached_btype(ftype)
+                    check(layout[i+1], ffi.sizeof(BField),
+                          "wrong size for field %r" % (fname,))
+                i += 2
+            assert i == len(layout)
+
+    # ----------
+    # 'anonymous' declarations.  These are produced for anonymous structs
+    # or unions; the 'name' is obtained by a typedef.
+
+    def _generate_gen_anonymous_decl(self, tp, name):
+        if isinstance(tp, model.EnumType):
+            self._generate_gen_enum_decl(tp, name, '')
+        else:
+            self._generate_struct_or_union_decl(tp, '', name)
+
+    def _loading_gen_anonymous(self, tp, name, module):
+        if isinstance(tp, model.EnumType):
+            self._loading_gen_enum(tp, name, module, '')
+        else:
+            self._loading_struct_or_union(tp, '', name, module)
+
+    def _loaded_gen_anonymous(self, tp, name, module, **kwds):
+        if isinstance(tp, model.EnumType):
+            self._loaded_gen_enum(tp, name, module, **kwds)
+        else:
+            self._loaded_struct_or_union(tp)
+
+    # ----------
+    # constants, likely declared with '#define'
+
+    def _generate_gen_const(self, is_int, name, tp=None, category='const',
+                            check_value=None):
+        prnt = self._prnt
+        funcname = '_cffi_%s_%s' % (category, name)
+        self.export_symbols.append(funcname)
+        if check_value is not None:
+            assert is_int
+            assert category == 'const'
+            prnt('int %s(char *out_error)' % funcname)
+            prnt('{')
+            self._check_int_constant_value(name, check_value)
+            prnt('  return 0;')
+            prnt('}')
+        elif is_int:
+            assert category == 'const'
+            prnt('int %s(long long *out_value)' % funcname)
+            prnt('{')
+            prnt('  *out_value = (long long)(%s);' % (name,))
+            prnt('  return (%s) <= 0;' % (name,))
+            prnt('}')
+        else:
+            assert tp is not None
+            assert check_value is None
+            if category == 'var':
+                ampersand = '&'
+            else:
+                ampersand = ''
+            extra = ''
+            if category == 'const' and isinstance(tp, model.StructOrUnion):
+                extra = 'const *'
+                ampersand = '&'
+            prnt(tp.get_c_name(' %s%s(void)' % (extra, funcname), name))
+            prnt('{')
+            prnt('  return (%s%s);' % (ampersand, name))
+            prnt('}')
+        prnt()
+
+    def _generate_gen_constant_decl(self, tp, name):
+        is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type()
+        self._generate_gen_const(is_int, name, tp)
+
+    _loading_gen_constant = _loaded_noop
+
+    def _load_constant(self, is_int, tp, name, module, check_value=None):
+        funcname = '_cffi_const_%s' % name
+        if check_value is not None:
+            assert is_int
+            self._load_known_int_constant(module, funcname)
+            value = check_value
+        elif is_int:
+            BType = self.ffi._typeof_locked("long long*")[0]
+            BFunc = self.ffi._typeof_locked("int(*)(long long*)")[0]
+            function = module.load_function(BFunc, funcname)
+            p = self.ffi.new(BType)
+            negative = function(p)
+            value = int(p[0])
+            if value < 0 and not negative:
+                BLongLong = self.ffi._typeof_locked("long long")[0]
+                value += (1 << (8*self.ffi.sizeof(BLongLong)))
+        else:
+            assert check_value is None
+            fntypeextra = '(*)(void)'
+            if isinstance(tp, model.StructOrUnion):
+                fntypeextra = '*' + fntypeextra
+            BFunc = self.ffi._typeof_locked(tp.get_c_name(fntypeextra, name))[0]
+            function = module.load_function(BFunc, funcname)
+            value = function()
+            if isinstance(tp, model.StructOrUnion):
+                value = value[0]
+        return value
+
+    def _loaded_gen_constant(self, tp, name, module, library):
+        is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type()
+        value = self._load_constant(is_int, tp, name, module)
+        setattr(library, name, value)
+        type(library)._cffi_dir.append(name)
+
+    # ----------
+    # enums
+
+    def _check_int_constant_value(self, name, value):
+        prnt = self._prnt
+        if value <= 0:
+            prnt('  if ((%s) > 0 || (long)(%s) != %dL) {' % (
+                name, name, value))
+        else:
+            prnt('  if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {' % (
+                name, name, value))
+        prnt('    char buf[64];')
+        prnt('    if ((%s) <= 0)' % name)
+        prnt('        sprintf(buf, "%%ld", (long)(%s));' % name)
+        prnt('    else')
+        prnt('        sprintf(buf, "%%lu", (unsigned long)(%s));' %
+             name)
+        prnt('    sprintf(out_error, "%s has the real value %s, not %s",')
+        prnt('            "%s", buf, "%d");' % (name[:100], value))
+        prnt('    return -1;')
+        prnt('  }')
+
+    def _load_known_int_constant(self, module, funcname):
+        BType = self.ffi._typeof_locked("char[]")[0]
+        BFunc = self.ffi._typeof_locked("int(*)(char*)")[0]
+        function = module.load_function(BFunc, funcname)
+        p = self.ffi.new(BType, 256)
+        if function(p) < 0:
+            error = self.ffi.string(p)
+            if sys.version_info >= (3,):
+                error = str(error, 'utf-8')
+            raise VerificationError(error)
+
+    def _enum_funcname(self, prefix, name):
+        # "$enum_$1" => "___D_enum____D_1"
+        name = name.replace('$', '___D_')
+        return '_cffi_e_%s_%s' % (prefix, name)
+
+    def _generate_gen_enum_decl(self, tp, name, prefix='enum'):
+        if tp.partial:
+            for enumerator in tp.enumerators:
+                self._generate_gen_const(True, enumerator)
+            return
+        #
+        funcname = self._enum_funcname(prefix, name)
+        self.export_symbols.append(funcname)
+        prnt = self._prnt
+        prnt('int %s(char *out_error)' % funcname)
+        prnt('{')
+        for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues):
+            self._check_int_constant_value(enumerator, enumvalue)
+        prnt('  return 0;')
+        prnt('}')
+        prnt()
+
+    def _loading_gen_enum(self, tp, name, module, prefix='enum'):
+        if tp.partial:
+            enumvalues = [self._load_constant(True, tp, enumerator, module)
+                          for enumerator in tp.enumerators]
+            tp.enumvalues = tuple(enumvalues)
+            tp.partial_resolved = True
+        else:
+            funcname = self._enum_funcname(prefix, name)
+            self._load_known_int_constant(module, funcname)
+
+    def _loaded_gen_enum(self, tp, name, module, library):
+        for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues):
+            setattr(library, enumerator, enumvalue)
+            type(library)._cffi_dir.append(enumerator)
+
+    # ----------
+    # macros: for now only for integers
+
+    def _generate_gen_macro_decl(self, tp, name):
+        if tp == '...':
+            check_value = None
+        else:
+            check_value = tp     # an integer
+        self._generate_gen_const(True, name, check_value=check_value)
+
+    _loading_gen_macro = _loaded_noop
+
+    def _loaded_gen_macro(self, tp, name, module, library):
+        if tp == '...':
+            check_value = None
+        else:
+            check_value = tp     # an integer
+        value = self._load_constant(True, tp, name, module,
+                                    check_value=check_value)
+        setattr(library, name, value)
+        type(library)._cffi_dir.append(name)
+
+    # ----------
+    # global variables
+
+    def _generate_gen_variable_decl(self, tp, name):
+        if isinstance(tp, model.ArrayType):
+            if tp.length_is_unknown():
+                prnt = self._prnt
+                funcname = '_cffi_sizeof_%s' % (name,)
+                self.export_symbols.append(funcname)
+                prnt("size_t %s(void)" % funcname)
+                prnt("{")
+                prnt("  return sizeof(%s);" % (name,))
+                prnt("}")
+            tp_ptr = model.PointerType(tp.item)
+            self._generate_gen_const(False, name, tp_ptr)
+        else:
+            tp_ptr = model.PointerType(tp)
+            self._generate_gen_const(False, name, tp_ptr, category='var')
+
+    _loading_gen_variable = _loaded_noop
+
+    def _loaded_gen_variable(self, tp, name, module, library):
+        if isinstance(tp, model.ArrayType):   # int a[5] is "constant" in the
+                                              # sense that "a=..." is forbidden
+            if tp.length_is_unknown():
+                funcname = '_cffi_sizeof_%s' % (name,)
+                BFunc = self.ffi._typeof_locked('size_t(*)(void)')[0]
+                function = module.load_function(BFunc, funcname)
+                size = function()
+                BItemType = self.ffi._get_cached_btype(tp.item)
+                length, rest = divmod(size, self.ffi.sizeof(BItemType))
+                if rest != 0:
+                    raise VerificationError(
+                        "bad size: %r does not seem to be an array of %s" %
+                        (name, tp.item))
+                tp = tp.resolve_length(length)
+            tp_ptr = model.PointerType(tp.item)
+            value = self._load_constant(False, tp_ptr, name, module)
+            # 'value' is a <cdata 'type *'> which we have to replace with
+            # a <cdata 'type[N]'> if the N is actually known
+            if tp.length is not None:
+                BArray = self.ffi._get_cached_btype(tp)
+                value = self.ffi.cast(BArray, value)
+            setattr(library, name, value)
+            type(library)._cffi_dir.append(name)
+            return
+        # remove ptr=<cdata 'int *'> from the library instance, and replace
+        # it by a property on the class, which reads/writes into ptr[0].
+        funcname = '_cffi_var_%s' % name
+        BFunc = self.ffi._typeof_locked(tp.get_c_name('*(*)(void)', name))[0]
+        function = module.load_function(BFunc, funcname)
+        ptr = function()
+        def getter(library):
+            return ptr[0]
+        def setter(library, value):
+            ptr[0] = value
+        setattr(type(library), name, property(getter, setter))
+        type(library)._cffi_dir.append(name)
+
+cffimod_header = r'''
+#include <stdio.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <sys/types.h>   /* XXX for ssize_t on some platforms */
+
+/* this block of #ifs should be kept exactly identical between
+   c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py
+   and cffi/_cffi_include.h */
+#if defined(_MSC_VER)
+# include <malloc.h>   /* for alloca() */
+# if _MSC_VER < 1600   /* MSVC < 2010 */
+   typedef __int8 int8_t;
+   typedef __int16 int16_t;
+   typedef __int32 int32_t;
+   typedef __int64 int64_t;
+   typedef unsigned __int8 uint8_t;
+   typedef unsigned __int16 uint16_t;
+   typedef unsigned __int32 uint32_t;
+   typedef unsigned __int64 uint64_t;
+   typedef __int8 int_least8_t;
+   typedef __int16 int_least16_t;
+   typedef __int32 int_least32_t;
+   typedef __int64 int_least64_t;
+   typedef unsigned __int8 uint_least8_t;
+   typedef unsigned __int16 uint_least16_t;
+   typedef unsigned __int32 uint_least32_t;
+   typedef unsigned __int64 uint_least64_t;
+   typedef __int8 int_fast8_t;
+   typedef __int16 int_fast16_t;
+   typedef __int32 int_fast32_t;
+   typedef __int64 int_fast64_t;
+   typedef unsigned __int8 uint_fast8_t;
+   typedef unsigned __int16 uint_fast16_t;
+   typedef unsigned __int32 uint_fast32_t;
+   typedef unsigned __int64 uint_fast64_t;
+   typedef __int64 intmax_t;
+   typedef unsigned __int64 uintmax_t;
+# else
+#  include <stdint.h>
+# endif
+# if _MSC_VER < 1800   /* MSVC < 2013 */
+#  ifndef __cplusplus
+    typedef unsigned char _Bool;
+#  endif
+# endif
+#else
+# include <stdint.h>
+# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux)
+#  include <alloca.h>
+# endif
+#endif
+'''
diff --git a/myenv/lib/python3.9/site-packages/cffi/verifier.py b/myenv/lib/python3.9/site-packages/cffi/verifier.py
new file mode 100644
index 0000000..a500c78
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cffi/verifier.py
@@ -0,0 +1,307 @@
+#
+# DEPRECATED: implementation for ffi.verify()
+#
+import sys, os, binascii, shutil, io
+from . import __version_verifier_modules__
+from . import ffiplatform
+from .error import VerificationError
+
+if sys.version_info >= (3, 3):
+    import importlib.machinery
+    def _extension_suffixes():
+        return importlib.machinery.EXTENSION_SUFFIXES[:]
+else:
+    import imp
+    def _extension_suffixes():
+        return [suffix for suffix, _, type in imp.get_suffixes()
+                if type == imp.C_EXTENSION]
+
+
+if sys.version_info >= (3,):
+    NativeIO = io.StringIO
+else:
+    class NativeIO(io.BytesIO):
+        def write(self, s):
+            if isinstance(s, unicode):
+                s = s.encode('ascii')
+            super(NativeIO, self).write(s)
+
+
+class Verifier(object):
+
+    def __init__(self, ffi, preamble, tmpdir=None, modulename=None,
+                 ext_package=None, tag='', force_generic_engine=False,
+                 source_extension='.c', flags=None, relative_to=None, **kwds):
+        if ffi._parser._uses_new_feature:
+            raise VerificationError(
+                "feature not supported with ffi.verify(), but only "
+                "with ffi.set_source(): %s" % (ffi._parser._uses_new_feature,))
+        self.ffi = ffi
+        self.preamble = preamble
+        if not modulename:
+            flattened_kwds = ffiplatform.flatten(kwds)
+        vengine_class = _locate_engine_class(ffi, force_generic_engine)
+        self._vengine = vengine_class(self)
+        self._vengine.patch_extension_kwds(kwds)
+        self.flags = flags
+        self.kwds = self.make_relative_to(kwds, relative_to)
+        #
+        if modulename:
+            if tag:
+                raise TypeError("can't specify both 'modulename' and 'tag'")
+        else:
+            key = '\x00'.join(['%d.%d' % sys.version_info[:2],
+                               __version_verifier_modules__,
+                               preamble, flattened_kwds] +
+                              ffi._cdefsources)
+            if sys.version_info >= (3,):
+                key = key.encode('utf-8')
+            k1 = hex(binascii.crc32(key[0::2]) & 0xffffffff)
+            k1 = k1.lstrip('0x').rstrip('L')
+            k2 = hex(binascii.crc32(key[1::2]) & 0xffffffff)
+            k2 = k2.lstrip('0').rstrip('L')
+            modulename = '_cffi_%s_%s%s%s' % (tag, self._vengine._class_key,
+                                              k1, k2)
+        suffix = _get_so_suffixes()[0]
+        self.tmpdir = tmpdir or _caller_dir_pycache()
+        self.sourcefilename = os.path.join(self.tmpdir, modulename + source_extension)
+        self.modulefilename = os.path.join(self.tmpdir, modulename + suffix)
+        self.ext_package = ext_package
+        self._has_source = False
+        self._has_module = False
+
+    def write_source(self, file=None):
+        """Write the C source code.  It is produced in 'self.sourcefilename',
+        which can be tweaked beforehand."""
+        with self.ffi._lock:
+            if self._has_source and file is None:
+                raise VerificationError(
+                    "source code already written")
+            self._write_source(file)
+
+    def compile_module(self):
+        """Write the C source code (if not done already) and compile it.
+        This produces a dynamic link library in 'self.modulefilename'."""
+        with self.ffi._lock:
+            if self._has_module:
+                raise VerificationError("module already compiled")
+            if not self._has_source:
+                self._write_source()
+            self._compile_module()
+
+    def load_library(self):
+        """Get a C module from this Verifier instance.
+        Returns an instance of a FFILibrary class that behaves like the
+        objects returned by ffi.dlopen(), but that delegates all
+        operations to the C module.  If necessary, the C code is written
+        and compiled first.
+        """
+        with self.ffi._lock:
+            if not self._has_module:
+                self._locate_module()
+                if not self._has_module:
+                    if not self._has_source:
+                        self._write_source()
+                    self._compile_module()
+            return self._load_library()
+
+    def get_module_name(self):
+        basename = os.path.basename(self.modulefilename)
+        # kill both the .so extension and the other .'s, as introduced
+        # by Python 3: 'basename.cpython-33m.so'
+        basename = basename.split('.', 1)[0]
+        # and the _d added in Python 2 debug builds --- but try to be
+        # conservative and not kill a legitimate _d
+        if basename.endswith('_d') and hasattr(sys, 'gettotalrefcount'):
+            basename = basename[:-2]
+        return basename
+
+    def get_extension(self):
+        ffiplatform._hack_at_distutils() # backward compatibility hack
+        if not self._has_source:
+            with self.ffi._lock:
+                if not self._has_source:
+                    self._write_source()
+        sourcename = ffiplatform.maybe_relative_path(self.sourcefilename)
+        modname = self.get_module_name()
+        return ffiplatform.get_extension(sourcename, modname, **self.kwds)
+
+    def generates_python_module(self):
+        return self._vengine._gen_python_module
+
+    def make_relative_to(self, kwds, relative_to):
+        if relative_to and os.path.dirname(relative_to):
+            dirname = os.path.dirname(relative_to)
+            kwds = kwds.copy()
+            for key in ffiplatform.LIST_OF_FILE_NAMES:
+                if key in kwds:
+                    lst = kwds[key]
+                    if not isinstance(lst, (list, tuple)):
+                        raise TypeError("keyword '%s' should be a list or tuple"
+                                        % (key,))
+                    lst = [os.path.join(dirname, fn) for fn in lst]
+                    kwds[key] = lst
+        return kwds
+
+    # ----------
+
+    def _locate_module(self):
+        if not os.path.isfile(self.modulefilename):
+            if self.ext_package:
+                try:
+                    pkg = __import__(self.ext_package, None, None, ['__doc__'])
+                except ImportError:
+                    return      # cannot import the package itself, give up
+                    # (e.g. it might be called differently before installation)
+                path = pkg.__path__
+            else:
+                path = None
+            filename = self._vengine.find_module(self.get_module_name(), path,
+                                                 _get_so_suffixes())
+            if filename is None:
+                return
+            self.modulefilename = filename
+        self._vengine.collect_types()
+        self._has_module = True
+
+    def _write_source_to(self, file):
+        self._vengine._f = file
+        try:
+            self._vengine.write_source_to_f()
+        finally:
+            del self._vengine._f
+
+    def _write_source(self, file=None):
+        if file is not None:
+            self._write_source_to(file)
+        else:
+            # Write our source file to an in memory file.
+            f = NativeIO()
+            self._write_source_to(f)
+            source_data = f.getvalue()
+
+            # Determine if this matches the current file
+            if os.path.exists(self.sourcefilename):
+                with open(self.sourcefilename, "r") as fp:
+                    needs_written = not (fp.read() == source_data)
+            else:
+                needs_written = True
+
+            # Actually write the file out if it doesn't match
+            if needs_written:
+                _ensure_dir(self.sourcefilename)
+                with open(self.sourcefilename, "w") as fp:
+                    fp.write(source_data)
+
+            # Set this flag
+            self._has_source = True
+
+    def _compile_module(self):
+        # compile this C source
+        tmpdir = os.path.dirname(self.sourcefilename)
+        outputfilename = ffiplatform.compile(tmpdir, self.get_extension())
+        try:
+            same = ffiplatform.samefile(outputfilename, self.modulefilename)
+        except OSError:
+            same = False
+        if not same:
+            _ensure_dir(self.modulefilename)
+            shutil.move(outputfilename, self.modulefilename)
+        self._has_module = True
+
+    def _load_library(self):
+        assert self._has_module
+        if self.flags is not None:
+            return self._vengine.load_library(self.flags)
+        else:
+            return self._vengine.load_library()
+
+# ____________________________________________________________
+
+_FORCE_GENERIC_ENGINE = False      # for tests
+
+def _locate_engine_class(ffi, force_generic_engine):
+    if _FORCE_GENERIC_ENGINE:
+        force_generic_engine = True
+    if not force_generic_engine:
+        if '__pypy__' in sys.builtin_module_names:
+            force_generic_engine = True
+        else:
+            try:
+                import _cffi_backend
+            except ImportError:
+                _cffi_backend = '?'
+            if ffi._backend is not _cffi_backend:
+                force_generic_engine = True
+    if force_generic_engine:
+        from . import vengine_gen
+        return vengine_gen.VGenericEngine
+    else:
+        from . import vengine_cpy
+        return vengine_cpy.VCPythonEngine
+
+# ____________________________________________________________
+
+_TMPDIR = None
+
+def _caller_dir_pycache():
+    if _TMPDIR:
+        return _TMPDIR
+    result = os.environ.get('CFFI_TMPDIR')
+    if result:
+        return result
+    filename = sys._getframe(2).f_code.co_filename
+    return os.path.abspath(os.path.join(os.path.dirname(filename),
+                           '__pycache__'))
+
+def set_tmpdir(dirname):
+    """Set the temporary directory to use instead of __pycache__."""
+    global _TMPDIR
+    _TMPDIR = dirname
+
+def cleanup_tmpdir(tmpdir=None, keep_so=False):
+    """Clean up the temporary directory by removing all files in it
+    called `_cffi_*.{c,so}` as well as the `build` subdirectory."""
+    tmpdir = tmpdir or _caller_dir_pycache()
+    try:
+        filelist = os.listdir(tmpdir)
+    except OSError:
+        return
+    if keep_so:
+        suffix = '.c'   # only remove .c files
+    else:
+        suffix = _get_so_suffixes()[0].lower()
+    for fn in filelist:
+        if fn.lower().startswith('_cffi_') and (
+                fn.lower().endswith(suffix) or fn.lower().endswith('.c')):
+            try:
+                os.unlink(os.path.join(tmpdir, fn))
+            except OSError:
+                pass
+    clean_dir = [os.path.join(tmpdir, 'build')]
+    for dir in clean_dir:
+        try:
+            for fn in os.listdir(dir):
+                fn = os.path.join(dir, fn)
+                if os.path.isdir(fn):
+                    clean_dir.append(fn)
+                else:
+                    os.unlink(fn)
+        except OSError:
+            pass
+
+def _get_so_suffixes():
+    suffixes = _extension_suffixes()
+    if not suffixes:
+        # bah, no C_EXTENSION available.  Occurs on pypy without cpyext
+        if sys.platform == 'win32':
+            suffixes = [".pyd"]
+        else:
+            suffixes = [".so"]
+
+    return suffixes
+
+def _ensure_dir(filename):
+    dirname = os.path.dirname(filename)
+    if dirname and not os.path.isdir(dirname):
+        os.makedirs(dirname)
diff --git a/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/LICENSE.rst b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/LICENSE.rst
new file mode 100644
index 0000000..d12a849
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/LICENSE.rst
@@ -0,0 +1,28 @@
+Copyright 2014 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/METADATA b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/METADATA
new file mode 100644
index 0000000..8e5dc1e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/METADATA
@@ -0,0 +1,111 @@
+Metadata-Version: 2.1
+Name: click
+Version: 8.1.3
+Summary: Composable command line interface toolkit
+Home-page: https://palletsprojects.com/p/click/
+Author: Armin Ronacher
+Author-email: armin.ronacher@active-4.com
+Maintainer: Pallets
+Maintainer-email: contact@palletsprojects.com
+License: BSD-3-Clause
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://click.palletsprojects.com/
+Project-URL: Changes, https://click.palletsprojects.com/changes/
+Project-URL: Source Code, https://github.com/pallets/click/
+Project-URL: Issue Tracker, https://github.com/pallets/click/issues/
+Project-URL: Twitter, https://twitter.com/PalletsTeam
+Project-URL: Chat, https://discord.gg/pallets
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+Requires-Dist: colorama ; platform_system == "Windows"
+Requires-Dist: importlib-metadata ; python_version < "3.8"
+
+\$ click\_
+==========
+
+Click is a Python package for creating beautiful command line interfaces
+in a composable way with as little code as necessary. It's the "Command
+Line Interface Creation Kit". It's highly configurable but comes with
+sensible defaults out of the box.
+
+It aims to make the process of writing command line tools quick and fun
+while also preventing any frustration caused by the inability to
+implement an intended CLI API.
+
+Click in three points:
+
+-   Arbitrary nesting of commands
+-   Automatic help page generation
+-   Supports lazy loading of subcommands at runtime
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    $ pip install -U click
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+A Simple Example
+----------------
+
+.. code-block:: python
+
+    import click
+
+    @click.command()
+    @click.option("--count", default=1, help="Number of greetings.")
+    @click.option("--name", prompt="Your name", help="The person to greet.")
+    def hello(count, name):
+        """Simple program that greets NAME for a total of COUNT times."""
+        for _ in range(count):
+            click.echo(f"Hello, {name}!")
+
+    if __name__ == '__main__':
+        hello()
+
+.. code-block:: text
+
+    $ python hello.py --count=3
+    Your name: Click
+    Hello, Click!
+    Hello, Click!
+    Hello, Click!
+
+
+Donate
+------
+
+The Pallets organization develops and supports Click and other popular
+packages. In order to grow the community of contributors and users, and
+allow the maintainers to devote more time to the projects, `please
+donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+-   Documentation: https://click.palletsprojects.com/
+-   Changes: https://click.palletsprojects.com/changes/
+-   PyPI Releases: https://pypi.org/project/click/
+-   Source Code: https://github.com/pallets/click
+-   Issue Tracker: https://github.com/pallets/click/issues
+-   Website: https://palletsprojects.com/p/click
+-   Twitter: https://twitter.com/PalletsTeam
+-   Chat: https://discord.gg/pallets
+
+
diff --git a/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/RECORD b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/RECORD
new file mode 100644
index 0000000..14981e3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/RECORD
@@ -0,0 +1,23 @@
+click/__init__.py,sha256=rQBLutqg-z6m8nOzivIfigDn_emijB_dKv9BZ2FNi5s,3138
+click/_compat.py,sha256=JIHLYs7Jzz4KT9t-ds4o4jBzLjnwCiJQKqur-5iwCKI,18810
+click/_termui_impl.py,sha256=qK6Cfy4mRFxvxE8dya8RBhLpSC8HjF-lvBc6aNrPdwg,23451
+click/_textwrap.py,sha256=10fQ64OcBUMuK7mFvh8363_uoOxPlRItZBmKzRJDgoY,1353
+click/_winconsole.py,sha256=5ju3jQkcZD0W27WEMGqmEP4y_crUVzPCqsX_FYb7BO0,7860
+click/core.py,sha256=mz87bYEKzIoNYEa56BFAiOJnvt1Y0L-i7wD4_ZecieE,112782
+click/decorators.py,sha256=yo3zvzgUm5q7h5CXjyV6q3h_PJAiUaem178zXwdWUFI,16350
+click/exceptions.py,sha256=7gDaLGuFZBeCNwY9ERMsF2-Z3R9Fvq09Zc6IZSKjseo,9167
+click/formatting.py,sha256=Frf0-5W33-loyY_i9qrwXR8-STnW3m5gvyxLVUdyxyk,9706
+click/globals.py,sha256=TP-qM88STzc7f127h35TD_v920FgfOD2EwzqA0oE8XU,1961
+click/parser.py,sha256=cAEt1uQR8gq3-S9ysqbVU-fdAZNvilxw4ReJ_T1OQMk,19044
+click/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+click/shell_completion.py,sha256=qOp_BeC9esEOSZKyu5G7RIxEUaLsXUX-mTb7hB1r4QY,18018
+click/termui.py,sha256=ACBQVOvFCTSqtD5VREeCAdRtlHd-Imla-Lte4wSfMjA,28355
+click/testing.py,sha256=ptpMYgRY7dVfE3UDgkgwayu9ePw98sQI3D7zZXiCpj4,16063
+click/types.py,sha256=rEb1aZSQKq3ciCMmjpG2Uva9vk498XRL7ThrcK2GRss,35805
+click/utils.py,sha256=33D6E7poH_nrKB-xr-UyDEXnxOcCiQqxuRLtrqeVv6o,18682
+click-8.1.3.dist-info/LICENSE.rst,sha256=morRBqOU6FO_4h9C9OctWSgZoigF2ZG18ydQKSkrZY0,1475
+click-8.1.3.dist-info/METADATA,sha256=tFJIX5lOjx7c5LjZbdTPFVDJSgyv9F74XY0XCPp_gnc,3247
+click-8.1.3.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+click-8.1.3.dist-info/top_level.txt,sha256=J1ZQogalYS4pphY_lPECoNMfw0HzTSrZglC4Yfwo4xA,6
+click-8.1.3.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+click-8.1.3.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/WHEEL
new file mode 100644
index 0000000..becc9a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/top_level.txt
new file mode 100644
index 0000000..dca9a90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click-8.1.3.dist-info/top_level.txt
@@ -0,0 +1 @@
+click
diff --git a/myenv/lib/python3.9/site-packages/click/__init__.py b/myenv/lib/python3.9/site-packages/click/__init__.py
new file mode 100644
index 0000000..e3ef423
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/__init__.py
@@ -0,0 +1,73 @@
+"""
+Click is a simple Python module inspired by the stdlib optparse to make
+writing command line scripts fun. Unlike other modules, it's based
+around a simple API that does not come with too much magic and is
+composable.
+"""
+from .core import Argument as Argument
+from .core import BaseCommand as BaseCommand
+from .core import Command as Command
+from .core import CommandCollection as CommandCollection
+from .core import Context as Context
+from .core import Group as Group
+from .core import MultiCommand as MultiCommand
+from .core import Option as Option
+from .core import Parameter as Parameter
+from .decorators import argument as argument
+from .decorators import command as command
+from .decorators import confirmation_option as confirmation_option
+from .decorators import group as group
+from .decorators import help_option as help_option
+from .decorators import make_pass_decorator as make_pass_decorator
+from .decorators import option as option
+from .decorators import pass_context as pass_context
+from .decorators import pass_obj as pass_obj
+from .decorators import password_option as password_option
+from .decorators import version_option as version_option
+from .exceptions import Abort as Abort
+from .exceptions import BadArgumentUsage as BadArgumentUsage
+from .exceptions import BadOptionUsage as BadOptionUsage
+from .exceptions import BadParameter as BadParameter
+from .exceptions import ClickException as ClickException
+from .exceptions import FileError as FileError
+from .exceptions import MissingParameter as MissingParameter
+from .exceptions import NoSuchOption as NoSuchOption
+from .exceptions import UsageError as UsageError
+from .formatting import HelpFormatter as HelpFormatter
+from .formatting import wrap_text as wrap_text
+from .globals import get_current_context as get_current_context
+from .parser import OptionParser as OptionParser
+from .termui import clear as clear
+from .termui import confirm as confirm
+from .termui import echo_via_pager as echo_via_pager
+from .termui import edit as edit
+from .termui import getchar as getchar
+from .termui import launch as launch
+from .termui import pause as pause
+from .termui import progressbar as progressbar
+from .termui import prompt as prompt
+from .termui import secho as secho
+from .termui import style as style
+from .termui import unstyle as unstyle
+from .types import BOOL as BOOL
+from .types import Choice as Choice
+from .types import DateTime as DateTime
+from .types import File as File
+from .types import FLOAT as FLOAT
+from .types import FloatRange as FloatRange
+from .types import INT as INT
+from .types import IntRange as IntRange
+from .types import ParamType as ParamType
+from .types import Path as Path
+from .types import STRING as STRING
+from .types import Tuple as Tuple
+from .types import UNPROCESSED as UNPROCESSED
+from .types import UUID as UUID
+from .utils import echo as echo
+from .utils import format_filename as format_filename
+from .utils import get_app_dir as get_app_dir
+from .utils import get_binary_stream as get_binary_stream
+from .utils import get_text_stream as get_text_stream
+from .utils import open_file as open_file
+
+__version__ = "8.1.3"
diff --git a/myenv/lib/python3.9/site-packages/click/_compat.py b/myenv/lib/python3.9/site-packages/click/_compat.py
new file mode 100644
index 0000000..766d286
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/_compat.py
@@ -0,0 +1,626 @@
+import codecs
+import io
+import os
+import re
+import sys
+import typing as t
+from weakref import WeakKeyDictionary
+
+CYGWIN = sys.platform.startswith("cygwin")
+MSYS2 = sys.platform.startswith("win") and ("GCC" in sys.version)
+# Determine local App Engine environment, per Google's own suggestion
+APP_ENGINE = "APPENGINE_RUNTIME" in os.environ and "Development/" in os.environ.get(
+    "SERVER_SOFTWARE", ""
+)
+WIN = sys.platform.startswith("win") and not APP_ENGINE and not MSYS2
+auto_wrap_for_ansi: t.Optional[t.Callable[[t.TextIO], t.TextIO]] = None
+_ansi_re = re.compile(r"\033\[[;?0-9]*[a-zA-Z]")
+
+
+def get_filesystem_encoding() -> str:
+    return sys.getfilesystemencoding() or sys.getdefaultencoding()
+
+
+def _make_text_stream(
+    stream: t.BinaryIO,
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+    force_readable: bool = False,
+    force_writable: bool = False,
+) -> t.TextIO:
+    if encoding is None:
+        encoding = get_best_encoding(stream)
+    if errors is None:
+        errors = "replace"
+    return _NonClosingTextIOWrapper(
+        stream,
+        encoding,
+        errors,
+        line_buffering=True,
+        force_readable=force_readable,
+        force_writable=force_writable,
+    )
+
+
+def is_ascii_encoding(encoding: str) -> bool:
+    """Checks if a given encoding is ascii."""
+    try:
+        return codecs.lookup(encoding).name == "ascii"
+    except LookupError:
+        return False
+
+
+def get_best_encoding(stream: t.IO) -> str:
+    """Returns the default stream encoding if not found."""
+    rv = getattr(stream, "encoding", None) or sys.getdefaultencoding()
+    if is_ascii_encoding(rv):
+        return "utf-8"
+    return rv
+
+
+class _NonClosingTextIOWrapper(io.TextIOWrapper):
+    def __init__(
+        self,
+        stream: t.BinaryIO,
+        encoding: t.Optional[str],
+        errors: t.Optional[str],
+        force_readable: bool = False,
+        force_writable: bool = False,
+        **extra: t.Any,
+    ) -> None:
+        self._stream = stream = t.cast(
+            t.BinaryIO, _FixupStream(stream, force_readable, force_writable)
+        )
+        super().__init__(stream, encoding, errors, **extra)
+
+    def __del__(self) -> None:
+        try:
+            self.detach()
+        except Exception:
+            pass
+
+    def isatty(self) -> bool:
+        # https://bitbucket.org/pypy/pypy/issue/1803
+        return self._stream.isatty()
+
+
+class _FixupStream:
+    """The new io interface needs more from streams than streams
+    traditionally implement.  As such, this fix-up code is necessary in
+    some circumstances.
+
+    The forcing of readable and writable flags are there because some tools
+    put badly patched objects on sys (one such offender are certain version
+    of jupyter notebook).
+    """
+
+    def __init__(
+        self,
+        stream: t.BinaryIO,
+        force_readable: bool = False,
+        force_writable: bool = False,
+    ):
+        self._stream = stream
+        self._force_readable = force_readable
+        self._force_writable = force_writable
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._stream, name)
+
+    def read1(self, size: int) -> bytes:
+        f = getattr(self._stream, "read1", None)
+
+        if f is not None:
+            return t.cast(bytes, f(size))
+
+        return self._stream.read(size)
+
+    def readable(self) -> bool:
+        if self._force_readable:
+            return True
+        x = getattr(self._stream, "readable", None)
+        if x is not None:
+            return t.cast(bool, x())
+        try:
+            self._stream.read(0)
+        except Exception:
+            return False
+        return True
+
+    def writable(self) -> bool:
+        if self._force_writable:
+            return True
+        x = getattr(self._stream, "writable", None)
+        if x is not None:
+            return t.cast(bool, x())
+        try:
+            self._stream.write("")  # type: ignore
+        except Exception:
+            try:
+                self._stream.write(b"")
+            except Exception:
+                return False
+        return True
+
+    def seekable(self) -> bool:
+        x = getattr(self._stream, "seekable", None)
+        if x is not None:
+            return t.cast(bool, x())
+        try:
+            self._stream.seek(self._stream.tell())
+        except Exception:
+            return False
+        return True
+
+
+def _is_binary_reader(stream: t.IO, default: bool = False) -> bool:
+    try:
+        return isinstance(stream.read(0), bytes)
+    except Exception:
+        return default
+        # This happens in some cases where the stream was already
+        # closed.  In this case, we assume the default.
+
+
+def _is_binary_writer(stream: t.IO, default: bool = False) -> bool:
+    try:
+        stream.write(b"")
+    except Exception:
+        try:
+            stream.write("")
+            return False
+        except Exception:
+            pass
+        return default
+    return True
+
+
+def _find_binary_reader(stream: t.IO) -> t.Optional[t.BinaryIO]:
+    # We need to figure out if the given stream is already binary.
+    # This can happen because the official docs recommend detaching
+    # the streams to get binary streams.  Some code might do this, so
+    # we need to deal with this case explicitly.
+    if _is_binary_reader(stream, False):
+        return t.cast(t.BinaryIO, stream)
+
+    buf = getattr(stream, "buffer", None)
+
+    # Same situation here; this time we assume that the buffer is
+    # actually binary in case it's closed.
+    if buf is not None and _is_binary_reader(buf, True):
+        return t.cast(t.BinaryIO, buf)
+
+    return None
+
+
+def _find_binary_writer(stream: t.IO) -> t.Optional[t.BinaryIO]:
+    # We need to figure out if the given stream is already binary.
+    # This can happen because the official docs recommend detaching
+    # the streams to get binary streams.  Some code might do this, so
+    # we need to deal with this case explicitly.
+    if _is_binary_writer(stream, False):
+        return t.cast(t.BinaryIO, stream)
+
+    buf = getattr(stream, "buffer", None)
+
+    # Same situation here; this time we assume that the buffer is
+    # actually binary in case it's closed.
+    if buf is not None and _is_binary_writer(buf, True):
+        return t.cast(t.BinaryIO, buf)
+
+    return None
+
+
+def _stream_is_misconfigured(stream: t.TextIO) -> bool:
+    """A stream is misconfigured if its encoding is ASCII."""
+    # If the stream does not have an encoding set, we assume it's set
+    # to ASCII.  This appears to happen in certain unittest
+    # environments.  It's not quite clear what the correct behavior is
+    # but this at least will force Click to recover somehow.
+    return is_ascii_encoding(getattr(stream, "encoding", None) or "ascii")
+
+
+def _is_compat_stream_attr(stream: t.TextIO, attr: str, value: t.Optional[str]) -> bool:
+    """A stream attribute is compatible if it is equal to the
+    desired value or the desired value is unset and the attribute
+    has a value.
+    """
+    stream_value = getattr(stream, attr, None)
+    return stream_value == value or (value is None and stream_value is not None)
+
+
+def _is_compatible_text_stream(
+    stream: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str]
+) -> bool:
+    """Check if a stream's encoding and errors attributes are
+    compatible with the desired values.
+    """
+    return _is_compat_stream_attr(
+        stream, "encoding", encoding
+    ) and _is_compat_stream_attr(stream, "errors", errors)
+
+
+def _force_correct_text_stream(
+    text_stream: t.IO,
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+    is_binary: t.Callable[[t.IO, bool], bool],
+    find_binary: t.Callable[[t.IO], t.Optional[t.BinaryIO]],
+    force_readable: bool = False,
+    force_writable: bool = False,
+) -> t.TextIO:
+    if is_binary(text_stream, False):
+        binary_reader = t.cast(t.BinaryIO, text_stream)
+    else:
+        text_stream = t.cast(t.TextIO, text_stream)
+        # If the stream looks compatible, and won't default to a
+        # misconfigured ascii encoding, return it as-is.
+        if _is_compatible_text_stream(text_stream, encoding, errors) and not (
+            encoding is None and _stream_is_misconfigured(text_stream)
+        ):
+            return text_stream
+
+        # Otherwise, get the underlying binary reader.
+        possible_binary_reader = find_binary(text_stream)
+
+        # If that's not possible, silently use the original reader
+        # and get mojibake instead of exceptions.
+        if possible_binary_reader is None:
+            return text_stream
+
+        binary_reader = possible_binary_reader
+
+    # Default errors to replace instead of strict in order to get
+    # something that works.
+    if errors is None:
+        errors = "replace"
+
+    # Wrap the binary stream in a text stream with the correct
+    # encoding parameters.
+    return _make_text_stream(
+        binary_reader,
+        encoding,
+        errors,
+        force_readable=force_readable,
+        force_writable=force_writable,
+    )
+
+
+def _force_correct_text_reader(
+    text_reader: t.IO,
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+    force_readable: bool = False,
+) -> t.TextIO:
+    return _force_correct_text_stream(
+        text_reader,
+        encoding,
+        errors,
+        _is_binary_reader,
+        _find_binary_reader,
+        force_readable=force_readable,
+    )
+
+
+def _force_correct_text_writer(
+    text_writer: t.IO,
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+    force_writable: bool = False,
+) -> t.TextIO:
+    return _force_correct_text_stream(
+        text_writer,
+        encoding,
+        errors,
+        _is_binary_writer,
+        _find_binary_writer,
+        force_writable=force_writable,
+    )
+
+
+def get_binary_stdin() -> t.BinaryIO:
+    reader = _find_binary_reader(sys.stdin)
+    if reader is None:
+        raise RuntimeError("Was not able to determine binary stream for sys.stdin.")
+    return reader
+
+
+def get_binary_stdout() -> t.BinaryIO:
+    writer = _find_binary_writer(sys.stdout)
+    if writer is None:
+        raise RuntimeError("Was not able to determine binary stream for sys.stdout.")
+    return writer
+
+
+def get_binary_stderr() -> t.BinaryIO:
+    writer = _find_binary_writer(sys.stderr)
+    if writer is None:
+        raise RuntimeError("Was not able to determine binary stream for sys.stderr.")
+    return writer
+
+
+def get_text_stdin(
+    encoding: t.Optional[str] = None, errors: t.Optional[str] = None
+) -> t.TextIO:
+    rv = _get_windows_console_stream(sys.stdin, encoding, errors)
+    if rv is not None:
+        return rv
+    return _force_correct_text_reader(sys.stdin, encoding, errors, force_readable=True)
+
+
+def get_text_stdout(
+    encoding: t.Optional[str] = None, errors: t.Optional[str] = None
+) -> t.TextIO:
+    rv = _get_windows_console_stream(sys.stdout, encoding, errors)
+    if rv is not None:
+        return rv
+    return _force_correct_text_writer(sys.stdout, encoding, errors, force_writable=True)
+
+
+def get_text_stderr(
+    encoding: t.Optional[str] = None, errors: t.Optional[str] = None
+) -> t.TextIO:
+    rv = _get_windows_console_stream(sys.stderr, encoding, errors)
+    if rv is not None:
+        return rv
+    return _force_correct_text_writer(sys.stderr, encoding, errors, force_writable=True)
+
+
+def _wrap_io_open(
+    file: t.Union[str, os.PathLike, int],
+    mode: str,
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+) -> t.IO:
+    """Handles not passing ``encoding`` and ``errors`` in binary mode."""
+    if "b" in mode:
+        return open(file, mode)
+
+    return open(file, mode, encoding=encoding, errors=errors)
+
+
+def open_stream(
+    filename: str,
+    mode: str = "r",
+    encoding: t.Optional[str] = None,
+    errors: t.Optional[str] = "strict",
+    atomic: bool = False,
+) -> t.Tuple[t.IO, bool]:
+    binary = "b" in mode
+
+    # Standard streams first. These are simple because they ignore the
+    # atomic flag. Use fsdecode to handle Path("-").
+    if os.fsdecode(filename) == "-":
+        if any(m in mode for m in ["w", "a", "x"]):
+            if binary:
+                return get_binary_stdout(), False
+            return get_text_stdout(encoding=encoding, errors=errors), False
+        if binary:
+            return get_binary_stdin(), False
+        return get_text_stdin(encoding=encoding, errors=errors), False
+
+    # Non-atomic writes directly go out through the regular open functions.
+    if not atomic:
+        return _wrap_io_open(filename, mode, encoding, errors), True
+
+    # Some usability stuff for atomic writes
+    if "a" in mode:
+        raise ValueError(
+            "Appending to an existing file is not supported, because that"
+            " would involve an expensive `copy`-operation to a temporary"
+            " file. Open the file in normal `w`-mode and copy explicitly"
+            " if that's what you're after."
+        )
+    if "x" in mode:
+        raise ValueError("Use the `overwrite`-parameter instead.")
+    if "w" not in mode:
+        raise ValueError("Atomic writes only make sense with `w`-mode.")
+
+    # Atomic writes are more complicated.  They work by opening a file
+    # as a proxy in the same folder and then using the fdopen
+    # functionality to wrap it in a Python file.  Then we wrap it in an
+    # atomic file that moves the file over on close.
+    import errno
+    import random
+
+    try:
+        perm: t.Optional[int] = os.stat(filename).st_mode
+    except OSError:
+        perm = None
+
+    flags = os.O_RDWR | os.O_CREAT | os.O_EXCL
+
+    if binary:
+        flags |= getattr(os, "O_BINARY", 0)
+
+    while True:
+        tmp_filename = os.path.join(
+            os.path.dirname(filename),
+            f".__atomic-write{random.randrange(1 << 32):08x}",
+        )
+        try:
+            fd = os.open(tmp_filename, flags, 0o666 if perm is None else perm)
+            break
+        except OSError as e:
+            if e.errno == errno.EEXIST or (
+                os.name == "nt"
+                and e.errno == errno.EACCES
+                and os.path.isdir(e.filename)
+                and os.access(e.filename, os.W_OK)
+            ):
+                continue
+            raise
+
+    if perm is not None:
+        os.chmod(tmp_filename, perm)  # in case perm includes bits in umask
+
+    f = _wrap_io_open(fd, mode, encoding, errors)
+    af = _AtomicFile(f, tmp_filename, os.path.realpath(filename))
+    return t.cast(t.IO, af), True
+
+
+class _AtomicFile:
+    def __init__(self, f: t.IO, tmp_filename: str, real_filename: str) -> None:
+        self._f = f
+        self._tmp_filename = tmp_filename
+        self._real_filename = real_filename
+        self.closed = False
+
+    @property
+    def name(self) -> str:
+        return self._real_filename
+
+    def close(self, delete: bool = False) -> None:
+        if self.closed:
+            return
+        self._f.close()
+        os.replace(self._tmp_filename, self._real_filename)
+        self.closed = True
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._f, name)
+
+    def __enter__(self) -> "_AtomicFile":
+        return self
+
+    def __exit__(self, exc_type, exc_value, tb):  # type: ignore
+        self.close(delete=exc_type is not None)
+
+    def __repr__(self) -> str:
+        return repr(self._f)
+
+
+def strip_ansi(value: str) -> str:
+    return _ansi_re.sub("", value)
+
+
+def _is_jupyter_kernel_output(stream: t.IO) -> bool:
+    while isinstance(stream, (_FixupStream, _NonClosingTextIOWrapper)):
+        stream = stream._stream
+
+    return stream.__class__.__module__.startswith("ipykernel.")
+
+
+def should_strip_ansi(
+    stream: t.Optional[t.IO] = None, color: t.Optional[bool] = None
+) -> bool:
+    if color is None:
+        if stream is None:
+            stream = sys.stdin
+        return not isatty(stream) and not _is_jupyter_kernel_output(stream)
+    return not color
+
+
+# On Windows, wrap the output streams with colorama to support ANSI
+# color codes.
+# NOTE: double check is needed so mypy does not analyze this on Linux
+if sys.platform.startswith("win") and WIN:
+    from ._winconsole import _get_windows_console_stream
+
+    def _get_argv_encoding() -> str:
+        import locale
+
+        return locale.getpreferredencoding()
+
+    _ansi_stream_wrappers: t.MutableMapping[t.TextIO, t.TextIO] = WeakKeyDictionary()
+
+    def auto_wrap_for_ansi(
+        stream: t.TextIO, color: t.Optional[bool] = None
+    ) -> t.TextIO:
+        """Support ANSI color and style codes on Windows by wrapping a
+        stream with colorama.
+        """
+        try:
+            cached = _ansi_stream_wrappers.get(stream)
+        except Exception:
+            cached = None
+
+        if cached is not None:
+            return cached
+
+        import colorama
+
+        strip = should_strip_ansi(stream, color)
+        ansi_wrapper = colorama.AnsiToWin32(stream, strip=strip)
+        rv = t.cast(t.TextIO, ansi_wrapper.stream)
+        _write = rv.write
+
+        def _safe_write(s):
+            try:
+                return _write(s)
+            except BaseException:
+                ansi_wrapper.reset_all()
+                raise
+
+        rv.write = _safe_write
+
+        try:
+            _ansi_stream_wrappers[stream] = rv
+        except Exception:
+            pass
+
+        return rv
+
+else:
+
+    def _get_argv_encoding() -> str:
+        return getattr(sys.stdin, "encoding", None) or get_filesystem_encoding()
+
+    def _get_windows_console_stream(
+        f: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str]
+    ) -> t.Optional[t.TextIO]:
+        return None
+
+
+def term_len(x: str) -> int:
+    return len(strip_ansi(x))
+
+
+def isatty(stream: t.IO) -> bool:
+    try:
+        return stream.isatty()
+    except Exception:
+        return False
+
+
+def _make_cached_stream_func(
+    src_func: t.Callable[[], t.TextIO], wrapper_func: t.Callable[[], t.TextIO]
+) -> t.Callable[[], t.TextIO]:
+    cache: t.MutableMapping[t.TextIO, t.TextIO] = WeakKeyDictionary()
+
+    def func() -> t.TextIO:
+        stream = src_func()
+        try:
+            rv = cache.get(stream)
+        except Exception:
+            rv = None
+        if rv is not None:
+            return rv
+        rv = wrapper_func()
+        try:
+            cache[stream] = rv
+        except Exception:
+            pass
+        return rv
+
+    return func
+
+
+_default_text_stdin = _make_cached_stream_func(lambda: sys.stdin, get_text_stdin)
+_default_text_stdout = _make_cached_stream_func(lambda: sys.stdout, get_text_stdout)
+_default_text_stderr = _make_cached_stream_func(lambda: sys.stderr, get_text_stderr)
+
+
+binary_streams: t.Mapping[str, t.Callable[[], t.BinaryIO]] = {
+    "stdin": get_binary_stdin,
+    "stdout": get_binary_stdout,
+    "stderr": get_binary_stderr,
+}
+
+text_streams: t.Mapping[
+    str, t.Callable[[t.Optional[str], t.Optional[str]], t.TextIO]
+] = {
+    "stdin": get_text_stdin,
+    "stdout": get_text_stdout,
+    "stderr": get_text_stderr,
+}
diff --git a/myenv/lib/python3.9/site-packages/click/_termui_impl.py b/myenv/lib/python3.9/site-packages/click/_termui_impl.py
new file mode 100644
index 0000000..4b979bc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/_termui_impl.py
@@ -0,0 +1,717 @@
+"""
+This module contains implementations for the termui module. To keep the
+import time of Click down, some infrequently used functionality is
+placed in this module and only imported as needed.
+"""
+import contextlib
+import math
+import os
+import sys
+import time
+import typing as t
+from gettext import gettext as _
+
+from ._compat import _default_text_stdout
+from ._compat import CYGWIN
+from ._compat import get_best_encoding
+from ._compat import isatty
+from ._compat import open_stream
+from ._compat import strip_ansi
+from ._compat import term_len
+from ._compat import WIN
+from .exceptions import ClickException
+from .utils import echo
+
+V = t.TypeVar("V")
+
+if os.name == "nt":
+    BEFORE_BAR = "\r"
+    AFTER_BAR = "\n"
+else:
+    BEFORE_BAR = "\r\033[?25l"
+    AFTER_BAR = "\033[?25h\n"
+
+
+class ProgressBar(t.Generic[V]):
+    def __init__(
+        self,
+        iterable: t.Optional[t.Iterable[V]],
+        length: t.Optional[int] = None,
+        fill_char: str = "#",
+        empty_char: str = " ",
+        bar_template: str = "%(bar)s",
+        info_sep: str = "  ",
+        show_eta: bool = True,
+        show_percent: t.Optional[bool] = None,
+        show_pos: bool = False,
+        item_show_func: t.Optional[t.Callable[[t.Optional[V]], t.Optional[str]]] = None,
+        label: t.Optional[str] = None,
+        file: t.Optional[t.TextIO] = None,
+        color: t.Optional[bool] = None,
+        update_min_steps: int = 1,
+        width: int = 30,
+    ) -> None:
+        self.fill_char = fill_char
+        self.empty_char = empty_char
+        self.bar_template = bar_template
+        self.info_sep = info_sep
+        self.show_eta = show_eta
+        self.show_percent = show_percent
+        self.show_pos = show_pos
+        self.item_show_func = item_show_func
+        self.label = label or ""
+        if file is None:
+            file = _default_text_stdout()
+        self.file = file
+        self.color = color
+        self.update_min_steps = update_min_steps
+        self._completed_intervals = 0
+        self.width = width
+        self.autowidth = width == 0
+
+        if length is None:
+            from operator import length_hint
+
+            length = length_hint(iterable, -1)
+
+            if length == -1:
+                length = None
+        if iterable is None:
+            if length is None:
+                raise TypeError("iterable or length is required")
+            iterable = t.cast(t.Iterable[V], range(length))
+        self.iter = iter(iterable)
+        self.length = length
+        self.pos = 0
+        self.avg: t.List[float] = []
+        self.start = self.last_eta = time.time()
+        self.eta_known = False
+        self.finished = False
+        self.max_width: t.Optional[int] = None
+        self.entered = False
+        self.current_item: t.Optional[V] = None
+        self.is_hidden = not isatty(self.file)
+        self._last_line: t.Optional[str] = None
+
+    def __enter__(self) -> "ProgressBar":
+        self.entered = True
+        self.render_progress()
+        return self
+
+    def __exit__(self, exc_type, exc_value, tb):  # type: ignore
+        self.render_finish()
+
+    def __iter__(self) -> t.Iterator[V]:
+        if not self.entered:
+            raise RuntimeError("You need to use progress bars in a with block.")
+        self.render_progress()
+        return self.generator()
+
+    def __next__(self) -> V:
+        # Iteration is defined in terms of a generator function,
+        # returned by iter(self); use that to define next(). This works
+        # because `self.iter` is an iterable consumed by that generator,
+        # so it is re-entry safe. Calling `next(self.generator())`
+        # twice works and does "what you want".
+        return next(iter(self))
+
+    def render_finish(self) -> None:
+        if self.is_hidden:
+            return
+        self.file.write(AFTER_BAR)
+        self.file.flush()
+
+    @property
+    def pct(self) -> float:
+        if self.finished:
+            return 1.0
+        return min(self.pos / (float(self.length or 1) or 1), 1.0)
+
+    @property
+    def time_per_iteration(self) -> float:
+        if not self.avg:
+            return 0.0
+        return sum(self.avg) / float(len(self.avg))
+
+    @property
+    def eta(self) -> float:
+        if self.length is not None and not self.finished:
+            return self.time_per_iteration * (self.length - self.pos)
+        return 0.0
+
+    def format_eta(self) -> str:
+        if self.eta_known:
+            t = int(self.eta)
+            seconds = t % 60
+            t //= 60
+            minutes = t % 60
+            t //= 60
+            hours = t % 24
+            t //= 24
+            if t > 0:
+                return f"{t}d {hours:02}:{minutes:02}:{seconds:02}"
+            else:
+                return f"{hours:02}:{minutes:02}:{seconds:02}"
+        return ""
+
+    def format_pos(self) -> str:
+        pos = str(self.pos)
+        if self.length is not None:
+            pos += f"/{self.length}"
+        return pos
+
+    def format_pct(self) -> str:
+        return f"{int(self.pct * 100): 4}%"[1:]
+
+    def format_bar(self) -> str:
+        if self.length is not None:
+            bar_length = int(self.pct * self.width)
+            bar = self.fill_char * bar_length
+            bar += self.empty_char * (self.width - bar_length)
+        elif self.finished:
+            bar = self.fill_char * self.width
+        else:
+            chars = list(self.empty_char * (self.width or 1))
+            if self.time_per_iteration != 0:
+                chars[
+                    int(
+                        (math.cos(self.pos * self.time_per_iteration) / 2.0 + 0.5)
+                        * self.width
+                    )
+                ] = self.fill_char
+            bar = "".join(chars)
+        return bar
+
+    def format_progress_line(self) -> str:
+        show_percent = self.show_percent
+
+        info_bits = []
+        if self.length is not None and show_percent is None:
+            show_percent = not self.show_pos
+
+        if self.show_pos:
+            info_bits.append(self.format_pos())
+        if show_percent:
+            info_bits.append(self.format_pct())
+        if self.show_eta and self.eta_known and not self.finished:
+            info_bits.append(self.format_eta())
+        if self.item_show_func is not None:
+            item_info = self.item_show_func(self.current_item)
+            if item_info is not None:
+                info_bits.append(item_info)
+
+        return (
+            self.bar_template
+            % {
+                "label": self.label,
+                "bar": self.format_bar(),
+                "info": self.info_sep.join(info_bits),
+            }
+        ).rstrip()
+
+    def render_progress(self) -> None:
+        import shutil
+
+        if self.is_hidden:
+            # Only output the label as it changes if the output is not a
+            # TTY. Use file=stderr if you expect to be piping stdout.
+            if self._last_line != self.label:
+                self._last_line = self.label
+                echo(self.label, file=self.file, color=self.color)
+
+            return
+
+        buf = []
+        # Update width in case the terminal has been resized
+        if self.autowidth:
+            old_width = self.width
+            self.width = 0
+            clutter_length = term_len(self.format_progress_line())
+            new_width = max(0, shutil.get_terminal_size().columns - clutter_length)
+            if new_width < old_width:
+                buf.append(BEFORE_BAR)
+                buf.append(" " * self.max_width)  # type: ignore
+                self.max_width = new_width
+            self.width = new_width
+
+        clear_width = self.width
+        if self.max_width is not None:
+            clear_width = self.max_width
+
+        buf.append(BEFORE_BAR)
+        line = self.format_progress_line()
+        line_len = term_len(line)
+        if self.max_width is None or self.max_width < line_len:
+            self.max_width = line_len
+
+        buf.append(line)
+        buf.append(" " * (clear_width - line_len))
+        line = "".join(buf)
+        # Render the line only if it changed.
+
+        if line != self._last_line:
+            self._last_line = line
+            echo(line, file=self.file, color=self.color, nl=False)
+            self.file.flush()
+
+    def make_step(self, n_steps: int) -> None:
+        self.pos += n_steps
+        if self.length is not None and self.pos >= self.length:
+            self.finished = True
+
+        if (time.time() - self.last_eta) < 1.0:
+            return
+
+        self.last_eta = time.time()
+
+        # self.avg is a rolling list of length <= 7 of steps where steps are
+        # defined as time elapsed divided by the total progress through
+        # self.length.
+        if self.pos:
+            step = (time.time() - self.start) / self.pos
+        else:
+            step = time.time() - self.start
+
+        self.avg = self.avg[-6:] + [step]
+
+        self.eta_known = self.length is not None
+
+    def update(self, n_steps: int, current_item: t.Optional[V] = None) -> None:
+        """Update the progress bar by advancing a specified number of
+        steps, and optionally set the ``current_item`` for this new
+        position.
+
+        :param n_steps: Number of steps to advance.
+        :param current_item: Optional item to set as ``current_item``
+            for the updated position.
+
+        .. versionchanged:: 8.0
+            Added the ``current_item`` optional parameter.
+
+        .. versionchanged:: 8.0
+            Only render when the number of steps meets the
+            ``update_min_steps`` threshold.
+        """
+        if current_item is not None:
+            self.current_item = current_item
+
+        self._completed_intervals += n_steps
+
+        if self._completed_intervals >= self.update_min_steps:
+            self.make_step(self._completed_intervals)
+            self.render_progress()
+            self._completed_intervals = 0
+
+    def finish(self) -> None:
+        self.eta_known = False
+        self.current_item = None
+        self.finished = True
+
+    def generator(self) -> t.Iterator[V]:
+        """Return a generator which yields the items added to the bar
+        during construction, and updates the progress bar *after* the
+        yielded block returns.
+        """
+        # WARNING: the iterator interface for `ProgressBar` relies on
+        # this and only works because this is a simple generator which
+        # doesn't create or manage additional state. If this function
+        # changes, the impact should be evaluated both against
+        # `iter(bar)` and `next(bar)`. `next()` in particular may call
+        # `self.generator()` repeatedly, and this must remain safe in
+        # order for that interface to work.
+        if not self.entered:
+            raise RuntimeError("You need to use progress bars in a with block.")
+
+        if self.is_hidden:
+            yield from self.iter
+        else:
+            for rv in self.iter:
+                self.current_item = rv
+
+                # This allows show_item_func to be updated before the
+                # item is processed. Only trigger at the beginning of
+                # the update interval.
+                if self._completed_intervals == 0:
+                    self.render_progress()
+
+                yield rv
+                self.update(1)
+
+            self.finish()
+            self.render_progress()
+
+
+def pager(generator: t.Iterable[str], color: t.Optional[bool] = None) -> None:
+    """Decide what method to use for paging through text."""
+    stdout = _default_text_stdout()
+    if not isatty(sys.stdin) or not isatty(stdout):
+        return _nullpager(stdout, generator, color)
+    pager_cmd = (os.environ.get("PAGER", None) or "").strip()
+    if pager_cmd:
+        if WIN:
+            return _tempfilepager(generator, pager_cmd, color)
+        return _pipepager(generator, pager_cmd, color)
+    if os.environ.get("TERM") in ("dumb", "emacs"):
+        return _nullpager(stdout, generator, color)
+    if WIN or sys.platform.startswith("os2"):
+        return _tempfilepager(generator, "more <", color)
+    if hasattr(os, "system") and os.system("(less) 2>/dev/null") == 0:
+        return _pipepager(generator, "less", color)
+
+    import tempfile
+
+    fd, filename = tempfile.mkstemp()
+    os.close(fd)
+    try:
+        if hasattr(os, "system") and os.system(f'more "{filename}"') == 0:
+            return _pipepager(generator, "more", color)
+        return _nullpager(stdout, generator, color)
+    finally:
+        os.unlink(filename)
+
+
+def _pipepager(generator: t.Iterable[str], cmd: str, color: t.Optional[bool]) -> None:
+    """Page through text by feeding it to another program.  Invoking a
+    pager through this might support colors.
+    """
+    import subprocess
+
+    env = dict(os.environ)
+
+    # If we're piping to less we might support colors under the
+    # condition that
+    cmd_detail = cmd.rsplit("/", 1)[-1].split()
+    if color is None and cmd_detail[0] == "less":
+        less_flags = f"{os.environ.get('LESS', '')}{' '.join(cmd_detail[1:])}"
+        if not less_flags:
+            env["LESS"] = "-R"
+            color = True
+        elif "r" in less_flags or "R" in less_flags:
+            color = True
+
+    c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, env=env)
+    stdin = t.cast(t.BinaryIO, c.stdin)
+    encoding = get_best_encoding(stdin)
+    try:
+        for text in generator:
+            if not color:
+                text = strip_ansi(text)
+
+            stdin.write(text.encode(encoding, "replace"))
+    except (OSError, KeyboardInterrupt):
+        pass
+    else:
+        stdin.close()
+
+    # Less doesn't respect ^C, but catches it for its own UI purposes (aborting
+    # search or other commands inside less).
+    #
+    # That means when the user hits ^C, the parent process (click) terminates,
+    # but less is still alive, paging the output and messing up the terminal.
+    #
+    # If the user wants to make the pager exit on ^C, they should set
+    # `LESS='-K'`. It's not our decision to make.
+    while True:
+        try:
+            c.wait()
+        except KeyboardInterrupt:
+            pass
+        else:
+            break
+
+
+def _tempfilepager(
+    generator: t.Iterable[str], cmd: str, color: t.Optional[bool]
+) -> None:
+    """Page through text by invoking a program on a temporary file."""
+    import tempfile
+
+    fd, filename = tempfile.mkstemp()
+    # TODO: This never terminates if the passed generator never terminates.
+    text = "".join(generator)
+    if not color:
+        text = strip_ansi(text)
+    encoding = get_best_encoding(sys.stdout)
+    with open_stream(filename, "wb")[0] as f:
+        f.write(text.encode(encoding))
+    try:
+        os.system(f'{cmd} "{filename}"')
+    finally:
+        os.close(fd)
+        os.unlink(filename)
+
+
+def _nullpager(
+    stream: t.TextIO, generator: t.Iterable[str], color: t.Optional[bool]
+) -> None:
+    """Simply print unformatted text.  This is the ultimate fallback."""
+    for text in generator:
+        if not color:
+            text = strip_ansi(text)
+        stream.write(text)
+
+
+class Editor:
+    def __init__(
+        self,
+        editor: t.Optional[str] = None,
+        env: t.Optional[t.Mapping[str, str]] = None,
+        require_save: bool = True,
+        extension: str = ".txt",
+    ) -> None:
+        self.editor = editor
+        self.env = env
+        self.require_save = require_save
+        self.extension = extension
+
+    def get_editor(self) -> str:
+        if self.editor is not None:
+            return self.editor
+        for key in "VISUAL", "EDITOR":
+            rv = os.environ.get(key)
+            if rv:
+                return rv
+        if WIN:
+            return "notepad"
+        for editor in "sensible-editor", "vim", "nano":
+            if os.system(f"which {editor} >/dev/null 2>&1") == 0:
+                return editor
+        return "vi"
+
+    def edit_file(self, filename: str) -> None:
+        import subprocess
+
+        editor = self.get_editor()
+        environ: t.Optional[t.Dict[str, str]] = None
+
+        if self.env:
+            environ = os.environ.copy()
+            environ.update(self.env)
+
+        try:
+            c = subprocess.Popen(f'{editor} "{filename}"', env=environ, shell=True)
+            exit_code = c.wait()
+            if exit_code != 0:
+                raise ClickException(
+                    _("{editor}: Editing failed").format(editor=editor)
+                )
+        except OSError as e:
+            raise ClickException(
+                _("{editor}: Editing failed: {e}").format(editor=editor, e=e)
+            ) from e
+
+    def edit(self, text: t.Optional[t.AnyStr]) -> t.Optional[t.AnyStr]:
+        import tempfile
+
+        if not text:
+            data = b""
+        elif isinstance(text, (bytes, bytearray)):
+            data = text
+        else:
+            if text and not text.endswith("\n"):
+                text += "\n"
+
+            if WIN:
+                data = text.replace("\n", "\r\n").encode("utf-8-sig")
+            else:
+                data = text.encode("utf-8")
+
+        fd, name = tempfile.mkstemp(prefix="editor-", suffix=self.extension)
+        f: t.BinaryIO
+
+        try:
+            with os.fdopen(fd, "wb") as f:
+                f.write(data)
+
+            # If the filesystem resolution is 1 second, like Mac OS
+            # 10.12 Extended, or 2 seconds, like FAT32, and the editor
+            # closes very fast, require_save can fail. Set the modified
+            # time to be 2 seconds in the past to work around this.
+            os.utime(name, (os.path.getatime(name), os.path.getmtime(name) - 2))
+            # Depending on the resolution, the exact value might not be
+            # recorded, so get the new recorded value.
+            timestamp = os.path.getmtime(name)
+
+            self.edit_file(name)
+
+            if self.require_save and os.path.getmtime(name) == timestamp:
+                return None
+
+            with open(name, "rb") as f:
+                rv = f.read()
+
+            if isinstance(text, (bytes, bytearray)):
+                return rv
+
+            return rv.decode("utf-8-sig").replace("\r\n", "\n")  # type: ignore
+        finally:
+            os.unlink(name)
+
+
+def open_url(url: str, wait: bool = False, locate: bool = False) -> int:
+    import subprocess
+
+    def _unquote_file(url: str) -> str:
+        from urllib.parse import unquote
+
+        if url.startswith("file://"):
+            url = unquote(url[7:])
+
+        return url
+
+    if sys.platform == "darwin":
+        args = ["open"]
+        if wait:
+            args.append("-W")
+        if locate:
+            args.append("-R")
+        args.append(_unquote_file(url))
+        null = open("/dev/null", "w")
+        try:
+            return subprocess.Popen(args, stderr=null).wait()
+        finally:
+            null.close()
+    elif WIN:
+        if locate:
+            url = _unquote_file(url.replace('"', ""))
+            args = f'explorer /select,"{url}"'
+        else:
+            url = url.replace('"', "")
+            wait_str = "/WAIT" if wait else ""
+            args = f'start {wait_str} "" "{url}"'
+        return os.system(args)
+    elif CYGWIN:
+        if locate:
+            url = os.path.dirname(_unquote_file(url).replace('"', ""))
+            args = f'cygstart "{url}"'
+        else:
+            url = url.replace('"', "")
+            wait_str = "-w" if wait else ""
+            args = f'cygstart {wait_str} "{url}"'
+        return os.system(args)
+
+    try:
+        if locate:
+            url = os.path.dirname(_unquote_file(url)) or "."
+        else:
+            url = _unquote_file(url)
+        c = subprocess.Popen(["xdg-open", url])
+        if wait:
+            return c.wait()
+        return 0
+    except OSError:
+        if url.startswith(("http://", "https://")) and not locate and not wait:
+            import webbrowser
+
+            webbrowser.open(url)
+            return 0
+        return 1
+
+
+def _translate_ch_to_exc(ch: str) -> t.Optional[BaseException]:
+    if ch == "\x03":
+        raise KeyboardInterrupt()
+
+    if ch == "\x04" and not WIN:  # Unix-like, Ctrl+D
+        raise EOFError()
+
+    if ch == "\x1a" and WIN:  # Windows, Ctrl+Z
+        raise EOFError()
+
+    return None
+
+
+if WIN:
+    import msvcrt
+
+    @contextlib.contextmanager
+    def raw_terminal() -> t.Iterator[int]:
+        yield -1
+
+    def getchar(echo: bool) -> str:
+        # The function `getch` will return a bytes object corresponding to
+        # the pressed character. Since Windows 10 build 1803, it will also
+        # return \x00 when called a second time after pressing a regular key.
+        #
+        # `getwch` does not share this probably-bugged behavior. Moreover, it
+        # returns a Unicode object by default, which is what we want.
+        #
+        # Either of these functions will return \x00 or \xe0 to indicate
+        # a special key, and you need to call the same function again to get
+        # the "rest" of the code. The fun part is that \u00e0 is
+        # "latin small letter a with grave", so if you type that on a French
+        # keyboard, you _also_ get a \xe0.
+        # E.g., consider the Up arrow. This returns \xe0 and then \x48. The
+        # resulting Unicode string reads as "a with grave" + "capital H".
+        # This is indistinguishable from when the user actually types
+        # "a with grave" and then "capital H".
+        #
+        # When \xe0 is returned, we assume it's part of a special-key sequence
+        # and call `getwch` again, but that means that when the user types
+        # the \u00e0 character, `getchar` doesn't return until a second
+        # character is typed.
+        # The alternative is returning immediately, but that would mess up
+        # cross-platform handling of arrow keys and others that start with
+        # \xe0. Another option is using `getch`, but then we can't reliably
+        # read non-ASCII characters, because return values of `getch` are
+        # limited to the current 8-bit codepage.
+        #
+        # Anyway, Click doesn't claim to do this Right(tm), and using `getwch`
+        # is doing the right thing in more situations than with `getch`.
+        func: t.Callable[[], str]
+
+        if echo:
+            func = msvcrt.getwche  # type: ignore
+        else:
+            func = msvcrt.getwch  # type: ignore
+
+        rv = func()
+
+        if rv in ("\x00", "\xe0"):
+            # \x00 and \xe0 are control characters that indicate special key,
+            # see above.
+            rv += func()
+
+        _translate_ch_to_exc(rv)
+        return rv
+
+else:
+    import tty
+    import termios
+
+    @contextlib.contextmanager
+    def raw_terminal() -> t.Iterator[int]:
+        f: t.Optional[t.TextIO]
+        fd: int
+
+        if not isatty(sys.stdin):
+            f = open("/dev/tty")
+            fd = f.fileno()
+        else:
+            fd = sys.stdin.fileno()
+            f = None
+
+        try:
+            old_settings = termios.tcgetattr(fd)
+
+            try:
+                tty.setraw(fd)
+                yield fd
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+                sys.stdout.flush()
+
+                if f is not None:
+                    f.close()
+        except termios.error:
+            pass
+
+    def getchar(echo: bool) -> str:
+        with raw_terminal() as fd:
+            ch = os.read(fd, 32).decode(get_best_encoding(sys.stdin), "replace")
+
+            if echo and isatty(sys.stdout):
+                sys.stdout.write(ch)
+
+            _translate_ch_to_exc(ch)
+            return ch
diff --git a/myenv/lib/python3.9/site-packages/click/_textwrap.py b/myenv/lib/python3.9/site-packages/click/_textwrap.py
new file mode 100644
index 0000000..b47dcbd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/_textwrap.py
@@ -0,0 +1,49 @@
+import textwrap
+import typing as t
+from contextlib import contextmanager
+
+
+class TextWrapper(textwrap.TextWrapper):
+    def _handle_long_word(
+        self,
+        reversed_chunks: t.List[str],
+        cur_line: t.List[str],
+        cur_len: int,
+        width: int,
+    ) -> None:
+        space_left = max(width - cur_len, 1)
+
+        if self.break_long_words:
+            last = reversed_chunks[-1]
+            cut = last[:space_left]
+            res = last[space_left:]
+            cur_line.append(cut)
+            reversed_chunks[-1] = res
+        elif not cur_line:
+            cur_line.append(reversed_chunks.pop())
+
+    @contextmanager
+    def extra_indent(self, indent: str) -> t.Iterator[None]:
+        old_initial_indent = self.initial_indent
+        old_subsequent_indent = self.subsequent_indent
+        self.initial_indent += indent
+        self.subsequent_indent += indent
+
+        try:
+            yield
+        finally:
+            self.initial_indent = old_initial_indent
+            self.subsequent_indent = old_subsequent_indent
+
+    def indent_only(self, text: str) -> str:
+        rv = []
+
+        for idx, line in enumerate(text.splitlines()):
+            indent = self.initial_indent
+
+            if idx > 0:
+                indent = self.subsequent_indent
+
+            rv.append(f"{indent}{line}")
+
+        return "\n".join(rv)
diff --git a/myenv/lib/python3.9/site-packages/click/_winconsole.py b/myenv/lib/python3.9/site-packages/click/_winconsole.py
new file mode 100644
index 0000000..6b20df3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/_winconsole.py
@@ -0,0 +1,279 @@
+# This module is based on the excellent work by Adam Bartoš who
+# provided a lot of what went into the implementation here in
+# the discussion to issue1602 in the Python bug tracker.
+#
+# There are some general differences in regards to how this works
+# compared to the original patches as we do not need to patch
+# the entire interpreter but just work in our little world of
+# echo and prompt.
+import io
+import sys
+import time
+import typing as t
+from ctypes import byref
+from ctypes import c_char
+from ctypes import c_char_p
+from ctypes import c_int
+from ctypes import c_ssize_t
+from ctypes import c_ulong
+from ctypes import c_void_p
+from ctypes import POINTER
+from ctypes import py_object
+from ctypes import Structure
+from ctypes.wintypes import DWORD
+from ctypes.wintypes import HANDLE
+from ctypes.wintypes import LPCWSTR
+from ctypes.wintypes import LPWSTR
+
+from ._compat import _NonClosingTextIOWrapper
+
+assert sys.platform == "win32"
+import msvcrt  # noqa: E402
+from ctypes import windll  # noqa: E402
+from ctypes import WINFUNCTYPE  # noqa: E402
+
+c_ssize_p = POINTER(c_ssize_t)
+
+kernel32 = windll.kernel32
+GetStdHandle = kernel32.GetStdHandle
+ReadConsoleW = kernel32.ReadConsoleW
+WriteConsoleW = kernel32.WriteConsoleW
+GetConsoleMode = kernel32.GetConsoleMode
+GetLastError = kernel32.GetLastError
+GetCommandLineW = WINFUNCTYPE(LPWSTR)(("GetCommandLineW", windll.kernel32))
+CommandLineToArgvW = WINFUNCTYPE(POINTER(LPWSTR), LPCWSTR, POINTER(c_int))(
+    ("CommandLineToArgvW", windll.shell32)
+)
+LocalFree = WINFUNCTYPE(c_void_p, c_void_p)(("LocalFree", windll.kernel32))
+
+STDIN_HANDLE = GetStdHandle(-10)
+STDOUT_HANDLE = GetStdHandle(-11)
+STDERR_HANDLE = GetStdHandle(-12)
+
+PyBUF_SIMPLE = 0
+PyBUF_WRITABLE = 1
+
+ERROR_SUCCESS = 0
+ERROR_NOT_ENOUGH_MEMORY = 8
+ERROR_OPERATION_ABORTED = 995
+
+STDIN_FILENO = 0
+STDOUT_FILENO = 1
+STDERR_FILENO = 2
+
+EOF = b"\x1a"
+MAX_BYTES_WRITTEN = 32767
+
+try:
+    from ctypes import pythonapi
+except ImportError:
+    # On PyPy we cannot get buffers so our ability to operate here is
+    # severely limited.
+    get_buffer = None
+else:
+
+    class Py_buffer(Structure):
+        _fields_ = [
+            ("buf", c_void_p),
+            ("obj", py_object),
+            ("len", c_ssize_t),
+            ("itemsize", c_ssize_t),
+            ("readonly", c_int),
+            ("ndim", c_int),
+            ("format", c_char_p),
+            ("shape", c_ssize_p),
+            ("strides", c_ssize_p),
+            ("suboffsets", c_ssize_p),
+            ("internal", c_void_p),
+        ]
+
+    PyObject_GetBuffer = pythonapi.PyObject_GetBuffer
+    PyBuffer_Release = pythonapi.PyBuffer_Release
+
+    def get_buffer(obj, writable=False):
+        buf = Py_buffer()
+        flags = PyBUF_WRITABLE if writable else PyBUF_SIMPLE
+        PyObject_GetBuffer(py_object(obj), byref(buf), flags)
+
+        try:
+            buffer_type = c_char * buf.len
+            return buffer_type.from_address(buf.buf)
+        finally:
+            PyBuffer_Release(byref(buf))
+
+
+class _WindowsConsoleRawIOBase(io.RawIOBase):
+    def __init__(self, handle):
+        self.handle = handle
+
+    def isatty(self):
+        super().isatty()
+        return True
+
+
+class _WindowsConsoleReader(_WindowsConsoleRawIOBase):
+    def readable(self):
+        return True
+
+    def readinto(self, b):
+        bytes_to_be_read = len(b)
+        if not bytes_to_be_read:
+            return 0
+        elif bytes_to_be_read % 2:
+            raise ValueError(
+                "cannot read odd number of bytes from UTF-16-LE encoded console"
+            )
+
+        buffer = get_buffer(b, writable=True)
+        code_units_to_be_read = bytes_to_be_read // 2
+        code_units_read = c_ulong()
+
+        rv = ReadConsoleW(
+            HANDLE(self.handle),
+            buffer,
+            code_units_to_be_read,
+            byref(code_units_read),
+            None,
+        )
+        if GetLastError() == ERROR_OPERATION_ABORTED:
+            # wait for KeyboardInterrupt
+            time.sleep(0.1)
+        if not rv:
+            raise OSError(f"Windows error: {GetLastError()}")
+
+        if buffer[0] == EOF:
+            return 0
+        return 2 * code_units_read.value
+
+
+class _WindowsConsoleWriter(_WindowsConsoleRawIOBase):
+    def writable(self):
+        return True
+
+    @staticmethod
+    def _get_error_message(errno):
+        if errno == ERROR_SUCCESS:
+            return "ERROR_SUCCESS"
+        elif errno == ERROR_NOT_ENOUGH_MEMORY:
+            return "ERROR_NOT_ENOUGH_MEMORY"
+        return f"Windows error {errno}"
+
+    def write(self, b):
+        bytes_to_be_written = len(b)
+        buf = get_buffer(b)
+        code_units_to_be_written = min(bytes_to_be_written, MAX_BYTES_WRITTEN) // 2
+        code_units_written = c_ulong()
+
+        WriteConsoleW(
+            HANDLE(self.handle),
+            buf,
+            code_units_to_be_written,
+            byref(code_units_written),
+            None,
+        )
+        bytes_written = 2 * code_units_written.value
+
+        if bytes_written == 0 and bytes_to_be_written > 0:
+            raise OSError(self._get_error_message(GetLastError()))
+        return bytes_written
+
+
+class ConsoleStream:
+    def __init__(self, text_stream: t.TextIO, byte_stream: t.BinaryIO) -> None:
+        self._text_stream = text_stream
+        self.buffer = byte_stream
+
+    @property
+    def name(self) -> str:
+        return self.buffer.name
+
+    def write(self, x: t.AnyStr) -> int:
+        if isinstance(x, str):
+            return self._text_stream.write(x)
+        try:
+            self.flush()
+        except Exception:
+            pass
+        return self.buffer.write(x)
+
+    def writelines(self, lines: t.Iterable[t.AnyStr]) -> None:
+        for line in lines:
+            self.write(line)
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._text_stream, name)
+
+    def isatty(self) -> bool:
+        return self.buffer.isatty()
+
+    def __repr__(self):
+        return f"<ConsoleStream name={self.name!r} encoding={self.encoding!r}>"
+
+
+def _get_text_stdin(buffer_stream: t.BinaryIO) -> t.TextIO:
+    text_stream = _NonClosingTextIOWrapper(
+        io.BufferedReader(_WindowsConsoleReader(STDIN_HANDLE)),
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
+
+
+def _get_text_stdout(buffer_stream: t.BinaryIO) -> t.TextIO:
+    text_stream = _NonClosingTextIOWrapper(
+        io.BufferedWriter(_WindowsConsoleWriter(STDOUT_HANDLE)),
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
+
+
+def _get_text_stderr(buffer_stream: t.BinaryIO) -> t.TextIO:
+    text_stream = _NonClosingTextIOWrapper(
+        io.BufferedWriter(_WindowsConsoleWriter(STDERR_HANDLE)),
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
+
+
+_stream_factories: t.Mapping[int, t.Callable[[t.BinaryIO], t.TextIO]] = {
+    0: _get_text_stdin,
+    1: _get_text_stdout,
+    2: _get_text_stderr,
+}
+
+
+def _is_console(f: t.TextIO) -> bool:
+    if not hasattr(f, "fileno"):
+        return False
+
+    try:
+        fileno = f.fileno()
+    except (OSError, io.UnsupportedOperation):
+        return False
+
+    handle = msvcrt.get_osfhandle(fileno)
+    return bool(GetConsoleMode(handle, byref(DWORD())))
+
+
+def _get_windows_console_stream(
+    f: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str]
+) -> t.Optional[t.TextIO]:
+    if (
+        get_buffer is not None
+        and encoding in {"utf-16-le", None}
+        and errors in {"strict", None}
+        and _is_console(f)
+    ):
+        func = _stream_factories.get(f.fileno())
+        if func is not None:
+            b = getattr(f, "buffer", None)
+
+            if b is None:
+                return None
+
+            return func(b)
diff --git a/myenv/lib/python3.9/site-packages/click/core.py b/myenv/lib/python3.9/site-packages/click/core.py
new file mode 100644
index 0000000..5abfb0f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/core.py
@@ -0,0 +1,2998 @@
+import enum
+import errno
+import inspect
+import os
+import sys
+import typing as t
+from collections import abc
+from contextlib import contextmanager
+from contextlib import ExitStack
+from functools import partial
+from functools import update_wrapper
+from gettext import gettext as _
+from gettext import ngettext
+from itertools import repeat
+
+from . import types
+from .exceptions import Abort
+from .exceptions import BadParameter
+from .exceptions import ClickException
+from .exceptions import Exit
+from .exceptions import MissingParameter
+from .exceptions import UsageError
+from .formatting import HelpFormatter
+from .formatting import join_options
+from .globals import pop_context
+from .globals import push_context
+from .parser import _flag_needs_value
+from .parser import OptionParser
+from .parser import split_opt
+from .termui import confirm
+from .termui import prompt
+from .termui import style
+from .utils import _detect_program_name
+from .utils import _expand_args
+from .utils import echo
+from .utils import make_default_short_help
+from .utils import make_str
+from .utils import PacifyFlushWrapper
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .shell_completion import CompletionItem
+
+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
+V = t.TypeVar("V")
+
+
+def _complete_visible_commands(
+    ctx: "Context", incomplete: str
+) -> t.Iterator[t.Tuple[str, "Command"]]:
+    """List all the subcommands of a group that start with the
+    incomplete value and aren't hidden.
+
+    :param ctx: Invocation context for the group.
+    :param incomplete: Value being completed. May be empty.
+    """
+    multi = t.cast(MultiCommand, ctx.command)
+
+    for name in multi.list_commands(ctx):
+        if name.startswith(incomplete):
+            command = multi.get_command(ctx, name)
+
+            if command is not None and not command.hidden:
+                yield name, command
+
+
+def _check_multicommand(
+    base_command: "MultiCommand", cmd_name: str, cmd: "Command", register: bool = False
+) -> None:
+    if not base_command.chain or not isinstance(cmd, MultiCommand):
+        return
+    if register:
+        hint = (
+            "It is not possible to add multi commands as children to"
+            " another multi command that is in chain mode."
+        )
+    else:
+        hint = (
+            "Found a multi command as subcommand to a multi command"
+            " that is in chain mode. This is not supported."
+        )
+    raise RuntimeError(
+        f"{hint}. Command {base_command.name!r} is set to chain and"
+        f" {cmd_name!r} was added as a subcommand but it in itself is a"
+        f" multi command. ({cmd_name!r} is a {type(cmd).__name__}"
+        f" within a chained {type(base_command).__name__} named"
+        f" {base_command.name!r})."
+    )
+
+
+def batch(iterable: t.Iterable[V], batch_size: int) -> t.List[t.Tuple[V, ...]]:
+    return list(zip(*repeat(iter(iterable), batch_size)))
+
+
+@contextmanager
+def augment_usage_errors(
+    ctx: "Context", param: t.Optional["Parameter"] = None
+) -> t.Iterator[None]:
+    """Context manager that attaches extra information to exceptions."""
+    try:
+        yield
+    except BadParameter as e:
+        if e.ctx is None:
+            e.ctx = ctx
+        if param is not None and e.param is None:
+            e.param = param
+        raise
+    except UsageError as e:
+        if e.ctx is None:
+            e.ctx = ctx
+        raise
+
+
+def iter_params_for_processing(
+    invocation_order: t.Sequence["Parameter"],
+    declaration_order: t.Sequence["Parameter"],
+) -> t.List["Parameter"]:
+    """Given a sequence of parameters in the order as should be considered
+    for processing and an iterable of parameters that exist, this returns
+    a list in the correct order as they should be processed.
+    """
+
+    def sort_key(item: "Parameter") -> t.Tuple[bool, float]:
+        try:
+            idx: float = invocation_order.index(item)
+        except ValueError:
+            idx = float("inf")
+
+        return not item.is_eager, idx
+
+    return sorted(declaration_order, key=sort_key)
+
+
+class ParameterSource(enum.Enum):
+    """This is an :class:`~enum.Enum` that indicates the source of a
+    parameter's value.
+
+    Use :meth:`click.Context.get_parameter_source` to get the
+    source for a parameter by name.
+
+    .. versionchanged:: 8.0
+        Use :class:`~enum.Enum` and drop the ``validate`` method.
+
+    .. versionchanged:: 8.0
+        Added the ``PROMPT`` value.
+    """
+
+    COMMANDLINE = enum.auto()
+    """The value was provided by the command line args."""
+    ENVIRONMENT = enum.auto()
+    """The value was provided with an environment variable."""
+    DEFAULT = enum.auto()
+    """Used the default specified by the parameter."""
+    DEFAULT_MAP = enum.auto()
+    """Used a default provided by :attr:`Context.default_map`."""
+    PROMPT = enum.auto()
+    """Used a prompt to confirm a default or provide a value."""
+
+
+class Context:
+    """The context is a special internal object that holds state relevant
+    for the script execution at every single level.  It's normally invisible
+    to commands unless they opt-in to getting access to it.
+
+    The context is useful as it can pass internal objects around and can
+    control special execution features such as reading data from
+    environment variables.
+
+    A context can be used as context manager in which case it will call
+    :meth:`close` on teardown.
+
+    :param command: the command class for this context.
+    :param parent: the parent context.
+    :param info_name: the info name for this invocation.  Generally this
+                      is the most descriptive name for the script or
+                      command.  For the toplevel script it is usually
+                      the name of the script, for commands below it it's
+                      the name of the script.
+    :param obj: an arbitrary object of user data.
+    :param auto_envvar_prefix: the prefix to use for automatic environment
+                               variables.  If this is `None` then reading
+                               from environment variables is disabled.  This
+                               does not affect manually set environment
+                               variables which are always read.
+    :param default_map: a dictionary (like object) with default values
+                        for parameters.
+    :param terminal_width: the width of the terminal.  The default is
+                           inherit from parent context.  If no context
+                           defines the terminal width then auto
+                           detection will be applied.
+    :param max_content_width: the maximum width for content rendered by
+                              Click (this currently only affects help
+                              pages).  This defaults to 80 characters if
+                              not overridden.  In other words: even if the
+                              terminal is larger than that, Click will not
+                              format things wider than 80 characters by
+                              default.  In addition to that, formatters might
+                              add some safety mapping on the right.
+    :param resilient_parsing: if this flag is enabled then Click will
+                              parse without any interactivity or callback
+                              invocation.  Default values will also be
+                              ignored.  This is useful for implementing
+                              things such as completion support.
+    :param allow_extra_args: if this is set to `True` then extra arguments
+                             at the end will not raise an error and will be
+                             kept on the context.  The default is to inherit
+                             from the command.
+    :param allow_interspersed_args: if this is set to `False` then options
+                                    and arguments cannot be mixed.  The
+                                    default is to inherit from the command.
+    :param ignore_unknown_options: instructs click to ignore options it does
+                                   not know and keeps them for later
+                                   processing.
+    :param help_option_names: optionally a list of strings that define how
+                              the default help parameter is named.  The
+                              default is ``['--help']``.
+    :param token_normalize_func: an optional function that is used to
+                                 normalize tokens (options, choices,
+                                 etc.).  This for instance can be used to
+                                 implement case insensitive behavior.
+    :param color: controls if the terminal supports ANSI colors or not.  The
+                  default is autodetection.  This is only needed if ANSI
+                  codes are used in texts that Click prints which is by
+                  default not the case.  This for instance would affect
+                  help output.
+    :param show_default: Show the default value for commands. If this
+        value is not set, it defaults to the value from the parent
+        context. ``Command.show_default`` overrides this default for the
+        specific command.
+
+    .. versionchanged:: 8.1
+        The ``show_default`` parameter is overridden by
+        ``Command.show_default``, instead of the other way around.
+
+    .. versionchanged:: 8.0
+        The ``show_default`` parameter defaults to the value from the
+        parent context.
+
+    .. versionchanged:: 7.1
+       Added the ``show_default`` parameter.
+
+    .. versionchanged:: 4.0
+        Added the ``color``, ``ignore_unknown_options``, and
+        ``max_content_width`` parameters.
+
+    .. versionchanged:: 3.0
+        Added the ``allow_extra_args`` and ``allow_interspersed_args``
+        parameters.
+
+    .. versionchanged:: 2.0
+        Added the ``resilient_parsing``, ``help_option_names``, and
+        ``token_normalize_func`` parameters.
+    """
+
+    #: The formatter class to create with :meth:`make_formatter`.
+    #:
+    #: .. versionadded:: 8.0
+    formatter_class: t.Type["HelpFormatter"] = HelpFormatter
+
+    def __init__(
+        self,
+        command: "Command",
+        parent: t.Optional["Context"] = None,
+        info_name: t.Optional[str] = None,
+        obj: t.Optional[t.Any] = None,
+        auto_envvar_prefix: t.Optional[str] = None,
+        default_map: t.Optional[t.Dict[str, t.Any]] = None,
+        terminal_width: t.Optional[int] = None,
+        max_content_width: t.Optional[int] = None,
+        resilient_parsing: bool = False,
+        allow_extra_args: t.Optional[bool] = None,
+        allow_interspersed_args: t.Optional[bool] = None,
+        ignore_unknown_options: t.Optional[bool] = None,
+        help_option_names: t.Optional[t.List[str]] = None,
+        token_normalize_func: t.Optional[t.Callable[[str], str]] = None,
+        color: t.Optional[bool] = None,
+        show_default: t.Optional[bool] = None,
+    ) -> None:
+        #: the parent context or `None` if none exists.
+        self.parent = parent
+        #: the :class:`Command` for this context.
+        self.command = command
+        #: the descriptive information name
+        self.info_name = info_name
+        #: Map of parameter names to their parsed values. Parameters
+        #: with ``expose_value=False`` are not stored.
+        self.params: t.Dict[str, t.Any] = {}
+        #: the leftover arguments.
+        self.args: t.List[str] = []
+        #: protected arguments.  These are arguments that are prepended
+        #: to `args` when certain parsing scenarios are encountered but
+        #: must be never propagated to another arguments.  This is used
+        #: to implement nested parsing.
+        self.protected_args: t.List[str] = []
+        #: the collected prefixes of the command's options.
+        self._opt_prefixes: t.Set[str] = set(parent._opt_prefixes) if parent else set()
+
+        if obj is None and parent is not None:
+            obj = parent.obj
+
+        #: the user object stored.
+        self.obj: t.Any = obj
+        self._meta: t.Dict[str, t.Any] = getattr(parent, "meta", {})
+
+        #: A dictionary (-like object) with defaults for parameters.
+        if (
+            default_map is None
+            and info_name is not None
+            and parent is not None
+            and parent.default_map is not None
+        ):
+            default_map = parent.default_map.get(info_name)
+
+        self.default_map: t.Optional[t.Dict[str, t.Any]] = default_map
+
+        #: This flag indicates if a subcommand is going to be executed. A
+        #: group callback can use this information to figure out if it's
+        #: being executed directly or because the execution flow passes
+        #: onwards to a subcommand. By default it's None, but it can be
+        #: the name of the subcommand to execute.
+        #:
+        #: If chaining is enabled this will be set to ``'*'`` in case
+        #: any commands are executed.  It is however not possible to
+        #: figure out which ones.  If you require this knowledge you
+        #: should use a :func:`result_callback`.
+        self.invoked_subcommand: t.Optional[str] = None
+
+        if terminal_width is None and parent is not None:
+            terminal_width = parent.terminal_width
+
+        #: The width of the terminal (None is autodetection).
+        self.terminal_width: t.Optional[int] = terminal_width
+
+        if max_content_width is None and parent is not None:
+            max_content_width = parent.max_content_width
+
+        #: The maximum width of formatted content (None implies a sensible
+        #: default which is 80 for most things).
+        self.max_content_width: t.Optional[int] = max_content_width
+
+        if allow_extra_args is None:
+            allow_extra_args = command.allow_extra_args
+
+        #: Indicates if the context allows extra args or if it should
+        #: fail on parsing.
+        #:
+        #: .. versionadded:: 3.0
+        self.allow_extra_args = allow_extra_args
+
+        if allow_interspersed_args is None:
+            allow_interspersed_args = command.allow_interspersed_args
+
+        #: Indicates if the context allows mixing of arguments and
+        #: options or not.
+        #:
+        #: .. versionadded:: 3.0
+        self.allow_interspersed_args: bool = allow_interspersed_args
+
+        if ignore_unknown_options is None:
+            ignore_unknown_options = command.ignore_unknown_options
+
+        #: Instructs click to ignore options that a command does not
+        #: understand and will store it on the context for later
+        #: processing.  This is primarily useful for situations where you
+        #: want to call into external programs.  Generally this pattern is
+        #: strongly discouraged because it's not possibly to losslessly
+        #: forward all arguments.
+        #:
+        #: .. versionadded:: 4.0
+        self.ignore_unknown_options: bool = ignore_unknown_options
+
+        if help_option_names is None:
+            if parent is not None:
+                help_option_names = parent.help_option_names
+            else:
+                help_option_names = ["--help"]
+
+        #: The names for the help options.
+        self.help_option_names: t.List[str] = help_option_names
+
+        if token_normalize_func is None and parent is not None:
+            token_normalize_func = parent.token_normalize_func
+
+        #: An optional normalization function for tokens.  This is
+        #: options, choices, commands etc.
+        self.token_normalize_func: t.Optional[
+            t.Callable[[str], str]
+        ] = token_normalize_func
+
+        #: Indicates if resilient parsing is enabled.  In that case Click
+        #: will do its best to not cause any failures and default values
+        #: will be ignored. Useful for completion.
+        self.resilient_parsing: bool = resilient_parsing
+
+        # If there is no envvar prefix yet, but the parent has one and
+        # the command on this level has a name, we can expand the envvar
+        # prefix automatically.
+        if auto_envvar_prefix is None:
+            if (
+                parent is not None
+                and parent.auto_envvar_prefix is not None
+                and self.info_name is not None
+            ):
+                auto_envvar_prefix = (
+                    f"{parent.auto_envvar_prefix}_{self.info_name.upper()}"
+                )
+        else:
+            auto_envvar_prefix = auto_envvar_prefix.upper()
+
+        if auto_envvar_prefix is not None:
+            auto_envvar_prefix = auto_envvar_prefix.replace("-", "_")
+
+        self.auto_envvar_prefix: t.Optional[str] = auto_envvar_prefix
+
+        if color is None and parent is not None:
+            color = parent.color
+
+        #: Controls if styling output is wanted or not.
+        self.color: t.Optional[bool] = color
+
+        if show_default is None and parent is not None:
+            show_default = parent.show_default
+
+        #: Show option default values when formatting help text.
+        self.show_default: t.Optional[bool] = show_default
+
+        self._close_callbacks: t.List[t.Callable[[], t.Any]] = []
+        self._depth = 0
+        self._parameter_source: t.Dict[str, ParameterSource] = {}
+        self._exit_stack = ExitStack()
+
+    def to_info_dict(self) -> t.Dict[str, t.Any]:
+        """Gather information that could be useful for a tool generating
+        user-facing documentation. This traverses the entire CLI
+        structure.
+
+        .. code-block:: python
+
+            with Context(cli) as ctx:
+                info = ctx.to_info_dict()
+
+        .. versionadded:: 8.0
+        """
+        return {
+            "command": self.command.to_info_dict(self),
+            "info_name": self.info_name,
+            "allow_extra_args": self.allow_extra_args,
+            "allow_interspersed_args": self.allow_interspersed_args,
+            "ignore_unknown_options": self.ignore_unknown_options,
+            "auto_envvar_prefix": self.auto_envvar_prefix,
+        }
+
+    def __enter__(self) -> "Context":
+        self._depth += 1
+        push_context(self)
+        return self
+
+    def __exit__(self, exc_type, exc_value, tb):  # type: ignore
+        self._depth -= 1
+        if self._depth == 0:
+            self.close()
+        pop_context()
+
+    @contextmanager
+    def scope(self, cleanup: bool = True) -> t.Iterator["Context"]:
+        """This helper method can be used with the context object to promote
+        it to the current thread local (see :func:`get_current_context`).
+        The default behavior of this is to invoke the cleanup functions which
+        can be disabled by setting `cleanup` to `False`.  The cleanup
+        functions are typically used for things such as closing file handles.
+
+        If the cleanup is intended the context object can also be directly
+        used as a context manager.
+
+        Example usage::
+
+            with ctx.scope():
+                assert get_current_context() is ctx
+
+        This is equivalent::
+
+            with ctx:
+                assert get_current_context() is ctx
+
+        .. versionadded:: 5.0
+
+        :param cleanup: controls if the cleanup functions should be run or
+                        not.  The default is to run these functions.  In
+                        some situations the context only wants to be
+                        temporarily pushed in which case this can be disabled.
+                        Nested pushes automatically defer the cleanup.
+        """
+        if not cleanup:
+            self._depth += 1
+        try:
+            with self as rv:
+                yield rv
+        finally:
+            if not cleanup:
+                self._depth -= 1
+
+    @property
+    def meta(self) -> t.Dict[str, t.Any]:
+        """This is a dictionary which is shared with all the contexts
+        that are nested.  It exists so that click utilities can store some
+        state here if they need to.  It is however the responsibility of
+        that code to manage this dictionary well.
+
+        The keys are supposed to be unique dotted strings.  For instance
+        module paths are a good choice for it.  What is stored in there is
+        irrelevant for the operation of click.  However what is important is
+        that code that places data here adheres to the general semantics of
+        the system.
+
+        Example usage::
+
+            LANG_KEY = f'{__name__}.lang'
+
+            def set_language(value):
+                ctx = get_current_context()
+                ctx.meta[LANG_KEY] = value
+
+            def get_language():
+                return get_current_context().meta.get(LANG_KEY, 'en_US')
+
+        .. versionadded:: 5.0
+        """
+        return self._meta
+
+    def make_formatter(self) -> HelpFormatter:
+        """Creates the :class:`~click.HelpFormatter` for the help and
+        usage output.
+
+        To quickly customize the formatter class used without overriding
+        this method, set the :attr:`formatter_class` attribute.
+
+        .. versionchanged:: 8.0
+            Added the :attr:`formatter_class` attribute.
+        """
+        return self.formatter_class(
+            width=self.terminal_width, max_width=self.max_content_width
+        )
+
+    def with_resource(self, context_manager: t.ContextManager[V]) -> V:
+        """Register a resource as if it were used in a ``with``
+        statement. The resource will be cleaned up when the context is
+        popped.
+
+        Uses :meth:`contextlib.ExitStack.enter_context`. It calls the
+        resource's ``__enter__()`` method and returns the result. When
+        the context is popped, it closes the stack, which calls the
+        resource's ``__exit__()`` method.
+
+        To register a cleanup function for something that isn't a
+        context manager, use :meth:`call_on_close`. Or use something
+        from :mod:`contextlib` to turn it into a context manager first.
+
+        .. code-block:: python
+
+            @click.group()
+            @click.option("--name")
+            @click.pass_context
+            def cli(ctx):
+                ctx.obj = ctx.with_resource(connect_db(name))
+
+        :param context_manager: The context manager to enter.
+        :return: Whatever ``context_manager.__enter__()`` returns.
+
+        .. versionadded:: 8.0
+        """
+        return self._exit_stack.enter_context(context_manager)
+
+    def call_on_close(self, f: t.Callable[..., t.Any]) -> t.Callable[..., t.Any]:
+        """Register a function to be called when the context tears down.
+
+        This can be used to close resources opened during the script
+        execution. Resources that support Python's context manager
+        protocol which would be used in a ``with`` statement should be
+        registered with :meth:`with_resource` instead.
+
+        :param f: The function to execute on teardown.
+        """
+        return self._exit_stack.callback(f)
+
+    def close(self) -> None:
+        """Invoke all close callbacks registered with
+        :meth:`call_on_close`, and exit all context managers entered
+        with :meth:`with_resource`.
+        """
+        self._exit_stack.close()
+        # In case the context is reused, create a new exit stack.
+        self._exit_stack = ExitStack()
+
+    @property
+    def command_path(self) -> str:
+        """The computed command path.  This is used for the ``usage``
+        information on the help page.  It's automatically created by
+        combining the info names of the chain of contexts to the root.
+        """
+        rv = ""
+        if self.info_name is not None:
+            rv = self.info_name
+        if self.parent is not None:
+            parent_command_path = [self.parent.command_path]
+
+            if isinstance(self.parent.command, Command):
+                for param in self.parent.command.get_params(self):
+                    parent_command_path.extend(param.get_usage_pieces(self))
+
+            rv = f"{' '.join(parent_command_path)} {rv}"
+        return rv.lstrip()
+
+    def find_root(self) -> "Context":
+        """Finds the outermost context."""
+        node = self
+        while node.parent is not None:
+            node = node.parent
+        return node
+
+    def find_object(self, object_type: t.Type[V]) -> t.Optional[V]:
+        """Finds the closest object of a given type."""
+        node: t.Optional["Context"] = self
+
+        while node is not None:
+            if isinstance(node.obj, object_type):
+                return node.obj
+
+            node = node.parent
+
+        return None
+
+    def ensure_object(self, object_type: t.Type[V]) -> V:
+        """Like :meth:`find_object` but sets the innermost object to a
+        new instance of `object_type` if it does not exist.
+        """
+        rv = self.find_object(object_type)
+        if rv is None:
+            self.obj = rv = object_type()
+        return rv
+
+    @t.overload
+    def lookup_default(
+        self, name: str, call: "te.Literal[True]" = True
+    ) -> t.Optional[t.Any]:
+        ...
+
+    @t.overload
+    def lookup_default(
+        self, name: str, call: "te.Literal[False]" = ...
+    ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
+        ...
+
+    def lookup_default(self, name: str, call: bool = True) -> t.Optional[t.Any]:
+        """Get the default for a parameter from :attr:`default_map`.
+
+        :param name: Name of the parameter.
+        :param call: If the default is a callable, call it. Disable to
+            return the callable instead.
+
+        .. versionchanged:: 8.0
+            Added the ``call`` parameter.
+        """
+        if self.default_map is not None:
+            value = self.default_map.get(name)
+
+            if call and callable(value):
+                return value()
+
+            return value
+
+        return None
+
+    def fail(self, message: str) -> "te.NoReturn":
+        """Aborts the execution of the program with a specific error
+        message.
+
+        :param message: the error message to fail with.
+        """
+        raise UsageError(message, self)
+
+    def abort(self) -> "te.NoReturn":
+        """Aborts the script."""
+        raise Abort()
+
+    def exit(self, code: int = 0) -> "te.NoReturn":
+        """Exits the application with a given exit code."""
+        raise Exit(code)
+
+    def get_usage(self) -> str:
+        """Helper method to get formatted usage string for the current
+        context and command.
+        """
+        return self.command.get_usage(self)
+
+    def get_help(self) -> str:
+        """Helper method to get formatted help page for the current
+        context and command.
+        """
+        return self.command.get_help(self)
+
+    def _make_sub_context(self, command: "Command") -> "Context":
+        """Create a new context of the same type as this context, but
+        for a new command.
+
+        :meta private:
+        """
+        return type(self)(command, info_name=command.name, parent=self)
+
+    def invoke(
+        __self,  # noqa: B902
+        __callback: t.Union["Command", t.Callable[..., t.Any]],
+        *args: t.Any,
+        **kwargs: t.Any,
+    ) -> t.Any:
+        """Invokes a command callback in exactly the way it expects.  There
+        are two ways to invoke this method:
+
+        1.  the first argument can be a callback and all other arguments and
+            keyword arguments are forwarded directly to the function.
+        2.  the first argument is a click command object.  In that case all
+            arguments are forwarded as well but proper click parameters
+            (options and click arguments) must be keyword arguments and Click
+            will fill in defaults.
+
+        Note that before Click 3.2 keyword arguments were not properly filled
+        in against the intention of this code and no context was created.  For
+        more information about this change and why it was done in a bugfix
+        release see :ref:`upgrade-to-3.2`.
+
+        .. versionchanged:: 8.0
+            All ``kwargs`` are tracked in :attr:`params` so they will be
+            passed if :meth:`forward` is called at multiple levels.
+        """
+        if isinstance(__callback, Command):
+            other_cmd = __callback
+
+            if other_cmd.callback is None:
+                raise TypeError(
+                    "The given command does not have a callback that can be invoked."
+                )
+            else:
+                __callback = other_cmd.callback
+
+            ctx = __self._make_sub_context(other_cmd)
+
+            for param in other_cmd.params:
+                if param.name not in kwargs and param.expose_value:
+                    kwargs[param.name] = param.type_cast_value(  # type: ignore
+                        ctx, param.get_default(ctx)
+                    )
+
+            # Track all kwargs as params, so that forward() will pass
+            # them on in subsequent calls.
+            ctx.params.update(kwargs)
+        else:
+            ctx = __self
+
+        with augment_usage_errors(__self):
+            with ctx:
+                return __callback(*args, **kwargs)
+
+    def forward(
+        __self, __cmd: "Command", *args: t.Any, **kwargs: t.Any  # noqa: B902
+    ) -> t.Any:
+        """Similar to :meth:`invoke` but fills in default keyword
+        arguments from the current context if the other command expects
+        it.  This cannot invoke callbacks directly, only other commands.
+
+        .. versionchanged:: 8.0
+            All ``kwargs`` are tracked in :attr:`params` so they will be
+            passed if ``forward`` is called at multiple levels.
+        """
+        # Can only forward to other commands, not direct callbacks.
+        if not isinstance(__cmd, Command):
+            raise TypeError("Callback is not a command.")
+
+        for param in __self.params:
+            if param not in kwargs:
+                kwargs[param] = __self.params[param]
+
+        return __self.invoke(__cmd, *args, **kwargs)
+
+    def set_parameter_source(self, name: str, source: ParameterSource) -> None:
+        """Set the source of a parameter. This indicates the location
+        from which the value of the parameter was obtained.
+
+        :param name: The name of the parameter.
+        :param source: A member of :class:`~click.core.ParameterSource`.
+        """
+        self._parameter_source[name] = source
+
+    def get_parameter_source(self, name: str) -> t.Optional[ParameterSource]:
+        """Get the source of a parameter. This indicates the location
+        from which the value of the parameter was obtained.
+
+        This can be useful for determining when a user specified a value
+        on the command line that is the same as the default value. It
+        will be :attr:`~click.core.ParameterSource.DEFAULT` only if the
+        value was actually taken from the default.
+
+        :param name: The name of the parameter.
+        :rtype: ParameterSource
+
+        .. versionchanged:: 8.0
+            Returns ``None`` if the parameter was not provided from any
+            source.
+        """
+        return self._parameter_source.get(name)
+
+
+class BaseCommand:
+    """The base command implements the minimal API contract of commands.
+    Most code will never use this as it does not implement a lot of useful
+    functionality but it can act as the direct subclass of alternative
+    parsing methods that do not depend on the Click parser.
+
+    For instance, this can be used to bridge Click and other systems like
+    argparse or docopt.
+
+    Because base commands do not implement a lot of the API that other
+    parts of Click take for granted, they are not supported for all
+    operations.  For instance, they cannot be used with the decorators
+    usually and they have no built-in callback system.
+
+    .. versionchanged:: 2.0
+       Added the `context_settings` parameter.
+
+    :param name: the name of the command to use unless a group overrides it.
+    :param context_settings: an optional dictionary with defaults that are
+                             passed to the context object.
+    """
+
+    #: The context class to create with :meth:`make_context`.
+    #:
+    #: .. versionadded:: 8.0
+    context_class: t.Type[Context] = Context
+    #: the default for the :attr:`Context.allow_extra_args` flag.
+    allow_extra_args = False
+    #: the default for the :attr:`Context.allow_interspersed_args` flag.
+    allow_interspersed_args = True
+    #: the default for the :attr:`Context.ignore_unknown_options` flag.
+    ignore_unknown_options = False
+
+    def __init__(
+        self,
+        name: t.Optional[str],
+        context_settings: t.Optional[t.Dict[str, t.Any]] = None,
+    ) -> None:
+        #: the name the command thinks it has.  Upon registering a command
+        #: on a :class:`Group` the group will default the command name
+        #: with this information.  You should instead use the
+        #: :class:`Context`\'s :attr:`~Context.info_name` attribute.
+        self.name = name
+
+        if context_settings is None:
+            context_settings = {}
+
+        #: an optional dictionary with defaults passed to the context.
+        self.context_settings: t.Dict[str, t.Any] = context_settings
+
+    def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
+        """Gather information that could be useful for a tool generating
+        user-facing documentation. This traverses the entire structure
+        below this command.
+
+        Use :meth:`click.Context.to_info_dict` to traverse the entire
+        CLI structure.
+
+        :param ctx: A :class:`Context` representing this command.
+
+        .. versionadded:: 8.0
+        """
+        return {"name": self.name}
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} {self.name}>"
+
+    def get_usage(self, ctx: Context) -> str:
+        raise NotImplementedError("Base commands cannot get usage")
+
+    def get_help(self, ctx: Context) -> str:
+        raise NotImplementedError("Base commands cannot get help")
+
+    def make_context(
+        self,
+        info_name: t.Optional[str],
+        args: t.List[str],
+        parent: t.Optional[Context] = None,
+        **extra: t.Any,
+    ) -> Context:
+        """This function when given an info name and arguments will kick
+        off the parsing and create a new :class:`Context`.  It does not
+        invoke the actual command callback though.
+
+        To quickly customize the context class used without overriding
+        this method, set the :attr:`context_class` attribute.
+
+        :param info_name: the info name for this invocation.  Generally this
+                          is the most descriptive name for the script or
+                          command.  For the toplevel script it's usually
+                          the name of the script, for commands below it it's
+                          the name of the command.
+        :param args: the arguments to parse as list of strings.
+        :param parent: the parent context if available.
+        :param extra: extra keyword arguments forwarded to the context
+                      constructor.
+
+        .. versionchanged:: 8.0
+            Added the :attr:`context_class` attribute.
+        """
+        for key, value in self.context_settings.items():
+            if key not in extra:
+                extra[key] = value
+
+        ctx = self.context_class(
+            self, info_name=info_name, parent=parent, **extra  # type: ignore
+        )
+
+        with ctx.scope(cleanup=False):
+            self.parse_args(ctx, args)
+        return ctx
+
+    def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
+        """Given a context and a list of arguments this creates the parser
+        and parses the arguments, then modifies the context as necessary.
+        This is automatically invoked by :meth:`make_context`.
+        """
+        raise NotImplementedError("Base commands do not know how to parse arguments.")
+
+    def invoke(self, ctx: Context) -> t.Any:
+        """Given a context, this invokes the command.  The default
+        implementation is raising a not implemented error.
+        """
+        raise NotImplementedError("Base commands are not invokable by default")
+
+    def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
+        """Return a list of completions for the incomplete value. Looks
+        at the names of chained multi-commands.
+
+        Any command could be part of a chained multi-command, so sibling
+        commands are valid at any point during command completion. Other
+        command classes will return more completions.
+
+        :param ctx: Invocation context for this command.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        from click.shell_completion import CompletionItem
+
+        results: t.List["CompletionItem"] = []
+
+        while ctx.parent is not None:
+            ctx = ctx.parent
+
+            if isinstance(ctx.command, MultiCommand) and ctx.command.chain:
+                results.extend(
+                    CompletionItem(name, help=command.get_short_help_str())
+                    for name, command in _complete_visible_commands(ctx, incomplete)
+                    if name not in ctx.protected_args
+                )
+
+        return results
+
+    @t.overload
+    def main(
+        self,
+        args: t.Optional[t.Sequence[str]] = None,
+        prog_name: t.Optional[str] = None,
+        complete_var: t.Optional[str] = None,
+        standalone_mode: "te.Literal[True]" = True,
+        **extra: t.Any,
+    ) -> "te.NoReturn":
+        ...
+
+    @t.overload
+    def main(
+        self,
+        args: t.Optional[t.Sequence[str]] = None,
+        prog_name: t.Optional[str] = None,
+        complete_var: t.Optional[str] = None,
+        standalone_mode: bool = ...,
+        **extra: t.Any,
+    ) -> t.Any:
+        ...
+
+    def main(
+        self,
+        args: t.Optional[t.Sequence[str]] = None,
+        prog_name: t.Optional[str] = None,
+        complete_var: t.Optional[str] = None,
+        standalone_mode: bool = True,
+        windows_expand_args: bool = True,
+        **extra: t.Any,
+    ) -> t.Any:
+        """This is the way to invoke a script with all the bells and
+        whistles as a command line application.  This will always terminate
+        the application after a call.  If this is not wanted, ``SystemExit``
+        needs to be caught.
+
+        This method is also available by directly calling the instance of
+        a :class:`Command`.
+
+        :param args: the arguments that should be used for parsing.  If not
+                     provided, ``sys.argv[1:]`` is used.
+        :param prog_name: the program name that should be used.  By default
+                          the program name is constructed by taking the file
+                          name from ``sys.argv[0]``.
+        :param complete_var: the environment variable that controls the
+                             bash completion support.  The default is
+                             ``"_<prog_name>_COMPLETE"`` with prog_name in
+                             uppercase.
+        :param standalone_mode: the default behavior is to invoke the script
+                                in standalone mode.  Click will then
+                                handle exceptions and convert them into
+                                error messages and the function will never
+                                return but shut down the interpreter.  If
+                                this is set to `False` they will be
+                                propagated to the caller and the return
+                                value of this function is the return value
+                                of :meth:`invoke`.
+        :param windows_expand_args: Expand glob patterns, user dir, and
+            env vars in command line args on Windows.
+        :param extra: extra keyword arguments are forwarded to the context
+                      constructor.  See :class:`Context` for more information.
+
+        .. versionchanged:: 8.0.1
+            Added the ``windows_expand_args`` parameter to allow
+            disabling command line arg expansion on Windows.
+
+        .. versionchanged:: 8.0
+            When taking arguments from ``sys.argv`` on Windows, glob
+            patterns, user dir, and env vars are expanded.
+
+        .. versionchanged:: 3.0
+           Added the ``standalone_mode`` parameter.
+        """
+        if args is None:
+            args = sys.argv[1:]
+
+            if os.name == "nt" and windows_expand_args:
+                args = _expand_args(args)
+        else:
+            args = list(args)
+
+        if prog_name is None:
+            prog_name = _detect_program_name()
+
+        # Process shell completion requests and exit early.
+        self._main_shell_completion(extra, prog_name, complete_var)
+
+        try:
+            try:
+                with self.make_context(prog_name, args, **extra) as ctx:
+                    rv = self.invoke(ctx)
+                    if not standalone_mode:
+                        return rv
+                    # it's not safe to `ctx.exit(rv)` here!
+                    # note that `rv` may actually contain data like "1" which
+                    # has obvious effects
+                    # more subtle case: `rv=[None, None]` can come out of
+                    # chained commands which all returned `None` -- so it's not
+                    # even always obvious that `rv` indicates success/failure
+                    # by its truthiness/falsiness
+                    ctx.exit()
+            except (EOFError, KeyboardInterrupt):
+                echo(file=sys.stderr)
+                raise Abort() from None
+            except ClickException as e:
+                if not standalone_mode:
+                    raise
+                e.show()
+                sys.exit(e.exit_code)
+            except OSError as e:
+                if e.errno == errno.EPIPE:
+                    sys.stdout = t.cast(t.TextIO, PacifyFlushWrapper(sys.stdout))
+                    sys.stderr = t.cast(t.TextIO, PacifyFlushWrapper(sys.stderr))
+                    sys.exit(1)
+                else:
+                    raise
+        except Exit as e:
+            if standalone_mode:
+                sys.exit(e.exit_code)
+            else:
+                # in non-standalone mode, return the exit code
+                # note that this is only reached if `self.invoke` above raises
+                # an Exit explicitly -- thus bypassing the check there which
+                # would return its result
+                # the results of non-standalone execution may therefore be
+                # somewhat ambiguous: if there are codepaths which lead to
+                # `ctx.exit(1)` and to `return 1`, the caller won't be able to
+                # tell the difference between the two
+                return e.exit_code
+        except Abort:
+            if not standalone_mode:
+                raise
+            echo(_("Aborted!"), file=sys.stderr)
+            sys.exit(1)
+
+    def _main_shell_completion(
+        self,
+        ctx_args: t.Dict[str, t.Any],
+        prog_name: str,
+        complete_var: t.Optional[str] = None,
+    ) -> None:
+        """Check if the shell is asking for tab completion, process
+        that, then exit early. Called from :meth:`main` before the
+        program is invoked.
+
+        :param prog_name: Name of the executable in the shell.
+        :param complete_var: Name of the environment variable that holds
+            the completion instruction. Defaults to
+            ``_{PROG_NAME}_COMPLETE``.
+        """
+        if complete_var is None:
+            complete_var = f"_{prog_name}_COMPLETE".replace("-", "_").upper()
+
+        instruction = os.environ.get(complete_var)
+
+        if not instruction:
+            return
+
+        from .shell_completion import shell_complete
+
+        rv = shell_complete(self, ctx_args, prog_name, complete_var, instruction)
+        sys.exit(rv)
+
+    def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        """Alias for :meth:`main`."""
+        return self.main(*args, **kwargs)
+
+
+class Command(BaseCommand):
+    """Commands are the basic building block of command line interfaces in
+    Click.  A basic command handles command line parsing and might dispatch
+    more parsing to commands nested below it.
+
+    :param name: the name of the command to use unless a group overrides it.
+    :param context_settings: an optional dictionary with defaults that are
+                             passed to the context object.
+    :param callback: the callback to invoke.  This is optional.
+    :param params: the parameters to register with this command.  This can
+                   be either :class:`Option` or :class:`Argument` objects.
+    :param help: the help string to use for this command.
+    :param epilog: like the help string but it's printed at the end of the
+                   help page after everything else.
+    :param short_help: the short help to use for this command.  This is
+                       shown on the command listing of the parent command.
+    :param add_help_option: by default each command registers a ``--help``
+                            option.  This can be disabled by this parameter.
+    :param no_args_is_help: this controls what happens if no arguments are
+                            provided.  This option is disabled by default.
+                            If enabled this will add ``--help`` as argument
+                            if no arguments are passed
+    :param hidden: hide this command from help outputs.
+
+    :param deprecated: issues a message indicating that
+                             the command is deprecated.
+
+    .. versionchanged:: 8.1
+        ``help``, ``epilog``, and ``short_help`` are stored unprocessed,
+        all formatting is done when outputting help text, not at init,
+        and is done even if not using the ``@command`` decorator.
+
+    .. versionchanged:: 8.0
+        Added a ``repr`` showing the command name.
+
+    .. versionchanged:: 7.1
+        Added the ``no_args_is_help`` parameter.
+
+    .. versionchanged:: 2.0
+        Added the ``context_settings`` parameter.
+    """
+
+    def __init__(
+        self,
+        name: t.Optional[str],
+        context_settings: t.Optional[t.Dict[str, t.Any]] = None,
+        callback: t.Optional[t.Callable[..., t.Any]] = None,
+        params: t.Optional[t.List["Parameter"]] = None,
+        help: t.Optional[str] = None,
+        epilog: t.Optional[str] = None,
+        short_help: t.Optional[str] = None,
+        options_metavar: t.Optional[str] = "[OPTIONS]",
+        add_help_option: bool = True,
+        no_args_is_help: bool = False,
+        hidden: bool = False,
+        deprecated: bool = False,
+    ) -> None:
+        super().__init__(name, context_settings)
+        #: the callback to execute when the command fires.  This might be
+        #: `None` in which case nothing happens.
+        self.callback = callback
+        #: the list of parameters for this command in the order they
+        #: should show up in the help page and execute.  Eager parameters
+        #: will automatically be handled before non eager ones.
+        self.params: t.List["Parameter"] = params or []
+        self.help = help
+        self.epilog = epilog
+        self.options_metavar = options_metavar
+        self.short_help = short_help
+        self.add_help_option = add_help_option
+        self.no_args_is_help = no_args_is_help
+        self.hidden = hidden
+        self.deprecated = deprecated
+
+    def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
+        info_dict = super().to_info_dict(ctx)
+        info_dict.update(
+            params=[param.to_info_dict() for param in self.get_params(ctx)],
+            help=self.help,
+            epilog=self.epilog,
+            short_help=self.short_help,
+            hidden=self.hidden,
+            deprecated=self.deprecated,
+        )
+        return info_dict
+
+    def get_usage(self, ctx: Context) -> str:
+        """Formats the usage line into a string and returns it.
+
+        Calls :meth:`format_usage` internally.
+        """
+        formatter = ctx.make_formatter()
+        self.format_usage(ctx, formatter)
+        return formatter.getvalue().rstrip("\n")
+
+    def get_params(self, ctx: Context) -> t.List["Parameter"]:
+        rv = self.params
+        help_option = self.get_help_option(ctx)
+
+        if help_option is not None:
+            rv = [*rv, help_option]
+
+        return rv
+
+    def format_usage(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Writes the usage line into the formatter.
+
+        This is a low-level method called by :meth:`get_usage`.
+        """
+        pieces = self.collect_usage_pieces(ctx)
+        formatter.write_usage(ctx.command_path, " ".join(pieces))
+
+    def collect_usage_pieces(self, ctx: Context) -> t.List[str]:
+        """Returns all the pieces that go into the usage line and returns
+        it as a list of strings.
+        """
+        rv = [self.options_metavar] if self.options_metavar else []
+
+        for param in self.get_params(ctx):
+            rv.extend(param.get_usage_pieces(ctx))
+
+        return rv
+
+    def get_help_option_names(self, ctx: Context) -> t.List[str]:
+        """Returns the names for the help option."""
+        all_names = set(ctx.help_option_names)
+        for param in self.params:
+            all_names.difference_update(param.opts)
+            all_names.difference_update(param.secondary_opts)
+        return list(all_names)
+
+    def get_help_option(self, ctx: Context) -> t.Optional["Option"]:
+        """Returns the help option object."""
+        help_options = self.get_help_option_names(ctx)
+
+        if not help_options or not self.add_help_option:
+            return None
+
+        def show_help(ctx: Context, param: "Parameter", value: str) -> None:
+            if value and not ctx.resilient_parsing:
+                echo(ctx.get_help(), color=ctx.color)
+                ctx.exit()
+
+        return Option(
+            help_options,
+            is_flag=True,
+            is_eager=True,
+            expose_value=False,
+            callback=show_help,
+            help=_("Show this message and exit."),
+        )
+
+    def make_parser(self, ctx: Context) -> OptionParser:
+        """Creates the underlying option parser for this command."""
+        parser = OptionParser(ctx)
+        for param in self.get_params(ctx):
+            param.add_to_parser(parser, ctx)
+        return parser
+
+    def get_help(self, ctx: Context) -> str:
+        """Formats the help into a string and returns it.
+
+        Calls :meth:`format_help` internally.
+        """
+        formatter = ctx.make_formatter()
+        self.format_help(ctx, formatter)
+        return formatter.getvalue().rstrip("\n")
+
+    def get_short_help_str(self, limit: int = 45) -> str:
+        """Gets short help for the command or makes it by shortening the
+        long help string.
+        """
+        if self.short_help:
+            text = inspect.cleandoc(self.short_help)
+        elif self.help:
+            text = make_default_short_help(self.help, limit)
+        else:
+            text = ""
+
+        if self.deprecated:
+            text = _("(Deprecated) {text}").format(text=text)
+
+        return text.strip()
+
+    def format_help(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Writes the help into the formatter if it exists.
+
+        This is a low-level method called by :meth:`get_help`.
+
+        This calls the following methods:
+
+        -   :meth:`format_usage`
+        -   :meth:`format_help_text`
+        -   :meth:`format_options`
+        -   :meth:`format_epilog`
+        """
+        self.format_usage(ctx, formatter)
+        self.format_help_text(ctx, formatter)
+        self.format_options(ctx, formatter)
+        self.format_epilog(ctx, formatter)
+
+    def format_help_text(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Writes the help text to the formatter if it exists."""
+        text = self.help if self.help is not None else ""
+
+        if self.deprecated:
+            text = _("(Deprecated) {text}").format(text=text)
+
+        if text:
+            text = inspect.cleandoc(text).partition("\f")[0]
+            formatter.write_paragraph()
+
+            with formatter.indentation():
+                formatter.write_text(text)
+
+    def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Writes all the options into the formatter if they exist."""
+        opts = []
+        for param in self.get_params(ctx):
+            rv = param.get_help_record(ctx)
+            if rv is not None:
+                opts.append(rv)
+
+        if opts:
+            with formatter.section(_("Options")):
+                formatter.write_dl(opts)
+
+    def format_epilog(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Writes the epilog into the formatter if it exists."""
+        if self.epilog:
+            epilog = inspect.cleandoc(self.epilog)
+            formatter.write_paragraph()
+
+            with formatter.indentation():
+                formatter.write_text(epilog)
+
+    def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
+        if not args and self.no_args_is_help and not ctx.resilient_parsing:
+            echo(ctx.get_help(), color=ctx.color)
+            ctx.exit()
+
+        parser = self.make_parser(ctx)
+        opts, args, param_order = parser.parse_args(args=args)
+
+        for param in iter_params_for_processing(param_order, self.get_params(ctx)):
+            value, args = param.handle_parse_result(ctx, opts, args)
+
+        if args and not ctx.allow_extra_args and not ctx.resilient_parsing:
+            ctx.fail(
+                ngettext(
+                    "Got unexpected extra argument ({args})",
+                    "Got unexpected extra arguments ({args})",
+                    len(args),
+                ).format(args=" ".join(map(str, args)))
+            )
+
+        ctx.args = args
+        ctx._opt_prefixes.update(parser._opt_prefixes)
+        return args
+
+    def invoke(self, ctx: Context) -> t.Any:
+        """Given a context, this invokes the attached callback (if it exists)
+        in the right way.
+        """
+        if self.deprecated:
+            message = _(
+                "DeprecationWarning: The command {name!r} is deprecated."
+            ).format(name=self.name)
+            echo(style(message, fg="red"), err=True)
+
+        if self.callback is not None:
+            return ctx.invoke(self.callback, **ctx.params)
+
+    def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
+        """Return a list of completions for the incomplete value. Looks
+        at the names of options and chained multi-commands.
+
+        :param ctx: Invocation context for this command.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        from click.shell_completion import CompletionItem
+
+        results: t.List["CompletionItem"] = []
+
+        if incomplete and not incomplete[0].isalnum():
+            for param in self.get_params(ctx):
+                if (
+                    not isinstance(param, Option)
+                    or param.hidden
+                    or (
+                        not param.multiple
+                        and ctx.get_parameter_source(param.name)  # type: ignore
+                        is ParameterSource.COMMANDLINE
+                    )
+                ):
+                    continue
+
+                results.extend(
+                    CompletionItem(name, help=param.help)
+                    for name in [*param.opts, *param.secondary_opts]
+                    if name.startswith(incomplete)
+                )
+
+        results.extend(super().shell_complete(ctx, incomplete))
+        return results
+
+
+class MultiCommand(Command):
+    """A multi command is the basic implementation of a command that
+    dispatches to subcommands.  The most common version is the
+    :class:`Group`.
+
+    :param invoke_without_command: this controls how the multi command itself
+                                   is invoked.  By default it's only invoked
+                                   if a subcommand is provided.
+    :param no_args_is_help: this controls what happens if no arguments are
+                            provided.  This option is enabled by default if
+                            `invoke_without_command` is disabled or disabled
+                            if it's enabled.  If enabled this will add
+                            ``--help`` as argument if no arguments are
+                            passed.
+    :param subcommand_metavar: the string that is used in the documentation
+                               to indicate the subcommand place.
+    :param chain: if this is set to `True` chaining of multiple subcommands
+                  is enabled.  This restricts the form of commands in that
+                  they cannot have optional arguments but it allows
+                  multiple commands to be chained together.
+    :param result_callback: The result callback to attach to this multi
+        command. This can be set or changed later with the
+        :meth:`result_callback` decorator.
+    """
+
+    allow_extra_args = True
+    allow_interspersed_args = False
+
+    def __init__(
+        self,
+        name: t.Optional[str] = None,
+        invoke_without_command: bool = False,
+        no_args_is_help: t.Optional[bool] = None,
+        subcommand_metavar: t.Optional[str] = None,
+        chain: bool = False,
+        result_callback: t.Optional[t.Callable[..., t.Any]] = None,
+        **attrs: t.Any,
+    ) -> None:
+        super().__init__(name, **attrs)
+
+        if no_args_is_help is None:
+            no_args_is_help = not invoke_without_command
+
+        self.no_args_is_help = no_args_is_help
+        self.invoke_without_command = invoke_without_command
+
+        if subcommand_metavar is None:
+            if chain:
+                subcommand_metavar = "COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]..."
+            else:
+                subcommand_metavar = "COMMAND [ARGS]..."
+
+        self.subcommand_metavar = subcommand_metavar
+        self.chain = chain
+        # The result callback that is stored. This can be set or
+        # overridden with the :func:`result_callback` decorator.
+        self._result_callback = result_callback
+
+        if self.chain:
+            for param in self.params:
+                if isinstance(param, Argument) and not param.required:
+                    raise RuntimeError(
+                        "Multi commands in chain mode cannot have"
+                        " optional arguments."
+                    )
+
+    def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
+        info_dict = super().to_info_dict(ctx)
+        commands = {}
+
+        for name in self.list_commands(ctx):
+            command = self.get_command(ctx, name)
+
+            if command is None:
+                continue
+
+            sub_ctx = ctx._make_sub_context(command)
+
+            with sub_ctx.scope(cleanup=False):
+                commands[name] = command.to_info_dict(sub_ctx)
+
+        info_dict.update(commands=commands, chain=self.chain)
+        return info_dict
+
+    def collect_usage_pieces(self, ctx: Context) -> t.List[str]:
+        rv = super().collect_usage_pieces(ctx)
+        rv.append(self.subcommand_metavar)
+        return rv
+
+    def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:
+        super().format_options(ctx, formatter)
+        self.format_commands(ctx, formatter)
+
+    def result_callback(self, replace: bool = False) -> t.Callable[[F], F]:
+        """Adds a result callback to the command.  By default if a
+        result callback is already registered this will chain them but
+        this can be disabled with the `replace` parameter.  The result
+        callback is invoked with the return value of the subcommand
+        (or the list of return values from all subcommands if chaining
+        is enabled) as well as the parameters as they would be passed
+        to the main callback.
+
+        Example::
+
+            @click.group()
+            @click.option('-i', '--input', default=23)
+            def cli(input):
+                return 42
+
+            @cli.result_callback()
+            def process_result(result, input):
+                return result + input
+
+        :param replace: if set to `True` an already existing result
+                        callback will be removed.
+
+        .. versionchanged:: 8.0
+            Renamed from ``resultcallback``.
+
+        .. versionadded:: 3.0
+        """
+
+        def decorator(f: F) -> F:
+            old_callback = self._result_callback
+
+            if old_callback is None or replace:
+                self._result_callback = f
+                return f
+
+            def function(__value, *args, **kwargs):  # type: ignore
+                inner = old_callback(__value, *args, **kwargs)  # type: ignore
+                return f(inner, *args, **kwargs)
+
+            self._result_callback = rv = update_wrapper(t.cast(F, function), f)
+            return rv
+
+        return decorator
+
+    def format_commands(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Extra format methods for multi methods that adds all the commands
+        after the options.
+        """
+        commands = []
+        for subcommand in self.list_commands(ctx):
+            cmd = self.get_command(ctx, subcommand)
+            # What is this, the tool lied about a command.  Ignore it
+            if cmd is None:
+                continue
+            if cmd.hidden:
+                continue
+
+            commands.append((subcommand, cmd))
+
+        # allow for 3 times the default spacing
+        if len(commands):
+            limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)
+
+            rows = []
+            for subcommand, cmd in commands:
+                help = cmd.get_short_help_str(limit)
+                rows.append((subcommand, help))
+
+            if rows:
+                with formatter.section(_("Commands")):
+                    formatter.write_dl(rows)
+
+    def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
+        if not args and self.no_args_is_help and not ctx.resilient_parsing:
+            echo(ctx.get_help(), color=ctx.color)
+            ctx.exit()
+
+        rest = super().parse_args(ctx, args)
+
+        if self.chain:
+            ctx.protected_args = rest
+            ctx.args = []
+        elif rest:
+            ctx.protected_args, ctx.args = rest[:1], rest[1:]
+
+        return ctx.args
+
+    def invoke(self, ctx: Context) -> t.Any:
+        def _process_result(value: t.Any) -> t.Any:
+            if self._result_callback is not None:
+                value = ctx.invoke(self._result_callback, value, **ctx.params)
+            return value
+
+        if not ctx.protected_args:
+            if self.invoke_without_command:
+                # No subcommand was invoked, so the result callback is
+                # invoked with the group return value for regular
+                # groups, or an empty list for chained groups.
+                with ctx:
+                    rv = super().invoke(ctx)
+                    return _process_result([] if self.chain else rv)
+            ctx.fail(_("Missing command."))
+
+        # Fetch args back out
+        args = [*ctx.protected_args, *ctx.args]
+        ctx.args = []
+        ctx.protected_args = []
+
+        # If we're not in chain mode, we only allow the invocation of a
+        # single command but we also inform the current context about the
+        # name of the command to invoke.
+        if not self.chain:
+            # Make sure the context is entered so we do not clean up
+            # resources until the result processor has worked.
+            with ctx:
+                cmd_name, cmd, args = self.resolve_command(ctx, args)
+                assert cmd is not None
+                ctx.invoked_subcommand = cmd_name
+                super().invoke(ctx)
+                sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)
+                with sub_ctx:
+                    return _process_result(sub_ctx.command.invoke(sub_ctx))
+
+        # In chain mode we create the contexts step by step, but after the
+        # base command has been invoked.  Because at that point we do not
+        # know the subcommands yet, the invoked subcommand attribute is
+        # set to ``*`` to inform the command that subcommands are executed
+        # but nothing else.
+        with ctx:
+            ctx.invoked_subcommand = "*" if args else None
+            super().invoke(ctx)
+
+            # Otherwise we make every single context and invoke them in a
+            # chain.  In that case the return value to the result processor
+            # is the list of all invoked subcommand's results.
+            contexts = []
+            while args:
+                cmd_name, cmd, args = self.resolve_command(ctx, args)
+                assert cmd is not None
+                sub_ctx = cmd.make_context(
+                    cmd_name,
+                    args,
+                    parent=ctx,
+                    allow_extra_args=True,
+                    allow_interspersed_args=False,
+                )
+                contexts.append(sub_ctx)
+                args, sub_ctx.args = sub_ctx.args, []
+
+            rv = []
+            for sub_ctx in contexts:
+                with sub_ctx:
+                    rv.append(sub_ctx.command.invoke(sub_ctx))
+            return _process_result(rv)
+
+    def resolve_command(
+        self, ctx: Context, args: t.List[str]
+    ) -> t.Tuple[t.Optional[str], t.Optional[Command], t.List[str]]:
+        cmd_name = make_str(args[0])
+        original_cmd_name = cmd_name
+
+        # Get the command
+        cmd = self.get_command(ctx, cmd_name)
+
+        # If we can't find the command but there is a normalization
+        # function available, we try with that one.
+        if cmd is None and ctx.token_normalize_func is not None:
+            cmd_name = ctx.token_normalize_func(cmd_name)
+            cmd = self.get_command(ctx, cmd_name)
+
+        # If we don't find the command we want to show an error message
+        # to the user that it was not provided.  However, there is
+        # something else we should do: if the first argument looks like
+        # an option we want to kick off parsing again for arguments to
+        # resolve things like --help which now should go to the main
+        # place.
+        if cmd is None and not ctx.resilient_parsing:
+            if split_opt(cmd_name)[0]:
+                self.parse_args(ctx, ctx.args)
+            ctx.fail(_("No such command {name!r}.").format(name=original_cmd_name))
+        return cmd_name if cmd else None, cmd, args[1:]
+
+    def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
+        """Given a context and a command name, this returns a
+        :class:`Command` object if it exists or returns `None`.
+        """
+        raise NotImplementedError
+
+    def list_commands(self, ctx: Context) -> t.List[str]:
+        """Returns a list of subcommand names in the order they should
+        appear.
+        """
+        return []
+
+    def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
+        """Return a list of completions for the incomplete value. Looks
+        at the names of options, subcommands, and chained
+        multi-commands.
+
+        :param ctx: Invocation context for this command.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        from click.shell_completion import CompletionItem
+
+        results = [
+            CompletionItem(name, help=command.get_short_help_str())
+            for name, command in _complete_visible_commands(ctx, incomplete)
+        ]
+        results.extend(super().shell_complete(ctx, incomplete))
+        return results
+
+
+class Group(MultiCommand):
+    """A group allows a command to have subcommands attached. This is
+    the most common way to implement nesting in Click.
+
+    :param name: The name of the group command.
+    :param commands: A dict mapping names to :class:`Command` objects.
+        Can also be a list of :class:`Command`, which will use
+        :attr:`Command.name` to create the dict.
+    :param attrs: Other command arguments described in
+        :class:`MultiCommand`, :class:`Command`, and
+        :class:`BaseCommand`.
+
+    .. versionchanged:: 8.0
+        The ``commmands`` argument can be a list of command objects.
+    """
+
+    #: If set, this is used by the group's :meth:`command` decorator
+    #: as the default :class:`Command` class. This is useful to make all
+    #: subcommands use a custom command class.
+    #:
+    #: .. versionadded:: 8.0
+    command_class: t.Optional[t.Type[Command]] = None
+
+    #: If set, this is used by the group's :meth:`group` decorator
+    #: as the default :class:`Group` class. This is useful to make all
+    #: subgroups use a custom group class.
+    #:
+    #: If set to the special value :class:`type` (literally
+    #: ``group_class = type``), this group's class will be used as the
+    #: default class. This makes a custom group class continue to make
+    #: custom groups.
+    #:
+    #: .. versionadded:: 8.0
+    group_class: t.Optional[t.Union[t.Type["Group"], t.Type[type]]] = None
+    # Literal[type] isn't valid, so use Type[type]
+
+    def __init__(
+        self,
+        name: t.Optional[str] = None,
+        commands: t.Optional[t.Union[t.Dict[str, Command], t.Sequence[Command]]] = None,
+        **attrs: t.Any,
+    ) -> None:
+        super().__init__(name, **attrs)
+
+        if commands is None:
+            commands = {}
+        elif isinstance(commands, abc.Sequence):
+            commands = {c.name: c for c in commands if c.name is not None}
+
+        #: The registered subcommands by their exported names.
+        self.commands: t.Dict[str, Command] = commands
+
+    def add_command(self, cmd: Command, name: t.Optional[str] = None) -> None:
+        """Registers another :class:`Command` with this group.  If the name
+        is not provided, the name of the command is used.
+        """
+        name = name or cmd.name
+        if name is None:
+            raise TypeError("Command has no name.")
+        _check_multicommand(self, name, cmd, register=True)
+        self.commands[name] = cmd
+
+    @t.overload
+    def command(self, __func: t.Callable[..., t.Any]) -> Command:
+        ...
+
+    @t.overload
+    def command(
+        self, *args: t.Any, **kwargs: t.Any
+    ) -> t.Callable[[t.Callable[..., t.Any]], Command]:
+        ...
+
+    def command(
+        self, *args: t.Any, **kwargs: t.Any
+    ) -> t.Union[t.Callable[[t.Callable[..., t.Any]], Command], Command]:
+        """A shortcut decorator for declaring and attaching a command to
+        the group. This takes the same arguments as :func:`command` and
+        immediately registers the created command with this group by
+        calling :meth:`add_command`.
+
+        To customize the command class used, set the
+        :attr:`command_class` attribute.
+
+        .. versionchanged:: 8.1
+            This decorator can be applied without parentheses.
+
+        .. versionchanged:: 8.0
+            Added the :attr:`command_class` attribute.
+        """
+        from .decorators import command
+
+        if self.command_class and kwargs.get("cls") is None:
+            kwargs["cls"] = self.command_class
+
+        func: t.Optional[t.Callable] = None
+
+        if args and callable(args[0]):
+            assert (
+                len(args) == 1 and not kwargs
+            ), "Use 'command(**kwargs)(callable)' to provide arguments."
+            (func,) = args
+            args = ()
+
+        def decorator(f: t.Callable[..., t.Any]) -> Command:
+            cmd: Command = command(*args, **kwargs)(f)
+            self.add_command(cmd)
+            return cmd
+
+        if func is not None:
+            return decorator(func)
+
+        return decorator
+
+    @t.overload
+    def group(self, __func: t.Callable[..., t.Any]) -> "Group":
+        ...
+
+    @t.overload
+    def group(
+        self, *args: t.Any, **kwargs: t.Any
+    ) -> t.Callable[[t.Callable[..., t.Any]], "Group"]:
+        ...
+
+    def group(
+        self, *args: t.Any, **kwargs: t.Any
+    ) -> t.Union[t.Callable[[t.Callable[..., t.Any]], "Group"], "Group"]:
+        """A shortcut decorator for declaring and attaching a group to
+        the group. This takes the same arguments as :func:`group` and
+        immediately registers the created group with this group by
+        calling :meth:`add_command`.
+
+        To customize the group class used, set the :attr:`group_class`
+        attribute.
+
+        .. versionchanged:: 8.1
+            This decorator can be applied without parentheses.
+
+        .. versionchanged:: 8.0
+            Added the :attr:`group_class` attribute.
+        """
+        from .decorators import group
+
+        func: t.Optional[t.Callable] = None
+
+        if args and callable(args[0]):
+            assert (
+                len(args) == 1 and not kwargs
+            ), "Use 'group(**kwargs)(callable)' to provide arguments."
+            (func,) = args
+            args = ()
+
+        if self.group_class is not None and kwargs.get("cls") is None:
+            if self.group_class is type:
+                kwargs["cls"] = type(self)
+            else:
+                kwargs["cls"] = self.group_class
+
+        def decorator(f: t.Callable[..., t.Any]) -> "Group":
+            cmd: Group = group(*args, **kwargs)(f)
+            self.add_command(cmd)
+            return cmd
+
+        if func is not None:
+            return decorator(func)
+
+        return decorator
+
+    def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
+        return self.commands.get(cmd_name)
+
+    def list_commands(self, ctx: Context) -> t.List[str]:
+        return sorted(self.commands)
+
+
+class CommandCollection(MultiCommand):
+    """A command collection is a multi command that merges multiple multi
+    commands together into one.  This is a straightforward implementation
+    that accepts a list of different multi commands as sources and
+    provides all the commands for each of them.
+    """
+
+    def __init__(
+        self,
+        name: t.Optional[str] = None,
+        sources: t.Optional[t.List[MultiCommand]] = None,
+        **attrs: t.Any,
+    ) -> None:
+        super().__init__(name, **attrs)
+        #: The list of registered multi commands.
+        self.sources: t.List[MultiCommand] = sources or []
+
+    def add_source(self, multi_cmd: MultiCommand) -> None:
+        """Adds a new multi command to the chain dispatcher."""
+        self.sources.append(multi_cmd)
+
+    def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
+        for source in self.sources:
+            rv = source.get_command(ctx, cmd_name)
+
+            if rv is not None:
+                if self.chain:
+                    _check_multicommand(self, cmd_name, rv)
+
+                return rv
+
+        return None
+
+    def list_commands(self, ctx: Context) -> t.List[str]:
+        rv: t.Set[str] = set()
+
+        for source in self.sources:
+            rv.update(source.list_commands(ctx))
+
+        return sorted(rv)
+
+
+def _check_iter(value: t.Any) -> t.Iterator[t.Any]:
+    """Check if the value is iterable but not a string. Raises a type
+    error, or return an iterator over the value.
+    """
+    if isinstance(value, str):
+        raise TypeError
+
+    return iter(value)
+
+
+class Parameter:
+    r"""A parameter to a command comes in two versions: they are either
+    :class:`Option`\s or :class:`Argument`\s.  Other subclasses are currently
+    not supported by design as some of the internals for parsing are
+    intentionally not finalized.
+
+    Some settings are supported by both options and arguments.
+
+    :param param_decls: the parameter declarations for this option or
+                        argument.  This is a list of flags or argument
+                        names.
+    :param type: the type that should be used.  Either a :class:`ParamType`
+                 or a Python type.  The later is converted into the former
+                 automatically if supported.
+    :param required: controls if this is optional or not.
+    :param default: the default value if omitted.  This can also be a callable,
+                    in which case it's invoked when the default is needed
+                    without any arguments.
+    :param callback: A function to further process or validate the value
+        after type conversion. It is called as ``f(ctx, param, value)``
+        and must return the value. It is called for all sources,
+        including prompts.
+    :param nargs: the number of arguments to match.  If not ``1`` the return
+                  value is a tuple instead of single value.  The default for
+                  nargs is ``1`` (except if the type is a tuple, then it's
+                  the arity of the tuple). If ``nargs=-1``, all remaining
+                  parameters are collected.
+    :param metavar: how the value is represented in the help page.
+    :param expose_value: if this is `True` then the value is passed onwards
+                         to the command callback and stored on the context,
+                         otherwise it's skipped.
+    :param is_eager: eager values are processed before non eager ones.  This
+                     should not be set for arguments or it will inverse the
+                     order of processing.
+    :param envvar: a string or list of strings that are environment variables
+                   that should be checked.
+    :param shell_complete: A function that returns custom shell
+        completions. Used instead of the param's type completion if
+        given. Takes ``ctx, param, incomplete`` and must return a list
+        of :class:`~click.shell_completion.CompletionItem` or a list of
+        strings.
+
+    .. versionchanged:: 8.0
+        ``process_value`` validates required parameters and bounded
+        ``nargs``, and invokes the parameter callback before returning
+        the value. This allows the callback to validate prompts.
+        ``full_process_value`` is removed.
+
+    .. versionchanged:: 8.0
+        ``autocompletion`` is renamed to ``shell_complete`` and has new
+        semantics described above. The old name is deprecated and will
+        be removed in 8.1, until then it will be wrapped to match the
+        new requirements.
+
+    .. versionchanged:: 8.0
+        For ``multiple=True, nargs>1``, the default must be a list of
+        tuples.
+
+    .. versionchanged:: 8.0
+        Setting a default is no longer required for ``nargs>1``, it will
+        default to ``None``. ``multiple=True`` or ``nargs=-1`` will
+        default to ``()``.
+
+    .. versionchanged:: 7.1
+        Empty environment variables are ignored rather than taking the
+        empty string value. This makes it possible for scripts to clear
+        variables if they can't unset them.
+
+    .. versionchanged:: 2.0
+        Changed signature for parameter callback to also be passed the
+        parameter. The old callback format will still work, but it will
+        raise a warning to give you a chance to migrate the code easier.
+    """
+
+    param_type_name = "parameter"
+
+    def __init__(
+        self,
+        param_decls: t.Optional[t.Sequence[str]] = None,
+        type: t.Optional[t.Union[types.ParamType, t.Any]] = None,
+        required: bool = False,
+        default: t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]] = None,
+        callback: t.Optional[t.Callable[[Context, "Parameter", t.Any], t.Any]] = None,
+        nargs: t.Optional[int] = None,
+        multiple: bool = False,
+        metavar: t.Optional[str] = None,
+        expose_value: bool = True,
+        is_eager: bool = False,
+        envvar: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        shell_complete: t.Optional[
+            t.Callable[
+                [Context, "Parameter", str],
+                t.Union[t.List["CompletionItem"], t.List[str]],
+            ]
+        ] = None,
+    ) -> None:
+        self.name, self.opts, self.secondary_opts = self._parse_decls(
+            param_decls or (), expose_value
+        )
+        self.type = types.convert_type(type, default)
+
+        # Default nargs to what the type tells us if we have that
+        # information available.
+        if nargs is None:
+            if self.type.is_composite:
+                nargs = self.type.arity
+            else:
+                nargs = 1
+
+        self.required = required
+        self.callback = callback
+        self.nargs = nargs
+        self.multiple = multiple
+        self.expose_value = expose_value
+        self.default = default
+        self.is_eager = is_eager
+        self.metavar = metavar
+        self.envvar = envvar
+        self._custom_shell_complete = shell_complete
+
+        if __debug__:
+            if self.type.is_composite and nargs != self.type.arity:
+                raise ValueError(
+                    f"'nargs' must be {self.type.arity} (or None) for"
+                    f" type {self.type!r}, but it was {nargs}."
+                )
+
+            # Skip no default or callable default.
+            check_default = default if not callable(default) else None
+
+            if check_default is not None:
+                if multiple:
+                    try:
+                        # Only check the first value against nargs.
+                        check_default = next(_check_iter(check_default), None)
+                    except TypeError:
+                        raise ValueError(
+                            "'default' must be a list when 'multiple' is true."
+                        ) from None
+
+                # Can be None for multiple with empty default.
+                if nargs != 1 and check_default is not None:
+                    try:
+                        _check_iter(check_default)
+                    except TypeError:
+                        if multiple:
+                            message = (
+                                "'default' must be a list of lists when 'multiple' is"
+                                " true and 'nargs' != 1."
+                            )
+                        else:
+                            message = "'default' must be a list when 'nargs' != 1."
+
+                        raise ValueError(message) from None
+
+                    if nargs > 1 and len(check_default) != nargs:
+                        subject = "item length" if multiple else "length"
+                        raise ValueError(
+                            f"'default' {subject} must match nargs={nargs}."
+                        )
+
+    def to_info_dict(self) -> t.Dict[str, t.Any]:
+        """Gather information that could be useful for a tool generating
+        user-facing documentation.
+
+        Use :meth:`click.Context.to_info_dict` to traverse the entire
+        CLI structure.
+
+        .. versionadded:: 8.0
+        """
+        return {
+            "name": self.name,
+            "param_type_name": self.param_type_name,
+            "opts": self.opts,
+            "secondary_opts": self.secondary_opts,
+            "type": self.type.to_info_dict(),
+            "required": self.required,
+            "nargs": self.nargs,
+            "multiple": self.multiple,
+            "default": self.default,
+            "envvar": self.envvar,
+        }
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} {self.name}>"
+
+    def _parse_decls(
+        self, decls: t.Sequence[str], expose_value: bool
+    ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
+        raise NotImplementedError()
+
+    @property
+    def human_readable_name(self) -> str:
+        """Returns the human readable name of this parameter.  This is the
+        same as the name for options, but the metavar for arguments.
+        """
+        return self.name  # type: ignore
+
+    def make_metavar(self) -> str:
+        if self.metavar is not None:
+            return self.metavar
+
+        metavar = self.type.get_metavar(self)
+
+        if metavar is None:
+            metavar = self.type.name.upper()
+
+        if self.nargs != 1:
+            metavar += "..."
+
+        return metavar
+
+    @t.overload
+    def get_default(
+        self, ctx: Context, call: "te.Literal[True]" = True
+    ) -> t.Optional[t.Any]:
+        ...
+
+    @t.overload
+    def get_default(
+        self, ctx: Context, call: bool = ...
+    ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
+        ...
+
+    def get_default(
+        self, ctx: Context, call: bool = True
+    ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
+        """Get the default for the parameter. Tries
+        :meth:`Context.lookup_default` first, then the local default.
+
+        :param ctx: Current context.
+        :param call: If the default is a callable, call it. Disable to
+            return the callable instead.
+
+        .. versionchanged:: 8.0.2
+            Type casting is no longer performed when getting a default.
+
+        .. versionchanged:: 8.0.1
+            Type casting can fail in resilient parsing mode. Invalid
+            defaults will not prevent showing help text.
+
+        .. versionchanged:: 8.0
+            Looks at ``ctx.default_map`` first.
+
+        .. versionchanged:: 8.0
+            Added the ``call`` parameter.
+        """
+        value = ctx.lookup_default(self.name, call=False)  # type: ignore
+
+        if value is None:
+            value = self.default
+
+        if call and callable(value):
+            value = value()
+
+        return value
+
+    def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
+        raise NotImplementedError()
+
+    def consume_value(
+        self, ctx: Context, opts: t.Mapping[str, t.Any]
+    ) -> t.Tuple[t.Any, ParameterSource]:
+        value = opts.get(self.name)  # type: ignore
+        source = ParameterSource.COMMANDLINE
+
+        if value is None:
+            value = self.value_from_envvar(ctx)
+            source = ParameterSource.ENVIRONMENT
+
+        if value is None:
+            value = ctx.lookup_default(self.name)  # type: ignore
+            source = ParameterSource.DEFAULT_MAP
+
+        if value is None:
+            value = self.get_default(ctx)
+            source = ParameterSource.DEFAULT
+
+        return value, source
+
+    def type_cast_value(self, ctx: Context, value: t.Any) -> t.Any:
+        """Convert and validate a value against the option's
+        :attr:`type`, :attr:`multiple`, and :attr:`nargs`.
+        """
+        if value is None:
+            return () if self.multiple or self.nargs == -1 else None
+
+        def check_iter(value: t.Any) -> t.Iterator:
+            try:
+                return _check_iter(value)
+            except TypeError:
+                # This should only happen when passing in args manually,
+                # the parser should construct an iterable when parsing
+                # the command line.
+                raise BadParameter(
+                    _("Value must be an iterable."), ctx=ctx, param=self
+                ) from None
+
+        if self.nargs == 1 or self.type.is_composite:
+            convert: t.Callable[[t.Any], t.Any] = partial(
+                self.type, param=self, ctx=ctx
+            )
+        elif self.nargs == -1:
+
+            def convert(value: t.Any) -> t.Tuple:
+                return tuple(self.type(x, self, ctx) for x in check_iter(value))
+
+        else:  # nargs > 1
+
+            def convert(value: t.Any) -> t.Tuple:
+                value = tuple(check_iter(value))
+
+                if len(value) != self.nargs:
+                    raise BadParameter(
+                        ngettext(
+                            "Takes {nargs} values but 1 was given.",
+                            "Takes {nargs} values but {len} were given.",
+                            len(value),
+                        ).format(nargs=self.nargs, len=len(value)),
+                        ctx=ctx,
+                        param=self,
+                    )
+
+                return tuple(self.type(x, self, ctx) for x in value)
+
+        if self.multiple:
+            return tuple(convert(x) for x in check_iter(value))
+
+        return convert(value)
+
+    def value_is_missing(self, value: t.Any) -> bool:
+        if value is None:
+            return True
+
+        if (self.nargs != 1 or self.multiple) and value == ():
+            return True
+
+        return False
+
+    def process_value(self, ctx: Context, value: t.Any) -> t.Any:
+        value = self.type_cast_value(ctx, value)
+
+        if self.required and self.value_is_missing(value):
+            raise MissingParameter(ctx=ctx, param=self)
+
+        if self.callback is not None:
+            value = self.callback(ctx, self, value)
+
+        return value
+
+    def resolve_envvar_value(self, ctx: Context) -> t.Optional[str]:
+        if self.envvar is None:
+            return None
+
+        if isinstance(self.envvar, str):
+            rv = os.environ.get(self.envvar)
+
+            if rv:
+                return rv
+        else:
+            for envvar in self.envvar:
+                rv = os.environ.get(envvar)
+
+                if rv:
+                    return rv
+
+        return None
+
+    def value_from_envvar(self, ctx: Context) -> t.Optional[t.Any]:
+        rv: t.Optional[t.Any] = self.resolve_envvar_value(ctx)
+
+        if rv is not None and self.nargs != 1:
+            rv = self.type.split_envvar_value(rv)
+
+        return rv
+
+    def handle_parse_result(
+        self, ctx: Context, opts: t.Mapping[str, t.Any], args: t.List[str]
+    ) -> t.Tuple[t.Any, t.List[str]]:
+        with augment_usage_errors(ctx, param=self):
+            value, source = self.consume_value(ctx, opts)
+            ctx.set_parameter_source(self.name, source)  # type: ignore
+
+            try:
+                value = self.process_value(ctx, value)
+            except Exception:
+                if not ctx.resilient_parsing:
+                    raise
+
+                value = None
+
+        if self.expose_value:
+            ctx.params[self.name] = value  # type: ignore
+
+        return value, args
+
+    def get_help_record(self, ctx: Context) -> t.Optional[t.Tuple[str, str]]:
+        pass
+
+    def get_usage_pieces(self, ctx: Context) -> t.List[str]:
+        return []
+
+    def get_error_hint(self, ctx: Context) -> str:
+        """Get a stringified version of the param for use in error messages to
+        indicate which param caused the error.
+        """
+        hint_list = self.opts or [self.human_readable_name]
+        return " / ".join(f"'{x}'" for x in hint_list)
+
+    def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
+        """Return a list of completions for the incomplete value. If a
+        ``shell_complete`` function was given during init, it is used.
+        Otherwise, the :attr:`type`
+        :meth:`~click.types.ParamType.shell_complete` function is used.
+
+        :param ctx: Invocation context for this command.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        if self._custom_shell_complete is not None:
+            results = self._custom_shell_complete(ctx, self, incomplete)
+
+            if results and isinstance(results[0], str):
+                from click.shell_completion import CompletionItem
+
+                results = [CompletionItem(c) for c in results]
+
+            return t.cast(t.List["CompletionItem"], results)
+
+        return self.type.shell_complete(ctx, self, incomplete)
+
+
+class Option(Parameter):
+    """Options are usually optional values on the command line and
+    have some extra features that arguments don't have.
+
+    All other parameters are passed onwards to the parameter constructor.
+
+    :param show_default: Show the default value for this option in its
+        help text. Values are not shown by default, unless
+        :attr:`Context.show_default` is ``True``. If this value is a
+        string, it shows that string in parentheses instead of the
+        actual value. This is particularly useful for dynamic options.
+        For single option boolean flags, the default remains hidden if
+        its value is ``False``.
+    :param show_envvar: Controls if an environment variable should be
+        shown on the help page. Normally, environment variables are not
+        shown.
+    :param prompt: If set to ``True`` or a non empty string then the
+        user will be prompted for input. If set to ``True`` the prompt
+        will be the option name capitalized.
+    :param confirmation_prompt: Prompt a second time to confirm the
+        value if it was prompted for. Can be set to a string instead of
+        ``True`` to customize the message.
+    :param prompt_required: If set to ``False``, the user will be
+        prompted for input only when the option was specified as a flag
+        without a value.
+    :param hide_input: If this is ``True`` then the input on the prompt
+        will be hidden from the user. This is useful for password input.
+    :param is_flag: forces this option to act as a flag.  The default is
+                    auto detection.
+    :param flag_value: which value should be used for this flag if it's
+                       enabled.  This is set to a boolean automatically if
+                       the option string contains a slash to mark two options.
+    :param multiple: if this is set to `True` then the argument is accepted
+                     multiple times and recorded.  This is similar to ``nargs``
+                     in how it works but supports arbitrary number of
+                     arguments.
+    :param count: this flag makes an option increment an integer.
+    :param allow_from_autoenv: if this is enabled then the value of this
+                               parameter will be pulled from an environment
+                               variable in case a prefix is defined on the
+                               context.
+    :param help: the help string.
+    :param hidden: hide this option from help outputs.
+
+    .. versionchanged:: 8.1.0
+        Help text indentation is cleaned here instead of only in the
+        ``@option`` decorator.
+
+    .. versionchanged:: 8.1.0
+        The ``show_default`` parameter overrides
+        ``Context.show_default``.
+
+    .. versionchanged:: 8.1.0
+        The default of a single option boolean flag is not shown if the
+        default value is ``False``.
+
+    .. versionchanged:: 8.0.1
+        ``type`` is detected from ``flag_value`` if given.
+    """
+
+    param_type_name = "option"
+
+    def __init__(
+        self,
+        param_decls: t.Optional[t.Sequence[str]] = None,
+        show_default: t.Union[bool, str, None] = None,
+        prompt: t.Union[bool, str] = False,
+        confirmation_prompt: t.Union[bool, str] = False,
+        prompt_required: bool = True,
+        hide_input: bool = False,
+        is_flag: t.Optional[bool] = None,
+        flag_value: t.Optional[t.Any] = None,
+        multiple: bool = False,
+        count: bool = False,
+        allow_from_autoenv: bool = True,
+        type: t.Optional[t.Union[types.ParamType, t.Any]] = None,
+        help: t.Optional[str] = None,
+        hidden: bool = False,
+        show_choices: bool = True,
+        show_envvar: bool = False,
+        **attrs: t.Any,
+    ) -> None:
+        if help:
+            help = inspect.cleandoc(help)
+
+        default_is_missing = "default" not in attrs
+        super().__init__(param_decls, type=type, multiple=multiple, **attrs)
+
+        if prompt is True:
+            if self.name is None:
+                raise TypeError("'name' is required with 'prompt=True'.")
+
+            prompt_text: t.Optional[str] = self.name.replace("_", " ").capitalize()
+        elif prompt is False:
+            prompt_text = None
+        else:
+            prompt_text = prompt
+
+        self.prompt = prompt_text
+        self.confirmation_prompt = confirmation_prompt
+        self.prompt_required = prompt_required
+        self.hide_input = hide_input
+        self.hidden = hidden
+
+        # If prompt is enabled but not required, then the option can be
+        # used as a flag to indicate using prompt or flag_value.
+        self._flag_needs_value = self.prompt is not None and not self.prompt_required
+
+        if is_flag is None:
+            if flag_value is not None:
+                # Implicitly a flag because flag_value was set.
+                is_flag = True
+            elif self._flag_needs_value:
+                # Not a flag, but when used as a flag it shows a prompt.
+                is_flag = False
+            else:
+                # Implicitly a flag because flag options were given.
+                is_flag = bool(self.secondary_opts)
+        elif is_flag is False and not self._flag_needs_value:
+            # Not a flag, and prompt is not enabled, can be used as a
+            # flag if flag_value is set.
+            self._flag_needs_value = flag_value is not None
+
+        if is_flag and default_is_missing and not self.required:
+            self.default: t.Union[t.Any, t.Callable[[], t.Any]] = False
+
+        if flag_value is None:
+            flag_value = not self.default
+
+        if is_flag and type is None:
+            # Re-guess the type from the flag value instead of the
+            # default.
+            self.type = types.convert_type(None, flag_value)
+
+        self.is_flag: bool = is_flag
+        self.is_bool_flag = is_flag and isinstance(self.type, types.BoolParamType)
+        self.flag_value: t.Any = flag_value
+
+        # Counting
+        self.count = count
+        if count:
+            if type is None:
+                self.type = types.IntRange(min=0)
+            if default_is_missing:
+                self.default = 0
+
+        self.allow_from_autoenv = allow_from_autoenv
+        self.help = help
+        self.show_default = show_default
+        self.show_choices = show_choices
+        self.show_envvar = show_envvar
+
+        if __debug__:
+            if self.nargs == -1:
+                raise TypeError("nargs=-1 is not supported for options.")
+
+            if self.prompt and self.is_flag and not self.is_bool_flag:
+                raise TypeError("'prompt' is not valid for non-boolean flag.")
+
+            if not self.is_bool_flag and self.secondary_opts:
+                raise TypeError("Secondary flag is not valid for non-boolean flag.")
+
+            if self.is_bool_flag and self.hide_input and self.prompt is not None:
+                raise TypeError(
+                    "'prompt' with 'hide_input' is not valid for boolean flag."
+                )
+
+            if self.count:
+                if self.multiple:
+                    raise TypeError("'count' is not valid with 'multiple'.")
+
+                if self.is_flag:
+                    raise TypeError("'count' is not valid with 'is_flag'.")
+
+            if self.multiple and self.is_flag:
+                raise TypeError("'multiple' is not valid with 'is_flag', use 'count'.")
+
+    def to_info_dict(self) -> t.Dict[str, t.Any]:
+        info_dict = super().to_info_dict()
+        info_dict.update(
+            help=self.help,
+            prompt=self.prompt,
+            is_flag=self.is_flag,
+            flag_value=self.flag_value,
+            count=self.count,
+            hidden=self.hidden,
+        )
+        return info_dict
+
+    def _parse_decls(
+        self, decls: t.Sequence[str], expose_value: bool
+    ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
+        opts = []
+        secondary_opts = []
+        name = None
+        possible_names = []
+
+        for decl in decls:
+            if decl.isidentifier():
+                if name is not None:
+                    raise TypeError(f"Name '{name}' defined twice")
+                name = decl
+            else:
+                split_char = ";" if decl[:1] == "/" else "/"
+                if split_char in decl:
+                    first, second = decl.split(split_char, 1)
+                    first = first.rstrip()
+                    if first:
+                        possible_names.append(split_opt(first))
+                        opts.append(first)
+                    second = second.lstrip()
+                    if second:
+                        secondary_opts.append(second.lstrip())
+                    if first == second:
+                        raise ValueError(
+                            f"Boolean option {decl!r} cannot use the"
+                            " same flag for true/false."
+                        )
+                else:
+                    possible_names.append(split_opt(decl))
+                    opts.append(decl)
+
+        if name is None and possible_names:
+            possible_names.sort(key=lambda x: -len(x[0]))  # group long options first
+            name = possible_names[0][1].replace("-", "_").lower()
+            if not name.isidentifier():
+                name = None
+
+        if name is None:
+            if not expose_value:
+                return None, opts, secondary_opts
+            raise TypeError("Could not determine name for option")
+
+        if not opts and not secondary_opts:
+            raise TypeError(
+                f"No options defined but a name was passed ({name})."
+                " Did you mean to declare an argument instead? Did"
+                f" you mean to pass '--{name}'?"
+            )
+
+        return name, opts, secondary_opts
+
+    def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
+        if self.multiple:
+            action = "append"
+        elif self.count:
+            action = "count"
+        else:
+            action = "store"
+
+        if self.is_flag:
+            action = f"{action}_const"
+
+            if self.is_bool_flag and self.secondary_opts:
+                parser.add_option(
+                    obj=self, opts=self.opts, dest=self.name, action=action, const=True
+                )
+                parser.add_option(
+                    obj=self,
+                    opts=self.secondary_opts,
+                    dest=self.name,
+                    action=action,
+                    const=False,
+                )
+            else:
+                parser.add_option(
+                    obj=self,
+                    opts=self.opts,
+                    dest=self.name,
+                    action=action,
+                    const=self.flag_value,
+                )
+        else:
+            parser.add_option(
+                obj=self,
+                opts=self.opts,
+                dest=self.name,
+                action=action,
+                nargs=self.nargs,
+            )
+
+    def get_help_record(self, ctx: Context) -> t.Optional[t.Tuple[str, str]]:
+        if self.hidden:
+            return None
+
+        any_prefix_is_slash = False
+
+        def _write_opts(opts: t.Sequence[str]) -> str:
+            nonlocal any_prefix_is_slash
+
+            rv, any_slashes = join_options(opts)
+
+            if any_slashes:
+                any_prefix_is_slash = True
+
+            if not self.is_flag and not self.count:
+                rv += f" {self.make_metavar()}"
+
+            return rv
+
+        rv = [_write_opts(self.opts)]
+
+        if self.secondary_opts:
+            rv.append(_write_opts(self.secondary_opts))
+
+        help = self.help or ""
+        extra = []
+
+        if self.show_envvar:
+            envvar = self.envvar
+
+            if envvar is None:
+                if (
+                    self.allow_from_autoenv
+                    and ctx.auto_envvar_prefix is not None
+                    and self.name is not None
+                ):
+                    envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}"
+
+            if envvar is not None:
+                var_str = (
+                    envvar
+                    if isinstance(envvar, str)
+                    else ", ".join(str(d) for d in envvar)
+                )
+                extra.append(_("env var: {var}").format(var=var_str))
+
+        # Temporarily enable resilient parsing to avoid type casting
+        # failing for the default. Might be possible to extend this to
+        # help formatting in general.
+        resilient = ctx.resilient_parsing
+        ctx.resilient_parsing = True
+
+        try:
+            default_value = self.get_default(ctx, call=False)
+        finally:
+            ctx.resilient_parsing = resilient
+
+        show_default = False
+        show_default_is_str = False
+
+        if self.show_default is not None:
+            if isinstance(self.show_default, str):
+                show_default_is_str = show_default = True
+            else:
+                show_default = self.show_default
+        elif ctx.show_default is not None:
+            show_default = ctx.show_default
+
+        if show_default_is_str or (show_default and (default_value is not None)):
+            if show_default_is_str:
+                default_string = f"({self.show_default})"
+            elif isinstance(default_value, (list, tuple)):
+                default_string = ", ".join(str(d) for d in default_value)
+            elif inspect.isfunction(default_value):
+                default_string = _("(dynamic)")
+            elif self.is_bool_flag and self.secondary_opts:
+                # For boolean flags that have distinct True/False opts,
+                # use the opt without prefix instead of the value.
+                default_string = split_opt(
+                    (self.opts if self.default else self.secondary_opts)[0]
+                )[1]
+            elif self.is_bool_flag and not self.secondary_opts and not default_value:
+                default_string = ""
+            else:
+                default_string = str(default_value)
+
+            if default_string:
+                extra.append(_("default: {default}").format(default=default_string))
+
+        if (
+            isinstance(self.type, types._NumberRangeBase)
+            # skip count with default range type
+            and not (self.count and self.type.min == 0 and self.type.max is None)
+        ):
+            range_str = self.type._describe_range()
+
+            if range_str:
+                extra.append(range_str)
+
+        if self.required:
+            extra.append(_("required"))
+
+        if extra:
+            extra_str = "; ".join(extra)
+            help = f"{help}  [{extra_str}]" if help else f"[{extra_str}]"
+
+        return ("; " if any_prefix_is_slash else " / ").join(rv), help
+
+    @t.overload
+    def get_default(
+        self, ctx: Context, call: "te.Literal[True]" = True
+    ) -> t.Optional[t.Any]:
+        ...
+
+    @t.overload
+    def get_default(
+        self, ctx: Context, call: bool = ...
+    ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
+        ...
+
+    def get_default(
+        self, ctx: Context, call: bool = True
+    ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
+        # If we're a non boolean flag our default is more complex because
+        # we need to look at all flags in the same group to figure out
+        # if we're the default one in which case we return the flag
+        # value as default.
+        if self.is_flag and not self.is_bool_flag:
+            for param in ctx.command.params:
+                if param.name == self.name and param.default:
+                    return param.flag_value  # type: ignore
+
+            return None
+
+        return super().get_default(ctx, call=call)
+
+    def prompt_for_value(self, ctx: Context) -> t.Any:
+        """This is an alternative flow that can be activated in the full
+        value processing if a value does not exist.  It will prompt the
+        user until a valid value exists and then returns the processed
+        value as result.
+        """
+        assert self.prompt is not None
+
+        # Calculate the default before prompting anything to be stable.
+        default = self.get_default(ctx)
+
+        # If this is a prompt for a flag we need to handle this
+        # differently.
+        if self.is_bool_flag:
+            return confirm(self.prompt, default)
+
+        return prompt(
+            self.prompt,
+            default=default,
+            type=self.type,
+            hide_input=self.hide_input,
+            show_choices=self.show_choices,
+            confirmation_prompt=self.confirmation_prompt,
+            value_proc=lambda x: self.process_value(ctx, x),
+        )
+
+    def resolve_envvar_value(self, ctx: Context) -> t.Optional[str]:
+        rv = super().resolve_envvar_value(ctx)
+
+        if rv is not None:
+            return rv
+
+        if (
+            self.allow_from_autoenv
+            and ctx.auto_envvar_prefix is not None
+            and self.name is not None
+        ):
+            envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}"
+            rv = os.environ.get(envvar)
+
+            if rv:
+                return rv
+
+        return None
+
+    def value_from_envvar(self, ctx: Context) -> t.Optional[t.Any]:
+        rv: t.Optional[t.Any] = self.resolve_envvar_value(ctx)
+
+        if rv is None:
+            return None
+
+        value_depth = (self.nargs != 1) + bool(self.multiple)
+
+        if value_depth > 0:
+            rv = self.type.split_envvar_value(rv)
+
+            if self.multiple and self.nargs != 1:
+                rv = batch(rv, self.nargs)
+
+        return rv
+
+    def consume_value(
+        self, ctx: Context, opts: t.Mapping[str, "Parameter"]
+    ) -> t.Tuple[t.Any, ParameterSource]:
+        value, source = super().consume_value(ctx, opts)
+
+        # The parser will emit a sentinel value if the option can be
+        # given as a flag without a value. This is different from None
+        # to distinguish from the flag not being given at all.
+        if value is _flag_needs_value:
+            if self.prompt is not None and not ctx.resilient_parsing:
+                value = self.prompt_for_value(ctx)
+                source = ParameterSource.PROMPT
+            else:
+                value = self.flag_value
+                source = ParameterSource.COMMANDLINE
+
+        elif (
+            self.multiple
+            and value is not None
+            and any(v is _flag_needs_value for v in value)
+        ):
+            value = [self.flag_value if v is _flag_needs_value else v for v in value]
+            source = ParameterSource.COMMANDLINE
+
+        # The value wasn't set, or used the param's default, prompt if
+        # prompting is enabled.
+        elif (
+            source in {None, ParameterSource.DEFAULT}
+            and self.prompt is not None
+            and (self.required or self.prompt_required)
+            and not ctx.resilient_parsing
+        ):
+            value = self.prompt_for_value(ctx)
+            source = ParameterSource.PROMPT
+
+        return value, source
+
+
+class Argument(Parameter):
+    """Arguments are positional parameters to a command.  They generally
+    provide fewer features than options but can have infinite ``nargs``
+    and are required by default.
+
+    All parameters are passed onwards to the parameter constructor.
+    """
+
+    param_type_name = "argument"
+
+    def __init__(
+        self,
+        param_decls: t.Sequence[str],
+        required: t.Optional[bool] = None,
+        **attrs: t.Any,
+    ) -> None:
+        if required is None:
+            if attrs.get("default") is not None:
+                required = False
+            else:
+                required = attrs.get("nargs", 1) > 0
+
+        if "multiple" in attrs:
+            raise TypeError("__init__() got an unexpected keyword argument 'multiple'.")
+
+        super().__init__(param_decls, required=required, **attrs)
+
+        if __debug__:
+            if self.default is not None and self.nargs == -1:
+                raise TypeError("'default' is not supported for nargs=-1.")
+
+    @property
+    def human_readable_name(self) -> str:
+        if self.metavar is not None:
+            return self.metavar
+        return self.name.upper()  # type: ignore
+
+    def make_metavar(self) -> str:
+        if self.metavar is not None:
+            return self.metavar
+        var = self.type.get_metavar(self)
+        if not var:
+            var = self.name.upper()  # type: ignore
+        if not self.required:
+            var = f"[{var}]"
+        if self.nargs != 1:
+            var += "..."
+        return var
+
+    def _parse_decls(
+        self, decls: t.Sequence[str], expose_value: bool
+    ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
+        if not decls:
+            if not expose_value:
+                return None, [], []
+            raise TypeError("Could not determine name for argument")
+        if len(decls) == 1:
+            name = arg = decls[0]
+            name = name.replace("-", "_").lower()
+        else:
+            raise TypeError(
+                "Arguments take exactly one parameter declaration, got"
+                f" {len(decls)}."
+            )
+        return name, [arg], []
+
+    def get_usage_pieces(self, ctx: Context) -> t.List[str]:
+        return [self.make_metavar()]
+
+    def get_error_hint(self, ctx: Context) -> str:
+        return f"'{self.make_metavar()}'"
+
+    def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
+        parser.add_argument(dest=self.name, nargs=self.nargs, obj=self)
diff --git a/myenv/lib/python3.9/site-packages/click/decorators.py b/myenv/lib/python3.9/site-packages/click/decorators.py
new file mode 100644
index 0000000..28618dc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/decorators.py
@@ -0,0 +1,497 @@
+import inspect
+import types
+import typing as t
+from functools import update_wrapper
+from gettext import gettext as _
+
+from .core import Argument
+from .core import Command
+from .core import Context
+from .core import Group
+from .core import Option
+from .core import Parameter
+from .globals import get_current_context
+from .utils import echo
+
+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
+FC = t.TypeVar("FC", bound=t.Union[t.Callable[..., t.Any], Command])
+
+
+def pass_context(f: F) -> F:
+    """Marks a callback as wanting to receive the current context
+    object as first argument.
+    """
+
+    def new_func(*args, **kwargs):  # type: ignore
+        return f(get_current_context(), *args, **kwargs)
+
+    return update_wrapper(t.cast(F, new_func), f)
+
+
+def pass_obj(f: F) -> F:
+    """Similar to :func:`pass_context`, but only pass the object on the
+    context onwards (:attr:`Context.obj`).  This is useful if that object
+    represents the state of a nested system.
+    """
+
+    def new_func(*args, **kwargs):  # type: ignore
+        return f(get_current_context().obj, *args, **kwargs)
+
+    return update_wrapper(t.cast(F, new_func), f)
+
+
+def make_pass_decorator(
+    object_type: t.Type, ensure: bool = False
+) -> "t.Callable[[F], F]":
+    """Given an object type this creates a decorator that will work
+    similar to :func:`pass_obj` but instead of passing the object of the
+    current context, it will find the innermost context of type
+    :func:`object_type`.
+
+    This generates a decorator that works roughly like this::
+
+        from functools import update_wrapper
+
+        def decorator(f):
+            @pass_context
+            def new_func(ctx, *args, **kwargs):
+                obj = ctx.find_object(object_type)
+                return ctx.invoke(f, obj, *args, **kwargs)
+            return update_wrapper(new_func, f)
+        return decorator
+
+    :param object_type: the type of the object to pass.
+    :param ensure: if set to `True`, a new object will be created and
+                   remembered on the context if it's not there yet.
+    """
+
+    def decorator(f: F) -> F:
+        def new_func(*args, **kwargs):  # type: ignore
+            ctx = get_current_context()
+
+            if ensure:
+                obj = ctx.ensure_object(object_type)
+            else:
+                obj = ctx.find_object(object_type)
+
+            if obj is None:
+                raise RuntimeError(
+                    "Managed to invoke callback without a context"
+                    f" object of type {object_type.__name__!r}"
+                    " existing."
+                )
+
+            return ctx.invoke(f, obj, *args, **kwargs)
+
+        return update_wrapper(t.cast(F, new_func), f)
+
+    return decorator
+
+
+def pass_meta_key(
+    key: str, *, doc_description: t.Optional[str] = None
+) -> "t.Callable[[F], F]":
+    """Create a decorator that passes a key from
+    :attr:`click.Context.meta` as the first argument to the decorated
+    function.
+
+    :param key: Key in ``Context.meta`` to pass.
+    :param doc_description: Description of the object being passed,
+        inserted into the decorator's docstring. Defaults to "the 'key'
+        key from Context.meta".
+
+    .. versionadded:: 8.0
+    """
+
+    def decorator(f: F) -> F:
+        def new_func(*args, **kwargs):  # type: ignore
+            ctx = get_current_context()
+            obj = ctx.meta[key]
+            return ctx.invoke(f, obj, *args, **kwargs)
+
+        return update_wrapper(t.cast(F, new_func), f)
+
+    if doc_description is None:
+        doc_description = f"the {key!r} key from :attr:`click.Context.meta`"
+
+    decorator.__doc__ = (
+        f"Decorator that passes {doc_description} as the first argument"
+        " to the decorated function."
+    )
+    return decorator
+
+
+CmdType = t.TypeVar("CmdType", bound=Command)
+
+
+@t.overload
+def command(
+    __func: t.Callable[..., t.Any],
+) -> Command:
+    ...
+
+
+@t.overload
+def command(
+    name: t.Optional[str] = None,
+    **attrs: t.Any,
+) -> t.Callable[..., Command]:
+    ...
+
+
+@t.overload
+def command(
+    name: t.Optional[str] = None,
+    cls: t.Type[CmdType] = ...,
+    **attrs: t.Any,
+) -> t.Callable[..., CmdType]:
+    ...
+
+
+def command(
+    name: t.Union[str, t.Callable[..., t.Any], None] = None,
+    cls: t.Optional[t.Type[Command]] = None,
+    **attrs: t.Any,
+) -> t.Union[Command, t.Callable[..., Command]]:
+    r"""Creates a new :class:`Command` and uses the decorated function as
+    callback.  This will also automatically attach all decorated
+    :func:`option`\s and :func:`argument`\s as parameters to the command.
+
+    The name of the command defaults to the name of the function with
+    underscores replaced by dashes.  If you want to change that, you can
+    pass the intended name as the first argument.
+
+    All keyword arguments are forwarded to the underlying command class.
+    For the ``params`` argument, any decorated params are appended to
+    the end of the list.
+
+    Once decorated the function turns into a :class:`Command` instance
+    that can be invoked as a command line utility or be attached to a
+    command :class:`Group`.
+
+    :param name: the name of the command.  This defaults to the function
+                 name with underscores replaced by dashes.
+    :param cls: the command class to instantiate.  This defaults to
+                :class:`Command`.
+
+    .. versionchanged:: 8.1
+        This decorator can be applied without parentheses.
+
+    .. versionchanged:: 8.1
+        The ``params`` argument can be used. Decorated params are
+        appended to the end of the list.
+    """
+
+    func: t.Optional[t.Callable[..., t.Any]] = None
+
+    if callable(name):
+        func = name
+        name = None
+        assert cls is None, "Use 'command(cls=cls)(callable)' to specify a class."
+        assert not attrs, "Use 'command(**kwargs)(callable)' to provide arguments."
+
+    if cls is None:
+        cls = Command
+
+    def decorator(f: t.Callable[..., t.Any]) -> Command:
+        if isinstance(f, Command):
+            raise TypeError("Attempted to convert a callback into a command twice.")
+
+        attr_params = attrs.pop("params", None)
+        params = attr_params if attr_params is not None else []
+
+        try:
+            decorator_params = f.__click_params__  # type: ignore
+        except AttributeError:
+            pass
+        else:
+            del f.__click_params__  # type: ignore
+            params.extend(reversed(decorator_params))
+
+        if attrs.get("help") is None:
+            attrs["help"] = f.__doc__
+
+        cmd = cls(  # type: ignore[misc]
+            name=name or f.__name__.lower().replace("_", "-"),  # type: ignore[arg-type]
+            callback=f,
+            params=params,
+            **attrs,
+        )
+        cmd.__doc__ = f.__doc__
+        return cmd
+
+    if func is not None:
+        return decorator(func)
+
+    return decorator
+
+
+@t.overload
+def group(
+    __func: t.Callable[..., t.Any],
+) -> Group:
+    ...
+
+
+@t.overload
+def group(
+    name: t.Optional[str] = None,
+    **attrs: t.Any,
+) -> t.Callable[[F], Group]:
+    ...
+
+
+def group(
+    name: t.Union[str, t.Callable[..., t.Any], None] = None, **attrs: t.Any
+) -> t.Union[Group, t.Callable[[F], Group]]:
+    """Creates a new :class:`Group` with a function as callback.  This
+    works otherwise the same as :func:`command` just that the `cls`
+    parameter is set to :class:`Group`.
+
+    .. versionchanged:: 8.1
+        This decorator can be applied without parentheses.
+    """
+    if attrs.get("cls") is None:
+        attrs["cls"] = Group
+
+    if callable(name):
+        grp: t.Callable[[F], Group] = t.cast(Group, command(**attrs))
+        return grp(name)
+
+    return t.cast(Group, command(name, **attrs))
+
+
+def _param_memo(f: FC, param: Parameter) -> None:
+    if isinstance(f, Command):
+        f.params.append(param)
+    else:
+        if not hasattr(f, "__click_params__"):
+            f.__click_params__ = []  # type: ignore
+
+        f.__click_params__.append(param)  # type: ignore
+
+
+def argument(*param_decls: str, **attrs: t.Any) -> t.Callable[[FC], FC]:
+    """Attaches an argument to the command.  All positional arguments are
+    passed as parameter declarations to :class:`Argument`; all keyword
+    arguments are forwarded unchanged (except ``cls``).
+    This is equivalent to creating an :class:`Argument` instance manually
+    and attaching it to the :attr:`Command.params` list.
+
+    :param cls: the argument class to instantiate.  This defaults to
+                :class:`Argument`.
+    """
+
+    def decorator(f: FC) -> FC:
+        ArgumentClass = attrs.pop("cls", None) or Argument
+        _param_memo(f, ArgumentClass(param_decls, **attrs))
+        return f
+
+    return decorator
+
+
+def option(*param_decls: str, **attrs: t.Any) -> t.Callable[[FC], FC]:
+    """Attaches an option to the command.  All positional arguments are
+    passed as parameter declarations to :class:`Option`; all keyword
+    arguments are forwarded unchanged (except ``cls``).
+    This is equivalent to creating an :class:`Option` instance manually
+    and attaching it to the :attr:`Command.params` list.
+
+    :param cls: the option class to instantiate.  This defaults to
+                :class:`Option`.
+    """
+
+    def decorator(f: FC) -> FC:
+        # Issue 926, copy attrs, so pre-defined options can re-use the same cls=
+        option_attrs = attrs.copy()
+        OptionClass = option_attrs.pop("cls", None) or Option
+        _param_memo(f, OptionClass(param_decls, **option_attrs))
+        return f
+
+    return decorator
+
+
+def confirmation_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Add a ``--yes`` option which shows a prompt before continuing if
+    not passed. If the prompt is declined, the program will exit.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--yes"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+
+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
+        if not value:
+            ctx.abort()
+
+    if not param_decls:
+        param_decls = ("--yes",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("callback", callback)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("prompt", "Do you want to continue?")
+    kwargs.setdefault("help", "Confirm the action without prompting.")
+    return option(*param_decls, **kwargs)
+
+
+def password_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Add a ``--password`` option which prompts for a password, hiding
+    input and asking to enter the value again for confirmation.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--password"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+    if not param_decls:
+        param_decls = ("--password",)
+
+    kwargs.setdefault("prompt", True)
+    kwargs.setdefault("confirmation_prompt", True)
+    kwargs.setdefault("hide_input", True)
+    return option(*param_decls, **kwargs)
+
+
+def version_option(
+    version: t.Optional[str] = None,
+    *param_decls: str,
+    package_name: t.Optional[str] = None,
+    prog_name: t.Optional[str] = None,
+    message: t.Optional[str] = None,
+    **kwargs: t.Any,
+) -> t.Callable[[FC], FC]:
+    """Add a ``--version`` option which immediately prints the version
+    number and exits the program.
+
+    If ``version`` is not provided, Click will try to detect it using
+    :func:`importlib.metadata.version` to get the version for the
+    ``package_name``. On Python < 3.8, the ``importlib_metadata``
+    backport must be installed.
+
+    If ``package_name`` is not provided, Click will try to detect it by
+    inspecting the stack frames. This will be used to detect the
+    version, so it must match the name of the installed package.
+
+    :param version: The version number to show. If not provided, Click
+        will try to detect it.
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--version"``.
+    :param package_name: The package name to detect the version from. If
+        not provided, Click will try to detect it.
+    :param prog_name: The name of the CLI to show in the message. If not
+        provided, it will be detected from the command.
+    :param message: The message to show. The values ``%(prog)s``,
+        ``%(package)s``, and ``%(version)s`` are available. Defaults to
+        ``"%(prog)s, version %(version)s"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    :raise RuntimeError: ``version`` could not be detected.
+
+    .. versionchanged:: 8.0
+        Add the ``package_name`` parameter, and the ``%(package)s``
+        value for messages.
+
+    .. versionchanged:: 8.0
+        Use :mod:`importlib.metadata` instead of ``pkg_resources``. The
+        version is detected based on the package name, not the entry
+        point name. The Python package name must match the installed
+        package name, or be passed with ``package_name=``.
+    """
+    if message is None:
+        message = _("%(prog)s, version %(version)s")
+
+    if version is None and package_name is None:
+        frame = inspect.currentframe()
+        f_back = frame.f_back if frame is not None else None
+        f_globals = f_back.f_globals if f_back is not None else None
+        # break reference cycle
+        # https://docs.python.org/3/library/inspect.html#the-interpreter-stack
+        del frame
+
+        if f_globals is not None:
+            package_name = f_globals.get("__name__")
+
+            if package_name == "__main__":
+                package_name = f_globals.get("__package__")
+
+            if package_name:
+                package_name = package_name.partition(".")[0]
+
+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
+        if not value or ctx.resilient_parsing:
+            return
+
+        nonlocal prog_name
+        nonlocal version
+
+        if prog_name is None:
+            prog_name = ctx.find_root().info_name
+
+        if version is None and package_name is not None:
+            metadata: t.Optional[types.ModuleType]
+
+            try:
+                from importlib import metadata  # type: ignore
+            except ImportError:
+                # Python < 3.8
+                import importlib_metadata as metadata  # type: ignore
+
+            try:
+                version = metadata.version(package_name)  # type: ignore
+            except metadata.PackageNotFoundError:  # type: ignore
+                raise RuntimeError(
+                    f"{package_name!r} is not installed. Try passing"
+                    " 'package_name' instead."
+                ) from None
+
+        if version is None:
+            raise RuntimeError(
+                f"Could not determine the version for {package_name!r} automatically."
+            )
+
+        echo(
+            t.cast(str, message)
+            % {"prog": prog_name, "package": package_name, "version": version},
+            color=ctx.color,
+        )
+        ctx.exit()
+
+    if not param_decls:
+        param_decls = ("--version",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("is_eager", True)
+    kwargs.setdefault("help", _("Show the version and exit."))
+    kwargs["callback"] = callback
+    return option(*param_decls, **kwargs)
+
+
+def help_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Add a ``--help`` option which immediately prints the help page
+    and exits the program.
+
+    This is usually unnecessary, as the ``--help`` option is added to
+    each command automatically unless ``add_help_option=False`` is
+    passed.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--help"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+
+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
+        if not value or ctx.resilient_parsing:
+            return
+
+        echo(ctx.get_help(), color=ctx.color)
+        ctx.exit()
+
+    if not param_decls:
+        param_decls = ("--help",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("is_eager", True)
+    kwargs.setdefault("help", _("Show this message and exit."))
+    kwargs["callback"] = callback
+    return option(*param_decls, **kwargs)
diff --git a/myenv/lib/python3.9/site-packages/click/exceptions.py b/myenv/lib/python3.9/site-packages/click/exceptions.py
new file mode 100644
index 0000000..9e20b3e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/exceptions.py
@@ -0,0 +1,287 @@
+import os
+import typing as t
+from gettext import gettext as _
+from gettext import ngettext
+
+from ._compat import get_text_stderr
+from .utils import echo
+
+if t.TYPE_CHECKING:
+    from .core import Context
+    from .core import Parameter
+
+
+def _join_param_hints(
+    param_hint: t.Optional[t.Union[t.Sequence[str], str]]
+) -> t.Optional[str]:
+    if param_hint is not None and not isinstance(param_hint, str):
+        return " / ".join(repr(x) for x in param_hint)
+
+    return param_hint
+
+
+class ClickException(Exception):
+    """An exception that Click can handle and show to the user."""
+
+    #: The exit code for this exception.
+    exit_code = 1
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        self.message = message
+
+    def format_message(self) -> str:
+        return self.message
+
+    def __str__(self) -> str:
+        return self.message
+
+    def show(self, file: t.Optional[t.IO] = None) -> None:
+        if file is None:
+            file = get_text_stderr()
+
+        echo(_("Error: {message}").format(message=self.format_message()), file=file)
+
+
+class UsageError(ClickException):
+    """An internal exception that signals a usage error.  This typically
+    aborts any further handling.
+
+    :param message: the error message to display.
+    :param ctx: optionally the context that caused this error.  Click will
+                fill in the context automatically in some situations.
+    """
+
+    exit_code = 2
+
+    def __init__(self, message: str, ctx: t.Optional["Context"] = None) -> None:
+        super().__init__(message)
+        self.ctx = ctx
+        self.cmd = self.ctx.command if self.ctx else None
+
+    def show(self, file: t.Optional[t.IO] = None) -> None:
+        if file is None:
+            file = get_text_stderr()
+        color = None
+        hint = ""
+        if (
+            self.ctx is not None
+            and self.ctx.command.get_help_option(self.ctx) is not None
+        ):
+            hint = _("Try '{command} {option}' for help.").format(
+                command=self.ctx.command_path, option=self.ctx.help_option_names[0]
+            )
+            hint = f"{hint}\n"
+        if self.ctx is not None:
+            color = self.ctx.color
+            echo(f"{self.ctx.get_usage()}\n{hint}", file=file, color=color)
+        echo(
+            _("Error: {message}").format(message=self.format_message()),
+            file=file,
+            color=color,
+        )
+
+
+class BadParameter(UsageError):
+    """An exception that formats out a standardized error message for a
+    bad parameter.  This is useful when thrown from a callback or type as
+    Click will attach contextual information to it (for instance, which
+    parameter it is).
+
+    .. versionadded:: 2.0
+
+    :param param: the parameter object that caused this error.  This can
+                  be left out, and Click will attach this info itself
+                  if possible.
+    :param param_hint: a string that shows up as parameter name.  This
+                       can be used as alternative to `param` in cases
+                       where custom validation should happen.  If it is
+                       a string it's used as such, if it's a list then
+                       each item is quoted and separated.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        ctx: t.Optional["Context"] = None,
+        param: t.Optional["Parameter"] = None,
+        param_hint: t.Optional[str] = None,
+    ) -> None:
+        super().__init__(message, ctx)
+        self.param = param
+        self.param_hint = param_hint
+
+    def format_message(self) -> str:
+        if self.param_hint is not None:
+            param_hint = self.param_hint
+        elif self.param is not None:
+            param_hint = self.param.get_error_hint(self.ctx)  # type: ignore
+        else:
+            return _("Invalid value: {message}").format(message=self.message)
+
+        return _("Invalid value for {param_hint}: {message}").format(
+            param_hint=_join_param_hints(param_hint), message=self.message
+        )
+
+
+class MissingParameter(BadParameter):
+    """Raised if click required an option or argument but it was not
+    provided when invoking the script.
+
+    .. versionadded:: 4.0
+
+    :param param_type: a string that indicates the type of the parameter.
+                       The default is to inherit the parameter type from
+                       the given `param`.  Valid values are ``'parameter'``,
+                       ``'option'`` or ``'argument'``.
+    """
+
+    def __init__(
+        self,
+        message: t.Optional[str] = None,
+        ctx: t.Optional["Context"] = None,
+        param: t.Optional["Parameter"] = None,
+        param_hint: t.Optional[str] = None,
+        param_type: t.Optional[str] = None,
+    ) -> None:
+        super().__init__(message or "", ctx, param, param_hint)
+        self.param_type = param_type
+
+    def format_message(self) -> str:
+        if self.param_hint is not None:
+            param_hint: t.Optional[str] = self.param_hint
+        elif self.param is not None:
+            param_hint = self.param.get_error_hint(self.ctx)  # type: ignore
+        else:
+            param_hint = None
+
+        param_hint = _join_param_hints(param_hint)
+        param_hint = f" {param_hint}" if param_hint else ""
+
+        param_type = self.param_type
+        if param_type is None and self.param is not None:
+            param_type = self.param.param_type_name
+
+        msg = self.message
+        if self.param is not None:
+            msg_extra = self.param.type.get_missing_message(self.param)
+            if msg_extra:
+                if msg:
+                    msg += f". {msg_extra}"
+                else:
+                    msg = msg_extra
+
+        msg = f" {msg}" if msg else ""
+
+        # Translate param_type for known types.
+        if param_type == "argument":
+            missing = _("Missing argument")
+        elif param_type == "option":
+            missing = _("Missing option")
+        elif param_type == "parameter":
+            missing = _("Missing parameter")
+        else:
+            missing = _("Missing {param_type}").format(param_type=param_type)
+
+        return f"{missing}{param_hint}.{msg}"
+
+    def __str__(self) -> str:
+        if not self.message:
+            param_name = self.param.name if self.param else None
+            return _("Missing parameter: {param_name}").format(param_name=param_name)
+        else:
+            return self.message
+
+
+class NoSuchOption(UsageError):
+    """Raised if click attempted to handle an option that does not
+    exist.
+
+    .. versionadded:: 4.0
+    """
+
+    def __init__(
+        self,
+        option_name: str,
+        message: t.Optional[str] = None,
+        possibilities: t.Optional[t.Sequence[str]] = None,
+        ctx: t.Optional["Context"] = None,
+    ) -> None:
+        if message is None:
+            message = _("No such option: {name}").format(name=option_name)
+
+        super().__init__(message, ctx)
+        self.option_name = option_name
+        self.possibilities = possibilities
+
+    def format_message(self) -> str:
+        if not self.possibilities:
+            return self.message
+
+        possibility_str = ", ".join(sorted(self.possibilities))
+        suggest = ngettext(
+            "Did you mean {possibility}?",
+            "(Possible options: {possibilities})",
+            len(self.possibilities),
+        ).format(possibility=possibility_str, possibilities=possibility_str)
+        return f"{self.message} {suggest}"
+
+
+class BadOptionUsage(UsageError):
+    """Raised if an option is generally supplied but the use of the option
+    was incorrect.  This is for instance raised if the number of arguments
+    for an option is not correct.
+
+    .. versionadded:: 4.0
+
+    :param option_name: the name of the option being used incorrectly.
+    """
+
+    def __init__(
+        self, option_name: str, message: str, ctx: t.Optional["Context"] = None
+    ) -> None:
+        super().__init__(message, ctx)
+        self.option_name = option_name
+
+
+class BadArgumentUsage(UsageError):
+    """Raised if an argument is generally supplied but the use of the argument
+    was incorrect.  This is for instance raised if the number of values
+    for an argument is not correct.
+
+    .. versionadded:: 6.0
+    """
+
+
+class FileError(ClickException):
+    """Raised if a file cannot be opened."""
+
+    def __init__(self, filename: str, hint: t.Optional[str] = None) -> None:
+        if hint is None:
+            hint = _("unknown error")
+
+        super().__init__(hint)
+        self.ui_filename = os.fsdecode(filename)
+        self.filename = filename
+
+    def format_message(self) -> str:
+        return _("Could not open file {filename!r}: {message}").format(
+            filename=self.ui_filename, message=self.message
+        )
+
+
+class Abort(RuntimeError):
+    """An internal signalling exception that signals Click to abort."""
+
+
+class Exit(RuntimeError):
+    """An exception that indicates that the application should exit with some
+    status code.
+
+    :param code: the status code to exit with.
+    """
+
+    __slots__ = ("exit_code",)
+
+    def __init__(self, code: int = 0) -> None:
+        self.exit_code = code
diff --git a/myenv/lib/python3.9/site-packages/click/formatting.py b/myenv/lib/python3.9/site-packages/click/formatting.py
new file mode 100644
index 0000000..ddd2a2f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/formatting.py
@@ -0,0 +1,301 @@
+import typing as t
+from contextlib import contextmanager
+from gettext import gettext as _
+
+from ._compat import term_len
+from .parser import split_opt
+
+# Can force a width.  This is used by the test system
+FORCED_WIDTH: t.Optional[int] = None
+
+
+def measure_table(rows: t.Iterable[t.Tuple[str, str]]) -> t.Tuple[int, ...]:
+    widths: t.Dict[int, int] = {}
+
+    for row in rows:
+        for idx, col in enumerate(row):
+            widths[idx] = max(widths.get(idx, 0), term_len(col))
+
+    return tuple(y for x, y in sorted(widths.items()))
+
+
+def iter_rows(
+    rows: t.Iterable[t.Tuple[str, str]], col_count: int
+) -> t.Iterator[t.Tuple[str, ...]]:
+    for row in rows:
+        yield row + ("",) * (col_count - len(row))
+
+
+def wrap_text(
+    text: str,
+    width: int = 78,
+    initial_indent: str = "",
+    subsequent_indent: str = "",
+    preserve_paragraphs: bool = False,
+) -> str:
+    """A helper function that intelligently wraps text.  By default, it
+    assumes that it operates on a single paragraph of text but if the
+    `preserve_paragraphs` parameter is provided it will intelligently
+    handle paragraphs (defined by two empty lines).
+
+    If paragraphs are handled, a paragraph can be prefixed with an empty
+    line containing the ``\\b`` character (``\\x08``) to indicate that
+    no rewrapping should happen in that block.
+
+    :param text: the text that should be rewrapped.
+    :param width: the maximum width for the text.
+    :param initial_indent: the initial indent that should be placed on the
+                           first line as a string.
+    :param subsequent_indent: the indent string that should be placed on
+                              each consecutive line.
+    :param preserve_paragraphs: if this flag is set then the wrapping will
+                                intelligently handle paragraphs.
+    """
+    from ._textwrap import TextWrapper
+
+    text = text.expandtabs()
+    wrapper = TextWrapper(
+        width,
+        initial_indent=initial_indent,
+        subsequent_indent=subsequent_indent,
+        replace_whitespace=False,
+    )
+    if not preserve_paragraphs:
+        return wrapper.fill(text)
+
+    p: t.List[t.Tuple[int, bool, str]] = []
+    buf: t.List[str] = []
+    indent = None
+
+    def _flush_par() -> None:
+        if not buf:
+            return
+        if buf[0].strip() == "\b":
+            p.append((indent or 0, True, "\n".join(buf[1:])))
+        else:
+            p.append((indent or 0, False, " ".join(buf)))
+        del buf[:]
+
+    for line in text.splitlines():
+        if not line:
+            _flush_par()
+            indent = None
+        else:
+            if indent is None:
+                orig_len = term_len(line)
+                line = line.lstrip()
+                indent = orig_len - term_len(line)
+            buf.append(line)
+    _flush_par()
+
+    rv = []
+    for indent, raw, text in p:
+        with wrapper.extra_indent(" " * indent):
+            if raw:
+                rv.append(wrapper.indent_only(text))
+            else:
+                rv.append(wrapper.fill(text))
+
+    return "\n\n".join(rv)
+
+
+class HelpFormatter:
+    """This class helps with formatting text-based help pages.  It's
+    usually just needed for very special internal cases, but it's also
+    exposed so that developers can write their own fancy outputs.
+
+    At present, it always writes into memory.
+
+    :param indent_increment: the additional increment for each level.
+    :param width: the width for the text.  This defaults to the terminal
+                  width clamped to a maximum of 78.
+    """
+
+    def __init__(
+        self,
+        indent_increment: int = 2,
+        width: t.Optional[int] = None,
+        max_width: t.Optional[int] = None,
+    ) -> None:
+        import shutil
+
+        self.indent_increment = indent_increment
+        if max_width is None:
+            max_width = 80
+        if width is None:
+            width = FORCED_WIDTH
+            if width is None:
+                width = max(min(shutil.get_terminal_size().columns, max_width) - 2, 50)
+        self.width = width
+        self.current_indent = 0
+        self.buffer: t.List[str] = []
+
+    def write(self, string: str) -> None:
+        """Writes a unicode string into the internal buffer."""
+        self.buffer.append(string)
+
+    def indent(self) -> None:
+        """Increases the indentation."""
+        self.current_indent += self.indent_increment
+
+    def dedent(self) -> None:
+        """Decreases the indentation."""
+        self.current_indent -= self.indent_increment
+
+    def write_usage(
+        self, prog: str, args: str = "", prefix: t.Optional[str] = None
+    ) -> None:
+        """Writes a usage line into the buffer.
+
+        :param prog: the program name.
+        :param args: whitespace separated list of arguments.
+        :param prefix: The prefix for the first line. Defaults to
+            ``"Usage: "``.
+        """
+        if prefix is None:
+            prefix = f"{_('Usage:')} "
+
+        usage_prefix = f"{prefix:>{self.current_indent}}{prog} "
+        text_width = self.width - self.current_indent
+
+        if text_width >= (term_len(usage_prefix) + 20):
+            # The arguments will fit to the right of the prefix.
+            indent = " " * term_len(usage_prefix)
+            self.write(
+                wrap_text(
+                    args,
+                    text_width,
+                    initial_indent=usage_prefix,
+                    subsequent_indent=indent,
+                )
+            )
+        else:
+            # The prefix is too long, put the arguments on the next line.
+            self.write(usage_prefix)
+            self.write("\n")
+            indent = " " * (max(self.current_indent, term_len(prefix)) + 4)
+            self.write(
+                wrap_text(
+                    args, text_width, initial_indent=indent, subsequent_indent=indent
+                )
+            )
+
+        self.write("\n")
+
+    def write_heading(self, heading: str) -> None:
+        """Writes a heading into the buffer."""
+        self.write(f"{'':>{self.current_indent}}{heading}:\n")
+
+    def write_paragraph(self) -> None:
+        """Writes a paragraph into the buffer."""
+        if self.buffer:
+            self.write("\n")
+
+    def write_text(self, text: str) -> None:
+        """Writes re-indented text into the buffer.  This rewraps and
+        preserves paragraphs.
+        """
+        indent = " " * self.current_indent
+        self.write(
+            wrap_text(
+                text,
+                self.width,
+                initial_indent=indent,
+                subsequent_indent=indent,
+                preserve_paragraphs=True,
+            )
+        )
+        self.write("\n")
+
+    def write_dl(
+        self,
+        rows: t.Sequence[t.Tuple[str, str]],
+        col_max: int = 30,
+        col_spacing: int = 2,
+    ) -> None:
+        """Writes a definition list into the buffer.  This is how options
+        and commands are usually formatted.
+
+        :param rows: a list of two item tuples for the terms and values.
+        :param col_max: the maximum width of the first column.
+        :param col_spacing: the number of spaces between the first and
+                            second column.
+        """
+        rows = list(rows)
+        widths = measure_table(rows)
+        if len(widths) != 2:
+            raise TypeError("Expected two columns for definition list")
+
+        first_col = min(widths[0], col_max) + col_spacing
+
+        for first, second in iter_rows(rows, len(widths)):
+            self.write(f"{'':>{self.current_indent}}{first}")
+            if not second:
+                self.write("\n")
+                continue
+            if term_len(first) <= first_col - col_spacing:
+                self.write(" " * (first_col - term_len(first)))
+            else:
+                self.write("\n")
+                self.write(" " * (first_col + self.current_indent))
+
+            text_width = max(self.width - first_col - 2, 10)
+            wrapped_text = wrap_text(second, text_width, preserve_paragraphs=True)
+            lines = wrapped_text.splitlines()
+
+            if lines:
+                self.write(f"{lines[0]}\n")
+
+                for line in lines[1:]:
+                    self.write(f"{'':>{first_col + self.current_indent}}{line}\n")
+            else:
+                self.write("\n")
+
+    @contextmanager
+    def section(self, name: str) -> t.Iterator[None]:
+        """Helpful context manager that writes a paragraph, a heading,
+        and the indents.
+
+        :param name: the section name that is written as heading.
+        """
+        self.write_paragraph()
+        self.write_heading(name)
+        self.indent()
+        try:
+            yield
+        finally:
+            self.dedent()
+
+    @contextmanager
+    def indentation(self) -> t.Iterator[None]:
+        """A context manager that increases the indentation."""
+        self.indent()
+        try:
+            yield
+        finally:
+            self.dedent()
+
+    def getvalue(self) -> str:
+        """Returns the buffer contents."""
+        return "".join(self.buffer)
+
+
+def join_options(options: t.Sequence[str]) -> t.Tuple[str, bool]:
+    """Given a list of option strings this joins them in the most appropriate
+    way and returns them in the form ``(formatted_string,
+    any_prefix_is_slash)`` where the second item in the tuple is a flag that
+    indicates if any of the option prefixes was a slash.
+    """
+    rv = []
+    any_prefix_is_slash = False
+
+    for opt in options:
+        prefix = split_opt(opt)[0]
+
+        if prefix == "/":
+            any_prefix_is_slash = True
+
+        rv.append((len(prefix), opt))
+
+    rv.sort(key=lambda x: x[0])
+    return ", ".join(x[1] for x in rv), any_prefix_is_slash
diff --git a/myenv/lib/python3.9/site-packages/click/globals.py b/myenv/lib/python3.9/site-packages/click/globals.py
new file mode 100644
index 0000000..480058f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/globals.py
@@ -0,0 +1,68 @@
+import typing as t
+from threading import local
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .core import Context
+
+_local = local()
+
+
+@t.overload
+def get_current_context(silent: "te.Literal[False]" = False) -> "Context":
+    ...
+
+
+@t.overload
+def get_current_context(silent: bool = ...) -> t.Optional["Context"]:
+    ...
+
+
+def get_current_context(silent: bool = False) -> t.Optional["Context"]:
+    """Returns the current click context.  This can be used as a way to
+    access the current context object from anywhere.  This is a more implicit
+    alternative to the :func:`pass_context` decorator.  This function is
+    primarily useful for helpers such as :func:`echo` which might be
+    interested in changing its behavior based on the current context.
+
+    To push the current context, :meth:`Context.scope` can be used.
+
+    .. versionadded:: 5.0
+
+    :param silent: if set to `True` the return value is `None` if no context
+                   is available.  The default behavior is to raise a
+                   :exc:`RuntimeError`.
+    """
+    try:
+        return t.cast("Context", _local.stack[-1])
+    except (AttributeError, IndexError) as e:
+        if not silent:
+            raise RuntimeError("There is no active click context.") from e
+
+    return None
+
+
+def push_context(ctx: "Context") -> None:
+    """Pushes a new context to the current stack."""
+    _local.__dict__.setdefault("stack", []).append(ctx)
+
+
+def pop_context() -> None:
+    """Removes the top level from the stack."""
+    _local.stack.pop()
+
+
+def resolve_color_default(color: t.Optional[bool] = None) -> t.Optional[bool]:
+    """Internal helper to get the default value of the color flag.  If a
+    value is passed it's returned unchanged, otherwise it's looked up from
+    the current context.
+    """
+    if color is not None:
+        return color
+
+    ctx = get_current_context(silent=True)
+
+    if ctx is not None:
+        return ctx.color
+
+    return None
diff --git a/myenv/lib/python3.9/site-packages/click/parser.py b/myenv/lib/python3.9/site-packages/click/parser.py
new file mode 100644
index 0000000..2d5a2ed
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/parser.py
@@ -0,0 +1,529 @@
+"""
+This module started out as largely a copy paste from the stdlib's
+optparse module with the features removed that we do not need from
+optparse because we implement them in Click on a higher level (for
+instance type handling, help formatting and a lot more).
+
+The plan is to remove more and more from here over time.
+
+The reason this is a different module and not optparse from the stdlib
+is that there are differences in 2.x and 3.x about the error messages
+generated and optparse in the stdlib uses gettext for no good reason
+and might cause us issues.
+
+Click uses parts of optparse written by Gregory P. Ward and maintained
+by the Python Software Foundation. This is limited to code in parser.py.
+
+Copyright 2001-2006 Gregory P. Ward. All rights reserved.
+Copyright 2002-2006 Python Software Foundation. All rights reserved.
+"""
+# This code uses parts of optparse written by Gregory P. Ward and
+# maintained by the Python Software Foundation.
+# Copyright 2001-2006 Gregory P. Ward
+# Copyright 2002-2006 Python Software Foundation
+import typing as t
+from collections import deque
+from gettext import gettext as _
+from gettext import ngettext
+
+from .exceptions import BadArgumentUsage
+from .exceptions import BadOptionUsage
+from .exceptions import NoSuchOption
+from .exceptions import UsageError
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .core import Argument as CoreArgument
+    from .core import Context
+    from .core import Option as CoreOption
+    from .core import Parameter as CoreParameter
+
+V = t.TypeVar("V")
+
+# Sentinel value that indicates an option was passed as a flag without a
+# value but is not a flag option. Option.consume_value uses this to
+# prompt or use the flag_value.
+_flag_needs_value = object()
+
+
+def _unpack_args(
+    args: t.Sequence[str], nargs_spec: t.Sequence[int]
+) -> t.Tuple[t.Sequence[t.Union[str, t.Sequence[t.Optional[str]], None]], t.List[str]]:
+    """Given an iterable of arguments and an iterable of nargs specifications,
+    it returns a tuple with all the unpacked arguments at the first index
+    and all remaining arguments as the second.
+
+    The nargs specification is the number of arguments that should be consumed
+    or `-1` to indicate that this position should eat up all the remainders.
+
+    Missing items are filled with `None`.
+    """
+    args = deque(args)
+    nargs_spec = deque(nargs_spec)
+    rv: t.List[t.Union[str, t.Tuple[t.Optional[str], ...], None]] = []
+    spos: t.Optional[int] = None
+
+    def _fetch(c: "te.Deque[V]") -> t.Optional[V]:
+        try:
+            if spos is None:
+                return c.popleft()
+            else:
+                return c.pop()
+        except IndexError:
+            return None
+
+    while nargs_spec:
+        nargs = _fetch(nargs_spec)
+
+        if nargs is None:
+            continue
+
+        if nargs == 1:
+            rv.append(_fetch(args))
+        elif nargs > 1:
+            x = [_fetch(args) for _ in range(nargs)]
+
+            # If we're reversed, we're pulling in the arguments in reverse,
+            # so we need to turn them around.
+            if spos is not None:
+                x.reverse()
+
+            rv.append(tuple(x))
+        elif nargs < 0:
+            if spos is not None:
+                raise TypeError("Cannot have two nargs < 0")
+
+            spos = len(rv)
+            rv.append(None)
+
+    # spos is the position of the wildcard (star).  If it's not `None`,
+    # we fill it with the remainder.
+    if spos is not None:
+        rv[spos] = tuple(args)
+        args = []
+        rv[spos + 1 :] = reversed(rv[spos + 1 :])
+
+    return tuple(rv), list(args)
+
+
+def split_opt(opt: str) -> t.Tuple[str, str]:
+    first = opt[:1]
+    if first.isalnum():
+        return "", opt
+    if opt[1:2] == first:
+        return opt[:2], opt[2:]
+    return first, opt[1:]
+
+
+def normalize_opt(opt: str, ctx: t.Optional["Context"]) -> str:
+    if ctx is None or ctx.token_normalize_func is None:
+        return opt
+    prefix, opt = split_opt(opt)
+    return f"{prefix}{ctx.token_normalize_func(opt)}"
+
+
+def split_arg_string(string: str) -> t.List[str]:
+    """Split an argument string as with :func:`shlex.split`, but don't
+    fail if the string is incomplete. Ignores a missing closing quote or
+    incomplete escape sequence and uses the partial token as-is.
+
+    .. code-block:: python
+
+        split_arg_string("example 'my file")
+        ["example", "my file"]
+
+        split_arg_string("example my\\")
+        ["example", "my"]
+
+    :param string: String to split.
+    """
+    import shlex
+
+    lex = shlex.shlex(string, posix=True)
+    lex.whitespace_split = True
+    lex.commenters = ""
+    out = []
+
+    try:
+        for token in lex:
+            out.append(token)
+    except ValueError:
+        # Raised when end-of-string is reached in an invalid state. Use
+        # the partial token as-is. The quote or escape character is in
+        # lex.state, not lex.token.
+        out.append(lex.token)
+
+    return out
+
+
+class Option:
+    def __init__(
+        self,
+        obj: "CoreOption",
+        opts: t.Sequence[str],
+        dest: t.Optional[str],
+        action: t.Optional[str] = None,
+        nargs: int = 1,
+        const: t.Optional[t.Any] = None,
+    ):
+        self._short_opts = []
+        self._long_opts = []
+        self.prefixes = set()
+
+        for opt in opts:
+            prefix, value = split_opt(opt)
+            if not prefix:
+                raise ValueError(f"Invalid start character for option ({opt})")
+            self.prefixes.add(prefix[0])
+            if len(prefix) == 1 and len(value) == 1:
+                self._short_opts.append(opt)
+            else:
+                self._long_opts.append(opt)
+                self.prefixes.add(prefix)
+
+        if action is None:
+            action = "store"
+
+        self.dest = dest
+        self.action = action
+        self.nargs = nargs
+        self.const = const
+        self.obj = obj
+
+    @property
+    def takes_value(self) -> bool:
+        return self.action in ("store", "append")
+
+    def process(self, value: str, state: "ParsingState") -> None:
+        if self.action == "store":
+            state.opts[self.dest] = value  # type: ignore
+        elif self.action == "store_const":
+            state.opts[self.dest] = self.const  # type: ignore
+        elif self.action == "append":
+            state.opts.setdefault(self.dest, []).append(value)  # type: ignore
+        elif self.action == "append_const":
+            state.opts.setdefault(self.dest, []).append(self.const)  # type: ignore
+        elif self.action == "count":
+            state.opts[self.dest] = state.opts.get(self.dest, 0) + 1  # type: ignore
+        else:
+            raise ValueError(f"unknown action '{self.action}'")
+        state.order.append(self.obj)
+
+
+class Argument:
+    def __init__(self, obj: "CoreArgument", dest: t.Optional[str], nargs: int = 1):
+        self.dest = dest
+        self.nargs = nargs
+        self.obj = obj
+
+    def process(
+        self,
+        value: t.Union[t.Optional[str], t.Sequence[t.Optional[str]]],
+        state: "ParsingState",
+    ) -> None:
+        if self.nargs > 1:
+            assert value is not None
+            holes = sum(1 for x in value if x is None)
+            if holes == len(value):
+                value = None
+            elif holes != 0:
+                raise BadArgumentUsage(
+                    _("Argument {name!r} takes {nargs} values.").format(
+                        name=self.dest, nargs=self.nargs
+                    )
+                )
+
+        if self.nargs == -1 and self.obj.envvar is not None and value == ():
+            # Replace empty tuple with None so that a value from the
+            # environment may be tried.
+            value = None
+
+        state.opts[self.dest] = value  # type: ignore
+        state.order.append(self.obj)
+
+
+class ParsingState:
+    def __init__(self, rargs: t.List[str]) -> None:
+        self.opts: t.Dict[str, t.Any] = {}
+        self.largs: t.List[str] = []
+        self.rargs = rargs
+        self.order: t.List["CoreParameter"] = []
+
+
+class OptionParser:
+    """The option parser is an internal class that is ultimately used to
+    parse options and arguments.  It's modelled after optparse and brings
+    a similar but vastly simplified API.  It should generally not be used
+    directly as the high level Click classes wrap it for you.
+
+    It's not nearly as extensible as optparse or argparse as it does not
+    implement features that are implemented on a higher level (such as
+    types or defaults).
+
+    :param ctx: optionally the :class:`~click.Context` where this parser
+                should go with.
+    """
+
+    def __init__(self, ctx: t.Optional["Context"] = None) -> None:
+        #: The :class:`~click.Context` for this parser.  This might be
+        #: `None` for some advanced use cases.
+        self.ctx = ctx
+        #: This controls how the parser deals with interspersed arguments.
+        #: If this is set to `False`, the parser will stop on the first
+        #: non-option.  Click uses this to implement nested subcommands
+        #: safely.
+        self.allow_interspersed_args = True
+        #: This tells the parser how to deal with unknown options.  By
+        #: default it will error out (which is sensible), but there is a
+        #: second mode where it will ignore it and continue processing
+        #: after shifting all the unknown options into the resulting args.
+        self.ignore_unknown_options = False
+
+        if ctx is not None:
+            self.allow_interspersed_args = ctx.allow_interspersed_args
+            self.ignore_unknown_options = ctx.ignore_unknown_options
+
+        self._short_opt: t.Dict[str, Option] = {}
+        self._long_opt: t.Dict[str, Option] = {}
+        self._opt_prefixes = {"-", "--"}
+        self._args: t.List[Argument] = []
+
+    def add_option(
+        self,
+        obj: "CoreOption",
+        opts: t.Sequence[str],
+        dest: t.Optional[str],
+        action: t.Optional[str] = None,
+        nargs: int = 1,
+        const: t.Optional[t.Any] = None,
+    ) -> None:
+        """Adds a new option named `dest` to the parser.  The destination
+        is not inferred (unlike with optparse) and needs to be explicitly
+        provided.  Action can be any of ``store``, ``store_const``,
+        ``append``, ``append_const`` or ``count``.
+
+        The `obj` can be used to identify the option in the order list
+        that is returned from the parser.
+        """
+        opts = [normalize_opt(opt, self.ctx) for opt in opts]
+        option = Option(obj, opts, dest, action=action, nargs=nargs, const=const)
+        self._opt_prefixes.update(option.prefixes)
+        for opt in option._short_opts:
+            self._short_opt[opt] = option
+        for opt in option._long_opts:
+            self._long_opt[opt] = option
+
+    def add_argument(
+        self, obj: "CoreArgument", dest: t.Optional[str], nargs: int = 1
+    ) -> None:
+        """Adds a positional argument named `dest` to the parser.
+
+        The `obj` can be used to identify the option in the order list
+        that is returned from the parser.
+        """
+        self._args.append(Argument(obj, dest=dest, nargs=nargs))
+
+    def parse_args(
+        self, args: t.List[str]
+    ) -> t.Tuple[t.Dict[str, t.Any], t.List[str], t.List["CoreParameter"]]:
+        """Parses positional arguments and returns ``(values, args, order)``
+        for the parsed options and arguments as well as the leftover
+        arguments if there are any.  The order is a list of objects as they
+        appear on the command line.  If arguments appear multiple times they
+        will be memorized multiple times as well.
+        """
+        state = ParsingState(args)
+        try:
+            self._process_args_for_options(state)
+            self._process_args_for_args(state)
+        except UsageError:
+            if self.ctx is None or not self.ctx.resilient_parsing:
+                raise
+        return state.opts, state.largs, state.order
+
+    def _process_args_for_args(self, state: ParsingState) -> None:
+        pargs, args = _unpack_args(
+            state.largs + state.rargs, [x.nargs for x in self._args]
+        )
+
+        for idx, arg in enumerate(self._args):
+            arg.process(pargs[idx], state)
+
+        state.largs = args
+        state.rargs = []
+
+    def _process_args_for_options(self, state: ParsingState) -> None:
+        while state.rargs:
+            arg = state.rargs.pop(0)
+            arglen = len(arg)
+            # Double dashes always handled explicitly regardless of what
+            # prefixes are valid.
+            if arg == "--":
+                return
+            elif arg[:1] in self._opt_prefixes and arglen > 1:
+                self._process_opts(arg, state)
+            elif self.allow_interspersed_args:
+                state.largs.append(arg)
+            else:
+                state.rargs.insert(0, arg)
+                return
+
+        # Say this is the original argument list:
+        # [arg0, arg1, ..., arg(i-1), arg(i), arg(i+1), ..., arg(N-1)]
+        #                            ^
+        # (we are about to process arg(i)).
+        #
+        # Then rargs is [arg(i), ..., arg(N-1)] and largs is a *subset* of
+        # [arg0, ..., arg(i-1)] (any options and their arguments will have
+        # been removed from largs).
+        #
+        # The while loop will usually consume 1 or more arguments per pass.
+        # If it consumes 1 (eg. arg is an option that takes no arguments),
+        # then after _process_arg() is done the situation is:
+        #
+        #   largs = subset of [arg0, ..., arg(i)]
+        #   rargs = [arg(i+1), ..., arg(N-1)]
+        #
+        # If allow_interspersed_args is false, largs will always be
+        # *empty* -- still a subset of [arg0, ..., arg(i-1)], but
+        # not a very interesting subset!
+
+    def _match_long_opt(
+        self, opt: str, explicit_value: t.Optional[str], state: ParsingState
+    ) -> None:
+        if opt not in self._long_opt:
+            from difflib import get_close_matches
+
+            possibilities = get_close_matches(opt, self._long_opt)
+            raise NoSuchOption(opt, possibilities=possibilities, ctx=self.ctx)
+
+        option = self._long_opt[opt]
+        if option.takes_value:
+            # At this point it's safe to modify rargs by injecting the
+            # explicit value, because no exception is raised in this
+            # branch.  This means that the inserted value will be fully
+            # consumed.
+            if explicit_value is not None:
+                state.rargs.insert(0, explicit_value)
+
+            value = self._get_value_from_state(opt, option, state)
+
+        elif explicit_value is not None:
+            raise BadOptionUsage(
+                opt, _("Option {name!r} does not take a value.").format(name=opt)
+            )
+
+        else:
+            value = None
+
+        option.process(value, state)
+
+    def _match_short_opt(self, arg: str, state: ParsingState) -> None:
+        stop = False
+        i = 1
+        prefix = arg[0]
+        unknown_options = []
+
+        for ch in arg[1:]:
+            opt = normalize_opt(f"{prefix}{ch}", self.ctx)
+            option = self._short_opt.get(opt)
+            i += 1
+
+            if not option:
+                if self.ignore_unknown_options:
+                    unknown_options.append(ch)
+                    continue
+                raise NoSuchOption(opt, ctx=self.ctx)
+            if option.takes_value:
+                # Any characters left in arg?  Pretend they're the
+                # next arg, and stop consuming characters of arg.
+                if i < len(arg):
+                    state.rargs.insert(0, arg[i:])
+                    stop = True
+
+                value = self._get_value_from_state(opt, option, state)
+
+            else:
+                value = None
+
+            option.process(value, state)
+
+            if stop:
+                break
+
+        # If we got any unknown options we re-combinate the string of the
+        # remaining options and re-attach the prefix, then report that
+        # to the state as new larg.  This way there is basic combinatorics
+        # that can be achieved while still ignoring unknown arguments.
+        if self.ignore_unknown_options and unknown_options:
+            state.largs.append(f"{prefix}{''.join(unknown_options)}")
+
+    def _get_value_from_state(
+        self, option_name: str, option: Option, state: ParsingState
+    ) -> t.Any:
+        nargs = option.nargs
+
+        if len(state.rargs) < nargs:
+            if option.obj._flag_needs_value:
+                # Option allows omitting the value.
+                value = _flag_needs_value
+            else:
+                raise BadOptionUsage(
+                    option_name,
+                    ngettext(
+                        "Option {name!r} requires an argument.",
+                        "Option {name!r} requires {nargs} arguments.",
+                        nargs,
+                    ).format(name=option_name, nargs=nargs),
+                )
+        elif nargs == 1:
+            next_rarg = state.rargs[0]
+
+            if (
+                option.obj._flag_needs_value
+                and isinstance(next_rarg, str)
+                and next_rarg[:1] in self._opt_prefixes
+                and len(next_rarg) > 1
+            ):
+                # The next arg looks like the start of an option, don't
+                # use it as the value if omitting the value is allowed.
+                value = _flag_needs_value
+            else:
+                value = state.rargs.pop(0)
+        else:
+            value = tuple(state.rargs[:nargs])
+            del state.rargs[:nargs]
+
+        return value
+
+    def _process_opts(self, arg: str, state: ParsingState) -> None:
+        explicit_value = None
+        # Long option handling happens in two parts.  The first part is
+        # supporting explicitly attached values.  In any case, we will try
+        # to long match the option first.
+        if "=" in arg:
+            long_opt, explicit_value = arg.split("=", 1)
+        else:
+            long_opt = arg
+        norm_long_opt = normalize_opt(long_opt, self.ctx)
+
+        # At this point we will match the (assumed) long option through
+        # the long option matching code.  Note that this allows options
+        # like "-foo" to be matched as long options.
+        try:
+            self._match_long_opt(norm_long_opt, explicit_value, state)
+        except NoSuchOption:
+            # At this point the long option matching failed, and we need
+            # to try with short options.  However there is a special rule
+            # which says, that if we have a two character options prefix
+            # (applies to "--foo" for instance), we do not dispatch to the
+            # short option code and will instead raise the no option
+            # error.
+            if arg[:2] not in self._opt_prefixes:
+                self._match_short_opt(arg, state)
+                return
+
+            if not self.ignore_unknown_options:
+                raise
+
+            state.largs.append(arg)
diff --git a/myenv/lib/python3.9/site-packages/click/py.typed b/myenv/lib/python3.9/site-packages/click/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/click/shell_completion.py b/myenv/lib/python3.9/site-packages/click/shell_completion.py
new file mode 100644
index 0000000..c17a8e6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/shell_completion.py
@@ -0,0 +1,580 @@
+import os
+import re
+import typing as t
+from gettext import gettext as _
+
+from .core import Argument
+from .core import BaseCommand
+from .core import Context
+from .core import MultiCommand
+from .core import Option
+from .core import Parameter
+from .core import ParameterSource
+from .parser import split_arg_string
+from .utils import echo
+
+
+def shell_complete(
+    cli: BaseCommand,
+    ctx_args: t.Dict[str, t.Any],
+    prog_name: str,
+    complete_var: str,
+    instruction: str,
+) -> int:
+    """Perform shell completion for the given CLI program.
+
+    :param cli: Command being called.
+    :param ctx_args: Extra arguments to pass to
+        ``cli.make_context``.
+    :param prog_name: Name of the executable in the shell.
+    :param complete_var: Name of the environment variable that holds
+        the completion instruction.
+    :param instruction: Value of ``complete_var`` with the completion
+        instruction and shell, in the form ``instruction_shell``.
+    :return: Status code to exit with.
+    """
+    shell, _, instruction = instruction.partition("_")
+    comp_cls = get_completion_class(shell)
+
+    if comp_cls is None:
+        return 1
+
+    comp = comp_cls(cli, ctx_args, prog_name, complete_var)
+
+    if instruction == "source":
+        echo(comp.source())
+        return 0
+
+    if instruction == "complete":
+        echo(comp.complete())
+        return 0
+
+    return 1
+
+
+class CompletionItem:
+    """Represents a completion value and metadata about the value. The
+    default metadata is ``type`` to indicate special shell handling,
+    and ``help`` if a shell supports showing a help string next to the
+    value.
+
+    Arbitrary parameters can be passed when creating the object, and
+    accessed using ``item.attr``. If an attribute wasn't passed,
+    accessing it returns ``None``.
+
+    :param value: The completion suggestion.
+    :param type: Tells the shell script to provide special completion
+        support for the type. Click uses ``"dir"`` and ``"file"``.
+    :param help: String shown next to the value if supported.
+    :param kwargs: Arbitrary metadata. The built-in implementations
+        don't use this, but custom type completions paired with custom
+        shell support could use it.
+    """
+
+    __slots__ = ("value", "type", "help", "_info")
+
+    def __init__(
+        self,
+        value: t.Any,
+        type: str = "plain",
+        help: t.Optional[str] = None,
+        **kwargs: t.Any,
+    ) -> None:
+        self.value = value
+        self.type = type
+        self.help = help
+        self._info = kwargs
+
+    def __getattr__(self, name: str) -> t.Any:
+        return self._info.get(name)
+
+
+# Only Bash >= 4.4 has the nosort option.
+_SOURCE_BASH = """\
+%(complete_func)s() {
+    local IFS=$'\\n'
+    local response
+
+    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD \
+%(complete_var)s=bash_complete $1)
+
+    for completion in $response; do
+        IFS=',' read type value <<< "$completion"
+
+        if [[ $type == 'dir' ]]; then
+            COMPREPLY=()
+            compopt -o dirnames
+        elif [[ $type == 'file' ]]; then
+            COMPREPLY=()
+            compopt -o default
+        elif [[ $type == 'plain' ]]; then
+            COMPREPLY+=($value)
+        fi
+    done
+
+    return 0
+}
+
+%(complete_func)s_setup() {
+    complete -o nosort -F %(complete_func)s %(prog_name)s
+}
+
+%(complete_func)s_setup;
+"""
+
+_SOURCE_ZSH = """\
+#compdef %(prog_name)s
+
+%(complete_func)s() {
+    local -a completions
+    local -a completions_with_descriptions
+    local -a response
+    (( ! $+commands[%(prog_name)s] )) && return 1
+
+    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) \
+%(complete_var)s=zsh_complete %(prog_name)s)}")
+
+    for type key descr in ${response}; do
+        if [[ "$type" == "plain" ]]; then
+            if [[ "$descr" == "_" ]]; then
+                completions+=("$key")
+            else
+                completions_with_descriptions+=("$key":"$descr")
+            fi
+        elif [[ "$type" == "dir" ]]; then
+            _path_files -/
+        elif [[ "$type" == "file" ]]; then
+            _path_files -f
+        fi
+    done
+
+    if [ -n "$completions_with_descriptions" ]; then
+        _describe -V unsorted completions_with_descriptions -U
+    fi
+
+    if [ -n "$completions" ]; then
+        compadd -U -V unsorted -a completions
+    fi
+}
+
+compdef %(complete_func)s %(prog_name)s;
+"""
+
+_SOURCE_FISH = """\
+function %(complete_func)s;
+    set -l response;
+
+    for value in (env %(complete_var)s=fish_complete COMP_WORDS=(commandline -cp) \
+COMP_CWORD=(commandline -t) %(prog_name)s);
+        set response $response $value;
+    end;
+
+    for completion in $response;
+        set -l metadata (string split "," $completion);
+
+        if test $metadata[1] = "dir";
+            __fish_complete_directories $metadata[2];
+        else if test $metadata[1] = "file";
+            __fish_complete_path $metadata[2];
+        else if test $metadata[1] = "plain";
+            echo $metadata[2];
+        end;
+    end;
+end;
+
+complete --no-files --command %(prog_name)s --arguments \
+"(%(complete_func)s)";
+"""
+
+
+class ShellComplete:
+    """Base class for providing shell completion support. A subclass for
+    a given shell will override attributes and methods to implement the
+    completion instructions (``source`` and ``complete``).
+
+    :param cli: Command being called.
+    :param prog_name: Name of the executable in the shell.
+    :param complete_var: Name of the environment variable that holds
+        the completion instruction.
+
+    .. versionadded:: 8.0
+    """
+
+    name: t.ClassVar[str]
+    """Name to register the shell as with :func:`add_completion_class`.
+    This is used in completion instructions (``{name}_source`` and
+    ``{name}_complete``).
+    """
+
+    source_template: t.ClassVar[str]
+    """Completion script template formatted by :meth:`source`. This must
+    be provided by subclasses.
+    """
+
+    def __init__(
+        self,
+        cli: BaseCommand,
+        ctx_args: t.Dict[str, t.Any],
+        prog_name: str,
+        complete_var: str,
+    ) -> None:
+        self.cli = cli
+        self.ctx_args = ctx_args
+        self.prog_name = prog_name
+        self.complete_var = complete_var
+
+    @property
+    def func_name(self) -> str:
+        """The name of the shell function defined by the completion
+        script.
+        """
+        safe_name = re.sub(r"\W*", "", self.prog_name.replace("-", "_"), re.ASCII)
+        return f"_{safe_name}_completion"
+
+    def source_vars(self) -> t.Dict[str, t.Any]:
+        """Vars for formatting :attr:`source_template`.
+
+        By default this provides ``complete_func``, ``complete_var``,
+        and ``prog_name``.
+        """
+        return {
+            "complete_func": self.func_name,
+            "complete_var": self.complete_var,
+            "prog_name": self.prog_name,
+        }
+
+    def source(self) -> str:
+        """Produce the shell script that defines the completion
+        function. By default this ``%``-style formats
+        :attr:`source_template` with the dict returned by
+        :meth:`source_vars`.
+        """
+        return self.source_template % self.source_vars()
+
+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
+        """Use the env vars defined by the shell script to return a
+        tuple of ``args, incomplete``. This must be implemented by
+        subclasses.
+        """
+        raise NotImplementedError
+
+    def get_completions(
+        self, args: t.List[str], incomplete: str
+    ) -> t.List[CompletionItem]:
+        """Determine the context and last complete command or parameter
+        from the complete args. Call that object's ``shell_complete``
+        method to get the completions for the incomplete value.
+
+        :param args: List of complete args before the incomplete value.
+        :param incomplete: Value being completed. May be empty.
+        """
+        ctx = _resolve_context(self.cli, self.ctx_args, self.prog_name, args)
+        obj, incomplete = _resolve_incomplete(ctx, args, incomplete)
+        return obj.shell_complete(ctx, incomplete)
+
+    def format_completion(self, item: CompletionItem) -> str:
+        """Format a completion item into the form recognized by the
+        shell script. This must be implemented by subclasses.
+
+        :param item: Completion item to format.
+        """
+        raise NotImplementedError
+
+    def complete(self) -> str:
+        """Produce the completion data to send back to the shell.
+
+        By default this calls :meth:`get_completion_args`, gets the
+        completions, then calls :meth:`format_completion` for each
+        completion.
+        """
+        args, incomplete = self.get_completion_args()
+        completions = self.get_completions(args, incomplete)
+        out = [self.format_completion(item) for item in completions]
+        return "\n".join(out)
+
+
+class BashComplete(ShellComplete):
+    """Shell completion for Bash."""
+
+    name = "bash"
+    source_template = _SOURCE_BASH
+
+    def _check_version(self) -> None:
+        import subprocess
+
+        output = subprocess.run(
+            ["bash", "-c", "echo ${BASH_VERSION}"], stdout=subprocess.PIPE
+        )
+        match = re.search(r"^(\d+)\.(\d+)\.\d+", output.stdout.decode())
+
+        if match is not None:
+            major, minor = match.groups()
+
+            if major < "4" or major == "4" and minor < "4":
+                raise RuntimeError(
+                    _(
+                        "Shell completion is not supported for Bash"
+                        " versions older than 4.4."
+                    )
+                )
+        else:
+            raise RuntimeError(
+                _("Couldn't detect Bash version, shell completion is not supported.")
+            )
+
+    def source(self) -> str:
+        self._check_version()
+        return super().source()
+
+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        cword = int(os.environ["COMP_CWORD"])
+        args = cwords[1:cword]
+
+        try:
+            incomplete = cwords[cword]
+        except IndexError:
+            incomplete = ""
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem) -> str:
+        return f"{item.type},{item.value}"
+
+
+class ZshComplete(ShellComplete):
+    """Shell completion for Zsh."""
+
+    name = "zsh"
+    source_template = _SOURCE_ZSH
+
+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        cword = int(os.environ["COMP_CWORD"])
+        args = cwords[1:cword]
+
+        try:
+            incomplete = cwords[cword]
+        except IndexError:
+            incomplete = ""
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem) -> str:
+        return f"{item.type}\n{item.value}\n{item.help if item.help else '_'}"
+
+
+class FishComplete(ShellComplete):
+    """Shell completion for Fish."""
+
+    name = "fish"
+    source_template = _SOURCE_FISH
+
+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        incomplete = os.environ["COMP_CWORD"]
+        args = cwords[1:]
+
+        # Fish stores the partial word in both COMP_WORDS and
+        # COMP_CWORD, remove it from complete args.
+        if incomplete and args and args[-1] == incomplete:
+            args.pop()
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem) -> str:
+        if item.help:
+            return f"{item.type},{item.value}\t{item.help}"
+
+        return f"{item.type},{item.value}"
+
+
+_available_shells: t.Dict[str, t.Type[ShellComplete]] = {
+    "bash": BashComplete,
+    "fish": FishComplete,
+    "zsh": ZshComplete,
+}
+
+
+def add_completion_class(
+    cls: t.Type[ShellComplete], name: t.Optional[str] = None
+) -> None:
+    """Register a :class:`ShellComplete` subclass under the given name.
+    The name will be provided by the completion instruction environment
+    variable during completion.
+
+    :param cls: The completion class that will handle completion for the
+        shell.
+    :param name: Name to register the class under. Defaults to the
+        class's ``name`` attribute.
+    """
+    if name is None:
+        name = cls.name
+
+    _available_shells[name] = cls
+
+
+def get_completion_class(shell: str) -> t.Optional[t.Type[ShellComplete]]:
+    """Look up a registered :class:`ShellComplete` subclass by the name
+    provided by the completion instruction environment variable. If the
+    name isn't registered, returns ``None``.
+
+    :param shell: Name the class is registered under.
+    """
+    return _available_shells.get(shell)
+
+
+def _is_incomplete_argument(ctx: Context, param: Parameter) -> bool:
+    """Determine if the given parameter is an argument that can still
+    accept values.
+
+    :param ctx: Invocation context for the command represented by the
+        parsed complete args.
+    :param param: Argument object being checked.
+    """
+    if not isinstance(param, Argument):
+        return False
+
+    assert param.name is not None
+    value = ctx.params[param.name]
+    return (
+        param.nargs == -1
+        or ctx.get_parameter_source(param.name) is not ParameterSource.COMMANDLINE
+        or (
+            param.nargs > 1
+            and isinstance(value, (tuple, list))
+            and len(value) < param.nargs
+        )
+    )
+
+
+def _start_of_option(ctx: Context, value: str) -> bool:
+    """Check if the value looks like the start of an option."""
+    if not value:
+        return False
+
+    c = value[0]
+    return c in ctx._opt_prefixes
+
+
+def _is_incomplete_option(ctx: Context, args: t.List[str], param: Parameter) -> bool:
+    """Determine if the given parameter is an option that needs a value.
+
+    :param args: List of complete args before the incomplete value.
+    :param param: Option object being checked.
+    """
+    if not isinstance(param, Option):
+        return False
+
+    if param.is_flag or param.count:
+        return False
+
+    last_option = None
+
+    for index, arg in enumerate(reversed(args)):
+        if index + 1 > param.nargs:
+            break
+
+        if _start_of_option(ctx, arg):
+            last_option = arg
+
+    return last_option is not None and last_option in param.opts
+
+
+def _resolve_context(
+    cli: BaseCommand, ctx_args: t.Dict[str, t.Any], prog_name: str, args: t.List[str]
+) -> Context:
+    """Produce the context hierarchy starting with the command and
+    traversing the complete arguments. This only follows the commands,
+    it doesn't trigger input prompts or callbacks.
+
+    :param cli: Command being called.
+    :param prog_name: Name of the executable in the shell.
+    :param args: List of complete args before the incomplete value.
+    """
+    ctx_args["resilient_parsing"] = True
+    ctx = cli.make_context(prog_name, args.copy(), **ctx_args)
+    args = ctx.protected_args + ctx.args
+
+    while args:
+        command = ctx.command
+
+        if isinstance(command, MultiCommand):
+            if not command.chain:
+                name, cmd, args = command.resolve_command(ctx, args)
+
+                if cmd is None:
+                    return ctx
+
+                ctx = cmd.make_context(name, args, parent=ctx, resilient_parsing=True)
+                args = ctx.protected_args + ctx.args
+            else:
+                while args:
+                    name, cmd, args = command.resolve_command(ctx, args)
+
+                    if cmd is None:
+                        return ctx
+
+                    sub_ctx = cmd.make_context(
+                        name,
+                        args,
+                        parent=ctx,
+                        allow_extra_args=True,
+                        allow_interspersed_args=False,
+                        resilient_parsing=True,
+                    )
+                    args = sub_ctx.args
+
+                ctx = sub_ctx
+                args = [*sub_ctx.protected_args, *sub_ctx.args]
+        else:
+            break
+
+    return ctx
+
+
+def _resolve_incomplete(
+    ctx: Context, args: t.List[str], incomplete: str
+) -> t.Tuple[t.Union[BaseCommand, Parameter], str]:
+    """Find the Click object that will handle the completion of the
+    incomplete value. Return the object and the incomplete value.
+
+    :param ctx: Invocation context for the command represented by
+        the parsed complete args.
+    :param args: List of complete args before the incomplete value.
+    :param incomplete: Value being completed. May be empty.
+    """
+    # Different shells treat an "=" between a long option name and
+    # value differently. Might keep the value joined, return the "="
+    # as a separate item, or return the split name and value. Always
+    # split and discard the "=" to make completion easier.
+    if incomplete == "=":
+        incomplete = ""
+    elif "=" in incomplete and _start_of_option(ctx, incomplete):
+        name, _, incomplete = incomplete.partition("=")
+        args.append(name)
+
+    # The "--" marker tells Click to stop treating values as options
+    # even if they start with the option character. If it hasn't been
+    # given and the incomplete arg looks like an option, the current
+    # command will provide option name completions.
+    if "--" not in args and _start_of_option(ctx, incomplete):
+        return ctx.command, incomplete
+
+    params = ctx.command.get_params(ctx)
+
+    # If the last complete arg is an option name with an incomplete
+    # value, the option will provide value completions.
+    for param in params:
+        if _is_incomplete_option(ctx, args, param):
+            return param, incomplete
+
+    # It's not an option name or value. The first argument without a
+    # parsed value will provide value completions.
+    for param in params:
+        if _is_incomplete_argument(ctx, param):
+            return param, incomplete
+
+    # There were no unparsed arguments, the command may be a group that
+    # will provide command name completions.
+    return ctx.command, incomplete
diff --git a/myenv/lib/python3.9/site-packages/click/termui.py b/myenv/lib/python3.9/site-packages/click/termui.py
new file mode 100644
index 0000000..bfb2f5a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/termui.py
@@ -0,0 +1,787 @@
+import inspect
+import io
+import itertools
+import os
+import sys
+import typing as t
+from gettext import gettext as _
+
+from ._compat import isatty
+from ._compat import strip_ansi
+from ._compat import WIN
+from .exceptions import Abort
+from .exceptions import UsageError
+from .globals import resolve_color_default
+from .types import Choice
+from .types import convert_type
+from .types import ParamType
+from .utils import echo
+from .utils import LazyFile
+
+if t.TYPE_CHECKING:
+    from ._termui_impl import ProgressBar
+
+V = t.TypeVar("V")
+
+# The prompt functions to use.  The doc tools currently override these
+# functions to customize how they work.
+visible_prompt_func: t.Callable[[str], str] = input
+
+_ansi_colors = {
+    "black": 30,
+    "red": 31,
+    "green": 32,
+    "yellow": 33,
+    "blue": 34,
+    "magenta": 35,
+    "cyan": 36,
+    "white": 37,
+    "reset": 39,
+    "bright_black": 90,
+    "bright_red": 91,
+    "bright_green": 92,
+    "bright_yellow": 93,
+    "bright_blue": 94,
+    "bright_magenta": 95,
+    "bright_cyan": 96,
+    "bright_white": 97,
+}
+_ansi_reset_all = "\033[0m"
+
+
+def hidden_prompt_func(prompt: str) -> str:
+    import getpass
+
+    return getpass.getpass(prompt)
+
+
+def _build_prompt(
+    text: str,
+    suffix: str,
+    show_default: bool = False,
+    default: t.Optional[t.Any] = None,
+    show_choices: bool = True,
+    type: t.Optional[ParamType] = None,
+) -> str:
+    prompt = text
+    if type is not None and show_choices and isinstance(type, Choice):
+        prompt += f" ({', '.join(map(str, type.choices))})"
+    if default is not None and show_default:
+        prompt = f"{prompt} [{_format_default(default)}]"
+    return f"{prompt}{suffix}"
+
+
+def _format_default(default: t.Any) -> t.Any:
+    if isinstance(default, (io.IOBase, LazyFile)) and hasattr(default, "name"):
+        return default.name  # type: ignore
+
+    return default
+
+
+def prompt(
+    text: str,
+    default: t.Optional[t.Any] = None,
+    hide_input: bool = False,
+    confirmation_prompt: t.Union[bool, str] = False,
+    type: t.Optional[t.Union[ParamType, t.Any]] = None,
+    value_proc: t.Optional[t.Callable[[str], t.Any]] = None,
+    prompt_suffix: str = ": ",
+    show_default: bool = True,
+    err: bool = False,
+    show_choices: bool = True,
+) -> t.Any:
+    """Prompts a user for input.  This is a convenience function that can
+    be used to prompt a user for input later.
+
+    If the user aborts the input by sending an interrupt signal, this
+    function will catch it and raise a :exc:`Abort` exception.
+
+    :param text: the text to show for the prompt.
+    :param default: the default value to use if no input happens.  If this
+                    is not given it will prompt until it's aborted.
+    :param hide_input: if this is set to true then the input value will
+                       be hidden.
+    :param confirmation_prompt: Prompt a second time to confirm the
+        value. Can be set to a string instead of ``True`` to customize
+        the message.
+    :param type: the type to use to check the value against.
+    :param value_proc: if this parameter is provided it's a function that
+                       is invoked instead of the type conversion to
+                       convert a value.
+    :param prompt_suffix: a suffix that should be added to the prompt.
+    :param show_default: shows or hides the default value in the prompt.
+    :param err: if set to true the file defaults to ``stderr`` instead of
+                ``stdout``, the same as with echo.
+    :param show_choices: Show or hide choices if the passed type is a Choice.
+                         For example if type is a Choice of either day or week,
+                         show_choices is true and text is "Group by" then the
+                         prompt will be "Group by (day, week): ".
+
+    .. versionadded:: 8.0
+        ``confirmation_prompt`` can be a custom string.
+
+    .. versionadded:: 7.0
+        Added the ``show_choices`` parameter.
+
+    .. versionadded:: 6.0
+        Added unicode support for cmd.exe on Windows.
+
+    .. versionadded:: 4.0
+        Added the `err` parameter.
+
+    """
+
+    def prompt_func(text: str) -> str:
+        f = hidden_prompt_func if hide_input else visible_prompt_func
+        try:
+            # Write the prompt separately so that we get nice
+            # coloring through colorama on Windows
+            echo(text.rstrip(" "), nl=False, err=err)
+            # Echo a space to stdout to work around an issue where
+            # readline causes backspace to clear the whole line.
+            return f(" ")
+        except (KeyboardInterrupt, EOFError):
+            # getpass doesn't print a newline if the user aborts input with ^C.
+            # Allegedly this behavior is inherited from getpass(3).
+            # A doc bug has been filed at https://bugs.python.org/issue24711
+            if hide_input:
+                echo(None, err=err)
+            raise Abort() from None
+
+    if value_proc is None:
+        value_proc = convert_type(type, default)
+
+    prompt = _build_prompt(
+        text, prompt_suffix, show_default, default, show_choices, type
+    )
+
+    if confirmation_prompt:
+        if confirmation_prompt is True:
+            confirmation_prompt = _("Repeat for confirmation")
+
+        confirmation_prompt = _build_prompt(confirmation_prompt, prompt_suffix)
+
+    while True:
+        while True:
+            value = prompt_func(prompt)
+            if value:
+                break
+            elif default is not None:
+                value = default
+                break
+        try:
+            result = value_proc(value)
+        except UsageError as e:
+            if hide_input:
+                echo(_("Error: The value you entered was invalid."), err=err)
+            else:
+                echo(_("Error: {e.message}").format(e=e), err=err)  # noqa: B306
+            continue
+        if not confirmation_prompt:
+            return result
+        while True:
+            value2 = prompt_func(confirmation_prompt)
+            is_empty = not value and not value2
+            if value2 or is_empty:
+                break
+        if value == value2:
+            return result
+        echo(_("Error: The two entered values do not match."), err=err)
+
+
+def confirm(
+    text: str,
+    default: t.Optional[bool] = False,
+    abort: bool = False,
+    prompt_suffix: str = ": ",
+    show_default: bool = True,
+    err: bool = False,
+) -> bool:
+    """Prompts for confirmation (yes/no question).
+
+    If the user aborts the input by sending a interrupt signal this
+    function will catch it and raise a :exc:`Abort` exception.
+
+    :param text: the question to ask.
+    :param default: The default value to use when no input is given. If
+        ``None``, repeat until input is given.
+    :param abort: if this is set to `True` a negative answer aborts the
+                  exception by raising :exc:`Abort`.
+    :param prompt_suffix: a suffix that should be added to the prompt.
+    :param show_default: shows or hides the default value in the prompt.
+    :param err: if set to true the file defaults to ``stderr`` instead of
+                ``stdout``, the same as with echo.
+
+    .. versionchanged:: 8.0
+        Repeat until input is given if ``default`` is ``None``.
+
+    .. versionadded:: 4.0
+        Added the ``err`` parameter.
+    """
+    prompt = _build_prompt(
+        text,
+        prompt_suffix,
+        show_default,
+        "y/n" if default is None else ("Y/n" if default else "y/N"),
+    )
+
+    while True:
+        try:
+            # Write the prompt separately so that we get nice
+            # coloring through colorama on Windows
+            echo(prompt.rstrip(" "), nl=False, err=err)
+            # Echo a space to stdout to work around an issue where
+            # readline causes backspace to clear the whole line.
+            value = visible_prompt_func(" ").lower().strip()
+        except (KeyboardInterrupt, EOFError):
+            raise Abort() from None
+        if value in ("y", "yes"):
+            rv = True
+        elif value in ("n", "no"):
+            rv = False
+        elif default is not None and value == "":
+            rv = default
+        else:
+            echo(_("Error: invalid input"), err=err)
+            continue
+        break
+    if abort and not rv:
+        raise Abort()
+    return rv
+
+
+def echo_via_pager(
+    text_or_generator: t.Union[t.Iterable[str], t.Callable[[], t.Iterable[str]], str],
+    color: t.Optional[bool] = None,
+) -> None:
+    """This function takes a text and shows it via an environment specific
+    pager on stdout.
+
+    .. versionchanged:: 3.0
+       Added the `color` flag.
+
+    :param text_or_generator: the text to page, or alternatively, a
+                              generator emitting the text to page.
+    :param color: controls if the pager supports ANSI colors or not.  The
+                  default is autodetection.
+    """
+    color = resolve_color_default(color)
+
+    if inspect.isgeneratorfunction(text_or_generator):
+        i = t.cast(t.Callable[[], t.Iterable[str]], text_or_generator)()
+    elif isinstance(text_or_generator, str):
+        i = [text_or_generator]
+    else:
+        i = iter(t.cast(t.Iterable[str], text_or_generator))
+
+    # convert every element of i to a text type if necessary
+    text_generator = (el if isinstance(el, str) else str(el) for el in i)
+
+    from ._termui_impl import pager
+
+    return pager(itertools.chain(text_generator, "\n"), color)
+
+
+def progressbar(
+    iterable: t.Optional[t.Iterable[V]] = None,
+    length: t.Optional[int] = None,
+    label: t.Optional[str] = None,
+    show_eta: bool = True,
+    show_percent: t.Optional[bool] = None,
+    show_pos: bool = False,
+    item_show_func: t.Optional[t.Callable[[t.Optional[V]], t.Optional[str]]] = None,
+    fill_char: str = "#",
+    empty_char: str = "-",
+    bar_template: str = "%(label)s  [%(bar)s]  %(info)s",
+    info_sep: str = "  ",
+    width: int = 36,
+    file: t.Optional[t.TextIO] = None,
+    color: t.Optional[bool] = None,
+    update_min_steps: int = 1,
+) -> "ProgressBar[V]":
+    """This function creates an iterable context manager that can be used
+    to iterate over something while showing a progress bar.  It will
+    either iterate over the `iterable` or `length` items (that are counted
+    up).  While iteration happens, this function will print a rendered
+    progress bar to the given `file` (defaults to stdout) and will attempt
+    to calculate remaining time and more.  By default, this progress bar
+    will not be rendered if the file is not a terminal.
+
+    The context manager creates the progress bar.  When the context
+    manager is entered the progress bar is already created.  With every
+    iteration over the progress bar, the iterable passed to the bar is
+    advanced and the bar is updated.  When the context manager exits,
+    a newline is printed and the progress bar is finalized on screen.
+
+    Note: The progress bar is currently designed for use cases where the
+    total progress can be expected to take at least several seconds.
+    Because of this, the ProgressBar class object won't display
+    progress that is considered too fast, and progress where the time
+    between steps is less than a second.
+
+    No printing must happen or the progress bar will be unintentionally
+    destroyed.
+
+    Example usage::
+
+        with progressbar(items) as bar:
+            for item in bar:
+                do_something_with(item)
+
+    Alternatively, if no iterable is specified, one can manually update the
+    progress bar through the `update()` method instead of directly
+    iterating over the progress bar.  The update method accepts the number
+    of steps to increment the bar with::
+
+        with progressbar(length=chunks.total_bytes) as bar:
+            for chunk in chunks:
+                process_chunk(chunk)
+                bar.update(chunks.bytes)
+
+    The ``update()`` method also takes an optional value specifying the
+    ``current_item`` at the new position. This is useful when used
+    together with ``item_show_func`` to customize the output for each
+    manual step::
+
+        with click.progressbar(
+            length=total_size,
+            label='Unzipping archive',
+            item_show_func=lambda a: a.filename
+        ) as bar:
+            for archive in zip_file:
+                archive.extract()
+                bar.update(archive.size, archive)
+
+    :param iterable: an iterable to iterate over.  If not provided the length
+                     is required.
+    :param length: the number of items to iterate over.  By default the
+                   progressbar will attempt to ask the iterator about its
+                   length, which might or might not work.  If an iterable is
+                   also provided this parameter can be used to override the
+                   length.  If an iterable is not provided the progress bar
+                   will iterate over a range of that length.
+    :param label: the label to show next to the progress bar.
+    :param show_eta: enables or disables the estimated time display.  This is
+                     automatically disabled if the length cannot be
+                     determined.
+    :param show_percent: enables or disables the percentage display.  The
+                         default is `True` if the iterable has a length or
+                         `False` if not.
+    :param show_pos: enables or disables the absolute position display.  The
+                     default is `False`.
+    :param item_show_func: A function called with the current item which
+        can return a string to show next to the progress bar. If the
+        function returns ``None`` nothing is shown. The current item can
+        be ``None``, such as when entering and exiting the bar.
+    :param fill_char: the character to use to show the filled part of the
+                      progress bar.
+    :param empty_char: the character to use to show the non-filled part of
+                       the progress bar.
+    :param bar_template: the format string to use as template for the bar.
+                         The parameters in it are ``label`` for the label,
+                         ``bar`` for the progress bar and ``info`` for the
+                         info section.
+    :param info_sep: the separator between multiple info items (eta etc.)
+    :param width: the width of the progress bar in characters, 0 means full
+                  terminal width
+    :param file: The file to write to. If this is not a terminal then
+        only the label is printed.
+    :param color: controls if the terminal supports ANSI colors or not.  The
+                  default is autodetection.  This is only needed if ANSI
+                  codes are included anywhere in the progress bar output
+                  which is not the case by default.
+    :param update_min_steps: Render only when this many updates have
+        completed. This allows tuning for very fast iterators.
+
+    .. versionchanged:: 8.0
+        Output is shown even if execution time is less than 0.5 seconds.
+
+    .. versionchanged:: 8.0
+        ``item_show_func`` shows the current item, not the previous one.
+
+    .. versionchanged:: 8.0
+        Labels are echoed if the output is not a TTY. Reverts a change
+        in 7.0 that removed all output.
+
+    .. versionadded:: 8.0
+       Added the ``update_min_steps`` parameter.
+
+    .. versionchanged:: 4.0
+        Added the ``color`` parameter. Added the ``update`` method to
+        the object.
+
+    .. versionadded:: 2.0
+    """
+    from ._termui_impl import ProgressBar
+
+    color = resolve_color_default(color)
+    return ProgressBar(
+        iterable=iterable,
+        length=length,
+        show_eta=show_eta,
+        show_percent=show_percent,
+        show_pos=show_pos,
+        item_show_func=item_show_func,
+        fill_char=fill_char,
+        empty_char=empty_char,
+        bar_template=bar_template,
+        info_sep=info_sep,
+        file=file,
+        label=label,
+        width=width,
+        color=color,
+        update_min_steps=update_min_steps,
+    )
+
+
+def clear() -> None:
+    """Clears the terminal screen.  This will have the effect of clearing
+    the whole visible space of the terminal and moving the cursor to the
+    top left.  This does not do anything if not connected to a terminal.
+
+    .. versionadded:: 2.0
+    """
+    if not isatty(sys.stdout):
+        return
+    if WIN:
+        os.system("cls")
+    else:
+        sys.stdout.write("\033[2J\033[1;1H")
+
+
+def _interpret_color(
+    color: t.Union[int, t.Tuple[int, int, int], str], offset: int = 0
+) -> str:
+    if isinstance(color, int):
+        return f"{38 + offset};5;{color:d}"
+
+    if isinstance(color, (tuple, list)):
+        r, g, b = color
+        return f"{38 + offset};2;{r:d};{g:d};{b:d}"
+
+    return str(_ansi_colors[color] + offset)
+
+
+def style(
+    text: t.Any,
+    fg: t.Optional[t.Union[int, t.Tuple[int, int, int], str]] = None,
+    bg: t.Optional[t.Union[int, t.Tuple[int, int, int], str]] = None,
+    bold: t.Optional[bool] = None,
+    dim: t.Optional[bool] = None,
+    underline: t.Optional[bool] = None,
+    overline: t.Optional[bool] = None,
+    italic: t.Optional[bool] = None,
+    blink: t.Optional[bool] = None,
+    reverse: t.Optional[bool] = None,
+    strikethrough: t.Optional[bool] = None,
+    reset: bool = True,
+) -> str:
+    """Styles a text with ANSI styles and returns the new string.  By
+    default the styling is self contained which means that at the end
+    of the string a reset code is issued.  This can be prevented by
+    passing ``reset=False``.
+
+    Examples::
+
+        click.echo(click.style('Hello World!', fg='green'))
+        click.echo(click.style('ATTENTION!', blink=True))
+        click.echo(click.style('Some things', reverse=True, fg='cyan'))
+        click.echo(click.style('More colors', fg=(255, 12, 128), bg=117))
+
+    Supported color names:
+
+    * ``black`` (might be a gray)
+    * ``red``
+    * ``green``
+    * ``yellow`` (might be an orange)
+    * ``blue``
+    * ``magenta``
+    * ``cyan``
+    * ``white`` (might be light gray)
+    * ``bright_black``
+    * ``bright_red``
+    * ``bright_green``
+    * ``bright_yellow``
+    * ``bright_blue``
+    * ``bright_magenta``
+    * ``bright_cyan``
+    * ``bright_white``
+    * ``reset`` (reset the color code only)
+
+    If the terminal supports it, color may also be specified as:
+
+    -   An integer in the interval [0, 255]. The terminal must support
+        8-bit/256-color mode.
+    -   An RGB tuple of three integers in [0, 255]. The terminal must
+        support 24-bit/true-color mode.
+
+    See https://en.wikipedia.org/wiki/ANSI_color and
+    https://gist.github.com/XVilka/8346728 for more information.
+
+    :param text: the string to style with ansi codes.
+    :param fg: if provided this will become the foreground color.
+    :param bg: if provided this will become the background color.
+    :param bold: if provided this will enable or disable bold mode.
+    :param dim: if provided this will enable or disable dim mode.  This is
+                badly supported.
+    :param underline: if provided this will enable or disable underline.
+    :param overline: if provided this will enable or disable overline.
+    :param italic: if provided this will enable or disable italic.
+    :param blink: if provided this will enable or disable blinking.
+    :param reverse: if provided this will enable or disable inverse
+                    rendering (foreground becomes background and the
+                    other way round).
+    :param strikethrough: if provided this will enable or disable
+        striking through text.
+    :param reset: by default a reset-all code is added at the end of the
+                  string which means that styles do not carry over.  This
+                  can be disabled to compose styles.
+
+    .. versionchanged:: 8.0
+        A non-string ``message`` is converted to a string.
+
+    .. versionchanged:: 8.0
+       Added support for 256 and RGB color codes.
+
+    .. versionchanged:: 8.0
+        Added the ``strikethrough``, ``italic``, and ``overline``
+        parameters.
+
+    .. versionchanged:: 7.0
+        Added support for bright colors.
+
+    .. versionadded:: 2.0
+    """
+    if not isinstance(text, str):
+        text = str(text)
+
+    bits = []
+
+    if fg:
+        try:
+            bits.append(f"\033[{_interpret_color(fg)}m")
+        except KeyError:
+            raise TypeError(f"Unknown color {fg!r}") from None
+
+    if bg:
+        try:
+            bits.append(f"\033[{_interpret_color(bg, 10)}m")
+        except KeyError:
+            raise TypeError(f"Unknown color {bg!r}") from None
+
+    if bold is not None:
+        bits.append(f"\033[{1 if bold else 22}m")
+    if dim is not None:
+        bits.append(f"\033[{2 if dim else 22}m")
+    if underline is not None:
+        bits.append(f"\033[{4 if underline else 24}m")
+    if overline is not None:
+        bits.append(f"\033[{53 if overline else 55}m")
+    if italic is not None:
+        bits.append(f"\033[{3 if italic else 23}m")
+    if blink is not None:
+        bits.append(f"\033[{5 if blink else 25}m")
+    if reverse is not None:
+        bits.append(f"\033[{7 if reverse else 27}m")
+    if strikethrough is not None:
+        bits.append(f"\033[{9 if strikethrough else 29}m")
+    bits.append(text)
+    if reset:
+        bits.append(_ansi_reset_all)
+    return "".join(bits)
+
+
+def unstyle(text: str) -> str:
+    """Removes ANSI styling information from a string.  Usually it's not
+    necessary to use this function as Click's echo function will
+    automatically remove styling if necessary.
+
+    .. versionadded:: 2.0
+
+    :param text: the text to remove style information from.
+    """
+    return strip_ansi(text)
+
+
+def secho(
+    message: t.Optional[t.Any] = None,
+    file: t.Optional[t.IO[t.AnyStr]] = None,
+    nl: bool = True,
+    err: bool = False,
+    color: t.Optional[bool] = None,
+    **styles: t.Any,
+) -> None:
+    """This function combines :func:`echo` and :func:`style` into one
+    call.  As such the following two calls are the same::
+
+        click.secho('Hello World!', fg='green')
+        click.echo(click.style('Hello World!', fg='green'))
+
+    All keyword arguments are forwarded to the underlying functions
+    depending on which one they go with.
+
+    Non-string types will be converted to :class:`str`. However,
+    :class:`bytes` are passed directly to :meth:`echo` without applying
+    style. If you want to style bytes that represent text, call
+    :meth:`bytes.decode` first.
+
+    .. versionchanged:: 8.0
+        A non-string ``message`` is converted to a string. Bytes are
+        passed through without style applied.
+
+    .. versionadded:: 2.0
+    """
+    if message is not None and not isinstance(message, (bytes, bytearray)):
+        message = style(message, **styles)
+
+    return echo(message, file=file, nl=nl, err=err, color=color)
+
+
+def edit(
+    text: t.Optional[t.AnyStr] = None,
+    editor: t.Optional[str] = None,
+    env: t.Optional[t.Mapping[str, str]] = None,
+    require_save: bool = True,
+    extension: str = ".txt",
+    filename: t.Optional[str] = None,
+) -> t.Optional[t.AnyStr]:
+    r"""Edits the given text in the defined editor.  If an editor is given
+    (should be the full path to the executable but the regular operating
+    system search path is used for finding the executable) it overrides
+    the detected editor.  Optionally, some environment variables can be
+    used.  If the editor is closed without changes, `None` is returned.  In
+    case a file is edited directly the return value is always `None` and
+    `require_save` and `extension` are ignored.
+
+    If the editor cannot be opened a :exc:`UsageError` is raised.
+
+    Note for Windows: to simplify cross-platform usage, the newlines are
+    automatically converted from POSIX to Windows and vice versa.  As such,
+    the message here will have ``\n`` as newline markers.
+
+    :param text: the text to edit.
+    :param editor: optionally the editor to use.  Defaults to automatic
+                   detection.
+    :param env: environment variables to forward to the editor.
+    :param require_save: if this is true, then not saving in the editor
+                         will make the return value become `None`.
+    :param extension: the extension to tell the editor about.  This defaults
+                      to `.txt` but changing this might change syntax
+                      highlighting.
+    :param filename: if provided it will edit this file instead of the
+                     provided text contents.  It will not use a temporary
+                     file as an indirection in that case.
+    """
+    from ._termui_impl import Editor
+
+    ed = Editor(editor=editor, env=env, require_save=require_save, extension=extension)
+
+    if filename is None:
+        return ed.edit(text)
+
+    ed.edit_file(filename)
+    return None
+
+
+def launch(url: str, wait: bool = False, locate: bool = False) -> int:
+    """This function launches the given URL (or filename) in the default
+    viewer application for this file type.  If this is an executable, it
+    might launch the executable in a new session.  The return value is
+    the exit code of the launched application.  Usually, ``0`` indicates
+    success.
+
+    Examples::
+
+        click.launch('https://click.palletsprojects.com/')
+        click.launch('/my/downloaded/file', locate=True)
+
+    .. versionadded:: 2.0
+
+    :param url: URL or filename of the thing to launch.
+    :param wait: Wait for the program to exit before returning. This
+        only works if the launched program blocks. In particular,
+        ``xdg-open`` on Linux does not block.
+    :param locate: if this is set to `True` then instead of launching the
+                   application associated with the URL it will attempt to
+                   launch a file manager with the file located.  This
+                   might have weird effects if the URL does not point to
+                   the filesystem.
+    """
+    from ._termui_impl import open_url
+
+    return open_url(url, wait=wait, locate=locate)
+
+
+# If this is provided, getchar() calls into this instead.  This is used
+# for unittesting purposes.
+_getchar: t.Optional[t.Callable[[bool], str]] = None
+
+
+def getchar(echo: bool = False) -> str:
+    """Fetches a single character from the terminal and returns it.  This
+    will always return a unicode character and under certain rare
+    circumstances this might return more than one character.  The
+    situations which more than one character is returned is when for
+    whatever reason multiple characters end up in the terminal buffer or
+    standard input was not actually a terminal.
+
+    Note that this will always read from the terminal, even if something
+    is piped into the standard input.
+
+    Note for Windows: in rare cases when typing non-ASCII characters, this
+    function might wait for a second character and then return both at once.
+    This is because certain Unicode characters look like special-key markers.
+
+    .. versionadded:: 2.0
+
+    :param echo: if set to `True`, the character read will also show up on
+                 the terminal.  The default is to not show it.
+    """
+    global _getchar
+
+    if _getchar is None:
+        from ._termui_impl import getchar as f
+
+        _getchar = f
+
+    return _getchar(echo)
+
+
+def raw_terminal() -> t.ContextManager[int]:
+    from ._termui_impl import raw_terminal as f
+
+    return f()
+
+
+def pause(info: t.Optional[str] = None, err: bool = False) -> None:
+    """This command stops execution and waits for the user to press any
+    key to continue.  This is similar to the Windows batch "pause"
+    command.  If the program is not run through a terminal, this command
+    will instead do nothing.
+
+    .. versionadded:: 2.0
+
+    .. versionadded:: 4.0
+       Added the `err` parameter.
+
+    :param info: The message to print before pausing. Defaults to
+        ``"Press any key to continue..."``.
+    :param err: if set to message goes to ``stderr`` instead of
+                ``stdout``, the same as with echo.
+    """
+    if not isatty(sys.stdin) or not isatty(sys.stdout):
+        return
+
+    if info is None:
+        info = _("Press any key to continue...")
+
+    try:
+        if info:
+            echo(info, nl=False, err=err)
+        try:
+            getchar()
+        except (KeyboardInterrupt, EOFError):
+            pass
+    finally:
+        if info:
+            echo(err=err)
diff --git a/myenv/lib/python3.9/site-packages/click/testing.py b/myenv/lib/python3.9/site-packages/click/testing.py
new file mode 100644
index 0000000..e395c2e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/testing.py
@@ -0,0 +1,479 @@
+import contextlib
+import io
+import os
+import shlex
+import shutil
+import sys
+import tempfile
+import typing as t
+from types import TracebackType
+
+from . import formatting
+from . import termui
+from . import utils
+from ._compat import _find_binary_reader
+
+if t.TYPE_CHECKING:
+    from .core import BaseCommand
+
+
+class EchoingStdin:
+    def __init__(self, input: t.BinaryIO, output: t.BinaryIO) -> None:
+        self._input = input
+        self._output = output
+        self._paused = False
+
+    def __getattr__(self, x: str) -> t.Any:
+        return getattr(self._input, x)
+
+    def _echo(self, rv: bytes) -> bytes:
+        if not self._paused:
+            self._output.write(rv)
+
+        return rv
+
+    def read(self, n: int = -1) -> bytes:
+        return self._echo(self._input.read(n))
+
+    def read1(self, n: int = -1) -> bytes:
+        return self._echo(self._input.read1(n))  # type: ignore
+
+    def readline(self, n: int = -1) -> bytes:
+        return self._echo(self._input.readline(n))
+
+    def readlines(self) -> t.List[bytes]:
+        return [self._echo(x) for x in self._input.readlines()]
+
+    def __iter__(self) -> t.Iterator[bytes]:
+        return iter(self._echo(x) for x in self._input)
+
+    def __repr__(self) -> str:
+        return repr(self._input)
+
+
+@contextlib.contextmanager
+def _pause_echo(stream: t.Optional[EchoingStdin]) -> t.Iterator[None]:
+    if stream is None:
+        yield
+    else:
+        stream._paused = True
+        yield
+        stream._paused = False
+
+
+class _NamedTextIOWrapper(io.TextIOWrapper):
+    def __init__(
+        self, buffer: t.BinaryIO, name: str, mode: str, **kwargs: t.Any
+    ) -> None:
+        super().__init__(buffer, **kwargs)
+        self._name = name
+        self._mode = mode
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def mode(self) -> str:
+        return self._mode
+
+
+def make_input_stream(
+    input: t.Optional[t.Union[str, bytes, t.IO]], charset: str
+) -> t.BinaryIO:
+    # Is already an input stream.
+    if hasattr(input, "read"):
+        rv = _find_binary_reader(t.cast(t.IO, input))
+
+        if rv is not None:
+            return rv
+
+        raise TypeError("Could not find binary reader for input stream.")
+
+    if input is None:
+        input = b""
+    elif isinstance(input, str):
+        input = input.encode(charset)
+
+    return io.BytesIO(t.cast(bytes, input))
+
+
+class Result:
+    """Holds the captured result of an invoked CLI script."""
+
+    def __init__(
+        self,
+        runner: "CliRunner",
+        stdout_bytes: bytes,
+        stderr_bytes: t.Optional[bytes],
+        return_value: t.Any,
+        exit_code: int,
+        exception: t.Optional[BaseException],
+        exc_info: t.Optional[
+            t.Tuple[t.Type[BaseException], BaseException, TracebackType]
+        ] = None,
+    ):
+        #: The runner that created the result
+        self.runner = runner
+        #: The standard output as bytes.
+        self.stdout_bytes = stdout_bytes
+        #: The standard error as bytes, or None if not available
+        self.stderr_bytes = stderr_bytes
+        #: The value returned from the invoked command.
+        #:
+        #: .. versionadded:: 8.0
+        self.return_value = return_value
+        #: The exit code as integer.
+        self.exit_code = exit_code
+        #: The exception that happened if one did.
+        self.exception = exception
+        #: The traceback
+        self.exc_info = exc_info
+
+    @property
+    def output(self) -> str:
+        """The (standard) output as unicode string."""
+        return self.stdout
+
+    @property
+    def stdout(self) -> str:
+        """The standard output as unicode string."""
+        return self.stdout_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
+
+    @property
+    def stderr(self) -> str:
+        """The standard error as unicode string."""
+        if self.stderr_bytes is None:
+            raise ValueError("stderr not separately captured")
+        return self.stderr_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
+
+    def __repr__(self) -> str:
+        exc_str = repr(self.exception) if self.exception else "okay"
+        return f"<{type(self).__name__} {exc_str}>"
+
+
+class CliRunner:
+    """The CLI runner provides functionality to invoke a Click command line
+    script for unittesting purposes in a isolated environment.  This only
+    works in single-threaded systems without any concurrency as it changes the
+    global interpreter state.
+
+    :param charset: the character set for the input and output data.
+    :param env: a dictionary with environment variables for overriding.
+    :param echo_stdin: if this is set to `True`, then reading from stdin writes
+                       to stdout.  This is useful for showing examples in
+                       some circumstances.  Note that regular prompts
+                       will automatically echo the input.
+    :param mix_stderr: if this is set to `False`, then stdout and stderr are
+                       preserved as independent streams.  This is useful for
+                       Unix-philosophy apps that have predictable stdout and
+                       noisy stderr, such that each may be measured
+                       independently
+    """
+
+    def __init__(
+        self,
+        charset: str = "utf-8",
+        env: t.Optional[t.Mapping[str, t.Optional[str]]] = None,
+        echo_stdin: bool = False,
+        mix_stderr: bool = True,
+    ) -> None:
+        self.charset = charset
+        self.env = env or {}
+        self.echo_stdin = echo_stdin
+        self.mix_stderr = mix_stderr
+
+    def get_default_prog_name(self, cli: "BaseCommand") -> str:
+        """Given a command object it will return the default program name
+        for it.  The default is the `name` attribute or ``"root"`` if not
+        set.
+        """
+        return cli.name or "root"
+
+    def make_env(
+        self, overrides: t.Optional[t.Mapping[str, t.Optional[str]]] = None
+    ) -> t.Mapping[str, t.Optional[str]]:
+        """Returns the environment overrides for invoking a script."""
+        rv = dict(self.env)
+        if overrides:
+            rv.update(overrides)
+        return rv
+
+    @contextlib.contextmanager
+    def isolation(
+        self,
+        input: t.Optional[t.Union[str, bytes, t.IO]] = None,
+        env: t.Optional[t.Mapping[str, t.Optional[str]]] = None,
+        color: bool = False,
+    ) -> t.Iterator[t.Tuple[io.BytesIO, t.Optional[io.BytesIO]]]:
+        """A context manager that sets up the isolation for invoking of a
+        command line tool.  This sets up stdin with the given input data
+        and `os.environ` with the overrides from the given dictionary.
+        This also rebinds some internals in Click to be mocked (like the
+        prompt functionality).
+
+        This is automatically done in the :meth:`invoke` method.
+
+        :param input: the input stream to put into sys.stdin.
+        :param env: the environment overrides as dictionary.
+        :param color: whether the output should contain color codes. The
+                      application can still override this explicitly.
+
+        .. versionchanged:: 8.0
+            ``stderr`` is opened with ``errors="backslashreplace"``
+            instead of the default ``"strict"``.
+
+        .. versionchanged:: 4.0
+            Added the ``color`` parameter.
+        """
+        bytes_input = make_input_stream(input, self.charset)
+        echo_input = None
+
+        old_stdin = sys.stdin
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        old_forced_width = formatting.FORCED_WIDTH
+        formatting.FORCED_WIDTH = 80
+
+        env = self.make_env(env)
+
+        bytes_output = io.BytesIO()
+
+        if self.echo_stdin:
+            bytes_input = echo_input = t.cast(
+                t.BinaryIO, EchoingStdin(bytes_input, bytes_output)
+            )
+
+        sys.stdin = text_input = _NamedTextIOWrapper(
+            bytes_input, encoding=self.charset, name="<stdin>", mode="r"
+        )
+
+        if self.echo_stdin:
+            # Force unbuffered reads, otherwise TextIOWrapper reads a
+            # large chunk which is echoed early.
+            text_input._CHUNK_SIZE = 1  # type: ignore
+
+        sys.stdout = _NamedTextIOWrapper(
+            bytes_output, encoding=self.charset, name="<stdout>", mode="w"
+        )
+
+        bytes_error = None
+        if self.mix_stderr:
+            sys.stderr = sys.stdout
+        else:
+            bytes_error = io.BytesIO()
+            sys.stderr = _NamedTextIOWrapper(
+                bytes_error,
+                encoding=self.charset,
+                name="<stderr>",
+                mode="w",
+                errors="backslashreplace",
+            )
+
+        @_pause_echo(echo_input)  # type: ignore
+        def visible_input(prompt: t.Optional[str] = None) -> str:
+            sys.stdout.write(prompt or "")
+            val = text_input.readline().rstrip("\r\n")
+            sys.stdout.write(f"{val}\n")
+            sys.stdout.flush()
+            return val
+
+        @_pause_echo(echo_input)  # type: ignore
+        def hidden_input(prompt: t.Optional[str] = None) -> str:
+            sys.stdout.write(f"{prompt or ''}\n")
+            sys.stdout.flush()
+            return text_input.readline().rstrip("\r\n")
+
+        @_pause_echo(echo_input)  # type: ignore
+        def _getchar(echo: bool) -> str:
+            char = sys.stdin.read(1)
+
+            if echo:
+                sys.stdout.write(char)
+
+            sys.stdout.flush()
+            return char
+
+        default_color = color
+
+        def should_strip_ansi(
+            stream: t.Optional[t.IO] = None, color: t.Optional[bool] = None
+        ) -> bool:
+            if color is None:
+                return not default_color
+            return not color
+
+        old_visible_prompt_func = termui.visible_prompt_func
+        old_hidden_prompt_func = termui.hidden_prompt_func
+        old__getchar_func = termui._getchar
+        old_should_strip_ansi = utils.should_strip_ansi  # type: ignore
+        termui.visible_prompt_func = visible_input
+        termui.hidden_prompt_func = hidden_input
+        termui._getchar = _getchar
+        utils.should_strip_ansi = should_strip_ansi  # type: ignore
+
+        old_env = {}
+        try:
+            for key, value in env.items():
+                old_env[key] = os.environ.get(key)
+                if value is None:
+                    try:
+                        del os.environ[key]
+                    except Exception:
+                        pass
+                else:
+                    os.environ[key] = value
+            yield (bytes_output, bytes_error)
+        finally:
+            for key, value in old_env.items():
+                if value is None:
+                    try:
+                        del os.environ[key]
+                    except Exception:
+                        pass
+                else:
+                    os.environ[key] = value
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+            sys.stdin = old_stdin
+            termui.visible_prompt_func = old_visible_prompt_func
+            termui.hidden_prompt_func = old_hidden_prompt_func
+            termui._getchar = old__getchar_func
+            utils.should_strip_ansi = old_should_strip_ansi  # type: ignore
+            formatting.FORCED_WIDTH = old_forced_width
+
+    def invoke(
+        self,
+        cli: "BaseCommand",
+        args: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        input: t.Optional[t.Union[str, bytes, t.IO]] = None,
+        env: t.Optional[t.Mapping[str, t.Optional[str]]] = None,
+        catch_exceptions: bool = True,
+        color: bool = False,
+        **extra: t.Any,
+    ) -> Result:
+        """Invokes a command in an isolated environment.  The arguments are
+        forwarded directly to the command line script, the `extra` keyword
+        arguments are passed to the :meth:`~clickpkg.Command.main` function of
+        the command.
+
+        This returns a :class:`Result` object.
+
+        :param cli: the command to invoke
+        :param args: the arguments to invoke. It may be given as an iterable
+                     or a string. When given as string it will be interpreted
+                     as a Unix shell command. More details at
+                     :func:`shlex.split`.
+        :param input: the input data for `sys.stdin`.
+        :param env: the environment overrides.
+        :param catch_exceptions: Whether to catch any other exceptions than
+                                 ``SystemExit``.
+        :param extra: the keyword arguments to pass to :meth:`main`.
+        :param color: whether the output should contain color codes. The
+                      application can still override this explicitly.
+
+        .. versionchanged:: 8.0
+            The result object has the ``return_value`` attribute with
+            the value returned from the invoked command.
+
+        .. versionchanged:: 4.0
+            Added the ``color`` parameter.
+
+        .. versionchanged:: 3.0
+            Added the ``catch_exceptions`` parameter.
+
+        .. versionchanged:: 3.0
+            The result object has the ``exc_info`` attribute with the
+            traceback if available.
+        """
+        exc_info = None
+        with self.isolation(input=input, env=env, color=color) as outstreams:
+            return_value = None
+            exception: t.Optional[BaseException] = None
+            exit_code = 0
+
+            if isinstance(args, str):
+                args = shlex.split(args)
+
+            try:
+                prog_name = extra.pop("prog_name")
+            except KeyError:
+                prog_name = self.get_default_prog_name(cli)
+
+            try:
+                return_value = cli.main(args=args or (), prog_name=prog_name, **extra)
+            except SystemExit as e:
+                exc_info = sys.exc_info()
+                e_code = t.cast(t.Optional[t.Union[int, t.Any]], e.code)
+
+                if e_code is None:
+                    e_code = 0
+
+                if e_code != 0:
+                    exception = e
+
+                if not isinstance(e_code, int):
+                    sys.stdout.write(str(e_code))
+                    sys.stdout.write("\n")
+                    e_code = 1
+
+                exit_code = e_code
+
+            except Exception as e:
+                if not catch_exceptions:
+                    raise
+                exception = e
+                exit_code = 1
+                exc_info = sys.exc_info()
+            finally:
+                sys.stdout.flush()
+                stdout = outstreams[0].getvalue()
+                if self.mix_stderr:
+                    stderr = None
+                else:
+                    stderr = outstreams[1].getvalue()  # type: ignore
+
+        return Result(
+            runner=self,
+            stdout_bytes=stdout,
+            stderr_bytes=stderr,
+            return_value=return_value,
+            exit_code=exit_code,
+            exception=exception,
+            exc_info=exc_info,  # type: ignore
+        )
+
+    @contextlib.contextmanager
+    def isolated_filesystem(
+        self, temp_dir: t.Optional[t.Union[str, os.PathLike]] = None
+    ) -> t.Iterator[str]:
+        """A context manager that creates a temporary directory and
+        changes the current working directory to it. This isolates tests
+        that affect the contents of the CWD to prevent them from
+        interfering with each other.
+
+        :param temp_dir: Create the temporary directory under this
+            directory. If given, the created directory is not removed
+            when exiting.
+
+        .. versionchanged:: 8.0
+            Added the ``temp_dir`` parameter.
+        """
+        cwd = os.getcwd()
+        dt = tempfile.mkdtemp(dir=temp_dir)  # type: ignore[type-var]
+        os.chdir(dt)
+
+        try:
+            yield t.cast(str, dt)
+        finally:
+            os.chdir(cwd)
+
+            if temp_dir is None:
+                try:
+                    shutil.rmtree(dt)
+                except OSError:  # noqa: B014
+                    pass
diff --git a/myenv/lib/python3.9/site-packages/click/types.py b/myenv/lib/python3.9/site-packages/click/types.py
new file mode 100644
index 0000000..b45ee53
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/types.py
@@ -0,0 +1,1073 @@
+import os
+import stat
+import typing as t
+from datetime import datetime
+from gettext import gettext as _
+from gettext import ngettext
+
+from ._compat import _get_argv_encoding
+from ._compat import get_filesystem_encoding
+from ._compat import open_stream
+from .exceptions import BadParameter
+from .utils import LazyFile
+from .utils import safecall
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .core import Context
+    from .core import Parameter
+    from .shell_completion import CompletionItem
+
+
+class ParamType:
+    """Represents the type of a parameter. Validates and converts values
+    from the command line or Python into the correct type.
+
+    To implement a custom type, subclass and implement at least the
+    following:
+
+    -   The :attr:`name` class attribute must be set.
+    -   Calling an instance of the type with ``None`` must return
+        ``None``. This is already implemented by default.
+    -   :meth:`convert` must convert string values to the correct type.
+    -   :meth:`convert` must accept values that are already the correct
+        type.
+    -   It must be able to convert a value if the ``ctx`` and ``param``
+        arguments are ``None``. This can occur when converting prompt
+        input.
+    """
+
+    is_composite: t.ClassVar[bool] = False
+    arity: t.ClassVar[int] = 1
+
+    #: the descriptive name of this type
+    name: str
+
+    #: if a list of this type is expected and the value is pulled from a
+    #: string environment variable, this is what splits it up.  `None`
+    #: means any whitespace.  For all parameters the general rule is that
+    #: whitespace splits them up.  The exception are paths and files which
+    #: are split by ``os.path.pathsep`` by default (":" on Unix and ";" on
+    #: Windows).
+    envvar_list_splitter: t.ClassVar[t.Optional[str]] = None
+
+    def to_info_dict(self) -> t.Dict[str, t.Any]:
+        """Gather information that could be useful for a tool generating
+        user-facing documentation.
+
+        Use :meth:`click.Context.to_info_dict` to traverse the entire
+        CLI structure.
+
+        .. versionadded:: 8.0
+        """
+        # The class name without the "ParamType" suffix.
+        param_type = type(self).__name__.partition("ParamType")[0]
+        param_type = param_type.partition("ParameterType")[0]
+
+        # Custom subclasses might not remember to set a name.
+        if hasattr(self, "name"):
+            name = self.name
+        else:
+            name = param_type
+
+        return {"param_type": param_type, "name": name}
+
+    def __call__(
+        self,
+        value: t.Any,
+        param: t.Optional["Parameter"] = None,
+        ctx: t.Optional["Context"] = None,
+    ) -> t.Any:
+        if value is not None:
+            return self.convert(value, param, ctx)
+
+    def get_metavar(self, param: "Parameter") -> t.Optional[str]:
+        """Returns the metavar default for this param if it provides one."""
+
+    def get_missing_message(self, param: "Parameter") -> t.Optional[str]:
+        """Optionally might return extra information about a missing
+        parameter.
+
+        .. versionadded:: 2.0
+        """
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        """Convert the value to the correct type. This is not called if
+        the value is ``None`` (the missing value).
+
+        This must accept string values from the command line, as well as
+        values that are already the correct type. It may also convert
+        other compatible types.
+
+        The ``param`` and ``ctx`` arguments may be ``None`` in certain
+        situations, such as when converting prompt input.
+
+        If the value cannot be converted, call :meth:`fail` with a
+        descriptive message.
+
+        :param value: The value to convert.
+        :param param: The parameter that is using this type to convert
+            its value. May be ``None``.
+        :param ctx: The current context that arrived at this value. May
+            be ``None``.
+        """
+        return value
+
+    def split_envvar_value(self, rv: str) -> t.Sequence[str]:
+        """Given a value from an environment variable this splits it up
+        into small chunks depending on the defined envvar list splitter.
+
+        If the splitter is set to `None`, which means that whitespace splits,
+        then leading and trailing whitespace is ignored.  Otherwise, leading
+        and trailing splitters usually lead to empty items being included.
+        """
+        return (rv or "").split(self.envvar_list_splitter)
+
+    def fail(
+        self,
+        message: str,
+        param: t.Optional["Parameter"] = None,
+        ctx: t.Optional["Context"] = None,
+    ) -> "t.NoReturn":
+        """Helper method to fail with an invalid value message."""
+        raise BadParameter(message, ctx=ctx, param=param)
+
+    def shell_complete(
+        self, ctx: "Context", param: "Parameter", incomplete: str
+    ) -> t.List["CompletionItem"]:
+        """Return a list of
+        :class:`~click.shell_completion.CompletionItem` objects for the
+        incomplete value. Most types do not provide completions, but
+        some do, and this allows custom types to provide custom
+        completions as well.
+
+        :param ctx: Invocation context for this command.
+        :param param: The parameter that is requesting completion.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        return []
+
+
+class CompositeParamType(ParamType):
+    is_composite = True
+
+    @property
+    def arity(self) -> int:  # type: ignore
+        raise NotImplementedError()
+
+
+class FuncParamType(ParamType):
+    def __init__(self, func: t.Callable[[t.Any], t.Any]) -> None:
+        self.name = func.__name__
+        self.func = func
+
+    def to_info_dict(self) -> t.Dict[str, t.Any]:
+        info_dict = super().to_info_dict()
+        info_dict["func"] = self.func
+        return info_dict
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        try:
+            return self.func(value)
+        except ValueError:
+            try:
+                value = str(value)
+            except UnicodeError:
+                value = value.decode("utf-8", "replace")
+
+            self.fail(value, param, ctx)
+
+
+class UnprocessedParamType(ParamType):
+    name = "text"
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        return value
+
+    def __repr__(self) -> str:
+        return "UNPROCESSED"
+
+
+class StringParamType(ParamType):
+    name = "text"
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        if isinstance(value, bytes):
+            enc = _get_argv_encoding()
+            try:
+                value = value.decode(enc)
+            except UnicodeError:
+                fs_enc = get_filesystem_encoding()
+                if fs_enc != enc:
+                    try:
+                        value = value.decode(fs_enc)
+                    except UnicodeError:
+                        value = value.decode("utf-8", "replace")
+                else:
+                    value = value.decode("utf-8", "replace")
+            return value
+        return str(value)
+
+    def __repr__(self) -> str:
+        return "STRING"
+
+
+class Choice(ParamType):
+    """The choice type allows a value to be checked against a fixed set
+    of supported values. All of these values have to be strings.
+
+    You should only pass a list or tuple of choices. Other iterables
+    (like generators) may lead to surprising results.
+
+    The resulting value will always be one of the originally passed choices
+    regardless of ``case_sensitive`` or any ``ctx.token_normalize_func``
+    being specified.
+
+    See :ref:`choice-opts` for an example.
+
+    :param case_sensitive: Set to false to make choices case
+        insensitive. Defaults to true.
+    """
+
+    name = "choice"
+
+    def __init__(self, choices: t.Sequence[str], case_sensitive: bool = True) -> None:
+        self.choices = choices
+        self.case_sensitive = case_sensitive
+
+    def to_info_dict(self) -> t.Dict[str, t.Any]:
+        info_dict = super().to_info_dict()
+        info_dict["choices"] = self.choices
+        info_dict["case_sensitive"] = self.case_sensitive
+        return info_dict
+
+    def get_metavar(self, param: "Parameter") -> str:
+        choices_str = "|".join(self.choices)
+
+        # Use curly braces to indicate a required argument.
+        if param.required and param.param_type_name == "argument":
+            return f"{{{choices_str}}}"
+
+        # Use square braces to indicate an option or optional argument.
+        return f"[{choices_str}]"
+
+    def get_missing_message(self, param: "Parameter") -> str:
+        return _("Choose from:\n\t{choices}").format(choices=",\n\t".join(self.choices))
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        # Match through normalization and case sensitivity
+        # first do token_normalize_func, then lowercase
+        # preserve original `value` to produce an accurate message in
+        # `self.fail`
+        normed_value = value
+        normed_choices = {choice: choice for choice in self.choices}
+
+        if ctx is not None and ctx.token_normalize_func is not None:
+            normed_value = ctx.token_normalize_func(value)
+            normed_choices = {
+                ctx.token_normalize_func(normed_choice): original
+                for normed_choice, original in normed_choices.items()
+            }
+
+        if not self.case_sensitive:
+            normed_value = normed_value.casefold()
+            normed_choices = {
+                normed_choice.casefold(): original
+                for normed_choice, original in normed_choices.items()
+            }
+
+        if normed_value in normed_choices:
+            return normed_choices[normed_value]
+
+        choices_str = ", ".join(map(repr, self.choices))
+        self.fail(
+            ngettext(
+                "{value!r} is not {choice}.",
+                "{value!r} is not one of {choices}.",
+                len(self.choices),
+            ).format(value=value, choice=choices_str, choices=choices_str),
+            param,
+            ctx,
+        )
+
+    def __repr__(self) -> str:
+        return f"Choice({list(self.choices)})"
+
+    def shell_complete(
+        self, ctx: "Context", param: "Parameter", incomplete: str
+    ) -> t.List["CompletionItem"]:
+        """Complete choices that start with the incomplete value.
+
+        :param ctx: Invocation context for this command.
+        :param param: The parameter that is requesting completion.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        from click.shell_completion import CompletionItem
+
+        str_choices = map(str, self.choices)
+
+        if self.case_sensitive:
+            matched = (c for c in str_choices if c.startswith(incomplete))
+        else:
+            incomplete = incomplete.lower()
+            matched = (c for c in str_choices if c.lower().startswith(incomplete))
+
+        return [CompletionItem(c) for c in matched]
+
+
+class DateTime(ParamType):
+    """The DateTime type converts date strings into `datetime` objects.
+
+    The format strings which are checked are configurable, but default to some
+    common (non-timezone aware) ISO 8601 formats.
+
+    When specifying *DateTime* formats, you should only pass a list or a tuple.
+    Other iterables, like generators, may lead to surprising results.
+
+    The format strings are processed using ``datetime.strptime``, and this
+    consequently defines the format strings which are allowed.
+
+    Parsing is tried using each format, in order, and the first format which
+    parses successfully is used.
+
+    :param formats: A list or tuple of date format strings, in the order in
+                    which they should be tried. Defaults to
+                    ``'%Y-%m-%d'``, ``'%Y-%m-%dT%H:%M:%S'``,
+                    ``'%Y-%m-%d %H:%M:%S'``.
+    """
+
+    name = "datetime"
+
+    def __init__(self, formats: t.Optional[t.Sequence[str]] = None):
+        self.formats = formats or ["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d %H:%M:%S"]
+
+    def to_info_dict(self) -> t.Dict[str, t.Any]:
+        info_dict = super().to_info_dict()
+        info_dict["formats"] = self.formats
+        return info_dict
+
+    def get_metavar(self, param: "Parameter") -> str:
+        return f"[{'|'.join(self.formats)}]"
+
+    def _try_to_convert_date(self, value: t.Any, format: str) -> t.Optional[datetime]:
+        try:
+            return datetime.strptime(value, format)
+        except ValueError:
+            return None
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        if isinstance(value, datetime):
+            return value
+
+        for format in self.formats:
+            converted = self._try_to_convert_date(value, format)
+
+            if converted is not None:
+                return converted
+
+        formats_str = ", ".join(map(repr, self.formats))
+        self.fail(
+            ngettext(
+                "{value!r} does not match the format {format}.",
+                "{value!r} does not match the formats {formats}.",
+                len(self.formats),
+            ).format(value=value, format=formats_str, formats=formats_str),
+            param,
+            ctx,
+        )
+
+    def __repr__(self) -> str:
+        return "DateTime"
+
+
+class _NumberParamTypeBase(ParamType):
+    _number_class: t.ClassVar[t.Type]
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        try:
+            return self._number_class(value)
+        except ValueError:
+            self.fail(
+                _("{value!r} is not a valid {number_type}.").format(
+                    value=value, number_type=self.name
+                ),
+                param,
+                ctx,
+            )
+
+
+class _NumberRangeBase(_NumberParamTypeBase):
+    def __init__(
+        self,
+        min: t.Optional[float] = None,
+        max: t.Optional[float] = None,
+        min_open: bool = False,
+        max_open: bool = False,
+        clamp: bool = False,
+    ) -> None:
+        self.min = min
+        self.max = max
+        self.min_open = min_open
+        self.max_open = max_open
+        self.clamp = clamp
+
+    def to_info_dict(self) -> t.Dict[str, t.Any]:
+        info_dict = super().to_info_dict()
+        info_dict.update(
+            min=self.min,
+            max=self.max,
+            min_open=self.min_open,
+            max_open=self.max_open,
+            clamp=self.clamp,
+        )
+        return info_dict
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        import operator
+
+        rv = super().convert(value, param, ctx)
+        lt_min: bool = self.min is not None and (
+            operator.le if self.min_open else operator.lt
+        )(rv, self.min)
+        gt_max: bool = self.max is not None and (
+            operator.ge if self.max_open else operator.gt
+        )(rv, self.max)
+
+        if self.clamp:
+            if lt_min:
+                return self._clamp(self.min, 1, self.min_open)  # type: ignore
+
+            if gt_max:
+                return self._clamp(self.max, -1, self.max_open)  # type: ignore
+
+        if lt_min or gt_max:
+            self.fail(
+                _("{value} is not in the range {range}.").format(
+                    value=rv, range=self._describe_range()
+                ),
+                param,
+                ctx,
+            )
+
+        return rv
+
+    def _clamp(self, bound: float, dir: "te.Literal[1, -1]", open: bool) -> float:
+        """Find the valid value to clamp to bound in the given
+        direction.
+
+        :param bound: The boundary value.
+        :param dir: 1 or -1 indicating the direction to move.
+        :param open: If true, the range does not include the bound.
+        """
+        raise NotImplementedError
+
+    def _describe_range(self) -> str:
+        """Describe the range for use in help text."""
+        if self.min is None:
+            op = "<" if self.max_open else "<="
+            return f"x{op}{self.max}"
+
+        if self.max is None:
+            op = ">" if self.min_open else ">="
+            return f"x{op}{self.min}"
+
+        lop = "<" if self.min_open else "<="
+        rop = "<" if self.max_open else "<="
+        return f"{self.min}{lop}x{rop}{self.max}"
+
+    def __repr__(self) -> str:
+        clamp = " clamped" if self.clamp else ""
+        return f"<{type(self).__name__} {self._describe_range()}{clamp}>"
+
+
+class IntParamType(_NumberParamTypeBase):
+    name = "integer"
+    _number_class = int
+
+    def __repr__(self) -> str:
+        return "INT"
+
+
+class IntRange(_NumberRangeBase, IntParamType):
+    """Restrict an :data:`click.INT` value to a range of accepted
+    values. See :ref:`ranges`.
+
+    If ``min`` or ``max`` are not passed, any value is accepted in that
+    direction. If ``min_open`` or ``max_open`` are enabled, the
+    corresponding boundary is not included in the range.
+
+    If ``clamp`` is enabled, a value outside the range is clamped to the
+    boundary instead of failing.
+
+    .. versionchanged:: 8.0
+        Added the ``min_open`` and ``max_open`` parameters.
+    """
+
+    name = "integer range"
+
+    def _clamp(  # type: ignore
+        self, bound: int, dir: "te.Literal[1, -1]", open: bool
+    ) -> int:
+        if not open:
+            return bound
+
+        return bound + dir
+
+
+class FloatParamType(_NumberParamTypeBase):
+    name = "float"
+    _number_class = float
+
+    def __repr__(self) -> str:
+        return "FLOAT"
+
+
+class FloatRange(_NumberRangeBase, FloatParamType):
+    """Restrict a :data:`click.FLOAT` value to a range of accepted
+    values. See :ref:`ranges`.
+
+    If ``min`` or ``max`` are not passed, any value is accepted in that
+    direction. If ``min_open`` or ``max_open`` are enabled, the
+    corresponding boundary is not included in the range.
+
+    If ``clamp`` is enabled, a value outside the range is clamped to the
+    boundary instead of failing. This is not supported if either
+    boundary is marked ``open``.
+
+    .. versionchanged:: 8.0
+        Added the ``min_open`` and ``max_open`` parameters.
+    """
+
+    name = "float range"
+
+    def __init__(
+        self,
+        min: t.Optional[float] = None,
+        max: t.Optional[float] = None,
+        min_open: bool = False,
+        max_open: bool = False,
+        clamp: bool = False,
+    ) -> None:
+        super().__init__(
+            min=min, max=max, min_open=min_open, max_open=max_open, clamp=clamp
+        )
+
+        if (min_open or max_open) and clamp:
+            raise TypeError("Clamping is not supported for open bounds.")
+
+    def _clamp(self, bound: float, dir: "te.Literal[1, -1]", open: bool) -> float:
+        if not open:
+            return bound
+
+        # Could use Python 3.9's math.nextafter here, but clamping an
+        # open float range doesn't seem to be particularly useful. It's
+        # left up to the user to write a callback to do it if needed.
+        raise RuntimeError("Clamping is not supported for open bounds.")
+
+
+class BoolParamType(ParamType):
+    name = "boolean"
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        if value in {False, True}:
+            return bool(value)
+
+        norm = value.strip().lower()
+
+        if norm in {"1", "true", "t", "yes", "y", "on"}:
+            return True
+
+        if norm in {"0", "false", "f", "no", "n", "off"}:
+            return False
+
+        self.fail(
+            _("{value!r} is not a valid boolean.").format(value=value), param, ctx
+        )
+
+    def __repr__(self) -> str:
+        return "BOOL"
+
+
+class UUIDParameterType(ParamType):
+    name = "uuid"
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        import uuid
+
+        if isinstance(value, uuid.UUID):
+            return value
+
+        value = value.strip()
+
+        try:
+            return uuid.UUID(value)
+        except ValueError:
+            self.fail(
+                _("{value!r} is not a valid UUID.").format(value=value), param, ctx
+            )
+
+    def __repr__(self) -> str:
+        return "UUID"
+
+
+class File(ParamType):
+    """Declares a parameter to be a file for reading or writing.  The file
+    is automatically closed once the context tears down (after the command
+    finished working).
+
+    Files can be opened for reading or writing.  The special value ``-``
+    indicates stdin or stdout depending on the mode.
+
+    By default, the file is opened for reading text data, but it can also be
+    opened in binary mode or for writing.  The encoding parameter can be used
+    to force a specific encoding.
+
+    The `lazy` flag controls if the file should be opened immediately or upon
+    first IO. The default is to be non-lazy for standard input and output
+    streams as well as files opened for reading, `lazy` otherwise. When opening a
+    file lazily for reading, it is still opened temporarily for validation, but
+    will not be held open until first IO. lazy is mainly useful when opening
+    for writing to avoid creating the file until it is needed.
+
+    Starting with Click 2.0, files can also be opened atomically in which
+    case all writes go into a separate file in the same folder and upon
+    completion the file will be moved over to the original location.  This
+    is useful if a file regularly read by other users is modified.
+
+    See :ref:`file-args` for more information.
+    """
+
+    name = "filename"
+    envvar_list_splitter = os.path.pathsep
+
+    def __init__(
+        self,
+        mode: str = "r",
+        encoding: t.Optional[str] = None,
+        errors: t.Optional[str] = "strict",
+        lazy: t.Optional[bool] = None,
+        atomic: bool = False,
+    ) -> None:
+        self.mode = mode
+        self.encoding = encoding
+        self.errors = errors
+        self.lazy = lazy
+        self.atomic = atomic
+
+    def to_info_dict(self) -> t.Dict[str, t.Any]:
+        info_dict = super().to_info_dict()
+        info_dict.update(mode=self.mode, encoding=self.encoding)
+        return info_dict
+
+    def resolve_lazy_flag(self, value: t.Any) -> bool:
+        if self.lazy is not None:
+            return self.lazy
+        if value == "-":
+            return False
+        elif "w" in self.mode:
+            return True
+        return False
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        try:
+            if hasattr(value, "read") or hasattr(value, "write"):
+                return value
+
+            lazy = self.resolve_lazy_flag(value)
+
+            if lazy:
+                f: t.IO = t.cast(
+                    t.IO,
+                    LazyFile(
+                        value, self.mode, self.encoding, self.errors, atomic=self.atomic
+                    ),
+                )
+
+                if ctx is not None:
+                    ctx.call_on_close(f.close_intelligently)  # type: ignore
+
+                return f
+
+            f, should_close = open_stream(
+                value, self.mode, self.encoding, self.errors, atomic=self.atomic
+            )
+
+            # If a context is provided, we automatically close the file
+            # at the end of the context execution (or flush out).  If a
+            # context does not exist, it's the caller's responsibility to
+            # properly close the file.  This for instance happens when the
+            # type is used with prompts.
+            if ctx is not None:
+                if should_close:
+                    ctx.call_on_close(safecall(f.close))
+                else:
+                    ctx.call_on_close(safecall(f.flush))
+
+            return f
+        except OSError as e:  # noqa: B014
+            self.fail(f"'{os.fsdecode(value)}': {e.strerror}", param, ctx)
+
+    def shell_complete(
+        self, ctx: "Context", param: "Parameter", incomplete: str
+    ) -> t.List["CompletionItem"]:
+        """Return a special completion marker that tells the completion
+        system to use the shell to provide file path completions.
+
+        :param ctx: Invocation context for this command.
+        :param param: The parameter that is requesting completion.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        from click.shell_completion import CompletionItem
+
+        return [CompletionItem(incomplete, type="file")]
+
+
+class Path(ParamType):
+    """The ``Path`` type is similar to the :class:`File` type, but
+    returns the filename instead of an open file. Various checks can be
+    enabled to validate the type of file and permissions.
+
+    :param exists: The file or directory needs to exist for the value to
+        be valid. If this is not set to ``True``, and the file does not
+        exist, then all further checks are silently skipped.
+    :param file_okay: Allow a file as a value.
+    :param dir_okay: Allow a directory as a value.
+    :param readable: if true, a readable check is performed.
+    :param writable: if true, a writable check is performed.
+    :param executable: if true, an executable check is performed.
+    :param resolve_path: Make the value absolute and resolve any
+        symlinks. A ``~`` is not expanded, as this is supposed to be
+        done by the shell only.
+    :param allow_dash: Allow a single dash as a value, which indicates
+        a standard stream (but does not open it). Use
+        :func:`~click.open_file` to handle opening this value.
+    :param path_type: Convert the incoming path value to this type. If
+        ``None``, keep Python's default, which is ``str``. Useful to
+        convert to :class:`pathlib.Path`.
+
+    .. versionchanged:: 8.1
+        Added the ``executable`` parameter.
+
+    .. versionchanged:: 8.0
+        Allow passing ``type=pathlib.Path``.
+
+    .. versionchanged:: 6.0
+        Added the ``allow_dash`` parameter.
+    """
+
+    envvar_list_splitter = os.path.pathsep
+
+    def __init__(
+        self,
+        exists: bool = False,
+        file_okay: bool = True,
+        dir_okay: bool = True,
+        writable: bool = False,
+        readable: bool = True,
+        resolve_path: bool = False,
+        allow_dash: bool = False,
+        path_type: t.Optional[t.Type] = None,
+        executable: bool = False,
+    ):
+        self.exists = exists
+        self.file_okay = file_okay
+        self.dir_okay = dir_okay
+        self.readable = readable
+        self.writable = writable
+        self.executable = executable
+        self.resolve_path = resolve_path
+        self.allow_dash = allow_dash
+        self.type = path_type
+
+        if self.file_okay and not self.dir_okay:
+            self.name = _("file")
+        elif self.dir_okay and not self.file_okay:
+            self.name = _("directory")
+        else:
+            self.name = _("path")
+
+    def to_info_dict(self) -> t.Dict[str, t.Any]:
+        info_dict = super().to_info_dict()
+        info_dict.update(
+            exists=self.exists,
+            file_okay=self.file_okay,
+            dir_okay=self.dir_okay,
+            writable=self.writable,
+            readable=self.readable,
+            allow_dash=self.allow_dash,
+        )
+        return info_dict
+
+    def coerce_path_result(self, rv: t.Any) -> t.Any:
+        if self.type is not None and not isinstance(rv, self.type):
+            if self.type is str:
+                rv = os.fsdecode(rv)
+            elif self.type is bytes:
+                rv = os.fsencode(rv)
+            else:
+                rv = self.type(rv)
+
+        return rv
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        rv = value
+
+        is_dash = self.file_okay and self.allow_dash and rv in (b"-", "-")
+
+        if not is_dash:
+            if self.resolve_path:
+                # os.path.realpath doesn't resolve symlinks on Windows
+                # until Python 3.8. Use pathlib for now.
+                import pathlib
+
+                rv = os.fsdecode(pathlib.Path(rv).resolve())
+
+            try:
+                st = os.stat(rv)
+            except OSError:
+                if not self.exists:
+                    return self.coerce_path_result(rv)
+                self.fail(
+                    _("{name} {filename!r} does not exist.").format(
+                        name=self.name.title(), filename=os.fsdecode(value)
+                    ),
+                    param,
+                    ctx,
+                )
+
+            if not self.file_okay and stat.S_ISREG(st.st_mode):
+                self.fail(
+                    _("{name} {filename!r} is a file.").format(
+                        name=self.name.title(), filename=os.fsdecode(value)
+                    ),
+                    param,
+                    ctx,
+                )
+            if not self.dir_okay and stat.S_ISDIR(st.st_mode):
+                self.fail(
+                    _("{name} '{filename}' is a directory.").format(
+                        name=self.name.title(), filename=os.fsdecode(value)
+                    ),
+                    param,
+                    ctx,
+                )
+
+            if self.readable and not os.access(rv, os.R_OK):
+                self.fail(
+                    _("{name} {filename!r} is not readable.").format(
+                        name=self.name.title(), filename=os.fsdecode(value)
+                    ),
+                    param,
+                    ctx,
+                )
+
+            if self.writable and not os.access(rv, os.W_OK):
+                self.fail(
+                    _("{name} {filename!r} is not writable.").format(
+                        name=self.name.title(), filename=os.fsdecode(value)
+                    ),
+                    param,
+                    ctx,
+                )
+
+            if self.executable and not os.access(value, os.X_OK):
+                self.fail(
+                    _("{name} {filename!r} is not executable.").format(
+                        name=self.name.title(), filename=os.fsdecode(value)
+                    ),
+                    param,
+                    ctx,
+                )
+
+        return self.coerce_path_result(rv)
+
+    def shell_complete(
+        self, ctx: "Context", param: "Parameter", incomplete: str
+    ) -> t.List["CompletionItem"]:
+        """Return a special completion marker that tells the completion
+        system to use the shell to provide path completions for only
+        directories or any paths.
+
+        :param ctx: Invocation context for this command.
+        :param param: The parameter that is requesting completion.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        from click.shell_completion import CompletionItem
+
+        type = "dir" if self.dir_okay and not self.file_okay else "file"
+        return [CompletionItem(incomplete, type=type)]
+
+
+class Tuple(CompositeParamType):
+    """The default behavior of Click is to apply a type on a value directly.
+    This works well in most cases, except for when `nargs` is set to a fixed
+    count and different types should be used for different items.  In this
+    case the :class:`Tuple` type can be used.  This type can only be used
+    if `nargs` is set to a fixed number.
+
+    For more information see :ref:`tuple-type`.
+
+    This can be selected by using a Python tuple literal as a type.
+
+    :param types: a list of types that should be used for the tuple items.
+    """
+
+    def __init__(self, types: t.Sequence[t.Union[t.Type, ParamType]]) -> None:
+        self.types = [convert_type(ty) for ty in types]
+
+    def to_info_dict(self) -> t.Dict[str, t.Any]:
+        info_dict = super().to_info_dict()
+        info_dict["types"] = [t.to_info_dict() for t in self.types]
+        return info_dict
+
+    @property
+    def name(self) -> str:  # type: ignore
+        return f"<{' '.join(ty.name for ty in self.types)}>"
+
+    @property
+    def arity(self) -> int:  # type: ignore
+        return len(self.types)
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        len_type = len(self.types)
+        len_value = len(value)
+
+        if len_value != len_type:
+            self.fail(
+                ngettext(
+                    "{len_type} values are required, but {len_value} was given.",
+                    "{len_type} values are required, but {len_value} were given.",
+                    len_value,
+                ).format(len_type=len_type, len_value=len_value),
+                param=param,
+                ctx=ctx,
+            )
+
+        return tuple(ty(x, param, ctx) for ty, x in zip(self.types, value))
+
+
+def convert_type(ty: t.Optional[t.Any], default: t.Optional[t.Any] = None) -> ParamType:
+    """Find the most appropriate :class:`ParamType` for the given Python
+    type. If the type isn't provided, it can be inferred from a default
+    value.
+    """
+    guessed_type = False
+
+    if ty is None and default is not None:
+        if isinstance(default, (tuple, list)):
+            # If the default is empty, ty will remain None and will
+            # return STRING.
+            if default:
+                item = default[0]
+
+                # A tuple of tuples needs to detect the inner types.
+                # Can't call convert recursively because that would
+                # incorrectly unwind the tuple to a single type.
+                if isinstance(item, (tuple, list)):
+                    ty = tuple(map(type, item))
+                else:
+                    ty = type(item)
+        else:
+            ty = type(default)
+
+        guessed_type = True
+
+    if isinstance(ty, tuple):
+        return Tuple(ty)
+
+    if isinstance(ty, ParamType):
+        return ty
+
+    if ty is str or ty is None:
+        return STRING
+
+    if ty is int:
+        return INT
+
+    if ty is float:
+        return FLOAT
+
+    if ty is bool:
+        return BOOL
+
+    if guessed_type:
+        return STRING
+
+    if __debug__:
+        try:
+            if issubclass(ty, ParamType):
+                raise AssertionError(
+                    f"Attempted to use an uninstantiated parameter type ({ty})."
+                )
+        except TypeError:
+            # ty is an instance (correct), so issubclass fails.
+            pass
+
+    return FuncParamType(ty)
+
+
+#: A dummy parameter type that just does nothing.  From a user's
+#: perspective this appears to just be the same as `STRING` but
+#: internally no string conversion takes place if the input was bytes.
+#: This is usually useful when working with file paths as they can
+#: appear in bytes and unicode.
+#:
+#: For path related uses the :class:`Path` type is a better choice but
+#: there are situations where an unprocessed type is useful which is why
+#: it is is provided.
+#:
+#: .. versionadded:: 4.0
+UNPROCESSED = UnprocessedParamType()
+
+#: A unicode string parameter type which is the implicit default.  This
+#: can also be selected by using ``str`` as type.
+STRING = StringParamType()
+
+#: An integer parameter.  This can also be selected by using ``int`` as
+#: type.
+INT = IntParamType()
+
+#: A floating point value parameter.  This can also be selected by using
+#: ``float`` as type.
+FLOAT = FloatParamType()
+
+#: A boolean parameter.  This is the default for boolean flags.  This can
+#: also be selected by using ``bool`` as a type.
+BOOL = BoolParamType()
+
+#: A UUID parameter.
+UUID = UUIDParameterType()
diff --git a/myenv/lib/python3.9/site-packages/click/utils.py b/myenv/lib/python3.9/site-packages/click/utils.py
new file mode 100644
index 0000000..8283788
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/click/utils.py
@@ -0,0 +1,580 @@
+import os
+import re
+import sys
+import typing as t
+from functools import update_wrapper
+from types import ModuleType
+
+from ._compat import _default_text_stderr
+from ._compat import _default_text_stdout
+from ._compat import _find_binary_writer
+from ._compat import auto_wrap_for_ansi
+from ._compat import binary_streams
+from ._compat import get_filesystem_encoding
+from ._compat import open_stream
+from ._compat import should_strip_ansi
+from ._compat import strip_ansi
+from ._compat import text_streams
+from ._compat import WIN
+from .globals import resolve_color_default
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
+
+
+def _posixify(name: str) -> str:
+    return "-".join(name.split()).lower()
+
+
+def safecall(func: F) -> F:
+    """Wraps a function so that it swallows exceptions."""
+
+    def wrapper(*args, **kwargs):  # type: ignore
+        try:
+            return func(*args, **kwargs)
+        except Exception:
+            pass
+
+    return update_wrapper(t.cast(F, wrapper), func)
+
+
+def make_str(value: t.Any) -> str:
+    """Converts a value into a valid string."""
+    if isinstance(value, bytes):
+        try:
+            return value.decode(get_filesystem_encoding())
+        except UnicodeError:
+            return value.decode("utf-8", "replace")
+    return str(value)
+
+
+def make_default_short_help(help: str, max_length: int = 45) -> str:
+    """Returns a condensed version of help string."""
+    # Consider only the first paragraph.
+    paragraph_end = help.find("\n\n")
+
+    if paragraph_end != -1:
+        help = help[:paragraph_end]
+
+    # Collapse newlines, tabs, and spaces.
+    words = help.split()
+
+    if not words:
+        return ""
+
+    # The first paragraph started with a "no rewrap" marker, ignore it.
+    if words[0] == "\b":
+        words = words[1:]
+
+    total_length = 0
+    last_index = len(words) - 1
+
+    for i, word in enumerate(words):
+        total_length += len(word) + (i > 0)
+
+        if total_length > max_length:  # too long, truncate
+            break
+
+        if word[-1] == ".":  # sentence end, truncate without "..."
+            return " ".join(words[: i + 1])
+
+        if total_length == max_length and i != last_index:
+            break  # not at sentence end, truncate with "..."
+    else:
+        return " ".join(words)  # no truncation needed
+
+    # Account for the length of the suffix.
+    total_length += len("...")
+
+    # remove words until the length is short enough
+    while i > 0:
+        total_length -= len(words[i]) + (i > 0)
+
+        if total_length <= max_length:
+            break
+
+        i -= 1
+
+    return " ".join(words[:i]) + "..."
+
+
+class LazyFile:
+    """A lazy file works like a regular file but it does not fully open
+    the file but it does perform some basic checks early to see if the
+    filename parameter does make sense.  This is useful for safely opening
+    files for writing.
+    """
+
+    def __init__(
+        self,
+        filename: str,
+        mode: str = "r",
+        encoding: t.Optional[str] = None,
+        errors: t.Optional[str] = "strict",
+        atomic: bool = False,
+    ):
+        self.name = filename
+        self.mode = mode
+        self.encoding = encoding
+        self.errors = errors
+        self.atomic = atomic
+        self._f: t.Optional[t.IO]
+
+        if filename == "-":
+            self._f, self.should_close = open_stream(filename, mode, encoding, errors)
+        else:
+            if "r" in mode:
+                # Open and close the file in case we're opening it for
+                # reading so that we can catch at least some errors in
+                # some cases early.
+                open(filename, mode).close()
+            self._f = None
+            self.should_close = True
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self.open(), name)
+
+    def __repr__(self) -> str:
+        if self._f is not None:
+            return repr(self._f)
+        return f"<unopened file '{self.name}' {self.mode}>"
+
+    def open(self) -> t.IO:
+        """Opens the file if it's not yet open.  This call might fail with
+        a :exc:`FileError`.  Not handling this error will produce an error
+        that Click shows.
+        """
+        if self._f is not None:
+            return self._f
+        try:
+            rv, self.should_close = open_stream(
+                self.name, self.mode, self.encoding, self.errors, atomic=self.atomic
+            )
+        except OSError as e:  # noqa: E402
+            from .exceptions import FileError
+
+            raise FileError(self.name, hint=e.strerror) from e
+        self._f = rv
+        return rv
+
+    def close(self) -> None:
+        """Closes the underlying file, no matter what."""
+        if self._f is not None:
+            self._f.close()
+
+    def close_intelligently(self) -> None:
+        """This function only closes the file if it was opened by the lazy
+        file wrapper.  For instance this will never close stdin.
+        """
+        if self.should_close:
+            self.close()
+
+    def __enter__(self) -> "LazyFile":
+        return self
+
+    def __exit__(self, exc_type, exc_value, tb):  # type: ignore
+        self.close_intelligently()
+
+    def __iter__(self) -> t.Iterator[t.AnyStr]:
+        self.open()
+        return iter(self._f)  # type: ignore
+
+
+class KeepOpenFile:
+    def __init__(self, file: t.IO) -> None:
+        self._file = file
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._file, name)
+
+    def __enter__(self) -> "KeepOpenFile":
+        return self
+
+    def __exit__(self, exc_type, exc_value, tb):  # type: ignore
+        pass
+
+    def __repr__(self) -> str:
+        return repr(self._file)
+
+    def __iter__(self) -> t.Iterator[t.AnyStr]:
+        return iter(self._file)
+
+
+def echo(
+    message: t.Optional[t.Any] = None,
+    file: t.Optional[t.IO[t.Any]] = None,
+    nl: bool = True,
+    err: bool = False,
+    color: t.Optional[bool] = None,
+) -> None:
+    """Print a message and newline to stdout or a file. This should be
+    used instead of :func:`print` because it provides better support
+    for different data, files, and environments.
+
+    Compared to :func:`print`, this does the following:
+
+    -   Ensures that the output encoding is not misconfigured on Linux.
+    -   Supports Unicode in the Windows console.
+    -   Supports writing to binary outputs, and supports writing bytes
+        to text outputs.
+    -   Supports colors and styles on Windows.
+    -   Removes ANSI color and style codes if the output does not look
+        like an interactive terminal.
+    -   Always flushes the output.
+
+    :param message: The string or bytes to output. Other objects are
+        converted to strings.
+    :param file: The file to write to. Defaults to ``stdout``.
+    :param err: Write to ``stderr`` instead of ``stdout``.
+    :param nl: Print a newline after the message. Enabled by default.
+    :param color: Force showing or hiding colors and other styles. By
+        default Click will remove color if the output does not look like
+        an interactive terminal.
+
+    .. versionchanged:: 6.0
+        Support Unicode output on the Windows console. Click does not
+        modify ``sys.stdout``, so ``sys.stdout.write()`` and ``print()``
+        will still not support Unicode.
+
+    .. versionchanged:: 4.0
+        Added the ``color`` parameter.
+
+    .. versionadded:: 3.0
+        Added the ``err`` parameter.
+
+    .. versionchanged:: 2.0
+        Support colors on Windows if colorama is installed.
+    """
+    if file is None:
+        if err:
+            file = _default_text_stderr()
+        else:
+            file = _default_text_stdout()
+
+    # Convert non bytes/text into the native string type.
+    if message is not None and not isinstance(message, (str, bytes, bytearray)):
+        out: t.Optional[t.Union[str, bytes]] = str(message)
+    else:
+        out = message
+
+    if nl:
+        out = out or ""
+        if isinstance(out, str):
+            out += "\n"
+        else:
+            out += b"\n"
+
+    if not out:
+        file.flush()
+        return
+
+    # If there is a message and the value looks like bytes, we manually
+    # need to find the binary stream and write the message in there.
+    # This is done separately so that most stream types will work as you
+    # would expect. Eg: you can write to StringIO for other cases.
+    if isinstance(out, (bytes, bytearray)):
+        binary_file = _find_binary_writer(file)
+
+        if binary_file is not None:
+            file.flush()
+            binary_file.write(out)
+            binary_file.flush()
+            return
+
+    # ANSI style code support. For no message or bytes, nothing happens.
+    # When outputting to a file instead of a terminal, strip codes.
+    else:
+        color = resolve_color_default(color)
+
+        if should_strip_ansi(file, color):
+            out = strip_ansi(out)
+        elif WIN:
+            if auto_wrap_for_ansi is not None:
+                file = auto_wrap_for_ansi(file)  # type: ignore
+            elif not color:
+                out = strip_ansi(out)
+
+    file.write(out)  # type: ignore
+    file.flush()
+
+
+def get_binary_stream(name: "te.Literal['stdin', 'stdout', 'stderr']") -> t.BinaryIO:
+    """Returns a system stream for byte processing.
+
+    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
+                 ``'stdout'`` and ``'stderr'``
+    """
+    opener = binary_streams.get(name)
+    if opener is None:
+        raise TypeError(f"Unknown standard stream '{name}'")
+    return opener()
+
+
+def get_text_stream(
+    name: "te.Literal['stdin', 'stdout', 'stderr']",
+    encoding: t.Optional[str] = None,
+    errors: t.Optional[str] = "strict",
+) -> t.TextIO:
+    """Returns a system stream for text processing.  This usually returns
+    a wrapped stream around a binary stream returned from
+    :func:`get_binary_stream` but it also can take shortcuts for already
+    correctly configured streams.
+
+    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
+                 ``'stdout'`` and ``'stderr'``
+    :param encoding: overrides the detected default encoding.
+    :param errors: overrides the default error mode.
+    """
+    opener = text_streams.get(name)
+    if opener is None:
+        raise TypeError(f"Unknown standard stream '{name}'")
+    return opener(encoding, errors)
+
+
+def open_file(
+    filename: str,
+    mode: str = "r",
+    encoding: t.Optional[str] = None,
+    errors: t.Optional[str] = "strict",
+    lazy: bool = False,
+    atomic: bool = False,
+) -> t.IO:
+    """Open a file, with extra behavior to handle ``'-'`` to indicate
+    a standard stream, lazy open on write, and atomic write. Similar to
+    the behavior of the :class:`~click.File` param type.
+
+    If ``'-'`` is given to open ``stdout`` or ``stdin``, the stream is
+    wrapped so that using it in a context manager will not close it.
+    This makes it possible to use the function without accidentally
+    closing a standard stream:
+
+    .. code-block:: python
+
+        with open_file(filename) as f:
+            ...
+
+    :param filename: The name of the file to open, or ``'-'`` for
+        ``stdin``/``stdout``.
+    :param mode: The mode in which to open the file.
+    :param encoding: The encoding to decode or encode a file opened in
+        text mode.
+    :param errors: The error handling mode.
+    :param lazy: Wait to open the file until it is accessed. For read
+        mode, the file is temporarily opened to raise access errors
+        early, then closed until it is read again.
+    :param atomic: Write to a temporary file and replace the given file
+        on close.
+
+    .. versionadded:: 3.0
+    """
+    if lazy:
+        return t.cast(t.IO, LazyFile(filename, mode, encoding, errors, atomic=atomic))
+
+    f, should_close = open_stream(filename, mode, encoding, errors, atomic=atomic)
+
+    if not should_close:
+        f = t.cast(t.IO, KeepOpenFile(f))
+
+    return f
+
+
+def format_filename(
+    filename: t.Union[str, bytes, os.PathLike], shorten: bool = False
+) -> str:
+    """Formats a filename for user display.  The main purpose of this
+    function is to ensure that the filename can be displayed at all.  This
+    will decode the filename to unicode if necessary in a way that it will
+    not fail.  Optionally, it can shorten the filename to not include the
+    full path to the filename.
+
+    :param filename: formats a filename for UI display.  This will also convert
+                     the filename into unicode without failing.
+    :param shorten: this optionally shortens the filename to strip of the
+                    path that leads up to it.
+    """
+    if shorten:
+        filename = os.path.basename(filename)
+
+    return os.fsdecode(filename)
+
+
+def get_app_dir(app_name: str, roaming: bool = True, force_posix: bool = False) -> str:
+    r"""Returns the config folder for the application.  The default behavior
+    is to return whatever is most appropriate for the operating system.
+
+    To give you an idea, for an app called ``"Foo Bar"``, something like
+    the following folders could be returned:
+
+    Mac OS X:
+      ``~/Library/Application Support/Foo Bar``
+    Mac OS X (POSIX):
+      ``~/.foo-bar``
+    Unix:
+      ``~/.config/foo-bar``
+    Unix (POSIX):
+      ``~/.foo-bar``
+    Windows (roaming):
+      ``C:\Users\<user>\AppData\Roaming\Foo Bar``
+    Windows (not roaming):
+      ``C:\Users\<user>\AppData\Local\Foo Bar``
+
+    .. versionadded:: 2.0
+
+    :param app_name: the application name.  This should be properly capitalized
+                     and can contain whitespace.
+    :param roaming: controls if the folder should be roaming or not on Windows.
+                    Has no affect otherwise.
+    :param force_posix: if this is set to `True` then on any POSIX system the
+                        folder will be stored in the home folder with a leading
+                        dot instead of the XDG config home or darwin's
+                        application support folder.
+    """
+    if WIN:
+        key = "APPDATA" if roaming else "LOCALAPPDATA"
+        folder = os.environ.get(key)
+        if folder is None:
+            folder = os.path.expanduser("~")
+        return os.path.join(folder, app_name)
+    if force_posix:
+        return os.path.join(os.path.expanduser(f"~/.{_posixify(app_name)}"))
+    if sys.platform == "darwin":
+        return os.path.join(
+            os.path.expanduser("~/Library/Application Support"), app_name
+        )
+    return os.path.join(
+        os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")),
+        _posixify(app_name),
+    )
+
+
+class PacifyFlushWrapper:
+    """This wrapper is used to catch and suppress BrokenPipeErrors resulting
+    from ``.flush()`` being called on broken pipe during the shutdown/final-GC
+    of the Python interpreter. Notably ``.flush()`` is always called on
+    ``sys.stdout`` and ``sys.stderr``. So as to have minimal impact on any
+    other cleanup code, and the case where the underlying file is not a broken
+    pipe, all calls and attributes are proxied.
+    """
+
+    def __init__(self, wrapped: t.IO) -> None:
+        self.wrapped = wrapped
+
+    def flush(self) -> None:
+        try:
+            self.wrapped.flush()
+        except OSError as e:
+            import errno
+
+            if e.errno != errno.EPIPE:
+                raise
+
+    def __getattr__(self, attr: str) -> t.Any:
+        return getattr(self.wrapped, attr)
+
+
+def _detect_program_name(
+    path: t.Optional[str] = None, _main: t.Optional[ModuleType] = None
+) -> str:
+    """Determine the command used to run the program, for use in help
+    text. If a file or entry point was executed, the file name is
+    returned. If ``python -m`` was used to execute a module or package,
+    ``python -m name`` is returned.
+
+    This doesn't try to be too precise, the goal is to give a concise
+    name for help text. Files are only shown as their name without the
+    path. ``python`` is only shown for modules, and the full path to
+    ``sys.executable`` is not shown.
+
+    :param path: The Python file being executed. Python puts this in
+        ``sys.argv[0]``, which is used by default.
+    :param _main: The ``__main__`` module. This should only be passed
+        during internal testing.
+
+    .. versionadded:: 8.0
+        Based on command args detection in the Werkzeug reloader.
+
+    :meta private:
+    """
+    if _main is None:
+        _main = sys.modules["__main__"]
+
+    if not path:
+        path = sys.argv[0]
+
+    # The value of __package__ indicates how Python was called. It may
+    # not exist if a setuptools script is installed as an egg. It may be
+    # set incorrectly for entry points created with pip on Windows.
+    if getattr(_main, "__package__", None) is None or (
+        os.name == "nt"
+        and _main.__package__ == ""
+        and not os.path.exists(path)
+        and os.path.exists(f"{path}.exe")
+    ):
+        # Executed a file, like "python app.py".
+        return os.path.basename(path)
+
+    # Executed a module, like "python -m example".
+    # Rewritten by Python from "-m script" to "/path/to/script.py".
+    # Need to look at main module to determine how it was executed.
+    py_module = t.cast(str, _main.__package__)
+    name = os.path.splitext(os.path.basename(path))[0]
+
+    # A submodule like "example.cli".
+    if name != "__main__":
+        py_module = f"{py_module}.{name}"
+
+    return f"python -m {py_module.lstrip('.')}"
+
+
+def _expand_args(
+    args: t.Iterable[str],
+    *,
+    user: bool = True,
+    env: bool = True,
+    glob_recursive: bool = True,
+) -> t.List[str]:
+    """Simulate Unix shell expansion with Python functions.
+
+    See :func:`glob.glob`, :func:`os.path.expanduser`, and
+    :func:`os.path.expandvars`.
+
+    This is intended for use on Windows, where the shell does not do any
+    expansion. It may not exactly match what a Unix shell would do.
+
+    :param args: List of command line arguments to expand.
+    :param user: Expand user home directory.
+    :param env: Expand environment variables.
+    :param glob_recursive: ``**`` matches directories recursively.
+
+    .. versionchanged:: 8.1
+        Invalid glob patterns are treated as empty expansions rather
+        than raising an error.
+
+    .. versionadded:: 8.0
+
+    :meta private:
+    """
+    from glob import glob
+
+    out = []
+
+    for arg in args:
+        if user:
+            arg = os.path.expanduser(arg)
+
+        if env:
+            arg = os.path.expandvars(arg)
+
+        try:
+            matches = glob(arg, recursive=glob_recursive)
+        except re.error:
+            matches = []
+
+        if not matches:
+            out.append(arg)
+        else:
+            out.extend(matches)
+
+    return out
diff --git a/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/LICENSE.txt b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/LICENSE.txt
new file mode 100644
index 0000000..3105888
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/LICENSE.txt
@@ -0,0 +1,27 @@
+Copyright (c) 2010 Jonathan Hartley
+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 holders, nor those of its contributors
+  may be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/METADATA b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/METADATA
new file mode 100644
index 0000000..cd93935
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/METADATA
@@ -0,0 +1,411 @@
+Metadata-Version: 2.1
+Name: colorama
+Version: 0.4.5
+Summary: Cross-platform colored terminal text.
+Home-page: https://github.com/tartley/colorama
+Author: Jonathan Hartley
+Author-email: tartley@tartley.com
+Maintainer: Arnon Yaari
+License: BSD
+Keywords: color colour terminal text ansi windows crossplatform xplatform
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Terminals
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
+License-File: LICENSE.txt
+
+.. image:: https://img.shields.io/pypi/v/colorama.svg
+    :target: https://pypi.org/project/colorama/
+    :alt: Latest Version
+
+.. image:: https://img.shields.io/pypi/pyversions/colorama.svg
+    :target: https://pypi.org/project/colorama/
+    :alt: Supported Python versions
+
+.. image:: https://github.com/tartley/colorama/actions/workflows/test.yml/badge.svg
+    :target: https://github.com/tartley/colorama/actions/workflows/test.yml
+    :alt: Build Status
+
+Colorama
+========
+
+Makes ANSI escape character sequences (for producing colored terminal text and
+cursor positioning) work under MS Windows.
+
+.. |donate| image:: https://www.paypalobjects.com/en_US/i/btn/btn_donate_SM.gif
+  :target: https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=2MZ9D2GMLYCUJ&item_name=Colorama&currency_code=USD
+  :alt: Donate with Paypal
+
+`PyPI for releases <https://pypi.org/project/colorama/>`_ |
+`Github for source <https://github.com/tartley/colorama>`_ |
+`Colorama for enterprise on Tidelift <https://github.com/tartley/colorama/blob/master/ENTERPRISE.md>`_
+
+If you find Colorama useful, please |donate| to the authors. Thank you!
+
+
+Installation
+------------
+
+Tested on CPython 2.7, 3.5, 3.6, 3.7, 3.8, 3.9 and 3.10 and Pypy 2.7 and 3.6.
+
+No requirements other than the standard library.
+
+.. code-block:: bash
+
+    pip install colorama
+    # or
+    conda install -c anaconda colorama
+
+
+Description
+-----------
+
+ANSI escape character sequences have long been used to produce colored terminal
+text and cursor positioning on Unix and Macs. Colorama makes this work on
+Windows, too, by wrapping ``stdout``, stripping ANSI sequences it finds (which
+would appear as gobbledygook in the output), and converting them into the
+appropriate win32 calls to modify the state of the terminal. On other platforms,
+Colorama does nothing.
+
+This has the upshot of providing a simple cross-platform API for printing
+colored terminal text from Python, and has the happy side-effect that existing
+applications or libraries which use ANSI sequences to produce colored output on
+Linux or Macs can now also work on Windows, simply by calling
+``colorama.init()``.
+
+An alternative approach is to install ``ansi.sys`` on Windows machines, which
+provides the same behaviour for all applications running in terminals. Colorama
+is intended for situations where that isn't easy (e.g., maybe your app doesn't
+have an installer.)
+
+Demo scripts in the source code repository print some colored text using
+ANSI sequences. Compare their output under Gnome-terminal's built in ANSI
+handling, versus on Windows Command-Prompt using Colorama:
+
+.. image:: https://github.com/tartley/colorama/raw/master/screenshots/ubuntu-demo.png
+    :width: 661
+    :height: 357
+    :alt: ANSI sequences on Ubuntu under gnome-terminal.
+
+.. image:: https://github.com/tartley/colorama/raw/master/screenshots/windows-demo.png
+    :width: 668
+    :height: 325
+    :alt: Same ANSI sequences on Windows, using Colorama.
+
+These screenshots show that, on Windows, Colorama does not support ANSI 'dim
+text'; it looks the same as 'normal text'.
+
+Usage
+-----
+
+Initialisation
+..............
+
+Applications should initialise Colorama using:
+
+.. code-block:: python
+
+    from colorama import init
+    init()
+
+On Windows, calling ``init()`` will filter ANSI escape sequences out of any
+text sent to ``stdout`` or ``stderr``, and replace them with equivalent Win32
+calls.
+
+On other platforms, calling ``init()`` has no effect (unless you request other
+optional functionality, see "Init Keyword Args" below; or if output
+is redirected). By design, this permits applications to call ``init()``
+unconditionally on all platforms, after which ANSI output should just work.
+
+On all platforms, if output is redirected, ANSI escape sequences are completely
+stripped out.
+
+To stop using Colorama before your program exits, simply call ``deinit()``.
+This will restore ``stdout`` and ``stderr`` to their original values, so that
+Colorama is disabled. To resume using Colorama again, call ``reinit()``; it is
+cheaper than calling ``init()`` again (but does the same thing).
+
+
+Colored Output
+..............
+
+Cross-platform printing of colored text can then be done using Colorama's
+constant shorthand for ANSI escape sequences. These are deliberately
+rudimentary, see below.
+
+.. code-block:: python
+
+    from colorama import Fore, Back, Style
+    print(Fore.RED + 'some red text')
+    print(Back.GREEN + 'and with a green background')
+    print(Style.DIM + 'and in dim text')
+    print(Style.RESET_ALL)
+    print('back to normal now')
+
+...or simply by manually printing ANSI sequences from your own code:
+
+.. code-block:: python
+
+    print('\033[31m' + 'some red text')
+    print('\033[39m') # and reset to default color
+
+...or, Colorama can be used in conjunction with existing ANSI libraries
+such as the venerable `Termcolor <https://pypi.org/project/termcolor/>`_
+the fabulous `Blessings <https://pypi.org/project/blessings/>`_,
+or the incredible `_Rich <https://pypi.org/project/rich/>`_.
+
+If you wish Colorama's Fore, Back and Style constants were more capable,
+then consider using one of the above highly capable libraries to generate
+colors, etc, and use Colorama just for its primary purpose: to convert
+those ANSI sequences to also work on Windows:
+
+.. code-block:: python
+
+    from colorama import init
+    from termcolor import colored
+
+    # use Colorama to make Termcolor work on Windows too
+    init()
+
+    # then use Termcolor for all colored text output
+    print(colored('Hello, World!', 'green', 'on_red'))
+
+Available formatting constants are::
+
+    Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
+    Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
+    Style: DIM, NORMAL, BRIGHT, RESET_ALL
+
+``Style.RESET_ALL`` resets foreground, background, and brightness. Colorama will
+perform this reset automatically on program exit.
+
+These are fairly well supported, but not part of the standard::
+
+    Fore: LIGHTBLACK_EX, LIGHTRED_EX, LIGHTGREEN_EX, LIGHTYELLOW_EX, LIGHTBLUE_EX, LIGHTMAGENTA_EX, LIGHTCYAN_EX, LIGHTWHITE_EX
+    Back: LIGHTBLACK_EX, LIGHTRED_EX, LIGHTGREEN_EX, LIGHTYELLOW_EX, LIGHTBLUE_EX, LIGHTMAGENTA_EX, LIGHTCYAN_EX, LIGHTWHITE_EX
+
+
+Cursor Positioning
+..................
+
+ANSI codes to reposition the cursor are supported. See ``demos/demo06.py`` for
+an example of how to generate them.
+
+
+Init Keyword Args
+.................
+
+``init()`` accepts some ``**kwargs`` to override default behaviour.
+
+init(autoreset=False):
+    If you find yourself repeatedly sending reset sequences to turn off color
+    changes at the end of every print, then ``init(autoreset=True)`` will
+    automate that:
+
+    .. code-block:: python
+
+        from colorama import init
+        init(autoreset=True)
+        print(Fore.RED + 'some red text')
+        print('automatically back to default color again')
+
+init(strip=None):
+    Pass ``True`` or ``False`` to override whether ANSI codes should be
+    stripped from the output. The default behaviour is to strip if on Windows
+    or if output is redirected (not a tty).
+
+init(convert=None):
+    Pass ``True`` or ``False`` to override whether to convert ANSI codes in the
+    output into win32 calls. The default behaviour is to convert if on Windows
+    and output is to a tty (terminal).
+
+init(wrap=True):
+    On Windows, Colorama works by replacing ``sys.stdout`` and ``sys.stderr``
+    with proxy objects, which override the ``.write()`` method to do their work.
+    If this wrapping causes you problems, then this can be disabled by passing
+    ``init(wrap=False)``. The default behaviour is to wrap if ``autoreset`` or
+    ``strip`` or ``convert`` are True.
+
+    When wrapping is disabled, colored printing on non-Windows platforms will
+    continue to work as normal. To do cross-platform colored output, you can
+    use Colorama's ``AnsiToWin32`` proxy directly:
+
+    .. code-block:: python
+
+        import sys
+        from colorama import init, AnsiToWin32
+        init(wrap=False)
+        stream = AnsiToWin32(sys.stderr).stream
+
+        # Python 2
+        print >>stream, Fore.BLUE + 'blue text on stderr'
+
+        # Python 3
+        print(Fore.BLUE + 'blue text on stderr', file=stream)
+
+
+Recognised ANSI Sequences
+.........................
+
+ANSI sequences generally take the form::
+
+    ESC [ <param> ; <param> ... <command>
+
+Where ``<param>`` is an integer, and ``<command>`` is a single letter. Zero or
+more params are passed to a ``<command>``. If no params are passed, it is
+generally synonymous with passing a single zero. No spaces exist in the
+sequence; they have been inserted here simply to read more easily.
+
+The only ANSI sequences that Colorama converts into win32 calls are::
+
+    ESC [ 0 m       # reset all (colors and brightness)
+    ESC [ 1 m       # bright
+    ESC [ 2 m       # dim (looks same as normal brightness)
+    ESC [ 22 m      # normal brightness
+
+    # FOREGROUND:
+    ESC [ 30 m      # black
+    ESC [ 31 m      # red
+    ESC [ 32 m      # green
+    ESC [ 33 m      # yellow
+    ESC [ 34 m      # blue
+    ESC [ 35 m      # magenta
+    ESC [ 36 m      # cyan
+    ESC [ 37 m      # white
+    ESC [ 39 m      # reset
+
+    # BACKGROUND
+    ESC [ 40 m      # black
+    ESC [ 41 m      # red
+    ESC [ 42 m      # green
+    ESC [ 43 m      # yellow
+    ESC [ 44 m      # blue
+    ESC [ 45 m      # magenta
+    ESC [ 46 m      # cyan
+    ESC [ 47 m      # white
+    ESC [ 49 m      # reset
+
+    # cursor positioning
+    ESC [ y;x H     # position cursor at x across, y down
+    ESC [ y;x f     # position cursor at x across, y down
+    ESC [ n A       # move cursor n lines up
+    ESC [ n B       # move cursor n lines down
+    ESC [ n C       # move cursor n characters forward
+    ESC [ n D       # move cursor n characters backward
+
+    # clear the screen
+    ESC [ mode J    # clear the screen
+
+    # clear the line
+    ESC [ mode K    # clear the line
+
+Multiple numeric params to the ``'m'`` command can be combined into a single
+sequence::
+
+    ESC [ 36 ; 45 ; 1 m     # bright cyan text on magenta background
+
+All other ANSI sequences of the form ``ESC [ <param> ; <param> ... <command>``
+are silently stripped from the output on Windows.
+
+Any other form of ANSI sequence, such as single-character codes or alternative
+initial characters, are not recognised or stripped. It would be cool to add
+them though. Let me know if it would be useful for you, via the Issues on
+GitHub.
+
+
+Status & Known Problems
+-----------------------
+
+I've personally only tested it on Windows XP (CMD, Console2), Ubuntu
+(gnome-terminal, xterm), and OS X.
+
+Some presumably valid ANSI sequences aren't recognised (see details below),
+but to my knowledge nobody has yet complained about this. Puzzling.
+
+See outstanding issues and wish-list:
+https://github.com/tartley/colorama/issues
+
+If anything doesn't work for you, or doesn't do what you expected or hoped for,
+I'd love to hear about it on that issues list, would be delighted by patches,
+and would be happy to grant commit access to anyone who submits a working patch
+or two.
+
+If you're hacking on the code, see `README-hacking.md`_.
+
+.. _README-hacking.md: README-hacking.md
+
+
+License
+-------
+
+Copyright Jonathan Hartley & Arnon Yaari, 2013-2020. BSD 3-Clause license; see
+LICENSE file.
+
+
+Professional support
+--------------------
+
+.. |tideliftlogo| image:: https://cdn2.hubspot.net/hubfs/4008838/website/logos/logos_for_download/Tidelift_primary-shorthand-logo.png
+   :alt: Tidelift
+   :target: https://tidelift.com/subscription/pkg/pypi-colorama?utm_source=pypi-colorama&utm_medium=referral&utm_campaign=readme
+
+.. list-table::
+   :widths: 10 100
+
+   * - |tideliftlogo|
+     - Professional support for colorama is available as part of the
+       `Tidelift Subscription`_.
+       Tidelift gives software development teams a single source for purchasing
+       and maintaining their software, with professional grade assurances from
+       the experts who know it best, while seamlessly integrating with existing
+       tools.
+
+.. _Tidelift Subscription: https://tidelift.com/subscription/pkg/pypi-colorama?utm_source=pypi-colorama&utm_medium=referral&utm_campaign=readme
+
+
+Thanks
+------
+
+* Marc Schlaich (schlamar) for a ``setup.py`` fix for Python2.5.
+* Marc Abramowitz, reported & fixed a crash on exit with closed ``stdout``,
+  providing a solution to issue #7's setuptools/distutils debate,
+  and other fixes.
+* User 'eryksun', for guidance on correctly instantiating ``ctypes.windll``.
+* Matthew McCormick for politely pointing out a longstanding crash on non-Win.
+* Ben Hoyt, for a magnificent fix under 64-bit Windows.
+* Jesse at Empty Square for submitting a fix for examples in the README.
+* User 'jamessp', an observant documentation fix for cursor positioning.
+* User 'vaal1239', Dave Mckee & Lackner Kristof for a tiny but much-needed Win7
+  fix.
+* Julien Stuyck, for wisely suggesting Python3 compatible updates to README.
+* Daniel Griffith for multiple fabulous patches.
+* Oscar Lesta for a valuable fix to stop ANSI chars being sent to non-tty
+  output.
+* Roger Binns, for many suggestions, valuable feedback, & bug reports.
+* Tim Golden for thought and much appreciated feedback on the initial idea.
+* User 'Zearin' for updates to the README file.
+* John Szakmeister for adding support for light colors
+* Charles Merriam for adding documentation to demos
+* Jurko for a fix on 64-bit Windows CPython2.5 w/o ctypes
+* Florian Bruhin for a fix when stdout or stderr are None
+* Thomas Weininger for fixing ValueError on Windows
+* Remi Rampin for better Github integration and fixes to the README file
+* Simeon Visser for closing a file handle using 'with' and updating classifiers
+  to include Python 3.3 and 3.4
+* Andy Neff for fixing RESET of LIGHT_EX colors.
+* Jonathan Hartley for the initial idea and implementation.
diff --git a/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/RECORD b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/RECORD
new file mode 100644
index 0000000..02a3c5e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/RECORD
@@ -0,0 +1,12 @@
+colorama/__init__.py,sha256=ihDoWQOkapwF7sqQ99AoDoEF3vGYm40OtmgW211cLZw,239
+colorama/ansi.py,sha256=Top4EeEuaQdBWdteKMEcGOTeKeF19Q-Wo_6_Cj5kOzQ,2522
+colorama/ansitowin32.py,sha256=gGrO7MVtwc-j1Sq3jKfZpERT1JWmYSOsTVDiTnFbZU4,10830
+colorama/initialise.py,sha256=PprovDNxMTrvoNHFcL2NZjpH2XzDc8BLxLxiErfUl4k,1915
+colorama/win32.py,sha256=bJ8Il9jwaBN5BJ8bmN6FoYZ1QYuMKv2j8fGrXh7TJjw,5404
+colorama/winterm.py,sha256=2y_2b7Zsv34feAsP67mLOVc-Bgq51mdYGo571VprlrM,6438
+colorama-0.4.5.dist-info/LICENSE.txt,sha256=ysNcAmhuXQSlpxQL-zs25zrtSWZW6JEQLkKIhteTAxg,1491
+colorama-0.4.5.dist-info/METADATA,sha256=Kb6MoYzWBmkPhFCf0SW7a-5Eeyssj-szefJmxokQFSU,15128
+colorama-0.4.5.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
+colorama-0.4.5.dist-info/top_level.txt,sha256=_Kx6-Cni2BT1PEATPhrSRxo0d7kSgfBbHf5o7IF1ABw,9
+colorama-0.4.5.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+colorama-0.4.5.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/WHEEL
new file mode 100644
index 0000000..0b18a28
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/top_level.txt
new file mode 100644
index 0000000..3fcfb51
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama-0.4.5.dist-info/top_level.txt
@@ -0,0 +1 @@
+colorama
diff --git a/myenv/lib/python3.9/site-packages/colorama/__init__.py b/myenv/lib/python3.9/site-packages/colorama/__init__.py
new file mode 100644
index 0000000..9138a8c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama/__init__.py
@@ -0,0 +1,6 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+from .initialise import init, deinit, reinit, colorama_text
+from .ansi import Fore, Back, Style, Cursor
+from .ansitowin32 import AnsiToWin32
+
+__version__ = '0.4.5'
diff --git a/myenv/lib/python3.9/site-packages/colorama/ansi.py b/myenv/lib/python3.9/site-packages/colorama/ansi.py
new file mode 100644
index 0000000..11ec695
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama/ansi.py
@@ -0,0 +1,102 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+'''
+This module generates ANSI character codes to printing colors to terminals.
+See: http://en.wikipedia.org/wiki/ANSI_escape_code
+'''
+
+CSI = '\033['
+OSC = '\033]'
+BEL = '\a'
+
+
+def code_to_chars(code):
+    return CSI + str(code) + 'm'
+
+def set_title(title):
+    return OSC + '2;' + title + BEL
+
+def clear_screen(mode=2):
+    return CSI + str(mode) + 'J'
+
+def clear_line(mode=2):
+    return CSI + str(mode) + 'K'
+
+
+class AnsiCodes(object):
+    def __init__(self):
+        # the subclasses declare class attributes which are numbers.
+        # Upon instantiation we define instance attributes, which are the same
+        # as the class attributes but wrapped with the ANSI escape sequence
+        for name in dir(self):
+            if not name.startswith('_'):
+                value = getattr(self, name)
+                setattr(self, name, code_to_chars(value))
+
+
+class AnsiCursor(object):
+    def UP(self, n=1):
+        return CSI + str(n) + 'A'
+    def DOWN(self, n=1):
+        return CSI + str(n) + 'B'
+    def FORWARD(self, n=1):
+        return CSI + str(n) + 'C'
+    def BACK(self, n=1):
+        return CSI + str(n) + 'D'
+    def POS(self, x=1, y=1):
+        return CSI + str(y) + ';' + str(x) + 'H'
+
+
+class AnsiFore(AnsiCodes):
+    BLACK           = 30
+    RED             = 31
+    GREEN           = 32
+    YELLOW          = 33
+    BLUE            = 34
+    MAGENTA         = 35
+    CYAN            = 36
+    WHITE           = 37
+    RESET           = 39
+
+    # These are fairly well supported, but not part of the standard.
+    LIGHTBLACK_EX   = 90
+    LIGHTRED_EX     = 91
+    LIGHTGREEN_EX   = 92
+    LIGHTYELLOW_EX  = 93
+    LIGHTBLUE_EX    = 94
+    LIGHTMAGENTA_EX = 95
+    LIGHTCYAN_EX    = 96
+    LIGHTWHITE_EX   = 97
+
+
+class AnsiBack(AnsiCodes):
+    BLACK           = 40
+    RED             = 41
+    GREEN           = 42
+    YELLOW          = 43
+    BLUE            = 44
+    MAGENTA         = 45
+    CYAN            = 46
+    WHITE           = 47
+    RESET           = 49
+
+    # These are fairly well supported, but not part of the standard.
+    LIGHTBLACK_EX   = 100
+    LIGHTRED_EX     = 101
+    LIGHTGREEN_EX   = 102
+    LIGHTYELLOW_EX  = 103
+    LIGHTBLUE_EX    = 104
+    LIGHTMAGENTA_EX = 105
+    LIGHTCYAN_EX    = 106
+    LIGHTWHITE_EX   = 107
+
+
+class AnsiStyle(AnsiCodes):
+    BRIGHT    = 1
+    DIM       = 2
+    NORMAL    = 22
+    RESET_ALL = 0
+
+Fore   = AnsiFore()
+Back   = AnsiBack()
+Style  = AnsiStyle()
+Cursor = AnsiCursor()
diff --git a/myenv/lib/python3.9/site-packages/colorama/ansitowin32.py b/myenv/lib/python3.9/site-packages/colorama/ansitowin32.py
new file mode 100644
index 0000000..3db248b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama/ansitowin32.py
@@ -0,0 +1,266 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import re
+import sys
+import os
+
+from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style, BEL
+from .winterm import WinTerm, WinColor, WinStyle
+from .win32 import windll, winapi_test
+
+
+winterm = None
+if windll is not None:
+    winterm = WinTerm()
+
+
+class StreamWrapper(object):
+    '''
+    Wraps a stream (such as stdout), acting as a transparent proxy for all
+    attribute access apart from method 'write()', which is delegated to our
+    Converter instance.
+    '''
+    def __init__(self, wrapped, converter):
+        # double-underscore everything to prevent clashes with names of
+        # attributes on the wrapped stream object.
+        self.__wrapped = wrapped
+        self.__convertor = converter
+
+    def __getattr__(self, name):
+        return getattr(self.__wrapped, name)
+
+    def __enter__(self, *args, **kwargs):
+        # special method lookup bypasses __getattr__/__getattribute__, see
+        # https://stackoverflow.com/questions/12632894/why-doesnt-getattr-work-with-exit
+        # thus, contextlib magic methods are not proxied via __getattr__
+        return self.__wrapped.__enter__(*args, **kwargs)
+
+    def __exit__(self, *args, **kwargs):
+        return self.__wrapped.__exit__(*args, **kwargs)
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+
+    def __getstate__(self):
+        return self.__dict__
+
+    def write(self, text):
+        self.__convertor.write(text)
+
+    def isatty(self):
+        stream = self.__wrapped
+        if 'PYCHARM_HOSTED' in os.environ:
+            if stream is not None and (stream is sys.__stdout__ or stream is sys.__stderr__):
+                return True
+        try:
+            stream_isatty = stream.isatty
+        except AttributeError:
+            return False
+        else:
+            return stream_isatty()
+
+    @property
+    def closed(self):
+        stream = self.__wrapped
+        try:
+            return stream.closed
+        # AttributeError in the case that the stream doesn't support being closed
+        # ValueError for the case that the stream has already been detached when atexit runs
+        except (AttributeError, ValueError):
+            return True
+
+
+class AnsiToWin32(object):
+    '''
+    Implements a 'write()' method which, on Windows, will strip ANSI character
+    sequences from the text, and if outputting to a tty, will convert them into
+    win32 function calls.
+    '''
+    ANSI_CSI_RE = re.compile('\001?\033\\[((?:\\d|;)*)([a-zA-Z])\002?')   # Control Sequence Introducer
+    ANSI_OSC_RE = re.compile('\001?\033\\]([^\a]*)(\a)\002?')             # Operating System Command
+
+    def __init__(self, wrapped, convert=None, strip=None, autoreset=False):
+        # The wrapped stream (normally sys.stdout or sys.stderr)
+        self.wrapped = wrapped
+
+        # should we reset colors to defaults after every .write()
+        self.autoreset = autoreset
+
+        # create the proxy wrapping our output stream
+        self.stream = StreamWrapper(wrapped, self)
+
+        on_windows = os.name == 'nt'
+        # We test if the WinAPI works, because even if we are on Windows
+        # we may be using a terminal that doesn't support the WinAPI
+        # (e.g. Cygwin Terminal). In this case it's up to the terminal
+        # to support the ANSI codes.
+        conversion_supported = on_windows and winapi_test()
+
+        # should we strip ANSI sequences from our output?
+        if strip is None:
+            strip = conversion_supported or (not self.stream.closed and not self.stream.isatty())
+        self.strip = strip
+
+        # should we should convert ANSI sequences into win32 calls?
+        if convert is None:
+            convert = conversion_supported and not self.stream.closed and self.stream.isatty()
+        self.convert = convert
+
+        # dict of ansi codes to win32 functions and parameters
+        self.win32_calls = self.get_win32_calls()
+
+        # are we wrapping stderr?
+        self.on_stderr = self.wrapped is sys.stderr
+
+    def should_wrap(self):
+        '''
+        True if this class is actually needed. If false, then the output
+        stream will not be affected, nor will win32 calls be issued, so
+        wrapping stdout is not actually required. This will generally be
+        False on non-Windows platforms, unless optional functionality like
+        autoreset has been requested using kwargs to init()
+        '''
+        return self.convert or self.strip or self.autoreset
+
+    def get_win32_calls(self):
+        if self.convert and winterm:
+            return {
+                AnsiStyle.RESET_ALL: (winterm.reset_all, ),
+                AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT),
+                AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL),
+                AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL),
+                AnsiFore.BLACK: (winterm.fore, WinColor.BLACK),
+                AnsiFore.RED: (winterm.fore, WinColor.RED),
+                AnsiFore.GREEN: (winterm.fore, WinColor.GREEN),
+                AnsiFore.YELLOW: (winterm.fore, WinColor.YELLOW),
+                AnsiFore.BLUE: (winterm.fore, WinColor.BLUE),
+                AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA),
+                AnsiFore.CYAN: (winterm.fore, WinColor.CYAN),
+                AnsiFore.WHITE: (winterm.fore, WinColor.GREY),
+                AnsiFore.RESET: (winterm.fore, ),
+                AnsiFore.LIGHTBLACK_EX: (winterm.fore, WinColor.BLACK, True),
+                AnsiFore.LIGHTRED_EX: (winterm.fore, WinColor.RED, True),
+                AnsiFore.LIGHTGREEN_EX: (winterm.fore, WinColor.GREEN, True),
+                AnsiFore.LIGHTYELLOW_EX: (winterm.fore, WinColor.YELLOW, True),
+                AnsiFore.LIGHTBLUE_EX: (winterm.fore, WinColor.BLUE, True),
+                AnsiFore.LIGHTMAGENTA_EX: (winterm.fore, WinColor.MAGENTA, True),
+                AnsiFore.LIGHTCYAN_EX: (winterm.fore, WinColor.CYAN, True),
+                AnsiFore.LIGHTWHITE_EX: (winterm.fore, WinColor.GREY, True),
+                AnsiBack.BLACK: (winterm.back, WinColor.BLACK),
+                AnsiBack.RED: (winterm.back, WinColor.RED),
+                AnsiBack.GREEN: (winterm.back, WinColor.GREEN),
+                AnsiBack.YELLOW: (winterm.back, WinColor.YELLOW),
+                AnsiBack.BLUE: (winterm.back, WinColor.BLUE),
+                AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA),
+                AnsiBack.CYAN: (winterm.back, WinColor.CYAN),
+                AnsiBack.WHITE: (winterm.back, WinColor.GREY),
+                AnsiBack.RESET: (winterm.back, ),
+                AnsiBack.LIGHTBLACK_EX: (winterm.back, WinColor.BLACK, True),
+                AnsiBack.LIGHTRED_EX: (winterm.back, WinColor.RED, True),
+                AnsiBack.LIGHTGREEN_EX: (winterm.back, WinColor.GREEN, True),
+                AnsiBack.LIGHTYELLOW_EX: (winterm.back, WinColor.YELLOW, True),
+                AnsiBack.LIGHTBLUE_EX: (winterm.back, WinColor.BLUE, True),
+                AnsiBack.LIGHTMAGENTA_EX: (winterm.back, WinColor.MAGENTA, True),
+                AnsiBack.LIGHTCYAN_EX: (winterm.back, WinColor.CYAN, True),
+                AnsiBack.LIGHTWHITE_EX: (winterm.back, WinColor.GREY, True),
+            }
+        return dict()
+
+    def write(self, text):
+        if self.strip or self.convert:
+            self.write_and_convert(text)
+        else:
+            self.wrapped.write(text)
+            self.wrapped.flush()
+        if self.autoreset:
+            self.reset_all()
+
+
+    def reset_all(self):
+        if self.convert:
+            self.call_win32('m', (0,))
+        elif not self.strip and not self.stream.closed:
+            self.wrapped.write(Style.RESET_ALL)
+
+
+    def write_and_convert(self, text):
+        '''
+        Write the given text to our wrapped stream, stripping any ANSI
+        sequences from the text, and optionally converting them into win32
+        calls.
+        '''
+        cursor = 0
+        text = self.convert_osc(text)
+        for match in self.ANSI_CSI_RE.finditer(text):
+            start, end = match.span()
+            self.write_plain_text(text, cursor, start)
+            self.convert_ansi(*match.groups())
+            cursor = end
+        self.write_plain_text(text, cursor, len(text))
+
+
+    def write_plain_text(self, text, start, end):
+        if start < end:
+            self.wrapped.write(text[start:end])
+            self.wrapped.flush()
+
+
+    def convert_ansi(self, paramstring, command):
+        if self.convert:
+            params = self.extract_params(command, paramstring)
+            self.call_win32(command, params)
+
+
+    def extract_params(self, command, paramstring):
+        if command in 'Hf':
+            params = tuple(int(p) if len(p) != 0 else 1 for p in paramstring.split(';'))
+            while len(params) < 2:
+                # defaults:
+                params = params + (1,)
+        else:
+            params = tuple(int(p) for p in paramstring.split(';') if len(p) != 0)
+            if len(params) == 0:
+                # defaults:
+                if command in 'JKm':
+                    params = (0,)
+                elif command in 'ABCD':
+                    params = (1,)
+
+        return params
+
+
+    def call_win32(self, command, params):
+        if command == 'm':
+            for param in params:
+                if param in self.win32_calls:
+                    func_args = self.win32_calls[param]
+                    func = func_args[0]
+                    args = func_args[1:]
+                    kwargs = dict(on_stderr=self.on_stderr)
+                    func(*args, **kwargs)
+        elif command in 'J':
+            winterm.erase_screen(params[0], on_stderr=self.on_stderr)
+        elif command in 'K':
+            winterm.erase_line(params[0], on_stderr=self.on_stderr)
+        elif command in 'Hf':     # cursor position - absolute
+            winterm.set_cursor_position(params, on_stderr=self.on_stderr)
+        elif command in 'ABCD':   # cursor position - relative
+            n = params[0]
+            # A - up, B - down, C - forward, D - back
+            x, y = {'A': (0, -n), 'B': (0, n), 'C': (n, 0), 'D': (-n, 0)}[command]
+            winterm.cursor_adjust(x, y, on_stderr=self.on_stderr)
+
+
+    def convert_osc(self, text):
+        for match in self.ANSI_OSC_RE.finditer(text):
+            start, end = match.span()
+            text = text[:start] + text[end:]
+            paramstring, command = match.groups()
+            if command == BEL:
+                if paramstring.count(";") == 1:
+                    params = paramstring.split(";")
+                    # 0 - change title and icon (we will only change title)
+                    # 1 - change icon (we don't support this)
+                    # 2 - change title
+                    if params[0] in '02':
+                        winterm.set_title(params[1])
+        return text
diff --git a/myenv/lib/python3.9/site-packages/colorama/initialise.py b/myenv/lib/python3.9/site-packages/colorama/initialise.py
new file mode 100644
index 0000000..430d066
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama/initialise.py
@@ -0,0 +1,80 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import atexit
+import contextlib
+import sys
+
+from .ansitowin32 import AnsiToWin32
+
+
+orig_stdout = None
+orig_stderr = None
+
+wrapped_stdout = None
+wrapped_stderr = None
+
+atexit_done = False
+
+
+def reset_all():
+    if AnsiToWin32 is not None:    # Issue #74: objects might become None at exit
+        AnsiToWin32(orig_stdout).reset_all()
+
+
+def init(autoreset=False, convert=None, strip=None, wrap=True):
+
+    if not wrap and any([autoreset, convert, strip]):
+        raise ValueError('wrap=False conflicts with any other arg=True')
+
+    global wrapped_stdout, wrapped_stderr
+    global orig_stdout, orig_stderr
+
+    orig_stdout = sys.stdout
+    orig_stderr = sys.stderr
+
+    if sys.stdout is None:
+        wrapped_stdout = None
+    else:
+        sys.stdout = wrapped_stdout = \
+            wrap_stream(orig_stdout, convert, strip, autoreset, wrap)
+    if sys.stderr is None:
+        wrapped_stderr = None
+    else:
+        sys.stderr = wrapped_stderr = \
+            wrap_stream(orig_stderr, convert, strip, autoreset, wrap)
+
+    global atexit_done
+    if not atexit_done:
+        atexit.register(reset_all)
+        atexit_done = True
+
+
+def deinit():
+    if orig_stdout is not None:
+        sys.stdout = orig_stdout
+    if orig_stderr is not None:
+        sys.stderr = orig_stderr
+
+
+@contextlib.contextmanager
+def colorama_text(*args, **kwargs):
+    init(*args, **kwargs)
+    try:
+        yield
+    finally:
+        deinit()
+
+
+def reinit():
+    if wrapped_stdout is not None:
+        sys.stdout = wrapped_stdout
+    if wrapped_stderr is not None:
+        sys.stderr = wrapped_stderr
+
+
+def wrap_stream(stream, convert, strip, autoreset, wrap):
+    if wrap:
+        wrapper = AnsiToWin32(stream,
+            convert=convert, strip=strip, autoreset=autoreset)
+        if wrapper.should_wrap():
+            stream = wrapper.stream
+    return stream
diff --git a/myenv/lib/python3.9/site-packages/colorama/win32.py b/myenv/lib/python3.9/site-packages/colorama/win32.py
new file mode 100644
index 0000000..c2d8360
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama/win32.py
@@ -0,0 +1,152 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+
+# from winbase.h
+STDOUT = -11
+STDERR = -12
+
+try:
+    import ctypes
+    from ctypes import LibraryLoader
+    windll = LibraryLoader(ctypes.WinDLL)
+    from ctypes import wintypes
+except (AttributeError, ImportError):
+    windll = None
+    SetConsoleTextAttribute = lambda *_: None
+    winapi_test = lambda *_: None
+else:
+    from ctypes import byref, Structure, c_char, POINTER
+
+    COORD = wintypes._COORD
+
+    class CONSOLE_SCREEN_BUFFER_INFO(Structure):
+        """struct in wincon.h."""
+        _fields_ = [
+            ("dwSize", COORD),
+            ("dwCursorPosition", COORD),
+            ("wAttributes", wintypes.WORD),
+            ("srWindow", wintypes.SMALL_RECT),
+            ("dwMaximumWindowSize", COORD),
+        ]
+        def __str__(self):
+            return '(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)' % (
+                self.dwSize.Y, self.dwSize.X
+                , self.dwCursorPosition.Y, self.dwCursorPosition.X
+                , self.wAttributes
+                , self.srWindow.Top, self.srWindow.Left, self.srWindow.Bottom, self.srWindow.Right
+                , self.dwMaximumWindowSize.Y, self.dwMaximumWindowSize.X
+            )
+
+    _GetStdHandle = windll.kernel32.GetStdHandle
+    _GetStdHandle.argtypes = [
+        wintypes.DWORD,
+    ]
+    _GetStdHandle.restype = wintypes.HANDLE
+
+    _GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo
+    _GetConsoleScreenBufferInfo.argtypes = [
+        wintypes.HANDLE,
+        POINTER(CONSOLE_SCREEN_BUFFER_INFO),
+    ]
+    _GetConsoleScreenBufferInfo.restype = wintypes.BOOL
+
+    _SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute
+    _SetConsoleTextAttribute.argtypes = [
+        wintypes.HANDLE,
+        wintypes.WORD,
+    ]
+    _SetConsoleTextAttribute.restype = wintypes.BOOL
+
+    _SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition
+    _SetConsoleCursorPosition.argtypes = [
+        wintypes.HANDLE,
+        COORD,
+    ]
+    _SetConsoleCursorPosition.restype = wintypes.BOOL
+
+    _FillConsoleOutputCharacterA = windll.kernel32.FillConsoleOutputCharacterA
+    _FillConsoleOutputCharacterA.argtypes = [
+        wintypes.HANDLE,
+        c_char,
+        wintypes.DWORD,
+        COORD,
+        POINTER(wintypes.DWORD),
+    ]
+    _FillConsoleOutputCharacterA.restype = wintypes.BOOL
+
+    _FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute
+    _FillConsoleOutputAttribute.argtypes = [
+        wintypes.HANDLE,
+        wintypes.WORD,
+        wintypes.DWORD,
+        COORD,
+        POINTER(wintypes.DWORD),
+    ]
+    _FillConsoleOutputAttribute.restype = wintypes.BOOL
+
+    _SetConsoleTitleW = windll.kernel32.SetConsoleTitleW
+    _SetConsoleTitleW.argtypes = [
+        wintypes.LPCWSTR
+    ]
+    _SetConsoleTitleW.restype = wintypes.BOOL
+
+    def _winapi_test(handle):
+        csbi = CONSOLE_SCREEN_BUFFER_INFO()
+        success = _GetConsoleScreenBufferInfo(
+            handle, byref(csbi))
+        return bool(success)
+
+    def winapi_test():
+        return any(_winapi_test(h) for h in
+                   (_GetStdHandle(STDOUT), _GetStdHandle(STDERR)))
+
+    def GetConsoleScreenBufferInfo(stream_id=STDOUT):
+        handle = _GetStdHandle(stream_id)
+        csbi = CONSOLE_SCREEN_BUFFER_INFO()
+        success = _GetConsoleScreenBufferInfo(
+            handle, byref(csbi))
+        return csbi
+
+    def SetConsoleTextAttribute(stream_id, attrs):
+        handle = _GetStdHandle(stream_id)
+        return _SetConsoleTextAttribute(handle, attrs)
+
+    def SetConsoleCursorPosition(stream_id, position, adjust=True):
+        position = COORD(*position)
+        # If the position is out of range, do nothing.
+        if position.Y <= 0 or position.X <= 0:
+            return
+        # Adjust for Windows' SetConsoleCursorPosition:
+        #    1. being 0-based, while ANSI is 1-based.
+        #    2. expecting (x,y), while ANSI uses (y,x).
+        adjusted_position = COORD(position.Y - 1, position.X - 1)
+        if adjust:
+            # Adjust for viewport's scroll position
+            sr = GetConsoleScreenBufferInfo(STDOUT).srWindow
+            adjusted_position.Y += sr.Top
+            adjusted_position.X += sr.Left
+        # Resume normal processing
+        handle = _GetStdHandle(stream_id)
+        return _SetConsoleCursorPosition(handle, adjusted_position)
+
+    def FillConsoleOutputCharacter(stream_id, char, length, start):
+        handle = _GetStdHandle(stream_id)
+        char = c_char(char.encode())
+        length = wintypes.DWORD(length)
+        num_written = wintypes.DWORD(0)
+        # Note that this is hard-coded for ANSI (vs wide) bytes.
+        success = _FillConsoleOutputCharacterA(
+            handle, char, length, start, byref(num_written))
+        return num_written.value
+
+    def FillConsoleOutputAttribute(stream_id, attr, length, start):
+        ''' FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )'''
+        handle = _GetStdHandle(stream_id)
+        attribute = wintypes.WORD(attr)
+        length = wintypes.DWORD(length)
+        num_written = wintypes.DWORD(0)
+        # Note that this is hard-coded for ANSI (vs wide) bytes.
+        return _FillConsoleOutputAttribute(
+            handle, attribute, length, start, byref(num_written))
+
+    def SetConsoleTitle(title):
+        return _SetConsoleTitleW(title)
diff --git a/myenv/lib/python3.9/site-packages/colorama/winterm.py b/myenv/lib/python3.9/site-packages/colorama/winterm.py
new file mode 100644
index 0000000..0fdb4ec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/colorama/winterm.py
@@ -0,0 +1,169 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+from . import win32
+
+
+# from wincon.h
+class WinColor(object):
+    BLACK   = 0
+    BLUE    = 1
+    GREEN   = 2
+    CYAN    = 3
+    RED     = 4
+    MAGENTA = 5
+    YELLOW  = 6
+    GREY    = 7
+
+# from wincon.h
+class WinStyle(object):
+    NORMAL              = 0x00 # dim text, dim background
+    BRIGHT              = 0x08 # bright text, dim background
+    BRIGHT_BACKGROUND   = 0x80 # dim text, bright background
+
+class WinTerm(object):
+
+    def __init__(self):
+        self._default = win32.GetConsoleScreenBufferInfo(win32.STDOUT).wAttributes
+        self.set_attrs(self._default)
+        self._default_fore = self._fore
+        self._default_back = self._back
+        self._default_style = self._style
+        # In order to emulate LIGHT_EX in windows, we borrow the BRIGHT style.
+        # So that LIGHT_EX colors and BRIGHT style do not clobber each other,
+        # we track them separately, since LIGHT_EX is overwritten by Fore/Back
+        # and BRIGHT is overwritten by Style codes.
+        self._light = 0
+
+    def get_attrs(self):
+        return self._fore + self._back * 16 + (self._style | self._light)
+
+    def set_attrs(self, value):
+        self._fore = value & 7
+        self._back = (value >> 4) & 7
+        self._style = value & (WinStyle.BRIGHT | WinStyle.BRIGHT_BACKGROUND)
+
+    def reset_all(self, on_stderr=None):
+        self.set_attrs(self._default)
+        self.set_console(attrs=self._default)
+        self._light = 0
+
+    def fore(self, fore=None, light=False, on_stderr=False):
+        if fore is None:
+            fore = self._default_fore
+        self._fore = fore
+        # Emulate LIGHT_EX with BRIGHT Style
+        if light:
+            self._light |= WinStyle.BRIGHT
+        else:
+            self._light &= ~WinStyle.BRIGHT
+        self.set_console(on_stderr=on_stderr)
+
+    def back(self, back=None, light=False, on_stderr=False):
+        if back is None:
+            back = self._default_back
+        self._back = back
+        # Emulate LIGHT_EX with BRIGHT_BACKGROUND Style
+        if light:
+            self._light |= WinStyle.BRIGHT_BACKGROUND
+        else:
+            self._light &= ~WinStyle.BRIGHT_BACKGROUND
+        self.set_console(on_stderr=on_stderr)
+
+    def style(self, style=None, on_stderr=False):
+        if style is None:
+            style = self._default_style
+        self._style = style
+        self.set_console(on_stderr=on_stderr)
+
+    def set_console(self, attrs=None, on_stderr=False):
+        if attrs is None:
+            attrs = self.get_attrs()
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        win32.SetConsoleTextAttribute(handle, attrs)
+
+    def get_position(self, handle):
+        position = win32.GetConsoleScreenBufferInfo(handle).dwCursorPosition
+        # Because Windows coordinates are 0-based,
+        # and win32.SetConsoleCursorPosition expects 1-based.
+        position.X += 1
+        position.Y += 1
+        return position
+
+    def set_cursor_position(self, position=None, on_stderr=False):
+        if position is None:
+            # I'm not currently tracking the position, so there is no default.
+            # position = self.get_position()
+            return
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        win32.SetConsoleCursorPosition(handle, position)
+
+    def cursor_adjust(self, x, y, on_stderr=False):
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        position = self.get_position(handle)
+        adjusted_position = (position.Y + y, position.X + x)
+        win32.SetConsoleCursorPosition(handle, adjusted_position, adjust=False)
+
+    def erase_screen(self, mode=0, on_stderr=False):
+        # 0 should clear from the cursor to the end of the screen.
+        # 1 should clear from the cursor to the beginning of the screen.
+        # 2 should clear the entire screen, and move cursor to (1,1)
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        csbi = win32.GetConsoleScreenBufferInfo(handle)
+        # get the number of character cells in the current buffer
+        cells_in_screen = csbi.dwSize.X * csbi.dwSize.Y
+        # get number of character cells before current cursor position
+        cells_before_cursor = csbi.dwSize.X * csbi.dwCursorPosition.Y + csbi.dwCursorPosition.X
+        if mode == 0:
+            from_coord = csbi.dwCursorPosition
+            cells_to_erase = cells_in_screen - cells_before_cursor
+        elif mode == 1:
+            from_coord = win32.COORD(0, 0)
+            cells_to_erase = cells_before_cursor
+        elif mode == 2:
+            from_coord = win32.COORD(0, 0)
+            cells_to_erase = cells_in_screen
+        else:
+            # invalid mode
+            return
+        # fill the entire screen with blanks
+        win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord)
+        # now set the buffer's attributes accordingly
+        win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord)
+        if mode == 2:
+            # put the cursor where needed
+            win32.SetConsoleCursorPosition(handle, (1, 1))
+
+    def erase_line(self, mode=0, on_stderr=False):
+        # 0 should clear from the cursor to the end of the line.
+        # 1 should clear from the cursor to the beginning of the line.
+        # 2 should clear the entire line.
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        csbi = win32.GetConsoleScreenBufferInfo(handle)
+        if mode == 0:
+            from_coord = csbi.dwCursorPosition
+            cells_to_erase = csbi.dwSize.X - csbi.dwCursorPosition.X
+        elif mode == 1:
+            from_coord = win32.COORD(0, csbi.dwCursorPosition.Y)
+            cells_to_erase = csbi.dwCursorPosition.X
+        elif mode == 2:
+            from_coord = win32.COORD(0, csbi.dwCursorPosition.Y)
+            cells_to_erase = csbi.dwSize.X
+        else:
+            # invalid mode
+            return
+        # fill the entire screen with blanks
+        win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord)
+        # now set the buffer's attributes accordingly
+        win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord)
+
+    def set_title(self, title):
+        win32.SetConsoleTitle(title)
diff --git a/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE
new file mode 100644
index 0000000..0707425
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE
@@ -0,0 +1,6 @@
+This software is made available under the terms of *either* of the licenses
+found in LICENSE.APACHE or LICENSE.BSD. Contributions to cryptography are made
+under the terms of *both* these licenses.
+
+The code used in the OS random engine is derived from CPython, and is licensed
+under the terms of the PSF License Agreement.
diff --git a/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE.APACHE b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE.APACHE
new file mode 100644
index 0000000..62589ed
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE.APACHE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE.BSD b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE.BSD
new file mode 100644
index 0000000..ec1a29d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE.BSD
@@ -0,0 +1,27 @@
+Copyright (c) Individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of PyCA Cryptography nor the names of its contributors
+       may be used to endorse or promote products derived from this software
+       without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE.PSF b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE.PSF
new file mode 100644
index 0000000..4d3a4f5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/LICENSE.PSF
@@ -0,0 +1,41 @@
+1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and
+   the Individual or Organization ("Licensee") accessing and otherwise using Python
+   2.7.12 software in source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+   grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+   analyze, test, perform and/or display publicly, prepare derivative works,
+   distribute, and otherwise use Python 2.7.12 alone or in any derivative
+   version, provided, however, that PSF's License Agreement and PSF's notice of
+   copyright, i.e., "Copyright © 2001-2016 Python Software Foundation; All Rights
+   Reserved" are retained in Python 2.7.12 alone or in any derivative version
+   prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+   incorporates Python 2.7.12 or any part thereof, and wants to make the
+   derivative work available to others as provided herein, then Licensee hereby
+   agrees to include in any such work a brief summary of the changes made to Python
+   2.7.12.
+
+4. PSF is making Python 2.7.12 available to Licensee on an "AS IS" basis.
+   PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.  BY WAY OF
+   EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
+   WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
+   USE OF PYTHON 2.7.12 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.7.12
+   FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
+   MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.7.12, OR ANY DERIVATIVE
+   THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material breach of
+   its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any relationship
+   of agency, partnership, or joint venture between PSF and Licensee.  This License
+   Agreement does not grant permission to use PSF trademarks or trade name in a
+   trademark sense to endorse or promote products or services of Licensee, or any
+   third party.
+
+8. By copying, installing or otherwise using Python 2.7.12, Licensee agrees
+   to be bound by the terms and conditions of this License Agreement.
diff --git a/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/METADATA b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/METADATA
new file mode 100644
index 0000000..9ed7d6c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/METADATA
@@ -0,0 +1,138 @@
+Metadata-Version: 2.1
+Name: cryptography
+Version: 37.0.4
+Summary: cryptography is a package which provides cryptographic recipes and primitives to Python developers.
+Home-page: https://github.com/pyca/cryptography
+Author: The Python Cryptographic Authority and individual contributors
+Author-email: cryptography-dev@python.org
+License: BSD-3-Clause OR Apache-2.0
+Project-URL: Documentation, https://cryptography.io/
+Project-URL: Source, https://github.com/pyca/cryptography/
+Project-URL: Issues, https://github.com/pyca/cryptography/issues
+Project-URL: Changelog, https://cryptography.io/en/latest/changelog/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: BSD
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.6
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: LICENSE.APACHE
+License-File: LICENSE.BSD
+License-File: LICENSE.PSF
+Requires-Dist: cffi (>=1.12)
+Provides-Extra: docs
+Requires-Dist: sphinx (!=1.8.0,!=3.1.0,!=3.1.1,>=1.6.5) ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
+Provides-Extra: docstest
+Requires-Dist: pyenchant (>=1.6.11) ; extra == 'docstest'
+Requires-Dist: twine (>=1.12.0) ; extra == 'docstest'
+Requires-Dist: sphinxcontrib-spelling (>=4.0.1) ; extra == 'docstest'
+Provides-Extra: pep8test
+Requires-Dist: black ; extra == 'pep8test'
+Requires-Dist: flake8 ; extra == 'pep8test'
+Requires-Dist: flake8-import-order ; extra == 'pep8test'
+Requires-Dist: pep8-naming ; extra == 'pep8test'
+Provides-Extra: sdist
+Requires-Dist: setuptools-rust (>=0.11.4) ; extra == 'sdist'
+Provides-Extra: ssh
+Requires-Dist: bcrypt (>=3.1.5) ; extra == 'ssh'
+Provides-Extra: test
+Requires-Dist: pytest (>=6.2.0) ; extra == 'test'
+Requires-Dist: pytest-benchmark ; extra == 'test'
+Requires-Dist: pytest-cov ; extra == 'test'
+Requires-Dist: pytest-subtests ; extra == 'test'
+Requires-Dist: pytest-xdist ; extra == 'test'
+Requires-Dist: pretend ; extra == 'test'
+Requires-Dist: iso8601 ; extra == 'test'
+Requires-Dist: pytz ; extra == 'test'
+Requires-Dist: hypothesis (!=3.79.2,>=1.11.4) ; extra == 'test'
+
+pyca/cryptography
+=================
+
+.. image:: https://img.shields.io/pypi/v/cryptography.svg
+    :target: https://pypi.org/project/cryptography/
+    :alt: Latest Version
+
+.. image:: https://readthedocs.org/projects/cryptography/badge/?version=latest
+    :target: https://cryptography.io
+    :alt: Latest Docs
+
+.. image:: https://github.com/pyca/cryptography/workflows/CI/badge.svg?branch=main
+    :target: https://github.com/pyca/cryptography/actions?query=workflow%3ACI+branch%3Amain
+
+.. image:: https://codecov.io/github/pyca/cryptography/coverage.svg?branch=main
+    :target: https://codecov.io/github/pyca/cryptography?branch=main
+
+
+``cryptography`` is a package which provides cryptographic recipes and
+primitives to Python developers.  Our goal is for it to be your "cryptographic
+standard library". It supports Python 3.6+ and PyPy3 7.2+.
+
+``cryptography`` includes both high level recipes and low level interfaces to
+common cryptographic algorithms such as symmetric ciphers, message digests, and
+key derivation functions. For example, to encrypt something with
+``cryptography``'s high level symmetric encryption recipe:
+
+.. code-block:: pycon
+
+    >>> from cryptography.fernet import Fernet
+    >>> # Put this somewhere safe!
+    >>> key = Fernet.generate_key()
+    >>> f = Fernet(key)
+    >>> token = f.encrypt(b"A really secret message. Not for prying eyes.")
+    >>> token
+    '...'
+    >>> f.decrypt(token)
+    'A really secret message. Not for prying eyes.'
+
+You can find more information in the `documentation`_.
+
+You can install ``cryptography`` with:
+
+.. code-block:: console
+
+    $ pip install cryptography
+
+For full details see `the installation documentation`_.
+
+Discussion
+~~~~~~~~~~
+
+If you run into bugs, you can file them in our `issue tracker`_.
+
+We maintain a `cryptography-dev`_ mailing list for development discussion.
+
+You can also join ``#pyca`` on ``irc.libera.chat`` to ask questions or get
+involved.
+
+Security
+~~~~~~~~
+
+Need to report a security issue? Please consult our `security reporting`_
+documentation.
+
+
+.. _`documentation`: https://cryptography.io/
+.. _`the installation documentation`: https://cryptography.io/en/latest/installation/
+.. _`issue tracker`: https://github.com/pyca/cryptography/issues
+.. _`cryptography-dev`: https://mail.python.org/mailman/listinfo/cryptography-dev
+.. _`security reporting`: https://cryptography.io/en/latest/security/
diff --git a/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/RECORD b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/RECORD
new file mode 100644
index 0000000..c09d990
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/RECORD
@@ -0,0 +1,99 @@
+cryptography/__about__.py,sha256=--Ir4xTpXvJIAKXDX9hap3KQf2E9--cHRoaKB-fb_cY,417
+cryptography/__init__.py,sha256=j08JCN_u_m8eL-zxbXRxgsriW6Oe29oSSo_e2hyyasg,748
+cryptography/exceptions.py,sha256=sN_VVTF_LuKMM6R-lIASFFuzAmz1uZ2Qbcdko9WyS64,1471
+cryptography/fernet.py,sha256=W1NZKgmIxX-iMJr6GW-vm-j4BkYACKxHjrq4cbIZMaw,6604
+cryptography/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cryptography/utils.py,sha256=v3zj8FS2bHYAmH__CECwfa0flmFCQnGrxZBRQcDys1A,5627
+cryptography/hazmat/__init__.py,sha256=OYlvgprzULzZlsf3yYTsd6VUVyQmpsbHjgJdNnsyRwE,418
+cryptography/hazmat/_oid.py,sha256=CrOgnohV6ckWZU7ZFUYvgf_Gj8npC7LhJfzBB6wLHYc,15440
+cryptography/hazmat/backends/__init__.py,sha256=bgrjB1SX2vXX-rmfG7A4PqGkq-isqQVXGaZtjWHAgj0,324
+cryptography/hazmat/backends/openssl/__init__.py,sha256=7rpz1Z3eV9vZy_d2iLrwC8Oz0vEruDFrjJlc6W2ZDXA,271
+cryptography/hazmat/backends/openssl/aead.py,sha256=1GASyrJPO8a-mDPTT7VJZXPb_0zEdrkW-Wu_rxV-6RQ,8442
+cryptography/hazmat/backends/openssl/backend.py,sha256=XBpLgVxVYvXwmkdcCwd0bVQWK0EBTHTbCFDsLGsBbBg,96584
+cryptography/hazmat/backends/openssl/ciphers.py,sha256=n3rrPQZi1blJBKqIWeMG6-U6YTvEb8rXGQKn8i-kFog,10342
+cryptography/hazmat/backends/openssl/cmac.py,sha256=K5-S0H72KHZH-WPAcHL5jCtcNyoBZSMe7VmxGn8_VWA,3005
+cryptography/hazmat/backends/openssl/decode_asn1.py,sha256=nSqtgO5MJVf_UUkvw9tez10zhGnsGHq24OP1X2GKOe4,1113
+cryptography/hazmat/backends/openssl/dh.py,sha256=9fwPordToELTkeJ-c7TuO9NiE1vfUBejk2QEUZbvo4s,12230
+cryptography/hazmat/backends/openssl/dsa.py,sha256=awfP80ykAfb4C_I-aOo-PnGU1DF6uf8bnEi-jld18ec,8888
+cryptography/hazmat/backends/openssl/ec.py,sha256=kgxwW508FTXDwGG-7pSywBLlICZKKfo4bcTHnNpsvJY,11103
+cryptography/hazmat/backends/openssl/ed25519.py,sha256=irHT-jSbpTNMMHqw5T885uzAi3Syf3kaaHuTnKgQPSg,5920
+cryptography/hazmat/backends/openssl/ed448.py,sha256=K8HDEiXl98QGJ-4llT4SVZf5-xe8aCuci00DkZf0lhw,5874
+cryptography/hazmat/backends/openssl/encode_asn1.py,sha256=4RUYVTpkYh6J1BnmYdr3G8xv4X1H-K2k2-fQoIDkpHI,570
+cryptography/hazmat/backends/openssl/hashes.py,sha256=3L5bkCOo2LbRSVNGLca_9rpCZ2zb8ISBrMLtts1BkEw,3241
+cryptography/hazmat/backends/openssl/hmac.py,sha256=9RX8bo9ywJievoodxjmqCXmD2iUWyH2jBmw78Hb-pOY,3095
+cryptography/hazmat/backends/openssl/poly1305.py,sha256=_qyGCXNaQVCFpa1qjb_9UtsI6lmnki_15Jbc5vihbeE,2514
+cryptography/hazmat/backends/openssl/rsa.py,sha256=KK97C_jBJEUGfKfJK7E8QZ-uZb6DTJjX6dLOuVbqTI8,20720
+cryptography/hazmat/backends/openssl/utils.py,sha256=7Ara81KkY0QCLPqW6kUG9dEsp52cZ3kOUJczwEpecJ0,1977
+cryptography/hazmat/backends/openssl/x25519.py,sha256=oA_ao4o27ki_OAx0UXNeI2ItZ84Xg_li7It1DxFlrZ0,4753
+cryptography/hazmat/backends/openssl/x448.py,sha256=a_zgqGUpGFvyKEoKRR1vgNdD_gk1gxGYpBp1a6x9HuE,4338
+cryptography/hazmat/backends/openssl/x509.py,sha256=WUoRC6UDM9FkOdn6xR5Mk-v_WCq7eJryenGN9ni8L-A,1452
+cryptography/hazmat/bindings/__init__.py,sha256=s9oKCQ2ycFdXoERdS1imafueSkBsL9kvbyfghaauZ9Y,180
+cryptography/hazmat/bindings/_openssl.abi3.so,sha256=8iHtYijm7UPnTTJ2C0n5tOrVDan81I-HEF9oR2SvVyM,6023128
+cryptography/hazmat/bindings/_rust.abi3.so,sha256=OmU1FnjADpbk4-CDvbk2G63VxB6MbrYeivWX_IBBNz0,2004592
+cryptography/hazmat/bindings/_rust/__init__.pyi,sha256=ga5QLYp8MmumQB-Rp4TGHq_NAqONcXTrLm2712TZ9Ms,103
+cryptography/hazmat/bindings/_rust/asn1.pyi,sha256=Hovrt8dXZ9p8BKHaroPYmunu1VtDuirslJnE4jTG28s,411
+cryptography/hazmat/bindings/_rust/ocsp.pyi,sha256=jATWMh1yz5JpnnT7A10_sbY-ja5zARnOpZaToLqm43Y,768
+cryptography/hazmat/bindings/_rust/x509.pyi,sha256=YdnUA9uu60WhQP5QihTgo2pBrT49wxYtayCZ4trgZAg,1497
+cryptography/hazmat/bindings/openssl/__init__.py,sha256=s9oKCQ2ycFdXoERdS1imafueSkBsL9kvbyfghaauZ9Y,180
+cryptography/hazmat/bindings/openssl/_conditional.py,sha256=K0JIsYkDBifV-x5WDeq9M1Hofr6HW667rDFlhDEiIMQ,10078
+cryptography/hazmat/bindings/openssl/binding.py,sha256=hWWp-N_JMUuYaNuRHgpadEEdVJsL-wAhdQpTj-Pi0Vc,8044
+cryptography/hazmat/primitives/__init__.py,sha256=s9oKCQ2ycFdXoERdS1imafueSkBsL9kvbyfghaauZ9Y,180
+cryptography/hazmat/primitives/_asymmetric.py,sha256=nVJwmxkakirAXfFp410pC4kY_CinzN5FSJwhEn2IE34,485
+cryptography/hazmat/primitives/_cipheralgorithm.py,sha256=zd7N8rBYWaf8tPM7GDtZ9vUgarK_P0_PUNCFi3A0u0c,1016
+cryptography/hazmat/primitives/_serialization.py,sha256=OC_uXC5cNHucoOkHuTsZbfcQ9bvZs1cq7b18TcJu4Es,1341
+cryptography/hazmat/primitives/cmac.py,sha256=ODkc7EonY1cRxyJ0SYOuwtiYQv6B0ZPxJQm3rXxfXd4,2037
+cryptography/hazmat/primitives/constant_time.py,sha256=6bkW00QjhKusdgsQbexXhMlGX0XRN59XNmxWS2W38NA,387
+cryptography/hazmat/primitives/hashes.py,sha256=cpaYjgkazlq7Xw0MVoR3cp17mD0TgyEvhZQbyoAWHzU,5996
+cryptography/hazmat/primitives/hmac.py,sha256=M_sa4smPIkO8ra17Xl_cM0daRhGCozUu_8gnHePEIb0,2131
+cryptography/hazmat/primitives/keywrap.py,sha256=TWqyG9K7k-Ymq4kcIw7u3NIKUPVDtv6bimwxIJYTe20,5643
+cryptography/hazmat/primitives/padding.py,sha256=xruasOE5Cd8KEQ-yp9W6v9WKPvKH-GudHCPKQ7A8HfI,6207
+cryptography/hazmat/primitives/poly1305.py,sha256=QvxPMrqjgKJt0mOZSeZKk4NcxsNCd2kgfI-X1CmyUW4,1837
+cryptography/hazmat/primitives/asymmetric/__init__.py,sha256=s9oKCQ2ycFdXoERdS1imafueSkBsL9kvbyfghaauZ9Y,180
+cryptography/hazmat/primitives/asymmetric/dh.py,sha256=pjjgKFcn2bCAaL_5zr0ygwXM8pHJFyAO6koJFkzhQb8,6604
+cryptography/hazmat/primitives/asymmetric/dsa.py,sha256=dIo6lYiHWRWUCxwejAi01w1-3jjmzEuJovqaVqDO3_g,7870
+cryptography/hazmat/primitives/asymmetric/ec.py,sha256=wX8wH9bD7g7-YxmINam_s9cPc9RUPrui2QdIKg6Q3Nc,14468
+cryptography/hazmat/primitives/asymmetric/ed25519.py,sha256=1qOl1UWV_-cXKHhwlFSyPBdhpx2HMDRukkI6eI5i8vM,2728
+cryptography/hazmat/primitives/asymmetric/ed448.py,sha256=oR-j4jGcWUnGxWi1GygHxVZbgkSOKHsR6y1E3Lf6wYM,2647
+cryptography/hazmat/primitives/asymmetric/padding.py,sha256=EkKuY9e6UFqSuQ0LvyKYKl_L19tOfNCTlHWEiKgHeUc,2690
+cryptography/hazmat/primitives/asymmetric/rsa.py,sha256=GiCIuBuJdpeew-yJ7mnTF4KFH_FUJaut1r-d6TRs31s,11322
+cryptography/hazmat/primitives/asymmetric/types.py,sha256=VidxjUWPOMB8q8vGiaXMhY715Zw8U9Vd4_rkqjOagRE,1814
+cryptography/hazmat/primitives/asymmetric/utils.py,sha256=5hD4KjfMbmozeFq08PLVunHr4FgeVzV1NkKalECM26s,756
+cryptography/hazmat/primitives/asymmetric/x25519.py,sha256=-nbaGlgT1sufO9Ic-urwKDql8Da0U3GL6hZJIMqHgVc,2588
+cryptography/hazmat/primitives/asymmetric/x448.py,sha256=V3lxb1VOiRTa3bzVUC3uZat2ogfExUOdktCIGUUMZ2Y,2556
+cryptography/hazmat/primitives/ciphers/__init__.py,sha256=Qp78Y3PDSRfwp7DDa3pezlLrED_QFhic_LvDw4LM9ZQ,646
+cryptography/hazmat/primitives/ciphers/aead.py,sha256=QnJD2doZ8XdpCIrDwqJBNgaw2eG9Tx4FWirIP159MAg,11488
+cryptography/hazmat/primitives/ciphers/algorithms.py,sha256=GoM_c2LNonci43B06g0e9zXW6PfBh_uAFiZhIxrQ_x4,4677
+cryptography/hazmat/primitives/ciphers/base.py,sha256=AiCYCzXbSZ9wQbXWMYc60IKmzqz5619YdaaF0zVr4rY,8251
+cryptography/hazmat/primitives/ciphers/modes.py,sha256=Pb2h2X0HUVfM6xKdSZjCgCsUcCQ32mDTSTRQQl4-1Gs,7988
+cryptography/hazmat/primitives/kdf/__init__.py,sha256=DcZhzfLG8d8IYBH771lGTVU5S87OQDpu3nrfOwZnsmA,715
+cryptography/hazmat/primitives/kdf/concatkdf.py,sha256=5YXw8cLZCBYT6rVDGS5URQEeFiPW-ZRBRcPdZQIxTMA,3772
+cryptography/hazmat/primitives/kdf/hkdf.py,sha256=LlDQbCvlNzuLa_UJXrkG5fXGjAjor5Wunv2378TBmms,3031
+cryptography/hazmat/primitives/kdf/kbkdf.py,sha256=QmgJw2_l0D21DEMMfuNQ6e1IaLV3bjwOzMJEAXhpOVs,7699
+cryptography/hazmat/primitives/kdf/pbkdf2.py,sha256=wEMH4CJfPccCg9apQLXyWUWBrZLTpYLLnoZEnzvaHQo,2032
+cryptography/hazmat/primitives/kdf/scrypt.py,sha256=JvX_cD0o0Op5EcFNeZhr-vI5sYv_LdnJ6kNEbW3u5ow,2228
+cryptography/hazmat/primitives/kdf/x963kdf.py,sha256=JsdrJhw2IJVYkl8JIWUN66h7DrKZM2RoQ_tw_iKAvdI,2018
+cryptography/hazmat/primitives/serialization/__init__.py,sha256=RALEthF7wRjlMyTvSq09XmKQey74tsSdDCCsDaD6yQU,1129
+cryptography/hazmat/primitives/serialization/base.py,sha256=yw8_yzIvruT6fmS-KrTmIXbAF00rItH48WXTPOSLdJ4,1761
+cryptography/hazmat/primitives/serialization/pkcs12.py,sha256=tHQlCKOY0EfOBBiqR_et4TgcDY_OAtRENC69arjvyLU,6481
+cryptography/hazmat/primitives/serialization/pkcs7.py,sha256=LnISP-1SEDXCpsoEbR0EfuIlWm8eJAgWupt0gvHyyIU,5870
+cryptography/hazmat/primitives/serialization/ssh.py,sha256=Bp4M8yFrLnw9Oj3jCbttewovymCX_OGzBg5GBw4RPpA,23923
+cryptography/hazmat/primitives/twofactor/__init__.py,sha256=ZHo4zwWidFP2RWFl8luiNuYkVMZPghzx54izPNSCtD4,222
+cryptography/hazmat/primitives/twofactor/hotp.py,sha256=v4wkTbdc1E53POx6pdNnEUBvANbmt4f6scQSsTgABeU,2989
+cryptography/hazmat/primitives/twofactor/totp.py,sha256=bIIxOI-LcLGNahB5kN7A_TwEyYMTsLjHd8eJc4b2cLg,1449
+cryptography/x509/__init__.py,sha256=yC0TbuvPmWL1U4rEY-0m46SayuxCfPVNFWjJJdi5lY0,7654
+cryptography/x509/base.py,sha256=FNBVG8ACCBZLF5TXlq1vjEPWtlR5YZ1Bs25AIxEHI34,33747
+cryptography/x509/certificate_transparency.py,sha256=Elm_-GGA6k9zrcm5KYVY5uTirDsvGc_BUuTLR7Hu-K4,1119
+cryptography/x509/extensions.py,sha256=LFy1jgd_0Z_P-lE2-07nZGJmsFh_1cOOTAl9ejyXFHQ,64999
+cryptography/x509/general_name.py,sha256=S_kJd4ZsNGrMfi2osfFJEWqPxy3oPCAWpLb91yhxzPs,7896
+cryptography/x509/name.py,sha256=EOtO9CscxrfsxhO6GTEfVhiZo3_EE7qGIFfv1eeI4-U,14200
+cryptography/x509/ocsp.py,sha256=OQKsqW_Y4mWY53UT_JG79RJR19xt53Q-iQSSw4m0kZM,16691
+cryptography/x509/oid.py,sha256=CLIlQwzE3PQXMvkKep4JbzVUaRDl_stwcX_U6-s2cNw,794
+cryptography-37.0.4.dist-info/LICENSE,sha256=Q9rSzHUqtyHNmp827OcPtTq3cTVR8tPYaU2OjFoG1uI,323
+cryptography-37.0.4.dist-info/LICENSE.APACHE,sha256=qsc7MUj20dcRHbyjIJn2jSbGRMaBOuHk8F9leaomY_4,11360
+cryptography-37.0.4.dist-info/LICENSE.BSD,sha256=YCxMdILeZHndLpeTzaJ15eY9dz2s0eymiSMqtwCPtPs,1532
+cryptography-37.0.4.dist-info/LICENSE.PSF,sha256=aT7ApmKzn5laTyUrA6YiKUVHDBtvEsoCkY5O_g32S58,2415
+cryptography-37.0.4.dist-info/METADATA,sha256=xTRAAMAb3cHqW1cXChdK9TXOWG2ghhz-sdfmRXvXrqU,5434
+cryptography-37.0.4.dist-info/WHEEL,sha256=MfjkjXwqeYlORnFhJNWi-eFW4jhozqV8XXeu9PzVv9Y,110
+cryptography-37.0.4.dist-info/top_level.txt,sha256=zYbdX67v4JFZPfsaNue7ZV4-mgoRqYCAhMsNgt22LqA,22
+cryptography-37.0.4.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+cryptography-37.0.4.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/WHEEL
new file mode 100644
index 0000000..fd41c07
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp36-abi3-macosx_10_10_x86_64
+
diff --git a/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/top_level.txt
new file mode 100644
index 0000000..f512e40
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography-37.0.4.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+_openssl
+cryptography
diff --git a/myenv/lib/python3.9/site-packages/cryptography/__about__.py b/myenv/lib/python3.9/site-packages/cryptography/__about__.py
new file mode 100644
index 0000000..399beb6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/__about__.py
@@ -0,0 +1,15 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+__all__ = [
+    "__version__",
+    "__author__",
+    "__copyright__",
+]
+
+__version__ = "37.0.4"
+
+__author__ = "The Python Cryptographic Authority and individual contributors"
+__copyright__ = "Copyright 2013-2022 {}".format(__author__)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/__init__.py
new file mode 100644
index 0000000..599bf51
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/__init__.py
@@ -0,0 +1,29 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import sys
+import warnings
+
+from cryptography.__about__ import (
+    __author__,
+    __copyright__,
+    __version__,
+)
+from cryptography.utils import CryptographyDeprecationWarning
+
+
+__all__ = [
+    "__version__",
+    "__author__",
+    "__copyright__",
+]
+
+if sys.version_info[:2] == (3, 6):
+    warnings.warn(
+        "Python 3.6 is no longer supported by the Python core team. "
+        "Therefore, support for it is deprecated in cryptography and will be"
+        " removed in a future release.",
+        CryptographyDeprecationWarning,
+        stacklevel=2,
+    )
diff --git a/myenv/lib/python3.9/site-packages/cryptography/exceptions.py b/myenv/lib/python3.9/site-packages/cryptography/exceptions.py
new file mode 100644
index 0000000..a315703
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/exceptions.py
@@ -0,0 +1,68 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import typing
+
+from cryptography import utils
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.bindings.openssl.binding import (
+        _OpenSSLErrorWithText,
+    )
+
+
+class _Reasons(utils.Enum):
+    BACKEND_MISSING_INTERFACE = 0
+    UNSUPPORTED_HASH = 1
+    UNSUPPORTED_CIPHER = 2
+    UNSUPPORTED_PADDING = 3
+    UNSUPPORTED_MGF = 4
+    UNSUPPORTED_PUBLIC_KEY_ALGORITHM = 5
+    UNSUPPORTED_ELLIPTIC_CURVE = 6
+    UNSUPPORTED_SERIALIZATION = 7
+    UNSUPPORTED_X509 = 8
+    UNSUPPORTED_EXCHANGE_ALGORITHM = 9
+    UNSUPPORTED_DIFFIE_HELLMAN = 10
+    UNSUPPORTED_MAC = 11
+
+
+class UnsupportedAlgorithm(Exception):
+    def __init__(
+        self, message: str, reason: typing.Optional[_Reasons] = None
+    ) -> None:
+        super(UnsupportedAlgorithm, self).__init__(message)
+        self._reason = reason
+
+
+class AlreadyFinalized(Exception):
+    pass
+
+
+class AlreadyUpdated(Exception):
+    pass
+
+
+class NotYetFinalized(Exception):
+    pass
+
+
+class InvalidTag(Exception):
+    pass
+
+
+class InvalidSignature(Exception):
+    pass
+
+
+class InternalError(Exception):
+    def __init__(
+        self, msg: str, err_code: typing.List["_OpenSSLErrorWithText"]
+    ) -> None:
+        super(InternalError, self).__init__(msg)
+        self.err_code = err_code
+
+
+class InvalidKey(Exception):
+    pass
diff --git a/myenv/lib/python3.9/site-packages/cryptography/fernet.py b/myenv/lib/python3.9/site-packages/cryptography/fernet.py
new file mode 100644
index 0000000..9c5a3d7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/fernet.py
@@ -0,0 +1,212 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import base64
+import binascii
+import os
+import time
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import hashes, padding
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives.hmac import HMAC
+
+
+class InvalidToken(Exception):
+    pass
+
+
+_MAX_CLOCK_SKEW = 60
+
+
+class Fernet:
+    def __init__(
+        self,
+        key: typing.Union[bytes, str],
+        backend: typing.Any = None,
+    ):
+        try:
+            key = base64.urlsafe_b64decode(key)
+        except binascii.Error as exc:
+            raise ValueError(
+                "Fernet key must be 32 url-safe base64-encoded bytes."
+            ) from exc
+        if len(key) != 32:
+            raise ValueError(
+                "Fernet key must be 32 url-safe base64-encoded bytes."
+            )
+
+        self._signing_key = key[:16]
+        self._encryption_key = key[16:]
+
+    @classmethod
+    def generate_key(cls) -> bytes:
+        return base64.urlsafe_b64encode(os.urandom(32))
+
+    def encrypt(self, data: bytes) -> bytes:
+        return self.encrypt_at_time(data, int(time.time()))
+
+    def encrypt_at_time(self, data: bytes, current_time: int) -> bytes:
+        iv = os.urandom(16)
+        return self._encrypt_from_parts(data, current_time, iv)
+
+    def _encrypt_from_parts(
+        self, data: bytes, current_time: int, iv: bytes
+    ) -> bytes:
+        utils._check_bytes("data", data)
+
+        padder = padding.PKCS7(algorithms.AES.block_size).padder()
+        padded_data = padder.update(data) + padder.finalize()
+        encryptor = Cipher(
+            algorithms.AES(self._encryption_key),
+            modes.CBC(iv),
+        ).encryptor()
+        ciphertext = encryptor.update(padded_data) + encryptor.finalize()
+
+        basic_parts = (
+            b"\x80"
+            + current_time.to_bytes(length=8, byteorder="big")
+            + iv
+            + ciphertext
+        )
+
+        h = HMAC(self._signing_key, hashes.SHA256())
+        h.update(basic_parts)
+        hmac = h.finalize()
+        return base64.urlsafe_b64encode(basic_parts + hmac)
+
+    def decrypt(self, token: bytes, ttl: typing.Optional[int] = None) -> bytes:
+        timestamp, data = Fernet._get_unverified_token_data(token)
+        if ttl is None:
+            time_info = None
+        else:
+            time_info = (ttl, int(time.time()))
+        return self._decrypt_data(data, timestamp, time_info)
+
+    def decrypt_at_time(
+        self, token: bytes, ttl: int, current_time: int
+    ) -> bytes:
+        if ttl is None:
+            raise ValueError(
+                "decrypt_at_time() can only be used with a non-None ttl"
+            )
+        timestamp, data = Fernet._get_unverified_token_data(token)
+        return self._decrypt_data(data, timestamp, (ttl, current_time))
+
+    def extract_timestamp(self, token: bytes) -> int:
+        timestamp, data = Fernet._get_unverified_token_data(token)
+        # Verify the token was not tampered with.
+        self._verify_signature(data)
+        return timestamp
+
+    @staticmethod
+    def _get_unverified_token_data(token: bytes) -> typing.Tuple[int, bytes]:
+        utils._check_bytes("token", token)
+        try:
+            data = base64.urlsafe_b64decode(token)
+        except (TypeError, binascii.Error):
+            raise InvalidToken
+
+        if not data or data[0] != 0x80:
+            raise InvalidToken
+
+        if len(data) < 9:
+            raise InvalidToken
+
+        timestamp = int.from_bytes(data[1:9], byteorder="big")
+        return timestamp, data
+
+    def _verify_signature(self, data: bytes) -> None:
+        h = HMAC(self._signing_key, hashes.SHA256())
+        h.update(data[:-32])
+        try:
+            h.verify(data[-32:])
+        except InvalidSignature:
+            raise InvalidToken
+
+    def _decrypt_data(
+        self,
+        data: bytes,
+        timestamp: int,
+        time_info: typing.Optional[typing.Tuple[int, int]],
+    ) -> bytes:
+        if time_info is not None:
+            ttl, current_time = time_info
+            if timestamp + ttl < current_time:
+                raise InvalidToken
+
+            if current_time + _MAX_CLOCK_SKEW < timestamp:
+                raise InvalidToken
+
+        self._verify_signature(data)
+
+        iv = data[9:25]
+        ciphertext = data[25:-32]
+        decryptor = Cipher(
+            algorithms.AES(self._encryption_key), modes.CBC(iv)
+        ).decryptor()
+        plaintext_padded = decryptor.update(ciphertext)
+        try:
+            plaintext_padded += decryptor.finalize()
+        except ValueError:
+            raise InvalidToken
+        unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
+
+        unpadded = unpadder.update(plaintext_padded)
+        try:
+            unpadded += unpadder.finalize()
+        except ValueError:
+            raise InvalidToken
+        return unpadded
+
+
+class MultiFernet:
+    def __init__(self, fernets: typing.Iterable[Fernet]):
+        fernets = list(fernets)
+        if not fernets:
+            raise ValueError(
+                "MultiFernet requires at least one Fernet instance"
+            )
+        self._fernets = fernets
+
+    def encrypt(self, msg: bytes) -> bytes:
+        return self.encrypt_at_time(msg, int(time.time()))
+
+    def encrypt_at_time(self, msg: bytes, current_time: int) -> bytes:
+        return self._fernets[0].encrypt_at_time(msg, current_time)
+
+    def rotate(self, msg: bytes) -> bytes:
+        timestamp, data = Fernet._get_unverified_token_data(msg)
+        for f in self._fernets:
+            try:
+                p = f._decrypt_data(data, timestamp, None)
+                break
+            except InvalidToken:
+                pass
+        else:
+            raise InvalidToken
+
+        iv = os.urandom(16)
+        return self._fernets[0]._encrypt_from_parts(p, timestamp, iv)
+
+    def decrypt(self, msg: bytes, ttl: typing.Optional[int] = None) -> bytes:
+        for f in self._fernets:
+            try:
+                return f.decrypt(msg, ttl)
+            except InvalidToken:
+                pass
+        raise InvalidToken
+
+    def decrypt_at_time(
+        self, msg: bytes, ttl: int, current_time: int
+    ) -> bytes:
+        for f in self._fernets:
+            try:
+                return f.decrypt_at_time(msg, ttl, current_time)
+            except InvalidToken:
+                pass
+        raise InvalidToken
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/__init__.py
new file mode 100644
index 0000000..007694b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/__init__.py
@@ -0,0 +1,10 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+"""
+Hazardous Materials
+
+This is a "Hazardous Materials" module. You should ONLY use it if you're
+100% absolutely sure that you know what you're doing because this module
+is full of land mines, dragons, and dinosaurs with laser guns.
+"""
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/_oid.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/_oid.py
new file mode 100644
index 0000000..da3668b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/_oid.py
@@ -0,0 +1,345 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives import hashes
+
+
+class ObjectIdentifier:
+    def __init__(self, dotted_string: str) -> None:
+        self._dotted_string = dotted_string
+
+        nodes = self._dotted_string.split(".")
+        intnodes = []
+
+        # There must be at least 2 nodes, the first node must be 0..2, and
+        # if less than 2, the second node cannot have a value outside the
+        # range 0..39.  All nodes must be integers.
+        for node in nodes:
+            try:
+                node_value = int(node, 10)
+            except ValueError:
+                raise ValueError(
+                    f"Malformed OID: {dotted_string} (non-integer nodes)"
+                )
+            if node_value < 0:
+                raise ValueError(
+                    f"Malformed OID: {dotted_string} (negative-integer nodes)"
+                )
+            intnodes.append(node_value)
+
+        if len(nodes) < 2:
+            raise ValueError(
+                f"Malformed OID: {dotted_string} "
+                "(insufficient number of nodes)"
+            )
+
+        if intnodes[0] > 2:
+            raise ValueError(
+                f"Malformed OID: {dotted_string} "
+                "(first node outside valid range)"
+            )
+
+        if intnodes[0] < 2 and intnodes[1] >= 40:
+            raise ValueError(
+                f"Malformed OID: {dotted_string} "
+                "(second node outside valid range)"
+            )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ObjectIdentifier):
+            return NotImplemented
+
+        return self.dotted_string == other.dotted_string
+
+    def __repr__(self) -> str:
+        return "<ObjectIdentifier(oid={}, name={})>".format(
+            self.dotted_string, self._name
+        )
+
+    def __hash__(self) -> int:
+        return hash(self.dotted_string)
+
+    @property
+    def _name(self) -> str:
+        return _OID_NAMES.get(self, "Unknown OID")
+
+    @property
+    def dotted_string(self) -> str:
+        return self._dotted_string
+
+
+class ExtensionOID:
+    SUBJECT_DIRECTORY_ATTRIBUTES = ObjectIdentifier("2.5.29.9")
+    SUBJECT_KEY_IDENTIFIER = ObjectIdentifier("2.5.29.14")
+    KEY_USAGE = ObjectIdentifier("2.5.29.15")
+    SUBJECT_ALTERNATIVE_NAME = ObjectIdentifier("2.5.29.17")
+    ISSUER_ALTERNATIVE_NAME = ObjectIdentifier("2.5.29.18")
+    BASIC_CONSTRAINTS = ObjectIdentifier("2.5.29.19")
+    NAME_CONSTRAINTS = ObjectIdentifier("2.5.29.30")
+    CRL_DISTRIBUTION_POINTS = ObjectIdentifier("2.5.29.31")
+    CERTIFICATE_POLICIES = ObjectIdentifier("2.5.29.32")
+    POLICY_MAPPINGS = ObjectIdentifier("2.5.29.33")
+    AUTHORITY_KEY_IDENTIFIER = ObjectIdentifier("2.5.29.35")
+    POLICY_CONSTRAINTS = ObjectIdentifier("2.5.29.36")
+    EXTENDED_KEY_USAGE = ObjectIdentifier("2.5.29.37")
+    FRESHEST_CRL = ObjectIdentifier("2.5.29.46")
+    INHIBIT_ANY_POLICY = ObjectIdentifier("2.5.29.54")
+    ISSUING_DISTRIBUTION_POINT = ObjectIdentifier("2.5.29.28")
+    AUTHORITY_INFORMATION_ACCESS = ObjectIdentifier("1.3.6.1.5.5.7.1.1")
+    SUBJECT_INFORMATION_ACCESS = ObjectIdentifier("1.3.6.1.5.5.7.1.11")
+    OCSP_NO_CHECK = ObjectIdentifier("1.3.6.1.5.5.7.48.1.5")
+    TLS_FEATURE = ObjectIdentifier("1.3.6.1.5.5.7.1.24")
+    CRL_NUMBER = ObjectIdentifier("2.5.29.20")
+    DELTA_CRL_INDICATOR = ObjectIdentifier("2.5.29.27")
+    PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS = ObjectIdentifier(
+        "1.3.6.1.4.1.11129.2.4.2"
+    )
+    PRECERT_POISON = ObjectIdentifier("1.3.6.1.4.1.11129.2.4.3")
+    SIGNED_CERTIFICATE_TIMESTAMPS = ObjectIdentifier("1.3.6.1.4.1.11129.2.4.5")
+
+
+class OCSPExtensionOID:
+    NONCE = ObjectIdentifier("1.3.6.1.5.5.7.48.1.2")
+
+
+class CRLEntryExtensionOID:
+    CERTIFICATE_ISSUER = ObjectIdentifier("2.5.29.29")
+    CRL_REASON = ObjectIdentifier("2.5.29.21")
+    INVALIDITY_DATE = ObjectIdentifier("2.5.29.24")
+
+
+class NameOID:
+    COMMON_NAME = ObjectIdentifier("2.5.4.3")
+    COUNTRY_NAME = ObjectIdentifier("2.5.4.6")
+    LOCALITY_NAME = ObjectIdentifier("2.5.4.7")
+    STATE_OR_PROVINCE_NAME = ObjectIdentifier("2.5.4.8")
+    STREET_ADDRESS = ObjectIdentifier("2.5.4.9")
+    ORGANIZATION_NAME = ObjectIdentifier("2.5.4.10")
+    ORGANIZATIONAL_UNIT_NAME = ObjectIdentifier("2.5.4.11")
+    SERIAL_NUMBER = ObjectIdentifier("2.5.4.5")
+    SURNAME = ObjectIdentifier("2.5.4.4")
+    GIVEN_NAME = ObjectIdentifier("2.5.4.42")
+    TITLE = ObjectIdentifier("2.5.4.12")
+    GENERATION_QUALIFIER = ObjectIdentifier("2.5.4.44")
+    X500_UNIQUE_IDENTIFIER = ObjectIdentifier("2.5.4.45")
+    DN_QUALIFIER = ObjectIdentifier("2.5.4.46")
+    PSEUDONYM = ObjectIdentifier("2.5.4.65")
+    USER_ID = ObjectIdentifier("0.9.2342.19200300.100.1.1")
+    DOMAIN_COMPONENT = ObjectIdentifier("0.9.2342.19200300.100.1.25")
+    EMAIL_ADDRESS = ObjectIdentifier("1.2.840.113549.1.9.1")
+    JURISDICTION_COUNTRY_NAME = ObjectIdentifier("1.3.6.1.4.1.311.60.2.1.3")
+    JURISDICTION_LOCALITY_NAME = ObjectIdentifier("1.3.6.1.4.1.311.60.2.1.1")
+    JURISDICTION_STATE_OR_PROVINCE_NAME = ObjectIdentifier(
+        "1.3.6.1.4.1.311.60.2.1.2"
+    )
+    BUSINESS_CATEGORY = ObjectIdentifier("2.5.4.15")
+    POSTAL_ADDRESS = ObjectIdentifier("2.5.4.16")
+    POSTAL_CODE = ObjectIdentifier("2.5.4.17")
+    INN = ObjectIdentifier("1.2.643.3.131.1.1")
+    OGRN = ObjectIdentifier("1.2.643.100.1")
+    SNILS = ObjectIdentifier("1.2.643.100.3")
+    UNSTRUCTURED_NAME = ObjectIdentifier("1.2.840.113549.1.9.2")
+
+
+class SignatureAlgorithmOID:
+    RSA_WITH_MD5 = ObjectIdentifier("1.2.840.113549.1.1.4")
+    RSA_WITH_SHA1 = ObjectIdentifier("1.2.840.113549.1.1.5")
+    # This is an alternate OID for RSA with SHA1 that is occasionally seen
+    _RSA_WITH_SHA1 = ObjectIdentifier("1.3.14.3.2.29")
+    RSA_WITH_SHA224 = ObjectIdentifier("1.2.840.113549.1.1.14")
+    RSA_WITH_SHA256 = ObjectIdentifier("1.2.840.113549.1.1.11")
+    RSA_WITH_SHA384 = ObjectIdentifier("1.2.840.113549.1.1.12")
+    RSA_WITH_SHA512 = ObjectIdentifier("1.2.840.113549.1.1.13")
+    RSA_WITH_SHA3_224 = ObjectIdentifier("2.16.840.1.101.3.4.3.13")
+    RSA_WITH_SHA3_256 = ObjectIdentifier("2.16.840.1.101.3.4.3.14")
+    RSA_WITH_SHA3_384 = ObjectIdentifier("2.16.840.1.101.3.4.3.15")
+    RSA_WITH_SHA3_512 = ObjectIdentifier("2.16.840.1.101.3.4.3.16")
+    RSASSA_PSS = ObjectIdentifier("1.2.840.113549.1.1.10")
+    ECDSA_WITH_SHA1 = ObjectIdentifier("1.2.840.10045.4.1")
+    ECDSA_WITH_SHA224 = ObjectIdentifier("1.2.840.10045.4.3.1")
+    ECDSA_WITH_SHA256 = ObjectIdentifier("1.2.840.10045.4.3.2")
+    ECDSA_WITH_SHA384 = ObjectIdentifier("1.2.840.10045.4.3.3")
+    ECDSA_WITH_SHA512 = ObjectIdentifier("1.2.840.10045.4.3.4")
+    ECDSA_WITH_SHA3_224 = ObjectIdentifier("2.16.840.1.101.3.4.3.9")
+    ECDSA_WITH_SHA3_256 = ObjectIdentifier("2.16.840.1.101.3.4.3.10")
+    ECDSA_WITH_SHA3_384 = ObjectIdentifier("2.16.840.1.101.3.4.3.11")
+    ECDSA_WITH_SHA3_512 = ObjectIdentifier("2.16.840.1.101.3.4.3.12")
+    DSA_WITH_SHA1 = ObjectIdentifier("1.2.840.10040.4.3")
+    DSA_WITH_SHA224 = ObjectIdentifier("2.16.840.1.101.3.4.3.1")
+    DSA_WITH_SHA256 = ObjectIdentifier("2.16.840.1.101.3.4.3.2")
+    DSA_WITH_SHA384 = ObjectIdentifier("2.16.840.1.101.3.4.3.3")
+    DSA_WITH_SHA512 = ObjectIdentifier("2.16.840.1.101.3.4.3.4")
+    ED25519 = ObjectIdentifier("1.3.101.112")
+    ED448 = ObjectIdentifier("1.3.101.113")
+    GOSTR3411_94_WITH_3410_2001 = ObjectIdentifier("1.2.643.2.2.3")
+    GOSTR3410_2012_WITH_3411_2012_256 = ObjectIdentifier("1.2.643.7.1.1.3.2")
+    GOSTR3410_2012_WITH_3411_2012_512 = ObjectIdentifier("1.2.643.7.1.1.3.3")
+
+
+_SIG_OIDS_TO_HASH: typing.Dict[
+    ObjectIdentifier, typing.Optional[hashes.HashAlgorithm]
+] = {
+    SignatureAlgorithmOID.RSA_WITH_MD5: hashes.MD5(),
+    SignatureAlgorithmOID.RSA_WITH_SHA1: hashes.SHA1(),
+    SignatureAlgorithmOID._RSA_WITH_SHA1: hashes.SHA1(),
+    SignatureAlgorithmOID.RSA_WITH_SHA224: hashes.SHA224(),
+    SignatureAlgorithmOID.RSA_WITH_SHA256: hashes.SHA256(),
+    SignatureAlgorithmOID.RSA_WITH_SHA384: hashes.SHA384(),
+    SignatureAlgorithmOID.RSA_WITH_SHA512: hashes.SHA512(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA1: hashes.SHA1(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA224: hashes.SHA224(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA256: hashes.SHA256(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA384: hashes.SHA384(),
+    SignatureAlgorithmOID.ECDSA_WITH_SHA512: hashes.SHA512(),
+    SignatureAlgorithmOID.DSA_WITH_SHA1: hashes.SHA1(),
+    SignatureAlgorithmOID.DSA_WITH_SHA224: hashes.SHA224(),
+    SignatureAlgorithmOID.DSA_WITH_SHA256: hashes.SHA256(),
+    SignatureAlgorithmOID.ED25519: None,
+    SignatureAlgorithmOID.ED448: None,
+    SignatureAlgorithmOID.GOSTR3411_94_WITH_3410_2001: None,
+    SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_256: None,
+    SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_512: None,
+}
+
+
+class ExtendedKeyUsageOID:
+    SERVER_AUTH = ObjectIdentifier("1.3.6.1.5.5.7.3.1")
+    CLIENT_AUTH = ObjectIdentifier("1.3.6.1.5.5.7.3.2")
+    CODE_SIGNING = ObjectIdentifier("1.3.6.1.5.5.7.3.3")
+    EMAIL_PROTECTION = ObjectIdentifier("1.3.6.1.5.5.7.3.4")
+    TIME_STAMPING = ObjectIdentifier("1.3.6.1.5.5.7.3.8")
+    OCSP_SIGNING = ObjectIdentifier("1.3.6.1.5.5.7.3.9")
+    ANY_EXTENDED_KEY_USAGE = ObjectIdentifier("2.5.29.37.0")
+    SMARTCARD_LOGON = ObjectIdentifier("1.3.6.1.4.1.311.20.2.2")
+    KERBEROS_PKINIT_KDC = ObjectIdentifier("1.3.6.1.5.2.3.5")
+    IPSEC_IKE = ObjectIdentifier("1.3.6.1.5.5.7.3.17")
+
+
+class AuthorityInformationAccessOID:
+    CA_ISSUERS = ObjectIdentifier("1.3.6.1.5.5.7.48.2")
+    OCSP = ObjectIdentifier("1.3.6.1.5.5.7.48.1")
+
+
+class SubjectInformationAccessOID:
+    CA_REPOSITORY = ObjectIdentifier("1.3.6.1.5.5.7.48.5")
+
+
+class CertificatePoliciesOID:
+    CPS_QUALIFIER = ObjectIdentifier("1.3.6.1.5.5.7.2.1")
+    CPS_USER_NOTICE = ObjectIdentifier("1.3.6.1.5.5.7.2.2")
+    ANY_POLICY = ObjectIdentifier("2.5.29.32.0")
+
+
+class AttributeOID:
+    CHALLENGE_PASSWORD = ObjectIdentifier("1.2.840.113549.1.9.7")
+    UNSTRUCTURED_NAME = ObjectIdentifier("1.2.840.113549.1.9.2")
+
+
+_OID_NAMES = {
+    NameOID.COMMON_NAME: "commonName",
+    NameOID.COUNTRY_NAME: "countryName",
+    NameOID.LOCALITY_NAME: "localityName",
+    NameOID.STATE_OR_PROVINCE_NAME: "stateOrProvinceName",
+    NameOID.STREET_ADDRESS: "streetAddress",
+    NameOID.ORGANIZATION_NAME: "organizationName",
+    NameOID.ORGANIZATIONAL_UNIT_NAME: "organizationalUnitName",
+    NameOID.SERIAL_NUMBER: "serialNumber",
+    NameOID.SURNAME: "surname",
+    NameOID.GIVEN_NAME: "givenName",
+    NameOID.TITLE: "title",
+    NameOID.GENERATION_QUALIFIER: "generationQualifier",
+    NameOID.X500_UNIQUE_IDENTIFIER: "x500UniqueIdentifier",
+    NameOID.DN_QUALIFIER: "dnQualifier",
+    NameOID.PSEUDONYM: "pseudonym",
+    NameOID.USER_ID: "userID",
+    NameOID.DOMAIN_COMPONENT: "domainComponent",
+    NameOID.EMAIL_ADDRESS: "emailAddress",
+    NameOID.JURISDICTION_COUNTRY_NAME: "jurisdictionCountryName",
+    NameOID.JURISDICTION_LOCALITY_NAME: "jurisdictionLocalityName",
+    NameOID.JURISDICTION_STATE_OR_PROVINCE_NAME: (
+        "jurisdictionStateOrProvinceName"
+    ),
+    NameOID.BUSINESS_CATEGORY: "businessCategory",
+    NameOID.POSTAL_ADDRESS: "postalAddress",
+    NameOID.POSTAL_CODE: "postalCode",
+    NameOID.INN: "INN",
+    NameOID.OGRN: "OGRN",
+    NameOID.SNILS: "SNILS",
+    NameOID.UNSTRUCTURED_NAME: "unstructuredName",
+    SignatureAlgorithmOID.RSA_WITH_MD5: "md5WithRSAEncryption",
+    SignatureAlgorithmOID.RSA_WITH_SHA1: "sha1WithRSAEncryption",
+    SignatureAlgorithmOID.RSA_WITH_SHA224: "sha224WithRSAEncryption",
+    SignatureAlgorithmOID.RSA_WITH_SHA256: "sha256WithRSAEncryption",
+    SignatureAlgorithmOID.RSA_WITH_SHA384: "sha384WithRSAEncryption",
+    SignatureAlgorithmOID.RSA_WITH_SHA512: "sha512WithRSAEncryption",
+    SignatureAlgorithmOID.RSASSA_PSS: "RSASSA-PSS",
+    SignatureAlgorithmOID.ECDSA_WITH_SHA1: "ecdsa-with-SHA1",
+    SignatureAlgorithmOID.ECDSA_WITH_SHA224: "ecdsa-with-SHA224",
+    SignatureAlgorithmOID.ECDSA_WITH_SHA256: "ecdsa-with-SHA256",
+    SignatureAlgorithmOID.ECDSA_WITH_SHA384: "ecdsa-with-SHA384",
+    SignatureAlgorithmOID.ECDSA_WITH_SHA512: "ecdsa-with-SHA512",
+    SignatureAlgorithmOID.DSA_WITH_SHA1: "dsa-with-sha1",
+    SignatureAlgorithmOID.DSA_WITH_SHA224: "dsa-with-sha224",
+    SignatureAlgorithmOID.DSA_WITH_SHA256: "dsa-with-sha256",
+    SignatureAlgorithmOID.ED25519: "ed25519",
+    SignatureAlgorithmOID.ED448: "ed448",
+    SignatureAlgorithmOID.GOSTR3411_94_WITH_3410_2001: (
+        "GOST R 34.11-94 with GOST R 34.10-2001"
+    ),
+    SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_256: (
+        "GOST R 34.10-2012 with GOST R 34.11-2012 (256 bit)"
+    ),
+    SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_512: (
+        "GOST R 34.10-2012 with GOST R 34.11-2012 (512 bit)"
+    ),
+    ExtendedKeyUsageOID.SERVER_AUTH: "serverAuth",
+    ExtendedKeyUsageOID.CLIENT_AUTH: "clientAuth",
+    ExtendedKeyUsageOID.CODE_SIGNING: "codeSigning",
+    ExtendedKeyUsageOID.EMAIL_PROTECTION: "emailProtection",
+    ExtendedKeyUsageOID.TIME_STAMPING: "timeStamping",
+    ExtendedKeyUsageOID.OCSP_SIGNING: "OCSPSigning",
+    ExtendedKeyUsageOID.SMARTCARD_LOGON: "msSmartcardLogin",
+    ExtendedKeyUsageOID.KERBEROS_PKINIT_KDC: "pkInitKDC",
+    ExtensionOID.SUBJECT_DIRECTORY_ATTRIBUTES: "subjectDirectoryAttributes",
+    ExtensionOID.SUBJECT_KEY_IDENTIFIER: "subjectKeyIdentifier",
+    ExtensionOID.KEY_USAGE: "keyUsage",
+    ExtensionOID.SUBJECT_ALTERNATIVE_NAME: "subjectAltName",
+    ExtensionOID.ISSUER_ALTERNATIVE_NAME: "issuerAltName",
+    ExtensionOID.BASIC_CONSTRAINTS: "basicConstraints",
+    ExtensionOID.PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS: (
+        "signedCertificateTimestampList"
+    ),
+    ExtensionOID.SIGNED_CERTIFICATE_TIMESTAMPS: (
+        "signedCertificateTimestampList"
+    ),
+    ExtensionOID.PRECERT_POISON: "ctPoison",
+    CRLEntryExtensionOID.CRL_REASON: "cRLReason",
+    CRLEntryExtensionOID.INVALIDITY_DATE: "invalidityDate",
+    CRLEntryExtensionOID.CERTIFICATE_ISSUER: "certificateIssuer",
+    ExtensionOID.NAME_CONSTRAINTS: "nameConstraints",
+    ExtensionOID.CRL_DISTRIBUTION_POINTS: "cRLDistributionPoints",
+    ExtensionOID.CERTIFICATE_POLICIES: "certificatePolicies",
+    ExtensionOID.POLICY_MAPPINGS: "policyMappings",
+    ExtensionOID.AUTHORITY_KEY_IDENTIFIER: "authorityKeyIdentifier",
+    ExtensionOID.POLICY_CONSTRAINTS: "policyConstraints",
+    ExtensionOID.EXTENDED_KEY_USAGE: "extendedKeyUsage",
+    ExtensionOID.FRESHEST_CRL: "freshestCRL",
+    ExtensionOID.INHIBIT_ANY_POLICY: "inhibitAnyPolicy",
+    ExtensionOID.ISSUING_DISTRIBUTION_POINT: ("issuingDistributionPoint"),
+    ExtensionOID.AUTHORITY_INFORMATION_ACCESS: "authorityInfoAccess",
+    ExtensionOID.SUBJECT_INFORMATION_ACCESS: "subjectInfoAccess",
+    ExtensionOID.OCSP_NO_CHECK: "OCSPNoCheck",
+    ExtensionOID.CRL_NUMBER: "cRLNumber",
+    ExtensionOID.DELTA_CRL_INDICATOR: "deltaCRLIndicator",
+    ExtensionOID.TLS_FEATURE: "TLSFeature",
+    AuthorityInformationAccessOID.OCSP: "OCSP",
+    AuthorityInformationAccessOID.CA_ISSUERS: "caIssuers",
+    SubjectInformationAccessOID.CA_REPOSITORY: "caRepository",
+    CertificatePoliciesOID.CPS_QUALIFIER: "id-qt-cps",
+    CertificatePoliciesOID.CPS_USER_NOTICE: "id-qt-unotice",
+    OCSPExtensionOID.NONCE: "OCSPNonce",
+    AttributeOID.CHALLENGE_PASSWORD: "challengePassword",
+}
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/__init__.py
new file mode 100644
index 0000000..3926f85
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/__init__.py
@@ -0,0 +1,10 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from typing import Any
+
+
+def default_backend() -> Any:
+    from cryptography.hazmat.backends.openssl.backend import backend
+
+    return backend
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/__init__.py
new file mode 100644
index 0000000..31fd17c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/__init__.py
@@ -0,0 +1,9 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+from cryptography.hazmat.backends.openssl.backend import backend
+
+
+__all__ = ["backend"]
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/aead.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/aead.py
new file mode 100644
index 0000000..f7914af
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/aead.py
@@ -0,0 +1,251 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.exceptions import InvalidTag
+
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+    from cryptography.hazmat.primitives.ciphers.aead import (
+        AESCCM,
+        AESGCM,
+        AESOCB3,
+        AESSIV,
+        ChaCha20Poly1305,
+    )
+
+    _AEAD_TYPES = typing.Union[
+        AESCCM, AESGCM, AESOCB3, AESSIV, ChaCha20Poly1305
+    ]
+
+_ENCRYPT = 1
+_DECRYPT = 0
+
+
+def _aead_cipher_name(cipher: "_AEAD_TYPES") -> bytes:
+    from cryptography.hazmat.primitives.ciphers.aead import (
+        AESCCM,
+        AESGCM,
+        AESOCB3,
+        AESSIV,
+        ChaCha20Poly1305,
+    )
+
+    if isinstance(cipher, ChaCha20Poly1305):
+        return b"chacha20-poly1305"
+    elif isinstance(cipher, AESCCM):
+        return f"aes-{len(cipher._key) * 8}-ccm".encode("ascii")
+    elif isinstance(cipher, AESOCB3):
+        return f"aes-{len(cipher._key) * 8}-ocb".encode("ascii")
+    elif isinstance(cipher, AESSIV):
+        return f"aes-{len(cipher._key) * 8 // 2}-siv".encode("ascii")
+    else:
+        assert isinstance(cipher, AESGCM)
+        return f"aes-{len(cipher._key) * 8}-gcm".encode("ascii")
+
+
+def _evp_cipher(cipher_name: bytes, backend: "Backend"):
+    if cipher_name.endswith(b"-siv"):
+        evp_cipher = backend._lib.EVP_CIPHER_fetch(
+            backend._ffi.NULL,
+            cipher_name,
+            backend._ffi.NULL,
+        )
+        backend.openssl_assert(evp_cipher != backend._ffi.NULL)
+        evp_cipher = backend._ffi.gc(evp_cipher, backend._lib.EVP_CIPHER_free)
+    else:
+        evp_cipher = backend._lib.EVP_get_cipherbyname(cipher_name)
+        backend.openssl_assert(evp_cipher != backend._ffi.NULL)
+
+    return evp_cipher
+
+
+def _aead_setup(
+    backend: "Backend",
+    cipher_name: bytes,
+    key: bytes,
+    nonce: bytes,
+    tag: typing.Optional[bytes],
+    tag_len: int,
+    operation: int,
+):
+    evp_cipher = _evp_cipher(cipher_name, backend)
+    ctx = backend._lib.EVP_CIPHER_CTX_new()
+    ctx = backend._ffi.gc(ctx, backend._lib.EVP_CIPHER_CTX_free)
+    res = backend._lib.EVP_CipherInit_ex(
+        ctx,
+        evp_cipher,
+        backend._ffi.NULL,
+        backend._ffi.NULL,
+        backend._ffi.NULL,
+        int(operation == _ENCRYPT),
+    )
+    backend.openssl_assert(res != 0)
+    res = backend._lib.EVP_CIPHER_CTX_set_key_length(ctx, len(key))
+    backend.openssl_assert(res != 0)
+    res = backend._lib.EVP_CIPHER_CTX_ctrl(
+        ctx,
+        backend._lib.EVP_CTRL_AEAD_SET_IVLEN,
+        len(nonce),
+        backend._ffi.NULL,
+    )
+    backend.openssl_assert(res != 0)
+    if operation == _DECRYPT:
+        assert tag is not None
+        res = backend._lib.EVP_CIPHER_CTX_ctrl(
+            ctx, backend._lib.EVP_CTRL_AEAD_SET_TAG, len(tag), tag
+        )
+        backend.openssl_assert(res != 0)
+    elif cipher_name.endswith(b"-ccm"):
+        res = backend._lib.EVP_CIPHER_CTX_ctrl(
+            ctx, backend._lib.EVP_CTRL_AEAD_SET_TAG, tag_len, backend._ffi.NULL
+        )
+        backend.openssl_assert(res != 0)
+
+    nonce_ptr = backend._ffi.from_buffer(nonce)
+    key_ptr = backend._ffi.from_buffer(key)
+    res = backend._lib.EVP_CipherInit_ex(
+        ctx,
+        backend._ffi.NULL,
+        backend._ffi.NULL,
+        key_ptr,
+        nonce_ptr,
+        int(operation == _ENCRYPT),
+    )
+    backend.openssl_assert(res != 0)
+    return ctx
+
+
+def _set_length(backend: "Backend", ctx, data_len: int) -> None:
+    intptr = backend._ffi.new("int *")
+    res = backend._lib.EVP_CipherUpdate(
+        ctx, backend._ffi.NULL, intptr, backend._ffi.NULL, data_len
+    )
+    backend.openssl_assert(res != 0)
+
+
+def _process_aad(backend: "Backend", ctx, associated_data: bytes) -> None:
+    outlen = backend._ffi.new("int *")
+    res = backend._lib.EVP_CipherUpdate(
+        ctx, backend._ffi.NULL, outlen, associated_data, len(associated_data)
+    )
+    backend.openssl_assert(res != 0)
+
+
+def _process_data(backend: "Backend", ctx, data: bytes) -> bytes:
+    outlen = backend._ffi.new("int *")
+    buf = backend._ffi.new("unsigned char[]", len(data))
+    res = backend._lib.EVP_CipherUpdate(ctx, buf, outlen, data, len(data))
+    if res == 0:
+        # AES SIV can error here if the data is invalid on decrypt
+        backend._consume_errors()
+        raise InvalidTag
+    return backend._ffi.buffer(buf, outlen[0])[:]
+
+
+def _encrypt(
+    backend: "Backend",
+    cipher: "_AEAD_TYPES",
+    nonce: bytes,
+    data: bytes,
+    associated_data: typing.List[bytes],
+    tag_length: int,
+) -> bytes:
+    from cryptography.hazmat.primitives.ciphers.aead import AESCCM, AESSIV
+
+    cipher_name = _aead_cipher_name(cipher)
+    ctx = _aead_setup(
+        backend, cipher_name, cipher._key, nonce, None, tag_length, _ENCRYPT
+    )
+    # CCM requires us to pass the length of the data before processing anything
+    # However calling this with any other AEAD results in an error
+    if isinstance(cipher, AESCCM):
+        _set_length(backend, ctx, len(data))
+
+    for ad in associated_data:
+        _process_aad(backend, ctx, ad)
+    processed_data = _process_data(backend, ctx, data)
+    outlen = backend._ffi.new("int *")
+    # All AEADs we support besides OCB are streaming so they return nothing
+    # in finalization. OCB can return up to (16 byte block - 1) bytes so
+    # we need a buffer here too.
+    buf = backend._ffi.new("unsigned char[]", 16)
+    res = backend._lib.EVP_CipherFinal_ex(ctx, buf, outlen)
+    backend.openssl_assert(res != 0)
+    processed_data += backend._ffi.buffer(buf, outlen[0])[:]
+    tag_buf = backend._ffi.new("unsigned char[]", tag_length)
+    res = backend._lib.EVP_CIPHER_CTX_ctrl(
+        ctx, backend._lib.EVP_CTRL_AEAD_GET_TAG, tag_length, tag_buf
+    )
+    backend.openssl_assert(res != 0)
+    tag = backend._ffi.buffer(tag_buf)[:]
+
+    if isinstance(cipher, AESSIV):
+        # RFC 5297 defines the output as IV || C, where the tag we generate is
+        # the "IV" and C is the ciphertext. This is the opposite of our
+        # other AEADs, which are Ciphertext || Tag
+        backend.openssl_assert(len(tag) == 16)
+        return tag + processed_data
+    else:
+        return processed_data + tag
+
+
+def _decrypt(
+    backend: "Backend",
+    cipher: "_AEAD_TYPES",
+    nonce: bytes,
+    data: bytes,
+    associated_data: typing.List[bytes],
+    tag_length: int,
+) -> bytes:
+    from cryptography.hazmat.primitives.ciphers.aead import AESCCM, AESSIV
+
+    if len(data) < tag_length:
+        raise InvalidTag
+
+    if isinstance(cipher, AESSIV):
+        # RFC 5297 defines the output as IV || C, where the tag we generate is
+        # the "IV" and C is the ciphertext. This is the opposite of our
+        # other AEADs, which are Ciphertext || Tag
+        tag = data[:tag_length]
+        data = data[tag_length:]
+    else:
+        tag = data[-tag_length:]
+        data = data[:-tag_length]
+    cipher_name = _aead_cipher_name(cipher)
+    ctx = _aead_setup(
+        backend, cipher_name, cipher._key, nonce, tag, tag_length, _DECRYPT
+    )
+    # CCM requires us to pass the length of the data before processing anything
+    # However calling this with any other AEAD results in an error
+    if isinstance(cipher, AESCCM):
+        _set_length(backend, ctx, len(data))
+
+    for ad in associated_data:
+        _process_aad(backend, ctx, ad)
+    # CCM has a different error path if the tag doesn't match. Errors are
+    # raised in Update and Final is irrelevant.
+    if isinstance(cipher, AESCCM):
+        outlen = backend._ffi.new("int *")
+        buf = backend._ffi.new("unsigned char[]", len(data))
+        res = backend._lib.EVP_CipherUpdate(ctx, buf, outlen, data, len(data))
+        if res != 1:
+            backend._consume_errors()
+            raise InvalidTag
+
+        processed_data = backend._ffi.buffer(buf, outlen[0])[:]
+    else:
+        processed_data = _process_data(backend, ctx, data)
+        outlen = backend._ffi.new("int *")
+        # OCB can return up to 15 bytes (16 byte block - 1) in finalization
+        buf = backend._ffi.new("unsigned char[]", 16)
+        res = backend._lib.EVP_CipherFinal_ex(ctx, buf, outlen)
+        processed_data += backend._ffi.buffer(buf, outlen[0])[:]
+        if res == 0:
+            backend._consume_errors()
+            raise InvalidTag
+
+    return processed_data
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/backend.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/backend.py
new file mode 100644
index 0000000..42fb446
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/backend.py
@@ -0,0 +1,2537 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import collections
+import contextlib
+import itertools
+import typing
+import warnings
+from contextlib import contextmanager
+
+from cryptography import utils, x509
+from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
+from cryptography.hazmat.backends.openssl import aead
+from cryptography.hazmat.backends.openssl.ciphers import _CipherContext
+from cryptography.hazmat.backends.openssl.cmac import _CMACContext
+from cryptography.hazmat.backends.openssl.dh import (
+    _DHParameters,
+    _DHPrivateKey,
+    _DHPublicKey,
+    _dh_params_dup,
+)
+from cryptography.hazmat.backends.openssl.dsa import (
+    _DSAParameters,
+    _DSAPrivateKey,
+    _DSAPublicKey,
+)
+from cryptography.hazmat.backends.openssl.ec import (
+    _EllipticCurvePrivateKey,
+    _EllipticCurvePublicKey,
+)
+from cryptography.hazmat.backends.openssl.ed25519 import (
+    _Ed25519PrivateKey,
+    _Ed25519PublicKey,
+)
+from cryptography.hazmat.backends.openssl.ed448 import (
+    _ED448_KEY_SIZE,
+    _Ed448PrivateKey,
+    _Ed448PublicKey,
+)
+from cryptography.hazmat.backends.openssl.hashes import _HashContext
+from cryptography.hazmat.backends.openssl.hmac import _HMACContext
+from cryptography.hazmat.backends.openssl.poly1305 import (
+    _POLY1305_KEY_SIZE,
+    _Poly1305Context,
+)
+from cryptography.hazmat.backends.openssl.rsa import (
+    _RSAPrivateKey,
+    _RSAPublicKey,
+)
+from cryptography.hazmat.backends.openssl.x25519 import (
+    _X25519PrivateKey,
+    _X25519PublicKey,
+)
+from cryptography.hazmat.backends.openssl.x448 import (
+    _X448PrivateKey,
+    _X448PublicKey,
+)
+from cryptography.hazmat.bindings._rust import (
+    x509 as rust_x509,
+)
+from cryptography.hazmat.bindings.openssl import binding
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives._asymmetric import AsymmetricPadding
+from cryptography.hazmat.primitives.asymmetric import (
+    dh,
+    dsa,
+    ec,
+    ed25519,
+    ed448,
+    rsa,
+    x25519,
+    x448,
+)
+from cryptography.hazmat.primitives.asymmetric.padding import (
+    MGF1,
+    OAEP,
+    PKCS1v15,
+    PSS,
+)
+from cryptography.hazmat.primitives.asymmetric.types import (
+    CERTIFICATE_ISSUER_PUBLIC_KEY_TYPES,
+    PRIVATE_KEY_TYPES,
+    PUBLIC_KEY_TYPES,
+)
+from cryptography.hazmat.primitives.ciphers import (
+    BlockCipherAlgorithm,
+    CipherAlgorithm,
+)
+from cryptography.hazmat.primitives.ciphers.algorithms import (
+    AES,
+    ARC4,
+    Camellia,
+    ChaCha20,
+    SM4,
+    TripleDES,
+    _BlowfishInternal,
+    _CAST5Internal,
+    _IDEAInternal,
+    _SEEDInternal,
+)
+from cryptography.hazmat.primitives.ciphers.modes import (
+    CBC,
+    CFB,
+    CFB8,
+    CTR,
+    ECB,
+    GCM,
+    Mode,
+    OFB,
+    XTS,
+)
+from cryptography.hazmat.primitives.kdf import scrypt
+from cryptography.hazmat.primitives.serialization import pkcs7, ssh
+from cryptography.hazmat.primitives.serialization.pkcs12 import (
+    PKCS12Certificate,
+    PKCS12KeyAndCertificates,
+    _ALLOWED_PKCS12_TYPES,
+    _PKCS12_CAS_TYPES,
+)
+
+
+_MemoryBIO = collections.namedtuple("_MemoryBIO", ["bio", "char_ptr"])
+
+
+# Not actually supported, just used as a marker for some serialization tests.
+class _RC2:
+    pass
+
+
+class Backend:
+    """
+    OpenSSL API binding interfaces.
+    """
+
+    name = "openssl"
+
+    # FIPS has opinions about acceptable algorithms and key sizes, but the
+    # disallowed algorithms are still present in OpenSSL. They just error if
+    # you try to use them. To avoid that we allowlist the algorithms in
+    # FIPS 140-3. This isn't ideal, but FIPS 140-3 is trash so here we are.
+    _fips_aead = {
+        b"aes-128-ccm",
+        b"aes-192-ccm",
+        b"aes-256-ccm",
+        b"aes-128-gcm",
+        b"aes-192-gcm",
+        b"aes-256-gcm",
+    }
+    # TripleDES encryption is disallowed/deprecated throughout 2023 in
+    # FIPS 140-3. To keep it simple we denylist any use of TripleDES (TDEA).
+    _fips_ciphers = (AES,)
+    # Sometimes SHA1 is still permissible. That logic is contained
+    # within the various *_supported methods.
+    _fips_hashes = (
+        hashes.SHA224,
+        hashes.SHA256,
+        hashes.SHA384,
+        hashes.SHA512,
+        hashes.SHA512_224,
+        hashes.SHA512_256,
+        hashes.SHA3_224,
+        hashes.SHA3_256,
+        hashes.SHA3_384,
+        hashes.SHA3_512,
+        hashes.SHAKE128,
+        hashes.SHAKE256,
+    )
+    _fips_ecdh_curves = (
+        ec.SECP224R1,
+        ec.SECP256R1,
+        ec.SECP384R1,
+        ec.SECP521R1,
+    )
+    _fips_rsa_min_key_size = 2048
+    _fips_rsa_min_public_exponent = 65537
+    _fips_dsa_min_modulus = 1 << 2048
+    _fips_dh_min_key_size = 2048
+    _fips_dh_min_modulus = 1 << _fips_dh_min_key_size
+
+    def __init__(self):
+        self._binding = binding.Binding()
+        self._ffi = self._binding.ffi
+        self._lib = self._binding.lib
+        self._rsa_skip_check_key = False
+        self._fips_enabled = self._is_fips_enabled()
+
+        self._cipher_registry = {}
+        self._register_default_ciphers()
+        if self._fips_enabled and self._lib.CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE:
+            warnings.warn(
+                "OpenSSL FIPS mode is enabled. Can't enable DRBG fork safety.",
+                UserWarning,
+            )
+        else:
+            self.activate_osrandom_engine()
+        self._dh_types = [self._lib.EVP_PKEY_DH]
+        if self._lib.Cryptography_HAS_EVP_PKEY_DHX:
+            self._dh_types.append(self._lib.EVP_PKEY_DHX)
+
+    def __repr__(self) -> str:
+        return "<OpenSSLBackend(version: {}, FIPS: {})>".format(
+            self.openssl_version_text(), self._fips_enabled
+        )
+
+    def openssl_assert(
+        self,
+        ok: bool,
+        errors: typing.Optional[typing.List[binding._OpenSSLError]] = None,
+    ) -> None:
+        return binding._openssl_assert(self._lib, ok, errors=errors)
+
+    def _is_fips_enabled(self) -> bool:
+        if self._lib.Cryptography_HAS_300_FIPS:
+            mode = self._lib.EVP_default_properties_is_fips_enabled(
+                self._ffi.NULL
+            )
+        else:
+            mode = getattr(self._lib, "FIPS_mode", lambda: 0)()
+
+        if mode == 0:
+            # OpenSSL without FIPS pushes an error on the error stack
+            self._lib.ERR_clear_error()
+        return bool(mode)
+
+    def _enable_fips(self) -> None:
+        # This function enables FIPS mode for OpenSSL 3.0.0 on installs that
+        # have the FIPS provider installed properly.
+        self._binding._enable_fips()
+        assert self._is_fips_enabled()
+        self._fips_enabled = self._is_fips_enabled()
+
+    def activate_builtin_random(self) -> None:
+        if self._lib.CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE:
+            # Obtain a new structural reference.
+            e = self._lib.ENGINE_get_default_RAND()
+            if e != self._ffi.NULL:
+                self._lib.ENGINE_unregister_RAND(e)
+                # Reset the RNG to use the built-in.
+                res = self._lib.RAND_set_rand_method(self._ffi.NULL)
+                self.openssl_assert(res == 1)
+                # decrement the structural reference from get_default_RAND
+                res = self._lib.ENGINE_finish(e)
+                self.openssl_assert(res == 1)
+
+    @contextlib.contextmanager
+    def _get_osurandom_engine(self):
+        # Fetches an engine by id and returns it. This creates a structural
+        # reference.
+        e = self._lib.ENGINE_by_id(self._lib.Cryptography_osrandom_engine_id)
+        self.openssl_assert(e != self._ffi.NULL)
+        # Initialize the engine for use. This adds a functional reference.
+        res = self._lib.ENGINE_init(e)
+        self.openssl_assert(res == 1)
+
+        try:
+            yield e
+        finally:
+            # Decrement the structural ref incremented by ENGINE_by_id.
+            res = self._lib.ENGINE_free(e)
+            self.openssl_assert(res == 1)
+            # Decrement the functional ref incremented by ENGINE_init.
+            res = self._lib.ENGINE_finish(e)
+            self.openssl_assert(res == 1)
+
+    def activate_osrandom_engine(self) -> None:
+        if self._lib.CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE:
+            # Unregister and free the current engine.
+            self.activate_builtin_random()
+            with self._get_osurandom_engine() as e:
+                # Set the engine as the default RAND provider.
+                res = self._lib.ENGINE_set_default_RAND(e)
+                self.openssl_assert(res == 1)
+            # Reset the RNG to use the engine
+            res = self._lib.RAND_set_rand_method(self._ffi.NULL)
+            self.openssl_assert(res == 1)
+
+    def osrandom_engine_implementation(self) -> str:
+        buf = self._ffi.new("char[]", 64)
+        with self._get_osurandom_engine() as e:
+            res = self._lib.ENGINE_ctrl_cmd(
+                e, b"get_implementation", len(buf), buf, self._ffi.NULL, 0
+            )
+            self.openssl_assert(res > 0)
+        return self._ffi.string(buf).decode("ascii")
+
+    def openssl_version_text(self) -> str:
+        """
+        Friendly string name of the loaded OpenSSL library. This is not
+        necessarily the same version as it was compiled against.
+
+        Example: OpenSSL 1.1.1d  10 Sep 2019
+        """
+        return self._ffi.string(
+            self._lib.OpenSSL_version(self._lib.OPENSSL_VERSION)
+        ).decode("ascii")
+
+    def openssl_version_number(self) -> int:
+        return self._lib.OpenSSL_version_num()
+
+    def create_hmac_ctx(
+        self, key: bytes, algorithm: hashes.HashAlgorithm
+    ) -> _HMACContext:
+        return _HMACContext(self, key, algorithm)
+
+    def _evp_md_from_algorithm(self, algorithm: hashes.HashAlgorithm):
+        if algorithm.name == "blake2b" or algorithm.name == "blake2s":
+            alg = "{}{}".format(
+                algorithm.name, algorithm.digest_size * 8
+            ).encode("ascii")
+        else:
+            alg = algorithm.name.encode("ascii")
+
+        evp_md = self._lib.EVP_get_digestbyname(alg)
+        return evp_md
+
+    def _evp_md_non_null_from_algorithm(self, algorithm: hashes.HashAlgorithm):
+        evp_md = self._evp_md_from_algorithm(algorithm)
+        self.openssl_assert(evp_md != self._ffi.NULL)
+        return evp_md
+
+    def hash_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        if self._fips_enabled and not isinstance(algorithm, self._fips_hashes):
+            return False
+
+        evp_md = self._evp_md_from_algorithm(algorithm)
+        return evp_md != self._ffi.NULL
+
+    def signature_hash_supported(
+        self, algorithm: hashes.HashAlgorithm
+    ) -> bool:
+        # Dedicated check for hashing algorithm use in message digest for
+        # signatures, e.g. RSA PKCS#1 v1.5 SHA1 (sha1WithRSAEncryption).
+        if self._fips_enabled and isinstance(algorithm, hashes.SHA1):
+            return False
+        return self.hash_supported(algorithm)
+
+    def scrypt_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        else:
+            return self._lib.Cryptography_HAS_SCRYPT == 1
+
+    def hmac_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        # FIPS mode still allows SHA1 for HMAC
+        if self._fips_enabled and isinstance(algorithm, hashes.SHA1):
+            return True
+
+        return self.hash_supported(algorithm)
+
+    def create_hash_ctx(
+        self, algorithm: hashes.HashAlgorithm
+    ) -> hashes.HashContext:
+        return _HashContext(self, algorithm)
+
+    def cipher_supported(self, cipher: CipherAlgorithm, mode: Mode) -> bool:
+        if self._fips_enabled:
+            # FIPS mode requires AES. TripleDES is disallowed/deprecated in
+            # FIPS 140-3.
+            if not isinstance(cipher, self._fips_ciphers):
+                return False
+
+        try:
+            adapter = self._cipher_registry[type(cipher), type(mode)]
+        except KeyError:
+            return False
+        evp_cipher = adapter(self, cipher, mode)
+        return self._ffi.NULL != evp_cipher
+
+    def register_cipher_adapter(self, cipher_cls, mode_cls, adapter):
+        if (cipher_cls, mode_cls) in self._cipher_registry:
+            raise ValueError(
+                "Duplicate registration for: {} {}.".format(
+                    cipher_cls, mode_cls
+                )
+            )
+        self._cipher_registry[cipher_cls, mode_cls] = adapter
+
+    def _register_default_ciphers(self) -> None:
+        for mode_cls in [CBC, CTR, ECB, OFB, CFB, CFB8, GCM]:
+            self.register_cipher_adapter(
+                AES,
+                mode_cls,
+                GetCipherByName("{cipher.name}-{cipher.key_size}-{mode.name}"),
+            )
+        for mode_cls in [CBC, CTR, ECB, OFB, CFB]:
+            self.register_cipher_adapter(
+                Camellia,
+                mode_cls,
+                GetCipherByName("{cipher.name}-{cipher.key_size}-{mode.name}"),
+            )
+        for mode_cls in [CBC, CFB, CFB8, OFB]:
+            self.register_cipher_adapter(
+                TripleDES, mode_cls, GetCipherByName("des-ede3-{mode.name}")
+            )
+        self.register_cipher_adapter(
+            TripleDES, ECB, GetCipherByName("des-ede3")
+        )
+        for mode_cls in [CBC, CFB, OFB, ECB]:
+            self.register_cipher_adapter(
+                _BlowfishInternal, mode_cls, GetCipherByName("bf-{mode.name}")
+            )
+        for mode_cls in [CBC, CFB, OFB, ECB]:
+            self.register_cipher_adapter(
+                _SEEDInternal, mode_cls, GetCipherByName("seed-{mode.name}")
+            )
+        for cipher_cls, mode_cls in itertools.product(
+            [_CAST5Internal, _IDEAInternal],
+            [CBC, OFB, CFB, ECB],
+        ):
+            self.register_cipher_adapter(
+                cipher_cls,
+                mode_cls,
+                GetCipherByName("{cipher.name}-{mode.name}"),
+            )
+        self.register_cipher_adapter(ARC4, type(None), GetCipherByName("rc4"))
+        # We don't actually support RC2, this is just used by some tests.
+        self.register_cipher_adapter(_RC2, type(None), GetCipherByName("rc2"))
+        self.register_cipher_adapter(
+            ChaCha20, type(None), GetCipherByName("chacha20")
+        )
+        self.register_cipher_adapter(AES, XTS, _get_xts_cipher)
+        for mode_cls in [ECB, CBC, OFB, CFB, CTR]:
+            self.register_cipher_adapter(
+                SM4, mode_cls, GetCipherByName("sm4-{mode.name}")
+            )
+
+    def create_symmetric_encryption_ctx(
+        self, cipher: CipherAlgorithm, mode: Mode
+    ) -> _CipherContext:
+        return _CipherContext(self, cipher, mode, _CipherContext._ENCRYPT)
+
+    def create_symmetric_decryption_ctx(
+        self, cipher: CipherAlgorithm, mode: Mode
+    ) -> _CipherContext:
+        return _CipherContext(self, cipher, mode, _CipherContext._DECRYPT)
+
+    def pbkdf2_hmac_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        return self.hmac_supported(algorithm)
+
+    def derive_pbkdf2_hmac(
+        self,
+        algorithm: hashes.HashAlgorithm,
+        length: int,
+        salt: bytes,
+        iterations: int,
+        key_material: bytes,
+    ) -> bytes:
+        buf = self._ffi.new("unsigned char[]", length)
+        evp_md = self._evp_md_non_null_from_algorithm(algorithm)
+        key_material_ptr = self._ffi.from_buffer(key_material)
+        res = self._lib.PKCS5_PBKDF2_HMAC(
+            key_material_ptr,
+            len(key_material),
+            salt,
+            len(salt),
+            iterations,
+            evp_md,
+            length,
+            buf,
+        )
+        self.openssl_assert(res == 1)
+        return self._ffi.buffer(buf)[:]
+
+    def _consume_errors(self) -> typing.List[binding._OpenSSLError]:
+        return binding._consume_errors(self._lib)
+
+    def _consume_errors_with_text(
+        self,
+    ) -> typing.List[binding._OpenSSLErrorWithText]:
+        return binding._consume_errors_with_text(self._lib)
+
+    def _bn_to_int(self, bn) -> int:
+        assert bn != self._ffi.NULL
+        self.openssl_assert(not self._lib.BN_is_negative(bn))
+
+        bn_num_bytes = self._lib.BN_num_bytes(bn)
+        bin_ptr = self._ffi.new("unsigned char[]", bn_num_bytes)
+        bin_len = self._lib.BN_bn2bin(bn, bin_ptr)
+        # A zero length means the BN has value 0
+        self.openssl_assert(bin_len >= 0)
+        val = int.from_bytes(self._ffi.buffer(bin_ptr)[:bin_len], "big")
+        return val
+
+    def _int_to_bn(self, num: int, bn=None):
+        """
+        Converts a python integer to a BIGNUM. The returned BIGNUM will not
+        be garbage collected (to support adding them to structs that take
+        ownership of the object). Be sure to register it for GC if it will
+        be discarded after use.
+        """
+        assert bn is None or bn != self._ffi.NULL
+
+        if bn is None:
+            bn = self._ffi.NULL
+
+        binary = num.to_bytes(int(num.bit_length() / 8.0 + 1), "big")
+        bn_ptr = self._lib.BN_bin2bn(binary, len(binary), bn)
+        self.openssl_assert(bn_ptr != self._ffi.NULL)
+        return bn_ptr
+
+    def generate_rsa_private_key(
+        self, public_exponent: int, key_size: int
+    ) -> rsa.RSAPrivateKey:
+        rsa._verify_rsa_parameters(public_exponent, key_size)
+
+        rsa_cdata = self._lib.RSA_new()
+        self.openssl_assert(rsa_cdata != self._ffi.NULL)
+        rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free)
+
+        bn = self._int_to_bn(public_exponent)
+        bn = self._ffi.gc(bn, self._lib.BN_free)
+
+        res = self._lib.RSA_generate_key_ex(
+            rsa_cdata, key_size, bn, self._ffi.NULL
+        )
+        self.openssl_assert(res == 1)
+        evp_pkey = self._rsa_cdata_to_evp_pkey(rsa_cdata)
+
+        return _RSAPrivateKey(
+            self, rsa_cdata, evp_pkey, self._rsa_skip_check_key
+        )
+
+    def generate_rsa_parameters_supported(
+        self, public_exponent: int, key_size: int
+    ) -> bool:
+        return (
+            public_exponent >= 3
+            and public_exponent & 1 != 0
+            and key_size >= 512
+        )
+
+    def load_rsa_private_numbers(
+        self, numbers: rsa.RSAPrivateNumbers
+    ) -> rsa.RSAPrivateKey:
+        rsa._check_private_key_components(
+            numbers.p,
+            numbers.q,
+            numbers.d,
+            numbers.dmp1,
+            numbers.dmq1,
+            numbers.iqmp,
+            numbers.public_numbers.e,
+            numbers.public_numbers.n,
+        )
+        rsa_cdata = self._lib.RSA_new()
+        self.openssl_assert(rsa_cdata != self._ffi.NULL)
+        rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free)
+        p = self._int_to_bn(numbers.p)
+        q = self._int_to_bn(numbers.q)
+        d = self._int_to_bn(numbers.d)
+        dmp1 = self._int_to_bn(numbers.dmp1)
+        dmq1 = self._int_to_bn(numbers.dmq1)
+        iqmp = self._int_to_bn(numbers.iqmp)
+        e = self._int_to_bn(numbers.public_numbers.e)
+        n = self._int_to_bn(numbers.public_numbers.n)
+        res = self._lib.RSA_set0_factors(rsa_cdata, p, q)
+        self.openssl_assert(res == 1)
+        res = self._lib.RSA_set0_key(rsa_cdata, n, e, d)
+        self.openssl_assert(res == 1)
+        res = self._lib.RSA_set0_crt_params(rsa_cdata, dmp1, dmq1, iqmp)
+        self.openssl_assert(res == 1)
+        evp_pkey = self._rsa_cdata_to_evp_pkey(rsa_cdata)
+
+        return _RSAPrivateKey(
+            self, rsa_cdata, evp_pkey, self._rsa_skip_check_key
+        )
+
+    def load_rsa_public_numbers(
+        self, numbers: rsa.RSAPublicNumbers
+    ) -> rsa.RSAPublicKey:
+        rsa._check_public_key_components(numbers.e, numbers.n)
+        rsa_cdata = self._lib.RSA_new()
+        self.openssl_assert(rsa_cdata != self._ffi.NULL)
+        rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free)
+        e = self._int_to_bn(numbers.e)
+        n = self._int_to_bn(numbers.n)
+        res = self._lib.RSA_set0_key(rsa_cdata, n, e, self._ffi.NULL)
+        self.openssl_assert(res == 1)
+        evp_pkey = self._rsa_cdata_to_evp_pkey(rsa_cdata)
+
+        return _RSAPublicKey(self, rsa_cdata, evp_pkey)
+
+    def _create_evp_pkey_gc(self):
+        evp_pkey = self._lib.EVP_PKEY_new()
+        self.openssl_assert(evp_pkey != self._ffi.NULL)
+        evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free)
+        return evp_pkey
+
+    def _rsa_cdata_to_evp_pkey(self, rsa_cdata):
+        evp_pkey = self._create_evp_pkey_gc()
+        res = self._lib.EVP_PKEY_set1_RSA(evp_pkey, rsa_cdata)
+        self.openssl_assert(res == 1)
+        return evp_pkey
+
+    def _bytes_to_bio(self, data: bytes):
+        """
+        Return a _MemoryBIO namedtuple of (BIO, char*).
+
+        The char* is the storage for the BIO and it must stay alive until the
+        BIO is finished with.
+        """
+        data_ptr = self._ffi.from_buffer(data)
+        bio = self._lib.BIO_new_mem_buf(data_ptr, len(data))
+        self.openssl_assert(bio != self._ffi.NULL)
+
+        return _MemoryBIO(self._ffi.gc(bio, self._lib.BIO_free), data_ptr)
+
+    def _create_mem_bio_gc(self):
+        """
+        Creates an empty memory BIO.
+        """
+        bio_method = self._lib.BIO_s_mem()
+        self.openssl_assert(bio_method != self._ffi.NULL)
+        bio = self._lib.BIO_new(bio_method)
+        self.openssl_assert(bio != self._ffi.NULL)
+        bio = self._ffi.gc(bio, self._lib.BIO_free)
+        return bio
+
+    def _read_mem_bio(self, bio) -> bytes:
+        """
+        Reads a memory BIO. This only works on memory BIOs.
+        """
+        buf = self._ffi.new("char **")
+        buf_len = self._lib.BIO_get_mem_data(bio, buf)
+        self.openssl_assert(buf_len > 0)
+        self.openssl_assert(buf[0] != self._ffi.NULL)
+        bio_data = self._ffi.buffer(buf[0], buf_len)[:]
+        return bio_data
+
+    def _evp_pkey_to_private_key(self, evp_pkey) -> PRIVATE_KEY_TYPES:
+        """
+        Return the appropriate type of PrivateKey given an evp_pkey cdata
+        pointer.
+        """
+
+        key_type = self._lib.EVP_PKEY_id(evp_pkey)
+
+        if key_type == self._lib.EVP_PKEY_RSA:
+            rsa_cdata = self._lib.EVP_PKEY_get1_RSA(evp_pkey)
+            self.openssl_assert(rsa_cdata != self._ffi.NULL)
+            rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free)
+            return _RSAPrivateKey(
+                self, rsa_cdata, evp_pkey, self._rsa_skip_check_key
+            )
+        elif (
+            key_type == self._lib.EVP_PKEY_RSA_PSS
+            and not self._lib.CRYPTOGRAPHY_IS_LIBRESSL
+            and not self._lib.CRYPTOGRAPHY_IS_BORINGSSL
+            and not self._lib.CRYPTOGRAPHY_OPENSSL_LESS_THAN_111E
+        ):
+            # At the moment the way we handle RSA PSS keys is to strip the
+            # PSS constraints from them and treat them as normal RSA keys
+            # Unfortunately the RSA * itself tracks this data so we need to
+            # extract, serialize, and reload it without the constraints.
+            rsa_cdata = self._lib.EVP_PKEY_get1_RSA(evp_pkey)
+            self.openssl_assert(rsa_cdata != self._ffi.NULL)
+            rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free)
+            bio = self._create_mem_bio_gc()
+            res = self._lib.i2d_RSAPrivateKey_bio(bio, rsa_cdata)
+            self.openssl_assert(res == 1)
+            return self.load_der_private_key(
+                self._read_mem_bio(bio), password=None
+            )
+        elif key_type == self._lib.EVP_PKEY_DSA:
+            dsa_cdata = self._lib.EVP_PKEY_get1_DSA(evp_pkey)
+            self.openssl_assert(dsa_cdata != self._ffi.NULL)
+            dsa_cdata = self._ffi.gc(dsa_cdata, self._lib.DSA_free)
+            return _DSAPrivateKey(self, dsa_cdata, evp_pkey)
+        elif key_type == self._lib.EVP_PKEY_EC:
+            ec_cdata = self._lib.EVP_PKEY_get1_EC_KEY(evp_pkey)
+            self.openssl_assert(ec_cdata != self._ffi.NULL)
+            ec_cdata = self._ffi.gc(ec_cdata, self._lib.EC_KEY_free)
+            return _EllipticCurvePrivateKey(self, ec_cdata, evp_pkey)
+        elif key_type in self._dh_types:
+            dh_cdata = self._lib.EVP_PKEY_get1_DH(evp_pkey)
+            self.openssl_assert(dh_cdata != self._ffi.NULL)
+            dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free)
+            return _DHPrivateKey(self, dh_cdata, evp_pkey)
+        elif key_type == getattr(self._lib, "EVP_PKEY_ED25519", None):
+            # EVP_PKEY_ED25519 is not present in OpenSSL < 1.1.1
+            return _Ed25519PrivateKey(self, evp_pkey)
+        elif key_type == getattr(self._lib, "EVP_PKEY_X448", None):
+            # EVP_PKEY_X448 is not present in OpenSSL < 1.1.1
+            return _X448PrivateKey(self, evp_pkey)
+        elif key_type == getattr(self._lib, "EVP_PKEY_X25519", None):
+            # EVP_PKEY_X25519 is not present in OpenSSL < 1.1.0
+            return _X25519PrivateKey(self, evp_pkey)
+        elif key_type == getattr(self._lib, "EVP_PKEY_ED448", None):
+            # EVP_PKEY_ED448 is not present in OpenSSL < 1.1.1
+            return _Ed448PrivateKey(self, evp_pkey)
+        else:
+            raise UnsupportedAlgorithm("Unsupported key type.")
+
+    def _evp_pkey_to_public_key(self, evp_pkey) -> PUBLIC_KEY_TYPES:
+        """
+        Return the appropriate type of PublicKey given an evp_pkey cdata
+        pointer.
+        """
+
+        key_type = self._lib.EVP_PKEY_id(evp_pkey)
+
+        if key_type == self._lib.EVP_PKEY_RSA:
+            rsa_cdata = self._lib.EVP_PKEY_get1_RSA(evp_pkey)
+            self.openssl_assert(rsa_cdata != self._ffi.NULL)
+            rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free)
+            return _RSAPublicKey(self, rsa_cdata, evp_pkey)
+        elif key_type == self._lib.EVP_PKEY_DSA:
+            dsa_cdata = self._lib.EVP_PKEY_get1_DSA(evp_pkey)
+            self.openssl_assert(dsa_cdata != self._ffi.NULL)
+            dsa_cdata = self._ffi.gc(dsa_cdata, self._lib.DSA_free)
+            return _DSAPublicKey(self, dsa_cdata, evp_pkey)
+        elif key_type == self._lib.EVP_PKEY_EC:
+            ec_cdata = self._lib.EVP_PKEY_get1_EC_KEY(evp_pkey)
+            if ec_cdata == self._ffi.NULL:
+                errors = self._consume_errors_with_text()
+                raise ValueError("Unable to load EC key", errors)
+            ec_cdata = self._ffi.gc(ec_cdata, self._lib.EC_KEY_free)
+            return _EllipticCurvePublicKey(self, ec_cdata, evp_pkey)
+        elif key_type in self._dh_types:
+            dh_cdata = self._lib.EVP_PKEY_get1_DH(evp_pkey)
+            self.openssl_assert(dh_cdata != self._ffi.NULL)
+            dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free)
+            return _DHPublicKey(self, dh_cdata, evp_pkey)
+        elif key_type == getattr(self._lib, "EVP_PKEY_ED25519", None):
+            # EVP_PKEY_ED25519 is not present in OpenSSL < 1.1.1
+            return _Ed25519PublicKey(self, evp_pkey)
+        elif key_type == getattr(self._lib, "EVP_PKEY_X448", None):
+            # EVP_PKEY_X448 is not present in OpenSSL < 1.1.1
+            return _X448PublicKey(self, evp_pkey)
+        elif key_type == getattr(self._lib, "EVP_PKEY_X25519", None):
+            # EVP_PKEY_X25519 is not present in OpenSSL < 1.1.0
+            return _X25519PublicKey(self, evp_pkey)
+        elif key_type == getattr(self._lib, "EVP_PKEY_ED448", None):
+            # EVP_PKEY_X25519 is not present in OpenSSL < 1.1.1
+            return _Ed448PublicKey(self, evp_pkey)
+        else:
+            raise UnsupportedAlgorithm("Unsupported key type.")
+
+    def _oaep_hash_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        return isinstance(
+            algorithm,
+            (
+                hashes.SHA1,
+                hashes.SHA224,
+                hashes.SHA256,
+                hashes.SHA384,
+                hashes.SHA512,
+            ),
+        )
+
+    def rsa_padding_supported(self, padding: AsymmetricPadding) -> bool:
+        if isinstance(padding, PKCS1v15):
+            return True
+        elif isinstance(padding, PSS) and isinstance(padding._mgf, MGF1):
+            # SHA1 is permissible in MGF1 in FIPS even when SHA1 is blocked
+            # as signature algorithm.
+            if self._fips_enabled and isinstance(
+                padding._mgf._algorithm, hashes.SHA1
+            ):
+                return True
+            else:
+                return self.hash_supported(padding._mgf._algorithm)
+        elif isinstance(padding, OAEP) and isinstance(padding._mgf, MGF1):
+            return self._oaep_hash_supported(
+                padding._mgf._algorithm
+            ) and self._oaep_hash_supported(padding._algorithm)
+        else:
+            return False
+
+    def generate_dsa_parameters(self, key_size: int) -> dsa.DSAParameters:
+        if key_size not in (1024, 2048, 3072, 4096):
+            raise ValueError(
+                "Key size must be 1024, 2048, 3072, or 4096 bits."
+            )
+
+        ctx = self._lib.DSA_new()
+        self.openssl_assert(ctx != self._ffi.NULL)
+        ctx = self._ffi.gc(ctx, self._lib.DSA_free)
+
+        res = self._lib.DSA_generate_parameters_ex(
+            ctx,
+            key_size,
+            self._ffi.NULL,
+            0,
+            self._ffi.NULL,
+            self._ffi.NULL,
+            self._ffi.NULL,
+        )
+
+        self.openssl_assert(res == 1)
+
+        return _DSAParameters(self, ctx)
+
+    def generate_dsa_private_key(
+        self, parameters: dsa.DSAParameters
+    ) -> dsa.DSAPrivateKey:
+        ctx = self._lib.DSAparams_dup(
+            parameters._dsa_cdata  # type: ignore[attr-defined]
+        )
+        self.openssl_assert(ctx != self._ffi.NULL)
+        ctx = self._ffi.gc(ctx, self._lib.DSA_free)
+        self._lib.DSA_generate_key(ctx)
+        evp_pkey = self._dsa_cdata_to_evp_pkey(ctx)
+
+        return _DSAPrivateKey(self, ctx, evp_pkey)
+
+    def generate_dsa_private_key_and_parameters(
+        self, key_size: int
+    ) -> dsa.DSAPrivateKey:
+        parameters = self.generate_dsa_parameters(key_size)
+        return self.generate_dsa_private_key(parameters)
+
+    def _dsa_cdata_set_values(self, dsa_cdata, p, q, g, pub_key, priv_key):
+        res = self._lib.DSA_set0_pqg(dsa_cdata, p, q, g)
+        self.openssl_assert(res == 1)
+        res = self._lib.DSA_set0_key(dsa_cdata, pub_key, priv_key)
+        self.openssl_assert(res == 1)
+
+    def load_dsa_private_numbers(
+        self, numbers: dsa.DSAPrivateNumbers
+    ) -> dsa.DSAPrivateKey:
+        dsa._check_dsa_private_numbers(numbers)
+        parameter_numbers = numbers.public_numbers.parameter_numbers
+
+        dsa_cdata = self._lib.DSA_new()
+        self.openssl_assert(dsa_cdata != self._ffi.NULL)
+        dsa_cdata = self._ffi.gc(dsa_cdata, self._lib.DSA_free)
+
+        p = self._int_to_bn(parameter_numbers.p)
+        q = self._int_to_bn(parameter_numbers.q)
+        g = self._int_to_bn(parameter_numbers.g)
+        pub_key = self._int_to_bn(numbers.public_numbers.y)
+        priv_key = self._int_to_bn(numbers.x)
+        self._dsa_cdata_set_values(dsa_cdata, p, q, g, pub_key, priv_key)
+
+        evp_pkey = self._dsa_cdata_to_evp_pkey(dsa_cdata)
+
+        return _DSAPrivateKey(self, dsa_cdata, evp_pkey)
+
+    def load_dsa_public_numbers(
+        self, numbers: dsa.DSAPublicNumbers
+    ) -> dsa.DSAPublicKey:
+        dsa._check_dsa_parameters(numbers.parameter_numbers)
+        dsa_cdata = self._lib.DSA_new()
+        self.openssl_assert(dsa_cdata != self._ffi.NULL)
+        dsa_cdata = self._ffi.gc(dsa_cdata, self._lib.DSA_free)
+
+        p = self._int_to_bn(numbers.parameter_numbers.p)
+        q = self._int_to_bn(numbers.parameter_numbers.q)
+        g = self._int_to_bn(numbers.parameter_numbers.g)
+        pub_key = self._int_to_bn(numbers.y)
+        priv_key = self._ffi.NULL
+        self._dsa_cdata_set_values(dsa_cdata, p, q, g, pub_key, priv_key)
+
+        evp_pkey = self._dsa_cdata_to_evp_pkey(dsa_cdata)
+
+        return _DSAPublicKey(self, dsa_cdata, evp_pkey)
+
+    def load_dsa_parameter_numbers(
+        self, numbers: dsa.DSAParameterNumbers
+    ) -> dsa.DSAParameters:
+        dsa._check_dsa_parameters(numbers)
+        dsa_cdata = self._lib.DSA_new()
+        self.openssl_assert(dsa_cdata != self._ffi.NULL)
+        dsa_cdata = self._ffi.gc(dsa_cdata, self._lib.DSA_free)
+
+        p = self._int_to_bn(numbers.p)
+        q = self._int_to_bn(numbers.q)
+        g = self._int_to_bn(numbers.g)
+        res = self._lib.DSA_set0_pqg(dsa_cdata, p, q, g)
+        self.openssl_assert(res == 1)
+
+        return _DSAParameters(self, dsa_cdata)
+
+    def _dsa_cdata_to_evp_pkey(self, dsa_cdata):
+        evp_pkey = self._create_evp_pkey_gc()
+        res = self._lib.EVP_PKEY_set1_DSA(evp_pkey, dsa_cdata)
+        self.openssl_assert(res == 1)
+        return evp_pkey
+
+    def dsa_supported(self) -> bool:
+        return not self._fips_enabled
+
+    def dsa_hash_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        if not self.dsa_supported():
+            return False
+        return self.signature_hash_supported(algorithm)
+
+    def cmac_algorithm_supported(self, algorithm) -> bool:
+        return self.cipher_supported(
+            algorithm, CBC(b"\x00" * algorithm.block_size)
+        )
+
+    def create_cmac_ctx(self, algorithm: BlockCipherAlgorithm) -> _CMACContext:
+        return _CMACContext(self, algorithm)
+
+    def load_pem_private_key(
+        self, data: bytes, password: typing.Optional[bytes]
+    ) -> PRIVATE_KEY_TYPES:
+        return self._load_key(
+            self._lib.PEM_read_bio_PrivateKey,
+            self._evp_pkey_to_private_key,
+            data,
+            password,
+        )
+
+    def load_pem_public_key(self, data: bytes) -> PUBLIC_KEY_TYPES:
+        mem_bio = self._bytes_to_bio(data)
+        # In OpenSSL 3.0.x the PEM_read_bio_PUBKEY function will invoke
+        # the default password callback if you pass an encrypted private
+        # key. This is very, very, very bad as the default callback can
+        # trigger an interactive console prompt, which will hang the
+        # Python process. We therefore provide our own callback to
+        # catch this and error out properly.
+        userdata = self._ffi.new("CRYPTOGRAPHY_PASSWORD_DATA *")
+        evp_pkey = self._lib.PEM_read_bio_PUBKEY(
+            mem_bio.bio,
+            self._ffi.NULL,
+            self._ffi.addressof(
+                self._lib._original_lib, "Cryptography_pem_password_cb"
+            ),
+            userdata,
+        )
+        if evp_pkey != self._ffi.NULL:
+            evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free)
+            return self._evp_pkey_to_public_key(evp_pkey)
+        else:
+            # It's not a (RSA/DSA/ECDSA) subjectPublicKeyInfo, but we still
+            # need to check to see if it is a pure PKCS1 RSA public key (not
+            # embedded in a subjectPublicKeyInfo)
+            self._consume_errors()
+            res = self._lib.BIO_reset(mem_bio.bio)
+            self.openssl_assert(res == 1)
+            rsa_cdata = self._lib.PEM_read_bio_RSAPublicKey(
+                mem_bio.bio,
+                self._ffi.NULL,
+                self._ffi.addressof(
+                    self._lib._original_lib, "Cryptography_pem_password_cb"
+                ),
+                userdata,
+            )
+            if rsa_cdata != self._ffi.NULL:
+                rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free)
+                evp_pkey = self._rsa_cdata_to_evp_pkey(rsa_cdata)
+                return _RSAPublicKey(self, rsa_cdata, evp_pkey)
+            else:
+                self._handle_key_loading_error()
+
+    def load_pem_parameters(self, data: bytes) -> dh.DHParameters:
+        mem_bio = self._bytes_to_bio(data)
+        # only DH is supported currently
+        dh_cdata = self._lib.PEM_read_bio_DHparams(
+            mem_bio.bio, self._ffi.NULL, self._ffi.NULL, self._ffi.NULL
+        )
+        if dh_cdata != self._ffi.NULL:
+            dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free)
+            return _DHParameters(self, dh_cdata)
+        else:
+            self._handle_key_loading_error()
+
+    def load_der_private_key(
+        self, data: bytes, password: typing.Optional[bytes]
+    ) -> PRIVATE_KEY_TYPES:
+        # OpenSSL has a function called d2i_AutoPrivateKey that in theory
+        # handles this automatically, however it doesn't handle encrypted
+        # private keys. Instead we try to load the key two different ways.
+        # First we'll try to load it as a traditional key.
+        bio_data = self._bytes_to_bio(data)
+        key = self._evp_pkey_from_der_traditional_key(bio_data, password)
+        if key:
+            return self._evp_pkey_to_private_key(key)
+        else:
+            # Finally we try to load it with the method that handles encrypted
+            # PKCS8 properly.
+            return self._load_key(
+                self._lib.d2i_PKCS8PrivateKey_bio,
+                self._evp_pkey_to_private_key,
+                data,
+                password,
+            )
+
+    def _evp_pkey_from_der_traditional_key(self, bio_data, password):
+        key = self._lib.d2i_PrivateKey_bio(bio_data.bio, self._ffi.NULL)
+        if key != self._ffi.NULL:
+            # In OpenSSL 3.0.0-alpha15 there exist scenarios where the key will
+            # successfully load but errors are still put on the stack. Tracked
+            # as https://github.com/openssl/openssl/issues/14996
+            self._consume_errors()
+
+            key = self._ffi.gc(key, self._lib.EVP_PKEY_free)
+            if password is not None:
+                raise TypeError(
+                    "Password was given but private key is not encrypted."
+                )
+
+            return key
+        else:
+            self._consume_errors()
+            return None
+
+    def load_der_public_key(self, data: bytes) -> PUBLIC_KEY_TYPES:
+        mem_bio = self._bytes_to_bio(data)
+        evp_pkey = self._lib.d2i_PUBKEY_bio(mem_bio.bio, self._ffi.NULL)
+        if evp_pkey != self._ffi.NULL:
+            evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free)
+            return self._evp_pkey_to_public_key(evp_pkey)
+        else:
+            # It's not a (RSA/DSA/ECDSA) subjectPublicKeyInfo, but we still
+            # need to check to see if it is a pure PKCS1 RSA public key (not
+            # embedded in a subjectPublicKeyInfo)
+            self._consume_errors()
+            res = self._lib.BIO_reset(mem_bio.bio)
+            self.openssl_assert(res == 1)
+            rsa_cdata = self._lib.d2i_RSAPublicKey_bio(
+                mem_bio.bio, self._ffi.NULL
+            )
+            if rsa_cdata != self._ffi.NULL:
+                rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free)
+                evp_pkey = self._rsa_cdata_to_evp_pkey(rsa_cdata)
+                return _RSAPublicKey(self, rsa_cdata, evp_pkey)
+            else:
+                self._handle_key_loading_error()
+
+    def load_der_parameters(self, data: bytes) -> dh.DHParameters:
+        mem_bio = self._bytes_to_bio(data)
+        dh_cdata = self._lib.d2i_DHparams_bio(mem_bio.bio, self._ffi.NULL)
+        if dh_cdata != self._ffi.NULL:
+            dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free)
+            return _DHParameters(self, dh_cdata)
+        elif self._lib.Cryptography_HAS_EVP_PKEY_DHX:
+            # We check to see if the is dhx.
+            self._consume_errors()
+            res = self._lib.BIO_reset(mem_bio.bio)
+            self.openssl_assert(res == 1)
+            dh_cdata = self._lib.Cryptography_d2i_DHxparams_bio(
+                mem_bio.bio, self._ffi.NULL
+            )
+            if dh_cdata != self._ffi.NULL:
+                dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free)
+                return _DHParameters(self, dh_cdata)
+
+        self._handle_key_loading_error()
+
+    def _cert2ossl(self, cert: x509.Certificate) -> typing.Any:
+        data = cert.public_bytes(serialization.Encoding.DER)
+        mem_bio = self._bytes_to_bio(data)
+        x509 = self._lib.d2i_X509_bio(mem_bio.bio, self._ffi.NULL)
+        self.openssl_assert(x509 != self._ffi.NULL)
+        x509 = self._ffi.gc(x509, self._lib.X509_free)
+        return x509
+
+    def _ossl2cert(self, x509: typing.Any) -> x509.Certificate:
+        bio = self._create_mem_bio_gc()
+        res = self._lib.i2d_X509_bio(bio, x509)
+        self.openssl_assert(res == 1)
+        return rust_x509.load_der_x509_certificate(self._read_mem_bio(bio))
+
+    def _csr2ossl(self, csr: x509.CertificateSigningRequest) -> typing.Any:
+        data = csr.public_bytes(serialization.Encoding.DER)
+        mem_bio = self._bytes_to_bio(data)
+        x509_req = self._lib.d2i_X509_REQ_bio(mem_bio.bio, self._ffi.NULL)
+        self.openssl_assert(x509_req != self._ffi.NULL)
+        x509_req = self._ffi.gc(x509_req, self._lib.X509_REQ_free)
+        return x509_req
+
+    def _ossl2csr(
+        self, x509_req: typing.Any
+    ) -> x509.CertificateSigningRequest:
+        bio = self._create_mem_bio_gc()
+        res = self._lib.i2d_X509_REQ_bio(bio, x509_req)
+        self.openssl_assert(res == 1)
+        return rust_x509.load_der_x509_csr(self._read_mem_bio(bio))
+
+    def _crl2ossl(self, crl: x509.CertificateRevocationList) -> typing.Any:
+        data = crl.public_bytes(serialization.Encoding.DER)
+        mem_bio = self._bytes_to_bio(data)
+        x509_crl = self._lib.d2i_X509_CRL_bio(mem_bio.bio, self._ffi.NULL)
+        self.openssl_assert(x509_crl != self._ffi.NULL)
+        x509_crl = self._ffi.gc(x509_crl, self._lib.X509_CRL_free)
+        return x509_crl
+
+    def _ossl2crl(
+        self, x509_crl: typing.Any
+    ) -> x509.CertificateRevocationList:
+        bio = self._create_mem_bio_gc()
+        res = self._lib.i2d_X509_CRL_bio(bio, x509_crl)
+        self.openssl_assert(res == 1)
+        return rust_x509.load_der_x509_crl(self._read_mem_bio(bio))
+
+    def _crl_is_signature_valid(
+        self,
+        crl: x509.CertificateRevocationList,
+        public_key: CERTIFICATE_ISSUER_PUBLIC_KEY_TYPES,
+    ) -> bool:
+        if not isinstance(
+            public_key,
+            (
+                _DSAPublicKey,
+                _RSAPublicKey,
+                _EllipticCurvePublicKey,
+            ),
+        ):
+            raise TypeError(
+                "Expecting one of DSAPublicKey, RSAPublicKey,"
+                " or EllipticCurvePublicKey."
+            )
+        x509_crl = self._crl2ossl(crl)
+        res = self._lib.X509_CRL_verify(x509_crl, public_key._evp_pkey)
+
+        if res != 1:
+            self._consume_errors()
+            return False
+
+        return True
+
+    def _csr_is_signature_valid(
+        self, csr: x509.CertificateSigningRequest
+    ) -> bool:
+        x509_req = self._csr2ossl(csr)
+        pkey = self._lib.X509_REQ_get_pubkey(x509_req)
+        self.openssl_assert(pkey != self._ffi.NULL)
+        pkey = self._ffi.gc(pkey, self._lib.EVP_PKEY_free)
+        res = self._lib.X509_REQ_verify(x509_req, pkey)
+
+        if res != 1:
+            self._consume_errors()
+            return False
+
+        return True
+
+    def _check_keys_correspond(self, key1, key2):
+        if self._lib.EVP_PKEY_cmp(key1._evp_pkey, key2._evp_pkey) != 1:
+            raise ValueError("Keys do not correspond")
+
+    def _load_key(self, openssl_read_func, convert_func, data, password):
+        mem_bio = self._bytes_to_bio(data)
+
+        userdata = self._ffi.new("CRYPTOGRAPHY_PASSWORD_DATA *")
+        if password is not None:
+            utils._check_byteslike("password", password)
+            password_ptr = self._ffi.from_buffer(password)
+            userdata.password = password_ptr
+            userdata.length = len(password)
+
+        evp_pkey = openssl_read_func(
+            mem_bio.bio,
+            self._ffi.NULL,
+            self._ffi.addressof(
+                self._lib._original_lib, "Cryptography_pem_password_cb"
+            ),
+            userdata,
+        )
+
+        if evp_pkey == self._ffi.NULL:
+            if userdata.error != 0:
+                self._consume_errors()
+                if userdata.error == -1:
+                    raise TypeError(
+                        "Password was not given but private key is encrypted"
+                    )
+                else:
+                    assert userdata.error == -2
+                    raise ValueError(
+                        "Passwords longer than {} bytes are not supported "
+                        "by this backend.".format(userdata.maxsize - 1)
+                    )
+            else:
+                self._handle_key_loading_error()
+
+        # In OpenSSL 3.0.0-alpha15 there exist scenarios where the key will
+        # successfully load but errors are still put on the stack. Tracked
+        # as https://github.com/openssl/openssl/issues/14996
+        self._consume_errors()
+
+        evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free)
+
+        if password is not None and userdata.called == 0:
+            raise TypeError(
+                "Password was given but private key is not encrypted."
+            )
+
+        assert (
+            password is not None and userdata.called == 1
+        ) or password is None
+
+        return convert_func(evp_pkey)
+
+    def _handle_key_loading_error(self) -> typing.NoReturn:
+        errors = self._consume_errors()
+
+        if not errors:
+            raise ValueError(
+                "Could not deserialize key data. The data may be in an "
+                "incorrect format or it may be encrypted with an unsupported "
+                "algorithm."
+            )
+
+        elif (
+            errors[0]._lib_reason_match(
+                self._lib.ERR_LIB_EVP, self._lib.EVP_R_BAD_DECRYPT
+            )
+            or errors[0]._lib_reason_match(
+                self._lib.ERR_LIB_PKCS12,
+                self._lib.PKCS12_R_PKCS12_CIPHERFINAL_ERROR,
+            )
+            or (
+                self._lib.Cryptography_HAS_PROVIDERS
+                and errors[0]._lib_reason_match(
+                    self._lib.ERR_LIB_PROV,
+                    self._lib.PROV_R_BAD_DECRYPT,
+                )
+            )
+        ):
+            raise ValueError("Bad decrypt. Incorrect password?")
+
+        elif any(
+            error._lib_reason_match(
+                self._lib.ERR_LIB_EVP,
+                self._lib.EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM,
+            )
+            for error in errors
+        ):
+            raise ValueError("Unsupported public key algorithm.")
+
+        else:
+            errors_with_text = binding._errors_with_text(errors)
+            raise ValueError(
+                "Could not deserialize key data. The data may be in an "
+                "incorrect format, it may be encrypted with an unsupported "
+                "algorithm, or it may be an unsupported key type (e.g. EC "
+                "curves with explicit parameters).",
+                errors_with_text,
+            )
+
+    def elliptic_curve_supported(self, curve: ec.EllipticCurve) -> bool:
+        try:
+            curve_nid = self._elliptic_curve_to_nid(curve)
+        except UnsupportedAlgorithm:
+            curve_nid = self._lib.NID_undef
+
+        group = self._lib.EC_GROUP_new_by_curve_name(curve_nid)
+
+        if group == self._ffi.NULL:
+            self._consume_errors()
+            return False
+        else:
+            self.openssl_assert(curve_nid != self._lib.NID_undef)
+            self._lib.EC_GROUP_free(group)
+            return True
+
+    def elliptic_curve_signature_algorithm_supported(
+        self,
+        signature_algorithm: ec.EllipticCurveSignatureAlgorithm,
+        curve: ec.EllipticCurve,
+    ) -> bool:
+        # We only support ECDSA right now.
+        if not isinstance(signature_algorithm, ec.ECDSA):
+            return False
+
+        return self.elliptic_curve_supported(curve)
+
+    def generate_elliptic_curve_private_key(
+        self, curve: ec.EllipticCurve
+    ) -> ec.EllipticCurvePrivateKey:
+        """
+        Generate a new private key on the named curve.
+        """
+
+        if self.elliptic_curve_supported(curve):
+            ec_cdata = self._ec_key_new_by_curve(curve)
+
+            res = self._lib.EC_KEY_generate_key(ec_cdata)
+            self.openssl_assert(res == 1)
+
+            evp_pkey = self._ec_cdata_to_evp_pkey(ec_cdata)
+
+            return _EllipticCurvePrivateKey(self, ec_cdata, evp_pkey)
+        else:
+            raise UnsupportedAlgorithm(
+                "Backend object does not support {}.".format(curve.name),
+                _Reasons.UNSUPPORTED_ELLIPTIC_CURVE,
+            )
+
+    def load_elliptic_curve_private_numbers(
+        self, numbers: ec.EllipticCurvePrivateNumbers
+    ) -> ec.EllipticCurvePrivateKey:
+        public = numbers.public_numbers
+
+        ec_cdata = self._ec_key_new_by_curve(public.curve)
+
+        private_value = self._ffi.gc(
+            self._int_to_bn(numbers.private_value), self._lib.BN_clear_free
+        )
+        res = self._lib.EC_KEY_set_private_key(ec_cdata, private_value)
+        if res != 1:
+            self._consume_errors()
+            raise ValueError("Invalid EC key.")
+
+        self._ec_key_set_public_key_affine_coordinates(
+            ec_cdata, public.x, public.y
+        )
+
+        evp_pkey = self._ec_cdata_to_evp_pkey(ec_cdata)
+
+        return _EllipticCurvePrivateKey(self, ec_cdata, evp_pkey)
+
+    def load_elliptic_curve_public_numbers(
+        self, numbers: ec.EllipticCurvePublicNumbers
+    ) -> ec.EllipticCurvePublicKey:
+        ec_cdata = self._ec_key_new_by_curve(numbers.curve)
+        self._ec_key_set_public_key_affine_coordinates(
+            ec_cdata, numbers.x, numbers.y
+        )
+        evp_pkey = self._ec_cdata_to_evp_pkey(ec_cdata)
+
+        return _EllipticCurvePublicKey(self, ec_cdata, evp_pkey)
+
+    def load_elliptic_curve_public_bytes(
+        self, curve: ec.EllipticCurve, point_bytes: bytes
+    ) -> ec.EllipticCurvePublicKey:
+        ec_cdata = self._ec_key_new_by_curve(curve)
+        group = self._lib.EC_KEY_get0_group(ec_cdata)
+        self.openssl_assert(group != self._ffi.NULL)
+        point = self._lib.EC_POINT_new(group)
+        self.openssl_assert(point != self._ffi.NULL)
+        point = self._ffi.gc(point, self._lib.EC_POINT_free)
+        with self._tmp_bn_ctx() as bn_ctx:
+            res = self._lib.EC_POINT_oct2point(
+                group, point, point_bytes, len(point_bytes), bn_ctx
+            )
+            if res != 1:
+                self._consume_errors()
+                raise ValueError("Invalid public bytes for the given curve")
+
+        res = self._lib.EC_KEY_set_public_key(ec_cdata, point)
+        self.openssl_assert(res == 1)
+        evp_pkey = self._ec_cdata_to_evp_pkey(ec_cdata)
+        return _EllipticCurvePublicKey(self, ec_cdata, evp_pkey)
+
+    def derive_elliptic_curve_private_key(
+        self, private_value: int, curve: ec.EllipticCurve
+    ) -> ec.EllipticCurvePrivateKey:
+        ec_cdata = self._ec_key_new_by_curve(curve)
+
+        get_func, group = self._ec_key_determine_group_get_func(ec_cdata)
+
+        point = self._lib.EC_POINT_new(group)
+        self.openssl_assert(point != self._ffi.NULL)
+        point = self._ffi.gc(point, self._lib.EC_POINT_free)
+
+        value = self._int_to_bn(private_value)
+        value = self._ffi.gc(value, self._lib.BN_clear_free)
+
+        with self._tmp_bn_ctx() as bn_ctx:
+            res = self._lib.EC_POINT_mul(
+                group, point, value, self._ffi.NULL, self._ffi.NULL, bn_ctx
+            )
+            self.openssl_assert(res == 1)
+
+            bn_x = self._lib.BN_CTX_get(bn_ctx)
+            bn_y = self._lib.BN_CTX_get(bn_ctx)
+
+            res = get_func(group, point, bn_x, bn_y, bn_ctx)
+            if res != 1:
+                self._consume_errors()
+                raise ValueError("Unable to derive key from private_value")
+
+        res = self._lib.EC_KEY_set_public_key(ec_cdata, point)
+        self.openssl_assert(res == 1)
+        private = self._int_to_bn(private_value)
+        private = self._ffi.gc(private, self._lib.BN_clear_free)
+        res = self._lib.EC_KEY_set_private_key(ec_cdata, private)
+        self.openssl_assert(res == 1)
+
+        evp_pkey = self._ec_cdata_to_evp_pkey(ec_cdata)
+
+        return _EllipticCurvePrivateKey(self, ec_cdata, evp_pkey)
+
+    def _ec_key_new_by_curve(self, curve: ec.EllipticCurve):
+        curve_nid = self._elliptic_curve_to_nid(curve)
+        return self._ec_key_new_by_curve_nid(curve_nid)
+
+    def _ec_key_new_by_curve_nid(self, curve_nid: int):
+        ec_cdata = self._lib.EC_KEY_new_by_curve_name(curve_nid)
+        self.openssl_assert(ec_cdata != self._ffi.NULL)
+        return self._ffi.gc(ec_cdata, self._lib.EC_KEY_free)
+
+    def elliptic_curve_exchange_algorithm_supported(
+        self, algorithm: ec.ECDH, curve: ec.EllipticCurve
+    ) -> bool:
+        if self._fips_enabled and not isinstance(
+            curve, self._fips_ecdh_curves
+        ):
+            return False
+
+        return self.elliptic_curve_supported(curve) and isinstance(
+            algorithm, ec.ECDH
+        )
+
+    def _ec_cdata_to_evp_pkey(self, ec_cdata):
+        evp_pkey = self._create_evp_pkey_gc()
+        res = self._lib.EVP_PKEY_set1_EC_KEY(evp_pkey, ec_cdata)
+        self.openssl_assert(res == 1)
+        return evp_pkey
+
+    def _elliptic_curve_to_nid(self, curve: ec.EllipticCurve) -> int:
+        """
+        Get the NID for a curve name.
+        """
+
+        curve_aliases = {"secp192r1": "prime192v1", "secp256r1": "prime256v1"}
+
+        curve_name = curve_aliases.get(curve.name, curve.name)
+
+        curve_nid = self._lib.OBJ_sn2nid(curve_name.encode())
+        if curve_nid == self._lib.NID_undef:
+            raise UnsupportedAlgorithm(
+                "{} is not a supported elliptic curve".format(curve.name),
+                _Reasons.UNSUPPORTED_ELLIPTIC_CURVE,
+            )
+        return curve_nid
+
+    @contextmanager
+    def _tmp_bn_ctx(self):
+        bn_ctx = self._lib.BN_CTX_new()
+        self.openssl_assert(bn_ctx != self._ffi.NULL)
+        bn_ctx = self._ffi.gc(bn_ctx, self._lib.BN_CTX_free)
+        self._lib.BN_CTX_start(bn_ctx)
+        try:
+            yield bn_ctx
+        finally:
+            self._lib.BN_CTX_end(bn_ctx)
+
+    def _ec_key_determine_group_get_func(self, ctx):
+        """
+        Given an EC_KEY determine the group and what function is required to
+        get point coordinates.
+        """
+        self.openssl_assert(ctx != self._ffi.NULL)
+
+        nid_two_field = self._lib.OBJ_sn2nid(b"characteristic-two-field")
+        self.openssl_assert(nid_two_field != self._lib.NID_undef)
+
+        group = self._lib.EC_KEY_get0_group(ctx)
+        self.openssl_assert(group != self._ffi.NULL)
+
+        method = self._lib.EC_GROUP_method_of(group)
+        self.openssl_assert(method != self._ffi.NULL)
+
+        nid = self._lib.EC_METHOD_get_field_type(method)
+        self.openssl_assert(nid != self._lib.NID_undef)
+
+        if nid == nid_two_field and self._lib.Cryptography_HAS_EC2M:
+            get_func = self._lib.EC_POINT_get_affine_coordinates_GF2m
+        else:
+            get_func = self._lib.EC_POINT_get_affine_coordinates_GFp
+
+        assert get_func
+
+        return get_func, group
+
+    def _ec_key_set_public_key_affine_coordinates(self, ctx, x: int, y: int):
+        """
+        Sets the public key point in the EC_KEY context to the affine x and y
+        values.
+        """
+
+        if x < 0 or y < 0:
+            raise ValueError(
+                "Invalid EC key. Both x and y must be non-negative."
+            )
+
+        x = self._ffi.gc(self._int_to_bn(x), self._lib.BN_free)
+        y = self._ffi.gc(self._int_to_bn(y), self._lib.BN_free)
+        res = self._lib.EC_KEY_set_public_key_affine_coordinates(ctx, x, y)
+        if res != 1:
+            self._consume_errors()
+            raise ValueError("Invalid EC key.")
+
+    def _private_key_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PrivateFormat,
+        encryption_algorithm: serialization.KeySerializationEncryption,
+        key,
+        evp_pkey,
+        cdata,
+    ) -> bytes:
+        # validate argument types
+        if not isinstance(encoding, serialization.Encoding):
+            raise TypeError("encoding must be an item from the Encoding enum")
+        if not isinstance(format, serialization.PrivateFormat):
+            raise TypeError(
+                "format must be an item from the PrivateFormat enum"
+            )
+        if not isinstance(
+            encryption_algorithm, serialization.KeySerializationEncryption
+        ):
+            raise TypeError(
+                "Encryption algorithm must be a KeySerializationEncryption "
+                "instance"
+            )
+
+        # validate password
+        if isinstance(encryption_algorithm, serialization.NoEncryption):
+            password = b""
+        elif isinstance(
+            encryption_algorithm, serialization.BestAvailableEncryption
+        ):
+            password = encryption_algorithm.password
+            if len(password) > 1023:
+                raise ValueError(
+                    "Passwords longer than 1023 bytes are not supported by "
+                    "this backend"
+                )
+        else:
+            raise ValueError("Unsupported encryption type")
+
+        # PKCS8 + PEM/DER
+        if format is serialization.PrivateFormat.PKCS8:
+            if encoding is serialization.Encoding.PEM:
+                write_bio = self._lib.PEM_write_bio_PKCS8PrivateKey
+            elif encoding is serialization.Encoding.DER:
+                write_bio = self._lib.i2d_PKCS8PrivateKey_bio
+            else:
+                raise ValueError("Unsupported encoding for PKCS8")
+            return self._private_key_bytes_via_bio(
+                write_bio, evp_pkey, password
+            )
+
+        # TraditionalOpenSSL + PEM/DER
+        if format is serialization.PrivateFormat.TraditionalOpenSSL:
+            if self._fips_enabled and not isinstance(
+                encryption_algorithm, serialization.NoEncryption
+            ):
+                raise ValueError(
+                    "Encrypted traditional OpenSSL format is not "
+                    "supported in FIPS mode."
+                )
+            key_type = self._lib.EVP_PKEY_id(evp_pkey)
+
+            if encoding is serialization.Encoding.PEM:
+                if key_type == self._lib.EVP_PKEY_RSA:
+                    write_bio = self._lib.PEM_write_bio_RSAPrivateKey
+                elif key_type == self._lib.EVP_PKEY_DSA:
+                    write_bio = self._lib.PEM_write_bio_DSAPrivateKey
+                elif key_type == self._lib.EVP_PKEY_EC:
+                    write_bio = self._lib.PEM_write_bio_ECPrivateKey
+                else:
+                    raise ValueError(
+                        "Unsupported key type for TraditionalOpenSSL"
+                    )
+                return self._private_key_bytes_via_bio(
+                    write_bio, cdata, password
+                )
+
+            if encoding is serialization.Encoding.DER:
+                if password:
+                    raise ValueError(
+                        "Encryption is not supported for DER encoded "
+                        "traditional OpenSSL keys"
+                    )
+                if key_type == self._lib.EVP_PKEY_RSA:
+                    write_bio = self._lib.i2d_RSAPrivateKey_bio
+                elif key_type == self._lib.EVP_PKEY_EC:
+                    write_bio = self._lib.i2d_ECPrivateKey_bio
+                elif key_type == self._lib.EVP_PKEY_DSA:
+                    write_bio = self._lib.i2d_DSAPrivateKey_bio
+                else:
+                    raise ValueError(
+                        "Unsupported key type for TraditionalOpenSSL"
+                    )
+                return self._bio_func_output(write_bio, cdata)
+
+            raise ValueError("Unsupported encoding for TraditionalOpenSSL")
+
+        # OpenSSH + PEM
+        if format is serialization.PrivateFormat.OpenSSH:
+            if encoding is serialization.Encoding.PEM:
+                return ssh.serialize_ssh_private_key(key, password)
+
+            raise ValueError(
+                "OpenSSH private key format can only be used"
+                " with PEM encoding"
+            )
+
+        # Anything that key-specific code was supposed to handle earlier,
+        # like Raw.
+        raise ValueError("format is invalid with this key")
+
+    def _private_key_bytes_via_bio(self, write_bio, evp_pkey, password):
+        if not password:
+            evp_cipher = self._ffi.NULL
+        else:
+            # This is a curated value that we will update over time.
+            evp_cipher = self._lib.EVP_get_cipherbyname(b"aes-256-cbc")
+
+        return self._bio_func_output(
+            write_bio,
+            evp_pkey,
+            evp_cipher,
+            password,
+            len(password),
+            self._ffi.NULL,
+            self._ffi.NULL,
+        )
+
+    def _bio_func_output(self, write_bio, *args):
+        bio = self._create_mem_bio_gc()
+        res = write_bio(bio, *args)
+        self.openssl_assert(res == 1)
+        return self._read_mem_bio(bio)
+
+    def _public_key_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PublicFormat,
+        key,
+        evp_pkey,
+        cdata,
+    ) -> bytes:
+        if not isinstance(encoding, serialization.Encoding):
+            raise TypeError("encoding must be an item from the Encoding enum")
+        if not isinstance(format, serialization.PublicFormat):
+            raise TypeError(
+                "format must be an item from the PublicFormat enum"
+            )
+
+        # SubjectPublicKeyInfo + PEM/DER
+        if format is serialization.PublicFormat.SubjectPublicKeyInfo:
+            if encoding is serialization.Encoding.PEM:
+                write_bio = self._lib.PEM_write_bio_PUBKEY
+            elif encoding is serialization.Encoding.DER:
+                write_bio = self._lib.i2d_PUBKEY_bio
+            else:
+                raise ValueError(
+                    "SubjectPublicKeyInfo works only with PEM or DER encoding"
+                )
+            return self._bio_func_output(write_bio, evp_pkey)
+
+        # PKCS1 + PEM/DER
+        if format is serialization.PublicFormat.PKCS1:
+            # Only RSA is supported here.
+            key_type = self._lib.EVP_PKEY_id(evp_pkey)
+            if key_type != self._lib.EVP_PKEY_RSA:
+                raise ValueError("PKCS1 format is supported only for RSA keys")
+
+            if encoding is serialization.Encoding.PEM:
+                write_bio = self._lib.PEM_write_bio_RSAPublicKey
+            elif encoding is serialization.Encoding.DER:
+                write_bio = self._lib.i2d_RSAPublicKey_bio
+            else:
+                raise ValueError("PKCS1 works only with PEM or DER encoding")
+            return self._bio_func_output(write_bio, cdata)
+
+        # OpenSSH + OpenSSH
+        if format is serialization.PublicFormat.OpenSSH:
+            if encoding is serialization.Encoding.OpenSSH:
+                return ssh.serialize_ssh_public_key(key)
+
+            raise ValueError(
+                "OpenSSH format must be used with OpenSSH encoding"
+            )
+
+        # Anything that key-specific code was supposed to handle earlier,
+        # like Raw, CompressedPoint, UncompressedPoint
+        raise ValueError("format is invalid with this key")
+
+    def dh_supported(self) -> bool:
+        return not self._lib.CRYPTOGRAPHY_IS_BORINGSSL
+
+    def generate_dh_parameters(
+        self, generator: int, key_size: int
+    ) -> dh.DHParameters:
+        if key_size < dh._MIN_MODULUS_SIZE:
+            raise ValueError(
+                "DH key_size must be at least {} bits".format(
+                    dh._MIN_MODULUS_SIZE
+                )
+            )
+
+        if generator not in (2, 5):
+            raise ValueError("DH generator must be 2 or 5")
+
+        dh_param_cdata = self._lib.DH_new()
+        self.openssl_assert(dh_param_cdata != self._ffi.NULL)
+        dh_param_cdata = self._ffi.gc(dh_param_cdata, self._lib.DH_free)
+
+        res = self._lib.DH_generate_parameters_ex(
+            dh_param_cdata, key_size, generator, self._ffi.NULL
+        )
+        self.openssl_assert(res == 1)
+
+        return _DHParameters(self, dh_param_cdata)
+
+    def _dh_cdata_to_evp_pkey(self, dh_cdata):
+        evp_pkey = self._create_evp_pkey_gc()
+        res = self._lib.EVP_PKEY_set1_DH(evp_pkey, dh_cdata)
+        self.openssl_assert(res == 1)
+        return evp_pkey
+
+    def generate_dh_private_key(
+        self, parameters: dh.DHParameters
+    ) -> dh.DHPrivateKey:
+        dh_key_cdata = _dh_params_dup(
+            parameters._dh_cdata, self  # type: ignore[attr-defined]
+        )
+
+        res = self._lib.DH_generate_key(dh_key_cdata)
+        self.openssl_assert(res == 1)
+
+        evp_pkey = self._dh_cdata_to_evp_pkey(dh_key_cdata)
+
+        return _DHPrivateKey(self, dh_key_cdata, evp_pkey)
+
+    def generate_dh_private_key_and_parameters(
+        self, generator: int, key_size: int
+    ) -> dh.DHPrivateKey:
+        return self.generate_dh_private_key(
+            self.generate_dh_parameters(generator, key_size)
+        )
+
+    def load_dh_private_numbers(
+        self, numbers: dh.DHPrivateNumbers
+    ) -> dh.DHPrivateKey:
+        parameter_numbers = numbers.public_numbers.parameter_numbers
+
+        dh_cdata = self._lib.DH_new()
+        self.openssl_assert(dh_cdata != self._ffi.NULL)
+        dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free)
+
+        p = self._int_to_bn(parameter_numbers.p)
+        g = self._int_to_bn(parameter_numbers.g)
+
+        if parameter_numbers.q is not None:
+            q = self._int_to_bn(parameter_numbers.q)
+        else:
+            q = self._ffi.NULL
+
+        pub_key = self._int_to_bn(numbers.public_numbers.y)
+        priv_key = self._int_to_bn(numbers.x)
+
+        res = self._lib.DH_set0_pqg(dh_cdata, p, q, g)
+        self.openssl_assert(res == 1)
+
+        res = self._lib.DH_set0_key(dh_cdata, pub_key, priv_key)
+        self.openssl_assert(res == 1)
+
+        codes = self._ffi.new("int[]", 1)
+        res = self._lib.Cryptography_DH_check(dh_cdata, codes)
+        self.openssl_assert(res == 1)
+
+        # DH_check will return DH_NOT_SUITABLE_GENERATOR if p % 24 does not
+        # equal 11 when the generator is 2 (a quadratic nonresidue).
+        # We want to ignore that error because p % 24 == 23 is also fine.
+        # Specifically, g is then a quadratic residue. Within the context of
+        # Diffie-Hellman this means it can only generate half the possible
+        # values. That sounds bad, but quadratic nonresidues leak a bit of
+        # the key to the attacker in exchange for having the full key space
+        # available. See: https://crypto.stackexchange.com/questions/12961
+        if codes[0] != 0 and not (
+            parameter_numbers.g == 2
+            and codes[0] ^ self._lib.DH_NOT_SUITABLE_GENERATOR == 0
+        ):
+            raise ValueError("DH private numbers did not pass safety checks.")
+
+        evp_pkey = self._dh_cdata_to_evp_pkey(dh_cdata)
+
+        return _DHPrivateKey(self, dh_cdata, evp_pkey)
+
+    def load_dh_public_numbers(
+        self, numbers: dh.DHPublicNumbers
+    ) -> dh.DHPublicKey:
+        dh_cdata = self._lib.DH_new()
+        self.openssl_assert(dh_cdata != self._ffi.NULL)
+        dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free)
+
+        parameter_numbers = numbers.parameter_numbers
+
+        p = self._int_to_bn(parameter_numbers.p)
+        g = self._int_to_bn(parameter_numbers.g)
+
+        if parameter_numbers.q is not None:
+            q = self._int_to_bn(parameter_numbers.q)
+        else:
+            q = self._ffi.NULL
+
+        pub_key = self._int_to_bn(numbers.y)
+
+        res = self._lib.DH_set0_pqg(dh_cdata, p, q, g)
+        self.openssl_assert(res == 1)
+
+        res = self._lib.DH_set0_key(dh_cdata, pub_key, self._ffi.NULL)
+        self.openssl_assert(res == 1)
+
+        evp_pkey = self._dh_cdata_to_evp_pkey(dh_cdata)
+
+        return _DHPublicKey(self, dh_cdata, evp_pkey)
+
+    def load_dh_parameter_numbers(
+        self, numbers: dh.DHParameterNumbers
+    ) -> dh.DHParameters:
+        dh_cdata = self._lib.DH_new()
+        self.openssl_assert(dh_cdata != self._ffi.NULL)
+        dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free)
+
+        p = self._int_to_bn(numbers.p)
+        g = self._int_to_bn(numbers.g)
+
+        if numbers.q is not None:
+            q = self._int_to_bn(numbers.q)
+        else:
+            q = self._ffi.NULL
+
+        res = self._lib.DH_set0_pqg(dh_cdata, p, q, g)
+        self.openssl_assert(res == 1)
+
+        return _DHParameters(self, dh_cdata)
+
+    def dh_parameters_supported(
+        self, p: int, g: int, q: typing.Optional[int] = None
+    ) -> bool:
+        dh_cdata = self._lib.DH_new()
+        self.openssl_assert(dh_cdata != self._ffi.NULL)
+        dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free)
+
+        p = self._int_to_bn(p)
+        g = self._int_to_bn(g)
+
+        if q is not None:
+            q = self._int_to_bn(q)
+        else:
+            q = self._ffi.NULL
+
+        res = self._lib.DH_set0_pqg(dh_cdata, p, q, g)
+        self.openssl_assert(res == 1)
+
+        codes = self._ffi.new("int[]", 1)
+        res = self._lib.Cryptography_DH_check(dh_cdata, codes)
+        self.openssl_assert(res == 1)
+
+        return codes[0] == 0
+
+    def dh_x942_serialization_supported(self) -> bool:
+        return self._lib.Cryptography_HAS_EVP_PKEY_DHX == 1
+
+    def x25519_load_public_bytes(self, data: bytes) -> x25519.X25519PublicKey:
+        # When we drop support for CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 we can
+        # switch this to EVP_PKEY_new_raw_public_key
+        if len(data) != 32:
+            raise ValueError("An X25519 public key is 32 bytes long")
+
+        evp_pkey = self._create_evp_pkey_gc()
+        res = self._lib.EVP_PKEY_set_type(evp_pkey, self._lib.NID_X25519)
+        self.openssl_assert(res == 1)
+        res = self._lib.EVP_PKEY_set1_tls_encodedpoint(
+            evp_pkey, data, len(data)
+        )
+        self.openssl_assert(res == 1)
+        return _X25519PublicKey(self, evp_pkey)
+
+    def x25519_load_private_bytes(
+        self, data: bytes
+    ) -> x25519.X25519PrivateKey:
+        # When we drop support for CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 we can
+        # switch this to EVP_PKEY_new_raw_private_key and drop the
+        # zeroed_bytearray garbage.
+        # OpenSSL only has facilities for loading PKCS8 formatted private
+        # keys using the algorithm identifiers specified in
+        # https://tools.ietf.org/html/draft-ietf-curdle-pkix-09.
+        # This is the standard PKCS8 prefix for a 32 byte X25519 key.
+        # The form is:
+        #    0:d=0  hl=2 l=  46 cons: SEQUENCE
+        #    2:d=1  hl=2 l=   1 prim: INTEGER           :00
+        #    5:d=1  hl=2 l=   5 cons: SEQUENCE
+        #    7:d=2  hl=2 l=   3 prim: OBJECT            :1.3.101.110
+        #    12:d=1  hl=2 l=  34 prim: OCTET STRING      (the key)
+        # Of course there's a bit more complexity. In reality OCTET STRING
+        # contains an OCTET STRING of length 32! So the last two bytes here
+        # are \x04\x20, which is an OCTET STRING of length 32.
+        if len(data) != 32:
+            raise ValueError("An X25519 private key is 32 bytes long")
+
+        pkcs8_prefix = b'0.\x02\x01\x000\x05\x06\x03+en\x04"\x04 '
+        with self._zeroed_bytearray(48) as ba:
+            ba[0:16] = pkcs8_prefix
+            ba[16:] = data
+            bio = self._bytes_to_bio(ba)
+            evp_pkey = self._lib.d2i_PrivateKey_bio(bio.bio, self._ffi.NULL)
+
+        self.openssl_assert(evp_pkey != self._ffi.NULL)
+        evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free)
+        self.openssl_assert(
+            self._lib.EVP_PKEY_id(evp_pkey) == self._lib.EVP_PKEY_X25519
+        )
+        return _X25519PrivateKey(self, evp_pkey)
+
+    def _evp_pkey_keygen_gc(self, nid):
+        evp_pkey_ctx = self._lib.EVP_PKEY_CTX_new_id(nid, self._ffi.NULL)
+        self.openssl_assert(evp_pkey_ctx != self._ffi.NULL)
+        evp_pkey_ctx = self._ffi.gc(evp_pkey_ctx, self._lib.EVP_PKEY_CTX_free)
+        res = self._lib.EVP_PKEY_keygen_init(evp_pkey_ctx)
+        self.openssl_assert(res == 1)
+        evp_ppkey = self._ffi.new("EVP_PKEY **")
+        res = self._lib.EVP_PKEY_keygen(evp_pkey_ctx, evp_ppkey)
+        self.openssl_assert(res == 1)
+        self.openssl_assert(evp_ppkey[0] != self._ffi.NULL)
+        evp_pkey = self._ffi.gc(evp_ppkey[0], self._lib.EVP_PKEY_free)
+        return evp_pkey
+
+    def x25519_generate_key(self) -> x25519.X25519PrivateKey:
+        evp_pkey = self._evp_pkey_keygen_gc(self._lib.NID_X25519)
+        return _X25519PrivateKey(self, evp_pkey)
+
+    def x25519_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return not self._lib.CRYPTOGRAPHY_IS_LIBRESSL
+
+    def x448_load_public_bytes(self, data: bytes) -> x448.X448PublicKey:
+        if len(data) != 56:
+            raise ValueError("An X448 public key is 56 bytes long")
+
+        evp_pkey = self._lib.EVP_PKEY_new_raw_public_key(
+            self._lib.NID_X448, self._ffi.NULL, data, len(data)
+        )
+        self.openssl_assert(evp_pkey != self._ffi.NULL)
+        evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free)
+        return _X448PublicKey(self, evp_pkey)
+
+    def x448_load_private_bytes(self, data: bytes) -> x448.X448PrivateKey:
+        if len(data) != 56:
+            raise ValueError("An X448 private key is 56 bytes long")
+
+        data_ptr = self._ffi.from_buffer(data)
+        evp_pkey = self._lib.EVP_PKEY_new_raw_private_key(
+            self._lib.NID_X448, self._ffi.NULL, data_ptr, len(data)
+        )
+        self.openssl_assert(evp_pkey != self._ffi.NULL)
+        evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free)
+        return _X448PrivateKey(self, evp_pkey)
+
+    def x448_generate_key(self) -> x448.X448PrivateKey:
+        evp_pkey = self._evp_pkey_keygen_gc(self._lib.NID_X448)
+        return _X448PrivateKey(self, evp_pkey)
+
+    def x448_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return (
+            not self._lib.CRYPTOGRAPHY_OPENSSL_LESS_THAN_111
+            and not self._lib.CRYPTOGRAPHY_IS_BORINGSSL
+        )
+
+    def ed25519_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return not self._lib.CRYPTOGRAPHY_OPENSSL_LESS_THAN_111B
+
+    def ed25519_load_public_bytes(
+        self, data: bytes
+    ) -> ed25519.Ed25519PublicKey:
+        utils._check_bytes("data", data)
+
+        if len(data) != ed25519._ED25519_KEY_SIZE:
+            raise ValueError("An Ed25519 public key is 32 bytes long")
+
+        evp_pkey = self._lib.EVP_PKEY_new_raw_public_key(
+            self._lib.NID_ED25519, self._ffi.NULL, data, len(data)
+        )
+        self.openssl_assert(evp_pkey != self._ffi.NULL)
+        evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free)
+
+        return _Ed25519PublicKey(self, evp_pkey)
+
+    def ed25519_load_private_bytes(
+        self, data: bytes
+    ) -> ed25519.Ed25519PrivateKey:
+        if len(data) != ed25519._ED25519_KEY_SIZE:
+            raise ValueError("An Ed25519 private key is 32 bytes long")
+
+        utils._check_byteslike("data", data)
+        data_ptr = self._ffi.from_buffer(data)
+        evp_pkey = self._lib.EVP_PKEY_new_raw_private_key(
+            self._lib.NID_ED25519, self._ffi.NULL, data_ptr, len(data)
+        )
+        self.openssl_assert(evp_pkey != self._ffi.NULL)
+        evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free)
+
+        return _Ed25519PrivateKey(self, evp_pkey)
+
+    def ed25519_generate_key(self) -> ed25519.Ed25519PrivateKey:
+        evp_pkey = self._evp_pkey_keygen_gc(self._lib.NID_ED25519)
+        return _Ed25519PrivateKey(self, evp_pkey)
+
+    def ed448_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return (
+            not self._lib.CRYPTOGRAPHY_OPENSSL_LESS_THAN_111B
+            and not self._lib.CRYPTOGRAPHY_IS_BORINGSSL
+        )
+
+    def ed448_load_public_bytes(self, data: bytes) -> ed448.Ed448PublicKey:
+        utils._check_bytes("data", data)
+        if len(data) != _ED448_KEY_SIZE:
+            raise ValueError("An Ed448 public key is 57 bytes long")
+
+        evp_pkey = self._lib.EVP_PKEY_new_raw_public_key(
+            self._lib.NID_ED448, self._ffi.NULL, data, len(data)
+        )
+        self.openssl_assert(evp_pkey != self._ffi.NULL)
+        evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free)
+
+        return _Ed448PublicKey(self, evp_pkey)
+
+    def ed448_load_private_bytes(self, data: bytes) -> ed448.Ed448PrivateKey:
+        utils._check_byteslike("data", data)
+        if len(data) != _ED448_KEY_SIZE:
+            raise ValueError("An Ed448 private key is 57 bytes long")
+
+        data_ptr = self._ffi.from_buffer(data)
+        evp_pkey = self._lib.EVP_PKEY_new_raw_private_key(
+            self._lib.NID_ED448, self._ffi.NULL, data_ptr, len(data)
+        )
+        self.openssl_assert(evp_pkey != self._ffi.NULL)
+        evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free)
+
+        return _Ed448PrivateKey(self, evp_pkey)
+
+    def ed448_generate_key(self) -> ed448.Ed448PrivateKey:
+        evp_pkey = self._evp_pkey_keygen_gc(self._lib.NID_ED448)
+        return _Ed448PrivateKey(self, evp_pkey)
+
+    def derive_scrypt(
+        self,
+        key_material: bytes,
+        salt: bytes,
+        length: int,
+        n: int,
+        r: int,
+        p: int,
+    ) -> bytes:
+        buf = self._ffi.new("unsigned char[]", length)
+        key_material_ptr = self._ffi.from_buffer(key_material)
+        res = self._lib.EVP_PBE_scrypt(
+            key_material_ptr,
+            len(key_material),
+            salt,
+            len(salt),
+            n,
+            r,
+            p,
+            scrypt._MEM_LIMIT,
+            buf,
+            length,
+        )
+        if res != 1:
+            errors = self._consume_errors_with_text()
+            # memory required formula explained here:
+            # https://blog.filippo.io/the-scrypt-parameters/
+            min_memory = 128 * n * r // (1024**2)
+            raise MemoryError(
+                "Not enough memory to derive key. These parameters require"
+                " {} MB of memory.".format(min_memory),
+                errors,
+            )
+        return self._ffi.buffer(buf)[:]
+
+    def aead_cipher_supported(self, cipher) -> bool:
+        cipher_name = aead._aead_cipher_name(cipher)
+        if self._fips_enabled and cipher_name not in self._fips_aead:
+            return False
+        # SIV isn't loaded through get_cipherbyname but instead a new fetch API
+        # only available in 3.0+. But if we know we're on 3.0+ then we know
+        # it's supported.
+        if cipher_name.endswith(b"-siv"):
+            return self._lib.CRYPTOGRAPHY_OPENSSL_300_OR_GREATER == 1
+        else:
+            return (
+                self._lib.EVP_get_cipherbyname(cipher_name) != self._ffi.NULL
+            )
+
+    @contextlib.contextmanager
+    def _zeroed_bytearray(self, length: int) -> typing.Iterator[bytearray]:
+        """
+        This method creates a bytearray, which we copy data into (hopefully
+        also from a mutable buffer that can be dynamically erased!), and then
+        zero when we're done.
+        """
+        ba = bytearray(length)
+        try:
+            yield ba
+        finally:
+            self._zero_data(ba, length)
+
+    def _zero_data(self, data, length: int) -> None:
+        # We clear things this way because at the moment we're not
+        # sure of a better way that can guarantee it overwrites the
+        # memory of a bytearray and doesn't just replace the underlying char *.
+        for i in range(length):
+            data[i] = 0
+
+    @contextlib.contextmanager
+    def _zeroed_null_terminated_buf(self, data):
+        """
+        This method takes bytes, which can be a bytestring or a mutable
+        buffer like a bytearray, and yields a null-terminated version of that
+        data. This is required because PKCS12_parse doesn't take a length with
+        its password char * and ffi.from_buffer doesn't provide null
+        termination. So, to support zeroing the data via bytearray we
+        need to build this ridiculous construct that copies the memory, but
+        zeroes it after use.
+        """
+        if data is None:
+            yield self._ffi.NULL
+        else:
+            data_len = len(data)
+            buf = self._ffi.new("char[]", data_len + 1)
+            self._ffi.memmove(buf, data, data_len)
+            try:
+                yield buf
+            finally:
+                # Cast to a uint8_t * so we can assign by integer
+                self._zero_data(self._ffi.cast("uint8_t *", buf), data_len)
+
+    def load_key_and_certificates_from_pkcs12(
+        self, data: bytes, password: typing.Optional[bytes]
+    ) -> typing.Tuple[
+        typing.Optional[PRIVATE_KEY_TYPES],
+        typing.Optional[x509.Certificate],
+        typing.List[x509.Certificate],
+    ]:
+        pkcs12 = self.load_pkcs12(data, password)
+        return (
+            pkcs12.key,
+            pkcs12.cert.certificate if pkcs12.cert else None,
+            [cert.certificate for cert in pkcs12.additional_certs],
+        )
+
+    def load_pkcs12(
+        self, data: bytes, password: typing.Optional[bytes]
+    ) -> PKCS12KeyAndCertificates:
+        if password is not None:
+            utils._check_byteslike("password", password)
+
+        bio = self._bytes_to_bio(data)
+        p12 = self._lib.d2i_PKCS12_bio(bio.bio, self._ffi.NULL)
+        if p12 == self._ffi.NULL:
+            self._consume_errors()
+            raise ValueError("Could not deserialize PKCS12 data")
+
+        p12 = self._ffi.gc(p12, self._lib.PKCS12_free)
+        evp_pkey_ptr = self._ffi.new("EVP_PKEY **")
+        x509_ptr = self._ffi.new("X509 **")
+        sk_x509_ptr = self._ffi.new("Cryptography_STACK_OF_X509 **")
+        with self._zeroed_null_terminated_buf(password) as password_buf:
+            res = self._lib.PKCS12_parse(
+                p12, password_buf, evp_pkey_ptr, x509_ptr, sk_x509_ptr
+            )
+
+        # Workaround for
+        # https://github.com/libressl-portable/portable/issues/659
+        if self._lib.CRYPTOGRAPHY_LIBRESSL_LESS_THAN_340:
+            self._consume_errors()
+
+        if res == 0:
+            self._consume_errors()
+            raise ValueError("Invalid password or PKCS12 data")
+
+        cert = None
+        key = None
+        additional_certificates = []
+
+        if evp_pkey_ptr[0] != self._ffi.NULL:
+            evp_pkey = self._ffi.gc(evp_pkey_ptr[0], self._lib.EVP_PKEY_free)
+            key = self._evp_pkey_to_private_key(evp_pkey)
+
+        if x509_ptr[0] != self._ffi.NULL:
+            x509 = self._ffi.gc(x509_ptr[0], self._lib.X509_free)
+            cert_obj = self._ossl2cert(x509)
+            name = None
+            maybe_name = self._lib.X509_alias_get0(x509, self._ffi.NULL)
+            if maybe_name != self._ffi.NULL:
+                name = self._ffi.string(maybe_name)
+            cert = PKCS12Certificate(cert_obj, name)
+
+        if sk_x509_ptr[0] != self._ffi.NULL:
+            sk_x509 = self._ffi.gc(sk_x509_ptr[0], self._lib.sk_X509_free)
+            num = self._lib.sk_X509_num(sk_x509_ptr[0])
+
+            # In OpenSSL < 3.0.0 PKCS12 parsing reverses the order of the
+            # certificates.
+            indices: typing.Iterable[int]
+            if (
+                self._lib.CRYPTOGRAPHY_OPENSSL_300_OR_GREATER
+                or self._lib.CRYPTOGRAPHY_IS_BORINGSSL
+            ):
+                indices = range(num)
+            else:
+                indices = reversed(range(num))
+
+            for i in indices:
+                x509 = self._lib.sk_X509_value(sk_x509, i)
+                self.openssl_assert(x509 != self._ffi.NULL)
+                x509 = self._ffi.gc(x509, self._lib.X509_free)
+                addl_cert = self._ossl2cert(x509)
+                addl_name = None
+                maybe_name = self._lib.X509_alias_get0(x509, self._ffi.NULL)
+                if maybe_name != self._ffi.NULL:
+                    addl_name = self._ffi.string(maybe_name)
+                additional_certificates.append(
+                    PKCS12Certificate(addl_cert, addl_name)
+                )
+
+        return PKCS12KeyAndCertificates(key, cert, additional_certificates)
+
+    def serialize_key_and_certificates_to_pkcs12(
+        self,
+        name: typing.Optional[bytes],
+        key: typing.Optional[_ALLOWED_PKCS12_TYPES],
+        cert: typing.Optional[x509.Certificate],
+        cas: typing.Optional[typing.List[_PKCS12_CAS_TYPES]],
+        encryption_algorithm: serialization.KeySerializationEncryption,
+    ) -> bytes:
+        password = None
+        if name is not None:
+            utils._check_bytes("name", name)
+
+        if isinstance(encryption_algorithm, serialization.NoEncryption):
+            nid_cert = -1
+            nid_key = -1
+            pkcs12_iter = 0
+            mac_iter = 0
+        elif isinstance(
+            encryption_algorithm, serialization.BestAvailableEncryption
+        ):
+            # PKCS12 encryption is hopeless trash and can never be fixed.
+            # This is the least terrible option.
+            nid_cert = self._lib.NID_pbe_WithSHA1And3_Key_TripleDES_CBC
+            nid_key = self._lib.NID_pbe_WithSHA1And3_Key_TripleDES_CBC
+            # At least we can set this higher than OpenSSL's default
+            pkcs12_iter = 20000
+            # mac_iter chosen for compatibility reasons, see:
+            # https://www.openssl.org/docs/man1.1.1/man3/PKCS12_create.html
+            # Did we mention how lousy PKCS12 encryption is?
+            mac_iter = 1
+            password = encryption_algorithm.password
+        else:
+            raise ValueError("Unsupported key encryption type")
+
+        if cas is None or len(cas) == 0:
+            sk_x509 = self._ffi.NULL
+        else:
+            sk_x509 = self._lib.sk_X509_new_null()
+            sk_x509 = self._ffi.gc(sk_x509, self._lib.sk_X509_free)
+
+            # This list is to keep the x509 values alive until end of function
+            ossl_cas = []
+            for ca in cas:
+                if isinstance(ca, PKCS12Certificate):
+                    ca_alias = ca.friendly_name
+                    ossl_ca = self._cert2ossl(ca.certificate)
+                    with self._zeroed_null_terminated_buf(
+                        ca_alias
+                    ) as ca_name_buf:
+                        res = self._lib.X509_alias_set1(
+                            ossl_ca, ca_name_buf, -1
+                        )
+                        self.openssl_assert(res == 1)
+                else:
+                    ossl_ca = self._cert2ossl(ca)
+                ossl_cas.append(ossl_ca)
+                res = self._lib.sk_X509_push(sk_x509, ossl_ca)
+                backend.openssl_assert(res >= 1)
+
+        with self._zeroed_null_terminated_buf(password) as password_buf:
+            with self._zeroed_null_terminated_buf(name) as name_buf:
+                ossl_cert = self._cert2ossl(cert) if cert else self._ffi.NULL
+                if key is not None:
+                    evp_pkey = key._evp_pkey  # type: ignore[union-attr]
+                else:
+                    evp_pkey = self._ffi.NULL
+
+                p12 = self._lib.PKCS12_create(
+                    password_buf,
+                    name_buf,
+                    evp_pkey,
+                    ossl_cert,
+                    sk_x509,
+                    nid_key,
+                    nid_cert,
+                    pkcs12_iter,
+                    mac_iter,
+                    0,
+                )
+
+        self.openssl_assert(p12 != self._ffi.NULL)
+        p12 = self._ffi.gc(p12, self._lib.PKCS12_free)
+
+        bio = self._create_mem_bio_gc()
+        res = self._lib.i2d_PKCS12_bio(bio, p12)
+        self.openssl_assert(res > 0)
+        return self._read_mem_bio(bio)
+
+    def poly1305_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return self._lib.Cryptography_HAS_POLY1305 == 1
+
+    def create_poly1305_ctx(self, key: bytes) -> _Poly1305Context:
+        utils._check_byteslike("key", key)
+        if len(key) != _POLY1305_KEY_SIZE:
+            raise ValueError("A poly1305 key is 32 bytes long")
+
+        return _Poly1305Context(self, key)
+
+    def pkcs7_supported(self) -> bool:
+        return not self._lib.CRYPTOGRAPHY_IS_BORINGSSL
+
+    def load_pem_pkcs7_certificates(
+        self, data: bytes
+    ) -> typing.List[x509.Certificate]:
+        utils._check_bytes("data", data)
+        bio = self._bytes_to_bio(data)
+        p7 = self._lib.PEM_read_bio_PKCS7(
+            bio.bio, self._ffi.NULL, self._ffi.NULL, self._ffi.NULL
+        )
+        if p7 == self._ffi.NULL:
+            self._consume_errors()
+            raise ValueError("Unable to parse PKCS7 data")
+
+        p7 = self._ffi.gc(p7, self._lib.PKCS7_free)
+        return self._load_pkcs7_certificates(p7)
+
+    def load_der_pkcs7_certificates(
+        self, data: bytes
+    ) -> typing.List[x509.Certificate]:
+        utils._check_bytes("data", data)
+        bio = self._bytes_to_bio(data)
+        p7 = self._lib.d2i_PKCS7_bio(bio.bio, self._ffi.NULL)
+        if p7 == self._ffi.NULL:
+            self._consume_errors()
+            raise ValueError("Unable to parse PKCS7 data")
+
+        p7 = self._ffi.gc(p7, self._lib.PKCS7_free)
+        return self._load_pkcs7_certificates(p7)
+
+    def _load_pkcs7_certificates(self, p7):
+        nid = self._lib.OBJ_obj2nid(p7.type)
+        self.openssl_assert(nid != self._lib.NID_undef)
+        if nid != self._lib.NID_pkcs7_signed:
+            raise UnsupportedAlgorithm(
+                "Only basic signed structures are currently supported. NID"
+                " for this data was {}".format(nid),
+                _Reasons.UNSUPPORTED_SERIALIZATION,
+            )
+
+        sk_x509 = p7.d.sign.cert
+        num = self._lib.sk_X509_num(sk_x509)
+        certs = []
+        for i in range(num):
+            x509 = self._lib.sk_X509_value(sk_x509, i)
+            self.openssl_assert(x509 != self._ffi.NULL)
+            res = self._lib.X509_up_ref(x509)
+            # When OpenSSL is less than 1.1.0 up_ref returns the current
+            # refcount. On 1.1.0+ it returns 1 for success.
+            self.openssl_assert(res >= 1)
+            x509 = self._ffi.gc(x509, self._lib.X509_free)
+            cert = self._ossl2cert(x509)
+            certs.append(cert)
+
+        return certs
+
+    def pkcs7_serialize_certificates(
+        self,
+        certs: typing.List[x509.Certificate],
+        encoding: serialization.Encoding,
+    ):
+        certs = list(certs)
+        if not certs or not all(
+            isinstance(cert, x509.Certificate) for cert in certs
+        ):
+            raise TypeError("certs must be a list of certs with length >= 1")
+
+        if encoding not in (
+            serialization.Encoding.PEM,
+            serialization.Encoding.DER,
+        ):
+            raise TypeError("encoding must DER or PEM from the Encoding enum")
+
+        certs_sk = self._lib.sk_X509_new_null()
+        certs_sk = self._ffi.gc(certs_sk, self._lib.sk_X509_free)
+        # This list is to keep the x509 values alive until end of function
+        ossl_certs = []
+        for cert in certs:
+            ossl_cert = self._cert2ossl(cert)
+            ossl_certs.append(ossl_cert)
+            res = self._lib.sk_X509_push(certs_sk, ossl_cert)
+            self.openssl_assert(res >= 1)
+        # We use PKCS7_sign here because it creates the PKCS7 and PKCS7_SIGNED
+        # structures for us rather than requiring manual assignment.
+        p7 = self._lib.PKCS7_sign(
+            self._ffi.NULL,
+            self._ffi.NULL,
+            certs_sk,
+            self._ffi.NULL,
+            self._lib.PKCS7_PARTIAL,
+        )
+        bio_out = self._create_mem_bio_gc()
+        if encoding is serialization.Encoding.PEM:
+            res = self._lib.PEM_write_bio_PKCS7_stream(
+                bio_out, p7, self._ffi.NULL, 0
+            )
+        else:
+            assert encoding is serialization.Encoding.DER
+            res = self._lib.i2d_PKCS7_bio(bio_out, p7)
+
+        self.openssl_assert(res == 1)
+        return self._read_mem_bio(bio_out)
+
+    def pkcs7_sign(
+        self,
+        builder: pkcs7.PKCS7SignatureBuilder,
+        encoding: serialization.Encoding,
+        options: typing.List[pkcs7.PKCS7Options],
+    ) -> bytes:
+        assert builder._data is not None
+        bio = self._bytes_to_bio(builder._data)
+        init_flags = self._lib.PKCS7_PARTIAL
+        final_flags = 0
+
+        if len(builder._additional_certs) == 0:
+            certs = self._ffi.NULL
+        else:
+            certs = self._lib.sk_X509_new_null()
+            certs = self._ffi.gc(certs, self._lib.sk_X509_free)
+            # This list is to keep the x509 values alive until end of function
+            ossl_certs = []
+            for cert in builder._additional_certs:
+                ossl_cert = self._cert2ossl(cert)
+                ossl_certs.append(ossl_cert)
+                res = self._lib.sk_X509_push(certs, ossl_cert)
+                self.openssl_assert(res >= 1)
+
+        if pkcs7.PKCS7Options.DetachedSignature in options:
+            # Don't embed the data in the PKCS7 structure
+            init_flags |= self._lib.PKCS7_DETACHED
+            final_flags |= self._lib.PKCS7_DETACHED
+
+        # This just inits a structure for us. However, there
+        # are flags we need to set, joy.
+        p7 = self._lib.PKCS7_sign(
+            self._ffi.NULL,
+            self._ffi.NULL,
+            certs,
+            self._ffi.NULL,
+            init_flags,
+        )
+        self.openssl_assert(p7 != self._ffi.NULL)
+        p7 = self._ffi.gc(p7, self._lib.PKCS7_free)
+        signer_flags = 0
+        # These flags are configurable on a per-signature basis
+        # but we've deliberately chosen to make the API only allow
+        # setting it across all signatures for now.
+        if pkcs7.PKCS7Options.NoCapabilities in options:
+            signer_flags |= self._lib.PKCS7_NOSMIMECAP
+        elif pkcs7.PKCS7Options.NoAttributes in options:
+            signer_flags |= self._lib.PKCS7_NOATTR
+
+        if pkcs7.PKCS7Options.NoCerts in options:
+            signer_flags |= self._lib.PKCS7_NOCERTS
+
+        for certificate, private_key, hash_algorithm in builder._signers:
+            ossl_cert = self._cert2ossl(certificate)
+            md = self._evp_md_non_null_from_algorithm(hash_algorithm)
+            p7signerinfo = self._lib.PKCS7_sign_add_signer(
+                p7,
+                ossl_cert,
+                private_key._evp_pkey,  # type: ignore[union-attr]
+                md,
+                signer_flags,
+            )
+            self.openssl_assert(p7signerinfo != self._ffi.NULL)
+
+        for option in options:
+            # DetachedSignature, NoCapabilities, and NoAttributes are already
+            # handled so we just need to check these last two options.
+            if option is pkcs7.PKCS7Options.Text:
+                final_flags |= self._lib.PKCS7_TEXT
+            elif option is pkcs7.PKCS7Options.Binary:
+                final_flags |= self._lib.PKCS7_BINARY
+
+        bio_out = self._create_mem_bio_gc()
+        if encoding is serialization.Encoding.SMIME:
+            # This finalizes the structure
+            res = self._lib.SMIME_write_PKCS7(
+                bio_out, p7, bio.bio, final_flags
+            )
+        elif encoding is serialization.Encoding.PEM:
+            res = self._lib.PKCS7_final(p7, bio.bio, final_flags)
+            self.openssl_assert(res == 1)
+            res = self._lib.PEM_write_bio_PKCS7_stream(
+                bio_out, p7, bio.bio, final_flags
+            )
+        else:
+            assert encoding is serialization.Encoding.DER
+            # We need to call finalize here becauase i2d_PKCS7_bio does not
+            # finalize.
+            res = self._lib.PKCS7_final(p7, bio.bio, final_flags)
+            self.openssl_assert(res == 1)
+            # OpenSSL 3.0 leaves a random bio error on the stack:
+            # https://github.com/openssl/openssl/issues/16681
+            if self._lib.CRYPTOGRAPHY_OPENSSL_300_OR_GREATER:
+                self._consume_errors()
+            res = self._lib.i2d_PKCS7_bio(bio_out, p7)
+        self.openssl_assert(res == 1)
+        return self._read_mem_bio(bio_out)
+
+
+class GetCipherByName:
+    def __init__(self, fmt: str):
+        self._fmt = fmt
+
+    def __call__(self, backend: Backend, cipher: CipherAlgorithm, mode: Mode):
+        cipher_name = self._fmt.format(cipher=cipher, mode=mode).lower()
+        return backend._lib.EVP_get_cipherbyname(cipher_name.encode("ascii"))
+
+
+def _get_xts_cipher(backend: Backend, cipher: AES, mode):
+    cipher_name = "aes-{}-xts".format(cipher.key_size // 2)
+    return backend._lib.EVP_get_cipherbyname(cipher_name.encode("ascii"))
+
+
+backend = Backend()
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ciphers.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ciphers.py
new file mode 100644
index 0000000..1058de9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ciphers.py
@@ -0,0 +1,282 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.exceptions import InvalidTag, UnsupportedAlgorithm, _Reasons
+from cryptography.hazmat.primitives import ciphers
+from cryptography.hazmat.primitives.ciphers import algorithms, modes
+
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+class _CipherContext:
+    _ENCRYPT = 1
+    _DECRYPT = 0
+    _MAX_CHUNK_SIZE = 2**30 - 1
+
+    def __init__(
+        self, backend: "Backend", cipher, mode, operation: int
+    ) -> None:
+        self._backend = backend
+        self._cipher = cipher
+        self._mode = mode
+        self._operation = operation
+        self._tag: typing.Optional[bytes] = None
+
+        if isinstance(self._cipher, ciphers.BlockCipherAlgorithm):
+            self._block_size_bytes = self._cipher.block_size // 8
+        else:
+            self._block_size_bytes = 1
+
+        ctx = self._backend._lib.EVP_CIPHER_CTX_new()
+        ctx = self._backend._ffi.gc(
+            ctx, self._backend._lib.EVP_CIPHER_CTX_free
+        )
+
+        registry = self._backend._cipher_registry
+        try:
+            adapter = registry[type(cipher), type(mode)]
+        except KeyError:
+            raise UnsupportedAlgorithm(
+                "cipher {} in {} mode is not supported "
+                "by this backend.".format(
+                    cipher.name, mode.name if mode else mode
+                ),
+                _Reasons.UNSUPPORTED_CIPHER,
+            )
+
+        evp_cipher = adapter(self._backend, cipher, mode)
+        if evp_cipher == self._backend._ffi.NULL:
+            msg = "cipher {0.name} ".format(cipher)
+            if mode is not None:
+                msg += "in {0.name} mode ".format(mode)
+            msg += (
+                "is not supported by this backend (Your version of OpenSSL "
+                "may be too old. Current version: {}.)"
+            ).format(self._backend.openssl_version_text())
+            raise UnsupportedAlgorithm(msg, _Reasons.UNSUPPORTED_CIPHER)
+
+        if isinstance(mode, modes.ModeWithInitializationVector):
+            iv_nonce = self._backend._ffi.from_buffer(
+                mode.initialization_vector
+            )
+        elif isinstance(mode, modes.ModeWithTweak):
+            iv_nonce = self._backend._ffi.from_buffer(mode.tweak)
+        elif isinstance(mode, modes.ModeWithNonce):
+            iv_nonce = self._backend._ffi.from_buffer(mode.nonce)
+        elif isinstance(cipher, algorithms.ChaCha20):
+            iv_nonce = self._backend._ffi.from_buffer(cipher.nonce)
+        else:
+            iv_nonce = self._backend._ffi.NULL
+        # begin init with cipher and operation type
+        res = self._backend._lib.EVP_CipherInit_ex(
+            ctx,
+            evp_cipher,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            operation,
+        )
+        self._backend.openssl_assert(res != 0)
+        # set the key length to handle variable key ciphers
+        res = self._backend._lib.EVP_CIPHER_CTX_set_key_length(
+            ctx, len(cipher.key)
+        )
+        self._backend.openssl_assert(res != 0)
+        if isinstance(mode, modes.GCM):
+            res = self._backend._lib.EVP_CIPHER_CTX_ctrl(
+                ctx,
+                self._backend._lib.EVP_CTRL_AEAD_SET_IVLEN,
+                len(iv_nonce),
+                self._backend._ffi.NULL,
+            )
+            self._backend.openssl_assert(res != 0)
+            if mode.tag is not None:
+                res = self._backend._lib.EVP_CIPHER_CTX_ctrl(
+                    ctx,
+                    self._backend._lib.EVP_CTRL_AEAD_SET_TAG,
+                    len(mode.tag),
+                    mode.tag,
+                )
+                self._backend.openssl_assert(res != 0)
+                self._tag = mode.tag
+
+        # pass key/iv
+        res = self._backend._lib.EVP_CipherInit_ex(
+            ctx,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._backend._ffi.from_buffer(cipher.key),
+            iv_nonce,
+            operation,
+        )
+
+        # Check for XTS mode duplicate keys error
+        errors = self._backend._consume_errors()
+        lib = self._backend._lib
+        if res == 0 and (
+            (
+                lib.CRYPTOGRAPHY_OPENSSL_111D_OR_GREATER
+                and errors[0]._lib_reason_match(
+                    lib.ERR_LIB_EVP, lib.EVP_R_XTS_DUPLICATED_KEYS
+                )
+            )
+            or (
+                lib.Cryptography_HAS_PROVIDERS
+                and errors[0]._lib_reason_match(
+                    lib.ERR_LIB_PROV, lib.PROV_R_XTS_DUPLICATED_KEYS
+                )
+            )
+        ):
+            raise ValueError("In XTS mode duplicated keys are not allowed")
+
+        self._backend.openssl_assert(res != 0, errors=errors)
+
+        # We purposely disable padding here as it's handled higher up in the
+        # API.
+        self._backend._lib.EVP_CIPHER_CTX_set_padding(ctx, 0)
+        self._ctx = ctx
+
+    def update(self, data: bytes) -> bytes:
+        buf = bytearray(len(data) + self._block_size_bytes - 1)
+        n = self.update_into(data, buf)
+        return bytes(buf[:n])
+
+    def update_into(self, data: bytes, buf: bytes) -> int:
+        total_data_len = len(data)
+        if len(buf) < (total_data_len + self._block_size_bytes - 1):
+            raise ValueError(
+                "buffer must be at least {} bytes for this "
+                "payload".format(len(data) + self._block_size_bytes - 1)
+            )
+
+        data_processed = 0
+        total_out = 0
+        outlen = self._backend._ffi.new("int *")
+        baseoutbuf = self._backend._ffi.from_buffer(buf)
+        baseinbuf = self._backend._ffi.from_buffer(data)
+
+        while data_processed != total_data_len:
+            outbuf = baseoutbuf + total_out
+            inbuf = baseinbuf + data_processed
+            inlen = min(self._MAX_CHUNK_SIZE, total_data_len - data_processed)
+
+            res = self._backend._lib.EVP_CipherUpdate(
+                self._ctx, outbuf, outlen, inbuf, inlen
+            )
+            if res == 0 and isinstance(self._mode, modes.XTS):
+                self._backend._consume_errors()
+                raise ValueError(
+                    "In XTS mode you must supply at least a full block in the "
+                    "first update call. For AES this is 16 bytes."
+                )
+            else:
+                self._backend.openssl_assert(res != 0)
+            data_processed += inlen
+            total_out += outlen[0]
+
+        return total_out
+
+    def finalize(self) -> bytes:
+        if (
+            self._operation == self._DECRYPT
+            and isinstance(self._mode, modes.ModeWithAuthenticationTag)
+            and self.tag is None
+        ):
+            raise ValueError(
+                "Authentication tag must be provided when decrypting."
+            )
+
+        buf = self._backend._ffi.new("unsigned char[]", self._block_size_bytes)
+        outlen = self._backend._ffi.new("int *")
+        res = self._backend._lib.EVP_CipherFinal_ex(self._ctx, buf, outlen)
+        if res == 0:
+            errors = self._backend._consume_errors()
+
+            if not errors and isinstance(self._mode, modes.GCM):
+                raise InvalidTag
+
+            lib = self._backend._lib
+            self._backend.openssl_assert(
+                errors[0]._lib_reason_match(
+                    lib.ERR_LIB_EVP,
+                    lib.EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH,
+                )
+                or (
+                    lib.Cryptography_HAS_PROVIDERS
+                    and errors[0]._lib_reason_match(
+                        lib.ERR_LIB_PROV,
+                        lib.PROV_R_WRONG_FINAL_BLOCK_LENGTH,
+                    )
+                )
+                or (
+                    lib.CRYPTOGRAPHY_IS_BORINGSSL
+                    and errors[0].reason
+                    == lib.CIPHER_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH
+                ),
+                errors=errors,
+            )
+            raise ValueError(
+                "The length of the provided data is not a multiple of "
+                "the block length."
+            )
+
+        if (
+            isinstance(self._mode, modes.GCM)
+            and self._operation == self._ENCRYPT
+        ):
+            tag_buf = self._backend._ffi.new(
+                "unsigned char[]", self._block_size_bytes
+            )
+            res = self._backend._lib.EVP_CIPHER_CTX_ctrl(
+                self._ctx,
+                self._backend._lib.EVP_CTRL_AEAD_GET_TAG,
+                self._block_size_bytes,
+                tag_buf,
+            )
+            self._backend.openssl_assert(res != 0)
+            self._tag = self._backend._ffi.buffer(tag_buf)[:]
+
+        res = self._backend._lib.EVP_CIPHER_CTX_reset(self._ctx)
+        self._backend.openssl_assert(res == 1)
+        return self._backend._ffi.buffer(buf)[: outlen[0]]
+
+    def finalize_with_tag(self, tag: bytes) -> bytes:
+        tag_len = len(tag)
+        if tag_len < self._mode._min_tag_length:
+            raise ValueError(
+                "Authentication tag must be {} bytes or longer.".format(
+                    self._mode._min_tag_length
+                )
+            )
+        elif tag_len > self._block_size_bytes:
+            raise ValueError(
+                "Authentication tag cannot be more than {} bytes.".format(
+                    self._block_size_bytes
+                )
+            )
+        res = self._backend._lib.EVP_CIPHER_CTX_ctrl(
+            self._ctx, self._backend._lib.EVP_CTRL_AEAD_SET_TAG, len(tag), tag
+        )
+        self._backend.openssl_assert(res != 0)
+        self._tag = tag
+        return self.finalize()
+
+    def authenticate_additional_data(self, data: bytes) -> None:
+        outlen = self._backend._ffi.new("int *")
+        res = self._backend._lib.EVP_CipherUpdate(
+            self._ctx,
+            self._backend._ffi.NULL,
+            outlen,
+            self._backend._ffi.from_buffer(data),
+            len(data),
+        )
+        self._backend.openssl_assert(res != 0)
+
+    @property
+    def tag(self) -> typing.Optional[bytes]:
+        return self._tag
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/cmac.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/cmac.py
new file mode 100644
index 0000000..35f50c5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/cmac.py
@@ -0,0 +1,87 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.exceptions import (
+    InvalidSignature,
+    UnsupportedAlgorithm,
+    _Reasons,
+)
+from cryptography.hazmat.primitives import constant_time
+from cryptography.hazmat.primitives.ciphers.modes import CBC
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.primitives import ciphers
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+class _CMACContext:
+    def __init__(
+        self,
+        backend: "Backend",
+        algorithm: "ciphers.BlockCipherAlgorithm",
+        ctx=None,
+    ) -> None:
+        if not backend.cmac_algorithm_supported(algorithm):
+            raise UnsupportedAlgorithm(
+                "This backend does not support CMAC.",
+                _Reasons.UNSUPPORTED_CIPHER,
+            )
+
+        self._backend = backend
+        self._key = algorithm.key
+        self._algorithm = algorithm
+        self._output_length = algorithm.block_size // 8
+
+        if ctx is None:
+            registry = self._backend._cipher_registry
+            adapter = registry[type(algorithm), CBC]
+
+            evp_cipher = adapter(self._backend, algorithm, CBC)
+
+            ctx = self._backend._lib.CMAC_CTX_new()
+
+            self._backend.openssl_assert(ctx != self._backend._ffi.NULL)
+            ctx = self._backend._ffi.gc(ctx, self._backend._lib.CMAC_CTX_free)
+
+            key_ptr = self._backend._ffi.from_buffer(self._key)
+            res = self._backend._lib.CMAC_Init(
+                ctx,
+                key_ptr,
+                len(self._key),
+                evp_cipher,
+                self._backend._ffi.NULL,
+            )
+            self._backend.openssl_assert(res == 1)
+
+        self._ctx = ctx
+
+    def update(self, data: bytes) -> None:
+        res = self._backend._lib.CMAC_Update(self._ctx, data, len(data))
+        self._backend.openssl_assert(res == 1)
+
+    def finalize(self) -> bytes:
+        buf = self._backend._ffi.new("unsigned char[]", self._output_length)
+        length = self._backend._ffi.new("size_t *", self._output_length)
+        res = self._backend._lib.CMAC_Final(self._ctx, buf, length)
+        self._backend.openssl_assert(res == 1)
+
+        self._ctx = None
+
+        return self._backend._ffi.buffer(buf)[:]
+
+    def copy(self) -> "_CMACContext":
+        copied_ctx = self._backend._lib.CMAC_CTX_new()
+        copied_ctx = self._backend._ffi.gc(
+            copied_ctx, self._backend._lib.CMAC_CTX_free
+        )
+        res = self._backend._lib.CMAC_CTX_copy(copied_ctx, self._ctx)
+        self._backend.openssl_assert(res == 1)
+        return _CMACContext(self._backend, self._algorithm, ctx=copied_ctx)
+
+    def verify(self, signature: bytes) -> None:
+        digest = self.finalize()
+        if not constant_time.bytes_eq(digest, signature):
+            raise InvalidSignature("Signature did not match digest.")
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/decode_asn1.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/decode_asn1.py
new file mode 100644
index 0000000..df91d6d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/decode_asn1.py
@@ -0,0 +1,31 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+from cryptography import x509
+
+#    CRLReason ::= ENUMERATED {
+#        unspecified             (0),
+#        keyCompromise           (1),
+#        cACompromise            (2),
+#        affiliationChanged      (3),
+#        superseded              (4),
+#        cessationOfOperation    (5),
+#        certificateHold         (6),
+#             -- value 7 is not used
+#        removeFromCRL           (8),
+#        privilegeWithdrawn      (9),
+#        aACompromise           (10) }
+_CRL_ENTRY_REASON_ENUM_TO_CODE = {
+    x509.ReasonFlags.unspecified: 0,
+    x509.ReasonFlags.key_compromise: 1,
+    x509.ReasonFlags.ca_compromise: 2,
+    x509.ReasonFlags.affiliation_changed: 3,
+    x509.ReasonFlags.superseded: 4,
+    x509.ReasonFlags.cessation_of_operation: 5,
+    x509.ReasonFlags.certificate_hold: 6,
+    x509.ReasonFlags.remove_from_crl: 8,
+    x509.ReasonFlags.privilege_withdrawn: 9,
+    x509.ReasonFlags.aa_compromise: 10,
+}
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/dh.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/dh.py
new file mode 100644
index 0000000..70364a3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/dh.py
@@ -0,0 +1,318 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import dh
+
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+def _dh_params_dup(dh_cdata, backend: "Backend"):
+    lib = backend._lib
+    ffi = backend._ffi
+
+    param_cdata = lib.DHparams_dup(dh_cdata)
+    backend.openssl_assert(param_cdata != ffi.NULL)
+    param_cdata = ffi.gc(param_cdata, lib.DH_free)
+    if lib.CRYPTOGRAPHY_IS_LIBRESSL:
+        # In libressl DHparams_dup don't copy q
+        q = ffi.new("BIGNUM **")
+        lib.DH_get0_pqg(dh_cdata, ffi.NULL, q, ffi.NULL)
+        q_dup = lib.BN_dup(q[0])
+        res = lib.DH_set0_pqg(param_cdata, ffi.NULL, q_dup, ffi.NULL)
+        backend.openssl_assert(res == 1)
+
+    return param_cdata
+
+
+def _dh_cdata_to_parameters(dh_cdata, backend: "Backend") -> "_DHParameters":
+    param_cdata = _dh_params_dup(dh_cdata, backend)
+    return _DHParameters(backend, param_cdata)
+
+
+class _DHParameters(dh.DHParameters):
+    def __init__(self, backend: "Backend", dh_cdata):
+        self._backend = backend
+        self._dh_cdata = dh_cdata
+
+    def parameter_numbers(self) -> dh.DHParameterNumbers:
+        p = self._backend._ffi.new("BIGNUM **")
+        g = self._backend._ffi.new("BIGNUM **")
+        q = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DH_get0_pqg(self._dh_cdata, p, q, g)
+        self._backend.openssl_assert(p[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(g[0] != self._backend._ffi.NULL)
+        q_val: typing.Optional[int]
+        if q[0] == self._backend._ffi.NULL:
+            q_val = None
+        else:
+            q_val = self._backend._bn_to_int(q[0])
+        return dh.DHParameterNumbers(
+            p=self._backend._bn_to_int(p[0]),
+            g=self._backend._bn_to_int(g[0]),
+            q=q_val,
+        )
+
+    def generate_private_key(self) -> dh.DHPrivateKey:
+        return self._backend.generate_dh_private_key(self)
+
+    def parameter_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.ParameterFormat,
+    ) -> bytes:
+        if encoding is serialization.Encoding.OpenSSH:
+            raise TypeError("OpenSSH encoding is not supported")
+
+        if format is not serialization.ParameterFormat.PKCS3:
+            raise ValueError("Only PKCS3 serialization is supported")
+
+        q = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DH_get0_pqg(
+            self._dh_cdata, self._backend._ffi.NULL, q, self._backend._ffi.NULL
+        )
+        if (
+            q[0] != self._backend._ffi.NULL
+            and not self._backend._lib.Cryptography_HAS_EVP_PKEY_DHX
+        ):
+            raise UnsupportedAlgorithm(
+                "DH X9.42 serialization is not supported",
+                _Reasons.UNSUPPORTED_SERIALIZATION,
+            )
+
+        if encoding is serialization.Encoding.PEM:
+            if q[0] != self._backend._ffi.NULL:
+                write_bio = self._backend._lib.PEM_write_bio_DHxparams
+            else:
+                write_bio = self._backend._lib.PEM_write_bio_DHparams
+        elif encoding is serialization.Encoding.DER:
+            if q[0] != self._backend._ffi.NULL:
+                write_bio = self._backend._lib.Cryptography_i2d_DHxparams_bio
+            else:
+                write_bio = self._backend._lib.i2d_DHparams_bio
+        else:
+            raise TypeError("encoding must be an item from the Encoding enum")
+
+        bio = self._backend._create_mem_bio_gc()
+        res = write_bio(bio, self._dh_cdata)
+        self._backend.openssl_assert(res == 1)
+        return self._backend._read_mem_bio(bio)
+
+
+def _get_dh_num_bits(backend, dh_cdata) -> int:
+    p = backend._ffi.new("BIGNUM **")
+    backend._lib.DH_get0_pqg(dh_cdata, p, backend._ffi.NULL, backend._ffi.NULL)
+    backend.openssl_assert(p[0] != backend._ffi.NULL)
+    return backend._lib.BN_num_bits(p[0])
+
+
+class _DHPrivateKey(dh.DHPrivateKey):
+    def __init__(self, backend: "Backend", dh_cdata, evp_pkey):
+        self._backend = backend
+        self._dh_cdata = dh_cdata
+        self._evp_pkey = evp_pkey
+        self._key_size_bytes = self._backend._lib.DH_size(dh_cdata)
+
+    @property
+    def key_size(self) -> int:
+        return _get_dh_num_bits(self._backend, self._dh_cdata)
+
+    def private_numbers(self) -> dh.DHPrivateNumbers:
+        p = self._backend._ffi.new("BIGNUM **")
+        g = self._backend._ffi.new("BIGNUM **")
+        q = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DH_get0_pqg(self._dh_cdata, p, q, g)
+        self._backend.openssl_assert(p[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(g[0] != self._backend._ffi.NULL)
+        if q[0] == self._backend._ffi.NULL:
+            q_val = None
+        else:
+            q_val = self._backend._bn_to_int(q[0])
+        pub_key = self._backend._ffi.new("BIGNUM **")
+        priv_key = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DH_get0_key(self._dh_cdata, pub_key, priv_key)
+        self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(priv_key[0] != self._backend._ffi.NULL)
+        return dh.DHPrivateNumbers(
+            public_numbers=dh.DHPublicNumbers(
+                parameter_numbers=dh.DHParameterNumbers(
+                    p=self._backend._bn_to_int(p[0]),
+                    g=self._backend._bn_to_int(g[0]),
+                    q=q_val,
+                ),
+                y=self._backend._bn_to_int(pub_key[0]),
+            ),
+            x=self._backend._bn_to_int(priv_key[0]),
+        )
+
+    def exchange(self, peer_public_key: dh.DHPublicKey) -> bytes:
+        if not isinstance(peer_public_key, _DHPublicKey):
+            raise TypeError("peer_public_key must be a DHPublicKey")
+
+        ctx = self._backend._lib.EVP_PKEY_CTX_new(
+            self._evp_pkey, self._backend._ffi.NULL
+        )
+        self._backend.openssl_assert(ctx != self._backend._ffi.NULL)
+        ctx = self._backend._ffi.gc(ctx, self._backend._lib.EVP_PKEY_CTX_free)
+        res = self._backend._lib.EVP_PKEY_derive_init(ctx)
+        self._backend.openssl_assert(res == 1)
+        res = self._backend._lib.EVP_PKEY_derive_set_peer(
+            ctx, peer_public_key._evp_pkey
+        )
+        # Invalid kex errors here in OpenSSL 3.0 because checks were moved
+        # to EVP_PKEY_derive_set_peer
+        self._exchange_assert(res == 1)
+        keylen = self._backend._ffi.new("size_t *")
+        res = self._backend._lib.EVP_PKEY_derive(
+            ctx, self._backend._ffi.NULL, keylen
+        )
+        # Invalid kex errors here in OpenSSL < 3
+        self._exchange_assert(res == 1)
+        self._backend.openssl_assert(keylen[0] > 0)
+        buf = self._backend._ffi.new("unsigned char[]", keylen[0])
+        res = self._backend._lib.EVP_PKEY_derive(ctx, buf, keylen)
+        self._backend.openssl_assert(res == 1)
+
+        key = self._backend._ffi.buffer(buf, keylen[0])[:]
+        pad = self._key_size_bytes - len(key)
+
+        if pad > 0:
+            key = (b"\x00" * pad) + key
+
+        return key
+
+    def _exchange_assert(self, ok: bool) -> None:
+        if not ok:
+            errors_with_text = self._backend._consume_errors_with_text()
+            raise ValueError(
+                "Error computing shared key.",
+                errors_with_text,
+            )
+
+    def public_key(self) -> dh.DHPublicKey:
+        dh_cdata = _dh_params_dup(self._dh_cdata, self._backend)
+        pub_key = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DH_get0_key(
+            self._dh_cdata, pub_key, self._backend._ffi.NULL
+        )
+        self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL)
+        pub_key_dup = self._backend._lib.BN_dup(pub_key[0])
+        self._backend.openssl_assert(pub_key_dup != self._backend._ffi.NULL)
+
+        res = self._backend._lib.DH_set0_key(
+            dh_cdata, pub_key_dup, self._backend._ffi.NULL
+        )
+        self._backend.openssl_assert(res == 1)
+        evp_pkey = self._backend._dh_cdata_to_evp_pkey(dh_cdata)
+        return _DHPublicKey(self._backend, dh_cdata, evp_pkey)
+
+    def parameters(self) -> dh.DHParameters:
+        return _dh_cdata_to_parameters(self._dh_cdata, self._backend)
+
+    def private_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PrivateFormat,
+        encryption_algorithm: serialization.KeySerializationEncryption,
+    ) -> bytes:
+        if format is not serialization.PrivateFormat.PKCS8:
+            raise ValueError(
+                "DH private keys support only PKCS8 serialization"
+            )
+        if not self._backend._lib.Cryptography_HAS_EVP_PKEY_DHX:
+            q = self._backend._ffi.new("BIGNUM **")
+            self._backend._lib.DH_get0_pqg(
+                self._dh_cdata,
+                self._backend._ffi.NULL,
+                q,
+                self._backend._ffi.NULL,
+            )
+            if q[0] != self._backend._ffi.NULL:
+                raise UnsupportedAlgorithm(
+                    "DH X9.42 serialization is not supported",
+                    _Reasons.UNSUPPORTED_SERIALIZATION,
+                )
+
+        return self._backend._private_key_bytes(
+            encoding,
+            format,
+            encryption_algorithm,
+            self,
+            self._evp_pkey,
+            self._dh_cdata,
+        )
+
+
+class _DHPublicKey(dh.DHPublicKey):
+    def __init__(self, backend: "Backend", dh_cdata, evp_pkey):
+        self._backend = backend
+        self._dh_cdata = dh_cdata
+        self._evp_pkey = evp_pkey
+        self._key_size_bits = _get_dh_num_bits(self._backend, self._dh_cdata)
+
+    @property
+    def key_size(self) -> int:
+        return self._key_size_bits
+
+    def public_numbers(self) -> dh.DHPublicNumbers:
+        p = self._backend._ffi.new("BIGNUM **")
+        g = self._backend._ffi.new("BIGNUM **")
+        q = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DH_get0_pqg(self._dh_cdata, p, q, g)
+        self._backend.openssl_assert(p[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(g[0] != self._backend._ffi.NULL)
+        if q[0] == self._backend._ffi.NULL:
+            q_val = None
+        else:
+            q_val = self._backend._bn_to_int(q[0])
+        pub_key = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DH_get0_key(
+            self._dh_cdata, pub_key, self._backend._ffi.NULL
+        )
+        self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL)
+        return dh.DHPublicNumbers(
+            parameter_numbers=dh.DHParameterNumbers(
+                p=self._backend._bn_to_int(p[0]),
+                g=self._backend._bn_to_int(g[0]),
+                q=q_val,
+            ),
+            y=self._backend._bn_to_int(pub_key[0]),
+        )
+
+    def parameters(self) -> dh.DHParameters:
+        return _dh_cdata_to_parameters(self._dh_cdata, self._backend)
+
+    def public_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PublicFormat,
+    ) -> bytes:
+        if format is not serialization.PublicFormat.SubjectPublicKeyInfo:
+            raise ValueError(
+                "DH public keys support only "
+                "SubjectPublicKeyInfo serialization"
+            )
+
+        if not self._backend._lib.Cryptography_HAS_EVP_PKEY_DHX:
+            q = self._backend._ffi.new("BIGNUM **")
+            self._backend._lib.DH_get0_pqg(
+                self._dh_cdata,
+                self._backend._ffi.NULL,
+                q,
+                self._backend._ffi.NULL,
+            )
+            if q[0] != self._backend._ffi.NULL:
+                raise UnsupportedAlgorithm(
+                    "DH X9.42 serialization is not supported",
+                    _Reasons.UNSUPPORTED_SERIALIZATION,
+                )
+
+        return self._backend._public_key_bytes(
+            encoding, format, self, self._evp_pkey, None
+        )
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/dsa.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/dsa.py
new file mode 100644
index 0000000..8634b72
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/dsa.py
@@ -0,0 +1,239 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import typing
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.backends.openssl.utils import (
+    _calculate_digest_and_algorithm,
+)
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import (
+    dsa,
+    utils as asym_utils,
+)
+
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+def _dsa_sig_sign(
+    backend: "Backend", private_key: "_DSAPrivateKey", data: bytes
+) -> bytes:
+    sig_buf_len = backend._lib.DSA_size(private_key._dsa_cdata)
+    sig_buf = backend._ffi.new("unsigned char[]", sig_buf_len)
+    buflen = backend._ffi.new("unsigned int *")
+
+    # The first parameter passed to DSA_sign is unused by OpenSSL but
+    # must be an integer.
+    res = backend._lib.DSA_sign(
+        0, data, len(data), sig_buf, buflen, private_key._dsa_cdata
+    )
+    backend.openssl_assert(res == 1)
+    backend.openssl_assert(buflen[0])
+
+    return backend._ffi.buffer(sig_buf)[: buflen[0]]
+
+
+def _dsa_sig_verify(
+    backend: "Backend",
+    public_key: "_DSAPublicKey",
+    signature: bytes,
+    data: bytes,
+) -> None:
+    # The first parameter passed to DSA_verify is unused by OpenSSL but
+    # must be an integer.
+    res = backend._lib.DSA_verify(
+        0, data, len(data), signature, len(signature), public_key._dsa_cdata
+    )
+
+    if res != 1:
+        backend._consume_errors()
+        raise InvalidSignature
+
+
+class _DSAParameters(dsa.DSAParameters):
+    def __init__(self, backend: "Backend", dsa_cdata):
+        self._backend = backend
+        self._dsa_cdata = dsa_cdata
+
+    def parameter_numbers(self) -> dsa.DSAParameterNumbers:
+        p = self._backend._ffi.new("BIGNUM **")
+        q = self._backend._ffi.new("BIGNUM **")
+        g = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DSA_get0_pqg(self._dsa_cdata, p, q, g)
+        self._backend.openssl_assert(p[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(q[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(g[0] != self._backend._ffi.NULL)
+        return dsa.DSAParameterNumbers(
+            p=self._backend._bn_to_int(p[0]),
+            q=self._backend._bn_to_int(q[0]),
+            g=self._backend._bn_to_int(g[0]),
+        )
+
+    def generate_private_key(self) -> dsa.DSAPrivateKey:
+        return self._backend.generate_dsa_private_key(self)
+
+
+class _DSAPrivateKey(dsa.DSAPrivateKey):
+    _key_size: int
+
+    def __init__(self, backend: "Backend", dsa_cdata, evp_pkey):
+        self._backend = backend
+        self._dsa_cdata = dsa_cdata
+        self._evp_pkey = evp_pkey
+
+        p = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DSA_get0_pqg(
+            dsa_cdata, p, self._backend._ffi.NULL, self._backend._ffi.NULL
+        )
+        self._backend.openssl_assert(p[0] != backend._ffi.NULL)
+        self._key_size = self._backend._lib.BN_num_bits(p[0])
+
+    @property
+    def key_size(self) -> int:
+        return self._key_size
+
+    def private_numbers(self) -> dsa.DSAPrivateNumbers:
+        p = self._backend._ffi.new("BIGNUM **")
+        q = self._backend._ffi.new("BIGNUM **")
+        g = self._backend._ffi.new("BIGNUM **")
+        pub_key = self._backend._ffi.new("BIGNUM **")
+        priv_key = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DSA_get0_pqg(self._dsa_cdata, p, q, g)
+        self._backend.openssl_assert(p[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(q[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(g[0] != self._backend._ffi.NULL)
+        self._backend._lib.DSA_get0_key(self._dsa_cdata, pub_key, priv_key)
+        self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(priv_key[0] != self._backend._ffi.NULL)
+        return dsa.DSAPrivateNumbers(
+            public_numbers=dsa.DSAPublicNumbers(
+                parameter_numbers=dsa.DSAParameterNumbers(
+                    p=self._backend._bn_to_int(p[0]),
+                    q=self._backend._bn_to_int(q[0]),
+                    g=self._backend._bn_to_int(g[0]),
+                ),
+                y=self._backend._bn_to_int(pub_key[0]),
+            ),
+            x=self._backend._bn_to_int(priv_key[0]),
+        )
+
+    def public_key(self) -> dsa.DSAPublicKey:
+        dsa_cdata = self._backend._lib.DSAparams_dup(self._dsa_cdata)
+        self._backend.openssl_assert(dsa_cdata != self._backend._ffi.NULL)
+        dsa_cdata = self._backend._ffi.gc(
+            dsa_cdata, self._backend._lib.DSA_free
+        )
+        pub_key = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DSA_get0_key(
+            self._dsa_cdata, pub_key, self._backend._ffi.NULL
+        )
+        self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL)
+        pub_key_dup = self._backend._lib.BN_dup(pub_key[0])
+        res = self._backend._lib.DSA_set0_key(
+            dsa_cdata, pub_key_dup, self._backend._ffi.NULL
+        )
+        self._backend.openssl_assert(res == 1)
+        evp_pkey = self._backend._dsa_cdata_to_evp_pkey(dsa_cdata)
+        return _DSAPublicKey(self._backend, dsa_cdata, evp_pkey)
+
+    def parameters(self) -> dsa.DSAParameters:
+        dsa_cdata = self._backend._lib.DSAparams_dup(self._dsa_cdata)
+        self._backend.openssl_assert(dsa_cdata != self._backend._ffi.NULL)
+        dsa_cdata = self._backend._ffi.gc(
+            dsa_cdata, self._backend._lib.DSA_free
+        )
+        return _DSAParameters(self._backend, dsa_cdata)
+
+    def private_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PrivateFormat,
+        encryption_algorithm: serialization.KeySerializationEncryption,
+    ) -> bytes:
+        return self._backend._private_key_bytes(
+            encoding,
+            format,
+            encryption_algorithm,
+            self,
+            self._evp_pkey,
+            self._dsa_cdata,
+        )
+
+    def sign(
+        self,
+        data: bytes,
+        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
+    ) -> bytes:
+        data, _ = _calculate_digest_and_algorithm(data, algorithm)
+        return _dsa_sig_sign(self._backend, self, data)
+
+
+class _DSAPublicKey(dsa.DSAPublicKey):
+    _key_size: int
+
+    def __init__(self, backend: "Backend", dsa_cdata, evp_pkey):
+        self._backend = backend
+        self._dsa_cdata = dsa_cdata
+        self._evp_pkey = evp_pkey
+        p = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DSA_get0_pqg(
+            dsa_cdata, p, self._backend._ffi.NULL, self._backend._ffi.NULL
+        )
+        self._backend.openssl_assert(p[0] != backend._ffi.NULL)
+        self._key_size = self._backend._lib.BN_num_bits(p[0])
+
+    @property
+    def key_size(self) -> int:
+        return self._key_size
+
+    def public_numbers(self) -> dsa.DSAPublicNumbers:
+        p = self._backend._ffi.new("BIGNUM **")
+        q = self._backend._ffi.new("BIGNUM **")
+        g = self._backend._ffi.new("BIGNUM **")
+        pub_key = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.DSA_get0_pqg(self._dsa_cdata, p, q, g)
+        self._backend.openssl_assert(p[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(q[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(g[0] != self._backend._ffi.NULL)
+        self._backend._lib.DSA_get0_key(
+            self._dsa_cdata, pub_key, self._backend._ffi.NULL
+        )
+        self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL)
+        return dsa.DSAPublicNumbers(
+            parameter_numbers=dsa.DSAParameterNumbers(
+                p=self._backend._bn_to_int(p[0]),
+                q=self._backend._bn_to_int(q[0]),
+                g=self._backend._bn_to_int(g[0]),
+            ),
+            y=self._backend._bn_to_int(pub_key[0]),
+        )
+
+    def parameters(self) -> dsa.DSAParameters:
+        dsa_cdata = self._backend._lib.DSAparams_dup(self._dsa_cdata)
+        dsa_cdata = self._backend._ffi.gc(
+            dsa_cdata, self._backend._lib.DSA_free
+        )
+        return _DSAParameters(self._backend, dsa_cdata)
+
+    def public_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PublicFormat,
+    ) -> bytes:
+        return self._backend._public_key_bytes(
+            encoding, format, self, self._evp_pkey, None
+        )
+
+    def verify(
+        self,
+        signature: bytes,
+        data: bytes,
+        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
+    ) -> None:
+        data, _ = _calculate_digest_and_algorithm(data, algorithm)
+        return _dsa_sig_verify(self._backend, self, signature, data)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ec.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ec.py
new file mode 100644
index 0000000..9bc6dd3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ec.py
@@ -0,0 +1,315 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.exceptions import (
+    InvalidSignature,
+    UnsupportedAlgorithm,
+    _Reasons,
+)
+from cryptography.hazmat.backends.openssl.utils import (
+    _calculate_digest_and_algorithm,
+    _evp_pkey_derive,
+)
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import ec
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+def _check_signature_algorithm(
+    signature_algorithm: ec.EllipticCurveSignatureAlgorithm,
+) -> None:
+    if not isinstance(signature_algorithm, ec.ECDSA):
+        raise UnsupportedAlgorithm(
+            "Unsupported elliptic curve signature algorithm.",
+            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM,
+        )
+
+
+def _ec_key_curve_sn(backend: "Backend", ec_key) -> str:
+    group = backend._lib.EC_KEY_get0_group(ec_key)
+    backend.openssl_assert(group != backend._ffi.NULL)
+
+    nid = backend._lib.EC_GROUP_get_curve_name(group)
+    # The following check is to find EC keys with unnamed curves and raise
+    # an error for now.
+    if nid == backend._lib.NID_undef:
+        raise ValueError(
+            "ECDSA keys with explicit parameters are unsupported at this time"
+        )
+
+    # This is like the above check, but it also catches the case where you
+    # explicitly encoded a curve with the same parameters as a named curve.
+    # Don't do that.
+    if (
+        not backend._lib.CRYPTOGRAPHY_IS_LIBRESSL
+        and backend._lib.EC_GROUP_get_asn1_flag(group) == 0
+    ):
+        raise ValueError(
+            "ECDSA keys with explicit parameters are unsupported at this time"
+        )
+
+    curve_name = backend._lib.OBJ_nid2sn(nid)
+    backend.openssl_assert(curve_name != backend._ffi.NULL)
+
+    sn = backend._ffi.string(curve_name).decode("ascii")
+    return sn
+
+
+def _mark_asn1_named_ec_curve(backend: "Backend", ec_cdata):
+    """
+    Set the named curve flag on the EC_KEY. This causes OpenSSL to
+    serialize EC keys along with their curve OID which makes
+    deserialization easier.
+    """
+
+    backend._lib.EC_KEY_set_asn1_flag(
+        ec_cdata, backend._lib.OPENSSL_EC_NAMED_CURVE
+    )
+
+
+def _check_key_infinity(backend: "Backend", ec_cdata) -> None:
+    point = backend._lib.EC_KEY_get0_public_key(ec_cdata)
+    backend.openssl_assert(point != backend._ffi.NULL)
+    group = backend._lib.EC_KEY_get0_group(ec_cdata)
+    backend.openssl_assert(group != backend._ffi.NULL)
+    if backend._lib.EC_POINT_is_at_infinity(group, point):
+        raise ValueError(
+            "Cannot load an EC public key where the point is at infinity"
+        )
+
+
+def _sn_to_elliptic_curve(backend: "Backend", sn: str) -> ec.EllipticCurve:
+    try:
+        return ec._CURVE_TYPES[sn]()
+    except KeyError:
+        raise UnsupportedAlgorithm(
+            "{} is not a supported elliptic curve".format(sn),
+            _Reasons.UNSUPPORTED_ELLIPTIC_CURVE,
+        )
+
+
+def _ecdsa_sig_sign(
+    backend: "Backend", private_key: "_EllipticCurvePrivateKey", data: bytes
+) -> bytes:
+    max_size = backend._lib.ECDSA_size(private_key._ec_key)
+    backend.openssl_assert(max_size > 0)
+
+    sigbuf = backend._ffi.new("unsigned char[]", max_size)
+    siglen_ptr = backend._ffi.new("unsigned int[]", 1)
+    res = backend._lib.ECDSA_sign(
+        0, data, len(data), sigbuf, siglen_ptr, private_key._ec_key
+    )
+    backend.openssl_assert(res == 1)
+    return backend._ffi.buffer(sigbuf)[: siglen_ptr[0]]
+
+
+def _ecdsa_sig_verify(
+    backend: "Backend",
+    public_key: "_EllipticCurvePublicKey",
+    signature: bytes,
+    data: bytes,
+) -> None:
+    res = backend._lib.ECDSA_verify(
+        0, data, len(data), signature, len(signature), public_key._ec_key
+    )
+    if res != 1:
+        backend._consume_errors()
+        raise InvalidSignature
+
+
+class _EllipticCurvePrivateKey(ec.EllipticCurvePrivateKey):
+    def __init__(self, backend: "Backend", ec_key_cdata, evp_pkey):
+        self._backend = backend
+        self._ec_key = ec_key_cdata
+        self._evp_pkey = evp_pkey
+
+        sn = _ec_key_curve_sn(backend, ec_key_cdata)
+        self._curve = _sn_to_elliptic_curve(backend, sn)
+        _mark_asn1_named_ec_curve(backend, ec_key_cdata)
+        _check_key_infinity(backend, ec_key_cdata)
+
+    @property
+    def curve(self) -> ec.EllipticCurve:
+        return self._curve
+
+    @property
+    def key_size(self) -> int:
+        return self.curve.key_size
+
+    def exchange(
+        self, algorithm: ec.ECDH, peer_public_key: ec.EllipticCurvePublicKey
+    ) -> bytes:
+        if not (
+            self._backend.elliptic_curve_exchange_algorithm_supported(
+                algorithm, self.curve
+            )
+        ):
+            raise UnsupportedAlgorithm(
+                "This backend does not support the ECDH algorithm.",
+                _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM,
+            )
+
+        if peer_public_key.curve.name != self.curve.name:
+            raise ValueError(
+                "peer_public_key and self are not on the same curve"
+            )
+
+        return _evp_pkey_derive(self._backend, self._evp_pkey, peer_public_key)
+
+    def public_key(self) -> ec.EllipticCurvePublicKey:
+        group = self._backend._lib.EC_KEY_get0_group(self._ec_key)
+        self._backend.openssl_assert(group != self._backend._ffi.NULL)
+
+        curve_nid = self._backend._lib.EC_GROUP_get_curve_name(group)
+        public_ec_key = self._backend._ec_key_new_by_curve_nid(curve_nid)
+
+        point = self._backend._lib.EC_KEY_get0_public_key(self._ec_key)
+        self._backend.openssl_assert(point != self._backend._ffi.NULL)
+
+        res = self._backend._lib.EC_KEY_set_public_key(public_ec_key, point)
+        self._backend.openssl_assert(res == 1)
+
+        evp_pkey = self._backend._ec_cdata_to_evp_pkey(public_ec_key)
+
+        return _EllipticCurvePublicKey(self._backend, public_ec_key, evp_pkey)
+
+    def private_numbers(self) -> ec.EllipticCurvePrivateNumbers:
+        bn = self._backend._lib.EC_KEY_get0_private_key(self._ec_key)
+        private_value = self._backend._bn_to_int(bn)
+        return ec.EllipticCurvePrivateNumbers(
+            private_value=private_value,
+            public_numbers=self.public_key().public_numbers(),
+        )
+
+    def private_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PrivateFormat,
+        encryption_algorithm: serialization.KeySerializationEncryption,
+    ) -> bytes:
+        return self._backend._private_key_bytes(
+            encoding,
+            format,
+            encryption_algorithm,
+            self,
+            self._evp_pkey,
+            self._ec_key,
+        )
+
+    def sign(
+        self,
+        data: bytes,
+        signature_algorithm: ec.EllipticCurveSignatureAlgorithm,
+    ) -> bytes:
+        _check_signature_algorithm(signature_algorithm)
+        data, _ = _calculate_digest_and_algorithm(
+            data,
+            signature_algorithm.algorithm,
+        )
+        return _ecdsa_sig_sign(self._backend, self, data)
+
+
+class _EllipticCurvePublicKey(ec.EllipticCurvePublicKey):
+    def __init__(self, backend: "Backend", ec_key_cdata, evp_pkey):
+        self._backend = backend
+        self._ec_key = ec_key_cdata
+        self._evp_pkey = evp_pkey
+
+        sn = _ec_key_curve_sn(backend, ec_key_cdata)
+        self._curve = _sn_to_elliptic_curve(backend, sn)
+        _mark_asn1_named_ec_curve(backend, ec_key_cdata)
+        _check_key_infinity(backend, ec_key_cdata)
+
+    @property
+    def curve(self) -> ec.EllipticCurve:
+        return self._curve
+
+    @property
+    def key_size(self) -> int:
+        return self.curve.key_size
+
+    def public_numbers(self) -> ec.EllipticCurvePublicNumbers:
+        get_func, group = self._backend._ec_key_determine_group_get_func(
+            self._ec_key
+        )
+        point = self._backend._lib.EC_KEY_get0_public_key(self._ec_key)
+        self._backend.openssl_assert(point != self._backend._ffi.NULL)
+
+        with self._backend._tmp_bn_ctx() as bn_ctx:
+            bn_x = self._backend._lib.BN_CTX_get(bn_ctx)
+            bn_y = self._backend._lib.BN_CTX_get(bn_ctx)
+
+            res = get_func(group, point, bn_x, bn_y, bn_ctx)
+            self._backend.openssl_assert(res == 1)
+
+            x = self._backend._bn_to_int(bn_x)
+            y = self._backend._bn_to_int(bn_y)
+
+        return ec.EllipticCurvePublicNumbers(x=x, y=y, curve=self._curve)
+
+    def _encode_point(self, format: serialization.PublicFormat) -> bytes:
+        if format is serialization.PublicFormat.CompressedPoint:
+            conversion = self._backend._lib.POINT_CONVERSION_COMPRESSED
+        else:
+            assert format is serialization.PublicFormat.UncompressedPoint
+            conversion = self._backend._lib.POINT_CONVERSION_UNCOMPRESSED
+
+        group = self._backend._lib.EC_KEY_get0_group(self._ec_key)
+        self._backend.openssl_assert(group != self._backend._ffi.NULL)
+        point = self._backend._lib.EC_KEY_get0_public_key(self._ec_key)
+        self._backend.openssl_assert(point != self._backend._ffi.NULL)
+        with self._backend._tmp_bn_ctx() as bn_ctx:
+            buflen = self._backend._lib.EC_POINT_point2oct(
+                group, point, conversion, self._backend._ffi.NULL, 0, bn_ctx
+            )
+            self._backend.openssl_assert(buflen > 0)
+            buf = self._backend._ffi.new("char[]", buflen)
+            res = self._backend._lib.EC_POINT_point2oct(
+                group, point, conversion, buf, buflen, bn_ctx
+            )
+            self._backend.openssl_assert(buflen == res)
+
+        return self._backend._ffi.buffer(buf)[:]
+
+    def public_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PublicFormat,
+    ) -> bytes:
+        if (
+            encoding is serialization.Encoding.X962
+            or format is serialization.PublicFormat.CompressedPoint
+            or format is serialization.PublicFormat.UncompressedPoint
+        ):
+            if encoding is not serialization.Encoding.X962 or format not in (
+                serialization.PublicFormat.CompressedPoint,
+                serialization.PublicFormat.UncompressedPoint,
+            ):
+                raise ValueError(
+                    "X962 encoding must be used with CompressedPoint or "
+                    "UncompressedPoint format"
+                )
+
+            return self._encode_point(format)
+        else:
+            return self._backend._public_key_bytes(
+                encoding, format, self, self._evp_pkey, None
+            )
+
+    def verify(
+        self,
+        signature: bytes,
+        data: bytes,
+        signature_algorithm: ec.EllipticCurveSignatureAlgorithm,
+    ) -> None:
+        _check_signature_algorithm(signature_algorithm)
+        data, _ = _calculate_digest_and_algorithm(
+            data,
+            signature_algorithm.algorithm,
+        )
+        _ecdsa_sig_verify(self._backend, self, signature, data)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ed25519.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ed25519.py
new file mode 100644
index 0000000..5cfdffb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ed25519.py
@@ -0,0 +1,155 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography import exceptions
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import (
+    Ed25519PrivateKey,
+    Ed25519PublicKey,
+    _ED25519_KEY_SIZE,
+    _ED25519_SIG_SIZE,
+)
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+class _Ed25519PublicKey(Ed25519PublicKey):
+    def __init__(self, backend: "Backend", evp_pkey):
+        self._backend = backend
+        self._evp_pkey = evp_pkey
+
+    def public_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PublicFormat,
+    ) -> bytes:
+        if (
+            encoding is serialization.Encoding.Raw
+            or format is serialization.PublicFormat.Raw
+        ):
+            if (
+                encoding is not serialization.Encoding.Raw
+                or format is not serialization.PublicFormat.Raw
+            ):
+                raise ValueError(
+                    "When using Raw both encoding and format must be Raw"
+                )
+
+            return self._raw_public_bytes()
+
+        return self._backend._public_key_bytes(
+            encoding, format, self, self._evp_pkey, None
+        )
+
+    def _raw_public_bytes(self) -> bytes:
+        buf = self._backend._ffi.new("unsigned char []", _ED25519_KEY_SIZE)
+        buflen = self._backend._ffi.new("size_t *", _ED25519_KEY_SIZE)
+        res = self._backend._lib.EVP_PKEY_get_raw_public_key(
+            self._evp_pkey, buf, buflen
+        )
+        self._backend.openssl_assert(res == 1)
+        self._backend.openssl_assert(buflen[0] == _ED25519_KEY_SIZE)
+        return self._backend._ffi.buffer(buf, _ED25519_KEY_SIZE)[:]
+
+    def verify(self, signature: bytes, data: bytes) -> None:
+        evp_md_ctx = self._backend._lib.EVP_MD_CTX_new()
+        self._backend.openssl_assert(evp_md_ctx != self._backend._ffi.NULL)
+        evp_md_ctx = self._backend._ffi.gc(
+            evp_md_ctx, self._backend._lib.EVP_MD_CTX_free
+        )
+        res = self._backend._lib.EVP_DigestVerifyInit(
+            evp_md_ctx,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._evp_pkey,
+        )
+        self._backend.openssl_assert(res == 1)
+        res = self._backend._lib.EVP_DigestVerify(
+            evp_md_ctx, signature, len(signature), data, len(data)
+        )
+        if res != 1:
+            self._backend._consume_errors()
+            raise exceptions.InvalidSignature
+
+
+class _Ed25519PrivateKey(Ed25519PrivateKey):
+    def __init__(self, backend: "Backend", evp_pkey):
+        self._backend = backend
+        self._evp_pkey = evp_pkey
+
+    def public_key(self) -> Ed25519PublicKey:
+        buf = self._backend._ffi.new("unsigned char []", _ED25519_KEY_SIZE)
+        buflen = self._backend._ffi.new("size_t *", _ED25519_KEY_SIZE)
+        res = self._backend._lib.EVP_PKEY_get_raw_public_key(
+            self._evp_pkey, buf, buflen
+        )
+        self._backend.openssl_assert(res == 1)
+        self._backend.openssl_assert(buflen[0] == _ED25519_KEY_SIZE)
+        public_bytes = self._backend._ffi.buffer(buf)[:]
+        return self._backend.ed25519_load_public_bytes(public_bytes)
+
+    def sign(self, data: bytes) -> bytes:
+        evp_md_ctx = self._backend._lib.EVP_MD_CTX_new()
+        self._backend.openssl_assert(evp_md_ctx != self._backend._ffi.NULL)
+        evp_md_ctx = self._backend._ffi.gc(
+            evp_md_ctx, self._backend._lib.EVP_MD_CTX_free
+        )
+        res = self._backend._lib.EVP_DigestSignInit(
+            evp_md_ctx,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._evp_pkey,
+        )
+        self._backend.openssl_assert(res == 1)
+        buf = self._backend._ffi.new("unsigned char[]", _ED25519_SIG_SIZE)
+        buflen = self._backend._ffi.new("size_t *", len(buf))
+        res = self._backend._lib.EVP_DigestSign(
+            evp_md_ctx, buf, buflen, data, len(data)
+        )
+        self._backend.openssl_assert(res == 1)
+        self._backend.openssl_assert(buflen[0] == _ED25519_SIG_SIZE)
+        return self._backend._ffi.buffer(buf, buflen[0])[:]
+
+    def private_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PrivateFormat,
+        encryption_algorithm: serialization.KeySerializationEncryption,
+    ) -> bytes:
+        if (
+            encoding is serialization.Encoding.Raw
+            or format is serialization.PublicFormat.Raw
+        ):
+            if (
+                format is not serialization.PrivateFormat.Raw
+                or encoding is not serialization.Encoding.Raw
+                or not isinstance(
+                    encryption_algorithm, serialization.NoEncryption
+                )
+            ):
+                raise ValueError(
+                    "When using Raw both encoding and format must be Raw "
+                    "and encryption_algorithm must be NoEncryption()"
+                )
+
+            return self._raw_private_bytes()
+
+        return self._backend._private_key_bytes(
+            encoding, format, encryption_algorithm, self, self._evp_pkey, None
+        )
+
+    def _raw_private_bytes(self) -> bytes:
+        buf = self._backend._ffi.new("unsigned char []", _ED25519_KEY_SIZE)
+        buflen = self._backend._ffi.new("size_t *", _ED25519_KEY_SIZE)
+        res = self._backend._lib.EVP_PKEY_get_raw_private_key(
+            self._evp_pkey, buf, buflen
+        )
+        self._backend.openssl_assert(res == 1)
+        self._backend.openssl_assert(buflen[0] == _ED25519_KEY_SIZE)
+        return self._backend._ffi.buffer(buf, _ED25519_KEY_SIZE)[:]
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ed448.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ed448.py
new file mode 100644
index 0000000..dad93c6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/ed448.py
@@ -0,0 +1,156 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography import exceptions
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed448 import (
+    Ed448PrivateKey,
+    Ed448PublicKey,
+)
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+_ED448_KEY_SIZE = 57
+_ED448_SIG_SIZE = 114
+
+
+class _Ed448PublicKey(Ed448PublicKey):
+    def __init__(self, backend: "Backend", evp_pkey):
+        self._backend = backend
+        self._evp_pkey = evp_pkey
+
+    def public_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PublicFormat,
+    ) -> bytes:
+        if (
+            encoding is serialization.Encoding.Raw
+            or format is serialization.PublicFormat.Raw
+        ):
+            if (
+                encoding is not serialization.Encoding.Raw
+                or format is not serialization.PublicFormat.Raw
+            ):
+                raise ValueError(
+                    "When using Raw both encoding and format must be Raw"
+                )
+
+            return self._raw_public_bytes()
+
+        return self._backend._public_key_bytes(
+            encoding, format, self, self._evp_pkey, None
+        )
+
+    def _raw_public_bytes(self) -> bytes:
+        buf = self._backend._ffi.new("unsigned char []", _ED448_KEY_SIZE)
+        buflen = self._backend._ffi.new("size_t *", _ED448_KEY_SIZE)
+        res = self._backend._lib.EVP_PKEY_get_raw_public_key(
+            self._evp_pkey, buf, buflen
+        )
+        self._backend.openssl_assert(res == 1)
+        self._backend.openssl_assert(buflen[0] == _ED448_KEY_SIZE)
+        return self._backend._ffi.buffer(buf, _ED448_KEY_SIZE)[:]
+
+    def verify(self, signature: bytes, data: bytes) -> None:
+        evp_md_ctx = self._backend._lib.EVP_MD_CTX_new()
+        self._backend.openssl_assert(evp_md_ctx != self._backend._ffi.NULL)
+        evp_md_ctx = self._backend._ffi.gc(
+            evp_md_ctx, self._backend._lib.EVP_MD_CTX_free
+        )
+        res = self._backend._lib.EVP_DigestVerifyInit(
+            evp_md_ctx,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._evp_pkey,
+        )
+        self._backend.openssl_assert(res == 1)
+        res = self._backend._lib.EVP_DigestVerify(
+            evp_md_ctx, signature, len(signature), data, len(data)
+        )
+        if res != 1:
+            self._backend._consume_errors()
+            raise exceptions.InvalidSignature
+
+
+class _Ed448PrivateKey(Ed448PrivateKey):
+    def __init__(self, backend: "Backend", evp_pkey):
+        self._backend = backend
+        self._evp_pkey = evp_pkey
+
+    def public_key(self) -> Ed448PublicKey:
+        buf = self._backend._ffi.new("unsigned char []", _ED448_KEY_SIZE)
+        buflen = self._backend._ffi.new("size_t *", _ED448_KEY_SIZE)
+        res = self._backend._lib.EVP_PKEY_get_raw_public_key(
+            self._evp_pkey, buf, buflen
+        )
+        self._backend.openssl_assert(res == 1)
+        self._backend.openssl_assert(buflen[0] == _ED448_KEY_SIZE)
+        public_bytes = self._backend._ffi.buffer(buf)[:]
+        return self._backend.ed448_load_public_bytes(public_bytes)
+
+    def sign(self, data: bytes) -> bytes:
+        evp_md_ctx = self._backend._lib.EVP_MD_CTX_new()
+        self._backend.openssl_assert(evp_md_ctx != self._backend._ffi.NULL)
+        evp_md_ctx = self._backend._ffi.gc(
+            evp_md_ctx, self._backend._lib.EVP_MD_CTX_free
+        )
+        res = self._backend._lib.EVP_DigestSignInit(
+            evp_md_ctx,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._evp_pkey,
+        )
+        self._backend.openssl_assert(res == 1)
+        buf = self._backend._ffi.new("unsigned char[]", _ED448_SIG_SIZE)
+        buflen = self._backend._ffi.new("size_t *", len(buf))
+        res = self._backend._lib.EVP_DigestSign(
+            evp_md_ctx, buf, buflen, data, len(data)
+        )
+        self._backend.openssl_assert(res == 1)
+        self._backend.openssl_assert(buflen[0] == _ED448_SIG_SIZE)
+        return self._backend._ffi.buffer(buf, buflen[0])[:]
+
+    def private_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PrivateFormat,
+        encryption_algorithm: serialization.KeySerializationEncryption,
+    ) -> bytes:
+        if (
+            encoding is serialization.Encoding.Raw
+            or format is serialization.PublicFormat.Raw
+        ):
+            if (
+                format is not serialization.PrivateFormat.Raw
+                or encoding is not serialization.Encoding.Raw
+                or not isinstance(
+                    encryption_algorithm, serialization.NoEncryption
+                )
+            ):
+                raise ValueError(
+                    "When using Raw both encoding and format must be Raw "
+                    "and encryption_algorithm must be NoEncryption()"
+                )
+
+            return self._raw_private_bytes()
+
+        return self._backend._private_key_bytes(
+            encoding, format, encryption_algorithm, self, self._evp_pkey, None
+        )
+
+    def _raw_private_bytes(self) -> bytes:
+        buf = self._backend._ffi.new("unsigned char []", _ED448_KEY_SIZE)
+        buflen = self._backend._ffi.new("size_t *", _ED448_KEY_SIZE)
+        res = self._backend._lib.EVP_PKEY_get_raw_private_key(
+            self._evp_pkey, buf, buflen
+        )
+        self._backend.openssl_assert(res == 1)
+        self._backend.openssl_assert(buflen[0] == _ED448_KEY_SIZE)
+        return self._backend._ffi.buffer(buf, _ED448_KEY_SIZE)[:]
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/encode_asn1.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/encode_asn1.py
new file mode 100644
index 0000000..2f29d71
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/encode_asn1.py
@@ -0,0 +1,18 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+from cryptography import x509
+
+
+_CRLREASONFLAGS = {
+    x509.ReasonFlags.key_compromise: 1,
+    x509.ReasonFlags.ca_compromise: 2,
+    x509.ReasonFlags.affiliation_changed: 3,
+    x509.ReasonFlags.superseded: 4,
+    x509.ReasonFlags.cessation_of_operation: 5,
+    x509.ReasonFlags.certificate_hold: 6,
+    x509.ReasonFlags.privilege_withdrawn: 7,
+    x509.ReasonFlags.aa_compromise: 8,
+}
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/hashes.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/hashes.py
new file mode 100644
index 0000000..278b381
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/hashes.py
@@ -0,0 +1,87 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
+from cryptography.hazmat.primitives import hashes
+
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+class _HashContext(hashes.HashContext):
+    def __init__(
+        self, backend: "Backend", algorithm: hashes.HashAlgorithm, ctx=None
+    ) -> None:
+        self._algorithm = algorithm
+
+        self._backend = backend
+
+        if ctx is None:
+            ctx = self._backend._lib.EVP_MD_CTX_new()
+            ctx = self._backend._ffi.gc(
+                ctx, self._backend._lib.EVP_MD_CTX_free
+            )
+            evp_md = self._backend._evp_md_from_algorithm(algorithm)
+            if evp_md == self._backend._ffi.NULL:
+                raise UnsupportedAlgorithm(
+                    "{} is not a supported hash on this backend.".format(
+                        algorithm.name
+                    ),
+                    _Reasons.UNSUPPORTED_HASH,
+                )
+            res = self._backend._lib.EVP_DigestInit_ex(
+                ctx, evp_md, self._backend._ffi.NULL
+            )
+            self._backend.openssl_assert(res != 0)
+
+        self._ctx = ctx
+
+    @property
+    def algorithm(self) -> hashes.HashAlgorithm:
+        return self._algorithm
+
+    def copy(self) -> "_HashContext":
+        copied_ctx = self._backend._lib.EVP_MD_CTX_new()
+        copied_ctx = self._backend._ffi.gc(
+            copied_ctx, self._backend._lib.EVP_MD_CTX_free
+        )
+        res = self._backend._lib.EVP_MD_CTX_copy_ex(copied_ctx, self._ctx)
+        self._backend.openssl_assert(res != 0)
+        return _HashContext(self._backend, self.algorithm, ctx=copied_ctx)
+
+    def update(self, data: bytes) -> None:
+        data_ptr = self._backend._ffi.from_buffer(data)
+        res = self._backend._lib.EVP_DigestUpdate(
+            self._ctx, data_ptr, len(data)
+        )
+        self._backend.openssl_assert(res != 0)
+
+    def finalize(self) -> bytes:
+        if isinstance(self.algorithm, hashes.ExtendableOutputFunction):
+            # extendable output functions use a different finalize
+            return self._finalize_xof()
+        else:
+            buf = self._backend._ffi.new(
+                "unsigned char[]", self._backend._lib.EVP_MAX_MD_SIZE
+            )
+            outlen = self._backend._ffi.new("unsigned int *")
+            res = self._backend._lib.EVP_DigestFinal_ex(self._ctx, buf, outlen)
+            self._backend.openssl_assert(res != 0)
+            self._backend.openssl_assert(
+                outlen[0] == self.algorithm.digest_size
+            )
+            return self._backend._ffi.buffer(buf)[: outlen[0]]
+
+    def _finalize_xof(self) -> bytes:
+        buf = self._backend._ffi.new(
+            "unsigned char[]", self.algorithm.digest_size
+        )
+        res = self._backend._lib.EVP_DigestFinalXOF(
+            self._ctx, buf, self.algorithm.digest_size
+        )
+        self._backend.openssl_assert(res != 0)
+        return self._backend._ffi.buffer(buf)[: self.algorithm.digest_size]
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/hmac.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/hmac.py
new file mode 100644
index 0000000..5fd5407
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/hmac.py
@@ -0,0 +1,85 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.exceptions import (
+    InvalidSignature,
+    UnsupportedAlgorithm,
+    _Reasons,
+)
+from cryptography.hazmat.primitives import constant_time, hashes
+
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+class _HMACContext(hashes.HashContext):
+    def __init__(
+        self,
+        backend: "Backend",
+        key: bytes,
+        algorithm: hashes.HashAlgorithm,
+        ctx=None,
+    ):
+        self._algorithm = algorithm
+        self._backend = backend
+
+        if ctx is None:
+            ctx = self._backend._lib.HMAC_CTX_new()
+            self._backend.openssl_assert(ctx != self._backend._ffi.NULL)
+            ctx = self._backend._ffi.gc(ctx, self._backend._lib.HMAC_CTX_free)
+            evp_md = self._backend._evp_md_from_algorithm(algorithm)
+            if evp_md == self._backend._ffi.NULL:
+                raise UnsupportedAlgorithm(
+                    "{} is not a supported hash on this backend".format(
+                        algorithm.name
+                    ),
+                    _Reasons.UNSUPPORTED_HASH,
+                )
+            key_ptr = self._backend._ffi.from_buffer(key)
+            res = self._backend._lib.HMAC_Init_ex(
+                ctx, key_ptr, len(key), evp_md, self._backend._ffi.NULL
+            )
+            self._backend.openssl_assert(res != 0)
+
+        self._ctx = ctx
+        self._key = key
+
+    @property
+    def algorithm(self) -> hashes.HashAlgorithm:
+        return self._algorithm
+
+    def copy(self) -> "_HMACContext":
+        copied_ctx = self._backend._lib.HMAC_CTX_new()
+        self._backend.openssl_assert(copied_ctx != self._backend._ffi.NULL)
+        copied_ctx = self._backend._ffi.gc(
+            copied_ctx, self._backend._lib.HMAC_CTX_free
+        )
+        res = self._backend._lib.HMAC_CTX_copy(copied_ctx, self._ctx)
+        self._backend.openssl_assert(res != 0)
+        return _HMACContext(
+            self._backend, self._key, self.algorithm, ctx=copied_ctx
+        )
+
+    def update(self, data: bytes) -> None:
+        data_ptr = self._backend._ffi.from_buffer(data)
+        res = self._backend._lib.HMAC_Update(self._ctx, data_ptr, len(data))
+        self._backend.openssl_assert(res != 0)
+
+    def finalize(self) -> bytes:
+        buf = self._backend._ffi.new(
+            "unsigned char[]", self._backend._lib.EVP_MAX_MD_SIZE
+        )
+        outlen = self._backend._ffi.new("unsigned int *")
+        res = self._backend._lib.HMAC_Final(self._ctx, buf, outlen)
+        self._backend.openssl_assert(res != 0)
+        self._backend.openssl_assert(outlen[0] == self.algorithm.digest_size)
+        return self._backend._ffi.buffer(buf)[: outlen[0]]
+
+    def verify(self, signature: bytes) -> None:
+        digest = self.finalize()
+        if not constant_time.bytes_eq(digest, signature):
+            raise InvalidSignature("Signature did not match digest.")
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/poly1305.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/poly1305.py
new file mode 100644
index 0000000..dd6d376
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/poly1305.py
@@ -0,0 +1,68 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import constant_time
+
+
+_POLY1305_TAG_SIZE = 16
+_POLY1305_KEY_SIZE = 32
+
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+class _Poly1305Context:
+    def __init__(self, backend: "Backend", key: bytes) -> None:
+        self._backend = backend
+
+        key_ptr = self._backend._ffi.from_buffer(key)
+        # This function copies the key into OpenSSL-owned memory so we don't
+        # need to retain it ourselves
+        evp_pkey = self._backend._lib.EVP_PKEY_new_raw_private_key(
+            self._backend._lib.NID_poly1305,
+            self._backend._ffi.NULL,
+            key_ptr,
+            len(key),
+        )
+        self._backend.openssl_assert(evp_pkey != self._backend._ffi.NULL)
+        self._evp_pkey = self._backend._ffi.gc(
+            evp_pkey, self._backend._lib.EVP_PKEY_free
+        )
+        ctx = self._backend._lib.EVP_MD_CTX_new()
+        self._backend.openssl_assert(ctx != self._backend._ffi.NULL)
+        self._ctx = self._backend._ffi.gc(
+            ctx, self._backend._lib.EVP_MD_CTX_free
+        )
+        res = self._backend._lib.EVP_DigestSignInit(
+            self._ctx,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._evp_pkey,
+        )
+        self._backend.openssl_assert(res == 1)
+
+    def update(self, data: bytes) -> None:
+        data_ptr = self._backend._ffi.from_buffer(data)
+        res = self._backend._lib.EVP_DigestSignUpdate(
+            self._ctx, data_ptr, len(data)
+        )
+        self._backend.openssl_assert(res != 0)
+
+    def finalize(self) -> bytes:
+        buf = self._backend._ffi.new("unsigned char[]", _POLY1305_TAG_SIZE)
+        outlen = self._backend._ffi.new("size_t *", _POLY1305_TAG_SIZE)
+        res = self._backend._lib.EVP_DigestSignFinal(self._ctx, buf, outlen)
+        self._backend.openssl_assert(res != 0)
+        self._backend.openssl_assert(outlen[0] == _POLY1305_TAG_SIZE)
+        return self._backend._ffi.buffer(buf)[: outlen[0]]
+
+    def verify(self, tag: bytes) -> None:
+        mac = self.finalize()
+        if not constant_time.bytes_eq(mac, tag):
+            raise InvalidSignature("Value did not match computed tag.")
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/rsa.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/rsa.py
new file mode 100644
index 0000000..20b643c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/rsa.py
@@ -0,0 +1,567 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import typing
+
+from cryptography.exceptions import (
+    InvalidSignature,
+    UnsupportedAlgorithm,
+    _Reasons,
+)
+from cryptography.hazmat.backends.openssl.utils import (
+    _calculate_digest_and_algorithm,
+)
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import (
+    utils as asym_utils,
+)
+from cryptography.hazmat.primitives.asymmetric.padding import (
+    AsymmetricPadding,
+    MGF1,
+    OAEP,
+    PKCS1v15,
+    PSS,
+    _Auto,
+    _DigestLength,
+    _MaxLength,
+    calculate_max_pss_salt_length,
+)
+from cryptography.hazmat.primitives.asymmetric.rsa import (
+    RSAPrivateKey,
+    RSAPrivateNumbers,
+    RSAPublicKey,
+    RSAPublicNumbers,
+)
+
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+def _get_rsa_pss_salt_length(
+    backend: "Backend",
+    pss: PSS,
+    key: typing.Union[RSAPrivateKey, RSAPublicKey],
+    hash_algorithm: hashes.HashAlgorithm,
+) -> int:
+    salt = pss._salt_length
+
+    if isinstance(salt, _MaxLength):
+        return calculate_max_pss_salt_length(key, hash_algorithm)
+    elif isinstance(salt, _DigestLength):
+        return hash_algorithm.digest_size
+    elif isinstance(salt, _Auto):
+        if isinstance(key, RSAPrivateKey):
+            raise ValueError(
+                "PSS salt length can only be set to AUTO when verifying"
+            )
+        return backend._lib.RSA_PSS_SALTLEN_AUTO
+    else:
+        return salt
+
+
+def _enc_dec_rsa(
+    backend: "Backend",
+    key: typing.Union["_RSAPrivateKey", "_RSAPublicKey"],
+    data: bytes,
+    padding: AsymmetricPadding,
+) -> bytes:
+    if not isinstance(padding, AsymmetricPadding):
+        raise TypeError("Padding must be an instance of AsymmetricPadding.")
+
+    if isinstance(padding, PKCS1v15):
+        padding_enum = backend._lib.RSA_PKCS1_PADDING
+    elif isinstance(padding, OAEP):
+        padding_enum = backend._lib.RSA_PKCS1_OAEP_PADDING
+
+        if not isinstance(padding._mgf, MGF1):
+            raise UnsupportedAlgorithm(
+                "Only MGF1 is supported by this backend.",
+                _Reasons.UNSUPPORTED_MGF,
+            )
+
+        if not backend.rsa_padding_supported(padding):
+            raise UnsupportedAlgorithm(
+                "This combination of padding and hash algorithm is not "
+                "supported by this backend.",
+                _Reasons.UNSUPPORTED_PADDING,
+            )
+
+    else:
+        raise UnsupportedAlgorithm(
+            "{} is not supported by this backend.".format(padding.name),
+            _Reasons.UNSUPPORTED_PADDING,
+        )
+
+    return _enc_dec_rsa_pkey_ctx(backend, key, data, padding_enum, padding)
+
+
+def _enc_dec_rsa_pkey_ctx(
+    backend: "Backend",
+    key: typing.Union["_RSAPrivateKey", "_RSAPublicKey"],
+    data: bytes,
+    padding_enum: int,
+    padding: AsymmetricPadding,
+) -> bytes:
+    init: typing.Callable[[typing.Any], int]
+    crypt: typing.Callable[[typing.Any, typing.Any, int, bytes, int], int]
+    if isinstance(key, _RSAPublicKey):
+        init = backend._lib.EVP_PKEY_encrypt_init
+        crypt = backend._lib.EVP_PKEY_encrypt
+    else:
+        init = backend._lib.EVP_PKEY_decrypt_init
+        crypt = backend._lib.EVP_PKEY_decrypt
+
+    pkey_ctx = backend._lib.EVP_PKEY_CTX_new(key._evp_pkey, backend._ffi.NULL)
+    backend.openssl_assert(pkey_ctx != backend._ffi.NULL)
+    pkey_ctx = backend._ffi.gc(pkey_ctx, backend._lib.EVP_PKEY_CTX_free)
+    res = init(pkey_ctx)
+    backend.openssl_assert(res == 1)
+    res = backend._lib.EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, padding_enum)
+    backend.openssl_assert(res > 0)
+    buf_size = backend._lib.EVP_PKEY_size(key._evp_pkey)
+    backend.openssl_assert(buf_size > 0)
+    if isinstance(padding, OAEP):
+        mgf1_md = backend._evp_md_non_null_from_algorithm(
+            padding._mgf._algorithm
+        )
+        res = backend._lib.EVP_PKEY_CTX_set_rsa_mgf1_md(pkey_ctx, mgf1_md)
+        backend.openssl_assert(res > 0)
+        oaep_md = backend._evp_md_non_null_from_algorithm(padding._algorithm)
+        res = backend._lib.EVP_PKEY_CTX_set_rsa_oaep_md(pkey_ctx, oaep_md)
+        backend.openssl_assert(res > 0)
+
+    if (
+        isinstance(padding, OAEP)
+        and padding._label is not None
+        and len(padding._label) > 0
+    ):
+        # set0_rsa_oaep_label takes ownership of the char * so we need to
+        # copy it into some new memory
+        labelptr = backend._lib.OPENSSL_malloc(len(padding._label))
+        backend.openssl_assert(labelptr != backend._ffi.NULL)
+        backend._ffi.memmove(labelptr, padding._label, len(padding._label))
+        res = backend._lib.EVP_PKEY_CTX_set0_rsa_oaep_label(
+            pkey_ctx, labelptr, len(padding._label)
+        )
+        backend.openssl_assert(res == 1)
+
+    outlen = backend._ffi.new("size_t *", buf_size)
+    buf = backend._ffi.new("unsigned char[]", buf_size)
+    # Everything from this line onwards is written with the goal of being as
+    # constant-time as is practical given the constraints of Python and our
+    # API. See Bleichenbacher's '98 attack on RSA, and its many many variants.
+    # As such, you should not attempt to change this (particularly to "clean it
+    # up") without understanding why it was written this way (see
+    # Chesterton's Fence), and without measuring to verify you have not
+    # introduced observable time differences.
+    res = crypt(pkey_ctx, buf, outlen, data, len(data))
+    resbuf = backend._ffi.buffer(buf)[: outlen[0]]
+    backend._lib.ERR_clear_error()
+    if res <= 0:
+        raise ValueError("Encryption/decryption failed.")
+    return resbuf
+
+
+def _rsa_sig_determine_padding(
+    backend: "Backend",
+    key: typing.Union["_RSAPrivateKey", "_RSAPublicKey"],
+    padding: AsymmetricPadding,
+    algorithm: typing.Optional[hashes.HashAlgorithm],
+) -> int:
+    if not isinstance(padding, AsymmetricPadding):
+        raise TypeError("Expected provider of AsymmetricPadding.")
+
+    pkey_size = backend._lib.EVP_PKEY_size(key._evp_pkey)
+    backend.openssl_assert(pkey_size > 0)
+
+    if isinstance(padding, PKCS1v15):
+        # Hash algorithm is ignored for PKCS1v15-padding, may be None.
+        padding_enum = backend._lib.RSA_PKCS1_PADDING
+    elif isinstance(padding, PSS):
+        if not isinstance(padding._mgf, MGF1):
+            raise UnsupportedAlgorithm(
+                "Only MGF1 is supported by this backend.",
+                _Reasons.UNSUPPORTED_MGF,
+            )
+
+        # PSS padding requires a hash algorithm
+        if not isinstance(algorithm, hashes.HashAlgorithm):
+            raise TypeError("Expected instance of hashes.HashAlgorithm.")
+
+        # Size of key in bytes - 2 is the maximum
+        # PSS signature length (salt length is checked later)
+        if pkey_size - algorithm.digest_size - 2 < 0:
+            raise ValueError(
+                "Digest too large for key size. Use a larger "
+                "key or different digest."
+            )
+
+        padding_enum = backend._lib.RSA_PKCS1_PSS_PADDING
+    else:
+        raise UnsupportedAlgorithm(
+            "{} is not supported by this backend.".format(padding.name),
+            _Reasons.UNSUPPORTED_PADDING,
+        )
+
+    return padding_enum
+
+
+# Hash algorithm can be absent (None) to initialize the context without setting
+# any message digest algorithm. This is currently only valid for the PKCS1v15
+# padding type, where it means that the signature data is encoded/decoded
+# as provided, without being wrapped in a DigestInfo structure.
+def _rsa_sig_setup(
+    backend: "Backend",
+    padding: AsymmetricPadding,
+    algorithm: typing.Optional[hashes.HashAlgorithm],
+    key: typing.Union["_RSAPublicKey", "_RSAPrivateKey"],
+    init_func: typing.Callable[[typing.Any], int],
+):
+    padding_enum = _rsa_sig_determine_padding(backend, key, padding, algorithm)
+    pkey_ctx = backend._lib.EVP_PKEY_CTX_new(key._evp_pkey, backend._ffi.NULL)
+    backend.openssl_assert(pkey_ctx != backend._ffi.NULL)
+    pkey_ctx = backend._ffi.gc(pkey_ctx, backend._lib.EVP_PKEY_CTX_free)
+    res = init_func(pkey_ctx)
+    if res != 1:
+        errors = backend._consume_errors()
+        raise ValueError("Unable to sign/verify with this key", errors)
+
+    if algorithm is not None:
+        evp_md = backend._evp_md_non_null_from_algorithm(algorithm)
+        res = backend._lib.EVP_PKEY_CTX_set_signature_md(pkey_ctx, evp_md)
+        if res <= 0:
+            backend._consume_errors()
+            raise UnsupportedAlgorithm(
+                "{} is not supported by this backend for RSA signing.".format(
+                    algorithm.name
+                ),
+                _Reasons.UNSUPPORTED_HASH,
+            )
+    res = backend._lib.EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, padding_enum)
+    if res <= 0:
+        backend._consume_errors()
+        raise UnsupportedAlgorithm(
+            "{} is not supported for the RSA signature operation.".format(
+                padding.name
+            ),
+            _Reasons.UNSUPPORTED_PADDING,
+        )
+    if isinstance(padding, PSS):
+        assert isinstance(algorithm, hashes.HashAlgorithm)
+        res = backend._lib.EVP_PKEY_CTX_set_rsa_pss_saltlen(
+            pkey_ctx,
+            _get_rsa_pss_salt_length(backend, padding, key, algorithm),
+        )
+        backend.openssl_assert(res > 0)
+
+        mgf1_md = backend._evp_md_non_null_from_algorithm(
+            padding._mgf._algorithm
+        )
+        res = backend._lib.EVP_PKEY_CTX_set_rsa_mgf1_md(pkey_ctx, mgf1_md)
+        backend.openssl_assert(res > 0)
+
+    return pkey_ctx
+
+
+def _rsa_sig_sign(
+    backend: "Backend",
+    padding: AsymmetricPadding,
+    algorithm: hashes.HashAlgorithm,
+    private_key: "_RSAPrivateKey",
+    data: bytes,
+) -> bytes:
+    pkey_ctx = _rsa_sig_setup(
+        backend,
+        padding,
+        algorithm,
+        private_key,
+        backend._lib.EVP_PKEY_sign_init,
+    )
+    buflen = backend._ffi.new("size_t *")
+    res = backend._lib.EVP_PKEY_sign(
+        pkey_ctx, backend._ffi.NULL, buflen, data, len(data)
+    )
+    backend.openssl_assert(res == 1)
+    buf = backend._ffi.new("unsigned char[]", buflen[0])
+    res = backend._lib.EVP_PKEY_sign(pkey_ctx, buf, buflen, data, len(data))
+    if res != 1:
+        errors = backend._consume_errors_with_text()
+        raise ValueError(
+            "Digest or salt length too long for key size. Use a larger key "
+            "or shorter salt length if you are specifying a PSS salt",
+            errors,
+        )
+
+    return backend._ffi.buffer(buf)[:]
+
+
+def _rsa_sig_verify(
+    backend: "Backend",
+    padding: AsymmetricPadding,
+    algorithm: hashes.HashAlgorithm,
+    public_key: "_RSAPublicKey",
+    signature: bytes,
+    data: bytes,
+) -> None:
+    pkey_ctx = _rsa_sig_setup(
+        backend,
+        padding,
+        algorithm,
+        public_key,
+        backend._lib.EVP_PKEY_verify_init,
+    )
+    res = backend._lib.EVP_PKEY_verify(
+        pkey_ctx, signature, len(signature), data, len(data)
+    )
+    # The previous call can return negative numbers in the event of an
+    # error. This is not a signature failure but we need to fail if it
+    # occurs.
+    backend.openssl_assert(res >= 0)
+    if res == 0:
+        backend._consume_errors()
+        raise InvalidSignature
+
+
+def _rsa_sig_recover(
+    backend: "Backend",
+    padding: AsymmetricPadding,
+    algorithm: typing.Optional[hashes.HashAlgorithm],
+    public_key: "_RSAPublicKey",
+    signature: bytes,
+) -> bytes:
+    pkey_ctx = _rsa_sig_setup(
+        backend,
+        padding,
+        algorithm,
+        public_key,
+        backend._lib.EVP_PKEY_verify_recover_init,
+    )
+
+    # Attempt to keep the rest of the code in this function as constant/time
+    # as possible. See the comment in _enc_dec_rsa_pkey_ctx. Note that the
+    # buflen parameter is used even though its value may be undefined in the
+    # error case. Due to the tolerant nature of Python slicing this does not
+    # trigger any exceptions.
+    maxlen = backend._lib.EVP_PKEY_size(public_key._evp_pkey)
+    backend.openssl_assert(maxlen > 0)
+    buf = backend._ffi.new("unsigned char[]", maxlen)
+    buflen = backend._ffi.new("size_t *", maxlen)
+    res = backend._lib.EVP_PKEY_verify_recover(
+        pkey_ctx, buf, buflen, signature, len(signature)
+    )
+    resbuf = backend._ffi.buffer(buf)[: buflen[0]]
+    backend._lib.ERR_clear_error()
+    # Assume that all parameter errors are handled during the setup phase and
+    # any error here is due to invalid signature.
+    if res != 1:
+        raise InvalidSignature
+    return resbuf
+
+
+class _RSAPrivateKey(RSAPrivateKey):
+    _evp_pkey: object
+    _rsa_cdata: object
+    _key_size: int
+
+    def __init__(
+        self, backend: "Backend", rsa_cdata, evp_pkey, _skip_check_key: bool
+    ):
+        res: int
+        # RSA_check_key is slower in OpenSSL 3.0.0 due to improved
+        # primality checking. In normal use this is unlikely to be a problem
+        # since users don't load new keys constantly, but for TESTING we've
+        # added an init arg that allows skipping the checks. You should not
+        # use this in production code unless you understand the consequences.
+        if not _skip_check_key:
+            res = backend._lib.RSA_check_key(rsa_cdata)
+            if res != 1:
+                errors = backend._consume_errors_with_text()
+                raise ValueError("Invalid private key", errors)
+            # 2 is prime and passes an RSA key check, so we also check
+            # if p and q are odd just to be safe.
+            p = backend._ffi.new("BIGNUM **")
+            q = backend._ffi.new("BIGNUM **")
+            backend._lib.RSA_get0_factors(rsa_cdata, p, q)
+            backend.openssl_assert(p[0] != backend._ffi.NULL)
+            backend.openssl_assert(q[0] != backend._ffi.NULL)
+            p_odd = backend._lib.BN_is_odd(p[0])
+            q_odd = backend._lib.BN_is_odd(q[0])
+            if p_odd != 1 or q_odd != 1:
+                errors = backend._consume_errors_with_text()
+                raise ValueError("Invalid private key", errors)
+
+        # Blinding is on by default in many versions of OpenSSL, but let's
+        # just be conservative here.
+        res = backend._lib.RSA_blinding_on(rsa_cdata, backend._ffi.NULL)
+        backend.openssl_assert(res == 1)
+
+        self._backend = backend
+        self._rsa_cdata = rsa_cdata
+        self._evp_pkey = evp_pkey
+
+        n = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.RSA_get0_key(
+            self._rsa_cdata,
+            n,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+        )
+        self._backend.openssl_assert(n[0] != self._backend._ffi.NULL)
+        self._key_size = self._backend._lib.BN_num_bits(n[0])
+
+    @property
+    def key_size(self) -> int:
+        return self._key_size
+
+    def decrypt(self, ciphertext: bytes, padding: AsymmetricPadding) -> bytes:
+        key_size_bytes = (self.key_size + 7) // 8
+        if key_size_bytes != len(ciphertext):
+            raise ValueError("Ciphertext length must be equal to key size.")
+
+        return _enc_dec_rsa(self._backend, self, ciphertext, padding)
+
+    def public_key(self) -> RSAPublicKey:
+        ctx = self._backend._lib.RSAPublicKey_dup(self._rsa_cdata)
+        self._backend.openssl_assert(ctx != self._backend._ffi.NULL)
+        ctx = self._backend._ffi.gc(ctx, self._backend._lib.RSA_free)
+        evp_pkey = self._backend._rsa_cdata_to_evp_pkey(ctx)
+        return _RSAPublicKey(self._backend, ctx, evp_pkey)
+
+    def private_numbers(self) -> RSAPrivateNumbers:
+        n = self._backend._ffi.new("BIGNUM **")
+        e = self._backend._ffi.new("BIGNUM **")
+        d = self._backend._ffi.new("BIGNUM **")
+        p = self._backend._ffi.new("BIGNUM **")
+        q = self._backend._ffi.new("BIGNUM **")
+        dmp1 = self._backend._ffi.new("BIGNUM **")
+        dmq1 = self._backend._ffi.new("BIGNUM **")
+        iqmp = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.RSA_get0_key(self._rsa_cdata, n, e, d)
+        self._backend.openssl_assert(n[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(e[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(d[0] != self._backend._ffi.NULL)
+        self._backend._lib.RSA_get0_factors(self._rsa_cdata, p, q)
+        self._backend.openssl_assert(p[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(q[0] != self._backend._ffi.NULL)
+        self._backend._lib.RSA_get0_crt_params(
+            self._rsa_cdata, dmp1, dmq1, iqmp
+        )
+        self._backend.openssl_assert(dmp1[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(dmq1[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(iqmp[0] != self._backend._ffi.NULL)
+        return RSAPrivateNumbers(
+            p=self._backend._bn_to_int(p[0]),
+            q=self._backend._bn_to_int(q[0]),
+            d=self._backend._bn_to_int(d[0]),
+            dmp1=self._backend._bn_to_int(dmp1[0]),
+            dmq1=self._backend._bn_to_int(dmq1[0]),
+            iqmp=self._backend._bn_to_int(iqmp[0]),
+            public_numbers=RSAPublicNumbers(
+                e=self._backend._bn_to_int(e[0]),
+                n=self._backend._bn_to_int(n[0]),
+            ),
+        )
+
+    def private_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PrivateFormat,
+        encryption_algorithm: serialization.KeySerializationEncryption,
+    ) -> bytes:
+        return self._backend._private_key_bytes(
+            encoding,
+            format,
+            encryption_algorithm,
+            self,
+            self._evp_pkey,
+            self._rsa_cdata,
+        )
+
+    def sign(
+        self,
+        data: bytes,
+        padding: AsymmetricPadding,
+        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
+    ) -> bytes:
+        data, algorithm = _calculate_digest_and_algorithm(data, algorithm)
+        return _rsa_sig_sign(self._backend, padding, algorithm, self, data)
+
+
+class _RSAPublicKey(RSAPublicKey):
+    _evp_pkey: object
+    _rsa_cdata: object
+    _key_size: int
+
+    def __init__(self, backend: "Backend", rsa_cdata, evp_pkey):
+        self._backend = backend
+        self._rsa_cdata = rsa_cdata
+        self._evp_pkey = evp_pkey
+
+        n = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.RSA_get0_key(
+            self._rsa_cdata,
+            n,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+        )
+        self._backend.openssl_assert(n[0] != self._backend._ffi.NULL)
+        self._key_size = self._backend._lib.BN_num_bits(n[0])
+
+    @property
+    def key_size(self) -> int:
+        return self._key_size
+
+    def encrypt(self, plaintext: bytes, padding: AsymmetricPadding) -> bytes:
+        return _enc_dec_rsa(self._backend, self, plaintext, padding)
+
+    def public_numbers(self) -> RSAPublicNumbers:
+        n = self._backend._ffi.new("BIGNUM **")
+        e = self._backend._ffi.new("BIGNUM **")
+        self._backend._lib.RSA_get0_key(
+            self._rsa_cdata, n, e, self._backend._ffi.NULL
+        )
+        self._backend.openssl_assert(n[0] != self._backend._ffi.NULL)
+        self._backend.openssl_assert(e[0] != self._backend._ffi.NULL)
+        return RSAPublicNumbers(
+            e=self._backend._bn_to_int(e[0]),
+            n=self._backend._bn_to_int(n[0]),
+        )
+
+    def public_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PublicFormat,
+    ) -> bytes:
+        return self._backend._public_key_bytes(
+            encoding, format, self, self._evp_pkey, self._rsa_cdata
+        )
+
+    def verify(
+        self,
+        signature: bytes,
+        data: bytes,
+        padding: AsymmetricPadding,
+        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
+    ) -> None:
+        data, algorithm = _calculate_digest_and_algorithm(data, algorithm)
+        _rsa_sig_verify(
+            self._backend, padding, algorithm, self, signature, data
+        )
+
+    def recover_data_from_signature(
+        self,
+        signature: bytes,
+        padding: AsymmetricPadding,
+        algorithm: typing.Optional[hashes.HashAlgorithm],
+    ) -> bytes:
+        if isinstance(algorithm, asym_utils.Prehashed):
+            raise TypeError(
+                "Prehashed is only supported in the sign and verify methods. "
+                "It cannot be used with recover_data_from_signature."
+            )
+        return _rsa_sig_recover(
+            self._backend, padding, algorithm, self, signature
+        )
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/utils.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/utils.py
new file mode 100644
index 0000000..3a70a58
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/utils.py
@@ -0,0 +1,52 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric.utils import Prehashed
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+def _evp_pkey_derive(backend: "Backend", evp_pkey, peer_public_key) -> bytes:
+    ctx = backend._lib.EVP_PKEY_CTX_new(evp_pkey, backend._ffi.NULL)
+    backend.openssl_assert(ctx != backend._ffi.NULL)
+    ctx = backend._ffi.gc(ctx, backend._lib.EVP_PKEY_CTX_free)
+    res = backend._lib.EVP_PKEY_derive_init(ctx)
+    backend.openssl_assert(res == 1)
+    res = backend._lib.EVP_PKEY_derive_set_peer(ctx, peer_public_key._evp_pkey)
+    backend.openssl_assert(res == 1)
+    keylen = backend._ffi.new("size_t *")
+    res = backend._lib.EVP_PKEY_derive(ctx, backend._ffi.NULL, keylen)
+    backend.openssl_assert(res == 1)
+    backend.openssl_assert(keylen[0] > 0)
+    buf = backend._ffi.new("unsigned char[]", keylen[0])
+    res = backend._lib.EVP_PKEY_derive(ctx, buf, keylen)
+    if res != 1:
+        errors_with_text = backend._consume_errors_with_text()
+        raise ValueError("Error computing shared key.", errors_with_text)
+
+    return backend._ffi.buffer(buf, keylen[0])[:]
+
+
+def _calculate_digest_and_algorithm(
+    data: bytes,
+    algorithm: typing.Union[Prehashed, hashes.HashAlgorithm],
+) -> typing.Tuple[bytes, hashes.HashAlgorithm]:
+    if not isinstance(algorithm, Prehashed):
+        hash_ctx = hashes.Hash(algorithm)
+        hash_ctx.update(data)
+        data = hash_ctx.finalize()
+    else:
+        algorithm = algorithm._algorithm
+
+    if len(data) != algorithm.digest_size:
+        raise ValueError(
+            "The provided data must be the same length as the hash "
+            "algorithm's digest size."
+        )
+
+    return (data, algorithm)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/x25519.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/x25519.py
new file mode 100644
index 0000000..f68501a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/x25519.py
@@ -0,0 +1,132 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.backends.openssl.utils import _evp_pkey_derive
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.x25519 import (
+    X25519PrivateKey,
+    X25519PublicKey,
+)
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+_X25519_KEY_SIZE = 32
+
+
+class _X25519PublicKey(X25519PublicKey):
+    def __init__(self, backend: "Backend", evp_pkey):
+        self._backend = backend
+        self._evp_pkey = evp_pkey
+
+    def public_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PublicFormat,
+    ) -> bytes:
+        if (
+            encoding is serialization.Encoding.Raw
+            or format is serialization.PublicFormat.Raw
+        ):
+            if (
+                encoding is not serialization.Encoding.Raw
+                or format is not serialization.PublicFormat.Raw
+            ):
+                raise ValueError(
+                    "When using Raw both encoding and format must be Raw"
+                )
+
+            return self._raw_public_bytes()
+
+        return self._backend._public_key_bytes(
+            encoding, format, self, self._evp_pkey, None
+        )
+
+    def _raw_public_bytes(self) -> bytes:
+        ucharpp = self._backend._ffi.new("unsigned char **")
+        res = self._backend._lib.EVP_PKEY_get1_tls_encodedpoint(
+            self._evp_pkey, ucharpp
+        )
+        self._backend.openssl_assert(res == 32)
+        self._backend.openssl_assert(ucharpp[0] != self._backend._ffi.NULL)
+        data = self._backend._ffi.gc(
+            ucharpp[0], self._backend._lib.OPENSSL_free
+        )
+        return self._backend._ffi.buffer(data, res)[:]
+
+
+class _X25519PrivateKey(X25519PrivateKey):
+    def __init__(self, backend: "Backend", evp_pkey):
+        self._backend = backend
+        self._evp_pkey = evp_pkey
+
+    def public_key(self) -> X25519PublicKey:
+        bio = self._backend._create_mem_bio_gc()
+        res = self._backend._lib.i2d_PUBKEY_bio(bio, self._evp_pkey)
+        self._backend.openssl_assert(res == 1)
+        evp_pkey = self._backend._lib.d2i_PUBKEY_bio(
+            bio, self._backend._ffi.NULL
+        )
+        self._backend.openssl_assert(evp_pkey != self._backend._ffi.NULL)
+        evp_pkey = self._backend._ffi.gc(
+            evp_pkey, self._backend._lib.EVP_PKEY_free
+        )
+        return _X25519PublicKey(self._backend, evp_pkey)
+
+    def exchange(self, peer_public_key: X25519PublicKey) -> bytes:
+        if not isinstance(peer_public_key, X25519PublicKey):
+            raise TypeError("peer_public_key must be X25519PublicKey.")
+
+        return _evp_pkey_derive(self._backend, self._evp_pkey, peer_public_key)
+
+    def private_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PrivateFormat,
+        encryption_algorithm: serialization.KeySerializationEncryption,
+    ) -> bytes:
+        if (
+            encoding is serialization.Encoding.Raw
+            or format is serialization.PublicFormat.Raw
+        ):
+            if (
+                format is not serialization.PrivateFormat.Raw
+                or encoding is not serialization.Encoding.Raw
+                or not isinstance(
+                    encryption_algorithm, serialization.NoEncryption
+                )
+            ):
+                raise ValueError(
+                    "When using Raw both encoding and format must be Raw "
+                    "and encryption_algorithm must be NoEncryption()"
+                )
+
+            return self._raw_private_bytes()
+
+        return self._backend._private_key_bytes(
+            encoding, format, encryption_algorithm, self, self._evp_pkey, None
+        )
+
+    def _raw_private_bytes(self) -> bytes:
+        # When we drop support for CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 we can
+        # switch this to EVP_PKEY_new_raw_private_key
+        # The trick we use here is serializing to a PKCS8 key and just
+        # using the last 32 bytes, which is the key itself.
+        bio = self._backend._create_mem_bio_gc()
+        res = self._backend._lib.i2d_PKCS8PrivateKey_bio(
+            bio,
+            self._evp_pkey,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            0,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+        )
+        self._backend.openssl_assert(res == 1)
+        pkcs8 = self._backend._read_mem_bio(bio)
+        self._backend.openssl_assert(len(pkcs8) == 48)
+        return pkcs8[-_X25519_KEY_SIZE:]
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/x448.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/x448.py
new file mode 100644
index 0000000..f45db56
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/x448.py
@@ -0,0 +1,117 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.backends.openssl.utils import _evp_pkey_derive
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.x448 import (
+    X448PrivateKey,
+    X448PublicKey,
+)
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+_X448_KEY_SIZE = 56
+
+
+class _X448PublicKey(X448PublicKey):
+    def __init__(self, backend: "Backend", evp_pkey):
+        self._backend = backend
+        self._evp_pkey = evp_pkey
+
+    def public_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PublicFormat,
+    ) -> bytes:
+        if (
+            encoding is serialization.Encoding.Raw
+            or format is serialization.PublicFormat.Raw
+        ):
+            if (
+                encoding is not serialization.Encoding.Raw
+                or format is not serialization.PublicFormat.Raw
+            ):
+                raise ValueError(
+                    "When using Raw both encoding and format must be Raw"
+                )
+
+            return self._raw_public_bytes()
+
+        return self._backend._public_key_bytes(
+            encoding, format, self, self._evp_pkey, None
+        )
+
+    def _raw_public_bytes(self) -> bytes:
+        buf = self._backend._ffi.new("unsigned char []", _X448_KEY_SIZE)
+        buflen = self._backend._ffi.new("size_t *", _X448_KEY_SIZE)
+        res = self._backend._lib.EVP_PKEY_get_raw_public_key(
+            self._evp_pkey, buf, buflen
+        )
+        self._backend.openssl_assert(res == 1)
+        self._backend.openssl_assert(buflen[0] == _X448_KEY_SIZE)
+        return self._backend._ffi.buffer(buf, _X448_KEY_SIZE)[:]
+
+
+class _X448PrivateKey(X448PrivateKey):
+    def __init__(self, backend: "Backend", evp_pkey):
+        self._backend = backend
+        self._evp_pkey = evp_pkey
+
+    def public_key(self) -> X448PublicKey:
+        buf = self._backend._ffi.new("unsigned char []", _X448_KEY_SIZE)
+        buflen = self._backend._ffi.new("size_t *", _X448_KEY_SIZE)
+        res = self._backend._lib.EVP_PKEY_get_raw_public_key(
+            self._evp_pkey, buf, buflen
+        )
+        self._backend.openssl_assert(res == 1)
+        self._backend.openssl_assert(buflen[0] == _X448_KEY_SIZE)
+        public_bytes = self._backend._ffi.buffer(buf)[:]
+        return self._backend.x448_load_public_bytes(public_bytes)
+
+    def exchange(self, peer_public_key: X448PublicKey) -> bytes:
+        if not isinstance(peer_public_key, X448PublicKey):
+            raise TypeError("peer_public_key must be X448PublicKey.")
+
+        return _evp_pkey_derive(self._backend, self._evp_pkey, peer_public_key)
+
+    def private_bytes(
+        self,
+        encoding: serialization.Encoding,
+        format: serialization.PrivateFormat,
+        encryption_algorithm: serialization.KeySerializationEncryption,
+    ) -> bytes:
+        if (
+            encoding is serialization.Encoding.Raw
+            or format is serialization.PublicFormat.Raw
+        ):
+            if (
+                format is not serialization.PrivateFormat.Raw
+                or encoding is not serialization.Encoding.Raw
+                or not isinstance(
+                    encryption_algorithm, serialization.NoEncryption
+                )
+            ):
+                raise ValueError(
+                    "When using Raw both encoding and format must be Raw "
+                    "and encryption_algorithm must be NoEncryption()"
+                )
+
+            return self._raw_private_bytes()
+
+        return self._backend._private_key_bytes(
+            encoding, format, encryption_algorithm, self, self._evp_pkey, None
+        )
+
+    def _raw_private_bytes(self) -> bytes:
+        buf = self._backend._ffi.new("unsigned char []", _X448_KEY_SIZE)
+        buflen = self._backend._ffi.new("size_t *", _X448_KEY_SIZE)
+        res = self._backend._lib.EVP_PKEY_get_raw_private_key(
+            self._evp_pkey, buf, buflen
+        )
+        self._backend.openssl_assert(res == 1)
+        self._backend.openssl_assert(buflen[0] == _X448_KEY_SIZE)
+        return self._backend._ffi.buffer(buf, _X448_KEY_SIZE)[:]
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/x509.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/x509.py
new file mode 100644
index 0000000..aa4ed10
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/backends/openssl/x509.py
@@ -0,0 +1,45 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import warnings
+
+from cryptography import utils, x509
+
+
+# This exists for pyOpenSSL compatibility and SHOULD NOT BE USED
+# WE WILL REMOVE THIS VERY SOON.
+def _Certificate(backend, x509) -> x509.Certificate:  # noqa: N802
+    warnings.warn(
+        "This version of cryptography contains a temporary pyOpenSSL "
+        "fallback path. Upgrade pyOpenSSL now.",
+        utils.DeprecatedIn35,
+    )
+    return backend._ossl2cert(x509)
+
+
+# This exists for pyOpenSSL compatibility and SHOULD NOT BE USED
+# WE WILL REMOVE THIS VERY SOON.
+def _CertificateSigningRequest(  # noqa: N802
+    backend, x509_req
+) -> x509.CertificateSigningRequest:
+    warnings.warn(
+        "This version of cryptography contains a temporary pyOpenSSL "
+        "fallback path. Upgrade pyOpenSSL now.",
+        utils.DeprecatedIn35,
+    )
+    return backend._ossl2csr(x509_req)
+
+
+# This exists for pyOpenSSL compatibility and SHOULD NOT BE USED
+# WE WILL REMOVE THIS VERY SOON.
+def _CertificateRevocationList(  # noqa: N802
+    backend, x509_crl
+) -> x509.CertificateRevocationList:
+    warnings.warn(
+        "This version of cryptography contains a temporary pyOpenSSL "
+        "fallback path. Upgrade pyOpenSSL now.",
+        utils.DeprecatedIn35,
+    )
+    return backend._ossl2crl(x509_crl)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/__init__.py
new file mode 100644
index 0000000..b509336
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/__init__.py
@@ -0,0 +1,3 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_openssl.abi3.so b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_openssl.abi3.so
new file mode 100755
index 0000000..dcb10a0
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_openssl.abi3.so differ
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust.abi3.so b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust.abi3.so
new file mode 100755
index 0000000..279aa7a
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust.abi3.so differ
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/__init__.pyi b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/__init__.pyi
new file mode 100644
index 0000000..393ee7a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/__init__.pyi
@@ -0,0 +1,2 @@
+def check_pkcs7_padding(data: bytes) -> bool: ...
+def check_ansix923_padding(data: bytes) -> bool: ...
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/asn1.pyi b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/asn1.pyi
new file mode 100644
index 0000000..5579c4f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/asn1.pyi
@@ -0,0 +1,12 @@
+import typing
+
+class TestCertificate:
+    not_after_tag: int
+    not_before_tag: int
+    issuer_value_tags: typing.List[int]
+    subject_value_tags: typing.List[int]
+
+def decode_dss_signature(signature: bytes) -> typing.Tuple[int, int]: ...
+def encode_dss_signature(r: int, s: int) -> bytes: ...
+def parse_spki_for_data(data: bytes) -> bytes: ...
+def test_parse_certificate(data: bytes) -> TestCertificate: ...
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/ocsp.pyi b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/ocsp.pyi
new file mode 100644
index 0000000..91b8495
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/ocsp.pyi
@@ -0,0 +1,22 @@
+import typing
+
+from cryptography.hazmat.primitives.asymmetric.types import PRIVATE_KEY_TYPES
+from cryptography.hazmat.primitives import hashes
+from cryptography.x509 import Extension
+from cryptography.x509.ocsp import (
+    OCSPRequest,
+    OCSPRequestBuilder,
+    OCSPResponse,
+    OCSPResponseStatus,
+    OCSPResponseBuilder,
+)
+
+def load_der_ocsp_request(data: bytes) -> OCSPRequest: ...
+def load_der_ocsp_response(data: bytes) -> OCSPResponse: ...
+def create_ocsp_request(builder: OCSPRequestBuilder) -> OCSPRequest: ...
+def create_ocsp_response(
+    status: OCSPResponseStatus,
+    builder: typing.Optional[OCSPResponseBuilder],
+    private_key: typing.Optional[PRIVATE_KEY_TYPES],
+    hash_algorithm: typing.Optional[hashes.HashAlgorithm],
+) -> OCSPResponse: ...
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/x509.pyi b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/x509.pyi
new file mode 100644
index 0000000..79aeb63
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/_rust/x509.pyi
@@ -0,0 +1,36 @@
+import datetime
+import typing
+
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric.types import PRIVATE_KEY_TYPES
+
+def load_pem_x509_certificate(data: bytes) -> x509.Certificate: ...
+def load_der_x509_certificate(data: bytes) -> x509.Certificate: ...
+def load_pem_x509_crl(data: bytes) -> x509.CertificateRevocationList: ...
+def load_der_x509_crl(data: bytes) -> x509.CertificateRevocationList: ...
+def load_pem_x509_csr(data: bytes) -> x509.CertificateSigningRequest: ...
+def load_der_x509_csr(data: bytes) -> x509.CertificateSigningRequest: ...
+def encode_name_bytes(name: x509.Name) -> bytes: ...
+def encode_extension_value(extension: x509.ExtensionType) -> bytes: ...
+def create_x509_certificate(
+    builder: x509.CertificateBuilder,
+    private_key: PRIVATE_KEY_TYPES,
+    hash_algorithm: typing.Optional[hashes.HashAlgorithm],
+) -> x509.Certificate: ...
+def create_x509_csr(
+    builder: x509.CertificateSigningRequestBuilder,
+    private_key: PRIVATE_KEY_TYPES,
+    hash_algorithm: typing.Optional[hashes.HashAlgorithm],
+) -> x509.CertificateSigningRequest: ...
+def create_x509_crl(
+    builder: x509.CertificateRevocationListBuilder,
+    private_key: PRIVATE_KEY_TYPES,
+    hash_algorithm: typing.Optional[hashes.HashAlgorithm],
+) -> x509.CertificateRevocationList: ...
+
+class Sct: ...
+class Certificate: ...
+class RevokedCertificate: ...
+class CertificateRevocationList: ...
+class CertificateSigningRequest: ...
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/openssl/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/openssl/__init__.py
new file mode 100644
index 0000000..b509336
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/openssl/__init__.py
@@ -0,0 +1,3 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/openssl/_conditional.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/openssl/_conditional.py
new file mode 100644
index 0000000..ed81b84
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/openssl/_conditional.py
@@ -0,0 +1,367 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+
+def cryptography_has_ec2m() -> typing.List[str]:
+    return [
+        "EC_POINT_get_affine_coordinates_GF2m",
+    ]
+
+
+def cryptography_has_ssl3_method() -> typing.List[str]:
+    return [
+        "SSLv3_method",
+        "SSLv3_client_method",
+        "SSLv3_server_method",
+    ]
+
+
+def cryptography_has_110_verification_params() -> typing.List[str]:
+    return ["X509_CHECK_FLAG_NEVER_CHECK_SUBJECT"]
+
+
+def cryptography_has_set_cert_cb() -> typing.List[str]:
+    return [
+        "SSL_CTX_set_cert_cb",
+        "SSL_set_cert_cb",
+    ]
+
+
+def cryptography_has_ssl_st() -> typing.List[str]:
+    return [
+        "SSL_ST_BEFORE",
+        "SSL_ST_OK",
+        "SSL_ST_INIT",
+        "SSL_ST_RENEGOTIATE",
+    ]
+
+
+def cryptography_has_tls_st() -> typing.List[str]:
+    return [
+        "TLS_ST_BEFORE",
+        "TLS_ST_OK",
+    ]
+
+
+def cryptography_has_scrypt() -> typing.List[str]:
+    return [
+        "EVP_PBE_scrypt",
+    ]
+
+
+def cryptography_has_evp_pkey_dhx() -> typing.List[str]:
+    return [
+        "EVP_PKEY_DHX",
+    ]
+
+
+def cryptography_has_mem_functions() -> typing.List[str]:
+    return [
+        "Cryptography_CRYPTO_set_mem_functions",
+    ]
+
+
+def cryptography_has_x509_store_ctx_get_issuer() -> typing.List[str]:
+    return [
+        "X509_STORE_get_get_issuer",
+        "X509_STORE_set_get_issuer",
+    ]
+
+
+def cryptography_has_ed448() -> typing.List[str]:
+    return [
+        "EVP_PKEY_ED448",
+        "NID_ED448",
+    ]
+
+
+def cryptography_has_ed25519() -> typing.List[str]:
+    return [
+        "NID_ED25519",
+        "EVP_PKEY_ED25519",
+    ]
+
+
+def cryptography_has_poly1305() -> typing.List[str]:
+    return [
+        "NID_poly1305",
+        "EVP_PKEY_POLY1305",
+    ]
+
+
+def cryptography_has_oneshot_evp_digest_sign_verify() -> typing.List[str]:
+    return [
+        "EVP_DigestSign",
+        "EVP_DigestVerify",
+    ]
+
+
+def cryptography_has_evp_digestfinal_xof() -> typing.List[str]:
+    return [
+        "EVP_DigestFinalXOF",
+    ]
+
+
+def cryptography_has_evp_pkey_get_set_tls_encodedpoint() -> typing.List[str]:
+    return [
+        "EVP_PKEY_get1_tls_encodedpoint",
+        "EVP_PKEY_set1_tls_encodedpoint",
+    ]
+
+
+def cryptography_has_fips() -> typing.List[str]:
+    return [
+        "FIPS_mode_set",
+        "FIPS_mode",
+    ]
+
+
+def cryptography_has_psk() -> typing.List[str]:
+    return [
+        "SSL_CTX_use_psk_identity_hint",
+        "SSL_CTX_set_psk_server_callback",
+        "SSL_CTX_set_psk_client_callback",
+    ]
+
+
+def cryptography_has_psk_tlsv13() -> typing.List[str]:
+    return [
+        "SSL_CTX_set_psk_find_session_callback",
+        "SSL_CTX_set_psk_use_session_callback",
+        "Cryptography_SSL_SESSION_new",
+        "SSL_CIPHER_find",
+        "SSL_SESSION_set1_master_key",
+        "SSL_SESSION_set_cipher",
+        "SSL_SESSION_set_protocol_version",
+    ]
+
+
+def cryptography_has_custom_ext() -> typing.List[str]:
+    return [
+        "SSL_CTX_add_client_custom_ext",
+        "SSL_CTX_add_server_custom_ext",
+        "SSL_extension_supported",
+    ]
+
+
+def cryptography_has_openssl_cleanup() -> typing.List[str]:
+    return [
+        "OPENSSL_cleanup",
+    ]
+
+
+def cryptography_has_tlsv13() -> typing.List[str]:
+    return [
+        "TLS1_3_VERSION",
+        "SSL_OP_NO_TLSv1_3",
+    ]
+
+
+def cryptography_has_tlsv13_functions() -> typing.List[str]:
+    return [
+        "SSL_VERIFY_POST_HANDSHAKE",
+        "SSL_CTX_set_ciphersuites",
+        "SSL_verify_client_post_handshake",
+        "SSL_CTX_set_post_handshake_auth",
+        "SSL_set_post_handshake_auth",
+        "SSL_SESSION_get_max_early_data",
+        "SSL_write_early_data",
+        "SSL_read_early_data",
+        "SSL_CTX_set_max_early_data",
+    ]
+
+
+def cryptography_has_keylog() -> typing.List[str]:
+    return [
+        "SSL_CTX_set_keylog_callback",
+        "SSL_CTX_get_keylog_callback",
+    ]
+
+
+def cryptography_has_raw_key() -> typing.List[str]:
+    return [
+        "EVP_PKEY_new_raw_private_key",
+        "EVP_PKEY_new_raw_public_key",
+        "EVP_PKEY_get_raw_private_key",
+        "EVP_PKEY_get_raw_public_key",
+    ]
+
+
+def cryptography_has_engine() -> typing.List[str]:
+    return [
+        "ENGINE_by_id",
+        "ENGINE_init",
+        "ENGINE_finish",
+        "ENGINE_get_default_RAND",
+        "ENGINE_set_default_RAND",
+        "ENGINE_unregister_RAND",
+        "ENGINE_ctrl_cmd",
+        "ENGINE_free",
+        "ENGINE_get_name",
+        "Cryptography_add_osrandom_engine",
+        "ENGINE_ctrl_cmd_string",
+        "ENGINE_load_builtin_engines",
+        "ENGINE_load_private_key",
+        "ENGINE_load_public_key",
+        "SSL_CTX_set_client_cert_engine",
+    ]
+
+
+def cryptography_has_verified_chain() -> typing.List[str]:
+    return [
+        "SSL_get0_verified_chain",
+    ]
+
+
+def cryptography_has_srtp() -> typing.List[str]:
+    return [
+        "SSL_CTX_set_tlsext_use_srtp",
+        "SSL_set_tlsext_use_srtp",
+        "SSL_get_selected_srtp_profile",
+    ]
+
+
+def cryptography_has_get_proto_version() -> typing.List[str]:
+    return [
+        "SSL_CTX_get_min_proto_version",
+        "SSL_CTX_get_max_proto_version",
+        "SSL_get_min_proto_version",
+        "SSL_get_max_proto_version",
+    ]
+
+
+def cryptography_has_providers() -> typing.List[str]:
+    return [
+        "OSSL_PROVIDER_load",
+        "OSSL_PROVIDER_unload",
+        "ERR_LIB_PROV",
+        "PROV_R_WRONG_FINAL_BLOCK_LENGTH",
+        "PROV_R_BAD_DECRYPT",
+    ]
+
+
+def cryptography_has_op_no_renegotiation() -> typing.List[str]:
+    return [
+        "SSL_OP_NO_RENEGOTIATION",
+    ]
+
+
+def cryptography_has_dtls_get_data_mtu() -> typing.List[str]:
+    return [
+        "DTLS_get_data_mtu",
+    ]
+
+
+def cryptography_has_300_fips() -> typing.List[str]:
+    return [
+        "EVP_default_properties_is_fips_enabled",
+        "EVP_default_properties_enable_fips",
+    ]
+
+
+def cryptography_has_ssl_cookie() -> typing.List[str]:
+    return [
+        "SSL_OP_COOKIE_EXCHANGE",
+        "DTLSv1_listen",
+        "SSL_CTX_set_cookie_generate_cb",
+        "SSL_CTX_set_cookie_verify_cb",
+    ]
+
+
+def cryptography_has_pkcs7_funcs() -> typing.List[str]:
+    return [
+        "SMIME_write_PKCS7",
+        "PEM_write_bio_PKCS7_stream",
+        "PKCS7_sign_add_signer",
+        "PKCS7_final",
+        "PKCS7_verify",
+        "SMIME_read_PKCS7",
+        "PKCS7_get0_signers",
+    ]
+
+
+def cryptography_has_bn_flags() -> typing.List[str]:
+    return [
+        "BN_FLG_CONSTTIME",
+        "BN_set_flags",
+        "BN_prime_checks_for_size",
+    ]
+
+
+def cryptography_has_evp_pkey_dh() -> typing.List[str]:
+    return [
+        "EVP_PKEY_set1_DH",
+    ]
+
+
+def cryptography_has_300_evp_cipher() -> typing.List[str]:
+    return ["EVP_CIPHER_fetch", "EVP_CIPHER_free"]
+
+
+def cryptography_has_unexpected_eof_while_reading() -> typing.List[str]:
+    return ["SSL_R_UNEXPECTED_EOF_WHILE_READING"]
+
+
+# This is a mapping of
+# {condition: function-returning-names-dependent-on-that-condition} so we can
+# loop over them and delete unsupported names at runtime. It will be removed
+# when cffi supports #if in cdef. We use functions instead of just a dict of
+# lists so we can use coverage to measure which are used.
+CONDITIONAL_NAMES = {
+    "Cryptography_HAS_EC2M": cryptography_has_ec2m,
+    "Cryptography_HAS_SSL3_METHOD": cryptography_has_ssl3_method,
+    "Cryptography_HAS_110_VERIFICATION_PARAMS": (
+        cryptography_has_110_verification_params
+    ),
+    "Cryptography_HAS_SET_CERT_CB": cryptography_has_set_cert_cb,
+    "Cryptography_HAS_SSL_ST": cryptography_has_ssl_st,
+    "Cryptography_HAS_TLS_ST": cryptography_has_tls_st,
+    "Cryptography_HAS_SCRYPT": cryptography_has_scrypt,
+    "Cryptography_HAS_EVP_PKEY_DHX": cryptography_has_evp_pkey_dhx,
+    "Cryptography_HAS_MEM_FUNCTIONS": cryptography_has_mem_functions,
+    "Cryptography_HAS_X509_STORE_CTX_GET_ISSUER": (
+        cryptography_has_x509_store_ctx_get_issuer
+    ),
+    "Cryptography_HAS_ED448": cryptography_has_ed448,
+    "Cryptography_HAS_ED25519": cryptography_has_ed25519,
+    "Cryptography_HAS_POLY1305": cryptography_has_poly1305,
+    "Cryptography_HAS_ONESHOT_EVP_DIGEST_SIGN_VERIFY": (
+        cryptography_has_oneshot_evp_digest_sign_verify
+    ),
+    "Cryptography_HAS_EVP_PKEY_get_set_tls_encodedpoint": (
+        cryptography_has_evp_pkey_get_set_tls_encodedpoint
+    ),
+    "Cryptography_HAS_FIPS": cryptography_has_fips,
+    "Cryptography_HAS_PSK": cryptography_has_psk,
+    "Cryptography_HAS_PSK_TLSv1_3": cryptography_has_psk_tlsv13,
+    "Cryptography_HAS_CUSTOM_EXT": cryptography_has_custom_ext,
+    "Cryptography_HAS_OPENSSL_CLEANUP": cryptography_has_openssl_cleanup,
+    "Cryptography_HAS_TLSv1_3": cryptography_has_tlsv13,
+    "Cryptography_HAS_TLSv1_3_FUNCTIONS": cryptography_has_tlsv13_functions,
+    "Cryptography_HAS_KEYLOG": cryptography_has_keylog,
+    "Cryptography_HAS_RAW_KEY": cryptography_has_raw_key,
+    "Cryptography_HAS_EVP_DIGESTFINAL_XOF": (
+        cryptography_has_evp_digestfinal_xof
+    ),
+    "Cryptography_HAS_ENGINE": cryptography_has_engine,
+    "Cryptography_HAS_VERIFIED_CHAIN": cryptography_has_verified_chain,
+    "Cryptography_HAS_SRTP": cryptography_has_srtp,
+    "Cryptography_HAS_GET_PROTO_VERSION": cryptography_has_get_proto_version,
+    "Cryptography_HAS_PROVIDERS": cryptography_has_providers,
+    "Cryptography_HAS_OP_NO_RENEGOTIATION": (
+        cryptography_has_op_no_renegotiation
+    ),
+    "Cryptography_HAS_DTLS_GET_DATA_MTU": cryptography_has_dtls_get_data_mtu,
+    "Cryptography_HAS_300_FIPS": cryptography_has_300_fips,
+    "Cryptography_HAS_SSL_COOKIE": cryptography_has_ssl_cookie,
+    "Cryptography_HAS_PKCS7_FUNCS": cryptography_has_pkcs7_funcs,
+    "Cryptography_HAS_BN_FLAGS": cryptography_has_bn_flags,
+    "Cryptography_HAS_EVP_PKEY_DH": cryptography_has_evp_pkey_dh,
+    "Cryptography_HAS_300_EVP_CIPHER": cryptography_has_300_evp_cipher,
+    "Cryptography_HAS_UNEXPECTED_EOF_WHILE_READING": (
+        cryptography_has_unexpected_eof_while_reading
+    ),
+}
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/openssl/binding.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/openssl/binding.py
new file mode 100644
index 0000000..a6fbc94
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/bindings/openssl/binding.py
@@ -0,0 +1,230 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import threading
+import types
+import typing
+import warnings
+
+import cryptography
+from cryptography import utils
+from cryptography.exceptions import InternalError
+from cryptography.hazmat.bindings._openssl import ffi, lib
+from cryptography.hazmat.bindings.openssl._conditional import CONDITIONAL_NAMES
+
+_OpenSSLErrorWithText = typing.NamedTuple(
+    "_OpenSSLErrorWithText",
+    [("code", int), ("lib", int), ("reason", int), ("reason_text", bytes)],
+)
+
+
+class _OpenSSLError:
+    def __init__(self, code: int, lib: int, reason: int):
+        self._code = code
+        self._lib = lib
+        self._reason = reason
+
+    def _lib_reason_match(self, lib: int, reason: int) -> bool:
+        return lib == self.lib and reason == self.reason
+
+    @property
+    def code(self) -> int:
+        return self._code
+
+    @property
+    def lib(self) -> int:
+        return self._lib
+
+    @property
+    def reason(self) -> int:
+        return self._reason
+
+
+def _consume_errors(lib) -> typing.List[_OpenSSLError]:
+    errors = []
+    while True:
+        code: int = lib.ERR_get_error()
+        if code == 0:
+            break
+
+        err_lib: int = lib.ERR_GET_LIB(code)
+        err_reason: int = lib.ERR_GET_REASON(code)
+
+        errors.append(_OpenSSLError(code, err_lib, err_reason))
+
+    return errors
+
+
+def _errors_with_text(
+    errors: typing.List[_OpenSSLError],
+) -> typing.List[_OpenSSLErrorWithText]:
+    errors_with_text = []
+    for err in errors:
+        buf = ffi.new("char[]", 256)
+        lib.ERR_error_string_n(err.code, buf, len(buf))
+        err_text_reason: bytes = ffi.string(buf)
+
+        errors_with_text.append(
+            _OpenSSLErrorWithText(
+                err.code, err.lib, err.reason, err_text_reason
+            )
+        )
+
+    return errors_with_text
+
+
+def _consume_errors_with_text(lib):
+    return _errors_with_text(_consume_errors(lib))
+
+
+def _openssl_assert(
+    lib, ok: bool, errors: typing.Optional[typing.List[_OpenSSLError]] = None
+) -> None:
+    if not ok:
+        if errors is None:
+            errors = _consume_errors(lib)
+        errors_with_text = _errors_with_text(errors)
+
+        raise InternalError(
+            "Unknown OpenSSL error. This error is commonly encountered when "
+            "another library is not cleaning up the OpenSSL error stack. If "
+            "you are using cryptography with another library that uses "
+            "OpenSSL try disabling it before reporting a bug. Otherwise "
+            "please file an issue at https://github.com/pyca/cryptography/"
+            "issues with information on how to reproduce "
+            "this. ({0!r})".format(errors_with_text),
+            errors_with_text,
+        )
+
+
+def build_conditional_library(lib, conditional_names):
+    conditional_lib = types.ModuleType("lib")
+    conditional_lib._original_lib = lib  # type: ignore[attr-defined]
+    excluded_names = set()
+    for condition, names_cb in conditional_names.items():
+        if not getattr(lib, condition):
+            excluded_names.update(names_cb())
+
+    for attr in dir(lib):
+        if attr not in excluded_names:
+            setattr(conditional_lib, attr, getattr(lib, attr))
+
+    return conditional_lib
+
+
+class Binding:
+    """
+    OpenSSL API wrapper.
+    """
+
+    lib: typing.ClassVar = None
+    ffi = ffi
+    _lib_loaded = False
+    _init_lock = threading.Lock()
+    _legacy_provider: typing.Any = None
+    _default_provider: typing.Any = None
+
+    def __init__(self):
+        self._ensure_ffi_initialized()
+
+    def _enable_fips(self) -> None:
+        # This function enables FIPS mode for OpenSSL 3.0.0 on installs that
+        # have the FIPS provider installed properly.
+        _openssl_assert(self.lib, self.lib.CRYPTOGRAPHY_OPENSSL_300_OR_GREATER)
+        self._base_provider = self.lib.OSSL_PROVIDER_load(
+            self.ffi.NULL, b"base"
+        )
+        _openssl_assert(self.lib, self._base_provider != self.ffi.NULL)
+        self.lib._fips_provider = self.lib.OSSL_PROVIDER_load(
+            self.ffi.NULL, b"fips"
+        )
+        _openssl_assert(self.lib, self.lib._fips_provider != self.ffi.NULL)
+
+        res = self.lib.EVP_default_properties_enable_fips(self.ffi.NULL, 1)
+        _openssl_assert(self.lib, res == 1)
+
+    @classmethod
+    def _register_osrandom_engine(cls):
+        # Clear any errors extant in the queue before we start. In many
+        # scenarios other things may be interacting with OpenSSL in the same
+        # process space and it has proven untenable to assume that they will
+        # reliably clear the error queue. Once we clear it here we will
+        # error on any subsequent unexpected item in the stack.
+        cls.lib.ERR_clear_error()
+        if cls.lib.CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE:
+            result = cls.lib.Cryptography_add_osrandom_engine()
+            _openssl_assert(cls.lib, result in (1, 2))
+
+    @classmethod
+    def _ensure_ffi_initialized(cls):
+        with cls._init_lock:
+            if not cls._lib_loaded:
+                cls.lib = build_conditional_library(lib, CONDITIONAL_NAMES)
+                cls._lib_loaded = True
+                cls._register_osrandom_engine()
+                # As of OpenSSL 3.0.0 we must register a legacy cipher provider
+                # to get RC2 (needed for junk asymmetric private key
+                # serialization), RC4, Blowfish, IDEA, SEED, etc. These things
+                # are ugly legacy, but we aren't going to get rid of them
+                # any time soon.
+                if cls.lib.CRYPTOGRAPHY_OPENSSL_300_OR_GREATER:
+                    cls._legacy_provider = cls.lib.OSSL_PROVIDER_load(
+                        cls.ffi.NULL, b"legacy"
+                    )
+                    _openssl_assert(
+                        cls.lib, cls._legacy_provider != cls.ffi.NULL
+                    )
+                    cls._default_provider = cls.lib.OSSL_PROVIDER_load(
+                        cls.ffi.NULL, b"default"
+                    )
+                    _openssl_assert(
+                        cls.lib, cls._default_provider != cls.ffi.NULL
+                    )
+
+    @classmethod
+    def init_static_locks(cls):
+        cls._ensure_ffi_initialized()
+
+
+def _verify_openssl_version(lib):
+    if (
+        lib.CRYPTOGRAPHY_OPENSSL_LESS_THAN_111
+        and not lib.CRYPTOGRAPHY_IS_LIBRESSL
+        and not lib.CRYPTOGRAPHY_IS_BORINGSSL
+    ):
+        warnings.warn(
+            "OpenSSL version 1.1.0 is no longer supported by the OpenSSL "
+            "project, please upgrade. The next release of cryptography will "
+            "be the last to support compiling with OpenSSL 1.1.0.",
+            utils.DeprecatedIn37,
+        )
+
+
+def _verify_package_version(version):
+    # Occasionally we run into situations where the version of the Python
+    # package does not match the version of the shared object that is loaded.
+    # This may occur in environments where multiple versions of cryptography
+    # are installed and available in the python path. To avoid errors cropping
+    # up later this code checks that the currently imported package and the
+    # shared object that were loaded have the same version and raise an
+    # ImportError if they do not
+    so_package_version = ffi.string(lib.CRYPTOGRAPHY_PACKAGE_VERSION)
+    if version.encode("ascii") != so_package_version:
+        raise ImportError(
+            "The version of cryptography does not match the loaded "
+            "shared object. This can happen if you have multiple copies of "
+            "cryptography installed in your Python path. Please try creating "
+            "a new virtual environment to resolve this issue. "
+            "Loaded python version: {}, shared object version: {}".format(
+                version, so_package_version
+            )
+        )
+
+
+_verify_package_version(cryptography.__version__)
+
+Binding.init_static_locks()
+
+_verify_openssl_version(Binding.lib)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/__init__.py
new file mode 100644
index 0000000..b509336
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/__init__.py
@@ -0,0 +1,3 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/_asymmetric.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/_asymmetric.py
new file mode 100644
index 0000000..cdadbde
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/_asymmetric.py
@@ -0,0 +1,17 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import abc
+
+
+# This exists to break an import cycle. It is normally accessible from the
+# asymmetric padding module.
+
+
+class AsymmetricPadding(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def name(self) -> str:
+        """
+        A string naming this padding (e.g. "PSS", "PKCS1").
+        """
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/_cipheralgorithm.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/_cipheralgorithm.py
new file mode 100644
index 0000000..7f32204
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/_cipheralgorithm.py
@@ -0,0 +1,40 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import abc
+import typing
+
+
+# This exists to break an import cycle. It is normally accessible from the
+# ciphers module.
+
+
+class CipherAlgorithm(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def name(self) -> str:
+        """
+        A string naming this mode (e.g. "AES", "Camellia").
+        """
+
+    @abc.abstractproperty
+    def key_sizes(self) -> typing.FrozenSet[int]:
+        """
+        Valid key sizes for this algorithm in bits
+        """
+
+    @abc.abstractproperty
+    def key_size(self) -> int:
+        """
+        The size of the key being used as an integer in bits (e.g. 128, 256).
+        """
+
+
+class BlockCipherAlgorithm(metaclass=abc.ABCMeta):
+    key: bytes
+
+    @abc.abstractproperty
+    def block_size(self) -> int:
+        """
+        The size of a block as an integer in bits (e.g. 64, 128).
+        """
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/_serialization.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/_serialization.py
new file mode 100644
index 0000000..160a6b8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/_serialization.py
@@ -0,0 +1,55 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import abc
+
+from cryptography import utils
+
+# This exists to break an import cycle. These classes are normally accessible
+# from the serialization module.
+
+
+class Encoding(utils.Enum):
+    PEM = "PEM"
+    DER = "DER"
+    OpenSSH = "OpenSSH"
+    Raw = "Raw"
+    X962 = "ANSI X9.62"
+    SMIME = "S/MIME"
+
+
+class PrivateFormat(utils.Enum):
+    PKCS8 = "PKCS8"
+    TraditionalOpenSSL = "TraditionalOpenSSL"
+    Raw = "Raw"
+    OpenSSH = "OpenSSH"
+
+
+class PublicFormat(utils.Enum):
+    SubjectPublicKeyInfo = "X.509 subjectPublicKeyInfo with PKCS#1"
+    PKCS1 = "Raw PKCS#1"
+    OpenSSH = "OpenSSH"
+    Raw = "Raw"
+    CompressedPoint = "X9.62 Compressed Point"
+    UncompressedPoint = "X9.62 Uncompressed Point"
+
+
+class ParameterFormat(utils.Enum):
+    PKCS3 = "PKCS3"
+
+
+class KeySerializationEncryption(metaclass=abc.ABCMeta):
+    pass
+
+
+class BestAvailableEncryption(KeySerializationEncryption):
+    def __init__(self, password: bytes):
+        if not isinstance(password, bytes) or len(password) == 0:
+            raise ValueError("Password must be 1 or more bytes.")
+
+        self.password = password
+
+
+class NoEncryption(KeySerializationEncryption):
+    pass
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/__init__.py
new file mode 100644
index 0000000..b509336
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/__init__.py
@@ -0,0 +1,3 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/dh.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/dh.py
new file mode 100644
index 0000000..2093ad4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/dh.py
@@ -0,0 +1,250 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import typing
+
+from cryptography.hazmat.primitives import _serialization
+
+
+_MIN_MODULUS_SIZE = 512
+
+
+def generate_parameters(
+    generator: int, key_size: int, backend: typing.Any = None
+) -> "DHParameters":
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.generate_dh_parameters(generator, key_size)
+
+
+class DHParameterNumbers:
+    def __init__(self, p: int, g: int, q: typing.Optional[int] = None) -> None:
+        if not isinstance(p, int) or not isinstance(g, int):
+            raise TypeError("p and g must be integers")
+        if q is not None and not isinstance(q, int):
+            raise TypeError("q must be integer or None")
+
+        if g < 2:
+            raise ValueError("DH generator must be 2 or greater")
+
+        if p.bit_length() < _MIN_MODULUS_SIZE:
+            raise ValueError(
+                "p (modulus) must be at least {}-bit".format(_MIN_MODULUS_SIZE)
+            )
+
+        self._p = p
+        self._g = g
+        self._q = q
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DHParameterNumbers):
+            return NotImplemented
+
+        return (
+            self._p == other._p and self._g == other._g and self._q == other._q
+        )
+
+    def parameters(self, backend: typing.Any = None) -> "DHParameters":
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        return ossl.load_dh_parameter_numbers(self)
+
+    @property
+    def p(self) -> int:
+        return self._p
+
+    @property
+    def g(self) -> int:
+        return self._g
+
+    @property
+    def q(self) -> typing.Optional[int]:
+        return self._q
+
+
+class DHPublicNumbers:
+    def __init__(self, y: int, parameter_numbers: DHParameterNumbers) -> None:
+        if not isinstance(y, int):
+            raise TypeError("y must be an integer.")
+
+        if not isinstance(parameter_numbers, DHParameterNumbers):
+            raise TypeError(
+                "parameters must be an instance of DHParameterNumbers."
+            )
+
+        self._y = y
+        self._parameter_numbers = parameter_numbers
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DHPublicNumbers):
+            return NotImplemented
+
+        return (
+            self._y == other._y
+            and self._parameter_numbers == other._parameter_numbers
+        )
+
+    def public_key(self, backend: typing.Any = None) -> "DHPublicKey":
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        return ossl.load_dh_public_numbers(self)
+
+    @property
+    def y(self) -> int:
+        return self._y
+
+    @property
+    def parameter_numbers(self) -> DHParameterNumbers:
+        return self._parameter_numbers
+
+
+class DHPrivateNumbers:
+    def __init__(self, x: int, public_numbers: DHPublicNumbers) -> None:
+        if not isinstance(x, int):
+            raise TypeError("x must be an integer.")
+
+        if not isinstance(public_numbers, DHPublicNumbers):
+            raise TypeError(
+                "public_numbers must be an instance of " "DHPublicNumbers."
+            )
+
+        self._x = x
+        self._public_numbers = public_numbers
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DHPrivateNumbers):
+            return NotImplemented
+
+        return (
+            self._x == other._x
+            and self._public_numbers == other._public_numbers
+        )
+
+    def private_key(self, backend: typing.Any = None) -> "DHPrivateKey":
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        return ossl.load_dh_private_numbers(self)
+
+    @property
+    def public_numbers(self) -> DHPublicNumbers:
+        return self._public_numbers
+
+    @property
+    def x(self) -> int:
+        return self._x
+
+
+class DHParameters(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def generate_private_key(self) -> "DHPrivateKey":
+        """
+        Generates and returns a DHPrivateKey.
+        """
+
+    @abc.abstractmethod
+    def parameter_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.ParameterFormat,
+    ) -> bytes:
+        """
+        Returns the parameters serialized as bytes.
+        """
+
+    @abc.abstractmethod
+    def parameter_numbers(self) -> DHParameterNumbers:
+        """
+        Returns a DHParameterNumbers.
+        """
+
+
+DHParametersWithSerialization = DHParameters
+
+
+class DHPublicKey(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def key_size(self) -> int:
+        """
+        The bit length of the prime modulus.
+        """
+
+    @abc.abstractmethod
+    def parameters(self) -> DHParameters:
+        """
+        The DHParameters object associated with this public key.
+        """
+
+    @abc.abstractmethod
+    def public_numbers(self) -> DHPublicNumbers:
+        """
+        Returns a DHPublicNumbers.
+        """
+
+    @abc.abstractmethod
+    def public_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PublicFormat,
+    ) -> bytes:
+        """
+        Returns the key serialized as bytes.
+        """
+
+
+DHPublicKeyWithSerialization = DHPublicKey
+
+
+class DHPrivateKey(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def key_size(self) -> int:
+        """
+        The bit length of the prime modulus.
+        """
+
+    @abc.abstractmethod
+    def public_key(self) -> DHPublicKey:
+        """
+        The DHPublicKey associated with this private key.
+        """
+
+    @abc.abstractmethod
+    def parameters(self) -> DHParameters:
+        """
+        The DHParameters object associated with this private key.
+        """
+
+    @abc.abstractmethod
+    def exchange(self, peer_public_key: DHPublicKey) -> bytes:
+        """
+        Given peer's DHPublicKey, carry out the key exchange and
+        return shared key as bytes.
+        """
+
+    @abc.abstractmethod
+    def private_numbers(self) -> DHPrivateNumbers:
+        """
+        Returns a DHPrivateNumbers.
+        """
+
+    @abc.abstractmethod
+    def private_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PrivateFormat,
+        encryption_algorithm: _serialization.KeySerializationEncryption,
+    ) -> bytes:
+        """
+        Returns the key serialized as bytes.
+        """
+
+
+DHPrivateKeyWithSerialization = DHPrivateKey
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/dsa.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/dsa.py
new file mode 100644
index 0000000..5e58709
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/dsa.py
@@ -0,0 +1,288 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import typing
+
+from cryptography.hazmat.primitives import _serialization, hashes
+from cryptography.hazmat.primitives.asymmetric import (
+    utils as asym_utils,
+)
+
+
+class DSAParameters(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def generate_private_key(self) -> "DSAPrivateKey":
+        """
+        Generates and returns a DSAPrivateKey.
+        """
+
+    @abc.abstractmethod
+    def parameter_numbers(self) -> "DSAParameterNumbers":
+        """
+        Returns a DSAParameterNumbers.
+        """
+
+
+DSAParametersWithNumbers = DSAParameters
+
+
+class DSAPrivateKey(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def key_size(self) -> int:
+        """
+        The bit length of the prime modulus.
+        """
+
+    @abc.abstractmethod
+    def public_key(self) -> "DSAPublicKey":
+        """
+        The DSAPublicKey associated with this private key.
+        """
+
+    @abc.abstractmethod
+    def parameters(self) -> DSAParameters:
+        """
+        The DSAParameters object associated with this private key.
+        """
+
+    @abc.abstractmethod
+    def sign(
+        self,
+        data: bytes,
+        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
+    ) -> bytes:
+        """
+        Signs the data
+        """
+
+    @abc.abstractmethod
+    def private_numbers(self) -> "DSAPrivateNumbers":
+        """
+        Returns a DSAPrivateNumbers.
+        """
+
+    @abc.abstractmethod
+    def private_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PrivateFormat,
+        encryption_algorithm: _serialization.KeySerializationEncryption,
+    ) -> bytes:
+        """
+        Returns the key serialized as bytes.
+        """
+
+
+DSAPrivateKeyWithSerialization = DSAPrivateKey
+
+
+class DSAPublicKey(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def key_size(self) -> int:
+        """
+        The bit length of the prime modulus.
+        """
+
+    @abc.abstractmethod
+    def parameters(self) -> DSAParameters:
+        """
+        The DSAParameters object associated with this public key.
+        """
+
+    @abc.abstractmethod
+    def public_numbers(self) -> "DSAPublicNumbers":
+        """
+        Returns a DSAPublicNumbers.
+        """
+
+    @abc.abstractmethod
+    def public_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PublicFormat,
+    ) -> bytes:
+        """
+        Returns the key serialized as bytes.
+        """
+
+    @abc.abstractmethod
+    def verify(
+        self,
+        signature: bytes,
+        data: bytes,
+        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
+    ) -> None:
+        """
+        Verifies the signature of the data.
+        """
+
+
+DSAPublicKeyWithSerialization = DSAPublicKey
+
+
+class DSAParameterNumbers:
+    def __init__(self, p: int, q: int, g: int):
+        if (
+            not isinstance(p, int)
+            or not isinstance(q, int)
+            or not isinstance(g, int)
+        ):
+            raise TypeError(
+                "DSAParameterNumbers p, q, and g arguments must be integers."
+            )
+
+        self._p = p
+        self._q = q
+        self._g = g
+
+    @property
+    def p(self) -> int:
+        return self._p
+
+    @property
+    def q(self) -> int:
+        return self._q
+
+    @property
+    def g(self) -> int:
+        return self._g
+
+    def parameters(self, backend: typing.Any = None) -> DSAParameters:
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        return ossl.load_dsa_parameter_numbers(self)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DSAParameterNumbers):
+            return NotImplemented
+
+        return self.p == other.p and self.q == other.q and self.g == other.g
+
+    def __repr__(self) -> str:
+        return (
+            "<DSAParameterNumbers(p={self.p}, q={self.q}, "
+            "g={self.g})>".format(self=self)
+        )
+
+
+class DSAPublicNumbers:
+    def __init__(self, y: int, parameter_numbers: DSAParameterNumbers):
+        if not isinstance(y, int):
+            raise TypeError("DSAPublicNumbers y argument must be an integer.")
+
+        if not isinstance(parameter_numbers, DSAParameterNumbers):
+            raise TypeError(
+                "parameter_numbers must be a DSAParameterNumbers instance."
+            )
+
+        self._y = y
+        self._parameter_numbers = parameter_numbers
+
+    @property
+    def y(self) -> int:
+        return self._y
+
+    @property
+    def parameter_numbers(self) -> DSAParameterNumbers:
+        return self._parameter_numbers
+
+    def public_key(self, backend: typing.Any = None) -> DSAPublicKey:
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        return ossl.load_dsa_public_numbers(self)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DSAPublicNumbers):
+            return NotImplemented
+
+        return (
+            self.y == other.y
+            and self.parameter_numbers == other.parameter_numbers
+        )
+
+    def __repr__(self) -> str:
+        return (
+            "<DSAPublicNumbers(y={self.y}, "
+            "parameter_numbers={self.parameter_numbers})>".format(self=self)
+        )
+
+
+class DSAPrivateNumbers:
+    def __init__(self, x: int, public_numbers: DSAPublicNumbers):
+        if not isinstance(x, int):
+            raise TypeError("DSAPrivateNumbers x argument must be an integer.")
+
+        if not isinstance(public_numbers, DSAPublicNumbers):
+            raise TypeError(
+                "public_numbers must be a DSAPublicNumbers instance."
+            )
+        self._public_numbers = public_numbers
+        self._x = x
+
+    @property
+    def x(self) -> int:
+        return self._x
+
+    @property
+    def public_numbers(self) -> DSAPublicNumbers:
+        return self._public_numbers
+
+    def private_key(self, backend: typing.Any = None) -> DSAPrivateKey:
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        return ossl.load_dsa_private_numbers(self)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DSAPrivateNumbers):
+            return NotImplemented
+
+        return (
+            self.x == other.x and self.public_numbers == other.public_numbers
+        )
+
+
+def generate_parameters(
+    key_size: int, backend: typing.Any = None
+) -> DSAParameters:
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.generate_dsa_parameters(key_size)
+
+
+def generate_private_key(
+    key_size: int, backend: typing.Any = None
+) -> DSAPrivateKey:
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.generate_dsa_private_key_and_parameters(key_size)
+
+
+def _check_dsa_parameters(parameters: DSAParameterNumbers) -> None:
+    if parameters.p.bit_length() not in [1024, 2048, 3072, 4096]:
+        raise ValueError(
+            "p must be exactly 1024, 2048, 3072, or 4096 bits long"
+        )
+    if parameters.q.bit_length() not in [160, 224, 256]:
+        raise ValueError("q must be exactly 160, 224, or 256 bits long")
+
+    if not (1 < parameters.g < parameters.p):
+        raise ValueError("g, p don't satisfy 1 < g < p.")
+
+
+def _check_dsa_private_numbers(numbers: DSAPrivateNumbers) -> None:
+    parameters = numbers.public_numbers.parameter_numbers
+    _check_dsa_parameters(parameters)
+    if numbers.x <= 0 or numbers.x >= parameters.q:
+        raise ValueError("x must be > 0 and < q.")
+
+    if numbers.public_numbers.y != pow(parameters.g, numbers.x, parameters.p):
+        raise ValueError("y must be equal to (g ** x % p).")
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/ec.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/ec.py
new file mode 100644
index 0000000..3aaa382
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/ec.py
@@ -0,0 +1,523 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import typing
+import warnings
+
+from cryptography import utils
+from cryptography.hazmat._oid import ObjectIdentifier
+from cryptography.hazmat.primitives import _serialization, hashes
+from cryptography.hazmat.primitives.asymmetric import (
+    utils as asym_utils,
+)
+
+
+class EllipticCurveOID:
+    SECP192R1 = ObjectIdentifier("1.2.840.10045.3.1.1")
+    SECP224R1 = ObjectIdentifier("1.3.132.0.33")
+    SECP256K1 = ObjectIdentifier("1.3.132.0.10")
+    SECP256R1 = ObjectIdentifier("1.2.840.10045.3.1.7")
+    SECP384R1 = ObjectIdentifier("1.3.132.0.34")
+    SECP521R1 = ObjectIdentifier("1.3.132.0.35")
+    BRAINPOOLP256R1 = ObjectIdentifier("1.3.36.3.3.2.8.1.1.7")
+    BRAINPOOLP384R1 = ObjectIdentifier("1.3.36.3.3.2.8.1.1.11")
+    BRAINPOOLP512R1 = ObjectIdentifier("1.3.36.3.3.2.8.1.1.13")
+    SECT163K1 = ObjectIdentifier("1.3.132.0.1")
+    SECT163R2 = ObjectIdentifier("1.3.132.0.15")
+    SECT233K1 = ObjectIdentifier("1.3.132.0.26")
+    SECT233R1 = ObjectIdentifier("1.3.132.0.27")
+    SECT283K1 = ObjectIdentifier("1.3.132.0.16")
+    SECT283R1 = ObjectIdentifier("1.3.132.0.17")
+    SECT409K1 = ObjectIdentifier("1.3.132.0.36")
+    SECT409R1 = ObjectIdentifier("1.3.132.0.37")
+    SECT571K1 = ObjectIdentifier("1.3.132.0.38")
+    SECT571R1 = ObjectIdentifier("1.3.132.0.39")
+
+
+class EllipticCurve(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def name(self) -> str:
+        """
+        The name of the curve. e.g. secp256r1.
+        """
+
+    @abc.abstractproperty
+    def key_size(self) -> int:
+        """
+        Bit size of a secret scalar for the curve.
+        """
+
+
+class EllipticCurveSignatureAlgorithm(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def algorithm(
+        self,
+    ) -> typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm]:
+        """
+        The digest algorithm used with this signature.
+        """
+
+
+class EllipticCurvePrivateKey(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def exchange(
+        self, algorithm: "ECDH", peer_public_key: "EllipticCurvePublicKey"
+    ) -> bytes:
+        """
+        Performs a key exchange operation using the provided algorithm with the
+        provided peer's public key.
+        """
+
+    @abc.abstractmethod
+    def public_key(self) -> "EllipticCurvePublicKey":
+        """
+        The EllipticCurvePublicKey for this private key.
+        """
+
+    @abc.abstractproperty
+    def curve(self) -> EllipticCurve:
+        """
+        The EllipticCurve that this key is on.
+        """
+
+    @abc.abstractproperty
+    def key_size(self) -> int:
+        """
+        Bit size of a secret scalar for the curve.
+        """
+
+    @abc.abstractmethod
+    def sign(
+        self,
+        data: bytes,
+        signature_algorithm: EllipticCurveSignatureAlgorithm,
+    ) -> bytes:
+        """
+        Signs the data
+        """
+
+    @abc.abstractmethod
+    def private_numbers(self) -> "EllipticCurvePrivateNumbers":
+        """
+        Returns an EllipticCurvePrivateNumbers.
+        """
+
+    @abc.abstractmethod
+    def private_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PrivateFormat,
+        encryption_algorithm: _serialization.KeySerializationEncryption,
+    ) -> bytes:
+        """
+        Returns the key serialized as bytes.
+        """
+
+
+EllipticCurvePrivateKeyWithSerialization = EllipticCurvePrivateKey
+
+
+class EllipticCurvePublicKey(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def curve(self) -> EllipticCurve:
+        """
+        The EllipticCurve that this key is on.
+        """
+
+    @abc.abstractproperty
+    def key_size(self) -> int:
+        """
+        Bit size of a secret scalar for the curve.
+        """
+
+    @abc.abstractmethod
+    def public_numbers(self) -> "EllipticCurvePublicNumbers":
+        """
+        Returns an EllipticCurvePublicNumbers.
+        """
+
+    @abc.abstractmethod
+    def public_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PublicFormat,
+    ) -> bytes:
+        """
+        Returns the key serialized as bytes.
+        """
+
+    @abc.abstractmethod
+    def verify(
+        self,
+        signature: bytes,
+        data: bytes,
+        signature_algorithm: EllipticCurveSignatureAlgorithm,
+    ) -> None:
+        """
+        Verifies the signature of the data.
+        """
+
+    @classmethod
+    def from_encoded_point(
+        cls, curve: EllipticCurve, data: bytes
+    ) -> "EllipticCurvePublicKey":
+        utils._check_bytes("data", data)
+
+        if not isinstance(curve, EllipticCurve):
+            raise TypeError("curve must be an EllipticCurve instance")
+
+        if len(data) == 0:
+            raise ValueError("data must not be an empty byte string")
+
+        if data[0] not in [0x02, 0x03, 0x04]:
+            raise ValueError("Unsupported elliptic curve point type")
+
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        return backend.load_elliptic_curve_public_bytes(curve, data)
+
+
+EllipticCurvePublicKeyWithSerialization = EllipticCurvePublicKey
+
+
+class SECT571R1(EllipticCurve):
+    name = "sect571r1"
+    key_size = 570
+
+
+class SECT409R1(EllipticCurve):
+    name = "sect409r1"
+    key_size = 409
+
+
+class SECT283R1(EllipticCurve):
+    name = "sect283r1"
+    key_size = 283
+
+
+class SECT233R1(EllipticCurve):
+    name = "sect233r1"
+    key_size = 233
+
+
+class SECT163R2(EllipticCurve):
+    name = "sect163r2"
+    key_size = 163
+
+
+class SECT571K1(EllipticCurve):
+    name = "sect571k1"
+    key_size = 571
+
+
+class SECT409K1(EllipticCurve):
+    name = "sect409k1"
+    key_size = 409
+
+
+class SECT283K1(EllipticCurve):
+    name = "sect283k1"
+    key_size = 283
+
+
+class SECT233K1(EllipticCurve):
+    name = "sect233k1"
+    key_size = 233
+
+
+class SECT163K1(EllipticCurve):
+    name = "sect163k1"
+    key_size = 163
+
+
+class SECP521R1(EllipticCurve):
+    name = "secp521r1"
+    key_size = 521
+
+
+class SECP384R1(EllipticCurve):
+    name = "secp384r1"
+    key_size = 384
+
+
+class SECP256R1(EllipticCurve):
+    name = "secp256r1"
+    key_size = 256
+
+
+class SECP256K1(EllipticCurve):
+    name = "secp256k1"
+    key_size = 256
+
+
+class SECP224R1(EllipticCurve):
+    name = "secp224r1"
+    key_size = 224
+
+
+class SECP192R1(EllipticCurve):
+    name = "secp192r1"
+    key_size = 192
+
+
+class BrainpoolP256R1(EllipticCurve):
+    name = "brainpoolP256r1"
+    key_size = 256
+
+
+class BrainpoolP384R1(EllipticCurve):
+    name = "brainpoolP384r1"
+    key_size = 384
+
+
+class BrainpoolP512R1(EllipticCurve):
+    name = "brainpoolP512r1"
+    key_size = 512
+
+
+_CURVE_TYPES: typing.Dict[str, typing.Type[EllipticCurve]] = {
+    "prime192v1": SECP192R1,
+    "prime256v1": SECP256R1,
+    "secp192r1": SECP192R1,
+    "secp224r1": SECP224R1,
+    "secp256r1": SECP256R1,
+    "secp384r1": SECP384R1,
+    "secp521r1": SECP521R1,
+    "secp256k1": SECP256K1,
+    "sect163k1": SECT163K1,
+    "sect233k1": SECT233K1,
+    "sect283k1": SECT283K1,
+    "sect409k1": SECT409K1,
+    "sect571k1": SECT571K1,
+    "sect163r2": SECT163R2,
+    "sect233r1": SECT233R1,
+    "sect283r1": SECT283R1,
+    "sect409r1": SECT409R1,
+    "sect571r1": SECT571R1,
+    "brainpoolP256r1": BrainpoolP256R1,
+    "brainpoolP384r1": BrainpoolP384R1,
+    "brainpoolP512r1": BrainpoolP512R1,
+}
+
+
+class ECDSA(EllipticCurveSignatureAlgorithm):
+    def __init__(
+        self,
+        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
+    ):
+        self._algorithm = algorithm
+
+    @property
+    def algorithm(
+        self,
+    ) -> typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm]:
+        return self._algorithm
+
+
+def generate_private_key(
+    curve: EllipticCurve, backend: typing.Any = None
+) -> EllipticCurvePrivateKey:
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.generate_elliptic_curve_private_key(curve)
+
+
+def derive_private_key(
+    private_value: int,
+    curve: EllipticCurve,
+    backend: typing.Any = None,
+) -> EllipticCurvePrivateKey:
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    if not isinstance(private_value, int):
+        raise TypeError("private_value must be an integer type.")
+
+    if private_value <= 0:
+        raise ValueError("private_value must be a positive integer.")
+
+    if not isinstance(curve, EllipticCurve):
+        raise TypeError("curve must provide the EllipticCurve interface.")
+
+    return ossl.derive_elliptic_curve_private_key(private_value, curve)
+
+
+class EllipticCurvePublicNumbers:
+    def __init__(self, x: int, y: int, curve: EllipticCurve):
+        if not isinstance(x, int) or not isinstance(y, int):
+            raise TypeError("x and y must be integers.")
+
+        if not isinstance(curve, EllipticCurve):
+            raise TypeError("curve must provide the EllipticCurve interface.")
+
+        self._y = y
+        self._x = x
+        self._curve = curve
+
+    def public_key(self, backend: typing.Any = None) -> EllipticCurvePublicKey:
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        return ossl.load_elliptic_curve_public_numbers(self)
+
+    def encode_point(self) -> bytes:
+        warnings.warn(
+            "encode_point has been deprecated on EllipticCurvePublicNumbers"
+            " and will be removed in a future version. Please use "
+            "EllipticCurvePublicKey.public_bytes to obtain both "
+            "compressed and uncompressed point encoding.",
+            utils.PersistentlyDeprecated2019,
+            stacklevel=2,
+        )
+        # key_size is in bits. Convert to bytes and round up
+        byte_length = (self.curve.key_size + 7) // 8
+        return (
+            b"\x04"
+            + utils.int_to_bytes(self.x, byte_length)
+            + utils.int_to_bytes(self.y, byte_length)
+        )
+
+    @classmethod
+    def from_encoded_point(
+        cls, curve: EllipticCurve, data: bytes
+    ) -> "EllipticCurvePublicNumbers":
+        if not isinstance(curve, EllipticCurve):
+            raise TypeError("curve must be an EllipticCurve instance")
+
+        warnings.warn(
+            "Support for unsafe construction of public numbers from "
+            "encoded data will be removed in a future version. "
+            "Please use EllipticCurvePublicKey.from_encoded_point",
+            utils.PersistentlyDeprecated2019,
+            stacklevel=2,
+        )
+
+        if data.startswith(b"\x04"):
+            # key_size is in bits. Convert to bytes and round up
+            byte_length = (curve.key_size + 7) // 8
+            if len(data) == 2 * byte_length + 1:
+                x = int.from_bytes(data[1 : byte_length + 1], "big")
+                y = int.from_bytes(data[byte_length + 1 :], "big")
+                return cls(x, y, curve)
+            else:
+                raise ValueError("Invalid elliptic curve point data length")
+        else:
+            raise ValueError("Unsupported elliptic curve point type")
+
+    @property
+    def curve(self) -> EllipticCurve:
+        return self._curve
+
+    @property
+    def x(self) -> int:
+        return self._x
+
+    @property
+    def y(self) -> int:
+        return self._y
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, EllipticCurvePublicNumbers):
+            return NotImplemented
+
+        return (
+            self.x == other.x
+            and self.y == other.y
+            and self.curve.name == other.curve.name
+            and self.curve.key_size == other.curve.key_size
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.x, self.y, self.curve.name, self.curve.key_size))
+
+    def __repr__(self) -> str:
+        return (
+            "<EllipticCurvePublicNumbers(curve={0.curve.name}, x={0.x}, "
+            "y={0.y}>".format(self)
+        )
+
+
+class EllipticCurvePrivateNumbers:
+    def __init__(
+        self, private_value: int, public_numbers: EllipticCurvePublicNumbers
+    ):
+        if not isinstance(private_value, int):
+            raise TypeError("private_value must be an integer.")
+
+        if not isinstance(public_numbers, EllipticCurvePublicNumbers):
+            raise TypeError(
+                "public_numbers must be an EllipticCurvePublicNumbers "
+                "instance."
+            )
+
+        self._private_value = private_value
+        self._public_numbers = public_numbers
+
+    def private_key(
+        self, backend: typing.Any = None
+    ) -> EllipticCurvePrivateKey:
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        return ossl.load_elliptic_curve_private_numbers(self)
+
+    @property
+    def private_value(self) -> int:
+        return self._private_value
+
+    @property
+    def public_numbers(self) -> EllipticCurvePublicNumbers:
+        return self._public_numbers
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, EllipticCurvePrivateNumbers):
+            return NotImplemented
+
+        return (
+            self.private_value == other.private_value
+            and self.public_numbers == other.public_numbers
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.private_value, self.public_numbers))
+
+
+class ECDH:
+    pass
+
+
+_OID_TO_CURVE = {
+    EllipticCurveOID.SECP192R1: SECP192R1,
+    EllipticCurveOID.SECP224R1: SECP224R1,
+    EllipticCurveOID.SECP256K1: SECP256K1,
+    EllipticCurveOID.SECP256R1: SECP256R1,
+    EllipticCurveOID.SECP384R1: SECP384R1,
+    EllipticCurveOID.SECP521R1: SECP521R1,
+    EllipticCurveOID.BRAINPOOLP256R1: BrainpoolP256R1,
+    EllipticCurveOID.BRAINPOOLP384R1: BrainpoolP384R1,
+    EllipticCurveOID.BRAINPOOLP512R1: BrainpoolP512R1,
+    EllipticCurveOID.SECT163K1: SECT163K1,
+    EllipticCurveOID.SECT163R2: SECT163R2,
+    EllipticCurveOID.SECT233K1: SECT233K1,
+    EllipticCurveOID.SECT233R1: SECT233R1,
+    EllipticCurveOID.SECT283K1: SECT283K1,
+    EllipticCurveOID.SECT283R1: SECT283R1,
+    EllipticCurveOID.SECT409K1: SECT409K1,
+    EllipticCurveOID.SECT409R1: SECT409R1,
+    EllipticCurveOID.SECT571K1: SECT571K1,
+    EllipticCurveOID.SECT571R1: SECT571R1,
+}
+
+
+def get_curve_for_oid(oid: ObjectIdentifier) -> typing.Type[EllipticCurve]:
+    try:
+        return _OID_TO_CURVE[oid]
+    except KeyError:
+        raise LookupError(
+            "The provided object identifier has no matching elliptic "
+            "curve class"
+        )
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/ed25519.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/ed25519.py
new file mode 100644
index 0000000..4327702
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/ed25519.py
@@ -0,0 +1,92 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+
+from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
+from cryptography.hazmat.primitives import _serialization
+
+
+_ED25519_KEY_SIZE = 32
+_ED25519_SIG_SIZE = 64
+
+
+class Ed25519PublicKey(metaclass=abc.ABCMeta):
+    @classmethod
+    def from_public_bytes(cls, data: bytes) -> "Ed25519PublicKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.ed25519_supported():
+            raise UnsupportedAlgorithm(
+                "ed25519 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM,
+            )
+
+        return backend.ed25519_load_public_bytes(data)
+
+    @abc.abstractmethod
+    def public_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PublicFormat,
+    ) -> bytes:
+        """
+        The serialized bytes of the public key.
+        """
+
+    @abc.abstractmethod
+    def verify(self, signature: bytes, data: bytes) -> None:
+        """
+        Verify the signature.
+        """
+
+
+class Ed25519PrivateKey(metaclass=abc.ABCMeta):
+    @classmethod
+    def generate(cls) -> "Ed25519PrivateKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.ed25519_supported():
+            raise UnsupportedAlgorithm(
+                "ed25519 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM,
+            )
+
+        return backend.ed25519_generate_key()
+
+    @classmethod
+    def from_private_bytes(cls, data: bytes) -> "Ed25519PrivateKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.ed25519_supported():
+            raise UnsupportedAlgorithm(
+                "ed25519 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM,
+            )
+
+        return backend.ed25519_load_private_bytes(data)
+
+    @abc.abstractmethod
+    def public_key(self) -> Ed25519PublicKey:
+        """
+        The Ed25519PublicKey derived from the private key.
+        """
+
+    @abc.abstractmethod
+    def private_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PrivateFormat,
+        encryption_algorithm: _serialization.KeySerializationEncryption,
+    ) -> bytes:
+        """
+        The serialized bytes of the private key.
+        """
+
+    @abc.abstractmethod
+    def sign(self, data: bytes) -> bytes:
+        """
+        Signs the data.
+        """
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/ed448.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/ed448.py
new file mode 100644
index 0000000..27bc27c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/ed448.py
@@ -0,0 +1,87 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+
+from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
+from cryptography.hazmat.primitives import _serialization
+
+
+class Ed448PublicKey(metaclass=abc.ABCMeta):
+    @classmethod
+    def from_public_bytes(cls, data: bytes) -> "Ed448PublicKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.ed448_supported():
+            raise UnsupportedAlgorithm(
+                "ed448 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM,
+            )
+
+        return backend.ed448_load_public_bytes(data)
+
+    @abc.abstractmethod
+    def public_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PublicFormat,
+    ) -> bytes:
+        """
+        The serialized bytes of the public key.
+        """
+
+    @abc.abstractmethod
+    def verify(self, signature: bytes, data: bytes) -> None:
+        """
+        Verify the signature.
+        """
+
+
+class Ed448PrivateKey(metaclass=abc.ABCMeta):
+    @classmethod
+    def generate(cls) -> "Ed448PrivateKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.ed448_supported():
+            raise UnsupportedAlgorithm(
+                "ed448 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM,
+            )
+        return backend.ed448_generate_key()
+
+    @classmethod
+    def from_private_bytes(cls, data: bytes) -> "Ed448PrivateKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.ed448_supported():
+            raise UnsupportedAlgorithm(
+                "ed448 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM,
+            )
+
+        return backend.ed448_load_private_bytes(data)
+
+    @abc.abstractmethod
+    def public_key(self) -> Ed448PublicKey:
+        """
+        The Ed448PublicKey derived from the private key.
+        """
+
+    @abc.abstractmethod
+    def sign(self, data: bytes) -> bytes:
+        """
+        Signs the data.
+        """
+
+    @abc.abstractmethod
+    def private_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PrivateFormat,
+        encryption_algorithm: _serialization.KeySerializationEncryption,
+    ) -> bytes:
+        """
+        The serialized bytes of the private key.
+        """
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/padding.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/padding.py
new file mode 100644
index 0000000..dd3c648
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/padding.py
@@ -0,0 +1,101 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import typing
+
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives._asymmetric import (
+    AsymmetricPadding as AsymmetricPadding,
+)
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+
+class PKCS1v15(AsymmetricPadding):
+    name = "EMSA-PKCS1-v1_5"
+
+
+class _MaxLength:
+    "Sentinel value for `MAX_LENGTH`."
+
+
+class _Auto:
+    "Sentinel value for `AUTO`."
+
+
+class _DigestLength:
+    "Sentinel value for `DIGEST_LENGTH`."
+
+
+class PSS(AsymmetricPadding):
+    MAX_LENGTH = _MaxLength()
+    AUTO = _Auto()
+    DIGEST_LENGTH = _DigestLength()
+    name = "EMSA-PSS"
+    _salt_length: typing.Union[int, _MaxLength, _Auto, _DigestLength]
+
+    def __init__(
+        self,
+        mgf: "MGF",
+        salt_length: typing.Union[int, _MaxLength, _Auto, _DigestLength],
+    ) -> None:
+        self._mgf = mgf
+
+        if not isinstance(
+            salt_length, (int, _MaxLength, _Auto, _DigestLength)
+        ):
+            raise TypeError(
+                "salt_length must be an integer, MAX_LENGTH, "
+                "DIGEST_LENGTH, or AUTO"
+            )
+
+        if isinstance(salt_length, int) and salt_length < 0:
+            raise ValueError("salt_length must be zero or greater.")
+
+        self._salt_length = salt_length
+
+
+class OAEP(AsymmetricPadding):
+    name = "EME-OAEP"
+
+    def __init__(
+        self,
+        mgf: "MGF",
+        algorithm: hashes.HashAlgorithm,
+        label: typing.Optional[bytes],
+    ):
+        if not isinstance(algorithm, hashes.HashAlgorithm):
+            raise TypeError("Expected instance of hashes.HashAlgorithm.")
+
+        self._mgf = mgf
+        self._algorithm = algorithm
+        self._label = label
+
+
+class MGF(metaclass=abc.ABCMeta):
+    _algorithm: hashes.HashAlgorithm
+
+
+class MGF1(MGF):
+    MAX_LENGTH = _MaxLength()
+
+    def __init__(self, algorithm: hashes.HashAlgorithm):
+        if not isinstance(algorithm, hashes.HashAlgorithm):
+            raise TypeError("Expected instance of hashes.HashAlgorithm.")
+
+        self._algorithm = algorithm
+
+
+def calculate_max_pss_salt_length(
+    key: typing.Union["rsa.RSAPrivateKey", "rsa.RSAPublicKey"],
+    hash_algorithm: hashes.HashAlgorithm,
+) -> int:
+    if not isinstance(key, (rsa.RSAPrivateKey, rsa.RSAPublicKey)):
+        raise TypeError("key must be an RSA public or private key")
+    # bit length - 1 per RFC 3447
+    emlen = (key.key_size + 6) // 8
+    salt_length = emlen - hash_algorithm.digest_size - 2
+    assert salt_length >= 0
+    return salt_length
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/rsa.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/rsa.py
new file mode 100644
index 0000000..5ffe767
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/rsa.py
@@ -0,0 +1,425 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import typing
+from math import gcd
+
+from cryptography.hazmat.primitives import _serialization, hashes
+from cryptography.hazmat.primitives._asymmetric import AsymmetricPadding
+from cryptography.hazmat.primitives.asymmetric import (
+    utils as asym_utils,
+)
+
+
+class RSAPrivateKey(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def decrypt(self, ciphertext: bytes, padding: AsymmetricPadding) -> bytes:
+        """
+        Decrypts the provided ciphertext.
+        """
+
+    @abc.abstractproperty
+    def key_size(self) -> int:
+        """
+        The bit length of the public modulus.
+        """
+
+    @abc.abstractmethod
+    def public_key(self) -> "RSAPublicKey":
+        """
+        The RSAPublicKey associated with this private key.
+        """
+
+    @abc.abstractmethod
+    def sign(
+        self,
+        data: bytes,
+        padding: AsymmetricPadding,
+        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
+    ) -> bytes:
+        """
+        Signs the data.
+        """
+
+    @abc.abstractmethod
+    def private_numbers(self) -> "RSAPrivateNumbers":
+        """
+        Returns an RSAPrivateNumbers.
+        """
+
+    @abc.abstractmethod
+    def private_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PrivateFormat,
+        encryption_algorithm: _serialization.KeySerializationEncryption,
+    ) -> bytes:
+        """
+        Returns the key serialized as bytes.
+        """
+
+
+RSAPrivateKeyWithSerialization = RSAPrivateKey
+
+
+class RSAPublicKey(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def encrypt(self, plaintext: bytes, padding: AsymmetricPadding) -> bytes:
+        """
+        Encrypts the given plaintext.
+        """
+
+    @abc.abstractproperty
+    def key_size(self) -> int:
+        """
+        The bit length of the public modulus.
+        """
+
+    @abc.abstractmethod
+    def public_numbers(self) -> "RSAPublicNumbers":
+        """
+        Returns an RSAPublicNumbers
+        """
+
+    @abc.abstractmethod
+    def public_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PublicFormat,
+    ) -> bytes:
+        """
+        Returns the key serialized as bytes.
+        """
+
+    @abc.abstractmethod
+    def verify(
+        self,
+        signature: bytes,
+        data: bytes,
+        padding: AsymmetricPadding,
+        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
+    ) -> None:
+        """
+        Verifies the signature of the data.
+        """
+
+    @abc.abstractmethod
+    def recover_data_from_signature(
+        self,
+        signature: bytes,
+        padding: AsymmetricPadding,
+        algorithm: typing.Optional[hashes.HashAlgorithm],
+    ) -> bytes:
+        """
+        Recovers the original data from the signature.
+        """
+
+
+RSAPublicKeyWithSerialization = RSAPublicKey
+
+
+def generate_private_key(
+    public_exponent: int,
+    key_size: int,
+    backend: typing.Any = None,
+) -> RSAPrivateKey:
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    _verify_rsa_parameters(public_exponent, key_size)
+    return ossl.generate_rsa_private_key(public_exponent, key_size)
+
+
+def _verify_rsa_parameters(public_exponent: int, key_size: int) -> None:
+    if public_exponent not in (3, 65537):
+        raise ValueError(
+            "public_exponent must be either 3 (for legacy compatibility) or "
+            "65537. Almost everyone should choose 65537 here!"
+        )
+
+    if key_size < 512:
+        raise ValueError("key_size must be at least 512-bits.")
+
+
+def _check_private_key_components(
+    p: int,
+    q: int,
+    private_exponent: int,
+    dmp1: int,
+    dmq1: int,
+    iqmp: int,
+    public_exponent: int,
+    modulus: int,
+) -> None:
+    if modulus < 3:
+        raise ValueError("modulus must be >= 3.")
+
+    if p >= modulus:
+        raise ValueError("p must be < modulus.")
+
+    if q >= modulus:
+        raise ValueError("q must be < modulus.")
+
+    if dmp1 >= modulus:
+        raise ValueError("dmp1 must be < modulus.")
+
+    if dmq1 >= modulus:
+        raise ValueError("dmq1 must be < modulus.")
+
+    if iqmp >= modulus:
+        raise ValueError("iqmp must be < modulus.")
+
+    if private_exponent >= modulus:
+        raise ValueError("private_exponent must be < modulus.")
+
+    if public_exponent < 3 or public_exponent >= modulus:
+        raise ValueError("public_exponent must be >= 3 and < modulus.")
+
+    if public_exponent & 1 == 0:
+        raise ValueError("public_exponent must be odd.")
+
+    if dmp1 & 1 == 0:
+        raise ValueError("dmp1 must be odd.")
+
+    if dmq1 & 1 == 0:
+        raise ValueError("dmq1 must be odd.")
+
+    if p * q != modulus:
+        raise ValueError("p*q must equal modulus.")
+
+
+def _check_public_key_components(e: int, n: int) -> None:
+    if n < 3:
+        raise ValueError("n must be >= 3.")
+
+    if e < 3 or e >= n:
+        raise ValueError("e must be >= 3 and < n.")
+
+    if e & 1 == 0:
+        raise ValueError("e must be odd.")
+
+
+def _modinv(e: int, m: int) -> int:
+    """
+    Modular Multiplicative Inverse. Returns x such that: (x*e) mod m == 1
+    """
+    x1, x2 = 1, 0
+    a, b = e, m
+    while b > 0:
+        q, r = divmod(a, b)
+        xn = x1 - q * x2
+        a, b, x1, x2 = b, r, x2, xn
+    return x1 % m
+
+
+def rsa_crt_iqmp(p: int, q: int) -> int:
+    """
+    Compute the CRT (q ** -1) % p value from RSA primes p and q.
+    """
+    return _modinv(q, p)
+
+
+def rsa_crt_dmp1(private_exponent: int, p: int) -> int:
+    """
+    Compute the CRT private_exponent % (p - 1) value from the RSA
+    private_exponent (d) and p.
+    """
+    return private_exponent % (p - 1)
+
+
+def rsa_crt_dmq1(private_exponent: int, q: int) -> int:
+    """
+    Compute the CRT private_exponent % (q - 1) value from the RSA
+    private_exponent (d) and q.
+    """
+    return private_exponent % (q - 1)
+
+
+# Controls the number of iterations rsa_recover_prime_factors will perform
+# to obtain the prime factors. Each iteration increments by 2 so the actual
+# maximum attempts is half this number.
+_MAX_RECOVERY_ATTEMPTS = 1000
+
+
+def rsa_recover_prime_factors(
+    n: int, e: int, d: int
+) -> typing.Tuple[int, int]:
+    """
+    Compute factors p and q from the private exponent d. We assume that n has
+    no more than two factors. This function is adapted from code in PyCrypto.
+    """
+    # See 8.2.2(i) in Handbook of Applied Cryptography.
+    ktot = d * e - 1
+    # The quantity d*e-1 is a multiple of phi(n), even,
+    # and can be represented as t*2^s.
+    t = ktot
+    while t % 2 == 0:
+        t = t // 2
+    # Cycle through all multiplicative inverses in Zn.
+    # The algorithm is non-deterministic, but there is a 50% chance
+    # any candidate a leads to successful factoring.
+    # See "Digitalized Signatures and Public Key Functions as Intractable
+    # as Factorization", M. Rabin, 1979
+    spotted = False
+    a = 2
+    while not spotted and a < _MAX_RECOVERY_ATTEMPTS:
+        k = t
+        # Cycle through all values a^{t*2^i}=a^k
+        while k < ktot:
+            cand = pow(a, k, n)
+            # Check if a^k is a non-trivial root of unity (mod n)
+            if cand != 1 and cand != (n - 1) and pow(cand, 2, n) == 1:
+                # We have found a number such that (cand-1)(cand+1)=0 (mod n).
+                # Either of the terms divides n.
+                p = gcd(cand + 1, n)
+                spotted = True
+                break
+            k *= 2
+        # This value was not any good... let's try another!
+        a += 2
+    if not spotted:
+        raise ValueError("Unable to compute factors p and q from exponent d.")
+    # Found !
+    q, r = divmod(n, p)
+    assert r == 0
+    p, q = sorted((p, q), reverse=True)
+    return (p, q)
+
+
+class RSAPrivateNumbers:
+    def __init__(
+        self,
+        p: int,
+        q: int,
+        d: int,
+        dmp1: int,
+        dmq1: int,
+        iqmp: int,
+        public_numbers: "RSAPublicNumbers",
+    ):
+        if (
+            not isinstance(p, int)
+            or not isinstance(q, int)
+            or not isinstance(d, int)
+            or not isinstance(dmp1, int)
+            or not isinstance(dmq1, int)
+            or not isinstance(iqmp, int)
+        ):
+            raise TypeError(
+                "RSAPrivateNumbers p, q, d, dmp1, dmq1, iqmp arguments must"
+                " all be an integers."
+            )
+
+        if not isinstance(public_numbers, RSAPublicNumbers):
+            raise TypeError(
+                "RSAPrivateNumbers public_numbers must be an RSAPublicNumbers"
+                " instance."
+            )
+
+        self._p = p
+        self._q = q
+        self._d = d
+        self._dmp1 = dmp1
+        self._dmq1 = dmq1
+        self._iqmp = iqmp
+        self._public_numbers = public_numbers
+
+    @property
+    def p(self) -> int:
+        return self._p
+
+    @property
+    def q(self) -> int:
+        return self._q
+
+    @property
+    def d(self) -> int:
+        return self._d
+
+    @property
+    def dmp1(self) -> int:
+        return self._dmp1
+
+    @property
+    def dmq1(self) -> int:
+        return self._dmq1
+
+    @property
+    def iqmp(self) -> int:
+        return self._iqmp
+
+    @property
+    def public_numbers(self) -> "RSAPublicNumbers":
+        return self._public_numbers
+
+    def private_key(self, backend: typing.Any = None) -> RSAPrivateKey:
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        return ossl.load_rsa_private_numbers(self)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RSAPrivateNumbers):
+            return NotImplemented
+
+        return (
+            self.p == other.p
+            and self.q == other.q
+            and self.d == other.d
+            and self.dmp1 == other.dmp1
+            and self.dmq1 == other.dmq1
+            and self.iqmp == other.iqmp
+            and self.public_numbers == other.public_numbers
+        )
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.p,
+                self.q,
+                self.d,
+                self.dmp1,
+                self.dmq1,
+                self.iqmp,
+                self.public_numbers,
+            )
+        )
+
+
+class RSAPublicNumbers:
+    def __init__(self, e: int, n: int):
+        if not isinstance(e, int) or not isinstance(n, int):
+            raise TypeError("RSAPublicNumbers arguments must be integers.")
+
+        self._e = e
+        self._n = n
+
+    @property
+    def e(self) -> int:
+        return self._e
+
+    @property
+    def n(self) -> int:
+        return self._n
+
+    def public_key(self, backend: typing.Any = None) -> RSAPublicKey:
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        return ossl.load_rsa_public_numbers(self)
+
+    def __repr__(self) -> str:
+        return "<RSAPublicNumbers(e={0.e}, n={0.n})>".format(self)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RSAPublicNumbers):
+            return NotImplemented
+
+        return self.e == other.e and self.n == other.n
+
+    def __hash__(self) -> int:
+        return hash((self.e, self.n))
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/types.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/types.py
new file mode 100644
index 0000000..d497815
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/types.py
@@ -0,0 +1,69 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives.asymmetric import (
+    dh,
+    dsa,
+    ec,
+    ed25519,
+    ed448,
+    rsa,
+    x25519,
+    x448,
+)
+
+
+# Every asymmetric key type
+PUBLIC_KEY_TYPES = typing.Union[
+    dh.DHPublicKey,
+    dsa.DSAPublicKey,
+    rsa.RSAPublicKey,
+    ec.EllipticCurvePublicKey,
+    ed25519.Ed25519PublicKey,
+    ed448.Ed448PublicKey,
+    x25519.X25519PublicKey,
+    x448.X448PublicKey,
+]
+# Every asymmetric key type
+PRIVATE_KEY_TYPES = typing.Union[
+    dh.DHPrivateKey,
+    ed25519.Ed25519PrivateKey,
+    ed448.Ed448PrivateKey,
+    rsa.RSAPrivateKey,
+    dsa.DSAPrivateKey,
+    ec.EllipticCurvePrivateKey,
+    x25519.X25519PrivateKey,
+    x448.X448PrivateKey,
+]
+# Just the key types we allow to be used for x509 signing. This mirrors
+# the certificate public key types
+CERTIFICATE_PRIVATE_KEY_TYPES = typing.Union[
+    ed25519.Ed25519PrivateKey,
+    ed448.Ed448PrivateKey,
+    rsa.RSAPrivateKey,
+    dsa.DSAPrivateKey,
+    ec.EllipticCurvePrivateKey,
+]
+# Just the key types we allow to be used for x509 signing. This mirrors
+# the certificate private key types
+CERTIFICATE_ISSUER_PUBLIC_KEY_TYPES = typing.Union[
+    dsa.DSAPublicKey,
+    rsa.RSAPublicKey,
+    ec.EllipticCurvePublicKey,
+    ed25519.Ed25519PublicKey,
+    ed448.Ed448PublicKey,
+]
+# This type removes DHPublicKey. x448/x25519 can be a public key
+# but cannot be used in signing so they are allowed here.
+CERTIFICATE_PUBLIC_KEY_TYPES = typing.Union[
+    dsa.DSAPublicKey,
+    rsa.RSAPublicKey,
+    ec.EllipticCurvePublicKey,
+    ed25519.Ed25519PublicKey,
+    ed448.Ed448PublicKey,
+    x25519.X25519PublicKey,
+    x448.X448PublicKey,
+]
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/utils.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/utils.py
new file mode 100644
index 0000000..638ecb3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/utils.py
@@ -0,0 +1,24 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+from cryptography.hazmat.bindings._rust import asn1
+from cryptography.hazmat.primitives import hashes
+
+
+decode_dss_signature = asn1.decode_dss_signature
+encode_dss_signature = asn1.encode_dss_signature
+
+
+class Prehashed:
+    def __init__(self, algorithm: hashes.HashAlgorithm):
+        if not isinstance(algorithm, hashes.HashAlgorithm):
+            raise TypeError("Expected instance of HashAlgorithm.")
+
+        self._algorithm = algorithm
+        self._digest_size = algorithm.digest_size
+
+    @property
+    def digest_size(self) -> int:
+        return self._digest_size
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/x25519.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/x25519.py
new file mode 100644
index 0000000..690af78
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/x25519.py
@@ -0,0 +1,81 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+
+from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
+from cryptography.hazmat.primitives import _serialization
+
+
+class X25519PublicKey(metaclass=abc.ABCMeta):
+    @classmethod
+    def from_public_bytes(cls, data: bytes) -> "X25519PublicKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.x25519_supported():
+            raise UnsupportedAlgorithm(
+                "X25519 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM,
+            )
+
+        return backend.x25519_load_public_bytes(data)
+
+    @abc.abstractmethod
+    def public_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PublicFormat,
+    ) -> bytes:
+        """
+        The serialized bytes of the public key.
+        """
+
+
+class X25519PrivateKey(metaclass=abc.ABCMeta):
+    @classmethod
+    def generate(cls) -> "X25519PrivateKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.x25519_supported():
+            raise UnsupportedAlgorithm(
+                "X25519 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM,
+            )
+        return backend.x25519_generate_key()
+
+    @classmethod
+    def from_private_bytes(cls, data: bytes) -> "X25519PrivateKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.x25519_supported():
+            raise UnsupportedAlgorithm(
+                "X25519 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM,
+            )
+
+        return backend.x25519_load_private_bytes(data)
+
+    @abc.abstractmethod
+    def public_key(self) -> X25519PublicKey:
+        """
+        The serialized bytes of the public key.
+        """
+
+    @abc.abstractmethod
+    def private_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PrivateFormat,
+        encryption_algorithm: _serialization.KeySerializationEncryption,
+    ) -> bytes:
+        """
+        The serialized bytes of the private key.
+        """
+
+    @abc.abstractmethod
+    def exchange(self, peer_public_key: X25519PublicKey) -> bytes:
+        """
+        Performs a key exchange operation using the provided peer's public key.
+        """
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/x448.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/x448.py
new file mode 100644
index 0000000..7f71c27
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/asymmetric/x448.py
@@ -0,0 +1,81 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+
+from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
+from cryptography.hazmat.primitives import _serialization
+
+
+class X448PublicKey(metaclass=abc.ABCMeta):
+    @classmethod
+    def from_public_bytes(cls, data: bytes) -> "X448PublicKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.x448_supported():
+            raise UnsupportedAlgorithm(
+                "X448 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM,
+            )
+
+        return backend.x448_load_public_bytes(data)
+
+    @abc.abstractmethod
+    def public_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PublicFormat,
+    ) -> bytes:
+        """
+        The serialized bytes of the public key.
+        """
+
+
+class X448PrivateKey(metaclass=abc.ABCMeta):
+    @classmethod
+    def generate(cls) -> "X448PrivateKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.x448_supported():
+            raise UnsupportedAlgorithm(
+                "X448 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM,
+            )
+        return backend.x448_generate_key()
+
+    @classmethod
+    def from_private_bytes(cls, data: bytes) -> "X448PrivateKey":
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.x448_supported():
+            raise UnsupportedAlgorithm(
+                "X448 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM,
+            )
+
+        return backend.x448_load_private_bytes(data)
+
+    @abc.abstractmethod
+    def public_key(self) -> X448PublicKey:
+        """
+        The serialized bytes of the public key.
+        """
+
+    @abc.abstractmethod
+    def private_bytes(
+        self,
+        encoding: _serialization.Encoding,
+        format: _serialization.PrivateFormat,
+        encryption_algorithm: _serialization.KeySerializationEncryption,
+    ) -> bytes:
+        """
+        The serialized bytes of the private key.
+        """
+
+    @abc.abstractmethod
+    def exchange(self, peer_public_key: X448PublicKey) -> bytes:
+        """
+        Performs a key exchange operation using the provided peer's public key.
+        """
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/__init__.py
new file mode 100644
index 0000000..874dbd4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/__init__.py
@@ -0,0 +1,27 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+from cryptography.hazmat.primitives._cipheralgorithm import (
+    BlockCipherAlgorithm,
+    CipherAlgorithm,
+)
+from cryptography.hazmat.primitives.ciphers.base import (
+    AEADCipherContext,
+    AEADDecryptionContext,
+    AEADEncryptionContext,
+    Cipher,
+    CipherContext,
+)
+
+
+__all__ = [
+    "Cipher",
+    "CipherAlgorithm",
+    "BlockCipherAlgorithm",
+    "CipherContext",
+    "AEADCipherContext",
+    "AEADDecryptionContext",
+    "AEADEncryptionContext",
+]
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/aead.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/aead.py
new file mode 100644
index 0000000..3cdb3eb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/aead.py
@@ -0,0 +1,361 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import os
+import typing
+
+from cryptography import exceptions, utils
+from cryptography.hazmat.backends.openssl import aead
+from cryptography.hazmat.backends.openssl.backend import backend
+
+
+class ChaCha20Poly1305:
+    _MAX_SIZE = 2**31 - 1
+
+    def __init__(self, key: bytes):
+        if not backend.aead_cipher_supported(self):
+            raise exceptions.UnsupportedAlgorithm(
+                "ChaCha20Poly1305 is not supported by this version of OpenSSL",
+                exceptions._Reasons.UNSUPPORTED_CIPHER,
+            )
+        utils._check_byteslike("key", key)
+
+        if len(key) != 32:
+            raise ValueError("ChaCha20Poly1305 key must be 32 bytes.")
+
+        self._key = key
+
+    @classmethod
+    def generate_key(cls) -> bytes:
+        return os.urandom(32)
+
+    def encrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: typing.Optional[bytes],
+    ) -> bytes:
+        if associated_data is None:
+            associated_data = b""
+
+        if len(data) > self._MAX_SIZE or len(associated_data) > self._MAX_SIZE:
+            # This is OverflowError to match what cffi would raise
+            raise OverflowError(
+                "Data or associated data too long. Max 2**31 - 1 bytes"
+            )
+
+        self._check_params(nonce, data, associated_data)
+        return aead._encrypt(backend, self, nonce, data, [associated_data], 16)
+
+    def decrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: typing.Optional[bytes],
+    ) -> bytes:
+        if associated_data is None:
+            associated_data = b""
+
+        self._check_params(nonce, data, associated_data)
+        return aead._decrypt(backend, self, nonce, data, [associated_data], 16)
+
+    def _check_params(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes,
+    ) -> None:
+        utils._check_byteslike("nonce", nonce)
+        utils._check_bytes("data", data)
+        utils._check_bytes("associated_data", associated_data)
+        if len(nonce) != 12:
+            raise ValueError("Nonce must be 12 bytes")
+
+
+class AESCCM:
+    _MAX_SIZE = 2**31 - 1
+
+    def __init__(self, key: bytes, tag_length: int = 16):
+        utils._check_byteslike("key", key)
+        if len(key) not in (16, 24, 32):
+            raise ValueError("AESCCM key must be 128, 192, or 256 bits.")
+
+        self._key = key
+        if not isinstance(tag_length, int):
+            raise TypeError("tag_length must be an integer")
+
+        if tag_length not in (4, 6, 8, 10, 12, 14, 16):
+            raise ValueError("Invalid tag_length")
+
+        self._tag_length = tag_length
+
+        if not backend.aead_cipher_supported(self):
+            raise exceptions.UnsupportedAlgorithm(
+                "AESCCM is not supported by this version of OpenSSL",
+                exceptions._Reasons.UNSUPPORTED_CIPHER,
+            )
+
+    @classmethod
+    def generate_key(cls, bit_length: int) -> bytes:
+        if not isinstance(bit_length, int):
+            raise TypeError("bit_length must be an integer")
+
+        if bit_length not in (128, 192, 256):
+            raise ValueError("bit_length must be 128, 192, or 256")
+
+        return os.urandom(bit_length // 8)
+
+    def encrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: typing.Optional[bytes],
+    ) -> bytes:
+        if associated_data is None:
+            associated_data = b""
+
+        if len(data) > self._MAX_SIZE or len(associated_data) > self._MAX_SIZE:
+            # This is OverflowError to match what cffi would raise
+            raise OverflowError(
+                "Data or associated data too long. Max 2**31 - 1 bytes"
+            )
+
+        self._check_params(nonce, data, associated_data)
+        self._validate_lengths(nonce, len(data))
+        return aead._encrypt(
+            backend, self, nonce, data, [associated_data], self._tag_length
+        )
+
+    def decrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: typing.Optional[bytes],
+    ) -> bytes:
+        if associated_data is None:
+            associated_data = b""
+
+        self._check_params(nonce, data, associated_data)
+        return aead._decrypt(
+            backend, self, nonce, data, [associated_data], self._tag_length
+        )
+
+    def _validate_lengths(self, nonce: bytes, data_len: int) -> None:
+        # For information about computing this, see
+        # https://tools.ietf.org/html/rfc3610#section-2.1
+        l_val = 15 - len(nonce)
+        if 2 ** (8 * l_val) < data_len:
+            raise ValueError("Data too long for nonce")
+
+    def _check_params(
+        self, nonce: bytes, data: bytes, associated_data: bytes
+    ) -> None:
+        utils._check_byteslike("nonce", nonce)
+        utils._check_bytes("data", data)
+        utils._check_bytes("associated_data", associated_data)
+        if not 7 <= len(nonce) <= 13:
+            raise ValueError("Nonce must be between 7 and 13 bytes")
+
+
+class AESGCM:
+    _MAX_SIZE = 2**31 - 1
+
+    def __init__(self, key: bytes):
+        utils._check_byteslike("key", key)
+        if len(key) not in (16, 24, 32):
+            raise ValueError("AESGCM key must be 128, 192, or 256 bits.")
+
+        self._key = key
+
+    @classmethod
+    def generate_key(cls, bit_length: int) -> bytes:
+        if not isinstance(bit_length, int):
+            raise TypeError("bit_length must be an integer")
+
+        if bit_length not in (128, 192, 256):
+            raise ValueError("bit_length must be 128, 192, or 256")
+
+        return os.urandom(bit_length // 8)
+
+    def encrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: typing.Optional[bytes],
+    ) -> bytes:
+        if associated_data is None:
+            associated_data = b""
+
+        if len(data) > self._MAX_SIZE or len(associated_data) > self._MAX_SIZE:
+            # This is OverflowError to match what cffi would raise
+            raise OverflowError(
+                "Data or associated data too long. Max 2**31 - 1 bytes"
+            )
+
+        self._check_params(nonce, data, associated_data)
+        return aead._encrypt(backend, self, nonce, data, [associated_data], 16)
+
+    def decrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: typing.Optional[bytes],
+    ) -> bytes:
+        if associated_data is None:
+            associated_data = b""
+
+        self._check_params(nonce, data, associated_data)
+        return aead._decrypt(backend, self, nonce, data, [associated_data], 16)
+
+    def _check_params(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes,
+    ) -> None:
+        utils._check_byteslike("nonce", nonce)
+        utils._check_bytes("data", data)
+        utils._check_bytes("associated_data", associated_data)
+        if len(nonce) < 8 or len(nonce) > 128:
+            raise ValueError("Nonce must be between 8 and 128 bytes")
+
+
+class AESOCB3:
+    _MAX_SIZE = 2**31 - 1
+
+    def __init__(self, key: bytes):
+        utils._check_byteslike("key", key)
+        if len(key) not in (16, 24, 32):
+            raise ValueError("AESOCB3 key must be 128, 192, or 256 bits.")
+
+        self._key = key
+
+        if not backend.aead_cipher_supported(self):
+            raise exceptions.UnsupportedAlgorithm(
+                "OCB3 is not supported by this version of OpenSSL",
+                exceptions._Reasons.UNSUPPORTED_CIPHER,
+            )
+
+    @classmethod
+    def generate_key(cls, bit_length: int) -> bytes:
+        if not isinstance(bit_length, int):
+            raise TypeError("bit_length must be an integer")
+
+        if bit_length not in (128, 192, 256):
+            raise ValueError("bit_length must be 128, 192, or 256")
+
+        return os.urandom(bit_length // 8)
+
+    def encrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: typing.Optional[bytes],
+    ) -> bytes:
+        if associated_data is None:
+            associated_data = b""
+
+        if len(data) > self._MAX_SIZE or len(associated_data) > self._MAX_SIZE:
+            # This is OverflowError to match what cffi would raise
+            raise OverflowError(
+                "Data or associated data too long. Max 2**31 - 1 bytes"
+            )
+
+        self._check_params(nonce, data, associated_data)
+        return aead._encrypt(backend, self, nonce, data, [associated_data], 16)
+
+    def decrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: typing.Optional[bytes],
+    ) -> bytes:
+        if associated_data is None:
+            associated_data = b""
+
+        self._check_params(nonce, data, associated_data)
+        return aead._decrypt(backend, self, nonce, data, [associated_data], 16)
+
+    def _check_params(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes,
+    ) -> None:
+        utils._check_byteslike("nonce", nonce)
+        utils._check_bytes("data", data)
+        utils._check_bytes("associated_data", associated_data)
+        if len(nonce) < 12 or len(nonce) > 15:
+            raise ValueError("Nonce must be between 12 and 15 bytes")
+
+
+class AESSIV(object):
+    _MAX_SIZE = 2**31 - 1
+
+    def __init__(self, key: bytes):
+        utils._check_byteslike("key", key)
+        if len(key) not in (32, 48, 64):
+            raise ValueError("AESSIV key must be 256, 384, or 512 bits.")
+
+        self._key = key
+
+        if not backend.aead_cipher_supported(self):
+            raise exceptions.UnsupportedAlgorithm(
+                "AES-SIV is not supported by this version of OpenSSL",
+                exceptions._Reasons.UNSUPPORTED_CIPHER,
+            )
+
+    @classmethod
+    def generate_key(cls, bit_length: int) -> bytes:
+        if not isinstance(bit_length, int):
+            raise TypeError("bit_length must be an integer")
+
+        if bit_length not in (256, 384, 512):
+            raise ValueError("bit_length must be 256, 384, or 512")
+
+        return os.urandom(bit_length // 8)
+
+    def encrypt(
+        self,
+        data: bytes,
+        associated_data: typing.Optional[typing.List[bytes]],
+    ) -> bytes:
+        if associated_data is None:
+            associated_data = []
+
+        self._check_params(data, associated_data)
+
+        if len(data) > self._MAX_SIZE or any(
+            len(ad) > self._MAX_SIZE for ad in associated_data
+        ):
+            # This is OverflowError to match what cffi would raise
+            raise OverflowError(
+                "Data or associated data too long. Max 2**31 - 1 bytes"
+            )
+
+        return aead._encrypt(backend, self, b"", data, associated_data, 16)
+
+    def decrypt(
+        self,
+        data: bytes,
+        associated_data: typing.Optional[typing.List[bytes]],
+    ) -> bytes:
+        if associated_data is None:
+            associated_data = []
+
+        self._check_params(data, associated_data)
+
+        return aead._decrypt(backend, self, b"", data, associated_data, 16)
+
+    def _check_params(
+        self,
+        data: bytes,
+        associated_data: typing.List,
+    ) -> None:
+        utils._check_bytes("data", data)
+        if not isinstance(associated_data, list) or not all(
+            isinstance(x, bytes) for x in associated_data
+        ):
+            raise TypeError("associated_data must be a list of bytes or None")
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/algorithms.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/algorithms.py
new file mode 100644
index 0000000..e327e76
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/algorithms.py
@@ -0,0 +1,207 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+from cryptography import utils
+from cryptography.hazmat.primitives.ciphers import (
+    BlockCipherAlgorithm,
+    CipherAlgorithm,
+)
+
+
+def _verify_key_size(algorithm: CipherAlgorithm, key: bytes) -> bytes:
+    # Verify that the key is instance of bytes
+    utils._check_byteslike("key", key)
+
+    # Verify that the key size matches the expected key size
+    if len(key) * 8 not in algorithm.key_sizes:
+        raise ValueError(
+            "Invalid key size ({}) for {}.".format(
+                len(key) * 8, algorithm.name
+            )
+        )
+    return key
+
+
+class AES(CipherAlgorithm, BlockCipherAlgorithm):
+    name = "AES"
+    block_size = 128
+    # 512 added to support AES-256-XTS, which uses 512-bit keys
+    key_sizes = frozenset([128, 192, 256, 512])
+
+    def __init__(self, key: bytes):
+        self.key = _verify_key_size(self, key)
+
+    @property
+    def key_size(self) -> int:
+        return len(self.key) * 8
+
+
+class Camellia(CipherAlgorithm, BlockCipherAlgorithm):
+    name = "camellia"
+    block_size = 128
+    key_sizes = frozenset([128, 192, 256])
+
+    def __init__(self, key: bytes):
+        self.key = _verify_key_size(self, key)
+
+    @property
+    def key_size(self) -> int:
+        return len(self.key) * 8
+
+
+class TripleDES(CipherAlgorithm, BlockCipherAlgorithm):
+    name = "3DES"
+    block_size = 64
+    key_sizes = frozenset([64, 128, 192])
+
+    def __init__(self, key: bytes):
+        if len(key) == 8:
+            key += key + key
+        elif len(key) == 16:
+            key += key[:8]
+        self.key = _verify_key_size(self, key)
+
+    @property
+    def key_size(self) -> int:
+        return len(self.key) * 8
+
+
+class Blowfish(CipherAlgorithm, BlockCipherAlgorithm):
+    name = "Blowfish"
+    block_size = 64
+    key_sizes = frozenset(range(32, 449, 8))
+
+    def __init__(self, key: bytes):
+        self.key = _verify_key_size(self, key)
+
+    @property
+    def key_size(self) -> int:
+        return len(self.key) * 8
+
+
+_BlowfishInternal = Blowfish
+utils.deprecated(
+    Blowfish,
+    __name__,
+    "Blowfish has been deprecated",
+    utils.DeprecatedIn37,
+    name="Blowfish",
+)
+
+
+class CAST5(CipherAlgorithm, BlockCipherAlgorithm):
+    name = "CAST5"
+    block_size = 64
+    key_sizes = frozenset(range(40, 129, 8))
+
+    def __init__(self, key: bytes):
+        self.key = _verify_key_size(self, key)
+
+    @property
+    def key_size(self) -> int:
+        return len(self.key) * 8
+
+
+_CAST5Internal = CAST5
+utils.deprecated(
+    CAST5,
+    __name__,
+    "CAST5 has been deprecated",
+    utils.DeprecatedIn37,
+    name="CAST5",
+)
+
+
+class ARC4(CipherAlgorithm):
+    name = "RC4"
+    key_sizes = frozenset([40, 56, 64, 80, 128, 160, 192, 256])
+
+    def __init__(self, key: bytes):
+        self.key = _verify_key_size(self, key)
+
+    @property
+    def key_size(self) -> int:
+        return len(self.key) * 8
+
+
+class IDEA(CipherAlgorithm, BlockCipherAlgorithm):
+    name = "IDEA"
+    block_size = 64
+    key_sizes = frozenset([128])
+
+    def __init__(self, key: bytes):
+        self.key = _verify_key_size(self, key)
+
+    @property
+    def key_size(self) -> int:
+        return len(self.key) * 8
+
+
+_IDEAInternal = IDEA
+utils.deprecated(
+    IDEA,
+    __name__,
+    "IDEA has been deprecated",
+    utils.DeprecatedIn37,
+    name="IDEA",
+)
+
+
+class SEED(CipherAlgorithm, BlockCipherAlgorithm):
+    name = "SEED"
+    block_size = 128
+    key_sizes = frozenset([128])
+
+    def __init__(self, key: bytes):
+        self.key = _verify_key_size(self, key)
+
+    @property
+    def key_size(self) -> int:
+        return len(self.key) * 8
+
+
+_SEEDInternal = SEED
+utils.deprecated(
+    SEED,
+    __name__,
+    "SEED has been deprecated",
+    utils.DeprecatedIn37,
+    name="SEED",
+)
+
+
+class ChaCha20(CipherAlgorithm):
+    name = "ChaCha20"
+    key_sizes = frozenset([256])
+
+    def __init__(self, key: bytes, nonce: bytes):
+        self.key = _verify_key_size(self, key)
+        utils._check_byteslike("nonce", nonce)
+
+        if len(nonce) != 16:
+            raise ValueError("nonce must be 128-bits (16 bytes)")
+
+        self._nonce = nonce
+
+    @property
+    def nonce(self) -> bytes:
+        return self._nonce
+
+    @property
+    def key_size(self) -> int:
+        return len(self.key) * 8
+
+
+class SM4(CipherAlgorithm, BlockCipherAlgorithm):
+    name = "SM4"
+    block_size = 128
+    key_sizes = frozenset([128])
+
+    def __init__(self, key: bytes):
+        self.key = _verify_key_size(self, key)
+
+    @property
+    def key_size(self) -> int:
+        return len(self.key) * 8
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/base.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/base.py
new file mode 100644
index 0000000..2ea7fc6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/base.py
@@ -0,0 +1,269 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import typing
+
+from cryptography.exceptions import (
+    AlreadyFinalized,
+    AlreadyUpdated,
+    NotYetFinalized,
+)
+from cryptography.hazmat.primitives._cipheralgorithm import CipherAlgorithm
+from cryptography.hazmat.primitives.ciphers import modes
+
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.ciphers import (
+        _CipherContext as _BackendCipherContext,
+    )
+
+
+class CipherContext(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def update(self, data: bytes) -> bytes:
+        """
+        Processes the provided bytes through the cipher and returns the results
+        as bytes.
+        """
+
+    @abc.abstractmethod
+    def update_into(self, data: bytes, buf: bytes) -> int:
+        """
+        Processes the provided bytes and writes the resulting data into the
+        provided buffer. Returns the number of bytes written.
+        """
+
+    @abc.abstractmethod
+    def finalize(self) -> bytes:
+        """
+        Returns the results of processing the final block as bytes.
+        """
+
+
+class AEADCipherContext(CipherContext, metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def authenticate_additional_data(self, data: bytes) -> None:
+        """
+        Authenticates the provided bytes.
+        """
+
+
+class AEADDecryptionContext(AEADCipherContext, metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def finalize_with_tag(self, tag: bytes) -> bytes:
+        """
+        Returns the results of processing the final block as bytes and allows
+        delayed passing of the authentication tag.
+        """
+
+
+class AEADEncryptionContext(AEADCipherContext, metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def tag(self) -> bytes:
+        """
+        Returns tag bytes. This is only available after encryption is
+        finalized.
+        """
+
+
+Mode = typing.TypeVar(
+    "Mode", bound=typing.Optional[modes.Mode], covariant=True
+)
+
+
+class Cipher(typing.Generic[Mode]):
+    def __init__(
+        self,
+        algorithm: CipherAlgorithm,
+        mode: Mode,
+        backend: typing.Any = None,
+    ):
+
+        if not isinstance(algorithm, CipherAlgorithm):
+            raise TypeError("Expected interface of CipherAlgorithm.")
+
+        if mode is not None:
+            # mypy needs this assert to narrow the type from our generic
+            # type. Maybe it won't some time in the future.
+            assert isinstance(mode, modes.Mode)
+            mode.validate_for_algorithm(algorithm)
+
+        self.algorithm = algorithm
+        self.mode = mode
+
+    @typing.overload
+    def encryptor(
+        self: "Cipher[modes.ModeWithAuthenticationTag]",
+    ) -> AEADEncryptionContext:
+        ...
+
+    @typing.overload
+    def encryptor(
+        self: "_CIPHER_TYPE",
+    ) -> CipherContext:
+        ...
+
+    def encryptor(self):
+        if isinstance(self.mode, modes.ModeWithAuthenticationTag):
+            if self.mode.tag is not None:
+                raise ValueError(
+                    "Authentication tag must be None when encrypting."
+                )
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        ctx = backend.create_symmetric_encryption_ctx(
+            self.algorithm, self.mode
+        )
+        return self._wrap_ctx(ctx, encrypt=True)
+
+    @typing.overload
+    def decryptor(
+        self: "Cipher[modes.ModeWithAuthenticationTag]",
+    ) -> AEADDecryptionContext:
+        ...
+
+    @typing.overload
+    def decryptor(
+        self: "_CIPHER_TYPE",
+    ) -> CipherContext:
+        ...
+
+    def decryptor(self):
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        ctx = backend.create_symmetric_decryption_ctx(
+            self.algorithm, self.mode
+        )
+        return self._wrap_ctx(ctx, encrypt=False)
+
+    def _wrap_ctx(
+        self, ctx: "_BackendCipherContext", encrypt: bool
+    ) -> typing.Union[
+        AEADEncryptionContext, AEADDecryptionContext, CipherContext
+    ]:
+        if isinstance(self.mode, modes.ModeWithAuthenticationTag):
+            if encrypt:
+                return _AEADEncryptionContext(ctx)
+            else:
+                return _AEADDecryptionContext(ctx)
+        else:
+            return _CipherContext(ctx)
+
+
+_CIPHER_TYPE = Cipher[
+    typing.Union[
+        modes.ModeWithNonce,
+        modes.ModeWithTweak,
+        None,
+        modes.ECB,
+        modes.ModeWithInitializationVector,
+    ]
+]
+
+
+class _CipherContext(CipherContext):
+    _ctx: typing.Optional["_BackendCipherContext"]
+
+    def __init__(self, ctx: "_BackendCipherContext") -> None:
+        self._ctx = ctx
+
+    def update(self, data: bytes) -> bytes:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        return self._ctx.update(data)
+
+    def update_into(self, data: bytes, buf: bytes) -> int:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        return self._ctx.update_into(data, buf)
+
+    def finalize(self) -> bytes:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        data = self._ctx.finalize()
+        self._ctx = None
+        return data
+
+
+class _AEADCipherContext(AEADCipherContext):
+    _ctx: typing.Optional["_BackendCipherContext"]
+    _tag: typing.Optional[bytes]
+
+    def __init__(self, ctx: "_BackendCipherContext") -> None:
+        self._ctx = ctx
+        self._bytes_processed = 0
+        self._aad_bytes_processed = 0
+        self._tag = None
+        self._updated = False
+
+    def _check_limit(self, data_size: int) -> None:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        self._updated = True
+        self._bytes_processed += data_size
+        if self._bytes_processed > self._ctx._mode._MAX_ENCRYPTED_BYTES:
+            raise ValueError(
+                "{} has a maximum encrypted byte limit of {}".format(
+                    self._ctx._mode.name, self._ctx._mode._MAX_ENCRYPTED_BYTES
+                )
+            )
+
+    def update(self, data: bytes) -> bytes:
+        self._check_limit(len(data))
+        # mypy needs this assert even though _check_limit already checked
+        assert self._ctx is not None
+        return self._ctx.update(data)
+
+    def update_into(self, data: bytes, buf: bytes) -> int:
+        self._check_limit(len(data))
+        # mypy needs this assert even though _check_limit already checked
+        assert self._ctx is not None
+        return self._ctx.update_into(data, buf)
+
+    def finalize(self) -> bytes:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        data = self._ctx.finalize()
+        self._tag = self._ctx.tag
+        self._ctx = None
+        return data
+
+    def authenticate_additional_data(self, data: bytes) -> None:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        if self._updated:
+            raise AlreadyUpdated("Update has been called on this context.")
+
+        self._aad_bytes_processed += len(data)
+        if self._aad_bytes_processed > self._ctx._mode._MAX_AAD_BYTES:
+            raise ValueError(
+                "{} has a maximum AAD byte limit of {}".format(
+                    self._ctx._mode.name, self._ctx._mode._MAX_AAD_BYTES
+                )
+            )
+
+        self._ctx.authenticate_additional_data(data)
+
+
+class _AEADDecryptionContext(_AEADCipherContext, AEADDecryptionContext):
+    def finalize_with_tag(self, tag: bytes) -> bytes:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        data = self._ctx.finalize_with_tag(tag)
+        self._tag = self._ctx.tag
+        self._ctx = None
+        return data
+
+
+class _AEADEncryptionContext(_AEADCipherContext, AEADEncryptionContext):
+    @property
+    def tag(self) -> bytes:
+        if self._ctx is not None:
+            raise NotYetFinalized(
+                "You must finalize encryption before " "getting the tag."
+            )
+        assert self._tag is not None
+        return self._tag
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/modes.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/modes.py
new file mode 100644
index 0000000..6911742
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/ciphers/modes.py
@@ -0,0 +1,263 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
+from cryptography.hazmat.primitives._cipheralgorithm import (
+    BlockCipherAlgorithm,
+    CipherAlgorithm,
+)
+
+
+class Mode(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def name(self) -> str:
+        """
+        A string naming this mode (e.g. "ECB", "CBC").
+        """
+
+    @abc.abstractmethod
+    def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None:
+        """
+        Checks that all the necessary invariants of this (mode, algorithm)
+        combination are met.
+        """
+
+
+class ModeWithInitializationVector(Mode, metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def initialization_vector(self) -> bytes:
+        """
+        The value of the initialization vector for this mode as bytes.
+        """
+
+
+class ModeWithTweak(Mode, metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def tweak(self) -> bytes:
+        """
+        The value of the tweak for this mode as bytes.
+        """
+
+
+class ModeWithNonce(Mode, metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def nonce(self) -> bytes:
+        """
+        The value of the nonce for this mode as bytes.
+        """
+
+
+class ModeWithAuthenticationTag(Mode, metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def tag(self) -> typing.Optional[bytes]:
+        """
+        The value of the tag supplied to the constructor of this mode.
+        """
+
+
+def _check_aes_key_length(self: Mode, algorithm: CipherAlgorithm) -> None:
+    if algorithm.key_size > 256 and algorithm.name == "AES":
+        raise ValueError(
+            "Only 128, 192, and 256 bit keys are allowed for this AES mode"
+        )
+
+
+def _check_iv_length(
+    self: ModeWithInitializationVector, algorithm: BlockCipherAlgorithm
+) -> None:
+    if len(self.initialization_vector) * 8 != algorithm.block_size:
+        raise ValueError(
+            "Invalid IV size ({}) for {}.".format(
+                len(self.initialization_vector), self.name
+            )
+        )
+
+
+def _check_nonce_length(
+    nonce: bytes, name: str, algorithm: CipherAlgorithm
+) -> None:
+    if not isinstance(algorithm, BlockCipherAlgorithm):
+        raise UnsupportedAlgorithm(
+            f"{name} requires a block cipher algorithm",
+            _Reasons.UNSUPPORTED_CIPHER,
+        )
+    if len(nonce) * 8 != algorithm.block_size:
+        raise ValueError(
+            "Invalid nonce size ({}) for {}.".format(len(nonce), name)
+        )
+
+
+def _check_iv_and_key_length(
+    self: ModeWithInitializationVector, algorithm: CipherAlgorithm
+) -> None:
+    if not isinstance(algorithm, BlockCipherAlgorithm):
+        raise UnsupportedAlgorithm(
+            f"{self} requires a block cipher algorithm",
+            _Reasons.UNSUPPORTED_CIPHER,
+        )
+    _check_aes_key_length(self, algorithm)
+    _check_iv_length(self, algorithm)
+
+
+class CBC(ModeWithInitializationVector):
+    name = "CBC"
+
+    def __init__(self, initialization_vector: bytes):
+        utils._check_byteslike("initialization_vector", initialization_vector)
+        self._initialization_vector = initialization_vector
+
+    @property
+    def initialization_vector(self) -> bytes:
+        return self._initialization_vector
+
+    validate_for_algorithm = _check_iv_and_key_length
+
+
+class XTS(ModeWithTweak):
+    name = "XTS"
+
+    def __init__(self, tweak: bytes):
+        utils._check_byteslike("tweak", tweak)
+
+        if len(tweak) != 16:
+            raise ValueError("tweak must be 128-bits (16 bytes)")
+
+        self._tweak = tweak
+
+    @property
+    def tweak(self) -> bytes:
+        return self._tweak
+
+    def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None:
+        if algorithm.key_size not in (256, 512):
+            raise ValueError(
+                "The XTS specification requires a 256-bit key for AES-128-XTS"
+                " and 512-bit key for AES-256-XTS"
+            )
+
+
+class ECB(Mode):
+    name = "ECB"
+
+    validate_for_algorithm = _check_aes_key_length
+
+
+class OFB(ModeWithInitializationVector):
+    name = "OFB"
+
+    def __init__(self, initialization_vector: bytes):
+        utils._check_byteslike("initialization_vector", initialization_vector)
+        self._initialization_vector = initialization_vector
+
+    @property
+    def initialization_vector(self) -> bytes:
+        return self._initialization_vector
+
+    validate_for_algorithm = _check_iv_and_key_length
+
+
+class CFB(ModeWithInitializationVector):
+    name = "CFB"
+
+    def __init__(self, initialization_vector: bytes):
+        utils._check_byteslike("initialization_vector", initialization_vector)
+        self._initialization_vector = initialization_vector
+
+    @property
+    def initialization_vector(self) -> bytes:
+        return self._initialization_vector
+
+    validate_for_algorithm = _check_iv_and_key_length
+
+
+class CFB8(ModeWithInitializationVector):
+    name = "CFB8"
+
+    def __init__(self, initialization_vector: bytes):
+        utils._check_byteslike("initialization_vector", initialization_vector)
+        self._initialization_vector = initialization_vector
+
+    @property
+    def initialization_vector(self) -> bytes:
+        return self._initialization_vector
+
+    validate_for_algorithm = _check_iv_and_key_length
+
+
+class CTR(ModeWithNonce):
+    name = "CTR"
+
+    def __init__(self, nonce: bytes):
+        utils._check_byteslike("nonce", nonce)
+        self._nonce = nonce
+
+    @property
+    def nonce(self) -> bytes:
+        return self._nonce
+
+    def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None:
+        _check_aes_key_length(self, algorithm)
+        _check_nonce_length(self.nonce, self.name, algorithm)
+
+
+class GCM(ModeWithInitializationVector, ModeWithAuthenticationTag):
+    name = "GCM"
+    _MAX_ENCRYPTED_BYTES = (2**39 - 256) // 8
+    _MAX_AAD_BYTES = (2**64) // 8
+
+    def __init__(
+        self,
+        initialization_vector: bytes,
+        tag: typing.Optional[bytes] = None,
+        min_tag_length: int = 16,
+    ):
+        # OpenSSL 3.0.0 constrains GCM IVs to [64, 1024] bits inclusive
+        # This is a sane limit anyway so we'll enforce it here.
+        utils._check_byteslike("initialization_vector", initialization_vector)
+        if len(initialization_vector) < 8 or len(initialization_vector) > 128:
+            raise ValueError(
+                "initialization_vector must be between 8 and 128 bytes (64 "
+                "and 1024 bits)."
+            )
+        self._initialization_vector = initialization_vector
+        if tag is not None:
+            utils._check_bytes("tag", tag)
+            if min_tag_length < 4:
+                raise ValueError("min_tag_length must be >= 4")
+            if len(tag) < min_tag_length:
+                raise ValueError(
+                    "Authentication tag must be {} bytes or longer.".format(
+                        min_tag_length
+                    )
+                )
+        self._tag = tag
+        self._min_tag_length = min_tag_length
+
+    @property
+    def tag(self) -> typing.Optional[bytes]:
+        return self._tag
+
+    @property
+    def initialization_vector(self) -> bytes:
+        return self._initialization_vector
+
+    def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None:
+        _check_aes_key_length(self, algorithm)
+        if not isinstance(algorithm, BlockCipherAlgorithm):
+            raise UnsupportedAlgorithm(
+                "GCM requires a block cipher algorithm",
+                _Reasons.UNSUPPORTED_CIPHER,
+            )
+        block_size_bytes = algorithm.block_size // 8
+        if self._tag is not None and len(self._tag) > block_size_bytes:
+            raise ValueError(
+                "Authentication tag cannot be more than {} bytes.".format(
+                    block_size_bytes
+                )
+            )
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/cmac.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/cmac.py
new file mode 100644
index 0000000..e08d65e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/cmac.py
@@ -0,0 +1,66 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import (
+    AlreadyFinalized,
+)
+from cryptography.hazmat.primitives import ciphers
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.cmac import _CMACContext
+
+
+class CMAC:
+    _ctx: typing.Optional["_CMACContext"]
+    _algorithm: ciphers.BlockCipherAlgorithm
+
+    def __init__(
+        self,
+        algorithm: ciphers.BlockCipherAlgorithm,
+        backend: typing.Any = None,
+        ctx: typing.Optional["_CMACContext"] = None,
+    ):
+        if not isinstance(algorithm, ciphers.BlockCipherAlgorithm):
+            raise TypeError("Expected instance of BlockCipherAlgorithm.")
+        self._algorithm = algorithm
+
+        if ctx is None:
+            from cryptography.hazmat.backends.openssl.backend import (
+                backend as ossl,
+            )
+
+            self._ctx = ossl.create_cmac_ctx(self._algorithm)
+        else:
+            self._ctx = ctx
+
+    def update(self, data: bytes) -> None:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+
+        utils._check_bytes("data", data)
+        self._ctx.update(data)
+
+    def finalize(self) -> bytes:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        digest = self._ctx.finalize()
+        self._ctx = None
+        return digest
+
+    def verify(self, signature: bytes) -> None:
+        utils._check_bytes("signature", signature)
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+
+        ctx, self._ctx = self._ctx, None
+        ctx.verify(signature)
+
+    def copy(self) -> "CMAC":
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        return CMAC(self._algorithm, ctx=self._ctx.copy())
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/constant_time.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/constant_time.py
new file mode 100644
index 0000000..a02fa9c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/constant_time.py
@@ -0,0 +1,13 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import hmac
+
+
+def bytes_eq(a: bytes, b: bytes) -> bool:
+    if not isinstance(a, bytes) or not isinstance(b, bytes):
+        raise TypeError("a and b must be bytes.")
+
+    return hmac.compare_digest(a, b)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/hashes.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/hashes.py
new file mode 100644
index 0000000..cc0771d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/hashes.py
@@ -0,0 +1,259 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import abc
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import (
+    AlreadyFinalized,
+)
+
+
+class HashAlgorithm(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def name(self) -> str:
+        """
+        A string naming this algorithm (e.g. "sha256", "md5").
+        """
+
+    @abc.abstractproperty
+    def digest_size(self) -> int:
+        """
+        The size of the resulting digest in bytes.
+        """
+
+    @abc.abstractproperty
+    def block_size(self) -> typing.Optional[int]:
+        """
+        The internal block size of the hash function, or None if the hash
+        function does not use blocks internally (e.g. SHA3).
+        """
+
+
+class HashContext(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def algorithm(self) -> HashAlgorithm:
+        """
+        A HashAlgorithm that will be used by this context.
+        """
+
+    @abc.abstractmethod
+    def update(self, data: bytes) -> None:
+        """
+        Processes the provided bytes through the hash.
+        """
+
+    @abc.abstractmethod
+    def finalize(self) -> bytes:
+        """
+        Finalizes the hash context and returns the hash digest as bytes.
+        """
+
+    @abc.abstractmethod
+    def copy(self) -> "HashContext":
+        """
+        Return a HashContext that is a copy of the current context.
+        """
+
+
+class ExtendableOutputFunction(metaclass=abc.ABCMeta):
+    """
+    An interface for extendable output functions.
+    """
+
+
+class Hash(HashContext):
+    _ctx: typing.Optional[HashContext]
+
+    def __init__(
+        self,
+        algorithm: HashAlgorithm,
+        backend: typing.Any = None,
+        ctx: typing.Optional["HashContext"] = None,
+    ):
+        if not isinstance(algorithm, HashAlgorithm):
+            raise TypeError("Expected instance of hashes.HashAlgorithm.")
+        self._algorithm = algorithm
+
+        if ctx is None:
+            from cryptography.hazmat.backends.openssl.backend import (
+                backend as ossl,
+            )
+
+            self._ctx = ossl.create_hash_ctx(self.algorithm)
+        else:
+            self._ctx = ctx
+
+    @property
+    def algorithm(self) -> HashAlgorithm:
+        return self._algorithm
+
+    def update(self, data: bytes) -> None:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        utils._check_byteslike("data", data)
+        self._ctx.update(data)
+
+    def copy(self) -> "Hash":
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        return Hash(self.algorithm, ctx=self._ctx.copy())
+
+    def finalize(self) -> bytes:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        digest = self._ctx.finalize()
+        self._ctx = None
+        return digest
+
+
+class SHA1(HashAlgorithm):
+    name = "sha1"
+    digest_size = 20
+    block_size = 64
+
+
+class SHA512_224(HashAlgorithm):  # noqa: N801
+    name = "sha512-224"
+    digest_size = 28
+    block_size = 128
+
+
+class SHA512_256(HashAlgorithm):  # noqa: N801
+    name = "sha512-256"
+    digest_size = 32
+    block_size = 128
+
+
+class SHA224(HashAlgorithm):
+    name = "sha224"
+    digest_size = 28
+    block_size = 64
+
+
+class SHA256(HashAlgorithm):
+    name = "sha256"
+    digest_size = 32
+    block_size = 64
+
+
+class SHA384(HashAlgorithm):
+    name = "sha384"
+    digest_size = 48
+    block_size = 128
+
+
+class SHA512(HashAlgorithm):
+    name = "sha512"
+    digest_size = 64
+    block_size = 128
+
+
+class SHA3_224(HashAlgorithm):  # noqa: N801
+    name = "sha3-224"
+    digest_size = 28
+    block_size = None
+
+
+class SHA3_256(HashAlgorithm):  # noqa: N801
+    name = "sha3-256"
+    digest_size = 32
+    block_size = None
+
+
+class SHA3_384(HashAlgorithm):  # noqa: N801
+    name = "sha3-384"
+    digest_size = 48
+    block_size = None
+
+
+class SHA3_512(HashAlgorithm):  # noqa: N801
+    name = "sha3-512"
+    digest_size = 64
+    block_size = None
+
+
+class SHAKE128(HashAlgorithm, ExtendableOutputFunction):
+    name = "shake128"
+    block_size = None
+
+    def __init__(self, digest_size: int):
+        if not isinstance(digest_size, int):
+            raise TypeError("digest_size must be an integer")
+
+        if digest_size < 1:
+            raise ValueError("digest_size must be a positive integer")
+
+        self._digest_size = digest_size
+
+    @property
+    def digest_size(self) -> int:
+        return self._digest_size
+
+
+class SHAKE256(HashAlgorithm, ExtendableOutputFunction):
+    name = "shake256"
+    block_size = None
+
+    def __init__(self, digest_size: int):
+        if not isinstance(digest_size, int):
+            raise TypeError("digest_size must be an integer")
+
+        if digest_size < 1:
+            raise ValueError("digest_size must be a positive integer")
+
+        self._digest_size = digest_size
+
+    @property
+    def digest_size(self) -> int:
+        return self._digest_size
+
+
+class MD5(HashAlgorithm):
+    name = "md5"
+    digest_size = 16
+    block_size = 64
+
+
+class BLAKE2b(HashAlgorithm):
+    name = "blake2b"
+    _max_digest_size = 64
+    _min_digest_size = 1
+    block_size = 128
+
+    def __init__(self, digest_size: int):
+
+        if digest_size != 64:
+            raise ValueError("Digest size must be 64")
+
+        self._digest_size = digest_size
+
+    @property
+    def digest_size(self) -> int:
+        return self._digest_size
+
+
+class BLAKE2s(HashAlgorithm):
+    name = "blake2s"
+    block_size = 64
+    _max_digest_size = 32
+    _min_digest_size = 1
+
+    def __init__(self, digest_size: int):
+
+        if digest_size != 32:
+            raise ValueError("Digest size must be 32")
+
+        self._digest_size = digest_size
+
+    @property
+    def digest_size(self) -> int:
+        return self._digest_size
+
+
+class SM3(HashAlgorithm):
+    name = "sm3"
+    digest_size = 32
+    block_size = 64
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/hmac.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/hmac.py
new file mode 100644
index 0000000..1577326
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/hmac.py
@@ -0,0 +1,72 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import (
+    AlreadyFinalized,
+)
+from cryptography.hazmat.backends.openssl.hmac import _HMACContext
+from cryptography.hazmat.primitives import hashes
+
+
+class HMAC(hashes.HashContext):
+    _ctx: typing.Optional[_HMACContext]
+
+    def __init__(
+        self,
+        key: bytes,
+        algorithm: hashes.HashAlgorithm,
+        backend: typing.Any = None,
+        ctx=None,
+    ):
+        if not isinstance(algorithm, hashes.HashAlgorithm):
+            raise TypeError("Expected instance of hashes.HashAlgorithm.")
+        self._algorithm = algorithm
+
+        self._key = key
+        if ctx is None:
+            from cryptography.hazmat.backends.openssl.backend import (
+                backend as ossl,
+            )
+
+            self._ctx = ossl.create_hmac_ctx(key, self.algorithm)
+        else:
+            self._ctx = ctx
+
+    @property
+    def algorithm(self) -> hashes.HashAlgorithm:
+        return self._algorithm
+
+    def update(self, data: bytes) -> None:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        utils._check_byteslike("data", data)
+        self._ctx.update(data)
+
+    def copy(self) -> "HMAC":
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        return HMAC(
+            self._key,
+            self.algorithm,
+            ctx=self._ctx.copy(),
+        )
+
+    def finalize(self) -> bytes:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        digest = self._ctx.finalize()
+        self._ctx = None
+        return digest
+
+    def verify(self, signature: bytes) -> None:
+        utils._check_bytes("signature", signature)
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+
+        ctx, self._ctx = self._ctx, None
+        ctx.verify(signature)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/__init__.py
new file mode 100644
index 0000000..38e2f8b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/__init__.py
@@ -0,0 +1,22 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+
+
+class KeyDerivationFunction(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def derive(self, key_material: bytes) -> bytes:
+        """
+        Deterministically generates and returns a new key based on the existing
+        key material.
+        """
+
+    @abc.abstractmethod
+    def verify(self, key_material: bytes, expected_key: bytes) -> None:
+        """
+        Checks whether the key generated by the key material matches the
+        expected derived key. Raises an exception if they do not match.
+        """
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/concatkdf.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/concatkdf.py
new file mode 100644
index 0000000..0b0262e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/concatkdf.py
@@ -0,0 +1,130 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import (
+    AlreadyFinalized,
+    InvalidKey,
+)
+from cryptography.hazmat.primitives import constant_time, hashes, hmac
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+
+def _int_to_u32be(n: int) -> bytes:
+    return n.to_bytes(length=4, byteorder="big")
+
+
+def _common_args_checks(
+    algorithm: hashes.HashAlgorithm,
+    length: int,
+    otherinfo: typing.Optional[bytes],
+) -> None:
+    max_length = algorithm.digest_size * (2**32 - 1)
+    if length > max_length:
+        raise ValueError(
+            "Cannot derive keys larger than {} bits.".format(max_length)
+        )
+    if otherinfo is not None:
+        utils._check_bytes("otherinfo", otherinfo)
+
+
+def _concatkdf_derive(
+    key_material: bytes,
+    length: int,
+    auxfn: typing.Callable[[], hashes.HashContext],
+    otherinfo: bytes,
+) -> bytes:
+    utils._check_byteslike("key_material", key_material)
+    output = [b""]
+    outlen = 0
+    counter = 1
+
+    while length > outlen:
+        h = auxfn()
+        h.update(_int_to_u32be(counter))
+        h.update(key_material)
+        h.update(otherinfo)
+        output.append(h.finalize())
+        outlen += len(output[-1])
+        counter += 1
+
+    return b"".join(output)[:length]
+
+
+class ConcatKDFHash(KeyDerivationFunction):
+    def __init__(
+        self,
+        algorithm: hashes.HashAlgorithm,
+        length: int,
+        otherinfo: typing.Optional[bytes],
+        backend: typing.Any = None,
+    ):
+        _common_args_checks(algorithm, length, otherinfo)
+        self._algorithm = algorithm
+        self._length = length
+        self._otherinfo: bytes = otherinfo if otherinfo is not None else b""
+
+        self._used = False
+
+    def _hash(self) -> hashes.Hash:
+        return hashes.Hash(self._algorithm)
+
+    def derive(self, key_material: bytes) -> bytes:
+        if self._used:
+            raise AlreadyFinalized
+        self._used = True
+        return _concatkdf_derive(
+            key_material, self._length, self._hash, self._otherinfo
+        )
+
+    def verify(self, key_material: bytes, expected_key: bytes) -> None:
+        if not constant_time.bytes_eq(self.derive(key_material), expected_key):
+            raise InvalidKey
+
+
+class ConcatKDFHMAC(KeyDerivationFunction):
+    def __init__(
+        self,
+        algorithm: hashes.HashAlgorithm,
+        length: int,
+        salt: typing.Optional[bytes],
+        otherinfo: typing.Optional[bytes],
+        backend: typing.Any = None,
+    ):
+        _common_args_checks(algorithm, length, otherinfo)
+        self._algorithm = algorithm
+        self._length = length
+        self._otherinfo: bytes = otherinfo if otherinfo is not None else b""
+
+        if algorithm.block_size is None:
+            raise TypeError(
+                "{} is unsupported for ConcatKDF".format(algorithm.name)
+            )
+
+        if salt is None:
+            salt = b"\x00" * algorithm.block_size
+        else:
+            utils._check_bytes("salt", salt)
+
+        self._salt = salt
+
+        self._used = False
+
+    def _hmac(self) -> hmac.HMAC:
+        return hmac.HMAC(self._salt, self._algorithm)
+
+    def derive(self, key_material: bytes) -> bytes:
+        if self._used:
+            raise AlreadyFinalized
+        self._used = True
+        return _concatkdf_derive(
+            key_material, self._length, self._hmac, self._otherinfo
+        )
+
+    def verify(self, key_material: bytes, expected_key: bytes) -> None:
+        if not constant_time.bytes_eq(self.derive(key_material), expected_key):
+            raise InvalidKey
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/hkdf.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/hkdf.py
new file mode 100644
index 0000000..44889b6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/hkdf.py
@@ -0,0 +1,103 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import (
+    AlreadyFinalized,
+    InvalidKey,
+)
+from cryptography.hazmat.primitives import constant_time, hashes, hmac
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+
+class HKDF(KeyDerivationFunction):
+    def __init__(
+        self,
+        algorithm: hashes.HashAlgorithm,
+        length: int,
+        salt: typing.Optional[bytes],
+        info: typing.Optional[bytes],
+        backend: typing.Any = None,
+    ):
+        self._algorithm = algorithm
+
+        if salt is None:
+            salt = b"\x00" * self._algorithm.digest_size
+        else:
+            utils._check_bytes("salt", salt)
+
+        self._salt = salt
+
+        self._hkdf_expand = HKDFExpand(self._algorithm, length, info)
+
+    def _extract(self, key_material: bytes) -> bytes:
+        h = hmac.HMAC(self._salt, self._algorithm)
+        h.update(key_material)
+        return h.finalize()
+
+    def derive(self, key_material: bytes) -> bytes:
+        utils._check_byteslike("key_material", key_material)
+        return self._hkdf_expand.derive(self._extract(key_material))
+
+    def verify(self, key_material: bytes, expected_key: bytes) -> None:
+        if not constant_time.bytes_eq(self.derive(key_material), expected_key):
+            raise InvalidKey
+
+
+class HKDFExpand(KeyDerivationFunction):
+    def __init__(
+        self,
+        algorithm: hashes.HashAlgorithm,
+        length: int,
+        info: typing.Optional[bytes],
+        backend: typing.Any = None,
+    ):
+        self._algorithm = algorithm
+
+        max_length = 255 * algorithm.digest_size
+
+        if length > max_length:
+            raise ValueError(
+                "Cannot derive keys larger than {} octets.".format(max_length)
+            )
+
+        self._length = length
+
+        if info is None:
+            info = b""
+        else:
+            utils._check_bytes("info", info)
+
+        self._info = info
+
+        self._used = False
+
+    def _expand(self, key_material: bytes) -> bytes:
+        output = [b""]
+        counter = 1
+
+        while self._algorithm.digest_size * (len(output) - 1) < self._length:
+            h = hmac.HMAC(key_material, self._algorithm)
+            h.update(output[-1])
+            h.update(self._info)
+            h.update(bytes([counter]))
+            output.append(h.finalize())
+            counter += 1
+
+        return b"".join(output)[: self._length]
+
+    def derive(self, key_material: bytes) -> bytes:
+        utils._check_byteslike("key_material", key_material)
+        if self._used:
+            raise AlreadyFinalized
+
+        self._used = True
+        return self._expand(key_material)
+
+    def verify(self, key_material: bytes, expected_key: bytes) -> None:
+        if not constant_time.bytes_eq(self.derive(key_material), expected_key):
+            raise InvalidKey
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/kbkdf.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/kbkdf.py
new file mode 100644
index 0000000..d365130
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/kbkdf.py
@@ -0,0 +1,258 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import (
+    AlreadyFinalized,
+    InvalidKey,
+    UnsupportedAlgorithm,
+    _Reasons,
+)
+from cryptography.hazmat.primitives import (
+    ciphers,
+    cmac,
+    constant_time,
+    hashes,
+    hmac,
+)
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+
+class Mode(utils.Enum):
+    CounterMode = "ctr"
+
+
+class CounterLocation(utils.Enum):
+    BeforeFixed = "before_fixed"
+    AfterFixed = "after_fixed"
+
+
+class _KBKDFDeriver:
+    def __init__(
+        self,
+        prf: typing.Callable,
+        mode: Mode,
+        length: int,
+        rlen: int,
+        llen: typing.Optional[int],
+        location: CounterLocation,
+        label: typing.Optional[bytes],
+        context: typing.Optional[bytes],
+        fixed: typing.Optional[bytes],
+    ):
+        assert callable(prf)
+
+        if not isinstance(mode, Mode):
+            raise TypeError("mode must be of type Mode")
+
+        if not isinstance(location, CounterLocation):
+            raise TypeError("location must be of type CounterLocation")
+
+        if (label or context) and fixed:
+            raise ValueError(
+                "When supplying fixed data, " "label and context are ignored."
+            )
+
+        if rlen is None or not self._valid_byte_length(rlen):
+            raise ValueError("rlen must be between 1 and 4")
+
+        if llen is None and fixed is None:
+            raise ValueError("Please specify an llen")
+
+        if llen is not None and not isinstance(llen, int):
+            raise TypeError("llen must be an integer")
+
+        if label is None:
+            label = b""
+
+        if context is None:
+            context = b""
+
+        utils._check_bytes("label", label)
+        utils._check_bytes("context", context)
+        self._prf = prf
+        self._mode = mode
+        self._length = length
+        self._rlen = rlen
+        self._llen = llen
+        self._location = location
+        self._label = label
+        self._context = context
+        self._used = False
+        self._fixed_data = fixed
+
+    @staticmethod
+    def _valid_byte_length(value: int) -> bool:
+        if not isinstance(value, int):
+            raise TypeError("value must be of type int")
+
+        value_bin = utils.int_to_bytes(1, value)
+        if not 1 <= len(value_bin) <= 4:
+            return False
+        return True
+
+    def derive(self, key_material: bytes, prf_output_size: int) -> bytes:
+        if self._used:
+            raise AlreadyFinalized
+
+        utils._check_byteslike("key_material", key_material)
+        self._used = True
+
+        # inverse floor division (equivalent to ceiling)
+        rounds = -(-self._length // prf_output_size)
+
+        output = [b""]
+
+        # For counter mode, the number of iterations shall not be
+        # larger than 2^r-1, where r <= 32 is the binary length of the counter
+        # This ensures that the counter values used as an input to the
+        # PRF will not repeat during a particular call to the KDF function.
+        r_bin = utils.int_to_bytes(1, self._rlen)
+        if rounds > pow(2, len(r_bin) * 8) - 1:
+            raise ValueError("There are too many iterations.")
+
+        for i in range(1, rounds + 1):
+            h = self._prf(key_material)
+
+            counter = utils.int_to_bytes(i, self._rlen)
+            if self._location == CounterLocation.BeforeFixed:
+                h.update(counter)
+
+            h.update(self._generate_fixed_input())
+
+            if self._location == CounterLocation.AfterFixed:
+                h.update(counter)
+
+            output.append(h.finalize())
+
+        return b"".join(output)[: self._length]
+
+    def _generate_fixed_input(self) -> bytes:
+        if self._fixed_data and isinstance(self._fixed_data, bytes):
+            return self._fixed_data
+
+        l_val = utils.int_to_bytes(self._length * 8, self._llen)
+
+        return b"".join([self._label, b"\x00", self._context, l_val])
+
+
+class KBKDFHMAC(KeyDerivationFunction):
+    def __init__(
+        self,
+        algorithm: hashes.HashAlgorithm,
+        mode: Mode,
+        length: int,
+        rlen: int,
+        llen: typing.Optional[int],
+        location: CounterLocation,
+        label: typing.Optional[bytes],
+        context: typing.Optional[bytes],
+        fixed: typing.Optional[bytes],
+        backend: typing.Any = None,
+    ):
+        if not isinstance(algorithm, hashes.HashAlgorithm):
+            raise UnsupportedAlgorithm(
+                "Algorithm supplied is not a supported hash algorithm.",
+                _Reasons.UNSUPPORTED_HASH,
+            )
+
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        if not ossl.hmac_supported(algorithm):
+            raise UnsupportedAlgorithm(
+                "Algorithm supplied is not a supported hmac algorithm.",
+                _Reasons.UNSUPPORTED_HASH,
+            )
+
+        self._algorithm = algorithm
+
+        self._deriver = _KBKDFDeriver(
+            self._prf,
+            mode,
+            length,
+            rlen,
+            llen,
+            location,
+            label,
+            context,
+            fixed,
+        )
+
+    def _prf(self, key_material: bytes) -> hmac.HMAC:
+        return hmac.HMAC(key_material, self._algorithm)
+
+    def derive(self, key_material: bytes) -> bytes:
+        return self._deriver.derive(key_material, self._algorithm.digest_size)
+
+    def verify(self, key_material: bytes, expected_key: bytes) -> None:
+        if not constant_time.bytes_eq(self.derive(key_material), expected_key):
+            raise InvalidKey
+
+
+class KBKDFCMAC(KeyDerivationFunction):
+    def __init__(
+        self,
+        algorithm,
+        mode: Mode,
+        length: int,
+        rlen: int,
+        llen: typing.Optional[int],
+        location: CounterLocation,
+        label: typing.Optional[bytes],
+        context: typing.Optional[bytes],
+        fixed: typing.Optional[bytes],
+        backend: typing.Any = None,
+    ):
+        if not issubclass(
+            algorithm, ciphers.BlockCipherAlgorithm
+        ) or not issubclass(algorithm, ciphers.CipherAlgorithm):
+            raise UnsupportedAlgorithm(
+                "Algorithm supplied is not a supported cipher algorithm.",
+                _Reasons.UNSUPPORTED_CIPHER,
+            )
+
+        self._algorithm = algorithm
+        self._cipher: typing.Optional[ciphers.BlockCipherAlgorithm] = None
+
+        self._deriver = _KBKDFDeriver(
+            self._prf,
+            mode,
+            length,
+            rlen,
+            llen,
+            location,
+            label,
+            context,
+            fixed,
+        )
+
+    def _prf(self, _: bytes) -> cmac.CMAC:
+        assert self._cipher is not None
+
+        return cmac.CMAC(self._cipher)
+
+    def derive(self, key_material: bytes) -> bytes:
+        self._cipher = self._algorithm(key_material)
+
+        assert self._cipher is not None
+
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        if not ossl.cmac_algorithm_supported(self._cipher):
+            raise UnsupportedAlgorithm(
+                "Algorithm supplied is not a supported cipher algorithm.",
+                _Reasons.UNSUPPORTED_CIPHER,
+            )
+
+        return self._deriver.derive(key_material, self._cipher.block_size // 8)
+
+    def verify(self, key_material: bytes, expected_key: bytes) -> None:
+        if not constant_time.bytes_eq(self.derive(key_material), expected_key):
+            raise InvalidKey
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/pbkdf2.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/pbkdf2.py
new file mode 100644
index 0000000..8d23f8c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/pbkdf2.py
@@ -0,0 +1,65 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import (
+    AlreadyFinalized,
+    InvalidKey,
+    UnsupportedAlgorithm,
+    _Reasons,
+)
+from cryptography.hazmat.primitives import constant_time, hashes
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+
+class PBKDF2HMAC(KeyDerivationFunction):
+    def __init__(
+        self,
+        algorithm: hashes.HashAlgorithm,
+        length: int,
+        salt: bytes,
+        iterations: int,
+        backend: typing.Any = None,
+    ):
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        if not ossl.pbkdf2_hmac_supported(algorithm):
+            raise UnsupportedAlgorithm(
+                "{} is not supported for PBKDF2 by this backend.".format(
+                    algorithm.name
+                ),
+                _Reasons.UNSUPPORTED_HASH,
+            )
+        self._used = False
+        self._algorithm = algorithm
+        self._length = length
+        utils._check_bytes("salt", salt)
+        self._salt = salt
+        self._iterations = iterations
+
+    def derive(self, key_material: bytes) -> bytes:
+        if self._used:
+            raise AlreadyFinalized("PBKDF2 instances can only be used once.")
+        self._used = True
+
+        utils._check_byteslike("key_material", key_material)
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        return backend.derive_pbkdf2_hmac(
+            self._algorithm,
+            self._length,
+            self._salt,
+            self._iterations,
+            key_material,
+        )
+
+    def verify(self, key_material: bytes, expected_key: bytes) -> None:
+        derived_key = self.derive(key_material)
+        if not constant_time.bytes_eq(derived_key, expected_key):
+            raise InvalidKey("Keys do not match.")
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/scrypt.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/scrypt.py
new file mode 100644
index 0000000..ff81bbb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/scrypt.py
@@ -0,0 +1,74 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import sys
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import (
+    AlreadyFinalized,
+    InvalidKey,
+    UnsupportedAlgorithm,
+)
+from cryptography.hazmat.primitives import constant_time
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+
+# This is used by the scrypt tests to skip tests that require more memory
+# than the MEM_LIMIT
+_MEM_LIMIT = sys.maxsize // 2
+
+
+class Scrypt(KeyDerivationFunction):
+    def __init__(
+        self,
+        salt: bytes,
+        length: int,
+        n: int,
+        r: int,
+        p: int,
+        backend: typing.Any = None,
+    ):
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        if not ossl.scrypt_supported():
+            raise UnsupportedAlgorithm(
+                "This version of OpenSSL does not support scrypt"
+            )
+        self._length = length
+        utils._check_bytes("salt", salt)
+        if n < 2 or (n & (n - 1)) != 0:
+            raise ValueError("n must be greater than 1 and be a power of 2.")
+
+        if r < 1:
+            raise ValueError("r must be greater than or equal to 1.")
+
+        if p < 1:
+            raise ValueError("p must be greater than or equal to 1.")
+
+        self._used = False
+        self._salt = salt
+        self._n = n
+        self._r = r
+        self._p = p
+
+    def derive(self, key_material: bytes) -> bytes:
+        if self._used:
+            raise AlreadyFinalized("Scrypt instances can only be used once.")
+        self._used = True
+
+        utils._check_byteslike("key_material", key_material)
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        return backend.derive_scrypt(
+            key_material, self._salt, self._length, self._n, self._r, self._p
+        )
+
+    def verify(self, key_material: bytes, expected_key: bytes) -> None:
+        derived_key = self.derive(key_material)
+        if not constant_time.bytes_eq(derived_key, expected_key):
+            raise InvalidKey("Keys do not match.")
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/x963kdf.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/x963kdf.py
new file mode 100644
index 0000000..aa6bcc1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/x963kdf.py
@@ -0,0 +1,65 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import (
+    AlreadyFinalized,
+    InvalidKey,
+)
+from cryptography.hazmat.primitives import constant_time, hashes
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+
+def _int_to_u32be(n: int) -> bytes:
+    return n.to_bytes(length=4, byteorder="big")
+
+
+class X963KDF(KeyDerivationFunction):
+    def __init__(
+        self,
+        algorithm: hashes.HashAlgorithm,
+        length: int,
+        sharedinfo: typing.Optional[bytes],
+        backend: typing.Any = None,
+    ):
+        max_len = algorithm.digest_size * (2**32 - 1)
+        if length > max_len:
+            raise ValueError(
+                "Cannot derive keys larger than {} bits.".format(max_len)
+            )
+        if sharedinfo is not None:
+            utils._check_bytes("sharedinfo", sharedinfo)
+
+        self._algorithm = algorithm
+        self._length = length
+        self._sharedinfo = sharedinfo
+        self._used = False
+
+    def derive(self, key_material: bytes) -> bytes:
+        if self._used:
+            raise AlreadyFinalized
+        self._used = True
+        utils._check_byteslike("key_material", key_material)
+        output = [b""]
+        outlen = 0
+        counter = 1
+
+        while self._length > outlen:
+            h = hashes.Hash(self._algorithm)
+            h.update(key_material)
+            h.update(_int_to_u32be(counter))
+            if self._sharedinfo is not None:
+                h.update(self._sharedinfo)
+            output.append(h.finalize())
+            outlen += len(output[-1])
+            counter += 1
+
+        return b"".join(output)[: self._length]
+
+    def verify(self, key_material: bytes, expected_key: bytes) -> None:
+        if not constant_time.bytes_eq(self.derive(key_material), expected_key):
+            raise InvalidKey
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/keywrap.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/keywrap.py
new file mode 100644
index 0000000..64771ca
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/keywrap.py
@@ -0,0 +1,176 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import typing
+
+from cryptography.hazmat.primitives.ciphers import Cipher
+from cryptography.hazmat.primitives.ciphers.algorithms import AES
+from cryptography.hazmat.primitives.ciphers.modes import ECB
+from cryptography.hazmat.primitives.constant_time import bytes_eq
+
+
+def _wrap_core(
+    wrapping_key: bytes,
+    a: bytes,
+    r: typing.List[bytes],
+) -> bytes:
+    # RFC 3394 Key Wrap - 2.2.1 (index method)
+    encryptor = Cipher(AES(wrapping_key), ECB()).encryptor()
+    n = len(r)
+    for j in range(6):
+        for i in range(n):
+            # every encryption operation is a discrete 16 byte chunk (because
+            # AES has a 128-bit block size) and since we're using ECB it is
+            # safe to reuse the encryptor for the entire operation
+            b = encryptor.update(a + r[i])
+            a = (
+                int.from_bytes(b[:8], byteorder="big") ^ ((n * j) + i + 1)
+            ).to_bytes(length=8, byteorder="big")
+            r[i] = b[-8:]
+
+    assert encryptor.finalize() == b""
+
+    return a + b"".join(r)
+
+
+def aes_key_wrap(
+    wrapping_key: bytes,
+    key_to_wrap: bytes,
+    backend: typing.Any = None,
+) -> bytes:
+    if len(wrapping_key) not in [16, 24, 32]:
+        raise ValueError("The wrapping key must be a valid AES key length")
+
+    if len(key_to_wrap) < 16:
+        raise ValueError("The key to wrap must be at least 16 bytes")
+
+    if len(key_to_wrap) % 8 != 0:
+        raise ValueError("The key to wrap must be a multiple of 8 bytes")
+
+    a = b"\xa6\xa6\xa6\xa6\xa6\xa6\xa6\xa6"
+    r = [key_to_wrap[i : i + 8] for i in range(0, len(key_to_wrap), 8)]
+    return _wrap_core(wrapping_key, a, r)
+
+
+def _unwrap_core(
+    wrapping_key: bytes,
+    a: bytes,
+    r: typing.List[bytes],
+) -> typing.Tuple[bytes, typing.List[bytes]]:
+    # Implement RFC 3394 Key Unwrap - 2.2.2 (index method)
+    decryptor = Cipher(AES(wrapping_key), ECB()).decryptor()
+    n = len(r)
+    for j in reversed(range(6)):
+        for i in reversed(range(n)):
+            atr = (
+                int.from_bytes(a, byteorder="big") ^ ((n * j) + i + 1)
+            ).to_bytes(length=8, byteorder="big") + r[i]
+            # every decryption operation is a discrete 16 byte chunk so
+            # it is safe to reuse the decryptor for the entire operation
+            b = decryptor.update(atr)
+            a = b[:8]
+            r[i] = b[-8:]
+
+    assert decryptor.finalize() == b""
+    return a, r
+
+
+def aes_key_wrap_with_padding(
+    wrapping_key: bytes,
+    key_to_wrap: bytes,
+    backend: typing.Any = None,
+) -> bytes:
+    if len(wrapping_key) not in [16, 24, 32]:
+        raise ValueError("The wrapping key must be a valid AES key length")
+
+    aiv = b"\xA6\x59\x59\xA6" + len(key_to_wrap).to_bytes(
+        length=4, byteorder="big"
+    )
+    # pad the key to wrap if necessary
+    pad = (8 - (len(key_to_wrap) % 8)) % 8
+    key_to_wrap = key_to_wrap + b"\x00" * pad
+    if len(key_to_wrap) == 8:
+        # RFC 5649 - 4.1 - exactly 8 octets after padding
+        encryptor = Cipher(AES(wrapping_key), ECB()).encryptor()
+        b = encryptor.update(aiv + key_to_wrap)
+        assert encryptor.finalize() == b""
+        return b
+    else:
+        r = [key_to_wrap[i : i + 8] for i in range(0, len(key_to_wrap), 8)]
+        return _wrap_core(wrapping_key, aiv, r)
+
+
+def aes_key_unwrap_with_padding(
+    wrapping_key: bytes,
+    wrapped_key: bytes,
+    backend: typing.Any = None,
+) -> bytes:
+    if len(wrapped_key) < 16:
+        raise InvalidUnwrap("Must be at least 16 bytes")
+
+    if len(wrapping_key) not in [16, 24, 32]:
+        raise ValueError("The wrapping key must be a valid AES key length")
+
+    if len(wrapped_key) == 16:
+        # RFC 5649 - 4.2 - exactly two 64-bit blocks
+        decryptor = Cipher(AES(wrapping_key), ECB()).decryptor()
+        out = decryptor.update(wrapped_key)
+        assert decryptor.finalize() == b""
+        a = out[:8]
+        data = out[8:]
+        n = 1
+    else:
+        r = [wrapped_key[i : i + 8] for i in range(0, len(wrapped_key), 8)]
+        encrypted_aiv = r.pop(0)
+        n = len(r)
+        a, r = _unwrap_core(wrapping_key, encrypted_aiv, r)
+        data = b"".join(r)
+
+    # 1) Check that MSB(32,A) = A65959A6.
+    # 2) Check that 8*(n-1) < LSB(32,A) <= 8*n.  If so, let
+    #    MLI = LSB(32,A).
+    # 3) Let b = (8*n)-MLI, and then check that the rightmost b octets of
+    #    the output data are zero.
+    mli = int.from_bytes(a[4:], byteorder="big")
+    b = (8 * n) - mli
+    if (
+        not bytes_eq(a[:4], b"\xa6\x59\x59\xa6")
+        or not 8 * (n - 1) < mli <= 8 * n
+        or (b != 0 and not bytes_eq(data[-b:], b"\x00" * b))
+    ):
+        raise InvalidUnwrap()
+
+    if b == 0:
+        return data
+    else:
+        return data[:-b]
+
+
+def aes_key_unwrap(
+    wrapping_key: bytes,
+    wrapped_key: bytes,
+    backend: typing.Any = None,
+) -> bytes:
+    if len(wrapped_key) < 24:
+        raise InvalidUnwrap("Must be at least 24 bytes")
+
+    if len(wrapped_key) % 8 != 0:
+        raise InvalidUnwrap("The wrapped key must be a multiple of 8 bytes")
+
+    if len(wrapping_key) not in [16, 24, 32]:
+        raise ValueError("The wrapping key must be a valid AES key length")
+
+    aiv = b"\xa6\xa6\xa6\xa6\xa6\xa6\xa6\xa6"
+    r = [wrapped_key[i : i + 8] for i in range(0, len(wrapped_key), 8)]
+    a = r.pop(0)
+    a, r = _unwrap_core(wrapping_key, a, r)
+    if not bytes_eq(a, aiv):
+        raise InvalidUnwrap()
+
+    return b"".join(r)
+
+
+class InvalidUnwrap(Exception):
+    pass
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/padding.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/padding.py
new file mode 100644
index 0000000..d6c1d91
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/padding.py
@@ -0,0 +1,224 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import AlreadyFinalized
+from cryptography.hazmat.bindings._rust import (
+    check_ansix923_padding,
+    check_pkcs7_padding,
+)
+
+
+class PaddingContext(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def update(self, data: bytes) -> bytes:
+        """
+        Pads the provided bytes and returns any available data as bytes.
+        """
+
+    @abc.abstractmethod
+    def finalize(self) -> bytes:
+        """
+        Finalize the padding, returns bytes.
+        """
+
+
+def _byte_padding_check(block_size: int) -> None:
+    if not (0 <= block_size <= 2040):
+        raise ValueError("block_size must be in range(0, 2041).")
+
+    if block_size % 8 != 0:
+        raise ValueError("block_size must be a multiple of 8.")
+
+
+def _byte_padding_update(
+    buffer_: typing.Optional[bytes], data: bytes, block_size: int
+) -> typing.Tuple[bytes, bytes]:
+    if buffer_ is None:
+        raise AlreadyFinalized("Context was already finalized.")
+
+    utils._check_byteslike("data", data)
+
+    buffer_ += bytes(data)
+
+    finished_blocks = len(buffer_) // (block_size // 8)
+
+    result = buffer_[: finished_blocks * (block_size // 8)]
+    buffer_ = buffer_[finished_blocks * (block_size // 8) :]
+
+    return buffer_, result
+
+
+def _byte_padding_pad(
+    buffer_: typing.Optional[bytes],
+    block_size: int,
+    paddingfn: typing.Callable[[int], bytes],
+) -> bytes:
+    if buffer_ is None:
+        raise AlreadyFinalized("Context was already finalized.")
+
+    pad_size = block_size // 8 - len(buffer_)
+    return buffer_ + paddingfn(pad_size)
+
+
+def _byte_unpadding_update(
+    buffer_: typing.Optional[bytes], data: bytes, block_size: int
+) -> typing.Tuple[bytes, bytes]:
+    if buffer_ is None:
+        raise AlreadyFinalized("Context was already finalized.")
+
+    utils._check_byteslike("data", data)
+
+    buffer_ += bytes(data)
+
+    finished_blocks = max(len(buffer_) // (block_size // 8) - 1, 0)
+
+    result = buffer_[: finished_blocks * (block_size // 8)]
+    buffer_ = buffer_[finished_blocks * (block_size // 8) :]
+
+    return buffer_, result
+
+
+def _byte_unpadding_check(
+    buffer_: typing.Optional[bytes],
+    block_size: int,
+    checkfn: typing.Callable[[bytes], int],
+) -> bytes:
+    if buffer_ is None:
+        raise AlreadyFinalized("Context was already finalized.")
+
+    if len(buffer_) != block_size // 8:
+        raise ValueError("Invalid padding bytes.")
+
+    valid = checkfn(buffer_)
+
+    if not valid:
+        raise ValueError("Invalid padding bytes.")
+
+    pad_size = buffer_[-1]
+    return buffer_[:-pad_size]
+
+
+class PKCS7:
+    def __init__(self, block_size: int):
+        _byte_padding_check(block_size)
+        self.block_size = block_size
+
+    def padder(self) -> PaddingContext:
+        return _PKCS7PaddingContext(self.block_size)
+
+    def unpadder(self) -> PaddingContext:
+        return _PKCS7UnpaddingContext(self.block_size)
+
+
+class _PKCS7PaddingContext(PaddingContext):
+    _buffer: typing.Optional[bytes]
+
+    def __init__(self, block_size: int):
+        self.block_size = block_size
+        # TODO: more copies than necessary, we should use zero-buffer (#193)
+        self._buffer = b""
+
+    def update(self, data: bytes) -> bytes:
+        self._buffer, result = _byte_padding_update(
+            self._buffer, data, self.block_size
+        )
+        return result
+
+    def _padding(self, size: int) -> bytes:
+        return bytes([size]) * size
+
+    def finalize(self) -> bytes:
+        result = _byte_padding_pad(
+            self._buffer, self.block_size, self._padding
+        )
+        self._buffer = None
+        return result
+
+
+class _PKCS7UnpaddingContext(PaddingContext):
+    _buffer: typing.Optional[bytes]
+
+    def __init__(self, block_size: int):
+        self.block_size = block_size
+        # TODO: more copies than necessary, we should use zero-buffer (#193)
+        self._buffer = b""
+
+    def update(self, data: bytes) -> bytes:
+        self._buffer, result = _byte_unpadding_update(
+            self._buffer, data, self.block_size
+        )
+        return result
+
+    def finalize(self) -> bytes:
+        result = _byte_unpadding_check(
+            self._buffer, self.block_size, check_pkcs7_padding
+        )
+        self._buffer = None
+        return result
+
+
+class ANSIX923:
+    def __init__(self, block_size: int):
+        _byte_padding_check(block_size)
+        self.block_size = block_size
+
+    def padder(self) -> PaddingContext:
+        return _ANSIX923PaddingContext(self.block_size)
+
+    def unpadder(self) -> PaddingContext:
+        return _ANSIX923UnpaddingContext(self.block_size)
+
+
+class _ANSIX923PaddingContext(PaddingContext):
+    _buffer: typing.Optional[bytes]
+
+    def __init__(self, block_size: int):
+        self.block_size = block_size
+        # TODO: more copies than necessary, we should use zero-buffer (#193)
+        self._buffer = b""
+
+    def update(self, data: bytes) -> bytes:
+        self._buffer, result = _byte_padding_update(
+            self._buffer, data, self.block_size
+        )
+        return result
+
+    def _padding(self, size: int) -> bytes:
+        return bytes([0]) * (size - 1) + bytes([size])
+
+    def finalize(self) -> bytes:
+        result = _byte_padding_pad(
+            self._buffer, self.block_size, self._padding
+        )
+        self._buffer = None
+        return result
+
+
+class _ANSIX923UnpaddingContext(PaddingContext):
+    _buffer: typing.Optional[bytes]
+
+    def __init__(self, block_size: int):
+        self.block_size = block_size
+        # TODO: more copies than necessary, we should use zero-buffer (#193)
+        self._buffer = b""
+
+    def update(self, data: bytes) -> bytes:
+        self._buffer, result = _byte_unpadding_update(
+            self._buffer, data, self.block_size
+        )
+        return result
+
+    def finalize(self) -> bytes:
+        result = _byte_unpadding_check(
+            self._buffer,
+            self.block_size,
+            check_ansix923_padding,
+        )
+        self._buffer = None
+        return result
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/poly1305.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/poly1305.py
new file mode 100644
index 0000000..7fcf4a5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/poly1305.py
@@ -0,0 +1,60 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography import utils
+from cryptography.exceptions import (
+    AlreadyFinalized,
+    UnsupportedAlgorithm,
+    _Reasons,
+)
+from cryptography.hazmat.backends.openssl.poly1305 import _Poly1305Context
+
+
+class Poly1305:
+    _ctx: typing.Optional[_Poly1305Context]
+
+    def __init__(self, key: bytes):
+        from cryptography.hazmat.backends.openssl.backend import backend
+
+        if not backend.poly1305_supported():
+            raise UnsupportedAlgorithm(
+                "poly1305 is not supported by this version of OpenSSL.",
+                _Reasons.UNSUPPORTED_MAC,
+            )
+        self._ctx = backend.create_poly1305_ctx(key)
+
+    def update(self, data: bytes) -> None:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        utils._check_byteslike("data", data)
+        self._ctx.update(data)
+
+    def finalize(self) -> bytes:
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+        mac = self._ctx.finalize()
+        self._ctx = None
+        return mac
+
+    def verify(self, tag: bytes) -> None:
+        utils._check_bytes("tag", tag)
+        if self._ctx is None:
+            raise AlreadyFinalized("Context was already finalized.")
+
+        ctx, self._ctx = self._ctx, None
+        ctx.verify(tag)
+
+    @classmethod
+    def generate_tag(cls, key: bytes, data: bytes) -> bytes:
+        p = Poly1305(key)
+        p.update(data)
+        return p.finalize()
+
+    @classmethod
+    def verify_tag(cls, key: bytes, data: bytes, tag: bytes) -> None:
+        p = Poly1305(key)
+        p.update(data)
+        p.verify(tag)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/__init__.py
new file mode 100644
index 0000000..1e0174b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/__init__.py
@@ -0,0 +1,45 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+from cryptography.hazmat.primitives._serialization import (
+    BestAvailableEncryption,
+    Encoding,
+    KeySerializationEncryption,
+    NoEncryption,
+    ParameterFormat,
+    PrivateFormat,
+    PublicFormat,
+)
+from cryptography.hazmat.primitives.serialization.base import (
+    load_der_parameters,
+    load_der_private_key,
+    load_der_public_key,
+    load_pem_parameters,
+    load_pem_private_key,
+    load_pem_public_key,
+)
+from cryptography.hazmat.primitives.serialization.ssh import (
+    load_ssh_private_key,
+    load_ssh_public_key,
+)
+
+
+__all__ = [
+    "load_der_parameters",
+    "load_der_private_key",
+    "load_der_public_key",
+    "load_pem_parameters",
+    "load_pem_private_key",
+    "load_pem_public_key",
+    "load_ssh_private_key",
+    "load_ssh_public_key",
+    "Encoding",
+    "PrivateFormat",
+    "PublicFormat",
+    "ParameterFormat",
+    "KeySerializationEncryption",
+    "BestAvailableEncryption",
+    "NoEncryption",
+]
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/base.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/base.py
new file mode 100644
index 0000000..059b6e4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/base.py
@@ -0,0 +1,64 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import typing
+
+from cryptography.hazmat.primitives.asymmetric import dh
+from cryptography.hazmat.primitives.asymmetric.types import (
+    PRIVATE_KEY_TYPES,
+    PUBLIC_KEY_TYPES,
+)
+
+
+def load_pem_private_key(
+    data: bytes,
+    password: typing.Optional[bytes],
+    backend: typing.Any = None,
+) -> PRIVATE_KEY_TYPES:
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.load_pem_private_key(data, password)
+
+
+def load_pem_public_key(
+    data: bytes, backend: typing.Any = None
+) -> PUBLIC_KEY_TYPES:
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.load_pem_public_key(data)
+
+
+def load_pem_parameters(
+    data: bytes, backend: typing.Any = None
+) -> "dh.DHParameters":
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.load_pem_parameters(data)
+
+
+def load_der_private_key(
+    data: bytes,
+    password: typing.Optional[bytes],
+    backend: typing.Any = None,
+) -> PRIVATE_KEY_TYPES:
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.load_der_private_key(data, password)
+
+
+def load_der_public_key(
+    data: bytes, backend: typing.Any = None
+) -> PUBLIC_KEY_TYPES:
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.load_der_public_key(data)
+
+
+def load_der_parameters(
+    data: bytes, backend: typing.Any = None
+) -> "dh.DHParameters":
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.load_der_parameters(data)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/pkcs12.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/pkcs12.py
new file mode 100644
index 0000000..791befd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/pkcs12.py
@@ -0,0 +1,219 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography import x509
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import (
+    dsa,
+    ec,
+    ed25519,
+    ed448,
+    rsa,
+)
+from cryptography.hazmat.primitives.asymmetric.types import (
+    PRIVATE_KEY_TYPES,
+)
+
+
+_ALLOWED_PKCS12_TYPES = typing.Union[
+    rsa.RSAPrivateKey,
+    dsa.DSAPrivateKey,
+    ec.EllipticCurvePrivateKey,
+    ed25519.Ed25519PrivateKey,
+    ed448.Ed448PrivateKey,
+]
+
+
+class PKCS12Certificate:
+    def __init__(
+        self,
+        cert: x509.Certificate,
+        friendly_name: typing.Optional[bytes],
+    ):
+        if not isinstance(cert, x509.Certificate):
+            raise TypeError("Expecting x509.Certificate object")
+        if friendly_name is not None and not isinstance(friendly_name, bytes):
+            raise TypeError("friendly_name must be bytes or None")
+        self._cert = cert
+        self._friendly_name = friendly_name
+
+    @property
+    def friendly_name(self) -> typing.Optional[bytes]:
+        return self._friendly_name
+
+    @property
+    def certificate(self) -> x509.Certificate:
+        return self._cert
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, PKCS12Certificate):
+            return NotImplemented
+
+        return (
+            self.certificate == other.certificate
+            and self.friendly_name == other.friendly_name
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.certificate, self.friendly_name))
+
+    def __repr__(self) -> str:
+        return "<PKCS12Certificate({}, friendly_name={!r})>".format(
+            self.certificate, self.friendly_name
+        )
+
+
+class PKCS12KeyAndCertificates:
+    def __init__(
+        self,
+        key: typing.Optional[PRIVATE_KEY_TYPES],
+        cert: typing.Optional[PKCS12Certificate],
+        additional_certs: typing.List[PKCS12Certificate],
+    ):
+        if key is not None and not isinstance(
+            key,
+            (
+                rsa.RSAPrivateKey,
+                dsa.DSAPrivateKey,
+                ec.EllipticCurvePrivateKey,
+                ed25519.Ed25519PrivateKey,
+                ed448.Ed448PrivateKey,
+            ),
+        ):
+            raise TypeError(
+                "Key must be RSA, DSA, EllipticCurve, ED25519, or ED448"
+                " private key, or None."
+            )
+        if cert is not None and not isinstance(cert, PKCS12Certificate):
+            raise TypeError("cert must be a PKCS12Certificate object or None")
+        if not all(
+            isinstance(add_cert, PKCS12Certificate)
+            for add_cert in additional_certs
+        ):
+            raise TypeError(
+                "all values in additional_certs must be PKCS12Certificate"
+                " objects"
+            )
+        self._key = key
+        self._cert = cert
+        self._additional_certs = additional_certs
+
+    @property
+    def key(self) -> typing.Optional[PRIVATE_KEY_TYPES]:
+        return self._key
+
+    @property
+    def cert(self) -> typing.Optional[PKCS12Certificate]:
+        return self._cert
+
+    @property
+    def additional_certs(self) -> typing.List[PKCS12Certificate]:
+        return self._additional_certs
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, PKCS12KeyAndCertificates):
+            return NotImplemented
+
+        return (
+            self.key == other.key
+            and self.cert == other.cert
+            and self.additional_certs == other.additional_certs
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.key, self.cert, tuple(self.additional_certs)))
+
+    def __repr__(self) -> str:
+        fmt = (
+            "<PKCS12KeyAndCertificates(key={}, cert={}, additional_certs={})>"
+        )
+        return fmt.format(self.key, self.cert, self.additional_certs)
+
+
+def load_key_and_certificates(
+    data: bytes,
+    password: typing.Optional[bytes],
+    backend: typing.Any = None,
+) -> typing.Tuple[
+    typing.Optional[PRIVATE_KEY_TYPES],
+    typing.Optional[x509.Certificate],
+    typing.List[x509.Certificate],
+]:
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.load_key_and_certificates_from_pkcs12(data, password)
+
+
+def load_pkcs12(
+    data: bytes,
+    password: typing.Optional[bytes],
+    backend: typing.Any = None,
+) -> PKCS12KeyAndCertificates:
+    from cryptography.hazmat.backends.openssl.backend import backend as ossl
+
+    return ossl.load_pkcs12(data, password)
+
+
+_PKCS12_CAS_TYPES = typing.Union[
+    x509.Certificate,
+    PKCS12Certificate,
+]
+
+
+def serialize_key_and_certificates(
+    name: typing.Optional[bytes],
+    key: typing.Optional[_ALLOWED_PKCS12_TYPES],
+    cert: typing.Optional[x509.Certificate],
+    cas: typing.Optional[typing.Iterable[_PKCS12_CAS_TYPES]],
+    encryption_algorithm: serialization.KeySerializationEncryption,
+) -> bytes:
+    if key is not None and not isinstance(
+        key,
+        (
+            rsa.RSAPrivateKey,
+            dsa.DSAPrivateKey,
+            ec.EllipticCurvePrivateKey,
+            ed25519.Ed25519PrivateKey,
+            ed448.Ed448PrivateKey,
+        ),
+    ):
+        raise TypeError(
+            "Key must be RSA, DSA, EllipticCurve, ED25519, or ED448"
+            " private key, or None."
+        )
+    if cert is not None and not isinstance(cert, x509.Certificate):
+        raise TypeError("cert must be a certificate or None")
+
+    if cas is not None:
+        cas = list(cas)
+        if not all(
+            isinstance(
+                val,
+                (
+                    x509.Certificate,
+                    PKCS12Certificate,
+                ),
+            )
+            for val in cas
+        ):
+            raise TypeError("all values in cas must be certificates")
+
+    if not isinstance(
+        encryption_algorithm, serialization.KeySerializationEncryption
+    ):
+        raise TypeError(
+            "Key encryption algorithm must be a "
+            "KeySerializationEncryption instance"
+        )
+
+    if key is None and cert is None and not cas:
+        raise ValueError("You must supply at least one of key, cert, or cas")
+
+    from cryptography.hazmat.backends.openssl.backend import backend
+
+    return backend.serialize_key_and_certificates_to_pkcs12(
+        name, key, cert, cas, encryption_algorithm
+    )
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/pkcs7.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/pkcs7.py
new file mode 100644
index 0000000..6641416
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/pkcs7.py
@@ -0,0 +1,180 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography import utils
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import ec, rsa
+from cryptography.utils import _check_byteslike
+
+
+def load_pem_pkcs7_certificates(data: bytes) -> typing.List[x509.Certificate]:
+    from cryptography.hazmat.backends.openssl.backend import backend
+
+    return backend.load_pem_pkcs7_certificates(data)
+
+
+def load_der_pkcs7_certificates(data: bytes) -> typing.List[x509.Certificate]:
+    from cryptography.hazmat.backends.openssl.backend import backend
+
+    return backend.load_der_pkcs7_certificates(data)
+
+
+def serialize_certificates(
+    certs: typing.List[x509.Certificate],
+    encoding: serialization.Encoding,
+) -> bytes:
+    from cryptography.hazmat.backends.openssl.backend import backend
+
+    return backend.pkcs7_serialize_certificates(certs, encoding)
+
+
+_ALLOWED_PKCS7_HASH_TYPES = typing.Union[
+    hashes.SHA1,
+    hashes.SHA224,
+    hashes.SHA256,
+    hashes.SHA384,
+    hashes.SHA512,
+]
+
+_ALLOWED_PRIVATE_KEY_TYPES = typing.Union[
+    rsa.RSAPrivateKey, ec.EllipticCurvePrivateKey
+]
+
+
+class PKCS7Options(utils.Enum):
+    Text = "Add text/plain MIME type"
+    Binary = "Don't translate input data into canonical MIME format"
+    DetachedSignature = "Don't embed data in the PKCS7 structure"
+    NoCapabilities = "Don't embed SMIME capabilities"
+    NoAttributes = "Don't embed authenticatedAttributes"
+    NoCerts = "Don't embed signer certificate"
+
+
+class PKCS7SignatureBuilder:
+    def __init__(
+        self,
+        data: typing.Optional[bytes] = None,
+        signers: typing.List[
+            typing.Tuple[
+                x509.Certificate,
+                _ALLOWED_PRIVATE_KEY_TYPES,
+                _ALLOWED_PKCS7_HASH_TYPES,
+            ]
+        ] = [],
+        additional_certs: typing.List[x509.Certificate] = [],
+    ):
+        self._data = data
+        self._signers = signers
+        self._additional_certs = additional_certs
+
+    def set_data(self, data: bytes) -> "PKCS7SignatureBuilder":
+        _check_byteslike("data", data)
+        if self._data is not None:
+            raise ValueError("data may only be set once")
+
+        return PKCS7SignatureBuilder(data, self._signers)
+
+    def add_signer(
+        self,
+        certificate: x509.Certificate,
+        private_key: _ALLOWED_PRIVATE_KEY_TYPES,
+        hash_algorithm: _ALLOWED_PKCS7_HASH_TYPES,
+    ) -> "PKCS7SignatureBuilder":
+        if not isinstance(
+            hash_algorithm,
+            (
+                hashes.SHA1,
+                hashes.SHA224,
+                hashes.SHA256,
+                hashes.SHA384,
+                hashes.SHA512,
+            ),
+        ):
+            raise TypeError(
+                "hash_algorithm must be one of hashes.SHA1, SHA224, "
+                "SHA256, SHA384, or SHA512"
+            )
+        if not isinstance(certificate, x509.Certificate):
+            raise TypeError("certificate must be a x509.Certificate")
+
+        if not isinstance(
+            private_key, (rsa.RSAPrivateKey, ec.EllipticCurvePrivateKey)
+        ):
+            raise TypeError("Only RSA & EC keys are supported at this time.")
+
+        return PKCS7SignatureBuilder(
+            self._data,
+            self._signers + [(certificate, private_key, hash_algorithm)],
+        )
+
+    def add_certificate(
+        self, certificate: x509.Certificate
+    ) -> "PKCS7SignatureBuilder":
+        if not isinstance(certificate, x509.Certificate):
+            raise TypeError("certificate must be a x509.Certificate")
+
+        return PKCS7SignatureBuilder(
+            self._data, self._signers, self._additional_certs + [certificate]
+        )
+
+    def sign(
+        self,
+        encoding: serialization.Encoding,
+        options: typing.Iterable[PKCS7Options],
+        backend: typing.Any = None,
+    ) -> bytes:
+        if len(self._signers) == 0:
+            raise ValueError("Must have at least one signer")
+        if self._data is None:
+            raise ValueError("You must add data to sign")
+        options = list(options)
+        if not all(isinstance(x, PKCS7Options) for x in options):
+            raise ValueError("options must be from the PKCS7Options enum")
+        if encoding not in (
+            serialization.Encoding.PEM,
+            serialization.Encoding.DER,
+            serialization.Encoding.SMIME,
+        ):
+            raise ValueError(
+                "Must be PEM, DER, or SMIME from the Encoding enum"
+            )
+
+        # Text is a meaningless option unless it is accompanied by
+        # DetachedSignature
+        if (
+            PKCS7Options.Text in options
+            and PKCS7Options.DetachedSignature not in options
+        ):
+            raise ValueError(
+                "When passing the Text option you must also pass "
+                "DetachedSignature"
+            )
+
+        if PKCS7Options.Text in options and encoding in (
+            serialization.Encoding.DER,
+            serialization.Encoding.PEM,
+        ):
+            raise ValueError(
+                "The Text option is only available for SMIME serialization"
+            )
+
+        # No attributes implies no capabilities so we'll error if you try to
+        # pass both.
+        if (
+            PKCS7Options.NoAttributes in options
+            and PKCS7Options.NoCapabilities in options
+        ):
+            raise ValueError(
+                "NoAttributes is a superset of NoCapabilities. Do not pass "
+                "both values."
+            )
+
+        from cryptography.hazmat.backends.openssl.backend import (
+            backend as ossl,
+        )
+
+        return ossl.pkcs7_sign(self, encoding, options)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/ssh.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/ssh.py
new file mode 100644
index 0000000..6649db5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/serialization/ssh.py
@@ -0,0 +1,757 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import binascii
+import os
+import re
+import typing
+from base64 import encodebytes as _base64_encode
+
+from cryptography import utils
+from cryptography.exceptions import UnsupportedAlgorithm
+from cryptography.hazmat.primitives.asymmetric import dsa, ec, ed25519, rsa
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives.serialization import (
+    Encoding,
+    NoEncryption,
+    PrivateFormat,
+    PublicFormat,
+)
+
+try:
+    from bcrypt import kdf as _bcrypt_kdf
+
+    _bcrypt_supported = True
+except ImportError:
+    _bcrypt_supported = False
+
+    def _bcrypt_kdf(
+        password: bytes,
+        salt: bytes,
+        desired_key_bytes: int,
+        rounds: int,
+        ignore_few_rounds: bool = False,
+    ) -> bytes:
+        raise UnsupportedAlgorithm("Need bcrypt module")
+
+
+_SSH_ED25519 = b"ssh-ed25519"
+_SSH_RSA = b"ssh-rsa"
+_SSH_DSA = b"ssh-dss"
+_ECDSA_NISTP256 = b"ecdsa-sha2-nistp256"
+_ECDSA_NISTP384 = b"ecdsa-sha2-nistp384"
+_ECDSA_NISTP521 = b"ecdsa-sha2-nistp521"
+_CERT_SUFFIX = b"-cert-v01@openssh.com"
+
+_SSH_PUBKEY_RC = re.compile(rb"\A(\S+)[ \t]+(\S+)")
+_SK_MAGIC = b"openssh-key-v1\0"
+_SK_START = b"-----BEGIN OPENSSH PRIVATE KEY-----"
+_SK_END = b"-----END OPENSSH PRIVATE KEY-----"
+_BCRYPT = b"bcrypt"
+_NONE = b"none"
+_DEFAULT_CIPHER = b"aes256-ctr"
+_DEFAULT_ROUNDS = 16
+_MAX_PASSWORD = 72
+
+# re is only way to work on bytes-like data
+_PEM_RC = re.compile(_SK_START + b"(.*?)" + _SK_END, re.DOTALL)
+
+# padding for max blocksize
+_PADDING = memoryview(bytearray(range(1, 1 + 16)))
+
+# ciphers that are actually used in key wrapping
+_SSH_CIPHERS: typing.Dict[
+    bytes,
+    typing.Tuple[
+        typing.Type[algorithms.AES],
+        int,
+        typing.Union[typing.Type[modes.CTR], typing.Type[modes.CBC]],
+        int,
+    ],
+] = {
+    b"aes256-ctr": (algorithms.AES, 32, modes.CTR, 16),
+    b"aes256-cbc": (algorithms.AES, 32, modes.CBC, 16),
+}
+
+# map local curve name to key type
+_ECDSA_KEY_TYPE = {
+    "secp256r1": _ECDSA_NISTP256,
+    "secp384r1": _ECDSA_NISTP384,
+    "secp521r1": _ECDSA_NISTP521,
+}
+
+
+def _ecdsa_key_type(public_key: ec.EllipticCurvePublicKey) -> bytes:
+    """Return SSH key_type and curve_name for private key."""
+    curve = public_key.curve
+    if curve.name not in _ECDSA_KEY_TYPE:
+        raise ValueError(
+            f"Unsupported curve for ssh private key: {curve.name!r}"
+        )
+    return _ECDSA_KEY_TYPE[curve.name]
+
+
+def _ssh_pem_encode(
+    data: bytes,
+    prefix: bytes = _SK_START + b"\n",
+    suffix: bytes = _SK_END + b"\n",
+) -> bytes:
+    return b"".join([prefix, _base64_encode(data), suffix])
+
+
+def _check_block_size(data: bytes, block_len: int) -> None:
+    """Require data to be full blocks"""
+    if not data or len(data) % block_len != 0:
+        raise ValueError("Corrupt data: missing padding")
+
+
+def _check_empty(data: bytes) -> None:
+    """All data should have been parsed."""
+    if data:
+        raise ValueError("Corrupt data: unparsed data")
+
+
+def _init_cipher(
+    ciphername: bytes,
+    password: typing.Optional[bytes],
+    salt: bytes,
+    rounds: int,
+) -> Cipher[typing.Union[modes.CBC, modes.CTR]]:
+    """Generate key + iv and return cipher."""
+    if not password:
+        raise ValueError("Key is password-protected.")
+
+    algo, key_len, mode, iv_len = _SSH_CIPHERS[ciphername]
+    seed = _bcrypt_kdf(password, salt, key_len + iv_len, rounds, True)
+    return Cipher(algo(seed[:key_len]), mode(seed[key_len:]))
+
+
+def _get_u32(data: memoryview) -> typing.Tuple[int, memoryview]:
+    """Uint32"""
+    if len(data) < 4:
+        raise ValueError("Invalid data")
+    return int.from_bytes(data[:4], byteorder="big"), data[4:]
+
+
+def _get_u64(data: memoryview) -> typing.Tuple[int, memoryview]:
+    """Uint64"""
+    if len(data) < 8:
+        raise ValueError("Invalid data")
+    return int.from_bytes(data[:8], byteorder="big"), data[8:]
+
+
+def _get_sshstr(data: memoryview) -> typing.Tuple[memoryview, memoryview]:
+    """Bytes with u32 length prefix"""
+    n, data = _get_u32(data)
+    if n > len(data):
+        raise ValueError("Invalid data")
+    return data[:n], data[n:]
+
+
+def _get_mpint(data: memoryview) -> typing.Tuple[int, memoryview]:
+    """Big integer."""
+    val, data = _get_sshstr(data)
+    if val and val[0] > 0x7F:
+        raise ValueError("Invalid data")
+    return int.from_bytes(val, "big"), data
+
+
+def _to_mpint(val: int) -> bytes:
+    """Storage format for signed bigint."""
+    if val < 0:
+        raise ValueError("negative mpint not allowed")
+    if not val:
+        return b""
+    nbytes = (val.bit_length() + 8) // 8
+    return utils.int_to_bytes(val, nbytes)
+
+
+class _FragList:
+    """Build recursive structure without data copy."""
+
+    flist: typing.List[bytes]
+
+    def __init__(self, init: typing.List[bytes] = None) -> None:
+        self.flist = []
+        if init:
+            self.flist.extend(init)
+
+    def put_raw(self, val: bytes) -> None:
+        """Add plain bytes"""
+        self.flist.append(val)
+
+    def put_u32(self, val: int) -> None:
+        """Big-endian uint32"""
+        self.flist.append(val.to_bytes(length=4, byteorder="big"))
+
+    def put_sshstr(self, val: typing.Union[bytes, "_FragList"]) -> None:
+        """Bytes prefixed with u32 length"""
+        if isinstance(val, (bytes, memoryview, bytearray)):
+            self.put_u32(len(val))
+            self.flist.append(val)
+        else:
+            self.put_u32(val.size())
+            self.flist.extend(val.flist)
+
+    def put_mpint(self, val: int) -> None:
+        """Big-endian bigint prefixed with u32 length"""
+        self.put_sshstr(_to_mpint(val))
+
+    def size(self) -> int:
+        """Current number of bytes"""
+        return sum(map(len, self.flist))
+
+    def render(self, dstbuf: memoryview, pos: int = 0) -> int:
+        """Write into bytearray"""
+        for frag in self.flist:
+            flen = len(frag)
+            start, pos = pos, pos + flen
+            dstbuf[start:pos] = frag
+        return pos
+
+    def tobytes(self) -> bytes:
+        """Return as bytes"""
+        buf = memoryview(bytearray(self.size()))
+        self.render(buf)
+        return buf.tobytes()
+
+
+class _SSHFormatRSA:
+    """Format for RSA keys.
+
+    Public:
+        mpint e, n
+    Private:
+        mpint n, e, d, iqmp, p, q
+    """
+
+    def get_public(self, data: memoryview):
+        """RSA public fields"""
+        e, data = _get_mpint(data)
+        n, data = _get_mpint(data)
+        return (e, n), data
+
+    def load_public(
+        self, data: memoryview
+    ) -> typing.Tuple[rsa.RSAPublicKey, memoryview]:
+        """Make RSA public key from data."""
+        (e, n), data = self.get_public(data)
+        public_numbers = rsa.RSAPublicNumbers(e, n)
+        public_key = public_numbers.public_key()
+        return public_key, data
+
+    def load_private(
+        self, data: memoryview, pubfields
+    ) -> typing.Tuple[rsa.RSAPrivateKey, memoryview]:
+        """Make RSA private key from data."""
+        n, data = _get_mpint(data)
+        e, data = _get_mpint(data)
+        d, data = _get_mpint(data)
+        iqmp, data = _get_mpint(data)
+        p, data = _get_mpint(data)
+        q, data = _get_mpint(data)
+
+        if (e, n) != pubfields:
+            raise ValueError("Corrupt data: rsa field mismatch")
+        dmp1 = rsa.rsa_crt_dmp1(d, p)
+        dmq1 = rsa.rsa_crt_dmq1(d, q)
+        public_numbers = rsa.RSAPublicNumbers(e, n)
+        private_numbers = rsa.RSAPrivateNumbers(
+            p, q, d, dmp1, dmq1, iqmp, public_numbers
+        )
+        private_key = private_numbers.private_key()
+        return private_key, data
+
+    def encode_public(
+        self, public_key: rsa.RSAPublicKey, f_pub: _FragList
+    ) -> None:
+        """Write RSA public key"""
+        pubn = public_key.public_numbers()
+        f_pub.put_mpint(pubn.e)
+        f_pub.put_mpint(pubn.n)
+
+    def encode_private(
+        self, private_key: rsa.RSAPrivateKey, f_priv: _FragList
+    ) -> None:
+        """Write RSA private key"""
+        private_numbers = private_key.private_numbers()
+        public_numbers = private_numbers.public_numbers
+
+        f_priv.put_mpint(public_numbers.n)
+        f_priv.put_mpint(public_numbers.e)
+
+        f_priv.put_mpint(private_numbers.d)
+        f_priv.put_mpint(private_numbers.iqmp)
+        f_priv.put_mpint(private_numbers.p)
+        f_priv.put_mpint(private_numbers.q)
+
+
+class _SSHFormatDSA:
+    """Format for DSA keys.
+
+    Public:
+        mpint p, q, g, y
+    Private:
+        mpint p, q, g, y, x
+    """
+
+    def get_public(
+        self, data: memoryview
+    ) -> typing.Tuple[typing.Tuple, memoryview]:
+        """DSA public fields"""
+        p, data = _get_mpint(data)
+        q, data = _get_mpint(data)
+        g, data = _get_mpint(data)
+        y, data = _get_mpint(data)
+        return (p, q, g, y), data
+
+    def load_public(
+        self, data: memoryview
+    ) -> typing.Tuple[dsa.DSAPublicKey, memoryview]:
+        """Make DSA public key from data."""
+        (p, q, g, y), data = self.get_public(data)
+        parameter_numbers = dsa.DSAParameterNumbers(p, q, g)
+        public_numbers = dsa.DSAPublicNumbers(y, parameter_numbers)
+        self._validate(public_numbers)
+        public_key = public_numbers.public_key()
+        return public_key, data
+
+    def load_private(
+        self, data: memoryview, pubfields
+    ) -> typing.Tuple[dsa.DSAPrivateKey, memoryview]:
+        """Make DSA private key from data."""
+        (p, q, g, y), data = self.get_public(data)
+        x, data = _get_mpint(data)
+
+        if (p, q, g, y) != pubfields:
+            raise ValueError("Corrupt data: dsa field mismatch")
+        parameter_numbers = dsa.DSAParameterNumbers(p, q, g)
+        public_numbers = dsa.DSAPublicNumbers(y, parameter_numbers)
+        self._validate(public_numbers)
+        private_numbers = dsa.DSAPrivateNumbers(x, public_numbers)
+        private_key = private_numbers.private_key()
+        return private_key, data
+
+    def encode_public(
+        self, public_key: dsa.DSAPublicKey, f_pub: _FragList
+    ) -> None:
+        """Write DSA public key"""
+        public_numbers = public_key.public_numbers()
+        parameter_numbers = public_numbers.parameter_numbers
+        self._validate(public_numbers)
+
+        f_pub.put_mpint(parameter_numbers.p)
+        f_pub.put_mpint(parameter_numbers.q)
+        f_pub.put_mpint(parameter_numbers.g)
+        f_pub.put_mpint(public_numbers.y)
+
+    def encode_private(
+        self, private_key: dsa.DSAPrivateKey, f_priv: _FragList
+    ) -> None:
+        """Write DSA private key"""
+        self.encode_public(private_key.public_key(), f_priv)
+        f_priv.put_mpint(private_key.private_numbers().x)
+
+    def _validate(self, public_numbers: dsa.DSAPublicNumbers) -> None:
+        parameter_numbers = public_numbers.parameter_numbers
+        if parameter_numbers.p.bit_length() != 1024:
+            raise ValueError("SSH supports only 1024 bit DSA keys")
+
+
+class _SSHFormatECDSA:
+    """Format for ECDSA keys.
+
+    Public:
+        str curve
+        bytes point
+    Private:
+        str curve
+        bytes point
+        mpint secret
+    """
+
+    def __init__(self, ssh_curve_name: bytes, curve: ec.EllipticCurve):
+        self.ssh_curve_name = ssh_curve_name
+        self.curve = curve
+
+    def get_public(
+        self, data: memoryview
+    ) -> typing.Tuple[typing.Tuple, memoryview]:
+        """ECDSA public fields"""
+        curve, data = _get_sshstr(data)
+        point, data = _get_sshstr(data)
+        if curve != self.ssh_curve_name:
+            raise ValueError("Curve name mismatch")
+        if point[0] != 4:
+            raise NotImplementedError("Need uncompressed point")
+        return (curve, point), data
+
+    def load_public(
+        self, data: memoryview
+    ) -> typing.Tuple[ec.EllipticCurvePublicKey, memoryview]:
+        """Make ECDSA public key from data."""
+        (curve_name, point), data = self.get_public(data)
+        public_key = ec.EllipticCurvePublicKey.from_encoded_point(
+            self.curve, point.tobytes()
+        )
+        return public_key, data
+
+    def load_private(
+        self, data: memoryview, pubfields
+    ) -> typing.Tuple[ec.EllipticCurvePrivateKey, memoryview]:
+        """Make ECDSA private key from data."""
+        (curve_name, point), data = self.get_public(data)
+        secret, data = _get_mpint(data)
+
+        if (curve_name, point) != pubfields:
+            raise ValueError("Corrupt data: ecdsa field mismatch")
+        private_key = ec.derive_private_key(secret, self.curve)
+        return private_key, data
+
+    def encode_public(
+        self, public_key: ec.EllipticCurvePublicKey, f_pub: _FragList
+    ) -> None:
+        """Write ECDSA public key"""
+        point = public_key.public_bytes(
+            Encoding.X962, PublicFormat.UncompressedPoint
+        )
+        f_pub.put_sshstr(self.ssh_curve_name)
+        f_pub.put_sshstr(point)
+
+    def encode_private(
+        self, private_key: ec.EllipticCurvePrivateKey, f_priv: _FragList
+    ) -> None:
+        """Write ECDSA private key"""
+        public_key = private_key.public_key()
+        private_numbers = private_key.private_numbers()
+
+        self.encode_public(public_key, f_priv)
+        f_priv.put_mpint(private_numbers.private_value)
+
+
+class _SSHFormatEd25519:
+    """Format for Ed25519 keys.
+
+    Public:
+        bytes point
+    Private:
+        bytes point
+        bytes secret_and_point
+    """
+
+    def get_public(
+        self, data: memoryview
+    ) -> typing.Tuple[typing.Tuple, memoryview]:
+        """Ed25519 public fields"""
+        point, data = _get_sshstr(data)
+        return (point,), data
+
+    def load_public(
+        self, data: memoryview
+    ) -> typing.Tuple[ed25519.Ed25519PublicKey, memoryview]:
+        """Make Ed25519 public key from data."""
+        (point,), data = self.get_public(data)
+        public_key = ed25519.Ed25519PublicKey.from_public_bytes(
+            point.tobytes()
+        )
+        return public_key, data
+
+    def load_private(
+        self, data: memoryview, pubfields
+    ) -> typing.Tuple[ed25519.Ed25519PrivateKey, memoryview]:
+        """Make Ed25519 private key from data."""
+        (point,), data = self.get_public(data)
+        keypair, data = _get_sshstr(data)
+
+        secret = keypair[:32]
+        point2 = keypair[32:]
+        if point != point2 or (point,) != pubfields:
+            raise ValueError("Corrupt data: ed25519 field mismatch")
+        private_key = ed25519.Ed25519PrivateKey.from_private_bytes(secret)
+        return private_key, data
+
+    def encode_public(
+        self, public_key: ed25519.Ed25519PublicKey, f_pub: _FragList
+    ) -> None:
+        """Write Ed25519 public key"""
+        raw_public_key = public_key.public_bytes(
+            Encoding.Raw, PublicFormat.Raw
+        )
+        f_pub.put_sshstr(raw_public_key)
+
+    def encode_private(
+        self, private_key: ed25519.Ed25519PrivateKey, f_priv: _FragList
+    ) -> None:
+        """Write Ed25519 private key"""
+        public_key = private_key.public_key()
+        raw_private_key = private_key.private_bytes(
+            Encoding.Raw, PrivateFormat.Raw, NoEncryption()
+        )
+        raw_public_key = public_key.public_bytes(
+            Encoding.Raw, PublicFormat.Raw
+        )
+        f_keypair = _FragList([raw_private_key, raw_public_key])
+
+        self.encode_public(public_key, f_priv)
+        f_priv.put_sshstr(f_keypair)
+
+
+_KEY_FORMATS = {
+    _SSH_RSA: _SSHFormatRSA(),
+    _SSH_DSA: _SSHFormatDSA(),
+    _SSH_ED25519: _SSHFormatEd25519(),
+    _ECDSA_NISTP256: _SSHFormatECDSA(b"nistp256", ec.SECP256R1()),
+    _ECDSA_NISTP384: _SSHFormatECDSA(b"nistp384", ec.SECP384R1()),
+    _ECDSA_NISTP521: _SSHFormatECDSA(b"nistp521", ec.SECP521R1()),
+}
+
+
+def _lookup_kformat(key_type: bytes):
+    """Return valid format or throw error"""
+    if not isinstance(key_type, bytes):
+        key_type = memoryview(key_type).tobytes()
+    if key_type in _KEY_FORMATS:
+        return _KEY_FORMATS[key_type]
+    raise UnsupportedAlgorithm(f"Unsupported key type: {key_type!r}")
+
+
+_SSH_PRIVATE_KEY_TYPES = typing.Union[
+    ec.EllipticCurvePrivateKey,
+    rsa.RSAPrivateKey,
+    dsa.DSAPrivateKey,
+    ed25519.Ed25519PrivateKey,
+]
+
+
+def load_ssh_private_key(
+    data: bytes,
+    password: typing.Optional[bytes],
+    backend: typing.Any = None,
+) -> _SSH_PRIVATE_KEY_TYPES:
+    """Load private key from OpenSSH custom encoding."""
+    utils._check_byteslike("data", data)
+    if password is not None:
+        utils._check_bytes("password", password)
+
+    m = _PEM_RC.search(data)
+    if not m:
+        raise ValueError("Not OpenSSH private key format")
+    p1 = m.start(1)
+    p2 = m.end(1)
+    data = binascii.a2b_base64(memoryview(data)[p1:p2])
+    if not data.startswith(_SK_MAGIC):
+        raise ValueError("Not OpenSSH private key format")
+    data = memoryview(data)[len(_SK_MAGIC) :]
+
+    # parse header
+    ciphername, data = _get_sshstr(data)
+    kdfname, data = _get_sshstr(data)
+    kdfoptions, data = _get_sshstr(data)
+    nkeys, data = _get_u32(data)
+    if nkeys != 1:
+        raise ValueError("Only one key supported")
+
+    # load public key data
+    pubdata, data = _get_sshstr(data)
+    pub_key_type, pubdata = _get_sshstr(pubdata)
+    kformat = _lookup_kformat(pub_key_type)
+    pubfields, pubdata = kformat.get_public(pubdata)
+    _check_empty(pubdata)
+
+    # load secret data
+    edata, data = _get_sshstr(data)
+    _check_empty(data)
+
+    if (ciphername, kdfname) != (_NONE, _NONE):
+        ciphername_bytes = ciphername.tobytes()
+        if ciphername_bytes not in _SSH_CIPHERS:
+            raise UnsupportedAlgorithm(
+                f"Unsupported cipher: {ciphername_bytes!r}"
+            )
+        if kdfname != _BCRYPT:
+            raise UnsupportedAlgorithm(f"Unsupported KDF: {kdfname!r}")
+        blklen = _SSH_CIPHERS[ciphername_bytes][3]
+        _check_block_size(edata, blklen)
+        salt, kbuf = _get_sshstr(kdfoptions)
+        rounds, kbuf = _get_u32(kbuf)
+        _check_empty(kbuf)
+        ciph = _init_cipher(ciphername_bytes, password, salt.tobytes(), rounds)
+        edata = memoryview(ciph.decryptor().update(edata))
+    else:
+        blklen = 8
+        _check_block_size(edata, blklen)
+    ck1, edata = _get_u32(edata)
+    ck2, edata = _get_u32(edata)
+    if ck1 != ck2:
+        raise ValueError("Corrupt data: broken checksum")
+
+    # load per-key struct
+    key_type, edata = _get_sshstr(edata)
+    if key_type != pub_key_type:
+        raise ValueError("Corrupt data: key type mismatch")
+    private_key, edata = kformat.load_private(edata, pubfields)
+    comment, edata = _get_sshstr(edata)
+
+    # yes, SSH does padding check *after* all other parsing is done.
+    # need to follow as it writes zero-byte padding too.
+    if edata != _PADDING[: len(edata)]:
+        raise ValueError("Corrupt data: invalid padding")
+
+    return private_key
+
+
+def serialize_ssh_private_key(
+    private_key: _SSH_PRIVATE_KEY_TYPES,
+    password: typing.Optional[bytes] = None,
+) -> bytes:
+    """Serialize private key with OpenSSH custom encoding."""
+    if password is not None:
+        utils._check_bytes("password", password)
+    if password and len(password) > _MAX_PASSWORD:
+        raise ValueError(
+            "Passwords longer than 72 bytes are not supported by "
+            "OpenSSH private key format"
+        )
+
+    if isinstance(private_key, ec.EllipticCurvePrivateKey):
+        key_type = _ecdsa_key_type(private_key.public_key())
+    elif isinstance(private_key, rsa.RSAPrivateKey):
+        key_type = _SSH_RSA
+    elif isinstance(private_key, dsa.DSAPrivateKey):
+        key_type = _SSH_DSA
+    elif isinstance(private_key, ed25519.Ed25519PrivateKey):
+        key_type = _SSH_ED25519
+    else:
+        raise ValueError("Unsupported key type")
+    kformat = _lookup_kformat(key_type)
+
+    # setup parameters
+    f_kdfoptions = _FragList()
+    if password:
+        ciphername = _DEFAULT_CIPHER
+        blklen = _SSH_CIPHERS[ciphername][3]
+        kdfname = _BCRYPT
+        rounds = _DEFAULT_ROUNDS
+        salt = os.urandom(16)
+        f_kdfoptions.put_sshstr(salt)
+        f_kdfoptions.put_u32(rounds)
+        ciph = _init_cipher(ciphername, password, salt, rounds)
+    else:
+        ciphername = kdfname = _NONE
+        blklen = 8
+        ciph = None
+    nkeys = 1
+    checkval = os.urandom(4)
+    comment = b""
+
+    # encode public and private parts together
+    f_public_key = _FragList()
+    f_public_key.put_sshstr(key_type)
+    kformat.encode_public(private_key.public_key(), f_public_key)
+
+    f_secrets = _FragList([checkval, checkval])
+    f_secrets.put_sshstr(key_type)
+    kformat.encode_private(private_key, f_secrets)
+    f_secrets.put_sshstr(comment)
+    f_secrets.put_raw(_PADDING[: blklen - (f_secrets.size() % blklen)])
+
+    # top-level structure
+    f_main = _FragList()
+    f_main.put_raw(_SK_MAGIC)
+    f_main.put_sshstr(ciphername)
+    f_main.put_sshstr(kdfname)
+    f_main.put_sshstr(f_kdfoptions)
+    f_main.put_u32(nkeys)
+    f_main.put_sshstr(f_public_key)
+    f_main.put_sshstr(f_secrets)
+
+    # copy result info bytearray
+    slen = f_secrets.size()
+    mlen = f_main.size()
+    buf = memoryview(bytearray(mlen + blklen))
+    f_main.render(buf)
+    ofs = mlen - slen
+
+    # encrypt in-place
+    if ciph is not None:
+        ciph.encryptor().update_into(buf[ofs:mlen], buf[ofs:])
+
+    txt = _ssh_pem_encode(buf[:mlen])
+    buf[ofs:mlen] = bytearray(slen)
+    return txt
+
+
+_SSH_PUBLIC_KEY_TYPES = typing.Union[
+    ec.EllipticCurvePublicKey,
+    rsa.RSAPublicKey,
+    dsa.DSAPublicKey,
+    ed25519.Ed25519PublicKey,
+]
+
+
+def load_ssh_public_key(
+    data: bytes, backend: typing.Any = None
+) -> _SSH_PUBLIC_KEY_TYPES:
+    """Load public key from OpenSSH one-line format."""
+    utils._check_byteslike("data", data)
+
+    m = _SSH_PUBKEY_RC.match(data)
+    if not m:
+        raise ValueError("Invalid line format")
+    key_type = orig_key_type = m.group(1)
+    key_body = m.group(2)
+    with_cert = False
+    if _CERT_SUFFIX == key_type[-len(_CERT_SUFFIX) :]:
+        with_cert = True
+        key_type = key_type[: -len(_CERT_SUFFIX)]
+    kformat = _lookup_kformat(key_type)
+
+    try:
+        rest = memoryview(binascii.a2b_base64(key_body))
+    except (TypeError, binascii.Error):
+        raise ValueError("Invalid key format")
+
+    inner_key_type, rest = _get_sshstr(rest)
+    if inner_key_type != orig_key_type:
+        raise ValueError("Invalid key format")
+    if with_cert:
+        nonce, rest = _get_sshstr(rest)
+    public_key, rest = kformat.load_public(rest)
+    if with_cert:
+        serial, rest = _get_u64(rest)
+        cctype, rest = _get_u32(rest)
+        key_id, rest = _get_sshstr(rest)
+        principals, rest = _get_sshstr(rest)
+        valid_after, rest = _get_u64(rest)
+        valid_before, rest = _get_u64(rest)
+        crit_options, rest = _get_sshstr(rest)
+        extensions, rest = _get_sshstr(rest)
+        reserved, rest = _get_sshstr(rest)
+        sig_key, rest = _get_sshstr(rest)
+        signature, rest = _get_sshstr(rest)
+    _check_empty(rest)
+    return public_key
+
+
+def serialize_ssh_public_key(public_key: _SSH_PUBLIC_KEY_TYPES) -> bytes:
+    """One-line public key format for OpenSSH"""
+    if isinstance(public_key, ec.EllipticCurvePublicKey):
+        key_type = _ecdsa_key_type(public_key)
+    elif isinstance(public_key, rsa.RSAPublicKey):
+        key_type = _SSH_RSA
+    elif isinstance(public_key, dsa.DSAPublicKey):
+        key_type = _SSH_DSA
+    elif isinstance(public_key, ed25519.Ed25519PublicKey):
+        key_type = _SSH_ED25519
+    else:
+        raise ValueError("Unsupported key type")
+    kformat = _lookup_kformat(key_type)
+
+    f_pub = _FragList()
+    f_pub.put_sshstr(key_type)
+    kformat.encode_public(public_key, f_pub)
+
+    pub = binascii.b2a_base64(f_pub.tobytes()).strip()
+    return b"".join([key_type, b" ", pub])
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/twofactor/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/twofactor/__init__.py
new file mode 100644
index 0000000..8a8b30f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/twofactor/__init__.py
@@ -0,0 +1,7 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+class InvalidToken(Exception):
+    pass
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/twofactor/hotp.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/twofactor/hotp.py
new file mode 100644
index 0000000..9730af2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/twofactor/hotp.py
@@ -0,0 +1,92 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import base64
+import typing
+from urllib.parse import quote, urlencode
+
+from cryptography.hazmat.primitives import constant_time, hmac
+from cryptography.hazmat.primitives.hashes import SHA1, SHA256, SHA512
+from cryptography.hazmat.primitives.twofactor import InvalidToken
+
+
+_ALLOWED_HASH_TYPES = typing.Union[SHA1, SHA256, SHA512]
+
+
+def _generate_uri(
+    hotp: "HOTP",
+    type_name: str,
+    account_name: str,
+    issuer: typing.Optional[str],
+    extra_parameters: typing.List[typing.Tuple[str, int]],
+) -> str:
+    parameters = [
+        ("digits", hotp._length),
+        ("secret", base64.b32encode(hotp._key)),
+        ("algorithm", hotp._algorithm.name.upper()),
+    ]
+
+    if issuer is not None:
+        parameters.append(("issuer", issuer))
+
+    parameters.extend(extra_parameters)
+
+    label = (
+        f"{quote(issuer)}:{quote(account_name)}"
+        if issuer
+        else quote(account_name)
+    )
+    return f"otpauth://{type_name}/{label}?{urlencode(parameters)}"
+
+
+class HOTP:
+    def __init__(
+        self,
+        key: bytes,
+        length: int,
+        algorithm: _ALLOWED_HASH_TYPES,
+        backend: typing.Any = None,
+        enforce_key_length: bool = True,
+    ) -> None:
+        if len(key) < 16 and enforce_key_length is True:
+            raise ValueError("Key length has to be at least 128 bits.")
+
+        if not isinstance(length, int):
+            raise TypeError("Length parameter must be an integer type.")
+
+        if length < 6 or length > 8:
+            raise ValueError("Length of HOTP has to be between 6 to 8.")
+
+        if not isinstance(algorithm, (SHA1, SHA256, SHA512)):
+            raise TypeError("Algorithm must be SHA1, SHA256 or SHA512.")
+
+        self._key = key
+        self._length = length
+        self._algorithm = algorithm
+
+    def generate(self, counter: int) -> bytes:
+        truncated_value = self._dynamic_truncate(counter)
+        hotp = truncated_value % (10**self._length)
+        return "{0:0{1}}".format(hotp, self._length).encode()
+
+    def verify(self, hotp: bytes, counter: int) -> None:
+        if not constant_time.bytes_eq(self.generate(counter), hotp):
+            raise InvalidToken("Supplied HOTP value does not match.")
+
+    def _dynamic_truncate(self, counter: int) -> int:
+        ctx = hmac.HMAC(self._key, self._algorithm)
+        ctx.update(counter.to_bytes(length=8, byteorder="big"))
+        hmac_value = ctx.finalize()
+
+        offset = hmac_value[len(hmac_value) - 1] & 0b1111
+        p = hmac_value[offset : offset + 4]
+        return int.from_bytes(p, byteorder="big") & 0x7FFFFFFF
+
+    def get_provisioning_uri(
+        self, account_name: str, counter: int, issuer: typing.Optional[str]
+    ) -> str:
+        return _generate_uri(
+            self, "hotp", account_name, issuer, [("counter", int(counter))]
+        )
diff --git a/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/twofactor/totp.py b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/twofactor/totp.py
new file mode 100644
index 0000000..317baba
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/hazmat/primitives/twofactor/totp.py
@@ -0,0 +1,48 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives import constant_time
+from cryptography.hazmat.primitives.twofactor import InvalidToken
+from cryptography.hazmat.primitives.twofactor.hotp import (
+    HOTP,
+    _ALLOWED_HASH_TYPES,
+    _generate_uri,
+)
+
+
+class TOTP:
+    def __init__(
+        self,
+        key: bytes,
+        length: int,
+        algorithm: _ALLOWED_HASH_TYPES,
+        time_step: int,
+        backend: typing.Any = None,
+        enforce_key_length: bool = True,
+    ):
+        self._time_step = time_step
+        self._hotp = HOTP(
+            key, length, algorithm, enforce_key_length=enforce_key_length
+        )
+
+    def generate(self, time: typing.Union[int, float]) -> bytes:
+        counter = int(time / self._time_step)
+        return self._hotp.generate(counter)
+
+    def verify(self, totp: bytes, time: int) -> None:
+        if not constant_time.bytes_eq(self.generate(time), totp):
+            raise InvalidToken("Supplied TOTP value does not match.")
+
+    def get_provisioning_uri(
+        self, account_name: str, issuer: typing.Optional[str]
+    ) -> str:
+        return _generate_uri(
+            self._hotp,
+            "totp",
+            account_name,
+            issuer,
+            [("period", int(self._time_step))],
+        )
diff --git a/myenv/lib/python3.9/site-packages/cryptography/py.typed b/myenv/lib/python3.9/site-packages/cryptography/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/cryptography/utils.py b/myenv/lib/python3.9/site-packages/cryptography/utils.py
new file mode 100644
index 0000000..df3abc8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/utils.py
@@ -0,0 +1,180 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import enum
+import inspect
+import sys
+import types
+import typing
+import warnings
+
+
+# We use a UserWarning subclass, instead of DeprecationWarning, because CPython
+# decided deprecation warnings should be invisble by default.
+class CryptographyDeprecationWarning(UserWarning):
+    pass
+
+
+# Several APIs were deprecated with no specific end-of-life date because of the
+# ubiquity of their use. They should not be removed until we agree on when that
+# cycle ends.
+PersistentlyDeprecated2019 = CryptographyDeprecationWarning
+DeprecatedIn35 = CryptographyDeprecationWarning
+DeprecatedIn36 = CryptographyDeprecationWarning
+DeprecatedIn37 = CryptographyDeprecationWarning
+
+
+def _check_bytes(name: str, value: bytes) -> None:
+    if not isinstance(value, bytes):
+        raise TypeError("{} must be bytes".format(name))
+
+
+def _check_byteslike(name: str, value: bytes) -> None:
+    try:
+        memoryview(value)
+    except TypeError:
+        raise TypeError("{} must be bytes-like".format(name))
+
+
+if typing.TYPE_CHECKING:
+    from typing_extensions import Protocol
+
+    _T_class = typing.TypeVar("_T_class", bound=type)
+
+    class _RegisterDecoratorType(Protocol):
+        def __call__(
+            self, klass: _T_class, *, check_annotations: bool = False
+        ) -> _T_class:
+            ...
+
+
+def register_interface(iface: abc.ABCMeta) -> "_RegisterDecoratorType":
+    def register_decorator(
+        klass: "_T_class", *, check_annotations: bool = False
+    ) -> "_T_class":
+        verify_interface(iface, klass, check_annotations=check_annotations)
+        iface.register(klass)
+        return klass
+
+    return register_decorator
+
+
+def int_to_bytes(integer: int, length: typing.Optional[int] = None) -> bytes:
+    return integer.to_bytes(
+        length or (integer.bit_length() + 7) // 8 or 1, "big"
+    )
+
+
+class InterfaceNotImplemented(Exception):
+    pass
+
+
+def strip_annotation(signature: inspect.Signature) -> inspect.Signature:
+    return inspect.Signature(
+        [
+            param.replace(annotation=inspect.Parameter.empty)
+            for param in signature.parameters.values()
+        ]
+    )
+
+
+def verify_interface(
+    iface: abc.ABCMeta, klass: object, *, check_annotations: bool = False
+):
+    for method in iface.__abstractmethods__:
+        if not hasattr(klass, method):
+            raise InterfaceNotImplemented(
+                "{} is missing a {!r} method".format(klass, method)
+            )
+        if isinstance(getattr(iface, method), abc.abstractproperty):
+            # Can't properly verify these yet.
+            continue
+        sig = inspect.signature(getattr(iface, method))
+        actual = inspect.signature(getattr(klass, method))
+        if check_annotations:
+            ok = sig == actual
+        else:
+            ok = strip_annotation(sig) == strip_annotation(actual)
+        if not ok:
+            raise InterfaceNotImplemented(
+                "{}.{}'s signature differs from the expected. Expected: "
+                "{!r}. Received: {!r}".format(klass, method, sig, actual)
+            )
+
+
+class _DeprecatedValue:
+    def __init__(self, value: object, message: str, warning_class):
+        self.value = value
+        self.message = message
+        self.warning_class = warning_class
+
+
+class _ModuleWithDeprecations(types.ModuleType):
+    def __init__(self, module: types.ModuleType):
+        super().__init__(module.__name__)
+        self.__dict__["_module"] = module
+
+    def __getattr__(self, attr: str) -> object:
+        obj = getattr(self._module, attr)
+        if isinstance(obj, _DeprecatedValue):
+            warnings.warn(obj.message, obj.warning_class, stacklevel=2)
+            obj = obj.value
+        return obj
+
+    def __setattr__(self, attr: str, value: object) -> None:
+        setattr(self._module, attr, value)
+
+    def __delattr__(self, attr: str) -> None:
+        obj = getattr(self._module, attr)
+        if isinstance(obj, _DeprecatedValue):
+            warnings.warn(obj.message, obj.warning_class, stacklevel=2)
+
+        delattr(self._module, attr)
+
+    def __dir__(self) -> typing.Sequence[str]:
+        return ["_module"] + dir(self._module)
+
+
+def deprecated(
+    value: object,
+    module_name: str,
+    message: str,
+    warning_class: typing.Type[Warning],
+    name: typing.Optional[str] = None,
+) -> _DeprecatedValue:
+    module = sys.modules[module_name]
+    if not isinstance(module, _ModuleWithDeprecations):
+        sys.modules[module_name] = module = _ModuleWithDeprecations(module)
+    dv = _DeprecatedValue(value, message, warning_class)
+    # Maintain backwards compatibility with `name is None` for pyOpenSSL.
+    if name is not None:
+        setattr(module, name, dv)
+    return dv
+
+
+def cached_property(func: typing.Callable) -> property:
+    cached_name = "_cached_{}".format(func)
+    sentinel = object()
+
+    def inner(instance: object):
+        cache = getattr(instance, cached_name, sentinel)
+        if cache is not sentinel:
+            return cache
+        result = func(instance)
+        setattr(instance, cached_name, result)
+        return result
+
+    return property(inner)
+
+
+# Python 3.10 changed representation of enums. We use well-defined object
+# representation and string representation from Python 3.9.
+class Enum(enum.Enum):
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}.{self._name_}: {self._value_!r}>"
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}.{self._name_}"
diff --git a/myenv/lib/python3.9/site-packages/cryptography/x509/__init__.py b/myenv/lib/python3.9/site-packages/cryptography/x509/__init__.py
new file mode 100644
index 0000000..906075d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/x509/__init__.py
@@ -0,0 +1,249 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+from cryptography.x509 import certificate_transparency
+from cryptography.x509.base import (
+    Attribute,
+    AttributeNotFound,
+    Attributes,
+    Certificate,
+    CertificateBuilder,
+    CertificateRevocationList,
+    CertificateRevocationListBuilder,
+    CertificateSigningRequest,
+    CertificateSigningRequestBuilder,
+    InvalidVersion,
+    RevokedCertificate,
+    RevokedCertificateBuilder,
+    Version,
+    load_der_x509_certificate,
+    load_der_x509_crl,
+    load_der_x509_csr,
+    load_pem_x509_certificate,
+    load_pem_x509_crl,
+    load_pem_x509_csr,
+    random_serial_number,
+)
+from cryptography.x509.extensions import (
+    AccessDescription,
+    AuthorityInformationAccess,
+    AuthorityKeyIdentifier,
+    BasicConstraints,
+    CRLDistributionPoints,
+    CRLNumber,
+    CRLReason,
+    CertificateIssuer,
+    CertificatePolicies,
+    DeltaCRLIndicator,
+    DistributionPoint,
+    DuplicateExtension,
+    ExtendedKeyUsage,
+    Extension,
+    ExtensionNotFound,
+    ExtensionType,
+    Extensions,
+    FreshestCRL,
+    GeneralNames,
+    InhibitAnyPolicy,
+    InvalidityDate,
+    IssuerAlternativeName,
+    IssuingDistributionPoint,
+    KeyUsage,
+    NameConstraints,
+    NoticeReference,
+    OCSPNoCheck,
+    OCSPNonce,
+    PolicyConstraints,
+    PolicyInformation,
+    PrecertPoison,
+    PrecertificateSignedCertificateTimestamps,
+    ReasonFlags,
+    SignedCertificateTimestamps,
+    SubjectAlternativeName,
+    SubjectInformationAccess,
+    SubjectKeyIdentifier,
+    TLSFeature,
+    TLSFeatureType,
+    UnrecognizedExtension,
+    UserNotice,
+)
+from cryptography.x509.general_name import (
+    DNSName,
+    DirectoryName,
+    GeneralName,
+    IPAddress,
+    OtherName,
+    RFC822Name,
+    RegisteredID,
+    UniformResourceIdentifier,
+    UnsupportedGeneralNameType,
+)
+from cryptography.x509.name import (
+    Name,
+    NameAttribute,
+    RelativeDistinguishedName,
+)
+from cryptography.x509.oid import (
+    AuthorityInformationAccessOID,
+    CRLEntryExtensionOID,
+    CertificatePoliciesOID,
+    ExtendedKeyUsageOID,
+    ExtensionOID,
+    NameOID,
+    ObjectIdentifier,
+    SignatureAlgorithmOID,
+)
+
+
+OID_AUTHORITY_INFORMATION_ACCESS = ExtensionOID.AUTHORITY_INFORMATION_ACCESS
+OID_AUTHORITY_KEY_IDENTIFIER = ExtensionOID.AUTHORITY_KEY_IDENTIFIER
+OID_BASIC_CONSTRAINTS = ExtensionOID.BASIC_CONSTRAINTS
+OID_CERTIFICATE_POLICIES = ExtensionOID.CERTIFICATE_POLICIES
+OID_CRL_DISTRIBUTION_POINTS = ExtensionOID.CRL_DISTRIBUTION_POINTS
+OID_EXTENDED_KEY_USAGE = ExtensionOID.EXTENDED_KEY_USAGE
+OID_FRESHEST_CRL = ExtensionOID.FRESHEST_CRL
+OID_INHIBIT_ANY_POLICY = ExtensionOID.INHIBIT_ANY_POLICY
+OID_ISSUER_ALTERNATIVE_NAME = ExtensionOID.ISSUER_ALTERNATIVE_NAME
+OID_KEY_USAGE = ExtensionOID.KEY_USAGE
+OID_NAME_CONSTRAINTS = ExtensionOID.NAME_CONSTRAINTS
+OID_OCSP_NO_CHECK = ExtensionOID.OCSP_NO_CHECK
+OID_POLICY_CONSTRAINTS = ExtensionOID.POLICY_CONSTRAINTS
+OID_POLICY_MAPPINGS = ExtensionOID.POLICY_MAPPINGS
+OID_SUBJECT_ALTERNATIVE_NAME = ExtensionOID.SUBJECT_ALTERNATIVE_NAME
+OID_SUBJECT_DIRECTORY_ATTRIBUTES = ExtensionOID.SUBJECT_DIRECTORY_ATTRIBUTES
+OID_SUBJECT_INFORMATION_ACCESS = ExtensionOID.SUBJECT_INFORMATION_ACCESS
+OID_SUBJECT_KEY_IDENTIFIER = ExtensionOID.SUBJECT_KEY_IDENTIFIER
+
+OID_DSA_WITH_SHA1 = SignatureAlgorithmOID.DSA_WITH_SHA1
+OID_DSA_WITH_SHA224 = SignatureAlgorithmOID.DSA_WITH_SHA224
+OID_DSA_WITH_SHA256 = SignatureAlgorithmOID.DSA_WITH_SHA256
+OID_ECDSA_WITH_SHA1 = SignatureAlgorithmOID.ECDSA_WITH_SHA1
+OID_ECDSA_WITH_SHA224 = SignatureAlgorithmOID.ECDSA_WITH_SHA224
+OID_ECDSA_WITH_SHA256 = SignatureAlgorithmOID.ECDSA_WITH_SHA256
+OID_ECDSA_WITH_SHA384 = SignatureAlgorithmOID.ECDSA_WITH_SHA384
+OID_ECDSA_WITH_SHA512 = SignatureAlgorithmOID.ECDSA_WITH_SHA512
+OID_RSA_WITH_MD5 = SignatureAlgorithmOID.RSA_WITH_MD5
+OID_RSA_WITH_SHA1 = SignatureAlgorithmOID.RSA_WITH_SHA1
+OID_RSA_WITH_SHA224 = SignatureAlgorithmOID.RSA_WITH_SHA224
+OID_RSA_WITH_SHA256 = SignatureAlgorithmOID.RSA_WITH_SHA256
+OID_RSA_WITH_SHA384 = SignatureAlgorithmOID.RSA_WITH_SHA384
+OID_RSA_WITH_SHA512 = SignatureAlgorithmOID.RSA_WITH_SHA512
+OID_RSASSA_PSS = SignatureAlgorithmOID.RSASSA_PSS
+
+OID_COMMON_NAME = NameOID.COMMON_NAME
+OID_COUNTRY_NAME = NameOID.COUNTRY_NAME
+OID_DOMAIN_COMPONENT = NameOID.DOMAIN_COMPONENT
+OID_DN_QUALIFIER = NameOID.DN_QUALIFIER
+OID_EMAIL_ADDRESS = NameOID.EMAIL_ADDRESS
+OID_GENERATION_QUALIFIER = NameOID.GENERATION_QUALIFIER
+OID_GIVEN_NAME = NameOID.GIVEN_NAME
+OID_LOCALITY_NAME = NameOID.LOCALITY_NAME
+OID_ORGANIZATIONAL_UNIT_NAME = NameOID.ORGANIZATIONAL_UNIT_NAME
+OID_ORGANIZATION_NAME = NameOID.ORGANIZATION_NAME
+OID_PSEUDONYM = NameOID.PSEUDONYM
+OID_SERIAL_NUMBER = NameOID.SERIAL_NUMBER
+OID_STATE_OR_PROVINCE_NAME = NameOID.STATE_OR_PROVINCE_NAME
+OID_SURNAME = NameOID.SURNAME
+OID_TITLE = NameOID.TITLE
+
+OID_CLIENT_AUTH = ExtendedKeyUsageOID.CLIENT_AUTH
+OID_CODE_SIGNING = ExtendedKeyUsageOID.CODE_SIGNING
+OID_EMAIL_PROTECTION = ExtendedKeyUsageOID.EMAIL_PROTECTION
+OID_OCSP_SIGNING = ExtendedKeyUsageOID.OCSP_SIGNING
+OID_SERVER_AUTH = ExtendedKeyUsageOID.SERVER_AUTH
+OID_TIME_STAMPING = ExtendedKeyUsageOID.TIME_STAMPING
+
+OID_ANY_POLICY = CertificatePoliciesOID.ANY_POLICY
+OID_CPS_QUALIFIER = CertificatePoliciesOID.CPS_QUALIFIER
+OID_CPS_USER_NOTICE = CertificatePoliciesOID.CPS_USER_NOTICE
+
+OID_CERTIFICATE_ISSUER = CRLEntryExtensionOID.CERTIFICATE_ISSUER
+OID_CRL_REASON = CRLEntryExtensionOID.CRL_REASON
+OID_INVALIDITY_DATE = CRLEntryExtensionOID.INVALIDITY_DATE
+
+OID_CA_ISSUERS = AuthorityInformationAccessOID.CA_ISSUERS
+OID_OCSP = AuthorityInformationAccessOID.OCSP
+
+__all__ = [
+    "certificate_transparency",
+    "load_pem_x509_certificate",
+    "load_der_x509_certificate",
+    "load_pem_x509_csr",
+    "load_der_x509_csr",
+    "load_pem_x509_crl",
+    "load_der_x509_crl",
+    "random_serial_number",
+    "Attribute",
+    "AttributeNotFound",
+    "Attributes",
+    "InvalidVersion",
+    "DeltaCRLIndicator",
+    "DuplicateExtension",
+    "ExtensionNotFound",
+    "UnsupportedGeneralNameType",
+    "NameAttribute",
+    "Name",
+    "RelativeDistinguishedName",
+    "ObjectIdentifier",
+    "ExtensionType",
+    "Extensions",
+    "Extension",
+    "ExtendedKeyUsage",
+    "FreshestCRL",
+    "IssuingDistributionPoint",
+    "TLSFeature",
+    "TLSFeatureType",
+    "OCSPNoCheck",
+    "BasicConstraints",
+    "CRLNumber",
+    "KeyUsage",
+    "AuthorityInformationAccess",
+    "SubjectInformationAccess",
+    "AccessDescription",
+    "CertificatePolicies",
+    "PolicyInformation",
+    "UserNotice",
+    "NoticeReference",
+    "SubjectKeyIdentifier",
+    "NameConstraints",
+    "CRLDistributionPoints",
+    "DistributionPoint",
+    "ReasonFlags",
+    "InhibitAnyPolicy",
+    "SubjectAlternativeName",
+    "IssuerAlternativeName",
+    "AuthorityKeyIdentifier",
+    "GeneralNames",
+    "GeneralName",
+    "RFC822Name",
+    "DNSName",
+    "UniformResourceIdentifier",
+    "RegisteredID",
+    "DirectoryName",
+    "IPAddress",
+    "OtherName",
+    "Certificate",
+    "CertificateRevocationList",
+    "CertificateRevocationListBuilder",
+    "CertificateSigningRequest",
+    "RevokedCertificate",
+    "RevokedCertificateBuilder",
+    "CertificateSigningRequestBuilder",
+    "CertificateBuilder",
+    "Version",
+    "OID_CA_ISSUERS",
+    "OID_OCSP",
+    "CertificateIssuer",
+    "CRLReason",
+    "InvalidityDate",
+    "UnrecognizedExtension",
+    "PolicyConstraints",
+    "PrecertificateSignedCertificateTimestamps",
+    "PrecertPoison",
+    "OCSPNonce",
+    "SignedCertificateTimestamps",
+    "SignatureAlgorithmOID",
+    "NameOID",
+]
diff --git a/myenv/lib/python3.9/site-packages/cryptography/x509/base.py b/myenv/lib/python3.9/site-packages/cryptography/x509/base.py
new file mode 100644
index 0000000..8213682
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/x509/base.py
@@ -0,0 +1,1090 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import datetime
+import os
+import typing
+
+from cryptography import utils
+from cryptography.hazmat.bindings._rust import x509 as rust_x509
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import (
+    dsa,
+    ec,
+    ed25519,
+    ed448,
+    rsa,
+    x25519,
+    x448,
+)
+from cryptography.hazmat.primitives.asymmetric.types import (
+    CERTIFICATE_ISSUER_PUBLIC_KEY_TYPES,
+    CERTIFICATE_PRIVATE_KEY_TYPES,
+    CERTIFICATE_PUBLIC_KEY_TYPES,
+)
+from cryptography.x509.extensions import (
+    Extension,
+    ExtensionType,
+    Extensions,
+    _make_sequence_methods,
+)
+from cryptography.x509.name import Name, _ASN1Type
+from cryptography.x509.oid import ObjectIdentifier
+
+
+_EARLIEST_UTC_TIME = datetime.datetime(1950, 1, 1)
+
+
+class AttributeNotFound(Exception):
+    def __init__(self, msg: str, oid: ObjectIdentifier) -> None:
+        super(AttributeNotFound, self).__init__(msg)
+        self.oid = oid
+
+
+def _reject_duplicate_extension(
+    extension: Extension[ExtensionType],
+    extensions: typing.List[Extension[ExtensionType]],
+) -> None:
+    # This is quadratic in the number of extensions
+    for e in extensions:
+        if e.oid == extension.oid:
+            raise ValueError("This extension has already been set.")
+
+
+def _reject_duplicate_attribute(
+    oid: ObjectIdentifier,
+    attributes: typing.List[
+        typing.Tuple[ObjectIdentifier, bytes, typing.Optional[int]]
+    ],
+) -> None:
+    # This is quadratic in the number of attributes
+    for attr_oid, _, _ in attributes:
+        if attr_oid == oid:
+            raise ValueError("This attribute has already been set.")
+
+
+def _convert_to_naive_utc_time(time: datetime.datetime) -> datetime.datetime:
+    """Normalizes a datetime to a naive datetime in UTC.
+
+    time -- datetime to normalize. Assumed to be in UTC if not timezone
+            aware.
+    """
+    if time.tzinfo is not None:
+        offset = time.utcoffset()
+        offset = offset if offset else datetime.timedelta()
+        return time.replace(tzinfo=None) - offset
+    else:
+        return time
+
+
+class Attribute:
+    def __init__(
+        self,
+        oid: ObjectIdentifier,
+        value: bytes,
+        _type: int = _ASN1Type.UTF8String.value,
+    ) -> None:
+        self._oid = oid
+        self._value = value
+        self._type = _type
+
+    @property
+    def oid(self) -> ObjectIdentifier:
+        return self._oid
+
+    @property
+    def value(self) -> bytes:
+        return self._value
+
+    def __repr__(self) -> str:
+        return "<Attribute(oid={}, value={!r})>".format(self.oid, self.value)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Attribute):
+            return NotImplemented
+
+        return (
+            self.oid == other.oid
+            and self.value == other.value
+            and self._type == other._type
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.oid, self.value, self._type))
+
+
+class Attributes:
+    def __init__(
+        self,
+        attributes: typing.Iterable[Attribute],
+    ) -> None:
+        self._attributes = list(attributes)
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods("_attributes")
+
+    def __repr__(self) -> str:
+        return "<Attributes({})>".format(self._attributes)
+
+    def get_attribute_for_oid(self, oid: ObjectIdentifier) -> Attribute:
+        for attr in self:
+            if attr.oid == oid:
+                return attr
+
+        raise AttributeNotFound("No {} attribute was found".format(oid), oid)
+
+
+class Version(utils.Enum):
+    v1 = 0
+    v3 = 2
+
+
+class InvalidVersion(Exception):
+    def __init__(self, msg: str, parsed_version: int) -> None:
+        super(InvalidVersion, self).__init__(msg)
+        self.parsed_version = parsed_version
+
+
+class Certificate(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def fingerprint(self, algorithm: hashes.HashAlgorithm) -> bytes:
+        """
+        Returns bytes using digest passed.
+        """
+
+    @abc.abstractproperty
+    def serial_number(self) -> int:
+        """
+        Returns certificate serial number
+        """
+
+    @abc.abstractproperty
+    def version(self) -> Version:
+        """
+        Returns the certificate version
+        """
+
+    @abc.abstractmethod
+    def public_key(self) -> CERTIFICATE_PUBLIC_KEY_TYPES:
+        """
+        Returns the public key
+        """
+
+    @abc.abstractproperty
+    def not_valid_before(self) -> datetime.datetime:
+        """
+        Not before time (represented as UTC datetime)
+        """
+
+    @abc.abstractproperty
+    def not_valid_after(self) -> datetime.datetime:
+        """
+        Not after time (represented as UTC datetime)
+        """
+
+    @abc.abstractproperty
+    def issuer(self) -> Name:
+        """
+        Returns the issuer name object.
+        """
+
+    @abc.abstractproperty
+    def subject(self) -> Name:
+        """
+        Returns the subject name object.
+        """
+
+    @abc.abstractproperty
+    def signature_hash_algorithm(
+        self,
+    ) -> typing.Optional[hashes.HashAlgorithm]:
+        """
+        Returns a HashAlgorithm corresponding to the type of the digest signed
+        in the certificate.
+        """
+
+    @abc.abstractproperty
+    def signature_algorithm_oid(self) -> ObjectIdentifier:
+        """
+        Returns the ObjectIdentifier of the signature algorithm.
+        """
+
+    @abc.abstractproperty
+    def extensions(self) -> Extensions:
+        """
+        Returns an Extensions object.
+        """
+
+    @abc.abstractproperty
+    def signature(self) -> bytes:
+        """
+        Returns the signature bytes.
+        """
+
+    @abc.abstractproperty
+    def tbs_certificate_bytes(self) -> bytes:
+        """
+        Returns the tbsCertificate payload bytes as defined in RFC 5280.
+        """
+
+    @abc.abstractmethod
+    def __eq__(self, other: object) -> bool:
+        """
+        Checks equality.
+        """
+
+    @abc.abstractmethod
+    def __hash__(self) -> int:
+        """
+        Computes a hash.
+        """
+
+    @abc.abstractmethod
+    def public_bytes(self, encoding: serialization.Encoding) -> bytes:
+        """
+        Serializes the certificate to PEM or DER format.
+        """
+
+
+# Runtime isinstance checks need this since the rust class is not a subclass.
+Certificate.register(rust_x509.Certificate)
+
+
+class RevokedCertificate(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def serial_number(self) -> int:
+        """
+        Returns the serial number of the revoked certificate.
+        """
+
+    @abc.abstractproperty
+    def revocation_date(self) -> datetime.datetime:
+        """
+        Returns the date of when this certificate was revoked.
+        """
+
+    @abc.abstractproperty
+    def extensions(self) -> Extensions:
+        """
+        Returns an Extensions object containing a list of Revoked extensions.
+        """
+
+
+# Runtime isinstance checks need this since the rust class is not a subclass.
+RevokedCertificate.register(rust_x509.RevokedCertificate)
+
+
+class _RawRevokedCertificate(RevokedCertificate):
+    def __init__(
+        self,
+        serial_number: int,
+        revocation_date: datetime.datetime,
+        extensions: Extensions,
+    ):
+        self._serial_number = serial_number
+        self._revocation_date = revocation_date
+        self._extensions = extensions
+
+    @property
+    def serial_number(self) -> int:
+        return self._serial_number
+
+    @property
+    def revocation_date(self) -> datetime.datetime:
+        return self._revocation_date
+
+    @property
+    def extensions(self) -> Extensions:
+        return self._extensions
+
+
+class CertificateRevocationList(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def public_bytes(self, encoding: serialization.Encoding) -> bytes:
+        """
+        Serializes the CRL to PEM or DER format.
+        """
+
+    @abc.abstractmethod
+    def fingerprint(self, algorithm: hashes.HashAlgorithm) -> bytes:
+        """
+        Returns bytes using digest passed.
+        """
+
+    @abc.abstractmethod
+    def get_revoked_certificate_by_serial_number(
+        self, serial_number: int
+    ) -> typing.Optional[RevokedCertificate]:
+        """
+        Returns an instance of RevokedCertificate or None if the serial_number
+        is not in the CRL.
+        """
+
+    @abc.abstractproperty
+    def signature_hash_algorithm(
+        self,
+    ) -> typing.Optional[hashes.HashAlgorithm]:
+        """
+        Returns a HashAlgorithm corresponding to the type of the digest signed
+        in the certificate.
+        """
+
+    @abc.abstractproperty
+    def signature_algorithm_oid(self) -> ObjectIdentifier:
+        """
+        Returns the ObjectIdentifier of the signature algorithm.
+        """
+
+    @abc.abstractproperty
+    def issuer(self) -> Name:
+        """
+        Returns the X509Name with the issuer of this CRL.
+        """
+
+    @abc.abstractproperty
+    def next_update(self) -> typing.Optional[datetime.datetime]:
+        """
+        Returns the date of next update for this CRL.
+        """
+
+    @abc.abstractproperty
+    def last_update(self) -> datetime.datetime:
+        """
+        Returns the date of last update for this CRL.
+        """
+
+    @abc.abstractproperty
+    def extensions(self) -> Extensions:
+        """
+        Returns an Extensions object containing a list of CRL extensions.
+        """
+
+    @abc.abstractproperty
+    def signature(self) -> bytes:
+        """
+        Returns the signature bytes.
+        """
+
+    @abc.abstractproperty
+    def tbs_certlist_bytes(self) -> bytes:
+        """
+        Returns the tbsCertList payload bytes as defined in RFC 5280.
+        """
+
+    @abc.abstractmethod
+    def __eq__(self, other: object) -> bool:
+        """
+        Checks equality.
+        """
+
+    @abc.abstractmethod
+    def __len__(self) -> int:
+        """
+        Number of revoked certificates in the CRL.
+        """
+
+    @typing.overload
+    def __getitem__(self, idx: int) -> RevokedCertificate:
+        ...
+
+    @typing.overload
+    def __getitem__(self, idx: slice) -> typing.List[RevokedCertificate]:
+        ...
+
+    @abc.abstractmethod
+    def __getitem__(
+        self, idx: typing.Union[int, slice]
+    ) -> typing.Union[RevokedCertificate, typing.List[RevokedCertificate]]:
+        """
+        Returns a revoked certificate (or slice of revoked certificates).
+        """
+
+    @abc.abstractmethod
+    def __iter__(self) -> typing.Iterator[RevokedCertificate]:
+        """
+        Iterator over the revoked certificates
+        """
+
+    @abc.abstractmethod
+    def is_signature_valid(
+        self, public_key: CERTIFICATE_ISSUER_PUBLIC_KEY_TYPES
+    ) -> bool:
+        """
+        Verifies signature of revocation list against given public key.
+        """
+
+
+CertificateRevocationList.register(rust_x509.CertificateRevocationList)
+
+
+class CertificateSigningRequest(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def __eq__(self, other: object) -> bool:
+        """
+        Checks equality.
+        """
+
+    @abc.abstractmethod
+    def __hash__(self) -> int:
+        """
+        Computes a hash.
+        """
+
+    @abc.abstractmethod
+    def public_key(self) -> CERTIFICATE_PUBLIC_KEY_TYPES:
+        """
+        Returns the public key
+        """
+
+    @abc.abstractproperty
+    def subject(self) -> Name:
+        """
+        Returns the subject name object.
+        """
+
+    @abc.abstractproperty
+    def signature_hash_algorithm(
+        self,
+    ) -> typing.Optional[hashes.HashAlgorithm]:
+        """
+        Returns a HashAlgorithm corresponding to the type of the digest signed
+        in the certificate.
+        """
+
+    @abc.abstractproperty
+    def signature_algorithm_oid(self) -> ObjectIdentifier:
+        """
+        Returns the ObjectIdentifier of the signature algorithm.
+        """
+
+    @abc.abstractproperty
+    def extensions(self) -> Extensions:
+        """
+        Returns the extensions in the signing request.
+        """
+
+    @abc.abstractproperty
+    def attributes(self) -> Attributes:
+        """
+        Returns an Attributes object.
+        """
+
+    @abc.abstractmethod
+    def public_bytes(self, encoding: serialization.Encoding) -> bytes:
+        """
+        Encodes the request to PEM or DER format.
+        """
+
+    @abc.abstractproperty
+    def signature(self) -> bytes:
+        """
+        Returns the signature bytes.
+        """
+
+    @abc.abstractproperty
+    def tbs_certrequest_bytes(self) -> bytes:
+        """
+        Returns the PKCS#10 CertificationRequestInfo bytes as defined in RFC
+        2986.
+        """
+
+    @abc.abstractproperty
+    def is_signature_valid(self) -> bool:
+        """
+        Verifies signature of signing request.
+        """
+
+    @abc.abstractmethod
+    def get_attribute_for_oid(self, oid: ObjectIdentifier) -> bytes:
+        """
+        Get the attribute value for a given OID.
+        """
+
+
+# Runtime isinstance checks need this since the rust class is not a subclass.
+CertificateSigningRequest.register(rust_x509.CertificateSigningRequest)
+
+
+# Backend argument preserved for API compatibility, but ignored.
+def load_pem_x509_certificate(
+    data: bytes, backend: typing.Any = None
+) -> Certificate:
+    return rust_x509.load_pem_x509_certificate(data)
+
+
+# Backend argument preserved for API compatibility, but ignored.
+def load_der_x509_certificate(
+    data: bytes, backend: typing.Any = None
+) -> Certificate:
+    return rust_x509.load_der_x509_certificate(data)
+
+
+# Backend argument preserved for API compatibility, but ignored.
+def load_pem_x509_csr(
+    data: bytes, backend: typing.Any = None
+) -> CertificateSigningRequest:
+    return rust_x509.load_pem_x509_csr(data)
+
+
+# Backend argument preserved for API compatibility, but ignored.
+def load_der_x509_csr(
+    data: bytes, backend: typing.Any = None
+) -> CertificateSigningRequest:
+    return rust_x509.load_der_x509_csr(data)
+
+
+# Backend argument preserved for API compatibility, but ignored.
+def load_pem_x509_crl(
+    data: bytes, backend: typing.Any = None
+) -> CertificateRevocationList:
+    return rust_x509.load_pem_x509_crl(data)
+
+
+# Backend argument preserved for API compatibility, but ignored.
+def load_der_x509_crl(
+    data: bytes, backend: typing.Any = None
+) -> CertificateRevocationList:
+    return rust_x509.load_der_x509_crl(data)
+
+
+class CertificateSigningRequestBuilder:
+    def __init__(
+        self,
+        subject_name: typing.Optional[Name] = None,
+        extensions: typing.List[Extension[ExtensionType]] = [],
+        attributes: typing.List[
+            typing.Tuple[ObjectIdentifier, bytes, typing.Optional[int]]
+        ] = [],
+    ):
+        """
+        Creates an empty X.509 certificate request (v1).
+        """
+        self._subject_name = subject_name
+        self._extensions = extensions
+        self._attributes = attributes
+
+    def subject_name(self, name: Name) -> "CertificateSigningRequestBuilder":
+        """
+        Sets the certificate requestor's distinguished name.
+        """
+        if not isinstance(name, Name):
+            raise TypeError("Expecting x509.Name object.")
+        if self._subject_name is not None:
+            raise ValueError("The subject name may only be set once.")
+        return CertificateSigningRequestBuilder(
+            name, self._extensions, self._attributes
+        )
+
+    def add_extension(
+        self, extval: ExtensionType, critical: bool
+    ) -> "CertificateSigningRequestBuilder":
+        """
+        Adds an X.509 extension to the certificate request.
+        """
+        if not isinstance(extval, ExtensionType):
+            raise TypeError("extension must be an ExtensionType")
+
+        extension = Extension(extval.oid, critical, extval)
+        _reject_duplicate_extension(extension, self._extensions)
+
+        return CertificateSigningRequestBuilder(
+            self._subject_name,
+            self._extensions + [extension],
+            self._attributes,
+        )
+
+    def add_attribute(
+        self,
+        oid: ObjectIdentifier,
+        value: bytes,
+        *,
+        _tag: typing.Optional[_ASN1Type] = None,
+    ) -> "CertificateSigningRequestBuilder":
+        """
+        Adds an X.509 attribute with an OID and associated value.
+        """
+        if not isinstance(oid, ObjectIdentifier):
+            raise TypeError("oid must be an ObjectIdentifier")
+
+        if not isinstance(value, bytes):
+            raise TypeError("value must be bytes")
+
+        if _tag is not None and not isinstance(_tag, _ASN1Type):
+            raise TypeError("tag must be _ASN1Type")
+
+        _reject_duplicate_attribute(oid, self._attributes)
+
+        if _tag is not None:
+            tag = _tag.value
+        else:
+            tag = None
+
+        return CertificateSigningRequestBuilder(
+            self._subject_name,
+            self._extensions,
+            self._attributes + [(oid, value, tag)],
+        )
+
+    def sign(
+        self,
+        private_key: CERTIFICATE_PRIVATE_KEY_TYPES,
+        algorithm: typing.Optional[hashes.HashAlgorithm],
+        backend: typing.Any = None,
+    ) -> CertificateSigningRequest:
+        """
+        Signs the request using the requestor's private key.
+        """
+        if self._subject_name is None:
+            raise ValueError("A CertificateSigningRequest must have a subject")
+        return rust_x509.create_x509_csr(self, private_key, algorithm)
+
+
+class CertificateBuilder:
+    _extensions: typing.List[Extension[ExtensionType]]
+
+    def __init__(
+        self,
+        issuer_name: typing.Optional[Name] = None,
+        subject_name: typing.Optional[Name] = None,
+        public_key: typing.Optional[CERTIFICATE_PUBLIC_KEY_TYPES] = None,
+        serial_number: typing.Optional[int] = None,
+        not_valid_before: typing.Optional[datetime.datetime] = None,
+        not_valid_after: typing.Optional[datetime.datetime] = None,
+        extensions: typing.List[Extension[ExtensionType]] = [],
+    ) -> None:
+        self._version = Version.v3
+        self._issuer_name = issuer_name
+        self._subject_name = subject_name
+        self._public_key = public_key
+        self._serial_number = serial_number
+        self._not_valid_before = not_valid_before
+        self._not_valid_after = not_valid_after
+        self._extensions = extensions
+
+    def issuer_name(self, name: Name) -> "CertificateBuilder":
+        """
+        Sets the CA's distinguished name.
+        """
+        if not isinstance(name, Name):
+            raise TypeError("Expecting x509.Name object.")
+        if self._issuer_name is not None:
+            raise ValueError("The issuer name may only be set once.")
+        return CertificateBuilder(
+            name,
+            self._subject_name,
+            self._public_key,
+            self._serial_number,
+            self._not_valid_before,
+            self._not_valid_after,
+            self._extensions,
+        )
+
+    def subject_name(self, name: Name) -> "CertificateBuilder":
+        """
+        Sets the requestor's distinguished name.
+        """
+        if not isinstance(name, Name):
+            raise TypeError("Expecting x509.Name object.")
+        if self._subject_name is not None:
+            raise ValueError("The subject name may only be set once.")
+        return CertificateBuilder(
+            self._issuer_name,
+            name,
+            self._public_key,
+            self._serial_number,
+            self._not_valid_before,
+            self._not_valid_after,
+            self._extensions,
+        )
+
+    def public_key(
+        self,
+        key: CERTIFICATE_PUBLIC_KEY_TYPES,
+    ) -> "CertificateBuilder":
+        """
+        Sets the requestor's public key (as found in the signing request).
+        """
+        if not isinstance(
+            key,
+            (
+                dsa.DSAPublicKey,
+                rsa.RSAPublicKey,
+                ec.EllipticCurvePublicKey,
+                ed25519.Ed25519PublicKey,
+                ed448.Ed448PublicKey,
+                x25519.X25519PublicKey,
+                x448.X448PublicKey,
+            ),
+        ):
+            raise TypeError(
+                "Expecting one of DSAPublicKey, RSAPublicKey,"
+                " EllipticCurvePublicKey, Ed25519PublicKey,"
+                " Ed448PublicKey, X25519PublicKey, or "
+                "X448PublicKey."
+            )
+        if self._public_key is not None:
+            raise ValueError("The public key may only be set once.")
+        return CertificateBuilder(
+            self._issuer_name,
+            self._subject_name,
+            key,
+            self._serial_number,
+            self._not_valid_before,
+            self._not_valid_after,
+            self._extensions,
+        )
+
+    def serial_number(self, number: int) -> "CertificateBuilder":
+        """
+        Sets the certificate serial number.
+        """
+        if not isinstance(number, int):
+            raise TypeError("Serial number must be of integral type.")
+        if self._serial_number is not None:
+            raise ValueError("The serial number may only be set once.")
+        if number <= 0:
+            raise ValueError("The serial number should be positive.")
+
+        # ASN.1 integers are always signed, so most significant bit must be
+        # zero.
+        if number.bit_length() >= 160:  # As defined in RFC 5280
+            raise ValueError(
+                "The serial number should not be more than 159 " "bits."
+            )
+        return CertificateBuilder(
+            self._issuer_name,
+            self._subject_name,
+            self._public_key,
+            number,
+            self._not_valid_before,
+            self._not_valid_after,
+            self._extensions,
+        )
+
+    def not_valid_before(
+        self, time: datetime.datetime
+    ) -> "CertificateBuilder":
+        """
+        Sets the certificate activation time.
+        """
+        if not isinstance(time, datetime.datetime):
+            raise TypeError("Expecting datetime object.")
+        if self._not_valid_before is not None:
+            raise ValueError("The not valid before may only be set once.")
+        time = _convert_to_naive_utc_time(time)
+        if time < _EARLIEST_UTC_TIME:
+            raise ValueError(
+                "The not valid before date must be on or after"
+                " 1950 January 1)."
+            )
+        if self._not_valid_after is not None and time > self._not_valid_after:
+            raise ValueError(
+                "The not valid before date must be before the not valid after "
+                "date."
+            )
+        return CertificateBuilder(
+            self._issuer_name,
+            self._subject_name,
+            self._public_key,
+            self._serial_number,
+            time,
+            self._not_valid_after,
+            self._extensions,
+        )
+
+    def not_valid_after(self, time: datetime.datetime) -> "CertificateBuilder":
+        """
+        Sets the certificate expiration time.
+        """
+        if not isinstance(time, datetime.datetime):
+            raise TypeError("Expecting datetime object.")
+        if self._not_valid_after is not None:
+            raise ValueError("The not valid after may only be set once.")
+        time = _convert_to_naive_utc_time(time)
+        if time < _EARLIEST_UTC_TIME:
+            raise ValueError(
+                "The not valid after date must be on or after"
+                " 1950 January 1."
+            )
+        if (
+            self._not_valid_before is not None
+            and time < self._not_valid_before
+        ):
+            raise ValueError(
+                "The not valid after date must be after the not valid before "
+                "date."
+            )
+        return CertificateBuilder(
+            self._issuer_name,
+            self._subject_name,
+            self._public_key,
+            self._serial_number,
+            self._not_valid_before,
+            time,
+            self._extensions,
+        )
+
+    def add_extension(
+        self, extval: ExtensionType, critical: bool
+    ) -> "CertificateBuilder":
+        """
+        Adds an X.509 extension to the certificate.
+        """
+        if not isinstance(extval, ExtensionType):
+            raise TypeError("extension must be an ExtensionType")
+
+        extension = Extension(extval.oid, critical, extval)
+        _reject_duplicate_extension(extension, self._extensions)
+
+        return CertificateBuilder(
+            self._issuer_name,
+            self._subject_name,
+            self._public_key,
+            self._serial_number,
+            self._not_valid_before,
+            self._not_valid_after,
+            self._extensions + [extension],
+        )
+
+    def sign(
+        self,
+        private_key: CERTIFICATE_PRIVATE_KEY_TYPES,
+        algorithm: typing.Optional[hashes.HashAlgorithm],
+        backend: typing.Any = None,
+    ) -> Certificate:
+        """
+        Signs the certificate using the CA's private key.
+        """
+        if self._subject_name is None:
+            raise ValueError("A certificate must have a subject name")
+
+        if self._issuer_name is None:
+            raise ValueError("A certificate must have an issuer name")
+
+        if self._serial_number is None:
+            raise ValueError("A certificate must have a serial number")
+
+        if self._not_valid_before is None:
+            raise ValueError("A certificate must have a not valid before time")
+
+        if self._not_valid_after is None:
+            raise ValueError("A certificate must have a not valid after time")
+
+        if self._public_key is None:
+            raise ValueError("A certificate must have a public key")
+
+        return rust_x509.create_x509_certificate(self, private_key, algorithm)
+
+
+class CertificateRevocationListBuilder:
+    _extensions: typing.List[Extension[ExtensionType]]
+    _revoked_certificates: typing.List[RevokedCertificate]
+
+    def __init__(
+        self,
+        issuer_name: typing.Optional[Name] = None,
+        last_update: typing.Optional[datetime.datetime] = None,
+        next_update: typing.Optional[datetime.datetime] = None,
+        extensions: typing.List[Extension[ExtensionType]] = [],
+        revoked_certificates: typing.List[RevokedCertificate] = [],
+    ):
+        self._issuer_name = issuer_name
+        self._last_update = last_update
+        self._next_update = next_update
+        self._extensions = extensions
+        self._revoked_certificates = revoked_certificates
+
+    def issuer_name(
+        self, issuer_name: Name
+    ) -> "CertificateRevocationListBuilder":
+        if not isinstance(issuer_name, Name):
+            raise TypeError("Expecting x509.Name object.")
+        if self._issuer_name is not None:
+            raise ValueError("The issuer name may only be set once.")
+        return CertificateRevocationListBuilder(
+            issuer_name,
+            self._last_update,
+            self._next_update,
+            self._extensions,
+            self._revoked_certificates,
+        )
+
+    def last_update(
+        self, last_update: datetime.datetime
+    ) -> "CertificateRevocationListBuilder":
+        if not isinstance(last_update, datetime.datetime):
+            raise TypeError("Expecting datetime object.")
+        if self._last_update is not None:
+            raise ValueError("Last update may only be set once.")
+        last_update = _convert_to_naive_utc_time(last_update)
+        if last_update < _EARLIEST_UTC_TIME:
+            raise ValueError(
+                "The last update date must be on or after" " 1950 January 1."
+            )
+        if self._next_update is not None and last_update > self._next_update:
+            raise ValueError(
+                "The last update date must be before the next update date."
+            )
+        return CertificateRevocationListBuilder(
+            self._issuer_name,
+            last_update,
+            self._next_update,
+            self._extensions,
+            self._revoked_certificates,
+        )
+
+    def next_update(
+        self, next_update: datetime.datetime
+    ) -> "CertificateRevocationListBuilder":
+        if not isinstance(next_update, datetime.datetime):
+            raise TypeError("Expecting datetime object.")
+        if self._next_update is not None:
+            raise ValueError("Last update may only be set once.")
+        next_update = _convert_to_naive_utc_time(next_update)
+        if next_update < _EARLIEST_UTC_TIME:
+            raise ValueError(
+                "The last update date must be on or after" " 1950 January 1."
+            )
+        if self._last_update is not None and next_update < self._last_update:
+            raise ValueError(
+                "The next update date must be after the last update date."
+            )
+        return CertificateRevocationListBuilder(
+            self._issuer_name,
+            self._last_update,
+            next_update,
+            self._extensions,
+            self._revoked_certificates,
+        )
+
+    def add_extension(
+        self, extval: ExtensionType, critical: bool
+    ) -> "CertificateRevocationListBuilder":
+        """
+        Adds an X.509 extension to the certificate revocation list.
+        """
+        if not isinstance(extval, ExtensionType):
+            raise TypeError("extension must be an ExtensionType")
+
+        extension = Extension(extval.oid, critical, extval)
+        _reject_duplicate_extension(extension, self._extensions)
+        return CertificateRevocationListBuilder(
+            self._issuer_name,
+            self._last_update,
+            self._next_update,
+            self._extensions + [extension],
+            self._revoked_certificates,
+        )
+
+    def add_revoked_certificate(
+        self, revoked_certificate: RevokedCertificate
+    ) -> "CertificateRevocationListBuilder":
+        """
+        Adds a revoked certificate to the CRL.
+        """
+        if not isinstance(revoked_certificate, RevokedCertificate):
+            raise TypeError("Must be an instance of RevokedCertificate")
+
+        return CertificateRevocationListBuilder(
+            self._issuer_name,
+            self._last_update,
+            self._next_update,
+            self._extensions,
+            self._revoked_certificates + [revoked_certificate],
+        )
+
+    def sign(
+        self,
+        private_key: CERTIFICATE_PRIVATE_KEY_TYPES,
+        algorithm: typing.Optional[hashes.HashAlgorithm],
+        backend: typing.Any = None,
+    ) -> CertificateRevocationList:
+        if self._issuer_name is None:
+            raise ValueError("A CRL must have an issuer name")
+
+        if self._last_update is None:
+            raise ValueError("A CRL must have a last update time")
+
+        if self._next_update is None:
+            raise ValueError("A CRL must have a next update time")
+
+        return rust_x509.create_x509_crl(self, private_key, algorithm)
+
+
+class RevokedCertificateBuilder:
+    def __init__(
+        self,
+        serial_number: typing.Optional[int] = None,
+        revocation_date: typing.Optional[datetime.datetime] = None,
+        extensions: typing.List[Extension[ExtensionType]] = [],
+    ):
+        self._serial_number = serial_number
+        self._revocation_date = revocation_date
+        self._extensions = extensions
+
+    def serial_number(self, number: int) -> "RevokedCertificateBuilder":
+        if not isinstance(number, int):
+            raise TypeError("Serial number must be of integral type.")
+        if self._serial_number is not None:
+            raise ValueError("The serial number may only be set once.")
+        if number <= 0:
+            raise ValueError("The serial number should be positive")
+
+        # ASN.1 integers are always signed, so most significant bit must be
+        # zero.
+        if number.bit_length() >= 160:  # As defined in RFC 5280
+            raise ValueError(
+                "The serial number should not be more than 159 " "bits."
+            )
+        return RevokedCertificateBuilder(
+            number, self._revocation_date, self._extensions
+        )
+
+    def revocation_date(
+        self, time: datetime.datetime
+    ) -> "RevokedCertificateBuilder":
+        if not isinstance(time, datetime.datetime):
+            raise TypeError("Expecting datetime object.")
+        if self._revocation_date is not None:
+            raise ValueError("The revocation date may only be set once.")
+        time = _convert_to_naive_utc_time(time)
+        if time < _EARLIEST_UTC_TIME:
+            raise ValueError(
+                "The revocation date must be on or after" " 1950 January 1."
+            )
+        return RevokedCertificateBuilder(
+            self._serial_number, time, self._extensions
+        )
+
+    def add_extension(
+        self, extval: ExtensionType, critical: bool
+    ) -> "RevokedCertificateBuilder":
+        if not isinstance(extval, ExtensionType):
+            raise TypeError("extension must be an ExtensionType")
+
+        extension = Extension(extval.oid, critical, extval)
+        _reject_duplicate_extension(extension, self._extensions)
+        return RevokedCertificateBuilder(
+            self._serial_number,
+            self._revocation_date,
+            self._extensions + [extension],
+        )
+
+    def build(self, backend: typing.Any = None) -> RevokedCertificate:
+        if self._serial_number is None:
+            raise ValueError("A revoked certificate must have a serial number")
+        if self._revocation_date is None:
+            raise ValueError(
+                "A revoked certificate must have a revocation date"
+            )
+        return _RawRevokedCertificate(
+            self._serial_number,
+            self._revocation_date,
+            Extensions(self._extensions),
+        )
+
+
+def random_serial_number() -> int:
+    return int.from_bytes(os.urandom(20), "big") >> 1
diff --git a/myenv/lib/python3.9/site-packages/cryptography/x509/certificate_transparency.py b/myenv/lib/python3.9/site-packages/cryptography/x509/certificate_transparency.py
new file mode 100644
index 0000000..8c198a1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/x509/certificate_transparency.py
@@ -0,0 +1,48 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import datetime
+
+from cryptography import utils
+from cryptography.hazmat.bindings._rust import x509 as rust_x509
+
+
+class LogEntryType(utils.Enum):
+    X509_CERTIFICATE = 0
+    PRE_CERTIFICATE = 1
+
+
+class Version(utils.Enum):
+    v1 = 0
+
+
+class SignedCertificateTimestamp(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def version(self) -> Version:
+        """
+        Returns the SCT version.
+        """
+
+    @abc.abstractproperty
+    def log_id(self) -> bytes:
+        """
+        Returns an identifier indicating which log this SCT is for.
+        """
+
+    @abc.abstractproperty
+    def timestamp(self) -> datetime.datetime:
+        """
+        Returns the timestamp for this SCT.
+        """
+
+    @abc.abstractproperty
+    def entry_type(self) -> LogEntryType:
+        """
+        Returns whether this is an SCT for a certificate or pre-certificate.
+        """
+
+
+SignedCertificateTimestamp.register(rust_x509.Sct)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/x509/extensions.py b/myenv/lib/python3.9/site-packages/cryptography/x509/extensions.py
new file mode 100644
index 0000000..e64f602
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/x509/extensions.py
@@ -0,0 +1,2103 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import datetime
+import hashlib
+import ipaddress
+import typing
+
+from cryptography import utils
+from cryptography.hazmat.bindings._rust import asn1
+from cryptography.hazmat.bindings._rust import x509 as rust_x509
+from cryptography.hazmat.primitives import constant_time, serialization
+from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePublicKey
+from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicKey
+from cryptography.hazmat.primitives.asymmetric.types import (
+    CERTIFICATE_ISSUER_PUBLIC_KEY_TYPES,
+    CERTIFICATE_PUBLIC_KEY_TYPES,
+)
+from cryptography.x509.certificate_transparency import (
+    SignedCertificateTimestamp,
+)
+from cryptography.x509.general_name import (
+    DNSName,
+    DirectoryName,
+    GeneralName,
+    IPAddress,
+    OtherName,
+    RFC822Name,
+    RegisteredID,
+    UniformResourceIdentifier,
+    _IPADDRESS_TYPES,
+)
+from cryptography.x509.name import Name, RelativeDistinguishedName
+from cryptography.x509.oid import (
+    CRLEntryExtensionOID,
+    ExtensionOID,
+    OCSPExtensionOID,
+    ObjectIdentifier,
+)
+
+ExtensionTypeVar = typing.TypeVar(
+    "ExtensionTypeVar", bound="ExtensionType", covariant=True
+)
+
+
+def _key_identifier_from_public_key(
+    public_key: CERTIFICATE_PUBLIC_KEY_TYPES,
+) -> bytes:
+    if isinstance(public_key, RSAPublicKey):
+        data = public_key.public_bytes(
+            serialization.Encoding.DER,
+            serialization.PublicFormat.PKCS1,
+        )
+    elif isinstance(public_key, EllipticCurvePublicKey):
+        data = public_key.public_bytes(
+            serialization.Encoding.X962,
+            serialization.PublicFormat.UncompressedPoint,
+        )
+    else:
+        # This is a very slow way to do this.
+        serialized = public_key.public_bytes(
+            serialization.Encoding.DER,
+            serialization.PublicFormat.SubjectPublicKeyInfo,
+        )
+        data = asn1.parse_spki_for_data(serialized)
+
+    return hashlib.sha1(data).digest()
+
+
+def _make_sequence_methods(field_name: str):
+    def len_method(self) -> int:
+        return len(getattr(self, field_name))
+
+    def iter_method(self):
+        return iter(getattr(self, field_name))
+
+    def getitem_method(self, idx):
+        return getattr(self, field_name)[idx]
+
+    return len_method, iter_method, getitem_method
+
+
+class DuplicateExtension(Exception):
+    def __init__(self, msg: str, oid: ObjectIdentifier) -> None:
+        super(DuplicateExtension, self).__init__(msg)
+        self.oid = oid
+
+
+class ExtensionNotFound(Exception):
+    def __init__(self, msg: str, oid: ObjectIdentifier) -> None:
+        super(ExtensionNotFound, self).__init__(msg)
+        self.oid = oid
+
+
+class ExtensionType(metaclass=abc.ABCMeta):
+    oid: typing.ClassVar[ObjectIdentifier]
+
+    def public_bytes(self) -> bytes:
+        """
+        Serializes the extension type to DER.
+        """
+        raise NotImplementedError(
+            "public_bytes is not implemented for extension type {0!r}".format(
+                self
+            )
+        )
+
+
+class Extensions:
+    def __init__(
+        self, extensions: typing.Iterable["Extension[ExtensionType]"]
+    ) -> None:
+        self._extensions = list(extensions)
+
+    def get_extension_for_oid(
+        self, oid: ObjectIdentifier
+    ) -> "Extension[ExtensionType]":
+        for ext in self:
+            if ext.oid == oid:
+                return ext
+
+        raise ExtensionNotFound("No {} extension was found".format(oid), oid)
+
+    def get_extension_for_class(
+        self, extclass: typing.Type[ExtensionTypeVar]
+    ) -> "Extension[ExtensionTypeVar]":
+        if extclass is UnrecognizedExtension:
+            raise TypeError(
+                "UnrecognizedExtension can't be used with "
+                "get_extension_for_class because more than one instance of the"
+                " class may be present."
+            )
+
+        for ext in self:
+            if isinstance(ext.value, extclass):
+                return ext
+
+        raise ExtensionNotFound(
+            "No {} extension was found".format(extclass), extclass.oid
+        )
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods("_extensions")
+
+    def __repr__(self) -> str:
+        return "<Extensions({})>".format(self._extensions)
+
+
+class CRLNumber(ExtensionType):
+    oid = ExtensionOID.CRL_NUMBER
+
+    def __init__(self, crl_number: int) -> None:
+        if not isinstance(crl_number, int):
+            raise TypeError("crl_number must be an integer")
+
+        self._crl_number = crl_number
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CRLNumber):
+            return NotImplemented
+
+        return self.crl_number == other.crl_number
+
+    def __hash__(self) -> int:
+        return hash(self.crl_number)
+
+    def __repr__(self) -> str:
+        return "<CRLNumber({})>".format(self.crl_number)
+
+    @property
+    def crl_number(self) -> int:
+        return self._crl_number
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class AuthorityKeyIdentifier(ExtensionType):
+    oid = ExtensionOID.AUTHORITY_KEY_IDENTIFIER
+
+    def __init__(
+        self,
+        key_identifier: typing.Optional[bytes],
+        authority_cert_issuer: typing.Optional[typing.Iterable[GeneralName]],
+        authority_cert_serial_number: typing.Optional[int],
+    ) -> None:
+        if (authority_cert_issuer is None) != (
+            authority_cert_serial_number is None
+        ):
+            raise ValueError(
+                "authority_cert_issuer and authority_cert_serial_number "
+                "must both be present or both None"
+            )
+
+        if authority_cert_issuer is not None:
+            authority_cert_issuer = list(authority_cert_issuer)
+            if not all(
+                isinstance(x, GeneralName) for x in authority_cert_issuer
+            ):
+                raise TypeError(
+                    "authority_cert_issuer must be a list of GeneralName "
+                    "objects"
+                )
+
+        if authority_cert_serial_number is not None and not isinstance(
+            authority_cert_serial_number, int
+        ):
+            raise TypeError("authority_cert_serial_number must be an integer")
+
+        self._key_identifier = key_identifier
+        self._authority_cert_issuer = authority_cert_issuer
+        self._authority_cert_serial_number = authority_cert_serial_number
+
+    # This takes a subset of CERTIFICATE_PUBLIC_KEY_TYPES because an issuer
+    # cannot have an X25519/X448 key. This introduces some unfortunate
+    # asymmetry that requires typing users to explicitly
+    # narrow their type, but we should make this accurate and not just
+    # convenient.
+    @classmethod
+    def from_issuer_public_key(
+        cls, public_key: CERTIFICATE_ISSUER_PUBLIC_KEY_TYPES
+    ) -> "AuthorityKeyIdentifier":
+        digest = _key_identifier_from_public_key(public_key)
+        return cls(
+            key_identifier=digest,
+            authority_cert_issuer=None,
+            authority_cert_serial_number=None,
+        )
+
+    @classmethod
+    def from_issuer_subject_key_identifier(
+        cls, ski: "SubjectKeyIdentifier"
+    ) -> "AuthorityKeyIdentifier":
+        return cls(
+            key_identifier=ski.digest,
+            authority_cert_issuer=None,
+            authority_cert_serial_number=None,
+        )
+
+    def __repr__(self) -> str:
+        return (
+            "<AuthorityKeyIdentifier(key_identifier={0.key_identifier!r}, "
+            "authority_cert_issuer={0.authority_cert_issuer}, "
+            "authority_cert_serial_number={0.authority_cert_serial_number}"
+            ")>".format(self)
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, AuthorityKeyIdentifier):
+            return NotImplemented
+
+        return (
+            self.key_identifier == other.key_identifier
+            and self.authority_cert_issuer == other.authority_cert_issuer
+            and self.authority_cert_serial_number
+            == other.authority_cert_serial_number
+        )
+
+    def __hash__(self) -> int:
+        if self.authority_cert_issuer is None:
+            aci = None
+        else:
+            aci = tuple(self.authority_cert_issuer)
+        return hash(
+            (self.key_identifier, aci, self.authority_cert_serial_number)
+        )
+
+    @property
+    def key_identifier(self) -> typing.Optional[bytes]:
+        return self._key_identifier
+
+    @property
+    def authority_cert_issuer(
+        self,
+    ) -> typing.Optional[typing.List[GeneralName]]:
+        return self._authority_cert_issuer
+
+    @property
+    def authority_cert_serial_number(self) -> typing.Optional[int]:
+        return self._authority_cert_serial_number
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class SubjectKeyIdentifier(ExtensionType):
+    oid = ExtensionOID.SUBJECT_KEY_IDENTIFIER
+
+    def __init__(self, digest: bytes) -> None:
+        self._digest = digest
+
+    @classmethod
+    def from_public_key(
+        cls, public_key: CERTIFICATE_PUBLIC_KEY_TYPES
+    ) -> "SubjectKeyIdentifier":
+        return cls(_key_identifier_from_public_key(public_key))
+
+    @property
+    def digest(self) -> bytes:
+        return self._digest
+
+    @property
+    def key_identifier(self) -> bytes:
+        return self._digest
+
+    def __repr__(self) -> str:
+        return "<SubjectKeyIdentifier(digest={0!r})>".format(self.digest)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SubjectKeyIdentifier):
+            return NotImplemented
+
+        return constant_time.bytes_eq(self.digest, other.digest)
+
+    def __hash__(self) -> int:
+        return hash(self.digest)
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class AuthorityInformationAccess(ExtensionType):
+    oid = ExtensionOID.AUTHORITY_INFORMATION_ACCESS
+
+    def __init__(
+        self, descriptions: typing.Iterable["AccessDescription"]
+    ) -> None:
+        descriptions = list(descriptions)
+        if not all(isinstance(x, AccessDescription) for x in descriptions):
+            raise TypeError(
+                "Every item in the descriptions list must be an "
+                "AccessDescription"
+            )
+
+        self._descriptions = descriptions
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods("_descriptions")
+
+    def __repr__(self) -> str:
+        return "<AuthorityInformationAccess({})>".format(self._descriptions)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, AuthorityInformationAccess):
+            return NotImplemented
+
+        return self._descriptions == other._descriptions
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._descriptions))
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class SubjectInformationAccess(ExtensionType):
+    oid = ExtensionOID.SUBJECT_INFORMATION_ACCESS
+
+    def __init__(
+        self, descriptions: typing.Iterable["AccessDescription"]
+    ) -> None:
+        descriptions = list(descriptions)
+        if not all(isinstance(x, AccessDescription) for x in descriptions):
+            raise TypeError(
+                "Every item in the descriptions list must be an "
+                "AccessDescription"
+            )
+
+        self._descriptions = descriptions
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods("_descriptions")
+
+    def __repr__(self) -> str:
+        return "<SubjectInformationAccess({})>".format(self._descriptions)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SubjectInformationAccess):
+            return NotImplemented
+
+        return self._descriptions == other._descriptions
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._descriptions))
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class AccessDescription:
+    def __init__(
+        self, access_method: ObjectIdentifier, access_location: GeneralName
+    ) -> None:
+        if not isinstance(access_method, ObjectIdentifier):
+            raise TypeError("access_method must be an ObjectIdentifier")
+
+        if not isinstance(access_location, GeneralName):
+            raise TypeError("access_location must be a GeneralName")
+
+        self._access_method = access_method
+        self._access_location = access_location
+
+    def __repr__(self) -> str:
+        return (
+            "<AccessDescription(access_method={0.access_method}, access_locati"
+            "on={0.access_location})>".format(self)
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, AccessDescription):
+            return NotImplemented
+
+        return (
+            self.access_method == other.access_method
+            and self.access_location == other.access_location
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.access_method, self.access_location))
+
+    @property
+    def access_method(self) -> ObjectIdentifier:
+        return self._access_method
+
+    @property
+    def access_location(self) -> GeneralName:
+        return self._access_location
+
+
+class BasicConstraints(ExtensionType):
+    oid = ExtensionOID.BASIC_CONSTRAINTS
+
+    def __init__(self, ca: bool, path_length: typing.Optional[int]) -> None:
+        if not isinstance(ca, bool):
+            raise TypeError("ca must be a boolean value")
+
+        if path_length is not None and not ca:
+            raise ValueError("path_length must be None when ca is False")
+
+        if path_length is not None and (
+            not isinstance(path_length, int) or path_length < 0
+        ):
+            raise TypeError(
+                "path_length must be a non-negative integer or None"
+            )
+
+        self._ca = ca
+        self._path_length = path_length
+
+    @property
+    def ca(self) -> bool:
+        return self._ca
+
+    @property
+    def path_length(self) -> typing.Optional[int]:
+        return self._path_length
+
+    def __repr__(self) -> str:
+        return (
+            "<BasicConstraints(ca={0.ca}, " "path_length={0.path_length})>"
+        ).format(self)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, BasicConstraints):
+            return NotImplemented
+
+        return self.ca == other.ca and self.path_length == other.path_length
+
+    def __hash__(self) -> int:
+        return hash((self.ca, self.path_length))
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class DeltaCRLIndicator(ExtensionType):
+    oid = ExtensionOID.DELTA_CRL_INDICATOR
+
+    def __init__(self, crl_number: int) -> None:
+        if not isinstance(crl_number, int):
+            raise TypeError("crl_number must be an integer")
+
+        self._crl_number = crl_number
+
+    @property
+    def crl_number(self) -> int:
+        return self._crl_number
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DeltaCRLIndicator):
+            return NotImplemented
+
+        return self.crl_number == other.crl_number
+
+    def __hash__(self) -> int:
+        return hash(self.crl_number)
+
+    def __repr__(self) -> str:
+        return "<DeltaCRLIndicator(crl_number={0.crl_number})>".format(self)
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class CRLDistributionPoints(ExtensionType):
+    oid = ExtensionOID.CRL_DISTRIBUTION_POINTS
+
+    def __init__(
+        self, distribution_points: typing.Iterable["DistributionPoint"]
+    ) -> None:
+        distribution_points = list(distribution_points)
+        if not all(
+            isinstance(x, DistributionPoint) for x in distribution_points
+        ):
+            raise TypeError(
+                "distribution_points must be a list of DistributionPoint "
+                "objects"
+            )
+
+        self._distribution_points = distribution_points
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods(
+        "_distribution_points"
+    )
+
+    def __repr__(self) -> str:
+        return "<CRLDistributionPoints({})>".format(self._distribution_points)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CRLDistributionPoints):
+            return NotImplemented
+
+        return self._distribution_points == other._distribution_points
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._distribution_points))
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class FreshestCRL(ExtensionType):
+    oid = ExtensionOID.FRESHEST_CRL
+
+    def __init__(
+        self, distribution_points: typing.Iterable["DistributionPoint"]
+    ) -> None:
+        distribution_points = list(distribution_points)
+        if not all(
+            isinstance(x, DistributionPoint) for x in distribution_points
+        ):
+            raise TypeError(
+                "distribution_points must be a list of DistributionPoint "
+                "objects"
+            )
+
+        self._distribution_points = distribution_points
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods(
+        "_distribution_points"
+    )
+
+    def __repr__(self) -> str:
+        return "<FreshestCRL({})>".format(self._distribution_points)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, FreshestCRL):
+            return NotImplemented
+
+        return self._distribution_points == other._distribution_points
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._distribution_points))
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class DistributionPoint:
+    def __init__(
+        self,
+        full_name: typing.Optional[typing.Iterable[GeneralName]],
+        relative_name: typing.Optional[RelativeDistinguishedName],
+        reasons: typing.Optional[typing.FrozenSet["ReasonFlags"]],
+        crl_issuer: typing.Optional[typing.Iterable[GeneralName]],
+    ) -> None:
+        if full_name and relative_name:
+            raise ValueError(
+                "You cannot provide both full_name and relative_name, at "
+                "least one must be None."
+            )
+
+        if full_name is not None:
+            full_name = list(full_name)
+            if not all(isinstance(x, GeneralName) for x in full_name):
+                raise TypeError(
+                    "full_name must be a list of GeneralName objects"
+                )
+
+        if relative_name:
+            if not isinstance(relative_name, RelativeDistinguishedName):
+                raise TypeError(
+                    "relative_name must be a RelativeDistinguishedName"
+                )
+
+        if crl_issuer is not None:
+            crl_issuer = list(crl_issuer)
+            if not all(isinstance(x, GeneralName) for x in crl_issuer):
+                raise TypeError(
+                    "crl_issuer must be None or a list of general names"
+                )
+
+        if reasons and (
+            not isinstance(reasons, frozenset)
+            or not all(isinstance(x, ReasonFlags) for x in reasons)
+        ):
+            raise TypeError("reasons must be None or frozenset of ReasonFlags")
+
+        if reasons and (
+            ReasonFlags.unspecified in reasons
+            or ReasonFlags.remove_from_crl in reasons
+        ):
+            raise ValueError(
+                "unspecified and remove_from_crl are not valid reasons in a "
+                "DistributionPoint"
+            )
+
+        if reasons and not crl_issuer and not (full_name or relative_name):
+            raise ValueError(
+                "You must supply crl_issuer, full_name, or relative_name when "
+                "reasons is not None"
+            )
+
+        self._full_name = full_name
+        self._relative_name = relative_name
+        self._reasons = reasons
+        self._crl_issuer = crl_issuer
+
+    def __repr__(self) -> str:
+        return (
+            "<DistributionPoint(full_name={0.full_name}, relative_name={0.rela"
+            "tive_name}, reasons={0.reasons}, "
+            "crl_issuer={0.crl_issuer})>".format(self)
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DistributionPoint):
+            return NotImplemented
+
+        return (
+            self.full_name == other.full_name
+            and self.relative_name == other.relative_name
+            and self.reasons == other.reasons
+            and self.crl_issuer == other.crl_issuer
+        )
+
+    def __hash__(self) -> int:
+        if self.full_name is not None:
+            fn: typing.Optional[typing.Tuple[GeneralName, ...]] = tuple(
+                self.full_name
+            )
+        else:
+            fn = None
+
+        if self.crl_issuer is not None:
+            crl_issuer: typing.Optional[
+                typing.Tuple[GeneralName, ...]
+            ] = tuple(self.crl_issuer)
+        else:
+            crl_issuer = None
+
+        return hash((fn, self.relative_name, self.reasons, crl_issuer))
+
+    @property
+    def full_name(self) -> typing.Optional[typing.List[GeneralName]]:
+        return self._full_name
+
+    @property
+    def relative_name(self) -> typing.Optional[RelativeDistinguishedName]:
+        return self._relative_name
+
+    @property
+    def reasons(self) -> typing.Optional[typing.FrozenSet["ReasonFlags"]]:
+        return self._reasons
+
+    @property
+    def crl_issuer(self) -> typing.Optional[typing.List[GeneralName]]:
+        return self._crl_issuer
+
+
+class ReasonFlags(utils.Enum):
+    unspecified = "unspecified"
+    key_compromise = "keyCompromise"
+    ca_compromise = "cACompromise"
+    affiliation_changed = "affiliationChanged"
+    superseded = "superseded"
+    cessation_of_operation = "cessationOfOperation"
+    certificate_hold = "certificateHold"
+    privilege_withdrawn = "privilegeWithdrawn"
+    aa_compromise = "aACompromise"
+    remove_from_crl = "removeFromCRL"
+
+
+# These are distribution point bit string mappings. Not to be confused with
+# CRLReason reason flags bit string mappings.
+# ReasonFlags ::= BIT STRING {
+#      unused                  (0),
+#      keyCompromise           (1),
+#      cACompromise            (2),
+#      affiliationChanged      (3),
+#      superseded              (4),
+#      cessationOfOperation    (5),
+#      certificateHold         (6),
+#      privilegeWithdrawn      (7),
+#      aACompromise            (8) }
+_REASON_BIT_MAPPING = {
+    1: ReasonFlags.key_compromise,
+    2: ReasonFlags.ca_compromise,
+    3: ReasonFlags.affiliation_changed,
+    4: ReasonFlags.superseded,
+    5: ReasonFlags.cessation_of_operation,
+    6: ReasonFlags.certificate_hold,
+    7: ReasonFlags.privilege_withdrawn,
+    8: ReasonFlags.aa_compromise,
+}
+
+
+class PolicyConstraints(ExtensionType):
+    oid = ExtensionOID.POLICY_CONSTRAINTS
+
+    def __init__(
+        self,
+        require_explicit_policy: typing.Optional[int],
+        inhibit_policy_mapping: typing.Optional[int],
+    ) -> None:
+        if require_explicit_policy is not None and not isinstance(
+            require_explicit_policy, int
+        ):
+            raise TypeError(
+                "require_explicit_policy must be a non-negative integer or "
+                "None"
+            )
+
+        if inhibit_policy_mapping is not None and not isinstance(
+            inhibit_policy_mapping, int
+        ):
+            raise TypeError(
+                "inhibit_policy_mapping must be a non-negative integer or None"
+            )
+
+        if inhibit_policy_mapping is None and require_explicit_policy is None:
+            raise ValueError(
+                "At least one of require_explicit_policy and "
+                "inhibit_policy_mapping must not be None"
+            )
+
+        self._require_explicit_policy = require_explicit_policy
+        self._inhibit_policy_mapping = inhibit_policy_mapping
+
+    def __repr__(self) -> str:
+        return (
+            "<PolicyConstraints(require_explicit_policy={0.require_explicit"
+            "_policy}, inhibit_policy_mapping={0.inhibit_policy_"
+            "mapping})>".format(self)
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, PolicyConstraints):
+            return NotImplemented
+
+        return (
+            self.require_explicit_policy == other.require_explicit_policy
+            and self.inhibit_policy_mapping == other.inhibit_policy_mapping
+        )
+
+    def __hash__(self) -> int:
+        return hash(
+            (self.require_explicit_policy, self.inhibit_policy_mapping)
+        )
+
+    @property
+    def require_explicit_policy(self) -> typing.Optional[int]:
+        return self._require_explicit_policy
+
+    @property
+    def inhibit_policy_mapping(self) -> typing.Optional[int]:
+        return self._inhibit_policy_mapping
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class CertificatePolicies(ExtensionType):
+    oid = ExtensionOID.CERTIFICATE_POLICIES
+
+    def __init__(self, policies: typing.Iterable["PolicyInformation"]) -> None:
+        policies = list(policies)
+        if not all(isinstance(x, PolicyInformation) for x in policies):
+            raise TypeError(
+                "Every item in the policies list must be a "
+                "PolicyInformation"
+            )
+
+        self._policies = policies
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods("_policies")
+
+    def __repr__(self) -> str:
+        return "<CertificatePolicies({})>".format(self._policies)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CertificatePolicies):
+            return NotImplemented
+
+        return self._policies == other._policies
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._policies))
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class PolicyInformation:
+    def __init__(
+        self,
+        policy_identifier: ObjectIdentifier,
+        policy_qualifiers: typing.Optional[
+            typing.Iterable[typing.Union[str, "UserNotice"]]
+        ],
+    ) -> None:
+        if not isinstance(policy_identifier, ObjectIdentifier):
+            raise TypeError("policy_identifier must be an ObjectIdentifier")
+
+        self._policy_identifier = policy_identifier
+
+        if policy_qualifiers is not None:
+            policy_qualifiers = list(policy_qualifiers)
+            if not all(
+                isinstance(x, (str, UserNotice)) for x in policy_qualifiers
+            ):
+                raise TypeError(
+                    "policy_qualifiers must be a list of strings and/or "
+                    "UserNotice objects or None"
+                )
+
+        self._policy_qualifiers = policy_qualifiers
+
+    def __repr__(self) -> str:
+        return (
+            "<PolicyInformation(policy_identifier={0.policy_identifier}, polic"
+            "y_qualifiers={0.policy_qualifiers})>".format(self)
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, PolicyInformation):
+            return NotImplemented
+
+        return (
+            self.policy_identifier == other.policy_identifier
+            and self.policy_qualifiers == other.policy_qualifiers
+        )
+
+    def __hash__(self) -> int:
+        if self.policy_qualifiers is not None:
+            pq: typing.Optional[
+                typing.Tuple[typing.Union[str, "UserNotice"], ...]
+            ] = tuple(self.policy_qualifiers)
+        else:
+            pq = None
+
+        return hash((self.policy_identifier, pq))
+
+    @property
+    def policy_identifier(self) -> ObjectIdentifier:
+        return self._policy_identifier
+
+    @property
+    def policy_qualifiers(
+        self,
+    ) -> typing.Optional[typing.List[typing.Union[str, "UserNotice"]]]:
+        return self._policy_qualifiers
+
+
+class UserNotice:
+    def __init__(
+        self,
+        notice_reference: typing.Optional["NoticeReference"],
+        explicit_text: typing.Optional[str],
+    ) -> None:
+        if notice_reference and not isinstance(
+            notice_reference, NoticeReference
+        ):
+            raise TypeError(
+                "notice_reference must be None or a NoticeReference"
+            )
+
+        self._notice_reference = notice_reference
+        self._explicit_text = explicit_text
+
+    def __repr__(self) -> str:
+        return (
+            "<UserNotice(notice_reference={0.notice_reference}, explicit_text="
+            "{0.explicit_text!r})>".format(self)
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, UserNotice):
+            return NotImplemented
+
+        return (
+            self.notice_reference == other.notice_reference
+            and self.explicit_text == other.explicit_text
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.notice_reference, self.explicit_text))
+
+    @property
+    def notice_reference(self) -> typing.Optional["NoticeReference"]:
+        return self._notice_reference
+
+    @property
+    def explicit_text(self) -> typing.Optional[str]:
+        return self._explicit_text
+
+
+class NoticeReference:
+    def __init__(
+        self,
+        organization: typing.Optional[str],
+        notice_numbers: typing.Iterable[int],
+    ) -> None:
+        self._organization = organization
+        notice_numbers = list(notice_numbers)
+        if not all(isinstance(x, int) for x in notice_numbers):
+            raise TypeError("notice_numbers must be a list of integers")
+
+        self._notice_numbers = notice_numbers
+
+    def __repr__(self) -> str:
+        return (
+            "<NoticeReference(organization={0.organization!r}, notice_numbers="
+            "{0.notice_numbers})>".format(self)
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, NoticeReference):
+            return NotImplemented
+
+        return (
+            self.organization == other.organization
+            and self.notice_numbers == other.notice_numbers
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.organization, tuple(self.notice_numbers)))
+
+    @property
+    def organization(self) -> typing.Optional[str]:
+        return self._organization
+
+    @property
+    def notice_numbers(self) -> typing.List[int]:
+        return self._notice_numbers
+
+
+class ExtendedKeyUsage(ExtensionType):
+    oid = ExtensionOID.EXTENDED_KEY_USAGE
+
+    def __init__(self, usages: typing.Iterable[ObjectIdentifier]) -> None:
+        usages = list(usages)
+        if not all(isinstance(x, ObjectIdentifier) for x in usages):
+            raise TypeError(
+                "Every item in the usages list must be an ObjectIdentifier"
+            )
+
+        self._usages = usages
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods("_usages")
+
+    def __repr__(self) -> str:
+        return "<ExtendedKeyUsage({})>".format(self._usages)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ExtendedKeyUsage):
+            return NotImplemented
+
+        return self._usages == other._usages
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._usages))
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class OCSPNoCheck(ExtensionType):
+    oid = ExtensionOID.OCSP_NO_CHECK
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, OCSPNoCheck):
+            return NotImplemented
+
+        return True
+
+    def __hash__(self) -> int:
+        return hash(OCSPNoCheck)
+
+    def __repr__(self) -> str:
+        return "<OCSPNoCheck()>"
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class PrecertPoison(ExtensionType):
+    oid = ExtensionOID.PRECERT_POISON
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, PrecertPoison):
+            return NotImplemented
+
+        return True
+
+    def __hash__(self) -> int:
+        return hash(PrecertPoison)
+
+    def __repr__(self) -> str:
+        return "<PrecertPoison()>"
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class TLSFeature(ExtensionType):
+    oid = ExtensionOID.TLS_FEATURE
+
+    def __init__(self, features: typing.Iterable["TLSFeatureType"]) -> None:
+        features = list(features)
+        if (
+            not all(isinstance(x, TLSFeatureType) for x in features)
+            or len(features) == 0
+        ):
+            raise TypeError(
+                "features must be a list of elements from the TLSFeatureType "
+                "enum"
+            )
+
+        self._features = features
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods("_features")
+
+    def __repr__(self) -> str:
+        return "<TLSFeature(features={0._features})>".format(self)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, TLSFeature):
+            return NotImplemented
+
+        return self._features == other._features
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._features))
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class TLSFeatureType(utils.Enum):
+    # status_request is defined in RFC 6066 and is used for what is commonly
+    # called OCSP Must-Staple when present in the TLS Feature extension in an
+    # X.509 certificate.
+    status_request = 5
+    # status_request_v2 is defined in RFC 6961 and allows multiple OCSP
+    # responses to be provided. It is not currently in use by clients or
+    # servers.
+    status_request_v2 = 17
+
+
+_TLS_FEATURE_TYPE_TO_ENUM = {x.value: x for x in TLSFeatureType}
+
+
+class InhibitAnyPolicy(ExtensionType):
+    oid = ExtensionOID.INHIBIT_ANY_POLICY
+
+    def __init__(self, skip_certs: int) -> None:
+        if not isinstance(skip_certs, int):
+            raise TypeError("skip_certs must be an integer")
+
+        if skip_certs < 0:
+            raise ValueError("skip_certs must be a non-negative integer")
+
+        self._skip_certs = skip_certs
+
+    def __repr__(self) -> str:
+        return "<InhibitAnyPolicy(skip_certs={0.skip_certs})>".format(self)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, InhibitAnyPolicy):
+            return NotImplemented
+
+        return self.skip_certs == other.skip_certs
+
+    def __hash__(self) -> int:
+        return hash(self.skip_certs)
+
+    @property
+    def skip_certs(self) -> int:
+        return self._skip_certs
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class KeyUsage(ExtensionType):
+    oid = ExtensionOID.KEY_USAGE
+
+    def __init__(
+        self,
+        digital_signature: bool,
+        content_commitment: bool,
+        key_encipherment: bool,
+        data_encipherment: bool,
+        key_agreement: bool,
+        key_cert_sign: bool,
+        crl_sign: bool,
+        encipher_only: bool,
+        decipher_only: bool,
+    ) -> None:
+        if not key_agreement and (encipher_only or decipher_only):
+            raise ValueError(
+                "encipher_only and decipher_only can only be true when "
+                "key_agreement is true"
+            )
+
+        self._digital_signature = digital_signature
+        self._content_commitment = content_commitment
+        self._key_encipherment = key_encipherment
+        self._data_encipherment = data_encipherment
+        self._key_agreement = key_agreement
+        self._key_cert_sign = key_cert_sign
+        self._crl_sign = crl_sign
+        self._encipher_only = encipher_only
+        self._decipher_only = decipher_only
+
+    @property
+    def digital_signature(self) -> bool:
+        return self._digital_signature
+
+    @property
+    def content_commitment(self) -> bool:
+        return self._content_commitment
+
+    @property
+    def key_encipherment(self) -> bool:
+        return self._key_encipherment
+
+    @property
+    def data_encipherment(self) -> bool:
+        return self._data_encipherment
+
+    @property
+    def key_agreement(self) -> bool:
+        return self._key_agreement
+
+    @property
+    def key_cert_sign(self) -> bool:
+        return self._key_cert_sign
+
+    @property
+    def crl_sign(self) -> bool:
+        return self._crl_sign
+
+    @property
+    def encipher_only(self) -> bool:
+        if not self.key_agreement:
+            raise ValueError(
+                "encipher_only is undefined unless key_agreement is true"
+            )
+        else:
+            return self._encipher_only
+
+    @property
+    def decipher_only(self) -> bool:
+        if not self.key_agreement:
+            raise ValueError(
+                "decipher_only is undefined unless key_agreement is true"
+            )
+        else:
+            return self._decipher_only
+
+    def __repr__(self) -> str:
+        try:
+            encipher_only = self.encipher_only
+            decipher_only = self.decipher_only
+        except ValueError:
+            # Users found None confusing because even though encipher/decipher
+            # have no meaning unless key_agreement is true, to construct an
+            # instance of the class you still need to pass False.
+            encipher_only = False
+            decipher_only = False
+
+        return (
+            "<KeyUsage(digital_signature={0.digital_signature}, "
+            "content_commitment={0.content_commitment}, "
+            "key_encipherment={0.key_encipherment}, "
+            "data_encipherment={0.data_encipherment}, "
+            "key_agreement={0.key_agreement}, "
+            "key_cert_sign={0.key_cert_sign}, crl_sign={0.crl_sign}, "
+            "encipher_only={1}, decipher_only={2})>"
+        ).format(self, encipher_only, decipher_only)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, KeyUsage):
+            return NotImplemented
+
+        return (
+            self.digital_signature == other.digital_signature
+            and self.content_commitment == other.content_commitment
+            and self.key_encipherment == other.key_encipherment
+            and self.data_encipherment == other.data_encipherment
+            and self.key_agreement == other.key_agreement
+            and self.key_cert_sign == other.key_cert_sign
+            and self.crl_sign == other.crl_sign
+            and self._encipher_only == other._encipher_only
+            and self._decipher_only == other._decipher_only
+        )
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.digital_signature,
+                self.content_commitment,
+                self.key_encipherment,
+                self.data_encipherment,
+                self.key_agreement,
+                self.key_cert_sign,
+                self.crl_sign,
+                self._encipher_only,
+                self._decipher_only,
+            )
+        )
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class NameConstraints(ExtensionType):
+    oid = ExtensionOID.NAME_CONSTRAINTS
+
+    def __init__(
+        self,
+        permitted_subtrees: typing.Optional[typing.Iterable[GeneralName]],
+        excluded_subtrees: typing.Optional[typing.Iterable[GeneralName]],
+    ) -> None:
+        if permitted_subtrees is not None:
+            permitted_subtrees = list(permitted_subtrees)
+            if not permitted_subtrees:
+                raise ValueError(
+                    "permitted_subtrees must be a non-empty list or None"
+                )
+            if not all(isinstance(x, GeneralName) for x in permitted_subtrees):
+                raise TypeError(
+                    "permitted_subtrees must be a list of GeneralName objects "
+                    "or None"
+                )
+
+            self._validate_ip_name(permitted_subtrees)
+
+        if excluded_subtrees is not None:
+            excluded_subtrees = list(excluded_subtrees)
+            if not excluded_subtrees:
+                raise ValueError(
+                    "excluded_subtrees must be a non-empty list or None"
+                )
+            if not all(isinstance(x, GeneralName) for x in excluded_subtrees):
+                raise TypeError(
+                    "excluded_subtrees must be a list of GeneralName objects "
+                    "or None"
+                )
+
+            self._validate_ip_name(excluded_subtrees)
+
+        if permitted_subtrees is None and excluded_subtrees is None:
+            raise ValueError(
+                "At least one of permitted_subtrees and excluded_subtrees "
+                "must not be None"
+            )
+
+        self._permitted_subtrees = permitted_subtrees
+        self._excluded_subtrees = excluded_subtrees
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, NameConstraints):
+            return NotImplemented
+
+        return (
+            self.excluded_subtrees == other.excluded_subtrees
+            and self.permitted_subtrees == other.permitted_subtrees
+        )
+
+    def _validate_ip_name(self, tree: typing.Iterable[GeneralName]) -> None:
+        if any(
+            isinstance(name, IPAddress)
+            and not isinstance(
+                name.value, (ipaddress.IPv4Network, ipaddress.IPv6Network)
+            )
+            for name in tree
+        ):
+            raise TypeError(
+                "IPAddress name constraints must be an IPv4Network or"
+                " IPv6Network object"
+            )
+
+    def __repr__(self) -> str:
+        return (
+            "<NameConstraints(permitted_subtrees={0.permitted_subtrees}, "
+            "excluded_subtrees={0.excluded_subtrees})>".format(self)
+        )
+
+    def __hash__(self) -> int:
+        if self.permitted_subtrees is not None:
+            ps: typing.Optional[typing.Tuple[GeneralName, ...]] = tuple(
+                self.permitted_subtrees
+            )
+        else:
+            ps = None
+
+        if self.excluded_subtrees is not None:
+            es: typing.Optional[typing.Tuple[GeneralName, ...]] = tuple(
+                self.excluded_subtrees
+            )
+        else:
+            es = None
+
+        return hash((ps, es))
+
+    @property
+    def permitted_subtrees(
+        self,
+    ) -> typing.Optional[typing.List[GeneralName]]:
+        return self._permitted_subtrees
+
+    @property
+    def excluded_subtrees(
+        self,
+    ) -> typing.Optional[typing.List[GeneralName]]:
+        return self._excluded_subtrees
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class Extension(typing.Generic[ExtensionTypeVar]):
+    def __init__(
+        self, oid: ObjectIdentifier, critical: bool, value: ExtensionTypeVar
+    ) -> None:
+        if not isinstance(oid, ObjectIdentifier):
+            raise TypeError(
+                "oid argument must be an ObjectIdentifier instance."
+            )
+
+        if not isinstance(critical, bool):
+            raise TypeError("critical must be a boolean value")
+
+        self._oid = oid
+        self._critical = critical
+        self._value = value
+
+    @property
+    def oid(self) -> ObjectIdentifier:
+        return self._oid
+
+    @property
+    def critical(self) -> bool:
+        return self._critical
+
+    @property
+    def value(self) -> ExtensionTypeVar:
+        return self._value
+
+    def __repr__(self) -> str:
+        return (
+            "<Extension(oid={0.oid}, critical={0.critical}, "
+            "value={0.value})>"
+        ).format(self)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Extension):
+            return NotImplemented
+
+        return (
+            self.oid == other.oid
+            and self.critical == other.critical
+            and self.value == other.value
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.oid, self.critical, self.value))
+
+
+class GeneralNames:
+    def __init__(self, general_names: typing.Iterable[GeneralName]) -> None:
+        general_names = list(general_names)
+        if not all(isinstance(x, GeneralName) for x in general_names):
+            raise TypeError(
+                "Every item in the general_names list must be an "
+                "object conforming to the GeneralName interface"
+            )
+
+        self._general_names = general_names
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods("_general_names")
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Union[
+            typing.Type[DNSName],
+            typing.Type[UniformResourceIdentifier],
+            typing.Type[RFC822Name],
+        ],
+    ) -> typing.List[str]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Type[DirectoryName],
+    ) -> typing.List[Name]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Type[RegisteredID],
+    ) -> typing.List[ObjectIdentifier]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self, type: typing.Type[IPAddress]
+    ) -> typing.List[_IPADDRESS_TYPES]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self, type: typing.Type[OtherName]
+    ) -> typing.List[OtherName]:
+        ...
+
+    def get_values_for_type(
+        self,
+        type: typing.Union[
+            typing.Type[DNSName],
+            typing.Type[DirectoryName],
+            typing.Type[IPAddress],
+            typing.Type[OtherName],
+            typing.Type[RFC822Name],
+            typing.Type[RegisteredID],
+            typing.Type[UniformResourceIdentifier],
+        ],
+    ) -> typing.Union[
+        typing.List[_IPADDRESS_TYPES],
+        typing.List[str],
+        typing.List[OtherName],
+        typing.List[Name],
+        typing.List[ObjectIdentifier],
+    ]:
+        # Return the value of each GeneralName, except for OtherName instances
+        # which we return directly because it has two important properties not
+        # just one value.
+        objs = (i for i in self if isinstance(i, type))
+        if type != OtherName:
+            return [i.value for i in objs]
+        return list(objs)
+
+    def __repr__(self) -> str:
+        return "<GeneralNames({})>".format(self._general_names)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, GeneralNames):
+            return NotImplemented
+
+        return self._general_names == other._general_names
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._general_names))
+
+
+class SubjectAlternativeName(ExtensionType):
+    oid = ExtensionOID.SUBJECT_ALTERNATIVE_NAME
+
+    def __init__(self, general_names: typing.Iterable[GeneralName]) -> None:
+        self._general_names = GeneralNames(general_names)
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods("_general_names")
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Union[
+            typing.Type[DNSName],
+            typing.Type[UniformResourceIdentifier],
+            typing.Type[RFC822Name],
+        ],
+    ) -> typing.List[str]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Type[DirectoryName],
+    ) -> typing.List[Name]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Type[RegisteredID],
+    ) -> typing.List[ObjectIdentifier]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self, type: typing.Type[IPAddress]
+    ) -> typing.List[_IPADDRESS_TYPES]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self, type: typing.Type[OtherName]
+    ) -> typing.List[OtherName]:
+        ...
+
+    def get_values_for_type(
+        self,
+        type: typing.Union[
+            typing.Type[DNSName],
+            typing.Type[DirectoryName],
+            typing.Type[IPAddress],
+            typing.Type[OtherName],
+            typing.Type[RFC822Name],
+            typing.Type[RegisteredID],
+            typing.Type[UniformResourceIdentifier],
+        ],
+    ) -> typing.Union[
+        typing.List[_IPADDRESS_TYPES],
+        typing.List[str],
+        typing.List[OtherName],
+        typing.List[Name],
+        typing.List[ObjectIdentifier],
+    ]:
+        return self._general_names.get_values_for_type(type)
+
+    def __repr__(self) -> str:
+        return "<SubjectAlternativeName({})>".format(self._general_names)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SubjectAlternativeName):
+            return NotImplemented
+
+        return self._general_names == other._general_names
+
+    def __hash__(self) -> int:
+        return hash(self._general_names)
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class IssuerAlternativeName(ExtensionType):
+    oid = ExtensionOID.ISSUER_ALTERNATIVE_NAME
+
+    def __init__(self, general_names: typing.Iterable[GeneralName]) -> None:
+        self._general_names = GeneralNames(general_names)
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods("_general_names")
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Union[
+            typing.Type[DNSName],
+            typing.Type[UniformResourceIdentifier],
+            typing.Type[RFC822Name],
+        ],
+    ) -> typing.List[str]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Type[DirectoryName],
+    ) -> typing.List[Name]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Type[RegisteredID],
+    ) -> typing.List[ObjectIdentifier]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self, type: typing.Type[IPAddress]
+    ) -> typing.List[_IPADDRESS_TYPES]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self, type: typing.Type[OtherName]
+    ) -> typing.List[OtherName]:
+        ...
+
+    def get_values_for_type(
+        self,
+        type: typing.Union[
+            typing.Type[DNSName],
+            typing.Type[DirectoryName],
+            typing.Type[IPAddress],
+            typing.Type[OtherName],
+            typing.Type[RFC822Name],
+            typing.Type[RegisteredID],
+            typing.Type[UniformResourceIdentifier],
+        ],
+    ) -> typing.Union[
+        typing.List[_IPADDRESS_TYPES],
+        typing.List[str],
+        typing.List[OtherName],
+        typing.List[Name],
+        typing.List[ObjectIdentifier],
+    ]:
+        return self._general_names.get_values_for_type(type)
+
+    def __repr__(self) -> str:
+        return "<IssuerAlternativeName({})>".format(self._general_names)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, IssuerAlternativeName):
+            return NotImplemented
+
+        return self._general_names == other._general_names
+
+    def __hash__(self) -> int:
+        return hash(self._general_names)
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class CertificateIssuer(ExtensionType):
+    oid = CRLEntryExtensionOID.CERTIFICATE_ISSUER
+
+    def __init__(self, general_names: typing.Iterable[GeneralName]) -> None:
+        self._general_names = GeneralNames(general_names)
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods("_general_names")
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Union[
+            typing.Type[DNSName],
+            typing.Type[UniformResourceIdentifier],
+            typing.Type[RFC822Name],
+        ],
+    ) -> typing.List[str]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Type[DirectoryName],
+    ) -> typing.List[Name]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self,
+        type: typing.Type[RegisteredID],
+    ) -> typing.List[ObjectIdentifier]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self, type: typing.Type[IPAddress]
+    ) -> typing.List[_IPADDRESS_TYPES]:
+        ...
+
+    @typing.overload
+    def get_values_for_type(
+        self, type: typing.Type[OtherName]
+    ) -> typing.List[OtherName]:
+        ...
+
+    def get_values_for_type(
+        self,
+        type: typing.Union[
+            typing.Type[DNSName],
+            typing.Type[DirectoryName],
+            typing.Type[IPAddress],
+            typing.Type[OtherName],
+            typing.Type[RFC822Name],
+            typing.Type[RegisteredID],
+            typing.Type[UniformResourceIdentifier],
+        ],
+    ) -> typing.Union[
+        typing.List[_IPADDRESS_TYPES],
+        typing.List[str],
+        typing.List[OtherName],
+        typing.List[Name],
+        typing.List[ObjectIdentifier],
+    ]:
+        return self._general_names.get_values_for_type(type)
+
+    def __repr__(self) -> str:
+        return "<CertificateIssuer({})>".format(self._general_names)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CertificateIssuer):
+            return NotImplemented
+
+        return self._general_names == other._general_names
+
+    def __hash__(self) -> int:
+        return hash(self._general_names)
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class CRLReason(ExtensionType):
+    oid = CRLEntryExtensionOID.CRL_REASON
+
+    def __init__(self, reason: ReasonFlags) -> None:
+        if not isinstance(reason, ReasonFlags):
+            raise TypeError("reason must be an element from ReasonFlags")
+
+        self._reason = reason
+
+    def __repr__(self) -> str:
+        return "<CRLReason(reason={})>".format(self._reason)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CRLReason):
+            return NotImplemented
+
+        return self.reason == other.reason
+
+    def __hash__(self) -> int:
+        return hash(self.reason)
+
+    @property
+    def reason(self) -> ReasonFlags:
+        return self._reason
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class InvalidityDate(ExtensionType):
+    oid = CRLEntryExtensionOID.INVALIDITY_DATE
+
+    def __init__(self, invalidity_date: datetime.datetime) -> None:
+        if not isinstance(invalidity_date, datetime.datetime):
+            raise TypeError("invalidity_date must be a datetime.datetime")
+
+        self._invalidity_date = invalidity_date
+
+    def __repr__(self) -> str:
+        return "<InvalidityDate(invalidity_date={})>".format(
+            self._invalidity_date
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, InvalidityDate):
+            return NotImplemented
+
+        return self.invalidity_date == other.invalidity_date
+
+    def __hash__(self) -> int:
+        return hash(self.invalidity_date)
+
+    @property
+    def invalidity_date(self) -> datetime.datetime:
+        return self._invalidity_date
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class PrecertificateSignedCertificateTimestamps(ExtensionType):
+    oid = ExtensionOID.PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS
+
+    def __init__(
+        self,
+        signed_certificate_timestamps: typing.Iterable[
+            SignedCertificateTimestamp
+        ],
+    ) -> None:
+        signed_certificate_timestamps = list(signed_certificate_timestamps)
+        if not all(
+            isinstance(sct, SignedCertificateTimestamp)
+            for sct in signed_certificate_timestamps
+        ):
+            raise TypeError(
+                "Every item in the signed_certificate_timestamps list must be "
+                "a SignedCertificateTimestamp"
+            )
+        self._signed_certificate_timestamps = signed_certificate_timestamps
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods(
+        "_signed_certificate_timestamps"
+    )
+
+    def __repr__(self) -> str:
+        return "<PrecertificateSignedCertificateTimestamps({})>".format(
+            list(self)
+        )
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._signed_certificate_timestamps))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, PrecertificateSignedCertificateTimestamps):
+            return NotImplemented
+
+        return (
+            self._signed_certificate_timestamps
+            == other._signed_certificate_timestamps
+        )
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class SignedCertificateTimestamps(ExtensionType):
+    oid = ExtensionOID.SIGNED_CERTIFICATE_TIMESTAMPS
+
+    def __init__(
+        self,
+        signed_certificate_timestamps: typing.Iterable[
+            SignedCertificateTimestamp
+        ],
+    ) -> None:
+        signed_certificate_timestamps = list(signed_certificate_timestamps)
+        if not all(
+            isinstance(sct, SignedCertificateTimestamp)
+            for sct in signed_certificate_timestamps
+        ):
+            raise TypeError(
+                "Every item in the signed_certificate_timestamps list must be "
+                "a SignedCertificateTimestamp"
+            )
+        self._signed_certificate_timestamps = signed_certificate_timestamps
+
+    __len__, __iter__, __getitem__ = _make_sequence_methods(
+        "_signed_certificate_timestamps"
+    )
+
+    def __repr__(self) -> str:
+        return "<SignedCertificateTimestamps({})>".format(list(self))
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._signed_certificate_timestamps))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SignedCertificateTimestamps):
+            return NotImplemented
+
+        return (
+            self._signed_certificate_timestamps
+            == other._signed_certificate_timestamps
+        )
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class OCSPNonce(ExtensionType):
+    oid = OCSPExtensionOID.NONCE
+
+    def __init__(self, nonce: bytes) -> None:
+        if not isinstance(nonce, bytes):
+            raise TypeError("nonce must be bytes")
+
+        self._nonce = nonce
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, OCSPNonce):
+            return NotImplemented
+
+        return self.nonce == other.nonce
+
+    def __hash__(self) -> int:
+        return hash(self.nonce)
+
+    def __repr__(self) -> str:
+        return "<OCSPNonce(nonce={0.nonce!r})>".format(self)
+
+    @property
+    def nonce(self) -> bytes:
+        return self._nonce
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class IssuingDistributionPoint(ExtensionType):
+    oid = ExtensionOID.ISSUING_DISTRIBUTION_POINT
+
+    def __init__(
+        self,
+        full_name: typing.Optional[typing.Iterable[GeneralName]],
+        relative_name: typing.Optional[RelativeDistinguishedName],
+        only_contains_user_certs: bool,
+        only_contains_ca_certs: bool,
+        only_some_reasons: typing.Optional[typing.FrozenSet[ReasonFlags]],
+        indirect_crl: bool,
+        only_contains_attribute_certs: bool,
+    ) -> None:
+        if full_name is not None:
+            full_name = list(full_name)
+
+        if only_some_reasons and (
+            not isinstance(only_some_reasons, frozenset)
+            or not all(isinstance(x, ReasonFlags) for x in only_some_reasons)
+        ):
+            raise TypeError(
+                "only_some_reasons must be None or frozenset of ReasonFlags"
+            )
+
+        if only_some_reasons and (
+            ReasonFlags.unspecified in only_some_reasons
+            or ReasonFlags.remove_from_crl in only_some_reasons
+        ):
+            raise ValueError(
+                "unspecified and remove_from_crl are not valid reasons in an "
+                "IssuingDistributionPoint"
+            )
+
+        if not (
+            isinstance(only_contains_user_certs, bool)
+            and isinstance(only_contains_ca_certs, bool)
+            and isinstance(indirect_crl, bool)
+            and isinstance(only_contains_attribute_certs, bool)
+        ):
+            raise TypeError(
+                "only_contains_user_certs, only_contains_ca_certs, "
+                "indirect_crl and only_contains_attribute_certs "
+                "must all be boolean."
+            )
+
+        crl_constraints = [
+            only_contains_user_certs,
+            only_contains_ca_certs,
+            indirect_crl,
+            only_contains_attribute_certs,
+        ]
+
+        if len([x for x in crl_constraints if x]) > 1:
+            raise ValueError(
+                "Only one of the following can be set to True: "
+                "only_contains_user_certs, only_contains_ca_certs, "
+                "indirect_crl, only_contains_attribute_certs"
+            )
+
+        if not any(
+            [
+                only_contains_user_certs,
+                only_contains_ca_certs,
+                indirect_crl,
+                only_contains_attribute_certs,
+                full_name,
+                relative_name,
+                only_some_reasons,
+            ]
+        ):
+            raise ValueError(
+                "Cannot create empty extension: "
+                "if only_contains_user_certs, only_contains_ca_certs, "
+                "indirect_crl, and only_contains_attribute_certs are all False"
+                ", then either full_name, relative_name, or only_some_reasons "
+                "must have a value."
+            )
+
+        self._only_contains_user_certs = only_contains_user_certs
+        self._only_contains_ca_certs = only_contains_ca_certs
+        self._indirect_crl = indirect_crl
+        self._only_contains_attribute_certs = only_contains_attribute_certs
+        self._only_some_reasons = only_some_reasons
+        self._full_name = full_name
+        self._relative_name = relative_name
+
+    def __repr__(self) -> str:
+        return (
+            "<IssuingDistributionPoint(full_name={0.full_name}, "
+            "relative_name={0.relative_name}, "
+            "only_contains_user_certs={0.only_contains_user_certs}, "
+            "only_contains_ca_certs={0.only_contains_ca_certs}, "
+            "only_some_reasons={0.only_some_reasons}, "
+            "indirect_crl={0.indirect_crl}, "
+            "only_contains_attribute_certs="
+            "{0.only_contains_attribute_certs})>".format(self)
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, IssuingDistributionPoint):
+            return NotImplemented
+
+        return (
+            self.full_name == other.full_name
+            and self.relative_name == other.relative_name
+            and self.only_contains_user_certs == other.only_contains_user_certs
+            and self.only_contains_ca_certs == other.only_contains_ca_certs
+            and self.only_some_reasons == other.only_some_reasons
+            and self.indirect_crl == other.indirect_crl
+            and self.only_contains_attribute_certs
+            == other.only_contains_attribute_certs
+        )
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.full_name,
+                self.relative_name,
+                self.only_contains_user_certs,
+                self.only_contains_ca_certs,
+                self.only_some_reasons,
+                self.indirect_crl,
+                self.only_contains_attribute_certs,
+            )
+        )
+
+    @property
+    def full_name(self) -> typing.Optional[typing.List[GeneralName]]:
+        return self._full_name
+
+    @property
+    def relative_name(self) -> typing.Optional[RelativeDistinguishedName]:
+        return self._relative_name
+
+    @property
+    def only_contains_user_certs(self) -> bool:
+        return self._only_contains_user_certs
+
+    @property
+    def only_contains_ca_certs(self) -> bool:
+        return self._only_contains_ca_certs
+
+    @property
+    def only_some_reasons(
+        self,
+    ) -> typing.Optional[typing.FrozenSet[ReasonFlags]]:
+        return self._only_some_reasons
+
+    @property
+    def indirect_crl(self) -> bool:
+        return self._indirect_crl
+
+    @property
+    def only_contains_attribute_certs(self) -> bool:
+        return self._only_contains_attribute_certs
+
+    def public_bytes(self) -> bytes:
+        return rust_x509.encode_extension_value(self)
+
+
+class UnrecognizedExtension(ExtensionType):
+    def __init__(self, oid: ObjectIdentifier, value: bytes) -> None:
+        if not isinstance(oid, ObjectIdentifier):
+            raise TypeError("oid must be an ObjectIdentifier")
+        self._oid = oid
+        self._value = value
+
+    @property
+    def oid(self) -> ObjectIdentifier:  # type: ignore[override]
+        return self._oid
+
+    @property
+    def value(self) -> bytes:
+        return self._value
+
+    def __repr__(self) -> str:
+        return (
+            "<UnrecognizedExtension(oid={0.oid}, "
+            "value={0.value!r})>".format(self)
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, UnrecognizedExtension):
+            return NotImplemented
+
+        return self.oid == other.oid and self.value == other.value
+
+    def __hash__(self) -> int:
+        return hash((self.oid, self.value))
+
+    def public_bytes(self) -> bytes:
+        return self.value
diff --git a/myenv/lib/python3.9/site-packages/cryptography/x509/general_name.py b/myenv/lib/python3.9/site-packages/cryptography/x509/general_name.py
new file mode 100644
index 0000000..9939233
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/x509/general_name.py
@@ -0,0 +1,284 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import ipaddress
+import typing
+from email.utils import parseaddr
+
+from cryptography.x509.name import Name
+from cryptography.x509.oid import ObjectIdentifier
+
+
+_IPADDRESS_TYPES = typing.Union[
+    ipaddress.IPv4Address,
+    ipaddress.IPv6Address,
+    ipaddress.IPv4Network,
+    ipaddress.IPv6Network,
+]
+
+
+class UnsupportedGeneralNameType(Exception):
+    pass
+
+
+class GeneralName(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def value(self) -> typing.Any:
+        """
+        Return the value of the object
+        """
+
+
+class RFC822Name(GeneralName):
+    def __init__(self, value: str) -> None:
+        if isinstance(value, str):
+            try:
+                value.encode("ascii")
+            except UnicodeEncodeError:
+                raise ValueError(
+                    "RFC822Name values should be passed as an A-label string. "
+                    "This means unicode characters should be encoded via "
+                    "a library like idna."
+                )
+        else:
+            raise TypeError("value must be string")
+
+        name, address = parseaddr(value)
+        if name or not address:
+            # parseaddr has found a name (e.g. Name <email>) or the entire
+            # value is an empty string.
+            raise ValueError("Invalid rfc822name value")
+
+        self._value = value
+
+    @property
+    def value(self) -> str:
+        return self._value
+
+    @classmethod
+    def _init_without_validation(cls, value: str) -> "RFC822Name":
+        instance = cls.__new__(cls)
+        instance._value = value
+        return instance
+
+    def __repr__(self) -> str:
+        return "<RFC822Name(value={0!r})>".format(self.value)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RFC822Name):
+            return NotImplemented
+
+        return self.value == other.value
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+
+class DNSName(GeneralName):
+    def __init__(self, value: str) -> None:
+        if isinstance(value, str):
+            try:
+                value.encode("ascii")
+            except UnicodeEncodeError:
+                raise ValueError(
+                    "DNSName values should be passed as an A-label string. "
+                    "This means unicode characters should be encoded via "
+                    "a library like idna."
+                )
+        else:
+            raise TypeError("value must be string")
+
+        self._value = value
+
+    @property
+    def value(self) -> str:
+        return self._value
+
+    @classmethod
+    def _init_without_validation(cls, value: str) -> "DNSName":
+        instance = cls.__new__(cls)
+        instance._value = value
+        return instance
+
+    def __repr__(self) -> str:
+        return "<DNSName(value={0!r})>".format(self.value)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DNSName):
+            return NotImplemented
+
+        return self.value == other.value
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+
+class UniformResourceIdentifier(GeneralName):
+    def __init__(self, value: str) -> None:
+        if isinstance(value, str):
+            try:
+                value.encode("ascii")
+            except UnicodeEncodeError:
+                raise ValueError(
+                    "URI values should be passed as an A-label string. "
+                    "This means unicode characters should be encoded via "
+                    "a library like idna."
+                )
+        else:
+            raise TypeError("value must be string")
+
+        self._value = value
+
+    @property
+    def value(self) -> str:
+        return self._value
+
+    @classmethod
+    def _init_without_validation(
+        cls, value: str
+    ) -> "UniformResourceIdentifier":
+        instance = cls.__new__(cls)
+        instance._value = value
+        return instance
+
+    def __repr__(self) -> str:
+        return "<UniformResourceIdentifier(value={0!r})>".format(self.value)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, UniformResourceIdentifier):
+            return NotImplemented
+
+        return self.value == other.value
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+
+class DirectoryName(GeneralName):
+    def __init__(self, value: Name) -> None:
+        if not isinstance(value, Name):
+            raise TypeError("value must be a Name")
+
+        self._value = value
+
+    @property
+    def value(self) -> Name:
+        return self._value
+
+    def __repr__(self) -> str:
+        return "<DirectoryName(value={})>".format(self.value)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DirectoryName):
+            return NotImplemented
+
+        return self.value == other.value
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+
+class RegisteredID(GeneralName):
+    def __init__(self, value: ObjectIdentifier) -> None:
+        if not isinstance(value, ObjectIdentifier):
+            raise TypeError("value must be an ObjectIdentifier")
+
+        self._value = value
+
+    @property
+    def value(self) -> ObjectIdentifier:
+        return self._value
+
+    def __repr__(self) -> str:
+        return "<RegisteredID(value={})>".format(self.value)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RegisteredID):
+            return NotImplemented
+
+        return self.value == other.value
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+
+class IPAddress(GeneralName):
+    def __init__(self, value: _IPADDRESS_TYPES) -> None:
+        if not isinstance(
+            value,
+            (
+                ipaddress.IPv4Address,
+                ipaddress.IPv6Address,
+                ipaddress.IPv4Network,
+                ipaddress.IPv6Network,
+            ),
+        ):
+            raise TypeError(
+                "value must be an instance of ipaddress.IPv4Address, "
+                "ipaddress.IPv6Address, ipaddress.IPv4Network, or "
+                "ipaddress.IPv6Network"
+            )
+
+        self._value = value
+
+    @property
+    def value(self) -> _IPADDRESS_TYPES:
+        return self._value
+
+    def _packed(self) -> bytes:
+        if isinstance(
+            self.value, (ipaddress.IPv4Address, ipaddress.IPv6Address)
+        ):
+            return self.value.packed
+        else:
+            return (
+                self.value.network_address.packed + self.value.netmask.packed
+            )
+
+    def __repr__(self) -> str:
+        return "<IPAddress(value={})>".format(self.value)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, IPAddress):
+            return NotImplemented
+
+        return self.value == other.value
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+
+class OtherName(GeneralName):
+    def __init__(self, type_id: ObjectIdentifier, value: bytes) -> None:
+        if not isinstance(type_id, ObjectIdentifier):
+            raise TypeError("type_id must be an ObjectIdentifier")
+        if not isinstance(value, bytes):
+            raise TypeError("value must be a binary string")
+
+        self._type_id = type_id
+        self._value = value
+
+    @property
+    def type_id(self) -> ObjectIdentifier:
+        return self._type_id
+
+    @property
+    def value(self) -> bytes:
+        return self._value
+
+    def __repr__(self) -> str:
+        return "<OtherName(type_id={}, value={!r})>".format(
+            self.type_id, self.value
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, OtherName):
+            return NotImplemented
+
+        return self.type_id == other.type_id and self.value == other.value
+
+    def __hash__(self) -> int:
+        return hash((self.type_id, self.value))
diff --git a/myenv/lib/python3.9/site-packages/cryptography/x509/name.py b/myenv/lib/python3.9/site-packages/cryptography/x509/name.py
new file mode 100644
index 0000000..4b32115
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/x509/name.py
@@ -0,0 +1,445 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import binascii
+import re
+import sys
+import typing
+import warnings
+
+from cryptography import utils
+from cryptography.hazmat.bindings._rust import (
+    x509 as rust_x509,
+)
+from cryptography.x509.oid import NameOID, ObjectIdentifier
+
+
+class _ASN1Type(utils.Enum):
+    BitString = 3
+    OctetString = 4
+    UTF8String = 12
+    NumericString = 18
+    PrintableString = 19
+    T61String = 20
+    IA5String = 22
+    UTCTime = 23
+    GeneralizedTime = 24
+    VisibleString = 26
+    UniversalString = 28
+    BMPString = 30
+
+
+_ASN1_TYPE_TO_ENUM = {i.value: i for i in _ASN1Type}
+_NAMEOID_DEFAULT_TYPE: typing.Dict[ObjectIdentifier, _ASN1Type] = {
+    NameOID.COUNTRY_NAME: _ASN1Type.PrintableString,
+    NameOID.JURISDICTION_COUNTRY_NAME: _ASN1Type.PrintableString,
+    NameOID.SERIAL_NUMBER: _ASN1Type.PrintableString,
+    NameOID.DN_QUALIFIER: _ASN1Type.PrintableString,
+    NameOID.EMAIL_ADDRESS: _ASN1Type.IA5String,
+    NameOID.DOMAIN_COMPONENT: _ASN1Type.IA5String,
+}
+
+# Type alias
+_OidNameMap = typing.Mapping[ObjectIdentifier, str]
+
+#: Short attribute names from RFC 4514:
+#: https://tools.ietf.org/html/rfc4514#page-7
+_NAMEOID_TO_NAME: _OidNameMap = {
+    NameOID.COMMON_NAME: "CN",
+    NameOID.LOCALITY_NAME: "L",
+    NameOID.STATE_OR_PROVINCE_NAME: "ST",
+    NameOID.ORGANIZATION_NAME: "O",
+    NameOID.ORGANIZATIONAL_UNIT_NAME: "OU",
+    NameOID.COUNTRY_NAME: "C",
+    NameOID.STREET_ADDRESS: "STREET",
+    NameOID.DOMAIN_COMPONENT: "DC",
+    NameOID.USER_ID: "UID",
+}
+_NAME_TO_NAMEOID = {v: k for k, v in _NAMEOID_TO_NAME.items()}
+
+
+def _escape_dn_value(val: typing.Union[str, bytes]) -> str:
+    """Escape special characters in RFC4514 Distinguished Name value."""
+
+    if not val:
+        return ""
+
+    # RFC 4514 Section 2.4 defines the value as being the # (U+0023) character
+    # followed by the hexadecimal encoding of the octets.
+    if isinstance(val, bytes):
+        return "#" + binascii.hexlify(val).decode("utf8")
+
+    # See https://tools.ietf.org/html/rfc4514#section-2.4
+    val = val.replace("\\", "\\\\")
+    val = val.replace('"', '\\"')
+    val = val.replace("+", "\\+")
+    val = val.replace(",", "\\,")
+    val = val.replace(";", "\\;")
+    val = val.replace("<", "\\<")
+    val = val.replace(">", "\\>")
+    val = val.replace("\0", "\\00")
+
+    if val[0] in ("#", " "):
+        val = "\\" + val
+    if val[-1] == " ":
+        val = val[:-1] + "\\ "
+
+    return val
+
+
+def _unescape_dn_value(val: str) -> str:
+    if not val:
+        return ""
+
+    # See https://tools.ietf.org/html/rfc4514#section-3
+
+    # special = escaped / SPACE / SHARP / EQUALS
+    # escaped = DQUOTE / PLUS / COMMA / SEMI / LANGLE / RANGLE
+    def sub(m):
+        val = m.group(1)
+        # Regular escape
+        if len(val) == 1:
+            return val
+        # Hex-value scape
+        return chr(int(val, 16))
+
+    return _RFC4514NameParser._PAIR_RE.sub(sub, val)
+
+
+class NameAttribute:
+    def __init__(
+        self,
+        oid: ObjectIdentifier,
+        value: typing.Union[str, bytes],
+        _type: typing.Optional[_ASN1Type] = None,
+        *,
+        _validate: bool = True,
+    ) -> None:
+        if not isinstance(oid, ObjectIdentifier):
+            raise TypeError(
+                "oid argument must be an ObjectIdentifier instance."
+            )
+        if _type == _ASN1Type.BitString:
+            if oid != NameOID.X500_UNIQUE_IDENTIFIER:
+                raise TypeError(
+                    "oid must be X500_UNIQUE_IDENTIFIER for BitString type."
+                )
+            if not isinstance(value, bytes):
+                raise TypeError("value must be bytes for BitString")
+        else:
+            if not isinstance(value, str):
+                raise TypeError("value argument must be a str")
+
+        if (
+            oid == NameOID.COUNTRY_NAME
+            or oid == NameOID.JURISDICTION_COUNTRY_NAME
+        ):
+            assert isinstance(value, str)
+            c_len = len(value.encode("utf8"))
+            if c_len != 2 and _validate is True:
+                raise ValueError(
+                    "Country name must be a 2 character country code"
+                )
+            elif c_len != 2:
+                warnings.warn(
+                    "Country names should be two characters, but the "
+                    "attribute is {} characters in length.".format(c_len),
+                    stacklevel=2,
+                )
+
+        # The appropriate ASN1 string type varies by OID and is defined across
+        # multiple RFCs including 2459, 3280, and 5280. In general UTF8String
+        # is preferred (2459), but 3280 and 5280 specify several OIDs with
+        # alternate types. This means when we see the sentinel value we need
+        # to look up whether the OID has a non-UTF8 type. If it does, set it
+        # to that. Otherwise, UTF8!
+        if _type is None:
+            _type = _NAMEOID_DEFAULT_TYPE.get(oid, _ASN1Type.UTF8String)
+
+        if not isinstance(_type, _ASN1Type):
+            raise TypeError("_type must be from the _ASN1Type enum")
+
+        self._oid = oid
+        self._value = value
+        self._type = _type
+
+    @property
+    def oid(self) -> ObjectIdentifier:
+        return self._oid
+
+    @property
+    def value(self) -> typing.Union[str, bytes]:
+        return self._value
+
+    @property
+    def rfc4514_attribute_name(self) -> str:
+        """
+        The short attribute name (for example "CN") if available,
+        otherwise the OID dotted string.
+        """
+        return _NAMEOID_TO_NAME.get(self.oid, self.oid.dotted_string)
+
+    def rfc4514_string(
+        self, attr_name_overrides: typing.Optional[_OidNameMap] = None
+    ) -> str:
+        """
+        Format as RFC4514 Distinguished Name string.
+
+        Use short attribute name if available, otherwise fall back to OID
+        dotted string.
+        """
+        attr_name = (
+            attr_name_overrides.get(self.oid) if attr_name_overrides else None
+        )
+        if attr_name is None:
+            attr_name = self.rfc4514_attribute_name
+
+        return f"{attr_name}={_escape_dn_value(self.value)}"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, NameAttribute):
+            return NotImplemented
+
+        return self.oid == other.oid and self.value == other.value
+
+    def __hash__(self) -> int:
+        return hash((self.oid, self.value))
+
+    def __repr__(self) -> str:
+        return "<NameAttribute(oid={0.oid}, value={0.value!r})>".format(self)
+
+
+class RelativeDistinguishedName:
+    def __init__(self, attributes: typing.Iterable[NameAttribute]):
+        attributes = list(attributes)
+        if not attributes:
+            raise ValueError("a relative distinguished name cannot be empty")
+        if not all(isinstance(x, NameAttribute) for x in attributes):
+            raise TypeError("attributes must be an iterable of NameAttribute")
+
+        # Keep list and frozenset to preserve attribute order where it matters
+        self._attributes = attributes
+        self._attribute_set = frozenset(attributes)
+
+        if len(self._attribute_set) != len(attributes):
+            raise ValueError("duplicate attributes are not allowed")
+
+    def get_attributes_for_oid(
+        self, oid: ObjectIdentifier
+    ) -> typing.List[NameAttribute]:
+        return [i for i in self if i.oid == oid]
+
+    def rfc4514_string(
+        self, attr_name_overrides: typing.Optional[_OidNameMap] = None
+    ) -> str:
+        """
+        Format as RFC4514 Distinguished Name string.
+
+        Within each RDN, attributes are joined by '+', although that is rarely
+        used in certificates.
+        """
+        return "+".join(
+            attr.rfc4514_string(attr_name_overrides)
+            for attr in self._attributes
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RelativeDistinguishedName):
+            return NotImplemented
+
+        return self._attribute_set == other._attribute_set
+
+    def __hash__(self) -> int:
+        return hash(self._attribute_set)
+
+    def __iter__(self) -> typing.Iterator[NameAttribute]:
+        return iter(self._attributes)
+
+    def __len__(self) -> int:
+        return len(self._attributes)
+
+    def __repr__(self) -> str:
+        return "<RelativeDistinguishedName({})>".format(self.rfc4514_string())
+
+
+class Name:
+    @typing.overload
+    def __init__(self, attributes: typing.Iterable[NameAttribute]) -> None:
+        ...
+
+    @typing.overload
+    def __init__(
+        self, attributes: typing.Iterable[RelativeDistinguishedName]
+    ) -> None:
+        ...
+
+    def __init__(
+        self,
+        attributes: typing.Iterable[
+            typing.Union[NameAttribute, RelativeDistinguishedName]
+        ],
+    ) -> None:
+        attributes = list(attributes)
+        if all(isinstance(x, NameAttribute) for x in attributes):
+            self._attributes = [
+                RelativeDistinguishedName([typing.cast(NameAttribute, x)])
+                for x in attributes
+            ]
+        elif all(isinstance(x, RelativeDistinguishedName) for x in attributes):
+            self._attributes = typing.cast(
+                typing.List[RelativeDistinguishedName], attributes
+            )
+        else:
+            raise TypeError(
+                "attributes must be a list of NameAttribute"
+                " or a list RelativeDistinguishedName"
+            )
+
+    @classmethod
+    def from_rfc4514_string(cls, data: str) -> "Name":
+        return _RFC4514NameParser(data).parse()
+
+    def rfc4514_string(
+        self, attr_name_overrides: typing.Optional[_OidNameMap] = None
+    ) -> str:
+        """
+        Format as RFC4514 Distinguished Name string.
+        For example 'CN=foobar.com,O=Foo Corp,C=US'
+
+        An X.509 name is a two-level structure: a list of sets of attributes.
+        Each list element is separated by ',' and within each list element, set
+        elements are separated by '+'. The latter is almost never used in
+        real world certificates. According to RFC4514 section 2.1 the
+        RDNSequence must be reversed when converting to string representation.
+        """
+        return ",".join(
+            attr.rfc4514_string(attr_name_overrides)
+            for attr in reversed(self._attributes)
+        )
+
+    def get_attributes_for_oid(
+        self, oid: ObjectIdentifier
+    ) -> typing.List[NameAttribute]:
+        return [i for i in self if i.oid == oid]
+
+    @property
+    def rdns(self) -> typing.List[RelativeDistinguishedName]:
+        return self._attributes
+
+    def public_bytes(self, backend: typing.Any = None) -> bytes:
+        return rust_x509.encode_name_bytes(self)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Name):
+            return NotImplemented
+
+        return self._attributes == other._attributes
+
+    def __hash__(self) -> int:
+        # TODO: this is relatively expensive, if this looks like a bottleneck
+        # for you, consider optimizing!
+        return hash(tuple(self._attributes))
+
+    def __iter__(self) -> typing.Iterator[NameAttribute]:
+        for rdn in self._attributes:
+            for ava in rdn:
+                yield ava
+
+    def __len__(self) -> int:
+        return sum(len(rdn) for rdn in self._attributes)
+
+    def __repr__(self) -> str:
+        rdns = ",".join(attr.rfc4514_string() for attr in self._attributes)
+        return "<Name({})>".format(rdns)
+
+
+class _RFC4514NameParser:
+    _OID_RE = re.compile(r"(0|([1-9]\d*))(\.(0|([1-9]\d*)))+")
+    _DESCR_RE = re.compile(r"[a-zA-Z][a-zA-Z\d-]*")
+
+    _PAIR = r"\\([\\ #=\"\+,;<>]|[\da-zA-Z]{2})"
+    _PAIR_RE = re.compile(_PAIR)
+    _LUTF1 = r"[\x01-\x1f\x21\x24-\x2A\x2D-\x3A\x3D\x3F-\x5B\x5D-\x7F]"
+    _SUTF1 = r"[\x01-\x21\x23-\x2A\x2D-\x3A\x3D\x3F-\x5B\x5D-\x7F]"
+    _TUTF1 = r"[\x01-\x1F\x21\x23-\x2A\x2D-\x3A\x3D\x3F-\x5B\x5D-\x7F]"
+    _UTFMB = rf"[\x80-{chr(sys.maxunicode)}]"
+    _LEADCHAR = rf"{_LUTF1}|{_UTFMB}"
+    _STRINGCHAR = rf"{_SUTF1}|{_UTFMB}"
+    _TRAILCHAR = rf"{_TUTF1}|{_UTFMB}"
+    _STRING_RE = re.compile(
+        rf"""
+        (
+            ({_LEADCHAR}|{_PAIR})
+            (
+                ({_STRINGCHAR}|{_PAIR})*
+                ({_TRAILCHAR}|{_PAIR})
+            )?
+        )?
+        """,
+        re.VERBOSE,
+    )
+    _HEXSTRING_RE = re.compile(r"#([\da-zA-Z]{2})+")
+
+    def __init__(self, data: str) -> None:
+        self._data = data
+        self._idx = 0
+
+    def _has_data(self) -> bool:
+        return self._idx < len(self._data)
+
+    def _peek(self) -> typing.Optional[str]:
+        if self._has_data():
+            return self._data[self._idx]
+        return None
+
+    def _read_char(self, ch: str) -> None:
+        if self._peek() != ch:
+            raise ValueError
+        self._idx += 1
+
+    def _read_re(self, pat) -> str:
+        match = pat.match(self._data, pos=self._idx)
+        if match is None:
+            raise ValueError
+        val = match.group()
+        self._idx += len(val)
+        return val
+
+    def parse(self) -> Name:
+        rdns = [self._parse_rdn()]
+
+        while self._has_data():
+            self._read_char(",")
+            rdns.append(self._parse_rdn())
+
+        return Name(rdns)
+
+    def _parse_rdn(self) -> RelativeDistinguishedName:
+        nas = [self._parse_na()]
+        while self._peek() == "+":
+            self._read_char("+")
+            nas.append(self._parse_na())
+
+        return RelativeDistinguishedName(nas)
+
+    def _parse_na(self) -> NameAttribute:
+        try:
+            oid_value = self._read_re(self._OID_RE)
+        except ValueError:
+            name = self._read_re(self._DESCR_RE)
+            oid = _NAME_TO_NAMEOID.get(name)
+            if oid is None:
+                raise ValueError
+        else:
+            oid = ObjectIdentifier(oid_value)
+
+        self._read_char("=")
+        if self._peek() == "#":
+            value = self._read_re(self._HEXSTRING_RE)
+            value = binascii.unhexlify(value[1:]).decode()
+        else:
+            raw_value = self._read_re(self._STRING_RE)
+            value = _unescape_dn_value(raw_value)
+
+        return NameAttribute(oid, value)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/x509/ocsp.py b/myenv/lib/python3.9/site-packages/cryptography/x509/ocsp.py
new file mode 100644
index 0000000..c01e77a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/x509/ocsp.py
@@ -0,0 +1,551 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+import abc
+import datetime
+import typing
+
+from cryptography import utils
+from cryptography import x509
+from cryptography.hazmat.bindings._rust import ocsp
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric.types import (
+    CERTIFICATE_PRIVATE_KEY_TYPES,
+)
+from cryptography.x509.base import (
+    _EARLIEST_UTC_TIME,
+    _convert_to_naive_utc_time,
+    _reject_duplicate_extension,
+)
+
+
+class OCSPResponderEncoding(utils.Enum):
+    HASH = "By Hash"
+    NAME = "By Name"
+
+
+class OCSPResponseStatus(utils.Enum):
+    SUCCESSFUL = 0
+    MALFORMED_REQUEST = 1
+    INTERNAL_ERROR = 2
+    TRY_LATER = 3
+    SIG_REQUIRED = 5
+    UNAUTHORIZED = 6
+
+
+_ALLOWED_HASHES = (
+    hashes.SHA1,
+    hashes.SHA224,
+    hashes.SHA256,
+    hashes.SHA384,
+    hashes.SHA512,
+)
+
+
+def _verify_algorithm(algorithm: hashes.HashAlgorithm) -> None:
+    if not isinstance(algorithm, _ALLOWED_HASHES):
+        raise ValueError(
+            "Algorithm must be SHA1, SHA224, SHA256, SHA384, or SHA512"
+        )
+
+
+class OCSPCertStatus(utils.Enum):
+    GOOD = 0
+    REVOKED = 1
+    UNKNOWN = 2
+
+
+class _SingleResponse:
+    def __init__(
+        self,
+        cert: x509.Certificate,
+        issuer: x509.Certificate,
+        algorithm: hashes.HashAlgorithm,
+        cert_status: OCSPCertStatus,
+        this_update: datetime.datetime,
+        next_update: typing.Optional[datetime.datetime],
+        revocation_time: typing.Optional[datetime.datetime],
+        revocation_reason: typing.Optional[x509.ReasonFlags],
+    ):
+        if not isinstance(cert, x509.Certificate) or not isinstance(
+            issuer, x509.Certificate
+        ):
+            raise TypeError("cert and issuer must be a Certificate")
+
+        _verify_algorithm(algorithm)
+        if not isinstance(this_update, datetime.datetime):
+            raise TypeError("this_update must be a datetime object")
+        if next_update is not None and not isinstance(
+            next_update, datetime.datetime
+        ):
+            raise TypeError("next_update must be a datetime object or None")
+
+        self._cert = cert
+        self._issuer = issuer
+        self._algorithm = algorithm
+        self._this_update = this_update
+        self._next_update = next_update
+
+        if not isinstance(cert_status, OCSPCertStatus):
+            raise TypeError(
+                "cert_status must be an item from the OCSPCertStatus enum"
+            )
+        if cert_status is not OCSPCertStatus.REVOKED:
+            if revocation_time is not None:
+                raise ValueError(
+                    "revocation_time can only be provided if the certificate "
+                    "is revoked"
+                )
+            if revocation_reason is not None:
+                raise ValueError(
+                    "revocation_reason can only be provided if the certificate"
+                    " is revoked"
+                )
+        else:
+            if not isinstance(revocation_time, datetime.datetime):
+                raise TypeError("revocation_time must be a datetime object")
+
+            revocation_time = _convert_to_naive_utc_time(revocation_time)
+            if revocation_time < _EARLIEST_UTC_TIME:
+                raise ValueError(
+                    "The revocation_time must be on or after"
+                    " 1950 January 1."
+                )
+
+            if revocation_reason is not None and not isinstance(
+                revocation_reason, x509.ReasonFlags
+            ):
+                raise TypeError(
+                    "revocation_reason must be an item from the ReasonFlags "
+                    "enum or None"
+                )
+
+        self._cert_status = cert_status
+        self._revocation_time = revocation_time
+        self._revocation_reason = revocation_reason
+
+
+class OCSPRequest(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def issuer_key_hash(self) -> bytes:
+        """
+        The hash of the issuer public key
+        """
+
+    @abc.abstractproperty
+    def issuer_name_hash(self) -> bytes:
+        """
+        The hash of the issuer name
+        """
+
+    @abc.abstractproperty
+    def hash_algorithm(self) -> hashes.HashAlgorithm:
+        """
+        The hash algorithm used in the issuer name and key hashes
+        """
+
+    @abc.abstractproperty
+    def serial_number(self) -> int:
+        """
+        The serial number of the cert whose status is being checked
+        """
+
+    @abc.abstractmethod
+    def public_bytes(self, encoding: serialization.Encoding) -> bytes:
+        """
+        Serializes the request to DER
+        """
+
+    @abc.abstractproperty
+    def extensions(self) -> x509.Extensions:
+        """
+        The list of request extensions. Not single request extensions.
+        """
+
+
+class OCSPSingleResponse(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def certificate_status(self) -> OCSPCertStatus:
+        """
+        The status of the certificate (an element from the OCSPCertStatus enum)
+        """
+
+    @abc.abstractproperty
+    def revocation_time(self) -> typing.Optional[datetime.datetime]:
+        """
+        The date of when the certificate was revoked or None if not
+        revoked.
+        """
+
+    @abc.abstractproperty
+    def revocation_reason(self) -> typing.Optional[x509.ReasonFlags]:
+        """
+        The reason the certificate was revoked or None if not specified or
+        not revoked.
+        """
+
+    @abc.abstractproperty
+    def this_update(self) -> datetime.datetime:
+        """
+        The most recent time at which the status being indicated is known by
+        the responder to have been correct
+        """
+
+    @abc.abstractproperty
+    def next_update(self) -> typing.Optional[datetime.datetime]:
+        """
+        The time when newer information will be available
+        """
+
+    @abc.abstractproperty
+    def issuer_key_hash(self) -> bytes:
+        """
+        The hash of the issuer public key
+        """
+
+    @abc.abstractproperty
+    def issuer_name_hash(self) -> bytes:
+        """
+        The hash of the issuer name
+        """
+
+    @abc.abstractproperty
+    def hash_algorithm(self) -> hashes.HashAlgorithm:
+        """
+        The hash algorithm used in the issuer name and key hashes
+        """
+
+    @abc.abstractproperty
+    def serial_number(self) -> int:
+        """
+        The serial number of the cert whose status is being checked
+        """
+
+
+class OCSPResponse(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def responses(self) -> typing.Iterator[OCSPSingleResponse]:
+        """
+        An iterator over the individual SINGLERESP structures in the
+        response
+        """
+
+    @abc.abstractproperty
+    def response_status(self) -> OCSPResponseStatus:
+        """
+        The status of the response. This is a value from the OCSPResponseStatus
+        enumeration
+        """
+
+    @abc.abstractproperty
+    def signature_algorithm_oid(self) -> x509.ObjectIdentifier:
+        """
+        The ObjectIdentifier of the signature algorithm
+        """
+
+    @abc.abstractproperty
+    def signature_hash_algorithm(
+        self,
+    ) -> typing.Optional[hashes.HashAlgorithm]:
+        """
+        Returns a HashAlgorithm corresponding to the type of the digest signed
+        """
+
+    @abc.abstractproperty
+    def signature(self) -> bytes:
+        """
+        The signature bytes
+        """
+
+    @abc.abstractproperty
+    def tbs_response_bytes(self) -> bytes:
+        """
+        The tbsResponseData bytes
+        """
+
+    @abc.abstractproperty
+    def certificates(self) -> typing.List[x509.Certificate]:
+        """
+        A list of certificates used to help build a chain to verify the OCSP
+        response. This situation occurs when the OCSP responder uses a delegate
+        certificate.
+        """
+
+    @abc.abstractproperty
+    def responder_key_hash(self) -> typing.Optional[bytes]:
+        """
+        The responder's key hash or None
+        """
+
+    @abc.abstractproperty
+    def responder_name(self) -> typing.Optional[x509.Name]:
+        """
+        The responder's Name or None
+        """
+
+    @abc.abstractproperty
+    def produced_at(self) -> datetime.datetime:
+        """
+        The time the response was produced
+        """
+
+    @abc.abstractproperty
+    def certificate_status(self) -> OCSPCertStatus:
+        """
+        The status of the certificate (an element from the OCSPCertStatus enum)
+        """
+
+    @abc.abstractproperty
+    def revocation_time(self) -> typing.Optional[datetime.datetime]:
+        """
+        The date of when the certificate was revoked or None if not
+        revoked.
+        """
+
+    @abc.abstractproperty
+    def revocation_reason(self) -> typing.Optional[x509.ReasonFlags]:
+        """
+        The reason the certificate was revoked or None if not specified or
+        not revoked.
+        """
+
+    @abc.abstractproperty
+    def this_update(self) -> datetime.datetime:
+        """
+        The most recent time at which the status being indicated is known by
+        the responder to have been correct
+        """
+
+    @abc.abstractproperty
+    def next_update(self) -> typing.Optional[datetime.datetime]:
+        """
+        The time when newer information will be available
+        """
+
+    @abc.abstractproperty
+    def issuer_key_hash(self) -> bytes:
+        """
+        The hash of the issuer public key
+        """
+
+    @abc.abstractproperty
+    def issuer_name_hash(self) -> bytes:
+        """
+        The hash of the issuer name
+        """
+
+    @abc.abstractproperty
+    def hash_algorithm(self) -> hashes.HashAlgorithm:
+        """
+        The hash algorithm used in the issuer name and key hashes
+        """
+
+    @abc.abstractproperty
+    def serial_number(self) -> int:
+        """
+        The serial number of the cert whose status is being checked
+        """
+
+    @abc.abstractproperty
+    def extensions(self) -> x509.Extensions:
+        """
+        The list of response extensions. Not single response extensions.
+        """
+
+    @abc.abstractproperty
+    def single_extensions(self) -> x509.Extensions:
+        """
+        The list of single response extensions. Not response extensions.
+        """
+
+    @abc.abstractmethod
+    def public_bytes(self, encoding: serialization.Encoding) -> bytes:
+        """
+        Serializes the response to DER
+        """
+
+
+class OCSPRequestBuilder:
+    def __init__(
+        self,
+        request: typing.Optional[
+            typing.Tuple[
+                x509.Certificate, x509.Certificate, hashes.HashAlgorithm
+            ]
+        ] = None,
+        extensions: typing.List[x509.Extension[x509.ExtensionType]] = [],
+    ) -> None:
+        self._request = request
+        self._extensions = extensions
+
+    def add_certificate(
+        self,
+        cert: x509.Certificate,
+        issuer: x509.Certificate,
+        algorithm: hashes.HashAlgorithm,
+    ) -> "OCSPRequestBuilder":
+        if self._request is not None:
+            raise ValueError("Only one certificate can be added to a request")
+
+        _verify_algorithm(algorithm)
+        if not isinstance(cert, x509.Certificate) or not isinstance(
+            issuer, x509.Certificate
+        ):
+            raise TypeError("cert and issuer must be a Certificate")
+
+        return OCSPRequestBuilder((cert, issuer, algorithm), self._extensions)
+
+    def add_extension(
+        self, extval: x509.ExtensionType, critical: bool
+    ) -> "OCSPRequestBuilder":
+        if not isinstance(extval, x509.ExtensionType):
+            raise TypeError("extension must be an ExtensionType")
+
+        extension = x509.Extension(extval.oid, critical, extval)
+        _reject_duplicate_extension(extension, self._extensions)
+
+        return OCSPRequestBuilder(
+            self._request, self._extensions + [extension]
+        )
+
+    def build(self) -> OCSPRequest:
+        if self._request is None:
+            raise ValueError("You must add a certificate before building")
+
+        return ocsp.create_ocsp_request(self)
+
+
+class OCSPResponseBuilder:
+    def __init__(
+        self,
+        response: typing.Optional[_SingleResponse] = None,
+        responder_id: typing.Optional[
+            typing.Tuple[x509.Certificate, OCSPResponderEncoding]
+        ] = None,
+        certs: typing.Optional[typing.List[x509.Certificate]] = None,
+        extensions: typing.List[x509.Extension[x509.ExtensionType]] = [],
+    ):
+        self._response = response
+        self._responder_id = responder_id
+        self._certs = certs
+        self._extensions = extensions
+
+    def add_response(
+        self,
+        cert: x509.Certificate,
+        issuer: x509.Certificate,
+        algorithm: hashes.HashAlgorithm,
+        cert_status: OCSPCertStatus,
+        this_update: datetime.datetime,
+        next_update: typing.Optional[datetime.datetime],
+        revocation_time: typing.Optional[datetime.datetime],
+        revocation_reason: typing.Optional[x509.ReasonFlags],
+    ) -> "OCSPResponseBuilder":
+        if self._response is not None:
+            raise ValueError("Only one response per OCSPResponse.")
+
+        singleresp = _SingleResponse(
+            cert,
+            issuer,
+            algorithm,
+            cert_status,
+            this_update,
+            next_update,
+            revocation_time,
+            revocation_reason,
+        )
+        return OCSPResponseBuilder(
+            singleresp,
+            self._responder_id,
+            self._certs,
+            self._extensions,
+        )
+
+    def responder_id(
+        self, encoding: OCSPResponderEncoding, responder_cert: x509.Certificate
+    ) -> "OCSPResponseBuilder":
+        if self._responder_id is not None:
+            raise ValueError("responder_id can only be set once")
+        if not isinstance(responder_cert, x509.Certificate):
+            raise TypeError("responder_cert must be a Certificate")
+        if not isinstance(encoding, OCSPResponderEncoding):
+            raise TypeError(
+                "encoding must be an element from OCSPResponderEncoding"
+            )
+
+        return OCSPResponseBuilder(
+            self._response,
+            (responder_cert, encoding),
+            self._certs,
+            self._extensions,
+        )
+
+    def certificates(
+        self, certs: typing.Iterable[x509.Certificate]
+    ) -> "OCSPResponseBuilder":
+        if self._certs is not None:
+            raise ValueError("certificates may only be set once")
+        certs = list(certs)
+        if len(certs) == 0:
+            raise ValueError("certs must not be an empty list")
+        if not all(isinstance(x, x509.Certificate) for x in certs):
+            raise TypeError("certs must be a list of Certificates")
+        return OCSPResponseBuilder(
+            self._response,
+            self._responder_id,
+            certs,
+            self._extensions,
+        )
+
+    def add_extension(
+        self, extval: x509.ExtensionType, critical: bool
+    ) -> "OCSPResponseBuilder":
+        if not isinstance(extval, x509.ExtensionType):
+            raise TypeError("extension must be an ExtensionType")
+
+        extension = x509.Extension(extval.oid, critical, extval)
+        _reject_duplicate_extension(extension, self._extensions)
+
+        return OCSPResponseBuilder(
+            self._response,
+            self._responder_id,
+            self._certs,
+            self._extensions + [extension],
+        )
+
+    def sign(
+        self,
+        private_key: CERTIFICATE_PRIVATE_KEY_TYPES,
+        algorithm: typing.Optional[hashes.HashAlgorithm],
+    ) -> OCSPResponse:
+        if self._response is None:
+            raise ValueError("You must add a response before signing")
+        if self._responder_id is None:
+            raise ValueError("You must add a responder_id before signing")
+
+        return ocsp.create_ocsp_response(
+            OCSPResponseStatus.SUCCESSFUL, self, private_key, algorithm
+        )
+
+    @classmethod
+    def build_unsuccessful(
+        cls, response_status: OCSPResponseStatus
+    ) -> OCSPResponse:
+        if not isinstance(response_status, OCSPResponseStatus):
+            raise TypeError(
+                "response_status must be an item from OCSPResponseStatus"
+            )
+        if response_status is OCSPResponseStatus.SUCCESSFUL:
+            raise ValueError("response_status cannot be SUCCESSFUL")
+
+        return ocsp.create_ocsp_response(response_status, None, None, None)
+
+
+def load_der_ocsp_request(data: bytes) -> OCSPRequest:
+    return ocsp.load_der_ocsp_request(data)
+
+
+def load_der_ocsp_response(data: bytes) -> OCSPResponse:
+    return ocsp.load_der_ocsp_response(data)
diff --git a/myenv/lib/python3.9/site-packages/cryptography/x509/oid.py b/myenv/lib/python3.9/site-packages/cryptography/x509/oid.py
new file mode 100644
index 0000000..9bfac75
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/cryptography/x509/oid.py
@@ -0,0 +1,32 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from cryptography.hazmat._oid import (
+    AttributeOID,
+    AuthorityInformationAccessOID,
+    CRLEntryExtensionOID,
+    CertificatePoliciesOID,
+    ExtendedKeyUsageOID,
+    ExtensionOID,
+    NameOID,
+    OCSPExtensionOID,
+    ObjectIdentifier,
+    SignatureAlgorithmOID,
+    SubjectInformationAccessOID,
+)
+
+
+__all__ = [
+    "AttributeOID",
+    "AuthorityInformationAccessOID",
+    "CRLEntryExtensionOID",
+    "CertificatePoliciesOID",
+    "ExtendedKeyUsageOID",
+    "ExtensionOID",
+    "NameOID",
+    "OCSPExtensionOID",
+    "ObjectIdentifier",
+    "SignatureAlgorithmOID",
+    "SubjectInformationAccessOID",
+]
diff --git a/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/LICENSE
new file mode 100644
index 0000000..6e9cde5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/LICENSE
@@ -0,0 +1,35 @@
+Copyright (c) 2004-2016 California Institute of Technology.
+Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+All rights reserved.
+
+This software is available subject to the conditions and terms laid
+out below. By downloading and using this software you are agreeing
+to the following conditions.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met::
+
+    - Redistribution of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    - Redistribution in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentations and/or other materials provided with the distribution.
+
+    - Neither the names of the copyright holders nor the names of any of
+      the 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/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/METADATA
new file mode 100644
index 0000000..250218c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/METADATA
@@ -0,0 +1,269 @@
+Metadata-Version: 2.1
+Name: dill
+Version: 0.3.5.1
+Summary: serialize all of python
+Home-page: https://github.com/uqfoundation/dill
+Download-URL: https://pypi.org/project/dill/#files
+Author: Mike McKerns
+Author-email: mmckerns@uqfoundation.org
+Maintainer: Mike McKerns
+Maintainer-email: mmckerns@uqfoundation.org
+License: 3-clause BSD
+Project-URL: Documentation, http://dill.rtfd.io
+Project-URL: Source Code, https://github.com/uqfoundation/dill
+Project-URL: Bug Tracker, https://github.com/uqfoundation/dill/issues
+Platform: Linux
+Platform: Windows
+Platform: Mac
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*
+License-File: LICENSE
+Provides-Extra: graph
+Requires-Dist: objgraph (>=1.7.2) ; extra == 'graph'
+Provides-Extra: readline
+
+-----------------------------
+dill: serialize all of python
+-----------------------------
+
+About Dill
+==========
+
+``dill`` extends python's ``pickle`` module for serializing and de-serializing
+python objects to the majority of the built-in python types. Serialization
+is the process of converting an object to a byte stream, and the inverse
+of which is converting a byte stream back to a python object hierarchy.
+
+``dill`` provides the user the same interface as the ``pickle`` module, and
+also includes some additional features. In addition to pickling python
+objects, ``dill`` provides the ability to save the state of an interpreter
+session in a single command.  Hence, it would be feasable to save an
+interpreter session, close the interpreter, ship the pickled file to
+another computer, open a new interpreter, unpickle the session and
+thus continue from the 'saved' state of the original interpreter
+session.
+
+``dill`` can be used to store python objects to a file, but the primary
+usage is to send python objects across the network as a byte stream.
+``dill`` is quite flexible, and allows arbitrary user defined classes
+and functions to be serialized.  Thus ``dill`` is not intended to be
+secure against erroneously or maliciously constructed data. It is
+left to the user to decide whether the data they unpickle is from
+a trustworthy source.
+
+``dill`` is part of ``pathos``, a python framework for heterogeneous computing.
+``dill`` is in active development, so any user feedback, bug reports, comments,
+or suggestions are highly appreciated.  A list of issues is located at https://github.com/uqfoundation/dill/issues, with a legacy list maintained at https://uqfoundation.github.io/project/pathos/query.
+
+
+Major Features
+==============
+
+``dill`` can pickle the following standard types:
+
+    - none, type, bool, int, long, float, complex, str, unicode,
+    - tuple, list, dict, file, buffer, builtin,
+    - both old and new style classes,
+    - instances of old and new style classes,
+    - set, frozenset, array, functions, exceptions
+
+``dill`` can also pickle more 'exotic' standard types:
+
+    - functions with yields, nested functions, lambdas,
+    - cell, method, unboundmethod, module, code, methodwrapper,
+    - dictproxy, methoddescriptor, getsetdescriptor, memberdescriptor,
+    - wrapperdescriptor, xrange, slice,
+    - notimplemented, ellipsis, quit
+
+``dill`` cannot yet pickle these standard types:
+
+    - frame, generator, traceback
+
+``dill`` also provides the capability to:
+
+    - save and load python interpreter sessions
+    - save and extract the source code from functions and classes
+    - interactively diagnose pickling errors
+
+
+Current Release
+===============
+
+The latest released version of ``dill`` is available from:
+
+    https://pypi.org/project/dill
+
+``dill`` is distributed under a 3-clause BSD license.
+
+
+Development Version
+===================
+
+You can get the latest development version with all the shiny new features at:
+
+    https://github.com/uqfoundation
+
+If you have a new contribution, please submit a pull request.
+
+
+Installation
+============
+
+``dill`` can be installed with ``pip``::
+
+    $ pip install dill
+
+To optionally include the ``objgraph`` diagnostic tool in the install::
+
+    $ pip install dill[graph]
+
+For windows users, to optionally install session history tools::
+
+    $ pip install dill[readline]
+
+
+Requirements
+============
+
+``dill`` requires:
+
+    - ``python`` (or ``pypy``), **==2.7** or **>=3.7**
+    - ``setuptools``, **>=42**
+
+Optional requirements:
+
+    - ``objgraph``, **>=1.7.2**
+    - ``pyreadline``, **>=1.7.1** (on windows)
+
+
+Basic Usage
+===========
+
+``dill`` is a drop-in replacement for ``pickle``. Existing code can be
+updated to allow complete pickling using::
+
+    >>> import dill as pickle
+
+or::
+
+    >>> from dill import dumps, loads
+
+``dumps`` converts the object to a unique byte string, and ``loads`` performs
+the inverse operation::
+
+    >>> squared = lambda x: x**2
+    >>> loads(dumps(squared))(3)
+    9
+
+There are a number of options to control serialization which are provided
+as keyword arguments to several ``dill`` functions:
+
+* with *protocol*, the pickle protocol level can be set. This uses the
+  same value as the ``pickle`` module, *HIGHEST_PROTOCOL* or *DEFAULT_PROTOCOL*.
+* with *byref=True*, ``dill`` to behave a lot more like pickle with
+  certain objects (like modules) pickled by reference as opposed to
+  attempting to pickle the object itself.
+* with *recurse=True*, objects referred to in the global dictionary are
+  recursively traced and pickled, instead of the default behavior of
+  attempting to store the entire global dictionary.
+* with *fmode*, the contents of the file can be pickled along with the file
+  handle, which is useful if the object is being sent over the wire to a
+  remote system which does not have the original file on disk. Options are
+  *HANDLE_FMODE* for just the handle, *CONTENTS_FMODE* for the file content
+  and *FILE_FMODE* for content and handle.
+* with *ignore=False*, objects reconstructed with types defined in the
+  top-level script environment use the existing type in the environment
+  rather than a possibly different reconstructed type.
+
+The default serialization can also be set globally in *dill.settings*.
+Thus, we can modify how ``dill`` handles references to the global dictionary
+locally or globally::
+
+    >>> import dill.settings
+    >>> dumps(absolute) == dumps(absolute, recurse=True)
+    False
+    >>> dill.settings['recurse'] = True
+    >>> dumps(absolute) == dumps(absolute, recurse=True)
+    True
+
+``dill`` also includes source code inspection, as an alternate to pickling::
+
+    >>> import dill.source
+    >>> print(dill.source.getsource(squared))
+    squared = lambda x:x**2
+
+To aid in debugging pickling issues, use *dill.detect* which provides
+tools like pickle tracing::
+
+    >>> import dill.detect
+    >>> dill.detect.trace(True)
+    >>> f = dumps(squared)
+    F1: <function <lambda> at 0x108899e18>
+    F2: <function _create_function at 0x108db7488>
+    # F2
+    Co: <code object <lambda> at 0x10866a270, file "<stdin>", line 1>
+    F2: <function _create_code at 0x108db7510>
+    # F2
+    # Co
+    D1: <dict object at 0x10862b3f0>
+    # D1
+    D2: <dict object at 0x108e42ee8>
+    # D2
+    # F1
+    >>> dill.detect.trace(False)
+
+With trace, we see how ``dill`` stored the lambda (``F1``) by first storing
+``_create_function``, the underlying code object (``Co``) and ``_create_code``
+(which is used to handle code objects), then we handle the reference to
+the global dict (``D2``).  A ``#`` marks when the object is actually stored.
+
+
+More Information
+================
+
+Probably the best way to get started is to look at the documentation at
+http://dill.rtfd.io. Also see ``dill.tests`` for a set of scripts that
+demonstrate how ``dill`` can serialize different python objects. You can
+run the test suite with ``python -m dill.tests``. The contents of any
+pickle file can be examined with ``undill``.  As ``dill`` conforms to
+the ``pickle`` interface, the examples and documentation found at
+http://docs.python.org/library/pickle.html also apply to ``dill``
+if one will ``import dill as pickle``. The source code is also generally
+well documented, so further questions may be resolved by inspecting the
+code itself. Please feel free to submit a ticket on github, or ask a
+question on stackoverflow (**@Mike McKerns**).
+If you would like to share how you use ``dill`` in your work, please send
+an email (to **mmckerns at uqfoundation dot org**).
+
+
+Citation
+========
+
+If you use ``dill`` to do research that leads to publication, we ask that you
+acknowledge use of ``dill`` by citing the following in your publication::
+
+    M.M. McKerns, L. Strand, T. Sullivan, A. Fang, M.A.G. Aivazis,
+    "Building a framework for predictive science", Proceedings of
+    the 10th Python in Science Conference, 2011;
+    http://arxiv.org/pdf/1202.1056
+
+    Michael McKerns and Michael Aivazis,
+    "pathos: a framework for heterogeneous computing", 2010- ;
+    https://uqfoundation.github.io/project/pathos
+
+Please see https://uqfoundation.github.io/project/pathos or
+http://arxiv.org/pdf/1202.1056 for further information.
diff --git a/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/RECORD
new file mode 100644
index 0000000..da83252
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/RECORD
@@ -0,0 +1,44 @@
+dill/__diff.py,sha256=66V4Y3jCZXL7qpCrxp2Emvk8XW-TUqgco_D4kdjvsu4,7211
+dill/__init__.py,sha256=hxoYKydGFTrNUnQArWKrM_ITy83xWAd20fjjgQrK6vU,13437
+dill/_dill.py,sha256=kc3fyUgZQZWxa_6nNkCRO8yumVvMizB01P_StU66MTU,81628
+dill/_objects.py,sha256=Ojaz1_gGrTegRSYCH_-uV8d3RvLXGwNdJKitqcjTZJo,20432
+dill/_shims.py,sha256=RzQ8pGN--AtOc5qnlEprjcVPvpiT79Q77TdtVyl22Gg,9730
+dill/detect.py,sha256=qpaHJXMWMklFDOurFyyN5PLUgkp_wD2nq6acyENqKVM,12336
+dill/objtypes.py,sha256=l3lfnIox6YJQXN-kXejlajubu-rAAfZ8alQF73l2V3U,736
+dill/pointers.py,sha256=7NIitFkL91Z0-_kTBHXGEqL8seI9qWVouFbykgDlcUw,4467
+dill/settings.py,sha256=Waa57PLciMqHzVhFkGEPmObeweLXruDl86tsWXuhb9Y,719
+dill/source.py,sha256=K6Gds4WbAa1Byv7yX-yqbO_njdt_CHLYwcr2NiVpQEM,44917
+dill/temp.py,sha256=yhV-agXaEweDfzzFVNJQCzQ8osTe4ywCvoSjpCft-LM,8242
+dill/tests/__init__.py,sha256=vZabTjRnwYaN-v3uL2fJBqKqj0T7_9Omwy63JSigvTA,501
+dill/tests/__main__.py,sha256=lxSBOWQpr8CWLrlrwZHhIOwS5bbvnU0wzTzwEnJpFVs,834
+dill/tests/test_check.py,sha256=aoqn8iGaJ_v5gP2wrMSDQeEr3QLbuvkARv7FPAkI1_U,1278
+dill/tests/test_classdef.py,sha256=1gkzO-Re6m0LvzrEKbddhPUWbO2NOdbCgBXDDHjPuvM,6944
+dill/tests/test_detect.py,sha256=btoQKJ-K4jeJlmvGoIkTaFak7lHM4OyglgPdbJ8yEsc,4143
+dill/tests/test_dictviews.py,sha256=_A3DiEkOz8aYt8XWQxgMYjsMWOof6qTOjZrB7WL_Vt4,1240
+dill/tests/test_diff.py,sha256=RS1nx0apXUe8jK-W3B7E0lSyHcQxM6fqD5GWU2AzatU,2761
+dill/tests/test_extendpickle.py,sha256=Ltr_pkjtE0gFBuMwx2t-G5aJX0XUi-fLixbXUtzKsS8,1368
+dill/tests/test_fglobals.py,sha256=a3xGhcKEp7ly3YDE1zKTL0NWtp6Hz7NmmCD_2IPDDLA,1679
+dill/tests/test_file.py,sha256=XCt2vYTTvqhDrI-w93IBbIouxU0SjYeMqty_K2pR_LM,13642
+dill/tests/test_functions.py,sha256=DqBQj9unXgN8lnNDcB6CBDa3uEi0FsJxSMacWaiqoZU,2745
+dill/tests/test_functors.py,sha256=Sc9npIl2jTaIWi9Q_1RP37mhLo1ipapilrKN8Pe9JzA,930
+dill/tests/test_mixins.py,sha256=oVHtv1W3v7VgpiBKtJIR1nqa2D6oDK6Br4zbIfVuXOI,4007
+dill/tests/test_module.py,sha256=HKlpDn0LW6bZ2D4Qv9sJAtiaEvXr9mLl9a1jzYtTt4A,1973
+dill/tests/test_moduledict.py,sha256=GQ-grHuJl1uwEarrhVFoizNvxcfR5pQJDLETfjj481M,1182
+dill/tests/test_nested.py,sha256=5ML9p0OhgII9P_y4waSwVX3LXwh38ual09ujSuKwhpw,3134
+dill/tests/test_objects.py,sha256=zJtLBerYOmBa9TMMgwOJLmwm-xvXZ0IEEhXDdy5VhvE,1779
+dill/tests/test_properties.py,sha256=1mBRrIeYAu_4x14viOtN8uMeefQ8Zwv6Ovvu3EPDg9g,1346
+dill/tests/test_recursive.py,sha256=PvTy1RfVpXbUdtUo-DBhT9rrNQfHeY3kIpfHUCSVlAY,4209
+dill/tests/test_restricted.py,sha256=fcEbNfLbb1ar4EuR_Np9QoOqdnLeRoXSQXnIMvp73Lg,783
+dill/tests/test_selected.py,sha256=Y6U7D4JlNRxXWKTzM_QIGjSPu8dQfZB5VIJoBplF2y0,2533
+dill/tests/test_session.py,sha256=kuX2yOkhd-P10l_rK4wsleKqMCf7KpUZnny3FVnJAOs,8741
+dill/tests/test_source.py,sha256=3K2yLts31FKruAsnvs_8W_VeN8ECS6y4plQtKug2oTI,6375
+dill/tests/test_temp.py,sha256=w2Z-GDhxz3Gx1jXMWpnE1728s7i0eGfXwc1VNWGl1OQ,2619
+dill/tests/test_weakref.py,sha256=S-p_FbiyKPzdpWMsTA8tV-nlYKMBLrgs_ydmINcHF9w,2056
+../../../bin/get_objgraph,sha256=tCXH1qHc46QqOlPMafrRFAHqdExneBYTkUTz3pXDTRk,1692
+../../../bin/undill,sha256=YY_ky_yIW3Zkwodhg9q6vojvt5E-Y-iI0hefJ90VioE,628
+dill-0.3.5.1.dist-info/LICENSE,sha256=evNBT-0eWbe4mO8SKnan2GaHddldBVbI6nbeRKXZoZc,1790
+dill-0.3.5.1.dist-info/METADATA,sha256=tLSZPXPB7L8FBky9p4RQKXS_nPi6VK8BVRB2ELlIqoE,9725
+dill-0.3.5.1.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
+dill-0.3.5.1.dist-info/top_level.txt,sha256=HLSIyYIjQzJiBvs3_-16ntezE3j6mWGTW0DT1xDd7X0,5
+dill-0.3.5.1.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+dill-0.3.5.1.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/WHEEL
new file mode 100644
index 0000000..0b18a28
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/top_level.txt
new file mode 100644
index 0000000..85eea70
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill-0.3.5.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+dill
diff --git a/myenv/lib/python3.9/site-packages/dill/__diff.py b/myenv/lib/python3.9/site-packages/dill/__diff.py
new file mode 100644
index 0000000..df2589e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/__diff.py
@@ -0,0 +1,240 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+"""
+Module to show if an object has changed since it was memorised
+"""
+
+import os
+import sys
+import types
+try:
+    import numpy
+    HAS_NUMPY = True
+except:
+    HAS_NUMPY = False
+try:
+    import builtins
+except ImportError:
+    import __builtin__ as builtins
+
+# pypy doesn't use reference counting
+getrefcount = getattr(sys, 'getrefcount', lambda x:0)
+
+# memo of objects indexed by id to a tuple (attributes, sequence items)
+# attributes is a dict indexed by attribute name to attribute id
+# sequence items is either a list of ids, of a dictionary of keys to ids
+memo = {}
+id_to_obj = {}
+# types that cannot have changing attributes
+builtins_types = set((str, list, dict, set, frozenset, int))
+dont_memo = set(id(i) for i in (memo, sys.modules, sys.path_importer_cache,
+             os.environ, id_to_obj))
+
+
+def get_attrs(obj):
+    """
+    Gets all the attributes of an object though its __dict__ or return None
+    """
+    if type(obj) in builtins_types \
+       or type(obj) is type and obj in builtins_types:
+        return
+    try:
+        return obj.__dict__
+    except:
+        return
+
+
+def get_seq(obj, cache={str: False, frozenset: False, list: True, set: True,
+                        dict: True, tuple: True, type: False,
+                        types.ModuleType: False, types.FunctionType: False,
+                        types.BuiltinFunctionType: False}):
+    """
+    Gets all the items in a sequence or return None
+    """
+    try:
+        o_type = obj.__class__
+    except AttributeError:
+        o_type = type(obj)
+    hsattr = hasattr
+    if o_type in cache:
+        if cache[o_type]:
+            if hsattr(obj, "copy"):
+                return obj.copy()
+            return obj
+    elif HAS_NUMPY and o_type in (numpy.ndarray, numpy.ma.core.MaskedConstant):
+        if obj.shape and obj.size:
+            return obj
+        else:
+            return []
+    elif hsattr(obj, "__contains__") and hsattr(obj, "__iter__") \
+       and hsattr(obj, "__len__") and hsattr(o_type, "__contains__") \
+       and hsattr(o_type, "__iter__") and hsattr(o_type, "__len__"):
+        cache[o_type] = True
+        if hsattr(obj, "copy"):
+            return obj.copy()
+        return obj
+    else:
+        cache[o_type] = False
+        return None
+
+
+def memorise(obj, force=False):
+    """
+    Adds an object to the memo, and recursively adds all the objects
+    attributes, and if it is a container, its items. Use force=True to update
+    an object already in the memo. Updating is not recursively done.
+    """
+    obj_id = id(obj)
+    if obj_id in memo and not force or obj_id in dont_memo:
+        return
+    id_ = id
+    g = get_attrs(obj)
+    if g is None:
+        attrs_id = None
+    else:
+        attrs_id = dict((key,id_(value)) for key, value in g.items())
+
+    s = get_seq(obj)
+    if s is None:
+        seq_id = None
+    elif hasattr(s, "items"):
+        seq_id = dict((id_(key),id_(value)) for key, value in s.items())
+    elif not hasattr(s, "__len__"): #XXX: avoid TypeError from unexpected case
+        seq_id = None
+    else:
+        seq_id = [id_(i) for i in s]
+
+    memo[obj_id] = attrs_id, seq_id
+    id_to_obj[obj_id] = obj
+    mem = memorise
+    if g is not None:
+        [mem(value) for key, value in g.items()]
+
+    if s is not None:
+        if hasattr(s, "items"):
+            [(mem(key), mem(item))
+             for key, item in s.items()]
+        else:
+            if hasattr(s, '__len__'):
+                [mem(item) for item in s]
+            else: mem(s)
+
+
+def release_gone():
+    itop, mp, src = id_to_obj.pop, memo.pop, getrefcount
+    [(itop(id_), mp(id_)) for id_, obj in list(id_to_obj.items())
+     if src(obj) < 4] #XXX: correct for pypy?
+
+
+def whats_changed(obj, seen=None, simple=False, first=True):
+    """
+    Check an object against the memo. Returns a list in the form
+    (attribute changes, container changed). Attribute changes is a dict of
+    attribute name to attribute value. container changed is a boolean.
+    If simple is true, just returns a boolean. None for either item means
+    that it has not been checked yet
+    """
+    # Special cases
+    if first:
+        # ignore the _ variable, which only appears in interactive sessions
+        if "_" in builtins.__dict__:
+            del builtins._
+        if seen is None:
+            seen = {}
+
+    obj_id = id(obj)
+
+    if obj_id in seen:
+        if simple:
+            return any(seen[obj_id])
+        return seen[obj_id]
+
+    # Safety checks
+    if obj_id in dont_memo:
+        seen[obj_id] = [{}, False]
+        if simple:
+            return False
+        return seen[obj_id]
+    elif obj_id not in memo:
+        if simple:
+            return True
+        else:
+            raise RuntimeError("Object not memorised " + str(obj))
+
+    seen[obj_id] = ({}, False)
+
+    chngd = whats_changed
+    id_ = id
+
+    # compare attributes
+    attrs = get_attrs(obj)
+    if attrs is None:
+        changed = {}
+    else:
+        obj_attrs = memo[obj_id][0]
+        obj_get = obj_attrs.get
+        changed = dict((key,None) for key in obj_attrs if key not in attrs)
+        for key, o in attrs.items():
+            if id_(o) != obj_get(key, None) or chngd(o, seen, True, False):
+                changed[key] = o
+
+    # compare sequence
+    items = get_seq(obj)
+    seq_diff = False
+    if (items is not None) and (hasattr(items, '__len__')):
+        obj_seq = memo[obj_id][1]
+        if (len(items) != len(obj_seq)):
+            seq_diff = True
+        elif hasattr(obj, "items"):  # dict type obj
+            obj_get = obj_seq.get
+            for key, item in items.items():
+                if id_(item) != obj_get(id_(key)) \
+                   or chngd(key, seen, True, False) \
+                   or chngd(item, seen, True, False):
+                    seq_diff = True
+                    break
+        else:
+            for i, j in zip(items, obj_seq):  # list type obj
+                if id_(i) != j or chngd(i, seen, True, False):
+                    seq_diff = True
+                    break
+    seen[obj_id] = changed, seq_diff
+    if simple:
+        return changed or seq_diff
+    return changed, seq_diff
+
+
+def has_changed(*args, **kwds):
+    kwds['simple'] = True  # ignore simple if passed in
+    return whats_changed(*args, **kwds)
+
+__import__ = __import__
+
+
+def _imp(*args, **kwds):
+    """
+    Replaces the default __import__, to allow a module to be memorised
+    before the user can change it
+    """
+    before = set(sys.modules.keys())
+    mod = __import__(*args, **kwds)
+    after = set(sys.modules.keys()).difference(before)
+    for m in after:
+        memorise(sys.modules[m])
+    return mod
+
+builtins.__import__ = _imp
+if hasattr(builtins, "_"):
+    del builtins._
+
+# memorise all already imported modules. This implies that this must be
+# imported first for any changes to be recorded
+for mod in sys.modules.values():
+    memorise(mod)
+release_gone()
diff --git a/myenv/lib/python3.9/site-packages/dill/__init__.py b/myenv/lib/python3.9/site-packages/dill/__init__.py
new file mode 100644
index 0000000..e47f482
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/__init__.py
@@ -0,0 +1,389 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+# author, version, license, and long description
+__version__ = '0.3.5.1'
+__author__ = 'Mike McKerns'
+
+__doc__ = """
+-----------------------------
+dill: serialize all of python
+-----------------------------
+
+About Dill
+==========
+
+``dill`` extends python's ``pickle`` module for serializing and de-serializing
+python objects to the majority of the built-in python types. Serialization
+is the process of converting an object to a byte stream, and the inverse
+of which is converting a byte stream back to a python object hierarchy.
+
+``dill`` provides the user the same interface as the ``pickle`` module, and
+also includes some additional features. In addition to pickling python
+objects, ``dill`` provides the ability to save the state of an interpreter
+session in a single command.  Hence, it would be feasable to save an
+interpreter session, close the interpreter, ship the pickled file to
+another computer, open a new interpreter, unpickle the session and
+thus continue from the 'saved' state of the original interpreter
+session.
+
+``dill`` can be used to store python objects to a file, but the primary
+usage is to send python objects across the network as a byte stream.
+``dill`` is quite flexible, and allows arbitrary user defined classes
+and functions to be serialized.  Thus ``dill`` is not intended to be
+secure against erroneously or maliciously constructed data. It is
+left to the user to decide whether the data they unpickle is from
+a trustworthy source.
+
+``dill`` is part of ``pathos``, a python framework for heterogeneous computing.
+``dill`` is in active development, so any user feedback, bug reports, comments,
+or suggestions are highly appreciated.  A list of issues is located at https://github.com/uqfoundation/dill/issues, with a legacy list maintained at https://uqfoundation.github.io/project/pathos/query.
+
+
+Major Features
+==============
+
+``dill`` can pickle the following standard types:
+
+    - none, type, bool, int, long, float, complex, str, unicode,
+    - tuple, list, dict, file, buffer, builtin,
+    - both old and new style classes,
+    - instances of old and new style classes,
+    - set, frozenset, array, functions, exceptions
+
+``dill`` can also pickle more 'exotic' standard types:
+
+    - functions with yields, nested functions, lambdas,
+    - cell, method, unboundmethod, module, code, methodwrapper,
+    - dictproxy, methoddescriptor, getsetdescriptor, memberdescriptor,
+    - wrapperdescriptor, xrange, slice,
+    - notimplemented, ellipsis, quit
+
+``dill`` cannot yet pickle these standard types:
+
+    - frame, generator, traceback
+
+``dill`` also provides the capability to:
+
+    - save and load python interpreter sessions
+    - save and extract the source code from functions and classes
+    - interactively diagnose pickling errors
+
+
+Current Release
+===============
+
+The latest released version of ``dill`` is available from:
+
+    https://pypi.org/project/dill
+
+``dill`` is distributed under a 3-clause BSD license.
+
+
+Development Version
+===================
+
+You can get the latest development version with all the shiny new features at:
+
+    https://github.com/uqfoundation
+
+If you have a new contribution, please submit a pull request.
+
+
+Installation
+============
+
+``dill`` can be installed with ``pip``::
+
+    $ pip install dill
+
+To optionally include the ``objgraph`` diagnostic tool in the install::
+
+    $ pip install dill[graph]
+
+For windows users, to optionally install session history tools::
+
+    $ pip install dill[readline]
+
+
+Requirements
+============
+
+``dill`` requires:
+
+    - ``python`` (or ``pypy``), **==2.7** or **>=3.7**
+    - ``setuptools``, **>=42**
+
+Optional requirements:
+
+    - ``objgraph``, **>=1.7.2**
+    - ``pyreadline``, **>=1.7.1** (on windows)
+
+
+Basic Usage
+===========
+
+``dill`` is a drop-in replacement for ``pickle``. Existing code can be
+updated to allow complete pickling using::
+
+    >>> import dill as pickle
+
+or::
+
+    >>> from dill import dumps, loads
+
+``dumps`` converts the object to a unique byte string, and ``loads`` performs
+the inverse operation::
+
+    >>> squared = lambda x: x**2
+    >>> loads(dumps(squared))(3)
+    9
+
+There are a number of options to control serialization which are provided
+as keyword arguments to several ``dill`` functions:
+
+* with *protocol*, the pickle protocol level can be set. This uses the
+  same value as the ``pickle`` module, *HIGHEST_PROTOCOL* or *DEFAULT_PROTOCOL*.
+* with *byref=True*, ``dill`` to behave a lot more like pickle with
+  certain objects (like modules) pickled by reference as opposed to
+  attempting to pickle the object itself.
+* with *recurse=True*, objects referred to in the global dictionary are
+  recursively traced and pickled, instead of the default behavior of
+  attempting to store the entire global dictionary.
+* with *fmode*, the contents of the file can be pickled along with the file
+  handle, which is useful if the object is being sent over the wire to a
+  remote system which does not have the original file on disk. Options are
+  *HANDLE_FMODE* for just the handle, *CONTENTS_FMODE* for the file content
+  and *FILE_FMODE* for content and handle.
+* with *ignore=False*, objects reconstructed with types defined in the
+  top-level script environment use the existing type in the environment
+  rather than a possibly different reconstructed type.
+
+The default serialization can also be set globally in *dill.settings*.
+Thus, we can modify how ``dill`` handles references to the global dictionary
+locally or globally::
+
+    >>> import dill.settings
+    >>> dumps(absolute) == dumps(absolute, recurse=True)
+    False
+    >>> dill.settings['recurse'] = True
+    >>> dumps(absolute) == dumps(absolute, recurse=True)
+    True
+
+``dill`` also includes source code inspection, as an alternate to pickling::
+
+    >>> import dill.source
+    >>> print(dill.source.getsource(squared))
+    squared = lambda x:x**2
+
+To aid in debugging pickling issues, use *dill.detect* which provides
+tools like pickle tracing::
+
+    >>> import dill.detect
+    >>> dill.detect.trace(True)
+    >>> f = dumps(squared)
+    F1: <function <lambda> at 0x108899e18>
+    F2: <function _create_function at 0x108db7488>
+    # F2
+    Co: <code object <lambda> at 0x10866a270, file "<stdin>", line 1>
+    F2: <function _create_code at 0x108db7510>
+    # F2
+    # Co
+    D1: <dict object at 0x10862b3f0>
+    # D1
+    D2: <dict object at 0x108e42ee8>
+    # D2
+    # F1
+    >>> dill.detect.trace(False)
+
+With trace, we see how ``dill`` stored the lambda (``F1``) by first storing
+``_create_function``, the underlying code object (``Co``) and ``_create_code``
+(which is used to handle code objects), then we handle the reference to
+the global dict (``D2``).  A ``#`` marks when the object is actually stored.
+
+
+More Information
+================
+
+Probably the best way to get started is to look at the documentation at
+http://dill.rtfd.io. Also see ``dill.tests`` for a set of scripts that
+demonstrate how ``dill`` can serialize different python objects. You can
+run the test suite with ``python -m dill.tests``. The contents of any
+pickle file can be examined with ``undill``.  As ``dill`` conforms to
+the ``pickle`` interface, the examples and documentation found at
+http://docs.python.org/library/pickle.html also apply to ``dill``
+if one will ``import dill as pickle``. The source code is also generally
+well documented, so further questions may be resolved by inspecting the
+code itself. Please feel free to submit a ticket on github, or ask a
+question on stackoverflow (**@Mike McKerns**).
+If you would like to share how you use ``dill`` in your work, please send
+an email (to **mmckerns at uqfoundation dot org**).
+
+
+Citation
+========
+
+If you use ``dill`` to do research that leads to publication, we ask that you
+acknowledge use of ``dill`` by citing the following in your publication::
+
+    M.M. McKerns, L. Strand, T. Sullivan, A. Fang, M.A.G. Aivazis,
+    "Building a framework for predictive science", Proceedings of
+    the 10th Python in Science Conference, 2011;
+    http://arxiv.org/pdf/1202.1056
+
+    Michael McKerns and Michael Aivazis,
+    "pathos: a framework for heterogeneous computing", 2010- ;
+    https://uqfoundation.github.io/project/pathos
+
+Please see https://uqfoundation.github.io/project/pathos or
+http://arxiv.org/pdf/1202.1056 for further information.
+
+"""
+
+__license__ = """
+Copyright (c) 2004-2016 California Institute of Technology.
+Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+All rights reserved.
+
+This software is available subject to the conditions and terms laid
+out below. By downloading and using this software you are agreeing
+to the following conditions.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met::
+
+    - Redistribution of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    - Redistribution in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentations and/or other materials provided with the distribution.
+
+    - Neither the names of the copyright holders nor the names of any of
+      the 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 ._dill import dump, dumps, load, loads, dump_session, load_session, \
+    Pickler, Unpickler, register, copy, pickle, pickles, check, \
+    HIGHEST_PROTOCOL, DEFAULT_PROTOCOL, PicklingError, UnpicklingError, \
+    HANDLE_FMODE, CONTENTS_FMODE, FILE_FMODE, PickleError, PickleWarning, \
+    PicklingWarning, UnpicklingWarning
+from . import source, temp, detect
+
+# get global settings
+from .settings import settings
+
+# make sure "trace" is turned off
+detect.trace(False)
+
+try:
+    from importlib import reload
+except ImportError:
+    try:
+        from imp import reload
+    except ImportError:
+        pass
+
+# put the objects in order, if possible
+try:
+    from collections import OrderedDict as odict
+except ImportError:
+    try:
+        from ordereddict import OrderedDict as odict
+    except ImportError:
+        odict = dict
+objects = odict()
+# local import of dill._objects
+#from . import _objects
+#objects.update(_objects.succeeds)
+#del _objects
+
+# local import of dill.objtypes
+from . import objtypes as types
+
+def load_types(pickleable=True, unpickleable=True):
+    """load pickleable and/or unpickleable types to ``dill.types``
+
+    ``dill.types`` is meant to mimic the ``types`` module, providing a
+    registry of object types.  By default, the module is empty (for import
+    speed purposes). Use the ``load_types`` function to load selected object
+    types to the ``dill.types`` module.
+
+    Args:
+        pickleable (bool, default=True): if True, load pickleable types.
+        unpickleable (bool, default=True): if True, load unpickleable types.
+
+    Returns:
+        None
+    """
+    # local import of dill.objects
+    from . import _objects
+    if pickleable:
+        objects.update(_objects.succeeds)
+    else:
+        [objects.pop(obj,None) for obj in _objects.succeeds]
+    if unpickleable:
+        objects.update(_objects.failures)
+    else:
+        [objects.pop(obj,None) for obj in _objects.failures]
+    objects.update(_objects.registered)
+    del _objects
+    # reset contents of types to 'empty'
+    [types.__dict__.pop(obj) for obj in list(types.__dict__.keys()) \
+                             if obj.find('Type') != -1]
+    # add corresponding types from objects to types
+    reload(types)
+
+def extend(use_dill=True):
+    '''add (or remove) dill types to/from the pickle registry
+
+    by default, ``dill`` populates its types to ``pickle.Pickler.dispatch``.
+    Thus, all ``dill`` types are available upon calling ``'import pickle'``.
+    To drop all ``dill`` types from the ``pickle`` dispatch, *use_dill=False*.
+
+    Args:
+        use_dill (bool, default=True): if True, extend the dispatch table.
+
+    Returns:
+        None
+    '''
+    from ._dill import _revert_extension, _extend
+    if use_dill: _extend()
+    else: _revert_extension()
+    return
+
+extend()
+del odict
+
+
+def license():
+    """print license"""
+    print (__license__)
+    return
+
+def citation():
+    """print citation"""
+    print (__doc__[-491:-118])
+    return
+
+# end of file
diff --git a/myenv/lib/python3.9/site-packages/dill/_dill.py b/myenv/lib/python3.9/site-packages/dill/_dill.py
new file mode 100644
index 0000000..3f3cb02
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/_dill.py
@@ -0,0 +1,2107 @@
+# -*- coding: utf-8 -*-
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2015 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+dill: a utility for serialization of python objects
+
+Based on code written by Oren Tirosh and Armin Ronacher.
+Extended to a (near) full set of the builtin types (in types module),
+and coded to the pickle interface, by <mmckerns@caltech.edu>.
+Initial port to python3 by Jonathan Dobson, continued by mmckerns.
+Test against "all" python types (Std. Lib. CH 1-15 @ 2.7) by mmckerns.
+Test against CH16+ Std. Lib. ... TBD.
+"""
+__all__ = ['dump','dumps','load','loads','dump_session','load_session',
+           'Pickler','Unpickler','register','copy','pickle','pickles',
+           'check','HIGHEST_PROTOCOL','DEFAULT_PROTOCOL','PicklingError',
+           'UnpicklingError','HANDLE_FMODE','CONTENTS_FMODE','FILE_FMODE',
+           'PickleError','PickleWarning','PicklingWarning','UnpicklingWarning']
+
+import logging
+log = logging.getLogger("dill")
+log.addHandler(logging.StreamHandler())
+def _trace(boolean):
+    """print a trace through the stack when pickling; useful for debugging"""
+    if boolean: log.setLevel(logging.INFO)
+    else: log.setLevel(logging.WARN)
+    return
+import warnings
+
+import os
+import sys
+diff = None
+_use_diff = False
+PY3 = (sys.hexversion >= 0x3000000)
+# OLDER: 3.0 <= x < 3.4 *OR* x < 2.7.10  #NOTE: guessing relevant versions
+OLDER = (PY3 and sys.hexversion < 0x3040000) or (sys.hexversion < 0x2070ab1)
+OLD33 = (sys.hexversion < 0x3030000)
+OLD37 = (sys.hexversion < 0x3070000)
+OLD39 = (sys.hexversion < 0x3090000)
+OLD310 = (sys.hexversion < 0x30a0000)
+PY34 = (0x3040000 <= sys.hexversion < 0x3050000)
+if PY3: #XXX: get types from .objtypes ?
+    import builtins as __builtin__
+    from pickle import _Pickler as StockPickler, Unpickler as StockUnpickler
+    from _thread import LockType
+    if (sys.hexversion >= 0x30200f0):
+        from _thread import RLock as RLockType
+    else:
+        from threading import _RLock as RLockType
+   #from io import IOBase
+    from types import CodeType, FunctionType, MethodType, GeneratorType, \
+        TracebackType, FrameType, ModuleType, BuiltinMethodType
+    BufferType = memoryview #XXX: unregistered
+    ClassType = type # no 'old-style' classes
+    EllipsisType = type(Ellipsis)
+   #FileType = IOBase
+    NotImplementedType = type(NotImplemented)
+    SliceType = slice
+    TypeType = type # 'new-style' classes #XXX: unregistered
+    XRangeType = range
+    if OLD33:
+        DictProxyType = type(object.__dict__)
+    else:
+        from types import MappingProxyType as DictProxyType
+else:
+    import __builtin__
+    from pickle import Pickler as StockPickler, Unpickler as StockUnpickler
+    from thread import LockType
+    from threading import _RLock as RLockType
+    from types import CodeType, FunctionType, ClassType, MethodType, \
+         GeneratorType, DictProxyType, XRangeType, SliceType, TracebackType, \
+         NotImplementedType, EllipsisType, FrameType, ModuleType, \
+         BufferType, BuiltinMethodType, TypeType
+from pickle import HIGHEST_PROTOCOL, PickleError, PicklingError, UnpicklingError
+try:
+    from pickle import DEFAULT_PROTOCOL
+except ImportError:
+    DEFAULT_PROTOCOL = HIGHEST_PROTOCOL
+import __main__ as _main_module
+import marshal
+import gc
+# import zlib
+from weakref import ReferenceType, ProxyType, CallableProxyType
+from functools import partial
+from operator import itemgetter, attrgetter
+# new in python3.3
+if sys.hexversion < 0x03030000:
+    FileNotFoundError = IOError
+if PY3 and sys.hexversion < 0x03040000:
+    GENERATOR_FAIL = True
+else: GENERATOR_FAIL = False
+if PY3:
+    import importlib.machinery
+    EXTENSION_SUFFIXES = tuple(importlib.machinery.EXTENSION_SUFFIXES)
+else:
+    import imp
+    EXTENSION_SUFFIXES = tuple(suffix
+                               for (suffix, _, s_type) in imp.get_suffixes()
+                               if s_type == imp.C_EXTENSION)
+try:
+    import ctypes
+    HAS_CTYPES = True
+    # if using `pypy`, pythonapi is not found
+    IS_PYPY = not hasattr(ctypes, 'pythonapi')
+except ImportError:
+    HAS_CTYPES = False
+    IS_PYPY = False
+IS_PYPY2 = IS_PYPY and not PY3
+NumpyUfuncType = None
+NumpyDType = None
+NumpyArrayType = None
+try:
+    if OLDER:
+        raise AttributeError('find_spec not found')
+    import importlib
+    if not importlib.machinery.PathFinder().find_spec('numpy'):
+        raise ImportError("No module named 'numpy'")
+    NumpyUfuncType = True
+    NumpyDType = True
+    NumpyArrayType = True
+except AttributeError:
+    try:
+        import imp
+        imp.find_module('numpy')
+        NumpyUfuncType = True
+        NumpyDType = True
+        NumpyArrayType = True
+    except ImportError:
+        pass
+except ImportError:
+    pass
+def __hook__():
+    global NumpyArrayType, NumpyDType, NumpyUfuncType
+    from numpy import ufunc as NumpyUfuncType
+    from numpy import ndarray as NumpyArrayType
+    from numpy import dtype as NumpyDType
+    return True
+if NumpyArrayType: # then has numpy
+    def ndarraysubclassinstance(obj):
+        if type(obj) in (TypeType, ClassType):
+            return False # all classes return False
+        try: # check if is ndarray, and elif is subclass of ndarray
+            cls = getattr(obj, '__class__', None)
+            if cls is None: return False
+            elif cls is TypeType: return False
+            elif 'numpy.ndarray' not in str(getattr(cls, 'mro', int.mro)()):
+                return False
+        except ReferenceError: return False # handle 'R3' weakref in 3.x
+        except TypeError: return False
+        # anything below here is a numpy array (or subclass) instance
+        __hook__() # import numpy (so the following works!!!)
+        # verify that __reduce__ has not been overridden
+        NumpyInstance = NumpyArrayType((0,),'int8')
+        if id(obj.__reduce_ex__) == id(NumpyInstance.__reduce_ex__) and \
+           id(obj.__reduce__) == id(NumpyInstance.__reduce__): return True
+        return False
+    def numpyufunc(obj):
+        if type(obj) in (TypeType, ClassType):
+            return False # all classes return False
+        try: # check if is ufunc
+            cls = getattr(obj, '__class__', None)
+            if cls is None: return False
+            elif cls is TypeType: return False
+            if 'numpy.ufunc' not in str(getattr(cls, 'mro', int.mro)()):
+                return False
+        except ReferenceError: return False # handle 'R3' weakref in 3.x
+        except TypeError: return False
+        # anything below here is a numpy ufunc
+        return True
+    def numpydtype(obj):
+        if type(obj) in (TypeType, ClassType):
+            return False # all classes return False
+        try: # check if is dtype
+            cls = getattr(obj, '__class__', None)
+            if cls is None: return False
+            elif cls is TypeType: return False
+            if 'numpy.dtype' not in str(getattr(obj, 'mro', int.mro)()):
+                return False
+        except ReferenceError: return False # handle 'R3' weakref in 3.x
+        except TypeError: return False
+        # anything below here is a numpy dtype
+        __hook__() # import numpy (so the following works!!!)
+        return type(obj) is type(NumpyDType) # handles subclasses
+else:
+    def ndarraysubclassinstance(obj): return False
+    def numpyufunc(obj): return False
+    def numpydtype(obj): return False
+
+# make sure to add these 'hand-built' types to _typemap
+if PY3:
+    CellType = type((lambda x: lambda y: x)(0).__closure__[0])
+else:
+    CellType = type((lambda x: lambda y: x)(0).func_closure[0])
+# new in python2.5
+if sys.hexversion >= 0x20500f0:
+    from types import GetSetDescriptorType
+    if not IS_PYPY:
+        from types import MemberDescriptorType
+    else:
+        # oddly, MemberDescriptorType is GetSetDescriptorType
+        # while, member_descriptor does exist otherwise... is this a pypy bug?
+        class _member(object):
+            __slots__ = ['descriptor']
+        MemberDescriptorType = type(_member.descriptor)
+if IS_PYPY:
+    WrapperDescriptorType = MethodType
+    MethodDescriptorType = FunctionType
+    ClassMethodDescriptorType = FunctionType
+else:
+    WrapperDescriptorType = type(type.__repr__)
+    MethodDescriptorType = type(type.__dict__['mro'])
+    ClassMethodDescriptorType = type(type.__dict__['__prepare__' if PY3 else 'mro'])
+
+MethodWrapperType = type([].__repr__)
+PartialType = type(partial(int,base=2))
+SuperType = type(super(Exception, TypeError()))
+ItemGetterType = type(itemgetter(0))
+AttrGetterType = type(attrgetter('__repr__'))
+
+try:
+    from functools import _lru_cache_wrapper as LRUCacheType
+except:
+    LRUCacheType = None
+
+if not isinstance(LRUCacheType, type):
+    LRUCacheType = None
+
+def get_file_type(*args, **kwargs):
+    open = kwargs.pop("open", __builtin__.open)
+    f = open(os.devnull, *args, **kwargs)
+    t = type(f)
+    f.close()
+    return t
+
+FileType = get_file_type('rb', buffering=0)
+TextWrapperType = get_file_type('r', buffering=-1)
+BufferedRandomType = get_file_type('r+b', buffering=-1)
+BufferedReaderType = get_file_type('rb', buffering=-1)
+BufferedWriterType = get_file_type('wb', buffering=-1)
+try:
+    from _pyio import open as _open
+    PyTextWrapperType = get_file_type('r', buffering=-1, open=_open)
+    PyBufferedRandomType = get_file_type('r+b', buffering=-1, open=_open)
+    PyBufferedReaderType = get_file_type('rb', buffering=-1, open=_open)
+    PyBufferedWriterType = get_file_type('wb', buffering=-1, open=_open)
+except ImportError:
+    PyTextWrapperType = PyBufferedRandomType = PyBufferedReaderType = PyBufferedWriterType = None
+try:
+    from cStringIO import StringIO, InputType, OutputType
+except ImportError:
+    if PY3:
+        from io import BytesIO as StringIO
+    else:
+        from StringIO import StringIO
+    InputType = OutputType = None
+if not IS_PYPY2:
+    from socket import socket as SocketType
+    try: #FIXME: additionally calls ForkingPickler.register several times
+        from multiprocessing.reduction import _reduce_socket as reduce_socket
+    except ImportError:
+        from multiprocessing.reduction import reduce_socket
+try:
+    __IPYTHON__ is True # is ipython
+    ExitType = None     # IPython.core.autocall.ExitAutocall
+    singletontypes = ['exit', 'quit', 'get_ipython']
+except NameError:
+    try: ExitType = type(exit) # apparently 'exit' can be removed
+    except NameError: ExitType = None
+    singletontypes = []
+
+from collections import OrderedDict
+
+import inspect
+
+### Shims for different versions of Python and dill
+class Sentinel(object):
+    """
+    Create a unique sentinel object that is pickled as a constant.
+    """
+    def __init__(self, name, module_name=None):
+        self.name = name
+        if module_name is None:
+            # Use the calling frame's module
+            self.__module__ = inspect.currentframe().f_back.f_globals['__name__']
+        else:
+            self.__module__ = module_name # pragma: no cover
+    def __repr__(self):
+        return self.__module__ + '.' + self.name # pragma: no cover
+    def __copy__(self):
+        return self # pragma: no cover
+    def __deepcopy__(self, memo):
+        return self # pragma: no cover
+    def __reduce__(self):
+        return self.name
+    def __reduce_ex__(self, protocol):
+        return self.name
+
+from . import _shims
+from ._shims import Reduce, Getattr
+
+### File modes
+#: Pickles the file handle, preserving mode. The position of the unpickled
+#: object is as for a new file handle.
+HANDLE_FMODE = 0
+#: Pickles the file contents, creating a new file if on load the file does
+#: not exist. The position = min(pickled position, EOF) and mode is chosen
+#: as such that "best" preserves behavior of the original file.
+CONTENTS_FMODE = 1
+#: Pickles the entire file (handle and contents), preserving mode and position.
+FILE_FMODE = 2
+
+### Shorthands (modified from python2.5/lib/pickle.py)
+def copy(obj, *args, **kwds):
+    """
+    Use pickling to 'copy' an object (i.e. `loads(dumps(obj))`).
+
+    See :func:`dumps` and :func:`loads` for keyword arguments.
+    """
+    ignore = kwds.pop('ignore', Unpickler.settings['ignore'])
+    return loads(dumps(obj, *args, **kwds), ignore=ignore)
+
+def dump(obj, file, protocol=None, byref=None, fmode=None, recurse=None, **kwds):#, strictio=None):
+    """
+    Pickle an object to a file.
+
+    See :func:`dumps` for keyword arguments.
+    """
+    from .settings import settings
+    protocol = settings['protocol'] if protocol is None else int(protocol)
+    _kwds = kwds.copy()
+    _kwds.update(dict(byref=byref, fmode=fmode, recurse=recurse))
+    Pickler(file, protocol, **_kwds).dump(obj)
+    return
+
+def dumps(obj, protocol=None, byref=None, fmode=None, recurse=None, **kwds):#, strictio=None):
+    """
+    Pickle an object to a string.
+
+    *protocol* is the pickler protocol, as defined for Python *pickle*.
+
+    If *byref=True*, then dill behaves a lot more like pickle as certain
+    objects (like modules) are pickled by reference as opposed to attempting
+    to pickle the object itself.
+
+    If *recurse=True*, then objects referred to in the global dictionary
+    are recursively traced and pickled, instead of the default behavior
+    of attempting to store the entire global dictionary. This is needed for
+    functions defined via *exec()*.
+
+    *fmode* (:const:`HANDLE_FMODE`, :const:`CONTENTS_FMODE`,
+    or :const:`FILE_FMODE`) indicates how file handles will be pickled.
+    For example, when pickling a data file handle for transfer to a remote
+    compute service, *FILE_FMODE* will include the file contents in the
+    pickle and cursor position so that a remote method can operate
+    transparently on an object with an open file handle.
+
+    Default values for keyword arguments can be set in :mod:`dill.settings`.
+    """
+    file = StringIO()
+    dump(obj, file, protocol, byref, fmode, recurse, **kwds)#, strictio)
+    return file.getvalue()
+
+def load(file, ignore=None, **kwds):
+    """
+    Unpickle an object from a file.
+
+    See :func:`loads` for keyword arguments.
+    """
+    return Unpickler(file, ignore=ignore, **kwds).load()
+
+def loads(str, ignore=None, **kwds):
+    """
+    Unpickle an object from a string.
+
+    If *ignore=False* then objects whose class is defined in the module
+    *__main__* are updated to reference the existing class in *__main__*,
+    otherwise they are left to refer to the reconstructed type, which may
+    be different.
+
+    Default values for keyword arguments can be set in :mod:`dill.settings`.
+    """
+    file = StringIO(str)
+    return load(file, ignore, **kwds)
+
+# def dumpzs(obj, protocol=None):
+#     """pickle an object to a compressed string"""
+#     return zlib.compress(dumps(obj, protocol))
+
+# def loadzs(str):
+#     """unpickle an object from a compressed string"""
+#     return loads(zlib.decompress(str))
+
+### End: Shorthands ###
+
+### Pickle the Interpreter Session
+SESSION_IMPORTED_AS_TYPES = (ModuleType, ClassType, TypeType, Exception,
+                             FunctionType, MethodType, BuiltinMethodType)
+
+def _module_map():
+    """get map of imported modules"""
+    from collections import defaultdict, namedtuple
+    modmap = namedtuple('Modmap', ['by_name', 'by_id', 'top_level'])
+    modmap = modmap(defaultdict(list), defaultdict(list), {})
+    items = 'items' if PY3 else 'iteritems'
+    for modname, module in getattr(sys.modules, items)():
+        if not isinstance(module, ModuleType):
+            continue
+        if '.' not in modname:
+            modmap.top_level[id(module)] = modname
+        for objname, modobj in module.__dict__.items():
+            modmap.by_name[objname].append((modobj, modname))
+            modmap.by_id[id(modobj)].append((modobj, objname, modname))
+    return modmap
+
+def _lookup_module(modmap, name, obj, main_module):
+    """lookup name or id of obj if module is imported"""
+    for modobj, modname in modmap.by_name[name]:
+        if modobj is obj and sys.modules[modname] is not main_module:
+            return modname, name
+    if isinstance(obj, SESSION_IMPORTED_AS_TYPES):
+        for modobj, objname, modname in modmap.by_id[id(obj)]:
+            if sys.modules[modname] is not main_module:
+                return modname, objname
+    return None, None
+
+def _stash_modules(main_module):
+    modmap = _module_map()
+    newmod = ModuleType(main_module.__name__)
+
+    imported = []
+    imported_as = []
+    imported_top_level = []  # keep separeted for backwards compatibility
+    original = {}
+    items = 'items' if PY3 else 'iteritems'
+    for name, obj in getattr(main_module.__dict__, items)():
+        if obj is main_module:
+            original[name] = newmod  # self-reference
+            continue
+
+        # Avoid incorrectly matching a singleton value in another package (ex.: __doc__).
+        if any(obj is singleton for singleton in (None, False, True)) or \
+                isinstance(obj, ModuleType) and _is_builtin_module(obj):  # always saved by ref
+            original[name] = obj
+            continue
+
+        source_module, objname = _lookup_module(modmap, name, obj, main_module)
+        if source_module:
+            if objname == name:
+                imported.append((source_module, name))
+            else:
+                imported_as.append((source_module, objname, name))
+        else:
+            try:
+                imported_top_level.append((modmap.top_level[id(obj)], name))
+            except KeyError:
+                original[name] = obj
+
+    if len(original) < len(main_module.__dict__):
+        newmod.__dict__.update(original)
+        newmod.__dill_imported = imported
+        newmod.__dill_imported_as = imported_as
+        newmod.__dill_imported_top_level = imported_top_level
+        return newmod
+    else:
+        return main_module
+
+def _restore_modules(unpickler, main_module):
+    try:
+        for modname, name in main_module.__dict__.pop('__dill_imported'):
+            main_module.__dict__[name] = unpickler.find_class(modname, name)
+        for modname, objname, name in main_module.__dict__.pop('__dill_imported_as'):
+            main_module.__dict__[name] = unpickler.find_class(modname, objname)
+        for modname, name in main_module.__dict__.pop('__dill_imported_top_level'):
+            main_module.__dict__[name] = __import__(modname)
+    except KeyError:
+        pass
+
+#NOTE: 06/03/15 renamed main_module to main
+def dump_session(filename='/tmp/session.pkl', main=None, byref=False, **kwds):
+    """pickle the current state of __main__ to a file"""
+    from .settings import settings
+    protocol = settings['protocol']
+    if main is None: main = _main_module
+    if hasattr(filename, 'write'):
+        f = filename
+    else:
+        f = open(filename, 'wb')
+    try:
+        pickler = Pickler(f, protocol, **kwds)
+        pickler._original_main = main
+        if byref:
+            main = _stash_modules(main)
+        pickler._main = main     #FIXME: dill.settings are disabled
+        pickler._byref = False   # disable pickling by name reference
+        pickler._recurse = False # disable pickling recursion for globals
+        pickler._session = True  # is best indicator of when pickling a session
+        pickler._first_pass = True
+        pickler._main_modified = main is not pickler._original_main
+        pickler.dump(main)
+    finally:
+        if f is not filename:  # If newly opened file
+            f.close()
+    return
+
+def load_session(filename='/tmp/session.pkl', main=None, **kwds):
+    """update the __main__ module with the state from the session file"""
+    if main is None: main = _main_module
+    if hasattr(filename, 'read'):
+        f = filename
+    else:
+        f = open(filename, 'rb')
+    try: #FIXME: dill.settings are disabled
+        unpickler = Unpickler(f, **kwds)
+        unpickler._main = main
+        unpickler._session = True
+        module = unpickler.load()
+        unpickler._session = False
+        main.__dict__.update(module.__dict__)
+        _restore_modules(unpickler, main)
+    finally:
+        if f is not filename:  # If newly opened file
+            f.close()
+    return
+
+### End: Pickle the Interpreter
+
+class MetaCatchingDict(dict):
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def __missing__(self, key):
+        if issubclass(key, type):
+            return save_type
+        else:
+            raise KeyError()
+
+class PickleWarning(Warning, PickleError):
+    pass
+
+class PicklingWarning(PickleWarning, PicklingError):
+    pass
+
+class UnpicklingWarning(PickleWarning, UnpicklingError):
+    pass
+
+### Extend the Picklers
+class Pickler(StockPickler):
+    """python's Pickler extended to interpreter sessions"""
+    dispatch = MetaCatchingDict(StockPickler.dispatch.copy())
+    _session = False
+    from .settings import settings
+
+    def __init__(self, *args, **kwds):
+        settings = Pickler.settings
+        _byref = kwds.pop('byref', None)
+       #_strictio = kwds.pop('strictio', None)
+        _fmode = kwds.pop('fmode', None)
+        _recurse = kwds.pop('recurse', None)
+        StockPickler.__init__(self, *args, **kwds)
+        self._main = _main_module
+        self._diff_cache = {}
+        self._byref = settings['byref'] if _byref is None else _byref
+        self._strictio = False #_strictio
+        self._fmode = settings['fmode'] if _fmode is None else _fmode
+        self._recurse = settings['recurse'] if _recurse is None else _recurse
+        from collections import OrderedDict
+        self._postproc = OrderedDict()
+
+    def dump(self, obj): #NOTE: if settings change, need to update attributes
+        # register if the object is a numpy ufunc
+        # thanks to Paul Kienzle for pointing out ufuncs didn't pickle
+        if NumpyUfuncType and numpyufunc(obj):
+            @register(type(obj))
+            def save_numpy_ufunc(pickler, obj):
+                log.info("Nu: %s" % obj)
+                name = getattr(obj, '__qualname__', getattr(obj, '__name__', None))
+                StockPickler.save_global(pickler, obj, name=name)
+                log.info("# Nu")
+                return
+            # NOTE: the above 'save' performs like:
+            #   import copy_reg
+            #   def udump(f): return f.__name__
+            #   def uload(name): return getattr(numpy, name)
+            #   copy_reg.pickle(NumpyUfuncType, udump, uload)
+        # register if the object is a numpy dtype
+        if NumpyDType and numpydtype(obj):
+            @register(type(obj))
+            def save_numpy_dtype(pickler, obj):
+                log.info("Dt: %s" % obj)
+                pickler.save_reduce(_create_dtypemeta, (obj.type,), obj=obj)
+                log.info("# Dt")
+                return
+            # NOTE: the above 'save' performs like:
+            #   import copy_reg
+            #   def uload(name): return type(NumpyDType(name))
+            #   def udump(f): return uload, (f.type,)
+            #   copy_reg.pickle(NumpyDTypeType, udump, uload)
+        # register if the object is a subclassed numpy array instance
+        if NumpyArrayType and ndarraysubclassinstance(obj):
+            @register(type(obj))
+            def save_numpy_array(pickler, obj):
+                log.info("Nu: (%s, %s)" % (obj.shape,obj.dtype))
+                npdict = getattr(obj, '__dict__', None)
+                f, args, state = obj.__reduce__()
+                pickler.save_reduce(_create_array, (f,args,state,npdict), obj=obj)
+                log.info("# Nu")
+                return
+        # end hack
+        if GENERATOR_FAIL and type(obj) == GeneratorType:
+            msg = "Can't pickle %s: attribute lookup builtins.generator failed" % GeneratorType
+            raise PicklingError(msg)
+        else:
+            StockPickler.dump(self, obj)
+        return
+    dump.__doc__ = StockPickler.dump.__doc__
+    pass
+
+class Unpickler(StockUnpickler):
+    """python's Unpickler extended to interpreter sessions and more types"""
+    from .settings import settings
+    _session = False
+
+    def find_class(self, module, name):
+        if (module, name) == ('__builtin__', '__main__'):
+            return self._main.__dict__ #XXX: above set w/save_module_dict
+        elif (module, name) == ('__builtin__', 'NoneType'):
+            return type(None) #XXX: special case: NoneType missing
+        if module == 'dill.dill': module = 'dill._dill'
+        return StockUnpickler.find_class(self, module, name)
+
+    def __init__(self, *args, **kwds):
+        settings = Pickler.settings
+        _ignore = kwds.pop('ignore', None)
+        StockUnpickler.__init__(self, *args, **kwds)
+        self._main = _main_module
+        self._ignore = settings['ignore'] if _ignore is None else _ignore
+
+    def load(self): #NOTE: if settings change, need to update attributes
+        obj = StockUnpickler.load(self)
+        if type(obj).__module__ == getattr(_main_module, '__name__', '__main__'):
+            if not self._ignore:
+                # point obj class to main
+                try: obj.__class__ = getattr(self._main, type(obj).__name__)
+                except (AttributeError,TypeError): pass # defined in a file
+       #_main_module.__dict__.update(obj.__dict__) #XXX: should update globals ?
+        return obj
+    load.__doc__ = StockUnpickler.load.__doc__
+    pass
+
+'''
+def dispatch_table():
+    """get the dispatch table of registered types"""
+    return Pickler.dispatch
+'''
+
+pickle_dispatch_copy = StockPickler.dispatch.copy()
+
+def pickle(t, func):
+    """expose dispatch table for user-created extensions"""
+    Pickler.dispatch[t] = func
+    return
+
+def register(t):
+    """register type to Pickler's dispatch table """
+    def proxy(func):
+        Pickler.dispatch[t] = func
+        return func
+    return proxy
+
+def _revert_extension():
+    """drop dill-registered types from pickle's dispatch table"""
+    for type, func in list(StockPickler.dispatch.items()):
+        if func.__module__ == __name__:
+            del StockPickler.dispatch[type]
+            if type in pickle_dispatch_copy:
+                StockPickler.dispatch[type] = pickle_dispatch_copy[type]
+
+def use_diff(on=True):
+    """
+    Reduces size of pickles by only including object which have changed.
+
+    Decreases pickle size but increases CPU time needed.
+    Also helps avoid some unpicklable objects.
+    MUST be called at start of script, otherwise changes will not be recorded.
+    """
+    global _use_diff, diff
+    _use_diff = on
+    if _use_diff and diff is None:
+        try:
+            from . import diff as d
+        except:
+            import diff as d
+        diff = d
+
+def _create_typemap():
+    import types
+    if PY3:
+        d = dict(list(__builtin__.__dict__.items()) + \
+                 list(types.__dict__.items())).items()
+        builtin = 'builtins'
+    else:
+        d = types.__dict__.iteritems()
+        builtin = '__builtin__'
+    for key, value in d:
+        if getattr(value, '__module__', None) == builtin \
+        and type(value) is type:
+            yield key, value
+    return
+_reverse_typemap = dict(_create_typemap())
+_reverse_typemap.update({
+    'CellType': CellType,
+    'MethodWrapperType': MethodWrapperType,
+    'PartialType': PartialType,
+    'SuperType': SuperType,
+    'ItemGetterType': ItemGetterType,
+    'AttrGetterType': AttrGetterType,
+    'FileType': FileType,
+    'BufferedRandomType': BufferedRandomType,
+    'BufferedReaderType': BufferedReaderType,
+    'BufferedWriterType': BufferedWriterType,
+    'TextWrapperType': TextWrapperType,
+    'PyBufferedRandomType': PyBufferedRandomType,
+    'PyBufferedReaderType': PyBufferedReaderType,
+    'PyBufferedWriterType': PyBufferedWriterType,
+    'PyTextWrapperType': PyTextWrapperType,
+})
+if ExitType:
+    _reverse_typemap['ExitType'] = ExitType
+if InputType:
+    _reverse_typemap['InputType'] = InputType
+    _reverse_typemap['OutputType'] = OutputType
+if not IS_PYPY:
+    _reverse_typemap['WrapperDescriptorType'] = WrapperDescriptorType
+    _reverse_typemap['MethodDescriptorType'] = MethodDescriptorType
+    _reverse_typemap['ClassMethodDescriptorType'] = ClassMethodDescriptorType
+else:
+    _reverse_typemap['MemberDescriptorType'] = MemberDescriptorType
+if PY3:
+    _typemap = dict((v, k) for k, v in _reverse_typemap.items())
+else:
+    _typemap = dict((v, k) for k, v in _reverse_typemap.iteritems())
+
+def _unmarshal(string):
+    return marshal.loads(string)
+
+def _load_type(name):
+    return _reverse_typemap[name]
+
+def _create_type(typeobj, *args):
+    return typeobj(*args)
+
+def _create_function(fcode, fglobals, fname=None, fdefaults=None,
+                     fclosure=None, fdict=None, fkwdefaults=None):
+    # same as FunctionType, but enable passing __dict__ to new function,
+    # __dict__ is the storehouse for attributes added after function creation
+    func = FunctionType(fcode, fglobals or dict(), fname, fdefaults, fclosure)
+    if fdict is not None:
+        func.__dict__.update(fdict) #XXX: better copy? option to copy?
+    if fkwdefaults is not None:
+        func.__kwdefaults__ = fkwdefaults
+    # 'recurse' only stores referenced modules/objects in fglobals,
+    # thus we need to make sure that we have __builtins__ as well
+    if "__builtins__" not in func.__globals__:
+        func.__globals__["__builtins__"] = globals()["__builtins__"]
+    # assert id(fglobals) == id(func.__globals__)
+    return func
+
+def _create_code(*args):
+    if PY3 and hasattr(args[-3], 'encode'): #FIXME: from PY2 fails (optcode)
+        args = list(args)
+        if len(args) == 20:
+            args[-3] = args[-3].encode() # co_exceptiontable
+            args[-6] = args[-6].encode() # co_lnotab
+            args[-14] = args[-14].encode() # co_code
+            if args[-4] is not None:
+                args[-4] = args[-4].encode() # co_columntable
+            if args[-5] is not None:
+                args[-5] = args[-5].encode() # co_endlinetable
+        else:
+            args[-3] = args[-3].encode() # co_lnotab
+            args[-10] = args[-10].encode() # co_code
+    if hasattr(CodeType, 'co_exceptiontable'):
+        if len(args) == 20: return CodeType(*args)
+        elif len(args) == 16:
+            argz = (None, None, b'')
+            argz = args[:-4] + args[-5:-4] + args[-4:-2] + argz + args[-2:]
+            return CodeType(*argz)
+        elif len(args) == 15:
+            argz = args[1:-4] + args[-5:-4] + args[-4:-2] + argz + args[-2:]
+            return CodeType(args[0], 0, *argz)
+        argz = args[1:-4] + args[-5:-4] + args[-4:-2] + argz + args[-2:]
+        return CodeType(args[0], 0, 0, *argz)
+    elif hasattr(CodeType, 'co_posonlyargcount'):
+        if len(args) == 20:
+            return CodeType(*(args[:12] + args[13:15] + args[18:]))
+        elif len(args) == 16: return CodeType(*args)
+        elif len(args) == 15: return CodeType(args[0], 0, *args[1:])
+        return CodeType(args[0], 0, 0, *args[1:])
+    elif hasattr(CodeType, 'co_kwonlyargcount'):
+        if len(args) == 20:
+            return CodeType(*(args[:1] + args[2:12] + args[13:15] + args[18:]))
+        elif len(args) == 16: return CodeType(args[0], *args[2:])
+        elif len(args) == 15: return CodeType(*args)
+        return CodeType(args[0], 0, *args[1:])
+    if len(args) == 20:
+        return CodeType(*(args[:1] + args[3:12] + args[13:15] + args[18:]))
+    elif len(args) == 16: return CodeType(args[0], *args[3:])
+    elif len(args) == 15: return CodeType(args[0], *args[2:])
+    return CodeType(*args)
+
+def _create_ftype(ftypeobj, func, args, kwds):
+    if kwds is None:
+        kwds = {}
+    if args is None:
+        args = ()
+    return ftypeobj(func, *args, **kwds)
+
+def _create_lock(locked, *args): #XXX: ignores 'blocking'
+    from threading import Lock
+    lock = Lock()
+    if locked:
+        if not lock.acquire(False):
+            raise UnpicklingError("Cannot acquire lock")
+    return lock
+
+def _create_rlock(count, owner, *args): #XXX: ignores 'blocking'
+    lock = RLockType()
+    if owner is not None:
+        lock._acquire_restore((count, owner))
+    if owner and not lock._is_owned():
+        raise UnpicklingError("Cannot acquire lock")
+    return lock
+
+# thanks to matsjoyce for adding all the different file modes
+def _create_filehandle(name, mode, position, closed, open, strictio, fmode, fdata): # buffering=0
+    # only pickles the handle, not the file contents... good? or StringIO(data)?
+    # (for file contents see: http://effbot.org/librarybook/copy-reg.htm)
+    # NOTE: handle special cases first (are there more special cases?)
+    names = {'<stdin>':sys.__stdin__, '<stdout>':sys.__stdout__,
+             '<stderr>':sys.__stderr__} #XXX: better fileno=(0,1,2) ?
+    if name in list(names.keys()):
+        f = names[name] #XXX: safer "f=sys.stdin"
+    elif name == '<tmpfile>':
+        f = os.tmpfile()
+    elif name == '<fdopen>':
+        import tempfile
+        f = tempfile.TemporaryFile(mode)
+    else:
+        # treat x mode as w mode
+        if "x" in mode and sys.hexversion < 0x03030000:
+            raise ValueError("invalid mode: '%s'" % mode)
+        try:
+            exists = os.path.exists(name)
+        except:
+            exists = False
+        if not exists:
+            if strictio:
+                raise FileNotFoundError("[Errno 2] No such file or directory: '%s'" % name)
+            elif "r" in mode and fmode != FILE_FMODE:
+                name = '<fdopen>' # or os.devnull?
+            current_size = 0 # or maintain position?
+        else:
+            current_size = os.path.getsize(name)
+
+        if position > current_size:
+            if strictio:
+                raise ValueError("invalid buffer size")
+            elif fmode == CONTENTS_FMODE:
+                position = current_size
+        # try to open the file by name
+        # NOTE: has different fileno
+        try:
+            #FIXME: missing: *buffering*, encoding, softspace
+            if fmode == FILE_FMODE:
+                f = open(name, mode if "w" in mode else "w")
+                f.write(fdata)
+                if "w" not in mode:
+                    f.close()
+                    f = open(name, mode)
+            elif name == '<fdopen>': # file did not exist
+                import tempfile
+                f = tempfile.TemporaryFile(mode)
+            elif fmode == CONTENTS_FMODE \
+               and ("w" in mode or "x" in mode):
+                # stop truncation when opening
+                flags = os.O_CREAT
+                if "+" in mode:
+                    flags |= os.O_RDWR
+                else:
+                    flags |= os.O_WRONLY
+                f = os.fdopen(os.open(name, flags), mode)
+                # set name to the correct value
+                if PY3:
+                    r = getattr(f, "buffer", f)
+                    r = getattr(r, "raw", r)
+                    r.name = name
+                else:
+                    if not HAS_CTYPES:
+                        raise ImportError("No module named 'ctypes'")
+                    class FILE(ctypes.Structure):
+                        _fields_ = [("refcount", ctypes.c_long),
+                                    ("type_obj", ctypes.py_object),
+                                    ("file_pointer", ctypes.c_voidp),
+                                    ("name", ctypes.py_object)]
+
+                    class PyObject(ctypes.Structure):
+                        _fields_ = [
+                            ("ob_refcnt", ctypes.c_int),
+                            ("ob_type", ctypes.py_object)
+                            ]
+                    #FIXME: CONTENTS_FMODE fails for pypy due to issue #1233
+                    #       https://bitbucket.org/pypy/pypy/issues/1233
+                    ctypes.cast(id(f), ctypes.POINTER(FILE)).contents.name = name
+                    ctypes.cast(id(name), ctypes.POINTER(PyObject)).contents.ob_refcnt += 1
+                assert f.name == name
+            else:
+                f = open(name, mode)
+        except (IOError, FileNotFoundError):
+            err = sys.exc_info()[1]
+            raise UnpicklingError(err)
+    if closed:
+        f.close()
+    elif position >= 0 and fmode != HANDLE_FMODE:
+        f.seek(position)
+    return f
+
+def _create_stringi(value, position, closed):
+    f = StringIO(value)
+    if closed: f.close()
+    else: f.seek(position)
+    return f
+
+def _create_stringo(value, position, closed):
+    f = StringIO()
+    if closed: f.close()
+    else:
+       f.write(value)
+       f.seek(position)
+    return f
+
+class _itemgetter_helper(object):
+    def __init__(self):
+        self.items = []
+    def __getitem__(self, item):
+        self.items.append(item)
+        return
+
+class _attrgetter_helper(object):
+    def __init__(self, attrs, index=None):
+        self.attrs = attrs
+        self.index = index
+    def __getattribute__(self, attr):
+        attrs = object.__getattribute__(self, "attrs")
+        index = object.__getattribute__(self, "index")
+        if index is None:
+            index = len(attrs)
+            attrs.append(attr)
+        else:
+            attrs[index] = ".".join([attrs[index], attr])
+        return type(self)(attrs, index)
+
+class _dictproxy_helper(dict):
+   def __ror__(self, a):
+        return a
+
+_dictproxy_helper_instance = _dictproxy_helper()
+
+__d = {}
+try:
+    # In CPython 3.9 and later, this trick can be used to exploit the
+    # implementation of the __or__ function of MappingProxyType to get the true
+    # mapping referenced by the proxy. It may work for other implementations,
+    # but is not guaranteed.
+    MAPPING_PROXY_TRICK = __d is (DictProxyType(__d) | _dictproxy_helper_instance)
+except:
+    MAPPING_PROXY_TRICK = False
+del __d
+
+# _CELL_REF and _CELL_EMPTY are used to stay compatible with versions of dill
+# whose _create_cell functions do not have a default value.
+# _CELL_REF can be safely removed entirely (replaced by empty tuples for calls
+# to _create_cell) once breaking changes are allowed.
+_CELL_REF = None
+_CELL_EMPTY = Sentinel('_CELL_EMPTY')
+
+if PY3:
+    def _create_cell(contents=None):
+        if contents is not _CELL_EMPTY:
+            value = contents
+        return (lambda: value).__closure__[0]
+
+else:
+    def _create_cell(contents=None):
+        if contents is not _CELL_EMPTY:
+            value = contents
+        return (lambda: value).func_closure[0]
+
+
+def _create_weakref(obj, *args):
+    from weakref import ref
+    if obj is None: # it's dead
+        if PY3:
+            from collections import UserDict
+        else:
+            from UserDict import UserDict
+        return ref(UserDict(), *args)
+    return ref(obj, *args)
+
+def _create_weakproxy(obj, callable=False, *args):
+    from weakref import proxy
+    if obj is None: # it's dead
+        if callable: return proxy(lambda x:x, *args)
+        if PY3:
+            from collections import UserDict
+        else:
+            from UserDict import UserDict
+        return proxy(UserDict(), *args)
+    return proxy(obj, *args)
+
+def _eval_repr(repr_str):
+    return eval(repr_str)
+
+def _create_array(f, args, state, npdict=None):
+   #array = numpy.core.multiarray._reconstruct(*args)
+    array = f(*args)
+    array.__setstate__(state)
+    if npdict is not None: # we also have saved state in __dict__
+        array.__dict__.update(npdict)
+    return array
+
+def _create_dtypemeta(scalar_type):
+    if NumpyDType is True: __hook__() # a bit hacky I think
+    if scalar_type is None:
+        return NumpyDType
+    return type(NumpyDType(scalar_type))
+
+if OLD37:
+    def _create_namedtuple(name, fieldnames, modulename, defaults=None):
+        class_ = _import_module(modulename + '.' + name, safe=True)
+        if class_ is not None:
+            return class_
+        import collections
+        t = collections.namedtuple(name, fieldnames)
+        t.__module__ = modulename
+        return t
+else:
+    def _create_namedtuple(name, fieldnames, modulename, defaults=None):
+        class_ = _import_module(modulename + '.' + name, safe=True)
+        if class_ is not None:
+            return class_
+        import collections
+        t = collections.namedtuple(name, fieldnames, defaults=defaults, module=modulename)
+        return t
+
+def _getattr(objclass, name, repr_str):
+    # hack to grab the reference directly
+    try: #XXX: works only for __builtin__ ?
+        attr = repr_str.split("'")[3]
+        return eval(attr+'.__dict__["'+name+'"]')
+    except:
+        try:
+            attr = objclass.__dict__
+            if type(attr) is DictProxyType:
+                attr = attr[name]
+            else:
+                attr = getattr(objclass,name)
+        except:
+            attr = getattr(objclass,name)
+        return attr
+
+def _get_attr(self, name):
+    # stop recursive pickling
+    return getattr(self, name, None) or getattr(__builtin__, name)
+
+def _dict_from_dictproxy(dictproxy):
+    _dict = dictproxy.copy() # convert dictproxy to dict
+    _dict.pop('__dict__', None)
+    _dict.pop('__weakref__', None)
+    _dict.pop('__prepare__', None)
+    return _dict
+
+def _import_module(import_name, safe=False):
+    try:
+        if '.' in import_name:
+            items = import_name.split('.')
+            module = '.'.join(items[:-1])
+            obj = items[-1]
+        else:
+            return __import__(import_name)
+        return getattr(__import__(module, None, None, [obj]), obj)
+    except (ImportError, AttributeError):
+        if safe:
+            return None
+        raise
+
+def _locate_function(obj, pickler=None):
+    if obj.__module__ in ['__main__', None] or \
+            pickler and is_dill(pickler, child=False) and pickler._session and obj.__module__ == pickler._main.__name__:
+        return False
+
+    found = _import_module(obj.__module__ + '.' + obj.__name__, safe=True)
+    return found is obj
+
+
+def _setitems(dest, source):
+    for k, v in source.items():
+        dest[k] = v
+
+
+def _save_with_postproc(pickler, reduction, is_pickler_dill=None, obj=Getattr.NO_DEFAULT, postproc_list=None):
+    if obj is Getattr.NO_DEFAULT:
+        obj = Reduce(reduction) # pragma: no cover
+
+    if is_pickler_dill is None:
+        is_pickler_dill = is_dill(pickler, child=True)
+    if is_pickler_dill:
+        # assert id(obj) not in pickler._postproc, str(obj) + ' already pushed on stack!'
+        # if not hasattr(pickler, 'x'): pickler.x = 0
+        # print(pickler.x*' ', 'push', obj, id(obj), pickler._recurse)
+        # pickler.x += 1
+        if postproc_list is None:
+            postproc_list = []
+
+        # Recursive object not supported. Default to a global instead.
+        if id(obj) in pickler._postproc:
+            name = '%s.%s ' % (obj.__module__, getattr(obj, '__qualname__', obj.__name__)) if hasattr(obj, '__module__') else ''
+            warnings.warn('Cannot pickle %r: %shas recursive self-references that trigger a RecursionError.' % (obj, name), PicklingWarning)
+            pickler.save_global(obj)
+            return
+        pickler._postproc[id(obj)] = postproc_list
+
+    # TODO: Use state_setter in Python 3.8 to allow for faster cPickle implementations
+    pickler.save_reduce(*reduction, obj=obj)
+
+    if is_pickler_dill:
+        # pickler.x -= 1
+        # print(pickler.x*' ', 'pop', obj, id(obj))
+        postproc = pickler._postproc.pop(id(obj))
+        # assert postproc_list == postproc, 'Stack tampered!'
+        for reduction in reversed(postproc):
+            if reduction[0] is _setitems:
+                # use the internal machinery of pickle.py to speedup when
+                # updating a dictionary in postproc
+                dest, source = reduction[1]
+                if source:
+                    pickler.write(pickler.get(pickler.memo[id(dest)][0]))
+                    pickler._batch_setitems(iter(source.items()))
+                else:
+                    # Updating with an empty dictionary. Same as doing nothing.
+                    continue
+            else:
+                pickler.save_reduce(*reduction)
+            # pop None created by calling preprocessing step off stack
+            if PY3:
+                pickler.write(bytes('0', 'UTF-8'))
+            else:
+                pickler.write('0')
+
+#@register(CodeType)
+#def save_code(pickler, obj):
+#    log.info("Co: %s" % obj)
+#    pickler.save_reduce(_unmarshal, (marshal.dumps(obj),), obj=obj)
+#    log.info("# Co")
+#    return
+
+# The following function is based on 'save_codeobject' from 'cloudpickle'
+# Copyright (c) 2012, Regents of the University of California.
+# Copyright (c) 2009 `PiCloud, Inc. <http://www.picloud.com>`_.
+# License: https://github.com/cloudpipe/cloudpickle/blob/master/LICENSE
+@register(CodeType)
+def save_code(pickler, obj):
+    log.info("Co: %s" % obj)
+    if PY3:
+        if hasattr(obj, "co_exceptiontable"):
+            args = (
+                obj.co_argcount, obj.co_posonlyargcount,
+                obj.co_kwonlyargcount, obj.co_nlocals, obj.co_stacksize,
+                obj.co_flags, obj.co_code, obj.co_consts, obj.co_names,
+                obj.co_varnames, obj.co_filename, obj.co_name, obj.co_qualname,
+                obj.co_firstlineno, obj.co_lnotab, obj.co_endlinetable,
+                obj.co_columntable, obj.co_exceptiontable, obj.co_freevars,
+                obj.co_cellvars
+        )
+        elif hasattr(obj, "co_posonlyargcount"):
+            args = (
+                obj.co_argcount, obj.co_posonlyargcount,
+                obj.co_kwonlyargcount, obj.co_nlocals, obj.co_stacksize,
+                obj.co_flags, obj.co_code, obj.co_consts, obj.co_names,
+                obj.co_varnames, obj.co_filename, obj.co_name,
+                obj.co_firstlineno, obj.co_lnotab, obj.co_freevars,
+                obj.co_cellvars
+        )
+        else:
+            args = (
+                obj.co_argcount, obj.co_kwonlyargcount, obj.co_nlocals,
+                obj.co_stacksize, obj.co_flags, obj.co_code, obj.co_consts,
+                obj.co_names, obj.co_varnames, obj.co_filename,
+                obj.co_name, obj.co_firstlineno, obj.co_lnotab,
+                obj.co_freevars, obj.co_cellvars
+        )
+    else:
+        args = (
+            obj.co_argcount, obj.co_nlocals, obj.co_stacksize, obj.co_flags,
+            obj.co_code, obj.co_consts, obj.co_names, obj.co_varnames,
+            obj.co_filename, obj.co_name, obj.co_firstlineno, obj.co_lnotab,
+            obj.co_freevars, obj.co_cellvars
+        )
+
+    pickler.save_reduce(_create_code, args, obj=obj)
+    log.info("# Co")
+    return
+
+@register(dict)
+def save_module_dict(pickler, obj):
+    if is_dill(pickler, child=False) and obj == pickler._main.__dict__ and \
+            not (pickler._session and pickler._first_pass):
+        log.info("D1: <dict%s" % str(obj.__repr__).split('dict')[-1]) # obj
+        if PY3:
+            pickler.write(bytes('c__builtin__\n__main__\n', 'UTF-8'))
+        else:
+            pickler.write('c__builtin__\n__main__\n')
+        log.info("# D1")
+    elif (not is_dill(pickler, child=False)) and (obj == _main_module.__dict__):
+        log.info("D3: <dict%s" % str(obj.__repr__).split('dict')[-1]) # obj
+        if PY3:
+            pickler.write(bytes('c__main__\n__dict__\n', 'UTF-8'))
+        else:
+            pickler.write('c__main__\n__dict__\n')   #XXX: works in general?
+        log.info("# D3")
+    elif '__name__' in obj and obj != _main_module.__dict__ \
+    and type(obj['__name__']) is str \
+    and obj is getattr(_import_module(obj['__name__'],True), '__dict__', None):
+        log.info("D4: <dict%s" % str(obj.__repr__).split('dict')[-1]) # obj
+        if PY3:
+            pickler.write(bytes('c%s\n__dict__\n' % obj['__name__'], 'UTF-8'))
+        else:
+            pickler.write('c%s\n__dict__\n' % obj['__name__'])
+        log.info("# D4")
+    else:
+        log.info("D2: <dict%s" % str(obj.__repr__).split('dict')[-1]) # obj
+        if is_dill(pickler, child=False) and pickler._session:
+            # we only care about session the first pass thru
+            pickler._first_pass = False
+        StockPickler.save_dict(pickler, obj)
+        log.info("# D2")
+    return
+
+
+if not OLD310 and MAPPING_PROXY_TRICK:
+    def save_dict_view(dicttype):
+        def save_dict_view_for_function(func):
+            def _save_dict_view(pickler, obj):
+                log.info("Dkvi: <%s>" % (obj,))
+                mapping = obj.mapping | _dictproxy_helper_instance
+                pickler.save_reduce(func, (mapping,), obj=obj)
+                log.info("# Dkvi")
+            return _save_dict_view
+        return [
+            (funcname, save_dict_view_for_function(getattr(dicttype, funcname)))
+            for funcname in ('keys', 'values', 'items')
+        ]
+else:
+    # The following functions are based on 'cloudpickle'
+    # https://github.com/cloudpipe/cloudpickle/blob/5d89947288a18029672596a4d719093cc6d5a412/cloudpickle/cloudpickle.py#L922-L940
+    # Copyright (c) 2012, Regents of the University of California.
+    # Copyright (c) 2009 `PiCloud, Inc. <http://www.picloud.com>`_.
+    # License: https://github.com/cloudpipe/cloudpickle/blob/master/LICENSE
+    def save_dict_view(dicttype):
+        def save_dict_keys(pickler, obj):
+            log.info("Dk: <%s>" % (obj,))
+            dict_constructor = _shims.Reduce(dicttype.fromkeys, (list(obj),))
+            pickler.save_reduce(dicttype.keys, (dict_constructor,), obj=obj)
+            log.info("# Dk")
+
+        def save_dict_values(pickler, obj):
+            log.info("Dv: <%s>" % (obj,))
+            dict_constructor = _shims.Reduce(dicttype, (enumerate(obj),))
+            pickler.save_reduce(dicttype.values, (dict_constructor,), obj=obj)
+            log.info("# Dv")
+
+        def save_dict_items(pickler, obj):
+            log.info("Di: <%s>" % (obj,))
+            pickler.save_reduce(dicttype.items, (dicttype(obj),), obj=obj)
+            log.info("# Di")
+
+        return (
+            ('keys', save_dict_keys),
+            ('values', save_dict_values),
+            ('items', save_dict_items)
+        )
+
+for __dicttype in (
+      dict,
+      OrderedDict
+):
+    __obj = __dicttype()
+    for __funcname, __savefunc in save_dict_view(__dicttype):
+        __tview = type(getattr(__obj, __funcname)())
+        if __tview not in Pickler.dispatch:
+            Pickler.dispatch[__tview] = __savefunc
+del __dicttype, __obj, __funcname, __tview, __savefunc
+
+
+@register(ClassType)
+def save_classobj(pickler, obj): #FIXME: enable pickler._byref
+    if not _locate_function(obj, pickler):
+        log.info("C1: %s" % obj)
+        pickler.save_reduce(ClassType, (obj.__name__, obj.__bases__,
+                                        obj.__dict__), obj=obj)
+                                       #XXX: or obj.__dict__.copy()), obj=obj) ?
+        log.info("# C1")
+    else:
+        log.info("C2: %s" % obj)
+        name = getattr(obj, '__qualname__', getattr(obj, '__name__', None))
+        StockPickler.save_global(pickler, obj, name=name)
+        log.info("# C2")
+    return
+
+@register(LockType)
+def save_lock(pickler, obj):
+    log.info("Lo: %s" % obj)
+    pickler.save_reduce(_create_lock, (obj.locked(),), obj=obj)
+    log.info("# Lo")
+    return
+
+@register(RLockType)
+def save_rlock(pickler, obj):
+    log.info("RL: %s" % obj)
+    r = obj.__repr__() # don't use _release_save as it unlocks the lock
+    count = int(r.split('count=')[1].split()[0].rstrip('>'))
+    owner = int(r.split('owner=')[1].split()[0]) if PY3 else getattr(obj, '_RLock__owner')
+    pickler.save_reduce(_create_rlock, (count,owner,), obj=obj)
+    log.info("# RL")
+    return
+
+if not IS_PYPY2:
+    #@register(SocketType) #FIXME: causes multiprocess test_pickling FAIL
+    def save_socket(pickler, obj):
+        log.info("So: %s" % obj)
+        pickler.save_reduce(*reduce_socket(obj))
+        log.info("# So")
+        return
+
+if sys.hexversion <= 0x3050000:
+    @register(ItemGetterType)
+    def save_itemgetter(pickler, obj):
+        log.info("Ig: %s" % obj)
+        helper = _itemgetter_helper()
+        obj(helper)
+        pickler.save_reduce(type(obj), tuple(helper.items), obj=obj)
+        log.info("# Ig")
+        return
+
+    @register(AttrGetterType)
+    def save_attrgetter(pickler, obj):
+        log.info("Ag: %s" % obj)
+        attrs = []
+        helper = _attrgetter_helper(attrs)
+        obj(helper)
+        pickler.save_reduce(type(obj), tuple(attrs), obj=obj)
+        log.info("# Ag")
+        return
+
+def _save_file(pickler, obj, open_):
+    if obj.closed:
+        position = 0
+    else:
+        obj.flush()
+        if obj in (sys.__stdout__, sys.__stderr__, sys.__stdin__):
+            position = -1
+        else:
+            position = obj.tell()
+    if is_dill(pickler, child=True) and pickler._fmode == FILE_FMODE:
+        f = open_(obj.name, "r")
+        fdata = f.read()
+        f.close()
+    else:
+        fdata = ""
+    if is_dill(pickler, child=True):
+        strictio = pickler._strictio
+        fmode = pickler._fmode
+    else:
+        strictio = False
+        fmode = 0 # HANDLE_FMODE
+    pickler.save_reduce(_create_filehandle, (obj.name, obj.mode, position,
+                                             obj.closed, open_, strictio,
+                                             fmode, fdata), obj=obj)
+    return
+
+
+@register(FileType) #XXX: in 3.x has buffer=0, needs different _create?
+@register(BufferedRandomType)
+@register(BufferedReaderType)
+@register(BufferedWriterType)
+@register(TextWrapperType)
+def save_file(pickler, obj):
+    log.info("Fi: %s" % obj)
+    f = _save_file(pickler, obj, open)
+    log.info("# Fi")
+    return f
+
+if PyTextWrapperType:
+    @register(PyBufferedRandomType)
+    @register(PyBufferedReaderType)
+    @register(PyBufferedWriterType)
+    @register(PyTextWrapperType)
+    def save_file(pickler, obj):
+        log.info("Fi: %s" % obj)
+        f = _save_file(pickler, obj, _open)
+        log.info("# Fi")
+        return f
+
+# The following two functions are based on 'saveCStringIoInput'
+# and 'saveCStringIoOutput' from spickle
+# Copyright (c) 2011 by science+computing ag
+# License: http://www.apache.org/licenses/LICENSE-2.0
+if InputType:
+    @register(InputType)
+    def save_stringi(pickler, obj):
+        log.info("Io: %s" % obj)
+        if obj.closed:
+            value = ''; position = 0
+        else:
+            value = obj.getvalue(); position = obj.tell()
+        pickler.save_reduce(_create_stringi, (value, position, \
+                                              obj.closed), obj=obj)
+        log.info("# Io")
+        return
+
+    @register(OutputType)
+    def save_stringo(pickler, obj):
+        log.info("Io: %s" % obj)
+        if obj.closed:
+            value = ''; position = 0
+        else:
+            value = obj.getvalue(); position = obj.tell()
+        pickler.save_reduce(_create_stringo, (value, position, \
+                                              obj.closed), obj=obj)
+        log.info("# Io")
+        return
+
+if 0x2050000 <= sys.hexversion < 0x3010000:
+    @register(PartialType)
+    def save_functor(pickler, obj):
+        log.info("Fu: %s" % obj)
+        pickler.save_reduce(_create_ftype, (type(obj), obj.func, obj.args,
+                                            obj.keywords), obj=obj)
+        log.info("# Fu")
+        return
+
+if LRUCacheType is not None:
+    from functools import lru_cache
+    @register(LRUCacheType)
+    def save_lru_cache(pickler, obj):
+        log.info("LRU: %s" % obj)
+        if OLD39:
+            kwargs = obj.cache_info()
+            args = (kwargs.maxsize,)
+        else:
+            kwargs = obj.cache_parameters()
+            args = (kwargs['maxsize'], kwargs['typed'])
+        if args != lru_cache.__defaults__:
+            wrapper = Reduce(lru_cache, args, is_callable=True)
+        else:
+            wrapper = lru_cache
+        pickler.save_reduce(wrapper, (obj.__wrapped__,), obj=obj)
+        log.info("# LRU")
+        return
+
+@register(SuperType)
+def save_super(pickler, obj):
+    log.info("Su: %s" % obj)
+    pickler.save_reduce(super, (obj.__thisclass__, obj.__self__), obj=obj)
+    log.info("# Su")
+    return
+
+if OLDER or not PY3:
+    @register(BuiltinMethodType)
+    def save_builtin_method(pickler, obj):
+        if obj.__self__ is not None:
+            if obj.__self__ is __builtin__:
+                module = 'builtins' if PY3 else '__builtin__'
+                _t = "B1"
+                log.info("%s: %s" % (_t, obj))
+            else:
+                module = obj.__self__
+                _t = "B3"
+                log.info("%s: %s" % (_t, obj))
+            if is_dill(pickler, child=True):
+                _recurse = pickler._recurse
+                pickler._recurse = False
+            pickler.save_reduce(_get_attr, (module, obj.__name__), obj=obj)
+            if is_dill(pickler, child=True):
+                pickler._recurse = _recurse
+            log.info("# %s" % _t)
+        else:
+            log.info("B2: %s" % obj)
+            name = getattr(obj, '__qualname__', getattr(obj, '__name__', None))
+            StockPickler.save_global(pickler, obj, name=name)
+            log.info("# B2")
+        return
+
+    @register(MethodType) #FIXME: fails for 'hidden' or 'name-mangled' classes
+    def save_instancemethod0(pickler, obj):# example: cStringIO.StringI
+        log.info("Me: %s" % obj) #XXX: obj.__dict__ handled elsewhere?
+        if PY3:
+            pickler.save_reduce(MethodType, (obj.__func__, obj.__self__), obj=obj)
+        else:
+            pickler.save_reduce(MethodType, (obj.im_func, obj.im_self,
+                                             obj.im_class), obj=obj)
+        log.info("# Me")
+        return
+
+if sys.hexversion >= 0x20500f0:
+    if not IS_PYPY:
+        @register(MemberDescriptorType)
+        @register(GetSetDescriptorType)
+        @register(MethodDescriptorType)
+        @register(WrapperDescriptorType)
+        @register(ClassMethodDescriptorType)
+        def save_wrapper_descriptor(pickler, obj):
+            log.info("Wr: %s" % obj)
+            pickler.save_reduce(_getattr, (obj.__objclass__, obj.__name__,
+                                           obj.__repr__()), obj=obj)
+            log.info("# Wr")
+            return
+    else:
+        @register(MemberDescriptorType)
+        @register(GetSetDescriptorType)
+        def save_wrapper_descriptor(pickler, obj):
+            log.info("Wr: %s" % obj)
+            pickler.save_reduce(_getattr, (obj.__objclass__, obj.__name__,
+                                           obj.__repr__()), obj=obj)
+            log.info("# Wr")
+            return
+
+    @register(MethodWrapperType)
+    def save_instancemethod(pickler, obj):
+        log.info("Mw: %s" % obj)
+        if IS_PYPY2 and obj.__self__ is None and obj.im_class:
+            # Can be a class method in PYPY2 if __self__ is none
+            pickler.save_reduce(getattr, (obj.im_class, obj.__name__), obj=obj)
+            return
+        pickler.save_reduce(getattr, (obj.__self__, obj.__name__), obj=obj)
+        log.info("# Mw")
+        return
+
+elif not IS_PYPY:
+    @register(MethodDescriptorType)
+    @register(WrapperDescriptorType)
+    def save_wrapper_descriptor(pickler, obj):
+        log.info("Wr: %s" % obj)
+        pickler.save_reduce(_getattr, (obj.__objclass__, obj.__name__,
+                                       obj.__repr__()), obj=obj)
+        log.info("# Wr")
+        return
+
+@register(CellType)
+def save_cell(pickler, obj):
+    try:
+        f = obj.cell_contents
+    except:
+        log.info("Ce3: %s" % obj)
+        # _shims._CELL_EMPTY is defined in _shims.py to support PyPy 2.7.
+        # It unpickles to a sentinel object _dill._CELL_EMPTY, also created in
+        # _shims.py. This object is not present in Python 3 because the cell's
+        # contents can be deleted in newer versions of Python. The reduce object
+        # will instead unpickle to None if unpickled in Python 3.
+
+        # When breaking changes are made to dill, (_shims._CELL_EMPTY,) can
+        # be replaced by () OR the delattr function can be removed repending on
+        # whichever is more convienient.
+        pickler.save_reduce(_create_cell, (_shims._CELL_EMPTY,), obj=obj)
+        # Call the function _delattr on the cell's cell_contents attribute
+        # The result of this function call will be None
+        pickler.save_reduce(_shims._delattr, (obj, 'cell_contents'))
+        # pop None created by calling _delattr off stack
+        if PY3:
+            pickler.write(bytes('0', 'UTF-8'))
+        else:
+            pickler.write('0')
+        log.info("# Ce3")
+        return
+    if is_dill(pickler, child=True):
+        if id(f) in pickler._postproc:
+            # Already seen. Add to its postprocessing.
+            postproc = pickler._postproc[id(f)]
+        else:
+            # Haven't seen it. Add to the highest possible object and set its
+            # value as late as possible to prevent cycle.
+            postproc = next(iter(pickler._postproc.values()), None)
+        if postproc is not None:
+            log.info("Ce2: %s" % obj)
+            # _CELL_REF is defined in _shims.py to support older versions of
+            # dill. When breaking changes are made to dill, (_CELL_REF,) can
+            # be replaced by ()
+            pickler.save_reduce(_create_cell, (_CELL_REF,), obj=obj)
+            postproc.append((_shims._setattr, (obj, 'cell_contents', f)))
+            log.info("# Ce2")
+            return
+    log.info("Ce1: %s" % obj)
+    pickler.save_reduce(_create_cell, (f,), obj=obj)
+    log.info("# Ce1")
+    return
+
+if MAPPING_PROXY_TRICK:
+    @register(DictProxyType)
+    def save_dictproxy(pickler, obj):
+        log.info("Mp: %s" % obj)
+        mapping = obj | _dictproxy_helper_instance
+        pickler.save_reduce(DictProxyType, (mapping,), obj=obj)
+        log.info("# Mp")
+        return
+elif not IS_PYPY:
+    if not OLD33:
+        @register(DictProxyType)
+        def save_dictproxy(pickler, obj):
+            log.info("Mp: %s" % obj)
+            pickler.save_reduce(DictProxyType, (obj.copy(),), obj=obj)
+            log.info("# Mp")
+            return
+    else:
+        # The following function is based on 'saveDictProxy' from spickle
+        # Copyright (c) 2011 by science+computing ag
+        # License: http://www.apache.org/licenses/LICENSE-2.0
+        @register(DictProxyType)
+        def save_dictproxy(pickler, obj):
+            log.info("Dp: %s" % obj)
+            attr = obj.get('__dict__')
+           #pickler.save_reduce(_create_dictproxy, (attr,'nested'), obj=obj)
+            if type(attr) == GetSetDescriptorType and attr.__name__ == "__dict__" \
+            and getattr(attr.__objclass__, "__dict__", None) == obj:
+                pickler.save_reduce(getattr, (attr.__objclass__,"__dict__"),obj=obj)
+                log.info("# Dp")
+                return
+            # all bad below... so throw ReferenceError or TypeError
+            raise ReferenceError("%s does not reference a class __dict__" % obj)
+
+@register(SliceType)
+def save_slice(pickler, obj):
+    log.info("Sl: %s" % obj)
+    pickler.save_reduce(slice, (obj.start, obj.stop, obj.step), obj=obj)
+    log.info("# Sl")
+    return
+
+@register(XRangeType)
+@register(EllipsisType)
+@register(NotImplementedType)
+def save_singleton(pickler, obj):
+    log.info("Si: %s" % obj)
+    pickler.save_reduce(_eval_repr, (obj.__repr__(),), obj=obj)
+    log.info("# Si")
+    return
+
+def _proxy_helper(obj): # a dead proxy returns a reference to None
+    """get memory address of proxy's reference object"""
+    _repr = repr(obj)
+    try: _str = str(obj)
+    except ReferenceError: # it's a dead proxy
+        return id(None)
+    if _str == _repr: return id(obj) # it's a repr
+    try: # either way, it's a proxy from here
+        address = int(_str.rstrip('>').split(' at ')[-1], base=16)
+    except ValueError: # special case: proxy of a 'type'
+        if not IS_PYPY:
+            address = int(_repr.rstrip('>').split(' at ')[-1], base=16)
+        else:
+            objects = iter(gc.get_objects())
+            for _obj in objects:
+                if repr(_obj) == _str: return id(_obj)
+            # all bad below... nothing found so throw ReferenceError
+            msg = "Cannot reference object for proxy at '%s'" % id(obj)
+            raise ReferenceError(msg)
+    return address
+
+def _locate_object(address, module=None):
+    """get object located at the given memory address (inverse of id(obj))"""
+    special = [None, True, False] #XXX: more...?
+    for obj in special:
+        if address == id(obj): return obj
+    if module:
+        if PY3:
+            objects = iter(module.__dict__.values())
+        else:
+            objects = module.__dict__.itervalues()
+    else: objects = iter(gc.get_objects())
+    for obj in objects:
+        if address == id(obj): return obj
+    # all bad below... nothing found so throw ReferenceError or TypeError
+    try: address = hex(address)
+    except TypeError:
+        raise TypeError("'%s' is not a valid memory address" % str(address))
+    raise ReferenceError("Cannot reference object at '%s'" % address)
+
+@register(ReferenceType)
+def save_weakref(pickler, obj):
+    refobj = obj()
+    log.info("R1: %s" % obj)
+   #refobj = ctypes.pythonapi.PyWeakref_GetObject(obj) # dead returns "None"
+    pickler.save_reduce(_create_weakref, (refobj,), obj=obj)
+    log.info("# R1")
+    return
+
+@register(ProxyType)
+@register(CallableProxyType)
+def save_weakproxy(pickler, obj):
+    refobj = _locate_object(_proxy_helper(obj))
+    try:
+        _t = "R2"
+        log.info("%s: %s" % (_t, obj))
+    except ReferenceError:
+        _t = "R3"
+        log.info("%s: %s" % (_t, sys.exc_info()[1]))
+   #callable = bool(getattr(refobj, '__call__', None))
+    if type(obj) is CallableProxyType: callable = True
+    else: callable = False
+    pickler.save_reduce(_create_weakproxy, (refobj, callable), obj=obj)
+    log.info("# %s" % _t)
+    return
+
+def _is_builtin_module(module):
+    if not hasattr(module, "__file__"): return True
+    # If a module file name starts with prefix, it should be a builtin
+    # module, so should always be pickled as a reference.
+    names = ["base_prefix", "base_exec_prefix", "exec_prefix", "prefix", "real_prefix"]
+    return any(os.path.realpath(module.__file__).startswith(os.path.realpath(getattr(sys, name)))
+               for name in names if hasattr(sys, name)) or \
+            module.__file__.endswith(EXTENSION_SUFFIXES) or \
+            'site-packages' in module.__file__
+
+@register(ModuleType)
+def save_module(pickler, obj):
+    if False: #_use_diff:
+        if obj.__name__.split('.', 1)[0] != "dill":
+            try:
+                changed = diff.whats_changed(obj, seen=pickler._diff_cache)[0]
+            except RuntimeError:  # not memorised module, probably part of dill
+                pass
+            else:
+                log.info("M2: %s with diff" % obj)
+                log.info("Diff: %s", changed.keys())
+                pickler.save_reduce(_import_module, (obj.__name__,), obj=obj,
+                                    state=changed)
+                log.info("# M2")
+                return
+
+        log.info("M1: %s" % obj)
+        pickler.save_reduce(_import_module, (obj.__name__,), obj=obj)
+        log.info("# M1")
+    else:
+        builtin_mod = _is_builtin_module(obj)
+        if obj.__name__ not in ("builtins", "dill", "dill._dill") and not builtin_mod or \
+                is_dill(pickler, child=True) and obj is pickler._main:
+            log.info("M1: %s" % obj)
+            _main_dict = obj.__dict__.copy() #XXX: better no copy? option to copy?
+            [_main_dict.pop(item, None) for item in singletontypes
+                + ["__builtins__", "__loader__"]]
+            pickler.save_reduce(_import_module, (obj.__name__,), obj=obj,
+                                state=_main_dict)
+            log.info("# M1")
+        elif PY3 and obj.__name__ == "dill._dill":
+            log.info("M2: %s" % obj)
+            pickler.save_global(obj, name="_dill")
+            log.info("# M2")
+        else:
+            log.info("M2: %s" % obj)
+            pickler.save_reduce(_import_module, (obj.__name__,), obj=obj)
+            log.info("# M2")
+        return
+    return
+
+@register(TypeType)
+def save_type(pickler, obj, postproc_list=None):
+    if obj in _typemap:
+        log.info("T1: %s" % obj)
+        pickler.save_reduce(_load_type, (_typemap[obj],), obj=obj)
+        log.info("# T1")
+    elif obj.__bases__ == (tuple,) and all([hasattr(obj, attr) for attr in ('_fields','_asdict','_make','_replace')]):
+        # special case: namedtuples
+        log.info("T6: %s" % obj)
+        if OLD37 or (not obj._field_defaults):
+            pickler.save_reduce(_create_namedtuple, (obj.__name__, obj._fields, obj.__module__), obj=obj)
+        else:
+            defaults = [obj._field_defaults[field] for field in obj._fields if field in obj._field_defaults]
+            pickler.save_reduce(_create_namedtuple, (obj.__name__, obj._fields, obj.__module__, defaults), obj=obj)
+        log.info("# T6")
+        return
+
+    # special cases: NoneType, NotImplementedType, EllipsisType
+    elif obj is type(None):
+        log.info("T7: %s" % obj)
+        #XXX: pickler.save_reduce(type, (None,), obj=obj)
+        if PY3:
+            pickler.write(bytes('c__builtin__\nNoneType\n', 'UTF-8'))
+        else:
+            pickler.write('c__builtin__\nNoneType\n')
+        log.info("# T7")
+    elif obj is NotImplementedType:
+        log.info("T7: %s" % obj)
+        pickler.save_reduce(type, (NotImplemented,), obj=obj)
+        log.info("# T7")
+    elif obj is EllipsisType:
+        log.info("T7: %s" % obj)
+        pickler.save_reduce(type, (Ellipsis,), obj=obj)
+        log.info("# T7")
+
+    else:
+        obj_name = getattr(obj, '__qualname__', getattr(obj, '__name__', None))
+        _byref = getattr(pickler, '_byref', None)
+        obj_recursive = id(obj) in getattr(pickler, '_postproc', ())
+        incorrectly_named = not _locate_function(obj, pickler)
+        if not _byref and not obj_recursive and incorrectly_named: # not a function, but the name was held over
+            if issubclass(type(obj), type):
+                # thanks to Tom Stepleton pointing out pickler._session unneeded
+                _t = 'T2'
+                log.info("%s: %s" % (_t, obj))
+                _dict = _dict_from_dictproxy(obj.__dict__)
+            else:
+                _t = 'T3'
+                log.info("%s: %s" % (_t, obj))
+                _dict = obj.__dict__
+           #print (_dict)
+           #print ("%s\n%s" % (type(obj), obj.__name__))
+           #print ("%s\n%s" % (obj.__bases__, obj.__dict__))
+            for name in _dict.get("__slots__", []):
+                del _dict[name]
+            if PY3 and obj_name != obj.__name__:
+                if postproc_list is None:
+                    postproc_list = []
+                postproc_list.append((setattr, (obj, '__qualname__', obj_name)))
+            _save_with_postproc(pickler, (_create_type, (
+                type(obj), obj.__name__, obj.__bases__, _dict
+            )), obj=obj, postproc_list=postproc_list)
+            log.info("# %s" % _t)
+        else:
+            log.info("T4: %s" % obj)
+            if incorrectly_named:
+                warnings.warn('Cannot locate reference to %r.' % (obj,), PicklingWarning)
+            if obj_recursive:
+                warnings.warn('Cannot pickle %r: %s.%s has recursive self-references that trigger a RecursionError.' % (obj, obj.__module__, obj_name), PicklingWarning)
+           #print (obj.__dict__)
+           #print ("%s\n%s" % (type(obj), obj.__name__))
+           #print ("%s\n%s" % (obj.__bases__, obj.__dict__))
+            StockPickler.save_global(pickler, obj, name=obj_name)
+            log.info("# T4")
+    return
+
+# Error in PyPy 2.7 when adding ABC support
+if IS_PYPY2:
+    @register(FrameType)
+    def save_frame(pickler, obj):
+        raise PicklingError('Cannot pickle a Python stack frame')
+
+@register(property)
+def save_property(pickler, obj):
+    log.info("Pr: %s" % obj)
+    pickler.save_reduce(property, (obj.fget, obj.fset, obj.fdel, obj.__doc__),
+                        obj=obj)
+    log.info("# Pr")
+
+@register(staticmethod)
+@register(classmethod)
+def save_classmethod(pickler, obj):
+    log.info("Cm: %s" % obj)
+    im_func = '__func__' if PY3 else 'im_func'
+    try:
+        orig_func = getattr(obj, im_func)
+    except AttributeError:  # Python 2.6
+        orig_func = obj.__get__(None, object)
+        if isinstance(obj, classmethod):
+            orig_func = getattr(orig_func, im_func) # Unbind
+
+    # if PY3:
+    #     if type(obj.__dict__) is dict:
+    #         if obj.__dict__:
+    #             state = obj.__dict__
+    #         else:
+    #             state = None
+    #     else:
+    #         state = (None, {'__dict__', obj.__dict__})
+    # else:
+    #     state = None
+
+    pickler.save_reduce(type(obj), (orig_func,), obj=obj)
+    log.info("# Cm")
+
+@register(FunctionType)
+def save_function(pickler, obj):
+    if not _locate_function(obj, pickler):
+        log.info("F1: %s" % obj)
+        _recurse = getattr(pickler, '_recurse', None)
+        _byref = getattr(pickler, '_byref', None)
+        _postproc = getattr(pickler, '_postproc', None)
+        _main_modified = getattr(pickler, '_main_modified', None)
+        _original_main = getattr(pickler, '_original_main', __builtin__)#'None'
+        postproc_list = []
+        if _recurse:
+            # recurse to get all globals referred to by obj
+            from .detect import globalvars
+            globs_copy = globalvars(obj, recurse=True, builtin=True)
+
+            # Add the name of the module to the globs dictionary to prevent
+            # the duplication of the dictionary. Pickle the unpopulated
+            # globals dictionary and set the remaining items after the function
+            # is created to correctly handle recursion.
+            globs = {'__name__': obj.__module__}
+        else:
+            globs_copy = obj.__globals__ if PY3 else obj.func_globals
+
+            # If the globals is the __dict__ from the module being saved as a
+            # session, substitute it by the dictionary being actually saved.
+            if _main_modified and globs_copy is _original_main.__dict__:
+                globs_copy = getattr(pickler, '_main', _original_main).__dict__
+                globs = globs_copy
+            # If the globals is a module __dict__, do not save it in the pickle.
+            elif globs_copy is not None and obj.__module__ is not None and \
+                    getattr(_import_module(obj.__module__, True), '__dict__', None) is globs_copy:
+                globs = globs_copy
+            else:
+                globs = {'__name__': obj.__module__}
+
+        if globs_copy is not None and globs is not globs_copy:
+            # In the case that the globals are copied, we need to ensure that
+            # the globals dictionary is updated when all objects in the
+            # dictionary are already created.
+            if PY3:
+                glob_ids = {id(g) for g in globs_copy.values()}
+            else:
+                glob_ids = {id(g) for g in globs_copy.itervalues()}
+            for stack_element in _postproc:
+                if stack_element in glob_ids:
+                    _postproc[stack_element].append((_setitems, (globs, globs_copy)))
+                    break
+            else:
+                postproc_list.append((_setitems, (globs, globs_copy)))
+
+        if PY3:
+            closure = obj.__closure__
+            state_dict = {}
+            for fattrname in ('__doc__', '__kwdefaults__', '__annotations__'):
+                fattr = getattr(obj, fattrname, None)
+                if fattr is not None:
+                    state_dict[fattrname] = fattr
+            if obj.__qualname__ != obj.__name__:
+                state_dict['__qualname__'] = obj.__qualname__
+            if '__name__' not in globs or obj.__module__ != globs['__name__']:
+                state_dict['__module__'] = obj.__module__
+
+            state = obj.__dict__
+            if type(state) is not dict:
+                state_dict['__dict__'] = state
+                state = None
+            if state_dict:
+                state = state, state_dict
+
+            _save_with_postproc(pickler, (_create_function, (
+                  obj.__code__, globs, obj.__name__, obj.__defaults__,
+                  closure
+            ), state), obj=obj, postproc_list=postproc_list)
+        else:
+            closure = obj.func_closure
+            if obj.__doc__ is not None:
+                postproc_list.append((setattr, (obj, '__doc__', obj.__doc__)))
+            if '__name__' not in globs or obj.__module__ != globs['__name__']:
+                postproc_list.append((setattr, (obj, '__module__', obj.__module__)))
+            if obj.__dict__:
+                postproc_list.append((setattr, (obj, '__dict__', obj.__dict__)))
+
+            _save_with_postproc(pickler, (_create_function, (
+                obj.func_code, globs, obj.func_name, obj.func_defaults,
+                closure
+            )), obj=obj, postproc_list=postproc_list)
+
+        # Lift closure cell update to earliest function (#458)
+        if _postproc:
+            topmost_postproc = next(iter(_postproc.values()), None)
+            if closure and topmost_postproc:
+                for cell in closure:
+                    possible_postproc = (setattr, (cell, 'cell_contents', obj))
+                    try:
+                        topmost_postproc.remove(possible_postproc)
+                    except ValueError:
+                        continue
+
+                    # Change the value of the cell
+                    pickler.save_reduce(*possible_postproc)
+                    # pop None created by calling preprocessing step off stack
+                    if PY3:
+                        pickler.write(bytes('0', 'UTF-8'))
+                    else:
+                        pickler.write('0')
+
+        log.info("# F1")
+    else:
+        log.info("F2: %s" % obj)
+        name = getattr(obj, '__qualname__', getattr(obj, '__name__', None))
+        StockPickler.save_global(pickler, obj, name=name)
+        log.info("# F2")
+    return
+
+# quick sanity checking
+def pickles(obj,exact=False,safe=False,**kwds):
+    """
+    Quick check if object pickles with dill.
+
+    If *exact=True* then an equality test is done to check if the reconstructed
+    object matches the original object.
+
+    If *safe=True* then any exception will raised in copy signal that the
+    object is not picklable, otherwise only pickling errors will be trapped.
+
+    Additional keyword arguments are as :func:`dumps` and :func:`loads`.
+    """
+    if safe: exceptions = (Exception,) # RuntimeError, ValueError
+    else:
+        exceptions = (TypeError, AssertionError, PicklingError, UnpicklingError)
+    try:
+        pik = copy(obj, **kwds)
+        #FIXME: should check types match first, then check content if "exact"
+        try:
+            #FIXME: should be "(pik == obj).all()" for numpy comparison, though that'll fail if shapes differ
+            result = bool(pik.all() == obj.all())
+        except AttributeError:
+            warnings.filterwarnings('ignore')
+            result = pik == obj
+            warnings.resetwarnings()
+        if hasattr(result, 'toarray'): # for unusual types like sparse matrix
+            result = result.toarray().all()
+        if result: return True
+        if not exact:
+            result = type(pik) == type(obj)
+            if result: return result
+            # class instances might have been dumped with byref=False
+            return repr(type(pik)) == repr(type(obj)) #XXX: InstanceType?
+        return False
+    except exceptions:
+        return False
+
+def check(obj, *args, **kwds):
+    """
+    Check pickling of an object across another process.
+
+    *python* is the path to the python interpreter (defaults to sys.executable)
+
+    Set *verbose=True* to print the unpickled object in the other process.
+
+    Additional keyword arguments are as :func:`dumps` and :func:`loads`.
+    """
+   # == undocumented ==
+   # python -- the string path or executable name of the selected python
+   # verbose -- if True, be verbose about printing warning messages
+   # all other args and kwds are passed to dill.dumps #FIXME: ignore on load
+    verbose = kwds.pop('verbose', False)
+    python = kwds.pop('python', None)
+    if python is None:
+        import sys
+        python = sys.executable
+    # type check
+    isinstance(python, str)
+    import subprocess
+    fail = True
+    try:
+        _obj = dumps(obj, *args, **kwds)
+        fail = False
+    finally:
+        if fail and verbose:
+            print("DUMP FAILED")
+    #FIXME: fails if python interpreter path contains spaces
+    # Use the following instead (which also processes the 'ignore' keyword):
+    #    ignore = kwds.pop('ignore', None)
+    #    unpickle = "dill.loads(%s, ignore=%s)"%(repr(_obj), repr(ignore))
+    #    cmd = [python, "-c", "import dill; print(%s)"%unpickle]
+    #    msg = "SUCCESS" if not subprocess.call(cmd) else "LOAD FAILED"
+    msg = "%s -c import dill; print(dill.loads(%s))" % (python, repr(_obj))
+    msg = "SUCCESS" if not subprocess.call(msg.split(None,2)) else "LOAD FAILED"
+    if verbose:
+        print(msg)
+    return
+
+# use to protect against missing attributes
+def is_dill(pickler, child=None):
+    "check the dill-ness of your pickler"
+    if (child is False) or PY34 or (not hasattr(pickler.__class__, 'mro')):
+        return 'dill' in pickler.__module__
+    return Pickler in pickler.__class__.mro()
+
+def _extend():
+    """extend pickle with all of dill's registered types"""
+    # need to have pickle not choke on _main_module?  use is_dill(pickler)
+    for t,func in Pickler.dispatch.items():
+        try:
+            StockPickler.dispatch[t] = func
+        except: #TypeError, PicklingError, UnpicklingError
+            log.info("skip: %s" % t)
+        else: pass
+    return
+
+del diff, _use_diff, use_diff
+
+# EOF
diff --git a/myenv/lib/python3.9/site-packages/dill/_objects.py b/myenv/lib/python3.9/site-packages/dill/_objects.py
new file mode 100644
index 0000000..8b1cb65
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/_objects.py
@@ -0,0 +1,558 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+all Python Standard Library objects (currently: CH 1-15 @ 2.7)
+and some other common objects (i.e. numpy.ndarray)
+"""
+
+__all__ = ['registered','failures','succeeds']
+
+# helper imports
+import warnings; warnings.filterwarnings("ignore", category=DeprecationWarning)
+import sys
+PY3 = (hex(sys.hexversion) >= '0x30000f0')
+if PY3:
+    import queue as Queue
+    import dbm as anydbm
+else:
+    import Queue
+    import anydbm
+    import sets # deprecated/removed
+    import mutex # removed
+try:
+    from cStringIO import StringIO # has StringI and StringO types
+except ImportError: # only has StringIO type
+    if PY3:
+        from io import BytesIO as StringIO
+    else:
+        from StringIO import StringIO
+import re
+import array
+import collections
+import codecs
+import struct
+import datetime
+import calendar
+import weakref
+import pprint
+import decimal
+import functools
+import itertools
+import operator
+import tempfile
+import shelve
+import zlib
+import gzip
+import zipfile
+import tarfile
+import xdrlib
+import csv
+import hashlib
+import hmac
+import os
+import logging
+import optparse
+#import __hello__
+import threading
+import socket
+import contextlib
+try:
+    import bz2
+    import sqlite3
+    if PY3: import dbm.ndbm as dbm
+    else: import dbm
+    HAS_ALL = True
+except ImportError: # Ubuntu
+    HAS_ALL = False
+try:
+    #import curses
+    #from curses import textpad, panel
+    HAS_CURSES = True
+except ImportError: # Windows
+    HAS_CURSES = False
+try:
+    import ctypes
+    HAS_CTYPES = True
+    # if using `pypy`, pythonapi is not found
+    IS_PYPY = not hasattr(ctypes, 'pythonapi')
+except ImportError: # MacPorts
+    HAS_CTYPES = False
+    IS_PYPY = False
+
+# helper objects
+class _class:
+    def _method(self):
+        pass
+#   @classmethod
+#   def _clsmethod(cls): #XXX: test me
+#       pass
+#   @staticmethod
+#   def _static(self): #XXX: test me
+#       pass
+class _class2:
+    def __call__(self):
+        pass
+_instance2 = _class2()
+class _newclass(object):
+    def _method(self):
+        pass
+#   @classmethod
+#   def _clsmethod(cls): #XXX: test me
+#       pass
+#   @staticmethod
+#   def _static(self): #XXX: test me
+#       pass
+class _newclass2(object):
+    __slots__ = ['descriptor']
+def _function(x): yield x
+def _function2():
+    try: raise
+    except:
+        from sys import exc_info
+        e, er, tb = exc_info()
+        return er, tb
+if HAS_CTYPES:
+    class _Struct(ctypes.Structure):
+        pass
+    _Struct._fields_ = [("_field", ctypes.c_int),("next", ctypes.POINTER(_Struct))]
+_filedescrip, _tempfile = tempfile.mkstemp('r') # deleted in cleanup
+_tmpf = tempfile.TemporaryFile('w')
+
+# put the objects in order, if possible
+try:
+    from collections import OrderedDict as odict
+except ImportError:
+    try:
+        from ordereddict import OrderedDict as odict
+    except ImportError:
+        odict = dict
+# objects used by dill for type declaration
+registered = d = odict()
+# objects dill fails to pickle
+failures = x = odict()
+# all other type objects
+succeeds = a = odict()
+
+# types module (part of CH 8)
+a['BooleanType'] = bool(1)
+a['BuiltinFunctionType'] = len
+a['BuiltinMethodType'] = a['BuiltinFunctionType']
+a['BytesType'] = _bytes = codecs.latin_1_encode('\x00')[0] # bytes(1)
+a['ClassType'] = _class
+a['ComplexType'] = complex(1)
+a['DictType'] = _dict = {}
+a['DictionaryType'] = a['DictType']
+a['FloatType'] = float(1)
+a['FunctionType'] = _function
+a['InstanceType'] = _instance = _class()
+a['IntType'] = _int = int(1)
+a['ListType'] = _list = []
+a['NoneType'] = None
+a['ObjectType'] = object()
+a['StringType'] = _str = str(1)
+a['TupleType'] = _tuple = ()
+a['TypeType'] = type
+if PY3:
+    a['LongType'] = _int
+    a['UnicodeType'] = _str
+else:
+    a['LongType'] = long(1)
+    a['UnicodeType'] = unicode(1)
+# built-in constants (CH 4)
+a['CopyrightType'] = copyright
+# built-in types (CH 5)
+a['ClassObjectType'] = _newclass # <type 'type'>
+a['ClassInstanceType'] = _newclass() # <type 'class'>
+a['SetType'] = _set = set()
+a['FrozenSetType'] = frozenset()
+# built-in exceptions (CH 6)
+a['ExceptionType'] = _exception = _function2()[0]
+# string services (CH 7)
+a['SREPatternType'] = _srepattern = re.compile('')
+# data types (CH 8)
+a['ArrayType'] = array.array("f")
+a['DequeType'] = collections.deque([0])
+a['DefaultDictType'] = collections.defaultdict(_function, _dict)
+a['TZInfoType'] = datetime.tzinfo()
+a['DateTimeType'] = datetime.datetime.today()
+a['CalendarType'] = calendar.Calendar()
+if not PY3:
+    a['SetsType'] = sets.Set()
+    a['ImmutableSetType'] = sets.ImmutableSet()
+    a['MutexType'] = mutex.mutex()
+# numeric and mathematical types (CH 9)
+a['DecimalType'] = decimal.Decimal(1)
+a['CountType'] = itertools.count(0)
+# data compression and archiving (CH 12)
+a['TarInfoType'] = tarfile.TarInfo()
+# generic operating system services (CH 15)
+a['LoggerType'] = logging.getLogger()
+a['FormatterType'] = logging.Formatter() # pickle ok
+a['FilterType'] = logging.Filter() # pickle ok
+a['LogRecordType'] = logging.makeLogRecord(_dict) # pickle ok
+a['OptionParserType'] = _oparser = optparse.OptionParser() # pickle ok
+a['OptionGroupType'] = optparse.OptionGroup(_oparser,"foo") # pickle ok
+a['OptionType'] = optparse.Option('--foo') # pickle ok
+if HAS_CTYPES:
+    a['CCharType'] = _cchar = ctypes.c_char()
+    a['CWCharType'] = ctypes.c_wchar() # fail == 2.6
+    a['CByteType'] = ctypes.c_byte()
+    a['CUByteType'] = ctypes.c_ubyte()
+    a['CShortType'] = ctypes.c_short()
+    a['CUShortType'] = ctypes.c_ushort()
+    a['CIntType'] = ctypes.c_int()
+    a['CUIntType'] = ctypes.c_uint()
+    a['CLongType'] = ctypes.c_long()
+    a['CULongType'] = ctypes.c_ulong()
+    a['CLongLongType'] = ctypes.c_longlong()
+    a['CULongLongType'] = ctypes.c_ulonglong()
+    a['CFloatType'] = ctypes.c_float()
+    a['CDoubleType'] = ctypes.c_double()
+    a['CSizeTType'] = ctypes.c_size_t()
+    a['CLibraryLoaderType'] = ctypes.cdll
+    a['StructureType'] = _Struct
+    # if not IS_PYPY:
+    #     a['BigEndianStructureType'] = ctypes.BigEndianStructure()
+#NOTE: also LittleEndianStructureType and UnionType... abstract classes
+#NOTE: remember for ctypesobj.contents creates a new python object
+#NOTE: ctypes.c_int._objects is memberdescriptor for object's __dict__
+#NOTE: base class of all ctypes data types is non-public _CData
+
+try: # python 2.6
+    import fractions
+    import number
+    import io
+    from io import StringIO as TextIO
+    # built-in functions (CH 2)
+    a['ByteArrayType'] = bytearray([1])
+    # numeric and mathematical types (CH 9)
+    a['FractionType'] = fractions.Fraction()
+    a['NumberType'] = numbers.Number()
+    # generic operating system services (CH 15)
+    a['IOBaseType'] = io.IOBase()
+    a['RawIOBaseType'] = io.RawIOBase()
+    a['TextIOBaseType'] = io.TextIOBase()
+    a['BufferedIOBaseType'] = io.BufferedIOBase()
+    a['UnicodeIOType'] = TextIO() # the new StringIO
+    a['LoggingAdapterType'] = logging.LoggingAdapter(_logger,_dict) # pickle ok
+    if HAS_CTYPES:
+        a['CBoolType'] = ctypes.c_bool(1)
+        a['CLongDoubleType'] = ctypes.c_longdouble()
+except ImportError:
+    pass
+try: # python 2.7
+    import argparse
+    # data types (CH 8)
+    a['OrderedDictType'] = collections.OrderedDict(_dict)
+    a['CounterType'] = collections.Counter(_dict)
+    if HAS_CTYPES:
+        a['CSSizeTType'] = ctypes.c_ssize_t()
+    # generic operating system services (CH 15)
+    a['NullHandlerType'] = logging.NullHandler() # pickle ok  # new 2.7
+    a['ArgParseFileType'] = argparse.FileType() # pickle ok
+except (AttributeError, ImportError):
+    pass
+
+# -- pickle fails on all below here -----------------------------------------
+# types module (part of CH 8)
+a['CodeType'] = compile('','','exec')
+a['DictProxyType'] = type.__dict__
+a['DictProxyType2'] = _newclass.__dict__
+a['EllipsisType'] = Ellipsis
+a['ClosedFileType'] = open(os.devnull, 'wb', buffering=0).close()
+a['GetSetDescriptorType'] = array.array.typecode
+a['LambdaType'] = _lambda = lambda x: lambda y: x #XXX: works when not imported!
+a['MemberDescriptorType'] = _newclass2.descriptor
+if not IS_PYPY:
+    a['MemberDescriptorType2'] = datetime.timedelta.days
+a['MethodType'] = _method = _class()._method #XXX: works when not imported!
+a['ModuleType'] = datetime
+a['NotImplementedType'] = NotImplemented
+a['SliceType'] = slice(1)
+a['UnboundMethodType'] = _class._method #XXX: works when not imported!
+a['TextWrapperType'] = open(os.devnull, 'r') # same as mode='w','w+','r+'
+a['BufferedRandomType'] = open(os.devnull, 'r+b') # same as mode='w+b'
+a['BufferedReaderType'] = open(os.devnull, 'rb') # (default: buffering=-1)
+a['BufferedWriterType'] = open(os.devnull, 'wb')
+try: # oddities: deprecated
+    from _pyio import open as _open
+    a['PyTextWrapperType'] = _open(os.devnull, 'r', buffering=-1)
+    a['PyBufferedRandomType'] = _open(os.devnull, 'r+b', buffering=-1)
+    a['PyBufferedReaderType'] = _open(os.devnull, 'rb', buffering=-1)
+    a['PyBufferedWriterType'] = _open(os.devnull, 'wb', buffering=-1)
+except ImportError:
+    pass
+# other (concrete) object types
+if PY3:
+    d['CellType'] = (_lambda)(0).__closure__[0]
+    a['XRangeType'] = _xrange = range(1)
+else:
+    d['CellType'] = (_lambda)(0).func_closure[0]
+    a['XRangeType'] = _xrange = xrange(1)
+if not IS_PYPY:
+    d['MethodDescriptorType'] = type.__dict__['mro']
+    d['WrapperDescriptorType'] = type.__repr__
+    a['WrapperDescriptorType2'] = type.__dict__['__module__']
+    d['ClassMethodDescriptorType'] = type.__dict__['__prepare__' if PY3 else 'mro']
+# built-in functions (CH 2)
+if PY3 or IS_PYPY: 
+    _methodwrap = (1).__lt__
+else: 
+    _methodwrap = (1).__cmp__
+d['MethodWrapperType'] = _methodwrap
+a['StaticMethodType'] = staticmethod(_method)
+a['ClassMethodType'] = classmethod(_method)
+a['PropertyType'] = property()
+d['SuperType'] = super(Exception, _exception)
+# string services (CH 7)
+if PY3: 
+    _in = _bytes
+else: 
+    _in = _str
+a['InputType'] = _cstrI = StringIO(_in)
+a['OutputType'] = _cstrO = StringIO()
+# data types (CH 8)
+a['WeakKeyDictionaryType'] = weakref.WeakKeyDictionary()
+a['WeakValueDictionaryType'] = weakref.WeakValueDictionary()
+a['ReferenceType'] = weakref.ref(_instance)
+a['DeadReferenceType'] = weakref.ref(_class())
+a['ProxyType'] = weakref.proxy(_instance)
+a['DeadProxyType'] = weakref.proxy(_class())
+a['CallableProxyType'] = weakref.proxy(_instance2)
+a['DeadCallableProxyType'] = weakref.proxy(_class2())
+a['QueueType'] = Queue.Queue()
+# numeric and mathematical types (CH 9)
+d['PartialType'] = functools.partial(int,base=2)
+if PY3:
+    a['IzipType'] = zip('0','1')
+else:
+    a['IzipType'] = itertools.izip('0','1')
+a['ChainType'] = itertools.chain('0','1')
+d['ItemGetterType'] = operator.itemgetter(0)
+d['AttrGetterType'] = operator.attrgetter('__repr__')
+# file and directory access (CH 10)
+if PY3: _fileW = _cstrO
+else: _fileW = _tmpf
+# data persistence (CH 11)
+if HAS_ALL:
+    a['ConnectionType'] = _conn = sqlite3.connect(':memory:')
+    a['CursorType'] = _conn.cursor()
+a['ShelveType'] = shelve.Shelf({})
+# data compression and archiving (CH 12)
+if HAS_ALL:
+    if (hex(sys.hexversion) < '0x2070ef0') or PY3:
+        a['BZ2FileType'] = bz2.BZ2File(os.devnull) #FIXME: fail >= 3.3, 2.7.14
+    a['BZ2CompressorType'] = bz2.BZ2Compressor()
+    a['BZ2DecompressorType'] = bz2.BZ2Decompressor()
+#a['ZipFileType'] = _zip = zipfile.ZipFile(os.devnull,'w') #FIXME: fail >= 3.2
+#_zip.write(_tempfile,'x') [causes annoying warning/error printed on import]
+#a['ZipInfoType'] = _zip.getinfo('x')
+a['TarFileType'] = tarfile.open(fileobj=_fileW,mode='w')
+# file formats (CH 13)
+a['DialectType'] = csv.get_dialect('excel')
+a['PackerType'] = xdrlib.Packer()
+# optional operating system services (CH 16)
+a['LockType'] = threading.Lock()
+a['RLockType'] = threading.RLock()
+# generic operating system services (CH 15) # also closed/open and r/w/etc...
+a['NamedLoggerType'] = _logger = logging.getLogger(__name__) #FIXME: fail >= 3.2 and <= 2.6
+#a['FrozenModuleType'] = __hello__ #FIXME: prints "Hello world..."
+# interprocess communication (CH 17)
+if PY3:
+    a['SocketType'] = _socket = socket.socket() #FIXME: fail >= 3.3
+    a['SocketPairType'] = socket.socketpair()[0] #FIXME: fail >= 3.3
+else:
+    a['SocketType'] = _socket = socket.socket()
+    a['SocketPairType'] = _socket._sock
+# python runtime services (CH 27)
+if PY3:
+    a['GeneratorContextManagerType'] = contextlib.contextmanager(max)([1])
+else:
+    a['GeneratorContextManagerType'] = contextlib.GeneratorContextManager(max)
+
+try: # ipython
+    __IPYTHON__ is True # is ipython
+except NameError:
+    # built-in constants (CH 4)
+    a['QuitterType'] = quit
+    d['ExitType'] = a['QuitterType']
+try: # numpy #FIXME: slow... 0.05 to 0.1 sec to import numpy
+    from numpy import ufunc as _numpy_ufunc
+    from numpy import array as _numpy_array
+    from numpy import int32 as _numpy_int32
+    a['NumpyUfuncType'] = _numpy_ufunc
+    a['NumpyArrayType'] = _numpy_array
+    a['NumpyInt32Type'] = _numpy_int32
+except ImportError:
+    pass
+try: # python 2.6
+    # numeric and mathematical types (CH 9)
+    a['ProductType'] = itertools.product('0','1')
+    # generic operating system services (CH 15)
+    a['FileHandlerType'] = logging.FileHandler(os.devnull) #FIXME: fail >= 3.2 and <= 2.6
+    a['RotatingFileHandlerType'] = logging.handlers.RotatingFileHandler(os.devnull)
+    a['SocketHandlerType'] = logging.handlers.SocketHandler('localhost',514)
+    a['MemoryHandlerType'] = logging.handlers.MemoryHandler(1)
+except AttributeError:
+    pass
+try: # python 2.7
+    # data types (CH 8)
+    a['WeakSetType'] = weakref.WeakSet() # 2.7
+#   # generic operating system services (CH 15) [errors when dill is imported]
+#   a['ArgumentParserType'] = _parser = argparse.ArgumentParser('PROG')
+#   a['NamespaceType'] = _parser.parse_args() # pickle ok
+#   a['SubParsersActionType'] = _parser.add_subparsers()
+#   a['MutuallyExclusiveGroupType'] = _parser.add_mutually_exclusive_group()
+#   a['ArgumentGroupType'] = _parser.add_argument_group()
+except AttributeError:
+    pass
+
+# -- dill fails in some versions below here ---------------------------------
+# types module (part of CH 8)
+a['FileType'] = open(os.devnull, 'rb', buffering=0) # same 'wb','wb+','rb+'
+# FIXME: FileType fails >= 3.1
+# built-in functions (CH 2)
+a['ListIteratorType'] = iter(_list) # empty vs non-empty FIXME: fail < 3.2
+a['TupleIteratorType']= iter(_tuple) # empty vs non-empty FIXME: fail < 3.2
+a['XRangeIteratorType'] = iter(_xrange) # empty vs non-empty FIXME: fail < 3.2
+# data types (CH 8)
+a['PrettyPrinterType'] = pprint.PrettyPrinter() #FIXME: fail >= 3.2 and == 2.5
+# numeric and mathematical types (CH 9)
+a['CycleType'] = itertools.cycle('0') #FIXME: fail < 3.2
+# file and directory access (CH 10)
+a['TemporaryFileType'] = _tmpf #FIXME: fail >= 3.2 and == 2.5
+# data compression and archiving (CH 12)
+a['GzipFileType'] = gzip.GzipFile(fileobj=_fileW) #FIXME: fail > 3.2 and <= 2.6
+# generic operating system services (CH 15)
+a['StreamHandlerType'] = logging.StreamHandler() #FIXME: fail >= 3.2 and == 2.5
+try: # python 2.6
+    # numeric and mathematical types (CH 9)
+    a['PermutationsType'] = itertools.permutations('0') #FIXME: fail < 3.2
+    a['CombinationsType'] = itertools.combinations('0',1) #FIXME: fail < 3.2
+except AttributeError:
+    pass
+try: # python 2.7
+    # numeric and mathematical types (CH 9)
+    a['RepeatType'] = itertools.repeat(0) #FIXME: fail < 3.2
+    a['CompressType'] = itertools.compress('0',[1]) #FIXME: fail < 3.2
+    #XXX: ...and etc
+except AttributeError:
+    pass
+
+# -- dill fails on all below here -------------------------------------------
+# types module (part of CH 8)
+x['GeneratorType'] = _generator = _function(1) #XXX: priority
+x['FrameType'] = _generator.gi_frame #XXX: inspect.currentframe()
+x['TracebackType'] = _function2()[1] #(see: inspect.getouterframes,getframeinfo)
+# other (concrete) object types
+# (also: Capsule / CObject ?)
+# built-in functions (CH 2)
+x['SetIteratorType'] = iter(_set) #XXX: empty vs non-empty
+# built-in types (CH 5)
+if PY3:
+    x['DictionaryItemIteratorType'] = iter(type.__dict__.items())
+    x['DictionaryKeyIteratorType'] = iter(type.__dict__.keys())
+    x['DictionaryValueIteratorType'] = iter(type.__dict__.values())
+else:
+    x['DictionaryItemIteratorType'] = type.__dict__.iteritems()
+    x['DictionaryKeyIteratorType'] = type.__dict__.iterkeys()
+    x['DictionaryValueIteratorType'] = type.__dict__.itervalues()
+# string services (CH 7)
+x['StructType'] = struct.Struct('c')
+x['CallableIteratorType'] = _srepattern.finditer('')
+x['SREMatchType'] = _srepattern.match('')
+x['SREScannerType'] = _srepattern.scanner('')
+x['StreamReader'] = codecs.StreamReader(_cstrI) #XXX: ... and etc
+# python object persistence (CH 11)
+# x['DbShelveType'] = shelve.open('foo','n')#,protocol=2) #XXX: delete foo
+if HAS_ALL:
+    x['DbmType'] = dbm.open(_tempfile,'n')
+# x['DbCursorType'] = _dbcursor = anydbm.open('foo','n') #XXX: delete foo
+# x['DbType'] = _dbcursor.db
+# data compression and archiving (CH 12)
+x['ZlibCompressType'] = zlib.compressobj()
+x['ZlibDecompressType'] = zlib.decompressobj()
+# file formats (CH 13)
+x['CSVReaderType'] = csv.reader(_cstrI)
+x['CSVWriterType'] = csv.writer(_cstrO)
+x['CSVDictReaderType'] = csv.DictReader(_cstrI)
+x['CSVDictWriterType'] = csv.DictWriter(_cstrO,{})
+# cryptographic services (CH 14)
+x['HashType'] = hashlib.md5()
+if (hex(sys.hexversion) < '0x30800a1'):
+    x['HMACType'] = hmac.new(_in)
+else:
+    x['HMACType'] = hmac.new(_in, digestmod='md5')
+# generic operating system services (CH 15)
+if HAS_CURSES: pass
+    #x['CursesWindowType'] = _curwin = curses.initscr() #FIXME: messes up tty
+    #x['CursesTextPadType'] = textpad.Textbox(_curwin)
+    #x['CursesPanelType'] = panel.new_panel(_curwin)
+if HAS_CTYPES:
+    x['CCharPType'] = ctypes.c_char_p()
+    x['CWCharPType'] = ctypes.c_wchar_p()
+    x['CVoidPType'] = ctypes.c_void_p()
+    if sys.platform[:3] == 'win':
+        x['CDLLType'] = _cdll = ctypes.cdll.msvcrt
+    else:
+        x['CDLLType'] = _cdll = ctypes.CDLL(None)
+    if not IS_PYPY:
+        x['PyDLLType'] = _pydll = ctypes.pythonapi
+    x['FuncPtrType'] = _cdll._FuncPtr()
+    x['CCharArrayType'] = ctypes.create_string_buffer(1)
+    x['CWCharArrayType'] = ctypes.create_unicode_buffer(1)
+    x['CParamType'] = ctypes.byref(_cchar)
+    x['LPCCharType'] = ctypes.pointer(_cchar)
+    x['LPCCharObjType'] = _lpchar = ctypes.POINTER(ctypes.c_char)
+    x['NullPtrType'] = _lpchar()
+    x['NullPyObjectType'] = ctypes.py_object()
+    x['PyObjectType'] = ctypes.py_object(lambda :None)
+    x['FieldType'] = _field = _Struct._field
+    x['CFUNCTYPEType'] = _cfunc = ctypes.CFUNCTYPE(ctypes.c_char)
+    x['CFunctionType'] = _cfunc(str)
+try: # python 2.6
+    # numeric and mathematical types (CH 9)
+    x['MethodCallerType'] = operator.methodcaller('mro') # 2.6
+except AttributeError:
+    pass
+try: # python 2.7
+    # built-in types (CH 5)
+    x['MemoryType'] = memoryview(_in) # 2.7
+    x['MemoryType2'] = memoryview(bytearray(_in)) # 2.7
+    if PY3:
+        x['DictItemsType'] = _dict.items() # 2.7
+        x['DictKeysType'] = _dict.keys() # 2.7
+        x['DictValuesType'] = _dict.values() # 2.7
+    else:
+        x['DictItemsType'] = _dict.viewitems() # 2.7
+        x['DictKeysType'] = _dict.viewkeys() # 2.7
+        x['DictValuesType'] = _dict.viewvalues() # 2.7
+    # generic operating system services (CH 15)
+    x['RawTextHelpFormatterType'] = argparse.RawTextHelpFormatter('PROG')
+    x['RawDescriptionHelpFormatterType'] = argparse.RawDescriptionHelpFormatter('PROG')
+    x['ArgDefaultsHelpFormatterType'] = argparse.ArgumentDefaultsHelpFormatter('PROG')
+except NameError:
+    pass
+try: # python 2.7 (and not 3.1)
+    x['CmpKeyType'] = _cmpkey = functools.cmp_to_key(_methodwrap) # 2.7, >=3.2
+    x['CmpKeyObjType'] = _cmpkey('0') #2.7, >=3.2
+except AttributeError:
+    pass
+if PY3: # oddities: removed, etc
+    x['BufferType'] = x['MemoryType']
+else:
+    x['BufferType'] = buffer('')
+
+# -- cleanup ----------------------------------------------------------------
+a.update(d) # registered also succeed
+if sys.platform[:3] == 'win':
+    os.close(_filedescrip) # required on win32
+os.remove(_tempfile)
+
+
+# EOF
diff --git a/myenv/lib/python3.9/site-packages/dill/_shims.py b/myenv/lib/python3.9/site-packages/dill/_shims.py
new file mode 100644
index 0000000..6bda513
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/_shims.py
@@ -0,0 +1,266 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Author: Anirudh Vegesana (avegesan@stanford.edu)
+# Copyright (c) 2021-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+Provides shims for compatibility between versions of dill and Python.
+
+Compatibility shims should be provided in this file. Here are two simple example
+use cases.
+
+Deprecation of constructor function:
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Assume that we were transitioning _import_module in _dill.py to
+the builtin function importlib.import_module when present.
+
+@move_to(_dill)
+def _import_module(import_name):
+    ... # code already in _dill.py
+
+_import_module = Getattr(importlib, 'import_module', Getattr(_dill, '_import_module', None))
+
+The code will attempt to find import_module in the importlib module. If not
+present, it will use the _import_module function in _dill.
+
+Emulate new Python behavior in older Python versions:
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+CellType.cell_contents behaves differently in Python 3.6 and 3.7. It is
+read-only in Python 3.6 and writable and deletable in 3.7.
+
+if _dill.OLD37 and _dill.HAS_CTYPES and ...:
+    @move_to(_dill)
+    def _setattr(object, name, value):
+        if type(object) is _dill.CellType and name == 'cell_contents':
+            _PyCell_Set.argtypes = (ctypes.py_object, ctypes.py_object)
+            _PyCell_Set(object, value)
+        else:
+            setattr(object, name, value)
+... # more cases below
+
+_setattr = Getattr(_dill, '_setattr', setattr)
+
+_dill._setattr will be used when present to emulate Python 3.7 functionality in
+older versions of Python while defaulting to the standard setattr in 3.7+.
+
+See this PR for the discussion that lead to this system:
+https://github.com/uqfoundation/dill/pull/443
+"""
+
+import inspect, sys
+
+_dill = sys.modules['dill._dill']
+
+
+class Reduce(object):
+    """
+    Reduce objects are wrappers used for compatibility enforcement during
+    unpickle-time. They should only be used in calls to pickler.save and
+    other Reduce objects. They are only evaluated within unpickler.load.
+
+    Pickling a Reduce object makes the two implementations equivalent:
+
+    pickler.save(Reduce(*reduction))
+
+    pickler.save_reduce(*reduction, obj=reduction)
+    """
+    __slots__ = ['reduction']
+    def __new__(cls, *reduction, **kwargs):
+        """
+        Args:
+            *reduction: a tuple that matches the format given here:
+              https://docs.python.org/3/library/pickle.html#object.__reduce__
+            is_callable: a bool to indicate that the object created by
+              unpickling `reduction` is callable. If true, the current Reduce
+              is allowed to be used as the function in further save_reduce calls
+              or Reduce objects.
+        """
+        is_callable = kwargs.get('is_callable', False) # Pleases Py2. Can be removed later
+        if is_callable:
+            self = object.__new__(_CallableReduce)
+        else:
+            self = object.__new__(Reduce)
+        self.reduction = reduction
+        return self
+    def __repr__(self):
+        return 'Reduce%s' % (self.reduction,)
+    def __copy__(self):
+        return self # pragma: no cover
+    def __deepcopy__(self, memo):
+        return self # pragma: no cover
+    def __reduce__(self):
+        return self.reduction
+    def __reduce_ex__(self, protocol):
+        return self.__reduce__()
+
+class _CallableReduce(Reduce):
+    # A version of Reduce for functions. Used to trick pickler.save_reduce into
+    # thinking that Reduce objects of functions are themselves meaningful functions.
+    def __call__(self, *args, **kwargs):
+        reduction = self.__reduce__()
+        func = reduction[0]
+        f_args = reduction[1]
+        obj = func(*f_args)
+        return obj(*args, **kwargs)
+
+__NO_DEFAULT = _dill.Sentinel('Getattr.NO_DEFAULT')
+
+def Getattr(object, name, default=__NO_DEFAULT):
+    """
+    A Reduce object that represents the getattr operation. When unpickled, the
+    Getattr will access an attribute 'name' of 'object' and return the value
+    stored there. If the attribute doesn't exist, the default value will be
+    returned if present.
+
+    The following statements are equivalent:
+
+    Getattr(collections, 'OrderedDict')
+    Getattr(collections, 'spam', None)
+    Getattr(*args)
+
+    Reduce(getattr, (collections, 'OrderedDict'))
+    Reduce(getattr, (collections, 'spam', None))
+    Reduce(getattr, args)
+
+    During unpickling, the first two will result in collections.OrderedDict and
+    None respectively because the first attribute exists and the second one does
+    not, forcing it to use the default value given in the third argument.
+    """
+
+    if default is Getattr.NO_DEFAULT:
+        reduction = (getattr, (object, name))
+    else:
+        reduction = (getattr, (object, name, default))
+
+    return Reduce(*reduction, is_callable=callable(default))
+
+Getattr.NO_DEFAULT = __NO_DEFAULT
+del __NO_DEFAULT
+
+def move_to(module, name=None):
+    def decorator(func):
+        if name is None:
+            fname = func.__name__
+        else:
+            fname = name
+        module.__dict__[fname] = func
+        func.__module__ = module.__name__
+        return func
+    return decorator
+
+######################
+## Compatibility Shims are defined below
+######################
+
+_CELL_EMPTY = Getattr(_dill, '_CELL_EMPTY', None)
+
+if _dill.OLD37:
+    if _dill.HAS_CTYPES and hasattr(_dill.ctypes, 'pythonapi') and hasattr(_dill.ctypes.pythonapi, 'PyCell_Set'):
+        # CPython
+        ctypes = _dill.ctypes
+
+        _PyCell_Set = ctypes.pythonapi.PyCell_Set
+
+        @move_to(_dill)
+        def _setattr(object, name, value):
+            if type(object) is _dill.CellType and name == 'cell_contents':
+                _PyCell_Set.argtypes = (ctypes.py_object, ctypes.py_object)
+                _PyCell_Set(object, value)
+            else:
+                setattr(object, name, value)
+
+        @move_to(_dill)
+        def _delattr(object, name):
+            if type(object) is _dill.CellType and name == 'cell_contents':
+                _PyCell_Set.argtypes = (ctypes.py_object, ctypes.c_void_p)
+                _PyCell_Set(object, None)
+            else:
+                delattr(object, name)
+
+    # General Python (not CPython) up to 3.6 is in a weird case, where it is
+    # possible to pickle recursive cells, but we can't assign directly to the
+    # cell.
+    elif _dill.PY3:
+        # Use nonlocal variables to reassign the cell value.
+        # https://stackoverflow.com/a/59276835
+        __nonlocal = ('nonlocal cell',)
+        exec('''def _setattr(cell, name, value):
+            if type(cell) is _dill.CellType and name == 'cell_contents':
+                def cell_setter(value):
+                    %s
+                    cell = value # pylint: disable=unused-variable
+                func = _dill.FunctionType(cell_setter.__code__, globals(), "", None, (cell,)) # same as cell_setter, but with cell being the cell's contents
+                func(value)
+            else:
+                setattr(cell, name, value)''' % __nonlocal)
+        move_to(_dill)(_setattr)
+
+        exec('''def _delattr(cell, name):
+            if type(cell) is _dill.CellType and name == 'cell_contents':
+                try:
+                    cell.cell_contents
+                except:
+                    return
+                def cell_deleter():
+                    %s
+                    del cell # pylint: disable=unused-variable
+                func = _dill.FunctionType(cell_deleter.__code__, globals(), "", None, (cell,)) # same as cell_deleter, but with cell being the cell's contents
+                func()
+            else:
+                delattr(cell, name)''' % __nonlocal)
+        move_to(_dill)(_delattr)
+
+    else:
+        # Likely PyPy 2.7. Simulate the nonlocal keyword with bytecode
+        # manipulation.
+
+        # The following function is based on 'cell_set' from 'cloudpickle'
+        # https://github.com/cloudpipe/cloudpickle/blob/5d89947288a18029672596a4d719093cc6d5a412/cloudpickle/cloudpickle.py#L393-L482
+        # Copyright (c) 2012, Regents of the University of California.
+        # Copyright (c) 2009 `PiCloud, Inc. <http://www.picloud.com>`_.
+        # License: https://github.com/cloudpipe/cloudpickle/blob/master/LICENSE
+        @move_to(_dill)
+        def _setattr(cell, name, value):
+            if type(cell) is _dill.CellType and name == 'cell_contents':
+                _cell_set = _dill.FunctionType(
+                      _cell_set_template_code, {}, '_cell_set', (), (cell,),)
+                _cell_set(value)
+            else:
+                setattr(cell, name, value)
+
+        def _cell_set_factory(value):
+            lambda: cell
+            cell = value
+
+        co = _cell_set_factory.__code__
+
+        _cell_set_template_code = _dill.CodeType(
+            co.co_argcount,
+            co.co_nlocals,
+            co.co_stacksize,
+            co.co_flags,
+            co.co_code,
+            co.co_consts,
+            co.co_names,
+            co.co_varnames,
+            co.co_filename,
+            co.co_name,
+            co.co_firstlineno,
+            co.co_lnotab,
+            co.co_cellvars,  # co_freevars is initialized with co_cellvars
+            (),  # co_cellvars is made empty
+        )
+
+        del co
+
+        @move_to(_dill)
+        def _delattr(cell, name):
+            if type(cell) is _dill.CellType and name == 'cell_contents':
+                pass
+            else:
+                delattr(cell, name)
+
+_setattr = Getattr(_dill, '_setattr', setattr)
+_delattr = Getattr(_dill, '_delattr', delattr)
diff --git a/myenv/lib/python3.9/site-packages/dill/detect.py b/myenv/lib/python3.9/site-packages/dill/detect.py
new file mode 100644
index 0000000..4157520
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/detect.py
@@ -0,0 +1,327 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+Methods for detecting objects leading to pickling failures.
+"""
+
+import dis
+from inspect import ismethod, isfunction, istraceback, isframe, iscode
+from .pointers import parent, reference, at, parents, children
+
+from ._dill import _trace as trace
+from ._dill import PY3
+
+__all__ = ['baditems','badobjects','badtypes','code','errors','freevars',
+           'getmodule','globalvars','nestedcode','nestedglobals','outermost',
+           'referredglobals','referrednested','trace','varnames']
+
+def getmodule(object, _filename=None, force=False):
+    """get the module of the object"""
+    from inspect import getmodule as getmod
+    module = getmod(object, _filename)
+    if module or not force: return module
+    if PY3: builtins = 'builtins'
+    else: builtins = '__builtin__'
+    builtins = __import__(builtins)
+    from .source import getname
+    name = getname(object, force=True)
+    return builtins if name in vars(builtins).keys() else None
+
+def outermost(func): # is analogous to getsource(func,enclosing=True)
+    """get outermost enclosing object (i.e. the outer function in a closure)
+
+    NOTE: this is the object-equivalent of getsource(func, enclosing=True)
+    """
+    if PY3:
+        if ismethod(func):
+            _globals = func.__func__.__globals__ or {}
+        elif isfunction(func):
+            _globals = func.__globals__ or {}
+        else:
+            return #XXX: or raise? no matches
+        _globals = _globals.items()
+    else:
+        if ismethod(func):
+            _globals = func.im_func.func_globals or {}
+        elif isfunction(func):
+            _globals = func.func_globals or {}
+        else:
+            return #XXX: or raise? no matches
+        _globals = _globals.iteritems()
+    # get the enclosing source
+    from .source import getsourcelines
+    try: lines,lnum = getsourcelines(func, enclosing=True)
+    except: #TypeError, IOError
+        lines,lnum = [],None
+    code = ''.join(lines)
+    # get all possible names,objects that are named in the enclosing source
+    _locals = ((name,obj) for (name,obj) in _globals if name in code)
+    # now only save the objects that generate the enclosing block
+    for name,obj in _locals: #XXX: don't really need 'name'
+        try:
+            if getsourcelines(obj) == (lines,lnum): return obj
+        except: #TypeError, IOError
+            pass
+    return #XXX: or raise? no matches
+
+def nestedcode(func, recurse=True): #XXX: or return dict of {co_name: co} ?
+    """get the code objects for any nested functions (e.g. in a closure)"""
+    func = code(func)
+    if not iscode(func): return [] #XXX: or raise? no matches
+    nested = set()
+    for co in func.co_consts:
+        if co is None: continue
+        co = code(co)
+        if co:
+            nested.add(co)
+            if recurse: nested |= set(nestedcode(co, recurse=True))
+    return list(nested)
+
+def code(func):
+    '''get the code object for the given function or method
+
+    NOTE: use dill.source.getsource(CODEOBJ) to get the source code
+    '''
+    if PY3:
+        im_func = '__func__'
+        func_code = '__code__'
+    else:
+        im_func = 'im_func'
+        func_code = 'func_code'
+    if ismethod(func): func = getattr(func, im_func)
+    if isfunction(func): func = getattr(func, func_code)
+    if istraceback(func): func = func.tb_frame
+    if isframe(func): func = func.f_code
+    if iscode(func): return func
+    return
+
+#XXX: ugly: parse dis.dis for name after "<code object" in line and in globals?
+def referrednested(func, recurse=True): #XXX: return dict of {__name__: obj} ?
+    """get functions defined inside of func (e.g. inner functions in a closure)
+
+    NOTE: results may differ if the function has been executed or not.
+    If len(nestedcode(func)) > len(referrednested(func)), try calling func().
+    If possible, python builds code objects, but delays building functions
+    until func() is called.
+    """
+    if PY3:
+        att1 = '__code__'
+        att0 = '__func__'
+    else:
+        att1 = 'func_code' # functions
+        att0 = 'im_func'   # methods
+
+    import gc
+    funcs = set()
+    # get the code objects, and try to track down by referrence
+    for co in nestedcode(func, recurse):
+        # look for function objects that refer to the code object
+        for obj in gc.get_referrers(co):
+            # get methods
+            _ = getattr(obj, att0, None) # ismethod
+            if getattr(_, att1, None) is co: funcs.add(obj)
+            # get functions
+            elif getattr(obj, att1, None) is co: funcs.add(obj)
+            # get frame objects
+            elif getattr(obj, 'f_code', None) is co: funcs.add(obj)
+            # get code objects
+            elif hasattr(obj, 'co_code') and obj is co: funcs.add(obj)
+#     frameobjs => func.func_code.co_varnames not in func.func_code.co_cellvars
+#     funcobjs => func.func_code.co_cellvars not in func.func_code.co_varnames
+#     frameobjs are not found, however funcobjs are...
+#     (see: test_mixins.quad ... and test_mixins.wtf)
+#     after execution, code objects get compiled, and then may be found by gc
+    return list(funcs)
+
+
+def freevars(func):
+    """get objects defined in enclosing code that are referred to by func
+
+    returns a dict of {name:object}"""
+    if PY3:
+        im_func = '__func__'
+        func_code = '__code__'
+        func_closure = '__closure__'
+    else:
+        im_func = 'im_func'
+        func_code = 'func_code'
+        func_closure = 'func_closure'
+    if ismethod(func): func = getattr(func, im_func)
+    if isfunction(func):
+        closures = getattr(func, func_closure) or ()
+        func = getattr(func, func_code).co_freevars # get freevars
+    else:
+        return {}
+
+    def get_cell_contents():
+        for (name,c) in zip(func,closures):
+            try:
+                cell_contents = c.cell_contents
+            except:
+                continue
+            yield (name,c.cell_contents)
+
+    return dict(get_cell_contents())
+
+# thanks to Davies Liu for recursion of globals
+def nestedglobals(func, recurse=True):
+    """get the names of any globals found within func"""
+    func = code(func)
+    if func is None: return list()
+    import sys
+    from .temp import capture
+    CAN_NULL = sys.hexversion >= 51052711 #NULL may be prepended >= 3.11a7
+    names = set()
+    with capture('stdout') as out:
+        dis.dis(func) #XXX: dis.dis(None) disassembles last traceback
+    for line in out.getvalue().splitlines():
+        if '_GLOBAL' in line:
+            name = line.split('(')[-1].split(')')[0]
+            if CAN_NULL:
+                names.add(name.replace('NULL + ', ''))
+            else:
+                names.add(name)
+    for co in getattr(func, 'co_consts', tuple()):
+        if co and recurse and iscode(co):
+            names.update(nestedglobals(co, recurse=True))
+    return list(names)
+
+def referredglobals(func, recurse=True, builtin=False):
+    """get the names of objects in the global scope referred to by func"""
+    return globalvars(func, recurse, builtin).keys()
+
+def globalvars(func, recurse=True, builtin=False):
+    """get objects defined in global scope that are referred to by func
+
+    return a dict of {name:object}"""
+    if PY3:
+        im_func = '__func__'
+        func_code = '__code__'
+        func_globals = '__globals__'
+        func_closure = '__closure__'
+    else:
+        im_func = 'im_func'
+        func_code = 'func_code'
+        func_globals = 'func_globals'
+        func_closure = 'func_closure'
+    if ismethod(func): func = getattr(func, im_func)
+    if isfunction(func):
+        globs = vars(getmodule(sum)).copy() if builtin else {}
+        # get references from within closure
+        orig_func, func = func, set()
+        for obj in getattr(orig_func, func_closure) or {}:
+            try:
+                cell_contents = obj.cell_contents
+            except:
+                pass
+            else:
+                _vars = globalvars(cell_contents, recurse, builtin) or {}
+                func.update(_vars) #XXX: (above) be wary of infinte recursion?
+                globs.update(_vars)
+        # get globals
+        globs.update(getattr(orig_func, func_globals) or {})
+        # get names of references
+        if not recurse:
+            func.update(getattr(orig_func, func_code).co_names)
+        else:
+            func.update(nestedglobals(getattr(orig_func, func_code)))
+            # find globals for all entries of func
+            for key in func.copy(): #XXX: unnecessary...?
+                nested_func = globs.get(key)
+                if nested_func is orig_func:
+                   #func.remove(key) if key in func else None
+                    continue  #XXX: globalvars(func, False)?
+                func.update(globalvars(nested_func, True, builtin))
+    elif iscode(func):
+        globs = vars(getmodule(sum)).copy() if builtin else {}
+       #globs.update(globals())
+        if not recurse:
+            func = func.co_names # get names
+        else:
+            orig_func = func.co_name # to stop infinite recursion
+            func = set(nestedglobals(func))
+            # find globals for all entries of func
+            for key in func.copy(): #XXX: unnecessary...?
+                if key is orig_func:
+                   #func.remove(key) if key in func else None
+                    continue  #XXX: globalvars(func, False)?
+                nested_func = globs.get(key)
+                func.update(globalvars(nested_func, True, builtin))
+    else:
+        return {}
+    #NOTE: if name not in func_globals, then we skip it...
+    return dict((name,globs[name]) for name in func if name in globs)
+
+
+def varnames(func):
+    """get names of variables defined by func
+
+    returns a tuple (local vars, local vars referrenced by nested functions)"""
+    func = code(func)
+    if not iscode(func):
+        return () #XXX: better ((),())? or None?
+    return func.co_varnames, func.co_cellvars
+
+
+def baditems(obj, exact=False, safe=False): #XXX: obj=globals() ?
+    """get items in object that fail to pickle"""
+    if not hasattr(obj,'__iter__'): # is not iterable
+        return [j for j in (badobjects(obj,0,exact,safe),) if j is not None]
+    obj = obj.values() if getattr(obj,'values',None) else obj
+    _obj = [] # can't use a set, as items may be unhashable
+    [_obj.append(badobjects(i,0,exact,safe)) for i in obj if i not in _obj]
+    return [j for j in _obj if j is not None]
+
+
+def badobjects(obj, depth=0, exact=False, safe=False):
+    """get objects that fail to pickle"""
+    from dill import pickles
+    if not depth:
+        if pickles(obj,exact,safe): return None
+        return obj
+    return dict(((attr, badobjects(getattr(obj,attr),depth-1,exact,safe)) \
+           for attr in dir(obj) if not pickles(getattr(obj,attr),exact,safe)))
+
+def badtypes(obj, depth=0, exact=False, safe=False):
+    """get types for objects that fail to pickle"""
+    from dill import pickles
+    if not depth:
+        if pickles(obj,exact,safe): return None
+        return type(obj)
+    return dict(((attr, badtypes(getattr(obj,attr),depth-1,exact,safe)) \
+           for attr in dir(obj) if not pickles(getattr(obj,attr),exact,safe)))
+
+def errors(obj, depth=0, exact=False, safe=False):
+    """get errors for objects that fail to pickle"""
+    from dill import pickles, copy
+    if not depth:
+        try:
+            pik = copy(obj)
+            if exact:
+                assert pik == obj, \
+                    "Unpickling produces %s instead of %s" % (pik,obj)
+            assert type(pik) == type(obj), \
+                "Unpickling produces %s instead of %s" % (type(pik),type(obj))
+            return None
+        except Exception:
+            import sys
+            return sys.exc_info()[1]
+    _dict = {}
+    for attr in dir(obj):
+        try:
+            _attr = getattr(obj,attr)
+        except Exception:
+            import sys
+            _dict[attr] = sys.exc_info()[1]
+            continue
+        if not pickles(_attr,exact,safe):
+            _dict[attr] = errors(_attr,depth-1,exact,safe)
+    return _dict
+
+
+# EOF
diff --git a/myenv/lib/python3.9/site-packages/dill/objtypes.py b/myenv/lib/python3.9/site-packages/dill/objtypes.py
new file mode 100644
index 0000000..37fbbc4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/objtypes.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+all Python Standard Library object types (currently: CH 1-15 @ 2.7)
+and some other common object types (i.e. numpy.ndarray)
+
+to load more objects and types, use dill.load_types()
+"""
+
+# non-local import of dill.objects
+from dill import objects
+for _type in objects.keys():
+    exec("%s = type(objects['%s'])" % (_type,_type))
+    
+del objects
+try:
+    del _type
+except NameError:
+    pass
diff --git a/myenv/lib/python3.9/site-packages/dill/pointers.py b/myenv/lib/python3.9/site-packages/dill/pointers.py
new file mode 100644
index 0000000..ca3a198
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/pointers.py
@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+__all__ = ['parent', 'reference', 'at', 'parents', 'children']
+
+import gc
+import sys
+
+from ._dill import _proxy_helper as reference
+from ._dill import _locate_object as at
+
+def parent(obj, objtype, ignore=()):
+    """
+>>> listiter = iter([4,5,6,7])
+>>> obj = parent(listiter, list)
+>>> obj == [4,5,6,7]  # actually 'is', but don't have handle any longer
+True
+
+NOTE: objtype can be a single type (e.g. int or list) or a tuple of types.
+
+WARNING: if obj is a sequence (e.g. list), may produce unexpected results.
+Parent finds *one* parent (e.g. the last member of the sequence).
+    """
+    depth = 1 #XXX: always looking for the parent (only, right?)
+    chain = parents(obj, objtype, depth, ignore)
+    parent = chain.pop()
+    if parent is obj:
+        return None
+    return parent
+
+
+def parents(obj, objtype, depth=1, ignore=()): #XXX: objtype=object ?
+    """Find the chain of referents for obj. Chain will end with obj.
+
+    objtype: an object type or tuple of types to search for
+    depth: search depth (e.g. depth=2 is 'grandparents')
+    ignore: an object or tuple of objects to ignore in the search
+    """
+    edge_func = gc.get_referents # looking for refs, not back_refs
+    predicate = lambda x: isinstance(x, objtype) # looking for parent type
+   #if objtype is None: predicate = lambda x: True #XXX: in obj.mro() ?
+    ignore = (ignore,) if not hasattr(ignore, '__len__') else ignore
+    ignore = (id(obj) for obj in ignore)
+    chain = find_chain(obj, predicate, edge_func, depth)[::-1]
+    #XXX: should pop off obj... ?
+    return chain
+
+
+def children(obj, objtype, depth=1, ignore=()): #XXX: objtype=object ?
+    """Find the chain of referrers for obj. Chain will start with obj.
+
+    objtype: an object type or tuple of types to search for
+    depth: search depth (e.g. depth=2 is 'grandchildren')
+    ignore: an object or tuple of objects to ignore in the search
+
+    NOTE: a common thing to ignore is all globals, 'ignore=(globals(),)'
+
+    NOTE: repeated calls may yield different results, as python stores
+    the last value in the special variable '_'; thus, it is often good
+    to execute something to replace '_' (e.g. >>> 1+1).
+    """
+    edge_func = gc.get_referrers # looking for back_refs, not refs
+    predicate = lambda x: isinstance(x, objtype) # looking for child type
+   #if objtype is None: predicate = lambda x: True #XXX: in obj.mro() ?
+    ignore = (ignore,) if not hasattr(ignore, '__len__') else ignore
+    ignore = (id(obj) for obj in ignore)
+    chain = find_chain(obj, predicate, edge_func, depth, ignore)
+    #XXX: should pop off obj... ?
+    return chain
+
+
+# more generic helper function (cut-n-paste from objgraph)
+# Source at http://mg.pov.lt/objgraph/
+# Copyright (c) 2008-2010 Marius Gedminas <marius@pov.lt>
+# Copyright (c) 2010 Stefano Rivera <stefano@rivera.za.net>
+# Released under the MIT licence (see objgraph/objgrah.py)
+
+def find_chain(obj, predicate, edge_func, max_depth=20, extra_ignore=()):
+    queue = [obj]
+    depth = {id(obj): 0}
+    parent = {id(obj): None}
+    ignore = set(extra_ignore)
+    ignore.add(id(extra_ignore))
+    ignore.add(id(queue))
+    ignore.add(id(depth))
+    ignore.add(id(parent))
+    ignore.add(id(ignore))
+    ignore.add(id(sys._getframe()))  # this function
+    ignore.add(id(sys._getframe(1))) # find_chain/find_backref_chain, likely
+    gc.collect()
+    while queue:
+        target = queue.pop(0)
+        if predicate(target):
+            chain = [target]
+            while parent[id(target)] is not None:
+                target = parent[id(target)]
+                chain.append(target)
+            return chain
+        tdepth = depth[id(target)]
+        if tdepth < max_depth:
+            referrers = edge_func(target)
+            ignore.add(id(referrers))
+            for source in referrers:
+                if id(source) in ignore:
+                    continue
+                if id(source) not in depth:
+                    depth[id(source)] = tdepth + 1
+                    parent[id(source)] = target
+                    queue.append(source)
+    return [obj] # not found
+
+
+# backward compatability
+refobject = at
+
+
+# EOF
diff --git a/myenv/lib/python3.9/site-packages/dill/settings.py b/myenv/lib/python3.9/site-packages/dill/settings.py
new file mode 100644
index 0000000..4d0226b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/settings.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+global settings for Pickler
+"""
+
+try:
+    from pickle import DEFAULT_PROTOCOL
+except ImportError:
+    from pickle import HIGHEST_PROTOCOL as DEFAULT_PROTOCOL
+
+settings = {
+   #'main' : None,
+    'protocol' : DEFAULT_PROTOCOL,
+    'byref' : False,
+   #'strictio' : False,
+    'fmode' : 0, #HANDLE_FMODE
+    'recurse' : False,
+    'ignore' : False,
+}
+
+del DEFAULT_PROTOCOL
+
diff --git a/myenv/lib/python3.9/site-packages/dill/source.py b/myenv/lib/python3.9/site-packages/dill/source.py
new file mode 100644
index 0000000..47064a1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/source.py
@@ -0,0 +1,1023 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+#
+# inspired by inspect.py from Python-2.7.6
+# inspect.py author: 'Ka-Ping Yee <ping@lfw.org>'
+# inspect.py merged into original dill.source by Mike McKerns 4/13/14
+"""
+Extensions to python's 'inspect' module, which can be used
+to retrieve information from live python objects. The methods
+defined in this module are augmented to facilitate access to 
+source code of interactively defined functions and classes,
+as well as provide access to source code for objects defined
+in a file.
+"""
+
+__all__ = ['findsource', 'getsourcelines', 'getsource', 'indent', 'outdent', \
+           '_wrap', 'dumpsource', 'getname', '_namespace', 'getimport', \
+           '_importable', 'importable','isdynamic', 'isfrommain']
+
+import linecache
+import re
+from inspect import (getblock, getfile, getmodule, getsourcefile, indentsize,
+                     isbuiltin, isclass, iscode, isframe, isfunction, ismethod,
+                     ismodule, istraceback)
+from tokenize import TokenError
+
+from ._dill import PY3
+
+
+def isfrommain(obj):
+    "check if object was built in __main__"
+    module = getmodule(obj)
+    if module and module.__name__ == '__main__':
+        return True
+    return False
+
+
+def isdynamic(obj):
+    "check if object was built in the interpreter"
+    try: file = getfile(obj)
+    except TypeError: file = None 
+    if file == '<stdin>' and isfrommain(obj):
+        return True
+    return False
+
+
+def _matchlambda(func, line):
+    """check if lambda object 'func' matches raw line of code 'line'"""
+    from .detect import code as getcode
+    from .detect import freevars, globalvars, varnames
+    dummy = lambda : '__this_is_a_big_dummy_function__'
+    # process the line (removing leading whitespace, etc)
+    lhs,rhs = line.split('lambda ',1)[-1].split(":", 1) #FIXME: if !1 inputs
+    try: #FIXME: unsafe
+        _ = eval("lambda %s : %s" % (lhs,rhs), globals(),locals())
+    except: _ = dummy
+    # get code objects, for comparison
+    _, code = getcode(_).co_code, getcode(func).co_code
+    # check if func is in closure
+    _f = [line.count(i) for i in freevars(func).keys()]
+    if not _f: # not in closure
+        # check if code matches
+        if _ == code: return True
+        return False
+    # weak check on freevars
+    if not all(_f): return False  #XXX: VERY WEAK
+    # weak check on varnames and globalvars
+    _f = varnames(func)
+    _f = [line.count(i) for i in _f[0]+_f[1]]
+    if _f and not all(_f): return False  #XXX: VERY WEAK
+    _f = [line.count(i) for i in globalvars(func).keys()]
+    if _f and not all(_f): return False  #XXX: VERY WEAK
+    # check if func is a double lambda
+    if (line.count('lambda ') > 1) and (lhs in freevars(func).keys()):
+        _lhs,_rhs = rhs.split('lambda ',1)[-1].split(":",1) #FIXME: if !1 inputs
+        try: #FIXME: unsafe
+            _f = eval("lambda %s : %s" % (_lhs,_rhs), globals(),locals())
+        except: _f = dummy
+        # get code objects, for comparison
+        _, code = getcode(_f).co_code, getcode(func).co_code
+        if len(_) != len(code): return False
+        #NOTE: should be same code same order, but except for 't' and '\x88'
+        _ = set((i,j) for (i,j) in zip(_,code) if i != j)
+        if len(_) != 1: return False #('t','\x88')
+        return True
+    # check indentsize
+    if not indentsize(line): return False #FIXME: is this a good check???
+    # check if code 'pattern' matches
+    #XXX: or pattern match against dis.dis(code)? (or use uncompyle2?)
+    _ = _.split(_[0])  # 't' #XXX: remove matching values if starts the same?
+    _f = code.split(code[0])  # '\x88'
+    #NOTE: should be same code different order, with different first element
+    _ = dict(re.match(r'([\W\D\S])(.*)', _[i]).groups() for i in range(1,len(_)))
+    _f = dict(re.match(r'([\W\D\S])(.*)', _f[i]).groups() for i in range(1,len(_f)))
+    if (_.keys() == _f.keys()) and (sorted(_.values()) == sorted(_f.values())):
+        return True
+    return False
+
+
+def findsource(object):
+    """Return the entire source file and starting line number for an object.
+    For interactively-defined objects, the 'file' is the interpreter's history.
+
+    The argument may be a module, class, method, function, traceback, frame,
+    or code object.  The source code is returned as a list of all the lines
+    in the file and the line number indexes a line in that list.  An IOError
+    is raised if the source code cannot be retrieved, while a TypeError is
+    raised for objects where the source code is unavailable (e.g. builtins)."""
+
+    module = getmodule(object)
+    try: file = getfile(module)
+    except TypeError: file = None 
+    # use readline when working in interpreter (i.e. __main__ and not file)
+    if module and module.__name__ == '__main__' and not file:
+        try: 
+            import readline
+            err = ''
+        except:
+            import sys
+            err = sys.exc_info()[1].args[0]
+            if sys.platform[:3] == 'win':
+                err += ", please install 'pyreadline'"
+        if err:
+            raise IOError(err)
+        lbuf = readline.get_current_history_length()
+        lines = [readline.get_history_item(i)+'\n' for i in range(1,lbuf)]
+    else:
+        try: # special handling for class instances
+            if not isclass(object) and isclass(type(object)): # __class__
+                file = getfile(module)        
+                sourcefile = getsourcefile(module)
+            else: # builtins fail with a TypeError
+                file = getfile(object)
+                sourcefile = getsourcefile(object)
+        except (TypeError, AttributeError): # fail with better error
+            file = getfile(object)
+            sourcefile = getsourcefile(object)
+        if not sourcefile and file[:1] + file[-1:] != '<>':
+            raise IOError('source code not available')
+        file = sourcefile if sourcefile else file
+
+        module = getmodule(object, file)
+        if module:
+            lines = linecache.getlines(file, module.__dict__)
+        else:
+            lines = linecache.getlines(file)
+
+    if not lines:
+        raise IOError('could not extract source code')
+
+    #FIXME: all below may fail if exec used (i.e. exec('f = lambda x:x') )
+    if ismodule(object):
+        return lines, 0
+
+    #NOTE: beneficial if search goes from end to start of buffer history
+    name = pat1 = obj = ''
+    pat2 = r'^(\s*@)'
+#   pat1b = r'^(\s*%s\W*=)' % name #FIXME: finds 'f = decorate(f)', not exec
+    if ismethod(object):
+        name = object.__name__
+        if name == '<lambda>': pat1 = r'(.*(?<!\w)lambda(:|\s))'
+        else: pat1 = r'^(\s*def\s)'
+        if PY3: object = object.__func__
+        else: object = object.im_func
+    if isfunction(object):
+        name = object.__name__
+        if name == '<lambda>':
+            pat1 = r'(.*(?<!\w)lambda(:|\s))'
+            obj = object #XXX: better a copy?
+        else: pat1 = r'^(\s*def\s)'
+        if PY3: object = object.__code__
+        else: object = object.func_code
+    if istraceback(object):
+        object = object.tb_frame
+    if isframe(object):
+        object = object.f_code
+    if iscode(object):
+        if not hasattr(object, 'co_firstlineno'):
+            raise IOError('could not find function definition')
+        stdin = object.co_filename == '<stdin>'
+        if stdin:
+            lnum = len(lines) - 1 # can't get lnum easily, so leverage pat
+            if not pat1: pat1 = r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)'
+        else:
+            lnum = object.co_firstlineno - 1
+            pat1 = r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)'
+        pat1 = re.compile(pat1); pat2 = re.compile(pat2)
+       #XXX: candidate_lnum = [n for n in range(lnum) if pat1.match(lines[n])]
+        while lnum > 0: #XXX: won't find decorators in <stdin> ?
+            line = lines[lnum]
+            if pat1.match(line):
+                if not stdin: break # co_firstlineno does the job
+                if name == '<lambda>': # hackery needed to confirm a match
+                    if _matchlambda(obj, line): break
+                else: # not a lambda, just look for the name
+                    if name in line: # need to check for decorator...
+                        hats = 0
+                        for _lnum in range(lnum-1,-1,-1):
+                            if pat2.match(lines[_lnum]): hats += 1
+                            else: break
+                        lnum = lnum - hats
+                        break
+            lnum = lnum - 1
+        return lines, lnum
+
+    try: # turn instances into classes
+        if not isclass(object) and isclass(type(object)): # __class__
+            object = object.__class__ #XXX: sometimes type(class) is better?
+            #XXX: we don't find how the instance was built
+    except AttributeError: pass
+    if isclass(object):
+        name = object.__name__
+        pat = re.compile(r'^(\s*)class\s*' + name + r'\b')
+        # make some effort to find the best matching class definition:
+        # use the one with the least indentation, which is the one
+        # that's most probably not inside a function definition.
+        candidates = []
+        for i in range(len(lines)-1,-1,-1):
+            match = pat.match(lines[i])
+            if match:
+                # if it's at toplevel, it's already the best one
+                if lines[i][0] == 'c':
+                    return lines, i
+                # else add whitespace to candidate list
+                candidates.append((match.group(1), i))
+        if candidates:
+            # this will sort by whitespace, and by line number,
+            # less whitespace first  #XXX: should sort high lnum before low
+            candidates.sort()
+            return lines, candidates[0][1]
+        else:
+            raise IOError('could not find class definition')
+    raise IOError('could not find code object')
+
+
+def getblocks(object, lstrip=False, enclosing=False, locate=False):
+    """Return a list of source lines and starting line number for an object.
+    Interactively-defined objects refer to lines in the interpreter's history.
+
+    If enclosing=True, then also return any enclosing code.
+    If lstrip=True, ensure there is no indentation in the first line of code.
+    If locate=True, then also return the line number for the block of code.
+
+    DEPRECATED: use 'getsourcelines' instead
+    """
+    lines, lnum = findsource(object)
+
+    if ismodule(object):
+        if lstrip: lines = _outdent(lines)
+        return ([lines], [0]) if locate is True else [lines]
+
+    #XXX: 'enclosing' means: closures only? or classes and files?
+    indent = indentsize(lines[lnum])
+    block = getblock(lines[lnum:]) #XXX: catch any TokenError here?
+
+    if not enclosing or not indent:
+        if lstrip: block = _outdent(block)
+        return ([block], [lnum]) if locate is True else [block]
+
+    pat1 = r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))'; pat1 = re.compile(pat1)
+    pat2 = r'^(\s*@)'; pat2 = re.compile(pat2)
+   #pat3 = r'^(\s*class\s)'; pat3 = re.compile(pat3) #XXX: enclosing class?
+    #FIXME: bound methods need enclosing class (and then instantiation)
+    #       *or* somehow apply a partial using the instance
+
+    skip = 0
+    line = 0
+    blocks = []; _lnum = []
+    target = ''.join(block)
+    while line <= lnum: #XXX: repeat lnum? or until line < lnum?
+        # see if starts with ('def','lambda') and contains our target block
+        if pat1.match(lines[line]):
+            if not skip:
+                try: code = getblock(lines[line:])
+                except TokenError: code = [lines[line]]
+            if indentsize(lines[line]) > indent: #XXX: should be >= ?
+                line += len(code) - skip
+            elif target in ''.join(code):
+                blocks.append(code) # save code block as the potential winner
+                _lnum.append(line - skip) # save the line number for the match
+                line += len(code) - skip
+            else:
+                line += 1
+            skip = 0
+        # find skip: the number of consecutive decorators
+        elif pat2.match(lines[line]):
+            try: code = getblock(lines[line:])
+            except TokenError: code = [lines[line]]
+            skip = 1
+            for _line in code[1:]: # skip lines that are decorators
+                if not pat2.match(_line): break
+                skip += 1
+            line += skip
+        # no match: reset skip and go to the next line
+        else:
+            line +=1
+            skip = 0
+
+    if not blocks:
+        blocks = [block]
+        _lnum = [lnum]
+    if lstrip: blocks = [_outdent(block) for block in blocks]
+    # return last match
+    return (blocks, _lnum) if locate is True else blocks
+
+
+def getsourcelines(object, lstrip=False, enclosing=False):
+    """Return a list of source lines and starting line number for an object.
+    Interactively-defined objects refer to lines in the interpreter's history.
+
+    The argument may be a module, class, method, function, traceback, frame,
+    or code object.  The source code is returned as a list of the lines
+    corresponding to the object and the line number indicates where in the
+    original source file the first line of code was found.  An IOError is
+    raised if the source code cannot be retrieved, while a TypeError is
+    raised for objects where the source code is unavailable (e.g. builtins).
+
+    If lstrip=True, ensure there is no indentation in the first line of code.
+    If enclosing=True, then also return any enclosing code."""
+    code, n = getblocks(object, lstrip=lstrip, enclosing=enclosing, locate=True)
+    return code[-1], n[-1]
+
+
+#NOTE: broke backward compatibility 4/16/14 (was lstrip=True, force=True)
+def getsource(object, alias='', lstrip=False, enclosing=False, \
+                                              force=False, builtin=False):
+    """Return the text of the source code for an object. The source code for
+    interactively-defined objects are extracted from the interpreter's history.
+
+    The argument may be a module, class, method, function, traceback, frame,
+    or code object.  The source code is returned as a single string.  An
+    IOError is raised if the source code cannot be retrieved, while a
+    TypeError is raised for objects where the source code is unavailable
+    (e.g. builtins).
+
+    If alias is provided, then add a line of code that renames the object.
+    If lstrip=True, ensure there is no indentation in the first line of code.
+    If enclosing=True, then also return any enclosing code.
+    If force=True, catch (TypeError,IOError) and try to use import hooks.
+    If builtin=True, force an import for any builtins
+    """
+    # hascode denotes a callable
+    hascode = _hascode(object)
+    # is a class instance type (and not in builtins)
+    instance = _isinstance(object)
+
+    # get source lines; if fail, try to 'force' an import
+    try: # fails for builtins, and other assorted object types
+        lines, lnum = getsourcelines(object, enclosing=enclosing)
+    except (TypeError, IOError): # failed to get source, resort to import hooks
+        if not force: # don't try to get types that findsource can't get
+            raise
+        if not getmodule(object): # get things like 'None' and '1'
+            if not instance: return getimport(object, alias, builtin=builtin)
+            # special handling (numpy arrays, ...)
+            _import = getimport(object, builtin=builtin)
+            name = getname(object, force=True)
+            _alias = "%s = " % alias if alias else ""
+            if alias == name: _alias = ""
+            return _import+_alias+"%s\n" % name
+        else: #FIXME: could use a good bit of cleanup, since using getimport...
+            if not instance: return getimport(object, alias, builtin=builtin)
+            # now we are dealing with an instance...
+            name = object.__class__.__name__
+            module = object.__module__
+            if module in ['builtins','__builtin__']:
+                return getimport(object, alias, builtin=builtin)
+            else: #FIXME: leverage getimport? use 'from module import name'?
+                lines, lnum = ["%s = __import__('%s', fromlist=['%s']).%s\n" % (name,module,name,name)], 0
+                obj = eval(lines[0].lstrip(name + ' = '))
+                lines, lnum = getsourcelines(obj, enclosing=enclosing)
+
+    # strip leading indent (helps ensure can be imported)
+    if lstrip or alias:
+        lines = _outdent(lines)
+
+    # instantiate, if there's a nice repr  #XXX: BAD IDEA???
+    if instance: #and force: #XXX: move into findsource or getsourcelines ?
+        if '(' in repr(object): lines.append('%r\n' % object)
+       #else: #XXX: better to somehow to leverage __reduce__ ?
+       #    reconstructor,args = object.__reduce__()
+       #    _ = reconstructor(*args)
+        else: # fall back to serialization #XXX: bad idea?
+            #XXX: better not duplicate work? #XXX: better new/enclose=True?
+            lines = dumpsource(object, alias='', new=force, enclose=False)
+            lines, lnum = [line+'\n' for line in lines.split('\n')][:-1], 0
+       #else: object.__code__ # raise AttributeError
+
+    # add an alias to the source code
+    if alias:
+        if hascode:
+            skip = 0
+            for line in lines: # skip lines that are decorators
+                if not line.startswith('@'): break
+                skip += 1
+            #XXX: use regex from findsource / getsourcelines ?
+            if lines[skip].lstrip().startswith('def '): # we have a function
+                if alias != object.__name__:
+                    lines.append('\n%s = %s\n' % (alias, object.__name__))
+            elif 'lambda ' in lines[skip]: # we have a lambda
+                if alias != lines[skip].split('=')[0].strip():
+                    lines[skip] = '%s = %s' % (alias, lines[skip])
+            else: # ...try to use the object's name
+                if alias != object.__name__:
+                    lines.append('\n%s = %s\n' % (alias, object.__name__))
+        else: # class or class instance
+            if instance:
+                if alias != lines[-1].split('=')[0].strip():
+                    lines[-1] = ('%s = ' % alias) + lines[-1]
+            else:
+                name = getname(object, force=True) or object.__name__
+                if alias != name:
+                    lines.append('\n%s = %s\n' % (alias, name))
+    return ''.join(lines)
+
+
+def _hascode(object):
+    '''True if object has an attribute that stores it's __code__'''
+    return getattr(object,'__code__',None) or getattr(object,'func_code',None)
+
+def _isinstance(object):
+    '''True if object is a class instance type (and is not a builtin)'''
+    if _hascode(object) or isclass(object) or ismodule(object):
+        return False
+    if istraceback(object) or isframe(object) or iscode(object):
+        return False
+    # special handling (numpy arrays, ...)
+    if not getmodule(object) and getmodule(type(object)).__name__ in ['numpy']:
+        return True
+#   # check if is instance of a builtin
+#   if not getmodule(object) and getmodule(type(object)).__name__ in ['__builtin__','builtins']:
+#       return False
+    _types = ('<class ',"<type 'instance'>")
+    if not repr(type(object)).startswith(_types): #FIXME: weak hack
+        return False
+    if not getmodule(object) or object.__module__ in ['builtins','__builtin__'] or getname(object, force=True) in ['array']:
+        return False
+    return True # by process of elimination... it's what we want
+
+
+def _intypes(object):
+    '''check if object is in the 'types' module'''
+    import types
+    # allow user to pass in object or object.__name__
+    if type(object) is not type(''):
+        object = getname(object, force=True)
+    if object == 'ellipsis': object = 'EllipsisType'
+    return True if hasattr(types, object) else False
+
+
+def _isstring(object): #XXX: isstringlike better?
+    '''check if object is a string-like type'''
+    if PY3: return isinstance(object, (str, bytes))
+    return isinstance(object, basestring)
+
+
+def indent(code, spaces=4):
+    '''indent a block of code with whitespace (default is 4 spaces)'''
+    indent = indentsize(code) 
+    if type(spaces) is int: spaces = ' '*spaces
+    # if '\t' is provided, will indent with a tab
+    nspaces = indentsize(spaces)
+    # blank lines (etc) need to be ignored
+    lines = code.split('\n')
+##  stq = "'''"; dtq = '"""'
+##  in_stq = in_dtq = False
+    for i in range(len(lines)):
+        #FIXME: works... but shouldn't indent 2nd+ lines of multiline doc
+        _indent = indentsize(lines[i])
+        if indent > _indent: continue
+        lines[i] = spaces+lines[i]
+##      #FIXME: may fail when stq and dtq in same line (depends on ordering)
+##      nstq, ndtq = lines[i].count(stq), lines[i].count(dtq)
+##      if not in_dtq and not in_stq:
+##          lines[i] = spaces+lines[i] # we indent
+##          # entering a comment block
+##          if nstq%2: in_stq = not in_stq
+##          if ndtq%2: in_dtq = not in_dtq
+##      # leaving a comment block
+##      elif in_dtq and ndtq%2: in_dtq = not in_dtq
+##      elif in_stq and nstq%2: in_stq = not in_stq
+##      else: pass
+    if lines[-1].strip() == '': lines[-1] = ''
+    return '\n'.join(lines)
+
+
+def _outdent(lines, spaces=None, all=True):
+    '''outdent lines of code, accounting for docs and line continuations'''
+    indent = indentsize(lines[0]) 
+    if spaces is None or spaces > indent or spaces < 0: spaces = indent
+    for i in range(len(lines) if all else 1):
+        #FIXME: works... but shouldn't outdent 2nd+ lines of multiline doc
+        _indent = indentsize(lines[i])
+        if spaces > _indent: _spaces = _indent
+        else: _spaces = spaces
+        lines[i] = lines[i][_spaces:]
+    return lines
+
+def outdent(code, spaces=None, all=True):
+    '''outdent a block of code (default is to strip all leading whitespace)'''
+    indent = indentsize(code) 
+    if spaces is None or spaces > indent or spaces < 0: spaces = indent
+    #XXX: will this delete '\n' in some cases?
+    if not all: return code[spaces:]
+    return '\n'.join(_outdent(code.split('\n'), spaces=spaces, all=all))
+
+
+#XXX: not sure what the point of _wrap is...
+#exec_ = lambda s, *a: eval(compile(s, '<string>', 'exec'), *a)
+__globals__ = globals()
+__locals__ = locals()
+wrap2 = '''
+def _wrap(f):
+    """ encapsulate a function and it's __import__ """
+    def func(*args, **kwds):
+        try:
+            # _ = eval(getsource(f, force=True)) #XXX: safer but less robust
+            exec getimportable(f, alias='_') in %s, %s
+        except:
+            raise ImportError('cannot import name ' + f.__name__)
+        return _(*args, **kwds)
+    func.__name__ = f.__name__
+    func.__doc__ = f.__doc__
+    return func
+''' % ('__globals__', '__locals__')
+wrap3 = '''
+def _wrap(f):
+    """ encapsulate a function and it's __import__ """
+    def func(*args, **kwds):
+        try:
+            # _ = eval(getsource(f, force=True)) #XXX: safer but less robust
+            exec(getimportable(f, alias='_'), %s, %s)
+        except:
+            raise ImportError('cannot import name ' + f.__name__)
+        return _(*args, **kwds)
+    func.__name__ = f.__name__
+    func.__doc__ = f.__doc__
+    return func
+''' % ('__globals__', '__locals__')
+if PY3:
+    exec(wrap3)
+else:
+    exec(wrap2)
+del wrap2, wrap3
+
+
+def _enclose(object, alias=''): #FIXME: needs alias to hold returned object
+    """create a function enclosure around the source of some object"""
+    #XXX: dummy and stub should append a random string
+    dummy = '__this_is_a_big_dummy_enclosing_function__'
+    stub = '__this_is_a_stub_variable__'
+    code = 'def %s():\n' % dummy
+    code += indent(getsource(object, alias=stub, lstrip=True, force=True))
+    code += indent('return %s\n' % stub)
+    if alias: code += '%s = ' % alias
+    code += '%s(); del %s\n' % (dummy, dummy)
+   #code += "globals().pop('%s',lambda :None)()\n" % dummy
+    return code
+
+
+def dumpsource(object, alias='', new=False, enclose=True):
+    """'dump to source', where the code includes a pickled object.
+
+    If new=True and object is a class instance, then create a new
+    instance using the unpacked class source code. If enclose, then
+    create the object inside a function enclosure (thus minimizing
+    any global namespace pollution).
+    """
+    from dill import dumps
+    pik = repr(dumps(object))
+    code = 'import dill\n'
+    if enclose:
+        stub = '__this_is_a_stub_variable__' #XXX: *must* be same _enclose.stub
+        pre = '%s = ' % stub
+        new = False #FIXME: new=True doesn't work with enclose=True
+    else:
+        stub = alias
+        pre = '%s = ' % stub if alias else alias
+    
+    # if a 'new' instance is not needed, then just dump and load
+    if not new or not _isinstance(object):
+        code += pre + 'dill.loads(%s)\n' % pik
+    else: #XXX: other cases where source code is needed???
+        code += getsource(object.__class__, alias='', lstrip=True, force=True)
+        mod = repr(object.__module__) # should have a module (no builtins here)
+        if PY3:
+            code += pre + 'dill.loads(%s.replace(b%s,bytes(__name__,"UTF-8")))\n' % (pik,mod)
+        else:
+            code += pre + 'dill.loads(%s.replace(%s,__name__))\n' % (pik,mod)
+       #code += 'del %s' % object.__class__.__name__ #NOTE: kills any existing!
+
+    if enclose:
+        # generation of the 'enclosure'
+        dummy = '__this_is_a_big_dummy_object__'
+        dummy = _enclose(dummy, alias=alias)
+        # hack to replace the 'dummy' with the 'real' code
+        dummy = dummy.split('\n')
+        code = dummy[0]+'\n' + indent(code) + '\n'.join(dummy[-3:])
+
+    return code #XXX: better 'dumpsourcelines', returning list of lines?
+
+
+def getname(obj, force=False, fqn=False): #XXX: throw(?) to raise error on fail?
+    """get the name of the object. for lambdas, get the name of the pointer """
+    if fqn: return '.'.join(_namespace(obj))
+    module = getmodule(obj)
+    if not module: # things like "None" and "1"
+        if not force: return None
+        return repr(obj)
+    try:
+        #XXX: 'wrong' for decorators and curried functions ?
+        #       if obj.func_closure: ...use logic from getimportable, etc ?
+        name = obj.__name__
+        if name == '<lambda>':
+            return getsource(obj).split('=',1)[0].strip()
+        # handle some special cases
+        if module.__name__ in ['builtins','__builtin__']:
+            if name == 'ellipsis': name = 'EllipsisType'
+        return name
+    except AttributeError: #XXX: better to just throw AttributeError ?
+        if not force: return None
+        name = repr(obj)
+        if name.startswith('<'): # or name.split('('):
+            return None
+        return name
+
+
+def _namespace(obj):
+    """_namespace(obj); return namespace hierarchy (as a list of names)
+    for the given object.  For an instance, find the class hierarchy.
+
+    For example:
+
+    >>> from functools import partial
+    >>> p = partial(int, base=2)
+    >>> _namespace(p)
+    [\'functools\', \'partial\']
+    """
+    # mostly for functions and modules and such
+    #FIXME: 'wrong' for decorators and curried functions
+    try: #XXX: needs some work and testing on different types
+        module = qual = str(getmodule(obj)).split()[1].strip('>').strip('"').strip("'")
+        qual = qual.split('.')
+        if ismodule(obj):
+            return qual
+        # get name of a lambda, function, etc
+        name = getname(obj) or obj.__name__ # failing, raise AttributeError
+        # check special cases (NoneType, ...)
+        if module in ['builtins','__builtin__']: # BuiltinFunctionType
+            if _intypes(name): return ['types'] + [name]
+        return qual + [name] #XXX: can be wrong for some aliased objects
+    except: pass
+    # special case: numpy.inf and numpy.nan (we don't want them as floats)
+    if str(obj) in ['inf','nan','Inf','NaN']: # is more, but are they needed?
+        return ['numpy'] + [str(obj)]
+    # mostly for classes and class instances and such
+    module = getattr(obj.__class__, '__module__', None)
+    qual = str(obj.__class__)
+    try: qual = qual[qual.index("'")+1:-2]
+    except ValueError: pass # str(obj.__class__) made the 'try' unnecessary
+    qual = qual.split(".")
+    if module in ['builtins','__builtin__']:
+        # check special cases (NoneType, Ellipsis, ...)
+        if qual[-1] == 'ellipsis': qual[-1] = 'EllipsisType'
+        if _intypes(qual[-1]): module = 'types' #XXX: BuiltinFunctionType
+        qual = [module] + qual
+    return qual
+
+
+#NOTE: 05/25/14 broke backward compatability: added 'alias' as 3rd argument
+def _getimport(head, tail, alias='', verify=True, builtin=False):
+    """helper to build a likely import string from head and tail of namespace.
+    ('head','tail') are used in the following context: "from head import tail"
+
+    If verify=True, then test the import string before returning it.
+    If builtin=True, then force an import for builtins where possible.
+    If alias is provided, then rename the object on import.
+    """
+    # special handling for a few common types
+    if tail in ['Ellipsis', 'NotImplemented'] and head in ['types']:
+        head = len.__module__
+    elif tail in ['None'] and head in ['types']:
+        _alias = '%s = ' % alias if alias else ''
+        if alias == tail: _alias = ''
+        return _alias+'%s\n' % tail
+    # we don't need to import from builtins, so return ''
+#   elif tail in ['NoneType','int','float','long','complex']: return '' #XXX: ?
+    if head in ['builtins','__builtin__']:
+        # special cases (NoneType, Ellipsis, ...) #XXX: BuiltinFunctionType
+        if tail == 'ellipsis': tail = 'EllipsisType'
+        if _intypes(tail): head = 'types'
+        elif not builtin:
+            _alias = '%s = ' % alias if alias else ''
+            if alias == tail: _alias = ''
+            return _alias+'%s\n' % tail
+        else: pass # handle builtins below
+    # get likely import string
+    if not head: _str = "import %s" % tail
+    else: _str = "from %s import %s" % (head, tail)
+    _alias = " as %s\n" % alias if alias else "\n"
+    if alias == tail: _alias = "\n"
+    _str += _alias
+    # FIXME: fails on most decorators, currying, and such...
+    #        (could look for magic __wrapped__ or __func__ attr)
+    #        (could fix in 'namespace' to check obj for closure)
+    if verify and not head.startswith('dill.'):# weird behavior for dill
+       #print(_str)
+        try: exec(_str) #XXX: check if == obj? (name collision)
+        except ImportError: #XXX: better top-down or bottom-up recursion?
+            _head = head.rsplit(".",1)[0] #(or get all, then compare == obj?)
+            if not _head: raise
+            if _head != head:
+                _str = _getimport(_head, tail, alias, verify)
+    return _str
+
+
+#XXX: rename builtin to force? vice versa? verify to force? (as in getsource)
+#NOTE: 05/25/14 broke backward compatability: added 'alias' as 2nd argument
+def getimport(obj, alias='', verify=True, builtin=False, enclosing=False):
+    """get the likely import string for the given object
+
+    obj is the object to inspect
+    If verify=True, then test the import string before returning it.
+    If builtin=True, then force an import for builtins where possible.
+    If enclosing=True, get the import for the outermost enclosing callable.
+    If alias is provided, then rename the object on import.
+    """
+    if enclosing:
+        from .detect import outermost
+        _obj = outermost(obj)
+        obj = _obj if _obj else obj
+    # get the namespace
+    qual = _namespace(obj)
+    head = '.'.join(qual[:-1])
+    tail = qual[-1]
+    # for named things... with a nice repr #XXX: move into _namespace?
+    try: # look for '<...>' and be mindful it might be in lists, dicts, etc...
+        name = repr(obj).split('<',1)[1].split('>',1)[1]
+        name = None # we have a 'object'-style repr
+    except: # it's probably something 'importable'
+        if head in ['builtins','__builtin__']:
+            name = repr(obj) #XXX: catch [1,2], (1,2), set([1,2])... others?
+        else:
+            name = repr(obj).split('(')[0]
+   #if not repr(obj).startswith('<'): name = repr(obj).split('(')[0]
+   #else: name = None
+    if name: # try using name instead of tail
+        try: return _getimport(head, name, alias, verify, builtin)
+        except ImportError: pass
+        except SyntaxError:
+            if head in ['builtins','__builtin__']:
+                _alias = '%s = ' % alias if alias else ''
+                if alias == name: _alias = ''
+                return _alias+'%s\n' % name
+            else: pass
+    try:
+       #if type(obj) is type(abs): _builtin = builtin # BuiltinFunctionType
+       #else: _builtin = False
+        return _getimport(head, tail, alias, verify, builtin)
+    except ImportError:
+        raise # could do some checking against obj
+    except SyntaxError:
+        if head in ['builtins','__builtin__']:
+            _alias = '%s = ' % alias if alias else ''
+            if alias == tail: _alias = ''
+            return _alias+'%s\n' % tail
+        raise # could do some checking against obj
+
+
+def _importable(obj, alias='', source=None, enclosing=False, force=True, \
+                                              builtin=True, lstrip=True):
+    """get an import string (or the source code) for the given object
+
+    This function will attempt to discover the name of the object, or the repr
+    of the object, or the source code for the object. To attempt to force
+    discovery of the source code, use source=True, to attempt to force the
+    use of an import, use source=False; otherwise an import will be sought
+    for objects not defined in __main__. The intent is to build a string
+    that can be imported from a python file. obj is the object to inspect.
+    If alias is provided, then rename the object with the given alias.
+
+    If source=True, use these options:
+      If enclosing=True, then also return any enclosing code.
+      If force=True, catch (TypeError,IOError) and try to use import hooks.
+      If lstrip=True, ensure there is no indentation in the first line of code.
+
+    If source=False, use these options:
+      If enclosing=True, get the import for the outermost enclosing callable.
+      If force=True, then don't test the import string before returning it.
+      If builtin=True, then force an import for builtins where possible.
+    """
+    if source is None:
+        source = True if isfrommain(obj) else False
+    if source: # first try to get the source
+        try:
+            return getsource(obj, alias, enclosing=enclosing, \
+                             force=force, lstrip=lstrip, builtin=builtin)
+        except: pass
+    try:
+        if not _isinstance(obj):
+            return getimport(obj, alias, enclosing=enclosing, \
+                                  verify=(not force), builtin=builtin)
+        # first 'get the import', then 'get the instance'
+        _import = getimport(obj, enclosing=enclosing, \
+                                 verify=(not force), builtin=builtin)
+        name = getname(obj, force=True)
+        if not name:
+            raise AttributeError("object has no atribute '__name__'")
+        _alias = "%s = " % alias if alias else ""
+        if alias == name: _alias = ""
+        return _import+_alias+"%s\n" % name
+
+    except: pass
+    if not source: # try getsource, only if it hasn't been tried yet
+        try:
+            return getsource(obj, alias, enclosing=enclosing, \
+                             force=force, lstrip=lstrip, builtin=builtin)
+        except: pass
+    # get the name (of functions, lambdas, and classes)
+    # or hope that obj can be built from the __repr__
+    #XXX: what to do about class instances and such?
+    obj = getname(obj, force=force)
+    # we either have __repr__ or __name__ (or None)
+    if not obj or obj.startswith('<'):
+        raise AttributeError("object has no atribute '__name__'")
+    _alias = '%s = ' % alias if alias else ''
+    if alias == obj: _alias = ''
+    return _alias+'%s\n' % obj
+    #XXX: possible failsafe... (for example, for instances when source=False)
+    #     "import dill; result = dill.loads(<pickled_object>); # repr(<object>)"
+
+def _closuredimport(func, alias='', builtin=False):
+    """get import for closured objects; return a dict of 'name' and 'import'"""
+    import re
+    from .detect import freevars, outermost
+    free_vars = freevars(func)
+    func_vars = {}
+    # split into 'funcs' and 'non-funcs'
+    for name,obj in list(free_vars.items()):
+        if not isfunction(obj): continue
+        # get import for 'funcs'
+        fobj = free_vars.pop(name)
+        src = getsource(fobj)
+        if src.lstrip().startswith('@'): # we have a decorator
+            src = getimport(fobj, alias=alias, builtin=builtin)
+        else: # we have to "hack" a bit... and maybe be lucky
+            encl = outermost(func)
+            # pattern: 'func = enclosing(fobj'
+            pat = r'.*[\w\s]=\s*'+getname(encl)+r'\('+getname(fobj)
+            mod = getname(getmodule(encl))
+            #HACK: get file containing 'outer' function; is func there?
+            lines,_ = findsource(encl)
+            candidate = [line for line in lines if getname(encl) in line and \
+                         re.match(pat, line)]
+            if not candidate:
+                mod = getname(getmodule(fobj))
+                #HACK: get file containing 'inner' function; is func there? 
+                lines,_ = findsource(fobj)
+                candidate = [line for line in lines \
+                             if getname(fobj) in line and re.match(pat, line)]
+            if not len(candidate): raise TypeError('import could not be found')
+            candidate = candidate[-1]
+            name = candidate.split('=',1)[0].split()[-1].strip()
+            src = _getimport(mod, name, alias=alias, builtin=builtin)
+        func_vars[name] = src
+    if not func_vars:
+        name = outermost(func)
+        mod = getname(getmodule(name))
+        if not mod or name is func: # then it can be handled by getimport
+            name = getname(func, force=True) #XXX: better key?
+            src = getimport(func, alias=alias, builtin=builtin)
+        else:
+            lines,_ = findsource(name)
+            # pattern: 'func = enclosing('
+            candidate = [line for line in lines if getname(name) in line and \
+                         re.match(r'.*[\w\s]=\s*'+getname(name)+r'\(', line)]
+            if not len(candidate): raise TypeError('import could not be found')
+            candidate = candidate[-1]
+            name = candidate.split('=',1)[0].split()[-1].strip()
+            src = _getimport(mod, name, alias=alias, builtin=builtin)
+        func_vars[name] = src
+    return func_vars
+
+#XXX: should be able to use __qualname__
+def _closuredsource(func, alias=''):
+    """get source code for closured objects; return a dict of 'name'
+    and 'code blocks'"""
+    #FIXME: this entire function is a messy messy HACK
+    #      - pollutes global namespace
+    #      - fails if name of freevars are reused
+    #      - can unnecessarily duplicate function code
+    from .detect import freevars
+    free_vars = freevars(func)
+    func_vars = {}
+    # split into 'funcs' and 'non-funcs'
+    for name,obj in list(free_vars.items()):
+        if not isfunction(obj):
+            # get source for 'non-funcs'
+            free_vars[name] = getsource(obj, force=True, alias=name)
+            continue
+        # get source for 'funcs'
+        fobj = free_vars.pop(name)
+        src = getsource(fobj, alias) # DO NOT include dependencies
+        # if source doesn't start with '@', use name as the alias
+        if not src.lstrip().startswith('@'): #FIXME: 'enclose' in dummy;
+            src = importable(fobj,alias=name)#        wrong ref 'name'
+            org = getsource(func, alias, enclosing=False, lstrip=True)
+            src = (src, org) # undecorated first, then target
+        else: #NOTE: reproduces the code!
+            org = getsource(func, enclosing=True, lstrip=False)
+            src = importable(fobj, alias, source=True) # include dependencies
+            src = (org, src) # target first, then decorated
+        func_vars[name] = src
+    src = ''.join(free_vars.values())
+    if not func_vars: #FIXME: 'enclose' in dummy; wrong ref 'name'
+        org = getsource(func, alias, force=True, enclosing=False, lstrip=True)
+        src = (src, org) # variables first, then target
+    else:
+        src = (src, None) # just variables        (better '' instead of None?)
+    func_vars[None] = src
+    # FIXME: remove duplicates (however, order is important...)
+    return func_vars
+
+def importable(obj, alias='', source=None, builtin=True):
+    """get an importable string (i.e. source code or the import string)
+    for the given object, including any required objects from the enclosing
+    and global scope
+
+    This function will attempt to discover the name of the object, or the repr
+    of the object, or the source code for the object. To attempt to force
+    discovery of the source code, use source=True, to attempt to force the
+    use of an import, use source=False; otherwise an import will be sought
+    for objects not defined in __main__. The intent is to build a string
+    that can be imported from a python file.
+
+    obj is the object to inspect. If alias is provided, then rename the
+    object with the given alias. If builtin=True, then force an import for
+    builtins where possible.
+    """
+    #NOTE: we always 'force', and 'lstrip' as necessary
+    #NOTE: for 'enclosing', use importable(outermost(obj))
+    if source is None:
+        source = True if isfrommain(obj) else False
+    elif builtin and isbuiltin(obj):
+        source = False
+    tried_source = tried_import = False
+    while True:
+        if not source: # we want an import
+            try:
+                if _isinstance(obj): # for instances, punt to _importable
+                    return _importable(obj, alias, source=False, builtin=builtin)
+                src = _closuredimport(obj, alias=alias, builtin=builtin)
+                if len(src) == 0:
+                    raise NotImplementedError('not implemented')
+                if len(src) > 1:
+                    raise NotImplementedError('not implemented')
+                return list(src.values())[0]
+            except:
+                if tried_source: raise
+                tried_import = True
+        # we want the source
+        try:
+            src = _closuredsource(obj, alias=alias)
+            if len(src) == 0:
+                raise NotImplementedError('not implemented')
+            # groan... an inline code stitcher
+            def _code_stitcher(block):
+                "stitch together the strings in tuple 'block'"
+                if block[0] and block[-1]: block = '\n'.join(block)
+                elif block[0]: block = block[0]
+                elif block[-1]: block = block[-1]
+                else: block = ''
+                return block
+            # get free_vars first
+            _src = _code_stitcher(src.pop(None))
+            _src = [_src] if _src else []
+            # get func_vars
+            for xxx in src.values():
+                xxx = _code_stitcher(xxx)
+                if xxx: _src.append(xxx)
+            # make a single source string
+            if not len(_src):
+                src = ''
+            elif len(_src) == 1:
+                src = _src[0]
+            else:
+                src = '\n'.join(_src)
+            # get source code of objects referred to by obj in global scope
+            from .detect import globalvars
+            obj = globalvars(obj) #XXX: don't worry about alias? recurse? etc?
+            obj = list(getsource(_obj,name,force=True) for (name,_obj) in obj.items() if not isbuiltin(_obj))
+            obj = '\n'.join(obj) if obj else ''
+            # combine all referred-to source (global then enclosing)
+            if not obj: return src
+            if not src: return obj
+            return obj + src
+        except:
+            if tried_import: raise
+            tried_source = True
+            source = not source
+    # should never get here
+    return
+
+
+# backward compatability
+def getimportable(obj, alias='', byname=True, explicit=False):
+    return importable(obj,alias,source=(not byname),builtin=explicit)
+   #return outdent(_importable(obj,alias,source=(not byname),builtin=explicit))
+def likely_import(obj, passive=False, explicit=False):
+    return getimport(obj, verify=(not passive), builtin=explicit)
+def _likely_import(first, last, passive=False, explicit=True):
+    return _getimport(first, last, verify=(not passive), builtin=explicit)
+_get_name = getname
+getblocks_from_history = getblocks
+
+
+
+# EOF
diff --git a/myenv/lib/python3.9/site-packages/dill/temp.py b/myenv/lib/python3.9/site-packages/dill/temp.py
new file mode 100644
index 0000000..251a8e3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/temp.py
@@ -0,0 +1,263 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+Methods for serialized objects (or source code) stored in temporary files
+and file-like objects.
+"""
+#XXX: better instead to have functions write to any given file-like object ?
+#XXX: currently, all file-like objects are created by the function...
+
+__all__ = ['dump_source', 'dump', 'dumpIO_source', 'dumpIO',\
+           'load_source', 'load', 'loadIO_source', 'loadIO',\
+           'capture']
+
+import contextlib
+from ._dill import PY3
+
+
+@contextlib.contextmanager
+def capture(stream='stdout'):
+    """builds a context that temporarily replaces the given stream name
+
+    >>> with capture('stdout') as out:
+    ...   print ("foo!")
+    ... 
+    >>> print (out.getvalue())
+    foo!
+
+    """
+    import sys
+    if PY3:
+        from io import StringIO
+    else:
+        from StringIO import StringIO
+    orig = getattr(sys, stream)
+    setattr(sys, stream, StringIO())
+    try:
+        yield getattr(sys, stream)
+    finally:
+        setattr(sys, stream, orig)
+
+
+def b(x): # deal with b'foo' versus 'foo'
+    import codecs
+    return codecs.latin_1_encode(x)[0]
+
+def load_source(file, **kwds):
+    """load an object that was stored with dill.temp.dump_source
+
+    file: filehandle
+    alias: string name of stored object
+    mode: mode to open the file, one of: {'r', 'rb'}
+
+    >>> f = lambda x: x**2
+    >>> pyfile = dill.temp.dump_source(f, alias='_f')
+    >>> _f = dill.temp.load_source(pyfile)
+    >>> _f(4)
+    16
+    """
+    alias = kwds.pop('alias', None)
+    mode = kwds.pop('mode', 'r')
+    fname = getattr(file, 'name', file) # fname=file.name or fname=file (if str)
+    source = open(fname, mode=mode, **kwds).read()
+    if not alias:
+        tag = source.strip().splitlines()[-1].split()
+        if tag[0] != '#NAME:':
+            stub = source.splitlines()[0]
+            raise IOError("unknown name for code: %s" % stub)
+        alias = tag[-1]
+    local = {}
+    exec(source, local)
+    _ = eval("%s" % alias, local)
+    return _
+
+def dump_source(object, **kwds):
+    """write object source to a NamedTemporaryFile (instead of dill.dump)
+Loads with "import" or "dill.temp.load_source".  Returns the filehandle.
+
+    >>> f = lambda x: x**2
+    >>> pyfile = dill.temp.dump_source(f, alias='_f')
+    >>> _f = dill.temp.load_source(pyfile)
+    >>> _f(4)
+    16
+
+    >>> f = lambda x: x**2
+    >>> pyfile = dill.temp.dump_source(f, dir='.')
+    >>> modulename = os.path.basename(pyfile.name).split('.py')[0]
+    >>> exec('from %s import f as _f' % modulename)
+    >>> _f(4)
+    16
+
+Optional kwds:
+    If 'alias' is specified, the object will be renamed to the given string.
+
+    If 'prefix' is specified, the file name will begin with that prefix,
+    otherwise a default prefix is used.
+    
+    If 'dir' is specified, the file will be created in that directory,
+    otherwise a default directory is used.
+    
+    If 'text' is specified and true, the file is opened in text
+    mode.  Else (the default) the file is opened in binary mode.  On
+    some operating systems, this makes no difference.
+
+NOTE: Keep the return value for as long as you want your file to exist !
+    """ #XXX: write a "load_source"?
+    from .source import importable, getname
+    import tempfile
+    kwds.pop('suffix', '') # this is *always* '.py'
+    alias = kwds.pop('alias', '') #XXX: include an alias so a name is known
+    name = str(alias) or getname(object)
+    name = "\n#NAME: %s\n" % name
+    #XXX: assumes kwds['dir'] is writable and on $PYTHONPATH
+    file = tempfile.NamedTemporaryFile(suffix='.py', **kwds)
+    file.write(b(''.join([importable(object, alias=alias),name])))
+    file.flush()
+    return file
+
+def load(file, **kwds):
+    """load an object that was stored with dill.temp.dump
+
+    file: filehandle
+    mode: mode to open the file, one of: {'r', 'rb'}
+
+    >>> dumpfile = dill.temp.dump([1, 2, 3, 4, 5])
+    >>> dill.temp.load(dumpfile)
+    [1, 2, 3, 4, 5]
+    """
+    import dill as pickle
+    mode = kwds.pop('mode', 'rb')
+    name = getattr(file, 'name', file) # name=file.name or name=file (if str)
+    return pickle.load(open(name, mode=mode, **kwds))
+
+def dump(object, **kwds):
+    """dill.dump of object to a NamedTemporaryFile.
+Loads with "dill.temp.load".  Returns the filehandle.
+
+    >>> dumpfile = dill.temp.dump([1, 2, 3, 4, 5])
+    >>> dill.temp.load(dumpfile)
+    [1, 2, 3, 4, 5]
+
+Optional kwds:
+    If 'suffix' is specified, the file name will end with that suffix,
+    otherwise there will be no suffix.
+    
+    If 'prefix' is specified, the file name will begin with that prefix,
+    otherwise a default prefix is used.
+    
+    If 'dir' is specified, the file will be created in that directory,
+    otherwise a default directory is used.
+    
+    If 'text' is specified and true, the file is opened in text
+    mode.  Else (the default) the file is opened in binary mode.  On
+    some operating systems, this makes no difference.
+
+NOTE: Keep the return value for as long as you want your file to exist !
+    """
+    import dill as pickle
+    import tempfile
+    file = tempfile.NamedTemporaryFile(**kwds)
+    pickle.dump(object, file)
+    file.flush()
+    return file
+
+def loadIO(buffer, **kwds):
+    """load an object that was stored with dill.temp.dumpIO
+
+    buffer: buffer object
+
+    >>> dumpfile = dill.temp.dumpIO([1, 2, 3, 4, 5])
+    >>> dill.temp.loadIO(dumpfile)
+    [1, 2, 3, 4, 5]
+    """
+    import dill as pickle
+    if PY3:
+        from io import BytesIO as StringIO
+    else:
+        from StringIO import StringIO
+    value = getattr(buffer, 'getvalue', buffer) # value or buffer.getvalue
+    if value != buffer: value = value() # buffer.getvalue()
+    return pickle.load(StringIO(value))
+
+def dumpIO(object, **kwds):
+    """dill.dump of object to a buffer.
+Loads with "dill.temp.loadIO".  Returns the buffer object.
+
+    >>> dumpfile = dill.temp.dumpIO([1, 2, 3, 4, 5])
+    >>> dill.temp.loadIO(dumpfile)
+    [1, 2, 3, 4, 5]
+    """
+    import dill as pickle
+    if PY3:
+        from io import BytesIO as StringIO
+    else:
+        from StringIO import StringIO
+    file = StringIO()
+    pickle.dump(object, file)
+    file.flush()
+    return file
+
+def loadIO_source(buffer, **kwds):
+    """load an object that was stored with dill.temp.dumpIO_source
+
+    buffer: buffer object
+    alias: string name of stored object
+
+    >>> f = lambda x:x**2
+    >>> pyfile = dill.temp.dumpIO_source(f, alias='_f')
+    >>> _f = dill.temp.loadIO_source(pyfile)
+    >>> _f(4)
+    16
+    """
+    alias = kwds.pop('alias', None)
+    source = getattr(buffer, 'getvalue', buffer) # source or buffer.getvalue
+    if source != buffer: source = source() # buffer.getvalue()
+    if PY3: source = source.decode() # buffer to string
+    if not alias:
+        tag = source.strip().splitlines()[-1].split()
+        if tag[0] != '#NAME:':
+            stub = source.splitlines()[0]
+            raise IOError("unknown name for code: %s" % stub)
+        alias = tag[-1]
+    local = {}
+    exec(source, local)
+    _ = eval("%s" % alias, local)
+    return _
+
+def dumpIO_source(object, **kwds):
+    """write object source to a buffer (instead of dill.dump)
+Loads by with dill.temp.loadIO_source.  Returns the buffer object.
+
+    >>> f = lambda x:x**2
+    >>> pyfile = dill.temp.dumpIO_source(f, alias='_f')
+    >>> _f = dill.temp.loadIO_source(pyfile)
+    >>> _f(4)
+    16
+
+Optional kwds:
+    If 'alias' is specified, the object will be renamed to the given string.
+    """
+    from .source import importable, getname
+    if PY3:
+        from io import BytesIO as StringIO
+    else:
+        from StringIO import StringIO
+    alias = kwds.pop('alias', '') #XXX: include an alias so a name is known
+    name = str(alias) or getname(object)
+    name = "\n#NAME: %s\n" % name
+    #XXX: assumes kwds['dir'] is writable and on $PYTHONPATH
+    file = StringIO()
+    file.write(b(''.join([importable(object, alias=alias),name])))
+    file.flush()
+    return file
+
+
+del contextlib
+
+
+# EOF
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/__init__.py b/myenv/lib/python3.9/site-packages/dill/tests/__init__.py
new file mode 100644
index 0000000..cfd05c6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/__init__.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2018-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+to run this test suite, first build and install `dill`.
+
+  $ python setup.py build
+  $ python setup.py install
+
+
+then run the tests with:
+
+  $ python -m dill.tests
+
+
+or, if `nose` is installed:
+
+  $ nosetests  
+
+"""
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/__main__.py b/myenv/lib/python3.9/site-packages/dill/tests/__main__.py
new file mode 100644
index 0000000..e82993c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/__main__.py
@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2018-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+from __future__ import print_function
+import glob
+import os
+try:
+    import pox
+    python = pox.which_python(version=True, fullpath=False) or 'python'
+except ImportError:
+    python = 'python'
+import subprocess as sp
+from sys import platform
+shell = platform[:3] == 'win'
+
+suite = os.path.dirname(__file__) or os.path.curdir
+tests = glob.glob(suite + os.path.sep + 'test_*.py')
+
+
+if __name__ == '__main__':
+
+    for test in tests:
+        p = sp.Popen([python, test], shell=shell).wait()
+        if not p:
+            print('.', end='')
+    print('')
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_check.py b/myenv/lib/python3.9/site-packages/dill/tests/test_check.py
new file mode 100644
index 0000000..134b8b0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_check.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+from dill import check
+import sys
+
+from dill.temp import capture
+from dill._dill import PY3
+
+
+#FIXME: this doesn't catch output... it's from the internal call
+def raise_check(func, **kwds):
+    try:
+        with capture('stdout') as out:
+            check(func, **kwds)
+    except Exception:
+        e = sys.exc_info()[1]
+        raise AssertionError(str(e))
+    else:
+        assert 'Traceback' not in out.getvalue()
+    finally:
+        out.close()
+
+
+f = lambda x:x**2
+
+
+def test_simple():
+    raise_check(f)
+
+
+def test_recurse():
+    raise_check(f, recurse=True)
+
+
+def test_byref():
+    raise_check(f, byref=True)
+
+
+def test_protocol():
+    raise_check(f, protocol=True)
+
+
+def test_python():
+    raise_check(f, python=None)
+
+
+#TODO: test incompatible versions
+#TODO: test dump failure
+#TODO: test load failure
+
+
+if __name__ == '__main__':
+    test_simple()
+    test_recurse()
+    test_byref()
+    test_protocol()
+    test_python()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_classdef.py b/myenv/lib/python3.9/site-packages/dill/tests/test_classdef.py
new file mode 100644
index 0000000..e23bef0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_classdef.py
@@ -0,0 +1,265 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+import sys
+dill.settings['recurse'] = True
+
+# test classdefs
+class _class:
+    def _method(self):
+        pass
+    def ok(self):
+        return True
+
+class _class2:
+    def __call__(self):
+        pass
+    def ok(self):
+        return True
+
+class _newclass(object):
+    def _method(self):
+        pass
+    def ok(self):
+        return True
+
+class _newclass2(object):
+    def __call__(self):
+        pass
+    def ok(self):
+        return True
+
+class _meta(type):
+    pass
+
+def __call__(self):
+    pass
+def ok(self):
+    return True
+
+_mclass = _meta("_mclass", (object,), {"__call__": __call__, "ok": ok})
+
+del __call__
+del ok
+
+o = _class()
+oc = _class2()
+n = _newclass()
+nc = _newclass2()
+m = _mclass()
+
+# test pickles for class instances
+def test_class_instances():
+    assert dill.pickles(o)
+    assert dill.pickles(oc)
+    assert dill.pickles(n)
+    assert dill.pickles(nc)
+    assert dill.pickles(m)
+
+def test_class_objects():
+    clslist = [_class,_class2,_newclass,_newclass2,_mclass]
+    objlist = [o,oc,n,nc,m]
+    _clslist = [dill.dumps(obj) for obj in clslist]
+    _objlist = [dill.dumps(obj) for obj in objlist]
+
+    for obj in clslist:
+        globals().pop(obj.__name__)
+    del clslist
+    for obj in ['o','oc','n','nc']:
+        globals().pop(obj)
+    del objlist
+    del obj
+
+    for obj,cls in zip(_objlist,_clslist):
+        _cls = dill.loads(cls)
+        _obj = dill.loads(obj)
+        assert _obj.ok()
+        assert _cls.ok(_cls())
+        if _cls.__name__ == "_mclass":
+            assert type(_cls).__name__ == "_meta"
+
+# test NoneType
+def test_specialtypes():
+    assert dill.pickles(type(None))
+    assert dill.pickles(type(NotImplemented))
+    assert dill.pickles(type(Ellipsis))
+
+if hex(sys.hexversion) >= '0x20600f0':
+    from collections import namedtuple
+    Z = namedtuple("Z", ['a','b'])
+    Zi = Z(0,1)
+    X = namedtuple("Y", ['a','b'])
+    X.__name__ = "X"
+    if hex(sys.hexversion) >= '0x30300f0':
+        X.__qualname__ = "X" #XXX: name must 'match' or fails to pickle
+    Xi = X(0,1)
+    Bad = namedtuple("FakeName", ['a','b'])
+    Badi = Bad(0,1)
+else:
+    Z = Zi = X = Xi = Bad = Badi = None
+
+# test namedtuple
+def test_namedtuple():
+    assert Z is dill.loads(dill.dumps(Z))
+    assert Zi == dill.loads(dill.dumps(Zi))
+    assert X is dill.loads(dill.dumps(X))
+    assert Xi == dill.loads(dill.dumps(Xi))
+    assert Bad is not dill.loads(dill.dumps(Bad))
+    assert Bad._fields == dill.loads(dill.dumps(Bad))._fields
+    assert tuple(Badi) == tuple(dill.loads(dill.dumps(Badi)))
+
+    class A:
+        class B(namedtuple("B", ["one", "two"])):
+            '''docstring'''
+        B.__module__ = 'testing'
+
+    a = A()
+    assert dill.copy(a)
+
+    assert dill.copy(A.B).__name__ == 'B'
+    if dill._dill.PY3:
+        assert dill.copy(A.B).__qualname__.endswith('.<locals>.A.B')
+    assert dill.copy(A.B).__doc__ == 'docstring'
+    assert dill.copy(A.B).__module__ == 'testing'
+
+def test_dtype():
+    try:
+        import numpy as np
+
+        dti = np.dtype('int')
+        assert np.dtype == dill.loads(dill.dumps(np.dtype))
+        assert dti == dill.loads(dill.dumps(dti))
+    except ImportError: pass
+
+
+def test_array_nested():
+    try:
+        import numpy as np
+
+        x = np.array([1])
+        y = (x,)
+        dill.dumps(x)
+        assert y == dill.loads(dill.dumps(y))
+
+    except ImportError: pass
+
+
+def test_array_subclass():
+    try:
+        import numpy as np
+
+        class TestArray(np.ndarray):
+            def __new__(cls, input_array, color):
+                obj = np.asarray(input_array).view(cls)
+                obj.color = color
+                return obj
+            def __array_finalize__(self, obj):
+                if obj is None:
+                    return
+                if isinstance(obj, type(self)):
+                    self.color = obj.color
+            def __getnewargs__(self):
+                return np.asarray(self), self.color
+
+        a1 = TestArray(np.zeros(100), color='green')
+        if dill._dill.PY3 and not dill._dill.IS_PYPY:
+            assert dill.pickles(a1)
+            assert a1.__dict__ == dill.copy(a1).__dict__
+
+        a2 = a1[0:9]
+        if dill._dill.PY3 and not dill._dill.IS_PYPY:
+            assert dill.pickles(a2)
+            assert a2.__dict__ == dill.copy(a2).__dict__
+
+        class TestArray2(np.ndarray):
+            color = 'blue'
+
+        a3 = TestArray2([1,2,3,4,5])
+        a3.color = 'green'
+        if dill._dill.PY3 and not dill._dill.IS_PYPY:
+            assert dill.pickles(a3)
+            assert a3.__dict__ == dill.copy(a3).__dict__
+
+    except ImportError: pass
+
+
+def test_method_decorator():
+    class A(object):
+      @classmethod
+      def test(cls):
+        pass
+
+    a = A()
+
+    res = dill.dumps(a)
+    new_obj = dill.loads(res)
+    new_obj.__class__.test()
+
+# test slots
+class Y(object):
+  __slots__ = ['y']
+  def __init__(self, y):
+    self.y = y
+
+value = 123
+y = Y(value)
+
+def test_slots():
+    assert dill.pickles(Y)
+    assert dill.pickles(y)
+    assert dill.pickles(Y.y)
+    assert dill.copy(y).y == value
+
+def test_metaclass():
+    if dill._dill.PY3:
+        class metaclass_with_new(type):
+            def __new__(mcls, name, bases, ns, **kwds):
+                cls = super().__new__(mcls, name, bases, ns, **kwds)
+                assert mcls is not None
+                assert cls.method(mcls)
+                return cls
+            def method(cls, mcls):
+                return isinstance(cls, mcls)
+
+        l = locals()
+        exec("""class subclass_with_new(metaclass=metaclass_with_new):
+            def __new__(cls):
+                self = super().__new__(cls)
+                return self""", None, l)
+        subclass_with_new = l['subclass_with_new']
+    else:
+        class metaclass_with_new(type):
+            def __new__(mcls, name, bases, ns, **kwds):
+                cls = super(mcls, metaclass_with_new).__new__(mcls, name, bases, ns, **kwds)
+                assert mcls is not None
+                assert cls.method(mcls)
+                return cls
+            def method(cls, mcls):
+                return isinstance(cls, mcls)
+
+        class subclass_with_new:
+            __metaclass__ = metaclass_with_new
+            def __new__(cls):
+                self = super(subclass_with_new, cls).__new__(cls)
+                return self
+
+    assert dill.copy(subclass_with_new())
+
+
+if __name__ == '__main__':
+    test_class_instances()
+    test_class_objects()
+    test_specialtypes()
+    test_namedtuple()
+    test_dtype()
+    test_array_nested()
+    test_array_subclass()
+    test_method_decorator()
+    test_slots()
+    test_metaclass()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_detect.py b/myenv/lib/python3.9/site-packages/dill/tests/test_detect.py
new file mode 100644
index 0000000..06339ac
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_detect.py
@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+from dill.detect import baditems, badobjects, badtypes, errors, parent, at, globalvars
+from dill import settings
+from dill._dill import IS_PYPY, IS_PYPY2
+from pickle import PicklingError
+
+import inspect
+import sys
+import os
+
+def test_bad_things():
+    f = inspect.currentframe()
+    assert baditems(f) == [f]
+    #assert baditems(globals()) == [f] #XXX
+    assert badobjects(f) is f
+    assert badtypes(f) == type(f)
+    assert type(errors(f)) is PicklingError if IS_PYPY2 else TypeError
+    d = badtypes(f, 1)
+    assert isinstance(d, dict)
+    assert list(badobjects(f, 1).keys()) == list(d.keys())
+    assert list(errors(f, 1).keys()) == list(d.keys())
+    s = set([(err.__class__.__name__,err.args[0]) for err in list(errors(f, 1).values())])
+    a = dict(s)
+    if not os.environ.get('COVERAGE'): #XXX: travis-ci
+        assert len(s) is len(a) # TypeError (and possibly PicklingError)
+    n = 1 if IS_PYPY2 else 2
+    assert len(a) is n if 'PicklingError' in a.keys() else n-1
+
+def test_parent():
+    x = [4,5,6,7]
+    listiter = iter(x)
+    obj = parent(listiter, list)
+    assert obj is x
+
+    if IS_PYPY: assert parent(obj, int) is None
+    else: assert parent(obj, int) is x[-1] # python oddly? finds last int
+    assert at(id(at)) is at
+
+a, b, c = 1, 2, 3
+
+def squared(x):
+  return a+x**2
+
+def foo(x):
+  def bar(y):
+    return squared(x)+y
+  return bar
+
+class _class:
+    def _method(self):
+        pass
+    def ok(self):
+        return True
+
+def test_globals():
+    def f():
+        a
+        def g():
+            b
+            def h():
+                c
+    assert globalvars(f) == dict(a=1, b=2, c=3)
+
+    res = globalvars(foo, recurse=True)
+    assert set(res) == set(['squared', 'a'])
+    res = globalvars(foo, recurse=False)
+    assert res == {}
+    zap = foo(2)
+    res = globalvars(zap, recurse=True)
+    assert set(res) == set(['squared', 'a'])
+    res = globalvars(zap, recurse=False)
+    assert set(res) == set(['squared'])
+    del zap
+    res = globalvars(squared)
+    assert set(res) == set(['a'])
+    # FIXME: should find referenced __builtins__
+    #res = globalvars(_class, recurse=True)
+    #assert set(res) == set(['True'])
+    #res = globalvars(_class, recurse=False)
+    #assert res == {}
+    #res = globalvars(_class.ok, recurse=True)
+    #assert set(res) == set(['True'])
+    #res = globalvars(_class.ok, recurse=False)
+    #assert set(res) == set(['True'])
+
+
+#98 dill ignores __getstate__ in interactive lambdas
+bar = [0]
+
+class Foo(object):
+    def __init__(self):
+        pass
+    def __getstate__(self):
+        bar[0] = bar[0]+1
+        return {}
+    def __setstate__(self, data):
+        pass
+
+f = Foo()
+
+def test_getstate():
+    from dill import dumps, loads
+    dumps(f)
+    b = bar[0]
+    dumps(lambda: f, recurse=False) # doesn't call __getstate__
+    assert bar[0] == b
+    dumps(lambda: f, recurse=True) # calls __getstate__
+    assert bar[0] == b + 1
+
+#97 serialize lambdas in test files
+def test_deleted():
+    global sin
+    from dill import dumps, loads
+    from math import sin, pi
+
+    def sinc(x):
+        return sin(x)/x
+
+    settings['recurse'] = True
+    _sinc = dumps(sinc)
+    sin = globals().pop('sin')
+    sin = 1
+    del sin
+    sinc_ = loads(_sinc) # no NameError... pickling preserves 'sin'
+    res = sinc_(1)
+    from math import sin
+    assert sinc(1) == res
+
+
+def test_lambdify():
+    try:
+        from sympy import symbols, lambdify
+    except ImportError:
+        return
+    settings['recurse'] = True
+    x = symbols("x")
+    y = x**2
+    f = lambdify([x], y)
+    z = min
+    d = globals()
+    globalvars(f, recurse=True, builtin=True)
+    assert z is min 
+    assert d is globals() 
+
+
+if __name__ == '__main__':
+    test_bad_things()
+    test_parent()
+    test_globals()
+    test_getstate()
+    test_deleted()
+    test_lambdify()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_dictviews.py b/myenv/lib/python3.9/site-packages/dill/tests/test_dictviews.py
new file mode 100644
index 0000000..3bbc5d6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_dictviews.py
@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2021 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+from dill._dill import OLD310, MAPPING_PROXY_TRICK
+
+def test_dictviews():
+    x = {'a': 1}
+    assert dill.copy(x.keys())
+    assert dill.copy(x.values())
+    assert dill.copy(x.items())
+
+def test_dictproxy_trick():
+    if not OLD310 and MAPPING_PROXY_TRICK:
+        x = {'a': 1}
+        all_views = (x.values(), x.items(), x.keys(), x)
+        seperate_views = dill.copy(all_views)
+        new_x = seperate_views[-1]
+        new_x['b'] = 2
+        new_x['c'] = 1
+        assert len(new_x) == 3 and len(x) == 1
+        assert len(seperate_views[0]) == 3 and len(all_views[0]) == 1
+        assert len(seperate_views[1]) == 3 and len(all_views[1]) == 1
+        assert len(seperate_views[2]) == 3 and len(all_views[2]) == 1
+        assert dict(all_views[1]) == x
+        assert dict(seperate_views[1]) == new_x
+
+if __name__ == '__main__':
+    test_dictviews()
+    test_dictproxy_trick()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_diff.py b/myenv/lib/python3.9/site-packages/dill/tests/test_diff.py
new file mode 100644
index 0000000..3277682
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_diff.py
@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+from dill import __diff as diff
+
+import sys
+IS_PYPY = not hasattr(sys, 'getrefcount')
+
+class A:
+    pass
+
+def test_diff():
+    a = A()
+    b = A()
+    c = A()
+    a.a = b
+    b.a = c
+    diff.memorise(a)
+    assert not diff.has_changed(a)
+    c.a = 1
+    assert diff.has_changed(a)
+    diff.memorise(c, force=True)
+    assert not diff.has_changed(a)
+    c.a = 2
+    assert diff.has_changed(a)
+    changed = diff.whats_changed(a)
+    assert list(changed[0].keys()) == ["a"]
+    assert not changed[1]
+
+    a2 = []
+    b2 = [a2]
+    c2 = [b2]
+    diff.memorise(c2)
+    assert not diff.has_changed(c2)
+    a2.append(1)
+    assert diff.has_changed(c2)
+    changed = diff.whats_changed(c2)
+    assert changed[0] == {}
+    assert changed[1]
+
+    a3 = {}
+    b3 = {1: a3}
+    c3 = {1: b3}
+    diff.memorise(c3)
+    assert not diff.has_changed(c3)
+    a3[1] = 1
+    assert diff.has_changed(c3)
+    changed = diff.whats_changed(c3)
+    assert changed[0] == {}
+    assert changed[1]
+
+    if not IS_PYPY:
+        try:
+            import abc
+            # make sure the "_abc_invaldation_counter" doesn't make test fail
+            diff.memorise(abc.ABCMeta, force=True)
+            assert not diff.has_changed(abc)
+            abc.ABCMeta.zzz = 1
+            assert diff.has_changed(abc)
+            changed = diff.whats_changed(abc)
+            assert list(changed[0].keys()) == ["ABCMeta"]
+            assert not changed[1]
+        except ImportError:
+            pass
+
+    '''
+    import Queue
+    diff.memorise(Queue, force=True)
+    assert not diff.has_changed(Queue)
+    Queue.Queue.zzz = 1
+    assert diff.has_changed(Queue)
+    changed = diff.whats_changed(Queue)
+    assert list(changed[0].keys()) == ["Queue"]
+    assert not changed[1]
+
+    import math
+    diff.memorise(math, force=True)
+    assert not diff.has_changed(math)
+    math.zzz = 1
+    assert diff.has_changed(math)
+    changed = diff.whats_changed(math)
+    assert list(changed[0].keys()) == ["zzz"]
+    assert not changed[1]
+    '''
+
+    a = A()
+    b = A()
+    c = A()
+    a.a = b
+    b.a = c
+    diff.memorise(a)
+    assert not diff.has_changed(a)
+    c.a = 1
+    assert diff.has_changed(a)
+    diff.memorise(c, force=True)
+    assert not diff.has_changed(a)
+    del c.a
+    assert diff.has_changed(a)
+    changed = diff.whats_changed(a)
+    assert list(changed[0].keys()) == ["a"]
+    assert not changed[1]
+
+
+if __name__ == '__main__':
+    test_diff()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_extendpickle.py b/myenv/lib/python3.9/site-packages/dill/tests/test_extendpickle.py
new file mode 100644
index 0000000..49b6f15
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_extendpickle.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill as pickle
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import BytesIO as StringIO
+
+
+def my_fn(x):
+    return x * 17
+
+
+def test_extend():
+    obj = lambda : my_fn(34)
+    assert obj() == 578
+
+    obj_io = StringIO()
+    pickler = pickle.Pickler(obj_io)
+    pickler.dump(obj)
+
+    obj_str = obj_io.getvalue()
+
+    obj2_io = StringIO(obj_str)
+    unpickler = pickle.Unpickler(obj2_io)
+    obj2 = unpickler.load()
+
+    assert obj2() == 578
+
+
+def test_isdill():
+    obj_io = StringIO()
+    pickler = pickle.Pickler(obj_io)
+    assert pickle._dill.is_dill(pickler) is True
+
+    pickler = pickle._dill.StockPickler(obj_io)
+    assert pickle._dill.is_dill(pickler) is False
+
+    try:
+        import multiprocess as mp
+        pickler = mp.reduction.ForkingPickler(obj_io)
+        assert pickle._dill.is_dill(pickler, child=True) is True
+        assert pickle._dill.is_dill(pickler, child=False) is False
+    except:
+        pass
+
+
+if __name__ == '__main__':
+    test_extend()
+    test_isdill()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_fglobals.py b/myenv/lib/python3.9/site-packages/dill/tests/test_fglobals.py
new file mode 100644
index 0000000..eea3c3a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_fglobals.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2021-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+dill.settings['recurse'] = True
+
+def get_fun_with_strftime():
+    def fun_with_strftime():
+        import datetime
+        return datetime.datetime.strptime("04-01-1943", "%d-%m-%Y").strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+    return fun_with_strftime
+
+
+def get_fun_with_strftime2():
+    import datetime
+    return datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')
+
+
+def test_doc_dill_issue_219():
+    back_fn = dill.loads(dill.dumps(get_fun_with_strftime()))
+    assert back_fn() == "1943-01-04 00:00:00"
+    dupl = dill.loads(dill.dumps(get_fun_with_strftime2))
+    assert dupl() == get_fun_with_strftime2()
+
+
+def get_fun_with_internal_import():
+    def fun_with_import():
+        import re
+        return re.compile("$")
+    return fun_with_import
+
+
+def test_method_with_internal_import_should_work():
+    import re
+    back_fn = dill.loads(dill.dumps(get_fun_with_internal_import()))
+    import inspect
+    if hasattr(inspect, 'getclosurevars'):
+        vars = inspect.getclosurevars(back_fn)
+        assert vars.globals == {}
+        assert vars.nonlocals == {}
+    assert back_fn() == re.compile("$")
+    assert "__builtins__" in back_fn.__globals__
+
+
+if __name__ == "__main__":
+    import sys
+    if (sys.version_info[:3] != (3,10,0) or sys.version_info[3] != 'alpha'):
+        test_doc_dill_issue_219()
+        test_method_with_internal_import_should_work()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_file.py b/myenv/lib/python3.9/site-packages/dill/tests/test_file.py
new file mode 100644
index 0000000..8118e3a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_file.py
@@ -0,0 +1,502 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import os
+import sys
+import string
+import random
+
+import dill
+
+
+dill.settings['recurse'] = True
+
+fname = "_test_file.txt"
+rand_chars = list(string.ascii_letters) + ["\n"] * 40  # bias newline
+
+if sys.hexversion < 0x03030000:
+    FileNotFoundError = IOError
+buffer_error = ValueError("invalid buffer size")
+dne_error = FileNotFoundError("[Errno 2] No such file or directory: '%s'" % fname)
+
+
+def write_randomness(number=200):
+    f = open(fname, "w")
+    for i in range(number):
+        f.write(random.choice(rand_chars))
+    f.close()
+    f = open(fname, "r")
+    contents = f.read()
+    f.close()
+    return contents
+
+
+def trunc_file():
+    open(fname, "w").close()
+
+
+def throws(op, args, exc):
+    try:
+        op(*args)
+    except type(exc):
+        return sys.exc_info()[1].args == exc.args
+    else:
+        return False
+
+
+def teardown_module():
+    if os.path.exists(fname):
+        os.remove(fname)
+
+
+def bench(strictio, fmode, skippypy):
+    import platform
+    if skippypy and platform.python_implementation() == 'PyPy':
+        # Skip for PyPy...
+        return
+
+    # file exists, with same contents
+    # read
+
+    write_randomness()
+
+    f = open(fname, "r")
+    _f = dill.loads(dill.dumps(f, fmode=fmode))#, strictio=strictio))
+    assert _f.mode == f.mode
+    assert _f.tell() == f.tell()
+    assert _f.read() == f.read()
+    f.close()
+    _f.close()
+
+    # write
+
+    f = open(fname, "w")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    f2 = dill.loads(f_dumped) #FIXME: fails due to pypy/issues/1233
+    # TypeError: expected py_object instance instead of str
+    f2mode = f2.mode
+    f2tell = f2.tell()
+    f2name = f2.name
+    f2.write(" world!")
+    f2.close()
+
+    if fmode == dill.HANDLE_FMODE:
+        assert open(fname).read() == " world!"
+        assert f2mode == f1mode
+        assert f2tell == 0
+    elif fmode == dill.CONTENTS_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2mode == f1mode
+        assert f2tell == ftell
+        assert f2name == fname
+    elif fmode == dill.FILE_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2mode == f1mode
+        assert f2tell == ftell
+    else:
+        raise RuntimeError("Unknown file mode '%s'" % fmode)
+
+    # append
+
+    trunc_file()
+
+    f = open(fname, "a")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    f2 = dill.loads(f_dumped)
+    f2mode = f2.mode
+    f2tell = f2.tell()
+    f2.write(" world!")
+    f2.close()
+
+    assert f2mode == f1mode
+    if fmode == dill.CONTENTS_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2tell == ftell
+    elif fmode == dill.HANDLE_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2tell == ftell
+    elif fmode == dill.FILE_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2tell == ftell
+    else:
+        raise RuntimeError("Unknown file mode '%s'" % fmode)
+
+    # file exists, with different contents (smaller size)
+    # read
+
+    write_randomness()
+
+    f = open(fname, "r")
+    fstr = f.read()
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    _flen = 150
+    _fstr = write_randomness(number=_flen)
+
+    if strictio:  # throw error if ftell > EOF
+        assert throws(dill.loads, (f_dumped,), buffer_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        assert f2.mode == f1mode
+        if fmode == dill.CONTENTS_FMODE:
+            assert f2.tell() == _flen
+            assert f2.read() == ""
+            f2.seek(0)
+            assert f2.read() == _fstr
+            assert f2.tell() == _flen  # 150
+        elif fmode == dill.HANDLE_FMODE:
+            assert f2.tell() == 0
+            assert f2.read() == _fstr
+            assert f2.tell() == _flen  # 150
+        elif fmode == dill.FILE_FMODE:
+            assert f2.tell() == ftell  # 200
+            assert f2.read() == ""
+            f2.seek(0)
+            assert f2.read() == fstr
+            assert f2.tell() == ftell  # 200
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+        f2.close()
+
+    # write
+
+    write_randomness()
+
+    f = open(fname, "w")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    fstr = open(fname).read()
+
+    f = open(fname, "w")
+    f.write("h")
+    _ftell = f.tell()
+    f.close()
+
+    if strictio:  # throw error if ftell > EOF
+        assert throws(dill.loads, (f_dumped,), buffer_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        f2mode = f2.mode
+        f2tell = f2.tell()
+        f2.write(" world!")
+        f2.close()
+        if fmode == dill.CONTENTS_FMODE:
+            assert open(fname).read() == "h world!"
+            assert f2mode == f1mode
+            assert f2tell == _ftell
+        elif fmode == dill.HANDLE_FMODE:
+            assert open(fname).read() == " world!"
+            assert f2mode == f1mode
+            assert f2tell == 0
+        elif fmode == dill.FILE_FMODE:
+            assert open(fname).read() == "hello world!"
+            assert f2mode == f1mode
+            assert f2tell == ftell
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+        f2.close()
+
+    # append
+
+    trunc_file()
+
+    f = open(fname, "a")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    fstr = open(fname).read()
+
+    f = open(fname, "w")
+    f.write("h")
+    _ftell = f.tell()
+    f.close()
+
+    if strictio:  # throw error if ftell > EOF
+        assert throws(dill.loads, (f_dumped,), buffer_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        f2mode = f2.mode
+        f2tell = f2.tell()
+        f2.write(" world!")
+        f2.close()
+        assert f2mode == f1mode
+        if fmode == dill.CONTENTS_FMODE:
+            # position of writes cannot be changed on some OSs
+            assert open(fname).read() == "h world!"
+            assert f2tell == _ftell
+        elif fmode == dill.HANDLE_FMODE:
+            assert open(fname).read() == "h world!"
+            assert f2tell == _ftell
+        elif fmode == dill.FILE_FMODE:
+            assert open(fname).read() == "hello world!"
+            assert f2tell == ftell
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+        f2.close()
+
+    # file does not exist
+    # read
+
+    write_randomness()
+
+    f = open(fname, "r")
+    fstr = f.read()
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+
+    os.remove(fname)
+
+    if strictio:  # throw error if file DNE
+        assert throws(dill.loads, (f_dumped,), dne_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        assert f2.mode == f1mode
+        if fmode == dill.CONTENTS_FMODE:
+            # FIXME: this fails on systems where f2.tell() always returns 0
+            # assert f2.tell() == ftell # 200
+            assert f2.read() == ""
+            f2.seek(0)
+            assert f2.read() == ""
+            assert f2.tell() == 0
+        elif fmode == dill.FILE_FMODE:
+            assert f2.tell() == ftell  # 200
+            assert f2.read() == ""
+            f2.seek(0)
+            assert f2.read() == fstr
+            assert f2.tell() == ftell  # 200
+        elif fmode == dill.HANDLE_FMODE:
+            assert f2.tell() == 0
+            assert f2.read() == ""
+            assert f2.tell() == 0
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+        f2.close()
+
+    # write
+
+    write_randomness()
+
+    f = open(fname, "w+")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    ftell = f.tell()
+    f1mode = f.mode
+    f.close()
+
+    os.remove(fname)
+
+    if strictio:  # throw error if file DNE
+        assert throws(dill.loads, (f_dumped,), dne_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        f2mode = f2.mode
+        f2tell = f2.tell()
+        f2.write(" world!")
+        f2.close()
+        if fmode == dill.CONTENTS_FMODE:
+            assert open(fname).read() == " world!"
+            assert f2mode == 'w+'
+            assert f2tell == 0
+        elif fmode == dill.HANDLE_FMODE:
+            assert open(fname).read() == " world!"
+            assert f2mode == f1mode
+            assert f2tell == 0
+        elif fmode == dill.FILE_FMODE:
+            assert open(fname).read() == "hello world!"
+            assert f2mode == f1mode
+            assert f2tell == ftell
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+
+    # append
+
+    trunc_file()
+
+    f = open(fname, "a")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    ftell = f.tell()
+    f1mode = f.mode
+    f.close()
+
+    os.remove(fname)
+
+    if strictio:  # throw error if file DNE
+        assert throws(dill.loads, (f_dumped,), dne_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        f2mode = f2.mode
+        f2tell = f2.tell()
+        f2.write(" world!")
+        f2.close()
+        assert f2mode == f1mode
+        if fmode == dill.CONTENTS_FMODE:
+            assert open(fname).read() == " world!"
+            assert f2tell == 0
+        elif fmode == dill.HANDLE_FMODE:
+            assert open(fname).read() == " world!"
+            assert f2tell == 0
+        elif fmode == dill.FILE_FMODE:
+            assert open(fname).read() == "hello world!"
+            assert f2tell == ftell
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+
+    # file exists, with different contents (larger size)
+    # read
+
+    write_randomness()
+
+    f = open(fname, "r")
+    fstr = f.read()
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    _flen = 250
+    _fstr = write_randomness(number=_flen)
+
+    # XXX: no safe_file: no way to be 'safe'?
+
+    f2 = dill.loads(f_dumped)
+    assert f2.mode == f1mode
+    if fmode == dill.CONTENTS_FMODE:
+        assert f2.tell() == ftell  # 200
+        assert f2.read() == _fstr[ftell:]
+        f2.seek(0)
+        assert f2.read() == _fstr
+        assert f2.tell() == _flen  # 250
+    elif fmode == dill.HANDLE_FMODE:
+        assert f2.tell() == 0
+        assert f2.read() == _fstr
+        assert f2.tell() == _flen  # 250
+    elif fmode == dill.FILE_FMODE:
+        assert f2.tell() == ftell  # 200
+        assert f2.read() == ""
+        f2.seek(0)
+        assert f2.read() == fstr
+        assert f2.tell() == ftell  # 200
+    else:
+        raise RuntimeError("Unknown file mode '%s'" % fmode)
+    f2.close()  # XXX: other alternatives?
+
+    # write
+
+    f = open(fname, "w")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+
+    fstr = open(fname).read()
+
+    f.write(" and goodbye!")
+    _ftell = f.tell()
+    f.close()
+
+    # XXX: no safe_file: no way to be 'safe'?
+
+    f2 = dill.loads(f_dumped)
+    f2mode = f2.mode
+    f2tell = f2.tell()
+    f2.write(" world!")
+    f2.close()
+    if fmode == dill.CONTENTS_FMODE:
+        assert open(fname).read() == "hello world!odbye!"
+        assert f2mode == f1mode
+        assert f2tell == ftell
+    elif fmode == dill.HANDLE_FMODE:
+        assert open(fname).read() == " world!"
+        assert f2mode == f1mode
+        assert f2tell == 0
+    elif fmode == dill.FILE_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2mode == f1mode
+        assert f2tell == ftell
+    else:
+        raise RuntimeError("Unknown file mode '%s'" % fmode)
+    f2.close()
+
+    # append
+
+    trunc_file()
+
+    f = open(fname, "a")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    fstr = open(fname).read()
+
+    f.write(" and goodbye!")
+    _ftell = f.tell()
+    f.close()
+
+    # XXX: no safe_file: no way to be 'safe'?
+
+    f2 = dill.loads(f_dumped)
+    f2mode = f2.mode
+    f2tell = f2.tell()
+    f2.write(" world!")
+    f2.close()
+    assert f2mode == f1mode
+    if fmode == dill.CONTENTS_FMODE:
+        assert open(fname).read() == "hello and goodbye! world!"
+        assert f2tell == ftell
+    elif fmode == dill.HANDLE_FMODE:
+        assert open(fname).read() == "hello and goodbye! world!"
+        assert f2tell == _ftell
+    elif fmode == dill.FILE_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2tell == ftell
+    else:
+        raise RuntimeError("Unknown file mode '%s'" % fmode)
+    f2.close()
+
+
+def test_nostrictio_handlefmode():
+    bench(False, dill.HANDLE_FMODE, False)
+    teardown_module()
+
+
+def test_nostrictio_filefmode():
+    bench(False, dill.FILE_FMODE, False)
+    teardown_module()
+
+
+def test_nostrictio_contentsfmode():
+    bench(False, dill.CONTENTS_FMODE, True)
+    teardown_module()
+
+
+#bench(True, dill.HANDLE_FMODE, False)
+#bench(True, dill.FILE_FMODE, False)
+#bench(True, dill.CONTENTS_FMODE, True)
+
+
+if __name__ == '__main__':
+    test_nostrictio_handlefmode()
+    test_nostrictio_filefmode()
+    test_nostrictio_contentsfmode()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_functions.py b/myenv/lib/python3.9/site-packages/dill/tests/test_functions.py
new file mode 100644
index 0000000..ec9670e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_functions.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2019-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import functools
+import dill
+import sys
+dill.settings['recurse'] = True
+
+
+def is_py3():
+    return hex(sys.hexversion) >= '0x30000f0'
+
+
+def function_a(a):
+    return a
+
+
+def function_b(b, b1):
+    return b + b1
+
+
+def function_c(c, c1=1):
+    return c + c1
+
+
+def function_d(d, d1, d2=1):
+    """doc string"""
+    return d + d1 + d2
+
+function_d.__module__ = 'a module'
+
+
+if is_py3():
+    exec('''
+def function_e(e, *e1, e2=1, e3=2):
+    return e + sum(e1) + e2 + e3''')
+
+    globalvar = 0
+
+    @functools.lru_cache(None)
+    def function_with_cache(x):
+        global globalvar
+        globalvar += x
+        return globalvar
+
+
+def function_with_unassigned_variable():
+    if False:
+        value = None
+    return (lambda: value)
+
+
+def test_functions():
+    dumped_func_a = dill.dumps(function_a)
+    assert dill.loads(dumped_func_a)(0) == 0
+
+    dumped_func_b = dill.dumps(function_b)
+    assert dill.loads(dumped_func_b)(1,2) == 3
+
+    dumped_func_c = dill.dumps(function_c)
+    assert dill.loads(dumped_func_c)(1) == 2
+    assert dill.loads(dumped_func_c)(1, 2) == 3
+
+    dumped_func_d = dill.dumps(function_d)
+    assert dill.loads(dumped_func_d).__doc__ == function_d.__doc__
+    assert dill.loads(dumped_func_d).__module__ == function_d.__module__
+    assert dill.loads(dumped_func_d)(1, 2) == 4
+    assert dill.loads(dumped_func_d)(1, 2, 3) == 6
+    assert dill.loads(dumped_func_d)(1, 2, d2=3) == 6
+
+    if is_py3():
+        function_with_cache(1)
+        globalvar = 0
+        dumped_func_cache = dill.dumps(function_with_cache)
+        assert function_with_cache(2) == 3
+        assert function_with_cache(1) == 1
+        assert function_with_cache(3) == 6
+        assert function_with_cache(2) == 3
+
+    empty_cell = function_with_unassigned_variable()
+    cell_copy = dill.loads(dill.dumps(empty_cell))
+    assert 'empty' in str(cell_copy.__closure__[0])
+    try:
+        cell_copy()
+    except:
+        # this is good
+        pass
+    else:
+        raise AssertionError('cell_copy() did not read an empty cell')
+
+    if is_py3():
+        exec('''
+dumped_func_e = dill.dumps(function_e)
+assert dill.loads(dumped_func_e)(1, 2) == 6
+assert dill.loads(dumped_func_e)(1, 2, 3) == 9
+assert dill.loads(dumped_func_e)(1, 2, e2=3) == 8
+assert dill.loads(dumped_func_e)(1, 2, e2=3, e3=4) == 10
+assert dill.loads(dumped_func_e)(1, 2, 3, e2=4) == 12
+assert dill.loads(dumped_func_e)(1, 2, 3, e2=4, e3=5) == 15''')
+
+if __name__ == '__main__':
+    test_functions()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_functors.py b/myenv/lib/python3.9/site-packages/dill/tests/test_functors.py
new file mode 100644
index 0000000..952a546
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_functors.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import functools
+import dill
+dill.settings['recurse'] = True
+
+
+def f(a, b, c):  # without keywords
+    pass
+
+
+def g(a, b, c=2):  # with keywords
+    pass
+
+
+def h(a=1, b=2, c=3):  # without args
+    pass
+
+
+def test_functools():
+    fp = functools.partial(f, 1, 2)
+    gp = functools.partial(g, 1, c=2)
+    hp = functools.partial(h, 1, c=2)
+    bp = functools.partial(int, base=2)
+
+    assert dill.pickles(fp, safe=True)
+    assert dill.pickles(gp, safe=True)
+    assert dill.pickles(hp, safe=True)
+    assert dill.pickles(bp, safe=True)
+
+
+if __name__ == '__main__':
+    test_functools()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_mixins.py b/myenv/lib/python3.9/site-packages/dill/tests/test_mixins.py
new file mode 100644
index 0000000..a2296c2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_mixins.py
@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+dill.settings['recurse'] = True
+
+
+def wtf(x,y,z):
+  def zzz():
+    return x
+  def yyy():
+    return y
+  def xxx():
+    return z
+  return zzz,yyy
+
+
+def quad(a=1, b=1, c=0):
+  inverted = [False]
+  def invert():
+    inverted[0] = not inverted[0]
+  def dec(f):
+    def func(*args, **kwds):
+      x = f(*args, **kwds)
+      if inverted[0]: x = -x
+      return a*x**2 + b*x + c
+    func.__wrapped__ = f
+    func.invert = invert
+    func.inverted = inverted
+    return func
+  return dec
+
+
+@quad(a=0,b=2)
+def double_add(*args):
+  return sum(args)
+
+
+fx = sum([1,2,3])
+
+
+### to make it interesting...
+def quad_factory(a=1,b=1,c=0):
+  def dec(f):
+    def func(*args,**kwds):
+      fx = f(*args,**kwds)
+      return a*fx**2 + b*fx + c
+    return func
+  return dec
+
+
+@quad_factory(a=0,b=4,c=0)
+def quadish(x):
+  return x+1
+
+
+quadratic = quad_factory()
+
+
+def doubler(f):
+  def inner(*args, **kwds):
+    fx = f(*args, **kwds)
+    return 2*fx
+  return inner
+
+
+@doubler
+def quadruple(x):
+  return 2*x
+
+
+def test_mixins():
+  # test mixins
+  assert double_add(1,2,3) == 2*fx
+  double_add.invert()
+  assert double_add(1,2,3) == -2*fx
+
+  _d = dill.copy(double_add)
+  assert _d(1,2,3) == -2*fx
+ #_d.invert() #FIXME: fails seemingly randomly
+ #assert _d(1,2,3) == 2*fx
+
+  assert _d.__wrapped__(1,2,3) == fx
+
+  # XXX: issue or feature? in python3.4, inverted is linked through copy
+  if not double_add.inverted[0]:
+      double_add.invert()
+
+  # test some stuff from source and pointers
+  ds = dill.source
+  dd = dill.detect
+  assert ds.getsource(dd.freevars(quadish)['f']) == '@quad_factory(a=0,b=4,c=0)\ndef quadish(x):\n  return x+1\n'
+  assert ds.getsource(dd.freevars(quadruple)['f']) == '@doubler\ndef quadruple(x):\n  return 2*x\n'
+  assert ds.importable(quadish, source=False) == 'from %s import quadish\n' % __name__
+  assert ds.importable(quadruple, source=False) == 'from %s import quadruple\n' % __name__
+  assert ds.importable(quadratic, source=False) == 'from %s import quadratic\n' % __name__
+  assert ds.importable(double_add, source=False) == 'from %s import double_add\n' % __name__
+  assert ds.importable(quadruple, source=True) == 'def doubler(f):\n  def inner(*args, **kwds):\n    fx = f(*args, **kwds)\n    return 2*fx\n  return inner\n\n@doubler\ndef quadruple(x):\n  return 2*x\n'
+  #***** #FIXME: this needs work
+  result = ds.importable(quadish, source=True)
+  a,b,c,_,result = result.split('\n',4)
+  assert result == 'def quad_factory(a=1,b=1,c=0):\n  def dec(f):\n    def func(*args,**kwds):\n      fx = f(*args,**kwds)\n      return a*fx**2 + b*fx + c\n    return func\n  return dec\n\n@quad_factory(a=0,b=4,c=0)\ndef quadish(x):\n  return x+1\n'
+  assert set([a,b,c]) == set(['a = 0', 'c = 0', 'b = 4'])
+  result = ds.importable(quadratic, source=True)
+  a,b,c,result = result.split('\n',3)
+  assert result == '\ndef dec(f):\n  def func(*args,**kwds):\n    fx = f(*args,**kwds)\n    return a*fx**2 + b*fx + c\n  return func\n'
+  assert set([a,b,c]) == set(['a = 1', 'c = 0', 'b = 1'])
+  result = ds.importable(double_add, source=True)
+  a,b,c,d,_,result = result.split('\n',5)
+  assert result == 'def quad(a=1, b=1, c=0):\n  inverted = [False]\n  def invert():\n    inverted[0] = not inverted[0]\n  def dec(f):\n    def func(*args, **kwds):\n      x = f(*args, **kwds)\n      if inverted[0]: x = -x\n      return a*x**2 + b*x + c\n    func.__wrapped__ = f\n    func.invert = invert\n    func.inverted = inverted\n    return func\n  return dec\n\n@quad(a=0,b=2)\ndef double_add(*args):\n  return sum(args)\n'
+  assert set([a,b,c,d]) == set(['a = 0', 'c = 0', 'b = 2', 'inverted = [True]'])
+  #*****
+
+
+if __name__ == '__main__':
+    test_mixins()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_module.py b/myenv/lib/python3.9/site-packages/dill/tests/test_module.py
new file mode 100644
index 0000000..5c5e000
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_module.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import sys
+import dill
+import test_mixins as module
+try: from importlib import reload
+except ImportError: pass
+dill.settings['recurse'] = True
+
+cached = (module.__cached__ if hasattr(module, "__cached__")
+          else module.__file__.split(".", 1)[0] + ".pyc")
+
+module.a = 1234
+
+pik_mod = dill.dumps(module)
+
+module.a = 0
+
+# remove module
+del sys.modules[module.__name__]
+del module
+
+module = dill.loads(pik_mod)
+def test_attributes():
+   #assert hasattr(module, "a") and module.a == 1234  #FIXME: -m dill.tests
+    assert module.double_add(1, 2, 3) == 2 * module.fx
+
+# Restart, and test use_diff
+
+reload(module)
+
+try:
+    dill.use_diff()
+
+    module.a = 1234
+
+    pik_mod = dill.dumps(module)
+
+    module.a = 0
+
+    # remove module
+    del sys.modules[module.__name__]
+    del module
+
+    module = dill.loads(pik_mod)
+    def test_diff_attributes():
+        assert hasattr(module, "a") and module.a == 1234
+        assert module.double_add(1, 2, 3) == 2 * module.fx
+
+except AttributeError:
+    def test_diff_attributes():
+        pass
+
+# clean up
+import os
+if os.path.exists(cached):
+    os.remove(cached)
+pycache = os.path.join(os.path.dirname(module.__file__), "__pycache__")
+if os.path.exists(pycache) and not os.listdir(pycache):
+    os.removedirs(pycache)
+
+
+# test when module is None
+import math
+
+def get_lambda(str, **kwarg):
+    return eval(str, kwarg, None)
+
+obj = get_lambda('lambda x: math.exp(x)', math=math)
+
+def test_module_is_none():
+    assert obj.__module__ is None
+    assert dill.copy(obj)(3) == obj(3)
+
+
+if __name__ == '__main__':
+    test_attributes()
+    test_diff_attributes()
+    test_module_is_none()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_moduledict.py b/myenv/lib/python3.9/site-packages/dill/tests/test_moduledict.py
new file mode 100644
index 0000000..1d4d77a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_moduledict.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+dill.settings['recurse'] = True
+
+def f(func):
+  def w(*args):
+    return f(*args)
+  return w
+
+@f
+def f2(): pass
+
+# check when __main__ and on import
+def test_decorated():
+  assert dill.pickles(f2)
+
+
+import doctest
+import logging
+logging.basicConfig(level=logging.DEBUG)
+
+class SomeUnreferencedUnpicklableClass(object):
+    def __reduce__(self):
+        raise Exception
+
+unpicklable = SomeUnreferencedUnpicklableClass()
+
+# This works fine outside of Doctest:
+def test_normal():
+    serialized = dill.dumps(lambda x: x)
+
+# should not try to pickle unpicklable object in __globals__
+def tests():
+    """
+    >>> serialized = dill.dumps(lambda x: x)
+    """
+    return
+
+#print("\n\nRunning Doctest:")
+def test_doctest():
+    doctest.testmod()
+
+
+if __name__ == '__main__':
+    test_decorated()
+    test_normal()
+    test_doctest()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_nested.py b/myenv/lib/python3.9/site-packages/dill/tests/test_nested.py
new file mode 100644
index 0000000..144f54b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_nested.py
@@ -0,0 +1,135 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+test dill's ability to handle nested functions
+"""
+
+import os
+import math
+
+import dill as pickle
+pickle.settings['recurse'] = True
+
+
+# the nested function: pickle should fail here, but dill is ok.
+def adder(augend):
+    zero = [0]
+
+    def inner(addend):
+        return addend + augend + zero[0]
+    return inner
+
+
+# rewrite the nested function using a class: standard pickle should work here.
+class cadder(object):
+    def __init__(self, augend):
+        self.augend = augend
+        self.zero = [0]
+
+    def __call__(self, addend):
+        return addend + self.augend + self.zero[0]
+
+
+# rewrite again, but as an old-style class
+class c2adder:
+    def __init__(self, augend):
+        self.augend = augend
+        self.zero = [0]
+
+    def __call__(self, addend):
+        return addend + self.augend + self.zero[0]
+
+
+# some basic class stuff
+class basic(object):
+    pass
+
+
+class basic2:
+    pass
+
+
+x = 5
+y = 1
+
+
+def test_basic():
+    a = [0, 1, 2]
+    pa = pickle.dumps(a)
+    pmath = pickle.dumps(math) #XXX: FAILS in pickle
+    pmap = pickle.dumps(map)
+    # ...
+    la = pickle.loads(pa)
+    lmath = pickle.loads(pmath)
+    lmap = pickle.loads(pmap)
+    assert list(map(math.sin, a)) == list(lmap(lmath.sin, la))
+
+
+def test_basic_class():
+    pbasic2 = pickle.dumps(basic2)
+    _pbasic2 = pickle.loads(pbasic2)()
+    pbasic = pickle.dumps(basic)
+    _pbasic = pickle.loads(pbasic)()
+
+
+def test_c2adder():
+    pc2adder = pickle.dumps(c2adder)
+    pc2add5 = pickle.loads(pc2adder)(x)
+    assert pc2add5(y) == x+y
+
+
+def test_pickled_cadder():
+    pcadder = pickle.dumps(cadder)
+    pcadd5 = pickle.loads(pcadder)(x)
+    assert pcadd5(y) == x+y
+
+
+def test_raw_adder_and_inner():
+    add5 = adder(x)
+    assert add5(y) == x+y
+
+
+def test_pickled_adder():
+    padder = pickle.dumps(adder)
+    padd5 = pickle.loads(padder)(x)
+    assert padd5(y) == x+y
+
+
+def test_pickled_inner():
+    add5 = adder(x)
+    pinner = pickle.dumps(add5) #XXX: FAILS in pickle
+    p5add = pickle.loads(pinner)
+    assert p5add(y) == x+y
+
+
+def test_moduledict_where_not_main():
+    try:
+        from . import test_moduledict
+    except:
+        import test_moduledict
+    name = 'test_moduledict.py'
+    if os.path.exists(name) and os.path.exists(name+'c'):
+        os.remove(name+'c')
+
+    if os.path.exists(name) and hasattr(test_moduledict, "__cached__") \
+       and os.path.exists(test_moduledict.__cached__):
+        os.remove(getattr(test_moduledict, "__cached__"))
+
+    if os.path.exists("__pycache__") and not os.listdir("__pycache__"):
+        os.removedirs("__pycache__")
+
+
+if __name__ == '__main__':
+    test_basic()
+    test_basic_class()
+    test_c2adder()
+    test_pickled_cadder()
+    test_raw_adder_and_inner()
+    test_pickled_adder()
+    test_pickled_inner()
+    test_moduledict_where_not_main()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_objects.py b/myenv/lib/python3.9/site-packages/dill/tests/test_objects.py
new file mode 100644
index 0000000..985041b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_objects.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+demonstrate dill's ability to pickle different python types
+test pickling of all Python Standard Library objects (currently: CH 1-14 @ 2.7)
+"""
+
+import dill as pickle
+pickle.settings['recurse'] = True
+#pickle.detect.trace(True)
+#import pickle
+
+# get all objects for testing
+from dill import load_types, objects, extend
+load_types(pickleable=True,unpickleable=False)
+
+# uncomment the next two lines to test cloudpickle
+#extend(False)
+#import cloudpickle as pickle
+
+# helper objects
+class _class:
+    def _method(self):
+        pass
+
+# objects that *fail* if imported
+special = {}
+special['LambdaType'] = _lambda = lambda x: lambda y: x
+special['MethodType'] = _method = _class()._method
+special['UnboundMethodType'] = _class._method
+objects.update(special)
+
+def pickles(name, exact=False):
+    """quick check if object pickles with dill"""
+    obj = objects[name]
+    try:
+        pik = pickle.loads(pickle.dumps(obj))
+        if exact:
+            try:
+                assert pik == obj
+            except AssertionError:
+                assert type(obj) == type(pik)
+                print ("weak: %s %s" % (name, type(obj)))
+        else:
+            assert type(obj) == type(pik)
+    except Exception:
+        print ("fails: %s %s" % (name, type(obj)))
+
+
+def test_objects():
+    for member in objects.keys():
+       #pickles(member, exact=True)
+        pickles(member, exact=False)
+
+
+if __name__ == '__main__':
+    test_objects()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_properties.py b/myenv/lib/python3.9/site-packages/dill/tests/test_properties.py
new file mode 100644
index 0000000..36589d5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_properties.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import sys
+
+import dill
+dill.settings['recurse'] = True
+
+
+class Foo(object):
+    def __init__(self):
+        self._data = 1
+
+    def _get_data(self):
+        return self._data
+
+    def _set_data(self, x):
+        self._data = x
+
+    data = property(_get_data, _set_data)
+
+
+def test_data_not_none():
+    FooS = dill.copy(Foo)
+    assert FooS.data.fget is not None
+    assert FooS.data.fset is not None
+    assert FooS.data.fdel is None
+
+
+def test_data_unchanged():
+    FooS = dill.copy(Foo)
+    try:
+        res = FooS().data
+    except Exception:
+        e = sys.exc_info()[1]
+        raise AssertionError(str(e))
+    else:
+        assert res == 1
+
+
+def test_data_changed():
+    FooS = dill.copy(Foo)
+    try:
+        f = FooS()
+        f.data = 1024
+        res = f.data
+    except Exception:
+        e = sys.exc_info()[1]
+        raise AssertionError(str(e))
+    else:
+        assert res == 1024
+
+
+if __name__ == '__main__':
+    test_data_not_none()
+    test_data_unchanged()
+    test_data_changed()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_recursive.py b/myenv/lib/python3.9/site-packages/dill/tests/test_recursive.py
new file mode 100644
index 0000000..ee71a68
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_recursive.py
@@ -0,0 +1,179 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2019-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+from dill._dill import PY3
+from functools import partial
+import warnings
+
+
+def copy(obj, byref=False, recurse=False):
+    if byref:
+        try:
+            return dill.copy(obj, byref=byref, recurse=recurse)
+        except:
+            pass
+        else:
+            raise AssertionError('Copy of %s with byref=True should have given a warning!' % (obj,))
+
+        warnings.simplefilter('ignore')
+        val = dill.copy(obj, byref=byref, recurse=recurse)
+        warnings.simplefilter('error')
+        return val
+    else:
+        return dill.copy(obj, byref=byref, recurse=recurse)
+
+
+class obj1(object):
+    def __init__(self):
+        super(obj1, self).__init__()
+
+class obj2(object):
+    def __init__(self):
+        super(obj2, self).__init__()
+
+class obj3(object):
+    super_ = super
+    def __init__(self):
+        obj3.super_(obj3, self).__init__()
+
+
+def test_super():
+    assert copy(obj1(), byref=True)
+    assert copy(obj1(), byref=True, recurse=True)
+    assert copy(obj1(), recurse=True)
+    assert copy(obj1())
+
+    assert copy(obj2(), byref=True)
+    assert copy(obj2(), byref=True, recurse=True)
+    assert copy(obj2(), recurse=True)
+    assert copy(obj2())
+
+    assert copy(obj3(), byref=True)
+    assert copy(obj3(), byref=True, recurse=True)
+    assert copy(obj3(), recurse=True)
+    assert copy(obj3())
+
+
+def get_trigger(model):
+    pass
+
+class Machine(object):
+    def __init__(self):
+        self.child = Model()
+        self.trigger = partial(get_trigger, self)
+        self.child.trigger = partial(get_trigger, self.child)
+
+class Model(object):
+    pass
+
+
+
+def test_partial():
+    assert copy(Machine(), byref=True)
+    assert copy(Machine(), byref=True, recurse=True)
+    assert copy(Machine(), recurse=True)
+    assert copy(Machine())
+
+
+class Machine2(object):
+    def __init__(self):
+        self.go = partial(self.member, self)
+    def member(self, model):
+        pass
+
+
+class SubMachine(Machine2):
+    def __init__(self):
+        super(SubMachine, self).__init__()
+
+
+def test_partials():
+    assert copy(SubMachine(), byref=True)
+    assert copy(SubMachine(), byref=True, recurse=True)
+    assert copy(SubMachine(), recurse=True)
+    assert copy(SubMachine())
+
+
+class obj4(object):
+    def __init__(self):
+        super(obj4, self).__init__()
+        a = self
+        class obj5(object):
+            def __init__(self):
+                super(obj5, self).__init__()
+                self.a = a
+        self.b = obj5()
+
+
+def test_circular_reference():
+    assert copy(obj4())
+    obj4_copy = dill.loads(dill.dumps(obj4()))
+    if PY3:
+        assert type(obj4_copy) is type(obj4_copy).__init__.__closure__[0].cell_contents
+        assert type(obj4_copy.b) is type(obj4_copy.b).__init__.__closure__[0].cell_contents
+
+
+def f():
+    def g():
+       return g
+    return g
+
+
+def test_function_cells():
+    assert copy(f())
+
+
+def fib(n):
+    assert n >= 0
+    if n <= 1:
+        return n
+    else:
+        return fib(n-1) + fib(n-2)
+
+
+def test_recursive_function():
+    global fib
+    fib2 = copy(fib, recurse=True)
+    fib3 = copy(fib)
+    fib4 = fib
+    del fib
+    assert fib2(5) == 5
+    for _fib in (fib3, fib4):
+        try:
+            _fib(5)
+        except:
+            # This is expected to fail because fib no longer exists
+            pass
+        else:
+            raise AssertionError("Function fib shouldn't have been found")
+    fib = fib4
+
+
+def collection_function_recursion():
+    d = {}
+    def g():
+        return d
+    d['g'] = g
+    return g
+
+
+def test_collection_function_recursion():
+    g = copy(collection_function_recursion())
+    assert g()['g'] is g
+
+
+if __name__ == '__main__':
+    with warnings.catch_warnings():
+        warnings.simplefilter('error')
+        test_super()
+        test_partial()
+        test_partials()
+        test_circular_reference()
+        test_function_cells()
+        test_recursive_function()
+        test_collection_function_recursion()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_restricted.py b/myenv/lib/python3.9/site-packages/dill/tests/test_restricted.py
new file mode 100644
index 0000000..c9d6e48
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_restricted.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+#
+# Author: Kirill Makhonin (@kirillmakhonin)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+
+class RestrictedType:
+    def __bool__(*args, **kwargs):
+        raise Exception('Restricted function')
+
+    __eq__ = __lt__ = __le__ = __ne__ = __gt__ = __ge__ = __hash__ = __bool__
+
+glob_obj = RestrictedType()
+
+def restricted_func():
+    a = glob_obj
+
+def test_function_with_restricted_object():
+    deserialized = dill.loads(dill.dumps(restricted_func, recurse=True))
+
+
+if __name__ == '__main__':
+    test_function_with_restricted_object()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_selected.py b/myenv/lib/python3.9/site-packages/dill/tests/test_selected.py
new file mode 100644
index 0000000..bd79083
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_selected.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+testing some selected object types
+"""
+
+import dill
+dill.settings['recurse'] = True
+
+verbose = False
+
+def test_dict_contents():
+  c = type.__dict__
+  for i,j in c.items():
+   #try:
+    ok = dill.pickles(j)
+   #except:
+   #  print ("FAIL: %s with %s" % (i, dill.detect.errors(j)))
+    if verbose: print ("%s: %s, %s" % (ok, type(j), j))
+    assert ok
+  if verbose: print ("")
+
+def _g(x): yield x;
+
+def _f():
+  try: raise
+  except:
+    from sys import exc_info
+    e, er, tb = exc_info()
+    return er, tb
+
+class _d(object):
+  def _method(self):
+    pass
+
+from dill import objects
+from dill import load_types
+load_types(pickleable=True,unpickleable=False)
+_newclass = objects['ClassObjectType']
+del objects
+
+# getset_descriptor for new-style classes (fails on '_method', if not __main__)
+def test_class_descriptors():
+  d = _d.__dict__
+  for i in d.values():
+    ok = dill.pickles(i)
+    if verbose: print ("%s: %s, %s" % (ok, type(i), i))
+    assert ok
+  if verbose: print ("")
+  od = _newclass.__dict__
+  for i in od.values():
+    ok = dill.pickles(i)
+    if verbose: print ("%s: %s, %s" % (ok, type(i), i))
+    assert ok
+  if verbose: print ("")
+
+# (__main__) class instance for new-style classes
+def test_class():
+  o = _d()
+  oo = _newclass()
+  ok = dill.pickles(o)
+  if verbose: print ("%s: %s, %s" % (ok, type(o), o))
+  assert ok
+  ok = dill.pickles(oo)
+  if verbose: print ("%s: %s, %s" % (ok, type(oo), oo))
+  assert ok
+  if verbose: print ("")
+
+# frames, generators, and tracebacks (all depend on frame)
+def test_frame_related():
+  g = _g(1)
+  f = g.gi_frame
+  e,t = _f()
+  _is = lambda ok: not ok if dill._dill.IS_PYPY2 else ok
+  ok = dill.pickles(f)
+  if verbose: print ("%s: %s, %s" % (ok, type(f), f))
+  assert not ok
+  ok = dill.pickles(g)
+  if verbose: print ("%s: %s, %s" % (ok, type(g), g))
+  assert _is(not ok) #XXX: dill fails
+  ok = dill.pickles(t)
+  if verbose: print ("%s: %s, %s" % (ok, type(t), t))
+  assert not ok #XXX: dill fails
+  ok = dill.pickles(e)
+  if verbose: print ("%s: %s, %s" % (ok, type(e), e))
+  assert ok
+  if verbose: print ("")
+
+
+if __name__ == '__main__':
+  test_frame_related()
+  test_dict_contents()
+  test_class()
+  test_class_descriptors()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_session.py b/myenv/lib/python3.9/site-packages/dill/tests/test_session.py
new file mode 100644
index 0000000..fd71ea0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_session.py
@@ -0,0 +1,243 @@
+#!/usr/bin/env python
+
+# Author: Leonardo Gama (@leogama)
+# Copyright (c) 2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+from __future__ import print_function
+import atexit, dill, os, sys, __main__
+
+session_file = os.path.join(os.path.dirname(__file__), 'session-byref-%s.pkl')
+
+def test_modules(main, byref):
+    main_dict = main.__dict__
+
+    try:
+        for obj in ('json', 'url', 'local_mod', 'sax', 'dom'):
+            assert main_dict[obj].__name__ in sys.modules
+
+        for obj in ('Calendar', 'isleap'):
+            assert main_dict[obj] is sys.modules['calendar'].__dict__[obj]
+        assert main.day_name.__module__ == 'calendar'
+        if byref:
+            assert main.day_name is sys.modules['calendar'].__dict__['day_name']
+
+        assert main.complex_log is sys.modules['cmath'].__dict__['log']
+
+    except AssertionError:
+        import traceback
+        error_line = traceback.format_exc().splitlines()[-2].replace('[obj]', '['+repr(obj)+']')
+        print("Error while testing (byref=%s):" % byref, error_line, sep="\n", file=sys.stderr)
+        raise
+
+
+# Test session loading in a fresh interpreter session.
+if __name__ == '__main__' and len(sys.argv) >= 3 and sys.argv[1] == '--child':
+    byref = sys.argv[2] == 'True'
+    dill.load_session(session_file % byref)
+    test_modules(__main__, byref)
+    sys.exit()
+
+del test_modules
+
+
+def _clean_up_cache(module):
+    cached = module.__file__.split('.', 1)[0] + '.pyc'
+    cached = module.__cached__ if hasattr(module, '__cached__') else cached
+    pycache = os.path.join(os.path.dirname(module.__file__), '__pycache__')
+    for remove, file in [(os.remove, cached), (os.removedirs, pycache)]:
+        try:
+            remove(file)
+        except OSError:
+            pass
+
+
+# To clean up namespace before loading the session.
+original_modules = set(sys.modules.keys()) - \
+        set(['json', 'urllib', 'xml.sax', 'xml.dom.minidom', 'calendar', 'cmath'])
+original_objects = set(__main__.__dict__.keys())
+original_objects.add('original_objects')
+
+
+# Create various kinds of objects to test different internal logics.
+
+## Modules.
+import json                                         # top-level module
+import urllib as url                                # top-level module under alias
+from xml import sax                                 # submodule
+import xml.dom.minidom as dom                       # submodule under alias
+import test_dictviews as local_mod                  # non-builtin top-level module
+atexit.register(_clean_up_cache, local_mod)
+
+## Imported objects.
+from calendar import Calendar, isleap, day_name     # class, function, other object
+from cmath import log as complex_log                # imported with alias
+
+## Local objects.
+x = 17
+empty = None
+names = ['Alice', 'Bob', 'Carol']
+def squared(x): return x**2
+cubed = lambda x: x**3
+class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+person = Person(names[0], x)
+class CalendarSubclass(Calendar):
+    def weekdays(self):
+        return [day_name[i] for i in self.iterweekdays()]
+cal = CalendarSubclass()
+selfref = __main__
+
+
+def test_objects(main, copy_dict, byref):
+    main_dict = main.__dict__
+
+    try:
+        for obj in ('json', 'url', 'local_mod', 'sax', 'dom'):
+            assert main_dict[obj].__name__ == copy_dict[obj].__name__
+
+        #FIXME: In the second test call, 'calendar' is not included in
+        # sys.modules, independent of the value of byref. Tried to run garbage
+        # collection before with no luck. This block fails even with
+        # "import calendar" before it. Needed to restore the original modules
+        # with the 'copy_modules' object. (Moved to "test_session_{1,2}.py".)
+
+        #for obj in ('Calendar', 'isleap'):
+        #    assert main_dict[obj] is sys.modules['calendar'].__dict__[obj]
+        #assert main_dict['day_name'].__module__ == 'calendar'
+        #if byref:
+        #    assert main_dict['day_name'] is sys.modules['calendar'].__dict__['day_name']
+
+        for obj in ('x', 'empty', 'names'):
+            assert main_dict[obj] == copy_dict[obj]
+
+        globs = '__globals__' if dill._dill.PY3 else 'func_globals'
+        for obj in ['squared', 'cubed']:
+            assert getattr(main_dict[obj], globs) is main_dict
+            assert main_dict[obj](3) == copy_dict[obj](3)
+
+        assert main.Person.__module__ == main.__name__
+        assert isinstance(main.person, main.Person)
+        assert main.person.age == copy_dict['person'].age
+
+        assert issubclass(main.CalendarSubclass, main.Calendar)
+        assert isinstance(main.cal, main.CalendarSubclass)
+        assert main.cal.weekdays() == copy_dict['cal'].weekdays()
+
+        assert main.selfref is main
+
+    except AssertionError:
+        import traceback
+        error_line = traceback.format_exc().splitlines()[-2].replace('[obj]', '['+repr(obj)+']')
+        print("Error while testing (byref=%s):" % byref, error_line, sep="\n", file=sys.stderr)
+        raise
+
+
+if __name__ == '__main__':
+
+    # Test dump_session() and load_session().
+    for byref in (False, True):
+        if byref:
+            # Test unpickleable imported object in main.
+            from sys import flags
+
+        #print(sorted(set(sys.modules.keys()) - original_modules))
+        dill._test_file = dill._dill.StringIO()
+        try:
+            # For the subprocess.
+            dill.dump_session(session_file % byref, byref=byref)
+
+            dill.dump_session(dill._test_file, byref=byref)
+            dump = dill._test_file.getvalue()
+            dill._test_file.close()
+
+            import __main__
+            copy_dict = __main__.__dict__.copy()
+            copy_modules = sys.modules.copy()
+            del copy_dict['dump']
+            del copy_dict['__main__']
+            for name in copy_dict.keys():
+                if name not in original_objects:
+                    del __main__.__dict__[name]
+            for module in list(sys.modules.keys()):
+                if module not in original_modules:
+                    del sys.modules[module]
+
+            dill._test_file = dill._dill.StringIO(dump)
+            dill.load_session(dill._test_file)
+            #print(sorted(set(sys.modules.keys()) - original_modules))
+
+            # Test session loading in a new session.
+            from dill.tests.__main__ import python, shell, sp
+            error = sp.call([python, __file__, '--child', str(byref)], shell=shell)
+            if error: sys.exit(error)
+            del python, shell, sp
+
+        finally:
+            dill._test_file.close()
+            try:
+                os.remove(session_file % byref)
+            except OSError:
+                pass
+
+        test_objects(__main__, copy_dict, byref)
+        __main__.__dict__.update(copy_dict)
+        sys.modules.update(copy_modules)
+        del __main__, copy_dict, copy_modules, dump
+
+
+    # This is for code coverage, tests the use case of dump_session(byref=True)
+    # without imported objects in the namespace. It's a contrived example because
+    # even dill can't be in it.
+    from types import ModuleType
+    modname = '__test_main__'
+    main = ModuleType(modname)
+    main.x = 42
+
+    _main = dill._dill._stash_modules(main)
+    if _main is not main:
+        print("There are objects to save by referenece that shouldn't be:",
+              _main.__dill_imported, _main.__dill_imported_as, _main.__dill_imported_top_level,
+              file=sys.stderr)
+
+    test_file = dill._dill.StringIO()
+    try:
+        dill.dump_session(test_file, main=main, byref=True)
+        dump = test_file.getvalue()
+        test_file.close()
+
+        sys.modules[modname] = ModuleType(modname)  # empty
+        # This should work after fixing https://github.com/uqfoundation/dill/issues/462
+        test_file = dill._dill.StringIO(dump)
+        dill.load_session(test_file)
+    finally:
+        test_file.close()
+
+    assert x == 42
+
+
+    # Dump session for module that is not __main__:
+    import test_classdef as module
+    atexit.register(_clean_up_cache, module)
+    module.selfref = module
+    dict_objects = [obj for obj in module.__dict__.keys() if not obj.startswith('__')]
+
+    test_file = dill._dill.StringIO()
+    try:
+        dill.dump_session(test_file, main=module)
+        dump = test_file.getvalue()
+        test_file.close()
+
+        for obj in dict_objects:
+            del module.__dict__[obj]
+
+        test_file = dill._dill.StringIO(dump)
+        dill.load_session(test_file, main=module)
+    finally:
+        test_file.close()
+
+    assert all(obj in module.__dict__ for obj in dict_objects)
+    assert module.selfref is module
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_source.py b/myenv/lib/python3.9/site-packages/dill/tests/test_source.py
new file mode 100644
index 0000000..57d25d1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_source.py
@@ -0,0 +1,163 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+from dill.source import getsource, getname, _wrap, likely_import
+from dill.source import getimportable
+from dill._dill import IS_PYPY
+
+import sys
+PY3 = sys.version_info[0] >= 3
+IS_PYPY3 = IS_PYPY and PY3
+PY310b = '0x30a00b1'
+
+f = lambda x: x**2
+def g(x): return f(x) - x
+
+def h(x):
+  def g(x): return x
+  return g(x) - x
+
+class Foo(object):
+  def bar(self, x):
+    return x*x+x
+_foo = Foo()
+
+def add(x,y):
+  return x+y
+
+# yes, same as 'f', but things are tricky when it comes to pointers
+squared = lambda x:x**2
+
+class Bar:
+  pass
+_bar = Bar()
+
+                       # inspect.getsourcelines # dill.source.getblocks
+def test_getsource():
+  assert getsource(f) == 'f = lambda x: x**2\n'
+  assert getsource(g) == 'def g(x): return f(x) - x\n'
+  assert getsource(h) == 'def h(x):\n  def g(x): return x\n  return g(x) - x\n'
+  assert getname(f) == 'f'
+  assert getname(g) == 'g'
+  assert getname(h) == 'h'
+  assert _wrap(f)(4) == 16
+  assert _wrap(g)(4) == 12
+  assert _wrap(h)(4) == 0
+
+  assert getname(Foo) == 'Foo'
+  assert getname(Bar) == 'Bar'
+  assert getsource(Bar) == 'class Bar:\n  pass\n'
+  assert getsource(Foo) == 'class Foo(object):\n  def bar(self, x):\n    return x*x+x\n'
+  #XXX: add getsource for  _foo, _bar
+
+# test itself
+def test_itself():
+  assert likely_import(likely_import)=='from dill.source import likely_import\n'
+
+# builtin functions and objects
+def test_builtin():
+  if PY3: builtin = 'builtins'
+  else: builtin = '__builtin__'
+  assert likely_import(pow) == 'pow\n'
+  assert likely_import(100) == '100\n'
+  assert likely_import(True) == 'True\n'
+  assert likely_import(pow, explicit=True) == 'from %s import pow\n' % builtin
+  assert likely_import(100, explicit=True) == '100\n'
+  assert likely_import(True, explicit=True) == 'True\n' if PY3 else 'from %s import True\n' % builtin
+  # this is kinda BS... you can't import a None
+  assert likely_import(None) == 'None\n'
+  assert likely_import(None, explicit=True) == 'None\n'
+
+
+# other imported functions
+def test_imported():
+  from math import sin
+  assert likely_import(sin) == 'from math import sin\n'
+
+# interactively defined functions
+def test_dynamic():
+  assert likely_import(add) == 'from %s import add\n' % __name__
+  # interactive lambdas
+  assert likely_import(squared) == 'from %s import squared\n' % __name__
+
+# classes and class instances
+def test_classes():
+  try: #XXX: should this be a 'special case'?
+    from StringIO import StringIO
+    y = "from StringIO import StringIO\n"
+    x = y
+  except ImportError:
+    from io import BytesIO as StringIO
+    y = "from _io import BytesIO\n"
+    x = y if (IS_PYPY3 or hex(sys.hexversion) >= PY310b) else "from io import BytesIO\n"
+  s = StringIO()
+
+  assert likely_import(StringIO) == x
+  assert likely_import(s) == y
+  # interactively defined classes and class instances
+  assert likely_import(Foo) == 'from %s import Foo\n' % __name__
+  assert likely_import(_foo) == 'from %s import Foo\n' % __name__
+
+
+# test getimportable
+def test_importable():
+  assert getimportable(add) == 'from %s import add\n' % __name__
+  assert getimportable(squared) == 'from %s import squared\n' % __name__
+  assert getimportable(Foo) == 'from %s import Foo\n' % __name__
+  assert getimportable(Foo.bar) == 'from %s import bar\n' % __name__
+  assert getimportable(_foo.bar) == 'from %s import bar\n' % __name__
+  assert getimportable(None) == 'None\n'
+  assert getimportable(100) == '100\n'
+
+  assert getimportable(add, byname=False) == 'def add(x,y):\n  return x+y\n'
+  assert getimportable(squared, byname=False) == 'squared = lambda x:x**2\n'
+  assert getimportable(None, byname=False) == 'None\n'
+  assert getimportable(Bar, byname=False) == 'class Bar:\n  pass\n'
+  assert getimportable(Foo, byname=False) == 'class Foo(object):\n  def bar(self, x):\n    return x*x+x\n'
+  assert getimportable(Foo.bar, byname=False) == 'def bar(self, x):\n  return x*x+x\n'
+  assert getimportable(Foo.bar, byname=True) == 'from %s import bar\n' % __name__
+  assert getimportable(Foo.bar, alias='memo', byname=True) == 'from %s import bar as memo\n' % __name__
+  assert getimportable(Foo, alias='memo', byname=True) == 'from %s import Foo as memo\n' % __name__
+  assert getimportable(squared, alias='memo', byname=True) == 'from %s import squared as memo\n' % __name__
+  assert getimportable(squared, alias='memo', byname=False) == 'memo = squared = lambda x:x**2\n'
+  assert getimportable(add, alias='memo', byname=False) == 'def add(x,y):\n  return x+y\n\nmemo = add\n'
+  assert getimportable(None, alias='memo', byname=False) == 'memo = None\n'
+  assert getimportable(100, alias='memo', byname=False) == 'memo = 100\n'
+  assert getimportable(add, explicit=True) == 'from %s import add\n' % __name__
+  assert getimportable(squared, explicit=True) == 'from %s import squared\n' % __name__
+  assert getimportable(Foo, explicit=True) == 'from %s import Foo\n' % __name__
+  assert getimportable(Foo.bar, explicit=True) == 'from %s import bar\n' % __name__
+  assert getimportable(_foo.bar, explicit=True) == 'from %s import bar\n' % __name__
+  assert getimportable(None, explicit=True) == 'None\n'
+  assert getimportable(100, explicit=True) == '100\n'
+
+
+def test_numpy():
+  try:
+    from numpy import array
+    x = array([1,2,3])
+    assert getimportable(x) == 'from numpy import array\narray([1, 2, 3])\n'
+    assert getimportable(array) == 'from %s import array\n' % array.__module__
+    assert getimportable(x, byname=False) == 'from numpy import array\narray([1, 2, 3])\n'
+    assert getimportable(array, byname=False) == 'from %s import array\n' % array.__module__
+  except ImportError: pass
+
+#NOTE: if before likely_import(pow), will cause pow to throw AssertionError
+def test_foo():
+  assert getimportable(_foo, byname=False).startswith("import dill\nclass Foo(object):\n  def bar(self, x):\n    return x*x+x\ndill.loads(")
+
+if __name__ == '__main__':
+    test_getsource()
+    test_itself()
+    test_builtin()
+    test_imported()
+    test_dynamic()
+    test_classes()
+    test_importable()
+    test_numpy()
+    test_foo()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_temp.py b/myenv/lib/python3.9/site-packages/dill/tests/test_temp.py
new file mode 100644
index 0000000..bcf7594
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_temp.py
@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import sys
+from dill.temp import dump, dump_source, dumpIO, dumpIO_source
+from dill.temp import load, load_source, loadIO, loadIO_source
+WINDOWS = sys.platform[:3] == 'win'
+
+
+f = lambda x: x**2
+x = [1,2,3,4,5]
+
+# source code to tempfile
+def test_code_to_tempfile():
+    if not WINDOWS:  #see: https://bugs.python.org/issue14243
+        pyfile = dump_source(f, alias='_f')
+        _f = load_source(pyfile)
+        assert _f(4) == f(4)
+
+# source code to stream
+def test_code_to_stream():
+    pyfile = dumpIO_source(f, alias='_f')
+    _f = loadIO_source(pyfile)
+    assert _f(4) == f(4)
+
+# pickle to tempfile
+def test_pickle_to_tempfile():
+    if not WINDOWS:  #see: https://bugs.python.org/issue14243
+        dumpfile = dump(x)
+        _x = load(dumpfile)
+        assert _x == x
+
+# pickle to stream
+def test_pickle_to_stream():
+    dumpfile = dumpIO(x)
+    _x = loadIO(dumpfile)
+    assert _x == x
+
+### now testing the objects ###
+f = lambda x: x**2
+def g(x): return f(x) - x
+
+def h(x):
+  def g(x): return x
+  return g(x) - x 
+
+class Foo(object):
+  def bar(self, x):
+    return x*x+x
+_foo = Foo()
+
+def add(x,y):
+  return x+y
+
+# yes, same as 'f', but things are tricky when it comes to pointers
+squared = lambda x:x**2
+
+class Bar:
+  pass
+_bar = Bar()
+
+
+# test function-type objects that take 2 args
+def test_two_arg_functions():
+  for obj in [add]:
+    pyfile = dumpIO_source(obj, alias='_obj')
+    _obj = loadIO_source(pyfile)
+    assert _obj(4,2) == obj(4,2)
+
+# test function-type objects that take 1 arg
+def test_one_arg_functions():
+  for obj in [g, h, squared]:
+    pyfile = dumpIO_source(obj, alias='_obj')
+    _obj = loadIO_source(pyfile)
+    assert _obj(4) == obj(4)
+
+# test instance-type objects
+#for obj in [_bar, _foo]:
+#  pyfile = dumpIO_source(obj, alias='_obj')
+#  _obj = loadIO_source(pyfile)
+#  assert type(_obj) == type(obj)
+
+# test the rest of the objects
+def test_the_rest():
+  for obj in [Bar, Foo, Foo.bar, _foo.bar]:
+    pyfile = dumpIO_source(obj, alias='_obj')
+    _obj = loadIO_source(pyfile)
+    assert _obj.__name__ == obj.__name__
+
+
+if __name__ == '__main__':
+    test_code_to_tempfile()
+    test_code_to_stream()
+    test_pickle_to_tempfile()
+    test_pickle_to_stream()
+    test_two_arg_functions()
+    test_one_arg_functions()
+    test_the_rest()
diff --git a/myenv/lib/python3.9/site-packages/dill/tests/test_weakref.py b/myenv/lib/python3.9/site-packages/dill/tests/test_weakref.py
new file mode 100644
index 0000000..ada7d14
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dill/tests/test_weakref.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2022 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+dill.settings['recurse'] = True
+import weakref
+
+class _class:
+    def _method(self):
+        pass
+
+class _class2:
+    def __call__(self):
+        pass
+
+class _newclass(object):
+    def _method(self):
+        pass
+
+class _newclass2(object):
+    def __call__(self):
+        pass
+
+def _function():
+    pass
+
+
+def test_weakref():
+    o = _class()
+    oc = _class2()
+    n = _newclass()
+    nc = _newclass2()
+    f = _function
+    z = _class
+    x = _newclass
+
+    r = weakref.ref(o)
+    dr = weakref.ref(_class())
+    p = weakref.proxy(o)
+    dp = weakref.proxy(_class())
+    c = weakref.proxy(oc)
+    dc = weakref.proxy(_class2())
+
+    m = weakref.ref(n)
+    dm = weakref.ref(_newclass())
+    t = weakref.proxy(n)
+    dt = weakref.proxy(_newclass())
+    d = weakref.proxy(nc)
+    dd = weakref.proxy(_newclass2())
+
+    fr = weakref.ref(f)
+    fp = weakref.proxy(f)
+    #zr = weakref.ref(z) #XXX: weakrefs not allowed for classobj objects
+    #zp = weakref.proxy(z) #XXX: weakrefs not allowed for classobj objects
+    xr = weakref.ref(x)
+    xp = weakref.proxy(x)
+
+    objlist = [r,dr,m,dm,fr,xr, p,dp,t,dt, c,dc,d,dd, fp,xp]
+    #dill.detect.trace(True)
+
+    for obj in objlist:
+      res = dill.detect.errors(obj)
+      if res:
+        print ("%s" % res)
+       #print ("%s:\n  %s" % (obj, res))
+    # else:
+    #   print ("PASS: %s" % obj)
+      assert not res
+
+def test_dictproxy():
+    from dill._dill import DictProxyType
+    try:
+        m = DictProxyType({"foo": "bar"})
+    except:
+        m = type.__dict__
+    mp = dill.copy(m)   
+    assert mp.items() == m.items()
+
+
+if __name__ == '__main__':
+    test_weakref()
+    from dill._dill import IS_PYPY
+    if not IS_PYPY:
+        test_dictproxy()
diff --git a/myenv/lib/python3.9/site-packages/dotenv/__init__.py b/myenv/lib/python3.9/site-packages/dotenv/__init__.py
new file mode 100644
index 0000000..3512d10
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dotenv/__init__.py
@@ -0,0 +1,49 @@
+from typing import Any, Optional
+
+from .main import (dotenv_values, find_dotenv, get_key, load_dotenv, set_key,
+                   unset_key)
+
+
+def load_ipython_extension(ipython: Any) -> None:
+    from .ipython import load_ipython_extension
+    load_ipython_extension(ipython)
+
+
+def get_cli_string(
+    path: Optional[str] = None,
+    action: Optional[str] = None,
+    key: Optional[str] = None,
+    value: Optional[str] = None,
+    quote: Optional[str] = None,
+):
+    """Returns a string suitable for running as a shell script.
+
+    Useful for converting a arguments passed to a fabric task
+    to be passed to a `local` or `run` command.
+    """
+    command = ['dotenv']
+    if quote:
+        command.append('-q %s' % quote)
+    if path:
+        command.append('-f %s' % path)
+    if action:
+        command.append(action)
+        if key:
+            command.append(key)
+            if value:
+                if ' ' in value:
+                    command.append('"%s"' % value)
+                else:
+                    command.append(value)
+
+    return ' '.join(command).strip()
+
+
+__all__ = ['get_cli_string',
+           'load_dotenv',
+           'dotenv_values',
+           'get_key',
+           'set_key',
+           'unset_key',
+           'find_dotenv',
+           'load_ipython_extension']
diff --git a/myenv/lib/python3.9/site-packages/dotenv/cli.py b/myenv/lib/python3.9/site-packages/dotenv/cli.py
new file mode 100644
index 0000000..b7ae24a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dotenv/cli.py
@@ -0,0 +1,164 @@
+import os
+import sys
+from subprocess import Popen
+from typing import Any, Dict, List
+
+try:
+    import click
+except ImportError:
+    sys.stderr.write('It seems python-dotenv is not installed with cli option. \n'
+                     'Run pip install "python-dotenv[cli]" to fix this.')
+    sys.exit(1)
+
+from .main import dotenv_values, get_key, set_key, unset_key
+from .version import __version__
+
+
+@click.group()
+@click.option('-f', '--file', default=os.path.join(os.getcwd(), '.env'),
+              type=click.Path(file_okay=True),
+              help="Location of the .env file, defaults to .env file in current working directory.")
+@click.option('-q', '--quote', default='always',
+              type=click.Choice(['always', 'never', 'auto']),
+              help="Whether to quote or not the variable values. Default mode is always. This does not affect parsing.")
+@click.option('-e', '--export', default=False,
+              type=click.BOOL,
+              help="Whether to write the dot file as an executable bash script.")
+@click.version_option(version=__version__)
+@click.pass_context
+def cli(ctx: click.Context, file: Any, quote: Any, export: Any) -> None:
+    '''This script is used to set, get or unset values from a .env file.'''
+    ctx.obj = {}
+    ctx.obj['QUOTE'] = quote
+    ctx.obj['EXPORT'] = export
+    ctx.obj['FILE'] = file
+
+
+@cli.command()
+@click.pass_context
+def list(ctx: click.Context) -> None:
+    '''Display all the stored key/value.'''
+    file = ctx.obj['FILE']
+    if not os.path.isfile(file):
+        raise click.BadParameter(
+            'Path "%s" does not exist.' % (file),
+            ctx=ctx
+        )
+    dotenv_as_dict = dotenv_values(file)
+    for k, v in dotenv_as_dict.items():
+        click.echo('%s=%s' % (k, v))
+
+
+@cli.command()
+@click.pass_context
+@click.argument('key', required=True)
+@click.argument('value', required=True)
+def set(ctx: click.Context, key: Any, value: Any) -> None:
+    '''Store the given key/value.'''
+    file = ctx.obj['FILE']
+    quote = ctx.obj['QUOTE']
+    export = ctx.obj['EXPORT']
+    success, key, value = set_key(file, key, value, quote, export)
+    if success:
+        click.echo('%s=%s' % (key, value))
+    else:
+        exit(1)
+
+
+@cli.command()
+@click.pass_context
+@click.argument('key', required=True)
+def get(ctx: click.Context, key: Any) -> None:
+    '''Retrieve the value for the given key.'''
+    file = ctx.obj['FILE']
+    if not os.path.isfile(file):
+        raise click.BadParameter(
+            'Path "%s" does not exist.' % (file),
+            ctx=ctx
+        )
+    stored_value = get_key(file, key)
+    if stored_value:
+        click.echo(stored_value)
+    else:
+        exit(1)
+
+
+@cli.command()
+@click.pass_context
+@click.argument('key', required=True)
+def unset(ctx: click.Context, key: Any) -> None:
+    '''Removes the given key.'''
+    file = ctx.obj['FILE']
+    quote = ctx.obj['QUOTE']
+    success, key = unset_key(file, key, quote)
+    if success:
+        click.echo("Successfully removed %s" % key)
+    else:
+        exit(1)
+
+
+@cli.command(context_settings={'ignore_unknown_options': True})
+@click.pass_context
+@click.option(
+    "--override/--no-override",
+    default=True,
+    help="Override variables from the environment file with those from the .env file.",
+)
+@click.argument('commandline', nargs=-1, type=click.UNPROCESSED)
+def run(ctx: click.Context, override: bool, commandline: List[str]) -> None:
+    """Run command with environment variables present."""
+    file = ctx.obj['FILE']
+    if not os.path.isfile(file):
+        raise click.BadParameter(
+            'Invalid value for \'-f\' "%s" does not exist.' % (file),
+            ctx=ctx
+        )
+    dotenv_as_dict = {
+        k: v
+        for (k, v) in dotenv_values(file).items()
+        if v is not None and (override or k not in os.environ)
+    }
+
+    if not commandline:
+        click.echo('No command given.')
+        exit(1)
+    ret = run_command(commandline, dotenv_as_dict)
+    exit(ret)
+
+
+def run_command(command: List[str], env: Dict[str, str]) -> int:
+    """Run command in sub process.
+
+    Runs the command in a sub process with the variables from `env`
+    added in the current environment variables.
+
+    Parameters
+    ----------
+    command: List[str]
+        The command and it's parameters
+    env: Dict
+        The additional environment variables
+
+    Returns
+    -------
+    int
+        The return code of the command
+
+    """
+    # copy the current environment variables and add the vales from
+    # `env`
+    cmd_env = os.environ.copy()
+    cmd_env.update(env)
+
+    p = Popen(command,
+              universal_newlines=True,
+              bufsize=0,
+              shell=False,
+              env=cmd_env)
+    _, _ = p.communicate()
+
+    return p.returncode
+
+
+if __name__ == "__main__":
+    cli()
diff --git a/myenv/lib/python3.9/site-packages/dotenv/ipython.py b/myenv/lib/python3.9/site-packages/dotenv/ipython.py
new file mode 100644
index 0000000..7df727c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dotenv/ipython.py
@@ -0,0 +1,39 @@
+from IPython.core.magic import Magics, line_magic, magics_class  # type: ignore
+from IPython.core.magic_arguments import (argument, magic_arguments,  # type: ignore
+                                          parse_argstring)  # type: ignore
+
+from .main import find_dotenv, load_dotenv
+
+
+@magics_class
+class IPythonDotEnv(Magics):
+
+    @magic_arguments()
+    @argument(
+        '-o', '--override', action='store_true',
+        help="Indicate to override existing variables"
+    )
+    @argument(
+        '-v', '--verbose', action='store_true',
+        help="Indicate function calls to be verbose"
+    )
+    @argument('dotenv_path', nargs='?', type=str, default='.env',
+              help='Search in increasingly higher folders for the `dotenv_path`')
+    @line_magic
+    def dotenv(self, line):
+        args = parse_argstring(self.dotenv, line)
+        # Locate the .env file
+        dotenv_path = args.dotenv_path
+        try:
+            dotenv_path = find_dotenv(dotenv_path, True, True)
+        except IOError:
+            print("cannot find .env file")
+            return
+
+        # Load the .env file
+        load_dotenv(dotenv_path, verbose=args.verbose, override=args.override)
+
+
+def load_ipython_extension(ipython):
+    """Register the %dotenv magic."""
+    ipython.register_magics(IPythonDotEnv)
diff --git a/myenv/lib/python3.9/site-packages/dotenv/main.py b/myenv/lib/python3.9/site-packages/dotenv/main.py
new file mode 100644
index 0000000..20ac61b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dotenv/main.py
@@ -0,0 +1,373 @@
+import io
+import logging
+import os
+import shutil
+import sys
+import tempfile
+from collections import OrderedDict
+from contextlib import contextmanager
+from typing import (IO, Dict, Iterable, Iterator, Mapping, Optional, Tuple,
+                    Union)
+
+from .parser import Binding, parse_stream
+from .variables import parse_variables
+
+logger = logging.getLogger(__name__)
+
+if sys.version_info >= (3, 6):
+    _PathLike = os.PathLike
+else:
+    _PathLike = str
+
+
+def with_warn_for_invalid_lines(mappings: Iterator[Binding]) -> Iterator[Binding]:
+    for mapping in mappings:
+        if mapping.error:
+            logger.warning(
+                "Python-dotenv could not parse statement starting at line %s",
+                mapping.original.line,
+            )
+        yield mapping
+
+
+class DotEnv():
+    def __init__(
+        self,
+        dotenv_path: Optional[Union[str, _PathLike]],
+        stream: Optional[IO[str]] = None,
+        verbose: bool = False,
+        encoding: Union[None, str] = None,
+        interpolate: bool = True,
+        override: bool = True,
+    ) -> None:
+        self.dotenv_path = dotenv_path  # type: Optional[Union[str, _PathLike]]
+        self.stream = stream  # type: Optional[IO[str]]
+        self._dict = None  # type: Optional[Dict[str, Optional[str]]]
+        self.verbose = verbose  # type: bool
+        self.encoding = encoding  # type: Union[None, str]
+        self.interpolate = interpolate  # type: bool
+        self.override = override  # type: bool
+
+    @contextmanager
+    def _get_stream(self) -> Iterator[IO[str]]:
+        if self.dotenv_path and os.path.isfile(self.dotenv_path):
+            with io.open(self.dotenv_path, encoding=self.encoding) as stream:
+                yield stream
+        elif self.stream is not None:
+            yield self.stream
+        else:
+            if self.verbose:
+                logger.info(
+                    "Python-dotenv could not find configuration file %s.",
+                    self.dotenv_path or '.env',
+                )
+            yield io.StringIO('')
+
+    def dict(self) -> Dict[str, Optional[str]]:
+        """Return dotenv as dict"""
+        if self._dict:
+            return self._dict
+
+        raw_values = self.parse()
+
+        if self.interpolate:
+            self._dict = OrderedDict(resolve_variables(raw_values, override=self.override))
+        else:
+            self._dict = OrderedDict(raw_values)
+
+        return self._dict
+
+    def parse(self) -> Iterator[Tuple[str, Optional[str]]]:
+        with self._get_stream() as stream:
+            for mapping in with_warn_for_invalid_lines(parse_stream(stream)):
+                if mapping.key is not None:
+                    yield mapping.key, mapping.value
+
+    def set_as_environment_variables(self) -> bool:
+        """
+        Load the current dotenv as system environment variable.
+        """
+        for k, v in self.dict().items():
+            if k in os.environ and not self.override:
+                continue
+            if v is not None:
+                os.environ[k] = v
+
+        return True
+
+    def get(self, key: str) -> Optional[str]:
+        """
+        """
+        data = self.dict()
+
+        if key in data:
+            return data[key]
+
+        if self.verbose:
+            logger.warning("Key %s not found in %s.", key, self.dotenv_path)
+
+        return None
+
+
+def get_key(
+    dotenv_path: Union[str, _PathLike],
+    key_to_get: str,
+    encoding: Optional[str] = "utf-8",
+) -> Optional[str]:
+    """
+    Get the value of a given key from the given .env.
+
+    Returns `None` if the key isn't found or doesn't have a value.
+    """
+    return DotEnv(dotenv_path, verbose=True, encoding=encoding).get(key_to_get)
+
+
+@contextmanager
+def rewrite(
+    path: Union[str, _PathLike],
+    encoding: Optional[str],
+) -> Iterator[Tuple[IO[str], IO[str]]]:
+    try:
+        if not os.path.isfile(path):
+            with io.open(path, "w+", encoding=encoding) as source:
+                source.write("")
+        with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding=encoding) as dest:
+            with io.open(path, encoding=encoding) as source:
+                yield (source, dest)  # type: ignore
+    except BaseException:
+        if os.path.isfile(dest.name):
+            os.unlink(dest.name)
+        raise
+    else:
+        shutil.move(dest.name, path)
+
+
+def set_key(
+    dotenv_path: Union[str, _PathLike],
+    key_to_set: str,
+    value_to_set: str,
+    quote_mode: str = "always",
+    export: bool = False,
+    encoding: Optional[str] = "utf-8",
+) -> Tuple[Optional[bool], str, str]:
+    """
+    Adds or Updates a key/value to the given .env
+
+    If the .env path given doesn't exist, fails instead of risking creating
+    an orphan .env somewhere in the filesystem
+    """
+    if quote_mode not in ("always", "auto", "never"):
+        raise ValueError("Unknown quote_mode: {}".format(quote_mode))
+
+    quote = (
+        quote_mode == "always"
+        or (quote_mode == "auto" and not value_to_set.isalnum())
+    )
+
+    if quote:
+        value_out = "'{}'".format(value_to_set.replace("'", "\\'"))
+    else:
+        value_out = value_to_set
+    if export:
+        line_out = 'export {}={}\n'.format(key_to_set, value_out)
+    else:
+        line_out = "{}={}\n".format(key_to_set, value_out)
+
+    with rewrite(dotenv_path, encoding=encoding) as (source, dest):
+        replaced = False
+        missing_newline = False
+        for mapping in with_warn_for_invalid_lines(parse_stream(source)):
+            if mapping.key == key_to_set:
+                dest.write(line_out)
+                replaced = True
+            else:
+                dest.write(mapping.original.string)
+                missing_newline = not mapping.original.string.endswith("\n")
+        if not replaced:
+            if missing_newline:
+                dest.write("\n")
+            dest.write(line_out)
+
+    return True, key_to_set, value_to_set
+
+
+def unset_key(
+    dotenv_path: Union[str, _PathLike],
+    key_to_unset: str,
+    quote_mode: str = "always",
+    encoding: Optional[str] = "utf-8",
+) -> Tuple[Optional[bool], str]:
+    """
+    Removes a given key from the given .env
+
+    If the .env path given doesn't exist, fails
+    If the given key doesn't exist in the .env, fails
+    """
+    if not os.path.exists(dotenv_path):
+        logger.warning("Can't delete from %s - it doesn't exist.", dotenv_path)
+        return None, key_to_unset
+
+    removed = False
+    with rewrite(dotenv_path, encoding=encoding) as (source, dest):
+        for mapping in with_warn_for_invalid_lines(parse_stream(source)):
+            if mapping.key == key_to_unset:
+                removed = True
+            else:
+                dest.write(mapping.original.string)
+
+    if not removed:
+        logger.warning("Key %s not removed from %s - key doesn't exist.", key_to_unset, dotenv_path)
+        return None, key_to_unset
+
+    return removed, key_to_unset
+
+
+def resolve_variables(
+    values: Iterable[Tuple[str, Optional[str]]],
+    override: bool,
+) -> Mapping[str, Optional[str]]:
+    new_values = {}  # type: Dict[str, Optional[str]]
+
+    for (name, value) in values:
+        if value is None:
+            result = None
+        else:
+            atoms = parse_variables(value)
+            env = {}  # type: Dict[str, Optional[str]]
+            if override:
+                env.update(os.environ)  # type: ignore
+                env.update(new_values)
+            else:
+                env.update(new_values)
+                env.update(os.environ)  # type: ignore
+            result = "".join(atom.resolve(env) for atom in atoms)
+
+        new_values[name] = result
+
+    return new_values
+
+
+def _walk_to_root(path: str) -> Iterator[str]:
+    """
+    Yield directories starting from the given directory up to the root
+    """
+    if not os.path.exists(path):
+        raise IOError('Starting path not found')
+
+    if os.path.isfile(path):
+        path = os.path.dirname(path)
+
+    last_dir = None
+    current_dir = os.path.abspath(path)
+    while last_dir != current_dir:
+        yield current_dir
+        parent_dir = os.path.abspath(os.path.join(current_dir, os.path.pardir))
+        last_dir, current_dir = current_dir, parent_dir
+
+
+def find_dotenv(
+    filename: str = '.env',
+    raise_error_if_not_found: bool = False,
+    usecwd: bool = False,
+) -> str:
+    """
+    Search in increasingly higher folders for the given file
+
+    Returns path to the file if found, or an empty string otherwise
+    """
+
+    def _is_interactive():
+        """ Decide whether this is running in a REPL or IPython notebook """
+        main = __import__('__main__', None, None, fromlist=['__file__'])
+        return not hasattr(main, '__file__')
+
+    if usecwd or _is_interactive() or getattr(sys, 'frozen', False):
+        # Should work without __file__, e.g. in REPL or IPython notebook.
+        path = os.getcwd()
+    else:
+        # will work for .py files
+        frame = sys._getframe()
+        current_file = __file__
+
+        while frame.f_code.co_filename == current_file:
+            assert frame.f_back is not None
+            frame = frame.f_back
+        frame_filename = frame.f_code.co_filename
+        path = os.path.dirname(os.path.abspath(frame_filename))
+
+    for dirname in _walk_to_root(path):
+        check_path = os.path.join(dirname, filename)
+        if os.path.isfile(check_path):
+            return check_path
+
+    if raise_error_if_not_found:
+        raise IOError('File not found')
+
+    return ''
+
+
+def load_dotenv(
+    dotenv_path: Union[str, _PathLike, None] = None,
+    stream: Optional[IO[str]] = None,
+    verbose: bool = False,
+    override: bool = False,
+    interpolate: bool = True,
+    encoding: Optional[str] = "utf-8",
+) -> bool:
+    """Parse a .env file and then load all the variables found as environment variables.
+
+    - *dotenv_path*: absolute or relative path to .env file.
+    - *stream*: Text stream (such as `io.StringIO`) with .env content, used if
+      `dotenv_path` is `None`.
+    - *verbose*: whether to output a warning the .env file is missing. Defaults to
+      `False`.
+    - *override*: whether to override the system environment variables with the variables
+      in `.env` file.  Defaults to `False`.
+    - *encoding*: encoding to be used to read the file.
+
+    If both `dotenv_path` and `stream`, `find_dotenv()` is used to find the .env file.
+    """
+    if dotenv_path is None and stream is None:
+        dotenv_path = find_dotenv()
+
+    dotenv = DotEnv(
+        dotenv_path=dotenv_path,
+        stream=stream,
+        verbose=verbose,
+        interpolate=interpolate,
+        override=override,
+        encoding=encoding,
+    )
+    return dotenv.set_as_environment_variables()
+
+
+def dotenv_values(
+    dotenv_path: Union[str, _PathLike, None] = None,
+    stream: Optional[IO[str]] = None,
+    verbose: bool = False,
+    interpolate: bool = True,
+    encoding: Optional[str] = "utf-8",
+) -> Dict[str, Optional[str]]:
+    """
+    Parse a .env file and return its content as a dict.
+
+    - *dotenv_path*: absolute or relative path to .env file.
+    - *stream*: `StringIO` object with .env content, used if `dotenv_path` is `None`.
+    - *verbose*: whether to output a warning the .env file is missing. Defaults to
+      `False`.
+      in `.env` file.  Defaults to `False`.
+    - *encoding*: encoding to be used to read the file.
+
+    If both `dotenv_path` and `stream`, `find_dotenv()` is used to find the .env file.
+    """
+    if dotenv_path is None and stream is None:
+        dotenv_path = find_dotenv()
+
+    return DotEnv(
+        dotenv_path=dotenv_path,
+        stream=stream,
+        verbose=verbose,
+        interpolate=interpolate,
+        override=True,
+        encoding=encoding,
+    ).dict()
diff --git a/myenv/lib/python3.9/site-packages/dotenv/parser.py b/myenv/lib/python3.9/site-packages/dotenv/parser.py
new file mode 100644
index 0000000..398bd49
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dotenv/parser.py
@@ -0,0 +1,182 @@
+import codecs
+import re
+from typing import (IO, Iterator, Match, NamedTuple, Optional,  # noqa:F401
+                    Pattern, Sequence, Tuple)
+
+
+def make_regex(string: str, extra_flags: int = 0) -> Pattern[str]:
+    return re.compile(string, re.UNICODE | extra_flags)
+
+
+_newline = make_regex(r"(\r\n|\n|\r)")
+_multiline_whitespace = make_regex(r"\s*", extra_flags=re.MULTILINE)
+_whitespace = make_regex(r"[^\S\r\n]*")
+_export = make_regex(r"(?:export[^\S\r\n]+)?")
+_single_quoted_key = make_regex(r"'([^']+)'")
+_unquoted_key = make_regex(r"([^=\#\s]+)")
+_equal_sign = make_regex(r"(=[^\S\r\n]*)")
+_single_quoted_value = make_regex(r"'((?:\\'|[^'])*)'")
+_double_quoted_value = make_regex(r'"((?:\\"|[^"])*)"')
+_unquoted_value = make_regex(r"([^\r\n]*)")
+_comment = make_regex(r"(?:[^\S\r\n]*#[^\r\n]*)?")
+_end_of_line = make_regex(r"[^\S\r\n]*(?:\r\n|\n|\r|$)")
+_rest_of_line = make_regex(r"[^\r\n]*(?:\r|\n|\r\n)?")
+_double_quote_escapes = make_regex(r"\\[\\'\"abfnrtv]")
+_single_quote_escapes = make_regex(r"\\[\\']")
+
+
+Original = NamedTuple(
+    "Original",
+    [
+        ("string", str),
+        ("line", int),
+    ],
+)
+
+Binding = NamedTuple(
+    "Binding",
+    [
+        ("key", Optional[str]),
+        ("value", Optional[str]),
+        ("original", Original),
+        ("error", bool),
+    ],
+)
+
+
+class Position:
+    def __init__(self, chars: int, line: int) -> None:
+        self.chars = chars
+        self.line = line
+
+    @classmethod
+    def start(cls) -> "Position":
+        return cls(chars=0, line=1)
+
+    def set(self, other: "Position") -> None:
+        self.chars = other.chars
+        self.line = other.line
+
+    def advance(self, string: str) -> None:
+        self.chars += len(string)
+        self.line += len(re.findall(_newline, string))
+
+
+class Error(Exception):
+    pass
+
+
+class Reader:
+    def __init__(self, stream: IO[str]) -> None:
+        self.string = stream.read()
+        self.position = Position.start()
+        self.mark = Position.start()
+
+    def has_next(self) -> bool:
+        return self.position.chars < len(self.string)
+
+    def set_mark(self) -> None:
+        self.mark.set(self.position)
+
+    def get_marked(self) -> Original:
+        return Original(
+            string=self.string[self.mark.chars:self.position.chars],
+            line=self.mark.line,
+        )
+
+    def peek(self, count: int) -> str:
+        return self.string[self.position.chars:self.position.chars + count]
+
+    def read(self, count: int) -> str:
+        result = self.string[self.position.chars:self.position.chars + count]
+        if len(result) < count:
+            raise Error("read: End of string")
+        self.position.advance(result)
+        return result
+
+    def read_regex(self, regex: Pattern[str]) -> Sequence[str]:
+        match = regex.match(self.string, self.position.chars)
+        if match is None:
+            raise Error("read_regex: Pattern not found")
+        self.position.advance(self.string[match.start():match.end()])
+        return match.groups()
+
+
+def decode_escapes(regex: Pattern[str], string: str) -> str:
+    def decode_match(match: Match[str]) -> str:
+        return codecs.decode(match.group(0), 'unicode-escape')  # type: ignore
+
+    return regex.sub(decode_match, string)
+
+
+def parse_key(reader: Reader) -> Optional[str]:
+    char = reader.peek(1)
+    if char == "#":
+        return None
+    elif char == "'":
+        (key,) = reader.read_regex(_single_quoted_key)
+    else:
+        (key,) = reader.read_regex(_unquoted_key)
+    return key
+
+
+def parse_unquoted_value(reader: Reader) -> str:
+    (part,) = reader.read_regex(_unquoted_value)
+    return re.sub(r"\s+#.*", "", part).rstrip()
+
+
+def parse_value(reader: Reader) -> str:
+    char = reader.peek(1)
+    if char == u"'":
+        (value,) = reader.read_regex(_single_quoted_value)
+        return decode_escapes(_single_quote_escapes, value)
+    elif char == u'"':
+        (value,) = reader.read_regex(_double_quoted_value)
+        return decode_escapes(_double_quote_escapes, value)
+    elif char in (u"", u"\n", u"\r"):
+        return u""
+    else:
+        return parse_unquoted_value(reader)
+
+
+def parse_binding(reader: Reader) -> Binding:
+    reader.set_mark()
+    try:
+        reader.read_regex(_multiline_whitespace)
+        if not reader.has_next():
+            return Binding(
+                key=None,
+                value=None,
+                original=reader.get_marked(),
+                error=False,
+            )
+        reader.read_regex(_export)
+        key = parse_key(reader)
+        reader.read_regex(_whitespace)
+        if reader.peek(1) == "=":
+            reader.read_regex(_equal_sign)
+            value = parse_value(reader)  # type: Optional[str]
+        else:
+            value = None
+        reader.read_regex(_comment)
+        reader.read_regex(_end_of_line)
+        return Binding(
+            key=key,
+            value=value,
+            original=reader.get_marked(),
+            error=False,
+        )
+    except Error:
+        reader.read_regex(_rest_of_line)
+        return Binding(
+            key=None,
+            value=None,
+            original=reader.get_marked(),
+            error=True,
+        )
+
+
+def parse_stream(stream: IO[str]) -> Iterator[Binding]:
+    reader = Reader(stream)
+    while reader.has_next():
+        yield parse_binding(reader)
diff --git a/myenv/lib/python3.9/site-packages/dotenv/py.typed b/myenv/lib/python3.9/site-packages/dotenv/py.typed
new file mode 100644
index 0000000..7632ecf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dotenv/py.typed
@@ -0,0 +1 @@
+# Marker file for PEP 561
diff --git a/myenv/lib/python3.9/site-packages/dotenv/variables.py b/myenv/lib/python3.9/site-packages/dotenv/variables.py
new file mode 100644
index 0000000..d77b700
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dotenv/variables.py
@@ -0,0 +1,88 @@
+import re
+from abc import ABCMeta
+from typing import Iterator, Mapping, Optional, Pattern
+
+_posix_variable = re.compile(
+    r"""
+    \$\{
+        (?P<name>[^\}:]*)
+        (?::-
+            (?P<default>[^\}]*)
+        )?
+    \}
+    """,
+    re.VERBOSE,
+)  # type: Pattern[str]
+
+
+class Atom():
+    __metaclass__ = ABCMeta
+
+    def __ne__(self, other: object) -> bool:
+        result = self.__eq__(other)
+        if result is NotImplemented:
+            return NotImplemented
+        return not result
+
+    def resolve(self, env: Mapping[str, Optional[str]]) -> str:
+        raise NotImplementedError
+
+
+class Literal(Atom):
+    def __init__(self, value: str) -> None:
+        self.value = value
+
+    def __repr__(self) -> str:
+        return "Literal(value={})".format(self.value)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return self.value == other.value
+
+    def __hash__(self) -> int:
+        return hash((self.__class__, self.value))
+
+    def resolve(self, env: Mapping[str, Optional[str]]) -> str:
+        return self.value
+
+
+class Variable(Atom):
+    def __init__(self, name: str, default: Optional[str]) -> None:
+        self.name = name
+        self.default = default
+
+    def __repr__(self) -> str:
+        return "Variable(name={}, default={})".format(self.name, self.default)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return (self.name, self.default) == (other.name, other.default)
+
+    def __hash__(self) -> int:
+        return hash((self.__class__, self.name, self.default))
+
+    def resolve(self, env: Mapping[str, Optional[str]]) -> str:
+        default = self.default if self.default is not None else ""
+        result = env.get(self.name, default)
+        return result if result is not None else ""
+
+
+def parse_variables(value: str) -> Iterator[Atom]:
+    cursor = 0
+
+    for match in _posix_variable.finditer(value):
+        (start, end) = match.span()
+        name = match.groupdict()["name"]
+        default = match.groupdict()["default"]
+
+        if start > cursor:
+            yield Literal(value=value[cursor:start])
+
+        yield Variable(name=name, default=default)
+        cursor = end
+
+    length = len(value)
+    if cursor < length:
+        yield Literal(value=value[cursor:length])
diff --git a/myenv/lib/python3.9/site-packages/dotenv/version.py b/myenv/lib/python3.9/site-packages/dotenv/version.py
new file mode 100644
index 0000000..5f4bb0b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/dotenv/version.py
@@ -0,0 +1 @@
+__version__ = "0.20.0"
diff --git a/myenv/lib/python3.9/site-packages/easy_install.py b/myenv/lib/python3.9/site-packages/easy_install.py
new file mode 100644
index 0000000..d87e984
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/easy_install.py
@@ -0,0 +1,5 @@
+"""Run the EasyInstall command"""
+
+if __name__ == '__main__':
+    from setuptools.command.easy_install import main
+    main()
diff --git a/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/LICENSE
new file mode 100644
index 0000000..474479a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/LICENSE
@@ -0,0 +1,24 @@
+"python-ecdsa" Copyright (c) 2010 Brian Warner
+
+Portions written in 2005 by Peter Pearson and placed in the public domain.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/METADATA
new file mode 100644
index 0000000..fa1c5fe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/METADATA
@@ -0,0 +1,675 @@
+Metadata-Version: 2.1
+Name: ecdsa
+Version: 0.18.0
+Summary: ECDSA cryptographic signature library (pure python)
+Home-page: http://github.com/tlsfuzzer/python-ecdsa
+Author: Brian Warner
+Author-email: warner@lothar.com
+License: MIT
+Platform: UNKNOWN
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=2.6, !=3.0.*, !=3.1.*, !=3.2.*
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: six (>=1.9.0)
+Provides-Extra: gmpy
+Requires-Dist: gmpy ; extra == 'gmpy'
+Provides-Extra: gmpy2
+Requires-Dist: gmpy2 ; extra == 'gmpy2'
+
+# Pure-Python ECDSA and ECDH
+
+[![Build Status](https://github.com/tlsfuzzer/python-ecdsa/workflows/GitHub%20CI/badge.svg?branch=master)](https://github.com/tlsfuzzer/python-ecdsa/actions?query=workflow%3A%22GitHub+CI%22+branch%3Amaster)
+[![Documentation Status](https://readthedocs.org/projects/ecdsa/badge/?version=latest)](https://ecdsa.readthedocs.io/en/latest/?badge=latest)
+[![Coverage Status](https://coveralls.io/repos/github/tlsfuzzer/python-ecdsa/badge.svg?branch=master)](https://coveralls.io/github/tlsfuzzer/python-ecdsa?branch=master)
+![condition coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/tomato42/9b6ca1f3410207fbeca785a178781651/raw/python-ecdsa-condition-coverage.json)
+[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/tlsfuzzer/python-ecdsa.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/tlsfuzzer/python-ecdsa/context:python)
+[![Total alerts](https://img.shields.io/lgtm/alerts/g/tlsfuzzer/python-ecdsa.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/tlsfuzzer/python-ecdsa/alerts/)
+[![Latest Version](https://img.shields.io/pypi/v/ecdsa.svg?style=flat)](https://pypi.python.org/pypi/ecdsa/)
+![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat)
+
+
+This is an easy-to-use implementation of ECC (Elliptic Curve Cryptography)
+with support for ECDSA (Elliptic Curve Digital Signature Algorithm),
+EdDSA (Edwards-curve Digital Signature Algorithm) and ECDH
+(Elliptic Curve Diffie-Hellman), implemented purely in Python, released under
+the MIT license. With this library, you can quickly create key pairs (signing
+key and verifying key), sign messages, and verify the signatures. You can
+also agree on a shared secret key based on exchanged public keys.
+The keys and signatures are very short, making them easy to handle and
+incorporate into other protocols.
+
+**NOTE: This library should not be used in production settings, see [Security](#Security) for more details.**
+
+## Features
+
+This library provides key generation, signing, verifying, and shared secret
+derivation for five
+popular NIST "Suite B" GF(p) (_prime field_) curves, with key lengths of 192,
+224, 256, 384, and 521 bits. The "short names" for these curves, as known by
+the OpenSSL tool (`openssl ecparam -list_curves`), are: `prime192v1`,
+`secp224r1`, `prime256v1`, `secp384r1`, and `secp521r1`. It includes the
+256-bit curve `secp256k1` used by Bitcoin. There is also support for the
+regular (non-twisted) variants of Brainpool curves from 160 to 512 bits. The
+"short names" of those curves are: `brainpoolP160r1`, `brainpoolP192r1`,
+`brainpoolP224r1`, `brainpoolP256r1`, `brainpoolP320r1`, `brainpoolP384r1`,
+`brainpoolP512r1`. Few of the small curves from SEC standard are also
+included (mainly to speed-up testing of the library), those are:
+`secp112r1`, `secp112r2`, `secp128r1`, and `secp160r1`.
+Key generation, siging and verifying is also supported for Ed25519 and
+Ed448 curves.
+No other curves are included, but it is not too hard to add support for more
+curves over prime fields.
+
+## Dependencies
+
+This library uses only Python and the 'six' package. It is compatible with
+Python 2.6, 2.7, and 3.3+. It also supports execution on alternative
+implementations like pypy and pypy3.
+
+If `gmpy2` or `gmpy` is installed, they will be used for faster arithmetic.
+Either of them can be installed after this library is installed,
+`python-ecdsa` will detect their presence on start-up and use them
+automatically.
+You should prefer `gmpy2` on Python3 for optimal performance.
+
+To run the OpenSSL compatibility tests, the 'openssl' tool must be in your
+`PATH`. This release has been tested successfully against OpenSSL 0.9.8o,
+1.0.0a, 1.0.2f, 1.1.1d and 3.0.1 (among others).
+
+
+## Installation
+
+This library is available on PyPI, it's recommended to install it using `pip`:
+
+```
+pip install ecdsa
+```
+
+In case higher performance is wanted and using native code is not a problem,
+it's possible to specify installation together with `gmpy2`:
+
+```
+pip install ecdsa[gmpy2]
+```
+
+or (slower, legacy option):
+```
+pip install ecdsa[gmpy]
+```
+
+## Speed
+
+The following table shows how long this library takes to generate key pairs
+(`keygen`), to sign data (`sign`), to verify those signatures (`verify`),
+to derive a shared secret (`ecdh`), and
+to verify the signatures with no key-specific precomputation (`no PC verify`).
+All those values are in seconds.
+For convenience, the inverses of those values are also provided:
+how many keys per second can be generated (`keygen/s`), how many signatures
+can be made per second (`sign/s`), how many signatures can be verified
+per second (`verify/s`), how many shared secrets can be derived per second
+(`ecdh/s`), and how many signatures with no key specific
+precomputation can be verified per second (`no PC verify/s`). The size of raw
+signature (generally the smallest
+the way a signature can be encoded) is also provided in the `siglen` column.
+Use `tox -e speed` to generate this table on your own computer.
+On an Intel Core i7 4790K @ 4.0GHz I'm getting the following performance:
+
+```
+                  siglen    keygen   keygen/s      sign     sign/s    verify   verify/s  no PC verify  no PC verify/s
+        NIST192p:     48   0.00032s   3134.06   0.00033s   2985.53   0.00063s   1598.36       0.00129s         774.43
+        NIST224p:     56   0.00040s   2469.24   0.00042s   2367.88   0.00081s   1233.41       0.00170s         586.66
+        NIST256p:     64   0.00051s   1952.73   0.00054s   1867.80   0.00098s   1021.86       0.00212s         471.27
+        NIST384p:     96   0.00107s    935.92   0.00111s    904.23   0.00203s    491.77       0.00446s         224.00
+        NIST521p:    132   0.00210s    475.52   0.00215s    464.16   0.00398s    251.28       0.00874s         114.39
+       SECP256k1:     64   0.00052s   1921.54   0.00054s   1847.49   0.00105s    948.68       0.00210s         477.01
+ BRAINPOOLP160r1:     40   0.00025s   4003.88   0.00026s   3845.12   0.00053s   1893.93       0.00105s         949.92
+ BRAINPOOLP192r1:     48   0.00033s   3043.97   0.00034s   2975.98   0.00063s   1581.50       0.00135s         742.29
+ BRAINPOOLP224r1:     56   0.00041s   2436.44   0.00043s   2315.51   0.00078s   1278.49       0.00180s         556.16
+ BRAINPOOLP256r1:     64   0.00053s   1892.49   0.00054s   1846.24   0.00114s    875.64       0.00229s         437.25
+ BRAINPOOLP320r1:     80   0.00073s   1361.26   0.00076s   1309.25   0.00143s    699.29       0.00322s         310.49
+ BRAINPOOLP384r1:     96   0.00107s    931.29   0.00111s    901.80   0.00230s    434.19       0.00476s         210.20
+ BRAINPOOLP512r1:    128   0.00207s    483.41   0.00212s    471.42   0.00425s    235.43       0.00912s         109.61
+       SECP112r1:     28   0.00015s   6672.53   0.00016s   6440.34   0.00031s   3265.41       0.00056s        1774.20
+       SECP112r2:     28   0.00015s   6697.11   0.00015s   6479.98   0.00028s   3524.72       0.00058s        1716.16
+       SECP128r1:     32   0.00018s   5497.65   0.00019s   5272.89   0.00036s   2747.39       0.00072s        1396.16
+       SECP160r1:     42   0.00025s   3949.32   0.00026s   3894.45   0.00046s   2153.85       0.00102s         985.07
+         Ed25519:     64   0.00076s   1324.48   0.00042s   2405.01   0.00109s    918.05       0.00344s         290.50
+           Ed448:    114   0.00176s    569.53   0.00115s    870.94   0.00282s    355.04       0.01024s          97.69
+
+                       ecdh     ecdh/s
+        NIST192p:   0.00104s    964.89
+        NIST224p:   0.00134s    748.63
+        NIST256p:   0.00170s    587.08
+        NIST384p:   0.00352s    283.90
+        NIST521p:   0.00717s    139.51
+       SECP256k1:   0.00154s    648.40
+ BRAINPOOLP160r1:   0.00082s   1220.70
+ BRAINPOOLP192r1:   0.00105s    956.75
+ BRAINPOOLP224r1:   0.00136s    734.52
+ BRAINPOOLP256r1:   0.00178s    563.32
+ BRAINPOOLP320r1:   0.00252s    397.23
+ BRAINPOOLP384r1:   0.00376s    266.27
+ BRAINPOOLP512r1:   0.00733s    136.35
+       SECP112r1:   0.00046s   2180.40
+       SECP112r2:   0.00045s   2229.14
+       SECP128r1:   0.00054s   1868.15
+       SECP160r1:   0.00080s   1243.98
+```
+
+To test performance with `gmpy2` loaded, use `tox -e speedgmpy2`.
+On the same machine I'm getting the following performance with `gmpy2`:
+```
+                  siglen    keygen   keygen/s      sign     sign/s    verify   verify/s  no PC verify  no PC verify/s
+        NIST192p:     48   0.00017s   5933.40   0.00017s   5751.70   0.00032s   3125.28       0.00067s        1502.41
+        NIST224p:     56   0.00021s   4782.87   0.00022s   4610.05   0.00040s   2487.04       0.00089s        1126.90
+        NIST256p:     64   0.00023s   4263.98   0.00024s   4125.16   0.00045s   2200.88       0.00098s        1016.82
+        NIST384p:     96   0.00041s   2449.54   0.00042s   2399.96   0.00083s   1210.57       0.00172s         581.43
+        NIST521p:    132   0.00071s   1416.07   0.00072s   1389.81   0.00144s    692.93       0.00312s         320.40
+       SECP256k1:     64   0.00024s   4245.05   0.00024s   4122.09   0.00045s   2206.40       0.00094s        1068.32
+ BRAINPOOLP160r1:     40   0.00014s   6939.17   0.00015s   6681.55   0.00029s   3452.43       0.00057s        1769.81
+ BRAINPOOLP192r1:     48   0.00017s   5920.05   0.00017s   5774.36   0.00034s   2979.00       0.00069s        1453.19
+ BRAINPOOLP224r1:     56   0.00021s   4732.12   0.00022s   4622.65   0.00041s   2422.47       0.00087s        1149.87
+ BRAINPOOLP256r1:     64   0.00024s   4233.02   0.00024s   4115.20   0.00047s   2143.27       0.00098s        1015.60
+ BRAINPOOLP320r1:     80   0.00032s   3162.38   0.00032s   3077.62   0.00063s   1598.83       0.00136s         737.34
+ BRAINPOOLP384r1:     96   0.00041s   2436.88   0.00042s   2395.62   0.00083s   1202.68       0.00178s         562.85
+ BRAINPOOLP512r1:    128   0.00063s   1587.60   0.00064s   1558.83   0.00125s    799.96       0.00281s         355.83
+       SECP112r1:     28   0.00009s  11118.66   0.00009s  10775.48   0.00018s   5456.00       0.00033s        3020.83
+       SECP112r2:     28   0.00009s  11322.97   0.00009s  10857.71   0.00017s   5748.77       0.00032s        3094.28
+       SECP128r1:     32   0.00010s  10078.39   0.00010s   9665.27   0.00019s   5200.58       0.00036s        2760.88
+       SECP160r1:     42   0.00015s   6875.51   0.00015s   6647.35   0.00029s   3422.41       0.00057s        1768.35
+         Ed25519:     64   0.00030s   3322.56   0.00018s   5568.63   0.00046s   2165.35       0.00153s         654.02
+           Ed448:    114   0.00060s   1680.53   0.00039s   2567.40   0.00096s   1036.67       0.00350s         285.62
+
+                       ecdh     ecdh/s
+        NIST192p:   0.00050s   1985.70
+        NIST224p:   0.00066s   1524.16
+        NIST256p:   0.00071s   1413.07
+        NIST384p:   0.00127s    788.89
+        NIST521p:   0.00230s    434.85
+       SECP256k1:   0.00071s   1409.95
+ BRAINPOOLP160r1:   0.00042s   2374.65
+ BRAINPOOLP192r1:   0.00051s   1960.01
+ BRAINPOOLP224r1:   0.00066s   1518.37
+ BRAINPOOLP256r1:   0.00071s   1399.90
+ BRAINPOOLP320r1:   0.00100s    997.21
+ BRAINPOOLP384r1:   0.00129s    777.51
+ BRAINPOOLP512r1:   0.00210s    475.99
+       SECP112r1:   0.00022s   4457.70
+       SECP112r2:   0.00024s   4252.33
+       SECP128r1:   0.00028s   3589.31
+       SECP160r1:   0.00043s   2305.02
+```
+
+(there's also `gmpy` version, execute it using `tox -e speedgmpy`)
+
+For comparison, a highly optimised implementation (including curve-specific
+assembly for some curves), like the one in OpenSSL 1.1.1d, provides the
+following performance numbers on the same machine.
+Run `openssl speed ecdsa` and `openssl speed ecdh` to reproduce it:
+```
+                              sign    verify    sign/s verify/s
+ 192 bits ecdsa (nistp192)   0.0002s   0.0002s   4785.6   5380.7
+ 224 bits ecdsa (nistp224)   0.0000s   0.0001s  22475.6   9822.0
+ 256 bits ecdsa (nistp256)   0.0000s   0.0001s  45069.6  14166.6
+ 384 bits ecdsa (nistp384)   0.0008s   0.0006s   1265.6   1648.1
+ 521 bits ecdsa (nistp521)   0.0003s   0.0005s   3753.1   1819.5
+ 256 bits ecdsa (brainpoolP256r1)   0.0003s   0.0003s   2983.5   3333.2
+ 384 bits ecdsa (brainpoolP384r1)   0.0008s   0.0007s   1258.8   1528.1
+ 512 bits ecdsa (brainpoolP512r1)   0.0015s   0.0012s    675.1    860.1
+
+                              sign    verify    sign/s verify/s
+ 253 bits EdDSA (Ed25519)   0.0000s   0.0001s  28217.9  10897.7
+ 456 bits EdDSA (Ed448)     0.0003s   0.0005s   3926.5   2147.7
+
+                               op      op/s
+ 192 bits ecdh (nistp192)   0.0002s   4853.4
+ 224 bits ecdh (nistp224)   0.0001s  15252.1
+ 256 bits ecdh (nistp256)   0.0001s  18436.3
+ 384 bits ecdh (nistp384)   0.0008s   1292.7
+ 521 bits ecdh (nistp521)   0.0003s   2884.7
+ 256 bits ecdh (brainpoolP256r1)   0.0003s   3066.5
+ 384 bits ecdh (brainpoolP384r1)   0.0008s   1298.0
+ 512 bits ecdh (brainpoolP512r1)   0.0014s    694.8
+```
+
+Keys and signature can be serialized in different ways (see Usage, below).
+For a NIST192p key, the three basic representations require strings of the
+following lengths (in bytes):
+
+    to_string:  signkey= 24, verifykey= 48, signature=48
+    compressed: signkey=n/a, verifykey= 25, signature=n/a
+    DER:        signkey=106, verifykey= 80, signature=55
+    PEM:        signkey=278, verifykey=162, (no support for PEM signatures)
+
+## History
+
+In 2006, Peter Pearson announced his pure-python implementation of ECDSA in a
+[message to sci.crypt][1], available from his [download site][2]. In 2010,
+Brian Warner wrote a wrapper around this code, to make it a bit easier and
+safer to use. In 2020, Hubert Kario included an implementation of elliptic
+curve cryptography that uses Jacobian coordinates internally, improving
+performance about 20-fold. You are looking at the README for this wrapper.
+
+[1]: http://www.derkeiler.com/Newsgroups/sci.crypt/2006-01/msg00651.html
+[2]: http://webpages.charter.net/curryfans/peter/downloads.html
+
+## Testing
+
+To run the full test suite, do this:
+
+    tox -e coverage
+
+On an Intel Core i7 4790K @ 4.0GHz, the tests take about 18 seconds to execute.
+The test suite uses
+[`hypothesis`](https://github.com/HypothesisWorks/hypothesis) so there is some
+inherent variability in the test suite execution time.
+
+One part of `test_pyecdsa.py` and `test_ecdh.py` checks compatibility with
+OpenSSL, by running the "openssl" CLI tool, make sure it's in your `PATH` if
+you want to test compatibility with it (if OpenSSL is missing, too old, or
+doesn't support all the curves supported in upstream releases you will see
+skipped tests in the above `coverage` run).
+
+## Security
+
+This library was not designed with security in mind. If you are processing
+data that needs to be protected we suggest you use a quality wrapper around
+OpenSSL. [pyca/cryptography](https://cryptography.io) is one example of such
+a wrapper. The primary use-case of this library is as a portable library for
+interoperability testing and as a teaching tool.
+
+**This library does not protect against side-channel attacks.**
+
+Do not allow attackers to measure how long it takes you to generate a key pair
+or sign a message. Do not allow attackers to run code on the same physical
+machine when key pair generation or signing is taking place (this includes
+virtual machines). Do not allow attackers to measure how much power your
+computer uses while generating the key pair or signing a message. Do not allow
+attackers to measure RF interference coming from your computer while generating
+a key pair or signing a message. Note: just loading the private key will cause
+key pair generation. Other operations or attack vectors may also be
+vulnerable to attacks. **For a sophisticated attacker observing just one
+operation with a private key will be sufficient to completely
+reconstruct the private key**.
+
+Please also note that any Pure-python cryptographic library will be vulnerable
+to the same side-channel attacks. This is because Python does not provide
+side-channel secure primitives (with the exception of
+[`hmac.compare_digest()`][3]), making side-channel secure programming
+impossible.
+
+This library depends upon a strong source of random numbers. Do not use it on
+a system where `os.urandom()` does not provide cryptographically secure
+random numbers.
+
+[3]: https://docs.python.org/3/library/hmac.html#hmac.compare_digest
+
+## Usage
+
+You start by creating a `SigningKey`. You can use this to sign data, by passing
+in data as a byte string and getting back the signature (also a byte string).
+You can also ask a `SigningKey` to give you the corresponding `VerifyingKey`.
+The `VerifyingKey` can be used to verify a signature, by passing it both the
+data string and the signature byte string: it either returns True or raises
+`BadSignatureError`.
+
+```python
+from ecdsa import SigningKey
+sk = SigningKey.generate() # uses NIST192p
+vk = sk.verifying_key
+signature = sk.sign(b"message")
+assert vk.verify(signature, b"message")
+```
+
+Each `SigningKey`/`VerifyingKey` is associated with a specific curve, like
+NIST192p (the default one). Longer curves are more secure, but take longer to
+use, and result in longer keys and signatures.
+
+```python
+from ecdsa import SigningKey, NIST384p
+sk = SigningKey.generate(curve=NIST384p)
+vk = sk.verifying_key
+signature = sk.sign(b"message")
+assert vk.verify(signature, b"message")
+```
+
+The `SigningKey` can be serialized into several different formats: the shortest
+is to call `s=sk.to_string()`, and then re-create it with
+`SigningKey.from_string(s, curve)` . This short form does not record the
+curve, so you must be sure to pass to `from_string()` the same curve you used
+for the original key. The short form of a NIST192p-based signing key is just 24
+bytes long. If a point encoding is invalid or it does not lie on the specified
+curve, `from_string()` will raise `MalformedPointError`.
+
+```python
+from ecdsa import SigningKey, NIST384p
+sk = SigningKey.generate(curve=NIST384p)
+sk_string = sk.to_string()
+sk2 = SigningKey.from_string(sk_string, curve=NIST384p)
+print(sk_string.hex())
+print(sk2.to_string().hex())
+```
+
+Note: while the methods are called `to_string()` the type they return is
+actually `bytes`, the "string" part is leftover from Python 2.
+
+`sk.to_pem()` and `sk.to_der()` will serialize the signing key into the same
+formats that OpenSSL uses. The PEM file looks like the familiar ASCII-armored
+`"-----BEGIN EC PRIVATE KEY-----"` base64-encoded format, and the DER format
+is a shorter binary form of the same data.
+`SigningKey.from_pem()/.from_der()` will undo this serialization. These
+formats include the curve name, so you do not need to pass in a curve
+identifier to the deserializer. In case the file is malformed `from_der()`
+and `from_pem()` will raise `UnexpectedDER` or` MalformedPointError`.
+
+```python
+from ecdsa import SigningKey, NIST384p
+sk = SigningKey.generate(curve=NIST384p)
+sk_pem = sk.to_pem()
+sk2 = SigningKey.from_pem(sk_pem)
+# sk and sk2 are the same key
+```
+
+Likewise, the `VerifyingKey` can be serialized in the same way:
+`vk.to_string()/VerifyingKey.from_string()`, `to_pem()/from_pem()`, and
+`to_der()/from_der()`. The same `curve=` argument is needed for
+`VerifyingKey.from_string()`.
+
+```python
+from ecdsa import SigningKey, VerifyingKey, NIST384p
+sk = SigningKey.generate(curve=NIST384p)
+vk = sk.verifying_key
+vk_string = vk.to_string()
+vk2 = VerifyingKey.from_string(vk_string, curve=NIST384p)
+# vk and vk2 are the same key
+
+from ecdsa import SigningKey, VerifyingKey, NIST384p
+sk = SigningKey.generate(curve=NIST384p)
+vk = sk.verifying_key
+vk_pem = vk.to_pem()
+vk2 = VerifyingKey.from_pem(vk_pem)
+# vk and vk2 are the same key
+```
+
+There are a couple of different ways to compute a signature. Fundamentally,
+ECDSA takes a number that represents the data being signed, and returns a
+pair of numbers that represent the signature. The `hashfunc=` argument to
+`sk.sign()` and `vk.verify()` is used to turn an arbitrary string into a
+fixed-length digest, which is then turned into a number that ECDSA can sign,
+and both sign and verify must use the same approach. The default value is
+`hashlib.sha1`, but if you use NIST256p or a longer curve, you can use
+`hashlib.sha256` instead.
+
+There are also multiple ways to represent a signature. The default
+`sk.sign()` and `vk.verify()` methods present it as a short string, for
+simplicity and minimal overhead. To use a different scheme, use the
+`sk.sign(sigencode=)` and `vk.verify(sigdecode=)` arguments. There are helper
+functions in the `ecdsa.util` module that can be useful here.
+
+It is also possible to create a `SigningKey` from a "seed", which is
+deterministic. This can be used in protocols where you want to derive
+consistent signing keys from some other secret, for example when you want
+three separate keys and only want to store a single master secret. You should
+start with a uniformly-distributed unguessable seed with about `curve.baselen`
+bytes of entropy, and then use one of the helper functions in `ecdsa.util` to
+convert it into an integer in the correct range, and then finally pass it
+into `SigningKey.from_secret_exponent()`, like this:
+
+```python
+import os
+from ecdsa import NIST384p, SigningKey
+from ecdsa.util import randrange_from_seed__trytryagain
+
+def make_key(seed):
+  secexp = randrange_from_seed__trytryagain(seed, NIST384p.order)
+  return SigningKey.from_secret_exponent(secexp, curve=NIST384p)
+
+seed = os.urandom(NIST384p.baselen) # or other starting point
+sk1a = make_key(seed)
+sk1b = make_key(seed)
+# note: sk1a and sk1b are the same key
+assert sk1a.to_string() == sk1b.to_string()
+sk2 = make_key(b"2-"+seed)  # different key
+assert sk1a.to_string() != sk2.to_string()
+```
+
+In case the application will verify a lot of signatures made with a single
+key, it's possible to precompute some of the internal values to make
+signature verification significantly faster. The break-even point occurs at
+about 100 signatures verified.
+
+To perform precomputation, you can call the `precompute()` method
+on `VerifyingKey` instance:
+```python
+from ecdsa import SigningKey, NIST384p
+sk = SigningKey.generate(curve=NIST384p)
+vk = sk.verifying_key
+vk.precompute()
+signature = sk.sign(b"message")
+assert vk.verify(signature, b"message")
+```
+
+Once `precompute()` was called, all signature verifications with this key will
+be faster to execute.
+
+## OpenSSL Compatibility
+
+To produce signatures that can be verified by OpenSSL tools, or to verify
+signatures that were produced by those tools, use:
+
+```python
+# openssl ecparam -name prime256v1 -genkey -out sk.pem
+# openssl ec -in sk.pem -pubout -out vk.pem
+# echo "data for signing" > data
+# openssl dgst -sha256 -sign sk.pem -out data.sig data
+# openssl dgst -sha256 -verify vk.pem -signature data.sig data
+# openssl dgst -sha256 -prverify sk.pem -signature data.sig data
+
+import hashlib
+from ecdsa import SigningKey, VerifyingKey
+from ecdsa.util import sigencode_der, sigdecode_der
+
+with open("vk.pem") as f:
+   vk = VerifyingKey.from_pem(f.read())
+
+with open("data", "rb") as f:
+   data = f.read()
+
+with open("data.sig", "rb") as f:
+   signature = f.read()
+
+assert vk.verify(signature, data, hashlib.sha256, sigdecode=sigdecode_der)
+
+with open("sk.pem") as f:
+   sk = SigningKey.from_pem(f.read(), hashlib.sha256)
+
+new_signature = sk.sign_deterministic(data, sigencode=sigencode_der)
+
+with open("data.sig2", "wb") as f:
+   f.write(new_signature)
+
+# openssl dgst -sha256 -verify vk.pem -signature data.sig2 data
+```
+
+Note: if compatibility with OpenSSL 1.0.0 or earlier is necessary, the
+`sigencode_string` and `sigdecode_string` from `ecdsa.util` can be used for
+respectively writing and reading the signatures.
+
+The keys also can be written in format that openssl can handle:
+
+```python
+from ecdsa import SigningKey, VerifyingKey
+
+with open("sk.pem") as f:
+    sk = SigningKey.from_pem(f.read())
+with open("sk.pem", "wb") as f:
+    f.write(sk.to_pem())
+
+with open("vk.pem") as f:
+    vk = VerifyingKey.from_pem(f.read())
+with open("vk.pem", "wb") as f:
+    f.write(vk.to_pem())
+```
+
+## Entropy
+
+Creating a signing key with `SigningKey.generate()` requires some form of
+entropy (as opposed to
+`from_secret_exponent`/`from_string`/`from_der`/`from_pem`,
+which are deterministic and do not require an entropy source). The default
+source is `os.urandom()`, but you can pass any other function that behaves
+like `os.urandom` as the `entropy=` argument to do something different. This
+may be useful in unit tests, where you want to achieve repeatable results. The
+`ecdsa.util.PRNG` utility is handy here: it takes a seed and produces a strong
+pseudo-random stream from it:
+
+```python
+from ecdsa.util import PRNG
+from ecdsa import SigningKey
+rng1 = PRNG(b"seed")
+sk1 = SigningKey.generate(entropy=rng1)
+rng2 = PRNG(b"seed")
+sk2 = SigningKey.generate(entropy=rng2)
+# sk1 and sk2 are the same key
+```
+
+Likewise, ECDSA signature generation requires a random number, and each
+signature must use a different one (using the same number twice will
+immediately reveal the private signing key). The `sk.sign()` method takes an
+`entropy=` argument which behaves the same as `SigningKey.generate(entropy=)`.
+
+## Deterministic Signatures
+
+If you call `SigningKey.sign_deterministic(data)` instead of `.sign(data)`,
+the code will generate a deterministic signature instead of a random one.
+This uses the algorithm from RFC6979 to safely generate a unique `k` value,
+derived from the private key and the message being signed. Each time you sign
+the same message with the same key, you will get the same signature (using
+the same `k`).
+
+This may become the default in a future version, as it is not vulnerable to
+failures of the entropy source.
+
+## Examples
+
+Create a NIST192p key pair and immediately save both to disk:
+
+```python
+from ecdsa import SigningKey
+sk = SigningKey.generate()
+vk = sk.verifying_key
+with open("private.pem", "wb") as f:
+    f.write(sk.to_pem())
+with open("public.pem", "wb") as f:
+    f.write(vk.to_pem())
+```
+
+Load a signing key from disk, use it to sign a message (using SHA-1), and write
+the signature to disk:
+
+```python
+from ecdsa import SigningKey
+with open("private.pem") as f:
+    sk = SigningKey.from_pem(f.read())
+with open("message", "rb") as f:
+    message = f.read()
+sig = sk.sign(message)
+with open("signature", "wb") as f:
+    f.write(sig)
+```
+
+Load the verifying key, message, and signature from disk, and verify the
+signature (assume SHA-1 hash):
+
+```python
+from ecdsa import VerifyingKey, BadSignatureError
+vk = VerifyingKey.from_pem(open("public.pem").read())
+with open("message", "rb") as f:
+    message = f.read()
+with open("signature", "rb") as f:
+    sig = f.read()
+try:
+    vk.verify(sig, message)
+    print "good signature"
+except BadSignatureError:
+    print "BAD SIGNATURE"
+```
+
+Create a NIST521p key pair:
+
+```python
+from ecdsa import SigningKey, NIST521p
+sk = SigningKey.generate(curve=NIST521p)
+vk = sk.verifying_key
+```
+
+Create three independent signing keys from a master seed:
+
+```python
+from ecdsa import NIST192p, SigningKey
+from ecdsa.util import randrange_from_seed__trytryagain
+
+def make_key_from_seed(seed, curve=NIST192p):
+    secexp = randrange_from_seed__trytryagain(seed, curve.order)
+    return SigningKey.from_secret_exponent(secexp, curve)
+
+sk1 = make_key_from_seed("1:%s" % seed)
+sk2 = make_key_from_seed("2:%s" % seed)
+sk3 = make_key_from_seed("3:%s" % seed)
+```
+
+Load a verifying key from disk and print it using hex encoding in
+uncompressed and compressed format (defined in X9.62 and SEC1 standards):
+
+```python
+from ecdsa import VerifyingKey
+
+with open("public.pem") as f:
+    vk = VerifyingKey.from_pem(f.read())
+
+print("uncompressed: {0}".format(vk.to_string("uncompressed").hex()))
+print("compressed: {0}".format(vk.to_string("compressed").hex()))
+```
+
+Load a verifying key from a hex string from compressed format, output
+uncompressed:
+
+```python
+from ecdsa import VerifyingKey, NIST256p
+
+comp_str = '022799c0d0ee09772fdd337d4f28dc155581951d07082fb19a38aa396b67e77759'
+vk = VerifyingKey.from_string(bytearray.fromhex(comp_str), curve=NIST256p)
+print(vk.to_string("uncompressed").hex())
+```
+
+ECDH key exchange with remote party:
+
+```python
+from ecdsa import ECDH, NIST256p
+
+ecdh = ECDH(curve=NIST256p)
+ecdh.generate_private_key()
+local_public_key = ecdh.get_public_key()
+#send `local_public_key` to remote party and receive `remote_public_key` from remote party
+with open("remote_public_key.pem") as e:
+    remote_public_key = e.read()
+ecdh.load_received_public_key_pem(remote_public_key)
+secret = ecdh.generate_sharedsecret_bytes()
+```
+
+
diff --git a/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/RECORD
new file mode 100644
index 0000000..722d990
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/RECORD
@@ -0,0 +1,35 @@
+ecdsa/__init__.py,sha256=m8jWFcZ9E-iiDqVaTy7ABtvEyTJlF58tZ45UAKj3UWo,1637
+ecdsa/_compat.py,sha256=EhUF8-sFu1dKKGDibkmItbYm_nKoklSIBgkIburUoAg,4619
+ecdsa/_rwlock.py,sha256=CAwHp2V65ksI8B1UqY7EccK9LaUToiv6pDLVzm44eag,2849
+ecdsa/_sha3.py,sha256=DJs7QLmdkQMU35llyD8HQeAXNvf5sMcujO6oFdScIqI,4747
+ecdsa/_version.py,sha256=YZ3BGOHr1Ltse4LfX7F80J6qmKFA-NS-G2eYUuw2WnU,498
+ecdsa/curves.py,sha256=Na5rpnuADNvWkCTlUGbs9xwVogY6Vl2_3uNzpVGgxtE,14390
+ecdsa/der.py,sha256=OmfH8fojeqfJnasAt7I1P8j_qfwcwl-W4gDx1-cO8M0,14109
+ecdsa/ecdh.py,sha256=Tiirawt5xegVDrY9eS-ATvvfmTIznUyv5fy2k7VnzTk,11011
+ecdsa/ecdsa.py,sha256=LPRHHXNvGyZ67lyM6cWqUuhQceCwoktfPij20UTsdJo,24955
+ecdsa/eddsa.py,sha256=IzsGzoGAefcoYjF7DVjFkX5ZJqiK2LTOmAMe6wyf4UU,7170
+ecdsa/ellipticcurve.py,sha256=HwlFqrihf7Q2GQTLYQ0PeCwsgMhk_GlkZz3I2Xj4-eI,53625
+ecdsa/errors.py,sha256=b4mhnmIpRnEdHzbectHAA5F7O9MtSaI-fYoc13_vBxQ,130
+ecdsa/keys.py,sha256=plsomRHYrN3Z3iigUqKM5An8_6TDk1nJNpFv_cPGAvM,65124
+ecdsa/numbertheory.py,sha256=XWugBG59BxrpvjZm7Ytsnmkv770vK8IkClObThpbvAM,17479
+ecdsa/rfc6979.py,sha256=zwzo33lsZJA9r2dSf7HCliI_yIbw5cJ0Ek9tLdRRO40,2850
+ecdsa/test_curves.py,sha256=l5N-m4Yo5IAy4a8aJMsBamaSlLAfSoYjYqCj1HDEVpU,13081
+ecdsa/test_der.py,sha256=q2mr4HS_JyUxojWTSLJu-MQZiTwaCE7W_VG3rwwPEas,14956
+ecdsa/test_ecdh.py,sha256=hUJXTo_Cr9ji9-EpPvpQf7-TgB97WUj2tWcwU-LqCXc,15238
+ecdsa/test_ecdsa.py,sha256=1clBfDtA0zdF-13BoKXsJffL5K-iFutlMgov0kmGro0,23923
+ecdsa/test_eddsa.py,sha256=Vlv5J0C4zNJu5zzr756qpm0AJmARpzBKCWrhHaF_bR4,32615
+ecdsa/test_ellipticcurve.py,sha256=K6W_EQunOfE-RVSux6d1O7LXzSuAsVk9F1elwyY-rYA,6085
+ecdsa/test_jacobi.py,sha256=JDQeM_JKwPfwWBd4IgqtOp1rboeQNUIPPA334b-nmLQ,18388
+ecdsa/test_keys.py,sha256=n_IYLxG4JwD84dYLDmRjV2A-NqsSrrR1P0XBJOCZsEI,32833
+ecdsa/test_malformed_sigs.py,sha256=hiV2vwzFrIdNIC-inYUJIKboyAAw2TKAIVXtFadyojg,10857
+ecdsa/test_numbertheory.py,sha256=g6hi7NZFKuMSAxJSAYW5sWM7ivSCiw8g5-PeoDyowgY,11619
+ecdsa/test_pyecdsa.py,sha256=WeRujEKpkZzHvEeXNnnhM1QdMH0Lxou7Bl4u8RXY-jM,82757
+ecdsa/test_rw_lock.py,sha256=byv0_FTM90cbuHPCI6__LeQJkHL_zYEeVYIBO8e2LLc,7021
+ecdsa/test_sha3.py,sha256=oKULy5KOTaXjpLXSyuHrB1wjPiQDxB6INp7Tf1EU8Ko,3022
+ecdsa/util.py,sha256=cOEN3_c8p79Dc8a-LcUQP2ctIsYky35jhSWc9hLP1qc,14618
+ecdsa-0.18.0.dist-info/LICENSE,sha256=PsqYRXc9LluMydjBGdNF8ApIBuS9Zg1KPWzfnA6di7I,1147
+ecdsa-0.18.0.dist-info/METADATA,sha256=vesFVMWT6uSeOuNwGGxtBm8nm6GROqNNRO28jr8wWqM,29750
+ecdsa-0.18.0.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
+ecdsa-0.18.0.dist-info/top_level.txt,sha256=7ovPHfAPyTou19f8gOSbHm6B9dGjTibWolcCB7Zjovs,6
+ecdsa-0.18.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+ecdsa-0.18.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/WHEEL
new file mode 100644
index 0000000..01b8fc7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/top_level.txt
new file mode 100644
index 0000000..aa5efdb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa-0.18.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+ecdsa
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/__init__.py b/myenv/lib/python3.9/site-packages/ecdsa/__init__.py
new file mode 100644
index 0000000..ce8749a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/__init__.py
@@ -0,0 +1,90 @@
+# while we don't use six in this file, we did bundle it for a long time, so
+# keep as part of module in a virtual way (through __all__)
+import six
+from .keys import (
+    SigningKey,
+    VerifyingKey,
+    BadSignatureError,
+    BadDigestError,
+    MalformedPointError,
+)
+from .curves import (
+    NIST192p,
+    NIST224p,
+    NIST256p,
+    NIST384p,
+    NIST521p,
+    SECP256k1,
+    BRAINPOOLP160r1,
+    BRAINPOOLP192r1,
+    BRAINPOOLP224r1,
+    BRAINPOOLP256r1,
+    BRAINPOOLP320r1,
+    BRAINPOOLP384r1,
+    BRAINPOOLP512r1,
+    SECP112r1,
+    SECP112r2,
+    SECP128r1,
+    SECP160r1,
+    Ed25519,
+    Ed448,
+)
+from .ecdh import (
+    ECDH,
+    NoKeyError,
+    NoCurveError,
+    InvalidCurveError,
+    InvalidSharedSecretError,
+)
+from .der import UnexpectedDER
+from . import _version
+
+# This code comes from http://github.com/tlsfuzzer/python-ecdsa
+__all__ = [
+    "curves",
+    "der",
+    "ecdsa",
+    "ellipticcurve",
+    "keys",
+    "numbertheory",
+    "test_pyecdsa",
+    "util",
+    "six",
+]
+
+_hush_pyflakes = [
+    SigningKey,
+    VerifyingKey,
+    BadSignatureError,
+    BadDigestError,
+    MalformedPointError,
+    UnexpectedDER,
+    InvalidCurveError,
+    NoKeyError,
+    InvalidSharedSecretError,
+    ECDH,
+    NoCurveError,
+    NIST192p,
+    NIST224p,
+    NIST256p,
+    NIST384p,
+    NIST521p,
+    SECP256k1,
+    BRAINPOOLP160r1,
+    BRAINPOOLP192r1,
+    BRAINPOOLP224r1,
+    BRAINPOOLP256r1,
+    BRAINPOOLP320r1,
+    BRAINPOOLP384r1,
+    BRAINPOOLP512r1,
+    SECP112r1,
+    SECP112r2,
+    SECP128r1,
+    SECP160r1,
+    Ed25519,
+    Ed448,
+    six.b(""),
+]
+del _hush_pyflakes
+
+__version__ = _version.get_versions()["version"]
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/_compat.py b/myenv/lib/python3.9/site-packages/ecdsa/_compat.py
new file mode 100644
index 0000000..83d41a5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/_compat.py
@@ -0,0 +1,153 @@
+"""
+Common functions for providing cross-python version compatibility.
+"""
+import sys
+import re
+import binascii
+from six import integer_types
+
+
+def str_idx_as_int(string, index):
+    """Take index'th byte from string, return as integer"""
+    val = string[index]
+    if isinstance(val, integer_types):
+        return val
+    return ord(val)
+
+
+if sys.version_info < (3, 0):  # pragma: no branch
+    import platform
+
+    def normalise_bytes(buffer_object):
+        """Cast the input into array of bytes."""
+        # flake8 runs on py3 where `buffer` indeed doesn't exist...
+        return buffer(buffer_object)  # noqa: F821
+
+    def hmac_compat(ret):
+        return ret
+
+    if (
+        sys.version_info < (2, 7)
+        or sys.version_info < (2, 7, 4)
+        or platform.system() == "Java"
+    ):  # pragma: no branch
+
+        def remove_whitespace(text):
+            """Removes all whitespace from passed in string"""
+            return re.sub(r"\s+", "", text)
+
+        def compat26_str(val):
+            return str(val)
+
+        def bit_length(val):
+            if val == 0:
+                return 0
+            return len(bin(val)) - 2
+
+    else:
+
+        def remove_whitespace(text):
+            """Removes all whitespace from passed in string"""
+            return re.sub(r"\s+", "", text, flags=re.UNICODE)
+
+        def compat26_str(val):
+            return val
+
+        def bit_length(val):
+            """Return number of bits necessary to represent an integer."""
+            return val.bit_length()
+
+    def b2a_hex(val):
+        return binascii.b2a_hex(compat26_str(val))
+
+    def a2b_hex(val):
+        try:
+            return bytearray(binascii.a2b_hex(val))
+        except Exception as e:
+            raise ValueError("base16 error: %s" % e)
+
+    def bytes_to_int(val, byteorder):
+        """Convert bytes to an int."""
+        if not val:
+            return 0
+        if byteorder == "big":
+            return int(b2a_hex(val), 16)
+        if byteorder == "little":
+            return int(b2a_hex(val[::-1]), 16)
+        raise ValueError("Only 'big' and 'little' endian supported")
+
+    def int_to_bytes(val, length=None, byteorder="big"):
+        """Return number converted to bytes"""
+        if length is None:
+            length = byte_length(val)
+        if byteorder == "big":
+            return bytearray(
+                (val >> i) & 0xFF for i in reversed(range(0, length * 8, 8))
+            )
+        if byteorder == "little":
+            return bytearray(
+                (val >> i) & 0xFF for i in range(0, length * 8, 8)
+            )
+        raise ValueError("Only 'big' or 'little' endian supported")
+
+else:
+    if sys.version_info < (3, 4):  # pragma: no branch
+        # on python 3.3 hmac.hmac.update() accepts only bytes, on newer
+        # versions it does accept memoryview() also
+        def hmac_compat(data):
+            if not isinstance(data, bytes):  # pragma: no branch
+                return bytes(data)
+            return data
+
+        def normalise_bytes(buffer_object):
+            """Cast the input into array of bytes."""
+            if not buffer_object:
+                return b""
+            return memoryview(buffer_object).cast("B")
+
+    else:
+
+        def hmac_compat(data):
+            return data
+
+        def normalise_bytes(buffer_object):
+            """Cast the input into array of bytes."""
+            return memoryview(buffer_object).cast("B")
+
+    def compat26_str(val):
+        return val
+
+    def remove_whitespace(text):
+        """Removes all whitespace from passed in string"""
+        return re.sub(r"\s+", "", text, flags=re.UNICODE)
+
+    def a2b_hex(val):
+        try:
+            return bytearray(binascii.a2b_hex(bytearray(val, "ascii")))
+        except Exception as e:
+            raise ValueError("base16 error: %s" % e)
+
+    # pylint: disable=invalid-name
+    # pylint is stupid here and doesn't notice it's a function, not
+    # constant
+    bytes_to_int = int.from_bytes
+    # pylint: enable=invalid-name
+
+    def bit_length(val):
+        """Return number of bits necessary to represent an integer."""
+        return val.bit_length()
+
+    def int_to_bytes(val, length=None, byteorder="big"):
+        """Convert integer to bytes."""
+        if length is None:
+            length = byte_length(val)
+        # for gmpy we need to convert back to native int
+        if type(val) != int:
+            val = int(val)
+        return bytearray(val.to_bytes(length=length, byteorder=byteorder))
+
+
+def byte_length(val):
+    """Return number of bytes necessary to represent an integer."""
+    length = bit_length(val)
+    return (length + 7) // 8
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/_rwlock.py b/myenv/lib/python3.9/site-packages/ecdsa/_rwlock.py
new file mode 100644
index 0000000..010e498
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/_rwlock.py
@@ -0,0 +1,86 @@
+# Copyright Mateusz Kobos, (c) 2011
+# https://code.activestate.com/recipes/577803-reader-writer-lock-with-priority-for-writers/
+# released under the MIT licence
+
+import threading
+
+
+__author__ = "Mateusz Kobos"
+
+
+class RWLock:
+    """
+    Read-Write locking primitive
+
+    Synchronization object used in a solution of so-called second
+    readers-writers problem. In this problem, many readers can simultaneously
+    access a share, and a writer has an exclusive access to this share.
+    Additionally, the following constraints should be met:
+    1) no reader should be kept waiting if the share is currently opened for
+       reading unless a writer is also waiting for the share,
+    2) no writer should be kept waiting for the share longer than absolutely
+       necessary.
+
+    The implementation is based on [1, secs. 4.2.2, 4.2.6, 4.2.7]
+    with a modification -- adding an additional lock (C{self.__readers_queue})
+    -- in accordance with [2].
+
+    Sources:
+    [1] A.B. Downey: "The little book of semaphores", Version 2.1.5, 2008
+    [2] P.J. Courtois, F. Heymans, D.L. Parnas:
+        "Concurrent Control with 'Readers' and 'Writers'",
+        Communications of the ACM, 1971 (via [3])
+    [3] http://en.wikipedia.org/wiki/Readers-writers_problem
+    """
+
+    def __init__(self):
+        """
+        A lock giving an even higher priority to the writer in certain
+        cases (see [2] for a discussion).
+        """
+        self.__read_switch = _LightSwitch()
+        self.__write_switch = _LightSwitch()
+        self.__no_readers = threading.Lock()
+        self.__no_writers = threading.Lock()
+        self.__readers_queue = threading.Lock()
+
+    def reader_acquire(self):
+        self.__readers_queue.acquire()
+        self.__no_readers.acquire()
+        self.__read_switch.acquire(self.__no_writers)
+        self.__no_readers.release()
+        self.__readers_queue.release()
+
+    def reader_release(self):
+        self.__read_switch.release(self.__no_writers)
+
+    def writer_acquire(self):
+        self.__write_switch.acquire(self.__no_readers)
+        self.__no_writers.acquire()
+
+    def writer_release(self):
+        self.__no_writers.release()
+        self.__write_switch.release(self.__no_readers)
+
+
+class _LightSwitch:
+    """An auxiliary "light switch"-like object. The first thread turns on the
+    "switch", the last one turns it off (see [1, sec. 4.2.2] for details)."""
+
+    def __init__(self):
+        self.__counter = 0
+        self.__mutex = threading.Lock()
+
+    def acquire(self, lock):
+        self.__mutex.acquire()
+        self.__counter += 1
+        if self.__counter == 1:
+            lock.acquire()
+        self.__mutex.release()
+
+    def release(self, lock):
+        self.__mutex.acquire()
+        self.__counter -= 1
+        if self.__counter == 0:
+            lock.release()
+        self.__mutex.release()
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/_sha3.py b/myenv/lib/python3.9/site-packages/ecdsa/_sha3.py
new file mode 100644
index 0000000..2db0058
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/_sha3.py
@@ -0,0 +1,181 @@
+"""
+Implementation of the SHAKE-256 algorithm for Ed448
+"""
+
+try:
+    import hashlib
+
+    hashlib.new("shake256").digest(64)
+
+    def shake_256(msg, outlen):
+        return hashlib.new("shake256", msg).digest(outlen)
+
+except (TypeError, ValueError):
+
+    from ._compat import bytes_to_int, int_to_bytes
+
+    # From little endian.
+    def _from_le(s):
+        return bytes_to_int(s, byteorder="little")
+
+    # Rotate a word x by b places to the left.
+    def _rol(x, b):
+        return ((x << b) | (x >> (64 - b))) & (2**64 - 1)
+
+    # Do the SHA-3 state transform on state s.
+    def _sha3_transform(s):
+        ROTATIONS = [
+            0,
+            1,
+            62,
+            28,
+            27,
+            36,
+            44,
+            6,
+            55,
+            20,
+            3,
+            10,
+            43,
+            25,
+            39,
+            41,
+            45,
+            15,
+            21,
+            8,
+            18,
+            2,
+            61,
+            56,
+            14,
+        ]
+        PERMUTATION = [
+            1,
+            6,
+            9,
+            22,
+            14,
+            20,
+            2,
+            12,
+            13,
+            19,
+            23,
+            15,
+            4,
+            24,
+            21,
+            8,
+            16,
+            5,
+            3,
+            18,
+            17,
+            11,
+            7,
+            10,
+        ]
+        RC = [
+            0x0000000000000001,
+            0x0000000000008082,
+            0x800000000000808A,
+            0x8000000080008000,
+            0x000000000000808B,
+            0x0000000080000001,
+            0x8000000080008081,
+            0x8000000000008009,
+            0x000000000000008A,
+            0x0000000000000088,
+            0x0000000080008009,
+            0x000000008000000A,
+            0x000000008000808B,
+            0x800000000000008B,
+            0x8000000000008089,
+            0x8000000000008003,
+            0x8000000000008002,
+            0x8000000000000080,
+            0x000000000000800A,
+            0x800000008000000A,
+            0x8000000080008081,
+            0x8000000000008080,
+            0x0000000080000001,
+            0x8000000080008008,
+        ]
+
+        for rnd in range(0, 24):
+            # AddColumnParity (Theta)
+            c = [0] * 5
+            d = [0] * 5
+            for i in range(0, 25):
+                c[i % 5] ^= s[i]
+            for i in range(0, 5):
+                d[i] = c[(i + 4) % 5] ^ _rol(c[(i + 1) % 5], 1)
+            for i in range(0, 25):
+                s[i] ^= d[i % 5]
+            # RotateWords (Rho)
+            for i in range(0, 25):
+                s[i] = _rol(s[i], ROTATIONS[i])
+            # PermuteWords (Pi)
+            t = s[PERMUTATION[0]]
+            for i in range(0, len(PERMUTATION) - 1):
+                s[PERMUTATION[i]] = s[PERMUTATION[i + 1]]
+            s[PERMUTATION[-1]] = t
+            # NonlinearMixRows (Chi)
+            for i in range(0, 25, 5):
+                t = [
+                    s[i],
+                    s[i + 1],
+                    s[i + 2],
+                    s[i + 3],
+                    s[i + 4],
+                    s[i],
+                    s[i + 1],
+                ]
+                for j in range(0, 5):
+                    s[i + j] = t[j] ^ ((~t[j + 1]) & (t[j + 2]))
+            # AddRoundConstant (Iota)
+            s[0] ^= RC[rnd]
+
+    # Reinterpret octet array b to word array and XOR it to state s.
+    def _reinterpret_to_words_and_xor(s, b):
+        for j in range(0, len(b) // 8):
+            s[j] ^= _from_le(b[8 * j : 8 * j + 8])
+
+    # Reinterpret word array w to octet array and return it.
+    def _reinterpret_to_octets(w):
+        mp = bytearray()
+        for j in range(0, len(w)):
+            mp += int_to_bytes(w[j], 8, byteorder="little")
+        return mp
+
+    def _sha3_raw(msg, r_w, o_p, e_b):
+        """Semi-generic SHA-3 implementation"""
+        r_b = 8 * r_w
+        s = [0] * 25
+        # Handle whole blocks.
+        idx = 0
+        blocks = len(msg) // r_b
+        for i in range(0, blocks):
+            _reinterpret_to_words_and_xor(s, msg[idx : idx + r_b])
+            idx += r_b
+            _sha3_transform(s)
+        # Handle last block padding.
+        m = bytearray(msg[idx:])
+        m.append(o_p)
+        while len(m) < r_b:
+            m.append(0)
+        m[len(m) - 1] |= 128
+        # Handle padded last block.
+        _reinterpret_to_words_and_xor(s, m)
+        _sha3_transform(s)
+        # Output.
+        out = bytearray()
+        while len(out) < e_b:
+            out += _reinterpret_to_octets(s[:r_w])
+            _sha3_transform(s)
+        return out[:e_b]
+
+    def shake_256(msg, outlen):
+        return _sha3_raw(msg, 17, 31, outlen)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/_version.py b/myenv/lib/python3.9/site-packages/ecdsa/_version.py
new file mode 100644
index 0000000..96aae17
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/_version.py
@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.21) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2022-07-09T14:49:17+0200",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "341e0d8be9fedf66fbc9a95630b4ed2138343380",
+ "version": "0.18.0"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/curves.py b/myenv/lib/python3.9/site-packages/ecdsa/curves.py
new file mode 100644
index 0000000..1119ee5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/curves.py
@@ -0,0 +1,513 @@
+from __future__ import division
+
+from six import PY2
+from . import der, ecdsa, ellipticcurve, eddsa
+from .util import orderlen, number_to_string, string_to_number
+from ._compat import normalise_bytes, bit_length
+
+
+# orderlen was defined in this module previously, so keep it in __all__,
+# will need to mark it as deprecated later
+__all__ = [
+    "UnknownCurveError",
+    "orderlen",
+    "Curve",
+    "SECP112r1",
+    "SECP112r2",
+    "SECP128r1",
+    "SECP160r1",
+    "NIST192p",
+    "NIST224p",
+    "NIST256p",
+    "NIST384p",
+    "NIST521p",
+    "curves",
+    "find_curve",
+    "curve_by_name",
+    "SECP256k1",
+    "BRAINPOOLP160r1",
+    "BRAINPOOLP192r1",
+    "BRAINPOOLP224r1",
+    "BRAINPOOLP256r1",
+    "BRAINPOOLP320r1",
+    "BRAINPOOLP384r1",
+    "BRAINPOOLP512r1",
+    "PRIME_FIELD_OID",
+    "CHARACTERISTIC_TWO_FIELD_OID",
+    "Ed25519",
+    "Ed448",
+]
+
+
+PRIME_FIELD_OID = (1, 2, 840, 10045, 1, 1)
+CHARACTERISTIC_TWO_FIELD_OID = (1, 2, 840, 10045, 1, 2)
+
+
+class UnknownCurveError(Exception):
+    pass
+
+
+class Curve:
+    def __init__(self, name, curve, generator, oid, openssl_name=None):
+        self.name = name
+        self.openssl_name = openssl_name  # maybe None
+        self.curve = curve
+        self.generator = generator
+        self.order = generator.order()
+        if isinstance(curve, ellipticcurve.CurveEdTw):
+            # EdDSA keys are special in that both private and public
+            # are the same size (as it's defined only with compressed points)
+
+            # +1 for the sign bit and then round up
+            self.baselen = (bit_length(curve.p()) + 1 + 7) // 8
+            self.verifying_key_length = self.baselen
+        else:
+            self.baselen = orderlen(self.order)
+            self.verifying_key_length = 2 * orderlen(curve.p())
+        self.signature_length = 2 * self.baselen
+        self.oid = oid
+        if oid:
+            self.encoded_oid = der.encode_oid(*oid)
+
+    def __eq__(self, other):
+        if isinstance(other, Curve):
+            return (
+                self.curve == other.curve and self.generator == other.generator
+            )
+        return NotImplemented
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __repr__(self):
+        return self.name
+
+    def to_der(self, encoding=None, point_encoding="uncompressed"):
+        """Serialise the curve parameters to binary string.
+
+        :param str encoding: the format to save the curve parameters in.
+            Default is ``named_curve``, with fallback being the ``explicit``
+            if the OID is not set for the curve.
+        :param str point_encoding: the point encoding of the generator when
+            explicit curve encoding is used. Ignored for ``named_curve``
+            format.
+
+        :return: DER encoded ECParameters structure
+        :rtype: bytes
+        """
+        if encoding is None:
+            if self.oid:
+                encoding = "named_curve"
+            else:
+                encoding = "explicit"
+
+        if encoding not in ("named_curve", "explicit"):
+            raise ValueError(
+                "Only 'named_curve' and 'explicit' encodings supported"
+            )
+
+        if encoding == "named_curve":
+            if not self.oid:
+                raise UnknownCurveError(
+                    "Can't encode curve using named_curve encoding without "
+                    "associated curve OID"
+                )
+            return der.encode_oid(*self.oid)
+        elif isinstance(self.curve, ellipticcurve.CurveEdTw):
+            assert encoding == "explicit"
+            raise UnknownCurveError(
+                "Twisted Edwards curves don't support explicit encoding"
+            )
+
+        # encode the ECParameters sequence
+        curve_p = self.curve.p()
+        version = der.encode_integer(1)
+        field_id = der.encode_sequence(
+            der.encode_oid(*PRIME_FIELD_OID), der.encode_integer(curve_p)
+        )
+        curve = der.encode_sequence(
+            der.encode_octet_string(
+                number_to_string(self.curve.a() % curve_p, curve_p)
+            ),
+            der.encode_octet_string(
+                number_to_string(self.curve.b() % curve_p, curve_p)
+            ),
+        )
+        base = der.encode_octet_string(self.generator.to_bytes(point_encoding))
+        order = der.encode_integer(self.generator.order())
+        seq_elements = [version, field_id, curve, base, order]
+        if self.curve.cofactor():
+            cofactor = der.encode_integer(self.curve.cofactor())
+            seq_elements.append(cofactor)
+
+        return der.encode_sequence(*seq_elements)
+
+    def to_pem(self, encoding=None, point_encoding="uncompressed"):
+        """
+        Serialise the curve parameters to the :term:`PEM` format.
+
+        :param str encoding: the format to save the curve parameters in.
+            Default is ``named_curve``, with fallback being the ``explicit``
+            if the OID is not set for the curve.
+        :param str point_encoding: the point encoding of the generator when
+            explicit curve encoding is used. Ignored for ``named_curve``
+            format.
+
+        :return: PEM encoded ECParameters structure
+        :rtype: str
+        """
+        return der.topem(
+            self.to_der(encoding, point_encoding), "EC PARAMETERS"
+        )
+
+    @staticmethod
+    def from_der(data, valid_encodings=None):
+        """Decode the curve parameters from DER file.
+
+        :param data: the binary string to decode the parameters from
+        :type data: :term:`bytes-like object`
+        :param valid_encodings: set of names of allowed encodings, by default
+            all (set by passing ``None``), supported ones are ``named_curve``
+            and ``explicit``
+        :type valid_encodings: :term:`set-like object`
+        """
+        if not valid_encodings:
+            valid_encodings = set(("named_curve", "explicit"))
+        if not all(i in ["named_curve", "explicit"] for i in valid_encodings):
+            raise ValueError(
+                "Only named_curve and explicit encodings supported"
+            )
+        data = normalise_bytes(data)
+        if not der.is_sequence(data):
+            if "named_curve" not in valid_encodings:
+                raise der.UnexpectedDER(
+                    "named_curve curve parameters not allowed"
+                )
+            oid, empty = der.remove_object(data)
+            if empty:
+                raise der.UnexpectedDER("Unexpected data after OID")
+            return find_curve(oid)
+
+        if "explicit" not in valid_encodings:
+            raise der.UnexpectedDER("explicit curve parameters not allowed")
+
+        seq, empty = der.remove_sequence(data)
+        if empty:
+            raise der.UnexpectedDER(
+                "Unexpected data after ECParameters structure"
+            )
+        # decode the ECParameters sequence
+        version, rest = der.remove_integer(seq)
+        if version != 1:
+            raise der.UnexpectedDER("Unknown parameter encoding format")
+        field_id, rest = der.remove_sequence(rest)
+        curve, rest = der.remove_sequence(rest)
+        base_bytes, rest = der.remove_octet_string(rest)
+        order, rest = der.remove_integer(rest)
+        cofactor = None
+        if rest:
+            # the ASN.1 specification of ECParameters allows for future
+            # extensions of the sequence, so ignore the remaining bytes
+            cofactor, _ = der.remove_integer(rest)
+
+        # decode the ECParameters.fieldID sequence
+        field_type, rest = der.remove_object(field_id)
+        if field_type == CHARACTERISTIC_TWO_FIELD_OID:
+            raise UnknownCurveError("Characteristic 2 curves unsupported")
+        if field_type != PRIME_FIELD_OID:
+            raise UnknownCurveError(
+                "Unknown field type: {0}".format(field_type)
+            )
+        prime, empty = der.remove_integer(rest)
+        if empty:
+            raise der.UnexpectedDER(
+                "Unexpected data after ECParameters.fieldID.Prime-p element"
+            )
+
+        # decode the ECParameters.curve sequence
+        curve_a_bytes, rest = der.remove_octet_string(curve)
+        curve_b_bytes, rest = der.remove_octet_string(rest)
+        # seed can be defined here, but we don't parse it, so ignore `rest`
+
+        curve_a = string_to_number(curve_a_bytes)
+        curve_b = string_to_number(curve_b_bytes)
+
+        curve_fp = ellipticcurve.CurveFp(prime, curve_a, curve_b, cofactor)
+
+        # decode the ECParameters.base point
+
+        base = ellipticcurve.PointJacobi.from_bytes(
+            curve_fp,
+            base_bytes,
+            valid_encodings=("uncompressed", "compressed", "hybrid"),
+            order=order,
+            generator=True,
+        )
+        tmp_curve = Curve("unknown", curve_fp, base, None)
+
+        # if the curve matches one of the well-known ones, use the well-known
+        # one in preference, as it will have the OID and name associated
+        for i in curves:
+            if tmp_curve == i:
+                return i
+        return tmp_curve
+
+    @classmethod
+    def from_pem(cls, string, valid_encodings=None):
+        """Decode the curve parameters from PEM file.
+
+        :param str string: the text string to decode the parameters from
+        :param valid_encodings: set of names of allowed encodings, by default
+            all (set by passing ``None``), supported ones are ``named_curve``
+            and ``explicit``
+        :type valid_encodings: :term:`set-like object`
+        """
+        if not PY2 and isinstance(string, str):  # pragma: no branch
+            string = string.encode()
+
+        ec_param_index = string.find(b"-----BEGIN EC PARAMETERS-----")
+        if ec_param_index == -1:
+            raise der.UnexpectedDER("EC PARAMETERS PEM header not found")
+
+        return cls.from_der(
+            der.unpem(string[ec_param_index:]), valid_encodings
+        )
+
+
+# the SEC curves
+SECP112r1 = Curve(
+    "SECP112r1",
+    ecdsa.curve_112r1,
+    ecdsa.generator_112r1,
+    (1, 3, 132, 0, 6),
+    "secp112r1",
+)
+
+
+SECP112r2 = Curve(
+    "SECP112r2",
+    ecdsa.curve_112r2,
+    ecdsa.generator_112r2,
+    (1, 3, 132, 0, 7),
+    "secp112r2",
+)
+
+
+SECP128r1 = Curve(
+    "SECP128r1",
+    ecdsa.curve_128r1,
+    ecdsa.generator_128r1,
+    (1, 3, 132, 0, 28),
+    "secp128r1",
+)
+
+
+SECP160r1 = Curve(
+    "SECP160r1",
+    ecdsa.curve_160r1,
+    ecdsa.generator_160r1,
+    (1, 3, 132, 0, 8),
+    "secp160r1",
+)
+
+
+# the NIST curves
+NIST192p = Curve(
+    "NIST192p",
+    ecdsa.curve_192,
+    ecdsa.generator_192,
+    (1, 2, 840, 10045, 3, 1, 1),
+    "prime192v1",
+)
+
+
+NIST224p = Curve(
+    "NIST224p",
+    ecdsa.curve_224,
+    ecdsa.generator_224,
+    (1, 3, 132, 0, 33),
+    "secp224r1",
+)
+
+
+NIST256p = Curve(
+    "NIST256p",
+    ecdsa.curve_256,
+    ecdsa.generator_256,
+    (1, 2, 840, 10045, 3, 1, 7),
+    "prime256v1",
+)
+
+
+NIST384p = Curve(
+    "NIST384p",
+    ecdsa.curve_384,
+    ecdsa.generator_384,
+    (1, 3, 132, 0, 34),
+    "secp384r1",
+)
+
+
+NIST521p = Curve(
+    "NIST521p",
+    ecdsa.curve_521,
+    ecdsa.generator_521,
+    (1, 3, 132, 0, 35),
+    "secp521r1",
+)
+
+
+SECP256k1 = Curve(
+    "SECP256k1",
+    ecdsa.curve_secp256k1,
+    ecdsa.generator_secp256k1,
+    (1, 3, 132, 0, 10),
+    "secp256k1",
+)
+
+
+BRAINPOOLP160r1 = Curve(
+    "BRAINPOOLP160r1",
+    ecdsa.curve_brainpoolp160r1,
+    ecdsa.generator_brainpoolp160r1,
+    (1, 3, 36, 3, 3, 2, 8, 1, 1, 1),
+    "brainpoolP160r1",
+)
+
+
+BRAINPOOLP192r1 = Curve(
+    "BRAINPOOLP192r1",
+    ecdsa.curve_brainpoolp192r1,
+    ecdsa.generator_brainpoolp192r1,
+    (1, 3, 36, 3, 3, 2, 8, 1, 1, 3),
+    "brainpoolP192r1",
+)
+
+
+BRAINPOOLP224r1 = Curve(
+    "BRAINPOOLP224r1",
+    ecdsa.curve_brainpoolp224r1,
+    ecdsa.generator_brainpoolp224r1,
+    (1, 3, 36, 3, 3, 2, 8, 1, 1, 5),
+    "brainpoolP224r1",
+)
+
+
+BRAINPOOLP256r1 = Curve(
+    "BRAINPOOLP256r1",
+    ecdsa.curve_brainpoolp256r1,
+    ecdsa.generator_brainpoolp256r1,
+    (1, 3, 36, 3, 3, 2, 8, 1, 1, 7),
+    "brainpoolP256r1",
+)
+
+
+BRAINPOOLP320r1 = Curve(
+    "BRAINPOOLP320r1",
+    ecdsa.curve_brainpoolp320r1,
+    ecdsa.generator_brainpoolp320r1,
+    (1, 3, 36, 3, 3, 2, 8, 1, 1, 9),
+    "brainpoolP320r1",
+)
+
+
+BRAINPOOLP384r1 = Curve(
+    "BRAINPOOLP384r1",
+    ecdsa.curve_brainpoolp384r1,
+    ecdsa.generator_brainpoolp384r1,
+    (1, 3, 36, 3, 3, 2, 8, 1, 1, 11),
+    "brainpoolP384r1",
+)
+
+
+BRAINPOOLP512r1 = Curve(
+    "BRAINPOOLP512r1",
+    ecdsa.curve_brainpoolp512r1,
+    ecdsa.generator_brainpoolp512r1,
+    (1, 3, 36, 3, 3, 2, 8, 1, 1, 13),
+    "brainpoolP512r1",
+)
+
+
+Ed25519 = Curve(
+    "Ed25519",
+    eddsa.curve_ed25519,
+    eddsa.generator_ed25519,
+    (1, 3, 101, 112),
+)
+
+
+Ed448 = Curve(
+    "Ed448",
+    eddsa.curve_ed448,
+    eddsa.generator_ed448,
+    (1, 3, 101, 113),
+)
+
+
+# no order in particular, but keep previously added curves first
+curves = [
+    NIST192p,
+    NIST224p,
+    NIST256p,
+    NIST384p,
+    NIST521p,
+    SECP256k1,
+    BRAINPOOLP160r1,
+    BRAINPOOLP192r1,
+    BRAINPOOLP224r1,
+    BRAINPOOLP256r1,
+    BRAINPOOLP320r1,
+    BRAINPOOLP384r1,
+    BRAINPOOLP512r1,
+    SECP112r1,
+    SECP112r2,
+    SECP128r1,
+    SECP160r1,
+    Ed25519,
+    Ed448,
+]
+
+
+def find_curve(oid_curve):
+    """Select a curve based on its OID
+
+    :param tuple[int,...] oid_curve: ASN.1 Object Identifier of the
+        curve to return, like ``(1, 2, 840, 10045, 3, 1, 7)`` for ``NIST256p``.
+
+    :raises UnknownCurveError: When the oid doesn't match any of the supported
+        curves
+
+    :rtype: ~ecdsa.curves.Curve
+    """
+    for c in curves:
+        if c.oid == oid_curve:
+            return c
+    raise UnknownCurveError(
+        "I don't know about the curve with oid %s."
+        "I only know about these: %s" % (oid_curve, [c.name for c in curves])
+    )
+
+
+def curve_by_name(name):
+    """Select a curve based on its name.
+
+    Returns a :py:class:`~ecdsa.curves.Curve` object with a ``name`` name.
+    Note that ``name`` is case-sensitve.
+
+    :param str name: Name of the curve to return, like ``NIST256p`` or
+        ``prime256v1``
+
+    :raises UnknownCurveError: When the name doesn't match any of the supported
+        curves
+
+    :rtype: ~ecdsa.curves.Curve
+    """
+    for c in curves:
+        if name == c.name or (c.openssl_name and name == c.openssl_name):
+            return c
+    raise UnknownCurveError(
+        "Curve with name {0!r} unknown, only curves supported: {1}".format(
+            name, [c.name for c in curves]
+        )
+    )
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/der.py b/myenv/lib/python3.9/site-packages/ecdsa/der.py
new file mode 100644
index 0000000..8b27941
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/der.py
@@ -0,0 +1,409 @@
+from __future__ import division
+
+import binascii
+import base64
+import warnings
+from itertools import chain
+from six import int2byte, b, text_type
+from ._compat import str_idx_as_int
+
+
+class UnexpectedDER(Exception):
+    pass
+
+
+def encode_constructed(tag, value):
+    return int2byte(0xA0 + tag) + encode_length(len(value)) + value
+
+
+def encode_integer(r):
+    assert r >= 0  # can't support negative numbers yet
+    h = ("%x" % r).encode()
+    if len(h) % 2:
+        h = b("0") + h
+    s = binascii.unhexlify(h)
+    num = str_idx_as_int(s, 0)
+    if num <= 0x7F:
+        return b("\x02") + encode_length(len(s)) + s
+    else:
+        # DER integers are two's complement, so if the first byte is
+        # 0x80-0xff then we need an extra 0x00 byte to prevent it from
+        # looking negative.
+        return b("\x02") + encode_length(len(s) + 1) + b("\x00") + s
+
+
+# sentry object to check if an argument was specified (used to detect
+# deprecated calling convention)
+_sentry = object()
+
+
+def encode_bitstring(s, unused=_sentry):
+    """
+    Encode a binary string as a BIT STRING using :term:`DER` encoding.
+
+    Note, because there is no native Python object that can encode an actual
+    bit string, this function only accepts byte strings as the `s` argument.
+    The byte string is the actual bit string that will be encoded, padded
+    on the right (least significant bits, looking from big endian perspective)
+    to the first full byte. If the bit string has a bit length that is multiple
+    of 8, then the padding should not be included. For correct DER encoding
+    the padding bits MUST be set to 0.
+
+    Number of bits of padding need to be provided as the `unused` parameter.
+    In case they are specified as None, it means the number of unused bits
+    is already encoded in the string as the first byte.
+
+    The deprecated call convention specifies just the `s` parameters and
+    encodes the number of unused bits as first parameter (same convention
+    as with None).
+
+    Empty string must be encoded with `unused` specified as 0.
+
+    Future version of python-ecdsa will make specifying the `unused` argument
+    mandatory.
+
+    :param s: bytes to encode
+    :type s: bytes like object
+    :param unused: number of bits at the end of `s` that are unused, must be
+        between 0 and 7 (inclusive)
+    :type unused: int or None
+
+    :raises ValueError: when `unused` is too large or too small
+
+    :return: `s` encoded using DER
+    :rtype: bytes
+    """
+    encoded_unused = b""
+    len_extra = 0
+    if unused is _sentry:
+        warnings.warn(
+            "Legacy call convention used, unused= needs to be specified",
+            DeprecationWarning,
+        )
+    elif unused is not None:
+        if not 0 <= unused <= 7:
+            raise ValueError("unused must be integer between 0 and 7")
+        if unused:
+            if not s:
+                raise ValueError("unused is non-zero but s is empty")
+            last = str_idx_as_int(s, -1)
+            if last & (2**unused - 1):
+                raise ValueError("unused bits must be zeros in DER")
+        encoded_unused = int2byte(unused)
+        len_extra = 1
+    return b("\x03") + encode_length(len(s) + len_extra) + encoded_unused + s
+
+
+def encode_octet_string(s):
+    return b("\x04") + encode_length(len(s)) + s
+
+
+def encode_oid(first, second, *pieces):
+    assert 0 <= first < 2 and 0 <= second <= 39 or first == 2 and 0 <= second
+    body = b"".join(
+        chain(
+            [encode_number(40 * first + second)],
+            (encode_number(p) for p in pieces),
+        )
+    )
+    return b"\x06" + encode_length(len(body)) + body
+
+
+def encode_sequence(*encoded_pieces):
+    total_len = sum([len(p) for p in encoded_pieces])
+    return b("\x30") + encode_length(total_len) + b("").join(encoded_pieces)
+
+
+def encode_number(n):
+    b128_digits = []
+    while n:
+        b128_digits.insert(0, (n & 0x7F) | 0x80)
+        n = n >> 7
+    if not b128_digits:
+        b128_digits.append(0)
+    b128_digits[-1] &= 0x7F
+    return b("").join([int2byte(d) for d in b128_digits])
+
+
+def is_sequence(string):
+    return string and string[:1] == b"\x30"
+
+
+def remove_constructed(string):
+    s0 = str_idx_as_int(string, 0)
+    if (s0 & 0xE0) != 0xA0:
+        raise UnexpectedDER(
+            "wanted type 'constructed tag' (0xa0-0xbf), got 0x%02x" % s0
+        )
+    tag = s0 & 0x1F
+    length, llen = read_length(string[1:])
+    body = string[1 + llen : 1 + llen + length]
+    rest = string[1 + llen + length :]
+    return tag, body, rest
+
+
+def remove_sequence(string):
+    if not string:
+        raise UnexpectedDER("Empty string does not encode a sequence")
+    if string[:1] != b"\x30":
+        n = str_idx_as_int(string, 0)
+        raise UnexpectedDER("wanted type 'sequence' (0x30), got 0x%02x" % n)
+    length, lengthlength = read_length(string[1:])
+    if length > len(string) - 1 - lengthlength:
+        raise UnexpectedDER("Length longer than the provided buffer")
+    endseq = 1 + lengthlength + length
+    return string[1 + lengthlength : endseq], string[endseq:]
+
+
+def remove_octet_string(string):
+    if string[:1] != b"\x04":
+        n = str_idx_as_int(string, 0)
+        raise UnexpectedDER("wanted type 'octetstring' (0x04), got 0x%02x" % n)
+    length, llen = read_length(string[1:])
+    body = string[1 + llen : 1 + llen + length]
+    rest = string[1 + llen + length :]
+    return body, rest
+
+
+def remove_object(string):
+    if not string:
+        raise UnexpectedDER(
+            "Empty string does not encode an object identifier"
+        )
+    if string[:1] != b"\x06":
+        n = str_idx_as_int(string, 0)
+        raise UnexpectedDER("wanted type 'object' (0x06), got 0x%02x" % n)
+    length, lengthlength = read_length(string[1:])
+    body = string[1 + lengthlength : 1 + lengthlength + length]
+    rest = string[1 + lengthlength + length :]
+    if not body:
+        raise UnexpectedDER("Empty object identifier")
+    if len(body) != length:
+        raise UnexpectedDER(
+            "Length of object identifier longer than the provided buffer"
+        )
+    numbers = []
+    while body:
+        n, ll = read_number(body)
+        numbers.append(n)
+        body = body[ll:]
+    n0 = numbers.pop(0)
+    if n0 < 80:
+        first = n0 // 40
+    else:
+        first = 2
+    second = n0 - (40 * first)
+    numbers.insert(0, first)
+    numbers.insert(1, second)
+    return tuple(numbers), rest
+
+
+def remove_integer(string):
+    if not string:
+        raise UnexpectedDER(
+            "Empty string is an invalid encoding of an integer"
+        )
+    if string[:1] != b"\x02":
+        n = str_idx_as_int(string, 0)
+        raise UnexpectedDER("wanted type 'integer' (0x02), got 0x%02x" % n)
+    length, llen = read_length(string[1:])
+    if length > len(string) - 1 - llen:
+        raise UnexpectedDER("Length longer than provided buffer")
+    if length == 0:
+        raise UnexpectedDER("0-byte long encoding of integer")
+    numberbytes = string[1 + llen : 1 + llen + length]
+    rest = string[1 + llen + length :]
+    msb = str_idx_as_int(numberbytes, 0)
+    if not msb < 0x80:
+        raise UnexpectedDER("Negative integers are not supported")
+    # check if the encoding is the minimal one (DER requirement)
+    if length > 1 and not msb:
+        # leading zero byte is allowed if the integer would have been
+        # considered a negative number otherwise
+        smsb = str_idx_as_int(numberbytes, 1)
+        if smsb < 0x80:
+            raise UnexpectedDER(
+                "Invalid encoding of integer, unnecessary "
+                "zero padding bytes"
+            )
+    return int(binascii.hexlify(numberbytes), 16), rest
+
+
+def read_number(string):
+    number = 0
+    llen = 0
+    if str_idx_as_int(string, 0) == 0x80:
+        raise UnexpectedDER("Non minimal encoding of OID subidentifier")
+    # base-128 big endian, with most significant bit set in all but the last
+    # byte
+    while True:
+        if llen >= len(string):
+            raise UnexpectedDER("ran out of length bytes")
+        number = number << 7
+        d = str_idx_as_int(string, llen)
+        number += d & 0x7F
+        llen += 1
+        if not d & 0x80:
+            break
+    return number, llen
+
+
+def encode_length(l):
+    assert l >= 0
+    if l < 0x80:
+        return int2byte(l)
+    s = ("%x" % l).encode()
+    if len(s) % 2:
+        s = b("0") + s
+    s = binascii.unhexlify(s)
+    llen = len(s)
+    return int2byte(0x80 | llen) + s
+
+
+def read_length(string):
+    if not string:
+        raise UnexpectedDER("Empty string can't encode valid length value")
+    num = str_idx_as_int(string, 0)
+    if not (num & 0x80):
+        # short form
+        return (num & 0x7F), 1
+    # else long-form: b0&0x7f is number of additional base256 length bytes,
+    # big-endian
+    llen = num & 0x7F
+    if not llen:
+        raise UnexpectedDER("Invalid length encoding, length of length is 0")
+    if llen > len(string) - 1:
+        raise UnexpectedDER("Length of length longer than provided buffer")
+    # verify that the encoding is minimal possible (DER requirement)
+    msb = str_idx_as_int(string, 1)
+    if not msb or llen == 1 and msb < 0x80:
+        raise UnexpectedDER("Not minimal encoding of length")
+    return int(binascii.hexlify(string[1 : 1 + llen]), 16), 1 + llen
+
+
+def remove_bitstring(string, expect_unused=_sentry):
+    """
+    Remove a BIT STRING object from `string` following :term:`DER`.
+
+    The `expect_unused` can be used to specify if the bit string should
+    have the amount of unused bits decoded or not. If it's an integer, any
+    read BIT STRING that has number of unused bits different from specified
+    value will cause UnexpectedDER exception to be raised (this is especially
+    useful when decoding BIT STRINGS that have DER encoded object in them;
+    DER encoding is byte oriented, so the unused bits will always equal 0).
+
+    If the `expect_unused` is specified as None, the first element returned
+    will be a tuple, with the first value being the extracted bit string
+    while the second value will be the decoded number of unused bits.
+
+    If the `expect_unused` is unspecified, the decoding of byte with
+    number of unused bits will not be attempted and the bit string will be
+    returned as-is, the callee will be required to decode it and verify its
+    correctness.
+
+    Future version of python will require the `expected_unused` parameter
+    to be specified.
+
+    :param string: string of bytes to extract the BIT STRING from
+    :type string: bytes like object
+    :param expect_unused: number of bits that should be unused in the BIT
+        STRING, or None, to return it to caller
+    :type expect_unused: int or None
+
+    :raises UnexpectedDER: when the encoding does not follow DER.
+
+    :return: a tuple with first element being the extracted bit string and
+        the second being the remaining bytes in the string (if any); if the
+        `expect_unused` is specified as None, the first element of the returned
+        tuple will be a tuple itself, with first element being the bit string
+        as bytes and the second element being the number of unused bits at the
+        end of the byte array as an integer
+    :rtype: tuple
+    """
+    if not string:
+        raise UnexpectedDER("Empty string does not encode a bitstring")
+    if expect_unused is _sentry:
+        warnings.warn(
+            "Legacy call convention used, expect_unused= needs to be"
+            " specified",
+            DeprecationWarning,
+        )
+    num = str_idx_as_int(string, 0)
+    if string[:1] != b"\x03":
+        raise UnexpectedDER("wanted bitstring (0x03), got 0x%02x" % num)
+    length, llen = read_length(string[1:])
+    if not length:
+        raise UnexpectedDER("Invalid length of bit string, can't be 0")
+    body = string[1 + llen : 1 + llen + length]
+    rest = string[1 + llen + length :]
+    if expect_unused is not _sentry:
+        unused = str_idx_as_int(body, 0)
+        if not 0 <= unused <= 7:
+            raise UnexpectedDER("Invalid encoding of unused bits")
+        if expect_unused is not None and expect_unused != unused:
+            raise UnexpectedDER("Unexpected number of unused bits")
+        body = body[1:]
+        if unused:
+            if not body:
+                raise UnexpectedDER("Invalid encoding of empty bit string")
+            last = str_idx_as_int(body, -1)
+            # verify that all the unused bits are set to zero (DER requirement)
+            if last & (2**unused - 1):
+                raise UnexpectedDER("Non zero padding bits in bit string")
+        if expect_unused is None:
+            body = (body, unused)
+    return body, rest
+
+
+# SEQUENCE([1, STRING(secexp), cont[0], OBJECT(curvename), cont[1], BINTSTRING)
+
+
+# signatures: (from RFC3279)
+#  ansi-X9-62  OBJECT IDENTIFIER ::= {
+#       iso(1) member-body(2) us(840) 10045 }
+#
+#  id-ecSigType OBJECT IDENTIFIER  ::=  {
+#       ansi-X9-62 signatures(4) }
+#  ecdsa-with-SHA1  OBJECT IDENTIFIER ::= {
+#       id-ecSigType 1 }
+# so 1,2,840,10045,4,1
+# so 0x42, .. ..
+
+#  Ecdsa-Sig-Value  ::=  SEQUENCE  {
+#       r     INTEGER,
+#       s     INTEGER  }
+
+# id-public-key-type OBJECT IDENTIFIER  ::= { ansi-X9.62 2 }
+#
+# id-ecPublicKey OBJECT IDENTIFIER ::= { id-publicKeyType 1 }
+
+# I think the secp224r1 identifier is (t=06,l=05,v=2b81040021)
+#  secp224r1 OBJECT IDENTIFIER ::= {
+#  iso(1) identified-organization(3) certicom(132) curve(0) 33 }
+# and the secp384r1 is (t=06,l=05,v=2b81040022)
+#  secp384r1 OBJECT IDENTIFIER ::= {
+#  iso(1) identified-organization(3) certicom(132) curve(0) 34 }
+
+
+def unpem(pem):
+    if isinstance(pem, text_type):  # pragma: no branch
+        pem = pem.encode()
+
+    d = b("").join(
+        [
+            l.strip()
+            for l in pem.split(b("\n"))
+            if l and not l.startswith(b("-----"))
+        ]
+    )
+    return base64.b64decode(d)
+
+
+def topem(der, name):
+    b64 = base64.b64encode(der)
+    lines = [("-----BEGIN %s-----\n" % name).encode()]
+    lines.extend(
+        [b64[start : start + 64] + b("\n") for start in range(0, len(b64), 64)]
+    )
+    lines.append(("-----END %s-----\n" % name).encode())
+    return b("").join(lines)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/ecdh.py b/myenv/lib/python3.9/site-packages/ecdsa/ecdh.py
new file mode 100644
index 0000000..7f697d9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/ecdh.py
@@ -0,0 +1,336 @@
+"""
+Class for performing Elliptic-curve Diffie-Hellman (ECDH) operations.
+"""
+
+from .util import number_to_string
+from .ellipticcurve import INFINITY
+from .keys import SigningKey, VerifyingKey
+
+
+__all__ = [
+    "ECDH",
+    "NoKeyError",
+    "NoCurveError",
+    "InvalidCurveError",
+    "InvalidSharedSecretError",
+]
+
+
+class NoKeyError(Exception):
+    """ECDH. Key not found but it is needed for operation."""
+
+    pass
+
+
+class NoCurveError(Exception):
+    """ECDH. Curve not set but it is needed for operation."""
+
+    pass
+
+
+class InvalidCurveError(Exception):
+    """
+    ECDH. Raised in case the public and private keys use different curves.
+    """
+
+    pass
+
+
+class InvalidSharedSecretError(Exception):
+    """ECDH. Raised in case the shared secret we obtained is an INFINITY."""
+
+    pass
+
+
+class ECDH(object):
+    """
+    Elliptic-curve Diffie-Hellman (ECDH). A key agreement protocol.
+
+    Allows two parties, each having an elliptic-curve public-private key
+    pair, to establish a shared secret over an insecure channel
+    """
+
+    def __init__(self, curve=None, private_key=None, public_key=None):
+        """
+        ECDH init.
+
+        Call can be initialised without parameters, then the first operation
+        (loading either key) will set the used curve.
+        All parameters must be ultimately set before shared secret
+        calculation will be allowed.
+
+        :param curve: curve for operations
+        :type curve: Curve
+        :param private_key: `my` private key for ECDH
+        :type private_key: SigningKey
+        :param public_key:  `their` public key for ECDH
+        :type public_key: VerifyingKey
+        """
+        self.curve = curve
+        self.private_key = None
+        self.public_key = None
+        if private_key:
+            self.load_private_key(private_key)
+        if public_key:
+            self.load_received_public_key(public_key)
+
+    def _get_shared_secret(self, remote_public_key):
+        if not self.private_key:
+            raise NoKeyError(
+                "Private key needs to be set to create shared secret"
+            )
+        if not self.public_key:
+            raise NoKeyError(
+                "Public key needs to be set to create shared secret"
+            )
+        if not (
+            self.private_key.curve == self.curve == remote_public_key.curve
+        ):
+            raise InvalidCurveError(
+                "Curves for public key and private key is not equal."
+            )
+
+        # shared secret = PUBKEYtheirs * PRIVATEKEYours
+        result = (
+            remote_public_key.pubkey.point
+            * self.private_key.privkey.secret_multiplier
+        )
+        if result == INFINITY:
+            raise InvalidSharedSecretError("Invalid shared secret (INFINITY).")
+
+        return result.x()
+
+    def set_curve(self, key_curve):
+        """
+        Set the working curve for ecdh operations.
+
+        :param key_curve: curve from `curves` module
+        :type key_curve: Curve
+        """
+        self.curve = key_curve
+
+    def generate_private_key(self):
+        """
+        Generate local private key for ecdh operation with curve that was set.
+
+        :raises NoCurveError: Curve must be set before key generation.
+
+        :return: public (verifying) key from this private key.
+        :rtype: VerifyingKey
+        """
+        if not self.curve:
+            raise NoCurveError("Curve must be set prior to key generation.")
+        return self.load_private_key(SigningKey.generate(curve=self.curve))
+
+    def load_private_key(self, private_key):
+        """
+        Load private key from SigningKey (keys.py) object.
+
+        Needs to have the same curve as was set with set_curve method.
+        If curve is not set - it sets from this SigningKey
+
+        :param private_key: Initialised SigningKey class
+        :type private_key: SigningKey
+
+        :raises InvalidCurveError: private_key curve not the same as self.curve
+
+        :return: public (verifying) key from this private key.
+        :rtype: VerifyingKey
+        """
+        if not self.curve:
+            self.curve = private_key.curve
+        if self.curve != private_key.curve:
+            raise InvalidCurveError("Curve mismatch.")
+        self.private_key = private_key
+        return self.private_key.get_verifying_key()
+
+    def load_private_key_bytes(self, private_key):
+        """
+        Load private key from byte string.
+
+        Uses current curve and checks if the provided key matches
+        the curve of ECDH key agreement.
+        Key loads via from_string method of SigningKey class
+
+        :param private_key: private key in bytes string format
+        :type private_key: :term:`bytes-like object`
+
+        :raises NoCurveError: Curve must be set before loading.
+
+        :return: public (verifying) key from this private key.
+        :rtype: VerifyingKey
+        """
+        if not self.curve:
+            raise NoCurveError("Curve must be set prior to key load.")
+        return self.load_private_key(
+            SigningKey.from_string(private_key, curve=self.curve)
+        )
+
+    def load_private_key_der(self, private_key_der):
+        """
+        Load private key from DER byte string.
+
+        Compares the curve of the DER-encoded key with the ECDH set curve,
+        uses the former if unset.
+
+        Note, the only DER format supported is the RFC5915
+        Look at keys.py:SigningKey.from_der()
+
+        :param private_key_der: string with the DER encoding of private ECDSA
+            key
+        :type private_key_der: string
+
+        :raises InvalidCurveError: private_key curve not the same as self.curve
+
+        :return: public (verifying) key from this private key.
+        :rtype: VerifyingKey
+        """
+        return self.load_private_key(SigningKey.from_der(private_key_der))
+
+    def load_private_key_pem(self, private_key_pem):
+        """
+        Load private key from PEM string.
+
+        Compares the curve of the DER-encoded key with the ECDH set curve,
+        uses the former if unset.
+
+        Note, the only PEM format supported is the RFC5915
+        Look at keys.py:SigningKey.from_pem()
+        it needs to have `EC PRIVATE KEY` section
+
+        :param private_key_pem: string with PEM-encoded private ECDSA key
+        :type private_key_pem: string
+
+        :raises InvalidCurveError: private_key curve not the same as self.curve
+
+        :return: public (verifying) key from this private key.
+        :rtype: VerifyingKey
+        """
+        return self.load_private_key(SigningKey.from_pem(private_key_pem))
+
+    def get_public_key(self):
+        """
+        Provides a public key that matches the local private key.
+
+        Needs to be sent to the remote party.
+
+        :return: public (verifying) key from local private key.
+        :rtype: VerifyingKey
+        """
+        return self.private_key.get_verifying_key()
+
+    def load_received_public_key(self, public_key):
+        """
+        Load public key from VerifyingKey (keys.py) object.
+
+        Needs to have the same curve as set as current for ecdh operation.
+        If curve is not set - it sets it from VerifyingKey.
+
+        :param public_key: Initialised VerifyingKey class
+        :type public_key: VerifyingKey
+
+        :raises InvalidCurveError: public_key curve not the same as self.curve
+        """
+        if not self.curve:
+            self.curve = public_key.curve
+        if self.curve != public_key.curve:
+            raise InvalidCurveError("Curve mismatch.")
+        self.public_key = public_key
+
+    def load_received_public_key_bytes(
+        self, public_key_str, valid_encodings=None
+    ):
+        """
+        Load public key from byte string.
+
+        Uses current curve and checks if key length corresponds to
+        the current curve.
+        Key loads via from_string method of VerifyingKey class
+
+        :param public_key_str: public key in bytes string format
+        :type public_key_str: :term:`bytes-like object`
+        :param valid_encodings: list of acceptable point encoding formats,
+            supported ones are: :term:`uncompressed`, :term:`compressed`,
+            :term:`hybrid`, and :term:`raw encoding` (specified with ``raw``
+            name). All formats by default (specified with ``None``).
+        :type valid_encodings: :term:`set-like object`
+        """
+        return self.load_received_public_key(
+            VerifyingKey.from_string(
+                public_key_str, self.curve, valid_encodings
+            )
+        )
+
+    def load_received_public_key_der(self, public_key_der):
+        """
+        Load public key from DER byte string.
+
+        Compares the curve of the DER-encoded key with the ECDH set curve,
+        uses the former if unset.
+
+        Note, the only DER format supported is the RFC5912
+        Look at keys.py:VerifyingKey.from_der()
+
+        :param public_key_der: string with the DER encoding of public ECDSA key
+        :type public_key_der: string
+
+        :raises InvalidCurveError: public_key curve not the same as self.curve
+        """
+        return self.load_received_public_key(
+            VerifyingKey.from_der(public_key_der)
+        )
+
+    def load_received_public_key_pem(self, public_key_pem):
+        """
+        Load public key from PEM string.
+
+        Compares the curve of the PEM-encoded key with the ECDH set curve,
+        uses the former if unset.
+
+        Note, the only PEM format supported is the RFC5912
+        Look at keys.py:VerifyingKey.from_pem()
+
+        :param public_key_pem: string with PEM-encoded public ECDSA key
+        :type public_key_pem: string
+
+        :raises InvalidCurveError: public_key curve not the same as self.curve
+        """
+        return self.load_received_public_key(
+            VerifyingKey.from_pem(public_key_pem)
+        )
+
+    def generate_sharedsecret_bytes(self):
+        """
+        Generate shared secret from local private key and remote public key.
+
+        The objects needs to have both private key and received public key
+        before generation is allowed.
+
+        :raises InvalidCurveError: public_key curve not the same as self.curve
+        :raises NoKeyError: public_key or private_key is not set
+
+        :return: shared secret
+        :rtype: bytes
+        """
+        return number_to_string(
+            self.generate_sharedsecret(), self.private_key.curve.curve.p()
+        )
+
+    def generate_sharedsecret(self):
+        """
+        Generate shared secret from local private key and remote public key.
+
+        The objects needs to have both private key and received public key
+        before generation is allowed.
+
+        It's the same for local and remote party,
+        shared secret(local private key, remote public key) ==
+        shared secret(local public key, remote private key)
+
+        :raises InvalidCurveError: public_key curve not the same as self.curve
+        :raises NoKeyError: public_key or private_key is not set
+
+        :return: shared secret
+        :rtype: int
+        """
+        return self._get_shared_secret(self.public_key)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/ecdsa.py b/myenv/lib/python3.9/site-packages/ecdsa/ecdsa.py
new file mode 100644
index 0000000..3328281
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/ecdsa.py
@@ -0,0 +1,859 @@
+#! /usr/bin/env python
+
+"""
+Low level implementation of Elliptic-Curve Digital Signatures.
+
+.. note ::
+    You're most likely looking for the :py:class:`~ecdsa.keys` module.
+    This is a low-level implementation of the ECDSA that operates on
+    integers, not byte strings.
+
+NOTE: This a low level implementation of ECDSA, for normal applications
+you should be looking at the keys.py module.
+
+Classes and methods for elliptic-curve signatures:
+private keys, public keys, signatures,
+and definitions of prime-modulus curves.
+
+Example:
+
+.. code-block:: python
+
+   # (In real-life applications, you would probably want to
+   # protect against defects in SystemRandom.)
+   from random import SystemRandom
+   randrange = SystemRandom().randrange
+
+   # Generate a public/private key pair using the NIST Curve P-192:
+
+   g = generator_192
+   n = g.order()
+   secret = randrange( 1, n )
+   pubkey = Public_key( g, g * secret )
+   privkey = Private_key( pubkey, secret )
+
+   # Signing a hash value:
+
+   hash = randrange( 1, n )
+   signature = privkey.sign( hash, randrange( 1, n ) )
+
+   # Verifying a signature for a hash value:
+
+   if pubkey.verifies( hash, signature ):
+     print_("Demo verification succeeded.")
+   else:
+     print_("*** Demo verification failed.")
+
+   # Verification fails if the hash value is modified:
+
+   if pubkey.verifies( hash-1, signature ):
+     print_("**** Demo verification failed to reject tampered hash.")
+   else:
+     print_("Demo verification correctly rejected tampered hash.")
+
+Revision history:
+      2005.12.31 - Initial version.
+
+      2008.11.25 - Substantial revisions introducing new classes.
+
+      2009.05.16 - Warn against using random.randrange in real applications.
+
+      2009.05.17 - Use random.SystemRandom by default.
+
+Originally written in 2005 by Peter Pearson and placed in the public domain,
+modified as part of the python-ecdsa package.
+"""
+
+from six import int2byte, b
+from . import ellipticcurve
+from . import numbertheory
+from .util import bit_length
+from ._compat import remove_whitespace
+
+
+class RSZeroError(RuntimeError):
+    pass
+
+
+class InvalidPointError(RuntimeError):
+    pass
+
+
+class Signature(object):
+    """
+    ECDSA signature.
+
+    :ivar int r: the ``r`` element of the ECDSA signature
+    :ivar int s: the ``s`` element of the ECDSA signature
+    """
+
+    def __init__(self, r, s):
+        self.r = r
+        self.s = s
+
+    def recover_public_keys(self, hash, generator):
+        """
+        Returns two public keys for which the signature is valid
+
+        :param int hash: signed hash
+        :param AbstractPoint generator: is the generator used in creation
+            of the signature
+        :rtype: tuple(Public_key, Public_key)
+        :return: a pair of public keys that can validate the signature
+        """
+        curve = generator.curve()
+        n = generator.order()
+        r = self.r
+        s = self.s
+        e = hash
+        x = r
+
+        # Compute the curve point with x as x-coordinate
+        alpha = (
+            pow(x, 3, curve.p()) + (curve.a() * x) + curve.b()
+        ) % curve.p()
+        beta = numbertheory.square_root_mod_prime(alpha, curve.p())
+        y = beta if beta % 2 == 0 else curve.p() - beta
+
+        # Compute the public key
+        R1 = ellipticcurve.PointJacobi(curve, x, y, 1, n)
+        Q1 = numbertheory.inverse_mod(r, n) * (s * R1 + (-e % n) * generator)
+        Pk1 = Public_key(generator, Q1)
+
+        # And the second solution
+        R2 = ellipticcurve.PointJacobi(curve, x, -y, 1, n)
+        Q2 = numbertheory.inverse_mod(r, n) * (s * R2 + (-e % n) * generator)
+        Pk2 = Public_key(generator, Q2)
+
+        return [Pk1, Pk2]
+
+
+class Public_key(object):
+    """Public key for ECDSA."""
+
+    def __init__(self, generator, point, verify=True):
+        """Low level ECDSA public key object.
+
+        :param generator: the Point that generates the group (the base point)
+        :param point: the Point that defines the public key
+        :param bool verify: if True check if point is valid point on curve
+
+        :raises InvalidPointError: if the point parameters are invalid or
+            point does not lay on the curve
+        """
+
+        self.curve = generator.curve()
+        self.generator = generator
+        self.point = point
+        n = generator.order()
+        p = self.curve.p()
+        if not (0 <= point.x() < p) or not (0 <= point.y() < p):
+            raise InvalidPointError(
+                "The public point has x or y out of range."
+            )
+        if verify and not self.curve.contains_point(point.x(), point.y()):
+            raise InvalidPointError("Point does not lay on the curve")
+        if not n:
+            raise InvalidPointError("Generator point must have order.")
+        # for curve parameters with base point with cofactor 1, all points
+        # that are on the curve are scalar multiples of the base point, so
+        # verifying that is not necessary. See Section 3.2.2.1 of SEC 1 v2
+        if (
+            verify
+            and self.curve.cofactor() != 1
+            and not n * point == ellipticcurve.INFINITY
+        ):
+            raise InvalidPointError("Generator point order is bad.")
+
+    def __eq__(self, other):
+        """Return True if the keys are identical, False otherwise.
+
+        Note: for comparison, only placement on the same curve and point
+        equality is considered, use of the same generator point is not
+        considered.
+        """
+        if isinstance(other, Public_key):
+            return self.curve == other.curve and self.point == other.point
+        return NotImplemented
+
+    def __ne__(self, other):
+        """Return False if the keys are identical, True otherwise."""
+        return not self == other
+
+    def verifies(self, hash, signature):
+        """Verify that signature is a valid signature of hash.
+        Return True if the signature is valid.
+        """
+
+        # From X9.62 J.3.1.
+
+        G = self.generator
+        n = G.order()
+        r = signature.r
+        s = signature.s
+        if r < 1 or r > n - 1:
+            return False
+        if s < 1 or s > n - 1:
+            return False
+        c = numbertheory.inverse_mod(s, n)
+        u1 = (hash * c) % n
+        u2 = (r * c) % n
+        if hasattr(G, "mul_add"):
+            xy = G.mul_add(u1, self.point, u2)
+        else:
+            xy = u1 * G + u2 * self.point
+        v = xy.x() % n
+        return v == r
+
+
+class Private_key(object):
+    """Private key for ECDSA."""
+
+    def __init__(self, public_key, secret_multiplier):
+        """public_key is of class Public_key;
+        secret_multiplier is a large integer.
+        """
+
+        self.public_key = public_key
+        self.secret_multiplier = secret_multiplier
+
+    def __eq__(self, other):
+        """Return True if the points are identical, False otherwise."""
+        if isinstance(other, Private_key):
+            return (
+                self.public_key == other.public_key
+                and self.secret_multiplier == other.secret_multiplier
+            )
+        return NotImplemented
+
+    def __ne__(self, other):
+        """Return False if the points are identical, True otherwise."""
+        return not self == other
+
+    def sign(self, hash, random_k):
+        """Return a signature for the provided hash, using the provided
+        random nonce.  It is absolutely vital that random_k be an unpredictable
+        number in the range [1, self.public_key.point.order()-1].  If
+        an attacker can guess random_k, he can compute our private key from a
+        single signature.  Also, if an attacker knows a few high-order
+        bits (or a few low-order bits) of random_k, he can compute our private
+        key from many signatures.  The generation of nonces with adequate
+        cryptographic strength is very difficult and far beyond the scope
+        of this comment.
+
+        May raise RuntimeError, in which case retrying with a new
+        random value k is in order.
+        """
+
+        G = self.public_key.generator
+        n = G.order()
+        k = random_k % n
+        # Fix the bit-length of the random nonce,
+        # so that it doesn't leak via timing.
+        # This does not change that ks = k mod n
+        ks = k + n
+        kt = ks + n
+        if bit_length(ks) == bit_length(n):
+            p1 = kt * G
+        else:
+            p1 = ks * G
+        r = p1.x() % n
+        if r == 0:
+            raise RSZeroError("amazingly unlucky random number r")
+        s = (
+            numbertheory.inverse_mod(k, n)
+            * (hash + (self.secret_multiplier * r) % n)
+        ) % n
+        if s == 0:
+            raise RSZeroError("amazingly unlucky random number s")
+        return Signature(r, s)
+
+
+def int_to_string(x):
+    """Convert integer x into a string of bytes, as per X9.62."""
+    assert x >= 0
+    if x == 0:
+        return b("\0")
+    result = []
+    while x:
+        ordinal = x & 0xFF
+        result.append(int2byte(ordinal))
+        x >>= 8
+
+    result.reverse()
+    return b("").join(result)
+
+
+def string_to_int(s):
+    """Convert a string of bytes into an integer, as per X9.62."""
+    result = 0
+    for c in s:
+        if not isinstance(c, int):
+            c = ord(c)
+        result = 256 * result + c
+    return result
+
+
+def digest_integer(m):
+    """Convert an integer into a string of bytes, compute
+    its SHA-1 hash, and convert the result to an integer."""
+    #
+    # I don't expect this function to be used much. I wrote
+    # it in order to be able to duplicate the examples
+    # in ECDSAVS.
+    #
+    from hashlib import sha1
+
+    return string_to_int(sha1(int_to_string(m)).digest())
+
+
+def point_is_valid(generator, x, y):
+    """Is (x,y) a valid public key based on the specified generator?"""
+
+    # These are the tests specified in X9.62.
+
+    n = generator.order()
+    curve = generator.curve()
+    p = curve.p()
+    if not (0 <= x < p) or not (0 <= y < p):
+        return False
+    if not curve.contains_point(x, y):
+        return False
+    if (
+        curve.cofactor() != 1
+        and not n * ellipticcurve.PointJacobi(curve, x, y, 1)
+        == ellipticcurve.INFINITY
+    ):
+        return False
+    return True
+
+
+# secp112r1 curve
+_p = int(remove_whitespace("DB7C 2ABF62E3 5E668076 BEAD208B"), 16)
+# s = 00F50B02 8E4D696E 67687561 51752904 72783FB1
+_a = int(remove_whitespace("DB7C 2ABF62E3 5E668076 BEAD2088"), 16)
+_b = int(remove_whitespace("659E F8BA0439 16EEDE89 11702B22"), 16)
+_Gx = int(remove_whitespace("09487239 995A5EE7 6B55F9C2 F098"), 16)
+_Gy = int(remove_whitespace("A89C E5AF8724 C0A23E0E 0FF77500"), 16)
+_r = int(remove_whitespace("DB7C 2ABF62E3 5E7628DF AC6561C5"), 16)
+_h = 1
+curve_112r1 = ellipticcurve.CurveFp(_p, _a, _b, _h)
+generator_112r1 = ellipticcurve.PointJacobi(
+    curve_112r1, _Gx, _Gy, 1, _r, generator=True
+)
+
+
+# secp112r2 curve
+_p = int(remove_whitespace("DB7C 2ABF62E3 5E668076 BEAD208B"), 16)
+# s = 022757A1 114D69E 67687561 51755316 C05E0BD4
+_a = int(remove_whitespace("6127 C24C05F3 8A0AAAF6 5C0EF02C"), 16)
+_b = int(remove_whitespace("51DE F1815DB5 ED74FCC3 4C85D709"), 16)
+_Gx = int(remove_whitespace("4BA30AB5 E892B4E1 649DD092 8643"), 16)
+_Gy = int(remove_whitespace("ADCD 46F5882E 3747DEF3 6E956E97"), 16)
+_r = int(remove_whitespace("36DF 0AAFD8B8 D7597CA1 0520D04B"), 16)
+_h = 4
+curve_112r2 = ellipticcurve.CurveFp(_p, _a, _b, _h)
+generator_112r2 = ellipticcurve.PointJacobi(
+    curve_112r2, _Gx, _Gy, 1, _r, generator=True
+)
+
+
+# secp128r1 curve
+_p = int(remove_whitespace("FFFFFFFD FFFFFFFF FFFFFFFF FFFFFFFF"), 16)
+# S = 000E0D4D 69E6768 75615175 0CC03A44 73D03679
+# a and b are mod p, so a is equal to p-3, or simply -3
+# _a = -3
+_b = int(remove_whitespace("E87579C1 1079F43D D824993C 2CEE5ED3"), 16)
+_Gx = int(remove_whitespace("161FF752 8B899B2D 0C28607C A52C5B86"), 16)
+_Gy = int(remove_whitespace("CF5AC839 5BAFEB13 C02DA292 DDED7A83"), 16)
+_r = int(remove_whitespace("FFFFFFFE 00000000 75A30D1B 9038A115"), 16)
+_h = 1
+curve_128r1 = ellipticcurve.CurveFp(_p, -3, _b, _h)
+generator_128r1 = ellipticcurve.PointJacobi(
+    curve_128r1, _Gx, _Gy, 1, _r, generator=True
+)
+
+
+# secp160r1
+_p = int(remove_whitespace("FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF 7FFFFFFF"), 16)
+# S = 1053CDE4 2C14D696 E6768756 1517533B F3F83345
+# a and b are mod p, so a is equal to p-3, or simply -3
+# _a = -3
+_b = int(remove_whitespace("1C97BEFC 54BD7A8B 65ACF89F 81D4D4AD C565FA45"), 16)
+_Gx = int(
+    remove_whitespace("4A96B568 8EF57328 46646989 68C38BB9 13CBFC82"),
+    16,
+)
+_Gy = int(
+    remove_whitespace("23A62855 3168947D 59DCC912 04235137 7AC5FB32"),
+    16,
+)
+_r = int(
+    remove_whitespace("01 00000000 00000000 0001F4C8 F927AED3 CA752257"),
+    16,
+)
+_h = 1
+curve_160r1 = ellipticcurve.CurveFp(_p, -3, _b, _h)
+generator_160r1 = ellipticcurve.PointJacobi(
+    curve_160r1, _Gx, _Gy, 1, _r, generator=True
+)
+
+
+# NIST Curve P-192:
+_p = 6277101735386680763835789423207666416083908700390324961279
+_r = 6277101735386680763835789423176059013767194773182842284081
+# s = 0x3045ae6fc8422f64ed579528d38120eae12196d5L
+# c = 0x3099d2bbbfcb2538542dcd5fb078b6ef5f3d6fe2c745de65L
+_b = int(
+    remove_whitespace(
+        """
+    64210519 E59C80E7 0FA7E9AB 72243049 FEB8DEEC C146B9B1"""
+    ),
+    16,
+)
+_Gx = int(
+    remove_whitespace(
+        """
+    188DA80E B03090F6 7CBF20EB 43A18800 F4FF0AFD 82FF1012"""
+    ),
+    16,
+)
+_Gy = int(
+    remove_whitespace(
+        """
+    07192B95 FFC8DA78 631011ED 6B24CDD5 73F977A1 1E794811"""
+    ),
+    16,
+)
+
+curve_192 = ellipticcurve.CurveFp(_p, -3, _b, 1)
+generator_192 = ellipticcurve.PointJacobi(
+    curve_192, _Gx, _Gy, 1, _r, generator=True
+)
+
+
+# NIST Curve P-224:
+_p = int(
+    remove_whitespace(
+        """
+    2695994666715063979466701508701963067355791626002630814351
+    0066298881"""
+    )
+)
+_r = int(
+    remove_whitespace(
+        """
+    2695994666715063979466701508701962594045780771442439172168
+    2722368061"""
+    )
+)
+# s = 0xbd71344799d5c7fcdc45b59fa3b9ab8f6a948bc5L
+# c = 0x5b056c7e11dd68f40469ee7f3c7a7d74f7d121116506d031218291fbL
+_b = int(
+    remove_whitespace(
+        """
+    B4050A85 0C04B3AB F5413256 5044B0B7 D7BFD8BA 270B3943
+    2355FFB4"""
+    ),
+    16,
+)
+_Gx = int(
+    remove_whitespace(
+        """
+    B70E0CBD 6BB4BF7F 321390B9 4A03C1D3 56C21122 343280D6
+    115C1D21"""
+    ),
+    16,
+)
+_Gy = int(
+    remove_whitespace(
+        """
+    BD376388 B5F723FB 4C22DFE6 CD4375A0 5A074764 44D58199
+    85007E34"""
+    ),
+    16,
+)
+
+curve_224 = ellipticcurve.CurveFp(_p, -3, _b, 1)
+generator_224 = ellipticcurve.PointJacobi(
+    curve_224, _Gx, _Gy, 1, _r, generator=True
+)
+
+# NIST Curve P-256:
+_p = int(
+    remove_whitespace(
+        """
+    1157920892103562487626974469494075735300861434152903141955
+    33631308867097853951"""
+    )
+)
+_r = int(
+    remove_whitespace(
+        """
+    115792089210356248762697446949407573529996955224135760342
+    422259061068512044369"""
+    )
+)
+# s = 0xc49d360886e704936a6678e1139d26b7819f7e90L
+# c = 0x7efba1662985be9403cb055c75d4f7e0ce8d84a9c5114abcaf3177680104fa0dL
+_b = int(
+    remove_whitespace(
+        """
+    5AC635D8 AA3A93E7 B3EBBD55 769886BC 651D06B0 CC53B0F6
+    3BCE3C3E 27D2604B"""
+    ),
+    16,
+)
+_Gx = int(
+    remove_whitespace(
+        """
+    6B17D1F2 E12C4247 F8BCE6E5 63A440F2 77037D81 2DEB33A0
+    F4A13945 D898C296"""
+    ),
+    16,
+)
+_Gy = int(
+    remove_whitespace(
+        """
+    4FE342E2 FE1A7F9B 8EE7EB4A 7C0F9E16 2BCE3357 6B315ECE
+    CBB64068 37BF51F5"""
+    ),
+    16,
+)
+
+curve_256 = ellipticcurve.CurveFp(_p, -3, _b, 1)
+generator_256 = ellipticcurve.PointJacobi(
+    curve_256, _Gx, _Gy, 1, _r, generator=True
+)
+
+# NIST Curve P-384:
+_p = int(
+    remove_whitespace(
+        """
+    3940200619639447921227904010014361380507973927046544666794
+    8293404245721771496870329047266088258938001861606973112319"""
+    )
+)
+_r = int(
+    remove_whitespace(
+        """
+    3940200619639447921227904010014361380507973927046544666794
+    6905279627659399113263569398956308152294913554433653942643"""
+    )
+)
+# s = 0xa335926aa319a27a1d00896a6773a4827acdac73L
+# c = int(remove_whitespace(
+#    """
+#    79d1e655 f868f02f ff48dcde e14151dd b80643c1 406d0ca1
+#    0dfe6fc5 2009540a 495e8042 ea5f744f 6e184667 cc722483"""
+# ), 16)
+_b = int(
+    remove_whitespace(
+        """
+    B3312FA7 E23EE7E4 988E056B E3F82D19 181D9C6E FE814112
+    0314088F 5013875A C656398D 8A2ED19D 2A85C8ED D3EC2AEF"""
+    ),
+    16,
+)
+_Gx = int(
+    remove_whitespace(
+        """
+    AA87CA22 BE8B0537 8EB1C71E F320AD74 6E1D3B62 8BA79B98
+    59F741E0 82542A38 5502F25D BF55296C 3A545E38 72760AB7"""
+    ),
+    16,
+)
+_Gy = int(
+    remove_whitespace(
+        """
+    3617DE4A 96262C6F 5D9E98BF 9292DC29 F8F41DBD 289A147C
+    E9DA3113 B5F0B8C0 0A60B1CE 1D7E819D 7A431D7C 90EA0E5F"""
+    ),
+    16,
+)
+
+curve_384 = ellipticcurve.CurveFp(_p, -3, _b, 1)
+generator_384 = ellipticcurve.PointJacobi(
+    curve_384, _Gx, _Gy, 1, _r, generator=True
+)
+
+# NIST Curve P-521:
+_p = int(
+    "686479766013060971498190079908139321726943530014330540939"
+    "446345918554318339765605212255964066145455497729631139148"
+    "0858037121987999716643812574028291115057151"
+)
+_r = int(
+    "686479766013060971498190079908139321726943530014330540939"
+    "446345918554318339765539424505774633321719753296399637136"
+    "3321113864768612440380340372808892707005449"
+)
+# s = 0xd09e8800291cb85396cc6717393284aaa0da64baL
+# c = int(remove_whitespace(
+#    """
+#         0b4 8bfa5f42 0a349495 39d2bdfc 264eeeeb 077688e4
+#    4fbf0ad8 f6d0edb3 7bd6b533 28100051 8e19f1b9 ffbe0fe9
+#    ed8a3c22 00b8f875 e523868c 70c1e5bf 55bad637"""
+# ), 16)
+_b = int(
+    remove_whitespace(
+        """
+         051 953EB961 8E1C9A1F 929A21A0 B68540EE A2DA725B
+    99B315F3 B8B48991 8EF109E1 56193951 EC7E937B 1652C0BD
+    3BB1BF07 3573DF88 3D2C34F1 EF451FD4 6B503F00"""
+    ),
+    16,
+)
+_Gx = int(
+    remove_whitespace(
+        """
+          C6 858E06B7 0404E9CD 9E3ECB66 2395B442 9C648139
+    053FB521 F828AF60 6B4D3DBA A14B5E77 EFE75928 FE1DC127
+    A2FFA8DE 3348B3C1 856A429B F97E7E31 C2E5BD66"""
+    ),
+    16,
+)
+_Gy = int(
+    remove_whitespace(
+        """
+         118 39296A78 9A3BC004 5C8A5FB4 2C7D1BD9 98F54449
+    579B4468 17AFBD17 273E662C 97EE7299 5EF42640 C550B901
+    3FAD0761 353C7086 A272C240 88BE9476 9FD16650"""
+    ),
+    16,
+)
+
+curve_521 = ellipticcurve.CurveFp(_p, -3, _b, 1)
+generator_521 = ellipticcurve.PointJacobi(
+    curve_521, _Gx, _Gy, 1, _r, generator=True
+)
+
+# Certicom secp256-k1
+_a = 0x0000000000000000000000000000000000000000000000000000000000000000
+_b = 0x0000000000000000000000000000000000000000000000000000000000000007
+_p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
+_Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
+_Gy = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8
+_r = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+
+curve_secp256k1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_secp256k1 = ellipticcurve.PointJacobi(
+    curve_secp256k1, _Gx, _Gy, 1, _r, generator=True
+)
+
+# Brainpool P-160-r1
+_a = 0x340E7BE2A280EB74E2BE61BADA745D97E8F7C300
+_b = 0x1E589A8595423412134FAA2DBDEC95C8D8675E58
+_p = 0xE95E4A5F737059DC60DFC7AD95B3D8139515620F
+_Gx = 0xBED5AF16EA3F6A4F62938C4631EB5AF7BDBCDBC3
+_Gy = 0x1667CB477A1A8EC338F94741669C976316DA6321
+_q = 0xE95E4A5F737059DC60DF5991D45029409E60FC09
+
+curve_brainpoolp160r1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp160r1 = ellipticcurve.PointJacobi(
+    curve_brainpoolp160r1, _Gx, _Gy, 1, _q, generator=True
+)
+
+# Brainpool P-192-r1
+_a = 0x6A91174076B1E0E19C39C031FE8685C1CAE040E5C69A28EF
+_b = 0x469A28EF7C28CCA3DC721D044F4496BCCA7EF4146FBF25C9
+_p = 0xC302F41D932A36CDA7A3463093D18DB78FCE476DE1A86297
+_Gx = 0xC0A0647EAAB6A48753B033C56CB0F0900A2F5C4853375FD6
+_Gy = 0x14B690866ABD5BB88B5F4828C1490002E6773FA2FA299B8F
+_q = 0xC302F41D932A36CDA7A3462F9E9E916B5BE8F1029AC4ACC1
+
+curve_brainpoolp192r1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp192r1 = ellipticcurve.PointJacobi(
+    curve_brainpoolp192r1, _Gx, _Gy, 1, _q, generator=True
+)
+
+# Brainpool P-224-r1
+_a = 0x68A5E62CA9CE6C1C299803A6C1530B514E182AD8B0042A59CAD29F43
+_b = 0x2580F63CCFE44138870713B1A92369E33E2135D266DBB372386C400B
+_p = 0xD7C134AA264366862A18302575D1D787B09F075797DA89F57EC8C0FF
+_Gx = 0x0D9029AD2C7E5CF4340823B2A87DC68C9E4CE3174C1E6EFDEE12C07D
+_Gy = 0x58AA56F772C0726F24C6B89E4ECDAC24354B9E99CAA3F6D3761402CD
+_q = 0xD7C134AA264366862A18302575D0FB98D116BC4B6DDEBCA3A5A7939F
+
+curve_brainpoolp224r1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp224r1 = ellipticcurve.PointJacobi(
+    curve_brainpoolp224r1, _Gx, _Gy, 1, _q, generator=True
+)
+
+# Brainpool P-256-r1
+_a = 0x7D5A0975FC2C3057EEF67530417AFFE7FB8055C126DC5C6CE94A4B44F330B5D9
+_b = 0x26DC5C6CE94A4B44F330B5D9BBD77CBF958416295CF7E1CE6BCCDC18FF8C07B6
+_p = 0xA9FB57DBA1EEA9BC3E660A909D838D726E3BF623D52620282013481D1F6E5377
+_Gx = 0x8BD2AEB9CB7E57CB2C4B482FFC81B7AFB9DE27E1E3BD23C23A4453BD9ACE3262
+_Gy = 0x547EF835C3DAC4FD97F8461A14611DC9C27745132DED8E545C1D54C72F046997
+_q = 0xA9FB57DBA1EEA9BC3E660A909D838D718C397AA3B561A6F7901E0E82974856A7
+
+curve_brainpoolp256r1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp256r1 = ellipticcurve.PointJacobi(
+    curve_brainpoolp256r1, _Gx, _Gy, 1, _q, generator=True
+)
+
+# Brainpool P-320-r1
+_a = int(
+    remove_whitespace(
+        """
+    3EE30B568FBAB0F883CCEBD46D3F3BB8A2A73513F5EB79DA66190EB085FFA9
+    F492F375A97D860EB4"""
+    ),
+    16,
+)
+_b = int(
+    remove_whitespace(
+        """
+    520883949DFDBC42D3AD198640688A6FE13F41349554B49ACC31DCCD884539
+    816F5EB4AC8FB1F1A6"""
+    ),
+    16,
+)
+_p = int(
+    remove_whitespace(
+        """
+    D35E472036BC4FB7E13C785ED201E065F98FCFA6F6F40DEF4F92B9EC7893EC
+    28FCD412B1F1B32E27"""
+    ),
+    16,
+)
+_Gx = int(
+    remove_whitespace(
+        """
+    43BD7E9AFB53D8B85289BCC48EE5BFE6F20137D10A087EB6E7871E2A10A599
+    C710AF8D0D39E20611"""
+    ),
+    16,
+)
+_Gy = int(
+    remove_whitespace(
+        """
+    14FDD05545EC1CC8AB4093247F77275E0743FFED117182EAA9C77877AAAC6A
+    C7D35245D1692E8EE1"""
+    ),
+    16,
+)
+_q = int(
+    remove_whitespace(
+        """
+    D35E472036BC4FB7E13C785ED201E065F98FCFA5B68F12A32D482EC7EE8658
+    E98691555B44C59311"""
+    ),
+    16,
+)
+
+curve_brainpoolp320r1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp320r1 = ellipticcurve.PointJacobi(
+    curve_brainpoolp320r1, _Gx, _Gy, 1, _q, generator=True
+)
+
+# Brainpool P-384-r1
+_a = int(
+    remove_whitespace(
+        """
+    7BC382C63D8C150C3C72080ACE05AFA0C2BEA28E4FB22787139165EFBA91F9
+    0F8AA5814A503AD4EB04A8C7DD22CE2826"""
+    ),
+    16,
+)
+_b = int(
+    remove_whitespace(
+        """
+    04A8C7DD22CE28268B39B55416F0447C2FB77DE107DCD2A62E880EA53EEB62
+    D57CB4390295DBC9943AB78696FA504C11"""
+    ),
+    16,
+)
+_p = int(
+    remove_whitespace(
+        """
+    8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B412B1DA197FB711
+    23ACD3A729901D1A71874700133107EC53"""
+    ),
+    16,
+)
+_Gx = int(
+    remove_whitespace(
+        """
+    1D1C64F068CF45FFA2A63A81B7C13F6B8847A3E77EF14FE3DB7FCAFE0CBD10
+    E8E826E03436D646AAEF87B2E247D4AF1E"""
+    ),
+    16,
+)
+_Gy = int(
+    remove_whitespace(
+        """
+    8ABE1D7520F9C2A45CB1EB8E95CFD55262B70B29FEEC5864E19C054FF991292
+    80E4646217791811142820341263C5315"""
+    ),
+    16,
+)
+_q = int(
+    remove_whitespace(
+        """
+    8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B31F166E6CAC0425
+    A7CF3AB6AF6B7FC3103B883202E9046565"""
+    ),
+    16,
+)
+
+curve_brainpoolp384r1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp384r1 = ellipticcurve.PointJacobi(
+    curve_brainpoolp384r1, _Gx, _Gy, 1, _q, generator=True
+)
+
+# Brainpool P-512-r1
+_a = int(
+    remove_whitespace(
+        """
+    7830A3318B603B89E2327145AC234CC594CBDD8D3DF91610A83441CAEA9863
+    BC2DED5D5AA8253AA10A2EF1C98B9AC8B57F1117A72BF2C7B9E7C1AC4D77FC94CA"""
+    ),
+    16,
+)
+_b = int(
+    remove_whitespace(
+        """
+    3DF91610A83441CAEA9863BC2DED5D5AA8253AA10A2EF1C98B9AC8B57F1117
+    A72BF2C7B9E7C1AC4D77FC94CADC083E67984050B75EBAE5DD2809BD638016F723"""
+    ),
+    16,
+)
+_p = int(
+    remove_whitespace(
+        """
+    AADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA703308
+    717D4D9B009BC66842AECDA12AE6A380E62881FF2F2D82C68528AA6056583A48F3"""
+    ),
+    16,
+)
+_Gx = int(
+    remove_whitespace(
+        """
+    81AEE4BDD82ED9645A21322E9C4C6A9385ED9F70B5D916C1B43B62EEF4D009
+    8EFF3B1F78E2D0D48D50D1687B93B97D5F7C6D5047406A5E688B352209BCB9F822"""
+    ),
+    16,
+)
+_Gy = int(
+    remove_whitespace(
+        """
+    7DDE385D566332ECC0EABFA9CF7822FDF209F70024A57B1AA000C55B881F81
+    11B2DCDE494A5F485E5BCA4BD88A2763AED1CA2B2FA8F0540678CD1E0F3AD80892"""
+    ),
+    16,
+)
+_q = int(
+    remove_whitespace(
+        """
+    AADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA703308
+    70553E5C414CA92619418661197FAC10471DB1D381085DDADDB58796829CA90069"""
+    ),
+    16,
+)
+
+curve_brainpoolp512r1 = ellipticcurve.CurveFp(_p, _a, _b, 1)
+generator_brainpoolp512r1 = ellipticcurve.PointJacobi(
+    curve_brainpoolp512r1, _Gx, _Gy, 1, _q, generator=True
+)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/eddsa.py b/myenv/lib/python3.9/site-packages/ecdsa/eddsa.py
new file mode 100644
index 0000000..9769cfd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/eddsa.py
@@ -0,0 +1,252 @@
+"""Implementation of Edwards Digital Signature Algorithm."""
+
+import hashlib
+from ._sha3 import shake_256
+from . import ellipticcurve
+from ._compat import (
+    remove_whitespace,
+    bit_length,
+    bytes_to_int,
+    int_to_bytes,
+    compat26_str,
+)
+
+# edwards25519, defined in RFC7748
+_p = 2**255 - 19
+_a = -1
+_d = int(
+    remove_whitespace(
+        "370957059346694393431380835087545651895421138798432190163887855330"
+        "85940283555"
+    )
+)
+_h = 8
+
+_Gx = int(
+    remove_whitespace(
+        "151122213495354007725011514095885315114540126930418572060461132"
+        "83949847762202"
+    )
+)
+_Gy = int(
+    remove_whitespace(
+        "463168356949264781694283940034751631413079938662562256157830336"
+        "03165251855960"
+    )
+)
+_r = 2**252 + 0x14DEF9DEA2F79CD65812631A5CF5D3ED
+
+
+def _sha512(data):
+    return hashlib.new("sha512", compat26_str(data)).digest()
+
+
+curve_ed25519 = ellipticcurve.CurveEdTw(_p, _a, _d, _h, _sha512)
+generator_ed25519 = ellipticcurve.PointEdwards(
+    curve_ed25519, _Gx, _Gy, 1, _Gx * _Gy % _p, _r, generator=True
+)
+
+
+# edwards448, defined in RFC7748
+_p = 2**448 - 2**224 - 1
+_a = 1
+_d = -39081 % _p
+_h = 4
+
+_Gx = int(
+    remove_whitespace(
+        "224580040295924300187604334099896036246789641632564134246125461"
+        "686950415467406032909029192869357953282578032075146446173674602635"
+        "247710"
+    )
+)
+_Gy = int(
+    remove_whitespace(
+        "298819210078481492676017930443930673437544040154080242095928241"
+        "372331506189835876003536878655418784733982303233503462500531545062"
+        "832660"
+    )
+)
+_r = 2**446 - 0x8335DC163BB124B65129C96FDE933D8D723A70AADC873D6D54A7BB0D
+
+
+def _shake256(data):
+    return shake_256(data, 114)
+
+
+curve_ed448 = ellipticcurve.CurveEdTw(_p, _a, _d, _h, _shake256)
+generator_ed448 = ellipticcurve.PointEdwards(
+    curve_ed448, _Gx, _Gy, 1, _Gx * _Gy % _p, _r, generator=True
+)
+
+
+class PublicKey(object):
+    """Public key for the Edwards Digital Signature Algorithm."""
+
+    def __init__(self, generator, public_key, public_point=None):
+        self.generator = generator
+        self.curve = generator.curve()
+        self.__encoded = public_key
+        # plus one for the sign bit and round up
+        self.baselen = (bit_length(self.curve.p()) + 1 + 7) // 8
+        if len(public_key) != self.baselen:
+            raise ValueError(
+                "Incorrect size of the public key, expected: {0} bytes".format(
+                    self.baselen
+                )
+            )
+        if public_point:
+            self.__point = public_point
+        else:
+            self.__point = ellipticcurve.PointEdwards.from_bytes(
+                self.curve, public_key
+            )
+
+    def __eq__(self, other):
+        if isinstance(other, PublicKey):
+            return (
+                self.curve == other.curve and self.__encoded == other.__encoded
+            )
+        return NotImplemented
+
+    def __ne__(self, other):
+        return not self == other
+
+    @property
+    def point(self):
+        return self.__point
+
+    @point.setter
+    def point(self, other):
+        if self.__point != other:
+            raise ValueError("Can't change the coordinates of the point")
+        self.__point = other
+
+    def public_point(self):
+        return self.__point
+
+    def public_key(self):
+        return self.__encoded
+
+    def verify(self, data, signature):
+        """Verify a Pure EdDSA signature over data."""
+        data = compat26_str(data)
+        if len(signature) != 2 * self.baselen:
+            raise ValueError(
+                "Invalid signature length, expected: {0} bytes".format(
+                    2 * self.baselen
+                )
+            )
+        R = ellipticcurve.PointEdwards.from_bytes(
+            self.curve, signature[: self.baselen]
+        )
+        S = bytes_to_int(signature[self.baselen :], "little")
+        if S >= self.generator.order():
+            raise ValueError("Invalid signature")
+
+        dom = bytearray()
+        if self.curve == curve_ed448:
+            dom = bytearray(b"SigEd448" + b"\x00\x00")
+
+        k = bytes_to_int(
+            self.curve.hash_func(dom + R.to_bytes() + self.__encoded + data),
+            "little",
+        )
+
+        if self.generator * S != self.__point * k + R:
+            raise ValueError("Invalid signature")
+
+        return True
+
+
+class PrivateKey(object):
+    """Private key for the Edwards Digital Signature Algorithm."""
+
+    def __init__(self, generator, private_key):
+        self.generator = generator
+        self.curve = generator.curve()
+        # plus one for the sign bit and round up
+        self.baselen = (bit_length(self.curve.p()) + 1 + 7) // 8
+        if len(private_key) != self.baselen:
+            raise ValueError(
+                "Incorrect size of private key, expected: {0} bytes".format(
+                    self.baselen
+                )
+            )
+        self.__private_key = bytes(private_key)
+        self.__h = bytearray(self.curve.hash_func(private_key))
+        self.__public_key = None
+
+        a = self.__h[: self.baselen]
+        a = self._key_prune(a)
+        scalar = bytes_to_int(a, "little")
+        self.__s = scalar
+
+    @property
+    def private_key(self):
+        return self.__private_key
+
+    def __eq__(self, other):
+        if isinstance(other, PrivateKey):
+            return (
+                self.curve == other.curve
+                and self.__private_key == other.__private_key
+            )
+        return NotImplemented
+
+    def __ne__(self, other):
+        return not self == other
+
+    def _key_prune(self, key):
+        # make sure the key is not in a small subgroup
+        h = self.curve.cofactor()
+        if h == 4:
+            h_log = 2
+        elif h == 8:
+            h_log = 3
+        else:
+            raise ValueError("Only cofactor 4 and 8 curves supported")
+        key[0] &= ~((1 << h_log) - 1)
+
+        # ensure the highest bit is set but no higher
+        l = bit_length(self.curve.p())
+        if l % 8 == 0:
+            key[-1] = 0
+            key[-2] |= 0x80
+        else:
+            key[-1] = key[-1] & (1 << (l % 8)) - 1 | 1 << (l % 8) - 1
+        return key
+
+    def public_key(self):
+        """Generate the public key based on the included private key"""
+        if self.__public_key:
+            return self.__public_key
+
+        public_point = self.generator * self.__s
+
+        self.__public_key = PublicKey(
+            self.generator, public_point.to_bytes(), public_point
+        )
+
+        return self.__public_key
+
+    def sign(self, data):
+        """Perform a Pure EdDSA signature over data."""
+        data = compat26_str(data)
+        A = self.public_key().public_key()
+
+        prefix = self.__h[self.baselen :]
+
+        dom = bytearray()
+        if self.curve == curve_ed448:
+            dom = bytearray(b"SigEd448" + b"\x00\x00")
+
+        r = bytes_to_int(self.curve.hash_func(dom + prefix + data), "little")
+        R = (self.generator * r).to_bytes()
+
+        k = bytes_to_int(self.curve.hash_func(dom + R + A + data), "little")
+        k %= self.generator.order()
+
+        S = (r + k * self.__s) % self.generator.order()
+
+        return R + int_to_bytes(S, self.baselen, "little")
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/ellipticcurve.py b/myenv/lib/python3.9/site-packages/ecdsa/ellipticcurve.py
new file mode 100644
index 0000000..d6f7146
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/ellipticcurve.py
@@ -0,0 +1,1584 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Implementation of elliptic curves, for cryptographic applications.
+#
+# This module doesn't provide any way to choose a random elliptic
+# curve, nor to verify that an elliptic curve was chosen randomly,
+# because one can simply use NIST's standard curves.
+#
+# Notes from X9.62-1998 (draft):
+#   Nomenclature:
+#     - Q is a public key.
+#     The "Elliptic Curve Domain Parameters" include:
+#     - q is the "field size", which in our case equals p.
+#     - p is a big prime.
+#     - G is a point of prime order (5.1.1.1).
+#     - n is the order of G (5.1.1.1).
+#   Public-key validation (5.2.2):
+#     - Verify that Q is not the point at infinity.
+#     - Verify that X_Q and Y_Q are in [0,p-1].
+#     - Verify that Q is on the curve.
+#     - Verify that nQ is the point at infinity.
+#   Signature generation (5.3):
+#     - Pick random k from [1,n-1].
+#   Signature checking (5.4.2):
+#     - Verify that r and s are in [1,n-1].
+#
+# Revision history:
+#    2005.12.31 - Initial version.
+#    2008.11.25 - Change CurveFp.is_on to contains_point.
+#
+# Written in 2005 by Peter Pearson and placed in the public domain.
+# Modified extensively as part of python-ecdsa.
+
+from __future__ import division
+
+try:
+    from gmpy2 import mpz
+
+    GMPY = True
+except ImportError:  # pragma: no branch
+    try:
+        from gmpy import mpz
+
+        GMPY = True
+    except ImportError:
+        GMPY = False
+
+
+from six import python_2_unicode_compatible
+from . import numbertheory
+from ._compat import normalise_bytes, int_to_bytes, bit_length, bytes_to_int
+from .errors import MalformedPointError
+from .util import orderlen, string_to_number, number_to_string
+
+
+@python_2_unicode_compatible
+class CurveFp(object):
+    """
+    :term:`Short Weierstrass Elliptic Curve <short Weierstrass curve>` over a
+    prime field.
+    """
+
+    if GMPY:  # pragma: no branch
+
+        def __init__(self, p, a, b, h=None):
+            """
+            The curve of points satisfying y^2 = x^3 + a*x + b (mod p).
+
+            h is an integer that is the cofactor of the elliptic curve domain
+            parameters; it is the number of points satisfying the elliptic
+            curve equation divided by the order of the base point. It is used
+            for selection of efficient algorithm for public point verification.
+            """
+            self.__p = mpz(p)
+            self.__a = mpz(a)
+            self.__b = mpz(b)
+            # h is not used in calculations and it can be None, so don't use
+            # gmpy with it
+            self.__h = h
+
+    else:  # pragma: no branch
+
+        def __init__(self, p, a, b, h=None):
+            """
+            The curve of points satisfying y^2 = x^3 + a*x + b (mod p).
+
+            h is an integer that is the cofactor of the elliptic curve domain
+            parameters; it is the number of points satisfying the elliptic
+            curve equation divided by the order of the base point. It is used
+            for selection of efficient algorithm for public point verification.
+            """
+            self.__p = p
+            self.__a = a
+            self.__b = b
+            self.__h = h
+
+    def __eq__(self, other):
+        """Return True if other is an identical curve, False otherwise.
+
+        Note: the value of the cofactor of the curve is not taken into account
+        when comparing curves, as it's derived from the base point and
+        intrinsic curve characteristic (but it's complex to compute),
+        only the prime and curve parameters are considered.
+        """
+        if isinstance(other, CurveFp):
+            p = self.__p
+            return (
+                self.__p == other.__p
+                and self.__a % p == other.__a % p
+                and self.__b % p == other.__b % p
+            )
+        return NotImplemented
+
+    def __ne__(self, other):
+        """Return False if other is an identical curve, True otherwise."""
+        return not self == other
+
+    def __hash__(self):
+        return hash((self.__p, self.__a, self.__b))
+
+    def p(self):
+        return self.__p
+
+    def a(self):
+        return self.__a
+
+    def b(self):
+        return self.__b
+
+    def cofactor(self):
+        return self.__h
+
+    def contains_point(self, x, y):
+        """Is the point (x,y) on this curve?"""
+        return (y * y - ((x * x + self.__a) * x + self.__b)) % self.__p == 0
+
+    def __str__(self):
+        return "CurveFp(p=%d, a=%d, b=%d, h=%d)" % (
+            self.__p,
+            self.__a,
+            self.__b,
+            self.__h,
+        )
+
+
+class CurveEdTw(object):
+    """Parameters for a Twisted Edwards Elliptic Curve"""
+
+    if GMPY:  # pragma: no branch
+
+        def __init__(self, p, a, d, h=None, hash_func=None):
+            """
+            The curve of points satisfying a*x^2 + y^2 = 1 + d*x^2*y^2 (mod p).
+
+            h is the cofactor of the curve.
+            hash_func is the hash function associated with the curve
+             (like SHA-512 for Ed25519)
+            """
+            self.__p = mpz(p)
+            self.__a = mpz(a)
+            self.__d = mpz(d)
+            self.__h = h
+            self.__hash_func = hash_func
+
+    else:
+
+        def __init__(self, p, a, d, h=None, hash_func=None):
+            """
+            The curve of points satisfying a*x^2 + y^2 = 1 + d*x^2*y^2 (mod p).
+
+            h is the cofactor of the curve.
+            hash_func is the hash function associated with the curve
+             (like SHA-512 for Ed25519)
+            """
+            self.__p = p
+            self.__a = a
+            self.__d = d
+            self.__h = h
+            self.__hash_func = hash_func
+
+    def __eq__(self, other):
+        """Returns True if other is an identical curve."""
+        if isinstance(other, CurveEdTw):
+            p = self.__p
+            return (
+                self.__p == other.__p
+                and self.__a % p == other.__a % p
+                and self.__d % p == other.__d % p
+            )
+        return NotImplemented
+
+    def __ne__(self, other):
+        """Return False if the other is an identical curve, True otherwise."""
+        return not self == other
+
+    def __hash__(self):
+        return hash((self.__p, self.__a, self.__d))
+
+    def contains_point(self, x, y):
+        """Is the point (x, y) on this curve?"""
+        return (
+            self.__a * x * x + y * y - 1 - self.__d * x * x * y * y
+        ) % self.__p == 0
+
+    def p(self):
+        return self.__p
+
+    def a(self):
+        return self.__a
+
+    def d(self):
+        return self.__d
+
+    def hash_func(self, data):
+        return self.__hash_func(data)
+
+    def cofactor(self):
+        return self.__h
+
+    def __str__(self):
+        return "CurveEdTw(p={0}, a={1}, d={2}, h={3})".format(
+            self.__p,
+            self.__a,
+            self.__d,
+            self.__h,
+        )
+
+
+class AbstractPoint(object):
+    """Class for common methods of elliptic curve points."""
+
+    @staticmethod
+    def _from_raw_encoding(data, raw_encoding_length):
+        """
+        Decode public point from :term:`raw encoding`.
+
+        :term:`raw encoding` is the same as the :term:`uncompressed` encoding,
+        but without the 0x04 byte at the beginning.
+        """
+        # real assert, from_bytes() should not call us with different length
+        assert len(data) == raw_encoding_length
+        xs = data[: raw_encoding_length // 2]
+        ys = data[raw_encoding_length // 2 :]
+        # real assert, raw_encoding_length is calculated by multiplying an
+        # integer by two so it will always be even
+        assert len(xs) == raw_encoding_length // 2
+        assert len(ys) == raw_encoding_length // 2
+        coord_x = string_to_number(xs)
+        coord_y = string_to_number(ys)
+
+        return coord_x, coord_y
+
+    @staticmethod
+    def _from_compressed(data, curve):
+        """Decode public point from compressed encoding."""
+        if data[:1] not in (b"\x02", b"\x03"):
+            raise MalformedPointError("Malformed compressed point encoding")
+
+        is_even = data[:1] == b"\x02"
+        x = string_to_number(data[1:])
+        p = curve.p()
+        alpha = (pow(x, 3, p) + (curve.a() * x) + curve.b()) % p
+        try:
+            beta = numbertheory.square_root_mod_prime(alpha, p)
+        except numbertheory.Error as e:
+            raise MalformedPointError(
+                "Encoding does not correspond to a point on curve", e
+            )
+        if is_even == bool(beta & 1):
+            y = p - beta
+        else:
+            y = beta
+        return x, y
+
+    @classmethod
+    def _from_hybrid(cls, data, raw_encoding_length, validate_encoding):
+        """Decode public point from hybrid encoding."""
+        # real assert, from_bytes() should not call us with different types
+        assert data[:1] in (b"\x06", b"\x07")
+
+        # primarily use the uncompressed as it's easiest to handle
+        x, y = cls._from_raw_encoding(data[1:], raw_encoding_length)
+
+        # but validate if it's self-consistent if we're asked to do that
+        if validate_encoding and (
+            y & 1
+            and data[:1] != b"\x07"
+            or (not y & 1)
+            and data[:1] != b"\x06"
+        ):
+            raise MalformedPointError("Inconsistent hybrid point encoding")
+
+        return x, y
+
+    @classmethod
+    def _from_edwards(cls, curve, data):
+        """Decode a point on an Edwards curve."""
+        data = bytearray(data)
+        p = curve.p()
+        # add 1 for the sign bit and then round up
+        exp_len = (bit_length(p) + 1 + 7) // 8
+        if len(data) != exp_len:
+            raise MalformedPointError("Point length doesn't match the curve.")
+        x_0 = (data[-1] & 0x80) >> 7
+
+        data[-1] &= 0x80 - 1
+
+        y = bytes_to_int(data, "little")
+        if GMPY:
+            y = mpz(y)
+
+        x2 = (
+            (y * y - 1)
+            * numbertheory.inverse_mod(curve.d() * y * y - curve.a(), p)
+            % p
+        )
+
+        try:
+            x = numbertheory.square_root_mod_prime(x2, p)
+        except numbertheory.Error as e:
+            raise MalformedPointError(
+                "Encoding does not correspond to a point on curve", e
+            )
+
+        if x % 2 != x_0:
+            x = -x % p
+
+        return x, y
+
+    @classmethod
+    def from_bytes(
+        cls, curve, data, validate_encoding=True, valid_encodings=None
+    ):
+        """
+        Initialise the object from byte encoding of a point.
+
+        The method does accept and automatically detect the type of point
+        encoding used. It supports the :term:`raw encoding`,
+        :term:`uncompressed`, :term:`compressed`, and :term:`hybrid` encodings.
+
+        Note: generally you will want to call the ``from_bytes()`` method of
+        either a child class, PointJacobi or Point.
+
+        :param data: single point encoding of the public key
+        :type data: :term:`bytes-like object`
+        :param curve: the curve on which the public key is expected to lay
+        :type curve: ~ecdsa.ellipticcurve.CurveFp
+        :param validate_encoding: whether to verify that the encoding of the
+            point is self-consistent, defaults to True, has effect only
+            on ``hybrid`` encoding
+        :type validate_encoding: bool
+        :param valid_encodings: list of acceptable point encoding formats,
+            supported ones are: :term:`uncompressed`, :term:`compressed`,
+            :term:`hybrid`, and :term:`raw encoding` (specified with ``raw``
+            name). All formats by default (specified with ``None``).
+        :type valid_encodings: :term:`set-like object`
+
+        :raises `~ecdsa.errors.MalformedPointError`: if the public point does
+            not lay on the curve or the encoding is invalid
+
+        :return: x and y coordinates of the encoded point
+        :rtype: tuple(int, int)
+        """
+        if not valid_encodings:
+            valid_encodings = set(
+                ["uncompressed", "compressed", "hybrid", "raw"]
+            )
+        if not all(
+            i in set(("uncompressed", "compressed", "hybrid", "raw"))
+            for i in valid_encodings
+        ):
+            raise ValueError(
+                "Only uncompressed, compressed, hybrid or raw encoding "
+                "supported."
+            )
+        data = normalise_bytes(data)
+
+        if isinstance(curve, CurveEdTw):
+            return cls._from_edwards(curve, data)
+
+        key_len = len(data)
+        raw_encoding_length = 2 * orderlen(curve.p())
+        if key_len == raw_encoding_length and "raw" in valid_encodings:
+            coord_x, coord_y = cls._from_raw_encoding(
+                data, raw_encoding_length
+            )
+        elif key_len == raw_encoding_length + 1 and (
+            "hybrid" in valid_encodings or "uncompressed" in valid_encodings
+        ):
+            if data[:1] in (b"\x06", b"\x07") and "hybrid" in valid_encodings:
+                coord_x, coord_y = cls._from_hybrid(
+                    data, raw_encoding_length, validate_encoding
+                )
+            elif data[:1] == b"\x04" and "uncompressed" in valid_encodings:
+                coord_x, coord_y = cls._from_raw_encoding(
+                    data[1:], raw_encoding_length
+                )
+            else:
+                raise MalformedPointError(
+                    "Invalid X9.62 encoding of the public point"
+                )
+        elif (
+            key_len == raw_encoding_length // 2 + 1
+            and "compressed" in valid_encodings
+        ):
+            coord_x, coord_y = cls._from_compressed(data, curve)
+        else:
+            raise MalformedPointError(
+                "Length of string does not match lengths of "
+                "any of the enabled ({0}) encodings of the "
+                "curve.".format(", ".join(valid_encodings))
+            )
+        return coord_x, coord_y
+
+    def _raw_encode(self):
+        """Convert the point to the :term:`raw encoding`."""
+        prime = self.curve().p()
+        x_str = number_to_string(self.x(), prime)
+        y_str = number_to_string(self.y(), prime)
+        return x_str + y_str
+
+    def _compressed_encode(self):
+        """Encode the point into the compressed form."""
+        prime = self.curve().p()
+        x_str = number_to_string(self.x(), prime)
+        if self.y() & 1:
+            return b"\x03" + x_str
+        return b"\x02" + x_str
+
+    def _hybrid_encode(self):
+        """Encode the point into the hybrid form."""
+        raw_enc = self._raw_encode()
+        if self.y() & 1:
+            return b"\x07" + raw_enc
+        return b"\x06" + raw_enc
+
+    def _edwards_encode(self):
+        """Encode the point according to RFC8032 encoding."""
+        self.scale()
+        x, y, p = self.x(), self.y(), self.curve().p()
+
+        # add 1 for the sign bit and then round up
+        enc_len = (bit_length(p) + 1 + 7) // 8
+        y_str = int_to_bytes(y, enc_len, "little")
+        if x % 2:
+            y_str[-1] |= 0x80
+        return y_str
+
+    def to_bytes(self, encoding="raw"):
+        """
+        Convert the point to a byte string.
+
+        The method by default uses the :term:`raw encoding` (specified
+        by `encoding="raw"`. It can also output points in :term:`uncompressed`,
+        :term:`compressed`, and :term:`hybrid` formats.
+
+        For points on Edwards curves `encoding` is ignored and only the
+        encoding defined in RFC 8032 is supported.
+
+        :return: :term:`raw encoding` of a public on the curve
+        :rtype: bytes
+        """
+        assert encoding in ("raw", "uncompressed", "compressed", "hybrid")
+        curve = self.curve()
+        if isinstance(curve, CurveEdTw):
+            return self._edwards_encode()
+        elif encoding == "raw":
+            return self._raw_encode()
+        elif encoding == "uncompressed":
+            return b"\x04" + self._raw_encode()
+        elif encoding == "hybrid":
+            return self._hybrid_encode()
+        else:
+            return self._compressed_encode()
+
+    @staticmethod
+    def _naf(mult):
+        """Calculate non-adjacent form of number."""
+        ret = []
+        while mult:
+            if mult % 2:
+                nd = mult % 4
+                if nd >= 2:
+                    nd -= 4
+                ret.append(nd)
+                mult -= nd
+            else:
+                ret.append(0)
+            mult //= 2
+        return ret
+
+
+class PointJacobi(AbstractPoint):
+    """
+    Point on a short Weierstrass elliptic curve. Uses Jacobi coordinates.
+
+    In Jacobian coordinates, there are three parameters, X, Y and Z.
+    They correspond to affine parameters 'x' and 'y' like so:
+
+    x = X / Z²
+    y = Y / Z³
+    """
+
+    def __init__(self, curve, x, y, z, order=None, generator=False):
+        """
+        Initialise a point that uses Jacobi representation internally.
+
+        :param CurveFp curve: curve on which the point resides
+        :param int x: the X parameter of Jacobi representation (equal to x when
+          converting from affine coordinates
+        :param int y: the Y parameter of Jacobi representation (equal to y when
+          converting from affine coordinates
+        :param int z: the Z parameter of Jacobi representation (equal to 1 when
+          converting from affine coordinates
+        :param int order: the point order, must be non zero when using
+          generator=True
+        :param bool generator: the point provided is a curve generator, as
+          such, it will be commonly used with scalar multiplication. This will
+          cause to precompute multiplication table generation for it
+        """
+        super(PointJacobi, self).__init__()
+        self.__curve = curve
+        if GMPY:  # pragma: no branch
+            self.__coords = (mpz(x), mpz(y), mpz(z))
+            self.__order = order and mpz(order)
+        else:  # pragma: no branch
+            self.__coords = (x, y, z)
+            self.__order = order
+        self.__generator = generator
+        self.__precompute = []
+
+    @classmethod
+    def from_bytes(
+        cls,
+        curve,
+        data,
+        validate_encoding=True,
+        valid_encodings=None,
+        order=None,
+        generator=False,
+    ):
+        """
+        Initialise the object from byte encoding of a point.
+
+        The method does accept and automatically detect the type of point
+        encoding used. It supports the :term:`raw encoding`,
+        :term:`uncompressed`, :term:`compressed`, and :term:`hybrid` encodings.
+
+        :param data: single point encoding of the public key
+        :type data: :term:`bytes-like object`
+        :param curve: the curve on which the public key is expected to lay
+        :type curve: ~ecdsa.ellipticcurve.CurveFp
+        :param validate_encoding: whether to verify that the encoding of the
+            point is self-consistent, defaults to True, has effect only
+            on ``hybrid`` encoding
+        :type validate_encoding: bool
+        :param valid_encodings: list of acceptable point encoding formats,
+            supported ones are: :term:`uncompressed`, :term:`compressed`,
+            :term:`hybrid`, and :term:`raw encoding` (specified with ``raw``
+            name). All formats by default (specified with ``None``).
+        :type valid_encodings: :term:`set-like object`
+        :param int order: the point order, must be non zero when using
+            generator=True
+        :param bool generator: the point provided is a curve generator, as
+            such, it will be commonly used with scalar multiplication. This
+            will cause to precompute multiplication table generation for it
+
+        :raises `~ecdsa.errors.MalformedPointError`: if the public point does
+            not lay on the curve or the encoding is invalid
+
+        :return: Point on curve
+        :rtype: PointJacobi
+        """
+        coord_x, coord_y = super(PointJacobi, cls).from_bytes(
+            curve, data, validate_encoding, valid_encodings
+        )
+        return PointJacobi(curve, coord_x, coord_y, 1, order, generator)
+
+    def _maybe_precompute(self):
+        if not self.__generator or self.__precompute:
+            return
+
+        # since this code will execute just once, and it's fully deterministic,
+        # depend on atomicity of the last assignment to switch from empty
+        # self.__precompute to filled one and just ignore the unlikely
+        # situation when two threads execute it at the same time (as it won't
+        # lead to inconsistent __precompute)
+        order = self.__order
+        assert order
+        precompute = []
+        i = 1
+        order *= 2
+        coord_x, coord_y, coord_z = self.__coords
+        doubler = PointJacobi(self.__curve, coord_x, coord_y, coord_z, order)
+        order *= 2
+        precompute.append((doubler.x(), doubler.y()))
+
+        while i < order:
+            i *= 2
+            doubler = doubler.double().scale()
+            precompute.append((doubler.x(), doubler.y()))
+
+        self.__precompute = precompute
+
+    def __getstate__(self):
+        # while this code can execute at the same time as _maybe_precompute()
+        # is updating the __precompute or scale() is updating the __coords,
+        # there is no requirement for consistency between __coords and
+        # __precompute
+        state = self.__dict__.copy()
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+
+    def __eq__(self, other):
+        """Compare for equality two points with each-other.
+
+        Note: only points that lay on the same curve can be equal.
+        """
+        x1, y1, z1 = self.__coords
+        if other is INFINITY:
+            return not y1 or not z1
+        if isinstance(other, Point):
+            x2, y2, z2 = other.x(), other.y(), 1
+        elif isinstance(other, PointJacobi):
+            x2, y2, z2 = other.__coords
+        else:
+            return NotImplemented
+        if self.__curve != other.curve():
+            return False
+        p = self.__curve.p()
+
+        zz1 = z1 * z1 % p
+        zz2 = z2 * z2 % p
+
+        # compare the fractions by bringing them to the same denominator
+        # depend on short-circuit to save 4 multiplications in case of
+        # inequality
+        return (x1 * zz2 - x2 * zz1) % p == 0 and (
+            y1 * zz2 * z2 - y2 * zz1 * z1
+        ) % p == 0
+
+    def __ne__(self, other):
+        """Compare for inequality two points with each-other."""
+        return not self == other
+
+    def order(self):
+        """Return the order of the point.
+
+        None if it is undefined.
+        """
+        return self.__order
+
+    def curve(self):
+        """Return curve over which the point is defined."""
+        return self.__curve
+
+    def x(self):
+        """
+        Return affine x coordinate.
+
+        This method should be used only when the 'y' coordinate is not needed.
+        It's computationally more efficient to use `to_affine()` and then
+        call x() and y() on the returned instance. Or call `scale()`
+        and then x() and y() on the returned instance.
+        """
+        x, _, z = self.__coords
+        if z == 1:
+            return x
+        p = self.__curve.p()
+        z = numbertheory.inverse_mod(z, p)
+        return x * z**2 % p
+
+    def y(self):
+        """
+        Return affine y coordinate.
+
+        This method should be used only when the 'x' coordinate is not needed.
+        It's computationally more efficient to use `to_affine()` and then
+        call x() and y() on the returned instance. Or call `scale()`
+        and then x() and y() on the returned instance.
+        """
+        _, y, z = self.__coords
+        if z == 1:
+            return y
+        p = self.__curve.p()
+        z = numbertheory.inverse_mod(z, p)
+        return y * z**3 % p
+
+    def scale(self):
+        """
+        Return point scaled so that z == 1.
+
+        Modifies point in place, returns self.
+        """
+        x, y, z = self.__coords
+        if z == 1:
+            return self
+
+        # scaling is deterministic, so even if two threads execute the below
+        # code at the same time, they will set __coords to the same value
+        p = self.__curve.p()
+        z_inv = numbertheory.inverse_mod(z, p)
+        zz_inv = z_inv * z_inv % p
+        x = x * zz_inv % p
+        y = y * zz_inv * z_inv % p
+        self.__coords = (x, y, 1)
+        return self
+
+    def to_affine(self):
+        """Return point in affine form."""
+        _, y, z = self.__coords
+        if not y or not z:
+            return INFINITY
+        self.scale()
+        x, y, z = self.__coords
+        return Point(self.__curve, x, y, self.__order)
+
+    @staticmethod
+    def from_affine(point, generator=False):
+        """Create from an affine point.
+
+        :param bool generator: set to True to make the point to precalculate
+          multiplication table - useful for public point when verifying many
+          signatures (around 100 or so) or for generator points of a curve.
+        """
+        return PointJacobi(
+            point.curve(), point.x(), point.y(), 1, point.order(), generator
+        )
+
+    # please note that all the methods that use the equations from
+    # hyperelliptic
+    # are formatted in a way to maximise performance.
+    # Things that make code faster: multiplying instead of taking to the power
+    # (`xx = x * x; xxxx = xx * xx % p` is faster than `xxxx = x**4 % p` and
+    # `pow(x, 4, p)`),
+    # multiple assignments at the same time (`x1, x2 = self.x1, self.x2` is
+    # faster than `x1 = self.x1; x2 = self.x2`),
+    # similarly, sometimes the `% p` is skipped if it makes the calculation
+    # faster and the result of calculation is later reduced modulo `p`
+
+    def _double_with_z_1(self, X1, Y1, p, a):
+        """Add a point to itself with z == 1."""
+        # after:
+        # http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#doubling-mdbl-2007-bl
+        XX, YY = X1 * X1 % p, Y1 * Y1 % p
+        if not YY:
+            return 0, 0, 1
+        YYYY = YY * YY % p
+        S = 2 * ((X1 + YY) ** 2 - XX - YYYY) % p
+        M = 3 * XX + a
+        T = (M * M - 2 * S) % p
+        # X3 = T
+        Y3 = (M * (S - T) - 8 * YYYY) % p
+        Z3 = 2 * Y1 % p
+        return T, Y3, Z3
+
+    def _double(self, X1, Y1, Z1, p, a):
+        """Add a point to itself, arbitrary z."""
+        if Z1 == 1:
+            return self._double_with_z_1(X1, Y1, p, a)
+        if not Y1 or not Z1:
+            return 0, 0, 1
+        # after:
+        # http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#doubling-dbl-2007-bl
+        XX, YY = X1 * X1 % p, Y1 * Y1 % p
+        if not YY:
+            return 0, 0, 1
+        YYYY = YY * YY % p
+        ZZ = Z1 * Z1 % p
+        S = 2 * ((X1 + YY) ** 2 - XX - YYYY) % p
+        M = (3 * XX + a * ZZ * ZZ) % p
+        T = (M * M - 2 * S) % p
+        # X3 = T
+        Y3 = (M * (S - T) - 8 * YYYY) % p
+        Z3 = ((Y1 + Z1) ** 2 - YY - ZZ) % p
+
+        return T, Y3, Z3
+
+    def double(self):
+        """Add a point to itself."""
+        X1, Y1, Z1 = self.__coords
+
+        if not Y1:
+            return INFINITY
+
+        p, a = self.__curve.p(), self.__curve.a()
+
+        X3, Y3, Z3 = self._double(X1, Y1, Z1, p, a)
+
+        if not Y3 or not Z3:
+            return INFINITY
+        return PointJacobi(self.__curve, X3, Y3, Z3, self.__order)
+
+    def _add_with_z_1(self, X1, Y1, X2, Y2, p):
+        """add points when both Z1 and Z2 equal 1"""
+        # after:
+        # http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#addition-mmadd-2007-bl
+        H = X2 - X1
+        HH = H * H
+        I = 4 * HH % p
+        J = H * I
+        r = 2 * (Y2 - Y1)
+        if not H and not r:
+            return self._double_with_z_1(X1, Y1, p, self.__curve.a())
+        V = X1 * I
+        X3 = (r**2 - J - 2 * V) % p
+        Y3 = (r * (V - X3) - 2 * Y1 * J) % p
+        Z3 = 2 * H % p
+        return X3, Y3, Z3
+
+    def _add_with_z_eq(self, X1, Y1, Z1, X2, Y2, p):
+        """add points when Z1 == Z2"""
+        # after:
+        # http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#addition-zadd-2007-m
+        A = (X2 - X1) ** 2 % p
+        B = X1 * A % p
+        C = X2 * A
+        D = (Y2 - Y1) ** 2 % p
+        if not A and not D:
+            return self._double(X1, Y1, Z1, p, self.__curve.a())
+        X3 = (D - B - C) % p
+        Y3 = ((Y2 - Y1) * (B - X3) - Y1 * (C - B)) % p
+        Z3 = Z1 * (X2 - X1) % p
+        return X3, Y3, Z3
+
+    def _add_with_z2_1(self, X1, Y1, Z1, X2, Y2, p):
+        """add points when Z2 == 1"""
+        # after:
+        # http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#addition-madd-2007-bl
+        Z1Z1 = Z1 * Z1 % p
+        U2, S2 = X2 * Z1Z1 % p, Y2 * Z1 * Z1Z1 % p
+        H = (U2 - X1) % p
+        HH = H * H % p
+        I = 4 * HH % p
+        J = H * I
+        r = 2 * (S2 - Y1) % p
+        if not r and not H:
+            return self._double_with_z_1(X2, Y2, p, self.__curve.a())
+        V = X1 * I
+        X3 = (r * r - J - 2 * V) % p
+        Y3 = (r * (V - X3) - 2 * Y1 * J) % p
+        Z3 = ((Z1 + H) ** 2 - Z1Z1 - HH) % p
+        return X3, Y3, Z3
+
+    def _add_with_z_ne(self, X1, Y1, Z1, X2, Y2, Z2, p):
+        """add points with arbitrary z"""
+        # after:
+        # http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#addition-add-2007-bl
+        Z1Z1 = Z1 * Z1 % p
+        Z2Z2 = Z2 * Z2 % p
+        U1 = X1 * Z2Z2 % p
+        U2 = X2 * Z1Z1 % p
+        S1 = Y1 * Z2 * Z2Z2 % p
+        S2 = Y2 * Z1 * Z1Z1 % p
+        H = U2 - U1
+        I = 4 * H * H % p
+        J = H * I % p
+        r = 2 * (S2 - S1) % p
+        if not H and not r:
+            return self._double(X1, Y1, Z1, p, self.__curve.a())
+        V = U1 * I
+        X3 = (r * r - J - 2 * V) % p
+        Y3 = (r * (V - X3) - 2 * S1 * J) % p
+        Z3 = ((Z1 + Z2) ** 2 - Z1Z1 - Z2Z2) * H % p
+
+        return X3, Y3, Z3
+
+    def __radd__(self, other):
+        """Add other to self."""
+        return self + other
+
+    def _add(self, X1, Y1, Z1, X2, Y2, Z2, p):
+        """add two points, select fastest method."""
+        if not Y1 or not Z1:
+            return X2, Y2, Z2
+        if not Y2 or not Z2:
+            return X1, Y1, Z1
+        if Z1 == Z2:
+            if Z1 == 1:
+                return self._add_with_z_1(X1, Y1, X2, Y2, p)
+            return self._add_with_z_eq(X1, Y1, Z1, X2, Y2, p)
+        if Z1 == 1:
+            return self._add_with_z2_1(X2, Y2, Z2, X1, Y1, p)
+        if Z2 == 1:
+            return self._add_with_z2_1(X1, Y1, Z1, X2, Y2, p)
+        return self._add_with_z_ne(X1, Y1, Z1, X2, Y2, Z2, p)
+
+    def __add__(self, other):
+        """Add two points on elliptic curve."""
+        if self == INFINITY:
+            return other
+        if other == INFINITY:
+            return self
+        if isinstance(other, Point):
+            other = PointJacobi.from_affine(other)
+        if self.__curve != other.__curve:
+            raise ValueError("The other point is on different curve")
+
+        p = self.__curve.p()
+        X1, Y1, Z1 = self.__coords
+        X2, Y2, Z2 = other.__coords
+
+        X3, Y3, Z3 = self._add(X1, Y1, Z1, X2, Y2, Z2, p)
+
+        if not Y3 or not Z3:
+            return INFINITY
+        return PointJacobi(self.__curve, X3, Y3, Z3, self.__order)
+
+    def __rmul__(self, other):
+        """Multiply point by an integer."""
+        return self * other
+
+    def _mul_precompute(self, other):
+        """Multiply point by integer with precomputation table."""
+        X3, Y3, Z3, p = 0, 0, 1, self.__curve.p()
+        _add = self._add
+        for X2, Y2 in self.__precompute:
+            if other % 2:
+                if other % 4 >= 2:
+                    other = (other + 1) // 2
+                    X3, Y3, Z3 = _add(X3, Y3, Z3, X2, -Y2, 1, p)
+                else:
+                    other = (other - 1) // 2
+                    X3, Y3, Z3 = _add(X3, Y3, Z3, X2, Y2, 1, p)
+            else:
+                other //= 2
+
+        if not Y3 or not Z3:
+            return INFINITY
+        return PointJacobi(self.__curve, X3, Y3, Z3, self.__order)
+
+    def __mul__(self, other):
+        """Multiply point by an integer."""
+        if not self.__coords[1] or not other:
+            return INFINITY
+        if other == 1:
+            return self
+        if self.__order:
+            # order*2 as a protection for Minerva
+            other = other % (self.__order * 2)
+        self._maybe_precompute()
+        if self.__precompute:
+            return self._mul_precompute(other)
+
+        self = self.scale()
+        X2, Y2, _ = self.__coords
+        X3, Y3, Z3 = 0, 0, 1
+        p, a = self.__curve.p(), self.__curve.a()
+        _double = self._double
+        _add = self._add
+        # since adding points when at least one of them is scaled
+        # is quicker, reverse the NAF order
+        for i in reversed(self._naf(other)):
+            X3, Y3, Z3 = _double(X3, Y3, Z3, p, a)
+            if i < 0:
+                X3, Y3, Z3 = _add(X3, Y3, Z3, X2, -Y2, 1, p)
+            elif i > 0:
+                X3, Y3, Z3 = _add(X3, Y3, Z3, X2, Y2, 1, p)
+
+        if not Y3 or not Z3:
+            return INFINITY
+
+        return PointJacobi(self.__curve, X3, Y3, Z3, self.__order)
+
+    def mul_add(self, self_mul, other, other_mul):
+        """
+        Do two multiplications at the same time, add results.
+
+        calculates self*self_mul + other*other_mul
+        """
+        if other == INFINITY or other_mul == 0:
+            return self * self_mul
+        if self_mul == 0:
+            return other * other_mul
+        if not isinstance(other, PointJacobi):
+            other = PointJacobi.from_affine(other)
+        # when the points have precomputed answers, then multiplying them alone
+        # is faster (as it uses NAF and no point doublings)
+        self._maybe_precompute()
+        other._maybe_precompute()
+        if self.__precompute and other.__precompute:
+            return self * self_mul + other * other_mul
+
+        if self.__order:
+            self_mul = self_mul % self.__order
+            other_mul = other_mul % self.__order
+
+        # (X3, Y3, Z3) is the accumulator
+        X3, Y3, Z3 = 0, 0, 1
+        p, a = self.__curve.p(), self.__curve.a()
+
+        # as we have 6 unique points to work with, we can't scale all of them,
+        # but do scale the ones that are used most often
+        self.scale()
+        X1, Y1, Z1 = self.__coords
+        other.scale()
+        X2, Y2, Z2 = other.__coords
+
+        _double = self._double
+        _add = self._add
+
+        # with NAF we have 3 options: no add, subtract, add
+        # so with 2 points, we have 9 combinations:
+        # 0, -A, +A, -B, -A-B, +A-B, +B, -A+B, +A+B
+        # so we need 4 combined points:
+        mAmB_X, mAmB_Y, mAmB_Z = _add(X1, -Y1, Z1, X2, -Y2, Z2, p)
+        pAmB_X, pAmB_Y, pAmB_Z = _add(X1, Y1, Z1, X2, -Y2, Z2, p)
+        mApB_X, mApB_Y, mApB_Z = _add(X1, -Y1, Z1, X2, Y2, Z2, p)
+        pApB_X, pApB_Y, pApB_Z = _add(X1, Y1, Z1, X2, Y2, Z2, p)
+        # when the self and other sum to infinity, we need to add them
+        # one by one to get correct result but as that's very unlikely to
+        # happen in regular operation, we don't need to optimise this case
+        if not pApB_Y or not pApB_Z:
+            return self * self_mul + other * other_mul
+
+        # gmp object creation has cumulatively higher overhead than the
+        # speedup we get from calculating the NAF using gmp so ensure use
+        # of int()
+        self_naf = list(reversed(self._naf(int(self_mul))))
+        other_naf = list(reversed(self._naf(int(other_mul))))
+        # ensure that the lists are the same length (zip() will truncate
+        # longer one otherwise)
+        if len(self_naf) < len(other_naf):
+            self_naf = [0] * (len(other_naf) - len(self_naf)) + self_naf
+        elif len(self_naf) > len(other_naf):
+            other_naf = [0] * (len(self_naf) - len(other_naf)) + other_naf
+
+        for A, B in zip(self_naf, other_naf):
+            X3, Y3, Z3 = _double(X3, Y3, Z3, p, a)
+
+            # conditions ordered from most to least likely
+            if A == 0:
+                if B == 0:
+                    pass
+                elif B < 0:
+                    X3, Y3, Z3 = _add(X3, Y3, Z3, X2, -Y2, Z2, p)
+                else:
+                    assert B > 0
+                    X3, Y3, Z3 = _add(X3, Y3, Z3, X2, Y2, Z2, p)
+            elif A < 0:
+                if B == 0:
+                    X3, Y3, Z3 = _add(X3, Y3, Z3, X1, -Y1, Z1, p)
+                elif B < 0:
+                    X3, Y3, Z3 = _add(X3, Y3, Z3, mAmB_X, mAmB_Y, mAmB_Z, p)
+                else:
+                    assert B > 0
+                    X3, Y3, Z3 = _add(X3, Y3, Z3, mApB_X, mApB_Y, mApB_Z, p)
+            else:
+                assert A > 0
+                if B == 0:
+                    X3, Y3, Z3 = _add(X3, Y3, Z3, X1, Y1, Z1, p)
+                elif B < 0:
+                    X3, Y3, Z3 = _add(X3, Y3, Z3, pAmB_X, pAmB_Y, pAmB_Z, p)
+                else:
+                    assert B > 0
+                    X3, Y3, Z3 = _add(X3, Y3, Z3, pApB_X, pApB_Y, pApB_Z, p)
+
+        if not Y3 or not Z3:
+            return INFINITY
+
+        return PointJacobi(self.__curve, X3, Y3, Z3, self.__order)
+
+    def __neg__(self):
+        """Return negated point."""
+        x, y, z = self.__coords
+        return PointJacobi(self.__curve, x, -y, z, self.__order)
+
+
+class Point(AbstractPoint):
+    """A point on a short Weierstrass elliptic curve. Altering x and y is
+    forbidden, but they can be read by the x() and y() methods."""
+
+    def __init__(self, curve, x, y, order=None):
+        """curve, x, y, order; order (optional) is the order of this point."""
+        super(Point, self).__init__()
+        self.__curve = curve
+        if GMPY:
+            self.__x = x and mpz(x)
+            self.__y = y and mpz(y)
+            self.__order = order and mpz(order)
+        else:
+            self.__x = x
+            self.__y = y
+            self.__order = order
+        # self.curve is allowed to be None only for INFINITY:
+        if self.__curve:
+            assert self.__curve.contains_point(x, y)
+        # for curves with cofactor 1, all points that are on the curve are
+        # scalar multiples of the base point, so performing multiplication is
+        # not necessary to verify that. See Section 3.2.2.1 of SEC 1 v2
+        if curve and curve.cofactor() != 1 and order:
+            assert self * order == INFINITY
+
+    @classmethod
+    def from_bytes(
+        cls,
+        curve,
+        data,
+        validate_encoding=True,
+        valid_encodings=None,
+        order=None,
+    ):
+        """
+        Initialise the object from byte encoding of a point.
+
+        The method does accept and automatically detect the type of point
+        encoding used. It supports the :term:`raw encoding`,
+        :term:`uncompressed`, :term:`compressed`, and :term:`hybrid` encodings.
+
+        :param data: single point encoding of the public key
+        :type data: :term:`bytes-like object`
+        :param curve: the curve on which the public key is expected to lay
+        :type curve: ~ecdsa.ellipticcurve.CurveFp
+        :param validate_encoding: whether to verify that the encoding of the
+            point is self-consistent, defaults to True, has effect only
+            on ``hybrid`` encoding
+        :type validate_encoding: bool
+        :param valid_encodings: list of acceptable point encoding formats,
+            supported ones are: :term:`uncompressed`, :term:`compressed`,
+            :term:`hybrid`, and :term:`raw encoding` (specified with ``raw``
+            name). All formats by default (specified with ``None``).
+        :type valid_encodings: :term:`set-like object`
+        :param int order: the point order, must be non zero when using
+            generator=True
+
+        :raises `~ecdsa.errors.MalformedPointError`: if the public point does
+            not lay on the curve or the encoding is invalid
+
+        :return: Point on curve
+        :rtype: Point
+        """
+        coord_x, coord_y = super(Point, cls).from_bytes(
+            curve, data, validate_encoding, valid_encodings
+        )
+        return Point(curve, coord_x, coord_y, order)
+
+    def __eq__(self, other):
+        """Return True if the points are identical, False otherwise.
+
+        Note: only points that lay on the same curve can be equal.
+        """
+        if isinstance(other, Point):
+            return (
+                self.__curve == other.__curve
+                and self.__x == other.__x
+                and self.__y == other.__y
+            )
+        return NotImplemented
+
+    def __ne__(self, other):
+        """Returns False if points are identical, True otherwise."""
+        return not self == other
+
+    def __neg__(self):
+        return Point(self.__curve, self.__x, self.__curve.p() - self.__y)
+
+    def __add__(self, other):
+        """Add one point to another point."""
+
+        # X9.62 B.3:
+
+        if not isinstance(other, Point):
+            return NotImplemented
+        if other == INFINITY:
+            return self
+        if self == INFINITY:
+            return other
+        assert self.__curve == other.__curve
+        if self.__x == other.__x:
+            if (self.__y + other.__y) % self.__curve.p() == 0:
+                return INFINITY
+            else:
+                return self.double()
+
+        p = self.__curve.p()
+
+        l = (
+            (other.__y - self.__y)
+            * numbertheory.inverse_mod(other.__x - self.__x, p)
+        ) % p
+
+        x3 = (l * l - self.__x - other.__x) % p
+        y3 = (l * (self.__x - x3) - self.__y) % p
+
+        return Point(self.__curve, x3, y3)
+
+    def __mul__(self, other):
+        """Multiply a point by an integer."""
+
+        def leftmost_bit(x):
+            assert x > 0
+            result = 1
+            while result <= x:
+                result = 2 * result
+            return result // 2
+
+        e = other
+        if e == 0 or (self.__order and e % self.__order == 0):
+            return INFINITY
+        if self == INFINITY:
+            return INFINITY
+        if e < 0:
+            return (-self) * (-e)
+
+        # From X9.62 D.3.2:
+
+        e3 = 3 * e
+        negative_self = Point(self.__curve, self.__x, -self.__y, self.__order)
+        i = leftmost_bit(e3) // 2
+        result = self
+        # print_("Multiplying %s by %d (e3 = %d):" % (self, other, e3))
+        while i > 1:
+            result = result.double()
+            if (e3 & i) != 0 and (e & i) == 0:
+                result = result + self
+            if (e3 & i) == 0 and (e & i) != 0:
+                result = result + negative_self
+            # print_(". . . i = %d, result = %s" % ( i, result ))
+            i = i // 2
+
+        return result
+
+    def __rmul__(self, other):
+        """Multiply a point by an integer."""
+
+        return self * other
+
+    def __str__(self):
+        if self == INFINITY:
+            return "infinity"
+        return "(%d,%d)" % (self.__x, self.__y)
+
+    def double(self):
+        """Return a new point that is twice the old."""
+
+        if self == INFINITY:
+            return INFINITY
+
+        # X9.62 B.3:
+
+        p = self.__curve.p()
+        a = self.__curve.a()
+
+        l = (
+            (3 * self.__x * self.__x + a)
+            * numbertheory.inverse_mod(2 * self.__y, p)
+        ) % p
+
+        x3 = (l * l - 2 * self.__x) % p
+        y3 = (l * (self.__x - x3) - self.__y) % p
+
+        return Point(self.__curve, x3, y3)
+
+    def x(self):
+        return self.__x
+
+    def y(self):
+        return self.__y
+
+    def curve(self):
+        return self.__curve
+
+    def order(self):
+        return self.__order
+
+
+class PointEdwards(AbstractPoint):
+    """Point on Twisted Edwards curve.
+
+    Internally represents the coordinates on the curve using four parameters,
+    X, Y, Z, T. They correspond to affine parameters 'x' and 'y' like so:
+
+    x = X / Z
+    y = Y / Z
+    x*y = T / Z
+    """
+
+    def __init__(self, curve, x, y, z, t, order=None, generator=False):
+        """
+        Initialise a point that uses the extended coordinates internally.
+        """
+        super(PointEdwards, self).__init__()
+        self.__curve = curve
+        if GMPY:  # pragma: no branch
+            self.__coords = (mpz(x), mpz(y), mpz(z), mpz(t))
+            self.__order = order and mpz(order)
+        else:  # pragma: no branch
+            self.__coords = (x, y, z, t)
+            self.__order = order
+        self.__generator = generator
+        self.__precompute = []
+
+    @classmethod
+    def from_bytes(
+        cls,
+        curve,
+        data,
+        validate_encoding=None,
+        valid_encodings=None,
+        order=None,
+        generator=False,
+    ):
+        """
+        Initialise the object from byte encoding of a point.
+
+        `validate_encoding` and `valid_encodings` are provided for
+        compatibility with Weierstrass curves, they are ignored for Edwards
+        points.
+
+        :param data: single point encoding of the public key
+        :type data: :term:`bytes-like object`
+        :param curve: the curve on which the public key is expected to lay
+        :type curve: ecdsa.ellipticcurve.CurveEdTw
+        :param None validate_encoding: Ignored, encoding is always validated
+        :param None valid_encodings: Ignored, there is just one encoding
+            supported
+        :param int order: the point order, must be non zero when using
+            generator=True
+        :param bool generator: Flag to mark the point as a curve generator,
+            this will cause the library to pre-compute some values to
+            make repeated usages of the point much faster
+
+        :raises `~ecdsa.errors.MalformedPointError`: if the public point does
+            not lay on the curve or the encoding is invalid
+
+        :return: Initialised point on an Edwards curve
+        :rtype: PointEdwards
+        """
+        coord_x, coord_y = super(PointEdwards, cls).from_bytes(
+            curve, data, validate_encoding, valid_encodings
+        )
+        return PointEdwards(
+            curve, coord_x, coord_y, 1, coord_x * coord_y, order, generator
+        )
+
+    def _maybe_precompute(self):
+        if not self.__generator or self.__precompute:
+            return self.__precompute
+
+        # since this code will execute just once, and it's fully deterministic,
+        # depend on atomicity of the last assignment to switch from empty
+        # self.__precompute to filled one and just ignore the unlikely
+        # situation when two threads execute it at the same time (as it won't
+        # lead to inconsistent __precompute)
+        order = self.__order
+        assert order
+        precompute = []
+        i = 1
+        order *= 2
+        coord_x, coord_y, coord_z, coord_t = self.__coords
+        prime = self.__curve.p()
+
+        doubler = PointEdwards(
+            self.__curve, coord_x, coord_y, coord_z, coord_t, order
+        )
+        # for "protection" against Minerva we need 1 or 2 more bits depending
+        # on order bit size, but it's easier to just calculate one
+        # point more always
+        order *= 4
+
+        while i < order:
+            doubler = doubler.scale()
+            coord_x, coord_y = doubler.x(), doubler.y()
+            coord_t = coord_x * coord_y % prime
+            precompute.append((coord_x, coord_y, coord_t))
+
+            i *= 2
+            doubler = doubler.double()
+
+        self.__precompute = precompute
+        return self.__precompute
+
+    def x(self):
+        """Return affine x coordinate."""
+        X1, _, Z1, _ = self.__coords
+        if Z1 == 1:
+            return X1
+        p = self.__curve.p()
+        z_inv = numbertheory.inverse_mod(Z1, p)
+        return X1 * z_inv % p
+
+    def y(self):
+        """Return affine y coordinate."""
+        _, Y1, Z1, _ = self.__coords
+        if Z1 == 1:
+            return Y1
+        p = self.__curve.p()
+        z_inv = numbertheory.inverse_mod(Z1, p)
+        return Y1 * z_inv % p
+
+    def curve(self):
+        """Return the curve of the point."""
+        return self.__curve
+
+    def order(self):
+        return self.__order
+
+    def scale(self):
+        """
+        Return point scaled so that z == 1.
+
+        Modifies point in place, returns self.
+        """
+        X1, Y1, Z1, _ = self.__coords
+        if Z1 == 1:
+            return self
+
+        p = self.__curve.p()
+        z_inv = numbertheory.inverse_mod(Z1, p)
+        x = X1 * z_inv % p
+        y = Y1 * z_inv % p
+        t = x * y % p
+        self.__coords = (x, y, 1, t)
+        return self
+
+    def __eq__(self, other):
+        """Compare for equality two points with each-other.
+
+        Note: only points on the same curve can be equal.
+        """
+        x1, y1, z1, t1 = self.__coords
+        if other is INFINITY:
+            return not x1 or not t1
+        if isinstance(other, PointEdwards):
+            x2, y2, z2, t2 = other.__coords
+        else:
+            return NotImplemented
+        if self.__curve != other.curve():
+            return False
+        p = self.__curve.p()
+
+        # cross multiply to eliminate divisions
+        xn1 = x1 * z2 % p
+        xn2 = x2 * z1 % p
+        yn1 = y1 * z2 % p
+        yn2 = y2 * z1 % p
+        return xn1 == xn2 and yn1 == yn2
+
+    def __ne__(self, other):
+        """Compare for inequality two points with each-other."""
+        return not self == other
+
+    def _add(self, X1, Y1, Z1, T1, X2, Y2, Z2, T2, p, a):
+        """add two points, assume sane parameters."""
+        # after add-2008-hwcd-2
+        # from https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html
+        # NOTE: there are more efficient formulas for Z1 or Z2 == 1
+        A = X1 * X2 % p
+        B = Y1 * Y2 % p
+        C = Z1 * T2 % p
+        D = T1 * Z2 % p
+        E = D + C
+        F = ((X1 - Y1) * (X2 + Y2) + B - A) % p
+        G = B + a * A
+        H = D - C
+        if not H:
+            return self._double(X1, Y1, Z1, T1, p, a)
+        X3 = E * F % p
+        Y3 = G * H % p
+        T3 = E * H % p
+        Z3 = F * G % p
+
+        return X3, Y3, Z3, T3
+
+    def __add__(self, other):
+        """Add point to another."""
+        if other == INFINITY:
+            return self
+        if (
+            not isinstance(other, PointEdwards)
+            or self.__curve != other.__curve
+        ):
+            raise ValueError("The other point is on a different curve.")
+
+        p, a = self.__curve.p(), self.__curve.a()
+        X1, Y1, Z1, T1 = self.__coords
+        X2, Y2, Z2, T2 = other.__coords
+
+        X3, Y3, Z3, T3 = self._add(X1, Y1, Z1, T1, X2, Y2, Z2, T2, p, a)
+
+        if not X3 or not T3:
+            return INFINITY
+        return PointEdwards(self.__curve, X3, Y3, Z3, T3, self.__order)
+
+    def __radd__(self, other):
+        """Add other to self."""
+        return self + other
+
+    def _double(self, X1, Y1, Z1, T1, p, a):
+        """Double the point, assume sane parameters."""
+        # after "dbl-2008-hwcd"
+        # from https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html
+        # NOTE: there are more efficient formulas for Z1 == 1
+        A = X1 * X1 % p
+        B = Y1 * Y1 % p
+        C = 2 * Z1 * Z1 % p
+        D = a * A % p
+        E = ((X1 + Y1) * (X1 + Y1) - A - B) % p
+        G = D + B
+        F = G - C
+        H = D - B
+        X3 = E * F % p
+        Y3 = G * H % p
+        T3 = E * H % p
+        Z3 = F * G % p
+
+        return X3, Y3, Z3, T3
+
+    def double(self):
+        """Return point added to itself."""
+        X1, Y1, Z1, T1 = self.__coords
+
+        if not X1 or not T1:
+            return INFINITY
+
+        p, a = self.__curve.p(), self.__curve.a()
+
+        X3, Y3, Z3, T3 = self._double(X1, Y1, Z1, T1, p, a)
+
+        if not X3 or not T3:
+            return INFINITY
+        return PointEdwards(self.__curve, X3, Y3, Z3, T3, self.__order)
+
+    def __rmul__(self, other):
+        """Multiply point by an integer."""
+        return self * other
+
+    def _mul_precompute(self, other):
+        """Multiply point by integer with precomputation table."""
+        X3, Y3, Z3, T3, p, a = 0, 1, 1, 0, self.__curve.p(), self.__curve.a()
+        _add = self._add
+        for X2, Y2, T2 in self.__precompute:
+            rem = other % 4
+            if rem == 0 or rem == 2:
+                other //= 2
+            elif rem == 3:
+                other = (other + 1) // 2
+                X3, Y3, Z3, T3 = _add(X3, Y3, Z3, T3, -X2, Y2, 1, -T2, p, a)
+            else:
+                assert rem == 1
+                other = (other - 1) // 2
+                X3, Y3, Z3, T3 = _add(X3, Y3, Z3, T3, X2, Y2, 1, T2, p, a)
+
+        if not X3 or not T3:
+            return INFINITY
+
+        return PointEdwards(self.__curve, X3, Y3, Z3, T3, self.__order)
+
+    def __mul__(self, other):
+        """Multiply point by an integer."""
+        X2, Y2, Z2, T2 = self.__coords
+        if not X2 or not T2 or not other:
+            return INFINITY
+        if other == 1:
+            return self
+        if self.__order:
+            # order*2 as a "protection" for Minerva
+            other = other % (self.__order * 2)
+        if self._maybe_precompute():
+            return self._mul_precompute(other)
+
+        X3, Y3, Z3, T3 = 0, 1, 1, 0  # INFINITY in extended coordinates
+        p, a = self.__curve.p(), self.__curve.a()
+        _double = self._double
+        _add = self._add
+
+        for i in reversed(self._naf(other)):
+            X3, Y3, Z3, T3 = _double(X3, Y3, Z3, T3, p, a)
+            if i < 0:
+                X3, Y3, Z3, T3 = _add(X3, Y3, Z3, T3, -X2, Y2, Z2, -T2, p, a)
+            elif i > 0:
+                X3, Y3, Z3, T3 = _add(X3, Y3, Z3, T3, X2, Y2, Z2, T2, p, a)
+
+        if not X3 or not T3:
+            return INFINITY
+
+        return PointEdwards(self.__curve, X3, Y3, Z3, T3, self.__order)
+
+
+# This one point is the Point At Infinity for all purposes:
+INFINITY = Point(None, None, None)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/errors.py b/myenv/lib/python3.9/site-packages/ecdsa/errors.py
new file mode 100644
index 0000000..0184c05
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/errors.py
@@ -0,0 +1,4 @@
+class MalformedPointError(AssertionError):
+    """Raised in case the encoding of private or public key is malformed."""
+
+    pass
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/keys.py b/myenv/lib/python3.9/site-packages/ecdsa/keys.py
new file mode 100644
index 0000000..2b7d316
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/keys.py
@@ -0,0 +1,1612 @@
+"""
+Primary classes for performing signing and verification operations.
+"""
+
+import binascii
+from hashlib import sha1
+import os
+from six import PY2, b
+from . import ecdsa, eddsa
+from . import der
+from . import rfc6979
+from . import ellipticcurve
+from .curves import NIST192p, Curve, Ed25519, Ed448
+from .ecdsa import RSZeroError
+from .util import string_to_number, number_to_string, randrange
+from .util import sigencode_string, sigdecode_string, bit_length
+from .util import (
+    oid_ecPublicKey,
+    encoded_oid_ecPublicKey,
+    oid_ecDH,
+    oid_ecMQV,
+    MalformedSignature,
+)
+from ._compat import normalise_bytes
+from .errors import MalformedPointError
+from .ellipticcurve import PointJacobi, CurveEdTw
+
+
+__all__ = [
+    "BadSignatureError",
+    "BadDigestError",
+    "VerifyingKey",
+    "SigningKey",
+    "MalformedPointError",
+]
+
+
+class BadSignatureError(Exception):
+    """
+    Raised when verification of signature failed.
+
+    Will be raised irrespective of reason of the failure:
+
+    * the calculated or provided hash does not match the signature
+    * the signature does not match the curve/public key
+    * the encoding of the signature is malformed
+    * the size of the signature does not match the curve of the VerifyingKey
+    """
+
+    pass
+
+
+class BadDigestError(Exception):
+    """Raised in case the selected hash is too large for the curve."""
+
+    pass
+
+
+def _truncate_and_convert_digest(digest, curve, allow_truncate):
+    """Truncates and converts digest to an integer."""
+    if not allow_truncate:
+        if len(digest) > curve.baselen:
+            raise BadDigestError(
+                "this curve ({0}) is too short "
+                "for the length of your digest ({1})".format(
+                    curve.name, 8 * len(digest)
+                )
+            )
+    else:
+        digest = digest[: curve.baselen]
+    number = string_to_number(digest)
+    if allow_truncate:
+        max_length = bit_length(curve.order)
+        # we don't use bit_length(number) as that truncates leading zeros
+        length = len(digest) * 8
+
+        # See NIST FIPS 186-4:
+        #
+        # When the length of the output of the hash function is greater
+        # than N (i.e., the bit length of q), then the leftmost N bits of
+        # the hash function output block shall be used in any calculation
+        # using the hash function output during the generation or
+        # verification of a digital signature.
+        #
+        # as such, we need to shift-out the low-order bits:
+        number >>= max(0, length - max_length)
+
+    return number
+
+
+class VerifyingKey(object):
+    """
+    Class for handling keys that can verify signatures (public keys).
+
+    :ivar `~ecdsa.curves.Curve` ~.curve: The Curve over which all the
+        cryptographic operations will take place
+    :ivar default_hashfunc: the function that will be used for hashing the
+        data. Should implement the same API as hashlib.sha1
+    :vartype default_hashfunc: callable
+    :ivar pubkey: the actual public key
+    :vartype pubkey: ~ecdsa.ecdsa.Public_key
+    """
+
+    def __init__(self, _error__please_use_generate=None):
+        """Unsupported, please use one of the classmethods to initialise."""
+        if not _error__please_use_generate:
+            raise TypeError(
+                "Please use VerifyingKey.generate() to construct me"
+            )
+        self.curve = None
+        self.default_hashfunc = None
+        self.pubkey = None
+
+    def __repr__(self):
+        pub_key = self.to_string("compressed")
+        if self.default_hashfunc:
+            hash_name = self.default_hashfunc().name
+        else:
+            hash_name = "None"
+        return "VerifyingKey.from_string({0!r}, {1!r}, {2})".format(
+            pub_key, self.curve, hash_name
+        )
+
+    def __eq__(self, other):
+        """Return True if the points are identical, False otherwise."""
+        if isinstance(other, VerifyingKey):
+            return self.curve == other.curve and self.pubkey == other.pubkey
+        return NotImplemented
+
+    def __ne__(self, other):
+        """Return False if the points are identical, True otherwise."""
+        return not self == other
+
+    @classmethod
+    def from_public_point(
+        cls, point, curve=NIST192p, hashfunc=sha1, validate_point=True
+    ):
+        """
+        Initialise the object from a Point object.
+
+        This is a low-level method, generally you will not want to use it.
+
+        :param point: The point to wrap around, the actual public key
+        :type point: ~ecdsa.ellipticcurve.AbstractPoint
+        :param curve: The curve on which the point needs to reside, defaults
+            to NIST192p
+        :type curve: ~ecdsa.curves.Curve
+        :param hashfunc: The default hash function that will be used for
+            verification, needs to implement the same interface
+            as :py:class:`hashlib.sha1`
+        :type hashfunc: callable
+        :type bool validate_point: whether to check if the point lays on curve
+            should always be used if the public point is not a result
+            of our own calculation
+
+        :raises MalformedPointError: if the public point does not lay on the
+            curve
+
+        :return: Initialised VerifyingKey object
+        :rtype: VerifyingKey
+        """
+        self = cls(_error__please_use_generate=True)
+        if isinstance(curve.curve, CurveEdTw):
+            raise ValueError("Method incompatible with Edwards curves")
+        if not isinstance(point, ellipticcurve.PointJacobi):
+            point = ellipticcurve.PointJacobi.from_affine(point)
+        self.curve = curve
+        self.default_hashfunc = hashfunc
+        try:
+            self.pubkey = ecdsa.Public_key(
+                curve.generator, point, validate_point
+            )
+        except ecdsa.InvalidPointError:
+            raise MalformedPointError("Point does not lay on the curve")
+        self.pubkey.order = curve.order
+        return self
+
+    def precompute(self, lazy=False):
+        """
+        Precompute multiplication tables for faster signature verification.
+
+        Calling this method will cause the library to precompute the
+        scalar multiplication tables, used in signature verification.
+        While it's an expensive operation (comparable to performing
+        as many signatures as the bit size of the curve, i.e. 256 for NIST256p)
+        it speeds up verification 2 times. You should call this method
+        if you expect to verify hundreds of signatures (or more) using the same
+        VerifyingKey object.
+
+        Note: You should call this method only once, this method generates a
+        new precomputation table every time it's called.
+
+        :param bool lazy: whether to calculate the precomputation table now
+           (if set to False) or if it should be delayed to the time of first
+           use (when set to True)
+        """
+        if isinstance(self.curve.curve, CurveEdTw):
+            pt = self.pubkey.point
+            self.pubkey.point = ellipticcurve.PointEdwards(
+                pt.curve(),
+                pt.x(),
+                pt.y(),
+                1,
+                pt.x() * pt.y(),
+                self.curve.order,
+                generator=True,
+            )
+        else:
+            self.pubkey.point = ellipticcurve.PointJacobi.from_affine(
+                self.pubkey.point, True
+            )
+        # as precomputation in now delayed to the time of first use of the
+        # point and we were asked specifically to precompute now, make
+        # sure the precomputation is performed now to preserve the behaviour
+        if not lazy:
+            self.pubkey.point * 2
+
+    @classmethod
+    def from_string(
+        cls,
+        string,
+        curve=NIST192p,
+        hashfunc=sha1,
+        validate_point=True,
+        valid_encodings=None,
+    ):
+        """
+        Initialise the object from byte encoding of public key.
+
+        The method does accept and automatically detect the type of point
+        encoding used. It supports the :term:`raw encoding`,
+        :term:`uncompressed`, :term:`compressed`, and :term:`hybrid` encodings.
+        It also works with the native encoding of Ed25519 and Ed448 public
+        keys (technically those are compressed, but encoded differently than
+        in other signature systems).
+
+        Note, while the method is named "from_string" it's a misnomer from
+        Python 2 days when there were no binary strings. In Python 3 the
+        input needs to be a bytes-like object.
+
+        :param string: single point encoding of the public key
+        :type string: :term:`bytes-like object`
+        :param curve: the curve on which the public key is expected to lay
+        :type curve: ~ecdsa.curves.Curve
+        :param hashfunc: The default hash function that will be used for
+            verification, needs to implement the same interface as
+            hashlib.sha1. Ignored for EdDSA.
+        :type hashfunc: callable
+        :param validate_point: whether to verify that the point lays on the
+            provided curve or not, defaults to True. Ignored for EdDSA.
+        :type validate_point: bool
+        :param valid_encodings: list of acceptable point encoding formats,
+            supported ones are: :term:`uncompressed`, :term:`compressed`,
+            :term:`hybrid`, and :term:`raw encoding` (specified with ``raw``
+            name). All formats by default (specified with ``None``).
+            Ignored for EdDSA.
+        :type valid_encodings: :term:`set-like object`
+
+        :raises MalformedPointError: if the public point does not lay on the
+            curve or the encoding is invalid
+
+        :return: Initialised VerifyingKey object
+        :rtype: VerifyingKey
+        """
+        if isinstance(curve.curve, CurveEdTw):
+            self = cls(_error__please_use_generate=True)
+            self.curve = curve
+            self.default_hashfunc = None  # ignored for EdDSA
+            try:
+                self.pubkey = eddsa.PublicKey(curve.generator, string)
+            except ValueError:
+                raise MalformedPointError("Malformed point for the curve")
+            return self
+
+        point = PointJacobi.from_bytes(
+            curve.curve,
+            string,
+            validate_encoding=validate_point,
+            valid_encodings=valid_encodings,
+        )
+        return cls.from_public_point(point, curve, hashfunc, validate_point)
+
+    @classmethod
+    def from_pem(
+        cls,
+        string,
+        hashfunc=sha1,
+        valid_encodings=None,
+        valid_curve_encodings=None,
+    ):
+        """
+        Initialise from public key stored in :term:`PEM` format.
+
+        The PEM header of the key should be ``BEGIN PUBLIC KEY``.
+
+        See the :func:`~VerifyingKey.from_der()` method for details of the
+        format supported.
+
+        Note: only a single PEM object decoding is supported in provided
+        string.
+
+        :param string: text with PEM-encoded public ECDSA key
+        :type string: str
+        :param valid_encodings: list of allowed point encodings.
+            By default :term:`uncompressed`, :term:`compressed`, and
+            :term:`hybrid`. To read malformed files, include
+            :term:`raw encoding` with ``raw`` in the list.
+        :type valid_encodings: :term:`set-like object`
+        :param valid_curve_encodings: list of allowed encoding formats
+            for curve parameters. By default (``None``) all are supported:
+            ``named_curve`` and ``explicit``.
+        :type valid_curve_encodings: :term:`set-like object`
+
+
+        :return: Initialised VerifyingKey object
+        :rtype: VerifyingKey
+        """
+        return cls.from_der(
+            der.unpem(string),
+            hashfunc=hashfunc,
+            valid_encodings=valid_encodings,
+            valid_curve_encodings=valid_curve_encodings,
+        )
+
+    @classmethod
+    def from_der(
+        cls,
+        string,
+        hashfunc=sha1,
+        valid_encodings=None,
+        valid_curve_encodings=None,
+    ):
+        """
+        Initialise the key stored in :term:`DER` format.
+
+        The expected format of the key is the SubjectPublicKeyInfo structure
+        from RFC5912 (for RSA keys, it's known as the PKCS#1 format)::
+
+           SubjectPublicKeyInfo {PUBLIC-KEY: IOSet} ::= SEQUENCE {
+               algorithm        AlgorithmIdentifier {PUBLIC-KEY, {IOSet}},
+               subjectPublicKey BIT STRING
+           }
+
+        Note: only public EC keys are supported by this method. The
+        SubjectPublicKeyInfo.algorithm.algorithm field must specify
+        id-ecPublicKey (see RFC3279).
+
+        Only the named curve encoding is supported, thus the
+        SubjectPublicKeyInfo.algorithm.parameters field needs to be an
+        object identifier. A sequence in that field indicates an explicit
+        parameter curve encoding, this format is not supported. A NULL object
+        in that field indicates an "implicitlyCA" encoding, where the curve
+        parameters come from CA certificate, those, again, are not supported.
+
+        :param string: binary string with the DER encoding of public ECDSA key
+        :type string: bytes-like object
+        :param valid_encodings: list of allowed point encodings.
+            By default :term:`uncompressed`, :term:`compressed`, and
+            :term:`hybrid`. To read malformed files, include
+            :term:`raw encoding` with ``raw`` in the list.
+        :type valid_encodings: :term:`set-like object`
+        :param valid_curve_encodings: list of allowed encoding formats
+            for curve parameters. By default (``None``) all are supported:
+            ``named_curve`` and ``explicit``.
+        :type valid_curve_encodings: :term:`set-like object`
+
+        :return: Initialised VerifyingKey object
+        :rtype: VerifyingKey
+        """
+        if valid_encodings is None:
+            valid_encodings = set(["uncompressed", "compressed", "hybrid"])
+        string = normalise_bytes(string)
+        # [[oid_ecPublicKey,oid_curve], point_str_bitstring]
+        s1, empty = der.remove_sequence(string)
+        if empty != b"":
+            raise der.UnexpectedDER(
+                "trailing junk after DER pubkey: %s" % binascii.hexlify(empty)
+            )
+        s2, point_str_bitstring = der.remove_sequence(s1)
+        # s2 = oid_ecPublicKey,oid_curve
+        oid_pk, rest = der.remove_object(s2)
+        if oid_pk in (Ed25519.oid, Ed448.oid):
+            if oid_pk == Ed25519.oid:
+                curve = Ed25519
+            else:
+                assert oid_pk == Ed448.oid
+                curve = Ed448
+            point_str, empty = der.remove_bitstring(point_str_bitstring, 0)
+            if empty:
+                raise der.UnexpectedDER("trailing junk after public key")
+            return cls.from_string(point_str, curve, None)
+        if not oid_pk == oid_ecPublicKey:
+            raise der.UnexpectedDER(
+                "Unexpected object identifier in DER "
+                "encoding: {0!r}".format(oid_pk)
+            )
+        curve = Curve.from_der(rest, valid_curve_encodings)
+        point_str, empty = der.remove_bitstring(point_str_bitstring, 0)
+        if empty != b"":
+            raise der.UnexpectedDER(
+                "trailing junk after pubkey pointstring: %s"
+                % binascii.hexlify(empty)
+            )
+        # raw encoding of point is invalid in DER files
+        if len(point_str) == curve.verifying_key_length:
+            raise der.UnexpectedDER("Malformed encoding of public point")
+        return cls.from_string(
+            point_str,
+            curve,
+            hashfunc=hashfunc,
+            valid_encodings=valid_encodings,
+        )
+
+    @classmethod
+    def from_public_key_recovery(
+        cls,
+        signature,
+        data,
+        curve,
+        hashfunc=sha1,
+        sigdecode=sigdecode_string,
+        allow_truncate=True,
+    ):
+        """
+        Return keys that can be used as verifiers of the provided signature.
+
+        Tries to recover the public key that can be used to verify the
+        signature, usually returns two keys like that.
+
+        :param signature: the byte string with the encoded signature
+        :type signature: bytes-like object
+        :param data: the data to be hashed for signature verification
+        :type data: bytes-like object
+        :param curve: the curve over which the signature was performed
+        :type curve: ~ecdsa.curves.Curve
+        :param hashfunc: The default hash function that will be used for
+            verification, needs to implement the same interface as hashlib.sha1
+        :type hashfunc: callable
+        :param sigdecode: Callable to define the way the signature needs to
+            be decoded to an object, needs to handle `signature` as the
+            first parameter, the curve order (an int) as the second and return
+            a tuple with two integers, "r" as the first one and "s" as the
+            second one. See :func:`ecdsa.util.sigdecode_string` and
+            :func:`ecdsa.util.sigdecode_der` for examples.
+        :param bool allow_truncate: if True, the provided hashfunc can generate
+            values larger than the bit size of the order of the curve, the
+            extra bits (at the end of the digest) will be truncated.
+        :type sigdecode: callable
+
+        :return: Initialised VerifyingKey objects
+        :rtype: list of VerifyingKey
+        """
+        if isinstance(curve.curve, CurveEdTw):
+            raise ValueError("Method unsupported for Edwards curves")
+        data = normalise_bytes(data)
+        digest = hashfunc(data).digest()
+        return cls.from_public_key_recovery_with_digest(
+            signature,
+            digest,
+            curve,
+            hashfunc=hashfunc,
+            sigdecode=sigdecode,
+            allow_truncate=allow_truncate,
+        )
+
+    @classmethod
+    def from_public_key_recovery_with_digest(
+        cls,
+        signature,
+        digest,
+        curve,
+        hashfunc=sha1,
+        sigdecode=sigdecode_string,
+        allow_truncate=False,
+    ):
+        """
+        Return keys that can be used as verifiers of the provided signature.
+
+        Tries to recover the public key that can be used to verify the
+        signature, usually returns two keys like that.
+
+        :param signature: the byte string with the encoded signature
+        :type signature: bytes-like object
+        :param digest: the hash value of the message signed by the signature
+        :type digest: bytes-like object
+        :param curve: the curve over which the signature was performed
+        :type curve: ~ecdsa.curves.Curve
+        :param hashfunc: The default hash function that will be used for
+            verification, needs to implement the same interface as hashlib.sha1
+        :type hashfunc: callable
+        :param sigdecode: Callable to define the way the signature needs to
+            be decoded to an object, needs to handle `signature` as the
+            first parameter, the curve order (an int) as the second and return
+            a tuple with two integers, "r" as the first one and "s" as the
+            second one. See :func:`ecdsa.util.sigdecode_string` and
+            :func:`ecdsa.util.sigdecode_der` for examples.
+        :type sigdecode: callable
+        :param bool allow_truncate: if True, the provided hashfunc can generate
+            values larger than the bit size of the order of the curve (and
+            the length of provided `digest`), the extra bits (at the end of the
+            digest) will be truncated.
+
+        :return: Initialised VerifyingKey object
+        :rtype: VerifyingKey
+        """
+        if isinstance(curve.curve, CurveEdTw):
+            raise ValueError("Method unsupported for Edwards curves")
+        generator = curve.generator
+        r, s = sigdecode(signature, generator.order())
+        sig = ecdsa.Signature(r, s)
+
+        digest = normalise_bytes(digest)
+        digest_as_number = _truncate_and_convert_digest(
+            digest, curve, allow_truncate
+        )
+        pks = sig.recover_public_keys(digest_as_number, generator)
+
+        # Transforms the ecdsa.Public_key object into a VerifyingKey
+        verifying_keys = [
+            cls.from_public_point(pk.point, curve, hashfunc) for pk in pks
+        ]
+        return verifying_keys
+
+    def to_string(self, encoding="raw"):
+        """
+        Convert the public key to a byte string.
+
+        The method by default uses the :term:`raw encoding` (specified
+        by `encoding="raw"`. It can also output keys in :term:`uncompressed`,
+        :term:`compressed` and :term:`hybrid` formats.
+
+        Remember that the curve identification is not part of the encoding
+        so to decode the point using :func:`~VerifyingKey.from_string`, curve
+        needs to be specified.
+
+        Note: while the method is called "to_string", it's a misnomer from
+        Python 2 days when character strings and byte strings shared type.
+        On Python 3 the returned type will be `bytes`.
+
+        :return: :term:`raw encoding` of the public key (public point) on the
+            curve
+        :rtype: bytes
+        """
+        assert encoding in ("raw", "uncompressed", "compressed", "hybrid")
+        return self.pubkey.point.to_bytes(encoding)
+
+    def to_pem(
+        self, point_encoding="uncompressed", curve_parameters_encoding=None
+    ):
+        """
+        Convert the public key to the :term:`PEM` format.
+
+        The PEM header of the key will be ``BEGIN PUBLIC KEY``.
+
+        The format of the key is described in the
+        :func:`~VerifyingKey.from_der()` method.
+        This method supports only "named curve" encoding of keys.
+
+        :param str point_encoding: specification of the encoding format
+            of public keys. "uncompressed" is most portable, "compressed" is
+            smallest. "hybrid" is uncommon and unsupported by most
+            implementations, it is as big as "uncompressed".
+        :param str curve_parameters_encoding: the encoding for curve parameters
+            to use, by default tries to use ``named_curve`` encoding,
+            if that is not possible, falls back to ``explicit`` encoding.
+
+        :return: portable encoding of the public key
+        :rtype: bytes
+
+        .. warning:: The PEM is encoded to US-ASCII, it needs to be
+            re-encoded if the system is incompatible (e.g. uses UTF-16)
+        """
+        return der.topem(
+            self.to_der(point_encoding, curve_parameters_encoding),
+            "PUBLIC KEY",
+        )
+
+    def to_der(
+        self, point_encoding="uncompressed", curve_parameters_encoding=None
+    ):
+        """
+        Convert the public key to the :term:`DER` format.
+
+        The format of the key is described in the
+        :func:`~VerifyingKey.from_der()` method.
+        This method supports only "named curve" encoding of keys.
+
+        :param str point_encoding: specification of the encoding format
+            of public keys. "uncompressed" is most portable, "compressed" is
+            smallest. "hybrid" is uncommon and unsupported by most
+            implementations, it is as big as "uncompressed".
+        :param str curve_parameters_encoding: the encoding for curve parameters
+            to use, by default tries to use ``named_curve`` encoding,
+            if that is not possible, falls back to ``explicit`` encoding.
+
+        :return: DER encoding of the public key
+        :rtype: bytes
+        """
+        if point_encoding == "raw":
+            raise ValueError("raw point_encoding not allowed in DER")
+        point_str = self.to_string(point_encoding)
+        if isinstance(self.curve.curve, CurveEdTw):
+            return der.encode_sequence(
+                der.encode_sequence(der.encode_oid(*self.curve.oid)),
+                der.encode_bitstring(bytes(point_str), 0),
+            )
+        return der.encode_sequence(
+            der.encode_sequence(
+                encoded_oid_ecPublicKey,
+                self.curve.to_der(curve_parameters_encoding, point_encoding),
+            ),
+            # 0 is the number of unused bits in the
+            # bit string
+            der.encode_bitstring(point_str, 0),
+        )
+
+    def verify(
+        self,
+        signature,
+        data,
+        hashfunc=None,
+        sigdecode=sigdecode_string,
+        allow_truncate=True,
+    ):
+        """
+        Verify a signature made over provided data.
+
+        Will hash `data` to verify the signature.
+
+        By default expects signature in :term:`raw encoding`. Can also be used
+        to verify signatures in ASN.1 DER encoding by using
+        :func:`ecdsa.util.sigdecode_der`
+        as the `sigdecode` parameter.
+
+        :param signature: encoding of the signature
+        :type signature: sigdecode method dependent
+        :param data: data signed by the `signature`, will be hashed using
+            `hashfunc`, if specified, or default hash function
+        :type data: :term:`bytes-like object`
+        :param hashfunc: The default hash function that will be used for
+            verification, needs to implement the same interface as hashlib.sha1
+        :type hashfunc: callable
+        :param sigdecode: Callable to define the way the signature needs to
+            be decoded to an object, needs to handle `signature` as the
+            first parameter, the curve order (an int) as the second and return
+            a tuple with two integers, "r" as the first one and "s" as the
+            second one. See :func:`ecdsa.util.sigdecode_string` and
+            :func:`ecdsa.util.sigdecode_der` for examples.
+        :type sigdecode: callable
+        :param bool allow_truncate: if True, the provided digest can have
+            bigger bit-size than the order of the curve, the extra bits (at
+            the end of the digest) will be truncated. Use it when verifying
+            SHA-384 output using NIST256p or in similar situations. Defaults to
+            True.
+
+        :raises BadSignatureError: if the signature is invalid or malformed
+
+        :return: True if the verification was successful
+        :rtype: bool
+        """
+        # signature doesn't have to be a bytes-like-object so don't normalise
+        # it, the decoders will do that
+        data = normalise_bytes(data)
+        if isinstance(self.curve.curve, CurveEdTw):
+            signature = normalise_bytes(signature)
+            try:
+                return self.pubkey.verify(data, signature)
+            except (ValueError, MalformedPointError) as e:
+                raise BadSignatureError("Signature verification failed", e)
+
+        hashfunc = hashfunc or self.default_hashfunc
+        digest = hashfunc(data).digest()
+        return self.verify_digest(signature, digest, sigdecode, allow_truncate)
+
+    def verify_digest(
+        self,
+        signature,
+        digest,
+        sigdecode=sigdecode_string,
+        allow_truncate=False,
+    ):
+        """
+        Verify a signature made over provided hash value.
+
+        By default expects signature in :term:`raw encoding`. Can also be used
+        to verify signatures in ASN.1 DER encoding by using
+        :func:`ecdsa.util.sigdecode_der`
+        as the `sigdecode` parameter.
+
+        :param signature: encoding of the signature
+        :type signature: sigdecode method dependent
+        :param digest: raw hash value that the signature authenticates.
+        :type digest: :term:`bytes-like object`
+        :param sigdecode: Callable to define the way the signature needs to
+            be decoded to an object, needs to handle `signature` as the
+            first parameter, the curve order (an int) as the second and return
+            a tuple with two integers, "r" as the first one and "s" as the
+            second one. See :func:`ecdsa.util.sigdecode_string` and
+            :func:`ecdsa.util.sigdecode_der` for examples.
+        :type sigdecode: callable
+        :param bool allow_truncate: if True, the provided digest can have
+            bigger bit-size than the order of the curve, the extra bits (at
+            the end of the digest) will be truncated. Use it when verifying
+            SHA-384 output using NIST256p or in similar situations.
+
+        :raises BadSignatureError: if the signature is invalid or malformed
+        :raises BadDigestError: if the provided digest is too big for the curve
+            associated with this VerifyingKey and allow_truncate was not set
+
+        :return: True if the verification was successful
+        :rtype: bool
+        """
+        # signature doesn't have to be a bytes-like-object so don't normalise
+        # it, the decoders will do that
+        digest = normalise_bytes(digest)
+        number = _truncate_and_convert_digest(
+            digest,
+            self.curve,
+            allow_truncate,
+        )
+
+        try:
+            r, s = sigdecode(signature, self.pubkey.order)
+        except (der.UnexpectedDER, MalformedSignature) as e:
+            raise BadSignatureError("Malformed formatting of signature", e)
+        sig = ecdsa.Signature(r, s)
+        if self.pubkey.verifies(number, sig):
+            return True
+        raise BadSignatureError("Signature verification failed")
+
+
+class SigningKey(object):
+    """
+    Class for handling keys that can create signatures (private keys).
+
+    :ivar `~ecdsa.curves.Curve` curve: The Curve over which all the
+        cryptographic operations will take place
+    :ivar default_hashfunc: the function that will be used for hashing the
+        data. Should implement the same API as :py:class:`hashlib.sha1`
+    :ivar int baselen: the length of a :term:`raw encoding` of private key
+    :ivar `~ecdsa.keys.VerifyingKey` verifying_key: the public key
+        associated with this private key
+    :ivar `~ecdsa.ecdsa.Private_key` privkey: the actual private key
+    """
+
+    def __init__(self, _error__please_use_generate=None):
+        """Unsupported, please use one of the classmethods to initialise."""
+        if not _error__please_use_generate:
+            raise TypeError("Please use SigningKey.generate() to construct me")
+        self.curve = None
+        self.default_hashfunc = None
+        self.baselen = None
+        self.verifying_key = None
+        self.privkey = None
+
+    def __eq__(self, other):
+        """Return True if the points are identical, False otherwise."""
+        if isinstance(other, SigningKey):
+            return (
+                self.curve == other.curve
+                and self.verifying_key == other.verifying_key
+                and self.privkey == other.privkey
+            )
+        return NotImplemented
+
+    def __ne__(self, other):
+        """Return False if the points are identical, True otherwise."""
+        return not self == other
+
+    @classmethod
+    def _twisted_edwards_keygen(cls, curve, entropy):
+        """Generate a private key on a Twisted Edwards curve."""
+        if not entropy:
+            entropy = os.urandom
+        random = entropy(curve.baselen)
+        private_key = eddsa.PrivateKey(curve.generator, random)
+        public_key = private_key.public_key()
+
+        verifying_key = VerifyingKey.from_string(
+            public_key.public_key(), curve
+        )
+
+        self = cls(_error__please_use_generate=True)
+        self.curve = curve
+        self.default_hashfunc = None
+        self.baselen = curve.baselen
+        self.privkey = private_key
+        self.verifying_key = verifying_key
+        return self
+
+    @classmethod
+    def _weierstrass_keygen(cls, curve, entropy, hashfunc):
+        """Generate a private key on a Weierstrass curve."""
+        secexp = randrange(curve.order, entropy)
+        return cls.from_secret_exponent(secexp, curve, hashfunc)
+
+    @classmethod
+    def generate(cls, curve=NIST192p, entropy=None, hashfunc=sha1):
+        """
+        Generate a random private key.
+
+        :param curve: The curve on which the point needs to reside, defaults
+            to NIST192p
+        :type curve: ~ecdsa.curves.Curve
+        :param entropy: Source of randomness for generating the private keys,
+            should provide cryptographically secure random numbers if the keys
+            need to be secure. Uses os.urandom() by default.
+        :type entropy: callable
+        :param hashfunc: The default hash function that will be used for
+            signing, needs to implement the same interface
+            as hashlib.sha1
+        :type hashfunc: callable
+
+        :return: Initialised SigningKey object
+        :rtype: SigningKey
+        """
+        if isinstance(curve.curve, CurveEdTw):
+            return cls._twisted_edwards_keygen(curve, entropy)
+        return cls._weierstrass_keygen(curve, entropy, hashfunc)
+
+    @classmethod
+    def from_secret_exponent(cls, secexp, curve=NIST192p, hashfunc=sha1):
+        """
+        Create a private key from a random integer.
+
+        Note: it's a low level method, it's recommended to use the
+        :func:`~SigningKey.generate` method to create private keys.
+
+        :param int secexp: secret multiplier (the actual private key in ECDSA).
+            Needs to be an integer between 1 and the curve order.
+        :param curve: The curve on which the point needs to reside
+        :type curve: ~ecdsa.curves.Curve
+        :param hashfunc: The default hash function that will be used for
+            signing, needs to implement the same interface
+            as hashlib.sha1
+        :type hashfunc: callable
+
+        :raises MalformedPointError: when the provided secexp is too large
+            or too small for the curve selected
+        :raises RuntimeError: if the generation of public key from private
+            key failed
+
+        :return: Initialised SigningKey object
+        :rtype: SigningKey
+        """
+        if isinstance(curve.curve, CurveEdTw):
+            raise ValueError(
+                "Edwards keys don't support setting the secret scalar "
+                "(exponent) directly"
+            )
+        self = cls(_error__please_use_generate=True)
+        self.curve = curve
+        self.default_hashfunc = hashfunc
+        self.baselen = curve.baselen
+        n = curve.order
+        if not 1 <= secexp < n:
+            raise MalformedPointError(
+                "Invalid value for secexp, expected integer "
+                "between 1 and {0}".format(n)
+            )
+        pubkey_point = curve.generator * secexp
+        if hasattr(pubkey_point, "scale"):
+            pubkey_point = pubkey_point.scale()
+        self.verifying_key = VerifyingKey.from_public_point(
+            pubkey_point, curve, hashfunc, False
+        )
+        pubkey = self.verifying_key.pubkey
+        self.privkey = ecdsa.Private_key(pubkey, secexp)
+        self.privkey.order = n
+        return self
+
+    @classmethod
+    def from_string(cls, string, curve=NIST192p, hashfunc=sha1):
+        """
+        Decode the private key from :term:`raw encoding`.
+
+        Note: the name of this method is a misnomer coming from days of
+        Python 2, when binary strings and character strings shared a type.
+        In Python 3, the expected type is `bytes`.
+
+        :param string: the raw encoding of the private key
+        :type string: :term:`bytes-like object`
+        :param curve: The curve on which the point needs to reside
+        :type curve: ~ecdsa.curves.Curve
+        :param hashfunc: The default hash function that will be used for
+            signing, needs to implement the same interface
+            as hashlib.sha1
+        :type hashfunc: callable
+
+        :raises MalformedPointError: if the length of encoding doesn't match
+            the provided curve or the encoded values is too large
+        :raises RuntimeError: if the generation of public key from private
+            key failed
+
+        :return: Initialised SigningKey object
+        :rtype: SigningKey
+        """
+        string = normalise_bytes(string)
+
+        if len(string) != curve.baselen:
+            raise MalformedPointError(
+                "Invalid length of private key, received {0}, "
+                "expected {1}".format(len(string), curve.baselen)
+            )
+        if isinstance(curve.curve, CurveEdTw):
+            self = cls(_error__please_use_generate=True)
+            self.curve = curve
+            self.default_hashfunc = None  # Ignored for EdDSA
+            self.baselen = curve.baselen
+            self.privkey = eddsa.PrivateKey(curve.generator, string)
+            self.verifying_key = VerifyingKey.from_string(
+                self.privkey.public_key().public_key(), curve
+            )
+            return self
+        secexp = string_to_number(string)
+        return cls.from_secret_exponent(secexp, curve, hashfunc)
+
+    @classmethod
+    def from_pem(cls, string, hashfunc=sha1, valid_curve_encodings=None):
+        """
+        Initialise from key stored in :term:`PEM` format.
+
+        The PEM formats supported are the un-encrypted RFC5915
+        (the ssleay format) supported by OpenSSL, and the more common
+        un-encrypted RFC5958 (the PKCS #8 format).
+
+        The legacy format files have the header with the string
+        ``BEGIN EC PRIVATE KEY``.
+        PKCS#8 files have the header ``BEGIN PRIVATE KEY``.
+        Encrypted files (ones that include the string
+        ``Proc-Type: 4,ENCRYPTED``
+        right after the PEM header) are not supported.
+
+        See :func:`~SigningKey.from_der` for ASN.1 syntax of the objects in
+        this files.
+
+        :param string: text with PEM-encoded private ECDSA key
+        :type string: str
+        :param valid_curve_encodings: list of allowed encoding formats
+            for curve parameters. By default (``None``) all are supported:
+            ``named_curve`` and ``explicit``.
+        :type valid_curve_encodings: :term:`set-like object`
+
+
+        :raises MalformedPointError: if the length of encoding doesn't match
+            the provided curve or the encoded values is too large
+        :raises RuntimeError: if the generation of public key from private
+            key failed
+        :raises UnexpectedDER: if the encoding of the PEM file is incorrect
+
+        :return: Initialised SigningKey object
+        :rtype: SigningKey
+        """
+        if not PY2 and isinstance(string, str):  # pragma: no branch
+            string = string.encode()
+
+        # The privkey pem may have multiple sections, commonly it also has
+        # "EC PARAMETERS", we need just "EC PRIVATE KEY". PKCS#8 should not
+        # have the "EC PARAMETERS" section; it's just "PRIVATE KEY".
+        private_key_index = string.find(b"-----BEGIN EC PRIVATE KEY-----")
+        if private_key_index == -1:
+            private_key_index = string.index(b"-----BEGIN PRIVATE KEY-----")
+
+        return cls.from_der(
+            der.unpem(string[private_key_index:]),
+            hashfunc,
+            valid_curve_encodings,
+        )
+
+    @classmethod
+    def from_der(cls, string, hashfunc=sha1, valid_curve_encodings=None):
+        """
+        Initialise from key stored in :term:`DER` format.
+
+        The DER formats supported are the un-encrypted RFC5915
+        (the ssleay format) supported by OpenSSL, and the more common
+        un-encrypted RFC5958 (the PKCS #8 format).
+
+        Both formats contain an ASN.1 object following the syntax specified
+        in RFC5915::
+
+            ECPrivateKey ::= SEQUENCE {
+              version        INTEGER { ecPrivkeyVer1(1) }} (ecPrivkeyVer1),
+              privateKey     OCTET STRING,
+              parameters [0] ECParameters {{ NamedCurve }} OPTIONAL,
+              publicKey  [1] BIT STRING OPTIONAL
+            }
+
+        `publicKey` field is ignored completely (errors, if any, in it will
+        be undetected).
+
+        Two formats are supported for the `parameters` field: the named
+        curve and the explicit encoding of curve parameters.
+        In the legacy ssleay format, this implementation requires the optional
+        `parameters` field to get the curve name. In PKCS #8 format, the curve
+        is part of the PrivateKeyAlgorithmIdentifier.
+
+        The PKCS #8 format includes an ECPrivateKey object as the `privateKey`
+        field within a larger structure::
+
+            OneAsymmetricKey ::= SEQUENCE {
+                version                   Version,
+                privateKeyAlgorithm       PrivateKeyAlgorithmIdentifier,
+                privateKey                PrivateKey,
+                attributes            [0] Attributes OPTIONAL,
+                ...,
+                [[2: publicKey        [1] PublicKey OPTIONAL ]],
+                ...
+            }
+
+        The `attributes` and `publicKey` fields are completely ignored; errors
+        in them will not be detected.
+
+        :param string: binary string with DER-encoded private ECDSA key
+        :type string: :term:`bytes-like object`
+        :param valid_curve_encodings: list of allowed encoding formats
+            for curve parameters. By default (``None``) all are supported:
+            ``named_curve`` and ``explicit``.
+            Ignored for EdDSA.
+        :type valid_curve_encodings: :term:`set-like object`
+
+        :raises MalformedPointError: if the length of encoding doesn't match
+            the provided curve or the encoded values is too large
+        :raises RuntimeError: if the generation of public key from private
+            key failed
+        :raises UnexpectedDER: if the encoding of the DER file is incorrect
+
+        :return: Initialised SigningKey object
+        :rtype: SigningKey
+        """
+        s = normalise_bytes(string)
+        curve = None
+
+        s, empty = der.remove_sequence(s)
+        if empty != b(""):
+            raise der.UnexpectedDER(
+                "trailing junk after DER privkey: %s" % binascii.hexlify(empty)
+            )
+
+        version, s = der.remove_integer(s)
+
+        # At this point, PKCS #8 has a sequence containing the algorithm
+        # identifier and the curve identifier. The ssleay format instead has
+        # an octet string containing the key data, so this is how we can
+        # distinguish the two formats.
+        if der.is_sequence(s):
+            if version not in (0, 1):
+                raise der.UnexpectedDER(
+                    "expected version '0' or '1' at start of privkey, got %d"
+                    % version
+                )
+
+            sequence, s = der.remove_sequence(s)
+            algorithm_oid, algorithm_identifier = der.remove_object(sequence)
+
+            if algorithm_oid in (Ed25519.oid, Ed448.oid):
+                if algorithm_identifier:
+                    raise der.UnexpectedDER(
+                        "Non NULL parameters for a EdDSA key"
+                    )
+                key_str_der, s = der.remove_octet_string(s)
+
+                # As RFC5958 describe, there are may be optional Attributes
+                # and Publickey. Don't raise error if something after
+                # Privatekey
+
+                # TODO parse attributes or validate publickey
+                # if s:
+                #     raise der.UnexpectedDER(
+                #         "trailing junk inside the privateKey"
+                #     )
+                key_str, s = der.remove_octet_string(key_str_der)
+                if s:
+                    raise der.UnexpectedDER(
+                        "trailing junk after the encoded private key"
+                    )
+
+                if algorithm_oid == Ed25519.oid:
+                    curve = Ed25519
+                else:
+                    assert algorithm_oid == Ed448.oid
+                    curve = Ed448
+
+                return cls.from_string(key_str, curve, None)
+
+            if algorithm_oid not in (oid_ecPublicKey, oid_ecDH, oid_ecMQV):
+                raise der.UnexpectedDER(
+                    "unexpected algorithm identifier '%s'" % (algorithm_oid,)
+                )
+
+            curve = Curve.from_der(algorithm_identifier, valid_curve_encodings)
+
+            if empty != b"":
+                raise der.UnexpectedDER(
+                    "unexpected data after algorithm identifier: %s"
+                    % binascii.hexlify(empty)
+                )
+
+            # Up next is an octet string containing an ECPrivateKey. Ignore
+            # the optional "attributes" and "publicKey" fields that come after.
+            s, _ = der.remove_octet_string(s)
+
+            # Unpack the ECPrivateKey to get to the key data octet string,
+            # and rejoin the ssleay parsing path.
+            s, empty = der.remove_sequence(s)
+            if empty != b(""):
+                raise der.UnexpectedDER(
+                    "trailing junk after DER privkey: %s"
+                    % binascii.hexlify(empty)
+                )
+
+            version, s = der.remove_integer(s)
+
+        # The version of the ECPrivateKey must be 1.
+        if version != 1:
+            raise der.UnexpectedDER(
+                "expected version '1' at start of DER privkey, got %d"
+                % version
+            )
+
+        privkey_str, s = der.remove_octet_string(s)
+
+        if not curve:
+            tag, curve_oid_str, s = der.remove_constructed(s)
+            if tag != 0:
+                raise der.UnexpectedDER(
+                    "expected tag 0 in DER privkey, got %d" % tag
+                )
+            curve = Curve.from_der(curve_oid_str, valid_curve_encodings)
+
+        # we don't actually care about the following fields
+        #
+        # tag, pubkey_bitstring, s = der.remove_constructed(s)
+        # if tag != 1:
+        #     raise der.UnexpectedDER("expected tag 1 in DER privkey, got %d"
+        #                             % tag)
+        # pubkey_str = der.remove_bitstring(pubkey_bitstring, 0)
+        # if empty != "":
+        #     raise der.UnexpectedDER("trailing junk after DER privkey "
+        #                             "pubkeystr: %s"
+        #                             % binascii.hexlify(empty))
+
+        # our from_string method likes fixed-length privkey strings
+        if len(privkey_str) < curve.baselen:
+            privkey_str = (
+                b("\x00") * (curve.baselen - len(privkey_str)) + privkey_str
+            )
+        return cls.from_string(privkey_str, curve, hashfunc)
+
+    def to_string(self):
+        """
+        Convert the private key to :term:`raw encoding`.
+
+        Note: while the method is named "to_string", its name comes from
+        Python 2 days, when binary and character strings used the same type.
+        The type used in Python 3 is `bytes`.
+
+        :return: raw encoding of private key
+        :rtype: bytes
+        """
+        if isinstance(self.curve.curve, CurveEdTw):
+            return bytes(self.privkey.private_key)
+        secexp = self.privkey.secret_multiplier
+        s = number_to_string(secexp, self.privkey.order)
+        return s
+
+    def to_pem(
+        self,
+        point_encoding="uncompressed",
+        format="ssleay",
+        curve_parameters_encoding=None,
+    ):
+        """
+        Convert the private key to the :term:`PEM` format.
+
+        See :func:`~SigningKey.from_pem` method for format description.
+
+        Only the named curve format is supported.
+        The public key will be included in generated string.
+
+        The PEM header will specify ``BEGIN EC PRIVATE KEY`` or
+        ``BEGIN PRIVATE KEY``, depending on the desired format.
+
+        :param str point_encoding: format to use for encoding public point
+        :param str format: either ``ssleay`` (default) or ``pkcs8``
+        :param str curve_parameters_encoding: format of encoded curve
+            parameters, default depends on the curve, if the curve has
+            an associated OID, ``named_curve`` format will be used,
+            if no OID is associated with the curve, the fallback of
+            ``explicit`` parameters will be used.
+
+        :return: PEM encoded private key
+        :rtype: bytes
+
+        .. warning:: The PEM is encoded to US-ASCII, it needs to be
+            re-encoded if the system is incompatible (e.g. uses UTF-16)
+        """
+        # TODO: "BEGIN ECPARAMETERS"
+        assert format in ("ssleay", "pkcs8")
+        header = "EC PRIVATE KEY" if format == "ssleay" else "PRIVATE KEY"
+        return der.topem(
+            self.to_der(point_encoding, format, curve_parameters_encoding),
+            header,
+        )
+
+    def _encode_eddsa(self):
+        """Create a PKCS#8 encoding of EdDSA keys."""
+        ec_private_key = der.encode_octet_string(self.to_string())
+        return der.encode_sequence(
+            der.encode_integer(0),
+            der.encode_sequence(der.encode_oid(*self.curve.oid)),
+            der.encode_octet_string(ec_private_key),
+        )
+
+    def to_der(
+        self,
+        point_encoding="uncompressed",
+        format="ssleay",
+        curve_parameters_encoding=None,
+    ):
+        """
+        Convert the private key to the :term:`DER` format.
+
+        See :func:`~SigningKey.from_der` method for format specification.
+
+        Only the named curve format is supported.
+        The public key will be included in the generated string.
+
+        :param str point_encoding: format to use for encoding public point
+            Ignored for EdDSA
+        :param str format: either ``ssleay`` (default) or ``pkcs8``.
+            EdDSA keys require ``pkcs8``.
+        :param str curve_parameters_encoding: format of encoded curve
+            parameters, default depends on the curve, if the curve has
+            an associated OID, ``named_curve`` format will be used,
+            if no OID is associated with the curve, the fallback of
+            ``explicit`` parameters will be used.
+            Ignored for EdDSA.
+
+        :return: DER encoded private key
+        :rtype: bytes
+        """
+        # SEQ([int(1), octetstring(privkey),cont[0], oid(secp224r1),
+        #      cont[1],bitstring])
+        if point_encoding == "raw":
+            raise ValueError("raw encoding not allowed in DER")
+        assert format in ("ssleay", "pkcs8")
+        if isinstance(self.curve.curve, CurveEdTw):
+            if format != "pkcs8":
+                raise ValueError("Only PKCS#8 format supported for EdDSA keys")
+            return self._encode_eddsa()
+        encoded_vk = self.get_verifying_key().to_string(point_encoding)
+        priv_key_elems = [
+            der.encode_integer(1),
+            der.encode_octet_string(self.to_string()),
+        ]
+        if format == "ssleay":
+            priv_key_elems.append(
+                der.encode_constructed(
+                    0, self.curve.to_der(curve_parameters_encoding)
+                )
+            )
+        # the 0 in encode_bitstring specifies the number of unused bits
+        # in the `encoded_vk` string
+        priv_key_elems.append(
+            der.encode_constructed(1, der.encode_bitstring(encoded_vk, 0))
+        )
+        ec_private_key = der.encode_sequence(*priv_key_elems)
+
+        if format == "ssleay":
+            return ec_private_key
+        else:
+            return der.encode_sequence(
+                # version = 1 means the public key is not present in the
+                # top-level structure.
+                der.encode_integer(1),
+                der.encode_sequence(
+                    der.encode_oid(*oid_ecPublicKey),
+                    self.curve.to_der(curve_parameters_encoding),
+                ),
+                der.encode_octet_string(ec_private_key),
+            )
+
+    def get_verifying_key(self):
+        """
+        Return the VerifyingKey associated with this private key.
+
+        Equivalent to reading the `verifying_key` field of an instance.
+
+        :return: a public key that can be used to verify the signatures made
+            with this SigningKey
+        :rtype: VerifyingKey
+        """
+        return self.verifying_key
+
+    def sign_deterministic(
+        self,
+        data,
+        hashfunc=None,
+        sigencode=sigencode_string,
+        extra_entropy=b"",
+    ):
+        """
+        Create signature over data.
+
+        For Weierstrass curves it uses the deterministic RFC6979 algorithm.
+        For Edwards curves it uses the standard EdDSA algorithm.
+
+        For ECDSA the data will be hashed using the `hashfunc` function before
+        signing.
+        For EdDSA the data will be hashed with the hash associated with the
+        curve (SHA-512 for Ed25519 and SHAKE-256 for Ed448).
+
+        This is the recommended method for performing signatures when hashing
+        of data is necessary.
+
+        :param data: data to be hashed and computed signature over
+        :type data: :term:`bytes-like object`
+        :param hashfunc: hash function to use for computing the signature,
+            if unspecified, the default hash function selected during
+            object initialisation will be used (see
+            `VerifyingKey.default_hashfunc`). The object needs to implement
+            the same interface as hashlib.sha1.
+            Ignored with EdDSA.
+        :type hashfunc: callable
+        :param sigencode: function used to encode the signature.
+            The function needs to accept three parameters: the two integers
+            that are the signature and the order of the curve over which the
+            signature was computed. It needs to return an encoded signature.
+            See `ecdsa.util.sigencode_string` and `ecdsa.util.sigencode_der`
+            as examples of such functions.
+            Ignored with EdDSA.
+        :type sigencode: callable
+        :param extra_entropy: additional data that will be fed into the random
+            number generator used in the RFC6979 process. Entirely optional.
+            Ignored with EdDSA.
+        :type extra_entropy: :term:`bytes-like object`
+
+        :return: encoded signature over `data`
+        :rtype: bytes or sigencode function dependent type
+        """
+        hashfunc = hashfunc or self.default_hashfunc
+        data = normalise_bytes(data)
+
+        if isinstance(self.curve.curve, CurveEdTw):
+            return self.privkey.sign(data)
+
+        extra_entropy = normalise_bytes(extra_entropy)
+        digest = hashfunc(data).digest()
+
+        return self.sign_digest_deterministic(
+            digest,
+            hashfunc=hashfunc,
+            sigencode=sigencode,
+            extra_entropy=extra_entropy,
+            allow_truncate=True,
+        )
+
+    def sign_digest_deterministic(
+        self,
+        digest,
+        hashfunc=None,
+        sigencode=sigencode_string,
+        extra_entropy=b"",
+        allow_truncate=False,
+    ):
+        """
+        Create signature for digest using the deterministic RFC6979 algorithm.
+
+        `digest` should be the output of cryptographically secure hash function
+        like SHA256 or SHA-3-256.
+
+        This is the recommended method for performing signatures when no
+        hashing of data is necessary.
+
+        :param digest: hash of data that will be signed
+        :type digest: :term:`bytes-like object`
+        :param hashfunc: hash function to use for computing the random "k"
+            value from RFC6979 process,
+            if unspecified, the default hash function selected during
+            object initialisation will be used (see
+            :attr:`.VerifyingKey.default_hashfunc`). The object needs to
+            implement
+            the same interface as :func:`~hashlib.sha1` from :py:mod:`hashlib`.
+        :type hashfunc: callable
+        :param sigencode: function used to encode the signature.
+            The function needs to accept three parameters: the two integers
+            that are the signature and the order of the curve over which the
+            signature was computed. It needs to return an encoded signature.
+            See :func:`~ecdsa.util.sigencode_string` and
+            :func:`~ecdsa.util.sigencode_der`
+            as examples of such functions.
+        :type sigencode: callable
+        :param extra_entropy: additional data that will be fed into the random
+            number generator used in the RFC6979 process. Entirely optional.
+        :type extra_entropy: :term:`bytes-like object`
+        :param bool allow_truncate: if True, the provided digest can have
+            bigger bit-size than the order of the curve, the extra bits (at
+            the end of the digest) will be truncated. Use it when signing
+            SHA-384 output using NIST256p or in similar situations.
+
+        :return: encoded signature for the `digest` hash
+        :rtype: bytes or sigencode function dependent type
+        """
+        if isinstance(self.curve.curve, CurveEdTw):
+            raise ValueError("Method unsupported for Edwards curves")
+        secexp = self.privkey.secret_multiplier
+        hashfunc = hashfunc or self.default_hashfunc
+        digest = normalise_bytes(digest)
+        extra_entropy = normalise_bytes(extra_entropy)
+
+        def simple_r_s(r, s, order):
+            return r, s, order
+
+        retry_gen = 0
+        while True:
+            k = rfc6979.generate_k(
+                self.curve.generator.order(),
+                secexp,
+                hashfunc,
+                digest,
+                retry_gen=retry_gen,
+                extra_entropy=extra_entropy,
+            )
+            try:
+                r, s, order = self.sign_digest(
+                    digest,
+                    sigencode=simple_r_s,
+                    k=k,
+                    allow_truncate=allow_truncate,
+                )
+                break
+            except RSZeroError:
+                retry_gen += 1
+
+        return sigencode(r, s, order)
+
+    def sign(
+        self,
+        data,
+        entropy=None,
+        hashfunc=None,
+        sigencode=sigencode_string,
+        k=None,
+        allow_truncate=True,
+    ):
+        """
+        Create signature over data.
+
+        Uses the probabilistic ECDSA algorithm for Weierstrass curves
+        (NIST256p, etc.) and the deterministic EdDSA algorithm for the
+        Edwards curves (Ed25519, Ed448).
+
+        This method uses the standard ECDSA algorithm that requires a
+        cryptographically secure random number generator.
+
+        It's recommended to use the :func:`~SigningKey.sign_deterministic`
+        method instead of this one.
+
+        :param data: data that will be hashed for signing
+        :type data: :term:`bytes-like object`
+        :param callable entropy: randomness source, :func:`os.urandom` by
+            default. Ignored with EdDSA.
+        :param hashfunc: hash function to use for hashing the provided
+            ``data``.
+            If unspecified the default hash function selected during
+            object initialisation will be used (see
+            :attr:`.VerifyingKey.default_hashfunc`).
+            Should behave like :func:`~hashlib.sha1` from :py:mod:`hashlib`.
+            The output length of the
+            hash (in bytes) must not be longer than the length of the curve
+            order (rounded up to the nearest byte), so using SHA256 with
+            NIST256p is ok, but SHA256 with NIST192p is not. (In the 2**-96ish
+            unlikely event of a hash output larger than the curve order, the
+            hash will effectively be wrapped mod n).
+            If you want to explicitly allow use of large hashes with small
+            curves set the ``allow_truncate`` to ``True``.
+            Use ``hashfunc=hashlib.sha1`` to match openssl's
+            ``-ecdsa-with-SHA1`` mode,
+            or ``hashfunc=hashlib.sha256`` for openssl-1.0.0's
+            ``-ecdsa-with-SHA256``.
+            Ignored for EdDSA
+        :type hashfunc: callable
+        :param sigencode: function used to encode the signature.
+            The function needs to accept three parameters: the two integers
+            that are the signature and the order of the curve over which the
+            signature was computed. It needs to return an encoded signature.
+            See :func:`~ecdsa.util.sigencode_string` and
+            :func:`~ecdsa.util.sigencode_der`
+            as examples of such functions.
+            Ignored for EdDSA
+        :type sigencode: callable
+        :param int k: a pre-selected nonce for calculating the signature.
+            In typical use cases, it should be set to None (the default) to
+            allow its generation from an entropy source.
+            Ignored for EdDSA.
+        :param bool allow_truncate: if ``True``, the provided digest can have
+            bigger bit-size than the order of the curve, the extra bits (at
+            the end of the digest) will be truncated. Use it when signing
+            SHA-384 output using NIST256p or in similar situations. True by
+            default.
+            Ignored for EdDSA.
+
+        :raises RSZeroError: in the unlikely event when *r* parameter or
+            *s* parameter of the created signature is equal 0, as that would
+            leak the key. Caller should try a better entropy source, retry with
+            different ``k``, or use the
+            :func:`~SigningKey.sign_deterministic` in such case.
+
+        :return: encoded signature of the hash of `data`
+        :rtype: bytes or sigencode function dependent type
+        """
+        hashfunc = hashfunc or self.default_hashfunc
+        data = normalise_bytes(data)
+        if isinstance(self.curve.curve, CurveEdTw):
+            return self.sign_deterministic(data)
+        h = hashfunc(data).digest()
+        return self.sign_digest(h, entropy, sigencode, k, allow_truncate)
+
+    def sign_digest(
+        self,
+        digest,
+        entropy=None,
+        sigencode=sigencode_string,
+        k=None,
+        allow_truncate=False,
+    ):
+        """
+        Create signature over digest using the probabilistic ECDSA algorithm.
+
+        This method uses the standard ECDSA algorithm that requires a
+        cryptographically secure random number generator.
+
+        This method does not hash the input.
+
+        It's recommended to use the
+        :func:`~SigningKey.sign_digest_deterministic` method
+        instead of this one.
+
+        :param digest: hash value that will be signed
+        :type digest: :term:`bytes-like object`
+        :param callable entropy: randomness source, os.urandom by default
+        :param sigencode: function used to encode the signature.
+            The function needs to accept three parameters: the two integers
+            that are the signature and the order of the curve over which the
+            signature was computed. It needs to return an encoded signature.
+            See `ecdsa.util.sigencode_string` and `ecdsa.util.sigencode_der`
+            as examples of such functions.
+        :type sigencode: callable
+        :param int k: a pre-selected nonce for calculating the signature.
+            In typical use cases, it should be set to None (the default) to
+            allow its generation from an entropy source.
+        :param bool allow_truncate: if True, the provided digest can have
+            bigger bit-size than the order of the curve, the extra bits (at
+            the end of the digest) will be truncated. Use it when signing
+            SHA-384 output using NIST256p or in similar situations.
+
+        :raises RSZeroError: in the unlikely event when "r" parameter or
+            "s" parameter of the created signature is equal 0, as that would
+            leak the key. Caller should try a better entropy source, retry with
+            different 'k', or use the
+            :func:`~SigningKey.sign_digest_deterministic` in such case.
+
+        :return: encoded signature for the `digest` hash
+        :rtype: bytes or sigencode function dependent type
+        """
+        if isinstance(self.curve.curve, CurveEdTw):
+            raise ValueError("Method unsupported for Edwards curves")
+        digest = normalise_bytes(digest)
+        number = _truncate_and_convert_digest(
+            digest,
+            self.curve,
+            allow_truncate,
+        )
+        r, s = self.sign_number(number, entropy, k)
+        return sigencode(r, s, self.privkey.order)
+
+    def sign_number(self, number, entropy=None, k=None):
+        """
+        Sign an integer directly.
+
+        Note, this is a low level method, usually you will want to use
+        :func:`~SigningKey.sign_deterministic` or
+        :func:`~SigningKey.sign_digest_deterministic`.
+
+        :param int number: number to sign using the probabilistic ECDSA
+            algorithm.
+        :param callable entropy: entropy source, os.urandom by default
+        :param int k: pre-selected nonce for signature operation. If unset
+            it will be selected at random using the entropy source.
+
+        :raises RSZeroError: in the unlikely event when "r" parameter or
+            "s" parameter of the created signature is equal 0, as that would
+            leak the key. Caller should try a better entropy source, retry with
+            different 'k', or use the
+            :func:`~SigningKey.sign_digest_deterministic` in such case.
+
+        :return: the "r" and "s" parameters of the signature
+        :rtype: tuple of ints
+        """
+        if isinstance(self.curve.curve, CurveEdTw):
+            raise ValueError("Method unsupported for Edwards curves")
+        order = self.privkey.order
+
+        if k is not None:
+            _k = k
+        else:
+            _k = randrange(order, entropy)
+
+        assert 1 <= _k < order
+        sig = self.privkey.sign(number, _k)
+        return sig.r, sig.s
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/numbertheory.py b/myenv/lib/python3.9/site-packages/ecdsa/numbertheory.py
new file mode 100644
index 0000000..d3500c7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/numbertheory.py
@@ -0,0 +1,825 @@
+#! /usr/bin/env python
+#
+# Provide some simple capabilities from number theory.
+#
+# Version of 2008.11.14.
+#
+# Written in 2005 and 2006 by Peter Pearson and placed in the public domain.
+# Revision history:
+#   2008.11.14: Use pow(base, exponent, modulus) for modular_exp.
+#               Make gcd and lcm accept arbitrarily many arguments.
+
+from __future__ import division
+
+import sys
+from six import integer_types, PY2
+from six.moves import reduce
+
+try:
+    xrange
+except NameError:
+    xrange = range
+try:
+    from gmpy2 import powmod
+
+    GMPY2 = True
+    GMPY = False
+except ImportError:
+    GMPY2 = False
+    try:
+        from gmpy import mpz
+
+        GMPY = True
+    except ImportError:
+        GMPY = False
+
+import math
+import warnings
+
+
+class Error(Exception):
+    """Base class for exceptions in this module."""
+
+    pass
+
+
+class JacobiError(Error):
+    pass
+
+
+class SquareRootError(Error):
+    pass
+
+
+class NegativeExponentError(Error):
+    pass
+
+
+def modular_exp(base, exponent, modulus):  # pragma: no cover
+    """Raise base to exponent, reducing by modulus"""
+    # deprecated in 0.14
+    warnings.warn(
+        "Function is unused in library code. If you use this code, "
+        "change to pow() builtin.",
+        DeprecationWarning,
+    )
+    if exponent < 0:
+        raise NegativeExponentError(
+            "Negative exponents (%d) not allowed" % exponent
+        )
+    return pow(base, exponent, modulus)
+
+
+def polynomial_reduce_mod(poly, polymod, p):
+    """Reduce poly by polymod, integer arithmetic modulo p.
+
+    Polynomials are represented as lists of coefficients
+    of increasing powers of x."""
+
+    # This module has been tested only by extensive use
+    # in calculating modular square roots.
+
+    # Just to make this easy, require a monic polynomial:
+    assert polymod[-1] == 1
+
+    assert len(polymod) > 1
+
+    while len(poly) >= len(polymod):
+        if poly[-1] != 0:
+            for i in xrange(2, len(polymod) + 1):
+                poly[-i] = (poly[-i] - poly[-1] * polymod[-i]) % p
+        poly = poly[0:-1]
+
+    return poly
+
+
+def polynomial_multiply_mod(m1, m2, polymod, p):
+    """Polynomial multiplication modulo a polynomial over ints mod p.
+
+    Polynomials are represented as lists of coefficients
+    of increasing powers of x."""
+
+    # This is just a seat-of-the-pants implementation.
+
+    # This module has been tested only by extensive use
+    # in calculating modular square roots.
+
+    # Initialize the product to zero:
+
+    prod = (len(m1) + len(m2) - 1) * [0]
+
+    # Add together all the cross-terms:
+
+    for i in xrange(len(m1)):
+        for j in xrange(len(m2)):
+            prod[i + j] = (prod[i + j] + m1[i] * m2[j]) % p
+
+    return polynomial_reduce_mod(prod, polymod, p)
+
+
+def polynomial_exp_mod(base, exponent, polymod, p):
+    """Polynomial exponentiation modulo a polynomial over ints mod p.
+
+    Polynomials are represented as lists of coefficients
+    of increasing powers of x."""
+
+    # Based on the Handbook of Applied Cryptography, algorithm 2.227.
+
+    # This module has been tested only by extensive use
+    # in calculating modular square roots.
+
+    assert exponent < p
+
+    if exponent == 0:
+        return [1]
+
+    G = base
+    k = exponent
+    if k % 2 == 1:
+        s = G
+    else:
+        s = [1]
+
+    while k > 1:
+        k = k // 2
+        G = polynomial_multiply_mod(G, G, polymod, p)
+        if k % 2 == 1:
+            s = polynomial_multiply_mod(G, s, polymod, p)
+
+    return s
+
+
+def jacobi(a, n):
+    """Jacobi symbol"""
+
+    # Based on the Handbook of Applied Cryptography (HAC), algorithm 2.149.
+
+    # This function has been tested by comparison with a small
+    # table printed in HAC, and by extensive use in calculating
+    # modular square roots.
+
+    if not n >= 3:
+        raise JacobiError("n must be larger than 2")
+    if not n % 2 == 1:
+        raise JacobiError("n must be odd")
+    a = a % n
+    if a == 0:
+        return 0
+    if a == 1:
+        return 1
+    a1, e = a, 0
+    while a1 % 2 == 0:
+        a1, e = a1 // 2, e + 1
+    if e % 2 == 0 or n % 8 == 1 or n % 8 == 7:
+        s = 1
+    else:
+        s = -1
+    if a1 == 1:
+        return s
+    if n % 4 == 3 and a1 % 4 == 3:
+        s = -s
+    return s * jacobi(n % a1, a1)
+
+
+def square_root_mod_prime(a, p):
+    """Modular square root of a, mod p, p prime."""
+
+    # Based on the Handbook of Applied Cryptography, algorithms 3.34 to 3.39.
+
+    # This module has been tested for all values in [0,p-1] for
+    # every prime p from 3 to 1229.
+
+    assert 0 <= a < p
+    assert 1 < p
+
+    if a == 0:
+        return 0
+    if p == 2:
+        return a
+
+    jac = jacobi(a, p)
+    if jac == -1:
+        raise SquareRootError("%d has no square root modulo %d" % (a, p))
+
+    if p % 4 == 3:
+        return pow(a, (p + 1) // 4, p)
+
+    if p % 8 == 5:
+        d = pow(a, (p - 1) // 4, p)
+        if d == 1:
+            return pow(a, (p + 3) // 8, p)
+        assert d == p - 1
+        return (2 * a * pow(4 * a, (p - 5) // 8, p)) % p
+
+    if PY2:
+        # xrange on python2 can take integers representable as C long only
+        range_top = min(0x7FFFFFFF, p)
+    else:
+        range_top = p
+    for b in xrange(2, range_top):
+        if jacobi(b * b - 4 * a, p) == -1:
+            f = (a, -b, 1)
+            ff = polynomial_exp_mod((0, 1), (p + 1) // 2, f, p)
+            if ff[1]:
+                raise SquareRootError("p is not prime")
+            return ff[0]
+    raise RuntimeError("No b found.")
+
+
+# because all the inverse_mod code is arch/environment specific, and coveralls
+# expects it to execute equal number of times, we need to waive it by
+# adding the "no branch" pragma to all branches
+if GMPY2:  # pragma: no branch
+
+    def inverse_mod(a, m):
+        """Inverse of a mod m."""
+        if a == 0:  # pragma: no branch
+            return 0
+        return powmod(a, -1, m)
+
+elif GMPY:  # pragma: no branch
+
+    def inverse_mod(a, m):
+        """Inverse of a mod m."""
+        # while libgmp does support inverses modulo, it is accessible
+        # only using the native `pow()` function, and `pow()` in gmpy sanity
+        # checks the parameters before passing them on to underlying
+        # implementation
+        if a == 0:  # pragma: no branch
+            return 0
+        a = mpz(a)
+        m = mpz(m)
+
+        lm, hm = mpz(1), mpz(0)
+        low, high = a % m, m
+        while low > 1:  # pragma: no branch
+            r = high // low
+            lm, low, hm, high = hm - lm * r, high - low * r, lm, low
+
+        return lm % m
+
+elif sys.version_info >= (3, 8):  # pragma: no branch
+
+    def inverse_mod(a, m):
+        """Inverse of a mod m."""
+        if a == 0:  # pragma: no branch
+            return 0
+        return pow(a, -1, m)
+
+else:  # pragma: no branch
+
+    def inverse_mod(a, m):
+        """Inverse of a mod m."""
+
+        if a == 0:  # pragma: no branch
+            return 0
+
+        lm, hm = 1, 0
+        low, high = a % m, m
+        while low > 1:  # pragma: no branch
+            r = high // low
+            lm, low, hm, high = hm - lm * r, high - low * r, lm, low
+
+        return lm % m
+
+
+try:
+    gcd2 = math.gcd
+except AttributeError:
+
+    def gcd2(a, b):
+        """Greatest common divisor using Euclid's algorithm."""
+        while a:
+            a, b = b % a, a
+        return b
+
+
+def gcd(*a):
+    """Greatest common divisor.
+
+    Usage: gcd([ 2, 4, 6 ])
+    or:    gcd(2, 4, 6)
+    """
+
+    if len(a) > 1:
+        return reduce(gcd2, a)
+    if hasattr(a[0], "__iter__"):
+        return reduce(gcd2, a[0])
+    return a[0]
+
+
+def lcm2(a, b):
+    """Least common multiple of two integers."""
+
+    return (a * b) // gcd(a, b)
+
+
+def lcm(*a):
+    """Least common multiple.
+
+    Usage: lcm([ 3, 4, 5 ])
+    or:    lcm(3, 4, 5)
+    """
+
+    if len(a) > 1:
+        return reduce(lcm2, a)
+    if hasattr(a[0], "__iter__"):
+        return reduce(lcm2, a[0])
+    return a[0]
+
+
+def factorization(n):
+    """Decompose n into a list of (prime,exponent) pairs."""
+
+    assert isinstance(n, integer_types)
+
+    if n < 2:
+        return []
+
+    result = []
+
+    # Test the small primes:
+
+    for d in smallprimes:
+        if d > n:
+            break
+        q, r = divmod(n, d)
+        if r == 0:
+            count = 1
+            while d <= n:
+                n = q
+                q, r = divmod(n, d)
+                if r != 0:
+                    break
+                count = count + 1
+            result.append((d, count))
+
+    # If n is still greater than the last of our small primes,
+    # it may require further work:
+
+    if n > smallprimes[-1]:
+        if is_prime(n):  # If what's left is prime, it's easy:
+            result.append((n, 1))
+        else:  # Ugh. Search stupidly for a divisor:
+            d = smallprimes[-1]
+            while 1:
+                d = d + 2  # Try the next divisor.
+                q, r = divmod(n, d)
+                if q < d:  # n < d*d means we're done, n = 1 or prime.
+                    break
+                if r == 0:  # d divides n. How many times?
+                    count = 1
+                    n = q
+                    while d <= n:  # As long as d might still divide n,
+                        q, r = divmod(n, d)  # see if it does.
+                        if r != 0:
+                            break
+                        n = q  # It does. Reduce n, increase count.
+                        count = count + 1
+                    result.append((d, count))
+            if n > 1:
+                result.append((n, 1))
+
+    return result
+
+
+def phi(n):  # pragma: no cover
+    """Return the Euler totient function of n."""
+    # deprecated in 0.14
+    warnings.warn(
+        "Function is unused by library code. If you use this code, "
+        "please open an issue in "
+        "https://github.com/tlsfuzzer/python-ecdsa",
+        DeprecationWarning,
+    )
+
+    assert isinstance(n, integer_types)
+
+    if n < 3:
+        return 1
+
+    result = 1
+    ff = factorization(n)
+    for f in ff:
+        e = f[1]
+        if e > 1:
+            result = result * f[0] ** (e - 1) * (f[0] - 1)
+        else:
+            result = result * (f[0] - 1)
+    return result
+
+
+def carmichael(n):  # pragma: no cover
+    """Return Carmichael function of n.
+
+    Carmichael(n) is the smallest integer x such that
+    m**x = 1 mod n for all m relatively prime to n.
+    """
+    # deprecated in 0.14
+    warnings.warn(
+        "Function is unused by library code. If you use this code, "
+        "please open an issue in "
+        "https://github.com/tlsfuzzer/python-ecdsa",
+        DeprecationWarning,
+    )
+
+    return carmichael_of_factorized(factorization(n))
+
+
+def carmichael_of_factorized(f_list):  # pragma: no cover
+    """Return the Carmichael function of a number that is
+    represented as a list of (prime,exponent) pairs.
+    """
+    # deprecated in 0.14
+    warnings.warn(
+        "Function is unused by library code. If you use this code, "
+        "please open an issue in "
+        "https://github.com/tlsfuzzer/python-ecdsa",
+        DeprecationWarning,
+    )
+
+    if len(f_list) < 1:
+        return 1
+
+    result = carmichael_of_ppower(f_list[0])
+    for i in xrange(1, len(f_list)):
+        result = lcm(result, carmichael_of_ppower(f_list[i]))
+
+    return result
+
+
+def carmichael_of_ppower(pp):  # pragma: no cover
+    """Carmichael function of the given power of the given prime."""
+    # deprecated in 0.14
+    warnings.warn(
+        "Function is unused by library code. If you use this code, "
+        "please open an issue in "
+        "https://github.com/tlsfuzzer/python-ecdsa",
+        DeprecationWarning,
+    )
+
+    p, a = pp
+    if p == 2 and a > 2:
+        return 2 ** (a - 2)
+    else:
+        return (p - 1) * p ** (a - 1)
+
+
+def order_mod(x, m):  # pragma: no cover
+    """Return the order of x in the multiplicative group mod m."""
+    # deprecated in 0.14
+    warnings.warn(
+        "Function is unused by library code. If you use this code, "
+        "please open an issue in "
+        "https://github.com/tlsfuzzer/python-ecdsa",
+        DeprecationWarning,
+    )
+
+    # Warning: this implementation is not very clever, and will
+    # take a long time if m is very large.
+
+    if m <= 1:
+        return 0
+
+    assert gcd(x, m) == 1
+
+    z = x
+    result = 1
+    while z != 1:
+        z = (z * x) % m
+        result = result + 1
+    return result
+
+
+def largest_factor_relatively_prime(a, b):  # pragma: no cover
+    """Return the largest factor of a relatively prime to b."""
+    # deprecated in 0.14
+    warnings.warn(
+        "Function is unused by library code. If you use this code, "
+        "please open an issue in "
+        "https://github.com/tlsfuzzer/python-ecdsa",
+        DeprecationWarning,
+    )
+
+    while 1:
+        d = gcd(a, b)
+        if d <= 1:
+            break
+        b = d
+        while 1:
+            q, r = divmod(a, d)
+            if r > 0:
+                break
+            a = q
+    return a
+
+
+def kinda_order_mod(x, m):  # pragma: no cover
+    """Return the order of x in the multiplicative group mod m',
+    where m' is the largest factor of m relatively prime to x.
+    """
+    # deprecated in 0.14
+    warnings.warn(
+        "Function is unused by library code. If you use this code, "
+        "please open an issue in "
+        "https://github.com/tlsfuzzer/python-ecdsa",
+        DeprecationWarning,
+    )
+
+    return order_mod(x, largest_factor_relatively_prime(m, x))
+
+
+def is_prime(n):
+    """Return True if x is prime, False otherwise.
+
+    We use the Miller-Rabin test, as given in Menezes et al. p. 138.
+    This test is not exact: there are composite values n for which
+    it returns True.
+
+    In testing the odd numbers from 10000001 to 19999999,
+    about 66 composites got past the first test,
+    5 got past the second test, and none got past the third.
+    Since factors of 2, 3, 5, 7, and 11 were detected during
+    preliminary screening, the number of numbers tested by
+    Miller-Rabin was (19999999 - 10000001)*(2/3)*(4/5)*(6/7)
+    = 4.57 million.
+    """
+
+    # (This is used to study the risk of false positives:)
+    global miller_rabin_test_count
+
+    miller_rabin_test_count = 0
+
+    if n <= smallprimes[-1]:
+        if n in smallprimes:
+            return True
+        else:
+            return False
+
+    if gcd(n, 2 * 3 * 5 * 7 * 11) != 1:
+        return False
+
+    # Choose a number of iterations sufficient to reduce the
+    # probability of accepting a composite below 2**-80
+    # (from Menezes et al. Table 4.4):
+
+    t = 40
+    n_bits = 1 + int(math.log(n, 2))
+    for k, tt in (
+        (100, 27),
+        (150, 18),
+        (200, 15),
+        (250, 12),
+        (300, 9),
+        (350, 8),
+        (400, 7),
+        (450, 6),
+        (550, 5),
+        (650, 4),
+        (850, 3),
+        (1300, 2),
+    ):
+        if n_bits < k:
+            break
+        t = tt
+
+    # Run the test t times:
+
+    s = 0
+    r = n - 1
+    while (r % 2) == 0:
+        s = s + 1
+        r = r // 2
+    for i in xrange(t):
+        a = smallprimes[i]
+        y = pow(a, r, n)
+        if y != 1 and y != n - 1:
+            j = 1
+            while j <= s - 1 and y != n - 1:
+                y = pow(y, 2, n)
+                if y == 1:
+                    miller_rabin_test_count = i + 1
+                    return False
+                j = j + 1
+            if y != n - 1:
+                miller_rabin_test_count = i + 1
+                return False
+    return True
+
+
+def next_prime(starting_value):
+    """Return the smallest prime larger than the starting value."""
+
+    if starting_value < 2:
+        return 2
+    result = (starting_value + 1) | 1
+    while not is_prime(result):
+        result = result + 2
+    return result
+
+
+smallprimes = [
+    2,
+    3,
+    5,
+    7,
+    11,
+    13,
+    17,
+    19,
+    23,
+    29,
+    31,
+    37,
+    41,
+    43,
+    47,
+    53,
+    59,
+    61,
+    67,
+    71,
+    73,
+    79,
+    83,
+    89,
+    97,
+    101,
+    103,
+    107,
+    109,
+    113,
+    127,
+    131,
+    137,
+    139,
+    149,
+    151,
+    157,
+    163,
+    167,
+    173,
+    179,
+    181,
+    191,
+    193,
+    197,
+    199,
+    211,
+    223,
+    227,
+    229,
+    233,
+    239,
+    241,
+    251,
+    257,
+    263,
+    269,
+    271,
+    277,
+    281,
+    283,
+    293,
+    307,
+    311,
+    313,
+    317,
+    331,
+    337,
+    347,
+    349,
+    353,
+    359,
+    367,
+    373,
+    379,
+    383,
+    389,
+    397,
+    401,
+    409,
+    419,
+    421,
+    431,
+    433,
+    439,
+    443,
+    449,
+    457,
+    461,
+    463,
+    467,
+    479,
+    487,
+    491,
+    499,
+    503,
+    509,
+    521,
+    523,
+    541,
+    547,
+    557,
+    563,
+    569,
+    571,
+    577,
+    587,
+    593,
+    599,
+    601,
+    607,
+    613,
+    617,
+    619,
+    631,
+    641,
+    643,
+    647,
+    653,
+    659,
+    661,
+    673,
+    677,
+    683,
+    691,
+    701,
+    709,
+    719,
+    727,
+    733,
+    739,
+    743,
+    751,
+    757,
+    761,
+    769,
+    773,
+    787,
+    797,
+    809,
+    811,
+    821,
+    823,
+    827,
+    829,
+    839,
+    853,
+    857,
+    859,
+    863,
+    877,
+    881,
+    883,
+    887,
+    907,
+    911,
+    919,
+    929,
+    937,
+    941,
+    947,
+    953,
+    967,
+    971,
+    977,
+    983,
+    991,
+    997,
+    1009,
+    1013,
+    1019,
+    1021,
+    1031,
+    1033,
+    1039,
+    1049,
+    1051,
+    1061,
+    1063,
+    1069,
+    1087,
+    1091,
+    1093,
+    1097,
+    1103,
+    1109,
+    1117,
+    1123,
+    1129,
+    1151,
+    1153,
+    1163,
+    1171,
+    1181,
+    1187,
+    1193,
+    1201,
+    1213,
+    1217,
+    1223,
+    1229,
+]
+
+miller_rabin_test_count = 0
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/rfc6979.py b/myenv/lib/python3.9/site-packages/ecdsa/rfc6979.py
new file mode 100644
index 0000000..0728b5a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/rfc6979.py
@@ -0,0 +1,113 @@
+"""
+RFC 6979:
+    Deterministic Usage of the Digital Signature Algorithm (DSA) and
+    Elliptic Curve Digital Signature Algorithm (ECDSA)
+
+    http://tools.ietf.org/html/rfc6979
+
+Many thanks to Coda Hale for his implementation in Go language:
+    https://github.com/codahale/rfc6979
+"""
+
+import hmac
+from binascii import hexlify
+from .util import number_to_string, number_to_string_crop, bit_length
+from ._compat import hmac_compat
+
+
+# bit_length was defined in this module previously so keep it for backwards
+# compatibility, will need to deprecate and remove it later
+__all__ = ["bit_length", "bits2int", "bits2octets", "generate_k"]
+
+
+def bits2int(data, qlen):
+    x = int(hexlify(data), 16)
+    l = len(data) * 8
+
+    if l > qlen:
+        return x >> (l - qlen)
+    return x
+
+
+def bits2octets(data, order):
+    z1 = bits2int(data, bit_length(order))
+    z2 = z1 - order
+
+    if z2 < 0:
+        z2 = z1
+
+    return number_to_string_crop(z2, order)
+
+
+# https://tools.ietf.org/html/rfc6979#section-3.2
+def generate_k(order, secexp, hash_func, data, retry_gen=0, extra_entropy=b""):
+    """
+    Generate the ``k`` value - the nonce for DSA.
+
+    :param int order: order of the DSA generator used in the signature
+    :param int secexp: secure exponent (private key) in numeric form
+    :param hash_func: reference to the same hash function used for generating
+        hash, like :py:class:`hashlib.sha1`
+    :param bytes data: hash in binary form of the signing data
+    :param int retry_gen: how many good 'k' values to skip before returning
+    :param bytes extra_entropy: additional added data in binary form as per
+        section-3.6 of rfc6979
+    :rtype: int
+    """
+
+    qlen = bit_length(order)
+    holen = hash_func().digest_size
+    rolen = (qlen + 7) // 8
+    bx = (
+        hmac_compat(number_to_string(secexp, order)),
+        hmac_compat(bits2octets(data, order)),
+        hmac_compat(extra_entropy),
+    )
+
+    # Step B
+    v = b"\x01" * holen
+
+    # Step C
+    k = b"\x00" * holen
+
+    # Step D
+
+    k = hmac.new(k, digestmod=hash_func)
+    k.update(v + b"\x00")
+    for i in bx:
+        k.update(i)
+    k = k.digest()
+
+    # Step E
+    v = hmac.new(k, v, hash_func).digest()
+
+    # Step F
+    k = hmac.new(k, digestmod=hash_func)
+    k.update(v + b"\x01")
+    for i in bx:
+        k.update(i)
+    k = k.digest()
+
+    # Step G
+    v = hmac.new(k, v, hash_func).digest()
+
+    # Step H
+    while True:
+        # Step H1
+        t = b""
+
+        # Step H2
+        while len(t) < rolen:
+            v = hmac.new(k, v, hash_func).digest()
+            t += v
+
+        # Step H3
+        secret = bits2int(t, qlen)
+
+        if 1 <= secret < order:
+            if retry_gen <= 0:
+                return secret
+            retry_gen -= 1
+
+        k = hmac.new(k, v + b"\x00", hash_func).digest()
+        v = hmac.new(k, v, hash_func).digest()
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_curves.py b/myenv/lib/python3.9/site-packages/ecdsa/test_curves.py
new file mode 100644
index 0000000..93b6c9b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_curves.py
@@ -0,0 +1,361 @@
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+
+import base64
+import pytest
+from .curves import (
+    Curve,
+    NIST256p,
+    curves,
+    UnknownCurveError,
+    PRIME_FIELD_OID,
+    curve_by_name,
+)
+from .ellipticcurve import CurveFp, PointJacobi, CurveEdTw
+from . import der
+from .util import number_to_string
+
+
+class TestParameterEncoding(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        # minimal, but with cofactor (excludes seed when compared to
+        # OpenSSL output)
+        cls.base64_params = (
+            "MIHgAgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP/////////"
+            "//////zBEBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12K"
+            "o6k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsEQQRrF9Hy4SxCR/i85uVjpEDyd"
+            "wN9gS3rM6D0oTlF2JjClk/jQuL+Gn+bjufrSnwPnhYrzjNXazFezsu2QGg3v1H1"
+            "AiEA/////wAAAAD//////////7zm+q2nF56E87nKwvxjJVECAQE="
+        )
+
+    def test_from_pem(self):
+        pem_params = (
+            "-----BEGIN EC PARAMETERS-----\n"
+            "MIHgAgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP/////////\n"
+            "//////zBEBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12K\n"
+            "o6k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsEQQRrF9Hy4SxCR/i85uVjpEDyd\n"
+            "wN9gS3rM6D0oTlF2JjClk/jQuL+Gn+bjufrSnwPnhYrzjNXazFezsu2QGg3v1H1\n"
+            "AiEA/////wAAAAD//////////7zm+q2nF56E87nKwvxjJVECAQE=\n"
+            "-----END EC PARAMETERS-----\n"
+        )
+        curve = Curve.from_pem(pem_params)
+
+        self.assertIs(curve, NIST256p)
+
+    def test_from_pem_with_explicit_when_explicit_disabled(self):
+        pem_params = (
+            "-----BEGIN EC PARAMETERS-----\n"
+            "MIHgAgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP/////////\n"
+            "//////zBEBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12K\n"
+            "o6k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsEQQRrF9Hy4SxCR/i85uVjpEDyd\n"
+            "wN9gS3rM6D0oTlF2JjClk/jQuL+Gn+bjufrSnwPnhYrzjNXazFezsu2QGg3v1H1\n"
+            "AiEA/////wAAAAD//////////7zm+q2nF56E87nKwvxjJVECAQE=\n"
+            "-----END EC PARAMETERS-----\n"
+        )
+        with self.assertRaises(der.UnexpectedDER) as e:
+            Curve.from_pem(pem_params, ["named_curve"])
+
+        self.assertIn("explicit curve parameters not", str(e.exception))
+
+    def test_from_pem_with_named_curve_with_named_curve_disabled(self):
+        pem_params = (
+            "-----BEGIN EC PARAMETERS-----\n"
+            "BggqhkjOPQMBBw==\n"
+            "-----END EC PARAMETERS-----\n"
+        )
+        with self.assertRaises(der.UnexpectedDER) as e:
+            Curve.from_pem(pem_params, ["explicit"])
+
+        self.assertIn("named_curve curve parameters not", str(e.exception))
+
+    def test_from_pem_with_wrong_header(self):
+        pem_params = (
+            "-----BEGIN PARAMETERS-----\n"
+            "MIHgAgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP/////////\n"
+            "//////zBEBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12K\n"
+            "o6k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsEQQRrF9Hy4SxCR/i85uVjpEDyd\n"
+            "wN9gS3rM6D0oTlF2JjClk/jQuL+Gn+bjufrSnwPnhYrzjNXazFezsu2QGg3v1H1\n"
+            "AiEA/////wAAAAD//////////7zm+q2nF56E87nKwvxjJVECAQE=\n"
+            "-----END PARAMETERS-----\n"
+        )
+        with self.assertRaises(der.UnexpectedDER) as e:
+            Curve.from_pem(pem_params)
+
+        self.assertIn("PARAMETERS PEM header", str(e.exception))
+
+    def test_to_pem(self):
+        pem_params = (
+            b"-----BEGIN EC PARAMETERS-----\n"
+            b"BggqhkjOPQMBBw==\n"
+            b"-----END EC PARAMETERS-----\n"
+        )
+        encoding = NIST256p.to_pem()
+
+        self.assertEqual(pem_params, encoding)
+
+    def test_compare_with_different_object(self):
+        self.assertNotEqual(NIST256p, 256)
+
+    def test_named_curve_params_der(self):
+        encoded = NIST256p.to_der()
+
+        # just the encoding of the NIST256p OID (prime256v1)
+        self.assertEqual(b"\x06\x08\x2a\x86\x48\xce\x3d\x03\x01\x07", encoded)
+
+    def test_verify_that_default_is_named_curve_der(self):
+        encoded_default = NIST256p.to_der()
+        encoded_named = NIST256p.to_der("named_curve")
+
+        self.assertEqual(encoded_default, encoded_named)
+
+    def test_encoding_to_explicit_params(self):
+        encoded = NIST256p.to_der("explicit")
+
+        self.assertEqual(encoded, bytes(base64.b64decode(self.base64_params)))
+
+    def test_encoding_to_unsupported_type(self):
+        with self.assertRaises(ValueError) as e:
+            NIST256p.to_der("unsupported")
+
+        self.assertIn("Only 'named_curve'", str(e.exception))
+
+    def test_encoding_to_explicit_compressed_params(self):
+        encoded = NIST256p.to_der("explicit", "compressed")
+
+        compressed_base_point = (
+            "MIHAAgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP//////////"
+            "/////zBEBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12Ko6"
+            "k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsEIQNrF9Hy4SxCR/i85uVjpEDydwN9"
+            "gS3rM6D0oTlF2JjClgIhAP////8AAAAA//////////+85vqtpxeehPO5ysL8YyVR"
+            "AgEB"
+        )
+
+        self.assertEqual(
+            encoded, bytes(base64.b64decode(compressed_base_point))
+        )
+
+    def test_decoding_explicit_from_openssl(self):
+        # generated with openssl 1.1.1k using
+        # openssl ecparam -name P-256 -param_enc explicit -out /tmp/file.pem
+        p256_explicit = (
+            "MIH3AgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP//////////"
+            "/////zBbBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12Ko6"
+            "k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsDFQDEnTYIhucEk2pmeOETnSa3gZ9+"
+            "kARBBGsX0fLhLEJH+Lzm5WOkQPJ3A32BLeszoPShOUXYmMKWT+NC4v4af5uO5+tK"
+            "fA+eFivOM1drMV7Oy7ZAaDe/UfUCIQD/////AAAAAP//////////vOb6racXnoTz"
+            "ucrC/GMlUQIBAQ=="
+        )
+
+        decoded = Curve.from_der(bytes(base64.b64decode(p256_explicit)))
+
+        self.assertEqual(NIST256p, decoded)
+
+    def test_decoding_well_known_from_explicit_params(self):
+        curve = Curve.from_der(bytes(base64.b64decode(self.base64_params)))
+
+        self.assertIs(curve, NIST256p)
+
+    def test_decoding_with_incorrect_valid_encodings(self):
+        with self.assertRaises(ValueError) as e:
+            Curve.from_der(b"", ["explicitCA"])
+
+        self.assertIn("Only named_curve", str(e.exception))
+
+    def test_compare_curves_with_different_generators(self):
+        curve_fp = CurveFp(23, 1, 7)
+        base_a = PointJacobi(curve_fp, 13, 3, 1, 9, generator=True)
+        base_b = PointJacobi(curve_fp, 1, 20, 1, 9, generator=True)
+
+        curve_a = Curve("unknown", curve_fp, base_a, None)
+        curve_b = Curve("unknown", curve_fp, base_b, None)
+
+        self.assertNotEqual(curve_a, curve_b)
+
+    def test_default_encode_for_custom_curve(self):
+        curve_fp = CurveFp(23, 1, 7)
+        base_point = PointJacobi(curve_fp, 13, 3, 1, 9, generator=True)
+
+        curve = Curve("unknown", curve_fp, base_point, None)
+
+        encoded = curve.to_der()
+
+        decoded = Curve.from_der(encoded)
+
+        self.assertEqual(curve, decoded)
+
+        expected = "MCECAQEwDAYHKoZIzj0BAQIBFzAGBAEBBAEHBAMEDQMCAQk="
+
+        self.assertEqual(encoded, bytes(base64.b64decode(expected)))
+
+    def test_named_curve_encode_for_custom_curve(self):
+        curve_fp = CurveFp(23, 1, 7)
+        base_point = PointJacobi(curve_fp, 13, 3, 1, 9, generator=True)
+
+        curve = Curve("unknown", curve_fp, base_point, None)
+
+        with self.assertRaises(UnknownCurveError) as e:
+            curve.to_der("named_curve")
+
+        self.assertIn("Can't encode curve", str(e.exception))
+
+    def test_try_decoding_binary_explicit(self):
+        sect113r1_explicit = (
+            "MIGRAgEBMBwGByqGSM49AQIwEQIBcQYJKoZIzj0BAgMCAgEJMDkEDwAwiCUMpufH"
+            "/mSc6Fgg9wQPAOi+5NPiJgdEGIvg6ccjAxUAEOcjqxTWluZ2h1YVF1b+v4/LSakE"
+            "HwQAnXNhbzX0qxQH1zViwQ8ApSgwJ3lY7oTRMV7TGIYCDwEAAAAAAAAA2czsijnl"
+            "bwIBAg=="
+        )
+
+        with self.assertRaises(UnknownCurveError) as e:
+            Curve.from_der(base64.b64decode(sect113r1_explicit))
+
+        self.assertIn("Characteristic 2 curves unsupported", str(e.exception))
+
+    def test_decode_malformed_named_curve(self):
+        bad_der = der.encode_oid(*NIST256p.oid) + der.encode_integer(1)
+
+        with self.assertRaises(der.UnexpectedDER) as e:
+            Curve.from_der(bad_der)
+
+        self.assertIn("Unexpected data after OID", str(e.exception))
+
+    def test_decode_malformed_explicit_garbage_after_ECParam(self):
+        bad_der = bytes(
+            base64.b64decode(self.base64_params)
+        ) + der.encode_integer(1)
+
+        with self.assertRaises(der.UnexpectedDER) as e:
+            Curve.from_der(bad_der)
+
+        self.assertIn("Unexpected data after ECParameters", str(e.exception))
+
+    def test_decode_malformed_unknown_version_number(self):
+        bad_der = der.encode_sequence(der.encode_integer(2))
+
+        with self.assertRaises(der.UnexpectedDER) as e:
+            Curve.from_der(bad_der)
+
+        self.assertIn("Unknown parameter encoding format", str(e.exception))
+
+    def test_decode_malformed_unknown_field_type(self):
+        curve_p = NIST256p.curve.p()
+        bad_der = der.encode_sequence(
+            der.encode_integer(1),
+            der.encode_sequence(
+                der.encode_oid(1, 2, 3), der.encode_integer(curve_p)
+            ),
+            der.encode_sequence(
+                der.encode_octet_string(
+                    number_to_string(NIST256p.curve.a() % curve_p, curve_p)
+                ),
+                der.encode_octet_string(
+                    number_to_string(NIST256p.curve.b(), curve_p)
+                ),
+            ),
+            der.encode_octet_string(
+                NIST256p.generator.to_bytes("uncompressed")
+            ),
+            der.encode_integer(NIST256p.generator.order()),
+        )
+
+        with self.assertRaises(UnknownCurveError) as e:
+            Curve.from_der(bad_der)
+
+        self.assertIn("Unknown field type: (1, 2, 3)", str(e.exception))
+
+    def test_decode_malformed_garbage_after_prime(self):
+        curve_p = NIST256p.curve.p()
+        bad_der = der.encode_sequence(
+            der.encode_integer(1),
+            der.encode_sequence(
+                der.encode_oid(*PRIME_FIELD_OID),
+                der.encode_integer(curve_p),
+                der.encode_integer(1),
+            ),
+            der.encode_sequence(
+                der.encode_octet_string(
+                    number_to_string(NIST256p.curve.a() % curve_p, curve_p)
+                ),
+                der.encode_octet_string(
+                    number_to_string(NIST256p.curve.b(), curve_p)
+                ),
+            ),
+            der.encode_octet_string(
+                NIST256p.generator.to_bytes("uncompressed")
+            ),
+            der.encode_integer(NIST256p.generator.order()),
+        )
+
+        with self.assertRaises(der.UnexpectedDER) as e:
+            Curve.from_der(bad_der)
+
+        self.assertIn("Prime-p element", str(e.exception))
+
+
+class TestCurveSearching(unittest.TestCase):
+    def test_correct_name(self):
+        c = curve_by_name("NIST256p")
+        self.assertIs(c, NIST256p)
+
+    def test_openssl_name(self):
+        c = curve_by_name("prime256v1")
+        self.assertIs(c, NIST256p)
+
+    def test_unknown_curve(self):
+        with self.assertRaises(UnknownCurveError) as e:
+            curve_by_name("foo bar")
+
+        self.assertIn(
+            "name 'foo bar' unknown, only curves supported: "
+            "['NIST192p', 'NIST224p'",
+            str(e.exception),
+        )
+
+    def test_with_None_as_parameter(self):
+        with self.assertRaises(UnknownCurveError) as e:
+            curve_by_name(None)
+
+        self.assertIn(
+            "name None unknown, only curves supported: "
+            "['NIST192p', 'NIST224p'",
+            str(e.exception),
+        )
+
+
+@pytest.mark.parametrize("curve", curves, ids=[i.name for i in curves])
+def test_curve_params_encode_decode_named(curve):
+    ret = Curve.from_der(curve.to_der("named_curve"))
+
+    assert curve == ret
+
+
+@pytest.mark.parametrize("curve", curves, ids=[i.name for i in curves])
+def test_curve_params_encode_decode_explicit(curve):
+    if isinstance(curve.curve, CurveEdTw):
+        with pytest.raises(UnknownCurveError):
+            curve.to_der("explicit")
+    else:
+        ret = Curve.from_der(curve.to_der("explicit"))
+
+        assert curve == ret
+
+
+@pytest.mark.parametrize("curve", curves, ids=[i.name for i in curves])
+def test_curve_params_encode_decode_default(curve):
+    ret = Curve.from_der(curve.to_der())
+
+    assert curve == ret
+
+
+@pytest.mark.parametrize("curve", curves, ids=[i.name for i in curves])
+def test_curve_params_encode_decode_explicit_compressed(curve):
+    if isinstance(curve.curve, CurveEdTw):
+        with pytest.raises(UnknownCurveError):
+            curve.to_der("explicit", "compressed")
+    else:
+        ret = Curve.from_der(curve.to_der("explicit", "compressed"))
+
+        assert curve == ret
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_der.py b/myenv/lib/python3.9/site-packages/ecdsa/test_der.py
new file mode 100644
index 0000000..0ca5bd7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_der.py
@@ -0,0 +1,476 @@
+# compatibility with Python 2.6, for that we need unittest2 package,
+# which is not available on 3.3 or 3.4
+import warnings
+from binascii import hexlify
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+from six import b
+import hypothesis.strategies as st
+from hypothesis import given
+import pytest
+from ._compat import str_idx_as_int
+from .curves import NIST256p, NIST224p
+from .der import (
+    remove_integer,
+    UnexpectedDER,
+    read_length,
+    encode_bitstring,
+    remove_bitstring,
+    remove_object,
+    encode_oid,
+    remove_constructed,
+    remove_octet_string,
+    remove_sequence,
+)
+
+
+class TestRemoveInteger(unittest.TestCase):
+    # DER requires the integers to be 0-padded only if they would be
+    # interpreted as negative, check if those errors are detected
+    def test_non_minimal_encoding(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_integer(b("\x02\x02\x00\x01"))
+
+    def test_negative_with_high_bit_set(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_integer(b("\x02\x01\x80"))
+
+    def test_minimal_with_high_bit_set(self):
+        val, rem = remove_integer(b("\x02\x02\x00\x80"))
+
+        self.assertEqual(val, 0x80)
+        self.assertEqual(rem, b"")
+
+    def test_two_zero_bytes_with_high_bit_set(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_integer(b("\x02\x03\x00\x00\xff"))
+
+    def test_zero_length_integer(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_integer(b("\x02\x00"))
+
+    def test_empty_string(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_integer(b(""))
+
+    def test_encoding_of_zero(self):
+        val, rem = remove_integer(b("\x02\x01\x00"))
+
+        self.assertEqual(val, 0)
+        self.assertEqual(rem, b"")
+
+    def test_encoding_of_127(self):
+        val, rem = remove_integer(b("\x02\x01\x7f"))
+
+        self.assertEqual(val, 127)
+        self.assertEqual(rem, b"")
+
+    def test_encoding_of_128(self):
+        val, rem = remove_integer(b("\x02\x02\x00\x80"))
+
+        self.assertEqual(val, 128)
+        self.assertEqual(rem, b"")
+
+    def test_wrong_tag(self):
+        with self.assertRaises(UnexpectedDER) as e:
+            remove_integer(b"\x01\x02\x00\x80")
+
+        self.assertIn("wanted type 'integer'", str(e.exception))
+
+    def test_wrong_length(self):
+        with self.assertRaises(UnexpectedDER) as e:
+            remove_integer(b"\x02\x03\x00\x80")
+
+        self.assertIn("Length longer", str(e.exception))
+
+
+class TestReadLength(unittest.TestCase):
+    # DER requires the lengths between 0 and 127 to be encoded using the short
+    # form and lengths above that encoded with minimal number of bytes
+    # necessary
+    def test_zero_length(self):
+        self.assertEqual((0, 1), read_length(b("\x00")))
+
+    def test_two_byte_zero_length(self):
+        with self.assertRaises(UnexpectedDER):
+            read_length(b("\x81\x00"))
+
+    def test_two_byte_small_length(self):
+        with self.assertRaises(UnexpectedDER):
+            read_length(b("\x81\x7f"))
+
+    def test_long_form_with_zero_length(self):
+        with self.assertRaises(UnexpectedDER):
+            read_length(b("\x80"))
+
+    def test_smallest_two_byte_length(self):
+        self.assertEqual((128, 2), read_length(b("\x81\x80")))
+
+    def test_zero_padded_length(self):
+        with self.assertRaises(UnexpectedDER):
+            read_length(b("\x82\x00\x80"))
+
+    def test_two_three_byte_length(self):
+        self.assertEqual((256, 3), read_length(b"\x82\x01\x00"))
+
+    def test_empty_string(self):
+        with self.assertRaises(UnexpectedDER):
+            read_length(b(""))
+
+    def test_length_overflow(self):
+        with self.assertRaises(UnexpectedDER):
+            read_length(b("\x83\x01\x00"))
+
+
+class TestEncodeBitstring(unittest.TestCase):
+    # DER requires BIT STRINGS to include a number of padding bits in the
+    # encoded byte string, that padding must be between 0 and 7
+
+    def test_old_call_convention(self):
+        """This is the old way to use the function."""
+        warnings.simplefilter("always")
+        with pytest.warns(DeprecationWarning) as warns:
+            der = encode_bitstring(b"\x00\xff")
+
+        self.assertEqual(len(warns), 1)
+        self.assertIn(
+            "unused= needs to be specified", warns[0].message.args[0]
+        )
+
+        self.assertEqual(der, b"\x03\x02\x00\xff")
+
+    def test_new_call_convention(self):
+        """This is how it should be called now."""
+        warnings.simplefilter("always")
+        with pytest.warns(None) as warns:
+            der = encode_bitstring(b"\xff", 0)
+
+        # verify that new call convention doesn't raise Warnings
+        self.assertEqual(len(warns), 0)
+
+        self.assertEqual(der, b"\x03\x02\x00\xff")
+
+    def test_implicit_unused_bits(self):
+        """
+        Writing bit string with already included the number of unused bits.
+        """
+        warnings.simplefilter("always")
+        with pytest.warns(None) as warns:
+            der = encode_bitstring(b"\x00\xff", None)
+
+        # verify that new call convention doesn't raise Warnings
+        self.assertEqual(len(warns), 0)
+
+        self.assertEqual(der, b"\x03\x02\x00\xff")
+
+    def test_explicit_unused_bits(self):
+        der = encode_bitstring(b"\xff\xf0", 4)
+
+        self.assertEqual(der, b"\x03\x03\x04\xff\xf0")
+
+    def test_empty_string(self):
+        self.assertEqual(encode_bitstring(b"", 0), b"\x03\x01\x00")
+
+    def test_invalid_unused_count(self):
+        with self.assertRaises(ValueError):
+            encode_bitstring(b"\xff\x00", 8)
+
+    def test_invalid_unused_with_empty_string(self):
+        with self.assertRaises(ValueError):
+            encode_bitstring(b"", 1)
+
+    def test_non_zero_padding_bits(self):
+        with self.assertRaises(ValueError):
+            encode_bitstring(b"\xff", 2)
+
+
+class TestRemoveBitstring(unittest.TestCase):
+    def test_old_call_convention(self):
+        """This is the old way to call the function."""
+        warnings.simplefilter("always")
+        with pytest.warns(DeprecationWarning) as warns:
+            bits, rest = remove_bitstring(b"\x03\x02\x00\xff")
+
+        self.assertEqual(len(warns), 1)
+        self.assertIn(
+            "expect_unused= needs to be specified", warns[0].message.args[0]
+        )
+
+        self.assertEqual(bits, b"\x00\xff")
+        self.assertEqual(rest, b"")
+
+    def test_new_call_convention(self):
+        warnings.simplefilter("always")
+        with pytest.warns(None) as warns:
+            bits, rest = remove_bitstring(b"\x03\x02\x00\xff", 0)
+
+        self.assertEqual(len(warns), 0)
+
+        self.assertEqual(bits, b"\xff")
+        self.assertEqual(rest, b"")
+
+    def test_implicit_unexpected_unused(self):
+        warnings.simplefilter("always")
+        with pytest.warns(None) as warns:
+            bits, rest = remove_bitstring(b"\x03\x02\x00\xff", None)
+
+        self.assertEqual(len(warns), 0)
+
+        self.assertEqual(bits, (b"\xff", 0))
+        self.assertEqual(rest, b"")
+
+    def test_with_padding(self):
+        ret, rest = remove_bitstring(b"\x03\x02\x04\xf0", None)
+
+        self.assertEqual(ret, (b"\xf0", 4))
+        self.assertEqual(rest, b"")
+
+    def test_not_a_bitstring(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_bitstring(b"\x02\x02\x00\xff", None)
+
+    def test_empty_encoding(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_bitstring(b"\x03\x00", None)
+
+    def test_empty_string(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_bitstring(b"", None)
+
+    def test_no_length(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_bitstring(b"\x03", None)
+
+    def test_unexpected_number_of_unused_bits(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_bitstring(b"\x03\x02\x00\xff", 1)
+
+    def test_invalid_encoding_of_unused_bits(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_bitstring(b"\x03\x03\x08\xff\x00", None)
+
+    def test_invalid_encoding_of_empty_string(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_bitstring(b"\x03\x01\x01", None)
+
+    def test_invalid_padding_bits(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_bitstring(b"\x03\x02\x01\xff", None)
+
+
+class TestStrIdxAsInt(unittest.TestCase):
+    def test_str(self):
+        self.assertEqual(115, str_idx_as_int("str", 0))
+
+    def test_bytes(self):
+        self.assertEqual(115, str_idx_as_int(b"str", 0))
+
+    def test_bytearray(self):
+        self.assertEqual(115, str_idx_as_int(bytearray(b"str"), 0))
+
+
+class TestEncodeOid(unittest.TestCase):
+    def test_pub_key_oid(self):
+        oid_ecPublicKey = encode_oid(1, 2, 840, 10045, 2, 1)
+        self.assertEqual(hexlify(oid_ecPublicKey), b("06072a8648ce3d0201"))
+
+    def test_nist224p_oid(self):
+        self.assertEqual(hexlify(NIST224p.encoded_oid), b("06052b81040021"))
+
+    def test_nist256p_oid(self):
+        self.assertEqual(
+            hexlify(NIST256p.encoded_oid), b"06082a8648ce3d030107"
+        )
+
+    def test_large_second_subid(self):
+        # from X.690, section 8.19.5
+        oid = encode_oid(2, 999, 3)
+        self.assertEqual(oid, b"\x06\x03\x88\x37\x03")
+
+    def test_with_two_subids(self):
+        oid = encode_oid(2, 999)
+        self.assertEqual(oid, b"\x06\x02\x88\x37")
+
+    def test_zero_zero(self):
+        oid = encode_oid(0, 0)
+        self.assertEqual(oid, b"\x06\x01\x00")
+
+    def test_with_wrong_types(self):
+        with self.assertRaises((TypeError, AssertionError)):
+            encode_oid(0, None)
+
+    def test_with_small_first_large_second(self):
+        with self.assertRaises(AssertionError):
+            encode_oid(1, 40)
+
+    def test_small_first_max_second(self):
+        oid = encode_oid(1, 39)
+        self.assertEqual(oid, b"\x06\x01\x4f")
+
+    def test_with_invalid_first(self):
+        with self.assertRaises(AssertionError):
+            encode_oid(3, 39)
+
+
+class TestRemoveObject(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.oid_ecPublicKey = encode_oid(1, 2, 840, 10045, 2, 1)
+
+    def test_pub_key_oid(self):
+        oid, rest = remove_object(self.oid_ecPublicKey)
+        self.assertEqual(rest, b"")
+        self.assertEqual(oid, (1, 2, 840, 10045, 2, 1))
+
+    def test_with_extra_bytes(self):
+        oid, rest = remove_object(self.oid_ecPublicKey + b"more")
+        self.assertEqual(rest, b"more")
+        self.assertEqual(oid, (1, 2, 840, 10045, 2, 1))
+
+    def test_with_large_second_subid(self):
+        # from X.690, section 8.19.5
+        oid, rest = remove_object(b"\x06\x03\x88\x37\x03")
+        self.assertEqual(rest, b"")
+        self.assertEqual(oid, (2, 999, 3))
+
+    def test_with_padded_first_subid(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_object(b"\x06\x02\x80\x00")
+
+    def test_with_padded_second_subid(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_object(b"\x06\x04\x88\x37\x80\x01")
+
+    def test_with_missing_last_byte_of_multi_byte(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_object(b"\x06\x03\x88\x37\x83")
+
+    def test_with_two_subids(self):
+        oid, rest = remove_object(b"\x06\x02\x88\x37")
+        self.assertEqual(rest, b"")
+        self.assertEqual(oid, (2, 999))
+
+    def test_zero_zero(self):
+        oid, rest = remove_object(b"\x06\x01\x00")
+        self.assertEqual(rest, b"")
+        self.assertEqual(oid, (0, 0))
+
+    def test_empty_string(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_object(b"")
+
+    def test_missing_length(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_object(b"\x06")
+
+    def test_empty_oid(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_object(b"\x06\x00")
+
+    def test_empty_oid_overflow(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_object(b"\x06\x01")
+
+    def test_with_wrong_type(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_object(b"\x04\x02\x88\x37")
+
+    def test_with_too_long_length(self):
+        with self.assertRaises(UnexpectedDER):
+            remove_object(b"\x06\x03\x88\x37")
+
+
+class TestRemoveConstructed(unittest.TestCase):
+    def test_simple(self):
+        data = b"\xa1\x02\xff\xaa"
+
+        tag, body, rest = remove_constructed(data)
+
+        self.assertEqual(tag, 0x01)
+        self.assertEqual(body, b"\xff\xaa")
+        self.assertEqual(rest, b"")
+
+    def test_with_malformed_tag(self):
+        data = b"\x01\x02\xff\xaa"
+
+        with self.assertRaises(UnexpectedDER) as e:
+            remove_constructed(data)
+
+        self.assertIn("constructed tag", str(e.exception))
+
+
+class TestRemoveOctetString(unittest.TestCase):
+    def test_simple(self):
+        data = b"\x04\x03\xaa\xbb\xcc"
+        body, rest = remove_octet_string(data)
+        self.assertEqual(body, b"\xaa\xbb\xcc")
+        self.assertEqual(rest, b"")
+
+    def test_with_malformed_tag(self):
+        data = b"\x03\x03\xaa\xbb\xcc"
+        with self.assertRaises(UnexpectedDER) as e:
+            remove_octet_string(data)
+
+        self.assertIn("octetstring", str(e.exception))
+
+
+class TestRemoveSequence(unittest.TestCase):
+    def test_simple(self):
+        data = b"\x30\x02\xff\xaa"
+        body, rest = remove_sequence(data)
+        self.assertEqual(body, b"\xff\xaa")
+        self.assertEqual(rest, b"")
+
+    def test_with_empty_string(self):
+        with self.assertRaises(UnexpectedDER) as e:
+            remove_sequence(b"")
+
+        self.assertIn("Empty string", str(e.exception))
+
+    def test_with_wrong_tag(self):
+        data = b"\x20\x02\xff\xaa"
+
+        with self.assertRaises(UnexpectedDER) as e:
+            remove_sequence(data)
+
+        self.assertIn("wanted type 'sequence'", str(e.exception))
+
+    def test_with_wrong_length(self):
+        data = b"\x30\x03\xff\xaa"
+
+        with self.assertRaises(UnexpectedDER) as e:
+            remove_sequence(data)
+
+        self.assertIn("Length longer", str(e.exception))
+
+
+@st.composite
+def st_oid(draw, max_value=2**512, max_size=50):
+    """
+    Hypothesis strategy that returns valid OBJECT IDENTIFIERs as tuples
+
+    :param max_value: maximum value of any single sub-identifier
+    :param max_size: maximum length of the generated OID
+    """
+    first = draw(st.integers(min_value=0, max_value=2))
+    if first < 2:
+        second = draw(st.integers(min_value=0, max_value=39))
+    else:
+        second = draw(st.integers(min_value=0, max_value=max_value))
+    rest = draw(
+        st.lists(
+            st.integers(min_value=0, max_value=max_value), max_size=max_size
+        )
+    )
+    return (first, second) + tuple(rest)
+
+
+@given(st_oid())
+def test_oids(ids):
+    encoded_oid = encode_oid(*ids)
+    decoded_oid, rest = remove_object(encoded_oid)
+    assert rest == b""
+    assert decoded_oid == ids
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_ecdh.py b/myenv/lib/python3.9/site-packages/ecdsa/test_ecdh.py
new file mode 100644
index 0000000..872d4d1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_ecdh.py
@@ -0,0 +1,441 @@
+import os
+import shutil
+import subprocess
+import pytest
+from binascii import unhexlify
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+
+from .curves import (
+    NIST192p,
+    NIST224p,
+    NIST256p,
+    NIST384p,
+    NIST521p,
+    BRAINPOOLP160r1,
+)
+from .curves import curves
+from .ecdh import (
+    ECDH,
+    InvalidCurveError,
+    InvalidSharedSecretError,
+    NoKeyError,
+    NoCurveError,
+)
+from .keys import SigningKey, VerifyingKey
+from .ellipticcurve import CurveEdTw
+
+
+@pytest.mark.parametrize(
+    "vcurve",
+    curves,
+    ids=[curve.name for curve in curves],
+)
+def test_ecdh_each(vcurve):
+    if isinstance(vcurve.curve, CurveEdTw):
+        pytest.skip("ECDH is not supported for Edwards curves")
+    ecdh1 = ECDH(curve=vcurve)
+    ecdh2 = ECDH(curve=vcurve)
+
+    ecdh2.generate_private_key()
+    ecdh1.load_received_public_key(ecdh2.get_public_key())
+    ecdh2.load_received_public_key(ecdh1.generate_private_key())
+
+    secret1 = ecdh1.generate_sharedsecret_bytes()
+    secret2 = ecdh2.generate_sharedsecret_bytes()
+    assert secret1 == secret2
+
+
+def test_ecdh_both_keys_present():
+    key1 = SigningKey.generate(BRAINPOOLP160r1)
+    key2 = SigningKey.generate(BRAINPOOLP160r1)
+
+    ecdh1 = ECDH(BRAINPOOLP160r1, key1, key2.verifying_key)
+    ecdh2 = ECDH(private_key=key2, public_key=key1.verifying_key)
+
+    secret1 = ecdh1.generate_sharedsecret_bytes()
+    secret2 = ecdh2.generate_sharedsecret_bytes()
+
+    assert secret1 == secret2
+
+
+def test_ecdh_no_public_key():
+    ecdh1 = ECDH(curve=NIST192p)
+
+    with pytest.raises(NoKeyError):
+        ecdh1.generate_sharedsecret_bytes()
+
+    ecdh1.generate_private_key()
+
+    with pytest.raises(NoKeyError):
+        ecdh1.generate_sharedsecret_bytes()
+
+
+class TestECDH(unittest.TestCase):
+    def test_load_key_from_wrong_curve(self):
+        ecdh1 = ECDH()
+        ecdh1.set_curve(NIST192p)
+
+        key1 = SigningKey.generate(BRAINPOOLP160r1)
+
+        with self.assertRaises(InvalidCurveError) as e:
+            ecdh1.load_private_key(key1)
+
+        self.assertIn("Curve mismatch", str(e.exception))
+
+    def test_generate_without_curve(self):
+        ecdh1 = ECDH()
+
+        with self.assertRaises(NoCurveError) as e:
+            ecdh1.generate_private_key()
+
+        self.assertIn("Curve must be set", str(e.exception))
+
+    def test_load_bytes_without_curve_set(self):
+        ecdh1 = ECDH()
+
+        with self.assertRaises(NoCurveError) as e:
+            ecdh1.load_private_key_bytes(b"\x01" * 32)
+
+        self.assertIn("Curve must be set", str(e.exception))
+
+    def test_set_curve_from_received_public_key(self):
+        ecdh1 = ECDH()
+
+        key1 = SigningKey.generate(BRAINPOOLP160r1)
+
+        ecdh1.load_received_public_key(key1.verifying_key)
+
+        self.assertEqual(ecdh1.curve, BRAINPOOLP160r1)
+
+
+def test_ecdh_wrong_public_key_curve():
+    ecdh1 = ECDH(curve=NIST192p)
+    ecdh1.generate_private_key()
+    ecdh2 = ECDH(curve=NIST256p)
+    ecdh2.generate_private_key()
+
+    with pytest.raises(InvalidCurveError):
+        ecdh1.load_received_public_key(ecdh2.get_public_key())
+
+    with pytest.raises(InvalidCurveError):
+        ecdh2.load_received_public_key(ecdh1.get_public_key())
+
+    ecdh1.public_key = ecdh2.get_public_key()
+    ecdh2.public_key = ecdh1.get_public_key()
+
+    with pytest.raises(InvalidCurveError):
+        ecdh1.generate_sharedsecret_bytes()
+
+    with pytest.raises(InvalidCurveError):
+        ecdh2.generate_sharedsecret_bytes()
+
+
+def test_ecdh_invalid_shared_secret_curve():
+    ecdh1 = ECDH(curve=NIST256p)
+    ecdh1.generate_private_key()
+
+    ecdh1.load_received_public_key(
+        SigningKey.generate(NIST256p).get_verifying_key()
+    )
+
+    ecdh1.private_key.privkey.secret_multiplier = ecdh1.private_key.curve.order
+
+    with pytest.raises(InvalidSharedSecretError):
+        ecdh1.generate_sharedsecret_bytes()
+
+
+# https://github.com/scogliani/ecc-test-vectors/blob/master/ecdh_kat/secp192r1.txt
+# https://github.com/scogliani/ecc-test-vectors/blob/master/ecdh_kat/secp256r1.txt
+# https://github.com/coruus/nist-testvectors/blob/master/csrc.nist.gov/groups/STM/cavp/documents/components/ecccdhtestvectors/KAS_ECC_CDH_PrimitiveTest.txt
+@pytest.mark.parametrize(
+    "curve,privatekey,pubkey,secret",
+    [
+        pytest.param(
+            NIST192p,
+            "f17d3fea367b74d340851ca4270dcb24c271f445bed9d527",
+            "42ea6dd9969dd2a61fea1aac7f8e98edcc896c6e55857cc0"
+            "dfbe5d7c61fac88b11811bde328e8a0d12bf01a9d204b523",
+            "803d8ab2e5b6e6fca715737c3a82f7ce3c783124f6d51cd0",
+            id="NIST192p-1",
+        ),
+        pytest.param(
+            NIST192p,
+            "56e853349d96fe4c442448dacb7cf92bb7a95dcf574a9bd5",
+            "deb5712fa027ac8d2f22c455ccb73a91e17b6512b5e030e7"
+            "7e2690a02cc9b28708431a29fb54b87b1f0c14e011ac2125",
+            "c208847568b98835d7312cef1f97f7aa298283152313c29d",
+            id="NIST192p-2",
+        ),
+        pytest.param(
+            NIST192p,
+            "c6ef61fe12e80bf56f2d3f7d0bb757394519906d55500949",
+            "4edaa8efc5a0f40f843663ec5815e7762dddc008e663c20f"
+            "0a9f8dc67a3e60ef6d64b522185d03df1fc0adfd42478279",
+            "87229107047a3b611920d6e3b2c0c89bea4f49412260b8dd",
+            id="NIST192p-3",
+        ),
+        pytest.param(
+            NIST192p,
+            "e6747b9c23ba7044f38ff7e62c35e4038920f5a0163d3cda",
+            "8887c276edeed3e9e866b46d58d895c73fbd80b63e382e88"
+            "04c5097ba6645e16206cfb70f7052655947dd44a17f1f9d5",
+            "eec0bed8fc55e1feddc82158fd6dc0d48a4d796aaf47d46c",
+            id="NIST192p-4",
+        ),
+        pytest.param(
+            NIST192p,
+            "beabedd0154a1afcfc85d52181c10f5eb47adc51f655047d",
+            "0d045f30254adc1fcefa8a5b1f31bf4e739dd327cd18d594"
+            "542c314e41427c08278a08ce8d7305f3b5b849c72d8aff73",
+            "716e743b1b37a2cd8479f0a3d5a74c10ba2599be18d7e2f4",
+            id="NIST192p-5",
+        ),
+        pytest.param(
+            NIST192p,
+            "cf70354226667321d6e2baf40999e2fd74c7a0f793fa8699",
+            "fb35ca20d2e96665c51b98e8f6eb3d79113508d8bccd4516"
+            "368eec0d5bfb847721df6aaff0e5d48c444f74bf9cd8a5a7",
+            "f67053b934459985a315cb017bf0302891798d45d0e19508",
+            id="NIST192p-6",
+        ),
+        pytest.param(
+            NIST224p,
+            "8346a60fc6f293ca5a0d2af68ba71d1dd389e5e40837942df3e43cbd",
+            "af33cd0629bc7e996320a3f40368f74de8704fa37b8fab69abaae280"
+            "882092ccbba7930f419a8a4f9bb16978bbc3838729992559a6f2e2d7",
+            "7d96f9a3bd3c05cf5cc37feb8b9d5209d5c2597464dec3e9983743e8",
+            id="NIST224p",
+        ),
+        pytest.param(
+            NIST256p,
+            "7d7dc5f71eb29ddaf80d6214632eeae03d9058af1fb6d22ed80badb62bc1a534",
+            "700c48f77f56584c5cc632ca65640db91b6bacce3a4df6b42ce7cc838833d287"
+            "db71e509e3fd9b060ddb20ba5c51dcc5948d46fbf640dfe0441782cab85fa4ac",
+            "46fc62106420ff012e54a434fbdd2d25ccc5852060561e68040dd7778997bd7b",
+            id="NIST256p-1",
+        ),
+        pytest.param(
+            NIST256p,
+            "38f65d6dce47676044d58ce5139582d568f64bb16098d179dbab07741dd5caf5",
+            "809f04289c64348c01515eb03d5ce7ac1a8cb9498f5caa50197e58d43a86a7ae"
+            "b29d84e811197f25eba8f5194092cb6ff440e26d4421011372461f579271cda3",
+            "057d636096cb80b67a8c038c890e887d1adfa4195e9b3ce241c8a778c59cda67",
+            id="NIST256p-2",
+        ),
+        pytest.param(
+            NIST256p,
+            "1accfaf1b97712b85a6f54b148985a1bdc4c9bec0bd258cad4b3d603f49f32c8",
+            "a2339c12d4a03c33546de533268b4ad667debf458b464d77443636440ee7fec3"
+            "ef48a3ab26e20220bcda2c1851076839dae88eae962869a497bf73cb66faf536",
+            "2d457b78b4614132477618a5b077965ec90730a8c81a1c75d6d4ec68005d67ec",
+            id="NIST256p-3",
+        ),
+        pytest.param(
+            NIST256p,
+            "207c43a79bfee03db6f4b944f53d2fb76cc49ef1c9c4d34d51b6c65c4db6932d",
+            "df3989b9fa55495719b3cf46dccd28b5153f7808191dd518eff0c3cff2b705ed"
+            "422294ff46003429d739a33206c8752552c8ba54a270defc06e221e0feaf6ac4",
+            "96441259534b80f6aee3d287a6bb17b5094dd4277d9e294f8fe73e48bf2a0024",
+            id="NIST256p-4",
+        ),
+        pytest.param(
+            NIST256p,
+            "59137e38152350b195c9718d39673d519838055ad908dd4757152fd8255c09bf",
+            "41192d2813e79561e6a1d6f53c8bc1a433a199c835e141b05a74a97b0faeb922"
+            "1af98cc45e98a7e041b01cf35f462b7562281351c8ebf3ffa02e33a0722a1328",
+            "19d44c8d63e8e8dd12c22a87b8cd4ece27acdde04dbf47f7f27537a6999a8e62",
+            id="NIST256p-5",
+        ),
+        pytest.param(
+            NIST256p,
+            "f5f8e0174610a661277979b58ce5c90fee6c9b3bb346a90a7196255e40b132ef",
+            "33e82092a0f1fb38f5649d5867fba28b503172b7035574bf8e5b7100a3052792"
+            "f2cf6b601e0a05945e335550bf648d782f46186c772c0f20d3cd0d6b8ca14b2f",
+            "664e45d5bba4ac931cd65d52017e4be9b19a515f669bea4703542a2c525cd3d3",
+            id="NIST256p-6",
+        ),
+        pytest.param(
+            NIST384p,
+            "3cc3122a68f0d95027ad38c067916ba0eb8c38894d22e1b1"
+            "5618b6818a661774ad463b205da88cf699ab4d43c9cf98a1",
+            "a7c76b970c3b5fe8b05d2838ae04ab47697b9eaf52e76459"
+            "2efda27fe7513272734466b400091adbf2d68c58e0c50066"
+            "ac68f19f2e1cb879aed43a9969b91a0839c4c38a49749b66"
+            "1efedf243451915ed0905a32b060992b468c64766fc8437a",
+            "5f9d29dc5e31a163060356213669c8ce132e22f57c9a04f4"
+            "0ba7fcead493b457e5621e766c40a2e3d4d6a04b25e533f1",
+            id="NIST384p",
+        ),
+        pytest.param(
+            NIST521p,
+            "017eecc07ab4b329068fba65e56a1f8890aa935e57134ae0ffcce802735151f4ea"
+            "c6564f6ee9974c5e6887a1fefee5743ae2241bfeb95d5ce31ddcb6f9edb4d6fc47",
+            "00685a48e86c79f0f0875f7bc18d25eb5fc8c0b07e5da4f4370f3a949034085433"
+            "4b1e1b87fa395464c60626124a4e70d0f785601d37c09870ebf176666877a2046d"
+            "01ba52c56fc8776d9e8f5db4f0cc27636d0b741bbe05400697942e80b739884a83"
+            "bde99e0f6716939e632bc8986fa18dccd443a348b6c3e522497955a4f3c302f676",
+            "005fc70477c3e63bc3954bd0df3ea0d1f41ee21746ed95fc5e1fdf90930d5e1366"
+            "72d72cc770742d1711c3c3a4c334a0ad9759436a4d3c5bf6e74b9578fac148c831",
+            id="NIST521p",
+        ),
+    ],
+)
+def test_ecdh_NIST(curve, privatekey, pubkey, secret):
+    ecdh = ECDH(curve=curve)
+    ecdh.load_private_key_bytes(unhexlify(privatekey))
+    ecdh.load_received_public_key_bytes(unhexlify(pubkey))
+
+    sharedsecret = ecdh.generate_sharedsecret_bytes()
+
+    assert sharedsecret == unhexlify(secret)
+
+
+pem_local_private_key = (
+    "-----BEGIN EC PRIVATE KEY-----\n"
+    "MF8CAQEEGF7IQgvW75JSqULpiQQ8op9WH6Uldw6xxaAKBggqhkjOPQMBAaE0AzIA\n"
+    "BLiBd9CE7xf15FY5QIAoNg+fWbSk1yZOYtoGUdzkejWkxbRc9RWTQjqLVXucIJnz\n"
+    "bA==\n"
+    "-----END EC PRIVATE KEY-----\n"
+)
+der_local_private_key = (
+    "305f02010104185ec8420bd6ef9252a942e989043ca29f561fa525770eb1c5a00a06082a864"
+    "8ce3d030101a13403320004b88177d084ef17f5e45639408028360f9f59b4a4d7264e62da06"
+    "51dce47a35a4c5b45cf51593423a8b557b9c2099f36c"
+)
+pem_remote_public_key = (
+    "-----BEGIN PUBLIC KEY-----\n"
+    "MEkwEwYHKoZIzj0CAQYIKoZIzj0DAQEDMgAEuIF30ITvF/XkVjlAgCg2D59ZtKTX\n"
+    "Jk5i2gZR3OR6NaTFtFz1FZNCOotVe5wgmfNs\n"
+    "-----END PUBLIC KEY-----\n"
+)
+der_remote_public_key = (
+    "3049301306072a8648ce3d020106082a8648ce3d03010103320004b88177d084ef17f5e4563"
+    "9408028360f9f59b4a4d7264e62da0651dce47a35a4c5b45cf51593423a8b557b9c2099f36c"
+)
+gshared_secret = "8f457e34982478d1c34b9cd2d0c15911b72dd60d869e2cea"
+
+
+def test_ecdh_pem():
+    ecdh = ECDH()
+    ecdh.load_private_key_pem(pem_local_private_key)
+    ecdh.load_received_public_key_pem(pem_remote_public_key)
+
+    sharedsecret = ecdh.generate_sharedsecret_bytes()
+
+    assert sharedsecret == unhexlify(gshared_secret)
+
+
+def test_ecdh_der():
+    ecdh = ECDH()
+    ecdh.load_private_key_der(unhexlify(der_local_private_key))
+    ecdh.load_received_public_key_der(unhexlify(der_remote_public_key))
+
+    sharedsecret = ecdh.generate_sharedsecret_bytes()
+
+    assert sharedsecret == unhexlify(gshared_secret)
+
+
+# Exception classes used by run_openssl.
+class RunOpenSslError(Exception):
+    pass
+
+
+def run_openssl(cmd):
+    OPENSSL = "openssl"
+    p = subprocess.Popen(
+        [OPENSSL] + cmd.split(),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+    )
+    stdout, ignored = p.communicate()
+    if p.returncode != 0:
+        raise RunOpenSslError(
+            "cmd '%s %s' failed: rc=%s, stdout/err was %s"
+            % (OPENSSL, cmd, p.returncode, stdout)
+        )
+    return stdout.decode()
+
+
+OPENSSL_SUPPORTED_CURVES = set(
+    c.split(":")[0].strip()
+    for c in run_openssl("ecparam -list_curves").split("\n")
+)
+
+
+@pytest.mark.parametrize(
+    "vcurve",
+    curves,
+    ids=[curve.name for curve in curves],
+)
+def test_ecdh_with_openssl(vcurve):
+    if isinstance(vcurve.curve, CurveEdTw):
+        pytest.skip("Edwards curves are not supported for ECDH")
+
+    assert vcurve.openssl_name
+
+    if vcurve.openssl_name not in OPENSSL_SUPPORTED_CURVES:
+        pytest.skip("system openssl does not support " + vcurve.openssl_name)
+
+    try:
+        hlp = run_openssl("pkeyutl -help")
+        if hlp.find("-derive") == 0:  # pragma: no cover
+            pytest.skip("system openssl does not support `pkeyutl -derive`")
+    except RunOpenSslError:  # pragma: no cover
+        pytest.skip("system openssl could not be executed")
+
+    if os.path.isdir("t"):  # pragma: no branch
+        shutil.rmtree("t")
+    os.mkdir("t")
+    run_openssl(
+        "ecparam -name %s -genkey -out t/privkey1.pem" % vcurve.openssl_name
+    )
+    run_openssl(
+        "ecparam -name %s -genkey -out t/privkey2.pem" % vcurve.openssl_name
+    )
+    run_openssl("ec -in t/privkey1.pem -pubout -out t/pubkey1.pem")
+
+    ecdh1 = ECDH(curve=vcurve)
+    ecdh2 = ECDH(curve=vcurve)
+    with open("t/privkey1.pem") as e:
+        key = e.read()
+    ecdh1.load_private_key_pem(key)
+    with open("t/privkey2.pem") as e:
+        key = e.read()
+    ecdh2.load_private_key_pem(key)
+
+    with open("t/pubkey1.pem") as e:
+        key = e.read()
+    vk1 = VerifyingKey.from_pem(key)
+    assert vk1.to_string() == ecdh1.get_public_key().to_string()
+    vk2 = ecdh2.get_public_key()
+    with open("t/pubkey2.pem", "wb") as e:
+        e.write(vk2.to_pem())
+
+    ecdh1.load_received_public_key(vk2)
+    ecdh2.load_received_public_key(vk1)
+    secret1 = ecdh1.generate_sharedsecret_bytes()
+    secret2 = ecdh2.generate_sharedsecret_bytes()
+
+    assert secret1 == secret2
+
+    run_openssl(
+        "pkeyutl -derive -inkey t/privkey1.pem -peerkey t/pubkey2.pem -out t/secret1"
+    )
+    run_openssl(
+        "pkeyutl -derive -inkey t/privkey2.pem -peerkey t/pubkey1.pem -out t/secret2"
+    )
+
+    with open("t/secret1", "rb") as e:
+        ssl_secret1 = e.read()
+    with open("t/secret1", "rb") as e:
+        ssl_secret2 = e.read()
+
+    assert len(ssl_secret1) == vk1.curve.verifying_key_length // 2
+    assert len(secret1) == vk1.curve.verifying_key_length // 2
+
+    assert ssl_secret1 == ssl_secret2
+    assert secret1 == ssl_secret1
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_ecdsa.py b/myenv/lib/python3.9/site-packages/ecdsa/test_ecdsa.py
new file mode 100644
index 0000000..dbc4a6e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_ecdsa.py
@@ -0,0 +1,661 @@
+from __future__ import print_function
+import sys
+import hypothesis.strategies as st
+from hypothesis import given, settings, note, example
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+import pytest
+from .ecdsa import (
+    Private_key,
+    Public_key,
+    Signature,
+    generator_192,
+    digest_integer,
+    ellipticcurve,
+    point_is_valid,
+    generator_224,
+    generator_256,
+    generator_384,
+    generator_521,
+    generator_secp256k1,
+    curve_192,
+    InvalidPointError,
+    curve_112r2,
+    generator_112r2,
+    int_to_string,
+)
+
+
+HYP_SETTINGS = {}
+# old hypothesis doesn't have the "deadline" setting
+if sys.version_info > (2, 7):  # pragma: no branch
+    # SEC521p is slow, allow long execution for it
+    HYP_SETTINGS["deadline"] = 5000
+
+
+class TestP192FromX9_62(unittest.TestCase):
+    """Check test vectors from X9.62"""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.d = 651056770906015076056810763456358567190100156695615665659
+        cls.Q = cls.d * generator_192
+        cls.k = 6140507067065001063065065565667405560006161556565665656654
+        cls.R = cls.k * generator_192
+
+        cls.msg = 968236873715988614170569073515315707566766479517
+        cls.pubk = Public_key(generator_192, generator_192 * cls.d)
+        cls.privk = Private_key(cls.pubk, cls.d)
+        cls.sig = cls.privk.sign(cls.msg, cls.k)
+
+    def test_point_multiplication(self):
+        assert self.Q.x() == 0x62B12D60690CDCF330BABAB6E69763B471F994DD702D16A5
+
+    def test_point_multiplication_2(self):
+        assert self.R.x() == 0x885052380FF147B734C330C43D39B2C4A89F29B0F749FEAD
+        assert self.R.y() == 0x9CF9FA1CBEFEFB917747A3BB29C072B9289C2547884FD835
+
+    def test_mult_and_addition(self):
+        u1 = 2563697409189434185194736134579731015366492496392189760599
+        u2 = 6266643813348617967186477710235785849136406323338782220568
+        temp = u1 * generator_192 + u2 * self.Q
+        assert temp.x() == 0x885052380FF147B734C330C43D39B2C4A89F29B0F749FEAD
+        assert temp.y() == 0x9CF9FA1CBEFEFB917747A3BB29C072B9289C2547884FD835
+
+    def test_signature(self):
+        r, s = self.sig.r, self.sig.s
+        assert r == 3342403536405981729393488334694600415596881826869351677613
+        assert s == 5735822328888155254683894997897571951568553642892029982342
+
+    def test_verification(self):
+        assert self.pubk.verifies(self.msg, self.sig)
+
+    def test_rejection(self):
+        assert not self.pubk.verifies(self.msg - 1, self.sig)
+
+
+class TestPublicKey(unittest.TestCase):
+    def test_equality_public_keys(self):
+        gen = generator_192
+        x = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+        y = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+        point = ellipticcurve.Point(gen.curve(), x, y)
+        pub_key1 = Public_key(gen, point)
+        pub_key2 = Public_key(gen, point)
+        self.assertEqual(pub_key1, pub_key2)
+
+    def test_inequality_public_key(self):
+        gen = generator_192
+        x1 = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+        y1 = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+        point1 = ellipticcurve.Point(gen.curve(), x1, y1)
+
+        x2 = 0x6A223D00BD22C52833409A163E057E5B5DA1DEF2A197DD15
+        y2 = 0x7B482604199367F1F303F9EF627F922F97023E90EAE08ABF
+        point2 = ellipticcurve.Point(gen.curve(), x2, y2)
+
+        pub_key1 = Public_key(gen, point1)
+        pub_key2 = Public_key(gen, point2)
+        self.assertNotEqual(pub_key1, pub_key2)
+
+    def test_inequality_different_curves(self):
+        gen = generator_192
+        x1 = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+        y1 = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+        point1 = ellipticcurve.Point(gen.curve(), x1, y1)
+
+        x2 = 0x722BA0FB6B8FC8898A4C6AB49E66
+        y2 = 0x2B7344BB57A7ABC8CA0F1A398C7D
+        point2 = ellipticcurve.Point(generator_112r2.curve(), x2, y2)
+
+        pub_key1 = Public_key(gen, point1)
+        pub_key2 = Public_key(generator_112r2, point2)
+        self.assertNotEqual(pub_key1, pub_key2)
+
+    def test_inequality_public_key_not_implemented(self):
+        gen = generator_192
+        x = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+        y = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+        point = ellipticcurve.Point(gen.curve(), x, y)
+        pub_key = Public_key(gen, point)
+        self.assertNotEqual(pub_key, None)
+
+    def test_public_key_with_generator_without_order(self):
+        gen = ellipticcurve.PointJacobi(
+            generator_192.curve(), generator_192.x(), generator_192.y(), 1
+        )
+
+        x = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+        y = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+        point = ellipticcurve.Point(gen.curve(), x, y)
+
+        with self.assertRaises(InvalidPointError) as e:
+            Public_key(gen, point)
+
+        self.assertIn("Generator point must have order", str(e.exception))
+
+    def test_public_point_on_curve_not_scalar_multiple_of_base_point(self):
+        x = 2
+        y = 0xBE6AA4938EF7CFE6FE29595B6B00
+        # we need a curve with cofactor != 1
+        point = ellipticcurve.PointJacobi(curve_112r2, x, y, 1)
+
+        self.assertTrue(curve_112r2.contains_point(x, y))
+
+        with self.assertRaises(InvalidPointError) as e:
+            Public_key(generator_112r2, point)
+
+        self.assertIn("Generator point order", str(e.exception))
+
+    def test_point_is_valid_with_not_scalar_multiple_of_base_point(self):
+        x = 2
+        y = 0xBE6AA4938EF7CFE6FE29595B6B00
+
+        self.assertFalse(point_is_valid(generator_112r2, x, y))
+
+    # the tests to verify the extensiveness of tests in ecdsa.ecdsa
+    # if PointJacobi gets modified to calculate the x and y mod p the tests
+    # below will need to use a fake/mock object
+    def test_invalid_point_x_negative(self):
+        pt = ellipticcurve.PointJacobi(curve_192, -1, 0, 1)
+
+        with self.assertRaises(InvalidPointError) as e:
+            Public_key(generator_192, pt)
+
+        self.assertIn("The public point has x or y", str(e.exception))
+
+    def test_invalid_point_x_equal_p(self):
+        pt = ellipticcurve.PointJacobi(curve_192, curve_192.p(), 0, 1)
+
+        with self.assertRaises(InvalidPointError) as e:
+            Public_key(generator_192, pt)
+
+        self.assertIn("The public point has x or y", str(e.exception))
+
+    def test_invalid_point_y_negative(self):
+        pt = ellipticcurve.PointJacobi(curve_192, 0, -1, 1)
+
+        with self.assertRaises(InvalidPointError) as e:
+            Public_key(generator_192, pt)
+
+        self.assertIn("The public point has x or y", str(e.exception))
+
+    def test_invalid_point_y_equal_p(self):
+        pt = ellipticcurve.PointJacobi(curve_192, 0, curve_192.p(), 1)
+
+        with self.assertRaises(InvalidPointError) as e:
+            Public_key(generator_192, pt)
+
+        self.assertIn("The public point has x or y", str(e.exception))
+
+
+class TestPublicKeyVerifies(unittest.TestCase):
+    # test all the different ways that a signature can be publicly invalid
+    @classmethod
+    def setUpClass(cls):
+        gen = generator_192
+        x = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+        y = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+        point = ellipticcurve.Point(gen.curve(), x, y)
+
+        cls.pub_key = Public_key(gen, point)
+
+    def test_sig_with_r_zero(self):
+        sig = Signature(0, 1)
+
+        self.assertFalse(self.pub_key.verifies(1, sig))
+
+    def test_sig_with_r_order(self):
+        sig = Signature(generator_192.order(), 1)
+
+        self.assertFalse(self.pub_key.verifies(1, sig))
+
+    def test_sig_with_s_zero(self):
+        sig = Signature(1, 0)
+
+        self.assertFalse(self.pub_key.verifies(1, sig))
+
+    def test_sig_with_s_order(self):
+        sig = Signature(1, generator_192.order())
+
+        self.assertFalse(self.pub_key.verifies(1, sig))
+
+
+class TestPrivateKey(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        gen = generator_192
+        x = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+        y = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+        point = ellipticcurve.Point(gen.curve(), x, y)
+        cls.pub_key = Public_key(gen, point)
+
+    def test_equality_private_keys(self):
+        pr_key1 = Private_key(self.pub_key, 100)
+        pr_key2 = Private_key(self.pub_key, 100)
+        self.assertEqual(pr_key1, pr_key2)
+
+    def test_inequality_private_keys(self):
+        pr_key1 = Private_key(self.pub_key, 100)
+        pr_key2 = Private_key(self.pub_key, 200)
+        self.assertNotEqual(pr_key1, pr_key2)
+
+    def test_inequality_private_keys_not_implemented(self):
+        pr_key = Private_key(self.pub_key, 100)
+        self.assertNotEqual(pr_key, None)
+
+
+# Testing point validity, as per ECDSAVS.pdf B.2.2:
+P192_POINTS = [
+    (
+        generator_192,
+        0xCD6D0F029A023E9AACA429615B8F577ABEE685D8257CC83A,
+        0x00019C410987680E9FB6C0B6ECC01D9A2647C8BAE27721BACDFC,
+        False,
+    ),
+    (
+        generator_192,
+        0x00017F2FCE203639E9EAF9FB50B81FC32776B30E3B02AF16C73B,
+        0x95DA95C5E72DD48E229D4748D4EEE658A9A54111B23B2ADB,
+        False,
+    ),
+    (
+        generator_192,
+        0x4F77F8BC7FCCBADD5760F4938746D5F253EE2168C1CF2792,
+        0x000147156FF824D131629739817EDB197717C41AAB5C2A70F0F6,
+        False,
+    ),
+    (
+        generator_192,
+        0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6,
+        0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F,
+        True,
+    ),
+    (
+        generator_192,
+        0xCDF56C1AA3D8AFC53C521ADF3FFB96734A6A630A4A5B5A70,
+        0x97C1C44A5FB229007B5EC5D25F7413D170068FFD023CAA4E,
+        True,
+    ),
+    (
+        generator_192,
+        0x89009C0DC361C81E99280C8E91DF578DF88CDF4B0CDEDCED,
+        0x27BE44A529B7513E727251F128B34262A0FD4D8EC82377B9,
+        True,
+    ),
+    (
+        generator_192,
+        0x6A223D00BD22C52833409A163E057E5B5DA1DEF2A197DD15,
+        0x7B482604199367F1F303F9EF627F922F97023E90EAE08ABF,
+        True,
+    ),
+    (
+        generator_192,
+        0x6DCCBDE75C0948C98DAB32EA0BC59FE125CF0FB1A3798EDA,
+        0x0001171A3E0FA60CF3096F4E116B556198DE430E1FBD330C8835,
+        False,
+    ),
+    (
+        generator_192,
+        0xD266B39E1F491FC4ACBBBC7D098430931CFA66D55015AF12,
+        0x193782EB909E391A3148B7764E6B234AA94E48D30A16DBB2,
+        False,
+    ),
+    (
+        generator_192,
+        0x9D6DDBCD439BAA0C6B80A654091680E462A7D1D3F1FFEB43,
+        0x6AD8EFC4D133CCF167C44EB4691C80ABFFB9F82B932B8CAA,
+        False,
+    ),
+    (
+        generator_192,
+        0x146479D944E6BDA87E5B35818AA666A4C998A71F4E95EDBC,
+        0xA86D6FE62BC8FBD88139693F842635F687F132255858E7F6,
+        False,
+    ),
+    (
+        generator_192,
+        0xE594D4A598046F3598243F50FD2C7BD7D380EDB055802253,
+        0x509014C0C4D6B536E3CA750EC09066AF39B4C8616A53A923,
+        False,
+    ),
+]
+
+
+@pytest.mark.parametrize("generator,x,y,expected", P192_POINTS)
+def test_point_validity(generator, x, y, expected):
+    """
+    `generator` defines the curve; is `(x, y)` a point on
+    this curve? `expected` is True if the right answer is Yes.
+    """
+    assert point_is_valid(generator, x, y) == expected
+
+
+# Trying signature-verification tests from ECDSAVS.pdf B.2.4:
+CURVE_192_KATS = [
+    (
+        generator_192,
+        int(
+            "0x84ce72aa8699df436059f052ac51b6398d2511e49631bcb7e71f89c499b9ee"
+            "425dfbc13a5f6d408471b054f2655617cbbaf7937b7c80cd8865cf02c8487d30"
+            "d2b0fbd8b2c4e102e16d828374bbc47b93852f212d5043c3ea720f086178ff79"
+            "8cc4f63f787b9c2e419efa033e7644ea7936f54462dc21a6c4580725f7f0e7d1"
+            "58",
+            16,
+        ),
+        0xD9DBFB332AA8E5FF091E8CE535857C37C73F6250FFB2E7AC,
+        0x282102E364FEDED3AD15DDF968F88D8321AA268DD483EBC4,
+        0x64DCA58A20787C488D11D6DD96313F1B766F2D8EFE122916,
+        0x1ECBA28141E84AB4ECAD92F56720E2CC83EB3D22DEC72479,
+        True,
+    ),
+    (
+        generator_192,
+        int(
+            "0x94bb5bacd5f8ea765810024db87f4224ad71362a3c28284b2b9f39fab86db1"
+            "2e8beb94aae899768229be8fdb6c4f12f28912bb604703a79ccff769c1607f5a"
+            "91450f30ba0460d359d9126cbd6296be6d9c4bb96c0ee74cbb44197c207f6db3"
+            "26ab6f5a659113a9034e54be7b041ced9dcf6458d7fb9cbfb2744d999f7dfd63"
+            "f4",
+            16,
+        ),
+        0x3E53EF8D3112AF3285C0E74842090712CD324832D4277AE7,
+        0xCC75F8952D30AEC2CBB719FC6AA9934590B5D0FF5A83ADB7,
+        0x8285261607283BA18F335026130BAB31840DCFD9C3E555AF,
+        0x356D89E1B04541AFC9704A45E9C535CE4A50929E33D7E06C,
+        True,
+    ),
+    (
+        generator_192,
+        int(
+            "0xf6227a8eeb34afed1621dcc89a91d72ea212cb2f476839d9b4243c66877911"
+            "b37b4ad6f4448792a7bbba76c63bdd63414b6facab7dc71c3396a73bd7ee14cd"
+            "d41a659c61c99b779cecf07bc51ab391aa3252386242b9853ea7da67fd768d30"
+            "3f1b9b513d401565b6f1eb722dfdb96b519fe4f9bd5de67ae131e64b40e78c42"
+            "dd",
+            16,
+        ),
+        0x16335DBE95F8E8254A4E04575D736BEFB258B8657F773CB7,
+        0x421B13379C59BC9DCE38A1099CA79BBD06D647C7F6242336,
+        0x4141BD5D64EA36C5B0BD21EF28C02DA216ED9D04522B1E91,
+        0x159A6AA852BCC579E821B7BB0994C0861FB08280C38DAA09,
+        False,
+    ),
+    (
+        generator_192,
+        int(
+            "0x16b5f93afd0d02246f662761ed8e0dd9504681ed02a253006eb36736b56309"
+            "7ba39f81c8e1bce7a16c1339e345efabbc6baa3efb0612948ae51103382a8ee8"
+            "bc448e3ef71e9f6f7a9676694831d7f5dd0db5446f179bcb737d4a526367a447"
+            "bfe2c857521c7f40b6d7d7e01a180d92431fb0bbd29c04a0c420a57b3ed26ccd"
+            "8a",
+            16,
+        ),
+        0xFD14CDF1607F5EFB7B1793037B15BDF4BAA6F7C16341AB0B,
+        0x83FA0795CC6C4795B9016DAC928FD6BAC32F3229A96312C4,
+        0x8DFDB832951E0167C5D762A473C0416C5C15BC1195667DC1,
+        0x1720288A2DC13FA1EC78F763F8FE2FF7354A7E6FDDE44520,
+        False,
+    ),
+    (
+        generator_192,
+        int(
+            "0x08a2024b61b79d260e3bb43ef15659aec89e5b560199bc82cf7c65c77d3919"
+            "2e03b9a895d766655105edd9188242b91fbde4167f7862d4ddd61e5d4ab55196"
+            "683d4f13ceb90d87aea6e07eb50a874e33086c4a7cb0273a8e1c4408f4b846bc"
+            "eae1ebaac1b2b2ea851a9b09de322efe34cebe601653efd6ddc876ce8c2f2072"
+            "fb",
+            16,
+        ),
+        0x674F941DC1A1F8B763C9334D726172D527B90CA324DB8828,
+        0x65ADFA32E8B236CB33A3E84CF59BFB9417AE7E8EDE57A7FF,
+        0x9508B9FDD7DAF0D8126F9E2BC5A35E4C6D800B5B804D7796,
+        0x36F2BF6B21B987C77B53BB801B3435A577E3D493744BFAB0,
+        False,
+    ),
+    (
+        generator_192,
+        int(
+            "0x1843aba74b0789d4ac6b0b8923848023a644a7b70afa23b1191829bbe4397c"
+            "e15b629bf21a8838298653ed0c19222b95fa4f7390d1b4c844d96e645537e0aa"
+            "e98afb5c0ac3bd0e4c37f8daaff25556c64e98c319c52687c904c4de7240a1cc"
+            "55cd9756b7edaef184e6e23b385726e9ffcba8001b8f574987c1a3fedaaa83ca"
+            "6d",
+            16,
+        ),
+        0x10ECCA1AAD7220B56A62008B35170BFD5E35885C4014A19F,
+        0x04EB61984C6C12ADE3BC47F3C629ECE7AA0A033B9948D686,
+        0x82BFA4E82C0DFE9274169B86694E76CE993FD83B5C60F325,
+        0xA97685676C59A65DBDE002FE9D613431FB183E8006D05633,
+        False,
+    ),
+    (
+        generator_192,
+        int(
+            "0x5a478f4084ddd1a7fea038aa9732a822106385797d02311aeef4d0264f824f"
+            "698df7a48cfb6b578cf3da416bc0799425bb491be5b5ecc37995b85b03420a98"
+            "f2c4dc5c31a69a379e9e322fbe706bbcaf0f77175e05cbb4fa162e0da82010a2"
+            "78461e3e974d137bc746d1880d6eb02aa95216014b37480d84b87f717bb13f76"
+            "e1",
+            16,
+        ),
+        0x6636653CB5B894CA65C448277B29DA3AD101C4C2300F7C04,
+        0xFDF1CBB3FC3FD6A4F890B59E554544175FA77DBDBEB656C1,
+        0xEAC2DDECDDFB79931A9C3D49C08DE0645C783A24CB365E1C,
+        0x3549FEE3CFA7E5F93BC47D92D8BA100E881A2A93C22F8D50,
+        False,
+    ),
+    (
+        generator_192,
+        int(
+            "0xc598774259a058fa65212ac57eaa4f52240e629ef4c310722088292d1d4af6"
+            "c39b49ce06ba77e4247b20637174d0bd67c9723feb57b5ead232b47ea452d5d7"
+            "a089f17c00b8b6767e434a5e16c231ba0efa718a340bf41d67ea2d295812ff1b"
+            "9277daacb8bc27b50ea5e6443bcf95ef4e9f5468fe78485236313d53d1c68f6b"
+            "a2",
+            16,
+        ),
+        0xA82BD718D01D354001148CD5F69B9EBF38FF6F21898F8AAA,
+        0xE67CEEDE07FC2EBFAFD62462A51E4B6C6B3D5B537B7CAF3E,
+        0x4D292486C620C3DE20856E57D3BB72FCDE4A73AD26376955,
+        0xA85289591A6081D5728825520E62FF1C64F94235C04C7F95,
+        False,
+    ),
+    (
+        generator_192,
+        int(
+            "0xca98ed9db081a07b7557f24ced6c7b9891269a95d2026747add9e9eb80638a"
+            "961cf9c71a1b9f2c29744180bd4c3d3db60f2243c5c0b7cc8a8d40a3f9a7fc91"
+            "0250f2187136ee6413ffc67f1a25e1c4c204fa9635312252ac0e0481d89b6d53"
+            "808f0c496ba87631803f6c572c1f61fa049737fdacce4adff757afed4f05beb6"
+            "58",
+            16,
+        ),
+        0x7D3B016B57758B160C4FCA73D48DF07AE3B6B30225126C2F,
+        0x4AF3790D9775742BDE46F8DA876711BE1B65244B2B39E7EC,
+        0x95F778F5F656511A5AB49A5D69DDD0929563C29CBC3A9E62,
+        0x75C87FC358C251B4C83D2DD979FAAD496B539F9F2EE7A289,
+        False,
+    ),
+    (
+        generator_192,
+        int(
+            "0x31dd9a54c8338bea06b87eca813d555ad1850fac9742ef0bbe40dad400e102"
+            "88acc9c11ea7dac79eb16378ebea9490e09536099f1b993e2653cd50240014c9"
+            "0a9c987f64545abc6a536b9bd2435eb5e911fdfde2f13be96ea36ad38df4ae9e"
+            "a387b29cced599af777338af2794820c9cce43b51d2112380a35802ab7e396c9"
+            "7a",
+            16,
+        ),
+        0x9362F28C4EF96453D8A2F849F21E881CD7566887DA8BEB4A,
+        0xE64D26D8D74C48A024AE85D982EE74CD16046F4EE5333905,
+        0xF3923476A296C88287E8DE914B0B324AD5A963319A4FE73B,
+        0xF0BAEED7624ED00D15244D8BA2AEDE085517DBDEC8AC65F5,
+        True,
+    ),
+    (
+        generator_192,
+        int(
+            "0xb2b94e4432267c92f9fdb9dc6040c95ffa477652761290d3c7de312283f645"
+            "0d89cc4aabe748554dfb6056b2d8e99c7aeaad9cdddebdee9dbc099839562d90"
+            "64e68e7bb5f3a6bba0749ca9a538181fc785553a4000785d73cc207922f63e8c"
+            "e1112768cb1de7b673aed83a1e4a74592f1268d8e2a4e9e63d414b5d442bd045"
+            "6d",
+            16,
+        ),
+        0xCC6FC032A846AAAC25533EB033522824F94E670FA997ECEF,
+        0xE25463EF77A029ECCDA8B294FD63DD694E38D223D30862F1,
+        0x066B1D07F3A40E679B620EDA7F550842A35C18B80C5EBE06,
+        0xA0B0FB201E8F2DF65E2C4508EF303BDC90D934016F16B2DC,
+        False,
+    ),
+    (
+        generator_192,
+        int(
+            "0x4366fcadf10d30d086911de30143da6f579527036937007b337f7282460eae"
+            "5678b15cccda853193ea5fc4bc0a6b9d7a31128f27e1214988592827520b214e"
+            "ed5052f7775b750b0c6b15f145453ba3fee24a085d65287e10509eb5d5f602c4"
+            "40341376b95c24e5c4727d4b859bfe1483d20538acdd92c7997fa9c614f0f839"
+            "d7",
+            16,
+        ),
+        0x955C908FE900A996F7E2089BEE2F6376830F76A19135E753,
+        0xBA0C42A91D3847DE4A592A46DC3FDAF45A7CC709B90DE520,
+        0x1F58AD77FC04C782815A1405B0925E72095D906CBF52A668,
+        0xF2E93758B3AF75EDF784F05A6761C9B9A6043C66B845B599,
+        False,
+    ),
+    (
+        generator_192,
+        int(
+            "0x543f8af57d750e33aa8565e0cae92bfa7a1ff78833093421c2942cadf99866"
+            "70a5ff3244c02a8225e790fbf30ea84c74720abf99cfd10d02d34377c3d3b412"
+            "69bea763384f372bb786b5846f58932defa68023136cd571863b304886e95e52"
+            "e7877f445b9364b3f06f3c28da12707673fecb4b8071de06b6e0a3c87da160ce"
+            "f3",
+            16,
+        ),
+        0x31F7FA05576D78A949B24812D4383107A9A45BB5FCCDD835,
+        0x8DC0EB65994A90F02B5E19BD18B32D61150746C09107E76B,
+        0xBE26D59E4E883DDE7C286614A767B31E49AD88789D3A78FF,
+        0x8762CA831C1CE42DF77893C9B03119428E7A9B819B619068,
+        False,
+    ),
+    (
+        generator_192,
+        int(
+            "0xd2e8454143ce281e609a9d748014dcebb9d0bc53adb02443a6aac2ffe6cb009f"
+            "387c346ecb051791404f79e902ee333ad65e5c8cb38dc0d1d39a8dc90add502357"
+            "2720e5b94b190d43dd0d7873397504c0c7aef2727e628eb6a74411f2e400c65670"
+            "716cb4a815dc91cbbfeb7cfe8c929e93184c938af2c078584da045e8f8d1",
+            16,
+        ),
+        0x66AA8EDBBDB5CF8E28CEB51B5BDA891CAE2DF84819FE25C0,
+        0x0C6BC2F69030A7CE58D4A00E3B3349844784A13B8936F8DA,
+        0xA4661E69B1734F4A71B788410A464B71E7FFE42334484F23,
+        0x738421CF5E049159D69C57A915143E226CAC8355E149AFE9,
+        False,
+    ),
+    (
+        generator_192,
+        int(
+            "0x6660717144040f3e2f95a4e25b08a7079c702a8b29babad5a19a87654bc5c5af"
+            "a261512a11b998a4fb36b5d8fe8bd942792ff0324b108120de86d63f65855e5461"
+            "184fc96a0a8ffd2ce6d5dfb0230cbbdd98f8543e361b3205f5da3d500fdc8bac6d"
+            "b377d75ebef3cb8f4d1ff738071ad0938917889250b41dd1d98896ca06fb",
+            16,
+        ),
+        0xBCFACF45139B6F5F690A4C35A5FFFA498794136A2353FC77,
+        0x6F4A6C906316A6AFC6D98FE1F0399D056F128FE0270B0F22,
+        0x9DB679A3DAFE48F7CCAD122933ACFE9DA0970B71C94C21C1,
+        0x984C2DB99827576C0A41A5DA41E07D8CC768BC82F18C9DA9,
+        False,
+    ),
+]
+
+
+@pytest.mark.parametrize("gen,msg,qx,qy,r,s,expected", CURVE_192_KATS)
+def test_signature_validity(gen, msg, qx, qy, r, s, expected):
+    """
+    `msg` = message, `qx` and `qy` represent the base point on
+    elliptic curve of `gen`, `r` and `s` are the signature, and
+    `expected` is True iff the signature is expected to be valid."""
+    pubk = Public_key(gen, ellipticcurve.Point(gen.curve(), qx, qy))
+    assert expected == pubk.verifies(digest_integer(msg), Signature(r, s))
+
+
+@pytest.mark.parametrize(
+    "gen,msg,qx,qy,r,s,expected", [x for x in CURVE_192_KATS if x[6]]
+)
+def test_pk_recovery(gen, msg, r, s, qx, qy, expected):
+    del expected
+    sign = Signature(r, s)
+    pks = sign.recover_public_keys(digest_integer(msg), gen)
+
+    assert pks
+
+    # Test if the signature is valid for all found public keys
+    for pk in pks:
+        q = pk.point
+        test_signature_validity(gen, msg, q.x(), q.y(), r, s, True)
+
+    # Test if the original public key is in the set of found keys
+    original_q = ellipticcurve.Point(gen.curve(), qx, qy)
+    points = [pk.point for pk in pks]
+    assert original_q in points
+
+
+@st.composite
+def st_random_gen_key_msg_nonce(draw):
+    """Hypothesis strategy for test_sig_verify()."""
+    name_gen = {
+        "generator_192": generator_192,
+        "generator_224": generator_224,
+        "generator_256": generator_256,
+        "generator_secp256k1": generator_secp256k1,
+        "generator_384": generator_384,
+        "generator_521": generator_521,
+    }
+    name = draw(st.sampled_from(sorted(name_gen.keys())))
+    note("Generator used: {0}".format(name))
+    generator = name_gen[name]
+    order = int(generator.order())
+
+    key = draw(st.integers(min_value=1, max_value=order))
+    msg = draw(st.integers(min_value=1, max_value=order))
+    nonce = draw(
+        st.integers(min_value=1, max_value=order + 1)
+        | st.integers(min_value=order >> 1, max_value=order)
+    )
+    return generator, key, msg, nonce
+
+
+SIG_VER_SETTINGS = dict(HYP_SETTINGS)
+SIG_VER_SETTINGS["max_examples"] = 10
+
+
+@settings(**SIG_VER_SETTINGS)
+@example((generator_224, 4, 1, 1))
+@given(st_random_gen_key_msg_nonce())
+def test_sig_verify(args):
+    """
+    Check if signing and verification works for arbitrary messages and
+    that signatures for other messages are rejected.
+    """
+    generator, sec_mult, msg, nonce = args
+
+    pubkey = Public_key(generator, generator * sec_mult)
+    privkey = Private_key(pubkey, sec_mult)
+
+    signature = privkey.sign(msg, nonce)
+
+    assert pubkey.verifies(msg, signature)
+
+    assert not pubkey.verifies(msg - 1, signature)
+
+
+def test_int_to_string_with_zero():
+    assert int_to_string(0) == b"\x00"
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_eddsa.py b/myenv/lib/python3.9/site-packages/ecdsa/test_eddsa.py
new file mode 100644
index 0000000..7a09ad7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_eddsa.py
@@ -0,0 +1,1079 @@
+import pickle
+import hashlib
+import pytest
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+from hypothesis import given, settings, example
+import hypothesis.strategies as st
+from .ellipticcurve import PointEdwards, INFINITY, CurveEdTw
+from .eddsa import (
+    generator_ed25519,
+    curve_ed25519,
+    generator_ed448,
+    curve_ed448,
+    PrivateKey,
+    PublicKey,
+)
+from .ecdsa import generator_256, curve_256
+from .errors import MalformedPointError
+from ._compat import a2b_hex, compat26_str
+
+
+class TestA2B_Hex(unittest.TestCase):
+    def test_invalid_input(self):
+        with self.assertRaises(ValueError):
+            a2b_hex("abcdefghi")
+
+
+def test_ed25519_curve_compare():
+    assert curve_ed25519 != curve_256
+
+
+def test_ed25519_and_ed448_compare():
+    assert curve_ed448 != curve_ed25519
+
+
+def test_ed25519_and_custom_curve_compare():
+    a = CurveEdTw(curve_ed25519.p(), -curve_ed25519.a(), 1)
+
+    assert curve_ed25519 != a
+
+
+def test_ed25519_and_almost_exact_curve_compare():
+    a = CurveEdTw(curve_ed25519.p(), curve_ed25519.a(), 1)
+
+    assert curve_ed25519 != a
+
+
+def test_ed25519_and_same_curve_params():
+    a = CurveEdTw(curve_ed25519.p(), curve_ed25519.a(), curve_ed25519.d())
+
+    assert curve_ed25519 == a
+    assert not (curve_ed25519 != a)
+
+
+def test_ed25519_contains_point():
+    g = generator_ed25519
+    assert curve_ed25519.contains_point(g.x(), g.y())
+
+
+def test_ed25519_contains_point_bad():
+    assert not curve_ed25519.contains_point(1, 1)
+
+
+def test_ed25519_double():
+    a = generator_ed25519
+
+    z = a.double()
+
+    assert isinstance(z, PointEdwards)
+
+    x2 = int(
+        "24727413235106541002554574571675588834622768167397638456726423"
+        "682521233608206"
+    )
+    y2 = int(
+        "15549675580280190176352668710449542251549572066445060580507079"
+        "593062643049417"
+    )
+
+    b = PointEdwards(curve_ed25519, x2, y2, 1, x2 * y2)
+
+    assert z == b
+    assert a != b
+
+
+def test_ed25519_add_as_double():
+    a = generator_ed25519
+
+    z = a + a
+
+    assert isinstance(z, PointEdwards)
+
+    b = generator_ed25519.double()
+
+    assert z == b
+
+
+def test_ed25519_double_infinity():
+    a = PointEdwards(curve_ed25519, 0, 1, 1, 0)
+
+    z = a.double()
+
+    assert z is INFINITY
+
+
+def test_ed25519_double_badly_encoded_infinity():
+    # invalid point, mostly to make instrumental happy
+    a = PointEdwards(curve_ed25519, 1, 1, 1, 0)
+
+    z = a.double()
+
+    assert z is INFINITY
+
+
+def test_ed25519_eq_with_different_z():
+    x = generator_ed25519.x()
+    y = generator_ed25519.y()
+    p = curve_ed25519.p()
+
+    a = PointEdwards(curve_ed25519, x * 2 % p, y * 2 % p, 2, x * y * 2 % p)
+    b = PointEdwards(curve_ed25519, x * 3 % p, y * 3 % p, 3, x * y * 3 % p)
+
+    assert a == b
+
+    assert not (a != b)
+
+
+def test_ed25519_eq_against_infinity():
+    assert generator_ed25519 != INFINITY
+
+
+def test_ed25519_eq_encoded_infinity_against_infinity():
+    a = PointEdwards(curve_ed25519, 0, 1, 1, 0)
+    assert a == INFINITY
+
+
+def test_ed25519_eq_bad_encode_of_infinity_against_infinity():
+    # technically incorrect encoding of the point at infinity, but we check
+    # both X and T, so verify that just T==0 works
+    a = PointEdwards(curve_ed25519, 1, 1, 1, 0)
+    assert a == INFINITY
+
+
+def test_ed25519_eq_against_non_Edwards_point():
+    assert generator_ed25519 != generator_256
+
+
+def test_ed25519_eq_against_negated_point():
+    g = generator_ed25519
+    neg = PointEdwards(curve_ed25519, -g.x(), g.y(), 1, -g.x() * g.y())
+    assert g != neg
+
+
+def test_ed25519_eq_x_different_y():
+    # not points on the curve, but __eq__ doesn't care
+    a = PointEdwards(curve_ed25519, 1, 1, 1, 1)
+    b = PointEdwards(curve_ed25519, 1, 2, 1, 2)
+
+    assert a != b
+
+
+def test_ed25519_test_normalisation_and_scaling():
+    x = generator_ed25519.x()
+    y = generator_ed25519.y()
+    p = curve_ed25519.p()
+
+    a = PointEdwards(curve_ed25519, x * 11 % p, y * 11 % p, 11, x * y * 11 % p)
+
+    assert a.x() == x
+    assert a.y() == y
+
+    a.scale()
+
+    assert a.x() == x
+    assert a.y() == y
+
+    a.scale()  # second execution should be a noop
+
+    assert a.x() == x
+    assert a.y() == y
+
+
+def test_ed25519_add_three_times():
+    a = generator_ed25519
+
+    z = a + a + a
+
+    x3 = int(
+        "468967334644549386571235445953867877890461982801326656862413"
+        "21779790909858396"
+    )
+    y3 = int(
+        "832484377853344397649037712036920113830141722629755531674120"
+        "2210403726505172"
+    )
+
+    b = PointEdwards(curve_ed25519, x3, y3, 1, x3 * y3)
+
+    assert z == b
+
+
+def test_ed25519_add_to_infinity():
+    # generator * (order-1)
+    x1 = int(
+        "427838232691226969392843410947554224151809796397784248136826"
+        "78720006717057747"
+    )
+    y1 = int(
+        "463168356949264781694283940034751631413079938662562256157830"
+        "33603165251855960"
+    )
+    inf_m_1 = PointEdwards(curve_ed25519, x1, y1, 1, x1 * y1)
+
+    inf = inf_m_1 + generator_ed25519
+
+    assert inf is INFINITY
+
+
+def test_ed25519_add_and_mul_equivalence():
+    g = generator_ed25519
+
+    assert g + g == g * 2
+    assert g + g + g == g * 3
+
+
+def test_ed25519_add_literal_infinity():
+    g = generator_ed25519
+    z = g + INFINITY
+
+    assert z == g
+
+
+def test_ed25519_add_infinity():
+    inf = PointEdwards(curve_ed25519, 0, 1, 1, 0)
+    g = generator_ed25519
+    z = g + inf
+
+    assert z == g
+
+    z = inf + g
+
+    assert z == g
+
+
+class TestEd25519(unittest.TestCase):
+    def test_add_wrong_curves(self):
+        with self.assertRaises(ValueError) as e:
+            generator_ed25519 + generator_ed448
+
+        self.assertIn("different curve", str(e.exception))
+
+    def test_add_wrong_point_type(self):
+        with self.assertRaises(ValueError) as e:
+            generator_ed25519 + generator_256
+
+        self.assertIn("different curve", str(e.exception))
+
+
+def test_ed25519_mul_to_order_min_1():
+    x1 = int(
+        "427838232691226969392843410947554224151809796397784248136826"
+        "78720006717057747"
+    )
+    y1 = int(
+        "463168356949264781694283940034751631413079938662562256157830"
+        "33603165251855960"
+    )
+    inf_m_1 = PointEdwards(curve_ed25519, x1, y1, 1, x1 * y1)
+
+    assert generator_ed25519 * (generator_ed25519.order() - 1) == inf_m_1
+
+
+def test_ed25519_mul_to_infinity():
+    assert generator_ed25519 * generator_ed25519.order() == INFINITY
+
+
+def test_ed25519_mul_to_infinity_plus_1():
+    g = generator_ed25519
+    assert g * (g.order() + 1) == g
+
+
+def test_ed25519_mul_and_add():
+    g = generator_ed25519
+    a = g * 128
+    b = g * 64 + g * 64
+
+    assert a == b
+
+
+def test_ed25519_mul_and_add_2():
+    g = generator_ed25519
+
+    a = g * 123
+    b = g * 120 + g * 3
+
+    assert a == b
+
+
+def test_ed25519_mul_infinity():
+    inf = PointEdwards(curve_ed25519, 0, 1, 1, 0)
+
+    z = inf * 11
+
+    assert z == INFINITY
+
+
+def test_ed25519_mul_by_zero():
+    z = generator_ed25519 * 0
+
+    assert z == INFINITY
+
+
+def test_ed25519_mul_by_one():
+    z = generator_ed25519 * 1
+
+    assert z == generator_ed25519
+
+
+def test_ed25519_mul_custom_point():
+    # verify that multiplication without order set works
+
+    g = generator_ed25519
+
+    a = PointEdwards(curve_ed25519, g.x(), g.y(), 1, g.x() * g.y())
+
+    z = a * 11
+
+    assert z == g * 11
+
+
+def test_ed25519_pickle():
+    g = generator_ed25519
+    assert pickle.loads(pickle.dumps(g)) == g
+
+
+def test_ed448_eq_against_different_curve():
+    assert generator_ed25519 != generator_ed448
+
+
+def test_ed448_double():
+    g = generator_ed448
+    z = g.double()
+
+    assert isinstance(z, PointEdwards)
+
+    x2 = int(
+        "4845591495304045936995492052586696895690942404582120401876"
+        "6013278705691214670908136440114445572635086627683154494739"
+        "7859048262938744149"
+    )
+    y2 = int(
+        "4940887598674337276743026725267350893505445523037277237461"
+        "2648447308771911703729389009346215770388834286503647778745"
+        "3078312060500281069"
+    )
+
+    b = PointEdwards(curve_ed448, x2, y2, 1, x2 * y2)
+
+    assert z == b
+    assert g != b
+
+
+def test_ed448_add_as_double():
+    g = generator_ed448
+    z = g + g
+
+    b = g.double()
+
+    assert z == b
+
+
+def test_ed448_mul_as_double():
+    g = generator_ed448
+    z = g * 2
+    b = g.double()
+
+    assert z == b
+
+
+def test_ed448_add_to_infinity():
+    # generator * (order - 1)
+    x1 = int(
+        "5022586839996825903617194737881084981068517190547539260353"
+        "6473749366191269932473977736719082931859264751085238669719"
+        "1187378895383117729"
+    )
+    y1 = int(
+        "2988192100784814926760179304439306734375440401540802420959"
+        "2824137233150618983587600353687865541878473398230323350346"
+        "2500531545062832660"
+    )
+    inf_m_1 = PointEdwards(curve_ed448, x1, y1, 1, x1 * y1)
+
+    inf = inf_m_1 + generator_ed448
+
+    assert inf is INFINITY
+
+
+def test_ed448_mul_to_infinity():
+    g = generator_ed448
+    inf = g * g.order()
+
+    assert inf is INFINITY
+
+
+def test_ed448_mul_to_infinity_plus_1():
+    g = generator_ed448
+
+    z = g * (g.order() + 1)
+
+    assert z == g
+
+
+def test_ed448_add_and_mul_equivalence():
+    g = generator_ed448
+
+    assert g + g == g * 2
+    assert g + g + g == g * 3
+
+
+def test_ed25519_encode():
+    g = generator_ed25519
+    g_bytes = g.to_bytes()
+    assert len(g_bytes) == 32
+    exp_bytes = (
+        b"\x58\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+        b"\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+    )
+    assert g_bytes == exp_bytes
+
+
+def test_ed25519_decode():
+    exp_bytes = (
+        b"\x58\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+        b"\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+    )
+    a = PointEdwards.from_bytes(curve_ed25519, exp_bytes)
+
+    assert a == generator_ed25519
+
+
+class TestEdwardsMalformed(unittest.TestCase):
+    def test_invalid_point(self):
+        exp_bytes = (
+            b"\x78\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+            b"\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+        )
+        with self.assertRaises(MalformedPointError):
+            PointEdwards.from_bytes(curve_ed25519, exp_bytes)
+
+    def test_invalid_length(self):
+        exp_bytes = (
+            b"\x58\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+            b"\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66\x66"
+            b"\x66"
+        )
+        with self.assertRaises(MalformedPointError) as e:
+            PointEdwards.from_bytes(curve_ed25519, exp_bytes)
+
+        self.assertIn("length", str(e.exception))
+
+    def test_ed448_invalid(self):
+        exp_bytes = b"\xff" * 57
+        with self.assertRaises(MalformedPointError):
+            PointEdwards.from_bytes(curve_ed448, exp_bytes)
+
+
+def test_ed448_encode():
+    g = generator_ed448
+    g_bytes = g.to_bytes()
+    assert len(g_bytes) == 57
+    exp_bytes = (
+        b"\x14\xfa\x30\xf2\x5b\x79\x08\x98\xad\xc8\xd7\x4e\x2c\x13\xbd"
+        b"\xfd\xc4\x39\x7c\xe6\x1c\xff\xd3\x3a\xd7\xc2\xa0\x05\x1e\x9c"
+        b"\x78\x87\x40\x98\xa3\x6c\x73\x73\xea\x4b\x62\xc7\xc9\x56\x37"
+        b"\x20\x76\x88\x24\xbc\xb6\x6e\x71\x46\x3f\x69\x00"
+    )
+    assert g_bytes == exp_bytes
+
+
+def test_ed448_decode():
+    exp_bytes = (
+        b"\x14\xfa\x30\xf2\x5b\x79\x08\x98\xad\xc8\xd7\x4e\x2c\x13\xbd"
+        b"\xfd\xc4\x39\x7c\xe6\x1c\xff\xd3\x3a\xd7\xc2\xa0\x05\x1e\x9c"
+        b"\x78\x87\x40\x98\xa3\x6c\x73\x73\xea\x4b\x62\xc7\xc9\x56\x37"
+        b"\x20\x76\x88\x24\xbc\xb6\x6e\x71\x46\x3f\x69\x00"
+    )
+
+    a = PointEdwards.from_bytes(curve_ed448, exp_bytes)
+
+    assert a == generator_ed448
+
+
+class TestEdDSAEquality(unittest.TestCase):
+    def test_equal_public_points(self):
+        key1 = PublicKey(generator_ed25519, b"\x01" * 32)
+        key2 = PublicKey(generator_ed25519, b"\x01" * 32)
+
+        self.assertEqual(key1, key2)
+        self.assertFalse(key1 != key2)
+
+    def test_unequal_public_points(self):
+        key1 = PublicKey(generator_ed25519, b"\x01" * 32)
+        key2 = PublicKey(generator_ed25519, b"\x03" * 32)
+
+        self.assertNotEqual(key1, key2)
+
+    def test_unequal_to_string(self):
+        key1 = PublicKey(generator_ed25519, b"\x01" * 32)
+        key2 = b"\x01" * 32
+
+        self.assertNotEqual(key1, key2)
+
+    def test_unequal_publickey_curves(self):
+        key1 = PublicKey(generator_ed25519, b"\x01" * 32)
+        key2 = PublicKey(generator_ed448, b"\x03" * 56 + b"\x00")
+
+        self.assertNotEqual(key1, key2)
+        self.assertTrue(key1 != key2)
+
+    def test_equal_private_keys(self):
+        key1 = PrivateKey(generator_ed25519, b"\x01" * 32)
+        key2 = PrivateKey(generator_ed25519, b"\x01" * 32)
+
+        self.assertEqual(key1, key2)
+        self.assertFalse(key1 != key2)
+
+    def test_unequal_private_keys(self):
+        key1 = PrivateKey(generator_ed25519, b"\x01" * 32)
+        key2 = PrivateKey(generator_ed25519, b"\x02" * 32)
+
+        self.assertNotEqual(key1, key2)
+        self.assertTrue(key1 != key2)
+
+    def test_unequal_privatekey_to_string(self):
+        key1 = PrivateKey(generator_ed25519, b"\x01" * 32)
+        key2 = b"\x01" * 32
+
+        self.assertNotEqual(key1, key2)
+
+    def test_unequal_privatekey_curves(self):
+        key1 = PrivateKey(generator_ed25519, b"\x01" * 32)
+        key2 = PrivateKey(generator_ed448, b"\x01" * 57)
+
+        self.assertNotEqual(key1, key2)
+
+
+class TestInvalidEdDSAInputs(unittest.TestCase):
+    def test_wrong_length_of_private_key(self):
+        with self.assertRaises(ValueError):
+            PrivateKey(generator_ed25519, b"\x01" * 31)
+
+    def test_wrong_length_of_public_key(self):
+        with self.assertRaises(ValueError):
+            PublicKey(generator_ed25519, b"\x01" * 33)
+
+    def test_wrong_cofactor_curve(self):
+        ed_c = curve_ed25519
+
+        def _hash(data):
+            return hashlib.new("sha512", compat26_str(data)).digest()
+
+        curve = CurveEdTw(ed_c.p(), ed_c.a(), ed_c.d(), 1, _hash)
+        g = generator_ed25519
+        fake_gen = PointEdwards(curve, g.x(), g.y(), 1, g.x() * g.y())
+
+        with self.assertRaises(ValueError) as e:
+            PrivateKey(fake_gen, g.to_bytes())
+
+        self.assertIn("cofactor", str(e.exception))
+
+    def test_invalid_signature_length(self):
+        key = PublicKey(generator_ed25519, b"\x01" * 32)
+
+        with self.assertRaises(ValueError) as e:
+            key.verify(b"", b"\x01" * 65)
+
+        self.assertIn("length", str(e.exception))
+
+    def test_changing_public_key(self):
+        key = PublicKey(generator_ed25519, b"\x01" * 32)
+
+        g = key.point
+
+        new_g = PointEdwards(curve_ed25519, g.x(), g.y(), 1, g.x() * g.y())
+
+        key.point = new_g
+
+        self.assertEqual(g, key.point)
+
+    def test_changing_public_key_to_different_point(self):
+        key = PublicKey(generator_ed25519, b"\x01" * 32)
+
+        with self.assertRaises(ValueError) as e:
+            key.point = generator_ed25519
+
+        self.assertIn("coordinates", str(e.exception))
+
+    def test_invalid_s_value(self):
+        key = PublicKey(
+            generator_ed25519,
+            b"\xd7\x5a\x98\x01\x82\xb1\x0a\xb7\xd5\x4b\xfe\xd3\xc9\x64\x07\x3a"
+            b"\x0e\xe1\x72\xf3\xda\xa6\x23\x25\xaf\x02\x1a\x68\xf7\x07\x51\x1a",
+        )
+        sig_valid = bytearray(
+            b"\xe5\x56\x43\x00\xc3\x60\xac\x72\x90\x86\xe2\xcc\x80\x6e\x82\x8a"
+            b"\x84\x87\x7f\x1e\xb8\xe5\xd9\x74\xd8\x73\xe0\x65\x22\x49\x01\x55"
+            b"\x5f\xb8\x82\x15\x90\xa3\x3b\xac\xc6\x1e\x39\x70\x1c\xf9\xb4\x6b"
+            b"\xd2\x5b\xf5\xf0\x59\x5b\xbe\x24\x65\x51\x41\x43\x8e\x7a\x10\x0b"
+        )
+
+        self.assertTrue(key.verify(b"", sig_valid))
+
+        sig_invalid = bytearray(sig_valid)
+        sig_invalid[-1] = 0xFF
+
+        with self.assertRaises(ValueError):
+            key.verify(b"", sig_invalid)
+
+    def test_invalid_r_value(self):
+        key = PublicKey(
+            generator_ed25519,
+            b"\xd7\x5a\x98\x01\x82\xb1\x0a\xb7\xd5\x4b\xfe\xd3\xc9\x64\x07\x3a"
+            b"\x0e\xe1\x72\xf3\xda\xa6\x23\x25\xaf\x02\x1a\x68\xf7\x07\x51\x1a",
+        )
+        sig_valid = bytearray(
+            b"\xe5\x56\x43\x00\xc3\x60\xac\x72\x90\x86\xe2\xcc\x80\x6e\x82\x8a"
+            b"\x84\x87\x7f\x1e\xb8\xe5\xd9\x74\xd8\x73\xe0\x65\x22\x49\x01\x55"
+            b"\x5f\xb8\x82\x15\x90\xa3\x3b\xac\xc6\x1e\x39\x70\x1c\xf9\xb4\x6b"
+            b"\xd2\x5b\xf5\xf0\x59\x5b\xbe\x24\x65\x51\x41\x43\x8e\x7a\x10\x0b"
+        )
+
+        self.assertTrue(key.verify(b"", sig_valid))
+
+        sig_invalid = bytearray(sig_valid)
+        sig_invalid[0] = 0xE0
+
+        with self.assertRaises(ValueError):
+            key.verify(b"", sig_invalid)
+
+
+HYP_SETTINGS = dict()
+HYP_SETTINGS["max_examples"] = 10
+
+
+@settings(**HYP_SETTINGS)
+@example(1)
+@example(5)  # smallest multiple that requires changing sign of x
+@given(st.integers(min_value=1, max_value=int(generator_ed25519.order() - 1)))
+def test_ed25519_encode_decode(multiple):
+    a = generator_ed25519 * multiple
+
+    b = PointEdwards.from_bytes(curve_ed25519, a.to_bytes())
+
+    assert a == b
+
+
+@settings(**HYP_SETTINGS)
+@example(1)
+@example(2)  # smallest multiple that requires changing the sign of x
+@given(st.integers(min_value=1, max_value=int(generator_ed448.order() - 1)))
+def test_ed448_encode_decode(multiple):
+    a = generator_ed448 * multiple
+
+    b = PointEdwards.from_bytes(curve_ed448, a.to_bytes())
+
+    assert a == b
+
+
+@settings(**HYP_SETTINGS)
+@example(1)
+@example(2)
+@given(st.integers(min_value=1, max_value=int(generator_ed25519.order()) - 1))
+def test_ed25519_mul_precompute_vs_naf(multiple):
+    """Compare multiplication with and without precomputation."""
+    g = generator_ed25519
+    new_g = PointEdwards(curve_ed25519, g.x(), g.y(), 1, g.x() * g.y())
+
+    assert g * multiple == multiple * new_g
+
+
+# Test vectors from RFC 8032
+TEST_VECTORS = [
+    # TEST 1
+    (
+        generator_ed25519,
+        "9d61b19deffd5a60ba844af492ec2cc4" "4449c5697b326919703bac031cae7f60",
+        "d75a980182b10ab7d54bfed3c964073a" "0ee172f3daa62325af021a68f707511a",
+        "",
+        "e5564300c360ac729086e2cc806e828a"
+        "84877f1eb8e5d974d873e06522490155"
+        "5fb8821590a33bacc61e39701cf9b46b"
+        "d25bf5f0595bbe24655141438e7a100b",
+    ),
+    # TEST 2
+    (
+        generator_ed25519,
+        "4ccd089b28ff96da9db6c346ec114e0f" "5b8a319f35aba624da8cf6ed4fb8a6fb",
+        "3d4017c3e843895a92b70aa74d1b7ebc" "9c982ccf2ec4968cc0cd55f12af4660c",
+        "72",
+        "92a009a9f0d4cab8720e820b5f642540"
+        "a2b27b5416503f8fb3762223ebdb69da"
+        "085ac1e43e15996e458f3613d0f11d8c"
+        "387b2eaeb4302aeeb00d291612bb0c00",
+    ),
+    # TEST 3
+    (
+        generator_ed25519,
+        "c5aa8df43f9f837bedb7442f31dcb7b1" "66d38535076f094b85ce3a2e0b4458f7",
+        "fc51cd8e6218a1a38da47ed00230f058" "0816ed13ba3303ac5deb911548908025",
+        "af82",
+        "6291d657deec24024827e69c3abe01a3"
+        "0ce548a284743a445e3680d7db5ac3ac"
+        "18ff9b538d16f290ae67f760984dc659"
+        "4a7c15e9716ed28dc027beceea1ec40a",
+    ),
+    # TEST 1024
+    (
+        generator_ed25519,
+        "f5e5767cf153319517630f226876b86c" "8160cc583bc013744c6bf255f5cc0ee5",
+        "278117fc144c72340f67d0f2316e8386" "ceffbf2b2428c9c51fef7c597f1d426e",
+        "08b8b2b733424243760fe426a4b54908"
+        "632110a66c2f6591eabd3345e3e4eb98"
+        "fa6e264bf09efe12ee50f8f54e9f77b1"
+        "e355f6c50544e23fb1433ddf73be84d8"
+        "79de7c0046dc4996d9e773f4bc9efe57"
+        "38829adb26c81b37c93a1b270b20329d"
+        "658675fc6ea534e0810a4432826bf58c"
+        "941efb65d57a338bbd2e26640f89ffbc"
+        "1a858efcb8550ee3a5e1998bd177e93a"
+        "7363c344fe6b199ee5d02e82d522c4fe"
+        "ba15452f80288a821a579116ec6dad2b"
+        "3b310da903401aa62100ab5d1a36553e"
+        "06203b33890cc9b832f79ef80560ccb9"
+        "a39ce767967ed628c6ad573cb116dbef"
+        "efd75499da96bd68a8a97b928a8bbc10"
+        "3b6621fcde2beca1231d206be6cd9ec7"
+        "aff6f6c94fcd7204ed3455c68c83f4a4"
+        "1da4af2b74ef5c53f1d8ac70bdcb7ed1"
+        "85ce81bd84359d44254d95629e9855a9"
+        "4a7c1958d1f8ada5d0532ed8a5aa3fb2"
+        "d17ba70eb6248e594e1a2297acbbb39d"
+        "502f1a8c6eb6f1ce22b3de1a1f40cc24"
+        "554119a831a9aad6079cad88425de6bd"
+        "e1a9187ebb6092cf67bf2b13fd65f270"
+        "88d78b7e883c8759d2c4f5c65adb7553"
+        "878ad575f9fad878e80a0c9ba63bcbcc"
+        "2732e69485bbc9c90bfbd62481d9089b"
+        "eccf80cfe2df16a2cf65bd92dd597b07"
+        "07e0917af48bbb75fed413d238f5555a"
+        "7a569d80c3414a8d0859dc65a46128ba"
+        "b27af87a71314f318c782b23ebfe808b"
+        "82b0ce26401d2e22f04d83d1255dc51a"
+        "ddd3b75a2b1ae0784504df543af8969b"
+        "e3ea7082ff7fc9888c144da2af58429e"
+        "c96031dbcad3dad9af0dcbaaaf268cb8"
+        "fcffead94f3c7ca495e056a9b47acdb7"
+        "51fb73e666c6c655ade8297297d07ad1"
+        "ba5e43f1bca32301651339e22904cc8c"
+        "42f58c30c04aafdb038dda0847dd988d"
+        "cda6f3bfd15c4b4c4525004aa06eeff8"
+        "ca61783aacec57fb3d1f92b0fe2fd1a8"
+        "5f6724517b65e614ad6808d6f6ee34df"
+        "f7310fdc82aebfd904b01e1dc54b2927"
+        "094b2db68d6f903b68401adebf5a7e08"
+        "d78ff4ef5d63653a65040cf9bfd4aca7"
+        "984a74d37145986780fc0b16ac451649"
+        "de6188a7dbdf191f64b5fc5e2ab47b57"
+        "f7f7276cd419c17a3ca8e1b939ae49e4"
+        "88acba6b965610b5480109c8b17b80e1"
+        "b7b750dfc7598d5d5011fd2dcc5600a3"
+        "2ef5b52a1ecc820e308aa342721aac09"
+        "43bf6686b64b2579376504ccc493d97e"
+        "6aed3fb0f9cd71a43dd497f01f17c0e2"
+        "cb3797aa2a2f256656168e6c496afc5f"
+        "b93246f6b1116398a346f1a641f3b041"
+        "e989f7914f90cc2c7fff357876e506b5"
+        "0d334ba77c225bc307ba537152f3f161"
+        "0e4eafe595f6d9d90d11faa933a15ef1"
+        "369546868a7f3a45a96768d40fd9d034"
+        "12c091c6315cf4fde7cb68606937380d"
+        "b2eaaa707b4c4185c32eddcdd306705e"
+        "4dc1ffc872eeee475a64dfac86aba41c"
+        "0618983f8741c5ef68d3a101e8a3b8ca"
+        "c60c905c15fc910840b94c00a0b9d0",
+        "0aab4c900501b3e24d7cdf4663326a3a"
+        "87df5e4843b2cbdb67cbf6e460fec350"
+        "aa5371b1508f9f4528ecea23c436d94b"
+        "5e8fcd4f681e30a6ac00a9704a188a03",
+    ),
+    # TEST SHA(abc)
+    (
+        generator_ed25519,
+        "833fe62409237b9d62ec77587520911e" "9a759cec1d19755b7da901b96dca3d42",
+        "ec172b93ad5e563bf4932c70e1245034" "c35467ef2efd4d64ebf819683467e2bf",
+        "ddaf35a193617abacc417349ae204131"
+        "12e6fa4e89a97ea20a9eeee64b55d39a"
+        "2192992a274fc1a836ba3c23a3feebbd"
+        "454d4423643ce80e2a9ac94fa54ca49f",
+        "dc2a4459e7369633a52b1bf277839a00"
+        "201009a3efbf3ecb69bea2186c26b589"
+        "09351fc9ac90b3ecfdfbc7c66431e030"
+        "3dca179c138ac17ad9bef1177331a704",
+    ),
+    # Blank
+    (
+        generator_ed448,
+        "6c82a562cb808d10d632be89c8513ebf"
+        "6c929f34ddfa8c9f63c9960ef6e348a3"
+        "528c8a3fcc2f044e39a3fc5b94492f8f"
+        "032e7549a20098f95b",
+        "5fd7449b59b461fd2ce787ec616ad46a"
+        "1da1342485a70e1f8a0ea75d80e96778"
+        "edf124769b46c7061bd6783df1e50f6c"
+        "d1fa1abeafe8256180",
+        "",
+        "533a37f6bbe457251f023c0d88f976ae"
+        "2dfb504a843e34d2074fd823d41a591f"
+        "2b233f034f628281f2fd7a22ddd47d78"
+        "28c59bd0a21bfd3980ff0d2028d4b18a"
+        "9df63e006c5d1c2d345b925d8dc00b41"
+        "04852db99ac5c7cdda8530a113a0f4db"
+        "b61149f05a7363268c71d95808ff2e65"
+        "2600",
+    ),
+    # 1 octet
+    (
+        generator_ed448,
+        "c4eab05d357007c632f3dbb48489924d"
+        "552b08fe0c353a0d4a1f00acda2c463a"
+        "fbea67c5e8d2877c5e3bc397a659949e"
+        "f8021e954e0a12274e",
+        "43ba28f430cdff456ae531545f7ecd0a"
+        "c834a55d9358c0372bfa0c6c6798c086"
+        "6aea01eb00742802b8438ea4cb82169c"
+        "235160627b4c3a9480",
+        "03",
+        "26b8f91727bd62897af15e41eb43c377"
+        "efb9c610d48f2335cb0bd0087810f435"
+        "2541b143c4b981b7e18f62de8ccdf633"
+        "fc1bf037ab7cd779805e0dbcc0aae1cb"
+        "cee1afb2e027df36bc04dcecbf154336"
+        "c19f0af7e0a6472905e799f1953d2a0f"
+        "f3348ab21aa4adafd1d234441cf807c0"
+        "3a00",
+    ),
+    # 11 octets
+    (
+        generator_ed448,
+        "cd23d24f714274e744343237b93290f5"
+        "11f6425f98e64459ff203e8985083ffd"
+        "f60500553abc0e05cd02184bdb89c4cc"
+        "d67e187951267eb328",
+        "dcea9e78f35a1bf3499a831b10b86c90"
+        "aac01cd84b67a0109b55a36e9328b1e3"
+        "65fce161d71ce7131a543ea4cb5f7e9f"
+        "1d8b00696447001400",
+        "0c3e544074ec63b0265e0c",
+        "1f0a8888ce25e8d458a21130879b840a"
+        "9089d999aaba039eaf3e3afa090a09d3"
+        "89dba82c4ff2ae8ac5cdfb7c55e94d5d"
+        "961a29fe0109941e00b8dbdeea6d3b05"
+        "1068df7254c0cdc129cbe62db2dc957d"
+        "bb47b51fd3f213fb8698f064774250a5"
+        "028961c9bf8ffd973fe5d5c206492b14"
+        "0e00",
+    ),
+    # 12 octets
+    (
+        generator_ed448,
+        "258cdd4ada32ed9c9ff54e63756ae582"
+        "fb8fab2ac721f2c8e676a72768513d93"
+        "9f63dddb55609133f29adf86ec9929dc"
+        "cb52c1c5fd2ff7e21b",
+        "3ba16da0c6f2cc1f30187740756f5e79"
+        "8d6bc5fc015d7c63cc9510ee3fd44adc"
+        "24d8e968b6e46e6f94d19b945361726b"
+        "d75e149ef09817f580",
+        "64a65f3cdedcdd66811e2915",
+        "7eeeab7c4e50fb799b418ee5e3197ff6"
+        "bf15d43a14c34389b59dd1a7b1b85b4a"
+        "e90438aca634bea45e3a2695f1270f07"
+        "fdcdf7c62b8efeaf00b45c2c96ba457e"
+        "b1a8bf075a3db28e5c24f6b923ed4ad7"
+        "47c3c9e03c7079efb87cb110d3a99861"
+        "e72003cbae6d6b8b827e4e6c143064ff"
+        "3c00",
+    ),
+    # 13 octets
+    (
+        generator_ed448,
+        "7ef4e84544236752fbb56b8f31a23a10"
+        "e42814f5f55ca037cdcc11c64c9a3b29"
+        "49c1bb60700314611732a6c2fea98eeb"
+        "c0266a11a93970100e",
+        "b3da079b0aa493a5772029f0467baebe"
+        "e5a8112d9d3a22532361da294f7bb381"
+        "5c5dc59e176b4d9f381ca0938e13c6c0"
+        "7b174be65dfa578e80",
+        "64a65f3cdedcdd66811e2915e7",
+        "6a12066f55331b6c22acd5d5bfc5d712"
+        "28fbda80ae8dec26bdd306743c5027cb"
+        "4890810c162c027468675ecf645a8317"
+        "6c0d7323a2ccde2d80efe5a1268e8aca"
+        "1d6fbc194d3f77c44986eb4ab4177919"
+        "ad8bec33eb47bbb5fc6e28196fd1caf5"
+        "6b4e7e0ba5519234d047155ac727a105"
+        "3100",
+    ),
+    # 64 octets
+    (
+        generator_ed448,
+        "d65df341ad13e008567688baedda8e9d"
+        "cdc17dc024974ea5b4227b6530e339bf"
+        "f21f99e68ca6968f3cca6dfe0fb9f4fa"
+        "b4fa135d5542ea3f01",
+        "df9705f58edbab802c7f8363cfe5560a"
+        "b1c6132c20a9f1dd163483a26f8ac53a"
+        "39d6808bf4a1dfbd261b099bb03b3fb5"
+        "0906cb28bd8a081f00",
+        "bd0f6a3747cd561bdddf4640a332461a"
+        "4a30a12a434cd0bf40d766d9c6d458e5"
+        "512204a30c17d1f50b5079631f64eb31"
+        "12182da3005835461113718d1a5ef944",
+        "554bc2480860b49eab8532d2a533b7d5"
+        "78ef473eeb58c98bb2d0e1ce488a98b1"
+        "8dfde9b9b90775e67f47d4a1c3482058"
+        "efc9f40d2ca033a0801b63d45b3b722e"
+        "f552bad3b4ccb667da350192b61c508c"
+        "f7b6b5adadc2c8d9a446ef003fb05cba"
+        "5f30e88e36ec2703b349ca229c267083"
+        "3900",
+    ),
+    # 256 octets
+    (
+        generator_ed448,
+        "2ec5fe3c17045abdb136a5e6a913e32a"
+        "b75ae68b53d2fc149b77e504132d3756"
+        "9b7e766ba74a19bd6162343a21c8590a"
+        "a9cebca9014c636df5",
+        "79756f014dcfe2079f5dd9e718be4171"
+        "e2ef2486a08f25186f6bff43a9936b9b"
+        "fe12402b08ae65798a3d81e22e9ec80e"
+        "7690862ef3d4ed3a00",
+        "15777532b0bdd0d1389f636c5f6b9ba7"
+        "34c90af572877e2d272dd078aa1e567c"
+        "fa80e12928bb542330e8409f31745041"
+        "07ecd5efac61ae7504dabe2a602ede89"
+        "e5cca6257a7c77e27a702b3ae39fc769"
+        "fc54f2395ae6a1178cab4738e543072f"
+        "c1c177fe71e92e25bf03e4ecb72f47b6"
+        "4d0465aaea4c7fad372536c8ba516a60"
+        "39c3c2a39f0e4d832be432dfa9a706a6"
+        "e5c7e19f397964ca4258002f7c0541b5"
+        "90316dbc5622b6b2a6fe7a4abffd9610"
+        "5eca76ea7b98816af0748c10df048ce0"
+        "12d901015a51f189f3888145c03650aa"
+        "23ce894c3bd889e030d565071c59f409"
+        "a9981b51878fd6fc110624dcbcde0bf7"
+        "a69ccce38fabdf86f3bef6044819de11",
+        "c650ddbb0601c19ca11439e1640dd931"
+        "f43c518ea5bea70d3dcde5f4191fe53f"
+        "00cf966546b72bcc7d58be2b9badef28"
+        "743954e3a44a23f880e8d4f1cfce2d7a"
+        "61452d26da05896f0a50da66a239a8a1"
+        "88b6d825b3305ad77b73fbac0836ecc6"
+        "0987fd08527c1a8e80d5823e65cafe2a"
+        "3d00",
+    ),
+    # 1023 octets
+    (
+        generator_ed448,
+        "872d093780f5d3730df7c212664b37b8"
+        "a0f24f56810daa8382cd4fa3f77634ec"
+        "44dc54f1c2ed9bea86fafb7632d8be19"
+        "9ea165f5ad55dd9ce8",
+        "a81b2e8a70a5ac94ffdbcc9badfc3feb"
+        "0801f258578bb114ad44ece1ec0e799d"
+        "a08effb81c5d685c0c56f64eecaef8cd"
+        "f11cc38737838cf400",
+        "6ddf802e1aae4986935f7f981ba3f035"
+        "1d6273c0a0c22c9c0e8339168e675412"
+        "a3debfaf435ed651558007db4384b650"
+        "fcc07e3b586a27a4f7a00ac8a6fec2cd"
+        "86ae4bf1570c41e6a40c931db27b2faa"
+        "15a8cedd52cff7362c4e6e23daec0fbc"
+        "3a79b6806e316efcc7b68119bf46bc76"
+        "a26067a53f296dafdbdc11c77f7777e9"
+        "72660cf4b6a9b369a6665f02e0cc9b6e"
+        "dfad136b4fabe723d2813db3136cfde9"
+        "b6d044322fee2947952e031b73ab5c60"
+        "3349b307bdc27bc6cb8b8bbd7bd32321"
+        "9b8033a581b59eadebb09b3c4f3d2277"
+        "d4f0343624acc817804728b25ab79717"
+        "2b4c5c21a22f9c7839d64300232eb66e"
+        "53f31c723fa37fe387c7d3e50bdf9813"
+        "a30e5bb12cf4cd930c40cfb4e1fc6225"
+        "92a49588794494d56d24ea4b40c89fc0"
+        "596cc9ebb961c8cb10adde976a5d602b"
+        "1c3f85b9b9a001ed3c6a4d3b1437f520"
+        "96cd1956d042a597d561a596ecd3d173"
+        "5a8d570ea0ec27225a2c4aaff26306d1"
+        "526c1af3ca6d9cf5a2c98f47e1c46db9"
+        "a33234cfd4d81f2c98538a09ebe76998"
+        "d0d8fd25997c7d255c6d66ece6fa56f1"
+        "1144950f027795e653008f4bd7ca2dee"
+        "85d8e90f3dc315130ce2a00375a318c7"
+        "c3d97be2c8ce5b6db41a6254ff264fa6"
+        "155baee3b0773c0f497c573f19bb4f42"
+        "40281f0b1f4f7be857a4e59d416c06b4"
+        "c50fa09e1810ddc6b1467baeac5a3668"
+        "d11b6ecaa901440016f389f80acc4db9"
+        "77025e7f5924388c7e340a732e554440"
+        "e76570f8dd71b7d640b3450d1fd5f041"
+        "0a18f9a3494f707c717b79b4bf75c984"
+        "00b096b21653b5d217cf3565c9597456"
+        "f70703497a078763829bc01bb1cbc8fa"
+        "04eadc9a6e3f6699587a9e75c94e5bab"
+        "0036e0b2e711392cff0047d0d6b05bd2"
+        "a588bc109718954259f1d86678a579a3"
+        "120f19cfb2963f177aeb70f2d4844826"
+        "262e51b80271272068ef5b3856fa8535"
+        "aa2a88b2d41f2a0e2fda7624c2850272"
+        "ac4a2f561f8f2f7a318bfd5caf969614"
+        "9e4ac824ad3460538fdc25421beec2cc"
+        "6818162d06bbed0c40a387192349db67"
+        "a118bada6cd5ab0140ee273204f628aa"
+        "d1c135f770279a651e24d8c14d75a605"
+        "9d76b96a6fd857def5e0b354b27ab937"
+        "a5815d16b5fae407ff18222c6d1ed263"
+        "be68c95f32d908bd895cd76207ae7264"
+        "87567f9a67dad79abec316f683b17f2d"
+        "02bf07e0ac8b5bc6162cf94697b3c27c"
+        "d1fea49b27f23ba2901871962506520c"
+        "392da8b6ad0d99f7013fbc06c2c17a56"
+        "9500c8a7696481c1cd33e9b14e40b82e"
+        "79a5f5db82571ba97bae3ad3e0479515"
+        "bb0e2b0f3bfcd1fd33034efc6245eddd"
+        "7ee2086ddae2600d8ca73e214e8c2b0b"
+        "db2b047c6a464a562ed77b73d2d841c4"
+        "b34973551257713b753632efba348169"
+        "abc90a68f42611a40126d7cb21b58695"
+        "568186f7e569d2ff0f9e745d0487dd2e"
+        "b997cafc5abf9dd102e62ff66cba87",
+        "e301345a41a39a4d72fff8df69c98075"
+        "a0cc082b802fc9b2b6bc503f926b65bd"
+        "df7f4c8f1cb49f6396afc8a70abe6d8a"
+        "ef0db478d4c6b2970076c6a0484fe76d"
+        "76b3a97625d79f1ce240e7c576750d29"
+        "5528286f719b413de9ada3e8eb78ed57"
+        "3603ce30d8bb761785dc30dbc320869e"
+        "1a00",
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "generator,private_key,public_key,message,signature",
+    TEST_VECTORS,
+)
+def test_vectors(generator, private_key, public_key, message, signature):
+    private_key = a2b_hex(private_key)
+    public_key = a2b_hex(public_key)
+    message = a2b_hex(message)
+    signature = a2b_hex(signature)
+
+    sig_key = PrivateKey(generator, private_key)
+    ver_key = PublicKey(generator, public_key)
+
+    assert sig_key.public_key().public_key() == ver_key.public_key()
+
+    gen_sig = sig_key.sign(message)
+
+    assert gen_sig == signature
+
+    assert ver_key.verify(message, signature)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_ellipticcurve.py b/myenv/lib/python3.9/site-packages/ecdsa/test_ellipticcurve.py
new file mode 100644
index 0000000..85faef4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_ellipticcurve.py
@@ -0,0 +1,199 @@
+import pytest
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+from hypothesis import given, settings
+import hypothesis.strategies as st
+
+try:
+    from hypothesis import HealthCheck
+
+    HC_PRESENT = True
+except ImportError:  # pragma: no cover
+    HC_PRESENT = False
+from .numbertheory import inverse_mod
+from .ellipticcurve import CurveFp, INFINITY, Point
+
+
+HYP_SETTINGS = {}
+if HC_PRESENT:  # pragma: no branch
+    HYP_SETTINGS["suppress_health_check"] = [HealthCheck.too_slow]
+    HYP_SETTINGS["deadline"] = 5000
+
+
+# NIST Curve P-192:
+p = 6277101735386680763835789423207666416083908700390324961279
+r = 6277101735386680763835789423176059013767194773182842284081
+# s = 0x3045ae6fc8422f64ed579528d38120eae12196d5
+# c = 0x3099d2bbbfcb2538542dcd5fb078b6ef5f3d6fe2c745de65
+b = 0x64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1
+Gx = 0x188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012
+Gy = 0x07192B95FFC8DA78631011ED6B24CDD573F977A11E794811
+
+c192 = CurveFp(p, -3, b)
+p192 = Point(c192, Gx, Gy, r)
+
+c_23 = CurveFp(23, 1, 1)
+g_23 = Point(c_23, 13, 7, 7)
+
+
+HYP_SLOW_SETTINGS = dict(HYP_SETTINGS)
+HYP_SLOW_SETTINGS["max_examples"] = 10
+
+
+@settings(**HYP_SLOW_SETTINGS)
+@given(st.integers(min_value=1, max_value=r + 1))
+def test_p192_mult_tests(multiple):
+    inv_m = inverse_mod(multiple, r)
+
+    p1 = p192 * multiple
+    assert p1 * inv_m == p192
+
+
+def add_n_times(point, n):
+    ret = INFINITY
+    i = 0
+    while i <= n:
+        yield ret
+        ret = ret + point
+        i += 1
+
+
+# From X9.62 I.1 (p. 96):
+@pytest.mark.parametrize(
+    "p, m, check",
+    [(g_23, n, exp) for n, exp in enumerate(add_n_times(g_23, 8))],
+    ids=["g_23 test with mult {0}".format(i) for i in range(9)],
+)
+def test_add_and_mult_equivalence(p, m, check):
+    assert p * m == check
+
+
+class TestCurve(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.c_23 = CurveFp(23, 1, 1)
+
+    def test_equality_curves(self):
+        self.assertEqual(self.c_23, CurveFp(23, 1, 1))
+
+    def test_inequality_curves(self):
+        c192 = CurveFp(p, -3, b)
+        self.assertNotEqual(self.c_23, c192)
+
+    def test_usability_in_a_hashed_collection_curves(self):
+        {self.c_23: None}
+
+    def test_hashability_curves(self):
+        hash(self.c_23)
+
+    def test_conflation_curves(self):
+        ne1, ne2, ne3 = CurveFp(24, 1, 1), CurveFp(23, 2, 1), CurveFp(23, 1, 2)
+        eq1, eq2, eq3 = CurveFp(23, 1, 1), CurveFp(23, 1, 1), self.c_23
+        self.assertEqual(len(set((c_23, eq1, eq2, eq3))), 1)
+        self.assertEqual(len(set((c_23, ne1, ne2, ne3))), 4)
+        self.assertDictEqual({c_23: None}, {eq1: None})
+        self.assertIn(eq2, {eq3: None})
+
+
+class TestPoint(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.c_23 = CurveFp(23, 1, 1)
+        cls.g_23 = Point(cls.c_23, 13, 7, 7)
+
+        p = 6277101735386680763835789423207666416083908700390324961279
+        r = 6277101735386680763835789423176059013767194773182842284081
+        # s = 0x3045ae6fc8422f64ed579528d38120eae12196d5
+        # c = 0x3099d2bbbfcb2538542dcd5fb078b6ef5f3d6fe2c745de65
+        b = 0x64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1
+        Gx = 0x188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012
+        Gy = 0x07192B95FFC8DA78631011ED6B24CDD573F977A11E794811
+
+        cls.c192 = CurveFp(p, -3, b)
+        cls.p192 = Point(cls.c192, Gx, Gy, r)
+
+    def test_p192(self):
+        # Checking against some sample computations presented
+        # in X9.62:
+        d = 651056770906015076056810763456358567190100156695615665659
+        Q = d * self.p192
+        self.assertEqual(
+            Q.x(), 0x62B12D60690CDCF330BABAB6E69763B471F994DD702D16A5
+        )
+
+        k = 6140507067065001063065065565667405560006161556565665656654
+        R = k * self.p192
+        self.assertEqual(
+            R.x(), 0x885052380FF147B734C330C43D39B2C4A89F29B0F749FEAD
+        )
+        self.assertEqual(
+            R.y(), 0x9CF9FA1CBEFEFB917747A3BB29C072B9289C2547884FD835
+        )
+
+        u1 = 2563697409189434185194736134579731015366492496392189760599
+        u2 = 6266643813348617967186477710235785849136406323338782220568
+        temp = u1 * self.p192 + u2 * Q
+        self.assertEqual(
+            temp.x(), 0x885052380FF147B734C330C43D39B2C4A89F29B0F749FEAD
+        )
+        self.assertEqual(
+            temp.y(), 0x9CF9FA1CBEFEFB917747A3BB29C072B9289C2547884FD835
+        )
+
+    def test_double_infinity(self):
+        p1 = INFINITY
+        p3 = p1.double()
+        self.assertEqual(p1, p3)
+        self.assertEqual(p3.x(), p1.x())
+        self.assertEqual(p3.y(), p3.y())
+
+    def test_double(self):
+        x1, y1, x3, y3 = (3, 10, 7, 12)
+
+        p1 = Point(self.c_23, x1, y1)
+        p3 = p1.double()
+        self.assertEqual(p3.x(), x3)
+        self.assertEqual(p3.y(), y3)
+
+    def test_multiply(self):
+        x1, y1, m, x3, y3 = (3, 10, 2, 7, 12)
+        p1 = Point(self.c_23, x1, y1)
+        p3 = p1 * m
+        self.assertEqual(p3.x(), x3)
+        self.assertEqual(p3.y(), y3)
+
+    # Trivial tests from X9.62 B.3:
+    def test_add(self):
+        """We expect that on curve c, (x1,y1) + (x2, y2 ) = (x3, y3)."""
+
+        x1, y1, x2, y2, x3, y3 = (3, 10, 9, 7, 17, 20)
+        p1 = Point(self.c_23, x1, y1)
+        p2 = Point(self.c_23, x2, y2)
+        p3 = p1 + p2
+        self.assertEqual(p3.x(), x3)
+        self.assertEqual(p3.y(), y3)
+
+    def test_add_as_double(self):
+        """We expect that on curve c, (x1,y1) + (x2, y2 ) = (x3, y3)."""
+
+        x1, y1, x2, y2, x3, y3 = (3, 10, 3, 10, 7, 12)
+        p1 = Point(self.c_23, x1, y1)
+        p2 = Point(self.c_23, x2, y2)
+        p3 = p1 + p2
+        self.assertEqual(p3.x(), x3)
+        self.assertEqual(p3.y(), y3)
+
+    def test_equality_points(self):
+        self.assertEqual(self.g_23, Point(self.c_23, 13, 7, 7))
+
+    def test_inequality_points(self):
+        c = CurveFp(100, -3, 100)
+        p = Point(c, 100, 100, 100)
+        self.assertNotEqual(self.g_23, p)
+
+    def test_inequality_points_diff_types(self):
+        c = CurveFp(100, -3, 100)
+        self.assertNotEqual(self.g_23, c)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_jacobi.py b/myenv/lib/python3.9/site-packages/ecdsa/test_jacobi.py
new file mode 100644
index 0000000..1f52804
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_jacobi.py
@@ -0,0 +1,657 @@
+import pickle
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+
+import os
+import sys
+import signal
+import pytest
+import threading
+import platform
+import hypothesis.strategies as st
+from hypothesis import given, assume, settings, example
+
+from .ellipticcurve import CurveFp, PointJacobi, INFINITY
+from .ecdsa import (
+    generator_256,
+    curve_256,
+    generator_224,
+    generator_brainpoolp160r1,
+    curve_brainpoolp160r1,
+    generator_112r2,
+)
+from .numbertheory import inverse_mod
+from .util import randrange
+
+
+NO_OLD_SETTINGS = {}
+if sys.version_info > (2, 7):  # pragma: no branch
+    NO_OLD_SETTINGS["deadline"] = 5000
+
+
+class TestJacobi(unittest.TestCase):
+    def test___init__(self):
+        curve = object()
+        x = 2
+        y = 3
+        z = 1
+        order = 4
+        pj = PointJacobi(curve, x, y, z, order)
+
+        self.assertEqual(pj.order(), order)
+        self.assertIs(pj.curve(), curve)
+        self.assertEqual(pj.x(), x)
+        self.assertEqual(pj.y(), y)
+
+    def test_add_with_different_curves(self):
+        p_a = PointJacobi.from_affine(generator_256)
+        p_b = PointJacobi.from_affine(generator_224)
+
+        with self.assertRaises(ValueError):
+            p_a + p_b
+
+    def test_compare_different_curves(self):
+        self.assertNotEqual(generator_256, generator_224)
+
+    def test_equality_with_non_point(self):
+        pj = PointJacobi.from_affine(generator_256)
+
+        self.assertNotEqual(pj, "value")
+
+    def test_conversion(self):
+        pj = PointJacobi.from_affine(generator_256)
+        pw = pj.to_affine()
+
+        self.assertEqual(generator_256, pw)
+
+    def test_single_double(self):
+        pj = PointJacobi.from_affine(generator_256)
+        pw = generator_256.double()
+
+        pj = pj.double()
+
+        self.assertEqual(pj.x(), pw.x())
+        self.assertEqual(pj.y(), pw.y())
+
+    def test_double_with_zero_point(self):
+        pj = PointJacobi(curve_256, 0, 0, 1)
+
+        pj = pj.double()
+
+        self.assertIs(pj, INFINITY)
+
+    def test_double_with_zero_equivalent_point(self):
+        pj = PointJacobi(curve_256, 0, curve_256.p(), 1)
+
+        pj = pj.double()
+
+        self.assertIs(pj, INFINITY)
+
+    def test_double_with_zero_equivalent_point_non_1_z(self):
+        pj = PointJacobi(curve_256, 0, curve_256.p(), 2)
+
+        pj = pj.double()
+
+        self.assertIs(pj, INFINITY)
+
+    def test_compare_with_affine_point(self):
+        pj = PointJacobi.from_affine(generator_256)
+        pa = pj.to_affine()
+
+        self.assertEqual(pj, pa)
+        self.assertEqual(pa, pj)
+
+    def test_to_affine_with_zero_point(self):
+        pj = PointJacobi(curve_256, 0, 0, 1)
+
+        pa = pj.to_affine()
+
+        self.assertIs(pa, INFINITY)
+
+    def test_add_with_affine_point(self):
+        pj = PointJacobi.from_affine(generator_256)
+        pa = pj.to_affine()
+
+        s = pj + pa
+
+        self.assertEqual(s, pj.double())
+
+    def test_radd_with_affine_point(self):
+        pj = PointJacobi.from_affine(generator_256)
+        pa = pj.to_affine()
+
+        s = pa + pj
+
+        self.assertEqual(s, pj.double())
+
+    def test_add_with_infinity(self):
+        pj = PointJacobi.from_affine(generator_256)
+
+        s = pj + INFINITY
+
+        self.assertEqual(s, pj)
+
+    def test_add_zero_point_to_affine(self):
+        pa = PointJacobi.from_affine(generator_256).to_affine()
+        pj = PointJacobi(curve_256, 0, 0, 1)
+
+        s = pj + pa
+
+        self.assertIs(s, pa)
+
+    def test_multiply_by_zero(self):
+        pj = PointJacobi.from_affine(generator_256)
+
+        pj = pj * 0
+
+        self.assertIs(pj, INFINITY)
+
+    def test_zero_point_multiply_by_one(self):
+        pj = PointJacobi(curve_256, 0, 0, 1)
+
+        pj = pj * 1
+
+        self.assertIs(pj, INFINITY)
+
+    def test_multiply_by_one(self):
+        pj = PointJacobi.from_affine(generator_256)
+        pw = generator_256 * 1
+
+        pj = pj * 1
+
+        self.assertEqual(pj.x(), pw.x())
+        self.assertEqual(pj.y(), pw.y())
+
+    def test_multiply_by_two(self):
+        pj = PointJacobi.from_affine(generator_256)
+        pw = generator_256 * 2
+
+        pj = pj * 2
+
+        self.assertEqual(pj.x(), pw.x())
+        self.assertEqual(pj.y(), pw.y())
+
+    def test_rmul_by_two(self):
+        pj = PointJacobi.from_affine(generator_256)
+        pw = generator_256 * 2
+
+        pj = 2 * pj
+
+        self.assertEqual(pj, pw)
+
+    def test_compare_non_zero_with_infinity(self):
+        pj = PointJacobi.from_affine(generator_256)
+
+        self.assertNotEqual(pj, INFINITY)
+
+    def test_compare_zero_point_with_infinity(self):
+        pj = PointJacobi(curve_256, 0, 0, 1)
+
+        self.assertEqual(pj, INFINITY)
+
+    def test_compare_double_with_multiply(self):
+        pj = PointJacobi.from_affine(generator_256)
+        dbl = pj.double()
+        mlpl = pj * 2
+
+        self.assertEqual(dbl, mlpl)
+
+    @settings(max_examples=10)
+    @given(
+        st.integers(
+            min_value=0, max_value=int(generator_brainpoolp160r1.order())
+        )
+    )
+    def test_multiplications(self, mul):
+        pj = PointJacobi.from_affine(generator_brainpoolp160r1)
+        pw = pj.to_affine() * mul
+
+        pj = pj * mul
+
+        self.assertEqual((pj.x(), pj.y()), (pw.x(), pw.y()))
+        self.assertEqual(pj, pw)
+
+    @settings(max_examples=10)
+    @given(
+        st.integers(
+            min_value=0, max_value=int(generator_brainpoolp160r1.order())
+        )
+    )
+    @example(0)
+    @example(int(generator_brainpoolp160r1.order()))
+    def test_precompute(self, mul):
+        precomp = generator_brainpoolp160r1
+        self.assertTrue(precomp._PointJacobi__precompute)
+        pj = PointJacobi.from_affine(generator_brainpoolp160r1)
+
+        a = precomp * mul
+        b = pj * mul
+
+        self.assertEqual(a, b)
+
+    @settings(max_examples=10)
+    @given(
+        st.integers(
+            min_value=1, max_value=int(generator_brainpoolp160r1.order())
+        ),
+        st.integers(
+            min_value=1, max_value=int(generator_brainpoolp160r1.order())
+        ),
+    )
+    @example(3, 3)
+    def test_add_scaled_points(self, a_mul, b_mul):
+        j_g = PointJacobi.from_affine(generator_brainpoolp160r1)
+        a = PointJacobi.from_affine(j_g * a_mul)
+        b = PointJacobi.from_affine(j_g * b_mul)
+
+        c = a + b
+
+        self.assertEqual(c, j_g * (a_mul + b_mul))
+
+    @settings(max_examples=10)
+    @given(
+        st.integers(
+            min_value=1, max_value=int(generator_brainpoolp160r1.order())
+        ),
+        st.integers(
+            min_value=1, max_value=int(generator_brainpoolp160r1.order())
+        ),
+        st.integers(min_value=1, max_value=int(curve_brainpoolp160r1.p() - 1)),
+    )
+    def test_add_one_scaled_point(self, a_mul, b_mul, new_z):
+        j_g = PointJacobi.from_affine(generator_brainpoolp160r1)
+        a = PointJacobi.from_affine(j_g * a_mul)
+        b = PointJacobi.from_affine(j_g * b_mul)
+
+        p = curve_brainpoolp160r1.p()
+
+        assume(inverse_mod(new_z, p))
+
+        new_zz = new_z * new_z % p
+
+        b = PointJacobi(
+            curve_brainpoolp160r1,
+            b.x() * new_zz % p,
+            b.y() * new_zz * new_z % p,
+            new_z,
+        )
+
+        c = a + b
+
+        self.assertEqual(c, j_g * (a_mul + b_mul))
+
+    @settings(max_examples=10)
+    @given(
+        st.integers(
+            min_value=1, max_value=int(generator_brainpoolp160r1.order())
+        ),
+        st.integers(
+            min_value=1, max_value=int(generator_brainpoolp160r1.order())
+        ),
+        st.integers(min_value=1, max_value=int(curve_brainpoolp160r1.p() - 1)),
+    )
+    @example(1, 1, 1)
+    @example(3, 3, 3)
+    @example(2, int(generator_brainpoolp160r1.order() - 2), 1)
+    @example(2, int(generator_brainpoolp160r1.order() - 2), 3)
+    def test_add_same_scale_points(self, a_mul, b_mul, new_z):
+        j_g = PointJacobi.from_affine(generator_brainpoolp160r1)
+        a = PointJacobi.from_affine(j_g * a_mul)
+        b = PointJacobi.from_affine(j_g * b_mul)
+
+        p = curve_brainpoolp160r1.p()
+
+        assume(inverse_mod(new_z, p))
+
+        new_zz = new_z * new_z % p
+
+        a = PointJacobi(
+            curve_brainpoolp160r1,
+            a.x() * new_zz % p,
+            a.y() * new_zz * new_z % p,
+            new_z,
+        )
+        b = PointJacobi(
+            curve_brainpoolp160r1,
+            b.x() * new_zz % p,
+            b.y() * new_zz * new_z % p,
+            new_z,
+        )
+
+        c = a + b
+
+        self.assertEqual(c, j_g * (a_mul + b_mul))
+
+    def test_add_same_scale_points_static(self):
+        j_g = generator_brainpoolp160r1
+        p = curve_brainpoolp160r1.p()
+        a = j_g * 11
+        a.scale()
+        z1 = 13
+        x = PointJacobi(
+            curve_brainpoolp160r1,
+            a.x() * z1**2 % p,
+            a.y() * z1**3 % p,
+            z1,
+        )
+        y = PointJacobi(
+            curve_brainpoolp160r1,
+            a.x() * z1**2 % p,
+            a.y() * z1**3 % p,
+            z1,
+        )
+
+        c = a + a
+
+        self.assertEqual(c, x + y)
+
+    @settings(max_examples=14)
+    @given(
+        st.integers(
+            min_value=1, max_value=int(generator_brainpoolp160r1.order())
+        ),
+        st.integers(
+            min_value=1, max_value=int(generator_brainpoolp160r1.order())
+        ),
+        st.lists(
+            st.integers(
+                min_value=1, max_value=int(curve_brainpoolp160r1.p() - 1)
+            ),
+            min_size=2,
+            max_size=2,
+            unique=True,
+        ),
+    )
+    @example(2, 2, [2, 1])
+    @example(2, 2, [2, 3])
+    @example(2, int(generator_brainpoolp160r1.order() - 2), [2, 3])
+    @example(2, int(generator_brainpoolp160r1.order() - 2), [2, 1])
+    def test_add_different_scale_points(self, a_mul, b_mul, new_z):
+        j_g = PointJacobi.from_affine(generator_brainpoolp160r1)
+        a = PointJacobi.from_affine(j_g * a_mul)
+        b = PointJacobi.from_affine(j_g * b_mul)
+
+        p = curve_brainpoolp160r1.p()
+
+        assume(inverse_mod(new_z[0], p))
+        assume(inverse_mod(new_z[1], p))
+
+        new_zz0 = new_z[0] * new_z[0] % p
+        new_zz1 = new_z[1] * new_z[1] % p
+
+        a = PointJacobi(
+            curve_brainpoolp160r1,
+            a.x() * new_zz0 % p,
+            a.y() * new_zz0 * new_z[0] % p,
+            new_z[0],
+        )
+        b = PointJacobi(
+            curve_brainpoolp160r1,
+            b.x() * new_zz1 % p,
+            b.y() * new_zz1 * new_z[1] % p,
+            new_z[1],
+        )
+
+        c = a + b
+
+        self.assertEqual(c, j_g * (a_mul + b_mul))
+
+    def test_add_different_scale_points_static(self):
+        j_g = generator_brainpoolp160r1
+        p = curve_brainpoolp160r1.p()
+        a = j_g * 11
+        a.scale()
+        z1 = 13
+        x = PointJacobi(
+            curve_brainpoolp160r1,
+            a.x() * z1**2 % p,
+            a.y() * z1**3 % p,
+            z1,
+        )
+        z2 = 29
+        y = PointJacobi(
+            curve_brainpoolp160r1,
+            a.x() * z2**2 % p,
+            a.y() * z2**3 % p,
+            z2,
+        )
+
+        c = a + a
+
+        self.assertEqual(c, x + y)
+
+    def test_add_point_3_times(self):
+        j_g = PointJacobi.from_affine(generator_256)
+
+        self.assertEqual(j_g * 3, j_g + j_g + j_g)
+
+    def test_mul_without_order(self):
+        j_g = PointJacobi(curve_256, generator_256.x(), generator_256.y(), 1)
+
+        self.assertEqual(j_g * generator_256.order(), INFINITY)
+
+    def test_mul_add_inf(self):
+        j_g = PointJacobi.from_affine(generator_256)
+
+        self.assertEqual(j_g, j_g.mul_add(1, INFINITY, 1))
+
+    def test_mul_add_same(self):
+        j_g = PointJacobi.from_affine(generator_256)
+
+        self.assertEqual(j_g * 2, j_g.mul_add(1, j_g, 1))
+
+    def test_mul_add_precompute(self):
+        j_g = PointJacobi.from_affine(generator_brainpoolp160r1, True)
+        b = PointJacobi.from_affine(j_g * 255, True)
+
+        self.assertEqual(j_g * 256, j_g + b)
+        self.assertEqual(j_g * (5 + 255 * 7), j_g * 5 + b * 7)
+        self.assertEqual(j_g * (5 + 255 * 7), j_g.mul_add(5, b, 7))
+
+    def test_mul_add_precompute_large(self):
+        j_g = PointJacobi.from_affine(generator_brainpoolp160r1, True)
+        b = PointJacobi.from_affine(j_g * 255, True)
+
+        self.assertEqual(j_g * 256, j_g + b)
+        self.assertEqual(
+            j_g * (0xFF00 + 255 * 0xF0F0), j_g * 0xFF00 + b * 0xF0F0
+        )
+        self.assertEqual(
+            j_g * (0xFF00 + 255 * 0xF0F0), j_g.mul_add(0xFF00, b, 0xF0F0)
+        )
+
+    def test_mul_add_to_mul(self):
+        j_g = PointJacobi.from_affine(generator_256)
+
+        a = j_g * 3
+        b = j_g.mul_add(2, j_g, 1)
+
+        self.assertEqual(a, b)
+
+    def test_mul_add_differnt(self):
+        j_g = PointJacobi.from_affine(generator_256)
+
+        w_a = j_g * 2
+
+        self.assertEqual(j_g.mul_add(1, w_a, 1), j_g * 3)
+
+    def test_mul_add_slightly_different(self):
+        j_g = PointJacobi.from_affine(generator_256)
+
+        w_a = j_g * 2
+        w_b = j_g * 3
+
+        self.assertEqual(w_a.mul_add(1, w_b, 3), w_a * 1 + w_b * 3)
+
+    def test_mul_add(self):
+        j_g = PointJacobi.from_affine(generator_256)
+
+        w_a = generator_256 * 255
+        w_b = generator_256 * (0xA8 * 0xF0)
+        j_b = j_g * 0xA8
+
+        ret = j_g.mul_add(255, j_b, 0xF0)
+
+        self.assertEqual(ret.to_affine(), w_a + w_b)
+
+    def test_mul_add_large(self):
+        j_g = PointJacobi.from_affine(generator_256)
+        b = PointJacobi.from_affine(j_g * 255)
+
+        self.assertEqual(j_g * 256, j_g + b)
+        self.assertEqual(
+            j_g * (0xFF00 + 255 * 0xF0F0), j_g * 0xFF00 + b * 0xF0F0
+        )
+        self.assertEqual(
+            j_g * (0xFF00 + 255 * 0xF0F0), j_g.mul_add(0xFF00, b, 0xF0F0)
+        )
+
+    def test_mul_add_with_infinity_as_result(self):
+        j_g = PointJacobi.from_affine(generator_256)
+
+        order = generator_256.order()
+
+        b = PointJacobi.from_affine(generator_256 * 256)
+
+        self.assertEqual(j_g.mul_add(order % 256, b, order // 256), INFINITY)
+
+    def test_mul_add_without_order(self):
+        j_g = PointJacobi(curve_256, generator_256.x(), generator_256.y(), 1)
+
+        order = generator_256.order()
+
+        w_b = generator_256 * 34
+        w_b.scale()
+
+        b = PointJacobi(curve_256, w_b.x(), w_b.y(), 1)
+
+        self.assertEqual(j_g.mul_add(order % 34, b, order // 34), INFINITY)
+
+    def test_mul_add_with_doubled_negation_of_itself(self):
+        j_g = PointJacobi.from_affine(generator_256 * 17)
+
+        dbl_neg = 2 * (-j_g)
+
+        self.assertEqual(j_g.mul_add(4, dbl_neg, 2), INFINITY)
+
+    def test_equality(self):
+        pj1 = PointJacobi(curve=CurveFp(23, 1, 1, 1), x=2, y=3, z=1, order=1)
+        pj2 = PointJacobi(curve=CurveFp(23, 1, 1, 1), x=2, y=3, z=1, order=1)
+        self.assertEqual(pj1, pj2)
+
+    def test_equality_with_invalid_object(self):
+        j_g = PointJacobi.from_affine(generator_256)
+
+        self.assertNotEqual(j_g, 12)
+
+    def test_equality_with_wrong_curves(self):
+        p_a = PointJacobi.from_affine(generator_256)
+        p_b = PointJacobi.from_affine(generator_224)
+
+        self.assertNotEqual(p_a, p_b)
+
+    def test_pickle(self):
+        pj = PointJacobi(curve=CurveFp(23, 1, 1, 1), x=2, y=3, z=1, order=1)
+        self.assertEqual(pickle.loads(pickle.dumps(pj)), pj)
+
+    @settings(**NO_OLD_SETTINGS)
+    @given(st.integers(min_value=1, max_value=10))
+    def test_multithreading(self, thread_num):
+        # ensure that generator's precomputation table is filled
+        generator_112r2 * 2
+
+        # create a fresh point that doesn't have a filled precomputation table
+        gen = generator_112r2
+        gen = PointJacobi(gen.curve(), gen.x(), gen.y(), 1, gen.order(), True)
+
+        self.assertEqual(gen._PointJacobi__precompute, [])
+
+        def runner(generator):
+            order = generator.order()
+            for _ in range(10):
+                generator * randrange(order)
+
+        threads = []
+        for _ in range(thread_num):
+            threads.append(threading.Thread(target=runner, args=(gen,)))
+
+        for t in threads:
+            t.start()
+
+        runner(gen)
+
+        for t in threads:
+            t.join()
+
+        self.assertEqual(
+            gen._PointJacobi__precompute,
+            generator_112r2._PointJacobi__precompute,
+        )
+
+    @pytest.mark.skipif(
+        platform.system() == "Windows",
+        reason="there are no signals on Windows",
+    )
+    def test_multithreading_with_interrupts(self):
+        thread_num = 10
+        # ensure that generator's precomputation table is filled
+        generator_112r2 * 2
+
+        # create a fresh point that doesn't have a filled precomputation table
+        gen = generator_112r2
+        gen = PointJacobi(gen.curve(), gen.x(), gen.y(), 1, gen.order(), True)
+
+        self.assertEqual(gen._PointJacobi__precompute, [])
+
+        def runner(generator):
+            order = generator.order()
+            for _ in range(50):
+                generator * randrange(order)
+
+        def interrupter(barrier_start, barrier_end, lock_exit):
+            # wait until MainThread can handle KeyboardInterrupt
+            barrier_start.release()
+            barrier_end.acquire()
+            os.kill(os.getpid(), signal.SIGINT)
+            lock_exit.release()
+
+        threads = []
+        for _ in range(thread_num):
+            threads.append(threading.Thread(target=runner, args=(gen,)))
+
+        barrier_start = threading.Lock()
+        barrier_start.acquire()
+        barrier_end = threading.Lock()
+        barrier_end.acquire()
+        lock_exit = threading.Lock()
+        lock_exit.acquire()
+
+        threads.append(
+            threading.Thread(
+                target=interrupter,
+                args=(barrier_start, barrier_end, lock_exit),
+            )
+        )
+
+        for t in threads:
+            t.start()
+
+        with self.assertRaises(KeyboardInterrupt):
+            # signal to interrupter that we can now handle the signal
+            barrier_start.acquire()
+            barrier_end.release()
+            runner(gen)
+            # use the lock to ensure we never go past the scope of
+            # assertRaises before the os.kill is called
+            lock_exit.acquire()
+
+        for t in threads:
+            t.join()
+
+        self.assertEqual(
+            gen._PointJacobi__precompute,
+            generator_112r2._PointJacobi__precompute,
+        )
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_keys.py b/myenv/lib/python3.9/site-packages/ecdsa/test_keys.py
new file mode 100644
index 0000000..25386b1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_keys.py
@@ -0,0 +1,959 @@
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+
+try:
+    buffer
+except NameError:
+    buffer = memoryview
+
+import os
+import array
+import pytest
+import hashlib
+
+from .keys import VerifyingKey, SigningKey, MalformedPointError
+from .der import (
+    unpem,
+    UnexpectedDER,
+    encode_sequence,
+    encode_oid,
+    encode_bitstring,
+)
+from .util import (
+    sigencode_string,
+    sigencode_der,
+    sigencode_strings,
+    sigdecode_string,
+    sigdecode_der,
+    sigdecode_strings,
+)
+from .curves import NIST256p, Curve, BRAINPOOLP160r1, Ed25519, Ed448
+from .ellipticcurve import Point, PointJacobi, CurveFp, INFINITY
+from .ecdsa import generator_brainpoolp160r1
+
+
+class TestVerifyingKeyFromString(unittest.TestCase):
+    """
+    Verify that ecdsa.keys.VerifyingKey.from_string() can be used with
+    bytes-like objects
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        cls.key_bytes = (
+            b"\x04L\xa2\x95\xdb\xc7Z\xd7\x1f\x93\nz\xcf\x97\xcf"
+            b"\xd7\xc2\xd9o\xfe8}X!\xae\xd4\xfah\xfa^\rpI\xba\xd1"
+            b"Y\xfb\x92xa\xebo+\x9cG\xfav\xca"
+        )
+        cls.vk = VerifyingKey.from_string(cls.key_bytes)
+
+    def test_bytes(self):
+        self.assertIsNotNone(self.vk)
+        self.assertIsInstance(self.vk, VerifyingKey)
+        self.assertEqual(
+            self.vk.pubkey.point.x(),
+            105419898848891948935835657980914000059957975659675736097,
+        )
+        self.assertEqual(
+            self.vk.pubkey.point.y(),
+            4286866841217412202667522375431381222214611213481632495306,
+        )
+
+    def test_bytes_memoryview(self):
+        vk = VerifyingKey.from_string(buffer(self.key_bytes))
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_bytearray(self):
+        vk = VerifyingKey.from_string(bytearray(self.key_bytes))
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_bytesarray_memoryview(self):
+        vk = VerifyingKey.from_string(buffer(bytearray(self.key_bytes)))
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_array_array_of_bytes(self):
+        arr = array.array("B", self.key_bytes)
+        vk = VerifyingKey.from_string(arr)
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_array_array_of_bytes_memoryview(self):
+        arr = array.array("B", self.key_bytes)
+        vk = VerifyingKey.from_string(buffer(arr))
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_array_array_of_ints(self):
+        arr = array.array("I", self.key_bytes)
+        vk = VerifyingKey.from_string(arr)
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_array_array_of_ints_memoryview(self):
+        arr = array.array("I", self.key_bytes)
+        vk = VerifyingKey.from_string(buffer(arr))
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_bytes_uncompressed(self):
+        vk = VerifyingKey.from_string(b"\x04" + self.key_bytes)
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_bytearray_uncompressed(self):
+        vk = VerifyingKey.from_string(bytearray(b"\x04" + self.key_bytes))
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_bytes_compressed(self):
+        vk = VerifyingKey.from_string(b"\x02" + self.key_bytes[:24])
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_bytearray_compressed(self):
+        vk = VerifyingKey.from_string(bytearray(b"\x02" + self.key_bytes[:24]))
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+
+class TestVerifyingKeyFromDer(unittest.TestCase):
+    """
+    Verify that ecdsa.keys.VerifyingKey.from_der() can be used with
+    bytes-like objects.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        prv_key_str = (
+            "-----BEGIN EC PRIVATE KEY-----\n"
+            "MF8CAQEEGF7IQgvW75JSqULpiQQ8op9WH6Uldw6xxaAKBggqhkjOPQMBAaE0AzIA\n"
+            "BLiBd9CE7xf15FY5QIAoNg+fWbSk1yZOYtoGUdzkejWkxbRc9RWTQjqLVXucIJnz\n"
+            "bA==\n"
+            "-----END EC PRIVATE KEY-----\n"
+        )
+        key_str = (
+            "-----BEGIN PUBLIC KEY-----\n"
+            "MEkwEwYHKoZIzj0CAQYIKoZIzj0DAQEDMgAEuIF30ITvF/XkVjlAgCg2D59ZtKTX\n"
+            "Jk5i2gZR3OR6NaTFtFz1FZNCOotVe5wgmfNs\n"
+            "-----END PUBLIC KEY-----\n"
+        )
+        cls.key_pem = key_str
+
+        cls.key_bytes = unpem(key_str)
+        assert isinstance(cls.key_bytes, bytes)
+        cls.vk = VerifyingKey.from_pem(key_str)
+        cls.sk = SigningKey.from_pem(prv_key_str)
+
+        key_str = (
+            "-----BEGIN PUBLIC KEY-----\n"
+            "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4H3iRbG4TSrsSRb/gusPQB/4YcN8\n"
+            "Poqzgjau4kfxBPyZimeRfuY/9g/wMmPuhGl4BUve51DsnKJFRr8psk0ieA==\n"
+            "-----END PUBLIC KEY-----\n"
+        )
+        cls.vk2 = VerifyingKey.from_pem(key_str)
+
+        cls.sk2 = SigningKey.generate(vk.curve)
+
+    def test_load_key_with_explicit_parameters(self):
+        pub_key_str = (
+            "-----BEGIN PUBLIC KEY-----\n"
+            "MIIBSzCCAQMGByqGSM49AgEwgfcCAQEwLAYHKoZIzj0BAQIhAP////8AAAABAAAA\n"
+            "AAAAAAAAAAAA////////////////MFsEIP////8AAAABAAAAAAAAAAAAAAAA////\n"
+            "///////////8BCBaxjXYqjqT57PrvVV2mIa8ZR0GsMxTsPY7zjw+J9JgSwMVAMSd\n"
+            "NgiG5wSTamZ44ROdJreBn36QBEEEaxfR8uEsQkf4vOblY6RA8ncDfYEt6zOg9KE5\n"
+            "RdiYwpZP40Li/hp/m47n60p8D54WK84zV2sxXs7LtkBoN79R9QIhAP////8AAAAA\n"
+            "//////////+85vqtpxeehPO5ysL8YyVRAgEBA0IABIr1UkgYs5jmbFc7it1/YI2X\n"
+            "T//IlaEjMNZft1owjqpBYH2ErJHk4U5Pp4WvWq1xmHwIZlsH7Ig4KmefCfR6SmU=\n"
+            "-----END PUBLIC KEY-----"
+        )
+        pk = VerifyingKey.from_pem(pub_key_str)
+
+        pk_exp = VerifyingKey.from_string(
+            b"\x04\x8a\xf5\x52\x48\x18\xb3\x98\xe6\x6c\x57\x3b\x8a\xdd\x7f"
+            b"\x60\x8d\x97\x4f\xff\xc8\x95\xa1\x23\x30\xd6\x5f\xb7\x5a\x30"
+            b"\x8e\xaa\x41\x60\x7d\x84\xac\x91\xe4\xe1\x4e\x4f\xa7\x85\xaf"
+            b"\x5a\xad\x71\x98\x7c\x08\x66\x5b\x07\xec\x88\x38\x2a\x67\x9f"
+            b"\x09\xf4\x7a\x4a\x65",
+            curve=NIST256p,
+        )
+        self.assertEqual(pk, pk_exp)
+
+    def test_load_key_with_explicit_with_explicit_disabled(self):
+        pub_key_str = (
+            "-----BEGIN PUBLIC KEY-----\n"
+            "MIIBSzCCAQMGByqGSM49AgEwgfcCAQEwLAYHKoZIzj0BAQIhAP////8AAAABAAAA\n"
+            "AAAAAAAAAAAA////////////////MFsEIP////8AAAABAAAAAAAAAAAAAAAA////\n"
+            "///////////8BCBaxjXYqjqT57PrvVV2mIa8ZR0GsMxTsPY7zjw+J9JgSwMVAMSd\n"
+            "NgiG5wSTamZ44ROdJreBn36QBEEEaxfR8uEsQkf4vOblY6RA8ncDfYEt6zOg9KE5\n"
+            "RdiYwpZP40Li/hp/m47n60p8D54WK84zV2sxXs7LtkBoN79R9QIhAP////8AAAAA\n"
+            "//////////+85vqtpxeehPO5ysL8YyVRAgEBA0IABIr1UkgYs5jmbFc7it1/YI2X\n"
+            "T//IlaEjMNZft1owjqpBYH2ErJHk4U5Pp4WvWq1xmHwIZlsH7Ig4KmefCfR6SmU=\n"
+            "-----END PUBLIC KEY-----"
+        )
+        with self.assertRaises(UnexpectedDER):
+            VerifyingKey.from_pem(
+                pub_key_str, valid_curve_encodings=["named_curve"]
+            )
+
+    def test_load_key_with_disabled_format(self):
+        with self.assertRaises(MalformedPointError) as e:
+            VerifyingKey.from_der(self.key_bytes, valid_encodings=["raw"])
+
+        self.assertIn("enabled (raw) encodings", str(e.exception))
+
+    def test_custom_hashfunc(self):
+        vk = VerifyingKey.from_der(self.key_bytes, hashlib.sha256)
+
+        self.assertIs(vk.default_hashfunc, hashlib.sha256)
+
+    def test_from_pem_with_custom_hashfunc(self):
+        vk = VerifyingKey.from_pem(self.key_pem, hashlib.sha256)
+
+        self.assertIs(vk.default_hashfunc, hashlib.sha256)
+
+    def test_bytes(self):
+        vk = VerifyingKey.from_der(self.key_bytes)
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_bytes_memoryview(self):
+        vk = VerifyingKey.from_der(buffer(self.key_bytes))
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_bytearray(self):
+        vk = VerifyingKey.from_der(bytearray(self.key_bytes))
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_bytesarray_memoryview(self):
+        vk = VerifyingKey.from_der(buffer(bytearray(self.key_bytes)))
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_array_array_of_bytes(self):
+        arr = array.array("B", self.key_bytes)
+        vk = VerifyingKey.from_der(arr)
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_array_array_of_bytes_memoryview(self):
+        arr = array.array("B", self.key_bytes)
+        vk = VerifyingKey.from_der(buffer(arr))
+
+        self.assertEqual(self.vk.to_string(), vk.to_string())
+
+    def test_equality_on_verifying_keys(self):
+        self.assertEqual(self.vk, self.sk.get_verifying_key())
+
+    def test_inequality_on_verifying_keys(self):
+        self.assertNotEqual(self.vk, self.vk2)
+
+    def test_inequality_on_verifying_keys_not_implemented(self):
+        self.assertNotEqual(self.vk, None)
+
+    def test_VerifyingKey_inequality_on_same_curve(self):
+        self.assertNotEqual(self.vk, self.sk2.verifying_key)
+
+    def test_SigningKey_inequality_on_same_curve(self):
+        self.assertNotEqual(self.sk, self.sk2)
+
+    def test_inequality_on_wrong_types(self):
+        self.assertNotEqual(self.vk, self.sk)
+
+    def test_from_public_point_old(self):
+        pj = self.vk.pubkey.point
+        point = Point(pj.curve(), pj.x(), pj.y())
+
+        vk = VerifyingKey.from_public_point(point, self.vk.curve)
+
+        self.assertEqual(vk, self.vk)
+
+    def test_ed25519_VerifyingKey_repr__(self):
+        sk = SigningKey.from_string(Ed25519.generator.to_bytes(), Ed25519)
+        string = repr(sk.verifying_key)
+
+        self.assertEqual(
+            "VerifyingKey.from_string("
+            "bytearray(b'K\\x0c\\xfbZH\\x8e\\x8c\\x8c\\x07\\xee\\xda\\xfb"
+            "\\xe1\\x97\\xcd\\x90\\x18\\x02\\x15h]\\xfe\\xbe\\xcbB\\xba\\xe6r"
+            "\\x10\\xae\\xf1P'), Ed25519, None)",
+            string,
+        )
+
+    def test_edwards_from_public_point(self):
+        point = Ed25519.generator
+        with self.assertRaises(ValueError) as e:
+            VerifyingKey.from_public_point(point, Ed25519)
+
+        self.assertIn("incompatible with Edwards", str(e.exception))
+
+    def test_edwards_precompute_no_side_effect(self):
+        sk = SigningKey.from_string(Ed25519.generator.to_bytes(), Ed25519)
+        vk = sk.verifying_key
+        vk2 = VerifyingKey.from_string(vk.to_string(), Ed25519)
+        vk.precompute()
+
+        self.assertEqual(vk, vk2)
+
+    def test_parse_malfomed_eddsa_der_pubkey(self):
+        der_str = encode_sequence(
+            encode_sequence(encode_oid(*Ed25519.oid)),
+            encode_bitstring(bytes(Ed25519.generator.to_bytes()), 0),
+            encode_bitstring(b"\x00", 0),
+        )
+
+        with self.assertRaises(UnexpectedDER) as e:
+            VerifyingKey.from_der(der_str)
+
+        self.assertIn("trailing junk after public key", str(e.exception))
+
+    def test_edwards_from_public_key_recovery(self):
+        with self.assertRaises(ValueError) as e:
+            VerifyingKey.from_public_key_recovery(b"", b"", Ed25519)
+
+        self.assertIn("unsupported for Edwards", str(e.exception))
+
+    def test_edwards_from_public_key_recovery_with_digest(self):
+        with self.assertRaises(ValueError) as e:
+            VerifyingKey.from_public_key_recovery_with_digest(
+                b"", b"", Ed25519
+            )
+
+        self.assertIn("unsupported for Edwards", str(e.exception))
+
+    def test_load_ed25519_from_pem(self):
+        vk_pem = (
+            "-----BEGIN PUBLIC KEY-----\n"
+            "MCowBQYDK2VwAyEAIwBQ0NZkIiiO41WJfm5BV42u3kQm7lYnvIXmCy8qy2U=\n"
+            "-----END PUBLIC KEY-----\n"
+        )
+
+        vk = VerifyingKey.from_pem(vk_pem)
+
+        self.assertIsInstance(vk.curve, Curve)
+        self.assertIs(vk.curve, Ed25519)
+
+        vk_str = (
+            b"\x23\x00\x50\xd0\xd6\x64\x22\x28\x8e\xe3\x55\x89\x7e\x6e\x41\x57"
+            b"\x8d\xae\xde\x44\x26\xee\x56\x27\xbc\x85\xe6\x0b\x2f\x2a\xcb\x65"
+        )
+
+        vk_2 = VerifyingKey.from_string(vk_str, Ed25519)
+
+        self.assertEqual(vk, vk_2)
+
+    def test_export_ed255_to_pem(self):
+        vk_str = (
+            b"\x23\x00\x50\xd0\xd6\x64\x22\x28\x8e\xe3\x55\x89\x7e\x6e\x41\x57"
+            b"\x8d\xae\xde\x44\x26\xee\x56\x27\xbc\x85\xe6\x0b\x2f\x2a\xcb\x65"
+        )
+
+        vk = VerifyingKey.from_string(vk_str, Ed25519)
+
+        vk_pem = (
+            b"-----BEGIN PUBLIC KEY-----\n"
+            b"MCowBQYDK2VwAyEAIwBQ0NZkIiiO41WJfm5BV42u3kQm7lYnvIXmCy8qy2U=\n"
+            b"-----END PUBLIC KEY-----\n"
+        )
+
+        self.assertEqual(vk_pem, vk.to_pem())
+
+    def test_ed25519_export_import(self):
+        sk = SigningKey.generate(Ed25519)
+        vk = sk.verifying_key
+
+        vk2 = VerifyingKey.from_pem(vk.to_pem())
+
+        self.assertEqual(vk, vk2)
+
+    def test_ed25519_sig_verify(self):
+        vk_pem = (
+            "-----BEGIN PUBLIC KEY-----\n"
+            "MCowBQYDK2VwAyEAIwBQ0NZkIiiO41WJfm5BV42u3kQm7lYnvIXmCy8qy2U=\n"
+            "-----END PUBLIC KEY-----\n"
+        )
+
+        vk = VerifyingKey.from_pem(vk_pem)
+
+        data = b"data\n"
+
+        # signature created by OpenSSL 3.0.0 beta1
+        sig = (
+            b"\x64\x47\xab\x6a\x33\xcd\x79\x45\xad\x98\x11\x6c\xb9\xf2\x20\xeb"
+            b"\x90\xd6\x50\xe3\xc7\x8f\x9f\x60\x10\xec\x75\xe0\x2f\x27\xd3\x96"
+            b"\xda\xe8\x58\x7f\xe0\xfe\x46\x5c\x81\xef\x50\xec\x29\x9f\xae\xd5"
+            b"\xad\x46\x3c\x91\x68\x83\x4d\xea\x8d\xa8\x19\x04\x04\x79\x03\x0b"
+        )
+
+        self.assertTrue(vk.verify(sig, data))
+
+    def test_ed448_from_pem(self):
+        pem_str = (
+            "-----BEGIN PUBLIC KEY-----\n"
+            "MEMwBQYDK2VxAzoAeQtetSu7CMEzE+XWB10Bg47LCA0giNikOxHzdp+tZ/eK/En0\n"
+            "dTdYD2ll94g58MhSnBiBQB9A1MMA\n"
+            "-----END PUBLIC KEY-----\n"
+        )
+
+        vk = VerifyingKey.from_pem(pem_str)
+
+        self.assertIsInstance(vk.curve, Curve)
+        self.assertIs(vk.curve, Ed448)
+
+        vk_str = (
+            b"\x79\x0b\x5e\xb5\x2b\xbb\x08\xc1\x33\x13\xe5\xd6\x07\x5d\x01\x83"
+            b"\x8e\xcb\x08\x0d\x20\x88\xd8\xa4\x3b\x11\xf3\x76\x9f\xad\x67\xf7"
+            b"\x8a\xfc\x49\xf4\x75\x37\x58\x0f\x69\x65\xf7\x88\x39\xf0\xc8\x52"
+            b"\x9c\x18\x81\x40\x1f\x40\xd4\xc3\x00"
+        )
+
+        vk2 = VerifyingKey.from_string(vk_str, Ed448)
+
+        self.assertEqual(vk, vk2)
+
+    def test_ed448_to_pem(self):
+        vk_str = (
+            b"\x79\x0b\x5e\xb5\x2b\xbb\x08\xc1\x33\x13\xe5\xd6\x07\x5d\x01\x83"
+            b"\x8e\xcb\x08\x0d\x20\x88\xd8\xa4\x3b\x11\xf3\x76\x9f\xad\x67\xf7"
+            b"\x8a\xfc\x49\xf4\x75\x37\x58\x0f\x69\x65\xf7\x88\x39\xf0\xc8\x52"
+            b"\x9c\x18\x81\x40\x1f\x40\xd4\xc3\x00"
+        )
+        vk = VerifyingKey.from_string(vk_str, Ed448)
+
+        vk_pem = (
+            b"-----BEGIN PUBLIC KEY-----\n"
+            b"MEMwBQYDK2VxAzoAeQtetSu7CMEzE+XWB10Bg47LCA0giNikOxHzdp+tZ/eK/En0\n"
+            b"dTdYD2ll94g58MhSnBiBQB9A1MMA\n"
+            b"-----END PUBLIC KEY-----\n"
+        )
+
+        self.assertEqual(vk_pem, vk.to_pem())
+
+    def test_ed448_export_import(self):
+        sk = SigningKey.generate(Ed448)
+        vk = sk.verifying_key
+
+        vk2 = VerifyingKey.from_pem(vk.to_pem())
+
+        self.assertEqual(vk, vk2)
+
+    def test_ed448_sig_verify(self):
+        pem_str = (
+            "-----BEGIN PUBLIC KEY-----\n"
+            "MEMwBQYDK2VxAzoAeQtetSu7CMEzE+XWB10Bg47LCA0giNikOxHzdp+tZ/eK/En0\n"
+            "dTdYD2ll94g58MhSnBiBQB9A1MMA\n"
+            "-----END PUBLIC KEY-----\n"
+        )
+
+        vk = VerifyingKey.from_pem(pem_str)
+
+        data = b"data\n"
+
+        # signature created by OpenSSL 3.0.0 beta1
+        sig = (
+            b"\x68\xed\x2c\x70\x35\x22\xca\x1c\x35\x03\xf3\xaa\x51\x33\x3d\x00"
+            b"\xc0\xae\xb0\x54\xc5\xdc\x7f\x6f\x30\x57\xb4\x1d\xcb\xe9\xec\xfa"
+            b"\xc8\x45\x3e\x51\xc1\xcb\x60\x02\x6a\xd0\x43\x11\x0b\x5f\x9b\xfa"
+            b"\x32\x88\xb2\x38\x6b\xed\xac\x09\x00\x78\xb1\x7b\x5d\x7e\xf8\x16"
+            b"\x31\xdd\x1b\x3f\x98\xa0\xce\x19\xe7\xd8\x1c\x9f\x30\xac\x2f\xd4"
+            b"\x1e\x55\xbf\x21\x98\xf6\x4c\x8c\xbe\x81\xa5\x2d\x80\x4c\x62\x53"
+            b"\x91\xd5\xee\x03\x30\xc6\x17\x66\x4b\x9e\x0c\x8d\x40\xd0\xad\xae"
+            b"\x0a\x00"
+        )
+
+        self.assertTrue(vk.verify(sig, data))
+
+
+class TestSigningKey(unittest.TestCase):
+    """
+    Verify that ecdsa.keys.SigningKey.from_der() can be used with
+    bytes-like objects.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        prv_key_str = (
+            "-----BEGIN EC PRIVATE KEY-----\n"
+            "MF8CAQEEGF7IQgvW75JSqULpiQQ8op9WH6Uldw6xxaAKBggqhkjOPQMBAaE0AzIA\n"
+            "BLiBd9CE7xf15FY5QIAoNg+fWbSk1yZOYtoGUdzkejWkxbRc9RWTQjqLVXucIJnz\n"
+            "bA==\n"
+            "-----END EC PRIVATE KEY-----\n"
+        )
+        cls.sk1 = SigningKey.from_pem(prv_key_str)
+
+        prv_key_str = (
+            "-----BEGIN PRIVATE KEY-----\n"
+            "MG8CAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQEEVTBTAgEBBBheyEIL1u+SUqlC6YkE\n"
+            "PKKfVh+lJXcOscWhNAMyAAS4gXfQhO8X9eRWOUCAKDYPn1m0pNcmTmLaBlHc5Ho1\n"
+            "pMW0XPUVk0I6i1V7nCCZ82w=\n"
+            "-----END PRIVATE KEY-----\n"
+        )
+        cls.sk1_pkcs8 = SigningKey.from_pem(prv_key_str)
+
+        prv_key_str = (
+            "-----BEGIN EC PRIVATE KEY-----\n"
+            "MHcCAQEEIKlL2EAm5NPPZuXwxRf4nXMk0A80y6UUbiQ17be/qFhRoAoGCCqGSM49\n"
+            "AwEHoUQDQgAE4H3iRbG4TSrsSRb/gusPQB/4YcN8Poqzgjau4kfxBPyZimeRfuY/\n"
+            "9g/wMmPuhGl4BUve51DsnKJFRr8psk0ieA==\n"
+            "-----END EC PRIVATE KEY-----\n"
+        )
+        cls.sk2 = SigningKey.from_pem(prv_key_str)
+
+    def test_decoding_explicit_curve_parameters(self):
+        prv_key_str = (
+            "-----BEGIN PRIVATE KEY-----\n"
+            "MIIBeQIBADCCAQMGByqGSM49AgEwgfcCAQEwLAYHKoZIzj0BAQIhAP////8AAAAB\n"
+            "AAAAAAAAAAAAAAAA////////////////MFsEIP////8AAAABAAAAAAAAAAAAAAAA\n"
+            "///////////////8BCBaxjXYqjqT57PrvVV2mIa8ZR0GsMxTsPY7zjw+J9JgSwMV\n"
+            "AMSdNgiG5wSTamZ44ROdJreBn36QBEEEaxfR8uEsQkf4vOblY6RA8ncDfYEt6zOg\n"
+            "9KE5RdiYwpZP40Li/hp/m47n60p8D54WK84zV2sxXs7LtkBoN79R9QIhAP////8A\n"
+            "AAAA//////////+85vqtpxeehPO5ysL8YyVRAgEBBG0wawIBAQQgIXtREfUmR16r\n"
+            "ZbmvDGD2lAEFPZa2DLPyz0czSja58yChRANCAASK9VJIGLOY5mxXO4rdf2CNl0//\n"
+            "yJWhIzDWX7daMI6qQWB9hKyR5OFOT6eFr1qtcZh8CGZbB+yIOCpnnwn0ekpl\n"
+            "-----END PRIVATE KEY-----\n"
+        )
+
+        sk = SigningKey.from_pem(prv_key_str)
+
+        sk2 = SigningKey.from_string(
+            b"\x21\x7b\x51\x11\xf5\x26\x47\x5e\xab\x65\xb9\xaf\x0c\x60\xf6"
+            b"\x94\x01\x05\x3d\x96\xb6\x0c\xb3\xf2\xcf\x47\x33\x4a\x36\xb9"
+            b"\xf3\x20",
+            curve=NIST256p,
+        )
+
+        self.assertEqual(sk, sk2)
+
+    def test_decoding_explicit_curve_parameters_with_explicit_disabled(self):
+        prv_key_str = (
+            "-----BEGIN PRIVATE KEY-----\n"
+            "MIIBeQIBADCCAQMGByqGSM49AgEwgfcCAQEwLAYHKoZIzj0BAQIhAP////8AAAAB\n"
+            "AAAAAAAAAAAAAAAA////////////////MFsEIP////8AAAABAAAAAAAAAAAAAAAA\n"
+            "///////////////8BCBaxjXYqjqT57PrvVV2mIa8ZR0GsMxTsPY7zjw+J9JgSwMV\n"
+            "AMSdNgiG5wSTamZ44ROdJreBn36QBEEEaxfR8uEsQkf4vOblY6RA8ncDfYEt6zOg\n"
+            "9KE5RdiYwpZP40Li/hp/m47n60p8D54WK84zV2sxXs7LtkBoN79R9QIhAP////8A\n"
+            "AAAA//////////+85vqtpxeehPO5ysL8YyVRAgEBBG0wawIBAQQgIXtREfUmR16r\n"
+            "ZbmvDGD2lAEFPZa2DLPyz0czSja58yChRANCAASK9VJIGLOY5mxXO4rdf2CNl0//\n"
+            "yJWhIzDWX7daMI6qQWB9hKyR5OFOT6eFr1qtcZh8CGZbB+yIOCpnnwn0ekpl\n"
+            "-----END PRIVATE KEY-----\n"
+        )
+
+        with self.assertRaises(UnexpectedDER):
+            SigningKey.from_pem(
+                prv_key_str, valid_curve_encodings=["named_curve"]
+            )
+
+    def test_equality_on_signing_keys(self):
+        sk = SigningKey.from_secret_exponent(
+            self.sk1.privkey.secret_multiplier, self.sk1.curve
+        )
+        self.assertEqual(self.sk1, sk)
+        self.assertEqual(self.sk1_pkcs8, sk)
+
+    def test_verify_with_empty_message(self):
+        sig = self.sk1.sign(b"")
+
+        self.assertTrue(sig)
+
+        vk = self.sk1.verifying_key
+
+        self.assertTrue(vk.verify(sig, b""))
+
+    def test_verify_with_precompute(self):
+        sig = self.sk1.sign(b"message")
+
+        vk = self.sk1.verifying_key
+
+        vk.precompute()
+
+        self.assertTrue(vk.verify(sig, b"message"))
+
+    def test_compare_verifying_key_with_precompute(self):
+        vk1 = self.sk1.verifying_key
+        vk1.precompute()
+
+        vk2 = self.sk1_pkcs8.verifying_key
+
+        self.assertEqual(vk1, vk2)
+
+    def test_verify_with_lazy_precompute(self):
+        sig = self.sk2.sign(b"other message")
+
+        vk = self.sk2.verifying_key
+
+        vk.precompute(lazy=True)
+
+        self.assertTrue(vk.verify(sig, b"other message"))
+
+    def test_inequality_on_signing_keys(self):
+        self.assertNotEqual(self.sk1, self.sk2)
+
+    def test_inequality_on_signing_keys_not_implemented(self):
+        self.assertNotEqual(self.sk1, None)
+
+    def test_ed25519_from_pem(self):
+        pem_str = (
+            "-----BEGIN PRIVATE KEY-----\n"
+            "MC4CAQAwBQYDK2VwBCIEIDS6x9FO1PG8T4xIPg8Zd0z8uL6sVGZFEZrX17gHC/XU\n"
+            "-----END PRIVATE KEY-----\n"
+        )
+
+        sk = SigningKey.from_pem(pem_str)
+
+        sk_str = SigningKey.from_string(
+            b"\x34\xBA\xC7\xD1\x4E\xD4\xF1\xBC\x4F\x8C\x48\x3E\x0F\x19\x77\x4C"
+            b"\xFC\xB8\xBE\xAC\x54\x66\x45\x11\x9A\xD7\xD7\xB8\x07\x0B\xF5\xD4",
+            Ed25519,
+        )
+
+        self.assertEqual(sk, sk_str)
+
+    def test_ed25519_to_pem(self):
+        sk = SigningKey.from_string(
+            b"\x34\xBA\xC7\xD1\x4E\xD4\xF1\xBC\x4F\x8C\x48\x3E\x0F\x19\x77\x4C"
+            b"\xFC\xB8\xBE\xAC\x54\x66\x45\x11\x9A\xD7\xD7\xB8\x07\x0B\xF5\xD4",
+            Ed25519,
+        )
+
+        pem_str = (
+            b"-----BEGIN PRIVATE KEY-----\n"
+            b"MC4CAQAwBQYDK2VwBCIEIDS6x9FO1PG8T4xIPg8Zd0z8uL6sVGZFEZrX17gHC/XU\n"
+            b"-----END PRIVATE KEY-----\n"
+        )
+
+        self.assertEqual(sk.to_pem(format="pkcs8"), pem_str)
+
+    def test_ed25519_to_and_from_pem(self):
+        sk = SigningKey.generate(Ed25519)
+
+        decoded = SigningKey.from_pem(sk.to_pem(format="pkcs8"))
+
+        self.assertEqual(sk, decoded)
+
+    def test_ed448_from_pem(self):
+        pem_str = (
+            "-----BEGIN PRIVATE KEY-----\n"
+            "MEcCAQAwBQYDK2VxBDsEOTyFuXqFLXgJlV8uDqcOw9nG4IqzLiZ/i5NfBDoHPzmP\n"
+            "OP0JMYaLGlTzwovmvCDJ2zLaezu9NLz9aQ==\n"
+            "-----END PRIVATE KEY-----\n"
+        )
+        sk = SigningKey.from_pem(pem_str)
+
+        sk_str = SigningKey.from_string(
+            b"\x3C\x85\xB9\x7A\x85\x2D\x78\x09\x95\x5F\x2E\x0E\xA7\x0E\xC3\xD9"
+            b"\xC6\xE0\x8A\xB3\x2E\x26\x7F\x8B\x93\x5F\x04\x3A\x07\x3F\x39\x8F"
+            b"\x38\xFD\x09\x31\x86\x8B\x1A\x54\xF3\xC2\x8B\xE6\xBC\x20\xC9\xDB"
+            b"\x32\xDA\x7B\x3B\xBD\x34\xBC\xFD\x69",
+            Ed448,
+        )
+
+        self.assertEqual(sk, sk_str)
+
+    def test_ed448_to_pem(self):
+        sk = SigningKey.from_string(
+            b"\x3C\x85\xB9\x7A\x85\x2D\x78\x09\x95\x5F\x2E\x0E\xA7\x0E\xC3\xD9"
+            b"\xC6\xE0\x8A\xB3\x2E\x26\x7F\x8B\x93\x5F\x04\x3A\x07\x3F\x39\x8F"
+            b"\x38\xFD\x09\x31\x86\x8B\x1A\x54\xF3\xC2\x8B\xE6\xBC\x20\xC9\xDB"
+            b"\x32\xDA\x7B\x3B\xBD\x34\xBC\xFD\x69",
+            Ed448,
+        )
+        pem_str = (
+            b"-----BEGIN PRIVATE KEY-----\n"
+            b"MEcCAQAwBQYDK2VxBDsEOTyFuXqFLXgJlV8uDqcOw9nG4IqzLiZ/i5NfBDoHPzmP\n"
+            b"OP0JMYaLGlTzwovmvCDJ2zLaezu9NLz9aQ==\n"
+            b"-----END PRIVATE KEY-----\n"
+        )
+
+        self.assertEqual(sk.to_pem(format="pkcs8"), pem_str)
+
+    def test_ed448_encode_decode(self):
+        sk = SigningKey.generate(Ed448)
+
+        decoded = SigningKey.from_pem(sk.to_pem(format="pkcs8"))
+
+        self.assertEqual(decoded, sk)
+
+
+class TestTrivialCurve(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        # To test what happens with r or s in signing happens to be zero we
+        # need to find a scalar that creates one of the points on a curve that
+        # has x coordinate equal to zero.
+        # Even for secp112r2 curve that's non trivial so use this toy
+        # curve, for which we can iterate over all points quickly
+        curve = CurveFp(163, 84, 58)
+        gen = PointJacobi(curve, 2, 87, 1, 167, generator=True)
+
+        cls.toy_curve = Curve("toy_p8", curve, gen, (1, 2, 0))
+
+        cls.sk = SigningKey.from_secret_exponent(
+            140,
+            cls.toy_curve,
+            hashfunc=hashlib.sha1,
+        )
+
+    def test_generator_sanity(self):
+        gen = self.toy_curve.generator
+
+        self.assertEqual(gen * gen.order(), INFINITY)
+
+    def test_public_key_sanity(self):
+        self.assertEqual(self.sk.verifying_key.to_string(), b"\x98\x1e")
+
+    def test_deterministic_sign(self):
+        sig = self.sk.sign_deterministic(b"message")
+
+        self.assertEqual(sig, b"-.")
+
+        self.assertTrue(self.sk.verifying_key.verify(sig, b"message"))
+
+    def test_deterministic_sign_random_message(self):
+        msg = os.urandom(32)
+        sig = self.sk.sign_deterministic(msg)
+        self.assertEqual(len(sig), 2)
+        self.assertTrue(self.sk.verifying_key.verify(sig, msg))
+
+    def test_deterministic_sign_that_rises_R_zero_error(self):
+        # the raised RSZeroError is caught and handled internally by
+        # sign_deterministic methods
+        msg = b"\x00\x4f"
+        sig = self.sk.sign_deterministic(msg)
+        self.assertEqual(sig, b"\x36\x9e")
+        self.assertTrue(self.sk.verifying_key.verify(sig, msg))
+
+    def test_deterministic_sign_that_rises_S_zero_error(self):
+        msg = b"\x01\x6d"
+        sig = self.sk.sign_deterministic(msg)
+        self.assertEqual(sig, b"\x49\x6c")
+        self.assertTrue(self.sk.verifying_key.verify(sig, msg))
+
+
+# test VerifyingKey.verify()
+prv_key_str = (
+    "-----BEGIN EC PRIVATE KEY-----\n"
+    "MF8CAQEEGF7IQgvW75JSqULpiQQ8op9WH6Uldw6xxaAKBggqhkjOPQMBAaE0AzIA\n"
+    "BLiBd9CE7xf15FY5QIAoNg+fWbSk1yZOYtoGUdzkejWkxbRc9RWTQjqLVXucIJnz\n"
+    "bA==\n"
+    "-----END EC PRIVATE KEY-----\n"
+)
+key_bytes = unpem(prv_key_str)
+assert isinstance(key_bytes, bytes)
+sk = SigningKey.from_der(key_bytes)
+vk = sk.verifying_key
+
+data = (
+    b"some string for signing"
+    b"contents don't really matter"
+    b"but do include also some crazy values: "
+    b"\x00\x01\t\r\n\x00\x00\x00\xff\xf0"
+)
+assert len(data) % 4 == 0
+sha1 = hashlib.sha1()
+sha1.update(data)
+data_hash = sha1.digest()
+assert isinstance(data_hash, bytes)
+sig_raw = sk.sign(data, sigencode=sigencode_string)
+assert isinstance(sig_raw, bytes)
+sig_der = sk.sign(data, sigencode=sigencode_der)
+assert isinstance(sig_der, bytes)
+sig_strings = sk.sign(data, sigencode=sigencode_strings)
+assert isinstance(sig_strings[0], bytes)
+
+verifiers = []
+for modifier, fun in [
+    ("bytes", lambda x: x),
+    ("bytes memoryview", lambda x: buffer(x)),
+    ("bytearray", lambda x: bytearray(x)),
+    ("bytearray memoryview", lambda x: buffer(bytearray(x))),
+    ("array.array of bytes", lambda x: array.array("B", x)),
+    ("array.array of bytes memoryview", lambda x: buffer(array.array("B", x))),
+    ("array.array of ints", lambda x: array.array("I", x)),
+    ("array.array of ints memoryview", lambda x: buffer(array.array("I", x))),
+]:
+    if "ints" in modifier:
+        conv = lambda x: x
+    else:
+        conv = fun
+    for sig_format, signature, decoder, mod_apply in [
+        ("raw", sig_raw, sigdecode_string, lambda x: conv(x)),
+        ("der", sig_der, sigdecode_der, lambda x: conv(x)),
+        (
+            "strings",
+            sig_strings,
+            sigdecode_strings,
+            lambda x: tuple(conv(i) for i in x),
+        ),
+    ]:
+        for method_name, vrf_mthd, vrf_data in [
+            ("verify", vk.verify, data),
+            ("verify_digest", vk.verify_digest, data_hash),
+        ]:
+            verifiers.append(
+                pytest.param(
+                    signature,
+                    decoder,
+                    mod_apply,
+                    fun,
+                    vrf_mthd,
+                    vrf_data,
+                    id="{2}-{0}-{1}".format(modifier, sig_format, method_name),
+                )
+            )
+
+
+@pytest.mark.parametrize(
+    "signature,decoder,mod_apply,fun,vrf_mthd,vrf_data", verifiers
+)
+def test_VerifyingKey_verify(
+    signature, decoder, mod_apply, fun, vrf_mthd, vrf_data
+):
+    sig = mod_apply(signature)
+
+    assert vrf_mthd(sig, fun(vrf_data), sigdecode=decoder)
+
+
+# test SigningKey.from_string()
+prv_key_bytes = (
+    b"^\xc8B\x0b\xd6\xef\x92R\xa9B\xe9\x89\x04<\xa2"
+    b"\x9fV\x1f\xa5%w\x0e\xb1\xc5"
+)
+assert len(prv_key_bytes) == 24
+converters = []
+for modifier, convert in [
+    ("bytes", lambda x: x),
+    ("bytes memoryview", buffer),
+    ("bytearray", bytearray),
+    ("bytearray memoryview", lambda x: buffer(bytearray(x))),
+    ("array.array of bytes", lambda x: array.array("B", x)),
+    ("array.array of bytes memoryview", lambda x: buffer(array.array("B", x))),
+    ("array.array of ints", lambda x: array.array("I", x)),
+    ("array.array of ints memoryview", lambda x: buffer(array.array("I", x))),
+]:
+    converters.append(pytest.param(convert, id=modifier))
+
+
+@pytest.mark.parametrize("convert", converters)
+def test_SigningKey_from_string(convert):
+    key = convert(prv_key_bytes)
+    sk = SigningKey.from_string(key)
+
+    assert sk.to_string() == prv_key_bytes
+
+
+# test SigningKey.from_der()
+prv_key_str = (
+    "-----BEGIN EC PRIVATE KEY-----\n"
+    "MF8CAQEEGF7IQgvW75JSqULpiQQ8op9WH6Uldw6xxaAKBggqhkjOPQMBAaE0AzIA\n"
+    "BLiBd9CE7xf15FY5QIAoNg+fWbSk1yZOYtoGUdzkejWkxbRc9RWTQjqLVXucIJnz\n"
+    "bA==\n"
+    "-----END EC PRIVATE KEY-----\n"
+)
+key_bytes = unpem(prv_key_str)
+assert isinstance(key_bytes, bytes)
+
+# last two converters are for array.array of ints, those require input
+# that's multiple of 4, which no curve we support produces
+@pytest.mark.parametrize("convert", converters[:-2])
+def test_SigningKey_from_der(convert):
+    key = convert(key_bytes)
+    sk = SigningKey.from_der(key)
+
+    assert sk.to_string() == prv_key_bytes
+
+
+# test SigningKey.sign_deterministic()
+extra_entropy = b"\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11"
+
+
+@pytest.mark.parametrize("convert", converters)
+def test_SigningKey_sign_deterministic(convert):
+    sig = sk.sign_deterministic(
+        convert(data), extra_entropy=convert(extra_entropy)
+    )
+
+    vk.verify(sig, data)
+
+
+# test SigningKey.sign_digest_deterministic()
+@pytest.mark.parametrize("convert", converters)
+def test_SigningKey_sign_digest_deterministic(convert):
+    sig = sk.sign_digest_deterministic(
+        convert(data_hash), extra_entropy=convert(extra_entropy)
+    )
+
+    vk.verify(sig, data)
+
+
+@pytest.mark.parametrize("convert", converters)
+def test_SigningKey_sign(convert):
+    sig = sk.sign(convert(data))
+
+    vk.verify(sig, data)
+
+
+@pytest.mark.parametrize("convert", converters)
+def test_SigningKey_sign_digest(convert):
+    sig = sk.sign_digest(convert(data_hash))
+
+    vk.verify(sig, data)
+
+
+def test_SigningKey_with_unlikely_value():
+    sk = SigningKey.from_secret_exponent(NIST256p.order - 1, curve=NIST256p)
+    vk = sk.verifying_key
+    sig = sk.sign(b"hello")
+    assert vk.verify(sig, b"hello")
+
+
+def test_SigningKey_with_custom_curve_old_point():
+    generator = generator_brainpoolp160r1
+    generator = Point(
+        generator.curve(),
+        generator.x(),
+        generator.y(),
+        generator.order(),
+    )
+
+    curve = Curve(
+        "BRAINPOOLP160r1",
+        generator.curve(),
+        generator,
+        (1, 3, 36, 3, 3, 2, 8, 1, 1, 1),
+    )
+
+    sk = SigningKey.from_secret_exponent(12, curve)
+
+    sk2 = SigningKey.from_secret_exponent(12, BRAINPOOLP160r1)
+
+    assert sk.privkey == sk2.privkey
+
+
+def test_VerifyingKey_inequality_with_different_curves():
+    sk1 = SigningKey.from_secret_exponent(2, BRAINPOOLP160r1)
+    sk2 = SigningKey.from_secret_exponent(2, NIST256p)
+
+    assert sk1.verifying_key != sk2.verifying_key
+
+
+def test_VerifyingKey_inequality_with_different_secret_points():
+    sk1 = SigningKey.from_secret_exponent(2, BRAINPOOLP160r1)
+    sk2 = SigningKey.from_secret_exponent(3, BRAINPOOLP160r1)
+
+    assert sk1.verifying_key != sk2.verifying_key
+
+
+def test_SigningKey_from_pem_pkcs8v2_EdDSA():
+    pem = """-----BEGIN PRIVATE KEY-----
+    MFMCAQEwBQYDK2VwBCIEICc2F2ag1n1QP0jY+g9qWx5sDkx0s/HdNi3cSRHw+zsI
+    oSMDIQA+HQ2xCif8a/LMWR2m5HaCm5I2pKe/cc8OiRANMHxjKQ==
+    -----END PRIVATE KEY-----"""
+
+    sk = SigningKey.from_pem(pem)
+    assert sk.curve == Ed25519
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_malformed_sigs.py b/myenv/lib/python3.9/site-packages/ecdsa/test_malformed_sigs.py
new file mode 100644
index 0000000..8e1b611
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_malformed_sigs.py
@@ -0,0 +1,370 @@
+from __future__ import with_statement, division
+
+import hashlib
+
+try:
+    from hashlib import algorithms_available
+except ImportError:  # pragma: no cover
+    algorithms_available = [
+        "md5",
+        "sha1",
+        "sha224",
+        "sha256",
+        "sha384",
+        "sha512",
+    ]
+# skip algorithms broken by change to OpenSSL 3.0 and early versions
+# of hashlib that list algorithms that require the legacy provider to work
+# https://bugs.python.org/issue38820
+algorithms_available = [
+    i
+    for i in algorithms_available
+    if i not in ("mdc2", "md2", "md4", "whirlpool", "ripemd160")
+]
+from functools import partial
+import pytest
+import sys
+import hypothesis.strategies as st
+from hypothesis import note, assume, given, settings, example
+
+from .keys import SigningKey
+from .keys import BadSignatureError
+from .util import sigencode_der, sigencode_string
+from .util import sigdecode_der, sigdecode_string
+from .curves import curves
+from .der import (
+    encode_integer,
+    encode_bitstring,
+    encode_octet_string,
+    encode_oid,
+    encode_sequence,
+    encode_constructed,
+)
+from .ellipticcurve import CurveEdTw
+
+
+example_data = b"some data to sign"
+"""Since the data is hashed for processing, really any string will do."""
+
+
+hash_and_size = [
+    (name, hashlib.new(name).digest_size) for name in algorithms_available
+]
+"""Pairs of hash names and their output sizes.
+Needed for pairing with curves as we don't support hashes
+bigger than order sizes of curves."""
+
+
+keys_and_sigs = []
+"""Name of the curve+hash combination, VerifyingKey and DER signature."""
+
+
+# for hypothesis strategy shrinking we want smallest curves and hashes first
+for curve in sorted(curves, key=lambda x: x.baselen):
+    for hash_alg in [
+        name
+        for name, size in sorted(hash_and_size, key=lambda x: x[1])
+        if 0 < size <= curve.baselen
+    ]:
+        sk = SigningKey.generate(
+            curve, hashfunc=partial(hashlib.new, hash_alg)
+        )
+
+        keys_and_sigs.append(
+            (
+                "{0} {1}".format(curve, hash_alg),
+                sk.verifying_key,
+                sk.sign(example_data, sigencode=sigencode_der),
+            )
+        )
+
+
+# first make sure that the signatures can be verified
+@pytest.mark.parametrize(
+    "verifying_key,signature",
+    [pytest.param(vk, sig, id=name) for name, vk, sig in keys_and_sigs],
+)
+def test_signatures(verifying_key, signature):
+    assert verifying_key.verify(
+        signature, example_data, sigdecode=sigdecode_der
+    )
+
+
+@st.composite
+def st_fuzzed_sig(draw, keys_and_sigs):
+    """
+    Hypothesis strategy that generates pairs of VerifyingKey and malformed
+    signatures created by fuzzing of a valid signature.
+    """
+    name, verifying_key, old_sig = draw(st.sampled_from(keys_and_sigs))
+    note("Configuration: {0}".format(name))
+
+    sig = bytearray(old_sig)
+
+    # decide which bytes should be removed
+    to_remove = draw(
+        st.lists(st.integers(min_value=0, max_value=len(sig) - 1), unique=True)
+    )
+    to_remove.sort()
+    for i in reversed(to_remove):
+        del sig[i]
+    note("Remove bytes: {0}".format(to_remove))
+
+    # decide which bytes of the original signature should be changed
+    if sig:  # pragma: no branch
+        xors = draw(
+            st.dictionaries(
+                st.integers(min_value=0, max_value=len(sig) - 1),
+                st.integers(min_value=1, max_value=255),
+            )
+        )
+        for i, val in xors.items():
+            sig[i] ^= val
+        note("xors: {0}".format(xors))
+
+    # decide where new data should be inserted
+    insert_pos = draw(st.integers(min_value=0, max_value=len(sig)))
+    # NIST521p signature is about 140 bytes long, test slightly longer
+    insert_data = draw(st.binary(max_size=256))
+
+    sig = sig[:insert_pos] + insert_data + sig[insert_pos:]
+    note(
+        "Inserted at position {0} bytes: {1!r}".format(insert_pos, insert_data)
+    )
+
+    sig = bytes(sig)
+    # make sure that there was performed at least one mutation on the data
+    assume(to_remove or xors or insert_data)
+    # and that the mutations didn't cancel each-other out
+    assume(sig != old_sig)
+
+    return verifying_key, sig
+
+
+params = {}
+# not supported in hypothesis 2.0.0
+if sys.version_info >= (2, 7):  # pragma: no branch
+    from hypothesis import HealthCheck
+
+    # deadline=5s because NIST521p are slow to verify
+    params["deadline"] = 5000
+    params["suppress_health_check"] = [
+        HealthCheck.data_too_large,
+        HealthCheck.filter_too_much,
+        HealthCheck.too_slow,
+    ]
+
+slow_params = dict(params)
+slow_params["max_examples"] = 10
+
+
+@settings(**params)
+@given(st_fuzzed_sig(keys_and_sigs))
+def test_fuzzed_der_signatures(args):
+    verifying_key, sig = args
+
+    with pytest.raises(BadSignatureError):
+        verifying_key.verify(sig, example_data, sigdecode=sigdecode_der)
+
+
+@st.composite
+def st_random_der_ecdsa_sig_value(draw):
+    """
+    Hypothesis strategy for selecting random values and encoding them
+    to ECDSA-Sig-Value object::
+
+        ECDSA-Sig-Value ::= SEQUENCE {
+            r INTEGER,
+            s INTEGER
+        }
+    """
+    name, verifying_key, _ = draw(st.sampled_from(keys_and_sigs))
+    note("Configuration: {0}".format(name))
+    order = int(verifying_key.curve.order)
+
+    # the encode_integer doesn't support negative numbers, would be nice
+    # to generate them too, but we have coverage for remove_integer()
+    # verifying that it doesn't accept them, so meh.
+    # Test all numbers around the ones that can show up (around order)
+    # way smaller and slightly bigger
+    r = draw(
+        st.integers(min_value=0, max_value=order << 4)
+        | st.integers(min_value=order >> 2, max_value=order + 1)
+    )
+    s = draw(
+        st.integers(min_value=0, max_value=order << 4)
+        | st.integers(min_value=order >> 2, max_value=order + 1)
+    )
+
+    sig = encode_sequence(encode_integer(r), encode_integer(s))
+
+    return verifying_key, sig
+
+
+@settings(**slow_params)
+@given(st_random_der_ecdsa_sig_value())
+def test_random_der_ecdsa_sig_value(params):
+    """
+    Check if random values encoded in ECDSA-Sig-Value structure are rejected
+    as signature.
+    """
+    verifying_key, sig = params
+
+    with pytest.raises(BadSignatureError):
+        verifying_key.verify(sig, example_data, sigdecode=sigdecode_der)
+
+
+def st_der_integer(*args, **kwargs):
+    """
+    Hypothesis strategy that returns a random positive integer as DER
+    INTEGER.
+    Parameters are passed to hypothesis.strategy.integer.
+    """
+    if "min_value" not in kwargs:  # pragma: no branch
+        kwargs["min_value"] = 0
+    return st.builds(encode_integer, st.integers(*args, **kwargs))
+
+
+@st.composite
+def st_der_bit_string(draw, *args, **kwargs):
+    """
+    Hypothesis strategy that returns a random DER BIT STRING.
+    Parameters are passed to hypothesis.strategy.binary.
+    """
+    data = draw(st.binary(*args, **kwargs))
+    if data:
+        unused = draw(st.integers(min_value=0, max_value=7))
+        data = bytearray(data)
+        data[-1] &= -(2**unused)
+        data = bytes(data)
+    else:
+        unused = 0
+    return encode_bitstring(data, unused)
+
+
+def st_der_octet_string(*args, **kwargs):
+    """
+    Hypothesis strategy that returns a random DER OCTET STRING object.
+    Parameters are passed to hypothesis.strategy.binary
+    """
+    return st.builds(encode_octet_string, st.binary(*args, **kwargs))
+
+
+def st_der_null():
+    """
+    Hypothesis strategy that returns DER NULL object.
+    """
+    return st.just(b"\x05\x00")
+
+
+@st.composite
+def st_der_oid(draw):
+    """
+    Hypothesis strategy that returns DER OBJECT IDENTIFIER objects.
+    """
+    first = draw(st.integers(min_value=0, max_value=2))
+    if first < 2:
+        second = draw(st.integers(min_value=0, max_value=39))
+    else:
+        second = draw(st.integers(min_value=0, max_value=2**512))
+    rest = draw(
+        st.lists(st.integers(min_value=0, max_value=2**512), max_size=50)
+    )
+    return encode_oid(first, second, *rest)
+
+
+def st_der():
+    """
+    Hypothesis strategy that returns random DER structures.
+
+    A valid DER structure is any primitive object, an octet encoding
+    of a valid DER structure, sequence of valid DER objects or a constructed
+    encoding of any of the above.
+    """
+    return st.recursive(
+        st.just(b"")
+        | st_der_integer(max_value=2**4096)
+        | st_der_bit_string(max_size=1024**2)
+        | st_der_octet_string(max_size=1024**2)
+        | st_der_null()
+        | st_der_oid(),
+        lambda children: st.builds(
+            lambda x: encode_octet_string(x), st.one_of(children)
+        )
+        | st.builds(lambda x: encode_bitstring(x, 0), st.one_of(children))
+        | st.builds(
+            lambda x: encode_sequence(*x), st.lists(children, max_size=200)
+        )
+        | st.builds(
+            lambda tag, x: encode_constructed(tag, x),
+            st.integers(min_value=0, max_value=0x3F),
+            st.one_of(children),
+        ),
+        max_leaves=40,
+    )
+
+
+@settings(**params)
+@given(st.sampled_from(keys_and_sigs), st_der())
+def test_random_der_as_signature(params, der):
+    """Check if random DER structures are rejected as signature"""
+    name, verifying_key, _ = params
+
+    with pytest.raises(BadSignatureError):
+        verifying_key.verify(der, example_data, sigdecode=sigdecode_der)
+
+
+@settings(**params)
+@given(st.sampled_from(keys_and_sigs), st.binary(max_size=1024**2))
+@example(
+    keys_and_sigs[0], encode_sequence(encode_integer(0), encode_integer(0))
+)
+@example(
+    keys_and_sigs[0],
+    encode_sequence(encode_integer(1), encode_integer(1)) + b"\x00",
+)
+@example(keys_and_sigs[0], encode_sequence(*[encode_integer(1)] * 3))
+def test_random_bytes_as_signature(params, der):
+    """Check if random bytes are rejected as signature"""
+    name, verifying_key, _ = params
+
+    with pytest.raises(BadSignatureError):
+        verifying_key.verify(der, example_data, sigdecode=sigdecode_der)
+
+
+keys_and_string_sigs = [
+    (
+        name,
+        verifying_key,
+        sigencode_string(
+            *sigdecode_der(sig, verifying_key.curve.order),
+            order=verifying_key.curve.order
+        ),
+    )
+    for name, verifying_key, sig in keys_and_sigs
+    if not isinstance(verifying_key.curve.curve, CurveEdTw)
+]
+"""
+Name of the curve+hash combination, VerifyingKey and signature as a
+byte string.
+"""
+
+
+keys_and_string_sigs += [
+    (
+        name,
+        verifying_key,
+        sig,
+    )
+    for name, verifying_key, sig in keys_and_sigs
+    if isinstance(verifying_key.curve.curve, CurveEdTw)
+]
+
+
+@settings(**params)
+@given(st_fuzzed_sig(keys_and_string_sigs))
+def test_fuzzed_string_signatures(params):
+    verifying_key, sig = params
+
+    with pytest.raises(BadSignatureError):
+        verifying_key.verify(sig, example_data, sigdecode=sigdecode_string)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_numbertheory.py b/myenv/lib/python3.9/site-packages/ecdsa/test_numbertheory.py
new file mode 100644
index 0000000..8bc787f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_numbertheory.py
@@ -0,0 +1,433 @@
+import operator
+from functools import reduce
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+import hypothesis.strategies as st
+import pytest
+from hypothesis import given, settings, example
+
+try:
+    from hypothesis import HealthCheck
+
+    HC_PRESENT = True
+except ImportError:  # pragma: no cover
+    HC_PRESENT = False
+from .numbertheory import (
+    SquareRootError,
+    JacobiError,
+    factorization,
+    gcd,
+    lcm,
+    jacobi,
+    inverse_mod,
+    is_prime,
+    next_prime,
+    smallprimes,
+    square_root_mod_prime,
+)
+
+
+BIGPRIMES = (
+    999671,
+    999683,
+    999721,
+    999727,
+    999749,
+    999763,
+    999769,
+    999773,
+    999809,
+    999853,
+    999863,
+    999883,
+    999907,
+    999917,
+    999931,
+    999953,
+    999959,
+    999961,
+    999979,
+    999983,
+)
+
+
+@pytest.mark.parametrize(
+    "prime, next_p", [(p, q) for p, q in zip(BIGPRIMES[:-1], BIGPRIMES[1:])]
+)
+def test_next_prime(prime, next_p):
+    assert next_prime(prime) == next_p
+
+
+@pytest.mark.parametrize("val", [-1, 0, 1])
+def test_next_prime_with_nums_less_2(val):
+    assert next_prime(val) == 2
+
+
+@pytest.mark.parametrize("prime", smallprimes)
+def test_square_root_mod_prime_for_small_primes(prime):
+    squares = set()
+    for num in range(0, 1 + prime // 2):
+        sq = num * num % prime
+        squares.add(sq)
+        root = square_root_mod_prime(sq, prime)
+        # tested for real with TestNumbertheory.test_square_root_mod_prime
+        assert root * root % prime == sq
+
+    for nonsquare in range(0, prime):
+        if nonsquare in squares:
+            continue
+        with pytest.raises(SquareRootError):
+            square_root_mod_prime(nonsquare, prime)
+
+
+def test_square_root_mod_prime_for_2():
+    a = square_root_mod_prime(1, 2)
+    assert a == 1
+
+
+def test_square_root_mod_prime_for_small_prime():
+    root = square_root_mod_prime(98**2 % 101, 101)
+    assert root * root % 101 == 9
+
+
+def test_square_root_mod_prime_for_p_congruent_5():
+    p = 13
+    assert p % 8 == 5
+
+    root = square_root_mod_prime(3, p)
+    assert root * root % p == 3
+
+
+def test_square_root_mod_prime_for_p_congruent_5_large_d():
+    p = 29
+    assert p % 8 == 5
+
+    root = square_root_mod_prime(4, p)
+    assert root * root % p == 4
+
+
+class TestSquareRootModPrime(unittest.TestCase):
+    def test_power_of_2_p(self):
+        with self.assertRaises(JacobiError):
+            square_root_mod_prime(12, 32)
+
+    def test_no_square(self):
+        with self.assertRaises(SquareRootError) as e:
+            square_root_mod_prime(12, 31)
+
+        self.assertIn("no square root", str(e.exception))
+
+    def test_non_prime(self):
+        with self.assertRaises(SquareRootError) as e:
+            square_root_mod_prime(12, 33)
+
+        self.assertIn("p is not prime", str(e.exception))
+
+    def test_non_prime_with_negative(self):
+        with self.assertRaises(SquareRootError) as e:
+            square_root_mod_prime(697 - 1, 697)
+
+        self.assertIn("p is not prime", str(e.exception))
+
+
+@st.composite
+def st_two_nums_rel_prime(draw):
+    # 521-bit is the biggest curve we operate on, use 1024 for a bit
+    # of breathing space
+    mod = draw(st.integers(min_value=2, max_value=2**1024))
+    num = draw(
+        st.integers(min_value=1, max_value=mod - 1).filter(
+            lambda x: gcd(x, mod) == 1
+        )
+    )
+    return num, mod
+
+
+@st.composite
+def st_primes(draw, *args, **kwargs):
+    if "min_value" not in kwargs:  # pragma: no branch
+        kwargs["min_value"] = 1
+    prime = draw(
+        st.sampled_from(smallprimes)
+        | st.integers(*args, **kwargs).filter(is_prime)
+    )
+    return prime
+
+
+@st.composite
+def st_num_square_prime(draw):
+    prime = draw(st_primes(max_value=2**1024))
+    num = draw(st.integers(min_value=0, max_value=1 + prime // 2))
+    sq = num * num % prime
+    return sq, prime
+
+
+@st.composite
+def st_comp_with_com_fac(draw):
+    """
+    Strategy that returns lists of numbers, all having a common factor.
+    """
+    primes = draw(
+        st.lists(st_primes(max_value=2**512), min_size=1, max_size=10)
+    )
+    # select random prime(s) that will make the common factor of composites
+    com_fac_primes = draw(
+        st.lists(st.sampled_from(primes), min_size=1, max_size=20)
+    )
+    com_fac = reduce(operator.mul, com_fac_primes, 1)
+
+    # select at most 20 lists (returned numbers),
+    # each having at most 30 primes (factors) including none (then the number
+    # will be 1)
+    comp_primes = draw(
+        st.integers(min_value=1, max_value=20).flatmap(
+            lambda n: st.lists(
+                st.lists(st.sampled_from(primes), max_size=30),
+                min_size=1,
+                max_size=n,
+            )
+        )
+    )
+
+    return [reduce(operator.mul, nums, 1) * com_fac for nums in comp_primes]
+
+
+@st.composite
+def st_comp_no_com_fac(draw):
+    """
+    Strategy that returns lists of numbers that don't have a common factor.
+    """
+    primes = draw(
+        st.lists(
+            st_primes(max_value=2**512), min_size=2, max_size=10, unique=True
+        )
+    )
+    # first select the primes that will create the uncommon factor
+    # between returned numbers
+    uncom_fac_primes = draw(
+        st.lists(
+            st.sampled_from(primes),
+            min_size=1,
+            max_size=len(primes) - 1,
+            unique=True,
+        )
+    )
+    uncom_fac = reduce(operator.mul, uncom_fac_primes, 1)
+
+    # then build composites from leftover primes
+    leftover_primes = [i for i in primes if i not in uncom_fac_primes]
+
+    assert leftover_primes
+    assert uncom_fac_primes
+
+    # select at most 20 lists, each having at most 30 primes
+    # selected from the leftover_primes list
+    number_primes = draw(
+        st.integers(min_value=1, max_value=20).flatmap(
+            lambda n: st.lists(
+                st.lists(st.sampled_from(leftover_primes), max_size=30),
+                min_size=1,
+                max_size=n,
+            )
+        )
+    )
+
+    numbers = [reduce(operator.mul, nums, 1) for nums in number_primes]
+
+    insert_at = draw(st.integers(min_value=0, max_value=len(numbers)))
+    numbers.insert(insert_at, uncom_fac)
+    return numbers
+
+
+HYP_SETTINGS = {}
+if HC_PRESENT:  # pragma: no branch
+    HYP_SETTINGS["suppress_health_check"] = [
+        HealthCheck.filter_too_much,
+        HealthCheck.too_slow,
+    ]
+    # the factorization() sometimes takes a long time to finish
+    HYP_SETTINGS["deadline"] = 5000
+
+
+HYP_SLOW_SETTINGS = dict(HYP_SETTINGS)
+HYP_SLOW_SETTINGS["max_examples"] = 10
+
+
+class TestIsPrime(unittest.TestCase):
+    def test_very_small_prime(self):
+        assert is_prime(23)
+
+    def test_very_small_composite(self):
+        assert not is_prime(22)
+
+    def test_small_prime(self):
+        assert is_prime(123456791)
+
+    def test_special_composite(self):
+        assert not is_prime(10261)
+
+    def test_medium_prime_1(self):
+        # nextPrime[2^256]
+        assert is_prime(2**256 + 0x129)
+
+    def test_medium_prime_2(self):
+        # nextPrime(2^256+0x129)
+        assert is_prime(2**256 + 0x12D)
+
+    def test_medium_trivial_composite(self):
+        assert not is_prime(2**256 + 0x130)
+
+    def test_medium_non_trivial_composite(self):
+        assert not is_prime(2**256 + 0x12F)
+
+    def test_large_prime(self):
+        # nextPrime[2^2048]
+        assert is_prime(2**2048 + 0x3D5)
+
+
+class TestNumbertheory(unittest.TestCase):
+    def test_gcd(self):
+        assert gcd(3 * 5 * 7, 3 * 5 * 11, 3 * 5 * 13) == 3 * 5
+        assert gcd([3 * 5 * 7, 3 * 5 * 11, 3 * 5 * 13]) == 3 * 5
+        assert gcd(3) == 3
+
+    @unittest.skipUnless(
+        HC_PRESENT,
+        "Hypothesis 2.0.0 can't be made tolerant of hard to "
+        "meet requirements (like `is_prime()`), the test "
+        "case times-out on it",
+    )
+    @settings(**HYP_SLOW_SETTINGS)
+    @given(st_comp_with_com_fac())
+    def test_gcd_with_com_factor(self, numbers):
+        n = gcd(numbers)
+        assert 1 in numbers or n != 1
+        for i in numbers:
+            assert i % n == 0
+
+    @unittest.skipUnless(
+        HC_PRESENT,
+        "Hypothesis 2.0.0 can't be made tolerant of hard to "
+        "meet requirements (like `is_prime()`), the test "
+        "case times-out on it",
+    )
+    @settings(**HYP_SLOW_SETTINGS)
+    @given(st_comp_no_com_fac())
+    def test_gcd_with_uncom_factor(self, numbers):
+        n = gcd(numbers)
+        assert n == 1
+
+    @given(
+        st.lists(
+            st.integers(min_value=1, max_value=2**8192),
+            min_size=1,
+            max_size=20,
+        )
+    )
+    def test_gcd_with_random_numbers(self, numbers):
+        n = gcd(numbers)
+        for i in numbers:
+            # check that at least it's a divider
+            assert i % n == 0
+
+    def test_lcm(self):
+        assert lcm(3, 5 * 3, 7 * 3) == 3 * 5 * 7
+        assert lcm([3, 5 * 3, 7 * 3]) == 3 * 5 * 7
+        assert lcm(3) == 3
+
+    @given(
+        st.lists(
+            st.integers(min_value=1, max_value=2**8192),
+            min_size=1,
+            max_size=20,
+        )
+    )
+    def test_lcm_with_random_numbers(self, numbers):
+        n = lcm(numbers)
+        for i in numbers:
+            assert n % i == 0
+
+    @unittest.skipUnless(
+        HC_PRESENT,
+        "Hypothesis 2.0.0 can't be made tolerant of hard to "
+        "meet requirements (like `is_prime()`), the test "
+        "case times-out on it",
+    )
+    @settings(**HYP_SETTINGS)
+    @given(st_num_square_prime())
+    def test_square_root_mod_prime(self, vals):
+        square, prime = vals
+
+        calc = square_root_mod_prime(square, prime)
+        assert calc * calc % prime == square
+
+    @settings(**HYP_SETTINGS)
+    @given(st.integers(min_value=1, max_value=10**12))
+    @example(265399 * 1526929)
+    @example(373297**2 * 553991)
+    def test_factorization(self, num):
+        factors = factorization(num)
+        mult = 1
+        for i in factors:
+            mult *= i[0] ** i[1]
+        assert mult == num
+
+    def test_factorisation_smallprimes(self):
+        exp = 101 * 103
+        assert 101 in smallprimes
+        assert 103 in smallprimes
+        factors = factorization(exp)
+        mult = 1
+        for i in factors:
+            mult *= i[0] ** i[1]
+        assert mult == exp
+
+    def test_factorisation_not_smallprimes(self):
+        exp = 1231 * 1237
+        assert 1231 not in smallprimes
+        assert 1237 not in smallprimes
+        factors = factorization(exp)
+        mult = 1
+        for i in factors:
+            mult *= i[0] ** i[1]
+        assert mult == exp
+
+    def test_jacobi_with_zero(self):
+        assert jacobi(0, 3) == 0
+
+    def test_jacobi_with_one(self):
+        assert jacobi(1, 3) == 1
+
+    @settings(**HYP_SETTINGS)
+    @given(st.integers(min_value=3, max_value=1000).filter(lambda x: x % 2))
+    def test_jacobi(self, mod):
+        if is_prime(mod):
+            squares = set()
+            for root in range(1, mod):
+                assert jacobi(root * root, mod) == 1
+                squares.add(root * root % mod)
+            for i in range(1, mod):
+                if i not in squares:
+                    assert jacobi(i, mod) == -1
+        else:
+            factors = factorization(mod)
+            for a in range(1, mod):
+                c = 1
+                for i in factors:
+                    c *= jacobi(a, i[0]) ** i[1]
+                assert c == jacobi(a, mod)
+
+    @given(st_two_nums_rel_prime())
+    def test_inverse_mod(self, nums):
+        num, mod = nums
+
+        inv = inverse_mod(num, mod)
+
+        assert 0 < inv < mod
+        assert num * inv % mod == 1
+
+    def test_inverse_mod_with_zero(self):
+        assert 0 == inverse_mod(0, 11)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_pyecdsa.py b/myenv/lib/python3.9/site-packages/ecdsa/test_pyecdsa.py
new file mode 100644
index 0000000..d61f508
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_pyecdsa.py
@@ -0,0 +1,2267 @@
+from __future__ import with_statement, division
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+import os
+import sys
+import shutil
+import subprocess
+import pytest
+from binascii import hexlify, unhexlify
+from hashlib import sha1, sha256, sha384, sha512
+import hashlib
+from functools import partial
+
+from hypothesis import given
+import hypothesis.strategies as st
+
+from six import b, print_, binary_type
+from .keys import SigningKey, VerifyingKey
+from .keys import BadSignatureError, MalformedPointError, BadDigestError
+from . import util
+from .util import sigencode_der, sigencode_strings
+from .util import sigdecode_der, sigdecode_strings
+from .util import number_to_string, encoded_oid_ecPublicKey, MalformedSignature
+from .curves import Curve, UnknownCurveError
+from .curves import (
+    SECP112r1,
+    SECP112r2,
+    SECP128r1,
+    SECP160r1,
+    NIST192p,
+    NIST224p,
+    NIST256p,
+    NIST384p,
+    NIST521p,
+    SECP256k1,
+    BRAINPOOLP160r1,
+    BRAINPOOLP192r1,
+    BRAINPOOLP224r1,
+    BRAINPOOLP256r1,
+    BRAINPOOLP320r1,
+    BRAINPOOLP384r1,
+    BRAINPOOLP512r1,
+    Ed25519,
+    Ed448,
+    curves,
+)
+from .ecdsa import (
+    curve_brainpoolp224r1,
+    curve_brainpoolp256r1,
+    curve_brainpoolp384r1,
+    curve_brainpoolp512r1,
+)
+from .ellipticcurve import Point
+from . import der
+from . import rfc6979
+from . import ecdsa
+
+
+class SubprocessError(Exception):
+    pass
+
+
+def run_openssl(cmd):
+    OPENSSL = "openssl"
+    p = subprocess.Popen(
+        [OPENSSL] + cmd.split(),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+    )
+    stdout, ignored = p.communicate()
+    if p.returncode != 0:
+        raise SubprocessError(
+            "cmd '%s %s' failed: rc=%s, stdout/err was %s"
+            % (OPENSSL, cmd, p.returncode, stdout)
+        )
+    return stdout.decode()
+
+
+class ECDSA(unittest.TestCase):
+    def test_basic(self):
+        priv = SigningKey.generate()
+        pub = priv.get_verifying_key()
+
+        data = b("blahblah")
+        sig = priv.sign(data)
+
+        self.assertTrue(pub.verify(sig, data))
+        self.assertRaises(BadSignatureError, pub.verify, sig, data + b("bad"))
+
+        pub2 = VerifyingKey.from_string(pub.to_string())
+        self.assertTrue(pub2.verify(sig, data))
+
+    def test_deterministic(self):
+        data = b("blahblah")
+        secexp = int("9d0219792467d7d37b4d43298a7d0c05", 16)
+
+        priv = SigningKey.from_secret_exponent(secexp, SECP256k1, sha256)
+        pub = priv.get_verifying_key()
+
+        k = rfc6979.generate_k(
+            SECP256k1.generator.order(), secexp, sha256, sha256(data).digest()
+        )
+
+        sig1 = priv.sign(data, k=k)
+        self.assertTrue(pub.verify(sig1, data))
+
+        sig2 = priv.sign(data, k=k)
+        self.assertTrue(pub.verify(sig2, data))
+
+        sig3 = priv.sign_deterministic(data, sha256)
+        self.assertTrue(pub.verify(sig3, data))
+
+        self.assertEqual(sig1, sig2)
+        self.assertEqual(sig1, sig3)
+
+    def test_bad_usage(self):
+        # sk=SigningKey() is wrong
+        self.assertRaises(TypeError, SigningKey)
+        self.assertRaises(TypeError, VerifyingKey)
+
+    def test_lengths(self):
+        default = NIST192p
+        priv = SigningKey.generate()
+        pub = priv.get_verifying_key()
+        self.assertEqual(len(pub.to_string()), default.verifying_key_length)
+        sig = priv.sign(b("data"))
+        self.assertEqual(len(sig), default.signature_length)
+        for curve in (
+            NIST192p,
+            NIST224p,
+            NIST256p,
+            NIST384p,
+            NIST521p,
+            BRAINPOOLP160r1,
+            BRAINPOOLP192r1,
+            BRAINPOOLP224r1,
+            BRAINPOOLP256r1,
+            BRAINPOOLP320r1,
+            BRAINPOOLP384r1,
+            BRAINPOOLP512r1,
+        ):
+            priv = SigningKey.generate(curve=curve)
+            pub1 = priv.get_verifying_key()
+            pub2 = VerifyingKey.from_string(pub1.to_string(), curve)
+            self.assertEqual(pub1.to_string(), pub2.to_string())
+            self.assertEqual(len(pub1.to_string()), curve.verifying_key_length)
+            sig = priv.sign(b("data"))
+            self.assertEqual(len(sig), curve.signature_length)
+
+    def test_serialize(self):
+        seed = b("secret")
+        curve = NIST192p
+        secexp1 = util.randrange_from_seed__trytryagain(seed, curve.order)
+        secexp2 = util.randrange_from_seed__trytryagain(seed, curve.order)
+        self.assertEqual(secexp1, secexp2)
+        priv1 = SigningKey.from_secret_exponent(secexp1, curve)
+        priv2 = SigningKey.from_secret_exponent(secexp2, curve)
+        self.assertEqual(
+            hexlify(priv1.to_string()), hexlify(priv2.to_string())
+        )
+        self.assertEqual(priv1.to_pem(), priv2.to_pem())
+        pub1 = priv1.get_verifying_key()
+        pub2 = priv2.get_verifying_key()
+        data = b("data")
+        sig1 = priv1.sign(data)
+        sig2 = priv2.sign(data)
+        self.assertTrue(pub1.verify(sig1, data))
+        self.assertTrue(pub2.verify(sig1, data))
+        self.assertTrue(pub1.verify(sig2, data))
+        self.assertTrue(pub2.verify(sig2, data))
+        self.assertEqual(hexlify(pub1.to_string()), hexlify(pub2.to_string()))
+
+    def test_nonrandom(self):
+        s = b("all the entropy in the entire world, compressed into one line")
+
+        def not_much_entropy(numbytes):
+            return s[:numbytes]
+
+        # we control the entropy source, these two keys should be identical:
+        priv1 = SigningKey.generate(entropy=not_much_entropy)
+        priv2 = SigningKey.generate(entropy=not_much_entropy)
+        self.assertEqual(
+            hexlify(priv1.get_verifying_key().to_string()),
+            hexlify(priv2.get_verifying_key().to_string()),
+        )
+        # likewise, signatures should be identical. Obviously you'd never
+        # want to do this with keys you care about, because the secrecy of
+        # the private key depends upon using different random numbers for
+        # each signature
+        sig1 = priv1.sign(b("data"), entropy=not_much_entropy)
+        sig2 = priv2.sign(b("data"), entropy=not_much_entropy)
+        self.assertEqual(hexlify(sig1), hexlify(sig2))
+
+    def assertTruePrivkeysEqual(self, priv1, priv2):
+        self.assertEqual(
+            priv1.privkey.secret_multiplier, priv2.privkey.secret_multiplier
+        )
+        self.assertEqual(
+            priv1.privkey.public_key.generator,
+            priv2.privkey.public_key.generator,
+        )
+
+    def test_privkey_creation(self):
+        s = b("all the entropy in the entire world, compressed into one line")
+
+        def not_much_entropy(numbytes):
+            return s[:numbytes]
+
+        priv1 = SigningKey.generate()
+        self.assertEqual(priv1.baselen, NIST192p.baselen)
+
+        priv1 = SigningKey.generate(curve=NIST224p)
+        self.assertEqual(priv1.baselen, NIST224p.baselen)
+
+        priv1 = SigningKey.generate(entropy=not_much_entropy)
+        self.assertEqual(priv1.baselen, NIST192p.baselen)
+        priv2 = SigningKey.generate(entropy=not_much_entropy)
+        self.assertEqual(priv2.baselen, NIST192p.baselen)
+        self.assertTruePrivkeysEqual(priv1, priv2)
+
+        priv1 = SigningKey.from_secret_exponent(secexp=3)
+        self.assertEqual(priv1.baselen, NIST192p.baselen)
+        priv2 = SigningKey.from_secret_exponent(secexp=3)
+        self.assertTruePrivkeysEqual(priv1, priv2)
+
+        priv1 = SigningKey.from_secret_exponent(secexp=4, curve=NIST224p)
+        self.assertEqual(priv1.baselen, NIST224p.baselen)
+
+    def test_privkey_strings(self):
+        priv1 = SigningKey.generate()
+        s1 = priv1.to_string()
+        self.assertEqual(type(s1), binary_type)
+        self.assertEqual(len(s1), NIST192p.baselen)
+        priv2 = SigningKey.from_string(s1)
+        self.assertTruePrivkeysEqual(priv1, priv2)
+
+        s1 = priv1.to_pem()
+        self.assertEqual(type(s1), binary_type)
+        self.assertTrue(s1.startswith(b("-----BEGIN EC PRIVATE KEY-----")))
+        self.assertTrue(s1.strip().endswith(b("-----END EC PRIVATE KEY-----")))
+        priv2 = SigningKey.from_pem(s1)
+        self.assertTruePrivkeysEqual(priv1, priv2)
+
+        s1 = priv1.to_der()
+        self.assertEqual(type(s1), binary_type)
+        priv2 = SigningKey.from_der(s1)
+        self.assertTruePrivkeysEqual(priv1, priv2)
+
+        priv1 = SigningKey.generate(curve=NIST256p)
+        s1 = priv1.to_pem()
+        self.assertEqual(type(s1), binary_type)
+        self.assertTrue(s1.startswith(b("-----BEGIN EC PRIVATE KEY-----")))
+        self.assertTrue(s1.strip().endswith(b("-----END EC PRIVATE KEY-----")))
+        priv2 = SigningKey.from_pem(s1)
+        self.assertTruePrivkeysEqual(priv1, priv2)
+
+        s1 = priv1.to_der()
+        self.assertEqual(type(s1), binary_type)
+        priv2 = SigningKey.from_der(s1)
+        self.assertTruePrivkeysEqual(priv1, priv2)
+
+    def test_privkey_strings_brainpool(self):
+        priv1 = SigningKey.generate(curve=BRAINPOOLP512r1)
+        s1 = priv1.to_pem()
+        self.assertEqual(type(s1), binary_type)
+        self.assertTrue(s1.startswith(b("-----BEGIN EC PRIVATE KEY-----")))
+        self.assertTrue(s1.strip().endswith(b("-----END EC PRIVATE KEY-----")))
+        priv2 = SigningKey.from_pem(s1)
+        self.assertTruePrivkeysEqual(priv1, priv2)
+
+        s1 = priv1.to_der()
+        self.assertEqual(type(s1), binary_type)
+        priv2 = SigningKey.from_der(s1)
+        self.assertTruePrivkeysEqual(priv1, priv2)
+
+    def assertTruePubkeysEqual(self, pub1, pub2):
+        self.assertEqual(pub1.pubkey.point, pub2.pubkey.point)
+        self.assertEqual(pub1.pubkey.generator, pub2.pubkey.generator)
+        self.assertEqual(pub1.curve, pub2.curve)
+
+    def test_pubkey_strings(self):
+        priv1 = SigningKey.generate()
+        pub1 = priv1.get_verifying_key()
+        s1 = pub1.to_string()
+        self.assertEqual(type(s1), binary_type)
+        self.assertEqual(len(s1), NIST192p.verifying_key_length)
+        pub2 = VerifyingKey.from_string(s1)
+        self.assertTruePubkeysEqual(pub1, pub2)
+
+        priv1 = SigningKey.generate(curve=NIST256p)
+        pub1 = priv1.get_verifying_key()
+        s1 = pub1.to_string()
+        self.assertEqual(type(s1), binary_type)
+        self.assertEqual(len(s1), NIST256p.verifying_key_length)
+        pub2 = VerifyingKey.from_string(s1, curve=NIST256p)
+        self.assertTruePubkeysEqual(pub1, pub2)
+
+        pub1_der = pub1.to_der()
+        self.assertEqual(type(pub1_der), binary_type)
+        pub2 = VerifyingKey.from_der(pub1_der)
+        self.assertTruePubkeysEqual(pub1, pub2)
+
+        self.assertRaises(
+            der.UnexpectedDER, VerifyingKey.from_der, pub1_der + b("junk")
+        )
+        badpub = VerifyingKey.from_der(pub1_der)
+
+        class FakeGenerator:
+            def order(self):
+                return 123456789
+
+        class FakeCurveFp:
+            def p(self):
+                return int(
+                    "6525534529039240705020950546962731340"
+                    "4541085228058844382513856749047873406763"
+                )
+
+        badcurve = Curve(
+            "unknown", FakeCurveFp(), FakeGenerator(), (1, 2, 3, 4, 5, 6), None
+        )
+        badpub.curve = badcurve
+        badder = badpub.to_der()
+        self.assertRaises(UnknownCurveError, VerifyingKey.from_der, badder)
+
+        pem = pub1.to_pem()
+        self.assertEqual(type(pem), binary_type)
+        self.assertTrue(pem.startswith(b("-----BEGIN PUBLIC KEY-----")), pem)
+        self.assertTrue(
+            pem.strip().endswith(b("-----END PUBLIC KEY-----")), pem
+        )
+        pub2 = VerifyingKey.from_pem(pem)
+        self.assertTruePubkeysEqual(pub1, pub2)
+
+    def test_pubkey_strings_brainpool(self):
+        priv1 = SigningKey.generate(curve=BRAINPOOLP512r1)
+        pub1 = priv1.get_verifying_key()
+        s1 = pub1.to_string()
+        self.assertEqual(type(s1), binary_type)
+        self.assertEqual(len(s1), BRAINPOOLP512r1.verifying_key_length)
+        pub2 = VerifyingKey.from_string(s1, curve=BRAINPOOLP512r1)
+        self.assertTruePubkeysEqual(pub1, pub2)
+
+        pub1_der = pub1.to_der()
+        self.assertEqual(type(pub1_der), binary_type)
+        pub2 = VerifyingKey.from_der(pub1_der)
+        self.assertTruePubkeysEqual(pub1, pub2)
+
+    def test_vk_to_der_with_invalid_point_encoding(self):
+        sk = SigningKey.generate()
+        vk = sk.verifying_key
+
+        with self.assertRaises(ValueError):
+            vk.to_der("raw")
+
+    def test_sk_to_der_with_invalid_point_encoding(self):
+        sk = SigningKey.generate()
+
+        with self.assertRaises(ValueError):
+            sk.to_der("raw")
+
+    def test_vk_from_der_garbage_after_curve_oid(self):
+        type_oid_der = encoded_oid_ecPublicKey
+        curve_oid_der = der.encode_oid(*(1, 2, 840, 10045, 3, 1, 1)) + b(
+            "garbage"
+        )
+        enc_type_der = der.encode_sequence(type_oid_der, curve_oid_der)
+        point_der = der.encode_bitstring(b"\x00\xff", None)
+        to_decode = der.encode_sequence(enc_type_der, point_der)
+
+        with self.assertRaises(der.UnexpectedDER):
+            VerifyingKey.from_der(to_decode)
+
+    def test_vk_from_der_invalid_key_type(self):
+        type_oid_der = der.encode_oid(*(1, 2, 3))
+        curve_oid_der = der.encode_oid(*(1, 2, 840, 10045, 3, 1, 1))
+        enc_type_der = der.encode_sequence(type_oid_der, curve_oid_der)
+        point_der = der.encode_bitstring(b"\x00\xff", None)
+        to_decode = der.encode_sequence(enc_type_der, point_der)
+
+        with self.assertRaises(der.UnexpectedDER):
+            VerifyingKey.from_der(to_decode)
+
+    def test_vk_from_der_garbage_after_point_string(self):
+        type_oid_der = encoded_oid_ecPublicKey
+        curve_oid_der = der.encode_oid(*(1, 2, 840, 10045, 3, 1, 1))
+        enc_type_der = der.encode_sequence(type_oid_der, curve_oid_der)
+        point_der = der.encode_bitstring(b"\x00\xff", None) + b("garbage")
+        to_decode = der.encode_sequence(enc_type_der, point_der)
+
+        with self.assertRaises(der.UnexpectedDER):
+            VerifyingKey.from_der(to_decode)
+
+    def test_vk_from_der_invalid_bitstring(self):
+        type_oid_der = encoded_oid_ecPublicKey
+        curve_oid_der = der.encode_oid(*(1, 2, 840, 10045, 3, 1, 1))
+        enc_type_der = der.encode_sequence(type_oid_der, curve_oid_der)
+        point_der = der.encode_bitstring(b"\x08\xff", None)
+        to_decode = der.encode_sequence(enc_type_der, point_der)
+
+        with self.assertRaises(der.UnexpectedDER):
+            VerifyingKey.from_der(to_decode)
+
+    def test_vk_from_der_with_invalid_length_of_encoding(self):
+        type_oid_der = encoded_oid_ecPublicKey
+        curve_oid_der = der.encode_oid(*(1, 2, 840, 10045, 3, 1, 1))
+        enc_type_der = der.encode_sequence(type_oid_der, curve_oid_der)
+        point_der = der.encode_bitstring(b"\xff" * 64, 0)
+        to_decode = der.encode_sequence(enc_type_der, point_der)
+
+        with self.assertRaises(MalformedPointError):
+            VerifyingKey.from_der(to_decode)
+
+    def test_vk_from_der_with_raw_encoding(self):
+        type_oid_der = encoded_oid_ecPublicKey
+        curve_oid_der = der.encode_oid(*(1, 2, 840, 10045, 3, 1, 1))
+        enc_type_der = der.encode_sequence(type_oid_der, curve_oid_der)
+        point_der = der.encode_bitstring(b"\xff" * 48, 0)
+        to_decode = der.encode_sequence(enc_type_der, point_der)
+
+        with self.assertRaises(der.UnexpectedDER):
+            VerifyingKey.from_der(to_decode)
+
+    def test_signature_strings(self):
+        priv1 = SigningKey.generate()
+        pub1 = priv1.get_verifying_key()
+        data = b("data")
+
+        sig = priv1.sign(data)
+        self.assertEqual(type(sig), binary_type)
+        self.assertEqual(len(sig), NIST192p.signature_length)
+        self.assertTrue(pub1.verify(sig, data))
+
+        sig = priv1.sign(data, sigencode=sigencode_strings)
+        self.assertEqual(type(sig), tuple)
+        self.assertEqual(len(sig), 2)
+        self.assertEqual(type(sig[0]), binary_type)
+        self.assertEqual(type(sig[1]), binary_type)
+        self.assertEqual(len(sig[0]), NIST192p.baselen)
+        self.assertEqual(len(sig[1]), NIST192p.baselen)
+        self.assertTrue(pub1.verify(sig, data, sigdecode=sigdecode_strings))
+
+        sig_der = priv1.sign(data, sigencode=sigencode_der)
+        self.assertEqual(type(sig_der), binary_type)
+        self.assertTrue(pub1.verify(sig_der, data, sigdecode=sigdecode_der))
+
+    def test_sig_decode_strings_with_invalid_count(self):
+        with self.assertRaises(MalformedSignature):
+            sigdecode_strings([b("one"), b("two"), b("three")], 0xFF)
+
+    def test_sig_decode_strings_with_wrong_r_len(self):
+        with self.assertRaises(MalformedSignature):
+            sigdecode_strings([b("one"), b("two")], 0xFF)
+
+    def test_sig_decode_strings_with_wrong_s_len(self):
+        with self.assertRaises(MalformedSignature):
+            sigdecode_strings([b("\xa0"), b("\xb0\xff")], 0xFF)
+
+    def test_verify_with_too_long_input(self):
+        sk = SigningKey.generate()
+        vk = sk.verifying_key
+
+        with self.assertRaises(BadDigestError):
+            vk.verify_digest(None, b("\x00") * 128)
+
+    def test_sk_from_secret_exponent_with_wrong_sec_exponent(self):
+        with self.assertRaises(MalformedPointError):
+            SigningKey.from_secret_exponent(0)
+
+    def test_sk_from_string_with_wrong_len_string(self):
+        with self.assertRaises(MalformedPointError):
+            SigningKey.from_string(b("\x01"))
+
+    def test_sk_from_der_with_junk_after_sequence(self):
+        ver_der = der.encode_integer(1)
+        to_decode = der.encode_sequence(ver_der) + b("garbage")
+
+        with self.assertRaises(der.UnexpectedDER):
+            SigningKey.from_der(to_decode)
+
+    def test_sk_from_der_with_wrong_version(self):
+        ver_der = der.encode_integer(0)
+        to_decode = der.encode_sequence(ver_der)
+
+        with self.assertRaises(der.UnexpectedDER):
+            SigningKey.from_der(to_decode)
+
+    def test_sk_from_der_invalid_const_tag(self):
+        ver_der = der.encode_integer(1)
+        privkey_der = der.encode_octet_string(b("\x00\xff"))
+        curve_oid_der = der.encode_oid(*(1, 2, 3))
+        const_der = der.encode_constructed(1, curve_oid_der)
+        to_decode = der.encode_sequence(
+            ver_der, privkey_der, const_der, curve_oid_der
+        )
+
+        with self.assertRaises(der.UnexpectedDER):
+            SigningKey.from_der(to_decode)
+
+    def test_sk_from_der_garbage_after_privkey_oid(self):
+        ver_der = der.encode_integer(1)
+        privkey_der = der.encode_octet_string(b("\x00\xff"))
+        curve_oid_der = der.encode_oid(*(1, 2, 3)) + b("garbage")
+        const_der = der.encode_constructed(0, curve_oid_der)
+        to_decode = der.encode_sequence(
+            ver_der, privkey_der, const_der, curve_oid_der
+        )
+
+        with self.assertRaises(der.UnexpectedDER):
+            SigningKey.from_der(to_decode)
+
+    def test_sk_from_der_with_short_privkey(self):
+        ver_der = der.encode_integer(1)
+        privkey_der = der.encode_octet_string(b("\x00\xff"))
+        curve_oid_der = der.encode_oid(*(1, 2, 840, 10045, 3, 1, 1))
+        const_der = der.encode_constructed(0, curve_oid_der)
+        to_decode = der.encode_sequence(
+            ver_der, privkey_der, const_der, curve_oid_der
+        )
+
+        sk = SigningKey.from_der(to_decode)
+        self.assertEqual(sk.privkey.secret_multiplier, 255)
+
+    def test_sk_from_p8_der_with_wrong_version(self):
+        ver_der = der.encode_integer(2)
+        algorithm_der = der.encode_sequence(
+            der.encode_oid(1, 2, 840, 10045, 2, 1),
+            der.encode_oid(1, 2, 840, 10045, 3, 1, 1),
+        )
+        privkey_der = der.encode_octet_string(
+            der.encode_sequence(
+                der.encode_integer(1), der.encode_octet_string(b"\x00\xff")
+            )
+        )
+        to_decode = der.encode_sequence(ver_der, algorithm_der, privkey_der)
+
+        with self.assertRaises(der.UnexpectedDER):
+            SigningKey.from_der(to_decode)
+
+    def test_sk_from_p8_der_with_wrong_algorithm(self):
+        ver_der = der.encode_integer(1)
+        algorithm_der = der.encode_sequence(
+            der.encode_oid(1, 2, 3), der.encode_oid(1, 2, 840, 10045, 3, 1, 1)
+        )
+        privkey_der = der.encode_octet_string(
+            der.encode_sequence(
+                der.encode_integer(1), der.encode_octet_string(b"\x00\xff")
+            )
+        )
+        to_decode = der.encode_sequence(ver_der, algorithm_der, privkey_der)
+
+        with self.assertRaises(der.UnexpectedDER):
+            SigningKey.from_der(to_decode)
+
+    def test_sk_from_p8_der_with_trailing_junk_after_algorithm(self):
+        ver_der = der.encode_integer(1)
+        algorithm_der = der.encode_sequence(
+            der.encode_oid(1, 2, 840, 10045, 2, 1),
+            der.encode_oid(1, 2, 840, 10045, 3, 1, 1),
+            der.encode_octet_string(b"junk"),
+        )
+        privkey_der = der.encode_octet_string(
+            der.encode_sequence(
+                der.encode_integer(1), der.encode_octet_string(b"\x00\xff")
+            )
+        )
+        to_decode = der.encode_sequence(ver_der, algorithm_der, privkey_der)
+
+        with self.assertRaises(der.UnexpectedDER):
+            SigningKey.from_der(to_decode)
+
+    def test_sk_from_p8_der_with_trailing_junk_after_key(self):
+        ver_der = der.encode_integer(1)
+        algorithm_der = der.encode_sequence(
+            der.encode_oid(1, 2, 840, 10045, 2, 1),
+            der.encode_oid(1, 2, 840, 10045, 3, 1, 1),
+        )
+        privkey_der = der.encode_octet_string(
+            der.encode_sequence(
+                der.encode_integer(1), der.encode_octet_string(b"\x00\xff")
+            )
+            + der.encode_integer(999)
+        )
+        to_decode = der.encode_sequence(
+            ver_der,
+            algorithm_der,
+            privkey_der,
+            der.encode_octet_string(b"junk"),
+        )
+
+        with self.assertRaises(der.UnexpectedDER):
+            SigningKey.from_der(to_decode)
+
+    def test_sign_with_too_long_hash(self):
+        sk = SigningKey.from_secret_exponent(12)
+
+        with self.assertRaises(BadDigestError):
+            sk.sign_digest(b("\xff") * 64)
+
+    def test_hashfunc(self):
+        sk = SigningKey.generate(curve=NIST256p, hashfunc=sha256)
+        data = b("security level is 128 bits")
+        sig = sk.sign(data)
+        vk = VerifyingKey.from_string(
+            sk.get_verifying_key().to_string(), curve=NIST256p, hashfunc=sha256
+        )
+        self.assertTrue(vk.verify(sig, data))
+
+        sk2 = SigningKey.generate(curve=NIST256p)
+        sig2 = sk2.sign(data, hashfunc=sha256)
+        vk2 = VerifyingKey.from_string(
+            sk2.get_verifying_key().to_string(),
+            curve=NIST256p,
+            hashfunc=sha256,
+        )
+        self.assertTrue(vk2.verify(sig2, data))
+
+        vk3 = VerifyingKey.from_string(
+            sk.get_verifying_key().to_string(), curve=NIST256p
+        )
+        self.assertTrue(vk3.verify(sig, data, hashfunc=sha256))
+
+    def test_public_key_recovery(self):
+        # Create keys
+        curve = BRAINPOOLP160r1
+
+        sk = SigningKey.generate(curve=curve)
+        vk = sk.get_verifying_key()
+
+        # Sign a message
+        data = b("blahblah")
+        signature = sk.sign(data)
+
+        # Recover verifying keys
+        recovered_vks = VerifyingKey.from_public_key_recovery(
+            signature, data, curve
+        )
+
+        # Test if each pk is valid
+        for recovered_vk in recovered_vks:
+            # Test if recovered vk is valid for the data
+            self.assertTrue(recovered_vk.verify(signature, data))
+
+            # Test if properties are equal
+            self.assertEqual(vk.curve, recovered_vk.curve)
+            self.assertEqual(
+                vk.default_hashfunc, recovered_vk.default_hashfunc
+            )
+
+        # Test if original vk is the list of recovered keys
+        self.assertIn(
+            vk.pubkey.point,
+            [recovered_vk.pubkey.point for recovered_vk in recovered_vks],
+        )
+
+    def test_public_key_recovery_with_custom_hash(self):
+        # Create keys
+        curve = BRAINPOOLP160r1
+
+        sk = SigningKey.generate(curve=curve, hashfunc=sha256)
+        vk = sk.get_verifying_key()
+
+        # Sign a message
+        data = b("blahblah")
+        signature = sk.sign(data)
+
+        # Recover verifying keys
+        recovered_vks = VerifyingKey.from_public_key_recovery(
+            signature, data, curve, hashfunc=sha256, allow_truncate=True
+        )
+
+        # Test if each pk is valid
+        for recovered_vk in recovered_vks:
+            # Test if recovered vk is valid for the data
+            self.assertTrue(recovered_vk.verify(signature, data))
+
+            # Test if properties are equal
+            self.assertEqual(vk.curve, recovered_vk.curve)
+            self.assertEqual(sha256, recovered_vk.default_hashfunc)
+
+        # Test if original vk is the list of recovered keys
+        self.assertIn(
+            vk.pubkey.point,
+            [recovered_vk.pubkey.point for recovered_vk in recovered_vks],
+        )
+
+    def test_encoding(self):
+        sk = SigningKey.from_secret_exponent(123456789)
+        vk = sk.verifying_key
+
+        exp = b(
+            "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+            "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+            "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+        )
+        self.assertEqual(vk.to_string(), exp)
+        self.assertEqual(vk.to_string("raw"), exp)
+        self.assertEqual(vk.to_string("uncompressed"), b("\x04") + exp)
+        self.assertEqual(vk.to_string("compressed"), b("\x02") + exp[:24])
+        self.assertEqual(vk.to_string("hybrid"), b("\x06") + exp)
+
+    def test_decoding(self):
+        sk = SigningKey.from_secret_exponent(123456789)
+        vk = sk.verifying_key
+
+        enc = b(
+            "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+            "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+            "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+        )
+
+        from_raw = VerifyingKey.from_string(enc)
+        self.assertEqual(from_raw.pubkey.point, vk.pubkey.point)
+
+        from_uncompressed = VerifyingKey.from_string(b("\x04") + enc)
+        self.assertEqual(from_uncompressed.pubkey.point, vk.pubkey.point)
+
+        from_compressed = VerifyingKey.from_string(b("\x02") + enc[:24])
+        self.assertEqual(from_compressed.pubkey.point, vk.pubkey.point)
+
+        from_uncompressed = VerifyingKey.from_string(b("\x06") + enc)
+        self.assertEqual(from_uncompressed.pubkey.point, vk.pubkey.point)
+
+    def test_uncompressed_decoding_as_only_alowed(self):
+        enc = b(
+            "\x04"
+            "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+            "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+            "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+        )
+        vk = VerifyingKey.from_string(enc, valid_encodings=("uncompressed",))
+        sk = SigningKey.from_secret_exponent(123456789)
+
+        self.assertEqual(vk, sk.verifying_key)
+
+    def test_raw_decoding_with_blocked_format(self):
+        enc = b(
+            "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+            "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+            "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+        )
+        with self.assertRaises(MalformedPointError) as exp:
+            VerifyingKey.from_string(enc, valid_encodings=("hybrid",))
+
+        self.assertIn("hybrid", str(exp.exception))
+
+    def test_decoding_with_unknown_format(self):
+        with self.assertRaises(ValueError) as e:
+            VerifyingKey.from_string(b"", valid_encodings=("raw", "foobar"))
+
+        self.assertIn("Only uncompressed, compressed", str(e.exception))
+
+    def test_uncompressed_decoding_with_blocked_format(self):
+        enc = b(
+            "\x04"
+            "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+            "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+            "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+        )
+        with self.assertRaises(MalformedPointError) as exp:
+            VerifyingKey.from_string(enc, valid_encodings=("hybrid",))
+
+        self.assertIn("Invalid X9.62 encoding", str(exp.exception))
+
+    def test_hybrid_decoding_with_blocked_format(self):
+        enc = b(
+            "\x06"
+            "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+            "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+            "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+        )
+        with self.assertRaises(MalformedPointError) as exp:
+            VerifyingKey.from_string(enc, valid_encodings=("uncompressed",))
+
+        self.assertIn("Invalid X9.62 encoding", str(exp.exception))
+
+    def test_compressed_decoding_with_blocked_format(self):
+        enc = b(
+            "\x02"
+            "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+            "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+            "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+        )[:25]
+        with self.assertRaises(MalformedPointError) as exp:
+            VerifyingKey.from_string(enc, valid_encodings=("hybrid", "raw"))
+
+        self.assertIn("(hybrid, raw)", str(exp.exception))
+
+    def test_decoding_with_malformed_uncompressed(self):
+        enc = b(
+            "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+            "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+            "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+        )
+
+        with self.assertRaises(MalformedPointError):
+            VerifyingKey.from_string(b("\x02") + enc)
+
+    def test_decoding_with_malformed_compressed(self):
+        enc = b(
+            "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+            "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+            "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+        )
+
+        with self.assertRaises(MalformedPointError):
+            VerifyingKey.from_string(b("\x01") + enc[:24])
+
+    def test_decoding_with_inconsistent_hybrid(self):
+        enc = b(
+            "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+            "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+            "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+        )
+
+        with self.assertRaises(MalformedPointError):
+            VerifyingKey.from_string(b("\x07") + enc)
+
+    def test_decoding_with_point_not_on_curve(self):
+        enc = b(
+            "\x0c\xe0\x1d\xe0d\x1c\x8eS\x8a\xc0\x9eK\xa8x !\xd5\xc2\xc3"
+            "\xfd\xc8\xa0c\xff\xfb\x02\xb9\xc4\x84)\x1a\x0f\x8b\x87\xa4"
+            "z\x8a#\xb5\x97\xecO\xb6\xa0HQ\x89*"
+        )
+
+        with self.assertRaises(MalformedPointError):
+            VerifyingKey.from_string(enc[:47] + b("\x00"))
+
+    def test_decoding_with_point_at_infinity(self):
+        # decoding it is unsupported, as it's not necessary to encode it
+        with self.assertRaises(MalformedPointError):
+            VerifyingKey.from_string(b("\x00"))
+
+    def test_not_lying_on_curve(self):
+        enc = number_to_string(NIST192p.curve.p(), NIST192p.curve.p() + 1)
+
+        with self.assertRaises(MalformedPointError):
+            VerifyingKey.from_string(b("\x02") + enc)
+
+    def test_from_string_with_invalid_curve_too_short_ver_key_len(self):
+        # both verifying_key_length and baselen are calculated internally
+        # by the Curve constructor, but since we depend on them verify
+        # that inconsistent values are detected
+        curve = Curve("test", ecdsa.curve_192, ecdsa.generator_192, (1, 2))
+        curve.verifying_key_length = 16
+        curve.baselen = 32
+
+        with self.assertRaises(MalformedPointError):
+            VerifyingKey.from_string(b("\x00") * 16, curve)
+
+    def test_from_string_with_invalid_curve_too_long_ver_key_len(self):
+        # both verifying_key_length and baselen are calculated internally
+        # by the Curve constructor, but since we depend on them verify
+        # that inconsistent values are detected
+        curve = Curve("test", ecdsa.curve_192, ecdsa.generator_192, (1, 2))
+        curve.verifying_key_length = 16
+        curve.baselen = 16
+
+        with self.assertRaises(MalformedPointError):
+            VerifyingKey.from_string(b("\x00") * 16, curve)
+
+
+@pytest.mark.parametrize(
+    "val,even", [(i, j) for i in range(256) for j in [True, False]]
+)
+def test_VerifyingKey_decode_with_small_values(val, even):
+    enc = number_to_string(val, NIST192p.order)
+
+    if even:
+        enc = b("\x02") + enc
+    else:
+        enc = b("\x03") + enc
+
+    # small values can both be actual valid public keys and not, verify that
+    # only expected exceptions are raised if they are not
+    try:
+        vk = VerifyingKey.from_string(enc)
+        assert isinstance(vk, VerifyingKey)
+    except MalformedPointError:
+        assert True
+
+
+params = []
+for curve in curves:
+    for enc in ["raw", "uncompressed", "compressed", "hybrid"]:
+        params.append(
+            pytest.param(curve, enc, id="{0}-{1}".format(curve.name, enc))
+        )
+
+
+@pytest.mark.parametrize("curve,encoding", params)
+def test_VerifyingKey_encode_decode(curve, encoding):
+    sk = SigningKey.generate(curve=curve)
+    vk = sk.verifying_key
+
+    encoded = vk.to_string(encoding)
+
+    from_enc = VerifyingKey.from_string(encoded, curve=curve)
+
+    assert vk.pubkey.point == from_enc.pubkey.point
+
+
+class OpenSSL(unittest.TestCase):
+    # test interoperability with OpenSSL tools. Note that openssl's ECDSA
+    # sign/verify arguments changed between 0.9.8 and 1.0.0: the early
+    # versions require "-ecdsa-with-SHA1", the later versions want just
+    # "-SHA1" (or to leave out that argument entirely, which means the
+    # signature will use some default digest algorithm, probably determined
+    # by the key, probably always SHA1).
+    #
+    # openssl ecparam -name secp224r1 -genkey -out privkey.pem
+    # openssl ec -in privkey.pem -text -noout # get the priv/pub keys
+    # openssl dgst -ecdsa-with-SHA1 -sign privkey.pem -out data.sig data.txt
+    # openssl asn1parse -in data.sig -inform DER
+    #  data.sig is 64 bytes, probably 56b plus ASN1 overhead
+    # openssl dgst -ecdsa-with-SHA1 -prverify privkey.pem -signature data.sig data.txt ; echo $?
+    # openssl ec -in privkey.pem -pubout -out pubkey.pem
+    # openssl ec -in privkey.pem -pubout -outform DER -out pubkey.der
+
+    OPENSSL_SUPPORTED_CURVES = set(
+        c.split(":")[0].strip()
+        for c in run_openssl("ecparam -list_curves").split("\n")
+    )
+
+    def get_openssl_messagedigest_arg(self, hash_name):
+        v = run_openssl("version")
+        # e.g. "OpenSSL 1.0.0 29 Mar 2010", or "OpenSSL 1.0.0a 1 Jun 2010",
+        # or "OpenSSL 0.9.8o 01 Jun 2010"
+        vs = v.split()[1].split(".")
+        if vs >= ["1", "0", "0"]:  # pragma: no cover
+            return "-{0}".format(hash_name)
+        else:  # pragma: no cover
+            return "-ecdsa-with-{0}".format(hash_name)
+
+    # sk: 1:OpenSSL->python  2:python->OpenSSL
+    # vk: 3:OpenSSL->python  4:python->OpenSSL
+    # sig: 5:OpenSSL->python 6:python->OpenSSL
+
+    @pytest.mark.skipif(
+        "secp112r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp112r1",
+    )
+    def test_from_openssl_secp112r1(self):
+        return self.do_test_from_openssl(SECP112r1)
+
+    @pytest.mark.skipif(
+        "secp112r2" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp112r2",
+    )
+    def test_from_openssl_secp112r2(self):
+        return self.do_test_from_openssl(SECP112r2)
+
+    @pytest.mark.skipif(
+        "secp128r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp128r1",
+    )
+    def test_from_openssl_secp128r1(self):
+        return self.do_test_from_openssl(SECP128r1)
+
+    @pytest.mark.skipif(
+        "secp160r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp160r1",
+    )
+    def test_from_openssl_secp160r1(self):
+        return self.do_test_from_openssl(SECP160r1)
+
+    @pytest.mark.skipif(
+        "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime192v1",
+    )
+    def test_from_openssl_nist192p(self):
+        return self.do_test_from_openssl(NIST192p)
+
+    @pytest.mark.skipif(
+        "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime192v1",
+    )
+    def test_from_openssl_nist192p_sha256(self):
+        return self.do_test_from_openssl(NIST192p, "SHA256")
+
+    @pytest.mark.skipif(
+        "secp224r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp224r1",
+    )
+    def test_from_openssl_nist224p(self):
+        return self.do_test_from_openssl(NIST224p)
+
+    @pytest.mark.skipif(
+        "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime256v1",
+    )
+    def test_from_openssl_nist256p(self):
+        return self.do_test_from_openssl(NIST256p)
+
+    @pytest.mark.skipif(
+        "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime256v1",
+    )
+    def test_from_openssl_nist256p_sha384(self):
+        return self.do_test_from_openssl(NIST256p, "SHA384")
+
+    @pytest.mark.skipif(
+        "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime256v1",
+    )
+    def test_from_openssl_nist256p_sha512(self):
+        return self.do_test_from_openssl(NIST256p, "SHA512")
+
+    @pytest.mark.skipif(
+        "secp384r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp384r1",
+    )
+    def test_from_openssl_nist384p(self):
+        return self.do_test_from_openssl(NIST384p)
+
+    @pytest.mark.skipif(
+        "secp521r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp521r1",
+    )
+    def test_from_openssl_nist521p(self):
+        return self.do_test_from_openssl(NIST521p)
+
+    @pytest.mark.skipif(
+        "secp256k1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp256k1",
+    )
+    def test_from_openssl_secp256k1(self):
+        return self.do_test_from_openssl(SECP256k1)
+
+    @pytest.mark.skipif(
+        "brainpoolP160r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP160r1",
+    )
+    def test_from_openssl_brainpoolp160r1(self):
+        return self.do_test_from_openssl(BRAINPOOLP160r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP192r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP192r1",
+    )
+    def test_from_openssl_brainpoolp192r1(self):
+        return self.do_test_from_openssl(BRAINPOOLP192r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP224r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP224r1",
+    )
+    def test_from_openssl_brainpoolp224r1(self):
+        return self.do_test_from_openssl(BRAINPOOLP224r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP256r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP256r1",
+    )
+    def test_from_openssl_brainpoolp256r1(self):
+        return self.do_test_from_openssl(BRAINPOOLP256r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP320r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP320r1",
+    )
+    def test_from_openssl_brainpoolp320r1(self):
+        return self.do_test_from_openssl(BRAINPOOLP320r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP384r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP384r1",
+    )
+    def test_from_openssl_brainpoolp384r1(self):
+        return self.do_test_from_openssl(BRAINPOOLP384r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP512r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP512r1",
+    )
+    def test_from_openssl_brainpoolp512r1(self):
+        return self.do_test_from_openssl(BRAINPOOLP512r1)
+
+    def do_test_from_openssl(self, curve, hash_name="SHA1"):
+        curvename = curve.openssl_name
+        assert curvename
+        # OpenSSL: create sk, vk, sign.
+        # Python: read vk(3), checksig(5), read sk(1), sign, check
+        mdarg = self.get_openssl_messagedigest_arg(hash_name)
+        if os.path.isdir("t"):  # pragma: no cover
+            shutil.rmtree("t")
+        os.mkdir("t")
+        run_openssl("ecparam -name %s -genkey -out t/privkey.pem" % curvename)
+        run_openssl("ec -in t/privkey.pem -pubout -out t/pubkey.pem")
+        data = b("data")
+        with open("t/data.txt", "wb") as e:
+            e.write(data)
+        run_openssl(
+            "dgst %s -sign t/privkey.pem -out t/data.sig t/data.txt" % mdarg
+        )
+        run_openssl(
+            "dgst %s -verify t/pubkey.pem -signature t/data.sig t/data.txt"
+            % mdarg
+        )
+        with open("t/pubkey.pem", "rb") as e:
+            pubkey_pem = e.read()
+        vk = VerifyingKey.from_pem(pubkey_pem)  # 3
+        with open("t/data.sig", "rb") as e:
+            sig_der = e.read()
+        self.assertTrue(
+            vk.verify(
+                sig_der,
+                data,  # 5
+                hashfunc=partial(hashlib.new, hash_name),
+                sigdecode=sigdecode_der,
+            )
+        )
+
+        with open("t/privkey.pem") as e:
+            fp = e.read()
+        sk = SigningKey.from_pem(fp)  # 1
+        sig = sk.sign(data, hashfunc=partial(hashlib.new, hash_name))
+        self.assertTrue(
+            vk.verify(sig, data, hashfunc=partial(hashlib.new, hash_name))
+        )
+
+        run_openssl(
+            "pkcs8 -topk8 -nocrypt "
+            "-in t/privkey.pem -outform pem -out t/privkey-p8.pem"
+        )
+        with open("t/privkey-p8.pem", "rb") as e:
+            privkey_p8_pem = e.read()
+        sk_from_p8 = SigningKey.from_pem(privkey_p8_pem)
+        self.assertEqual(sk, sk_from_p8)
+
+    @pytest.mark.skipif(
+        "secp112r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp112r1",
+    )
+    def test_to_openssl_secp112r1(self):
+        self.do_test_to_openssl(SECP112r1)
+
+    @pytest.mark.skipif(
+        "secp112r2" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp112r2",
+    )
+    def test_to_openssl_secp112r2(self):
+        self.do_test_to_openssl(SECP112r2)
+
+    @pytest.mark.skipif(
+        "secp128r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp128r1",
+    )
+    def test_to_openssl_secp128r1(self):
+        self.do_test_to_openssl(SECP128r1)
+
+    @pytest.mark.skipif(
+        "secp160r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp160r1",
+    )
+    def test_to_openssl_secp160r1(self):
+        self.do_test_to_openssl(SECP160r1)
+
+    @pytest.mark.skipif(
+        "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime192v1",
+    )
+    def test_to_openssl_nist192p(self):
+        self.do_test_to_openssl(NIST192p)
+
+    @pytest.mark.skipif(
+        "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime192v1",
+    )
+    def test_to_openssl_nist192p_sha256(self):
+        self.do_test_to_openssl(NIST192p, "SHA256")
+
+    @pytest.mark.skipif(
+        "secp224r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp224r1",
+    )
+    def test_to_openssl_nist224p(self):
+        self.do_test_to_openssl(NIST224p)
+
+    @pytest.mark.skipif(
+        "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime256v1",
+    )
+    def test_to_openssl_nist256p(self):
+        self.do_test_to_openssl(NIST256p)
+
+    @pytest.mark.skipif(
+        "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime256v1",
+    )
+    def test_to_openssl_nist256p_sha384(self):
+        self.do_test_to_openssl(NIST256p, "SHA384")
+
+    @pytest.mark.skipif(
+        "prime256v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime256v1",
+    )
+    def test_to_openssl_nist256p_sha512(self):
+        self.do_test_to_openssl(NIST256p, "SHA512")
+
+    @pytest.mark.skipif(
+        "secp384r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp384r1",
+    )
+    def test_to_openssl_nist384p(self):
+        self.do_test_to_openssl(NIST384p)
+
+    @pytest.mark.skipif(
+        "secp521r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp521r1",
+    )
+    def test_to_openssl_nist521p(self):
+        self.do_test_to_openssl(NIST521p)
+
+    @pytest.mark.skipif(
+        "secp256k1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support secp256k1",
+    )
+    def test_to_openssl_secp256k1(self):
+        self.do_test_to_openssl(SECP256k1)
+
+    @pytest.mark.skipif(
+        "brainpoolP160r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP160r1",
+    )
+    def test_to_openssl_brainpoolp160r1(self):
+        self.do_test_to_openssl(BRAINPOOLP160r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP192r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP192r1",
+    )
+    def test_to_openssl_brainpoolp192r1(self):
+        self.do_test_to_openssl(BRAINPOOLP192r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP224r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP224r1",
+    )
+    def test_to_openssl_brainpoolp224r1(self):
+        self.do_test_to_openssl(BRAINPOOLP224r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP256r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP256r1",
+    )
+    def test_to_openssl_brainpoolp256r1(self):
+        self.do_test_to_openssl(BRAINPOOLP256r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP320r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP320r1",
+    )
+    def test_to_openssl_brainpoolp320r1(self):
+        self.do_test_to_openssl(BRAINPOOLP320r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP384r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP384r1",
+    )
+    def test_to_openssl_brainpoolp384r1(self):
+        self.do_test_to_openssl(BRAINPOOLP384r1)
+
+    @pytest.mark.skipif(
+        "brainpoolP512r1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support brainpoolP512r1",
+    )
+    def test_to_openssl_brainpoolp512r1(self):
+        self.do_test_to_openssl(BRAINPOOLP512r1)
+
+    def do_test_to_openssl(self, curve, hash_name="SHA1"):
+        curvename = curve.openssl_name
+        assert curvename
+        # Python: create sk, vk, sign.
+        # OpenSSL: read vk(4), checksig(6), read sk(2), sign, check
+        mdarg = self.get_openssl_messagedigest_arg(hash_name)
+        if os.path.isdir("t"):  # pragma: no cover
+            shutil.rmtree("t")
+        os.mkdir("t")
+        sk = SigningKey.generate(curve=curve)
+        vk = sk.get_verifying_key()
+        data = b("data")
+        with open("t/pubkey.der", "wb") as e:
+            e.write(vk.to_der())  # 4
+        with open("t/pubkey.pem", "wb") as e:
+            e.write(vk.to_pem())  # 4
+        sig_der = sk.sign(
+            data,
+            hashfunc=partial(hashlib.new, hash_name),
+            sigencode=sigencode_der,
+        )
+
+        with open("t/data.sig", "wb") as e:
+            e.write(sig_der)  # 6
+        with open("t/data.txt", "wb") as e:
+            e.write(data)
+        with open("t/baddata.txt", "wb") as e:
+            e.write(data + b("corrupt"))
+
+        self.assertRaises(
+            SubprocessError,
+            run_openssl,
+            "dgst %s -verify t/pubkey.der -keyform DER -signature t/data.sig t/baddata.txt"
+            % mdarg,
+        )
+        run_openssl(
+            "dgst %s -verify t/pubkey.der -keyform DER -signature t/data.sig t/data.txt"
+            % mdarg
+        )
+
+        with open("t/privkey.pem", "wb") as e:
+            e.write(sk.to_pem())  # 2
+        run_openssl(
+            "dgst %s -sign t/privkey.pem -out t/data.sig2 t/data.txt" % mdarg
+        )
+        run_openssl(
+            "dgst %s -verify t/pubkey.pem -signature t/data.sig2 t/data.txt"
+            % mdarg
+        )
+
+        with open("t/privkey-explicit.pem", "wb") as e:
+            e.write(sk.to_pem(curve_parameters_encoding="explicit"))
+        run_openssl(
+            "dgst %s -sign t/privkey-explicit.pem -out t/data.sig2 t/data.txt"
+            % mdarg
+        )
+        run_openssl(
+            "dgst %s -verify t/pubkey.pem -signature t/data.sig2 t/data.txt"
+            % mdarg
+        )
+
+        with open("t/privkey-p8.pem", "wb") as e:
+            e.write(sk.to_pem(format="pkcs8"))
+        run_openssl(
+            "dgst %s -sign t/privkey-p8.pem -out t/data.sig3 t/data.txt"
+            % mdarg
+        )
+        run_openssl(
+            "dgst %s -verify t/pubkey.pem -signature t/data.sig3 t/data.txt"
+            % mdarg
+        )
+
+        with open("t/privkey-p8-explicit.pem", "wb") as e:
+            e.write(
+                sk.to_pem(format="pkcs8", curve_parameters_encoding="explicit")
+            )
+        run_openssl(
+            "dgst %s -sign t/privkey-p8-explicit.pem -out t/data.sig3 t/data.txt"
+            % mdarg
+        )
+        run_openssl(
+            "dgst %s -verify t/pubkey.pem -signature t/data.sig3 t/data.txt"
+            % mdarg
+        )
+
+    OPENSSL_SUPPORTED_TYPES = set()
+    try:
+        if "-rawin" in run_openssl("pkeyutl -help"):
+            OPENSSL_SUPPORTED_TYPES = set(
+                c.lower()
+                for c in ("ED25519", "ED448")
+                if c in run_openssl("list -public-key-methods")
+            )
+    except SubprocessError:
+        pass
+
+    def do_eddsa_test_to_openssl(self, curve):
+        curvename = curve.name.upper()
+
+        if os.path.isdir("t"):
+            shutil.rmtree("t")
+        os.mkdir("t")
+
+        sk = SigningKey.generate(curve=curve)
+        vk = sk.get_verifying_key()
+
+        data = b"data"
+        with open("t/pubkey.der", "wb") as e:
+            e.write(vk.to_der())
+        with open("t/pubkey.pem", "wb") as e:
+            e.write(vk.to_pem())
+
+        sig = sk.sign(data)
+
+        with open("t/data.sig", "wb") as e:
+            e.write(sig)
+        with open("t/data.txt", "wb") as e:
+            e.write(data)
+        with open("t/baddata.txt", "wb") as e:
+            e.write(data + b"corrupt")
+
+        with self.assertRaises(SubprocessError):
+            run_openssl(
+                "pkeyutl -verify -pubin -inkey t/pubkey.pem -rawin "
+                "-in t/baddata.txt -sigfile t/data.sig"
+            )
+        run_openssl(
+            "pkeyutl -verify -pubin -inkey t/pubkey.pem -rawin "
+            "-in t/data.txt -sigfile t/data.sig"
+        )
+
+        shutil.rmtree("t")
+
+    # in practice at least OpenSSL 3.0.0 is needed to make EdDSA signatures
+    # earlier versions support EdDSA only in X.509 certificates
+    @pytest.mark.skipif(
+        "ed25519" not in OPENSSL_SUPPORTED_TYPES,
+        reason="system openssl does not support signing with Ed25519",
+    )
+    def test_to_openssl_ed25519(self):
+        return self.do_eddsa_test_to_openssl(Ed25519)
+
+    @pytest.mark.skipif(
+        "ed448" not in OPENSSL_SUPPORTED_TYPES,
+        reason="system openssl does not support signing with Ed448",
+    )
+    def test_to_openssl_ed448(self):
+        return self.do_eddsa_test_to_openssl(Ed448)
+
+    def do_eddsa_test_from_openssl(self, curve):
+        curvename = curve.name
+
+        if os.path.isdir("t"):
+            shutil.rmtree("t")
+        os.mkdir("t")
+
+        data = b"data"
+
+        run_openssl(
+            "genpkey -algorithm {0} -outform PEM -out t/privkey.pem".format(
+                curvename
+            )
+        )
+        run_openssl(
+            "pkey -outform PEM -pubout -in t/privkey.pem -out t/pubkey.pem"
+        )
+
+        with open("t/data.txt", "wb") as e:
+            e.write(data)
+        run_openssl(
+            "pkeyutl -sign -inkey t/privkey.pem "
+            "-rawin -in t/data.txt -out t/data.sig"
+        )
+
+        with open("t/data.sig", "rb") as e:
+            sig = e.read()
+        with open("t/pubkey.pem", "rb") as e:
+            vk = VerifyingKey.from_pem(e.read())
+
+        self.assertIs(vk.curve, curve)
+
+        vk.verify(sig, data)
+
+        shutil.rmtree("t")
+
+    @pytest.mark.skipif(
+        "ed25519" not in OPENSSL_SUPPORTED_TYPES,
+        reason="system openssl does not support signing with Ed25519",
+    )
+    def test_from_openssl_ed25519(self):
+        return self.do_eddsa_test_from_openssl(Ed25519)
+
+    @pytest.mark.skipif(
+        "ed448" not in OPENSSL_SUPPORTED_TYPES,
+        reason="system openssl does not support signing with Ed448",
+    )
+    def test_from_openssl_ed448(self):
+        return self.do_eddsa_test_from_openssl(Ed448)
+
+
+class TooSmallCurve(unittest.TestCase):
+    OPENSSL_SUPPORTED_CURVES = set(
+        c.split(":")[0].strip()
+        for c in run_openssl("ecparam -list_curves").split("\n")
+    )
+
+    @pytest.mark.skipif(
+        "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime192v1",
+    )
+    def test_sign_too_small_curve_dont_allow_truncate_raises(self):
+        sk = SigningKey.generate(curve=NIST192p)
+        data = b("data")
+        with self.assertRaises(BadDigestError):
+            sk.sign(
+                data,
+                hashfunc=partial(hashlib.new, "SHA256"),
+                sigencode=sigencode_der,
+                allow_truncate=False,
+            )
+
+    @pytest.mark.skipif(
+        "prime192v1" not in OPENSSL_SUPPORTED_CURVES,
+        reason="system openssl does not support prime192v1",
+    )
+    def test_verify_too_small_curve_dont_allow_truncate_raises(self):
+        sk = SigningKey.generate(curve=NIST192p)
+        vk = sk.get_verifying_key()
+        data = b("data")
+        sig_der = sk.sign(
+            data,
+            hashfunc=partial(hashlib.new, "SHA256"),
+            sigencode=sigencode_der,
+            allow_truncate=True,
+        )
+        with self.assertRaises(BadDigestError):
+            vk.verify(
+                sig_der,
+                data,
+                hashfunc=partial(hashlib.new, "SHA256"),
+                sigdecode=sigdecode_der,
+                allow_truncate=False,
+            )
+
+
+class DER(unittest.TestCase):
+    def test_integer(self):
+        self.assertEqual(der.encode_integer(0), b("\x02\x01\x00"))
+        self.assertEqual(der.encode_integer(1), b("\x02\x01\x01"))
+        self.assertEqual(der.encode_integer(127), b("\x02\x01\x7f"))
+        self.assertEqual(der.encode_integer(128), b("\x02\x02\x00\x80"))
+        self.assertEqual(der.encode_integer(256), b("\x02\x02\x01\x00"))
+        # self.assertEqual(der.encode_integer(-1), b("\x02\x01\xff"))
+
+        def s(n):
+            return der.remove_integer(der.encode_integer(n) + b("junk"))
+
+        self.assertEqual(s(0), (0, b("junk")))
+        self.assertEqual(s(1), (1, b("junk")))
+        self.assertEqual(s(127), (127, b("junk")))
+        self.assertEqual(s(128), (128, b("junk")))
+        self.assertEqual(s(256), (256, b("junk")))
+        self.assertEqual(
+            s(1234567890123456789012345678901234567890),
+            (1234567890123456789012345678901234567890, b("junk")),
+        )
+
+    def test_number(self):
+        self.assertEqual(der.encode_number(0), b("\x00"))
+        self.assertEqual(der.encode_number(127), b("\x7f"))
+        self.assertEqual(der.encode_number(128), b("\x81\x00"))
+        self.assertEqual(der.encode_number(3 * 128 + 7), b("\x83\x07"))
+        # self.assertEqual(der.read_number("\x81\x9b" + "more"), (155, 2))
+        # self.assertEqual(der.encode_number(155), b("\x81\x9b"))
+        for n in (0, 1, 2, 127, 128, 3 * 128 + 7, 840, 10045):  # , 155):
+            x = der.encode_number(n) + b("more")
+            n1, llen = der.read_number(x)
+            self.assertEqual(n1, n)
+            self.assertEqual(x[llen:], b("more"))
+
+    def test_length(self):
+        self.assertEqual(der.encode_length(0), b("\x00"))
+        self.assertEqual(der.encode_length(127), b("\x7f"))
+        self.assertEqual(der.encode_length(128), b("\x81\x80"))
+        self.assertEqual(der.encode_length(255), b("\x81\xff"))
+        self.assertEqual(der.encode_length(256), b("\x82\x01\x00"))
+        self.assertEqual(der.encode_length(3 * 256 + 7), b("\x82\x03\x07"))
+        self.assertEqual(der.read_length(b("\x81\x9b") + b("more")), (155, 2))
+        self.assertEqual(der.encode_length(155), b("\x81\x9b"))
+        for n in (0, 1, 2, 127, 128, 255, 256, 3 * 256 + 7, 155):
+            x = der.encode_length(n) + b("more")
+            n1, llen = der.read_length(x)
+            self.assertEqual(n1, n)
+            self.assertEqual(x[llen:], b("more"))
+
+    def test_sequence(self):
+        x = der.encode_sequence(b("ABC"), b("DEF")) + b("GHI")
+        self.assertEqual(x, b("\x30\x06ABCDEFGHI"))
+        x1, rest = der.remove_sequence(x)
+        self.assertEqual(x1, b("ABCDEF"))
+        self.assertEqual(rest, b("GHI"))
+
+    def test_constructed(self):
+        x = der.encode_constructed(0, NIST224p.encoded_oid)
+        self.assertEqual(hexlify(x), b("a007") + b("06052b81040021"))
+        x = der.encode_constructed(1, unhexlify(b("0102030a0b0c")))
+        self.assertEqual(hexlify(x), b("a106") + b("0102030a0b0c"))
+
+
+class Util(unittest.TestCase):
+    def test_trytryagain(self):
+        tta = util.randrange_from_seed__trytryagain
+        for i in range(1000):
+            seed = "seed-%d" % i
+            for order in (
+                2**8 - 2,
+                2**8 - 1,
+                2**8,
+                2**8 + 1,
+                2**8 + 2,
+                2**16 - 1,
+                2**16 + 1,
+            ):
+                n = tta(seed, order)
+                self.assertTrue(1 <= n < order, (1, n, order))
+        # this trytryagain *does* provide long-term stability
+        self.assertEqual(
+            ("%x" % (tta("seed", NIST224p.order))).encode(),
+            b("6fa59d73bf0446ae8743cf748fc5ac11d5585a90356417e97155c3bc"),
+        )
+
+    def test_trytryagain_single(self):
+        tta = util.randrange_from_seed__trytryagain
+        order = 2**8 - 2
+        seed = b"text"
+        n = tta(seed, order)
+        # known issue: https://github.com/warner/python-ecdsa/issues/221
+        if sys.version_info < (3, 0):  # pragma: no branch
+            self.assertEqual(n, 228)
+        else:
+            self.assertEqual(n, 18)
+
+    @given(st.integers(min_value=0, max_value=10**200))
+    def test_randrange(self, i):
+        # util.randrange does not provide long-term stability: we might
+        # change the algorithm in the future.
+        entropy = util.PRNG("seed-%d" % i)
+        for order in (
+            2**8 - 2,
+            2**8 - 1,
+            2**8,
+            2**16 - 1,
+            2**16 + 1,
+        ):
+            # that oddball 2**16+1 takes half our runtime
+            n = util.randrange(order, entropy=entropy)
+            self.assertTrue(1 <= n < order, (1, n, order))
+
+    def OFF_test_prove_uniformity(self):  # pragma: no cover
+        order = 2**8 - 2
+        counts = dict([(i, 0) for i in range(1, order)])
+        assert 0 not in counts
+        assert order not in counts
+        for i in range(1000000):
+            seed = "seed-%d" % i
+            n = util.randrange_from_seed__trytryagain(seed, order)
+            counts[n] += 1
+        # this technique should use the full range
+        self.assertTrue(counts[order - 1])
+        for i in range(1, order):
+            print_("%3d: %s" % (i, "*" * (counts[i] // 100)))
+
+
+class RFC6979(unittest.TestCase):
+    # https://tools.ietf.org/html/rfc6979#appendix-A.1
+    def _do(self, generator, secexp, hsh, hash_func, expected):
+        actual = rfc6979.generate_k(generator.order(), secexp, hash_func, hsh)
+        self.assertEqual(expected, actual)
+
+    def test_SECP256k1(self):
+        """RFC doesn't contain test vectors for SECP256k1 used in bitcoin.
+        This vector has been computed by Golang reference implementation instead."""
+        self._do(
+            generator=SECP256k1.generator,
+            secexp=int("9d0219792467d7d37b4d43298a7d0c05", 16),
+            hsh=sha256(b("sample")).digest(),
+            hash_func=sha256,
+            expected=int(
+                "8fa1f95d514760e498f28957b824ee6ec39ed64826ff4fecc2b5739ec45b91cd",
+                16,
+            ),
+        )
+
+    def test_SECP256k1_2(self):
+        self._do(
+            generator=SECP256k1.generator,
+            secexp=int(
+                "cca9fbcc1b41e5a95d369eaa6ddcff73b61a4efaa279cfc6567e8daa39cbaf50",
+                16,
+            ),
+            hsh=sha256(b("sample")).digest(),
+            hash_func=sha256,
+            expected=int(
+                "2df40ca70e639d89528a6b670d9d48d9165fdc0febc0974056bdce192b8e16a3",
+                16,
+            ),
+        )
+
+    def test_SECP256k1_3(self):
+        self._do(
+            generator=SECP256k1.generator,
+            secexp=0x1,
+            hsh=sha256(b("Satoshi Nakamoto")).digest(),
+            hash_func=sha256,
+            expected=0x8F8A276C19F4149656B280621E358CCE24F5F52542772691EE69063B74F15D15,
+        )
+
+    def test_SECP256k1_4(self):
+        self._do(
+            generator=SECP256k1.generator,
+            secexp=0x1,
+            hsh=sha256(
+                b(
+                    "All those moments will be lost in time, like tears in rain. Time to die..."
+                )
+            ).digest(),
+            hash_func=sha256,
+            expected=0x38AA22D72376B4DBC472E06C3BA403EE0A394DA63FC58D88686C611ABA98D6B3,
+        )
+
+    def test_SECP256k1_5(self):
+        self._do(
+            generator=SECP256k1.generator,
+            secexp=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140,
+            hsh=sha256(b("Satoshi Nakamoto")).digest(),
+            hash_func=sha256,
+            expected=0x33A19B60E25FB6F4435AF53A3D42D493644827367E6453928554F43E49AA6F90,
+        )
+
+    def test_SECP256k1_6(self):
+        self._do(
+            generator=SECP256k1.generator,
+            secexp=0xF8B8AF8CE3C7CCA5E300D33939540C10D45CE001B8F252BFBC57BA0342904181,
+            hsh=sha256(b("Alan Turing")).digest(),
+            hash_func=sha256,
+            expected=0x525A82B70E67874398067543FD84C83D30C175FDC45FDEEE082FE13B1D7CFDF1,
+        )
+
+    def test_1(self):
+        # Basic example of the RFC, it also tests 'try-try-again' from Step H of rfc6979
+        self._do(
+            generator=Point(
+                None,
+                0,
+                0,
+                int("4000000000000000000020108A2E0CC0D99F8A5EF", 16),
+            ),
+            secexp=int("09A4D6792295A7F730FC3F2B49CBC0F62E862272F", 16),
+            hsh=unhexlify(
+                b(
+                    "AF2BDBE1AA9B6EC1E2ADE1D694F41FC71A831D0268E9891562113D8A62ADD1BF"
+                )
+            ),
+            hash_func=sha256,
+            expected=int("23AF4074C90A02B3FE61D286D5C87F425E6BDD81B", 16),
+        )
+
+    def test_2(self):
+        self._do(
+            generator=NIST192p.generator,
+            secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
+            hsh=sha1(b("sample")).digest(),
+            hash_func=sha1,
+            expected=int(
+                "37D7CA00D2C7B0E5E412AC03BD44BA837FDD5B28CD3B0021", 16
+            ),
+        )
+
+    def test_3(self):
+        self._do(
+            generator=NIST192p.generator,
+            secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
+            hsh=sha256(b("sample")).digest(),
+            hash_func=sha256,
+            expected=int(
+                "32B1B6D7D42A05CB449065727A84804FB1A3E34D8F261496", 16
+            ),
+        )
+
+    def test_4(self):
+        self._do(
+            generator=NIST192p.generator,
+            secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
+            hsh=sha512(b("sample")).digest(),
+            hash_func=sha512,
+            expected=int(
+                "A2AC7AB055E4F20692D49209544C203A7D1F2C0BFBC75DB1", 16
+            ),
+        )
+
+    def test_5(self):
+        self._do(
+            generator=NIST192p.generator,
+            secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
+            hsh=sha1(b("test")).digest(),
+            hash_func=sha1,
+            expected=int(
+                "D9CF9C3D3297D3260773A1DA7418DB5537AB8DD93DE7FA25", 16
+            ),
+        )
+
+    def test_6(self):
+        self._do(
+            generator=NIST192p.generator,
+            secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
+            hsh=sha256(b("test")).digest(),
+            hash_func=sha256,
+            expected=int(
+                "5C4CE89CF56D9E7C77C8585339B006B97B5F0680B4306C6C", 16
+            ),
+        )
+
+    def test_7(self):
+        self._do(
+            generator=NIST192p.generator,
+            secexp=int("6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4", 16),
+            hsh=sha512(b("test")).digest(),
+            hash_func=sha512,
+            expected=int(
+                "0758753A5254759C7CFBAD2E2D9B0792EEE44136C9480527", 16
+            ),
+        )
+
+    def test_8(self):
+        self._do(
+            generator=NIST521p.generator,
+            secexp=int(
+                "0FAD06DAA62BA3B25D2FB40133DA757205DE67F5BB0018FEE8C86E1B68C7E75CAA896EB32F1F47C70855836A6D16FCC1466F6D8FBEC67DB89EC0C08B0E996B83538",
+                16,
+            ),
+            hsh=sha1(b("sample")).digest(),
+            hash_func=sha1,
+            expected=int(
+                "089C071B419E1C2820962321787258469511958E80582E95D8378E0C2CCDB3CB42BEDE42F50E3FA3C71F5A76724281D31D9C89F0F91FC1BE4918DB1C03A5838D0F9",
+                16,
+            ),
+        )
+
+    def test_9(self):
+        self._do(
+            generator=NIST521p.generator,
+            secexp=int(
+                "0FAD06DAA62BA3B25D2FB40133DA757205DE67F5BB0018FEE8C86E1B68C7E75CAA896EB32F1F47C70855836A6D16FCC1466F6D8FBEC67DB89EC0C08B0E996B83538",
+                16,
+            ),
+            hsh=sha256(b("sample")).digest(),
+            hash_func=sha256,
+            expected=int(
+                "0EDF38AFCAAECAB4383358B34D67C9F2216C8382AAEA44A3DAD5FDC9C32575761793FEF24EB0FC276DFC4F6E3EC476752F043CF01415387470BCBD8678ED2C7E1A0",
+                16,
+            ),
+        )
+
+    def test_10(self):
+        self._do(
+            generator=NIST521p.generator,
+            secexp=int(
+                "0FAD06DAA62BA3B25D2FB40133DA757205DE67F5BB0018FEE8C86E1B68C7E75CAA896EB32F1F47C70855836A6D16FCC1466F6D8FBEC67DB89EC0C08B0E996B83538",
+                16,
+            ),
+            hsh=sha512(b("test")).digest(),
+            hash_func=sha512,
+            expected=int(
+                "16200813020EC986863BEDFC1B121F605C1215645018AEA1A7B215A564DE9EB1B38A67AA1128B80CE391C4FB71187654AAA3431027BFC7F395766CA988C964DC56D",
+                16,
+            ),
+        )
+
+
+class ECDH(unittest.TestCase):
+    def _do(self, curve, generator, dA, x_qA, y_qA, dB, x_qB, y_qB, x_Z, y_Z):
+        qA = dA * generator
+        qB = dB * generator
+        Z = dA * qB
+        self.assertEqual(Point(curve, x_qA, y_qA), qA)
+        self.assertEqual(Point(curve, x_qB, y_qB), qB)
+        self.assertTrue(
+            (dA * qB)
+            == (dA * dB * generator)
+            == (dB * dA * generator)
+            == (dB * qA)
+        )
+        self.assertEqual(Point(curve, x_Z, y_Z), Z)
+
+
+class RFC6932(ECDH):
+    # https://tools.ietf.org/html/rfc6932#appendix-A.1
+
+    def test_brainpoolP224r1(self):
+        self._do(
+            curve=curve_brainpoolp224r1,
+            generator=BRAINPOOLP224r1.generator,
+            dA=int(
+                "7C4B7A2C8A4BAD1FBB7D79CC0955DB7C6A4660CA64CC4778159B495E", 16
+            ),
+            x_qA=int(
+                "B104A67A6F6E85E14EC1825E1539E8ECDBBF584922367DD88C6BDCF2", 16
+            ),
+            y_qA=int(
+                "46D782E7FDB5F60CD8404301AC5949C58EDB26BC68BA07695B750A94", 16
+            ),
+            dB=int(
+                "63976D4AAE6CD0F6DD18DEFEF55D96569D0507C03E74D6486FFA28FB", 16
+            ),
+            x_qB=int(
+                "2A97089A9296147B71B21A4B574E1278245B536F14D8C2B9D07A874E", 16
+            ),
+            y_qB=int(
+                "9B900D7C77A709A797276B8CA1BA61BB95B546FC29F862E44D59D25B", 16
+            ),
+            x_Z=int(
+                "312DFD98783F9FB77B9704945A73BEB6DCCBE3B65D0F967DCAB574EB", 16
+            ),
+            y_Z=int(
+                "6F800811D64114B1C48C621AB3357CF93F496E4238696A2A012B3C98", 16
+            ),
+        )
+
+    def test_brainpoolP256r1(self):
+        self._do(
+            curve=curve_brainpoolp256r1,
+            generator=BRAINPOOLP256r1.generator,
+            dA=int(
+                "041EB8B1E2BC681BCE8E39963B2E9FC415B05283313DD1A8BCC055F11AE"
+                "49699",
+                16,
+            ),
+            x_qA=int(
+                "78028496B5ECAAB3C8B6C12E45DB1E02C9E4D26B4113BC4F015F60C5C"
+                "CC0D206",
+                16,
+            ),
+            y_qA=int(
+                "A2AE1762A3831C1D20F03F8D1E3C0C39AFE6F09B4D44BBE80CD100987"
+                "B05F92B",
+                16,
+            ),
+            dB=int(
+                "06F5240EACDB9837BC96D48274C8AA834B6C87BA9CC3EEDD81F99A16B8D"
+                "804D3",
+                16,
+            ),
+            x_qB=int(
+                "8E07E219BA588916C5B06AA30A2F464C2F2ACFC1610A3BE2FB240B635"
+                "341F0DB",
+                16,
+            ),
+            y_qB=int(
+                "148EA1D7D1E7E54B9555B6C9AC90629C18B63BEE5D7AA6949EBBF47B2"
+                "4FDE40D",
+                16,
+            ),
+            x_Z=int(
+                "05E940915549E9F6A4A75693716E37466ABA79B4BF2919877A16DD2CC2"
+                "E23708",
+                16,
+            ),
+            y_Z=int(
+                "6BC23B6702BC5A019438CEEA107DAAD8B94232FFBBC350F3B137628FE6"
+                "FD134C",
+                16,
+            ),
+        )
+
+    def test_brainpoolP384r1(self):
+        self._do(
+            curve=curve_brainpoolp384r1,
+            generator=BRAINPOOLP384r1.generator,
+            dA=int(
+                "014EC0755B78594BA47FB0A56F6173045B4331E74BA1A6F47322E70D79D"
+                "828D97E095884CA72B73FDABD5910DF0FA76A",
+                16,
+            ),
+            x_qA=int(
+                "45CB26E4384DAF6FB776885307B9A38B7AD1B5C692E0C32F012533277"
+                "8F3B8D3F50CA358099B30DEB5EE69A95C058B4E",
+                16,
+            ),
+            y_qA=int(
+                "8173A1C54AFFA7E781D0E1E1D12C0DC2B74F4DF58E4A4E3AF7026C5D3"
+                "2DC530A2CD89C859BB4B4B768497F49AB8CC859",
+                16,
+            ),
+            dB=int(
+                "6B461CB79BD0EA519A87D6828815D8CE7CD9B3CAA0B5A8262CBCD550A01"
+                "5C90095B976F3529957506E1224A861711D54",
+                16,
+            ),
+            x_qB=int(
+                "01BF92A92EE4BE8DED1A911125C209B03F99E3161CFCC986DC7711383"
+                "FC30AF9CE28CA3386D59E2C8D72CE1E7B4666E8",
+                16,
+            ),
+            y_qB=int(
+                "3289C4A3A4FEE035E39BDB885D509D224A142FF9FBCC5CFE5CCBB3026"
+                "8EE47487ED8044858D31D848F7A95C635A347AC",
+                16,
+            ),
+            x_Z=int(
+                "04CC4FF3DCCCB07AF24E0ACC529955B36D7C807772B92FCBE48F3AFE9A"
+                "2F370A1F98D3FA73FD0C0747C632E12F1423EC",
+                16,
+            ),
+            y_Z=int(
+                "7F465F90BD69AFB8F828A214EB9716D66ABC59F17AF7C75EE7F1DE22AB"
+                "5D05085F5A01A9382D05BF72D96698FE3FF64E",
+                16,
+            ),
+        )
+
+    def test_brainpoolP512r1(self):
+        self._do(
+            curve=curve_brainpoolp512r1,
+            generator=BRAINPOOLP512r1.generator,
+            dA=int(
+                "636B6BE0482A6C1C41AA7AE7B245E983392DB94CECEA2660A379CFE1595"
+                "59E357581825391175FC195D28BAC0CF03A7841A383B95C262B98378287"
+                "4CCE6FE333",
+                16,
+            ),
+            x_qA=int(
+                "0562E68B9AF7CBFD5565C6B16883B777FF11C199161ECC427A39D17EC"
+                "2166499389571D6A994977C56AD8252658BA8A1B72AE42F4FB7532151"
+                "AFC3EF0971CCDA",
+                16,
+            ),
+            y_qA=int(
+                "A7CA2D8191E21776A89860AFBC1F582FAA308D551C1DC6133AF9F9C3C"
+                "AD59998D70079548140B90B1F311AFB378AA81F51B275B2BE6B7DEE97"
+                "8EFC7343EA642E",
+                16,
+            ),
+            dB=int(
+                "0AF4E7F6D52EDD52907BB8DBAB3992A0BB696EC10DF11892FF205B66D38"
+                "1ECE72314E6A6EA079CEA06961DBA5AE6422EF2E9EE803A1F236FB96A17"
+                "99B86E5C8B",
+                16,
+            ),
+            x_qB=int(
+                "5A7954E32663DFF11AE24712D87419F26B708AC2B92877D6BFEE2BFC4"
+                "3714D89BBDB6D24D807BBD3AEB7F0C325F862E8BADE4F74636B97EAAC"
+                "E739E11720D323",
+                16,
+            ),
+            y_qB=int(
+                "96D14621A9283A1BED84DE8DD64836B2C0758B11441179DC0C54C0D49"
+                "A47C03807D171DD544B72CAAEF7B7CE01C7753E2CAD1A861ECA55A719"
+                "54EE1BA35E04BE",
+                16,
+            ),
+            x_Z=int(
+                "1EE8321A4BBF93B9CF8921AB209850EC9B7066D1984EF08C2BB7232362"
+                "08AC8F1A483E79461A00E0D5F6921CE9D360502F85C812BEDEE23AC5B2"
+                "10E5811B191E",
+                16,
+            ),
+            y_Z=int(
+                "2632095B7B936174B41FD2FAF369B1D18DCADEED7E410A7E251F083109"
+                "7C50D02CFED02607B6A2D5ADB4C0006008562208631875B58B54ECDA5A"
+                "4F9FE9EAABA6",
+                16,
+            ),
+        )
+
+
+class RFC7027(ECDH):
+    # https://tools.ietf.org/html/rfc7027#appendix-A
+
+    def test_brainpoolP256r1(self):
+        self._do(
+            curve=curve_brainpoolp256r1,
+            generator=BRAINPOOLP256r1.generator,
+            dA=int(
+                "81DB1EE100150FF2EA338D708271BE38300CB54241D79950F77B0630398"
+                "04F1D",
+                16,
+            ),
+            x_qA=int(
+                "44106E913F92BC02A1705D9953A8414DB95E1AAA49E81D9E85F929A8E"
+                "3100BE5",
+                16,
+            ),
+            y_qA=int(
+                "8AB4846F11CACCB73CE49CBDD120F5A900A69FD32C272223F789EF10E"
+                "B089BDC",
+                16,
+            ),
+            dB=int(
+                "55E40BC41E37E3E2AD25C3C6654511FFA8474A91A0032087593852D3E7D"
+                "76BD3",
+                16,
+            ),
+            x_qB=int(
+                "8D2D688C6CF93E1160AD04CC4429117DC2C41825E1E9FCA0ADDD34E6F"
+                "1B39F7B",
+                16,
+            ),
+            y_qB=int(
+                "990C57520812BE512641E47034832106BC7D3E8DD0E4C7F1136D70065"
+                "47CEC6A",
+                16,
+            ),
+            x_Z=int(
+                "89AFC39D41D3B327814B80940B042590F96556EC91E6AE7939BCE31F3A"
+                "18BF2B",
+                16,
+            ),
+            y_Z=int(
+                "49C27868F4ECA2179BFD7D59B1E3BF34C1DBDE61AE12931648F43E5963"
+                "2504DE",
+                16,
+            ),
+        )
+
+    def test_brainpoolP384r1(self):
+        self._do(
+            curve=curve_brainpoolp384r1,
+            generator=BRAINPOOLP384r1.generator,
+            dA=int(
+                "1E20F5E048A5886F1F157C74E91BDE2B98C8B52D58E5003D57053FC4B0B"
+                "D65D6F15EB5D1EE1610DF870795143627D042",
+                16,
+            ),
+            x_qA=int(
+                "68B665DD91C195800650CDD363C625F4E742E8134667B767B1B476793"
+                "588F885AB698C852D4A6E77A252D6380FCAF068",
+                16,
+            ),
+            y_qA=int(
+                "55BC91A39C9EC01DEE36017B7D673A931236D2F1F5C83942D049E3FA2"
+                "0607493E0D038FF2FD30C2AB67D15C85F7FAA59",
+                16,
+            ),
+            dB=int(
+                "032640BC6003C59260F7250C3DB58CE647F98E1260ACCE4ACDA3DD869F7"
+                "4E01F8BA5E0324309DB6A9831497ABAC96670",
+                16,
+            ),
+            x_qB=int(
+                "4D44326F269A597A5B58BBA565DA5556ED7FD9A8A9EB76C25F46DB69D"
+                "19DC8CE6AD18E404B15738B2086DF37E71D1EB4",
+                16,
+            ),
+            y_qB=int(
+                "62D692136DE56CBE93BF5FA3188EF58BC8A3A0EC6C1E151A21038A42E"
+                "9185329B5B275903D192F8D4E1F32FE9CC78C48",
+                16,
+            ),
+            x_Z=int(
+                "0BD9D3A7EA0B3D519D09D8E48D0785FB744A6B355E6304BC51C229FBBC"
+                "E239BBADF6403715C35D4FB2A5444F575D4F42",
+                16,
+            ),
+            y_Z=int(
+                "0DF213417EBE4D8E40A5F76F66C56470C489A3478D146DECF6DF0D94BA"
+                "E9E598157290F8756066975F1DB34B2324B7BD",
+                16,
+            ),
+        )
+
+    def test_brainpoolP512r1(self):
+        self._do(
+            curve=curve_brainpoolp512r1,
+            generator=BRAINPOOLP512r1.generator,
+            dA=int(
+                "16302FF0DBBB5A8D733DAB7141C1B45ACBC8715939677F6A56850A38BD8"
+                "7BD59B09E80279609FF333EB9D4C061231FB26F92EEB04982A5F1D1764C"
+                "AD57665422",
+                16,
+            ),
+            x_qA=int(
+                "0A420517E406AAC0ACDCE90FCD71487718D3B953EFD7FBEC5F7F27E28"
+                "C6149999397E91E029E06457DB2D3E640668B392C2A7E737A7F0BF044"
+                "36D11640FD09FD",
+                16,
+            ),
+            y_qA=int(
+                "72E6882E8DB28AAD36237CD25D580DB23783961C8DC52DFA2EC138AD4"
+                "72A0FCEF3887CF62B623B2A87DE5C588301EA3E5FC269B373B60724F5"
+                "E82A6AD147FDE7",
+                16,
+            ),
+            dB=int(
+                "230E18E1BCC88A362FA54E4EA3902009292F7F8033624FD471B5D8ACE49"
+                "D12CFABBC19963DAB8E2F1EBA00BFFB29E4D72D13F2224562F405CB8050"
+                "3666B25429",
+                16,
+            ),
+            x_qB=int(
+                "9D45F66DE5D67E2E6DB6E93A59CE0BB48106097FF78A081DE781CDB31"
+                "FCE8CCBAAEA8DD4320C4119F1E9CD437A2EAB3731FA9668AB268D871D"
+                "EDA55A5473199F",
+                16,
+            ),
+            y_qB=int(
+                "2FDC313095BCDD5FB3A91636F07A959C8E86B5636A1E930E8396049CB"
+                "481961D365CC11453A06C719835475B12CB52FC3C383BCE35E27EF194"
+                "512B71876285FA",
+                16,
+            ),
+            x_Z=int(
+                "A7927098655F1F9976FA50A9D566865DC530331846381C87256BAF3226"
+                "244B76D36403C024D7BBF0AA0803EAFF405D3D24F11A9B5C0BEF679FE1"
+                "454B21C4CD1F",
+                16,
+            ),
+            y_Z=int(
+                "7DB71C3DEF63212841C463E881BDCF055523BD368240E6C3143BD8DEF8"
+                "B3B3223B95E0F53082FF5E412F4222537A43DF1C6D25729DDB51620A83"
+                "2BE6A26680A2",
+                16,
+            ),
+        )
+
+
+# https://tools.ietf.org/html/rfc4754#page-5
+@pytest.mark.parametrize(
+    "w, gwx, gwy, k, msg, md, r, s, curve",
+    [
+        pytest.param(
+            "DC51D3866A15BACDE33D96F992FCA99DA7E6EF0934E7097559C27F1614C88A7F",
+            "2442A5CC0ECD015FA3CA31DC8E2BBC70BF42D60CBCA20085E0822CB04235E970",
+            "6FC98BD7E50211A4A27102FA3549DF79EBCB4BF246B80945CDDFE7D509BBFD7D",
+            "9E56F509196784D963D1C0A401510EE7ADA3DCC5DEE04B154BF61AF1D5A6DECE",
+            b"abc",
+            sha256,
+            "CB28E0999B9C7715FD0A80D8E47A77079716CBBF917DD72E97566EA1C066957C",
+            "86FA3BB4E26CAD5BF90B7F81899256CE7594BB1EA0C89212748BFF3B3D5B0315",
+            NIST256p,
+            id="ECDSA-256",
+        ),
+        pytest.param(
+            "0BEB646634BA87735D77AE4809A0EBEA865535DE4C1E1DCB692E84708E81A5AF"
+            "62E528C38B2A81B35309668D73524D9F",
+            "96281BF8DD5E0525CA049C048D345D3082968D10FEDF5C5ACA0C64E6465A97EA"
+            "5CE10C9DFEC21797415710721F437922",
+            "447688BA94708EB6E2E4D59F6AB6D7EDFF9301D249FE49C33096655F5D502FAD"
+            "3D383B91C5E7EDAA2B714CC99D5743CA",
+            "B4B74E44D71A13D568003D7489908D564C7761E229C58CBFA18950096EB7463B"
+            "854D7FA992F934D927376285E63414FA",
+            b"abc",
+            sha384,
+            "FB017B914E29149432D8BAC29A514640B46F53DDAB2C69948084E2930F1C8F7E"
+            "08E07C9C63F2D21A07DCB56A6AF56EB3",
+            "B263A1305E057F984D38726A1B46874109F417BCA112674C528262A40A629AF1"
+            "CBB9F516CE0FA7D2FF630863A00E8B9F",
+            NIST384p,
+            id="ECDSA-384",
+        ),
+        pytest.param(
+            "0065FDA3409451DCAB0A0EAD45495112A3D813C17BFD34BDF8C1209D7DF58491"
+            "20597779060A7FF9D704ADF78B570FFAD6F062E95C7E0C5D5481C5B153B48B37"
+            "5FA1",
+            "0151518F1AF0F563517EDD5485190DF95A4BF57B5CBA4CF2A9A3F6474725A35F"
+            "7AFE0A6DDEB8BEDBCD6A197E592D40188901CECD650699C9B5E456AEA5ADD190"
+            "52A8",
+            "006F3B142EA1BFFF7E2837AD44C9E4FF6D2D34C73184BBAD90026DD5E6E85317"
+            "D9DF45CAD7803C6C20035B2F3FF63AFF4E1BA64D1C077577DA3F4286C58F0AEA"
+            "E643",
+            "00C1C2B305419F5A41344D7E4359933D734096F556197A9B244342B8B62F46F9"
+            "373778F9DE6B6497B1EF825FF24F42F9B4A4BD7382CFC3378A540B1B7F0C1B95"
+            "6C2F",
+            b"abc",
+            sha512,
+            "0154FD3836AF92D0DCA57DD5341D3053988534FDE8318FC6AAAAB68E2E6F4339"
+            "B19F2F281A7E0B22C269D93CF8794A9278880ED7DBB8D9362CAEACEE54432055"
+            "2251",
+            "017705A7030290D1CEB605A9A1BB03FF9CDD521E87A696EC926C8C10C8362DF4"
+            "975367101F67D1CF9BCCBF2F3D239534FA509E70AAC851AE01AAC68D62F86647"
+            "2660",
+            NIST521p,
+            id="ECDSA-521",
+        ),
+    ],
+)
+def test_RFC4754_vectors(w, gwx, gwy, k, msg, md, r, s, curve):
+    sk = SigningKey.from_string(unhexlify(w), curve)
+    vk = VerifyingKey.from_string(unhexlify(gwx + gwy), curve)
+    assert sk.verifying_key == vk
+    sig = sk.sign(msg, hashfunc=md, sigencode=sigencode_strings, k=int(k, 16))
+
+    assert sig == (unhexlify(r), unhexlify(s))
+
+    assert vk.verify(sig, msg, md, sigdecode_strings)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_rw_lock.py b/myenv/lib/python3.9/site-packages/ecdsa/test_rw_lock.py
new file mode 100644
index 0000000..0a84b9c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_rw_lock.py
@@ -0,0 +1,180 @@
+# Copyright Mateusz Kobos, (c) 2011
+# https://code.activestate.com/recipes/577803-reader-writer-lock-with-priority-for-writers/
+# released under the MIT licence
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+import threading
+import time
+import copy
+from ._rwlock import RWLock
+
+
+class Writer(threading.Thread):
+    def __init__(
+        self, buffer_, rw_lock, init_sleep_time, sleep_time, to_write
+    ):
+        """
+        @param buffer_: common buffer_ shared by the readers and writers
+        @type buffer_: list
+        @type rw_lock: L{RWLock}
+        @param init_sleep_time: sleep time before doing any action
+        @type init_sleep_time: C{float}
+        @param sleep_time: sleep time while in critical section
+        @type sleep_time: C{float}
+        @param to_write: data that will be appended to the buffer
+        """
+        threading.Thread.__init__(self)
+        self.__buffer = buffer_
+        self.__rw_lock = rw_lock
+        self.__init_sleep_time = init_sleep_time
+        self.__sleep_time = sleep_time
+        self.__to_write = to_write
+        self.entry_time = None
+        """Time of entry to the critical section"""
+        self.exit_time = None
+        """Time of exit from the critical section"""
+
+    def run(self):
+        time.sleep(self.__init_sleep_time)
+        self.__rw_lock.writer_acquire()
+        self.entry_time = time.time()
+        time.sleep(self.__sleep_time)
+        self.__buffer.append(self.__to_write)
+        self.exit_time = time.time()
+        self.__rw_lock.writer_release()
+
+
+class Reader(threading.Thread):
+    def __init__(self, buffer_, rw_lock, init_sleep_time, sleep_time):
+        """
+        @param buffer_: common buffer shared by the readers and writers
+        @type buffer_: list
+        @type rw_lock: L{RWLock}
+        @param init_sleep_time: sleep time before doing any action
+        @type init_sleep_time: C{float}
+        @param sleep_time: sleep time while in critical section
+        @type sleep_time: C{float}
+        """
+        threading.Thread.__init__(self)
+        self.__buffer = buffer_
+        self.__rw_lock = rw_lock
+        self.__init_sleep_time = init_sleep_time
+        self.__sleep_time = sleep_time
+        self.buffer_read = None
+        """a copy of a the buffer read while in critical section"""
+        self.entry_time = None
+        """Time of entry to the critical section"""
+        self.exit_time = None
+        """Time of exit from the critical section"""
+
+    def run(self):
+        time.sleep(self.__init_sleep_time)
+        self.__rw_lock.reader_acquire()
+        self.entry_time = time.time()
+        time.sleep(self.__sleep_time)
+        self.buffer_read = copy.deepcopy(self.__buffer)
+        self.exit_time = time.time()
+        self.__rw_lock.reader_release()
+
+
+class RWLockTestCase(unittest.TestCase):
+    def test_readers_nonexclusive_access(self):
+        (buffer_, rw_lock, threads) = self.__init_variables()
+
+        threads.append(Reader(buffer_, rw_lock, 0, 0))
+        threads.append(Writer(buffer_, rw_lock, 0.2, 0.4, 1))
+        threads.append(Reader(buffer_, rw_lock, 0.3, 0.3))
+        threads.append(Reader(buffer_, rw_lock, 0.5, 0))
+
+        self.__start_and_join_threads(threads)
+
+        ## The third reader should enter after the second one but it should
+        ## exit before the second one exits
+        ## (i.e. the readers should be in the critical section
+        ## at the same time)
+
+        self.assertEqual([], threads[0].buffer_read)
+        self.assertEqual([1], threads[2].buffer_read)
+        self.assertEqual([1], threads[3].buffer_read)
+        self.assertTrue(threads[1].exit_time <= threads[2].entry_time)
+        self.assertTrue(threads[2].entry_time <= threads[3].entry_time)
+        self.assertTrue(threads[3].exit_time < threads[2].exit_time)
+
+    def test_writers_exclusive_access(self):
+        (buffer_, rw_lock, threads) = self.__init_variables()
+
+        threads.append(Writer(buffer_, rw_lock, 0, 0.4, 1))
+        threads.append(Writer(buffer_, rw_lock, 0.1, 0, 2))
+        threads.append(Reader(buffer_, rw_lock, 0.2, 0))
+
+        self.__start_and_join_threads(threads)
+
+        ## The second writer should wait for the first one to exit
+
+        self.assertEqual([1, 2], threads[2].buffer_read)
+        self.assertTrue(threads[0].exit_time <= threads[1].entry_time)
+        self.assertTrue(threads[1].exit_time <= threads[2].exit_time)
+
+    def test_writer_priority(self):
+        (buffer_, rw_lock, threads) = self.__init_variables()
+
+        threads.append(Writer(buffer_, rw_lock, 0, 0, 1))
+        threads.append(Reader(buffer_, rw_lock, 0.1, 0.4))
+        threads.append(Writer(buffer_, rw_lock, 0.2, 0, 2))
+        threads.append(Reader(buffer_, rw_lock, 0.3, 0))
+        threads.append(Reader(buffer_, rw_lock, 0.3, 0))
+
+        self.__start_and_join_threads(threads)
+
+        ## The second writer should go before the second and the third reader
+
+        self.assertEqual([1], threads[1].buffer_read)
+        self.assertEqual([1, 2], threads[3].buffer_read)
+        self.assertEqual([1, 2], threads[4].buffer_read)
+        self.assertTrue(threads[0].exit_time < threads[1].entry_time)
+        self.assertTrue(threads[1].exit_time <= threads[2].entry_time)
+        self.assertTrue(threads[2].exit_time <= threads[3].entry_time)
+        self.assertTrue(threads[2].exit_time <= threads[4].entry_time)
+
+    def test_many_writers_priority(self):
+        (buffer_, rw_lock, threads) = self.__init_variables()
+
+        threads.append(Writer(buffer_, rw_lock, 0, 0, 1))
+        threads.append(Reader(buffer_, rw_lock, 0.1, 0.6))
+        threads.append(Writer(buffer_, rw_lock, 0.2, 0.1, 2))
+        threads.append(Reader(buffer_, rw_lock, 0.3, 0))
+        threads.append(Reader(buffer_, rw_lock, 0.4, 0))
+        threads.append(Writer(buffer_, rw_lock, 0.5, 0.1, 3))
+
+        self.__start_and_join_threads(threads)
+
+        ## The two last writers should go first -- after the first reader and
+        ## before the second and the third reader
+
+        self.assertEqual([1], threads[1].buffer_read)
+        self.assertEqual([1, 2, 3], threads[3].buffer_read)
+        self.assertEqual([1, 2, 3], threads[4].buffer_read)
+        self.assertTrue(threads[0].exit_time < threads[1].entry_time)
+        self.assertTrue(threads[1].exit_time <= threads[2].entry_time)
+        self.assertTrue(threads[1].exit_time <= threads[5].entry_time)
+        self.assertTrue(threads[2].exit_time <= threads[3].entry_time)
+        self.assertTrue(threads[2].exit_time <= threads[4].entry_time)
+        self.assertTrue(threads[5].exit_time <= threads[3].entry_time)
+        self.assertTrue(threads[5].exit_time <= threads[4].entry_time)
+
+    @staticmethod
+    def __init_variables():
+        buffer_ = []
+        rw_lock = RWLock()
+        threads = []
+        return (buffer_, rw_lock, threads)
+
+    @staticmethod
+    def __start_and_join_threads(threads):
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/test_sha3.py b/myenv/lib/python3.9/site-packages/ecdsa/test_sha3.py
new file mode 100644
index 0000000..2c6bd15
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/test_sha3.py
@@ -0,0 +1,111 @@
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+import pytest
+
+try:
+    from gmpy2 import mpz
+
+    GMPY = True
+except ImportError:
+    try:
+        from gmpy import mpz
+
+        GMPY = True
+    except ImportError:
+        GMPY = False
+
+from ._sha3 import shake_256
+from ._compat import bytes_to_int, int_to_bytes
+
+B2I_VECTORS = [
+    (b"\x00\x01", "big", 1),
+    (b"\x00\x01", "little", 0x0100),
+    (b"", "big", 0),
+    (b"\x00", "little", 0),
+]
+
+
+@pytest.mark.parametrize("bytes_in,endian,int_out", B2I_VECTORS)
+def test_bytes_to_int(bytes_in, endian, int_out):
+    out = bytes_to_int(bytes_in, endian)
+    assert out == int_out
+
+
+class TestBytesToInt(unittest.TestCase):
+    def test_bytes_to_int_wrong_endian(self):
+        with self.assertRaises(ValueError):
+            bytes_to_int(b"\x00", "middle")
+
+    def test_int_to_bytes_wrong_endian(self):
+        with self.assertRaises(ValueError):
+            int_to_bytes(0, byteorder="middle")
+
+
+@pytest.mark.skipif(GMPY == False, reason="requites gmpy or gmpy2")
+def test_int_to_bytes_with_gmpy():
+    assert int_to_bytes(mpz(1)) == b"\x01"
+
+
+I2B_VECTORS = [
+    (0, None, "big", b""),
+    (0, 1, "big", b"\x00"),
+    (1, None, "big", b"\x01"),
+    (0x0100, None, "little", b"\x00\x01"),
+    (0x0100, 4, "little", b"\x00\x01\x00\x00"),
+    (1, 4, "big", b"\x00\x00\x00\x01"),
+]
+
+
+@pytest.mark.parametrize("int_in,length,endian,bytes_out", I2B_VECTORS)
+def test_int_to_bytes(int_in, length, endian, bytes_out):
+    out = int_to_bytes(int_in, length, endian)
+    assert out == bytes_out
+
+
+SHAKE_256_VECTORS = [
+    (
+        b"Message.",
+        32,
+        b"\x78\xa1\x37\xbb\x33\xae\xe2\x72\xb1\x02\x4f\x39\x43\xe5\xcf\x0c"
+        b"\x4e\x9c\x72\x76\x2e\x34\x4c\xf8\xf9\xc3\x25\x9d\x4f\x91\x2c\x3a",
+    ),
+    (
+        b"",
+        32,
+        b"\x46\xb9\xdd\x2b\x0b\xa8\x8d\x13\x23\x3b\x3f\xeb\x74\x3e\xeb\x24"
+        b"\x3f\xcd\x52\xea\x62\xb8\x1b\x82\xb5\x0c\x27\x64\x6e\xd5\x76\x2f",
+    ),
+    (
+        b"message",
+        32,
+        b"\x86\x16\xe1\xe4\xcf\xd8\xb5\xf7\xd9\x2d\x43\xd8\x6e\x1b\x14\x51"
+        b"\xa2\xa6\x5a\xf8\x64\xfc\xb1\x26\xc2\x66\x0a\xb3\x46\x51\xb1\x75",
+    ),
+    (
+        b"message",
+        16,
+        b"\x86\x16\xe1\xe4\xcf\xd8\xb5\xf7\xd9\x2d\x43\xd8\x6e\x1b\x14\x51",
+    ),
+    (
+        b"message",
+        64,
+        b"\x86\x16\xe1\xe4\xcf\xd8\xb5\xf7\xd9\x2d\x43\xd8\x6e\x1b\x14\x51"
+        b"\xa2\xa6\x5a\xf8\x64\xfc\xb1\x26\xc2\x66\x0a\xb3\x46\x51\xb1\x75"
+        b"\x30\xd6\xba\x2a\x46\x65\xf1\x9d\xf0\x62\x25\xb1\x26\xd1\x3e\xed"
+        b"\x91\xd5\x0d\xe7\xb9\xcb\x65\xf3\x3a\x46\xae\xd3\x6c\x7d\xc5\xe8",
+    ),
+    (
+        b"A" * 1024,
+        32,
+        b"\xa5\xef\x7e\x30\x8b\xe8\x33\x64\xe5\x9c\xf3\xb5\xf3\xba\x20\xa3"
+        b"\x5a\xe7\x30\xfd\xbc\x33\x11\xbf\x83\x89\x50\x82\xb4\x41\xe9\xb3",
+    ),
+]
+
+
+@pytest.mark.parametrize("msg,olen,ohash", SHAKE_256_VECTORS)
+def test_shake_256(msg, olen, ohash):
+    out = shake_256(msg, olen)
+    assert out == bytearray(ohash)
diff --git a/myenv/lib/python3.9/site-packages/ecdsa/util.py b/myenv/lib/python3.9/site-packages/ecdsa/util.py
new file mode 100644
index 0000000..9a56110
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/ecdsa/util.py
@@ -0,0 +1,433 @@
+from __future__ import division
+
+import os
+import math
+import binascii
+import sys
+from hashlib import sha256
+from six import PY2, int2byte, b, next
+from . import der
+from ._compat import normalise_bytes
+
+# RFC5480:
+#   The "unrestricted" algorithm identifier is:
+#     id-ecPublicKey OBJECT IDENTIFIER ::= {
+#       iso(1) member-body(2) us(840) ansi-X9-62(10045) keyType(2) 1 }
+
+oid_ecPublicKey = (1, 2, 840, 10045, 2, 1)
+encoded_oid_ecPublicKey = der.encode_oid(*oid_ecPublicKey)
+
+# RFC5480:
+# The ECDH algorithm uses the following object identifier:
+#      id-ecDH OBJECT IDENTIFIER ::= {
+#        iso(1) identified-organization(3) certicom(132) schemes(1)
+#        ecdh(12) }
+
+oid_ecDH = (1, 3, 132, 1, 12)
+
+# RFC5480:
+# The ECMQV algorithm uses the following object identifier:
+#      id-ecMQV OBJECT IDENTIFIER ::= {
+#        iso(1) identified-organization(3) certicom(132) schemes(1)
+#        ecmqv(13) }
+
+oid_ecMQV = (1, 3, 132, 1, 13)
+
+if sys.version_info >= (3,):  # pragma: no branch
+
+    def entropy_to_bits(ent_256):
+        """Convert a bytestring to string of 0's and 1's"""
+        return bin(int.from_bytes(ent_256, "big"))[2:].zfill(len(ent_256) * 8)
+
+else:
+
+    def entropy_to_bits(ent_256):
+        """Convert a bytestring to string of 0's and 1's"""
+        return "".join(bin(ord(x))[2:].zfill(8) for x in ent_256)
+
+
+if sys.version_info < (2, 7):  # pragma: no branch
+    # Can't add a method to a built-in type so we are stuck with this
+    def bit_length(x):
+        return len(bin(x)) - 2
+
+else:
+
+    def bit_length(x):
+        return x.bit_length() or 1
+
+
+def orderlen(order):
+    return (1 + len("%x" % order)) // 2  # bytes
+
+
+def randrange(order, entropy=None):
+    """Return a random integer k such that 1 <= k < order, uniformly
+    distributed across that range. Worst case should be a mean of 2 loops at
+    (2**k)+2.
+
+    Note that this function is not declared to be forwards-compatible: we may
+    change the behavior in future releases. The entropy= argument (which
+    should get a callable that behaves like os.urandom) can be used to
+    achieve stability within a given release (for repeatable unit tests), but
+    should not be used as a long-term-compatible key generation algorithm.
+    """
+    assert order > 1
+    if entropy is None:
+        entropy = os.urandom
+    upper_2 = bit_length(order - 2)
+    upper_256 = upper_2 // 8 + 1
+    while True:  # I don't think this needs a counter with bit-wise randrange
+        ent_256 = entropy(upper_256)
+        ent_2 = entropy_to_bits(ent_256)
+        rand_num = int(ent_2[:upper_2], base=2) + 1
+        if 0 < rand_num < order:
+            return rand_num
+
+
+class PRNG:
+    # this returns a callable which, when invoked with an integer N, will
+    # return N pseudorandom bytes. Note: this is a short-term PRNG, meant
+    # primarily for the needs of randrange_from_seed__trytryagain(), which
+    # only needs to run it a few times per seed. It does not provide
+    # protection against state compromise (forward security).
+    def __init__(self, seed):
+        self.generator = self.block_generator(seed)
+
+    def __call__(self, numbytes):
+        a = [next(self.generator) for i in range(numbytes)]
+
+        if PY2:  # pragma: no branch
+            return "".join(a)
+        else:
+            return bytes(a)
+
+    def block_generator(self, seed):
+        counter = 0
+        while True:
+            for byte in sha256(
+                ("prng-%d-%s" % (counter, seed)).encode()
+            ).digest():
+                yield byte
+            counter += 1
+
+
+def randrange_from_seed__overshoot_modulo(seed, order):
+    # hash the data, then turn the digest into a number in [1,order).
+    #
+    # We use David-Sarah Hopwood's suggestion: turn it into a number that's
+    # sufficiently larger than the group order, then modulo it down to fit.
+    # This should give adequate (but not perfect) uniformity, and simple
+    # code. There are other choices: try-try-again is the main one.
+    base = PRNG(seed)(2 * orderlen(order))
+    number = (int(binascii.hexlify(base), 16) % (order - 1)) + 1
+    assert 1 <= number < order, (1, number, order)
+    return number
+
+
+def lsb_of_ones(numbits):
+    return (1 << numbits) - 1
+
+
+def bits_and_bytes(order):
+    bits = int(math.log(order - 1, 2) + 1)
+    bytes = bits // 8
+    extrabits = bits % 8
+    return bits, bytes, extrabits
+
+
+# the following randrange_from_seed__METHOD() functions take an
+# arbitrarily-sized secret seed and turn it into a number that obeys the same
+# range limits as randrange() above. They are meant for deriving consistent
+# signing keys from a secret rather than generating them randomly, for
+# example a protocol in which three signing keys are derived from a master
+# secret. You should use a uniformly-distributed unguessable seed with about
+# curve.baselen bytes of entropy. To use one, do this:
+#   seed = os.urandom(curve.baselen) # or other starting point
+#   secexp = ecdsa.util.randrange_from_seed__trytryagain(sed, curve.order)
+#   sk = SigningKey.from_secret_exponent(secexp, curve)
+
+
+def randrange_from_seed__truncate_bytes(seed, order, hashmod=sha256):
+    # hash the seed, then turn the digest into a number in [1,order), but
+    # don't worry about trying to uniformly fill the range. This will lose,
+    # on average, four bits of entropy.
+    bits, _bytes, extrabits = bits_and_bytes(order)
+    if extrabits:
+        _bytes += 1
+    base = hashmod(seed).digest()[:_bytes]
+    base = "\x00" * (_bytes - len(base)) + base
+    number = 1 + int(binascii.hexlify(base), 16)
+    assert 1 <= number < order
+    return number
+
+
+def randrange_from_seed__truncate_bits(seed, order, hashmod=sha256):
+    # like string_to_randrange_truncate_bytes, but only lose an average of
+    # half a bit
+    bits = int(math.log(order - 1, 2) + 1)
+    maxbytes = (bits + 7) // 8
+    base = hashmod(seed).digest()[:maxbytes]
+    base = "\x00" * (maxbytes - len(base)) + base
+    topbits = 8 * maxbytes - bits
+    if topbits:
+        base = int2byte(ord(base[0]) & lsb_of_ones(topbits)) + base[1:]
+    number = 1 + int(binascii.hexlify(base), 16)
+    assert 1 <= number < order
+    return number
+
+
+def randrange_from_seed__trytryagain(seed, order):
+    # figure out exactly how many bits we need (rounded up to the nearest
+    # bit), so we can reduce the chance of looping to less than 0.5 . This is
+    # specified to feed from a byte-oriented PRNG, and discards the
+    # high-order bits of the first byte as necessary to get the right number
+    # of bits. The average number of loops will range from 1.0 (when
+    # order=2**k-1) to 2.0 (when order=2**k+1).
+    assert order > 1
+    bits, bytes, extrabits = bits_and_bytes(order)
+    generate = PRNG(seed)
+    while True:
+        extrabyte = b("")
+        if extrabits:
+            extrabyte = int2byte(ord(generate(1)) & lsb_of_ones(extrabits))
+        guess = string_to_number(extrabyte + generate(bytes)) + 1
+        if 1 <= guess < order:
+            return guess
+
+
+def number_to_string(num, order):
+    l = orderlen(order)
+    fmt_str = "%0" + str(2 * l) + "x"
+    string = binascii.unhexlify((fmt_str % num).encode())
+    assert len(string) == l, (len(string), l)
+    return string
+
+
+def number_to_string_crop(num, order):
+    l = orderlen(order)
+    fmt_str = "%0" + str(2 * l) + "x"
+    string = binascii.unhexlify((fmt_str % num).encode())
+    return string[:l]
+
+
+def string_to_number(string):
+    return int(binascii.hexlify(string), 16)
+
+
+def string_to_number_fixedlen(string, order):
+    l = orderlen(order)
+    assert len(string) == l, (len(string), l)
+    return int(binascii.hexlify(string), 16)
+
+
+# these methods are useful for the sigencode= argument to SK.sign() and the
+# sigdecode= argument to VK.verify(), and control how the signature is packed
+# or unpacked.
+
+
+def sigencode_strings(r, s, order):
+    r_str = number_to_string(r, order)
+    s_str = number_to_string(s, order)
+    return (r_str, s_str)
+
+
+def sigencode_string(r, s, order):
+    """
+    Encode the signature to raw format (:term:`raw encoding`)
+
+    It's expected that this function will be used as a `sigencode=` parameter
+    in :func:`ecdsa.keys.SigningKey.sign` method.
+
+    :param int r: first parameter of the signature
+    :param int s: second parameter of the signature
+    :param int order: the order of the curve over which the signature was
+        computed
+
+    :return: raw encoding of ECDSA signature
+    :rtype: bytes
+    """
+    # for any given curve, the size of the signature numbers is
+    # fixed, so just use simple concatenation
+    r_str, s_str = sigencode_strings(r, s, order)
+    return r_str + s_str
+
+
+def sigencode_der(r, s, order):
+    """
+    Encode the signature into the ECDSA-Sig-Value structure using :term:`DER`.
+
+    Encodes the signature to the following :term:`ASN.1` structure::
+
+        Ecdsa-Sig-Value ::= SEQUENCE {
+            r       INTEGER,
+            s       INTEGER
+        }
+
+    It's expected that this function will be used as a `sigencode=` parameter
+    in :func:`ecdsa.keys.SigningKey.sign` method.
+
+    :param int r: first parameter of the signature
+    :param int s: second parameter of the signature
+    :param int order: the order of the curve over which the signature was
+        computed
+
+    :return: DER encoding of ECDSA signature
+    :rtype: bytes
+    """
+    return der.encode_sequence(der.encode_integer(r), der.encode_integer(s))
+
+
+# canonical versions of sigencode methods
+# these enforce low S values, by negating the value (modulo the order) if
+# above order/2 see CECKey::Sign()
+# https://github.com/bitcoin/bitcoin/blob/master/src/key.cpp#L214
+def sigencode_strings_canonize(r, s, order):
+    if s > order / 2:
+        s = order - s
+    return sigencode_strings(r, s, order)
+
+
+def sigencode_string_canonize(r, s, order):
+    if s > order / 2:
+        s = order - s
+    return sigencode_string(r, s, order)
+
+
+def sigencode_der_canonize(r, s, order):
+    if s > order / 2:
+        s = order - s
+    return sigencode_der(r, s, order)
+
+
+class MalformedSignature(Exception):
+    """
+    Raised by decoding functions when the signature is malformed.
+
+    Malformed in this context means that the relevant strings or integers
+    do not match what a signature over provided curve would create. Either
+    because the byte strings have incorrect lengths or because the encoded
+    values are too large.
+    """
+
+    pass
+
+
+def sigdecode_string(signature, order):
+    """
+    Decoder for :term:`raw encoding`  of ECDSA signatures.
+
+    raw encoding is a simple concatenation of the two integers that comprise
+    the signature, with each encoded using the same amount of bytes depending
+    on curve size/order.
+
+    It's expected that this function will be used as the `sigdecode=`
+    parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method.
+
+    :param signature: encoded signature
+    :type signature: bytes like object
+    :param order: order of the curve over which the signature was computed
+    :type order: int
+
+    :raises MalformedSignature: when the encoding of the signature is invalid
+
+    :return: tuple with decoded 'r' and 's' values of signature
+    :rtype: tuple of ints
+    """
+    signature = normalise_bytes(signature)
+    l = orderlen(order)
+    if not len(signature) == 2 * l:
+        raise MalformedSignature(
+            "Invalid length of signature, expected {0} bytes long, "
+            "provided string is {1} bytes long".format(2 * l, len(signature))
+        )
+    r = string_to_number_fixedlen(signature[:l], order)
+    s = string_to_number_fixedlen(signature[l:], order)
+    return r, s
+
+
+def sigdecode_strings(rs_strings, order):
+    """
+    Decode the signature from two strings.
+
+    First string needs to be a big endian encoding of 'r', second needs to
+    be a big endian encoding of the 's' parameter of an ECDSA signature.
+
+    It's expected that this function will be used as the `sigdecode=`
+    parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method.
+
+    :param list rs_strings: list of two bytes-like objects, each encoding one
+        parameter of signature
+    :param int order: order of the curve over which the signature was computed
+
+    :raises MalformedSignature: when the encoding of the signature is invalid
+
+    :return: tuple with decoded 'r' and 's' values of signature
+    :rtype: tuple of ints
+    """
+    if not len(rs_strings) == 2:
+        raise MalformedSignature(
+            "Invalid number of strings provided: {0}, expected 2".format(
+                len(rs_strings)
+            )
+        )
+    (r_str, s_str) = rs_strings
+    r_str = normalise_bytes(r_str)
+    s_str = normalise_bytes(s_str)
+    l = orderlen(order)
+    if not len(r_str) == l:
+        raise MalformedSignature(
+            "Invalid length of first string ('r' parameter), "
+            "expected {0} bytes long, provided string is {1} "
+            "bytes long".format(l, len(r_str))
+        )
+    if not len(s_str) == l:
+        raise MalformedSignature(
+            "Invalid length of second string ('s' parameter), "
+            "expected {0} bytes long, provided string is {1} "
+            "bytes long".format(l, len(s_str))
+        )
+    r = string_to_number_fixedlen(r_str, order)
+    s = string_to_number_fixedlen(s_str, order)
+    return r, s
+
+
+def sigdecode_der(sig_der, order):
+    """
+    Decoder for DER format of ECDSA signatures.
+
+    DER format of signature is one that uses the :term:`ASN.1` :term:`DER`
+    rules to encode it as a sequence of two integers::
+
+        Ecdsa-Sig-Value ::= SEQUENCE {
+            r       INTEGER,
+            s       INTEGER
+        }
+
+    It's expected that this function will be used as as the `sigdecode=`
+    parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method.
+
+    :param sig_der: encoded signature
+    :type sig_der: bytes like object
+    :param order: order of the curve over which the signature was computed
+    :type order: int
+
+    :raises UnexpectedDER: when the encoding of signature is invalid
+
+    :return: tuple with decoded 'r' and 's' values of signature
+    :rtype: tuple of ints
+    """
+    sig_der = normalise_bytes(sig_der)
+    # return der.encode_sequence(der.encode_integer(r), der.encode_integer(s))
+    rs_strings, empty = der.remove_sequence(sig_der)
+    if empty != b"":
+        raise der.UnexpectedDER(
+            "trailing junk after DER sig: %s" % binascii.hexlify(empty)
+        )
+    r, rest = der.remove_integer(rs_strings)
+    s, empty = der.remove_integer(rest)
+    if empty != b"":
+        raise der.UnexpectedDER(
+            "trailing junk after DER numbers: %s" % binascii.hexlify(empty)
+        )
+    return r, s
diff --git a/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/LICENSE
new file mode 100644
index 0000000..3e92463
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Sebastián Ramírez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/METADATA
new file mode 100644
index 0000000..f62f221
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/METADATA
@@ -0,0 +1,545 @@
+Metadata-Version: 2.1
+Name: fastapi
+Version: 0.70.1
+Summary: FastAPI framework, high performance, easy to learn, fast to code, ready for production
+Home-page: https://github.com/tiangolo/fastapi
+Author: Sebastián Ramírez
+Author-email: tiangolo@gmail.com
+Requires-Python: >=3.6.1
+Description-Content-Type: text/markdown
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Dist: starlette ==0.16.0
+Requires-Dist: pydantic >=1.6.2,!=1.7,!=1.7.1,!=1.7.2,!=1.7.3,!=1.8,!=1.8.1,<2.0.0
+Requires-Dist: requests >=2.24.0,<3.0.0 ; extra == "all"
+Requires-Dist: jinja2 >=2.11.2,<4.0.0 ; extra == "all"
+Requires-Dist: python-multipart >=0.0.5,<0.0.6 ; extra == "all"
+Requires-Dist: itsdangerous >=1.1.0,<3.0.0 ; extra == "all"
+Requires-Dist: pyyaml >=5.3.1,<6.0.0 ; extra == "all"
+Requires-Dist: ujson >=4.0.1,<5.0.0 ; extra == "all"
+Requires-Dist: orjson >=3.2.1,<4.0.0 ; extra == "all"
+Requires-Dist: email_validator >=1.1.1,<2.0.0 ; extra == "all"
+Requires-Dist: uvicorn[standard] >=0.12.0,<0.16.0 ; extra == "all"
+Requires-Dist: python-jose[cryptography] >=3.3.0,<4.0.0 ; extra == "dev"
+Requires-Dist: passlib[bcrypt] >=1.7.2,<2.0.0 ; extra == "dev"
+Requires-Dist: autoflake >=1.4.0,<2.0.0 ; extra == "dev"
+Requires-Dist: flake8 >=3.8.3,<4.0.0 ; extra == "dev"
+Requires-Dist: uvicorn[standard] >=0.12.0,<0.16.0 ; extra == "dev"
+Requires-Dist: mkdocs >=1.1.2,<2.0.0 ; extra == "doc"
+Requires-Dist: mkdocs-material >=7.1.9,<8.0.0 ; extra == "doc"
+Requires-Dist: mdx-include >=1.4.1,<2.0.0 ; extra == "doc"
+Requires-Dist: mkdocs-markdownextradata-plugin >=0.1.7,<0.3.0 ; extra == "doc"
+Requires-Dist: typer-cli >=0.0.12,<0.0.13 ; extra == "doc"
+Requires-Dist: pyyaml >=5.3.1,<6.0.0 ; extra == "doc"
+Requires-Dist: pytest >=6.2.4,<7.0.0 ; extra == "test"
+Requires-Dist: pytest-cov >=2.12.0,<4.0.0 ; extra == "test"
+Requires-Dist: mypy ==0.910 ; extra == "test"
+Requires-Dist: flake8 >=3.8.3,<4.0.0 ; extra == "test"
+Requires-Dist: black ==21.9b0 ; extra == "test"
+Requires-Dist: isort >=5.0.6,<6.0.0 ; extra == "test"
+Requires-Dist: requests >=2.24.0,<3.0.0 ; extra == "test"
+Requires-Dist: httpx >=0.14.0,<0.19.0 ; extra == "test"
+Requires-Dist: email_validator >=1.1.1,<2.0.0 ; extra == "test"
+Requires-Dist: sqlalchemy >=1.3.18,<1.5.0 ; extra == "test"
+Requires-Dist: peewee >=3.13.3,<4.0.0 ; extra == "test"
+Requires-Dist: databases[sqlite] >=0.3.2,<0.6.0 ; extra == "test"
+Requires-Dist: orjson >=3.2.1,<4.0.0 ; extra == "test"
+Requires-Dist: ujson >=4.0.1,<5.0.0 ; extra == "test"
+Requires-Dist: python-multipart >=0.0.5,<0.0.6 ; extra == "test"
+Requires-Dist: flask >=1.1.2,<3.0.0 ; extra == "test"
+Requires-Dist: anyio[trio] >=3.2.1,<4.0.0 ; extra == "test"
+Requires-Dist: types-ujson ==0.1.1 ; extra == "test"
+Requires-Dist: types-orjson ==3.6.0 ; extra == "test"
+Requires-Dist: types-dataclasses ==0.1.7 ; extra == "test" and ( python_version<'3.7')
+Project-URL: Documentation, https://fastapi.tiangolo.com/
+Provides-Extra: all
+Provides-Extra: dev
+Provides-Extra: doc
+Provides-Extra: test
+
+<p align="center">
+  <a href="https://fastapi.tiangolo.com"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
+</p>
+<p align="center">
+    <em>FastAPI framework, high performance, easy to learn, fast to code, ready for production</em>
+</p>
+<p align="center">
+<a href="https://github.com/tiangolo/fastapi/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster" target="_blank">
+    <img src="https://github.com/tiangolo/fastapi/workflows/Test/badge.svg?event=push&branch=master" alt="Test">
+</a>
+<a href="https://codecov.io/gh/tiangolo/fastapi" target="_blank">
+    <img src="https://img.shields.io/codecov/c/github/tiangolo/fastapi?color=%2334D058" alt="Coverage">
+</a>
+<a href="https://pypi.org/project/fastapi" target="_blank">
+    <img src="https://img.shields.io/pypi/v/fastapi?color=%2334D058&label=pypi%20package" alt="Package version">
+</a>
+<a href="https://pypi.org/project/fastapi" target="_blank">
+    <img src="https://img.shields.io/pypi/pyversions/fastapi.svg?color=%2334D058" alt="Supported Python versions">
+</a>
+</p>
+
+---
+
+**Documentation**: <a href="https://fastapi.tiangolo.com" target="_blank">https://fastapi.tiangolo.com</a>
+
+**Source Code**: <a href="https://github.com/tiangolo/fastapi" target="_blank">https://github.com/tiangolo/fastapi</a>
+
+---
+
+FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.
+
+The key features are:
+
+* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
+
+* **Fast to code**: Increase the speed to develop features by about 200% to 300%. *
+* **Fewer bugs**: Reduce about 40% of human (developer) induced errors. *
+* **Intuitive**: Great editor support. <abbr title="also known as auto-complete, autocompletion, IntelliSense">Completion</abbr> everywhere. Less time debugging.
+* **Easy**: Designed to be easy to use and learn. Less time reading docs.
+* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
+* **Robust**: Get production-ready code. With automatic interactive documentation.
+* **Standards-based**: Based on (and fully compatible with) the open standards for APIs: <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (previously known as Swagger) and <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
+
+<small>* estimation based on tests on an internal development team, building production applications.</small>
+
+## Sponsors
+
+<!-- sponsors -->
+
+<a href="https://bit.ly/2QSouzH" target="_blank" title="Jina: build neural search-as-a-service for any kind of data in just minutes."><img src="https://fastapi.tiangolo.com/img/sponsors/jina.svg"></a>
+<a href="https://cryptapi.io/" target="_blank" title="CryptAPI: Your easy to use, secure and privacy oriented payment gateway."><img src="https://fastapi.tiangolo.com/img/sponsors/cryptapi.svg"></a>
+<a href="https://www.deta.sh/?ref=fastapi" target="_blank" title="The launchpad for all your (team's) ideas"><img src="https://fastapi.tiangolo.com/img/sponsors/deta.svg"></a>
+<a href="https://www.investsuite.com/jobs" target="_blank" title="Wealthtech jobs with FastAPI"><img src="https://fastapi.tiangolo.com/img/sponsors/investsuite.svg"></a>
+<a href="https://www.vim.so/?utm_source=FastAPI" target="_blank" title="We help you master vim with interactive exercises"><img src="https://fastapi.tiangolo.com/img/sponsors/vimso.png"></a>
+<a href="https://talkpython.fm/fastapi-sponsor" target="_blank" title="FastAPI video courses on demand from people you trust"><img src="https://fastapi.tiangolo.com/img/sponsors/talkpython.png"></a>
+<a href="https://testdriven.io/courses/tdd-fastapi/" target="_blank" title="Learn to build high-quality web apps with best practices"><img src="https://fastapi.tiangolo.com/img/sponsors/testdriven.svg"></a>
+<a href="https://github.com/deepset-ai/haystack/" target="_blank" title="Build powerful search from composable, open source building blocks"><img src="https://fastapi.tiangolo.com/img/sponsors/haystack-fastapi.svg"></a>
+
+<!-- /sponsors -->
+
+<a href="https://fastapi.tiangolo.com/fastapi-people/#sponsors" class="external-link" target="_blank">Other sponsors</a>
+
+## Opinions
+
+"_[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products._"
+
+<div style="text-align: right; margin-right: 10%;">Kabir Khan - <strong>Microsoft</strong> <a href="https://github.com/tiangolo/fastapi/pull/26" target="_blank"><small>(ref)</small></a></div>
+
+---
+
+"_We adopted the **FastAPI** library to spawn a **REST** server that can be queried to obtain **predictions**. [for Ludwig]_"
+
+<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/" target="_blank"><small>(ref)</small></a></div>
+
+---
+
+"_**Netflix** is pleased to announce the open-source release of our **crisis management** orchestration framework: **Dispatch**! [built with **FastAPI**]_"
+
+<div style="text-align: right; margin-right: 10%;">Kevin Glisson, Marc Vilanova, Forest Monsen - <strong>Netflix</strong> <a href="https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072" target="_blank"><small>(ref)</small></a></div>
+
+---
+
+"_I’m over the moon excited about **FastAPI**. It’s so fun!_"
+
+<div style="text-align: right; margin-right: 10%;">Brian Okken - <strong><a href="https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855" target="_blank">Python Bytes</a> podcast host</strong> <a href="https://twitter.com/brianokken/status/1112220079972728832" target="_blank"><small>(ref)</small></a></div>
+
+---
+
+"_Honestly, what you've built looks super solid and polished. In many ways, it's what I wanted **Hug** to be - it's really inspiring to see someone build that._"
+
+<div style="text-align: right; margin-right: 10%;">Timothy Crosley - <strong><a href="https://www.hug.rest/" target="_blank">Hug</a> creator</strong> <a href="https://news.ycombinator.com/item?id=19455465" target="_blank"><small>(ref)</small></a></div>
+
+---
+
+"_If you're looking to learn one **modern framework** for building REST APIs, check out **FastAPI** [...] It's fast, easy to use and easy to learn [...]_"
+
+"_We've switched over to **FastAPI** for our **APIs** [...] I think you'll like it [...]_"
+
+<div style="text-align: right; margin-right: 10%;">Ines Montani - Matthew Honnibal - <strong><a href="https://explosion.ai" target="_blank">Explosion AI</a> founders - <a href="https://spacy.io" target="_blank">spaCy</a> creators</strong> <a href="https://twitter.com/_inesmontani/status/1144173225322143744" target="_blank"><small>(ref)</small></a> - <a href="https://twitter.com/honnibal/status/1144031421859655680" target="_blank"><small>(ref)</small></a></div>
+
+---
+
+## **Typer**, the FastAPI of CLIs
+
+<a href="https://typer.tiangolo.com" target="_blank"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
+
+If you are building a <abbr title="Command Line Interface">CLI</abbr> app to be used in the terminal instead of a web API, check out <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
+
+**Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀
+
+## Requirements
+
+Python 3.6+
+
+FastAPI stands on the shoulders of giants:
+
+* <a href="https://www.starlette.io/" class="external-link" target="_blank">Starlette</a> for the web parts.
+* <a href="https://pydantic-docs.helpmanual.io/" class="external-link" target="_blank">Pydantic</a> for the data parts.
+
+## Installation
+
+<div class="termy">
+
+```console
+$ pip install fastapi
+
+---> 100%
+```
+
+</div>
+
+You will also need an ASGI server, for production such as <a href="https://www.uvicorn.org" class="external-link" target="_blank">Uvicorn</a> or <a href="https://gitlab.com/pgjones/hypercorn" class="external-link" target="_blank">Hypercorn</a>.
+
+<div class="termy">
+
+```console
+$ pip install "uvicorn[standard]"
+
+---> 100%
+```
+
+</div>
+
+## Example
+
+### Create it
+
+* Create a file `main.py` with:
+
+```Python
+from typing import Optional
+
+from fastapi import FastAPI
+
+app = FastAPI()
+
+
+@app.get("/")
+def read_root():
+    return {"Hello": "World"}
+
+
+@app.get("/items/{item_id}")
+def read_item(item_id: int, q: Optional[str] = None):
+    return {"item_id": item_id, "q": q}
+```
+
+<details markdown="1">
+<summary>Or use <code>async def</code>...</summary>
+
+If your code uses `async` / `await`, use `async def`:
+
+```Python hl_lines="9  14"
+from typing import Optional
+
+from fastapi import FastAPI
+
+app = FastAPI()
+
+
+@app.get("/")
+async def read_root():
+    return {"Hello": "World"}
+
+
+@app.get("/items/{item_id}")
+async def read_item(item_id: int, q: Optional[str] = None):
+    return {"item_id": item_id, "q": q}
+```
+
+**Note**:
+
+If you don't know, check the _"In a hurry?"_ section about <a href="https://fastapi.tiangolo.com/async/#in-a-hurry" target="_blank">`async` and `await` in the docs</a>.
+
+</details>
+
+### Run it
+
+Run the server with:
+
+<div class="termy">
+
+```console
+$ uvicorn main:app --reload
+
+INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+INFO:     Started reloader process [28720]
+INFO:     Started server process [28722]
+INFO:     Waiting for application startup.
+INFO:     Application startup complete.
+```
+
+</div>
+
+<details markdown="1">
+<summary>About the command <code>uvicorn main:app --reload</code>...</summary>
+
+The command `uvicorn main:app` refers to:
+
+* `main`: the file `main.py` (the Python "module").
+* `app`: the object created inside of `main.py` with the line `app = FastAPI()`.
+* `--reload`: make the server restart after code changes. Only do this for development.
+
+</details>
+
+### Check it
+
+Open your browser at <a href="http://127.0.0.1:8000/items/5?q=somequery" class="external-link" target="_blank">http://127.0.0.1:8000/items/5?q=somequery</a>.
+
+You will see the JSON response as:
+
+```JSON
+{"item_id": 5, "q": "somequery"}
+```
+
+You already created an API that:
+
+* Receives HTTP requests in the _paths_ `/` and `/items/{item_id}`.
+* Both _paths_ take `GET` <em>operations</em> (also known as HTTP _methods_).
+* The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`.
+* The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`.
+
+### Interactive API docs
+
+Now go to <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+
+You will see the automatic interactive API documentation (provided by <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>):
+
+![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
+
+### Alternative API docs
+
+And now, go to <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
+
+You will see the alternative automatic documentation (provided by <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>):
+
+![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
+
+## Example upgrade
+
+Now modify the file `main.py` to receive a body from a `PUT` request.
+
+Declare the body using standard Python types, thanks to Pydantic.
+
+```Python hl_lines="4  9-12  25-27"
+from typing import Optional
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+    name: str
+    price: float
+    is_offer: Optional[bool] = None
+
+
+@app.get("/")
+def read_root():
+    return {"Hello": "World"}
+
+
+@app.get("/items/{item_id}")
+def read_item(item_id: int, q: Optional[str] = None):
+    return {"item_id": item_id, "q": q}
+
+
+@app.put("/items/{item_id}")
+def update_item(item_id: int, item: Item):
+    return {"item_name": item.name, "item_id": item_id}
+```
+
+The server should reload automatically (because you added `--reload` to the `uvicorn` command above).
+
+### Interactive API docs upgrade
+
+Now go to <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+
+* The interactive API documentation will be automatically updated, including the new body:
+
+![Swagger UI](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)
+
+* Click on the button "Try it out", it allows you to fill the parameters and directly interact with the API:
+
+![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-04-swagger-03.png)
+
+* Then click on the "Execute" button, the user interface will communicate with your API, send the parameters, get the results and show them on the screen:
+
+![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-05-swagger-04.png)
+
+### Alternative API docs upgrade
+
+And now, go to <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
+
+* The alternative documentation will also reflect the new query parameter and body:
+
+![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
+
+### Recap
+
+In summary, you declare **once** the types of parameters, body, etc. as function parameters.
+
+You do that with standard modern Python types.
+
+You don't have to learn a new syntax, the methods or classes of a specific library, etc.
+
+Just standard **Python 3.6+**.
+
+For example, for an `int`:
+
+```Python
+item_id: int
+```
+
+or for a more complex `Item` model:
+
+```Python
+item: Item
+```
+
+...and with that single declaration you get:
+
+* Editor support, including:
+    * Completion.
+    * Type checks.
+* Validation of data:
+    * Automatic and clear errors when the data is invalid.
+    * Validation even for deeply nested JSON objects.
+* <abbr title="also known as: serialization, parsing, marshalling">Conversion</abbr> of input data: coming from the network to Python data and types. Reading from:
+    * JSON.
+    * Path parameters.
+    * Query parameters.
+    * Cookies.
+    * Headers.
+    * Forms.
+    * Files.
+* <abbr title="also known as: serialization, parsing, marshalling">Conversion</abbr> of output data: converting from Python data and types to network data (as JSON):
+    * Convert Python types (`str`, `int`, `float`, `bool`, `list`, etc).
+    * `datetime` objects.
+    * `UUID` objects.
+    * Database models.
+    * ...and many more.
+* Automatic interactive API documentation, including 2 alternative user interfaces:
+    * Swagger UI.
+    * ReDoc.
+
+---
+
+Coming back to the previous code example, **FastAPI** will:
+
+* Validate that there is an `item_id` in the path for `GET` and `PUT` requests.
+* Validate that the `item_id` is of type `int` for `GET` and `PUT` requests.
+    * If it is not, the client will see a useful, clear error.
+* Check if there is an optional query parameter named `q` (as in `http://127.0.0.1:8000/items/foo?q=somequery`) for `GET` requests.
+    * As the `q` parameter is declared with `= None`, it is optional.
+    * Without the `None` it would be required (as is the body in the case with `PUT`).
+* For `PUT` requests to `/items/{item_id}`, Read the body as JSON:
+    * Check that it has a required attribute `name` that should be a `str`.
+    * Check that it has a required attribute `price` that has to be a `float`.
+    * Check that it has an optional attribute `is_offer`, that should be a `bool`, if present.
+    * All this would also work for deeply nested JSON objects.
+* Convert from and to JSON automatically.
+* Document everything with OpenAPI, that can be used by:
+    * Interactive documentation systems.
+    * Automatic client code generation systems, for many languages.
+* Provide 2 interactive documentation web interfaces directly.
+
+---
+
+We just scratched the surface, but you already get the idea of how it all works.
+
+Try changing the line with:
+
+```Python
+    return {"item_name": item.name, "item_id": item_id}
+```
+
+...from:
+
+```Python
+        ... "item_name": item.name ...
+```
+
+...to:
+
+```Python
+        ... "item_price": item.price ...
+```
+
+...and see how your editor will auto-complete the attributes and know their types:
+
+![editor support](https://fastapi.tiangolo.com/img/vscode-completion.png)
+
+For a more complete example including more features, see the <a href="https://fastapi.tiangolo.com/tutorial/">Tutorial - User Guide</a>.
+
+**Spoiler alert**: the tutorial - user guide includes:
+
+* Declaration of **parameters** from other different places as: **headers**, **cookies**, **form fields** and **files**.
+* How to set **validation constraints** as `maximum_length` or `regex`.
+* A very powerful and easy to use **<abbr title="also known as components, resources, providers, services, injectables">Dependency Injection</abbr>** system.
+* Security and authentication, including support for **OAuth2** with **JWT tokens** and **HTTP Basic** auth.
+* More advanced (but equally easy) techniques for declaring **deeply nested JSON models** (thanks to Pydantic).
+* **GraphQL** integration with <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> and other libraries.
+* Many extra features (thanks to Starlette) as:
+    * **WebSockets**
+    * extremely easy tests based on `requests` and `pytest`
+    * **CORS**
+    * **Cookie Sessions**
+    * ...and more.
+
+## Performance
+
+Independent TechEmpower benchmarks show **FastAPI** applications running under Uvicorn as <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">one of the fastest Python frameworks available</a>, only below Starlette and Uvicorn themselves (used internally by FastAPI). (*)
+
+To understand more about it, see the section <a href="https://fastapi.tiangolo.com/benchmarks/" class="internal-link" target="_blank">Benchmarks</a>.
+
+## Optional Dependencies
+
+Used by Pydantic:
+
+* <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - for faster JSON <abbr title="converting the string that comes from an HTTP request into Python data">"parsing"</abbr>.
+* <a href="https://github.com/JoshData/python-email-validator" target="_blank"><code>email_validator</code></a> - for email validation.
+
+Used by Starlette:
+
+* <a href="https://requests.readthedocs.io" target="_blank"><code>requests</code></a> - Required if you want to use the `TestClient`.
+* <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - Required if you want to use the default template configuration.
+* <a href="https://andrew-d.github.io/python-multipart/" target="_blank"><code>python-multipart</code></a> - Required if you want to support form <abbr title="converting the string that comes from an HTTP request into Python data">"parsing"</abbr>, with `request.form()`.
+* <a href="https://pythonhosted.org/itsdangerous/" target="_blank"><code>itsdangerous</code></a> - Required for `SessionMiddleware` support.
+* <a href="https://pyyaml.org/wiki/PyYAMLDocumentation" target="_blank"><code>pyyaml</code></a> - Required for Starlette's `SchemaGenerator` support (you probably don't need it with FastAPI).
+* <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - Required if you want to use `UJSONResponse`.
+
+Used by FastAPI / Starlette:
+
+* <a href="https://www.uvicorn.org" target="_blank"><code>uvicorn</code></a> - for the server that loads and serves your application.
+* <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - Required if you want to use `ORJSONResponse`.
+
+You can install all of these with `pip install "fastapi[all]"`.
+
+## License
+
+This project is licensed under the terms of the MIT license.
+
diff --git a/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/RECORD
new file mode 100644
index 0000000..2c0634f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/RECORD
@@ -0,0 +1,47 @@
+fastapi/__init__.py,sha256=DCuKSRU6kaM12G9kTSa1GBVYftxLI99U7UEYvvMI3zs,1015
+fastapi/applications.py,sha256=3_VBHSCd8FoA0sTWLltGbo0sYZgyiZeiYablU6ENzkg,33127
+fastapi/background.py,sha256=HtN5_pJJrOdalSbuGSMKJAPNWUU5h7rY_BXXubu7-IQ,76
+fastapi/concurrency.py,sha256=ne71p0K426vPxvI0_H7mcs3nr2_8lkXyvEIfbHZiCXg,1072
+fastapi/datastructures.py,sha256=5wDaZ4-54n1xL-cjDgMdw9aLqhihpuVQRTOT5XUi8x4,1743
+fastapi/encoders.py,sha256=VJDILyb8fVE69aCK-x3lMT3mrxTHSgmXqvO2okTqUoY,5380
+fastapi/exception_handlers.py,sha256=UVYCCe4qt5-5_NuQ3SxTXjDvOdKMHiTfcLp3RUKXhg8,912
+fastapi/exceptions.py,sha256=8B4f4gmHUVaX04L9IxxfEbUzX6OhJy4y6-utQbqNX0Q,1131
+fastapi/logger.py,sha256=I9NNi3ov8AcqbsbC9wl1X-hdItKgYt2XTrx1f99Zpl4,54
+fastapi/param_functions.py,sha256=XQZKy9q-1LFLupDdiBnqX2G_06q7QqYotyk9b1Ke6XM,7065
+fastapi/params.py,sha256=4JTDim09Sb1K2wS_Y9j0vsPqJzvjwbLWaavBTeV6bJM,10017
+fastapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi/requests.py,sha256=zayepKFcienBllv3snmWI20Gk0oHNVLU4DDhqXBb4LU,142
+fastapi/responses.py,sha256=K9Gzj0E5GfwTgLiuCE-BuiXn9JdqGJHeXBMkvd8lFC8,1196
+fastapi/routing.py,sha256=GZtad4pK9SqCsUdLsukl3JwGrZAJEPohMsu-8cutNa4,49671
+fastapi/staticfiles.py,sha256=iirGIt3sdY2QZXd36ijs3Cj-T0FuGFda3cd90kM9Ikw,69
+fastapi/templating.py,sha256=4zsuTWgcjcEainMJFAlW6-gnslm6AgOS1SiiDWfmQxk,76
+fastapi/testclient.py,sha256=nBvaAmX66YldReJNZXPOk1sfuo2Q6hs8bOvIaCep6LQ,66
+fastapi/types.py,sha256=r6MngTHzkZOP9lzXgduje9yeZe5EInWAzCLuRJlhIuE,118
+fastapi/utils.py,sha256=g_H9Owy8vbUgY_L4tfYBJRdX9ofIqKPXkhh0LTRLRYE,5545
+fastapi/websockets.py,sha256=SroIkqE-lfChvtRP3mFaNKKtD6TmePDWBZtQfgM4noo,148
+fastapi/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi/dependencies/models.py,sha256=zNbioxICuOeb-9ADDVQ45hUHOC0PBtPVEfVU3f1l_nc,2494
+fastapi/dependencies/utils.py,sha256=AExSzce8f0SL383fLuV1WN91NL33AT63E8iwK0_HJcs,28054
+fastapi/middleware/__init__.py,sha256=oQDxiFVcc1fYJUOIFvphnK7pTT5kktmfL32QXpBFvvo,58
+fastapi/middleware/cors.py,sha256=ynwjWQZoc_vbhzZ3_ZXceoaSrslHFHPdoM52rXr0WUU,79
+fastapi/middleware/gzip.py,sha256=xM5PcsH8QlAimZw4VDvcmTnqQamslThsfe3CVN2voa0,79
+fastapi/middleware/httpsredirect.py,sha256=rL8eXMnmLijwVkH7_400zHri1AekfeBd6D6qs8ix950,115
+fastapi/middleware/trustedhost.py,sha256=eE5XGRxGa7c5zPnMJDGp3BxaL25k5iVQlhnv-Pk0Pss,109
+fastapi/middleware/wsgi.py,sha256=Z3Ue-7wni4lUZMvH3G9ek__acgYdJstbnpZX_HQAboY,79
+fastapi/openapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi/openapi/constants.py,sha256=sJSpZzRp7Kky9R-jucU-K6_pJzLBRO75ddW7-MixZWc,166
+fastapi/openapi/docs.py,sha256=XyDQ4t2Ca95ZN_sSfwjCP3DcwM5Rv21FrwqTfk4x_H4,5538
+fastapi/openapi/models.py,sha256=iGtr1Xk5limukAi7JCW7-wRcasVJMc7M8y-2hRDH0xo,10936
+fastapi/openapi/utils.py,sha256=k26LXwhzG21w5VspJbi9FtZqs5_0Oqv2eQpWgG2c4Kk,17276
+fastapi/security/__init__.py,sha256=bO8pNmxqVRXUjfl2mOKiVZLn0FpBQ61VUYVjmppnbJw,881
+fastapi/security/api_key.py,sha256=NbVpS9TxDOaipoZa8-SREHyMtTcM3bmy5szMiQxEX9s,2793
+fastapi/security/base.py,sha256=dl4pvbC-RxjfbWgPtCWd8MVU-7CB2SZ22rJDXVCXO6c,141
+fastapi/security/http.py,sha256=ZSy3DFKFDLa3-I4vwsY1r8hQB_VrtAXw4-fMJauZIK0,5984
+fastapi/security/oauth2.py,sha256=xkbUW0b-G4aiEhSO7BZyE7iAdYK41cXB-SL1MnQvBh4,8183
+fastapi/security/open_id_connect_url.py,sha256=iikzuJCz_DG44Q77VrupqSoCbJYaiXkuo_W-kdmAzeo,1145
+fastapi/security/utils.py,sha256=izlh-HBaL1VnJeOeRTQnyNgI3hgTFs73eCyLy-snb4A,266
+fastapi-0.70.1.dist-info/LICENSE,sha256=Tsif_IFIW5f-xYSy1KlhAy7v_oNEU4lP2cEnSQbMdE4,1086
+fastapi-0.70.1.dist-info/WHEEL,sha256=LVOPL_YDMEiGvRLgDK1hLkfhFCnTcxcAYZJtpNFses0,81
+fastapi-0.70.1.dist-info/METADATA,sha256=9cgceXBWBzPlk7u9YLK_GC4jKNmJDGe18UPIhmJvK_A,24068
+fastapi-0.70.1.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+fastapi-0.70.1.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/WHEEL
new file mode 100644
index 0000000..884ceb5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi-0.70.1.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.5.1
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/myenv/lib/python3.9/site-packages/fastapi/__init__.py b/myenv/lib/python3.9/site-packages/fastapi/__init__.py
new file mode 100644
index 0000000..8bb6ce1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/__init__.py
@@ -0,0 +1,24 @@
+"""FastAPI framework, high performance, easy to learn, fast to code, ready for production"""
+
+__version__ = "0.70.1"
+
+from starlette import status as status
+
+from .applications import FastAPI as FastAPI
+from .background import BackgroundTasks as BackgroundTasks
+from .datastructures import UploadFile as UploadFile
+from .exceptions import HTTPException as HTTPException
+from .param_functions import Body as Body
+from .param_functions import Cookie as Cookie
+from .param_functions import Depends as Depends
+from .param_functions import File as File
+from .param_functions import Form as Form
+from .param_functions import Header as Header
+from .param_functions import Path as Path
+from .param_functions import Query as Query
+from .param_functions import Security as Security
+from .requests import Request as Request
+from .responses import Response as Response
+from .routing import APIRouter as APIRouter
+from .websockets import WebSocket as WebSocket
+from .websockets import WebSocketDisconnect as WebSocketDisconnect
diff --git a/myenv/lib/python3.9/site-packages/fastapi/applications.py b/myenv/lib/python3.9/site-packages/fastapi/applications.py
new file mode 100644
index 0000000..0c25026
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/applications.py
@@ -0,0 +1,768 @@
+from typing import Any, Callable, Coroutine, Dict, List, Optional, Sequence, Type, Union
+
+from fastapi import routing
+from fastapi.concurrency import AsyncExitStack
+from fastapi.datastructures import Default, DefaultPlaceholder
+from fastapi.encoders import DictIntStrAny, SetIntStr
+from fastapi.exception_handlers import (
+    http_exception_handler,
+    request_validation_exception_handler,
+)
+from fastapi.exceptions import RequestValidationError
+from fastapi.logger import logger
+from fastapi.openapi.docs import (
+    get_redoc_html,
+    get_swagger_ui_html,
+    get_swagger_ui_oauth2_redirect_html,
+)
+from fastapi.openapi.utils import get_openapi
+from fastapi.params import Depends
+from fastapi.types import DecoratedCallable
+from starlette.applications import Starlette
+from starlette.datastructures import State
+from starlette.exceptions import HTTPException
+from starlette.middleware import Middleware
+from starlette.requests import Request
+from starlette.responses import HTMLResponse, JSONResponse, Response
+from starlette.routing import BaseRoute
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+
+class FastAPI(Starlette):
+    def __init__(
+        self,
+        *,
+        debug: bool = False,
+        routes: Optional[List[BaseRoute]] = None,
+        title: str = "FastAPI",
+        description: str = "",
+        version: str = "0.1.0",
+        openapi_url: Optional[str] = "/openapi.json",
+        openapi_tags: Optional[List[Dict[str, Any]]] = None,
+        servers: Optional[List[Dict[str, Union[str, Any]]]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        default_response_class: Type[Response] = Default(JSONResponse),
+        docs_url: Optional[str] = "/docs",
+        redoc_url: Optional[str] = "/redoc",
+        swagger_ui_oauth2_redirect_url: Optional[str] = "/docs/oauth2-redirect",
+        swagger_ui_init_oauth: Optional[Dict[str, Any]] = None,
+        middleware: Optional[Sequence[Middleware]] = None,
+        exception_handlers: Optional[
+            Dict[
+                Union[int, Type[Exception]],
+                Callable[[Request, Any], Coroutine[Any, Any, Response]],
+            ]
+        ] = None,
+        on_startup: Optional[Sequence[Callable[[], Any]]] = None,
+        on_shutdown: Optional[Sequence[Callable[[], Any]]] = None,
+        terms_of_service: Optional[str] = None,
+        contact: Optional[Dict[str, Union[str, Any]]] = None,
+        license_info: Optional[Dict[str, Union[str, Any]]] = None,
+        openapi_prefix: str = "",
+        root_path: str = "",
+        root_path_in_servers: bool = True,
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        deprecated: Optional[bool] = None,
+        include_in_schema: bool = True,
+        **extra: Any,
+    ) -> None:
+        self._debug: bool = debug
+        self.state: State = State()
+        self.router: routing.APIRouter = routing.APIRouter(
+            routes=routes,
+            dependency_overrides_provider=self,
+            on_startup=on_startup,
+            on_shutdown=on_shutdown,
+            default_response_class=default_response_class,
+            dependencies=dependencies,
+            callbacks=callbacks,
+            deprecated=deprecated,
+            include_in_schema=include_in_schema,
+            responses=responses,
+        )
+        self.exception_handlers: Dict[
+            Union[int, Type[Exception]],
+            Callable[[Request, Any], Coroutine[Any, Any, Response]],
+        ] = (
+            {} if exception_handlers is None else dict(exception_handlers)
+        )
+        self.exception_handlers.setdefault(HTTPException, http_exception_handler)
+        self.exception_handlers.setdefault(
+            RequestValidationError, request_validation_exception_handler
+        )
+
+        self.user_middleware: List[Middleware] = (
+            [] if middleware is None else list(middleware)
+        )
+        self.middleware_stack: ASGIApp = self.build_middleware_stack()
+
+        self.title = title
+        self.description = description
+        self.version = version
+        self.terms_of_service = terms_of_service
+        self.contact = contact
+        self.license_info = license_info
+        self.servers = servers or []
+        self.openapi_url = openapi_url
+        self.openapi_tags = openapi_tags
+        # TODO: remove when discarding the openapi_prefix parameter
+        if openapi_prefix:
+            logger.warning(
+                '"openapi_prefix" has been deprecated in favor of "root_path", which '
+                "follows more closely the ASGI standard, is simpler, and more "
+                "automatic. Check the docs at "
+                "https://fastapi.tiangolo.com/advanced/sub-applications/"
+            )
+        self.root_path = root_path or openapi_prefix
+        self.root_path_in_servers = root_path_in_servers
+        self.docs_url = docs_url
+        self.redoc_url = redoc_url
+        self.swagger_ui_oauth2_redirect_url = swagger_ui_oauth2_redirect_url
+        self.swagger_ui_init_oauth = swagger_ui_init_oauth
+        self.extra = extra
+        self.dependency_overrides: Dict[Callable[..., Any], Callable[..., Any]] = {}
+
+        self.openapi_version = "3.0.2"
+
+        if self.openapi_url:
+            assert self.title, "A title must be provided for OpenAPI, e.g.: 'My API'"
+            assert self.version, "A version must be provided for OpenAPI, e.g.: '2.1.0'"
+        self.openapi_schema: Optional[Dict[str, Any]] = None
+        self.setup()
+
+    def openapi(self) -> Dict[str, Any]:
+        if not self.openapi_schema:
+            self.openapi_schema = get_openapi(
+                title=self.title,
+                version=self.version,
+                openapi_version=self.openapi_version,
+                description=self.description,
+                terms_of_service=self.terms_of_service,
+                contact=self.contact,
+                license_info=self.license_info,
+                routes=self.routes,
+                tags=self.openapi_tags,
+                servers=self.servers,
+            )
+        return self.openapi_schema
+
+    def setup(self) -> None:
+        if self.openapi_url:
+            urls = (server_data.get("url") for server_data in self.servers)
+            server_urls = {url for url in urls if url}
+
+            async def openapi(req: Request) -> JSONResponse:
+                root_path = req.scope.get("root_path", "").rstrip("/")
+                if root_path not in server_urls:
+                    if root_path and self.root_path_in_servers:
+                        self.servers.insert(0, {"url": root_path})
+                        server_urls.add(root_path)
+                return JSONResponse(self.openapi())
+
+            self.add_route(self.openapi_url, openapi, include_in_schema=False)
+        if self.openapi_url and self.docs_url:
+
+            async def swagger_ui_html(req: Request) -> HTMLResponse:
+                root_path = req.scope.get("root_path", "").rstrip("/")
+                openapi_url = root_path + self.openapi_url
+                oauth2_redirect_url = self.swagger_ui_oauth2_redirect_url
+                if oauth2_redirect_url:
+                    oauth2_redirect_url = root_path + oauth2_redirect_url
+                return get_swagger_ui_html(
+                    openapi_url=openapi_url,
+                    title=self.title + " - Swagger UI",
+                    oauth2_redirect_url=oauth2_redirect_url,
+                    init_oauth=self.swagger_ui_init_oauth,
+                )
+
+            self.add_route(self.docs_url, swagger_ui_html, include_in_schema=False)
+
+            if self.swagger_ui_oauth2_redirect_url:
+
+                async def swagger_ui_redirect(req: Request) -> HTMLResponse:
+                    return get_swagger_ui_oauth2_redirect_html()
+
+                self.add_route(
+                    self.swagger_ui_oauth2_redirect_url,
+                    swagger_ui_redirect,
+                    include_in_schema=False,
+                )
+        if self.openapi_url and self.redoc_url:
+
+            async def redoc_html(req: Request) -> HTMLResponse:
+                root_path = req.scope.get("root_path", "").rstrip("/")
+                openapi_url = root_path + self.openapi_url
+                return get_redoc_html(
+                    openapi_url=openapi_url, title=self.title + " - ReDoc"
+                )
+
+            self.add_route(self.redoc_url, redoc_html, include_in_schema=False)
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if self.root_path:
+            scope["root_path"] = self.root_path
+        if AsyncExitStack:
+            async with AsyncExitStack() as stack:
+                scope["fastapi_astack"] = stack
+                await super().__call__(scope, receive, send)
+        else:
+            await super().__call__(scope, receive, send)  # pragma: no cover
+
+    def add_api_route(
+        self,
+        path: str,
+        endpoint: Callable[..., Coroutine[Any, Any, Response]],
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        methods: Optional[List[str]] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Union[Type[Response], DefaultPlaceholder] = Default(
+            JSONResponse
+        ),
+        name: Optional[str] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.router.add_api_route(
+            path,
+            endpoint=endpoint,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            methods=methods,
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            openapi_extra=openapi_extra,
+        )
+
+    def api_route(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        methods: Optional[List[str]] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        def decorator(func: DecoratedCallable) -> DecoratedCallable:
+            self.router.add_api_route(
+                path,
+                func,
+                response_model=response_model,
+                status_code=status_code,
+                tags=tags,
+                dependencies=dependencies,
+                summary=summary,
+                description=description,
+                response_description=response_description,
+                responses=responses,
+                deprecated=deprecated,
+                methods=methods,
+                operation_id=operation_id,
+                response_model_include=response_model_include,
+                response_model_exclude=response_model_exclude,
+                response_model_by_alias=response_model_by_alias,
+                response_model_exclude_unset=response_model_exclude_unset,
+                response_model_exclude_defaults=response_model_exclude_defaults,
+                response_model_exclude_none=response_model_exclude_none,
+                include_in_schema=include_in_schema,
+                response_class=response_class,
+                name=name,
+                openapi_extra=openapi_extra,
+            )
+            return func
+
+        return decorator
+
+    def add_api_websocket_route(
+        self, path: str, endpoint: Callable[..., Any], name: Optional[str] = None
+    ) -> None:
+        self.router.add_api_websocket_route(path, endpoint, name=name)
+
+    def websocket(
+        self, path: str, name: Optional[str] = None
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        def decorator(func: DecoratedCallable) -> DecoratedCallable:
+            self.add_api_websocket_route(path, func, name=name)
+            return func
+
+        return decorator
+
+    def include_router(
+        self,
+        router: routing.APIRouter,
+        *,
+        prefix: str = "",
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        include_in_schema: bool = True,
+        default_response_class: Type[Response] = Default(JSONResponse),
+        callbacks: Optional[List[BaseRoute]] = None,
+    ) -> None:
+        self.router.include_router(
+            router,
+            prefix=prefix,
+            tags=tags,
+            dependencies=dependencies,
+            responses=responses,
+            deprecated=deprecated,
+            include_in_schema=include_in_schema,
+            default_response_class=default_response_class,
+            callbacks=callbacks,
+        )
+
+    def get(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.router.get(
+            path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def put(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.router.put(
+            path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def post(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.router.post(
+            path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def delete(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.router.delete(
+            path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            operation_id=operation_id,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def options(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.router.options(
+            path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def head(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.router.head(
+            path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def patch(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.router.patch(
+            path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def trace(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.router.trace(
+            path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
diff --git a/myenv/lib/python3.9/site-packages/fastapi/background.py b/myenv/lib/python3.9/site-packages/fastapi/background.py
new file mode 100644
index 0000000..dd3bbe2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/background.py
@@ -0,0 +1 @@
+from starlette.background import BackgroundTasks as BackgroundTasks  # noqa
diff --git a/myenv/lib/python3.9/site-packages/fastapi/concurrency.py b/myenv/lib/python3.9/site-packages/fastapi/concurrency.py
new file mode 100644
index 0000000..04382c6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/concurrency.py
@@ -0,0 +1,32 @@
+import sys
+from typing import AsyncGenerator, ContextManager, TypeVar
+
+from starlette.concurrency import iterate_in_threadpool as iterate_in_threadpool  # noqa
+from starlette.concurrency import run_in_threadpool as run_in_threadpool  # noqa
+from starlette.concurrency import (  # noqa
+    run_until_first_complete as run_until_first_complete,
+)
+
+if sys.version_info >= (3, 7):
+    from contextlib import AsyncExitStack as AsyncExitStack
+    from contextlib import asynccontextmanager as asynccontextmanager
+else:
+    from contextlib2 import AsyncExitStack as AsyncExitStack  # noqa
+    from contextlib2 import asynccontextmanager as asynccontextmanager  # noqa
+
+
+_T = TypeVar("_T")
+
+
+@asynccontextmanager
+async def contextmanager_in_threadpool(
+    cm: ContextManager[_T],
+) -> AsyncGenerator[_T, None]:
+    try:
+        yield await run_in_threadpool(cm.__enter__)
+    except Exception as e:
+        ok = await run_in_threadpool(cm.__exit__, type(e), e, None)
+        if not ok:
+            raise e
+    else:
+        await run_in_threadpool(cm.__exit__, None, None, None)
diff --git a/myenv/lib/python3.9/site-packages/fastapi/datastructures.py b/myenv/lib/python3.9/site-packages/fastapi/datastructures.py
new file mode 100644
index 0000000..b131712
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/datastructures.py
@@ -0,0 +1,52 @@
+from typing import Any, Callable, Iterable, Type, TypeVar
+
+from starlette.datastructures import URL as URL  # noqa: F401
+from starlette.datastructures import Address as Address  # noqa: F401
+from starlette.datastructures import FormData as FormData  # noqa: F401
+from starlette.datastructures import Headers as Headers  # noqa: F401
+from starlette.datastructures import QueryParams as QueryParams  # noqa: F401
+from starlette.datastructures import State as State  # noqa: F401
+from starlette.datastructures import UploadFile as StarletteUploadFile
+
+
+class UploadFile(StarletteUploadFile):
+    @classmethod
+    def __get_validators__(cls: Type["UploadFile"]) -> Iterable[Callable[..., Any]]:
+        yield cls.validate
+
+    @classmethod
+    def validate(cls: Type["UploadFile"], v: Any) -> Any:
+        if not isinstance(v, StarletteUploadFile):
+            raise ValueError(f"Expected UploadFile, received: {type(v)}")
+        return v
+
+
+class DefaultPlaceholder:
+    """
+    You shouldn't use this class directly.
+
+    It's used internally to recognize when a default value has been overwritten, even
+    if the overridden default value was truthy.
+    """
+
+    def __init__(self, value: Any):
+        self.value = value
+
+    def __bool__(self) -> bool:
+        return bool(self.value)
+
+    def __eq__(self, o: object) -> bool:
+        return isinstance(o, DefaultPlaceholder) and o.value == self.value
+
+
+DefaultType = TypeVar("DefaultType")
+
+
+def Default(value: DefaultType) -> DefaultType:
+    """
+    You shouldn't use this function directly.
+
+    It's used internally to recognize when a default value has been overwritten, even
+    if the overridden default value was truthy.
+    """
+    return DefaultPlaceholder(value)  # type: ignore
diff --git a/myenv/lib/python3.9/site-packages/fastapi/dependencies/__init__.py b/myenv/lib/python3.9/site-packages/fastapi/dependencies/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/fastapi/dependencies/models.py b/myenv/lib/python3.9/site-packages/fastapi/dependencies/models.py
new file mode 100644
index 0000000..443590b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/dependencies/models.py
@@ -0,0 +1,58 @@
+from typing import Any, Callable, List, Optional, Sequence
+
+from fastapi.security.base import SecurityBase
+from pydantic.fields import ModelField
+
+
+class SecurityRequirement:
+    def __init__(
+        self, security_scheme: SecurityBase, scopes: Optional[Sequence[str]] = None
+    ):
+        self.security_scheme = security_scheme
+        self.scopes = scopes
+
+
+class Dependant:
+    def __init__(
+        self,
+        *,
+        path_params: Optional[List[ModelField]] = None,
+        query_params: Optional[List[ModelField]] = None,
+        header_params: Optional[List[ModelField]] = None,
+        cookie_params: Optional[List[ModelField]] = None,
+        body_params: Optional[List[ModelField]] = None,
+        dependencies: Optional[List["Dependant"]] = None,
+        security_schemes: Optional[List[SecurityRequirement]] = None,
+        name: Optional[str] = None,
+        call: Optional[Callable[..., Any]] = None,
+        request_param_name: Optional[str] = None,
+        websocket_param_name: Optional[str] = None,
+        http_connection_param_name: Optional[str] = None,
+        response_param_name: Optional[str] = None,
+        background_tasks_param_name: Optional[str] = None,
+        security_scopes_param_name: Optional[str] = None,
+        security_scopes: Optional[List[str]] = None,
+        use_cache: bool = True,
+        path: Optional[str] = None,
+    ) -> None:
+        self.path_params = path_params or []
+        self.query_params = query_params or []
+        self.header_params = header_params or []
+        self.cookie_params = cookie_params or []
+        self.body_params = body_params or []
+        self.dependencies = dependencies or []
+        self.security_requirements = security_schemes or []
+        self.request_param_name = request_param_name
+        self.websocket_param_name = websocket_param_name
+        self.http_connection_param_name = http_connection_param_name
+        self.response_param_name = response_param_name
+        self.background_tasks_param_name = background_tasks_param_name
+        self.security_scopes = security_scopes
+        self.security_scopes_param_name = security_scopes_param_name
+        self.name = name
+        self.call = call
+        self.use_cache = use_cache
+        # Store the path to be able to re-generate a dependable from it in overrides
+        self.path = path
+        # Save the cache key at creation to optimize performance
+        self.cache_key = (self.call, tuple(sorted(set(self.security_scopes or []))))
diff --git a/myenv/lib/python3.9/site-packages/fastapi/dependencies/utils.py b/myenv/lib/python3.9/site-packages/fastapi/dependencies/utils.py
new file mode 100644
index 0000000..35ba44a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/dependencies/utils.py
@@ -0,0 +1,769 @@
+import dataclasses
+import inspect
+from contextlib import contextmanager
+from copy import deepcopy
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+
+import anyio
+from fastapi import params
+from fastapi.concurrency import (
+    AsyncExitStack,
+    asynccontextmanager,
+    contextmanager_in_threadpool,
+)
+from fastapi.dependencies.models import Dependant, SecurityRequirement
+from fastapi.logger import logger
+from fastapi.security.base import SecurityBase
+from fastapi.security.oauth2 import OAuth2, SecurityScopes
+from fastapi.security.open_id_connect_url import OpenIdConnect
+from fastapi.utils import create_response_field, get_path_param_names
+from pydantic import BaseModel, create_model
+from pydantic.error_wrappers import ErrorWrapper
+from pydantic.errors import MissingError
+from pydantic.fields import (
+    SHAPE_LIST,
+    SHAPE_SEQUENCE,
+    SHAPE_SET,
+    SHAPE_SINGLETON,
+    SHAPE_TUPLE,
+    SHAPE_TUPLE_ELLIPSIS,
+    FieldInfo,
+    ModelField,
+    Required,
+)
+from pydantic.schema import get_annotation_from_field_info
+from pydantic.typing import ForwardRef, evaluate_forwardref
+from pydantic.utils import lenient_issubclass
+from starlette.background import BackgroundTasks
+from starlette.concurrency import run_in_threadpool
+from starlette.datastructures import FormData, Headers, QueryParams, UploadFile
+from starlette.requests import HTTPConnection, Request
+from starlette.responses import Response
+from starlette.websockets import WebSocket
+
+sequence_shapes = {
+    SHAPE_LIST,
+    SHAPE_SET,
+    SHAPE_TUPLE,
+    SHAPE_SEQUENCE,
+    SHAPE_TUPLE_ELLIPSIS,
+}
+sequence_types = (list, set, tuple)
+sequence_shape_to_type = {
+    SHAPE_LIST: list,
+    SHAPE_SET: set,
+    SHAPE_TUPLE: tuple,
+    SHAPE_SEQUENCE: list,
+    SHAPE_TUPLE_ELLIPSIS: list,
+}
+
+
+multipart_not_installed_error = (
+    'Form data requires "python-multipart" to be installed. \n'
+    'You can install "python-multipart" with: \n\n'
+    "pip install python-multipart\n"
+)
+multipart_incorrect_install_error = (
+    'Form data requires "python-multipart" to be installed. '
+    'It seems you installed "multipart" instead. \n'
+    'You can remove "multipart" with: \n\n'
+    "pip uninstall multipart\n\n"
+    'And then install "python-multipart" with: \n\n'
+    "pip install python-multipart\n"
+)
+
+
+def check_file_field(field: ModelField) -> None:
+    field_info = field.field_info
+    if isinstance(field_info, params.Form):
+        try:
+            # __version__ is available in both multiparts, and can be mocked
+            from multipart import __version__  # type: ignore
+
+            assert __version__
+            try:
+                # parse_options_header is only available in the right multipart
+                from multipart.multipart import parse_options_header  # type: ignore
+
+                assert parse_options_header
+            except ImportError:
+                logger.error(multipart_incorrect_install_error)
+                raise RuntimeError(multipart_incorrect_install_error)
+        except ImportError:
+            logger.error(multipart_not_installed_error)
+            raise RuntimeError(multipart_not_installed_error)
+
+
+def get_param_sub_dependant(
+    *, param: inspect.Parameter, path: str, security_scopes: Optional[List[str]] = None
+) -> Dependant:
+    depends: params.Depends = param.default
+    if depends.dependency:
+        dependency = depends.dependency
+    else:
+        dependency = param.annotation
+    return get_sub_dependant(
+        depends=depends,
+        dependency=dependency,
+        path=path,
+        name=param.name,
+        security_scopes=security_scopes,
+    )
+
+
+def get_parameterless_sub_dependant(*, depends: params.Depends, path: str) -> Dependant:
+    assert callable(
+        depends.dependency
+    ), "A parameter-less dependency must have a callable dependency"
+    return get_sub_dependant(depends=depends, dependency=depends.dependency, path=path)
+
+
+def get_sub_dependant(
+    *,
+    depends: params.Depends,
+    dependency: Callable[..., Any],
+    path: str,
+    name: Optional[str] = None,
+    security_scopes: Optional[List[str]] = None,
+) -> Dependant:
+    security_requirement = None
+    security_scopes = security_scopes or []
+    if isinstance(depends, params.Security):
+        dependency_scopes = depends.scopes
+        security_scopes.extend(dependency_scopes)
+    if isinstance(dependency, SecurityBase):
+        use_scopes: List[str] = []
+        if isinstance(dependency, (OAuth2, OpenIdConnect)):
+            use_scopes = security_scopes
+        security_requirement = SecurityRequirement(
+            security_scheme=dependency, scopes=use_scopes
+        )
+    sub_dependant = get_dependant(
+        path=path,
+        call=dependency,
+        name=name,
+        security_scopes=security_scopes,
+        use_cache=depends.use_cache,
+    )
+    if security_requirement:
+        sub_dependant.security_requirements.append(security_requirement)
+    sub_dependant.security_scopes = security_scopes
+    return sub_dependant
+
+
+CacheKey = Tuple[Optional[Callable[..., Any]], Tuple[str, ...]]
+
+
+def get_flat_dependant(
+    dependant: Dependant,
+    *,
+    skip_repeats: bool = False,
+    visited: Optional[List[CacheKey]] = None,
+) -> Dependant:
+    if visited is None:
+        visited = []
+    visited.append(dependant.cache_key)
+
+    flat_dependant = Dependant(
+        path_params=dependant.path_params.copy(),
+        query_params=dependant.query_params.copy(),
+        header_params=dependant.header_params.copy(),
+        cookie_params=dependant.cookie_params.copy(),
+        body_params=dependant.body_params.copy(),
+        security_schemes=dependant.security_requirements.copy(),
+        use_cache=dependant.use_cache,
+        path=dependant.path,
+    )
+    for sub_dependant in dependant.dependencies:
+        if skip_repeats and sub_dependant.cache_key in visited:
+            continue
+        flat_sub = get_flat_dependant(
+            sub_dependant, skip_repeats=skip_repeats, visited=visited
+        )
+        flat_dependant.path_params.extend(flat_sub.path_params)
+        flat_dependant.query_params.extend(flat_sub.query_params)
+        flat_dependant.header_params.extend(flat_sub.header_params)
+        flat_dependant.cookie_params.extend(flat_sub.cookie_params)
+        flat_dependant.body_params.extend(flat_sub.body_params)
+        flat_dependant.security_requirements.extend(flat_sub.security_requirements)
+    return flat_dependant
+
+
+def get_flat_params(dependant: Dependant) -> List[ModelField]:
+    flat_dependant = get_flat_dependant(dependant, skip_repeats=True)
+    return (
+        flat_dependant.path_params
+        + flat_dependant.query_params
+        + flat_dependant.header_params
+        + flat_dependant.cookie_params
+    )
+
+
+def is_scalar_field(field: ModelField) -> bool:
+    field_info = field.field_info
+    if not (
+        field.shape == SHAPE_SINGLETON
+        and not lenient_issubclass(field.type_, BaseModel)
+        and not lenient_issubclass(field.type_, sequence_types + (dict,))
+        and not dataclasses.is_dataclass(field.type_)
+        and not isinstance(field_info, params.Body)
+    ):
+        return False
+    if field.sub_fields:
+        if not all(is_scalar_field(f) for f in field.sub_fields):
+            return False
+    return True
+
+
+def is_scalar_sequence_field(field: ModelField) -> bool:
+    if (field.shape in sequence_shapes) and not lenient_issubclass(
+        field.type_, BaseModel
+    ):
+        if field.sub_fields is not None:
+            for sub_field in field.sub_fields:
+                if not is_scalar_field(sub_field):
+                    return False
+        return True
+    if lenient_issubclass(field.type_, sequence_types):
+        return True
+    return False
+
+
+def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
+    signature = inspect.signature(call)
+    globalns = getattr(call, "__globals__", {})
+    typed_params = [
+        inspect.Parameter(
+            name=param.name,
+            kind=param.kind,
+            default=param.default,
+            annotation=get_typed_annotation(param, globalns),
+        )
+        for param in signature.parameters.values()
+    ]
+    typed_signature = inspect.Signature(typed_params)
+    return typed_signature
+
+
+def get_typed_annotation(param: inspect.Parameter, globalns: Dict[str, Any]) -> Any:
+    annotation = param.annotation
+    if isinstance(annotation, str):
+        annotation = ForwardRef(annotation)
+        annotation = evaluate_forwardref(annotation, globalns, globalns)
+    return annotation
+
+
+def get_dependant(
+    *,
+    path: str,
+    call: Callable[..., Any],
+    name: Optional[str] = None,
+    security_scopes: Optional[List[str]] = None,
+    use_cache: bool = True,
+) -> Dependant:
+    path_param_names = get_path_param_names(path)
+    endpoint_signature = get_typed_signature(call)
+    signature_params = endpoint_signature.parameters
+    dependant = Dependant(call=call, name=name, path=path, use_cache=use_cache)
+    for param_name, param in signature_params.items():
+        if isinstance(param.default, params.Depends):
+            sub_dependant = get_param_sub_dependant(
+                param=param, path=path, security_scopes=security_scopes
+            )
+            dependant.dependencies.append(sub_dependant)
+            continue
+        if add_non_field_param_to_dependency(param=param, dependant=dependant):
+            continue
+        param_field = get_param_field(
+            param=param, default_field_info=params.Query, param_name=param_name
+        )
+        if param_name in path_param_names:
+            assert is_scalar_field(
+                field=param_field
+            ), "Path params must be of one of the supported types"
+            if isinstance(param.default, params.Path):
+                ignore_default = False
+            else:
+                ignore_default = True
+            param_field = get_param_field(
+                param=param,
+                param_name=param_name,
+                default_field_info=params.Path,
+                force_type=params.ParamTypes.path,
+                ignore_default=ignore_default,
+            )
+            add_param_to_fields(field=param_field, dependant=dependant)
+        elif is_scalar_field(field=param_field):
+            add_param_to_fields(field=param_field, dependant=dependant)
+        elif isinstance(
+            param.default, (params.Query, params.Header)
+        ) and is_scalar_sequence_field(param_field):
+            add_param_to_fields(field=param_field, dependant=dependant)
+        else:
+            field_info = param_field.field_info
+            assert isinstance(
+                field_info, params.Body
+            ), f"Param: {param_field.name} can only be a request body, using Body(...)"
+            dependant.body_params.append(param_field)
+    return dependant
+
+
+def add_non_field_param_to_dependency(
+    *, param: inspect.Parameter, dependant: Dependant
+) -> Optional[bool]:
+    if lenient_issubclass(param.annotation, Request):
+        dependant.request_param_name = param.name
+        return True
+    elif lenient_issubclass(param.annotation, WebSocket):
+        dependant.websocket_param_name = param.name
+        return True
+    elif lenient_issubclass(param.annotation, HTTPConnection):
+        dependant.http_connection_param_name = param.name
+        return True
+    elif lenient_issubclass(param.annotation, Response):
+        dependant.response_param_name = param.name
+        return True
+    elif lenient_issubclass(param.annotation, BackgroundTasks):
+        dependant.background_tasks_param_name = param.name
+        return True
+    elif lenient_issubclass(param.annotation, SecurityScopes):
+        dependant.security_scopes_param_name = param.name
+        return True
+    return None
+
+
+def get_param_field(
+    *,
+    param: inspect.Parameter,
+    param_name: str,
+    default_field_info: Type[params.Param] = params.Param,
+    force_type: Optional[params.ParamTypes] = None,
+    ignore_default: bool = False,
+) -> ModelField:
+    default_value = Required
+    had_schema = False
+    if not param.default == param.empty and ignore_default is False:
+        default_value = param.default
+    if isinstance(default_value, FieldInfo):
+        had_schema = True
+        field_info = default_value
+        default_value = field_info.default
+        if (
+            isinstance(field_info, params.Param)
+            and getattr(field_info, "in_", None) is None
+        ):
+            field_info.in_ = default_field_info.in_
+        if force_type:
+            field_info.in_ = force_type  # type: ignore
+    else:
+        field_info = default_field_info(default_value)
+    required = default_value == Required
+    annotation: Any = Any
+    if not param.annotation == param.empty:
+        annotation = param.annotation
+    annotation = get_annotation_from_field_info(annotation, field_info, param_name)
+    if not field_info.alias and getattr(field_info, "convert_underscores", None):
+        alias = param.name.replace("_", "-")
+    else:
+        alias = field_info.alias or param.name
+    field = create_response_field(
+        name=param.name,
+        type_=annotation,
+        default=None if required else default_value,
+        alias=alias,
+        required=required,
+        field_info=field_info,
+    )
+    field.required = required
+    if not had_schema and not is_scalar_field(field=field):
+        field.field_info = params.Body(field_info.default)
+
+    return field
+
+
+def add_param_to_fields(*, field: ModelField, dependant: Dependant) -> None:
+    field_info = cast(params.Param, field.field_info)
+    if field_info.in_ == params.ParamTypes.path:
+        dependant.path_params.append(field)
+    elif field_info.in_ == params.ParamTypes.query:
+        dependant.query_params.append(field)
+    elif field_info.in_ == params.ParamTypes.header:
+        dependant.header_params.append(field)
+    else:
+        assert (
+            field_info.in_ == params.ParamTypes.cookie
+        ), f"non-body parameters must be in path, query, header or cookie: {field.name}"
+        dependant.cookie_params.append(field)
+
+
+def is_coroutine_callable(call: Callable[..., Any]) -> bool:
+    if inspect.isroutine(call):
+        return inspect.iscoroutinefunction(call)
+    if inspect.isclass(call):
+        return False
+    call = getattr(call, "__call__", None)
+    return inspect.iscoroutinefunction(call)
+
+
+def is_async_gen_callable(call: Callable[..., Any]) -> bool:
+    if inspect.isasyncgenfunction(call):
+        return True
+    call = getattr(call, "__call__", None)
+    return inspect.isasyncgenfunction(call)
+
+
+def is_gen_callable(call: Callable[..., Any]) -> bool:
+    if inspect.isgeneratorfunction(call):
+        return True
+    call = getattr(call, "__call__", None)
+    return inspect.isgeneratorfunction(call)
+
+
+async def solve_generator(
+    *, call: Callable[..., Any], stack: AsyncExitStack, sub_values: Dict[str, Any]
+) -> Any:
+    if is_gen_callable(call):
+        cm = contextmanager_in_threadpool(contextmanager(call)(**sub_values))
+    elif is_async_gen_callable(call):
+        cm = asynccontextmanager(call)(**sub_values)
+    return await stack.enter_async_context(cm)
+
+
+async def solve_dependencies(
+    *,
+    request: Union[Request, WebSocket],
+    dependant: Dependant,
+    body: Optional[Union[Dict[str, Any], FormData]] = None,
+    background_tasks: Optional[BackgroundTasks] = None,
+    response: Optional[Response] = None,
+    dependency_overrides_provider: Optional[Any] = None,
+    dependency_cache: Optional[Dict[Tuple[Callable[..., Any], Tuple[str]], Any]] = None,
+) -> Tuple[
+    Dict[str, Any],
+    List[ErrorWrapper],
+    Optional[BackgroundTasks],
+    Response,
+    Dict[Tuple[Callable[..., Any], Tuple[str]], Any],
+]:
+    values: Dict[str, Any] = {}
+    errors: List[ErrorWrapper] = []
+    response = response or Response(
+        content=None,
+        status_code=None,  # type: ignore
+        headers=None,  # type: ignore # in Starlette
+        media_type=None,  # type: ignore # in Starlette
+        background=None,  # type: ignore # in Starlette
+    )
+    dependency_cache = dependency_cache or {}
+    sub_dependant: Dependant
+    for sub_dependant in dependant.dependencies:
+        sub_dependant.call = cast(Callable[..., Any], sub_dependant.call)
+        sub_dependant.cache_key = cast(
+            Tuple[Callable[..., Any], Tuple[str]], sub_dependant.cache_key
+        )
+        call = sub_dependant.call
+        use_sub_dependant = sub_dependant
+        if (
+            dependency_overrides_provider
+            and dependency_overrides_provider.dependency_overrides
+        ):
+            original_call = sub_dependant.call
+            call = getattr(
+                dependency_overrides_provider, "dependency_overrides", {}
+            ).get(original_call, original_call)
+            use_path: str = sub_dependant.path  # type: ignore
+            use_sub_dependant = get_dependant(
+                path=use_path,
+                call=call,
+                name=sub_dependant.name,
+                security_scopes=sub_dependant.security_scopes,
+            )
+            use_sub_dependant.security_scopes = sub_dependant.security_scopes
+
+        solved_result = await solve_dependencies(
+            request=request,
+            dependant=use_sub_dependant,
+            body=body,
+            background_tasks=background_tasks,
+            response=response,
+            dependency_overrides_provider=dependency_overrides_provider,
+            dependency_cache=dependency_cache,
+        )
+        (
+            sub_values,
+            sub_errors,
+            background_tasks,
+            _,  # the subdependency returns the same response we have
+            sub_dependency_cache,
+        ) = solved_result
+        dependency_cache.update(sub_dependency_cache)
+        if sub_errors:
+            errors.extend(sub_errors)
+            continue
+        if sub_dependant.use_cache and sub_dependant.cache_key in dependency_cache:
+            solved = dependency_cache[sub_dependant.cache_key]
+        elif is_gen_callable(call) or is_async_gen_callable(call):
+            stack = request.scope.get("fastapi_astack")
+            assert isinstance(stack, AsyncExitStack)
+            solved = await solve_generator(
+                call=call, stack=stack, sub_values=sub_values
+            )
+        elif is_coroutine_callable(call):
+            solved = await call(**sub_values)
+        else:
+            solved = await run_in_threadpool(call, **sub_values)
+        if sub_dependant.name is not None:
+            values[sub_dependant.name] = solved
+        if sub_dependant.cache_key not in dependency_cache:
+            dependency_cache[sub_dependant.cache_key] = solved
+    path_values, path_errors = request_params_to_args(
+        dependant.path_params, request.path_params
+    )
+    query_values, query_errors = request_params_to_args(
+        dependant.query_params, request.query_params
+    )
+    header_values, header_errors = request_params_to_args(
+        dependant.header_params, request.headers
+    )
+    cookie_values, cookie_errors = request_params_to_args(
+        dependant.cookie_params, request.cookies
+    )
+    values.update(path_values)
+    values.update(query_values)
+    values.update(header_values)
+    values.update(cookie_values)
+    errors += path_errors + query_errors + header_errors + cookie_errors
+    if dependant.body_params:
+        (
+            body_values,
+            body_errors,
+        ) = await request_body_to_args(  # body_params checked above
+            required_params=dependant.body_params, received_body=body
+        )
+        values.update(body_values)
+        errors.extend(body_errors)
+    if dependant.http_connection_param_name:
+        values[dependant.http_connection_param_name] = request
+    if dependant.request_param_name and isinstance(request, Request):
+        values[dependant.request_param_name] = request
+    elif dependant.websocket_param_name and isinstance(request, WebSocket):
+        values[dependant.websocket_param_name] = request
+    if dependant.background_tasks_param_name:
+        if background_tasks is None:
+            background_tasks = BackgroundTasks()
+        values[dependant.background_tasks_param_name] = background_tasks
+    if dependant.response_param_name:
+        values[dependant.response_param_name] = response
+    if dependant.security_scopes_param_name:
+        values[dependant.security_scopes_param_name] = SecurityScopes(
+            scopes=dependant.security_scopes
+        )
+    return values, errors, background_tasks, response, dependency_cache
+
+
+def request_params_to_args(
+    required_params: Sequence[ModelField],
+    received_params: Union[Mapping[str, Any], QueryParams, Headers],
+) -> Tuple[Dict[str, Any], List[ErrorWrapper]]:
+    values = {}
+    errors = []
+    for field in required_params:
+        if is_scalar_sequence_field(field) and isinstance(
+            received_params, (QueryParams, Headers)
+        ):
+            value = received_params.getlist(field.alias) or field.default
+        else:
+            value = received_params.get(field.alias)
+        field_info = field.field_info
+        assert isinstance(
+            field_info, params.Param
+        ), "Params must be subclasses of Param"
+        if value is None:
+            if field.required:
+                errors.append(
+                    ErrorWrapper(
+                        MissingError(), loc=(field_info.in_.value, field.alias)
+                    )
+                )
+            else:
+                values[field.name] = deepcopy(field.default)
+            continue
+        v_, errors_ = field.validate(
+            value, values, loc=(field_info.in_.value, field.alias)
+        )
+        if isinstance(errors_, ErrorWrapper):
+            errors.append(errors_)
+        elif isinstance(errors_, list):
+            errors.extend(errors_)
+        else:
+            values[field.name] = v_
+    return values, errors
+
+
+async def request_body_to_args(
+    required_params: List[ModelField],
+    received_body: Optional[Union[Dict[str, Any], FormData]],
+) -> Tuple[Dict[str, Any], List[ErrorWrapper]]:
+    values = {}
+    errors = []
+    if required_params:
+        field = required_params[0]
+        field_info = field.field_info
+        embed = getattr(field_info, "embed", None)
+        field_alias_omitted = len(required_params) == 1 and not embed
+        if field_alias_omitted:
+            received_body = {field.alias: received_body}
+
+        for field in required_params:
+            loc: Tuple[str, ...]
+            if field_alias_omitted:
+                loc = ("body",)
+            else:
+                loc = ("body", field.alias)
+
+            value: Optional[Any] = None
+            if received_body is not None:
+                if (
+                    field.shape in sequence_shapes or field.type_ in sequence_types
+                ) and isinstance(received_body, FormData):
+                    value = received_body.getlist(field.alias)
+                else:
+                    try:
+                        value = received_body.get(field.alias)
+                    except AttributeError:
+                        errors.append(get_missing_field_error(loc))
+                        continue
+            if (
+                value is None
+                or (isinstance(field_info, params.Form) and value == "")
+                or (
+                    isinstance(field_info, params.Form)
+                    and field.shape in sequence_shapes
+                    and len(value) == 0
+                )
+            ):
+                if field.required:
+                    errors.append(get_missing_field_error(loc))
+                else:
+                    values[field.name] = deepcopy(field.default)
+                continue
+            if (
+                isinstance(field_info, params.File)
+                and lenient_issubclass(field.type_, bytes)
+                and isinstance(value, UploadFile)
+            ):
+                value = await value.read()
+            elif (
+                field.shape in sequence_shapes
+                and isinstance(field_info, params.File)
+                and lenient_issubclass(field.type_, bytes)
+                and isinstance(value, sequence_types)
+            ):
+                results: List[Union[bytes, str]] = []
+
+                async def process_fn(
+                    fn: Callable[[], Coroutine[Any, Any, Any]]
+                ) -> None:
+                    result = await fn()
+                    results.append(result)
+
+                async with anyio.create_task_group() as tg:
+                    for sub_value in value:
+                        tg.start_soon(process_fn, sub_value.read)
+                value = sequence_shape_to_type[field.shape](results)
+
+            v_, errors_ = field.validate(value, values, loc=loc)
+
+            if isinstance(errors_, ErrorWrapper):
+                errors.append(errors_)
+            elif isinstance(errors_, list):
+                errors.extend(errors_)
+            else:
+                values[field.name] = v_
+    return values, errors
+
+
+def get_missing_field_error(loc: Tuple[str, ...]) -> ErrorWrapper:
+    missing_field_error = ErrorWrapper(MissingError(), loc=loc)
+    return missing_field_error
+
+
+def get_schema_compatible_field(*, field: ModelField) -> ModelField:
+    out_field = field
+    if lenient_issubclass(field.type_, UploadFile):
+        use_type: type = bytes
+        if field.shape in sequence_shapes:
+            use_type = List[bytes]
+        out_field = create_response_field(
+            name=field.name,
+            type_=use_type,
+            class_validators=field.class_validators,
+            model_config=field.model_config,
+            default=field.default,
+            required=field.required,
+            alias=field.alias,
+            field_info=field.field_info,
+        )
+    return out_field
+
+
+def get_body_field(*, dependant: Dependant, name: str) -> Optional[ModelField]:
+    flat_dependant = get_flat_dependant(dependant)
+    if not flat_dependant.body_params:
+        return None
+    first_param = flat_dependant.body_params[0]
+    field_info = first_param.field_info
+    embed = getattr(field_info, "embed", None)
+    body_param_names_set = {param.name for param in flat_dependant.body_params}
+    if len(body_param_names_set) == 1 and not embed:
+        final_field = get_schema_compatible_field(field=first_param)
+        check_file_field(final_field)
+        return final_field
+    # If one field requires to embed, all have to be embedded
+    # in case a sub-dependency is evaluated with a single unique body field
+    # That is combined (embedded) with other body fields
+    for param in flat_dependant.body_params:
+        setattr(param.field_info, "embed", True)
+    model_name = "Body_" + name
+    BodyModel: Type[BaseModel] = create_model(model_name)
+    for f in flat_dependant.body_params:
+        BodyModel.__fields__[f.name] = get_schema_compatible_field(field=f)
+    required = any(True for f in flat_dependant.body_params if f.required)
+
+    BodyFieldInfo_kwargs: Dict[str, Any] = dict(default=None)
+    if any(isinstance(f.field_info, params.File) for f in flat_dependant.body_params):
+        BodyFieldInfo: Type[params.Body] = params.File
+    elif any(isinstance(f.field_info, params.Form) for f in flat_dependant.body_params):
+        BodyFieldInfo = params.Form
+    else:
+        BodyFieldInfo = params.Body
+
+        body_param_media_types = [
+            getattr(f.field_info, "media_type")
+            for f in flat_dependant.body_params
+            if isinstance(f.field_info, params.Body)
+        ]
+        if len(set(body_param_media_types)) == 1:
+            BodyFieldInfo_kwargs["media_type"] = body_param_media_types[0]
+    final_field = create_response_field(
+        name="body",
+        type_=BodyModel,
+        required=required,
+        alias="body",
+        field_info=BodyFieldInfo(**BodyFieldInfo_kwargs),
+    )
+    check_file_field(final_field)
+    return final_field
diff --git a/myenv/lib/python3.9/site-packages/fastapi/encoders.py b/myenv/lib/python3.9/site-packages/fastapi/encoders.py
new file mode 100644
index 0000000..3f599c9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/encoders.py
@@ -0,0 +1,153 @@
+import dataclasses
+from collections import defaultdict
+from enum import Enum
+from pathlib import PurePath
+from types import GeneratorType
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+
+from pydantic import BaseModel
+from pydantic.json import ENCODERS_BY_TYPE
+
+SetIntStr = Set[Union[int, str]]
+DictIntStrAny = Dict[Union[int, str], Any]
+
+
+def generate_encoders_by_class_tuples(
+    type_encoder_map: Dict[Any, Callable[[Any], Any]]
+) -> Dict[Callable[[Any], Any], Tuple[Any, ...]]:
+    encoders_by_class_tuples: Dict[Callable[[Any], Any], Tuple[Any, ...]] = defaultdict(
+        tuple
+    )
+    for type_, encoder in type_encoder_map.items():
+        encoders_by_class_tuples[encoder] += (type_,)
+    return encoders_by_class_tuples
+
+
+encoders_by_class_tuples = generate_encoders_by_class_tuples(ENCODERS_BY_TYPE)
+
+
+def jsonable_encoder(
+    obj: Any,
+    include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+    exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+    by_alias: bool = True,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+    custom_encoder: Dict[Any, Callable[[Any], Any]] = {},
+    sqlalchemy_safe: bool = True,
+) -> Any:
+    if include is not None and not isinstance(include, (set, dict)):
+        include = set(include)
+    if exclude is not None and not isinstance(exclude, (set, dict)):
+        exclude = set(exclude)
+    if isinstance(obj, BaseModel):
+        encoder = getattr(obj.__config__, "json_encoders", {})
+        if custom_encoder:
+            encoder.update(custom_encoder)
+        obj_dict = obj.dict(
+            include=include,  # type: ignore # in Pydantic
+            exclude=exclude,  # type: ignore # in Pydantic
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_none=exclude_none,
+            exclude_defaults=exclude_defaults,
+        )
+        if "__root__" in obj_dict:
+            obj_dict = obj_dict["__root__"]
+        return jsonable_encoder(
+            obj_dict,
+            exclude_none=exclude_none,
+            exclude_defaults=exclude_defaults,
+            custom_encoder=encoder,
+            sqlalchemy_safe=sqlalchemy_safe,
+        )
+    if dataclasses.is_dataclass(obj):
+        return dataclasses.asdict(obj)
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, PurePath):
+        return str(obj)
+    if isinstance(obj, (str, int, float, type(None))):
+        return obj
+    if isinstance(obj, dict):
+        encoded_dict = {}
+        for key, value in obj.items():
+            if (
+                (
+                    not sqlalchemy_safe
+                    or (not isinstance(key, str))
+                    or (not key.startswith("_sa"))
+                )
+                and (value is not None or not exclude_none)
+                and ((include and key in include) or not exclude or key not in exclude)
+            ):
+                encoded_key = jsonable_encoder(
+                    key,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+                encoded_value = jsonable_encoder(
+                    value,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+                encoded_dict[encoded_key] = encoded_value
+        return encoded_dict
+    if isinstance(obj, (list, set, frozenset, GeneratorType, tuple)):
+        encoded_list = []
+        for item in obj:
+            encoded_list.append(
+                jsonable_encoder(
+                    item,
+                    include=include,
+                    exclude=exclude,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_defaults=exclude_defaults,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+            )
+        return encoded_list
+
+    if custom_encoder:
+        if type(obj) in custom_encoder:
+            return custom_encoder[type(obj)](obj)
+        else:
+            for encoder_type, encoder in custom_encoder.items():
+                if isinstance(obj, encoder_type):
+                    return encoder(obj)
+
+    if type(obj) in ENCODERS_BY_TYPE:
+        return ENCODERS_BY_TYPE[type(obj)](obj)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(obj, classes_tuple):
+            return encoder(obj)
+
+    errors: List[Exception] = []
+    try:
+        data = dict(obj)
+    except Exception as e:
+        errors.append(e)
+        try:
+            data = vars(obj)
+        except Exception as e:
+            errors.append(e)
+            raise ValueError(errors)
+    return jsonable_encoder(
+        data,
+        by_alias=by_alias,
+        exclude_unset=exclude_unset,
+        exclude_defaults=exclude_defaults,
+        exclude_none=exclude_none,
+        custom_encoder=custom_encoder,
+        sqlalchemy_safe=sqlalchemy_safe,
+    )
diff --git a/myenv/lib/python3.9/site-packages/fastapi/exception_handlers.py b/myenv/lib/python3.9/site-packages/fastapi/exception_handlers.py
new file mode 100644
index 0000000..2b286d7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/exception_handlers.py
@@ -0,0 +1,25 @@
+from fastapi.encoders import jsonable_encoder
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY
+
+
+async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
+    headers = getattr(exc, "headers", None)
+    if headers:
+        return JSONResponse(
+            {"detail": exc.detail}, status_code=exc.status_code, headers=headers
+        )
+    else:
+        return JSONResponse({"detail": exc.detail}, status_code=exc.status_code)
+
+
+async def request_validation_exception_handler(
+    request: Request, exc: RequestValidationError
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+        content={"detail": jsonable_encoder(exc.errors())},
+    )
diff --git a/myenv/lib/python3.9/site-packages/fastapi/exceptions.py b/myenv/lib/python3.9/site-packages/fastapi/exceptions.py
new file mode 100644
index 0000000..f4a837b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/exceptions.py
@@ -0,0 +1,37 @@
+from typing import Any, Dict, Optional, Sequence, Type
+
+from pydantic import BaseModel, ValidationError, create_model
+from pydantic.error_wrappers import ErrorList
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+
+class HTTPException(StarletteHTTPException):
+    def __init__(
+        self,
+        status_code: int,
+        detail: Any = None,
+        headers: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(status_code=status_code, detail=detail)
+        self.headers = headers
+
+
+RequestErrorModel: Type[BaseModel] = create_model("Request")
+WebSocketErrorModel: Type[BaseModel] = create_model("WebSocket")
+
+
+class FastAPIError(RuntimeError):
+    """
+    A generic, FastAPI-specific error.
+    """
+
+
+class RequestValidationError(ValidationError):
+    def __init__(self, errors: Sequence[ErrorList], *, body: Any = None) -> None:
+        self.body = body
+        super().__init__(errors, RequestErrorModel)
+
+
+class WebSocketRequestValidationError(ValidationError):
+    def __init__(self, errors: Sequence[ErrorList]) -> None:
+        super().__init__(errors, WebSocketErrorModel)
diff --git a/myenv/lib/python3.9/site-packages/fastapi/logger.py b/myenv/lib/python3.9/site-packages/fastapi/logger.py
new file mode 100644
index 0000000..5b2c4ad
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/logger.py
@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger("fastapi")
diff --git a/myenv/lib/python3.9/site-packages/fastapi/middleware/__init__.py b/myenv/lib/python3.9/site-packages/fastapi/middleware/__init__.py
new file mode 100644
index 0000000..620296d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/middleware/__init__.py
@@ -0,0 +1 @@
+from starlette.middleware import Middleware as Middleware
diff --git a/myenv/lib/python3.9/site-packages/fastapi/middleware/cors.py b/myenv/lib/python3.9/site-packages/fastapi/middleware/cors.py
new file mode 100644
index 0000000..8dfaad0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/middleware/cors.py
@@ -0,0 +1 @@
+from starlette.middleware.cors import CORSMiddleware as CORSMiddleware  # noqa
diff --git a/myenv/lib/python3.9/site-packages/fastapi/middleware/gzip.py b/myenv/lib/python3.9/site-packages/fastapi/middleware/gzip.py
new file mode 100644
index 0000000..bbeb2cc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/middleware/gzip.py
@@ -0,0 +1 @@
+from starlette.middleware.gzip import GZipMiddleware as GZipMiddleware  # noqa
diff --git a/myenv/lib/python3.9/site-packages/fastapi/middleware/httpsredirect.py b/myenv/lib/python3.9/site-packages/fastapi/middleware/httpsredirect.py
new file mode 100644
index 0000000..b7a3d8e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/middleware/httpsredirect.py
@@ -0,0 +1,3 @@
+from starlette.middleware.httpsredirect import (  # noqa
+    HTTPSRedirectMiddleware as HTTPSRedirectMiddleware,
+)
diff --git a/myenv/lib/python3.9/site-packages/fastapi/middleware/trustedhost.py b/myenv/lib/python3.9/site-packages/fastapi/middleware/trustedhost.py
new file mode 100644
index 0000000..08d7e03
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/middleware/trustedhost.py
@@ -0,0 +1,3 @@
+from starlette.middleware.trustedhost import (  # noqa
+    TrustedHostMiddleware as TrustedHostMiddleware,
+)
diff --git a/myenv/lib/python3.9/site-packages/fastapi/middleware/wsgi.py b/myenv/lib/python3.9/site-packages/fastapi/middleware/wsgi.py
new file mode 100644
index 0000000..c4c6a79
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/middleware/wsgi.py
@@ -0,0 +1 @@
+from starlette.middleware.wsgi import WSGIMiddleware as WSGIMiddleware  # noqa
diff --git a/myenv/lib/python3.9/site-packages/fastapi/openapi/__init__.py b/myenv/lib/python3.9/site-packages/fastapi/openapi/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/fastapi/openapi/constants.py b/myenv/lib/python3.9/site-packages/fastapi/openapi/constants.py
new file mode 100644
index 0000000..3e69e55
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/openapi/constants.py
@@ -0,0 +1,3 @@
+METHODS_WITH_BODY = {"GET", "HEAD", "POST", "PUT", "DELETE", "PATCH"}
+STATUS_CODES_WITH_NO_BODY = {100, 101, 102, 103, 204, 304}
+REF_PREFIX = "#/components/schemas/"
diff --git a/myenv/lib/python3.9/site-packages/fastapi/openapi/docs.py b/myenv/lib/python3.9/site-packages/fastapi/openapi/docs.py
new file mode 100644
index 0000000..fd22e4e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/openapi/docs.py
@@ -0,0 +1,177 @@
+import json
+from typing import Any, Dict, Optional
+
+from fastapi.encoders import jsonable_encoder
+from starlette.responses import HTMLResponse
+
+
+def get_swagger_ui_html(
+    *,
+    openapi_url: str,
+    title: str,
+    swagger_js_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@3/swagger-ui-bundle.js",
+    swagger_css_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@3/swagger-ui.css",
+    swagger_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
+    oauth2_redirect_url: Optional[str] = None,
+    init_oauth: Optional[Dict[str, Any]] = None,
+) -> HTMLResponse:
+
+    html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+    <link type="text/css" rel="stylesheet" href="{swagger_css_url}">
+    <link rel="shortcut icon" href="{swagger_favicon_url}">
+    <title>{title}</title>
+    </head>
+    <body>
+    <div id="swagger-ui">
+    </div>
+    <script src="{swagger_js_url}"></script>
+    <!-- `SwaggerUIBundle` is now available on the page -->
+    <script>
+    const ui = SwaggerUIBundle({{
+        url: '{openapi_url}',
+    """
+
+    if oauth2_redirect_url:
+        html += f"oauth2RedirectUrl: window.location.origin + '{oauth2_redirect_url}',"
+
+    html += """
+        dom_id: '#swagger-ui',
+        presets: [
+        SwaggerUIBundle.presets.apis,
+        SwaggerUIBundle.SwaggerUIStandalonePreset
+        ],
+        layout: "BaseLayout",
+        deepLinking: true,
+        showExtensions: true,
+        showCommonExtensions: true
+    })"""
+
+    if init_oauth:
+        html += f"""
+        ui.initOAuth({json.dumps(jsonable_encoder(init_oauth))})
+        """
+
+    html += """
+    </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(html)
+
+
+def get_redoc_html(
+    *,
+    openapi_url: str,
+    title: str,
+    redoc_js_url: str = "https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js",
+    redoc_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
+    with_google_fonts: bool = True,
+) -> HTMLResponse:
+    html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+    <title>{title}</title>
+    <!-- needed for adaptive design -->
+    <meta charset="utf-8"/>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    """
+    if with_google_fonts:
+        html += """
+    <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
+    """
+    html += f"""
+    <link rel="shortcut icon" href="{redoc_favicon_url}">
+    <!--
+    ReDoc doesn't change outer page styles
+    -->
+    <style>
+      body {{
+        margin: 0;
+        padding: 0;
+      }}
+    </style>
+    </head>
+    <body>
+    <redoc spec-url="{openapi_url}"></redoc>
+    <script src="{redoc_js_url}"> </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(html)
+
+
+def get_swagger_ui_oauth2_redirect_html() -> HTMLResponse:
+    html = """
+    <!DOCTYPE html>
+    <html lang="en-US">
+    <body onload="run()">
+    </body>
+    </html>
+    <script>
+        'use strict';
+        function run () {
+            var oauth2 = window.opener.swaggerUIRedirectOauth2;
+            var sentState = oauth2.state;
+            var redirectUrl = oauth2.redirectUrl;
+            var isValid, qp, arr;
+
+            if (/code|token|error/.test(window.location.hash)) {
+                qp = window.location.hash.substring(1);
+            } else {
+                qp = location.search.substring(1);
+            }
+
+            arr = qp.split("&")
+            arr.forEach(function (v,i,_arr) { _arr[i] = '"' + v.replace('=', '":"') + '"';})
+            qp = qp ? JSON.parse('{' + arr.join() + '}',
+                    function (key, value) {
+                        return key === "" ? value : decodeURIComponent(value)
+                    }
+            ) : {}
+
+            isValid = qp.state === sentState
+
+            if ((
+            oauth2.auth.schema.get("flow") === "accessCode"||
+            oauth2.auth.schema.get("flow") === "authorizationCode"
+            ) && !oauth2.auth.code) {
+                if (!isValid) {
+                    oauth2.errCb({
+                        authId: oauth2.auth.name,
+                        source: "auth",
+                        level: "warning",
+                        message: "Authorization may be unsafe, passed state was changed in server Passed state wasn't returned from auth server"
+                    });
+                }
+
+                if (qp.code) {
+                    delete oauth2.state;
+                    oauth2.auth.code = qp.code;
+                    oauth2.callback({auth: oauth2.auth, redirectUrl: redirectUrl});
+                } else {
+                    let oauthErrorMsg
+                    if (qp.error) {
+                        oauthErrorMsg = "["+qp.error+"]: " +
+                            (qp.error_description ? qp.error_description+ ". " : "no accessCode received from the server. ") +
+                            (qp.error_uri ? "More info: "+qp.error_uri : "");
+                    }
+
+                    oauth2.errCb({
+                        authId: oauth2.auth.name,
+                        source: "auth",
+                        level: "error",
+                        message: oauthErrorMsg || "[Authorization failed]: no accessCode received from the server"
+                    });
+                }
+            } else {
+                oauth2.callback({auth: oauth2.auth, token: qp, isValid: isValid, redirectUrl: redirectUrl});
+            }
+            window.close();
+        }
+    </script>
+        """
+    return HTMLResponse(content=html)
diff --git a/myenv/lib/python3.9/site-packages/fastapi/openapi/models.py b/myenv/lib/python3.9/site-packages/fastapi/openapi/models.py
new file mode 100644
index 0000000..361c750
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/openapi/models.py
@@ -0,0 +1,406 @@
+from enum import Enum
+from typing import Any, Callable, Dict, Iterable, List, Optional, Union
+
+from fastapi.logger import logger
+from pydantic import AnyUrl, BaseModel, Field
+
+try:
+    import email_validator  # type: ignore
+
+    assert email_validator  # make autoflake ignore the unused import
+    from pydantic import EmailStr
+except ImportError:  # pragma: no cover
+
+    class EmailStr(str):  # type: ignore
+        @classmethod
+        def __get_validators__(cls) -> Iterable[Callable[..., Any]]:
+            yield cls.validate
+
+        @classmethod
+        def validate(cls, v: Any) -> str:
+            logger.warning(
+                "email-validator not installed, email fields will be treated as str.\n"
+                "To install, run: pip install email-validator"
+            )
+            return str(v)
+
+
+class Contact(BaseModel):
+    name: Optional[str] = None
+    url: Optional[AnyUrl] = None
+    email: Optional[EmailStr] = None
+
+    class Config:
+        extra = "allow"
+
+
+class License(BaseModel):
+    name: str
+    url: Optional[AnyUrl] = None
+
+    class Config:
+        extra = "allow"
+
+
+class Info(BaseModel):
+    title: str
+    description: Optional[str] = None
+    termsOfService: Optional[str] = None
+    contact: Optional[Contact] = None
+    license: Optional[License] = None
+    version: str
+
+    class Config:
+        extra = "allow"
+
+
+class ServerVariable(BaseModel):
+    enum: Optional[List[str]] = None
+    default: str
+    description: Optional[str] = None
+
+    class Config:
+        extra = "allow"
+
+
+class Server(BaseModel):
+    url: Union[AnyUrl, str]
+    description: Optional[str] = None
+    variables: Optional[Dict[str, ServerVariable]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class Reference(BaseModel):
+    ref: str = Field(..., alias="$ref")
+
+
+class Discriminator(BaseModel):
+    propertyName: str
+    mapping: Optional[Dict[str, str]] = None
+
+
+class XML(BaseModel):
+    name: Optional[str] = None
+    namespace: Optional[str] = None
+    prefix: Optional[str] = None
+    attribute: Optional[bool] = None
+    wrapped: Optional[bool] = None
+
+    class Config:
+        extra = "allow"
+
+
+class ExternalDocumentation(BaseModel):
+    description: Optional[str] = None
+    url: AnyUrl
+
+    class Config:
+        extra = "allow"
+
+
+class Schema(BaseModel):
+    ref: Optional[str] = Field(None, alias="$ref")
+    title: Optional[str] = None
+    multipleOf: Optional[float] = None
+    maximum: Optional[float] = None
+    exclusiveMaximum: Optional[float] = None
+    minimum: Optional[float] = None
+    exclusiveMinimum: Optional[float] = None
+    maxLength: Optional[int] = Field(None, gte=0)
+    minLength: Optional[int] = Field(None, gte=0)
+    pattern: Optional[str] = None
+    maxItems: Optional[int] = Field(None, gte=0)
+    minItems: Optional[int] = Field(None, gte=0)
+    uniqueItems: Optional[bool] = None
+    maxProperties: Optional[int] = Field(None, gte=0)
+    minProperties: Optional[int] = Field(None, gte=0)
+    required: Optional[List[str]] = None
+    enum: Optional[List[Any]] = None
+    type: Optional[str] = None
+    allOf: Optional[List["Schema"]] = None
+    oneOf: Optional[List["Schema"]] = None
+    anyOf: Optional[List["Schema"]] = None
+    not_: Optional["Schema"] = Field(None, alias="not")
+    items: Optional["Schema"] = None
+    properties: Optional[Dict[str, "Schema"]] = None
+    additionalProperties: Optional[Union["Schema", Reference, bool]] = None
+    description: Optional[str] = None
+    format: Optional[str] = None
+    default: Optional[Any] = None
+    nullable: Optional[bool] = None
+    discriminator: Optional[Discriminator] = None
+    readOnly: Optional[bool] = None
+    writeOnly: Optional[bool] = None
+    xml: Optional[XML] = None
+    externalDocs: Optional[ExternalDocumentation] = None
+    example: Optional[Any] = None
+    deprecated: Optional[bool] = None
+
+    class Config:
+        extra: str = "allow"
+
+
+class Example(BaseModel):
+    summary: Optional[str] = None
+    description: Optional[str] = None
+    value: Optional[Any] = None
+    externalValue: Optional[AnyUrl] = None
+
+    class Config:
+        extra = "allow"
+
+
+class ParameterInType(Enum):
+    query = "query"
+    header = "header"
+    path = "path"
+    cookie = "cookie"
+
+
+class Encoding(BaseModel):
+    contentType: Optional[str] = None
+    headers: Optional[Dict[str, Union["Header", Reference]]] = None
+    style: Optional[str] = None
+    explode: Optional[bool] = None
+    allowReserved: Optional[bool] = None
+
+    class Config:
+        extra = "allow"
+
+
+class MediaType(BaseModel):
+    schema_: Optional[Union[Schema, Reference]] = Field(None, alias="schema")
+    example: Optional[Any] = None
+    examples: Optional[Dict[str, Union[Example, Reference]]] = None
+    encoding: Optional[Dict[str, Encoding]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class ParameterBase(BaseModel):
+    description: Optional[str] = None
+    required: Optional[bool] = None
+    deprecated: Optional[bool] = None
+    # Serialization rules for simple scenarios
+    style: Optional[str] = None
+    explode: Optional[bool] = None
+    allowReserved: Optional[bool] = None
+    schema_: Optional[Union[Schema, Reference]] = Field(None, alias="schema")
+    example: Optional[Any] = None
+    examples: Optional[Dict[str, Union[Example, Reference]]] = None
+    # Serialization rules for more complex scenarios
+    content: Optional[Dict[str, MediaType]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class Parameter(ParameterBase):
+    name: str
+    in_: ParameterInType = Field(..., alias="in")
+
+
+class Header(ParameterBase):
+    pass
+
+
+class RequestBody(BaseModel):
+    description: Optional[str] = None
+    content: Dict[str, MediaType]
+    required: Optional[bool] = None
+
+    class Config:
+        extra = "allow"
+
+
+class Link(BaseModel):
+    operationRef: Optional[str] = None
+    operationId: Optional[str] = None
+    parameters: Optional[Dict[str, Union[Any, str]]] = None
+    requestBody: Optional[Union[Any, str]] = None
+    description: Optional[str] = None
+    server: Optional[Server] = None
+
+    class Config:
+        extra = "allow"
+
+
+class Response(BaseModel):
+    description: str
+    headers: Optional[Dict[str, Union[Header, Reference]]] = None
+    content: Optional[Dict[str, MediaType]] = None
+    links: Optional[Dict[str, Union[Link, Reference]]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class Operation(BaseModel):
+    tags: Optional[List[str]] = None
+    summary: Optional[str] = None
+    description: Optional[str] = None
+    externalDocs: Optional[ExternalDocumentation] = None
+    operationId: Optional[str] = None
+    parameters: Optional[List[Union[Parameter, Reference]]] = None
+    requestBody: Optional[Union[RequestBody, Reference]] = None
+    # Using Any for Specification Extensions
+    responses: Dict[str, Union[Response, Any]]
+    callbacks: Optional[Dict[str, Union[Dict[str, "PathItem"], Reference]]] = None
+    deprecated: Optional[bool] = None
+    security: Optional[List[Dict[str, List[str]]]] = None
+    servers: Optional[List[Server]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class PathItem(BaseModel):
+    ref: Optional[str] = Field(None, alias="$ref")
+    summary: Optional[str] = None
+    description: Optional[str] = None
+    get: Optional[Operation] = None
+    put: Optional[Operation] = None
+    post: Optional[Operation] = None
+    delete: Optional[Operation] = None
+    options: Optional[Operation] = None
+    head: Optional[Operation] = None
+    patch: Optional[Operation] = None
+    trace: Optional[Operation] = None
+    servers: Optional[List[Server]] = None
+    parameters: Optional[List[Union[Parameter, Reference]]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class SecuritySchemeType(Enum):
+    apiKey = "apiKey"
+    http = "http"
+    oauth2 = "oauth2"
+    openIdConnect = "openIdConnect"
+
+
+class SecurityBase(BaseModel):
+    type_: SecuritySchemeType = Field(..., alias="type")
+    description: Optional[str] = None
+
+    class Config:
+        extra = "allow"
+
+
+class APIKeyIn(Enum):
+    query = "query"
+    header = "header"
+    cookie = "cookie"
+
+
+class APIKey(SecurityBase):
+    type_ = Field(SecuritySchemeType.apiKey, alias="type")
+    in_: APIKeyIn = Field(..., alias="in")
+    name: str
+
+
+class HTTPBase(SecurityBase):
+    type_ = Field(SecuritySchemeType.http, alias="type")
+    scheme: str
+
+
+class HTTPBearer(HTTPBase):
+    scheme = "bearer"
+    bearerFormat: Optional[str] = None
+
+
+class OAuthFlow(BaseModel):
+    refreshUrl: Optional[str] = None
+    scopes: Dict[str, str] = {}
+
+    class Config:
+        extra = "allow"
+
+
+class OAuthFlowImplicit(OAuthFlow):
+    authorizationUrl: str
+
+
+class OAuthFlowPassword(OAuthFlow):
+    tokenUrl: str
+
+
+class OAuthFlowClientCredentials(OAuthFlow):
+    tokenUrl: str
+
+
+class OAuthFlowAuthorizationCode(OAuthFlow):
+    authorizationUrl: str
+    tokenUrl: str
+
+
+class OAuthFlows(BaseModel):
+    implicit: Optional[OAuthFlowImplicit] = None
+    password: Optional[OAuthFlowPassword] = None
+    clientCredentials: Optional[OAuthFlowClientCredentials] = None
+    authorizationCode: Optional[OAuthFlowAuthorizationCode] = None
+
+    class Config:
+        extra = "allow"
+
+
+class OAuth2(SecurityBase):
+    type_ = Field(SecuritySchemeType.oauth2, alias="type")
+    flows: OAuthFlows
+
+
+class OpenIdConnect(SecurityBase):
+    type_ = Field(SecuritySchemeType.openIdConnect, alias="type")
+    openIdConnectUrl: str
+
+
+SecurityScheme = Union[APIKey, HTTPBase, OAuth2, OpenIdConnect, HTTPBearer]
+
+
+class Components(BaseModel):
+    schemas: Optional[Dict[str, Union[Schema, Reference]]] = None
+    responses: Optional[Dict[str, Union[Response, Reference]]] = None
+    parameters: Optional[Dict[str, Union[Parameter, Reference]]] = None
+    examples: Optional[Dict[str, Union[Example, Reference]]] = None
+    requestBodies: Optional[Dict[str, Union[RequestBody, Reference]]] = None
+    headers: Optional[Dict[str, Union[Header, Reference]]] = None
+    securitySchemes: Optional[Dict[str, Union[SecurityScheme, Reference]]] = None
+    links: Optional[Dict[str, Union[Link, Reference]]] = None
+    # Using Any for Specification Extensions
+    callbacks: Optional[Dict[str, Union[Dict[str, PathItem], Reference, Any]]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class Tag(BaseModel):
+    name: str
+    description: Optional[str] = None
+    externalDocs: Optional[ExternalDocumentation] = None
+
+    class Config:
+        extra = "allow"
+
+
+class OpenAPI(BaseModel):
+    openapi: str
+    info: Info
+    servers: Optional[List[Server]] = None
+    # Using Any for Specification Extensions
+    paths: Dict[str, Union[PathItem, Any]]
+    components: Optional[Components] = None
+    security: Optional[List[Dict[str, List[str]]]] = None
+    tags: Optional[List[Tag]] = None
+    externalDocs: Optional[ExternalDocumentation] = None
+
+    class Config:
+        extra = "allow"
+
+
+Schema.update_forward_refs()
+Operation.update_forward_refs()
+Encoding.update_forward_refs()
diff --git a/myenv/lib/python3.9/site-packages/fastapi/openapi/utils.py b/myenv/lib/python3.9/site-packages/fastapi/openapi/utils.py
new file mode 100644
index 0000000..0e73e21
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/openapi/utils.py
@@ -0,0 +1,410 @@
+import http.client
+import inspect
+from enum import Enum
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Type, Union, cast
+
+from fastapi import routing
+from fastapi.datastructures import DefaultPlaceholder
+from fastapi.dependencies.models import Dependant
+from fastapi.dependencies.utils import get_flat_dependant, get_flat_params
+from fastapi.encoders import jsonable_encoder
+from fastapi.openapi.constants import (
+    METHODS_WITH_BODY,
+    REF_PREFIX,
+    STATUS_CODES_WITH_NO_BODY,
+)
+from fastapi.openapi.models import OpenAPI
+from fastapi.params import Body, Param
+from fastapi.responses import Response
+from fastapi.utils import (
+    deep_dict_update,
+    generate_operation_id_for_path,
+    get_model_definitions,
+)
+from pydantic import BaseModel
+from pydantic.fields import ModelField, Undefined
+from pydantic.schema import (
+    field_schema,
+    get_flat_models_from_fields,
+    get_model_name_map,
+)
+from pydantic.utils import lenient_issubclass
+from starlette.responses import JSONResponse
+from starlette.routing import BaseRoute
+from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY
+
+validation_error_definition = {
+    "title": "ValidationError",
+    "type": "object",
+    "properties": {
+        "loc": {"title": "Location", "type": "array", "items": {"type": "string"}},
+        "msg": {"title": "Message", "type": "string"},
+        "type": {"title": "Error Type", "type": "string"},
+    },
+    "required": ["loc", "msg", "type"],
+}
+
+validation_error_response_definition = {
+    "title": "HTTPValidationError",
+    "type": "object",
+    "properties": {
+        "detail": {
+            "title": "Detail",
+            "type": "array",
+            "items": {"$ref": REF_PREFIX + "ValidationError"},
+        }
+    },
+}
+
+status_code_ranges: Dict[str, str] = {
+    "1XX": "Information",
+    "2XX": "Success",
+    "3XX": "Redirection",
+    "4XX": "Client Error",
+    "5XX": "Server Error",
+    "DEFAULT": "Default Response",
+}
+
+
+def get_openapi_security_definitions(
+    flat_dependant: Dependant,
+) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
+    security_definitions = {}
+    operation_security = []
+    for security_requirement in flat_dependant.security_requirements:
+        security_definition = jsonable_encoder(
+            security_requirement.security_scheme.model,
+            by_alias=True,
+            exclude_none=True,
+        )
+        security_name = security_requirement.security_scheme.scheme_name
+        security_definitions[security_name] = security_definition
+        operation_security.append({security_name: security_requirement.scopes})
+    return security_definitions, operation_security
+
+
+def get_openapi_operation_parameters(
+    *,
+    all_route_params: Sequence[ModelField],
+    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],
+) -> List[Dict[str, Any]]:
+    parameters = []
+    for param in all_route_params:
+        field_info = param.field_info
+        field_info = cast(Param, field_info)
+        parameter = {
+            "name": param.alias,
+            "in": field_info.in_.value,
+            "required": param.required,
+            "schema": field_schema(
+                param, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+            )[0],
+        }
+        if field_info.description:
+            parameter["description"] = field_info.description
+        if field_info.examples:
+            parameter["examples"] = jsonable_encoder(field_info.examples)
+        elif field_info.example != Undefined:
+            parameter["example"] = jsonable_encoder(field_info.example)
+        if field_info.deprecated:
+            parameter["deprecated"] = field_info.deprecated
+        parameters.append(parameter)
+    return parameters
+
+
+def get_openapi_operation_request_body(
+    *,
+    body_field: Optional[ModelField],
+    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],
+) -> Optional[Dict[str, Any]]:
+    if not body_field:
+        return None
+    assert isinstance(body_field, ModelField)
+    body_schema, _, _ = field_schema(
+        body_field, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+    )
+    field_info = cast(Body, body_field.field_info)
+    request_media_type = field_info.media_type
+    required = body_field.required
+    request_body_oai: Dict[str, Any] = {}
+    if required:
+        request_body_oai["required"] = required
+    request_media_content: Dict[str, Any] = {"schema": body_schema}
+    if field_info.examples:
+        request_media_content["examples"] = jsonable_encoder(field_info.examples)
+    elif field_info.example != Undefined:
+        request_media_content["example"] = jsonable_encoder(field_info.example)
+    request_body_oai["content"] = {request_media_type: request_media_content}
+    return request_body_oai
+
+
+def generate_operation_id(*, route: routing.APIRoute, method: str) -> str:
+    if route.operation_id:
+        return route.operation_id
+    path: str = route.path_format
+    return generate_operation_id_for_path(name=route.name, path=path, method=method)
+
+
+def generate_operation_summary(*, route: routing.APIRoute, method: str) -> str:
+    if route.summary:
+        return route.summary
+    return route.name.replace("_", " ").title()
+
+
+def get_openapi_operation_metadata(
+    *, route: routing.APIRoute, method: str
+) -> Dict[str, Any]:
+    operation: Dict[str, Any] = {}
+    if route.tags:
+        operation["tags"] = route.tags
+    operation["summary"] = generate_operation_summary(route=route, method=method)
+    if route.description:
+        operation["description"] = route.description
+    operation["operationId"] = generate_operation_id(route=route, method=method)
+    if route.deprecated:
+        operation["deprecated"] = route.deprecated
+    return operation
+
+
+def get_openapi_path(
+    *, route: routing.APIRoute, model_name_map: Dict[type, str]
+) -> Tuple[Dict[str, Any], Dict[str, Any], Dict[str, Any]]:
+    path = {}
+    security_schemes: Dict[str, Any] = {}
+    definitions: Dict[str, Any] = {}
+    assert route.methods is not None, "Methods must be a list"
+    if isinstance(route.response_class, DefaultPlaceholder):
+        current_response_class: Type[Response] = route.response_class.value
+    else:
+        current_response_class = route.response_class
+    assert current_response_class, "A response class is needed to generate OpenAPI"
+    route_response_media_type: Optional[str] = current_response_class.media_type
+    if route.include_in_schema:
+        for method in route.methods:
+            operation = get_openapi_operation_metadata(route=route, method=method)
+            parameters: List[Dict[str, Any]] = []
+            flat_dependant = get_flat_dependant(route.dependant, skip_repeats=True)
+            security_definitions, operation_security = get_openapi_security_definitions(
+                flat_dependant=flat_dependant
+            )
+            if operation_security:
+                operation.setdefault("security", []).extend(operation_security)
+            if security_definitions:
+                security_schemes.update(security_definitions)
+            all_route_params = get_flat_params(route.dependant)
+            operation_parameters = get_openapi_operation_parameters(
+                all_route_params=all_route_params, model_name_map=model_name_map
+            )
+            parameters.extend(operation_parameters)
+            if parameters:
+                operation["parameters"] = list(
+                    {param["name"]: param for param in parameters}.values()
+                )
+            if method in METHODS_WITH_BODY:
+                request_body_oai = get_openapi_operation_request_body(
+                    body_field=route.body_field, model_name_map=model_name_map
+                )
+                if request_body_oai:
+                    operation["requestBody"] = request_body_oai
+            if route.callbacks:
+                callbacks = {}
+                for callback in route.callbacks:
+                    if isinstance(callback, routing.APIRoute):
+                        (
+                            cb_path,
+                            cb_security_schemes,
+                            cb_definitions,
+                        ) = get_openapi_path(
+                            route=callback, model_name_map=model_name_map
+                        )
+                        callbacks[callback.name] = {callback.path: cb_path}
+                operation["callbacks"] = callbacks
+            if route.status_code is not None:
+                status_code = str(route.status_code)
+            else:
+                # It would probably make more sense for all response classes to have an
+                # explicit default status_code, and to extract it from them, instead of
+                # doing this inspection tricks, that would probably be in the future
+                # TODO: probably make status_code a default class attribute for all
+                # responses in Starlette
+                response_signature = inspect.signature(current_response_class.__init__)
+                status_code_param = response_signature.parameters.get("status_code")
+                if status_code_param is not None:
+                    if isinstance(status_code_param.default, int):
+                        status_code = str(status_code_param.default)
+            operation.setdefault("responses", {}).setdefault(status_code, {})[
+                "description"
+            ] = route.response_description
+            if (
+                route_response_media_type
+                and route.status_code not in STATUS_CODES_WITH_NO_BODY
+            ):
+                response_schema = {"type": "string"}
+                if lenient_issubclass(current_response_class, JSONResponse):
+                    if route.response_field:
+                        response_schema, _, _ = field_schema(
+                            route.response_field,
+                            model_name_map=model_name_map,
+                            ref_prefix=REF_PREFIX,
+                        )
+                    else:
+                        response_schema = {}
+                operation.setdefault("responses", {}).setdefault(
+                    status_code, {}
+                ).setdefault("content", {}).setdefault(route_response_media_type, {})[
+                    "schema"
+                ] = response_schema
+            if route.responses:
+                operation_responses = operation.setdefault("responses", {})
+                for (
+                    additional_status_code,
+                    additional_response,
+                ) in route.responses.items():
+                    process_response = additional_response.copy()
+                    process_response.pop("model", None)
+                    status_code_key = str(additional_status_code).upper()
+                    if status_code_key == "DEFAULT":
+                        status_code_key = "default"
+                    openapi_response = operation_responses.setdefault(
+                        status_code_key, {}
+                    )
+                    assert isinstance(
+                        process_response, dict
+                    ), "An additional response must be a dict"
+                    field = route.response_fields.get(additional_status_code)
+                    additional_field_schema: Optional[Dict[str, Any]] = None
+                    if field:
+                        additional_field_schema, _, _ = field_schema(
+                            field, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+                        )
+                        media_type = route_response_media_type or "application/json"
+                        additional_schema = (
+                            process_response.setdefault("content", {})
+                            .setdefault(media_type, {})
+                            .setdefault("schema", {})
+                        )
+                        deep_dict_update(additional_schema, additional_field_schema)
+                    status_text: Optional[str] = status_code_ranges.get(
+                        str(additional_status_code).upper()
+                    ) or http.client.responses.get(int(additional_status_code))
+                    description = (
+                        process_response.get("description")
+                        or openapi_response.get("description")
+                        or status_text
+                        or "Additional Response"
+                    )
+                    deep_dict_update(openapi_response, process_response)
+                    openapi_response["description"] = description
+            http422 = str(HTTP_422_UNPROCESSABLE_ENTITY)
+            if (all_route_params or route.body_field) and not any(
+                [
+                    status in operation["responses"]
+                    for status in [http422, "4XX", "default"]
+                ]
+            ):
+                operation["responses"][http422] = {
+                    "description": "Validation Error",
+                    "content": {
+                        "application/json": {
+                            "schema": {"$ref": REF_PREFIX + "HTTPValidationError"}
+                        }
+                    },
+                }
+                if "ValidationError" not in definitions:
+                    definitions.update(
+                        {
+                            "ValidationError": validation_error_definition,
+                            "HTTPValidationError": validation_error_response_definition,
+                        }
+                    )
+            if route.openapi_extra:
+                deep_dict_update(operation, route.openapi_extra)
+            path[method.lower()] = operation
+    return path, security_schemes, definitions
+
+
+def get_flat_models_from_routes(
+    routes: Sequence[BaseRoute],
+) -> Set[Union[Type[BaseModel], Type[Enum]]]:
+    body_fields_from_routes: List[ModelField] = []
+    responses_from_routes: List[ModelField] = []
+    request_fields_from_routes: List[ModelField] = []
+    callback_flat_models: Set[Union[Type[BaseModel], Type[Enum]]] = set()
+    for route in routes:
+        if getattr(route, "include_in_schema", None) and isinstance(
+            route, routing.APIRoute
+        ):
+            if route.body_field:
+                assert isinstance(
+                    route.body_field, ModelField
+                ), "A request body must be a Pydantic Field"
+                body_fields_from_routes.append(route.body_field)
+            if route.response_field:
+                responses_from_routes.append(route.response_field)
+            if route.response_fields:
+                responses_from_routes.extend(route.response_fields.values())
+            if route.callbacks:
+                callback_flat_models |= get_flat_models_from_routes(route.callbacks)
+            params = get_flat_params(route.dependant)
+            request_fields_from_routes.extend(params)
+
+    flat_models = callback_flat_models | get_flat_models_from_fields(
+        body_fields_from_routes + responses_from_routes + request_fields_from_routes,
+        known_models=set(),
+    )
+    return flat_models
+
+
+def get_openapi(
+    *,
+    title: str,
+    version: str,
+    openapi_version: str = "3.0.2",
+    description: Optional[str] = None,
+    routes: Sequence[BaseRoute],
+    tags: Optional[List[Dict[str, Any]]] = None,
+    servers: Optional[List[Dict[str, Union[str, Any]]]] = None,
+    terms_of_service: Optional[str] = None,
+    contact: Optional[Dict[str, Union[str, Any]]] = None,
+    license_info: Optional[Dict[str, Union[str, Any]]] = None,
+) -> Dict[str, Any]:
+    info: Dict[str, Any] = {"title": title, "version": version}
+    if description:
+        info["description"] = description
+    if terms_of_service:
+        info["termsOfService"] = terms_of_service
+    if contact:
+        info["contact"] = contact
+    if license_info:
+        info["license"] = license_info
+    output: Dict[str, Any] = {"openapi": openapi_version, "info": info}
+    if servers:
+        output["servers"] = servers
+    components: Dict[str, Dict[str, Any]] = {}
+    paths: Dict[str, Dict[str, Any]] = {}
+    flat_models = get_flat_models_from_routes(routes)
+    model_name_map = get_model_name_map(flat_models)
+    definitions = get_model_definitions(
+        flat_models=flat_models, model_name_map=model_name_map
+    )
+    for route in routes:
+        if isinstance(route, routing.APIRoute):
+            result = get_openapi_path(route=route, model_name_map=model_name_map)
+            if result:
+                path, security_schemes, path_definitions = result
+                if path:
+                    paths.setdefault(route.path_format, {}).update(path)
+                if security_schemes:
+                    components.setdefault("securitySchemes", {}).update(
+                        security_schemes
+                    )
+                if path_definitions:
+                    definitions.update(path_definitions)
+    if definitions:
+        components["schemas"] = {k: definitions[k] for k in sorted(definitions)}
+    if components:
+        output["components"] = components
+    output["paths"] = paths
+    if tags:
+        output["tags"] = tags
+    return jsonable_encoder(OpenAPI(**output), by_alias=True, exclude_none=True)  # type: ignore
diff --git a/myenv/lib/python3.9/site-packages/fastapi/param_functions.py b/myenv/lib/python3.9/site-packages/fastapi/param_functions.py
new file mode 100644
index 0000000..ff65d72
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/param_functions.py
@@ -0,0 +1,282 @@
+from typing import Any, Callable, Dict, Optional, Sequence
+
+from fastapi import params
+from pydantic.fields import Undefined
+
+
+def Path(  # noqa: N802
+    default: Any,
+    *,
+    alias: Optional[str] = None,
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+    gt: Optional[float] = None,
+    ge: Optional[float] = None,
+    lt: Optional[float] = None,
+    le: Optional[float] = None,
+    min_length: Optional[int] = None,
+    max_length: Optional[int] = None,
+    regex: Optional[str] = None,
+    example: Any = Undefined,
+    examples: Optional[Dict[str, Any]] = None,
+    deprecated: Optional[bool] = None,
+    **extra: Any,
+) -> Any:
+    return params.Path(
+        default=default,
+        alias=alias,
+        title=title,
+        description=description,
+        gt=gt,
+        ge=ge,
+        lt=lt,
+        le=le,
+        min_length=min_length,
+        max_length=max_length,
+        regex=regex,
+        example=example,
+        examples=examples,
+        deprecated=deprecated,
+        **extra,
+    )
+
+
+def Query(  # noqa: N802
+    default: Any,
+    *,
+    alias: Optional[str] = None,
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+    gt: Optional[float] = None,
+    ge: Optional[float] = None,
+    lt: Optional[float] = None,
+    le: Optional[float] = None,
+    min_length: Optional[int] = None,
+    max_length: Optional[int] = None,
+    regex: Optional[str] = None,
+    example: Any = Undefined,
+    examples: Optional[Dict[str, Any]] = None,
+    deprecated: Optional[bool] = None,
+    **extra: Any,
+) -> Any:
+    return params.Query(
+        default,
+        alias=alias,
+        title=title,
+        description=description,
+        gt=gt,
+        ge=ge,
+        lt=lt,
+        le=le,
+        min_length=min_length,
+        max_length=max_length,
+        regex=regex,
+        example=example,
+        examples=examples,
+        deprecated=deprecated,
+        **extra,
+    )
+
+
+def Header(  # noqa: N802
+    default: Any,
+    *,
+    alias: Optional[str] = None,
+    convert_underscores: bool = True,
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+    gt: Optional[float] = None,
+    ge: Optional[float] = None,
+    lt: Optional[float] = None,
+    le: Optional[float] = None,
+    min_length: Optional[int] = None,
+    max_length: Optional[int] = None,
+    regex: Optional[str] = None,
+    example: Any = Undefined,
+    examples: Optional[Dict[str, Any]] = None,
+    deprecated: Optional[bool] = None,
+    **extra: Any,
+) -> Any:
+    return params.Header(
+        default,
+        alias=alias,
+        convert_underscores=convert_underscores,
+        title=title,
+        description=description,
+        gt=gt,
+        ge=ge,
+        lt=lt,
+        le=le,
+        min_length=min_length,
+        max_length=max_length,
+        regex=regex,
+        example=example,
+        examples=examples,
+        deprecated=deprecated,
+        **extra,
+    )
+
+
+def Cookie(  # noqa: N802
+    default: Any,
+    *,
+    alias: Optional[str] = None,
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+    gt: Optional[float] = None,
+    ge: Optional[float] = None,
+    lt: Optional[float] = None,
+    le: Optional[float] = None,
+    min_length: Optional[int] = None,
+    max_length: Optional[int] = None,
+    regex: Optional[str] = None,
+    example: Any = Undefined,
+    examples: Optional[Dict[str, Any]] = None,
+    deprecated: Optional[bool] = None,
+    **extra: Any,
+) -> Any:
+    return params.Cookie(
+        default,
+        alias=alias,
+        title=title,
+        description=description,
+        gt=gt,
+        ge=ge,
+        lt=lt,
+        le=le,
+        min_length=min_length,
+        max_length=max_length,
+        regex=regex,
+        example=example,
+        examples=examples,
+        deprecated=deprecated,
+        **extra,
+    )
+
+
+def Body(  # noqa: N802
+    default: Any,
+    *,
+    embed: bool = False,
+    media_type: str = "application/json",
+    alias: Optional[str] = None,
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+    gt: Optional[float] = None,
+    ge: Optional[float] = None,
+    lt: Optional[float] = None,
+    le: Optional[float] = None,
+    min_length: Optional[int] = None,
+    max_length: Optional[int] = None,
+    regex: Optional[str] = None,
+    example: Any = Undefined,
+    examples: Optional[Dict[str, Any]] = None,
+    **extra: Any,
+) -> Any:
+    return params.Body(
+        default,
+        embed=embed,
+        media_type=media_type,
+        alias=alias,
+        title=title,
+        description=description,
+        gt=gt,
+        ge=ge,
+        lt=lt,
+        le=le,
+        min_length=min_length,
+        max_length=max_length,
+        regex=regex,
+        example=example,
+        examples=examples,
+        **extra,
+    )
+
+
+def Form(  # noqa: N802
+    default: Any,
+    *,
+    media_type: str = "application/x-www-form-urlencoded",
+    alias: Optional[str] = None,
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+    gt: Optional[float] = None,
+    ge: Optional[float] = None,
+    lt: Optional[float] = None,
+    le: Optional[float] = None,
+    min_length: Optional[int] = None,
+    max_length: Optional[int] = None,
+    regex: Optional[str] = None,
+    example: Any = Undefined,
+    examples: Optional[Dict[str, Any]] = None,
+    **extra: Any,
+) -> Any:
+    return params.Form(
+        default,
+        media_type=media_type,
+        alias=alias,
+        title=title,
+        description=description,
+        gt=gt,
+        ge=ge,
+        lt=lt,
+        le=le,
+        min_length=min_length,
+        max_length=max_length,
+        regex=regex,
+        example=example,
+        examples=examples,
+        **extra,
+    )
+
+
+def File(  # noqa: N802
+    default: Any,
+    *,
+    media_type: str = "multipart/form-data",
+    alias: Optional[str] = None,
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+    gt: Optional[float] = None,
+    ge: Optional[float] = None,
+    lt: Optional[float] = None,
+    le: Optional[float] = None,
+    min_length: Optional[int] = None,
+    max_length: Optional[int] = None,
+    regex: Optional[str] = None,
+    example: Any = Undefined,
+    examples: Optional[Dict[str, Any]] = None,
+    **extra: Any,
+) -> Any:
+    return params.File(
+        default,
+        media_type=media_type,
+        alias=alias,
+        title=title,
+        description=description,
+        gt=gt,
+        ge=ge,
+        lt=lt,
+        le=le,
+        min_length=min_length,
+        max_length=max_length,
+        regex=regex,
+        example=example,
+        examples=examples,
+        **extra,
+    )
+
+
+def Depends(  # noqa: N802
+    dependency: Optional[Callable[..., Any]] = None, *, use_cache: bool = True
+) -> Any:
+    return params.Depends(dependency=dependency, use_cache=use_cache)
+
+
+def Security(  # noqa: N802
+    dependency: Optional[Callable[..., Any]] = None,
+    *,
+    scopes: Optional[Sequence[str]] = None,
+    use_cache: bool = True,
+) -> Any:
+    return params.Security(dependency=dependency, scopes=scopes, use_cache=use_cache)
diff --git a/myenv/lib/python3.9/site-packages/fastapi/params.py b/myenv/lib/python3.9/site-packages/fastapi/params.py
new file mode 100644
index 0000000..3cab98b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/params.py
@@ -0,0 +1,370 @@
+from enum import Enum
+from typing import Any, Callable, Dict, Optional, Sequence
+
+from pydantic.fields import FieldInfo, Undefined
+
+
+class ParamTypes(Enum):
+    query = "query"
+    header = "header"
+    path = "path"
+    cookie = "cookie"
+
+
+class Param(FieldInfo):
+    in_: ParamTypes
+
+    def __init__(
+        self,
+        default: Any,
+        *,
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        gt: Optional[float] = None,
+        ge: Optional[float] = None,
+        lt: Optional[float] = None,
+        le: Optional[float] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        regex: Optional[str] = None,
+        example: Any = Undefined,
+        examples: Optional[Dict[str, Any]] = None,
+        deprecated: Optional[bool] = None,
+        **extra: Any,
+    ):
+        self.deprecated = deprecated
+        self.example = example
+        self.examples = examples
+        super().__init__(
+            default,
+            alias=alias,
+            title=title,
+            description=description,
+            gt=gt,
+            ge=ge,
+            lt=lt,
+            le=le,
+            min_length=min_length,
+            max_length=max_length,
+            regex=regex,
+            **extra,
+        )
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.default})"
+
+
+class Path(Param):
+    in_ = ParamTypes.path
+
+    def __init__(
+        self,
+        default: Any,
+        *,
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        gt: Optional[float] = None,
+        ge: Optional[float] = None,
+        lt: Optional[float] = None,
+        le: Optional[float] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        regex: Optional[str] = None,
+        example: Any = Undefined,
+        examples: Optional[Dict[str, Any]] = None,
+        deprecated: Optional[bool] = None,
+        **extra: Any,
+    ):
+        self.in_ = self.in_
+        super().__init__(
+            ...,
+            alias=alias,
+            title=title,
+            description=description,
+            gt=gt,
+            ge=ge,
+            lt=lt,
+            le=le,
+            min_length=min_length,
+            max_length=max_length,
+            regex=regex,
+            deprecated=deprecated,
+            example=example,
+            examples=examples,
+            **extra,
+        )
+
+
+class Query(Param):
+    in_ = ParamTypes.query
+
+    def __init__(
+        self,
+        default: Any,
+        *,
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        gt: Optional[float] = None,
+        ge: Optional[float] = None,
+        lt: Optional[float] = None,
+        le: Optional[float] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        regex: Optional[str] = None,
+        example: Any = Undefined,
+        examples: Optional[Dict[str, Any]] = None,
+        deprecated: Optional[bool] = None,
+        **extra: Any,
+    ):
+        super().__init__(
+            default,
+            alias=alias,
+            title=title,
+            description=description,
+            gt=gt,
+            ge=ge,
+            lt=lt,
+            le=le,
+            min_length=min_length,
+            max_length=max_length,
+            regex=regex,
+            deprecated=deprecated,
+            example=example,
+            examples=examples,
+            **extra,
+        )
+
+
+class Header(Param):
+    in_ = ParamTypes.header
+
+    def __init__(
+        self,
+        default: Any,
+        *,
+        alias: Optional[str] = None,
+        convert_underscores: bool = True,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        gt: Optional[float] = None,
+        ge: Optional[float] = None,
+        lt: Optional[float] = None,
+        le: Optional[float] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        regex: Optional[str] = None,
+        example: Any = Undefined,
+        examples: Optional[Dict[str, Any]] = None,
+        deprecated: Optional[bool] = None,
+        **extra: Any,
+    ):
+        self.convert_underscores = convert_underscores
+        super().__init__(
+            default,
+            alias=alias,
+            title=title,
+            description=description,
+            gt=gt,
+            ge=ge,
+            lt=lt,
+            le=le,
+            min_length=min_length,
+            max_length=max_length,
+            regex=regex,
+            deprecated=deprecated,
+            example=example,
+            examples=examples,
+            **extra,
+        )
+
+
+class Cookie(Param):
+    in_ = ParamTypes.cookie
+
+    def __init__(
+        self,
+        default: Any,
+        *,
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        gt: Optional[float] = None,
+        ge: Optional[float] = None,
+        lt: Optional[float] = None,
+        le: Optional[float] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        regex: Optional[str] = None,
+        example: Any = Undefined,
+        examples: Optional[Dict[str, Any]] = None,
+        deprecated: Optional[bool] = None,
+        **extra: Any,
+    ):
+        super().__init__(
+            default,
+            alias=alias,
+            title=title,
+            description=description,
+            gt=gt,
+            ge=ge,
+            lt=lt,
+            le=le,
+            min_length=min_length,
+            max_length=max_length,
+            regex=regex,
+            deprecated=deprecated,
+            example=example,
+            examples=examples,
+            **extra,
+        )
+
+
+class Body(FieldInfo):
+    def __init__(
+        self,
+        default: Any,
+        *,
+        embed: bool = False,
+        media_type: str = "application/json",
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        gt: Optional[float] = None,
+        ge: Optional[float] = None,
+        lt: Optional[float] = None,
+        le: Optional[float] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        regex: Optional[str] = None,
+        example: Any = Undefined,
+        examples: Optional[Dict[str, Any]] = None,
+        **extra: Any,
+    ):
+        self.embed = embed
+        self.media_type = media_type
+        self.example = example
+        self.examples = examples
+        super().__init__(
+            default,
+            alias=alias,
+            title=title,
+            description=description,
+            gt=gt,
+            ge=ge,
+            lt=lt,
+            le=le,
+            min_length=min_length,
+            max_length=max_length,
+            regex=regex,
+            **extra,
+        )
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.default})"
+
+
+class Form(Body):
+    def __init__(
+        self,
+        default: Any,
+        *,
+        media_type: str = "application/x-www-form-urlencoded",
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        gt: Optional[float] = None,
+        ge: Optional[float] = None,
+        lt: Optional[float] = None,
+        le: Optional[float] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        regex: Optional[str] = None,
+        example: Any = Undefined,
+        examples: Optional[Dict[str, Any]] = None,
+        **extra: Any,
+    ):
+        super().__init__(
+            default,
+            embed=True,
+            media_type=media_type,
+            alias=alias,
+            title=title,
+            description=description,
+            gt=gt,
+            ge=ge,
+            lt=lt,
+            le=le,
+            min_length=min_length,
+            max_length=max_length,
+            regex=regex,
+            example=example,
+            examples=examples,
+            **extra,
+        )
+
+
+class File(Form):
+    def __init__(
+        self,
+        default: Any,
+        *,
+        media_type: str = "multipart/form-data",
+        alias: Optional[str] = None,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        gt: Optional[float] = None,
+        ge: Optional[float] = None,
+        lt: Optional[float] = None,
+        le: Optional[float] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        regex: Optional[str] = None,
+        example: Any = Undefined,
+        examples: Optional[Dict[str, Any]] = None,
+        **extra: Any,
+    ):
+        super().__init__(
+            default,
+            media_type=media_type,
+            alias=alias,
+            title=title,
+            description=description,
+            gt=gt,
+            ge=ge,
+            lt=lt,
+            le=le,
+            min_length=min_length,
+            max_length=max_length,
+            regex=regex,
+            example=example,
+            examples=examples,
+            **extra,
+        )
+
+
+class Depends:
+    def __init__(
+        self, dependency: Optional[Callable[..., Any]] = None, *, use_cache: bool = True
+    ):
+        self.dependency = dependency
+        self.use_cache = use_cache
+
+    def __repr__(self) -> str:
+        attr = getattr(self.dependency, "__name__", type(self.dependency).__name__)
+        cache = "" if self.use_cache else ", use_cache=False"
+        return f"{self.__class__.__name__}({attr}{cache})"
+
+
+class Security(Depends):
+    def __init__(
+        self,
+        dependency: Optional[Callable[..., Any]] = None,
+        *,
+        scopes: Optional[Sequence[str]] = None,
+        use_cache: bool = True,
+    ):
+        super().__init__(dependency=dependency, use_cache=use_cache)
+        self.scopes = scopes or []
diff --git a/myenv/lib/python3.9/site-packages/fastapi/py.typed b/myenv/lib/python3.9/site-packages/fastapi/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/fastapi/requests.py b/myenv/lib/python3.9/site-packages/fastapi/requests.py
new file mode 100644
index 0000000..d16552c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/requests.py
@@ -0,0 +1,2 @@
+from starlette.requests import HTTPConnection as HTTPConnection  # noqa: F401
+from starlette.requests import Request as Request  # noqa: F401
diff --git a/myenv/lib/python3.9/site-packages/fastapi/responses.py b/myenv/lib/python3.9/site-packages/fastapi/responses.py
new file mode 100644
index 0000000..6cd7931
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/responses.py
@@ -0,0 +1,34 @@
+from typing import Any
+
+from starlette.responses import FileResponse as FileResponse  # noqa
+from starlette.responses import HTMLResponse as HTMLResponse  # noqa
+from starlette.responses import JSONResponse as JSONResponse  # noqa
+from starlette.responses import PlainTextResponse as PlainTextResponse  # noqa
+from starlette.responses import RedirectResponse as RedirectResponse  # noqa
+from starlette.responses import Response as Response  # noqa
+from starlette.responses import StreamingResponse as StreamingResponse  # noqa
+
+try:
+    import ujson
+except ImportError:  # pragma: nocover
+    ujson = None  # type: ignore
+
+
+try:
+    import orjson
+except ImportError:  # pragma: nocover
+    orjson = None  # type: ignore
+
+
+class UJSONResponse(JSONResponse):
+    def render(self, content: Any) -> bytes:
+        assert ujson is not None, "ujson must be installed to use UJSONResponse"
+        return ujson.dumps(content, ensure_ascii=False).encode("utf-8")
+
+
+class ORJSONResponse(JSONResponse):
+    media_type = "application/json"
+
+    def render(self, content: Any) -> bytes:
+        assert orjson is not None, "orjson must be installed to use ORJSONResponse"
+        return orjson.dumps(content)
diff --git a/myenv/lib/python3.9/site-packages/fastapi/routing.py b/myenv/lib/python3.9/site-packages/fastapi/routing.py
new file mode 100644
index 0000000..63ad729
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/routing.py
@@ -0,0 +1,1150 @@
+import asyncio
+import dataclasses
+import email.message
+import enum
+import inspect
+import json
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Type,
+    Union,
+)
+
+from fastapi import params
+from fastapi.datastructures import Default, DefaultPlaceholder
+from fastapi.dependencies.models import Dependant
+from fastapi.dependencies.utils import (
+    get_body_field,
+    get_dependant,
+    get_parameterless_sub_dependant,
+    solve_dependencies,
+)
+from fastapi.encoders import DictIntStrAny, SetIntStr, jsonable_encoder
+from fastapi.exceptions import RequestValidationError, WebSocketRequestValidationError
+from fastapi.openapi.constants import STATUS_CODES_WITH_NO_BODY
+from fastapi.types import DecoratedCallable
+from fastapi.utils import (
+    create_cloned_field,
+    create_response_field,
+    generate_operation_id_for_path,
+    get_value_or_default,
+)
+from pydantic import BaseModel
+from pydantic.error_wrappers import ErrorWrapper, ValidationError
+from pydantic.fields import ModelField, Undefined
+from starlette import routing
+from starlette.concurrency import run_in_threadpool
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+from starlette.routing import BaseRoute
+from starlette.routing import Mount as Mount  # noqa
+from starlette.routing import (
+    compile_path,
+    get_name,
+    request_response,
+    websocket_session,
+)
+from starlette.status import WS_1008_POLICY_VIOLATION
+from starlette.types import ASGIApp
+from starlette.websockets import WebSocket
+
+
+def _prepare_response_content(
+    res: Any,
+    *,
+    exclude_unset: bool,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+) -> Any:
+    if isinstance(res, BaseModel):
+        read_with_orm_mode = getattr(res.__config__, "read_with_orm_mode", None)
+        if read_with_orm_mode:
+            # Let from_orm extract the data from this model instead of converting
+            # it now to a dict.
+            # Otherwise there's no way to extract lazy data that requires attribute
+            # access instead of dict iteration, e.g. lazy relationships.
+            return res
+        return res.dict(
+            by_alias=True,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+    elif isinstance(res, list):
+        return [
+            _prepare_response_content(
+                item,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+            )
+            for item in res
+        ]
+    elif isinstance(res, dict):
+        return {
+            k: _prepare_response_content(
+                v,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+            )
+            for k, v in res.items()
+        }
+    elif dataclasses.is_dataclass(res):
+        return dataclasses.asdict(res)
+    return res
+
+
+async def serialize_response(
+    *,
+    field: Optional[ModelField] = None,
+    response_content: Any,
+    include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+    exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+    by_alias: bool = True,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+    is_coroutine: bool = True,
+) -> Any:
+    if field:
+        errors = []
+        response_content = _prepare_response_content(
+            response_content,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+        if is_coroutine:
+            value, errors_ = field.validate(response_content, {}, loc=("response",))
+        else:
+            value, errors_ = await run_in_threadpool(
+                field.validate, response_content, {}, loc=("response",)
+            )
+        if isinstance(errors_, ErrorWrapper):
+            errors.append(errors_)
+        elif isinstance(errors_, list):
+            errors.extend(errors_)
+        if errors:
+            raise ValidationError(errors, field.type_)
+        return jsonable_encoder(
+            value,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+    else:
+        return jsonable_encoder(response_content)
+
+
+async def run_endpoint_function(
+    *, dependant: Dependant, values: Dict[str, Any], is_coroutine: bool
+) -> Any:
+    # Only called by get_request_handler. Has been split into its own function to
+    # facilitate profiling endpoints, since inner functions are harder to profile.
+    assert dependant.call is not None, "dependant.call must be a function"
+
+    if is_coroutine:
+        return await dependant.call(**values)
+    else:
+        return await run_in_threadpool(dependant.call, **values)
+
+
+def get_request_handler(
+    dependant: Dependant,
+    body_field: Optional[ModelField] = None,
+    status_code: Optional[int] = None,
+    response_class: Union[Type[Response], DefaultPlaceholder] = Default(JSONResponse),
+    response_field: Optional[ModelField] = None,
+    response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+    response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+    response_model_by_alias: bool = True,
+    response_model_exclude_unset: bool = False,
+    response_model_exclude_defaults: bool = False,
+    response_model_exclude_none: bool = False,
+    dependency_overrides_provider: Optional[Any] = None,
+) -> Callable[[Request], Coroutine[Any, Any, Response]]:
+    assert dependant.call is not None, "dependant.call must be a function"
+    is_coroutine = asyncio.iscoroutinefunction(dependant.call)
+    is_body_form = body_field and isinstance(body_field.field_info, params.Form)
+    if isinstance(response_class, DefaultPlaceholder):
+        actual_response_class: Type[Response] = response_class.value
+    else:
+        actual_response_class = response_class
+
+    async def app(request: Request) -> Response:
+        try:
+            body: Any = None
+            if body_field:
+                if is_body_form:
+                    body = await request.form()
+                else:
+                    body_bytes = await request.body()
+                    if body_bytes:
+                        json_body: Any = Undefined
+                        content_type_value = request.headers.get("content-type")
+                        if not content_type_value:
+                            json_body = await request.json()
+                        else:
+                            message = email.message.Message()
+                            message["content-type"] = content_type_value
+                            if message.get_content_maintype() == "application":
+                                subtype = message.get_content_subtype()
+                                if subtype == "json" or subtype.endswith("+json"):
+                                    json_body = await request.json()
+                        if json_body != Undefined:
+                            body = json_body
+                        else:
+                            body = body_bytes
+        except json.JSONDecodeError as e:
+            raise RequestValidationError([ErrorWrapper(e, ("body", e.pos))], body=e.doc)
+        except Exception as e:
+            raise HTTPException(
+                status_code=400, detail="There was an error parsing the body"
+            ) from e
+        solved_result = await solve_dependencies(
+            request=request,
+            dependant=dependant,
+            body=body,
+            dependency_overrides_provider=dependency_overrides_provider,
+        )
+        values, errors, background_tasks, sub_response, _ = solved_result
+        if errors:
+            raise RequestValidationError(errors, body=body)
+        else:
+            raw_response = await run_endpoint_function(
+                dependant=dependant, values=values, is_coroutine=is_coroutine
+            )
+
+            if isinstance(raw_response, Response):
+                if raw_response.background is None:
+                    raw_response.background = background_tasks
+                return raw_response
+            response_data = await serialize_response(
+                field=response_field,
+                response_content=raw_response,
+                include=response_model_include,
+                exclude=response_model_exclude,
+                by_alias=response_model_by_alias,
+                exclude_unset=response_model_exclude_unset,
+                exclude_defaults=response_model_exclude_defaults,
+                exclude_none=response_model_exclude_none,
+                is_coroutine=is_coroutine,
+            )
+            response_args: Dict[str, Any] = {"background": background_tasks}
+            # If status_code was set, use it, otherwise use the default from the
+            # response class, in the case of redirect it's 307
+            if status_code is not None:
+                response_args["status_code"] = status_code
+            response = actual_response_class(response_data, **response_args)
+            response.headers.raw.extend(sub_response.headers.raw)
+            if sub_response.status_code:
+                response.status_code = sub_response.status_code
+            return response
+
+    return app
+
+
+def get_websocket_app(
+    dependant: Dependant, dependency_overrides_provider: Optional[Any] = None
+) -> Callable[[WebSocket], Coroutine[Any, Any, Any]]:
+    async def app(websocket: WebSocket) -> None:
+        solved_result = await solve_dependencies(
+            request=websocket,
+            dependant=dependant,
+            dependency_overrides_provider=dependency_overrides_provider,
+        )
+        values, errors, _, _2, _3 = solved_result
+        if errors:
+            await websocket.close(code=WS_1008_POLICY_VIOLATION)
+            raise WebSocketRequestValidationError(errors)
+        assert dependant.call is not None, "dependant.call must be a function"
+        await dependant.call(**values)
+
+    return app
+
+
+class APIWebSocketRoute(routing.WebSocketRoute):
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        *,
+        name: Optional[str] = None,
+        dependency_overrides_provider: Optional[Any] = None,
+    ) -> None:
+        self.path = path
+        self.endpoint = endpoint
+        self.name = get_name(endpoint) if name is None else name
+        self.dependant = get_dependant(path=path, call=self.endpoint)
+        self.app = websocket_session(
+            get_websocket_app(
+                dependant=self.dependant,
+                dependency_overrides_provider=dependency_overrides_provider,
+            )
+        )
+        self.path_regex, self.path_format, self.param_convertors = compile_path(path)
+
+
+class APIRoute(routing.Route):
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        name: Optional[str] = None,
+        methods: Optional[Union[Set[str], List[str]]] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Union[Type[Response], DefaultPlaceholder] = Default(
+            JSONResponse
+        ),
+        dependency_overrides_provider: Optional[Any] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        # normalise enums e.g. http.HTTPStatus
+        if isinstance(status_code, enum.IntEnum):
+            status_code = int(status_code)
+        self.path = path
+        self.endpoint = endpoint
+        self.name = get_name(endpoint) if name is None else name
+        self.path_regex, self.path_format, self.param_convertors = compile_path(path)
+        if methods is None:
+            methods = ["GET"]
+        self.methods: Set[str] = set([method.upper() for method in methods])
+        self.unique_id = generate_operation_id_for_path(
+            name=self.name, path=self.path_format, method=list(methods)[0]
+        )
+        self.response_model = response_model
+        if self.response_model:
+            assert (
+                status_code not in STATUS_CODES_WITH_NO_BODY
+            ), f"Status code {status_code} must not have a response body"
+            response_name = "Response_" + self.unique_id
+            self.response_field = create_response_field(
+                name=response_name, type_=self.response_model
+            )
+            # Create a clone of the field, so that a Pydantic submodel is not returned
+            # as is just because it's an instance of a subclass of a more limited class
+            # e.g. UserInDB (containing hashed_password) could be a subclass of User
+            # that doesn't have the hashed_password. But because it's a subclass, it
+            # would pass the validation and be returned as is.
+            # By being a new field, no inheritance will be passed as is. A new model
+            # will be always created.
+            self.secure_cloned_response_field: Optional[
+                ModelField
+            ] = create_cloned_field(self.response_field)
+        else:
+            self.response_field = None  # type: ignore
+            self.secure_cloned_response_field = None
+        self.status_code = status_code
+        self.tags = tags or []
+        if dependencies:
+            self.dependencies = list(dependencies)
+        else:
+            self.dependencies = []
+        self.summary = summary
+        self.description = description or inspect.cleandoc(self.endpoint.__doc__ or "")
+        # if a "form feed" character (page break) is found in the description text,
+        # truncate description text to the content preceding the first "form feed"
+        self.description = self.description.split("\f")[0]
+        self.response_description = response_description
+        self.responses = responses or {}
+        response_fields = {}
+        for additional_status_code, response in self.responses.items():
+            assert isinstance(response, dict), "An additional response must be a dict"
+            model = response.get("model")
+            if model:
+                assert (
+                    additional_status_code not in STATUS_CODES_WITH_NO_BODY
+                ), f"Status code {additional_status_code} must not have a response body"
+                response_name = f"Response_{additional_status_code}_{self.unique_id}"
+                response_field = create_response_field(name=response_name, type_=model)
+                response_fields[additional_status_code] = response_field
+        if response_fields:
+            self.response_fields: Dict[Union[int, str], ModelField] = response_fields
+        else:
+            self.response_fields = {}
+        self.deprecated = deprecated
+        self.operation_id = operation_id
+        self.response_model_include = response_model_include
+        self.response_model_exclude = response_model_exclude
+        self.response_model_by_alias = response_model_by_alias
+        self.response_model_exclude_unset = response_model_exclude_unset
+        self.response_model_exclude_defaults = response_model_exclude_defaults
+        self.response_model_exclude_none = response_model_exclude_none
+        self.include_in_schema = include_in_schema
+        self.response_class = response_class
+
+        assert callable(endpoint), "An endpoint must be a callable"
+        self.dependant = get_dependant(path=self.path_format, call=self.endpoint)
+        for depends in self.dependencies[::-1]:
+            self.dependant.dependencies.insert(
+                0,
+                get_parameterless_sub_dependant(depends=depends, path=self.path_format),
+            )
+        self.body_field = get_body_field(dependant=self.dependant, name=self.unique_id)
+        self.dependency_overrides_provider = dependency_overrides_provider
+        self.callbacks = callbacks
+        self.app = request_response(self.get_route_handler())
+        self.openapi_extra = openapi_extra
+
+    def get_route_handler(self) -> Callable[[Request], Coroutine[Any, Any, Response]]:
+        return get_request_handler(
+            dependant=self.dependant,
+            body_field=self.body_field,
+            status_code=self.status_code,
+            response_class=self.response_class,
+            response_field=self.secure_cloned_response_field,
+            response_model_include=self.response_model_include,
+            response_model_exclude=self.response_model_exclude,
+            response_model_by_alias=self.response_model_by_alias,
+            response_model_exclude_unset=self.response_model_exclude_unset,
+            response_model_exclude_defaults=self.response_model_exclude_defaults,
+            response_model_exclude_none=self.response_model_exclude_none,
+            dependency_overrides_provider=self.dependency_overrides_provider,
+        )
+
+
+class APIRouter(routing.Router):
+    def __init__(
+        self,
+        *,
+        prefix: str = "",
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        default_response_class: Type[Response] = Default(JSONResponse),
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        routes: Optional[List[routing.BaseRoute]] = None,
+        redirect_slashes: bool = True,
+        default: Optional[ASGIApp] = None,
+        dependency_overrides_provider: Optional[Any] = None,
+        route_class: Type[APIRoute] = APIRoute,
+        on_startup: Optional[Sequence[Callable[[], Any]]] = None,
+        on_shutdown: Optional[Sequence[Callable[[], Any]]] = None,
+        deprecated: Optional[bool] = None,
+        include_in_schema: bool = True,
+    ) -> None:
+        super().__init__(
+            routes=routes,  # type: ignore # in Starlette
+            redirect_slashes=redirect_slashes,
+            default=default,  # type: ignore # in Starlette
+            on_startup=on_startup,  # type: ignore # in Starlette
+            on_shutdown=on_shutdown,  # type: ignore # in Starlette
+        )
+        if prefix:
+            assert prefix.startswith("/"), "A path prefix must start with '/'"
+            assert not prefix.endswith(
+                "/"
+            ), "A path prefix must not end with '/', as the routes will start with '/'"
+        self.prefix = prefix
+        self.tags: List[str] = tags or []
+        self.dependencies = list(dependencies or []) or []
+        self.deprecated = deprecated
+        self.include_in_schema = include_in_schema
+        self.responses = responses or {}
+        self.callbacks = callbacks or []
+        self.dependency_overrides_provider = dependency_overrides_provider
+        self.route_class = route_class
+        self.default_response_class = default_response_class
+
+    def add_api_route(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        methods: Optional[Union[Set[str], List[str]]] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Union[Type[Response], DefaultPlaceholder] = Default(
+            JSONResponse
+        ),
+        name: Optional[str] = None,
+        route_class_override: Optional[Type[APIRoute]] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        route_class = route_class_override or self.route_class
+        responses = responses or {}
+        combined_responses = {**self.responses, **responses}
+        current_response_class = get_value_or_default(
+            response_class, self.default_response_class
+        )
+        current_tags = self.tags.copy()
+        if tags:
+            current_tags.extend(tags)
+        current_dependencies = self.dependencies.copy()
+        if dependencies:
+            current_dependencies.extend(dependencies)
+        current_callbacks = self.callbacks.copy()
+        if callbacks:
+            current_callbacks.extend(callbacks)
+        route = route_class(
+            self.prefix + path,
+            endpoint=endpoint,
+            response_model=response_model,
+            status_code=status_code,
+            tags=current_tags,
+            dependencies=current_dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=combined_responses,
+            deprecated=deprecated or self.deprecated,
+            methods=methods,
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema and self.include_in_schema,
+            response_class=current_response_class,
+            name=name,
+            dependency_overrides_provider=self.dependency_overrides_provider,
+            callbacks=current_callbacks,
+            openapi_extra=openapi_extra,
+        )
+        self.routes.append(route)
+
+    def api_route(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        methods: Optional[List[str]] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        def decorator(func: DecoratedCallable) -> DecoratedCallable:
+            self.add_api_route(
+                path,
+                func,
+                response_model=response_model,
+                status_code=status_code,
+                tags=tags,
+                dependencies=dependencies,
+                summary=summary,
+                description=description,
+                response_description=response_description,
+                responses=responses,
+                deprecated=deprecated,
+                methods=methods,
+                operation_id=operation_id,
+                response_model_include=response_model_include,
+                response_model_exclude=response_model_exclude,
+                response_model_by_alias=response_model_by_alias,
+                response_model_exclude_unset=response_model_exclude_unset,
+                response_model_exclude_defaults=response_model_exclude_defaults,
+                response_model_exclude_none=response_model_exclude_none,
+                include_in_schema=include_in_schema,
+                response_class=response_class,
+                name=name,
+                callbacks=callbacks,
+                openapi_extra=openapi_extra,
+            )
+            return func
+
+        return decorator
+
+    def add_api_websocket_route(
+        self, path: str, endpoint: Callable[..., Any], name: Optional[str] = None
+    ) -> None:
+        route = APIWebSocketRoute(
+            path,
+            endpoint=endpoint,
+            name=name,
+            dependency_overrides_provider=self.dependency_overrides_provider,
+        )
+        self.routes.append(route)
+
+    def websocket(
+        self, path: str, name: Optional[str] = None
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        def decorator(func: DecoratedCallable) -> DecoratedCallable:
+            self.add_api_websocket_route(path, func, name=name)
+            return func
+
+        return decorator
+
+    def include_router(
+        self,
+        router: "APIRouter",
+        *,
+        prefix: str = "",
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        default_response_class: Type[Response] = Default(JSONResponse),
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        deprecated: Optional[bool] = None,
+        include_in_schema: bool = True,
+    ) -> None:
+        if prefix:
+            assert prefix.startswith("/"), "A path prefix must start with '/'"
+            assert not prefix.endswith(
+                "/"
+            ), "A path prefix must not end with '/', as the routes will start with '/'"
+        else:
+            for r in router.routes:
+                path = getattr(r, "path")
+                name = getattr(r, "name", "unknown")
+                if path is not None and not path:
+                    raise Exception(
+                        f"Prefix and path cannot be both empty (path operation: {name})"
+                    )
+        if responses is None:
+            responses = {}
+        for route in router.routes:
+            if isinstance(route, APIRoute):
+                combined_responses = {**responses, **route.responses}
+                use_response_class = get_value_or_default(
+                    route.response_class,
+                    router.default_response_class,
+                    default_response_class,
+                    self.default_response_class,
+                )
+                current_tags = []
+                if tags:
+                    current_tags.extend(tags)
+                if route.tags:
+                    current_tags.extend(route.tags)
+                current_dependencies: List[params.Depends] = []
+                if dependencies:
+                    current_dependencies.extend(dependencies)
+                if route.dependencies:
+                    current_dependencies.extend(route.dependencies)
+                current_callbacks = []
+                if callbacks:
+                    current_callbacks.extend(callbacks)
+                if route.callbacks:
+                    current_callbacks.extend(route.callbacks)
+                self.add_api_route(
+                    prefix + route.path,
+                    route.endpoint,
+                    response_model=route.response_model,
+                    status_code=route.status_code,
+                    tags=current_tags,
+                    dependencies=current_dependencies,
+                    summary=route.summary,
+                    description=route.description,
+                    response_description=route.response_description,
+                    responses=combined_responses,
+                    deprecated=route.deprecated or deprecated or self.deprecated,
+                    methods=route.methods,
+                    operation_id=route.operation_id,
+                    response_model_include=route.response_model_include,
+                    response_model_exclude=route.response_model_exclude,
+                    response_model_by_alias=route.response_model_by_alias,
+                    response_model_exclude_unset=route.response_model_exclude_unset,
+                    response_model_exclude_defaults=route.response_model_exclude_defaults,
+                    response_model_exclude_none=route.response_model_exclude_none,
+                    include_in_schema=route.include_in_schema
+                    and self.include_in_schema
+                    and include_in_schema,
+                    response_class=use_response_class,
+                    name=route.name,
+                    route_class_override=type(route),
+                    callbacks=current_callbacks,
+                    openapi_extra=route.openapi_extra,
+                )
+            elif isinstance(route, routing.Route):
+                methods = list(route.methods or [])  # type: ignore # in Starlette
+                self.add_route(
+                    prefix + route.path,
+                    route.endpoint,
+                    methods=methods,
+                    include_in_schema=route.include_in_schema,
+                    name=route.name,
+                )
+            elif isinstance(route, APIWebSocketRoute):
+                self.add_api_websocket_route(
+                    prefix + route.path, route.endpoint, name=route.name
+                )
+            elif isinstance(route, routing.WebSocketRoute):
+                self.add_websocket_route(
+                    prefix + route.path, route.endpoint, name=route.name
+                )
+        for handler in router.on_startup:
+            self.add_event_handler("startup", handler)
+        for handler in router.on_shutdown:
+            self.add_event_handler("shutdown", handler)
+
+    def get(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.api_route(
+            path=path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            methods=["GET"],
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def put(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.api_route(
+            path=path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            methods=["PUT"],
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def post(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.api_route(
+            path=path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            methods=["POST"],
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def delete(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.api_route(
+            path=path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            methods=["DELETE"],
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def options(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.api_route(
+            path=path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            methods=["OPTIONS"],
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def head(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.api_route(
+            path=path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            methods=["HEAD"],
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def patch(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        return self.api_route(
+            path=path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            methods=["PATCH"],
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
+
+    def trace(
+        self,
+        path: str,
+        *,
+        response_model: Optional[Type[Any]] = None,
+        status_code: Optional[int] = None,
+        tags: Optional[List[str]] = None,
+        dependencies: Optional[Sequence[params.Depends]] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        response_description: str = "Successful Response",
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        deprecated: Optional[bool] = None,
+        operation_id: Optional[str] = None,
+        response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: Type[Response] = Default(JSONResponse),
+        name: Optional[str] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        openapi_extra: Optional[Dict[str, Any]] = None,
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+
+        return self.api_route(
+            path=path,
+            response_model=response_model,
+            status_code=status_code,
+            tags=tags,
+            dependencies=dependencies,
+            summary=summary,
+            description=description,
+            response_description=response_description,
+            responses=responses,
+            deprecated=deprecated,
+            methods=["TRACE"],
+            operation_id=operation_id,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
+            response_class=response_class,
+            name=name,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )
diff --git a/myenv/lib/python3.9/site-packages/fastapi/security/__init__.py b/myenv/lib/python3.9/site-packages/fastapi/security/__init__.py
new file mode 100644
index 0000000..3aa6bf2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/security/__init__.py
@@ -0,0 +1,15 @@
+from .api_key import APIKeyCookie as APIKeyCookie
+from .api_key import APIKeyHeader as APIKeyHeader
+from .api_key import APIKeyQuery as APIKeyQuery
+from .http import HTTPAuthorizationCredentials as HTTPAuthorizationCredentials
+from .http import HTTPBasic as HTTPBasic
+from .http import HTTPBasicCredentials as HTTPBasicCredentials
+from .http import HTTPBearer as HTTPBearer
+from .http import HTTPDigest as HTTPDigest
+from .oauth2 import OAuth2 as OAuth2
+from .oauth2 import OAuth2AuthorizationCodeBearer as OAuth2AuthorizationCodeBearer
+from .oauth2 import OAuth2PasswordBearer as OAuth2PasswordBearer
+from .oauth2 import OAuth2PasswordRequestForm as OAuth2PasswordRequestForm
+from .oauth2 import OAuth2PasswordRequestFormStrict as OAuth2PasswordRequestFormStrict
+from .oauth2 import SecurityScopes as SecurityScopes
+from .open_id_connect_url import OpenIdConnect as OpenIdConnect
diff --git a/myenv/lib/python3.9/site-packages/fastapi/security/api_key.py b/myenv/lib/python3.9/site-packages/fastapi/security/api_key.py
new file mode 100644
index 0000000..36ab60e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/security/api_key.py
@@ -0,0 +1,92 @@
+from typing import Optional
+
+from fastapi.openapi.models import APIKey, APIKeyIn
+from fastapi.security.base import SecurityBase
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.status import HTTP_403_FORBIDDEN
+
+
+class APIKeyBase(SecurityBase):
+    pass
+
+
+class APIKeyQuery(APIKeyBase):
+    def __init__(
+        self,
+        *,
+        name: str,
+        scheme_name: Optional[str] = None,
+        description: Optional[str] = None,
+        auto_error: bool = True
+    ):
+        self.model: APIKey = APIKey(
+            **{"in": APIKeyIn.query}, name=name, description=description
+        )
+        self.scheme_name = scheme_name or self.__class__.__name__
+        self.auto_error = auto_error
+
+    async def __call__(self, request: Request) -> Optional[str]:
+        api_key: str = request.query_params.get(self.model.name)
+        if not api_key:
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_403_FORBIDDEN, detail="Not authenticated"
+                )
+            else:
+                return None
+        return api_key
+
+
+class APIKeyHeader(APIKeyBase):
+    def __init__(
+        self,
+        *,
+        name: str,
+        scheme_name: Optional[str] = None,
+        description: Optional[str] = None,
+        auto_error: bool = True
+    ):
+        self.model: APIKey = APIKey(
+            **{"in": APIKeyIn.header}, name=name, description=description
+        )
+        self.scheme_name = scheme_name or self.__class__.__name__
+        self.auto_error = auto_error
+
+    async def __call__(self, request: Request) -> Optional[str]:
+        api_key: str = request.headers.get(self.model.name)
+        if not api_key:
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_403_FORBIDDEN, detail="Not authenticated"
+                )
+            else:
+                return None
+        return api_key
+
+
+class APIKeyCookie(APIKeyBase):
+    def __init__(
+        self,
+        *,
+        name: str,
+        scheme_name: Optional[str] = None,
+        description: Optional[str] = None,
+        auto_error: bool = True
+    ):
+        self.model: APIKey = APIKey(
+            **{"in": APIKeyIn.cookie}, name=name, description=description
+        )
+        self.scheme_name = scheme_name or self.__class__.__name__
+        self.auto_error = auto_error
+
+    async def __call__(self, request: Request) -> Optional[str]:
+        api_key = request.cookies.get(self.model.name)
+        if not api_key:
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_403_FORBIDDEN, detail="Not authenticated"
+                )
+            else:
+                return None
+        return api_key
diff --git a/myenv/lib/python3.9/site-packages/fastapi/security/base.py b/myenv/lib/python3.9/site-packages/fastapi/security/base.py
new file mode 100644
index 0000000..c43555d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/security/base.py
@@ -0,0 +1,6 @@
+from fastapi.openapi.models import SecurityBase as SecurityBaseModel
+
+
+class SecurityBase:
+    model: SecurityBaseModel
+    scheme_name: str
diff --git a/myenv/lib/python3.9/site-packages/fastapi/security/http.py b/myenv/lib/python3.9/site-packages/fastapi/security/http.py
new file mode 100644
index 0000000..1b473c6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/security/http.py
@@ -0,0 +1,165 @@
+import binascii
+from base64 import b64decode
+from typing import Optional
+
+from fastapi.exceptions import HTTPException
+from fastapi.openapi.models import HTTPBase as HTTPBaseModel
+from fastapi.openapi.models import HTTPBearer as HTTPBearerModel
+from fastapi.security.base import SecurityBase
+from fastapi.security.utils import get_authorization_scheme_param
+from pydantic import BaseModel
+from starlette.requests import Request
+from starlette.status import HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN
+
+
+class HTTPBasicCredentials(BaseModel):
+    username: str
+    password: str
+
+
+class HTTPAuthorizationCredentials(BaseModel):
+    scheme: str
+    credentials: str
+
+
+class HTTPBase(SecurityBase):
+    def __init__(
+        self,
+        *,
+        scheme: str,
+        scheme_name: Optional[str] = None,
+        description: Optional[str] = None,
+        auto_error: bool = True,
+    ):
+        self.model = HTTPBaseModel(scheme=scheme, description=description)
+        self.scheme_name = scheme_name or self.__class__.__name__
+        self.auto_error = auto_error
+
+    async def __call__(
+        self, request: Request
+    ) -> Optional[HTTPAuthorizationCredentials]:
+        authorization: str = request.headers.get("Authorization")
+        scheme, credentials = get_authorization_scheme_param(authorization)
+        if not (authorization and scheme and credentials):
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_403_FORBIDDEN, detail="Not authenticated"
+                )
+            else:
+                return None
+        return HTTPAuthorizationCredentials(scheme=scheme, credentials=credentials)
+
+
+class HTTPBasic(HTTPBase):
+    def __init__(
+        self,
+        *,
+        scheme_name: Optional[str] = None,
+        realm: Optional[str] = None,
+        description: Optional[str] = None,
+        auto_error: bool = True,
+    ):
+        self.model = HTTPBaseModel(scheme="basic", description=description)
+        self.scheme_name = scheme_name or self.__class__.__name__
+        self.realm = realm
+        self.auto_error = auto_error
+
+    async def __call__(  # type: ignore
+        self, request: Request
+    ) -> Optional[HTTPBasicCredentials]:
+        authorization: str = request.headers.get("Authorization")
+        scheme, param = get_authorization_scheme_param(authorization)
+        if self.realm:
+            unauthorized_headers = {"WWW-Authenticate": f'Basic realm="{self.realm}"'}
+        else:
+            unauthorized_headers = {"WWW-Authenticate": "Basic"}
+        invalid_user_credentials_exc = HTTPException(
+            status_code=HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            headers=unauthorized_headers,
+        )
+        if not authorization or scheme.lower() != "basic":
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_401_UNAUTHORIZED,
+                    detail="Not authenticated",
+                    headers=unauthorized_headers,
+                )
+            else:
+                return None
+        try:
+            data = b64decode(param).decode("ascii")
+        except (ValueError, UnicodeDecodeError, binascii.Error):
+            raise invalid_user_credentials_exc
+        username, separator, password = data.partition(":")
+        if not separator:
+            raise invalid_user_credentials_exc
+        return HTTPBasicCredentials(username=username, password=password)
+
+
+class HTTPBearer(HTTPBase):
+    def __init__(
+        self,
+        *,
+        bearerFormat: Optional[str] = None,
+        scheme_name: Optional[str] = None,
+        description: Optional[str] = None,
+        auto_error: bool = True,
+    ):
+        self.model = HTTPBearerModel(bearerFormat=bearerFormat, description=description)
+        self.scheme_name = scheme_name or self.__class__.__name__
+        self.auto_error = auto_error
+
+    async def __call__(
+        self, request: Request
+    ) -> Optional[HTTPAuthorizationCredentials]:
+        authorization: str = request.headers.get("Authorization")
+        scheme, credentials = get_authorization_scheme_param(authorization)
+        if not (authorization and scheme and credentials):
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_403_FORBIDDEN, detail="Not authenticated"
+                )
+            else:
+                return None
+        if scheme.lower() != "bearer":
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_403_FORBIDDEN,
+                    detail="Invalid authentication credentials",
+                )
+            else:
+                return None
+        return HTTPAuthorizationCredentials(scheme=scheme, credentials=credentials)
+
+
+class HTTPDigest(HTTPBase):
+    def __init__(
+        self,
+        *,
+        scheme_name: Optional[str] = None,
+        description: Optional[str] = None,
+        auto_error: bool = True,
+    ):
+        self.model = HTTPBaseModel(scheme="digest", description=description)
+        self.scheme_name = scheme_name or self.__class__.__name__
+        self.auto_error = auto_error
+
+    async def __call__(
+        self, request: Request
+    ) -> Optional[HTTPAuthorizationCredentials]:
+        authorization: str = request.headers.get("Authorization")
+        scheme, credentials = get_authorization_scheme_param(authorization)
+        if not (authorization and scheme and credentials):
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_403_FORBIDDEN, detail="Not authenticated"
+                )
+            else:
+                return None
+        if scheme.lower() != "digest":
+            raise HTTPException(
+                status_code=HTTP_403_FORBIDDEN,
+                detail="Invalid authentication credentials",
+            )
+        return HTTPAuthorizationCredentials(scheme=scheme, credentials=credentials)
diff --git a/myenv/lib/python3.9/site-packages/fastapi/security/oauth2.py b/myenv/lib/python3.9/site-packages/fastapi/security/oauth2.py
new file mode 100644
index 0000000..bdc6e2e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/security/oauth2.py
@@ -0,0 +1,220 @@
+from typing import Any, Dict, List, Optional, Union
+
+from fastapi.exceptions import HTTPException
+from fastapi.openapi.models import OAuth2 as OAuth2Model
+from fastapi.openapi.models import OAuthFlows as OAuthFlowsModel
+from fastapi.param_functions import Form
+from fastapi.security.base import SecurityBase
+from fastapi.security.utils import get_authorization_scheme_param
+from starlette.requests import Request
+from starlette.status import HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN
+
+
+class OAuth2PasswordRequestForm:
+    """
+    This is a dependency class, use it like:
+
+        @app.post("/login")
+        def login(form_data: OAuth2PasswordRequestForm = Depends()):
+            data = form_data.parse()
+            print(data.username)
+            print(data.password)
+            for scope in data.scopes:
+                print(scope)
+            if data.client_id:
+                print(data.client_id)
+            if data.client_secret:
+                print(data.client_secret)
+            return data
+
+
+    It creates the following Form request parameters in your endpoint:
+
+    grant_type: the OAuth2 spec says it is required and MUST be the fixed string "password".
+        Nevertheless, this dependency class is permissive and allows not passing it. If you want to enforce it,
+        use instead the OAuth2PasswordRequestFormStrict dependency.
+    username: username string. The OAuth2 spec requires the exact field name "username".
+    password: password string. The OAuth2 spec requires the exact field name "password".
+    scope: Optional string. Several scopes (each one a string) separated by spaces. E.g.
+        "items:read items:write users:read profile openid"
+    client_id: optional string. OAuth2 recommends sending the client_id and client_secret (if any)
+        using HTTP Basic auth, as: client_id:client_secret
+    client_secret: optional string. OAuth2 recommends sending the client_id and client_secret (if any)
+        using HTTP Basic auth, as: client_id:client_secret
+    """
+
+    def __init__(
+        self,
+        grant_type: str = Form(None, regex="password"),
+        username: str = Form(...),
+        password: str = Form(...),
+        scope: str = Form(""),
+        client_id: Optional[str] = Form(None),
+        client_secret: Optional[str] = Form(None),
+    ):
+        self.grant_type = grant_type
+        self.username = username
+        self.password = password
+        self.scopes = scope.split()
+        self.client_id = client_id
+        self.client_secret = client_secret
+
+
+class OAuth2PasswordRequestFormStrict(OAuth2PasswordRequestForm):
+    """
+    This is a dependency class, use it like:
+
+        @app.post("/login")
+        def login(form_data: OAuth2PasswordRequestFormStrict = Depends()):
+            data = form_data.parse()
+            print(data.username)
+            print(data.password)
+            for scope in data.scopes:
+                print(scope)
+            if data.client_id:
+                print(data.client_id)
+            if data.client_secret:
+                print(data.client_secret)
+            return data
+
+
+    It creates the following Form request parameters in your endpoint:
+
+    grant_type: the OAuth2 spec says it is required and MUST be the fixed string "password".
+        This dependency is strict about it. If you want to be permissive, use instead the
+        OAuth2PasswordRequestForm dependency class.
+    username: username string. The OAuth2 spec requires the exact field name "username".
+    password: password string. The OAuth2 spec requires the exact field name "password".
+    scope: Optional string. Several scopes (each one a string) separated by spaces. E.g.
+        "items:read items:write users:read profile openid"
+    client_id: optional string. OAuth2 recommends sending the client_id and client_secret (if any)
+        using HTTP Basic auth, as: client_id:client_secret
+    client_secret: optional string. OAuth2 recommends sending the client_id and client_secret (if any)
+        using HTTP Basic auth, as: client_id:client_secret
+    """
+
+    def __init__(
+        self,
+        grant_type: str = Form(..., regex="password"),
+        username: str = Form(...),
+        password: str = Form(...),
+        scope: str = Form(""),
+        client_id: Optional[str] = Form(None),
+        client_secret: Optional[str] = Form(None),
+    ):
+        super().__init__(
+            grant_type=grant_type,
+            username=username,
+            password=password,
+            scope=scope,
+            client_id=client_id,
+            client_secret=client_secret,
+        )
+
+
+class OAuth2(SecurityBase):
+    def __init__(
+        self,
+        *,
+        flows: Union[OAuthFlowsModel, Dict[str, Dict[str, Any]]] = OAuthFlowsModel(),
+        scheme_name: Optional[str] = None,
+        description: Optional[str] = None,
+        auto_error: Optional[bool] = True
+    ):
+        self.model = OAuth2Model(flows=flows, description=description)
+        self.scheme_name = scheme_name or self.__class__.__name__
+        self.auto_error = auto_error
+
+    async def __call__(self, request: Request) -> Optional[str]:
+        authorization: str = request.headers.get("Authorization")
+        if not authorization:
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_403_FORBIDDEN, detail="Not authenticated"
+                )
+            else:
+                return None
+        return authorization
+
+
+class OAuth2PasswordBearer(OAuth2):
+    def __init__(
+        self,
+        tokenUrl: str,
+        scheme_name: Optional[str] = None,
+        scopes: Optional[Dict[str, str]] = None,
+        description: Optional[str] = None,
+        auto_error: bool = True,
+    ):
+        if not scopes:
+            scopes = {}
+        flows = OAuthFlowsModel(password={"tokenUrl": tokenUrl, "scopes": scopes})
+        super().__init__(
+            flows=flows,
+            scheme_name=scheme_name,
+            description=description,
+            auto_error=auto_error,
+        )
+
+    async def __call__(self, request: Request) -> Optional[str]:
+        authorization: str = request.headers.get("Authorization")
+        scheme, param = get_authorization_scheme_param(authorization)
+        if not authorization or scheme.lower() != "bearer":
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_401_UNAUTHORIZED,
+                    detail="Not authenticated",
+                    headers={"WWW-Authenticate": "Bearer"},
+                )
+            else:
+                return None
+        return param
+
+
+class OAuth2AuthorizationCodeBearer(OAuth2):
+    def __init__(
+        self,
+        authorizationUrl: str,
+        tokenUrl: str,
+        refreshUrl: Optional[str] = None,
+        scheme_name: Optional[str] = None,
+        scopes: Optional[Dict[str, str]] = None,
+        description: Optional[str] = None,
+        auto_error: bool = True,
+    ):
+        if not scopes:
+            scopes = {}
+        flows = OAuthFlowsModel(
+            authorizationCode={
+                "authorizationUrl": authorizationUrl,
+                "tokenUrl": tokenUrl,
+                "refreshUrl": refreshUrl,
+                "scopes": scopes,
+            }
+        )
+        super().__init__(
+            flows=flows,
+            scheme_name=scheme_name,
+            description=description,
+            auto_error=auto_error,
+        )
+
+    async def __call__(self, request: Request) -> Optional[str]:
+        authorization: str = request.headers.get("Authorization")
+        scheme, param = get_authorization_scheme_param(authorization)
+        if not authorization or scheme.lower() != "bearer":
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_401_UNAUTHORIZED,
+                    detail="Not authenticated",
+                    headers={"WWW-Authenticate": "Bearer"},
+                )
+            else:
+                return None  # pragma: nocover
+        return param
+
+
+class SecurityScopes:
+    def __init__(self, scopes: Optional[List[str]] = None):
+        self.scopes = scopes or []
+        self.scope_str = " ".join(self.scopes)
diff --git a/myenv/lib/python3.9/site-packages/fastapi/security/open_id_connect_url.py b/myenv/lib/python3.9/site-packages/fastapi/security/open_id_connect_url.py
new file mode 100644
index 0000000..dfe9f7b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/security/open_id_connect_url.py
@@ -0,0 +1,34 @@
+from typing import Optional
+
+from fastapi.openapi.models import OpenIdConnect as OpenIdConnectModel
+from fastapi.security.base import SecurityBase
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.status import HTTP_403_FORBIDDEN
+
+
+class OpenIdConnect(SecurityBase):
+    def __init__(
+        self,
+        *,
+        openIdConnectUrl: str,
+        scheme_name: Optional[str] = None,
+        description: Optional[str] = None,
+        auto_error: bool = True
+    ):
+        self.model = OpenIdConnectModel(
+            openIdConnectUrl=openIdConnectUrl, description=description
+        )
+        self.scheme_name = scheme_name or self.__class__.__name__
+        self.auto_error = auto_error
+
+    async def __call__(self, request: Request) -> Optional[str]:
+        authorization: str = request.headers.get("Authorization")
+        if not authorization:
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_403_FORBIDDEN, detail="Not authenticated"
+                )
+            else:
+                return None
+        return authorization
diff --git a/myenv/lib/python3.9/site-packages/fastapi/security/utils.py b/myenv/lib/python3.9/site-packages/fastapi/security/utils.py
new file mode 100644
index 0000000..2da0dd2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/security/utils.py
@@ -0,0 +1,8 @@
+from typing import Tuple
+
+
+def get_authorization_scheme_param(authorization_header_value: str) -> Tuple[str, str]:
+    if not authorization_header_value:
+        return "", ""
+    scheme, _, param = authorization_header_value.partition(" ")
+    return scheme, param
diff --git a/myenv/lib/python3.9/site-packages/fastapi/staticfiles.py b/myenv/lib/python3.9/site-packages/fastapi/staticfiles.py
new file mode 100644
index 0000000..299015d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/staticfiles.py
@@ -0,0 +1 @@
+from starlette.staticfiles import StaticFiles as StaticFiles  # noqa
diff --git a/myenv/lib/python3.9/site-packages/fastapi/templating.py b/myenv/lib/python3.9/site-packages/fastapi/templating.py
new file mode 100644
index 0000000..0cb8684
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/templating.py
@@ -0,0 +1 @@
+from starlette.templating import Jinja2Templates as Jinja2Templates  # noqa
diff --git a/myenv/lib/python3.9/site-packages/fastapi/testclient.py b/myenv/lib/python3.9/site-packages/fastapi/testclient.py
new file mode 100644
index 0000000..4012406
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/testclient.py
@@ -0,0 +1 @@
+from starlette.testclient import TestClient as TestClient  # noqa
diff --git a/myenv/lib/python3.9/site-packages/fastapi/types.py b/myenv/lib/python3.9/site-packages/fastapi/types.py
new file mode 100644
index 0000000..e0bca46
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/types.py
@@ -0,0 +1,3 @@
+from typing import Any, Callable, TypeVar
+
+DecoratedCallable = TypeVar("DecoratedCallable", bound=Callable[..., Any])
diff --git a/myenv/lib/python3.9/site-packages/fastapi/utils.py b/myenv/lib/python3.9/site-packages/fastapi/utils.py
new file mode 100644
index 0000000..8913d85
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/utils.py
@@ -0,0 +1,156 @@
+import functools
+import re
+from dataclasses import is_dataclass
+from enum import Enum
+from typing import Any, Dict, Optional, Set, Type, Union, cast
+
+import fastapi
+from fastapi.datastructures import DefaultPlaceholder, DefaultType
+from fastapi.openapi.constants import REF_PREFIX
+from pydantic import BaseConfig, BaseModel, create_model
+from pydantic.class_validators import Validator
+from pydantic.fields import FieldInfo, ModelField, UndefinedType
+from pydantic.schema import model_process_schema
+from pydantic.utils import lenient_issubclass
+
+
+def get_model_definitions(
+    *,
+    flat_models: Set[Union[Type[BaseModel], Type[Enum]]],
+    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],
+) -> Dict[str, Any]:
+    definitions: Dict[str, Dict[str, Any]] = {}
+    for model in flat_models:
+        m_schema, m_definitions, m_nested_models = model_process_schema(
+            model, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+        )
+        definitions.update(m_definitions)
+        model_name = model_name_map[model]
+        definitions[model_name] = m_schema
+    return definitions
+
+
+def get_path_param_names(path: str) -> Set[str]:
+    return set(re.findall("{(.*?)}", path))
+
+
+def create_response_field(
+    name: str,
+    type_: Type[Any],
+    class_validators: Optional[Dict[str, Validator]] = None,
+    default: Optional[Any] = None,
+    required: Union[bool, UndefinedType] = False,
+    model_config: Type[BaseConfig] = BaseConfig,
+    field_info: Optional[FieldInfo] = None,
+    alias: Optional[str] = None,
+) -> ModelField:
+    """
+    Create a new response field. Raises if type_ is invalid.
+    """
+    class_validators = class_validators or {}
+    field_info = field_info or FieldInfo(None)
+
+    response_field = functools.partial(
+        ModelField,
+        name=name,
+        type_=type_,
+        class_validators=class_validators,
+        default=default,
+        required=required,
+        model_config=model_config,
+        alias=alias,
+    )
+
+    try:
+        return response_field(field_info=field_info)
+    except RuntimeError:
+        raise fastapi.exceptions.FastAPIError(
+            f"Invalid args for response field! Hint: check that {type_} is a valid pydantic field type"
+        )
+
+
+def create_cloned_field(
+    field: ModelField,
+    *,
+    cloned_types: Optional[Dict[Type[BaseModel], Type[BaseModel]]] = None,
+) -> ModelField:
+    # _cloned_types has already cloned types, to support recursive models
+    if cloned_types is None:
+        cloned_types = dict()
+    original_type = field.type_
+    if is_dataclass(original_type) and hasattr(original_type, "__pydantic_model__"):
+        original_type = original_type.__pydantic_model__
+    use_type = original_type
+    if lenient_issubclass(original_type, BaseModel):
+        original_type = cast(Type[BaseModel], original_type)
+        use_type = cloned_types.get(original_type)
+        if use_type is None:
+            use_type = create_model(original_type.__name__, __base__=original_type)
+            cloned_types[original_type] = use_type
+            for f in original_type.__fields__.values():
+                use_type.__fields__[f.name] = create_cloned_field(
+                    f, cloned_types=cloned_types
+                )
+    new_field = create_response_field(name=field.name, type_=use_type)
+    new_field.has_alias = field.has_alias
+    new_field.alias = field.alias
+    new_field.class_validators = field.class_validators
+    new_field.default = field.default
+    new_field.required = field.required
+    new_field.model_config = field.model_config
+    new_field.field_info = field.field_info
+    new_field.allow_none = field.allow_none
+    new_field.validate_always = field.validate_always
+    if field.sub_fields:
+        new_field.sub_fields = [
+            create_cloned_field(sub_field, cloned_types=cloned_types)
+            for sub_field in field.sub_fields
+        ]
+    if field.key_field:
+        new_field.key_field = create_cloned_field(
+            field.key_field, cloned_types=cloned_types
+        )
+    new_field.validators = field.validators
+    new_field.pre_validators = field.pre_validators
+    new_field.post_validators = field.post_validators
+    new_field.parse_json = field.parse_json
+    new_field.shape = field.shape
+    new_field.populate_validators()
+    return new_field
+
+
+def generate_operation_id_for_path(*, name: str, path: str, method: str) -> str:
+    operation_id = name + path
+    operation_id = re.sub("[^0-9a-zA-Z_]", "_", operation_id)
+    operation_id = operation_id + "_" + method.lower()
+    return operation_id
+
+
+def deep_dict_update(main_dict: Dict[Any, Any], update_dict: Dict[Any, Any]) -> None:
+    for key in update_dict:
+        if (
+            key in main_dict
+            and isinstance(main_dict[key], dict)
+            and isinstance(update_dict[key], dict)
+        ):
+            deep_dict_update(main_dict[key], update_dict[key])
+        else:
+            main_dict[key] = update_dict[key]
+
+
+def get_value_or_default(
+    first_item: Union[DefaultPlaceholder, DefaultType],
+    *extra_items: Union[DefaultPlaceholder, DefaultType],
+) -> Union[DefaultPlaceholder, DefaultType]:
+    """
+    Pass items or `DefaultPlaceholder`s by descending priority.
+
+    The first one to _not_ be a `DefaultPlaceholder` will be returned.
+
+    Otherwise, the first item (a `DefaultPlaceholder`) will be returned.
+    """
+    items = (first_item,) + extra_items
+    for item in items:
+        if not isinstance(item, DefaultPlaceholder):
+            return item
+    return first_item
diff --git a/myenv/lib/python3.9/site-packages/fastapi/websockets.py b/myenv/lib/python3.9/site-packages/fastapi/websockets.py
new file mode 100644
index 0000000..bed672a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/fastapi/websockets.py
@@ -0,0 +1,2 @@
+from starlette.websockets import WebSocket as WebSocket  # noqa
+from starlette.websockets import WebSocketDisconnect as WebSocketDisconnect  # noqa
diff --git a/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/LICENSE
new file mode 100644
index 0000000..522fbe2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2017 Anthony Sottile
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/METADATA
new file mode 100644
index 0000000..49ff084
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/METADATA
@@ -0,0 +1,110 @@
+Metadata-Version: 2.1
+Name: future-fstrings
+Version: 1.2.0
+Summary: A backport of fstrings to python<3.6
+Home-page: https://github.com/asottile/future-fstrings
+Author: Anthony Sottile
+Author-email: asottile@umich.edu
+License: MIT
+Platform: UNKNOWN
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
+Description-Content-Type: text/markdown
+Requires-Dist: tokenize-rt (>=3) ; python_version < "3.6"
+Provides-Extra: rewrite
+Requires-Dist: tokenize-rt (>=3) ; extra == 'rewrite'
+
+[![Build Status](https://asottile.visualstudio.com/asottile/_apis/build/status/asottile.future-fstrings?branchName=master)](https://asottile.visualstudio.com/asottile/_build/latest?definitionId=15&branchName=master)
+[![Azure DevOps coverage](https://img.shields.io/azure-devops/coverage/asottile/asottile/15/master.svg)](https://dev.azure.com/asottile/asottile/_build/latest?definitionId=15&branchName=master)
+
+future-fstrings
+===============
+
+A backport of fstrings to python<3.6.
+
+
+## Installation
+
+`pip install future-fstrings`
+
+
+## Usage
+
+Include the following encoding cookie at the top of your file (this replaces
+the utf-8 cookie if you already have it):
+
+```python
+# -*- coding: future_fstrings -*-
+```
+
+And then write python3.6 fstring code as usual!
+
+```python
+# -*- coding: future_fstrings -*-
+thing = 'world'
+print(f'hello {thing}')
+```
+
+```console
+$ python2.7 main.py
+hello world
+```
+
+## Showing transformed source
+
+`future-fstrings` also includes a cli to show transformed source.
+
+```console
+$ future-fstrings-show main.py
+# -*- coding: future_fstrings -*-
+thing = 'world'
+print('hello {}'.format((thing)))
+```
+
+## Transform source for micropython
+
+The `future-fstrings-show` command can be used to transform source before
+distributing.  This can allow you to write f-string code but target platforms
+which do not support f-strings, such as [micropython].
+
+To use this on modern versions of python, install using:
+
+```bash
+pip install future-fstrings[rewrite]
+```
+
+and then use `future-fstrings-show` as above.
+
+For instance:
+
+```bash
+future-fstrings-show code.py > code_rewritten.py
+```
+
+[micropython]: https://github.com/micropython/micropython
+
+## How does this work?
+
+`future-fstrings` has two parts:
+
+1. A utf-8 compatible `codec` which performs source manipulation
+    - The `codec` first decodes the source bytes using the UTF-8 codec
+    - The `codec` then leverages
+      [tokenize-rt](https://github.com/asottile/tokenize-rt) to rewrite
+      f-strings.
+2. A `.pth` file which registers a codec on interpreter startup.
+
+## you may also like
+
+- [future-breakpoint](https://github.com/asottile/future-breakpoint)
+
+
diff --git a/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/RECORD
new file mode 100644
index 0000000..3106ee6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/RECORD
@@ -0,0 +1,10 @@
+../../../bin/future-fstrings-show,sha256=8dSO0wZooi7AfRP9kZ2KvYvOTb-wPFQp8aOOFIlPwEU,255
+aaaaa_future_fstrings.pth,sha256=guBUlzeG4Sx1hSyL74lnGDGibEolIDKiWX3nKRZjDPw,126
+future_fstrings.py,sha256=rISrOdh1700HnkCueIPWTS3ssUiw_FHNrBusXCnJd1c,8262
+future_fstrings-1.2.0.dist-info/LICENSE,sha256=7B5zOcT_kkhS3y9ddBcBIOOnIqqyjItu8gZgw9vporc,1059
+future_fstrings-1.2.0.dist-info/METADATA,sha256=0ji_RA4E-e5D7xUvt77zHTYqt-JqaLImL4woAddyMTg,3160
+future_fstrings-1.2.0.dist-info/WHEEL,sha256=h_aVn5OB2IERUjMbi2pucmR_zzWJtk303YXvhh60NJ8,110
+future_fstrings-1.2.0.dist-info/entry_points.txt,sha256=O36UVAN_0W2gH0yhOquLcMNhstouT3kKhrZ4ErL-QnU,63
+future_fstrings-1.2.0.dist-info/top_level.txt,sha256=LEIf3UDAlbXiS6plxfUkTXe8hgmDEBPWVwso3KMHxDc,16
+future_fstrings-1.2.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+future_fstrings-1.2.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/WHEEL
new file mode 100644
index 0000000..78e6f69
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.33.4)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/entry_points.txt
new file mode 100644
index 0000000..0c8d51b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/entry_points.txt
@@ -0,0 +1,3 @@
+[console_scripts]
+future-fstrings-show = future_fstrings:main
+
diff --git a/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/top_level.txt
new file mode 100644
index 0000000..5c59166
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/future_fstrings-1.2.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+future_fstrings
diff --git a/myenv/lib/python3.9/site-packages/future_fstrings.py b/myenv/lib/python3.9/site-packages/future_fstrings.py
new file mode 100644
index 0000000..97e4711
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/future_fstrings.py
@@ -0,0 +1,297 @@
+from __future__ import absolute_import
+from __future__ import unicode_literals
+
+import argparse
+import codecs
+import encodings
+import io
+import sys
+
+
+utf_8 = encodings.search_function('utf8')
+
+
+class TokenSyntaxError(SyntaxError):
+    def __init__(self, e, token):
+        super(TokenSyntaxError, self).__init__(e)
+        self.e = e
+        self.token = token
+
+
+def _find_literal(s, start, level, parts, exprs):
+    """Roughly Python/ast.c:fstring_find_literal"""
+    i = start
+    parse_expr = True
+
+    while i < len(s):
+        ch = s[i]
+
+        if ch in ('{', '}'):
+            if level == 0:
+                if i + 1 < len(s) and s[i + 1] == ch:
+                    i += 2
+                    parse_expr = False
+                    break
+                elif ch == '}':
+                    raise SyntaxError("f-string: single '}' is not allowed")
+            break
+
+        i += 1
+
+    parts.append(s[start:i])
+    return i, parse_expr and i < len(s)
+
+
+def _find_expr(s, start, level, parts, exprs):
+    """Roughly Python/ast.c:fstring_find_expr"""
+    i = start
+    nested_depth = 0
+    quote_char = None
+    triple_quoted = None
+
+    def _check_end():
+        if i == len(s):
+            raise SyntaxError("f-string: expecting '}'")
+
+    if level >= 2:
+        raise SyntaxError("f-string: expressions nested too deeply")
+
+    parts.append(s[i])
+    i += 1
+
+    while i < len(s):
+        ch = s[i]
+
+        if ch == '\\':
+            raise SyntaxError(
+                'f-string expression part cannot include a backslash',
+            )
+        if quote_char is not None:
+            if ch == quote_char:
+                if triple_quoted:
+                    if i + 2 < len(s) and s[i + 1] == ch and s[i + 2] == ch:
+                        i += 2
+                        quote_char = None
+                        triple_quoted = None
+                else:
+                    quote_char = None
+                    triple_quoted = None
+        elif ch in ('"', "'"):
+            quote_char = ch
+            if i + 2 < len(s) and s[i + 1] == ch and s[i + 2] == ch:
+                triple_quoted = True
+                i += 2
+            else:
+                triple_quoted = False
+        elif ch in ('[', '{', '('):
+            nested_depth += 1
+        elif nested_depth and ch in (']', '}', ')'):
+            nested_depth -= 1
+        elif ch == '#':
+            raise SyntaxError("f-string expression cannot include '#'")
+        elif nested_depth == 0 and ch in ('!', ':', '}'):
+            if ch == '!' and i + 1 < len(s) and s[i + 1] == '=':
+                # Allow != at top level as `=` isn't a valid conversion
+                pass
+            else:
+                break
+        i += 1
+
+    if quote_char is not None:
+        raise SyntaxError('f-string: unterminated string')
+    elif nested_depth:
+        raise SyntaxError("f-string: mismatched '(', '{', or '['")
+    _check_end()
+
+    exprs.append(s[start + 1:i])
+
+    if s[i] == '!':
+        parts.append(s[i])
+        i += 1
+        _check_end()
+        parts.append(s[i])
+        i += 1
+
+    _check_end()
+
+    if s[i] == ':':
+        parts.append(s[i])
+        i += 1
+        _check_end()
+        i = _fstring_parse(s, i, level + 1, parts, exprs)
+
+    _check_end()
+    if s[i] != '}':
+        raise SyntaxError("f-string: expecting '}'")
+
+    parts.append(s[i])
+    i += 1
+    return i
+
+
+def _fstring_parse(s, i, level, parts, exprs):
+    """Roughly Python/ast.c:fstring_find_literal_and_expr"""
+    while True:
+        i, parse_expr = _find_literal(s, i, level, parts, exprs)
+        if i == len(s) or s[i] == '}':
+            return i
+        if parse_expr:
+            i = _find_expr(s, i, level, parts, exprs)
+
+
+def _fstring_parse_outer(s, i, level, parts, exprs):
+    for q in ('"' * 3, "'" * 3, '"', "'"):
+        if s.startswith(q):
+            s = s[len(q):len(s) - len(q)]
+            break
+    else:
+        raise AssertionError('unreachable')
+    parts.append(q)
+    ret = _fstring_parse(s, i, level, parts, exprs)
+    parts.append(q)
+    return ret
+
+
+def _is_f(token):
+    import tokenize_rt
+
+    prefix, _ = tokenize_rt.parse_string_literal(token.src)
+    return 'f' in prefix.lower()
+
+
+def _make_fstring(tokens):
+    import tokenize_rt
+
+    new_tokens = []
+    exprs = []
+
+    for i, token in enumerate(tokens):
+        if token.name == 'STRING' and _is_f(token):
+            prefix, s = tokenize_rt.parse_string_literal(token.src)
+            parts = []
+            try:
+                _fstring_parse_outer(s, 0, 0, parts, exprs)
+            except SyntaxError as e:
+                raise TokenSyntaxError(e, tokens[i - 1])
+            if 'r' in prefix.lower():
+                parts = [s.replace('\\', '\\\\') for s in parts]
+            token = token._replace(src=''.join(parts))
+        elif token.name == 'STRING':
+            new_src = token.src.replace('{', '{{').replace('}', '}}')
+            token = token._replace(src=new_src)
+        new_tokens.append(token)
+
+    exprs = ('({})'.format(expr) for expr in exprs)
+    format_src = '.format({})'.format(', '.join(exprs))
+    new_tokens.append(tokenize_rt.Token('FORMAT', src=format_src))
+
+    return new_tokens
+
+
+def decode(b, errors='strict'):
+    import tokenize_rt  # pip install future-fstrings[rewrite]
+
+    u, length = utf_8.decode(b, errors)
+    tokens = tokenize_rt.src_to_tokens(u)
+
+    to_replace = []
+    start = end = seen_f = None
+
+    for i, token in enumerate(tokens):
+        if start is None:
+            if token.name == 'STRING':
+                start, end = i, i + 1
+                seen_f = _is_f(token)
+        elif token.name == 'STRING':
+            end = i + 1
+            seen_f |= _is_f(token)
+        elif token.name not in tokenize_rt.NON_CODING_TOKENS:
+            if seen_f:
+                to_replace.append((start, end))
+            start = end = seen_f = None
+
+    for start, end in reversed(to_replace):
+        try:
+            tokens[start:end] = _make_fstring(tokens[start:end])
+        except TokenSyntaxError as e:
+            msg = str(e.e)
+            line = u.splitlines()[e.token.line - 1]
+            bts = line.encode('UTF-8')[:e.token.utf8_byte_offset]
+            indent = len(bts.decode('UTF-8'))
+            raise SyntaxError(msg + '\n\n' + line + '\n' + ' ' * indent + '^')
+    return tokenize_rt.tokens_to_src(tokens), length
+
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, input, errors, final):  # pragma: no cover
+        if final:
+            return decode(input, errors)
+        else:
+            return '', 0
+
+
+class StreamReader(utf_8.streamreader, object):
+    """decode is deferred to support better error messages"""
+    _stream = None
+    _decoded = False
+
+    @property
+    def stream(self):
+        if not self._decoded:
+            text, _ = decode(self._stream.read())
+            self._stream = io.BytesIO(text.encode('UTF-8'))
+            self._decoded = True
+        return self._stream
+
+    @stream.setter
+    def stream(self, stream):
+        self._stream = stream
+        self._decoded = False
+
+
+def _natively_supports_fstrings():
+    try:
+        return eval('f"hi"') == 'hi'
+    except SyntaxError:
+        return False
+
+
+fstring_decode = decode
+SUPPORTS_FSTRINGS = _natively_supports_fstrings()
+if SUPPORTS_FSTRINGS:  # pragma: no cover
+    decode = utf_8.decode  # noqa
+    IncrementalDecoder = utf_8.incrementaldecoder  # noqa
+    StreamReader = utf_8.streamreader  # noqa
+
+# codec api
+
+codec_map = {
+    name: codecs.CodecInfo(
+        name=name,
+        encode=utf_8.encode,
+        decode=decode,
+        incrementalencoder=utf_8.incrementalencoder,
+        incrementaldecoder=IncrementalDecoder,
+        streamreader=StreamReader,
+        streamwriter=utf_8.streamwriter,
+    )
+    for name in ('future-fstrings', 'future_fstrings')
+}
+
+
+def register():  # pragma: no cover
+    codecs.register(codec_map.get)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description='Prints transformed source.')
+    parser.add_argument('filename')
+    args = parser.parse_args(argv)
+
+    with open(args.filename, 'rb') as f:
+        text, _ = fstring_decode(f.read())
+    getattr(sys.stdout, 'buffer', sys.stdout).write(text.encode('UTF-8'))
+
+
+if __name__ == '__main__':
+    exit(main())
diff --git a/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/LICENSE.txt b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/LICENSE.txt
new file mode 100644
index 0000000..8f080ea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/LICENSE.txt
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Nathaniel J. Smith <njs@pobox.com> and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/METADATA
new file mode 100644
index 0000000..5478c3c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/METADATA
@@ -0,0 +1,194 @@
+Metadata-Version: 2.1
+Name: h11
+Version: 0.12.0
+Summary: A pure-Python, bring-your-own-I/O implementation of HTTP/1.1
+Home-page: https://github.com/python-hyper/h11
+Author: Nathaniel J. Smith
+Author-email: njs@pobox.com
+License: MIT
+Platform: UNKNOWN
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.6
+
+h11
+===
+
+.. image:: https://travis-ci.org/python-hyper/h11.svg?branch=master
+   :target: https://travis-ci.org/python-hyper/h11
+   :alt: Automated test status
+
+.. image:: https://codecov.io/gh/python-hyper/h11/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/python-hyper/h11
+   :alt: Test coverage
+
+.. image:: https://readthedocs.org/projects/h11/badge/?version=latest
+   :target: http://h11.readthedocs.io/en/latest/?badge=latest
+   :alt: Documentation Status
+
+This is a little HTTP/1.1 library written from scratch in Python,
+heavily inspired by `hyper-h2 <https://hyper-h2.readthedocs.io/>`_.
+
+It's a "bring-your-own-I/O" library; h11 contains no IO code
+whatsoever. This means you can hook h11 up to your favorite network
+API, and that could be anything you want: synchronous, threaded,
+asynchronous, or your own implementation of `RFC 6214
+<https://tools.ietf.org/html/rfc6214>`_ -- h11 won't judge you.
+(Compare this to the current state of the art, where every time a `new
+network API <https://trio.readthedocs.io/>`_ comes along then someone
+gets to start over reimplementing the entire HTTP protocol from
+scratch.) Cory Benfield made an `excellent blog post describing the
+benefits of this approach
+<https://lukasa.co.uk/2015/10/The_New_Hyper/>`_, or if you like video
+then here's his `PyCon 2016 talk on the same theme
+<https://www.youtube.com/watch?v=7cC3_jGwl_U>`_.
+
+This also means that h11 is not immediately useful out of the box:
+it's a toolkit for building programs that speak HTTP, not something
+that could directly replace ``requests`` or ``twisted.web`` or
+whatever. But h11 makes it much easier to implement something like
+``requests`` or ``twisted.web``.
+
+At a high level, working with h11 goes like this:
+
+1) First, create an ``h11.Connection`` object to track the state of a
+   single HTTP/1.1 connection.
+
+2) When you read data off the network, pass it to
+   ``conn.receive_data(...)``; you'll get back a list of objects
+   representing high-level HTTP "events".
+
+3) When you want to send a high-level HTTP event, create the
+   corresponding "event" object and pass it to ``conn.send(...)``;
+   this will give you back some bytes that you can then push out
+   through the network.
+
+For example, a client might instantiate and then send a
+``h11.Request`` object, then zero or more ``h11.Data`` objects for the
+request body (e.g., if this is a POST), and then a
+``h11.EndOfMessage`` to indicate the end of the message. Then the
+server would then send back a ``h11.Response``, some ``h11.Data``, and
+its own ``h11.EndOfMessage``. If either side violates the protocol,
+you'll get a ``h11.ProtocolError`` exception.
+
+h11 is suitable for implementing both servers and clients, and has a
+pleasantly symmetric API: the events you send as a client are exactly
+the ones that you receive as a server and vice-versa.
+
+`Here's an example of a tiny HTTP client
+<https://github.com/python-hyper/h11/blob/master/examples/basic-client.py>`_
+
+It also has `a fine manual <https://h11.readthedocs.io/>`_.
+
+FAQ
+---
+
+*Whyyyyy?*
+
+I wanted to play with HTTP in `Curio
+<https://curio.readthedocs.io/en/latest/tutorial.html>`__ and `Trio
+<https://trio.readthedocs.io>`__, which at the time didn't have any
+HTTP libraries. So I thought, no big deal, Python has, like, a dozen
+different implementations of HTTP, surely I can find one that's
+reusable. I didn't find one, but I did find Cory's call-to-arms
+blog-post. So I figured, well, fine, if I have to implement HTTP from
+scratch, at least I can make sure no-one *else* has to ever again.
+
+*Should I use it?*
+
+Maybe. You should be aware that it's a very young project. But, it's
+feature complete and has an exhaustive test-suite and complete docs,
+so the next step is for people to try using it and see how it goes
+:-). If you do then please let us know -- if nothing else we'll want
+to talk to you before making any incompatible changes!
+
+*What are the features/limitations?*
+
+Roughly speaking, it's trying to be a robust, complete, and non-hacky
+implementation of the first "chapter" of the HTTP/1.1 spec: `RFC 7230:
+HTTP/1.1 Message Syntax and Routing
+<https://tools.ietf.org/html/rfc7230>`_. That is, it mostly focuses on
+implementing HTTP at the level of taking bytes on and off the wire,
+and the headers related to that, and tries to be anal about spec
+conformance. It doesn't know about higher-level concerns like URL
+routing, conditional GETs, cross-origin cookie policies, or content
+negotiation. But it does know how to take care of framing,
+cross-version differences in keep-alive handling, and the "obsolete
+line folding" rule, so you can focus your energies on the hard /
+interesting parts for your application, and it tries to support the
+full specification in the sense that any useful HTTP/1.1 conformant
+application should be able to use h11.
+
+It's pure Python, and has no dependencies outside of the standard
+library.
+
+It has a test suite with 100.0% coverage for both statements and
+branches.
+
+Currently it supports Python 3 (testing on 3.6-3.9) and PyPy 3.
+The last Python 2-compatible version was h11 0.11.x.
+(Originally it had a Cython wrapper for `http-parser
+<https://github.com/nodejs/http-parser>`_ and a beautiful nested state
+machine implemented with ``yield from`` to postprocess the output. But
+I had to take these out -- the new *parser* needs fewer lines-of-code
+than the old *parser wrapper*, is written in pure Python, uses no
+exotic language syntax, and has more features. It's sad, really; that
+old state machine was really slick. I just need a few sentences here
+to mourn that.)
+
+I don't know how fast it is. I haven't benchmarked or profiled it yet,
+so it's probably got a few pointless hot spots, and I've been trying
+to err on the side of simplicity and robustness instead of
+micro-optimization. But at the architectural level I tried hard to
+avoid fundamentally bad decisions, e.g., I believe that all the
+parsing algorithms remain linear-time even in the face of pathological
+input like slowloris, and there are no byte-by-byte loops. (I also
+believe that it maintains bounded memory usage in the face of
+arbitrary/pathological input.)
+
+The whole library is ~800 lines-of-code. You can read and understand
+the whole thing in less than an hour. Most of the energy invested in
+this so far has been spent on trying to keep things simple by
+minimizing special-cases and ad hoc state manipulation; even though it
+is now quite small and simple, I'm still annoyed that I haven't
+figured out how to make it even smaller and simpler. (Unfortunately,
+HTTP does not lend itself to simplicity.)
+
+The API is ~feature complete and I don't expect the general outlines
+to change much, but you can't judge an API's ergonomics until you
+actually document and use it, so I'd expect some changes in the
+details.
+
+*How do I try it?*
+
+.. code-block:: sh
+
+  $ pip install h11
+  $ git clone git@github.com:python-hyper/h11
+  $ cd h11/examples
+  $ python basic-client.py
+
+and go from there.
+
+*License?*
+
+MIT
+
+*Code of conduct?*
+
+Contributors are requested to follow our `code of conduct
+<https://github.com/python-hyper/h11/blob/master/CODE_OF_CONDUCT.md>`_ in
+all project spaces.
+
+
diff --git a/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/RECORD
new file mode 100644
index 0000000..a5f2182
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/RECORD
@@ -0,0 +1,29 @@
+h11/__init__.py,sha256=3gYpvQiX8_6-dyXaAxQt_sIYREVTz1T-zB5Lf4hjKt0,909
+h11/_abnf.py,sha256=tMKqgOEkTHHp8sPd_gmU9Qowe_yXXrihct63RX2zJsg,4637
+h11/_connection.py,sha256=XFZ-LPb3C2vgF4v5ifmcJqX-a2tHkItucJ7uIGvPYZA,24964
+h11/_events.py,sha256=IJtM7i2TxKv0S-givq2b-oehPVsmsbsIelTW6NHcIvg,9834
+h11/_headers.py,sha256=P2h8Q39SIFiRS9CpYjAwo_99XKJUvLHjn0U3tnm4qHE,9130
+h11/_readers.py,sha256=DmJKQwH9Iu7U3WNljKB09d6iJIO6P2_WtylJEY3HvPY,7280
+h11/_receivebuffer.py,sha256=pMOLWjS53haaCm73O6tSWKFD_6BQQWzVLqLCm2ouvcE,5029
+h11/_state.py,sha256=Upg0_uiO_C_QNXHxLB4YUprEeoeso0i_ma12SOrrA54,12167
+h11/_util.py,sha256=Lw_CoIUMR8wjnvgKwo94FCdmFcIbRQsokmxpBV7LcTI,4387
+h11/_version.py,sha256=14wRZqPo0n2t5kFKCQLsldnyZAfOZoKPJbbwJnbGPcc,686
+h11/_writers.py,sha256=dj8HQ4Pnzq5SjkUZrgh3RKQ6-8Ecy9RKC1MjSo27y4s,4173
+h11/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h11/tests/helpers.py,sha256=nKheRzldPf278C81d_9_Mb9yWsYJ5udwKg_oq-fAz-U,2528
+h11/tests/test_against_stdlib_http.py,sha256=aA4oDd3_jXkapvW0ER9dbGxIiNt6Ytsfs3U2Rd5XtUc,3700
+h11/tests/test_connection.py,sha256=1WybI9IQROZ0QPtR2wQjetPIR_Jwsvw5i5j2fO7XtcI,36375
+h11/tests/test_events.py,sha256=RTPFBIg81Muc7ZoDhsLwaZxthD76R1UCzHF5nzsbM-Q,5182
+h11/tests/test_headers.py,sha256=pa-WMjCk8ZXJFABkojr2db7ZKrgNKiwl-D-hjjt6-Eg,5390
+h11/tests/test_helpers.py,sha256=mPOAiv4HtyG0_T23K_ihh1JUs0y71ykD47c9r3iVtz0,573
+h11/tests/test_io.py,sha256=oaIEAy3ktA_e1xuyP09fX_GiSlS7GKMlFhQIdkg-EhI,15494
+h11/tests/test_receivebuffer.py,sha256=nZ9_LXj3wfyOn4dkgvjnDjZeNTEtxO8-lNphAB0FVF0,3399
+h11/tests/test_state.py,sha256=JMKqA2d2wtskf7FbsAr1s9qsIul4WtwdXVAOCUJgalk,8551
+h11/tests/test_util.py,sha256=j28tMloUSuhlpUxmgvS1PRurRFSbyzWb7yCTp6qy9_Q,2710
+h11/tests/data/test-file,sha256=ZJ03Rqs98oJw29OHzJg7LlMzyGQaRAY0r3AqBeM2wVU,65
+h11-0.12.0.dist-info/LICENSE.txt,sha256=N9tbuFkm2yikJ6JYZ_ELEjIAOuob5pzLhRE4rbjm82E,1124
+h11-0.12.0.dist-info/METADATA,sha256=_X-4TWqWCxSJ_mDyAbZPzdxHqP290_yVu09nelJOk04,8109
+h11-0.12.0.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+h11-0.12.0.dist-info/top_level.txt,sha256=F7dC4jl3zeh8TGHEPaWJrMbeuoWbS379Gwdi-Yvdcis,4
+h11-0.12.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+h11-0.12.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/WHEEL
new file mode 100644
index 0000000..385faab
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/top_level.txt
new file mode 100644
index 0000000..0d24def
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11-0.12.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+h11
diff --git a/myenv/lib/python3.9/site-packages/h11/__init__.py b/myenv/lib/python3.9/site-packages/h11/__init__.py
new file mode 100644
index 0000000..ae39e01
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/__init__.py
@@ -0,0 +1,21 @@
+# A highish-level implementation of the HTTP/1.1 wire protocol (RFC 7230),
+# containing no networking code at all, loosely modelled on hyper-h2's generic
+# implementation of HTTP/2 (and in particular the h2.connection.H2Connection
+# class). There's still a bunch of subtle details you need to get right if you
+# want to make this actually useful, because it doesn't implement all the
+# semantics to check that what you're asking to write to the wire is sensible,
+# but at least it gets you out of dealing with the wire itself.
+
+from ._connection import *
+from ._events import *
+from ._state import *
+from ._util import LocalProtocolError, ProtocolError, RemoteProtocolError
+from ._version import __version__
+
+PRODUCT_ID = "python-h11/" + __version__
+
+
+__all__ = ["ProtocolError", "LocalProtocolError", "RemoteProtocolError"]
+__all__ += _events.__all__
+__all__ += _connection.__all__
+__all__ += _state.__all__
diff --git a/myenv/lib/python3.9/site-packages/h11/_abnf.py b/myenv/lib/python3.9/site-packages/h11/_abnf.py
new file mode 100644
index 0000000..e6d49e1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/_abnf.py
@@ -0,0 +1,129 @@
+# We use native strings for all the re patterns, to take advantage of string
+# formatting, and then convert to bytestrings when compiling the final re
+# objects.
+
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#whitespace
+#  OWS            = *( SP / HTAB )
+#                 ; optional whitespace
+OWS = r"[ \t]*"
+
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#rule.token.separators
+#   token          = 1*tchar
+#
+#   tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+#                  / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+#                  / DIGIT / ALPHA
+#                  ; any VCHAR, except delimiters
+token = r"[-!#$%&'*+.^_`|~0-9a-zA-Z]+"
+
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#header.fields
+#  field-name     = token
+field_name = token
+
+# The standard says:
+#
+#  field-value    = *( field-content / obs-fold )
+#  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+#  field-vchar    = VCHAR / obs-text
+#  obs-fold       = CRLF 1*( SP / HTAB )
+#                 ; obsolete line folding
+#                 ; see Section 3.2.4
+#
+# https://tools.ietf.org/html/rfc5234#appendix-B.1
+#
+#   VCHAR          =  %x21-7E
+#                  ; visible (printing) characters
+#
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#rule.quoted-string
+#   obs-text       = %x80-FF
+#
+# However, the standard definition of field-content is WRONG! It disallows
+# fields containing a single visible character surrounded by whitespace,
+# e.g. "foo a bar".
+#
+# See: https://www.rfc-editor.org/errata_search.php?rfc=7230&eid=4189
+#
+# So our definition of field_content attempts to fix it up...
+#
+# Also, we allow lots of control characters, because apparently people assume
+# that they're legal in practice (e.g., google analytics makes cookies with
+# \x01 in them!):
+#   https://github.com/python-hyper/h11/issues/57
+# We still don't allow NUL or whitespace, because those are often treated as
+# meta-characters and letting them through can lead to nasty issues like SSRF.
+vchar = r"[\x21-\x7e]"
+vchar_or_obs_text = r"[^\x00\s]"
+field_vchar = vchar_or_obs_text
+field_content = r"{field_vchar}+(?:[ \t]+{field_vchar}+)*".format(**globals())
+
+# We handle obs-fold at a different level, and our fixed-up field_content
+# already grows to swallow the whole value, so ? instead of *
+field_value = r"({field_content})?".format(**globals())
+
+#  header-field   = field-name ":" OWS field-value OWS
+header_field = (
+    r"(?P<field_name>{field_name})"
+    r":"
+    r"{OWS}"
+    r"(?P<field_value>{field_value})"
+    r"{OWS}".format(**globals())
+)
+
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#request.line
+#
+#   request-line   = method SP request-target SP HTTP-version CRLF
+#   method         = token
+#   HTTP-version   = HTTP-name "/" DIGIT "." DIGIT
+#   HTTP-name      = %x48.54.54.50 ; "HTTP", case-sensitive
+#
+# request-target is complicated (see RFC 7230 sec 5.3) -- could be path, full
+# URL, host+port (for connect), or even "*", but in any case we are guaranteed
+# that it contists of the visible printing characters.
+method = token
+request_target = r"{vchar}+".format(**globals())
+http_version = r"HTTP/(?P<http_version>[0-9]\.[0-9])"
+request_line = (
+    r"(?P<method>{method})"
+    r" "
+    r"(?P<target>{request_target})"
+    r" "
+    r"{http_version}".format(**globals())
+)
+
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#status.line
+#
+#   status-line = HTTP-version SP status-code SP reason-phrase CRLF
+#   status-code    = 3DIGIT
+#   reason-phrase  = *( HTAB / SP / VCHAR / obs-text )
+status_code = r"[0-9]{3}"
+reason_phrase = r"([ \t]|{vchar_or_obs_text})*".format(**globals())
+status_line = (
+    r"{http_version}"
+    r" "
+    r"(?P<status_code>{status_code})"
+    # However, there are apparently a few too many servers out there that just
+    # leave out the reason phrase:
+    #   https://github.com/scrapy/scrapy/issues/345#issuecomment-281756036
+    #   https://github.com/seanmonstar/httparse/issues/29
+    # so make it optional. ?: is a non-capturing group.
+    r"(?: (?P<reason>{reason_phrase}))?".format(**globals())
+)
+
+HEXDIG = r"[0-9A-Fa-f]"
+# Actually
+#
+#      chunk-size     = 1*HEXDIG
+#
+# but we impose an upper-limit to avoid ridiculosity. len(str(2**64)) == 20
+chunk_size = r"({HEXDIG}){{1,20}}".format(**globals())
+# Actually
+#
+#     chunk-ext      = *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
+#
+# but we aren't parsing the things so we don't really care.
+chunk_ext = r";.*"
+chunk_header = (
+    r"(?P<chunk_size>{chunk_size})"
+    r"(?P<chunk_ext>{chunk_ext})?"
+    r"\r\n".format(**globals())
+)
diff --git a/myenv/lib/python3.9/site-packages/h11/_connection.py b/myenv/lib/python3.9/site-packages/h11/_connection.py
new file mode 100644
index 0000000..6f796ef
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/_connection.py
@@ -0,0 +1,585 @@
+# This contains the main Connection class. Everything in h11 revolves around
+# this.
+
+from ._events import *  # Import all event types
+from ._headers import get_comma_header, has_expect_100_continue, set_comma_header
+from ._readers import READERS
+from ._receivebuffer import ReceiveBuffer
+from ._state import *  # Import all state sentinels
+from ._state import _SWITCH_CONNECT, _SWITCH_UPGRADE, ConnectionState
+from ._util import (  # Import the internal things we need
+    LocalProtocolError,
+    make_sentinel,
+    RemoteProtocolError,
+)
+from ._writers import WRITERS
+
+# Everything in __all__ gets re-exported as part of the h11 public API.
+__all__ = ["Connection", "NEED_DATA", "PAUSED"]
+
+NEED_DATA = make_sentinel("NEED_DATA")
+PAUSED = make_sentinel("PAUSED")
+
+# If we ever have this much buffered without it making a complete parseable
+# event, we error out. The only time we really buffer is when reading the
+# request/reponse line + headers together, so this is effectively the limit on
+# the size of that.
+#
+# Some precedents for defaults:
+# - node.js: 80 * 1024
+# - tomcat: 8 * 1024
+# - IIS: 16 * 1024
+# - Apache: <8 KiB per line>
+DEFAULT_MAX_INCOMPLETE_EVENT_SIZE = 16 * 1024
+
+# RFC 7230's rules for connection lifecycles:
+# - If either side says they want to close the connection, then the connection
+#   must close.
+# - HTTP/1.1 defaults to keep-alive unless someone says Connection: close
+# - HTTP/1.0 defaults to close unless both sides say Connection: keep-alive
+#   (and even this is a mess -- e.g. if you're implementing a proxy then
+#   sending Connection: keep-alive is forbidden).
+#
+# We simplify life by simply not supporting keep-alive with HTTP/1.0 peers. So
+# our rule is:
+# - If someone says Connection: close, we will close
+# - If someone uses HTTP/1.0, we will close.
+def _keep_alive(event):
+    connection = get_comma_header(event.headers, b"connection")
+    if b"close" in connection:
+        return False
+    if getattr(event, "http_version", b"1.1") < b"1.1":
+        return False
+    return True
+
+
+def _body_framing(request_method, event):
+    # Called when we enter SEND_BODY to figure out framing information for
+    # this body.
+    #
+    # These are the only two events that can trigger a SEND_BODY state:
+    assert type(event) in (Request, Response)
+    # Returns one of:
+    #
+    #    ("content-length", count)
+    #    ("chunked", ())
+    #    ("http/1.0", ())
+    #
+    # which are (lookup key, *args) for constructing body reader/writer
+    # objects.
+    #
+    # Reference: https://tools.ietf.org/html/rfc7230#section-3.3.3
+    #
+    # Step 1: some responses always have an empty body, regardless of what the
+    # headers say.
+    if type(event) is Response:
+        if (
+            event.status_code in (204, 304)
+            or request_method == b"HEAD"
+            or (request_method == b"CONNECT" and 200 <= event.status_code < 300)
+        ):
+            return ("content-length", (0,))
+        # Section 3.3.3 also lists another case -- responses with status_code
+        # < 200. For us these are InformationalResponses, not Responses, so
+        # they can't get into this function in the first place.
+        assert event.status_code >= 200
+
+    # Step 2: check for Transfer-Encoding (T-E beats C-L):
+    transfer_encodings = get_comma_header(event.headers, b"transfer-encoding")
+    if transfer_encodings:
+        assert transfer_encodings == [b"chunked"]
+        return ("chunked", ())
+
+    # Step 3: check for Content-Length
+    content_lengths = get_comma_header(event.headers, b"content-length")
+    if content_lengths:
+        return ("content-length", (int(content_lengths[0]),))
+
+    # Step 4: no applicable headers; fallback/default depends on type
+    if type(event) is Request:
+        return ("content-length", (0,))
+    else:
+        return ("http/1.0", ())
+
+
+################################################################
+#
+# The main Connection class
+#
+################################################################
+
+
+class Connection:
+    """An object encapsulating the state of an HTTP connection.
+
+    Args:
+        our_role: If you're implementing a client, pass :data:`h11.CLIENT`. If
+            you're implementing a server, pass :data:`h11.SERVER`.
+
+        max_incomplete_event_size (int):
+            The maximum number of bytes we're willing to buffer of an
+            incomplete event. In practice this mostly sets a limit on the
+            maximum size of the request/response line + headers. If this is
+            exceeded, then :meth:`next_event` will raise
+            :exc:`RemoteProtocolError`.
+
+    """
+
+    def __init__(
+        self, our_role, max_incomplete_event_size=DEFAULT_MAX_INCOMPLETE_EVENT_SIZE
+    ):
+        self._max_incomplete_event_size = max_incomplete_event_size
+        # State and role tracking
+        if our_role not in (CLIENT, SERVER):
+            raise ValueError("expected CLIENT or SERVER, not {!r}".format(our_role))
+        self.our_role = our_role
+        if our_role is CLIENT:
+            self.their_role = SERVER
+        else:
+            self.their_role = CLIENT
+        self._cstate = ConnectionState()
+
+        # Callables for converting data->events or vice-versa given the
+        # current state
+        self._writer = self._get_io_object(self.our_role, None, WRITERS)
+        self._reader = self._get_io_object(self.their_role, None, READERS)
+
+        # Holds any unprocessed received data
+        self._receive_buffer = ReceiveBuffer()
+        # If this is true, then it indicates that the incoming connection was
+        # closed *after* the end of whatever's in self._receive_buffer:
+        self._receive_buffer_closed = False
+
+        # Extra bits of state that don't fit into the state machine.
+        #
+        # These two are only used to interpret framing headers for figuring
+        # out how to read/write response bodies. their_http_version is also
+        # made available as a convenient public API.
+        self.their_http_version = None
+        self._request_method = None
+        # This is pure flow-control and doesn't at all affect the set of legal
+        # transitions, so no need to bother ConnectionState with it:
+        self.client_is_waiting_for_100_continue = False
+
+    @property
+    def states(self):
+        """A dictionary like::
+
+           {CLIENT: <client state>, SERVER: <server state>}
+
+        See :ref:`state-machine` for details.
+
+        """
+        return dict(self._cstate.states)
+
+    @property
+    def our_state(self):
+        """The current state of whichever role we are playing. See
+        :ref:`state-machine` for details.
+        """
+        return self._cstate.states[self.our_role]
+
+    @property
+    def their_state(self):
+        """The current state of whichever role we are NOT playing. See
+        :ref:`state-machine` for details.
+        """
+        return self._cstate.states[self.their_role]
+
+    @property
+    def they_are_waiting_for_100_continue(self):
+        return self.their_role is CLIENT and self.client_is_waiting_for_100_continue
+
+    def start_next_cycle(self):
+        """Attempt to reset our connection state for a new request/response
+        cycle.
+
+        If both client and server are in :data:`DONE` state, then resets them
+        both to :data:`IDLE` state in preparation for a new request/response
+        cycle on this same connection. Otherwise, raises a
+        :exc:`LocalProtocolError`.
+
+        See :ref:`keepalive-and-pipelining`.
+
+        """
+        old_states = dict(self._cstate.states)
+        self._cstate.start_next_cycle()
+        self._request_method = None
+        # self.their_http_version gets left alone, since it presumably lasts
+        # beyond a single request/response cycle
+        assert not self.client_is_waiting_for_100_continue
+        self._respond_to_state_changes(old_states)
+
+    def _process_error(self, role):
+        old_states = dict(self._cstate.states)
+        self._cstate.process_error(role)
+        self._respond_to_state_changes(old_states)
+
+    def _server_switch_event(self, event):
+        if type(event) is InformationalResponse and event.status_code == 101:
+            return _SWITCH_UPGRADE
+        if type(event) is Response:
+            if (
+                _SWITCH_CONNECT in self._cstate.pending_switch_proposals
+                and 200 <= event.status_code < 300
+            ):
+                return _SWITCH_CONNECT
+        return None
+
+    # All events go through here
+    def _process_event(self, role, event):
+        # First, pass the event through the state machine to make sure it
+        # succeeds.
+        old_states = dict(self._cstate.states)
+        if role is CLIENT and type(event) is Request:
+            if event.method == b"CONNECT":
+                self._cstate.process_client_switch_proposal(_SWITCH_CONNECT)
+            if get_comma_header(event.headers, b"upgrade"):
+                self._cstate.process_client_switch_proposal(_SWITCH_UPGRADE)
+        server_switch_event = None
+        if role is SERVER:
+            server_switch_event = self._server_switch_event(event)
+        self._cstate.process_event(role, type(event), server_switch_event)
+
+        # Then perform the updates triggered by it.
+
+        # self._request_method
+        if type(event) is Request:
+            self._request_method = event.method
+
+        # self.their_http_version
+        if role is self.their_role and type(event) in (
+            Request,
+            Response,
+            InformationalResponse,
+        ):
+            self.their_http_version = event.http_version
+
+        # Keep alive handling
+        #
+        # RFC 7230 doesn't really say what one should do if Connection: close
+        # shows up on a 1xx InformationalResponse. I think the idea is that
+        # this is not supposed to happen. In any case, if it does happen, we
+        # ignore it.
+        if type(event) in (Request, Response) and not _keep_alive(event):
+            self._cstate.process_keep_alive_disabled()
+
+        # 100-continue
+        if type(event) is Request and has_expect_100_continue(event):
+            self.client_is_waiting_for_100_continue = True
+        if type(event) in (InformationalResponse, Response):
+            self.client_is_waiting_for_100_continue = False
+        if role is CLIENT and type(event) in (Data, EndOfMessage):
+            self.client_is_waiting_for_100_continue = False
+
+        self._respond_to_state_changes(old_states, event)
+
+    def _get_io_object(self, role, event, io_dict):
+        # event may be None; it's only used when entering SEND_BODY
+        state = self._cstate.states[role]
+        if state is SEND_BODY:
+            # Special case: the io_dict has a dict of reader/writer factories
+            # that depend on the request/response framing.
+            framing_type, args = _body_framing(self._request_method, event)
+            return io_dict[SEND_BODY][framing_type](*args)
+        else:
+            # General case: the io_dict just has the appropriate reader/writer
+            # for this state
+            return io_dict.get((role, state))
+
+    # This must be called after any action that might have caused
+    # self._cstate.states to change.
+    def _respond_to_state_changes(self, old_states, event=None):
+        # Update reader/writer
+        if self.our_state != old_states[self.our_role]:
+            self._writer = self._get_io_object(self.our_role, event, WRITERS)
+        if self.their_state != old_states[self.their_role]:
+            self._reader = self._get_io_object(self.their_role, event, READERS)
+
+    @property
+    def trailing_data(self):
+        """Data that has been received, but not yet processed, represented as
+        a tuple with two elements, where the first is a byte-string containing
+        the unprocessed data itself, and the second is a bool that is True if
+        the receive connection was closed.
+
+        See :ref:`switching-protocols` for discussion of why you'd want this.
+        """
+        return (bytes(self._receive_buffer), self._receive_buffer_closed)
+
+    def receive_data(self, data):
+        """Add data to our internal receive buffer.
+
+        This does not actually do any processing on the data, just stores
+        it. To trigger processing, you have to call :meth:`next_event`.
+
+        Args:
+            data (:term:`bytes-like object`):
+                The new data that was just received.
+
+                Special case: If *data* is an empty byte-string like ``b""``,
+                then this indicates that the remote side has closed the
+                connection (end of file). Normally this is convenient, because
+                standard Python APIs like :meth:`file.read` or
+                :meth:`socket.recv` use ``b""`` to indicate end-of-file, while
+                other failures to read are indicated using other mechanisms
+                like raising :exc:`TimeoutError`. When using such an API you
+                can just blindly pass through whatever you get from ``read``
+                to :meth:`receive_data`, and everything will work.
+
+                But, if you have an API where reading an empty string is a
+                valid non-EOF condition, then you need to be aware of this and
+                make sure to check for such strings and avoid passing them to
+                :meth:`receive_data`.
+
+        Returns:
+            Nothing, but after calling this you should call :meth:`next_event`
+            to parse the newly received data.
+
+        Raises:
+            RuntimeError:
+                Raised if you pass an empty *data*, indicating EOF, and then
+                pass a non-empty *data*, indicating more data that somehow
+                arrived after the EOF.
+
+                (Calling ``receive_data(b"")`` multiple times is fine,
+                and equivalent to calling it once.)
+
+        """
+        if data:
+            if self._receive_buffer_closed:
+                raise RuntimeError("received close, then received more data?")
+            self._receive_buffer += data
+        else:
+            self._receive_buffer_closed = True
+
+    def _extract_next_receive_event(self):
+        state = self.their_state
+        # We don't pause immediately when they enter DONE, because even in
+        # DONE state we can still process a ConnectionClosed() event. But
+        # if we have data in our buffer, then we definitely aren't getting
+        # a ConnectionClosed() immediately and we need to pause.
+        if state is DONE and self._receive_buffer:
+            return PAUSED
+        if state is MIGHT_SWITCH_PROTOCOL or state is SWITCHED_PROTOCOL:
+            return PAUSED
+        assert self._reader is not None
+        event = self._reader(self._receive_buffer)
+        if event is None:
+            if not self._receive_buffer and self._receive_buffer_closed:
+                # In some unusual cases (basically just HTTP/1.0 bodies), EOF
+                # triggers an actual protocol event; in that case, we want to
+                # return that event, and then the state will change and we'll
+                # get called again to generate the actual ConnectionClosed().
+                if hasattr(self._reader, "read_eof"):
+                    event = self._reader.read_eof()
+                else:
+                    event = ConnectionClosed()
+        if event is None:
+            event = NEED_DATA
+        return event
+
+    def next_event(self):
+        """Parse the next event out of our receive buffer, update our internal
+        state, and return it.
+
+        This is a mutating operation -- think of it like calling :func:`next`
+        on an iterator.
+
+        Returns:
+            : One of three things:
+
+            1) An event object -- see :ref:`events`.
+
+            2) The special constant :data:`NEED_DATA`, which indicates that
+               you need to read more data from your socket and pass it to
+               :meth:`receive_data` before this method will be able to return
+               any more events.
+
+            3) The special constant :data:`PAUSED`, which indicates that we
+               are not in a state where we can process incoming data (usually
+               because the peer has finished their part of the current
+               request/response cycle, and you have not yet called
+               :meth:`start_next_cycle`). See :ref:`flow-control` for details.
+
+        Raises:
+            RemoteProtocolError:
+                The peer has misbehaved. You should close the connection
+                (possibly after sending some kind of 4xx response).
+
+        Once this method returns :class:`ConnectionClosed` once, then all
+        subsequent calls will also return :class:`ConnectionClosed`.
+
+        If this method raises any exception besides :exc:`RemoteProtocolError`
+        then that's a bug -- if it happens please file a bug report!
+
+        If this method raises any exception then it also sets
+        :attr:`Connection.their_state` to :data:`ERROR` -- see
+        :ref:`error-handling` for discussion.
+
+        """
+
+        if self.their_state is ERROR:
+            raise RemoteProtocolError("Can't receive data when peer state is ERROR")
+        try:
+            event = self._extract_next_receive_event()
+            if event not in [NEED_DATA, PAUSED]:
+                self._process_event(self.their_role, event)
+            if event is NEED_DATA:
+                if len(self._receive_buffer) > self._max_incomplete_event_size:
+                    # 431 is "Request header fields too large" which is pretty
+                    # much the only situation where we can get here
+                    raise RemoteProtocolError(
+                        "Receive buffer too long", error_status_hint=431
+                    )
+                if self._receive_buffer_closed:
+                    # We're still trying to complete some event, but that's
+                    # never going to happen because no more data is coming
+                    raise RemoteProtocolError("peer unexpectedly closed connection")
+            return event
+        except BaseException as exc:
+            self._process_error(self.their_role)
+            if isinstance(exc, LocalProtocolError):
+                exc._reraise_as_remote_protocol_error()
+            else:
+                raise
+
+    def send(self, event):
+        """Convert a high-level event into bytes that can be sent to the peer,
+        while updating our internal state machine.
+
+        Args:
+            event: The :ref:`event <events>` to send.
+
+        Returns:
+            If ``type(event) is ConnectionClosed``, then returns
+            ``None``. Otherwise, returns a :term:`bytes-like object`.
+
+        Raises:
+            LocalProtocolError:
+                Sending this event at this time would violate our
+                understanding of the HTTP/1.1 protocol.
+
+        If this method raises any exception then it also sets
+        :attr:`Connection.our_state` to :data:`ERROR` -- see
+        :ref:`error-handling` for discussion.
+
+        """
+        data_list = self.send_with_data_passthrough(event)
+        if data_list is None:
+            return None
+        else:
+            return b"".join(data_list)
+
+    def send_with_data_passthrough(self, event):
+        """Identical to :meth:`send`, except that in situations where
+        :meth:`send` returns a single :term:`bytes-like object`, this instead
+        returns a list of them -- and when sending a :class:`Data` event, this
+        list is guaranteed to contain the exact object you passed in as
+        :attr:`Data.data`. See :ref:`sendfile` for discussion.
+
+        """
+        if self.our_state is ERROR:
+            raise LocalProtocolError("Can't send data when our state is ERROR")
+        try:
+            if type(event) is Response:
+                self._clean_up_response_headers_for_sending(event)
+            # We want to call _process_event before calling the writer,
+            # because if someone tries to do something invalid then this will
+            # give a sensible error message, while our writers all just assume
+            # they will only receive valid events. But, _process_event might
+            # change self._writer. So we have to do a little dance:
+            writer = self._writer
+            self._process_event(self.our_role, event)
+            if type(event) is ConnectionClosed:
+                return None
+            else:
+                # In any situation where writer is None, process_event should
+                # have raised ProtocolError
+                assert writer is not None
+                data_list = []
+                writer(event, data_list.append)
+                return data_list
+        except:
+            self._process_error(self.our_role)
+            raise
+
+    def send_failed(self):
+        """Notify the state machine that we failed to send the data it gave
+        us.
+
+        This causes :attr:`Connection.our_state` to immediately become
+        :data:`ERROR` -- see :ref:`error-handling` for discussion.
+
+        """
+        self._process_error(self.our_role)
+
+    # When sending a Response, we take responsibility for a few things:
+    #
+    # - Sometimes you MUST set Connection: close. We take care of those
+    #   times. (You can also set it yourself if you want, and if you do then
+    #   we'll respect that and close the connection at the right time. But you
+    #   don't have to worry about that unless you want to.)
+    #
+    # - The user has to set Content-Length if they want it. Otherwise, for
+    #   responses that have bodies (e.g. not HEAD), then we will automatically
+    #   select the right mechanism for streaming a body of unknown length,
+    #   which depends on depending on the peer's HTTP version.
+    #
+    # This function's *only* responsibility is making sure headers are set up
+    # right -- everything downstream just looks at the headers. There are no
+    # side channels. It mutates the response event in-place (but not the
+    # response.headers list object).
+    def _clean_up_response_headers_for_sending(self, response):
+        assert type(response) is Response
+
+        headers = response.headers
+        need_close = False
+
+        # HEAD requests need some special handling: they always act like they
+        # have Content-Length: 0, and that's how _body_framing treats
+        # them. But their headers are supposed to match what we would send if
+        # the request was a GET. (Technically there is one deviation allowed:
+        # we're allowed to leave out the framing headers -- see
+        # https://tools.ietf.org/html/rfc7231#section-4.3.2 . But it's just as
+        # easy to get them right.)
+        method_for_choosing_headers = self._request_method
+        if method_for_choosing_headers == b"HEAD":
+            method_for_choosing_headers = b"GET"
+        framing_type, _ = _body_framing(method_for_choosing_headers, response)
+        if framing_type in ("chunked", "http/1.0"):
+            # This response has a body of unknown length.
+            # If our peer is HTTP/1.1, we use Transfer-Encoding: chunked
+            # If our peer is HTTP/1.0, we use no framing headers, and close the
+            # connection afterwards.
+            #
+            # Make sure to clear Content-Length (in principle user could have
+            # set both and then we ignored Content-Length b/c
+            # Transfer-Encoding overwrote it -- this would be naughty of them,
+            # but the HTTP spec says that if our peer does this then we have
+            # to fix it instead of erroring out, so we'll accord the user the
+            # same respect).
+            headers = set_comma_header(headers, b"content-length", [])
+            if self.their_http_version is None or self.their_http_version < b"1.1":
+                # Either we never got a valid request and are sending back an
+                # error (their_http_version is None), so we assume the worst;
+                # or else we did get a valid HTTP/1.0 request, so we know that
+                # they don't understand chunked encoding.
+                headers = set_comma_header(headers, b"transfer-encoding", [])
+                # This is actually redundant ATM, since currently we
+                # unconditionally disable keep-alive when talking to HTTP/1.0
+                # peers. But let's be defensive just in case we add
+                # Connection: keep-alive support later:
+                if self._request_method != b"HEAD":
+                    need_close = True
+            else:
+                headers = set_comma_header(headers, b"transfer-encoding", ["chunked"])
+
+        if not self._cstate.keep_alive or need_close:
+            # Make sure Connection: close is set
+            connection = set(get_comma_header(headers, b"connection"))
+            connection.discard(b"keep-alive")
+            connection.add(b"close")
+            headers = set_comma_header(headers, b"connection", sorted(connection))
+
+        response.headers = headers
diff --git a/myenv/lib/python3.9/site-packages/h11/_events.py b/myenv/lib/python3.9/site-packages/h11/_events.py
new file mode 100644
index 0000000..1827930
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/_events.py
@@ -0,0 +1,302 @@
+# High level events that make up HTTP/1.1 conversations. Loosely inspired by
+# the corresponding events in hyper-h2:
+#
+#     http://python-hyper.org/h2/en/stable/api.html#events
+#
+# Don't subclass these. Stuff will break.
+
+import re
+
+from . import _headers
+from ._abnf import request_target
+from ._util import bytesify, LocalProtocolError, validate
+
+# Everything in __all__ gets re-exported as part of the h11 public API.
+__all__ = [
+    "Request",
+    "InformationalResponse",
+    "Response",
+    "Data",
+    "EndOfMessage",
+    "ConnectionClosed",
+]
+
+request_target_re = re.compile(request_target.encode("ascii"))
+
+
+class _EventBundle:
+    _fields = []
+    _defaults = {}
+
+    def __init__(self, **kwargs):
+        _parsed = kwargs.pop("_parsed", False)
+        allowed = set(self._fields)
+        for kwarg in kwargs:
+            if kwarg not in allowed:
+                raise TypeError(
+                    "unrecognized kwarg {} for {}".format(
+                        kwarg, self.__class__.__name__
+                    )
+                )
+        required = allowed.difference(self._defaults)
+        for field in required:
+            if field not in kwargs:
+                raise TypeError(
+                    "missing required kwarg {} for {}".format(
+                        field, self.__class__.__name__
+                    )
+                )
+        self.__dict__.update(self._defaults)
+        self.__dict__.update(kwargs)
+
+        # Special handling for some fields
+
+        if "headers" in self.__dict__:
+            self.headers = _headers.normalize_and_validate(
+                self.headers, _parsed=_parsed
+            )
+
+        if not _parsed:
+            for field in ["method", "target", "http_version", "reason"]:
+                if field in self.__dict__:
+                    self.__dict__[field] = bytesify(self.__dict__[field])
+
+            if "status_code" in self.__dict__:
+                if not isinstance(self.status_code, int):
+                    raise LocalProtocolError("status code must be integer")
+                # Because IntEnum objects are instances of int, but aren't
+                # duck-compatible (sigh), see gh-72.
+                self.status_code = int(self.status_code)
+
+        self._validate()
+
+    def _validate(self):
+        pass
+
+    def __repr__(self):
+        name = self.__class__.__name__
+        kwarg_strs = [
+            "{}={}".format(field, self.__dict__[field]) for field in self._fields
+        ]
+        kwarg_str = ", ".join(kwarg_strs)
+        return "{}({})".format(name, kwarg_str)
+
+    # Useful for tests
+    def __eq__(self, other):
+        return self.__class__ == other.__class__ and self.__dict__ == other.__dict__
+
+    # This is an unhashable type.
+    __hash__ = None
+
+
+class Request(_EventBundle):
+    """The beginning of an HTTP request.
+
+    Fields:
+
+    .. attribute:: method
+
+       An HTTP method, e.g. ``b"GET"`` or ``b"POST"``. Always a byte
+       string. :term:`Bytes-like objects <bytes-like object>` and native
+       strings containing only ascii characters will be automatically
+       converted to byte strings.
+
+    .. attribute:: target
+
+       The target of an HTTP request, e.g. ``b"/index.html"``, or one of the
+       more exotic formats described in `RFC 7320, section 5.3
+       <https://tools.ietf.org/html/rfc7230#section-5.3>`_. Always a byte
+       string. :term:`Bytes-like objects <bytes-like object>` and native
+       strings containing only ascii characters will be automatically
+       converted to byte strings.
+
+    .. attribute:: headers
+
+       Request headers, represented as a list of (name, value) pairs. See
+       :ref:`the header normalization rules <headers-format>` for details.
+
+    .. attribute:: http_version
+
+       The HTTP protocol version, represented as a byte string like
+       ``b"1.1"``. See :ref:`the HTTP version normalization rules
+       <http_version-format>` for details.
+
+    """
+
+    _fields = ["method", "target", "headers", "http_version"]
+    _defaults = {"http_version": b"1.1"}
+
+    def _validate(self):
+        # "A server MUST respond with a 400 (Bad Request) status code to any
+        # HTTP/1.1 request message that lacks a Host header field and to any
+        # request message that contains more than one Host header field or a
+        # Host header field with an invalid field-value."
+        # -- https://tools.ietf.org/html/rfc7230#section-5.4
+        host_count = 0
+        for name, value in self.headers:
+            if name == b"host":
+                host_count += 1
+        if self.http_version == b"1.1" and host_count == 0:
+            raise LocalProtocolError("Missing mandatory Host: header")
+        if host_count > 1:
+            raise LocalProtocolError("Found multiple Host: headers")
+
+        validate(request_target_re, self.target, "Illegal target characters")
+
+
+class _ResponseBase(_EventBundle):
+    _fields = ["status_code", "headers", "http_version", "reason"]
+    _defaults = {"http_version": b"1.1", "reason": b""}
+
+
+class InformationalResponse(_ResponseBase):
+    """An HTTP informational response.
+
+    Fields:
+
+    .. attribute:: status_code
+
+       The status code of this response, as an integer. For an
+       :class:`InformationalResponse`, this is always in the range [100,
+       200).
+
+    .. attribute:: headers
+
+       Request headers, represented as a list of (name, value) pairs. See
+       :ref:`the header normalization rules <headers-format>` for
+       details.
+
+    .. attribute:: http_version
+
+       The HTTP protocol version, represented as a byte string like
+       ``b"1.1"``. See :ref:`the HTTP version normalization rules
+       <http_version-format>` for details.
+
+    .. attribute:: reason
+
+       The reason phrase of this response, as a byte string. For example:
+       ``b"OK"``, or ``b"Not Found"``.
+
+    """
+
+    def _validate(self):
+        if not (100 <= self.status_code < 200):
+            raise LocalProtocolError(
+                "InformationalResponse status_code should be in range "
+                "[100, 200), not {}".format(self.status_code)
+            )
+
+
+class Response(_ResponseBase):
+    """The beginning of an HTTP response.
+
+    Fields:
+
+    .. attribute:: status_code
+
+       The status code of this response, as an integer. For an
+       :class:`Response`, this is always in the range [200,
+       600).
+
+    .. attribute:: headers
+
+       Request headers, represented as a list of (name, value) pairs. See
+       :ref:`the header normalization rules <headers-format>` for details.
+
+    .. attribute:: http_version
+
+       The HTTP protocol version, represented as a byte string like
+       ``b"1.1"``. See :ref:`the HTTP version normalization rules
+       <http_version-format>` for details.
+
+    .. attribute:: reason
+
+       The reason phrase of this response, as a byte string. For example:
+       ``b"OK"``, or ``b"Not Found"``.
+
+    """
+
+    def _validate(self):
+        if not (200 <= self.status_code < 600):
+            raise LocalProtocolError(
+                "Response status_code should be in range [200, 600), not {}".format(
+                    self.status_code
+                )
+            )
+
+
+class Data(_EventBundle):
+    """Part of an HTTP message body.
+
+    Fields:
+
+    .. attribute:: data
+
+       A :term:`bytes-like object` containing part of a message body. Or, if
+       using the ``combine=False`` argument to :meth:`Connection.send`, then
+       any object that your socket writing code knows what to do with, and for
+       which calling :func:`len` returns the number of bytes that will be
+       written -- see :ref:`sendfile` for details.
+
+    .. attribute:: chunk_start
+
+       A marker that indicates whether this data object is from the start of a
+       chunked transfer encoding chunk. This field is ignored when when a Data
+       event is provided to :meth:`Connection.send`: it is only valid on
+       events emitted from :meth:`Connection.next_event`. You probably
+       shouldn't use this attribute at all; see
+       :ref:`chunk-delimiters-are-bad` for details.
+
+    .. attribute:: chunk_end
+
+       A marker that indicates whether this data object is the last for a
+       given chunked transfer encoding chunk. This field is ignored when when
+       a Data event is provided to :meth:`Connection.send`: it is only valid
+       on events emitted from :meth:`Connection.next_event`. You probably
+       shouldn't use this attribute at all; see
+       :ref:`chunk-delimiters-are-bad` for details.
+
+    """
+
+    _fields = ["data", "chunk_start", "chunk_end"]
+    _defaults = {"chunk_start": False, "chunk_end": False}
+
+
+# XX FIXME: "A recipient MUST ignore (or consider as an error) any fields that
+# are forbidden to be sent in a trailer, since processing them as if they were
+# present in the header section might bypass external security filters."
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#chunked.trailer.part
+# Unfortunately, the list of forbidden fields is long and vague :-/
+class EndOfMessage(_EventBundle):
+    """The end of an HTTP message.
+
+    Fields:
+
+    .. attribute:: headers
+
+       Default value: ``[]``
+
+       Any trailing headers attached to this message, represented as a list of
+       (name, value) pairs. See :ref:`the header normalization rules
+       <headers-format>` for details.
+
+       Must be empty unless ``Transfer-Encoding: chunked`` is in use.
+
+    """
+
+    _fields = ["headers"]
+    _defaults = {"headers": []}
+
+
+class ConnectionClosed(_EventBundle):
+    """This event indicates that the sender has closed their outgoing
+    connection.
+
+    Note that this does not necessarily mean that they can't *receive* further
+    data, because TCP connections are composed to two one-way channels which
+    can be closed independently. See :ref:`closing` for details.
+
+    No fields.
+    """
+
+    pass
diff --git a/myenv/lib/python3.9/site-packages/h11/_headers.py b/myenv/lib/python3.9/site-packages/h11/_headers.py
new file mode 100644
index 0000000..7ed39bc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/_headers.py
@@ -0,0 +1,242 @@
+import re
+
+from ._abnf import field_name, field_value
+from ._util import bytesify, LocalProtocolError, validate
+
+# Facts
+# -----
+#
+# Headers are:
+#   keys: case-insensitive ascii
+#   values: mixture of ascii and raw bytes
+#
+# "Historically, HTTP has allowed field content with text in the ISO-8859-1
+# charset [ISO-8859-1], supporting other charsets only through use of
+# [RFC2047] encoding.  In practice, most HTTP header field values use only a
+# subset of the US-ASCII charset [USASCII]. Newly defined header fields SHOULD
+# limit their field values to US-ASCII octets.  A recipient SHOULD treat other
+# octets in field content (obs-text) as opaque data."
+# And it deprecates all non-ascii values
+#
+# Leading/trailing whitespace in header names is forbidden
+#
+# Values get leading/trailing whitespace stripped
+#
+# Content-Disposition actually needs to contain unicode semantically; to
+# accomplish this it has a terrifically weird way of encoding the filename
+# itself as ascii (and even this still has lots of cross-browser
+# incompatibilities)
+#
+# Order is important:
+# "a proxy MUST NOT change the order of these field values when forwarding a
+# message"
+# (and there are several headers where the order indicates a preference)
+#
+# Multiple occurences of the same header:
+# "A sender MUST NOT generate multiple header fields with the same field name
+# in a message unless either the entire field value for that header field is
+# defined as a comma-separated list [or the header is Set-Cookie which gets a
+# special exception]" - RFC 7230. (cookies are in RFC 6265)
+#
+# So every header aside from Set-Cookie can be merged by b", ".join if it
+# occurs repeatedly. But, of course, they can't necessarily be split by
+# .split(b","), because quoting.
+#
+# Given all this mess (case insensitive, duplicates allowed, order is
+# important, ...), there doesn't appear to be any standard way to handle
+# headers in Python -- they're almost like dicts, but... actually just
+# aren't. For now we punt and just use a super simple representation: headers
+# are a list of pairs
+#
+#   [(name1, value1), (name2, value2), ...]
+#
+# where all entries are bytestrings, names are lowercase and have no
+# leading/trailing whitespace, and values are bytestrings with no
+# leading/trailing whitespace. Searching and updating are done via naive O(n)
+# methods.
+#
+# Maybe a dict-of-lists would be better?
+
+_content_length_re = re.compile(br"[0-9]+")
+_field_name_re = re.compile(field_name.encode("ascii"))
+_field_value_re = re.compile(field_value.encode("ascii"))
+
+
+class Headers:
+    """
+    A list-like interface that allows iterating over headers as byte-pairs
+    of (lowercased-name, value).
+
+    Internally we actually store the representation as three-tuples,
+    including both the raw original casing, in order to preserve casing
+    over-the-wire, and the lowercased name, for case-insensitive comparisions.
+
+    r = Request(
+        method="GET",
+        target="/",
+        headers=[("Host", "example.org"), ("Connection", "keep-alive")],
+        http_version="1.1",
+    )
+    assert r.headers == [
+        (b"host", b"example.org"),
+        (b"connection", b"keep-alive")
+    ]
+    assert r.headers.raw_items() == [
+        (b"Host", b"example.org"),
+        (b"Connection", b"keep-alive")
+    ]
+    """
+
+    __slots__ = "_full_items"
+
+    def __init__(self, full_items):
+        self._full_items = full_items
+
+    def __iter__(self):
+        for _, name, value in self._full_items:
+            yield name, value
+
+    def __bool__(self):
+        return bool(self._full_items)
+
+    def __eq__(self, other):
+        return list(self) == list(other)
+
+    def __len__(self):
+        return len(self._full_items)
+
+    def __repr__(self):
+        return "<Headers(%s)>" % repr(list(self))
+
+    def __getitem__(self, idx):
+        _, name, value = self._full_items[idx]
+        return (name, value)
+
+    def raw_items(self):
+        return [(raw_name, value) for raw_name, _, value in self._full_items]
+
+
+def normalize_and_validate(headers, _parsed=False):
+    new_headers = []
+    seen_content_length = None
+    saw_transfer_encoding = False
+    for name, value in headers:
+        # For headers coming out of the parser, we can safely skip some steps,
+        # because it always returns bytes and has already run these regexes
+        # over the data:
+        if not _parsed:
+            name = bytesify(name)
+            value = bytesify(value)
+            validate(_field_name_re, name, "Illegal header name {!r}", name)
+            validate(_field_value_re, value, "Illegal header value {!r}", value)
+        raw_name = name
+        name = name.lower()
+        if name == b"content-length":
+            lengths = {length.strip() for length in value.split(b",")}
+            if len(lengths) != 1:
+                raise LocalProtocolError("conflicting Content-Length headers")
+            value = lengths.pop()
+            validate(_content_length_re, value, "bad Content-Length")
+            if seen_content_length is None:
+                seen_content_length = value
+                new_headers.append((raw_name, name, value))
+            elif seen_content_length != value:
+                raise LocalProtocolError("conflicting Content-Length headers")
+        elif name == b"transfer-encoding":
+            # "A server that receives a request message with a transfer coding
+            # it does not understand SHOULD respond with 501 (Not
+            # Implemented)."
+            # https://tools.ietf.org/html/rfc7230#section-3.3.1
+            if saw_transfer_encoding:
+                raise LocalProtocolError(
+                    "multiple Transfer-Encoding headers", error_status_hint=501
+                )
+            # "All transfer-coding names are case-insensitive"
+            # -- https://tools.ietf.org/html/rfc7230#section-4
+            value = value.lower()
+            if value != b"chunked":
+                raise LocalProtocolError(
+                    "Only Transfer-Encoding: chunked is supported",
+                    error_status_hint=501,
+                )
+            saw_transfer_encoding = True
+            new_headers.append((raw_name, name, value))
+        else:
+            new_headers.append((raw_name, name, value))
+    return Headers(new_headers)
+
+
+def get_comma_header(headers, name):
+    # Should only be used for headers whose value is a list of
+    # comma-separated, case-insensitive values.
+    #
+    # The header name `name` is expected to be lower-case bytes.
+    #
+    # Connection: meets these criteria (including cast insensitivity).
+    #
+    # Content-Length: technically is just a single value (1*DIGIT), but the
+    # standard makes reference to implementations that do multiple values, and
+    # using this doesn't hurt. Ditto, case insensitivity doesn't things either
+    # way.
+    #
+    # Transfer-Encoding: is more complex (allows for quoted strings), so
+    # splitting on , is actually wrong. For example, this is legal:
+    #
+    #    Transfer-Encoding: foo; options="1,2", chunked
+    #
+    # and should be parsed as
+    #
+    #    foo; options="1,2"
+    #    chunked
+    #
+    # but this naive function will parse it as
+    #
+    #    foo; options="1
+    #    2"
+    #    chunked
+    #
+    # However, this is okay because the only thing we are going to do with
+    # any Transfer-Encoding is reject ones that aren't just "chunked", so
+    # both of these will be treated the same anyway.
+    #
+    # Expect: the only legal value is the literal string
+    # "100-continue". Splitting on commas is harmless. Case insensitive.
+    #
+    out = []
+    for _, found_name, found_raw_value in headers._full_items:
+        if found_name == name:
+            found_raw_value = found_raw_value.lower()
+            for found_split_value in found_raw_value.split(b","):
+                found_split_value = found_split_value.strip()
+                if found_split_value:
+                    out.append(found_split_value)
+    return out
+
+
+def set_comma_header(headers, name, new_values):
+    # The header name `name` is expected to be lower-case bytes.
+    #
+    # Note that when we store the header we use title casing for the header
+    # names, in order to match the conventional HTTP header style.
+    #
+    # Simply calling `.title()` is a blunt approach, but it's correct
+    # here given the cases where we're using `set_comma_header`...
+    #
+    # Connection, Content-Length, Transfer-Encoding.
+    new_headers = []
+    for found_raw_name, found_name, found_raw_value in headers._full_items:
+        if found_name != name:
+            new_headers.append((found_raw_name, found_raw_value))
+    for new_value in new_values:
+        new_headers.append((name.title(), new_value))
+    return normalize_and_validate(new_headers)
+
+
+def has_expect_100_continue(request):
+    # https://tools.ietf.org/html/rfc7231#section-5.1.1
+    # "A server that receives a 100-continue expectation in an HTTP/1.0 request
+    # MUST ignore that expectation."
+    if request.http_version < b"1.1":
+        return False
+    expect = get_comma_header(request.headers, b"expect")
+    return b"100-continue" in expect
diff --git a/myenv/lib/python3.9/site-packages/h11/_readers.py b/myenv/lib/python3.9/site-packages/h11/_readers.py
new file mode 100644
index 0000000..0ead0be
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/_readers.py
@@ -0,0 +1,222 @@
+# Code to read HTTP data
+#
+# Strategy: each reader is a callable which takes a ReceiveBuffer object, and
+# either:
+# 1) consumes some of it and returns an Event
+# 2) raises a LocalProtocolError (for consistency -- e.g. we call validate()
+#    and it might raise a LocalProtocolError, so simpler just to always use
+#    this)
+# 3) returns None, meaning "I need more data"
+#
+# If they have a .read_eof attribute, then this will be called if an EOF is
+# received -- but this is optional. Either way, the actual ConnectionClosed
+# event will be generated afterwards.
+#
+# READERS is a dict describing how to pick a reader. It maps states to either:
+# - a reader
+# - or, for body readers, a dict of per-framing reader factories
+
+import re
+
+from ._abnf import chunk_header, header_field, request_line, status_line
+from ._events import *
+from ._state import *
+from ._util import LocalProtocolError, RemoteProtocolError, validate
+
+__all__ = ["READERS"]
+
+header_field_re = re.compile(header_field.encode("ascii"))
+
+# Remember that this has to run in O(n) time -- so e.g. the bytearray cast is
+# critical.
+obs_fold_re = re.compile(br"[ \t]+")
+
+
+def _obsolete_line_fold(lines):
+    it = iter(lines)
+    last = None
+    for line in it:
+        match = obs_fold_re.match(line)
+        if match:
+            if last is None:
+                raise LocalProtocolError("continuation line at start of headers")
+            if not isinstance(last, bytearray):
+                last = bytearray(last)
+            last += b" "
+            last += line[match.end() :]
+        else:
+            if last is not None:
+                yield last
+            last = line
+    if last is not None:
+        yield last
+
+
+def _decode_header_lines(lines):
+    for line in _obsolete_line_fold(lines):
+        matches = validate(header_field_re, line, "illegal header line: {!r}", line)
+        yield (matches["field_name"], matches["field_value"])
+
+
+request_line_re = re.compile(request_line.encode("ascii"))
+
+
+def maybe_read_from_IDLE_client(buf):
+    lines = buf.maybe_extract_lines()
+    if lines is None:
+        if buf.is_next_line_obviously_invalid_request_line():
+            raise LocalProtocolError("illegal request line")
+        return None
+    if not lines:
+        raise LocalProtocolError("no request line received")
+    matches = validate(
+        request_line_re, lines[0], "illegal request line: {!r}", lines[0]
+    )
+    return Request(
+        headers=list(_decode_header_lines(lines[1:])), _parsed=True, **matches
+    )
+
+
+status_line_re = re.compile(status_line.encode("ascii"))
+
+
+def maybe_read_from_SEND_RESPONSE_server(buf):
+    lines = buf.maybe_extract_lines()
+    if lines is None:
+        if buf.is_next_line_obviously_invalid_request_line():
+            raise LocalProtocolError("illegal request line")
+        return None
+    if not lines:
+        raise LocalProtocolError("no response line received")
+    matches = validate(status_line_re, lines[0], "illegal status line: {!r}", lines[0])
+    # Tolerate missing reason phrases
+    if matches["reason"] is None:
+        matches["reason"] = b""
+    status_code = matches["status_code"] = int(matches["status_code"])
+    class_ = InformationalResponse if status_code < 200 else Response
+    return class_(
+        headers=list(_decode_header_lines(lines[1:])), _parsed=True, **matches
+    )
+
+
+class ContentLengthReader:
+    def __init__(self, length):
+        self._length = length
+        self._remaining = length
+
+    def __call__(self, buf):
+        if self._remaining == 0:
+            return EndOfMessage()
+        data = buf.maybe_extract_at_most(self._remaining)
+        if data is None:
+            return None
+        self._remaining -= len(data)
+        return Data(data=data)
+
+    def read_eof(self):
+        raise RemoteProtocolError(
+            "peer closed connection without sending complete message body "
+            "(received {} bytes, expected {})".format(
+                self._length - self._remaining, self._length
+            )
+        )
+
+
+chunk_header_re = re.compile(chunk_header.encode("ascii"))
+
+
+class ChunkedReader:
+    def __init__(self):
+        self._bytes_in_chunk = 0
+        # After reading a chunk, we have to throw away the trailing \r\n; if
+        # this is >0 then we discard that many bytes before resuming regular
+        # de-chunkification.
+        self._bytes_to_discard = 0
+        self._reading_trailer = False
+
+    def __call__(self, buf):
+        if self._reading_trailer:
+            lines = buf.maybe_extract_lines()
+            if lines is None:
+                return None
+            return EndOfMessage(headers=list(_decode_header_lines(lines)))
+        if self._bytes_to_discard > 0:
+            data = buf.maybe_extract_at_most(self._bytes_to_discard)
+            if data is None:
+                return None
+            self._bytes_to_discard -= len(data)
+            if self._bytes_to_discard > 0:
+                return None
+            # else, fall through and read some more
+        assert self._bytes_to_discard == 0
+        if self._bytes_in_chunk == 0:
+            # We need to refill our chunk count
+            chunk_header = buf.maybe_extract_next_line()
+            if chunk_header is None:
+                return None
+            matches = validate(
+                chunk_header_re,
+                chunk_header,
+                "illegal chunk header: {!r}",
+                chunk_header,
+            )
+            # XX FIXME: we discard chunk extensions. Does anyone care?
+            self._bytes_in_chunk = int(matches["chunk_size"], base=16)
+            if self._bytes_in_chunk == 0:
+                self._reading_trailer = True
+                return self(buf)
+            chunk_start = True
+        else:
+            chunk_start = False
+        assert self._bytes_in_chunk > 0
+        data = buf.maybe_extract_at_most(self._bytes_in_chunk)
+        if data is None:
+            return None
+        self._bytes_in_chunk -= len(data)
+        if self._bytes_in_chunk == 0:
+            self._bytes_to_discard = 2
+            chunk_end = True
+        else:
+            chunk_end = False
+        return Data(data=data, chunk_start=chunk_start, chunk_end=chunk_end)
+
+    def read_eof(self):
+        raise RemoteProtocolError(
+            "peer closed connection without sending complete message body "
+            "(incomplete chunked read)"
+        )
+
+
+class Http10Reader:
+    def __call__(self, buf):
+        data = buf.maybe_extract_at_most(999999999)
+        if data is None:
+            return None
+        return Data(data=data)
+
+    def read_eof(self):
+        return EndOfMessage()
+
+
+def expect_nothing(buf):
+    if buf:
+        raise LocalProtocolError("Got data when expecting EOF")
+    return None
+
+
+READERS = {
+    (CLIENT, IDLE): maybe_read_from_IDLE_client,
+    (SERVER, IDLE): maybe_read_from_SEND_RESPONSE_server,
+    (SERVER, SEND_RESPONSE): maybe_read_from_SEND_RESPONSE_server,
+    (CLIENT, DONE): expect_nothing,
+    (CLIENT, MUST_CLOSE): expect_nothing,
+    (CLIENT, CLOSED): expect_nothing,
+    (SERVER, DONE): expect_nothing,
+    (SERVER, MUST_CLOSE): expect_nothing,
+    (SERVER, CLOSED): expect_nothing,
+    SEND_BODY: {
+        "chunked": ChunkedReader,
+        "content-length": ContentLengthReader,
+        "http/1.0": Http10Reader,
+    },
+}
diff --git a/myenv/lib/python3.9/site-packages/h11/_receivebuffer.py b/myenv/lib/python3.9/site-packages/h11/_receivebuffer.py
new file mode 100644
index 0000000..a3737f3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/_receivebuffer.py
@@ -0,0 +1,152 @@
+import re
+import sys
+
+__all__ = ["ReceiveBuffer"]
+
+
+# Operations we want to support:
+# - find next \r\n or \r\n\r\n (\n or \n\n are also acceptable),
+#   or wait until there is one
+# - read at-most-N bytes
+# Goals:
+# - on average, do this fast
+# - worst case, do this in O(n) where n is the number of bytes processed
+# Plan:
+# - store bytearray, offset, how far we've searched for a separator token
+# - use the how-far-we've-searched data to avoid rescanning
+# - while doing a stream of uninterrupted processing, advance offset instead
+#   of constantly copying
+# WARNING:
+# - I haven't benchmarked or profiled any of this yet.
+#
+# Note that starting in Python 3.4, deleting the initial n bytes from a
+# bytearray is amortized O(n), thanks to some excellent work by Antoine
+# Martin:
+#
+#     https://bugs.python.org/issue19087
+#
+# This means that if we only supported 3.4+, we could get rid of the code here
+# involving self._start and self.compress, because it's doing exactly the same
+# thing that bytearray now does internally.
+#
+# BUT unfortunately, we still support 2.7, and reading short segments out of a
+# long buffer MUST be O(bytes read) to avoid DoS issues, so we can't actually
+# delete this code. Yet:
+#
+#     https://pythonclock.org/
+#
+# (Two things to double-check first though: make sure PyPy also has the
+# optimization, and benchmark to make sure it's a win, since we do have a
+# slightly clever thing where we delay calling compress() until we've
+# processed a whole event, which could in theory be slightly more efficient
+# than the internal bytearray support.)
+blank_line_regex = re.compile(b"\n\r?\n", re.MULTILINE)
+
+
+class ReceiveBuffer:
+    def __init__(self):
+        self._data = bytearray()
+        self._next_line_search = 0
+        self._multiple_lines_search = 0
+
+    def __iadd__(self, byteslike):
+        self._data += byteslike
+        return self
+
+    def __bool__(self):
+        return bool(len(self))
+
+    def __len__(self):
+        return len(self._data)
+
+    # for @property unprocessed_data
+    def __bytes__(self):
+        return bytes(self._data)
+
+    def _extract(self, count):
+        # extracting an initial slice of the data buffer and return it
+        out = self._data[:count]
+        del self._data[:count]
+
+        self._next_line_search = 0
+        self._multiple_lines_search = 0
+
+        return out
+
+    def maybe_extract_at_most(self, count):
+        """
+        Extract a fixed number of bytes from the buffer.
+        """
+        out = self._data[:count]
+        if not out:
+            return None
+
+        return self._extract(count)
+
+    def maybe_extract_next_line(self):
+        """
+        Extract the first line, if it is completed in the buffer.
+        """
+        # Only search in buffer space that we've not already looked at.
+        search_start_index = max(0, self._next_line_search - 1)
+        partial_idx = self._data.find(b"\r\n", search_start_index)
+
+        if partial_idx == -1:
+            self._next_line_search = len(self._data)
+            return None
+
+        # + 2 is to compensate len(b"\r\n")
+        idx = partial_idx + 2
+
+        return self._extract(idx)
+
+    def maybe_extract_lines(self):
+        """
+        Extract everything up to the first blank line, and return a list of lines.
+        """
+        # Handle the case where we have an immediate empty line.
+        if self._data[:1] == b"\n":
+            self._extract(1)
+            return []
+
+        if self._data[:2] == b"\r\n":
+            self._extract(2)
+            return []
+
+        # Only search in buffer space that we've not already looked at.
+        match = blank_line_regex.search(self._data, self._multiple_lines_search)
+        if match is None:
+            self._multiple_lines_search = max(0, len(self._data) - 2)
+            return None
+
+        # Truncate the buffer and return it.
+        idx = match.span(0)[-1]
+        out = self._extract(idx)
+        lines = out.split(b"\n")
+
+        for line in lines:
+            if line.endswith(b"\r"):
+                del line[-1]
+
+        assert lines[-2] == lines[-1] == b""
+
+        del lines[-2:]
+
+        return lines
+
+    # In theory we should wait until `\r\n` before starting to validate
+    # incoming data. However it's interesting to detect (very) invalid data
+    # early given they might not even contain `\r\n` at all (hence only
+    # timeout will get rid of them).
+    # This is not a 100% effective detection but more of a cheap sanity check
+    # allowing for early abort in some useful cases.
+    # This is especially interesting when peer is messing up with HTTPS and
+    # sent us a TLS stream where we were expecting plain HTTP given all
+    # versions of TLS so far start handshake with a 0x16 message type code.
+    def is_next_line_obviously_invalid_request_line(self):
+        try:
+            # HTTP header line must not contain non-printable characters
+            # and should not start with a space
+            return self._data[0] < 0x21
+        except IndexError:
+            return False
diff --git a/myenv/lib/python3.9/site-packages/h11/_state.py b/myenv/lib/python3.9/site-packages/h11/_state.py
new file mode 100644
index 0000000..0f08a09
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/_state.py
@@ -0,0 +1,307 @@
+################################################################
+# The core state machine
+################################################################
+#
+# Rule 1: everything that affects the state machine and state transitions must
+# live here in this file. As much as possible goes into the table-based
+# representation, but for the bits that don't quite fit, the actual code and
+# state must nonetheless live here.
+#
+# Rule 2: this file does not know about what role we're playing; it only knows
+# about HTTP request/response cycles in the abstract. This ensures that we
+# don't cheat and apply different rules to local and remote parties.
+#
+#
+# Theory of operation
+# ===================
+#
+# Possibly the simplest way to think about this is that we actually have 5
+# different state machines here. Yes, 5. These are:
+#
+# 1) The client state, with its complicated automaton (see the docs)
+# 2) The server state, with its complicated automaton (see the docs)
+# 3) The keep-alive state, with possible states {True, False}
+# 4) The SWITCH_CONNECT state, with possible states {False, True}
+# 5) The SWITCH_UPGRADE state, with possible states {False, True}
+#
+# For (3)-(5), the first state listed is the initial state.
+#
+# (1)-(3) are stored explicitly in member variables. The last
+# two are stored implicitly in the pending_switch_proposals set as:
+#   (state of 4) == (_SWITCH_CONNECT in pending_switch_proposals)
+#   (state of 5) == (_SWITCH_UPGRADE in pending_switch_proposals)
+#
+# And each of these machines has two different kinds of transitions:
+#
+# a) Event-triggered
+# b) State-triggered
+#
+# Event triggered is the obvious thing that you'd think it is: some event
+# happens, and if it's the right event at the right time then a transition
+# happens. But there are somewhat complicated rules for which machines can
+# "see" which events. (As a rule of thumb, if a machine "sees" an event, this
+# means two things: the event can affect the machine, and if the machine is
+# not in a state where it expects that event then it's an error.) These rules
+# are:
+#
+# 1) The client machine sees all h11.events objects emitted by the client.
+#
+# 2) The server machine sees all h11.events objects emitted by the server.
+#
+#    It also sees the client's Request event.
+#
+#    And sometimes, server events are annotated with a _SWITCH_* event. For
+#    example, we can have a (Response, _SWITCH_CONNECT) event, which is
+#    different from a regular Response event.
+#
+# 3) The keep-alive machine sees the process_keep_alive_disabled() event
+#    (which is derived from Request/Response events), and this event
+#    transitions it from True -> False, or from False -> False. There's no way
+#    to transition back.
+#
+# 4&5) The _SWITCH_* machines transition from False->True when we get a
+#    Request that proposes the relevant type of switch (via
+#    process_client_switch_proposals), and they go from True->False when we
+#    get a Response that has no _SWITCH_* annotation.
+#
+# So that's event-triggered transitions.
+#
+# State-triggered transitions are less standard. What they do here is couple
+# the machines together. The way this works is, when certain *joint*
+# configurations of states are achieved, then we automatically transition to a
+# new *joint* state. So, for example, if we're ever in a joint state with
+#
+#   client: DONE
+#   keep-alive: False
+#
+# then the client state immediately transitions to:
+#
+#   client: MUST_CLOSE
+#
+# This is fundamentally different from an event-based transition, because it
+# doesn't matter how we arrived at the {client: DONE, keep-alive: False} state
+# -- maybe the client transitioned SEND_BODY -> DONE, or keep-alive
+# transitioned True -> False. Either way, once this precondition is satisfied,
+# this transition is immediately triggered.
+#
+# What if two conflicting state-based transitions get enabled at the same
+# time?  In practice there's only one case where this arises (client DONE ->
+# MIGHT_SWITCH_PROTOCOL versus DONE -> MUST_CLOSE), and we resolve it by
+# explicitly prioritizing the DONE -> MIGHT_SWITCH_PROTOCOL transition.
+#
+# Implementation
+# --------------
+#
+# The event-triggered transitions for the server and client machines are all
+# stored explicitly in a table. Ditto for the state-triggered transitions that
+# involve just the server and client state.
+#
+# The transitions for the other machines, and the state-triggered transitions
+# that involve the other machines, are written out as explicit Python code.
+#
+# It'd be nice if there were some cleaner way to do all this. This isn't
+# *too* terrible, but I feel like it could probably be better.
+#
+# WARNING
+# -------
+#
+# The script that generates the state machine diagrams for the docs knows how
+# to read out the EVENT_TRIGGERED_TRANSITIONS and STATE_TRIGGERED_TRANSITIONS
+# tables. But it can't automatically read the transitions that are written
+# directly in Python code. So if you touch those, you need to also update the
+# script to keep it in sync!
+
+from ._events import *
+from ._util import LocalProtocolError, make_sentinel
+
+# Everything in __all__ gets re-exported as part of the h11 public API.
+__all__ = [
+    "CLIENT",
+    "SERVER",
+    "IDLE",
+    "SEND_RESPONSE",
+    "SEND_BODY",
+    "DONE",
+    "MUST_CLOSE",
+    "CLOSED",
+    "MIGHT_SWITCH_PROTOCOL",
+    "SWITCHED_PROTOCOL",
+    "ERROR",
+]
+
+CLIENT = make_sentinel("CLIENT")
+SERVER = make_sentinel("SERVER")
+
+# States
+IDLE = make_sentinel("IDLE")
+SEND_RESPONSE = make_sentinel("SEND_RESPONSE")
+SEND_BODY = make_sentinel("SEND_BODY")
+DONE = make_sentinel("DONE")
+MUST_CLOSE = make_sentinel("MUST_CLOSE")
+CLOSED = make_sentinel("CLOSED")
+ERROR = make_sentinel("ERROR")
+
+# Switch types
+MIGHT_SWITCH_PROTOCOL = make_sentinel("MIGHT_SWITCH_PROTOCOL")
+SWITCHED_PROTOCOL = make_sentinel("SWITCHED_PROTOCOL")
+
+_SWITCH_UPGRADE = make_sentinel("_SWITCH_UPGRADE")
+_SWITCH_CONNECT = make_sentinel("_SWITCH_CONNECT")
+
+EVENT_TRIGGERED_TRANSITIONS = {
+    CLIENT: {
+        IDLE: {Request: SEND_BODY, ConnectionClosed: CLOSED},
+        SEND_BODY: {Data: SEND_BODY, EndOfMessage: DONE},
+        DONE: {ConnectionClosed: CLOSED},
+        MUST_CLOSE: {ConnectionClosed: CLOSED},
+        CLOSED: {ConnectionClosed: CLOSED},
+        MIGHT_SWITCH_PROTOCOL: {},
+        SWITCHED_PROTOCOL: {},
+        ERROR: {},
+    },
+    SERVER: {
+        IDLE: {
+            ConnectionClosed: CLOSED,
+            Response: SEND_BODY,
+            # Special case: server sees client Request events, in this form
+            (Request, CLIENT): SEND_RESPONSE,
+        },
+        SEND_RESPONSE: {
+            InformationalResponse: SEND_RESPONSE,
+            Response: SEND_BODY,
+            (InformationalResponse, _SWITCH_UPGRADE): SWITCHED_PROTOCOL,
+            (Response, _SWITCH_CONNECT): SWITCHED_PROTOCOL,
+        },
+        SEND_BODY: {Data: SEND_BODY, EndOfMessage: DONE},
+        DONE: {ConnectionClosed: CLOSED},
+        MUST_CLOSE: {ConnectionClosed: CLOSED},
+        CLOSED: {ConnectionClosed: CLOSED},
+        SWITCHED_PROTOCOL: {},
+        ERROR: {},
+    },
+}
+
+# NB: there are also some special-case state-triggered transitions hard-coded
+# into _fire_state_triggered_transitions below.
+STATE_TRIGGERED_TRANSITIONS = {
+    # (Client state, Server state) -> new states
+    # Protocol negotiation
+    (MIGHT_SWITCH_PROTOCOL, SWITCHED_PROTOCOL): {CLIENT: SWITCHED_PROTOCOL},
+    # Socket shutdown
+    (CLOSED, DONE): {SERVER: MUST_CLOSE},
+    (CLOSED, IDLE): {SERVER: MUST_CLOSE},
+    (ERROR, DONE): {SERVER: MUST_CLOSE},
+    (DONE, CLOSED): {CLIENT: MUST_CLOSE},
+    (IDLE, CLOSED): {CLIENT: MUST_CLOSE},
+    (DONE, ERROR): {CLIENT: MUST_CLOSE},
+}
+
+
+class ConnectionState:
+    def __init__(self):
+        # Extra bits of state that don't quite fit into the state model.
+
+        # If this is False then it enables the automatic DONE -> MUST_CLOSE
+        # transition. Don't set this directly; call .keep_alive_disabled()
+        self.keep_alive = True
+
+        # This is a subset of {UPGRADE, CONNECT}, containing the proposals
+        # made by the client for switching protocols.
+        self.pending_switch_proposals = set()
+
+        self.states = {CLIENT: IDLE, SERVER: IDLE}
+
+    def process_error(self, role):
+        self.states[role] = ERROR
+        self._fire_state_triggered_transitions()
+
+    def process_keep_alive_disabled(self):
+        self.keep_alive = False
+        self._fire_state_triggered_transitions()
+
+    def process_client_switch_proposal(self, switch_event):
+        self.pending_switch_proposals.add(switch_event)
+        self._fire_state_triggered_transitions()
+
+    def process_event(self, role, event_type, server_switch_event=None):
+        if server_switch_event is not None:
+            assert role is SERVER
+            if server_switch_event not in self.pending_switch_proposals:
+                raise LocalProtocolError(
+                    "Received server {} event without a pending proposal".format(
+                        server_switch_event
+                    )
+                )
+            event_type = (event_type, server_switch_event)
+        if server_switch_event is None and event_type is Response:
+            self.pending_switch_proposals = set()
+        self._fire_event_triggered_transitions(role, event_type)
+        # Special case: the server state does get to see Request
+        # events.
+        if event_type is Request:
+            assert role is CLIENT
+            self._fire_event_triggered_transitions(SERVER, (Request, CLIENT))
+        self._fire_state_triggered_transitions()
+
+    def _fire_event_triggered_transitions(self, role, event_type):
+        state = self.states[role]
+        try:
+            new_state = EVENT_TRIGGERED_TRANSITIONS[role][state][event_type]
+        except KeyError:
+            raise LocalProtocolError(
+                "can't handle event type {} when role={} and state={}".format(
+                    event_type.__name__, role, self.states[role]
+                )
+            )
+        self.states[role] = new_state
+
+    def _fire_state_triggered_transitions(self):
+        # We apply these rules repeatedly until converging on a fixed point
+        while True:
+            start_states = dict(self.states)
+
+            # It could happen that both these special-case transitions are
+            # enabled at the same time:
+            #
+            #    DONE -> MIGHT_SWITCH_PROTOCOL
+            #    DONE -> MUST_CLOSE
+            #
+            # For example, this will always be true of a HTTP/1.0 client
+            # requesting CONNECT.  If this happens, the protocol switch takes
+            # priority. From there the client will either go to
+            # SWITCHED_PROTOCOL, in which case it's none of our business when
+            # they close the connection, or else the server will deny the
+            # request, in which case the client will go back to DONE and then
+            # from there to MUST_CLOSE.
+            if self.pending_switch_proposals:
+                if self.states[CLIENT] is DONE:
+                    self.states[CLIENT] = MIGHT_SWITCH_PROTOCOL
+
+            if not self.pending_switch_proposals:
+                if self.states[CLIENT] is MIGHT_SWITCH_PROTOCOL:
+                    self.states[CLIENT] = DONE
+
+            if not self.keep_alive:
+                for role in (CLIENT, SERVER):
+                    if self.states[role] is DONE:
+                        self.states[role] = MUST_CLOSE
+
+            # Tabular state-triggered transitions
+            joint_state = (self.states[CLIENT], self.states[SERVER])
+            changes = STATE_TRIGGERED_TRANSITIONS.get(joint_state, {})
+            self.states.update(changes)
+
+            if self.states == start_states:
+                # Fixed point reached
+                return
+
+    def start_next_cycle(self):
+        if self.states != {CLIENT: DONE, SERVER: DONE}:
+            raise LocalProtocolError(
+                "not in a reusable state. self.states={}".format(self.states)
+            )
+        # Can't reach DONE/DONE with any of these active, but still, let's be
+        # sure.
+        assert self.keep_alive
+        assert not self.pending_switch_proposals
+        self.states = {CLIENT: IDLE, SERVER: IDLE}
diff --git a/myenv/lib/python3.9/site-packages/h11/_util.py b/myenv/lib/python3.9/site-packages/h11/_util.py
new file mode 100644
index 0000000..eb1a5cd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/_util.py
@@ -0,0 +1,122 @@
+__all__ = [
+    "ProtocolError",
+    "LocalProtocolError",
+    "RemoteProtocolError",
+    "validate",
+    "make_sentinel",
+    "bytesify",
+]
+
+
+class ProtocolError(Exception):
+    """Exception indicating a violation of the HTTP/1.1 protocol.
+
+    This as an abstract base class, with two concrete base classes:
+    :exc:`LocalProtocolError`, which indicates that you tried to do something
+    that HTTP/1.1 says is illegal, and :exc:`RemoteProtocolError`, which
+    indicates that the remote peer tried to do something that HTTP/1.1 says is
+    illegal. See :ref:`error-handling` for details.
+
+    In addition to the normal :exc:`Exception` features, it has one attribute:
+
+    .. attribute:: error_status_hint
+
+       This gives a suggestion as to what status code a server might use if
+       this error occurred as part of a request.
+
+       For a :exc:`RemoteProtocolError`, this is useful as a suggestion for
+       how you might want to respond to a misbehaving peer, if you're
+       implementing a server.
+
+       For a :exc:`LocalProtocolError`, this can be taken as a suggestion for
+       how your peer might have responded to *you* if h11 had allowed you to
+       continue.
+
+       The default is 400 Bad Request, a generic catch-all for protocol
+       violations.
+
+    """
+
+    def __init__(self, msg, error_status_hint=400):
+        if type(self) is ProtocolError:
+            raise TypeError("tried to directly instantiate ProtocolError")
+        Exception.__init__(self, msg)
+        self.error_status_hint = error_status_hint
+
+
+# Strategy: there are a number of public APIs where a LocalProtocolError can
+# be raised (send(), all the different event constructors, ...), and only one
+# public API where RemoteProtocolError can be raised
+# (receive_data()). Therefore we always raise LocalProtocolError internally,
+# and then receive_data will translate this into a RemoteProtocolError.
+#
+# Internally:
+#   LocalProtocolError is the generic "ProtocolError".
+# Externally:
+#   LocalProtocolError is for local errors and RemoteProtocolError is for
+#   remote errors.
+class LocalProtocolError(ProtocolError):
+    def _reraise_as_remote_protocol_error(self):
+        # After catching a LocalProtocolError, use this method to re-raise it
+        # as a RemoteProtocolError. This method must be called from inside an
+        # except: block.
+        #
+        # An easy way to get an equivalent RemoteProtocolError is just to
+        # modify 'self' in place.
+        self.__class__ = RemoteProtocolError
+        # But the re-raising is somewhat non-trivial -- you might think that
+        # now that we've modified the in-flight exception object, that just
+        # doing 'raise' to re-raise it would be enough. But it turns out that
+        # this doesn't work, because Python tracks the exception type
+        # (exc_info[0]) separately from the exception object (exc_info[1]),
+        # and we only modified the latter. So we really do need to re-raise
+        # the new type explicitly.
+        # On py3, the traceback is part of the exception object, so our
+        # in-place modification preserved it and we can just re-raise:
+        raise self
+
+
+class RemoteProtocolError(ProtocolError):
+    pass
+
+
+def validate(regex, data, msg="malformed data", *format_args):
+    match = regex.fullmatch(data)
+    if not match:
+        if format_args:
+            msg = msg.format(*format_args)
+        raise LocalProtocolError(msg)
+    return match.groupdict()
+
+
+# Sentinel values
+#
+# - Inherit identity-based comparison and hashing from object
+# - Have a nice repr
+# - Have a *bonus property*: type(sentinel) is sentinel
+#
+# The bonus property is useful if you want to take the return value from
+# next_event() and do some sort of dispatch based on type(event).
+class _SentinelBase(type):
+    def __repr__(self):
+        return self.__name__
+
+
+def make_sentinel(name):
+    cls = _SentinelBase(name, (_SentinelBase,), {})
+    cls.__class__ = cls
+    return cls
+
+
+# Used for methods, request targets, HTTP versions, header names, and header
+# values. Accepts ascii-strings, or bytes/bytearray/memoryview/..., and always
+# returns bytes.
+def bytesify(s):
+    # Fast-path:
+    if type(s) is bytes:
+        return s
+    if isinstance(s, str):
+        s = s.encode("ascii")
+    if isinstance(s, int):
+        raise TypeError("expected bytes-like object, not int")
+    return bytes(s)
diff --git a/myenv/lib/python3.9/site-packages/h11/_version.py b/myenv/lib/python3.9/site-packages/h11/_version.py
new file mode 100644
index 0000000..cb5c2c3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/_version.py
@@ -0,0 +1,16 @@
+# This file must be kept very simple, because it is consumed from several
+# places -- it is imported by h11/__init__.py, execfile'd by setup.py, etc.
+
+# We use a simple scheme:
+#   1.0.0 -> 1.0.0+dev -> 1.1.0 -> 1.1.0+dev
+# where the +dev versions are never released into the wild, they're just what
+# we stick into the VCS in between releases.
+#
+# This is compatible with PEP 440:
+#   http://legacy.python.org/dev/peps/pep-0440/
+# via the use of the "local suffix" "+dev", which is disallowed on index
+# servers and causes 1.0.0+dev to sort after plain 1.0.0, which is what we
+# want. (Contrast with the special suffix 1.0.0.dev, which sorts *before*
+# 1.0.0.)
+
+__version__ = "0.12.0"
diff --git a/myenv/lib/python3.9/site-packages/h11/_writers.py b/myenv/lib/python3.9/site-packages/h11/_writers.py
new file mode 100644
index 0000000..cb5e8a8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/_writers.py
@@ -0,0 +1,123 @@
+# Code to read HTTP data
+#
+# Strategy: each writer takes an event + a write-some-bytes function, which is
+# calls.
+#
+# WRITERS is a dict describing how to pick a reader. It maps states to either:
+# - a writer
+# - or, for body writers, a dict of framin-dependent writer factories
+
+from ._events import Data, EndOfMessage
+from ._state import CLIENT, IDLE, SEND_BODY, SEND_RESPONSE, SERVER
+from ._util import LocalProtocolError
+
+__all__ = ["WRITERS"]
+
+
+def write_headers(headers, write):
+    # "Since the Host field-value is critical information for handling a
+    # request, a user agent SHOULD generate Host as the first header field
+    # following the request-line." - RFC 7230
+    raw_items = headers._full_items
+    for raw_name, name, value in raw_items:
+        if name == b"host":
+            write(b"%s: %s\r\n" % (raw_name, value))
+    for raw_name, name, value in raw_items:
+        if name != b"host":
+            write(b"%s: %s\r\n" % (raw_name, value))
+    write(b"\r\n")
+
+
+def write_request(request, write):
+    if request.http_version != b"1.1":
+        raise LocalProtocolError("I only send HTTP/1.1")
+    write(b"%s %s HTTP/1.1\r\n" % (request.method, request.target))
+    write_headers(request.headers, write)
+
+
+# Shared between InformationalResponse and Response
+def write_any_response(response, write):
+    if response.http_version != b"1.1":
+        raise LocalProtocolError("I only send HTTP/1.1")
+    status_bytes = str(response.status_code).encode("ascii")
+    # We don't bother sending ascii status messages like "OK"; they're
+    # optional and ignored by the protocol. (But the space after the numeric
+    # status code is mandatory.)
+    #
+    # XX FIXME: could at least make an effort to pull out the status message
+    # from stdlib's http.HTTPStatus table. Or maybe just steal their enums
+    # (either by import or copy/paste). We already accept them as status codes
+    # since they're of type IntEnum < int.
+    write(b"HTTP/1.1 %s %s\r\n" % (status_bytes, response.reason))
+    write_headers(response.headers, write)
+
+
+class BodyWriter:
+    def __call__(self, event, write):
+        if type(event) is Data:
+            self.send_data(event.data, write)
+        elif type(event) is EndOfMessage:
+            self.send_eom(event.headers, write)
+        else:  # pragma: no cover
+            assert False
+
+
+#
+# These are all careful not to do anything to 'data' except call len(data) and
+# write(data). This allows us to transparently pass-through funny objects,
+# like placeholder objects referring to files on disk that will be sent via
+# sendfile(2).
+#
+class ContentLengthWriter(BodyWriter):
+    def __init__(self, length):
+        self._length = length
+
+    def send_data(self, data, write):
+        self._length -= len(data)
+        if self._length < 0:
+            raise LocalProtocolError("Too much data for declared Content-Length")
+        write(data)
+
+    def send_eom(self, headers, write):
+        if self._length != 0:
+            raise LocalProtocolError("Too little data for declared Content-Length")
+        if headers:
+            raise LocalProtocolError("Content-Length and trailers don't mix")
+
+
+class ChunkedWriter(BodyWriter):
+    def send_data(self, data, write):
+        # if we encoded 0-length data in the naive way, it would look like an
+        # end-of-message.
+        if not data:
+            return
+        write(b"%x\r\n" % len(data))
+        write(data)
+        write(b"\r\n")
+
+    def send_eom(self, headers, write):
+        write(b"0\r\n")
+        write_headers(headers, write)
+
+
+class Http10Writer(BodyWriter):
+    def send_data(self, data, write):
+        write(data)
+
+    def send_eom(self, headers, write):
+        if headers:
+            raise LocalProtocolError("can't send trailers to HTTP/1.0 client")
+        # no need to close the socket ourselves, that will be taken care of by
+        # Connection: close machinery
+
+
+WRITERS = {
+    (CLIENT, IDLE): write_request,
+    (SERVER, IDLE): write_any_response,
+    (SERVER, SEND_RESPONSE): write_any_response,
+    SEND_BODY: {
+        "chunked": ChunkedWriter,
+        "content-length": ContentLengthWriter,
+        "http/1.0": Http10Writer,
+    },
+}
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/__init__.py b/myenv/lib/python3.9/site-packages/h11/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/data/test-file b/myenv/lib/python3.9/site-packages/h11/tests/data/test-file
new file mode 100644
index 0000000..d0be0a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/tests/data/test-file
@@ -0,0 +1 @@
+92b12bc045050b55b848d37167a1a63947c364579889ce1d39788e45e9fac9e5
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/helpers.py b/myenv/lib/python3.9/site-packages/h11/tests/helpers.py
new file mode 100644
index 0000000..9d2cf38
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/tests/helpers.py
@@ -0,0 +1,77 @@
+from .._connection import *
+from .._events import *
+from .._state import *
+
+
+def get_all_events(conn):
+    got_events = []
+    while True:
+        event = conn.next_event()
+        if event in (NEED_DATA, PAUSED):
+            break
+        got_events.append(event)
+        if type(event) is ConnectionClosed:
+            break
+    return got_events
+
+
+def receive_and_get(conn, data):
+    conn.receive_data(data)
+    return get_all_events(conn)
+
+
+# Merges adjacent Data events, converts payloads to bytestrings, and removes
+# chunk boundaries.
+def normalize_data_events(in_events):
+    out_events = []
+    for event in in_events:
+        if type(event) is Data:
+            event.data = bytes(event.data)
+            event.chunk_start = False
+            event.chunk_end = False
+        if out_events and type(out_events[-1]) is type(event) is Data:
+            out_events[-1].data += event.data
+        else:
+            out_events.append(event)
+    return out_events
+
+
+# Given that we want to write tests that push some events through a Connection
+# and check that its state updates appropriately... we might as make a habit
+# of pushing them through two Connections with a fake network link in
+# between.
+class ConnectionPair:
+    def __init__(self):
+        self.conn = {CLIENT: Connection(CLIENT), SERVER: Connection(SERVER)}
+        self.other = {CLIENT: SERVER, SERVER: CLIENT}
+
+    @property
+    def conns(self):
+        return self.conn.values()
+
+    # expect="match" if expect=send_events; expect=[...] to say what expected
+    def send(self, role, send_events, expect="match"):
+        if not isinstance(send_events, list):
+            send_events = [send_events]
+        data = b""
+        closed = False
+        for send_event in send_events:
+            new_data = self.conn[role].send(send_event)
+            if new_data is None:
+                closed = True
+            else:
+                data += new_data
+        # send uses b"" to mean b"", and None to mean closed
+        # receive uses b"" to mean closed, and None to mean "try again"
+        # so we have to translate between the two conventions
+        if data:
+            self.conn[self.other[role]].receive_data(data)
+        if closed:
+            self.conn[self.other[role]].receive_data(b"")
+        got_events = get_all_events(self.conn[self.other[role]])
+        if expect == "match":
+            expect = send_events
+        if not isinstance(expect, list):
+            expect = [expect]
+        assert got_events == expect
+        return data
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/test_against_stdlib_http.py b/myenv/lib/python3.9/site-packages/h11/tests/test_against_stdlib_http.py
new file mode 100644
index 0000000..e6c5db4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/tests/test_against_stdlib_http.py
@@ -0,0 +1,111 @@
+import json
+import os.path
+import socket
+import socketserver
+import threading
+from contextlib import closing, contextmanager
+from http.server import SimpleHTTPRequestHandler
+from urllib.request import urlopen
+
+import h11
+
+
+@contextmanager
+def socket_server(handler):
+    httpd = socketserver.TCPServer(("127.0.0.1", 0), handler)
+    thread = threading.Thread(
+        target=httpd.serve_forever, kwargs={"poll_interval": 0.01}
+    )
+    thread.daemon = True
+    try:
+        thread.start()
+        yield httpd
+    finally:
+        httpd.shutdown()
+
+
+test_file_path = os.path.join(os.path.dirname(__file__), "data/test-file")
+with open(test_file_path, "rb") as f:
+    test_file_data = f.read()
+
+
+class SingleMindedRequestHandler(SimpleHTTPRequestHandler):
+    def translate_path(self, path):
+        return test_file_path
+
+
+def test_h11_as_client():
+    with socket_server(SingleMindedRequestHandler) as httpd:
+        with closing(socket.create_connection(httpd.server_address)) as s:
+            c = h11.Connection(h11.CLIENT)
+
+            s.sendall(
+                c.send(
+                    h11.Request(
+                        method="GET", target="/foo", headers=[("Host", "localhost")]
+                    )
+                )
+            )
+            s.sendall(c.send(h11.EndOfMessage()))
+
+            data = bytearray()
+            while True:
+                event = c.next_event()
+                print(event)
+                if event is h11.NEED_DATA:
+                    # Use a small read buffer to make things more challenging
+                    # and exercise more paths :-)
+                    c.receive_data(s.recv(10))
+                    continue
+                if type(event) is h11.Response:
+                    assert event.status_code == 200
+                if type(event) is h11.Data:
+                    data += event.data
+                if type(event) is h11.EndOfMessage:
+                    break
+            assert bytes(data) == test_file_data
+
+
+class H11RequestHandler(socketserver.BaseRequestHandler):
+    def handle(self):
+        with closing(self.request) as s:
+            c = h11.Connection(h11.SERVER)
+            request = None
+            while True:
+                event = c.next_event()
+                if event is h11.NEED_DATA:
+                    # Use a small read buffer to make things more challenging
+                    # and exercise more paths :-)
+                    c.receive_data(s.recv(10))
+                    continue
+                if type(event) is h11.Request:
+                    request = event
+                if type(event) is h11.EndOfMessage:
+                    break
+            info = json.dumps(
+                {
+                    "method": request.method.decode("ascii"),
+                    "target": request.target.decode("ascii"),
+                    "headers": {
+                        name.decode("ascii"): value.decode("ascii")
+                        for (name, value) in request.headers
+                    },
+                }
+            )
+            s.sendall(c.send(h11.Response(status_code=200, headers=[])))
+            s.sendall(c.send(h11.Data(data=info.encode("ascii"))))
+            s.sendall(c.send(h11.EndOfMessage()))
+
+
+def test_h11_as_server():
+    with socket_server(H11RequestHandler) as httpd:
+        host, port = httpd.server_address
+        url = "http://{}:{}/some-path".format(host, port)
+        with closing(urlopen(url)) as f:
+            assert f.getcode() == 200
+            data = f.read()
+    info = json.loads(data.decode("ascii"))
+    print(info)
+    assert info["method"] == "GET"
+    assert info["target"] == "/some-path"
+    assert "urllib" in info["headers"]["user-agent"]
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/test_connection.py b/myenv/lib/python3.9/site-packages/h11/tests/test_connection.py
new file mode 100644
index 0000000..baadec8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/tests/test_connection.py
@@ -0,0 +1,1078 @@
+import pytest
+
+from .._connection import _body_framing, _keep_alive, Connection, NEED_DATA, PAUSED
+from .._events import *
+from .._state import *
+from .._util import LocalProtocolError, RemoteProtocolError
+from .helpers import ConnectionPair, get_all_events, receive_and_get
+
+
+def test__keep_alive():
+    assert _keep_alive(
+        Request(method="GET", target="/", headers=[("Host", "Example.com")])
+    )
+    assert not _keep_alive(
+        Request(
+            method="GET",
+            target="/",
+            headers=[("Host", "Example.com"), ("Connection", "close")],
+        )
+    )
+    assert not _keep_alive(
+        Request(
+            method="GET",
+            target="/",
+            headers=[("Host", "Example.com"), ("Connection", "a, b, cLOse, foo")],
+        )
+    )
+    assert not _keep_alive(
+        Request(method="GET", target="/", headers=[], http_version="1.0")
+    )
+
+    assert _keep_alive(Response(status_code=200, headers=[]))
+    assert not _keep_alive(Response(status_code=200, headers=[("Connection", "close")]))
+    assert not _keep_alive(
+        Response(status_code=200, headers=[("Connection", "a, b, cLOse, foo")])
+    )
+    assert not _keep_alive(Response(status_code=200, headers=[], http_version="1.0"))
+
+
+def test__body_framing():
+    def headers(cl, te):
+        headers = []
+        if cl is not None:
+            headers.append(("Content-Length", str(cl)))
+        if te:
+            headers.append(("Transfer-Encoding", "chunked"))
+        return headers
+
+    def resp(status_code=200, cl=None, te=False):
+        return Response(status_code=status_code, headers=headers(cl, te))
+
+    def req(cl=None, te=False):
+        h = headers(cl, te)
+        h += [("Host", "example.com")]
+        return Request(method="GET", target="/", headers=h)
+
+    # Special cases where the headers are ignored:
+    for kwargs in [{}, {"cl": 100}, {"te": True}, {"cl": 100, "te": True}]:
+        for meth, r in [
+            (b"HEAD", resp(**kwargs)),
+            (b"GET", resp(status_code=204, **kwargs)),
+            (b"GET", resp(status_code=304, **kwargs)),
+        ]:
+            assert _body_framing(meth, r) == ("content-length", (0,))
+
+    # Transfer-encoding
+    for kwargs in [{"te": True}, {"cl": 100, "te": True}]:
+        for meth, r in [(None, req(**kwargs)), (b"GET", resp(**kwargs))]:
+            assert _body_framing(meth, r) == ("chunked", ())
+
+    # Content-Length
+    for meth, r in [(None, req(cl=100)), (b"GET", resp(cl=100))]:
+        assert _body_framing(meth, r) == ("content-length", (100,))
+
+    # No headers
+    assert _body_framing(None, req()) == ("content-length", (0,))
+    assert _body_framing(b"GET", resp()) == ("http/1.0", ())
+
+
+def test_Connection_basics_and_content_length():
+    with pytest.raises(ValueError):
+        Connection("CLIENT")
+
+    p = ConnectionPair()
+    assert p.conn[CLIENT].our_role is CLIENT
+    assert p.conn[CLIENT].their_role is SERVER
+    assert p.conn[SERVER].our_role is SERVER
+    assert p.conn[SERVER].their_role is CLIENT
+
+    data = p.send(
+        CLIENT,
+        Request(
+            method="GET",
+            target="/",
+            headers=[("Host", "example.com"), ("Content-Length", "10")],
+        ),
+    )
+    assert data == (
+        b"GET / HTTP/1.1\r\n" b"Host: example.com\r\n" b"Content-Length: 10\r\n\r\n"
+    )
+
+    for conn in p.conns:
+        assert conn.states == {CLIENT: SEND_BODY, SERVER: SEND_RESPONSE}
+    assert p.conn[CLIENT].our_state is SEND_BODY
+    assert p.conn[CLIENT].their_state is SEND_RESPONSE
+    assert p.conn[SERVER].our_state is SEND_RESPONSE
+    assert p.conn[SERVER].their_state is SEND_BODY
+
+    assert p.conn[CLIENT].their_http_version is None
+    assert p.conn[SERVER].their_http_version == b"1.1"
+
+    data = p.send(SERVER, InformationalResponse(status_code=100, headers=[]))
+    assert data == b"HTTP/1.1 100 \r\n\r\n"
+
+    data = p.send(SERVER, Response(status_code=200, headers=[("Content-Length", "11")]))
+    assert data == b"HTTP/1.1 200 \r\nContent-Length: 11\r\n\r\n"
+
+    for conn in p.conns:
+        assert conn.states == {CLIENT: SEND_BODY, SERVER: SEND_BODY}
+
+    assert p.conn[CLIENT].their_http_version == b"1.1"
+    assert p.conn[SERVER].their_http_version == b"1.1"
+
+    data = p.send(CLIENT, Data(data=b"12345"))
+    assert data == b"12345"
+    data = p.send(
+        CLIENT, Data(data=b"67890"), expect=[Data(data=b"67890"), EndOfMessage()]
+    )
+    assert data == b"67890"
+    data = p.send(CLIENT, EndOfMessage(), expect=[])
+    assert data == b""
+
+    for conn in p.conns:
+        assert conn.states == {CLIENT: DONE, SERVER: SEND_BODY}
+
+    data = p.send(SERVER, Data(data=b"1234567890"))
+    assert data == b"1234567890"
+    data = p.send(SERVER, Data(data=b"1"), expect=[Data(data=b"1"), EndOfMessage()])
+    assert data == b"1"
+    data = p.send(SERVER, EndOfMessage(), expect=[])
+    assert data == b""
+
+    for conn in p.conns:
+        assert conn.states == {CLIENT: DONE, SERVER: DONE}
+
+
+def test_chunked():
+    p = ConnectionPair()
+
+    p.send(
+        CLIENT,
+        Request(
+            method="GET",
+            target="/",
+            headers=[("Host", "example.com"), ("Transfer-Encoding", "chunked")],
+        ),
+    )
+    data = p.send(CLIENT, Data(data=b"1234567890", chunk_start=True, chunk_end=True))
+    assert data == b"a\r\n1234567890\r\n"
+    data = p.send(CLIENT, Data(data=b"abcde", chunk_start=True, chunk_end=True))
+    assert data == b"5\r\nabcde\r\n"
+    data = p.send(CLIENT, Data(data=b""), expect=[])
+    assert data == b""
+    data = p.send(CLIENT, EndOfMessage(headers=[("hello", "there")]))
+    assert data == b"0\r\nhello: there\r\n\r\n"
+
+    p.send(
+        SERVER, Response(status_code=200, headers=[("Transfer-Encoding", "chunked")])
+    )
+    p.send(SERVER, Data(data=b"54321", chunk_start=True, chunk_end=True))
+    p.send(SERVER, Data(data=b"12345", chunk_start=True, chunk_end=True))
+    p.send(SERVER, EndOfMessage())
+
+    for conn in p.conns:
+        assert conn.states == {CLIENT: DONE, SERVER: DONE}
+
+
+def test_chunk_boundaries():
+    conn = Connection(our_role=SERVER)
+
+    request = (
+        b"POST / HTTP/1.1\r\n"
+        b"Host: example.com\r\n"
+        b"Transfer-Encoding: chunked\r\n"
+        b"\r\n"
+    )
+    conn.receive_data(request)
+    assert conn.next_event() == Request(
+        method="POST",
+        target="/",
+        headers=[("Host", "example.com"), ("Transfer-Encoding", "chunked")],
+    )
+    assert conn.next_event() is NEED_DATA
+
+    conn.receive_data(b"5\r\nhello\r\n")
+    assert conn.next_event() == Data(data=b"hello", chunk_start=True, chunk_end=True)
+
+    conn.receive_data(b"5\r\nhel")
+    assert conn.next_event() == Data(data=b"hel", chunk_start=True, chunk_end=False)
+
+    conn.receive_data(b"l")
+    assert conn.next_event() == Data(data=b"l", chunk_start=False, chunk_end=False)
+
+    conn.receive_data(b"o\r\n")
+    assert conn.next_event() == Data(data=b"o", chunk_start=False, chunk_end=True)
+
+    conn.receive_data(b"5\r\nhello")
+    assert conn.next_event() == Data(data=b"hello", chunk_start=True, chunk_end=True)
+
+    conn.receive_data(b"\r\n")
+    assert conn.next_event() == NEED_DATA
+
+    conn.receive_data(b"0\r\n\r\n")
+    assert conn.next_event() == EndOfMessage()
+
+
+def test_client_talking_to_http10_server():
+    c = Connection(CLIENT)
+    c.send(Request(method="GET", target="/", headers=[("Host", "example.com")]))
+    c.send(EndOfMessage())
+    assert c.our_state is DONE
+    # No content-length, so Http10 framing for body
+    assert receive_and_get(c, b"HTTP/1.0 200 OK\r\n\r\n") == [
+        Response(status_code=200, headers=[], http_version="1.0", reason=b"OK")
+    ]
+    assert c.our_state is MUST_CLOSE
+    assert receive_and_get(c, b"12345") == [Data(data=b"12345")]
+    assert receive_and_get(c, b"67890") == [Data(data=b"67890")]
+    assert receive_and_get(c, b"") == [EndOfMessage(), ConnectionClosed()]
+    assert c.their_state is CLOSED
+
+
+def test_server_talking_to_http10_client():
+    c = Connection(SERVER)
+    # No content-length, so no body
+    # NB: no host header
+    assert receive_and_get(c, b"GET / HTTP/1.0\r\n\r\n") == [
+        Request(method="GET", target="/", headers=[], http_version="1.0"),
+        EndOfMessage(),
+    ]
+    assert c.their_state is MUST_CLOSE
+
+    # We automatically Connection: close back at them
+    assert (
+        c.send(Response(status_code=200, headers=[]))
+        == b"HTTP/1.1 200 \r\nConnection: close\r\n\r\n"
+    )
+
+    assert c.send(Data(data=b"12345")) == b"12345"
+    assert c.send(EndOfMessage()) == b""
+    assert c.our_state is MUST_CLOSE
+
+    # Check that it works if they do send Content-Length
+    c = Connection(SERVER)
+    # NB: no host header
+    assert receive_and_get(c, b"POST / HTTP/1.0\r\nContent-Length: 10\r\n\r\n1") == [
+        Request(
+            method="POST",
+            target="/",
+            headers=[("Content-Length", "10")],
+            http_version="1.0",
+        ),
+        Data(data=b"1"),
+    ]
+    assert receive_and_get(c, b"234567890") == [Data(data=b"234567890"), EndOfMessage()]
+    assert c.their_state is MUST_CLOSE
+    assert receive_and_get(c, b"") == [ConnectionClosed()]
+
+
+def test_automatic_transfer_encoding_in_response():
+    # Check that in responses, the user can specify either Transfer-Encoding:
+    # chunked or no framing at all, and in both cases we automatically select
+    # the right option depending on whether the peer speaks HTTP/1.0 or
+    # HTTP/1.1
+    for user_headers in [
+        [("Transfer-Encoding", "chunked")],
+        [],
+        # In fact, this even works if Content-Length is set,
+        # because if both are set then Transfer-Encoding wins
+        [("Transfer-Encoding", "chunked"), ("Content-Length", "100")],
+    ]:
+        p = ConnectionPair()
+        p.send(
+            CLIENT,
+            [
+                Request(method="GET", target="/", headers=[("Host", "example.com")]),
+                EndOfMessage(),
+            ],
+        )
+        # When speaking to HTTP/1.1 client, all of the above cases get
+        # normalized to Transfer-Encoding: chunked
+        p.send(
+            SERVER,
+            Response(status_code=200, headers=user_headers),
+            expect=Response(
+                status_code=200, headers=[("Transfer-Encoding", "chunked")]
+            ),
+        )
+
+        # When speaking to HTTP/1.0 client, all of the above cases get
+        # normalized to no-framing-headers
+        c = Connection(SERVER)
+        receive_and_get(c, b"GET / HTTP/1.0\r\n\r\n")
+        assert (
+            c.send(Response(status_code=200, headers=user_headers))
+            == b"HTTP/1.1 200 \r\nConnection: close\r\n\r\n"
+        )
+        assert c.send(Data(data=b"12345")) == b"12345"
+
+
+def test_automagic_connection_close_handling():
+    p = ConnectionPair()
+    # If the user explicitly sets Connection: close, then we notice and
+    # respect it
+    p.send(
+        CLIENT,
+        [
+            Request(
+                method="GET",
+                target="/",
+                headers=[("Host", "example.com"), ("Connection", "close")],
+            ),
+            EndOfMessage(),
+        ],
+    )
+    for conn in p.conns:
+        assert conn.states[CLIENT] is MUST_CLOSE
+    # And if the client sets it, the server automatically echoes it back
+    p.send(
+        SERVER,
+        # no header here...
+        [Response(status_code=204, headers=[]), EndOfMessage()],
+        # ...but oh look, it arrived anyway
+        expect=[
+            Response(status_code=204, headers=[("connection", "close")]),
+            EndOfMessage(),
+        ],
+    )
+    for conn in p.conns:
+        assert conn.states == {CLIENT: MUST_CLOSE, SERVER: MUST_CLOSE}
+
+
+def test_100_continue():
+    def setup():
+        p = ConnectionPair()
+        p.send(
+            CLIENT,
+            Request(
+                method="GET",
+                target="/",
+                headers=[
+                    ("Host", "example.com"),
+                    ("Content-Length", "100"),
+                    ("Expect", "100-continue"),
+                ],
+            ),
+        )
+        for conn in p.conns:
+            assert conn.client_is_waiting_for_100_continue
+        assert not p.conn[CLIENT].they_are_waiting_for_100_continue
+        assert p.conn[SERVER].they_are_waiting_for_100_continue
+        return p
+
+    # Disabled by 100 Continue
+    p = setup()
+    p.send(SERVER, InformationalResponse(status_code=100, headers=[]))
+    for conn in p.conns:
+        assert not conn.client_is_waiting_for_100_continue
+        assert not conn.they_are_waiting_for_100_continue
+
+    # Disabled by a real response
+    p = setup()
+    p.send(
+        SERVER, Response(status_code=200, headers=[("Transfer-Encoding", "chunked")])
+    )
+    for conn in p.conns:
+        assert not conn.client_is_waiting_for_100_continue
+        assert not conn.they_are_waiting_for_100_continue
+
+    # Disabled by the client going ahead and sending stuff anyway
+    p = setup()
+    p.send(CLIENT, Data(data=b"12345"))
+    for conn in p.conns:
+        assert not conn.client_is_waiting_for_100_continue
+        assert not conn.they_are_waiting_for_100_continue
+
+
+def test_max_incomplete_event_size_countermeasure():
+    # Infinitely long headers are definitely not okay
+    c = Connection(SERVER)
+    c.receive_data(b"GET / HTTP/1.0\r\nEndless: ")
+    assert c.next_event() is NEED_DATA
+    with pytest.raises(RemoteProtocolError):
+        while True:
+            c.receive_data(b"a" * 1024)
+            c.next_event()
+
+    # Checking that the same header is accepted / rejected depending on the
+    # max_incomplete_event_size setting:
+    c = Connection(SERVER, max_incomplete_event_size=5000)
+    c.receive_data(b"GET / HTTP/1.0\r\nBig: ")
+    c.receive_data(b"a" * 4000)
+    c.receive_data(b"\r\n\r\n")
+    assert get_all_events(c) == [
+        Request(
+            method="GET", target="/", http_version="1.0", headers=[("big", "a" * 4000)]
+        ),
+        EndOfMessage(),
+    ]
+
+    c = Connection(SERVER, max_incomplete_event_size=4000)
+    c.receive_data(b"GET / HTTP/1.0\r\nBig: ")
+    c.receive_data(b"a" * 4000)
+    with pytest.raises(RemoteProtocolError):
+        c.next_event()
+
+    # Temporarily exceeding the size limit is fine, as long as its done with
+    # complete events:
+    c = Connection(SERVER, max_incomplete_event_size=5000)
+    c.receive_data(b"GET / HTTP/1.0\r\nContent-Length: 10000")
+    c.receive_data(b"\r\n\r\n" + b"a" * 10000)
+    assert get_all_events(c) == [
+        Request(
+            method="GET",
+            target="/",
+            http_version="1.0",
+            headers=[("Content-Length", "10000")],
+        ),
+        Data(data=b"a" * 10000),
+        EndOfMessage(),
+    ]
+
+    c = Connection(SERVER, max_incomplete_event_size=100)
+    # Two pipelined requests to create a way-too-big receive buffer... but
+    # it's fine because we're not checking
+    c.receive_data(
+        b"GET /1 HTTP/1.1\r\nHost: a\r\n\r\n"
+        b"GET /2 HTTP/1.1\r\nHost: b\r\n\r\n" + b"X" * 1000
+    )
+    assert get_all_events(c) == [
+        Request(method="GET", target="/1", headers=[("host", "a")]),
+        EndOfMessage(),
+    ]
+    # Even more data comes in, still no problem
+    c.receive_data(b"X" * 1000)
+    # We can respond and reuse to get the second pipelined request
+    c.send(Response(status_code=200, headers=[]))
+    c.send(EndOfMessage())
+    c.start_next_cycle()
+    assert get_all_events(c) == [
+        Request(method="GET", target="/2", headers=[("host", "b")]),
+        EndOfMessage(),
+    ]
+    # But once we unpause and try to read the next message, and find that it's
+    # incomplete and the buffer is *still* way too large, then *that's* a
+    # problem:
+    c.send(Response(status_code=200, headers=[]))
+    c.send(EndOfMessage())
+    c.start_next_cycle()
+    with pytest.raises(RemoteProtocolError):
+        c.next_event()
+
+
+def test_reuse_simple():
+    p = ConnectionPair()
+    p.send(
+        CLIENT,
+        [Request(method="GET", target="/", headers=[("Host", "a")]), EndOfMessage()],
+    )
+    p.send(SERVER, [Response(status_code=200, headers=[]), EndOfMessage()])
+    for conn in p.conns:
+        assert conn.states == {CLIENT: DONE, SERVER: DONE}
+        conn.start_next_cycle()
+
+    p.send(
+        CLIENT,
+        [
+            Request(method="DELETE", target="/foo", headers=[("Host", "a")]),
+            EndOfMessage(),
+        ],
+    )
+    p.send(SERVER, [Response(status_code=404, headers=[]), EndOfMessage()])
+
+
+def test_pipelining():
+    # Client doesn't support pipelining, so we have to do this by hand
+    c = Connection(SERVER)
+    assert c.next_event() is NEED_DATA
+    # 3 requests all bunched up
+    c.receive_data(
+        b"GET /1 HTTP/1.1\r\nHost: a.com\r\nContent-Length: 5\r\n\r\n"
+        b"12345"
+        b"GET /2 HTTP/1.1\r\nHost: a.com\r\nContent-Length: 5\r\n\r\n"
+        b"67890"
+        b"GET /3 HTTP/1.1\r\nHost: a.com\r\n\r\n"
+    )
+    assert get_all_events(c) == [
+        Request(
+            method="GET",
+            target="/1",
+            headers=[("Host", "a.com"), ("Content-Length", "5")],
+        ),
+        Data(data=b"12345"),
+        EndOfMessage(),
+    ]
+    assert c.their_state is DONE
+    assert c.our_state is SEND_RESPONSE
+
+    assert c.next_event() is PAUSED
+
+    c.send(Response(status_code=200, headers=[]))
+    c.send(EndOfMessage())
+    assert c.their_state is DONE
+    assert c.our_state is DONE
+
+    c.start_next_cycle()
+
+    assert get_all_events(c) == [
+        Request(
+            method="GET",
+            target="/2",
+            headers=[("Host", "a.com"), ("Content-Length", "5")],
+        ),
+        Data(data=b"67890"),
+        EndOfMessage(),
+    ]
+    assert c.next_event() is PAUSED
+    c.send(Response(status_code=200, headers=[]))
+    c.send(EndOfMessage())
+    c.start_next_cycle()
+
+    assert get_all_events(c) == [
+        Request(method="GET", target="/3", headers=[("Host", "a.com")]),
+        EndOfMessage(),
+    ]
+    # Doesn't pause this time, no trailing data
+    assert c.next_event() is NEED_DATA
+    c.send(Response(status_code=200, headers=[]))
+    c.send(EndOfMessage())
+
+    # Arrival of more data triggers pause
+    assert c.next_event() is NEED_DATA
+    c.receive_data(b"SADF")
+    assert c.next_event() is PAUSED
+    assert c.trailing_data == (b"SADF", False)
+    # If EOF arrives while paused, we don't see that either:
+    c.receive_data(b"")
+    assert c.trailing_data == (b"SADF", True)
+    assert c.next_event() is PAUSED
+    c.receive_data(b"")
+    assert c.next_event() is PAUSED
+    # Can't call receive_data with non-empty buf after closing it
+    with pytest.raises(RuntimeError):
+        c.receive_data(b"FDSA")
+
+
+def test_protocol_switch():
+    for (req, deny, accept) in [
+        (
+            Request(
+                method="CONNECT",
+                target="example.com:443",
+                headers=[("Host", "foo"), ("Content-Length", "1")],
+            ),
+            Response(status_code=404, headers=[]),
+            Response(status_code=200, headers=[]),
+        ),
+        (
+            Request(
+                method="GET",
+                target="/",
+                headers=[("Host", "foo"), ("Content-Length", "1"), ("Upgrade", "a, b")],
+            ),
+            Response(status_code=200, headers=[]),
+            InformationalResponse(status_code=101, headers=[("Upgrade", "a")]),
+        ),
+        (
+            Request(
+                method="CONNECT",
+                target="example.com:443",
+                headers=[("Host", "foo"), ("Content-Length", "1"), ("Upgrade", "a, b")],
+            ),
+            Response(status_code=404, headers=[]),
+            # Accept CONNECT, not upgrade
+            Response(status_code=200, headers=[]),
+        ),
+        (
+            Request(
+                method="CONNECT",
+                target="example.com:443",
+                headers=[("Host", "foo"), ("Content-Length", "1"), ("Upgrade", "a, b")],
+            ),
+            Response(status_code=404, headers=[]),
+            # Accept Upgrade, not CONNECT
+            InformationalResponse(status_code=101, headers=[("Upgrade", "b")]),
+        ),
+    ]:
+
+        def setup():
+            p = ConnectionPair()
+            p.send(CLIENT, req)
+            # No switch-related state change stuff yet; the client has to
+            # finish the request before that kicks in
+            for conn in p.conns:
+                assert conn.states[CLIENT] is SEND_BODY
+            p.send(CLIENT, [Data(data=b"1"), EndOfMessage()])
+            for conn in p.conns:
+                assert conn.states[CLIENT] is MIGHT_SWITCH_PROTOCOL
+            assert p.conn[SERVER].next_event() is PAUSED
+            return p
+
+        # Test deny case
+        p = setup()
+        p.send(SERVER, deny)
+        for conn in p.conns:
+            assert conn.states == {CLIENT: DONE, SERVER: SEND_BODY}
+        p.send(SERVER, EndOfMessage())
+        # Check that re-use is still allowed after a denial
+        for conn in p.conns:
+            conn.start_next_cycle()
+
+        # Test accept case
+        p = setup()
+        p.send(SERVER, accept)
+        for conn in p.conns:
+            assert conn.states == {CLIENT: SWITCHED_PROTOCOL, SERVER: SWITCHED_PROTOCOL}
+            conn.receive_data(b"123")
+            assert conn.next_event() is PAUSED
+            conn.receive_data(b"456")
+            assert conn.next_event() is PAUSED
+            assert conn.trailing_data == (b"123456", False)
+
+        # Pausing in might-switch, then recovery
+        # (weird artificial case where the trailing data actually is valid
+        # HTTP for some reason, because this makes it easier to test the state
+        # logic)
+        p = setup()
+        sc = p.conn[SERVER]
+        sc.receive_data(b"GET / HTTP/1.0\r\n\r\n")
+        assert sc.next_event() is PAUSED
+        assert sc.trailing_data == (b"GET / HTTP/1.0\r\n\r\n", False)
+        sc.send(deny)
+        assert sc.next_event() is PAUSED
+        sc.send(EndOfMessage())
+        sc.start_next_cycle()
+        assert get_all_events(sc) == [
+            Request(method="GET", target="/", headers=[], http_version="1.0"),
+            EndOfMessage(),
+        ]
+
+        # When we're DONE, have no trailing data, and the connection gets
+        # closed, we report ConnectionClosed(). When we're in might-switch or
+        # switched, we don't.
+        p = setup()
+        sc = p.conn[SERVER]
+        sc.receive_data(b"")
+        assert sc.next_event() is PAUSED
+        assert sc.trailing_data == (b"", True)
+        p.send(SERVER, accept)
+        assert sc.next_event() is PAUSED
+
+        p = setup()
+        sc = p.conn[SERVER]
+        sc.receive_data(b"") == []
+        assert sc.next_event() is PAUSED
+        sc.send(deny)
+        assert sc.next_event() == ConnectionClosed()
+
+        # You can't send after switching protocols, or while waiting for a
+        # protocol switch
+        p = setup()
+        with pytest.raises(LocalProtocolError):
+            p.conn[CLIENT].send(
+                Request(method="GET", target="/", headers=[("Host", "a")])
+            )
+        p = setup()
+        p.send(SERVER, accept)
+        with pytest.raises(LocalProtocolError):
+            p.conn[SERVER].send(Data(data=b"123"))
+
+
+def test_close_simple():
+    # Just immediately closing a new connection without anything having
+    # happened yet.
+    for (who_shot_first, who_shot_second) in [(CLIENT, SERVER), (SERVER, CLIENT)]:
+
+        def setup():
+            p = ConnectionPair()
+            p.send(who_shot_first, ConnectionClosed())
+            for conn in p.conns:
+                assert conn.states == {
+                    who_shot_first: CLOSED,
+                    who_shot_second: MUST_CLOSE,
+                }
+            return p
+
+        # You can keep putting b"" into a closed connection, and you keep
+        # getting ConnectionClosed() out:
+        p = setup()
+        assert p.conn[who_shot_second].next_event() == ConnectionClosed()
+        assert p.conn[who_shot_second].next_event() == ConnectionClosed()
+        p.conn[who_shot_second].receive_data(b"")
+        assert p.conn[who_shot_second].next_event() == ConnectionClosed()
+        # Second party can close...
+        p = setup()
+        p.send(who_shot_second, ConnectionClosed())
+        for conn in p.conns:
+            assert conn.our_state is CLOSED
+            assert conn.their_state is CLOSED
+        # But trying to receive new data on a closed connection is a
+        # RuntimeError (not ProtocolError, because the problem here isn't
+        # violation of HTTP, it's violation of physics)
+        p = setup()
+        with pytest.raises(RuntimeError):
+            p.conn[who_shot_second].receive_data(b"123")
+        # And receiving new data on a MUST_CLOSE connection is a ProtocolError
+        p = setup()
+        p.conn[who_shot_first].receive_data(b"GET")
+        with pytest.raises(RemoteProtocolError):
+            p.conn[who_shot_first].next_event()
+
+
+def test_close_different_states():
+    req = [
+        Request(method="GET", target="/foo", headers=[("Host", "a")]),
+        EndOfMessage(),
+    ]
+    resp = [Response(status_code=200, headers=[]), EndOfMessage()]
+
+    # Client before request
+    p = ConnectionPair()
+    p.send(CLIENT, ConnectionClosed())
+    for conn in p.conns:
+        assert conn.states == {CLIENT: CLOSED, SERVER: MUST_CLOSE}
+
+    # Client after request
+    p = ConnectionPair()
+    p.send(CLIENT, req)
+    p.send(CLIENT, ConnectionClosed())
+    for conn in p.conns:
+        assert conn.states == {CLIENT: CLOSED, SERVER: SEND_RESPONSE}
+
+    # Server after request -> not allowed
+    p = ConnectionPair()
+    p.send(CLIENT, req)
+    with pytest.raises(LocalProtocolError):
+        p.conn[SERVER].send(ConnectionClosed())
+    p.conn[CLIENT].receive_data(b"")
+    with pytest.raises(RemoteProtocolError):
+        p.conn[CLIENT].next_event()
+
+    # Server after response
+    p = ConnectionPair()
+    p.send(CLIENT, req)
+    p.send(SERVER, resp)
+    p.send(SERVER, ConnectionClosed())
+    for conn in p.conns:
+        assert conn.states == {CLIENT: MUST_CLOSE, SERVER: CLOSED}
+
+    # Both after closing (ConnectionClosed() is idempotent)
+    p = ConnectionPair()
+    p.send(CLIENT, req)
+    p.send(SERVER, resp)
+    p.send(CLIENT, ConnectionClosed())
+    p.send(SERVER, ConnectionClosed())
+    p.send(CLIENT, ConnectionClosed())
+    p.send(SERVER, ConnectionClosed())
+
+    # In the middle of sending -> not allowed
+    p = ConnectionPair()
+    p.send(
+        CLIENT,
+        Request(
+            method="GET", target="/", headers=[("Host", "a"), ("Content-Length", "10")]
+        ),
+    )
+    with pytest.raises(LocalProtocolError):
+        p.conn[CLIENT].send(ConnectionClosed())
+    p.conn[SERVER].receive_data(b"")
+    with pytest.raises(RemoteProtocolError):
+        p.conn[SERVER].next_event()
+
+
+# Receive several requests and then client shuts down their side of the
+# connection; we can respond to each
+def test_pipelined_close():
+    c = Connection(SERVER)
+    # 2 requests then a close
+    c.receive_data(
+        b"GET /1 HTTP/1.1\r\nHost: a.com\r\nContent-Length: 5\r\n\r\n"
+        b"12345"
+        b"GET /2 HTTP/1.1\r\nHost: a.com\r\nContent-Length: 5\r\n\r\n"
+        b"67890"
+    )
+    c.receive_data(b"")
+    assert get_all_events(c) == [
+        Request(
+            method="GET",
+            target="/1",
+            headers=[("host", "a.com"), ("content-length", "5")],
+        ),
+        Data(data=b"12345"),
+        EndOfMessage(),
+    ]
+    assert c.states[CLIENT] is DONE
+    c.send(Response(status_code=200, headers=[]))
+    c.send(EndOfMessage())
+    assert c.states[SERVER] is DONE
+    c.start_next_cycle()
+    assert get_all_events(c) == [
+        Request(
+            method="GET",
+            target="/2",
+            headers=[("host", "a.com"), ("content-length", "5")],
+        ),
+        Data(data=b"67890"),
+        EndOfMessage(),
+        ConnectionClosed(),
+    ]
+    assert c.states == {CLIENT: CLOSED, SERVER: SEND_RESPONSE}
+    c.send(Response(status_code=200, headers=[]))
+    c.send(EndOfMessage())
+    assert c.states == {CLIENT: CLOSED, SERVER: MUST_CLOSE}
+    c.send(ConnectionClosed())
+    assert c.states == {CLIENT: CLOSED, SERVER: CLOSED}
+
+
+def test_sendfile():
+    class SendfilePlaceholder:
+        def __len__(self):
+            return 10
+
+    placeholder = SendfilePlaceholder()
+
+    def setup(header, http_version):
+        c = Connection(SERVER)
+        receive_and_get(
+            c, "GET / HTTP/{}\r\nHost: a\r\n\r\n".format(http_version).encode("ascii")
+        )
+        headers = []
+        if header:
+            headers.append(header)
+        c.send(Response(status_code=200, headers=headers))
+        return c, c.send_with_data_passthrough(Data(data=placeholder))
+
+    c, data = setup(("Content-Length", "10"), "1.1")
+    assert data == [placeholder]
+    # Raises an error if the connection object doesn't think we've sent
+    # exactly 10 bytes
+    c.send(EndOfMessage())
+
+    _, data = setup(("Transfer-Encoding", "chunked"), "1.1")
+    assert placeholder in data
+    data[data.index(placeholder)] = b"x" * 10
+    assert b"".join(data) == b"a\r\nxxxxxxxxxx\r\n"
+
+    c, data = setup(None, "1.0")
+    assert data == [placeholder]
+    assert c.our_state is SEND_BODY
+
+
+def test_errors():
+    # After a receive error, you can't receive
+    for role in [CLIENT, SERVER]:
+        c = Connection(our_role=role)
+        c.receive_data(b"gibberish\r\n\r\n")
+        with pytest.raises(RemoteProtocolError):
+            c.next_event()
+        # Now any attempt to receive continues to raise
+        assert c.their_state is ERROR
+        assert c.our_state is not ERROR
+        print(c._cstate.states)
+        with pytest.raises(RemoteProtocolError):
+            c.next_event()
+        # But we can still yell at the client for sending us gibberish
+        if role is SERVER:
+            assert (
+                c.send(Response(status_code=400, headers=[]))
+                == b"HTTP/1.1 400 \r\nConnection: close\r\n\r\n"
+            )
+
+    # After an error sending, you can no longer send
+    # (This is especially important for things like content-length errors,
+    # where there's complex internal state being modified)
+    def conn(role):
+        c = Connection(our_role=role)
+        if role is SERVER:
+            # Put it into the state where it *could* send a response...
+            receive_and_get(c, b"GET / HTTP/1.0\r\n\r\n")
+            assert c.our_state is SEND_RESPONSE
+        return c
+
+    for role in [CLIENT, SERVER]:
+        if role is CLIENT:
+            # This HTTP/1.0 request won't be detected as bad until after we go
+            # through the state machine and hit the writing code
+            good = Request(method="GET", target="/", headers=[("Host", "example.com")])
+            bad = Request(
+                method="GET",
+                target="/",
+                headers=[("Host", "example.com")],
+                http_version="1.0",
+            )
+        elif role is SERVER:
+            good = Response(status_code=200, headers=[])
+            bad = Response(status_code=200, headers=[], http_version="1.0")
+        # Make sure 'good' actually is good
+        c = conn(role)
+        c.send(good)
+        assert c.our_state is not ERROR
+        # Do that again, but this time sending 'bad' first
+        c = conn(role)
+        with pytest.raises(LocalProtocolError):
+            c.send(bad)
+        assert c.our_state is ERROR
+        assert c.their_state is not ERROR
+        # Now 'good' is not so good
+        with pytest.raises(LocalProtocolError):
+            c.send(good)
+
+        # And check send_failed() too
+        c = conn(role)
+        c.send_failed()
+        assert c.our_state is ERROR
+        assert c.their_state is not ERROR
+        # This is idempotent
+        c.send_failed()
+        assert c.our_state is ERROR
+        assert c.their_state is not ERROR
+
+
+def test_idle_receive_nothing():
+    # At one point this incorrectly raised an error
+    for role in [CLIENT, SERVER]:
+        c = Connection(role)
+        assert c.next_event() is NEED_DATA
+
+
+def test_connection_drop():
+    c = Connection(SERVER)
+    c.receive_data(b"GET /")
+    assert c.next_event() is NEED_DATA
+    c.receive_data(b"")
+    with pytest.raises(RemoteProtocolError):
+        c.next_event()
+
+
+def test_408_request_timeout():
+    # Should be able to send this spontaneously as a server without seeing
+    # anything from client
+    p = ConnectionPair()
+    p.send(SERVER, Response(status_code=408, headers=[]))
+
+
+# This used to raise IndexError
+def test_empty_request():
+    c = Connection(SERVER)
+    c.receive_data(b"\r\n")
+    with pytest.raises(RemoteProtocolError):
+        c.next_event()
+
+
+# This used to raise IndexError
+def test_empty_response():
+    c = Connection(CLIENT)
+    c.send(Request(method="GET", target="/", headers=[("Host", "a")]))
+    c.receive_data(b"\r\n")
+    with pytest.raises(RemoteProtocolError):
+        c.next_event()
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        b"\x00",
+        b"\x20",
+        b"\x16\x03\x01\x00\xa5",  # Typical start of a TLS Client Hello
+    ],
+)
+def test_early_detection_of_invalid_request(data):
+    c = Connection(SERVER)
+    # Early detection should occur before even receiving a `\r\n`
+    c.receive_data(data)
+    with pytest.raises(RemoteProtocolError):
+        c.next_event()
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        b"\x00",
+        b"\x20",
+        b"\x16\x03\x03\x00\x31",  # Typical start of a TLS Server Hello
+    ],
+)
+def test_early_detection_of_invalid_response(data):
+    c = Connection(CLIENT)
+    # Early detection should occur before even receiving a `\r\n`
+    c.receive_data(data)
+    with pytest.raises(RemoteProtocolError):
+        c.next_event()
+
+
+# This used to give different headers for HEAD and GET.
+# The correct way to handle HEAD is to put whatever headers we *would* have
+# put if it were a GET -- even though we know that for HEAD, those headers
+# will be ignored.
+def test_HEAD_framing_headers():
+    def setup(method, http_version):
+        c = Connection(SERVER)
+        c.receive_data(
+            method + b" / HTTP/" + http_version + b"\r\n" + b"Host: example.com\r\n\r\n"
+        )
+        assert type(c.next_event()) is Request
+        assert type(c.next_event()) is EndOfMessage
+        return c
+
+    for method in [b"GET", b"HEAD"]:
+        # No Content-Length, HTTP/1.1 peer, should use chunked
+        c = setup(method, b"1.1")
+        assert (
+            c.send(Response(status_code=200, headers=[])) == b"HTTP/1.1 200 \r\n"
+            b"Transfer-Encoding: chunked\r\n\r\n"
+        )
+
+        # No Content-Length, HTTP/1.0 peer, frame with connection: close
+        c = setup(method, b"1.0")
+        assert (
+            c.send(Response(status_code=200, headers=[])) == b"HTTP/1.1 200 \r\n"
+            b"Connection: close\r\n\r\n"
+        )
+
+        # Content-Length + Transfer-Encoding, TE wins
+        c = setup(method, b"1.1")
+        assert (
+            c.send(
+                Response(
+                    status_code=200,
+                    headers=[
+                        ("Content-Length", "100"),
+                        ("Transfer-Encoding", "chunked"),
+                    ],
+                )
+            )
+            == b"HTTP/1.1 200 \r\n"
+            b"Transfer-Encoding: chunked\r\n\r\n"
+        )
+
+
+def test_special_exceptions_for_lost_connection_in_message_body():
+    c = Connection(SERVER)
+    c.receive_data(
+        b"POST / HTTP/1.1\r\n" b"Host: example.com\r\n" b"Content-Length: 100\r\n\r\n"
+    )
+    assert type(c.next_event()) is Request
+    assert c.next_event() is NEED_DATA
+    c.receive_data(b"12345")
+    assert c.next_event() == Data(data=b"12345")
+    c.receive_data(b"")
+    with pytest.raises(RemoteProtocolError) as excinfo:
+        c.next_event()
+    assert "received 5 bytes" in str(excinfo.value)
+    assert "expected 100" in str(excinfo.value)
+
+    c = Connection(SERVER)
+    c.receive_data(
+        b"POST / HTTP/1.1\r\n"
+        b"Host: example.com\r\n"
+        b"Transfer-Encoding: chunked\r\n\r\n"
+    )
+    assert type(c.next_event()) is Request
+    assert c.next_event() is NEED_DATA
+    c.receive_data(b"8\r\n012345")
+    assert c.next_event().data == b"012345"
+    c.receive_data(b"")
+    with pytest.raises(RemoteProtocolError) as excinfo:
+        c.next_event()
+    assert "incomplete chunked read" in str(excinfo.value)
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/test_events.py b/myenv/lib/python3.9/site-packages/h11/tests/test_events.py
new file mode 100644
index 0000000..e20f741
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/tests/test_events.py
@@ -0,0 +1,179 @@
+from http import HTTPStatus
+
+import pytest
+
+from .. import _events
+from .._events import *
+from .._util import LocalProtocolError
+
+
+def test_event_bundle():
+    class T(_events._EventBundle):
+        _fields = ["a", "b"]
+        _defaults = {"b": 1}
+
+        def _validate(self):
+            if self.a == 0:
+                raise ValueError
+
+    # basic construction and methods
+    t = T(a=1, b=0)
+    assert repr(t) == "T(a=1, b=0)"
+    assert t == T(a=1, b=0)
+    assert not (t == T(a=2, b=0))
+    assert not (t != T(a=1, b=0))
+    assert t != T(a=2, b=0)
+    with pytest.raises(TypeError):
+        hash(t)
+
+    # check defaults
+    t = T(a=10)
+    assert t.a == 10
+    assert t.b == 1
+
+    # no positional args
+    with pytest.raises(TypeError):
+        T(1)
+
+    with pytest.raises(TypeError):
+        T(1, a=1, b=0)
+
+    # unknown field
+    with pytest.raises(TypeError):
+        T(a=1, b=0, c=10)
+
+    # missing required field
+    with pytest.raises(TypeError) as exc:
+        T(b=0)
+    # make sure we error on the right missing kwarg
+    assert "kwarg a" in str(exc.value)
+
+    # _validate is called
+    with pytest.raises(ValueError):
+        T(a=0, b=0)
+
+
+def test_events():
+    with pytest.raises(LocalProtocolError):
+        # Missing Host:
+        req = Request(
+            method="GET", target="/", headers=[("a", "b")], http_version="1.1"
+        )
+    # But this is okay (HTTP/1.0)
+    req = Request(method="GET", target="/", headers=[("a", "b")], http_version="1.0")
+    # fields are normalized
+    assert req.method == b"GET"
+    assert req.target == b"/"
+    assert req.headers == [(b"a", b"b")]
+    assert req.http_version == b"1.0"
+
+    # This is also okay -- has a Host (with weird capitalization, which is ok)
+    req = Request(
+        method="GET",
+        target="/",
+        headers=[("a", "b"), ("hOSt", "example.com")],
+        http_version="1.1",
+    )
+    # we normalize header capitalization
+    assert req.headers == [(b"a", b"b"), (b"host", b"example.com")]
+
+    # Multiple host is bad too
+    with pytest.raises(LocalProtocolError):
+        req = Request(
+            method="GET",
+            target="/",
+            headers=[("Host", "a"), ("Host", "a")],
+            http_version="1.1",
+        )
+    # Even for HTTP/1.0
+    with pytest.raises(LocalProtocolError):
+        req = Request(
+            method="GET",
+            target="/",
+            headers=[("Host", "a"), ("Host", "a")],
+            http_version="1.0",
+        )
+
+    # Header values are validated
+    for bad_char in "\x00\r\n\f\v":
+        with pytest.raises(LocalProtocolError):
+            req = Request(
+                method="GET",
+                target="/",
+                headers=[("Host", "a"), ("Foo", "asd" + bad_char)],
+                http_version="1.0",
+            )
+
+    # But for compatibility we allow non-whitespace control characters, even
+    # though they're forbidden by the spec.
+    Request(
+        method="GET",
+        target="/",
+        headers=[("Host", "a"), ("Foo", "asd\x01\x02\x7f")],
+        http_version="1.0",
+    )
+
+    # Request target is validated
+    for bad_char in b"\x00\x20\x7f\xee":
+        target = bytearray(b"/")
+        target.append(bad_char)
+        with pytest.raises(LocalProtocolError):
+            Request(
+                method="GET", target=target, headers=[("Host", "a")], http_version="1.1"
+            )
+
+    ir = InformationalResponse(status_code=100, headers=[("Host", "a")])
+    assert ir.status_code == 100
+    assert ir.headers == [(b"host", b"a")]
+    assert ir.http_version == b"1.1"
+
+    with pytest.raises(LocalProtocolError):
+        InformationalResponse(status_code=200, headers=[("Host", "a")])
+
+    resp = Response(status_code=204, headers=[], http_version="1.0")
+    assert resp.status_code == 204
+    assert resp.headers == []
+    assert resp.http_version == b"1.0"
+
+    with pytest.raises(LocalProtocolError):
+        resp = Response(status_code=100, headers=[], http_version="1.0")
+
+    with pytest.raises(LocalProtocolError):
+        Response(status_code="100", headers=[], http_version="1.0")
+
+    with pytest.raises(LocalProtocolError):
+        InformationalResponse(status_code=b"100", headers=[], http_version="1.0")
+
+    d = Data(data=b"asdf")
+    assert d.data == b"asdf"
+
+    eom = EndOfMessage()
+    assert eom.headers == []
+
+    cc = ConnectionClosed()
+    assert repr(cc) == "ConnectionClosed()"
+
+
+def test_intenum_status_code():
+    # https://github.com/python-hyper/h11/issues/72
+
+    r = Response(status_code=HTTPStatus.OK, headers=[], http_version="1.0")
+    assert r.status_code == HTTPStatus.OK
+    assert type(r.status_code) is not type(HTTPStatus.OK)
+    assert type(r.status_code) is int
+
+
+def test_header_casing():
+    r = Request(
+        method="GET",
+        target="/",
+        headers=[("Host", "example.org"), ("Connection", "keep-alive")],
+        http_version="1.1",
+    )
+    assert len(r.headers) == 2
+    assert r.headers[0] == (b"host", b"example.org")
+    assert r.headers == [(b"host", b"example.org"), (b"connection", b"keep-alive")]
+    assert r.headers.raw_items() == [
+        (b"Host", b"example.org"),
+        (b"Connection", b"keep-alive"),
+    ]
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/test_headers.py b/myenv/lib/python3.9/site-packages/h11/tests/test_headers.py
new file mode 100644
index 0000000..ff3dc8d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/tests/test_headers.py
@@ -0,0 +1,151 @@
+import pytest
+
+from .._headers import *
+
+
+def test_normalize_and_validate():
+    assert normalize_and_validate([("foo", "bar")]) == [(b"foo", b"bar")]
+    assert normalize_and_validate([(b"foo", b"bar")]) == [(b"foo", b"bar")]
+
+    # no leading/trailing whitespace in names
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([(b"foo ", "bar")])
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([(b" foo", "bar")])
+
+    # no weird characters in names
+    with pytest.raises(LocalProtocolError) as excinfo:
+        normalize_and_validate([(b"foo bar", b"baz")])
+    assert "foo bar" in str(excinfo.value)
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([(b"foo\x00bar", b"baz")])
+    # Not even 8-bit characters:
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([(b"foo\xffbar", b"baz")])
+    # And not even the control characters we allow in values:
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([(b"foo\x01bar", b"baz")])
+
+    # no return or NUL characters in values
+    with pytest.raises(LocalProtocolError) as excinfo:
+        normalize_and_validate([("foo", "bar\rbaz")])
+    assert "bar\\rbaz" in str(excinfo.value)
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([("foo", "bar\nbaz")])
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([("foo", "bar\x00baz")])
+    # no leading/trailing whitespace
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([("foo", "barbaz  ")])
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([("foo", "  barbaz")])
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([("foo", "barbaz\t")])
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([("foo", "\tbarbaz")])
+
+    # content-length
+    assert normalize_and_validate([("Content-Length", "1")]) == [
+        (b"content-length", b"1")
+    ]
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([("Content-Length", "asdf")])
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([("Content-Length", "1x")])
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([("Content-Length", "1"), ("Content-Length", "2")])
+    assert normalize_and_validate(
+        [("Content-Length", "0"), ("Content-Length", "0")]
+    ) == [(b"content-length", b"0")]
+    assert normalize_and_validate([("Content-Length", "0 , 0")]) == [
+        (b"content-length", b"0")
+    ]
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate(
+            [("Content-Length", "1"), ("Content-Length", "1"), ("Content-Length", "2")]
+        )
+    with pytest.raises(LocalProtocolError):
+        normalize_and_validate([("Content-Length", "1 , 1,2")])
+
+    # transfer-encoding
+    assert normalize_and_validate([("Transfer-Encoding", "chunked")]) == [
+        (b"transfer-encoding", b"chunked")
+    ]
+    assert normalize_and_validate([("Transfer-Encoding", "cHuNkEd")]) == [
+        (b"transfer-encoding", b"chunked")
+    ]
+    with pytest.raises(LocalProtocolError) as excinfo:
+        normalize_and_validate([("Transfer-Encoding", "gzip")])
+    assert excinfo.value.error_status_hint == 501  # Not Implemented
+    with pytest.raises(LocalProtocolError) as excinfo:
+        normalize_and_validate(
+            [("Transfer-Encoding", "chunked"), ("Transfer-Encoding", "gzip")]
+        )
+    assert excinfo.value.error_status_hint == 501  # Not Implemented
+
+
+def test_get_set_comma_header():
+    headers = normalize_and_validate(
+        [
+            ("Connection", "close"),
+            ("whatever", "something"),
+            ("connectiON", "fOo,, , BAR"),
+        ]
+    )
+
+    assert get_comma_header(headers, b"connection") == [b"close", b"foo", b"bar"]
+
+    headers = set_comma_header(headers, b"newthing", ["a", "b"])
+
+    with pytest.raises(LocalProtocolError):
+        set_comma_header(headers, b"newthing", ["  a", "b"])
+
+    assert headers == [
+        (b"connection", b"close"),
+        (b"whatever", b"something"),
+        (b"connection", b"fOo,, , BAR"),
+        (b"newthing", b"a"),
+        (b"newthing", b"b"),
+    ]
+
+    headers = set_comma_header(headers, b"whatever", ["different thing"])
+
+    assert headers == [
+        (b"connection", b"close"),
+        (b"connection", b"fOo,, , BAR"),
+        (b"newthing", b"a"),
+        (b"newthing", b"b"),
+        (b"whatever", b"different thing"),
+    ]
+
+
+def test_has_100_continue():
+    from .._events import Request
+
+    assert has_expect_100_continue(
+        Request(
+            method="GET",
+            target="/",
+            headers=[("Host", "example.com"), ("Expect", "100-continue")],
+        )
+    )
+    assert not has_expect_100_continue(
+        Request(method="GET", target="/", headers=[("Host", "example.com")])
+    )
+    # Case insensitive
+    assert has_expect_100_continue(
+        Request(
+            method="GET",
+            target="/",
+            headers=[("Host", "example.com"), ("Expect", "100-Continue")],
+        )
+    )
+    # Doesn't work in HTTP/1.0
+    assert not has_expect_100_continue(
+        Request(
+            method="GET",
+            target="/",
+            headers=[("Host", "example.com"), ("Expect", "100-continue")],
+            http_version="1.0",
+        )
+    )
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/test_helpers.py b/myenv/lib/python3.9/site-packages/h11/tests/test_helpers.py
new file mode 100644
index 0000000..1477947
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/tests/test_helpers.py
@@ -0,0 +1,23 @@
+from .helpers import *
+
+
+def test_normalize_data_events():
+    assert normalize_data_events(
+        [
+            Data(data=bytearray(b"1")),
+            Data(data=b"2"),
+            Response(status_code=200, headers=[]),
+            Data(data=b"3"),
+            Data(data=b"4"),
+            EndOfMessage(),
+            Data(data=b"5"),
+            Data(data=b"6"),
+            Data(data=b"7"),
+        ]
+    ) == [
+        Data(data=b"12"),
+        Response(status_code=200, headers=[]),
+        Data(data=b"34"),
+        EndOfMessage(),
+        Data(data=b"567"),
+    ]
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/test_io.py b/myenv/lib/python3.9/site-packages/h11/tests/test_io.py
new file mode 100644
index 0000000..459a627
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/tests/test_io.py
@@ -0,0 +1,544 @@
+import pytest
+
+from .._events import *
+from .._headers import Headers, normalize_and_validate
+from .._readers import (
+    _obsolete_line_fold,
+    ChunkedReader,
+    ContentLengthReader,
+    Http10Reader,
+    READERS,
+)
+from .._receivebuffer import ReceiveBuffer
+from .._state import *
+from .._util import LocalProtocolError
+from .._writers import (
+    ChunkedWriter,
+    ContentLengthWriter,
+    Http10Writer,
+    write_any_response,
+    write_headers,
+    write_request,
+    WRITERS,
+)
+from .helpers import normalize_data_events
+
+SIMPLE_CASES = [
+    (
+        (CLIENT, IDLE),
+        Request(
+            method="GET",
+            target="/a",
+            headers=[("Host", "foo"), ("Connection", "close")],
+        ),
+        b"GET /a HTTP/1.1\r\nHost: foo\r\nConnection: close\r\n\r\n",
+    ),
+    (
+        (SERVER, SEND_RESPONSE),
+        Response(status_code=200, headers=[("Connection", "close")], reason=b"OK"),
+        b"HTTP/1.1 200 OK\r\nConnection: close\r\n\r\n",
+    ),
+    (
+        (SERVER, SEND_RESPONSE),
+        Response(status_code=200, headers=[], reason=b"OK"),
+        b"HTTP/1.1 200 OK\r\n\r\n",
+    ),
+    (
+        (SERVER, SEND_RESPONSE),
+        InformationalResponse(
+            status_code=101, headers=[("Upgrade", "websocket")], reason=b"Upgrade"
+        ),
+        b"HTTP/1.1 101 Upgrade\r\nUpgrade: websocket\r\n\r\n",
+    ),
+    (
+        (SERVER, SEND_RESPONSE),
+        InformationalResponse(status_code=101, headers=[], reason=b"Upgrade"),
+        b"HTTP/1.1 101 Upgrade\r\n\r\n",
+    ),
+]
+
+
+def dowrite(writer, obj):
+    got_list = []
+    writer(obj, got_list.append)
+    return b"".join(got_list)
+
+
+def tw(writer, obj, expected):
+    got = dowrite(writer, obj)
+    assert got == expected
+
+
+def makebuf(data):
+    buf = ReceiveBuffer()
+    buf += data
+    return buf
+
+
+def tr(reader, data, expected):
+    def check(got):
+        assert got == expected
+        # Headers should always be returned as bytes, not e.g. bytearray
+        # https://github.com/python-hyper/wsproto/pull/54#issuecomment-377709478
+        for name, value in getattr(got, "headers", []):
+            print(name, value)
+            assert type(name) is bytes
+            assert type(value) is bytes
+
+    # Simple: consume whole thing
+    buf = makebuf(data)
+    check(reader(buf))
+    assert not buf
+
+    # Incrementally growing buffer
+    buf = ReceiveBuffer()
+    for i in range(len(data)):
+        assert reader(buf) is None
+        buf += data[i : i + 1]
+    check(reader(buf))
+
+    # Trailing data
+    buf = makebuf(data)
+    buf += b"trailing"
+    check(reader(buf))
+    assert bytes(buf) == b"trailing"
+
+
+def test_writers_simple():
+    for ((role, state), event, binary) in SIMPLE_CASES:
+        tw(WRITERS[role, state], event, binary)
+
+
+def test_readers_simple():
+    for ((role, state), event, binary) in SIMPLE_CASES:
+        tr(READERS[role, state], binary, event)
+
+
+def test_writers_unusual():
+    # Simple test of the write_headers utility routine
+    tw(
+        write_headers,
+        normalize_and_validate([("foo", "bar"), ("baz", "quux")]),
+        b"foo: bar\r\nbaz: quux\r\n\r\n",
+    )
+    tw(write_headers, Headers([]), b"\r\n")
+
+    # We understand HTTP/1.0, but we don't speak it
+    with pytest.raises(LocalProtocolError):
+        tw(
+            write_request,
+            Request(
+                method="GET",
+                target="/",
+                headers=[("Host", "foo"), ("Connection", "close")],
+                http_version="1.0",
+            ),
+            None,
+        )
+    with pytest.raises(LocalProtocolError):
+        tw(
+            write_any_response,
+            Response(
+                status_code=200, headers=[("Connection", "close")], http_version="1.0"
+            ),
+            None,
+        )
+
+
+def test_readers_unusual():
+    # Reading HTTP/1.0
+    tr(
+        READERS[CLIENT, IDLE],
+        b"HEAD /foo HTTP/1.0\r\nSome: header\r\n\r\n",
+        Request(
+            method="HEAD",
+            target="/foo",
+            headers=[("Some", "header")],
+            http_version="1.0",
+        ),
+    )
+
+    # check no-headers, since it's only legal with HTTP/1.0
+    tr(
+        READERS[CLIENT, IDLE],
+        b"HEAD /foo HTTP/1.0\r\n\r\n",
+        Request(method="HEAD", target="/foo", headers=[], http_version="1.0"),
+    )
+
+    tr(
+        READERS[SERVER, SEND_RESPONSE],
+        b"HTTP/1.0 200 OK\r\nSome: header\r\n\r\n",
+        Response(
+            status_code=200,
+            headers=[("Some", "header")],
+            http_version="1.0",
+            reason=b"OK",
+        ),
+    )
+
+    # single-character header values (actually disallowed by the ABNF in RFC
+    # 7230 -- this is a bug in the standard that we originally copied...)
+    tr(
+        READERS[SERVER, SEND_RESPONSE],
+        b"HTTP/1.0 200 OK\r\n" b"Foo: a a a a a \r\n\r\n",
+        Response(
+            status_code=200,
+            headers=[("Foo", "a a a a a")],
+            http_version="1.0",
+            reason=b"OK",
+        ),
+    )
+
+    # Empty headers -- also legal
+    tr(
+        READERS[SERVER, SEND_RESPONSE],
+        b"HTTP/1.0 200 OK\r\n" b"Foo:\r\n\r\n",
+        Response(
+            status_code=200, headers=[("Foo", "")], http_version="1.0", reason=b"OK"
+        ),
+    )
+
+    tr(
+        READERS[SERVER, SEND_RESPONSE],
+        b"HTTP/1.0 200 OK\r\n" b"Foo: \t \t \r\n\r\n",
+        Response(
+            status_code=200, headers=[("Foo", "")], http_version="1.0", reason=b"OK"
+        ),
+    )
+
+    # Tolerate broken servers that leave off the response code
+    tr(
+        READERS[SERVER, SEND_RESPONSE],
+        b"HTTP/1.0 200\r\n" b"Foo: bar\r\n\r\n",
+        Response(
+            status_code=200, headers=[("Foo", "bar")], http_version="1.0", reason=b""
+        ),
+    )
+
+    # Tolerate headers line endings (\r\n and \n)
+    #    \n\r\b between headers and body
+    tr(
+        READERS[SERVER, SEND_RESPONSE],
+        b"HTTP/1.1 200 OK\r\nSomeHeader: val\n\r\n",
+        Response(
+            status_code=200,
+            headers=[("SomeHeader", "val")],
+            http_version="1.1",
+            reason="OK",
+        ),
+    )
+
+    #   delimited only with \n
+    tr(
+        READERS[SERVER, SEND_RESPONSE],
+        b"HTTP/1.1 200 OK\nSomeHeader1: val1\nSomeHeader2: val2\n\n",
+        Response(
+            status_code=200,
+            headers=[("SomeHeader1", "val1"), ("SomeHeader2", "val2")],
+            http_version="1.1",
+            reason="OK",
+        ),
+    )
+
+    #   mixed \r\n and \n
+    tr(
+        READERS[SERVER, SEND_RESPONSE],
+        b"HTTP/1.1 200 OK\r\nSomeHeader1: val1\nSomeHeader2: val2\n\r\n",
+        Response(
+            status_code=200,
+            headers=[("SomeHeader1", "val1"), ("SomeHeader2", "val2")],
+            http_version="1.1",
+            reason="OK",
+        ),
+    )
+
+    # obsolete line folding
+    tr(
+        READERS[CLIENT, IDLE],
+        b"HEAD /foo HTTP/1.1\r\n"
+        b"Host: example.com\r\n"
+        b"Some: multi-line\r\n"
+        b" header\r\n"
+        b"\tnonsense\r\n"
+        b"    \t   \t\tI guess\r\n"
+        b"Connection: close\r\n"
+        b"More-nonsense: in the\r\n"
+        b"    last header  \r\n\r\n",
+        Request(
+            method="HEAD",
+            target="/foo",
+            headers=[
+                ("Host", "example.com"),
+                ("Some", "multi-line header nonsense I guess"),
+                ("Connection", "close"),
+                ("More-nonsense", "in the last header"),
+            ],
+        ),
+    )
+
+    with pytest.raises(LocalProtocolError):
+        tr(
+            READERS[CLIENT, IDLE],
+            b"HEAD /foo HTTP/1.1\r\n" b"  folded: line\r\n\r\n",
+            None,
+        )
+
+    with pytest.raises(LocalProtocolError):
+        tr(
+            READERS[CLIENT, IDLE],
+            b"HEAD /foo HTTP/1.1\r\n" b"foo  : line\r\n\r\n",
+            None,
+        )
+    with pytest.raises(LocalProtocolError):
+        tr(
+            READERS[CLIENT, IDLE],
+            b"HEAD /foo HTTP/1.1\r\n" b"foo\t: line\r\n\r\n",
+            None,
+        )
+    with pytest.raises(LocalProtocolError):
+        tr(
+            READERS[CLIENT, IDLE],
+            b"HEAD /foo HTTP/1.1\r\n" b"foo\t: line\r\n\r\n",
+            None,
+        )
+    with pytest.raises(LocalProtocolError):
+        tr(READERS[CLIENT, IDLE], b"HEAD /foo HTTP/1.1\r\n" b": line\r\n\r\n", None)
+
+
+def test__obsolete_line_fold_bytes():
+    # _obsolete_line_fold has a defensive cast to bytearray, which is
+    # necessary to protect against O(n^2) behavior in case anyone ever passes
+    # in regular bytestrings... but right now we never pass in regular
+    # bytestrings. so this test just exists to get some coverage on that
+    # defensive cast.
+    assert list(_obsolete_line_fold([b"aaa", b"bbb", b"  ccc", b"ddd"])) == [
+        b"aaa",
+        bytearray(b"bbb ccc"),
+        b"ddd",
+    ]
+
+
+def _run_reader_iter(reader, buf, do_eof):
+    while True:
+        event = reader(buf)
+        if event is None:
+            break
+        yield event
+        # body readers have undefined behavior after returning EndOfMessage,
+        # because this changes the state so they don't get called again
+        if type(event) is EndOfMessage:
+            break
+    if do_eof:
+        assert not buf
+        yield reader.read_eof()
+
+
+def _run_reader(*args):
+    events = list(_run_reader_iter(*args))
+    return normalize_data_events(events)
+
+
+def t_body_reader(thunk, data, expected, do_eof=False):
+    # Simple: consume whole thing
+    print("Test 1")
+    buf = makebuf(data)
+    assert _run_reader(thunk(), buf, do_eof) == expected
+
+    # Incrementally growing buffer
+    print("Test 2")
+    reader = thunk()
+    buf = ReceiveBuffer()
+    events = []
+    for i in range(len(data)):
+        events += _run_reader(reader, buf, False)
+        buf += data[i : i + 1]
+    events += _run_reader(reader, buf, do_eof)
+    assert normalize_data_events(events) == expected
+
+    is_complete = any(type(event) is EndOfMessage for event in expected)
+    if is_complete and not do_eof:
+        buf = makebuf(data + b"trailing")
+        assert _run_reader(thunk(), buf, False) == expected
+
+
+def test_ContentLengthReader():
+    t_body_reader(lambda: ContentLengthReader(0), b"", [EndOfMessage()])
+
+    t_body_reader(
+        lambda: ContentLengthReader(10),
+        b"0123456789",
+        [Data(data=b"0123456789"), EndOfMessage()],
+    )
+
+
+def test_Http10Reader():
+    t_body_reader(Http10Reader, b"", [EndOfMessage()], do_eof=True)
+    t_body_reader(Http10Reader, b"asdf", [Data(data=b"asdf")], do_eof=False)
+    t_body_reader(
+        Http10Reader, b"asdf", [Data(data=b"asdf"), EndOfMessage()], do_eof=True
+    )
+
+
+def test_ChunkedReader():
+    t_body_reader(ChunkedReader, b"0\r\n\r\n", [EndOfMessage()])
+
+    t_body_reader(
+        ChunkedReader,
+        b"0\r\nSome: header\r\n\r\n",
+        [EndOfMessage(headers=[("Some", "header")])],
+    )
+
+    t_body_reader(
+        ChunkedReader,
+        b"5\r\n01234\r\n"
+        + b"10\r\n0123456789abcdef\r\n"
+        + b"0\r\n"
+        + b"Some: header\r\n\r\n",
+        [
+            Data(data=b"012340123456789abcdef"),
+            EndOfMessage(headers=[("Some", "header")]),
+        ],
+    )
+
+    t_body_reader(
+        ChunkedReader,
+        b"5\r\n01234\r\n" + b"10\r\n0123456789abcdef\r\n" + b"0\r\n\r\n",
+        [Data(data=b"012340123456789abcdef"), EndOfMessage()],
+    )
+
+    # handles upper and lowercase hex
+    t_body_reader(
+        ChunkedReader,
+        b"aA\r\n" + b"x" * 0xAA + b"\r\n" + b"0\r\n\r\n",
+        [Data(data=b"x" * 0xAA), EndOfMessage()],
+    )
+
+    # refuses arbitrarily long chunk integers
+    with pytest.raises(LocalProtocolError):
+        # Technically this is legal HTTP/1.1, but we refuse to process chunk
+        # sizes that don't fit into 20 characters of hex
+        t_body_reader(ChunkedReader, b"9" * 100 + b"\r\nxxx", [Data(data=b"xxx")])
+
+    # refuses garbage in the chunk count
+    with pytest.raises(LocalProtocolError):
+        t_body_reader(ChunkedReader, b"10\x00\r\nxxx", None)
+
+    # handles (and discards) "chunk extensions" omg wtf
+    t_body_reader(
+        ChunkedReader,
+        b"5; hello=there\r\n"
+        + b"xxxxx"
+        + b"\r\n"
+        + b'0; random="junk"; some=more; canbe=lonnnnngg\r\n\r\n',
+        [Data(data=b"xxxxx"), EndOfMessage()],
+    )
+
+
+def test_ContentLengthWriter():
+    w = ContentLengthWriter(5)
+    assert dowrite(w, Data(data=b"123")) == b"123"
+    assert dowrite(w, Data(data=b"45")) == b"45"
+    assert dowrite(w, EndOfMessage()) == b""
+
+    w = ContentLengthWriter(5)
+    with pytest.raises(LocalProtocolError):
+        dowrite(w, Data(data=b"123456"))
+
+    w = ContentLengthWriter(5)
+    dowrite(w, Data(data=b"123"))
+    with pytest.raises(LocalProtocolError):
+        dowrite(w, Data(data=b"456"))
+
+    w = ContentLengthWriter(5)
+    dowrite(w, Data(data=b"123"))
+    with pytest.raises(LocalProtocolError):
+        dowrite(w, EndOfMessage())
+
+    w = ContentLengthWriter(5)
+    dowrite(w, Data(data=b"123")) == b"123"
+    dowrite(w, Data(data=b"45")) == b"45"
+    with pytest.raises(LocalProtocolError):
+        dowrite(w, EndOfMessage(headers=[("Etag", "asdf")]))
+
+
+def test_ChunkedWriter():
+    w = ChunkedWriter()
+    assert dowrite(w, Data(data=b"aaa")) == b"3\r\naaa\r\n"
+    assert dowrite(w, Data(data=b"a" * 20)) == b"14\r\n" + b"a" * 20 + b"\r\n"
+
+    assert dowrite(w, Data(data=b"")) == b""
+
+    assert dowrite(w, EndOfMessage()) == b"0\r\n\r\n"
+
+    assert (
+        dowrite(w, EndOfMessage(headers=[("Etag", "asdf"), ("a", "b")]))
+        == b"0\r\nEtag: asdf\r\na: b\r\n\r\n"
+    )
+
+
+def test_Http10Writer():
+    w = Http10Writer()
+    assert dowrite(w, Data(data=b"1234")) == b"1234"
+    assert dowrite(w, EndOfMessage()) == b""
+
+    with pytest.raises(LocalProtocolError):
+        dowrite(w, EndOfMessage(headers=[("Etag", "asdf")]))
+
+
+def test_reject_garbage_after_request_line():
+    with pytest.raises(LocalProtocolError):
+        tr(READERS[SERVER, SEND_RESPONSE], b"HTTP/1.0 200 OK\x00xxxx\r\n\r\n", None)
+
+
+def test_reject_garbage_after_response_line():
+    with pytest.raises(LocalProtocolError):
+        tr(
+            READERS[CLIENT, IDLE],
+            b"HEAD /foo HTTP/1.1 xxxxxx\r\n" b"Host: a\r\n\r\n",
+            None,
+        )
+
+
+def test_reject_garbage_in_header_line():
+    with pytest.raises(LocalProtocolError):
+        tr(
+            READERS[CLIENT, IDLE],
+            b"HEAD /foo HTTP/1.1\r\n" b"Host: foo\x00bar\r\n\r\n",
+            None,
+        )
+
+
+def test_reject_non_vchar_in_path():
+    for bad_char in b"\x00\x20\x7f\xee":
+        message = bytearray(b"HEAD /")
+        message.append(bad_char)
+        message.extend(b" HTTP/1.1\r\nHost: foobar\r\n\r\n")
+        with pytest.raises(LocalProtocolError):
+            tr(READERS[CLIENT, IDLE], message, None)
+
+
+# https://github.com/python-hyper/h11/issues/57
+def test_allow_some_garbage_in_cookies():
+    tr(
+        READERS[CLIENT, IDLE],
+        b"HEAD /foo HTTP/1.1\r\n"
+        b"Host: foo\r\n"
+        b"Set-Cookie: ___utmvafIumyLc=kUd\x01UpAt; path=/; Max-Age=900\r\n"
+        b"\r\n",
+        Request(
+            method="HEAD",
+            target="/foo",
+            headers=[
+                ("Host", "foo"),
+                ("Set-Cookie", "___utmvafIumyLc=kUd\x01UpAt; path=/; Max-Age=900"),
+            ],
+        ),
+    )
+
+
+def test_host_comes_first():
+    tw(
+        write_headers,
+        normalize_and_validate([("foo", "bar"), ("Host", "example.com")]),
+        b"Host: example.com\r\nfoo: bar\r\n\r\n",
+    )
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/test_receivebuffer.py b/myenv/lib/python3.9/site-packages/h11/tests/test_receivebuffer.py
new file mode 100644
index 0000000..3a61f9d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/tests/test_receivebuffer.py
@@ -0,0 +1,134 @@
+import re
+
+import pytest
+
+from .._receivebuffer import ReceiveBuffer
+
+
+def test_receivebuffer():
+    b = ReceiveBuffer()
+    assert not b
+    assert len(b) == 0
+    assert bytes(b) == b""
+
+    b += b"123"
+    assert b
+    assert len(b) == 3
+    assert bytes(b) == b"123"
+
+    assert bytes(b) == b"123"
+
+    assert b.maybe_extract_at_most(2) == b"12"
+    assert b
+    assert len(b) == 1
+    assert bytes(b) == b"3"
+
+    assert bytes(b) == b"3"
+
+    assert b.maybe_extract_at_most(10) == b"3"
+    assert bytes(b) == b""
+
+    assert b.maybe_extract_at_most(10) is None
+    assert not b
+
+    ################################################################
+    # maybe_extract_until_next
+    ################################################################
+
+    b += b"123\n456\r\n789\r\n"
+
+    assert b.maybe_extract_next_line() == b"123\n456\r\n"
+    assert bytes(b) == b"789\r\n"
+
+    assert b.maybe_extract_next_line() == b"789\r\n"
+    assert bytes(b) == b""
+
+    b += b"12\r"
+    assert b.maybe_extract_next_line() is None
+    assert bytes(b) == b"12\r"
+
+    b += b"345\n\r"
+    assert b.maybe_extract_next_line() is None
+    assert bytes(b) == b"12\r345\n\r"
+
+    # here we stopped at the middle of b"\r\n" delimiter
+
+    b += b"\n6789aaa123\r\n"
+    assert b.maybe_extract_next_line() == b"12\r345\n\r\n"
+    assert b.maybe_extract_next_line() == b"6789aaa123\r\n"
+    assert b.maybe_extract_next_line() is None
+    assert bytes(b) == b""
+
+    ################################################################
+    # maybe_extract_lines
+    ################################################################
+
+    b += b"123\r\na: b\r\nfoo:bar\r\n\r\ntrailing"
+    lines = b.maybe_extract_lines()
+    assert lines == [b"123", b"a: b", b"foo:bar"]
+    assert bytes(b) == b"trailing"
+
+    assert b.maybe_extract_lines() is None
+
+    b += b"\r\n\r"
+    assert b.maybe_extract_lines() is None
+
+    assert b.maybe_extract_at_most(100) == b"trailing\r\n\r"
+    assert not b
+
+    # Empty body case (as happens at the end of chunked encoding if there are
+    # no trailing headers, e.g.)
+    b += b"\r\ntrailing"
+    assert b.maybe_extract_lines() == []
+    assert bytes(b) == b"trailing"
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        pytest.param(
+            (
+                b"HTTP/1.1 200 OK\r\n",
+                b"Content-type: text/plain\r\n",
+                b"Connection: close\r\n",
+                b"\r\n",
+                b"Some body",
+            ),
+            id="with_crlf_delimiter",
+        ),
+        pytest.param(
+            (
+                b"HTTP/1.1 200 OK\n",
+                b"Content-type: text/plain\n",
+                b"Connection: close\n",
+                b"\n",
+                b"Some body",
+            ),
+            id="with_lf_only_delimiter",
+        ),
+        pytest.param(
+            (
+                b"HTTP/1.1 200 OK\n",
+                b"Content-type: text/plain\r\n",
+                b"Connection: close\n",
+                b"\n",
+                b"Some body",
+            ),
+            id="with_mixed_crlf_and_lf",
+        ),
+    ],
+)
+def test_receivebuffer_for_invalid_delimiter(data):
+    b = ReceiveBuffer()
+
+    for line in data:
+        b += line
+
+    lines = b.maybe_extract_lines()
+
+    assert lines == [
+        b"HTTP/1.1 200 OK",
+        b"Content-type: text/plain",
+        b"Connection: close",
+    ]
+    assert bytes(b) == b"Some body"
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/test_state.py b/myenv/lib/python3.9/site-packages/h11/tests/test_state.py
new file mode 100644
index 0000000..efe83f0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/tests/test_state.py
@@ -0,0 +1,250 @@
+import pytest
+
+from .._events import *
+from .._state import *
+from .._state import _SWITCH_CONNECT, _SWITCH_UPGRADE, ConnectionState
+from .._util import LocalProtocolError
+
+
+def test_ConnectionState():
+    cs = ConnectionState()
+
+    # Basic event-triggered transitions
+
+    assert cs.states == {CLIENT: IDLE, SERVER: IDLE}
+
+    cs.process_event(CLIENT, Request)
+    # The SERVER-Request special case:
+    assert cs.states == {CLIENT: SEND_BODY, SERVER: SEND_RESPONSE}
+
+    # Illegal transitions raise an error and nothing happens
+    with pytest.raises(LocalProtocolError):
+        cs.process_event(CLIENT, Request)
+    assert cs.states == {CLIENT: SEND_BODY, SERVER: SEND_RESPONSE}
+
+    cs.process_event(SERVER, InformationalResponse)
+    assert cs.states == {CLIENT: SEND_BODY, SERVER: SEND_RESPONSE}
+
+    cs.process_event(SERVER, Response)
+    assert cs.states == {CLIENT: SEND_BODY, SERVER: SEND_BODY}
+
+    cs.process_event(CLIENT, EndOfMessage)
+    cs.process_event(SERVER, EndOfMessage)
+    assert cs.states == {CLIENT: DONE, SERVER: DONE}
+
+    # State-triggered transition
+
+    cs.process_event(SERVER, ConnectionClosed)
+    assert cs.states == {CLIENT: MUST_CLOSE, SERVER: CLOSED}
+
+
+def test_ConnectionState_keep_alive():
+    # keep_alive = False
+    cs = ConnectionState()
+    cs.process_event(CLIENT, Request)
+    cs.process_keep_alive_disabled()
+    cs.process_event(CLIENT, EndOfMessage)
+    assert cs.states == {CLIENT: MUST_CLOSE, SERVER: SEND_RESPONSE}
+
+    cs.process_event(SERVER, Response)
+    cs.process_event(SERVER, EndOfMessage)
+    assert cs.states == {CLIENT: MUST_CLOSE, SERVER: MUST_CLOSE}
+
+
+def test_ConnectionState_keep_alive_in_DONE():
+    # Check that if keep_alive is disabled when the CLIENT is already in DONE,
+    # then this is sufficient to immediately trigger the DONE -> MUST_CLOSE
+    # transition
+    cs = ConnectionState()
+    cs.process_event(CLIENT, Request)
+    cs.process_event(CLIENT, EndOfMessage)
+    assert cs.states[CLIENT] is DONE
+    cs.process_keep_alive_disabled()
+    assert cs.states[CLIENT] is MUST_CLOSE
+
+
+def test_ConnectionState_switch_denied():
+    for switch_type in (_SWITCH_CONNECT, _SWITCH_UPGRADE):
+        for deny_early in (True, False):
+            cs = ConnectionState()
+            cs.process_client_switch_proposal(switch_type)
+            cs.process_event(CLIENT, Request)
+            cs.process_event(CLIENT, Data)
+            assert cs.states == {CLIENT: SEND_BODY, SERVER: SEND_RESPONSE}
+
+            assert switch_type in cs.pending_switch_proposals
+
+            if deny_early:
+                # before client reaches DONE
+                cs.process_event(SERVER, Response)
+                assert not cs.pending_switch_proposals
+
+            cs.process_event(CLIENT, EndOfMessage)
+
+            if deny_early:
+                assert cs.states == {CLIENT: DONE, SERVER: SEND_BODY}
+            else:
+                assert cs.states == {
+                    CLIENT: MIGHT_SWITCH_PROTOCOL,
+                    SERVER: SEND_RESPONSE,
+                }
+
+                cs.process_event(SERVER, InformationalResponse)
+                assert cs.states == {
+                    CLIENT: MIGHT_SWITCH_PROTOCOL,
+                    SERVER: SEND_RESPONSE,
+                }
+
+                cs.process_event(SERVER, Response)
+                assert cs.states == {CLIENT: DONE, SERVER: SEND_BODY}
+                assert not cs.pending_switch_proposals
+
+
+_response_type_for_switch = {
+    _SWITCH_UPGRADE: InformationalResponse,
+    _SWITCH_CONNECT: Response,
+    None: Response,
+}
+
+
+def test_ConnectionState_protocol_switch_accepted():
+    for switch_event in [_SWITCH_UPGRADE, _SWITCH_CONNECT]:
+        cs = ConnectionState()
+        cs.process_client_switch_proposal(switch_event)
+        cs.process_event(CLIENT, Request)
+        cs.process_event(CLIENT, Data)
+        assert cs.states == {CLIENT: SEND_BODY, SERVER: SEND_RESPONSE}
+
+        cs.process_event(CLIENT, EndOfMessage)
+        assert cs.states == {CLIENT: MIGHT_SWITCH_PROTOCOL, SERVER: SEND_RESPONSE}
+
+        cs.process_event(SERVER, InformationalResponse)
+        assert cs.states == {CLIENT: MIGHT_SWITCH_PROTOCOL, SERVER: SEND_RESPONSE}
+
+        cs.process_event(SERVER, _response_type_for_switch[switch_event], switch_event)
+        assert cs.states == {CLIENT: SWITCHED_PROTOCOL, SERVER: SWITCHED_PROTOCOL}
+
+
+def test_ConnectionState_double_protocol_switch():
+    # CONNECT + Upgrade is legal! Very silly, but legal. So we support
+    # it. Because sometimes doing the silly thing is easier than not.
+    for server_switch in [None, _SWITCH_UPGRADE, _SWITCH_CONNECT]:
+        cs = ConnectionState()
+        cs.process_client_switch_proposal(_SWITCH_UPGRADE)
+        cs.process_client_switch_proposal(_SWITCH_CONNECT)
+        cs.process_event(CLIENT, Request)
+        cs.process_event(CLIENT, EndOfMessage)
+        assert cs.states == {CLIENT: MIGHT_SWITCH_PROTOCOL, SERVER: SEND_RESPONSE}
+        cs.process_event(
+            SERVER, _response_type_for_switch[server_switch], server_switch
+        )
+        if server_switch is None:
+            assert cs.states == {CLIENT: DONE, SERVER: SEND_BODY}
+        else:
+            assert cs.states == {CLIENT: SWITCHED_PROTOCOL, SERVER: SWITCHED_PROTOCOL}
+
+
+def test_ConnectionState_inconsistent_protocol_switch():
+    for client_switches, server_switch in [
+        ([], _SWITCH_CONNECT),
+        ([], _SWITCH_UPGRADE),
+        ([_SWITCH_UPGRADE], _SWITCH_CONNECT),
+        ([_SWITCH_CONNECT], _SWITCH_UPGRADE),
+    ]:
+        cs = ConnectionState()
+        for client_switch in client_switches:
+            cs.process_client_switch_proposal(client_switch)
+        cs.process_event(CLIENT, Request)
+        with pytest.raises(LocalProtocolError):
+            cs.process_event(SERVER, Response, server_switch)
+
+
+def test_ConnectionState_keepalive_protocol_switch_interaction():
+    # keep_alive=False + pending_switch_proposals
+    cs = ConnectionState()
+    cs.process_client_switch_proposal(_SWITCH_UPGRADE)
+    cs.process_event(CLIENT, Request)
+    cs.process_keep_alive_disabled()
+    cs.process_event(CLIENT, Data)
+    assert cs.states == {CLIENT: SEND_BODY, SERVER: SEND_RESPONSE}
+
+    # the protocol switch "wins"
+    cs.process_event(CLIENT, EndOfMessage)
+    assert cs.states == {CLIENT: MIGHT_SWITCH_PROTOCOL, SERVER: SEND_RESPONSE}
+
+    # but when the server denies the request, keep_alive comes back into play
+    cs.process_event(SERVER, Response)
+    assert cs.states == {CLIENT: MUST_CLOSE, SERVER: SEND_BODY}
+
+
+def test_ConnectionState_reuse():
+    cs = ConnectionState()
+
+    with pytest.raises(LocalProtocolError):
+        cs.start_next_cycle()
+
+    cs.process_event(CLIENT, Request)
+    cs.process_event(CLIENT, EndOfMessage)
+
+    with pytest.raises(LocalProtocolError):
+        cs.start_next_cycle()
+
+    cs.process_event(SERVER, Response)
+    cs.process_event(SERVER, EndOfMessage)
+
+    cs.start_next_cycle()
+    assert cs.states == {CLIENT: IDLE, SERVER: IDLE}
+
+    # No keepalive
+
+    cs.process_event(CLIENT, Request)
+    cs.process_keep_alive_disabled()
+    cs.process_event(CLIENT, EndOfMessage)
+    cs.process_event(SERVER, Response)
+    cs.process_event(SERVER, EndOfMessage)
+
+    with pytest.raises(LocalProtocolError):
+        cs.start_next_cycle()
+
+    # One side closed
+
+    cs = ConnectionState()
+    cs.process_event(CLIENT, Request)
+    cs.process_event(CLIENT, EndOfMessage)
+    cs.process_event(CLIENT, ConnectionClosed)
+    cs.process_event(SERVER, Response)
+    cs.process_event(SERVER, EndOfMessage)
+
+    with pytest.raises(LocalProtocolError):
+        cs.start_next_cycle()
+
+    # Succesful protocol switch
+
+    cs = ConnectionState()
+    cs.process_client_switch_proposal(_SWITCH_UPGRADE)
+    cs.process_event(CLIENT, Request)
+    cs.process_event(CLIENT, EndOfMessage)
+    cs.process_event(SERVER, InformationalResponse, _SWITCH_UPGRADE)
+
+    with pytest.raises(LocalProtocolError):
+        cs.start_next_cycle()
+
+    # Failed protocol switch
+
+    cs = ConnectionState()
+    cs.process_client_switch_proposal(_SWITCH_UPGRADE)
+    cs.process_event(CLIENT, Request)
+    cs.process_event(CLIENT, EndOfMessage)
+    cs.process_event(SERVER, Response)
+    cs.process_event(SERVER, EndOfMessage)
+
+    cs.start_next_cycle()
+    assert cs.states == {CLIENT: IDLE, SERVER: IDLE}
+
+
+def test_server_request_is_illegal():
+    # There used to be a bug in how we handled the Request special case that
+    # made this allowed...
+    cs = ConnectionState()
+    with pytest.raises(LocalProtocolError):
+        cs.process_event(SERVER, Request)
diff --git a/myenv/lib/python3.9/site-packages/h11/tests/test_util.py b/myenv/lib/python3.9/site-packages/h11/tests/test_util.py
new file mode 100644
index 0000000..d851bdc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/h11/tests/test_util.py
@@ -0,0 +1,99 @@
+import re
+import sys
+import traceback
+
+import pytest
+
+from .._util import *
+
+
+def test_ProtocolError():
+    with pytest.raises(TypeError):
+        ProtocolError("abstract base class")
+
+
+def test_LocalProtocolError():
+    try:
+        raise LocalProtocolError("foo")
+    except LocalProtocolError as e:
+        assert str(e) == "foo"
+        assert e.error_status_hint == 400
+
+    try:
+        raise LocalProtocolError("foo", error_status_hint=418)
+    except LocalProtocolError as e:
+        assert str(e) == "foo"
+        assert e.error_status_hint == 418
+
+    def thunk():
+        raise LocalProtocolError("a", error_status_hint=420)
+
+    try:
+        try:
+            thunk()
+        except LocalProtocolError as exc1:
+            orig_traceback = "".join(traceback.format_tb(sys.exc_info()[2]))
+            exc1._reraise_as_remote_protocol_error()
+    except RemoteProtocolError as exc2:
+        assert type(exc2) is RemoteProtocolError
+        assert exc2.args == ("a",)
+        assert exc2.error_status_hint == 420
+        new_traceback = "".join(traceback.format_tb(sys.exc_info()[2]))
+        assert new_traceback.endswith(orig_traceback)
+
+
+def test_validate():
+    my_re = re.compile(br"(?P<group1>[0-9]+)\.(?P<group2>[0-9]+)")
+    with pytest.raises(LocalProtocolError):
+        validate(my_re, b"0.")
+
+    groups = validate(my_re, b"0.1")
+    assert groups == {"group1": b"0", "group2": b"1"}
+
+    # successful partial matches are an error - must match whole string
+    with pytest.raises(LocalProtocolError):
+        validate(my_re, b"0.1xx")
+    with pytest.raises(LocalProtocolError):
+        validate(my_re, b"0.1\n")
+
+
+def test_validate_formatting():
+    my_re = re.compile(br"foo")
+
+    with pytest.raises(LocalProtocolError) as excinfo:
+        validate(my_re, b"", "oops")
+    assert "oops" in str(excinfo.value)
+
+    with pytest.raises(LocalProtocolError) as excinfo:
+        validate(my_re, b"", "oops {}")
+    assert "oops {}" in str(excinfo.value)
+
+    with pytest.raises(LocalProtocolError) as excinfo:
+        validate(my_re, b"", "oops {} xx", 10)
+    assert "oops 10 xx" in str(excinfo.value)
+
+
+def test_make_sentinel():
+    S = make_sentinel("S")
+    assert repr(S) == "S"
+    assert S == S
+    assert type(S).__name__ == "S"
+    assert S in {S}
+    assert type(S) is S
+    S2 = make_sentinel("S2")
+    assert repr(S2) == "S2"
+    assert S != S2
+    assert S not in {S2}
+    assert type(S) is not type(S2)
+
+
+def test_bytesify():
+    assert bytesify(b"123") == b"123"
+    assert bytesify(bytearray(b"123")) == b"123"
+    assert bytesify("123") == b"123"
+
+    with pytest.raises(UnicodeEncodeError):
+        bytesify("\u1234")
+
+    with pytest.raises(TypeError):
+        bytesify(10)
diff --git a/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/LICENSE.md b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/LICENSE.md
new file mode 100644
index 0000000..311b2b5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/LICENSE.md
@@ -0,0 +1,27 @@
+Copyright © 2020, [Encode OSS Ltd](https://www.encode.io/).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/METADATA
new file mode 100644
index 0000000..2361011
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/METADATA
@@ -0,0 +1,489 @@
+Metadata-Version: 2.1
+Name: httpcore
+Version: 0.15.0
+Summary: A minimal low-level HTTP client.
+Home-page: https://github.com/encode/httpcore
+Author: Tom Christie
+Author-email: tom@tomchristie.com
+License: BSD
+Project-URL: Documentation, https://www.encode.io/httpcore
+Project-URL: Source, https://github.com/encode/httpcore
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: h11 (<0.13,>=0.11)
+Requires-Dist: sniffio (==1.*)
+Requires-Dist: anyio (==3.*)
+Requires-Dist: certifi
+Provides-Extra: http2
+Requires-Dist: h2 (<5,>=3) ; extra == 'http2'
+Provides-Extra: socks
+Requires-Dist: socksio (==1.*) ; extra == 'socks'
+
+# HTTP Core
+
+[![Test Suite](https://github.com/encode/httpcore/workflows/Test%20Suite/badge.svg)](https://github.com/encode/httpcore/actions)
+[![Package version](https://badge.fury.io/py/httpcore.svg)](https://pypi.org/project/httpcore/)
+
+> *Do one thing, and do it well.*
+
+The HTTP Core package provides a minimal low-level HTTP client, which does
+one thing only. Sending HTTP requests.
+
+It does not provide any high level model abstractions over the API,
+does not handle redirects, multipart uploads, building authentication headers,
+transparent HTTP caching, URL parsing, session cookie handling,
+content or charset decoding, handling JSON, environment based configuration
+defaults, or any of that Jazz.
+
+Some things HTTP Core does do:
+
+* Sending HTTP requests.
+* Thread-safe / task-safe connection pooling.
+* HTTP(S) proxy & SOCKS proxy support.
+* Supports HTTP/1.1 and HTTP/2.
+* Provides both sync and async interfaces.
+* Async backend support for `asyncio` and `trio`.
+
+## Requirements
+
+Python 3.7+
+
+## Installation
+
+For HTTP/1.1 only support, install with:
+
+```shell
+$ pip install httpcore
+```
+
+For HTTP/1.1 and HTTP/2 support, install with:
+
+```shell
+$ pip install httpcore[http2]
+```
+
+For SOCKS proxy support, install with:
+
+```shell
+$ pip install httpcore[socks]
+```
+
+# Sending requests
+
+Send an HTTP request:
+
+```python
+import httpcore
+
+response = httpcore.request("GET", "https://www.example.com/")
+
+print(response)
+# <Response [200]>
+print(response.status)
+# 200
+print(response.headers)
+# [(b'Accept-Ranges', b'bytes'), (b'Age', b'557328'), (b'Cache-Control', b'max-age=604800'), ...]
+print(response.content)
+# b'<!doctype html>\n<html>\n<head>\n<title>Example Domain</title>\n\n<meta charset="utf-8"/>\n ...'
+```
+
+The top-level `httpcore.request()` function is provided for convenience. In practice whenever you're working with `httpcore` you'll want to use the connection pooling functionality that it provides.
+
+```python
+import httpcore
+
+http = httpcore.ConnectionPool()
+response = http.request("GET", "https://www.example.com/")
+```
+
+Once you're ready to get going, [head over to the documentation](https://www.encode.io/httpcore/).
+
+## Motivation
+
+You *probably* don't want to be using HTTP Core directly. It might make sense if
+you're writing something like a proxy service in Python, and you just want
+something at the lowest possible level, but more typically you'll want to use
+a higher level client library, such as `httpx`.
+
+The motivation for `httpcore` is:
+
+* To provide a reusable low-level client library, that other packages can then build on top of.
+* To provide a *really clear interface split* between the networking code and client logic,
+  so that each is easier to understand and reason about in isolation.
+
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## 0.15.0 (May 17th, 2022)
+
+- Drop Python 3.6 support (#535)
+- Ensure HTTP proxy CONNECT requests include `timeout` configuration. (#506)
+- Switch to explicit `typing.Optional` for type hints (#513)
+- For `trio` map OSError exceptions to `ConnectError` (#543)
+
+## 0.14.7 (February 4th, 2022)
+
+- Requests which raise a PoolTimeout need to be removed from the pool queue. (#502)
+- Fix AttributeError that happened when Socks5Connection were terminated. (#501)
+
+## 0.14.6 (February 1st, 2022)
+
+- Fix SOCKS support for `http://` URLs. (#492)
+- Resolve race condition around exceptions during streaming a response. (#491)
+
+## 0.14.5 (January 18th, 2022)
+
+- SOCKS proxy support. (#478)
+- Add proxy_auth argument to HTTPProxy (#481)
+- Improve error message on 'RemoteProtocolError' exception when server disconnects without sending a response (#479)
+
+## 0.14.4 (January 5th, 2022)
+
+- Support HTTP/2 on HTTPS tunnelling proxies. (#468)
+- Fix proxy headers missing on HTTP forwarding. (#456)
+- Only instantiate SSL context if required. (#457)
+- More robust HTTP/2 handling. (#253, #439, #440, #441)
+
+## 0.14.3 (November 17th, 2021)
+
+- Fix race condition when removing closed connections from the pool (#437)
+
+## 0.14.2 (November 16th, 2021)
+
+- Failed connections no longer remain in the pool. (Pull #433)
+
+## 0.14.1 (November 12th, 2021)
+
+- `max_connections` becomes optional. (Pull #429)
+- `certifi` is now included in the install dependancies. (Pull #428)
+- `h2` is now strictly optional. (Pull #428)
+
+## 0.14.0 (November 11th, 2021)
+
+The 0.14 release is a complete reworking of `httpcore`, comprehensively addressing some underlying issues in the connection pooling, as well as substantially redesigning the API to be more user friendly.
+
+Some of the lower-level API design also makes the components more easily testable in isolation, and the package now has 100% test coverage.
+
+See [discussion #419](https://github.com/encode/httpcore/discussions/419) for a little more background.
+
+There's some other neat bits in there too, such as the "trace" extension, which gives a hook into inspecting the internal events that occur during the request/response cycle. This extension is needed for the HTTPX cli, in order to...
+
+* Log the point at which the connection is established, and the IP/port on which it is made.
+* Determine if the outgoing request should log as HTTP/1.1 or HTTP/2, rather than having to assume it's HTTP/2 if the --http2 flag was passed. (Which may not actually be true.)
+* Log SSL version info / certificate info.
+
+Note that `curio` support is not currently available in 0.14.0. If you're using `httpcore` with `curio` please get in touch, so we can assess if we ought to prioritize it as a feature or not.
+
+## 0.13.7 (September 13th, 2021)
+
+- Fix broken error messaging when URL scheme is missing, or a non HTTP(S) scheme is used. (Pull #403)
+
+## 0.13.6 (June 15th, 2021)
+
+### Fixed
+
+- Close sockets when read or write timeouts occur. (Pull #365)
+
+## 0.13.5 (June 14th, 2021)
+
+### Fixed
+
+- Resolved niggles with AnyIO EOF behaviours. (Pull #358, #362)
+
+## 0.13.4 (June 9th, 2021)
+
+### Added
+
+- Improved error messaging when URL scheme is missing, or a non HTTP(S) scheme is used. (Pull #354)
+
+### Fixed
+
+- Switched to `anyio` as the default backend implementation when running with `asyncio`. Resolves some awkward [TLS timeout issues](https://github.com/encode/httpx/discussions/1511).
+
+## 0.13.3 (May 6th, 2021)
+
+### Added
+
+- Support HTTP/2 prior knowledge, using `httpcore.SyncConnectionPool(http1=False)`. (Pull #333)
+
+### Fixed
+
+- Handle cases where environment does not provide `select.poll` support. (Pull #331)
+
+## 0.13.2 (April 29th, 2021)
+
+### Added
+
+- Improve error message for specific case of `RemoteProtocolError` where server disconnects without sending a response. (Pull #313)
+
+## 0.13.1 (April 28th, 2021)
+
+### Fixed
+
+- More resiliant testing for closed connections. (Pull #311)
+- Don't raise exceptions on ungraceful connection closes. (Pull #310)
+
+## 0.13.0 (April 21st, 2021)
+
+The 0.13 release updates the core API in order to match the HTTPX Transport API,
+introduced in HTTPX 0.18 onwards.
+
+An example of making requests with the new interface is:
+
+```python
+with httpcore.SyncConnectionPool() as http:
+    status_code, headers, stream, extensions = http.handle_request(
+        method=b'GET',
+        url=(b'https', b'example.org', 443, b'/'),
+        headers=[(b'host', b'example.org'), (b'user-agent', b'httpcore')]
+        stream=httpcore.ByteStream(b''),
+        extensions={}
+    )
+    body = stream.read()
+    print(status_code, body)
+```
+
+### Changed
+
+- The `.request()` method is now `handle_request()`. (Pull #296)
+- The `.arequest()` method is now `.handle_async_request()`. (Pull #296)
+- The `headers` argument is no longer optional. (Pull #296)
+- The `stream` argument is no longer optional. (Pull #296)
+- The `ext` argument is now named `extensions`, and is no longer optional. (Pull #296)
+- The `"reason"` extension keyword is now named `"reason_phrase"`. (Pull #296)
+- The `"reason_phrase"` and `"http_version"` extensions now use byte strings for their values. (Pull #296)
+- The `httpcore.PlainByteStream()` class becomes `httpcore.ByteStream()`. (Pull #296)
+
+### Added
+
+- Streams now support a `.read()` interface. (Pull #296)
+
+### Fixed
+
+- Task cancellation no longer leaks connections from the connection pool. (Pull #305)
+
+## 0.12.3 (December 7th, 2020)
+
+### Fixed
+
+- Abort SSL connections on close rather than waiting for remote EOF when using `asyncio`.  (Pull #167)
+- Fix exception raised in case of connect timeouts when using the `anyio` backend. (Pull #236)
+- Fix `Host` header precedence for `:authority` in HTTP/2. (Pull #241, #243)
+- Handle extra edge case when detecting for socket readability when using `asyncio`. (Pull #242, #244)
+- Fix `asyncio` SSL warning when using proxy tunneling. (Pull #249)
+
+## 0.12.2 (November 20th, 2020)
+
+### Fixed
+
+- Properly wrap connect errors on the asyncio backend. (Pull #235)
+- Fix `ImportError` occurring on Python 3.9 when using the HTTP/1.1 sync client in a multithreaded context. (Pull #237)
+
+## 0.12.1 (November 7th, 2020)
+
+### Added
+
+- Add connect retries. (Pull #221)
+
+### Fixed
+
+- Tweak detection of dropped connections, resolving an issue with open files limits on Linux. (Pull #185)
+- Avoid leaking connections when establishing an HTTP tunnel to a proxy has failed. (Pull #223)
+- Properly wrap OS errors when using `trio`. (Pull #225)
+
+## 0.12.0 (October 6th, 2020)
+
+### Changed
+
+- HTTP header casing is now preserved, rather than always sent in lowercase. (#216 and python-hyper/h11#104)
+
+### Added
+
+- Add Python 3.9 to officially supported versions.
+
+### Fixed
+
+- Gracefully handle a stdlib asyncio bug when a connection is closed while it is in a paused-for-reading state. (#201)
+
+## 0.11.1 (September 28nd, 2020)
+
+### Fixed
+
+- Add await to async semaphore release() coroutine (#197)
+- Drop incorrect curio classifier (#192)
+
+## 0.11.0 (September 22nd, 2020)
+
+The Transport API with 0.11.0 has a couple of significant changes.
+
+Firstly we've moved changed the request interface in order to allow extensions, which will later enable us to support features
+such as trailing headers, HTTP/2 server push, and CONNECT/Upgrade connections.
+
+The interface changes from:
+
+```python
+def request(method, url, headers, stream, timeout):
+    return (http_version, status_code, reason, headers, stream)
+```
+
+To instead including an optional dictionary of extensions on the request and response:
+
+```python
+def request(method, url, headers, stream, ext):
+    return (status_code, headers, stream, ext)
+```
+
+Having an open-ended extensions point will allow us to add later support for various optional features, that wouldn't otherwise be supported without these API changes.
+
+In particular:
+
+* Trailing headers support.
+* HTTP/2 Server Push
+* sendfile.
+* Exposing raw connection on CONNECT, Upgrade, HTTP/2 bi-di streaming.
+* Exposing debug information out of the API, including template name, template context.
+
+Currently extensions are limited to:
+
+* request: `timeout` - Optional. Timeout dictionary.
+* response: `http_version` - Optional. Include the HTTP version used on the response.
+* response: `reason` - Optional. Include the reason phrase used on the response. Only valid with HTTP/1.*.
+
+See https://github.com/encode/httpx/issues/1274#issuecomment-694884553 for the history behind this.
+
+Secondly, the async version of `request` is now namespaced as `arequest`.
+
+This allows concrete transports to support both sync and async implementations on the same class.
+
+### Added
+
+- Add curio support. (Pull #168)
+- Add anyio support, with `backend="anyio"`. (Pull #169)
+
+### Changed
+
+- Update the Transport API to use 'ext' for optional extensions. (Pull #190)
+- Update the Transport API to use `.request` and `.arequest` so implementations can support both sync and async. (Pull #189)
+
+## 0.10.2 (August 20th, 2020)
+
+### Added
+
+- Added Unix Domain Socket support. (Pull #139)
+
+### Fixed
+
+- Always include the port on proxy CONNECT requests. (Pull #154)
+- Fix `max_keepalive_connections` configuration. (Pull #153)
+- Fixes behaviour in HTTP/1.1 where server disconnects can be used to signal the end of the response body. (Pull #164)
+
+## 0.10.1 (August 7th, 2020)
+
+- Include `max_keepalive_connections` on `AsyncHTTPProxy`/`SyncHTTPProxy` classes.
+
+## 0.10.0 (August 7th, 2020)
+
+The most notable change in the 0.10.0 release is that HTTP/2 support is now fully optional.
+
+Use either `pip install httpcore` for HTTP/1.1 support only, or `pip install httpcore[http2]` for HTTP/1.1 and HTTP/2 support.
+
+### Added
+
+- HTTP/2 support becomes optional. (Pull #121, #130)
+- Add `local_address=...` support. (Pull #100, #134)
+- Add `PlainByteStream`, `IteratorByteStream`, `AsyncIteratorByteStream`. The `AsyncByteSteam` and `SyncByteStream` classes are now pure interface classes. (#133)
+- Add `LocalProtocolError`, `RemoteProtocolError` exceptions. (Pull #129)
+- Add `UnsupportedProtocol` exception. (Pull #128)
+- Add `.get_connection_info()` method. (Pull #102, #137)
+- Add better TRACE logs. (Pull #101)
+
+### Changed
+
+- `max_keepalive` is deprecated in favour of `max_keepalive_connections`. (Pull #140)
+
+### Fixed
+
+- Improve handling of server disconnects. (Pull #112)
+
+## 0.9.1 (May 27th, 2020)
+
+### Fixed
+
+- Proper host resolution for sync case, including IPv6 support. (Pull #97)
+- Close outstanding connections when connection pool is closed. (Pull #98)
+
+## 0.9.0 (May 21th, 2020)
+
+### Changed
+
+- URL port becomes an `Optional[int]` instead of `int`. (Pull #92)
+
+### Fixed
+
+- Honor HTTP/2 max concurrent streams settings. (Pull #89, #90)
+- Remove incorrect debug log. (Pull #83)
+
+## 0.8.4 (May 11th, 2020)
+
+### Added
+
+- Logging via HTTPCORE_LOG_LEVEL and HTTPX_LOG_LEVEL environment variables
+and TRACE level logging. (Pull #79)
+
+### Fixed
+
+- Reuse of connections on HTTP/2 in close concurrency situations. (Pull #81)
+
+## 0.8.3 (May 6rd, 2020)
+
+### Fixed
+
+- Include `Host` and `Accept` headers on proxy "CONNECT" requests.
+- De-duplicate any headers also contained in proxy_headers.
+- HTTP/2 flag not being passed down to proxy connections.
+
+## 0.8.2 (May 3rd, 2020)
+
+### Fixed
+
+- Fix connections using proxy forwarding requests not being added to the
+connection pool properly. (Pull #70)
+
+## 0.8.1 (April 30th, 2020)
+
+### Changed
+
+- Allow inherintance of both `httpcore.AsyncByteStream`, `httpcore.SyncByteStream` without type conflicts.
+
+## 0.8.0 (April 30th, 2020)
+
+### Fixed
+
+- Fixed tunnel proxy support.
+
+### Added
+
+- New `TimeoutException` base class.
+
+## 0.7.0 (March 5th, 2020)
+
+- First integration with HTTPX.
diff --git a/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/RECORD
new file mode 100644
index 0000000..72f9d95
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/RECORD
@@ -0,0 +1,38 @@
+httpcore/__init__.py,sha256=XmFtXye6ccUEQzSoUUKpEpmd0DV8SROuIzg0fx1vVKw,1869
+httpcore/_api.py,sha256=kasGkW6W8-DDd_74UaC-KQDBV5N4GTdsuP32yuW0la8,3154
+httpcore/_exceptions.py,sha256=L8hJfhAVa3HUdef9OrlXOuU-VxuXEwND-SKanz0siJ4,1111
+httpcore/_models.py,sha256=ukPIXFSfbapVKQQ9pX5Nl9qA6zBj_m7zDghp6Z6Gja8,16205
+httpcore/_ssl.py,sha256=W41aVdVq5UkCp_y3wqGBxp4ozDe2GAMpiJkhYOddlfs,203
+httpcore/_synchronization.py,sha256=8Ay8T57hRRCZxYsvZ6xh3EWSm8Zs0aXzt-nSFH4yx9s,2226
+httpcore/_trace.py,sha256=TOg0iQINCX3DNQCaNBfMrrvp8cIuOTOnAh-STvyGeN4,1797
+httpcore/_utils.py,sha256=9QPh5ib4JilWX4dBCC_XO6wdBY4b0kbUGgfV3QfBANc,1525
+httpcore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpcore/_async/__init__.py,sha256=EWdl2v4thnAHzJpqjU4h2a8DUiGAvNiWrkii9pfhTf0,1221
+httpcore/_async/connection.py,sha256=_q5CUhTi3v01kpfAPway7f5377LgpeYut7NqDbJDY54,7827
+httpcore/_async/connection_pool.py,sha256=h6Z7LpnpXEbYOptoO5XnHVDkBw5L9CNUdg_G-VwKWdw,14020
+httpcore/_async/http11.py,sha256=KlWD3I0tQ9elXFehjxgQSTt1UjJXdjj7rzc1oIy9Z50,11263
+httpcore/_async/http2.py,sha256=JX8M2fiCiswzTKfrTi8O8IUZn8mO8PNmS0GTaRkUJXo,19588
+httpcore/_async/http_proxy.py,sha256=DWo9qoKuM52giv5fbNpYOy9_Pl-Y9ok-M3Ef_CiAYrI,13471
+httpcore/_async/interfaces.py,sha256=o36n2kNiYwA5jlLFNXTqYFyLmoc1v29igN7M-zxqvUw,4465
+httpcore/_async/socks_proxy.py,sha256=jCawaM9EAGdxy-bc_jnlOQmLG-uAy-IWB1R2EzuH784,13754
+httpcore/_sync/__init__.py,sha256=JBDIgXt5la1LCJ1sLQeKhjKFpLnpNr8Svs6z2ni3fgg,1141
+httpcore/_sync/connection.py,sha256=VFHf3i1CCpUT7bbWwGObDfCJ8u3WM7HVgP70jA2Bw3c,7628
+httpcore/_sync/connection_pool.py,sha256=zD9OEX96vCdKRm0fA_Kesu85CgQXSPLPLNMm3Tve0Eg,13658
+httpcore/_sync/http11.py,sha256=Te2fILGjsJcvFJYSHwQv2IqxJtwCPwWCG5fyfONTDWc,10939
+httpcore/_sync/http2.py,sha256=aNAwq1BHadSUO6EtLbt97BBzPdmliIW7WbnWTPbxtJ4,19146
+httpcore/_sync/http_proxy.py,sha256=K1t1qfrMmy3POIXed-DEfL7ra1j_QStnSwJjHLkauOM,13233
+httpcore/_sync/interfaces.py,sha256=a3Jh2VCuz6GOgZuOF1VK9aJ89f52CMbVUrtrsac0n7Q,4344
+httpcore/_sync/socks_proxy.py,sha256=tcUpNjFNCye_qwCwfmWo9N45e1WR4Vy-x5s2Z6iOJ_I,13539
+httpcore/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpcore/backends/asyncio.py,sha256=KMGdbntlx-KdWER_VyHjV6X7ThdZ8JIa6nYhzNZKgrY,4381
+httpcore/backends/auto.py,sha256=WDfYnVtuXh1SZKZ85yM1bIGe63RssDFBNKbecqYXVD0,1321
+httpcore/backends/base.py,sha256=1R0753TvDRGwiPNeIKfuu-PRcssY_xXqtxtXq6EeiVk,2699
+httpcore/backends/mock.py,sha256=KhAofRzcxMqfk_8gUJ-1znBy1U8DbHES4pb_MoFeokk,3366
+httpcore/backends/sync.py,sha256=7aap1R3t6wiEsFNkWS9gUaIYUB8eZaF_vQuQXiD5aCw,3327
+httpcore/backends/trio.py,sha256=nbvet36SpcfQxhayDvCP1kPp62PJ1Mr6_4_S_FV4OJg,5045
+httpcore-0.15.0.dist-info/LICENSE.md,sha256=_ctZFUx0y6uhahEkL3dAvqnyPW_rVUeRfYxflKgDkqU,1518
+httpcore-0.15.0.dist-info/METADATA,sha256=JD5fs4RqwsoHRRusp7J__aClnRNb4XKbQWUxNQbl3Dw,15849
+httpcore-0.15.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+httpcore-0.15.0.dist-info/top_level.txt,sha256=RaSz_iTqWmkXuXYRXC61wQGRTub4xiYn0d71TCHCrAg,58
+httpcore-0.15.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+httpcore-0.15.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/WHEEL
new file mode 100644
index 0000000..becc9a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/top_level.txt
new file mode 100644
index 0000000..855079b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore-0.15.0.dist-info/top_level.txt
@@ -0,0 +1,4 @@
+httpcore
+httpcore/_async
+httpcore/_sync
+httpcore/backends
diff --git a/myenv/lib/python3.9/site-packages/httpcore/__init__.py b/myenv/lib/python3.9/site-packages/httpcore/__init__.py
new file mode 100644
index 0000000..e435076
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/__init__.py
@@ -0,0 +1,91 @@
+from ._api import request, stream
+from ._async import (
+    AsyncConnectionInterface,
+    AsyncConnectionPool,
+    AsyncHTTP2Connection,
+    AsyncHTTP11Connection,
+    AsyncHTTPConnection,
+    AsyncHTTPProxy,
+    AsyncSOCKSProxy,
+)
+from ._exceptions import (
+    ConnectError,
+    ConnectionNotAvailable,
+    ConnectTimeout,
+    LocalProtocolError,
+    NetworkError,
+    PoolTimeout,
+    ProtocolError,
+    ProxyError,
+    ReadError,
+    ReadTimeout,
+    RemoteProtocolError,
+    TimeoutException,
+    UnsupportedProtocol,
+    WriteError,
+    WriteTimeout,
+)
+from ._models import URL, Origin, Request, Response
+from ._ssl import default_ssl_context
+from ._sync import (
+    ConnectionInterface,
+    ConnectionPool,
+    HTTP2Connection,
+    HTTP11Connection,
+    HTTPConnection,
+    HTTPProxy,
+    SOCKSProxy,
+)
+
+__all__ = [
+    # top-level requests
+    "request",
+    "stream",
+    # models
+    "Origin",
+    "URL",
+    "Request",
+    "Response",
+    # async
+    "AsyncHTTPConnection",
+    "AsyncConnectionPool",
+    "AsyncHTTPProxy",
+    "AsyncHTTP11Connection",
+    "AsyncHTTP2Connection",
+    "AsyncConnectionInterface",
+    "AsyncSOCKSProxy",
+    # sync
+    "HTTPConnection",
+    "ConnectionPool",
+    "HTTPProxy",
+    "HTTP11Connection",
+    "HTTP2Connection",
+    "ConnectionInterface",
+    "SOCKSProxy",
+    # util
+    "default_ssl_context",
+    # exceptions
+    "ConnectionNotAvailable",
+    "ProxyError",
+    "ProtocolError",
+    "LocalProtocolError",
+    "RemoteProtocolError",
+    "UnsupportedProtocol",
+    "TimeoutException",
+    "PoolTimeout",
+    "ConnectTimeout",
+    "ReadTimeout",
+    "WriteTimeout",
+    "NetworkError",
+    "ConnectError",
+    "ReadError",
+    "WriteError",
+]
+
+__version__ = "0.15.0"
+
+
+__locals = locals()
+for __name in __all__:
+    if not __name.startswith("__"):
+        setattr(__locals[__name], "__module__", "httpcore")  # noqa
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_api.py b/myenv/lib/python3.9/site-packages/httpcore/_api.py
new file mode 100644
index 0000000..859a189
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_api.py
@@ -0,0 +1,92 @@
+from contextlib import contextmanager
+from typing import Iterator, Optional, Union
+
+from ._models import URL, Response
+from ._sync.connection_pool import ConnectionPool
+
+
+def request(
+    method: Union[bytes, str],
+    url: Union[URL, bytes, str],
+    *,
+    headers: Union[dict, list, None] = None,
+    content: Union[bytes, Iterator[bytes], None] = None,
+    extensions: Optional[dict] = None,
+) -> Response:
+    """
+    Sends an HTTP request, returning the response.
+
+    ```
+    response = httpcore.request("GET", "https://www.example.com/")
+    ```
+
+    Arguments:
+        method: The HTTP method for the request. Typically one of `"GET"`,
+            `"OPTIONS"`, `"HEAD"`, `"POST"`, `"PUT"`, `"PATCH"`, or `"DELETE"`.
+        url: The URL of the HTTP request. Either as an instance of `httpcore.URL`,
+            or as str/bytes.
+        headers: The HTTP request headers. Either as a dictionary of str/bytes,
+            or as a list of two-tuples of str/bytes.
+        content: The content of the request body. Either as bytes,
+            or as a bytes iterator.
+        extensions: A dictionary of optional extra information included on the request.
+            Possible keys include `"timeout"`.
+
+    Returns:
+        An instance of `httpcore.Response`.
+    """
+    with ConnectionPool() as pool:
+        return pool.request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+
+
+@contextmanager
+def stream(
+    method: Union[bytes, str],
+    url: Union[URL, bytes, str],
+    *,
+    headers: Union[dict, list, None] = None,
+    content: Union[bytes, Iterator[bytes], None] = None,
+    extensions: Optional[dict] = None,
+) -> Iterator[Response]:
+    """
+    Sends an HTTP request, returning the response within a content manager.
+
+    ```
+    with httpcore.stream("GET", "https://www.example.com/") as response:
+        ...
+    ```
+
+    When using the `stream()` function, the body of the response will not be
+    automatically read. If you want to access the response body you should
+    either use `content = response.read()`, or `for chunk in response.iter_content()`.
+
+    Arguments:
+        method: The HTTP method for the request. Typically one of `"GET"`,
+            `"OPTIONS"`, `"HEAD"`, `"POST"`, `"PUT"`, `"PATCH"`, or `"DELETE"`.
+        url: The URL of the HTTP request. Either as an instance of `httpcore.URL`,
+            or as str/bytes.
+        headers: The HTTP request headers. Either as a dictionary of str/bytes,
+            or as a list of two-tuples of str/bytes.
+        content: The content of the request body. Either as bytes,
+            or as a bytes iterator.
+        extensions: A dictionary of optional extra information included on the request.
+            Possible keys include `"timeout"`.
+
+    Returns:
+        An instance of `httpcore.Response`.
+    """
+    with ConnectionPool() as pool:
+        with pool.stream(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        ) as response:
+            yield response
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_async/__init__.py b/myenv/lib/python3.9/site-packages/httpcore/_async/__init__.py
new file mode 100644
index 0000000..88dc7f0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_async/__init__.py
@@ -0,0 +1,39 @@
+from .connection import AsyncHTTPConnection
+from .connection_pool import AsyncConnectionPool
+from .http11 import AsyncHTTP11Connection
+from .http_proxy import AsyncHTTPProxy
+from .interfaces import AsyncConnectionInterface
+
+try:
+    from .http2 import AsyncHTTP2Connection
+except ImportError:  # pragma: nocover
+
+    class AsyncHTTP2Connection:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use http2 support, but the `h2` package is not "
+                "installed. Use 'pip install httpcore[http2]'."
+            )
+
+
+try:
+    from .socks_proxy import AsyncSOCKSProxy
+except ImportError:  # pragma: nocover
+
+    class AsyncSOCKSProxy:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use SOCKS support, but the `socksio` package is not "
+                "installed. Use 'pip install httpcore[socks]'."
+            )
+
+
+__all__ = [
+    "AsyncHTTPConnection",
+    "AsyncConnectionPool",
+    "AsyncHTTPProxy",
+    "AsyncHTTP11Connection",
+    "AsyncHTTP2Connection",
+    "AsyncConnectionInterface",
+    "AsyncSOCKSProxy",
+]
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_async/connection.py b/myenv/lib/python3.9/site-packages/httpcore/_async/connection.py
new file mode 100644
index 0000000..b919678
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_async/connection.py
@@ -0,0 +1,208 @@
+import itertools
+import ssl
+from types import TracebackType
+from typing import Iterator, Optional, Type
+
+from .._exceptions import ConnectError, ConnectionNotAvailable, ConnectTimeout
+from .._models import Origin, Request, Response
+from .._ssl import default_ssl_context
+from .._synchronization import AsyncLock
+from .._trace import Trace
+from ..backends.auto import AutoBackend
+from ..backends.base import AsyncNetworkBackend, AsyncNetworkStream
+from .http11 import AsyncHTTP11Connection
+from .interfaces import AsyncConnectionInterface
+
+RETRIES_BACKOFF_FACTOR = 0.5  # 0s, 0.5s, 1s, 2s, 4s, etc.
+
+
+def exponential_backoff(factor: float) -> Iterator[float]:
+    yield 0
+    for n in itertools.count(2):
+        yield factor * (2 ** (n - 2))
+
+
+class AsyncHTTPConnection(AsyncConnectionInterface):
+    def __init__(
+        self,
+        origin: Origin,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[AsyncNetworkBackend] = None,
+    ) -> None:
+        self._origin = origin
+        self._ssl_context = ssl_context
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._retries = retries
+        self._local_address = local_address
+        self._uds = uds
+
+        self._network_backend: AsyncNetworkBackend = (
+            AutoBackend() if network_backend is None else network_backend
+        )
+        self._connection: Optional[AsyncConnectionInterface] = None
+        self._connect_failed: bool = False
+        self._request_lock = AsyncLock()
+
+    async def handle_async_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection to {self._origin}"
+            )
+
+        async with self._request_lock:
+            if self._connection is None:
+                try:
+                    stream = await self._connect(request)
+
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = (
+                        ssl_object is not None
+                        and ssl_object.selected_alpn_protocol() == "h2"
+                    )
+                    if http2_negotiated or (self._http2 and not self._http1):
+                        from .http2 import AsyncHTTP2Connection
+
+                        self._connection = AsyncHTTP2Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = AsyncHTTP11Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                except Exception as exc:
+                    self._connect_failed = True
+                    raise exc
+            elif not self._connection.is_available():
+                raise ConnectionNotAvailable()
+
+        return await self._connection.handle_async_request(request)
+
+    async def _connect(self, request: Request) -> AsyncNetworkStream:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("connect", None)
+
+        retries_left = self._retries
+        delays = exponential_backoff(factor=RETRIES_BACKOFF_FACTOR)
+
+        while True:
+            try:
+                if self._uds is None:
+                    kwargs = {
+                        "host": self._origin.host.decode("ascii"),
+                        "port": self._origin.port,
+                        "local_address": self._local_address,
+                        "timeout": timeout,
+                    }
+                    async with Trace(
+                        "connection.connect_tcp", request, kwargs
+                    ) as trace:
+                        stream = await self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
+                else:
+                    kwargs = {
+                        "path": self._uds,
+                        "timeout": timeout,
+                    }
+                    async with Trace(
+                        "connection.connect_unix_socket", request, kwargs
+                    ) as trace:
+                        stream = await self._network_backend.connect_unix_socket(
+                            **kwargs
+                        )
+                        trace.return_value = stream
+            except (ConnectError, ConnectTimeout):
+                if retries_left <= 0:
+                    raise
+                retries_left -= 1
+                delay = next(delays)
+                # TRACE 'retry'
+                await self._network_backend.sleep(delay)
+            else:
+                break
+
+        if self._origin.scheme == b"https":
+            ssl_context = (
+                default_ssl_context()
+                if self._ssl_context is None
+                else self._ssl_context
+            )
+            alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+            ssl_context.set_alpn_protocols(alpn_protocols)
+
+            kwargs = {
+                "ssl_context": ssl_context,
+                "server_hostname": self._origin.host.decode("ascii"),
+                "timeout": timeout,
+            }
+            async with Trace("connection.start_tls", request, kwargs) as trace:
+                stream = await stream.start_tls(**kwargs)
+                trace.return_value = stream
+        return stream
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    async def aclose(self) -> None:
+        if self._connection is not None:
+            await self._connection.aclose()
+
+    def is_available(self) -> bool:
+        if self._connection is None:
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return (
+                self._http2
+                and (self._origin.scheme == b"https" or not self._http1)
+                and not self._connect_failed
+            )
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    async def __aenter__(self) -> "AsyncHTTPConnection":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        await self.aclose()
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_async/connection_pool.py b/myenv/lib/python3.9/site-packages/httpcore/_async/connection_pool.py
new file mode 100644
index 0000000..06ead3e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_async/connection_pool.py
@@ -0,0 +1,354 @@
+import ssl
+import sys
+from types import TracebackType
+from typing import AsyncIterable, AsyncIterator, List, Optional, Type
+
+from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
+from .._models import Origin, Request, Response
+from .._synchronization import AsyncEvent, AsyncLock
+from ..backends.auto import AutoBackend
+from ..backends.base import AsyncNetworkBackend
+from .connection import AsyncHTTPConnection
+from .interfaces import AsyncConnectionInterface, AsyncRequestInterface
+
+
+class RequestStatus:
+    def __init__(self, request: Request):
+        self.request = request
+        self.connection: Optional[AsyncConnectionInterface] = None
+        self._connection_acquired = AsyncEvent()
+
+    def set_connection(self, connection: AsyncConnectionInterface) -> None:
+        assert self.connection is None
+        self.connection = connection
+        self._connection_acquired.set()
+
+    def unset_connection(self) -> None:
+        assert self.connection is not None
+        self.connection = None
+        self._connection_acquired = AsyncEvent()
+
+    async def wait_for_connection(
+        self, timeout: Optional[float] = None
+    ) -> AsyncConnectionInterface:
+        await self._connection_acquired.wait(timeout=timeout)
+        assert self.connection is not None
+        return self.connection
+
+
+class AsyncConnectionPool(AsyncRequestInterface):
+    """
+    A connection pool for making HTTP requests.
+    """
+
+    def __init__(
+        self,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        max_connections: Optional[int] = 10,
+        max_keepalive_connections: Optional[int] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[AsyncNetworkBackend] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish a
+                connection.
+            local_address: Local address to connect from. Can also be used to connect
+                using a particular address family. Using `local_address="0.0.0.0"`
+                will connect using an `AF_INET` address (IPv4), while using
+                `local_address="::"` will connect using an `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        self._ssl_context = ssl_context
+
+        self._max_connections = (
+            sys.maxsize if max_connections is None else max_connections
+        )
+        self._max_keepalive_connections = (
+            sys.maxsize
+            if max_keepalive_connections is None
+            else max_keepalive_connections
+        )
+        self._max_keepalive_connections = min(
+            self._max_connections, self._max_keepalive_connections
+        )
+
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._retries = retries
+        self._local_address = local_address
+        self._uds = uds
+
+        self._pool: List[AsyncConnectionInterface] = []
+        self._requests: List[RequestStatus] = []
+        self._pool_lock = AsyncLock()
+        self._network_backend = (
+            AutoBackend() if network_backend is None else network_backend
+        )
+
+    def create_connection(self, origin: Origin) -> AsyncConnectionInterface:
+        return AsyncHTTPConnection(
+            origin=origin,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            retries=self._retries,
+            local_address=self._local_address,
+            uds=self._uds,
+            network_backend=self._network_backend,
+        )
+
+    @property
+    def connections(self) -> List[AsyncConnectionInterface]:
+        """
+        Return a list of the connections currently in the pool.
+
+        For example:
+
+        ```python
+        >>> pool.connections
+        [
+            <AsyncHTTPConnection ['https://example.com:443', HTTP/1.1, ACTIVE, Request Count: 6]>,
+            <AsyncHTTPConnection ['https://example.com:443', HTTP/1.1, IDLE, Request Count: 9]> ,
+            <AsyncHTTPConnection ['http://example.com:80', HTTP/1.1, IDLE, Request Count: 1]>,
+        ]
+        ```
+        """
+        return list(self._pool)
+
+    async def _attempt_to_acquire_connection(self, status: RequestStatus) -> bool:
+        """
+        Attempt to provide a connection that can handle the given origin.
+        """
+        origin = status.request.url.origin
+
+        # If there are queued requests in front of us, then don't acquire a
+        # connection. We handle requests strictly in order.
+        waiting = [s for s in self._requests if s.connection is None]
+        if waiting and waiting[0] is not status:
+            return False
+
+        # Reuse an existing connection if one is currently available.
+        for idx, connection in enumerate(self._pool):
+            if connection.can_handle_request(origin) and connection.is_available():
+                self._pool.pop(idx)
+                self._pool.insert(0, connection)
+                status.set_connection(connection)
+                return True
+
+        # If the pool is currently full, attempt to close one idle connection.
+        if len(self._pool) >= self._max_connections:
+            for idx, connection in reversed(list(enumerate(self._pool))):
+                if connection.is_idle():
+                    await connection.aclose()
+                    self._pool.pop(idx)
+                    break
+
+        # If the pool is still full, then we cannot acquire a connection.
+        if len(self._pool) >= self._max_connections:
+            return False
+
+        # Otherwise create a new connection.
+        connection = self.create_connection(origin)
+        self._pool.insert(0, connection)
+        status.set_connection(connection)
+        return True
+
+    async def _close_expired_connections(self) -> None:
+        """
+        Clean up the connection pool by closing off any connections that have expired.
+        """
+        # Close any connections that have expired their keep-alive time.
+        for idx, connection in reversed(list(enumerate(self._pool))):
+            if connection.has_expired():
+                await connection.aclose()
+                self._pool.pop(idx)
+
+        # If the pool size exceeds the maximum number of allowed keep-alive connections,
+        # then close off idle connections as required.
+        pool_size = len(self._pool)
+        for idx, connection in reversed(list(enumerate(self._pool))):
+            if connection.is_idle() and pool_size > self._max_keepalive_connections:
+                await connection.aclose()
+                self._pool.pop(idx)
+                pool_size -= 1
+
+    async def handle_async_request(self, request: Request) -> Response:
+        """
+        Send an HTTP request, and return an HTTP response.
+
+        This is the core implementation that is called into by `.request()` or `.stream()`.
+        """
+        scheme = request.url.scheme.decode()
+        if scheme == "":
+            raise UnsupportedProtocol(
+                "Request URL is missing an 'http://' or 'https://' protocol."
+            )
+        if scheme not in ("http", "https"):
+            raise UnsupportedProtocol(
+                f"Request URL has an unsupported protocol '{scheme}://'."
+            )
+
+        status = RequestStatus(request)
+
+        async with self._pool_lock:
+            self._requests.append(status)
+            await self._close_expired_connections()
+            await self._attempt_to_acquire_connection(status)
+
+        while True:
+            timeouts = request.extensions.get("timeout", {})
+            timeout = timeouts.get("pool", None)
+            try:
+                connection = await status.wait_for_connection(timeout=timeout)
+            except BaseException as exc:
+                # If we timeout here, or if the task is cancelled, then make
+                # sure to remove the request from the queue before bubbling
+                # up the exception.
+                async with self._pool_lock:
+                    self._requests.remove(status)
+                    raise exc
+
+            try:
+                response = await connection.handle_async_request(request)
+            except ConnectionNotAvailable:
+                # The ConnectionNotAvailable exception is a special case, that
+                # indicates we need to retry the request on a new connection.
+                #
+                # The most common case where this can occur is when multiple
+                # requests are queued waiting for a single connection, which
+                # might end up as an HTTP/2 connection, but which actually ends
+                # up as HTTP/1.1.
+                async with self._pool_lock:
+                    # Maintain our position in the request queue, but reset the
+                    # status so that the request becomes queued again.
+                    status.unset_connection()
+                    await self._attempt_to_acquire_connection(status)
+            except BaseException as exc:
+                await self.response_closed(status)
+                raise exc
+            else:
+                break
+
+        # When we return the response, we wrap the stream in a special class
+        # that handles notifying the connection pool once the response
+        # has been released.
+        assert isinstance(response.stream, AsyncIterable)
+        return Response(
+            status=response.status,
+            headers=response.headers,
+            content=ConnectionPoolByteStream(response.stream, self, status),
+            extensions=response.extensions,
+        )
+
+    async def response_closed(self, status: RequestStatus) -> None:
+        """
+        This method acts as a callback once the request/response cycle is complete.
+
+        It is called into from the `ConnectionPoolByteStream.aclose()` method.
+        """
+        assert status.connection is not None
+        connection = status.connection
+
+        async with self._pool_lock:
+            # Update the state of the connection pool.
+            if status in self._requests:
+                self._requests.remove(status)
+
+            if connection.is_closed() and connection in self._pool:
+                self._pool.remove(connection)
+
+            # Since we've had a response closed, it's possible we'll now be able
+            # to service one or more requests that are currently pending.
+            for status in self._requests:
+                if status.connection is None:
+                    acquired = await self._attempt_to_acquire_connection(status)
+                    # If we could not acquire a connection for a queued request
+                    # then we don't need to check anymore requests that are
+                    # queued later behind it.
+                    if not acquired:
+                        break
+
+            # Housekeeping.
+            await self._close_expired_connections()
+
+    async def aclose(self) -> None:
+        """
+        Close any connections in the pool.
+        """
+        async with self._pool_lock:
+            requests_still_in_flight = len(self._requests)
+
+            for connection in self._pool:
+                await connection.aclose()
+            self._pool = []
+            self._requests = []
+
+            if requests_still_in_flight:
+                raise RuntimeError(
+                    f"The connection pool was closed while {requests_still_in_flight} "
+                    f"HTTP requests/responses were still in-flight."
+                )
+
+    async def __aenter__(self) -> "AsyncConnectionPool":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        await self.aclose()
+
+
+class ConnectionPoolByteStream:
+    """
+    A wrapper around the response byte stream, that additionally handles
+    notifying the connection pool when the response has been closed.
+    """
+
+    def __init__(
+        self,
+        stream: AsyncIterable[bytes],
+        pool: AsyncConnectionPool,
+        status: RequestStatus,
+    ) -> None:
+        self._stream = stream
+        self._pool = pool
+        self._status = status
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        async for part in self._stream:
+            yield part
+
+    async def aclose(self) -> None:
+        try:
+            if hasattr(self._stream, "aclose"):
+                await self._stream.aclose()  # type: ignore
+        finally:
+            await self._pool.response_closed(self._status)
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_async/http11.py b/myenv/lib/python3.9/site-packages/httpcore/_async/http11.py
new file mode 100644
index 0000000..a4880f3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_async/http11.py
@@ -0,0 +1,306 @@
+import enum
+import time
+from types import TracebackType
+from typing import AsyncIterable, AsyncIterator, List, Optional, Tuple, Type, Union
+
+import h11
+
+from .._exceptions import (
+    ConnectionNotAvailable,
+    LocalProtocolError,
+    RemoteProtocolError,
+    map_exceptions,
+)
+from .._models import Origin, Request, Response
+from .._synchronization import AsyncLock
+from .._trace import Trace
+from ..backends.base import AsyncNetworkStream
+from .interfaces import AsyncConnectionInterface
+
+H11Event = Union[
+    h11.Request,
+    h11.Response,
+    h11.InformationalResponse,
+    h11.Data,
+    h11.EndOfMessage,
+    h11.ConnectionClosed,
+]
+
+
+class HTTPConnectionState(enum.IntEnum):
+    NEW = 0
+    ACTIVE = 1
+    IDLE = 2
+    CLOSED = 3
+
+
+class AsyncHTTP11Connection(AsyncConnectionInterface):
+    READ_NUM_BYTES = 64 * 1024
+
+    def __init__(
+        self,
+        origin: Origin,
+        stream: AsyncNetworkStream,
+        keepalive_expiry: Optional[float] = None,
+    ) -> None:
+        self._origin = origin
+        self._network_stream = stream
+        self._keepalive_expiry: Optional[float] = keepalive_expiry
+        self._expire_at: Optional[float] = None
+        self._state = HTTPConnectionState.NEW
+        self._state_lock = AsyncLock()
+        self._request_count = 0
+        self._h11_state = h11.Connection(our_role=h11.CLIENT)
+
+    async def handle_async_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection "
+                f"to {self._origin}"
+            )
+
+        async with self._state_lock:
+            if self._state in (HTTPConnectionState.NEW, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._state = HTTPConnectionState.ACTIVE
+                self._expire_at = None
+            else:
+                raise ConnectionNotAvailable()
+
+        try:
+            kwargs = {"request": request}
+            async with Trace("http11.send_request_headers", request, kwargs) as trace:
+                await self._send_request_headers(**kwargs)
+            async with Trace("http11.send_request_body", request, kwargs) as trace:
+                await self._send_request_body(**kwargs)
+            async with Trace(
+                "http11.receive_response_headers", request, kwargs
+            ) as trace:
+                (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                ) = await self._receive_response_headers(**kwargs)
+                trace.return_value = (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                )
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP11ConnectionByteStream(self, request),
+                extensions={
+                    "http_version": http_version,
+                    "reason_phrase": reason_phrase,
+                    "network_stream": self._network_stream,
+                },
+            )
+        except BaseException as exc:
+            async with Trace("http11.response_closed", request) as trace:
+                await self._response_closed()
+            raise exc
+
+    # Sending the request...
+
+    async def _send_request_headers(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        with map_exceptions({h11.LocalProtocolError: LocalProtocolError}):
+            event = h11.Request(
+                method=request.method,
+                target=request.url.target,
+                headers=request.headers,
+            )
+        await self._send_event(event, timeout=timeout)
+
+    async def _send_request_body(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        assert isinstance(request.stream, AsyncIterable)
+        async for chunk in request.stream:
+            event = h11.Data(data=chunk)
+            await self._send_event(event, timeout=timeout)
+
+        event = h11.EndOfMessage()
+        await self._send_event(event, timeout=timeout)
+
+    async def _send_event(
+        self, event: H11Event, timeout: Optional[float] = None
+    ) -> None:
+        bytes_to_send = self._h11_state.send(event)
+        await self._network_stream.write(bytes_to_send, timeout=timeout)
+
+    # Receiving the response...
+
+    async def _receive_response_headers(
+        self, request: Request
+    ) -> Tuple[bytes, int, bytes, List[Tuple[bytes, bytes]]]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        while True:
+            event = await self._receive_event(timeout=timeout)
+            if isinstance(event, h11.Response):
+                break
+
+        http_version = b"HTTP/" + event.http_version
+
+        # h11 version 0.11+ supports a `raw_items` interface to get the
+        # raw header casing, rather than the enforced lowercase headers.
+        headers = event.headers.raw_items()
+
+        return http_version, event.status_code, event.reason, headers
+
+    async def _receive_response_body(self, request: Request) -> AsyncIterator[bytes]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        while True:
+            event = await self._receive_event(timeout=timeout)
+            if isinstance(event, h11.Data):
+                yield bytes(event.data)
+            elif isinstance(event, (h11.EndOfMessage, h11.PAUSED)):
+                break
+
+    async def _receive_event(self, timeout: Optional[float] = None) -> H11Event:
+        while True:
+            with map_exceptions({h11.RemoteProtocolError: RemoteProtocolError}):
+                event = self._h11_state.next_event()
+
+            if event is h11.NEED_DATA:
+                data = await self._network_stream.read(
+                    self.READ_NUM_BYTES, timeout=timeout
+                )
+
+                # If we feed this case through h11 we'll raise an exception like:
+                #
+                #     httpcore.RemoteProtocolError: can't handle event type
+                #     ConnectionClosed when role=SERVER and state=SEND_RESPONSE
+                #
+                # Which is accurate, but not very informative from an end-user
+                # perspective. Instead we handle this case distinctly and treat
+                # it as a ConnectError.
+                if data == b"" and self._h11_state.their_state == h11.SEND_RESPONSE:
+                    msg = "Server disconnected without sending a response."
+                    raise RemoteProtocolError(msg)
+
+                self._h11_state.receive_data(data)
+            else:
+                return event
+
+    async def _response_closed(self) -> None:
+        async with self._state_lock:
+            if (
+                self._h11_state.our_state is h11.DONE
+                and self._h11_state.their_state is h11.DONE
+            ):
+                self._state = HTTPConnectionState.IDLE
+                self._h11_state.start_next_cycle()
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+            else:
+                await self.aclose()
+
+    # Once the connection is no longer required...
+
+    async def aclose(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._state = HTTPConnectionState.CLOSED
+        await self._network_stream.aclose()
+
+    # The AsyncConnectionInterface methods provide information about the state of
+    # the connection, allowing for a connection pooling implementation to
+    # determine when to reuse and when to close the connection...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_available(self) -> bool:
+        # Note that HTTP/1.1 connections in the "NEW" state are not treated as
+        # being "available". The control flow which created the connection will
+        # be able to send an outgoing request, but the connection will not be
+        # acquired from the connection pool for any other request.
+        return self._state == HTTPConnectionState.IDLE
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        keepalive_expired = self._expire_at is not None and now > self._expire_at
+
+        # If the HTTP connection is idle but the socket is readable, then the
+        # only valid state is that the socket is about to return b"", indicating
+        # a server-initiated disconnect.
+        server_disconnected = (
+            self._state == HTTPConnectionState.IDLE
+            and self._network_stream.get_extra_info("is_readable")
+        )
+
+        return keepalive_expired or server_disconnected
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return (
+            f"{origin!r}, HTTP/1.1, {self._state.name}, "
+            f"Request Count: {self._request_count}"
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return (
+            f"<{class_name} [{origin!r}, {self._state.name}, "
+            f"Request Count: {self._request_count}]>"
+        )
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    async def __aenter__(self) -> "AsyncHTTP11Connection":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        await self.aclose()
+
+
+class HTTP11ConnectionByteStream:
+    def __init__(self, connection: AsyncHTTP11Connection, request: Request) -> None:
+        self._connection = connection
+        self._request = request
+        self._closed = False
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        kwargs = {"request": self._request}
+        try:
+            async with Trace("http11.receive_response_body", self._request, kwargs):
+                async for chunk in self._connection._receive_response_body(**kwargs):
+                    yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            await self.aclose()
+            raise exc
+
+    async def aclose(self) -> None:
+        if not self._closed:
+            self._closed = True
+            async with Trace("http11.response_closed", self._request):
+                await self._connection._response_closed()
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_async/http2.py b/myenv/lib/python3.9/site-packages/httpcore/_async/http2.py
new file mode 100644
index 0000000..4be4789
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_async/http2.py
@@ -0,0 +1,475 @@
+import enum
+import time
+import types
+import typing
+
+import h2.config
+import h2.connection
+import h2.events
+import h2.exceptions
+import h2.settings
+
+from .._exceptions import (
+    ConnectionNotAvailable,
+    LocalProtocolError,
+    RemoteProtocolError,
+)
+from .._models import Origin, Request, Response
+from .._synchronization import AsyncLock, AsyncSemaphore
+from .._trace import Trace
+from ..backends.base import AsyncNetworkStream
+from .interfaces import AsyncConnectionInterface
+
+
+def has_body_headers(request: Request) -> bool:
+    return any(
+        [
+            k.lower() == b"content-length" or k.lower() == b"transfer-encoding"
+            for k, v in request.headers
+        ]
+    )
+
+
+class HTTPConnectionState(enum.IntEnum):
+    ACTIVE = 1
+    IDLE = 2
+    CLOSED = 3
+
+
+class AsyncHTTP2Connection(AsyncConnectionInterface):
+    READ_NUM_BYTES = 64 * 1024
+    CONFIG = h2.config.H2Configuration(validate_inbound_headers=False)
+
+    def __init__(
+        self,
+        origin: Origin,
+        stream: AsyncNetworkStream,
+        keepalive_expiry: typing.Optional[float] = None,
+    ):
+        self._origin = origin
+        self._network_stream = stream
+        self._keepalive_expiry: typing.Optional[float] = keepalive_expiry
+        self._h2_state = h2.connection.H2Connection(config=self.CONFIG)
+        self._state = HTTPConnectionState.IDLE
+        self._expire_at: typing.Optional[float] = None
+        self._request_count = 0
+        self._init_lock = AsyncLock()
+        self._state_lock = AsyncLock()
+        self._read_lock = AsyncLock()
+        self._write_lock = AsyncLock()
+        self._sent_connection_init = False
+        self._used_all_stream_ids = False
+        self._connection_error = False
+        self._events: typing.Dict[int, h2.events.Event] = {}
+        self._read_exception: typing.Optional[Exception] = None
+        self._write_exception: typing.Optional[Exception] = None
+        self._connection_error_event: typing.Optional[h2.events.Event] = None
+
+    async def handle_async_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            # This cannot occur in normal operation, since the connection pool
+            # will only send requests on connections that handle them.
+            # It's in place simply for resilience as a guard against incorrect
+            # usage, for anyone working directly with httpcore connections.
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection "
+                f"to {self._origin}"
+            )
+
+        async with self._state_lock:
+            if self._state in (HTTPConnectionState.ACTIVE, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._expire_at = None
+                self._state = HTTPConnectionState.ACTIVE
+            else:
+                raise ConnectionNotAvailable()
+
+        async with self._init_lock:
+            if not self._sent_connection_init:
+                kwargs = {"request": request}
+                async with Trace("http2.send_connection_init", request, kwargs):
+                    await self._send_connection_init(**kwargs)
+                self._sent_connection_init = True
+                max_streams = self._h2_state.local_settings.max_concurrent_streams
+                self._max_streams_semaphore = AsyncSemaphore(max_streams)
+
+        await self._max_streams_semaphore.acquire()
+
+        try:
+            stream_id = self._h2_state.get_next_available_stream_id()
+            self._events[stream_id] = []
+        except h2.exceptions.NoAvailableStreamIDError:  # pragma: nocover
+            self._used_all_stream_ids = True
+            raise ConnectionNotAvailable()
+
+        try:
+            kwargs = {"request": request, "stream_id": stream_id}
+            async with Trace("http2.send_request_headers", request, kwargs):
+                await self._send_request_headers(request=request, stream_id=stream_id)
+            async with Trace("http2.send_request_body", request, kwargs):
+                await self._send_request_body(request=request, stream_id=stream_id)
+            async with Trace(
+                "http2.receive_response_headers", request, kwargs
+            ) as trace:
+                status, headers = await self._receive_response(
+                    request=request, stream_id=stream_id
+                )
+                trace.return_value = (status, headers)
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP2ConnectionByteStream(self, request, stream_id=stream_id),
+                extensions={"stream_id": stream_id, "http_version": b"HTTP/2"},
+            )
+        except Exception as exc:  # noqa: PIE786
+            kwargs = {"stream_id": stream_id}
+            async with Trace("http2.response_closed", request, kwargs):
+                await self._response_closed(stream_id=stream_id)
+
+            if isinstance(exc, h2.exceptions.ProtocolError):
+                # One case where h2 can raise a protocol error is when a
+                # closed frame has been seen by the state machine.
+                #
+                # This happens when one stream is reading, and encounters
+                # a GOAWAY event. Other flows of control may then raise
+                # a protocol error at any point they interact with the 'h2_state'.
+                #
+                # In this case we'll have stored the event, and should raise
+                # it as a RemoteProtocolError.
+                if self._connection_error_event:
+                    raise RemoteProtocolError(self._connection_error_event)
+                # If h2 raises a protocol error in some other state then we
+                # must somehow have made a protocol violation.
+                raise LocalProtocolError(exc)  # pragma: nocover
+
+            raise exc
+
+    async def _send_connection_init(self, request: Request) -> None:
+        """
+        The HTTP/2 connection requires some initial setup before we can start
+        using individual request/response streams on it.
+        """
+        # Need to set these manually here instead of manipulating via
+        # __setitem__() otherwise the H2Connection will emit SettingsUpdate
+        # frames in addition to sending the undesired defaults.
+        self._h2_state.local_settings = h2.settings.Settings(
+            client=True,
+            initial_values={
+                # Disable PUSH_PROMISE frames from the server since we don't do anything
+                # with them for now.  Maybe when we support caching?
+                h2.settings.SettingCodes.ENABLE_PUSH: 0,
+                # These two are taken from h2 for safe defaults
+                h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS: 100,
+                h2.settings.SettingCodes.MAX_HEADER_LIST_SIZE: 65536,
+            },
+        )
+
+        # Some websites (*cough* Yahoo *cough*) balk at this setting being
+        # present in the initial handshake since it's not defined in the original
+        # RFC despite the RFC mandating ignoring settings you don't know about.
+        del self._h2_state.local_settings[
+            h2.settings.SettingCodes.ENABLE_CONNECT_PROTOCOL
+        ]
+
+        self._h2_state.initiate_connection()
+        self._h2_state.increment_flow_control_window(2**24)
+        await self._write_outgoing_data(request)
+
+    # Sending the request...
+
+    async def _send_request_headers(self, request: Request, stream_id: int) -> None:
+        end_stream = not has_body_headers(request)
+
+        # In HTTP/2 the ':authority' pseudo-header is used instead of 'Host'.
+        # In order to gracefully handle HTTP/1.1 and HTTP/2 we always require
+        # HTTP/1.1 style headers, and map them appropriately if we end up on
+        # an HTTP/2 connection.
+        authority = [v for k, v in request.headers if k.lower() == b"host"][0]
+
+        headers = [
+            (b":method", request.method),
+            (b":authority", authority),
+            (b":scheme", request.url.scheme),
+            (b":path", request.url.target),
+        ] + [
+            (k.lower(), v)
+            for k, v in request.headers
+            if k.lower()
+            not in (
+                b"host",
+                b"transfer-encoding",
+            )
+        ]
+
+        self._h2_state.send_headers(stream_id, headers, end_stream=end_stream)
+        self._h2_state.increment_flow_control_window(2**24, stream_id=stream_id)
+        await self._write_outgoing_data(request)
+
+    async def _send_request_body(self, request: Request, stream_id: int) -> None:
+        if not has_body_headers(request):
+            return
+
+        assert isinstance(request.stream, typing.AsyncIterable)
+        async for data in request.stream:
+            while data:
+                max_flow = await self._wait_for_outgoing_flow(request, stream_id)
+                chunk_size = min(len(data), max_flow)
+                chunk, data = data[:chunk_size], data[chunk_size:]
+                self._h2_state.send_data(stream_id, chunk)
+                await self._write_outgoing_data(request)
+
+        self._h2_state.end_stream(stream_id)
+        await self._write_outgoing_data(request)
+
+    # Receiving the response...
+
+    async def _receive_response(
+        self, request: Request, stream_id: int
+    ) -> typing.Tuple[int, typing.List[typing.Tuple[bytes, bytes]]]:
+        while True:
+            event = await self._receive_stream_event(request, stream_id)
+            if isinstance(event, h2.events.ResponseReceived):
+                break
+
+        status_code = 200
+        headers = []
+        for k, v in event.headers:
+            if k == b":status":
+                status_code = int(v.decode("ascii", errors="ignore"))
+            elif not k.startswith(b":"):
+                headers.append((k, v))
+
+        return (status_code, headers)
+
+    async def _receive_response_body(
+        self, request: Request, stream_id: int
+    ) -> typing.AsyncIterator[bytes]:
+        while True:
+            event = await self._receive_stream_event(request, stream_id)
+            if isinstance(event, h2.events.DataReceived):
+                amount = event.flow_controlled_length
+                self._h2_state.acknowledge_received_data(amount, stream_id)
+                await self._write_outgoing_data(request)
+                yield event.data
+            elif isinstance(event, (h2.events.StreamEnded, h2.events.StreamReset)):
+                break
+
+    async def _receive_stream_event(
+        self, request: Request, stream_id: int
+    ) -> h2.events.Event:
+        while not self._events.get(stream_id):
+            await self._receive_events(request, stream_id)
+        event = self._events[stream_id].pop(0)
+        # The StreamReset event applies to a single stream.
+        if hasattr(event, "error_code"):
+            raise RemoteProtocolError(event)
+        return event
+
+    async def _receive_events(
+        self, request: Request, stream_id: typing.Optional[int] = None
+    ) -> None:
+        async with self._read_lock:
+            if self._connection_error_event is not None:  # pragma: nocover
+                raise RemoteProtocolError(self._connection_error_event)
+
+            # This conditional is a bit icky. We don't want to block reading if we've
+            # actually got an event to return for a given stream. We need to do that
+            # check *within* the atomic read lock. Though it also need to be optional,
+            # because when we call it from `_wait_for_outgoing_flow` we *do* want to
+            # block until we've available flow control, event when we have events
+            # pending for the stream ID we're attempting to send on.
+            if stream_id is None or not self._events.get(stream_id):
+                events = await self._read_incoming_data(request)
+                for event in events:
+                    event_stream_id = getattr(event, "stream_id", 0)
+
+                    # The ConnectionTerminatedEvent applies to the entire connection,
+                    # and should be saved so it can be raised on all streams.
+                    if hasattr(event, "error_code") and event_stream_id == 0:
+                        self._connection_error_event = event
+                        raise RemoteProtocolError(event)
+
+                    if event_stream_id in self._events:
+                        self._events[event_stream_id].append(event)
+
+        await self._write_outgoing_data(request)
+
+    async def _response_closed(self, stream_id: int) -> None:
+        await self._max_streams_semaphore.release()
+        del self._events[stream_id]
+        async with self._state_lock:
+            if self._state == HTTPConnectionState.ACTIVE and not self._events:
+                self._state = HTTPConnectionState.IDLE
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+                if self._used_all_stream_ids:  # pragma: nocover
+                    await self.aclose()
+
+    async def aclose(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._h2_state.close_connection()
+        self._state = HTTPConnectionState.CLOSED
+        await self._network_stream.aclose()
+
+    # Wrappers around network read/write operations...
+
+    async def _read_incoming_data(
+        self, request: Request
+    ) -> typing.List[h2.events.Event]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        if self._read_exception is not None:
+            raise self._read_exception  # pragma: nocover
+
+        try:
+            data = await self._network_stream.read(self.READ_NUM_BYTES, timeout)
+            if data == b"":
+                raise RemoteProtocolError("Server disconnected")
+        except Exception as exc:
+            # If we get a network error we should:
+            #
+            # 1. Save the exception and just raise it immediately on any future reads.
+            #    (For example, this means that a single read timeout or disconnect will
+            #    immediately close all pending streams. Without requiring multiple
+            #    sequential timeouts.)
+            # 2. Mark the connection as errored, so that we don't accept any other
+            #    incoming requests.
+            self._read_exception = exc
+            self._connection_error = True
+            raise exc
+
+        events = self._h2_state.receive_data(data)
+
+        return events
+
+    async def _write_outgoing_data(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        async with self._write_lock:
+            data_to_send = self._h2_state.data_to_send()
+
+            if self._write_exception is not None:
+                raise self._write_exception  # pragma: nocover
+
+            try:
+                await self._network_stream.write(data_to_send, timeout)
+            except Exception as exc:  # pragma: nocover
+                # If we get a network error we should:
+                #
+                # 1. Save the exception and just raise it immediately on any future write.
+                #    (For example, this means that a single write timeout or disconnect will
+                #    immediately close all pending streams. Without requiring multiple
+                #    sequential timeouts.)
+                # 2. Mark the connection as errored, so that we don't accept any other
+                #    incoming requests.
+                self._write_exception = exc
+                self._connection_error = True
+                raise exc
+
+    # Flow control...
+
+    async def _wait_for_outgoing_flow(self, request: Request, stream_id: int) -> int:
+        """
+        Returns the maximum allowable outgoing flow for a given stream.
+
+        If the allowable flow is zero, then waits on the network until
+        WindowUpdated frames have increased the flow rate.
+        https://tools.ietf.org/html/rfc7540#section-6.9
+        """
+        local_flow = self._h2_state.local_flow_control_window(stream_id)
+        max_frame_size = self._h2_state.max_outbound_frame_size
+        flow = min(local_flow, max_frame_size)
+        while flow == 0:
+            await self._receive_events(request)
+            local_flow = self._h2_state.local_flow_control_window(stream_id)
+            max_frame_size = self._h2_state.max_outbound_frame_size
+            flow = min(local_flow, max_frame_size)
+        return flow
+
+    # Interface for connection pooling...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_available(self) -> bool:
+        return (
+            self._state != HTTPConnectionState.CLOSED
+            and not self._connection_error
+            and not self._used_all_stream_ids
+        )
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        return self._expire_at is not None and now > self._expire_at
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return (
+            f"{origin!r}, HTTP/2, {self._state.name}, "
+            f"Request Count: {self._request_count}"
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return (
+            f"<{class_name} [{origin!r}, {self._state.name}, "
+            f"Request Count: {self._request_count}]>"
+        )
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    async def __aenter__(self) -> "AsyncHTTP2Connection":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]] = None,
+        exc_value: typing.Optional[BaseException] = None,
+        traceback: typing.Optional[types.TracebackType] = None,
+    ) -> None:
+        await self.aclose()
+
+
+class HTTP2ConnectionByteStream:
+    def __init__(
+        self, connection: AsyncHTTP2Connection, request: Request, stream_id: int
+    ) -> None:
+        self._connection = connection
+        self._request = request
+        self._stream_id = stream_id
+        self._closed = False
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        kwargs = {"request": self._request, "stream_id": self._stream_id}
+        try:
+            async with Trace("http2.receive_response_body", self._request, kwargs):
+                async for chunk in self._connection._receive_response_body(
+                    request=self._request, stream_id=self._stream_id
+                ):
+                    yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            await self.aclose()
+            raise exc
+
+    async def aclose(self) -> None:
+        if not self._closed:
+            self._closed = True
+            kwargs = {"stream_id": self._stream_id}
+            async with Trace("http2.response_closed", self._request, kwargs):
+                await self._connection._response_closed(stream_id=self._stream_id)
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_async/http_proxy.py b/myenv/lib/python3.9/site-packages/httpcore/_async/http_proxy.py
new file mode 100644
index 0000000..48d37cd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_async/http_proxy.py
@@ -0,0 +1,337 @@
+import ssl
+from base64 import b64encode
+from typing import List, Mapping, Optional, Sequence, Tuple, Union
+
+from .._exceptions import ProxyError
+from .._models import (
+    URL,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+)
+from .._ssl import default_ssl_context
+from .._synchronization import AsyncLock
+from .._trace import Trace
+from ..backends.base import AsyncNetworkBackend
+from .connection import AsyncHTTPConnection
+from .connection_pool import AsyncConnectionPool
+from .http11 import AsyncHTTP11Connection
+from .interfaces import AsyncConnectionInterface
+
+HeadersAsSequence = Sequence[Tuple[Union[bytes, str], Union[bytes, str]]]
+HeadersAsMapping = Mapping[Union[bytes, str], Union[bytes, str]]
+
+
+def merge_headers(
+    default_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+    override_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+) -> List[Tuple[bytes, bytes]]:
+    """
+    Append default_headers and override_headers, de-duplicating if a key exists
+    in both cases.
+    """
+    default_headers = [] if default_headers is None else list(default_headers)
+    override_headers = [] if override_headers is None else list(override_headers)
+    has_override = set([key.lower() for key, value in override_headers])
+    default_headers = [
+        (key, value)
+        for key, value in default_headers
+        if key.lower() not in has_override
+    ]
+    return default_headers + override_headers
+
+
+def build_auth_header(username: bytes, password: bytes) -> bytes:
+    userpass = username + b":" + password
+    return b"Basic " + b64encode(userpass)
+
+
+class AsyncHTTPProxy(AsyncConnectionPool):
+    """
+    A connection pool that sends requests via an HTTP proxy.
+    """
+
+    def __init__(
+        self,
+        proxy_url: Union[URL, bytes, str],
+        proxy_auth: Optional[Tuple[Union[bytes, str], Union[bytes, str]]] = None,
+        proxy_headers: Union[HeadersAsMapping, HeadersAsSequence, None] = None,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        max_connections: Optional[int] = 10,
+        max_keepalive_connections: Optional[int] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[AsyncNetworkBackend] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            proxy_auth: Any proxy authentication as a two-tuple of
+                (username, password). May be either bytes or ascii-only str.
+            proxy_headers: Any HTTP headers to use for the proxy requests.
+                For example `{"Proxy-Authorization": "Basic <username>:<password>"}`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        super().__init__(
+            ssl_context=ssl_context,
+            max_connections=max_connections,
+            max_keepalive_connections=max_keepalive_connections,
+            keepalive_expiry=keepalive_expiry,
+            http1=http1,
+            http2=http2,
+            network_backend=network_backend,
+            retries=retries,
+            local_address=local_address,
+            uds=uds,
+        )
+        self._ssl_context = ssl_context
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        if proxy_auth is not None:
+            username = enforce_bytes(proxy_auth[0], name="proxy_auth")
+            password = enforce_bytes(proxy_auth[1], name="proxy_auth")
+            authorization = build_auth_header(username, password)
+            self._proxy_headers = [
+                (b"Proxy-Authorization", authorization)
+            ] + self._proxy_headers
+
+    def create_connection(self, origin: Origin) -> AsyncConnectionInterface:
+        if origin.scheme == b"http":
+            return AsyncForwardHTTPConnection(
+                proxy_origin=self._proxy_url.origin,
+                proxy_headers=self._proxy_headers,
+                keepalive_expiry=self._keepalive_expiry,
+                network_backend=self._network_backend,
+            )
+        return AsyncTunnelHTTPConnection(
+            proxy_origin=self._proxy_url.origin,
+            proxy_headers=self._proxy_headers,
+            remote_origin=origin,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
+        )
+
+
+class AsyncForwardHTTPConnection(AsyncConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        proxy_headers: Union[HeadersAsMapping, HeadersAsSequence, None] = None,
+        keepalive_expiry: Optional[float] = None,
+        network_backend: Optional[AsyncNetworkBackend] = None,
+    ) -> None:
+        self._connection = AsyncHTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+        )
+        self._proxy_origin = proxy_origin
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+
+    async def handle_async_request(self, request: Request) -> Response:
+        headers = merge_headers(self._proxy_headers, request.headers)
+        url = URL(
+            scheme=self._proxy_origin.scheme,
+            host=self._proxy_origin.host,
+            port=self._proxy_origin.port,
+            target=bytes(request.url),
+        )
+        proxy_request = Request(
+            method=request.method,
+            url=url,
+            headers=headers,
+            content=request.stream,
+            extensions=request.extensions,
+        )
+        return await self._connection.handle_async_request(proxy_request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin.scheme == b"http"
+
+    async def aclose(self) -> None:
+        await self._connection.aclose()
+
+    def info(self) -> str:
+        return self._connection.info()
+
+    def is_available(self) -> bool:
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
+
+
+class AsyncTunnelHTTPConnection(AsyncConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        proxy_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: Optional[AsyncNetworkBackend] = None,
+    ) -> None:
+        self._connection: AsyncConnectionInterface = AsyncHTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+        )
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._ssl_context = ssl_context
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._connect_lock = AsyncLock()
+        self._connected = False
+
+    async def handle_async_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("connect", None)
+
+        async with self._connect_lock:
+            if not self._connected:
+                target = b"%b:%d" % (self._remote_origin.host, self._remote_origin.port)
+
+                connect_url = URL(
+                    scheme=self._proxy_origin.scheme,
+                    host=self._proxy_origin.host,
+                    port=self._proxy_origin.port,
+                    target=target,
+                )
+                connect_headers = merge_headers(
+                    [(b"Host", target), (b"Accept", b"*/*")], self._proxy_headers
+                )
+                connect_request = Request(
+                    method=b"CONNECT",
+                    url=connect_url,
+                    headers=connect_headers,
+                    extensions=request.extensions,
+                )
+                connect_response = await self._connection.handle_async_request(
+                    connect_request
+                )
+
+                if connect_response.status < 200 or connect_response.status > 299:
+                    reason_bytes = connect_response.extensions.get("reason_phrase", b"")
+                    reason_str = reason_bytes.decode("ascii", errors="ignore")
+                    msg = "%d %s" % (connect_response.status, reason_str)
+                    await self._connection.aclose()
+                    raise ProxyError(msg)
+
+                stream = connect_response.extensions["network_stream"]
+
+                # Upgrade the stream to SSL
+                ssl_context = (
+                    default_ssl_context()
+                    if self._ssl_context is None
+                    else self._ssl_context
+                )
+                alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+                ssl_context.set_alpn_protocols(alpn_protocols)
+
+                kwargs = {
+                    "ssl_context": ssl_context,
+                    "server_hostname": self._remote_origin.host.decode("ascii"),
+                    "timeout": timeout,
+                }
+                async with Trace("connection.start_tls", request, kwargs) as trace:
+                    stream = await stream.start_tls(**kwargs)
+                    trace.return_value = stream
+
+                # Determine if we should be using HTTP/1.1 or HTTP/2
+                ssl_object = stream.get_extra_info("ssl_object")
+                http2_negotiated = (
+                    ssl_object is not None
+                    and ssl_object.selected_alpn_protocol() == "h2"
+                )
+
+                # Create the HTTP/1.1 or HTTP/2 connection
+                if http2_negotiated or (self._http2 and not self._http1):
+                    from .http2 import AsyncHTTP2Connection
+
+                    self._connection = AsyncHTTP2Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+                else:
+                    self._connection = AsyncHTTP11Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+
+                self._connected = True
+        return await self._connection.handle_async_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    async def aclose(self) -> None:
+        await self._connection.aclose()
+
+    def info(self) -> str:
+        return self._connection.info()
+
+    def is_available(self) -> bool:
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_async/interfaces.py b/myenv/lib/python3.9/site-packages/httpcore/_async/interfaces.py
new file mode 100644
index 0000000..c3ffa2a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_async/interfaces.py
@@ -0,0 +1,133 @@
+from contextlib import asynccontextmanager
+from typing import AsyncIterator, Optional, Union
+
+from .._models import (
+    URL,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+    include_request_headers,
+)
+
+
+class AsyncRequestInterface:
+    async def request(
+        self,
+        method: Union[bytes, str],
+        url: Union[URL, bytes, str],
+        *,
+        headers: Union[dict, list, None] = None,
+        content: Union[bytes, AsyncIterator[bytes], None] = None,
+        extensions: Optional[dict] = None,
+    ) -> Response:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = await self.handle_async_request(request)
+        try:
+            await response.aread()
+        finally:
+            await response.aclose()
+        return response
+
+    @asynccontextmanager
+    async def stream(
+        self,
+        method: Union[bytes, str],
+        url: Union[URL, bytes, str],
+        *,
+        headers: Union[dict, list, None] = None,
+        content: Union[bytes, AsyncIterator[bytes], None] = None,
+        extensions: Optional[dict] = None,
+    ) -> AsyncIterator[Response]:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = await self.handle_async_request(request)
+        try:
+            yield response
+        finally:
+            await response.aclose()
+
+    async def handle_async_request(self, request: Request) -> Response:
+        raise NotImplementedError()  # pragma: nocover
+
+
+class AsyncConnectionInterface(AsyncRequestInterface):
+    async def aclose(self) -> None:
+        raise NotImplementedError()  # pragma: nocover
+
+    def info(self) -> str:
+        raise NotImplementedError()  # pragma: nocover
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_available(self) -> bool:
+        """
+        Return `True` if the connection is currently able to accept an
+        outgoing request.
+
+        An HTTP/1.1 connection will only be available if it is currently idle.
+
+        An HTTP/2 connection will be available so long as the stream ID space is
+        not yet exhausted, and the connection is not in an error state.
+
+        While the connection is being established we may not yet know if it is going
+        to result in an HTTP/1.1 or HTTP/2 connection. The connection should be
+        treated as being available, but might ultimately raise `NewConnectionRequired`
+        required exceptions if multiple requests are attempted over a connection
+        that ends up being established as HTTP/1.1.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def has_expired(self) -> bool:
+        """
+        Return `True` if the connection is in a state where it should be closed.
+
+        This either means that the connection is idle and it has passed the
+        expiry time on its keep-alive, or that server has sent an EOF.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_idle(self) -> bool:
+        """
+        Return `True` if the connection is currently idle.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_closed(self) -> bool:
+        """
+        Return `True` if the connection has been closed.
+
+        Used when a response is closed to determine if the connection may be
+        returned to the connection pool or not.
+        """
+        raise NotImplementedError()  # pragma: nocover
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_async/socks_proxy.py b/myenv/lib/python3.9/site-packages/httpcore/_async/socks_proxy.py
new file mode 100644
index 0000000..fcba9e5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_async/socks_proxy.py
@@ -0,0 +1,336 @@
+import ssl
+import typing
+
+from socksio import socks5
+
+from .._exceptions import ConnectionNotAvailable, ProxyError
+from .._models import URL, Origin, Request, Response, enforce_bytes, enforce_url
+from .._ssl import default_ssl_context
+from .._synchronization import AsyncLock
+from .._trace import Trace
+from ..backends.auto import AutoBackend
+from ..backends.base import AsyncNetworkBackend, AsyncNetworkStream
+from .connection_pool import AsyncConnectionPool
+from .http11 import AsyncHTTP11Connection
+from .interfaces import AsyncConnectionInterface
+
+AUTH_METHODS = {
+    b"\x00": "NO AUTHENTICATION REQUIRED",
+    b"\x01": "GSSAPI",
+    b"\x02": "USERNAME/PASSWORD",
+    b"\xff": "NO ACCEPTABLE METHODS",
+}
+
+REPLY_CODES = {
+    b"\x00": "Succeeded",
+    b"\x01": "General SOCKS server failure",
+    b"\x02": "Connection not allowed by ruleset",
+    b"\x03": "Network unreachable",
+    b"\x04": "Host unreachable",
+    b"\x05": "Connection refused",
+    b"\x06": "TTL expired",
+    b"\x07": "Command not supported",
+    b"\x08": "Address type not supported",
+}
+
+
+async def _init_socks5_connection(
+    stream: AsyncNetworkStream,
+    *,
+    host: bytes,
+    port: int,
+    auth: typing.Optional[typing.Tuple[bytes, bytes]] = None,
+) -> None:
+    conn = socks5.SOCKS5Connection()
+
+    # Auth method request
+    auth_method = (
+        socks5.SOCKS5AuthMethod.NO_AUTH_REQUIRED
+        if auth is None
+        else socks5.SOCKS5AuthMethod.USERNAME_PASSWORD
+    )
+    conn.send(socks5.SOCKS5AuthMethodsRequest([auth_method]))
+    outgoing_bytes = conn.data_to_send()
+    await stream.write(outgoing_bytes)
+
+    # Auth method response
+    incoming_bytes = await stream.read(max_bytes=4096)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socks5.SOCKS5AuthReply)
+    if response.method != auth_method:
+        requested = AUTH_METHODS.get(auth_method, "UNKNOWN")
+        responded = AUTH_METHODS.get(response.method, "UNKNOWN")
+        raise ProxyError(
+            f"Requested {requested} from proxy server, but got {responded}."
+        )
+
+    if response.method == socks5.SOCKS5AuthMethod.USERNAME_PASSWORD:
+        # Username/password request
+        assert auth is not None
+        username, password = auth
+        conn.send(socks5.SOCKS5UsernamePasswordRequest(username, password))
+        outgoing_bytes = conn.data_to_send()
+        await stream.write(outgoing_bytes)
+
+        # Username/password response
+        incoming_bytes = await stream.read(max_bytes=4096)
+        response = conn.receive_data(incoming_bytes)
+        assert isinstance(response, socks5.SOCKS5UsernamePasswordReply)
+        if not response.success:
+            raise ProxyError("Invalid username/password")
+
+    # Connect request
+    conn.send(
+        socks5.SOCKS5CommandRequest.from_address(
+            socks5.SOCKS5Command.CONNECT, (host, port)
+        )
+    )
+    outgoing_bytes = conn.data_to_send()
+    await stream.write(outgoing_bytes)
+
+    # Connect response
+    incoming_bytes = await stream.read(max_bytes=4096)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socks5.SOCKS5Reply)
+    if response.reply_code != socks5.SOCKS5ReplyCode.SUCCEEDED:
+        reply_code = REPLY_CODES.get(response.reply_code, "UNKOWN")
+        raise ProxyError(f"Proxy Server could not connect: {reply_code}.")
+
+
+class AsyncSOCKSProxy(AsyncConnectionPool):
+    """
+    A connection pool that sends requests via an HTTP proxy.
+    """
+
+    def __init__(
+        self,
+        proxy_url: typing.Union[URL, bytes, str],
+        proxy_auth: typing.Optional[
+            typing.Tuple[typing.Union[bytes, str], typing.Union[bytes, str]]
+        ] = None,
+        ssl_context: typing.Optional[ssl.SSLContext] = None,
+        max_connections: typing.Optional[int] = 10,
+        max_keepalive_connections: typing.Optional[int] = None,
+        keepalive_expiry: typing.Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: typing.Optional[AsyncNetworkBackend] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        super().__init__(
+            ssl_context=ssl_context,
+            max_connections=max_connections,
+            max_keepalive_connections=max_keepalive_connections,
+            keepalive_expiry=keepalive_expiry,
+            http1=http1,
+            http2=http2,
+            network_backend=network_backend,
+        )
+        self._ssl_context = ssl_context
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
+        if proxy_auth is not None:
+            username, password = proxy_auth
+            username_bytes = enforce_bytes(username, name="proxy_auth")
+            password_bytes = enforce_bytes(password, name="proxy_auth")
+            self._proxy_auth: typing.Optional[typing.Tuple[bytes, bytes]] = (
+                username_bytes,
+                password_bytes,
+            )
+        else:
+            self._proxy_auth = None
+
+    def create_connection(self, origin: Origin) -> AsyncConnectionInterface:
+        return AsyncSocks5Connection(
+            proxy_origin=self._proxy_url.origin,
+            remote_origin=origin,
+            proxy_auth=self._proxy_auth,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
+        )
+
+
+class AsyncSocks5Connection(AsyncConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        proxy_auth: typing.Optional[typing.Tuple[bytes, bytes]] = None,
+        ssl_context: typing.Optional[ssl.SSLContext] = None,
+        keepalive_expiry: typing.Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: typing.Optional[AsyncNetworkBackend] = None,
+    ) -> None:
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._proxy_auth = proxy_auth
+        self._ssl_context = ssl_context
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+
+        self._network_backend: AsyncNetworkBackend = (
+            AutoBackend() if network_backend is None else network_backend
+        )
+        self._connect_lock = AsyncLock()
+        self._connection: typing.Optional[AsyncConnectionInterface] = None
+        self._connect_failed = False
+
+    async def handle_async_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("connect", None)
+
+        async with self._connect_lock:
+            if self._connection is None:
+                try:
+                    # Connect to the proxy
+                    kwargs = {
+                        "host": self._proxy_origin.host.decode("ascii"),
+                        "port": self._proxy_origin.port,
+                        "timeout": timeout,
+                    }
+                    with Trace("connection.connect_tcp", request, kwargs) as trace:
+                        stream = await self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
+
+                    # Connect to the remote host using socks5
+                    kwargs = {
+                        "stream": stream,
+                        "host": self._remote_origin.host.decode("ascii"),
+                        "port": self._remote_origin.port,
+                        "auth": self._proxy_auth,
+                    }
+                    with Trace(
+                        "connection.setup_socks5_connection", request, kwargs
+                    ) as trace:
+                        await _init_socks5_connection(**kwargs)
+                        trace.return_value = stream
+
+                    # Upgrade the stream to SSL
+                    if self._remote_origin.scheme == b"https":
+                        ssl_context = (
+                            default_ssl_context()
+                            if self._ssl_context is None
+                            else self._ssl_context
+                        )
+                        alpn_protocols = (
+                            ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+                        )
+                        ssl_context.set_alpn_protocols(alpn_protocols)
+
+                        kwargs = {
+                            "ssl_context": ssl_context,
+                            "server_hostname": self._remote_origin.host.decode("ascii"),
+                            "timeout": timeout,
+                        }
+                        async with Trace(
+                            "connection.start_tls", request, kwargs
+                        ) as trace:
+                            stream = await stream.start_tls(**kwargs)
+                            trace.return_value = stream
+
+                    # Determine if we should be using HTTP/1.1 or HTTP/2
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = (
+                        ssl_object is not None
+                        and ssl_object.selected_alpn_protocol() == "h2"
+                    )
+
+                    # Create the HTTP/1.1 or HTTP/2 connection
+                    if http2_negotiated or (
+                        self._http2 and not self._http1
+                    ):  # pragma: nocover
+                        from .http2 import AsyncHTTP2Connection
+
+                        self._connection = AsyncHTTP2Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = AsyncHTTP11Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                except Exception as exc:
+                    self._connect_failed = True
+                    raise exc
+            elif not self._connection.is_available():  # pragma: nocover
+                raise ConnectionNotAvailable()
+
+        return await self._connection.handle_async_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    async def aclose(self) -> None:
+        if self._connection is not None:
+            await self._connection.aclose()
+
+    def is_available(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return (
+                self._http2
+                and (self._remote_origin.scheme == b"https" or not self._http1)
+                and not self._connect_failed
+            )
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:  # pragma: nocover
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_exceptions.py b/myenv/lib/python3.9/site-packages/httpcore/_exceptions.py
new file mode 100644
index 0000000..f28dcc2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_exceptions.py
@@ -0,0 +1,79 @@
+import contextlib
+from typing import Dict, Iterator, Type
+
+
+@contextlib.contextmanager
+def map_exceptions(map: Dict[Type, Type]) -> Iterator[None]:
+    try:
+        yield
+    except Exception as exc:  # noqa: PIE786
+        for from_exc, to_exc in map.items():
+            if isinstance(exc, from_exc):
+                raise to_exc(exc)
+        raise  # pragma: nocover
+
+
+class ConnectionNotAvailable(Exception):
+    pass
+
+
+class ProxyError(Exception):
+    pass
+
+
+class UnsupportedProtocol(Exception):
+    pass
+
+
+class ProtocolError(Exception):
+    pass
+
+
+class RemoteProtocolError(ProtocolError):
+    pass
+
+
+class LocalProtocolError(ProtocolError):
+    pass
+
+
+# Timeout errors
+
+
+class TimeoutException(Exception):
+    pass
+
+
+class PoolTimeout(TimeoutException):
+    pass
+
+
+class ConnectTimeout(TimeoutException):
+    pass
+
+
+class ReadTimeout(TimeoutException):
+    pass
+
+
+class WriteTimeout(TimeoutException):
+    pass
+
+
+# Network errors
+
+
+class NetworkError(Exception):
+    pass
+
+
+class ConnectError(NetworkError):
+    pass
+
+
+class ReadError(NetworkError):
+    pass
+
+
+class WriteError(NetworkError):
+    pass
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_models.py b/myenv/lib/python3.9/site-packages/httpcore/_models.py
new file mode 100644
index 0000000..170011c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_models.py
@@ -0,0 +1,474 @@
+from typing import (
+    Any,
+    AsyncIterable,
+    AsyncIterator,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
+from urllib.parse import urlparse
+
+# Functions for typechecking...
+
+
+HeadersAsSequence = Sequence[Tuple[Union[bytes, str], Union[bytes, str]]]
+HeadersAsMapping = Mapping[Union[bytes, str], Union[bytes, str]]
+
+
+def enforce_bytes(value: Union[bytes, str], *, name: str) -> bytes:
+    """
+    Any arguments that are ultimately represented as bytes can be specified
+    either as bytes or as strings.
+
+    However we enforce that any string arguments must only contain characters in
+    the plain ASCII range. chr(0)...chr(127). If you need to use characters
+    outside that range then be precise, and use a byte-wise argument.
+    """
+    if isinstance(value, str):
+        try:
+            return value.encode("ascii")
+        except UnicodeEncodeError:
+            raise TypeError(f"{name} strings may not include unicode characters.")
+    elif isinstance(value, bytes):
+        return value
+
+    seen_type = type(value).__name__
+    raise TypeError(f"{name} must be bytes or str, but got {seen_type}.")
+
+
+def enforce_url(value: Union["URL", bytes, str], *, name: str) -> "URL":
+    """
+    Type check for URL parameters.
+    """
+    if isinstance(value, (bytes, str)):
+        return URL(value)
+    elif isinstance(value, URL):
+        return value
+
+    seen_type = type(value).__name__
+    raise TypeError(f"{name} must be a URL, bytes, or str, but got {seen_type}.")
+
+
+def enforce_headers(
+    value: Union[HeadersAsMapping, HeadersAsSequence, None] = None, *, name: str
+) -> List[Tuple[bytes, bytes]]:
+    """
+    Convienence function that ensure all items in request or response headers
+    are either bytes or strings in the plain ASCII range.
+    """
+    if value is None:
+        return []
+    elif isinstance(value, Mapping):
+        return [
+            (
+                enforce_bytes(k, name="header name"),
+                enforce_bytes(v, name="header value"),
+            )
+            for k, v in value.items()
+        ]
+    elif isinstance(value, Sequence):
+        return [
+            (
+                enforce_bytes(k, name="header name"),
+                enforce_bytes(v, name="header value"),
+            )
+            for k, v in value
+        ]
+
+    seen_type = type(value).__name__
+    raise TypeError(
+        f"{name} must be a mapping or sequence of two-tuples, but got {seen_type}."
+    )
+
+
+def enforce_stream(
+    value: Union[bytes, Iterable[bytes], AsyncIterable[bytes], None], *, name: str
+) -> Union[Iterable[bytes], AsyncIterable[bytes]]:
+    if value is None:
+        return ByteStream(b"")
+    elif isinstance(value, bytes):
+        return ByteStream(value)
+    return value
+
+
+# * https://tools.ietf.org/html/rfc3986#section-3.2.3
+# * https://url.spec.whatwg.org/#url-miscellaneous
+# * https://url.spec.whatwg.org/#scheme-state
+DEFAULT_PORTS = {
+    b"ftp": 21,
+    b"http": 80,
+    b"https": 443,
+    b"ws": 80,
+    b"wss": 443,
+}
+
+
+def include_request_headers(
+    headers: List[Tuple[bytes, bytes]],
+    *,
+    url: "URL",
+    content: Union[None, bytes, Iterable[bytes], AsyncIterable[bytes]],
+) -> List[Tuple[bytes, bytes]]:
+    headers_set = set([k.lower() for k, v in headers])
+
+    if b"host" not in headers_set:
+        default_port = DEFAULT_PORTS.get(url.scheme)
+        if url.port is None or url.port == default_port:
+            header_value = url.host
+        else:
+            header_value = b"%b:%d" % (url.host, url.port)
+        headers = [(b"Host", header_value)] + headers
+
+    if (
+        content is not None
+        and b"content-length" not in headers_set
+        and b"transfer-encoding" not in headers_set
+    ):
+        if isinstance(content, bytes):
+            content_length = str(len(content)).encode("ascii")
+            headers += [(b"Content-Length", content_length)]
+        else:
+            headers += [(b"Transfer-Encoding", b"chunked")]  # pragma: nocover
+
+    return headers
+
+
+# Interfaces for byte streams...
+
+
+class ByteStream:
+    """
+    A container for non-streaming content, and that supports both sync and async
+    stream iteration.
+    """
+
+    def __init__(self, content: bytes) -> None:
+        self._content = content
+
+    def __iter__(self) -> Iterator[bytes]:
+        yield self._content
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        yield self._content
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{len(self._content)} bytes]>"
+
+
+class Origin:
+    def __init__(self, scheme: bytes, host: bytes, port: int) -> None:
+        self.scheme = scheme
+        self.host = host
+        self.port = port
+
+    def __eq__(self, other: Any) -> bool:
+        return (
+            isinstance(other, Origin)
+            and self.scheme == other.scheme
+            and self.host == other.host
+            and self.port == other.port
+        )
+
+    def __str__(self) -> str:
+        scheme = self.scheme.decode("ascii")
+        host = self.host.decode("ascii")
+        port = str(self.port)
+        return f"{scheme}://{host}:{port}"
+
+
+class URL:
+    """
+    Represents the URL against which an HTTP request may be made.
+
+    The URL may either be specified as a plain string, for convienence:
+
+    ```python
+    url = httpcore.URL("https://www.example.com/")
+    ```
+
+    Or be constructed with explicitily pre-parsed components:
+
+    ```python
+    url = httpcore.URL(scheme=b'https', host=b'www.example.com', port=None, target=b'/')
+    ```
+
+    Using this second more explicit style allows integrations that are using
+    `httpcore` to pass through URLs that have already been parsed in order to use
+    libraries such as `rfc-3986` rather than relying on the stdlib. It also ensures
+    that URL parsing is treated identically at both the networking level and at any
+    higher layers of abstraction.
+
+    The four components are important here, as they allow the URL to be precisely
+    specified in a pre-parsed format. They also allow certain types of request to
+    be created that could not otherwise be expressed.
+
+    For example, an HTTP request to `http://www.example.com/` forwarded via a proxy
+    at `http://localhost:8080`...
+
+    ```python
+    # Constructs an HTTP request with a complete URL as the target:
+    # GET https://www.example.com/ HTTP/1.1
+    url = httpcore.URL(
+        scheme=b'http',
+        host=b'localhost',
+        port=8080,
+        target=b'https://www.example.com/'
+    )
+    request = httpcore.Request(
+        method="GET",
+        url=url
+    )
+    ```
+
+    Another example is constructing an `OPTIONS *` request...
+
+    ```python
+    # Constructs an 'OPTIONS *' HTTP request:
+    # OPTIONS * HTTP/1.1
+    url = httpcore.URL(scheme=b'https', host=b'www.example.com', target=b'*')
+    request = httpcore.Request(method="OPTIONS", url=url)
+    ```
+
+    This kind of request is not possible to formulate with a URL string,
+    because the `/` delimiter is always used to demark the target from the
+    host/port portion of the URL.
+
+    For convenience, string-like arguments may be specified either as strings or
+    as bytes. However, once a request is being issue over-the-wire, the URL
+    components are always ultimately required to be a bytewise representation.
+
+    In order to avoid any ambiguity over character encodings, when strings are used
+    as arguments, they must be strictly limited to the ASCII range `chr(0)`-`chr(127)`.
+    If you require a bytewise representation that is outside this range you must
+    handle the character encoding directly, and pass a bytes instance.
+    """
+
+    def __init__(
+        self,
+        url: Union[bytes, str] = "",
+        *,
+        scheme: Union[bytes, str] = b"",
+        host: Union[bytes, str] = b"",
+        port: Optional[int] = None,
+        target: Union[bytes, str] = b"",
+    ) -> None:
+        """
+        Parameters:
+            url: The complete URL as a string or bytes.
+            scheme: The URL scheme as a string or bytes.
+                Typically either `"http"` or `"https"`.
+            host: The URL host as a string or bytes. Such as `"www.example.com"`.
+            port: The port to connect to. Either an integer or `None`.
+            target: The target of the HTTP request. Such as `"/items?search=red"`.
+        """
+        if url:
+            parsed = urlparse(enforce_bytes(url, name="url"))
+            self.scheme = parsed.scheme
+            self.host = parsed.hostname or b""
+            self.port = parsed.port
+            self.target = (parsed.path or b"/") + (
+                b"?" + parsed.query if parsed.query else b""
+            )
+        else:
+            self.scheme = enforce_bytes(scheme, name="scheme")
+            self.host = enforce_bytes(host, name="host")
+            self.port = port
+            self.target = enforce_bytes(target, name="target")
+
+    @property
+    def origin(self) -> Origin:
+        default_port = {b"http": 80, b"https": 443, b"socks5": 1080}[self.scheme]
+        return Origin(
+            scheme=self.scheme, host=self.host, port=self.port or default_port
+        )
+
+    def __eq__(self, other: Any) -> bool:
+        return (
+            isinstance(other, URL)
+            and other.scheme == self.scheme
+            and other.host == self.host
+            and other.port == self.port
+            and other.target == self.target
+        )
+
+    def __bytes__(self) -> bytes:
+        if self.port is None:
+            return b"%b://%b%b" % (self.scheme, self.host, self.target)
+        return b"%b://%b:%d%b" % (self.scheme, self.host, self.port, self.target)
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}(scheme={self.scheme!r}, "
+            f"host={self.host!r}, port={self.port!r}, target={self.target!r})"
+        )
+
+
+class Request:
+    """
+    An HTTP request.
+    """
+
+    def __init__(
+        self,
+        method: Union[bytes, str],
+        url: Union[URL, bytes, str],
+        *,
+        headers: Union[dict, list, None] = None,
+        content: Union[bytes, Iterable[bytes], AsyncIterable[bytes], None] = None,
+        extensions: Optional[dict] = None,
+    ) -> None:
+        """
+        Parameters:
+            method: The HTTP request method, either as a string or bytes.
+                For example: `GET`.
+            url: The request URL, either as a `URL` instance, or as a string or bytes.
+                For example: `"https://www.example.com".`
+            headers: The HTTP request headers.
+            content: The content of the response body.
+            extensions: A dictionary of optional extra information included on
+                the request. Possible keys include `"timeout"`, and `"trace"`.
+        """
+        self.method: bytes = enforce_bytes(method, name="method")
+        self.url: URL = enforce_url(url, name="url")
+        self.headers: List[Tuple[bytes, bytes]] = enforce_headers(
+            headers, name="headers"
+        )
+        self.stream: Union[Iterable[bytes], AsyncIterable[bytes]] = enforce_stream(
+            content, name="content"
+        )
+        self.extensions = {} if extensions is None else extensions
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.method!r}]>"
+
+
+class Response:
+    """
+    An HTTP response.
+    """
+
+    def __init__(
+        self,
+        status: int,
+        *,
+        headers: Union[dict, list, None] = None,
+        content: Union[bytes, Iterable[bytes], AsyncIterable[bytes], None] = None,
+        extensions: Optional[dict] = None,
+    ) -> None:
+        """
+        Parameters:
+            status: The HTTP status code of the response. For example `200`.
+            headers: The HTTP response headers.
+            content: The content of the response body.
+            extensions: A dictionary of optional extra information included on
+                the responseself.Possible keys include `"http_version"`,
+                `"reason_phrase"`, and `"network_stream"`.
+        """
+        self.status: int = status
+        self.headers: List[Tuple[bytes, bytes]] = enforce_headers(
+            headers, name="headers"
+        )
+        self.stream: Union[Iterable[bytes], AsyncIterable[bytes]] = enforce_stream(
+            content, name="content"
+        )
+        self.extensions: dict = {} if extensions is None else extensions
+
+        self._stream_consumed = False
+
+    @property
+    def content(self) -> bytes:
+        if not hasattr(self, "_content"):
+            if isinstance(self.stream, Iterable):
+                raise RuntimeError(
+                    "Attempted to access 'response.content' on a streaming response. "
+                    "Call 'response.read()' first."
+                )
+            else:
+                raise RuntimeError(
+                    "Attempted to access 'response.content' on a streaming response. "
+                    "Call 'await response.aread()' first."
+                )
+        return self._content
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.status}]>"
+
+    # Sync interface...
+
+    def read(self) -> bytes:
+        if not isinstance(self.stream, Iterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to read an asynchronous response using 'response.read()'. "
+                "You should use 'await response.aread()' instead."
+            )
+        if not hasattr(self, "_content"):
+            self._content = b"".join([part for part in self.iter_stream()])
+        return self._content
+
+    def iter_stream(self) -> Iterator[bytes]:
+        if not isinstance(self.stream, Iterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to stream an asynchronous response using 'for ... in "
+                "response.iter_stream()'. "
+                "You should use 'async for ... in response.aiter_stream()' instead."
+            )
+        if self._stream_consumed:
+            raise RuntimeError(
+                "Attempted to call 'for ... in response.iter_stream()' more than once."
+            )
+        self._stream_consumed = True
+        for chunk in self.stream:
+            yield chunk
+
+    def close(self) -> None:
+        if not isinstance(self.stream, Iterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to close an asynchronous response using 'response.close()'. "
+                "You should use 'await response.aclose()' instead."
+            )
+        if hasattr(self.stream, "close"):
+            self.stream.close()  # type: ignore
+
+    # Async interface...
+
+    async def aread(self) -> bytes:
+        if not isinstance(self.stream, AsyncIterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to read an synchronous response using "
+                "'await response.aread()'. "
+                "You should use 'response.read()' instead."
+            )
+        if not hasattr(self, "_content"):
+            self._content = b"".join([part async for part in self.aiter_stream()])
+        return self._content
+
+    async def aiter_stream(self) -> AsyncIterator[bytes]:
+        if not isinstance(self.stream, AsyncIterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to stream an synchronous response using 'async for ... in "
+                "response.aiter_stream()'. "
+                "You should use 'for ... in response.iter_stream()' instead."
+            )
+        if self._stream_consumed:
+            raise RuntimeError(
+                "Attempted to call 'async for ... in response.aiter_stream()' "
+                "more than once."
+            )
+        self._stream_consumed = True
+        async for chunk in self.stream:
+            yield chunk
+
+    async def aclose(self) -> None:
+        if not isinstance(self.stream, AsyncIterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to close a synchronous response using "
+                "'await response.aclose()'. "
+                "You should use 'response.close()' instead."
+            )
+        if hasattr(self.stream, "aclose"):
+            await self.stream.aclose()  # type: ignore
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_ssl.py b/myenv/lib/python3.9/site-packages/httpcore/_ssl.py
new file mode 100644
index 0000000..629f002
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_ssl.py
@@ -0,0 +1,9 @@
+import ssl
+
+import certifi  # type: ignore
+
+
+def default_ssl_context() -> ssl.SSLContext:
+    context = ssl.create_default_context()
+    context.load_verify_locations(certifi.where())
+    return context
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_sync/__init__.py b/myenv/lib/python3.9/site-packages/httpcore/_sync/__init__.py
new file mode 100644
index 0000000..b476d76
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_sync/__init__.py
@@ -0,0 +1,39 @@
+from .connection import HTTPConnection
+from .connection_pool import ConnectionPool
+from .http11 import HTTP11Connection
+from .http_proxy import HTTPProxy
+from .interfaces import ConnectionInterface
+
+try:
+    from .http2 import HTTP2Connection
+except ImportError:  # pragma: nocover
+
+    class HTTP2Connection:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use http2 support, but the `h2` package is not "
+                "installed. Use 'pip install httpcore[http2]'."
+            )
+
+
+try:
+    from .socks_proxy import SOCKSProxy
+except ImportError:  # pragma: nocover
+
+    class SOCKSProxy:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use SOCKS support, but the `socksio` package is not "
+                "installed. Use 'pip install httpcore[socks]'."
+            )
+
+
+__all__ = [
+    "HTTPConnection",
+    "ConnectionPool",
+    "HTTPProxy",
+    "HTTP11Connection",
+    "HTTP2Connection",
+    "ConnectionInterface",
+    "SOCKSProxy",
+]
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_sync/connection.py b/myenv/lib/python3.9/site-packages/httpcore/_sync/connection.py
new file mode 100644
index 0000000..3312c2c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_sync/connection.py
@@ -0,0 +1,208 @@
+import itertools
+import ssl
+from types import TracebackType
+from typing import Iterator, Optional, Type
+
+from .._exceptions import ConnectError, ConnectionNotAvailable, ConnectTimeout
+from .._models import Origin, Request, Response
+from .._ssl import default_ssl_context
+from .._synchronization import Lock
+from .._trace import Trace
+from ..backends.sync import SyncBackend
+from ..backends.base import NetworkBackend, NetworkStream
+from .http11 import HTTP11Connection
+from .interfaces import ConnectionInterface
+
+RETRIES_BACKOFF_FACTOR = 0.5  # 0s, 0.5s, 1s, 2s, 4s, etc.
+
+
+def exponential_backoff(factor: float) -> Iterator[float]:
+    yield 0
+    for n in itertools.count(2):
+        yield factor * (2 ** (n - 2))
+
+
+class HTTPConnection(ConnectionInterface):
+    def __init__(
+        self,
+        origin: Origin,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[NetworkBackend] = None,
+    ) -> None:
+        self._origin = origin
+        self._ssl_context = ssl_context
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._retries = retries
+        self._local_address = local_address
+        self._uds = uds
+
+        self._network_backend: NetworkBackend = (
+            SyncBackend() if network_backend is None else network_backend
+        )
+        self._connection: Optional[ConnectionInterface] = None
+        self._connect_failed: bool = False
+        self._request_lock = Lock()
+
+    def handle_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection to {self._origin}"
+            )
+
+        with self._request_lock:
+            if self._connection is None:
+                try:
+                    stream = self._connect(request)
+
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = (
+                        ssl_object is not None
+                        and ssl_object.selected_alpn_protocol() == "h2"
+                    )
+                    if http2_negotiated or (self._http2 and not self._http1):
+                        from .http2 import HTTP2Connection
+
+                        self._connection = HTTP2Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = HTTP11Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                except Exception as exc:
+                    self._connect_failed = True
+                    raise exc
+            elif not self._connection.is_available():
+                raise ConnectionNotAvailable()
+
+        return self._connection.handle_request(request)
+
+    def _connect(self, request: Request) -> NetworkStream:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("connect", None)
+
+        retries_left = self._retries
+        delays = exponential_backoff(factor=RETRIES_BACKOFF_FACTOR)
+
+        while True:
+            try:
+                if self._uds is None:
+                    kwargs = {
+                        "host": self._origin.host.decode("ascii"),
+                        "port": self._origin.port,
+                        "local_address": self._local_address,
+                        "timeout": timeout,
+                    }
+                    with Trace(
+                        "connection.connect_tcp", request, kwargs
+                    ) as trace:
+                        stream = self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
+                else:
+                    kwargs = {
+                        "path": self._uds,
+                        "timeout": timeout,
+                    }
+                    with Trace(
+                        "connection.connect_unix_socket", request, kwargs
+                    ) as trace:
+                        stream = self._network_backend.connect_unix_socket(
+                            **kwargs
+                        )
+                        trace.return_value = stream
+            except (ConnectError, ConnectTimeout):
+                if retries_left <= 0:
+                    raise
+                retries_left -= 1
+                delay = next(delays)
+                # TRACE 'retry'
+                self._network_backend.sleep(delay)
+            else:
+                break
+
+        if self._origin.scheme == b"https":
+            ssl_context = (
+                default_ssl_context()
+                if self._ssl_context is None
+                else self._ssl_context
+            )
+            alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+            ssl_context.set_alpn_protocols(alpn_protocols)
+
+            kwargs = {
+                "ssl_context": ssl_context,
+                "server_hostname": self._origin.host.decode("ascii"),
+                "timeout": timeout,
+            }
+            with Trace("connection.start_tls", request, kwargs) as trace:
+                stream = stream.start_tls(**kwargs)
+                trace.return_value = stream
+        return stream
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def close(self) -> None:
+        if self._connection is not None:
+            self._connection.close()
+
+    def is_available(self) -> bool:
+        if self._connection is None:
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return (
+                self._http2
+                and (self._origin.scheme == b"https" or not self._http1)
+                and not self._connect_failed
+            )
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    def __enter__(self) -> "HTTPConnection":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        self.close()
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_sync/connection_pool.py b/myenv/lib/python3.9/site-packages/httpcore/_sync/connection_pool.py
new file mode 100644
index 0000000..88b2918
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_sync/connection_pool.py
@@ -0,0 +1,354 @@
+import ssl
+import sys
+from types import TracebackType
+from typing import Iterable, Iterator, List, Optional, Type
+
+from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
+from .._models import Origin, Request, Response
+from .._synchronization import Event, Lock
+from ..backends.sync import SyncBackend
+from ..backends.base import NetworkBackend
+from .connection import HTTPConnection
+from .interfaces import ConnectionInterface, RequestInterface
+
+
+class RequestStatus:
+    def __init__(self, request: Request):
+        self.request = request
+        self.connection: Optional[ConnectionInterface] = None
+        self._connection_acquired = Event()
+
+    def set_connection(self, connection: ConnectionInterface) -> None:
+        assert self.connection is None
+        self.connection = connection
+        self._connection_acquired.set()
+
+    def unset_connection(self) -> None:
+        assert self.connection is not None
+        self.connection = None
+        self._connection_acquired = Event()
+
+    def wait_for_connection(
+        self, timeout: Optional[float] = None
+    ) -> ConnectionInterface:
+        self._connection_acquired.wait(timeout=timeout)
+        assert self.connection is not None
+        return self.connection
+
+
+class ConnectionPool(RequestInterface):
+    """
+    A connection pool for making HTTP requests.
+    """
+
+    def __init__(
+        self,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        max_connections: Optional[int] = 10,
+        max_keepalive_connections: Optional[int] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[NetworkBackend] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish a
+                connection.
+            local_address: Local address to connect from. Can also be used to connect
+                using a particular address family. Using `local_address="0.0.0.0"`
+                will connect using an `AF_INET` address (IPv4), while using
+                `local_address="::"` will connect using an `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        self._ssl_context = ssl_context
+
+        self._max_connections = (
+            sys.maxsize if max_connections is None else max_connections
+        )
+        self._max_keepalive_connections = (
+            sys.maxsize
+            if max_keepalive_connections is None
+            else max_keepalive_connections
+        )
+        self._max_keepalive_connections = min(
+            self._max_connections, self._max_keepalive_connections
+        )
+
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._retries = retries
+        self._local_address = local_address
+        self._uds = uds
+
+        self._pool: List[ConnectionInterface] = []
+        self._requests: List[RequestStatus] = []
+        self._pool_lock = Lock()
+        self._network_backend = (
+            SyncBackend() if network_backend is None else network_backend
+        )
+
+    def create_connection(self, origin: Origin) -> ConnectionInterface:
+        return HTTPConnection(
+            origin=origin,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            retries=self._retries,
+            local_address=self._local_address,
+            uds=self._uds,
+            network_backend=self._network_backend,
+        )
+
+    @property
+    def connections(self) -> List[ConnectionInterface]:
+        """
+        Return a list of the connections currently in the pool.
+
+        For example:
+
+        ```python
+        >>> pool.connections
+        [
+            <HTTPConnection ['https://example.com:443', HTTP/1.1, ACTIVE, Request Count: 6]>,
+            <HTTPConnection ['https://example.com:443', HTTP/1.1, IDLE, Request Count: 9]> ,
+            <HTTPConnection ['http://example.com:80', HTTP/1.1, IDLE, Request Count: 1]>,
+        ]
+        ```
+        """
+        return list(self._pool)
+
+    def _attempt_to_acquire_connection(self, status: RequestStatus) -> bool:
+        """
+        Attempt to provide a connection that can handle the given origin.
+        """
+        origin = status.request.url.origin
+
+        # If there are queued requests in front of us, then don't acquire a
+        # connection. We handle requests strictly in order.
+        waiting = [s for s in self._requests if s.connection is None]
+        if waiting and waiting[0] is not status:
+            return False
+
+        # Reuse an existing connection if one is currently available.
+        for idx, connection in enumerate(self._pool):
+            if connection.can_handle_request(origin) and connection.is_available():
+                self._pool.pop(idx)
+                self._pool.insert(0, connection)
+                status.set_connection(connection)
+                return True
+
+        # If the pool is currently full, attempt to close one idle connection.
+        if len(self._pool) >= self._max_connections:
+            for idx, connection in reversed(list(enumerate(self._pool))):
+                if connection.is_idle():
+                    connection.close()
+                    self._pool.pop(idx)
+                    break
+
+        # If the pool is still full, then we cannot acquire a connection.
+        if len(self._pool) >= self._max_connections:
+            return False
+
+        # Otherwise create a new connection.
+        connection = self.create_connection(origin)
+        self._pool.insert(0, connection)
+        status.set_connection(connection)
+        return True
+
+    def _close_expired_connections(self) -> None:
+        """
+        Clean up the connection pool by closing off any connections that have expired.
+        """
+        # Close any connections that have expired their keep-alive time.
+        for idx, connection in reversed(list(enumerate(self._pool))):
+            if connection.has_expired():
+                connection.close()
+                self._pool.pop(idx)
+
+        # If the pool size exceeds the maximum number of allowed keep-alive connections,
+        # then close off idle connections as required.
+        pool_size = len(self._pool)
+        for idx, connection in reversed(list(enumerate(self._pool))):
+            if connection.is_idle() and pool_size > self._max_keepalive_connections:
+                connection.close()
+                self._pool.pop(idx)
+                pool_size -= 1
+
+    def handle_request(self, request: Request) -> Response:
+        """
+        Send an HTTP request, and return an HTTP response.
+
+        This is the core implementation that is called into by `.request()` or `.stream()`.
+        """
+        scheme = request.url.scheme.decode()
+        if scheme == "":
+            raise UnsupportedProtocol(
+                "Request URL is missing an 'http://' or 'https://' protocol."
+            )
+        if scheme not in ("http", "https"):
+            raise UnsupportedProtocol(
+                f"Request URL has an unsupported protocol '{scheme}://'."
+            )
+
+        status = RequestStatus(request)
+
+        with self._pool_lock:
+            self._requests.append(status)
+            self._close_expired_connections()
+            self._attempt_to_acquire_connection(status)
+
+        while True:
+            timeouts = request.extensions.get("timeout", {})
+            timeout = timeouts.get("pool", None)
+            try:
+                connection = status.wait_for_connection(timeout=timeout)
+            except BaseException as exc:
+                # If we timeout here, or if the task is cancelled, then make
+                # sure to remove the request from the queue before bubbling
+                # up the exception.
+                with self._pool_lock:
+                    self._requests.remove(status)
+                    raise exc
+
+            try:
+                response = connection.handle_request(request)
+            except ConnectionNotAvailable:
+                # The ConnectionNotAvailable exception is a special case, that
+                # indicates we need to retry the request on a new connection.
+                #
+                # The most common case where this can occur is when multiple
+                # requests are queued waiting for a single connection, which
+                # might end up as an HTTP/2 connection, but which actually ends
+                # up as HTTP/1.1.
+                with self._pool_lock:
+                    # Maintain our position in the request queue, but reset the
+                    # status so that the request becomes queued again.
+                    status.unset_connection()
+                    self._attempt_to_acquire_connection(status)
+            except BaseException as exc:
+                self.response_closed(status)
+                raise exc
+            else:
+                break
+
+        # When we return the response, we wrap the stream in a special class
+        # that handles notifying the connection pool once the response
+        # has been released.
+        assert isinstance(response.stream, Iterable)
+        return Response(
+            status=response.status,
+            headers=response.headers,
+            content=ConnectionPoolByteStream(response.stream, self, status),
+            extensions=response.extensions,
+        )
+
+    def response_closed(self, status: RequestStatus) -> None:
+        """
+        This method acts as a callback once the request/response cycle is complete.
+
+        It is called into from the `ConnectionPoolByteStream.close()` method.
+        """
+        assert status.connection is not None
+        connection = status.connection
+
+        with self._pool_lock:
+            # Update the state of the connection pool.
+            if status in self._requests:
+                self._requests.remove(status)
+
+            if connection.is_closed() and connection in self._pool:
+                self._pool.remove(connection)
+
+            # Since we've had a response closed, it's possible we'll now be able
+            # to service one or more requests that are currently pending.
+            for status in self._requests:
+                if status.connection is None:
+                    acquired = self._attempt_to_acquire_connection(status)
+                    # If we could not acquire a connection for a queued request
+                    # then we don't need to check anymore requests that are
+                    # queued later behind it.
+                    if not acquired:
+                        break
+
+            # Housekeeping.
+            self._close_expired_connections()
+
+    def close(self) -> None:
+        """
+        Close any connections in the pool.
+        """
+        with self._pool_lock:
+            requests_still_in_flight = len(self._requests)
+
+            for connection in self._pool:
+                connection.close()
+            self._pool = []
+            self._requests = []
+
+            if requests_still_in_flight:
+                raise RuntimeError(
+                    f"The connection pool was closed while {requests_still_in_flight} "
+                    f"HTTP requests/responses were still in-flight."
+                )
+
+    def __enter__(self) -> "ConnectionPool":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        self.close()
+
+
+class ConnectionPoolByteStream:
+    """
+    A wrapper around the response byte stream, that additionally handles
+    notifying the connection pool when the response has been closed.
+    """
+
+    def __init__(
+        self,
+        stream: Iterable[bytes],
+        pool: ConnectionPool,
+        status: RequestStatus,
+    ) -> None:
+        self._stream = stream
+        self._pool = pool
+        self._status = status
+
+    def __iter__(self) -> Iterator[bytes]:
+        for part in self._stream:
+            yield part
+
+    def close(self) -> None:
+        try:
+            if hasattr(self._stream, "close"):
+                self._stream.close()  # type: ignore
+        finally:
+            self._pool.response_closed(self._status)
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_sync/http11.py b/myenv/lib/python3.9/site-packages/httpcore/_sync/http11.py
new file mode 100644
index 0000000..d7ea275
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_sync/http11.py
@@ -0,0 +1,306 @@
+import enum
+import time
+from types import TracebackType
+from typing import Iterable, Iterator, List, Optional, Tuple, Type, Union
+
+import h11
+
+from .._exceptions import (
+    ConnectionNotAvailable,
+    LocalProtocolError,
+    RemoteProtocolError,
+    map_exceptions,
+)
+from .._models import Origin, Request, Response
+from .._synchronization import Lock
+from .._trace import Trace
+from ..backends.base import NetworkStream
+from .interfaces import ConnectionInterface
+
+H11Event = Union[
+    h11.Request,
+    h11.Response,
+    h11.InformationalResponse,
+    h11.Data,
+    h11.EndOfMessage,
+    h11.ConnectionClosed,
+]
+
+
+class HTTPConnectionState(enum.IntEnum):
+    NEW = 0
+    ACTIVE = 1
+    IDLE = 2
+    CLOSED = 3
+
+
+class HTTP11Connection(ConnectionInterface):
+    READ_NUM_BYTES = 64 * 1024
+
+    def __init__(
+        self,
+        origin: Origin,
+        stream: NetworkStream,
+        keepalive_expiry: Optional[float] = None,
+    ) -> None:
+        self._origin = origin
+        self._network_stream = stream
+        self._keepalive_expiry: Optional[float] = keepalive_expiry
+        self._expire_at: Optional[float] = None
+        self._state = HTTPConnectionState.NEW
+        self._state_lock = Lock()
+        self._request_count = 0
+        self._h11_state = h11.Connection(our_role=h11.CLIENT)
+
+    def handle_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection "
+                f"to {self._origin}"
+            )
+
+        with self._state_lock:
+            if self._state in (HTTPConnectionState.NEW, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._state = HTTPConnectionState.ACTIVE
+                self._expire_at = None
+            else:
+                raise ConnectionNotAvailable()
+
+        try:
+            kwargs = {"request": request}
+            with Trace("http11.send_request_headers", request, kwargs) as trace:
+                self._send_request_headers(**kwargs)
+            with Trace("http11.send_request_body", request, kwargs) as trace:
+                self._send_request_body(**kwargs)
+            with Trace(
+                "http11.receive_response_headers", request, kwargs
+            ) as trace:
+                (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                ) = self._receive_response_headers(**kwargs)
+                trace.return_value = (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                )
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP11ConnectionByteStream(self, request),
+                extensions={
+                    "http_version": http_version,
+                    "reason_phrase": reason_phrase,
+                    "network_stream": self._network_stream,
+                },
+            )
+        except BaseException as exc:
+            with Trace("http11.response_closed", request) as trace:
+                self._response_closed()
+            raise exc
+
+    # Sending the request...
+
+    def _send_request_headers(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        with map_exceptions({h11.LocalProtocolError: LocalProtocolError}):
+            event = h11.Request(
+                method=request.method,
+                target=request.url.target,
+                headers=request.headers,
+            )
+        self._send_event(event, timeout=timeout)
+
+    def _send_request_body(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        assert isinstance(request.stream, Iterable)
+        for chunk in request.stream:
+            event = h11.Data(data=chunk)
+            self._send_event(event, timeout=timeout)
+
+        event = h11.EndOfMessage()
+        self._send_event(event, timeout=timeout)
+
+    def _send_event(
+        self, event: H11Event, timeout: Optional[float] = None
+    ) -> None:
+        bytes_to_send = self._h11_state.send(event)
+        self._network_stream.write(bytes_to_send, timeout=timeout)
+
+    # Receiving the response...
+
+    def _receive_response_headers(
+        self, request: Request
+    ) -> Tuple[bytes, int, bytes, List[Tuple[bytes, bytes]]]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        while True:
+            event = self._receive_event(timeout=timeout)
+            if isinstance(event, h11.Response):
+                break
+
+        http_version = b"HTTP/" + event.http_version
+
+        # h11 version 0.11+ supports a `raw_items` interface to get the
+        # raw header casing, rather than the enforced lowercase headers.
+        headers = event.headers.raw_items()
+
+        return http_version, event.status_code, event.reason, headers
+
+    def _receive_response_body(self, request: Request) -> Iterator[bytes]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        while True:
+            event = self._receive_event(timeout=timeout)
+            if isinstance(event, h11.Data):
+                yield bytes(event.data)
+            elif isinstance(event, (h11.EndOfMessage, h11.PAUSED)):
+                break
+
+    def _receive_event(self, timeout: Optional[float] = None) -> H11Event:
+        while True:
+            with map_exceptions({h11.RemoteProtocolError: RemoteProtocolError}):
+                event = self._h11_state.next_event()
+
+            if event is h11.NEED_DATA:
+                data = self._network_stream.read(
+                    self.READ_NUM_BYTES, timeout=timeout
+                )
+
+                # If we feed this case through h11 we'll raise an exception like:
+                #
+                #     httpcore.RemoteProtocolError: can't handle event type
+                #     ConnectionClosed when role=SERVER and state=SEND_RESPONSE
+                #
+                # Which is accurate, but not very informative from an end-user
+                # perspective. Instead we handle this case distinctly and treat
+                # it as a ConnectError.
+                if data == b"" and self._h11_state.their_state == h11.SEND_RESPONSE:
+                    msg = "Server disconnected without sending a response."
+                    raise RemoteProtocolError(msg)
+
+                self._h11_state.receive_data(data)
+            else:
+                return event
+
+    def _response_closed(self) -> None:
+        with self._state_lock:
+            if (
+                self._h11_state.our_state is h11.DONE
+                and self._h11_state.their_state is h11.DONE
+            ):
+                self._state = HTTPConnectionState.IDLE
+                self._h11_state.start_next_cycle()
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+            else:
+                self.close()
+
+    # Once the connection is no longer required...
+
+    def close(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._state = HTTPConnectionState.CLOSED
+        self._network_stream.close()
+
+    # The ConnectionInterface methods provide information about the state of
+    # the connection, allowing for a connection pooling implementation to
+    # determine when to reuse and when to close the connection...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_available(self) -> bool:
+        # Note that HTTP/1.1 connections in the "NEW" state are not treated as
+        # being "available". The control flow which created the connection will
+        # be able to send an outgoing request, but the connection will not be
+        # acquired from the connection pool for any other request.
+        return self._state == HTTPConnectionState.IDLE
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        keepalive_expired = self._expire_at is not None and now > self._expire_at
+
+        # If the HTTP connection is idle but the socket is readable, then the
+        # only valid state is that the socket is about to return b"", indicating
+        # a server-initiated disconnect.
+        server_disconnected = (
+            self._state == HTTPConnectionState.IDLE
+            and self._network_stream.get_extra_info("is_readable")
+        )
+
+        return keepalive_expired or server_disconnected
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return (
+            f"{origin!r}, HTTP/1.1, {self._state.name}, "
+            f"Request Count: {self._request_count}"
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return (
+            f"<{class_name} [{origin!r}, {self._state.name}, "
+            f"Request Count: {self._request_count}]>"
+        )
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    def __enter__(self) -> "HTTP11Connection":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        self.close()
+
+
+class HTTP11ConnectionByteStream:
+    def __init__(self, connection: HTTP11Connection, request: Request) -> None:
+        self._connection = connection
+        self._request = request
+        self._closed = False
+
+    def __iter__(self) -> Iterator[bytes]:
+        kwargs = {"request": self._request}
+        try:
+            with Trace("http11.receive_response_body", self._request, kwargs):
+                for chunk in self._connection._receive_response_body(**kwargs):
+                    yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            self.close()
+            raise exc
+
+    def close(self) -> None:
+        if not self._closed:
+            self._closed = True
+            with Trace("http11.response_closed", self._request):
+                self._connection._response_closed()
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_sync/http2.py b/myenv/lib/python3.9/site-packages/httpcore/_sync/http2.py
new file mode 100644
index 0000000..5bd2de0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_sync/http2.py
@@ -0,0 +1,475 @@
+import enum
+import time
+import types
+import typing
+
+import h2.config
+import h2.connection
+import h2.events
+import h2.exceptions
+import h2.settings
+
+from .._exceptions import (
+    ConnectionNotAvailable,
+    LocalProtocolError,
+    RemoteProtocolError,
+)
+from .._models import Origin, Request, Response
+from .._synchronization import Lock, Semaphore
+from .._trace import Trace
+from ..backends.base import NetworkStream
+from .interfaces import ConnectionInterface
+
+
+def has_body_headers(request: Request) -> bool:
+    return any(
+        [
+            k.lower() == b"content-length" or k.lower() == b"transfer-encoding"
+            for k, v in request.headers
+        ]
+    )
+
+
+class HTTPConnectionState(enum.IntEnum):
+    ACTIVE = 1
+    IDLE = 2
+    CLOSED = 3
+
+
+class HTTP2Connection(ConnectionInterface):
+    READ_NUM_BYTES = 64 * 1024
+    CONFIG = h2.config.H2Configuration(validate_inbound_headers=False)
+
+    def __init__(
+        self,
+        origin: Origin,
+        stream: NetworkStream,
+        keepalive_expiry: typing.Optional[float] = None,
+    ):
+        self._origin = origin
+        self._network_stream = stream
+        self._keepalive_expiry: typing.Optional[float] = keepalive_expiry
+        self._h2_state = h2.connection.H2Connection(config=self.CONFIG)
+        self._state = HTTPConnectionState.IDLE
+        self._expire_at: typing.Optional[float] = None
+        self._request_count = 0
+        self._init_lock = Lock()
+        self._state_lock = Lock()
+        self._read_lock = Lock()
+        self._write_lock = Lock()
+        self._sent_connection_init = False
+        self._used_all_stream_ids = False
+        self._connection_error = False
+        self._events: typing.Dict[int, h2.events.Event] = {}
+        self._read_exception: typing.Optional[Exception] = None
+        self._write_exception: typing.Optional[Exception] = None
+        self._connection_error_event: typing.Optional[h2.events.Event] = None
+
+    def handle_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            # This cannot occur in normal operation, since the connection pool
+            # will only send requests on connections that handle them.
+            # It's in place simply for resilience as a guard against incorrect
+            # usage, for anyone working directly with httpcore connections.
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection "
+                f"to {self._origin}"
+            )
+
+        with self._state_lock:
+            if self._state in (HTTPConnectionState.ACTIVE, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._expire_at = None
+                self._state = HTTPConnectionState.ACTIVE
+            else:
+                raise ConnectionNotAvailable()
+
+        with self._init_lock:
+            if not self._sent_connection_init:
+                kwargs = {"request": request}
+                with Trace("http2.send_connection_init", request, kwargs):
+                    self._send_connection_init(**kwargs)
+                self._sent_connection_init = True
+                max_streams = self._h2_state.local_settings.max_concurrent_streams
+                self._max_streams_semaphore = Semaphore(max_streams)
+
+        self._max_streams_semaphore.acquire()
+
+        try:
+            stream_id = self._h2_state.get_next_available_stream_id()
+            self._events[stream_id] = []
+        except h2.exceptions.NoAvailableStreamIDError:  # pragma: nocover
+            self._used_all_stream_ids = True
+            raise ConnectionNotAvailable()
+
+        try:
+            kwargs = {"request": request, "stream_id": stream_id}
+            with Trace("http2.send_request_headers", request, kwargs):
+                self._send_request_headers(request=request, stream_id=stream_id)
+            with Trace("http2.send_request_body", request, kwargs):
+                self._send_request_body(request=request, stream_id=stream_id)
+            with Trace(
+                "http2.receive_response_headers", request, kwargs
+            ) as trace:
+                status, headers = self._receive_response(
+                    request=request, stream_id=stream_id
+                )
+                trace.return_value = (status, headers)
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP2ConnectionByteStream(self, request, stream_id=stream_id),
+                extensions={"stream_id": stream_id, "http_version": b"HTTP/2"},
+            )
+        except Exception as exc:  # noqa: PIE786
+            kwargs = {"stream_id": stream_id}
+            with Trace("http2.response_closed", request, kwargs):
+                self._response_closed(stream_id=stream_id)
+
+            if isinstance(exc, h2.exceptions.ProtocolError):
+                # One case where h2 can raise a protocol error is when a
+                # closed frame has been seen by the state machine.
+                #
+                # This happens when one stream is reading, and encounters
+                # a GOAWAY event. Other flows of control may then raise
+                # a protocol error at any point they interact with the 'h2_state'.
+                #
+                # In this case we'll have stored the event, and should raise
+                # it as a RemoteProtocolError.
+                if self._connection_error_event:
+                    raise RemoteProtocolError(self._connection_error_event)
+                # If h2 raises a protocol error in some other state then we
+                # must somehow have made a protocol violation.
+                raise LocalProtocolError(exc)  # pragma: nocover
+
+            raise exc
+
+    def _send_connection_init(self, request: Request) -> None:
+        """
+        The HTTP/2 connection requires some initial setup before we can start
+        using individual request/response streams on it.
+        """
+        # Need to set these manually here instead of manipulating via
+        # __setitem__() otherwise the H2Connection will emit SettingsUpdate
+        # frames in addition to sending the undesired defaults.
+        self._h2_state.local_settings = h2.settings.Settings(
+            client=True,
+            initial_values={
+                # Disable PUSH_PROMISE frames from the server since we don't do anything
+                # with them for now.  Maybe when we support caching?
+                h2.settings.SettingCodes.ENABLE_PUSH: 0,
+                # These two are taken from h2 for safe defaults
+                h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS: 100,
+                h2.settings.SettingCodes.MAX_HEADER_LIST_SIZE: 65536,
+            },
+        )
+
+        # Some websites (*cough* Yahoo *cough*) balk at this setting being
+        # present in the initial handshake since it's not defined in the original
+        # RFC despite the RFC mandating ignoring settings you don't know about.
+        del self._h2_state.local_settings[
+            h2.settings.SettingCodes.ENABLE_CONNECT_PROTOCOL
+        ]
+
+        self._h2_state.initiate_connection()
+        self._h2_state.increment_flow_control_window(2**24)
+        self._write_outgoing_data(request)
+
+    # Sending the request...
+
+    def _send_request_headers(self, request: Request, stream_id: int) -> None:
+        end_stream = not has_body_headers(request)
+
+        # In HTTP/2 the ':authority' pseudo-header is used instead of 'Host'.
+        # In order to gracefully handle HTTP/1.1 and HTTP/2 we always require
+        # HTTP/1.1 style headers, and map them appropriately if we end up on
+        # an HTTP/2 connection.
+        authority = [v for k, v in request.headers if k.lower() == b"host"][0]
+
+        headers = [
+            (b":method", request.method),
+            (b":authority", authority),
+            (b":scheme", request.url.scheme),
+            (b":path", request.url.target),
+        ] + [
+            (k.lower(), v)
+            for k, v in request.headers
+            if k.lower()
+            not in (
+                b"host",
+                b"transfer-encoding",
+            )
+        ]
+
+        self._h2_state.send_headers(stream_id, headers, end_stream=end_stream)
+        self._h2_state.increment_flow_control_window(2**24, stream_id=stream_id)
+        self._write_outgoing_data(request)
+
+    def _send_request_body(self, request: Request, stream_id: int) -> None:
+        if not has_body_headers(request):
+            return
+
+        assert isinstance(request.stream, typing.Iterable)
+        for data in request.stream:
+            while data:
+                max_flow = self._wait_for_outgoing_flow(request, stream_id)
+                chunk_size = min(len(data), max_flow)
+                chunk, data = data[:chunk_size], data[chunk_size:]
+                self._h2_state.send_data(stream_id, chunk)
+                self._write_outgoing_data(request)
+
+        self._h2_state.end_stream(stream_id)
+        self._write_outgoing_data(request)
+
+    # Receiving the response...
+
+    def _receive_response(
+        self, request: Request, stream_id: int
+    ) -> typing.Tuple[int, typing.List[typing.Tuple[bytes, bytes]]]:
+        while True:
+            event = self._receive_stream_event(request, stream_id)
+            if isinstance(event, h2.events.ResponseReceived):
+                break
+
+        status_code = 200
+        headers = []
+        for k, v in event.headers:
+            if k == b":status":
+                status_code = int(v.decode("ascii", errors="ignore"))
+            elif not k.startswith(b":"):
+                headers.append((k, v))
+
+        return (status_code, headers)
+
+    def _receive_response_body(
+        self, request: Request, stream_id: int
+    ) -> typing.Iterator[bytes]:
+        while True:
+            event = self._receive_stream_event(request, stream_id)
+            if isinstance(event, h2.events.DataReceived):
+                amount = event.flow_controlled_length
+                self._h2_state.acknowledge_received_data(amount, stream_id)
+                self._write_outgoing_data(request)
+                yield event.data
+            elif isinstance(event, (h2.events.StreamEnded, h2.events.StreamReset)):
+                break
+
+    def _receive_stream_event(
+        self, request: Request, stream_id: int
+    ) -> h2.events.Event:
+        while not self._events.get(stream_id):
+            self._receive_events(request, stream_id)
+        event = self._events[stream_id].pop(0)
+        # The StreamReset event applies to a single stream.
+        if hasattr(event, "error_code"):
+            raise RemoteProtocolError(event)
+        return event
+
+    def _receive_events(
+        self, request: Request, stream_id: typing.Optional[int] = None
+    ) -> None:
+        with self._read_lock:
+            if self._connection_error_event is not None:  # pragma: nocover
+                raise RemoteProtocolError(self._connection_error_event)
+
+            # This conditional is a bit icky. We don't want to block reading if we've
+            # actually got an event to return for a given stream. We need to do that
+            # check *within* the atomic read lock. Though it also need to be optional,
+            # because when we call it from `_wait_for_outgoing_flow` we *do* want to
+            # block until we've available flow control, event when we have events
+            # pending for the stream ID we're attempting to send on.
+            if stream_id is None or not self._events.get(stream_id):
+                events = self._read_incoming_data(request)
+                for event in events:
+                    event_stream_id = getattr(event, "stream_id", 0)
+
+                    # The ConnectionTerminatedEvent applies to the entire connection,
+                    # and should be saved so it can be raised on all streams.
+                    if hasattr(event, "error_code") and event_stream_id == 0:
+                        self._connection_error_event = event
+                        raise RemoteProtocolError(event)
+
+                    if event_stream_id in self._events:
+                        self._events[event_stream_id].append(event)
+
+        self._write_outgoing_data(request)
+
+    def _response_closed(self, stream_id: int) -> None:
+        self._max_streams_semaphore.release()
+        del self._events[stream_id]
+        with self._state_lock:
+            if self._state == HTTPConnectionState.ACTIVE and not self._events:
+                self._state = HTTPConnectionState.IDLE
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+                if self._used_all_stream_ids:  # pragma: nocover
+                    self.close()
+
+    def close(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._h2_state.close_connection()
+        self._state = HTTPConnectionState.CLOSED
+        self._network_stream.close()
+
+    # Wrappers around network read/write operations...
+
+    def _read_incoming_data(
+        self, request: Request
+    ) -> typing.List[h2.events.Event]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        if self._read_exception is not None:
+            raise self._read_exception  # pragma: nocover
+
+        try:
+            data = self._network_stream.read(self.READ_NUM_BYTES, timeout)
+            if data == b"":
+                raise RemoteProtocolError("Server disconnected")
+        except Exception as exc:
+            # If we get a network error we should:
+            #
+            # 1. Save the exception and just raise it immediately on any future reads.
+            #    (For example, this means that a single read timeout or disconnect will
+            #    immediately close all pending streams. Without requiring multiple
+            #    sequential timeouts.)
+            # 2. Mark the connection as errored, so that we don't accept any other
+            #    incoming requests.
+            self._read_exception = exc
+            self._connection_error = True
+            raise exc
+
+        events = self._h2_state.receive_data(data)
+
+        return events
+
+    def _write_outgoing_data(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        with self._write_lock:
+            data_to_send = self._h2_state.data_to_send()
+
+            if self._write_exception is not None:
+                raise self._write_exception  # pragma: nocover
+
+            try:
+                self._network_stream.write(data_to_send, timeout)
+            except Exception as exc:  # pragma: nocover
+                # If we get a network error we should:
+                #
+                # 1. Save the exception and just raise it immediately on any future write.
+                #    (For example, this means that a single write timeout or disconnect will
+                #    immediately close all pending streams. Without requiring multiple
+                #    sequential timeouts.)
+                # 2. Mark the connection as errored, so that we don't accept any other
+                #    incoming requests.
+                self._write_exception = exc
+                self._connection_error = True
+                raise exc
+
+    # Flow control...
+
+    def _wait_for_outgoing_flow(self, request: Request, stream_id: int) -> int:
+        """
+        Returns the maximum allowable outgoing flow for a given stream.
+
+        If the allowable flow is zero, then waits on the network until
+        WindowUpdated frames have increased the flow rate.
+        https://tools.ietf.org/html/rfc7540#section-6.9
+        """
+        local_flow = self._h2_state.local_flow_control_window(stream_id)
+        max_frame_size = self._h2_state.max_outbound_frame_size
+        flow = min(local_flow, max_frame_size)
+        while flow == 0:
+            self._receive_events(request)
+            local_flow = self._h2_state.local_flow_control_window(stream_id)
+            max_frame_size = self._h2_state.max_outbound_frame_size
+            flow = min(local_flow, max_frame_size)
+        return flow
+
+    # Interface for connection pooling...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_available(self) -> bool:
+        return (
+            self._state != HTTPConnectionState.CLOSED
+            and not self._connection_error
+            and not self._used_all_stream_ids
+        )
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        return self._expire_at is not None and now > self._expire_at
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return (
+            f"{origin!r}, HTTP/2, {self._state.name}, "
+            f"Request Count: {self._request_count}"
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return (
+            f"<{class_name} [{origin!r}, {self._state.name}, "
+            f"Request Count: {self._request_count}]>"
+        )
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    def __enter__(self) -> "HTTP2Connection":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]] = None,
+        exc_value: typing.Optional[BaseException] = None,
+        traceback: typing.Optional[types.TracebackType] = None,
+    ) -> None:
+        self.close()
+
+
+class HTTP2ConnectionByteStream:
+    def __init__(
+        self, connection: HTTP2Connection, request: Request, stream_id: int
+    ) -> None:
+        self._connection = connection
+        self._request = request
+        self._stream_id = stream_id
+        self._closed = False
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        kwargs = {"request": self._request, "stream_id": self._stream_id}
+        try:
+            with Trace("http2.receive_response_body", self._request, kwargs):
+                for chunk in self._connection._receive_response_body(
+                    request=self._request, stream_id=self._stream_id
+                ):
+                    yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            self.close()
+            raise exc
+
+    def close(self) -> None:
+        if not self._closed:
+            self._closed = True
+            kwargs = {"stream_id": self._stream_id}
+            with Trace("http2.response_closed", self._request, kwargs):
+                self._connection._response_closed(stream_id=self._stream_id)
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_sync/http_proxy.py b/myenv/lib/python3.9/site-packages/httpcore/_sync/http_proxy.py
new file mode 100644
index 0000000..3dadf9a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_sync/http_proxy.py
@@ -0,0 +1,337 @@
+import ssl
+from base64 import b64encode
+from typing import List, Mapping, Optional, Sequence, Tuple, Union
+
+from .._exceptions import ProxyError
+from .._models import (
+    URL,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+)
+from .._ssl import default_ssl_context
+from .._synchronization import Lock
+from .._trace import Trace
+from ..backends.base import NetworkBackend
+from .connection import HTTPConnection
+from .connection_pool import ConnectionPool
+from .http11 import HTTP11Connection
+from .interfaces import ConnectionInterface
+
+HeadersAsSequence = Sequence[Tuple[Union[bytes, str], Union[bytes, str]]]
+HeadersAsMapping = Mapping[Union[bytes, str], Union[bytes, str]]
+
+
+def merge_headers(
+    default_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+    override_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+) -> List[Tuple[bytes, bytes]]:
+    """
+    Append default_headers and override_headers, de-duplicating if a key exists
+    in both cases.
+    """
+    default_headers = [] if default_headers is None else list(default_headers)
+    override_headers = [] if override_headers is None else list(override_headers)
+    has_override = set([key.lower() for key, value in override_headers])
+    default_headers = [
+        (key, value)
+        for key, value in default_headers
+        if key.lower() not in has_override
+    ]
+    return default_headers + override_headers
+
+
+def build_auth_header(username: bytes, password: bytes) -> bytes:
+    userpass = username + b":" + password
+    return b"Basic " + b64encode(userpass)
+
+
+class HTTPProxy(ConnectionPool):
+    """
+    A connection pool that sends requests via an HTTP proxy.
+    """
+
+    def __init__(
+        self,
+        proxy_url: Union[URL, bytes, str],
+        proxy_auth: Optional[Tuple[Union[bytes, str], Union[bytes, str]]] = None,
+        proxy_headers: Union[HeadersAsMapping, HeadersAsSequence, None] = None,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        max_connections: Optional[int] = 10,
+        max_keepalive_connections: Optional[int] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[NetworkBackend] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            proxy_auth: Any proxy authentication as a two-tuple of
+                (username, password). May be either bytes or ascii-only str.
+            proxy_headers: Any HTTP headers to use for the proxy requests.
+                For example `{"Proxy-Authorization": "Basic <username>:<password>"}`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        super().__init__(
+            ssl_context=ssl_context,
+            max_connections=max_connections,
+            max_keepalive_connections=max_keepalive_connections,
+            keepalive_expiry=keepalive_expiry,
+            http1=http1,
+            http2=http2,
+            network_backend=network_backend,
+            retries=retries,
+            local_address=local_address,
+            uds=uds,
+        )
+        self._ssl_context = ssl_context
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        if proxy_auth is not None:
+            username = enforce_bytes(proxy_auth[0], name="proxy_auth")
+            password = enforce_bytes(proxy_auth[1], name="proxy_auth")
+            authorization = build_auth_header(username, password)
+            self._proxy_headers = [
+                (b"Proxy-Authorization", authorization)
+            ] + self._proxy_headers
+
+    def create_connection(self, origin: Origin) -> ConnectionInterface:
+        if origin.scheme == b"http":
+            return ForwardHTTPConnection(
+                proxy_origin=self._proxy_url.origin,
+                proxy_headers=self._proxy_headers,
+                keepalive_expiry=self._keepalive_expiry,
+                network_backend=self._network_backend,
+            )
+        return TunnelHTTPConnection(
+            proxy_origin=self._proxy_url.origin,
+            proxy_headers=self._proxy_headers,
+            remote_origin=origin,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
+        )
+
+
+class ForwardHTTPConnection(ConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        proxy_headers: Union[HeadersAsMapping, HeadersAsSequence, None] = None,
+        keepalive_expiry: Optional[float] = None,
+        network_backend: Optional[NetworkBackend] = None,
+    ) -> None:
+        self._connection = HTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+        )
+        self._proxy_origin = proxy_origin
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+
+    def handle_request(self, request: Request) -> Response:
+        headers = merge_headers(self._proxy_headers, request.headers)
+        url = URL(
+            scheme=self._proxy_origin.scheme,
+            host=self._proxy_origin.host,
+            port=self._proxy_origin.port,
+            target=bytes(request.url),
+        )
+        proxy_request = Request(
+            method=request.method,
+            url=url,
+            headers=headers,
+            content=request.stream,
+            extensions=request.extensions,
+        )
+        return self._connection.handle_request(proxy_request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin.scheme == b"http"
+
+    def close(self) -> None:
+        self._connection.close()
+
+    def info(self) -> str:
+        return self._connection.info()
+
+    def is_available(self) -> bool:
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
+
+
+class TunnelHTTPConnection(ConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        proxy_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: Optional[NetworkBackend] = None,
+    ) -> None:
+        self._connection: ConnectionInterface = HTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+        )
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._ssl_context = ssl_context
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._connect_lock = Lock()
+        self._connected = False
+
+    def handle_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("connect", None)
+
+        with self._connect_lock:
+            if not self._connected:
+                target = b"%b:%d" % (self._remote_origin.host, self._remote_origin.port)
+
+                connect_url = URL(
+                    scheme=self._proxy_origin.scheme,
+                    host=self._proxy_origin.host,
+                    port=self._proxy_origin.port,
+                    target=target,
+                )
+                connect_headers = merge_headers(
+                    [(b"Host", target), (b"Accept", b"*/*")], self._proxy_headers
+                )
+                connect_request = Request(
+                    method=b"CONNECT",
+                    url=connect_url,
+                    headers=connect_headers,
+                    extensions=request.extensions,
+                )
+                connect_response = self._connection.handle_request(
+                    connect_request
+                )
+
+                if connect_response.status < 200 or connect_response.status > 299:
+                    reason_bytes = connect_response.extensions.get("reason_phrase", b"")
+                    reason_str = reason_bytes.decode("ascii", errors="ignore")
+                    msg = "%d %s" % (connect_response.status, reason_str)
+                    self._connection.close()
+                    raise ProxyError(msg)
+
+                stream = connect_response.extensions["network_stream"]
+
+                # Upgrade the stream to SSL
+                ssl_context = (
+                    default_ssl_context()
+                    if self._ssl_context is None
+                    else self._ssl_context
+                )
+                alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+                ssl_context.set_alpn_protocols(alpn_protocols)
+
+                kwargs = {
+                    "ssl_context": ssl_context,
+                    "server_hostname": self._remote_origin.host.decode("ascii"),
+                    "timeout": timeout,
+                }
+                with Trace("connection.start_tls", request, kwargs) as trace:
+                    stream = stream.start_tls(**kwargs)
+                    trace.return_value = stream
+
+                # Determine if we should be using HTTP/1.1 or HTTP/2
+                ssl_object = stream.get_extra_info("ssl_object")
+                http2_negotiated = (
+                    ssl_object is not None
+                    and ssl_object.selected_alpn_protocol() == "h2"
+                )
+
+                # Create the HTTP/1.1 or HTTP/2 connection
+                if http2_negotiated or (self._http2 and not self._http1):
+                    from .http2 import HTTP2Connection
+
+                    self._connection = HTTP2Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+                else:
+                    self._connection = HTTP11Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+
+                self._connected = True
+        return self._connection.handle_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    def close(self) -> None:
+        self._connection.close()
+
+    def info(self) -> str:
+        return self._connection.info()
+
+    def is_available(self) -> bool:
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_sync/interfaces.py b/myenv/lib/python3.9/site-packages/httpcore/_sync/interfaces.py
new file mode 100644
index 0000000..bf512ab
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_sync/interfaces.py
@@ -0,0 +1,133 @@
+from contextlib import contextmanager
+from typing import Iterator, Optional, Union
+
+from .._models import (
+    URL,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+    include_request_headers,
+)
+
+
+class RequestInterface:
+    def request(
+        self,
+        method: Union[bytes, str],
+        url: Union[URL, bytes, str],
+        *,
+        headers: Union[dict, list, None] = None,
+        content: Union[bytes, Iterator[bytes], None] = None,
+        extensions: Optional[dict] = None,
+    ) -> Response:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = self.handle_request(request)
+        try:
+            response.read()
+        finally:
+            response.close()
+        return response
+
+    @contextmanager
+    def stream(
+        self,
+        method: Union[bytes, str],
+        url: Union[URL, bytes, str],
+        *,
+        headers: Union[dict, list, None] = None,
+        content: Union[bytes, Iterator[bytes], None] = None,
+        extensions: Optional[dict] = None,
+    ) -> Iterator[Response]:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = self.handle_request(request)
+        try:
+            yield response
+        finally:
+            response.close()
+
+    def handle_request(self, request: Request) -> Response:
+        raise NotImplementedError()  # pragma: nocover
+
+
+class ConnectionInterface(RequestInterface):
+    def close(self) -> None:
+        raise NotImplementedError()  # pragma: nocover
+
+    def info(self) -> str:
+        raise NotImplementedError()  # pragma: nocover
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_available(self) -> bool:
+        """
+        Return `True` if the connection is currently able to accept an
+        outgoing request.
+
+        An HTTP/1.1 connection will only be available if it is currently idle.
+
+        An HTTP/2 connection will be available so long as the stream ID space is
+        not yet exhausted, and the connection is not in an error state.
+
+        While the connection is being established we may not yet know if it is going
+        to result in an HTTP/1.1 or HTTP/2 connection. The connection should be
+        treated as being available, but might ultimately raise `NewConnectionRequired`
+        required exceptions if multiple requests are attempted over a connection
+        that ends up being established as HTTP/1.1.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def has_expired(self) -> bool:
+        """
+        Return `True` if the connection is in a state where it should be closed.
+
+        This either means that the connection is idle and it has passed the
+        expiry time on its keep-alive, or that server has sent an EOF.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_idle(self) -> bool:
+        """
+        Return `True` if the connection is currently idle.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_closed(self) -> bool:
+        """
+        Return `True` if the connection has been closed.
+
+        Used when a response is closed to determine if the connection may be
+        returned to the connection pool or not.
+        """
+        raise NotImplementedError()  # pragma: nocover
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_sync/socks_proxy.py b/myenv/lib/python3.9/site-packages/httpcore/_sync/socks_proxy.py
new file mode 100644
index 0000000..95c004a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_sync/socks_proxy.py
@@ -0,0 +1,336 @@
+import ssl
+import typing
+
+from socksio import socks5
+
+from .._exceptions import ConnectionNotAvailable, ProxyError
+from .._models import URL, Origin, Request, Response, enforce_bytes, enforce_url
+from .._ssl import default_ssl_context
+from .._synchronization import Lock
+from .._trace import Trace
+from ..backends.sync import SyncBackend
+from ..backends.base import NetworkBackend, NetworkStream
+from .connection_pool import ConnectionPool
+from .http11 import HTTP11Connection
+from .interfaces import ConnectionInterface
+
+AUTH_METHODS = {
+    b"\x00": "NO AUTHENTICATION REQUIRED",
+    b"\x01": "GSSAPI",
+    b"\x02": "USERNAME/PASSWORD",
+    b"\xff": "NO ACCEPTABLE METHODS",
+}
+
+REPLY_CODES = {
+    b"\x00": "Succeeded",
+    b"\x01": "General SOCKS server failure",
+    b"\x02": "Connection not allowed by ruleset",
+    b"\x03": "Network unreachable",
+    b"\x04": "Host unreachable",
+    b"\x05": "Connection refused",
+    b"\x06": "TTL expired",
+    b"\x07": "Command not supported",
+    b"\x08": "Address type not supported",
+}
+
+
+def _init_socks5_connection(
+    stream: NetworkStream,
+    *,
+    host: bytes,
+    port: int,
+    auth: typing.Optional[typing.Tuple[bytes, bytes]] = None,
+) -> None:
+    conn = socks5.SOCKS5Connection()
+
+    # Auth method request
+    auth_method = (
+        socks5.SOCKS5AuthMethod.NO_AUTH_REQUIRED
+        if auth is None
+        else socks5.SOCKS5AuthMethod.USERNAME_PASSWORD
+    )
+    conn.send(socks5.SOCKS5AuthMethodsRequest([auth_method]))
+    outgoing_bytes = conn.data_to_send()
+    stream.write(outgoing_bytes)
+
+    # Auth method response
+    incoming_bytes = stream.read(max_bytes=4096)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socks5.SOCKS5AuthReply)
+    if response.method != auth_method:
+        requested = AUTH_METHODS.get(auth_method, "UNKNOWN")
+        responded = AUTH_METHODS.get(response.method, "UNKNOWN")
+        raise ProxyError(
+            f"Requested {requested} from proxy server, but got {responded}."
+        )
+
+    if response.method == socks5.SOCKS5AuthMethod.USERNAME_PASSWORD:
+        # Username/password request
+        assert auth is not None
+        username, password = auth
+        conn.send(socks5.SOCKS5UsernamePasswordRequest(username, password))
+        outgoing_bytes = conn.data_to_send()
+        stream.write(outgoing_bytes)
+
+        # Username/password response
+        incoming_bytes = stream.read(max_bytes=4096)
+        response = conn.receive_data(incoming_bytes)
+        assert isinstance(response, socks5.SOCKS5UsernamePasswordReply)
+        if not response.success:
+            raise ProxyError("Invalid username/password")
+
+    # Connect request
+    conn.send(
+        socks5.SOCKS5CommandRequest.from_address(
+            socks5.SOCKS5Command.CONNECT, (host, port)
+        )
+    )
+    outgoing_bytes = conn.data_to_send()
+    stream.write(outgoing_bytes)
+
+    # Connect response
+    incoming_bytes = stream.read(max_bytes=4096)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socks5.SOCKS5Reply)
+    if response.reply_code != socks5.SOCKS5ReplyCode.SUCCEEDED:
+        reply_code = REPLY_CODES.get(response.reply_code, "UNKOWN")
+        raise ProxyError(f"Proxy Server could not connect: {reply_code}.")
+
+
+class SOCKSProxy(ConnectionPool):
+    """
+    A connection pool that sends requests via an HTTP proxy.
+    """
+
+    def __init__(
+        self,
+        proxy_url: typing.Union[URL, bytes, str],
+        proxy_auth: typing.Optional[
+            typing.Tuple[typing.Union[bytes, str], typing.Union[bytes, str]]
+        ] = None,
+        ssl_context: typing.Optional[ssl.SSLContext] = None,
+        max_connections: typing.Optional[int] = 10,
+        max_keepalive_connections: typing.Optional[int] = None,
+        keepalive_expiry: typing.Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: typing.Optional[NetworkBackend] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        super().__init__(
+            ssl_context=ssl_context,
+            max_connections=max_connections,
+            max_keepalive_connections=max_keepalive_connections,
+            keepalive_expiry=keepalive_expiry,
+            http1=http1,
+            http2=http2,
+            network_backend=network_backend,
+        )
+        self._ssl_context = ssl_context
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
+        if proxy_auth is not None:
+            username, password = proxy_auth
+            username_bytes = enforce_bytes(username, name="proxy_auth")
+            password_bytes = enforce_bytes(password, name="proxy_auth")
+            self._proxy_auth: typing.Optional[typing.Tuple[bytes, bytes]] = (
+                username_bytes,
+                password_bytes,
+            )
+        else:
+            self._proxy_auth = None
+
+    def create_connection(self, origin: Origin) -> ConnectionInterface:
+        return Socks5Connection(
+            proxy_origin=self._proxy_url.origin,
+            remote_origin=origin,
+            proxy_auth=self._proxy_auth,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
+        )
+
+
+class Socks5Connection(ConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        proxy_auth: typing.Optional[typing.Tuple[bytes, bytes]] = None,
+        ssl_context: typing.Optional[ssl.SSLContext] = None,
+        keepalive_expiry: typing.Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: typing.Optional[NetworkBackend] = None,
+    ) -> None:
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._proxy_auth = proxy_auth
+        self._ssl_context = ssl_context
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+
+        self._network_backend: NetworkBackend = (
+            SyncBackend() if network_backend is None else network_backend
+        )
+        self._connect_lock = Lock()
+        self._connection: typing.Optional[ConnectionInterface] = None
+        self._connect_failed = False
+
+    def handle_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("connect", None)
+
+        with self._connect_lock:
+            if self._connection is None:
+                try:
+                    # Connect to the proxy
+                    kwargs = {
+                        "host": self._proxy_origin.host.decode("ascii"),
+                        "port": self._proxy_origin.port,
+                        "timeout": timeout,
+                    }
+                    with Trace("connection.connect_tcp", request, kwargs) as trace:
+                        stream = self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
+
+                    # Connect to the remote host using socks5
+                    kwargs = {
+                        "stream": stream,
+                        "host": self._remote_origin.host.decode("ascii"),
+                        "port": self._remote_origin.port,
+                        "auth": self._proxy_auth,
+                    }
+                    with Trace(
+                        "connection.setup_socks5_connection", request, kwargs
+                    ) as trace:
+                        _init_socks5_connection(**kwargs)
+                        trace.return_value = stream
+
+                    # Upgrade the stream to SSL
+                    if self._remote_origin.scheme == b"https":
+                        ssl_context = (
+                            default_ssl_context()
+                            if self._ssl_context is None
+                            else self._ssl_context
+                        )
+                        alpn_protocols = (
+                            ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+                        )
+                        ssl_context.set_alpn_protocols(alpn_protocols)
+
+                        kwargs = {
+                            "ssl_context": ssl_context,
+                            "server_hostname": self._remote_origin.host.decode("ascii"),
+                            "timeout": timeout,
+                        }
+                        with Trace(
+                            "connection.start_tls", request, kwargs
+                        ) as trace:
+                            stream = stream.start_tls(**kwargs)
+                            trace.return_value = stream
+
+                    # Determine if we should be using HTTP/1.1 or HTTP/2
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = (
+                        ssl_object is not None
+                        and ssl_object.selected_alpn_protocol() == "h2"
+                    )
+
+                    # Create the HTTP/1.1 or HTTP/2 connection
+                    if http2_negotiated or (
+                        self._http2 and not self._http1
+                    ):  # pragma: nocover
+                        from .http2 import HTTP2Connection
+
+                        self._connection = HTTP2Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = HTTP11Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                except Exception as exc:
+                    self._connect_failed = True
+                    raise exc
+            elif not self._connection.is_available():  # pragma: nocover
+                raise ConnectionNotAvailable()
+
+        return self._connection.handle_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    def close(self) -> None:
+        if self._connection is not None:
+            self._connection.close()
+
+    def is_available(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return (
+                self._http2
+                and (self._remote_origin.scheme == b"https" or not self._http1)
+                and not self._connect_failed
+            )
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:  # pragma: nocover
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_synchronization.py b/myenv/lib/python3.9/site-packages/httpcore/_synchronization.py
new file mode 100644
index 0000000..3885ca7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_synchronization.py
@@ -0,0 +1,89 @@
+import threading
+from types import TracebackType
+from typing import Optional, Type
+
+import anyio
+
+from ._exceptions import PoolTimeout, map_exceptions
+
+
+class AsyncLock:
+    def __init__(self) -> None:
+        self._lock = anyio.Lock()
+
+    async def __aenter__(self) -> "AsyncLock":
+        await self._lock.acquire()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        self._lock.release()
+
+
+class AsyncEvent:
+    def __init__(self) -> None:
+        self._event = anyio.Event()
+
+    def set(self) -> None:
+        self._event.set()
+
+    async def wait(self, timeout: Optional[float] = None) -> None:
+        exc_map: dict = {TimeoutError: PoolTimeout}
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                await self._event.wait()
+
+
+class AsyncSemaphore:
+    def __init__(self, bound: int) -> None:
+        self._semaphore = anyio.Semaphore(initial_value=bound, max_value=bound)
+
+    async def acquire(self) -> None:
+        await self._semaphore.acquire()
+
+    async def release(self) -> None:
+        self._semaphore.release()
+
+
+class Lock:
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+
+    def __enter__(self) -> "Lock":
+        self._lock.acquire()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        self._lock.release()
+
+
+class Event:
+    def __init__(self) -> None:
+        self._event = threading.Event()
+
+    def set(self) -> None:
+        self._event.set()
+
+    def wait(self, timeout: Optional[float] = None) -> None:
+        if not self._event.wait(timeout=timeout):
+            raise PoolTimeout()  # pragma: nocover
+
+
+class Semaphore:
+    def __init__(self, bound: int) -> None:
+        self._semaphore = threading.Semaphore(value=bound)
+
+    def acquire(self) -> None:
+        self._semaphore.acquire()
+
+    def release(self) -> None:
+        self._semaphore.release()
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_trace.py b/myenv/lib/python3.9/site-packages/httpcore/_trace.py
new file mode 100644
index 0000000..c957c2c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_trace.py
@@ -0,0 +1,54 @@
+from types import TracebackType
+from typing import Any, Optional, Type
+
+from ._models import Request
+
+
+class Trace:
+    def __init__(
+        self, name: str, request: Request, kwargs: Optional[dict] = None
+    ) -> None:
+        self.name = name
+        self.trace = request.extensions.get("trace")
+        self.kwargs = kwargs or {}
+        self.return_value: Any = None
+
+    def __enter__(self) -> "Trace":
+        if self.trace is not None:
+            info = self.kwargs
+            self.trace(f"{self.name}.started", info)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        if self.trace is not None:
+            if exc_value is None:
+                info: dict = {"return_value": self.return_value}
+                self.trace(f"{self.name}.complete", info)
+            else:
+                info = {"exception": exc_value}
+                self.trace(f"{self.name}.failed", info)
+
+    async def __aenter__(self) -> "Trace":
+        if self.trace is not None:
+            info = self.kwargs
+            await self.trace(f"{self.name}.started", info)
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        if self.trace is not None:
+            if exc_value is None:
+                info: dict = {"return_value": self.return_value}
+                await self.trace(f"{self.name}.complete", info)
+            else:
+                info = {"exception": exc_value}
+                await self.trace(f"{self.name}.failed", info)
diff --git a/myenv/lib/python3.9/site-packages/httpcore/_utils.py b/myenv/lib/python3.9/site-packages/httpcore/_utils.py
new file mode 100644
index 0000000..df5dea8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/_utils.py
@@ -0,0 +1,36 @@
+import select
+import socket
+import sys
+import typing
+
+
+def is_socket_readable(sock: typing.Optional[socket.socket]) -> bool:
+    """
+    Return whether a socket, as identifed by its file descriptor, is readable.
+    "A socket is readable" means that the read buffer isn't empty, i.e. that calling
+    .recv() on it would immediately return some data.
+    """
+    # NOTE: we want check for readability without actually attempting to read, because
+    # we don't want to block forever if it's not readable.
+
+    # In the case that the socket no longer exists, or cannot return a file
+    # descriptor, we treat it as being readable, as if it the next read operation
+    # on it is ready to return the terminating `b""`.
+    sock_fd = None if sock is None else sock.fileno()
+    if sock_fd is None or sock_fd < 0:  # pragma: nocover
+        return True
+
+    # The implementation below was stolen from:
+    # https://github.com/python-trio/trio/blob/20ee2b1b7376db637435d80e266212a35837ddcc/trio/_socket.py#L471-L478
+    # See also: https://github.com/encode/httpcore/pull/193#issuecomment-703129316
+
+    # Use select.select on Windows, and when poll is unavailable and select.poll
+    # everywhere else. (E.g. When eventlet is in use. See #327)
+    if (
+        sys.platform == "win32" or getattr(select, "poll", None) is None
+    ):  # pragma: nocover
+        rready, _, _ = select.select([sock_fd], [], [], 0)
+        return bool(rready)
+    p = select.poll()
+    p.register(sock_fd, select.POLLIN)
+    return bool(p.poll(0))
diff --git a/myenv/lib/python3.9/site-packages/httpcore/backends/__init__.py b/myenv/lib/python3.9/site-packages/httpcore/backends/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/httpcore/backends/asyncio.py b/myenv/lib/python3.9/site-packages/httpcore/backends/asyncio.py
new file mode 100644
index 0000000..3b8abf1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/backends/asyncio.py
@@ -0,0 +1,130 @@
+import ssl
+import typing
+
+import anyio
+
+from .._exceptions import (
+    ConnectError,
+    ConnectTimeout,
+    ReadError,
+    ReadTimeout,
+    WriteError,
+    WriteTimeout,
+    map_exceptions,
+)
+from .._utils import is_socket_readable
+from .base import AsyncNetworkBackend, AsyncNetworkStream
+
+
+class AsyncIOStream(AsyncNetworkStream):
+    def __init__(self, stream: anyio.abc.ByteStream) -> None:
+        self._stream = stream
+
+    async def read(
+        self, max_bytes: int, timeout: typing.Optional[float] = None
+    ) -> bytes:
+        exc_map = {
+            TimeoutError: ReadTimeout,
+            anyio.BrokenResourceError: ReadError,
+        }
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                try:
+                    return await self._stream.receive(max_bytes=max_bytes)
+                except anyio.EndOfStream:  # pragma: nocover
+                    return b""
+
+    async def write(
+        self, buffer: bytes, timeout: typing.Optional[float] = None
+    ) -> None:
+        if not buffer:
+            return
+
+        exc_map = {
+            TimeoutError: WriteTimeout,
+            anyio.BrokenResourceError: WriteError,
+        }
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                await self._stream.send(item=buffer)
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+    async def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncNetworkStream:
+        exc_map = {
+            TimeoutError: ConnectTimeout,
+            anyio.BrokenResourceError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            try:
+                with anyio.fail_after(timeout):
+                    ssl_stream = await anyio.streams.tls.TLSStream.wrap(
+                        self._stream,
+                        ssl_context=ssl_context,
+                        hostname=server_hostname,
+                        standard_compatible=False,
+                        server_side=False,
+                    )
+            except Exception as exc:  # pragma: nocover
+                await self.aclose()
+                raise exc
+        return AsyncIOStream(ssl_stream)
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        if info == "ssl_object":
+            return self._stream.extra(anyio.streams.tls.TLSAttribute.ssl_object, None)
+        if info == "client_addr":
+            return self._stream.extra(anyio.abc.SocketAttribute.local_address, None)
+        if info == "server_addr":
+            return self._stream.extra(anyio.abc.SocketAttribute.remote_address, None)
+        if info == "socket":
+            return self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
+        if info == "is_readable":
+            sock = self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
+            return is_socket_readable(sock)
+        return None
+
+
+class AsyncIOBackend(AsyncNetworkBackend):
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: typing.Optional[float] = None,
+        local_address: typing.Optional[str] = None,
+    ) -> AsyncNetworkStream:
+        exc_map = {
+            TimeoutError: ConnectTimeout,
+            OSError: ConnectError,
+            anyio.BrokenResourceError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                stream: anyio.abc.ByteStream = await anyio.connect_tcp(
+                    remote_host=host,
+                    remote_port=port,
+                    local_host=local_address,
+                )
+        return AsyncIOStream(stream)
+
+    async def connect_unix_socket(
+        self, path: str, timeout: typing.Optional[float] = None
+    ) -> AsyncNetworkStream:  # pragma: nocover
+        exc_map = {
+            TimeoutError: ConnectTimeout,
+            OSError: ConnectError,
+            anyio.BrokenResourceError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                stream: anyio.abc.ByteStream = await anyio.connect_unix(path)
+        return AsyncIOStream(stream)
+
+    async def sleep(self, seconds: float) -> None:
+        await anyio.sleep(seconds)  # pragma: nocover
diff --git a/myenv/lib/python3.9/site-packages/httpcore/backends/auto.py b/myenv/lib/python3.9/site-packages/httpcore/backends/auto.py
new file mode 100644
index 0000000..62087d8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/backends/auto.py
@@ -0,0 +1,41 @@
+from typing import Optional
+
+import sniffio
+
+from .base import AsyncNetworkBackend, AsyncNetworkStream
+
+
+class AutoBackend(AsyncNetworkBackend):
+    async def _init_backend(self) -> None:
+        if not (hasattr(self, "_backend")):
+            backend = sniffio.current_async_library()
+            if backend == "trio":
+                from .trio import TrioBackend
+
+                self._backend: AsyncNetworkBackend = TrioBackend()
+            else:
+                from .asyncio import AsyncIOBackend
+
+                self._backend = AsyncIOBackend()
+
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: Optional[float] = None,
+        local_address: Optional[str] = None,
+    ) -> AsyncNetworkStream:
+        await self._init_backend()
+        return await self._backend.connect_tcp(
+            host, port, timeout=timeout, local_address=local_address
+        )
+
+    async def connect_unix_socket(
+        self, path: str, timeout: Optional[float] = None
+    ) -> AsyncNetworkStream:  # pragma: nocover
+        await self._init_backend()
+        return await self._backend.connect_unix_socket(path, timeout=timeout)
+
+    async def sleep(self, seconds: float) -> None:  # pragma: nocover
+        await self._init_backend()
+        return await self._backend.sleep(seconds)
diff --git a/myenv/lib/python3.9/site-packages/httpcore/backends/base.py b/myenv/lib/python3.9/site-packages/httpcore/backends/base.py
new file mode 100644
index 0000000..6854db6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/backends/base.py
@@ -0,0 +1,89 @@
+import ssl
+import time
+import typing
+
+
+class NetworkStream:
+    def read(self, max_bytes: int, timeout: typing.Optional[float] = None) -> bytes:
+        raise NotImplementedError()  # pragma: nocover
+
+    def write(self, buffer: bytes, timeout: typing.Optional[float] = None) -> None:
+        raise NotImplementedError()  # pragma: nocover
+
+    def close(self) -> None:
+        raise NotImplementedError()  # pragma: nocover
+
+    def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> "NetworkStream":
+        raise NotImplementedError()  # pragma: nocover
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return None  # pragma: nocover
+
+
+class NetworkBackend:
+    def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: typing.Optional[float] = None,
+        local_address: typing.Optional[str] = None,
+    ) -> NetworkStream:
+        raise NotImplementedError()  # pragma: nocover
+
+    def connect_unix_socket(
+        self, path: str, timeout: typing.Optional[float] = None
+    ) -> NetworkStream:
+        raise NotImplementedError()  # pragma: nocover
+
+    def sleep(self, seconds: float) -> None:
+        time.sleep(seconds)  # pragma: nocover
+
+
+class AsyncNetworkStream:
+    async def read(
+        self, max_bytes: int, timeout: typing.Optional[float] = None
+    ) -> bytes:
+        raise NotImplementedError()  # pragma: nocover
+
+    async def write(
+        self, buffer: bytes, timeout: typing.Optional[float] = None
+    ) -> None:
+        raise NotImplementedError()  # pragma: nocover
+
+    async def aclose(self) -> None:
+        raise NotImplementedError()  # pragma: nocover
+
+    async def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> "AsyncNetworkStream":
+        raise NotImplementedError()  # pragma: nocover
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return None  # pragma: nocover
+
+
+class AsyncNetworkBackend:
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: typing.Optional[float] = None,
+        local_address: typing.Optional[str] = None,
+    ) -> AsyncNetworkStream:
+        raise NotImplementedError()  # pragma: nocover
+
+    async def connect_unix_socket(
+        self, path: str, timeout: typing.Optional[float] = None
+    ) -> AsyncNetworkStream:
+        raise NotImplementedError()  # pragma: nocover
+
+    async def sleep(self, seconds: float) -> None:
+        raise NotImplementedError()  # pragma: nocover
diff --git a/myenv/lib/python3.9/site-packages/httpcore/backends/mock.py b/myenv/lib/python3.9/site-packages/httpcore/backends/mock.py
new file mode 100644
index 0000000..8491f6d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/backends/mock.py
@@ -0,0 +1,115 @@
+import ssl
+import typing
+from typing import Optional
+
+from .base import AsyncNetworkBackend, AsyncNetworkStream, NetworkBackend, NetworkStream
+
+
+class MockSSLObject:
+    def __init__(self, http2: bool):
+        self._http2 = http2
+
+    def selected_alpn_protocol(self) -> str:
+        return "h2" if self._http2 else "http/1.1"
+
+
+class MockStream(NetworkStream):
+    def __init__(self, buffer: typing.List[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+
+    def read(self, max_bytes: int, timeout: Optional[float] = None) -> bytes:
+        if not self._buffer:
+            return b""
+        return self._buffer.pop(0)
+
+    def write(self, buffer: bytes, timeout: Optional[float] = None) -> None:
+        pass
+
+    def close(self) -> None:
+        pass
+
+    def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> NetworkStream:
+        return self
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return MockSSLObject(http2=self._http2) if info == "ssl_object" else None
+
+
+class MockBackend(NetworkBackend):
+    def __init__(self, buffer: typing.List[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+
+    def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: Optional[float] = None,
+        local_address: Optional[str] = None,
+    ) -> NetworkStream:
+        return MockStream(list(self._buffer), http2=self._http2)
+
+    def connect_unix_socket(
+        self, path: str, timeout: Optional[float] = None
+    ) -> NetworkStream:
+        return MockStream(list(self._buffer), http2=self._http2)
+
+    def sleep(self, seconds: float) -> None:
+        pass
+
+
+class AsyncMockStream(AsyncNetworkStream):
+    def __init__(self, buffer: typing.List[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+
+    async def read(self, max_bytes: int, timeout: Optional[float] = None) -> bytes:
+        if not self._buffer:
+            return b""
+        return self._buffer.pop(0)
+
+    async def write(self, buffer: bytes, timeout: Optional[float] = None) -> None:
+        pass
+
+    async def aclose(self) -> None:
+        pass
+
+    async def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> AsyncNetworkStream:
+        return self
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return MockSSLObject(http2=self._http2) if info == "ssl_object" else None
+
+
+class AsyncMockBackend(AsyncNetworkBackend):
+    def __init__(self, buffer: typing.List[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: Optional[float] = None,
+        local_address: Optional[str] = None,
+    ) -> AsyncNetworkStream:
+        return AsyncMockStream(list(self._buffer), http2=self._http2)
+
+    async def connect_unix_socket(
+        self, path: str, timeout: Optional[float] = None
+    ) -> AsyncNetworkStream:
+        return AsyncMockStream(list(self._buffer), http2=self._http2)
+
+    async def sleep(self, seconds: float) -> None:
+        pass
diff --git a/myenv/lib/python3.9/site-packages/httpcore/backends/sync.py b/myenv/lib/python3.9/site-packages/httpcore/backends/sync.py
new file mode 100644
index 0000000..18e1dd3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/backends/sync.py
@@ -0,0 +1,99 @@
+import socket
+import ssl
+import typing
+
+from .._exceptions import (
+    ConnectError,
+    ConnectTimeout,
+    ReadError,
+    ReadTimeout,
+    WriteError,
+    WriteTimeout,
+    map_exceptions,
+)
+from .._utils import is_socket_readable
+from .base import NetworkBackend, NetworkStream
+
+
+class SyncStream(NetworkStream):
+    def __init__(self, sock: socket.socket) -> None:
+        self._sock = sock
+
+    def read(self, max_bytes: int, timeout: typing.Optional[float] = None) -> bytes:
+        exc_map = {socket.timeout: ReadTimeout, socket.error: ReadError}
+        with map_exceptions(exc_map):
+            self._sock.settimeout(timeout)
+            return self._sock.recv(max_bytes)
+
+    def write(self, buffer: bytes, timeout: typing.Optional[float] = None) -> None:
+        if not buffer:
+            return
+
+        exc_map = {socket.timeout: WriteTimeout, socket.error: WriteError}
+        with map_exceptions(exc_map):
+            while buffer:
+                self._sock.settimeout(timeout)
+                n = self._sock.send(buffer)
+                buffer = buffer[n:]
+
+    def close(self) -> None:
+        self._sock.close()
+
+    def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> NetworkStream:
+        exc_map = {socket.timeout: ConnectTimeout, socket.error: ConnectError}
+        with map_exceptions(exc_map):
+            try:
+                self._sock.settimeout(timeout)
+                sock = ssl_context.wrap_socket(
+                    self._sock, server_hostname=server_hostname
+                )
+            except Exception as exc:  # pragma: nocover
+                self.close()
+                raise exc
+        return SyncStream(sock)
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        if info == "ssl_object" and isinstance(self._sock, ssl.SSLSocket):
+            return self._sock._sslobj  # type: ignore
+        if info == "client_addr":
+            return self._sock.getsockname()
+        if info == "server_addr":
+            return self._sock.getpeername()
+        if info == "socket":
+            return self._sock
+        if info == "is_readable":
+            return is_socket_readable(self._sock)
+        return None
+
+
+class SyncBackend(NetworkBackend):
+    def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: typing.Optional[float] = None,
+        local_address: typing.Optional[str] = None,
+    ) -> NetworkStream:
+        address = (host, port)
+        source_address = None if local_address is None else (local_address, 0)
+        exc_map = {socket.timeout: ConnectTimeout, socket.error: ConnectError}
+        with map_exceptions(exc_map):
+            sock = socket.create_connection(
+                address, timeout, source_address=source_address
+            )
+        return SyncStream(sock)
+
+    def connect_unix_socket(
+        self, path: str, timeout: typing.Optional[float] = None
+    ) -> NetworkStream:  # pragma: nocover
+        exc_map = {socket.timeout: ConnectTimeout, socket.error: ConnectError}
+        with map_exceptions(exc_map):
+            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            sock.settimeout(timeout)
+            sock.connect(path)
+        return SyncStream(sock)
diff --git a/myenv/lib/python3.9/site-packages/httpcore/backends/trio.py b/myenv/lib/python3.9/site-packages/httpcore/backends/trio.py
new file mode 100644
index 0000000..c1d9794
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpcore/backends/trio.py
@@ -0,0 +1,142 @@
+import ssl
+import typing
+
+import trio
+
+from .._exceptions import (
+    ConnectError,
+    ConnectTimeout,
+    ReadError,
+    ReadTimeout,
+    WriteError,
+    WriteTimeout,
+    map_exceptions,
+)
+from .base import AsyncNetworkBackend, AsyncNetworkStream
+
+
+class TrioStream(AsyncNetworkStream):
+    def __init__(self, stream: trio.abc.Stream) -> None:
+        self._stream = stream
+
+    async def read(
+        self, max_bytes: int, timeout: typing.Optional[float] = None
+    ) -> bytes:
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map = {trio.TooSlowError: ReadTimeout, trio.BrokenResourceError: ReadError}
+        with map_exceptions(exc_map):
+            with trio.fail_after(timeout_or_inf):
+                return await self._stream.receive_some(max_bytes=max_bytes)
+
+    async def write(
+        self, buffer: bytes, timeout: typing.Optional[float] = None
+    ) -> None:
+        if not buffer:
+            return
+
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map = {
+            trio.TooSlowError: WriteTimeout,
+            trio.BrokenResourceError: WriteError,
+        }
+        with map_exceptions(exc_map):
+            with trio.fail_after(timeout_or_inf):
+                await self._stream.send_all(data=buffer)
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+    async def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncNetworkStream:
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map = {
+            trio.TooSlowError: ConnectTimeout,
+            trio.BrokenResourceError: ConnectError,
+        }
+        ssl_stream = trio.SSLStream(
+            self._stream,
+            ssl_context=ssl_context,
+            server_hostname=server_hostname,
+            https_compatible=True,
+            server_side=False,
+        )
+        with map_exceptions(exc_map):
+            try:
+                with trio.fail_after(timeout_or_inf):
+                    await ssl_stream.do_handshake()
+            except Exception as exc:  # pragma: nocover
+                await self.aclose()
+                raise exc
+        return TrioStream(ssl_stream)
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        if info == "ssl_object" and isinstance(self._stream, trio.SSLStream):
+            return self._stream._ssl_object  # type: ignore
+        if info == "client_addr":
+            return self._get_socket_stream().socket.getsockname()
+        if info == "server_addr":
+            return self._get_socket_stream().socket.getpeername()
+        if info == "socket":
+            stream = self._stream
+            while isinstance(stream, trio.SSLStream):
+                stream = stream.transport_stream
+            assert isinstance(stream, trio.SocketStream)
+            return stream.socket
+        if info == "is_readable":
+            socket = self.get_extra_info("socket")
+            return socket.is_readable()
+        return None
+
+    def _get_socket_stream(self) -> trio.SocketStream:
+        stream = self._stream
+        while isinstance(stream, trio.SSLStream):
+            stream = stream.transport_stream
+        assert isinstance(stream, trio.SocketStream)
+        return stream
+
+
+class TrioBackend(AsyncNetworkBackend):
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: typing.Optional[float] = None,
+        local_address: typing.Optional[str] = None,
+    ) -> AsyncNetworkStream:
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map = {
+            trio.TooSlowError: ConnectTimeout,
+            trio.BrokenResourceError: ConnectError,
+            OSError: ConnectError,
+        }
+        # Trio supports 'local_address' from 0.16.1 onwards.
+        # We only include the keyword argument if a local_address
+        # argument has been passed.
+        kwargs: dict = {} if local_address is None else {"local_address": local_address}
+        with map_exceptions(exc_map):
+            with trio.fail_after(timeout_or_inf):
+                stream: trio.abc.Stream = await trio.open_tcp_stream(
+                    host=host, port=port, **kwargs
+                )
+        return TrioStream(stream)
+
+    async def connect_unix_socket(
+        self, path: str, timeout: typing.Optional[float] = None
+    ) -> AsyncNetworkStream:  # pragma: nocover
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map = {
+            trio.TooSlowError: ConnectTimeout,
+            trio.BrokenResourceError: ConnectError,
+            OSError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            with trio.fail_after(timeout_or_inf):
+                stream: trio.abc.Stream = await trio.open_unix_socket(path)
+        return TrioStream(stream)
+
+    async def sleep(self, seconds: float) -> None:
+        await trio.sleep(seconds)  # pragma: nocover
diff --git a/myenv/lib/python3.9/site-packages/httpcore/py.typed b/myenv/lib/python3.9/site-packages/httpcore/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/LICENSE
new file mode 100644
index 0000000..79a03ca
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/LICENSE
@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015 MagicStack Inc.  http://magic.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/METADATA
new file mode 100644
index 0000000..77d6e49
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/METADATA
@@ -0,0 +1,135 @@
+Metadata-Version: 2.1
+Name: httptools
+Version: 0.3.0
+Summary: A collection of framework independent HTTP protocol utils.
+Home-page: https://github.com/MagicStack/httptools
+Author: Yury Selivanov
+Author-email: yury@magic.io
+License: MIT
+Platform: macOS
+Platform: POSIX
+Platform: Windows
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Environment :: Web Environment
+Classifier: Development Status :: 5 - Production/Stable
+Requires-Python: >=3.5.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: Cython (<0.30.0,>=0.29.24) ; extra == 'test'
+
+![Tests](https://github.com/MagicStack/httptools/workflows/Tests/badge.svg)
+
+httptools is a Python binding for the nodejs HTTP parser.
+
+The package is available on PyPI: `pip install httptools`.
+
+
+# APIs
+
+httptools contains two classes `httptools.HttpRequestParser`,
+`httptools.HttpResponseParser` (fulfilled through
+[llhttp](https://github.com/nodejs/llhttp)) and a function for
+parsing URLs `httptools.parse_url` (through
+[http-parse](https://github.com/nodejs/http-parser) for now).
+See unittests for examples.
+
+
+```python
+
+class HttpRequestParser:
+
+    def __init__(self, protocol):
+        """HttpRequestParser
+
+        protocol -- a Python object with the following methods
+        (all optional):
+
+          - on_message_begin()
+          - on_url(url: bytes)
+          - on_header(name: bytes, value: bytes)
+          - on_headers_complete()
+          - on_body(body: bytes)
+          - on_message_complete()
+          - on_chunk_header()
+          - on_chunk_complete()
+          - on_status(status: bytes)
+        """
+
+    def get_http_version(self) -> str:
+        """Return an HTTP protocol version."""
+
+    def should_keep_alive(self) -> bool:
+        """Return ``True`` if keep-alive mode is preferred."""
+
+    def should_upgrade(self) -> bool:
+        """Return ``True`` if the parsed request is a valid Upgrade request.
+	The method exposes a flag set just before on_headers_complete.
+	Calling this method earlier will only yield `False`.
+	"""
+
+    def feed_data(self, data: bytes):
+        """Feed data to the parser.
+
+        Will eventually trigger callbacks on the ``protocol``
+        object.
+
+        On HTTP upgrade, this method will raise an
+        ``HttpParserUpgrade`` exception, with its sole argument
+        set to the offset of the non-HTTP data in ``data``.
+        """
+
+    def get_method(self) -> bytes:
+        """Return HTTP request method (GET, HEAD, etc)"""
+
+
+class HttpResponseParser:
+
+    """Has all methods except ``get_method()`` that
+    HttpRequestParser has."""
+
+    def get_status_code(self) -> int:
+        """Return the status code of the HTTP response"""
+
+
+def parse_url(url: bytes):
+    """Parse URL strings into a structured Python object.
+
+    Returns an instance of ``httptools.URL`` class with the
+    following attributes:
+
+      - schema: bytes
+      - host: bytes
+      - port: int
+      - path: bytes
+      - query: bytes
+      - fragment: bytes
+      - userinfo: bytes
+    """
+```
+
+
+# Development
+
+1. Clone this repository with
+   `git clone --recursive git@github.com:MagicStack/httptools.git`
+
+2. Create a virtual environment with Python 3:
+   `python3 -m venv envname`
+
+3. Activate the environment with `source envname/bin/activate`
+
+4. Install development requirements with `pip install -e .[test]`
+
+5. Run `make` and `make test`.
+
+
+# License
+
+MIT.
+
+
diff --git a/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/RECORD
new file mode 100644
index 0000000..a0fc539
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/RECORD
@@ -0,0 +1,14 @@
+httptools-0.3.0.dist-info/LICENSE,sha256=9Fc-fLdnZ0X7W402-lSKqT45HPtoct2s1lEwxF6mqS0,1093
+httptools-0.3.0.dist-info/WHEEL,sha256=bRe_g_g-vZInZP5wOdewl-4AeWx8E2_UC3Ffr2csPyk,109
+httptools-0.3.0.dist-info/top_level.txt,sha256=APjJKTbZcj0OQ4fdgf2eTCk82nK1n2BFXOD7ky41MPY,10
+httptools-0.3.0.dist-info/METADATA,sha256=dpBDixuRjdq-QLwIgV5XqxUcLzZeMgM6g7GCpdjZDSg,3597
+httptools/_version.py,sha256=b8pdihIYuOWdO3Rpi5ZLDFTAiW4v4IwK95V14jBWrzw,575
+httptools/__init__.py,sha256=plt3MIbueJdco9Dy7zoH3ksLNeyirqWagat5rwRmAjo,147
+httptools/parser/url_parser.cpython-39-darwin.so,sha256=CWNauH_HaYaaso1U4BpCr0mjNDP5DLZXzBpbLfZBV8U,89080
+httptools/parser/parser.cpython-39-darwin.so,sha256=FHIawJFL9Dcpxc5N2WLQ5r0jHLjZQb9yyt1HQwoqhNI,148944
+httptools/parser/__init__.py,sha256=fWyconPEHZlJojzRwmBKSn4C85OGXmKEwiEcdjHqXO8,166
+httptools/parser/url_parser.c,sha256=gZj4QulPeuygRPfjX4qxOBccjoOsOYQNTZXqaLWatSk,232605
+httptools/parser/errors.py,sha256=ZVrtN1smPIb_opQ2Ud3uCbGlNLMlECYM2-6S7r5LnHs,566
+httptools/parser/parser.c,sha256=QILAMkPuFSa_CQGJJfIZU6fBsxQVWMmpUsSkbdiYk8I,395897
+httptools-0.3.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+httptools-0.3.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/WHEEL
new file mode 100644
index 0000000..868d54a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_9_x86_64
+
diff --git a/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/top_level.txt
new file mode 100644
index 0000000..bef3b40
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools-0.3.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+httptools
diff --git a/myenv/lib/python3.9/site-packages/httptools/__init__.py b/myenv/lib/python3.9/site-packages/httptools/__init__.py
new file mode 100644
index 0000000..972053e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools/__init__.py
@@ -0,0 +1,6 @@
+from . import parser
+from .parser import *  # NOQA
+
+from ._version import __version__  # NOQA
+
+__all__ = parser.__all__ + ('__version__',)  # NOQA
diff --git a/myenv/lib/python3.9/site-packages/httptools/_version.py b/myenv/lib/python3.9/site-packages/httptools/_version.py
new file mode 100644
index 0000000..1878dfc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools/_version.py
@@ -0,0 +1,13 @@
+# This file MUST NOT contain anything but the __version__ assignment.
+#
+# When making a release, change the value of __version__
+# to an appropriate value, and open a pull request against
+# the correct branch (master if making a new feature release).
+# The commit message MUST contain a properly formatted release
+# log, and the commit must be signed.
+#
+# The release automation will: build and test the packages for the
+# supported platforms, publish the packages on PyPI, merge the PR
+# to the target branch, create a Git tag pointing to the commit.
+
+__version__ = '0.3.0'
diff --git a/myenv/lib/python3.9/site-packages/httptools/parser/__init__.py b/myenv/lib/python3.9/site-packages/httptools/parser/__init__.py
new file mode 100644
index 0000000..ba371f5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools/parser/__init__.py
@@ -0,0 +1,5 @@
+from .parser import *  # NoQA
+from .errors import *  # NoQA
+from .url_parser import *  # NoQA
+
+__all__ = parser.__all__ + errors.__all__ + url_parser.__all__  # NoQA
diff --git a/myenv/lib/python3.9/site-packages/httptools/parser/errors.py b/myenv/lib/python3.9/site-packages/httptools/parser/errors.py
new file mode 100644
index 0000000..bc24c46
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools/parser/errors.py
@@ -0,0 +1,30 @@
+__all__ = ('HttpParserError',
+           'HttpParserCallbackError',
+           'HttpParserInvalidStatusError',
+           'HttpParserInvalidMethodError',
+           'HttpParserInvalidURLError',
+           'HttpParserUpgrade')
+
+
+class HttpParserError(Exception):
+    pass
+
+
+class HttpParserCallbackError(HttpParserError):
+    pass
+
+
+class HttpParserInvalidStatusError(HttpParserError):
+    pass
+
+
+class HttpParserInvalidMethodError(HttpParserError):
+    pass
+
+
+class HttpParserInvalidURLError(HttpParserError):
+    pass
+
+
+class HttpParserUpgrade(Exception):
+    pass
diff --git a/myenv/lib/python3.9/site-packages/httptools/parser/parser.c b/myenv/lib/python3.9/site-packages/httptools/parser/parser.c
new file mode 100644
index 0000000..c3c2428
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools/parser/parser.c
@@ -0,0 +1,10319 @@
+/* Generated by Cython 0.29.24 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "name": "httptools.parser.parser",
+        "sources": [
+            "httptools/parser/parser.pyx"
+        ]
+    },
+    "module_name": "httptools.parser.parser"
+}
+END: Cython Metadata */
+
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif /* PY_SSIZE_T_CLEAN */
+#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+.
+#else
+#define CYTHON_ABI "0_29_24"
+#define CYTHON_HEX_VERSION 0x001D18F0
+#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)
+  #ifndef __stdcall
+    #define __stdcall
+  #endif
+  #ifndef __cdecl
+    #define __cdecl
+  #endif
+  #ifndef __fastcall
+    #define __fastcall
+  #endif
+#endif
+#ifndef DL_IMPORT
+  #define DL_IMPORT(t) t
+#endif
+#ifndef DL_EXPORT
+  #define DL_EXPORT(t) t
+#endif
+#define __PYX_COMMA ,
+#ifndef HAVE_LONG_LONG
+  #if PY_VERSION_HEX >= 0x02070000
+    #define HAVE_LONG_LONG
+  #endif
+#endif
+#ifndef PY_LONG_LONG
+  #define PY_LONG_LONG LONG_LONG
+#endif
+#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 CYTHON_COMPILING_IN_CPYTHON 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #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_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #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_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+#elif defined(PYSTON_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 1
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #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
+  #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_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #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_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+#else
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 1
+  #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)
+    #define CYTHON_USE_PYTYPE_LOOKUP 1
+  #endif
+  #if PY_MAJOR_VERSION < 3
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #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)
+    #define CYTHON_USE_PYLONG_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_PYLIST_INTERNALS
+    #define CYTHON_USE_PYLIST_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #if PY_VERSION_HEX < 0x030300F0
+    #undef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
+  #elif !defined(CYTHON_USE_UNICODE_WRITER)
+    #define CYTHON_USE_UNICODE_WRITER 1
+  #endif
+  #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
+  #ifndef CYTHON_FAST_THREAD_STATE
+    #define CYTHON_FAST_THREAD_STATE 1
+  #endif
+  #ifndef CYTHON_FAST_PYCALL
+    #define CYTHON_FAST_PYCALL 1
+  #endif
+  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #endif
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #endif
+  #ifndef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #endif
+  #ifndef CYTHON_USE_EXC_INFO_STACK
+    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+  #endif
+#endif
+#if !defined(CYTHON_FAST_PYCCALL)
+#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+  #include "longintrepr.h"
+  #undef SHIFT
+  #undef BASE
+  #undef MASK
+  #ifdef SIZEOF_VOID_P
+    enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
+  #endif
+#endif
+#ifndef __has_attribute
+  #define __has_attribute(x) 0
+#endif
+#ifndef __has_cpp_attribute
+  #define __has_cpp_attribute(x) 0
+#endif
+#ifndef CYTHON_RESTRICT
+  #if defined(__GNUC__)
+    #define CYTHON_RESTRICT __restrict__
+  #elif defined(_MSC_VER) && _MSC_VER >= 1400
+    #define CYTHON_RESTRICT __restrict
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_RESTRICT restrict
+  #else
+    #define CYTHON_RESTRICT
+  #endif
+#endif
+#ifndef CYTHON_UNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define CYTHON_UNUSED __attribute__ ((__unused__))
+#   else
+#     define CYTHON_UNUSED
+#   endif
+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
+#   define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+#   define CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+#  if defined(__cplusplus)
+     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+#  else
+#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#  endif
+#endif
+#ifndef CYTHON_NCP_UNUSED
+# if CYTHON_COMPILING_IN_CPYTHON
+#  define CYTHON_NCP_UNUSED
+# else
+#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
+# 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;
+        #else
+           typedef unsigned __int8   uint8_t;
+           typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+#else
+   #include <stdint.h>
+#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]]
+    #endif
+  #endif
+  #ifndef CYTHON_FALLTHROUGH
+    #if __has_attribute(fallthrough)
+      #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
+    #else
+      #define CYTHON_FALLTHROUGH
+    #endif
+  #endif
+  #if defined(__clang__ ) && defined(__apple_build_version__)
+    #if __apple_build_version__ < 7000000
+      #undef  CYTHON_FALLTHROUGH
+      #define CYTHON_FALLTHROUGH
+    #endif
+  #endif
+#endif
+
+#ifndef CYTHON_INLINE
+  #if defined(__clang__)
+    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
+  #elif defined(__GNUC__)
+    #define CYTHON_INLINE __inline__
+  #elif defined(_MSC_VER)
+    #define CYTHON_INLINE __inline
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_INLINE inline
+  #else
+    #define CYTHON_INLINE
+  #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
+#else
+  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
+#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a, 0, 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)\
+          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#endif
+  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+  #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+  #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+  #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef METH_STACKLESS
+  #define METH_STACKLESS 0
+#endif
+#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
+  #ifndef METH_FASTCALL
+     #define METH_FASTCALL 0x80
+  #endif
+  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
+  typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
+                                                          Py_ssize_t nargs, PyObject *kwnames);
+#else
+  #define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+#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)))))
+#else
+#define __Pyx_PyFastCFunction_Check(func) 0
+#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)
+#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
+  #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x03060000
+  #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
+#elif PY_VERSION_HEX >= 0x03000000
+  #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#else
+  #define __Pyx_PyThreadState_Current _PyThreadState_Current
+#endif
+#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
+#include "pythread.h"
+#define Py_tss_NEEDS_INIT 0
+typedef int Py_tss_t;
+static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
+  *key = PyThread_create_key();
+  return 0;
+}
+static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
+  Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
+  *key = Py_tss_NEEDS_INIT;
+  return key;
+}
+static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
+  PyObject_Free(key);
+}
+static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
+  return *key != Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
+  PyThread_delete_key(*key);
+  *key = Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
+  return PyThread_set_key_value(*key, value);
+}
+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)
+#define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
+#else
+#define __Pyx_PyDict_NewPresized(n)  PyDict_New()
+#endif
+#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
+#else
+  #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)
+#else
+#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#endif
+#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #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)
+  #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_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
+  #else
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+  #endif
+#else
+  #define CYTHON_PEP393_ENABLED 0
+  #define PyUnicode_1BYTE_KIND  1
+  #define PyUnicode_2BYTE_KIND  2
+  #define PyUnicode_4BYTE_KIND  4
+  #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_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_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
+#else
+  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
+  #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)
+#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))
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
+#else
+  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
+#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+  #define PyObject_ASCII(o)            PyObject_Repr(o)
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBaseString_Type            PyUnicode_Type
+  #define PyStringObject               PyUnicodeObject
+  #define PyString_Type                PyUnicode_Type
+  #define PyString_Check               PyUnicode_Check
+  #define PyString_CheckExact          PyUnicode_CheckExact
+#ifndef PyObject_Unicode
+  #define PyObject_Unicode             PyObject_Str
+#endif
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
+  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#else
+  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
+  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+#endif
+#ifndef PySet_CheckExact
+  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+#endif
+#if PY_VERSION_HEX >= 0x030900A4
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
+#else
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
+#endif
+#if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+#else
+  #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+#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 PyInt_FromString             PyLong_FromString
+  #define PyInt_FromUnicode            PyLong_FromUnicode
+  #define PyInt_FromLong               PyLong_FromLong
+  #define PyInt_FromSize_t             PyLong_FromSize_t
+  #define PyInt_FromSsize_t            PyLong_FromSsize_t
+  #define PyInt_AsLong                 PyLong_AsLong
+  #define PyInt_AS_LONG                PyLong_AS_LONG
+  #define PyInt_AsSsize_t              PyLong_AsSsize_t
+  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
+  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+  #define PyNumber_Int                 PyNumber_Long
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBoolObject                 PyLongObject
+#endif
+#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
+  #ifndef PyUnicode_InternFromString
+    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+  #endif
+#endif
+#if PY_VERSION_HEX < 0x030200A4
+  typedef long Py_hash_t;
+  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
+#else
+  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
+  #define __Pyx_PyInt_AsHash_t   PyInt_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
+    #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
+  #else
+    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
+  #endif
+#else
+  #define __Pyx_PyType_AsAsync(obj) NULL
+#endif
+#ifndef __Pyx_PyAsyncMethodsStruct
+    typedef struct {
+        unaryfunc am_await;
+        unaryfunc am_aiter;
+        unaryfunc am_anext;
+    } __Pyx_PyAsyncMethodsStruct;
+#endif
+
+#if defined(WIN32) || defined(MS_WINDOWS)
+  #define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+#ifdef NAN
+#define __PYX_NAN() ((float) NAN)
+#else
+static CYTHON_INLINE float __PYX_NAN() {
+  float value;
+  memset(&value, 0xFF, sizeof(value));
+  return value;
+}
+#endif
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#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; }
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+    { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
+
+#ifndef __PYX_EXTERN_C
+  #ifdef __cplusplus
+    #define __PYX_EXTERN_C extern "C"
+  #else
+    #define __PYX_EXTERN_C extern
+  #endif
+#endif
+
+#define __PYX_HAVE__httptools__parser__parser
+#define __PYX_HAVE_API__httptools__parser__parser
+/* Early includes */
+#include <string.h>
+#include <stdio.h>
+#include "pythread.h"
+#include <stdint.h>
+#include "llhttp.h"
+#ifdef _OPENMP
+#include <omp.h>
+#endif /* _OPENMP */
+
+#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
+                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
+    (sizeof(type) < sizeof(Py_ssize_t))  ||\
+    (sizeof(type) > sizeof(Py_ssize_t) &&\
+          likely(v < (type)PY_SSIZE_T_MAX ||\
+                 v == (type)PY_SSIZE_T_MAX)  &&\
+          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+                                v == (type)PY_SSIZE_T_MIN)))  ||\
+    (sizeof(type) == sizeof(Py_ssize_t) &&\
+          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+                               v == (type)PY_SSIZE_T_MAX)))  )
+static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
+    return (size_t) i < (size_t) limit;
+}
+#if defined (__cplusplus) && __cplusplus >= 201103L
+    #include <cstdlib>
+    #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER)
+    #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+    #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+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))
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString        PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+#if PY_MAJOR_VERSION < 3
+    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#else
+    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
+#endif
+#define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AS_STRING(s))
+#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_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)
+#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
+#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_AsUnicode            PyUnicode_AsUnicode
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+#define __Pyx_PySequence_Tuple(obj)\
+    (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#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;
+    const char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    if (strcmp(default_encoding_c, "ascii") == 0) {
+        __Pyx_sys_getdefaultencoding_not_ascii = 0;
+    } else {
+        char ascii_chars[128];
+        int c;
+        for (c = 0; c < 128; c++) {
+            ascii_chars[c] = c;
+        }
+        __Pyx_sys_getdefaultencoding_not_ascii = 1;
+        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+        if (!ascii_chars_u) goto bad;
+        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+            PyErr_Format(
+                PyExc_ValueError,
+                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+                default_encoding_c);
+            goto bad;
+        }
+        Py_DECREF(ascii_chars_u);
+        Py_DECREF(ascii_chars_b);
+    }
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    Py_XDECREF(ascii_chars_u);
+    Py_XDECREF(ascii_chars_b);
+    return -1;
+}
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#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
+static char* __PYX_DEFAULT_STRING_ENCODING;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
+    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    return -1;
+}
+#endif
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+  #define likely(x)   __builtin_expect(!!(x), 1)
+  #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+  #define likely(x)   (x)
+  #define unlikely(x) (x)
+#endif /* __GNUC__ */
+static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
+
+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;
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * __pyx_cfilenm= __FILE__;
+static const char *__pyx_filename;
+
+
+static const char *__pyx_f[] = {
+  "httptools/parser/parser.pyx",
+  "stringsource",
+  ".eggs/Cython-0.29.24-py3.9-macosx-10.9-x86_64.egg/Cython/Includes/cpython/type.pxd",
+  ".eggs/Cython-0.29.24-py3.9-macosx-10.9-x86_64.egg/Cython/Includes/cpython/bool.pxd",
+  ".eggs/Cython-0.29.24-py3.9-macosx-10.9-x86_64.egg/Cython/Includes/cpython/complex.pxd",
+};
+
+/*--- Type declarations ---*/
+struct __pyx_obj_9httptools_6parser_6parser_HttpParser;
+struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser;
+struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser;
+
+/* "httptools/parser/parser.pyx":26
+ * 
+ * @cython.internal
+ * cdef class HttpParser:             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+struct __pyx_obj_9httptools_6parser_6parser_HttpParser {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser *__pyx_vtab;
+  llhttp_t *_cparser;
+  llhttp_settings_t *_csettings;
+  PyObject *_current_header_name;
+  PyObject *_current_header_value;
+  PyObject *_proto_on_url;
+  PyObject *_proto_on_status;
+  PyObject *_proto_on_body;
+  PyObject *_proto_on_header;
+  PyObject *_proto_on_headers_complete;
+  PyObject *_proto_on_message_complete;
+  PyObject *_proto_on_chunk_header;
+  PyObject *_proto_on_chunk_complete;
+  PyObject *_proto_on_message_begin;
+  PyObject *_last_error;
+  Py_buffer py_buf;
+};
+
+
+/* "httptools/parser/parser.pyx":215
+ * 
+ * 
+ * cdef class HttpRequestParser(HttpParser):             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self, protocol):
+ */
+struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser __pyx_base;
+};
+
+
+/* "httptools/parser/parser.pyx":229
+ * 
+ * 
+ * cdef class HttpResponseParser(HttpParser):             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self, protocol):
+ */
+struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser __pyx_base;
+};
+
+
+
+/* "httptools/parser/parser.pyx":26
+ * 
+ * @cython.internal
+ * cdef class HttpParser:             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+
+struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser {
+  PyObject *(*_init)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *, PyObject *, llhttp_type_t);
+  PyObject *(*_maybe_call_on_header)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *);
+  PyObject *(*_on_header_field)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *, PyObject *);
+  PyObject *(*_on_header_value)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *, PyObject *);
+  PyObject *(*_on_headers_complete)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *);
+  PyObject *(*_on_chunk_header)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *);
+  PyObject *(*_on_chunk_complete)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *);
+};
+static struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser *__pyx_vtabptr_9httptools_6parser_6parser_HttpParser;
+
+
+/* "httptools/parser/parser.pyx":215
+ * 
+ * 
+ * cdef class HttpRequestParser(HttpParser):             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self, protocol):
+ */
+
+struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpRequestParser {
+  struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser __pyx_base;
+};
+static struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpRequestParser *__pyx_vtabptr_9httptools_6parser_6parser_HttpRequestParser;
+
+
+/* "httptools/parser/parser.pyx":229
+ * 
+ * 
+ * cdef class HttpResponseParser(HttpParser):             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self, protocol):
+ */
+
+struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpResponseParser {
+  struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser __pyx_base;
+};
+static struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpResponseParser *__pyx_vtabptr_9httptools_6parser_6parser_HttpResponseParser;
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+  #define CYTHON_REFNANNY 0
+#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 (*FinishContext)(void**);
+  } __Pyx_RefNannyAPIStruct;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+#ifdef WITH_THREAD
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          if (acquire_gil) {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              PyGILState_Release(__pyx_gilstate_save);\
+          } else {\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+          }
+#else
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+#endif
+  #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)
+#else
+  #define __Pyx_RefNannyDeclarations
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContext()
+  #define __Pyx_INCREF(r) Py_INCREF(r)
+  #define __Pyx_DECREF(r) Py_DECREF(r)
+  #define __Pyx_GOTREF(r)
+  #define __Pyx_GIVEREF(r)
+  #define __Pyx_XINCREF(r) Py_XINCREF(r)
+  #define __Pyx_XDECREF(r) Py_XDECREF(r)
+  #define __Pyx_XGOTREF(r)
+  #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_XDECREF(tmp);\
+    } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_DECREF(tmp);\
+    } while (0)
+#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);
+
+/* 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;
+#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
+
+/* GetAttr.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *);
+
+/* GetAttr3.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *);
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#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
+  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
+
+/* 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
+
+/* 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
+
+/* 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
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyDictVersioning.proto */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+#define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
+#define __PYX_GET_DICT_VERSION(dict)  (((PyDictObject*)(dict))->ma_version_tag)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
+    (version_var) = __PYX_GET_DICT_VERSION(dict);\
+    (cache_var) = (value);
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
+    static PY_UINT64_T __pyx_dict_version = 0;\
+    static PyObject *__pyx_dict_cached_value = NULL;\
+    if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
+        (VAR) = __pyx_dict_cached_value;\
+    } else {\
+        (VAR) = __pyx_dict_cached_value = (LOOKUP);\
+        __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
+    }\
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
+#else
+#define __PYX_GET_DICT_VERSION(dict)  (0)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP)  (VAR) = (LOOKUP);
+#endif
+
+/* GetModuleGlobalName.proto */
+#if CYTHON_USE_DICT_VERSIONS
+#define __Pyx_GetModuleGlobalName(var, name)  {\
+    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)  {\
+    PY_UINT64_T __pyx_dict_version;\
+    PyObject *__pyx_dict_cached_value;\
+    (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
+}
+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)
+#define __Pyx_GetModuleGlobalNameUncached(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
+#endif
+
+/* PyObjectCall2Args.proto */
+static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
+
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* GetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* SwapException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSwap(type, value, tb)  __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* GetTopmostException.proto */
+#if CYTHON_USE_EXC_INFO_STACK
+static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
+#endif
+
+/* SaveResetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+#else
+#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
+#endif
+
+/* PyObjectSetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL)
+static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value);
+#else
+#define __Pyx_PyObject_DelAttrStr(o,n)   PyObject_DelAttr(o,n)
+#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v)
+#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,\
+    const char* function_name);
+
+/* decode_c_string_utf16.proto */
+static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) {
+    int byteorder = 0;
+    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
+}
+static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) {
+    int byteorder = -1;
+    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
+}
+static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) {
+    int byteorder = 1;
+    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
+}
+
+/* decode_c_bytes.proto */
+static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes(
+         const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));
+
+/* decode_bytes.proto */
+static CYTHON_INLINE PyObject* __Pyx_decode_bytes(
+         PyObject* string, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
+    return __Pyx_decode_c_bytes(
+        PyBytes_AS_STRING(string), PyBytes_GET_SIZE(string),
+        start, stop, encoding, errors, decode_func);
+}
+
+/* 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);
+#else
+#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr
+#endif
+
+/* PyObject_GenericGetAttr.proto */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
+#endif
+
+/* SetVTable.proto */
+static int __Pyx_SetVtable(PyObject *dict, void *vtable);
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* SetupReduce.proto */
+static int __Pyx_setup_reduce(PyObject* type_obj);
+
+/* 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
+};
+static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+#endif
+
+/* Import.proto */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+
+/* ImportFrom.proto */
+static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
+
+/* CLineInTraceback.proto */
+#ifdef CYTHON_CLINE_IN_TRACEBACK
+#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
+#else
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
+#endif
+
+/* CodeObjectCache.proto */
+typedef struct {
+    PyCodeObject* code_object;
+    int code_line;
+} __Pyx_CodeObjectCacheEntry;
+struct __Pyx_CodeObjectCache {
+    int count;
+    int max_count;
+    __Pyx_CodeObjectCacheEntry* entries;
+};
+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);
+
+/* 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))
+#define __Pyx_HAS_GCC_DIAGNOSTIC
+#endif
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint8_t(uint8_t value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_ptrdiff_t(ptrdiff_t value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint16_t(uint16_t value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+
+/* CIntFromPy.proto */
+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)
+static CYTHON_INLINE int __Pyx_IsSubtype(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_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_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(void);
+
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__init(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_protocol, llhttp_type_t __pyx_v_mode); /* proto*/
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__maybe_call_on_header(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__on_header_field(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_field); /* proto*/
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__on_header_value(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_val); /* proto*/
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__on_headers_complete(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__on_chunk_header(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__on_chunk_complete(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self); /* proto*/
+
+/* Module declarations from 'cpython.mem' */
+
+/* Module declarations from 'cpython.version' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.type' */
+static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
+
+/* Module declarations from 'libc.string' */
+
+/* Module declarations from 'libc.stdio' */
+
+/* Module declarations from 'cpython.object' */
+
+/* Module declarations from 'cpython.ref' */
+
+/* Module declarations from 'cpython.exc' */
+
+/* Module declarations from 'cpython.module' */
+
+/* Module declarations from 'cpython.tuple' */
+
+/* Module declarations from 'cpython.list' */
+
+/* Module declarations from 'cpython.sequence' */
+
+/* Module declarations from 'cpython.mapping' */
+
+/* Module declarations from 'cpython.iterator' */
+
+/* Module declarations from 'cpython.number' */
+
+/* Module declarations from 'cpython.int' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.bool' */
+static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0;
+
+/* Module declarations from 'cpython.long' */
+
+/* Module declarations from 'cpython.float' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.complex' */
+static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0;
+
+/* Module declarations from 'cpython.string' */
+
+/* Module declarations from 'cpython.unicode' */
+
+/* Module declarations from 'cpython.dict' */
+
+/* Module declarations from 'cpython.instance' */
+
+/* Module declarations from 'cpython.function' */
+
+/* Module declarations from 'cpython.method' */
+
+/* Module declarations from 'cpython.weakref' */
+
+/* Module declarations from 'cpython.getargs' */
+
+/* Module declarations from 'cpython.pythread' */
+
+/* Module declarations from 'cpython.pystate' */
+
+/* Module declarations from 'cpython.cobject' */
+
+/* Module declarations from 'cpython.oldbuffer' */
+
+/* Module declarations from 'cpython.set' */
+
+/* Module declarations from 'cpython.buffer' */
+
+/* Module declarations from 'cpython.bytes' */
+
+/* Module declarations from 'cpython.pycapsule' */
+
+/* Module declarations from 'cpython' */
+
+/* Module declarations from 'httptools.parser.python' */
+
+/* Module declarations from 'cython' */
+
+/* Module declarations from 'httptools.parser' */
+
+/* Module declarations from 'libc.stdint' */
+
+/* Module declarations from 'httptools.parser.cparser' */
+
+/* Module declarations from 'httptools.parser.parser' */
+static PyTypeObject *__pyx_ptype_9httptools_6parser_6parser_HttpParser = 0;
+static PyTypeObject *__pyx_ptype_9httptools_6parser_6parser_HttpRequestParser = 0;
+static PyTypeObject *__pyx_ptype_9httptools_6parser_6parser_HttpResponseParser = 0;
+static int __pyx_f_9httptools_6parser_6parser_cb_on_message_begin(llhttp_t *); /*proto*/
+static int __pyx_f_9httptools_6parser_6parser_cb_on_url(llhttp_t *, char const *, size_t); /*proto*/
+static int __pyx_f_9httptools_6parser_6parser_cb_on_status(llhttp_t *, char const *, size_t); /*proto*/
+static int __pyx_f_9httptools_6parser_6parser_cb_on_header_field(llhttp_t *, char const *, size_t); /*proto*/
+static int __pyx_f_9httptools_6parser_6parser_cb_on_header_value(llhttp_t *, char const *, size_t); /*proto*/
+static int __pyx_f_9httptools_6parser_6parser_cb_on_headers_complete(llhttp_t *); /*proto*/
+static int __pyx_f_9httptools_6parser_6parser_cb_on_body(llhttp_t *, char const *, size_t); /*proto*/
+static int __pyx_f_9httptools_6parser_6parser_cb_on_message_complete(llhttp_t *); /*proto*/
+static int __pyx_f_9httptools_6parser_6parser_cb_on_chunk_header(llhttp_t *); /*proto*/
+static int __pyx_f_9httptools_6parser_6parser_cb_on_chunk_complete(llhttp_t *); /*proto*/
+static PyObject *__pyx_f_9httptools_6parser_6parser_parser_error_from_errno(llhttp_t *, llhttp_errno_t); /*proto*/
+#define __Pyx_MODULE_NAME "httptools.parser.parser"
+extern int __pyx_module_is_main_httptools__parser__parser;
+int __pyx_module_is_main_httptools__parser__parser = 0;
+
+/* Implementation of 'httptools.parser.parser' */
+static PyObject *__pyx_builtin_MemoryError;
+static PyObject *__pyx_builtin_TypeError;
+static PyObject *__pyx_builtin_BaseException;
+static const char __pyx_k_[] = "{}.{}";
+static const char __pyx_k_all[] = "__all__";
+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_errors[] = "errors";
+static const char __pyx_k_format[] = "format";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_on_url[] = "on_url";
+static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_context[] = "__context__";
+static const char __pyx_k_on_body[] = "on_body";
+static const char __pyx_k_getstate[] = "__getstate__";
+static const char __pyx_k_protocol[] = "protocol";
+static const char __pyx_k_setstate[] = "__setstate__";
+static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_on_header[] = "on_header";
+static const char __pyx_k_on_status[] = "on_status";
+static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
+static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
+static const char __pyx_k_MemoryError[] = "MemoryError";
+static const char __pyx_k_BaseException[] = "BaseException";
+static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_HttpParserError[] = "HttpParserError";
+static const char __pyx_k_on_chunk_header[] = "on_chunk_header";
+static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_on_message_begin[] = "on_message_begin";
+static const char __pyx_k_HttpParserUpgrade[] = "HttpParserUpgrade";
+static const char __pyx_k_HttpRequestParser[] = "HttpRequestParser";
+static const char __pyx_k_on_chunk_complete[] = "on_chunk_complete";
+static const char __pyx_k_HttpResponseParser[] = "HttpResponseParser";
+static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_on_headers_complete[] = "on_headers_complete";
+static const char __pyx_k_on_message_complete[] = "on_message_complete";
+static const char __pyx_k_invalid_headers_state[] = "invalid headers state";
+static const char __pyx_k_HttpParserCallbackError[] = "HttpParserCallbackError";
+static const char __pyx_k_HttpParserInvalidURLError[] = "HttpParserInvalidURLError";
+static const char __pyx_k_HttpParserInvalidMethodError[] = "HttpParserInvalidMethodError";
+static const char __pyx_k_HttpParserInvalidStatusError[] = "HttpParserInvalidStatusError";
+static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
+static PyObject *__pyx_kp_u_;
+static PyObject *__pyx_n_s_BaseException;
+static PyObject *__pyx_n_s_HttpParserCallbackError;
+static PyObject *__pyx_n_s_HttpParserError;
+static PyObject *__pyx_n_s_HttpParserInvalidMethodError;
+static PyObject *__pyx_n_s_HttpParserInvalidStatusError;
+static PyObject *__pyx_n_s_HttpParserInvalidURLError;
+static PyObject *__pyx_n_s_HttpParserUpgrade;
+static PyObject *__pyx_n_s_HttpRequestParser;
+static PyObject *__pyx_n_u_HttpRequestParser;
+static PyObject *__pyx_n_s_HttpResponseParser;
+static PyObject *__pyx_n_u_HttpResponseParser;
+static PyObject *__pyx_n_s_MemoryError;
+static PyObject *__pyx_n_s_TypeError;
+static PyObject *__pyx_n_s_all;
+static PyObject *__pyx_n_s_cline_in_traceback;
+static PyObject *__pyx_n_s_context;
+static PyObject *__pyx_n_s_errors;
+static PyObject *__pyx_n_s_format;
+static PyObject *__pyx_n_s_getstate;
+static PyObject *__pyx_n_s_import;
+static PyObject *__pyx_kp_u_invalid_headers_state;
+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_u_on_body;
+static PyObject *__pyx_n_u_on_chunk_complete;
+static PyObject *__pyx_n_u_on_chunk_header;
+static PyObject *__pyx_n_u_on_header;
+static PyObject *__pyx_n_u_on_headers_complete;
+static PyObject *__pyx_n_u_on_message_begin;
+static PyObject *__pyx_n_u_on_message_complete;
+static PyObject *__pyx_n_u_on_status;
+static PyObject *__pyx_n_u_on_url;
+static PyObject *__pyx_n_s_protocol;
+static PyObject *__pyx_n_s_pyx_vtable;
+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;
+static int __pyx_pf_9httptools_6parser_6parser_10HttpParser___cinit__(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self); /* proto */
+static void __pyx_pf_9httptools_6parser_6parser_10HttpParser_2__dealloc__(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_4get_http_version(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_6should_keep_alive(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_8should_upgrade(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_10feed_data(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_data); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_9httptools_6parser_6parser_17HttpRequestParser___init__(struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *__pyx_v_self, PyObject *__pyx_v_protocol); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_17HttpRequestParser_2get_method(struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_17HttpRequestParser_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_17HttpRequestParser_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_9httptools_6parser_6parser_18HttpResponseParser___init__(struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *__pyx_v_self, PyObject *__pyx_v_protocol); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_18HttpResponseParser_2get_status_code(struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_18HttpResponseParser_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_6parser_18HttpResponseParser_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_tp_new_9httptools_6parser_6parser_HttpParser(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9httptools_6parser_6parser_HttpRequestParser(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9httptools_6parser_6parser_HttpResponseParser(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+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;
+/* Late includes */
+
+/* "httptools/parser/parser.pyx":44
+ *         Py_buffer py_buf
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._cparser = <cparser.llhttp_t*> \
+ *                                 PyMem_Malloc(sizeof(cparser.llhttp_t))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9httptools_6parser_6parser_10HttpParser_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9httptools_6parser_6parser_10HttpParser_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_9httptools_6parser_6parser_10HttpParser___cinit__(((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_9httptools_6parser_6parser_10HttpParser___cinit__(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__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);
+
+  /* "httptools/parser/parser.pyx":45
+ * 
+ *     def __cinit__(self):
+ *         self._cparser = <cparser.llhttp_t*> \             # <<<<<<<<<<<<<<
+ *                                 PyMem_Malloc(sizeof(cparser.llhttp_t))
+ *         if self._cparser is NULL:
+ */
+  __pyx_v_self->_cparser = ((llhttp_t *)PyMem_Malloc((sizeof(llhttp_t))));
+
+  /* "httptools/parser/parser.pyx":47
+ *         self._cparser = <cparser.llhttp_t*> \
+ *                                 PyMem_Malloc(sizeof(cparser.llhttp_t))
+ *         if self._cparser is NULL:             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_cparser == NULL) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "httptools/parser/parser.pyx":48
+ *                                 PyMem_Malloc(sizeof(cparser.llhttp_t))
+ *         if self._cparser is NULL:
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *         self._csettings = <cparser.llhttp_settings_t*> \
+ */
+    PyErr_NoMemory(); __PYX_ERR(0, 48, __pyx_L1_error)
+
+    /* "httptools/parser/parser.pyx":47
+ *         self._cparser = <cparser.llhttp_t*> \
+ *                                 PyMem_Malloc(sizeof(cparser.llhttp_t))
+ *         if self._cparser is NULL:             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":50
+ *             raise MemoryError()
+ * 
+ *         self._csettings = <cparser.llhttp_settings_t*> \             # <<<<<<<<<<<<<<
+ *                                 PyMem_Malloc(sizeof(cparser.llhttp_settings_t))
+ *         if self._csettings is NULL:
+ */
+  __pyx_v_self->_csettings = ((llhttp_settings_t *)PyMem_Malloc((sizeof(llhttp_settings_t))));
+
+  /* "httptools/parser/parser.pyx":52
+ *         self._csettings = <cparser.llhttp_settings_t*> \
+ *                                 PyMem_Malloc(sizeof(cparser.llhttp_settings_t))
+ *         if self._csettings is NULL:             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_csettings == NULL) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "httptools/parser/parser.pyx":53
+ *                                 PyMem_Malloc(sizeof(cparser.llhttp_settings_t))
+ *         if self._csettings is NULL:
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+    PyErr_NoMemory(); __PYX_ERR(0, 53, __pyx_L1_error)
+
+    /* "httptools/parser/parser.pyx":52
+ *         self._csettings = <cparser.llhttp_settings_t*> \
+ *                                 PyMem_Malloc(sizeof(cparser.llhttp_settings_t))
+ *         if self._csettings is NULL:             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":44
+ *         Py_buffer py_buf
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._cparser = <cparser.llhttp_t*> \
+ *                                 PyMem_Malloc(sizeof(cparser.llhttp_t))
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":55
+ *             raise MemoryError()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         PyMem_Free(self._cparser)
+ *         PyMem_Free(self._csettings)
+ */
+
+/* Python wrapper */
+static void __pyx_pw_9httptools_6parser_6parser_10HttpParser_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_9httptools_6parser_6parser_10HttpParser_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_9httptools_6parser_6parser_10HttpParser_2__dealloc__(((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_9httptools_6parser_6parser_10HttpParser_2__dealloc__(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "httptools/parser/parser.pyx":56
+ * 
+ *     def __dealloc__(self):
+ *         PyMem_Free(self._cparser)             # <<<<<<<<<<<<<<
+ *         PyMem_Free(self._csettings)
+ * 
+ */
+  PyMem_Free(__pyx_v_self->_cparser);
+
+  /* "httptools/parser/parser.pyx":57
+ *     def __dealloc__(self):
+ *         PyMem_Free(self._cparser)
+ *         PyMem_Free(self._csettings)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _init(self, protocol, cparser.llhttp_type_t mode):
+ */
+  PyMem_Free(__pyx_v_self->_csettings);
+
+  /* "httptools/parser/parser.pyx":55
+ *             raise MemoryError()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         PyMem_Free(self._cparser)
+ *         PyMem_Free(self._csettings)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "httptools/parser/parser.pyx":59
+ *         PyMem_Free(self._csettings)
+ * 
+ *     cdef _init(self, protocol, cparser.llhttp_type_t mode):             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_settings_init(self._csettings)
+ * 
+ */
+
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__init(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_protocol, llhttp_type_t __pyx_v_mode) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init", 0);
+
+  /* "httptools/parser/parser.pyx":60
+ * 
+ *     cdef _init(self, protocol, cparser.llhttp_type_t mode):
+ *         cparser.llhttp_settings_init(self._csettings)             # <<<<<<<<<<<<<<
+ * 
+ *         cparser.llhttp_init(self._cparser, mode, self._csettings)
+ */
+  llhttp_settings_init(__pyx_v_self->_csettings);
+
+  /* "httptools/parser/parser.pyx":62
+ *         cparser.llhttp_settings_init(self._csettings)
+ * 
+ *         cparser.llhttp_init(self._cparser, mode, self._csettings)             # <<<<<<<<<<<<<<
+ *         self._cparser.data = <void*>self
+ * 
+ */
+  llhttp_init(__pyx_v_self->_cparser, __pyx_v_mode, __pyx_v_self->_csettings);
+
+  /* "httptools/parser/parser.pyx":63
+ * 
+ *         cparser.llhttp_init(self._cparser, mode, self._csettings)
+ *         self._cparser.data = <void*>self             # <<<<<<<<<<<<<<
+ * 
+ *         self._current_header_name = None
+ */
+  __pyx_v_self->_cparser->data = ((void *)__pyx_v_self);
+
+  /* "httptools/parser/parser.pyx":65
+ *         self._cparser.data = <void*>self
+ * 
+ *         self._current_header_name = None             # <<<<<<<<<<<<<<
+ *         self._current_header_value = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_current_header_name);
+  __Pyx_DECREF(__pyx_v_self->_current_header_name);
+  __pyx_v_self->_current_header_name = ((PyObject*)Py_None);
+
+  /* "httptools/parser/parser.pyx":66
+ * 
+ *         self._current_header_name = None
+ *         self._current_header_value = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._proto_on_header = getattr(protocol, 'on_header', None)
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_current_header_value);
+  __Pyx_DECREF(__pyx_v_self->_current_header_value);
+  __pyx_v_self->_current_header_value = ((PyObject*)Py_None);
+
+  /* "httptools/parser/parser.pyx":68
+ *         self._current_header_value = None
+ * 
+ *         self._proto_on_header = getattr(protocol, 'on_header', None)             # <<<<<<<<<<<<<<
+ *         if self._proto_on_header is not None:
+ *             self._csettings.on_header_field = cb_on_header_field
+ */
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_protocol, __pyx_n_u_on_header, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_proto_on_header);
+  __Pyx_DECREF(__pyx_v_self->_proto_on_header);
+  __pyx_v_self->_proto_on_header = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":69
+ * 
+ *         self._proto_on_header = getattr(protocol, 'on_header', None)
+ *         if self._proto_on_header is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_header_field = cb_on_header_field
+ *             self._csettings.on_header_value = cb_on_header_value
+ */
+  __pyx_t_2 = (__pyx_v_self->_proto_on_header != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "httptools/parser/parser.pyx":70
+ *         self._proto_on_header = getattr(protocol, 'on_header', None)
+ *         if self._proto_on_header is not None:
+ *             self._csettings.on_header_field = cb_on_header_field             # <<<<<<<<<<<<<<
+ *             self._csettings.on_header_value = cb_on_header_value
+ *         self._proto_on_headers_complete = getattr(
+ */
+    __pyx_v_self->_csettings->on_header_field = __pyx_f_9httptools_6parser_6parser_cb_on_header_field;
+
+    /* "httptools/parser/parser.pyx":71
+ *         if self._proto_on_header is not None:
+ *             self._csettings.on_header_field = cb_on_header_field
+ *             self._csettings.on_header_value = cb_on_header_value             # <<<<<<<<<<<<<<
+ *         self._proto_on_headers_complete = getattr(
+ *             protocol, 'on_headers_complete', None)
+ */
+    __pyx_v_self->_csettings->on_header_value = __pyx_f_9httptools_6parser_6parser_cb_on_header_value;
+
+    /* "httptools/parser/parser.pyx":69
+ * 
+ *         self._proto_on_header = getattr(protocol, 'on_header', None)
+ *         if self._proto_on_header is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_header_field = cb_on_header_field
+ *             self._csettings.on_header_value = cb_on_header_value
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":72
+ *             self._csettings.on_header_field = cb_on_header_field
+ *             self._csettings.on_header_value = cb_on_header_value
+ *         self._proto_on_headers_complete = getattr(             # <<<<<<<<<<<<<<
+ *             protocol, 'on_headers_complete', None)
+ *         self._csettings.on_headers_complete = cb_on_headers_complete
+ */
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_protocol, __pyx_n_u_on_headers_complete, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_proto_on_headers_complete);
+  __Pyx_DECREF(__pyx_v_self->_proto_on_headers_complete);
+  __pyx_v_self->_proto_on_headers_complete = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":74
+ *         self._proto_on_headers_complete = getattr(
+ *             protocol, 'on_headers_complete', None)
+ *         self._csettings.on_headers_complete = cb_on_headers_complete             # <<<<<<<<<<<<<<
+ * 
+ *         self._proto_on_body = getattr(protocol, 'on_body', None)
+ */
+  __pyx_v_self->_csettings->on_headers_complete = __pyx_f_9httptools_6parser_6parser_cb_on_headers_complete;
+
+  /* "httptools/parser/parser.pyx":76
+ *         self._csettings.on_headers_complete = cb_on_headers_complete
+ * 
+ *         self._proto_on_body = getattr(protocol, 'on_body', None)             # <<<<<<<<<<<<<<
+ *         if self._proto_on_body is not None:
+ *             self._csettings.on_body = cb_on_body
+ */
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_protocol, __pyx_n_u_on_body, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_proto_on_body);
+  __Pyx_DECREF(__pyx_v_self->_proto_on_body);
+  __pyx_v_self->_proto_on_body = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":77
+ * 
+ *         self._proto_on_body = getattr(protocol, 'on_body', None)
+ *         if self._proto_on_body is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_body = cb_on_body
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->_proto_on_body != Py_None);
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "httptools/parser/parser.pyx":78
+ *         self._proto_on_body = getattr(protocol, 'on_body', None)
+ *         if self._proto_on_body is not None:
+ *             self._csettings.on_body = cb_on_body             # <<<<<<<<<<<<<<
+ * 
+ *         self._proto_on_message_begin = getattr(
+ */
+    __pyx_v_self->_csettings->on_body = __pyx_f_9httptools_6parser_6parser_cb_on_body;
+
+    /* "httptools/parser/parser.pyx":77
+ * 
+ *         self._proto_on_body = getattr(protocol, 'on_body', None)
+ *         if self._proto_on_body is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_body = cb_on_body
+ * 
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":80
+ *             self._csettings.on_body = cb_on_body
+ * 
+ *         self._proto_on_message_begin = getattr(             # <<<<<<<<<<<<<<
+ *             protocol, 'on_message_begin', None)
+ *         if self._proto_on_message_begin is not None:
+ */
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_protocol, __pyx_n_u_on_message_begin, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_proto_on_message_begin);
+  __Pyx_DECREF(__pyx_v_self->_proto_on_message_begin);
+  __pyx_v_self->_proto_on_message_begin = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":82
+ *         self._proto_on_message_begin = getattr(
+ *             protocol, 'on_message_begin', None)
+ *         if self._proto_on_message_begin is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_message_begin = cb_on_message_begin
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_self->_proto_on_message_begin != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "httptools/parser/parser.pyx":83
+ *             protocol, 'on_message_begin', None)
+ *         if self._proto_on_message_begin is not None:
+ *             self._csettings.on_message_begin = cb_on_message_begin             # <<<<<<<<<<<<<<
+ * 
+ *         self._proto_on_message_complete = getattr(
+ */
+    __pyx_v_self->_csettings->on_message_begin = __pyx_f_9httptools_6parser_6parser_cb_on_message_begin;
+
+    /* "httptools/parser/parser.pyx":82
+ *         self._proto_on_message_begin = getattr(
+ *             protocol, 'on_message_begin', None)
+ *         if self._proto_on_message_begin is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_message_begin = cb_on_message_begin
+ * 
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":85
+ *             self._csettings.on_message_begin = cb_on_message_begin
+ * 
+ *         self._proto_on_message_complete = getattr(             # <<<<<<<<<<<<<<
+ *             protocol, 'on_message_complete', None)
+ *         if self._proto_on_message_complete is not None:
+ */
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_protocol, __pyx_n_u_on_message_complete, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_proto_on_message_complete);
+  __Pyx_DECREF(__pyx_v_self->_proto_on_message_complete);
+  __pyx_v_self->_proto_on_message_complete = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":87
+ *         self._proto_on_message_complete = getattr(
+ *             protocol, 'on_message_complete', None)
+ *         if self._proto_on_message_complete is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_message_complete = cb_on_message_complete
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->_proto_on_message_complete != Py_None);
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "httptools/parser/parser.pyx":88
+ *             protocol, 'on_message_complete', None)
+ *         if self._proto_on_message_complete is not None:
+ *             self._csettings.on_message_complete = cb_on_message_complete             # <<<<<<<<<<<<<<
+ * 
+ *         self._proto_on_chunk_header = getattr(
+ */
+    __pyx_v_self->_csettings->on_message_complete = __pyx_f_9httptools_6parser_6parser_cb_on_message_complete;
+
+    /* "httptools/parser/parser.pyx":87
+ *         self._proto_on_message_complete = getattr(
+ *             protocol, 'on_message_complete', None)
+ *         if self._proto_on_message_complete is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_message_complete = cb_on_message_complete
+ * 
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":90
+ *             self._csettings.on_message_complete = cb_on_message_complete
+ * 
+ *         self._proto_on_chunk_header = getattr(             # <<<<<<<<<<<<<<
+ *             protocol, 'on_chunk_header', None)
+ *         self._csettings.on_chunk_header = cb_on_chunk_header
+ */
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_protocol, __pyx_n_u_on_chunk_header, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_proto_on_chunk_header);
+  __Pyx_DECREF(__pyx_v_self->_proto_on_chunk_header);
+  __pyx_v_self->_proto_on_chunk_header = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":92
+ *         self._proto_on_chunk_header = getattr(
+ *             protocol, 'on_chunk_header', None)
+ *         self._csettings.on_chunk_header = cb_on_chunk_header             # <<<<<<<<<<<<<<
+ * 
+ *         self._proto_on_chunk_complete = getattr(
+ */
+  __pyx_v_self->_csettings->on_chunk_header = __pyx_f_9httptools_6parser_6parser_cb_on_chunk_header;
+
+  /* "httptools/parser/parser.pyx":94
+ *         self._csettings.on_chunk_header = cb_on_chunk_header
+ * 
+ *         self._proto_on_chunk_complete = getattr(             # <<<<<<<<<<<<<<
+ *             protocol, 'on_chunk_complete', None)
+ *         self._csettings.on_chunk_complete = cb_on_chunk_complete
+ */
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_protocol, __pyx_n_u_on_chunk_complete, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_proto_on_chunk_complete);
+  __Pyx_DECREF(__pyx_v_self->_proto_on_chunk_complete);
+  __pyx_v_self->_proto_on_chunk_complete = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":96
+ *         self._proto_on_chunk_complete = getattr(
+ *             protocol, 'on_chunk_complete', None)
+ *         self._csettings.on_chunk_complete = cb_on_chunk_complete             # <<<<<<<<<<<<<<
+ * 
+ *         self._last_error = None
+ */
+  __pyx_v_self->_csettings->on_chunk_complete = __pyx_f_9httptools_6parser_6parser_cb_on_chunk_complete;
+
+  /* "httptools/parser/parser.pyx":98
+ *         self._csettings.on_chunk_complete = cb_on_chunk_complete
+ * 
+ *         self._last_error = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _maybe_call_on_header(self):
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_last_error);
+  __Pyx_DECREF(__pyx_v_self->_last_error);
+  __pyx_v_self->_last_error = Py_None;
+
+  /* "httptools/parser/parser.pyx":59
+ *         PyMem_Free(self._csettings)
+ * 
+ *     cdef _init(self, protocol, cparser.llhttp_type_t mode):             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_settings_init(self._csettings)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":100
+ *         self._last_error = None
+ * 
+ *     cdef _maybe_call_on_header(self):             # <<<<<<<<<<<<<<
+ *         if self._current_header_value is not None:
+ *             current_header_name = self._current_header_name
+ */
+
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__maybe_call_on_header(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self) {
+  PyObject *__pyx_v_current_header_name = NULL;
+  PyObject *__pyx_v_current_header_value = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_maybe_call_on_header", 0);
+
+  /* "httptools/parser/parser.pyx":101
+ * 
+ *     cdef _maybe_call_on_header(self):
+ *         if self._current_header_value is not None:             # <<<<<<<<<<<<<<
+ *             current_header_name = self._current_header_name
+ *             current_header_value = self._current_header_value
+ */
+  __pyx_t_1 = (__pyx_v_self->_current_header_value != ((PyObject*)Py_None));
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "httptools/parser/parser.pyx":102
+ *     cdef _maybe_call_on_header(self):
+ *         if self._current_header_value is not None:
+ *             current_header_name = self._current_header_name             # <<<<<<<<<<<<<<
+ *             current_header_value = self._current_header_value
+ * 
+ */
+    __pyx_t_3 = __pyx_v_self->_current_header_name;
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_v_current_header_name = ((PyObject*)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "httptools/parser/parser.pyx":103
+ *         if self._current_header_value is not None:
+ *             current_header_name = self._current_header_name
+ *             current_header_value = self._current_header_value             # <<<<<<<<<<<<<<
+ * 
+ *             self._current_header_name = self._current_header_value = None
+ */
+    __pyx_t_3 = __pyx_v_self->_current_header_value;
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_v_current_header_value = ((PyObject*)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "httptools/parser/parser.pyx":105
+ *             current_header_value = self._current_header_value
+ * 
+ *             self._current_header_name = self._current_header_value = None             # <<<<<<<<<<<<<<
+ * 
+ *             if self._proto_on_header is not None:
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_current_header_name);
+    __Pyx_DECREF(__pyx_v_self->_current_header_name);
+    __pyx_v_self->_current_header_name = ((PyObject*)Py_None);
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_current_header_value);
+    __Pyx_DECREF(__pyx_v_self->_current_header_value);
+    __pyx_v_self->_current_header_value = ((PyObject*)Py_None);
+
+    /* "httptools/parser/parser.pyx":107
+ *             self._current_header_name = self._current_header_value = None
+ * 
+ *             if self._proto_on_header is not None:             # <<<<<<<<<<<<<<
+ *                 self._proto_on_header(current_header_name,
+ *                                       current_header_value)
+ */
+    __pyx_t_2 = (__pyx_v_self->_proto_on_header != Py_None);
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (__pyx_t_1) {
+
+      /* "httptools/parser/parser.pyx":109
+ *             if self._proto_on_header is not None:
+ *                 self._proto_on_header(current_header_name,
+ *                                       current_header_value)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_header_field(self, bytes field):
+ */
+      __Pyx_INCREF(__pyx_v_self->_proto_on_header);
+      __pyx_t_4 = __pyx_v_self->_proto_on_header; __pyx_t_5 = NULL;
+      __pyx_t_6 = 0;
+      if (CYTHON_UNPACK_METHODS && 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;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_4)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_current_header_name, __pyx_v_current_header_value};
+        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_current_header_name, __pyx_v_current_header_value};
+        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+      } else
+      #endif
+      {
+        __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 108, __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_v_current_header_name);
+        __Pyx_GIVEREF(__pyx_v_current_header_name);
+        PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_v_current_header_name);
+        __Pyx_INCREF(__pyx_v_current_header_value);
+        __Pyx_GIVEREF(__pyx_v_current_header_value);
+        PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_current_header_value);
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "httptools/parser/parser.pyx":107
+ *             self._current_header_name = self._current_header_value = None
+ * 
+ *             if self._proto_on_header is not None:             # <<<<<<<<<<<<<<
+ *                 self._proto_on_header(current_header_name,
+ *                                       current_header_value)
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":101
+ * 
+ *     cdef _maybe_call_on_header(self):
+ *         if self._current_header_value is not None:             # <<<<<<<<<<<<<<
+ *             current_header_name = self._current_header_name
+ *             current_header_value = self._current_header_value
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":100
+ *         self._last_error = None
+ * 
+ *     cdef _maybe_call_on_header(self):             # <<<<<<<<<<<<<<
+ *         if self._current_header_value is not None:
+ *             current_header_name = self._current_header_name
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser._maybe_call_on_header", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_current_header_name);
+  __Pyx_XDECREF(__pyx_v_current_header_value);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":111
+ *                                       current_header_value)
+ * 
+ *     cdef _on_header_field(self, bytes field):             # <<<<<<<<<<<<<<
+ *         self._maybe_call_on_header()
+ *         if self._current_header_name is None:
+ */
+
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__on_header_field(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_field) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_header_field", 0);
+
+  /* "httptools/parser/parser.pyx":112
+ * 
+ *     cdef _on_header_field(self, bytes field):
+ *         self._maybe_call_on_header()             # <<<<<<<<<<<<<<
+ *         if self._current_header_name is None:
+ *             self._current_header_name = field
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser *)__pyx_v_self->__pyx_vtab)->_maybe_call_on_header(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":113
+ *     cdef _on_header_field(self, bytes field):
+ *         self._maybe_call_on_header()
+ *         if self._current_header_name is None:             # <<<<<<<<<<<<<<
+ *             self._current_header_name = field
+ *         else:
+ */
+  __pyx_t_2 = (__pyx_v_self->_current_header_name == ((PyObject*)Py_None));
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "httptools/parser/parser.pyx":114
+ *         self._maybe_call_on_header()
+ *         if self._current_header_name is None:
+ *             self._current_header_name = field             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._current_header_name += field
+ */
+    __Pyx_INCREF(__pyx_v_field);
+    __Pyx_GIVEREF(__pyx_v_field);
+    __Pyx_GOTREF(__pyx_v_self->_current_header_name);
+    __Pyx_DECREF(__pyx_v_self->_current_header_name);
+    __pyx_v_self->_current_header_name = __pyx_v_field;
+
+    /* "httptools/parser/parser.pyx":113
+ *     cdef _on_header_field(self, bytes field):
+ *         self._maybe_call_on_header()
+ *         if self._current_header_name is None:             # <<<<<<<<<<<<<<
+ *             self._current_header_name = field
+ *         else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "httptools/parser/parser.pyx":116
+ *             self._current_header_name = field
+ *         else:
+ *             self._current_header_name += field             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_header_value(self, bytes val):
+ */
+  /*else*/ {
+    __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_self->_current_header_name, __pyx_v_field); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_1);
+    __Pyx_GOTREF(__pyx_v_self->_current_header_name);
+    __Pyx_DECREF(__pyx_v_self->_current_header_name);
+    __pyx_v_self->_current_header_name = ((PyObject*)__pyx_t_1);
+    __pyx_t_1 = 0;
+  }
+  __pyx_L3:;
+
+  /* "httptools/parser/parser.pyx":111
+ *                                       current_header_value)
+ * 
+ *     cdef _on_header_field(self, bytes field):             # <<<<<<<<<<<<<<
+ *         self._maybe_call_on_header()
+ *         if self._current_header_name is None:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser._on_header_field", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":118
+ *             self._current_header_name += field
+ * 
+ *     cdef _on_header_value(self, bytes val):             # <<<<<<<<<<<<<<
+ *         if self._current_header_value is None:
+ *             self._current_header_value = val
+ */
+
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__on_header_value(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_val) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("_on_header_value", 0);
+
+  /* "httptools/parser/parser.pyx":119
+ * 
+ *     cdef _on_header_value(self, bytes val):
+ *         if self._current_header_value is None:             # <<<<<<<<<<<<<<
+ *             self._current_header_value = val
+ *         else:
+ */
+  __pyx_t_1 = (__pyx_v_self->_current_header_value == ((PyObject*)Py_None));
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "httptools/parser/parser.pyx":120
+ *     cdef _on_header_value(self, bytes val):
+ *         if self._current_header_value is None:
+ *             self._current_header_value = val             # <<<<<<<<<<<<<<
+ *         else:
+ *             # This is unlikely, as mostly HTTP headers are one-line
+ */
+    __Pyx_INCREF(__pyx_v_val);
+    __Pyx_GIVEREF(__pyx_v_val);
+    __Pyx_GOTREF(__pyx_v_self->_current_header_value);
+    __Pyx_DECREF(__pyx_v_self->_current_header_value);
+    __pyx_v_self->_current_header_value = __pyx_v_val;
+
+    /* "httptools/parser/parser.pyx":119
+ * 
+ *     cdef _on_header_value(self, bytes val):
+ *         if self._current_header_value is None:             # <<<<<<<<<<<<<<
+ *             self._current_header_value = val
+ *         else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "httptools/parser/parser.pyx":123
+ *         else:
+ *             # This is unlikely, as mostly HTTP headers are one-line
+ *             self._current_header_value += val             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_headers_complete(self):
+ */
+  /*else*/ {
+    __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_self->_current_header_value, __pyx_v_val); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 123, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __Pyx_GOTREF(__pyx_v_self->_current_header_value);
+    __Pyx_DECREF(__pyx_v_self->_current_header_value);
+    __pyx_v_self->_current_header_value = ((PyObject*)__pyx_t_3);
+    __pyx_t_3 = 0;
+  }
+  __pyx_L3:;
+
+  /* "httptools/parser/parser.pyx":118
+ *             self._current_header_name += field
+ * 
+ *     cdef _on_header_value(self, bytes val):             # <<<<<<<<<<<<<<
+ *         if self._current_header_value is None:
+ *             self._current_header_value = val
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser._on_header_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":125
+ *             self._current_header_value += val
+ * 
+ *     cdef _on_headers_complete(self):             # <<<<<<<<<<<<<<
+ *         self._maybe_call_on_header()
+ * 
+ */
+
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__on_headers_complete(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_headers_complete", 0);
+
+  /* "httptools/parser/parser.pyx":126
+ * 
+ *     cdef _on_headers_complete(self):
+ *         self._maybe_call_on_header()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._proto_on_headers_complete is not None:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser *)__pyx_v_self->__pyx_vtab)->_maybe_call_on_header(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":128
+ *         self._maybe_call_on_header()
+ * 
+ *         if self._proto_on_headers_complete is not None:             # <<<<<<<<<<<<<<
+ *             self._proto_on_headers_complete()
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_self->_proto_on_headers_complete != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "httptools/parser/parser.pyx":129
+ * 
+ *         if self._proto_on_headers_complete is not None:
+ *             self._proto_on_headers_complete()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_chunk_header(self):
+ */
+    __Pyx_INCREF(__pyx_v_self->_proto_on_headers_complete);
+    __pyx_t_4 = __pyx_v_self->_proto_on_headers_complete; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "httptools/parser/parser.pyx":128
+ *         self._maybe_call_on_header()
+ * 
+ *         if self._proto_on_headers_complete is not None:             # <<<<<<<<<<<<<<
+ *             self._proto_on_headers_complete()
+ * 
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":125
+ *             self._current_header_value += val
+ * 
+ *     cdef _on_headers_complete(self):             # <<<<<<<<<<<<<<
+ *         self._maybe_call_on_header()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser._on_headers_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":131
+ *             self._proto_on_headers_complete()
+ * 
+ *     cdef _on_chunk_header(self):             # <<<<<<<<<<<<<<
+ *         if (self._current_header_value is not None or
+ *             self._current_header_name is not None):
+ */
+
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__on_chunk_header(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_chunk_header", 0);
+
+  /* "httptools/parser/parser.pyx":132
+ * 
+ *     cdef _on_chunk_header(self):
+ *         if (self._current_header_value is not None or             # <<<<<<<<<<<<<<
+ *             self._current_header_name is not None):
+ *             raise HttpParserError('invalid headers state')
+ */
+  __pyx_t_2 = (__pyx_v_self->_current_header_value != ((PyObject*)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;
+  }
+
+  /* "httptools/parser/parser.pyx":133
+ *     cdef _on_chunk_header(self):
+ *         if (self._current_header_value is not None or
+ *             self._current_header_name is not None):             # <<<<<<<<<<<<<<
+ *             raise HttpParserError('invalid headers state')
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->_current_header_name != ((PyObject*)Py_None));
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+
+  /* "httptools/parser/parser.pyx":132
+ * 
+ *     cdef _on_chunk_header(self):
+ *         if (self._current_header_value is not None or             # <<<<<<<<<<<<<<
+ *             self._current_header_name is not None):
+ *             raise HttpParserError('invalid headers state')
+ */
+  if (unlikely(__pyx_t_1)) {
+
+    /* "httptools/parser/parser.pyx":134
+ *         if (self._current_header_value is not None or
+ *             self._current_header_name is not None):
+ *             raise HttpParserError('invalid headers state')             # <<<<<<<<<<<<<<
+ * 
+ *         if self._proto_on_chunk_header is not None:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_HttpParserError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 134, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_kp_u_invalid_headers_state) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_kp_u_invalid_headers_state);
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __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, 134, __pyx_L1_error)
+
+    /* "httptools/parser/parser.pyx":132
+ * 
+ *     cdef _on_chunk_header(self):
+ *         if (self._current_header_value is not None or             # <<<<<<<<<<<<<<
+ *             self._current_header_name is not None):
+ *             raise HttpParserError('invalid headers state')
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":136
+ *             raise HttpParserError('invalid headers state')
+ * 
+ *         if self._proto_on_chunk_header is not None:             # <<<<<<<<<<<<<<
+ *             self._proto_on_chunk_header()
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->_proto_on_chunk_header != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "httptools/parser/parser.pyx":137
+ * 
+ *         if self._proto_on_chunk_header is not None:
+ *             self._proto_on_chunk_header()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_chunk_complete(self):
+ */
+    __Pyx_INCREF(__pyx_v_self->_proto_on_chunk_header);
+    __pyx_t_5 = __pyx_v_self->_proto_on_chunk_header; __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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_4 = (__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_4)) __PYX_ERR(0, 137, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "httptools/parser/parser.pyx":136
+ *             raise HttpParserError('invalid headers state')
+ * 
+ *         if self._proto_on_chunk_header is not None:             # <<<<<<<<<<<<<<
+ *             self._proto_on_chunk_header()
+ * 
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":131
+ *             self._proto_on_headers_complete()
+ * 
+ *     cdef _on_chunk_header(self):             # <<<<<<<<<<<<<<
+ *         if (self._current_header_value is not None or
+ *             self._current_header_name is not None):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser._on_chunk_header", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":139
+ *             self._proto_on_chunk_header()
+ * 
+ *     cdef _on_chunk_complete(self):             # <<<<<<<<<<<<<<
+ *         self._maybe_call_on_header()
+ * 
+ */
+
+static PyObject *__pyx_f_9httptools_6parser_6parser_10HttpParser__on_chunk_complete(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_chunk_complete", 0);
+
+  /* "httptools/parser/parser.pyx":140
+ * 
+ *     cdef _on_chunk_complete(self):
+ *         self._maybe_call_on_header()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._proto_on_chunk_complete is not None:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser *)__pyx_v_self->__pyx_vtab)->_maybe_call_on_header(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":142
+ *         self._maybe_call_on_header()
+ * 
+ *         if self._proto_on_chunk_complete is not None:             # <<<<<<<<<<<<<<
+ *             self._proto_on_chunk_complete()
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_self->_proto_on_chunk_complete != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "httptools/parser/parser.pyx":143
+ * 
+ *         if self._proto_on_chunk_complete is not None:
+ *             self._proto_on_chunk_complete()             # <<<<<<<<<<<<<<
+ * 
+ *     ### Public API ###
+ */
+    __Pyx_INCREF(__pyx_v_self->_proto_on_chunk_complete);
+    __pyx_t_4 = __pyx_v_self->_proto_on_chunk_complete; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "httptools/parser/parser.pyx":142
+ *         self._maybe_call_on_header()
+ * 
+ *         if self._proto_on_chunk_complete is not None:             # <<<<<<<<<<<<<<
+ *             self._proto_on_chunk_complete()
+ * 
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":139
+ *             self._proto_on_chunk_header()
+ * 
+ *     cdef _on_chunk_complete(self):             # <<<<<<<<<<<<<<
+ *         self._maybe_call_on_header()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser._on_chunk_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":147
+ *     ### Public API ###
+ * 
+ *     def get_http_version(self):             # <<<<<<<<<<<<<<
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return '{}.{}'.format(parser.http_major, parser.http_minor)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_6parser_10HttpParser_5get_http_version(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_10HttpParser_5get_http_version(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_http_version (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_6parser_10HttpParser_4get_http_version(((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_4get_http_version(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self) {
+  llhttp_t *__pyx_v_parser;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  llhttp_t *__pyx_t_1;
+  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;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_http_version", 0);
+
+  /* "httptools/parser/parser.pyx":148
+ * 
+ *     def get_http_version(self):
+ *         cdef cparser.llhttp_t* parser = self._cparser             # <<<<<<<<<<<<<<
+ *         return '{}.{}'.format(parser.http_major, parser.http_minor)
+ * 
+ */
+  __pyx_t_1 = __pyx_v_self->_cparser;
+  __pyx_v_parser = __pyx_t_1;
+
+  /* "httptools/parser/parser.pyx":149
+ *     def get_http_version(self):
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return '{}.{}'.format(parser.http_major, parser.http_minor)             # <<<<<<<<<<<<<<
+ * 
+ *     def should_keep_alive(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyInt_From_uint8_t(__pyx_v_parser->http_major); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyInt_From_uint8_t(__pyx_v_parser->http_minor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = NULL;
+  __pyx_t_7 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(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_7 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_4, __pyx_t_5};
+    __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_4, __pyx_t_5};
+    __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 149, __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_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "httptools/parser/parser.pyx":147
+ *     ### Public API ###
+ * 
+ *     def get_http_version(self):             # <<<<<<<<<<<<<<
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return '{}.{}'.format(parser.http_major, parser.http_minor)
+ */
+
+  /* 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_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser.get_http_version", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":151
+ *         return '{}.{}'.format(parser.http_major, parser.http_minor)
+ * 
+ *     def should_keep_alive(self):             # <<<<<<<<<<<<<<
+ *         return bool(cparser.llhttp_should_keep_alive(self._cparser))
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_6parser_10HttpParser_7should_keep_alive(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_10HttpParser_7should_keep_alive(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("should_keep_alive (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_6parser_10HttpParser_6should_keep_alive(((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_6should_keep_alive(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("should_keep_alive", 0);
+
+  /* "httptools/parser/parser.pyx":152
+ * 
+ *     def should_keep_alive(self):
+ *         return bool(cparser.llhttp_should_keep_alive(self._cparser))             # <<<<<<<<<<<<<<
+ * 
+ *     def should_upgrade(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(llhttp_should_keep_alive(__pyx_v_self->_cparser)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __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, 152, __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, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "httptools/parser/parser.pyx":151
+ *         return '{}.{}'.format(parser.http_major, parser.http_minor)
+ * 
+ *     def should_keep_alive(self):             # <<<<<<<<<<<<<<
+ *         return bool(cparser.llhttp_should_keep_alive(self._cparser))
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser.should_keep_alive", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":154
+ *         return bool(cparser.llhttp_should_keep_alive(self._cparser))
+ * 
+ *     def should_upgrade(self):             # <<<<<<<<<<<<<<
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return bool(parser.upgrade)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_6parser_10HttpParser_9should_upgrade(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_10HttpParser_9should_upgrade(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("should_upgrade (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_6parser_10HttpParser_8should_upgrade(((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_8should_upgrade(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self) {
+  llhttp_t *__pyx_v_parser;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  llhttp_t *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("should_upgrade", 0);
+
+  /* "httptools/parser/parser.pyx":155
+ * 
+ *     def should_upgrade(self):
+ *         cdef cparser.llhttp_t* parser = self._cparser             # <<<<<<<<<<<<<<
+ *         return bool(parser.upgrade)
+ * 
+ */
+  __pyx_t_1 = __pyx_v_self->_cparser;
+  __pyx_v_parser = __pyx_t_1;
+
+  /* "httptools/parser/parser.pyx":156
+ *     def should_upgrade(self):
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return bool(parser.upgrade)             # <<<<<<<<<<<<<<
+ * 
+ *     def feed_data(self, data):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyInt_From_uint8_t(__pyx_v_parser->upgrade); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 156, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_3))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "httptools/parser/parser.pyx":154
+ *         return bool(cparser.llhttp_should_keep_alive(self._cparser))
+ * 
+ *     def should_upgrade(self):             # <<<<<<<<<<<<<<
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return bool(parser.upgrade)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser.should_upgrade", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":158
+ *         return bool(parser.upgrade)
+ * 
+ *     def feed_data(self, data):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             size_t data_len
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_6parser_10HttpParser_11feed_data(PyObject *__pyx_v_self, PyObject *__pyx_v_data); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_10HttpParser_11feed_data(PyObject *__pyx_v_self, PyObject *__pyx_v_data) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("feed_data (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_6parser_10HttpParser_10feed_data(((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_v_self), ((PyObject *)__pyx_v_data));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_10feed_data(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_data) {
+  size_t __pyx_v_data_len;
+  llhttp_errno_t __pyx_v_err;
+  Py_buffer *__pyx_v_buf;
+  int __pyx_v_owning_buf;
+  char *__pyx_v_err_pos;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  char const *__pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("feed_data", 0);
+
+  /* "httptools/parser/parser.pyx":163
+ *             cparser.llhttp_errno_t err
+ *             Py_buffer *buf
+ *             bint owning_buf = False             # <<<<<<<<<<<<<<
+ *             char* err_pos
+ * 
+ */
+  __pyx_v_owning_buf = 0;
+
+  /* "httptools/parser/parser.pyx":166
+ *             char* err_pos
+ * 
+ *         if PyMemoryView_Check(data):             # <<<<<<<<<<<<<<
+ *             buf = PyMemoryView_GET_BUFFER(data)
+ *             data_len = <size_t>buf.len
+ */
+  __pyx_t_1 = (PyMemoryView_Check(__pyx_v_data) != 0);
+  if (__pyx_t_1) {
+
+    /* "httptools/parser/parser.pyx":167
+ * 
+ *         if PyMemoryView_Check(data):
+ *             buf = PyMemoryView_GET_BUFFER(data)             # <<<<<<<<<<<<<<
+ *             data_len = <size_t>buf.len
+ *             err = cparser.llhttp_execute(
+ */
+    __pyx_v_buf = PyMemoryView_GET_BUFFER(__pyx_v_data);
+
+    /* "httptools/parser/parser.pyx":168
+ *         if PyMemoryView_Check(data):
+ *             buf = PyMemoryView_GET_BUFFER(data)
+ *             data_len = <size_t>buf.len             # <<<<<<<<<<<<<<
+ *             err = cparser.llhttp_execute(
+ *                 self._cparser,
+ */
+    __pyx_v_data_len = ((size_t)__pyx_v_buf->len);
+
+    /* "httptools/parser/parser.pyx":169
+ *             buf = PyMemoryView_GET_BUFFER(data)
+ *             data_len = <size_t>buf.len
+ *             err = cparser.llhttp_execute(             # <<<<<<<<<<<<<<
+ *                 self._cparser,
+ *                 <char*>buf.buf,
+ */
+    __pyx_v_err = llhttp_execute(__pyx_v_self->_cparser, ((char *)__pyx_v_buf->buf), __pyx_v_data_len);
+
+    /* "httptools/parser/parser.pyx":166
+ *             char* err_pos
+ * 
+ *         if PyMemoryView_Check(data):             # <<<<<<<<<<<<<<
+ *             buf = PyMemoryView_GET_BUFFER(data)
+ *             data_len = <size_t>buf.len
+ */
+    goto __pyx_L3;
+  }
+
+  /* "httptools/parser/parser.pyx":175
+ * 
+ *         else:
+ *             buf = &self.py_buf             # <<<<<<<<<<<<<<
+ *             PyObject_GetBuffer(data, buf, PyBUF_SIMPLE)
+ *             owning_buf = True
+ */
+  /*else*/ {
+    __pyx_v_buf = (&__pyx_v_self->py_buf);
+
+    /* "httptools/parser/parser.pyx":176
+ *         else:
+ *             buf = &self.py_buf
+ *             PyObject_GetBuffer(data, buf, PyBUF_SIMPLE)             # <<<<<<<<<<<<<<
+ *             owning_buf = True
+ *             data_len = <size_t>buf.len
+ */
+    __pyx_t_2 = PyObject_GetBuffer(__pyx_v_data, __pyx_v_buf, PyBUF_SIMPLE); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 176, __pyx_L1_error)
+
+    /* "httptools/parser/parser.pyx":177
+ *             buf = &self.py_buf
+ *             PyObject_GetBuffer(data, buf, PyBUF_SIMPLE)
+ *             owning_buf = True             # <<<<<<<<<<<<<<
+ *             data_len = <size_t>buf.len
+ * 
+ */
+    __pyx_v_owning_buf = 1;
+
+    /* "httptools/parser/parser.pyx":178
+ *             PyObject_GetBuffer(data, buf, PyBUF_SIMPLE)
+ *             owning_buf = True
+ *             data_len = <size_t>buf.len             # <<<<<<<<<<<<<<
+ * 
+ *             err = cparser.llhttp_execute(
+ */
+    __pyx_v_data_len = ((size_t)__pyx_v_buf->len);
+
+    /* "httptools/parser/parser.pyx":180
+ *             data_len = <size_t>buf.len
+ * 
+ *             err = cparser.llhttp_execute(             # <<<<<<<<<<<<<<
+ *                 self._cparser,
+ *                 <char*>buf.buf,
+ */
+    __pyx_v_err = llhttp_execute(__pyx_v_self->_cparser, ((char *)__pyx_v_buf->buf), __pyx_v_data_len);
+  }
+  __pyx_L3:;
+
+  /* "httptools/parser/parser.pyx":185
+ *                 data_len)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self._cparser.upgrade == 1 and err == cparser.HPE_PAUSED_UPGRADE:
+ *                 err_pos = cparser.llhttp_get_error_pos(self._cparser)
+ */
+  /*try:*/ {
+
+    /* "httptools/parser/parser.pyx":186
+ * 
+ *         try:
+ *             if self._cparser.upgrade == 1 and err == cparser.HPE_PAUSED_UPGRADE:             # <<<<<<<<<<<<<<
+ *                 err_pos = cparser.llhttp_get_error_pos(self._cparser)
+ * 
+ */
+    __pyx_t_3 = ((__pyx_v_self->_cparser->upgrade == 1) != 0);
+    if (__pyx_t_3) {
+    } else {
+      __pyx_t_1 = __pyx_t_3;
+      goto __pyx_L8_bool_binop_done;
+    }
+    __pyx_t_3 = ((__pyx_v_err == HPE_PAUSED_UPGRADE) != 0);
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_L8_bool_binop_done:;
+    if (unlikely(__pyx_t_1)) {
+
+      /* "httptools/parser/parser.pyx":187
+ *         try:
+ *             if self._cparser.upgrade == 1 and err == cparser.HPE_PAUSED_UPGRADE:
+ *                 err_pos = cparser.llhttp_get_error_pos(self._cparser)             # <<<<<<<<<<<<<<
+ * 
+ *                 # Immediately free the parser from "error" state, simulating
+ */
+      __pyx_v_err_pos = llhttp_get_error_pos(__pyx_v_self->_cparser);
+
+      /* "httptools/parser/parser.pyx":193
+ *                 # allow users manually "resume after upgrade", and 2) the use
+ *                 # case for resuming parsing is very rare.
+ *                 cparser.llhttp_resume_after_upgrade(self._cparser)             # <<<<<<<<<<<<<<
+ * 
+ *                 # The err_pos here is specific for the input buf. So if we ever
+ */
+      llhttp_resume_after_upgrade(__pyx_v_self->_cparser);
+
+      /* "httptools/parser/parser.pyx":199
+ *                 # successive calls to feed_data() until resume_after_upgrade is
+ *                 # called), we have to store the result and keep our own state.
+ *                 raise HttpParserUpgrade(err_pos - <char*>buf.buf)             # <<<<<<<<<<<<<<
+ *         finally:
+ *             if owning_buf:
+ */
+      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_HttpParserUpgrade); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_6 = __Pyx_PyInt_From_ptrdiff_t((__pyx_v_err_pos - ((char *)__pyx_v_buf->buf))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 199, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_5, function);
+        }
+      }
+      __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 199, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __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, 199, __pyx_L5_error)
+
+      /* "httptools/parser/parser.pyx":186
+ * 
+ *         try:
+ *             if self._cparser.upgrade == 1 and err == cparser.HPE_PAUSED_UPGRADE:             # <<<<<<<<<<<<<<
+ *                 err_pos = cparser.llhttp_get_error_pos(self._cparser)
+ * 
+ */
+    }
+  }
+
+  /* "httptools/parser/parser.pyx":201
+ *                 raise HttpParserUpgrade(err_pos - <char*>buf.buf)
+ *         finally:
+ *             if owning_buf:             # <<<<<<<<<<<<<<
+ *                 PyBuffer_Release(buf)
+ * 
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_1 = (__pyx_v_owning_buf != 0);
+      if (__pyx_t_1) {
+
+        /* "httptools/parser/parser.pyx":202
+ *         finally:
+ *             if owning_buf:
+ *                 PyBuffer_Release(buf)             # <<<<<<<<<<<<<<
+ * 
+ *         if err != cparser.HPE_OK:
+ */
+        PyBuffer_Release(__pyx_v_buf);
+
+        /* "httptools/parser/parser.pyx":201
+ *                 raise HttpParserUpgrade(err_pos - <char*>buf.buf)
+ *         finally:
+ *             if owning_buf:             # <<<<<<<<<<<<<<
+ *                 PyBuffer_Release(buf)
+ * 
+ */
+      }
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __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_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 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);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __Pyx_XGOTREF(__pyx_t_15);
+      __pyx_t_2 = __pyx_lineno; __pyx_t_8 = __pyx_clineno; __pyx_t_9 = __pyx_filename;
+      {
+        __pyx_t_1 = (__pyx_v_owning_buf != 0);
+        if (__pyx_t_1) {
+
+          /* "httptools/parser/parser.pyx":202
+ *         finally:
+ *             if owning_buf:
+ *                 PyBuffer_Release(buf)             # <<<<<<<<<<<<<<
+ * 
+ *         if err != cparser.HPE_OK:
+ */
+          PyBuffer_Release(__pyx_v_buf);
+
+          /* "httptools/parser/parser.pyx":201
+ *                 raise HttpParserUpgrade(err_pos - <char*>buf.buf)
+ *         finally:
+ *             if owning_buf:             # <<<<<<<<<<<<<<
+ *                 PyBuffer_Release(buf)
+ * 
+ */
+        }
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+      }
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __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_2; __pyx_clineno = __pyx_t_8; __pyx_filename = __pyx_t_9;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "httptools/parser/parser.pyx":204
+ *                 PyBuffer_Release(buf)
+ * 
+ *         if err != cparser.HPE_OK:             # <<<<<<<<<<<<<<
+ *             ex = parser_error_from_errno(
+ *                 self._cparser,
+ */
+  __pyx_t_1 = ((__pyx_v_err != HPE_OK) != 0);
+  if (__pyx_t_1) {
+
+    /* "httptools/parser/parser.pyx":205
+ * 
+ *         if err != cparser.HPE_OK:
+ *             ex = parser_error_from_errno(             # <<<<<<<<<<<<<<
+ *                 self._cparser,
+ *                 <cparser.llhttp_errno_t> self._cparser.error)
+ */
+    __pyx_t_4 = __pyx_f_9httptools_6parser_6parser_parser_error_from_errno(__pyx_v_self->_cparser, ((llhttp_errno_t)__pyx_v_self->_cparser->error)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 205, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_v_ex = __pyx_t_4;
+    __pyx_t_4 = 0;
+
+    /* "httptools/parser/parser.pyx":208
+ *                 self._cparser,
+ *                 <cparser.llhttp_errno_t> self._cparser.error)
+ *             if isinstance(ex, HttpParserCallbackError):             # <<<<<<<<<<<<<<
+ *                 if self._last_error is not None:
+ *                     ex.__context__ = self._last_error
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_HttpParserCallbackError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_1 = PyObject_IsInstance(__pyx_v_ex, __pyx_t_4); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 208, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_3 = (__pyx_t_1 != 0);
+    if (__pyx_t_3) {
+
+      /* "httptools/parser/parser.pyx":209
+ *                 <cparser.llhttp_errno_t> self._cparser.error)
+ *             if isinstance(ex, HttpParserCallbackError):
+ *                 if self._last_error is not None:             # <<<<<<<<<<<<<<
+ *                     ex.__context__ = self._last_error
+ *                     self._last_error = None
+ */
+      __pyx_t_3 = (__pyx_v_self->_last_error != Py_None);
+      __pyx_t_1 = (__pyx_t_3 != 0);
+      if (__pyx_t_1) {
+
+        /* "httptools/parser/parser.pyx":210
+ *             if isinstance(ex, HttpParserCallbackError):
+ *                 if self._last_error is not None:
+ *                     ex.__context__ = self._last_error             # <<<<<<<<<<<<<<
+ *                     self._last_error = None
+ *             raise ex
+ */
+        __pyx_t_4 = __pyx_v_self->_last_error;
+        __Pyx_INCREF(__pyx_t_4);
+        if (__Pyx_PyObject_SetAttrStr(__pyx_v_ex, __pyx_n_s_context, __pyx_t_4) < 0) __PYX_ERR(0, 210, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "httptools/parser/parser.pyx":211
+ *                 if self._last_error is not None:
+ *                     ex.__context__ = self._last_error
+ *                     self._last_error = None             # <<<<<<<<<<<<<<
+ *             raise ex
+ * 
+ */
+        __Pyx_INCREF(Py_None);
+        __Pyx_GIVEREF(Py_None);
+        __Pyx_GOTREF(__pyx_v_self->_last_error);
+        __Pyx_DECREF(__pyx_v_self->_last_error);
+        __pyx_v_self->_last_error = Py_None;
+
+        /* "httptools/parser/parser.pyx":209
+ *                 <cparser.llhttp_errno_t> self._cparser.error)
+ *             if isinstance(ex, HttpParserCallbackError):
+ *                 if self._last_error is not None:             # <<<<<<<<<<<<<<
+ *                     ex.__context__ = self._last_error
+ *                     self._last_error = None
+ */
+      }
+
+      /* "httptools/parser/parser.pyx":208
+ *                 self._cparser,
+ *                 <cparser.llhttp_errno_t> self._cparser.error)
+ *             if isinstance(ex, HttpParserCallbackError):             # <<<<<<<<<<<<<<
+ *                 if self._last_error is not None:
+ *                     ex.__context__ = self._last_error
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":212
+ *                     ex.__context__ = self._last_error
+ *                     self._last_error = None
+ *             raise ex             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __Pyx_Raise(__pyx_v_ex, 0, 0, 0);
+    __PYX_ERR(0, 212, __pyx_L1_error)
+
+    /* "httptools/parser/parser.pyx":204
+ *                 PyBuffer_Release(buf)
+ * 
+ *         if err != cparser.HPE_OK:             # <<<<<<<<<<<<<<
+ *             ex = parser_error_from_errno(
+ *                 self._cparser,
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":158
+ *         return bool(parser.upgrade)
+ * 
+ *     def feed_data(self, data):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             size_t data_len
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser.feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ex);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_6parser_10HttpParser_13__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_10HttpParser_13__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_9httptools_6parser_6parser_10HttpParser_12__reduce_cython__(((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__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);
+
+  /* "(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_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_ERR(1, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser.__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_9httptools_6parser_6parser_10HttpParser_15__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_10HttpParser_15__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_9httptools_6parser_6parser_10HttpParser_14__setstate_cython__(((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_10HttpParser_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__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);
+
+  /* "(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__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_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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpParser.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":217
+ * cdef class HttpRequestParser(HttpParser):
+ * 
+ *     def __init__(self, protocol):             # <<<<<<<<<<<<<<
+ *         self._init(protocol, cparser.HTTP_REQUEST)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9httptools_6parser_6parser_17HttpRequestParser_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9httptools_6parser_6parser_17HttpRequestParser_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_protocol = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol,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_protocol)) != 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, "__init__") < 0)) __PYX_ERR(0, 217, __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_protocol = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 217, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("httptools.parser.parser.HttpRequestParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_9httptools_6parser_6parser_17HttpRequestParser___init__(((struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *)__pyx_v_self), __pyx_v_protocol);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_9httptools_6parser_6parser_17HttpRequestParser___init__(struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *__pyx_v_self, PyObject *__pyx_v_protocol) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  /* "httptools/parser/parser.pyx":218
+ * 
+ *     def __init__(self, protocol):
+ *         self._init(protocol, cparser.HTTP_REQUEST)             # <<<<<<<<<<<<<<
+ * 
+ *         self._proto_on_url = getattr(protocol, 'on_url', None)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpRequestParser *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._init(((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_v_self), __pyx_v_protocol, HTTP_REQUEST); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":220
+ *         self._init(protocol, cparser.HTTP_REQUEST)
+ * 
+ *         self._proto_on_url = getattr(protocol, 'on_url', None)             # <<<<<<<<<<<<<<
+ *         if self._proto_on_url is not None:
+ *             self._csettings.on_url = cb_on_url
+ */
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_protocol, __pyx_n_u_on_url, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->__pyx_base._proto_on_url);
+  __Pyx_DECREF(__pyx_v_self->__pyx_base._proto_on_url);
+  __pyx_v_self->__pyx_base._proto_on_url = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":221
+ * 
+ *         self._proto_on_url = getattr(protocol, 'on_url', None)
+ *         if self._proto_on_url is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_url = cb_on_url
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_self->__pyx_base._proto_on_url != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "httptools/parser/parser.pyx":222
+ *         self._proto_on_url = getattr(protocol, 'on_url', None)
+ *         if self._proto_on_url is not None:
+ *             self._csettings.on_url = cb_on_url             # <<<<<<<<<<<<<<
+ * 
+ *     def get_method(self):
+ */
+    __pyx_v_self->__pyx_base._csettings->on_url = __pyx_f_9httptools_6parser_6parser_cb_on_url;
+
+    /* "httptools/parser/parser.pyx":221
+ * 
+ *         self._proto_on_url = getattr(protocol, 'on_url', None)
+ *         if self._proto_on_url is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_url = cb_on_url
+ * 
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":217
+ * cdef class HttpRequestParser(HttpParser):
+ * 
+ *     def __init__(self, protocol):             # <<<<<<<<<<<<<<
+ *         self._init(protocol, cparser.HTTP_REQUEST)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpRequestParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":224
+ *             self._csettings.on_url = cb_on_url
+ * 
+ *     def get_method(self):             # <<<<<<<<<<<<<<
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return cparser.llhttp_method_name(<cparser.llhttp_method_t> parser.method)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_6parser_17HttpRequestParser_3get_method(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_17HttpRequestParser_3get_method(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_method (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_6parser_17HttpRequestParser_2get_method(((struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_17HttpRequestParser_2get_method(struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *__pyx_v_self) {
+  llhttp_t *__pyx_v_parser;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  llhttp_t *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_method", 0);
+
+  /* "httptools/parser/parser.pyx":225
+ * 
+ *     def get_method(self):
+ *         cdef cparser.llhttp_t* parser = self._cparser             # <<<<<<<<<<<<<<
+ *         return cparser.llhttp_method_name(<cparser.llhttp_method_t> parser.method)
+ * 
+ */
+  __pyx_t_1 = __pyx_v_self->__pyx_base._cparser;
+  __pyx_v_parser = __pyx_t_1;
+
+  /* "httptools/parser/parser.pyx":226
+ *     def get_method(self):
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return cparser.llhttp_method_name(<cparser.llhttp_method_t> parser.method)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyBytes_FromString(llhttp_method_name(((llhttp_method_t)__pyx_v_parser->method))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "httptools/parser/parser.pyx":224
+ *             self._csettings.on_url = cb_on_url
+ * 
+ *     def get_method(self):             # <<<<<<<<<<<<<<
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return cparser.llhttp_method_name(<cparser.llhttp_method_t> parser.method)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpRequestParser.get_method", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_6parser_17HttpRequestParser_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_17HttpRequestParser_5__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_9httptools_6parser_6parser_17HttpRequestParser_4__reduce_cython__(((struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_17HttpRequestParser_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, 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_ERR(1, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpRequestParser.__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_9httptools_6parser_6parser_17HttpRequestParser_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_17HttpRequestParser_7__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_9httptools_6parser_6parser_17HttpRequestParser_6__setstate_cython__(((struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_17HttpRequestParser_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *__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);
+
+  /* "(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__5, 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__")
+ * 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("httptools.parser.parser.HttpRequestParser.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":231
+ * cdef class HttpResponseParser(HttpParser):
+ * 
+ *     def __init__(self, protocol):             # <<<<<<<<<<<<<<
+ *         self._init(protocol, cparser.HTTP_RESPONSE)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9httptools_6parser_6parser_18HttpResponseParser_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9httptools_6parser_6parser_18HttpResponseParser_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_protocol = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol,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_protocol)) != 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, "__init__") < 0)) __PYX_ERR(0, 231, __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_protocol = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 231, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("httptools.parser.parser.HttpResponseParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_9httptools_6parser_6parser_18HttpResponseParser___init__(((struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *)__pyx_v_self), __pyx_v_protocol);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_9httptools_6parser_6parser_18HttpResponseParser___init__(struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *__pyx_v_self, PyObject *__pyx_v_protocol) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  /* "httptools/parser/parser.pyx":232
+ * 
+ *     def __init__(self, protocol):
+ *         self._init(protocol, cparser.HTTP_RESPONSE)             # <<<<<<<<<<<<<<
+ * 
+ *         self._proto_on_status = getattr(protocol, 'on_status', None)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpResponseParser *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._init(((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_v_self), __pyx_v_protocol, HTTP_RESPONSE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":234
+ *         self._init(protocol, cparser.HTTP_RESPONSE)
+ * 
+ *         self._proto_on_status = getattr(protocol, 'on_status', None)             # <<<<<<<<<<<<<<
+ *         if self._proto_on_status is not None:
+ *             self._csettings.on_status = cb_on_status
+ */
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_protocol, __pyx_n_u_on_status, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->__pyx_base._proto_on_status);
+  __Pyx_DECREF(__pyx_v_self->__pyx_base._proto_on_status);
+  __pyx_v_self->__pyx_base._proto_on_status = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":235
+ * 
+ *         self._proto_on_status = getattr(protocol, 'on_status', None)
+ *         if self._proto_on_status is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_status = cb_on_status
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_self->__pyx_base._proto_on_status != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "httptools/parser/parser.pyx":236
+ *         self._proto_on_status = getattr(protocol, 'on_status', None)
+ *         if self._proto_on_status is not None:
+ *             self._csettings.on_status = cb_on_status             # <<<<<<<<<<<<<<
+ * 
+ *     def get_status_code(self):
+ */
+    __pyx_v_self->__pyx_base._csettings->on_status = __pyx_f_9httptools_6parser_6parser_cb_on_status;
+
+    /* "httptools/parser/parser.pyx":235
+ * 
+ *         self._proto_on_status = getattr(protocol, 'on_status', None)
+ *         if self._proto_on_status is not None:             # <<<<<<<<<<<<<<
+ *             self._csettings.on_status = cb_on_status
+ * 
+ */
+  }
+
+  /* "httptools/parser/parser.pyx":231
+ * cdef class HttpResponseParser(HttpParser):
+ * 
+ *     def __init__(self, protocol):             # <<<<<<<<<<<<<<
+ *         self._init(protocol, cparser.HTTP_RESPONSE)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpResponseParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":238
+ *             self._csettings.on_status = cb_on_status
+ * 
+ *     def get_status_code(self):             # <<<<<<<<<<<<<<
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return parser.status_code
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_6parser_18HttpResponseParser_3get_status_code(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_18HttpResponseParser_3get_status_code(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_status_code (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_6parser_18HttpResponseParser_2get_status_code(((struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_18HttpResponseParser_2get_status_code(struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *__pyx_v_self) {
+  llhttp_t *__pyx_v_parser;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  llhttp_t *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_status_code", 0);
+
+  /* "httptools/parser/parser.pyx":239
+ * 
+ *     def get_status_code(self):
+ *         cdef cparser.llhttp_t* parser = self._cparser             # <<<<<<<<<<<<<<
+ *         return parser.status_code
+ * 
+ */
+  __pyx_t_1 = __pyx_v_self->__pyx_base._cparser;
+  __pyx_v_parser = __pyx_t_1;
+
+  /* "httptools/parser/parser.pyx":240
+ *     def get_status_code(self):
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return parser.status_code             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyInt_From_uint16_t(__pyx_v_parser->status_code); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "httptools/parser/parser.pyx":238
+ *             self._csettings.on_status = cb_on_status
+ * 
+ *     def get_status_code(self):             # <<<<<<<<<<<<<<
+ *         cdef cparser.llhttp_t* parser = self._cparser
+ *         return parser.status_code
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpResponseParser.get_status_code", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_6parser_18HttpResponseParser_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_18HttpResponseParser_5__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_9httptools_6parser_6parser_18HttpResponseParser_4__reduce_cython__(((struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_18HttpResponseParser_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, 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_ERR(1, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("httptools.parser.parser.HttpResponseParser.__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_9httptools_6parser_6parser_18HttpResponseParser_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_6parser_18HttpResponseParser_7__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_9httptools_6parser_6parser_18HttpResponseParser_6__setstate_cython__(((struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_6parser_18HttpResponseParser_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *__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);
+
+  /* "(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__7, 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__")
+ * 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("httptools.parser.parser.HttpResponseParser.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":243
+ * 
+ * 
+ * cdef int cb_on_message_begin(cparser.llhttp_t* parser) except -1:             # <<<<<<<<<<<<<<
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ */
+
+static int __pyx_f_9httptools_6parser_6parser_cb_on_message_begin(llhttp_t *__pyx_v_parser) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_pyparser = 0;
+  PyObject *__pyx_v_ex = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cb_on_message_begin", 0);
+
+  /* "httptools/parser/parser.pyx":244
+ * 
+ * cdef int cb_on_message_begin(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data             # <<<<<<<<<<<<<<
+ *     try:
+ *         pyparser._proto_on_message_begin()
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_parser->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_pyparser = ((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":245
+ * cdef int cb_on_message_begin(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_message_begin()
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "httptools/parser/parser.pyx":246
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ *         pyparser._proto_on_message_begin()             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex
+ */
+      __Pyx_INCREF(__pyx_v_pyparser->_proto_on_message_begin);
+      __pyx_t_5 = __pyx_v_pyparser->_proto_on_message_begin; __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_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_1 = (__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_1)) __PYX_ERR(0, 246, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "httptools/parser/parser.pyx":245
+ * cdef int cb_on_message_begin(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_message_begin()
+ *     except BaseException as ex:
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":251
+ *         return -1
+ *     else:
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    /*else:*/ {
+      __pyx_r = 0;
+      goto __pyx_L6_except_return;
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "httptools/parser/parser.pyx":247
+ *     try:
+ *         pyparser._proto_on_message_begin()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return -1
+ */
+    __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_7) {
+      __Pyx_AddTraceback("httptools.parser.parser.cb_on_message_begin", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(0, 247, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_v_ex = __pyx_t_5;
+      /*try:*/ {
+
+        /* "httptools/parser/parser.pyx":248
+ *         pyparser._proto_on_message_begin()
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex             # <<<<<<<<<<<<<<
+ *         return -1
+ *     else:
+ */
+        __Pyx_INCREF(__pyx_v_ex);
+        __Pyx_GIVEREF(__pyx_v_ex);
+        __Pyx_GOTREF(__pyx_v_pyparser->_last_error);
+        __Pyx_DECREF(__pyx_v_pyparser->_last_error);
+        __pyx_v_pyparser->_last_error = __pyx_v_ex;
+
+        /* "httptools/parser/parser.pyx":249
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex
+ *         return -1             # <<<<<<<<<<<<<<
+ *     else:
+ *         return 0
+ */
+        __pyx_r = -1;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        goto __pyx_L13_return;
+      }
+
+      /* "httptools/parser/parser.pyx":247
+ *     try:
+ *         pyparser._proto_on_message_begin()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return -1
+ */
+      /*finally:*/ {
+        __pyx_L13_return: {
+          __pyx_t_7 = __pyx_r;
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          __pyx_r = __pyx_t_7;
+          goto __pyx_L6_except_return;
+        }
+      }
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "httptools/parser/parser.pyx":245
+ * cdef int cb_on_message_begin(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_message_begin()
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+  }
+
+  /* "httptools/parser/parser.pyx":243
+ * 
+ * 
+ * cdef int cb_on_message_begin(cparser.llhttp_t* parser) except -1:             # <<<<<<<<<<<<<<
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("httptools.parser.parser.cb_on_message_begin", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pyparser);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":254
+ * 
+ * 
+ * cdef int cb_on_url(cparser.llhttp_t* parser,             # <<<<<<<<<<<<<<
+ *                    const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ */
+
+static int __pyx_f_9httptools_6parser_6parser_cb_on_url(llhttp_t *__pyx_v_parser, char const *__pyx_v_at, size_t __pyx_v_length) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_pyparser = 0;
+  PyObject *__pyx_v_ex = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cb_on_url", 0);
+
+  /* "httptools/parser/parser.pyx":256
+ * cdef int cb_on_url(cparser.llhttp_t* parser,
+ *                    const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data             # <<<<<<<<<<<<<<
+ *     try:
+ *         pyparser._proto_on_url(at[:length])
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_parser->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_pyparser = ((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":257
+ *                    const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_url(at[:length])
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "httptools/parser/parser.pyx":258
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ *         pyparser._proto_on_url(at[:length])             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_url` callback error")
+ */
+      __pyx_t_5 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_at + 0, __pyx_v_length - 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 258, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_v_pyparser->_proto_on_url);
+      __pyx_t_6 = __pyx_v_pyparser->_proto_on_url; __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 258, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "httptools/parser/parser.pyx":257
+ *                    const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_url(at[:length])
+ *     except BaseException as ex:
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":264
+ *         return cparser.HPE_USER
+ *     else:
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    /*else:*/ {
+      __pyx_r = 0;
+      goto __pyx_L6_except_return;
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "httptools/parser/parser.pyx":259
+ *     try:
+ *         pyparser._proto_on_url(at[:length])
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_set_error_reason(parser, "`on_url` callback error")
+ *         pyparser._last_error = ex
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("httptools.parser.parser.cb_on_url", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_5) < 0) __PYX_ERR(0, 259, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_v_ex = __pyx_t_6;
+      /*try:*/ {
+
+        /* "httptools/parser/parser.pyx":260
+ *         pyparser._proto_on_url(at[:length])
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_url` callback error")             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return cparser.HPE_USER
+ */
+        llhttp_set_error_reason(__pyx_v_parser, ((char const *)"`on_url` callback error"));
+
+        /* "httptools/parser/parser.pyx":261
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_url` callback error")
+ *         pyparser._last_error = ex             # <<<<<<<<<<<<<<
+ *         return cparser.HPE_USER
+ *     else:
+ */
+        __Pyx_INCREF(__pyx_v_ex);
+        __Pyx_GIVEREF(__pyx_v_ex);
+        __Pyx_GOTREF(__pyx_v_pyparser->_last_error);
+        __Pyx_DECREF(__pyx_v_pyparser->_last_error);
+        __pyx_v_pyparser->_last_error = __pyx_v_ex;
+
+        /* "httptools/parser/parser.pyx":262
+ *         cparser.llhttp_set_error_reason(parser, "`on_url` callback error")
+ *         pyparser._last_error = ex
+ *         return cparser.HPE_USER             # <<<<<<<<<<<<<<
+ *     else:
+ *         return 0
+ */
+        __pyx_r = HPE_USER;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        goto __pyx_L13_return;
+      }
+
+      /* "httptools/parser/parser.pyx":259
+ *     try:
+ *         pyparser._proto_on_url(at[:length])
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_set_error_reason(parser, "`on_url` callback error")
+ *         pyparser._last_error = ex
+ */
+      /*finally:*/ {
+        __pyx_L13_return: {
+          __pyx_t_8 = __pyx_r;
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          __pyx_r = __pyx_t_8;
+          goto __pyx_L6_except_return;
+        }
+      }
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "httptools/parser/parser.pyx":257
+ *                    const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_url(at[:length])
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+  }
+
+  /* "httptools/parser/parser.pyx":254
+ * 
+ * 
+ * cdef int cb_on_url(cparser.llhttp_t* parser,             # <<<<<<<<<<<<<<
+ *                    const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ */
+
+  /* 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_AddTraceback("httptools.parser.parser.cb_on_url", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pyparser);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":267
+ * 
+ * 
+ * cdef int cb_on_status(cparser.llhttp_t* parser,             # <<<<<<<<<<<<<<
+ *                       const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ */
+
+static int __pyx_f_9httptools_6parser_6parser_cb_on_status(llhttp_t *__pyx_v_parser, char const *__pyx_v_at, size_t __pyx_v_length) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_pyparser = 0;
+  PyObject *__pyx_v_ex = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cb_on_status", 0);
+
+  /* "httptools/parser/parser.pyx":269
+ * cdef int cb_on_status(cparser.llhttp_t* parser,
+ *                       const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data             # <<<<<<<<<<<<<<
+ *     try:
+ *         pyparser._proto_on_status(at[:length])
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_parser->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_pyparser = ((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":270
+ *                       const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_status(at[:length])
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "httptools/parser/parser.pyx":271
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ *         pyparser._proto_on_status(at[:length])             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_status` callback error")
+ */
+      __pyx_t_5 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_at + 0, __pyx_v_length - 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 271, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_v_pyparser->_proto_on_status);
+      __pyx_t_6 = __pyx_v_pyparser->_proto_on_status; __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 271, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "httptools/parser/parser.pyx":270
+ *                       const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_status(at[:length])
+ *     except BaseException as ex:
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":277
+ *         return cparser.HPE_USER
+ *     else:
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    /*else:*/ {
+      __pyx_r = 0;
+      goto __pyx_L6_except_return;
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "httptools/parser/parser.pyx":272
+ *     try:
+ *         pyparser._proto_on_status(at[:length])
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_set_error_reason(parser, "`on_status` callback error")
+ *         pyparser._last_error = ex
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("httptools.parser.parser.cb_on_status", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_5) < 0) __PYX_ERR(0, 272, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_v_ex = __pyx_t_6;
+      /*try:*/ {
+
+        /* "httptools/parser/parser.pyx":273
+ *         pyparser._proto_on_status(at[:length])
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_status` callback error")             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return cparser.HPE_USER
+ */
+        llhttp_set_error_reason(__pyx_v_parser, ((char const *)"`on_status` callback error"));
+
+        /* "httptools/parser/parser.pyx":274
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_status` callback error")
+ *         pyparser._last_error = ex             # <<<<<<<<<<<<<<
+ *         return cparser.HPE_USER
+ *     else:
+ */
+        __Pyx_INCREF(__pyx_v_ex);
+        __Pyx_GIVEREF(__pyx_v_ex);
+        __Pyx_GOTREF(__pyx_v_pyparser->_last_error);
+        __Pyx_DECREF(__pyx_v_pyparser->_last_error);
+        __pyx_v_pyparser->_last_error = __pyx_v_ex;
+
+        /* "httptools/parser/parser.pyx":275
+ *         cparser.llhttp_set_error_reason(parser, "`on_status` callback error")
+ *         pyparser._last_error = ex
+ *         return cparser.HPE_USER             # <<<<<<<<<<<<<<
+ *     else:
+ *         return 0
+ */
+        __pyx_r = HPE_USER;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        goto __pyx_L13_return;
+      }
+
+      /* "httptools/parser/parser.pyx":272
+ *     try:
+ *         pyparser._proto_on_status(at[:length])
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_set_error_reason(parser, "`on_status` callback error")
+ *         pyparser._last_error = ex
+ */
+      /*finally:*/ {
+        __pyx_L13_return: {
+          __pyx_t_8 = __pyx_r;
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          __pyx_r = __pyx_t_8;
+          goto __pyx_L6_except_return;
+        }
+      }
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "httptools/parser/parser.pyx":270
+ *                       const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_status(at[:length])
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+  }
+
+  /* "httptools/parser/parser.pyx":267
+ * 
+ * 
+ * cdef int cb_on_status(cparser.llhttp_t* parser,             # <<<<<<<<<<<<<<
+ *                       const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ */
+
+  /* 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_AddTraceback("httptools.parser.parser.cb_on_status", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pyparser);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":280
+ * 
+ * 
+ * cdef int cb_on_header_field(cparser.llhttp_t* parser,             # <<<<<<<<<<<<<<
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ */
+
+static int __pyx_f_9httptools_6parser_6parser_cb_on_header_field(llhttp_t *__pyx_v_parser, char const *__pyx_v_at, size_t __pyx_v_length) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_pyparser = 0;
+  PyObject *__pyx_v_ex = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  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_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cb_on_header_field", 0);
+
+  /* "httptools/parser/parser.pyx":282
+ * cdef int cb_on_header_field(cparser.llhttp_t* parser,
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data             # <<<<<<<<<<<<<<
+ *     try:
+ *         pyparser._on_header_field(at[:length])
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_parser->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_pyparser = ((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":283
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_header_field(at[:length])
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "httptools/parser/parser.pyx":284
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ *         pyparser._on_header_field(at[:length])             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_field` callback error")
+ */
+      __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_at + 0, __pyx_v_length - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 284, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_5 = ((struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser *)__pyx_v_pyparser->__pyx_vtab)->_on_header_field(__pyx_v_pyparser, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 284, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+      /* "httptools/parser/parser.pyx":283
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_header_field(at[:length])
+ *     except BaseException as ex:
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":290
+ *         return cparser.HPE_USER
+ *     else:
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    /*else:*/ {
+      __pyx_r = 0;
+      goto __pyx_L6_except_return;
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "httptools/parser/parser.pyx":285
+ *     try:
+ *         pyparser._on_header_field(at[:length])
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_field` callback error")
+ *         pyparser._last_error = ex
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("httptools.parser.parser.cb_on_header_field", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(0, 285, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_1);
+      __pyx_v_ex = __pyx_t_1;
+      /*try:*/ {
+
+        /* "httptools/parser/parser.pyx":286
+ *         pyparser._on_header_field(at[:length])
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_field` callback error")             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return cparser.HPE_USER
+ */
+        llhttp_set_error_reason(__pyx_v_parser, ((char const *)"`on_header_field` callback error"));
+
+        /* "httptools/parser/parser.pyx":287
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_field` callback error")
+ *         pyparser._last_error = ex             # <<<<<<<<<<<<<<
+ *         return cparser.HPE_USER
+ *     else:
+ */
+        __Pyx_INCREF(__pyx_v_ex);
+        __Pyx_GIVEREF(__pyx_v_ex);
+        __Pyx_GOTREF(__pyx_v_pyparser->_last_error);
+        __Pyx_DECREF(__pyx_v_pyparser->_last_error);
+        __pyx_v_pyparser->_last_error = __pyx_v_ex;
+
+        /* "httptools/parser/parser.pyx":288
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_field` callback error")
+ *         pyparser._last_error = ex
+ *         return cparser.HPE_USER             # <<<<<<<<<<<<<<
+ *     else:
+ *         return 0
+ */
+        __pyx_r = HPE_USER;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L13_return;
+      }
+
+      /* "httptools/parser/parser.pyx":285
+ *     try:
+ *         pyparser._on_header_field(at[:length])
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_field` callback error")
+ *         pyparser._last_error = ex
+ */
+      /*finally:*/ {
+        __pyx_L13_return: {
+          __pyx_t_6 = __pyx_r;
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          __pyx_r = __pyx_t_6;
+          goto __pyx_L6_except_return;
+        }
+      }
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "httptools/parser/parser.pyx":283
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_header_field(at[:length])
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+  }
+
+  /* "httptools/parser/parser.pyx":280
+ * 
+ * 
+ * cdef int cb_on_header_field(cparser.llhttp_t* parser,             # <<<<<<<<<<<<<<
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("httptools.parser.parser.cb_on_header_field", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pyparser);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":293
+ * 
+ * 
+ * cdef int cb_on_header_value(cparser.llhttp_t* parser,             # <<<<<<<<<<<<<<
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ */
+
+static int __pyx_f_9httptools_6parser_6parser_cb_on_header_value(llhttp_t *__pyx_v_parser, char const *__pyx_v_at, size_t __pyx_v_length) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_pyparser = 0;
+  PyObject *__pyx_v_ex = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  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_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cb_on_header_value", 0);
+
+  /* "httptools/parser/parser.pyx":295
+ * cdef int cb_on_header_value(cparser.llhttp_t* parser,
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data             # <<<<<<<<<<<<<<
+ *     try:
+ *         pyparser._on_header_value(at[:length])
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_parser->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_pyparser = ((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":296
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_header_value(at[:length])
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "httptools/parser/parser.pyx":297
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ *         pyparser._on_header_value(at[:length])             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_value` callback error")
+ */
+      __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_at + 0, __pyx_v_length - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 297, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_5 = ((struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser *)__pyx_v_pyparser->__pyx_vtab)->_on_header_value(__pyx_v_pyparser, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 297, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+      /* "httptools/parser/parser.pyx":296
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_header_value(at[:length])
+ *     except BaseException as ex:
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":303
+ *         return cparser.HPE_USER
+ *     else:
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    /*else:*/ {
+      __pyx_r = 0;
+      goto __pyx_L6_except_return;
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "httptools/parser/parser.pyx":298
+ *     try:
+ *         pyparser._on_header_value(at[:length])
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_value` callback error")
+ *         pyparser._last_error = ex
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("httptools.parser.parser.cb_on_header_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(0, 298, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_1);
+      __pyx_v_ex = __pyx_t_1;
+      /*try:*/ {
+
+        /* "httptools/parser/parser.pyx":299
+ *         pyparser._on_header_value(at[:length])
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_value` callback error")             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return cparser.HPE_USER
+ */
+        llhttp_set_error_reason(__pyx_v_parser, ((char const *)"`on_header_value` callback error"));
+
+        /* "httptools/parser/parser.pyx":300
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_value` callback error")
+ *         pyparser._last_error = ex             # <<<<<<<<<<<<<<
+ *         return cparser.HPE_USER
+ *     else:
+ */
+        __Pyx_INCREF(__pyx_v_ex);
+        __Pyx_GIVEREF(__pyx_v_ex);
+        __Pyx_GOTREF(__pyx_v_pyparser->_last_error);
+        __Pyx_DECREF(__pyx_v_pyparser->_last_error);
+        __pyx_v_pyparser->_last_error = __pyx_v_ex;
+
+        /* "httptools/parser/parser.pyx":301
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_value` callback error")
+ *         pyparser._last_error = ex
+ *         return cparser.HPE_USER             # <<<<<<<<<<<<<<
+ *     else:
+ *         return 0
+ */
+        __pyx_r = HPE_USER;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L13_return;
+      }
+
+      /* "httptools/parser/parser.pyx":298
+ *     try:
+ *         pyparser._on_header_value(at[:length])
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_set_error_reason(parser, "`on_header_value` callback error")
+ *         pyparser._last_error = ex
+ */
+      /*finally:*/ {
+        __pyx_L13_return: {
+          __pyx_t_6 = __pyx_r;
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          __pyx_r = __pyx_t_6;
+          goto __pyx_L6_except_return;
+        }
+      }
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "httptools/parser/parser.pyx":296
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_header_value(at[:length])
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+  }
+
+  /* "httptools/parser/parser.pyx":293
+ * 
+ * 
+ * cdef int cb_on_header_value(cparser.llhttp_t* parser,             # <<<<<<<<<<<<<<
+ *                             const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("httptools.parser.parser.cb_on_header_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pyparser);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":306
+ * 
+ * 
+ * cdef int cb_on_headers_complete(cparser.llhttp_t* parser) except -1:             # <<<<<<<<<<<<<<
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ */
+
+static int __pyx_f_9httptools_6parser_6parser_cb_on_headers_complete(llhttp_t *__pyx_v_parser) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_pyparser = 0;
+  PyObject *__pyx_v_ex = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cb_on_headers_complete", 0);
+
+  /* "httptools/parser/parser.pyx":307
+ * 
+ * cdef int cb_on_headers_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data             # <<<<<<<<<<<<<<
+ *     try:
+ *         pyparser._on_headers_complete()
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_parser->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_pyparser = ((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":308
+ * cdef int cb_on_headers_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_headers_complete()
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "httptools/parser/parser.pyx":309
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ *         pyparser._on_headers_complete()             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser *)__pyx_v_pyparser->__pyx_vtab)->_on_headers_complete(__pyx_v_pyparser); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 309, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "httptools/parser/parser.pyx":308
+ * cdef int cb_on_headers_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_headers_complete()
+ *     except BaseException as ex:
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":314
+ *         return -1
+ *     else:
+ *         if pyparser._cparser.upgrade:             # <<<<<<<<<<<<<<
+ *             return 1
+ *         else:
+ */
+    /*else:*/ {
+      __pyx_t_5 = (__pyx_v_pyparser->_cparser->upgrade != 0);
+      if (__pyx_t_5) {
+
+        /* "httptools/parser/parser.pyx":315
+ *     else:
+ *         if pyparser._cparser.upgrade:
+ *             return 1             # <<<<<<<<<<<<<<
+ *         else:
+ *             return 0
+ */
+        __pyx_r = 1;
+        goto __pyx_L6_except_return;
+
+        /* "httptools/parser/parser.pyx":314
+ *         return -1
+ *     else:
+ *         if pyparser._cparser.upgrade:             # <<<<<<<<<<<<<<
+ *             return 1
+ *         else:
+ */
+      }
+
+      /* "httptools/parser/parser.pyx":317
+ *             return 1
+ *         else:
+ *             return 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+      /*else*/ {
+        __pyx_r = 0;
+        goto __pyx_L6_except_return;
+      }
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "httptools/parser/parser.pyx":310
+ *     try:
+ *         pyparser._on_headers_complete()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return -1
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("httptools.parser.parser.cb_on_headers_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 310, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_7);
+      __pyx_v_ex = __pyx_t_7;
+      /*try:*/ {
+
+        /* "httptools/parser/parser.pyx":311
+ *         pyparser._on_headers_complete()
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex             # <<<<<<<<<<<<<<
+ *         return -1
+ *     else:
+ */
+        __Pyx_INCREF(__pyx_v_ex);
+        __Pyx_GIVEREF(__pyx_v_ex);
+        __Pyx_GOTREF(__pyx_v_pyparser->_last_error);
+        __Pyx_DECREF(__pyx_v_pyparser->_last_error);
+        __pyx_v_pyparser->_last_error = __pyx_v_ex;
+
+        /* "httptools/parser/parser.pyx":312
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex
+ *         return -1             # <<<<<<<<<<<<<<
+ *     else:
+ *         if pyparser._cparser.upgrade:
+ */
+        __pyx_r = -1;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        goto __pyx_L14_return;
+      }
+
+      /* "httptools/parser/parser.pyx":310
+ *     try:
+ *         pyparser._on_headers_complete()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return -1
+ */
+      /*finally:*/ {
+        __pyx_L14_return: {
+          __pyx_t_6 = __pyx_r;
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          __pyx_r = __pyx_t_6;
+          goto __pyx_L6_except_return;
+        }
+      }
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "httptools/parser/parser.pyx":308
+ * cdef int cb_on_headers_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_headers_complete()
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+  }
+
+  /* "httptools/parser/parser.pyx":306
+ * 
+ * 
+ * cdef int cb_on_headers_complete(cparser.llhttp_t* parser) except -1:             # <<<<<<<<<<<<<<
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("httptools.parser.parser.cb_on_headers_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pyparser);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":320
+ * 
+ * 
+ * cdef int cb_on_body(cparser.llhttp_t* parser,             # <<<<<<<<<<<<<<
+ *                     const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ */
+
+static int __pyx_f_9httptools_6parser_6parser_cb_on_body(llhttp_t *__pyx_v_parser, char const *__pyx_v_at, size_t __pyx_v_length) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_pyparser = 0;
+  PyObject *__pyx_v_ex = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cb_on_body", 0);
+
+  /* "httptools/parser/parser.pyx":322
+ * cdef int cb_on_body(cparser.llhttp_t* parser,
+ *                     const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data             # <<<<<<<<<<<<<<
+ *     try:
+ *         pyparser._proto_on_body(at[:length])
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_parser->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_pyparser = ((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":323
+ *                     const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_body(at[:length])
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "httptools/parser/parser.pyx":324
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ *         pyparser._proto_on_body(at[:length])             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_body` callback error")
+ */
+      __pyx_t_5 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_at + 0, __pyx_v_length - 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 324, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_v_pyparser->_proto_on_body);
+      __pyx_t_6 = __pyx_v_pyparser->_proto_on_body; __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 324, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "httptools/parser/parser.pyx":323
+ *                     const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_body(at[:length])
+ *     except BaseException as ex:
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":330
+ *         return cparser.HPE_USER
+ *     else:
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    /*else:*/ {
+      __pyx_r = 0;
+      goto __pyx_L6_except_return;
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "httptools/parser/parser.pyx":325
+ *     try:
+ *         pyparser._proto_on_body(at[:length])
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_set_error_reason(parser, "`on_body` callback error")
+ *         pyparser._last_error = ex
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("httptools.parser.parser.cb_on_body", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_5) < 0) __PYX_ERR(0, 325, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_v_ex = __pyx_t_6;
+      /*try:*/ {
+
+        /* "httptools/parser/parser.pyx":326
+ *         pyparser._proto_on_body(at[:length])
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_body` callback error")             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return cparser.HPE_USER
+ */
+        llhttp_set_error_reason(__pyx_v_parser, ((char const *)"`on_body` callback error"));
+
+        /* "httptools/parser/parser.pyx":327
+ *     except BaseException as ex:
+ *         cparser.llhttp_set_error_reason(parser, "`on_body` callback error")
+ *         pyparser._last_error = ex             # <<<<<<<<<<<<<<
+ *         return cparser.HPE_USER
+ *     else:
+ */
+        __Pyx_INCREF(__pyx_v_ex);
+        __Pyx_GIVEREF(__pyx_v_ex);
+        __Pyx_GOTREF(__pyx_v_pyparser->_last_error);
+        __Pyx_DECREF(__pyx_v_pyparser->_last_error);
+        __pyx_v_pyparser->_last_error = __pyx_v_ex;
+
+        /* "httptools/parser/parser.pyx":328
+ *         cparser.llhttp_set_error_reason(parser, "`on_body` callback error")
+ *         pyparser._last_error = ex
+ *         return cparser.HPE_USER             # <<<<<<<<<<<<<<
+ *     else:
+ *         return 0
+ */
+        __pyx_r = HPE_USER;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        goto __pyx_L13_return;
+      }
+
+      /* "httptools/parser/parser.pyx":325
+ *     try:
+ *         pyparser._proto_on_body(at[:length])
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         cparser.llhttp_set_error_reason(parser, "`on_body` callback error")
+ *         pyparser._last_error = ex
+ */
+      /*finally:*/ {
+        __pyx_L13_return: {
+          __pyx_t_8 = __pyx_r;
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          __pyx_r = __pyx_t_8;
+          goto __pyx_L6_except_return;
+        }
+      }
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "httptools/parser/parser.pyx":323
+ *                     const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_body(at[:length])
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+  }
+
+  /* "httptools/parser/parser.pyx":320
+ * 
+ * 
+ * cdef int cb_on_body(cparser.llhttp_t* parser,             # <<<<<<<<<<<<<<
+ *                     const char *at, size_t length) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ */
+
+  /* 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_AddTraceback("httptools.parser.parser.cb_on_body", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pyparser);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":333
+ * 
+ * 
+ * cdef int cb_on_message_complete(cparser.llhttp_t* parser) except -1:             # <<<<<<<<<<<<<<
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ */
+
+static int __pyx_f_9httptools_6parser_6parser_cb_on_message_complete(llhttp_t *__pyx_v_parser) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_pyparser = 0;
+  PyObject *__pyx_v_ex = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cb_on_message_complete", 0);
+
+  /* "httptools/parser/parser.pyx":334
+ * 
+ * cdef int cb_on_message_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data             # <<<<<<<<<<<<<<
+ *     try:
+ *         pyparser._proto_on_message_complete()
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_parser->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_pyparser = ((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":335
+ * cdef int cb_on_message_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_message_complete()
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "httptools/parser/parser.pyx":336
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ *         pyparser._proto_on_message_complete()             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex
+ */
+      __Pyx_INCREF(__pyx_v_pyparser->_proto_on_message_complete);
+      __pyx_t_5 = __pyx_v_pyparser->_proto_on_message_complete; __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_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_1 = (__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_1)) __PYX_ERR(0, 336, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "httptools/parser/parser.pyx":335
+ * cdef int cb_on_message_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_message_complete()
+ *     except BaseException as ex:
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":341
+ *         return -1
+ *     else:
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    /*else:*/ {
+      __pyx_r = 0;
+      goto __pyx_L6_except_return;
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "httptools/parser/parser.pyx":337
+ *     try:
+ *         pyparser._proto_on_message_complete()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return -1
+ */
+    __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_7) {
+      __Pyx_AddTraceback("httptools.parser.parser.cb_on_message_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(0, 337, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_v_ex = __pyx_t_5;
+      /*try:*/ {
+
+        /* "httptools/parser/parser.pyx":338
+ *         pyparser._proto_on_message_complete()
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex             # <<<<<<<<<<<<<<
+ *         return -1
+ *     else:
+ */
+        __Pyx_INCREF(__pyx_v_ex);
+        __Pyx_GIVEREF(__pyx_v_ex);
+        __Pyx_GOTREF(__pyx_v_pyparser->_last_error);
+        __Pyx_DECREF(__pyx_v_pyparser->_last_error);
+        __pyx_v_pyparser->_last_error = __pyx_v_ex;
+
+        /* "httptools/parser/parser.pyx":339
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex
+ *         return -1             # <<<<<<<<<<<<<<
+ *     else:
+ *         return 0
+ */
+        __pyx_r = -1;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        goto __pyx_L13_return;
+      }
+
+      /* "httptools/parser/parser.pyx":337
+ *     try:
+ *         pyparser._proto_on_message_complete()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return -1
+ */
+      /*finally:*/ {
+        __pyx_L13_return: {
+          __pyx_t_7 = __pyx_r;
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          __pyx_r = __pyx_t_7;
+          goto __pyx_L6_except_return;
+        }
+      }
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "httptools/parser/parser.pyx":335
+ * cdef int cb_on_message_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._proto_on_message_complete()
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+  }
+
+  /* "httptools/parser/parser.pyx":333
+ * 
+ * 
+ * cdef int cb_on_message_complete(cparser.llhttp_t* parser) except -1:             # <<<<<<<<<<<<<<
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("httptools.parser.parser.cb_on_message_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pyparser);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":344
+ * 
+ * 
+ * cdef int cb_on_chunk_header(cparser.llhttp_t* parser) except -1:             # <<<<<<<<<<<<<<
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ */
+
+static int __pyx_f_9httptools_6parser_6parser_cb_on_chunk_header(llhttp_t *__pyx_v_parser) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_pyparser = 0;
+  PyObject *__pyx_v_ex = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cb_on_chunk_header", 0);
+
+  /* "httptools/parser/parser.pyx":345
+ * 
+ * cdef int cb_on_chunk_header(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data             # <<<<<<<<<<<<<<
+ *     try:
+ *         pyparser._on_chunk_header()
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_parser->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_pyparser = ((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":346
+ * cdef int cb_on_chunk_header(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_chunk_header()
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "httptools/parser/parser.pyx":347
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ *         pyparser._on_chunk_header()             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser *)__pyx_v_pyparser->__pyx_vtab)->_on_chunk_header(__pyx_v_pyparser); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "httptools/parser/parser.pyx":346
+ * cdef int cb_on_chunk_header(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_chunk_header()
+ *     except BaseException as ex:
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":352
+ *         return -1
+ *     else:
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    /*else:*/ {
+      __pyx_r = 0;
+      goto __pyx_L6_except_return;
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "httptools/parser/parser.pyx":348
+ *     try:
+ *         pyparser._on_chunk_header()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return -1
+ */
+    __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_5) {
+      __Pyx_AddTraceback("httptools.parser.parser.cb_on_chunk_header", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 348, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_v_ex = __pyx_t_6;
+      /*try:*/ {
+
+        /* "httptools/parser/parser.pyx":349
+ *         pyparser._on_chunk_header()
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex             # <<<<<<<<<<<<<<
+ *         return -1
+ *     else:
+ */
+        __Pyx_INCREF(__pyx_v_ex);
+        __Pyx_GIVEREF(__pyx_v_ex);
+        __Pyx_GOTREF(__pyx_v_pyparser->_last_error);
+        __Pyx_DECREF(__pyx_v_pyparser->_last_error);
+        __pyx_v_pyparser->_last_error = __pyx_v_ex;
+
+        /* "httptools/parser/parser.pyx":350
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex
+ *         return -1             # <<<<<<<<<<<<<<
+ *     else:
+ *         return 0
+ */
+        __pyx_r = -1;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L13_return;
+      }
+
+      /* "httptools/parser/parser.pyx":348
+ *     try:
+ *         pyparser._on_chunk_header()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return -1
+ */
+      /*finally:*/ {
+        __pyx_L13_return: {
+          __pyx_t_5 = __pyx_r;
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          __pyx_r = __pyx_t_5;
+          goto __pyx_L6_except_return;
+        }
+      }
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "httptools/parser/parser.pyx":346
+ * cdef int cb_on_chunk_header(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_chunk_header()
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+  }
+
+  /* "httptools/parser/parser.pyx":344
+ * 
+ * 
+ * cdef int cb_on_chunk_header(cparser.llhttp_t* parser) except -1:             # <<<<<<<<<<<<<<
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("httptools.parser.parser.cb_on_chunk_header", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pyparser);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":355
+ * 
+ * 
+ * cdef int cb_on_chunk_complete(cparser.llhttp_t* parser) except -1:             # <<<<<<<<<<<<<<
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ */
+
+static int __pyx_f_9httptools_6parser_6parser_cb_on_chunk_complete(llhttp_t *__pyx_v_parser) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *__pyx_v_pyparser = 0;
+  PyObject *__pyx_v_ex = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cb_on_chunk_complete", 0);
+
+  /* "httptools/parser/parser.pyx":356
+ * 
+ * cdef int cb_on_chunk_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data             # <<<<<<<<<<<<<<
+ *     try:
+ *         pyparser._on_chunk_complete()
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_parser->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_pyparser = ((struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":357
+ * cdef int cb_on_chunk_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_chunk_complete()
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "httptools/parser/parser.pyx":358
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ *         pyparser._on_chunk_complete()             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser *)__pyx_v_pyparser->__pyx_vtab)->_on_chunk_complete(__pyx_v_pyparser); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 358, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "httptools/parser/parser.pyx":357
+ * cdef int cb_on_chunk_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_chunk_complete()
+ *     except BaseException as ex:
+ */
+    }
+
+    /* "httptools/parser/parser.pyx":363
+ *         return -1
+ *     else:
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    /*else:*/ {
+      __pyx_r = 0;
+      goto __pyx_L6_except_return;
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "httptools/parser/parser.pyx":359
+ *     try:
+ *         pyparser._on_chunk_complete()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return -1
+ */
+    __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_5) {
+      __Pyx_AddTraceback("httptools.parser.parser.cb_on_chunk_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 359, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_v_ex = __pyx_t_6;
+      /*try:*/ {
+
+        /* "httptools/parser/parser.pyx":360
+ *         pyparser._on_chunk_complete()
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex             # <<<<<<<<<<<<<<
+ *         return -1
+ *     else:
+ */
+        __Pyx_INCREF(__pyx_v_ex);
+        __Pyx_GIVEREF(__pyx_v_ex);
+        __Pyx_GOTREF(__pyx_v_pyparser->_last_error);
+        __Pyx_DECREF(__pyx_v_pyparser->_last_error);
+        __pyx_v_pyparser->_last_error = __pyx_v_ex;
+
+        /* "httptools/parser/parser.pyx":361
+ *     except BaseException as ex:
+ *         pyparser._last_error = ex
+ *         return -1             # <<<<<<<<<<<<<<
+ *     else:
+ *         return 0
+ */
+        __pyx_r = -1;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L13_return;
+      }
+
+      /* "httptools/parser/parser.pyx":359
+ *     try:
+ *         pyparser._on_chunk_complete()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         pyparser._last_error = ex
+ *         return -1
+ */
+      /*finally:*/ {
+        __pyx_L13_return: {
+          __pyx_t_5 = __pyx_r;
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          __pyx_r = __pyx_t_5;
+          goto __pyx_L6_except_return;
+        }
+      }
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "httptools/parser/parser.pyx":357
+ * cdef int cb_on_chunk_complete(cparser.llhttp_t* parser) except -1:
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyparser._on_chunk_complete()
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+  }
+
+  /* "httptools/parser/parser.pyx":355
+ * 
+ * 
+ * cdef int cb_on_chunk_complete(cparser.llhttp_t* parser) except -1:             # <<<<<<<<<<<<<<
+ *     cdef HttpParser pyparser = <HttpParser>parser.data
+ *     try:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("httptools.parser.parser.cb_on_chunk_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pyparser);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/parser.pyx":366
+ * 
+ * 
+ * cdef parser_error_from_errno(cparser.llhttp_t* parser, cparser.llhttp_errno_t errno):             # <<<<<<<<<<<<<<
+ *     cdef bytes reason = cparser.llhttp_get_error_reason(parser)
+ * 
+ */
+
+static PyObject *__pyx_f_9httptools_6parser_6parser_parser_error_from_errno(llhttp_t *__pyx_v_parser, llhttp_errno_t __pyx_v_errno) {
+  PyObject *__pyx_v_reason = 0;
+  PyObject *__pyx_v_cls = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("parser_error_from_errno", 0);
+
+  /* "httptools/parser/parser.pyx":367
+ * 
+ * cdef parser_error_from_errno(cparser.llhttp_t* parser, cparser.llhttp_errno_t errno):
+ *     cdef bytes reason = cparser.llhttp_get_error_reason(parser)             # <<<<<<<<<<<<<<
+ * 
+ *     if errno in (cparser.HPE_CB_MESSAGE_BEGIN,
+ */
+  __pyx_t_1 = __Pyx_PyBytes_FromString(llhttp_get_error_reason(__pyx_v_parser)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 367, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_reason = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "httptools/parser/parser.pyx":369
+ *     cdef bytes reason = cparser.llhttp_get_error_reason(parser)
+ * 
+ *     if errno in (cparser.HPE_CB_MESSAGE_BEGIN,             # <<<<<<<<<<<<<<
+ *                  cparser.HPE_CB_HEADERS_COMPLETE,
+ *                  cparser.HPE_CB_MESSAGE_COMPLETE,
+ */
+  switch (__pyx_v_errno) {
+    case HPE_CB_MESSAGE_BEGIN:
+    case HPE_CB_HEADERS_COMPLETE:
+
+    /* "httptools/parser/parser.pyx":370
+ * 
+ *     if errno in (cparser.HPE_CB_MESSAGE_BEGIN,
+ *                  cparser.HPE_CB_HEADERS_COMPLETE,             # <<<<<<<<<<<<<<
+ *                  cparser.HPE_CB_MESSAGE_COMPLETE,
+ *                  cparser.HPE_CB_CHUNK_HEADER,
+ */
+    case HPE_CB_MESSAGE_COMPLETE:
+
+    /* "httptools/parser/parser.pyx":371
+ *     if errno in (cparser.HPE_CB_MESSAGE_BEGIN,
+ *                  cparser.HPE_CB_HEADERS_COMPLETE,
+ *                  cparser.HPE_CB_MESSAGE_COMPLETE,             # <<<<<<<<<<<<<<
+ *                  cparser.HPE_CB_CHUNK_HEADER,
+ *                  cparser.HPE_CB_CHUNK_COMPLETE,
+ */
+    case HPE_CB_CHUNK_HEADER:
+
+    /* "httptools/parser/parser.pyx":372
+ *                  cparser.HPE_CB_HEADERS_COMPLETE,
+ *                  cparser.HPE_CB_MESSAGE_COMPLETE,
+ *                  cparser.HPE_CB_CHUNK_HEADER,             # <<<<<<<<<<<<<<
+ *                  cparser.HPE_CB_CHUNK_COMPLETE,
+ *                  cparser.HPE_USER):
+ */
+    case HPE_CB_CHUNK_COMPLETE:
+
+    /* "httptools/parser/parser.pyx":373
+ *                  cparser.HPE_CB_MESSAGE_COMPLETE,
+ *                  cparser.HPE_CB_CHUNK_HEADER,
+ *                  cparser.HPE_CB_CHUNK_COMPLETE,             # <<<<<<<<<<<<<<
+ *                  cparser.HPE_USER):
+ *         cls = HttpParserCallbackError
+ */
+    case HPE_USER:
+
+    /* "httptools/parser/parser.pyx":375
+ *                  cparser.HPE_CB_CHUNK_COMPLETE,
+ *                  cparser.HPE_USER):
+ *         cls = HttpParserCallbackError             # <<<<<<<<<<<<<<
+ * 
+ *     elif errno == cparser.HPE_INVALID_STATUS:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_HttpParserCallbackError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 375, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_cls = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "httptools/parser/parser.pyx":369
+ *     cdef bytes reason = cparser.llhttp_get_error_reason(parser)
+ * 
+ *     if errno in (cparser.HPE_CB_MESSAGE_BEGIN,             # <<<<<<<<<<<<<<
+ *                  cparser.HPE_CB_HEADERS_COMPLETE,
+ *                  cparser.HPE_CB_MESSAGE_COMPLETE,
+ */
+    break;
+    case HPE_INVALID_STATUS:
+
+    /* "httptools/parser/parser.pyx":378
+ * 
+ *     elif errno == cparser.HPE_INVALID_STATUS:
+ *         cls = HttpParserInvalidStatusError             # <<<<<<<<<<<<<<
+ * 
+ *     elif errno == cparser.HPE_INVALID_METHOD:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_HttpParserInvalidStatusError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 378, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_cls = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "httptools/parser/parser.pyx":377
+ *         cls = HttpParserCallbackError
+ * 
+ *     elif errno == cparser.HPE_INVALID_STATUS:             # <<<<<<<<<<<<<<
+ *         cls = HttpParserInvalidStatusError
+ * 
+ */
+    break;
+    case HPE_INVALID_METHOD:
+
+    /* "httptools/parser/parser.pyx":381
+ * 
+ *     elif errno == cparser.HPE_INVALID_METHOD:
+ *         cls = HttpParserInvalidMethodError             # <<<<<<<<<<<<<<
+ * 
+ *     elif errno == cparser.HPE_INVALID_URL:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_HttpParserInvalidMethodError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 381, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_cls = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "httptools/parser/parser.pyx":380
+ *         cls = HttpParserInvalidStatusError
+ * 
+ *     elif errno == cparser.HPE_INVALID_METHOD:             # <<<<<<<<<<<<<<
+ *         cls = HttpParserInvalidMethodError
+ * 
+ */
+    break;
+    case HPE_INVALID_URL:
+
+    /* "httptools/parser/parser.pyx":384
+ * 
+ *     elif errno == cparser.HPE_INVALID_URL:
+ *         cls = HttpParserInvalidURLError             # <<<<<<<<<<<<<<
+ * 
+ *     else:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_HttpParserInvalidURLError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 384, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_cls = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "httptools/parser/parser.pyx":383
+ *         cls = HttpParserInvalidMethodError
+ * 
+ *     elif errno == cparser.HPE_INVALID_URL:             # <<<<<<<<<<<<<<
+ *         cls = HttpParserInvalidURLError
+ * 
+ */
+    break;
+    default:
+
+    /* "httptools/parser/parser.pyx":387
+ * 
+ *     else:
+ *         cls = HttpParserError             # <<<<<<<<<<<<<<
+ * 
+ *     return cls(reason.decode('latin-1'))
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_HttpParserError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 387, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_cls = __pyx_t_1;
+    __pyx_t_1 = 0;
+    break;
+  }
+
+  /* "httptools/parser/parser.pyx":389
+ *         cls = HttpParserError
+ * 
+ *     return cls(reason.decode('latin-1'))             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_decode_bytes(__pyx_v_reason, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 389, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_cls);
+  __pyx_t_3 = __pyx_v_cls; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 389, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "httptools/parser/parser.pyx":366
+ * 
+ * 
+ * cdef parser_error_from_errno(cparser.llhttp_t* parser, cparser.llhttp_errno_t errno):             # <<<<<<<<<<<<<<
+ *     cdef bytes reason = cparser.llhttp_get_error_reason(parser)
+ * 
+ */
+
+  /* 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_AddTraceback("httptools.parser.parser.parser_error_from_errno", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_reason);
+  __Pyx_XDECREF(__pyx_v_cls);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser __pyx_vtable_9httptools_6parser_6parser_HttpParser;
+
+static PyObject *__pyx_tp_new_9httptools_6parser_6parser_HttpParser(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *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_9httptools_6parser_6parser_HttpParser *)o);
+  p->__pyx_vtab = __pyx_vtabptr_9httptools_6parser_6parser_HttpParser;
+  p->_current_header_name = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_current_header_value = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_proto_on_url = Py_None; Py_INCREF(Py_None);
+  p->_proto_on_status = Py_None; Py_INCREF(Py_None);
+  p->_proto_on_body = Py_None; Py_INCREF(Py_None);
+  p->_proto_on_header = Py_None; Py_INCREF(Py_None);
+  p->_proto_on_headers_complete = Py_None; Py_INCREF(Py_None);
+  p->_proto_on_message_complete = Py_None; Py_INCREF(Py_None);
+  p->_proto_on_chunk_header = Py_None; Py_INCREF(Py_None);
+  p->_proto_on_chunk_complete = Py_None; Py_INCREF(Py_None);
+  p->_proto_on_message_begin = Py_None; Py_INCREF(Py_None);
+  p->_last_error = Py_None; Py_INCREF(Py_None);
+  p->py_buf.obj = NULL;
+  if (unlikely(__pyx_pw_9httptools_6parser_6parser_10HttpParser_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_9httptools_6parser_6parser_HttpParser(PyObject *o) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *p = (struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)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_9httptools_6parser_6parser_10HttpParser_3__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->_current_header_name);
+  Py_CLEAR(p->_current_header_value);
+  Py_CLEAR(p->_proto_on_url);
+  Py_CLEAR(p->_proto_on_status);
+  Py_CLEAR(p->_proto_on_body);
+  Py_CLEAR(p->_proto_on_header);
+  Py_CLEAR(p->_proto_on_headers_complete);
+  Py_CLEAR(p->_proto_on_message_complete);
+  Py_CLEAR(p->_proto_on_chunk_header);
+  Py_CLEAR(p->_proto_on_chunk_complete);
+  Py_CLEAR(p->_proto_on_message_begin);
+  Py_CLEAR(p->_last_error);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_tp_traverse_9httptools_6parser_6parser_HttpParser(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *p = (struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)o;
+  if (p->_proto_on_url) {
+    e = (*v)(p->_proto_on_url, a); if (e) return e;
+  }
+  if (p->_proto_on_status) {
+    e = (*v)(p->_proto_on_status, a); if (e) return e;
+  }
+  if (p->_proto_on_body) {
+    e = (*v)(p->_proto_on_body, a); if (e) return e;
+  }
+  if (p->_proto_on_header) {
+    e = (*v)(p->_proto_on_header, a); if (e) return e;
+  }
+  if (p->_proto_on_headers_complete) {
+    e = (*v)(p->_proto_on_headers_complete, a); if (e) return e;
+  }
+  if (p->_proto_on_message_complete) {
+    e = (*v)(p->_proto_on_message_complete, a); if (e) return e;
+  }
+  if (p->_proto_on_chunk_header) {
+    e = (*v)(p->_proto_on_chunk_header, a); if (e) return e;
+  }
+  if (p->_proto_on_chunk_complete) {
+    e = (*v)(p->_proto_on_chunk_complete, a); if (e) return e;
+  }
+  if (p->_proto_on_message_begin) {
+    e = (*v)(p->_proto_on_message_begin, a); if (e) return e;
+  }
+  if (p->_last_error) {
+    e = (*v)(p->_last_error, a); if (e) return e;
+  }
+  if (p->py_buf.obj) {
+    e = (*v)(p->py_buf.obj, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_9httptools_6parser_6parser_HttpParser(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_9httptools_6parser_6parser_HttpParser *p = (struct __pyx_obj_9httptools_6parser_6parser_HttpParser *)o;
+  tmp = ((PyObject*)p->_proto_on_url);
+  p->_proto_on_url = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_proto_on_status);
+  p->_proto_on_status = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_proto_on_body);
+  p->_proto_on_body = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_proto_on_header);
+  p->_proto_on_header = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_proto_on_headers_complete);
+  p->_proto_on_headers_complete = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_proto_on_message_complete);
+  p->_proto_on_message_complete = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_proto_on_chunk_header);
+  p->_proto_on_chunk_header = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_proto_on_chunk_complete);
+  p->_proto_on_chunk_complete = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_proto_on_message_begin);
+  p->_proto_on_message_begin = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_last_error);
+  p->_last_error = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  Py_CLEAR(p->py_buf.obj);
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_9httptools_6parser_6parser_HttpParser[] = {
+  {"get_http_version", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_10HttpParser_5get_http_version, METH_NOARGS, 0},
+  {"should_keep_alive", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_10HttpParser_7should_keep_alive, METH_NOARGS, 0},
+  {"should_upgrade", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_10HttpParser_9should_upgrade, METH_NOARGS, 0},
+  {"feed_data", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_10HttpParser_11feed_data, METH_O, 0},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_10HttpParser_13__reduce_cython__, METH_NOARGS, 0},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_10HttpParser_15__setstate_cython__, METH_O, 0},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9httptools_6parser_6parser_HttpParser = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "httptools.parser.parser.HttpParser", /*tp_name*/
+  sizeof(struct __pyx_obj_9httptools_6parser_6parser_HttpParser), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_9httptools_6parser_6parser_HttpParser, /*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_9httptools_6parser_6parser_HttpParser, /*tp_traverse*/
+  __pyx_tp_clear_9httptools_6parser_6parser_HttpParser, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_9httptools_6parser_6parser_HttpParser, /*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_9httptools_6parser_6parser_HttpParser, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpRequestParser __pyx_vtable_9httptools_6parser_6parser_HttpRequestParser;
+
+static PyObject *__pyx_tp_new_9httptools_6parser_6parser_HttpRequestParser(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *p;
+  PyObject *o = __pyx_tp_new_9httptools_6parser_6parser_HttpParser(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser*)__pyx_vtabptr_9httptools_6parser_6parser_HttpRequestParser;
+  return o;
+}
+
+static PyMethodDef __pyx_methods_9httptools_6parser_6parser_HttpRequestParser[] = {
+  {"get_method", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_17HttpRequestParser_3get_method, METH_NOARGS, 0},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_17HttpRequestParser_5__reduce_cython__, METH_NOARGS, 0},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_17HttpRequestParser_7__setstate_cython__, METH_O, 0},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9httptools_6parser_6parser_HttpRequestParser = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "httptools.parser.parser.HttpRequestParser", /*tp_name*/
+  sizeof(struct __pyx_obj_9httptools_6parser_6parser_HttpRequestParser), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_9httptools_6parser_6parser_HttpParser, /*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_9httptools_6parser_6parser_HttpParser, /*tp_traverse*/
+  __pyx_tp_clear_9httptools_6parser_6parser_HttpParser, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_9httptools_6parser_6parser_HttpRequestParser, /*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*/
+  __pyx_pw_9httptools_6parser_6parser_17HttpRequestParser_1__init__, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_9httptools_6parser_6parser_HttpRequestParser, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpResponseParser __pyx_vtable_9httptools_6parser_6parser_HttpResponseParser;
+
+static PyObject *__pyx_tp_new_9httptools_6parser_6parser_HttpResponseParser(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *p;
+  PyObject *o = __pyx_tp_new_9httptools_6parser_6parser_HttpParser(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9httptools_6parser_6parser_HttpParser*)__pyx_vtabptr_9httptools_6parser_6parser_HttpResponseParser;
+  return o;
+}
+
+static PyMethodDef __pyx_methods_9httptools_6parser_6parser_HttpResponseParser[] = {
+  {"get_status_code", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_18HttpResponseParser_3get_status_code, METH_NOARGS, 0},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_18HttpResponseParser_5__reduce_cython__, METH_NOARGS, 0},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_9httptools_6parser_6parser_18HttpResponseParser_7__setstate_cython__, METH_O, 0},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9httptools_6parser_6parser_HttpResponseParser = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "httptools.parser.parser.HttpResponseParser", /*tp_name*/
+  sizeof(struct __pyx_obj_9httptools_6parser_6parser_HttpResponseParser), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_9httptools_6parser_6parser_HttpParser, /*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_9httptools_6parser_6parser_HttpParser, /*tp_traverse*/
+  __pyx_tp_clear_9httptools_6parser_6parser_HttpParser, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_9httptools_6parser_6parser_HttpResponseParser, /*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*/
+  __pyx_pw_9httptools_6parser_6parser_18HttpResponseParser_1__init__, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_9httptools_6parser_6parser_HttpResponseParser, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #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_parser(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_parser},
+  {0, NULL}
+};
+#endif
+
+static struct PyModuleDef __pyx_moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "parser",
+    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
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+    #define CYTHON_SMALL_CODE __attribute__((cold))
+#else
+    #define CYTHON_SMALL_CODE
+#endif
+#endif
+
+static __Pyx_StringTabEntry __pyx_string_tab[] = {
+  {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0},
+  {&__pyx_n_s_BaseException, __pyx_k_BaseException, sizeof(__pyx_k_BaseException), 0, 0, 1, 1},
+  {&__pyx_n_s_HttpParserCallbackError, __pyx_k_HttpParserCallbackError, sizeof(__pyx_k_HttpParserCallbackError), 0, 0, 1, 1},
+  {&__pyx_n_s_HttpParserError, __pyx_k_HttpParserError, sizeof(__pyx_k_HttpParserError), 0, 0, 1, 1},
+  {&__pyx_n_s_HttpParserInvalidMethodError, __pyx_k_HttpParserInvalidMethodError, sizeof(__pyx_k_HttpParserInvalidMethodError), 0, 0, 1, 1},
+  {&__pyx_n_s_HttpParserInvalidStatusError, __pyx_k_HttpParserInvalidStatusError, sizeof(__pyx_k_HttpParserInvalidStatusError), 0, 0, 1, 1},
+  {&__pyx_n_s_HttpParserInvalidURLError, __pyx_k_HttpParserInvalidURLError, sizeof(__pyx_k_HttpParserInvalidURLError), 0, 0, 1, 1},
+  {&__pyx_n_s_HttpParserUpgrade, __pyx_k_HttpParserUpgrade, sizeof(__pyx_k_HttpParserUpgrade), 0, 0, 1, 1},
+  {&__pyx_n_s_HttpRequestParser, __pyx_k_HttpRequestParser, sizeof(__pyx_k_HttpRequestParser), 0, 0, 1, 1},
+  {&__pyx_n_u_HttpRequestParser, __pyx_k_HttpRequestParser, sizeof(__pyx_k_HttpRequestParser), 0, 1, 0, 1},
+  {&__pyx_n_s_HttpResponseParser, __pyx_k_HttpResponseParser, sizeof(__pyx_k_HttpResponseParser), 0, 0, 1, 1},
+  {&__pyx_n_u_HttpResponseParser, __pyx_k_HttpResponseParser, sizeof(__pyx_k_HttpResponseParser), 0, 1, 0, 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_all, __pyx_k_all, sizeof(__pyx_k_all), 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_context, __pyx_k_context, sizeof(__pyx_k_context), 0, 0, 1, 1},
+  {&__pyx_n_s_errors, __pyx_k_errors, sizeof(__pyx_k_errors), 0, 0, 1, 1},
+  {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 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_kp_u_invalid_headers_state, __pyx_k_invalid_headers_state, sizeof(__pyx_k_invalid_headers_state), 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_u_on_body, __pyx_k_on_body, sizeof(__pyx_k_on_body), 0, 1, 0, 1},
+  {&__pyx_n_u_on_chunk_complete, __pyx_k_on_chunk_complete, sizeof(__pyx_k_on_chunk_complete), 0, 1, 0, 1},
+  {&__pyx_n_u_on_chunk_header, __pyx_k_on_chunk_header, sizeof(__pyx_k_on_chunk_header), 0, 1, 0, 1},
+  {&__pyx_n_u_on_header, __pyx_k_on_header, sizeof(__pyx_k_on_header), 0, 1, 0, 1},
+  {&__pyx_n_u_on_headers_complete, __pyx_k_on_headers_complete, sizeof(__pyx_k_on_headers_complete), 0, 1, 0, 1},
+  {&__pyx_n_u_on_message_begin, __pyx_k_on_message_begin, sizeof(__pyx_k_on_message_begin), 0, 1, 0, 1},
+  {&__pyx_n_u_on_message_complete, __pyx_k_on_message_complete, sizeof(__pyx_k_on_message_complete), 0, 1, 0, 1},
+  {&__pyx_n_u_on_status, __pyx_k_on_status, sizeof(__pyx_k_on_status), 0, 1, 0, 1},
+  {&__pyx_n_u_on_url, __pyx_k_on_url, sizeof(__pyx_k_on_url), 0, 1, 0, 1},
+  {&__pyx_n_s_protocol, __pyx_k_protocol, sizeof(__pyx_k_protocol), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 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_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+  {0, 0, 0, 0, 0, 0, 0}
+};
+static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
+  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 48, __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_BaseException = __Pyx_GetBuiltinName(__pyx_n_s_BaseException); if (!__pyx_builtin_BaseException) __PYX_ERR(0, 247, __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__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__")             # <<<<<<<<<<<<<<
+ */
+  __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_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+
+  /* "(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__4 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
+
+  /* "(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__5 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+
+  /* "(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__6 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+
+  /* "(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(1, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+
+  /* "httptools/parser/parser.pyx":22
+ * 
+ * 
+ * __all__ = ('HttpRequestParser', 'HttpResponseParser')             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_tuple__8 = PyTuple_Pack(2, __pyx_n_u_HttpRequestParser, __pyx_n_u_HttpResponseParser); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__8);
+  __Pyx_GIVEREF(__pyx_tuple__8);
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __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);
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+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 ---*/
+  __pyx_vtabptr_9httptools_6parser_6parser_HttpParser = &__pyx_vtable_9httptools_6parser_6parser_HttpParser;
+  __pyx_vtable_9httptools_6parser_6parser_HttpParser._init = (PyObject *(*)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *, PyObject *, llhttp_type_t))__pyx_f_9httptools_6parser_6parser_10HttpParser__init;
+  __pyx_vtable_9httptools_6parser_6parser_HttpParser._maybe_call_on_header = (PyObject *(*)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *))__pyx_f_9httptools_6parser_6parser_10HttpParser__maybe_call_on_header;
+  __pyx_vtable_9httptools_6parser_6parser_HttpParser._on_header_field = (PyObject *(*)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *, PyObject *))__pyx_f_9httptools_6parser_6parser_10HttpParser__on_header_field;
+  __pyx_vtable_9httptools_6parser_6parser_HttpParser._on_header_value = (PyObject *(*)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *, PyObject *))__pyx_f_9httptools_6parser_6parser_10HttpParser__on_header_value;
+  __pyx_vtable_9httptools_6parser_6parser_HttpParser._on_headers_complete = (PyObject *(*)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *))__pyx_f_9httptools_6parser_6parser_10HttpParser__on_headers_complete;
+  __pyx_vtable_9httptools_6parser_6parser_HttpParser._on_chunk_header = (PyObject *(*)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *))__pyx_f_9httptools_6parser_6parser_10HttpParser__on_chunk_header;
+  __pyx_vtable_9httptools_6parser_6parser_HttpParser._on_chunk_complete = (PyObject *(*)(struct __pyx_obj_9httptools_6parser_6parser_HttpParser *))__pyx_f_9httptools_6parser_6parser_10HttpParser__on_chunk_complete;
+  if (PyType_Ready(&__pyx_type_9httptools_6parser_6parser_HttpParser) < 0) __PYX_ERR(0, 26, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_9httptools_6parser_6parser_HttpParser.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9httptools_6parser_6parser_HttpParser.tp_dictoffset && __pyx_type_9httptools_6parser_6parser_HttpParser.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_9httptools_6parser_6parser_HttpParser.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_9httptools_6parser_6parser_HttpParser.tp_dict, __pyx_vtabptr_9httptools_6parser_6parser_HttpParser) < 0) __PYX_ERR(0, 26, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9httptools_6parser_6parser_HttpParser) < 0) __PYX_ERR(0, 26, __pyx_L1_error)
+  __pyx_ptype_9httptools_6parser_6parser_HttpParser = &__pyx_type_9httptools_6parser_6parser_HttpParser;
+  __pyx_vtabptr_9httptools_6parser_6parser_HttpRequestParser = &__pyx_vtable_9httptools_6parser_6parser_HttpRequestParser;
+  __pyx_vtable_9httptools_6parser_6parser_HttpRequestParser.__pyx_base = *__pyx_vtabptr_9httptools_6parser_6parser_HttpParser;
+  __pyx_type_9httptools_6parser_6parser_HttpRequestParser.tp_base = __pyx_ptype_9httptools_6parser_6parser_HttpParser;
+  if (PyType_Ready(&__pyx_type_9httptools_6parser_6parser_HttpRequestParser) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_9httptools_6parser_6parser_HttpRequestParser.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9httptools_6parser_6parser_HttpRequestParser.tp_dictoffset && __pyx_type_9httptools_6parser_6parser_HttpRequestParser.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_9httptools_6parser_6parser_HttpRequestParser.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_9httptools_6parser_6parser_HttpRequestParser.tp_dict, __pyx_vtabptr_9httptools_6parser_6parser_HttpRequestParser) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_HttpRequestParser, (PyObject *)&__pyx_type_9httptools_6parser_6parser_HttpRequestParser) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9httptools_6parser_6parser_HttpRequestParser) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
+  __pyx_ptype_9httptools_6parser_6parser_HttpRequestParser = &__pyx_type_9httptools_6parser_6parser_HttpRequestParser;
+  __pyx_vtabptr_9httptools_6parser_6parser_HttpResponseParser = &__pyx_vtable_9httptools_6parser_6parser_HttpResponseParser;
+  __pyx_vtable_9httptools_6parser_6parser_HttpResponseParser.__pyx_base = *__pyx_vtabptr_9httptools_6parser_6parser_HttpParser;
+  __pyx_type_9httptools_6parser_6parser_HttpResponseParser.tp_base = __pyx_ptype_9httptools_6parser_6parser_HttpParser;
+  if (PyType_Ready(&__pyx_type_9httptools_6parser_6parser_HttpResponseParser) < 0) __PYX_ERR(0, 229, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_9httptools_6parser_6parser_HttpResponseParser.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9httptools_6parser_6parser_HttpResponseParser.tp_dictoffset && __pyx_type_9httptools_6parser_6parser_HttpResponseParser.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_9httptools_6parser_6parser_HttpResponseParser.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_9httptools_6parser_6parser_HttpResponseParser.tp_dict, __pyx_vtabptr_9httptools_6parser_6parser_HttpResponseParser) < 0) __PYX_ERR(0, 229, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_HttpResponseParser, (PyObject *)&__pyx_type_9httptools_6parser_6parser_HttpResponseParser) < 0) __PYX_ERR(0, 229, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9httptools_6parser_6parser_HttpResponseParser) < 0) __PYX_ERR(0, 229, __pyx_L1_error)
+  __pyx_ptype_9httptools_6parser_6parser_HttpResponseParser = &__pyx_type_9httptools_6parser_6parser_HttpResponseParser;
+  __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(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_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
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
+  /*--- Function import code ---*/
+  __Pyx_RefNannyFinishContext();
+  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
+#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 initparser(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC initparser(void)
+#else
+__Pyx_PyMODINIT_FUNC PyInit_parser(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC PyInit_parser(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;
+}
+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);
+        }
+        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, 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;
+}
+
+
+static CYTHON_SMALL_CODE int __pyx_pymod_exec_parser(PyObject *__pyx_pyinit_module)
+#endif
+#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 'parser' 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");
+}
+#endif
+  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_parser(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("parser", __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_httptools__parser__parser) {
+    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, "httptools.parser.parser")) {
+      if (unlikely(PyDict_SetItemString(modules, "httptools.parser.parser", __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();
+  (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_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  (void)__Pyx_modinit_variable_import_code();
+  (void)__Pyx_modinit_function_import_code();
+  /*--- Execution code ---*/
+  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+
+  /* "httptools/parser/parser.pyx":11
+ * 
+ * 
+ * from .errors import (HttpParserError,             # <<<<<<<<<<<<<<
+ *                      HttpParserCallbackError,
+ *                      HttpParserInvalidStatusError,
+ */
+  __pyx_t_1 = PyList_New(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_n_s_HttpParserError);
+  __Pyx_GIVEREF(__pyx_n_s_HttpParserError);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_HttpParserError);
+  __Pyx_INCREF(__pyx_n_s_HttpParserCallbackError);
+  __Pyx_GIVEREF(__pyx_n_s_HttpParserCallbackError);
+  PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_HttpParserCallbackError);
+  __Pyx_INCREF(__pyx_n_s_HttpParserInvalidStatusError);
+  __Pyx_GIVEREF(__pyx_n_s_HttpParserInvalidStatusError);
+  PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_HttpParserInvalidStatusError);
+  __Pyx_INCREF(__pyx_n_s_HttpParserInvalidMethodError);
+  __Pyx_GIVEREF(__pyx_n_s_HttpParserInvalidMethodError);
+  PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_HttpParserInvalidMethodError);
+  __Pyx_INCREF(__pyx_n_s_HttpParserInvalidURLError);
+  __Pyx_GIVEREF(__pyx_n_s_HttpParserInvalidURLError);
+  PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_HttpParserInvalidURLError);
+  __Pyx_INCREF(__pyx_n_s_HttpParserUpgrade);
+  __Pyx_GIVEREF(__pyx_n_s_HttpParserUpgrade);
+  PyList_SET_ITEM(__pyx_t_1, 5, __pyx_n_s_HttpParserUpgrade);
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_errors, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 11, __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_HttpParserError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HttpParserError, __pyx_t_1) < 0) __PYX_ERR(0, 11, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_HttpParserCallbackError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HttpParserCallbackError, __pyx_t_1) < 0) __PYX_ERR(0, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_HttpParserInvalidStatusError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HttpParserInvalidStatusError, __pyx_t_1) < 0) __PYX_ERR(0, 13, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_HttpParserInvalidMethodError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HttpParserInvalidMethodError, __pyx_t_1) < 0) __PYX_ERR(0, 14, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_HttpParserInvalidURLError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HttpParserInvalidURLError, __pyx_t_1) < 0) __PYX_ERR(0, 15, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_HttpParserUpgrade); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HttpParserUpgrade, __pyx_t_1) < 0) __PYX_ERR(0, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "httptools/parser/parser.pyx":22
+ * 
+ * 
+ * __all__ = ('HttpRequestParser', 'HttpResponseParser')             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_tuple__8) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
+
+  /* "httptools/parser/parser.pyx":1
+ * #cython: language_level=3             # <<<<<<<<<<<<<<
+ * 
+ * from __future__ import print_function
+ */
+  __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) {
+      __Pyx_AddTraceback("init httptools.parser.parser", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    Py_CLEAR(__pyx_m);
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init httptools.parser.parser");
+  }
+  __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
+}
+
+/* --- 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
+
+/* 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)) {
+        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;
+}
+
+/* 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);
+}
+
+/* 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 ((!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;
+}
+
+/* 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
+
+/* 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
+
+/* GetAttr */
+static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) {
+#if CYTHON_USE_TYPE_SLOTS
+#if PY_MAJOR_VERSION >= 3
+    if (likely(PyUnicode_Check(n)))
+#else
+    if (likely(PyString_Check(n)))
+#endif
+        return __Pyx_PyObject_GetAttrStr(o, n);
+#endif
+    return PyObject_GetAttr(o, n);
+}
+
+/* GetAttr3 */
+static PyObject *__Pyx_GetAttr3Default(PyObject *d) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        return NULL;
+    __Pyx_PyErr_Clear();
+    Py_INCREF(d);
+    return d;
+}
+static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) {
+    PyObject *r = __Pyx_GetAttr(o, n);
+    return (likely(r)) ? r : __Pyx_GetAttr3Default(d);
+}
+
+/* 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;
+    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;
+}
+#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);
+    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_EnterRecursiveCall((char*)" while calling a Python object")) {
+        return NULL;
+    }
+    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
+#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);
+    }
+}
+#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");
+    }
+    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 = PyCFunction_GET_FUNCTION(func);
+    self = PyCFunction_GET_SELF(func);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    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
+
+/* 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
+
+/* 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);
+    }
+#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
+        }
+    }
+    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
+
+/* PyDictVersioning */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
+    PyObject **dictptr = NULL;
+    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
+    if (offset) {
+#if CYTHON_COMPILING_IN_CPYTHON
+        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
+#else
+        dictptr = _PyObject_GetDictPtr(obj);
+#endif
+    }
+    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
+}
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
+        return 0;
+    return obj_dict_version == __Pyx_get_object_dict_version(obj);
+}
+#endif
+
+/* GetModuleGlobalName */
+#if CYTHON_USE_DICT_VERSIONS
+static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
+#else
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
+#endif
+{
+    PyObject *result;
+#if !CYTHON_AVOID_BORROWED_REFS
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
+    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)) {
+        return __Pyx_NewRef(result);
+    } else if (unlikely(PyErr_Occurred())) {
+        return NULL;
+    }
+#else
+    result = PyDict_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+#endif
+#else
+    result = PyObject_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+    PyErr_Clear();
+#endif
+    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;
+}
+
+/* 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;
+        }
+    }
+    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 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
+        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);
+        }
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#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, *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);
+#endif
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if 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;
+        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);
+#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
+    _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
+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) &&
+           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
+    _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 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;
+    #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
+
+/* PyObjectSetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_setattro))
+        return tp->tp_setattro(obj, attr_name, value);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_setattr))
+        return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value);
+#endif
+    return PyObject_SetAttr(obj, attr_name, value);
+}
+#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 **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++;
+                }
+            }
+        } 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++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    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;
+}
+
+/* decode_c_bytes */
+static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes(
+         const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
+    if (unlikely((start < 0) | (stop < 0))) {
+        if (start < 0) {
+            start += length;
+            if (start < 0)
+                start = 0;
+        }
+        if (stop < 0)
+            stop += length;
+    }
+    if (stop > length)
+        stop = length;
+    if (unlikely(stop <= start))
+        return __Pyx_NewRef(__pyx_empty_unicode);
+    length = stop - start;
+    cstring += start;
+    if (decode_func) {
+        return decode_func(cstring, length, errors);
+    } else {
+        return PyUnicode_Decode(cstring, length, encoding, errors);
+    }
+}
+
+/* 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);
+    }
+    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
+
+/* SetVTable */
+static int __Pyx_SetVtable(PyObject *dict, void *vtable) {
+#if PY_VERSION_HEX >= 0x02070000
+    PyObject *ob = PyCapsule_New(vtable, 0, 0);
+#else
+    PyObject *ob = PyCObject_FromVoidPtr(vtable, 0);
+#endif
+    if (!ob)
+        goto bad;
+    if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0)
+        goto bad;
+    Py_DECREF(ob);
+    return 0;
+bad:
+    Py_XDECREF(ob);
+    return -1;
+}
+
+/* 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 */
+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 int __Pyx_setup_reduce(PyObject* type_obj) {
+    int ret = 0;
+    PyObject *object_reduce = NULL;
+    PyObject *object_reduce_ex = NULL;
+    PyObject *reduce = NULL;
+    PyObject *reduce_ex = NULL;
+    PyObject *reduce_cython = NULL;
+    PyObject *setstate = NULL;
+    PyObject *setstate_cython = NULL;
+#if CYTHON_USE_PYTYPE_LOOKUP
+    if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
+#else
+    if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
+#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;
+#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_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);
+#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;
+#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;
+#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;
+    }
+    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;
+    }
+    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 (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
+}
+#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;
+    }
+    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
+        }
+    }
+bad:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(py_import);
+    #endif
+    Py_XDECREF(empty_list);
+    Py_XDECREF(empty_dict);
+    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)) {
+        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;
+}
+
+/* CLineInTraceback */
+#ifndef CYTHON_CLINE_IN_TRACEBACK
+static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+    PyObject *use_cline;
+    PyObject *ptype, *pvalue, *ptraceback;
+#if CYTHON_COMPILING_IN_CPYTHON
+    PyObject **cython_runtime_dict;
+#endif
+    if (unlikely(!__pyx_cython_runtime)) {
+        return c_line;
+    }
+    __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
+#if CYTHON_COMPILING_IN_CPYTHON
+    cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
+    if (likely(cython_runtime_dict)) {
+        __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
+            use_cline, *cython_runtime_dict,
+            __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback))
+    } else
+#endif
+    {
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__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);
+      } else {
+        PyErr_Clear();
+        use_cline = NULL;
+      }
+    }
+    if (!use_cline) {
+        c_line = 0;
+        PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False);
+    }
+    else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
+        c_line = 0;
+    }
+    __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
+    return c_line;
+}
+#endif
+
+/* CodeObjectCache */
+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) {
+        return count;
+    }
+    while (start < end) {
+        mid = start + (end - start) / 2;
+        if (code_line < entries[mid].code_line) {
+            end = mid;
+        } else if (code_line > entries[mid].code_line) {
+             start = mid + 1;
+        } else {
+            return mid;
+        }
+    }
+    if (code_line <= entries[mid].code_line) {
+        return mid;
+    } else {
+        return mid + 1;
+    }
+}
+static PyCodeObject *__pyx_find_code_object(int code_line) {
+    PyCodeObject* code_object;
+    int pos;
+    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
+        return NULL;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
+        return NULL;
+    }
+    code_object = __pyx_code_cache.entries[pos].code_object;
+    Py_INCREF(code_object);
+    return code_object;
+}
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
+    int pos, i;
+    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    if (unlikely(!code_line)) {
+        return;
+    }
+    if (unlikely(!entries)) {
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (likely(entries)) {
+            __pyx_code_cache.entries = entries;
+            __pyx_code_cache.max_count = 64;
+            __pyx_code_cache.count = 1;
+            entries[0].code_line = code_line;
+            entries[0].code_object = code_object;
+            Py_INCREF(code_object);
+        }
+        return;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
+        PyCodeObject* tmp = entries[pos].code_object;
+        entries[pos].code_object = code_object;
+        Py_DECREF(tmp);
+        return;
+    }
+    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
+        int new_max = __pyx_code_cache.max_count + 64;
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
+            __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));
+        if (unlikely(!entries)) {
+            return;
+        }
+        __pyx_code_cache.entries = entries;
+        __pyx_code_cache.max_count = new_max;
+    }
+    for (i=__pyx_code_cache.count; i>pos; i--) {
+        entries[i] = entries[i-1];
+    }
+    entries[pos].code_line = code_line;
+    entries[pos].code_object = code_object;
+    __pyx_code_cache.count++;
+    Py_INCREF(code_object);
+}
+
+/* AddTraceback */
+#include "compile.h"
+#include "frameobject.h"
+#include "traceback.h"
+static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
+            const char *funcname, int c_line,
+            int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyObject *py_srcfile = 0;
+    PyObject *py_funcname = 0;
+    #if PY_MAJOR_VERSION < 3
+    py_srcfile = PyString_FromString(filename);
+    #else
+    py_srcfile = PyUnicode_FromString(filename);
+    #endif
+    if (!py_srcfile) goto bad;
+    if (c_line) {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #else
+        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #endif
+    }
+    else {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromString(funcname);
+        #else
+        py_funcname = PyUnicode_FromString(funcname);
+        #endif
+    }
+    if (!py_funcname) goto bad;
+    py_code = __Pyx_PyCode_New(
+        0,
+        0,
+        0,
+        0,
+        0,
+        __pyx_empty_bytes, /*PyObject *code,*/
+        __pyx_empty_tuple, /*PyObject *consts,*/
+        __pyx_empty_tuple, /*PyObject *names,*/
+        __pyx_empty_tuple, /*PyObject *varnames,*/
+        __pyx_empty_tuple, /*PyObject *freevars,*/
+        __pyx_empty_tuple, /*PyObject *cellvars,*/
+        py_srcfile,   /*PyObject *filename,*/
+        py_funcname,  /*PyObject *name,*/
+        py_line,
+        __pyx_empty_bytes  /*PyObject *lnotab*/
+    );
+    Py_DECREF(py_srcfile);
+    Py_DECREF(py_funcname);
+    return py_code;
+bad:
+    Py_XDECREF(py_srcfile);
+    Py_XDECREF(py_funcname);
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyFrameObject *py_frame = 0;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    if (c_line) {
+        c_line = __Pyx_CLineForTraceback(tstate, c_line);
+    }
+    py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
+    if (!py_code) {
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, c_line, py_line, filename);
+        if (!py_code) goto bad;
+        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
+    }
+    py_frame = PyFrame_New(
+        tstate,            /*PyThreadState *tstate,*/
+        py_code,           /*PyCodeObject *code,*/
+        __pyx_d,    /*PyObject *globals,*/
+        0                  /*PyObject *locals*/
+    );
+    if (!py_frame) goto bad;
+    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
+    PyTraceBack_Here(py_frame);
+bad:
+    Py_XDECREF(py_code);
+    Py_XDECREF(py_frame);
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint8_t(uint8_t value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const uint8_t neg_one = (uint8_t) -1, const_zero = (uint8_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(uint8_t) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(uint8_t) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(uint8_t) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(uint8_t) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(uint8_t) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(uint8_t),
+                                     little, !is_unsigned);
+    }
+}
+
+/* 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
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_ptrdiff_t(ptrdiff_t value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const ptrdiff_t neg_one = (ptrdiff_t) -1, const_zero = (ptrdiff_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(ptrdiff_t) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(ptrdiff_t) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(ptrdiff_t) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(ptrdiff_t) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(ptrdiff_t) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(ptrdiff_t),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint16_t(uint16_t value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const uint16_t neg_one = (uint16_t) -1, const_zero = (uint16_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(uint16_t) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(uint16_t) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(uint16_t) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(uint16_t) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(uint16_t) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(uint16_t),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(long) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(long) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(long),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPyVerify */
+#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
+#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
+#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
+    {\
+        func_type value = func_value;\
+        if (sizeof(target_type) < sizeof(func_type)) {\
+            if (unlikely(value != (func_type) (target_type) value)) {\
+                func_type zero = 0;\
+                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
+                    return (target_type) -1;\
+                if (is_unsigned && unlikely(value < zero))\
+                    goto raise_neg_overflow;\
+                else\
+                    goto raise_overflow;\
+            }\
+        }\
+        return (target_type) value;\
+    }
+
+/* CIntFromPy */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(long) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (long) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        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])
+                case 2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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;
+            }
+#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;
+            }
+#endif
+            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))
+#endif
+            }
+        } 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])
+                case -2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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))
+#ifdef HAVE_LONG_LONG
+            } 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");
+#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;
+            }
+#endif
+            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:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to long");
+    return (long) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to long");
+    return (long) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
+#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 PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(int) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        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])
+                case 2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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;
+            }
+#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;
+            }
+#endif
+            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))
+#endif
+            }
+        } 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])
+                case -2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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))
+#ifdef HAVE_LONG_LONG
+            } 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");
+#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);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            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:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to int");
+    return (int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to int");
+    return (int) -1;
+}
+
+/* FastTypeChecks */
+#if CYTHON_COMPILING_IN_CPYTHON
+static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
+    while (a) {
+        a = a->tp_base;
+        if (a == b)
+            return 1;
+    }
+    return b == &PyBaseObject_Type;
+}
+static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (a == b) return 1;
+    mro = a->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(a, b);
+}
+#if PY_MAJOR_VERSION == 2
+static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
+    PyObject *exception, *value, *tb;
+    int res;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&exception, &value, &tb);
+    res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0;
+    if (unlikely(res == -1)) {
+        PyErr_WriteUnraisable(err);
+        res = 0;
+    }
+    if (!res) {
+        res = PyObject_IsSubclass(err, exc_type2);
+        if (unlikely(res == -1)) {
+            PyErr_WriteUnraisable(err);
+            res = 0;
+        }
+    }
+    __Pyx_ErrRestore(exception, value, tb);
+    return res;
+}
+#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);
+    }
+    return res;
+}
+#endif
+static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    assert(PyExceptionClass_Check(exc_type));
+    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++) {
+        PyObject *t = PyTuple_GET_ITEM(tuple, i);
+        #if PY_MAJOR_VERSION < 3
+        if (likely(exc_type == t)) return 1;
+        #endif
+        if (likely(PyExceptionClass_Check(t))) {
+            if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
+        } else {
+        }
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
+    if (likely(err == exc_type)) return 1;
+    if (likely(PyExceptionClass_Check(err))) {
+        if (likely(PyExceptionClass_Check(exc_type))) {
+            return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
+        } else if (likely(PyTuple_Check(exc_type))) {
+            return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
+        } else {
+        }
+    }
+    return PyErr_GivenExceptionMatches(err, exc_type);
+}
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
+    assert(PyExceptionClass_Check(exc_type1));
+    assert(PyExceptionClass_Check(exc_type2));
+    if (likely(err == exc_type1 || err == exc_type2)) return 1;
+    if (likely(PyExceptionClass_Check(err))) {
+        return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
+    }
+    return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
+}
+#endif
+
+/* CheckBinaryVersion */
+static int __Pyx_check_binary_version(void) {
+    char ctversion[4], rtversion[4];
+    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
+    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
+    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
+        char message[200];
+        PyOS_snprintf(message, sizeof(message),
+                      "compiletime version %s of module '%.100s' "
+                      "does not match runtime version %s",
+                      ctversion, __Pyx_MODULE_NAME, rtversion);
+        return PyErr_WarnEx(NULL, message, 1);
+    }
+    return 0;
+}
+
+/* InitStrings */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
+    while (t->p) {
+        #if PY_MAJOR_VERSION < 3
+        if (t->is_unicode) {
+            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
+        } else if (t->intern) {
+            *t->p = PyString_InternFromString(t->s);
+        } 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;
+        ++t;
+    }
+    return 0;
+}
+
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+}
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
+    Py_ssize_t ignore;
+    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#if !CYTHON_PEP393_ENABLED
+static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    char* defenc_c;
+    PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
+    if (!defenc) return NULL;
+    defenc_c = PyBytes_AS_STRING(defenc);
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    {
+        char* end = defenc_c + PyBytes_GET_SIZE(defenc);
+        char* c;
+        for (c = defenc_c; c < end; c++) {
+            if ((unsigned char) (*c) >= 128) {
+                PyUnicode_AsASCIIString(o);
+                return NULL;
+            }
+        }
+    }
+#endif
+    *length = PyBytes_GET_SIZE(defenc);
+    return defenc_c;
+}
+#else
+static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    if (likely(PyUnicode_IS_ASCII(o))) {
+        *length = PyUnicode_GET_LENGTH(o);
+        return PyUnicode_AsUTF8(o);
+    } else {
+        PyUnicode_AsASCIIString(o);
+        return NULL;
+    }
+#else
+    return PyUnicode_AsUTF8AndSize(o, length);
+#endif
+}
+#endif
+#endif
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+    if (
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+            __Pyx_sys_getdefaultencoding_not_ascii &&
+#endif
+            PyUnicode_Check(o)) {
+        return __Pyx_PyUnicode_AsStringAndSize(o, length);
+    } else
+#endif
+#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+    if (PyByteArray_Check(o)) {
+        *length = PyByteArray_GET_SIZE(o);
+        return PyByteArray_AS_STRING(o);
+    } else
+#endif
+    {
+        char* result;
+        int r = PyBytes_AsStringAndSize(o, &result, length);
+        if (unlikely(r < 0)) {
+            return NULL;
+        } else {
+            return result;
+        }
+    }
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+   int is_true = x == Py_True;
+   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
+   else return PyObject_IsTrue(x);
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
+    int retval;
+    if (unlikely(!x)) return -1;
+    retval = __Pyx_PyObject_IsTrue(x);
+    Py_DECREF(x);
+    return retval;
+}
+static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+#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)) {
+            Py_DECREF(result);
+            return NULL;
+        }
+        return result;
+    }
+#endif
+    PyErr_Format(PyExc_TypeError,
+                 "__%.4s__ returned non-%.4s (type %.200s)",
+                 type_name, type_name, Py_TYPE(result)->tp_name);
+    Py_DECREF(result);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
+#if CYTHON_USE_TYPE_SLOTS
+  PyNumberMethods *m;
+#endif
+  const char *name = NULL;
+  PyObject *res = NULL;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_Check(x) || PyLong_Check(x)))
+#else
+  if (likely(PyLong_Check(x)))
+#endif
+    return __Pyx_NewRef(x);
+#if CYTHON_USE_TYPE_SLOTS
+  m = Py_TYPE(x)->tp_as_number;
+  #if PY_MAJOR_VERSION < 3
+  if (m && m->nb_int) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  else if (m && m->nb_long) {
+    name = "long";
+    res = m->nb_long(x);
+  }
+  #else
+  if (likely(m && m->nb_int)) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  #endif
+#else
+  if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
+    res = PyNumber_Int(x);
+  }
+#endif
+  if (likely(res)) {
+#if PY_MAJOR_VERSION < 3
+    if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) {
+#else
+    if (unlikely(!PyLong_CheckExact(res))) {
+#endif
+        return __Pyx_PyNumber_IntOrLongWrongResultType(res, name);
+    }
+  }
+  else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_TypeError,
+                    "an integer is required");
+  }
+  return res;
+}
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+  Py_ssize_t ival;
+  PyObject *x;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_CheckExact(b))) {
+    if (sizeof(Py_ssize_t) >= sizeof(long))
+        return PyInt_AS_LONG(b);
+    else
+        return PyInt_AsSsize_t(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;
+    } else {
+      switch (size) {
+         case 2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((((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(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return -(Py_ssize_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
+    return PyLong_AsSsize_t(b);
+  }
+  x = PyNumber_Index(b);
+  if (!x) return -1;
+  ival = PyInt_AsSsize_t(x);
+  Py_DECREF(x);
+  return ival;
+}
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
+  return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);
+}
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+    return PyInt_FromSize_t(ival);
+}
+
+
+#endif /* Py_PYTHON_H */
diff --git a/myenv/lib/python3.9/site-packages/httptools/parser/parser.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/httptools/parser/parser.cpython-39-darwin.so
new file mode 100755
index 0000000..89c036c
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/httptools/parser/parser.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/httptools/parser/url_parser.c b/myenv/lib/python3.9/site-packages/httptools/parser/url_parser.c
new file mode 100644
index 0000000..3f56d85
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httptools/parser/url_parser.c
@@ -0,0 +1,5935 @@
+/* Generated by Cython 0.29.24 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "name": "httptools.parser.url_parser",
+        "sources": [
+            "httptools/parser/url_parser.pyx"
+        ]
+    },
+    "module_name": "httptools.parser.url_parser"
+}
+END: Cython Metadata */
+
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif /* PY_SSIZE_T_CLEAN */
+#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+.
+#else
+#define CYTHON_ABI "0_29_24"
+#define CYTHON_HEX_VERSION 0x001D18F0
+#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)
+  #ifndef __stdcall
+    #define __stdcall
+  #endif
+  #ifndef __cdecl
+    #define __cdecl
+  #endif
+  #ifndef __fastcall
+    #define __fastcall
+  #endif
+#endif
+#ifndef DL_IMPORT
+  #define DL_IMPORT(t) t
+#endif
+#ifndef DL_EXPORT
+  #define DL_EXPORT(t) t
+#endif
+#define __PYX_COMMA ,
+#ifndef HAVE_LONG_LONG
+  #if PY_VERSION_HEX >= 0x02070000
+    #define HAVE_LONG_LONG
+  #endif
+#endif
+#ifndef PY_LONG_LONG
+  #define PY_LONG_LONG LONG_LONG
+#endif
+#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 CYTHON_COMPILING_IN_CPYTHON 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #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_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #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_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+#elif defined(PYSTON_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 1
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #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
+  #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_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #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_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+#else
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 1
+  #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)
+    #define CYTHON_USE_PYTYPE_LOOKUP 1
+  #endif
+  #if PY_MAJOR_VERSION < 3
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #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)
+    #define CYTHON_USE_PYLONG_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_PYLIST_INTERNALS
+    #define CYTHON_USE_PYLIST_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #if PY_VERSION_HEX < 0x030300F0
+    #undef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
+  #elif !defined(CYTHON_USE_UNICODE_WRITER)
+    #define CYTHON_USE_UNICODE_WRITER 1
+  #endif
+  #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
+  #ifndef CYTHON_FAST_THREAD_STATE
+    #define CYTHON_FAST_THREAD_STATE 1
+  #endif
+  #ifndef CYTHON_FAST_PYCALL
+    #define CYTHON_FAST_PYCALL 1
+  #endif
+  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #endif
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #endif
+  #ifndef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #endif
+  #ifndef CYTHON_USE_EXC_INFO_STACK
+    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+  #endif
+#endif
+#if !defined(CYTHON_FAST_PYCCALL)
+#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+  #include "longintrepr.h"
+  #undef SHIFT
+  #undef BASE
+  #undef MASK
+  #ifdef SIZEOF_VOID_P
+    enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
+  #endif
+#endif
+#ifndef __has_attribute
+  #define __has_attribute(x) 0
+#endif
+#ifndef __has_cpp_attribute
+  #define __has_cpp_attribute(x) 0
+#endif
+#ifndef CYTHON_RESTRICT
+  #if defined(__GNUC__)
+    #define CYTHON_RESTRICT __restrict__
+  #elif defined(_MSC_VER) && _MSC_VER >= 1400
+    #define CYTHON_RESTRICT __restrict
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_RESTRICT restrict
+  #else
+    #define CYTHON_RESTRICT
+  #endif
+#endif
+#ifndef CYTHON_UNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define CYTHON_UNUSED __attribute__ ((__unused__))
+#   else
+#     define CYTHON_UNUSED
+#   endif
+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
+#   define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+#   define CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+#  if defined(__cplusplus)
+     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+#  else
+#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#  endif
+#endif
+#ifndef CYTHON_NCP_UNUSED
+# if CYTHON_COMPILING_IN_CPYTHON
+#  define CYTHON_NCP_UNUSED
+# else
+#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
+# 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;
+        #else
+           typedef unsigned __int8   uint8_t;
+           typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+#else
+   #include <stdint.h>
+#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]]
+    #endif
+  #endif
+  #ifndef CYTHON_FALLTHROUGH
+    #if __has_attribute(fallthrough)
+      #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
+    #else
+      #define CYTHON_FALLTHROUGH
+    #endif
+  #endif
+  #if defined(__clang__ ) && defined(__apple_build_version__)
+    #if __apple_build_version__ < 7000000
+      #undef  CYTHON_FALLTHROUGH
+      #define CYTHON_FALLTHROUGH
+    #endif
+  #endif
+#endif
+
+#ifndef CYTHON_INLINE
+  #if defined(__clang__)
+    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
+  #elif defined(__GNUC__)
+    #define CYTHON_INLINE __inline__
+  #elif defined(_MSC_VER)
+    #define CYTHON_INLINE __inline
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_INLINE inline
+  #else
+    #define CYTHON_INLINE
+  #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
+#else
+  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
+#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a, 0, 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)\
+          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#endif
+  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+  #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+  #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+  #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef METH_STACKLESS
+  #define METH_STACKLESS 0
+#endif
+#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
+  #ifndef METH_FASTCALL
+     #define METH_FASTCALL 0x80
+  #endif
+  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
+  typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
+                                                          Py_ssize_t nargs, PyObject *kwnames);
+#else
+  #define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+#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)))))
+#else
+#define __Pyx_PyFastCFunction_Check(func) 0
+#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)
+#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
+  #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x03060000
+  #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
+#elif PY_VERSION_HEX >= 0x03000000
+  #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#else
+  #define __Pyx_PyThreadState_Current _PyThreadState_Current
+#endif
+#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
+#include "pythread.h"
+#define Py_tss_NEEDS_INIT 0
+typedef int Py_tss_t;
+static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
+  *key = PyThread_create_key();
+  return 0;
+}
+static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
+  Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
+  *key = Py_tss_NEEDS_INIT;
+  return key;
+}
+static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
+  PyObject_Free(key);
+}
+static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
+  return *key != Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
+  PyThread_delete_key(*key);
+  *key = Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
+  return PyThread_set_key_value(*key, value);
+}
+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)
+#define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
+#else
+#define __Pyx_PyDict_NewPresized(n)  PyDict_New()
+#endif
+#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
+#else
+  #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)
+#else
+#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#endif
+#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #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)
+  #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_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
+  #else
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+  #endif
+#else
+  #define CYTHON_PEP393_ENABLED 0
+  #define PyUnicode_1BYTE_KIND  1
+  #define PyUnicode_2BYTE_KIND  2
+  #define PyUnicode_4BYTE_KIND  4
+  #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_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_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
+#else
+  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
+  #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)
+#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))
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
+#else
+  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
+#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+  #define PyObject_ASCII(o)            PyObject_Repr(o)
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBaseString_Type            PyUnicode_Type
+  #define PyStringObject               PyUnicodeObject
+  #define PyString_Type                PyUnicode_Type
+  #define PyString_Check               PyUnicode_Check
+  #define PyString_CheckExact          PyUnicode_CheckExact
+#ifndef PyObject_Unicode
+  #define PyObject_Unicode             PyObject_Str
+#endif
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
+  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#else
+  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
+  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+#endif
+#ifndef PySet_CheckExact
+  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+#endif
+#if PY_VERSION_HEX >= 0x030900A4
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
+#else
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
+#endif
+#if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+#else
+  #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+#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 PyInt_FromString             PyLong_FromString
+  #define PyInt_FromUnicode            PyLong_FromUnicode
+  #define PyInt_FromLong               PyLong_FromLong
+  #define PyInt_FromSize_t             PyLong_FromSize_t
+  #define PyInt_FromSsize_t            PyLong_FromSsize_t
+  #define PyInt_AsLong                 PyLong_AsLong
+  #define PyInt_AS_LONG                PyLong_AS_LONG
+  #define PyInt_AsSsize_t              PyLong_AsSsize_t
+  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
+  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+  #define PyNumber_Int                 PyNumber_Long
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBoolObject                 PyLongObject
+#endif
+#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
+  #ifndef PyUnicode_InternFromString
+    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+  #endif
+#endif
+#if PY_VERSION_HEX < 0x030200A4
+  typedef long Py_hash_t;
+  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
+#else
+  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
+  #define __Pyx_PyInt_AsHash_t   PyInt_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
+    #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
+  #else
+    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
+  #endif
+#else
+  #define __Pyx_PyType_AsAsync(obj) NULL
+#endif
+#ifndef __Pyx_PyAsyncMethodsStruct
+    typedef struct {
+        unaryfunc am_await;
+        unaryfunc am_aiter;
+        unaryfunc am_anext;
+    } __Pyx_PyAsyncMethodsStruct;
+#endif
+
+#if defined(WIN32) || defined(MS_WINDOWS)
+  #define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+#ifdef NAN
+#define __PYX_NAN() ((float) NAN)
+#else
+static CYTHON_INLINE float __PYX_NAN() {
+  float value;
+  memset(&value, 0xFF, sizeof(value));
+  return value;
+}
+#endif
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#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; }
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+    { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
+
+#ifndef __PYX_EXTERN_C
+  #ifdef __cplusplus
+    #define __PYX_EXTERN_C extern "C"
+  #else
+    #define __PYX_EXTERN_C extern
+  #endif
+#endif
+
+#define __PYX_HAVE__httptools__parser__url_parser
+#define __PYX_HAVE_API__httptools__parser__url_parser
+/* Early includes */
+#include <string.h>
+#include <stdio.h>
+#include "pythread.h"
+#include <stdint.h>
+#include "http_parser.h"
+#ifdef _OPENMP
+#include <omp.h>
+#endif /* _OPENMP */
+
+#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
+                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
+    (sizeof(type) < sizeof(Py_ssize_t))  ||\
+    (sizeof(type) > sizeof(Py_ssize_t) &&\
+          likely(v < (type)PY_SSIZE_T_MAX ||\
+                 v == (type)PY_SSIZE_T_MAX)  &&\
+          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+                                v == (type)PY_SSIZE_T_MIN)))  ||\
+    (sizeof(type) == sizeof(Py_ssize_t) &&\
+          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+                               v == (type)PY_SSIZE_T_MAX)))  )
+static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
+    return (size_t) i < (size_t) limit;
+}
+#if defined (__cplusplus) && __cplusplus >= 201103L
+    #include <cstdlib>
+    #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER)
+    #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+    #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+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))
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString        PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+#if PY_MAJOR_VERSION < 3
+    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#else
+    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
+#endif
+#define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AS_STRING(s))
+#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_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)
+#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
+#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_AsUnicode            PyUnicode_AsUnicode
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+#define __Pyx_PySequence_Tuple(obj)\
+    (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#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;
+    const char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    if (strcmp(default_encoding_c, "ascii") == 0) {
+        __Pyx_sys_getdefaultencoding_not_ascii = 0;
+    } else {
+        char ascii_chars[128];
+        int c;
+        for (c = 0; c < 128; c++) {
+            ascii_chars[c] = c;
+        }
+        __Pyx_sys_getdefaultencoding_not_ascii = 1;
+        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+        if (!ascii_chars_u) goto bad;
+        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+            PyErr_Format(
+                PyExc_ValueError,
+                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+                default_encoding_c);
+            goto bad;
+        }
+        Py_DECREF(ascii_chars_u);
+        Py_DECREF(ascii_chars_b);
+    }
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    Py_XDECREF(ascii_chars_u);
+    Py_XDECREF(ascii_chars_b);
+    return -1;
+}
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#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
+static char* __PYX_DEFAULT_STRING_ENCODING;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
+    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    return -1;
+}
+#endif
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+  #define likely(x)   __builtin_expect(!!(x), 1)
+  #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+  #define likely(x)   (x)
+  #define unlikely(x) (x)
+#endif /* __GNUC__ */
+static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
+
+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;
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * __pyx_cfilenm= __FILE__;
+static const char *__pyx_filename;
+
+
+static const char *__pyx_f[] = {
+  "stringsource",
+  "httptools/parser/url_parser.pyx",
+  ".eggs/Cython-0.29.24-py3.9-macosx-10.9-x86_64.egg/Cython/Includes/cpython/type.pxd",
+  ".eggs/Cython-0.29.24-py3.9-macosx-10.9-x86_64.egg/Cython/Includes/cpython/bool.pxd",
+  ".eggs/Cython-0.29.24-py3.9-macosx-10.9-x86_64.egg/Cython/Includes/cpython/complex.pxd",
+};
+
+/*--- Type declarations ---*/
+struct __pyx_obj_9httptools_6parser_10url_parser_URL;
+
+/* "httptools/parser/url_parser.pyx":16
+ * 
+ * @cython.freelist(250)
+ * cdef class URL:             # <<<<<<<<<<<<<<
+ *     cdef readonly bytes schema
+ *     cdef readonly bytes host
+ */
+struct __pyx_obj_9httptools_6parser_10url_parser_URL {
+  PyObject_HEAD
+  PyObject *schema;
+  PyObject *host;
+  PyObject *port;
+  PyObject *path;
+  PyObject *query;
+  PyObject *fragment;
+  PyObject *userinfo;
+};
+
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+  #define CYTHON_REFNANNY 0
+#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 (*FinishContext)(void**);
+  } __Pyx_RefNannyAPIStruct;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+#ifdef WITH_THREAD
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          if (acquire_gil) {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              PyGILState_Release(__pyx_gilstate_save);\
+          } else {\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+          }
+#else
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+#endif
+  #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)
+#else
+  #define __Pyx_RefNannyDeclarations
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContext()
+  #define __Pyx_INCREF(r) Py_INCREF(r)
+  #define __Pyx_DECREF(r) Py_DECREF(r)
+  #define __Pyx_GOTREF(r)
+  #define __Pyx_GIVEREF(r)
+  #define __Pyx_XINCREF(r) Py_XINCREF(r)
+  #define __Pyx_XDECREF(r) Py_XDECREF(r)
+  #define __Pyx_XGOTREF(r)
+  #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_XDECREF(tmp);\
+    } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_DECREF(tmp);\
+    } while (0)
+#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);
+
+/* 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);
+
+/* 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);
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#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
+  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
+
+/* 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
+
+/* 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
+
+/* 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);
+
+/* PyDictVersioning.proto */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+#define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
+#define __PYX_GET_DICT_VERSION(dict)  (((PyDictObject*)(dict))->ma_version_tag)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
+    (version_var) = __PYX_GET_DICT_VERSION(dict);\
+    (cache_var) = (value);
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
+    static PY_UINT64_T __pyx_dict_version = 0;\
+    static PyObject *__pyx_dict_cached_value = NULL;\
+    if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
+        (VAR) = __pyx_dict_cached_value;\
+    } else {\
+        (VAR) = __pyx_dict_cached_value = (LOOKUP);\
+        __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
+    }\
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
+#else
+#define __PYX_GET_DICT_VERSION(dict)  (0)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP)  (VAR) = (LOOKUP);
+#endif
+
+/* GetModuleGlobalName.proto */
+#if CYTHON_USE_DICT_VERSIONS
+#define __Pyx_GetModuleGlobalName(var, name)  {\
+    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)  {\
+    PY_UINT64_T __pyx_dict_version;\
+    PyObject *__pyx_dict_cached_value;\
+    (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
+}
+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)
+#define __Pyx_GetModuleGlobalNameUncached(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
+#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);
+
+/* GetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* SwapException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSwap(type, value, tb)  __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* GetTopmostException.proto */
+#if CYTHON_USE_EXC_INFO_STACK
+static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
+#endif
+
+/* SaveResetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+#else
+#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* 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);
+#else
+#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr
+#endif
+
+/* PyObject_GenericGetAttr.proto */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name);
+#else
+#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 */
+static int __Pyx_setup_reduce(PyObject* type_obj);
+
+/* 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
+};
+static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+#endif
+
+/* Import.proto */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+
+/* ImportFrom.proto */
+static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
+
+/* CLineInTraceback.proto */
+#ifdef CYTHON_CLINE_IN_TRACEBACK
+#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
+#else
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
+#endif
+
+/* CodeObjectCache.proto */
+typedef struct {
+    PyCodeObject* code_object;
+    int code_line;
+} __Pyx_CodeObjectCacheEntry;
+struct __Pyx_CodeObjectCache {
+    int count;
+    int max_count;
+    __Pyx_CodeObjectCacheEntry* entries;
+};
+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);
+
+/* 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))
+#define __Pyx_HAS_GCC_DIAGNOSTIC
+#endif
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint16_t(uint16_t value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+
+/* CIntFromPy.proto */
+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)
+static CYTHON_INLINE int __Pyx_IsSubtype(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_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_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(void);
+
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+
+
+/* Module declarations from 'cpython.mem' */
+
+/* Module declarations from 'cpython.version' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.type' */
+static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
+
+/* Module declarations from 'libc.string' */
+
+/* Module declarations from 'libc.stdio' */
+
+/* Module declarations from 'cpython.object' */
+
+/* Module declarations from 'cpython.ref' */
+
+/* Module declarations from 'cpython.exc' */
+
+/* Module declarations from 'cpython.module' */
+
+/* Module declarations from 'cpython.tuple' */
+
+/* Module declarations from 'cpython.list' */
+
+/* Module declarations from 'cpython.sequence' */
+
+/* Module declarations from 'cpython.mapping' */
+
+/* Module declarations from 'cpython.iterator' */
+
+/* Module declarations from 'cpython.number' */
+
+/* Module declarations from 'cpython.int' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.bool' */
+static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0;
+
+/* Module declarations from 'cpython.long' */
+
+/* Module declarations from 'cpython.float' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.complex' */
+static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0;
+
+/* Module declarations from 'cpython.string' */
+
+/* Module declarations from 'cpython.unicode' */
+
+/* Module declarations from 'cpython.dict' */
+
+/* Module declarations from 'cpython.instance' */
+
+/* Module declarations from 'cpython.function' */
+
+/* Module declarations from 'cpython.method' */
+
+/* Module declarations from 'cpython.weakref' */
+
+/* Module declarations from 'cpython.getargs' */
+
+/* Module declarations from 'cpython.pythread' */
+
+/* Module declarations from 'cpython.pystate' */
+
+/* Module declarations from 'cpython.cobject' */
+
+/* Module declarations from 'cpython.oldbuffer' */
+
+/* Module declarations from 'cpython.set' */
+
+/* Module declarations from 'cpython.buffer' */
+
+/* Module declarations from 'cpython.bytes' */
+
+/* Module declarations from 'cpython.pycapsule' */
+
+/* Module declarations from 'cpython' */
+
+/* Module declarations from 'cython' */
+
+/* Module declarations from 'httptools.parser' */
+
+/* Module declarations from 'libc.stdint' */
+
+/* Module declarations from 'httptools.parser.url_cparser' */
+
+/* Module declarations from 'httptools.parser.url_parser' */
+static PyTypeObject *__pyx_ptype_9httptools_6parser_10url_parser_URL = 0;
+#define __Pyx_MODULE_NAME "httptools.parser.url_parser"
+extern int __pyx_module_is_main_httptools__parser__url_parser;
+int __pyx_module_is_main_httptools__parser__url_parser = 0;
+
+/* Implementation of 'httptools.parser.url_parser' */
+static PyObject *__pyx_builtin_TypeError;
+static const char __pyx_k_ln[] = "ln";
+static const char __pyx_k_URL[] = "URL";
+static const char __pyx_k_all[] = "__all__";
+static const char __pyx_k_off[] = "off";
+static const char __pyx_k_res[] = "res";
+static const char __pyx_k_url[] = "url";
+static const char __pyx_k_host[] = "host";
+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_port[] = "port";
+static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_query[] = "query";
+static const char __pyx_k_errors[] = "errors";
+static const char __pyx_k_format[] = "format";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_parsed[] = "parsed";
+static const char __pyx_k_py_buf[] = "py_buf";
+static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_result[] = "result";
+static const char __pyx_k_schema[] = "schema";
+static const char __pyx_k_buf_data[] = "buf_data";
+static const char __pyx_k_fragment[] = "fragment";
+static const char __pyx_k_getstate[] = "__getstate__";
+static const char __pyx_k_setstate[] = "__setstate__";
+static const char __pyx_k_userinfo[] = "userinfo";
+static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_parse_url[] = "parse_url";
+static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
+static const char __pyx_k_invalid_url_r[] = "invalid url {!r}";
+static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_HttpParserInvalidURLError[] = "HttpParserInvalidURLError";
+static const char __pyx_k_httptools_parser_url_parser[] = "httptools.parser.url_parser";
+static const char __pyx_k_URL_schema_r_host_r_port_r_path[] = "<URL schema: {!r}, host: {!r}, port: {!r}, path: {!r}, query: {!r}, fragment: {!r}, userinfo: {!r}>";
+static const char __pyx_k_httptools_parser_url_parser_pyx[] = "httptools/parser/url_parser.pyx";
+static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
+static PyObject *__pyx_n_s_HttpParserInvalidURLError;
+static PyObject *__pyx_n_s_TypeError;
+static PyObject *__pyx_n_s_URL;
+static PyObject *__pyx_kp_u_URL_schema_r_host_r_port_r_path;
+static PyObject *__pyx_n_s_all;
+static PyObject *__pyx_n_s_buf_data;
+static PyObject *__pyx_n_s_cline_in_traceback;
+static PyObject *__pyx_n_s_errors;
+static PyObject *__pyx_n_s_format;
+static PyObject *__pyx_n_s_fragment;
+static PyObject *__pyx_n_s_getstate;
+static PyObject *__pyx_n_s_host;
+static PyObject *__pyx_n_s_httptools_parser_url_parser;
+static PyObject *__pyx_kp_s_httptools_parser_url_parser_pyx;
+static PyObject *__pyx_n_s_import;
+static PyObject *__pyx_kp_u_invalid_url_r;
+static PyObject *__pyx_n_s_ln;
+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_off;
+static PyObject *__pyx_n_s_parse_url;
+static PyObject *__pyx_n_u_parse_url;
+static PyObject *__pyx_n_s_parsed;
+static PyObject *__pyx_n_s_path;
+static PyObject *__pyx_n_s_port;
+static PyObject *__pyx_n_s_py_buf;
+static PyObject *__pyx_n_s_query;
+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_res;
+static PyObject *__pyx_n_s_result;
+static PyObject *__pyx_n_s_schema;
+static PyObject *__pyx_n_s_setstate;
+static PyObject *__pyx_n_s_setstate_cython;
+static PyObject *__pyx_n_s_test;
+static PyObject *__pyx_n_s_url;
+static PyObject *__pyx_n_s_userinfo;
+static int __pyx_pf_9httptools_6parser_10url_parser_3URL___cinit__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self, PyObject *__pyx_v_schema, PyObject *__pyx_v_host, PyObject *__pyx_v_port, PyObject *__pyx_v_path, PyObject *__pyx_v_query, PyObject *__pyx_v_fragment, PyObject *__pyx_v_userinfo); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_2__repr__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_6schema___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_4host___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_4port___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_4path___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_5query___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_8fragment___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_8userinfo___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_parse_url(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_url); /* proto */
+static PyObject *__pyx_tp_new_9httptools_6parser_10url_parser_URL(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_codeobj__5;
+/* Late includes */
+
+/* "httptools/parser/url_parser.pyx":25
+ *     cdef readonly bytes userinfo
+ * 
+ *     def __cinit__(self, bytes schema, bytes host, object port, bytes path,             # <<<<<<<<<<<<<<
+ *                   bytes query, bytes fragment, bytes userinfo):
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9httptools_6parser_10url_parser_3URL_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9httptools_6parser_10url_parser_3URL_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_schema = 0;
+  PyObject *__pyx_v_host = 0;
+  PyObject *__pyx_v_port = 0;
+  PyObject *__pyx_v_path = 0;
+  PyObject *__pyx_v_query = 0;
+  PyObject *__pyx_v_fragment = 0;
+  PyObject *__pyx_v_userinfo = 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_schema,&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_path,&__pyx_n_s_query,&__pyx_n_s_fragment,&__pyx_n_s_userinfo,0};
+    PyObject* values[7] = {0,0,0,0,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  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+        CYTHON_FALLTHROUGH;
+        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+        CYTHON_FALLTHROUGH;
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        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);
+        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_schema)) != 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_host)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 7, 7, 1); __PYX_ERR(1, 25, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_port)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 7, 7, 2); __PYX_ERR(1, 25, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 7, 7, 3); __PYX_ERR(1, 25, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_query)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 7, 7, 4); __PYX_ERR(1, 25, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  5:
+        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fragment)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 7, 7, 5); __PYX_ERR(1, 25, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  6:
+        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_userinfo)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 7, 7, 6); __PYX_ERR(1, 25, __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, 25, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 7) {
+      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[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+      values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+    }
+    __pyx_v_schema = ((PyObject*)values[0]);
+    __pyx_v_host = ((PyObject*)values[1]);
+    __pyx_v_port = values[2];
+    __pyx_v_path = ((PyObject*)values[3]);
+    __pyx_v_query = ((PyObject*)values[4]);
+    __pyx_v_fragment = ((PyObject*)values[5]);
+    __pyx_v_userinfo = ((PyObject*)values[6]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 7, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 25, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("httptools.parser.url_parser.URL.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_schema), (&PyBytes_Type), 1, "schema", 1))) __PYX_ERR(1, 25, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_host), (&PyBytes_Type), 1, "host", 1))) __PYX_ERR(1, 25, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_path), (&PyBytes_Type), 1, "path", 1))) __PYX_ERR(1, 25, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_query), (&PyBytes_Type), 1, "query", 1))) __PYX_ERR(1, 26, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_fragment), (&PyBytes_Type), 1, "fragment", 1))) __PYX_ERR(1, 26, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_userinfo), (&PyBytes_Type), 1, "userinfo", 1))) __PYX_ERR(1, 26, __pyx_L1_error)
+  __pyx_r = __pyx_pf_9httptools_6parser_10url_parser_3URL___cinit__(((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)__pyx_v_self), __pyx_v_schema, __pyx_v_host, __pyx_v_port, __pyx_v_path, __pyx_v_query, __pyx_v_fragment, __pyx_v_userinfo);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_9httptools_6parser_10url_parser_3URL___cinit__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self, PyObject *__pyx_v_schema, PyObject *__pyx_v_host, PyObject *__pyx_v_port, PyObject *__pyx_v_path, PyObject *__pyx_v_query, PyObject *__pyx_v_fragment, PyObject *__pyx_v_userinfo) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "httptools/parser/url_parser.pyx":28
+ *                   bytes query, bytes fragment, bytes userinfo):
+ * 
+ *         self.schema = schema             # <<<<<<<<<<<<<<
+ *         self.host = host
+ *         self.port = port
+ */
+  __Pyx_INCREF(__pyx_v_schema);
+  __Pyx_GIVEREF(__pyx_v_schema);
+  __Pyx_GOTREF(__pyx_v_self->schema);
+  __Pyx_DECREF(__pyx_v_self->schema);
+  __pyx_v_self->schema = __pyx_v_schema;
+
+  /* "httptools/parser/url_parser.pyx":29
+ * 
+ *         self.schema = schema
+ *         self.host = host             # <<<<<<<<<<<<<<
+ *         self.port = port
+ *         self.path = path
+ */
+  __Pyx_INCREF(__pyx_v_host);
+  __Pyx_GIVEREF(__pyx_v_host);
+  __Pyx_GOTREF(__pyx_v_self->host);
+  __Pyx_DECREF(__pyx_v_self->host);
+  __pyx_v_self->host = __pyx_v_host;
+
+  /* "httptools/parser/url_parser.pyx":30
+ *         self.schema = schema
+ *         self.host = host
+ *         self.port = port             # <<<<<<<<<<<<<<
+ *         self.path = path
+ *         self.query = query
+ */
+  __Pyx_INCREF(__pyx_v_port);
+  __Pyx_GIVEREF(__pyx_v_port);
+  __Pyx_GOTREF(__pyx_v_self->port);
+  __Pyx_DECREF(__pyx_v_self->port);
+  __pyx_v_self->port = __pyx_v_port;
+
+  /* "httptools/parser/url_parser.pyx":31
+ *         self.host = host
+ *         self.port = port
+ *         self.path = path             # <<<<<<<<<<<<<<
+ *         self.query = query
+ *         self.fragment = fragment
+ */
+  __Pyx_INCREF(__pyx_v_path);
+  __Pyx_GIVEREF(__pyx_v_path);
+  __Pyx_GOTREF(__pyx_v_self->path);
+  __Pyx_DECREF(__pyx_v_self->path);
+  __pyx_v_self->path = __pyx_v_path;
+
+  /* "httptools/parser/url_parser.pyx":32
+ *         self.port = port
+ *         self.path = path
+ *         self.query = query             # <<<<<<<<<<<<<<
+ *         self.fragment = fragment
+ *         self.userinfo = userinfo
+ */
+  __Pyx_INCREF(__pyx_v_query);
+  __Pyx_GIVEREF(__pyx_v_query);
+  __Pyx_GOTREF(__pyx_v_self->query);
+  __Pyx_DECREF(__pyx_v_self->query);
+  __pyx_v_self->query = __pyx_v_query;
+
+  /* "httptools/parser/url_parser.pyx":33
+ *         self.path = path
+ *         self.query = query
+ *         self.fragment = fragment             # <<<<<<<<<<<<<<
+ *         self.userinfo = userinfo
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_fragment);
+  __Pyx_GIVEREF(__pyx_v_fragment);
+  __Pyx_GOTREF(__pyx_v_self->fragment);
+  __Pyx_DECREF(__pyx_v_self->fragment);
+  __pyx_v_self->fragment = __pyx_v_fragment;
+
+  /* "httptools/parser/url_parser.pyx":34
+ *         self.query = query
+ *         self.fragment = fragment
+ *         self.userinfo = userinfo             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+  __Pyx_INCREF(__pyx_v_userinfo);
+  __Pyx_GIVEREF(__pyx_v_userinfo);
+  __Pyx_GOTREF(__pyx_v_self->userinfo);
+  __Pyx_DECREF(__pyx_v_self->userinfo);
+  __pyx_v_self->userinfo = __pyx_v_userinfo;
+
+  /* "httptools/parser/url_parser.pyx":25
+ *     cdef readonly bytes userinfo
+ * 
+ *     def __cinit__(self, bytes schema, bytes host, object port, bytes path,             # <<<<<<<<<<<<<<
+ *                   bytes query, bytes fragment, bytes userinfo):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/url_parser.pyx":36
+ *         self.userinfo = userinfo
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return ('<URL schema: {!r}, host: {!r}, port: {!r}, path: {!r}, '
+ *                 'query: {!r}, fragment: {!r}, userinfo: {!r}>'
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_3__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_10url_parser_3URL_2__repr__(((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_2__repr__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = 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("__repr__", 0);
+
+  /* "httptools/parser/url_parser.pyx":37
+ * 
+ *     def __repr__(self):
+ *         return ('<URL schema: {!r}, host: {!r}, port: {!r}, path: {!r}, '             # <<<<<<<<<<<<<<
+ *                 'query: {!r}, fragment: {!r}, userinfo: {!r}>'
+ *                 .format(self.schema, self.host, self.port, self.path,
+ */
+  __Pyx_XDECREF(__pyx_r);
+
+  /* "httptools/parser/url_parser.pyx":39
+ *         return ('<URL schema: {!r}, host: {!r}, port: {!r}, path: {!r}, '
+ *                 'query: {!r}, fragment: {!r}, userinfo: {!r}>'
+ *                 .format(self.schema, self.host, self.port, self.path,             # <<<<<<<<<<<<<<
+ *                     self.query, self.fragment, self.userinfo))
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_URL_schema_r_host_r_port_r_path, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 39, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "httptools/parser/url_parser.pyx":40
+ *                 'query: {!r}, fragment: {!r}, userinfo: {!r}>'
+ *                 .format(self.schema, self.host, self.port, self.path,
+ *                     self.query, self.fragment, self.userinfo))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_3 = NULL;
+  __pyx_t_4 = 0;
+  if (CYTHON_UNPACK_METHODS && 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;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[8] = {__pyx_t_3, __pyx_v_self->schema, __pyx_v_self->host, __pyx_v_self->port, __pyx_v_self->path, __pyx_v_self->query, __pyx_v_self->fragment, __pyx_v_self->userinfo};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 7+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 39, __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[8] = {__pyx_t_3, __pyx_v_self->schema, __pyx_v_self->host, __pyx_v_self->port, __pyx_v_self->path, __pyx_v_self->query, __pyx_v_self->fragment, __pyx_v_self->userinfo};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 7+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 39, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  {
+    __pyx_t_5 = PyTuple_New(7+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 39, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (__pyx_t_3) {
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+    }
+    __Pyx_INCREF(__pyx_v_self->schema);
+    __Pyx_GIVEREF(__pyx_v_self->schema);
+    PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_self->schema);
+    __Pyx_INCREF(__pyx_v_self->host);
+    __Pyx_GIVEREF(__pyx_v_self->host);
+    PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_self->host);
+    __Pyx_INCREF(__pyx_v_self->port);
+    __Pyx_GIVEREF(__pyx_v_self->port);
+    PyTuple_SET_ITEM(__pyx_t_5, 2+__pyx_t_4, __pyx_v_self->port);
+    __Pyx_INCREF(__pyx_v_self->path);
+    __Pyx_GIVEREF(__pyx_v_self->path);
+    PyTuple_SET_ITEM(__pyx_t_5, 3+__pyx_t_4, __pyx_v_self->path);
+    __Pyx_INCREF(__pyx_v_self->query);
+    __Pyx_GIVEREF(__pyx_v_self->query);
+    PyTuple_SET_ITEM(__pyx_t_5, 4+__pyx_t_4, __pyx_v_self->query);
+    __Pyx_INCREF(__pyx_v_self->fragment);
+    __Pyx_GIVEREF(__pyx_v_self->fragment);
+    PyTuple_SET_ITEM(__pyx_t_5, 5+__pyx_t_4, __pyx_v_self->fragment);
+    __Pyx_INCREF(__pyx_v_self->userinfo);
+    __Pyx_GIVEREF(__pyx_v_self->userinfo);
+    PyTuple_SET_ITEM(__pyx_t_5, 6+__pyx_t_4, __pyx_v_self->userinfo);
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 39, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "httptools/parser/url_parser.pyx":36
+ *         self.userinfo = userinfo
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return ('<URL schema: {!r}, host: {!r}, port: {!r}, path: {!r}, '
+ *                 'query: {!r}, fragment: {!r}, userinfo: {!r}>'
+ */
+
+  /* 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_5);
+  __Pyx_AddTraceback("httptools.parser.url_parser.URL.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/url_parser.pyx":17
+ * @cython.freelist(250)
+ * cdef class URL:
+ *     cdef readonly bytes schema             # <<<<<<<<<<<<<<
+ *     cdef readonly bytes host
+ *     cdef readonly object port
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_6schema_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_6schema_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_10url_parser_3URL_6schema___get__(((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_6schema___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->schema);
+  __pyx_r = __pyx_v_self->schema;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/url_parser.pyx":18
+ * cdef class URL:
+ *     cdef readonly bytes schema
+ *     cdef readonly bytes host             # <<<<<<<<<<<<<<
+ *     cdef readonly object port
+ *     cdef readonly bytes path
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_4host_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_4host_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_10url_parser_3URL_4host___get__(((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_4host___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->host);
+  __pyx_r = __pyx_v_self->host;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/url_parser.pyx":19
+ *     cdef readonly bytes schema
+ *     cdef readonly bytes host
+ *     cdef readonly object port             # <<<<<<<<<<<<<<
+ *     cdef readonly bytes path
+ *     cdef readonly bytes query
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_4port_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_4port_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_10url_parser_3URL_4port___get__(((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_4port___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->port);
+  __pyx_r = __pyx_v_self->port;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/url_parser.pyx":20
+ *     cdef readonly bytes host
+ *     cdef readonly object port
+ *     cdef readonly bytes path             # <<<<<<<<<<<<<<
+ *     cdef readonly bytes query
+ *     cdef readonly bytes fragment
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_4path_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_4path_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_10url_parser_3URL_4path___get__(((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_4path___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->path);
+  __pyx_r = __pyx_v_self->path;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/url_parser.pyx":21
+ *     cdef readonly object port
+ *     cdef readonly bytes path
+ *     cdef readonly bytes query             # <<<<<<<<<<<<<<
+ *     cdef readonly bytes fragment
+ *     cdef readonly bytes userinfo
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_5query_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_5query_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_10url_parser_3URL_5query___get__(((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_5query___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->query);
+  __pyx_r = __pyx_v_self->query;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/url_parser.pyx":22
+ *     cdef readonly bytes path
+ *     cdef readonly bytes query
+ *     cdef readonly bytes fragment             # <<<<<<<<<<<<<<
+ *     cdef readonly bytes userinfo
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_8fragment_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_8fragment_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_10url_parser_3URL_8fragment___get__(((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_8fragment___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->fragment);
+  __pyx_r = __pyx_v_self->fragment;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/url_parser.pyx":23
+ *     cdef readonly bytes query
+ *     cdef readonly bytes fragment
+ *     cdef readonly bytes userinfo             # <<<<<<<<<<<<<<
+ * 
+ *     def __cinit__(self, bytes schema, bytes host, object port, bytes path,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_8userinfo_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_8userinfo_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_10url_parser_3URL_8userinfo___get__(((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_8userinfo___get__(struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->userinfo);
+  __pyx_r = __pyx_v_self->userinfo;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_5__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_9httptools_6parser_10url_parser_3URL_4__reduce_cython__(((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_10url_parser_URL *__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);
+
+  /* "(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_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)
+
+  /* "(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("httptools.parser.url_parser.URL.__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_9httptools_6parser_10url_parser_3URL_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_3URL_7__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_9httptools_6parser_10url_parser_3URL_6__setstate_cython__(((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_3URL_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9httptools_6parser_10url_parser_URL *__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);
+
+  /* "(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__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_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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("httptools.parser.url_parser.URL.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "httptools/parser/url_parser.pyx":43
+ * 
+ * 
+ * def parse_url(url):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         Py_buffer py_buf
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_1parse_url(PyObject *__pyx_self, PyObject *__pyx_v_url); /*proto*/
+static PyMethodDef __pyx_mdef_9httptools_6parser_10url_parser_1parse_url = {"parse_url", (PyCFunction)__pyx_pw_9httptools_6parser_10url_parser_1parse_url, METH_O, 0};
+static PyObject *__pyx_pw_9httptools_6parser_10url_parser_1parse_url(PyObject *__pyx_self, PyObject *__pyx_v_url) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("parse_url (wrapper)", 0);
+  __pyx_r = __pyx_pf_9httptools_6parser_10url_parser_parse_url(__pyx_self, ((PyObject *)__pyx_v_url));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9httptools_6parser_10url_parser_parse_url(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_url) {
+  Py_buffer __pyx_v_py_buf;
+  char *__pyx_v_buf_data;
+  struct http_parser_url *__pyx_v_parsed;
+  int __pyx_v_res;
+  PyObject *__pyx_v_schema = 0;
+  PyObject *__pyx_v_host = 0;
+  PyObject *__pyx_v_port = 0;
+  PyObject *__pyx_v_path = 0;
+  PyObject *__pyx_v_query = 0;
+  PyObject *__pyx_v_fragment = 0;
+  PyObject *__pyx_v_userinfo = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_result = 0;
+  int __pyx_v_off;
+  int __pyx_v_ln;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  uint16_t __pyx_t_3;
+  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;
+  int __pyx_t_9;
+  char const *__pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("parse_url", 0);
+
+  /* "httptools/parser/url_parser.pyx":49
+ *         uparser.http_parser_url* parsed
+ *         int res
+ *         bytes schema = None             # <<<<<<<<<<<<<<
+ *         bytes host = None
+ *         object port = None
+ */
+  __Pyx_INCREF(Py_None);
+  __pyx_v_schema = ((PyObject*)Py_None);
+
+  /* "httptools/parser/url_parser.pyx":50
+ *         int res
+ *         bytes schema = None
+ *         bytes host = None             # <<<<<<<<<<<<<<
+ *         object port = None
+ *         bytes path = None
+ */
+  __Pyx_INCREF(Py_None);
+  __pyx_v_host = ((PyObject*)Py_None);
+
+  /* "httptools/parser/url_parser.pyx":51
+ *         bytes schema = None
+ *         bytes host = None
+ *         object port = None             # <<<<<<<<<<<<<<
+ *         bytes path = None
+ *         bytes query = None
+ */
+  __Pyx_INCREF(Py_None);
+  __pyx_v_port = Py_None;
+
+  /* "httptools/parser/url_parser.pyx":52
+ *         bytes host = None
+ *         object port = None
+ *         bytes path = None             # <<<<<<<<<<<<<<
+ *         bytes query = None
+ *         bytes fragment = None
+ */
+  __Pyx_INCREF(Py_None);
+  __pyx_v_path = ((PyObject*)Py_None);
+
+  /* "httptools/parser/url_parser.pyx":53
+ *         object port = None
+ *         bytes path = None
+ *         bytes query = None             # <<<<<<<<<<<<<<
+ *         bytes fragment = None
+ *         bytes userinfo = None
+ */
+  __Pyx_INCREF(Py_None);
+  __pyx_v_query = ((PyObject*)Py_None);
+
+  /* "httptools/parser/url_parser.pyx":54
+ *         bytes path = None
+ *         bytes query = None
+ *         bytes fragment = None             # <<<<<<<<<<<<<<
+ *         bytes userinfo = None
+ *         object result = None
+ */
+  __Pyx_INCREF(Py_None);
+  __pyx_v_fragment = ((PyObject*)Py_None);
+
+  /* "httptools/parser/url_parser.pyx":55
+ *         bytes query = None
+ *         bytes fragment = None
+ *         bytes userinfo = None             # <<<<<<<<<<<<<<
+ *         object result = None
+ *         int off
+ */
+  __Pyx_INCREF(Py_None);
+  __pyx_v_userinfo = ((PyObject*)Py_None);
+
+  /* "httptools/parser/url_parser.pyx":56
+ *         bytes fragment = None
+ *         bytes userinfo = None
+ *         object result = None             # <<<<<<<<<<<<<<
+ *         int off
+ *         int ln
+ */
+  __Pyx_INCREF(Py_None);
+  __pyx_v_result = Py_None;
+
+  /* "httptools/parser/url_parser.pyx":60
+ *         int ln
+ * 
+ *     parsed = <uparser.http_parser_url*> \             # <<<<<<<<<<<<<<
+ *                         PyMem_Malloc(sizeof(uparser.http_parser_url))
+ *     uparser.http_parser_url_init(parsed)
+ */
+  __pyx_v_parsed = ((struct http_parser_url *)PyMem_Malloc((sizeof(struct http_parser_url))));
+
+  /* "httptools/parser/url_parser.pyx":62
+ *     parsed = <uparser.http_parser_url*> \
+ *                         PyMem_Malloc(sizeof(uparser.http_parser_url))
+ *     uparser.http_parser_url_init(parsed)             # <<<<<<<<<<<<<<
+ * 
+ *     PyObject_GetBuffer(url, &py_buf, PyBUF_SIMPLE)
+ */
+  http_parser_url_init(__pyx_v_parsed);
+
+  /* "httptools/parser/url_parser.pyx":64
+ *     uparser.http_parser_url_init(parsed)
+ * 
+ *     PyObject_GetBuffer(url, &py_buf, PyBUF_SIMPLE)             # <<<<<<<<<<<<<<
+ *     try:
+ *         buf_data = <char*>py_buf.buf
+ */
+  __pyx_t_1 = PyObject_GetBuffer(__pyx_v_url, (&__pyx_v_py_buf), PyBUF_SIMPLE); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 64, __pyx_L1_error)
+
+  /* "httptools/parser/url_parser.pyx":65
+ * 
+ *     PyObject_GetBuffer(url, &py_buf, PyBUF_SIMPLE)
+ *     try:             # <<<<<<<<<<<<<<
+ *         buf_data = <char*>py_buf.buf
+ *         res = uparser.http_parser_parse_url(buf_data, py_buf.len, 0, parsed)
+ */
+  /*try:*/ {
+
+    /* "httptools/parser/url_parser.pyx":66
+ *     PyObject_GetBuffer(url, &py_buf, PyBUF_SIMPLE)
+ *     try:
+ *         buf_data = <char*>py_buf.buf             # <<<<<<<<<<<<<<
+ *         res = uparser.http_parser_parse_url(buf_data, py_buf.len, 0, parsed)
+ * 
+ */
+    __pyx_v_buf_data = ((char *)__pyx_v_py_buf.buf);
+
+    /* "httptools/parser/url_parser.pyx":67
+ *     try:
+ *         buf_data = <char*>py_buf.buf
+ *         res = uparser.http_parser_parse_url(buf_data, py_buf.len, 0, parsed)             # <<<<<<<<<<<<<<
+ * 
+ *         if res == 0:
+ */
+    __pyx_v_res = http_parser_parse_url(__pyx_v_buf_data, __pyx_v_py_buf.len, 0, __pyx_v_parsed);
+
+    /* "httptools/parser/url_parser.pyx":69
+ *         res = uparser.http_parser_parse_url(buf_data, py_buf.len, 0, parsed)
+ * 
+ *         if res == 0:             # <<<<<<<<<<<<<<
+ *             if parsed.field_set & (1 << uparser.UF_SCHEMA):
+ *                 off = parsed.field_data[<int>uparser.UF_SCHEMA].off
+ */
+    __pyx_t_2 = ((__pyx_v_res == 0) != 0);
+    if (likely(__pyx_t_2)) {
+
+      /* "httptools/parser/url_parser.pyx":70
+ * 
+ *         if res == 0:
+ *             if parsed.field_set & (1 << uparser.UF_SCHEMA):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_SCHEMA].off
+ *                 ln = parsed.field_data[<int>uparser.UF_SCHEMA].len
+ */
+      __pyx_t_2 = ((__pyx_v_parsed->field_set & (1 << UF_SCHEMA)) != 0);
+      if (__pyx_t_2) {
+
+        /* "httptools/parser/url_parser.pyx":71
+ *         if res == 0:
+ *             if parsed.field_set & (1 << uparser.UF_SCHEMA):
+ *                 off = parsed.field_data[<int>uparser.UF_SCHEMA].off             # <<<<<<<<<<<<<<
+ *                 ln = parsed.field_data[<int>uparser.UF_SCHEMA].len
+ *                 schema = buf_data[off:off+ln]
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_SCHEMA)]).off;
+        __pyx_v_off = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":72
+ *             if parsed.field_set & (1 << uparser.UF_SCHEMA):
+ *                 off = parsed.field_data[<int>uparser.UF_SCHEMA].off
+ *                 ln = parsed.field_data[<int>uparser.UF_SCHEMA].len             # <<<<<<<<<<<<<<
+ *                 schema = buf_data[off:off+ln]
+ * 
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_SCHEMA)]).len;
+        __pyx_v_ln = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":73
+ *                 off = parsed.field_data[<int>uparser.UF_SCHEMA].off
+ *                 ln = parsed.field_data[<int>uparser.UF_SCHEMA].len
+ *                 schema = buf_data[off:off+ln]             # <<<<<<<<<<<<<<
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_HOST):
+ */
+        __pyx_t_4 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_buf_data + __pyx_v_off, (__pyx_v_off + __pyx_v_ln) - __pyx_v_off); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 73, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF_SET(__pyx_v_schema, ((PyObject*)__pyx_t_4));
+        __pyx_t_4 = 0;
+
+        /* "httptools/parser/url_parser.pyx":70
+ * 
+ *         if res == 0:
+ *             if parsed.field_set & (1 << uparser.UF_SCHEMA):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_SCHEMA].off
+ *                 ln = parsed.field_data[<int>uparser.UF_SCHEMA].len
+ */
+      }
+
+      /* "httptools/parser/url_parser.pyx":75
+ *                 schema = buf_data[off:off+ln]
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_HOST):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_HOST].off
+ *                 ln = parsed.field_data[<int>uparser.UF_HOST].len
+ */
+      __pyx_t_2 = ((__pyx_v_parsed->field_set & (1 << UF_HOST)) != 0);
+      if (__pyx_t_2) {
+
+        /* "httptools/parser/url_parser.pyx":76
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_HOST):
+ *                 off = parsed.field_data[<int>uparser.UF_HOST].off             # <<<<<<<<<<<<<<
+ *                 ln = parsed.field_data[<int>uparser.UF_HOST].len
+ *                 host = buf_data[off:off+ln]
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_HOST)]).off;
+        __pyx_v_off = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":77
+ *             if parsed.field_set & (1 << uparser.UF_HOST):
+ *                 off = parsed.field_data[<int>uparser.UF_HOST].off
+ *                 ln = parsed.field_data[<int>uparser.UF_HOST].len             # <<<<<<<<<<<<<<
+ *                 host = buf_data[off:off+ln]
+ * 
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_HOST)]).len;
+        __pyx_v_ln = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":78
+ *                 off = parsed.field_data[<int>uparser.UF_HOST].off
+ *                 ln = parsed.field_data[<int>uparser.UF_HOST].len
+ *                 host = buf_data[off:off+ln]             # <<<<<<<<<<<<<<
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_PORT):
+ */
+        __pyx_t_4 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_buf_data + __pyx_v_off, (__pyx_v_off + __pyx_v_ln) - __pyx_v_off); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 78, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF_SET(__pyx_v_host, ((PyObject*)__pyx_t_4));
+        __pyx_t_4 = 0;
+
+        /* "httptools/parser/url_parser.pyx":75
+ *                 schema = buf_data[off:off+ln]
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_HOST):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_HOST].off
+ *                 ln = parsed.field_data[<int>uparser.UF_HOST].len
+ */
+      }
+
+      /* "httptools/parser/url_parser.pyx":80
+ *                 host = buf_data[off:off+ln]
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_PORT):             # <<<<<<<<<<<<<<
+ *                 port = parsed.port
+ * 
+ */
+      __pyx_t_2 = ((__pyx_v_parsed->field_set & (1 << UF_PORT)) != 0);
+      if (__pyx_t_2) {
+
+        /* "httptools/parser/url_parser.pyx":81
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_PORT):
+ *                 port = parsed.port             # <<<<<<<<<<<<<<
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_PATH):
+ */
+        __pyx_t_4 = __Pyx_PyInt_From_uint16_t(__pyx_v_parsed->port); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 81, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF_SET(__pyx_v_port, __pyx_t_4);
+        __pyx_t_4 = 0;
+
+        /* "httptools/parser/url_parser.pyx":80
+ *                 host = buf_data[off:off+ln]
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_PORT):             # <<<<<<<<<<<<<<
+ *                 port = parsed.port
+ * 
+ */
+      }
+
+      /* "httptools/parser/url_parser.pyx":83
+ *                 port = parsed.port
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_PATH):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_PATH].off
+ *                 ln = parsed.field_data[<int>uparser.UF_PATH].len
+ */
+      __pyx_t_2 = ((__pyx_v_parsed->field_set & (1 << UF_PATH)) != 0);
+      if (__pyx_t_2) {
+
+        /* "httptools/parser/url_parser.pyx":84
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_PATH):
+ *                 off = parsed.field_data[<int>uparser.UF_PATH].off             # <<<<<<<<<<<<<<
+ *                 ln = parsed.field_data[<int>uparser.UF_PATH].len
+ *                 path = buf_data[off:off+ln]
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_PATH)]).off;
+        __pyx_v_off = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":85
+ *             if parsed.field_set & (1 << uparser.UF_PATH):
+ *                 off = parsed.field_data[<int>uparser.UF_PATH].off
+ *                 ln = parsed.field_data[<int>uparser.UF_PATH].len             # <<<<<<<<<<<<<<
+ *                 path = buf_data[off:off+ln]
+ * 
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_PATH)]).len;
+        __pyx_v_ln = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":86
+ *                 off = parsed.field_data[<int>uparser.UF_PATH].off
+ *                 ln = parsed.field_data[<int>uparser.UF_PATH].len
+ *                 path = buf_data[off:off+ln]             # <<<<<<<<<<<<<<
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_QUERY):
+ */
+        __pyx_t_4 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_buf_data + __pyx_v_off, (__pyx_v_off + __pyx_v_ln) - __pyx_v_off); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 86, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF_SET(__pyx_v_path, ((PyObject*)__pyx_t_4));
+        __pyx_t_4 = 0;
+
+        /* "httptools/parser/url_parser.pyx":83
+ *                 port = parsed.port
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_PATH):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_PATH].off
+ *                 ln = parsed.field_data[<int>uparser.UF_PATH].len
+ */
+      }
+
+      /* "httptools/parser/url_parser.pyx":88
+ *                 path = buf_data[off:off+ln]
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_QUERY):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_QUERY].off
+ *                 ln = parsed.field_data[<int>uparser.UF_QUERY].len
+ */
+      __pyx_t_2 = ((__pyx_v_parsed->field_set & (1 << UF_QUERY)) != 0);
+      if (__pyx_t_2) {
+
+        /* "httptools/parser/url_parser.pyx":89
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_QUERY):
+ *                 off = parsed.field_data[<int>uparser.UF_QUERY].off             # <<<<<<<<<<<<<<
+ *                 ln = parsed.field_data[<int>uparser.UF_QUERY].len
+ *                 query = buf_data[off:off+ln]
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_QUERY)]).off;
+        __pyx_v_off = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":90
+ *             if parsed.field_set & (1 << uparser.UF_QUERY):
+ *                 off = parsed.field_data[<int>uparser.UF_QUERY].off
+ *                 ln = parsed.field_data[<int>uparser.UF_QUERY].len             # <<<<<<<<<<<<<<
+ *                 query = buf_data[off:off+ln]
+ * 
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_QUERY)]).len;
+        __pyx_v_ln = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":91
+ *                 off = parsed.field_data[<int>uparser.UF_QUERY].off
+ *                 ln = parsed.field_data[<int>uparser.UF_QUERY].len
+ *                 query = buf_data[off:off+ln]             # <<<<<<<<<<<<<<
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_FRAGMENT):
+ */
+        __pyx_t_4 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_buf_data + __pyx_v_off, (__pyx_v_off + __pyx_v_ln) - __pyx_v_off); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 91, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF_SET(__pyx_v_query, ((PyObject*)__pyx_t_4));
+        __pyx_t_4 = 0;
+
+        /* "httptools/parser/url_parser.pyx":88
+ *                 path = buf_data[off:off+ln]
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_QUERY):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_QUERY].off
+ *                 ln = parsed.field_data[<int>uparser.UF_QUERY].len
+ */
+      }
+
+      /* "httptools/parser/url_parser.pyx":93
+ *                 query = buf_data[off:off+ln]
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_FRAGMENT):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_FRAGMENT].off
+ *                 ln = parsed.field_data[<int>uparser.UF_FRAGMENT].len
+ */
+      __pyx_t_2 = ((__pyx_v_parsed->field_set & (1 << UF_FRAGMENT)) != 0);
+      if (__pyx_t_2) {
+
+        /* "httptools/parser/url_parser.pyx":94
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_FRAGMENT):
+ *                 off = parsed.field_data[<int>uparser.UF_FRAGMENT].off             # <<<<<<<<<<<<<<
+ *                 ln = parsed.field_data[<int>uparser.UF_FRAGMENT].len
+ *                 fragment = buf_data[off:off+ln]
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_FRAGMENT)]).off;
+        __pyx_v_off = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":95
+ *             if parsed.field_set & (1 << uparser.UF_FRAGMENT):
+ *                 off = parsed.field_data[<int>uparser.UF_FRAGMENT].off
+ *                 ln = parsed.field_data[<int>uparser.UF_FRAGMENT].len             # <<<<<<<<<<<<<<
+ *                 fragment = buf_data[off:off+ln]
+ * 
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_FRAGMENT)]).len;
+        __pyx_v_ln = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":96
+ *                 off = parsed.field_data[<int>uparser.UF_FRAGMENT].off
+ *                 ln = parsed.field_data[<int>uparser.UF_FRAGMENT].len
+ *                 fragment = buf_data[off:off+ln]             # <<<<<<<<<<<<<<
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_USERINFO):
+ */
+        __pyx_t_4 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_buf_data + __pyx_v_off, (__pyx_v_off + __pyx_v_ln) - __pyx_v_off); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 96, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF_SET(__pyx_v_fragment, ((PyObject*)__pyx_t_4));
+        __pyx_t_4 = 0;
+
+        /* "httptools/parser/url_parser.pyx":93
+ *                 query = buf_data[off:off+ln]
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_FRAGMENT):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_FRAGMENT].off
+ *                 ln = parsed.field_data[<int>uparser.UF_FRAGMENT].len
+ */
+      }
+
+      /* "httptools/parser/url_parser.pyx":98
+ *                 fragment = buf_data[off:off+ln]
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_USERINFO):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_USERINFO].off
+ *                 ln = parsed.field_data[<int>uparser.UF_USERINFO].len
+ */
+      __pyx_t_2 = ((__pyx_v_parsed->field_set & (1 << UF_USERINFO)) != 0);
+      if (__pyx_t_2) {
+
+        /* "httptools/parser/url_parser.pyx":99
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_USERINFO):
+ *                 off = parsed.field_data[<int>uparser.UF_USERINFO].off             # <<<<<<<<<<<<<<
+ *                 ln = parsed.field_data[<int>uparser.UF_USERINFO].len
+ *                 userinfo = buf_data[off:off+ln]
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_USERINFO)]).off;
+        __pyx_v_off = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":100
+ *             if parsed.field_set & (1 << uparser.UF_USERINFO):
+ *                 off = parsed.field_data[<int>uparser.UF_USERINFO].off
+ *                 ln = parsed.field_data[<int>uparser.UF_USERINFO].len             # <<<<<<<<<<<<<<
+ *                 userinfo = buf_data[off:off+ln]
+ * 
+ */
+        __pyx_t_3 = (__pyx_v_parsed->field_data[((int)UF_USERINFO)]).len;
+        __pyx_v_ln = __pyx_t_3;
+
+        /* "httptools/parser/url_parser.pyx":101
+ *                 off = parsed.field_data[<int>uparser.UF_USERINFO].off
+ *                 ln = parsed.field_data[<int>uparser.UF_USERINFO].len
+ *                 userinfo = buf_data[off:off+ln]             # <<<<<<<<<<<<<<
+ * 
+ *             return URL(schema, host, port, path, query, fragment, userinfo)
+ */
+        __pyx_t_4 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_buf_data + __pyx_v_off, (__pyx_v_off + __pyx_v_ln) - __pyx_v_off); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 101, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF_SET(__pyx_v_userinfo, ((PyObject*)__pyx_t_4));
+        __pyx_t_4 = 0;
+
+        /* "httptools/parser/url_parser.pyx":98
+ *                 fragment = buf_data[off:off+ln]
+ * 
+ *             if parsed.field_set & (1 << uparser.UF_USERINFO):             # <<<<<<<<<<<<<<
+ *                 off = parsed.field_data[<int>uparser.UF_USERINFO].off
+ *                 ln = parsed.field_data[<int>uparser.UF_USERINFO].len
+ */
+      }
+
+      /* "httptools/parser/url_parser.pyx":103
+ *                 userinfo = buf_data[off:off+ln]
+ * 
+ *             return URL(schema, host, port, path, query, fragment, userinfo)             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise HttpParserInvalidURLError("invalid url {!r}".format(url))
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_t_4 = PyTuple_New(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 103, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_v_schema);
+      __Pyx_GIVEREF(__pyx_v_schema);
+      PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_schema);
+      __Pyx_INCREF(__pyx_v_host);
+      __Pyx_GIVEREF(__pyx_v_host);
+      PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_host);
+      __Pyx_INCREF(__pyx_v_port);
+      __Pyx_GIVEREF(__pyx_v_port);
+      PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_port);
+      __Pyx_INCREF(__pyx_v_path);
+      __Pyx_GIVEREF(__pyx_v_path);
+      PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_path);
+      __Pyx_INCREF(__pyx_v_query);
+      __Pyx_GIVEREF(__pyx_v_query);
+      PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_v_query);
+      __Pyx_INCREF(__pyx_v_fragment);
+      __Pyx_GIVEREF(__pyx_v_fragment);
+      PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_v_fragment);
+      __Pyx_INCREF(__pyx_v_userinfo);
+      __Pyx_GIVEREF(__pyx_v_userinfo);
+      PyTuple_SET_ITEM(__pyx_t_4, 6, __pyx_v_userinfo);
+      __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9httptools_6parser_10url_parser_URL), __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 103, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_r = __pyx_t_5;
+      __pyx_t_5 = 0;
+      goto __pyx_L3_return;
+
+      /* "httptools/parser/url_parser.pyx":69
+ *         res = uparser.http_parser_parse_url(buf_data, py_buf.len, 0, parsed)
+ * 
+ *         if res == 0:             # <<<<<<<<<<<<<<
+ *             if parsed.field_set & (1 << uparser.UF_SCHEMA):
+ *                 off = parsed.field_data[<int>uparser.UF_SCHEMA].off
+ */
+    }
+
+    /* "httptools/parser/url_parser.pyx":105
+ *             return URL(schema, host, port, path, query, fragment, userinfo)
+ *         else:
+ *             raise HttpParserInvalidURLError("invalid url {!r}".format(url))             # <<<<<<<<<<<<<<
+ *     finally:
+ *         PyBuffer_Release(&py_buf)
+ */
+    /*else*/ {
+      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_HttpParserInvalidURLError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 105, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_invalid_url_r, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 105, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_8 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+        if (likely(__pyx_t_8)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+          __Pyx_INCREF(__pyx_t_8);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_7, function);
+        }
+      }
+      __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_v_url) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_url);
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 105, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_4, function);
+        }
+      }
+      __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 105, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __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(1, 105, __pyx_L4_error)
+    }
+  }
+
+  /* "httptools/parser/url_parser.pyx":107
+ *             raise HttpParserInvalidURLError("invalid url {!r}".format(url))
+ *     finally:
+ *         PyBuffer_Release(&py_buf)             # <<<<<<<<<<<<<<
+ *         PyMem_Free(parsed)
+ */
+  /*finally:*/ {
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __Pyx_XGOTREF(__pyx_t_15);
+      __Pyx_XGOTREF(__pyx_t_16);
+      __pyx_t_1 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename;
+      {
+        PyBuffer_Release((&__pyx_v_py_buf));
+
+        /* "httptools/parser/url_parser.pyx":108
+ *     finally:
+ *         PyBuffer_Release(&py_buf)
+ *         PyMem_Free(parsed)             # <<<<<<<<<<<<<<
+ */
+        PyMem_Free(__pyx_v_parsed);
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+      }
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __Pyx_XGIVEREF(__pyx_t_12);
+      __Pyx_XGIVEREF(__pyx_t_13);
+      __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+      __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+      __pyx_lineno = __pyx_t_1; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10;
+      goto __pyx_L1_error;
+    }
+    __pyx_L3_return: {
+      __pyx_t_16 = __pyx_r;
+      __pyx_r = 0;
+
+      /* "httptools/parser/url_parser.pyx":107
+ *             raise HttpParserInvalidURLError("invalid url {!r}".format(url))
+ *     finally:
+ *         PyBuffer_Release(&py_buf)             # <<<<<<<<<<<<<<
+ *         PyMem_Free(parsed)
+ */
+      PyBuffer_Release((&__pyx_v_py_buf));
+
+      /* "httptools/parser/url_parser.pyx":108
+ *     finally:
+ *         PyBuffer_Release(&py_buf)
+ *         PyMem_Free(parsed)             # <<<<<<<<<<<<<<
+ */
+      PyMem_Free(__pyx_v_parsed);
+      __pyx_r = __pyx_t_16;
+      __pyx_t_16 = 0;
+      goto __pyx_L0;
+    }
+  }
+
+  /* "httptools/parser/url_parser.pyx":43
+ * 
+ * 
+ * def parse_url(url):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         Py_buffer py_buf
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("httptools.parser.url_parser.parse_url", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_schema);
+  __Pyx_XDECREF(__pyx_v_host);
+  __Pyx_XDECREF(__pyx_v_port);
+  __Pyx_XDECREF(__pyx_v_path);
+  __Pyx_XDECREF(__pyx_v_query);
+  __Pyx_XDECREF(__pyx_v_fragment);
+  __Pyx_XDECREF(__pyx_v_userinfo);
+  __Pyx_XDECREF(__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static struct __pyx_obj_9httptools_6parser_10url_parser_URL *__pyx_freelist_9httptools_6parser_10url_parser_URL[250];
+static int __pyx_freecount_9httptools_6parser_10url_parser_URL = 0;
+
+static PyObject *__pyx_tp_new_9httptools_6parser_10url_parser_URL(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_9httptools_6parser_10url_parser_URL *p;
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_9httptools_6parser_10url_parser_URL > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_9httptools_6parser_10url_parser_URL)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    o = (PyObject*)__pyx_freelist_9httptools_6parser_10url_parser_URL[--__pyx_freecount_9httptools_6parser_10url_parser_URL];
+    memset(o, 0, sizeof(struct __pyx_obj_9httptools_6parser_10url_parser_URL));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    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_9httptools_6parser_10url_parser_URL *)o);
+  p->schema = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->host = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->port = Py_None; Py_INCREF(Py_None);
+  p->path = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->query = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->fragment = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->userinfo = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_9httptools_6parser_10url_parser_3URL_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_9httptools_6parser_10url_parser_URL(PyObject *o) {
+  struct __pyx_obj_9httptools_6parser_10url_parser_URL *p = (struct __pyx_obj_9httptools_6parser_10url_parser_URL *)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);
+  Py_CLEAR(p->schema);
+  Py_CLEAR(p->host);
+  Py_CLEAR(p->port);
+  Py_CLEAR(p->path);
+  Py_CLEAR(p->query);
+  Py_CLEAR(p->fragment);
+  Py_CLEAR(p->userinfo);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_9httptools_6parser_10url_parser_URL < 250) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_9httptools_6parser_10url_parser_URL)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    __pyx_freelist_9httptools_6parser_10url_parser_URL[__pyx_freecount_9httptools_6parser_10url_parser_URL++] = ((struct __pyx_obj_9httptools_6parser_10url_parser_URL *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_9httptools_6parser_10url_parser_URL(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_9httptools_6parser_10url_parser_URL *p = (struct __pyx_obj_9httptools_6parser_10url_parser_URL *)o;
+  if (p->port) {
+    e = (*v)(p->port, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_9httptools_6parser_10url_parser_URL(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_9httptools_6parser_10url_parser_URL *p = (struct __pyx_obj_9httptools_6parser_10url_parser_URL *)o;
+  tmp = ((PyObject*)p->port);
+  p->port = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyObject *__pyx_getprop_9httptools_6parser_10url_parser_3URL_schema(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_9httptools_6parser_10url_parser_3URL_6schema_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_9httptools_6parser_10url_parser_3URL_host(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_9httptools_6parser_10url_parser_3URL_4host_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_9httptools_6parser_10url_parser_3URL_port(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_9httptools_6parser_10url_parser_3URL_4port_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_9httptools_6parser_10url_parser_3URL_path(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_9httptools_6parser_10url_parser_3URL_4path_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_9httptools_6parser_10url_parser_3URL_query(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_9httptools_6parser_10url_parser_3URL_5query_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_9httptools_6parser_10url_parser_3URL_fragment(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_9httptools_6parser_10url_parser_3URL_8fragment_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_9httptools_6parser_10url_parser_3URL_userinfo(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_9httptools_6parser_10url_parser_3URL_8userinfo_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_9httptools_6parser_10url_parser_URL[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_9httptools_6parser_10url_parser_3URL_5__reduce_cython__, METH_NOARGS, 0},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_9httptools_6parser_10url_parser_3URL_7__setstate_cython__, METH_O, 0},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_9httptools_6parser_10url_parser_URL[] = {
+  {(char *)"schema", __pyx_getprop_9httptools_6parser_10url_parser_3URL_schema, 0, (char *)0, 0},
+  {(char *)"host", __pyx_getprop_9httptools_6parser_10url_parser_3URL_host, 0, (char *)0, 0},
+  {(char *)"port", __pyx_getprop_9httptools_6parser_10url_parser_3URL_port, 0, (char *)0, 0},
+  {(char *)"path", __pyx_getprop_9httptools_6parser_10url_parser_3URL_path, 0, (char *)0, 0},
+  {(char *)"query", __pyx_getprop_9httptools_6parser_10url_parser_3URL_query, 0, (char *)0, 0},
+  {(char *)"fragment", __pyx_getprop_9httptools_6parser_10url_parser_3URL_fragment, 0, (char *)0, 0},
+  {(char *)"userinfo", __pyx_getprop_9httptools_6parser_10url_parser_3URL_userinfo, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9httptools_6parser_10url_parser_URL = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "httptools.parser.url_parser.URL", /*tp_name*/
+  sizeof(struct __pyx_obj_9httptools_6parser_10url_parser_URL), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_9httptools_6parser_10url_parser_URL, /*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
+  __pyx_pw_9httptools_6parser_10url_parser_3URL_3__repr__, /*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_9httptools_6parser_10url_parser_URL, /*tp_traverse*/
+  __pyx_tp_clear_9httptools_6parser_10url_parser_URL, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_9httptools_6parser_10url_parser_URL, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_9httptools_6parser_10url_parser_URL, /*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_9httptools_6parser_10url_parser_URL, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #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_url_parser(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_url_parser},
+  {0, NULL}
+};
+#endif
+
+static struct PyModuleDef __pyx_moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "url_parser",
+    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
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+    #define CYTHON_SMALL_CODE __attribute__((cold))
+#else
+    #define CYTHON_SMALL_CODE
+#endif
+#endif
+
+static __Pyx_StringTabEntry __pyx_string_tab[] = {
+  {&__pyx_n_s_HttpParserInvalidURLError, __pyx_k_HttpParserInvalidURLError, sizeof(__pyx_k_HttpParserInvalidURLError), 0, 0, 1, 1},
+  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+  {&__pyx_n_s_URL, __pyx_k_URL, sizeof(__pyx_k_URL), 0, 0, 1, 1},
+  {&__pyx_kp_u_URL_schema_r_host_r_port_r_path, __pyx_k_URL_schema_r_host_r_port_r_path, sizeof(__pyx_k_URL_schema_r_host_r_port_r_path), 0, 1, 0, 0},
+  {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1},
+  {&__pyx_n_s_buf_data, __pyx_k_buf_data, sizeof(__pyx_k_buf_data), 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_errors, __pyx_k_errors, sizeof(__pyx_k_errors), 0, 0, 1, 1},
+  {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1},
+  {&__pyx_n_s_fragment, __pyx_k_fragment, sizeof(__pyx_k_fragment), 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_httptools_parser_url_parser, __pyx_k_httptools_parser_url_parser, sizeof(__pyx_k_httptools_parser_url_parser), 0, 0, 1, 1},
+  {&__pyx_kp_s_httptools_parser_url_parser_pyx, __pyx_k_httptools_parser_url_parser_pyx, sizeof(__pyx_k_httptools_parser_url_parser_pyx), 0, 0, 1, 0},
+  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+  {&__pyx_kp_u_invalid_url_r, __pyx_k_invalid_url_r, sizeof(__pyx_k_invalid_url_r), 0, 1, 0, 0},
+  {&__pyx_n_s_ln, __pyx_k_ln, sizeof(__pyx_k_ln), 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_off, __pyx_k_off, sizeof(__pyx_k_off), 0, 0, 1, 1},
+  {&__pyx_n_s_parse_url, __pyx_k_parse_url, sizeof(__pyx_k_parse_url), 0, 0, 1, 1},
+  {&__pyx_n_u_parse_url, __pyx_k_parse_url, sizeof(__pyx_k_parse_url), 0, 1, 0, 1},
+  {&__pyx_n_s_parsed, __pyx_k_parsed, sizeof(__pyx_k_parsed), 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_py_buf, __pyx_k_py_buf, sizeof(__pyx_k_py_buf), 0, 0, 1, 1},
+  {&__pyx_n_s_query, __pyx_k_query, sizeof(__pyx_k_query), 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_res, __pyx_k_res, sizeof(__pyx_k_res), 0, 0, 1, 1},
+  {&__pyx_n_s_result, __pyx_k_result, sizeof(__pyx_k_result), 0, 0, 1, 1},
+  {&__pyx_n_s_schema, __pyx_k_schema, sizeof(__pyx_k_schema), 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_url, __pyx_k_url, sizeof(__pyx_k_url), 0, 0, 1, 1},
+  {&__pyx_n_s_userinfo, __pyx_k_userinfo, sizeof(__pyx_k_userinfo), 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)
+  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);
+
+  /* "httptools/parser/url_parser.pyx":13
+ * from . cimport url_cparser as uparser
+ * 
+ * __all__ = ('parse_url',)             # <<<<<<<<<<<<<<
+ * 
+ * @cython.freelist(250)
+ */
+  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_n_u_parse_url); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 13, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+
+  /* "httptools/parser/url_parser.pyx":43
+ * 
+ * 
+ * def parse_url(url):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         Py_buffer py_buf
+ */
+  __pyx_tuple__4 = PyTuple_Pack(15, __pyx_n_s_url, __pyx_n_s_py_buf, __pyx_n_s_buf_data, __pyx_n_s_parsed, __pyx_n_s_res, __pyx_n_s_schema, __pyx_n_s_host, __pyx_n_s_port, __pyx_n_s_path, __pyx_n_s_query, __pyx_n_s_fragment, __pyx_n_s_userinfo, __pyx_n_s_result, __pyx_n_s_off, __pyx_n_s_ln); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
+  __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(1, 0, 15, 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_httptools_parser_url_parser_pyx, __pyx_n_s_parse_url, 43, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(1, 43, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+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;
+}
+
+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 (PyType_Ready(&__pyx_type_9httptools_6parser_10url_parser_URL) < 0) __PYX_ERR(1, 16, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_9httptools_6parser_10url_parser_URL.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9httptools_6parser_10url_parser_URL.tp_dictoffset && __pyx_type_9httptools_6parser_10url_parser_URL.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_9httptools_6parser_10url_parser_URL.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_URL, (PyObject *)&__pyx_type_9httptools_6parser_10url_parser_URL) < 0) __PYX_ERR(1, 16, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9httptools_6parser_10url_parser_URL) < 0) __PYX_ERR(1, 16, __pyx_L1_error)
+  __pyx_ptype_9httptools_6parser_10url_parser_URL = &__pyx_type_9httptools_6parser_10url_parser_URL;
+  __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(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_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
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
+  /*--- Function import code ---*/
+  __Pyx_RefNannyFinishContext();
+  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
+#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 initurl_parser(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC initurl_parser(void)
+#else
+__Pyx_PyMODINIT_FUNC PyInit_url_parser(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC PyInit_url_parser(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;
+}
+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);
+        }
+        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, 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;
+}
+
+
+static CYTHON_SMALL_CODE int __pyx_pymod_exec_url_parser(PyObject *__pyx_pyinit_module)
+#endif
+#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 'url_parser' 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");
+}
+#endif
+  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_url_parser(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("url_parser", __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_httptools__parser__url_parser) {
+    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __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, "httptools.parser.url_parser")) {
+      if (unlikely(PyDict_SetItemString(modules, "httptools.parser.url_parser", __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();
+  (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)
+  (void)__Pyx_modinit_variable_import_code();
+  (void)__Pyx_modinit_function_import_code();
+  /*--- Execution code ---*/
+  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+  if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+
+  /* "httptools/parser/url_parser.pyx":8
+ *                      Py_buffer
+ * 
+ * from .errors import HttpParserInvalidURLError             # <<<<<<<<<<<<<<
+ * 
+ * cimport cython
+ */
+  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_n_s_HttpParserInvalidURLError);
+  __Pyx_GIVEREF(__pyx_n_s_HttpParserInvalidURLError);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_HttpParserInvalidURLError);
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_errors, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 8, __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_HttpParserInvalidURLError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HttpParserInvalidURLError, __pyx_t_1) < 0) __PYX_ERR(1, 8, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "httptools/parser/url_parser.pyx":13
+ * from . cimport url_cparser as uparser
+ * 
+ * __all__ = ('parse_url',)             # <<<<<<<<<<<<<<
+ * 
+ * @cython.freelist(250)
+ */
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_tuple__3) < 0) __PYX_ERR(1, 13, __pyx_L1_error)
+
+  /* "httptools/parser/url_parser.pyx":43
+ * 
+ * 
+ * def parse_url(url):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         Py_buffer py_buf
+ */
+  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_9httptools_6parser_10url_parser_1parse_url, NULL, __pyx_n_s_httptools_parser_url_parser); 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_parse_url, __pyx_t_2) < 0) __PYX_ERR(1, 43, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "httptools/parser/url_parser.pyx":1
+ * #cython: language_level=3             # <<<<<<<<<<<<<<
+ * 
+ * from __future__ import print_function
+ */
+  __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) {
+      __Pyx_AddTraceback("init httptools.parser.url_parser", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    Py_CLEAR(__pyx_m);
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init httptools.parser.url_parser");
+  }
+  __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
+}
+
+/* --- 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
+
+/* 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)) {
+        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;
+}
+
+/* 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);
+}
+
+/* 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 **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++;
+                }
+            }
+        } 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++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    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;
+}
+
+/* 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
+    }
+    else {
+        if (likely(__Pyx_TypeCheck(obj, type))) 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;
+}
+
+/* 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;
+    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;
+}
+#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);
+    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_EnterRecursiveCall((char*)" while calling a Python object")) {
+        return NULL;
+    }
+    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
+#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);
+    }
+}
+#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");
+    }
+    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) {
+    __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;
+        }
+    }
+    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 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
+        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);
+        }
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#endif
+
+/* PyDictVersioning */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
+    PyObject **dictptr = NULL;
+    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
+    if (offset) {
+#if CYTHON_COMPILING_IN_CPYTHON
+        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
+#else
+        dictptr = _PyObject_GetDictPtr(obj);
+#endif
+    }
+    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
+}
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
+        return 0;
+    return obj_dict_version == __Pyx_get_object_dict_version(obj);
+}
+#endif
+
+/* GetModuleGlobalName */
+#if CYTHON_USE_DICT_VERSIONS
+static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
+#else
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
+#endif
+{
+    PyObject *result;
+#if !CYTHON_AVOID_BORROWED_REFS
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
+    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)) {
+        return __Pyx_NewRef(result);
+    } else if (unlikely(PyErr_Occurred())) {
+        return NULL;
+    }
+#else
+    result = PyDict_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+#endif
+#else
+    result = PyObject_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+    PyErr_Clear();
+#endif
+    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;
+}
+
+/* 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);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    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
+
+/* 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);
+    }
+#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
+        }
+    }
+    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
+
+/* 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, *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);
+#endif
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if 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;
+        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);
+#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
+    _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
+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) &&
+           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
+    _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 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;
+    #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
+
+/* 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);
+    }
+    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
+
+/* 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 */
+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 int __Pyx_setup_reduce(PyObject* type_obj) {
+    int ret = 0;
+    PyObject *object_reduce = NULL;
+    PyObject *object_reduce_ex = NULL;
+    PyObject *reduce = NULL;
+    PyObject *reduce_ex = NULL;
+    PyObject *reduce_cython = NULL;
+    PyObject *setstate = NULL;
+    PyObject *setstate_cython = NULL;
+#if CYTHON_USE_PYTYPE_LOOKUP
+    if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
+#else
+    if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
+#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;
+#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_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);
+#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;
+#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;
+#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;
+    }
+    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;
+    }
+    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 (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
+}
+#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;
+    }
+    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
+        }
+    }
+bad:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(py_import);
+    #endif
+    Py_XDECREF(empty_list);
+    Py_XDECREF(empty_dict);
+    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)) {
+        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;
+}
+
+/* CLineInTraceback */
+#ifndef CYTHON_CLINE_IN_TRACEBACK
+static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+    PyObject *use_cline;
+    PyObject *ptype, *pvalue, *ptraceback;
+#if CYTHON_COMPILING_IN_CPYTHON
+    PyObject **cython_runtime_dict;
+#endif
+    if (unlikely(!__pyx_cython_runtime)) {
+        return c_line;
+    }
+    __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
+#if CYTHON_COMPILING_IN_CPYTHON
+    cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
+    if (likely(cython_runtime_dict)) {
+        __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
+            use_cline, *cython_runtime_dict,
+            __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback))
+    } else
+#endif
+    {
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__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);
+      } else {
+        PyErr_Clear();
+        use_cline = NULL;
+      }
+    }
+    if (!use_cline) {
+        c_line = 0;
+        PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False);
+    }
+    else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
+        c_line = 0;
+    }
+    __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
+    return c_line;
+}
+#endif
+
+/* CodeObjectCache */
+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) {
+        return count;
+    }
+    while (start < end) {
+        mid = start + (end - start) / 2;
+        if (code_line < entries[mid].code_line) {
+            end = mid;
+        } else if (code_line > entries[mid].code_line) {
+             start = mid + 1;
+        } else {
+            return mid;
+        }
+    }
+    if (code_line <= entries[mid].code_line) {
+        return mid;
+    } else {
+        return mid + 1;
+    }
+}
+static PyCodeObject *__pyx_find_code_object(int code_line) {
+    PyCodeObject* code_object;
+    int pos;
+    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
+        return NULL;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
+        return NULL;
+    }
+    code_object = __pyx_code_cache.entries[pos].code_object;
+    Py_INCREF(code_object);
+    return code_object;
+}
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
+    int pos, i;
+    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    if (unlikely(!code_line)) {
+        return;
+    }
+    if (unlikely(!entries)) {
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (likely(entries)) {
+            __pyx_code_cache.entries = entries;
+            __pyx_code_cache.max_count = 64;
+            __pyx_code_cache.count = 1;
+            entries[0].code_line = code_line;
+            entries[0].code_object = code_object;
+            Py_INCREF(code_object);
+        }
+        return;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
+        PyCodeObject* tmp = entries[pos].code_object;
+        entries[pos].code_object = code_object;
+        Py_DECREF(tmp);
+        return;
+    }
+    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
+        int new_max = __pyx_code_cache.max_count + 64;
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
+            __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));
+        if (unlikely(!entries)) {
+            return;
+        }
+        __pyx_code_cache.entries = entries;
+        __pyx_code_cache.max_count = new_max;
+    }
+    for (i=__pyx_code_cache.count; i>pos; i--) {
+        entries[i] = entries[i-1];
+    }
+    entries[pos].code_line = code_line;
+    entries[pos].code_object = code_object;
+    __pyx_code_cache.count++;
+    Py_INCREF(code_object);
+}
+
+/* AddTraceback */
+#include "compile.h"
+#include "frameobject.h"
+#include "traceback.h"
+static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
+            const char *funcname, int c_line,
+            int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyObject *py_srcfile = 0;
+    PyObject *py_funcname = 0;
+    #if PY_MAJOR_VERSION < 3
+    py_srcfile = PyString_FromString(filename);
+    #else
+    py_srcfile = PyUnicode_FromString(filename);
+    #endif
+    if (!py_srcfile) goto bad;
+    if (c_line) {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #else
+        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #endif
+    }
+    else {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromString(funcname);
+        #else
+        py_funcname = PyUnicode_FromString(funcname);
+        #endif
+    }
+    if (!py_funcname) goto bad;
+    py_code = __Pyx_PyCode_New(
+        0,
+        0,
+        0,
+        0,
+        0,
+        __pyx_empty_bytes, /*PyObject *code,*/
+        __pyx_empty_tuple, /*PyObject *consts,*/
+        __pyx_empty_tuple, /*PyObject *names,*/
+        __pyx_empty_tuple, /*PyObject *varnames,*/
+        __pyx_empty_tuple, /*PyObject *freevars,*/
+        __pyx_empty_tuple, /*PyObject *cellvars,*/
+        py_srcfile,   /*PyObject *filename,*/
+        py_funcname,  /*PyObject *name,*/
+        py_line,
+        __pyx_empty_bytes  /*PyObject *lnotab*/
+    );
+    Py_DECREF(py_srcfile);
+    Py_DECREF(py_funcname);
+    return py_code;
+bad:
+    Py_XDECREF(py_srcfile);
+    Py_XDECREF(py_funcname);
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyFrameObject *py_frame = 0;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    if (c_line) {
+        c_line = __Pyx_CLineForTraceback(tstate, c_line);
+    }
+    py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
+    if (!py_code) {
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, c_line, py_line, filename);
+        if (!py_code) goto bad;
+        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
+    }
+    py_frame = PyFrame_New(
+        tstate,            /*PyThreadState *tstate,*/
+        py_code,           /*PyCodeObject *code,*/
+        __pyx_d,    /*PyObject *globals,*/
+        0                  /*PyObject *locals*/
+    );
+    if (!py_frame) goto bad;
+    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
+    PyTraceBack_Here(py_frame);
+bad:
+    Py_XDECREF(py_code);
+    Py_XDECREF(py_frame);
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint16_t(uint16_t value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const uint16_t neg_one = (uint16_t) -1, const_zero = (uint16_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(uint16_t) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(uint16_t) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(uint16_t) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(uint16_t) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(uint16_t) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(uint16_t),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(long) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(long) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(long),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPyVerify */
+#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
+#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
+#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
+    {\
+        func_type value = func_value;\
+        if (sizeof(target_type) < sizeof(func_type)) {\
+            if (unlikely(value != (func_type) (target_type) value)) {\
+                func_type zero = 0;\
+                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
+                    return (target_type) -1;\
+                if (is_unsigned && unlikely(value < zero))\
+                    goto raise_neg_overflow;\
+                else\
+                    goto raise_overflow;\
+            }\
+        }\
+        return (target_type) value;\
+    }
+
+/* CIntFromPy */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(long) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (long) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        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])
+                case 2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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;
+            }
+#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;
+            }
+#endif
+            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))
+#endif
+            }
+        } 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])
+                case -2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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))
+#ifdef HAVE_LONG_LONG
+            } 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");
+#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;
+            }
+#endif
+            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:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to long");
+    return (long) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to long");
+    return (long) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
+#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 PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(int) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        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])
+                case 2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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;
+            }
+#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;
+            }
+#endif
+            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))
+#endif
+            }
+        } 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])
+                case -2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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))
+#ifdef HAVE_LONG_LONG
+            } 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");
+#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);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            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:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to int");
+    return (int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to int");
+    return (int) -1;
+}
+
+/* FastTypeChecks */
+#if CYTHON_COMPILING_IN_CPYTHON
+static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
+    while (a) {
+        a = a->tp_base;
+        if (a == b)
+            return 1;
+    }
+    return b == &PyBaseObject_Type;
+}
+static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (a == b) return 1;
+    mro = a->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(a, b);
+}
+#if PY_MAJOR_VERSION == 2
+static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
+    PyObject *exception, *value, *tb;
+    int res;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&exception, &value, &tb);
+    res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0;
+    if (unlikely(res == -1)) {
+        PyErr_WriteUnraisable(err);
+        res = 0;
+    }
+    if (!res) {
+        res = PyObject_IsSubclass(err, exc_type2);
+        if (unlikely(res == -1)) {
+            PyErr_WriteUnraisable(err);
+            res = 0;
+        }
+    }
+    __Pyx_ErrRestore(exception, value, tb);
+    return res;
+}
+#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);
+    }
+    return res;
+}
+#endif
+static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    assert(PyExceptionClass_Check(exc_type));
+    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++) {
+        PyObject *t = PyTuple_GET_ITEM(tuple, i);
+        #if PY_MAJOR_VERSION < 3
+        if (likely(exc_type == t)) return 1;
+        #endif
+        if (likely(PyExceptionClass_Check(t))) {
+            if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
+        } else {
+        }
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
+    if (likely(err == exc_type)) return 1;
+    if (likely(PyExceptionClass_Check(err))) {
+        if (likely(PyExceptionClass_Check(exc_type))) {
+            return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
+        } else if (likely(PyTuple_Check(exc_type))) {
+            return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
+        } else {
+        }
+    }
+    return PyErr_GivenExceptionMatches(err, exc_type);
+}
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
+    assert(PyExceptionClass_Check(exc_type1));
+    assert(PyExceptionClass_Check(exc_type2));
+    if (likely(err == exc_type1 || err == exc_type2)) return 1;
+    if (likely(PyExceptionClass_Check(err))) {
+        return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
+    }
+    return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
+}
+#endif
+
+/* CheckBinaryVersion */
+static int __Pyx_check_binary_version(void) {
+    char ctversion[4], rtversion[4];
+    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
+    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
+    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
+        char message[200];
+        PyOS_snprintf(message, sizeof(message),
+                      "compiletime version %s of module '%.100s' "
+                      "does not match runtime version %s",
+                      ctversion, __Pyx_MODULE_NAME, rtversion);
+        return PyErr_WarnEx(NULL, message, 1);
+    }
+    return 0;
+}
+
+/* InitStrings */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
+    while (t->p) {
+        #if PY_MAJOR_VERSION < 3
+        if (t->is_unicode) {
+            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
+        } else if (t->intern) {
+            *t->p = PyString_InternFromString(t->s);
+        } 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;
+        ++t;
+    }
+    return 0;
+}
+
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+}
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
+    Py_ssize_t ignore;
+    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#if !CYTHON_PEP393_ENABLED
+static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    char* defenc_c;
+    PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
+    if (!defenc) return NULL;
+    defenc_c = PyBytes_AS_STRING(defenc);
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    {
+        char* end = defenc_c + PyBytes_GET_SIZE(defenc);
+        char* c;
+        for (c = defenc_c; c < end; c++) {
+            if ((unsigned char) (*c) >= 128) {
+                PyUnicode_AsASCIIString(o);
+                return NULL;
+            }
+        }
+    }
+#endif
+    *length = PyBytes_GET_SIZE(defenc);
+    return defenc_c;
+}
+#else
+static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    if (likely(PyUnicode_IS_ASCII(o))) {
+        *length = PyUnicode_GET_LENGTH(o);
+        return PyUnicode_AsUTF8(o);
+    } else {
+        PyUnicode_AsASCIIString(o);
+        return NULL;
+    }
+#else
+    return PyUnicode_AsUTF8AndSize(o, length);
+#endif
+}
+#endif
+#endif
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+    if (
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+            __Pyx_sys_getdefaultencoding_not_ascii &&
+#endif
+            PyUnicode_Check(o)) {
+        return __Pyx_PyUnicode_AsStringAndSize(o, length);
+    } else
+#endif
+#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+    if (PyByteArray_Check(o)) {
+        *length = PyByteArray_GET_SIZE(o);
+        return PyByteArray_AS_STRING(o);
+    } else
+#endif
+    {
+        char* result;
+        int r = PyBytes_AsStringAndSize(o, &result, length);
+        if (unlikely(r < 0)) {
+            return NULL;
+        } else {
+            return result;
+        }
+    }
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+   int is_true = x == Py_True;
+   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
+   else return PyObject_IsTrue(x);
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
+    int retval;
+    if (unlikely(!x)) return -1;
+    retval = __Pyx_PyObject_IsTrue(x);
+    Py_DECREF(x);
+    return retval;
+}
+static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+#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)) {
+            Py_DECREF(result);
+            return NULL;
+        }
+        return result;
+    }
+#endif
+    PyErr_Format(PyExc_TypeError,
+                 "__%.4s__ returned non-%.4s (type %.200s)",
+                 type_name, type_name, Py_TYPE(result)->tp_name);
+    Py_DECREF(result);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
+#if CYTHON_USE_TYPE_SLOTS
+  PyNumberMethods *m;
+#endif
+  const char *name = NULL;
+  PyObject *res = NULL;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_Check(x) || PyLong_Check(x)))
+#else
+  if (likely(PyLong_Check(x)))
+#endif
+    return __Pyx_NewRef(x);
+#if CYTHON_USE_TYPE_SLOTS
+  m = Py_TYPE(x)->tp_as_number;
+  #if PY_MAJOR_VERSION < 3
+  if (m && m->nb_int) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  else if (m && m->nb_long) {
+    name = "long";
+    res = m->nb_long(x);
+  }
+  #else
+  if (likely(m && m->nb_int)) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  #endif
+#else
+  if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
+    res = PyNumber_Int(x);
+  }
+#endif
+  if (likely(res)) {
+#if PY_MAJOR_VERSION < 3
+    if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) {
+#else
+    if (unlikely(!PyLong_CheckExact(res))) {
+#endif
+        return __Pyx_PyNumber_IntOrLongWrongResultType(res, name);
+    }
+  }
+  else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_TypeError,
+                    "an integer is required");
+  }
+  return res;
+}
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+  Py_ssize_t ival;
+  PyObject *x;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_CheckExact(b))) {
+    if (sizeof(Py_ssize_t) >= sizeof(long))
+        return PyInt_AS_LONG(b);
+    else
+        return PyInt_AsSsize_t(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;
+    } else {
+      switch (size) {
+         case 2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((((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(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return -(Py_ssize_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
+    return PyLong_AsSsize_t(b);
+  }
+  x = PyNumber_Index(b);
+  if (!x) return -1;
+  ival = PyInt_AsSsize_t(x);
+  Py_DECREF(x);
+  return ival;
+}
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
+  return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);
+}
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+    return PyInt_FromSize_t(ival);
+}
+
+
+#endif /* Py_PYTHON_H */
diff --git a/myenv/lib/python3.9/site-packages/httptools/parser/url_parser.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/httptools/parser/url_parser.cpython-39-darwin.so
new file mode 100755
index 0000000..0f73120
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/httptools/parser/url_parser.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/LICENSE.md b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/LICENSE.md
new file mode 100644
index 0000000..ab79d16
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/LICENSE.md
@@ -0,0 +1,12 @@
+Copyright © 2019, [Encode OSS Ltd](https://www.encode.io/).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/METADATA
new file mode 100644
index 0000000..7ca65d0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/METADATA
@@ -0,0 +1,1145 @@
+Metadata-Version: 2.1
+Name: httpx
+Version: 0.23.0
+Summary: The next generation HTTP client.
+Home-page: https://github.com/encode/httpx
+Author: Tom Christie
+Author-email: tom@tomchristie.com
+License: BSD
+Project-URL: Changelog, https://github.com/encode/httpx/blob/master/CHANGELOG.md
+Project-URL: Documentation, https://www.python-httpx.org
+Project-URL: Source, https://github.com/encode/httpx
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: certifi
+Requires-Dist: sniffio
+Requires-Dist: rfc3986[idna2008] (<2,>=1.3)
+Requires-Dist: httpcore (<0.16.0,>=0.15.0)
+Provides-Extra: brotli
+Requires-Dist: brotlicffi ; (platform_python_implementation != "CPython") and extra == 'brotli'
+Requires-Dist: brotli ; (platform_python_implementation == "CPython") and extra == 'brotli'
+Provides-Extra: cli
+Requires-Dist: click (==8.*) ; extra == 'cli'
+Requires-Dist: rich (<13,>=10) ; extra == 'cli'
+Requires-Dist: pygments (==2.*) ; extra == 'cli'
+Provides-Extra: http2
+Requires-Dist: h2 (<5,>=3) ; extra == 'http2'
+Provides-Extra: socks
+Requires-Dist: socksio (==1.*) ; extra == 'socks'
+
+<p align="center">
+  <a href="https://www.python-httpx.org/"><img width="350" height="208" src="https://raw.githubusercontent.com/encode/httpx/master/docs/img/butterfly.png" alt='HTTPX'></a>
+</p>
+
+<p align="center"><strong>HTTPX</strong> <em>- A next-generation HTTP client for Python.</em></p>
+
+<p align="center">
+<a href="https://github.com/encode/httpx/actions">
+    <img src="https://github.com/encode/httpx/workflows/Test%20Suite/badge.svg" alt="Test Suite">
+</a>
+<a href="https://pypi.org/project/httpx/">
+    <img src="https://badge.fury.io/py/httpx.svg" alt="Package version">
+</a>
+</p>
+
+HTTPX is a fully featured HTTP client library for Python 3. It includes **an integrated
+command line client**, has support for both **HTTP/1.1 and HTTP/2**, and provides both **sync
+and async APIs**.
+
+---
+
+Install HTTPX using pip:
+
+```shell
+$ pip install httpx
+```
+
+Now, let's get started:
+
+```pycon
+>>> import httpx
+>>> r = httpx.get('https://www.example.org/')
+>>> r
+<Response [200 OK]>
+>>> r.status_code
+200
+>>> r.headers['content-type']
+'text/html; charset=UTF-8'
+>>> r.text
+'<!doctype html>\n<html>\n<head>\n<title>Example Domain</title>...'
+```
+
+Or, using the command-line client.
+
+```shell
+$ pip install 'httpx[cli]'  # The command line client is an optional dependency.
+```
+
+Which now allows us to use HTTPX directly from the command-line...
+
+<p align="center">
+  <img width="700" src="docs/img/httpx-help.png" alt='httpx --help'>
+</p>
+
+Sending a request...
+
+<p align="center">
+  <img width="700" src="docs/img/httpx-request.png" alt='httpx http://httpbin.org/json'>
+</p>
+
+## Features
+
+HTTPX builds on the well-established usability of `requests`, and gives you:
+
+* A broadly [requests-compatible API](https://www.python-httpx.org/compatibility/).
+* An integrated command-line client.
+* HTTP/1.1 [and HTTP/2 support](https://www.python-httpx.org/http2/).
+* Standard synchronous interface, but with [async support if you need it](https://www.python-httpx.org/async/).
+* Ability to make requests directly to [WSGI applications](https://www.python-httpx.org/advanced/#calling-into-python-web-apps) or [ASGI applications](https://www.python-httpx.org/async/#calling-into-python-web-apps).
+* Strict timeouts everywhere.
+* Fully type annotated.
+* 100% test coverage.
+
+Plus all the standard features of `requests`...
+
+* International Domains and URLs
+* Keep-Alive & Connection Pooling
+* Sessions with Cookie Persistence
+* Browser-style SSL Verification
+* Basic/Digest Authentication
+* Elegant Key/Value Cookies
+* Automatic Decompression
+* Automatic Content Decoding
+* Unicode Response Bodies
+* Multipart File Uploads
+* HTTP(S) Proxy Support
+* Connection Timeouts
+* Streaming Downloads
+* .netrc Support
+* Chunked Requests
+
+## Installation
+
+Install with pip:
+
+```shell
+$ pip install httpx
+```
+
+Or, to include the optional HTTP/2 support, use:
+
+```shell
+$ pip install httpx[http2]
+```
+
+HTTPX requires Python 3.6+.
+
+## Documentation
+
+Project documentation is available at [https://www.python-httpx.org/](https://www.python-httpx.org/).
+
+For a run-through of all the basics, head over to the [QuickStart](https://www.python-httpx.org/quickstart/).
+
+For more advanced topics, see the [Advanced Usage](https://www.python-httpx.org/advanced/) section, the [async support](https://www.python-httpx.org/async/) section, or the [HTTP/2](https://www.python-httpx.org/http2/) section.
+
+The [Developer Interface](https://www.python-httpx.org/api/) provides a comprehensive API reference.
+
+To find out about tools that integrate with HTTPX, see [Third Party Packages](https://www.python-httpx.org/third_party_packages/).
+
+## Contribute
+
+If you want to contribute with HTTPX check out the [Contributing Guide](https://www.python-httpx.org/contributing/) to learn how to start.
+
+## Dependencies
+
+The HTTPX project relies on these excellent libraries:
+
+* `httpcore` - The underlying transport implementation for `httpx`.
+  * `h11` - HTTP/1.1 support.
+* `certifi` - SSL certificates.
+* `rfc3986` - URL parsing & normalization.
+  * `idna` - Internationalized domain name support.
+* `sniffio` - Async library autodetection.
+
+As well as these optional installs:
+
+* `h2` - HTTP/2 support. *(Optional, with `httpx[http2]`)*
+* `socksio` - SOCKS proxy support. *(Optional, with `httpx[socks]`)*
+* `rich` - Rich terminal support. *(Optional, with `httpx[cli]`)*
+* `click` - Command line client support. *(Optional, with `httpx[cli]`)*
+* `brotli` or `brotlicffi` - Decoding for "brotli" compressed responses. *(Optional, with `httpx[brotli]`)*
+
+A huge amount of credit is due to `requests` for the API layout that
+much of this work follows, as well as to `urllib3` for plenty of design
+inspiration around the lower-level networking details.
+
+---
+
+<p align="center"><i>HTTPX is <a href="https://github.com/encode/httpx/blob/master/LICENSE.md">BSD licensed</a> code.<br/>Designed & crafted with care.</i><br/>&mdash; 🦋 &mdash;</p>
+
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## 0.23.0 (23rd May, 2022)
+
+### Changed
+
+* Drop support for Python 3.6. (#2097)
+* Use `utf-8` as the default character set, instead of falling back to `charset-normalizer` for auto-detection. To enable automatic character set detection, see [the documentation](https://www.python-httpx.org/advanced/#character-set-encodings-and-auto-detection). (#2165)
+
+### Fixed
+
+* Fix `URL.copy_with` for some oddly formed URL cases. (#2185)
+* Digest authentication should use case-insensitive comparison for determining which algorithm is being used. (#2204)
+* Fix console markup escaping in command line client. (#1866)
+* When files are used in multipart upload, ensure we always seek to the start of the file. (#2065)
+* Ensure that `iter_bytes` never yields zero-length chunks. (#2068)
+* Preserve `Authorization` header for redirects that are to the same origin, but are an `http`-to-`https` upgrade. (#2074)
+* When responses have binary output, don't print the output to the console in the command line client. Use output like `<16086 bytes of binary data>` instead. (#2076)
+* Fix display of `--proxies` argument in the command line client help. (#2125)
+* Close responses when task cancellations occur during stream reading. (#2156)
+* Fix type error on accessing `.request` on `HTTPError` exceptions. (#2158)
+
+## 0.22.0 (26th January, 2022)
+
+### Added
+
+* Support for [the SOCKS5 proxy protocol](https://www.python-httpx.org/advanced/#socks) via [the `socksio` package](https://github.com/sethmlarson/socksio). (#2034)
+* Support for custom headers in multipart/form-data requests (#1936)
+
+### Fixed
+
+* Don't perform unreliable close/warning on `__del__` with unclosed clients. (#2026)
+* Fix `Headers.update(...)` to correctly handle repeated headers (#2038)
+
+## 0.21.3 (6th January, 2022)
+
+### Fixed
+
+* Fix streaming uploads using `SyncByteStream` or `AsyncByteStream`. Regression in 0.21.2. (#2016)
+
+## 0.21.2 (5th January, 2022)
+
+### Fixed
+
+* HTTP/2 support for tunnelled proxy cases. (#2009)
+* Improved the speed of large file uploads. (#1948)
+
+## 0.21.1 (16th November, 2021)
+
+### Fixed
+
+* The `response.url` property is now correctly annotated as `URL`, instead of `Optional[URL]`. (#1940)
+
+## 0.21.0 (15th November, 2021)
+
+The 0.21.0 release integrates against a newly redesigned `httpcore` backend.
+
+Both packages ought to automatically update to the required versions, but if you are
+seeing any issues, you should ensure that you have `httpx==0.21.*` and `httpcore==0.14.*` installed.
+
+### Added
+
+* The command-line client will now display connection information when `-v/--verbose` is used.
+* The command-line client will now display server certificate information when `-v/--verbose` is used.
+* The command-line client is now able to properly detect if the outgoing request
+should be formatted as HTTP/1.1 or HTTP/2, based on the result of the HTTP/2 negotiation.
+
+### Removed
+
+* Curio support is no longer currently included. Please get in touch if you require this, so that we can assess priorities.
+
+## 0.20.0 (13th October, 2021)
+
+The 0.20.0 release adds an integrated command-line client, and also includes some
+design changes. The most notable of these is that redirect responses are no longer
+automatically followed, unless specifically requested.
+
+This design decision prioritises a more explicit approach to redirects, in order
+to avoid code that unintentionally issues multiple requests as a result of
+misconfigured URLs.
+
+For example, previously a client configured to send requests to `http://api.github.com/`
+would end up sending every API request twice, as each request would be redirected to `https://api.github.com/`.
+
+If you do want auto-redirect behaviour, you can enable this either by configuring
+the client instance with `Client(follow_redirects=True)`, or on a per-request
+basis, with `.get(..., follow_redirects=True)`.
+
+This change is a classic trade-off between convenience and precision, with no "right"
+answer. See [discussion #1785](https://github.com/encode/httpx/discussions/1785) for more
+context.
+
+The other major design change is an update to the Transport API, which is the low-level
+interface against which requests are sent. Previously this interface used only primitive
+datastructures, like so...
+
+```python
+(status_code, headers, stream, extensions) = transport.handle_request(method, url, headers, stream, extensions)
+try
+    ...
+finally:
+    stream.close()
+```
+
+Now the interface is much simpler...
+
+```python
+response = transport.handle_request(request)
+try
+    ...
+finally:
+    response.close()
+```
+
+### Changed
+
+* The `allow_redirects` flag is now `follow_redirects` and defaults to `False`.
+* The `raise_for_status()` method will now raise an exception for any responses
+  except those with 2xx status codes. Previously only 4xx and 5xx status codes
+  would result in an exception.
+* The low-level transport API changes to the much simpler `response = transport.handle_request(request)`.
+* The `client.send()` method no longer accepts a `timeout=...` argument, but the
+  `client.build_request()` does. This required by the signature change of the
+  Transport API. The request timeout configuration is now stored on the request
+  instance, as `request.extensions['timeout']`.
+
+### Added
+
+* Added the `httpx` command-line client.
+* Response instances now include `.is_informational`, `.is_success`, `.is_redirect`, `.is_client_error`, and `.is_server_error`
+  properties for checking 1xx, 2xx, 3xx, 4xx, and 5xx response types. Note that the behaviour of `.is_redirect` is slightly different in that it now returns True for all 3xx responses, in order to allow for a consistent set of properties onto the different HTTP status code types. The `response.has_redirect_location` location may be used to determine responses with properly formed URL redirects.
+
+### Fixed
+
+* `response.iter_bytes()` no longer raises a ValueError when called on a response with no content. (Pull #1827)
+* The `'wsgi.error'` configuration now defaults to `sys.stderr`, and is corrected to be a `TextIO` interface, not a `BytesIO` interface. Additionally, the WSGITransport now accepts a `wsgi_error` configuration. (Pull #1828)
+* Follow the WSGI spec by properly closing the iterable returned by the application. (Pull #1830)
+
+## 0.19.0 (19th August, 2021)
+
+### Added
+
+* Add support for `Client(allow_redirects=<bool>)`. (Pull #1790)
+* Add automatic character set detection, when no `charset` is included in the response `Content-Type` header. (Pull #1791)
+
+### Changed
+
+* Event hooks are now also called for any additional redirect or auth requests/responses. (Pull #1806)
+* Strictly enforce that upload files must be opened in binary mode. (Pull #1736)
+* Strictly enforce that client instances can only be opened and closed once, and cannot be re-opened. (Pull #1800)
+* Drop `mode` argument from `httpx.Proxy(..., mode=...)`. (Pull #1795)
+
+## 0.18.2 (17th June, 2021)
+
+### Added
+
+* Support for Python 3.10. (Pull #1687)
+* Expose `httpx.USE_CLIENT_DEFAULT`, used as the default to `auth` and `timeout` parameters in request methods. (Pull #1634)
+* Support [HTTP/2 "prior knowledge"](https://python-hyper.org/projects/hyper-h2/en/v2.3.1/negotiating-http2.html#prior-knowledge), using `httpx.Client(http1=False, http2=True)`. (Pull #1624)
+
+### Fixed
+
+* Clean up some cases where warnings were being issued. (Pull #1687)
+* Prefer Content-Length over Transfer-Encoding: chunked for content=<file-like> cases. (Pull #1619)
+
+## 0.18.1 (29th April, 2021)
+
+### Changed
+
+* Update brotli support to use the `brotlicffi` package (Pull #1605)
+* Ensure that `Request(..., stream=...)` does not auto-generate any headers on the request instance. (Pull #1607)
+
+### Fixed
+
+* Pass through `timeout=...` in top-level httpx.stream() function. (Pull #1613)
+* Map httpcore transport close exceptions to httpx exceptions. (Pull #1606)
+
+## 0.18.0 (27th April, 2021)
+
+The 0.18.x release series formalises our low-level Transport API, introducing the base classes `httpx.BaseTransport` and `httpx.AsyncBaseTransport`.
+
+See the "[Writing custom transports](https://www.python-httpx.org/advanced/#writing-custom-transports)" documentation and the [`httpx.BaseTransport.handle_request()`](https://github.com/encode/httpx/blob/397aad98fdc8b7580a5fc3e88f1578b4302c6382/httpx/_transports/base.py#L77-L147) docstring for more complete details on implementing custom transports.
+
+Pull request #1522 includes a checklist of differences from the previous `httpcore` transport API, for developers implementing custom transports.
+
+The following API changes have been issuing deprecation warnings since 0.17.0 onwards, and are now fully deprecated...
+
+* You should now use httpx.codes consistently instead of httpx.StatusCodes.
+* Use limits=... instead of pool_limits=....
+* Use proxies={"http://": ...} instead of proxies={"http": ...} for scheme-specific mounting.
+
+### Changed
+
+* Transport instances now inherit from `httpx.BaseTransport` or `httpx.AsyncBaseTransport`,
+  and should implement either the `handle_request` method or `handle_async_request` method. (Pull #1522, #1550)
+* The `response.ext` property and `Response(ext=...)` argument are now named `extensions`. (Pull #1522)
+* The recommendation to not use `data=<bytes|str|bytes (a)iterator>` in favour of `content=<bytes|str|bytes (a)iterator>` has now been escalated to a deprecation warning. (Pull #1573)
+* Drop `Response(on_close=...)` from API, since it was a bit of leaking implementation detail. (Pull #1572)
+* When using a client instance, cookies should always be set on the client, rather than on a per-request basis. We prefer enforcing a stricter API here because it provides clearer expectations around cookie persistence, particularly when redirects occur. (Pull #1574)
+* The runtime exception `httpx.ResponseClosed` is now named `httpx.StreamClosed`. (#1584)
+* The `httpx.QueryParams` model now presents an immutable interface. There is a discussion on [the design and motivation here](https://github.com/encode/httpx/discussions/1599). Use `client.params = client.params.merge(...)` instead of `client.params.update(...)`. The basic query manipulation methods are `query.set(...)`, `query.add(...)`, and `query.remove()`. (#1600)
+
+### Added
+
+* The `Request` and `Response` classes can now be serialized using pickle. (#1579)
+* Handle `data={"key": [None|int|float|bool]}` cases. (Pull #1539)
+* Support `httpx.URL(**kwargs)`, for example `httpx.URL(scheme="https", host="www.example.com", path="/')`, or `httpx.URL("https://www.example.com/", username="tom@gmail.com", password="123 456")`. (Pull #1601)
+* Support `url.copy_with(params=...)`. (Pull #1601)
+* Add `url.params` parameter, returning an immutable `QueryParams` instance. (Pull #1601)
+* Support query manipulation methods on the URL class. These are `url.copy_set_param()`, `url.copy_add_param()`, `url.copy_remove_param()`, `url.copy_merge_params()`. (Pull #1601)
+* The `httpx.URL` class now performs port normalization, so `:80` ports are stripped from `http` URLs and `:443` ports are stripped from `https` URLs. (Pull #1603)
+* The `URL.host` property returns unicode strings for internationalized domain names. The `URL.raw_host` property returns byte strings with IDNA escaping applied. (Pull #1590)
+
+### Fixed
+
+* Fix Content-Length for cases of `files=...` where unicode string is used as the file content. (Pull #1537)
+* Fix some cases of merging relative URLs against `Client(base_url=...)`. (Pull #1532)
+* The `request.content` attribute is now always available except for streaming content, which requires an explicit `.read()`. (Pull #1583)
+
+## 0.17.1 (March 15th, 2021)
+
+### Fixed
+
+* Type annotation on `CertTypes` allows `keyfile` and `password` to be optional. (Pull #1503)
+* Fix httpcore pinned version. (Pull #1495)
+
+## 0.17.0 (February 28th, 2021)
+
+### Added
+
+* Add `httpx.MockTransport()`, allowing to mock out a transport using pre-determined responses. (Pull #1401, Pull #1449)
+* Add `httpx.HTTPTransport()` and `httpx.AsyncHTTPTransport()` default transports. (Pull #1399)
+* Add mount API support, using `httpx.Client(mounts=...)`. (Pull #1362)
+* Add `chunk_size` parameter to `iter_raw()`, `iter_bytes()`, `iter_text()`. (Pull #1277)
+* Add `keepalive_expiry` parameter to `httpx.Limits()` configuration. (Pull #1398)
+* Add repr to `httpx.Cookies` to display available cookies. (Pull #1411)
+* Add support for `params=<tuple>` (previously only `params=<list>` was supported). (Pull #1426)
+
+### Fixed
+
+* Add missing `raw_path` to ASGI scope. (Pull #1357)
+* Tweak `create_ssl_context` defaults to use `trust_env=True`. (Pull #1447)
+* Properly URL-escape WSGI `PATH_INFO`. (Pull #1391)
+* Properly set default ports in WSGI transport. (Pull #1469)
+* Properly encode slashes when using `base_url`. (Pull #1407)
+* Properly map exceptions in `request.aclose()`. (Pull #1465)
+
+## 0.16.1 (October 8th, 2020)
+
+### Fixed
+
+* Support literal IPv6 addresses in URLs. (Pull #1349)
+* Force lowercase headers in ASGI scope dictionaries. (Pull #1351)
+
+## 0.16.0 (October 6th, 2020)
+
+### Changed
+
+* Preserve HTTP header casing. (Pull #1338, encode/httpcore#216, python-hyper/h11#104)
+* Drop `response.next()` and `response.anext()` methods in favour of `response.next_request` attribute. (Pull #1339)
+* Closed clients now raise a runtime error if attempting to send a request. (Pull #1346)
+
+### Added
+
+* Add Python 3.9 to officially supported versions.
+* Type annotate `__enter__`/`__exit__`/`__aenter__`/`__aexit__` in a way that supports subclasses of `Client` and `AsyncClient`. (Pull #1336)
+
+## 0.15.5 (October 1st, 2020)
+
+### Added
+
+* Add `response.next_request` (Pull #1334)
+
+## 0.15.4 (September 25th, 2020)
+
+### Added
+
+* Support direct comparisons between `Headers` and dicts or lists of two-tuples. Eg. `assert response.headers == {"Content-Length": 24}` (Pull #1326)
+
+### Fixed
+
+* Fix automatic `.read()` when `Response` instances are created with `content=<str>` (Pull #1324)
+
+## 0.15.3 (September 24th, 2020)
+
+### Fixed
+
+* Fixed connection leak in async client due to improper closing of response streams. (Pull #1316)
+
+## 0.15.2 (September 23nd, 2020)
+
+### Fixed
+
+* Fixed `response.elapsed` property. (Pull #1313)
+* Fixed client authentication interaction with `.stream()`. (Pull #1312)
+
+## 0.15.1 (September 23nd, 2020)
+
+### Fixed
+
+* ASGITransport now properly applies URL decoding to the `path` component, as-per the ASGI spec. (Pull #1307)
+
+## 0.15.0 (September 22nd, 2020)
+
+### Added
+
+* Added support for curio. (Pull https://github.com/encode/httpcore/pull/168)
+* Added support for event hooks. (Pull #1246)
+* Added support for authentication flows which require either sync or async I/O. (Pull #1217)
+* Added support for monitoring download progress with `response.num_bytes_downloaded`. (Pull #1268)
+* Added `Request(content=...)` for byte content, instead of overloading `Request(data=...)` (Pull #1266)
+* Added support for all URL components as parameter names when using `url.copy_with(...)`. (Pull #1285)
+* Neater split between automatically populated headers on `Request` instances, vs default `client.headers`. (Pull #1248)
+* Unclosed `AsyncClient` instances will now raise warnings if garbage collected. (Pull #1197)
+* Support `Response(content=..., text=..., html=..., json=...)` for creating usable response instances in code. (Pull #1265, #1297)
+* Support instantiating requests from the low-level transport API. (Pull #1293)
+* Raise errors on invalid URL types. (Pull #1259)
+
+### Changed
+
+* Cleaned up expected behaviour for URL escaping. `url.path` is now URL escaped. (Pull #1285)
+* Cleaned up expected behaviour for bytes vs str in URL components. `url.userinfo` and `url.query` are not URL escaped, and so return bytes. (Pull #1285)
+* Drop `url.authority` property in favour of `url.netloc`, since "authority" was semantically incorrect. (Pull #1285)
+* Drop `url.full_path` property in favour of `url.raw_path`, for better consistency with other parts of the API. (Pull #1285)
+* No longer use the `chardet` library for auto-detecting charsets, instead defaulting to a simpler approach when no charset is specified. (#1269)
+
+### Fixed
+
+* Swapped ordering of redirects and authentication flow. (Pull #1267)
+* `.netrc` lookups should use host, not host+port. (Pull #1298)
+
+### Removed
+
+* The `URLLib3Transport` class no longer exists. We've published it instead as an example of [a custom transport class](https://gist.github.com/florimondmanca/d56764d78d748eb9f73165da388e546e). (Pull #1182)
+* Drop `request.timer` attribute, which was being used internally to set `response.elapsed`. (Pull #1249)
+* Drop `response.decoder` attribute, which was being used internally. (Pull #1276)
+* `Request.prepare()` is now a private method. (Pull #1284)
+* The `Headers.getlist()` method had previously been deprecated in favour of `Headers.get_list()`. It is now fully removed.
+* The `QueryParams.getlist()` method had previously been deprecated in favour of `QueryParams.get_list()`. It is now fully removed.
+* The `URL.is_ssl` property had previously been deprecated in favour of `URL.scheme == "https"`. It is now fully removed.
+* The `httpx.PoolLimits` class had previously been deprecated in favour of `httpx.Limits`. It is now fully removed.
+* The `max_keepalive` setting had previously been deprecated in favour of the more explicit `max_keepalive_connections`. It is now fully removed.
+* The verbose `httpx.Timeout(5.0, connect_timeout=60.0)` style had previously been deprecated in favour of `httpx.Timeout(5.0, connect=60.0)`. It is now fully removed.
+* Support for instantiating a timeout config missing some defaults, such as `httpx.Timeout(connect=60.0)`, had previously been deprecated in favour of enforcing a more explicit style, such as `httpx.Timeout(5.0, connect=60.0)`. This is now strictly enforced.
+
+## 0.14.3 (September 2nd, 2020)
+
+### Added
+
+* `http.Response()` may now be instantiated without a `request=...` parameter. Useful for some unit testing cases. (Pull #1238)
+* Add `103 Early Hints` and `425 Too Early` status codes. (Pull #1244)
+
+### Fixed
+
+* `DigestAuth` now handles responses that include multiple 'WWW-Authenticate' headers. (Pull #1240)
+* Call into transport `__enter__`/`__exit__` or `__aenter__`/`__aexit__` when client is used in a context manager style. (Pull #1218)
+
+## 0.14.2 (August 24th, 2020)
+
+### Added
+
+* Support `client.get(..., auth=None)` to bypass the default authentication on a clients. (Pull #1115)
+* Support `client.auth = ...` property setter. (Pull #1185)
+* Support `httpx.get(..., proxies=...)` on top-level request functions. (Pull #1198)
+* Display instances with nicer import styles. (Eg. <httpx.ReadTimeout ...>) (Pull #1155)
+* Support `cookies=[(key, value)]` list-of-two-tuples style usage. (Pull #1211)
+
+### Fixed
+
+* Ensure that automatically included headers on a request may be modified. (Pull #1205)
+* Allow explicit `Content-Length` header on streaming requests. (Pull #1170)
+* Handle URL quoted usernames and passwords properly. (Pull #1159)
+* Use more consistent default for `HEAD` requests, setting `allow_redirects=True`. (Pull #1183)
+* If a transport error occurs while streaming the response, raise an `httpx` exception, not the underlying `httpcore` exception. (Pull #1190)
+* Include the underlying `httpcore` traceback, when transport exceptions occur. (Pull #1199)
+
+## 0.14.1 (August 11th, 2020)
+
+### Added
+
+* The `httpx.URL(...)` class now raises `httpx.InvalidURL` on invalid URLs, rather than exposing the underlying `rfc3986` exception. If a redirect response includes an invalid 'Location' header, then a `RemoteProtocolError` exception is raised, which will be associated with the request that caused it. (Pull #1163)
+
+### Fixed
+
+* Handling multiple `Set-Cookie` headers became broken in the 0.14.0 release, and is now resolved. (Pull #1156)
+
+## 0.14.0 (August 7th, 2020)
+
+The 0.14 release includes a range of improvements to the public API, intended on preparing for our upcoming 1.0 release.
+
+* Our HTTP/2 support is now fully optional. **You now need to use `pip install httpx[http2]` if you want to include the HTTP/2 dependencies.**
+* Our HSTS support has now been removed. Rewriting URLs from `http` to `https` if the host is on the HSTS list can be beneficial in avoiding roundtrips to incorrectly formed URLs, but on balance we've decided to remove this feature, on the principle of least surprise. Most programmatic clients do not include HSTS support, and for now we're opting to remove our support for it.
+* Our exception hierarchy has been overhauled. Most users will want to stick with their existing `httpx.HTTPError` usage, but we've got a clearer overall structure now. See https://www.python-httpx.org/exceptions/ for more details.
+
+When upgrading you should be aware of the following public API changes. Note that deprecated usages will currently continue to function, but will issue warnings.
+
+* You should now use `httpx.codes` consistently instead of `httpx.StatusCodes`.
+* Usage of `httpx.Timeout()` should now always include an explicit default. Eg. `httpx.Timeout(None, pool=5.0)`.
+* When using `httpx.Timeout()`, we now have more concisely named keyword arguments. Eg. `read=5.0`, instead of `read_timeout=5.0`.
+* Use `httpx.Limits()` instead of `httpx.PoolLimits()`, and `limits=...` instead of `pool_limits=...`.
+* The `httpx.Limits(max_keepalive=...)` argument is now deprecated in favour of a more explicit `httpx.Limits(max_keepalive_connections=...)`.
+* Keys used with `Client(proxies={...})` should now be in the style of `{"http://": ...}`, rather than `{"http": ...}`.
+* The multidict methods `Headers.getlist()` and `QueryParams.getlist()` are deprecated in favour of more consistent `.get_list()` variants.
+* The `URL.is_ssl` property is deprecated in favour of `URL.scheme == "https"`.
+* The `URL.join(relative_url=...)` method is now `URL.join(url=...)`. This change does not support warnings for the deprecated usage style.
+
+One notable aspect of the 0.14.0 release is that it tightens up the public API for `httpx`, by ensuring that several internal attributes and methods have now become strictly private.
+
+The following previously had nominally public names on the client, but were all undocumented and intended solely for internal usage. They are all now replaced with underscored names, and should not be relied on or accessed.
+
+These changes should not affect users who have been working from the `httpx` documentation.
+
+* `.merge_url()`, `.merge_headers()`, `.merge_cookies()`, `.merge_queryparams()`
+* `.build_auth()`, `.build_redirect_request()`
+* `.redirect_method()`, `.redirect_url()`, `.redirect_headers()`, `.redirect_stream()`
+* `.send_handling_redirects()`, `.send_handling_auth()`, `.send_single_request()`
+* `.init_transport()`, `.init_proxy_transport()`
+* `.proxies`, `.transport`, `.netrc`, `.get_proxy_map()`
+
+See pull requests #997, #1065, #1071.
+
+Some areas of API which were already on the deprecation path, and were raising warnings or errors in 0.13.x have now been escalated to being fully removed.
+
+* Drop `ASGIDispatch`, `WSGIDispatch`, which have been replaced by `ASGITransport`, `WSGITransport`.
+* Drop `dispatch=...`` on client, which has been replaced by `transport=...``
+* Drop `soft_limit`, `hard_limit`, which have been replaced by `max_keepalive` and `max_connections`.
+* Drop `Response.stream` and` `Response.raw`, which have been replaced by ``.aiter_bytes` and `.aiter_raw`.
+* Drop `proxies=<transport instance>` in favor of `proxies=httpx.Proxy(...)`.
+
+See pull requests #1057, #1058.
+
+### Added
+
+* Added dedicated exception class `httpx.HTTPStatusError` for `.raise_for_status()` exceptions. (Pull #1072)
+* Added `httpx.create_ssl_context()` helper function. (Pull #996)
+* Support for proxy exlcusions like `proxies={"https://www.example.com": None}`. (Pull #1099)
+* Support `QueryParams(None)` and `client.params = None`. (Pull #1060)
+
+### Changed
+
+* Use `httpx.codes` consistently in favour of `httpx.StatusCodes` which is placed into deprecation. (Pull #1088)
+* Usage of `httpx.Timeout()` should now always include an explicit default. Eg. `httpx.Timeout(None, pool=5.0)`. (Pull #1085)
+* Switch to more concise `httpx.Timeout()` keyword arguments. Eg. `read=5.0`, instead of `read_timeout=5.0`. (Pull #1111)
+* Use `httpx.Limits()` instead of `httpx.PoolLimits()`, and `limits=...` instead of `pool_limits=...`. (Pull #1113)
+* Keys used with `Client(proxies={...})` should now be in the style of `{"http://": ...}`, rather than `{"http": ...}`. (Pull #1127)
+* The multidict methods `Headers.getlist` and `QueryParams.getlist` are deprecated in favour of more consistent `.get_list()` variants. (Pull #1089)
+* `URL.port` becomes `Optional[int]`. Now only returns a port if one is explicitly included in the URL string. (Pull #1080)
+* The `URL(..., allow_relative=[bool])` parameter no longer exists. All URL instances may be relative. (Pull #1073)
+* Drop unnecessary `url.full_path = ...` property setter. (Pull #1069)
+* The `URL.join(relative_url=...)` method is now `URL.join(url=...)`. (Pull #1129)
+* The `URL.is_ssl` property is deprecated in favour of `URL.scheme == "https"`. (Pull #1128)
+
+### Fixed
+
+* Add missing `Response.next()` method. (Pull #1055)
+* Ensure all exception classes are exposed as public API. (Pull #1045)
+* Support multiple items with an identical field name in multipart encodings. (Pull #777)
+* Skip HSTS preloading on single-label domains. (Pull #1074)
+* Fixes for `Response.iter_lines()`. (Pull #1033, #1075)
+* Ignore permission errors when accessing `.netrc` files. (Pull #1104)
+* Allow bare hostnames in `HTTP_PROXY` etc... environment variables. (Pull #1120)
+* Settings `app=...` or `transport=...` bypasses any environment based proxy defaults. (Pull #1122)
+* Fix handling of `.base_url` when a path component is included in the base URL. (Pull #1130)
+
+---
+
+## 0.13.3 (May 29th, 2020)
+
+### Fixed
+
+* Include missing keepalive expiry configuration. (Pull #1005)
+* Improved error message when URL redirect has a custom scheme. (Pull #1002)
+
+## 0.13.2 (May 27th, 2020)
+
+### Fixed
+
+* Include explicit "Content-Length: 0" on POST, PUT, PATCH if no request body is used. (Pull #995)
+* Add `http2` option to `httpx.Client`. (Pull #982)
+* Tighten up API typing in places. (Pull #992, #999)
+
+## 0.13.1 (May 22nd, 2020)
+
+### Fixed
+
+* Fix pool options deprecation warning. (Pull #980)
+* Include `httpx.URLLib3ProxyTransport` in top-level API. (Pull #979)
+
+## 0.13.0 (May 22nd, 2020)
+
+This release switches to `httpcore` for all the internal networking, which means:
+
+* We're using the same codebase for both our sync and async clients.
+* HTTP/2 support is now available with the sync client.
+* We no longer have a `urllib3` dependency for our sync client, although there is still an *optional* `URLLib3Transport` class.
+
+It also means we've had to remove our UDS support, since maintaining that would have meant having to push back our work towards a 1.0 release, which isn't a trade-off we wanted to make.
+
+We also now have [a public "Transport API"](https://www.python-httpx.org/advanced/#custom-transports), which you can use to implement custom transport implementations against. This formalises and replaces our previously private "Dispatch API".
+
+### Changed
+
+* Use `httpcore` for underlying HTTP transport. Drop `urllib3` requirement. (Pull #804, #967)
+* Rename pool limit options from `soft_limit`/`hard_limit` to `max_keepalive`/`max_connections`. (Pull #968)
+* The previous private "Dispatch API" has now been promoted to a public "Transport API". When customizing the transport use `transport=...`. The `ASGIDispatch` and `WSGIDispatch` class naming is deprecated in favour of `ASGITransport` and `WSGITransport`. (Pull #963)
+
+### Added
+
+* Added `URLLib3Transport` class for optional `urllib3` transport support. (Pull #804, #963)
+* Streaming multipart uploads. (Pull #857)
+* Logging via HTTPCORE_LOG_LEVEL and HTTPX_LOG_LEVEL environment variables
+and TRACE level logging. (Pull encode/httpcore#79)
+
+### Fixed
+
+* Performance improvement in brotli decoder. (Pull #906)
+* Proper warning level of deprecation notice in `Response.stream` and `Response.raw`. (Pull #908)
+* Fix support for generator based WSGI apps. (Pull #887)
+* Reuse of connections on HTTP/2 in close concurrency situations. (Pull encode/httpcore#81)
+* Honor HTTP/2 max concurrent streams settings (Pull encode/httpcore#89, encode/httpcore#90)
+* Fix bytes support in multipart uploads. (Pull #974)
+* Improve typing support for `files=...`. (Pull #976)
+
+### Removed
+
+* Dropped support for `Client(uds=...)` (Pull #804)
+
+## 0.13.0.dev2 (May 12th, 2020)
+
+The 0.13.0.dev2 is a *pre-release* version. To install it, use `pip install httpx --pre`.
+
+### Added
+
+* Logging via HTTPCORE_LOG_LEVEL and HTTPX_LOG_LEVEL environment variables
+and TRACE level logging. (HTTPCore Pull #79)
+
+### Fixed
+
+* Reuse of connections on HTTP/2 in close concurrency situations. (HTTPCore Pull #81)
+* When using an `app=<ASGI app>` observe neater disconnect behaviour instead of sending empty body messages. (Pull #919)
+
+## 0.13.0.dev1 (May 6th, 2020)
+
+The 0.13.0.dev1 is a *pre-release* version. To install it, use `pip install httpx --pre`.
+
+### Fixed
+
+* Passing `http2` flag to proxy dispatchers. (Pull #934)
+* Use [`httpcore` v0.8.3](https://github.com/encode/httpcore/releases/tag/0.8.3)
+which addresses problems in handling of headers when using proxies.
+
+## 0.13.0.dev0 (April 30th, 2020)
+
+The 0.13.0.dev0 is a *pre-release* version. To install it, use `pip install httpx --pre`.
+
+This release switches to `httpcore` for all the internal networking, which means:
+
+* We're using the same codebase for both our sync and async clients.
+* HTTP/2 support is now available with the sync client.
+* We no longer have a `urllib3` dependency for our sync client, although there is still an *optional* `URLLib3Dispatcher` class.
+
+It also means we've had to remove our UDS support, since maintaining that would have meant having to push back our work towards a 1.0 release, which isn't a trade-off we wanted to make.
+
+### Changed
+
+* Use `httpcore` for underlying HTTP transport. Drop `urllib3` requirement. (Pull #804)
+
+### Added
+
+* Added `URLLib3Dispatcher` class for optional `urllib3` transport support. (Pull #804)
+* Streaming multipart uploads. (Pull #857)
+
+### Fixed
+
+* Performance improvement in brotli decoder. (Pull #906)
+* Proper warning level of deprecation notice in `Response.stream` and `Response.raw`. (Pull #908)
+* Fix support for generator based WSGI apps. (Pull #887)
+
+### Removed
+
+* Dropped support for `Client(uds=...)` (Pull #804)
+
+---
+
+## 0.12.1 (March 19th, 2020)
+
+### Fixed
+
+* Resolved packaging issue, where additional files were being included.
+
+## 0.12.0 (March 9th, 2020)
+
+The 0.12 release tightens up the API expectations for `httpx` by switching to private module names to enforce better clarity around public API.
+
+All imports of `httpx` should import from the top-level package only, such as `from httpx import Request`, rather than importing from privately namespaced modules such as `from httpx._models import Request`.
+
+### Added
+
+* Support making response body available to auth classes with `.requires_response_body`. (Pull #803)
+* Export `NetworkError` exception. (Pull #814)
+* Add support for `NO_PROXY` environment variable. (Pull #835)
+
+### Changed
+
+* Switched to private module names. (Pull #785)
+* Drop redirect looping detection and the `RedirectLoop` exception, instead using `TooManyRedirects`. (Pull #819)
+* Drop `backend=...` parameter on `AsyncClient`, in favour of always autodetecting `trio`/`asyncio`. (Pull #791)
+
+### Fixed
+
+* Support basic auth credentials in proxy URLs. (Pull #780)
+* Fix `httpx.Proxy(url, mode="FORWARD_ONLY")` configuration. (Pull #788)
+* Fallback to setting headers as UTF-8 if no encoding is specified. (Pull #820)
+* Close proxy dispatches classes on client close. (Pull #826)
+* Support custom `cert` parameters even if `verify=False`. (Pull #796)
+* Don't support invalid dict-of-dicts form data in `data=...`. (Pull #811)
+
+---
+
+## 0.11.1 (January 17th, 2020)
+
+### Fixed
+
+* Fixed usage of `proxies=...` on `Client()`. (Pull #763)
+* Support both `zlib` and `deflate` style encodings on `Content-Encoding: deflate`. (Pull #758)
+* Fix for streaming a redirect response body with `allow_redirects=False`. (Pull #766)
+* Handle redirect with malformed Location headers missing host. (Pull #774)
+
+## 0.11.0 (January 9th, 2020)
+
+The 0.11 release reintroduces our sync support, so that `httpx` now supports both a standard thread-concurrency API, and an async API.
+
+Existing async `httpx` users that are upgrading to 0.11 should ensure that:
+
+* Async codebases should always use a client instance to make requests, instead of the top-level API.
+* The async client is named as `httpx.AsyncClient()`, instead of `httpx.Client()`.
+* When instantiating proxy configurations use the `httpx.Proxy()` class, instead of the previous `httpx.HTTPProxy()`. This new configuration class works for configuring both sync and async clients.
+
+We believe the API is now pretty much stable, and are aiming for a 1.0 release sometime on or before April 2020.
+
+### Changed
+
+- Top level API such as `httpx.get(url, ...)`, `httpx.post(url, ...)`, `httpx.request(method, url, ...)` becomes synchronous.
+- Added `httpx.Client()` for synchronous clients, with `httpx.AsyncClient` being used for async clients.
+- Switched to `proxies=httpx.Proxy(...)` for proxy configuration.
+- Network connection errors are wrapped in `httpx.NetworkError`, rather than exposing lower-level exception types directly.
+
+### Removed
+
+- The `request.url.origin` property and `httpx.Origin` class are no longer available.
+- The per-request `cert`, `verify`, and `trust_env` arguments are escalated from raising errors if used, to no longer being available. These arguments should be used on a per-client instance instead, or in the top-level API.
+- The `stream` argument has escalated from raising an error when used, to no longer being available. Use the `client.stream(...)` or `httpx.stream()` streaming API instead.
+
+### Fixed
+
+- Redirect loop detection matches against `(method, url)` rather than `url`. (Pull #734)
+
+---
+
+## 0.10.1 (December 31st, 2019)
+
+### Fixed
+
+- Fix issue with concurrent connection acquiry. (Pull #700)
+- Fix write error on closing HTTP/2 connections. (Pull #699)
+
+## 0.10.0 (December 29th, 2019)
+
+The 0.10.0 release makes some changes that will allow us to support both sync and async interfaces.
+
+In particular with streaming responses the `response.read()` method becomes `response.aread()`, and the `response.close()` method becomes `response.aclose()`.
+
+If following redirects explicitly the `response.next()` method becomes `response.anext()`.
+
+### Fixed
+
+- End HTTP/2 streams immediately on no-body requests, rather than sending an empty body message. (Pull #682)
+- Improve typing for `Response.request`: switch from `Optional[Request]` to `Request`. (Pull #666)
+- `Response.elapsed` now reflects the entire download time. (Pull #687, #692)
+
+### Changed
+
+- Added `AsyncClient` as a synonym for `Client`. (Pull #680)
+- Switch to `response.aread()` for conditionally reading streaming responses. (Pull #674)
+- Switch to `response.aclose()` and `client.aclose()` for explicit closing. (Pull #674, #675)
+- Switch to `response.anext()` for resolving the next redirect response. (Pull #676)
+
+### Removed
+
+- When using a client instance, the per-request usage of `verify`, `cert`, and `trust_env` have now escalated from raising a warning to raising an error. You should set these arguments on the client instead. (Pull #617)
+- Removed the undocumented `request.read()`, since end users should not require it.
+
+---
+
+## 0.9.5 (December 20th, 2019)
+
+### Fixed
+
+- Fix Host header and HSTS rewrites when an explicit `:80` port is included in URL. (Pull #649)
+- Query Params on the URL string are merged with any `params=...` argument. (Pull #653)
+- More robust behavior when closing connections. (Pull #640)
+- More robust behavior when handling HTTP/2 headers with trailing whitespace. (Pull #637)
+- Allow any explicit `Content-Type` header to take precedence over the encoding default. (Pull #633)
+
+## 0.9.4 (December 12th, 2019)
+
+### Fixed
+
+- Added expiry to Keep-Alive connections, resolving issues with acquiring connections. (Pull #627)
+- Increased flow control windows on HTTP/2, resolving download speed issues. (Pull #629)
+
+## 0.9.3 (December 7th, 2019)
+
+### Fixed
+
+- Fixed HTTP/2 with autodetection backend. (Pull #614)
+
+## 0.9.2 (December 7th, 2019)
+
+* Released due to packaging build artifact.
+
+## 0.9.1 (December 6th, 2019)
+
+* Released due to packaging build artifact.
+
+## 0.9.0 (December 6th, 2019)
+
+The 0.9 releases brings some major new features, including:
+
+* A new streaming API.
+* Autodetection of either asyncio or trio.
+* Nicer timeout configuration.
+* HTTP/2 support off by default, but can be enabled.
+
+We've also removed all private types from the top-level package export.
+
+In order to ensure you are only ever working with public API you should make
+sure to only import the top-level package eg. `import httpx`, rather than
+importing modules within the package.
+
+### Added
+
+- Added concurrency backend autodetection. (Pull #585)
+- Added `Client(backend='trio')` and `Client(backend='asyncio')` API. (Pull #585)
+- Added `response.stream_lines()` API. (Pull #575)
+- Added `response.is_error` API. (Pull #574)
+- Added support for `timeout=Timeout(5.0, connect_timeout=60.0)` styles. (Pull #593)
+
+### Fixed
+
+- Requests or Clients with `timeout=None` now correctly always disable timeouts. (Pull #592)
+- Request 'Authorization' headers now have priority over `.netrc` authentication info. (Commit 095b691)
+- Files without a filename no longer set a Content-Type in multipart data. (Commit ed94950)
+
+### Changed
+
+- Added `httpx.stream()` API. Using `stream=True` now results in a warning. (Pull #600, #610)
+- HTTP/2 support is switched to "off by default", but can be enabled explicitly. (Pull #584)
+- Switched to `Client(http2=True)` API from `Client(http_versions=["HTTP/1.1", "HTTP/2"])`. (Pull #586)
+- Removed all private types from the top-level package export. (Pull #608)
+- The SSL configuration settings of `verify`, `cert`, and `trust_env` now raise warnings if used per-request when using a Client instance. They should always be set on the Client instance itself. (Pull #597)
+- Use plain strings "TUNNEL_ONLY" or "FORWARD_ONLY" on the HTTPProxy `proxy_mode` argument. The `HTTPProxyMode` enum still exists, but its usage will raise warnings. (#610)
+- Pool timeouts are now on the timeout configuration, not the pool limits configuration. (Pull #563)
+- The timeout configuration is now named `httpx.Timeout(...)`, not `httpx.TimeoutConfig(...)`. The old version currently remains as a synonym for backwards compatibility.  (Pull #591)
+
+---
+
+## 0.8.0 (November 27, 2019)
+
+### Removed
+
+- The synchronous API has been removed, in order to allow us to fundamentally change how we approach supporting both sync and async variants. (See #588 for more details.)
+
+---
+
+## 0.7.8 (November 17, 2019)
+
+### Added
+
+- Add support for proxy tunnels for Python 3.6 + asyncio. (Pull #521)
+
+## 0.7.7 (November 15, 2019)
+
+### Fixed
+
+- Resolve an issue with cookies behavior on redirect requests. (Pull #529)
+
+### Added
+
+- Add request/response DEBUG logs. (Pull #502)
+- Use TRACE log level for low level info. (Pull #500)
+
+## 0.7.6 (November 2, 2019)
+
+### Removed
+
+- Drop `proxies` parameter from the high-level API. (Pull #485)
+
+### Fixed
+
+- Tweak multipart files: omit null filenames, add support for `str` file contents. (Pull #482)
+- Cache NETRC authentication per-client. (Pull #400)
+- Rely on `getproxies` for all proxy environment variables. (Pull #470)
+- Wait for the `asyncio` stream to close when closing a connection. (Pull #494)
+
+## 0.7.5 (October 10, 2019)
+
+### Added
+
+- Allow lists of values to be passed to `params`. (Pull #386)
+- `ASGIDispatch`, `WSGIDispatch` are now available in the `httpx.dispatch` namespace. (Pull #407)
+- `HTTPError` is now available in the `httpx` namespace.  (Pull #421)
+- Add support for `start_tls()` to the Trio concurrency backend. (Pull #467)
+
+### Fixed
+
+- Username and password are no longer included in the `Host` header when basic authentication
+  credentials are supplied via the URL. (Pull #417)
+
+### Removed
+
+- The `.delete()` function no longer has `json`, `data`, or `files` parameters
+  to match the expected semantics of the `DELETE` method. (Pull #408)
+- Removed the `trio` extra. Trio support is detected automatically. (Pull #390)
+
+## 0.7.4 (September 25, 2019)
+
+### Added
+
+- Add Trio concurrency backend. (Pull #276)
+- Add `params` parameter to `Client` for setting default query parameters. (Pull #372)
+- Add support for `SSL_CERT_FILE` and `SSL_CERT_DIR` environment variables. (Pull #307)
+- Add debug logging to calls into ASGI apps. (Pull #371)
+- Add debug logging to SSL configuration. (Pull #378)
+
+### Fixed
+
+- Fix a bug when using `Client` without timeouts in Python 3.6. (Pull #383)
+- Propagate `Client` configuration to HTTP proxies. (Pull #377)
+
+## 0.7.3 (September 20, 2019)
+
+### Added
+
+- HTTP Proxy support. (Pulls #259, #353)
+- Add Digest authentication. (Pull #332)
+- Add `.build_request()` method to `Client` and `AsyncClient`. (Pull #319)
+- Add `.elapsed` property on responses. (Pull #351)
+- Add support for `SSLKEYLOGFILE` in Python 3.8b4+. (Pull #301)
+
+### Removed
+
+- Drop NPN support for HTTP version negotiation. (Pull #314)
+
+### Fixed
+
+- Fix distribution of type annotations for mypy (Pull #361).
+- Set `Host` header when redirecting cross-origin. (Pull #321)
+- Drop `Content-Length` headers on `GET` redirects. (Pull #310)
+- Raise `KeyError` if header isn't found in `Headers`. (Pull #324)
+- Raise `NotRedirectResponse` in `response.next()` if there is no redirection to perform. (Pull #297)
+- Fix bug in calculating the HTTP/2 maximum frame size. (Pull #153)
+
+## 0.7.2 (August 28, 2019)
+
+- Enforce using `httpx.AsyncioBackend` for the synchronous client. (Pull #232)
+- `httpx.ConnectionPool` will properly release a dropped connection. (Pull #230)
+- Remove the `raise_app_exceptions` argument from `Client`. (Pull #238)
+- `DecodeError` will no longer be raised for an empty body encoded with Brotli. (Pull #237)
+- Added `http_versions` parameter to `Client`. (Pull #250)
+- Only use HTTP/1.1 on short-lived connections like `httpx.get()`. (Pull #284)
+- Convert `Client.cookies` and `Client.headers` when set as a property. (Pull #274)
+- Setting `HTTPX_DEBUG=1` enables debug logging on all requests. (Pull #277)
+
+## 0.7.1 (August 18, 2019)
+
+- Include files with source distribution to be installable. (Pull #233)
+
+## 0.7.0 (August 17, 2019)
+
+- Add the `trust_env` property to `BaseClient`. (Pull #187)
+- Add the `links` property to `BaseResponse`. (Pull #211)
+- Accept `ssl.SSLContext` instances into `SSLConfig(verify=...)`. (Pull #215)
+- Add `Response.stream_text()` with incremental encoding detection. (Pull #183)
+- Properly updated the `Host` header when a redirect changes the origin. (Pull #199)
+- Ignore invalid `Content-Encoding` headers. (Pull #196)
+- Use `~/.netrc` and `~/_netrc` files by default when `trust_env=True`. (Pull #189)
+- Create exception base class `HTTPError` with `request` and `response` properties. (Pull #162)
+- Add HSTS preload list checking within `BaseClient` to upgrade HTTP URLs to HTTPS. (Pull #184)
+- Switch IDNA encoding from IDNA 2003 to IDNA 2008. (Pull #161)
+- Expose base classes for alternate concurrency backends. (Pull #178)
+- Improve Multipart parameter encoding. (Pull #167)
+- Add the `headers` property to `BaseClient`. (Pull #159)
+- Add support for Google's `brotli` library. (Pull #156)
+- Remove deprecated TLS versions (TLSv1 and TLSv1.1) from default `SSLConfig`. (Pull #155)
+- Fix `URL.join(...)` to work similarly to RFC 3986 URL joining. (Pull #144)
+
+---
+
+## 0.6.8 (July 25, 2019)
+
+- Check for disconnections when searching for an available
+  connection in `ConnectionPool.keepalive_connections` (Pull #145)
+- Allow string comparison for `URL` objects (Pull #139)
+- Add HTTP status codes 418 and 451 (Pull #135)
+- Add support for client certificate passwords (Pull #118)
+- Enable post-handshake client cert authentication for TLSv1.3 (Pull #118)
+- Disable using `commonName` for hostname checking for OpenSSL 1.1.0+ (Pull #118)
+- Detect encoding for `Response.json()` (Pull #116)
+
+## 0.6.7 (July 8, 2019)
+
+- Check for connection aliveness on re-acquiry (Pull #111)
+
+## 0.6.6 (July 3, 2019)
+
+- Improve `USER_AGENT` (Pull #110)
+- Add `Connection: keep-alive` by default to HTTP/1.1 connections. (Pull #110)
+
+## 0.6.5 (June 27, 2019)
+
+- Include `Host` header by default. (Pull #109)
+- Improve HTTP protocol detection. (Pull #107)
+
+## 0.6.4 (June 25, 2019)
+
+- Implement read and write timeouts (Pull #104)
+
+## 0.6.3 (June 24, 2019)
+
+- Handle early connection closes (Pull #103)
+
+## 0.6.2 (June 23, 2019)
+
+- Use urllib3's `DEFAULT_CIPHERS` for the `SSLConfig` object. (Pull #100)
+
+## 0.6.1 (June 21, 2019)
+
+- Add support for setting a `base_url` on the `Client`.
+
+## 0.6.0 (June 21, 2019)
+
+- Honor `local_flow_control_window` for HTTP/2 connections (Pull #98)
+
+
diff --git a/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/RECORD
new file mode 100644
index 0000000..eb640b1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/RECORD
@@ -0,0 +1,32 @@
+../../../bin/httpx,sha256=QcKfM-fkjnr3_I8fP0pWdXHdn2-1KruTxl7xaMwkMQY,245
+httpx/__init__.py,sha256=GHtP9_yAnMm1lWiaMcrKZpDdFCXZHYk5cpqB_PmcuUE,3181
+httpx/__version__.py,sha256=MF2vNzMmwODNv9hDqn3z9n6s0bcTjjeVKPBkfrWYxlg,108
+httpx/_api.py,sha256=cVU9ErzaXve5rqoPoSHr9yJbovHtICrcxR7yBoNSeOw,13011
+httpx/_auth.py,sha256=q66GwQRkvk5FhTh9-5ujgLPUBRhhAoF7FusvccUEWws,10250
+httpx/_client.py,sha256=mv17TOUDnkLBHJJ6gjrnKdDwTU8miOEs0aCIMEuc210,67940
+httpx/_compat.py,sha256=IRU0J9d5bQrULQOtfTvM2Qxl5O0t0yzkGzbClLvmzPQ,1547
+httpx/_config.py,sha256=qg-rnH8RhRJOg_Rl0zaCmY-KMXKuMkgloosp_1yWb3U,12329
+httpx/_content.py,sha256=CX8wi5xD3xP5FBHNvIBihkaBBt8-qVvT0IQPeyABJjA,7957
+httpx/_decoders.py,sha256=78zHx-qjiECUel4QIqs784OSEOJY92RAYgyxMHsz56U,10208
+httpx/_exceptions.py,sha256=5n8ZKXee3AmXBzWzGtZFzvwsLpzfILpcOAqjilIjLg4,7879
+httpx/_main.py,sha256=Xtbnk1yyJ2QwzIJ3sutcBdQBmMCItLDVAZRKpo0vpHY,15508
+httpx/_models.py,sha256=KlYlXS9uvx4WyN_axQSzzswoN6GHoTMS0Q43W8vDEgI,42106
+httpx/_multipart.py,sha256=3cC9YwiFkhyZWHVTezhs4jI4LVG-vLEJ1E181zvzGWM,7901
+httpx/_status_codes.py,sha256=9p71cQ6jrGSq_kVHzoTR8Q3MOevq6z3WKA1kYl2SPWY,5586
+httpx/_types.py,sha256=xJGcb-L0L7Xm2vI_baRdmf7M9nF6RcjHD4EUDhOxy9E,3984
+httpx/_urls.py,sha256=dqsMdgZs5-rAToBy-kFIhRVDHXIPMdOruS3WxKMMHG0,27883
+httpx/_utils.py,sha256=4gvRr2bSR1l7swk_-SIcWEceO5FxescOhVN6pCoRaZA,16901
+httpx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpx/_transports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpx/_transports/asgi.py,sha256=4VI5ID_LjapQpF_pXhy8RPwh966y83ZIizqXV-wDzUI,4959
+httpx/_transports/base.py,sha256=mS6d9wr5pyz1umUKh3kp260LQXsZ4WJLsuMHwzUNRiU,2508
+httpx/_transports/default.py,sha256=xafKg7eajxSR8RNsM70OgMh5IIUnFPMwXvzK3m_HKRQ,12653
+httpx/_transports/mock.py,sha256=opEbEyPD9cQ8LntlQRhfBhZ8fVJ_dEodV7WNp0wgIYg,923
+httpx/_transports/wsgi.py,sha256=RVcf6gbmFjutfIingDG74TTZUfRJljuG4ZKTHdk1HpM,4405
+httpx-0.23.0.dist-info/LICENSE.md,sha256=TsWdVE8StfU5o6cW_TIaxYzNgDC0ZSIfLIgCAM3yjY0,1508
+httpx-0.23.0.dist-info/METADATA,sha256=xD26jQUfrxwZSSncib6WE3byJIbN79uatkxYdifzdTo,52005
+httpx-0.23.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+httpx-0.23.0.dist-info/entry_points.txt,sha256=RfPz07Z-6okb4DXupAwHIQFyjq2Io_W7nlac92f4kqM,36
+httpx-0.23.0.dist-info/top_level.txt,sha256=8QYqFolXm27kV0x-8K8V5t-uZskSHKtq8jZVxGwtIq4,24
+httpx-0.23.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+httpx-0.23.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/WHEEL
new file mode 100644
index 0000000..becc9a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/entry_points.txt
new file mode 100644
index 0000000..fef52b6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/entry_points.txt
@@ -0,0 +1,3 @@
+[console_scripts]
+httpx=httpx:main
+
diff --git a/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/top_level.txt
new file mode 100644
index 0000000..c180eb2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx-0.23.0.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+httpx
+httpx/_transports
diff --git a/myenv/lib/python3.9/site-packages/httpx/__init__.py b/myenv/lib/python3.9/site-packages/httpx/__init__.py
new file mode 100644
index 0000000..b93ca92
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/__init__.py
@@ -0,0 +1,137 @@
+from .__version__ import __description__, __title__, __version__
+from ._api import delete, get, head, options, patch, post, put, request, stream
+from ._auth import Auth, BasicAuth, DigestAuth
+from ._client import USE_CLIENT_DEFAULT, AsyncClient, Client
+from ._config import Limits, Proxy, Timeout, create_ssl_context
+from ._content import ByteStream
+from ._exceptions import (
+    CloseError,
+    ConnectError,
+    ConnectTimeout,
+    CookieConflict,
+    DecodingError,
+    HTTPError,
+    HTTPStatusError,
+    InvalidURL,
+    LocalProtocolError,
+    NetworkError,
+    PoolTimeout,
+    ProtocolError,
+    ProxyError,
+    ReadError,
+    ReadTimeout,
+    RemoteProtocolError,
+    RequestError,
+    RequestNotRead,
+    ResponseNotRead,
+    StreamClosed,
+    StreamConsumed,
+    StreamError,
+    TimeoutException,
+    TooManyRedirects,
+    TransportError,
+    UnsupportedProtocol,
+    WriteError,
+    WriteTimeout,
+)
+from ._models import Cookies, Headers, Request, Response
+from ._status_codes import codes
+from ._transports.asgi import ASGITransport
+from ._transports.base import AsyncBaseTransport, BaseTransport
+from ._transports.default import AsyncHTTPTransport, HTTPTransport
+from ._transports.mock import MockTransport
+from ._transports.wsgi import WSGITransport
+from ._types import AsyncByteStream, SyncByteStream
+from ._urls import URL, QueryParams
+
+try:
+    from ._main import main
+except ImportError:  # pragma: nocover
+
+    def main() -> None:  # type: ignore
+        import sys
+
+        print(
+            "The httpx command line client could not run because the required "
+            "dependencies were not installed.\nMake sure you've installed "
+            "everything with: pip install 'httpx[cli]'"
+        )
+        sys.exit(1)
+
+
+__all__ = [
+    "__description__",
+    "__title__",
+    "__version__",
+    "ASGITransport",
+    "AsyncBaseTransport",
+    "AsyncByteStream",
+    "AsyncClient",
+    "AsyncHTTPTransport",
+    "Auth",
+    "BaseTransport",
+    "BasicAuth",
+    "ByteStream",
+    "Client",
+    "CloseError",
+    "codes",
+    "ConnectError",
+    "ConnectTimeout",
+    "CookieConflict",
+    "Cookies",
+    "create_ssl_context",
+    "DecodingError",
+    "delete",
+    "DigestAuth",
+    "get",
+    "head",
+    "Headers",
+    "HTTPError",
+    "HTTPStatusError",
+    "HTTPTransport",
+    "InvalidURL",
+    "Limits",
+    "LocalProtocolError",
+    "main",
+    "MockTransport",
+    "NetworkError",
+    "options",
+    "patch",
+    "PoolTimeout",
+    "post",
+    "ProtocolError",
+    "Proxy",
+    "ProxyError",
+    "put",
+    "QueryParams",
+    "ReadError",
+    "ReadTimeout",
+    "RemoteProtocolError",
+    "request",
+    "Request",
+    "RequestError",
+    "RequestNotRead",
+    "Response",
+    "ResponseNotRead",
+    "stream",
+    "StreamClosed",
+    "StreamConsumed",
+    "StreamError",
+    "SyncByteStream",
+    "Timeout",
+    "TimeoutException",
+    "TooManyRedirects",
+    "TransportError",
+    "UnsupportedProtocol",
+    "URL",
+    "USE_CLIENT_DEFAULT",
+    "WriteError",
+    "WriteTimeout",
+    "WSGITransport",
+]
+
+
+__locals = locals()
+for __name in __all__:
+    if not __name.startswith("__"):
+        setattr(__locals[__name], "__module__", "httpx")  # noqa
diff --git a/myenv/lib/python3.9/site-packages/httpx/__version__.py b/myenv/lib/python3.9/site-packages/httpx/__version__.py
new file mode 100644
index 0000000..68831d0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/__version__.py
@@ -0,0 +1,3 @@
+__title__ = "httpx"
+__description__ = "A next generation HTTP client, for Python 3."
+__version__ = "0.23.0"
diff --git a/myenv/lib/python3.9/site-packages/httpx/_api.py b/myenv/lib/python3.9/site-packages/httpx/_api.py
new file mode 100644
index 0000000..571289c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_api.py
@@ -0,0 +1,445 @@
+import typing
+from contextlib import contextmanager
+
+from ._client import Client
+from ._config import DEFAULT_TIMEOUT_CONFIG
+from ._models import Response
+from ._types import (
+    AuthTypes,
+    CertTypes,
+    CookieTypes,
+    HeaderTypes,
+    ProxiesTypes,
+    QueryParamTypes,
+    RequestContent,
+    RequestData,
+    RequestFiles,
+    TimeoutTypes,
+    URLTypes,
+    VerifyTypes,
+)
+
+
+def request(
+    method: str,
+    url: URLTypes,
+    *,
+    params: typing.Optional[QueryParamTypes] = None,
+    content: typing.Optional[RequestContent] = None,
+    data: typing.Optional[RequestData] = None,
+    files: typing.Optional[RequestFiles] = None,
+    json: typing.Optional[typing.Any] = None,
+    headers: typing.Optional[HeaderTypes] = None,
+    cookies: typing.Optional[CookieTypes] = None,
+    auth: typing.Optional[AuthTypes] = None,
+    proxies: typing.Optional[ProxiesTypes] = None,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    follow_redirects: bool = False,
+    verify: VerifyTypes = True,
+    cert: typing.Optional[CertTypes] = None,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends an HTTP request.
+
+    **Parameters:**
+
+    * **method** - HTTP method for the new `Request` object: `GET`, `OPTIONS`,
+    `HEAD`, `POST`, `PUT`, `PATCH`, or `DELETE`.
+    * **url** - URL for the new `Request` object.
+    * **params** - *(optional)* Query parameters to include in the URL, as a
+    string, dictionary, or sequence of two-tuples.
+    * **content** - *(optional)* Binary content to include in the body of the
+    request, as bytes or a byte iterator.
+    * **data** - *(optional)* Form data to include in the body of the request,
+    as a dictionary.
+    * **files** - *(optional)* A dictionary of upload files to include in the
+    body of the request.
+    * **json** - *(optional)* A JSON serializable object to include in the body
+    of the request.
+    * **headers** - *(optional)* Dictionary of HTTP headers to include in the
+    request.
+    * **cookies** - *(optional)* Dictionary of Cookie items to include in the
+    request.
+    * **auth** - *(optional)* An authentication class to use when sending the
+    request.
+    * **proxies** - *(optional)* A dictionary mapping proxy keys to proxy URLs.
+    * **timeout** - *(optional)* The timeout configuration to use when sending
+    the request.
+    * **follow_redirects** - *(optional)* Enables or disables HTTP redirects.
+    * **verify** - *(optional)* SSL certificates (a.k.a CA bundle) used to
+    verify the identity of requested hosts. Either `True` (default CA bundle),
+    a path to an SSL certificate file, an `ssl.SSLContext`, or `False`
+    (which will disable verification).
+    * **cert** - *(optional)* An SSL certificate used by the requested host
+    to authenticate the client. Either a path to an SSL certificate file, or
+    two-tuple of (certificate file, key file), or a three-tuple of (certificate
+    file, key file, password).
+    * **trust_env** - *(optional)* Enables or disables usage of environment
+    variables for configuration.
+
+    **Returns:** `Response`
+
+    Usage:
+
+    ```
+    >>> import httpx
+    >>> response = httpx.request('GET', 'https://httpbin.org/get')
+    >>> response
+    <Response [200 OK]>
+    ```
+    """
+    with Client(
+        cookies=cookies,
+        proxies=proxies,
+        cert=cert,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    ) as client:
+        return client.request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            auth=auth,
+            follow_redirects=follow_redirects,
+        )
+
+
+@contextmanager
+def stream(
+    method: str,
+    url: URLTypes,
+    *,
+    params: typing.Optional[QueryParamTypes] = None,
+    content: typing.Optional[RequestContent] = None,
+    data: typing.Optional[RequestData] = None,
+    files: typing.Optional[RequestFiles] = None,
+    json: typing.Optional[typing.Any] = None,
+    headers: typing.Optional[HeaderTypes] = None,
+    cookies: typing.Optional[CookieTypes] = None,
+    auth: typing.Optional[AuthTypes] = None,
+    proxies: typing.Optional[ProxiesTypes] = None,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    follow_redirects: bool = False,
+    verify: VerifyTypes = True,
+    cert: typing.Optional[CertTypes] = None,
+    trust_env: bool = True,
+) -> typing.Iterator[Response]:
+    """
+    Alternative to `httpx.request()` that streams the response body
+    instead of loading it into memory at once.
+
+    **Parameters**: See `httpx.request`.
+
+    See also: [Streaming Responses][0]
+
+    [0]: /quickstart#streaming-responses
+    """
+    with Client(
+        cookies=cookies,
+        proxies=proxies,
+        cert=cert,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    ) as client:
+        with client.stream(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            auth=auth,
+            follow_redirects=follow_redirects,
+        ) as response:
+            yield response
+
+
+def get(
+    url: URLTypes,
+    *,
+    params: typing.Optional[QueryParamTypes] = None,
+    headers: typing.Optional[HeaderTypes] = None,
+    cookies: typing.Optional[CookieTypes] = None,
+    auth: typing.Optional[AuthTypes] = None,
+    proxies: typing.Optional[ProxiesTypes] = None,
+    follow_redirects: bool = False,
+    cert: typing.Optional[CertTypes] = None,
+    verify: VerifyTypes = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `GET` request.
+
+    **Parameters**: See `httpx.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `GET` requests should not include a request body.
+    """
+    return request(
+        "GET",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxies=proxies,
+        follow_redirects=follow_redirects,
+        cert=cert,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def options(
+    url: URLTypes,
+    *,
+    params: typing.Optional[QueryParamTypes] = None,
+    headers: typing.Optional[HeaderTypes] = None,
+    cookies: typing.Optional[CookieTypes] = None,
+    auth: typing.Optional[AuthTypes] = None,
+    proxies: typing.Optional[ProxiesTypes] = None,
+    follow_redirects: bool = False,
+    cert: typing.Optional[CertTypes] = None,
+    verify: VerifyTypes = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends an `OPTIONS` request.
+
+    **Parameters**: See `httpx.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `OPTIONS` requests should not include a request body.
+    """
+    return request(
+        "OPTIONS",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxies=proxies,
+        follow_redirects=follow_redirects,
+        cert=cert,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def head(
+    url: URLTypes,
+    *,
+    params: typing.Optional[QueryParamTypes] = None,
+    headers: typing.Optional[HeaderTypes] = None,
+    cookies: typing.Optional[CookieTypes] = None,
+    auth: typing.Optional[AuthTypes] = None,
+    proxies: typing.Optional[ProxiesTypes] = None,
+    follow_redirects: bool = False,
+    cert: typing.Optional[CertTypes] = None,
+    verify: VerifyTypes = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `HEAD` request.
+
+    **Parameters**: See `httpx.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `HEAD` requests should not include a request body.
+    """
+    return request(
+        "HEAD",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxies=proxies,
+        follow_redirects=follow_redirects,
+        cert=cert,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def post(
+    url: URLTypes,
+    *,
+    content: typing.Optional[RequestContent] = None,
+    data: typing.Optional[RequestData] = None,
+    files: typing.Optional[RequestFiles] = None,
+    json: typing.Optional[typing.Any] = None,
+    params: typing.Optional[QueryParamTypes] = None,
+    headers: typing.Optional[HeaderTypes] = None,
+    cookies: typing.Optional[CookieTypes] = None,
+    auth: typing.Optional[AuthTypes] = None,
+    proxies: typing.Optional[ProxiesTypes] = None,
+    follow_redirects: bool = False,
+    cert: typing.Optional[CertTypes] = None,
+    verify: VerifyTypes = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `POST` request.
+
+    **Parameters**: See `httpx.request`.
+    """
+    return request(
+        "POST",
+        url,
+        content=content,
+        data=data,
+        files=files,
+        json=json,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxies=proxies,
+        follow_redirects=follow_redirects,
+        cert=cert,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def put(
+    url: URLTypes,
+    *,
+    content: typing.Optional[RequestContent] = None,
+    data: typing.Optional[RequestData] = None,
+    files: typing.Optional[RequestFiles] = None,
+    json: typing.Optional[typing.Any] = None,
+    params: typing.Optional[QueryParamTypes] = None,
+    headers: typing.Optional[HeaderTypes] = None,
+    cookies: typing.Optional[CookieTypes] = None,
+    auth: typing.Optional[AuthTypes] = None,
+    proxies: typing.Optional[ProxiesTypes] = None,
+    follow_redirects: bool = False,
+    cert: typing.Optional[CertTypes] = None,
+    verify: VerifyTypes = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `PUT` request.
+
+    **Parameters**: See `httpx.request`.
+    """
+    return request(
+        "PUT",
+        url,
+        content=content,
+        data=data,
+        files=files,
+        json=json,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxies=proxies,
+        follow_redirects=follow_redirects,
+        cert=cert,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def patch(
+    url: URLTypes,
+    *,
+    content: typing.Optional[RequestContent] = None,
+    data: typing.Optional[RequestData] = None,
+    files: typing.Optional[RequestFiles] = None,
+    json: typing.Optional[typing.Any] = None,
+    params: typing.Optional[QueryParamTypes] = None,
+    headers: typing.Optional[HeaderTypes] = None,
+    cookies: typing.Optional[CookieTypes] = None,
+    auth: typing.Optional[AuthTypes] = None,
+    proxies: typing.Optional[ProxiesTypes] = None,
+    follow_redirects: bool = False,
+    cert: typing.Optional[CertTypes] = None,
+    verify: VerifyTypes = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `PATCH` request.
+
+    **Parameters**: See `httpx.request`.
+    """
+    return request(
+        "PATCH",
+        url,
+        content=content,
+        data=data,
+        files=files,
+        json=json,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxies=proxies,
+        follow_redirects=follow_redirects,
+        cert=cert,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def delete(
+    url: URLTypes,
+    *,
+    params: typing.Optional[QueryParamTypes] = None,
+    headers: typing.Optional[HeaderTypes] = None,
+    cookies: typing.Optional[CookieTypes] = None,
+    auth: typing.Optional[AuthTypes] = None,
+    proxies: typing.Optional[ProxiesTypes] = None,
+    follow_redirects: bool = False,
+    cert: typing.Optional[CertTypes] = None,
+    verify: VerifyTypes = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `DELETE` request.
+
+    **Parameters**: See `httpx.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `DELETE` requests should not include a request body.
+    """
+    return request(
+        "DELETE",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxies=proxies,
+        follow_redirects=follow_redirects,
+        cert=cert,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
diff --git a/myenv/lib/python3.9/site-packages/httpx/_auth.py b/myenv/lib/python3.9/site-packages/httpx/_auth.py
new file mode 100644
index 0000000..2b00b49
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_auth.py
@@ -0,0 +1,304 @@
+import hashlib
+import os
+import re
+import time
+import typing
+from base64 import b64encode
+from urllib.request import parse_http_list
+
+from ._exceptions import ProtocolError
+from ._models import Request, Response
+from ._utils import to_bytes, to_str, unquote
+
+
+class Auth:
+    """
+    Base class for all authentication schemes.
+
+    To implement a custom authentication scheme, subclass `Auth` and override
+    the `.auth_flow()` method.
+
+    If the authentication scheme does I/O such as disk access or network calls, or uses
+    synchronization primitives such as locks, you should override `.sync_auth_flow()`
+    and/or `.async_auth_flow()` instead of `.auth_flow()` to provide specialized
+    implementations that will be used by `Client` and `AsyncClient` respectively.
+    """
+
+    requires_request_body = False
+    requires_response_body = False
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        """
+        Execute the authentication flow.
+
+        To dispatch a request, `yield` it:
+
+        ```
+        yield request
+        ```
+
+        The client will `.send()` the response back into the flow generator. You can
+        access it like so:
+
+        ```
+        response = yield request
+        ```
+
+        A `return` (or reaching the end of the generator) will result in the
+        client returning the last response obtained from the server.
+
+        You can dispatch as many requests as is necessary.
+        """
+        yield request
+
+    def sync_auth_flow(
+        self, request: Request
+    ) -> typing.Generator[Request, Response, None]:
+        """
+        Execute the authentication flow synchronously.
+
+        By default, this defers to `.auth_flow()`. You should override this method
+        when the authentication scheme does I/O and/or uses concurrency primitives.
+        """
+        if self.requires_request_body:
+            request.read()
+
+        flow = self.auth_flow(request)
+        request = next(flow)
+
+        while True:
+            response = yield request
+            if self.requires_response_body:
+                response.read()
+
+            try:
+                request = flow.send(response)
+            except StopIteration:
+                break
+
+    async def async_auth_flow(
+        self, request: Request
+    ) -> typing.AsyncGenerator[Request, Response]:
+        """
+        Execute the authentication flow asynchronously.
+
+        By default, this defers to `.auth_flow()`. You should override this method
+        when the authentication scheme does I/O and/or uses concurrency primitives.
+        """
+        if self.requires_request_body:
+            await request.aread()
+
+        flow = self.auth_flow(request)
+        request = next(flow)
+
+        while True:
+            response = yield request
+            if self.requires_response_body:
+                await response.aread()
+
+            try:
+                request = flow.send(response)
+            except StopIteration:
+                break
+
+
+class FunctionAuth(Auth):
+    """
+    Allows the 'auth' argument to be passed as a simple callable function,
+    that takes the request, and returns a new, modified request.
+    """
+
+    def __init__(self, func: typing.Callable[[Request], Request]) -> None:
+        self._func = func
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        yield self._func(request)
+
+
+class BasicAuth(Auth):
+    """
+    Allows the 'auth' argument to be passed as a (username, password) pair,
+    and uses HTTP Basic authentication.
+    """
+
+    def __init__(
+        self, username: typing.Union[str, bytes], password: typing.Union[str, bytes]
+    ):
+        self._auth_header = self._build_auth_header(username, password)
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        request.headers["Authorization"] = self._auth_header
+        yield request
+
+    def _build_auth_header(
+        self, username: typing.Union[str, bytes], password: typing.Union[str, bytes]
+    ) -> str:
+        userpass = b":".join((to_bytes(username), to_bytes(password)))
+        token = b64encode(userpass).decode()
+        return f"Basic {token}"
+
+
+class DigestAuth(Auth):
+    _ALGORITHM_TO_HASH_FUNCTION: typing.Dict[str, typing.Callable] = {
+        "MD5": hashlib.md5,
+        "MD5-SESS": hashlib.md5,
+        "SHA": hashlib.sha1,
+        "SHA-SESS": hashlib.sha1,
+        "SHA-256": hashlib.sha256,
+        "SHA-256-SESS": hashlib.sha256,
+        "SHA-512": hashlib.sha512,
+        "SHA-512-SESS": hashlib.sha512,
+    }
+
+    def __init__(
+        self, username: typing.Union[str, bytes], password: typing.Union[str, bytes]
+    ) -> None:
+        self._username = to_bytes(username)
+        self._password = to_bytes(password)
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        response = yield request
+
+        if response.status_code != 401 or "www-authenticate" not in response.headers:
+            # If the response is not a 401 then we don't
+            # need to build an authenticated request.
+            return
+
+        for auth_header in response.headers.get_list("www-authenticate"):
+            if auth_header.lower().startswith("digest "):
+                break
+        else:
+            # If the response does not include a 'WWW-Authenticate: Digest ...'
+            # header, then we don't need to build an authenticated request.
+            return
+
+        challenge = self._parse_challenge(request, response, auth_header)
+        request.headers["Authorization"] = self._build_auth_header(request, challenge)
+        yield request
+
+    def _parse_challenge(
+        self, request: Request, response: Response, auth_header: str
+    ) -> "_DigestAuthChallenge":
+        """
+        Returns a challenge from a Digest WWW-Authenticate header.
+        These take the form of:
+        `Digest realm="realm@host.com",qop="auth,auth-int",nonce="abc",opaque="xyz"`
+        """
+        scheme, _, fields = auth_header.partition(" ")
+
+        # This method should only ever have been called with a Digest auth header.
+        assert scheme.lower() == "digest"
+
+        header_dict: typing.Dict[str, str] = {}
+        for field in parse_http_list(fields):
+            key, value = field.strip().split("=", 1)
+            header_dict[key] = unquote(value)
+
+        try:
+            realm = header_dict["realm"].encode()
+            nonce = header_dict["nonce"].encode()
+            algorithm = header_dict.get("algorithm", "MD5")
+            opaque = header_dict["opaque"].encode() if "opaque" in header_dict else None
+            qop = header_dict["qop"].encode() if "qop" in header_dict else None
+            return _DigestAuthChallenge(
+                realm=realm, nonce=nonce, algorithm=algorithm, opaque=opaque, qop=qop
+            )
+        except KeyError as exc:
+            message = "Malformed Digest WWW-Authenticate header"
+            raise ProtocolError(message, request=request) from exc
+
+    def _build_auth_header(
+        self, request: Request, challenge: "_DigestAuthChallenge"
+    ) -> str:
+        hash_func = self._ALGORITHM_TO_HASH_FUNCTION[challenge.algorithm.upper()]
+
+        def digest(data: bytes) -> bytes:
+            return hash_func(data).hexdigest().encode()
+
+        A1 = b":".join((self._username, challenge.realm, self._password))
+
+        path = request.url.raw_path
+        A2 = b":".join((request.method.encode(), path))
+        # TODO: implement auth-int
+        HA2 = digest(A2)
+
+        nonce_count = 1  # TODO: implement nonce counting
+        nc_value = b"%08x" % nonce_count
+        cnonce = self._get_client_nonce(nonce_count, challenge.nonce)
+
+        HA1 = digest(A1)
+        if challenge.algorithm.lower().endswith("-sess"):
+            HA1 = digest(b":".join((HA1, challenge.nonce, cnonce)))
+
+        qop = self._resolve_qop(challenge.qop, request=request)
+        if qop is None:
+            digest_data = [HA1, challenge.nonce, HA2]
+        else:
+            digest_data = [challenge.nonce, nc_value, cnonce, qop, HA2]
+        key_digest = b":".join(digest_data)
+
+        format_args = {
+            "username": self._username,
+            "realm": challenge.realm,
+            "nonce": challenge.nonce,
+            "uri": path,
+            "response": digest(b":".join((HA1, key_digest))),
+            "algorithm": challenge.algorithm.encode(),
+        }
+        if challenge.opaque:
+            format_args["opaque"] = challenge.opaque
+        if qop:
+            format_args["qop"] = b"auth"
+            format_args["nc"] = nc_value
+            format_args["cnonce"] = cnonce
+
+        return "Digest " + self._get_header_value(format_args)
+
+    def _get_client_nonce(self, nonce_count: int, nonce: bytes) -> bytes:
+        s = str(nonce_count).encode()
+        s += nonce
+        s += time.ctime().encode()
+        s += os.urandom(8)
+
+        return hashlib.sha1(s).hexdigest()[:16].encode()
+
+    def _get_header_value(self, header_fields: typing.Dict[str, bytes]) -> str:
+        NON_QUOTED_FIELDS = ("algorithm", "qop", "nc")
+        QUOTED_TEMPLATE = '{}="{}"'
+        NON_QUOTED_TEMPLATE = "{}={}"
+
+        header_value = ""
+        for i, (field, value) in enumerate(header_fields.items()):
+            if i > 0:
+                header_value += ", "
+            template = (
+                QUOTED_TEMPLATE
+                if field not in NON_QUOTED_FIELDS
+                else NON_QUOTED_TEMPLATE
+            )
+            header_value += template.format(field, to_str(value))
+
+        return header_value
+
+    def _resolve_qop(
+        self, qop: typing.Optional[bytes], request: Request
+    ) -> typing.Optional[bytes]:
+        if qop is None:
+            return None
+        qops = re.split(b", ?", qop)
+        if b"auth" in qops:
+            return b"auth"
+
+        if qops == [b"auth-int"]:
+            raise NotImplementedError("Digest auth-int support is not yet implemented")
+
+        message = f'Unexpected qop value "{qop!r}" in digest auth'
+        raise ProtocolError(message, request=request)
+
+
+class _DigestAuthChallenge(typing.NamedTuple):
+    realm: bytes
+    nonce: bytes
+    algorithm: str
+    opaque: typing.Optional[bytes]
+    qop: typing.Optional[bytes]
diff --git a/myenv/lib/python3.9/site-packages/httpx/_client.py b/myenv/lib/python3.9/site-packages/httpx/_client.py
new file mode 100644
index 0000000..2ed3f49
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_client.py
@@ -0,0 +1,2000 @@
+import datetime
+import enum
+import typing
+import warnings
+from contextlib import asynccontextmanager, contextmanager
+from types import TracebackType
+
+from .__version__ import __version__
+from ._auth import Auth, BasicAuth, FunctionAuth
+from ._config import (
+    DEFAULT_LIMITS,
+    DEFAULT_MAX_REDIRECTS,
+    DEFAULT_TIMEOUT_CONFIG,
+    Limits,
+    Proxy,
+    Timeout,
+)
+from ._decoders import SUPPORTED_DECODERS
+from ._exceptions import (
+    InvalidURL,
+    RemoteProtocolError,
+    TooManyRedirects,
+    request_context,
+)
+from ._models import Cookies, Headers, Request, Response
+from ._status_codes import codes
+from ._transports.asgi import ASGITransport
+from ._transports.base import AsyncBaseTransport, BaseTransport
+from ._transports.default import AsyncHTTPTransport, HTTPTransport
+from ._transports.wsgi import WSGITransport
+from ._types import (
+    AsyncByteStream,
+    AuthTypes,
+    CertTypes,
+    CookieTypes,
+    HeaderTypes,
+    ProxiesTypes,
+    QueryParamTypes,
+    RequestContent,
+    RequestData,
+    RequestFiles,
+    SyncByteStream,
+    TimeoutTypes,
+    URLTypes,
+    VerifyTypes,
+)
+from ._urls import URL, QueryParams
+from ._utils import (
+    NetRCInfo,
+    Timer,
+    URLPattern,
+    get_environment_proxies,
+    get_logger,
+    is_https_redirect,
+    same_origin,
+)
+
+# The type annotation for @classmethod and context managers here follows PEP 484
+# https://www.python.org/dev/peps/pep-0484/#annotating-instance-and-class-methods
+T = typing.TypeVar("T", bound="Client")
+U = typing.TypeVar("U", bound="AsyncClient")
+
+
+class UseClientDefault:
+    """
+    For some parameters such as `auth=...` and `timeout=...` we need to be able
+    to indicate the default "unset" state, in a way that is distinctly different
+    to using `None`.
+
+    The default "unset" state indicates that whatever default is set on the
+    client should be used. This is different to setting `None`, which
+    explicitly disables the parameter, possibly overriding a client default.
+
+    For example we use `timeout=USE_CLIENT_DEFAULT` in the `request()` signature.
+    Omitting the `timeout` parameter will send a request using whatever default
+    timeout has been configured on the client. Including `timeout=None` will
+    ensure no timeout is used.
+
+    Note that user code shouldn't need to use the `USE_CLIENT_DEFAULT` constant,
+    but it is used internally when a parameter is not included.
+    """
+
+
+USE_CLIENT_DEFAULT = UseClientDefault()
+
+
+logger = get_logger(__name__)
+
+USER_AGENT = f"python-httpx/{__version__}"
+ACCEPT_ENCODING = ", ".join(
+    [key for key in SUPPORTED_DECODERS.keys() if key != "identity"]
+)
+
+
+class ClientState(enum.Enum):
+    # UNOPENED:
+    #   The client has been instantiated, but has not been used to send a request,
+    #   or been opened by entering the context of a `with` block.
+    UNOPENED = 1
+    # OPENED:
+    #   The client has either sent a request, or is within a `with` block.
+    OPENED = 2
+    # CLOSED:
+    #   The client has either exited the `with` block, or `close()` has
+    #   been called explicitly.
+    CLOSED = 3
+
+
+class BoundSyncStream(SyncByteStream):
+    """
+    A byte stream that is bound to a given response instance, and that
+    ensures the `response.elapsed` is set once the response is closed.
+    """
+
+    def __init__(
+        self, stream: SyncByteStream, response: Response, timer: Timer
+    ) -> None:
+        self._stream = stream
+        self._response = response
+        self._timer = timer
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        for chunk in self._stream:
+            yield chunk
+
+    def close(self) -> None:
+        seconds = self._timer.sync_elapsed()
+        self._response.elapsed = datetime.timedelta(seconds=seconds)
+        self._stream.close()
+
+
+class BoundAsyncStream(AsyncByteStream):
+    """
+    An async byte stream that is bound to a given response instance, and that
+    ensures the `response.elapsed` is set once the response is closed.
+    """
+
+    def __init__(
+        self, stream: AsyncByteStream, response: Response, timer: Timer
+    ) -> None:
+        self._stream = stream
+        self._response = response
+        self._timer = timer
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        async for chunk in self._stream:
+            yield chunk
+
+    async def aclose(self) -> None:
+        seconds = await self._timer.async_elapsed()
+        self._response.elapsed = datetime.timedelta(seconds=seconds)
+        await self._stream.aclose()
+
+
+class BaseClient:
+    def __init__(
+        self,
+        *,
+        auth: typing.Optional[AuthTypes] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: typing.Optional[
+            typing.Mapping[str, typing.List[typing.Callable]]
+        ] = None,
+        base_url: URLTypes = "",
+        trust_env: bool = True,
+        default_encoding: typing.Union[str, typing.Callable[[bytes], str]] = "utf-8",
+    ):
+        event_hooks = {} if event_hooks is None else event_hooks
+
+        self._base_url = self._enforce_trailing_slash(URL(base_url))
+
+        self._auth = self._build_auth(auth)
+        self._params = QueryParams(params)
+        self.headers = Headers(headers)
+        self._cookies = Cookies(cookies)
+        self._timeout = Timeout(timeout)
+        self.follow_redirects = follow_redirects
+        self.max_redirects = max_redirects
+        self._event_hooks = {
+            "request": list(event_hooks.get("request", [])),
+            "response": list(event_hooks.get("response", [])),
+        }
+        self._trust_env = trust_env
+        self._default_encoding = default_encoding
+        self._netrc = NetRCInfo()
+        self._state = ClientState.UNOPENED
+
+    @property
+    def is_closed(self) -> bool:
+        """
+        Check if the client being closed
+        """
+        return self._state == ClientState.CLOSED
+
+    @property
+    def trust_env(self) -> bool:
+        return self._trust_env
+
+    def _enforce_trailing_slash(self, url: URL) -> URL:
+        if url.raw_path.endswith(b"/"):
+            return url
+        return url.copy_with(raw_path=url.raw_path + b"/")
+
+    def _get_proxy_map(
+        self, proxies: typing.Optional[ProxiesTypes], allow_env_proxies: bool
+    ) -> typing.Dict[str, typing.Optional[Proxy]]:
+        if proxies is None:
+            if allow_env_proxies:
+                return {
+                    key: None if url is None else Proxy(url=url)
+                    for key, url in get_environment_proxies().items()
+                }
+            return {}
+        if isinstance(proxies, dict):
+            new_proxies = {}
+            for key, value in proxies.items():
+                proxy = Proxy(url=value) if isinstance(value, (str, URL)) else value
+                new_proxies[str(key)] = proxy
+            return new_proxies
+        else:
+            proxy = Proxy(url=proxies) if isinstance(proxies, (str, URL)) else proxies
+            return {"all://": proxy}
+
+    @property
+    def timeout(self) -> Timeout:
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, timeout: TimeoutTypes) -> None:
+        self._timeout = Timeout(timeout)
+
+    @property
+    def event_hooks(self) -> typing.Dict[str, typing.List[typing.Callable]]:
+        return self._event_hooks
+
+    @event_hooks.setter
+    def event_hooks(
+        self, event_hooks: typing.Dict[str, typing.List[typing.Callable]]
+    ) -> None:
+        self._event_hooks = {
+            "request": list(event_hooks.get("request", [])),
+            "response": list(event_hooks.get("response", [])),
+        }
+
+    @property
+    def auth(self) -> typing.Optional[Auth]:
+        """
+        Authentication class used when none is passed at the request-level.
+
+        See also [Authentication][0].
+
+        [0]: /quickstart/#authentication
+        """
+        return self._auth
+
+    @auth.setter
+    def auth(self, auth: AuthTypes) -> None:
+        self._auth = self._build_auth(auth)
+
+    @property
+    def base_url(self) -> URL:
+        """
+        Base URL to use when sending requests with relative URLs.
+        """
+        return self._base_url
+
+    @base_url.setter
+    def base_url(self, url: URLTypes) -> None:
+        self._base_url = self._enforce_trailing_slash(URL(url))
+
+    @property
+    def headers(self) -> Headers:
+        """
+        HTTP headers to include when sending requests.
+        """
+        return self._headers
+
+    @headers.setter
+    def headers(self, headers: HeaderTypes) -> None:
+        client_headers = Headers(
+            {
+                b"Accept": b"*/*",
+                b"Accept-Encoding": ACCEPT_ENCODING.encode("ascii"),
+                b"Connection": b"keep-alive",
+                b"User-Agent": USER_AGENT.encode("ascii"),
+            }
+        )
+        client_headers.update(headers)
+        self._headers = client_headers
+
+    @property
+    def cookies(self) -> Cookies:
+        """
+        Cookie values to include when sending requests.
+        """
+        return self._cookies
+
+    @cookies.setter
+    def cookies(self, cookies: CookieTypes) -> None:
+        self._cookies = Cookies(cookies)
+
+    @property
+    def params(self) -> QueryParams:
+        """
+        Query parameters to include in the URL when sending requests.
+        """
+        return self._params
+
+    @params.setter
+    def params(self, params: QueryParamTypes) -> None:
+        self._params = QueryParams(params)
+
+    def build_request(
+        self,
+        method: str,
+        url: URLTypes,
+        *,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Request:
+        """
+        Build and return a request instance.
+
+        * The `params`, `headers` and `cookies` arguments
+        are merged with any values set on the client.
+        * The `url` argument is merged with any `base_url` set on the client.
+
+        See also: [Request instances][0]
+
+        [0]: /advanced/#request-instances
+        """
+        url = self._merge_url(url)
+        headers = self._merge_headers(headers)
+        cookies = self._merge_cookies(cookies)
+        params = self._merge_queryparams(params)
+        extensions = {} if extensions is None else extensions
+        if "timeout" not in extensions:
+            timeout = (
+                self.timeout
+                if isinstance(timeout, UseClientDefault)
+                else Timeout(timeout)
+            )
+            extensions["timeout"] = timeout.as_dict()
+        return Request(
+            method,
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            extensions=extensions,
+        )
+
+    def _merge_url(self, url: URLTypes) -> URL:
+        """
+        Merge a URL argument together with any 'base_url' on the client,
+        to create the URL used for the outgoing request.
+        """
+        merge_url = URL(url)
+        if merge_url.is_relative_url:
+            # To merge URLs we always append to the base URL. To get this
+            # behaviour correct we always ensure the base URL ends in a '/'
+            # separator, and strip any leading '/' from the merge URL.
+            #
+            # So, eg...
+            #
+            # >>> client = Client(base_url="https://www.example.com/subpath")
+            # >>> client.base_url
+            # URL('https://www.example.com/subpath/')
+            # >>> client.build_request("GET", "/path").url
+            # URL('https://www.example.com/subpath/path')
+            merge_raw_path = self.base_url.raw_path + merge_url.raw_path.lstrip(b"/")
+            return self.base_url.copy_with(raw_path=merge_raw_path)
+        return merge_url
+
+    def _merge_cookies(
+        self, cookies: typing.Optional[CookieTypes] = None
+    ) -> typing.Optional[CookieTypes]:
+        """
+        Merge a cookies argument together with any cookies on the client,
+        to create the cookies used for the outgoing request.
+        """
+        if cookies or self.cookies:
+            merged_cookies = Cookies(self.cookies)
+            merged_cookies.update(cookies)
+            return merged_cookies
+        return cookies
+
+    def _merge_headers(
+        self, headers: typing.Optional[HeaderTypes] = None
+    ) -> typing.Optional[HeaderTypes]:
+        """
+        Merge a headers argument together with any headers on the client,
+        to create the headers used for the outgoing request.
+        """
+        merged_headers = Headers(self.headers)
+        merged_headers.update(headers)
+        return merged_headers
+
+    def _merge_queryparams(
+        self, params: typing.Optional[QueryParamTypes] = None
+    ) -> typing.Optional[QueryParamTypes]:
+        """
+        Merge a queryparams argument together with any queryparams on the client,
+        to create the queryparams used for the outgoing request.
+        """
+        if params or self.params:
+            merged_queryparams = QueryParams(self.params)
+            return merged_queryparams.merge(params)
+        return params
+
+    def _build_auth(self, auth: typing.Optional[AuthTypes]) -> typing.Optional[Auth]:
+        if auth is None:
+            return None
+        elif isinstance(auth, tuple):
+            return BasicAuth(username=auth[0], password=auth[1])
+        elif isinstance(auth, Auth):
+            return auth
+        elif callable(auth):
+            return FunctionAuth(func=auth)
+        else:
+            raise TypeError(f'Invalid "auth" argument: {auth!r}')
+
+    def _build_request_auth(
+        self,
+        request: Request,
+        auth: typing.Union[AuthTypes, UseClientDefault, None] = USE_CLIENT_DEFAULT,
+    ) -> Auth:
+        auth = (
+            self._auth if isinstance(auth, UseClientDefault) else self._build_auth(auth)
+        )
+
+        if auth is not None:
+            return auth
+
+        username, password = request.url.username, request.url.password
+        if username or password:
+            return BasicAuth(username=username, password=password)
+
+        if self.trust_env and "Authorization" not in request.headers:
+            credentials = self._netrc.get_credentials(request.url.host)
+            if credentials is not None:
+                return BasicAuth(username=credentials[0], password=credentials[1])
+
+        return Auth()
+
+    def _build_redirect_request(self, request: Request, response: Response) -> Request:
+        """
+        Given a request and a redirect response, return a new request that
+        should be used to effect the redirect.
+        """
+        method = self._redirect_method(request, response)
+        url = self._redirect_url(request, response)
+        headers = self._redirect_headers(request, url, method)
+        stream = self._redirect_stream(request, method)
+        cookies = Cookies(self.cookies)
+        return Request(
+            method=method,
+            url=url,
+            headers=headers,
+            cookies=cookies,
+            stream=stream,
+            extensions=request.extensions,
+        )
+
+    def _redirect_method(self, request: Request, response: Response) -> str:
+        """
+        When being redirected we may want to change the method of the request
+        based on certain specs or browser behavior.
+        """
+        method = request.method
+
+        # https://tools.ietf.org/html/rfc7231#section-6.4.4
+        if response.status_code == codes.SEE_OTHER and method != "HEAD":
+            method = "GET"
+
+        # Do what the browsers do, despite standards...
+        # Turn 302s into GETs.
+        if response.status_code == codes.FOUND and method != "HEAD":
+            method = "GET"
+
+        # If a POST is responded to with a 301, turn it into a GET.
+        # This bizarre behaviour is explained in 'requests' issue 1704.
+        if response.status_code == codes.MOVED_PERMANENTLY and method == "POST":
+            method = "GET"
+
+        return method
+
+    def _redirect_url(self, request: Request, response: Response) -> URL:
+        """
+        Return the URL for the redirect to follow.
+        """
+        location = response.headers["Location"]
+
+        try:
+            url = URL(location)
+        except InvalidURL as exc:
+            raise RemoteProtocolError(
+                f"Invalid URL in location header: {exc}.", request=request
+            ) from None
+
+        # Handle malformed 'Location' headers that are "absolute" form, have no host.
+        # See: https://github.com/encode/httpx/issues/771
+        if url.scheme and not url.host:
+            url = url.copy_with(host=request.url.host)
+
+        # Facilitate relative 'Location' headers, as allowed by RFC 7231.
+        # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
+        if url.is_relative_url:
+            url = request.url.join(url)
+
+        # Attach previous fragment if needed (RFC 7231 7.1.2)
+        if request.url.fragment and not url.fragment:
+            url = url.copy_with(fragment=request.url.fragment)
+
+        return url
+
+    def _redirect_headers(self, request: Request, url: URL, method: str) -> Headers:
+        """
+        Return the headers that should be used for the redirect request.
+        """
+        headers = Headers(request.headers)
+
+        if not same_origin(url, request.url):
+            if not is_https_redirect(request.url, url):
+                # Strip Authorization headers when responses are redirected
+                # away from the origin. (Except for direct HTTP to HTTPS redirects.)
+                headers.pop("Authorization", None)
+
+            # Update the Host header.
+            headers["Host"] = url.netloc.decode("ascii")
+
+        if method != request.method and method == "GET":
+            # If we've switch to a 'GET' request, then strip any headers which
+            # are only relevant to the request body.
+            headers.pop("Content-Length", None)
+            headers.pop("Transfer-Encoding", None)
+
+        # We should use the client cookie store to determine any cookie header,
+        # rather than whatever was on the original outgoing request.
+        headers.pop("Cookie", None)
+
+        return headers
+
+    def _redirect_stream(
+        self, request: Request, method: str
+    ) -> typing.Optional[typing.Union[SyncByteStream, AsyncByteStream]]:
+        """
+        Return the body that should be used for the redirect request.
+        """
+        if method != request.method and method == "GET":
+            return None
+
+        return request.stream
+
+
+class Client(BaseClient):
+    """
+    An HTTP client, with connection pooling, HTTP/2, redirects, cookie persistence, etc.
+
+    Usage:
+
+    ```python
+    >>> client = httpx.Client()
+    >>> response = client.get('https://example.org')
+    ```
+
+    **Parameters:**
+
+    * **auth** - *(optional)* An authentication class to use when sending
+    requests.
+    * **params** - *(optional)* Query parameters to include in request URLs, as
+    a string, dictionary, or sequence of two-tuples.
+    * **headers** - *(optional)* Dictionary of HTTP headers to include when
+    sending requests.
+    * **cookies** - *(optional)* Dictionary of Cookie items to include when
+    sending requests.
+    * **verify** - *(optional)* SSL certificates (a.k.a CA bundle) used to
+    verify the identity of requested hosts. Either `True` (default CA bundle),
+    a path to an SSL certificate file, an `ssl.SSLContext`, or `False`
+    (which will disable verification).
+    * **cert** - *(optional)* An SSL certificate used by the requested host
+    to authenticate the client. Either a path to an SSL certificate file, or
+    two-tuple of (certificate file, key file), or a three-tuple of (certificate
+    file, key file, password).
+    * **proxies** - *(optional)* A dictionary mapping proxy keys to proxy
+    URLs.
+    * **timeout** - *(optional)* The timeout configuration to use when sending
+    requests.
+    * **limits** - *(optional)* The limits configuration to use.
+    * **max_redirects** - *(optional)* The maximum number of redirect responses
+    that should be followed.
+    * **base_url** - *(optional)* A URL to use as the base when building
+    request URLs.
+    * **transport** - *(optional)* A transport class to use for sending requests
+    over the network.
+    * **app** - *(optional)* An WSGI application to send requests to,
+    rather than sending actual network requests.
+    * **trust_env** - *(optional)* Enables or disables usage of environment
+    variables for configuration.
+    * **default_encoding** - *(optional)* The default encoding to use for decoding
+    response text, if no charset information is included in a response Content-Type
+    header. Set to a callable for automatic character set detection. Default: "utf-8".
+    """
+
+    def __init__(
+        self,
+        *,
+        auth: typing.Optional[AuthTypes] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        verify: VerifyTypes = True,
+        cert: typing.Optional[CertTypes] = None,
+        http1: bool = True,
+        http2: bool = False,
+        proxies: typing.Optional[ProxiesTypes] = None,
+        mounts: typing.Optional[typing.Mapping[str, BaseTransport]] = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: typing.Optional[
+            typing.Mapping[str, typing.List[typing.Callable]]
+        ] = None,
+        base_url: URLTypes = "",
+        transport: typing.Optional[BaseTransport] = None,
+        app: typing.Optional[typing.Callable] = None,
+        trust_env: bool = True,
+        default_encoding: typing.Union[str, typing.Callable[[bytes], str]] = "utf-8",
+    ):
+        super().__init__(
+            auth=auth,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            follow_redirects=follow_redirects,
+            max_redirects=max_redirects,
+            event_hooks=event_hooks,
+            base_url=base_url,
+            trust_env=trust_env,
+            default_encoding=default_encoding,
+        )
+
+        if http2:
+            try:
+                import h2  # noqa
+            except ImportError:  # pragma: nocover
+                raise ImportError(
+                    "Using http2=True, but the 'h2' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[http2]`."
+                ) from None
+
+        allow_env_proxies = trust_env and app is None and transport is None
+        proxy_map = self._get_proxy_map(proxies, allow_env_proxies)
+
+        self._transport = self._init_transport(
+            verify=verify,
+            cert=cert,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            transport=transport,
+            app=app,
+            trust_env=trust_env,
+        )
+        self._mounts: typing.Dict[URLPattern, typing.Optional[BaseTransport]] = {
+            URLPattern(key): None
+            if proxy is None
+            else self._init_proxy_transport(
+                proxy,
+                verify=verify,
+                cert=cert,
+                http1=http1,
+                http2=http2,
+                limits=limits,
+                trust_env=trust_env,
+            )
+            for key, proxy in proxy_map.items()
+        }
+        if mounts is not None:
+            self._mounts.update(
+                {URLPattern(key): transport for key, transport in mounts.items()}
+            )
+
+        self._mounts = dict(sorted(self._mounts.items()))
+
+    def _init_transport(
+        self,
+        verify: VerifyTypes = True,
+        cert: typing.Optional[CertTypes] = None,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        transport: typing.Optional[BaseTransport] = None,
+        app: typing.Optional[typing.Callable] = None,
+        trust_env: bool = True,
+    ) -> BaseTransport:
+        if transport is not None:
+            return transport
+
+        if app is not None:
+            return WSGITransport(app=app)
+
+        return HTTPTransport(
+            verify=verify,
+            cert=cert,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            trust_env=trust_env,
+        )
+
+    def _init_proxy_transport(
+        self,
+        proxy: Proxy,
+        verify: VerifyTypes = True,
+        cert: typing.Optional[CertTypes] = None,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        trust_env: bool = True,
+    ) -> BaseTransport:
+        return HTTPTransport(
+            verify=verify,
+            cert=cert,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            trust_env=trust_env,
+            proxy=proxy,
+        )
+
+    def _transport_for_url(self, url: URL) -> BaseTransport:
+        """
+        Returns the transport instance that should be used for a given URL.
+        This will either be the standard connection pool, or a proxy.
+        """
+        for pattern, transport in self._mounts.items():
+            if pattern.matches(url):
+                return self._transport if transport is None else transport
+
+        return self._transport
+
+    def request(
+        self,
+        method: str,
+        url: URLTypes,
+        *,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault, None] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Build and send a request.
+
+        Equivalent to:
+
+        ```python
+        request = client.build_request(...)
+        response = client.send(request, ...)
+        ```
+
+        See `Client.build_request()`, `Client.send()` and
+        [Merging of configuration][0] for how the various parameters
+        are merged with client-level configuration.
+
+        [0]: /advanced/#merging-of-configuration
+        """
+        if cookies is not None:
+            message = (
+                "Setting per-request cookies=<...> is being deprecated, because "
+                "the expected behaviour on cookie persistence is ambiguous. Set "
+                "cookies directly on the client instance instead."
+            )
+            warnings.warn(message, DeprecationWarning)
+
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        return self.send(request, auth=auth, follow_redirects=follow_redirects)
+
+    @contextmanager
+    def stream(
+        self,
+        method: str,
+        url: URLTypes,
+        *,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault, None] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> typing.Iterator[Response]:
+        """
+        Alternative to `httpx.request()` that streams the response body
+        instead of loading it into memory at once.
+
+        **Parameters**: See `httpx.request`.
+
+        See also: [Streaming Responses][0]
+
+        [0]: /quickstart#streaming-responses
+        """
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        response = self.send(
+            request=request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            stream=True,
+        )
+        try:
+            yield response
+        finally:
+            response.close()
+
+    def send(
+        self,
+        request: Request,
+        *,
+        stream: bool = False,
+        auth: typing.Union[AuthTypes, UseClientDefault, None] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+    ) -> Response:
+        """
+        Send a request.
+
+        The request is sent as-is, unmodified.
+
+        Typically you'll want to build one with `Client.build_request()`
+        so that any client-level configuration is merged into the request,
+        but passing an explicit `httpx.Request()` is supported as well.
+
+        See also: [Request instances][0]
+
+        [0]: /advanced/#request-instances
+        """
+        if self._state == ClientState.CLOSED:
+            raise RuntimeError("Cannot send a request, as the client has been closed.")
+
+        self._state = ClientState.OPENED
+        follow_redirects = (
+            self.follow_redirects
+            if isinstance(follow_redirects, UseClientDefault)
+            else follow_redirects
+        )
+
+        auth = self._build_request_auth(request, auth)
+
+        response = self._send_handling_auth(
+            request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            history=[],
+        )
+        try:
+            if not stream:
+                response.read()
+
+            return response
+
+        except BaseException as exc:
+            response.close()
+            raise exc
+
+    def _send_handling_auth(
+        self,
+        request: Request,
+        auth: Auth,
+        follow_redirects: bool,
+        history: typing.List[Response],
+    ) -> Response:
+        auth_flow = auth.sync_auth_flow(request)
+        try:
+            request = next(auth_flow)
+
+            while True:
+                response = self._send_handling_redirects(
+                    request,
+                    follow_redirects=follow_redirects,
+                    history=history,
+                )
+                try:
+                    try:
+                        next_request = auth_flow.send(response)
+                    except StopIteration:
+                        return response
+
+                    response.history = list(history)
+                    response.read()
+                    request = next_request
+                    history.append(response)
+
+                except BaseException as exc:
+                    response.close()
+                    raise exc
+        finally:
+            auth_flow.close()
+
+    def _send_handling_redirects(
+        self,
+        request: Request,
+        follow_redirects: bool,
+        history: typing.List[Response],
+    ) -> Response:
+        while True:
+            if len(history) > self.max_redirects:
+                raise TooManyRedirects(
+                    "Exceeded maximum allowed redirects.", request=request
+                )
+
+            for hook in self._event_hooks["request"]:
+                hook(request)
+
+            response = self._send_single_request(request)
+            try:
+                for hook in self._event_hooks["response"]:
+                    hook(response)
+                response.history = list(history)
+
+                if not response.has_redirect_location:
+                    return response
+
+                request = self._build_redirect_request(request, response)
+                history = history + [response]
+
+                if follow_redirects:
+                    response.read()
+                else:
+                    response.next_request = request
+                    return response
+
+            except BaseException as exc:
+                response.close()
+                raise exc
+
+    def _send_single_request(self, request: Request) -> Response:
+        """
+        Sends a single request, without handling any redirections.
+        """
+        transport = self._transport_for_url(request.url)
+        timer = Timer()
+        timer.sync_start()
+
+        if not isinstance(request.stream, SyncByteStream):
+            raise RuntimeError(
+                "Attempted to send an async request with a sync Client instance."
+            )
+
+        with request_context(request=request):
+            response = transport.handle_request(request)
+
+        assert isinstance(response.stream, SyncByteStream)
+
+        response.request = request
+        response.stream = BoundSyncStream(
+            response.stream, response=response, timer=timer
+        )
+        self.cookies.extract_cookies(response)
+        response.default_encoding = self._default_encoding
+
+        status = f"{response.status_code} {response.reason_phrase}"
+        response_line = f"{response.http_version} {status}"
+        logger.debug(
+            'HTTP Request: %s %s "%s"', request.method, request.url, response_line
+        )
+
+        return response
+
+    def get(
+        self,
+        url: URLTypes,
+        *,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `GET` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "GET",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def options(
+        self,
+        url: URLTypes,
+        *,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send an `OPTIONS` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "OPTIONS",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def head(
+        self,
+        url: URLTypes,
+        *,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `HEAD` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "HEAD",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def post(
+        self,
+        url: URLTypes,
+        *,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `POST` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "POST",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def put(
+        self,
+        url: URLTypes,
+        *,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `PUT` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "PUT",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def patch(
+        self,
+        url: URLTypes,
+        *,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `PATCH` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "PATCH",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def delete(
+        self,
+        url: URLTypes,
+        *,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `DELETE` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "DELETE",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def close(self) -> None:
+        """
+        Close transport and proxies.
+        """
+        if self._state != ClientState.CLOSED:
+            self._state = ClientState.CLOSED
+
+            self._transport.close()
+            for transport in self._mounts.values():
+                if transport is not None:
+                    transport.close()
+
+    def __enter__(self: T) -> T:
+        if self._state != ClientState.UNOPENED:
+            msg = {
+                ClientState.OPENED: "Cannot open a client instance more than once.",
+                ClientState.CLOSED: "Cannot reopen a client instance, once it has been closed.",
+            }[self._state]
+            raise RuntimeError(msg)
+
+        self._state = ClientState.OPENED
+
+        self._transport.__enter__()
+        for transport in self._mounts.values():
+            if transport is not None:
+                transport.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]] = None,
+        exc_value: typing.Optional[BaseException] = None,
+        traceback: typing.Optional[TracebackType] = None,
+    ) -> None:
+        self._state = ClientState.CLOSED
+
+        self._transport.__exit__(exc_type, exc_value, traceback)
+        for transport in self._mounts.values():
+            if transport is not None:
+                transport.__exit__(exc_type, exc_value, traceback)
+
+
+class AsyncClient(BaseClient):
+    """
+    An asynchronous HTTP client, with connection pooling, HTTP/2, redirects,
+    cookie persistence, etc.
+
+    Usage:
+
+    ```python
+    >>> async with httpx.AsyncClient() as client:
+    >>>     response = await client.get('https://example.org')
+    ```
+
+    **Parameters:**
+
+    * **auth** - *(optional)* An authentication class to use when sending
+    requests.
+    * **params** - *(optional)* Query parameters to include in request URLs, as
+    a string, dictionary, or sequence of two-tuples.
+    * **headers** - *(optional)* Dictionary of HTTP headers to include when
+    sending requests.
+    * **cookies** - *(optional)* Dictionary of Cookie items to include when
+    sending requests.
+    * **verify** - *(optional)* SSL certificates (a.k.a CA bundle) used to
+    verify the identity of requested hosts. Either `True` (default CA bundle),
+    a path to an SSL certificate file, or `False` (disable verification).
+    * **cert** - *(optional)* An SSL certificate used by the requested host
+    to authenticate the client. Either a path to an SSL certificate file, or
+    two-tuple of (certificate file, key file), or a three-tuple of (certificate
+    file, key file, password).
+    * **http2** - *(optional)* A boolean indicating if HTTP/2 support should be
+    enabled. Defaults to `False`.
+    * **proxies** - *(optional)* A dictionary mapping HTTP protocols to proxy
+    URLs.
+    * **timeout** - *(optional)* The timeout configuration to use when sending
+    requests.
+    * **limits** - *(optional)* The limits configuration to use.
+    * **max_redirects** - *(optional)* The maximum number of redirect responses
+    that should be followed.
+    * **base_url** - *(optional)* A URL to use as the base when building
+    request URLs.
+    * **transport** - *(optional)* A transport class to use for sending requests
+    over the network.
+    * **app** - *(optional)* An ASGI application to send requests to,
+    rather than sending actual network requests.
+    * **trust_env** - *(optional)* Enables or disables usage of environment
+    variables for configuration.
+    * **default_encoding** - *(optional)* The default encoding to use for decoding
+    response text, if no charset information is included in a response Content-Type
+    header. Set to a callable for automatic character set detection. Default: "utf-8".
+    """
+
+    def __init__(
+        self,
+        *,
+        auth: typing.Optional[AuthTypes] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        verify: VerifyTypes = True,
+        cert: typing.Optional[CertTypes] = None,
+        http1: bool = True,
+        http2: bool = False,
+        proxies: typing.Optional[ProxiesTypes] = None,
+        mounts: typing.Optional[typing.Mapping[str, AsyncBaseTransport]] = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: typing.Optional[
+            typing.Mapping[str, typing.List[typing.Callable]]
+        ] = None,
+        base_url: URLTypes = "",
+        transport: typing.Optional[AsyncBaseTransport] = None,
+        app: typing.Optional[typing.Callable] = None,
+        trust_env: bool = True,
+        default_encoding: str = "utf-8",
+    ):
+        super().__init__(
+            auth=auth,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            follow_redirects=follow_redirects,
+            max_redirects=max_redirects,
+            event_hooks=event_hooks,
+            base_url=base_url,
+            trust_env=trust_env,
+            default_encoding=default_encoding,
+        )
+
+        if http2:
+            try:
+                import h2  # noqa
+            except ImportError:  # pragma: nocover
+                raise ImportError(
+                    "Using http2=True, but the 'h2' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[http2]`."
+                ) from None
+
+        allow_env_proxies = trust_env and app is None and transport is None
+        proxy_map = self._get_proxy_map(proxies, allow_env_proxies)
+
+        self._transport = self._init_transport(
+            verify=verify,
+            cert=cert,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            transport=transport,
+            app=app,
+            trust_env=trust_env,
+        )
+
+        self._mounts: typing.Dict[URLPattern, typing.Optional[AsyncBaseTransport]] = {
+            URLPattern(key): None
+            if proxy is None
+            else self._init_proxy_transport(
+                proxy,
+                verify=verify,
+                cert=cert,
+                http1=http1,
+                http2=http2,
+                limits=limits,
+                trust_env=trust_env,
+            )
+            for key, proxy in proxy_map.items()
+        }
+        if mounts is not None:
+            self._mounts.update(
+                {URLPattern(key): transport for key, transport in mounts.items()}
+            )
+        self._mounts = dict(sorted(self._mounts.items()))
+
+    def _init_transport(
+        self,
+        verify: VerifyTypes = True,
+        cert: typing.Optional[CertTypes] = None,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        transport: typing.Optional[AsyncBaseTransport] = None,
+        app: typing.Optional[typing.Callable] = None,
+        trust_env: bool = True,
+    ) -> AsyncBaseTransport:
+        if transport is not None:
+            return transport
+
+        if app is not None:
+            return ASGITransport(app=app)
+
+        return AsyncHTTPTransport(
+            verify=verify,
+            cert=cert,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            trust_env=trust_env,
+        )
+
+    def _init_proxy_transport(
+        self,
+        proxy: Proxy,
+        verify: VerifyTypes = True,
+        cert: typing.Optional[CertTypes] = None,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        trust_env: bool = True,
+    ) -> AsyncBaseTransport:
+        return AsyncHTTPTransport(
+            verify=verify,
+            cert=cert,
+            http2=http2,
+            limits=limits,
+            trust_env=trust_env,
+            proxy=proxy,
+        )
+
+    def _transport_for_url(self, url: URL) -> AsyncBaseTransport:
+        """
+        Returns the transport instance that should be used for a given URL.
+        This will either be the standard connection pool, or a proxy.
+        """
+        for pattern, transport in self._mounts.items():
+            if pattern.matches(url):
+                return self._transport if transport is None else transport
+
+        return self._transport
+
+    async def request(
+        self,
+        method: str,
+        url: URLTypes,
+        *,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault, None] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Build and send a request.
+
+        Equivalent to:
+
+        ```python
+        request = client.build_request(...)
+        response = await client.send(request, ...)
+        ```
+
+        See `AsyncClient.build_request()`, `AsyncClient.send()`
+        and [Merging of configuration][0] for how the various parameters
+        are merged with client-level configuration.
+
+        [0]: /advanced/#merging-of-configuration
+        """
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        return await self.send(request, auth=auth, follow_redirects=follow_redirects)
+
+    @asynccontextmanager
+    async def stream(
+        self,
+        method: str,
+        url: URLTypes,
+        *,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> typing.AsyncIterator[Response]:
+        """
+        Alternative to `httpx.request()` that streams the response body
+        instead of loading it into memory at once.
+
+        **Parameters**: See `httpx.request`.
+
+        See also: [Streaming Responses][0]
+
+        [0]: /quickstart#streaming-responses
+        """
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        response = await self.send(
+            request=request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            stream=True,
+        )
+        try:
+            yield response
+        finally:
+            await response.aclose()
+
+    async def send(
+        self,
+        request: Request,
+        *,
+        stream: bool = False,
+        auth: typing.Union[AuthTypes, UseClientDefault, None] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+    ) -> Response:
+        """
+        Send a request.
+
+        The request is sent as-is, unmodified.
+
+        Typically you'll want to build one with `AsyncClient.build_request()`
+        so that any client-level configuration is merged into the request,
+        but passing an explicit `httpx.Request()` is supported as well.
+
+        See also: [Request instances][0]
+
+        [0]: /advanced/#request-instances
+        """
+        if self._state == ClientState.CLOSED:
+            raise RuntimeError("Cannot send a request, as the client has been closed.")
+
+        self._state = ClientState.OPENED
+        follow_redirects = (
+            self.follow_redirects
+            if isinstance(follow_redirects, UseClientDefault)
+            else follow_redirects
+        )
+
+        auth = self._build_request_auth(request, auth)
+
+        response = await self._send_handling_auth(
+            request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            history=[],
+        )
+        try:
+            if not stream:
+                await response.aread()
+
+            return response
+
+        except BaseException as exc:  # pragma: no cover
+            await response.aclose()
+            raise exc
+
+    async def _send_handling_auth(
+        self,
+        request: Request,
+        auth: Auth,
+        follow_redirects: bool,
+        history: typing.List[Response],
+    ) -> Response:
+        auth_flow = auth.async_auth_flow(request)
+        try:
+            request = await auth_flow.__anext__()
+
+            while True:
+                response = await self._send_handling_redirects(
+                    request,
+                    follow_redirects=follow_redirects,
+                    history=history,
+                )
+                try:
+                    try:
+                        next_request = await auth_flow.asend(response)
+                    except StopAsyncIteration:
+                        return response
+
+                    response.history = list(history)
+                    await response.aread()
+                    request = next_request
+                    history.append(response)
+
+                except BaseException as exc:
+                    await response.aclose()
+                    raise exc
+        finally:
+            await auth_flow.aclose()
+
+    async def _send_handling_redirects(
+        self,
+        request: Request,
+        follow_redirects: bool,
+        history: typing.List[Response],
+    ) -> Response:
+        while True:
+            if len(history) > self.max_redirects:
+                raise TooManyRedirects(
+                    "Exceeded maximum allowed redirects.", request=request
+                )
+
+            for hook in self._event_hooks["request"]:
+                await hook(request)
+
+            response = await self._send_single_request(request)
+            try:
+                for hook in self._event_hooks["response"]:
+                    await hook(response)
+
+                response.history = list(history)
+
+                if not response.has_redirect_location:
+                    return response
+
+                request = self._build_redirect_request(request, response)
+                history = history + [response]
+
+                if follow_redirects:
+                    await response.aread()
+                else:
+                    response.next_request = request
+                    return response
+
+            except BaseException as exc:
+                await response.aclose()
+                raise exc
+
+    async def _send_single_request(self, request: Request) -> Response:
+        """
+        Sends a single request, without handling any redirections.
+        """
+        transport = self._transport_for_url(request.url)
+        timer = Timer()
+        await timer.async_start()
+
+        if not isinstance(request.stream, AsyncByteStream):
+            raise RuntimeError(
+                "Attempted to send an sync request with an AsyncClient instance."
+            )
+
+        with request_context(request=request):
+            response = await transport.handle_async_request(request)
+
+        assert isinstance(response.stream, AsyncByteStream)
+        response.request = request
+        response.stream = BoundAsyncStream(
+            response.stream, response=response, timer=timer
+        )
+        self.cookies.extract_cookies(response)
+        response.default_encoding = self._default_encoding
+
+        status = f"{response.status_code} {response.reason_phrase}"
+        response_line = f"{response.http_version} {status}"
+        logger.debug(
+            'HTTP Request: %s %s "%s"', request.method, request.url, response_line
+        )
+
+        return response
+
+    async def get(
+        self,
+        url: URLTypes,
+        *,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault, None] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `GET` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "GET",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def options(
+        self,
+        url: URLTypes,
+        *,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send an `OPTIONS` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "OPTIONS",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def head(
+        self,
+        url: URLTypes,
+        *,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `HEAD` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "HEAD",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def post(
+        self,
+        url: URLTypes,
+        *,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `POST` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "POST",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def put(
+        self,
+        url: URLTypes,
+        *,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `PUT` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "PUT",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def patch(
+        self,
+        url: URLTypes,
+        *,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `PATCH` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "PATCH",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def delete(
+        self,
+        url: URLTypes,
+        *,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
+        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        extensions: typing.Optional[dict] = None,
+    ) -> Response:
+        """
+        Send a `DELETE` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "DELETE",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def aclose(self) -> None:
+        """
+        Close transport and proxies.
+        """
+        if self._state != ClientState.CLOSED:
+            self._state = ClientState.CLOSED
+
+            await self._transport.aclose()
+            for proxy in self._mounts.values():
+                if proxy is not None:
+                    await proxy.aclose()
+
+    async def __aenter__(self: U) -> U:
+        if self._state != ClientState.UNOPENED:
+            msg = {
+                ClientState.OPENED: "Cannot open a client instance more than once.",
+                ClientState.CLOSED: "Cannot reopen a client instance, once it has been closed.",
+            }[self._state]
+            raise RuntimeError(msg)
+
+        self._state = ClientState.OPENED
+
+        await self._transport.__aenter__()
+        for proxy in self._mounts.values():
+            if proxy is not None:
+                await proxy.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]] = None,
+        exc_value: typing.Optional[BaseException] = None,
+        traceback: typing.Optional[TracebackType] = None,
+    ) -> None:
+        self._state = ClientState.CLOSED
+
+        await self._transport.__aexit__(exc_type, exc_value, traceback)
+        for proxy in self._mounts.values():
+            if proxy is not None:
+                await proxy.__aexit__(exc_type, exc_value, traceback)
diff --git a/myenv/lib/python3.9/site-packages/httpx/_compat.py b/myenv/lib/python3.9/site-packages/httpx/_compat.py
new file mode 100644
index 0000000..6d96ad2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_compat.py
@@ -0,0 +1,40 @@
+"""
+The _compat module is used for code which requires branching between different
+Python environments. It is excluded from the code coverage checks.
+"""
+import ssl
+import sys
+
+# Brotli support is optional
+# The C bindings in `brotli` are recommended for CPython.
+# The CFFI bindings in `brotlicffi` are recommended for PyPy and everything else.
+try:
+    import brotlicffi as brotli
+except ImportError:  # pragma: nocover
+    try:
+        import brotli
+    except ImportError:
+        brotli = None
+
+if sys.version_info >= (3, 10) or (
+    sys.version_info >= (3, 7) and ssl.OPENSSL_VERSION_INFO >= (1, 1, 0, 7)
+):
+
+    def set_minimum_tls_version_1_2(context: ssl.SSLContext) -> None:
+        # The OP_NO_SSL* and OP_NO_TLS* become deprecated in favor of
+        # 'SSLContext.minimum_version' from Python 3.7 onwards, however
+        # this attribute is not available unless the ssl module is compiled
+        # with OpenSSL 1.1.0g or newer.
+        # https://docs.python.org/3.10/library/ssl.html#ssl.SSLContext.minimum_version
+        # https://docs.python.org/3.7/library/ssl.html#ssl.SSLContext.minimum_version
+        context.minimum_version = ssl.TLSVersion.TLSv1_2
+
+else:
+
+    def set_minimum_tls_version_1_2(context: ssl.SSLContext) -> None:
+        # If 'minimum_version' isn't available, we configure these options with
+        # the older deprecated variants.
+        context.options |= ssl.OP_NO_SSLv2
+        context.options |= ssl.OP_NO_SSLv3
+        context.options |= ssl.OP_NO_TLSv1
+        context.options |= ssl.OP_NO_TLSv1_1
diff --git a/myenv/lib/python3.9/site-packages/httpx/_config.py b/myenv/lib/python3.9/site-packages/httpx/_config.py
new file mode 100644
index 0000000..d164e4c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_config.py
@@ -0,0 +1,363 @@
+import os
+import ssl
+import typing
+from pathlib import Path
+
+import certifi
+
+from ._compat import set_minimum_tls_version_1_2
+from ._models import URL, Headers
+from ._types import CertTypes, HeaderTypes, TimeoutTypes, URLTypes, VerifyTypes
+from ._utils import get_ca_bundle_from_env, get_logger
+
+DEFAULT_CIPHERS = ":".join(
+    [
+        "ECDHE+AESGCM",
+        "ECDHE+CHACHA20",
+        "DHE+AESGCM",
+        "DHE+CHACHA20",
+        "ECDH+AESGCM",
+        "DH+AESGCM",
+        "ECDH+AES",
+        "DH+AES",
+        "RSA+AESGCM",
+        "RSA+AES",
+        "!aNULL",
+        "!eNULL",
+        "!MD5",
+        "!DSS",
+    ]
+)
+
+
+logger = get_logger(__name__)
+
+
+class UnsetType:
+    pass  # pragma: nocover
+
+
+UNSET = UnsetType()
+
+
+def create_ssl_context(
+    cert: typing.Optional[CertTypes] = None,
+    verify: VerifyTypes = True,
+    trust_env: bool = True,
+    http2: bool = False,
+) -> ssl.SSLContext:
+    return SSLConfig(
+        cert=cert, verify=verify, trust_env=trust_env, http2=http2
+    ).ssl_context
+
+
+class SSLConfig:
+    """
+    SSL Configuration.
+    """
+
+    DEFAULT_CA_BUNDLE_PATH = Path(certifi.where())
+
+    def __init__(
+        self,
+        *,
+        cert: typing.Optional[CertTypes] = None,
+        verify: VerifyTypes = True,
+        trust_env: bool = True,
+        http2: bool = False,
+    ):
+        self.cert = cert
+        self.verify = verify
+        self.trust_env = trust_env
+        self.http2 = http2
+        self.ssl_context = self.load_ssl_context()
+
+    def load_ssl_context(self) -> ssl.SSLContext:
+        logger.trace(
+            f"load_ssl_context "
+            f"verify={self.verify!r} "
+            f"cert={self.cert!r} "
+            f"trust_env={self.trust_env!r} "
+            f"http2={self.http2!r}"
+        )
+
+        if self.verify:
+            return self.load_ssl_context_verify()
+        return self.load_ssl_context_no_verify()
+
+    def load_ssl_context_no_verify(self) -> ssl.SSLContext:
+        """
+        Return an SSL context for unverified connections.
+        """
+        context = self._create_default_ssl_context()
+        context.check_hostname = False
+        context.verify_mode = ssl.CERT_NONE
+        self._load_client_certs(context)
+        return context
+
+    def load_ssl_context_verify(self) -> ssl.SSLContext:
+        """
+        Return an SSL context for verified connections.
+        """
+        if self.trust_env and self.verify is True:
+            ca_bundle = get_ca_bundle_from_env()
+            if ca_bundle is not None:
+                self.verify = ca_bundle
+
+        if isinstance(self.verify, ssl.SSLContext):
+            # Allow passing in our own SSLContext object that's pre-configured.
+            context = self.verify
+            self._load_client_certs(context)
+            return context
+        elif isinstance(self.verify, bool):
+            ca_bundle_path = self.DEFAULT_CA_BUNDLE_PATH
+        elif Path(self.verify).exists():
+            ca_bundle_path = Path(self.verify)
+        else:
+            raise IOError(
+                "Could not find a suitable TLS CA certificate bundle, "
+                "invalid path: {}".format(self.verify)
+            )
+
+        context = self._create_default_ssl_context()
+        context.verify_mode = ssl.CERT_REQUIRED
+        context.check_hostname = True
+
+        # Signal to server support for PHA in TLS 1.3. Raises an
+        # AttributeError if only read-only access is implemented.
+        try:
+            context.post_handshake_auth = True  # type: ignore
+        except AttributeError:  # pragma: nocover
+            pass
+
+        # Disable using 'commonName' for SSLContext.check_hostname
+        # when the 'subjectAltName' extension isn't available.
+        try:
+            context.hostname_checks_common_name = False  # type: ignore
+        except AttributeError:  # pragma: nocover
+            pass
+
+        if ca_bundle_path.is_file():
+            logger.trace(f"load_verify_locations cafile={ca_bundle_path!s}")
+            context.load_verify_locations(cafile=str(ca_bundle_path))
+        elif ca_bundle_path.is_dir():
+            logger.trace(f"load_verify_locations capath={ca_bundle_path!s}")
+            context.load_verify_locations(capath=str(ca_bundle_path))
+
+        self._load_client_certs(context)
+
+        return context
+
+    def _create_default_ssl_context(self) -> ssl.SSLContext:
+        """
+        Creates the default SSLContext object that's used for both verified
+        and unverified connections.
+        """
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        set_minimum_tls_version_1_2(context)
+        context.options |= ssl.OP_NO_COMPRESSION
+        context.set_ciphers(DEFAULT_CIPHERS)
+
+        if ssl.HAS_ALPN:
+            alpn_idents = ["http/1.1", "h2"] if self.http2 else ["http/1.1"]
+            context.set_alpn_protocols(alpn_idents)
+
+        if hasattr(context, "keylog_filename"):  # pragma: nocover (Available in 3.8+)
+            keylogfile = os.environ.get("SSLKEYLOGFILE")
+            if keylogfile and self.trust_env:
+                context.keylog_filename = keylogfile  # type: ignore
+
+        return context
+
+    def _load_client_certs(self, ssl_context: ssl.SSLContext) -> None:
+        """
+        Loads client certificates into our SSLContext object
+        """
+        if self.cert is not None:
+            if isinstance(self.cert, str):
+                ssl_context.load_cert_chain(certfile=self.cert)
+            elif isinstance(self.cert, tuple) and len(self.cert) == 2:
+                ssl_context.load_cert_chain(certfile=self.cert[0], keyfile=self.cert[1])
+            elif isinstance(self.cert, tuple) and len(self.cert) == 3:
+                ssl_context.load_cert_chain(
+                    certfile=self.cert[0],
+                    keyfile=self.cert[1],
+                    password=self.cert[2],  # type: ignore
+                )
+
+
+class Timeout:
+    """
+    Timeout configuration.
+
+    **Usage**:
+
+    Timeout(None)               # No timeouts.
+    Timeout(5.0)                # 5s timeout on all operations.
+    Timeout(None, connect=5.0)  # 5s timeout on connect, no other timeouts.
+    Timeout(5.0, connect=10.0)  # 10s timeout on connect. 5s timeout elsewhere.
+    Timeout(5.0, pool=None)     # No timeout on acquiring connection from pool.
+                                # 5s timeout elsewhere.
+    """
+
+    def __init__(
+        self,
+        timeout: typing.Union[TimeoutTypes, UnsetType] = UNSET,
+        *,
+        connect: typing.Union[None, float, UnsetType] = UNSET,
+        read: typing.Union[None, float, UnsetType] = UNSET,
+        write: typing.Union[None, float, UnsetType] = UNSET,
+        pool: typing.Union[None, float, UnsetType] = UNSET,
+    ):
+        if isinstance(timeout, Timeout):
+            # Passed as a single explicit Timeout.
+            assert connect is UNSET
+            assert read is UNSET
+            assert write is UNSET
+            assert pool is UNSET
+            self.connect = timeout.connect  # type: typing.Optional[float]
+            self.read = timeout.read  # type: typing.Optional[float]
+            self.write = timeout.write  # type: typing.Optional[float]
+            self.pool = timeout.pool  # type: typing.Optional[float]
+        elif isinstance(timeout, tuple):
+            # Passed as a tuple.
+            self.connect = timeout[0]
+            self.read = timeout[1]
+            self.write = None if len(timeout) < 3 else timeout[2]
+            self.pool = None if len(timeout) < 4 else timeout[3]
+        elif not (
+            isinstance(connect, UnsetType)
+            or isinstance(read, UnsetType)
+            or isinstance(write, UnsetType)
+            or isinstance(pool, UnsetType)
+        ):
+            self.connect = connect
+            self.read = read
+            self.write = write
+            self.pool = pool
+        else:
+            if isinstance(timeout, UnsetType):
+                raise ValueError(
+                    "httpx.Timeout must either include a default, or set all "
+                    "four parameters explicitly."
+                )
+            self.connect = timeout if isinstance(connect, UnsetType) else connect
+            self.read = timeout if isinstance(read, UnsetType) else read
+            self.write = timeout if isinstance(write, UnsetType) else write
+            self.pool = timeout if isinstance(pool, UnsetType) else pool
+
+    def as_dict(self) -> typing.Dict[str, typing.Optional[float]]:
+        return {
+            "connect": self.connect,
+            "read": self.read,
+            "write": self.write,
+            "pool": self.pool,
+        }
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, self.__class__)
+            and self.connect == other.connect
+            and self.read == other.read
+            and self.write == other.write
+            and self.pool == other.pool
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        if len({self.connect, self.read, self.write, self.pool}) == 1:
+            return f"{class_name}(timeout={self.connect})"
+        return (
+            f"{class_name}(connect={self.connect}, "
+            f"read={self.read}, write={self.write}, pool={self.pool})"
+        )
+
+
+class Limits:
+    """
+    Configuration for limits to various client behaviors.
+
+    **Parameters:**
+
+    * **max_connections** - The maximum number of concurrent connections that may be
+            established.
+    * **max_keepalive_connections** - Allow the connection pool to maintain
+            keep-alive connections below this point. Should be less than or equal
+            to `max_connections`.
+    * **keepalive_expiry** - Time limit on idle keep-alive connections in seconds.
+    """
+
+    def __init__(
+        self,
+        *,
+        max_connections: typing.Optional[int] = None,
+        max_keepalive_connections: typing.Optional[int] = None,
+        keepalive_expiry: typing.Optional[float] = 5.0,
+    ):
+        self.max_connections = max_connections
+        self.max_keepalive_connections = max_keepalive_connections
+        self.keepalive_expiry = keepalive_expiry
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, self.__class__)
+            and self.max_connections == other.max_connections
+            and self.max_keepalive_connections == other.max_keepalive_connections
+            and self.keepalive_expiry == other.keepalive_expiry
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return (
+            f"{class_name}(max_connections={self.max_connections}, "
+            f"max_keepalive_connections={self.max_keepalive_connections}, "
+            f"keepalive_expiry={self.keepalive_expiry})"
+        )
+
+
+class Proxy:
+    def __init__(
+        self,
+        url: URLTypes,
+        *,
+        auth: typing.Optional[typing.Tuple[str, str]] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+    ):
+        url = URL(url)
+        headers = Headers(headers)
+
+        if url.scheme not in ("http", "https", "socks5"):
+            raise ValueError(f"Unknown scheme for proxy URL {url!r}")
+
+        if url.username or url.password:
+            # Remove any auth credentials from the URL.
+            auth = (url.username, url.password)
+            url = url.copy_with(username=None, password=None)
+
+        self.url = url
+        self.auth = auth
+        self.headers = headers
+
+    @property
+    def raw_auth(self) -> typing.Optional[typing.Tuple[bytes, bytes]]:
+        # The proxy authentication as raw bytes.
+        return (
+            None
+            if self.auth is None
+            else (self.auth[0].encode("utf-8"), self.auth[1].encode("utf-8"))
+        )
+
+    def __repr__(self) -> str:
+        # The authentication is represented with the password component masked.
+        auth = (self.auth[0], "********") if self.auth else None
+
+        # Build a nice concise representation.
+        url_str = f"{str(self.url)!r}"
+        auth_str = f", auth={auth!r}" if auth else ""
+        headers_str = f", headers={dict(self.headers)!r}" if self.headers else ""
+        return f"Proxy({url_str}{auth_str}{headers_str})"
+
+
+DEFAULT_TIMEOUT_CONFIG = Timeout(timeout=5.0)
+DEFAULT_LIMITS = Limits(max_connections=100, max_keepalive_connections=20)
+DEFAULT_MAX_REDIRECTS = 20
diff --git a/myenv/lib/python3.9/site-packages/httpx/_content.py b/myenv/lib/python3.9/site-packages/httpx/_content.py
new file mode 100644
index 0000000..24a967d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_content.py
@@ -0,0 +1,238 @@
+import inspect
+import warnings
+from json import dumps as json_dumps
+from typing import (
+    Any,
+    AsyncIterable,
+    AsyncIterator,
+    Dict,
+    Iterable,
+    Iterator,
+    Optional,
+    Tuple,
+    Union,
+)
+from urllib.parse import urlencode
+
+from ._exceptions import StreamClosed, StreamConsumed
+from ._multipart import MultipartStream
+from ._types import (
+    AsyncByteStream,
+    RequestContent,
+    RequestData,
+    RequestFiles,
+    ResponseContent,
+    SyncByteStream,
+)
+from ._utils import peek_filelike_length, primitive_value_to_str
+
+
+class ByteStream(AsyncByteStream, SyncByteStream):
+    def __init__(self, stream: bytes) -> None:
+        self._stream = stream
+
+    def __iter__(self) -> Iterator[bytes]:
+        yield self._stream
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        yield self._stream
+
+
+class IteratorByteStream(SyncByteStream):
+    CHUNK_SIZE = 65_536
+
+    def __init__(self, stream: Iterable[bytes]):
+        self._stream = stream
+        self._is_stream_consumed = False
+        self._is_generator = inspect.isgenerator(stream)
+
+    def __iter__(self) -> Iterator[bytes]:
+        if self._is_stream_consumed and self._is_generator:
+            raise StreamConsumed()
+
+        self._is_stream_consumed = True
+        if hasattr(self._stream, "read") and not isinstance(
+            self._stream, SyncByteStream
+        ):
+            # File-like interfaces should use 'read' directly.
+            chunk = self._stream.read(self.CHUNK_SIZE)  # type: ignore
+            while chunk:
+                yield chunk
+                chunk = self._stream.read(self.CHUNK_SIZE)  # type: ignore
+        else:
+            # Otherwise iterate.
+            for part in self._stream:
+                yield part
+
+
+class AsyncIteratorByteStream(AsyncByteStream):
+    CHUNK_SIZE = 65_536
+
+    def __init__(self, stream: AsyncIterable[bytes]):
+        self._stream = stream
+        self._is_stream_consumed = False
+        self._is_generator = inspect.isasyncgen(stream)
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        if self._is_stream_consumed and self._is_generator:
+            raise StreamConsumed()
+
+        self._is_stream_consumed = True
+        if hasattr(self._stream, "aread") and not isinstance(
+            self._stream, AsyncByteStream
+        ):
+            # File-like interfaces should use 'aread' directly.
+            chunk = await self._stream.aread(self.CHUNK_SIZE)  # type: ignore
+            while chunk:
+                yield chunk
+                chunk = await self._stream.aread(self.CHUNK_SIZE)  # type: ignore
+        else:
+            # Otherwise iterate.
+            async for part in self._stream:
+                yield part
+
+
+class UnattachedStream(AsyncByteStream, SyncByteStream):
+    """
+    If a request or response is serialized using pickle, then it is no longer
+    attached to a stream for I/O purposes. Any stream operations should result
+    in `httpx.StreamClosed`.
+    """
+
+    def __iter__(self) -> Iterator[bytes]:
+        raise StreamClosed()
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        raise StreamClosed()
+        yield b""  # pragma: nocover
+
+
+def encode_content(
+    content: Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
+) -> Tuple[Dict[str, str], Union[SyncByteStream, AsyncByteStream]]:
+
+    if isinstance(content, (bytes, str)):
+        body = content.encode("utf-8") if isinstance(content, str) else content
+        content_length = len(body)
+        headers = {"Content-Length": str(content_length)} if body else {}
+        return headers, ByteStream(body)
+
+    elif isinstance(content, Iterable):
+        content_length_or_none = peek_filelike_length(content)
+
+        if content_length_or_none is None:
+            headers = {"Transfer-Encoding": "chunked"}
+        else:
+            headers = {"Content-Length": str(content_length_or_none)}
+        return headers, IteratorByteStream(content)  # type: ignore
+
+    elif isinstance(content, AsyncIterable):
+        headers = {"Transfer-Encoding": "chunked"}
+        return headers, AsyncIteratorByteStream(content)
+
+    raise TypeError(f"Unexpected type for 'content', {type(content)!r}")
+
+
+def encode_urlencoded_data(
+    data: dict,
+) -> Tuple[Dict[str, str], ByteStream]:
+    plain_data = []
+    for key, value in data.items():
+        if isinstance(value, (list, tuple)):
+            plain_data.extend([(key, primitive_value_to_str(item)) for item in value])
+        else:
+            plain_data.append((key, primitive_value_to_str(value)))
+    body = urlencode(plain_data, doseq=True).encode("utf-8")
+    content_length = str(len(body))
+    content_type = "application/x-www-form-urlencoded"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_multipart_data(
+    data: dict, files: RequestFiles, boundary: Optional[bytes] = None
+) -> Tuple[Dict[str, str], MultipartStream]:
+    multipart = MultipartStream(data=data, files=files, boundary=boundary)
+    headers = multipart.get_headers()
+    return headers, multipart
+
+
+def encode_text(text: str) -> Tuple[Dict[str, str], ByteStream]:
+    body = text.encode("utf-8")
+    content_length = str(len(body))
+    content_type = "text/plain; charset=utf-8"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_html(html: str) -> Tuple[Dict[str, str], ByteStream]:
+    body = html.encode("utf-8")
+    content_length = str(len(body))
+    content_type = "text/html; charset=utf-8"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_json(json: Any) -> Tuple[Dict[str, str], ByteStream]:
+    body = json_dumps(json).encode("utf-8")
+    content_length = str(len(body))
+    content_type = "application/json"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_request(
+    content: Optional[RequestContent] = None,
+    data: Optional[RequestData] = None,
+    files: Optional[RequestFiles] = None,
+    json: Optional[Any] = None,
+    boundary: Optional[bytes] = None,
+) -> Tuple[Dict[str, str], Union[SyncByteStream, AsyncByteStream]]:
+    """
+    Handles encoding the given `content`, `data`, `files`, and `json`,
+    returning a two-tuple of (<headers>, <stream>).
+    """
+    if data is not None and not isinstance(data, dict):
+        # We prefer to separate `content=<bytes|str|byte iterator|bytes aiterator>`
+        # for raw request content, and `data=<form data>` for url encoded or
+        # multipart form content.
+        #
+        # However for compat with requests, we *do* still support
+        # `data=<bytes...>` usages. We deal with that case here, treating it
+        # as if `content=<...>` had been supplied instead.
+        message = "Use 'content=<...>' to upload raw bytes/text content."
+        warnings.warn(message, DeprecationWarning)
+        return encode_content(data)
+
+    if content is not None:
+        return encode_content(content)
+    elif files:
+        return encode_multipart_data(data or {}, files, boundary)
+    elif data:
+        return encode_urlencoded_data(data)
+    elif json is not None:
+        return encode_json(json)
+
+    return {}, ByteStream(b"")
+
+
+def encode_response(
+    content: Optional[ResponseContent] = None,
+    text: Optional[str] = None,
+    html: Optional[str] = None,
+    json: Optional[Any] = None,
+) -> Tuple[Dict[str, str], Union[SyncByteStream, AsyncByteStream]]:
+    """
+    Handles encoding the given `content`, returning a two-tuple of
+    (<headers>, <stream>).
+    """
+    if content is not None:
+        return encode_content(content)
+    elif text is not None:
+        return encode_text(text)
+    elif html is not None:
+        return encode_html(html)
+    elif json is not None:
+        return encode_json(json)
+
+    return {}, ByteStream(b"")
diff --git a/myenv/lib/python3.9/site-packages/httpx/_decoders.py b/myenv/lib/python3.9/site-packages/httpx/_decoders.py
new file mode 100644
index 0000000..69c0369
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_decoders.py
@@ -0,0 +1,333 @@
+"""
+Handlers for Content-Encoding.
+
+See: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
+"""
+import codecs
+import io
+import typing
+import zlib
+
+from ._compat import brotli
+from ._exceptions import DecodingError
+
+
+class ContentDecoder:
+    def decode(self, data: bytes) -> bytes:
+        raise NotImplementedError()  # pragma: nocover
+
+    def flush(self) -> bytes:
+        raise NotImplementedError()  # pragma: nocover
+
+
+class IdentityDecoder(ContentDecoder):
+    """
+    Handle unencoded data.
+    """
+
+    def decode(self, data: bytes) -> bytes:
+        return data
+
+    def flush(self) -> bytes:
+        return b""
+
+
+class DeflateDecoder(ContentDecoder):
+    """
+    Handle 'deflate' decoding.
+
+    See: https://stackoverflow.com/questions/1838699
+    """
+
+    def __init__(self) -> None:
+        self.first_attempt = True
+        self.decompressor = zlib.decompressobj()
+
+    def decode(self, data: bytes) -> bytes:
+        was_first_attempt = self.first_attempt
+        self.first_attempt = False
+        try:
+            return self.decompressor.decompress(data)
+        except zlib.error as exc:
+            if was_first_attempt:
+                self.decompressor = zlib.decompressobj(-zlib.MAX_WBITS)
+                return self.decode(data)
+            raise DecodingError(str(exc)) from exc
+
+    def flush(self) -> bytes:
+        try:
+            return self.decompressor.flush()
+        except zlib.error as exc:  # pragma: nocover
+            raise DecodingError(str(exc)) from exc
+
+
+class GZipDecoder(ContentDecoder):
+    """
+    Handle 'gzip' decoding.
+
+    See: https://stackoverflow.com/questions/1838699
+    """
+
+    def __init__(self) -> None:
+        self.decompressor = zlib.decompressobj(zlib.MAX_WBITS | 16)
+
+    def decode(self, data: bytes) -> bytes:
+        try:
+            return self.decompressor.decompress(data)
+        except zlib.error as exc:
+            raise DecodingError(str(exc)) from exc
+
+    def flush(self) -> bytes:
+        try:
+            return self.decompressor.flush()
+        except zlib.error as exc:  # pragma: nocover
+            raise DecodingError(str(exc)) from exc
+
+
+class BrotliDecoder(ContentDecoder):
+    """
+    Handle 'brotli' decoding.
+
+    Requires `pip install brotlipy`. See: https://brotlipy.readthedocs.io/
+        or   `pip install brotli`. See https://github.com/google/brotli
+    Supports both 'brotlipy' and 'Brotli' packages since they share an import
+    name. The top branches are for 'brotlipy' and bottom branches for 'Brotli'
+    """
+
+    def __init__(self) -> None:
+        if brotli is None:  # pragma: nocover
+            raise ImportError(
+                "Using 'BrotliDecoder', but neither of the 'brotlicffi' or 'brotli' "
+                "packages have been installed. "
+                "Make sure to install httpx using `pip install httpx[brotli]`."
+            ) from None
+
+        self.decompressor = brotli.Decompressor()
+        self.seen_data = False
+        if hasattr(self.decompressor, "decompress"):
+            # The 'brotlicffi' package.
+            self._decompress = self.decompressor.decompress  # pragma: nocover
+        else:
+            # The 'brotli' package.
+            self._decompress = self.decompressor.process  # pragma: nocover
+
+    def decode(self, data: bytes) -> bytes:
+        if not data:
+            return b""
+        self.seen_data = True
+        try:
+            return self._decompress(data)
+        except brotli.error as exc:
+            raise DecodingError(str(exc)) from exc
+
+    def flush(self) -> bytes:
+        if not self.seen_data:
+            return b""
+        try:
+            if hasattr(self.decompressor, "finish"):
+                # Only available in the 'brotlicffi' package.
+
+                # As the decompressor decompresses eagerly, this
+                # will never actually emit any data. However, it will potentially throw
+                # errors if a truncated or damaged data stream has been used.
+                self.decompressor.finish()  # pragma: nocover
+            return b""
+        except brotli.error as exc:  # pragma: nocover
+            raise DecodingError(str(exc)) from exc
+
+
+class MultiDecoder(ContentDecoder):
+    """
+    Handle the case where multiple encodings have been applied.
+    """
+
+    def __init__(self, children: typing.Sequence[ContentDecoder]) -> None:
+        """
+        'children' should be a sequence of decoders in the order in which
+        each was applied.
+        """
+        # Note that we reverse the order for decoding.
+        self.children = list(reversed(children))
+
+    def decode(self, data: bytes) -> bytes:
+        for child in self.children:
+            data = child.decode(data)
+        return data
+
+    def flush(self) -> bytes:
+        data = b""
+        for child in self.children:
+            data = child.decode(data) + child.flush()
+        return data
+
+
+class ByteChunker:
+    """
+    Handles returning byte content in fixed-size chunks.
+    """
+
+    def __init__(self, chunk_size: typing.Optional[int] = None) -> None:
+        self._buffer = io.BytesIO()
+        self._chunk_size = chunk_size
+
+    def decode(self, content: bytes) -> typing.List[bytes]:
+        if self._chunk_size is None:
+            return [content] if content else []
+
+        self._buffer.write(content)
+        if self._buffer.tell() >= self._chunk_size:
+            value = self._buffer.getvalue()
+            chunks = [
+                value[i : i + self._chunk_size]
+                for i in range(0, len(value), self._chunk_size)
+            ]
+            if len(chunks[-1]) == self._chunk_size:
+                self._buffer.seek(0)
+                self._buffer.truncate()
+                return chunks
+            else:
+                self._buffer.seek(0)
+                self._buffer.write(chunks[-1])
+                self._buffer.truncate()
+                return chunks[:-1]
+        else:
+            return []
+
+    def flush(self) -> typing.List[bytes]:
+        value = self._buffer.getvalue()
+        self._buffer.seek(0)
+        self._buffer.truncate()
+        return [value] if value else []
+
+
+class TextChunker:
+    """
+    Handles returning text content in fixed-size chunks.
+    """
+
+    def __init__(self, chunk_size: typing.Optional[int] = None) -> None:
+        self._buffer = io.StringIO()
+        self._chunk_size = chunk_size
+
+    def decode(self, content: str) -> typing.List[str]:
+        if self._chunk_size is None:
+            return [content]
+
+        self._buffer.write(content)
+        if self._buffer.tell() >= self._chunk_size:
+            value = self._buffer.getvalue()
+            chunks = [
+                value[i : i + self._chunk_size]
+                for i in range(0, len(value), self._chunk_size)
+            ]
+            if len(chunks[-1]) == self._chunk_size:
+                self._buffer.seek(0)
+                self._buffer.truncate()
+                return chunks
+            else:
+                self._buffer.seek(0)
+                self._buffer.write(chunks[-1])
+                self._buffer.truncate()
+                return chunks[:-1]
+        else:
+            return []
+
+    def flush(self) -> typing.List[str]:
+        value = self._buffer.getvalue()
+        self._buffer.seek(0)
+        self._buffer.truncate()
+        return [value] if value else []
+
+
+class TextDecoder:
+    """
+    Handles incrementally decoding bytes into text
+    """
+
+    def __init__(self, encoding: str = "utf-8"):
+        self.decoder = codecs.getincrementaldecoder(encoding)(errors="replace")
+
+    def decode(self, data: bytes) -> str:
+        return self.decoder.decode(data)
+
+    def flush(self) -> str:
+        return self.decoder.decode(b"", True)
+
+
+class LineDecoder:
+    """
+    Handles incrementally reading lines from text.
+
+    Uses universal line decoding, supporting any of `\n`, `\r`, or `\r\n`
+    as line endings, normalizing to `\n`.
+    """
+
+    def __init__(self) -> None:
+        self.buffer = ""
+
+    def decode(self, text: str) -> typing.List[str]:
+        lines = []
+
+        if text and self.buffer and self.buffer[-1] == "\r":
+            if text.startswith("\n"):
+                # Handle the case where we have an "\r\n" split across
+                # our previous input, and our new chunk.
+                lines.append(self.buffer[:-1] + "\n")
+                self.buffer = ""
+                text = text[1:]
+            else:
+                # Handle the case where we have "\r" at the end of our
+                # previous input.
+                lines.append(self.buffer[:-1] + "\n")
+                self.buffer = ""
+
+        while text:
+            num_chars = len(text)
+            for idx in range(num_chars):
+                char = text[idx]
+                next_char = None if idx + 1 == num_chars else text[idx + 1]
+                if char == "\n":
+                    lines.append(self.buffer + text[: idx + 1])
+                    self.buffer = ""
+                    text = text[idx + 1 :]
+                    break
+                elif char == "\r" and next_char == "\n":
+                    lines.append(self.buffer + text[:idx] + "\n")
+                    self.buffer = ""
+                    text = text[idx + 2 :]
+                    break
+                elif char == "\r" and next_char is not None:
+                    lines.append(self.buffer + text[:idx] + "\n")
+                    self.buffer = ""
+                    text = text[idx + 1 :]
+                    break
+                elif next_char is None:
+                    self.buffer += text
+                    text = ""
+                    break
+
+        return lines
+
+    def flush(self) -> typing.List[str]:
+        if self.buffer.endswith("\r"):
+            # Handle the case where we had a trailing '\r', which could have
+            # been a '\r\n' pair.
+            lines = [self.buffer[:-1] + "\n"]
+        elif self.buffer:
+            lines = [self.buffer]
+        else:
+            lines = []
+        self.buffer = ""
+        return lines
+
+
+SUPPORTED_DECODERS = {
+    "identity": IdentityDecoder,
+    "gzip": GZipDecoder,
+    "deflate": DeflateDecoder,
+    "br": BrotliDecoder,
+}
+
+
+if brotli is None:
+    SUPPORTED_DECODERS.pop("br")  # pragma: nocover
diff --git a/myenv/lib/python3.9/site-packages/httpx/_exceptions.py b/myenv/lib/python3.9/site-packages/httpx/_exceptions.py
new file mode 100644
index 0000000..1941250
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_exceptions.py
@@ -0,0 +1,343 @@
+"""
+Our exception hierarchy:
+
+* HTTPError
+  x RequestError
+    + TransportError
+      - TimeoutException
+        · ConnectTimeout
+        · ReadTimeout
+        · WriteTimeout
+        · PoolTimeout
+      - NetworkError
+        · ConnectError
+        · ReadError
+        · WriteError
+        · CloseError
+      - ProtocolError
+        · LocalProtocolError
+        · RemoteProtocolError
+      - ProxyError
+      - UnsupportedProtocol
+    + DecodingError
+    + TooManyRedirects
+  x HTTPStatusError
+* InvalidURL
+* CookieConflict
+* StreamError
+  x StreamConsumed
+  x StreamClosed
+  x ResponseNotRead
+  x RequestNotRead
+"""
+import contextlib
+import typing
+
+if typing.TYPE_CHECKING:
+    from ._models import Request, Response  # pragma: nocover
+
+
+class HTTPError(Exception):
+    """
+    Base class for `RequestError` and `HTTPStatusError`.
+
+    Useful for `try...except` blocks when issuing a request,
+    and then calling `.raise_for_status()`.
+
+    For example:
+
+    ```
+    try:
+        response = httpx.get("https://www.example.com")
+        response.raise_for_status()
+    except httpx.HTTPError as exc:
+        print(f"HTTP Exception for {exc.request.url} - {exc}")
+    ```
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        self._request: typing.Optional["Request"] = None
+
+    @property
+    def request(self) -> "Request":
+        if self._request is None:
+            raise RuntimeError("The .request property has not been set.")
+        return self._request
+
+    @request.setter
+    def request(self, request: "Request") -> None:
+        self._request = request
+
+
+class RequestError(HTTPError):
+    """
+    Base class for all exceptions that may occur when issuing a `.request()`.
+    """
+
+    def __init__(
+        self, message: str, *, request: typing.Optional["Request"] = None
+    ) -> None:
+        super().__init__(message)
+        # At the point an exception is raised we won't typically have a request
+        # instance to associate it with.
+        #
+        # The 'request_context' context manager is used within the Client and
+        # Response methods in order to ensure that any raised exceptions
+        # have a `.request` property set on them.
+        self._request = request
+
+
+class TransportError(RequestError):
+    """
+    Base class for all exceptions that occur at the level of the Transport API.
+    """
+
+
+# Timeout exceptions...
+
+
+class TimeoutException(TransportError):
+    """
+    The base class for timeout errors.
+
+    An operation has timed out.
+    """
+
+
+class ConnectTimeout(TimeoutException):
+    """
+    Timed out while connecting to the host.
+    """
+
+
+class ReadTimeout(TimeoutException):
+    """
+    Timed out while receiving data from the host.
+    """
+
+
+class WriteTimeout(TimeoutException):
+    """
+    Timed out while sending data to the host.
+    """
+
+
+class PoolTimeout(TimeoutException):
+    """
+    Timed out waiting to acquire a connection from the pool.
+    """
+
+
+# Core networking exceptions...
+
+
+class NetworkError(TransportError):
+    """
+    The base class for network-related errors.
+
+    An error occurred while interacting with the network.
+    """
+
+
+class ReadError(NetworkError):
+    """
+    Failed to receive data from the network.
+    """
+
+
+class WriteError(NetworkError):
+    """
+    Failed to send data through the network.
+    """
+
+
+class ConnectError(NetworkError):
+    """
+    Failed to establish a connection.
+    """
+
+
+class CloseError(NetworkError):
+    """
+    Failed to close a connection.
+    """
+
+
+# Other transport exceptions...
+
+
+class ProxyError(TransportError):
+    """
+    An error occurred while establishing a proxy connection.
+    """
+
+
+class UnsupportedProtocol(TransportError):
+    """
+    Attempted to make a request to an unsupported protocol.
+
+    For example issuing a request to `ftp://www.example.com`.
+    """
+
+
+class ProtocolError(TransportError):
+    """
+    The protocol was violated.
+    """
+
+
+class LocalProtocolError(ProtocolError):
+    """
+    A protocol was violated by the client.
+
+    For example if the user instantiated a `Request` instance explicitly,
+    failed to include the mandatory `Host:` header, and then issued it directly
+    using `client.send()`.
+    """
+
+
+class RemoteProtocolError(ProtocolError):
+    """
+    The protocol was violated by the server.
+
+    For example, returning malformed HTTP.
+    """
+
+
+# Other request exceptions...
+
+
+class DecodingError(RequestError):
+    """
+    Decoding of the response failed, due to a malformed encoding.
+    """
+
+
+class TooManyRedirects(RequestError):
+    """
+    Too many redirects.
+    """
+
+
+# Client errors
+
+
+class HTTPStatusError(HTTPError):
+    """
+    The response had an error HTTP status of 4xx or 5xx.
+
+    May be raised when calling `response.raise_for_status()`
+    """
+
+    def __init__(
+        self, message: str, *, request: "Request", response: "Response"
+    ) -> None:
+        super().__init__(message)
+        self.request = request
+        self.response = response
+
+
+class InvalidURL(Exception):
+    """
+    URL is improperly formed or cannot be parsed.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class CookieConflict(Exception):
+    """
+    Attempted to lookup a cookie by name, but multiple cookies existed.
+
+    Can occur when calling `response.cookies.get(...)`.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+# Stream exceptions...
+
+# These may occur as the result of a programming error, by accessing
+# the request/response stream in an invalid manner.
+
+
+class StreamError(RuntimeError):
+    """
+    The base class for stream exceptions.
+
+    The developer made an error in accessing the request stream in
+    an invalid way.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class StreamConsumed(StreamError):
+    """
+    Attempted to read or stream content, but the content has already
+    been streamed.
+    """
+
+    def __init__(self) -> None:
+        message = (
+            "Attempted to read or stream some content, but the content has "
+            "already been streamed. For requests, this could be due to passing "
+            "a generator as request content, and then receiving a redirect "
+            "response or a secondary request as part of an authentication flow."
+            "For responses, this could be due to attempting to stream the response "
+            "content more than once."
+        )
+        super().__init__(message)
+
+
+class StreamClosed(StreamError):
+    """
+    Attempted to read or stream response content, but the request has been
+    closed.
+    """
+
+    def __init__(self) -> None:
+        message = (
+            "Attempted to read or stream content, but the stream has " "been closed."
+        )
+        super().__init__(message)
+
+
+class ResponseNotRead(StreamError):
+    """
+    Attempted to access streaming response content, without having called `read()`.
+    """
+
+    def __init__(self) -> None:
+        message = "Attempted to access streaming response content, without having called `read()`."
+        super().__init__(message)
+
+
+class RequestNotRead(StreamError):
+    """
+    Attempted to access streaming request content, without having called `read()`.
+    """
+
+    def __init__(self) -> None:
+        message = "Attempted to access streaming request content, without having called `read()`."
+        super().__init__(message)
+
+
+@contextlib.contextmanager
+def request_context(
+    request: typing.Optional["Request"] = None,
+) -> typing.Iterator[None]:
+    """
+    A context manager that can be used to attach the given request context
+    to any `RequestError` exceptions that are raised within the block.
+    """
+    try:
+        yield
+    except RequestError as exc:
+        if request is not None:
+            exc.request = request
+        raise exc
diff --git a/myenv/lib/python3.9/site-packages/httpx/_main.py b/myenv/lib/python3.9/site-packages/httpx/_main.py
new file mode 100644
index 0000000..ebcb652
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_main.py
@@ -0,0 +1,497 @@
+import functools
+import json
+import sys
+import typing
+
+import click
+import httpcore
+import pygments.lexers
+import pygments.util
+import rich.console
+import rich.markup
+import rich.progress
+import rich.syntax
+import rich.table
+
+from ._client import Client
+from ._exceptions import RequestError
+from ._models import Response
+from ._status_codes import codes
+
+
+def print_help() -> None:
+    console = rich.console.Console()
+
+    console.print("[bold]HTTPX :butterfly:", justify="center")
+    console.print()
+    console.print("A next generation HTTP client.", justify="center")
+    console.print()
+    console.print(
+        "Usage: [bold]httpx[/bold] [cyan]<URL> [OPTIONS][/cyan] ", justify="left"
+    )
+    console.print()
+
+    table = rich.table.Table.grid(padding=1, pad_edge=True)
+    table.add_column("Parameter", no_wrap=True, justify="left", style="bold")
+    table.add_column("Description")
+    table.add_row(
+        "-m, --method [cyan]METHOD",
+        "Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD.\n"
+        "[Default: GET, or POST if a request body is included]",
+    )
+    table.add_row(
+        "-p, --params [cyan]<NAME VALUE> ...",
+        "Query parameters to include in the request URL.",
+    )
+    table.add_row(
+        "-c, --content [cyan]TEXT", "Byte content to include in the request body."
+    )
+    table.add_row(
+        "-d, --data [cyan]<NAME VALUE> ...", "Form data to include in the request body."
+    )
+    table.add_row(
+        "-f, --files [cyan]<NAME FILENAME> ...",
+        "Form files to include in the request body.",
+    )
+    table.add_row("-j, --json [cyan]TEXT", "JSON data to include in the request body.")
+    table.add_row(
+        "-h, --headers [cyan]<NAME VALUE> ...",
+        "Include additional HTTP headers in the request.",
+    )
+    table.add_row(
+        "--cookies [cyan]<NAME VALUE> ...", "Cookies to include in the request."
+    )
+    table.add_row(
+        "--auth [cyan]<USER PASS>",
+        "Username and password to include in the request. Specify '-' for the password to use "
+        "a password prompt. Note that using --verbose/-v will expose the Authorization "
+        "header, including the password encoding in a trivially reversible format.",
+    )
+
+    table.add_row(
+        "--proxies [cyan]URL",
+        "Send the request via a proxy. Should be the URL giving the proxy address.",
+    )
+
+    table.add_row(
+        "--timeout [cyan]FLOAT",
+        "Timeout value to use for network operations, such as establishing the connection, "
+        "reading some data, etc... [Default: 5.0]",
+    )
+
+    table.add_row("--follow-redirects", "Automatically follow redirects.")
+    table.add_row("--no-verify", "Disable SSL verification.")
+    table.add_row(
+        "--http2", "Send the request using HTTP/2, if the remote server supports it."
+    )
+
+    table.add_row(
+        "--download [cyan]FILE",
+        "Save the response content as a file, rather than displaying it.",
+    )
+
+    table.add_row("-v, --verbose", "Verbose output. Show request as well as response.")
+    table.add_row("--help", "Show this message and exit.")
+    console.print(table)
+
+
+def get_lexer_for_response(response: Response) -> str:
+    content_type = response.headers.get("Content-Type")
+    if content_type is not None:
+        mime_type, _, _ = content_type.partition(";")
+        try:
+            return pygments.lexers.get_lexer_for_mimetype(mime_type.strip()).name
+        except pygments.util.ClassNotFound:  # pragma: nocover
+            pass
+    return ""  # pragma: nocover
+
+
+def format_request_headers(request: httpcore.Request, http2: bool = False) -> str:
+    version = "HTTP/2" if http2 else "HTTP/1.1"
+    headers = [
+        (name.lower() if http2 else name, value) for name, value in request.headers
+    ]
+    method = request.method.decode("ascii")
+    target = request.url.target.decode("ascii")
+    lines = [f"{method} {target} {version}"] + [
+        f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
+    ]
+    return "\n".join(lines)
+
+
+def format_response_headers(
+    http_version: bytes,
+    status: int,
+    reason_phrase: typing.Optional[bytes],
+    headers: typing.List[typing.Tuple[bytes, bytes]],
+) -> str:
+    version = http_version.decode("ascii")
+    reason = (
+        codes.get_reason_phrase(status)
+        if reason_phrase is None
+        else reason_phrase.decode("ascii")
+    )
+    lines = [f"{version} {status} {reason}"] + [
+        f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
+    ]
+    return "\n".join(lines)
+
+
+def print_request_headers(request: httpcore.Request, http2: bool = False) -> None:
+    console = rich.console.Console()
+    http_text = format_request_headers(request, http2=http2)
+    syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+    syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+
+
+def print_response_headers(
+    http_version: bytes,
+    status: int,
+    reason_phrase: typing.Optional[bytes],
+    headers: typing.List[typing.Tuple[bytes, bytes]],
+) -> None:
+    console = rich.console.Console()
+    http_text = format_response_headers(http_version, status, reason_phrase, headers)
+    syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+    syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+
+
+def print_response(response: Response) -> None:
+    console = rich.console.Console()
+    lexer_name = get_lexer_for_response(response)
+    if lexer_name:
+        if lexer_name.lower() == "json":
+            try:
+                data = response.json()
+                text = json.dumps(data, indent=4)
+            except ValueError:  # pragma: nocover
+                text = response.text
+        else:
+            text = response.text
+
+        syntax = rich.syntax.Syntax(text, lexer_name, theme="ansi_dark", word_wrap=True)
+        console.print(syntax)
+    else:
+        console.print(f"<{len(response.content)} bytes of binary data>")
+
+
+def format_certificate(cert: dict) -> str:  # pragma: nocover
+    lines = []
+    for key, value in cert.items():
+        if isinstance(value, (list, tuple)):
+            lines.append(f"*   {key}:")
+            for item in value:
+                if key in ("subject", "issuer"):
+                    for sub_item in item:
+                        lines.append(f"*     {sub_item[0]}: {sub_item[1]!r}")
+                elif isinstance(item, tuple) and len(item) == 2:
+                    lines.append(f"*     {item[0]}: {item[1]!r}")
+                else:
+                    lines.append(f"*     {item!r}")
+        else:
+            lines.append(f"*   {key}: {value!r}")
+    return "\n".join(lines)
+
+
+def trace(name: str, info: dict, verbose: bool = False) -> None:
+    console = rich.console.Console()
+    if name == "connection.connect_tcp.started" and verbose:
+        host = info["host"]
+        console.print(f"* Connecting to {host!r}")
+    elif name == "connection.connect_tcp.complete" and verbose:
+        stream = info["return_value"]
+        server_addr = stream.get_extra_info("server_addr")
+        console.print(f"* Connected to {server_addr[0]!r} on port {server_addr[1]}")
+    elif name == "connection.start_tls.complete" and verbose:  # pragma: nocover
+        stream = info["return_value"]
+        ssl_object = stream.get_extra_info("ssl_object")
+        version = ssl_object.version()
+        cipher = ssl_object.cipher()
+        server_cert = ssl_object.getpeercert()
+        alpn = ssl_object.selected_alpn_protocol()
+        console.print(f"* SSL established using {version!r} / {cipher[0]!r}")
+        console.print(f"* Selected ALPN protocol: {alpn!r}")
+        if server_cert:
+            console.print("* Server certificate:")
+            console.print(format_certificate(server_cert))
+    elif name == "http11.send_request_headers.started" and verbose:
+        request = info["request"]
+        print_request_headers(request, http2=False)
+    elif name == "http2.send_request_headers.started" and verbose:  # pragma: nocover
+        request = info["request"]
+        print_request_headers(request, http2=True)
+    elif name == "http11.receive_response_headers.complete":
+        http_version, status, reason_phrase, headers = info["return_value"]
+        print_response_headers(http_version, status, reason_phrase, headers)
+    elif name == "http2.receive_response_headers.complete":  # pragma: nocover
+        status, headers = info["return_value"]
+        http_version = b"HTTP/2"
+        reason_phrase = None
+        print_response_headers(http_version, status, reason_phrase, headers)
+
+
+def download_response(response: Response, download: typing.BinaryIO) -> None:
+    console = rich.console.Console()
+    console.print()
+    content_length = response.headers.get("Content-Length")
+    with rich.progress.Progress(
+        "[progress.description]{task.description}",
+        "[progress.percentage]{task.percentage:>3.0f}%",
+        rich.progress.BarColumn(bar_width=None),
+        rich.progress.DownloadColumn(),
+        rich.progress.TransferSpeedColumn(),
+    ) as progress:
+        description = f"Downloading [bold]{rich.markup.escape(download.name)}"
+        download_task = progress.add_task(
+            description,
+            total=int(content_length or 0),
+            start=content_length is not None,
+        )
+        for chunk in response.iter_bytes():
+            download.write(chunk)
+            progress.update(download_task, completed=response.num_bytes_downloaded)
+
+
+def validate_json(
+    ctx: click.Context,
+    param: typing.Union[click.Option, click.Parameter],
+    value: typing.Any,
+) -> typing.Any:
+    if value is None:
+        return None
+
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:  # pragma: nocover
+        raise click.BadParameter("Not valid JSON")
+
+
+def validate_auth(
+    ctx: click.Context,
+    param: typing.Union[click.Option, click.Parameter],
+    value: typing.Any,
+) -> typing.Any:
+    if value == (None, None):
+        return None
+
+    username, password = value
+    if password == "-":  # pragma: nocover
+        password = click.prompt("Password", hide_input=True)
+    return (username, password)
+
+
+def handle_help(
+    ctx: click.Context,
+    param: typing.Union[click.Option, click.Parameter],
+    value: typing.Any,
+) -> None:
+    if not value or ctx.resilient_parsing:
+        return
+
+    print_help()
+    ctx.exit()
+
+
+@click.command(add_help_option=False)
+@click.argument("url", type=str)
+@click.option(
+    "--method",
+    "-m",
+    "method",
+    type=str,
+    help=(
+        "Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD. "
+        "[Default: GET, or POST if a request body is included]"
+    ),
+)
+@click.option(
+    "--params",
+    "-p",
+    "params",
+    type=(str, str),
+    multiple=True,
+    help="Query parameters to include in the request URL.",
+)
+@click.option(
+    "--content",
+    "-c",
+    "content",
+    type=str,
+    help="Byte content to include in the request body.",
+)
+@click.option(
+    "--data",
+    "-d",
+    "data",
+    type=(str, str),
+    multiple=True,
+    help="Form data to include in the request body.",
+)
+@click.option(
+    "--files",
+    "-f",
+    "files",
+    type=(str, click.File(mode="rb")),
+    multiple=True,
+    help="Form files to include in the request body.",
+)
+@click.option(
+    "--json",
+    "-j",
+    "json",
+    type=str,
+    callback=validate_json,
+    help="JSON data to include in the request body.",
+)
+@click.option(
+    "--headers",
+    "-h",
+    "headers",
+    type=(str, str),
+    multiple=True,
+    help="Include additional HTTP headers in the request.",
+)
+@click.option(
+    "--cookies",
+    "cookies",
+    type=(str, str),
+    multiple=True,
+    help="Cookies to include in the request.",
+)
+@click.option(
+    "--auth",
+    "auth",
+    type=(str, str),
+    default=(None, None),
+    callback=validate_auth,
+    help=(
+        "Username and password to include in the request. "
+        "Specify '-' for the password to use a password prompt. "
+        "Note that using --verbose/-v will expose the Authorization header, "
+        "including the password encoding in a trivially reversible format."
+    ),
+)
+@click.option(
+    "--proxies",
+    "proxies",
+    type=str,
+    default=None,
+    help="Send the request via a proxy. Should be the URL giving the proxy address.",
+)
+@click.option(
+    "--timeout",
+    "timeout",
+    type=float,
+    default=5.0,
+    help=(
+        "Timeout value to use for network operations, such as establishing the "
+        "connection, reading some data, etc... [Default: 5.0]"
+    ),
+)
+@click.option(
+    "--follow-redirects",
+    "follow_redirects",
+    is_flag=True,
+    default=False,
+    help="Automatically follow redirects.",
+)
+@click.option(
+    "--no-verify",
+    "verify",
+    is_flag=True,
+    default=True,
+    help="Disable SSL verification.",
+)
+@click.option(
+    "--http2",
+    "http2",
+    type=bool,
+    is_flag=True,
+    default=False,
+    help="Send the request using HTTP/2, if the remote server supports it.",
+)
+@click.option(
+    "--download",
+    type=click.File("wb"),
+    help="Save the response content as a file, rather than displaying it.",
+)
+@click.option(
+    "--verbose",
+    "-v",
+    type=bool,
+    is_flag=True,
+    default=False,
+    help="Verbose. Show request as well as response.",
+)
+@click.option(
+    "--help",
+    is_flag=True,
+    is_eager=True,
+    expose_value=False,
+    callback=handle_help,
+    help="Show this message and exit.",
+)
+def main(
+    url: str,
+    method: str,
+    params: typing.List[typing.Tuple[str, str]],
+    content: str,
+    data: typing.List[typing.Tuple[str, str]],
+    files: typing.List[typing.Tuple[str, click.File]],
+    json: str,
+    headers: typing.List[typing.Tuple[str, str]],
+    cookies: typing.List[typing.Tuple[str, str]],
+    auth: typing.Optional[typing.Tuple[str, str]],
+    proxies: str,
+    timeout: float,
+    follow_redirects: bool,
+    verify: bool,
+    http2: bool,
+    download: typing.Optional[typing.BinaryIO],
+    verbose: bool,
+) -> None:
+    """
+    An HTTP command line client.
+    Sends a request and displays the response.
+    """
+    if not method:
+        method = "POST" if content or data or files or json else "GET"
+
+    try:
+        with Client(
+            proxies=proxies,
+            timeout=timeout,
+            verify=verify,
+            http2=http2,
+        ) as client:
+            with client.stream(
+                method,
+                url,
+                params=list(params),
+                content=content,
+                data=dict(data),
+                files=files,  # type: ignore
+                json=json,
+                headers=headers,
+                cookies=dict(cookies),
+                auth=auth,
+                follow_redirects=follow_redirects,
+                extensions={"trace": functools.partial(trace, verbose=verbose)},
+            ) as response:
+                if download is not None:
+                    download_response(response, download)
+                else:
+                    response.read()
+                    if response.content:
+                        print_response(response)
+
+    except RequestError as exc:
+        console = rich.console.Console()
+        console.print(f"[red]{type(exc).__name__}[/red]: {exc}")
+        sys.exit(1)
+
+    sys.exit(0 if response.is_success else 1)
diff --git a/myenv/lib/python3.9/site-packages/httpx/_models.py b/myenv/lib/python3.9/site-packages/httpx/_models.py
new file mode 100644
index 0000000..cff6929
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_models.py
@@ -0,0 +1,1196 @@
+import cgi
+import datetime
+import email.message
+import json as jsonlib
+import typing
+import urllib.request
+from collections.abc import MutableMapping
+from http.cookiejar import Cookie, CookieJar
+
+from ._content import ByteStream, UnattachedStream, encode_request, encode_response
+from ._decoders import (
+    SUPPORTED_DECODERS,
+    ByteChunker,
+    ContentDecoder,
+    IdentityDecoder,
+    LineDecoder,
+    MultiDecoder,
+    TextChunker,
+    TextDecoder,
+)
+from ._exceptions import (
+    CookieConflict,
+    HTTPStatusError,
+    RequestNotRead,
+    ResponseNotRead,
+    StreamClosed,
+    StreamConsumed,
+    request_context,
+)
+from ._status_codes import codes
+from ._types import (
+    AsyncByteStream,
+    CookieTypes,
+    HeaderTypes,
+    QueryParamTypes,
+    RawURL,
+    RequestContent,
+    RequestData,
+    RequestFiles,
+    ResponseContent,
+    SyncByteStream,
+)
+from ._urls import URL
+from ._utils import (
+    guess_json_utf,
+    is_known_encoding,
+    normalize_header_key,
+    normalize_header_value,
+    obfuscate_sensitive_headers,
+    parse_header_links,
+)
+
+
+class Headers(typing.MutableMapping[str, str]):
+    """
+    HTTP headers, as a case-insensitive multi-dict.
+    """
+
+    def __init__(
+        self,
+        headers: typing.Optional[HeaderTypes] = None,
+        encoding: typing.Optional[str] = None,
+    ) -> None:
+        if headers is None:
+            self._list = []  # type: typing.List[typing.Tuple[bytes, bytes, bytes]]
+        elif isinstance(headers, Headers):
+            self._list = list(headers._list)
+        elif isinstance(headers, dict):
+            self._list = [
+                (
+                    normalize_header_key(k, lower=False, encoding=encoding),
+                    normalize_header_key(k, lower=True, encoding=encoding),
+                    normalize_header_value(v, encoding),
+                )
+                for k, v in headers.items()
+            ]
+        else:
+            self._list = [
+                (
+                    normalize_header_key(k, lower=False, encoding=encoding),
+                    normalize_header_key(k, lower=True, encoding=encoding),
+                    normalize_header_value(v, encoding),
+                )
+                for k, v in headers
+            ]
+
+        self._encoding = encoding
+
+    @property
+    def encoding(self) -> str:
+        """
+        Header encoding is mandated as ascii, but we allow fallbacks to utf-8
+        or iso-8859-1.
+        """
+        if self._encoding is None:
+            for encoding in ["ascii", "utf-8"]:
+                for key, value in self.raw:
+                    try:
+                        key.decode(encoding)
+                        value.decode(encoding)
+                    except UnicodeDecodeError:
+                        break
+                else:
+                    # The else block runs if 'break' did not occur, meaning
+                    # all values fitted the encoding.
+                    self._encoding = encoding
+                    break
+            else:
+                # The ISO-8859-1 encoding covers all 256 code points in a byte,
+                # so will never raise decode errors.
+                self._encoding = "iso-8859-1"
+        return self._encoding
+
+    @encoding.setter
+    def encoding(self, value: str) -> None:
+        self._encoding = value
+
+    @property
+    def raw(self) -> typing.List[typing.Tuple[bytes, bytes]]:
+        """
+        Returns a list of the raw header items, as byte pairs.
+        """
+        return [(raw_key, value) for raw_key, _, value in self._list]
+
+    def keys(self) -> typing.KeysView[str]:
+        return {key.decode(self.encoding): None for _, key, value in self._list}.keys()
+
+    def values(self) -> typing.ValuesView[str]:
+        values_dict: typing.Dict[str, str] = {}
+        for _, key, value in self._list:
+            str_key = key.decode(self.encoding)
+            str_value = value.decode(self.encoding)
+            if str_key in values_dict:
+                values_dict[str_key] += f", {str_value}"
+            else:
+                values_dict[str_key] = str_value
+        return values_dict.values()
+
+    def items(self) -> typing.ItemsView[str, str]:
+        """
+        Return `(key, value)` items of headers. Concatenate headers
+        into a single comma separated value when a key occurs multiple times.
+        """
+        values_dict: typing.Dict[str, str] = {}
+        for _, key, value in self._list:
+            str_key = key.decode(self.encoding)
+            str_value = value.decode(self.encoding)
+            if str_key in values_dict:
+                values_dict[str_key] += f", {str_value}"
+            else:
+                values_dict[str_key] = str_value
+        return values_dict.items()
+
+    def multi_items(self) -> typing.List[typing.Tuple[str, str]]:
+        """
+        Return a list of `(key, value)` pairs of headers. Allow multiple
+        occurrences of the same key without concatenating into a single
+        comma separated value.
+        """
+        return [
+            (key.decode(self.encoding), value.decode(self.encoding))
+            for _, key, value in self._list
+        ]
+
+    def get(self, key: str, default: typing.Any = None) -> typing.Any:
+        """
+        Return a header value. If multiple occurrences of the header occur
+        then concatenate them together with commas.
+        """
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def get_list(self, key: str, split_commas: bool = False) -> typing.List[str]:
+        """
+        Return a list of all header values for a given key.
+        If `split_commas=True` is passed, then any comma separated header
+        values are split into multiple return strings.
+        """
+        get_header_key = key.lower().encode(self.encoding)
+
+        values = [
+            item_value.decode(self.encoding)
+            for _, item_key, item_value in self._list
+            if item_key.lower() == get_header_key
+        ]
+
+        if not split_commas:
+            return values
+
+        split_values = []
+        for value in values:
+            split_values.extend([item.strip() for item in value.split(",")])
+        return split_values
+
+    def update(self, headers: typing.Optional[HeaderTypes] = None) -> None:  # type: ignore
+        headers = Headers(headers)
+        for key in headers.keys():
+            if key in self:
+                self.pop(key)
+        self._list.extend(headers._list)
+
+    def copy(self) -> "Headers":
+        return Headers(self, encoding=self.encoding)
+
+    def __getitem__(self, key: str) -> str:
+        """
+        Return a single header value.
+
+        If there are multiple headers with the same key, then we concatenate
+        them with commas. See: https://tools.ietf.org/html/rfc7230#section-3.2.2
+        """
+        normalized_key = key.lower().encode(self.encoding)
+
+        items = [
+            header_value.decode(self.encoding)
+            for _, header_key, header_value in self._list
+            if header_key == normalized_key
+        ]
+
+        if items:
+            return ", ".join(items)
+
+        raise KeyError(key)
+
+    def __setitem__(self, key: str, value: str) -> None:
+        """
+        Set the header `key` to `value`, removing any duplicate entries.
+        Retains insertion order.
+        """
+        set_key = key.encode(self._encoding or "utf-8")
+        set_value = value.encode(self._encoding or "utf-8")
+        lookup_key = set_key.lower()
+
+        found_indexes = [
+            idx
+            for idx, (_, item_key, _) in enumerate(self._list)
+            if item_key == lookup_key
+        ]
+
+        for idx in reversed(found_indexes[1:]):
+            del self._list[idx]
+
+        if found_indexes:
+            idx = found_indexes[0]
+            self._list[idx] = (set_key, lookup_key, set_value)
+        else:
+            self._list.append((set_key, lookup_key, set_value))
+
+    def __delitem__(self, key: str) -> None:
+        """
+        Remove the header `key`.
+        """
+        del_key = key.lower().encode(self.encoding)
+
+        pop_indexes = [
+            idx
+            for idx, (_, item_key, _) in enumerate(self._list)
+            if item_key.lower() == del_key
+        ]
+
+        if not pop_indexes:
+            raise KeyError(key)
+
+        for idx in reversed(pop_indexes):
+            del self._list[idx]
+
+    def __contains__(self, key: typing.Any) -> bool:
+        header_key = key.lower().encode(self.encoding)
+        return header_key in [key for _, key, _ in self._list]
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._list)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        try:
+            other_headers = Headers(other)
+        except ValueError:
+            return False
+
+        self_list = [(key, value) for _, key, value in self._list]
+        other_list = [(key, value) for _, key, value in other_headers._list]
+        return sorted(self_list) == sorted(other_list)
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+
+        encoding_str = ""
+        if self.encoding != "ascii":
+            encoding_str = f", encoding={self.encoding!r}"
+
+        as_list = list(obfuscate_sensitive_headers(self.multi_items()))
+        as_dict = dict(as_list)
+
+        no_duplicate_keys = len(as_dict) == len(as_list)
+        if no_duplicate_keys:
+            return f"{class_name}({as_dict!r}{encoding_str})"
+        return f"{class_name}({as_list!r}{encoding_str})"
+
+
+class Request:
+    def __init__(
+        self,
+        method: typing.Union[str, bytes],
+        url: typing.Union["URL", str, RawURL],
+        *,
+        params: typing.Optional[QueryParamTypes] = None,
+        headers: typing.Optional[HeaderTypes] = None,
+        cookies: typing.Optional[CookieTypes] = None,
+        content: typing.Optional[RequestContent] = None,
+        data: typing.Optional[RequestData] = None,
+        files: typing.Optional[RequestFiles] = None,
+        json: typing.Optional[typing.Any] = None,
+        stream: typing.Union[SyncByteStream, AsyncByteStream, None] = None,
+        extensions: typing.Optional[dict] = None,
+    ):
+        self.method = (
+            method.decode("ascii").upper()
+            if isinstance(method, bytes)
+            else method.upper()
+        )
+        self.url = URL(url)
+        if params is not None:
+            self.url = self.url.copy_merge_params(params=params)
+        self.headers = Headers(headers)
+        self.extensions = {} if extensions is None else extensions
+
+        if cookies:
+            Cookies(cookies).set_cookie_header(self)
+
+        if stream is None:
+            headers, stream = encode_request(content, data, files, json)
+            self._prepare(headers)
+            self.stream = stream
+            # Load the request body, except for streaming content.
+            if isinstance(stream, ByteStream):
+                self.read()
+        else:
+            # There's an important distinction between `Request(content=...)`,
+            # and `Request(stream=...)`.
+            #
+            # Using `content=...` implies automatically populated `Host` and content
+            # headers, of either `Content-Length: ...` or `Transfer-Encoding: chunked`.
+            #
+            # Using `stream=...` will not automatically include *any* auto-populated headers.
+            #
+            # As an end-user you don't really need `stream=...`. It's only
+            # useful when:
+            #
+            # * Preserving the request stream when copying requests, eg for redirects.
+            # * Creating request instances on the *server-side* of the transport API.
+            self.stream = stream
+
+    def _prepare(self, default_headers: typing.Dict[str, str]) -> None:
+        for key, value in default_headers.items():
+            # Ignore Transfer-Encoding if the Content-Length has been set explicitly.
+            if key.lower() == "transfer-encoding" and "Content-Length" in self.headers:
+                continue
+            self.headers.setdefault(key, value)
+
+        auto_headers: typing.List[typing.Tuple[bytes, bytes]] = []
+
+        has_host = "Host" in self.headers
+        has_content_length = (
+            "Content-Length" in self.headers or "Transfer-Encoding" in self.headers
+        )
+
+        if not has_host and self.url.host:
+            auto_headers.append((b"Host", self.url.netloc))
+        if not has_content_length and self.method in ("POST", "PUT", "PATCH"):
+            auto_headers.append((b"Content-Length", b"0"))
+
+        self.headers = Headers(auto_headers + self.headers.raw)
+
+    @property
+    def content(self) -> bytes:
+        if not hasattr(self, "_content"):
+            raise RequestNotRead()
+        return self._content
+
+    def read(self) -> bytes:
+        """
+        Read and return the request content.
+        """
+        if not hasattr(self, "_content"):
+            assert isinstance(self.stream, typing.Iterable)
+            self._content = b"".join(self.stream)
+            if not isinstance(self.stream, ByteStream):
+                # If a streaming request has been read entirely into memory, then
+                # we can replace the stream with a raw bytes implementation,
+                # to ensure that any non-replayable streams can still be used.
+                self.stream = ByteStream(self._content)
+        return self._content
+
+    async def aread(self) -> bytes:
+        """
+        Read and return the request content.
+        """
+        if not hasattr(self, "_content"):
+            assert isinstance(self.stream, typing.AsyncIterable)
+            self._content = b"".join([part async for part in self.stream])
+            if not isinstance(self.stream, ByteStream):
+                # If a streaming request has been read entirely into memory, then
+                # we can replace the stream with a raw bytes implementation,
+                # to ensure that any non-replayable streams can still be used.
+                self.stream = ByteStream(self._content)
+        return self._content
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        url = str(self.url)
+        return f"<{class_name}({self.method!r}, {url!r})>"
+
+    def __getstate__(self) -> typing.Dict[str, typing.Any]:
+        return {
+            name: value
+            for name, value in self.__dict__.items()
+            if name not in ["extensions", "stream"]
+        }
+
+    def __setstate__(self, state: typing.Dict[str, typing.Any]) -> None:
+        for name, value in state.items():
+            setattr(self, name, value)
+        self.extensions = {}
+        self.stream = UnattachedStream()
+
+
+class Response:
+    def __init__(
+        self,
+        status_code: int,
+        *,
+        headers: typing.Optional[HeaderTypes] = None,
+        content: typing.Optional[ResponseContent] = None,
+        text: typing.Optional[str] = None,
+        html: typing.Optional[str] = None,
+        json: typing.Any = None,
+        stream: typing.Union[SyncByteStream, AsyncByteStream, None] = None,
+        request: typing.Optional[Request] = None,
+        extensions: typing.Optional[dict] = None,
+        history: typing.Optional[typing.List["Response"]] = None,
+        default_encoding: typing.Union[str, typing.Callable[[bytes], str]] = "utf-8",
+    ):
+        self.status_code = status_code
+        self.headers = Headers(headers)
+
+        self._request: typing.Optional[Request] = request
+
+        # When follow_redirects=False and a redirect is received,
+        # the client will set `response.next_request`.
+        self.next_request: typing.Optional[Request] = None
+
+        self.extensions = {} if extensions is None else extensions
+        self.history = [] if history is None else list(history)
+
+        self.is_closed = False
+        self.is_stream_consumed = False
+
+        self.default_encoding = default_encoding
+
+        if stream is None:
+            headers, stream = encode_response(content, text, html, json)
+            self._prepare(headers)
+            self.stream = stream
+            if isinstance(stream, ByteStream):
+                # Load the response body, except for streaming content.
+                self.read()
+        else:
+            # There's an important distinction between `Response(content=...)`,
+            # and `Response(stream=...)`.
+            #
+            # Using `content=...` implies automatically populated content headers,
+            # of either `Content-Length: ...` or `Transfer-Encoding: chunked`.
+            #
+            # Using `stream=...` will not automatically include any content headers.
+            #
+            # As an end-user you don't really need `stream=...`. It's only
+            # useful when creating response instances having received a stream
+            # from the transport API.
+            self.stream = stream
+
+        self._num_bytes_downloaded = 0
+
+    def _prepare(self, default_headers: typing.Dict[str, str]) -> None:
+        for key, value in default_headers.items():
+            # Ignore Transfer-Encoding if the Content-Length has been set explicitly.
+            if key.lower() == "transfer-encoding" and "content-length" in self.headers:
+                continue
+            self.headers.setdefault(key, value)
+
+    @property
+    def elapsed(self) -> datetime.timedelta:
+        """
+        Returns the time taken for the complete request/response
+        cycle to complete.
+        """
+        if not hasattr(self, "_elapsed"):
+            raise RuntimeError(
+                "'.elapsed' may only be accessed after the response "
+                "has been read or closed."
+            )
+        return self._elapsed
+
+    @elapsed.setter
+    def elapsed(self, elapsed: datetime.timedelta) -> None:
+        self._elapsed = elapsed
+
+    @property
+    def request(self) -> Request:
+        """
+        Returns the request instance associated to the current response.
+        """
+        if self._request is None:
+            raise RuntimeError(
+                "The request instance has not been set on this response."
+            )
+        return self._request
+
+    @request.setter
+    def request(self, value: Request) -> None:
+        self._request = value
+
+    @property
+    def http_version(self) -> str:
+        try:
+            return self.extensions["http_version"].decode("ascii", errors="ignore")
+        except KeyError:
+            return "HTTP/1.1"
+
+    @property
+    def reason_phrase(self) -> str:
+        try:
+            return self.extensions["reason_phrase"].decode("ascii", errors="ignore")
+        except KeyError:
+            return codes.get_reason_phrase(self.status_code)
+
+    @property
+    def url(self) -> URL:
+        """
+        Returns the URL for which the request was made.
+        """
+        return self.request.url
+
+    @property
+    def content(self) -> bytes:
+        if not hasattr(self, "_content"):
+            raise ResponseNotRead()
+        return self._content
+
+    @property
+    def text(self) -> str:
+        if not hasattr(self, "_text"):
+            content = self.content
+            if not content:
+                self._text = ""
+            else:
+                decoder = TextDecoder(encoding=self.encoding or "utf-8")
+                self._text = "".join([decoder.decode(self.content), decoder.flush()])
+        return self._text
+
+    @property
+    def encoding(self) -> typing.Optional[str]:
+        """
+        Return an encoding to use for decoding the byte content into text.
+        The priority for determining this is given by...
+
+        * `.encoding = <>` has been set explicitly.
+        * The encoding as specified by the charset parameter in the Content-Type header.
+        * The encoding as determined by `default_encoding`, which may either be
+          a string like "utf-8" indicating the encoding to use, or may be a callable
+          which enables charset autodetection.
+        """
+        if not hasattr(self, "_encoding"):
+            encoding = self.charset_encoding
+            if encoding is None or not is_known_encoding(encoding):
+                if isinstance(self.default_encoding, str):
+                    encoding = self.default_encoding
+                elif hasattr(self, "_content"):
+                    encoding = self.default_encoding(self._content)
+            self._encoding = encoding or "utf-8"
+        return self._encoding
+
+    @encoding.setter
+    def encoding(self, value: str) -> None:
+        self._encoding = value
+
+    @property
+    def charset_encoding(self) -> typing.Optional[str]:
+        """
+        Return the encoding, as specified by the Content-Type header.
+        """
+        content_type = self.headers.get("Content-Type")
+        if content_type is None:
+            return None
+
+        _, params = cgi.parse_header(content_type)
+        if "charset" not in params:
+            return None
+
+        return params["charset"].strip("'\"")
+
+    def _get_content_decoder(self) -> ContentDecoder:
+        """
+        Returns a decoder instance which can be used to decode the raw byte
+        content, depending on the Content-Encoding used in the response.
+        """
+        if not hasattr(self, "_decoder"):
+            decoders: typing.List[ContentDecoder] = []
+            values = self.headers.get_list("content-encoding", split_commas=True)
+            for value in values:
+                value = value.strip().lower()
+                try:
+                    decoder_cls = SUPPORTED_DECODERS[value]
+                    decoders.append(decoder_cls())
+                except KeyError:
+                    continue
+
+            if len(decoders) == 1:
+                self._decoder = decoders[0]
+            elif len(decoders) > 1:
+                self._decoder = MultiDecoder(children=decoders)
+            else:
+                self._decoder = IdentityDecoder()
+
+        return self._decoder
+
+    @property
+    def is_informational(self) -> bool:
+        """
+        A property which is `True` for 1xx status codes, `False` otherwise.
+        """
+        return codes.is_informational(self.status_code)
+
+    @property
+    def is_success(self) -> bool:
+        """
+        A property which is `True` for 2xx status codes, `False` otherwise.
+        """
+        return codes.is_success(self.status_code)
+
+    @property
+    def is_redirect(self) -> bool:
+        """
+        A property which is `True` for 3xx status codes, `False` otherwise.
+
+        Note that not all responses with a 3xx status code indicate a URL redirect.
+
+        Use `response.has_redirect_location` to determine responses with a properly
+        formed URL redirection.
+        """
+        return codes.is_redirect(self.status_code)
+
+    @property
+    def is_client_error(self) -> bool:
+        """
+        A property which is `True` for 4xx status codes, `False` otherwise.
+        """
+        return codes.is_client_error(self.status_code)
+
+    @property
+    def is_server_error(self) -> bool:
+        """
+        A property which is `True` for 5xx status codes, `False` otherwise.
+        """
+        return codes.is_server_error(self.status_code)
+
+    @property
+    def is_error(self) -> bool:
+        """
+        A property which is `True` for 4xx and 5xx status codes, `False` otherwise.
+        """
+        return codes.is_error(self.status_code)
+
+    @property
+    def has_redirect_location(self) -> bool:
+        """
+        Returns True for 3xx responses with a properly formed URL redirection,
+        `False` otherwise.
+        """
+        return (
+            self.status_code
+            in (
+                # 301 (Cacheable redirect. Method may change to GET.)
+                codes.MOVED_PERMANENTLY,
+                # 302 (Uncacheable redirect. Method may change to GET.)
+                codes.FOUND,
+                # 303 (Client should make a GET or HEAD request.)
+                codes.SEE_OTHER,
+                # 307 (Equiv. 302, but retain method)
+                codes.TEMPORARY_REDIRECT,
+                # 308 (Equiv. 301, but retain method)
+                codes.PERMANENT_REDIRECT,
+            )
+            and "Location" in self.headers
+        )
+
+    def raise_for_status(self) -> None:
+        """
+        Raise the `HTTPStatusError` if one occurred.
+        """
+        request = self._request
+        if request is None:
+            raise RuntimeError(
+                "Cannot call `raise_for_status` as the request "
+                "instance has not been set on this response."
+            )
+
+        if self.is_success:
+            return
+
+        if self.has_redirect_location:
+            message = (
+                "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n"
+                "Redirect location: '{0.headers[location]}'\n"
+                "For more information check: https://httpstatuses.com/{0.status_code}"
+            )
+        else:
+            message = (
+                "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n"
+                "For more information check: https://httpstatuses.com/{0.status_code}"
+            )
+
+        status_class = self.status_code // 100
+        error_types = {
+            1: "Informational response",
+            3: "Redirect response",
+            4: "Client error",
+            5: "Server error",
+        }
+        error_type = error_types.get(status_class, "Invalid status code")
+        message = message.format(self, error_type=error_type)
+        raise HTTPStatusError(message, request=request, response=self)
+
+    def json(self, **kwargs: typing.Any) -> typing.Any:
+        if self.charset_encoding is None and self.content and len(self.content) > 3:
+            encoding = guess_json_utf(self.content)
+            if encoding is not None:
+                return jsonlib.loads(self.content.decode(encoding), **kwargs)
+        return jsonlib.loads(self.text, **kwargs)
+
+    @property
+    def cookies(self) -> "Cookies":
+        if not hasattr(self, "_cookies"):
+            self._cookies = Cookies()
+            self._cookies.extract_cookies(self)
+        return self._cookies
+
+    @property
+    def links(self) -> typing.Dict[typing.Optional[str], typing.Dict[str, str]]:
+        """
+        Returns the parsed header links of the response, if any
+        """
+        header = self.headers.get("link")
+        ldict = {}
+        if header:
+            links = parse_header_links(header)
+            for link in links:
+                key = link.get("rel") or link.get("url")
+                ldict[key] = link
+        return ldict
+
+    @property
+    def num_bytes_downloaded(self) -> int:
+        return self._num_bytes_downloaded
+
+    def __repr__(self) -> str:
+        return f"<Response [{self.status_code} {self.reason_phrase}]>"
+
+    def __getstate__(self) -> typing.Dict[str, typing.Any]:
+        return {
+            name: value
+            for name, value in self.__dict__.items()
+            if name not in ["extensions", "stream", "is_closed", "_decoder"]
+        }
+
+    def __setstate__(self, state: typing.Dict[str, typing.Any]) -> None:
+        for name, value in state.items():
+            setattr(self, name, value)
+        self.is_closed = True
+        self.extensions = {}
+        self.stream = UnattachedStream()
+
+    def read(self) -> bytes:
+        """
+        Read and return the response content.
+        """
+        if not hasattr(self, "_content"):
+            self._content = b"".join(self.iter_bytes())
+        return self._content
+
+    def iter_bytes(
+        self, chunk_size: typing.Optional[int] = None
+    ) -> typing.Iterator[bytes]:
+        """
+        A byte-iterator over the decoded response content.
+        This allows us to handle gzip, deflate, and brotli encoded responses.
+        """
+        if hasattr(self, "_content"):
+            chunk_size = len(self._content) if chunk_size is None else chunk_size
+            for i in range(0, len(self._content), max(chunk_size, 1)):
+                yield self._content[i : i + chunk_size]
+        else:
+            decoder = self._get_content_decoder()
+            chunker = ByteChunker(chunk_size=chunk_size)
+            with request_context(request=self._request):
+                for raw_bytes in self.iter_raw():
+                    decoded = decoder.decode(raw_bytes)
+                    for chunk in chunker.decode(decoded):
+                        yield chunk
+                decoded = decoder.flush()
+                for chunk in chunker.decode(decoded):
+                    yield chunk  # pragma: nocover
+                for chunk in chunker.flush():
+                    yield chunk
+
+    def iter_text(
+        self, chunk_size: typing.Optional[int] = None
+    ) -> typing.Iterator[str]:
+        """
+        A str-iterator over the decoded response content
+        that handles both gzip, deflate, etc but also detects the content's
+        string encoding.
+        """
+        decoder = TextDecoder(encoding=self.encoding or "utf-8")
+        chunker = TextChunker(chunk_size=chunk_size)
+        with request_context(request=self._request):
+            for byte_content in self.iter_bytes():
+                text_content = decoder.decode(byte_content)
+                for chunk in chunker.decode(text_content):
+                    yield chunk
+            text_content = decoder.flush()
+            for chunk in chunker.decode(text_content):
+                yield chunk
+            for chunk in chunker.flush():
+                yield chunk
+
+    def iter_lines(self) -> typing.Iterator[str]:
+        decoder = LineDecoder()
+        with request_context(request=self._request):
+            for text in self.iter_text():
+                for line in decoder.decode(text):
+                    yield line
+            for line in decoder.flush():
+                yield line
+
+    def iter_raw(
+        self, chunk_size: typing.Optional[int] = None
+    ) -> typing.Iterator[bytes]:
+        """
+        A byte-iterator over the raw response content.
+        """
+        if self.is_stream_consumed:
+            raise StreamConsumed()
+        if self.is_closed:
+            raise StreamClosed()
+        if not isinstance(self.stream, SyncByteStream):
+            raise RuntimeError("Attempted to call a sync iterator on an async stream.")
+
+        self.is_stream_consumed = True
+        self._num_bytes_downloaded = 0
+        chunker = ByteChunker(chunk_size=chunk_size)
+
+        with request_context(request=self._request):
+            for raw_stream_bytes in self.stream:
+                self._num_bytes_downloaded += len(raw_stream_bytes)
+                for chunk in chunker.decode(raw_stream_bytes):
+                    yield chunk
+
+        for chunk in chunker.flush():
+            yield chunk
+
+        self.close()
+
+    def close(self) -> None:
+        """
+        Close the response and release the connection.
+        Automatically called if the response body is read to completion.
+        """
+        if not isinstance(self.stream, SyncByteStream):
+            raise RuntimeError("Attempted to call an sync close on an async stream.")
+
+        if not self.is_closed:
+            self.is_closed = True
+            with request_context(request=self._request):
+                self.stream.close()
+
+    async def aread(self) -> bytes:
+        """
+        Read and return the response content.
+        """
+        if not hasattr(self, "_content"):
+            self._content = b"".join([part async for part in self.aiter_bytes()])
+        return self._content
+
+    async def aiter_bytes(
+        self, chunk_size: typing.Optional[int] = None
+    ) -> typing.AsyncIterator[bytes]:
+        """
+        A byte-iterator over the decoded response content.
+        This allows us to handle gzip, deflate, and brotli encoded responses.
+        """
+        if hasattr(self, "_content"):
+            chunk_size = len(self._content) if chunk_size is None else chunk_size
+            for i in range(0, len(self._content), max(chunk_size, 1)):
+                yield self._content[i : i + chunk_size]
+        else:
+            decoder = self._get_content_decoder()
+            chunker = ByteChunker(chunk_size=chunk_size)
+            with request_context(request=self._request):
+                async for raw_bytes in self.aiter_raw():
+                    decoded = decoder.decode(raw_bytes)
+                    for chunk in chunker.decode(decoded):
+                        yield chunk
+                decoded = decoder.flush()
+                for chunk in chunker.decode(decoded):
+                    yield chunk  # pragma: nocover
+                for chunk in chunker.flush():
+                    yield chunk
+
+    async def aiter_text(
+        self, chunk_size: typing.Optional[int] = None
+    ) -> typing.AsyncIterator[str]:
+        """
+        A str-iterator over the decoded response content
+        that handles both gzip, deflate, etc but also detects the content's
+        string encoding.
+        """
+        decoder = TextDecoder(encoding=self.encoding or "utf-8")
+        chunker = TextChunker(chunk_size=chunk_size)
+        with request_context(request=self._request):
+            async for byte_content in self.aiter_bytes():
+                text_content = decoder.decode(byte_content)
+                for chunk in chunker.decode(text_content):
+                    yield chunk
+            text_content = decoder.flush()
+            for chunk in chunker.decode(text_content):
+                yield chunk
+            for chunk in chunker.flush():
+                yield chunk
+
+    async def aiter_lines(self) -> typing.AsyncIterator[str]:
+        decoder = LineDecoder()
+        with request_context(request=self._request):
+            async for text in self.aiter_text():
+                for line in decoder.decode(text):
+                    yield line
+            for line in decoder.flush():
+                yield line
+
+    async def aiter_raw(
+        self, chunk_size: typing.Optional[int] = None
+    ) -> typing.AsyncIterator[bytes]:
+        """
+        A byte-iterator over the raw response content.
+        """
+        if self.is_stream_consumed:
+            raise StreamConsumed()
+        if self.is_closed:
+            raise StreamClosed()
+        if not isinstance(self.stream, AsyncByteStream):
+            raise RuntimeError("Attempted to call an async iterator on an sync stream.")
+
+        self.is_stream_consumed = True
+        self._num_bytes_downloaded = 0
+        chunker = ByteChunker(chunk_size=chunk_size)
+
+        with request_context(request=self._request):
+            async for raw_stream_bytes in self.stream:
+                self._num_bytes_downloaded += len(raw_stream_bytes)
+                for chunk in chunker.decode(raw_stream_bytes):
+                    yield chunk
+
+        for chunk in chunker.flush():
+            yield chunk
+
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        """
+        Close the response and release the connection.
+        Automatically called if the response body is read to completion.
+        """
+        if not isinstance(self.stream, AsyncByteStream):
+            raise RuntimeError("Attempted to call an async close on an sync stream.")
+
+        if not self.is_closed:
+            self.is_closed = True
+            with request_context(request=self._request):
+                await self.stream.aclose()
+
+
+class Cookies(MutableMapping):
+    """
+    HTTP Cookies, as a mutable mapping.
+    """
+
+    def __init__(self, cookies: typing.Optional[CookieTypes] = None) -> None:
+        if cookies is None or isinstance(cookies, dict):
+            self.jar = CookieJar()
+            if isinstance(cookies, dict):
+                for key, value in cookies.items():
+                    self.set(key, value)
+        elif isinstance(cookies, list):
+            self.jar = CookieJar()
+            for key, value in cookies:
+                self.set(key, value)
+        elif isinstance(cookies, Cookies):
+            self.jar = CookieJar()
+            for cookie in cookies.jar:
+                self.jar.set_cookie(cookie)
+        else:
+            self.jar = cookies
+
+    def extract_cookies(self, response: Response) -> None:
+        """
+        Loads any cookies based on the response `Set-Cookie` headers.
+        """
+        urllib_response = self._CookieCompatResponse(response)
+        urllib_request = self._CookieCompatRequest(response.request)
+
+        self.jar.extract_cookies(urllib_response, urllib_request)  # type: ignore
+
+    def set_cookie_header(self, request: Request) -> None:
+        """
+        Sets an appropriate 'Cookie:' HTTP header on the `Request`.
+        """
+        urllib_request = self._CookieCompatRequest(request)
+        self.jar.add_cookie_header(urllib_request)
+
+    def set(self, name: str, value: str, domain: str = "", path: str = "/") -> None:
+        """
+        Set a cookie value by name. May optionally include domain and path.
+        """
+        kwargs = {
+            "version": 0,
+            "name": name,
+            "value": value,
+            "port": None,
+            "port_specified": False,
+            "domain": domain,
+            "domain_specified": bool(domain),
+            "domain_initial_dot": domain.startswith("."),
+            "path": path,
+            "path_specified": bool(path),
+            "secure": False,
+            "expires": None,
+            "discard": True,
+            "comment": None,
+            "comment_url": None,
+            "rest": {"HttpOnly": None},
+            "rfc2109": False,
+        }
+        cookie = Cookie(**kwargs)  # type: ignore
+        self.jar.set_cookie(cookie)
+
+    def get(  # type: ignore
+        self,
+        name: str,
+        default: typing.Optional[str] = None,
+        domain: typing.Optional[str] = None,
+        path: typing.Optional[str] = None,
+    ) -> typing.Optional[str]:
+        """
+        Get a cookie by name. May optionally include domain and path
+        in order to specify exactly which cookie to retrieve.
+        """
+        value = None
+        for cookie in self.jar:
+            if cookie.name == name:
+                if domain is None or cookie.domain == domain:
+                    if path is None or cookie.path == path:
+                        if value is not None:
+                            message = f"Multiple cookies exist with name={name}"
+                            raise CookieConflict(message)
+                        value = cookie.value
+
+        if value is None:
+            return default
+        return value
+
+    def delete(
+        self,
+        name: str,
+        domain: typing.Optional[str] = None,
+        path: typing.Optional[str] = None,
+    ) -> None:
+        """
+        Delete a cookie by name. May optionally include domain and path
+        in order to specify exactly which cookie to delete.
+        """
+        if domain is not None and path is not None:
+            return self.jar.clear(domain, path, name)
+
+        remove = [
+            cookie
+            for cookie in self.jar
+            if cookie.name == name
+            and (domain is None or cookie.domain == domain)
+            and (path is None or cookie.path == path)
+        ]
+
+        for cookie in remove:
+            self.jar.clear(cookie.domain, cookie.path, cookie.name)
+
+    def clear(
+        self, domain: typing.Optional[str] = None, path: typing.Optional[str] = None
+    ) -> None:
+        """
+        Delete all cookies. Optionally include a domain and path in
+        order to only delete a subset of all the cookies.
+        """
+        args = []
+        if domain is not None:
+            args.append(domain)
+        if path is not None:
+            assert domain is not None
+            args.append(path)
+        self.jar.clear(*args)
+
+    def update(self, cookies: typing.Optional[CookieTypes] = None) -> None:  # type: ignore
+        cookies = Cookies(cookies)
+        for cookie in cookies.jar:
+            self.jar.set_cookie(cookie)
+
+    def __setitem__(self, name: str, value: str) -> None:
+        return self.set(name, value)
+
+    def __getitem__(self, name: str) -> str:
+        value = self.get(name)
+        if value is None:
+            raise KeyError(name)
+        return value
+
+    def __delitem__(self, name: str) -> None:
+        return self.delete(name)
+
+    def __len__(self) -> int:
+        return len(self.jar)
+
+    def __iter__(self) -> typing.Iterator[str]:
+        return (cookie.name for cookie in self.jar)
+
+    def __bool__(self) -> bool:
+        for _ in self.jar:
+            return True
+        return False
+
+    def __repr__(self) -> str:
+        cookies_repr = ", ".join(
+            [
+                f"<Cookie {cookie.name}={cookie.value} for {cookie.domain} />"
+                for cookie in self.jar
+            ]
+        )
+
+        return f"<Cookies[{cookies_repr}]>"
+
+    class _CookieCompatRequest(urllib.request.Request):
+        """
+        Wraps a `Request` instance up in a compatibility interface suitable
+        for use with `CookieJar` operations.
+        """
+
+        def __init__(self, request: Request) -> None:
+            super().__init__(
+                url=str(request.url),
+                headers=dict(request.headers),
+                method=request.method,
+            )
+            self.request = request
+
+        def add_unredirected_header(self, key: str, value: str) -> None:
+            super().add_unredirected_header(key, value)
+            self.request.headers[key] = value
+
+    class _CookieCompatResponse:
+        """
+        Wraps a `Request` instance up in a compatibility interface suitable
+        for use with `CookieJar` operations.
+        """
+
+        def __init__(self, response: Response):
+            self.response = response
+
+        def info(self) -> email.message.Message:
+            info = email.message.Message()
+            for key, value in self.response.headers.multi_items():
+                # Note that setting `info[key]` here is an "append" operation,
+                # not a "replace" operation.
+                # https://docs.python.org/3/library/email.compat32-message.html#email.message.Message.__setitem__
+                info[key] = value
+            return info
diff --git a/myenv/lib/python3.9/site-packages/httpx/_multipart.py b/myenv/lib/python3.9/site-packages/httpx/_multipart.py
new file mode 100644
index 0000000..d42f5cb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_multipart.py
@@ -0,0 +1,236 @@
+import binascii
+import io
+import os
+import typing
+from pathlib import Path
+
+from ._types import (
+    AsyncByteStream,
+    FileContent,
+    FileTypes,
+    RequestFiles,
+    SyncByteStream,
+)
+from ._utils import (
+    format_form_param,
+    guess_content_type,
+    peek_filelike_length,
+    primitive_value_to_str,
+    to_bytes,
+)
+
+
+class DataField:
+    """
+    A single form field item, within a multipart form field.
+    """
+
+    def __init__(
+        self, name: str, value: typing.Union[str, bytes, int, float, None]
+    ) -> None:
+        if not isinstance(name, str):
+            raise TypeError(
+                f"Invalid type for name. Expected str, got {type(name)}: {name!r}"
+            )
+        if value is not None and not isinstance(value, (str, bytes, int, float)):
+            raise TypeError(
+                f"Invalid type for value. Expected primitive type, got {type(value)}: {value!r}"
+            )
+        self.name = name
+        self.value: typing.Union[str, bytes] = (
+            value if isinstance(value, bytes) else primitive_value_to_str(value)
+        )
+
+    def render_headers(self) -> bytes:
+        if not hasattr(self, "_headers"):
+            name = format_form_param("name", self.name)
+            self._headers = b"".join(
+                [b"Content-Disposition: form-data; ", name, b"\r\n\r\n"]
+            )
+
+        return self._headers
+
+    def render_data(self) -> bytes:
+        if not hasattr(self, "_data"):
+            self._data = to_bytes(self.value)
+
+        return self._data
+
+    def get_length(self) -> int:
+        headers = self.render_headers()
+        data = self.render_data()
+        return len(headers) + len(data)
+
+    def render(self) -> typing.Iterator[bytes]:
+        yield self.render_headers()
+        yield self.render_data()
+
+
+class FileField:
+    """
+    A single file field item, within a multipart form field.
+    """
+
+    CHUNK_SIZE = 64 * 1024
+
+    def __init__(self, name: str, value: FileTypes) -> None:
+        self.name = name
+
+        fileobj: FileContent
+
+        headers: typing.Dict[str, str] = {}
+        content_type: typing.Optional[str] = None
+
+        # This large tuple based API largely mirror's requests' API
+        # It would be good to think of better APIs for this that we could include in httpx 2.0
+        # since variable length tuples (especially of 4 elements) are quite unwieldly
+        if isinstance(value, tuple):
+            if len(value) == 2:
+                # neither the 3rd parameter (content_type) nor the 4th (headers) was included
+                filename, fileobj = value  # type: ignore
+            elif len(value) == 3:
+                filename, fileobj, content_type = value  # type: ignore
+            else:
+                # all 4 parameters included
+                filename, fileobj, content_type, headers = value  # type: ignore
+        else:
+            filename = Path(str(getattr(value, "name", "upload"))).name
+            fileobj = value
+
+        if content_type is None:
+            content_type = guess_content_type(filename)
+
+        has_content_type_header = any("content-type" in key.lower() for key in headers)
+        if content_type is not None and not has_content_type_header:
+            # note that unlike requests, we ignore the content_type
+            # provided in the 3rd tuple element if it is also included in the headers
+            # requests does the opposite (it overwrites the header with the 3rd tuple element)
+            headers["Content-Type"] = content_type
+
+        if isinstance(fileobj, (str, io.StringIO)):
+            raise TypeError(f"Expected bytes or bytes-like object got: {type(fileobj)}")
+
+        self.filename = filename
+        self.file = fileobj
+        self.headers = headers
+
+    def get_length(self) -> int:
+        headers = self.render_headers()
+
+        if isinstance(self.file, (str, bytes)):
+            return len(headers) + len(to_bytes(self.file))
+
+        # Let's do our best not to read `file` into memory.
+        file_length = peek_filelike_length(self.file)
+        if file_length is None:
+            # As a last resort, read file and cache contents for later.
+            assert not hasattr(self, "_data")
+            self._data = to_bytes(self.file.read())
+            file_length = len(self._data)
+
+        return len(headers) + file_length
+
+    def render_headers(self) -> bytes:
+        if not hasattr(self, "_headers"):
+            parts = [
+                b"Content-Disposition: form-data; ",
+                format_form_param("name", self.name),
+            ]
+            if self.filename:
+                filename = format_form_param("filename", self.filename)
+                parts.extend([b"; ", filename])
+            for header_name, header_value in self.headers.items():
+                key, val = f"\r\n{header_name}: ".encode(), header_value.encode()
+                parts.extend([key, val])
+            parts.append(b"\r\n\r\n")
+            self._headers = b"".join(parts)
+
+        return self._headers
+
+    def render_data(self) -> typing.Iterator[bytes]:
+        if isinstance(self.file, (str, bytes)):
+            yield to_bytes(self.file)
+            return
+
+        if hasattr(self, "_data"):
+            # Already rendered.
+            yield self._data
+            return
+
+        if hasattr(self.file, "seek"):
+            self.file.seek(0)
+
+        chunk = self.file.read(self.CHUNK_SIZE)
+        while chunk:
+            yield to_bytes(chunk)
+            chunk = self.file.read(self.CHUNK_SIZE)
+
+    def render(self) -> typing.Iterator[bytes]:
+        yield self.render_headers()
+        yield from self.render_data()
+
+
+class MultipartStream(SyncByteStream, AsyncByteStream):
+    """
+    Request content as streaming multipart encoded form data.
+    """
+
+    def __init__(
+        self, data: dict, files: RequestFiles, boundary: typing.Optional[bytes] = None
+    ) -> None:
+        if boundary is None:
+            boundary = binascii.hexlify(os.urandom(16))
+
+        self.boundary = boundary
+        self.content_type = "multipart/form-data; boundary=%s" % boundary.decode(
+            "ascii"
+        )
+        self.fields = list(self._iter_fields(data, files))
+
+    def _iter_fields(
+        self, data: dict, files: RequestFiles
+    ) -> typing.Iterator[typing.Union[FileField, DataField]]:
+        for name, value in data.items():
+            if isinstance(value, list):
+                for item in value:
+                    yield DataField(name=name, value=item)
+            else:
+                yield DataField(name=name, value=value)
+
+        file_items = files.items() if isinstance(files, typing.Mapping) else files
+        for name, value in file_items:
+            yield FileField(name=name, value=value)
+
+    def iter_chunks(self) -> typing.Iterator[bytes]:
+        for field in self.fields:
+            yield b"--%s\r\n" % self.boundary
+            yield from field.render()
+            yield b"\r\n"
+        yield b"--%s--\r\n" % self.boundary
+
+    def iter_chunks_lengths(self) -> typing.Iterator[int]:
+        boundary_length = len(self.boundary)
+        # Follow closely what `.iter_chunks()` does.
+        for field in self.fields:
+            yield 2 + boundary_length + 2
+            yield field.get_length()
+            yield 2
+        yield 2 + boundary_length + 4
+
+    def get_content_length(self) -> int:
+        return sum(self.iter_chunks_lengths())
+
+    # Content stream interface.
+
+    def get_headers(self) -> typing.Dict[str, str]:
+        content_length = str(self.get_content_length())
+        content_type = self.content_type
+        return {"Content-Length": content_length, "Content-Type": content_type}
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        for chunk in self.iter_chunks():
+            yield chunk
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        for chunk in self.iter_chunks():
+            yield chunk
diff --git a/myenv/lib/python3.9/site-packages/httpx/_status_codes.py b/myenv/lib/python3.9/site-packages/httpx/_status_codes.py
new file mode 100644
index 0000000..e500441
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_status_codes.py
@@ -0,0 +1,158 @@
+from enum import IntEnum
+
+
+class codes(IntEnum):
+    """HTTP status codes and reason phrases
+
+    Status codes from the following RFCs are all observed:
+
+        * RFC 7231: Hypertext Transfer Protocol (HTTP/1.1), obsoletes 2616
+        * RFC 6585: Additional HTTP Status Codes
+        * RFC 3229: Delta encoding in HTTP
+        * RFC 4918: HTTP Extensions for WebDAV, obsoletes 2518
+        * RFC 5842: Binding Extensions to WebDAV
+        * RFC 7238: Permanent Redirect
+        * RFC 2295: Transparent Content Negotiation in HTTP
+        * RFC 2774: An HTTP Extension Framework
+        * RFC 7540: Hypertext Transfer Protocol Version 2 (HTTP/2)
+        * RFC 2324: Hyper Text Coffee Pot Control Protocol (HTCPCP/1.0)
+        * RFC 7725: An HTTP Status Code to Report Legal Obstacles
+        * RFC 8297: An HTTP Status Code for Indicating Hints
+        * RFC 8470: Using Early Data in HTTP
+    """
+
+    def __new__(cls, value: int, phrase: str = "") -> "codes":
+        obj = int.__new__(cls, value)  # type: ignore
+        obj._value_ = value
+
+        obj.phrase = phrase  # type: ignore
+        return obj
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def get_reason_phrase(cls, value: int) -> str:
+        try:
+            return codes(value).phrase  # type: ignore
+        except ValueError:
+            return ""
+
+    @classmethod
+    def is_informational(cls, value: int) -> bool:
+        """
+        Returns `True` for 1xx status codes, `False` otherwise.
+        """
+        return 100 <= value <= 199
+
+    @classmethod
+    def is_success(cls, value: int) -> bool:
+        """
+        Returns `True` for 2xx status codes, `False` otherwise.
+        """
+        return 200 <= value <= 299
+
+    @classmethod
+    def is_redirect(cls, value: int) -> bool:
+        """
+        Returns `True` for 3xx status codes, `False` otherwise.
+        """
+        return 300 <= value <= 399
+
+    @classmethod
+    def is_client_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 4xx status codes, `False` otherwise.
+        """
+        return 400 <= value <= 499
+
+    @classmethod
+    def is_server_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 5xx status codes, `False` otherwise.
+        """
+        return 500 <= value <= 599
+
+    @classmethod
+    def is_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 4xx or 5xx status codes, `False` otherwise.
+        """
+        return 400 <= value <= 599
+
+    # informational
+    CONTINUE = 100, "Continue"
+    SWITCHING_PROTOCOLS = 101, "Switching Protocols"
+    PROCESSING = 102, "Processing"
+    EARLY_HINTS = 103, "Early Hints"
+
+    # success
+    OK = 200, "OK"
+    CREATED = 201, "Created"
+    ACCEPTED = 202, "Accepted"
+    NON_AUTHORITATIVE_INFORMATION = 203, "Non-Authoritative Information"
+    NO_CONTENT = 204, "No Content"
+    RESET_CONTENT = 205, "Reset Content"
+    PARTIAL_CONTENT = 206, "Partial Content"
+    MULTI_STATUS = 207, "Multi-Status"
+    ALREADY_REPORTED = 208, "Already Reported"
+    IM_USED = 226, "IM Used"
+
+    # redirection
+    MULTIPLE_CHOICES = 300, "Multiple Choices"
+    MOVED_PERMANENTLY = 301, "Moved Permanently"
+    FOUND = 302, "Found"
+    SEE_OTHER = 303, "See Other"
+    NOT_MODIFIED = 304, "Not Modified"
+    USE_PROXY = 305, "Use Proxy"
+    TEMPORARY_REDIRECT = 307, "Temporary Redirect"
+    PERMANENT_REDIRECT = 308, "Permanent Redirect"
+
+    # client error
+    BAD_REQUEST = 400, "Bad Request"
+    UNAUTHORIZED = 401, "Unauthorized"
+    PAYMENT_REQUIRED = 402, "Payment Required"
+    FORBIDDEN = 403, "Forbidden"
+    NOT_FOUND = 404, "Not Found"
+    METHOD_NOT_ALLOWED = 405, "Method Not Allowed"
+    NOT_ACCEPTABLE = 406, "Not Acceptable"
+    PROXY_AUTHENTICATION_REQUIRED = 407, "Proxy Authentication Required"
+    REQUEST_TIMEOUT = 408, "Request Timeout"
+    CONFLICT = 409, "Conflict"
+    GONE = 410, "Gone"
+    LENGTH_REQUIRED = 411, "Length Required"
+    PRECONDITION_FAILED = 412, "Precondition Failed"
+    REQUEST_ENTITY_TOO_LARGE = 413, "Request Entity Too Large"
+    REQUEST_URI_TOO_LONG = 414, "Request-URI Too Long"
+    UNSUPPORTED_MEDIA_TYPE = 415, "Unsupported Media Type"
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416, "Requested Range Not Satisfiable"
+    EXPECTATION_FAILED = 417, "Expectation Failed"
+    IM_A_TEAPOT = 418, "I'm a teapot"
+    MISDIRECTED_REQUEST = 421, "Misdirected Request"
+    UNPROCESSABLE_ENTITY = 422, "Unprocessable Entity"
+    LOCKED = 423, "Locked"
+    FAILED_DEPENDENCY = 424, "Failed Dependency"
+    TOO_EARLY = 425, "Too Early"
+    UPGRADE_REQUIRED = 426, "Upgrade Required"
+    PRECONDITION_REQUIRED = 428, "Precondition Required"
+    TOO_MANY_REQUESTS = 429, "Too Many Requests"
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431, "Request Header Fields Too Large"
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451, "Unavailable For Legal Reasons"
+
+    # server errors
+    INTERNAL_SERVER_ERROR = 500, "Internal Server Error"
+    NOT_IMPLEMENTED = 501, "Not Implemented"
+    BAD_GATEWAY = 502, "Bad Gateway"
+    SERVICE_UNAVAILABLE = 503, "Service Unavailable"
+    GATEWAY_TIMEOUT = 504, "Gateway Timeout"
+    HTTP_VERSION_NOT_SUPPORTED = 505, "HTTP Version Not Supported"
+    VARIANT_ALSO_NEGOTIATES = 506, "Variant Also Negotiates"
+    INSUFFICIENT_STORAGE = 507, "Insufficient Storage"
+    LOOP_DETECTED = 508, "Loop Detected"
+    NOT_EXTENDED = 510, "Not Extended"
+    NETWORK_AUTHENTICATION_REQUIRED = 511, "Network Authentication Required"
+
+
+# Include lower-case styles for `requests` compatibility.
+for code in codes:
+    setattr(codes, code._name_.lower(), int(code))
diff --git a/myenv/lib/python3.9/site-packages/httpx/_transports/__init__.py b/myenv/lib/python3.9/site-packages/httpx/_transports/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/httpx/_transports/asgi.py b/myenv/lib/python3.9/site-packages/httpx/_transports/asgi.py
new file mode 100644
index 0000000..711a6f6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_transports/asgi.py
@@ -0,0 +1,163 @@
+import typing
+
+import sniffio
+
+from .._models import Request, Response
+from .._types import AsyncByteStream
+from .base import AsyncBaseTransport
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    import asyncio
+
+    import trio
+
+    Event = typing.Union[asyncio.Event, trio.Event]
+
+
+def create_event() -> "Event":
+    if sniffio.current_async_library() == "trio":
+        import trio
+
+        return trio.Event()
+    else:
+        import asyncio
+
+        return asyncio.Event()
+
+
+class ASGIResponseStream(AsyncByteStream):
+    def __init__(self, body: typing.List[bytes]) -> None:
+        self._body = body
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        yield b"".join(self._body)
+
+
+class ASGITransport(AsyncBaseTransport):
+    """
+    A custom AsyncTransport that handles sending requests directly to an ASGI app.
+    The simplest way to use this functionality is to use the `app` argument.
+
+    ```
+    client = httpx.AsyncClient(app=app)
+    ```
+
+    Alternatively, you can setup the transport instance explicitly.
+    This allows you to include any additional configuration arguments specific
+    to the ASGITransport class:
+
+    ```
+    transport = httpx.ASGITransport(
+        app=app,
+        root_path="/submount",
+        client=("1.2.3.4", 123)
+    )
+    client = httpx.AsyncClient(transport=transport)
+    ```
+
+    Arguments:
+
+    * `app` - The ASGI application.
+    * `raise_app_exceptions` - Boolean indicating if exceptions in the application
+       should be raised. Default to `True`. Can be set to `False` for use cases
+       such as testing the content of a client 500 response.
+    * `root_path` - The root path on which the ASGI application should be mounted.
+    * `client` - A two-tuple indicating the client IP and port of incoming requests.
+    ```
+    """
+
+    def __init__(
+        self,
+        app: typing.Callable,
+        raise_app_exceptions: bool = True,
+        root_path: str = "",
+        client: typing.Tuple[str, int] = ("127.0.0.1", 123),
+    ) -> None:
+        self.app = app
+        self.raise_app_exceptions = raise_app_exceptions
+        self.root_path = root_path
+        self.client = client
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, AsyncByteStream)
+
+        # ASGI scope.
+        scope = {
+            "type": "http",
+            "asgi": {"version": "3.0"},
+            "http_version": "1.1",
+            "method": request.method,
+            "headers": [(k.lower(), v) for (k, v) in request.headers.raw],
+            "scheme": request.url.scheme,
+            "path": request.url.path,
+            "raw_path": request.url.raw_path,
+            "query_string": request.url.query,
+            "server": (request.url.host, request.url.port),
+            "client": self.client,
+            "root_path": self.root_path,
+        }
+
+        # Request.
+        request_body_chunks = request.stream.__aiter__()
+        request_complete = False
+
+        # Response.
+        status_code = None
+        response_headers = None
+        body_parts = []
+        response_started = False
+        response_complete = create_event()
+
+        # ASGI callables.
+
+        async def receive() -> dict:
+            nonlocal request_complete
+
+            if request_complete:
+                await response_complete.wait()
+                return {"type": "http.disconnect"}
+
+            try:
+                body = await request_body_chunks.__anext__()
+            except StopAsyncIteration:
+                request_complete = True
+                return {"type": "http.request", "body": b"", "more_body": False}
+            return {"type": "http.request", "body": body, "more_body": True}
+
+        async def send(message: dict) -> None:
+            nonlocal status_code, response_headers, response_started
+
+            if message["type"] == "http.response.start":
+                assert not response_started
+
+                status_code = message["status"]
+                response_headers = message.get("headers", [])
+                response_started = True
+
+            elif message["type"] == "http.response.body":
+                assert not response_complete.is_set()
+                body = message.get("body", b"")
+                more_body = message.get("more_body", False)
+
+                if body and request.method != "HEAD":
+                    body_parts.append(body)
+
+                if not more_body:
+                    response_complete.set()
+
+        try:
+            await self.app(scope, receive, send)
+        except Exception:  # noqa: PIE-786
+            if self.raise_app_exceptions or not response_complete.is_set():
+                raise
+
+        assert response_complete.is_set()
+        assert status_code is not None
+        assert response_headers is not None
+
+        stream = ASGIResponseStream(body_parts)
+
+        return Response(status_code, headers=response_headers, stream=stream)
diff --git a/myenv/lib/python3.9/site-packages/httpx/_transports/base.py b/myenv/lib/python3.9/site-packages/httpx/_transports/base.py
new file mode 100644
index 0000000..ffba6a4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_transports/base.py
@@ -0,0 +1,82 @@
+import typing
+from types import TracebackType
+
+from .._models import Request, Response
+
+T = typing.TypeVar("T", bound="BaseTransport")
+A = typing.TypeVar("A", bound="AsyncBaseTransport")
+
+
+class BaseTransport:
+    def __enter__(self: T) -> T:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]] = None,
+        exc_value: typing.Optional[BaseException] = None,
+        traceback: typing.Optional[TracebackType] = None,
+    ) -> None:
+        self.close()
+
+    def handle_request(self, request: Request) -> Response:
+        """
+        Send a single HTTP request and return a response.
+
+        Developers shouldn't typically ever need to call into this API directly,
+        since the Client class provides all the higher level user-facing API
+        niceties.
+
+        In order to properly release any network resources, the response
+        stream should *either* be consumed immediately, with a call to
+        `response.stream.read()`, or else the `handle_request` call should
+        be followed with a try/finally block to ensuring the stream is
+        always closed.
+
+        Example usage:
+
+            with httpx.HTTPTransport() as transport:
+                req = httpx.Request(
+                    method=b"GET",
+                    url=(b"https", b"www.example.com", 443, b"/"),
+                    headers=[(b"Host", b"www.example.com")],
+                )
+                resp = transport.handle_request(req)
+                body = resp.stream.read()
+                print(resp.status_code, resp.headers, body)
+
+
+        Takes a `Request` instance as the only argument.
+
+        Returns a `Response` instance.
+        """
+        raise NotImplementedError(
+            "The 'handle_request' method must be implemented."
+        )  # pragma: nocover
+
+    def close(self) -> None:
+        pass
+
+
+class AsyncBaseTransport:
+    async def __aenter__(self: A) -> A:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]] = None,
+        exc_value: typing.Optional[BaseException] = None,
+        traceback: typing.Optional[TracebackType] = None,
+    ) -> None:
+        await self.aclose()
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        raise NotImplementedError(
+            "The 'handle_async_request' method must be implemented."
+        )  # pragma: nocover
+
+    async def aclose(self) -> None:
+        pass
diff --git a/myenv/lib/python3.9/site-packages/httpx/_transports/default.py b/myenv/lib/python3.9/site-packages/httpx/_transports/default.py
new file mode 100644
index 0000000..2086454
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_transports/default.py
@@ -0,0 +1,365 @@
+"""
+Custom transports, with nicely configured defaults.
+
+The following additional keyword arguments are currently supported by httpcore...
+
+* uds: str
+* local_address: str
+* retries: int
+
+Example usages...
+
+# Disable HTTP/2 on a single specific domain.
+mounts = {
+    "all://": httpx.HTTPTransport(http2=True),
+    "all://*example.org": httpx.HTTPTransport()
+}
+
+# Using advanced httpcore configuration, with connection retries.
+transport = httpx.HTTPTransport(retries=1)
+client = httpx.Client(transport=transport)
+
+# Using advanced httpcore configuration, with unix domain sockets.
+transport = httpx.HTTPTransport(uds="socket.uds")
+client = httpx.Client(transport=transport)
+"""
+import contextlib
+import typing
+from types import TracebackType
+
+import httpcore
+
+from .._config import DEFAULT_LIMITS, Limits, Proxy, create_ssl_context
+from .._exceptions import (
+    ConnectError,
+    ConnectTimeout,
+    LocalProtocolError,
+    NetworkError,
+    PoolTimeout,
+    ProtocolError,
+    ProxyError,
+    ReadError,
+    ReadTimeout,
+    RemoteProtocolError,
+    TimeoutException,
+    UnsupportedProtocol,
+    WriteError,
+    WriteTimeout,
+)
+from .._models import Request, Response
+from .._types import AsyncByteStream, CertTypes, SyncByteStream, VerifyTypes
+from .base import AsyncBaseTransport, BaseTransport
+
+T = typing.TypeVar("T", bound="HTTPTransport")
+A = typing.TypeVar("A", bound="AsyncHTTPTransport")
+
+
+@contextlib.contextmanager
+def map_httpcore_exceptions() -> typing.Iterator[None]:
+    try:
+        yield
+    except Exception as exc:  # noqa: PIE-786
+        mapped_exc = None
+
+        for from_exc, to_exc in HTTPCORE_EXC_MAP.items():
+            if not isinstance(exc, from_exc):
+                continue
+            # We want to map to the most specific exception we can find.
+            # Eg if `exc` is an `httpcore.ReadTimeout`, we want to map to
+            # `httpx.ReadTimeout`, not just `httpx.TimeoutException`.
+            if mapped_exc is None or issubclass(to_exc, mapped_exc):
+                mapped_exc = to_exc
+
+        if mapped_exc is None:  # pragma: nocover
+            raise
+
+        message = str(exc)
+        raise mapped_exc(message) from exc
+
+
+HTTPCORE_EXC_MAP = {
+    httpcore.TimeoutException: TimeoutException,
+    httpcore.ConnectTimeout: ConnectTimeout,
+    httpcore.ReadTimeout: ReadTimeout,
+    httpcore.WriteTimeout: WriteTimeout,
+    httpcore.PoolTimeout: PoolTimeout,
+    httpcore.NetworkError: NetworkError,
+    httpcore.ConnectError: ConnectError,
+    httpcore.ReadError: ReadError,
+    httpcore.WriteError: WriteError,
+    httpcore.ProxyError: ProxyError,
+    httpcore.UnsupportedProtocol: UnsupportedProtocol,
+    httpcore.ProtocolError: ProtocolError,
+    httpcore.LocalProtocolError: LocalProtocolError,
+    httpcore.RemoteProtocolError: RemoteProtocolError,
+}
+
+
+class ResponseStream(SyncByteStream):
+    def __init__(self, httpcore_stream: typing.Iterable[bytes]):
+        self._httpcore_stream = httpcore_stream
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        with map_httpcore_exceptions():
+            for part in self._httpcore_stream:
+                yield part
+
+    def close(self) -> None:
+        if hasattr(self._httpcore_stream, "close"):
+            self._httpcore_stream.close()  # type: ignore
+
+
+class HTTPTransport(BaseTransport):
+    def __init__(
+        self,
+        verify: VerifyTypes = True,
+        cert: typing.Optional[CertTypes] = None,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        trust_env: bool = True,
+        proxy: typing.Optional[Proxy] = None,
+        uds: typing.Optional[str] = None,
+        local_address: typing.Optional[str] = None,
+        retries: int = 0,
+    ) -> None:
+        ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)
+
+        if proxy is None:
+            self._pool = httpcore.ConnectionPool(
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                uds=uds,
+                local_address=local_address,
+                retries=retries,
+            )
+        elif proxy.url.scheme in ("http", "https"):
+            self._pool = httpcore.HTTPProxy(
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                proxy_headers=proxy.headers.raw,
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+            )
+        elif proxy.url.scheme == "socks5":
+            try:
+                import socksio  # noqa
+            except ImportError:  # pragma: nocover
+                raise ImportError(
+                    "Using SOCKS proxy, but the 'socksio' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[socks]`."
+                ) from None
+
+            self._pool = httpcore.SOCKSProxy(
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+            )
+        else:  # pragma: nocover
+            raise ValueError(
+                f"Proxy protocol must be either 'http', 'https', or 'socks5', but got {proxy.url.scheme!r}."
+            )
+
+    def __enter__(self: T) -> T:  # Use generics for subclass support.
+        self._pool.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]] = None,
+        exc_value: typing.Optional[BaseException] = None,
+        traceback: typing.Optional[TracebackType] = None,
+    ) -> None:
+        with map_httpcore_exceptions():
+            self._pool.__exit__(exc_type, exc_value, traceback)
+
+    def handle_request(
+        self,
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, SyncByteStream)
+
+        req = httpcore.Request(
+            method=request.method,
+            url=httpcore.URL(
+                scheme=request.url.raw_scheme,
+                host=request.url.raw_host,
+                port=request.url.port,
+                target=request.url.raw_path,
+            ),
+            headers=request.headers.raw,
+            content=request.stream,
+            extensions=request.extensions,
+        )
+        with map_httpcore_exceptions():
+            resp = self._pool.handle_request(req)
+
+        assert isinstance(resp.stream, typing.Iterable)
+
+        return Response(
+            status_code=resp.status,
+            headers=resp.headers,
+            stream=ResponseStream(resp.stream),
+            extensions=resp.extensions,
+        )
+
+    def close(self) -> None:
+        self._pool.close()
+
+
+class AsyncResponseStream(AsyncByteStream):
+    def __init__(self, httpcore_stream: typing.AsyncIterable[bytes]):
+        self._httpcore_stream = httpcore_stream
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        with map_httpcore_exceptions():
+            async for part in self._httpcore_stream:
+                yield part
+
+    async def aclose(self) -> None:
+        if hasattr(self._httpcore_stream, "aclose"):
+            await self._httpcore_stream.aclose()  # type: ignore
+
+
+class AsyncHTTPTransport(AsyncBaseTransport):
+    def __init__(
+        self,
+        verify: VerifyTypes = True,
+        cert: typing.Optional[CertTypes] = None,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        trust_env: bool = True,
+        proxy: typing.Optional[Proxy] = None,
+        uds: typing.Optional[str] = None,
+        local_address: typing.Optional[str] = None,
+        retries: int = 0,
+    ) -> None:
+        ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)
+
+        if proxy is None:
+            self._pool = httpcore.AsyncConnectionPool(
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                uds=uds,
+                local_address=local_address,
+                retries=retries,
+            )
+        elif proxy.url.scheme in ("http", "https"):
+            self._pool = httpcore.AsyncHTTPProxy(
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                proxy_headers=proxy.headers.raw,
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+            )
+        elif proxy.url.scheme == "socks5":
+            try:
+                import socksio  # noqa
+            except ImportError:  # pragma: nocover
+                raise ImportError(
+                    "Using SOCKS proxy, but the 'socksio' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[socks]`."
+                ) from None
+
+            self._pool = httpcore.AsyncSOCKSProxy(
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+            )
+        else:  # pragma: nocover
+            raise ValueError(
+                f"Proxy protocol must be either 'http', 'https', or 'socks5', but got {proxy.url.scheme!r}."
+            )
+
+    async def __aenter__(self: A) -> A:  # Use generics for subclass support.
+        await self._pool.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]] = None,
+        exc_value: typing.Optional[BaseException] = None,
+        traceback: typing.Optional[TracebackType] = None,
+    ) -> None:
+        with map_httpcore_exceptions():
+            await self._pool.__aexit__(exc_type, exc_value, traceback)
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, AsyncByteStream)
+
+        req = httpcore.Request(
+            method=request.method,
+            url=httpcore.URL(
+                scheme=request.url.raw_scheme,
+                host=request.url.raw_host,
+                port=request.url.port,
+                target=request.url.raw_path,
+            ),
+            headers=request.headers.raw,
+            content=request.stream,
+            extensions=request.extensions,
+        )
+        with map_httpcore_exceptions():
+            resp = await self._pool.handle_async_request(req)
+
+        assert isinstance(resp.stream, typing.AsyncIterable)
+
+        return Response(
+            status_code=resp.status,
+            headers=resp.headers,
+            stream=AsyncResponseStream(resp.stream),
+            extensions=resp.extensions,
+        )
+
+    async def aclose(self) -> None:
+        await self._pool.aclose()
diff --git a/myenv/lib/python3.9/site-packages/httpx/_transports/mock.py b/myenv/lib/python3.9/site-packages/httpx/_transports/mock.py
new file mode 100644
index 0000000..f61aee7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_transports/mock.py
@@ -0,0 +1,34 @@
+import asyncio
+import typing
+
+from .._models import Request, Response
+from .base import AsyncBaseTransport, BaseTransport
+
+
+class MockTransport(AsyncBaseTransport, BaseTransport):
+    def __init__(self, handler: typing.Callable) -> None:
+        self.handler = handler
+
+    def handle_request(
+        self,
+        request: Request,
+    ) -> Response:
+        request.read()
+        return self.handler(request)
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        await request.aread()
+        response = self.handler(request)
+
+        # Allow handler to *optionally* be an `async` function.
+        # If it is, then the `response` variable need to be awaited to actually
+        # return the result.
+
+        # https://simonwillison.net/2020/Sep/2/await-me-maybe/
+        if asyncio.iscoroutine(response):
+            response = await response
+
+        return response
diff --git a/myenv/lib/python3.9/site-packages/httpx/_transports/wsgi.py b/myenv/lib/python3.9/site-packages/httpx/_transports/wsgi.py
new file mode 100644
index 0000000..3dedf49
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_transports/wsgi.py
@@ -0,0 +1,134 @@
+import io
+import itertools
+import sys
+import typing
+
+from .._models import Request, Response
+from .._types import SyncByteStream
+from .base import BaseTransport
+
+
+def _skip_leading_empty_chunks(body: typing.Iterable) -> typing.Iterable:
+    body = iter(body)
+    for chunk in body:
+        if chunk:
+            return itertools.chain([chunk], body)
+    return []
+
+
+class WSGIByteStream(SyncByteStream):
+    def __init__(self, result: typing.Iterable[bytes]) -> None:
+        self._close = getattr(result, "close", None)
+        self._result = _skip_leading_empty_chunks(result)
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        for part in self._result:
+            yield part
+
+    def close(self) -> None:
+        if self._close is not None:
+            self._close()
+
+
+class WSGITransport(BaseTransport):
+    """
+    A custom transport that handles sending requests directly to an WSGI app.
+    The simplest way to use this functionality is to use the `app` argument.
+
+    ```
+    client = httpx.Client(app=app)
+    ```
+
+    Alternatively, you can setup the transport instance explicitly.
+    This allows you to include any additional configuration arguments specific
+    to the WSGITransport class:
+
+    ```
+    transport = httpx.WSGITransport(
+        app=app,
+        script_name="/submount",
+        remote_addr="1.2.3.4"
+    )
+    client = httpx.Client(transport=transport)
+    ```
+
+    Arguments:
+
+    * `app` - The ASGI application.
+    * `raise_app_exceptions` - Boolean indicating if exceptions in the application
+       should be raised. Default to `True`. Can be set to `False` for use cases
+       such as testing the content of a client 500 response.
+    * `script_name` - The root path on which the WSGI application should be mounted.
+    * `remote_addr` - A string indicating the client IP of incoming requests.
+    ```
+    """
+
+    def __init__(
+        self,
+        app: typing.Callable,
+        raise_app_exceptions: bool = True,
+        script_name: str = "",
+        remote_addr: str = "127.0.0.1",
+        wsgi_errors: typing.Optional[typing.TextIO] = None,
+    ) -> None:
+        self.app = app
+        self.raise_app_exceptions = raise_app_exceptions
+        self.script_name = script_name
+        self.remote_addr = remote_addr
+        self.wsgi_errors = wsgi_errors
+
+    def handle_request(self, request: Request) -> Response:
+        request.read()
+        wsgi_input = io.BytesIO(request.content)
+
+        port = request.url.port or {"http": 80, "https": 443}[request.url.scheme]
+        environ = {
+            "wsgi.version": (1, 0),
+            "wsgi.url_scheme": request.url.scheme,
+            "wsgi.input": wsgi_input,
+            "wsgi.errors": self.wsgi_errors or sys.stderr,
+            "wsgi.multithread": True,
+            "wsgi.multiprocess": False,
+            "wsgi.run_once": False,
+            "REQUEST_METHOD": request.method,
+            "SCRIPT_NAME": self.script_name,
+            "PATH_INFO": request.url.path,
+            "QUERY_STRING": request.url.query.decode("ascii"),
+            "SERVER_NAME": request.url.host,
+            "SERVER_PORT": str(port),
+            "REMOTE_ADDR": self.remote_addr,
+        }
+        for header_key, header_value in request.headers.raw:
+            key = header_key.decode("ascii").upper().replace("-", "_")
+            if key not in ("CONTENT_TYPE", "CONTENT_LENGTH"):
+                key = "HTTP_" + key
+            environ[key] = header_value.decode("ascii")
+
+        seen_status = None
+        seen_response_headers = None
+        seen_exc_info = None
+
+        def start_response(
+            status: str, response_headers: list, exc_info: typing.Any = None
+        ) -> None:
+            nonlocal seen_status, seen_response_headers, seen_exc_info
+            seen_status = status
+            seen_response_headers = response_headers
+            seen_exc_info = exc_info
+
+        result = self.app(environ, start_response)
+
+        stream = WSGIByteStream(result)
+
+        assert seen_status is not None
+        assert seen_response_headers is not None
+        if seen_exc_info and self.raise_app_exceptions:
+            raise seen_exc_info[1]
+
+        status_code = int(seen_status.split()[0])
+        headers = [
+            (key.encode("ascii"), value.encode("ascii"))
+            for key, value in seen_response_headers
+        ]
+
+        return Response(status_code, headers=headers, stream=stream)
diff --git a/myenv/lib/python3.9/site-packages/httpx/_types.py b/myenv/lib/python3.9/site-packages/httpx/_types.py
new file mode 100644
index 0000000..c4063fe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_types.py
@@ -0,0 +1,151 @@
+"""
+Type definitions for type checking purposes.
+"""
+
+import ssl
+from http.cookiejar import CookieJar
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    AsyncIterable,
+    AsyncIterator,
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from ._auth import Auth  # noqa: F401
+    from ._config import Proxy, Timeout  # noqa: F401
+    from ._models import Cookies, Headers, Request  # noqa: F401
+    from ._urls import URL, QueryParams  # noqa: F401
+
+
+PrimitiveData = Optional[Union[str, int, float, bool]]
+
+RawURL = Tuple[bytes, bytes, Optional[int], bytes]
+
+URLTypes = Union["URL", str]
+
+QueryParamTypes = Union[
+    "QueryParams",
+    Mapping[str, Union[PrimitiveData, Sequence[PrimitiveData]]],
+    List[Tuple[str, PrimitiveData]],
+    Tuple[Tuple[str, PrimitiveData], ...],
+    str,
+    bytes,
+]
+
+HeaderTypes = Union[
+    "Headers",
+    Dict[str, str],
+    Dict[bytes, bytes],
+    Sequence[Tuple[str, str]],
+    Sequence[Tuple[bytes, bytes]],
+]
+
+CookieTypes = Union["Cookies", CookieJar, Dict[str, str], List[Tuple[str, str]]]
+
+CertTypes = Union[
+    # certfile
+    str,
+    # (certfile, keyfile)
+    Tuple[str, Optional[str]],
+    # (certfile, keyfile, password)
+    Tuple[str, Optional[str], Optional[str]],
+]
+VerifyTypes = Union[str, bool, ssl.SSLContext]
+TimeoutTypes = Union[
+    Optional[float],
+    Tuple[Optional[float], Optional[float], Optional[float], Optional[float]],
+    "Timeout",
+]
+ProxiesTypes = Union[URLTypes, "Proxy", Dict[URLTypes, Union[None, URLTypes, "Proxy"]]]
+
+AuthTypes = Union[
+    Tuple[Union[str, bytes], Union[str, bytes]],
+    Callable[["Request"], "Request"],
+    "Auth",
+]
+
+RequestContent = Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
+ResponseContent = Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
+
+RequestData = dict
+
+FileContent = Union[IO[bytes], bytes]
+FileTypes = Union[
+    # file (or bytes)
+    FileContent,
+    # (filename, file (or bytes))
+    Tuple[Optional[str], FileContent],
+    # (filename, file (or bytes), content_type)
+    Tuple[Optional[str], FileContent, Optional[str]],
+    # (filename, file (or bytes), content_type, headers)
+    Tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
+]
+RequestFiles = Union[Mapping[str, FileTypes], Sequence[Tuple[str, FileTypes]]]
+
+
+class SyncByteStream:
+    def __iter__(self) -> Iterator[bytes]:
+        raise NotImplementedError(
+            "The '__iter__' method must be implemented."
+        )  # pragma: nocover
+        yield b""  # pragma: nocover
+
+    def close(self) -> None:
+        """
+        Subclasses can override this method to release any network resources
+        after a request/response cycle is complete.
+
+        Streaming cases should use a `try...finally` block to ensure that
+        the stream `close()` method is always called.
+
+        Example:
+
+            status_code, headers, stream, extensions = transport.handle_request(...)
+            try:
+                ...
+            finally:
+                stream.close()
+        """
+
+    def read(self) -> bytes:
+        """
+        Simple cases can use `.read()` as a convenience method for consuming
+        the entire stream and then closing it.
+
+        Example:
+
+            status_code, headers, stream, extensions = transport.handle_request(...)
+            body = stream.read()
+        """
+        try:
+            return b"".join([part for part in self])
+        finally:
+            self.close()
+
+
+class AsyncByteStream:
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        raise NotImplementedError(
+            "The '__aiter__' method must be implemented."
+        )  # pragma: nocover
+        yield b""  # pragma: nocover
+
+    async def aclose(self) -> None:
+        pass
+
+    async def aread(self) -> bytes:
+        try:
+            return b"".join([part async for part in self])
+        finally:
+            await self.aclose()
diff --git a/myenv/lib/python3.9/site-packages/httpx/_urls.py b/myenv/lib/python3.9/site-packages/httpx/_urls.py
new file mode 100644
index 0000000..8beeacf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_urls.py
@@ -0,0 +1,779 @@
+import typing
+from urllib.parse import parse_qs, quote, unquote, urlencode
+
+import idna
+import rfc3986
+import rfc3986.exceptions
+
+from ._exceptions import InvalidURL
+from ._types import PrimitiveData, QueryParamTypes, RawURL, URLTypes
+from ._utils import primitive_value_to_str
+
+
+class URL:
+    """
+    url = httpx.URL("HTTPS://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink")
+
+    assert url.scheme == "https"
+    assert url.username == "jo@email.com"
+    assert url.password == "a secret"
+    assert url.userinfo == b"jo%40email.com:a%20secret"
+    assert url.host == "müller.de"
+    assert url.raw_host == b"xn--mller-kva.de"
+    assert url.port == 1234
+    assert url.netloc == b"xn--mller-kva.de:1234"
+    assert url.path == "/pa th"
+    assert url.query == b"?search=ab"
+    assert url.raw_path == b"/pa%20th?search=ab"
+    assert url.fragment == "anchorlink"
+
+    The components of a URL are broken down like this:
+
+       https://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink
+    [scheme]   [  username  ] [password] [ host ][port][ path ] [ query ] [fragment]
+               [       userinfo        ] [   netloc   ][    raw_path    ]
+
+    Note that:
+
+    * `url.scheme` is normalized to always be lowercased.
+
+    * `url.host` is normalized to always be lowercased. Internationalized domain
+      names are represented in unicode, without IDNA encoding applied. For instance:
+
+      url = httpx.URL("http://中国.icom.museum")
+      assert url.host == "中国.icom.museum"
+      url = httpx.URL("http://xn--fiqs8s.icom.museum")
+      assert url.host == "中国.icom.museum"
+
+    * `url.raw_host` is normalized to always be lowercased, and is IDNA encoded.
+
+      url = httpx.URL("http://中国.icom.museum")
+      assert url.raw_host == b"xn--fiqs8s.icom.museum"
+      url = httpx.URL("http://xn--fiqs8s.icom.museum")
+      assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+    * `url.port` is either None or an integer. URLs that include the default port for
+      "http", "https", "ws", "wss", and "ftp" schemes have their port normalized to `None`.
+
+      assert httpx.URL("http://example.com") == httpx.URL("http://example.com:80")
+      assert httpx.URL("http://example.com").port is None
+      assert httpx.URL("http://example.com:80").port is None
+
+    * `url.userinfo` is raw bytes, without URL escaping. Usually you'll want to work with
+      `url.username` and `url.password` instead, which handle the URL escaping.
+
+    * `url.raw_path` is raw bytes of both the path and query, without URL escaping.
+      This portion is used as the target when constructing HTTP requests. Usually you'll
+      want to work with `url.path` instead.
+
+    * `url.query` is raw bytes, without URL escaping. A URL query string portion can only
+      be properly URL escaped when decoding the parameter names and values themselves.
+    """
+
+    def __init__(
+        self, url: typing.Union["URL", str, RawURL] = "", **kwargs: typing.Any
+    ) -> None:
+        if isinstance(url, (str, tuple)):
+            if isinstance(url, tuple):
+                raw_scheme, raw_host, port, raw_path = url
+                scheme = raw_scheme.decode("ascii")
+                host = raw_host.decode("ascii")
+                if host and ":" in host and host[0] != "[":
+                    # it's an IPv6 address, so it should be enclosed in "[" and "]"
+                    # ref: https://tools.ietf.org/html/rfc2732#section-2
+                    # ref: https://tools.ietf.org/html/rfc3986#section-3.2.2
+                    host = f"[{host}]"
+                port_str = "" if port is None else f":{port}"
+                path = raw_path.decode("ascii")
+                url = f"{scheme}://{host}{port_str}{path}"
+
+            try:
+                self._uri_reference = rfc3986.iri_reference(url).encode()
+            except rfc3986.exceptions.InvalidAuthority as exc:
+                raise InvalidURL(message=str(exc)) from None
+
+            if self.is_absolute_url:
+                # We don't want to normalize relative URLs, since doing so
+                # removes any leading `../` portion.
+                self._uri_reference = self._uri_reference.normalize()
+        elif isinstance(url, URL):
+            self._uri_reference = url._uri_reference
+        else:
+            raise TypeError(
+                f"Invalid type for url.  Expected str or httpx.URL, got {type(url)}: {url!r}"
+            )
+
+        # Perform port normalization, following the WHATWG spec for default ports.
+        #
+        # See:
+        # * https://tools.ietf.org/html/rfc3986#section-3.2.3
+        # * https://url.spec.whatwg.org/#url-miscellaneous
+        # * https://url.spec.whatwg.org/#scheme-state
+        default_port = {
+            "ftp": ":21",
+            "http": ":80",
+            "https": ":443",
+            "ws": ":80",
+            "wss": ":443",
+        }.get(self._uri_reference.scheme, "")
+        authority = self._uri_reference.authority or ""
+        if default_port and authority.endswith(default_port):
+            authority = authority[: -len(default_port)]
+            self._uri_reference = self._uri_reference.copy_with(authority=authority)
+
+        if kwargs:
+            self._uri_reference = self.copy_with(**kwargs)._uri_reference
+
+    @property
+    def scheme(self) -> str:
+        """
+        The URL scheme, such as "http", "https".
+        Always normalised to lowercase.
+        """
+        return self._uri_reference.scheme or ""
+
+    @property
+    def raw_scheme(self) -> bytes:
+        """
+        The raw bytes representation of the URL scheme, such as b"http", b"https".
+        Always normalised to lowercase.
+        """
+        return self.scheme.encode("ascii")
+
+    @property
+    def userinfo(self) -> bytes:
+        """
+        The URL userinfo as a raw bytestring.
+        For example: b"jo%40email.com:a%20secret".
+        """
+        userinfo = self._uri_reference.userinfo or ""
+        return userinfo.encode("ascii")
+
+    @property
+    def username(self) -> str:
+        """
+        The URL username as a string, with URL decoding applied.
+        For example: "jo@email.com"
+        """
+        userinfo = self._uri_reference.userinfo or ""
+        return unquote(userinfo.partition(":")[0])
+
+    @property
+    def password(self) -> str:
+        """
+        The URL password as a string, with URL decoding applied.
+        For example: "a secret"
+        """
+        userinfo = self._uri_reference.userinfo or ""
+        return unquote(userinfo.partition(":")[2])
+
+    @property
+    def host(self) -> str:
+        """
+        The URL host as a string.
+        Always normalized to lowercase, with IDNA hosts decoded into unicode.
+
+        Examples:
+
+        url = httpx.URL("http://www.EXAMPLE.org")
+        assert url.host == "www.example.org"
+
+        url = httpx.URL("http://中国.icom.museum")
+        assert url.host == "中国.icom.museum"
+
+        url = httpx.URL("http://xn--fiqs8s.icom.museum")
+        assert url.host == "中国.icom.museum"
+
+        url = httpx.URL("https://[::ffff:192.168.0.1]")
+        assert url.host == "::ffff:192.168.0.1"
+        """
+        host: str = self._uri_reference.host or ""
+
+        if host and ":" in host and host[0] == "[":
+            # it's an IPv6 address
+            host = host.lstrip("[").rstrip("]")
+
+        if host.startswith("xn--"):
+            host = idna.decode(host)
+
+        return host
+
+    @property
+    def raw_host(self) -> bytes:
+        """
+        The raw bytes representation of the URL host.
+        Always normalized to lowercase, and IDNA encoded.
+
+        Examples:
+
+        url = httpx.URL("http://www.EXAMPLE.org")
+        assert url.raw_host == b"www.example.org"
+
+        url = httpx.URL("http://中国.icom.museum")
+        assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+        url = httpx.URL("http://xn--fiqs8s.icom.museum")
+        assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+        url = httpx.URL("https://[::ffff:192.168.0.1]")
+        assert url.raw_host == b"::ffff:192.168.0.1"
+        """
+        host: str = self._uri_reference.host or ""
+
+        if host and ":" in host and host[0] == "[":
+            # it's an IPv6 address
+            host = host.lstrip("[").rstrip("]")
+
+        return host.encode("ascii")
+
+    @property
+    def port(self) -> typing.Optional[int]:
+        """
+        The URL port as an integer.
+
+        Note that the URL class performs port normalization as per the WHATWG spec.
+        Default ports for "http", "https", "ws", "wss", and "ftp" schemes are always
+        treated as `None`.
+
+        For example:
+
+        assert httpx.URL("http://www.example.com") == httpx.URL("http://www.example.com:80")
+        assert httpx.URL("http://www.example.com:80").port is None
+        """
+        port = self._uri_reference.port
+        return int(port) if port else None
+
+    @property
+    def netloc(self) -> bytes:
+        """
+        Either `<host>` or `<host>:<port>` as bytes.
+        Always normalized to lowercase, and IDNA encoded.
+
+        This property may be used for generating the value of a request
+        "Host" header.
+        """
+        host = self._uri_reference.host or ""
+        port = self._uri_reference.port
+        netloc = host.encode("ascii")
+        if port:
+            netloc = netloc + b":" + port.encode("ascii")
+        return netloc
+
+    @property
+    def path(self) -> str:
+        """
+        The URL path as a string. Excluding the query string, and URL decoded.
+
+        For example:
+
+        url = httpx.URL("https://example.com/pa%20th")
+        assert url.path == "/pa th"
+        """
+        path = self._uri_reference.path or "/"
+        return unquote(path)
+
+    @property
+    def query(self) -> bytes:
+        """
+        The URL query string, as raw bytes, excluding the leading b"?".
+
+        This is necessarily a bytewise interface, because we cannot
+        perform URL decoding of this representation until we've parsed
+        the keys and values into a QueryParams instance.
+
+        For example:
+
+        url = httpx.URL("https://example.com/?filter=some%20search%20terms")
+        assert url.query == b"filter=some%20search%20terms"
+        """
+        query = self._uri_reference.query or ""
+        return query.encode("ascii")
+
+    @property
+    def params(self) -> "QueryParams":
+        """
+        The URL query parameters, neatly parsed and packaged into an immutable
+        multidict representation.
+        """
+        return QueryParams(self._uri_reference.query)
+
+    @property
+    def raw_path(self) -> bytes:
+        """
+        The complete URL path and query string as raw bytes.
+        Used as the target when constructing HTTP requests.
+
+        For example:
+
+        GET /users?search=some%20text HTTP/1.1
+        Host: www.example.org
+        Connection: close
+        """
+        path = self._uri_reference.path or "/"
+        if self._uri_reference.query is not None:
+            path += "?" + self._uri_reference.query
+        return path.encode("ascii")
+
+    @property
+    def fragment(self) -> str:
+        """
+        The URL fragments, as used in HTML anchors.
+        As a string, without the leading '#'.
+        """
+        return unquote(self._uri_reference.fragment or "")
+
+    @property
+    def raw(self) -> RawURL:
+        """
+        The URL in the raw representation used by the low level
+        transport API. See `BaseTransport.handle_request`.
+
+        Provides the (scheme, host, port, target) for the outgoing request.
+        """
+        return (
+            self.raw_scheme,
+            self.raw_host,
+            self.port,
+            self.raw_path,
+        )
+
+    @property
+    def is_absolute_url(self) -> bool:
+        """
+        Return `True` for absolute URLs such as 'http://example.com/path',
+        and `False` for relative URLs such as '/path'.
+        """
+        # We don't use `.is_absolute` from `rfc3986` because it treats
+        # URLs with a fragment portion as not absolute.
+        # What we actually care about is if the URL provides
+        # a scheme and hostname to which connections should be made.
+        return bool(self._uri_reference.scheme and self._uri_reference.host)
+
+    @property
+    def is_relative_url(self) -> bool:
+        """
+        Return `False` for absolute URLs such as 'http://example.com/path',
+        and `True` for relative URLs such as '/path'.
+        """
+        return not self.is_absolute_url
+
+    def copy_with(self, **kwargs: typing.Any) -> "URL":
+        """
+        Copy this URL, returning a new URL with some components altered.
+        Accepts the same set of parameters as the components that are made
+        available via properties on the `URL` class.
+
+        For example:
+
+        url = httpx.URL("https://www.example.com").copy_with(username="jo@gmail.com", password="a secret")
+        assert url == "https://jo%40email.com:a%20secret@www.example.com"
+        """
+        allowed = {
+            "scheme": str,
+            "username": str,
+            "password": str,
+            "userinfo": bytes,
+            "host": str,
+            "port": int,
+            "netloc": bytes,
+            "path": str,
+            "query": bytes,
+            "raw_path": bytes,
+            "fragment": str,
+            "params": object,
+        }
+
+        # Step 1
+        # ======
+        #
+        # Perform type checking for all supported keyword arguments.
+        for key, value in kwargs.items():
+            if key not in allowed:
+                message = f"{key!r} is an invalid keyword argument for copy_with()"
+                raise TypeError(message)
+            if value is not None and not isinstance(value, allowed[key]):
+                expected = allowed[key].__name__
+                seen = type(value).__name__
+                message = f"Argument {key!r} must be {expected} but got {seen}"
+                raise TypeError(message)
+
+        # Step 2
+        # ======
+        #
+        # Consolidate "username", "password", "userinfo", "host", "port" and "netloc"
+        # into a single "authority" keyword, for `rfc3986`.
+        if "username" in kwargs or "password" in kwargs:
+            # Consolidate "username" and "password" into "userinfo".
+            username = quote(kwargs.pop("username", self.username) or "")
+            password = quote(kwargs.pop("password", self.password) or "")
+            userinfo = f"{username}:{password}" if password else username
+            kwargs["userinfo"] = userinfo.encode("ascii")
+
+        if "host" in kwargs or "port" in kwargs:
+            # Consolidate "host" and "port" into "netloc".
+            host = kwargs.pop("host", self.host) or ""
+            port = kwargs.pop("port", self.port)
+
+            if host and ":" in host and host[0] != "[":
+                # IPv6 addresses need to be escaped within square brackets.
+                host = f"[{host}]"
+
+            kwargs["netloc"] = (
+                f"{host}:{port}".encode("ascii")
+                if port is not None
+                else host.encode("ascii")
+            )
+
+        if "userinfo" in kwargs or "netloc" in kwargs:
+            # Consolidate "userinfo" and "netloc" into authority.
+            userinfo = (kwargs.pop("userinfo", self.userinfo) or b"").decode("ascii")
+            netloc = (kwargs.pop("netloc", self.netloc) or b"").decode("ascii")
+            authority = f"{userinfo}@{netloc}" if userinfo else netloc
+            kwargs["authority"] = authority
+
+        # Step 3
+        # ======
+        #
+        # Wrangle any "path", "query", "raw_path" and "params" keywords into
+        # "query" and "path" keywords for `rfc3986`.
+        if "raw_path" in kwargs:
+            # If "raw_path" is included, then split it into "path" and "query" components.
+            raw_path = kwargs.pop("raw_path") or b""
+            path, has_query, query = raw_path.decode("ascii").partition("?")
+            kwargs["path"] = path
+            kwargs["query"] = query if has_query else None
+
+        else:
+            if kwargs.get("path") is not None:
+                # Ensure `kwargs["path"] = <url quoted str>` for `rfc3986`.
+                kwargs["path"] = quote(kwargs["path"])
+
+            if kwargs.get("query") is not None:
+                # Ensure `kwargs["query"] = <str>` for `rfc3986`.
+                #
+                # Note that `.copy_with(query=None)` and `.copy_with(query=b"")`
+                # are subtly different. The `None` style will not include an empty
+                # trailing "?" character.
+                kwargs["query"] = kwargs["query"].decode("ascii")
+
+            if "params" in kwargs:
+                # Replace any "params" keyword with the raw "query" instead.
+                #
+                # Ensure that empty params use `kwargs["query"] = None` rather
+                # than `kwargs["query"] = ""`, so that generated URLs do not
+                # include an empty trailing "?".
+                params = kwargs.pop("params")
+                kwargs["query"] = None if not params else str(QueryParams(params))
+
+        # Step 4
+        # ======
+        #
+        # Ensure any fragment component is quoted.
+        if kwargs.get("fragment") is not None:
+            kwargs["fragment"] = quote(kwargs["fragment"])
+
+        # Step 5
+        # ======
+        #
+        # At this point kwargs may include keys for "scheme", "authority", "path",
+        # "query" and "fragment". Together these constitute the entire URL.
+        #
+        # See https://tools.ietf.org/html/rfc3986#section-3
+        #
+        #  foo://example.com:8042/over/there?name=ferret#nose
+        #  \_/   \______________/\_________/ \_________/ \__/
+        #   |           |            |            |        |
+        # scheme     authority       path        query   fragment
+        new_url = URL(self)
+        new_url._uri_reference = self._uri_reference.copy_with(**kwargs)
+        if new_url.is_absolute_url:
+            new_url._uri_reference = new_url._uri_reference.normalize()
+        return URL(new_url)
+
+    def copy_set_param(self, key: str, value: typing.Any = None) -> "URL":
+        return self.copy_with(params=self.params.set(key, value))
+
+    def copy_add_param(self, key: str, value: typing.Any = None) -> "URL":
+        return self.copy_with(params=self.params.add(key, value))
+
+    def copy_remove_param(self, key: str) -> "URL":
+        return self.copy_with(params=self.params.remove(key))
+
+    def copy_merge_params(self, params: QueryParamTypes) -> "URL":
+        return self.copy_with(params=self.params.merge(params))
+
+    def join(self, url: URLTypes) -> "URL":
+        """
+        Return an absolute URL, using this URL as the base.
+
+        Eg.
+
+        url = httpx.URL("https://www.example.com/test")
+        url = url.join("/new/path")
+        assert url == "https://www.example.com/new/path"
+        """
+        if self.is_relative_url:
+            # Workaround to handle relative URLs, which otherwise raise
+            # rfc3986.exceptions.ResolutionError when used as an argument
+            # in `.resolve_with`.
+            return (
+                self.copy_with(scheme="http", host="example.com")
+                .join(url)
+                .copy_with(scheme=None, host=None)
+            )
+
+        # We drop any fragment portion, because RFC 3986 strictly
+        # treats URLs with a fragment portion as not being absolute URLs.
+        base_uri = self._uri_reference.copy_with(fragment=None)
+        relative_url = URL(url)
+        return URL(relative_url._uri_reference.resolve_with(base_uri).unsplit())
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, (URL, str)) and str(self) == str(URL(other))
+
+    def __str__(self) -> str:
+        return self._uri_reference.unsplit()
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        url_str = str(self)
+        if self._uri_reference.userinfo:
+            # Mask any password component in the URL representation, to lower the
+            # risk of unintended leakage, such as in debug information and logging.
+            username = quote(self.username)
+            url_str = (
+                rfc3986.urlparse(url_str)
+                .copy_with(userinfo=f"{username}:[secure]")
+                .unsplit()
+            )
+        return f"{class_name}({url_str!r})"
+
+
+class QueryParams(typing.Mapping[str, str]):
+    """
+    URL query parameters, as a multi-dict.
+    """
+
+    def __init__(
+        self, *args: typing.Optional[QueryParamTypes], **kwargs: typing.Any
+    ) -> None:
+        assert len(args) < 2, "Too many arguments."
+        assert not (args and kwargs), "Cannot mix named and unnamed arguments."
+
+        value = args[0] if args else kwargs
+
+        items: typing.Sequence[typing.Tuple[str, PrimitiveData]]
+        if value is None or isinstance(value, (str, bytes)):
+            value = value.decode("ascii") if isinstance(value, bytes) else value
+            self._dict = parse_qs(value)
+        elif isinstance(value, QueryParams):
+            self._dict = {k: list(v) for k, v in value._dict.items()}
+        else:
+            dict_value: typing.Dict[typing.Any, typing.List[typing.Any]] = {}
+            if isinstance(value, (list, tuple)):
+                # Convert list inputs like:
+                #     [("a", "123"), ("a", "456"), ("b", "789")]
+                # To a dict representation, like:
+                #     {"a": ["123", "456"], "b": ["789"]}
+                for item in value:
+                    dict_value.setdefault(item[0], []).append(item[1])
+            else:
+                # Convert dict inputs like:
+                #    {"a": "123", "b": ["456", "789"]}
+                # To dict inputs where values are always lists, like:
+                #    {"a": ["123"], "b": ["456", "789"]}
+                dict_value = {
+                    k: list(v) if isinstance(v, (list, tuple)) else [v]
+                    for k, v in value.items()
+                }
+
+            # Ensure that keys and values are neatly coerced to strings.
+            # We coerce values `True` and `False` to JSON-like "true" and "false"
+            # representations, and coerce `None` values to the empty string.
+            self._dict = {
+                str(k): [primitive_value_to_str(item) for item in v]
+                for k, v in dict_value.items()
+            }
+
+    def keys(self) -> typing.KeysView:
+        """
+        Return all the keys in the query params.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.keys()) == ["a", "b"]
+        """
+        return self._dict.keys()
+
+    def values(self) -> typing.ValuesView:
+        """
+        Return all the values in the query params. If a key occurs more than once
+        only the first item for that key is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.values()) == ["123", "789"]
+        """
+        return {k: v[0] for k, v in self._dict.items()}.values()
+
+    def items(self) -> typing.ItemsView:
+        """
+        Return all items in the query params. If a key occurs more than once
+        only the first item for that key is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.items()) == [("a", "123"), ("b", "789")]
+        """
+        return {k: v[0] for k, v in self._dict.items()}.items()
+
+    def multi_items(self) -> typing.List[typing.Tuple[str, str]]:
+        """
+        Return all items in the query params. Allow duplicate keys to occur.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.multi_items()) == [("a", "123"), ("a", "456"), ("b", "789")]
+        """
+        multi_items: typing.List[typing.Tuple[str, str]] = []
+        for k, v in self._dict.items():
+            multi_items.extend([(k, i) for i in v])
+        return multi_items
+
+    def get(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
+        """
+        Get a value from the query param for a given key. If the key occurs
+        more than once, then only the first value is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert q.get("a") == "123"
+        """
+        if key in self._dict:
+            return self._dict[str(key)][0]
+        return default
+
+    def get_list(self, key: str) -> typing.List[str]:
+        """
+        Get all values from the query param for a given key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert q.get_list("a") == ["123", "456"]
+        """
+        return list(self._dict.get(str(key), []))
+
+    def set(self, key: str, value: typing.Any = None) -> "QueryParams":
+        """
+        Return a new QueryParams instance, setting the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.set("a", "456")
+        assert q == httpx.QueryParams("a=456")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict[str(key)] = [primitive_value_to_str(value)]
+        return q
+
+    def add(self, key: str, value: typing.Any = None) -> "QueryParams":
+        """
+        Return a new QueryParams instance, setting or appending the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.add("a", "456")
+        assert q == httpx.QueryParams("a=123&a=456")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict[str(key)] = q.get_list(key) + [primitive_value_to_str(value)]
+        return q
+
+    def remove(self, key: str) -> "QueryParams":
+        """
+        Return a new QueryParams instance, removing the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.remove("a")
+        assert q == httpx.QueryParams("")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict.pop(str(key), None)
+        return q
+
+    def merge(self, params: typing.Optional[QueryParamTypes] = None) -> "QueryParams":
+        """
+        Return a new QueryParams instance, updated with.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.merge({"b": "456"})
+        assert q == httpx.QueryParams("a=123&b=456")
+
+        q = httpx.QueryParams("a=123")
+        q = q.merge({"a": "456", "b": "789"})
+        assert q == httpx.QueryParams("a=456&b=789")
+        """
+        q = QueryParams(params)
+        q._dict = {**self._dict, **q._dict}
+        return q
+
+    def __getitem__(self, key: typing.Any) -> str:
+        return self._dict[key][0]
+
+    def __contains__(self, key: typing.Any) -> bool:
+        return key in self._dict
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    def __bool__(self) -> bool:
+        return bool(self._dict)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return sorted(self.multi_items()) == sorted(other.multi_items())
+
+    def __str__(self) -> str:
+        return urlencode(self.multi_items())
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        query_string = str(self)
+        return f"{class_name}({query_string!r})"
+
+    def update(self, params: typing.Optional[QueryParamTypes] = None) -> None:
+        raise RuntimeError(
+            "QueryParams are immutable since 0.18.0. "
+            "Use `q = q.merge(...)` to create an updated copy."
+        )
+
+    def __setitem__(self, key: str, value: str) -> None:
+        raise RuntimeError(
+            "QueryParams are immutable since 0.18.0. "
+            "Use `q = q.set(key, value)` to create an updated copy."
+        )
diff --git a/myenv/lib/python3.9/site-packages/httpx/_utils.py b/myenv/lib/python3.9/site-packages/httpx/_utils.py
new file mode 100644
index 0000000..e01c050
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/httpx/_utils.py
@@ -0,0 +1,522 @@
+import codecs
+import logging
+import mimetypes
+import netrc
+import os
+import re
+import sys
+import time
+import typing
+from pathlib import Path
+from urllib.request import getproxies
+
+import sniffio
+
+from ._types import PrimitiveData
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    from ._models import URL
+
+
+_HTML5_FORM_ENCODING_REPLACEMENTS = {'"': "%22", "\\": "\\\\"}
+_HTML5_FORM_ENCODING_REPLACEMENTS.update(
+    {chr(c): "%{:02X}".format(c) for c in range(0x1F + 1) if c != 0x1B}
+)
+_HTML5_FORM_ENCODING_RE = re.compile(
+    r"|".join([re.escape(c) for c in _HTML5_FORM_ENCODING_REPLACEMENTS.keys()])
+)
+
+
+def normalize_header_key(
+    value: typing.Union[str, bytes],
+    lower: bool,
+    encoding: typing.Optional[str] = None,
+) -> bytes:
+    """
+    Coerce str/bytes into a strictly byte-wise HTTP header key.
+    """
+    if isinstance(value, bytes):
+        bytes_value = value
+    else:
+        bytes_value = value.encode(encoding or "ascii")
+
+    return bytes_value.lower() if lower else bytes_value
+
+
+def normalize_header_value(
+    value: typing.Union[str, bytes], encoding: typing.Optional[str] = None
+) -> bytes:
+    """
+    Coerce str/bytes into a strictly byte-wise HTTP header value.
+    """
+    if isinstance(value, bytes):
+        return value
+    return value.encode(encoding or "ascii")
+
+
+def primitive_value_to_str(value: "PrimitiveData") -> str:
+    """
+    Coerce a primitive data type into a string value.
+
+    Note that we prefer JSON-style 'true'/'false' for boolean values here.
+    """
+    if value is True:
+        return "true"
+    elif value is False:
+        return "false"
+    elif value is None:
+        return ""
+    return str(value)
+
+
+def is_known_encoding(encoding: str) -> bool:
+    """
+    Return `True` if `encoding` is a known codec.
+    """
+    try:
+        codecs.lookup(encoding)
+    except LookupError:
+        return False
+    return True
+
+
+def format_form_param(name: str, value: typing.Union[str, bytes]) -> bytes:
+    """
+    Encode a name/value pair within a multipart form.
+    """
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    def replacer(match: typing.Match[str]) -> str:
+        return _HTML5_FORM_ENCODING_REPLACEMENTS[match.group(0)]
+
+    value = _HTML5_FORM_ENCODING_RE.sub(replacer, value)
+    return f'{name}="{value}"'.encode()
+
+
+# Null bytes; no need to recreate these on each call to guess_json_utf
+_null = b"\x00"
+_null2 = _null * 2
+_null3 = _null * 3
+
+
+def guess_json_utf(data: bytes) -> typing.Optional[str]:
+    # JSON always starts with two ASCII characters, so detection is as
+    # easy as counting the nulls and from their location and count
+    # determine the encoding. Also detect a BOM, if present.
+    sample = data[:4]
+    if sample in (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE):
+        return "utf-32"  # BOM included
+    if sample[:3] == codecs.BOM_UTF8:
+        return "utf-8-sig"  # BOM included, MS style (discouraged)
+    if sample[:2] in (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE):
+        return "utf-16"  # BOM included
+    nullcount = sample.count(_null)
+    if nullcount == 0:
+        return "utf-8"
+    if nullcount == 2:
+        if sample[::2] == _null2:  # 1st and 3rd are null
+            return "utf-16-be"
+        if sample[1::2] == _null2:  # 2nd and 4th are null
+            return "utf-16-le"
+        # Did not detect 2 valid UTF-16 ascii-range characters
+    if nullcount == 3:
+        if sample[:3] == _null3:
+            return "utf-32-be"
+        if sample[1:] == _null3:
+            return "utf-32-le"
+        # Did not detect a valid UTF-32 ascii-range character
+    return None
+
+
+class NetRCInfo:
+    def __init__(self, files: typing.Optional[typing.List[str]] = None) -> None:
+        if files is None:
+            files = [os.getenv("NETRC", ""), "~/.netrc", "~/_netrc"]
+        self.netrc_files = files
+
+    @property
+    def netrc_info(self) -> typing.Optional[netrc.netrc]:
+        if not hasattr(self, "_netrc_info"):
+            self._netrc_info = None
+            for file_path in self.netrc_files:
+                expanded_path = Path(file_path).expanduser()
+                try:
+                    if expanded_path.is_file():
+                        self._netrc_info = netrc.netrc(str(expanded_path))
+                        break
+                except (netrc.NetrcParseError, IOError):  # pragma: nocover
+                    # Issue while reading the netrc file, ignore...
+                    pass
+        return self._netrc_info
+
+    def get_credentials(self, host: str) -> typing.Optional[typing.Tuple[str, str]]:
+        if self.netrc_info is None:
+            return None
+
+        auth_info = self.netrc_info.authenticators(host)
+        if auth_info is None or auth_info[2] is None:
+            return None
+        return (auth_info[0], auth_info[2])
+
+
+def get_ca_bundle_from_env() -> typing.Optional[str]:
+    if "SSL_CERT_FILE" in os.environ:
+        ssl_file = Path(os.environ["SSL_CERT_FILE"])
+        if ssl_file.is_file():
+            return str(ssl_file)
+    if "SSL_CERT_DIR" in os.environ:
+        ssl_path = Path(os.environ["SSL_CERT_DIR"])
+        if ssl_path.is_dir():
+            return str(ssl_path)
+    return None
+
+
+def parse_header_links(value: str) -> typing.List[typing.Dict[str, str]]:
+    """
+    Returns a list of parsed link headers, for more info see:
+    https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link
+    The generic syntax of those is:
+    Link: < uri-reference >; param1=value1; param2="value2"
+    So for instance:
+    Link; '<http:/.../front.jpeg>; type="image/jpeg",<http://.../back.jpeg>;'
+    would return
+        [
+            {"url": "http:/.../front.jpeg", "type": "image/jpeg"},
+            {"url": "http://.../back.jpeg"},
+        ]
+    :param value: HTTP Link entity-header field
+    :return: list of parsed link headers
+    """
+    links: typing.List[typing.Dict[str, str]] = []
+    replace_chars = " '\""
+    value = value.strip(replace_chars)
+    if not value:
+        return links
+    for val in re.split(", *<", value):
+        try:
+            url, params = val.split(";", 1)
+        except ValueError:
+            url, params = val, ""
+        link = {"url": url.strip("<> '\"")}
+        for param in params.split(";"):
+            try:
+                key, value = param.split("=")
+            except ValueError:
+                break
+            link[key.strip(replace_chars)] = value.strip(replace_chars)
+        links.append(link)
+    return links
+
+
+SENSITIVE_HEADERS = {"authorization", "proxy-authorization"}
+
+
+def obfuscate_sensitive_headers(
+    items: typing.Iterable[typing.Tuple[typing.AnyStr, typing.AnyStr]]
+) -> typing.Iterator[typing.Tuple[typing.AnyStr, typing.AnyStr]]:
+    for k, v in items:
+        if to_str(k.lower()) in SENSITIVE_HEADERS:
+            v = to_bytes_or_str("[secure]", match_type_of=v)
+        yield k, v
+
+
+_LOGGER_INITIALIZED = False
+TRACE_LOG_LEVEL = 5
+
+
+class Logger(logging.Logger):
+    # Stub for type checkers.
+    def trace(self, message: str, *args: typing.Any, **kwargs: typing.Any) -> None:
+        ...  # pragma: nocover
+
+
+def get_logger(name: str) -> Logger:
+    """
+    Get a `logging.Logger` instance, and optionally
+    set up debug logging based on the HTTPX_LOG_LEVEL environment variable.
+    """
+    global _LOGGER_INITIALIZED
+
+    if not _LOGGER_INITIALIZED:
+        _LOGGER_INITIALIZED = True
+        logging.addLevelName(TRACE_LOG_LEVEL, "TRACE")
+
+        log_level = os.environ.get("HTTPX_LOG_LEVEL", "").upper()
+        if log_level in ("DEBUG", "TRACE"):
+            logger = logging.getLogger("httpx")
+            logger.setLevel(logging.DEBUG if log_level == "DEBUG" else TRACE_LOG_LEVEL)
+            handler = logging.StreamHandler(sys.stderr)
+            handler.setFormatter(
+                logging.Formatter(
+                    fmt="%(levelname)s [%(asctime)s] %(name)s - %(message)s",
+                    datefmt="%Y-%m-%d %H:%M:%S",
+                )
+            )
+            logger.addHandler(handler)
+
+    logger = logging.getLogger(name)
+
+    def trace(message: str, *args: typing.Any, **kwargs: typing.Any) -> None:
+        logger.log(TRACE_LOG_LEVEL, message, *args, **kwargs)
+
+    logger.trace = trace  # type: ignore
+
+    return typing.cast(Logger, logger)
+
+
+def port_or_default(url: "URL") -> typing.Optional[int]:
+    if url.port is not None:
+        return url.port
+    return {"http": 80, "https": 443}.get(url.scheme)
+
+
+def same_origin(url: "URL", other: "URL") -> bool:
+    """
+    Return 'True' if the given URLs share the same origin.
+    """
+    return (
+        url.scheme == other.scheme
+        and url.host == other.host
+        and port_or_default(url) == port_or_default(other)
+    )
+
+
+def is_https_redirect(url: "URL", location: "URL") -> bool:
+    """
+    Return 'True' if 'location' is a HTTPS upgrade of 'url'
+    """
+    if url.host != location.host:
+        return False
+
+    return (
+        url.scheme == "http"
+        and port_or_default(url) == 80
+        and location.scheme == "https"
+        and port_or_default(location) == 443
+    )
+
+
+def get_environment_proxies() -> typing.Dict[str, typing.Optional[str]]:
+    """Gets proxy information from the environment"""
+
+    # urllib.request.getproxies() falls back on System
+    # Registry and Config for proxies on Windows and macOS.
+    # We don't want to propagate non-HTTP proxies into
+    # our configuration such as 'TRAVIS_APT_PROXY'.
+    proxy_info = getproxies()
+    mounts: typing.Dict[str, typing.Optional[str]] = {}
+
+    for scheme in ("http", "https", "all"):
+        if proxy_info.get(scheme):
+            hostname = proxy_info[scheme]
+            mounts[f"{scheme}://"] = (
+                hostname if "://" in hostname else f"http://{hostname}"
+            )
+
+    no_proxy_hosts = [host.strip() for host in proxy_info.get("no", "").split(",")]
+    for hostname in no_proxy_hosts:
+        # See https://curl.haxx.se/libcurl/c/CURLOPT_NOPROXY.html for details
+        # on how names in `NO_PROXY` are handled.
+        if hostname == "*":
+            # If NO_PROXY=* is used or if "*" occurs as any one of the comma
+            # separated hostnames, then we should just bypass any information
+            # from HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, and always ignore
+            # proxies.
+            return {}
+        elif hostname:
+            # NO_PROXY=.google.com is marked as "all://*.google.com,
+            #   which disables "www.google.com" but not "google.com"
+            # NO_PROXY=google.com is marked as "all://*google.com,
+            #   which disables "www.google.com" and "google.com".
+            #   (But not "wwwgoogle.com")
+            mounts[f"all://*{hostname}"] = None
+
+    return mounts
+
+
+def to_bytes(value: typing.Union[str, bytes], encoding: str = "utf-8") -> bytes:
+    return value.encode(encoding) if isinstance(value, str) else value
+
+
+def to_str(value: typing.Union[str, bytes], encoding: str = "utf-8") -> str:
+    return value if isinstance(value, str) else value.decode(encoding)
+
+
+def to_bytes_or_str(value: str, match_type_of: typing.AnyStr) -> typing.AnyStr:
+    return value if isinstance(match_type_of, str) else value.encode()
+
+
+def unquote(value: str) -> str:
+    return value[1:-1] if value[0] == value[-1] == '"' else value
+
+
+def guess_content_type(filename: typing.Optional[str]) -> typing.Optional[str]:
+    if filename:
+        return mimetypes.guess_type(filename)[0] or "application/octet-stream"
+    return None
+
+
+def peek_filelike_length(stream: typing.Any) -> typing.Optional[int]:
+    """
+    Given a file-like stream object, return its length in number of bytes
+    without reading it into memory.
+    """
+    try:
+        # Is it an actual file?
+        fd = stream.fileno()
+        # Yup, seems to be an actual file.
+        length = os.fstat(fd).st_size
+    except (AttributeError, OSError):
+        # No... Maybe it's something that supports random access, like `io.BytesIO`?
+        try:
+            # Assuming so, go to end of stream to figure out its length,
+            # then put it back in place.
+            offset = stream.tell()
+            length = stream.seek(0, os.SEEK_END)
+            stream.seek(offset)
+        except (AttributeError, OSError):
+            # Not even that? Sorry, we're doomed...
+            return None
+
+    return length
+
+
+class Timer:
+    async def _get_time(self) -> float:
+        library = sniffio.current_async_library()
+        if library == "trio":
+            import trio
+
+            return trio.current_time()
+        elif library == "curio":  # pragma: nocover
+            import curio
+
+            return await curio.clock()
+
+        import asyncio
+
+        return asyncio.get_event_loop().time()
+
+    def sync_start(self) -> None:
+        self.started = time.perf_counter()
+
+    async def async_start(self) -> None:
+        self.started = await self._get_time()
+
+    def sync_elapsed(self) -> float:
+        now = time.perf_counter()
+        return now - self.started
+
+    async def async_elapsed(self) -> float:
+        now = await self._get_time()
+        return now - self.started
+
+
+class URLPattern:
+    """
+    A utility class currently used for making lookups against proxy keys...
+
+    # Wildcard matching...
+    >>> pattern = URLPattern("all")
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    True
+
+    # Witch scheme matching...
+    >>> pattern = URLPattern("https")
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    False
+
+    # With domain matching...
+    >>> pattern = URLPattern("https://example.com")
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    False
+    >>> pattern.matches(httpx.URL("https://other.com"))
+    False
+
+    # Wildcard scheme, with domain matching...
+    >>> pattern = URLPattern("all://example.com")
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("https://other.com"))
+    False
+
+    # With port matching...
+    >>> pattern = URLPattern("https://example.com:1234")
+    >>> pattern.matches(httpx.URL("https://example.com:1234"))
+    True
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    False
+    """
+
+    def __init__(self, pattern: str) -> None:
+        from ._models import URL
+
+        if pattern and ":" not in pattern:
+            raise ValueError(
+                f"Proxy keys should use proper URL forms rather "
+                f"than plain scheme strings. "
+                f'Instead of "{pattern}", use "{pattern}://"'
+            )
+
+        url = URL(pattern)
+        self.pattern = pattern
+        self.scheme = "" if url.scheme == "all" else url.scheme
+        self.host = "" if url.host == "*" else url.host
+        self.port = url.port
+        if not url.host or url.host == "*":
+            self.host_regex: typing.Optional[typing.Pattern[str]] = None
+        elif url.host.startswith("*."):
+            # *.example.com should match "www.example.com", but not "example.com"
+            domain = re.escape(url.host[2:])
+            self.host_regex = re.compile(f"^.+\\.{domain}$")
+        elif url.host.startswith("*"):
+            # *example.com should match "www.example.com" and "example.com"
+            domain = re.escape(url.host[1:])
+            self.host_regex = re.compile(f"^(.+\\.)?{domain}$")
+        else:
+            # example.com should match "example.com" but not "www.example.com"
+            domain = re.escape(url.host)
+            self.host_regex = re.compile(f"^{domain}$")
+
+    def matches(self, other: "URL") -> bool:
+        if self.scheme and self.scheme != other.scheme:
+            return False
+        if (
+            self.host
+            and self.host_regex is not None
+            and not self.host_regex.match(other.host)
+        ):
+            return False
+        if self.port is not None and self.port != other.port:
+            return False
+        return True
+
+    @property
+    def priority(self) -> tuple:
+        """
+        The priority allows URLPattern instances to be sortable, so that
+        we can match from most specific to least specific.
+        """
+        # URLs with a port should take priority over URLs without a port.
+        port_priority = 0 if self.port is not None else 1
+        # Longer hostnames should match first.
+        host_priority = -len(self.host)
+        # Longer schemes should match first.
+        scheme_priority = -len(self.scheme)
+        return (port_priority, host_priority, scheme_priority)
+
+    def __hash__(self) -> int:
+        return hash(self.pattern)
+
+    def __lt__(self, other: "URLPattern") -> bool:
+        return self.priority < other.priority
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, URLPattern) and self.pattern == other.pattern
diff --git a/myenv/lib/python3.9/site-packages/httpx/py.typed b/myenv/lib/python3.9/site-packages/httpx/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/LICENSE.md b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/LICENSE.md
new file mode 100644
index 0000000..b6f8732
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/LICENSE.md
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2013-2021, Kim Davies
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/METADATA b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/METADATA
new file mode 100644
index 0000000..6446805
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/METADATA
@@ -0,0 +1,236 @@
+Metadata-Version: 2.1
+Name: idna
+Version: 3.3
+Summary: Internationalized Domain Names in Applications (IDNA)
+Home-page: https://github.com/kjd/idna
+Author: Kim Davies
+Author-email: kim@cynosure.com.au
+License: BSD-3-Clause
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: Name Service (DNS)
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.5
+License-File: LICENSE.md
+
+Internationalized Domain Names in Applications (IDNA)
+=====================================================
+
+Support for the Internationalised Domain Names in Applications
+(IDNA) protocol as specified in `RFC 5891 <https://tools.ietf.org/html/rfc5891>`_.
+This is the latest version of the protocol and is sometimes referred to as
+“IDNA 2008”.
+
+This library also provides support for Unicode Technical Standard 46,
+`Unicode IDNA Compatibility Processing <https://unicode.org/reports/tr46/>`_.
+
+This acts as a suitable replacement for the “encodings.idna” module that
+comes with the Python standard library, but which only supports the
+older superseded IDNA specification (`RFC 3490 <https://tools.ietf.org/html/rfc3490>`_).
+
+Basic functions are simply executed:
+
+.. code-block:: pycon
+
+    >>> import idna
+    >>> idna.encode('ドメイン.テスト')
+    b'xn--eckwd4c7c.xn--zckzah'
+    >>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
+    ドメイン.テスト
+
+
+Installation
+------------
+
+To install this library, you can use pip:
+
+.. code-block:: bash
+
+    $ pip install idna
+
+Alternatively, you can install the package using the bundled setup script:
+
+.. code-block:: bash
+
+    $ python setup.py install
+
+
+Usage
+-----
+
+For typical usage, the ``encode`` and ``decode`` functions will take a domain
+name argument and perform a conversion to A-labels or U-labels respectively.
+
+.. code-block:: pycon
+
+    >>> import idna
+    >>> idna.encode('ドメイン.テスト')
+    b'xn--eckwd4c7c.xn--zckzah'
+    >>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
+    ドメイン.テスト
+
+You may use the codec encoding and decoding methods using the
+``idna.codec`` module:
+
+.. code-block:: pycon
+
+    >>> import idna.codec
+    >>> print('домен.испытание'.encode('idna'))
+    b'xn--d1acufc.xn--80akhbyknj4f'
+    >>> print(b'xn--d1acufc.xn--80akhbyknj4f'.decode('idna'))
+    домен.испытание
+
+Conversions can be applied at a per-label basis using the ``ulabel`` or ``alabel``
+functions if necessary:
+
+.. code-block:: pycon
+
+    >>> idna.alabel('测试')
+    b'xn--0zwm56d'
+
+Compatibility Mapping (UTS #46)
++++++++++++++++++++++++++++++++
+
+As described in `RFC 5895 <https://tools.ietf.org/html/rfc5895>`_, the IDNA
+specification does not normalize input from different potential ways a user
+may input a domain name. This functionality, known as a “mapping”, is 
+considered by the specification to be a local user-interface issue distinct
+from IDNA conversion functionality.
+
+This library provides one such mapping, that was developed by the Unicode
+Consortium. Known as `Unicode IDNA Compatibility Processing <https://unicode.org/reports/tr46/>`_,
+it provides for both a regular mapping for typical applications, as well as
+a transitional mapping to help migrate from older IDNA 2003 applications.
+
+For example, “Königsgäßchen” is not a permissible label as *LATIN CAPITAL
+LETTER K* is not allowed (nor are capital letters in general). UTS 46 will
+convert this into lower case prior to applying the IDNA conversion.
+
+.. code-block:: pycon
+
+    >>> import idna
+    >>> idna.encode('Königsgäßchen')
+    ...
+    idna.core.InvalidCodepoint: Codepoint U+004B at position 1 of 'Königsgäßchen' not allowed
+    >>> idna.encode('Königsgäßchen', uts46=True)
+    b'xn--knigsgchen-b4a3dun'
+    >>> print(idna.decode('xn--knigsgchen-b4a3dun'))
+    königsgäßchen
+
+Transitional processing provides conversions to help transition from the older
+2003 standard to the current standard. For example, in the original IDNA
+specification, the *LATIN SMALL LETTER SHARP S* (ß) was converted into two
+*LATIN SMALL LETTER S* (ss), whereas in the current IDNA specification this
+conversion is not performed.
+
+.. code-block:: pycon
+
+    >>> idna.encode('Königsgäßchen', uts46=True, transitional=True)
+    'xn--knigsgsschen-lcb0w'
+
+Implementors should use transitional processing with caution, only in rare
+cases where conversion from legacy labels to current labels must be performed
+(i.e. IDNA implementations that pre-date 2008). For typical applications
+that just need to convert labels, transitional processing is unlikely to be
+beneficial and could produce unexpected incompatible results.
+
+``encodings.idna`` Compatibility
+++++++++++++++++++++++++++++++++
+
+Function calls from the Python built-in ``encodings.idna`` module are
+mapped to their IDNA 2008 equivalents using the ``idna.compat`` module.
+Simply substitute the ``import`` clause in your code to refer to the
+new module name.
+
+Exceptions
+----------
+
+All errors raised during the conversion following the specification should
+raise an exception derived from the ``idna.IDNAError`` base class.
+
+More specific exceptions that may be generated as ``idna.IDNABidiError``
+when the error reflects an illegal combination of left-to-right and
+right-to-left characters in a label; ``idna.InvalidCodepoint`` when
+a specific codepoint is an illegal character in an IDN label (i.e.
+INVALID); and ``idna.InvalidCodepointContext`` when the codepoint is
+illegal based on its positional context (i.e. it is CONTEXTO or CONTEXTJ
+but the contextual requirements are not satisfied.)
+
+Building and Diagnostics
+------------------------
+
+The IDNA and UTS 46 functionality relies upon pre-calculated lookup
+tables for performance. These tables are derived from computing against
+eligibility criteria in the respective standards. These tables are
+computed using the command-line script ``tools/idna-data``.
+
+This tool will fetch relevant codepoint data from the Unicode repository 
+and perform the required calculations to identify eligibility. There are 
+three main modes:
+
+* ``idna-data make-libdata``. Generates ``idnadata.py`` and ``uts46data.py``,
+  the pre-calculated lookup tables using for IDNA and UTS 46 conversions. Implementors
+  who wish to track this library against a different Unicode version may use this tool
+  to manually generate a different version of the ``idnadata.py`` and ``uts46data.py``
+  files.
+
+* ``idna-data make-table``. Generate a table of the IDNA disposition
+  (e.g. PVALID, CONTEXTJ, CONTEXTO) in the format found in Appendix B.1 of RFC
+  5892 and the pre-computed tables published by `IANA <https://www.iana.org/>`_.
+
+* ``idna-data U+0061``. Prints debugging output on the various properties
+  associated with an individual Unicode codepoint (in this case, U+0061), that are
+  used to assess the IDNA and UTS 46 status of a codepoint. This is helpful in debugging
+  or analysis.
+
+The tool accepts a number of arguments, described using ``idna-data -h``. Most notably,
+the ``--version`` argument allows the specification of the version of Unicode to use
+in computing the table data. For example, ``idna-data --version 9.0.0 make-libdata``
+will generate library data against Unicode 9.0.0.
+
+
+Additional Notes
+----------------
+
+* **Packages**. The latest tagged release version is published in the
+  `Python Package Index <https://pypi.org/project/idna/>`_.
+
+* **Version support**. This library supports Python 3.5 and higher. As this library
+  serves as a low-level toolkit for a variety of applications, many of which strive
+  for broad compatibility with older Python versions, there is no rush to remove
+  older intepreter support. Removing support for older versions should be well
+  justified in that the maintenance burden has become too high.
+
+* **Python 2**. Python 2 is supported by version 2.x of this library. While active
+  development of the version 2.x series has ended, notable issues being corrected
+  may be backported to 2.x. Use "idna<3" in your requirements file if you need this
+  library for a Python 2 application.
+
+* **Testing**. The library has a test suite based on each rule of the IDNA specification, as
+  well as tests that are provided as part of the Unicode Technical Standard 46,
+  `Unicode IDNA Compatibility Processing <https://unicode.org/reports/tr46/>`_.
+
+* **Emoji**. It is an occasional request to support emoji domains in this library. Encoding
+  of symbols like emoji is expressly prohibited by the technical standard IDNA 2008 and
+  emoji domains are broadly phased out across the domain industry due to associated security
+  risks. For now, applications that wish need to support these non-compliant labels may
+  wish to consider trying the encode/decode operation in this library first, and then falling
+  back to using `encodings.idna`. See `the Github project <https://github.com/kjd/idna/issues/18>`_
+  for more discussion.
+
diff --git a/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/RECORD b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/RECORD
new file mode 100644
index 0000000..969358c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/RECORD
@@ -0,0 +1,15 @@
+idna/__init__.py,sha256=KJQN1eQBr8iIK5SKrJ47lXvxG0BJ7Lm38W4zT0v_8lk,849
+idna/codec.py,sha256=6ly5odKfqrytKT9_7UrlGklHnf1DSK2r9C6cSM4sa28,3374
+idna/compat.py,sha256=0_sOEUMT4CVw9doD3vyRhX80X19PwqFoUBs7gWsFME4,321
+idna/core.py,sha256=RFIkY-HhFZaDoBEFjGwyGd_vWI04uOAQjnzueMWqwOU,12795
+idna/idnadata.py,sha256=fzMzkCea2xieVxcrjngJ-2pLsKQNejPCZFlBajIuQdw,44025
+idna/intranges.py,sha256=YBr4fRYuWH7kTKS2tXlFjM24ZF1Pdvcir-aywniInqg,1881
+idna/package_data.py,sha256=szxQhV0ZD0nKJ84Kuobw3l8q4_KeCyXjFRdpwIpKZmw,21
+idna/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idna/uts46data.py,sha256=o-D7V-a0fOLZNd7tvxof6MYfUd0TBZzE2bLR5XO67xU,204400
+idna-3.3.dist-info/LICENSE.md,sha256=otbk2UC9JNvnuWRc3hmpeSzFHbeuDVrNMBrIYMqj6DY,1523
+idna-3.3.dist-info/METADATA,sha256=BdqiAf8ou4x1nzIHp2_sDfXWjl7BrSUGpOeVzbYHQuQ,9765
+idna-3.3.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+idna-3.3.dist-info/top_level.txt,sha256=jSag9sEDqvSPftxOQy-ABfGV_RSy7oFh4zZJpODV8k0,5
+idna-3.3.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+idna-3.3.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/WHEEL
new file mode 100644
index 0000000..5bad85f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/top_level.txt
new file mode 100644
index 0000000..c40472e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna-3.3.dist-info/top_level.txt
@@ -0,0 +1 @@
+idna
diff --git a/myenv/lib/python3.9/site-packages/idna/__init__.py b/myenv/lib/python3.9/site-packages/idna/__init__.py
new file mode 100644
index 0000000..a40eeaf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna/__init__.py
@@ -0,0 +1,44 @@
+from .package_data import __version__
+from .core import (
+    IDNABidiError,
+    IDNAError,
+    InvalidCodepoint,
+    InvalidCodepointContext,
+    alabel,
+    check_bidi,
+    check_hyphen_ok,
+    check_initial_combiner,
+    check_label,
+    check_nfc,
+    decode,
+    encode,
+    ulabel,
+    uts46_remap,
+    valid_contextj,
+    valid_contexto,
+    valid_label_length,
+    valid_string_length,
+)
+from .intranges import intranges_contain
+
+__all__ = [
+    "IDNABidiError",
+    "IDNAError",
+    "InvalidCodepoint",
+    "InvalidCodepointContext",
+    "alabel",
+    "check_bidi",
+    "check_hyphen_ok",
+    "check_initial_combiner",
+    "check_label",
+    "check_nfc",
+    "decode",
+    "encode",
+    "intranges_contain",
+    "ulabel",
+    "uts46_remap",
+    "valid_contextj",
+    "valid_contexto",
+    "valid_label_length",
+    "valid_string_length",
+]
diff --git a/myenv/lib/python3.9/site-packages/idna/codec.py b/myenv/lib/python3.9/site-packages/idna/codec.py
new file mode 100644
index 0000000..1ca9ba6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna/codec.py
@@ -0,0 +1,112 @@
+from .core import encode, decode, alabel, ulabel, IDNAError
+import codecs
+import re
+from typing import Tuple, Optional
+
+_unicode_dots_re = re.compile('[\u002e\u3002\uff0e\uff61]')
+
+class Codec(codecs.Codec):
+
+    def encode(self, data: str, errors: str = 'strict') -> Tuple[bytes, int]:
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return b"", 0
+
+        return encode(data), len(data)
+
+    def decode(self, data: bytes, errors: str = 'strict') -> Tuple[str, int]:
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return '', 0
+
+        return decode(data), len(data)
+
+class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
+    def _buffer_encode(self, data: str, errors: str, final: bool) -> Tuple[str, int]:  # type: ignore
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return "", 0
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = ''
+        if labels:
+            if not labels[-1]:
+                trailing_dot = '.'
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = '.'
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(alabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        # Join with U+002E
+        result_str = '.'.join(result) + trailing_dot  # type: ignore
+        size += len(trailing_dot)
+        return result_str, size
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, data: str, errors: str, final: bool) -> Tuple[str, int]:  # type: ignore
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return ('', 0)
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = ''
+        if labels:
+            if not labels[-1]:
+                trailing_dot = '.'
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = '.'
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(ulabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        result_str = '.'.join(result) + trailing_dot
+        size += len(trailing_dot)
+        return (result_str, size)
+
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    pass
+
+
+class StreamReader(Codec, codecs.StreamReader):
+    pass
+
+
+def getregentry() -> codecs.CodecInfo:
+    # Compatibility as a search_function for codecs.register()
+    return codecs.CodecInfo(
+        name='idna',
+        encode=Codec().encode,  # type: ignore
+        decode=Codec().decode,  # type: ignore
+        incrementalencoder=IncrementalEncoder,
+        incrementaldecoder=IncrementalDecoder,
+        streamwriter=StreamWriter,
+        streamreader=StreamReader,
+    )
diff --git a/myenv/lib/python3.9/site-packages/idna/compat.py b/myenv/lib/python3.9/site-packages/idna/compat.py
new file mode 100644
index 0000000..786e6bd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna/compat.py
@@ -0,0 +1,13 @@
+from .core import *
+from .codec import *
+from typing import Any, Union
+
+def ToASCII(label: str) -> bytes:
+    return encode(label)
+
+def ToUnicode(label: Union[bytes, bytearray]) -> str:
+    return decode(label)
+
+def nameprep(s: Any) -> None:
+    raise NotImplementedError('IDNA 2008 does not utilise nameprep protocol')
+
diff --git a/myenv/lib/python3.9/site-packages/idna/core.py b/myenv/lib/python3.9/site-packages/idna/core.py
new file mode 100644
index 0000000..55ab967
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna/core.py
@@ -0,0 +1,397 @@
+from . import idnadata
+import bisect
+import unicodedata
+import re
+from typing import Union, Optional
+from .intranges import intranges_contain
+
+_virama_combining_class = 9
+_alabel_prefix = b'xn--'
+_unicode_dots_re = re.compile('[\u002e\u3002\uff0e\uff61]')
+
+class IDNAError(UnicodeError):
+    """ Base exception for all IDNA-encoding related problems """
+    pass
+
+
+class IDNABidiError(IDNAError):
+    """ Exception when bidirectional requirements are not satisfied """
+    pass
+
+
+class InvalidCodepoint(IDNAError):
+    """ Exception when a disallowed or unallocated codepoint is used """
+    pass
+
+
+class InvalidCodepointContext(IDNAError):
+    """ Exception when the codepoint is not valid in the context it is used """
+    pass
+
+
+def _combining_class(cp: int) -> int:
+    v = unicodedata.combining(chr(cp))
+    if v == 0:
+        if not unicodedata.name(chr(cp)):
+            raise ValueError('Unknown character in unicodedata')
+    return v
+
+def _is_script(cp: str, script: str) -> bool:
+    return intranges_contain(ord(cp), idnadata.scripts[script])
+
+def _punycode(s: str) -> bytes:
+    return s.encode('punycode')
+
+def _unot(s: int) -> str:
+    return 'U+{:04X}'.format(s)
+
+
+def valid_label_length(label: Union[bytes, str]) -> bool:
+    if len(label) > 63:
+        return False
+    return True
+
+
+def valid_string_length(label: Union[bytes, str], trailing_dot: bool) -> bool:
+    if len(label) > (254 if trailing_dot else 253):
+        return False
+    return True
+
+
+def check_bidi(label: str, check_ltr: bool = False) -> bool:
+    # Bidi rules should only be applied if string contains RTL characters
+    bidi_label = False
+    for (idx, cp) in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+        if direction == '':
+            # String likely comes from a newer version of Unicode
+            raise IDNABidiError('Unknown directionality in label {} at position {}'.format(repr(label), idx))
+        if direction in ['R', 'AL', 'AN']:
+            bidi_label = True
+    if not bidi_label and not check_ltr:
+        return True
+
+    # Bidi rule 1
+    direction = unicodedata.bidirectional(label[0])
+    if direction in ['R', 'AL']:
+        rtl = True
+    elif direction == 'L':
+        rtl = False
+    else:
+        raise IDNABidiError('First codepoint in label {} must be directionality L, R or AL'.format(repr(label)))
+
+    valid_ending = False
+    number_type = None  # type: Optional[str]
+    for (idx, cp) in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+
+        if rtl:
+            # Bidi rule 2
+            if not direction in ['R', 'AL', 'AN', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']:
+                raise IDNABidiError('Invalid direction for codepoint at position {} in a right-to-left label'.format(idx))
+            # Bidi rule 3
+            if direction in ['R', 'AL', 'EN', 'AN']:
+                valid_ending = True
+            elif direction != 'NSM':
+                valid_ending = False
+            # Bidi rule 4
+            if direction in ['AN', 'EN']:
+                if not number_type:
+                    number_type = direction
+                else:
+                    if number_type != direction:
+                        raise IDNABidiError('Can not mix numeral types in a right-to-left label')
+        else:
+            # Bidi rule 5
+            if not direction in ['L', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']:
+                raise IDNABidiError('Invalid direction for codepoint at position {} in a left-to-right label'.format(idx))
+            # Bidi rule 6
+            if direction in ['L', 'EN']:
+                valid_ending = True
+            elif direction != 'NSM':
+                valid_ending = False
+
+    if not valid_ending:
+        raise IDNABidiError('Label ends with illegal codepoint directionality')
+
+    return True
+
+
+def check_initial_combiner(label: str) -> bool:
+    if unicodedata.category(label[0])[0] == 'M':
+        raise IDNAError('Label begins with an illegal combining character')
+    return True
+
+
+def check_hyphen_ok(label: str) -> bool:
+    if label[2:4] == '--':
+        raise IDNAError('Label has disallowed hyphens in 3rd and 4th position')
+    if label[0] == '-' or label[-1] == '-':
+        raise IDNAError('Label must not start or end with a hyphen')
+    return True
+
+
+def check_nfc(label: str) -> None:
+    if unicodedata.normalize('NFC', label) != label:
+        raise IDNAError('Label must be in Normalization Form C')
+
+
+def valid_contextj(label: str, pos: int) -> bool:
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x200c:
+
+        if pos > 0:
+            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
+                return True
+
+        ok = False
+        for i in range(pos-1, -1, -1):
+            joining_type = idnadata.joining_types.get(ord(label[i]))
+            if joining_type == ord('T'):
+                continue
+            if joining_type in [ord('L'), ord('D')]:
+                ok = True
+                break
+
+        if not ok:
+            return False
+
+        ok = False
+        for i in range(pos+1, len(label)):
+            joining_type = idnadata.joining_types.get(ord(label[i]))
+            if joining_type == ord('T'):
+                continue
+            if joining_type in [ord('R'), ord('D')]:
+                ok = True
+                break
+        return ok
+
+    if cp_value == 0x200d:
+
+        if pos > 0:
+            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
+                return True
+        return False
+
+    else:
+
+        return False
+
+
+def valid_contexto(label: str, pos: int, exception: bool = False) -> bool:
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x00b7:
+        if 0 < pos < len(label)-1:
+            if ord(label[pos - 1]) == 0x006c and ord(label[pos + 1]) == 0x006c:
+                return True
+        return False
+
+    elif cp_value == 0x0375:
+        if pos < len(label)-1 and len(label) > 1:
+            return _is_script(label[pos + 1], 'Greek')
+        return False
+
+    elif cp_value == 0x05f3 or cp_value == 0x05f4:
+        if pos > 0:
+            return _is_script(label[pos - 1], 'Hebrew')
+        return False
+
+    elif cp_value == 0x30fb:
+        for cp in label:
+            if cp == '\u30fb':
+                continue
+            if _is_script(cp, 'Hiragana') or _is_script(cp, 'Katakana') or _is_script(cp, 'Han'):
+                return True
+        return False
+
+    elif 0x660 <= cp_value <= 0x669:
+        for cp in label:
+            if 0x6f0 <= ord(cp) <= 0x06f9:
+                return False
+        return True
+
+    elif 0x6f0 <= cp_value <= 0x6f9:
+        for cp in label:
+            if 0x660 <= ord(cp) <= 0x0669:
+                return False
+        return True
+
+    return False
+
+
+def check_label(label: Union[str, bytes, bytearray]) -> None:
+    if isinstance(label, (bytes, bytearray)):
+        label = label.decode('utf-8')
+    if len(label) == 0:
+        raise IDNAError('Empty Label')
+
+    check_nfc(label)
+    check_hyphen_ok(label)
+    check_initial_combiner(label)
+
+    for (pos, cp) in enumerate(label):
+        cp_value = ord(cp)
+        if intranges_contain(cp_value, idnadata.codepoint_classes['PVALID']):
+            continue
+        elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTJ']):
+            try:
+                if not valid_contextj(label, pos):
+                    raise InvalidCodepointContext('Joiner {} not allowed at position {} in {}'.format(
+                        _unot(cp_value), pos+1, repr(label)))
+            except ValueError:
+                raise IDNAError('Unknown codepoint adjacent to joiner {} at position {} in {}'.format(
+                    _unot(cp_value), pos+1, repr(label)))
+        elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTO']):
+            if not valid_contexto(label, pos):
+                raise InvalidCodepointContext('Codepoint {} not allowed at position {} in {}'.format(_unot(cp_value), pos+1, repr(label)))
+        else:
+            raise InvalidCodepoint('Codepoint {} at position {} of {} not allowed'.format(_unot(cp_value), pos+1, repr(label)))
+
+    check_bidi(label)
+
+
+def alabel(label: str) -> bytes:
+    try:
+        label_bytes = label.encode('ascii')
+        ulabel(label_bytes)
+        if not valid_label_length(label_bytes):
+            raise IDNAError('Label too long')
+        return label_bytes
+    except UnicodeEncodeError:
+        pass
+
+    if not label:
+        raise IDNAError('No Input')
+
+    label = str(label)
+    check_label(label)
+    label_bytes = _punycode(label)
+    label_bytes = _alabel_prefix + label_bytes
+
+    if not valid_label_length(label_bytes):
+        raise IDNAError('Label too long')
+
+    return label_bytes
+
+
+def ulabel(label: Union[str, bytes, bytearray]) -> str:
+    if not isinstance(label, (bytes, bytearray)):
+        try:
+            label_bytes = label.encode('ascii')
+        except UnicodeEncodeError:
+            check_label(label)
+            return label
+    else:
+        label_bytes = label
+
+    label_bytes = label_bytes.lower()
+    if label_bytes.startswith(_alabel_prefix):
+        label_bytes = label_bytes[len(_alabel_prefix):]
+        if not label_bytes:
+            raise IDNAError('Malformed A-label, no Punycode eligible content found')
+        if label_bytes.decode('ascii')[-1] == '-':
+            raise IDNAError('A-label must not end with a hyphen')
+    else:
+        check_label(label_bytes)
+        return label_bytes.decode('ascii')
+
+    try:
+        label = label_bytes.decode('punycode')
+    except UnicodeError:
+        raise IDNAError('Invalid A-label')
+    check_label(label)
+    return label
+
+
+def uts46_remap(domain: str, std3_rules: bool = True, transitional: bool = False) -> str:
+    """Re-map the characters in the string according to UTS46 processing."""
+    from .uts46data import uts46data
+    output = ''
+
+    for pos, char in enumerate(domain):
+        code_point = ord(char)
+        try:
+            uts46row = uts46data[code_point if code_point < 256 else
+                bisect.bisect_left(uts46data, (code_point, 'Z')) - 1]
+            status = uts46row[1]
+            replacement = None  # type: Optional[str]
+            if len(uts46row) == 3:
+                replacement = uts46row[2]  # type: ignore
+            if (status == 'V' or
+                    (status == 'D' and not transitional) or
+                    (status == '3' and not std3_rules and replacement is None)):
+                output += char
+            elif replacement is not None and (status == 'M' or
+                    (status == '3' and not std3_rules) or
+                    (status == 'D' and transitional)):
+                output += replacement
+            elif status != 'I':
+                raise IndexError()
+        except IndexError:
+            raise InvalidCodepoint(
+                'Codepoint {} not allowed at position {} in {}'.format(
+                _unot(code_point), pos + 1, repr(domain)))
+
+    return unicodedata.normalize('NFC', output)
+
+
+def encode(s: Union[str, bytes, bytearray], strict: bool = False, uts46: bool = False, std3_rules: bool = False, transitional: bool = False) -> bytes:
+    if isinstance(s, (bytes, bytearray)):
+        s = s.decode('ascii')
+    if uts46:
+        s = uts46_remap(s, std3_rules, transitional)
+    trailing_dot = False
+    result = []
+    if strict:
+        labels = s.split('.')
+    else:
+        labels = _unicode_dots_re.split(s)
+    if not labels or labels == ['']:
+        raise IDNAError('Empty domain')
+    if labels[-1] == '':
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        s = alabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError('Empty label')
+    if trailing_dot:
+        result.append(b'')
+    s = b'.'.join(result)
+    if not valid_string_length(s, trailing_dot):
+        raise IDNAError('Domain too long')
+    return s
+
+
+def decode(s: Union[str, bytes, bytearray], strict: bool = False, uts46: bool = False, std3_rules: bool = False) -> str:
+    try:
+        if isinstance(s, (bytes, bytearray)):
+            s = s.decode('ascii')
+    except UnicodeDecodeError:
+        raise IDNAError('Invalid ASCII in A-label')
+    if uts46:
+        s = uts46_remap(s, std3_rules, False)
+    trailing_dot = False
+    result = []
+    if not strict:
+        labels = _unicode_dots_re.split(s)
+    else:
+        labels = s.split('.')
+    if not labels or labels == ['']:
+        raise IDNAError('Empty domain')
+    if not labels[-1]:
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        s = ulabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError('Empty label')
+    if trailing_dot:
+        result.append('')
+    return '.'.join(result)
diff --git a/myenv/lib/python3.9/site-packages/idna/idnadata.py b/myenv/lib/python3.9/site-packages/idna/idnadata.py
new file mode 100644
index 0000000..1b5805d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna/idnadata.py
@@ -0,0 +1,2137 @@
+# This file is automatically generated by tools/idna-data
+
+__version__ = '14.0.0'
+scripts = {
+    'Greek': (
+        0x37000000374,
+        0x37500000378,
+        0x37a0000037e,
+        0x37f00000380,
+        0x38400000385,
+        0x38600000387,
+        0x3880000038b,
+        0x38c0000038d,
+        0x38e000003a2,
+        0x3a3000003e2,
+        0x3f000000400,
+        0x1d2600001d2b,
+        0x1d5d00001d62,
+        0x1d6600001d6b,
+        0x1dbf00001dc0,
+        0x1f0000001f16,
+        0x1f1800001f1e,
+        0x1f2000001f46,
+        0x1f4800001f4e,
+        0x1f5000001f58,
+        0x1f5900001f5a,
+        0x1f5b00001f5c,
+        0x1f5d00001f5e,
+        0x1f5f00001f7e,
+        0x1f8000001fb5,
+        0x1fb600001fc5,
+        0x1fc600001fd4,
+        0x1fd600001fdc,
+        0x1fdd00001ff0,
+        0x1ff200001ff5,
+        0x1ff600001fff,
+        0x212600002127,
+        0xab650000ab66,
+        0x101400001018f,
+        0x101a0000101a1,
+        0x1d2000001d246,
+    ),
+    'Han': (
+        0x2e8000002e9a,
+        0x2e9b00002ef4,
+        0x2f0000002fd6,
+        0x300500003006,
+        0x300700003008,
+        0x30210000302a,
+        0x30380000303c,
+        0x340000004dc0,
+        0x4e000000a000,
+        0xf9000000fa6e,
+        0xfa700000fada,
+        0x16fe200016fe4,
+        0x16ff000016ff2,
+        0x200000002a6e0,
+        0x2a7000002b739,
+        0x2b7400002b81e,
+        0x2b8200002cea2,
+        0x2ceb00002ebe1,
+        0x2f8000002fa1e,
+        0x300000003134b,
+    ),
+    'Hebrew': (
+        0x591000005c8,
+        0x5d0000005eb,
+        0x5ef000005f5,
+        0xfb1d0000fb37,
+        0xfb380000fb3d,
+        0xfb3e0000fb3f,
+        0xfb400000fb42,
+        0xfb430000fb45,
+        0xfb460000fb50,
+    ),
+    'Hiragana': (
+        0x304100003097,
+        0x309d000030a0,
+        0x1b0010001b120,
+        0x1b1500001b153,
+        0x1f2000001f201,
+    ),
+    'Katakana': (
+        0x30a1000030fb,
+        0x30fd00003100,
+        0x31f000003200,
+        0x32d0000032ff,
+        0x330000003358,
+        0xff660000ff70,
+        0xff710000ff9e,
+        0x1aff00001aff4,
+        0x1aff50001affc,
+        0x1affd0001afff,
+        0x1b0000001b001,
+        0x1b1200001b123,
+        0x1b1640001b168,
+    ),
+}
+joining_types = {
+    0x600: 85,
+    0x601: 85,
+    0x602: 85,
+    0x603: 85,
+    0x604: 85,
+    0x605: 85,
+    0x608: 85,
+    0x60b: 85,
+    0x620: 68,
+    0x621: 85,
+    0x622: 82,
+    0x623: 82,
+    0x624: 82,
+    0x625: 82,
+    0x626: 68,
+    0x627: 82,
+    0x628: 68,
+    0x629: 82,
+    0x62a: 68,
+    0x62b: 68,
+    0x62c: 68,
+    0x62d: 68,
+    0x62e: 68,
+    0x62f: 82,
+    0x630: 82,
+    0x631: 82,
+    0x632: 82,
+    0x633: 68,
+    0x634: 68,
+    0x635: 68,
+    0x636: 68,
+    0x637: 68,
+    0x638: 68,
+    0x639: 68,
+    0x63a: 68,
+    0x63b: 68,
+    0x63c: 68,
+    0x63d: 68,
+    0x63e: 68,
+    0x63f: 68,
+    0x640: 67,
+    0x641: 68,
+    0x642: 68,
+    0x643: 68,
+    0x644: 68,
+    0x645: 68,
+    0x646: 68,
+    0x647: 68,
+    0x648: 82,
+    0x649: 68,
+    0x64a: 68,
+    0x66e: 68,
+    0x66f: 68,
+    0x671: 82,
+    0x672: 82,
+    0x673: 82,
+    0x674: 85,
+    0x675: 82,
+    0x676: 82,
+    0x677: 82,
+    0x678: 68,
+    0x679: 68,
+    0x67a: 68,
+    0x67b: 68,
+    0x67c: 68,
+    0x67d: 68,
+    0x67e: 68,
+    0x67f: 68,
+    0x680: 68,
+    0x681: 68,
+    0x682: 68,
+    0x683: 68,
+    0x684: 68,
+    0x685: 68,
+    0x686: 68,
+    0x687: 68,
+    0x688: 82,
+    0x689: 82,
+    0x68a: 82,
+    0x68b: 82,
+    0x68c: 82,
+    0x68d: 82,
+    0x68e: 82,
+    0x68f: 82,
+    0x690: 82,
+    0x691: 82,
+    0x692: 82,
+    0x693: 82,
+    0x694: 82,
+    0x695: 82,
+    0x696: 82,
+    0x697: 82,
+    0x698: 82,
+    0x699: 82,
+    0x69a: 68,
+    0x69b: 68,
+    0x69c: 68,
+    0x69d: 68,
+    0x69e: 68,
+    0x69f: 68,
+    0x6a0: 68,
+    0x6a1: 68,
+    0x6a2: 68,
+    0x6a3: 68,
+    0x6a4: 68,
+    0x6a5: 68,
+    0x6a6: 68,
+    0x6a7: 68,
+    0x6a8: 68,
+    0x6a9: 68,
+    0x6aa: 68,
+    0x6ab: 68,
+    0x6ac: 68,
+    0x6ad: 68,
+    0x6ae: 68,
+    0x6af: 68,
+    0x6b0: 68,
+    0x6b1: 68,
+    0x6b2: 68,
+    0x6b3: 68,
+    0x6b4: 68,
+    0x6b5: 68,
+    0x6b6: 68,
+    0x6b7: 68,
+    0x6b8: 68,
+    0x6b9: 68,
+    0x6ba: 68,
+    0x6bb: 68,
+    0x6bc: 68,
+    0x6bd: 68,
+    0x6be: 68,
+    0x6bf: 68,
+    0x6c0: 82,
+    0x6c1: 68,
+    0x6c2: 68,
+    0x6c3: 82,
+    0x6c4: 82,
+    0x6c5: 82,
+    0x6c6: 82,
+    0x6c7: 82,
+    0x6c8: 82,
+    0x6c9: 82,
+    0x6ca: 82,
+    0x6cb: 82,
+    0x6cc: 68,
+    0x6cd: 82,
+    0x6ce: 68,
+    0x6cf: 82,
+    0x6d0: 68,
+    0x6d1: 68,
+    0x6d2: 82,
+    0x6d3: 82,
+    0x6d5: 82,
+    0x6dd: 85,
+    0x6ee: 82,
+    0x6ef: 82,
+    0x6fa: 68,
+    0x6fb: 68,
+    0x6fc: 68,
+    0x6ff: 68,
+    0x70f: 84,
+    0x710: 82,
+    0x712: 68,
+    0x713: 68,
+    0x714: 68,
+    0x715: 82,
+    0x716: 82,
+    0x717: 82,
+    0x718: 82,
+    0x719: 82,
+    0x71a: 68,
+    0x71b: 68,
+    0x71c: 68,
+    0x71d: 68,
+    0x71e: 82,
+    0x71f: 68,
+    0x720: 68,
+    0x721: 68,
+    0x722: 68,
+    0x723: 68,
+    0x724: 68,
+    0x725: 68,
+    0x726: 68,
+    0x727: 68,
+    0x728: 82,
+    0x729: 68,
+    0x72a: 82,
+    0x72b: 68,
+    0x72c: 82,
+    0x72d: 68,
+    0x72e: 68,
+    0x72f: 82,
+    0x74d: 82,
+    0x74e: 68,
+    0x74f: 68,
+    0x750: 68,
+    0x751: 68,
+    0x752: 68,
+    0x753: 68,
+    0x754: 68,
+    0x755: 68,
+    0x756: 68,
+    0x757: 68,
+    0x758: 68,
+    0x759: 82,
+    0x75a: 82,
+    0x75b: 82,
+    0x75c: 68,
+    0x75d: 68,
+    0x75e: 68,
+    0x75f: 68,
+    0x760: 68,
+    0x761: 68,
+    0x762: 68,
+    0x763: 68,
+    0x764: 68,
+    0x765: 68,
+    0x766: 68,
+    0x767: 68,
+    0x768: 68,
+    0x769: 68,
+    0x76a: 68,
+    0x76b: 82,
+    0x76c: 82,
+    0x76d: 68,
+    0x76e: 68,
+    0x76f: 68,
+    0x770: 68,
+    0x771: 82,
+    0x772: 68,
+    0x773: 82,
+    0x774: 82,
+    0x775: 68,
+    0x776: 68,
+    0x777: 68,
+    0x778: 82,
+    0x779: 82,
+    0x77a: 68,
+    0x77b: 68,
+    0x77c: 68,
+    0x77d: 68,
+    0x77e: 68,
+    0x77f: 68,
+    0x7ca: 68,
+    0x7cb: 68,
+    0x7cc: 68,
+    0x7cd: 68,
+    0x7ce: 68,
+    0x7cf: 68,
+    0x7d0: 68,
+    0x7d1: 68,
+    0x7d2: 68,
+    0x7d3: 68,
+    0x7d4: 68,
+    0x7d5: 68,
+    0x7d6: 68,
+    0x7d7: 68,
+    0x7d8: 68,
+    0x7d9: 68,
+    0x7da: 68,
+    0x7db: 68,
+    0x7dc: 68,
+    0x7dd: 68,
+    0x7de: 68,
+    0x7df: 68,
+    0x7e0: 68,
+    0x7e1: 68,
+    0x7e2: 68,
+    0x7e3: 68,
+    0x7e4: 68,
+    0x7e5: 68,
+    0x7e6: 68,
+    0x7e7: 68,
+    0x7e8: 68,
+    0x7e9: 68,
+    0x7ea: 68,
+    0x7fa: 67,
+    0x840: 82,
+    0x841: 68,
+    0x842: 68,
+    0x843: 68,
+    0x844: 68,
+    0x845: 68,
+    0x846: 82,
+    0x847: 82,
+    0x848: 68,
+    0x849: 82,
+    0x84a: 68,
+    0x84b: 68,
+    0x84c: 68,
+    0x84d: 68,
+    0x84e: 68,
+    0x84f: 68,
+    0x850: 68,
+    0x851: 68,
+    0x852: 68,
+    0x853: 68,
+    0x854: 82,
+    0x855: 68,
+    0x856: 82,
+    0x857: 82,
+    0x858: 82,
+    0x860: 68,
+    0x861: 85,
+    0x862: 68,
+    0x863: 68,
+    0x864: 68,
+    0x865: 68,
+    0x866: 85,
+    0x867: 82,
+    0x868: 68,
+    0x869: 82,
+    0x86a: 82,
+    0x870: 82,
+    0x871: 82,
+    0x872: 82,
+    0x873: 82,
+    0x874: 82,
+    0x875: 82,
+    0x876: 82,
+    0x877: 82,
+    0x878: 82,
+    0x879: 82,
+    0x87a: 82,
+    0x87b: 82,
+    0x87c: 82,
+    0x87d: 82,
+    0x87e: 82,
+    0x87f: 82,
+    0x880: 82,
+    0x881: 82,
+    0x882: 82,
+    0x883: 67,
+    0x884: 67,
+    0x885: 67,
+    0x886: 68,
+    0x887: 85,
+    0x888: 85,
+    0x889: 68,
+    0x88a: 68,
+    0x88b: 68,
+    0x88c: 68,
+    0x88d: 68,
+    0x88e: 82,
+    0x890: 85,
+    0x891: 85,
+    0x8a0: 68,
+    0x8a1: 68,
+    0x8a2: 68,
+    0x8a3: 68,
+    0x8a4: 68,
+    0x8a5: 68,
+    0x8a6: 68,
+    0x8a7: 68,
+    0x8a8: 68,
+    0x8a9: 68,
+    0x8aa: 82,
+    0x8ab: 82,
+    0x8ac: 82,
+    0x8ad: 85,
+    0x8ae: 82,
+    0x8af: 68,
+    0x8b0: 68,
+    0x8b1: 82,
+    0x8b2: 82,
+    0x8b3: 68,
+    0x8b4: 68,
+    0x8b5: 68,
+    0x8b6: 68,
+    0x8b7: 68,
+    0x8b8: 68,
+    0x8b9: 82,
+    0x8ba: 68,
+    0x8bb: 68,
+    0x8bc: 68,
+    0x8bd: 68,
+    0x8be: 68,
+    0x8bf: 68,
+    0x8c0: 68,
+    0x8c1: 68,
+    0x8c2: 68,
+    0x8c3: 68,
+    0x8c4: 68,
+    0x8c5: 68,
+    0x8c6: 68,
+    0x8c7: 68,
+    0x8c8: 68,
+    0x8e2: 85,
+    0x1806: 85,
+    0x1807: 68,
+    0x180a: 67,
+    0x180e: 85,
+    0x1820: 68,
+    0x1821: 68,
+    0x1822: 68,
+    0x1823: 68,
+    0x1824: 68,
+    0x1825: 68,
+    0x1826: 68,
+    0x1827: 68,
+    0x1828: 68,
+    0x1829: 68,
+    0x182a: 68,
+    0x182b: 68,
+    0x182c: 68,
+    0x182d: 68,
+    0x182e: 68,
+    0x182f: 68,
+    0x1830: 68,
+    0x1831: 68,
+    0x1832: 68,
+    0x1833: 68,
+    0x1834: 68,
+    0x1835: 68,
+    0x1836: 68,
+    0x1837: 68,
+    0x1838: 68,
+    0x1839: 68,
+    0x183a: 68,
+    0x183b: 68,
+    0x183c: 68,
+    0x183d: 68,
+    0x183e: 68,
+    0x183f: 68,
+    0x1840: 68,
+    0x1841: 68,
+    0x1842: 68,
+    0x1843: 68,
+    0x1844: 68,
+    0x1845: 68,
+    0x1846: 68,
+    0x1847: 68,
+    0x1848: 68,
+    0x1849: 68,
+    0x184a: 68,
+    0x184b: 68,
+    0x184c: 68,
+    0x184d: 68,
+    0x184e: 68,
+    0x184f: 68,
+    0x1850: 68,
+    0x1851: 68,
+    0x1852: 68,
+    0x1853: 68,
+    0x1854: 68,
+    0x1855: 68,
+    0x1856: 68,
+    0x1857: 68,
+    0x1858: 68,
+    0x1859: 68,
+    0x185a: 68,
+    0x185b: 68,
+    0x185c: 68,
+    0x185d: 68,
+    0x185e: 68,
+    0x185f: 68,
+    0x1860: 68,
+    0x1861: 68,
+    0x1862: 68,
+    0x1863: 68,
+    0x1864: 68,
+    0x1865: 68,
+    0x1866: 68,
+    0x1867: 68,
+    0x1868: 68,
+    0x1869: 68,
+    0x186a: 68,
+    0x186b: 68,
+    0x186c: 68,
+    0x186d: 68,
+    0x186e: 68,
+    0x186f: 68,
+    0x1870: 68,
+    0x1871: 68,
+    0x1872: 68,
+    0x1873: 68,
+    0x1874: 68,
+    0x1875: 68,
+    0x1876: 68,
+    0x1877: 68,
+    0x1878: 68,
+    0x1880: 85,
+    0x1881: 85,
+    0x1882: 85,
+    0x1883: 85,
+    0x1884: 85,
+    0x1885: 84,
+    0x1886: 84,
+    0x1887: 68,
+    0x1888: 68,
+    0x1889: 68,
+    0x188a: 68,
+    0x188b: 68,
+    0x188c: 68,
+    0x188d: 68,
+    0x188e: 68,
+    0x188f: 68,
+    0x1890: 68,
+    0x1891: 68,
+    0x1892: 68,
+    0x1893: 68,
+    0x1894: 68,
+    0x1895: 68,
+    0x1896: 68,
+    0x1897: 68,
+    0x1898: 68,
+    0x1899: 68,
+    0x189a: 68,
+    0x189b: 68,
+    0x189c: 68,
+    0x189d: 68,
+    0x189e: 68,
+    0x189f: 68,
+    0x18a0: 68,
+    0x18a1: 68,
+    0x18a2: 68,
+    0x18a3: 68,
+    0x18a4: 68,
+    0x18a5: 68,
+    0x18a6: 68,
+    0x18a7: 68,
+    0x18a8: 68,
+    0x18aa: 68,
+    0x200c: 85,
+    0x200d: 67,
+    0x202f: 85,
+    0x2066: 85,
+    0x2067: 85,
+    0x2068: 85,
+    0x2069: 85,
+    0xa840: 68,
+    0xa841: 68,
+    0xa842: 68,
+    0xa843: 68,
+    0xa844: 68,
+    0xa845: 68,
+    0xa846: 68,
+    0xa847: 68,
+    0xa848: 68,
+    0xa849: 68,
+    0xa84a: 68,
+    0xa84b: 68,
+    0xa84c: 68,
+    0xa84d: 68,
+    0xa84e: 68,
+    0xa84f: 68,
+    0xa850: 68,
+    0xa851: 68,
+    0xa852: 68,
+    0xa853: 68,
+    0xa854: 68,
+    0xa855: 68,
+    0xa856: 68,
+    0xa857: 68,
+    0xa858: 68,
+    0xa859: 68,
+    0xa85a: 68,
+    0xa85b: 68,
+    0xa85c: 68,
+    0xa85d: 68,
+    0xa85e: 68,
+    0xa85f: 68,
+    0xa860: 68,
+    0xa861: 68,
+    0xa862: 68,
+    0xa863: 68,
+    0xa864: 68,
+    0xa865: 68,
+    0xa866: 68,
+    0xa867: 68,
+    0xa868: 68,
+    0xa869: 68,
+    0xa86a: 68,
+    0xa86b: 68,
+    0xa86c: 68,
+    0xa86d: 68,
+    0xa86e: 68,
+    0xa86f: 68,
+    0xa870: 68,
+    0xa871: 68,
+    0xa872: 76,
+    0xa873: 85,
+    0x10ac0: 68,
+    0x10ac1: 68,
+    0x10ac2: 68,
+    0x10ac3: 68,
+    0x10ac4: 68,
+    0x10ac5: 82,
+    0x10ac6: 85,
+    0x10ac7: 82,
+    0x10ac8: 85,
+    0x10ac9: 82,
+    0x10aca: 82,
+    0x10acb: 85,
+    0x10acc: 85,
+    0x10acd: 76,
+    0x10ace: 82,
+    0x10acf: 82,
+    0x10ad0: 82,
+    0x10ad1: 82,
+    0x10ad2: 82,
+    0x10ad3: 68,
+    0x10ad4: 68,
+    0x10ad5: 68,
+    0x10ad6: 68,
+    0x10ad7: 76,
+    0x10ad8: 68,
+    0x10ad9: 68,
+    0x10ada: 68,
+    0x10adb: 68,
+    0x10adc: 68,
+    0x10add: 82,
+    0x10ade: 68,
+    0x10adf: 68,
+    0x10ae0: 68,
+    0x10ae1: 82,
+    0x10ae2: 85,
+    0x10ae3: 85,
+    0x10ae4: 82,
+    0x10aeb: 68,
+    0x10aec: 68,
+    0x10aed: 68,
+    0x10aee: 68,
+    0x10aef: 82,
+    0x10b80: 68,
+    0x10b81: 82,
+    0x10b82: 68,
+    0x10b83: 82,
+    0x10b84: 82,
+    0x10b85: 82,
+    0x10b86: 68,
+    0x10b87: 68,
+    0x10b88: 68,
+    0x10b89: 82,
+    0x10b8a: 68,
+    0x10b8b: 68,
+    0x10b8c: 82,
+    0x10b8d: 68,
+    0x10b8e: 82,
+    0x10b8f: 82,
+    0x10b90: 68,
+    0x10b91: 82,
+    0x10ba9: 82,
+    0x10baa: 82,
+    0x10bab: 82,
+    0x10bac: 82,
+    0x10bad: 68,
+    0x10bae: 68,
+    0x10baf: 85,
+    0x10d00: 76,
+    0x10d01: 68,
+    0x10d02: 68,
+    0x10d03: 68,
+    0x10d04: 68,
+    0x10d05: 68,
+    0x10d06: 68,
+    0x10d07: 68,
+    0x10d08: 68,
+    0x10d09: 68,
+    0x10d0a: 68,
+    0x10d0b: 68,
+    0x10d0c: 68,
+    0x10d0d: 68,
+    0x10d0e: 68,
+    0x10d0f: 68,
+    0x10d10: 68,
+    0x10d11: 68,
+    0x10d12: 68,
+    0x10d13: 68,
+    0x10d14: 68,
+    0x10d15: 68,
+    0x10d16: 68,
+    0x10d17: 68,
+    0x10d18: 68,
+    0x10d19: 68,
+    0x10d1a: 68,
+    0x10d1b: 68,
+    0x10d1c: 68,
+    0x10d1d: 68,
+    0x10d1e: 68,
+    0x10d1f: 68,
+    0x10d20: 68,
+    0x10d21: 68,
+    0x10d22: 82,
+    0x10d23: 68,
+    0x10f30: 68,
+    0x10f31: 68,
+    0x10f32: 68,
+    0x10f33: 82,
+    0x10f34: 68,
+    0x10f35: 68,
+    0x10f36: 68,
+    0x10f37: 68,
+    0x10f38: 68,
+    0x10f39: 68,
+    0x10f3a: 68,
+    0x10f3b: 68,
+    0x10f3c: 68,
+    0x10f3d: 68,
+    0x10f3e: 68,
+    0x10f3f: 68,
+    0x10f40: 68,
+    0x10f41: 68,
+    0x10f42: 68,
+    0x10f43: 68,
+    0x10f44: 68,
+    0x10f45: 85,
+    0x10f51: 68,
+    0x10f52: 68,
+    0x10f53: 68,
+    0x10f54: 82,
+    0x10f70: 68,
+    0x10f71: 68,
+    0x10f72: 68,
+    0x10f73: 68,
+    0x10f74: 82,
+    0x10f75: 82,
+    0x10f76: 68,
+    0x10f77: 68,
+    0x10f78: 68,
+    0x10f79: 68,
+    0x10f7a: 68,
+    0x10f7b: 68,
+    0x10f7c: 68,
+    0x10f7d: 68,
+    0x10f7e: 68,
+    0x10f7f: 68,
+    0x10f80: 68,
+    0x10f81: 68,
+    0x10fb0: 68,
+    0x10fb1: 85,
+    0x10fb2: 68,
+    0x10fb3: 68,
+    0x10fb4: 82,
+    0x10fb5: 82,
+    0x10fb6: 82,
+    0x10fb7: 85,
+    0x10fb8: 68,
+    0x10fb9: 82,
+    0x10fba: 82,
+    0x10fbb: 68,
+    0x10fbc: 68,
+    0x10fbd: 82,
+    0x10fbe: 68,
+    0x10fbf: 68,
+    0x10fc0: 85,
+    0x10fc1: 68,
+    0x10fc2: 82,
+    0x10fc3: 82,
+    0x10fc4: 68,
+    0x10fc5: 85,
+    0x10fc6: 85,
+    0x10fc7: 85,
+    0x10fc8: 85,
+    0x10fc9: 82,
+    0x10fca: 68,
+    0x10fcb: 76,
+    0x110bd: 85,
+    0x110cd: 85,
+    0x1e900: 68,
+    0x1e901: 68,
+    0x1e902: 68,
+    0x1e903: 68,
+    0x1e904: 68,
+    0x1e905: 68,
+    0x1e906: 68,
+    0x1e907: 68,
+    0x1e908: 68,
+    0x1e909: 68,
+    0x1e90a: 68,
+    0x1e90b: 68,
+    0x1e90c: 68,
+    0x1e90d: 68,
+    0x1e90e: 68,
+    0x1e90f: 68,
+    0x1e910: 68,
+    0x1e911: 68,
+    0x1e912: 68,
+    0x1e913: 68,
+    0x1e914: 68,
+    0x1e915: 68,
+    0x1e916: 68,
+    0x1e917: 68,
+    0x1e918: 68,
+    0x1e919: 68,
+    0x1e91a: 68,
+    0x1e91b: 68,
+    0x1e91c: 68,
+    0x1e91d: 68,
+    0x1e91e: 68,
+    0x1e91f: 68,
+    0x1e920: 68,
+    0x1e921: 68,
+    0x1e922: 68,
+    0x1e923: 68,
+    0x1e924: 68,
+    0x1e925: 68,
+    0x1e926: 68,
+    0x1e927: 68,
+    0x1e928: 68,
+    0x1e929: 68,
+    0x1e92a: 68,
+    0x1e92b: 68,
+    0x1e92c: 68,
+    0x1e92d: 68,
+    0x1e92e: 68,
+    0x1e92f: 68,
+    0x1e930: 68,
+    0x1e931: 68,
+    0x1e932: 68,
+    0x1e933: 68,
+    0x1e934: 68,
+    0x1e935: 68,
+    0x1e936: 68,
+    0x1e937: 68,
+    0x1e938: 68,
+    0x1e939: 68,
+    0x1e93a: 68,
+    0x1e93b: 68,
+    0x1e93c: 68,
+    0x1e93d: 68,
+    0x1e93e: 68,
+    0x1e93f: 68,
+    0x1e940: 68,
+    0x1e941: 68,
+    0x1e942: 68,
+    0x1e943: 68,
+    0x1e94b: 84,
+}
+codepoint_classes = {
+    'PVALID': (
+        0x2d0000002e,
+        0x300000003a,
+        0x610000007b,
+        0xdf000000f7,
+        0xf800000100,
+        0x10100000102,
+        0x10300000104,
+        0x10500000106,
+        0x10700000108,
+        0x1090000010a,
+        0x10b0000010c,
+        0x10d0000010e,
+        0x10f00000110,
+        0x11100000112,
+        0x11300000114,
+        0x11500000116,
+        0x11700000118,
+        0x1190000011a,
+        0x11b0000011c,
+        0x11d0000011e,
+        0x11f00000120,
+        0x12100000122,
+        0x12300000124,
+        0x12500000126,
+        0x12700000128,
+        0x1290000012a,
+        0x12b0000012c,
+        0x12d0000012e,
+        0x12f00000130,
+        0x13100000132,
+        0x13500000136,
+        0x13700000139,
+        0x13a0000013b,
+        0x13c0000013d,
+        0x13e0000013f,
+        0x14200000143,
+        0x14400000145,
+        0x14600000147,
+        0x14800000149,
+        0x14b0000014c,
+        0x14d0000014e,
+        0x14f00000150,
+        0x15100000152,
+        0x15300000154,
+        0x15500000156,
+        0x15700000158,
+        0x1590000015a,
+        0x15b0000015c,
+        0x15d0000015e,
+        0x15f00000160,
+        0x16100000162,
+        0x16300000164,
+        0x16500000166,
+        0x16700000168,
+        0x1690000016a,
+        0x16b0000016c,
+        0x16d0000016e,
+        0x16f00000170,
+        0x17100000172,
+        0x17300000174,
+        0x17500000176,
+        0x17700000178,
+        0x17a0000017b,
+        0x17c0000017d,
+        0x17e0000017f,
+        0x18000000181,
+        0x18300000184,
+        0x18500000186,
+        0x18800000189,
+        0x18c0000018e,
+        0x19200000193,
+        0x19500000196,
+        0x1990000019c,
+        0x19e0000019f,
+        0x1a1000001a2,
+        0x1a3000001a4,
+        0x1a5000001a6,
+        0x1a8000001a9,
+        0x1aa000001ac,
+        0x1ad000001ae,
+        0x1b0000001b1,
+        0x1b4000001b5,
+        0x1b6000001b7,
+        0x1b9000001bc,
+        0x1bd000001c4,
+        0x1ce000001cf,
+        0x1d0000001d1,
+        0x1d2000001d3,
+        0x1d4000001d5,
+        0x1d6000001d7,
+        0x1d8000001d9,
+        0x1da000001db,
+        0x1dc000001de,
+        0x1df000001e0,
+        0x1e1000001e2,
+        0x1e3000001e4,
+        0x1e5000001e6,
+        0x1e7000001e8,
+        0x1e9000001ea,
+        0x1eb000001ec,
+        0x1ed000001ee,
+        0x1ef000001f1,
+        0x1f5000001f6,
+        0x1f9000001fa,
+        0x1fb000001fc,
+        0x1fd000001fe,
+        0x1ff00000200,
+        0x20100000202,
+        0x20300000204,
+        0x20500000206,
+        0x20700000208,
+        0x2090000020a,
+        0x20b0000020c,
+        0x20d0000020e,
+        0x20f00000210,
+        0x21100000212,
+        0x21300000214,
+        0x21500000216,
+        0x21700000218,
+        0x2190000021a,
+        0x21b0000021c,
+        0x21d0000021e,
+        0x21f00000220,
+        0x22100000222,
+        0x22300000224,
+        0x22500000226,
+        0x22700000228,
+        0x2290000022a,
+        0x22b0000022c,
+        0x22d0000022e,
+        0x22f00000230,
+        0x23100000232,
+        0x2330000023a,
+        0x23c0000023d,
+        0x23f00000241,
+        0x24200000243,
+        0x24700000248,
+        0x2490000024a,
+        0x24b0000024c,
+        0x24d0000024e,
+        0x24f000002b0,
+        0x2b9000002c2,
+        0x2c6000002d2,
+        0x2ec000002ed,
+        0x2ee000002ef,
+        0x30000000340,
+        0x34200000343,
+        0x3460000034f,
+        0x35000000370,
+        0x37100000372,
+        0x37300000374,
+        0x37700000378,
+        0x37b0000037e,
+        0x39000000391,
+        0x3ac000003cf,
+        0x3d7000003d8,
+        0x3d9000003da,
+        0x3db000003dc,
+        0x3dd000003de,
+        0x3df000003e0,
+        0x3e1000003e2,
+        0x3e3000003e4,
+        0x3e5000003e6,
+        0x3e7000003e8,
+        0x3e9000003ea,
+        0x3eb000003ec,
+        0x3ed000003ee,
+        0x3ef000003f0,
+        0x3f3000003f4,
+        0x3f8000003f9,
+        0x3fb000003fd,
+        0x43000000460,
+        0x46100000462,
+        0x46300000464,
+        0x46500000466,
+        0x46700000468,
+        0x4690000046a,
+        0x46b0000046c,
+        0x46d0000046e,
+        0x46f00000470,
+        0x47100000472,
+        0x47300000474,
+        0x47500000476,
+        0x47700000478,
+        0x4790000047a,
+        0x47b0000047c,
+        0x47d0000047e,
+        0x47f00000480,
+        0x48100000482,
+        0x48300000488,
+        0x48b0000048c,
+        0x48d0000048e,
+        0x48f00000490,
+        0x49100000492,
+        0x49300000494,
+        0x49500000496,
+        0x49700000498,
+        0x4990000049a,
+        0x49b0000049c,
+        0x49d0000049e,
+        0x49f000004a0,
+        0x4a1000004a2,
+        0x4a3000004a4,
+        0x4a5000004a6,
+        0x4a7000004a8,
+        0x4a9000004aa,
+        0x4ab000004ac,
+        0x4ad000004ae,
+        0x4af000004b0,
+        0x4b1000004b2,
+        0x4b3000004b4,
+        0x4b5000004b6,
+        0x4b7000004b8,
+        0x4b9000004ba,
+        0x4bb000004bc,
+        0x4bd000004be,
+        0x4bf000004c0,
+        0x4c2000004c3,
+        0x4c4000004c5,
+        0x4c6000004c7,
+        0x4c8000004c9,
+        0x4ca000004cb,
+        0x4cc000004cd,
+        0x4ce000004d0,
+        0x4d1000004d2,
+        0x4d3000004d4,
+        0x4d5000004d6,
+        0x4d7000004d8,
+        0x4d9000004da,
+        0x4db000004dc,
+        0x4dd000004de,
+        0x4df000004e0,
+        0x4e1000004e2,
+        0x4e3000004e4,
+        0x4e5000004e6,
+        0x4e7000004e8,
+        0x4e9000004ea,
+        0x4eb000004ec,
+        0x4ed000004ee,
+        0x4ef000004f0,
+        0x4f1000004f2,
+        0x4f3000004f4,
+        0x4f5000004f6,
+        0x4f7000004f8,
+        0x4f9000004fa,
+        0x4fb000004fc,
+        0x4fd000004fe,
+        0x4ff00000500,
+        0x50100000502,
+        0x50300000504,
+        0x50500000506,
+        0x50700000508,
+        0x5090000050a,
+        0x50b0000050c,
+        0x50d0000050e,
+        0x50f00000510,
+        0x51100000512,
+        0x51300000514,
+        0x51500000516,
+        0x51700000518,
+        0x5190000051a,
+        0x51b0000051c,
+        0x51d0000051e,
+        0x51f00000520,
+        0x52100000522,
+        0x52300000524,
+        0x52500000526,
+        0x52700000528,
+        0x5290000052a,
+        0x52b0000052c,
+        0x52d0000052e,
+        0x52f00000530,
+        0x5590000055a,
+        0x56000000587,
+        0x58800000589,
+        0x591000005be,
+        0x5bf000005c0,
+        0x5c1000005c3,
+        0x5c4000005c6,
+        0x5c7000005c8,
+        0x5d0000005eb,
+        0x5ef000005f3,
+        0x6100000061b,
+        0x62000000640,
+        0x64100000660,
+        0x66e00000675,
+        0x679000006d4,
+        0x6d5000006dd,
+        0x6df000006e9,
+        0x6ea000006f0,
+        0x6fa00000700,
+        0x7100000074b,
+        0x74d000007b2,
+        0x7c0000007f6,
+        0x7fd000007fe,
+        0x8000000082e,
+        0x8400000085c,
+        0x8600000086b,
+        0x87000000888,
+        0x8890000088f,
+        0x898000008e2,
+        0x8e300000958,
+        0x96000000964,
+        0x96600000970,
+        0x97100000984,
+        0x9850000098d,
+        0x98f00000991,
+        0x993000009a9,
+        0x9aa000009b1,
+        0x9b2000009b3,
+        0x9b6000009ba,
+        0x9bc000009c5,
+        0x9c7000009c9,
+        0x9cb000009cf,
+        0x9d7000009d8,
+        0x9e0000009e4,
+        0x9e6000009f2,
+        0x9fc000009fd,
+        0x9fe000009ff,
+        0xa0100000a04,
+        0xa0500000a0b,
+        0xa0f00000a11,
+        0xa1300000a29,
+        0xa2a00000a31,
+        0xa3200000a33,
+        0xa3500000a36,
+        0xa3800000a3a,
+        0xa3c00000a3d,
+        0xa3e00000a43,
+        0xa4700000a49,
+        0xa4b00000a4e,
+        0xa5100000a52,
+        0xa5c00000a5d,
+        0xa6600000a76,
+        0xa8100000a84,
+        0xa8500000a8e,
+        0xa8f00000a92,
+        0xa9300000aa9,
+        0xaaa00000ab1,
+        0xab200000ab4,
+        0xab500000aba,
+        0xabc00000ac6,
+        0xac700000aca,
+        0xacb00000ace,
+        0xad000000ad1,
+        0xae000000ae4,
+        0xae600000af0,
+        0xaf900000b00,
+        0xb0100000b04,
+        0xb0500000b0d,
+        0xb0f00000b11,
+        0xb1300000b29,
+        0xb2a00000b31,
+        0xb3200000b34,
+        0xb3500000b3a,
+        0xb3c00000b45,
+        0xb4700000b49,
+        0xb4b00000b4e,
+        0xb5500000b58,
+        0xb5f00000b64,
+        0xb6600000b70,
+        0xb7100000b72,
+        0xb8200000b84,
+        0xb8500000b8b,
+        0xb8e00000b91,
+        0xb9200000b96,
+        0xb9900000b9b,
+        0xb9c00000b9d,
+        0xb9e00000ba0,
+        0xba300000ba5,
+        0xba800000bab,
+        0xbae00000bba,
+        0xbbe00000bc3,
+        0xbc600000bc9,
+        0xbca00000bce,
+        0xbd000000bd1,
+        0xbd700000bd8,
+        0xbe600000bf0,
+        0xc0000000c0d,
+        0xc0e00000c11,
+        0xc1200000c29,
+        0xc2a00000c3a,
+        0xc3c00000c45,
+        0xc4600000c49,
+        0xc4a00000c4e,
+        0xc5500000c57,
+        0xc5800000c5b,
+        0xc5d00000c5e,
+        0xc6000000c64,
+        0xc6600000c70,
+        0xc8000000c84,
+        0xc8500000c8d,
+        0xc8e00000c91,
+        0xc9200000ca9,
+        0xcaa00000cb4,
+        0xcb500000cba,
+        0xcbc00000cc5,
+        0xcc600000cc9,
+        0xcca00000cce,
+        0xcd500000cd7,
+        0xcdd00000cdf,
+        0xce000000ce4,
+        0xce600000cf0,
+        0xcf100000cf3,
+        0xd0000000d0d,
+        0xd0e00000d11,
+        0xd1200000d45,
+        0xd4600000d49,
+        0xd4a00000d4f,
+        0xd5400000d58,
+        0xd5f00000d64,
+        0xd6600000d70,
+        0xd7a00000d80,
+        0xd8100000d84,
+        0xd8500000d97,
+        0xd9a00000db2,
+        0xdb300000dbc,
+        0xdbd00000dbe,
+        0xdc000000dc7,
+        0xdca00000dcb,
+        0xdcf00000dd5,
+        0xdd600000dd7,
+        0xdd800000de0,
+        0xde600000df0,
+        0xdf200000df4,
+        0xe0100000e33,
+        0xe3400000e3b,
+        0xe4000000e4f,
+        0xe5000000e5a,
+        0xe8100000e83,
+        0xe8400000e85,
+        0xe8600000e8b,
+        0xe8c00000ea4,
+        0xea500000ea6,
+        0xea700000eb3,
+        0xeb400000ebe,
+        0xec000000ec5,
+        0xec600000ec7,
+        0xec800000ece,
+        0xed000000eda,
+        0xede00000ee0,
+        0xf0000000f01,
+        0xf0b00000f0c,
+        0xf1800000f1a,
+        0xf2000000f2a,
+        0xf3500000f36,
+        0xf3700000f38,
+        0xf3900000f3a,
+        0xf3e00000f43,
+        0xf4400000f48,
+        0xf4900000f4d,
+        0xf4e00000f52,
+        0xf5300000f57,
+        0xf5800000f5c,
+        0xf5d00000f69,
+        0xf6a00000f6d,
+        0xf7100000f73,
+        0xf7400000f75,
+        0xf7a00000f81,
+        0xf8200000f85,
+        0xf8600000f93,
+        0xf9400000f98,
+        0xf9900000f9d,
+        0xf9e00000fa2,
+        0xfa300000fa7,
+        0xfa800000fac,
+        0xfad00000fb9,
+        0xfba00000fbd,
+        0xfc600000fc7,
+        0x10000000104a,
+        0x10500000109e,
+        0x10d0000010fb,
+        0x10fd00001100,
+        0x120000001249,
+        0x124a0000124e,
+        0x125000001257,
+        0x125800001259,
+        0x125a0000125e,
+        0x126000001289,
+        0x128a0000128e,
+        0x1290000012b1,
+        0x12b2000012b6,
+        0x12b8000012bf,
+        0x12c0000012c1,
+        0x12c2000012c6,
+        0x12c8000012d7,
+        0x12d800001311,
+        0x131200001316,
+        0x13180000135b,
+        0x135d00001360,
+        0x138000001390,
+        0x13a0000013f6,
+        0x14010000166d,
+        0x166f00001680,
+        0x16810000169b,
+        0x16a0000016eb,
+        0x16f1000016f9,
+        0x170000001716,
+        0x171f00001735,
+        0x174000001754,
+        0x17600000176d,
+        0x176e00001771,
+        0x177200001774,
+        0x1780000017b4,
+        0x17b6000017d4,
+        0x17d7000017d8,
+        0x17dc000017de,
+        0x17e0000017ea,
+        0x18100000181a,
+        0x182000001879,
+        0x1880000018ab,
+        0x18b0000018f6,
+        0x19000000191f,
+        0x19200000192c,
+        0x19300000193c,
+        0x19460000196e,
+        0x197000001975,
+        0x1980000019ac,
+        0x19b0000019ca,
+        0x19d0000019da,
+        0x1a0000001a1c,
+        0x1a2000001a5f,
+        0x1a6000001a7d,
+        0x1a7f00001a8a,
+        0x1a9000001a9a,
+        0x1aa700001aa8,
+        0x1ab000001abe,
+        0x1abf00001acf,
+        0x1b0000001b4d,
+        0x1b5000001b5a,
+        0x1b6b00001b74,
+        0x1b8000001bf4,
+        0x1c0000001c38,
+        0x1c4000001c4a,
+        0x1c4d00001c7e,
+        0x1cd000001cd3,
+        0x1cd400001cfb,
+        0x1d0000001d2c,
+        0x1d2f00001d30,
+        0x1d3b00001d3c,
+        0x1d4e00001d4f,
+        0x1d6b00001d78,
+        0x1d7900001d9b,
+        0x1dc000001e00,
+        0x1e0100001e02,
+        0x1e0300001e04,
+        0x1e0500001e06,
+        0x1e0700001e08,
+        0x1e0900001e0a,
+        0x1e0b00001e0c,
+        0x1e0d00001e0e,
+        0x1e0f00001e10,
+        0x1e1100001e12,
+        0x1e1300001e14,
+        0x1e1500001e16,
+        0x1e1700001e18,
+        0x1e1900001e1a,
+        0x1e1b00001e1c,
+        0x1e1d00001e1e,
+        0x1e1f00001e20,
+        0x1e2100001e22,
+        0x1e2300001e24,
+        0x1e2500001e26,
+        0x1e2700001e28,
+        0x1e2900001e2a,
+        0x1e2b00001e2c,
+        0x1e2d00001e2e,
+        0x1e2f00001e30,
+        0x1e3100001e32,
+        0x1e3300001e34,
+        0x1e3500001e36,
+        0x1e3700001e38,
+        0x1e3900001e3a,
+        0x1e3b00001e3c,
+        0x1e3d00001e3e,
+        0x1e3f00001e40,
+        0x1e4100001e42,
+        0x1e4300001e44,
+        0x1e4500001e46,
+        0x1e4700001e48,
+        0x1e4900001e4a,
+        0x1e4b00001e4c,
+        0x1e4d00001e4e,
+        0x1e4f00001e50,
+        0x1e5100001e52,
+        0x1e5300001e54,
+        0x1e5500001e56,
+        0x1e5700001e58,
+        0x1e5900001e5a,
+        0x1e5b00001e5c,
+        0x1e5d00001e5e,
+        0x1e5f00001e60,
+        0x1e6100001e62,
+        0x1e6300001e64,
+        0x1e6500001e66,
+        0x1e6700001e68,
+        0x1e6900001e6a,
+        0x1e6b00001e6c,
+        0x1e6d00001e6e,
+        0x1e6f00001e70,
+        0x1e7100001e72,
+        0x1e7300001e74,
+        0x1e7500001e76,
+        0x1e7700001e78,
+        0x1e7900001e7a,
+        0x1e7b00001e7c,
+        0x1e7d00001e7e,
+        0x1e7f00001e80,
+        0x1e8100001e82,
+        0x1e8300001e84,
+        0x1e8500001e86,
+        0x1e8700001e88,
+        0x1e8900001e8a,
+        0x1e8b00001e8c,
+        0x1e8d00001e8e,
+        0x1e8f00001e90,
+        0x1e9100001e92,
+        0x1e9300001e94,
+        0x1e9500001e9a,
+        0x1e9c00001e9e,
+        0x1e9f00001ea0,
+        0x1ea100001ea2,
+        0x1ea300001ea4,
+        0x1ea500001ea6,
+        0x1ea700001ea8,
+        0x1ea900001eaa,
+        0x1eab00001eac,
+        0x1ead00001eae,
+        0x1eaf00001eb0,
+        0x1eb100001eb2,
+        0x1eb300001eb4,
+        0x1eb500001eb6,
+        0x1eb700001eb8,
+        0x1eb900001eba,
+        0x1ebb00001ebc,
+        0x1ebd00001ebe,
+        0x1ebf00001ec0,
+        0x1ec100001ec2,
+        0x1ec300001ec4,
+        0x1ec500001ec6,
+        0x1ec700001ec8,
+        0x1ec900001eca,
+        0x1ecb00001ecc,
+        0x1ecd00001ece,
+        0x1ecf00001ed0,
+        0x1ed100001ed2,
+        0x1ed300001ed4,
+        0x1ed500001ed6,
+        0x1ed700001ed8,
+        0x1ed900001eda,
+        0x1edb00001edc,
+        0x1edd00001ede,
+        0x1edf00001ee0,
+        0x1ee100001ee2,
+        0x1ee300001ee4,
+        0x1ee500001ee6,
+        0x1ee700001ee8,
+        0x1ee900001eea,
+        0x1eeb00001eec,
+        0x1eed00001eee,
+        0x1eef00001ef0,
+        0x1ef100001ef2,
+        0x1ef300001ef4,
+        0x1ef500001ef6,
+        0x1ef700001ef8,
+        0x1ef900001efa,
+        0x1efb00001efc,
+        0x1efd00001efe,
+        0x1eff00001f08,
+        0x1f1000001f16,
+        0x1f2000001f28,
+        0x1f3000001f38,
+        0x1f4000001f46,
+        0x1f5000001f58,
+        0x1f6000001f68,
+        0x1f7000001f71,
+        0x1f7200001f73,
+        0x1f7400001f75,
+        0x1f7600001f77,
+        0x1f7800001f79,
+        0x1f7a00001f7b,
+        0x1f7c00001f7d,
+        0x1fb000001fb2,
+        0x1fb600001fb7,
+        0x1fc600001fc7,
+        0x1fd000001fd3,
+        0x1fd600001fd8,
+        0x1fe000001fe3,
+        0x1fe400001fe8,
+        0x1ff600001ff7,
+        0x214e0000214f,
+        0x218400002185,
+        0x2c3000002c60,
+        0x2c6100002c62,
+        0x2c6500002c67,
+        0x2c6800002c69,
+        0x2c6a00002c6b,
+        0x2c6c00002c6d,
+        0x2c7100002c72,
+        0x2c7300002c75,
+        0x2c7600002c7c,
+        0x2c8100002c82,
+        0x2c8300002c84,
+        0x2c8500002c86,
+        0x2c8700002c88,
+        0x2c8900002c8a,
+        0x2c8b00002c8c,
+        0x2c8d00002c8e,
+        0x2c8f00002c90,
+        0x2c9100002c92,
+        0x2c9300002c94,
+        0x2c9500002c96,
+        0x2c9700002c98,
+        0x2c9900002c9a,
+        0x2c9b00002c9c,
+        0x2c9d00002c9e,
+        0x2c9f00002ca0,
+        0x2ca100002ca2,
+        0x2ca300002ca4,
+        0x2ca500002ca6,
+        0x2ca700002ca8,
+        0x2ca900002caa,
+        0x2cab00002cac,
+        0x2cad00002cae,
+        0x2caf00002cb0,
+        0x2cb100002cb2,
+        0x2cb300002cb4,
+        0x2cb500002cb6,
+        0x2cb700002cb8,
+        0x2cb900002cba,
+        0x2cbb00002cbc,
+        0x2cbd00002cbe,
+        0x2cbf00002cc0,
+        0x2cc100002cc2,
+        0x2cc300002cc4,
+        0x2cc500002cc6,
+        0x2cc700002cc8,
+        0x2cc900002cca,
+        0x2ccb00002ccc,
+        0x2ccd00002cce,
+        0x2ccf00002cd0,
+        0x2cd100002cd2,
+        0x2cd300002cd4,
+        0x2cd500002cd6,
+        0x2cd700002cd8,
+        0x2cd900002cda,
+        0x2cdb00002cdc,
+        0x2cdd00002cde,
+        0x2cdf00002ce0,
+        0x2ce100002ce2,
+        0x2ce300002ce5,
+        0x2cec00002ced,
+        0x2cee00002cf2,
+        0x2cf300002cf4,
+        0x2d0000002d26,
+        0x2d2700002d28,
+        0x2d2d00002d2e,
+        0x2d3000002d68,
+        0x2d7f00002d97,
+        0x2da000002da7,
+        0x2da800002daf,
+        0x2db000002db7,
+        0x2db800002dbf,
+        0x2dc000002dc7,
+        0x2dc800002dcf,
+        0x2dd000002dd7,
+        0x2dd800002ddf,
+        0x2de000002e00,
+        0x2e2f00002e30,
+        0x300500003008,
+        0x302a0000302e,
+        0x303c0000303d,
+        0x304100003097,
+        0x30990000309b,
+        0x309d0000309f,
+        0x30a1000030fb,
+        0x30fc000030ff,
+        0x310500003130,
+        0x31a0000031c0,
+        0x31f000003200,
+        0x340000004dc0,
+        0x4e000000a48d,
+        0xa4d00000a4fe,
+        0xa5000000a60d,
+        0xa6100000a62c,
+        0xa6410000a642,
+        0xa6430000a644,
+        0xa6450000a646,
+        0xa6470000a648,
+        0xa6490000a64a,
+        0xa64b0000a64c,
+        0xa64d0000a64e,
+        0xa64f0000a650,
+        0xa6510000a652,
+        0xa6530000a654,
+        0xa6550000a656,
+        0xa6570000a658,
+        0xa6590000a65a,
+        0xa65b0000a65c,
+        0xa65d0000a65e,
+        0xa65f0000a660,
+        0xa6610000a662,
+        0xa6630000a664,
+        0xa6650000a666,
+        0xa6670000a668,
+        0xa6690000a66a,
+        0xa66b0000a66c,
+        0xa66d0000a670,
+        0xa6740000a67e,
+        0xa67f0000a680,
+        0xa6810000a682,
+        0xa6830000a684,
+        0xa6850000a686,
+        0xa6870000a688,
+        0xa6890000a68a,
+        0xa68b0000a68c,
+        0xa68d0000a68e,
+        0xa68f0000a690,
+        0xa6910000a692,
+        0xa6930000a694,
+        0xa6950000a696,
+        0xa6970000a698,
+        0xa6990000a69a,
+        0xa69b0000a69c,
+        0xa69e0000a6e6,
+        0xa6f00000a6f2,
+        0xa7170000a720,
+        0xa7230000a724,
+        0xa7250000a726,
+        0xa7270000a728,
+        0xa7290000a72a,
+        0xa72b0000a72c,
+        0xa72d0000a72e,
+        0xa72f0000a732,
+        0xa7330000a734,
+        0xa7350000a736,
+        0xa7370000a738,
+        0xa7390000a73a,
+        0xa73b0000a73c,
+        0xa73d0000a73e,
+        0xa73f0000a740,
+        0xa7410000a742,
+        0xa7430000a744,
+        0xa7450000a746,
+        0xa7470000a748,
+        0xa7490000a74a,
+        0xa74b0000a74c,
+        0xa74d0000a74e,
+        0xa74f0000a750,
+        0xa7510000a752,
+        0xa7530000a754,
+        0xa7550000a756,
+        0xa7570000a758,
+        0xa7590000a75a,
+        0xa75b0000a75c,
+        0xa75d0000a75e,
+        0xa75f0000a760,
+        0xa7610000a762,
+        0xa7630000a764,
+        0xa7650000a766,
+        0xa7670000a768,
+        0xa7690000a76a,
+        0xa76b0000a76c,
+        0xa76d0000a76e,
+        0xa76f0000a770,
+        0xa7710000a779,
+        0xa77a0000a77b,
+        0xa77c0000a77d,
+        0xa77f0000a780,
+        0xa7810000a782,
+        0xa7830000a784,
+        0xa7850000a786,
+        0xa7870000a789,
+        0xa78c0000a78d,
+        0xa78e0000a790,
+        0xa7910000a792,
+        0xa7930000a796,
+        0xa7970000a798,
+        0xa7990000a79a,
+        0xa79b0000a79c,
+        0xa79d0000a79e,
+        0xa79f0000a7a0,
+        0xa7a10000a7a2,
+        0xa7a30000a7a4,
+        0xa7a50000a7a6,
+        0xa7a70000a7a8,
+        0xa7a90000a7aa,
+        0xa7af0000a7b0,
+        0xa7b50000a7b6,
+        0xa7b70000a7b8,
+        0xa7b90000a7ba,
+        0xa7bb0000a7bc,
+        0xa7bd0000a7be,
+        0xa7bf0000a7c0,
+        0xa7c10000a7c2,
+        0xa7c30000a7c4,
+        0xa7c80000a7c9,
+        0xa7ca0000a7cb,
+        0xa7d10000a7d2,
+        0xa7d30000a7d4,
+        0xa7d50000a7d6,
+        0xa7d70000a7d8,
+        0xa7d90000a7da,
+        0xa7f20000a7f5,
+        0xa7f60000a7f8,
+        0xa7fa0000a828,
+        0xa82c0000a82d,
+        0xa8400000a874,
+        0xa8800000a8c6,
+        0xa8d00000a8da,
+        0xa8e00000a8f8,
+        0xa8fb0000a8fc,
+        0xa8fd0000a92e,
+        0xa9300000a954,
+        0xa9800000a9c1,
+        0xa9cf0000a9da,
+        0xa9e00000a9ff,
+        0xaa000000aa37,
+        0xaa400000aa4e,
+        0xaa500000aa5a,
+        0xaa600000aa77,
+        0xaa7a0000aac3,
+        0xaadb0000aade,
+        0xaae00000aaf0,
+        0xaaf20000aaf7,
+        0xab010000ab07,
+        0xab090000ab0f,
+        0xab110000ab17,
+        0xab200000ab27,
+        0xab280000ab2f,
+        0xab300000ab5b,
+        0xab600000ab6a,
+        0xabc00000abeb,
+        0xabec0000abee,
+        0xabf00000abfa,
+        0xac000000d7a4,
+        0xfa0e0000fa10,
+        0xfa110000fa12,
+        0xfa130000fa15,
+        0xfa1f0000fa20,
+        0xfa210000fa22,
+        0xfa230000fa25,
+        0xfa270000fa2a,
+        0xfb1e0000fb1f,
+        0xfe200000fe30,
+        0xfe730000fe74,
+        0x100000001000c,
+        0x1000d00010027,
+        0x100280001003b,
+        0x1003c0001003e,
+        0x1003f0001004e,
+        0x100500001005e,
+        0x10080000100fb,
+        0x101fd000101fe,
+        0x102800001029d,
+        0x102a0000102d1,
+        0x102e0000102e1,
+        0x1030000010320,
+        0x1032d00010341,
+        0x103420001034a,
+        0x103500001037b,
+        0x103800001039e,
+        0x103a0000103c4,
+        0x103c8000103d0,
+        0x104280001049e,
+        0x104a0000104aa,
+        0x104d8000104fc,
+        0x1050000010528,
+        0x1053000010564,
+        0x10597000105a2,
+        0x105a3000105b2,
+        0x105b3000105ba,
+        0x105bb000105bd,
+        0x1060000010737,
+        0x1074000010756,
+        0x1076000010768,
+        0x1078000010786,
+        0x10787000107b1,
+        0x107b2000107bb,
+        0x1080000010806,
+        0x1080800010809,
+        0x1080a00010836,
+        0x1083700010839,
+        0x1083c0001083d,
+        0x1083f00010856,
+        0x1086000010877,
+        0x108800001089f,
+        0x108e0000108f3,
+        0x108f4000108f6,
+        0x1090000010916,
+        0x109200001093a,
+        0x10980000109b8,
+        0x109be000109c0,
+        0x10a0000010a04,
+        0x10a0500010a07,
+        0x10a0c00010a14,
+        0x10a1500010a18,
+        0x10a1900010a36,
+        0x10a3800010a3b,
+        0x10a3f00010a40,
+        0x10a6000010a7d,
+        0x10a8000010a9d,
+        0x10ac000010ac8,
+        0x10ac900010ae7,
+        0x10b0000010b36,
+        0x10b4000010b56,
+        0x10b6000010b73,
+        0x10b8000010b92,
+        0x10c0000010c49,
+        0x10cc000010cf3,
+        0x10d0000010d28,
+        0x10d3000010d3a,
+        0x10e8000010eaa,
+        0x10eab00010ead,
+        0x10eb000010eb2,
+        0x10f0000010f1d,
+        0x10f2700010f28,
+        0x10f3000010f51,
+        0x10f7000010f86,
+        0x10fb000010fc5,
+        0x10fe000010ff7,
+        0x1100000011047,
+        0x1106600011076,
+        0x1107f000110bb,
+        0x110c2000110c3,
+        0x110d0000110e9,
+        0x110f0000110fa,
+        0x1110000011135,
+        0x1113600011140,
+        0x1114400011148,
+        0x1115000011174,
+        0x1117600011177,
+        0x11180000111c5,
+        0x111c9000111cd,
+        0x111ce000111db,
+        0x111dc000111dd,
+        0x1120000011212,
+        0x1121300011238,
+        0x1123e0001123f,
+        0x1128000011287,
+        0x1128800011289,
+        0x1128a0001128e,
+        0x1128f0001129e,
+        0x1129f000112a9,
+        0x112b0000112eb,
+        0x112f0000112fa,
+        0x1130000011304,
+        0x113050001130d,
+        0x1130f00011311,
+        0x1131300011329,
+        0x1132a00011331,
+        0x1133200011334,
+        0x113350001133a,
+        0x1133b00011345,
+        0x1134700011349,
+        0x1134b0001134e,
+        0x1135000011351,
+        0x1135700011358,
+        0x1135d00011364,
+        0x113660001136d,
+        0x1137000011375,
+        0x114000001144b,
+        0x114500001145a,
+        0x1145e00011462,
+        0x11480000114c6,
+        0x114c7000114c8,
+        0x114d0000114da,
+        0x11580000115b6,
+        0x115b8000115c1,
+        0x115d8000115de,
+        0x1160000011641,
+        0x1164400011645,
+        0x116500001165a,
+        0x11680000116b9,
+        0x116c0000116ca,
+        0x117000001171b,
+        0x1171d0001172c,
+        0x117300001173a,
+        0x1174000011747,
+        0x118000001183b,
+        0x118c0000118ea,
+        0x118ff00011907,
+        0x119090001190a,
+        0x1190c00011914,
+        0x1191500011917,
+        0x1191800011936,
+        0x1193700011939,
+        0x1193b00011944,
+        0x119500001195a,
+        0x119a0000119a8,
+        0x119aa000119d8,
+        0x119da000119e2,
+        0x119e3000119e5,
+        0x11a0000011a3f,
+        0x11a4700011a48,
+        0x11a5000011a9a,
+        0x11a9d00011a9e,
+        0x11ab000011af9,
+        0x11c0000011c09,
+        0x11c0a00011c37,
+        0x11c3800011c41,
+        0x11c5000011c5a,
+        0x11c7200011c90,
+        0x11c9200011ca8,
+        0x11ca900011cb7,
+        0x11d0000011d07,
+        0x11d0800011d0a,
+        0x11d0b00011d37,
+        0x11d3a00011d3b,
+        0x11d3c00011d3e,
+        0x11d3f00011d48,
+        0x11d5000011d5a,
+        0x11d6000011d66,
+        0x11d6700011d69,
+        0x11d6a00011d8f,
+        0x11d9000011d92,
+        0x11d9300011d99,
+        0x11da000011daa,
+        0x11ee000011ef7,
+        0x11fb000011fb1,
+        0x120000001239a,
+        0x1248000012544,
+        0x12f9000012ff1,
+        0x130000001342f,
+        0x1440000014647,
+        0x1680000016a39,
+        0x16a4000016a5f,
+        0x16a6000016a6a,
+        0x16a7000016abf,
+        0x16ac000016aca,
+        0x16ad000016aee,
+        0x16af000016af5,
+        0x16b0000016b37,
+        0x16b4000016b44,
+        0x16b5000016b5a,
+        0x16b6300016b78,
+        0x16b7d00016b90,
+        0x16e6000016e80,
+        0x16f0000016f4b,
+        0x16f4f00016f88,
+        0x16f8f00016fa0,
+        0x16fe000016fe2,
+        0x16fe300016fe5,
+        0x16ff000016ff2,
+        0x17000000187f8,
+        0x1880000018cd6,
+        0x18d0000018d09,
+        0x1aff00001aff4,
+        0x1aff50001affc,
+        0x1affd0001afff,
+        0x1b0000001b123,
+        0x1b1500001b153,
+        0x1b1640001b168,
+        0x1b1700001b2fc,
+        0x1bc000001bc6b,
+        0x1bc700001bc7d,
+        0x1bc800001bc89,
+        0x1bc900001bc9a,
+        0x1bc9d0001bc9f,
+        0x1cf000001cf2e,
+        0x1cf300001cf47,
+        0x1da000001da37,
+        0x1da3b0001da6d,
+        0x1da750001da76,
+        0x1da840001da85,
+        0x1da9b0001daa0,
+        0x1daa10001dab0,
+        0x1df000001df1f,
+        0x1e0000001e007,
+        0x1e0080001e019,
+        0x1e01b0001e022,
+        0x1e0230001e025,
+        0x1e0260001e02b,
+        0x1e1000001e12d,
+        0x1e1300001e13e,
+        0x1e1400001e14a,
+        0x1e14e0001e14f,
+        0x1e2900001e2af,
+        0x1e2c00001e2fa,
+        0x1e7e00001e7e7,
+        0x1e7e80001e7ec,
+        0x1e7ed0001e7ef,
+        0x1e7f00001e7ff,
+        0x1e8000001e8c5,
+        0x1e8d00001e8d7,
+        0x1e9220001e94c,
+        0x1e9500001e95a,
+        0x1fbf00001fbfa,
+        0x200000002a6e0,
+        0x2a7000002b739,
+        0x2b7400002b81e,
+        0x2b8200002cea2,
+        0x2ceb00002ebe1,
+        0x300000003134b,
+    ),
+    'CONTEXTJ': (
+        0x200c0000200e,
+    ),
+    'CONTEXTO': (
+        0xb7000000b8,
+        0x37500000376,
+        0x5f3000005f5,
+        0x6600000066a,
+        0x6f0000006fa,
+        0x30fb000030fc,
+    ),
+}
diff --git a/myenv/lib/python3.9/site-packages/idna/intranges.py b/myenv/lib/python3.9/site-packages/idna/intranges.py
new file mode 100644
index 0000000..6a43b04
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna/intranges.py
@@ -0,0 +1,54 @@
+"""
+Given a list of integers, made up of (hopefully) a small number of long runs
+of consecutive integers, compute a representation of the form
+((start1, end1), (start2, end2) ...). Then answer the question "was x present
+in the original list?" in time O(log(# runs)).
+"""
+
+import bisect
+from typing import List, Tuple
+
+def intranges_from_list(list_: List[int]) -> Tuple[int, ...]:
+    """Represent a list of integers as a sequence of ranges:
+    ((start_0, end_0), (start_1, end_1), ...), such that the original
+    integers are exactly those x such that start_i <= x < end_i for some i.
+
+    Ranges are encoded as single integers (start << 32 | end), not as tuples.
+    """
+
+    sorted_list = sorted(list_)
+    ranges = []
+    last_write = -1
+    for i in range(len(sorted_list)):
+        if i+1 < len(sorted_list):
+            if sorted_list[i] == sorted_list[i+1]-1:
+                continue
+        current_range = sorted_list[last_write+1:i+1]
+        ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
+        last_write = i
+
+    return tuple(ranges)
+
+def _encode_range(start: int, end: int) -> int:
+    return (start << 32) | end
+
+def _decode_range(r: int) -> Tuple[int, int]:
+    return (r >> 32), (r & ((1 << 32) - 1))
+
+
+def intranges_contain(int_: int, ranges: Tuple[int, ...]) -> bool:
+    """Determine if `int_` falls into one of the ranges in `ranges`."""
+    tuple_ = _encode_range(int_, 0)
+    pos = bisect.bisect_left(ranges, tuple_)
+    # we could be immediately ahead of a tuple (start, end)
+    # with start < int_ <= end
+    if pos > 0:
+        left, right = _decode_range(ranges[pos-1])
+        if left <= int_ < right:
+            return True
+    # or we could be immediately behind a tuple (int_, end)
+    if pos < len(ranges):
+        left, _ = _decode_range(ranges[pos])
+        if left == int_:
+            return True
+    return False
diff --git a/myenv/lib/python3.9/site-packages/idna/package_data.py b/myenv/lib/python3.9/site-packages/idna/package_data.py
new file mode 100644
index 0000000..f5ea87c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna/package_data.py
@@ -0,0 +1,2 @@
+__version__ = '3.3'
+
diff --git a/myenv/lib/python3.9/site-packages/idna/py.typed b/myenv/lib/python3.9/site-packages/idna/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/idna/uts46data.py b/myenv/lib/python3.9/site-packages/idna/uts46data.py
new file mode 100644
index 0000000..8f65705
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/idna/uts46data.py
@@ -0,0 +1,8512 @@
+# This file is automatically generated by tools/idna-data
+# vim: set fileencoding=utf-8 :
+
+from typing import List, Tuple, Union
+
+
+"""IDNA Mapping Table from UTS46."""
+
+
+__version__ = '14.0.0'
+def _seg_0() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x0, '3'),
+    (0x1, '3'),
+    (0x2, '3'),
+    (0x3, '3'),
+    (0x4, '3'),
+    (0x5, '3'),
+    (0x6, '3'),
+    (0x7, '3'),
+    (0x8, '3'),
+    (0x9, '3'),
+    (0xA, '3'),
+    (0xB, '3'),
+    (0xC, '3'),
+    (0xD, '3'),
+    (0xE, '3'),
+    (0xF, '3'),
+    (0x10, '3'),
+    (0x11, '3'),
+    (0x12, '3'),
+    (0x13, '3'),
+    (0x14, '3'),
+    (0x15, '3'),
+    (0x16, '3'),
+    (0x17, '3'),
+    (0x18, '3'),
+    (0x19, '3'),
+    (0x1A, '3'),
+    (0x1B, '3'),
+    (0x1C, '3'),
+    (0x1D, '3'),
+    (0x1E, '3'),
+    (0x1F, '3'),
+    (0x20, '3'),
+    (0x21, '3'),
+    (0x22, '3'),
+    (0x23, '3'),
+    (0x24, '3'),
+    (0x25, '3'),
+    (0x26, '3'),
+    (0x27, '3'),
+    (0x28, '3'),
+    (0x29, '3'),
+    (0x2A, '3'),
+    (0x2B, '3'),
+    (0x2C, '3'),
+    (0x2D, 'V'),
+    (0x2E, 'V'),
+    (0x2F, '3'),
+    (0x30, 'V'),
+    (0x31, 'V'),
+    (0x32, 'V'),
+    (0x33, 'V'),
+    (0x34, 'V'),
+    (0x35, 'V'),
+    (0x36, 'V'),
+    (0x37, 'V'),
+    (0x38, 'V'),
+    (0x39, 'V'),
+    (0x3A, '3'),
+    (0x3B, '3'),
+    (0x3C, '3'),
+    (0x3D, '3'),
+    (0x3E, '3'),
+    (0x3F, '3'),
+    (0x40, '3'),
+    (0x41, 'M', 'a'),
+    (0x42, 'M', 'b'),
+    (0x43, 'M', 'c'),
+    (0x44, 'M', 'd'),
+    (0x45, 'M', 'e'),
+    (0x46, 'M', 'f'),
+    (0x47, 'M', 'g'),
+    (0x48, 'M', 'h'),
+    (0x49, 'M', 'i'),
+    (0x4A, 'M', 'j'),
+    (0x4B, 'M', 'k'),
+    (0x4C, 'M', 'l'),
+    (0x4D, 'M', 'm'),
+    (0x4E, 'M', 'n'),
+    (0x4F, 'M', 'o'),
+    (0x50, 'M', 'p'),
+    (0x51, 'M', 'q'),
+    (0x52, 'M', 'r'),
+    (0x53, 'M', 's'),
+    (0x54, 'M', 't'),
+    (0x55, 'M', 'u'),
+    (0x56, 'M', 'v'),
+    (0x57, 'M', 'w'),
+    (0x58, 'M', 'x'),
+    (0x59, 'M', 'y'),
+    (0x5A, 'M', 'z'),
+    (0x5B, '3'),
+    (0x5C, '3'),
+    (0x5D, '3'),
+    (0x5E, '3'),
+    (0x5F, '3'),
+    (0x60, '3'),
+    (0x61, 'V'),
+    (0x62, 'V'),
+    (0x63, 'V'),
+    ]
+
+def _seg_1() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x64, 'V'),
+    (0x65, 'V'),
+    (0x66, 'V'),
+    (0x67, 'V'),
+    (0x68, 'V'),
+    (0x69, 'V'),
+    (0x6A, 'V'),
+    (0x6B, 'V'),
+    (0x6C, 'V'),
+    (0x6D, 'V'),
+    (0x6E, 'V'),
+    (0x6F, 'V'),
+    (0x70, 'V'),
+    (0x71, 'V'),
+    (0x72, 'V'),
+    (0x73, 'V'),
+    (0x74, 'V'),
+    (0x75, 'V'),
+    (0x76, 'V'),
+    (0x77, 'V'),
+    (0x78, 'V'),
+    (0x79, 'V'),
+    (0x7A, 'V'),
+    (0x7B, '3'),
+    (0x7C, '3'),
+    (0x7D, '3'),
+    (0x7E, '3'),
+    (0x7F, '3'),
+    (0x80, 'X'),
+    (0x81, 'X'),
+    (0x82, 'X'),
+    (0x83, 'X'),
+    (0x84, 'X'),
+    (0x85, 'X'),
+    (0x86, 'X'),
+    (0x87, 'X'),
+    (0x88, 'X'),
+    (0x89, 'X'),
+    (0x8A, 'X'),
+    (0x8B, 'X'),
+    (0x8C, 'X'),
+    (0x8D, 'X'),
+    (0x8E, 'X'),
+    (0x8F, 'X'),
+    (0x90, 'X'),
+    (0x91, 'X'),
+    (0x92, 'X'),
+    (0x93, 'X'),
+    (0x94, 'X'),
+    (0x95, 'X'),
+    (0x96, 'X'),
+    (0x97, 'X'),
+    (0x98, 'X'),
+    (0x99, 'X'),
+    (0x9A, 'X'),
+    (0x9B, 'X'),
+    (0x9C, 'X'),
+    (0x9D, 'X'),
+    (0x9E, 'X'),
+    (0x9F, 'X'),
+    (0xA0, '3', ' '),
+    (0xA1, 'V'),
+    (0xA2, 'V'),
+    (0xA3, 'V'),
+    (0xA4, 'V'),
+    (0xA5, 'V'),
+    (0xA6, 'V'),
+    (0xA7, 'V'),
+    (0xA8, '3', ' ̈'),
+    (0xA9, 'V'),
+    (0xAA, 'M', 'a'),
+    (0xAB, 'V'),
+    (0xAC, 'V'),
+    (0xAD, 'I'),
+    (0xAE, 'V'),
+    (0xAF, '3', ' ̄'),
+    (0xB0, 'V'),
+    (0xB1, 'V'),
+    (0xB2, 'M', '2'),
+    (0xB3, 'M', '3'),
+    (0xB4, '3', ' ́'),
+    (0xB5, 'M', 'μ'),
+    (0xB6, 'V'),
+    (0xB7, 'V'),
+    (0xB8, '3', ' ̧'),
+    (0xB9, 'M', '1'),
+    (0xBA, 'M', 'o'),
+    (0xBB, 'V'),
+    (0xBC, 'M', '1⁄4'),
+    (0xBD, 'M', '1⁄2'),
+    (0xBE, 'M', '3⁄4'),
+    (0xBF, 'V'),
+    (0xC0, 'M', 'à'),
+    (0xC1, 'M', 'á'),
+    (0xC2, 'M', 'â'),
+    (0xC3, 'M', 'ã'),
+    (0xC4, 'M', 'ä'),
+    (0xC5, 'M', 'å'),
+    (0xC6, 'M', 'æ'),
+    (0xC7, 'M', 'ç'),
+    ]
+
+def _seg_2() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xC8, 'M', 'è'),
+    (0xC9, 'M', 'é'),
+    (0xCA, 'M', 'ê'),
+    (0xCB, 'M', 'ë'),
+    (0xCC, 'M', 'ì'),
+    (0xCD, 'M', 'í'),
+    (0xCE, 'M', 'î'),
+    (0xCF, 'M', 'ï'),
+    (0xD0, 'M', 'ð'),
+    (0xD1, 'M', 'ñ'),
+    (0xD2, 'M', 'ò'),
+    (0xD3, 'M', 'ó'),
+    (0xD4, 'M', 'ô'),
+    (0xD5, 'M', 'õ'),
+    (0xD6, 'M', 'ö'),
+    (0xD7, 'V'),
+    (0xD8, 'M', 'ø'),
+    (0xD9, 'M', 'ù'),
+    (0xDA, 'M', 'ú'),
+    (0xDB, 'M', 'û'),
+    (0xDC, 'M', 'ü'),
+    (0xDD, 'M', 'ý'),
+    (0xDE, 'M', 'þ'),
+    (0xDF, 'D', 'ss'),
+    (0xE0, 'V'),
+    (0xE1, 'V'),
+    (0xE2, 'V'),
+    (0xE3, 'V'),
+    (0xE4, 'V'),
+    (0xE5, 'V'),
+    (0xE6, 'V'),
+    (0xE7, 'V'),
+    (0xE8, 'V'),
+    (0xE9, 'V'),
+    (0xEA, 'V'),
+    (0xEB, 'V'),
+    (0xEC, 'V'),
+    (0xED, 'V'),
+    (0xEE, 'V'),
+    (0xEF, 'V'),
+    (0xF0, 'V'),
+    (0xF1, 'V'),
+    (0xF2, 'V'),
+    (0xF3, 'V'),
+    (0xF4, 'V'),
+    (0xF5, 'V'),
+    (0xF6, 'V'),
+    (0xF7, 'V'),
+    (0xF8, 'V'),
+    (0xF9, 'V'),
+    (0xFA, 'V'),
+    (0xFB, 'V'),
+    (0xFC, 'V'),
+    (0xFD, 'V'),
+    (0xFE, 'V'),
+    (0xFF, 'V'),
+    (0x100, 'M', 'ā'),
+    (0x101, 'V'),
+    (0x102, 'M', 'ă'),
+    (0x103, 'V'),
+    (0x104, 'M', 'ą'),
+    (0x105, 'V'),
+    (0x106, 'M', 'ć'),
+    (0x107, 'V'),
+    (0x108, 'M', 'ĉ'),
+    (0x109, 'V'),
+    (0x10A, 'M', 'ċ'),
+    (0x10B, 'V'),
+    (0x10C, 'M', 'č'),
+    (0x10D, 'V'),
+    (0x10E, 'M', 'ď'),
+    (0x10F, 'V'),
+    (0x110, 'M', 'đ'),
+    (0x111, 'V'),
+    (0x112, 'M', 'ē'),
+    (0x113, 'V'),
+    (0x114, 'M', 'ĕ'),
+    (0x115, 'V'),
+    (0x116, 'M', 'ė'),
+    (0x117, 'V'),
+    (0x118, 'M', 'ę'),
+    (0x119, 'V'),
+    (0x11A, 'M', 'ě'),
+    (0x11B, 'V'),
+    (0x11C, 'M', 'ĝ'),
+    (0x11D, 'V'),
+    (0x11E, 'M', 'ğ'),
+    (0x11F, 'V'),
+    (0x120, 'M', 'ġ'),
+    (0x121, 'V'),
+    (0x122, 'M', 'ģ'),
+    (0x123, 'V'),
+    (0x124, 'M', 'ĥ'),
+    (0x125, 'V'),
+    (0x126, 'M', 'ħ'),
+    (0x127, 'V'),
+    (0x128, 'M', 'ĩ'),
+    (0x129, 'V'),
+    (0x12A, 'M', 'ī'),
+    (0x12B, 'V'),
+    ]
+
+def _seg_3() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x12C, 'M', 'ĭ'),
+    (0x12D, 'V'),
+    (0x12E, 'M', 'į'),
+    (0x12F, 'V'),
+    (0x130, 'M', 'i̇'),
+    (0x131, 'V'),
+    (0x132, 'M', 'ij'),
+    (0x134, 'M', 'ĵ'),
+    (0x135, 'V'),
+    (0x136, 'M', 'ķ'),
+    (0x137, 'V'),
+    (0x139, 'M', 'ĺ'),
+    (0x13A, 'V'),
+    (0x13B, 'M', 'ļ'),
+    (0x13C, 'V'),
+    (0x13D, 'M', 'ľ'),
+    (0x13E, 'V'),
+    (0x13F, 'M', 'l·'),
+    (0x141, 'M', 'ł'),
+    (0x142, 'V'),
+    (0x143, 'M', 'ń'),
+    (0x144, 'V'),
+    (0x145, 'M', 'ņ'),
+    (0x146, 'V'),
+    (0x147, 'M', 'ň'),
+    (0x148, 'V'),
+    (0x149, 'M', 'ʼn'),
+    (0x14A, 'M', 'ŋ'),
+    (0x14B, 'V'),
+    (0x14C, 'M', 'ō'),
+    (0x14D, 'V'),
+    (0x14E, 'M', 'ŏ'),
+    (0x14F, 'V'),
+    (0x150, 'M', 'ő'),
+    (0x151, 'V'),
+    (0x152, 'M', 'œ'),
+    (0x153, 'V'),
+    (0x154, 'M', 'ŕ'),
+    (0x155, 'V'),
+    (0x156, 'M', 'ŗ'),
+    (0x157, 'V'),
+    (0x158, 'M', 'ř'),
+    (0x159, 'V'),
+    (0x15A, 'M', 'ś'),
+    (0x15B, 'V'),
+    (0x15C, 'M', 'ŝ'),
+    (0x15D, 'V'),
+    (0x15E, 'M', 'ş'),
+    (0x15F, 'V'),
+    (0x160, 'M', 'š'),
+    (0x161, 'V'),
+    (0x162, 'M', 'ţ'),
+    (0x163, 'V'),
+    (0x164, 'M', 'ť'),
+    (0x165, 'V'),
+    (0x166, 'M', 'ŧ'),
+    (0x167, 'V'),
+    (0x168, 'M', 'ũ'),
+    (0x169, 'V'),
+    (0x16A, 'M', 'ū'),
+    (0x16B, 'V'),
+    (0x16C, 'M', 'ŭ'),
+    (0x16D, 'V'),
+    (0x16E, 'M', 'ů'),
+    (0x16F, 'V'),
+    (0x170, 'M', 'ű'),
+    (0x171, 'V'),
+    (0x172, 'M', 'ų'),
+    (0x173, 'V'),
+    (0x174, 'M', 'ŵ'),
+    (0x175, 'V'),
+    (0x176, 'M', 'ŷ'),
+    (0x177, 'V'),
+    (0x178, 'M', 'ÿ'),
+    (0x179, 'M', 'ź'),
+    (0x17A, 'V'),
+    (0x17B, 'M', 'ż'),
+    (0x17C, 'V'),
+    (0x17D, 'M', 'ž'),
+    (0x17E, 'V'),
+    (0x17F, 'M', 's'),
+    (0x180, 'V'),
+    (0x181, 'M', 'ɓ'),
+    (0x182, 'M', 'ƃ'),
+    (0x183, 'V'),
+    (0x184, 'M', 'ƅ'),
+    (0x185, 'V'),
+    (0x186, 'M', 'ɔ'),
+    (0x187, 'M', 'ƈ'),
+    (0x188, 'V'),
+    (0x189, 'M', 'ɖ'),
+    (0x18A, 'M', 'ɗ'),
+    (0x18B, 'M', 'ƌ'),
+    (0x18C, 'V'),
+    (0x18E, 'M', 'ǝ'),
+    (0x18F, 'M', 'ə'),
+    (0x190, 'M', 'ɛ'),
+    (0x191, 'M', 'ƒ'),
+    (0x192, 'V'),
+    (0x193, 'M', 'ɠ'),
+    ]
+
+def _seg_4() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x194, 'M', 'ɣ'),
+    (0x195, 'V'),
+    (0x196, 'M', 'ɩ'),
+    (0x197, 'M', 'ɨ'),
+    (0x198, 'M', 'ƙ'),
+    (0x199, 'V'),
+    (0x19C, 'M', 'ɯ'),
+    (0x19D, 'M', 'ɲ'),
+    (0x19E, 'V'),
+    (0x19F, 'M', 'ɵ'),
+    (0x1A0, 'M', 'ơ'),
+    (0x1A1, 'V'),
+    (0x1A2, 'M', 'ƣ'),
+    (0x1A3, 'V'),
+    (0x1A4, 'M', 'ƥ'),
+    (0x1A5, 'V'),
+    (0x1A6, 'M', 'ʀ'),
+    (0x1A7, 'M', 'ƨ'),
+    (0x1A8, 'V'),
+    (0x1A9, 'M', 'ʃ'),
+    (0x1AA, 'V'),
+    (0x1AC, 'M', 'ƭ'),
+    (0x1AD, 'V'),
+    (0x1AE, 'M', 'ʈ'),
+    (0x1AF, 'M', 'ư'),
+    (0x1B0, 'V'),
+    (0x1B1, 'M', 'ʊ'),
+    (0x1B2, 'M', 'ʋ'),
+    (0x1B3, 'M', 'ƴ'),
+    (0x1B4, 'V'),
+    (0x1B5, 'M', 'ƶ'),
+    (0x1B6, 'V'),
+    (0x1B7, 'M', 'ʒ'),
+    (0x1B8, 'M', 'ƹ'),
+    (0x1B9, 'V'),
+    (0x1BC, 'M', 'ƽ'),
+    (0x1BD, 'V'),
+    (0x1C4, 'M', 'dž'),
+    (0x1C7, 'M', 'lj'),
+    (0x1CA, 'M', 'nj'),
+    (0x1CD, 'M', 'ǎ'),
+    (0x1CE, 'V'),
+    (0x1CF, 'M', 'ǐ'),
+    (0x1D0, 'V'),
+    (0x1D1, 'M', 'ǒ'),
+    (0x1D2, 'V'),
+    (0x1D3, 'M', 'ǔ'),
+    (0x1D4, 'V'),
+    (0x1D5, 'M', 'ǖ'),
+    (0x1D6, 'V'),
+    (0x1D7, 'M', 'ǘ'),
+    (0x1D8, 'V'),
+    (0x1D9, 'M', 'ǚ'),
+    (0x1DA, 'V'),
+    (0x1DB, 'M', 'ǜ'),
+    (0x1DC, 'V'),
+    (0x1DE, 'M', 'ǟ'),
+    (0x1DF, 'V'),
+    (0x1E0, 'M', 'ǡ'),
+    (0x1E1, 'V'),
+    (0x1E2, 'M', 'ǣ'),
+    (0x1E3, 'V'),
+    (0x1E4, 'M', 'ǥ'),
+    (0x1E5, 'V'),
+    (0x1E6, 'M', 'ǧ'),
+    (0x1E7, 'V'),
+    (0x1E8, 'M', 'ǩ'),
+    (0x1E9, 'V'),
+    (0x1EA, 'M', 'ǫ'),
+    (0x1EB, 'V'),
+    (0x1EC, 'M', 'ǭ'),
+    (0x1ED, 'V'),
+    (0x1EE, 'M', 'ǯ'),
+    (0x1EF, 'V'),
+    (0x1F1, 'M', 'dz'),
+    (0x1F4, 'M', 'ǵ'),
+    (0x1F5, 'V'),
+    (0x1F6, 'M', 'ƕ'),
+    (0x1F7, 'M', 'ƿ'),
+    (0x1F8, 'M', 'ǹ'),
+    (0x1F9, 'V'),
+    (0x1FA, 'M', 'ǻ'),
+    (0x1FB, 'V'),
+    (0x1FC, 'M', 'ǽ'),
+    (0x1FD, 'V'),
+    (0x1FE, 'M', 'ǿ'),
+    (0x1FF, 'V'),
+    (0x200, 'M', 'ȁ'),
+    (0x201, 'V'),
+    (0x202, 'M', 'ȃ'),
+    (0x203, 'V'),
+    (0x204, 'M', 'ȅ'),
+    (0x205, 'V'),
+    (0x206, 'M', 'ȇ'),
+    (0x207, 'V'),
+    (0x208, 'M', 'ȉ'),
+    (0x209, 'V'),
+    (0x20A, 'M', 'ȋ'),
+    (0x20B, 'V'),
+    (0x20C, 'M', 'ȍ'),
+    ]
+
+def _seg_5() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x20D, 'V'),
+    (0x20E, 'M', 'ȏ'),
+    (0x20F, 'V'),
+    (0x210, 'M', 'ȑ'),
+    (0x211, 'V'),
+    (0x212, 'M', 'ȓ'),
+    (0x213, 'V'),
+    (0x214, 'M', 'ȕ'),
+    (0x215, 'V'),
+    (0x216, 'M', 'ȗ'),
+    (0x217, 'V'),
+    (0x218, 'M', 'ș'),
+    (0x219, 'V'),
+    (0x21A, 'M', 'ț'),
+    (0x21B, 'V'),
+    (0x21C, 'M', 'ȝ'),
+    (0x21D, 'V'),
+    (0x21E, 'M', 'ȟ'),
+    (0x21F, 'V'),
+    (0x220, 'M', 'ƞ'),
+    (0x221, 'V'),
+    (0x222, 'M', 'ȣ'),
+    (0x223, 'V'),
+    (0x224, 'M', 'ȥ'),
+    (0x225, 'V'),
+    (0x226, 'M', 'ȧ'),
+    (0x227, 'V'),
+    (0x228, 'M', 'ȩ'),
+    (0x229, 'V'),
+    (0x22A, 'M', 'ȫ'),
+    (0x22B, 'V'),
+    (0x22C, 'M', 'ȭ'),
+    (0x22D, 'V'),
+    (0x22E, 'M', 'ȯ'),
+    (0x22F, 'V'),
+    (0x230, 'M', 'ȱ'),
+    (0x231, 'V'),
+    (0x232, 'M', 'ȳ'),
+    (0x233, 'V'),
+    (0x23A, 'M', 'ⱥ'),
+    (0x23B, 'M', 'ȼ'),
+    (0x23C, 'V'),
+    (0x23D, 'M', 'ƚ'),
+    (0x23E, 'M', 'ⱦ'),
+    (0x23F, 'V'),
+    (0x241, 'M', 'ɂ'),
+    (0x242, 'V'),
+    (0x243, 'M', 'ƀ'),
+    (0x244, 'M', 'ʉ'),
+    (0x245, 'M', 'ʌ'),
+    (0x246, 'M', 'ɇ'),
+    (0x247, 'V'),
+    (0x248, 'M', 'ɉ'),
+    (0x249, 'V'),
+    (0x24A, 'M', 'ɋ'),
+    (0x24B, 'V'),
+    (0x24C, 'M', 'ɍ'),
+    (0x24D, 'V'),
+    (0x24E, 'M', 'ɏ'),
+    (0x24F, 'V'),
+    (0x2B0, 'M', 'h'),
+    (0x2B1, 'M', 'ɦ'),
+    (0x2B2, 'M', 'j'),
+    (0x2B3, 'M', 'r'),
+    (0x2B4, 'M', 'ɹ'),
+    (0x2B5, 'M', 'ɻ'),
+    (0x2B6, 'M', 'ʁ'),
+    (0x2B7, 'M', 'w'),
+    (0x2B8, 'M', 'y'),
+    (0x2B9, 'V'),
+    (0x2D8, '3', ' ̆'),
+    (0x2D9, '3', ' ̇'),
+    (0x2DA, '3', ' ̊'),
+    (0x2DB, '3', ' ̨'),
+    (0x2DC, '3', ' ̃'),
+    (0x2DD, '3', ' ̋'),
+    (0x2DE, 'V'),
+    (0x2E0, 'M', 'ɣ'),
+    (0x2E1, 'M', 'l'),
+    (0x2E2, 'M', 's'),
+    (0x2E3, 'M', 'x'),
+    (0x2E4, 'M', 'ʕ'),
+    (0x2E5, 'V'),
+    (0x340, 'M', '̀'),
+    (0x341, 'M', '́'),
+    (0x342, 'V'),
+    (0x343, 'M', '̓'),
+    (0x344, 'M', '̈́'),
+    (0x345, 'M', 'ι'),
+    (0x346, 'V'),
+    (0x34F, 'I'),
+    (0x350, 'V'),
+    (0x370, 'M', 'ͱ'),
+    (0x371, 'V'),
+    (0x372, 'M', 'ͳ'),
+    (0x373, 'V'),
+    (0x374, 'M', 'ʹ'),
+    (0x375, 'V'),
+    (0x376, 'M', 'ͷ'),
+    (0x377, 'V'),
+    ]
+
+def _seg_6() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x378, 'X'),
+    (0x37A, '3', ' ι'),
+    (0x37B, 'V'),
+    (0x37E, '3', ';'),
+    (0x37F, 'M', 'ϳ'),
+    (0x380, 'X'),
+    (0x384, '3', ' ́'),
+    (0x385, '3', ' ̈́'),
+    (0x386, 'M', 'ά'),
+    (0x387, 'M', '·'),
+    (0x388, 'M', 'έ'),
+    (0x389, 'M', 'ή'),
+    (0x38A, 'M', 'ί'),
+    (0x38B, 'X'),
+    (0x38C, 'M', 'ό'),
+    (0x38D, 'X'),
+    (0x38E, 'M', 'ύ'),
+    (0x38F, 'M', 'ώ'),
+    (0x390, 'V'),
+    (0x391, 'M', 'α'),
+    (0x392, 'M', 'β'),
+    (0x393, 'M', 'γ'),
+    (0x394, 'M', 'δ'),
+    (0x395, 'M', 'ε'),
+    (0x396, 'M', 'ζ'),
+    (0x397, 'M', 'η'),
+    (0x398, 'M', 'θ'),
+    (0x399, 'M', 'ι'),
+    (0x39A, 'M', 'κ'),
+    (0x39B, 'M', 'λ'),
+    (0x39C, 'M', 'μ'),
+    (0x39D, 'M', 'ν'),
+    (0x39E, 'M', 'ξ'),
+    (0x39F, 'M', 'ο'),
+    (0x3A0, 'M', 'π'),
+    (0x3A1, 'M', 'ρ'),
+    (0x3A2, 'X'),
+    (0x3A3, 'M', 'σ'),
+    (0x3A4, 'M', 'τ'),
+    (0x3A5, 'M', 'υ'),
+    (0x3A6, 'M', 'φ'),
+    (0x3A7, 'M', 'χ'),
+    (0x3A8, 'M', 'ψ'),
+    (0x3A9, 'M', 'ω'),
+    (0x3AA, 'M', 'ϊ'),
+    (0x3AB, 'M', 'ϋ'),
+    (0x3AC, 'V'),
+    (0x3C2, 'D', 'σ'),
+    (0x3C3, 'V'),
+    (0x3CF, 'M', 'ϗ'),
+    (0x3D0, 'M', 'β'),
+    (0x3D1, 'M', 'θ'),
+    (0x3D2, 'M', 'υ'),
+    (0x3D3, 'M', 'ύ'),
+    (0x3D4, 'M', 'ϋ'),
+    (0x3D5, 'M', 'φ'),
+    (0x3D6, 'M', 'π'),
+    (0x3D7, 'V'),
+    (0x3D8, 'M', 'ϙ'),
+    (0x3D9, 'V'),
+    (0x3DA, 'M', 'ϛ'),
+    (0x3DB, 'V'),
+    (0x3DC, 'M', 'ϝ'),
+    (0x3DD, 'V'),
+    (0x3DE, 'M', 'ϟ'),
+    (0x3DF, 'V'),
+    (0x3E0, 'M', 'ϡ'),
+    (0x3E1, 'V'),
+    (0x3E2, 'M', 'ϣ'),
+    (0x3E3, 'V'),
+    (0x3E4, 'M', 'ϥ'),
+    (0x3E5, 'V'),
+    (0x3E6, 'M', 'ϧ'),
+    (0x3E7, 'V'),
+    (0x3E8, 'M', 'ϩ'),
+    (0x3E9, 'V'),
+    (0x3EA, 'M', 'ϫ'),
+    (0x3EB, 'V'),
+    (0x3EC, 'M', 'ϭ'),
+    (0x3ED, 'V'),
+    (0x3EE, 'M', 'ϯ'),
+    (0x3EF, 'V'),
+    (0x3F0, 'M', 'κ'),
+    (0x3F1, 'M', 'ρ'),
+    (0x3F2, 'M', 'σ'),
+    (0x3F3, 'V'),
+    (0x3F4, 'M', 'θ'),
+    (0x3F5, 'M', 'ε'),
+    (0x3F6, 'V'),
+    (0x3F7, 'M', 'ϸ'),
+    (0x3F8, 'V'),
+    (0x3F9, 'M', 'σ'),
+    (0x3FA, 'M', 'ϻ'),
+    (0x3FB, 'V'),
+    (0x3FD, 'M', 'ͻ'),
+    (0x3FE, 'M', 'ͼ'),
+    (0x3FF, 'M', 'ͽ'),
+    (0x400, 'M', 'ѐ'),
+    (0x401, 'M', 'ё'),
+    (0x402, 'M', 'ђ'),
+    ]
+
+def _seg_7() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x403, 'M', 'ѓ'),
+    (0x404, 'M', 'є'),
+    (0x405, 'M', 'ѕ'),
+    (0x406, 'M', 'і'),
+    (0x407, 'M', 'ї'),
+    (0x408, 'M', 'ј'),
+    (0x409, 'M', 'љ'),
+    (0x40A, 'M', 'њ'),
+    (0x40B, 'M', 'ћ'),
+    (0x40C, 'M', 'ќ'),
+    (0x40D, 'M', 'ѝ'),
+    (0x40E, 'M', 'ў'),
+    (0x40F, 'M', 'џ'),
+    (0x410, 'M', 'а'),
+    (0x411, 'M', 'б'),
+    (0x412, 'M', 'в'),
+    (0x413, 'M', 'г'),
+    (0x414, 'M', 'д'),
+    (0x415, 'M', 'е'),
+    (0x416, 'M', 'ж'),
+    (0x417, 'M', 'з'),
+    (0x418, 'M', 'и'),
+    (0x419, 'M', 'й'),
+    (0x41A, 'M', 'к'),
+    (0x41B, 'M', 'л'),
+    (0x41C, 'M', 'м'),
+    (0x41D, 'M', 'н'),
+    (0x41E, 'M', 'о'),
+    (0x41F, 'M', 'п'),
+    (0x420, 'M', 'р'),
+    (0x421, 'M', 'с'),
+    (0x422, 'M', 'т'),
+    (0x423, 'M', 'у'),
+    (0x424, 'M', 'ф'),
+    (0x425, 'M', 'х'),
+    (0x426, 'M', 'ц'),
+    (0x427, 'M', 'ч'),
+    (0x428, 'M', 'ш'),
+    (0x429, 'M', 'щ'),
+    (0x42A, 'M', 'ъ'),
+    (0x42B, 'M', 'ы'),
+    (0x42C, 'M', 'ь'),
+    (0x42D, 'M', 'э'),
+    (0x42E, 'M', 'ю'),
+    (0x42F, 'M', 'я'),
+    (0x430, 'V'),
+    (0x460, 'M', 'ѡ'),
+    (0x461, 'V'),
+    (0x462, 'M', 'ѣ'),
+    (0x463, 'V'),
+    (0x464, 'M', 'ѥ'),
+    (0x465, 'V'),
+    (0x466, 'M', 'ѧ'),
+    (0x467, 'V'),
+    (0x468, 'M', 'ѩ'),
+    (0x469, 'V'),
+    (0x46A, 'M', 'ѫ'),
+    (0x46B, 'V'),
+    (0x46C, 'M', 'ѭ'),
+    (0x46D, 'V'),
+    (0x46E, 'M', 'ѯ'),
+    (0x46F, 'V'),
+    (0x470, 'M', 'ѱ'),
+    (0x471, 'V'),
+    (0x472, 'M', 'ѳ'),
+    (0x473, 'V'),
+    (0x474, 'M', 'ѵ'),
+    (0x475, 'V'),
+    (0x476, 'M', 'ѷ'),
+    (0x477, 'V'),
+    (0x478, 'M', 'ѹ'),
+    (0x479, 'V'),
+    (0x47A, 'M', 'ѻ'),
+    (0x47B, 'V'),
+    (0x47C, 'M', 'ѽ'),
+    (0x47D, 'V'),
+    (0x47E, 'M', 'ѿ'),
+    (0x47F, 'V'),
+    (0x480, 'M', 'ҁ'),
+    (0x481, 'V'),
+    (0x48A, 'M', 'ҋ'),
+    (0x48B, 'V'),
+    (0x48C, 'M', 'ҍ'),
+    (0x48D, 'V'),
+    (0x48E, 'M', 'ҏ'),
+    (0x48F, 'V'),
+    (0x490, 'M', 'ґ'),
+    (0x491, 'V'),
+    (0x492, 'M', 'ғ'),
+    (0x493, 'V'),
+    (0x494, 'M', 'ҕ'),
+    (0x495, 'V'),
+    (0x496, 'M', 'җ'),
+    (0x497, 'V'),
+    (0x498, 'M', 'ҙ'),
+    (0x499, 'V'),
+    (0x49A, 'M', 'қ'),
+    (0x49B, 'V'),
+    (0x49C, 'M', 'ҝ'),
+    (0x49D, 'V'),
+    ]
+
+def _seg_8() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x49E, 'M', 'ҟ'),
+    (0x49F, 'V'),
+    (0x4A0, 'M', 'ҡ'),
+    (0x4A1, 'V'),
+    (0x4A2, 'M', 'ң'),
+    (0x4A3, 'V'),
+    (0x4A4, 'M', 'ҥ'),
+    (0x4A5, 'V'),
+    (0x4A6, 'M', 'ҧ'),
+    (0x4A7, 'V'),
+    (0x4A8, 'M', 'ҩ'),
+    (0x4A9, 'V'),
+    (0x4AA, 'M', 'ҫ'),
+    (0x4AB, 'V'),
+    (0x4AC, 'M', 'ҭ'),
+    (0x4AD, 'V'),
+    (0x4AE, 'M', 'ү'),
+    (0x4AF, 'V'),
+    (0x4B0, 'M', 'ұ'),
+    (0x4B1, 'V'),
+    (0x4B2, 'M', 'ҳ'),
+    (0x4B3, 'V'),
+    (0x4B4, 'M', 'ҵ'),
+    (0x4B5, 'V'),
+    (0x4B6, 'M', 'ҷ'),
+    (0x4B7, 'V'),
+    (0x4B8, 'M', 'ҹ'),
+    (0x4B9, 'V'),
+    (0x4BA, 'M', 'һ'),
+    (0x4BB, 'V'),
+    (0x4BC, 'M', 'ҽ'),
+    (0x4BD, 'V'),
+    (0x4BE, 'M', 'ҿ'),
+    (0x4BF, 'V'),
+    (0x4C0, 'X'),
+    (0x4C1, 'M', 'ӂ'),
+    (0x4C2, 'V'),
+    (0x4C3, 'M', 'ӄ'),
+    (0x4C4, 'V'),
+    (0x4C5, 'M', 'ӆ'),
+    (0x4C6, 'V'),
+    (0x4C7, 'M', 'ӈ'),
+    (0x4C8, 'V'),
+    (0x4C9, 'M', 'ӊ'),
+    (0x4CA, 'V'),
+    (0x4CB, 'M', 'ӌ'),
+    (0x4CC, 'V'),
+    (0x4CD, 'M', 'ӎ'),
+    (0x4CE, 'V'),
+    (0x4D0, 'M', 'ӑ'),
+    (0x4D1, 'V'),
+    (0x4D2, 'M', 'ӓ'),
+    (0x4D3, 'V'),
+    (0x4D4, 'M', 'ӕ'),
+    (0x4D5, 'V'),
+    (0x4D6, 'M', 'ӗ'),
+    (0x4D7, 'V'),
+    (0x4D8, 'M', 'ә'),
+    (0x4D9, 'V'),
+    (0x4DA, 'M', 'ӛ'),
+    (0x4DB, 'V'),
+    (0x4DC, 'M', 'ӝ'),
+    (0x4DD, 'V'),
+    (0x4DE, 'M', 'ӟ'),
+    (0x4DF, 'V'),
+    (0x4E0, 'M', 'ӡ'),
+    (0x4E1, 'V'),
+    (0x4E2, 'M', 'ӣ'),
+    (0x4E3, 'V'),
+    (0x4E4, 'M', 'ӥ'),
+    (0x4E5, 'V'),
+    (0x4E6, 'M', 'ӧ'),
+    (0x4E7, 'V'),
+    (0x4E8, 'M', 'ө'),
+    (0x4E9, 'V'),
+    (0x4EA, 'M', 'ӫ'),
+    (0x4EB, 'V'),
+    (0x4EC, 'M', 'ӭ'),
+    (0x4ED, 'V'),
+    (0x4EE, 'M', 'ӯ'),
+    (0x4EF, 'V'),
+    (0x4F0, 'M', 'ӱ'),
+    (0x4F1, 'V'),
+    (0x4F2, 'M', 'ӳ'),
+    (0x4F3, 'V'),
+    (0x4F4, 'M', 'ӵ'),
+    (0x4F5, 'V'),
+    (0x4F6, 'M', 'ӷ'),
+    (0x4F7, 'V'),
+    (0x4F8, 'M', 'ӹ'),
+    (0x4F9, 'V'),
+    (0x4FA, 'M', 'ӻ'),
+    (0x4FB, 'V'),
+    (0x4FC, 'M', 'ӽ'),
+    (0x4FD, 'V'),
+    (0x4FE, 'M', 'ӿ'),
+    (0x4FF, 'V'),
+    (0x500, 'M', 'ԁ'),
+    (0x501, 'V'),
+    (0x502, 'M', 'ԃ'),
+    ]
+
+def _seg_9() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x503, 'V'),
+    (0x504, 'M', 'ԅ'),
+    (0x505, 'V'),
+    (0x506, 'M', 'ԇ'),
+    (0x507, 'V'),
+    (0x508, 'M', 'ԉ'),
+    (0x509, 'V'),
+    (0x50A, 'M', 'ԋ'),
+    (0x50B, 'V'),
+    (0x50C, 'M', 'ԍ'),
+    (0x50D, 'V'),
+    (0x50E, 'M', 'ԏ'),
+    (0x50F, 'V'),
+    (0x510, 'M', 'ԑ'),
+    (0x511, 'V'),
+    (0x512, 'M', 'ԓ'),
+    (0x513, 'V'),
+    (0x514, 'M', 'ԕ'),
+    (0x515, 'V'),
+    (0x516, 'M', 'ԗ'),
+    (0x517, 'V'),
+    (0x518, 'M', 'ԙ'),
+    (0x519, 'V'),
+    (0x51A, 'M', 'ԛ'),
+    (0x51B, 'V'),
+    (0x51C, 'M', 'ԝ'),
+    (0x51D, 'V'),
+    (0x51E, 'M', 'ԟ'),
+    (0x51F, 'V'),
+    (0x520, 'M', 'ԡ'),
+    (0x521, 'V'),
+    (0x522, 'M', 'ԣ'),
+    (0x523, 'V'),
+    (0x524, 'M', 'ԥ'),
+    (0x525, 'V'),
+    (0x526, 'M', 'ԧ'),
+    (0x527, 'V'),
+    (0x528, 'M', 'ԩ'),
+    (0x529, 'V'),
+    (0x52A, 'M', 'ԫ'),
+    (0x52B, 'V'),
+    (0x52C, 'M', 'ԭ'),
+    (0x52D, 'V'),
+    (0x52E, 'M', 'ԯ'),
+    (0x52F, 'V'),
+    (0x530, 'X'),
+    (0x531, 'M', 'ա'),
+    (0x532, 'M', 'բ'),
+    (0x533, 'M', 'գ'),
+    (0x534, 'M', 'դ'),
+    (0x535, 'M', 'ե'),
+    (0x536, 'M', 'զ'),
+    (0x537, 'M', 'է'),
+    (0x538, 'M', 'ը'),
+    (0x539, 'M', 'թ'),
+    (0x53A, 'M', 'ժ'),
+    (0x53B, 'M', 'ի'),
+    (0x53C, 'M', 'լ'),
+    (0x53D, 'M', 'խ'),
+    (0x53E, 'M', 'ծ'),
+    (0x53F, 'M', 'կ'),
+    (0x540, 'M', 'հ'),
+    (0x541, 'M', 'ձ'),
+    (0x542, 'M', 'ղ'),
+    (0x543, 'M', 'ճ'),
+    (0x544, 'M', 'մ'),
+    (0x545, 'M', 'յ'),
+    (0x546, 'M', 'ն'),
+    (0x547, 'M', 'շ'),
+    (0x548, 'M', 'ո'),
+    (0x549, 'M', 'չ'),
+    (0x54A, 'M', 'պ'),
+    (0x54B, 'M', 'ջ'),
+    (0x54C, 'M', 'ռ'),
+    (0x54D, 'M', 'ս'),
+    (0x54E, 'M', 'վ'),
+    (0x54F, 'M', 'տ'),
+    (0x550, 'M', 'ր'),
+    (0x551, 'M', 'ց'),
+    (0x552, 'M', 'ւ'),
+    (0x553, 'M', 'փ'),
+    (0x554, 'M', 'ք'),
+    (0x555, 'M', 'օ'),
+    (0x556, 'M', 'ֆ'),
+    (0x557, 'X'),
+    (0x559, 'V'),
+    (0x587, 'M', 'եւ'),
+    (0x588, 'V'),
+    (0x58B, 'X'),
+    (0x58D, 'V'),
+    (0x590, 'X'),
+    (0x591, 'V'),
+    (0x5C8, 'X'),
+    (0x5D0, 'V'),
+    (0x5EB, 'X'),
+    (0x5EF, 'V'),
+    (0x5F5, 'X'),
+    (0x606, 'V'),
+    (0x61C, 'X'),
+    (0x61D, 'V'),
+    ]
+
+def _seg_10() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x675, 'M', 'اٴ'),
+    (0x676, 'M', 'وٴ'),
+    (0x677, 'M', 'ۇٴ'),
+    (0x678, 'M', 'يٴ'),
+    (0x679, 'V'),
+    (0x6DD, 'X'),
+    (0x6DE, 'V'),
+    (0x70E, 'X'),
+    (0x710, 'V'),
+    (0x74B, 'X'),
+    (0x74D, 'V'),
+    (0x7B2, 'X'),
+    (0x7C0, 'V'),
+    (0x7FB, 'X'),
+    (0x7FD, 'V'),
+    (0x82E, 'X'),
+    (0x830, 'V'),
+    (0x83F, 'X'),
+    (0x840, 'V'),
+    (0x85C, 'X'),
+    (0x85E, 'V'),
+    (0x85F, 'X'),
+    (0x860, 'V'),
+    (0x86B, 'X'),
+    (0x870, 'V'),
+    (0x88F, 'X'),
+    (0x898, 'V'),
+    (0x8E2, 'X'),
+    (0x8E3, 'V'),
+    (0x958, 'M', 'क़'),
+    (0x959, 'M', 'ख़'),
+    (0x95A, 'M', 'ग़'),
+    (0x95B, 'M', 'ज़'),
+    (0x95C, 'M', 'ड़'),
+    (0x95D, 'M', 'ढ़'),
+    (0x95E, 'M', 'फ़'),
+    (0x95F, 'M', 'य़'),
+    (0x960, 'V'),
+    (0x984, 'X'),
+    (0x985, 'V'),
+    (0x98D, 'X'),
+    (0x98F, 'V'),
+    (0x991, 'X'),
+    (0x993, 'V'),
+    (0x9A9, 'X'),
+    (0x9AA, 'V'),
+    (0x9B1, 'X'),
+    (0x9B2, 'V'),
+    (0x9B3, 'X'),
+    (0x9B6, 'V'),
+    (0x9BA, 'X'),
+    (0x9BC, 'V'),
+    (0x9C5, 'X'),
+    (0x9C7, 'V'),
+    (0x9C9, 'X'),
+    (0x9CB, 'V'),
+    (0x9CF, 'X'),
+    (0x9D7, 'V'),
+    (0x9D8, 'X'),
+    (0x9DC, 'M', 'ড়'),
+    (0x9DD, 'M', 'ঢ়'),
+    (0x9DE, 'X'),
+    (0x9DF, 'M', 'য়'),
+    (0x9E0, 'V'),
+    (0x9E4, 'X'),
+    (0x9E6, 'V'),
+    (0x9FF, 'X'),
+    (0xA01, 'V'),
+    (0xA04, 'X'),
+    (0xA05, 'V'),
+    (0xA0B, 'X'),
+    (0xA0F, 'V'),
+    (0xA11, 'X'),
+    (0xA13, 'V'),
+    (0xA29, 'X'),
+    (0xA2A, 'V'),
+    (0xA31, 'X'),
+    (0xA32, 'V'),
+    (0xA33, 'M', 'ਲ਼'),
+    (0xA34, 'X'),
+    (0xA35, 'V'),
+    (0xA36, 'M', 'ਸ਼'),
+    (0xA37, 'X'),
+    (0xA38, 'V'),
+    (0xA3A, 'X'),
+    (0xA3C, 'V'),
+    (0xA3D, 'X'),
+    (0xA3E, 'V'),
+    (0xA43, 'X'),
+    (0xA47, 'V'),
+    (0xA49, 'X'),
+    (0xA4B, 'V'),
+    (0xA4E, 'X'),
+    (0xA51, 'V'),
+    (0xA52, 'X'),
+    (0xA59, 'M', 'ਖ਼'),
+    (0xA5A, 'M', 'ਗ਼'),
+    (0xA5B, 'M', 'ਜ਼'),
+    (0xA5C, 'V'),
+    (0xA5D, 'X'),
+    ]
+
+def _seg_11() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA5E, 'M', 'ਫ਼'),
+    (0xA5F, 'X'),
+    (0xA66, 'V'),
+    (0xA77, 'X'),
+    (0xA81, 'V'),
+    (0xA84, 'X'),
+    (0xA85, 'V'),
+    (0xA8E, 'X'),
+    (0xA8F, 'V'),
+    (0xA92, 'X'),
+    (0xA93, 'V'),
+    (0xAA9, 'X'),
+    (0xAAA, 'V'),
+    (0xAB1, 'X'),
+    (0xAB2, 'V'),
+    (0xAB4, 'X'),
+    (0xAB5, 'V'),
+    (0xABA, 'X'),
+    (0xABC, 'V'),
+    (0xAC6, 'X'),
+    (0xAC7, 'V'),
+    (0xACA, 'X'),
+    (0xACB, 'V'),
+    (0xACE, 'X'),
+    (0xAD0, 'V'),
+    (0xAD1, 'X'),
+    (0xAE0, 'V'),
+    (0xAE4, 'X'),
+    (0xAE6, 'V'),
+    (0xAF2, 'X'),
+    (0xAF9, 'V'),
+    (0xB00, 'X'),
+    (0xB01, 'V'),
+    (0xB04, 'X'),
+    (0xB05, 'V'),
+    (0xB0D, 'X'),
+    (0xB0F, 'V'),
+    (0xB11, 'X'),
+    (0xB13, 'V'),
+    (0xB29, 'X'),
+    (0xB2A, 'V'),
+    (0xB31, 'X'),
+    (0xB32, 'V'),
+    (0xB34, 'X'),
+    (0xB35, 'V'),
+    (0xB3A, 'X'),
+    (0xB3C, 'V'),
+    (0xB45, 'X'),
+    (0xB47, 'V'),
+    (0xB49, 'X'),
+    (0xB4B, 'V'),
+    (0xB4E, 'X'),
+    (0xB55, 'V'),
+    (0xB58, 'X'),
+    (0xB5C, 'M', 'ଡ଼'),
+    (0xB5D, 'M', 'ଢ଼'),
+    (0xB5E, 'X'),
+    (0xB5F, 'V'),
+    (0xB64, 'X'),
+    (0xB66, 'V'),
+    (0xB78, 'X'),
+    (0xB82, 'V'),
+    (0xB84, 'X'),
+    (0xB85, 'V'),
+    (0xB8B, 'X'),
+    (0xB8E, 'V'),
+    (0xB91, 'X'),
+    (0xB92, 'V'),
+    (0xB96, 'X'),
+    (0xB99, 'V'),
+    (0xB9B, 'X'),
+    (0xB9C, 'V'),
+    (0xB9D, 'X'),
+    (0xB9E, 'V'),
+    (0xBA0, 'X'),
+    (0xBA3, 'V'),
+    (0xBA5, 'X'),
+    (0xBA8, 'V'),
+    (0xBAB, 'X'),
+    (0xBAE, 'V'),
+    (0xBBA, 'X'),
+    (0xBBE, 'V'),
+    (0xBC3, 'X'),
+    (0xBC6, 'V'),
+    (0xBC9, 'X'),
+    (0xBCA, 'V'),
+    (0xBCE, 'X'),
+    (0xBD0, 'V'),
+    (0xBD1, 'X'),
+    (0xBD7, 'V'),
+    (0xBD8, 'X'),
+    (0xBE6, 'V'),
+    (0xBFB, 'X'),
+    (0xC00, 'V'),
+    (0xC0D, 'X'),
+    (0xC0E, 'V'),
+    (0xC11, 'X'),
+    (0xC12, 'V'),
+    (0xC29, 'X'),
+    (0xC2A, 'V'),
+    ]
+
+def _seg_12() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xC3A, 'X'),
+    (0xC3C, 'V'),
+    (0xC45, 'X'),
+    (0xC46, 'V'),
+    (0xC49, 'X'),
+    (0xC4A, 'V'),
+    (0xC4E, 'X'),
+    (0xC55, 'V'),
+    (0xC57, 'X'),
+    (0xC58, 'V'),
+    (0xC5B, 'X'),
+    (0xC5D, 'V'),
+    (0xC5E, 'X'),
+    (0xC60, 'V'),
+    (0xC64, 'X'),
+    (0xC66, 'V'),
+    (0xC70, 'X'),
+    (0xC77, 'V'),
+    (0xC8D, 'X'),
+    (0xC8E, 'V'),
+    (0xC91, 'X'),
+    (0xC92, 'V'),
+    (0xCA9, 'X'),
+    (0xCAA, 'V'),
+    (0xCB4, 'X'),
+    (0xCB5, 'V'),
+    (0xCBA, 'X'),
+    (0xCBC, 'V'),
+    (0xCC5, 'X'),
+    (0xCC6, 'V'),
+    (0xCC9, 'X'),
+    (0xCCA, 'V'),
+    (0xCCE, 'X'),
+    (0xCD5, 'V'),
+    (0xCD7, 'X'),
+    (0xCDD, 'V'),
+    (0xCDF, 'X'),
+    (0xCE0, 'V'),
+    (0xCE4, 'X'),
+    (0xCE6, 'V'),
+    (0xCF0, 'X'),
+    (0xCF1, 'V'),
+    (0xCF3, 'X'),
+    (0xD00, 'V'),
+    (0xD0D, 'X'),
+    (0xD0E, 'V'),
+    (0xD11, 'X'),
+    (0xD12, 'V'),
+    (0xD45, 'X'),
+    (0xD46, 'V'),
+    (0xD49, 'X'),
+    (0xD4A, 'V'),
+    (0xD50, 'X'),
+    (0xD54, 'V'),
+    (0xD64, 'X'),
+    (0xD66, 'V'),
+    (0xD80, 'X'),
+    (0xD81, 'V'),
+    (0xD84, 'X'),
+    (0xD85, 'V'),
+    (0xD97, 'X'),
+    (0xD9A, 'V'),
+    (0xDB2, 'X'),
+    (0xDB3, 'V'),
+    (0xDBC, 'X'),
+    (0xDBD, 'V'),
+    (0xDBE, 'X'),
+    (0xDC0, 'V'),
+    (0xDC7, 'X'),
+    (0xDCA, 'V'),
+    (0xDCB, 'X'),
+    (0xDCF, 'V'),
+    (0xDD5, 'X'),
+    (0xDD6, 'V'),
+    (0xDD7, 'X'),
+    (0xDD8, 'V'),
+    (0xDE0, 'X'),
+    (0xDE6, 'V'),
+    (0xDF0, 'X'),
+    (0xDF2, 'V'),
+    (0xDF5, 'X'),
+    (0xE01, 'V'),
+    (0xE33, 'M', 'ํา'),
+    (0xE34, 'V'),
+    (0xE3B, 'X'),
+    (0xE3F, 'V'),
+    (0xE5C, 'X'),
+    (0xE81, 'V'),
+    (0xE83, 'X'),
+    (0xE84, 'V'),
+    (0xE85, 'X'),
+    (0xE86, 'V'),
+    (0xE8B, 'X'),
+    (0xE8C, 'V'),
+    (0xEA4, 'X'),
+    (0xEA5, 'V'),
+    (0xEA6, 'X'),
+    (0xEA7, 'V'),
+    (0xEB3, 'M', 'ໍາ'),
+    (0xEB4, 'V'),
+    ]
+
+def _seg_13() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xEBE, 'X'),
+    (0xEC0, 'V'),
+    (0xEC5, 'X'),
+    (0xEC6, 'V'),
+    (0xEC7, 'X'),
+    (0xEC8, 'V'),
+    (0xECE, 'X'),
+    (0xED0, 'V'),
+    (0xEDA, 'X'),
+    (0xEDC, 'M', 'ຫນ'),
+    (0xEDD, 'M', 'ຫມ'),
+    (0xEDE, 'V'),
+    (0xEE0, 'X'),
+    (0xF00, 'V'),
+    (0xF0C, 'M', '་'),
+    (0xF0D, 'V'),
+    (0xF43, 'M', 'གྷ'),
+    (0xF44, 'V'),
+    (0xF48, 'X'),
+    (0xF49, 'V'),
+    (0xF4D, 'M', 'ཌྷ'),
+    (0xF4E, 'V'),
+    (0xF52, 'M', 'དྷ'),
+    (0xF53, 'V'),
+    (0xF57, 'M', 'བྷ'),
+    (0xF58, 'V'),
+    (0xF5C, 'M', 'ཛྷ'),
+    (0xF5D, 'V'),
+    (0xF69, 'M', 'ཀྵ'),
+    (0xF6A, 'V'),
+    (0xF6D, 'X'),
+    (0xF71, 'V'),
+    (0xF73, 'M', 'ཱི'),
+    (0xF74, 'V'),
+    (0xF75, 'M', 'ཱུ'),
+    (0xF76, 'M', 'ྲྀ'),
+    (0xF77, 'M', 'ྲཱྀ'),
+    (0xF78, 'M', 'ླྀ'),
+    (0xF79, 'M', 'ླཱྀ'),
+    (0xF7A, 'V'),
+    (0xF81, 'M', 'ཱྀ'),
+    (0xF82, 'V'),
+    (0xF93, 'M', 'ྒྷ'),
+    (0xF94, 'V'),
+    (0xF98, 'X'),
+    (0xF99, 'V'),
+    (0xF9D, 'M', 'ྜྷ'),
+    (0xF9E, 'V'),
+    (0xFA2, 'M', 'ྡྷ'),
+    (0xFA3, 'V'),
+    (0xFA7, 'M', 'ྦྷ'),
+    (0xFA8, 'V'),
+    (0xFAC, 'M', 'ྫྷ'),
+    (0xFAD, 'V'),
+    (0xFB9, 'M', 'ྐྵ'),
+    (0xFBA, 'V'),
+    (0xFBD, 'X'),
+    (0xFBE, 'V'),
+    (0xFCD, 'X'),
+    (0xFCE, 'V'),
+    (0xFDB, 'X'),
+    (0x1000, 'V'),
+    (0x10A0, 'X'),
+    (0x10C7, 'M', 'ⴧ'),
+    (0x10C8, 'X'),
+    (0x10CD, 'M', 'ⴭ'),
+    (0x10CE, 'X'),
+    (0x10D0, 'V'),
+    (0x10FC, 'M', 'ნ'),
+    (0x10FD, 'V'),
+    (0x115F, 'X'),
+    (0x1161, 'V'),
+    (0x1249, 'X'),
+    (0x124A, 'V'),
+    (0x124E, 'X'),
+    (0x1250, 'V'),
+    (0x1257, 'X'),
+    (0x1258, 'V'),
+    (0x1259, 'X'),
+    (0x125A, 'V'),
+    (0x125E, 'X'),
+    (0x1260, 'V'),
+    (0x1289, 'X'),
+    (0x128A, 'V'),
+    (0x128E, 'X'),
+    (0x1290, 'V'),
+    (0x12B1, 'X'),
+    (0x12B2, 'V'),
+    (0x12B6, 'X'),
+    (0x12B8, 'V'),
+    (0x12BF, 'X'),
+    (0x12C0, 'V'),
+    (0x12C1, 'X'),
+    (0x12C2, 'V'),
+    (0x12C6, 'X'),
+    (0x12C8, 'V'),
+    (0x12D7, 'X'),
+    (0x12D8, 'V'),
+    (0x1311, 'X'),
+    (0x1312, 'V'),
+    ]
+
+def _seg_14() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1316, 'X'),
+    (0x1318, 'V'),
+    (0x135B, 'X'),
+    (0x135D, 'V'),
+    (0x137D, 'X'),
+    (0x1380, 'V'),
+    (0x139A, 'X'),
+    (0x13A0, 'V'),
+    (0x13F6, 'X'),
+    (0x13F8, 'M', 'Ᏸ'),
+    (0x13F9, 'M', 'Ᏹ'),
+    (0x13FA, 'M', 'Ᏺ'),
+    (0x13FB, 'M', 'Ᏻ'),
+    (0x13FC, 'M', 'Ᏼ'),
+    (0x13FD, 'M', 'Ᏽ'),
+    (0x13FE, 'X'),
+    (0x1400, 'V'),
+    (0x1680, 'X'),
+    (0x1681, 'V'),
+    (0x169D, 'X'),
+    (0x16A0, 'V'),
+    (0x16F9, 'X'),
+    (0x1700, 'V'),
+    (0x1716, 'X'),
+    (0x171F, 'V'),
+    (0x1737, 'X'),
+    (0x1740, 'V'),
+    (0x1754, 'X'),
+    (0x1760, 'V'),
+    (0x176D, 'X'),
+    (0x176E, 'V'),
+    (0x1771, 'X'),
+    (0x1772, 'V'),
+    (0x1774, 'X'),
+    (0x1780, 'V'),
+    (0x17B4, 'X'),
+    (0x17B6, 'V'),
+    (0x17DE, 'X'),
+    (0x17E0, 'V'),
+    (0x17EA, 'X'),
+    (0x17F0, 'V'),
+    (0x17FA, 'X'),
+    (0x1800, 'V'),
+    (0x1806, 'X'),
+    (0x1807, 'V'),
+    (0x180B, 'I'),
+    (0x180E, 'X'),
+    (0x180F, 'I'),
+    (0x1810, 'V'),
+    (0x181A, 'X'),
+    (0x1820, 'V'),
+    (0x1879, 'X'),
+    (0x1880, 'V'),
+    (0x18AB, 'X'),
+    (0x18B0, 'V'),
+    (0x18F6, 'X'),
+    (0x1900, 'V'),
+    (0x191F, 'X'),
+    (0x1920, 'V'),
+    (0x192C, 'X'),
+    (0x1930, 'V'),
+    (0x193C, 'X'),
+    (0x1940, 'V'),
+    (0x1941, 'X'),
+    (0x1944, 'V'),
+    (0x196E, 'X'),
+    (0x1970, 'V'),
+    (0x1975, 'X'),
+    (0x1980, 'V'),
+    (0x19AC, 'X'),
+    (0x19B0, 'V'),
+    (0x19CA, 'X'),
+    (0x19D0, 'V'),
+    (0x19DB, 'X'),
+    (0x19DE, 'V'),
+    (0x1A1C, 'X'),
+    (0x1A1E, 'V'),
+    (0x1A5F, 'X'),
+    (0x1A60, 'V'),
+    (0x1A7D, 'X'),
+    (0x1A7F, 'V'),
+    (0x1A8A, 'X'),
+    (0x1A90, 'V'),
+    (0x1A9A, 'X'),
+    (0x1AA0, 'V'),
+    (0x1AAE, 'X'),
+    (0x1AB0, 'V'),
+    (0x1ACF, 'X'),
+    (0x1B00, 'V'),
+    (0x1B4D, 'X'),
+    (0x1B50, 'V'),
+    (0x1B7F, 'X'),
+    (0x1B80, 'V'),
+    (0x1BF4, 'X'),
+    (0x1BFC, 'V'),
+    (0x1C38, 'X'),
+    (0x1C3B, 'V'),
+    (0x1C4A, 'X'),
+    (0x1C4D, 'V'),
+    (0x1C80, 'M', 'в'),
+    ]
+
+def _seg_15() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1C81, 'M', 'д'),
+    (0x1C82, 'M', 'о'),
+    (0x1C83, 'M', 'с'),
+    (0x1C84, 'M', 'т'),
+    (0x1C86, 'M', 'ъ'),
+    (0x1C87, 'M', 'ѣ'),
+    (0x1C88, 'M', 'ꙋ'),
+    (0x1C89, 'X'),
+    (0x1C90, 'M', 'ა'),
+    (0x1C91, 'M', 'ბ'),
+    (0x1C92, 'M', 'გ'),
+    (0x1C93, 'M', 'დ'),
+    (0x1C94, 'M', 'ე'),
+    (0x1C95, 'M', 'ვ'),
+    (0x1C96, 'M', 'ზ'),
+    (0x1C97, 'M', 'თ'),
+    (0x1C98, 'M', 'ი'),
+    (0x1C99, 'M', 'კ'),
+    (0x1C9A, 'M', 'ლ'),
+    (0x1C9B, 'M', 'მ'),
+    (0x1C9C, 'M', 'ნ'),
+    (0x1C9D, 'M', 'ო'),
+    (0x1C9E, 'M', 'პ'),
+    (0x1C9F, 'M', 'ჟ'),
+    (0x1CA0, 'M', 'რ'),
+    (0x1CA1, 'M', 'ს'),
+    (0x1CA2, 'M', 'ტ'),
+    (0x1CA3, 'M', 'უ'),
+    (0x1CA4, 'M', 'ფ'),
+    (0x1CA5, 'M', 'ქ'),
+    (0x1CA6, 'M', 'ღ'),
+    (0x1CA7, 'M', 'ყ'),
+    (0x1CA8, 'M', 'შ'),
+    (0x1CA9, 'M', 'ჩ'),
+    (0x1CAA, 'M', 'ც'),
+    (0x1CAB, 'M', 'ძ'),
+    (0x1CAC, 'M', 'წ'),
+    (0x1CAD, 'M', 'ჭ'),
+    (0x1CAE, 'M', 'ხ'),
+    (0x1CAF, 'M', 'ჯ'),
+    (0x1CB0, 'M', 'ჰ'),
+    (0x1CB1, 'M', 'ჱ'),
+    (0x1CB2, 'M', 'ჲ'),
+    (0x1CB3, 'M', 'ჳ'),
+    (0x1CB4, 'M', 'ჴ'),
+    (0x1CB5, 'M', 'ჵ'),
+    (0x1CB6, 'M', 'ჶ'),
+    (0x1CB7, 'M', 'ჷ'),
+    (0x1CB8, 'M', 'ჸ'),
+    (0x1CB9, 'M', 'ჹ'),
+    (0x1CBA, 'M', 'ჺ'),
+    (0x1CBB, 'X'),
+    (0x1CBD, 'M', 'ჽ'),
+    (0x1CBE, 'M', 'ჾ'),
+    (0x1CBF, 'M', 'ჿ'),
+    (0x1CC0, 'V'),
+    (0x1CC8, 'X'),
+    (0x1CD0, 'V'),
+    (0x1CFB, 'X'),
+    (0x1D00, 'V'),
+    (0x1D2C, 'M', 'a'),
+    (0x1D2D, 'M', 'æ'),
+    (0x1D2E, 'M', 'b'),
+    (0x1D2F, 'V'),
+    (0x1D30, 'M', 'd'),
+    (0x1D31, 'M', 'e'),
+    (0x1D32, 'M', 'ǝ'),
+    (0x1D33, 'M', 'g'),
+    (0x1D34, 'M', 'h'),
+    (0x1D35, 'M', 'i'),
+    (0x1D36, 'M', 'j'),
+    (0x1D37, 'M', 'k'),
+    (0x1D38, 'M', 'l'),
+    (0x1D39, 'M', 'm'),
+    (0x1D3A, 'M', 'n'),
+    (0x1D3B, 'V'),
+    (0x1D3C, 'M', 'o'),
+    (0x1D3D, 'M', 'ȣ'),
+    (0x1D3E, 'M', 'p'),
+    (0x1D3F, 'M', 'r'),
+    (0x1D40, 'M', 't'),
+    (0x1D41, 'M', 'u'),
+    (0x1D42, 'M', 'w'),
+    (0x1D43, 'M', 'a'),
+    (0x1D44, 'M', 'ɐ'),
+    (0x1D45, 'M', 'ɑ'),
+    (0x1D46, 'M', 'ᴂ'),
+    (0x1D47, 'M', 'b'),
+    (0x1D48, 'M', 'd'),
+    (0x1D49, 'M', 'e'),
+    (0x1D4A, 'M', 'ə'),
+    (0x1D4B, 'M', 'ɛ'),
+    (0x1D4C, 'M', 'ɜ'),
+    (0x1D4D, 'M', 'g'),
+    (0x1D4E, 'V'),
+    (0x1D4F, 'M', 'k'),
+    (0x1D50, 'M', 'm'),
+    (0x1D51, 'M', 'ŋ'),
+    (0x1D52, 'M', 'o'),
+    (0x1D53, 'M', 'ɔ'),
+    ]
+
+def _seg_16() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D54, 'M', 'ᴖ'),
+    (0x1D55, 'M', 'ᴗ'),
+    (0x1D56, 'M', 'p'),
+    (0x1D57, 'M', 't'),
+    (0x1D58, 'M', 'u'),
+    (0x1D59, 'M', 'ᴝ'),
+    (0x1D5A, 'M', 'ɯ'),
+    (0x1D5B, 'M', 'v'),
+    (0x1D5C, 'M', 'ᴥ'),
+    (0x1D5D, 'M', 'β'),
+    (0x1D5E, 'M', 'γ'),
+    (0x1D5F, 'M', 'δ'),
+    (0x1D60, 'M', 'φ'),
+    (0x1D61, 'M', 'χ'),
+    (0x1D62, 'M', 'i'),
+    (0x1D63, 'M', 'r'),
+    (0x1D64, 'M', 'u'),
+    (0x1D65, 'M', 'v'),
+    (0x1D66, 'M', 'β'),
+    (0x1D67, 'M', 'γ'),
+    (0x1D68, 'M', 'ρ'),
+    (0x1D69, 'M', 'φ'),
+    (0x1D6A, 'M', 'χ'),
+    (0x1D6B, 'V'),
+    (0x1D78, 'M', 'н'),
+    (0x1D79, 'V'),
+    (0x1D9B, 'M', 'ɒ'),
+    (0x1D9C, 'M', 'c'),
+    (0x1D9D, 'M', 'ɕ'),
+    (0x1D9E, 'M', 'ð'),
+    (0x1D9F, 'M', 'ɜ'),
+    (0x1DA0, 'M', 'f'),
+    (0x1DA1, 'M', 'ɟ'),
+    (0x1DA2, 'M', 'ɡ'),
+    (0x1DA3, 'M', 'ɥ'),
+    (0x1DA4, 'M', 'ɨ'),
+    (0x1DA5, 'M', 'ɩ'),
+    (0x1DA6, 'M', 'ɪ'),
+    (0x1DA7, 'M', 'ᵻ'),
+    (0x1DA8, 'M', 'ʝ'),
+    (0x1DA9, 'M', 'ɭ'),
+    (0x1DAA, 'M', 'ᶅ'),
+    (0x1DAB, 'M', 'ʟ'),
+    (0x1DAC, 'M', 'ɱ'),
+    (0x1DAD, 'M', 'ɰ'),
+    (0x1DAE, 'M', 'ɲ'),
+    (0x1DAF, 'M', 'ɳ'),
+    (0x1DB0, 'M', 'ɴ'),
+    (0x1DB1, 'M', 'ɵ'),
+    (0x1DB2, 'M', 'ɸ'),
+    (0x1DB3, 'M', 'ʂ'),
+    (0x1DB4, 'M', 'ʃ'),
+    (0x1DB5, 'M', 'ƫ'),
+    (0x1DB6, 'M', 'ʉ'),
+    (0x1DB7, 'M', 'ʊ'),
+    (0x1DB8, 'M', 'ᴜ'),
+    (0x1DB9, 'M', 'ʋ'),
+    (0x1DBA, 'M', 'ʌ'),
+    (0x1DBB, 'M', 'z'),
+    (0x1DBC, 'M', 'ʐ'),
+    (0x1DBD, 'M', 'ʑ'),
+    (0x1DBE, 'M', 'ʒ'),
+    (0x1DBF, 'M', 'θ'),
+    (0x1DC0, 'V'),
+    (0x1E00, 'M', 'ḁ'),
+    (0x1E01, 'V'),
+    (0x1E02, 'M', 'ḃ'),
+    (0x1E03, 'V'),
+    (0x1E04, 'M', 'ḅ'),
+    (0x1E05, 'V'),
+    (0x1E06, 'M', 'ḇ'),
+    (0x1E07, 'V'),
+    (0x1E08, 'M', 'ḉ'),
+    (0x1E09, 'V'),
+    (0x1E0A, 'M', 'ḋ'),
+    (0x1E0B, 'V'),
+    (0x1E0C, 'M', 'ḍ'),
+    (0x1E0D, 'V'),
+    (0x1E0E, 'M', 'ḏ'),
+    (0x1E0F, 'V'),
+    (0x1E10, 'M', 'ḑ'),
+    (0x1E11, 'V'),
+    (0x1E12, 'M', 'ḓ'),
+    (0x1E13, 'V'),
+    (0x1E14, 'M', 'ḕ'),
+    (0x1E15, 'V'),
+    (0x1E16, 'M', 'ḗ'),
+    (0x1E17, 'V'),
+    (0x1E18, 'M', 'ḙ'),
+    (0x1E19, 'V'),
+    (0x1E1A, 'M', 'ḛ'),
+    (0x1E1B, 'V'),
+    (0x1E1C, 'M', 'ḝ'),
+    (0x1E1D, 'V'),
+    (0x1E1E, 'M', 'ḟ'),
+    (0x1E1F, 'V'),
+    (0x1E20, 'M', 'ḡ'),
+    (0x1E21, 'V'),
+    (0x1E22, 'M', 'ḣ'),
+    (0x1E23, 'V'),
+    ]
+
+def _seg_17() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1E24, 'M', 'ḥ'),
+    (0x1E25, 'V'),
+    (0x1E26, 'M', 'ḧ'),
+    (0x1E27, 'V'),
+    (0x1E28, 'M', 'ḩ'),
+    (0x1E29, 'V'),
+    (0x1E2A, 'M', 'ḫ'),
+    (0x1E2B, 'V'),
+    (0x1E2C, 'M', 'ḭ'),
+    (0x1E2D, 'V'),
+    (0x1E2E, 'M', 'ḯ'),
+    (0x1E2F, 'V'),
+    (0x1E30, 'M', 'ḱ'),
+    (0x1E31, 'V'),
+    (0x1E32, 'M', 'ḳ'),
+    (0x1E33, 'V'),
+    (0x1E34, 'M', 'ḵ'),
+    (0x1E35, 'V'),
+    (0x1E36, 'M', 'ḷ'),
+    (0x1E37, 'V'),
+    (0x1E38, 'M', 'ḹ'),
+    (0x1E39, 'V'),
+    (0x1E3A, 'M', 'ḻ'),
+    (0x1E3B, 'V'),
+    (0x1E3C, 'M', 'ḽ'),
+    (0x1E3D, 'V'),
+    (0x1E3E, 'M', 'ḿ'),
+    (0x1E3F, 'V'),
+    (0x1E40, 'M', 'ṁ'),
+    (0x1E41, 'V'),
+    (0x1E42, 'M', 'ṃ'),
+    (0x1E43, 'V'),
+    (0x1E44, 'M', 'ṅ'),
+    (0x1E45, 'V'),
+    (0x1E46, 'M', 'ṇ'),
+    (0x1E47, 'V'),
+    (0x1E48, 'M', 'ṉ'),
+    (0x1E49, 'V'),
+    (0x1E4A, 'M', 'ṋ'),
+    (0x1E4B, 'V'),
+    (0x1E4C, 'M', 'ṍ'),
+    (0x1E4D, 'V'),
+    (0x1E4E, 'M', 'ṏ'),
+    (0x1E4F, 'V'),
+    (0x1E50, 'M', 'ṑ'),
+    (0x1E51, 'V'),
+    (0x1E52, 'M', 'ṓ'),
+    (0x1E53, 'V'),
+    (0x1E54, 'M', 'ṕ'),
+    (0x1E55, 'V'),
+    (0x1E56, 'M', 'ṗ'),
+    (0x1E57, 'V'),
+    (0x1E58, 'M', 'ṙ'),
+    (0x1E59, 'V'),
+    (0x1E5A, 'M', 'ṛ'),
+    (0x1E5B, 'V'),
+    (0x1E5C, 'M', 'ṝ'),
+    (0x1E5D, 'V'),
+    (0x1E5E, 'M', 'ṟ'),
+    (0x1E5F, 'V'),
+    (0x1E60, 'M', 'ṡ'),
+    (0x1E61, 'V'),
+    (0x1E62, 'M', 'ṣ'),
+    (0x1E63, 'V'),
+    (0x1E64, 'M', 'ṥ'),
+    (0x1E65, 'V'),
+    (0x1E66, 'M', 'ṧ'),
+    (0x1E67, 'V'),
+    (0x1E68, 'M', 'ṩ'),
+    (0x1E69, 'V'),
+    (0x1E6A, 'M', 'ṫ'),
+    (0x1E6B, 'V'),
+    (0x1E6C, 'M', 'ṭ'),
+    (0x1E6D, 'V'),
+    (0x1E6E, 'M', 'ṯ'),
+    (0x1E6F, 'V'),
+    (0x1E70, 'M', 'ṱ'),
+    (0x1E71, 'V'),
+    (0x1E72, 'M', 'ṳ'),
+    (0x1E73, 'V'),
+    (0x1E74, 'M', 'ṵ'),
+    (0x1E75, 'V'),
+    (0x1E76, 'M', 'ṷ'),
+    (0x1E77, 'V'),
+    (0x1E78, 'M', 'ṹ'),
+    (0x1E79, 'V'),
+    (0x1E7A, 'M', 'ṻ'),
+    (0x1E7B, 'V'),
+    (0x1E7C, 'M', 'ṽ'),
+    (0x1E7D, 'V'),
+    (0x1E7E, 'M', 'ṿ'),
+    (0x1E7F, 'V'),
+    (0x1E80, 'M', 'ẁ'),
+    (0x1E81, 'V'),
+    (0x1E82, 'M', 'ẃ'),
+    (0x1E83, 'V'),
+    (0x1E84, 'M', 'ẅ'),
+    (0x1E85, 'V'),
+    (0x1E86, 'M', 'ẇ'),
+    (0x1E87, 'V'),
+    ]
+
+def _seg_18() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1E88, 'M', 'ẉ'),
+    (0x1E89, 'V'),
+    (0x1E8A, 'M', 'ẋ'),
+    (0x1E8B, 'V'),
+    (0x1E8C, 'M', 'ẍ'),
+    (0x1E8D, 'V'),
+    (0x1E8E, 'M', 'ẏ'),
+    (0x1E8F, 'V'),
+    (0x1E90, 'M', 'ẑ'),
+    (0x1E91, 'V'),
+    (0x1E92, 'M', 'ẓ'),
+    (0x1E93, 'V'),
+    (0x1E94, 'M', 'ẕ'),
+    (0x1E95, 'V'),
+    (0x1E9A, 'M', 'aʾ'),
+    (0x1E9B, 'M', 'ṡ'),
+    (0x1E9C, 'V'),
+    (0x1E9E, 'M', 'ss'),
+    (0x1E9F, 'V'),
+    (0x1EA0, 'M', 'ạ'),
+    (0x1EA1, 'V'),
+    (0x1EA2, 'M', 'ả'),
+    (0x1EA3, 'V'),
+    (0x1EA4, 'M', 'ấ'),
+    (0x1EA5, 'V'),
+    (0x1EA6, 'M', 'ầ'),
+    (0x1EA7, 'V'),
+    (0x1EA8, 'M', 'ẩ'),
+    (0x1EA9, 'V'),
+    (0x1EAA, 'M', 'ẫ'),
+    (0x1EAB, 'V'),
+    (0x1EAC, 'M', 'ậ'),
+    (0x1EAD, 'V'),
+    (0x1EAE, 'M', 'ắ'),
+    (0x1EAF, 'V'),
+    (0x1EB0, 'M', 'ằ'),
+    (0x1EB1, 'V'),
+    (0x1EB2, 'M', 'ẳ'),
+    (0x1EB3, 'V'),
+    (0x1EB4, 'M', 'ẵ'),
+    (0x1EB5, 'V'),
+    (0x1EB6, 'M', 'ặ'),
+    (0x1EB7, 'V'),
+    (0x1EB8, 'M', 'ẹ'),
+    (0x1EB9, 'V'),
+    (0x1EBA, 'M', 'ẻ'),
+    (0x1EBB, 'V'),
+    (0x1EBC, 'M', 'ẽ'),
+    (0x1EBD, 'V'),
+    (0x1EBE, 'M', 'ế'),
+    (0x1EBF, 'V'),
+    (0x1EC0, 'M', 'ề'),
+    (0x1EC1, 'V'),
+    (0x1EC2, 'M', 'ể'),
+    (0x1EC3, 'V'),
+    (0x1EC4, 'M', 'ễ'),
+    (0x1EC5, 'V'),
+    (0x1EC6, 'M', 'ệ'),
+    (0x1EC7, 'V'),
+    (0x1EC8, 'M', 'ỉ'),
+    (0x1EC9, 'V'),
+    (0x1ECA, 'M', 'ị'),
+    (0x1ECB, 'V'),
+    (0x1ECC, 'M', 'ọ'),
+    (0x1ECD, 'V'),
+    (0x1ECE, 'M', 'ỏ'),
+    (0x1ECF, 'V'),
+    (0x1ED0, 'M', 'ố'),
+    (0x1ED1, 'V'),
+    (0x1ED2, 'M', 'ồ'),
+    (0x1ED3, 'V'),
+    (0x1ED4, 'M', 'ổ'),
+    (0x1ED5, 'V'),
+    (0x1ED6, 'M', 'ỗ'),
+    (0x1ED7, 'V'),
+    (0x1ED8, 'M', 'ộ'),
+    (0x1ED9, 'V'),
+    (0x1EDA, 'M', 'ớ'),
+    (0x1EDB, 'V'),
+    (0x1EDC, 'M', 'ờ'),
+    (0x1EDD, 'V'),
+    (0x1EDE, 'M', 'ở'),
+    (0x1EDF, 'V'),
+    (0x1EE0, 'M', 'ỡ'),
+    (0x1EE1, 'V'),
+    (0x1EE2, 'M', 'ợ'),
+    (0x1EE3, 'V'),
+    (0x1EE4, 'M', 'ụ'),
+    (0x1EE5, 'V'),
+    (0x1EE6, 'M', 'ủ'),
+    (0x1EE7, 'V'),
+    (0x1EE8, 'M', 'ứ'),
+    (0x1EE9, 'V'),
+    (0x1EEA, 'M', 'ừ'),
+    (0x1EEB, 'V'),
+    (0x1EEC, 'M', 'ử'),
+    (0x1EED, 'V'),
+    (0x1EEE, 'M', 'ữ'),
+    (0x1EEF, 'V'),
+    (0x1EF0, 'M', 'ự'),
+    ]
+
+def _seg_19() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1EF1, 'V'),
+    (0x1EF2, 'M', 'ỳ'),
+    (0x1EF3, 'V'),
+    (0x1EF4, 'M', 'ỵ'),
+    (0x1EF5, 'V'),
+    (0x1EF6, 'M', 'ỷ'),
+    (0x1EF7, 'V'),
+    (0x1EF8, 'M', 'ỹ'),
+    (0x1EF9, 'V'),
+    (0x1EFA, 'M', 'ỻ'),
+    (0x1EFB, 'V'),
+    (0x1EFC, 'M', 'ỽ'),
+    (0x1EFD, 'V'),
+    (0x1EFE, 'M', 'ỿ'),
+    (0x1EFF, 'V'),
+    (0x1F08, 'M', 'ἀ'),
+    (0x1F09, 'M', 'ἁ'),
+    (0x1F0A, 'M', 'ἂ'),
+    (0x1F0B, 'M', 'ἃ'),
+    (0x1F0C, 'M', 'ἄ'),
+    (0x1F0D, 'M', 'ἅ'),
+    (0x1F0E, 'M', 'ἆ'),
+    (0x1F0F, 'M', 'ἇ'),
+    (0x1F10, 'V'),
+    (0x1F16, 'X'),
+    (0x1F18, 'M', 'ἐ'),
+    (0x1F19, 'M', 'ἑ'),
+    (0x1F1A, 'M', 'ἒ'),
+    (0x1F1B, 'M', 'ἓ'),
+    (0x1F1C, 'M', 'ἔ'),
+    (0x1F1D, 'M', 'ἕ'),
+    (0x1F1E, 'X'),
+    (0x1F20, 'V'),
+    (0x1F28, 'M', 'ἠ'),
+    (0x1F29, 'M', 'ἡ'),
+    (0x1F2A, 'M', 'ἢ'),
+    (0x1F2B, 'M', 'ἣ'),
+    (0x1F2C, 'M', 'ἤ'),
+    (0x1F2D, 'M', 'ἥ'),
+    (0x1F2E, 'M', 'ἦ'),
+    (0x1F2F, 'M', 'ἧ'),
+    (0x1F30, 'V'),
+    (0x1F38, 'M', 'ἰ'),
+    (0x1F39, 'M', 'ἱ'),
+    (0x1F3A, 'M', 'ἲ'),
+    (0x1F3B, 'M', 'ἳ'),
+    (0x1F3C, 'M', 'ἴ'),
+    (0x1F3D, 'M', 'ἵ'),
+    (0x1F3E, 'M', 'ἶ'),
+    (0x1F3F, 'M', 'ἷ'),
+    (0x1F40, 'V'),
+    (0x1F46, 'X'),
+    (0x1F48, 'M', 'ὀ'),
+    (0x1F49, 'M', 'ὁ'),
+    (0x1F4A, 'M', 'ὂ'),
+    (0x1F4B, 'M', 'ὃ'),
+    (0x1F4C, 'M', 'ὄ'),
+    (0x1F4D, 'M', 'ὅ'),
+    (0x1F4E, 'X'),
+    (0x1F50, 'V'),
+    (0x1F58, 'X'),
+    (0x1F59, 'M', 'ὑ'),
+    (0x1F5A, 'X'),
+    (0x1F5B, 'M', 'ὓ'),
+    (0x1F5C, 'X'),
+    (0x1F5D, 'M', 'ὕ'),
+    (0x1F5E, 'X'),
+    (0x1F5F, 'M', 'ὗ'),
+    (0x1F60, 'V'),
+    (0x1F68, 'M', 'ὠ'),
+    (0x1F69, 'M', 'ὡ'),
+    (0x1F6A, 'M', 'ὢ'),
+    (0x1F6B, 'M', 'ὣ'),
+    (0x1F6C, 'M', 'ὤ'),
+    (0x1F6D, 'M', 'ὥ'),
+    (0x1F6E, 'M', 'ὦ'),
+    (0x1F6F, 'M', 'ὧ'),
+    (0x1F70, 'V'),
+    (0x1F71, 'M', 'ά'),
+    (0x1F72, 'V'),
+    (0x1F73, 'M', 'έ'),
+    (0x1F74, 'V'),
+    (0x1F75, 'M', 'ή'),
+    (0x1F76, 'V'),
+    (0x1F77, 'M', 'ί'),
+    (0x1F78, 'V'),
+    (0x1F79, 'M', 'ό'),
+    (0x1F7A, 'V'),
+    (0x1F7B, 'M', 'ύ'),
+    (0x1F7C, 'V'),
+    (0x1F7D, 'M', 'ώ'),
+    (0x1F7E, 'X'),
+    (0x1F80, 'M', 'ἀι'),
+    (0x1F81, 'M', 'ἁι'),
+    (0x1F82, 'M', 'ἂι'),
+    (0x1F83, 'M', 'ἃι'),
+    (0x1F84, 'M', 'ἄι'),
+    (0x1F85, 'M', 'ἅι'),
+    (0x1F86, 'M', 'ἆι'),
+    (0x1F87, 'M', 'ἇι'),
+    ]
+
+def _seg_20() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1F88, 'M', 'ἀι'),
+    (0x1F89, 'M', 'ἁι'),
+    (0x1F8A, 'M', 'ἂι'),
+    (0x1F8B, 'M', 'ἃι'),
+    (0x1F8C, 'M', 'ἄι'),
+    (0x1F8D, 'M', 'ἅι'),
+    (0x1F8E, 'M', 'ἆι'),
+    (0x1F8F, 'M', 'ἇι'),
+    (0x1F90, 'M', 'ἠι'),
+    (0x1F91, 'M', 'ἡι'),
+    (0x1F92, 'M', 'ἢι'),
+    (0x1F93, 'M', 'ἣι'),
+    (0x1F94, 'M', 'ἤι'),
+    (0x1F95, 'M', 'ἥι'),
+    (0x1F96, 'M', 'ἦι'),
+    (0x1F97, 'M', 'ἧι'),
+    (0x1F98, 'M', 'ἠι'),
+    (0x1F99, 'M', 'ἡι'),
+    (0x1F9A, 'M', 'ἢι'),
+    (0x1F9B, 'M', 'ἣι'),
+    (0x1F9C, 'M', 'ἤι'),
+    (0x1F9D, 'M', 'ἥι'),
+    (0x1F9E, 'M', 'ἦι'),
+    (0x1F9F, 'M', 'ἧι'),
+    (0x1FA0, 'M', 'ὠι'),
+    (0x1FA1, 'M', 'ὡι'),
+    (0x1FA2, 'M', 'ὢι'),
+    (0x1FA3, 'M', 'ὣι'),
+    (0x1FA4, 'M', 'ὤι'),
+    (0x1FA5, 'M', 'ὥι'),
+    (0x1FA6, 'M', 'ὦι'),
+    (0x1FA7, 'M', 'ὧι'),
+    (0x1FA8, 'M', 'ὠι'),
+    (0x1FA9, 'M', 'ὡι'),
+    (0x1FAA, 'M', 'ὢι'),
+    (0x1FAB, 'M', 'ὣι'),
+    (0x1FAC, 'M', 'ὤι'),
+    (0x1FAD, 'M', 'ὥι'),
+    (0x1FAE, 'M', 'ὦι'),
+    (0x1FAF, 'M', 'ὧι'),
+    (0x1FB0, 'V'),
+    (0x1FB2, 'M', 'ὰι'),
+    (0x1FB3, 'M', 'αι'),
+    (0x1FB4, 'M', 'άι'),
+    (0x1FB5, 'X'),
+    (0x1FB6, 'V'),
+    (0x1FB7, 'M', 'ᾶι'),
+    (0x1FB8, 'M', 'ᾰ'),
+    (0x1FB9, 'M', 'ᾱ'),
+    (0x1FBA, 'M', 'ὰ'),
+    (0x1FBB, 'M', 'ά'),
+    (0x1FBC, 'M', 'αι'),
+    (0x1FBD, '3', ' ̓'),
+    (0x1FBE, 'M', 'ι'),
+    (0x1FBF, '3', ' ̓'),
+    (0x1FC0, '3', ' ͂'),
+    (0x1FC1, '3', ' ̈͂'),
+    (0x1FC2, 'M', 'ὴι'),
+    (0x1FC3, 'M', 'ηι'),
+    (0x1FC4, 'M', 'ήι'),
+    (0x1FC5, 'X'),
+    (0x1FC6, 'V'),
+    (0x1FC7, 'M', 'ῆι'),
+    (0x1FC8, 'M', 'ὲ'),
+    (0x1FC9, 'M', 'έ'),
+    (0x1FCA, 'M', 'ὴ'),
+    (0x1FCB, 'M', 'ή'),
+    (0x1FCC, 'M', 'ηι'),
+    (0x1FCD, '3', ' ̓̀'),
+    (0x1FCE, '3', ' ̓́'),
+    (0x1FCF, '3', ' ̓͂'),
+    (0x1FD0, 'V'),
+    (0x1FD3, 'M', 'ΐ'),
+    (0x1FD4, 'X'),
+    (0x1FD6, 'V'),
+    (0x1FD8, 'M', 'ῐ'),
+    (0x1FD9, 'M', 'ῑ'),
+    (0x1FDA, 'M', 'ὶ'),
+    (0x1FDB, 'M', 'ί'),
+    (0x1FDC, 'X'),
+    (0x1FDD, '3', ' ̔̀'),
+    (0x1FDE, '3', ' ̔́'),
+    (0x1FDF, '3', ' ̔͂'),
+    (0x1FE0, 'V'),
+    (0x1FE3, 'M', 'ΰ'),
+    (0x1FE4, 'V'),
+    (0x1FE8, 'M', 'ῠ'),
+    (0x1FE9, 'M', 'ῡ'),
+    (0x1FEA, 'M', 'ὺ'),
+    (0x1FEB, 'M', 'ύ'),
+    (0x1FEC, 'M', 'ῥ'),
+    (0x1FED, '3', ' ̈̀'),
+    (0x1FEE, '3', ' ̈́'),
+    (0x1FEF, '3', '`'),
+    (0x1FF0, 'X'),
+    (0x1FF2, 'M', 'ὼι'),
+    (0x1FF3, 'M', 'ωι'),
+    (0x1FF4, 'M', 'ώι'),
+    (0x1FF5, 'X'),
+    (0x1FF6, 'V'),
+    ]
+
+def _seg_21() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1FF7, 'M', 'ῶι'),
+    (0x1FF8, 'M', 'ὸ'),
+    (0x1FF9, 'M', 'ό'),
+    (0x1FFA, 'M', 'ὼ'),
+    (0x1FFB, 'M', 'ώ'),
+    (0x1FFC, 'M', 'ωι'),
+    (0x1FFD, '3', ' ́'),
+    (0x1FFE, '3', ' ̔'),
+    (0x1FFF, 'X'),
+    (0x2000, '3', ' '),
+    (0x200B, 'I'),
+    (0x200C, 'D', ''),
+    (0x200E, 'X'),
+    (0x2010, 'V'),
+    (0x2011, 'M', '‐'),
+    (0x2012, 'V'),
+    (0x2017, '3', ' ̳'),
+    (0x2018, 'V'),
+    (0x2024, 'X'),
+    (0x2027, 'V'),
+    (0x2028, 'X'),
+    (0x202F, '3', ' '),
+    (0x2030, 'V'),
+    (0x2033, 'M', '′′'),
+    (0x2034, 'M', '′′′'),
+    (0x2035, 'V'),
+    (0x2036, 'M', '‵‵'),
+    (0x2037, 'M', '‵‵‵'),
+    (0x2038, 'V'),
+    (0x203C, '3', '!!'),
+    (0x203D, 'V'),
+    (0x203E, '3', ' ̅'),
+    (0x203F, 'V'),
+    (0x2047, '3', '??'),
+    (0x2048, '3', '?!'),
+    (0x2049, '3', '!?'),
+    (0x204A, 'V'),
+    (0x2057, 'M', '′′′′'),
+    (0x2058, 'V'),
+    (0x205F, '3', ' '),
+    (0x2060, 'I'),
+    (0x2061, 'X'),
+    (0x2064, 'I'),
+    (0x2065, 'X'),
+    (0x2070, 'M', '0'),
+    (0x2071, 'M', 'i'),
+    (0x2072, 'X'),
+    (0x2074, 'M', '4'),
+    (0x2075, 'M', '5'),
+    (0x2076, 'M', '6'),
+    (0x2077, 'M', '7'),
+    (0x2078, 'M', '8'),
+    (0x2079, 'M', '9'),
+    (0x207A, '3', '+'),
+    (0x207B, 'M', '−'),
+    (0x207C, '3', '='),
+    (0x207D, '3', '('),
+    (0x207E, '3', ')'),
+    (0x207F, 'M', 'n'),
+    (0x2080, 'M', '0'),
+    (0x2081, 'M', '1'),
+    (0x2082, 'M', '2'),
+    (0x2083, 'M', '3'),
+    (0x2084, 'M', '4'),
+    (0x2085, 'M', '5'),
+    (0x2086, 'M', '6'),
+    (0x2087, 'M', '7'),
+    (0x2088, 'M', '8'),
+    (0x2089, 'M', '9'),
+    (0x208A, '3', '+'),
+    (0x208B, 'M', '−'),
+    (0x208C, '3', '='),
+    (0x208D, '3', '('),
+    (0x208E, '3', ')'),
+    (0x208F, 'X'),
+    (0x2090, 'M', 'a'),
+    (0x2091, 'M', 'e'),
+    (0x2092, 'M', 'o'),
+    (0x2093, 'M', 'x'),
+    (0x2094, 'M', 'ə'),
+    (0x2095, 'M', 'h'),
+    (0x2096, 'M', 'k'),
+    (0x2097, 'M', 'l'),
+    (0x2098, 'M', 'm'),
+    (0x2099, 'M', 'n'),
+    (0x209A, 'M', 'p'),
+    (0x209B, 'M', 's'),
+    (0x209C, 'M', 't'),
+    (0x209D, 'X'),
+    (0x20A0, 'V'),
+    (0x20A8, 'M', 'rs'),
+    (0x20A9, 'V'),
+    (0x20C1, 'X'),
+    (0x20D0, 'V'),
+    (0x20F1, 'X'),
+    (0x2100, '3', 'a/c'),
+    (0x2101, '3', 'a/s'),
+    (0x2102, 'M', 'c'),
+    (0x2103, 'M', '°c'),
+    (0x2104, 'V'),
+    ]
+
+def _seg_22() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2105, '3', 'c/o'),
+    (0x2106, '3', 'c/u'),
+    (0x2107, 'M', 'ɛ'),
+    (0x2108, 'V'),
+    (0x2109, 'M', '°f'),
+    (0x210A, 'M', 'g'),
+    (0x210B, 'M', 'h'),
+    (0x210F, 'M', 'ħ'),
+    (0x2110, 'M', 'i'),
+    (0x2112, 'M', 'l'),
+    (0x2114, 'V'),
+    (0x2115, 'M', 'n'),
+    (0x2116, 'M', 'no'),
+    (0x2117, 'V'),
+    (0x2119, 'M', 'p'),
+    (0x211A, 'M', 'q'),
+    (0x211B, 'M', 'r'),
+    (0x211E, 'V'),
+    (0x2120, 'M', 'sm'),
+    (0x2121, 'M', 'tel'),
+    (0x2122, 'M', 'tm'),
+    (0x2123, 'V'),
+    (0x2124, 'M', 'z'),
+    (0x2125, 'V'),
+    (0x2126, 'M', 'ω'),
+    (0x2127, 'V'),
+    (0x2128, 'M', 'z'),
+    (0x2129, 'V'),
+    (0x212A, 'M', 'k'),
+    (0x212B, 'M', 'å'),
+    (0x212C, 'M', 'b'),
+    (0x212D, 'M', 'c'),
+    (0x212E, 'V'),
+    (0x212F, 'M', 'e'),
+    (0x2131, 'M', 'f'),
+    (0x2132, 'X'),
+    (0x2133, 'M', 'm'),
+    (0x2134, 'M', 'o'),
+    (0x2135, 'M', 'א'),
+    (0x2136, 'M', 'ב'),
+    (0x2137, 'M', 'ג'),
+    (0x2138, 'M', 'ד'),
+    (0x2139, 'M', 'i'),
+    (0x213A, 'V'),
+    (0x213B, 'M', 'fax'),
+    (0x213C, 'M', 'π'),
+    (0x213D, 'M', 'γ'),
+    (0x213F, 'M', 'π'),
+    (0x2140, 'M', '∑'),
+    (0x2141, 'V'),
+    (0x2145, 'M', 'd'),
+    (0x2147, 'M', 'e'),
+    (0x2148, 'M', 'i'),
+    (0x2149, 'M', 'j'),
+    (0x214A, 'V'),
+    (0x2150, 'M', '1⁄7'),
+    (0x2151, 'M', '1⁄9'),
+    (0x2152, 'M', '1⁄10'),
+    (0x2153, 'M', '1⁄3'),
+    (0x2154, 'M', '2⁄3'),
+    (0x2155, 'M', '1⁄5'),
+    (0x2156, 'M', '2⁄5'),
+    (0x2157, 'M', '3⁄5'),
+    (0x2158, 'M', '4⁄5'),
+    (0x2159, 'M', '1⁄6'),
+    (0x215A, 'M', '5⁄6'),
+    (0x215B, 'M', '1⁄8'),
+    (0x215C, 'M', '3⁄8'),
+    (0x215D, 'M', '5⁄8'),
+    (0x215E, 'M', '7⁄8'),
+    (0x215F, 'M', '1⁄'),
+    (0x2160, 'M', 'i'),
+    (0x2161, 'M', 'ii'),
+    (0x2162, 'M', 'iii'),
+    (0x2163, 'M', 'iv'),
+    (0x2164, 'M', 'v'),
+    (0x2165, 'M', 'vi'),
+    (0x2166, 'M', 'vii'),
+    (0x2167, 'M', 'viii'),
+    (0x2168, 'M', 'ix'),
+    (0x2169, 'M', 'x'),
+    (0x216A, 'M', 'xi'),
+    (0x216B, 'M', 'xii'),
+    (0x216C, 'M', 'l'),
+    (0x216D, 'M', 'c'),
+    (0x216E, 'M', 'd'),
+    (0x216F, 'M', 'm'),
+    (0x2170, 'M', 'i'),
+    (0x2171, 'M', 'ii'),
+    (0x2172, 'M', 'iii'),
+    (0x2173, 'M', 'iv'),
+    (0x2174, 'M', 'v'),
+    (0x2175, 'M', 'vi'),
+    (0x2176, 'M', 'vii'),
+    (0x2177, 'M', 'viii'),
+    (0x2178, 'M', 'ix'),
+    (0x2179, 'M', 'x'),
+    (0x217A, 'M', 'xi'),
+    (0x217B, 'M', 'xii'),
+    (0x217C, 'M', 'l'),
+    ]
+
+def _seg_23() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x217D, 'M', 'c'),
+    (0x217E, 'M', 'd'),
+    (0x217F, 'M', 'm'),
+    (0x2180, 'V'),
+    (0x2183, 'X'),
+    (0x2184, 'V'),
+    (0x2189, 'M', '0⁄3'),
+    (0x218A, 'V'),
+    (0x218C, 'X'),
+    (0x2190, 'V'),
+    (0x222C, 'M', '∫∫'),
+    (0x222D, 'M', '∫∫∫'),
+    (0x222E, 'V'),
+    (0x222F, 'M', '∮∮'),
+    (0x2230, 'M', '∮∮∮'),
+    (0x2231, 'V'),
+    (0x2260, '3'),
+    (0x2261, 'V'),
+    (0x226E, '3'),
+    (0x2270, 'V'),
+    (0x2329, 'M', '〈'),
+    (0x232A, 'M', '〉'),
+    (0x232B, 'V'),
+    (0x2427, 'X'),
+    (0x2440, 'V'),
+    (0x244B, 'X'),
+    (0x2460, 'M', '1'),
+    (0x2461, 'M', '2'),
+    (0x2462, 'M', '3'),
+    (0x2463, 'M', '4'),
+    (0x2464, 'M', '5'),
+    (0x2465, 'M', '6'),
+    (0x2466, 'M', '7'),
+    (0x2467, 'M', '8'),
+    (0x2468, 'M', '9'),
+    (0x2469, 'M', '10'),
+    (0x246A, 'M', '11'),
+    (0x246B, 'M', '12'),
+    (0x246C, 'M', '13'),
+    (0x246D, 'M', '14'),
+    (0x246E, 'M', '15'),
+    (0x246F, 'M', '16'),
+    (0x2470, 'M', '17'),
+    (0x2471, 'M', '18'),
+    (0x2472, 'M', '19'),
+    (0x2473, 'M', '20'),
+    (0x2474, '3', '(1)'),
+    (0x2475, '3', '(2)'),
+    (0x2476, '3', '(3)'),
+    (0x2477, '3', '(4)'),
+    (0x2478, '3', '(5)'),
+    (0x2479, '3', '(6)'),
+    (0x247A, '3', '(7)'),
+    (0x247B, '3', '(8)'),
+    (0x247C, '3', '(9)'),
+    (0x247D, '3', '(10)'),
+    (0x247E, '3', '(11)'),
+    (0x247F, '3', '(12)'),
+    (0x2480, '3', '(13)'),
+    (0x2481, '3', '(14)'),
+    (0x2482, '3', '(15)'),
+    (0x2483, '3', '(16)'),
+    (0x2484, '3', '(17)'),
+    (0x2485, '3', '(18)'),
+    (0x2486, '3', '(19)'),
+    (0x2487, '3', '(20)'),
+    (0x2488, 'X'),
+    (0x249C, '3', '(a)'),
+    (0x249D, '3', '(b)'),
+    (0x249E, '3', '(c)'),
+    (0x249F, '3', '(d)'),
+    (0x24A0, '3', '(e)'),
+    (0x24A1, '3', '(f)'),
+    (0x24A2, '3', '(g)'),
+    (0x24A3, '3', '(h)'),
+    (0x24A4, '3', '(i)'),
+    (0x24A5, '3', '(j)'),
+    (0x24A6, '3', '(k)'),
+    (0x24A7, '3', '(l)'),
+    (0x24A8, '3', '(m)'),
+    (0x24A9, '3', '(n)'),
+    (0x24AA, '3', '(o)'),
+    (0x24AB, '3', '(p)'),
+    (0x24AC, '3', '(q)'),
+    (0x24AD, '3', '(r)'),
+    (0x24AE, '3', '(s)'),
+    (0x24AF, '3', '(t)'),
+    (0x24B0, '3', '(u)'),
+    (0x24B1, '3', '(v)'),
+    (0x24B2, '3', '(w)'),
+    (0x24B3, '3', '(x)'),
+    (0x24B4, '3', '(y)'),
+    (0x24B5, '3', '(z)'),
+    (0x24B6, 'M', 'a'),
+    (0x24B7, 'M', 'b'),
+    (0x24B8, 'M', 'c'),
+    (0x24B9, 'M', 'd'),
+    (0x24BA, 'M', 'e'),
+    (0x24BB, 'M', 'f'),
+    (0x24BC, 'M', 'g'),
+    ]
+
+def _seg_24() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x24BD, 'M', 'h'),
+    (0x24BE, 'M', 'i'),
+    (0x24BF, 'M', 'j'),
+    (0x24C0, 'M', 'k'),
+    (0x24C1, 'M', 'l'),
+    (0x24C2, 'M', 'm'),
+    (0x24C3, 'M', 'n'),
+    (0x24C4, 'M', 'o'),
+    (0x24C5, 'M', 'p'),
+    (0x24C6, 'M', 'q'),
+    (0x24C7, 'M', 'r'),
+    (0x24C8, 'M', 's'),
+    (0x24C9, 'M', 't'),
+    (0x24CA, 'M', 'u'),
+    (0x24CB, 'M', 'v'),
+    (0x24CC, 'M', 'w'),
+    (0x24CD, 'M', 'x'),
+    (0x24CE, 'M', 'y'),
+    (0x24CF, 'M', 'z'),
+    (0x24D0, 'M', 'a'),
+    (0x24D1, 'M', 'b'),
+    (0x24D2, 'M', 'c'),
+    (0x24D3, 'M', 'd'),
+    (0x24D4, 'M', 'e'),
+    (0x24D5, 'M', 'f'),
+    (0x24D6, 'M', 'g'),
+    (0x24D7, 'M', 'h'),
+    (0x24D8, 'M', 'i'),
+    (0x24D9, 'M', 'j'),
+    (0x24DA, 'M', 'k'),
+    (0x24DB, 'M', 'l'),
+    (0x24DC, 'M', 'm'),
+    (0x24DD, 'M', 'n'),
+    (0x24DE, 'M', 'o'),
+    (0x24DF, 'M', 'p'),
+    (0x24E0, 'M', 'q'),
+    (0x24E1, 'M', 'r'),
+    (0x24E2, 'M', 's'),
+    (0x24E3, 'M', 't'),
+    (0x24E4, 'M', 'u'),
+    (0x24E5, 'M', 'v'),
+    (0x24E6, 'M', 'w'),
+    (0x24E7, 'M', 'x'),
+    (0x24E8, 'M', 'y'),
+    (0x24E9, 'M', 'z'),
+    (0x24EA, 'M', '0'),
+    (0x24EB, 'V'),
+    (0x2A0C, 'M', '∫∫∫∫'),
+    (0x2A0D, 'V'),
+    (0x2A74, '3', '::='),
+    (0x2A75, '3', '=='),
+    (0x2A76, '3', '==='),
+    (0x2A77, 'V'),
+    (0x2ADC, 'M', '⫝̸'),
+    (0x2ADD, 'V'),
+    (0x2B74, 'X'),
+    (0x2B76, 'V'),
+    (0x2B96, 'X'),
+    (0x2B97, 'V'),
+    (0x2C00, 'M', 'ⰰ'),
+    (0x2C01, 'M', 'ⰱ'),
+    (0x2C02, 'M', 'ⰲ'),
+    (0x2C03, 'M', 'ⰳ'),
+    (0x2C04, 'M', 'ⰴ'),
+    (0x2C05, 'M', 'ⰵ'),
+    (0x2C06, 'M', 'ⰶ'),
+    (0x2C07, 'M', 'ⰷ'),
+    (0x2C08, 'M', 'ⰸ'),
+    (0x2C09, 'M', 'ⰹ'),
+    (0x2C0A, 'M', 'ⰺ'),
+    (0x2C0B, 'M', 'ⰻ'),
+    (0x2C0C, 'M', 'ⰼ'),
+    (0x2C0D, 'M', 'ⰽ'),
+    (0x2C0E, 'M', 'ⰾ'),
+    (0x2C0F, 'M', 'ⰿ'),
+    (0x2C10, 'M', 'ⱀ'),
+    (0x2C11, 'M', 'ⱁ'),
+    (0x2C12, 'M', 'ⱂ'),
+    (0x2C13, 'M', 'ⱃ'),
+    (0x2C14, 'M', 'ⱄ'),
+    (0x2C15, 'M', 'ⱅ'),
+    (0x2C16, 'M', 'ⱆ'),
+    (0x2C17, 'M', 'ⱇ'),
+    (0x2C18, 'M', 'ⱈ'),
+    (0x2C19, 'M', 'ⱉ'),
+    (0x2C1A, 'M', 'ⱊ'),
+    (0x2C1B, 'M', 'ⱋ'),
+    (0x2C1C, 'M', 'ⱌ'),
+    (0x2C1D, 'M', 'ⱍ'),
+    (0x2C1E, 'M', 'ⱎ'),
+    (0x2C1F, 'M', 'ⱏ'),
+    (0x2C20, 'M', 'ⱐ'),
+    (0x2C21, 'M', 'ⱑ'),
+    (0x2C22, 'M', 'ⱒ'),
+    (0x2C23, 'M', 'ⱓ'),
+    (0x2C24, 'M', 'ⱔ'),
+    (0x2C25, 'M', 'ⱕ'),
+    (0x2C26, 'M', 'ⱖ'),
+    (0x2C27, 'M', 'ⱗ'),
+    (0x2C28, 'M', 'ⱘ'),
+    ]
+
+def _seg_25() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2C29, 'M', 'ⱙ'),
+    (0x2C2A, 'M', 'ⱚ'),
+    (0x2C2B, 'M', 'ⱛ'),
+    (0x2C2C, 'M', 'ⱜ'),
+    (0x2C2D, 'M', 'ⱝ'),
+    (0x2C2E, 'M', 'ⱞ'),
+    (0x2C2F, 'M', 'ⱟ'),
+    (0x2C30, 'V'),
+    (0x2C60, 'M', 'ⱡ'),
+    (0x2C61, 'V'),
+    (0x2C62, 'M', 'ɫ'),
+    (0x2C63, 'M', 'ᵽ'),
+    (0x2C64, 'M', 'ɽ'),
+    (0x2C65, 'V'),
+    (0x2C67, 'M', 'ⱨ'),
+    (0x2C68, 'V'),
+    (0x2C69, 'M', 'ⱪ'),
+    (0x2C6A, 'V'),
+    (0x2C6B, 'M', 'ⱬ'),
+    (0x2C6C, 'V'),
+    (0x2C6D, 'M', 'ɑ'),
+    (0x2C6E, 'M', 'ɱ'),
+    (0x2C6F, 'M', 'ɐ'),
+    (0x2C70, 'M', 'ɒ'),
+    (0x2C71, 'V'),
+    (0x2C72, 'M', 'ⱳ'),
+    (0x2C73, 'V'),
+    (0x2C75, 'M', 'ⱶ'),
+    (0x2C76, 'V'),
+    (0x2C7C, 'M', 'j'),
+    (0x2C7D, 'M', 'v'),
+    (0x2C7E, 'M', 'ȿ'),
+    (0x2C7F, 'M', 'ɀ'),
+    (0x2C80, 'M', 'ⲁ'),
+    (0x2C81, 'V'),
+    (0x2C82, 'M', 'ⲃ'),
+    (0x2C83, 'V'),
+    (0x2C84, 'M', 'ⲅ'),
+    (0x2C85, 'V'),
+    (0x2C86, 'M', 'ⲇ'),
+    (0x2C87, 'V'),
+    (0x2C88, 'M', 'ⲉ'),
+    (0x2C89, 'V'),
+    (0x2C8A, 'M', 'ⲋ'),
+    (0x2C8B, 'V'),
+    (0x2C8C, 'M', 'ⲍ'),
+    (0x2C8D, 'V'),
+    (0x2C8E, 'M', 'ⲏ'),
+    (0x2C8F, 'V'),
+    (0x2C90, 'M', 'ⲑ'),
+    (0x2C91, 'V'),
+    (0x2C92, 'M', 'ⲓ'),
+    (0x2C93, 'V'),
+    (0x2C94, 'M', 'ⲕ'),
+    (0x2C95, 'V'),
+    (0x2C96, 'M', 'ⲗ'),
+    (0x2C97, 'V'),
+    (0x2C98, 'M', 'ⲙ'),
+    (0x2C99, 'V'),
+    (0x2C9A, 'M', 'ⲛ'),
+    (0x2C9B, 'V'),
+    (0x2C9C, 'M', 'ⲝ'),
+    (0x2C9D, 'V'),
+    (0x2C9E, 'M', 'ⲟ'),
+    (0x2C9F, 'V'),
+    (0x2CA0, 'M', 'ⲡ'),
+    (0x2CA1, 'V'),
+    (0x2CA2, 'M', 'ⲣ'),
+    (0x2CA3, 'V'),
+    (0x2CA4, 'M', 'ⲥ'),
+    (0x2CA5, 'V'),
+    (0x2CA6, 'M', 'ⲧ'),
+    (0x2CA7, 'V'),
+    (0x2CA8, 'M', 'ⲩ'),
+    (0x2CA9, 'V'),
+    (0x2CAA, 'M', 'ⲫ'),
+    (0x2CAB, 'V'),
+    (0x2CAC, 'M', 'ⲭ'),
+    (0x2CAD, 'V'),
+    (0x2CAE, 'M', 'ⲯ'),
+    (0x2CAF, 'V'),
+    (0x2CB0, 'M', 'ⲱ'),
+    (0x2CB1, 'V'),
+    (0x2CB2, 'M', 'ⲳ'),
+    (0x2CB3, 'V'),
+    (0x2CB4, 'M', 'ⲵ'),
+    (0x2CB5, 'V'),
+    (0x2CB6, 'M', 'ⲷ'),
+    (0x2CB7, 'V'),
+    (0x2CB8, 'M', 'ⲹ'),
+    (0x2CB9, 'V'),
+    (0x2CBA, 'M', 'ⲻ'),
+    (0x2CBB, 'V'),
+    (0x2CBC, 'M', 'ⲽ'),
+    (0x2CBD, 'V'),
+    (0x2CBE, 'M', 'ⲿ'),
+    (0x2CBF, 'V'),
+    (0x2CC0, 'M', 'ⳁ'),
+    (0x2CC1, 'V'),
+    (0x2CC2, 'M', 'ⳃ'),
+    ]
+
+def _seg_26() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2CC3, 'V'),
+    (0x2CC4, 'M', 'ⳅ'),
+    (0x2CC5, 'V'),
+    (0x2CC6, 'M', 'ⳇ'),
+    (0x2CC7, 'V'),
+    (0x2CC8, 'M', 'ⳉ'),
+    (0x2CC9, 'V'),
+    (0x2CCA, 'M', 'ⳋ'),
+    (0x2CCB, 'V'),
+    (0x2CCC, 'M', 'ⳍ'),
+    (0x2CCD, 'V'),
+    (0x2CCE, 'M', 'ⳏ'),
+    (0x2CCF, 'V'),
+    (0x2CD0, 'M', 'ⳑ'),
+    (0x2CD1, 'V'),
+    (0x2CD2, 'M', 'ⳓ'),
+    (0x2CD3, 'V'),
+    (0x2CD4, 'M', 'ⳕ'),
+    (0x2CD5, 'V'),
+    (0x2CD6, 'M', 'ⳗ'),
+    (0x2CD7, 'V'),
+    (0x2CD8, 'M', 'ⳙ'),
+    (0x2CD9, 'V'),
+    (0x2CDA, 'M', 'ⳛ'),
+    (0x2CDB, 'V'),
+    (0x2CDC, 'M', 'ⳝ'),
+    (0x2CDD, 'V'),
+    (0x2CDE, 'M', 'ⳟ'),
+    (0x2CDF, 'V'),
+    (0x2CE0, 'M', 'ⳡ'),
+    (0x2CE1, 'V'),
+    (0x2CE2, 'M', 'ⳣ'),
+    (0x2CE3, 'V'),
+    (0x2CEB, 'M', 'ⳬ'),
+    (0x2CEC, 'V'),
+    (0x2CED, 'M', 'ⳮ'),
+    (0x2CEE, 'V'),
+    (0x2CF2, 'M', 'ⳳ'),
+    (0x2CF3, 'V'),
+    (0x2CF4, 'X'),
+    (0x2CF9, 'V'),
+    (0x2D26, 'X'),
+    (0x2D27, 'V'),
+    (0x2D28, 'X'),
+    (0x2D2D, 'V'),
+    (0x2D2E, 'X'),
+    (0x2D30, 'V'),
+    (0x2D68, 'X'),
+    (0x2D6F, 'M', 'ⵡ'),
+    (0x2D70, 'V'),
+    (0x2D71, 'X'),
+    (0x2D7F, 'V'),
+    (0x2D97, 'X'),
+    (0x2DA0, 'V'),
+    (0x2DA7, 'X'),
+    (0x2DA8, 'V'),
+    (0x2DAF, 'X'),
+    (0x2DB0, 'V'),
+    (0x2DB7, 'X'),
+    (0x2DB8, 'V'),
+    (0x2DBF, 'X'),
+    (0x2DC0, 'V'),
+    (0x2DC7, 'X'),
+    (0x2DC8, 'V'),
+    (0x2DCF, 'X'),
+    (0x2DD0, 'V'),
+    (0x2DD7, 'X'),
+    (0x2DD8, 'V'),
+    (0x2DDF, 'X'),
+    (0x2DE0, 'V'),
+    (0x2E5E, 'X'),
+    (0x2E80, 'V'),
+    (0x2E9A, 'X'),
+    (0x2E9B, 'V'),
+    (0x2E9F, 'M', '母'),
+    (0x2EA0, 'V'),
+    (0x2EF3, 'M', '龟'),
+    (0x2EF4, 'X'),
+    (0x2F00, 'M', '一'),
+    (0x2F01, 'M', '丨'),
+    (0x2F02, 'M', '丶'),
+    (0x2F03, 'M', '丿'),
+    (0x2F04, 'M', '乙'),
+    (0x2F05, 'M', '亅'),
+    (0x2F06, 'M', '二'),
+    (0x2F07, 'M', '亠'),
+    (0x2F08, 'M', '人'),
+    (0x2F09, 'M', '儿'),
+    (0x2F0A, 'M', '入'),
+    (0x2F0B, 'M', '八'),
+    (0x2F0C, 'M', '冂'),
+    (0x2F0D, 'M', '冖'),
+    (0x2F0E, 'M', '冫'),
+    (0x2F0F, 'M', '几'),
+    (0x2F10, 'M', '凵'),
+    (0x2F11, 'M', '刀'),
+    (0x2F12, 'M', '力'),
+    (0x2F13, 'M', '勹'),
+    (0x2F14, 'M', '匕'),
+    (0x2F15, 'M', '匚'),
+    ]
+
+def _seg_27() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F16, 'M', '匸'),
+    (0x2F17, 'M', '十'),
+    (0x2F18, 'M', '卜'),
+    (0x2F19, 'M', '卩'),
+    (0x2F1A, 'M', '厂'),
+    (0x2F1B, 'M', '厶'),
+    (0x2F1C, 'M', '又'),
+    (0x2F1D, 'M', '口'),
+    (0x2F1E, 'M', '囗'),
+    (0x2F1F, 'M', '土'),
+    (0x2F20, 'M', '士'),
+    (0x2F21, 'M', '夂'),
+    (0x2F22, 'M', '夊'),
+    (0x2F23, 'M', '夕'),
+    (0x2F24, 'M', '大'),
+    (0x2F25, 'M', '女'),
+    (0x2F26, 'M', '子'),
+    (0x2F27, 'M', '宀'),
+    (0x2F28, 'M', '寸'),
+    (0x2F29, 'M', '小'),
+    (0x2F2A, 'M', '尢'),
+    (0x2F2B, 'M', '尸'),
+    (0x2F2C, 'M', '屮'),
+    (0x2F2D, 'M', '山'),
+    (0x2F2E, 'M', '巛'),
+    (0x2F2F, 'M', '工'),
+    (0x2F30, 'M', '己'),
+    (0x2F31, 'M', '巾'),
+    (0x2F32, 'M', '干'),
+    (0x2F33, 'M', '幺'),
+    (0x2F34, 'M', '广'),
+    (0x2F35, 'M', '廴'),
+    (0x2F36, 'M', '廾'),
+    (0x2F37, 'M', '弋'),
+    (0x2F38, 'M', '弓'),
+    (0x2F39, 'M', '彐'),
+    (0x2F3A, 'M', '彡'),
+    (0x2F3B, 'M', '彳'),
+    (0x2F3C, 'M', '心'),
+    (0x2F3D, 'M', '戈'),
+    (0x2F3E, 'M', '戶'),
+    (0x2F3F, 'M', '手'),
+    (0x2F40, 'M', '支'),
+    (0x2F41, 'M', '攴'),
+    (0x2F42, 'M', '文'),
+    (0x2F43, 'M', '斗'),
+    (0x2F44, 'M', '斤'),
+    (0x2F45, 'M', '方'),
+    (0x2F46, 'M', '无'),
+    (0x2F47, 'M', '日'),
+    (0x2F48, 'M', '曰'),
+    (0x2F49, 'M', '月'),
+    (0x2F4A, 'M', '木'),
+    (0x2F4B, 'M', '欠'),
+    (0x2F4C, 'M', '止'),
+    (0x2F4D, 'M', '歹'),
+    (0x2F4E, 'M', '殳'),
+    (0x2F4F, 'M', '毋'),
+    (0x2F50, 'M', '比'),
+    (0x2F51, 'M', '毛'),
+    (0x2F52, 'M', '氏'),
+    (0x2F53, 'M', '气'),
+    (0x2F54, 'M', '水'),
+    (0x2F55, 'M', '火'),
+    (0x2F56, 'M', '爪'),
+    (0x2F57, 'M', '父'),
+    (0x2F58, 'M', '爻'),
+    (0x2F59, 'M', '爿'),
+    (0x2F5A, 'M', '片'),
+    (0x2F5B, 'M', '牙'),
+    (0x2F5C, 'M', '牛'),
+    (0x2F5D, 'M', '犬'),
+    (0x2F5E, 'M', '玄'),
+    (0x2F5F, 'M', '玉'),
+    (0x2F60, 'M', '瓜'),
+    (0x2F61, 'M', '瓦'),
+    (0x2F62, 'M', '甘'),
+    (0x2F63, 'M', '生'),
+    (0x2F64, 'M', '用'),
+    (0x2F65, 'M', '田'),
+    (0x2F66, 'M', '疋'),
+    (0x2F67, 'M', '疒'),
+    (0x2F68, 'M', '癶'),
+    (0x2F69, 'M', '白'),
+    (0x2F6A, 'M', '皮'),
+    (0x2F6B, 'M', '皿'),
+    (0x2F6C, 'M', '目'),
+    (0x2F6D, 'M', '矛'),
+    (0x2F6E, 'M', '矢'),
+    (0x2F6F, 'M', '石'),
+    (0x2F70, 'M', '示'),
+    (0x2F71, 'M', '禸'),
+    (0x2F72, 'M', '禾'),
+    (0x2F73, 'M', '穴'),
+    (0x2F74, 'M', '立'),
+    (0x2F75, 'M', '竹'),
+    (0x2F76, 'M', '米'),
+    (0x2F77, 'M', '糸'),
+    (0x2F78, 'M', '缶'),
+    (0x2F79, 'M', '网'),
+    ]
+
+def _seg_28() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F7A, 'M', '羊'),
+    (0x2F7B, 'M', '羽'),
+    (0x2F7C, 'M', '老'),
+    (0x2F7D, 'M', '而'),
+    (0x2F7E, 'M', '耒'),
+    (0x2F7F, 'M', '耳'),
+    (0x2F80, 'M', '聿'),
+    (0x2F81, 'M', '肉'),
+    (0x2F82, 'M', '臣'),
+    (0x2F83, 'M', '自'),
+    (0x2F84, 'M', '至'),
+    (0x2F85, 'M', '臼'),
+    (0x2F86, 'M', '舌'),
+    (0x2F87, 'M', '舛'),
+    (0x2F88, 'M', '舟'),
+    (0x2F89, 'M', '艮'),
+    (0x2F8A, 'M', '色'),
+    (0x2F8B, 'M', '艸'),
+    (0x2F8C, 'M', '虍'),
+    (0x2F8D, 'M', '虫'),
+    (0x2F8E, 'M', '血'),
+    (0x2F8F, 'M', '行'),
+    (0x2F90, 'M', '衣'),
+    (0x2F91, 'M', '襾'),
+    (0x2F92, 'M', '見'),
+    (0x2F93, 'M', '角'),
+    (0x2F94, 'M', '言'),
+    (0x2F95, 'M', '谷'),
+    (0x2F96, 'M', '豆'),
+    (0x2F97, 'M', '豕'),
+    (0x2F98, 'M', '豸'),
+    (0x2F99, 'M', '貝'),
+    (0x2F9A, 'M', '赤'),
+    (0x2F9B, 'M', '走'),
+    (0x2F9C, 'M', '足'),
+    (0x2F9D, 'M', '身'),
+    (0x2F9E, 'M', '車'),
+    (0x2F9F, 'M', '辛'),
+    (0x2FA0, 'M', '辰'),
+    (0x2FA1, 'M', '辵'),
+    (0x2FA2, 'M', '邑'),
+    (0x2FA3, 'M', '酉'),
+    (0x2FA4, 'M', '釆'),
+    (0x2FA5, 'M', '里'),
+    (0x2FA6, 'M', '金'),
+    (0x2FA7, 'M', '長'),
+    (0x2FA8, 'M', '門'),
+    (0x2FA9, 'M', '阜'),
+    (0x2FAA, 'M', '隶'),
+    (0x2FAB, 'M', '隹'),
+    (0x2FAC, 'M', '雨'),
+    (0x2FAD, 'M', '靑'),
+    (0x2FAE, 'M', '非'),
+    (0x2FAF, 'M', '面'),
+    (0x2FB0, 'M', '革'),
+    (0x2FB1, 'M', '韋'),
+    (0x2FB2, 'M', '韭'),
+    (0x2FB3, 'M', '音'),
+    (0x2FB4, 'M', '頁'),
+    (0x2FB5, 'M', '風'),
+    (0x2FB6, 'M', '飛'),
+    (0x2FB7, 'M', '食'),
+    (0x2FB8, 'M', '首'),
+    (0x2FB9, 'M', '香'),
+    (0x2FBA, 'M', '馬'),
+    (0x2FBB, 'M', '骨'),
+    (0x2FBC, 'M', '高'),
+    (0x2FBD, 'M', '髟'),
+    (0x2FBE, 'M', '鬥'),
+    (0x2FBF, 'M', '鬯'),
+    (0x2FC0, 'M', '鬲'),
+    (0x2FC1, 'M', '鬼'),
+    (0x2FC2, 'M', '魚'),
+    (0x2FC3, 'M', '鳥'),
+    (0x2FC4, 'M', '鹵'),
+    (0x2FC5, 'M', '鹿'),
+    (0x2FC6, 'M', '麥'),
+    (0x2FC7, 'M', '麻'),
+    (0x2FC8, 'M', '黃'),
+    (0x2FC9, 'M', '黍'),
+    (0x2FCA, 'M', '黑'),
+    (0x2FCB, 'M', '黹'),
+    (0x2FCC, 'M', '黽'),
+    (0x2FCD, 'M', '鼎'),
+    (0x2FCE, 'M', '鼓'),
+    (0x2FCF, 'M', '鼠'),
+    (0x2FD0, 'M', '鼻'),
+    (0x2FD1, 'M', '齊'),
+    (0x2FD2, 'M', '齒'),
+    (0x2FD3, 'M', '龍'),
+    (0x2FD4, 'M', '龜'),
+    (0x2FD5, 'M', '龠'),
+    (0x2FD6, 'X'),
+    (0x3000, '3', ' '),
+    (0x3001, 'V'),
+    (0x3002, 'M', '.'),
+    (0x3003, 'V'),
+    (0x3036, 'M', '〒'),
+    (0x3037, 'V'),
+    (0x3038, 'M', '十'),
+    ]
+
+def _seg_29() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x3039, 'M', '卄'),
+    (0x303A, 'M', '卅'),
+    (0x303B, 'V'),
+    (0x3040, 'X'),
+    (0x3041, 'V'),
+    (0x3097, 'X'),
+    (0x3099, 'V'),
+    (0x309B, '3', ' ゙'),
+    (0x309C, '3', ' ゚'),
+    (0x309D, 'V'),
+    (0x309F, 'M', 'より'),
+    (0x30A0, 'V'),
+    (0x30FF, 'M', 'コト'),
+    (0x3100, 'X'),
+    (0x3105, 'V'),
+    (0x3130, 'X'),
+    (0x3131, 'M', 'ᄀ'),
+    (0x3132, 'M', 'ᄁ'),
+    (0x3133, 'M', 'ᆪ'),
+    (0x3134, 'M', 'ᄂ'),
+    (0x3135, 'M', 'ᆬ'),
+    (0x3136, 'M', 'ᆭ'),
+    (0x3137, 'M', 'ᄃ'),
+    (0x3138, 'M', 'ᄄ'),
+    (0x3139, 'M', 'ᄅ'),
+    (0x313A, 'M', 'ᆰ'),
+    (0x313B, 'M', 'ᆱ'),
+    (0x313C, 'M', 'ᆲ'),
+    (0x313D, 'M', 'ᆳ'),
+    (0x313E, 'M', 'ᆴ'),
+    (0x313F, 'M', 'ᆵ'),
+    (0x3140, 'M', 'ᄚ'),
+    (0x3141, 'M', 'ᄆ'),
+    (0x3142, 'M', 'ᄇ'),
+    (0x3143, 'M', 'ᄈ'),
+    (0x3144, 'M', 'ᄡ'),
+    (0x3145, 'M', 'ᄉ'),
+    (0x3146, 'M', 'ᄊ'),
+    (0x3147, 'M', 'ᄋ'),
+    (0x3148, 'M', 'ᄌ'),
+    (0x3149, 'M', 'ᄍ'),
+    (0x314A, 'M', 'ᄎ'),
+    (0x314B, 'M', 'ᄏ'),
+    (0x314C, 'M', 'ᄐ'),
+    (0x314D, 'M', 'ᄑ'),
+    (0x314E, 'M', 'ᄒ'),
+    (0x314F, 'M', 'ᅡ'),
+    (0x3150, 'M', 'ᅢ'),
+    (0x3151, 'M', 'ᅣ'),
+    (0x3152, 'M', 'ᅤ'),
+    (0x3153, 'M', 'ᅥ'),
+    (0x3154, 'M', 'ᅦ'),
+    (0x3155, 'M', 'ᅧ'),
+    (0x3156, 'M', 'ᅨ'),
+    (0x3157, 'M', 'ᅩ'),
+    (0x3158, 'M', 'ᅪ'),
+    (0x3159, 'M', 'ᅫ'),
+    (0x315A, 'M', 'ᅬ'),
+    (0x315B, 'M', 'ᅭ'),
+    (0x315C, 'M', 'ᅮ'),
+    (0x315D, 'M', 'ᅯ'),
+    (0x315E, 'M', 'ᅰ'),
+    (0x315F, 'M', 'ᅱ'),
+    (0x3160, 'M', 'ᅲ'),
+    (0x3161, 'M', 'ᅳ'),
+    (0x3162, 'M', 'ᅴ'),
+    (0x3163, 'M', 'ᅵ'),
+    (0x3164, 'X'),
+    (0x3165, 'M', 'ᄔ'),
+    (0x3166, 'M', 'ᄕ'),
+    (0x3167, 'M', 'ᇇ'),
+    (0x3168, 'M', 'ᇈ'),
+    (0x3169, 'M', 'ᇌ'),
+    (0x316A, 'M', 'ᇎ'),
+    (0x316B, 'M', 'ᇓ'),
+    (0x316C, 'M', 'ᇗ'),
+    (0x316D, 'M', 'ᇙ'),
+    (0x316E, 'M', 'ᄜ'),
+    (0x316F, 'M', 'ᇝ'),
+    (0x3170, 'M', 'ᇟ'),
+    (0x3171, 'M', 'ᄝ'),
+    (0x3172, 'M', 'ᄞ'),
+    (0x3173, 'M', 'ᄠ'),
+    (0x3174, 'M', 'ᄢ'),
+    (0x3175, 'M', 'ᄣ'),
+    (0x3176, 'M', 'ᄧ'),
+    (0x3177, 'M', 'ᄩ'),
+    (0x3178, 'M', 'ᄫ'),
+    (0x3179, 'M', 'ᄬ'),
+    (0x317A, 'M', 'ᄭ'),
+    (0x317B, 'M', 'ᄮ'),
+    (0x317C, 'M', 'ᄯ'),
+    (0x317D, 'M', 'ᄲ'),
+    (0x317E, 'M', 'ᄶ'),
+    (0x317F, 'M', 'ᅀ'),
+    (0x3180, 'M', 'ᅇ'),
+    (0x3181, 'M', 'ᅌ'),
+    (0x3182, 'M', 'ᇱ'),
+    (0x3183, 'M', 'ᇲ'),
+    (0x3184, 'M', 'ᅗ'),
+    ]
+
+def _seg_30() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x3185, 'M', 'ᅘ'),
+    (0x3186, 'M', 'ᅙ'),
+    (0x3187, 'M', 'ᆄ'),
+    (0x3188, 'M', 'ᆅ'),
+    (0x3189, 'M', 'ᆈ'),
+    (0x318A, 'M', 'ᆑ'),
+    (0x318B, 'M', 'ᆒ'),
+    (0x318C, 'M', 'ᆔ'),
+    (0x318D, 'M', 'ᆞ'),
+    (0x318E, 'M', 'ᆡ'),
+    (0x318F, 'X'),
+    (0x3190, 'V'),
+    (0x3192, 'M', '一'),
+    (0x3193, 'M', '二'),
+    (0x3194, 'M', '三'),
+    (0x3195, 'M', '四'),
+    (0x3196, 'M', '上'),
+    (0x3197, 'M', '中'),
+    (0x3198, 'M', '下'),
+    (0x3199, 'M', '甲'),
+    (0x319A, 'M', '乙'),
+    (0x319B, 'M', '丙'),
+    (0x319C, 'M', '丁'),
+    (0x319D, 'M', '天'),
+    (0x319E, 'M', '地'),
+    (0x319F, 'M', '人'),
+    (0x31A0, 'V'),
+    (0x31E4, 'X'),
+    (0x31F0, 'V'),
+    (0x3200, '3', '(ᄀ)'),
+    (0x3201, '3', '(ᄂ)'),
+    (0x3202, '3', '(ᄃ)'),
+    (0x3203, '3', '(ᄅ)'),
+    (0x3204, '3', '(ᄆ)'),
+    (0x3205, '3', '(ᄇ)'),
+    (0x3206, '3', '(ᄉ)'),
+    (0x3207, '3', '(ᄋ)'),
+    (0x3208, '3', '(ᄌ)'),
+    (0x3209, '3', '(ᄎ)'),
+    (0x320A, '3', '(ᄏ)'),
+    (0x320B, '3', '(ᄐ)'),
+    (0x320C, '3', '(ᄑ)'),
+    (0x320D, '3', '(ᄒ)'),
+    (0x320E, '3', '(가)'),
+    (0x320F, '3', '(나)'),
+    (0x3210, '3', '(다)'),
+    (0x3211, '3', '(라)'),
+    (0x3212, '3', '(마)'),
+    (0x3213, '3', '(바)'),
+    (0x3214, '3', '(사)'),
+    (0x3215, '3', '(아)'),
+    (0x3216, '3', '(자)'),
+    (0x3217, '3', '(차)'),
+    (0x3218, '3', '(카)'),
+    (0x3219, '3', '(타)'),
+    (0x321A, '3', '(파)'),
+    (0x321B, '3', '(하)'),
+    (0x321C, '3', '(주)'),
+    (0x321D, '3', '(오전)'),
+    (0x321E, '3', '(오후)'),
+    (0x321F, 'X'),
+    (0x3220, '3', '(一)'),
+    (0x3221, '3', '(二)'),
+    (0x3222, '3', '(三)'),
+    (0x3223, '3', '(四)'),
+    (0x3224, '3', '(五)'),
+    (0x3225, '3', '(六)'),
+    (0x3226, '3', '(七)'),
+    (0x3227, '3', '(八)'),
+    (0x3228, '3', '(九)'),
+    (0x3229, '3', '(十)'),
+    (0x322A, '3', '(月)'),
+    (0x322B, '3', '(火)'),
+    (0x322C, '3', '(水)'),
+    (0x322D, '3', '(木)'),
+    (0x322E, '3', '(金)'),
+    (0x322F, '3', '(土)'),
+    (0x3230, '3', '(日)'),
+    (0x3231, '3', '(株)'),
+    (0x3232, '3', '(有)'),
+    (0x3233, '3', '(社)'),
+    (0x3234, '3', '(名)'),
+    (0x3235, '3', '(特)'),
+    (0x3236, '3', '(財)'),
+    (0x3237, '3', '(祝)'),
+    (0x3238, '3', '(労)'),
+    (0x3239, '3', '(代)'),
+    (0x323A, '3', '(呼)'),
+    (0x323B, '3', '(学)'),
+    (0x323C, '3', '(監)'),
+    (0x323D, '3', '(企)'),
+    (0x323E, '3', '(資)'),
+    (0x323F, '3', '(協)'),
+    (0x3240, '3', '(祭)'),
+    (0x3241, '3', '(休)'),
+    (0x3242, '3', '(自)'),
+    (0x3243, '3', '(至)'),
+    (0x3244, 'M', '問'),
+    (0x3245, 'M', '幼'),
+    (0x3246, 'M', '文'),
+    ]
+
+def _seg_31() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x3247, 'M', '箏'),
+    (0x3248, 'V'),
+    (0x3250, 'M', 'pte'),
+    (0x3251, 'M', '21'),
+    (0x3252, 'M', '22'),
+    (0x3253, 'M', '23'),
+    (0x3254, 'M', '24'),
+    (0x3255, 'M', '25'),
+    (0x3256, 'M', '26'),
+    (0x3257, 'M', '27'),
+    (0x3258, 'M', '28'),
+    (0x3259, 'M', '29'),
+    (0x325A, 'M', '30'),
+    (0x325B, 'M', '31'),
+    (0x325C, 'M', '32'),
+    (0x325D, 'M', '33'),
+    (0x325E, 'M', '34'),
+    (0x325F, 'M', '35'),
+    (0x3260, 'M', 'ᄀ'),
+    (0x3261, 'M', 'ᄂ'),
+    (0x3262, 'M', 'ᄃ'),
+    (0x3263, 'M', 'ᄅ'),
+    (0x3264, 'M', 'ᄆ'),
+    (0x3265, 'M', 'ᄇ'),
+    (0x3266, 'M', 'ᄉ'),
+    (0x3267, 'M', 'ᄋ'),
+    (0x3268, 'M', 'ᄌ'),
+    (0x3269, 'M', 'ᄎ'),
+    (0x326A, 'M', 'ᄏ'),
+    (0x326B, 'M', 'ᄐ'),
+    (0x326C, 'M', 'ᄑ'),
+    (0x326D, 'M', 'ᄒ'),
+    (0x326E, 'M', '가'),
+    (0x326F, 'M', '나'),
+    (0x3270, 'M', '다'),
+    (0x3271, 'M', '라'),
+    (0x3272, 'M', '마'),
+    (0x3273, 'M', '바'),
+    (0x3274, 'M', '사'),
+    (0x3275, 'M', '아'),
+    (0x3276, 'M', '자'),
+    (0x3277, 'M', '차'),
+    (0x3278, 'M', '카'),
+    (0x3279, 'M', '타'),
+    (0x327A, 'M', '파'),
+    (0x327B, 'M', '하'),
+    (0x327C, 'M', '참고'),
+    (0x327D, 'M', '주의'),
+    (0x327E, 'M', '우'),
+    (0x327F, 'V'),
+    (0x3280, 'M', '一'),
+    (0x3281, 'M', '二'),
+    (0x3282, 'M', '三'),
+    (0x3283, 'M', '四'),
+    (0x3284, 'M', '五'),
+    (0x3285, 'M', '六'),
+    (0x3286, 'M', '七'),
+    (0x3287, 'M', '八'),
+    (0x3288, 'M', '九'),
+    (0x3289, 'M', '十'),
+    (0x328A, 'M', '月'),
+    (0x328B, 'M', '火'),
+    (0x328C, 'M', '水'),
+    (0x328D, 'M', '木'),
+    (0x328E, 'M', '金'),
+    (0x328F, 'M', '土'),
+    (0x3290, 'M', '日'),
+    (0x3291, 'M', '株'),
+    (0x3292, 'M', '有'),
+    (0x3293, 'M', '社'),
+    (0x3294, 'M', '名'),
+    (0x3295, 'M', '特'),
+    (0x3296, 'M', '財'),
+    (0x3297, 'M', '祝'),
+    (0x3298, 'M', '労'),
+    (0x3299, 'M', '秘'),
+    (0x329A, 'M', '男'),
+    (0x329B, 'M', '女'),
+    (0x329C, 'M', '適'),
+    (0x329D, 'M', '優'),
+    (0x329E, 'M', '印'),
+    (0x329F, 'M', '注'),
+    (0x32A0, 'M', '項'),
+    (0x32A1, 'M', '休'),
+    (0x32A2, 'M', '写'),
+    (0x32A3, 'M', '正'),
+    (0x32A4, 'M', '上'),
+    (0x32A5, 'M', '中'),
+    (0x32A6, 'M', '下'),
+    (0x32A7, 'M', '左'),
+    (0x32A8, 'M', '右'),
+    (0x32A9, 'M', '医'),
+    (0x32AA, 'M', '宗'),
+    (0x32AB, 'M', '学'),
+    (0x32AC, 'M', '監'),
+    (0x32AD, 'M', '企'),
+    (0x32AE, 'M', '資'),
+    (0x32AF, 'M', '協'),
+    (0x32B0, 'M', '夜'),
+    (0x32B1, 'M', '36'),
+    ]
+
+def _seg_32() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x32B2, 'M', '37'),
+    (0x32B3, 'M', '38'),
+    (0x32B4, 'M', '39'),
+    (0x32B5, 'M', '40'),
+    (0x32B6, 'M', '41'),
+    (0x32B7, 'M', '42'),
+    (0x32B8, 'M', '43'),
+    (0x32B9, 'M', '44'),
+    (0x32BA, 'M', '45'),
+    (0x32BB, 'M', '46'),
+    (0x32BC, 'M', '47'),
+    (0x32BD, 'M', '48'),
+    (0x32BE, 'M', '49'),
+    (0x32BF, 'M', '50'),
+    (0x32C0, 'M', '1月'),
+    (0x32C1, 'M', '2月'),
+    (0x32C2, 'M', '3月'),
+    (0x32C3, 'M', '4月'),
+    (0x32C4, 'M', '5月'),
+    (0x32C5, 'M', '6月'),
+    (0x32C6, 'M', '7月'),
+    (0x32C7, 'M', '8月'),
+    (0x32C8, 'M', '9月'),
+    (0x32C9, 'M', '10月'),
+    (0x32CA, 'M', '11月'),
+    (0x32CB, 'M', '12月'),
+    (0x32CC, 'M', 'hg'),
+    (0x32CD, 'M', 'erg'),
+    (0x32CE, 'M', 'ev'),
+    (0x32CF, 'M', 'ltd'),
+    (0x32D0, 'M', 'ア'),
+    (0x32D1, 'M', 'イ'),
+    (0x32D2, 'M', 'ウ'),
+    (0x32D3, 'M', 'エ'),
+    (0x32D4, 'M', 'オ'),
+    (0x32D5, 'M', 'カ'),
+    (0x32D6, 'M', 'キ'),
+    (0x32D7, 'M', 'ク'),
+    (0x32D8, 'M', 'ケ'),
+    (0x32D9, 'M', 'コ'),
+    (0x32DA, 'M', 'サ'),
+    (0x32DB, 'M', 'シ'),
+    (0x32DC, 'M', 'ス'),
+    (0x32DD, 'M', 'セ'),
+    (0x32DE, 'M', 'ソ'),
+    (0x32DF, 'M', 'タ'),
+    (0x32E0, 'M', 'チ'),
+    (0x32E1, 'M', 'ツ'),
+    (0x32E2, 'M', 'テ'),
+    (0x32E3, 'M', 'ト'),
+    (0x32E4, 'M', 'ナ'),
+    (0x32E5, 'M', 'ニ'),
+    (0x32E6, 'M', 'ヌ'),
+    (0x32E7, 'M', 'ネ'),
+    (0x32E8, 'M', 'ノ'),
+    (0x32E9, 'M', 'ハ'),
+    (0x32EA, 'M', 'ヒ'),
+    (0x32EB, 'M', 'フ'),
+    (0x32EC, 'M', 'ヘ'),
+    (0x32ED, 'M', 'ホ'),
+    (0x32EE, 'M', 'マ'),
+    (0x32EF, 'M', 'ミ'),
+    (0x32F0, 'M', 'ム'),
+    (0x32F1, 'M', 'メ'),
+    (0x32F2, 'M', 'モ'),
+    (0x32F3, 'M', 'ヤ'),
+    (0x32F4, 'M', 'ユ'),
+    (0x32F5, 'M', 'ヨ'),
+    (0x32F6, 'M', 'ラ'),
+    (0x32F7, 'M', 'リ'),
+    (0x32F8, 'M', 'ル'),
+    (0x32F9, 'M', 'レ'),
+    (0x32FA, 'M', 'ロ'),
+    (0x32FB, 'M', 'ワ'),
+    (0x32FC, 'M', 'ヰ'),
+    (0x32FD, 'M', 'ヱ'),
+    (0x32FE, 'M', 'ヲ'),
+    (0x32FF, 'M', '令和'),
+    (0x3300, 'M', 'アパート'),
+    (0x3301, 'M', 'アルファ'),
+    (0x3302, 'M', 'アンペア'),
+    (0x3303, 'M', 'アール'),
+    (0x3304, 'M', 'イニング'),
+    (0x3305, 'M', 'インチ'),
+    (0x3306, 'M', 'ウォン'),
+    (0x3307, 'M', 'エスクード'),
+    (0x3308, 'M', 'エーカー'),
+    (0x3309, 'M', 'オンス'),
+    (0x330A, 'M', 'オーム'),
+    (0x330B, 'M', 'カイリ'),
+    (0x330C, 'M', 'カラット'),
+    (0x330D, 'M', 'カロリー'),
+    (0x330E, 'M', 'ガロン'),
+    (0x330F, 'M', 'ガンマ'),
+    (0x3310, 'M', 'ギガ'),
+    (0x3311, 'M', 'ギニー'),
+    (0x3312, 'M', 'キュリー'),
+    (0x3313, 'M', 'ギルダー'),
+    (0x3314, 'M', 'キロ'),
+    (0x3315, 'M', 'キログラム'),
+    ]
+
+def _seg_33() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x3316, 'M', 'キロメートル'),
+    (0x3317, 'M', 'キロワット'),
+    (0x3318, 'M', 'グラム'),
+    (0x3319, 'M', 'グラムトン'),
+    (0x331A, 'M', 'クルゼイロ'),
+    (0x331B, 'M', 'クローネ'),
+    (0x331C, 'M', 'ケース'),
+    (0x331D, 'M', 'コルナ'),
+    (0x331E, 'M', 'コーポ'),
+    (0x331F, 'M', 'サイクル'),
+    (0x3320, 'M', 'サンチーム'),
+    (0x3321, 'M', 'シリング'),
+    (0x3322, 'M', 'センチ'),
+    (0x3323, 'M', 'セント'),
+    (0x3324, 'M', 'ダース'),
+    (0x3325, 'M', 'デシ'),
+    (0x3326, 'M', 'ドル'),
+    (0x3327, 'M', 'トン'),
+    (0x3328, 'M', 'ナノ'),
+    (0x3329, 'M', 'ノット'),
+    (0x332A, 'M', 'ハイツ'),
+    (0x332B, 'M', 'パーセント'),
+    (0x332C, 'M', 'パーツ'),
+    (0x332D, 'M', 'バーレル'),
+    (0x332E, 'M', 'ピアストル'),
+    (0x332F, 'M', 'ピクル'),
+    (0x3330, 'M', 'ピコ'),
+    (0x3331, 'M', 'ビル'),
+    (0x3332, 'M', 'ファラッド'),
+    (0x3333, 'M', 'フィート'),
+    (0x3334, 'M', 'ブッシェル'),
+    (0x3335, 'M', 'フラン'),
+    (0x3336, 'M', 'ヘクタール'),
+    (0x3337, 'M', 'ペソ'),
+    (0x3338, 'M', 'ペニヒ'),
+    (0x3339, 'M', 'ヘルツ'),
+    (0x333A, 'M', 'ペンス'),
+    (0x333B, 'M', 'ページ'),
+    (0x333C, 'M', 'ベータ'),
+    (0x333D, 'M', 'ポイント'),
+    (0x333E, 'M', 'ボルト'),
+    (0x333F, 'M', 'ホン'),
+    (0x3340, 'M', 'ポンド'),
+    (0x3341, 'M', 'ホール'),
+    (0x3342, 'M', 'ホーン'),
+    (0x3343, 'M', 'マイクロ'),
+    (0x3344, 'M', 'マイル'),
+    (0x3345, 'M', 'マッハ'),
+    (0x3346, 'M', 'マルク'),
+    (0x3347, 'M', 'マンション'),
+    (0x3348, 'M', 'ミクロン'),
+    (0x3349, 'M', 'ミリ'),
+    (0x334A, 'M', 'ミリバール'),
+    (0x334B, 'M', 'メガ'),
+    (0x334C, 'M', 'メガトン'),
+    (0x334D, 'M', 'メートル'),
+    (0x334E, 'M', 'ヤード'),
+    (0x334F, 'M', 'ヤール'),
+    (0x3350, 'M', 'ユアン'),
+    (0x3351, 'M', 'リットル'),
+    (0x3352, 'M', 'リラ'),
+    (0x3353, 'M', 'ルピー'),
+    (0x3354, 'M', 'ルーブル'),
+    (0x3355, 'M', 'レム'),
+    (0x3356, 'M', 'レントゲン'),
+    (0x3357, 'M', 'ワット'),
+    (0x3358, 'M', '0点'),
+    (0x3359, 'M', '1点'),
+    (0x335A, 'M', '2点'),
+    (0x335B, 'M', '3点'),
+    (0x335C, 'M', '4点'),
+    (0x335D, 'M', '5点'),
+    (0x335E, 'M', '6点'),
+    (0x335F, 'M', '7点'),
+    (0x3360, 'M', '8点'),
+    (0x3361, 'M', '9点'),
+    (0x3362, 'M', '10点'),
+    (0x3363, 'M', '11点'),
+    (0x3364, 'M', '12点'),
+    (0x3365, 'M', '13点'),
+    (0x3366, 'M', '14点'),
+    (0x3367, 'M', '15点'),
+    (0x3368, 'M', '16点'),
+    (0x3369, 'M', '17点'),
+    (0x336A, 'M', '18点'),
+    (0x336B, 'M', '19点'),
+    (0x336C, 'M', '20点'),
+    (0x336D, 'M', '21点'),
+    (0x336E, 'M', '22点'),
+    (0x336F, 'M', '23点'),
+    (0x3370, 'M', '24点'),
+    (0x3371, 'M', 'hpa'),
+    (0x3372, 'M', 'da'),
+    (0x3373, 'M', 'au'),
+    (0x3374, 'M', 'bar'),
+    (0x3375, 'M', 'ov'),
+    (0x3376, 'M', 'pc'),
+    (0x3377, 'M', 'dm'),
+    (0x3378, 'M', 'dm2'),
+    (0x3379, 'M', 'dm3'),
+    ]
+
+def _seg_34() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x337A, 'M', 'iu'),
+    (0x337B, 'M', '平成'),
+    (0x337C, 'M', '昭和'),
+    (0x337D, 'M', '大正'),
+    (0x337E, 'M', '明治'),
+    (0x337F, 'M', '株式会社'),
+    (0x3380, 'M', 'pa'),
+    (0x3381, 'M', 'na'),
+    (0x3382, 'M', 'μa'),
+    (0x3383, 'M', 'ma'),
+    (0x3384, 'M', 'ka'),
+    (0x3385, 'M', 'kb'),
+    (0x3386, 'M', 'mb'),
+    (0x3387, 'M', 'gb'),
+    (0x3388, 'M', 'cal'),
+    (0x3389, 'M', 'kcal'),
+    (0x338A, 'M', 'pf'),
+    (0x338B, 'M', 'nf'),
+    (0x338C, 'M', 'μf'),
+    (0x338D, 'M', 'μg'),
+    (0x338E, 'M', 'mg'),
+    (0x338F, 'M', 'kg'),
+    (0x3390, 'M', 'hz'),
+    (0x3391, 'M', 'khz'),
+    (0x3392, 'M', 'mhz'),
+    (0x3393, 'M', 'ghz'),
+    (0x3394, 'M', 'thz'),
+    (0x3395, 'M', 'μl'),
+    (0x3396, 'M', 'ml'),
+    (0x3397, 'M', 'dl'),
+    (0x3398, 'M', 'kl'),
+    (0x3399, 'M', 'fm'),
+    (0x339A, 'M', 'nm'),
+    (0x339B, 'M', 'μm'),
+    (0x339C, 'M', 'mm'),
+    (0x339D, 'M', 'cm'),
+    (0x339E, 'M', 'km'),
+    (0x339F, 'M', 'mm2'),
+    (0x33A0, 'M', 'cm2'),
+    (0x33A1, 'M', 'm2'),
+    (0x33A2, 'M', 'km2'),
+    (0x33A3, 'M', 'mm3'),
+    (0x33A4, 'M', 'cm3'),
+    (0x33A5, 'M', 'm3'),
+    (0x33A6, 'M', 'km3'),
+    (0x33A7, 'M', 'm∕s'),
+    (0x33A8, 'M', 'm∕s2'),
+    (0x33A9, 'M', 'pa'),
+    (0x33AA, 'M', 'kpa'),
+    (0x33AB, 'M', 'mpa'),
+    (0x33AC, 'M', 'gpa'),
+    (0x33AD, 'M', 'rad'),
+    (0x33AE, 'M', 'rad∕s'),
+    (0x33AF, 'M', 'rad∕s2'),
+    (0x33B0, 'M', 'ps'),
+    (0x33B1, 'M', 'ns'),
+    (0x33B2, 'M', 'μs'),
+    (0x33B3, 'M', 'ms'),
+    (0x33B4, 'M', 'pv'),
+    (0x33B5, 'M', 'nv'),
+    (0x33B6, 'M', 'μv'),
+    (0x33B7, 'M', 'mv'),
+    (0x33B8, 'M', 'kv'),
+    (0x33B9, 'M', 'mv'),
+    (0x33BA, 'M', 'pw'),
+    (0x33BB, 'M', 'nw'),
+    (0x33BC, 'M', 'μw'),
+    (0x33BD, 'M', 'mw'),
+    (0x33BE, 'M', 'kw'),
+    (0x33BF, 'M', 'mw'),
+    (0x33C0, 'M', 'kω'),
+    (0x33C1, 'M', 'mω'),
+    (0x33C2, 'X'),
+    (0x33C3, 'M', 'bq'),
+    (0x33C4, 'M', 'cc'),
+    (0x33C5, 'M', 'cd'),
+    (0x33C6, 'M', 'c∕kg'),
+    (0x33C7, 'X'),
+    (0x33C8, 'M', 'db'),
+    (0x33C9, 'M', 'gy'),
+    (0x33CA, 'M', 'ha'),
+    (0x33CB, 'M', 'hp'),
+    (0x33CC, 'M', 'in'),
+    (0x33CD, 'M', 'kk'),
+    (0x33CE, 'M', 'km'),
+    (0x33CF, 'M', 'kt'),
+    (0x33D0, 'M', 'lm'),
+    (0x33D1, 'M', 'ln'),
+    (0x33D2, 'M', 'log'),
+    (0x33D3, 'M', 'lx'),
+    (0x33D4, 'M', 'mb'),
+    (0x33D5, 'M', 'mil'),
+    (0x33D6, 'M', 'mol'),
+    (0x33D7, 'M', 'ph'),
+    (0x33D8, 'X'),
+    (0x33D9, 'M', 'ppm'),
+    (0x33DA, 'M', 'pr'),
+    (0x33DB, 'M', 'sr'),
+    (0x33DC, 'M', 'sv'),
+    (0x33DD, 'M', 'wb'),
+    ]
+
+def _seg_35() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x33DE, 'M', 'v∕m'),
+    (0x33DF, 'M', 'a∕m'),
+    (0x33E0, 'M', '1日'),
+    (0x33E1, 'M', '2日'),
+    (0x33E2, 'M', '3日'),
+    (0x33E3, 'M', '4日'),
+    (0x33E4, 'M', '5日'),
+    (0x33E5, 'M', '6日'),
+    (0x33E6, 'M', '7日'),
+    (0x33E7, 'M', '8日'),
+    (0x33E8, 'M', '9日'),
+    (0x33E9, 'M', '10日'),
+    (0x33EA, 'M', '11日'),
+    (0x33EB, 'M', '12日'),
+    (0x33EC, 'M', '13日'),
+    (0x33ED, 'M', '14日'),
+    (0x33EE, 'M', '15日'),
+    (0x33EF, 'M', '16日'),
+    (0x33F0, 'M', '17日'),
+    (0x33F1, 'M', '18日'),
+    (0x33F2, 'M', '19日'),
+    (0x33F3, 'M', '20日'),
+    (0x33F4, 'M', '21日'),
+    (0x33F5, 'M', '22日'),
+    (0x33F6, 'M', '23日'),
+    (0x33F7, 'M', '24日'),
+    (0x33F8, 'M', '25日'),
+    (0x33F9, 'M', '26日'),
+    (0x33FA, 'M', '27日'),
+    (0x33FB, 'M', '28日'),
+    (0x33FC, 'M', '29日'),
+    (0x33FD, 'M', '30日'),
+    (0x33FE, 'M', '31日'),
+    (0x33FF, 'M', 'gal'),
+    (0x3400, 'V'),
+    (0xA48D, 'X'),
+    (0xA490, 'V'),
+    (0xA4C7, 'X'),
+    (0xA4D0, 'V'),
+    (0xA62C, 'X'),
+    (0xA640, 'M', 'ꙁ'),
+    (0xA641, 'V'),
+    (0xA642, 'M', 'ꙃ'),
+    (0xA643, 'V'),
+    (0xA644, 'M', 'ꙅ'),
+    (0xA645, 'V'),
+    (0xA646, 'M', 'ꙇ'),
+    (0xA647, 'V'),
+    (0xA648, 'M', 'ꙉ'),
+    (0xA649, 'V'),
+    (0xA64A, 'M', 'ꙋ'),
+    (0xA64B, 'V'),
+    (0xA64C, 'M', 'ꙍ'),
+    (0xA64D, 'V'),
+    (0xA64E, 'M', 'ꙏ'),
+    (0xA64F, 'V'),
+    (0xA650, 'M', 'ꙑ'),
+    (0xA651, 'V'),
+    (0xA652, 'M', 'ꙓ'),
+    (0xA653, 'V'),
+    (0xA654, 'M', 'ꙕ'),
+    (0xA655, 'V'),
+    (0xA656, 'M', 'ꙗ'),
+    (0xA657, 'V'),
+    (0xA658, 'M', 'ꙙ'),
+    (0xA659, 'V'),
+    (0xA65A, 'M', 'ꙛ'),
+    (0xA65B, 'V'),
+    (0xA65C, 'M', 'ꙝ'),
+    (0xA65D, 'V'),
+    (0xA65E, 'M', 'ꙟ'),
+    (0xA65F, 'V'),
+    (0xA660, 'M', 'ꙡ'),
+    (0xA661, 'V'),
+    (0xA662, 'M', 'ꙣ'),
+    (0xA663, 'V'),
+    (0xA664, 'M', 'ꙥ'),
+    (0xA665, 'V'),
+    (0xA666, 'M', 'ꙧ'),
+    (0xA667, 'V'),
+    (0xA668, 'M', 'ꙩ'),
+    (0xA669, 'V'),
+    (0xA66A, 'M', 'ꙫ'),
+    (0xA66B, 'V'),
+    (0xA66C, 'M', 'ꙭ'),
+    (0xA66D, 'V'),
+    (0xA680, 'M', 'ꚁ'),
+    (0xA681, 'V'),
+    (0xA682, 'M', 'ꚃ'),
+    (0xA683, 'V'),
+    (0xA684, 'M', 'ꚅ'),
+    (0xA685, 'V'),
+    (0xA686, 'M', 'ꚇ'),
+    (0xA687, 'V'),
+    (0xA688, 'M', 'ꚉ'),
+    (0xA689, 'V'),
+    (0xA68A, 'M', 'ꚋ'),
+    (0xA68B, 'V'),
+    (0xA68C, 'M', 'ꚍ'),
+    (0xA68D, 'V'),
+    ]
+
+def _seg_36() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA68E, 'M', 'ꚏ'),
+    (0xA68F, 'V'),
+    (0xA690, 'M', 'ꚑ'),
+    (0xA691, 'V'),
+    (0xA692, 'M', 'ꚓ'),
+    (0xA693, 'V'),
+    (0xA694, 'M', 'ꚕ'),
+    (0xA695, 'V'),
+    (0xA696, 'M', 'ꚗ'),
+    (0xA697, 'V'),
+    (0xA698, 'M', 'ꚙ'),
+    (0xA699, 'V'),
+    (0xA69A, 'M', 'ꚛ'),
+    (0xA69B, 'V'),
+    (0xA69C, 'M', 'ъ'),
+    (0xA69D, 'M', 'ь'),
+    (0xA69E, 'V'),
+    (0xA6F8, 'X'),
+    (0xA700, 'V'),
+    (0xA722, 'M', 'ꜣ'),
+    (0xA723, 'V'),
+    (0xA724, 'M', 'ꜥ'),
+    (0xA725, 'V'),
+    (0xA726, 'M', 'ꜧ'),
+    (0xA727, 'V'),
+    (0xA728, 'M', 'ꜩ'),
+    (0xA729, 'V'),
+    (0xA72A, 'M', 'ꜫ'),
+    (0xA72B, 'V'),
+    (0xA72C, 'M', 'ꜭ'),
+    (0xA72D, 'V'),
+    (0xA72E, 'M', 'ꜯ'),
+    (0xA72F, 'V'),
+    (0xA732, 'M', 'ꜳ'),
+    (0xA733, 'V'),
+    (0xA734, 'M', 'ꜵ'),
+    (0xA735, 'V'),
+    (0xA736, 'M', 'ꜷ'),
+    (0xA737, 'V'),
+    (0xA738, 'M', 'ꜹ'),
+    (0xA739, 'V'),
+    (0xA73A, 'M', 'ꜻ'),
+    (0xA73B, 'V'),
+    (0xA73C, 'M', 'ꜽ'),
+    (0xA73D, 'V'),
+    (0xA73E, 'M', 'ꜿ'),
+    (0xA73F, 'V'),
+    (0xA740, 'M', 'ꝁ'),
+    (0xA741, 'V'),
+    (0xA742, 'M', 'ꝃ'),
+    (0xA743, 'V'),
+    (0xA744, 'M', 'ꝅ'),
+    (0xA745, 'V'),
+    (0xA746, 'M', 'ꝇ'),
+    (0xA747, 'V'),
+    (0xA748, 'M', 'ꝉ'),
+    (0xA749, 'V'),
+    (0xA74A, 'M', 'ꝋ'),
+    (0xA74B, 'V'),
+    (0xA74C, 'M', 'ꝍ'),
+    (0xA74D, 'V'),
+    (0xA74E, 'M', 'ꝏ'),
+    (0xA74F, 'V'),
+    (0xA750, 'M', 'ꝑ'),
+    (0xA751, 'V'),
+    (0xA752, 'M', 'ꝓ'),
+    (0xA753, 'V'),
+    (0xA754, 'M', 'ꝕ'),
+    (0xA755, 'V'),
+    (0xA756, 'M', 'ꝗ'),
+    (0xA757, 'V'),
+    (0xA758, 'M', 'ꝙ'),
+    (0xA759, 'V'),
+    (0xA75A, 'M', 'ꝛ'),
+    (0xA75B, 'V'),
+    (0xA75C, 'M', 'ꝝ'),
+    (0xA75D, 'V'),
+    (0xA75E, 'M', 'ꝟ'),
+    (0xA75F, 'V'),
+    (0xA760, 'M', 'ꝡ'),
+    (0xA761, 'V'),
+    (0xA762, 'M', 'ꝣ'),
+    (0xA763, 'V'),
+    (0xA764, 'M', 'ꝥ'),
+    (0xA765, 'V'),
+    (0xA766, 'M', 'ꝧ'),
+    (0xA767, 'V'),
+    (0xA768, 'M', 'ꝩ'),
+    (0xA769, 'V'),
+    (0xA76A, 'M', 'ꝫ'),
+    (0xA76B, 'V'),
+    (0xA76C, 'M', 'ꝭ'),
+    (0xA76D, 'V'),
+    (0xA76E, 'M', 'ꝯ'),
+    (0xA76F, 'V'),
+    (0xA770, 'M', 'ꝯ'),
+    (0xA771, 'V'),
+    (0xA779, 'M', 'ꝺ'),
+    (0xA77A, 'V'),
+    (0xA77B, 'M', 'ꝼ'),
+    ]
+
+def _seg_37() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA77C, 'V'),
+    (0xA77D, 'M', 'ᵹ'),
+    (0xA77E, 'M', 'ꝿ'),
+    (0xA77F, 'V'),
+    (0xA780, 'M', 'ꞁ'),
+    (0xA781, 'V'),
+    (0xA782, 'M', 'ꞃ'),
+    (0xA783, 'V'),
+    (0xA784, 'M', 'ꞅ'),
+    (0xA785, 'V'),
+    (0xA786, 'M', 'ꞇ'),
+    (0xA787, 'V'),
+    (0xA78B, 'M', 'ꞌ'),
+    (0xA78C, 'V'),
+    (0xA78D, 'M', 'ɥ'),
+    (0xA78E, 'V'),
+    (0xA790, 'M', 'ꞑ'),
+    (0xA791, 'V'),
+    (0xA792, 'M', 'ꞓ'),
+    (0xA793, 'V'),
+    (0xA796, 'M', 'ꞗ'),
+    (0xA797, 'V'),
+    (0xA798, 'M', 'ꞙ'),
+    (0xA799, 'V'),
+    (0xA79A, 'M', 'ꞛ'),
+    (0xA79B, 'V'),
+    (0xA79C, 'M', 'ꞝ'),
+    (0xA79D, 'V'),
+    (0xA79E, 'M', 'ꞟ'),
+    (0xA79F, 'V'),
+    (0xA7A0, 'M', 'ꞡ'),
+    (0xA7A1, 'V'),
+    (0xA7A2, 'M', 'ꞣ'),
+    (0xA7A3, 'V'),
+    (0xA7A4, 'M', 'ꞥ'),
+    (0xA7A5, 'V'),
+    (0xA7A6, 'M', 'ꞧ'),
+    (0xA7A7, 'V'),
+    (0xA7A8, 'M', 'ꞩ'),
+    (0xA7A9, 'V'),
+    (0xA7AA, 'M', 'ɦ'),
+    (0xA7AB, 'M', 'ɜ'),
+    (0xA7AC, 'M', 'ɡ'),
+    (0xA7AD, 'M', 'ɬ'),
+    (0xA7AE, 'M', 'ɪ'),
+    (0xA7AF, 'V'),
+    (0xA7B0, 'M', 'ʞ'),
+    (0xA7B1, 'M', 'ʇ'),
+    (0xA7B2, 'M', 'ʝ'),
+    (0xA7B3, 'M', 'ꭓ'),
+    (0xA7B4, 'M', 'ꞵ'),
+    (0xA7B5, 'V'),
+    (0xA7B6, 'M', 'ꞷ'),
+    (0xA7B7, 'V'),
+    (0xA7B8, 'M', 'ꞹ'),
+    (0xA7B9, 'V'),
+    (0xA7BA, 'M', 'ꞻ'),
+    (0xA7BB, 'V'),
+    (0xA7BC, 'M', 'ꞽ'),
+    (0xA7BD, 'V'),
+    (0xA7BE, 'M', 'ꞿ'),
+    (0xA7BF, 'V'),
+    (0xA7C0, 'M', 'ꟁ'),
+    (0xA7C1, 'V'),
+    (0xA7C2, 'M', 'ꟃ'),
+    (0xA7C3, 'V'),
+    (0xA7C4, 'M', 'ꞔ'),
+    (0xA7C5, 'M', 'ʂ'),
+    (0xA7C6, 'M', 'ᶎ'),
+    (0xA7C7, 'M', 'ꟈ'),
+    (0xA7C8, 'V'),
+    (0xA7C9, 'M', 'ꟊ'),
+    (0xA7CA, 'V'),
+    (0xA7CB, 'X'),
+    (0xA7D0, 'M', 'ꟑ'),
+    (0xA7D1, 'V'),
+    (0xA7D2, 'X'),
+    (0xA7D3, 'V'),
+    (0xA7D4, 'X'),
+    (0xA7D5, 'V'),
+    (0xA7D6, 'M', 'ꟗ'),
+    (0xA7D7, 'V'),
+    (0xA7D8, 'M', 'ꟙ'),
+    (0xA7D9, 'V'),
+    (0xA7DA, 'X'),
+    (0xA7F2, 'M', 'c'),
+    (0xA7F3, 'M', 'f'),
+    (0xA7F4, 'M', 'q'),
+    (0xA7F5, 'M', 'ꟶ'),
+    (0xA7F6, 'V'),
+    (0xA7F8, 'M', 'ħ'),
+    (0xA7F9, 'M', 'œ'),
+    (0xA7FA, 'V'),
+    (0xA82D, 'X'),
+    (0xA830, 'V'),
+    (0xA83A, 'X'),
+    (0xA840, 'V'),
+    (0xA878, 'X'),
+    (0xA880, 'V'),
+    (0xA8C6, 'X'),
+    ]
+
+def _seg_38() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA8CE, 'V'),
+    (0xA8DA, 'X'),
+    (0xA8E0, 'V'),
+    (0xA954, 'X'),
+    (0xA95F, 'V'),
+    (0xA97D, 'X'),
+    (0xA980, 'V'),
+    (0xA9CE, 'X'),
+    (0xA9CF, 'V'),
+    (0xA9DA, 'X'),
+    (0xA9DE, 'V'),
+    (0xA9FF, 'X'),
+    (0xAA00, 'V'),
+    (0xAA37, 'X'),
+    (0xAA40, 'V'),
+    (0xAA4E, 'X'),
+    (0xAA50, 'V'),
+    (0xAA5A, 'X'),
+    (0xAA5C, 'V'),
+    (0xAAC3, 'X'),
+    (0xAADB, 'V'),
+    (0xAAF7, 'X'),
+    (0xAB01, 'V'),
+    (0xAB07, 'X'),
+    (0xAB09, 'V'),
+    (0xAB0F, 'X'),
+    (0xAB11, 'V'),
+    (0xAB17, 'X'),
+    (0xAB20, 'V'),
+    (0xAB27, 'X'),
+    (0xAB28, 'V'),
+    (0xAB2F, 'X'),
+    (0xAB30, 'V'),
+    (0xAB5C, 'M', 'ꜧ'),
+    (0xAB5D, 'M', 'ꬷ'),
+    (0xAB5E, 'M', 'ɫ'),
+    (0xAB5F, 'M', 'ꭒ'),
+    (0xAB60, 'V'),
+    (0xAB69, 'M', 'ʍ'),
+    (0xAB6A, 'V'),
+    (0xAB6C, 'X'),
+    (0xAB70, 'M', 'Ꭰ'),
+    (0xAB71, 'M', 'Ꭱ'),
+    (0xAB72, 'M', 'Ꭲ'),
+    (0xAB73, 'M', 'Ꭳ'),
+    (0xAB74, 'M', 'Ꭴ'),
+    (0xAB75, 'M', 'Ꭵ'),
+    (0xAB76, 'M', 'Ꭶ'),
+    (0xAB77, 'M', 'Ꭷ'),
+    (0xAB78, 'M', 'Ꭸ'),
+    (0xAB79, 'M', 'Ꭹ'),
+    (0xAB7A, 'M', 'Ꭺ'),
+    (0xAB7B, 'M', 'Ꭻ'),
+    (0xAB7C, 'M', 'Ꭼ'),
+    (0xAB7D, 'M', 'Ꭽ'),
+    (0xAB7E, 'M', 'Ꭾ'),
+    (0xAB7F, 'M', 'Ꭿ'),
+    (0xAB80, 'M', 'Ꮀ'),
+    (0xAB81, 'M', 'Ꮁ'),
+    (0xAB82, 'M', 'Ꮂ'),
+    (0xAB83, 'M', 'Ꮃ'),
+    (0xAB84, 'M', 'Ꮄ'),
+    (0xAB85, 'M', 'Ꮅ'),
+    (0xAB86, 'M', 'Ꮆ'),
+    (0xAB87, 'M', 'Ꮇ'),
+    (0xAB88, 'M', 'Ꮈ'),
+    (0xAB89, 'M', 'Ꮉ'),
+    (0xAB8A, 'M', 'Ꮊ'),
+    (0xAB8B, 'M', 'Ꮋ'),
+    (0xAB8C, 'M', 'Ꮌ'),
+    (0xAB8D, 'M', 'Ꮍ'),
+    (0xAB8E, 'M', 'Ꮎ'),
+    (0xAB8F, 'M', 'Ꮏ'),
+    (0xAB90, 'M', 'Ꮐ'),
+    (0xAB91, 'M', 'Ꮑ'),
+    (0xAB92, 'M', 'Ꮒ'),
+    (0xAB93, 'M', 'Ꮓ'),
+    (0xAB94, 'M', 'Ꮔ'),
+    (0xAB95, 'M', 'Ꮕ'),
+    (0xAB96, 'M', 'Ꮖ'),
+    (0xAB97, 'M', 'Ꮗ'),
+    (0xAB98, 'M', 'Ꮘ'),
+    (0xAB99, 'M', 'Ꮙ'),
+    (0xAB9A, 'M', 'Ꮚ'),
+    (0xAB9B, 'M', 'Ꮛ'),
+    (0xAB9C, 'M', 'Ꮜ'),
+    (0xAB9D, 'M', 'Ꮝ'),
+    (0xAB9E, 'M', 'Ꮞ'),
+    (0xAB9F, 'M', 'Ꮟ'),
+    (0xABA0, 'M', 'Ꮠ'),
+    (0xABA1, 'M', 'Ꮡ'),
+    (0xABA2, 'M', 'Ꮢ'),
+    (0xABA3, 'M', 'Ꮣ'),
+    (0xABA4, 'M', 'Ꮤ'),
+    (0xABA5, 'M', 'Ꮥ'),
+    (0xABA6, 'M', 'Ꮦ'),
+    (0xABA7, 'M', 'Ꮧ'),
+    (0xABA8, 'M', 'Ꮨ'),
+    (0xABA9, 'M', 'Ꮩ'),
+    (0xABAA, 'M', 'Ꮪ'),
+    ]
+
+def _seg_39() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xABAB, 'M', 'Ꮫ'),
+    (0xABAC, 'M', 'Ꮬ'),
+    (0xABAD, 'M', 'Ꮭ'),
+    (0xABAE, 'M', 'Ꮮ'),
+    (0xABAF, 'M', 'Ꮯ'),
+    (0xABB0, 'M', 'Ꮰ'),
+    (0xABB1, 'M', 'Ꮱ'),
+    (0xABB2, 'M', 'Ꮲ'),
+    (0xABB3, 'M', 'Ꮳ'),
+    (0xABB4, 'M', 'Ꮴ'),
+    (0xABB5, 'M', 'Ꮵ'),
+    (0xABB6, 'M', 'Ꮶ'),
+    (0xABB7, 'M', 'Ꮷ'),
+    (0xABB8, 'M', 'Ꮸ'),
+    (0xABB9, 'M', 'Ꮹ'),
+    (0xABBA, 'M', 'Ꮺ'),
+    (0xABBB, 'M', 'Ꮻ'),
+    (0xABBC, 'M', 'Ꮼ'),
+    (0xABBD, 'M', 'Ꮽ'),
+    (0xABBE, 'M', 'Ꮾ'),
+    (0xABBF, 'M', 'Ꮿ'),
+    (0xABC0, 'V'),
+    (0xABEE, 'X'),
+    (0xABF0, 'V'),
+    (0xABFA, 'X'),
+    (0xAC00, 'V'),
+    (0xD7A4, 'X'),
+    (0xD7B0, 'V'),
+    (0xD7C7, 'X'),
+    (0xD7CB, 'V'),
+    (0xD7FC, 'X'),
+    (0xF900, 'M', '豈'),
+    (0xF901, 'M', '更'),
+    (0xF902, 'M', '車'),
+    (0xF903, 'M', '賈'),
+    (0xF904, 'M', '滑'),
+    (0xF905, 'M', '串'),
+    (0xF906, 'M', '句'),
+    (0xF907, 'M', '龜'),
+    (0xF909, 'M', '契'),
+    (0xF90A, 'M', '金'),
+    (0xF90B, 'M', '喇'),
+    (0xF90C, 'M', '奈'),
+    (0xF90D, 'M', '懶'),
+    (0xF90E, 'M', '癩'),
+    (0xF90F, 'M', '羅'),
+    (0xF910, 'M', '蘿'),
+    (0xF911, 'M', '螺'),
+    (0xF912, 'M', '裸'),
+    (0xF913, 'M', '邏'),
+    (0xF914, 'M', '樂'),
+    (0xF915, 'M', '洛'),
+    (0xF916, 'M', '烙'),
+    (0xF917, 'M', '珞'),
+    (0xF918, 'M', '落'),
+    (0xF919, 'M', '酪'),
+    (0xF91A, 'M', '駱'),
+    (0xF91B, 'M', '亂'),
+    (0xF91C, 'M', '卵'),
+    (0xF91D, 'M', '欄'),
+    (0xF91E, 'M', '爛'),
+    (0xF91F, 'M', '蘭'),
+    (0xF920, 'M', '鸞'),
+    (0xF921, 'M', '嵐'),
+    (0xF922, 'M', '濫'),
+    (0xF923, 'M', '藍'),
+    (0xF924, 'M', '襤'),
+    (0xF925, 'M', '拉'),
+    (0xF926, 'M', '臘'),
+    (0xF927, 'M', '蠟'),
+    (0xF928, 'M', '廊'),
+    (0xF929, 'M', '朗'),
+    (0xF92A, 'M', '浪'),
+    (0xF92B, 'M', '狼'),
+    (0xF92C, 'M', '郎'),
+    (0xF92D, 'M', '來'),
+    (0xF92E, 'M', '冷'),
+    (0xF92F, 'M', '勞'),
+    (0xF930, 'M', '擄'),
+    (0xF931, 'M', '櫓'),
+    (0xF932, 'M', '爐'),
+    (0xF933, 'M', '盧'),
+    (0xF934, 'M', '老'),
+    (0xF935, 'M', '蘆'),
+    (0xF936, 'M', '虜'),
+    (0xF937, 'M', '路'),
+    (0xF938, 'M', '露'),
+    (0xF939, 'M', '魯'),
+    (0xF93A, 'M', '鷺'),
+    (0xF93B, 'M', '碌'),
+    (0xF93C, 'M', '祿'),
+    (0xF93D, 'M', '綠'),
+    (0xF93E, 'M', '菉'),
+    (0xF93F, 'M', '錄'),
+    (0xF940, 'M', '鹿'),
+    (0xF941, 'M', '論'),
+    (0xF942, 'M', '壟'),
+    (0xF943, 'M', '弄'),
+    (0xF944, 'M', '籠'),
+    (0xF945, 'M', '聾'),
+    ]
+
+def _seg_40() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xF946, 'M', '牢'),
+    (0xF947, 'M', '磊'),
+    (0xF948, 'M', '賂'),
+    (0xF949, 'M', '雷'),
+    (0xF94A, 'M', '壘'),
+    (0xF94B, 'M', '屢'),
+    (0xF94C, 'M', '樓'),
+    (0xF94D, 'M', '淚'),
+    (0xF94E, 'M', '漏'),
+    (0xF94F, 'M', '累'),
+    (0xF950, 'M', '縷'),
+    (0xF951, 'M', '陋'),
+    (0xF952, 'M', '勒'),
+    (0xF953, 'M', '肋'),
+    (0xF954, 'M', '凜'),
+    (0xF955, 'M', '凌'),
+    (0xF956, 'M', '稜'),
+    (0xF957, 'M', '綾'),
+    (0xF958, 'M', '菱'),
+    (0xF959, 'M', '陵'),
+    (0xF95A, 'M', '讀'),
+    (0xF95B, 'M', '拏'),
+    (0xF95C, 'M', '樂'),
+    (0xF95D, 'M', '諾'),
+    (0xF95E, 'M', '丹'),
+    (0xF95F, 'M', '寧'),
+    (0xF960, 'M', '怒'),
+    (0xF961, 'M', '率'),
+    (0xF962, 'M', '異'),
+    (0xF963, 'M', '北'),
+    (0xF964, 'M', '磻'),
+    (0xF965, 'M', '便'),
+    (0xF966, 'M', '復'),
+    (0xF967, 'M', '不'),
+    (0xF968, 'M', '泌'),
+    (0xF969, 'M', '數'),
+    (0xF96A, 'M', '索'),
+    (0xF96B, 'M', '參'),
+    (0xF96C, 'M', '塞'),
+    (0xF96D, 'M', '省'),
+    (0xF96E, 'M', '葉'),
+    (0xF96F, 'M', '說'),
+    (0xF970, 'M', '殺'),
+    (0xF971, 'M', '辰'),
+    (0xF972, 'M', '沈'),
+    (0xF973, 'M', '拾'),
+    (0xF974, 'M', '若'),
+    (0xF975, 'M', '掠'),
+    (0xF976, 'M', '略'),
+    (0xF977, 'M', '亮'),
+    (0xF978, 'M', '兩'),
+    (0xF979, 'M', '凉'),
+    (0xF97A, 'M', '梁'),
+    (0xF97B, 'M', '糧'),
+    (0xF97C, 'M', '良'),
+    (0xF97D, 'M', '諒'),
+    (0xF97E, 'M', '量'),
+    (0xF97F, 'M', '勵'),
+    (0xF980, 'M', '呂'),
+    (0xF981, 'M', '女'),
+    (0xF982, 'M', '廬'),
+    (0xF983, 'M', '旅'),
+    (0xF984, 'M', '濾'),
+    (0xF985, 'M', '礪'),
+    (0xF986, 'M', '閭'),
+    (0xF987, 'M', '驪'),
+    (0xF988, 'M', '麗'),
+    (0xF989, 'M', '黎'),
+    (0xF98A, 'M', '力'),
+    (0xF98B, 'M', '曆'),
+    (0xF98C, 'M', '歷'),
+    (0xF98D, 'M', '轢'),
+    (0xF98E, 'M', '年'),
+    (0xF98F, 'M', '憐'),
+    (0xF990, 'M', '戀'),
+    (0xF991, 'M', '撚'),
+    (0xF992, 'M', '漣'),
+    (0xF993, 'M', '煉'),
+    (0xF994, 'M', '璉'),
+    (0xF995, 'M', '秊'),
+    (0xF996, 'M', '練'),
+    (0xF997, 'M', '聯'),
+    (0xF998, 'M', '輦'),
+    (0xF999, 'M', '蓮'),
+    (0xF99A, 'M', '連'),
+    (0xF99B, 'M', '鍊'),
+    (0xF99C, 'M', '列'),
+    (0xF99D, 'M', '劣'),
+    (0xF99E, 'M', '咽'),
+    (0xF99F, 'M', '烈'),
+    (0xF9A0, 'M', '裂'),
+    (0xF9A1, 'M', '說'),
+    (0xF9A2, 'M', '廉'),
+    (0xF9A3, 'M', '念'),
+    (0xF9A4, 'M', '捻'),
+    (0xF9A5, 'M', '殮'),
+    (0xF9A6, 'M', '簾'),
+    (0xF9A7, 'M', '獵'),
+    (0xF9A8, 'M', '令'),
+    (0xF9A9, 'M', '囹'),
+    ]
+
+def _seg_41() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xF9AA, 'M', '寧'),
+    (0xF9AB, 'M', '嶺'),
+    (0xF9AC, 'M', '怜'),
+    (0xF9AD, 'M', '玲'),
+    (0xF9AE, 'M', '瑩'),
+    (0xF9AF, 'M', '羚'),
+    (0xF9B0, 'M', '聆'),
+    (0xF9B1, 'M', '鈴'),
+    (0xF9B2, 'M', '零'),
+    (0xF9B3, 'M', '靈'),
+    (0xF9B4, 'M', '領'),
+    (0xF9B5, 'M', '例'),
+    (0xF9B6, 'M', '禮'),
+    (0xF9B7, 'M', '醴'),
+    (0xF9B8, 'M', '隸'),
+    (0xF9B9, 'M', '惡'),
+    (0xF9BA, 'M', '了'),
+    (0xF9BB, 'M', '僚'),
+    (0xF9BC, 'M', '寮'),
+    (0xF9BD, 'M', '尿'),
+    (0xF9BE, 'M', '料'),
+    (0xF9BF, 'M', '樂'),
+    (0xF9C0, 'M', '燎'),
+    (0xF9C1, 'M', '療'),
+    (0xF9C2, 'M', '蓼'),
+    (0xF9C3, 'M', '遼'),
+    (0xF9C4, 'M', '龍'),
+    (0xF9C5, 'M', '暈'),
+    (0xF9C6, 'M', '阮'),
+    (0xF9C7, 'M', '劉'),
+    (0xF9C8, 'M', '杻'),
+    (0xF9C9, 'M', '柳'),
+    (0xF9CA, 'M', '流'),
+    (0xF9CB, 'M', '溜'),
+    (0xF9CC, 'M', '琉'),
+    (0xF9CD, 'M', '留'),
+    (0xF9CE, 'M', '硫'),
+    (0xF9CF, 'M', '紐'),
+    (0xF9D0, 'M', '類'),
+    (0xF9D1, 'M', '六'),
+    (0xF9D2, 'M', '戮'),
+    (0xF9D3, 'M', '陸'),
+    (0xF9D4, 'M', '倫'),
+    (0xF9D5, 'M', '崙'),
+    (0xF9D6, 'M', '淪'),
+    (0xF9D7, 'M', '輪'),
+    (0xF9D8, 'M', '律'),
+    (0xF9D9, 'M', '慄'),
+    (0xF9DA, 'M', '栗'),
+    (0xF9DB, 'M', '率'),
+    (0xF9DC, 'M', '隆'),
+    (0xF9DD, 'M', '利'),
+    (0xF9DE, 'M', '吏'),
+    (0xF9DF, 'M', '履'),
+    (0xF9E0, 'M', '易'),
+    (0xF9E1, 'M', '李'),
+    (0xF9E2, 'M', '梨'),
+    (0xF9E3, 'M', '泥'),
+    (0xF9E4, 'M', '理'),
+    (0xF9E5, 'M', '痢'),
+    (0xF9E6, 'M', '罹'),
+    (0xF9E7, 'M', '裏'),
+    (0xF9E8, 'M', '裡'),
+    (0xF9E9, 'M', '里'),
+    (0xF9EA, 'M', '離'),
+    (0xF9EB, 'M', '匿'),
+    (0xF9EC, 'M', '溺'),
+    (0xF9ED, 'M', '吝'),
+    (0xF9EE, 'M', '燐'),
+    (0xF9EF, 'M', '璘'),
+    (0xF9F0, 'M', '藺'),
+    (0xF9F1, 'M', '隣'),
+    (0xF9F2, 'M', '鱗'),
+    (0xF9F3, 'M', '麟'),
+    (0xF9F4, 'M', '林'),
+    (0xF9F5, 'M', '淋'),
+    (0xF9F6, 'M', '臨'),
+    (0xF9F7, 'M', '立'),
+    (0xF9F8, 'M', '笠'),
+    (0xF9F9, 'M', '粒'),
+    (0xF9FA, 'M', '狀'),
+    (0xF9FB, 'M', '炙'),
+    (0xF9FC, 'M', '識'),
+    (0xF9FD, 'M', '什'),
+    (0xF9FE, 'M', '茶'),
+    (0xF9FF, 'M', '刺'),
+    (0xFA00, 'M', '切'),
+    (0xFA01, 'M', '度'),
+    (0xFA02, 'M', '拓'),
+    (0xFA03, 'M', '糖'),
+    (0xFA04, 'M', '宅'),
+    (0xFA05, 'M', '洞'),
+    (0xFA06, 'M', '暴'),
+    (0xFA07, 'M', '輻'),
+    (0xFA08, 'M', '行'),
+    (0xFA09, 'M', '降'),
+    (0xFA0A, 'M', '見'),
+    (0xFA0B, 'M', '廓'),
+    (0xFA0C, 'M', '兀'),
+    (0xFA0D, 'M', '嗀'),
+    ]
+
+def _seg_42() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFA0E, 'V'),
+    (0xFA10, 'M', '塚'),
+    (0xFA11, 'V'),
+    (0xFA12, 'M', '晴'),
+    (0xFA13, 'V'),
+    (0xFA15, 'M', '凞'),
+    (0xFA16, 'M', '猪'),
+    (0xFA17, 'M', '益'),
+    (0xFA18, 'M', '礼'),
+    (0xFA19, 'M', '神'),
+    (0xFA1A, 'M', '祥'),
+    (0xFA1B, 'M', '福'),
+    (0xFA1C, 'M', '靖'),
+    (0xFA1D, 'M', '精'),
+    (0xFA1E, 'M', '羽'),
+    (0xFA1F, 'V'),
+    (0xFA20, 'M', '蘒'),
+    (0xFA21, 'V'),
+    (0xFA22, 'M', '諸'),
+    (0xFA23, 'V'),
+    (0xFA25, 'M', '逸'),
+    (0xFA26, 'M', '都'),
+    (0xFA27, 'V'),
+    (0xFA2A, 'M', '飯'),
+    (0xFA2B, 'M', '飼'),
+    (0xFA2C, 'M', '館'),
+    (0xFA2D, 'M', '鶴'),
+    (0xFA2E, 'M', '郞'),
+    (0xFA2F, 'M', '隷'),
+    (0xFA30, 'M', '侮'),
+    (0xFA31, 'M', '僧'),
+    (0xFA32, 'M', '免'),
+    (0xFA33, 'M', '勉'),
+    (0xFA34, 'M', '勤'),
+    (0xFA35, 'M', '卑'),
+    (0xFA36, 'M', '喝'),
+    (0xFA37, 'M', '嘆'),
+    (0xFA38, 'M', '器'),
+    (0xFA39, 'M', '塀'),
+    (0xFA3A, 'M', '墨'),
+    (0xFA3B, 'M', '層'),
+    (0xFA3C, 'M', '屮'),
+    (0xFA3D, 'M', '悔'),
+    (0xFA3E, 'M', '慨'),
+    (0xFA3F, 'M', '憎'),
+    (0xFA40, 'M', '懲'),
+    (0xFA41, 'M', '敏'),
+    (0xFA42, 'M', '既'),
+    (0xFA43, 'M', '暑'),
+    (0xFA44, 'M', '梅'),
+    (0xFA45, 'M', '海'),
+    (0xFA46, 'M', '渚'),
+    (0xFA47, 'M', '漢'),
+    (0xFA48, 'M', '煮'),
+    (0xFA49, 'M', '爫'),
+    (0xFA4A, 'M', '琢'),
+    (0xFA4B, 'M', '碑'),
+    (0xFA4C, 'M', '社'),
+    (0xFA4D, 'M', '祉'),
+    (0xFA4E, 'M', '祈'),
+    (0xFA4F, 'M', '祐'),
+    (0xFA50, 'M', '祖'),
+    (0xFA51, 'M', '祝'),
+    (0xFA52, 'M', '禍'),
+    (0xFA53, 'M', '禎'),
+    (0xFA54, 'M', '穀'),
+    (0xFA55, 'M', '突'),
+    (0xFA56, 'M', '節'),
+    (0xFA57, 'M', '練'),
+    (0xFA58, 'M', '縉'),
+    (0xFA59, 'M', '繁'),
+    (0xFA5A, 'M', '署'),
+    (0xFA5B, 'M', '者'),
+    (0xFA5C, 'M', '臭'),
+    (0xFA5D, 'M', '艹'),
+    (0xFA5F, 'M', '著'),
+    (0xFA60, 'M', '褐'),
+    (0xFA61, 'M', '視'),
+    (0xFA62, 'M', '謁'),
+    (0xFA63, 'M', '謹'),
+    (0xFA64, 'M', '賓'),
+    (0xFA65, 'M', '贈'),
+    (0xFA66, 'M', '辶'),
+    (0xFA67, 'M', '逸'),
+    (0xFA68, 'M', '難'),
+    (0xFA69, 'M', '響'),
+    (0xFA6A, 'M', '頻'),
+    (0xFA6B, 'M', '恵'),
+    (0xFA6C, 'M', '𤋮'),
+    (0xFA6D, 'M', '舘'),
+    (0xFA6E, 'X'),
+    (0xFA70, 'M', '並'),
+    (0xFA71, 'M', '况'),
+    (0xFA72, 'M', '全'),
+    (0xFA73, 'M', '侀'),
+    (0xFA74, 'M', '充'),
+    (0xFA75, 'M', '冀'),
+    (0xFA76, 'M', '勇'),
+    (0xFA77, 'M', '勺'),
+    (0xFA78, 'M', '喝'),
+    ]
+
+def _seg_43() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFA79, 'M', '啕'),
+    (0xFA7A, 'M', '喙'),
+    (0xFA7B, 'M', '嗢'),
+    (0xFA7C, 'M', '塚'),
+    (0xFA7D, 'M', '墳'),
+    (0xFA7E, 'M', '奄'),
+    (0xFA7F, 'M', '奔'),
+    (0xFA80, 'M', '婢'),
+    (0xFA81, 'M', '嬨'),
+    (0xFA82, 'M', '廒'),
+    (0xFA83, 'M', '廙'),
+    (0xFA84, 'M', '彩'),
+    (0xFA85, 'M', '徭'),
+    (0xFA86, 'M', '惘'),
+    (0xFA87, 'M', '慎'),
+    (0xFA88, 'M', '愈'),
+    (0xFA89, 'M', '憎'),
+    (0xFA8A, 'M', '慠'),
+    (0xFA8B, 'M', '懲'),
+    (0xFA8C, 'M', '戴'),
+    (0xFA8D, 'M', '揄'),
+    (0xFA8E, 'M', '搜'),
+    (0xFA8F, 'M', '摒'),
+    (0xFA90, 'M', '敖'),
+    (0xFA91, 'M', '晴'),
+    (0xFA92, 'M', '朗'),
+    (0xFA93, 'M', '望'),
+    (0xFA94, 'M', '杖'),
+    (0xFA95, 'M', '歹'),
+    (0xFA96, 'M', '殺'),
+    (0xFA97, 'M', '流'),
+    (0xFA98, 'M', '滛'),
+    (0xFA99, 'M', '滋'),
+    (0xFA9A, 'M', '漢'),
+    (0xFA9B, 'M', '瀞'),
+    (0xFA9C, 'M', '煮'),
+    (0xFA9D, 'M', '瞧'),
+    (0xFA9E, 'M', '爵'),
+    (0xFA9F, 'M', '犯'),
+    (0xFAA0, 'M', '猪'),
+    (0xFAA1, 'M', '瑱'),
+    (0xFAA2, 'M', '甆'),
+    (0xFAA3, 'M', '画'),
+    (0xFAA4, 'M', '瘝'),
+    (0xFAA5, 'M', '瘟'),
+    (0xFAA6, 'M', '益'),
+    (0xFAA7, 'M', '盛'),
+    (0xFAA8, 'M', '直'),
+    (0xFAA9, 'M', '睊'),
+    (0xFAAA, 'M', '着'),
+    (0xFAAB, 'M', '磌'),
+    (0xFAAC, 'M', '窱'),
+    (0xFAAD, 'M', '節'),
+    (0xFAAE, 'M', '类'),
+    (0xFAAF, 'M', '絛'),
+    (0xFAB0, 'M', '練'),
+    (0xFAB1, 'M', '缾'),
+    (0xFAB2, 'M', '者'),
+    (0xFAB3, 'M', '荒'),
+    (0xFAB4, 'M', '華'),
+    (0xFAB5, 'M', '蝹'),
+    (0xFAB6, 'M', '襁'),
+    (0xFAB7, 'M', '覆'),
+    (0xFAB8, 'M', '視'),
+    (0xFAB9, 'M', '調'),
+    (0xFABA, 'M', '諸'),
+    (0xFABB, 'M', '請'),
+    (0xFABC, 'M', '謁'),
+    (0xFABD, 'M', '諾'),
+    (0xFABE, 'M', '諭'),
+    (0xFABF, 'M', '謹'),
+    (0xFAC0, 'M', '變'),
+    (0xFAC1, 'M', '贈'),
+    (0xFAC2, 'M', '輸'),
+    (0xFAC3, 'M', '遲'),
+    (0xFAC4, 'M', '醙'),
+    (0xFAC5, 'M', '鉶'),
+    (0xFAC6, 'M', '陼'),
+    (0xFAC7, 'M', '難'),
+    (0xFAC8, 'M', '靖'),
+    (0xFAC9, 'M', '韛'),
+    (0xFACA, 'M', '響'),
+    (0xFACB, 'M', '頋'),
+    (0xFACC, 'M', '頻'),
+    (0xFACD, 'M', '鬒'),
+    (0xFACE, 'M', '龜'),
+    (0xFACF, 'M', '𢡊'),
+    (0xFAD0, 'M', '𢡄'),
+    (0xFAD1, 'M', '𣏕'),
+    (0xFAD2, 'M', '㮝'),
+    (0xFAD3, 'M', '䀘'),
+    (0xFAD4, 'M', '䀹'),
+    (0xFAD5, 'M', '𥉉'),
+    (0xFAD6, 'M', '𥳐'),
+    (0xFAD7, 'M', '𧻓'),
+    (0xFAD8, 'M', '齃'),
+    (0xFAD9, 'M', '龎'),
+    (0xFADA, 'X'),
+    (0xFB00, 'M', 'ff'),
+    (0xFB01, 'M', 'fi'),
+    ]
+
+def _seg_44() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFB02, 'M', 'fl'),
+    (0xFB03, 'M', 'ffi'),
+    (0xFB04, 'M', 'ffl'),
+    (0xFB05, 'M', 'st'),
+    (0xFB07, 'X'),
+    (0xFB13, 'M', 'մն'),
+    (0xFB14, 'M', 'մե'),
+    (0xFB15, 'M', 'մի'),
+    (0xFB16, 'M', 'վն'),
+    (0xFB17, 'M', 'մխ'),
+    (0xFB18, 'X'),
+    (0xFB1D, 'M', 'יִ'),
+    (0xFB1E, 'V'),
+    (0xFB1F, 'M', 'ײַ'),
+    (0xFB20, 'M', 'ע'),
+    (0xFB21, 'M', 'א'),
+    (0xFB22, 'M', 'ד'),
+    (0xFB23, 'M', 'ה'),
+    (0xFB24, 'M', 'כ'),
+    (0xFB25, 'M', 'ל'),
+    (0xFB26, 'M', 'ם'),
+    (0xFB27, 'M', 'ר'),
+    (0xFB28, 'M', 'ת'),
+    (0xFB29, '3', '+'),
+    (0xFB2A, 'M', 'שׁ'),
+    (0xFB2B, 'M', 'שׂ'),
+    (0xFB2C, 'M', 'שּׁ'),
+    (0xFB2D, 'M', 'שּׂ'),
+    (0xFB2E, 'M', 'אַ'),
+    (0xFB2F, 'M', 'אָ'),
+    (0xFB30, 'M', 'אּ'),
+    (0xFB31, 'M', 'בּ'),
+    (0xFB32, 'M', 'גּ'),
+    (0xFB33, 'M', 'דּ'),
+    (0xFB34, 'M', 'הּ'),
+    (0xFB35, 'M', 'וּ'),
+    (0xFB36, 'M', 'זּ'),
+    (0xFB37, 'X'),
+    (0xFB38, 'M', 'טּ'),
+    (0xFB39, 'M', 'יּ'),
+    (0xFB3A, 'M', 'ךּ'),
+    (0xFB3B, 'M', 'כּ'),
+    (0xFB3C, 'M', 'לּ'),
+    (0xFB3D, 'X'),
+    (0xFB3E, 'M', 'מּ'),
+    (0xFB3F, 'X'),
+    (0xFB40, 'M', 'נּ'),
+    (0xFB41, 'M', 'סּ'),
+    (0xFB42, 'X'),
+    (0xFB43, 'M', 'ףּ'),
+    (0xFB44, 'M', 'פּ'),
+    (0xFB45, 'X'),
+    (0xFB46, 'M', 'צּ'),
+    (0xFB47, 'M', 'קּ'),
+    (0xFB48, 'M', 'רּ'),
+    (0xFB49, 'M', 'שּ'),
+    (0xFB4A, 'M', 'תּ'),
+    (0xFB4B, 'M', 'וֹ'),
+    (0xFB4C, 'M', 'בֿ'),
+    (0xFB4D, 'M', 'כֿ'),
+    (0xFB4E, 'M', 'פֿ'),
+    (0xFB4F, 'M', 'אל'),
+    (0xFB50, 'M', 'ٱ'),
+    (0xFB52, 'M', 'ٻ'),
+    (0xFB56, 'M', 'پ'),
+    (0xFB5A, 'M', 'ڀ'),
+    (0xFB5E, 'M', 'ٺ'),
+    (0xFB62, 'M', 'ٿ'),
+    (0xFB66, 'M', 'ٹ'),
+    (0xFB6A, 'M', 'ڤ'),
+    (0xFB6E, 'M', 'ڦ'),
+    (0xFB72, 'M', 'ڄ'),
+    (0xFB76, 'M', 'ڃ'),
+    (0xFB7A, 'M', 'چ'),
+    (0xFB7E, 'M', 'ڇ'),
+    (0xFB82, 'M', 'ڍ'),
+    (0xFB84, 'M', 'ڌ'),
+    (0xFB86, 'M', 'ڎ'),
+    (0xFB88, 'M', 'ڈ'),
+    (0xFB8A, 'M', 'ژ'),
+    (0xFB8C, 'M', 'ڑ'),
+    (0xFB8E, 'M', 'ک'),
+    (0xFB92, 'M', 'گ'),
+    (0xFB96, 'M', 'ڳ'),
+    (0xFB9A, 'M', 'ڱ'),
+    (0xFB9E, 'M', 'ں'),
+    (0xFBA0, 'M', 'ڻ'),
+    (0xFBA4, 'M', 'ۀ'),
+    (0xFBA6, 'M', 'ہ'),
+    (0xFBAA, 'M', 'ھ'),
+    (0xFBAE, 'M', 'ے'),
+    (0xFBB0, 'M', 'ۓ'),
+    (0xFBB2, 'V'),
+    (0xFBC3, 'X'),
+    (0xFBD3, 'M', 'ڭ'),
+    (0xFBD7, 'M', 'ۇ'),
+    (0xFBD9, 'M', 'ۆ'),
+    (0xFBDB, 'M', 'ۈ'),
+    (0xFBDD, 'M', 'ۇٴ'),
+    (0xFBDE, 'M', 'ۋ'),
+    ]
+
+def _seg_45() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFBE0, 'M', 'ۅ'),
+    (0xFBE2, 'M', 'ۉ'),
+    (0xFBE4, 'M', 'ې'),
+    (0xFBE8, 'M', 'ى'),
+    (0xFBEA, 'M', 'ئا'),
+    (0xFBEC, 'M', 'ئە'),
+    (0xFBEE, 'M', 'ئو'),
+    (0xFBF0, 'M', 'ئۇ'),
+    (0xFBF2, 'M', 'ئۆ'),
+    (0xFBF4, 'M', 'ئۈ'),
+    (0xFBF6, 'M', 'ئې'),
+    (0xFBF9, 'M', 'ئى'),
+    (0xFBFC, 'M', 'ی'),
+    (0xFC00, 'M', 'ئج'),
+    (0xFC01, 'M', 'ئح'),
+    (0xFC02, 'M', 'ئم'),
+    (0xFC03, 'M', 'ئى'),
+    (0xFC04, 'M', 'ئي'),
+    (0xFC05, 'M', 'بج'),
+    (0xFC06, 'M', 'بح'),
+    (0xFC07, 'M', 'بخ'),
+    (0xFC08, 'M', 'بم'),
+    (0xFC09, 'M', 'بى'),
+    (0xFC0A, 'M', 'بي'),
+    (0xFC0B, 'M', 'تج'),
+    (0xFC0C, 'M', 'تح'),
+    (0xFC0D, 'M', 'تخ'),
+    (0xFC0E, 'M', 'تم'),
+    (0xFC0F, 'M', 'تى'),
+    (0xFC10, 'M', 'تي'),
+    (0xFC11, 'M', 'ثج'),
+    (0xFC12, 'M', 'ثم'),
+    (0xFC13, 'M', 'ثى'),
+    (0xFC14, 'M', 'ثي'),
+    (0xFC15, 'M', 'جح'),
+    (0xFC16, 'M', 'جم'),
+    (0xFC17, 'M', 'حج'),
+    (0xFC18, 'M', 'حم'),
+    (0xFC19, 'M', 'خج'),
+    (0xFC1A, 'M', 'خح'),
+    (0xFC1B, 'M', 'خم'),
+    (0xFC1C, 'M', 'سج'),
+    (0xFC1D, 'M', 'سح'),
+    (0xFC1E, 'M', 'سخ'),
+    (0xFC1F, 'M', 'سم'),
+    (0xFC20, 'M', 'صح'),
+    (0xFC21, 'M', 'صم'),
+    (0xFC22, 'M', 'ضج'),
+    (0xFC23, 'M', 'ضح'),
+    (0xFC24, 'M', 'ضخ'),
+    (0xFC25, 'M', 'ضم'),
+    (0xFC26, 'M', 'طح'),
+    (0xFC27, 'M', 'طم'),
+    (0xFC28, 'M', 'ظم'),
+    (0xFC29, 'M', 'عج'),
+    (0xFC2A, 'M', 'عم'),
+    (0xFC2B, 'M', 'غج'),
+    (0xFC2C, 'M', 'غم'),
+    (0xFC2D, 'M', 'فج'),
+    (0xFC2E, 'M', 'فح'),
+    (0xFC2F, 'M', 'فخ'),
+    (0xFC30, 'M', 'فم'),
+    (0xFC31, 'M', 'فى'),
+    (0xFC32, 'M', 'في'),
+    (0xFC33, 'M', 'قح'),
+    (0xFC34, 'M', 'قم'),
+    (0xFC35, 'M', 'قى'),
+    (0xFC36, 'M', 'قي'),
+    (0xFC37, 'M', 'كا'),
+    (0xFC38, 'M', 'كج'),
+    (0xFC39, 'M', 'كح'),
+    (0xFC3A, 'M', 'كخ'),
+    (0xFC3B, 'M', 'كل'),
+    (0xFC3C, 'M', 'كم'),
+    (0xFC3D, 'M', 'كى'),
+    (0xFC3E, 'M', 'كي'),
+    (0xFC3F, 'M', 'لج'),
+    (0xFC40, 'M', 'لح'),
+    (0xFC41, 'M', 'لخ'),
+    (0xFC42, 'M', 'لم'),
+    (0xFC43, 'M', 'لى'),
+    (0xFC44, 'M', 'لي'),
+    (0xFC45, 'M', 'مج'),
+    (0xFC46, 'M', 'مح'),
+    (0xFC47, 'M', 'مخ'),
+    (0xFC48, 'M', 'مم'),
+    (0xFC49, 'M', 'مى'),
+    (0xFC4A, 'M', 'مي'),
+    (0xFC4B, 'M', 'نج'),
+    (0xFC4C, 'M', 'نح'),
+    (0xFC4D, 'M', 'نخ'),
+    (0xFC4E, 'M', 'نم'),
+    (0xFC4F, 'M', 'نى'),
+    (0xFC50, 'M', 'ني'),
+    (0xFC51, 'M', 'هج'),
+    (0xFC52, 'M', 'هم'),
+    (0xFC53, 'M', 'هى'),
+    (0xFC54, 'M', 'هي'),
+    (0xFC55, 'M', 'يج'),
+    (0xFC56, 'M', 'يح'),
+    ]
+
+def _seg_46() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFC57, 'M', 'يخ'),
+    (0xFC58, 'M', 'يم'),
+    (0xFC59, 'M', 'يى'),
+    (0xFC5A, 'M', 'يي'),
+    (0xFC5B, 'M', 'ذٰ'),
+    (0xFC5C, 'M', 'رٰ'),
+    (0xFC5D, 'M', 'ىٰ'),
+    (0xFC5E, '3', ' ٌّ'),
+    (0xFC5F, '3', ' ٍّ'),
+    (0xFC60, '3', ' َّ'),
+    (0xFC61, '3', ' ُّ'),
+    (0xFC62, '3', ' ِّ'),
+    (0xFC63, '3', ' ّٰ'),
+    (0xFC64, 'M', 'ئر'),
+    (0xFC65, 'M', 'ئز'),
+    (0xFC66, 'M', 'ئم'),
+    (0xFC67, 'M', 'ئن'),
+    (0xFC68, 'M', 'ئى'),
+    (0xFC69, 'M', 'ئي'),
+    (0xFC6A, 'M', 'بر'),
+    (0xFC6B, 'M', 'بز'),
+    (0xFC6C, 'M', 'بم'),
+    (0xFC6D, 'M', 'بن'),
+    (0xFC6E, 'M', 'بى'),
+    (0xFC6F, 'M', 'بي'),
+    (0xFC70, 'M', 'تر'),
+    (0xFC71, 'M', 'تز'),
+    (0xFC72, 'M', 'تم'),
+    (0xFC73, 'M', 'تن'),
+    (0xFC74, 'M', 'تى'),
+    (0xFC75, 'M', 'تي'),
+    (0xFC76, 'M', 'ثر'),
+    (0xFC77, 'M', 'ثز'),
+    (0xFC78, 'M', 'ثم'),
+    (0xFC79, 'M', 'ثن'),
+    (0xFC7A, 'M', 'ثى'),
+    (0xFC7B, 'M', 'ثي'),
+    (0xFC7C, 'M', 'فى'),
+    (0xFC7D, 'M', 'في'),
+    (0xFC7E, 'M', 'قى'),
+    (0xFC7F, 'M', 'قي'),
+    (0xFC80, 'M', 'كا'),
+    (0xFC81, 'M', 'كل'),
+    (0xFC82, 'M', 'كم'),
+    (0xFC83, 'M', 'كى'),
+    (0xFC84, 'M', 'كي'),
+    (0xFC85, 'M', 'لم'),
+    (0xFC86, 'M', 'لى'),
+    (0xFC87, 'M', 'لي'),
+    (0xFC88, 'M', 'ما'),
+    (0xFC89, 'M', 'مم'),
+    (0xFC8A, 'M', 'نر'),
+    (0xFC8B, 'M', 'نز'),
+    (0xFC8C, 'M', 'نم'),
+    (0xFC8D, 'M', 'نن'),
+    (0xFC8E, 'M', 'نى'),
+    (0xFC8F, 'M', 'ني'),
+    (0xFC90, 'M', 'ىٰ'),
+    (0xFC91, 'M', 'ير'),
+    (0xFC92, 'M', 'يز'),
+    (0xFC93, 'M', 'يم'),
+    (0xFC94, 'M', 'ين'),
+    (0xFC95, 'M', 'يى'),
+    (0xFC96, 'M', 'يي'),
+    (0xFC97, 'M', 'ئج'),
+    (0xFC98, 'M', 'ئح'),
+    (0xFC99, 'M', 'ئخ'),
+    (0xFC9A, 'M', 'ئم'),
+    (0xFC9B, 'M', 'ئه'),
+    (0xFC9C, 'M', 'بج'),
+    (0xFC9D, 'M', 'بح'),
+    (0xFC9E, 'M', 'بخ'),
+    (0xFC9F, 'M', 'بم'),
+    (0xFCA0, 'M', 'به'),
+    (0xFCA1, 'M', 'تج'),
+    (0xFCA2, 'M', 'تح'),
+    (0xFCA3, 'M', 'تخ'),
+    (0xFCA4, 'M', 'تم'),
+    (0xFCA5, 'M', 'ته'),
+    (0xFCA6, 'M', 'ثم'),
+    (0xFCA7, 'M', 'جح'),
+    (0xFCA8, 'M', 'جم'),
+    (0xFCA9, 'M', 'حج'),
+    (0xFCAA, 'M', 'حم'),
+    (0xFCAB, 'M', 'خج'),
+    (0xFCAC, 'M', 'خم'),
+    (0xFCAD, 'M', 'سج'),
+    (0xFCAE, 'M', 'سح'),
+    (0xFCAF, 'M', 'سخ'),
+    (0xFCB0, 'M', 'سم'),
+    (0xFCB1, 'M', 'صح'),
+    (0xFCB2, 'M', 'صخ'),
+    (0xFCB3, 'M', 'صم'),
+    (0xFCB4, 'M', 'ضج'),
+    (0xFCB5, 'M', 'ضح'),
+    (0xFCB6, 'M', 'ضخ'),
+    (0xFCB7, 'M', 'ضم'),
+    (0xFCB8, 'M', 'طح'),
+    (0xFCB9, 'M', 'ظم'),
+    (0xFCBA, 'M', 'عج'),
+    ]
+
+def _seg_47() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFCBB, 'M', 'عم'),
+    (0xFCBC, 'M', 'غج'),
+    (0xFCBD, 'M', 'غم'),
+    (0xFCBE, 'M', 'فج'),
+    (0xFCBF, 'M', 'فح'),
+    (0xFCC0, 'M', 'فخ'),
+    (0xFCC1, 'M', 'فم'),
+    (0xFCC2, 'M', 'قح'),
+    (0xFCC3, 'M', 'قم'),
+    (0xFCC4, 'M', 'كج'),
+    (0xFCC5, 'M', 'كح'),
+    (0xFCC6, 'M', 'كخ'),
+    (0xFCC7, 'M', 'كل'),
+    (0xFCC8, 'M', 'كم'),
+    (0xFCC9, 'M', 'لج'),
+    (0xFCCA, 'M', 'لح'),
+    (0xFCCB, 'M', 'لخ'),
+    (0xFCCC, 'M', 'لم'),
+    (0xFCCD, 'M', 'له'),
+    (0xFCCE, 'M', 'مج'),
+    (0xFCCF, 'M', 'مح'),
+    (0xFCD0, 'M', 'مخ'),
+    (0xFCD1, 'M', 'مم'),
+    (0xFCD2, 'M', 'نج'),
+    (0xFCD3, 'M', 'نح'),
+    (0xFCD4, 'M', 'نخ'),
+    (0xFCD5, 'M', 'نم'),
+    (0xFCD6, 'M', 'نه'),
+    (0xFCD7, 'M', 'هج'),
+    (0xFCD8, 'M', 'هم'),
+    (0xFCD9, 'M', 'هٰ'),
+    (0xFCDA, 'M', 'يج'),
+    (0xFCDB, 'M', 'يح'),
+    (0xFCDC, 'M', 'يخ'),
+    (0xFCDD, 'M', 'يم'),
+    (0xFCDE, 'M', 'يه'),
+    (0xFCDF, 'M', 'ئم'),
+    (0xFCE0, 'M', 'ئه'),
+    (0xFCE1, 'M', 'بم'),
+    (0xFCE2, 'M', 'به'),
+    (0xFCE3, 'M', 'تم'),
+    (0xFCE4, 'M', 'ته'),
+    (0xFCE5, 'M', 'ثم'),
+    (0xFCE6, 'M', 'ثه'),
+    (0xFCE7, 'M', 'سم'),
+    (0xFCE8, 'M', 'سه'),
+    (0xFCE9, 'M', 'شم'),
+    (0xFCEA, 'M', 'شه'),
+    (0xFCEB, 'M', 'كل'),
+    (0xFCEC, 'M', 'كم'),
+    (0xFCED, 'M', 'لم'),
+    (0xFCEE, 'M', 'نم'),
+    (0xFCEF, 'M', 'نه'),
+    (0xFCF0, 'M', 'يم'),
+    (0xFCF1, 'M', 'يه'),
+    (0xFCF2, 'M', 'ـَّ'),
+    (0xFCF3, 'M', 'ـُّ'),
+    (0xFCF4, 'M', 'ـِّ'),
+    (0xFCF5, 'M', 'طى'),
+    (0xFCF6, 'M', 'طي'),
+    (0xFCF7, 'M', 'عى'),
+    (0xFCF8, 'M', 'عي'),
+    (0xFCF9, 'M', 'غى'),
+    (0xFCFA, 'M', 'غي'),
+    (0xFCFB, 'M', 'سى'),
+    (0xFCFC, 'M', 'سي'),
+    (0xFCFD, 'M', 'شى'),
+    (0xFCFE, 'M', 'شي'),
+    (0xFCFF, 'M', 'حى'),
+    (0xFD00, 'M', 'حي'),
+    (0xFD01, 'M', 'جى'),
+    (0xFD02, 'M', 'جي'),
+    (0xFD03, 'M', 'خى'),
+    (0xFD04, 'M', 'خي'),
+    (0xFD05, 'M', 'صى'),
+    (0xFD06, 'M', 'صي'),
+    (0xFD07, 'M', 'ضى'),
+    (0xFD08, 'M', 'ضي'),
+    (0xFD09, 'M', 'شج'),
+    (0xFD0A, 'M', 'شح'),
+    (0xFD0B, 'M', 'شخ'),
+    (0xFD0C, 'M', 'شم'),
+    (0xFD0D, 'M', 'شر'),
+    (0xFD0E, 'M', 'سر'),
+    (0xFD0F, 'M', 'صر'),
+    (0xFD10, 'M', 'ضر'),
+    (0xFD11, 'M', 'طى'),
+    (0xFD12, 'M', 'طي'),
+    (0xFD13, 'M', 'عى'),
+    (0xFD14, 'M', 'عي'),
+    (0xFD15, 'M', 'غى'),
+    (0xFD16, 'M', 'غي'),
+    (0xFD17, 'M', 'سى'),
+    (0xFD18, 'M', 'سي'),
+    (0xFD19, 'M', 'شى'),
+    (0xFD1A, 'M', 'شي'),
+    (0xFD1B, 'M', 'حى'),
+    (0xFD1C, 'M', 'حي'),
+    (0xFD1D, 'M', 'جى'),
+    (0xFD1E, 'M', 'جي'),
+    ]
+
+def _seg_48() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFD1F, 'M', 'خى'),
+    (0xFD20, 'M', 'خي'),
+    (0xFD21, 'M', 'صى'),
+    (0xFD22, 'M', 'صي'),
+    (0xFD23, 'M', 'ضى'),
+    (0xFD24, 'M', 'ضي'),
+    (0xFD25, 'M', 'شج'),
+    (0xFD26, 'M', 'شح'),
+    (0xFD27, 'M', 'شخ'),
+    (0xFD28, 'M', 'شم'),
+    (0xFD29, 'M', 'شر'),
+    (0xFD2A, 'M', 'سر'),
+    (0xFD2B, 'M', 'صر'),
+    (0xFD2C, 'M', 'ضر'),
+    (0xFD2D, 'M', 'شج'),
+    (0xFD2E, 'M', 'شح'),
+    (0xFD2F, 'M', 'شخ'),
+    (0xFD30, 'M', 'شم'),
+    (0xFD31, 'M', 'سه'),
+    (0xFD32, 'M', 'شه'),
+    (0xFD33, 'M', 'طم'),
+    (0xFD34, 'M', 'سج'),
+    (0xFD35, 'M', 'سح'),
+    (0xFD36, 'M', 'سخ'),
+    (0xFD37, 'M', 'شج'),
+    (0xFD38, 'M', 'شح'),
+    (0xFD39, 'M', 'شخ'),
+    (0xFD3A, 'M', 'طم'),
+    (0xFD3B, 'M', 'ظم'),
+    (0xFD3C, 'M', 'اً'),
+    (0xFD3E, 'V'),
+    (0xFD50, 'M', 'تجم'),
+    (0xFD51, 'M', 'تحج'),
+    (0xFD53, 'M', 'تحم'),
+    (0xFD54, 'M', 'تخم'),
+    (0xFD55, 'M', 'تمج'),
+    (0xFD56, 'M', 'تمح'),
+    (0xFD57, 'M', 'تمخ'),
+    (0xFD58, 'M', 'جمح'),
+    (0xFD5A, 'M', 'حمي'),
+    (0xFD5B, 'M', 'حمى'),
+    (0xFD5C, 'M', 'سحج'),
+    (0xFD5D, 'M', 'سجح'),
+    (0xFD5E, 'M', 'سجى'),
+    (0xFD5F, 'M', 'سمح'),
+    (0xFD61, 'M', 'سمج'),
+    (0xFD62, 'M', 'سمم'),
+    (0xFD64, 'M', 'صحح'),
+    (0xFD66, 'M', 'صمم'),
+    (0xFD67, 'M', 'شحم'),
+    (0xFD69, 'M', 'شجي'),
+    (0xFD6A, 'M', 'شمخ'),
+    (0xFD6C, 'M', 'شمم'),
+    (0xFD6E, 'M', 'ضحى'),
+    (0xFD6F, 'M', 'ضخم'),
+    (0xFD71, 'M', 'طمح'),
+    (0xFD73, 'M', 'طمم'),
+    (0xFD74, 'M', 'طمي'),
+    (0xFD75, 'M', 'عجم'),
+    (0xFD76, 'M', 'عمم'),
+    (0xFD78, 'M', 'عمى'),
+    (0xFD79, 'M', 'غمم'),
+    (0xFD7A, 'M', 'غمي'),
+    (0xFD7B, 'M', 'غمى'),
+    (0xFD7C, 'M', 'فخم'),
+    (0xFD7E, 'M', 'قمح'),
+    (0xFD7F, 'M', 'قمم'),
+    (0xFD80, 'M', 'لحم'),
+    (0xFD81, 'M', 'لحي'),
+    (0xFD82, 'M', 'لحى'),
+    (0xFD83, 'M', 'لجج'),
+    (0xFD85, 'M', 'لخم'),
+    (0xFD87, 'M', 'لمح'),
+    (0xFD89, 'M', 'محج'),
+    (0xFD8A, 'M', 'محم'),
+    (0xFD8B, 'M', 'محي'),
+    (0xFD8C, 'M', 'مجح'),
+    (0xFD8D, 'M', 'مجم'),
+    (0xFD8E, 'M', 'مخج'),
+    (0xFD8F, 'M', 'مخم'),
+    (0xFD90, 'X'),
+    (0xFD92, 'M', 'مجخ'),
+    (0xFD93, 'M', 'همج'),
+    (0xFD94, 'M', 'همم'),
+    (0xFD95, 'M', 'نحم'),
+    (0xFD96, 'M', 'نحى'),
+    (0xFD97, 'M', 'نجم'),
+    (0xFD99, 'M', 'نجى'),
+    (0xFD9A, 'M', 'نمي'),
+    (0xFD9B, 'M', 'نمى'),
+    (0xFD9C, 'M', 'يمم'),
+    (0xFD9E, 'M', 'بخي'),
+    (0xFD9F, 'M', 'تجي'),
+    (0xFDA0, 'M', 'تجى'),
+    (0xFDA1, 'M', 'تخي'),
+    (0xFDA2, 'M', 'تخى'),
+    (0xFDA3, 'M', 'تمي'),
+    (0xFDA4, 'M', 'تمى'),
+    (0xFDA5, 'M', 'جمي'),
+    (0xFDA6, 'M', 'جحى'),
+    ]
+
+def _seg_49() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFDA7, 'M', 'جمى'),
+    (0xFDA8, 'M', 'سخى'),
+    (0xFDA9, 'M', 'صحي'),
+    (0xFDAA, 'M', 'شحي'),
+    (0xFDAB, 'M', 'ضحي'),
+    (0xFDAC, 'M', 'لجي'),
+    (0xFDAD, 'M', 'لمي'),
+    (0xFDAE, 'M', 'يحي'),
+    (0xFDAF, 'M', 'يجي'),
+    (0xFDB0, 'M', 'يمي'),
+    (0xFDB1, 'M', 'ممي'),
+    (0xFDB2, 'M', 'قمي'),
+    (0xFDB3, 'M', 'نحي'),
+    (0xFDB4, 'M', 'قمح'),
+    (0xFDB5, 'M', 'لحم'),
+    (0xFDB6, 'M', 'عمي'),
+    (0xFDB7, 'M', 'كمي'),
+    (0xFDB8, 'M', 'نجح'),
+    (0xFDB9, 'M', 'مخي'),
+    (0xFDBA, 'M', 'لجم'),
+    (0xFDBB, 'M', 'كمم'),
+    (0xFDBC, 'M', 'لجم'),
+    (0xFDBD, 'M', 'نجح'),
+    (0xFDBE, 'M', 'جحي'),
+    (0xFDBF, 'M', 'حجي'),
+    (0xFDC0, 'M', 'مجي'),
+    (0xFDC1, 'M', 'فمي'),
+    (0xFDC2, 'M', 'بحي'),
+    (0xFDC3, 'M', 'كمم'),
+    (0xFDC4, 'M', 'عجم'),
+    (0xFDC5, 'M', 'صمم'),
+    (0xFDC6, 'M', 'سخي'),
+    (0xFDC7, 'M', 'نجي'),
+    (0xFDC8, 'X'),
+    (0xFDCF, 'V'),
+    (0xFDD0, 'X'),
+    (0xFDF0, 'M', 'صلے'),
+    (0xFDF1, 'M', 'قلے'),
+    (0xFDF2, 'M', 'الله'),
+    (0xFDF3, 'M', 'اكبر'),
+    (0xFDF4, 'M', 'محمد'),
+    (0xFDF5, 'M', 'صلعم'),
+    (0xFDF6, 'M', 'رسول'),
+    (0xFDF7, 'M', 'عليه'),
+    (0xFDF8, 'M', 'وسلم'),
+    (0xFDF9, 'M', 'صلى'),
+    (0xFDFA, '3', 'صلى الله عليه وسلم'),
+    (0xFDFB, '3', 'جل جلاله'),
+    (0xFDFC, 'M', 'ریال'),
+    (0xFDFD, 'V'),
+    (0xFE00, 'I'),
+    (0xFE10, '3', ','),
+    (0xFE11, 'M', '、'),
+    (0xFE12, 'X'),
+    (0xFE13, '3', ':'),
+    (0xFE14, '3', ';'),
+    (0xFE15, '3', '!'),
+    (0xFE16, '3', '?'),
+    (0xFE17, 'M', '〖'),
+    (0xFE18, 'M', '〗'),
+    (0xFE19, 'X'),
+    (0xFE20, 'V'),
+    (0xFE30, 'X'),
+    (0xFE31, 'M', '—'),
+    (0xFE32, 'M', '–'),
+    (0xFE33, '3', '_'),
+    (0xFE35, '3', '('),
+    (0xFE36, '3', ')'),
+    (0xFE37, '3', '{'),
+    (0xFE38, '3', '}'),
+    (0xFE39, 'M', '〔'),
+    (0xFE3A, 'M', '〕'),
+    (0xFE3B, 'M', '【'),
+    (0xFE3C, 'M', '】'),
+    (0xFE3D, 'M', '《'),
+    (0xFE3E, 'M', '》'),
+    (0xFE3F, 'M', '〈'),
+    (0xFE40, 'M', '〉'),
+    (0xFE41, 'M', '「'),
+    (0xFE42, 'M', '」'),
+    (0xFE43, 'M', '『'),
+    (0xFE44, 'M', '』'),
+    (0xFE45, 'V'),
+    (0xFE47, '3', '['),
+    (0xFE48, '3', ']'),
+    (0xFE49, '3', ' ̅'),
+    (0xFE4D, '3', '_'),
+    (0xFE50, '3', ','),
+    (0xFE51, 'M', '、'),
+    (0xFE52, 'X'),
+    (0xFE54, '3', ';'),
+    (0xFE55, '3', ':'),
+    (0xFE56, '3', '?'),
+    (0xFE57, '3', '!'),
+    (0xFE58, 'M', '—'),
+    (0xFE59, '3', '('),
+    (0xFE5A, '3', ')'),
+    (0xFE5B, '3', '{'),
+    (0xFE5C, '3', '}'),
+    (0xFE5D, 'M', '〔'),
+    ]
+
+def _seg_50() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFE5E, 'M', '〕'),
+    (0xFE5F, '3', '#'),
+    (0xFE60, '3', '&'),
+    (0xFE61, '3', '*'),
+    (0xFE62, '3', '+'),
+    (0xFE63, 'M', '-'),
+    (0xFE64, '3', '<'),
+    (0xFE65, '3', '>'),
+    (0xFE66, '3', '='),
+    (0xFE67, 'X'),
+    (0xFE68, '3', '\\'),
+    (0xFE69, '3', '$'),
+    (0xFE6A, '3', '%'),
+    (0xFE6B, '3', '@'),
+    (0xFE6C, 'X'),
+    (0xFE70, '3', ' ً'),
+    (0xFE71, 'M', 'ـً'),
+    (0xFE72, '3', ' ٌ'),
+    (0xFE73, 'V'),
+    (0xFE74, '3', ' ٍ'),
+    (0xFE75, 'X'),
+    (0xFE76, '3', ' َ'),
+    (0xFE77, 'M', 'ـَ'),
+    (0xFE78, '3', ' ُ'),
+    (0xFE79, 'M', 'ـُ'),
+    (0xFE7A, '3', ' ِ'),
+    (0xFE7B, 'M', 'ـِ'),
+    (0xFE7C, '3', ' ّ'),
+    (0xFE7D, 'M', 'ـّ'),
+    (0xFE7E, '3', ' ْ'),
+    (0xFE7F, 'M', 'ـْ'),
+    (0xFE80, 'M', 'ء'),
+    (0xFE81, 'M', 'آ'),
+    (0xFE83, 'M', 'أ'),
+    (0xFE85, 'M', 'ؤ'),
+    (0xFE87, 'M', 'إ'),
+    (0xFE89, 'M', 'ئ'),
+    (0xFE8D, 'M', 'ا'),
+    (0xFE8F, 'M', 'ب'),
+    (0xFE93, 'M', 'ة'),
+    (0xFE95, 'M', 'ت'),
+    (0xFE99, 'M', 'ث'),
+    (0xFE9D, 'M', 'ج'),
+    (0xFEA1, 'M', 'ح'),
+    (0xFEA5, 'M', 'خ'),
+    (0xFEA9, 'M', 'د'),
+    (0xFEAB, 'M', 'ذ'),
+    (0xFEAD, 'M', 'ر'),
+    (0xFEAF, 'M', 'ز'),
+    (0xFEB1, 'M', 'س'),
+    (0xFEB5, 'M', 'ش'),
+    (0xFEB9, 'M', 'ص'),
+    (0xFEBD, 'M', 'ض'),
+    (0xFEC1, 'M', 'ط'),
+    (0xFEC5, 'M', 'ظ'),
+    (0xFEC9, 'M', 'ع'),
+    (0xFECD, 'M', 'غ'),
+    (0xFED1, 'M', 'ف'),
+    (0xFED5, 'M', 'ق'),
+    (0xFED9, 'M', 'ك'),
+    (0xFEDD, 'M', 'ل'),
+    (0xFEE1, 'M', 'م'),
+    (0xFEE5, 'M', 'ن'),
+    (0xFEE9, 'M', 'ه'),
+    (0xFEED, 'M', 'و'),
+    (0xFEEF, 'M', 'ى'),
+    (0xFEF1, 'M', 'ي'),
+    (0xFEF5, 'M', 'لآ'),
+    (0xFEF7, 'M', 'لأ'),
+    (0xFEF9, 'M', 'لإ'),
+    (0xFEFB, 'M', 'لا'),
+    (0xFEFD, 'X'),
+    (0xFEFF, 'I'),
+    (0xFF00, 'X'),
+    (0xFF01, '3', '!'),
+    (0xFF02, '3', '"'),
+    (0xFF03, '3', '#'),
+    (0xFF04, '3', '$'),
+    (0xFF05, '3', '%'),
+    (0xFF06, '3', '&'),
+    (0xFF07, '3', '\''),
+    (0xFF08, '3', '('),
+    (0xFF09, '3', ')'),
+    (0xFF0A, '3', '*'),
+    (0xFF0B, '3', '+'),
+    (0xFF0C, '3', ','),
+    (0xFF0D, 'M', '-'),
+    (0xFF0E, 'M', '.'),
+    (0xFF0F, '3', '/'),
+    (0xFF10, 'M', '0'),
+    (0xFF11, 'M', '1'),
+    (0xFF12, 'M', '2'),
+    (0xFF13, 'M', '3'),
+    (0xFF14, 'M', '4'),
+    (0xFF15, 'M', '5'),
+    (0xFF16, 'M', '6'),
+    (0xFF17, 'M', '7'),
+    (0xFF18, 'M', '8'),
+    (0xFF19, 'M', '9'),
+    (0xFF1A, '3', ':'),
+    ]
+
+def _seg_51() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFF1B, '3', ';'),
+    (0xFF1C, '3', '<'),
+    (0xFF1D, '3', '='),
+    (0xFF1E, '3', '>'),
+    (0xFF1F, '3', '?'),
+    (0xFF20, '3', '@'),
+    (0xFF21, 'M', 'a'),
+    (0xFF22, 'M', 'b'),
+    (0xFF23, 'M', 'c'),
+    (0xFF24, 'M', 'd'),
+    (0xFF25, 'M', 'e'),
+    (0xFF26, 'M', 'f'),
+    (0xFF27, 'M', 'g'),
+    (0xFF28, 'M', 'h'),
+    (0xFF29, 'M', 'i'),
+    (0xFF2A, 'M', 'j'),
+    (0xFF2B, 'M', 'k'),
+    (0xFF2C, 'M', 'l'),
+    (0xFF2D, 'M', 'm'),
+    (0xFF2E, 'M', 'n'),
+    (0xFF2F, 'M', 'o'),
+    (0xFF30, 'M', 'p'),
+    (0xFF31, 'M', 'q'),
+    (0xFF32, 'M', 'r'),
+    (0xFF33, 'M', 's'),
+    (0xFF34, 'M', 't'),
+    (0xFF35, 'M', 'u'),
+    (0xFF36, 'M', 'v'),
+    (0xFF37, 'M', 'w'),
+    (0xFF38, 'M', 'x'),
+    (0xFF39, 'M', 'y'),
+    (0xFF3A, 'M', 'z'),
+    (0xFF3B, '3', '['),
+    (0xFF3C, '3', '\\'),
+    (0xFF3D, '3', ']'),
+    (0xFF3E, '3', '^'),
+    (0xFF3F, '3', '_'),
+    (0xFF40, '3', '`'),
+    (0xFF41, 'M', 'a'),
+    (0xFF42, 'M', 'b'),
+    (0xFF43, 'M', 'c'),
+    (0xFF44, 'M', 'd'),
+    (0xFF45, 'M', 'e'),
+    (0xFF46, 'M', 'f'),
+    (0xFF47, 'M', 'g'),
+    (0xFF48, 'M', 'h'),
+    (0xFF49, 'M', 'i'),
+    (0xFF4A, 'M', 'j'),
+    (0xFF4B, 'M', 'k'),
+    (0xFF4C, 'M', 'l'),
+    (0xFF4D, 'M', 'm'),
+    (0xFF4E, 'M', 'n'),
+    (0xFF4F, 'M', 'o'),
+    (0xFF50, 'M', 'p'),
+    (0xFF51, 'M', 'q'),
+    (0xFF52, 'M', 'r'),
+    (0xFF53, 'M', 's'),
+    (0xFF54, 'M', 't'),
+    (0xFF55, 'M', 'u'),
+    (0xFF56, 'M', 'v'),
+    (0xFF57, 'M', 'w'),
+    (0xFF58, 'M', 'x'),
+    (0xFF59, 'M', 'y'),
+    (0xFF5A, 'M', 'z'),
+    (0xFF5B, '3', '{'),
+    (0xFF5C, '3', '|'),
+    (0xFF5D, '3', '}'),
+    (0xFF5E, '3', '~'),
+    (0xFF5F, 'M', '⦅'),
+    (0xFF60, 'M', '⦆'),
+    (0xFF61, 'M', '.'),
+    (0xFF62, 'M', '「'),
+    (0xFF63, 'M', '」'),
+    (0xFF64, 'M', '、'),
+    (0xFF65, 'M', '・'),
+    (0xFF66, 'M', 'ヲ'),
+    (0xFF67, 'M', 'ァ'),
+    (0xFF68, 'M', 'ィ'),
+    (0xFF69, 'M', 'ゥ'),
+    (0xFF6A, 'M', 'ェ'),
+    (0xFF6B, 'M', 'ォ'),
+    (0xFF6C, 'M', 'ャ'),
+    (0xFF6D, 'M', 'ュ'),
+    (0xFF6E, 'M', 'ョ'),
+    (0xFF6F, 'M', 'ッ'),
+    (0xFF70, 'M', 'ー'),
+    (0xFF71, 'M', 'ア'),
+    (0xFF72, 'M', 'イ'),
+    (0xFF73, 'M', 'ウ'),
+    (0xFF74, 'M', 'エ'),
+    (0xFF75, 'M', 'オ'),
+    (0xFF76, 'M', 'カ'),
+    (0xFF77, 'M', 'キ'),
+    (0xFF78, 'M', 'ク'),
+    (0xFF79, 'M', 'ケ'),
+    (0xFF7A, 'M', 'コ'),
+    (0xFF7B, 'M', 'サ'),
+    (0xFF7C, 'M', 'シ'),
+    (0xFF7D, 'M', 'ス'),
+    (0xFF7E, 'M', 'セ'),
+    ]
+
+def _seg_52() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFF7F, 'M', 'ソ'),
+    (0xFF80, 'M', 'タ'),
+    (0xFF81, 'M', 'チ'),
+    (0xFF82, 'M', 'ツ'),
+    (0xFF83, 'M', 'テ'),
+    (0xFF84, 'M', 'ト'),
+    (0xFF85, 'M', 'ナ'),
+    (0xFF86, 'M', 'ニ'),
+    (0xFF87, 'M', 'ヌ'),
+    (0xFF88, 'M', 'ネ'),
+    (0xFF89, 'M', 'ノ'),
+    (0xFF8A, 'M', 'ハ'),
+    (0xFF8B, 'M', 'ヒ'),
+    (0xFF8C, 'M', 'フ'),
+    (0xFF8D, 'M', 'ヘ'),
+    (0xFF8E, 'M', 'ホ'),
+    (0xFF8F, 'M', 'マ'),
+    (0xFF90, 'M', 'ミ'),
+    (0xFF91, 'M', 'ム'),
+    (0xFF92, 'M', 'メ'),
+    (0xFF93, 'M', 'モ'),
+    (0xFF94, 'M', 'ヤ'),
+    (0xFF95, 'M', 'ユ'),
+    (0xFF96, 'M', 'ヨ'),
+    (0xFF97, 'M', 'ラ'),
+    (0xFF98, 'M', 'リ'),
+    (0xFF99, 'M', 'ル'),
+    (0xFF9A, 'M', 'レ'),
+    (0xFF9B, 'M', 'ロ'),
+    (0xFF9C, 'M', 'ワ'),
+    (0xFF9D, 'M', 'ン'),
+    (0xFF9E, 'M', '゙'),
+    (0xFF9F, 'M', '゚'),
+    (0xFFA0, 'X'),
+    (0xFFA1, 'M', 'ᄀ'),
+    (0xFFA2, 'M', 'ᄁ'),
+    (0xFFA3, 'M', 'ᆪ'),
+    (0xFFA4, 'M', 'ᄂ'),
+    (0xFFA5, 'M', 'ᆬ'),
+    (0xFFA6, 'M', 'ᆭ'),
+    (0xFFA7, 'M', 'ᄃ'),
+    (0xFFA8, 'M', 'ᄄ'),
+    (0xFFA9, 'M', 'ᄅ'),
+    (0xFFAA, 'M', 'ᆰ'),
+    (0xFFAB, 'M', 'ᆱ'),
+    (0xFFAC, 'M', 'ᆲ'),
+    (0xFFAD, 'M', 'ᆳ'),
+    (0xFFAE, 'M', 'ᆴ'),
+    (0xFFAF, 'M', 'ᆵ'),
+    (0xFFB0, 'M', 'ᄚ'),
+    (0xFFB1, 'M', 'ᄆ'),
+    (0xFFB2, 'M', 'ᄇ'),
+    (0xFFB3, 'M', 'ᄈ'),
+    (0xFFB4, 'M', 'ᄡ'),
+    (0xFFB5, 'M', 'ᄉ'),
+    (0xFFB6, 'M', 'ᄊ'),
+    (0xFFB7, 'M', 'ᄋ'),
+    (0xFFB8, 'M', 'ᄌ'),
+    (0xFFB9, 'M', 'ᄍ'),
+    (0xFFBA, 'M', 'ᄎ'),
+    (0xFFBB, 'M', 'ᄏ'),
+    (0xFFBC, 'M', 'ᄐ'),
+    (0xFFBD, 'M', 'ᄑ'),
+    (0xFFBE, 'M', 'ᄒ'),
+    (0xFFBF, 'X'),
+    (0xFFC2, 'M', 'ᅡ'),
+    (0xFFC3, 'M', 'ᅢ'),
+    (0xFFC4, 'M', 'ᅣ'),
+    (0xFFC5, 'M', 'ᅤ'),
+    (0xFFC6, 'M', 'ᅥ'),
+    (0xFFC7, 'M', 'ᅦ'),
+    (0xFFC8, 'X'),
+    (0xFFCA, 'M', 'ᅧ'),
+    (0xFFCB, 'M', 'ᅨ'),
+    (0xFFCC, 'M', 'ᅩ'),
+    (0xFFCD, 'M', 'ᅪ'),
+    (0xFFCE, 'M', 'ᅫ'),
+    (0xFFCF, 'M', 'ᅬ'),
+    (0xFFD0, 'X'),
+    (0xFFD2, 'M', 'ᅭ'),
+    (0xFFD3, 'M', 'ᅮ'),
+    (0xFFD4, 'M', 'ᅯ'),
+    (0xFFD5, 'M', 'ᅰ'),
+    (0xFFD6, 'M', 'ᅱ'),
+    (0xFFD7, 'M', 'ᅲ'),
+    (0xFFD8, 'X'),
+    (0xFFDA, 'M', 'ᅳ'),
+    (0xFFDB, 'M', 'ᅴ'),
+    (0xFFDC, 'M', 'ᅵ'),
+    (0xFFDD, 'X'),
+    (0xFFE0, 'M', '¢'),
+    (0xFFE1, 'M', '£'),
+    (0xFFE2, 'M', '¬'),
+    (0xFFE3, '3', ' ̄'),
+    (0xFFE4, 'M', '¦'),
+    (0xFFE5, 'M', '¥'),
+    (0xFFE6, 'M', '₩'),
+    (0xFFE7, 'X'),
+    (0xFFE8, 'M', '│'),
+    (0xFFE9, 'M', '←'),
+    ]
+
+def _seg_53() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFFEA, 'M', '↑'),
+    (0xFFEB, 'M', '→'),
+    (0xFFEC, 'M', '↓'),
+    (0xFFED, 'M', '■'),
+    (0xFFEE, 'M', '○'),
+    (0xFFEF, 'X'),
+    (0x10000, 'V'),
+    (0x1000C, 'X'),
+    (0x1000D, 'V'),
+    (0x10027, 'X'),
+    (0x10028, 'V'),
+    (0x1003B, 'X'),
+    (0x1003C, 'V'),
+    (0x1003E, 'X'),
+    (0x1003F, 'V'),
+    (0x1004E, 'X'),
+    (0x10050, 'V'),
+    (0x1005E, 'X'),
+    (0x10080, 'V'),
+    (0x100FB, 'X'),
+    (0x10100, 'V'),
+    (0x10103, 'X'),
+    (0x10107, 'V'),
+    (0x10134, 'X'),
+    (0x10137, 'V'),
+    (0x1018F, 'X'),
+    (0x10190, 'V'),
+    (0x1019D, 'X'),
+    (0x101A0, 'V'),
+    (0x101A1, 'X'),
+    (0x101D0, 'V'),
+    (0x101FE, 'X'),
+    (0x10280, 'V'),
+    (0x1029D, 'X'),
+    (0x102A0, 'V'),
+    (0x102D1, 'X'),
+    (0x102E0, 'V'),
+    (0x102FC, 'X'),
+    (0x10300, 'V'),
+    (0x10324, 'X'),
+    (0x1032D, 'V'),
+    (0x1034B, 'X'),
+    (0x10350, 'V'),
+    (0x1037B, 'X'),
+    (0x10380, 'V'),
+    (0x1039E, 'X'),
+    (0x1039F, 'V'),
+    (0x103C4, 'X'),
+    (0x103C8, 'V'),
+    (0x103D6, 'X'),
+    (0x10400, 'M', '𐐨'),
+    (0x10401, 'M', '𐐩'),
+    (0x10402, 'M', '𐐪'),
+    (0x10403, 'M', '𐐫'),
+    (0x10404, 'M', '𐐬'),
+    (0x10405, 'M', '𐐭'),
+    (0x10406, 'M', '𐐮'),
+    (0x10407, 'M', '𐐯'),
+    (0x10408, 'M', '𐐰'),
+    (0x10409, 'M', '𐐱'),
+    (0x1040A, 'M', '𐐲'),
+    (0x1040B, 'M', '𐐳'),
+    (0x1040C, 'M', '𐐴'),
+    (0x1040D, 'M', '𐐵'),
+    (0x1040E, 'M', '𐐶'),
+    (0x1040F, 'M', '𐐷'),
+    (0x10410, 'M', '𐐸'),
+    (0x10411, 'M', '𐐹'),
+    (0x10412, 'M', '𐐺'),
+    (0x10413, 'M', '𐐻'),
+    (0x10414, 'M', '𐐼'),
+    (0x10415, 'M', '𐐽'),
+    (0x10416, 'M', '𐐾'),
+    (0x10417, 'M', '𐐿'),
+    (0x10418, 'M', '𐑀'),
+    (0x10419, 'M', '𐑁'),
+    (0x1041A, 'M', '𐑂'),
+    (0x1041B, 'M', '𐑃'),
+    (0x1041C, 'M', '𐑄'),
+    (0x1041D, 'M', '𐑅'),
+    (0x1041E, 'M', '𐑆'),
+    (0x1041F, 'M', '𐑇'),
+    (0x10420, 'M', '𐑈'),
+    (0x10421, 'M', '𐑉'),
+    (0x10422, 'M', '𐑊'),
+    (0x10423, 'M', '𐑋'),
+    (0x10424, 'M', '𐑌'),
+    (0x10425, 'M', '𐑍'),
+    (0x10426, 'M', '𐑎'),
+    (0x10427, 'M', '𐑏'),
+    (0x10428, 'V'),
+    (0x1049E, 'X'),
+    (0x104A0, 'V'),
+    (0x104AA, 'X'),
+    (0x104B0, 'M', '𐓘'),
+    (0x104B1, 'M', '𐓙'),
+    (0x104B2, 'M', '𐓚'),
+    (0x104B3, 'M', '𐓛'),
+    (0x104B4, 'M', '𐓜'),
+    (0x104B5, 'M', '𐓝'),
+    ]
+
+def _seg_54() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x104B6, 'M', '𐓞'),
+    (0x104B7, 'M', '𐓟'),
+    (0x104B8, 'M', '𐓠'),
+    (0x104B9, 'M', '𐓡'),
+    (0x104BA, 'M', '𐓢'),
+    (0x104BB, 'M', '𐓣'),
+    (0x104BC, 'M', '𐓤'),
+    (0x104BD, 'M', '𐓥'),
+    (0x104BE, 'M', '𐓦'),
+    (0x104BF, 'M', '𐓧'),
+    (0x104C0, 'M', '𐓨'),
+    (0x104C1, 'M', '𐓩'),
+    (0x104C2, 'M', '𐓪'),
+    (0x104C3, 'M', '𐓫'),
+    (0x104C4, 'M', '𐓬'),
+    (0x104C5, 'M', '𐓭'),
+    (0x104C6, 'M', '𐓮'),
+    (0x104C7, 'M', '𐓯'),
+    (0x104C8, 'M', '𐓰'),
+    (0x104C9, 'M', '𐓱'),
+    (0x104CA, 'M', '𐓲'),
+    (0x104CB, 'M', '𐓳'),
+    (0x104CC, 'M', '𐓴'),
+    (0x104CD, 'M', '𐓵'),
+    (0x104CE, 'M', '𐓶'),
+    (0x104CF, 'M', '𐓷'),
+    (0x104D0, 'M', '𐓸'),
+    (0x104D1, 'M', '𐓹'),
+    (0x104D2, 'M', '𐓺'),
+    (0x104D3, 'M', '𐓻'),
+    (0x104D4, 'X'),
+    (0x104D8, 'V'),
+    (0x104FC, 'X'),
+    (0x10500, 'V'),
+    (0x10528, 'X'),
+    (0x10530, 'V'),
+    (0x10564, 'X'),
+    (0x1056F, 'V'),
+    (0x10570, 'M', '𐖗'),
+    (0x10571, 'M', '𐖘'),
+    (0x10572, 'M', '𐖙'),
+    (0x10573, 'M', '𐖚'),
+    (0x10574, 'M', '𐖛'),
+    (0x10575, 'M', '𐖜'),
+    (0x10576, 'M', '𐖝'),
+    (0x10577, 'M', '𐖞'),
+    (0x10578, 'M', '𐖟'),
+    (0x10579, 'M', '𐖠'),
+    (0x1057A, 'M', '𐖡'),
+    (0x1057B, 'X'),
+    (0x1057C, 'M', '𐖣'),
+    (0x1057D, 'M', '𐖤'),
+    (0x1057E, 'M', '𐖥'),
+    (0x1057F, 'M', '𐖦'),
+    (0x10580, 'M', '𐖧'),
+    (0x10581, 'M', '𐖨'),
+    (0x10582, 'M', '𐖩'),
+    (0x10583, 'M', '𐖪'),
+    (0x10584, 'M', '𐖫'),
+    (0x10585, 'M', '𐖬'),
+    (0x10586, 'M', '𐖭'),
+    (0x10587, 'M', '𐖮'),
+    (0x10588, 'M', '𐖯'),
+    (0x10589, 'M', '𐖰'),
+    (0x1058A, 'M', '𐖱'),
+    (0x1058B, 'X'),
+    (0x1058C, 'M', '𐖳'),
+    (0x1058D, 'M', '𐖴'),
+    (0x1058E, 'M', '𐖵'),
+    (0x1058F, 'M', '𐖶'),
+    (0x10590, 'M', '𐖷'),
+    (0x10591, 'M', '𐖸'),
+    (0x10592, 'M', '𐖹'),
+    (0x10593, 'X'),
+    (0x10594, 'M', '𐖻'),
+    (0x10595, 'M', '𐖼'),
+    (0x10596, 'X'),
+    (0x10597, 'V'),
+    (0x105A2, 'X'),
+    (0x105A3, 'V'),
+    (0x105B2, 'X'),
+    (0x105B3, 'V'),
+    (0x105BA, 'X'),
+    (0x105BB, 'V'),
+    (0x105BD, 'X'),
+    (0x10600, 'V'),
+    (0x10737, 'X'),
+    (0x10740, 'V'),
+    (0x10756, 'X'),
+    (0x10760, 'V'),
+    (0x10768, 'X'),
+    (0x10780, 'V'),
+    (0x10781, 'M', 'ː'),
+    (0x10782, 'M', 'ˑ'),
+    (0x10783, 'M', 'æ'),
+    (0x10784, 'M', 'ʙ'),
+    (0x10785, 'M', 'ɓ'),
+    (0x10786, 'X'),
+    (0x10787, 'M', 'ʣ'),
+    (0x10788, 'M', 'ꭦ'),
+    ]
+
+def _seg_55() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x10789, 'M', 'ʥ'),
+    (0x1078A, 'M', 'ʤ'),
+    (0x1078B, 'M', 'ɖ'),
+    (0x1078C, 'M', 'ɗ'),
+    (0x1078D, 'M', 'ᶑ'),
+    (0x1078E, 'M', 'ɘ'),
+    (0x1078F, 'M', 'ɞ'),
+    (0x10790, 'M', 'ʩ'),
+    (0x10791, 'M', 'ɤ'),
+    (0x10792, 'M', 'ɢ'),
+    (0x10793, 'M', 'ɠ'),
+    (0x10794, 'M', 'ʛ'),
+    (0x10795, 'M', 'ħ'),
+    (0x10796, 'M', 'ʜ'),
+    (0x10797, 'M', 'ɧ'),
+    (0x10798, 'M', 'ʄ'),
+    (0x10799, 'M', 'ʪ'),
+    (0x1079A, 'M', 'ʫ'),
+    (0x1079B, 'M', 'ɬ'),
+    (0x1079C, 'M', '𝼄'),
+    (0x1079D, 'M', 'ꞎ'),
+    (0x1079E, 'M', 'ɮ'),
+    (0x1079F, 'M', '𝼅'),
+    (0x107A0, 'M', 'ʎ'),
+    (0x107A1, 'M', '𝼆'),
+    (0x107A2, 'M', 'ø'),
+    (0x107A3, 'M', 'ɶ'),
+    (0x107A4, 'M', 'ɷ'),
+    (0x107A5, 'M', 'q'),
+    (0x107A6, 'M', 'ɺ'),
+    (0x107A7, 'M', '𝼈'),
+    (0x107A8, 'M', 'ɽ'),
+    (0x107A9, 'M', 'ɾ'),
+    (0x107AA, 'M', 'ʀ'),
+    (0x107AB, 'M', 'ʨ'),
+    (0x107AC, 'M', 'ʦ'),
+    (0x107AD, 'M', 'ꭧ'),
+    (0x107AE, 'M', 'ʧ'),
+    (0x107AF, 'M', 'ʈ'),
+    (0x107B0, 'M', 'ⱱ'),
+    (0x107B1, 'X'),
+    (0x107B2, 'M', 'ʏ'),
+    (0x107B3, 'M', 'ʡ'),
+    (0x107B4, 'M', 'ʢ'),
+    (0x107B5, 'M', 'ʘ'),
+    (0x107B6, 'M', 'ǀ'),
+    (0x107B7, 'M', 'ǁ'),
+    (0x107B8, 'M', 'ǂ'),
+    (0x107B9, 'M', '𝼊'),
+    (0x107BA, 'M', '𝼞'),
+    (0x107BB, 'X'),
+    (0x10800, 'V'),
+    (0x10806, 'X'),
+    (0x10808, 'V'),
+    (0x10809, 'X'),
+    (0x1080A, 'V'),
+    (0x10836, 'X'),
+    (0x10837, 'V'),
+    (0x10839, 'X'),
+    (0x1083C, 'V'),
+    (0x1083D, 'X'),
+    (0x1083F, 'V'),
+    (0x10856, 'X'),
+    (0x10857, 'V'),
+    (0x1089F, 'X'),
+    (0x108A7, 'V'),
+    (0x108B0, 'X'),
+    (0x108E0, 'V'),
+    (0x108F3, 'X'),
+    (0x108F4, 'V'),
+    (0x108F6, 'X'),
+    (0x108FB, 'V'),
+    (0x1091C, 'X'),
+    (0x1091F, 'V'),
+    (0x1093A, 'X'),
+    (0x1093F, 'V'),
+    (0x10940, 'X'),
+    (0x10980, 'V'),
+    (0x109B8, 'X'),
+    (0x109BC, 'V'),
+    (0x109D0, 'X'),
+    (0x109D2, 'V'),
+    (0x10A04, 'X'),
+    (0x10A05, 'V'),
+    (0x10A07, 'X'),
+    (0x10A0C, 'V'),
+    (0x10A14, 'X'),
+    (0x10A15, 'V'),
+    (0x10A18, 'X'),
+    (0x10A19, 'V'),
+    (0x10A36, 'X'),
+    (0x10A38, 'V'),
+    (0x10A3B, 'X'),
+    (0x10A3F, 'V'),
+    (0x10A49, 'X'),
+    (0x10A50, 'V'),
+    (0x10A59, 'X'),
+    (0x10A60, 'V'),
+    (0x10AA0, 'X'),
+    (0x10AC0, 'V'),
+    ]
+
+def _seg_56() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x10AE7, 'X'),
+    (0x10AEB, 'V'),
+    (0x10AF7, 'X'),
+    (0x10B00, 'V'),
+    (0x10B36, 'X'),
+    (0x10B39, 'V'),
+    (0x10B56, 'X'),
+    (0x10B58, 'V'),
+    (0x10B73, 'X'),
+    (0x10B78, 'V'),
+    (0x10B92, 'X'),
+    (0x10B99, 'V'),
+    (0x10B9D, 'X'),
+    (0x10BA9, 'V'),
+    (0x10BB0, 'X'),
+    (0x10C00, 'V'),
+    (0x10C49, 'X'),
+    (0x10C80, 'M', '𐳀'),
+    (0x10C81, 'M', '𐳁'),
+    (0x10C82, 'M', '𐳂'),
+    (0x10C83, 'M', '𐳃'),
+    (0x10C84, 'M', '𐳄'),
+    (0x10C85, 'M', '𐳅'),
+    (0x10C86, 'M', '𐳆'),
+    (0x10C87, 'M', '𐳇'),
+    (0x10C88, 'M', '𐳈'),
+    (0x10C89, 'M', '𐳉'),
+    (0x10C8A, 'M', '𐳊'),
+    (0x10C8B, 'M', '𐳋'),
+    (0x10C8C, 'M', '𐳌'),
+    (0x10C8D, 'M', '𐳍'),
+    (0x10C8E, 'M', '𐳎'),
+    (0x10C8F, 'M', '𐳏'),
+    (0x10C90, 'M', '𐳐'),
+    (0x10C91, 'M', '𐳑'),
+    (0x10C92, 'M', '𐳒'),
+    (0x10C93, 'M', '𐳓'),
+    (0x10C94, 'M', '𐳔'),
+    (0x10C95, 'M', '𐳕'),
+    (0x10C96, 'M', '𐳖'),
+    (0x10C97, 'M', '𐳗'),
+    (0x10C98, 'M', '𐳘'),
+    (0x10C99, 'M', '𐳙'),
+    (0x10C9A, 'M', '𐳚'),
+    (0x10C9B, 'M', '𐳛'),
+    (0x10C9C, 'M', '𐳜'),
+    (0x10C9D, 'M', '𐳝'),
+    (0x10C9E, 'M', '𐳞'),
+    (0x10C9F, 'M', '𐳟'),
+    (0x10CA0, 'M', '𐳠'),
+    (0x10CA1, 'M', '𐳡'),
+    (0x10CA2, 'M', '𐳢'),
+    (0x10CA3, 'M', '𐳣'),
+    (0x10CA4, 'M', '𐳤'),
+    (0x10CA5, 'M', '𐳥'),
+    (0x10CA6, 'M', '𐳦'),
+    (0x10CA7, 'M', '𐳧'),
+    (0x10CA8, 'M', '𐳨'),
+    (0x10CA9, 'M', '𐳩'),
+    (0x10CAA, 'M', '𐳪'),
+    (0x10CAB, 'M', '𐳫'),
+    (0x10CAC, 'M', '𐳬'),
+    (0x10CAD, 'M', '𐳭'),
+    (0x10CAE, 'M', '𐳮'),
+    (0x10CAF, 'M', '𐳯'),
+    (0x10CB0, 'M', '𐳰'),
+    (0x10CB1, 'M', '𐳱'),
+    (0x10CB2, 'M', '𐳲'),
+    (0x10CB3, 'X'),
+    (0x10CC0, 'V'),
+    (0x10CF3, 'X'),
+    (0x10CFA, 'V'),
+    (0x10D28, 'X'),
+    (0x10D30, 'V'),
+    (0x10D3A, 'X'),
+    (0x10E60, 'V'),
+    (0x10E7F, 'X'),
+    (0x10E80, 'V'),
+    (0x10EAA, 'X'),
+    (0x10EAB, 'V'),
+    (0x10EAE, 'X'),
+    (0x10EB0, 'V'),
+    (0x10EB2, 'X'),
+    (0x10F00, 'V'),
+    (0x10F28, 'X'),
+    (0x10F30, 'V'),
+    (0x10F5A, 'X'),
+    (0x10F70, 'V'),
+    (0x10F8A, 'X'),
+    (0x10FB0, 'V'),
+    (0x10FCC, 'X'),
+    (0x10FE0, 'V'),
+    (0x10FF7, 'X'),
+    (0x11000, 'V'),
+    (0x1104E, 'X'),
+    (0x11052, 'V'),
+    (0x11076, 'X'),
+    (0x1107F, 'V'),
+    (0x110BD, 'X'),
+    (0x110BE, 'V'),
+    ]
+
+def _seg_57() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x110C3, 'X'),
+    (0x110D0, 'V'),
+    (0x110E9, 'X'),
+    (0x110F0, 'V'),
+    (0x110FA, 'X'),
+    (0x11100, 'V'),
+    (0x11135, 'X'),
+    (0x11136, 'V'),
+    (0x11148, 'X'),
+    (0x11150, 'V'),
+    (0x11177, 'X'),
+    (0x11180, 'V'),
+    (0x111E0, 'X'),
+    (0x111E1, 'V'),
+    (0x111F5, 'X'),
+    (0x11200, 'V'),
+    (0x11212, 'X'),
+    (0x11213, 'V'),
+    (0x1123F, 'X'),
+    (0x11280, 'V'),
+    (0x11287, 'X'),
+    (0x11288, 'V'),
+    (0x11289, 'X'),
+    (0x1128A, 'V'),
+    (0x1128E, 'X'),
+    (0x1128F, 'V'),
+    (0x1129E, 'X'),
+    (0x1129F, 'V'),
+    (0x112AA, 'X'),
+    (0x112B0, 'V'),
+    (0x112EB, 'X'),
+    (0x112F0, 'V'),
+    (0x112FA, 'X'),
+    (0x11300, 'V'),
+    (0x11304, 'X'),
+    (0x11305, 'V'),
+    (0x1130D, 'X'),
+    (0x1130F, 'V'),
+    (0x11311, 'X'),
+    (0x11313, 'V'),
+    (0x11329, 'X'),
+    (0x1132A, 'V'),
+    (0x11331, 'X'),
+    (0x11332, 'V'),
+    (0x11334, 'X'),
+    (0x11335, 'V'),
+    (0x1133A, 'X'),
+    (0x1133B, 'V'),
+    (0x11345, 'X'),
+    (0x11347, 'V'),
+    (0x11349, 'X'),
+    (0x1134B, 'V'),
+    (0x1134E, 'X'),
+    (0x11350, 'V'),
+    (0x11351, 'X'),
+    (0x11357, 'V'),
+    (0x11358, 'X'),
+    (0x1135D, 'V'),
+    (0x11364, 'X'),
+    (0x11366, 'V'),
+    (0x1136D, 'X'),
+    (0x11370, 'V'),
+    (0x11375, 'X'),
+    (0x11400, 'V'),
+    (0x1145C, 'X'),
+    (0x1145D, 'V'),
+    (0x11462, 'X'),
+    (0x11480, 'V'),
+    (0x114C8, 'X'),
+    (0x114D0, 'V'),
+    (0x114DA, 'X'),
+    (0x11580, 'V'),
+    (0x115B6, 'X'),
+    (0x115B8, 'V'),
+    (0x115DE, 'X'),
+    (0x11600, 'V'),
+    (0x11645, 'X'),
+    (0x11650, 'V'),
+    (0x1165A, 'X'),
+    (0x11660, 'V'),
+    (0x1166D, 'X'),
+    (0x11680, 'V'),
+    (0x116BA, 'X'),
+    (0x116C0, 'V'),
+    (0x116CA, 'X'),
+    (0x11700, 'V'),
+    (0x1171B, 'X'),
+    (0x1171D, 'V'),
+    (0x1172C, 'X'),
+    (0x11730, 'V'),
+    (0x11747, 'X'),
+    (0x11800, 'V'),
+    (0x1183C, 'X'),
+    (0x118A0, 'M', '𑣀'),
+    (0x118A1, 'M', '𑣁'),
+    (0x118A2, 'M', '𑣂'),
+    (0x118A3, 'M', '𑣃'),
+    (0x118A4, 'M', '𑣄'),
+    (0x118A5, 'M', '𑣅'),
+    (0x118A6, 'M', '𑣆'),
+    ]
+
+def _seg_58() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x118A7, 'M', '𑣇'),
+    (0x118A8, 'M', '𑣈'),
+    (0x118A9, 'M', '𑣉'),
+    (0x118AA, 'M', '𑣊'),
+    (0x118AB, 'M', '𑣋'),
+    (0x118AC, 'M', '𑣌'),
+    (0x118AD, 'M', '𑣍'),
+    (0x118AE, 'M', '𑣎'),
+    (0x118AF, 'M', '𑣏'),
+    (0x118B0, 'M', '𑣐'),
+    (0x118B1, 'M', '𑣑'),
+    (0x118B2, 'M', '𑣒'),
+    (0x118B3, 'M', '𑣓'),
+    (0x118B4, 'M', '𑣔'),
+    (0x118B5, 'M', '𑣕'),
+    (0x118B6, 'M', '𑣖'),
+    (0x118B7, 'M', '𑣗'),
+    (0x118B8, 'M', '𑣘'),
+    (0x118B9, 'M', '𑣙'),
+    (0x118BA, 'M', '𑣚'),
+    (0x118BB, 'M', '𑣛'),
+    (0x118BC, 'M', '𑣜'),
+    (0x118BD, 'M', '𑣝'),
+    (0x118BE, 'M', '𑣞'),
+    (0x118BF, 'M', '𑣟'),
+    (0x118C0, 'V'),
+    (0x118F3, 'X'),
+    (0x118FF, 'V'),
+    (0x11907, 'X'),
+    (0x11909, 'V'),
+    (0x1190A, 'X'),
+    (0x1190C, 'V'),
+    (0x11914, 'X'),
+    (0x11915, 'V'),
+    (0x11917, 'X'),
+    (0x11918, 'V'),
+    (0x11936, 'X'),
+    (0x11937, 'V'),
+    (0x11939, 'X'),
+    (0x1193B, 'V'),
+    (0x11947, 'X'),
+    (0x11950, 'V'),
+    (0x1195A, 'X'),
+    (0x119A0, 'V'),
+    (0x119A8, 'X'),
+    (0x119AA, 'V'),
+    (0x119D8, 'X'),
+    (0x119DA, 'V'),
+    (0x119E5, 'X'),
+    (0x11A00, 'V'),
+    (0x11A48, 'X'),
+    (0x11A50, 'V'),
+    (0x11AA3, 'X'),
+    (0x11AB0, 'V'),
+    (0x11AF9, 'X'),
+    (0x11C00, 'V'),
+    (0x11C09, 'X'),
+    (0x11C0A, 'V'),
+    (0x11C37, 'X'),
+    (0x11C38, 'V'),
+    (0x11C46, 'X'),
+    (0x11C50, 'V'),
+    (0x11C6D, 'X'),
+    (0x11C70, 'V'),
+    (0x11C90, 'X'),
+    (0x11C92, 'V'),
+    (0x11CA8, 'X'),
+    (0x11CA9, 'V'),
+    (0x11CB7, 'X'),
+    (0x11D00, 'V'),
+    (0x11D07, 'X'),
+    (0x11D08, 'V'),
+    (0x11D0A, 'X'),
+    (0x11D0B, 'V'),
+    (0x11D37, 'X'),
+    (0x11D3A, 'V'),
+    (0x11D3B, 'X'),
+    (0x11D3C, 'V'),
+    (0x11D3E, 'X'),
+    (0x11D3F, 'V'),
+    (0x11D48, 'X'),
+    (0x11D50, 'V'),
+    (0x11D5A, 'X'),
+    (0x11D60, 'V'),
+    (0x11D66, 'X'),
+    (0x11D67, 'V'),
+    (0x11D69, 'X'),
+    (0x11D6A, 'V'),
+    (0x11D8F, 'X'),
+    (0x11D90, 'V'),
+    (0x11D92, 'X'),
+    (0x11D93, 'V'),
+    (0x11D99, 'X'),
+    (0x11DA0, 'V'),
+    (0x11DAA, 'X'),
+    (0x11EE0, 'V'),
+    (0x11EF9, 'X'),
+    (0x11FB0, 'V'),
+    (0x11FB1, 'X'),
+    (0x11FC0, 'V'),
+    ]
+
+def _seg_59() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x11FF2, 'X'),
+    (0x11FFF, 'V'),
+    (0x1239A, 'X'),
+    (0x12400, 'V'),
+    (0x1246F, 'X'),
+    (0x12470, 'V'),
+    (0x12475, 'X'),
+    (0x12480, 'V'),
+    (0x12544, 'X'),
+    (0x12F90, 'V'),
+    (0x12FF3, 'X'),
+    (0x13000, 'V'),
+    (0x1342F, 'X'),
+    (0x14400, 'V'),
+    (0x14647, 'X'),
+    (0x16800, 'V'),
+    (0x16A39, 'X'),
+    (0x16A40, 'V'),
+    (0x16A5F, 'X'),
+    (0x16A60, 'V'),
+    (0x16A6A, 'X'),
+    (0x16A6E, 'V'),
+    (0x16ABF, 'X'),
+    (0x16AC0, 'V'),
+    (0x16ACA, 'X'),
+    (0x16AD0, 'V'),
+    (0x16AEE, 'X'),
+    (0x16AF0, 'V'),
+    (0x16AF6, 'X'),
+    (0x16B00, 'V'),
+    (0x16B46, 'X'),
+    (0x16B50, 'V'),
+    (0x16B5A, 'X'),
+    (0x16B5B, 'V'),
+    (0x16B62, 'X'),
+    (0x16B63, 'V'),
+    (0x16B78, 'X'),
+    (0x16B7D, 'V'),
+    (0x16B90, 'X'),
+    (0x16E40, 'M', '𖹠'),
+    (0x16E41, 'M', '𖹡'),
+    (0x16E42, 'M', '𖹢'),
+    (0x16E43, 'M', '𖹣'),
+    (0x16E44, 'M', '𖹤'),
+    (0x16E45, 'M', '𖹥'),
+    (0x16E46, 'M', '𖹦'),
+    (0x16E47, 'M', '𖹧'),
+    (0x16E48, 'M', '𖹨'),
+    (0x16E49, 'M', '𖹩'),
+    (0x16E4A, 'M', '𖹪'),
+    (0x16E4B, 'M', '𖹫'),
+    (0x16E4C, 'M', '𖹬'),
+    (0x16E4D, 'M', '𖹭'),
+    (0x16E4E, 'M', '𖹮'),
+    (0x16E4F, 'M', '𖹯'),
+    (0x16E50, 'M', '𖹰'),
+    (0x16E51, 'M', '𖹱'),
+    (0x16E52, 'M', '𖹲'),
+    (0x16E53, 'M', '𖹳'),
+    (0x16E54, 'M', '𖹴'),
+    (0x16E55, 'M', '𖹵'),
+    (0x16E56, 'M', '𖹶'),
+    (0x16E57, 'M', '𖹷'),
+    (0x16E58, 'M', '𖹸'),
+    (0x16E59, 'M', '𖹹'),
+    (0x16E5A, 'M', '𖹺'),
+    (0x16E5B, 'M', '𖹻'),
+    (0x16E5C, 'M', '𖹼'),
+    (0x16E5D, 'M', '𖹽'),
+    (0x16E5E, 'M', '𖹾'),
+    (0x16E5F, 'M', '𖹿'),
+    (0x16E60, 'V'),
+    (0x16E9B, 'X'),
+    (0x16F00, 'V'),
+    (0x16F4B, 'X'),
+    (0x16F4F, 'V'),
+    (0x16F88, 'X'),
+    (0x16F8F, 'V'),
+    (0x16FA0, 'X'),
+    (0x16FE0, 'V'),
+    (0x16FE5, 'X'),
+    (0x16FF0, 'V'),
+    (0x16FF2, 'X'),
+    (0x17000, 'V'),
+    (0x187F8, 'X'),
+    (0x18800, 'V'),
+    (0x18CD6, 'X'),
+    (0x18D00, 'V'),
+    (0x18D09, 'X'),
+    (0x1AFF0, 'V'),
+    (0x1AFF4, 'X'),
+    (0x1AFF5, 'V'),
+    (0x1AFFC, 'X'),
+    (0x1AFFD, 'V'),
+    (0x1AFFF, 'X'),
+    (0x1B000, 'V'),
+    (0x1B123, 'X'),
+    (0x1B150, 'V'),
+    (0x1B153, 'X'),
+    (0x1B164, 'V'),
+    ]
+
+def _seg_60() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1B168, 'X'),
+    (0x1B170, 'V'),
+    (0x1B2FC, 'X'),
+    (0x1BC00, 'V'),
+    (0x1BC6B, 'X'),
+    (0x1BC70, 'V'),
+    (0x1BC7D, 'X'),
+    (0x1BC80, 'V'),
+    (0x1BC89, 'X'),
+    (0x1BC90, 'V'),
+    (0x1BC9A, 'X'),
+    (0x1BC9C, 'V'),
+    (0x1BCA0, 'I'),
+    (0x1BCA4, 'X'),
+    (0x1CF00, 'V'),
+    (0x1CF2E, 'X'),
+    (0x1CF30, 'V'),
+    (0x1CF47, 'X'),
+    (0x1CF50, 'V'),
+    (0x1CFC4, 'X'),
+    (0x1D000, 'V'),
+    (0x1D0F6, 'X'),
+    (0x1D100, 'V'),
+    (0x1D127, 'X'),
+    (0x1D129, 'V'),
+    (0x1D15E, 'M', '𝅗𝅥'),
+    (0x1D15F, 'M', '𝅘𝅥'),
+    (0x1D160, 'M', '𝅘𝅥𝅮'),
+    (0x1D161, 'M', '𝅘𝅥𝅯'),
+    (0x1D162, 'M', '𝅘𝅥𝅰'),
+    (0x1D163, 'M', '𝅘𝅥𝅱'),
+    (0x1D164, 'M', '𝅘𝅥𝅲'),
+    (0x1D165, 'V'),
+    (0x1D173, 'X'),
+    (0x1D17B, 'V'),
+    (0x1D1BB, 'M', '𝆹𝅥'),
+    (0x1D1BC, 'M', '𝆺𝅥'),
+    (0x1D1BD, 'M', '𝆹𝅥𝅮'),
+    (0x1D1BE, 'M', '𝆺𝅥𝅮'),
+    (0x1D1BF, 'M', '𝆹𝅥𝅯'),
+    (0x1D1C0, 'M', '𝆺𝅥𝅯'),
+    (0x1D1C1, 'V'),
+    (0x1D1EB, 'X'),
+    (0x1D200, 'V'),
+    (0x1D246, 'X'),
+    (0x1D2E0, 'V'),
+    (0x1D2F4, 'X'),
+    (0x1D300, 'V'),
+    (0x1D357, 'X'),
+    (0x1D360, 'V'),
+    (0x1D379, 'X'),
+    (0x1D400, 'M', 'a'),
+    (0x1D401, 'M', 'b'),
+    (0x1D402, 'M', 'c'),
+    (0x1D403, 'M', 'd'),
+    (0x1D404, 'M', 'e'),
+    (0x1D405, 'M', 'f'),
+    (0x1D406, 'M', 'g'),
+    (0x1D407, 'M', 'h'),
+    (0x1D408, 'M', 'i'),
+    (0x1D409, 'M', 'j'),
+    (0x1D40A, 'M', 'k'),
+    (0x1D40B, 'M', 'l'),
+    (0x1D40C, 'M', 'm'),
+    (0x1D40D, 'M', 'n'),
+    (0x1D40E, 'M', 'o'),
+    (0x1D40F, 'M', 'p'),
+    (0x1D410, 'M', 'q'),
+    (0x1D411, 'M', 'r'),
+    (0x1D412, 'M', 's'),
+    (0x1D413, 'M', 't'),
+    (0x1D414, 'M', 'u'),
+    (0x1D415, 'M', 'v'),
+    (0x1D416, 'M', 'w'),
+    (0x1D417, 'M', 'x'),
+    (0x1D418, 'M', 'y'),
+    (0x1D419, 'M', 'z'),
+    (0x1D41A, 'M', 'a'),
+    (0x1D41B, 'M', 'b'),
+    (0x1D41C, 'M', 'c'),
+    (0x1D41D, 'M', 'd'),
+    (0x1D41E, 'M', 'e'),
+    (0x1D41F, 'M', 'f'),
+    (0x1D420, 'M', 'g'),
+    (0x1D421, 'M', 'h'),
+    (0x1D422, 'M', 'i'),
+    (0x1D423, 'M', 'j'),
+    (0x1D424, 'M', 'k'),
+    (0x1D425, 'M', 'l'),
+    (0x1D426, 'M', 'm'),
+    (0x1D427, 'M', 'n'),
+    (0x1D428, 'M', 'o'),
+    (0x1D429, 'M', 'p'),
+    (0x1D42A, 'M', 'q'),
+    (0x1D42B, 'M', 'r'),
+    (0x1D42C, 'M', 's'),
+    (0x1D42D, 'M', 't'),
+    (0x1D42E, 'M', 'u'),
+    (0x1D42F, 'M', 'v'),
+    (0x1D430, 'M', 'w'),
+    ]
+
+def _seg_61() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D431, 'M', 'x'),
+    (0x1D432, 'M', 'y'),
+    (0x1D433, 'M', 'z'),
+    (0x1D434, 'M', 'a'),
+    (0x1D435, 'M', 'b'),
+    (0x1D436, 'M', 'c'),
+    (0x1D437, 'M', 'd'),
+    (0x1D438, 'M', 'e'),
+    (0x1D439, 'M', 'f'),
+    (0x1D43A, 'M', 'g'),
+    (0x1D43B, 'M', 'h'),
+    (0x1D43C, 'M', 'i'),
+    (0x1D43D, 'M', 'j'),
+    (0x1D43E, 'M', 'k'),
+    (0x1D43F, 'M', 'l'),
+    (0x1D440, 'M', 'm'),
+    (0x1D441, 'M', 'n'),
+    (0x1D442, 'M', 'o'),
+    (0x1D443, 'M', 'p'),
+    (0x1D444, 'M', 'q'),
+    (0x1D445, 'M', 'r'),
+    (0x1D446, 'M', 's'),
+    (0x1D447, 'M', 't'),
+    (0x1D448, 'M', 'u'),
+    (0x1D449, 'M', 'v'),
+    (0x1D44A, 'M', 'w'),
+    (0x1D44B, 'M', 'x'),
+    (0x1D44C, 'M', 'y'),
+    (0x1D44D, 'M', 'z'),
+    (0x1D44E, 'M', 'a'),
+    (0x1D44F, 'M', 'b'),
+    (0x1D450, 'M', 'c'),
+    (0x1D451, 'M', 'd'),
+    (0x1D452, 'M', 'e'),
+    (0x1D453, 'M', 'f'),
+    (0x1D454, 'M', 'g'),
+    (0x1D455, 'X'),
+    (0x1D456, 'M', 'i'),
+    (0x1D457, 'M', 'j'),
+    (0x1D458, 'M', 'k'),
+    (0x1D459, 'M', 'l'),
+    (0x1D45A, 'M', 'm'),
+    (0x1D45B, 'M', 'n'),
+    (0x1D45C, 'M', 'o'),
+    (0x1D45D, 'M', 'p'),
+    (0x1D45E, 'M', 'q'),
+    (0x1D45F, 'M', 'r'),
+    (0x1D460, 'M', 's'),
+    (0x1D461, 'M', 't'),
+    (0x1D462, 'M', 'u'),
+    (0x1D463, 'M', 'v'),
+    (0x1D464, 'M', 'w'),
+    (0x1D465, 'M', 'x'),
+    (0x1D466, 'M', 'y'),
+    (0x1D467, 'M', 'z'),
+    (0x1D468, 'M', 'a'),
+    (0x1D469, 'M', 'b'),
+    (0x1D46A, 'M', 'c'),
+    (0x1D46B, 'M', 'd'),
+    (0x1D46C, 'M', 'e'),
+    (0x1D46D, 'M', 'f'),
+    (0x1D46E, 'M', 'g'),
+    (0x1D46F, 'M', 'h'),
+    (0x1D470, 'M', 'i'),
+    (0x1D471, 'M', 'j'),
+    (0x1D472, 'M', 'k'),
+    (0x1D473, 'M', 'l'),
+    (0x1D474, 'M', 'm'),
+    (0x1D475, 'M', 'n'),
+    (0x1D476, 'M', 'o'),
+    (0x1D477, 'M', 'p'),
+    (0x1D478, 'M', 'q'),
+    (0x1D479, 'M', 'r'),
+    (0x1D47A, 'M', 's'),
+    (0x1D47B, 'M', 't'),
+    (0x1D47C, 'M', 'u'),
+    (0x1D47D, 'M', 'v'),
+    (0x1D47E, 'M', 'w'),
+    (0x1D47F, 'M', 'x'),
+    (0x1D480, 'M', 'y'),
+    (0x1D481, 'M', 'z'),
+    (0x1D482, 'M', 'a'),
+    (0x1D483, 'M', 'b'),
+    (0x1D484, 'M', 'c'),
+    (0x1D485, 'M', 'd'),
+    (0x1D486, 'M', 'e'),
+    (0x1D487, 'M', 'f'),
+    (0x1D488, 'M', 'g'),
+    (0x1D489, 'M', 'h'),
+    (0x1D48A, 'M', 'i'),
+    (0x1D48B, 'M', 'j'),
+    (0x1D48C, 'M', 'k'),
+    (0x1D48D, 'M', 'l'),
+    (0x1D48E, 'M', 'm'),
+    (0x1D48F, 'M', 'n'),
+    (0x1D490, 'M', 'o'),
+    (0x1D491, 'M', 'p'),
+    (0x1D492, 'M', 'q'),
+    (0x1D493, 'M', 'r'),
+    (0x1D494, 'M', 's'),
+    ]
+
+def _seg_62() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D495, 'M', 't'),
+    (0x1D496, 'M', 'u'),
+    (0x1D497, 'M', 'v'),
+    (0x1D498, 'M', 'w'),
+    (0x1D499, 'M', 'x'),
+    (0x1D49A, 'M', 'y'),
+    (0x1D49B, 'M', 'z'),
+    (0x1D49C, 'M', 'a'),
+    (0x1D49D, 'X'),
+    (0x1D49E, 'M', 'c'),
+    (0x1D49F, 'M', 'd'),
+    (0x1D4A0, 'X'),
+    (0x1D4A2, 'M', 'g'),
+    (0x1D4A3, 'X'),
+    (0x1D4A5, 'M', 'j'),
+    (0x1D4A6, 'M', 'k'),
+    (0x1D4A7, 'X'),
+    (0x1D4A9, 'M', 'n'),
+    (0x1D4AA, 'M', 'o'),
+    (0x1D4AB, 'M', 'p'),
+    (0x1D4AC, 'M', 'q'),
+    (0x1D4AD, 'X'),
+    (0x1D4AE, 'M', 's'),
+    (0x1D4AF, 'M', 't'),
+    (0x1D4B0, 'M', 'u'),
+    (0x1D4B1, 'M', 'v'),
+    (0x1D4B2, 'M', 'w'),
+    (0x1D4B3, 'M', 'x'),
+    (0x1D4B4, 'M', 'y'),
+    (0x1D4B5, 'M', 'z'),
+    (0x1D4B6, 'M', 'a'),
+    (0x1D4B7, 'M', 'b'),
+    (0x1D4B8, 'M', 'c'),
+    (0x1D4B9, 'M', 'd'),
+    (0x1D4BA, 'X'),
+    (0x1D4BB, 'M', 'f'),
+    (0x1D4BC, 'X'),
+    (0x1D4BD, 'M', 'h'),
+    (0x1D4BE, 'M', 'i'),
+    (0x1D4BF, 'M', 'j'),
+    (0x1D4C0, 'M', 'k'),
+    (0x1D4C1, 'M', 'l'),
+    (0x1D4C2, 'M', 'm'),
+    (0x1D4C3, 'M', 'n'),
+    (0x1D4C4, 'X'),
+    (0x1D4C5, 'M', 'p'),
+    (0x1D4C6, 'M', 'q'),
+    (0x1D4C7, 'M', 'r'),
+    (0x1D4C8, 'M', 's'),
+    (0x1D4C9, 'M', 't'),
+    (0x1D4CA, 'M', 'u'),
+    (0x1D4CB, 'M', 'v'),
+    (0x1D4CC, 'M', 'w'),
+    (0x1D4CD, 'M', 'x'),
+    (0x1D4CE, 'M', 'y'),
+    (0x1D4CF, 'M', 'z'),
+    (0x1D4D0, 'M', 'a'),
+    (0x1D4D1, 'M', 'b'),
+    (0x1D4D2, 'M', 'c'),
+    (0x1D4D3, 'M', 'd'),
+    (0x1D4D4, 'M', 'e'),
+    (0x1D4D5, 'M', 'f'),
+    (0x1D4D6, 'M', 'g'),
+    (0x1D4D7, 'M', 'h'),
+    (0x1D4D8, 'M', 'i'),
+    (0x1D4D9, 'M', 'j'),
+    (0x1D4DA, 'M', 'k'),
+    (0x1D4DB, 'M', 'l'),
+    (0x1D4DC, 'M', 'm'),
+    (0x1D4DD, 'M', 'n'),
+    (0x1D4DE, 'M', 'o'),
+    (0x1D4DF, 'M', 'p'),
+    (0x1D4E0, 'M', 'q'),
+    (0x1D4E1, 'M', 'r'),
+    (0x1D4E2, 'M', 's'),
+    (0x1D4E3, 'M', 't'),
+    (0x1D4E4, 'M', 'u'),
+    (0x1D4E5, 'M', 'v'),
+    (0x1D4E6, 'M', 'w'),
+    (0x1D4E7, 'M', 'x'),
+    (0x1D4E8, 'M', 'y'),
+    (0x1D4E9, 'M', 'z'),
+    (0x1D4EA, 'M', 'a'),
+    (0x1D4EB, 'M', 'b'),
+    (0x1D4EC, 'M', 'c'),
+    (0x1D4ED, 'M', 'd'),
+    (0x1D4EE, 'M', 'e'),
+    (0x1D4EF, 'M', 'f'),
+    (0x1D4F0, 'M', 'g'),
+    (0x1D4F1, 'M', 'h'),
+    (0x1D4F2, 'M', 'i'),
+    (0x1D4F3, 'M', 'j'),
+    (0x1D4F4, 'M', 'k'),
+    (0x1D4F5, 'M', 'l'),
+    (0x1D4F6, 'M', 'm'),
+    (0x1D4F7, 'M', 'n'),
+    (0x1D4F8, 'M', 'o'),
+    (0x1D4F9, 'M', 'p'),
+    (0x1D4FA, 'M', 'q'),
+    (0x1D4FB, 'M', 'r'),
+    ]
+
+def _seg_63() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D4FC, 'M', 's'),
+    (0x1D4FD, 'M', 't'),
+    (0x1D4FE, 'M', 'u'),
+    (0x1D4FF, 'M', 'v'),
+    (0x1D500, 'M', 'w'),
+    (0x1D501, 'M', 'x'),
+    (0x1D502, 'M', 'y'),
+    (0x1D503, 'M', 'z'),
+    (0x1D504, 'M', 'a'),
+    (0x1D505, 'M', 'b'),
+    (0x1D506, 'X'),
+    (0x1D507, 'M', 'd'),
+    (0x1D508, 'M', 'e'),
+    (0x1D509, 'M', 'f'),
+    (0x1D50A, 'M', 'g'),
+    (0x1D50B, 'X'),
+    (0x1D50D, 'M', 'j'),
+    (0x1D50E, 'M', 'k'),
+    (0x1D50F, 'M', 'l'),
+    (0x1D510, 'M', 'm'),
+    (0x1D511, 'M', 'n'),
+    (0x1D512, 'M', 'o'),
+    (0x1D513, 'M', 'p'),
+    (0x1D514, 'M', 'q'),
+    (0x1D515, 'X'),
+    (0x1D516, 'M', 's'),
+    (0x1D517, 'M', 't'),
+    (0x1D518, 'M', 'u'),
+    (0x1D519, 'M', 'v'),
+    (0x1D51A, 'M', 'w'),
+    (0x1D51B, 'M', 'x'),
+    (0x1D51C, 'M', 'y'),
+    (0x1D51D, 'X'),
+    (0x1D51E, 'M', 'a'),
+    (0x1D51F, 'M', 'b'),
+    (0x1D520, 'M', 'c'),
+    (0x1D521, 'M', 'd'),
+    (0x1D522, 'M', 'e'),
+    (0x1D523, 'M', 'f'),
+    (0x1D524, 'M', 'g'),
+    (0x1D525, 'M', 'h'),
+    (0x1D526, 'M', 'i'),
+    (0x1D527, 'M', 'j'),
+    (0x1D528, 'M', 'k'),
+    (0x1D529, 'M', 'l'),
+    (0x1D52A, 'M', 'm'),
+    (0x1D52B, 'M', 'n'),
+    (0x1D52C, 'M', 'o'),
+    (0x1D52D, 'M', 'p'),
+    (0x1D52E, 'M', 'q'),
+    (0x1D52F, 'M', 'r'),
+    (0x1D530, 'M', 's'),
+    (0x1D531, 'M', 't'),
+    (0x1D532, 'M', 'u'),
+    (0x1D533, 'M', 'v'),
+    (0x1D534, 'M', 'w'),
+    (0x1D535, 'M', 'x'),
+    (0x1D536, 'M', 'y'),
+    (0x1D537, 'M', 'z'),
+    (0x1D538, 'M', 'a'),
+    (0x1D539, 'M', 'b'),
+    (0x1D53A, 'X'),
+    (0x1D53B, 'M', 'd'),
+    (0x1D53C, 'M', 'e'),
+    (0x1D53D, 'M', 'f'),
+    (0x1D53E, 'M', 'g'),
+    (0x1D53F, 'X'),
+    (0x1D540, 'M', 'i'),
+    (0x1D541, 'M', 'j'),
+    (0x1D542, 'M', 'k'),
+    (0x1D543, 'M', 'l'),
+    (0x1D544, 'M', 'm'),
+    (0x1D545, 'X'),
+    (0x1D546, 'M', 'o'),
+    (0x1D547, 'X'),
+    (0x1D54A, 'M', 's'),
+    (0x1D54B, 'M', 't'),
+    (0x1D54C, 'M', 'u'),
+    (0x1D54D, 'M', 'v'),
+    (0x1D54E, 'M', 'w'),
+    (0x1D54F, 'M', 'x'),
+    (0x1D550, 'M', 'y'),
+    (0x1D551, 'X'),
+    (0x1D552, 'M', 'a'),
+    (0x1D553, 'M', 'b'),
+    (0x1D554, 'M', 'c'),
+    (0x1D555, 'M', 'd'),
+    (0x1D556, 'M', 'e'),
+    (0x1D557, 'M', 'f'),
+    (0x1D558, 'M', 'g'),
+    (0x1D559, 'M', 'h'),
+    (0x1D55A, 'M', 'i'),
+    (0x1D55B, 'M', 'j'),
+    (0x1D55C, 'M', 'k'),
+    (0x1D55D, 'M', 'l'),
+    (0x1D55E, 'M', 'm'),
+    (0x1D55F, 'M', 'n'),
+    (0x1D560, 'M', 'o'),
+    (0x1D561, 'M', 'p'),
+    (0x1D562, 'M', 'q'),
+    ]
+
+def _seg_64() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D563, 'M', 'r'),
+    (0x1D564, 'M', 's'),
+    (0x1D565, 'M', 't'),
+    (0x1D566, 'M', 'u'),
+    (0x1D567, 'M', 'v'),
+    (0x1D568, 'M', 'w'),
+    (0x1D569, 'M', 'x'),
+    (0x1D56A, 'M', 'y'),
+    (0x1D56B, 'M', 'z'),
+    (0x1D56C, 'M', 'a'),
+    (0x1D56D, 'M', 'b'),
+    (0x1D56E, 'M', 'c'),
+    (0x1D56F, 'M', 'd'),
+    (0x1D570, 'M', 'e'),
+    (0x1D571, 'M', 'f'),
+    (0x1D572, 'M', 'g'),
+    (0x1D573, 'M', 'h'),
+    (0x1D574, 'M', 'i'),
+    (0x1D575, 'M', 'j'),
+    (0x1D576, 'M', 'k'),
+    (0x1D577, 'M', 'l'),
+    (0x1D578, 'M', 'm'),
+    (0x1D579, 'M', 'n'),
+    (0x1D57A, 'M', 'o'),
+    (0x1D57B, 'M', 'p'),
+    (0x1D57C, 'M', 'q'),
+    (0x1D57D, 'M', 'r'),
+    (0x1D57E, 'M', 's'),
+    (0x1D57F, 'M', 't'),
+    (0x1D580, 'M', 'u'),
+    (0x1D581, 'M', 'v'),
+    (0x1D582, 'M', 'w'),
+    (0x1D583, 'M', 'x'),
+    (0x1D584, 'M', 'y'),
+    (0x1D585, 'M', 'z'),
+    (0x1D586, 'M', 'a'),
+    (0x1D587, 'M', 'b'),
+    (0x1D588, 'M', 'c'),
+    (0x1D589, 'M', 'd'),
+    (0x1D58A, 'M', 'e'),
+    (0x1D58B, 'M', 'f'),
+    (0x1D58C, 'M', 'g'),
+    (0x1D58D, 'M', 'h'),
+    (0x1D58E, 'M', 'i'),
+    (0x1D58F, 'M', 'j'),
+    (0x1D590, 'M', 'k'),
+    (0x1D591, 'M', 'l'),
+    (0x1D592, 'M', 'm'),
+    (0x1D593, 'M', 'n'),
+    (0x1D594, 'M', 'o'),
+    (0x1D595, 'M', 'p'),
+    (0x1D596, 'M', 'q'),
+    (0x1D597, 'M', 'r'),
+    (0x1D598, 'M', 's'),
+    (0x1D599, 'M', 't'),
+    (0x1D59A, 'M', 'u'),
+    (0x1D59B, 'M', 'v'),
+    (0x1D59C, 'M', 'w'),
+    (0x1D59D, 'M', 'x'),
+    (0x1D59E, 'M', 'y'),
+    (0x1D59F, 'M', 'z'),
+    (0x1D5A0, 'M', 'a'),
+    (0x1D5A1, 'M', 'b'),
+    (0x1D5A2, 'M', 'c'),
+    (0x1D5A3, 'M', 'd'),
+    (0x1D5A4, 'M', 'e'),
+    (0x1D5A5, 'M', 'f'),
+    (0x1D5A6, 'M', 'g'),
+    (0x1D5A7, 'M', 'h'),
+    (0x1D5A8, 'M', 'i'),
+    (0x1D5A9, 'M', 'j'),
+    (0x1D5AA, 'M', 'k'),
+    (0x1D5AB, 'M', 'l'),
+    (0x1D5AC, 'M', 'm'),
+    (0x1D5AD, 'M', 'n'),
+    (0x1D5AE, 'M', 'o'),
+    (0x1D5AF, 'M', 'p'),
+    (0x1D5B0, 'M', 'q'),
+    (0x1D5B1, 'M', 'r'),
+    (0x1D5B2, 'M', 's'),
+    (0x1D5B3, 'M', 't'),
+    (0x1D5B4, 'M', 'u'),
+    (0x1D5B5, 'M', 'v'),
+    (0x1D5B6, 'M', 'w'),
+    (0x1D5B7, 'M', 'x'),
+    (0x1D5B8, 'M', 'y'),
+    (0x1D5B9, 'M', 'z'),
+    (0x1D5BA, 'M', 'a'),
+    (0x1D5BB, 'M', 'b'),
+    (0x1D5BC, 'M', 'c'),
+    (0x1D5BD, 'M', 'd'),
+    (0x1D5BE, 'M', 'e'),
+    (0x1D5BF, 'M', 'f'),
+    (0x1D5C0, 'M', 'g'),
+    (0x1D5C1, 'M', 'h'),
+    (0x1D5C2, 'M', 'i'),
+    (0x1D5C3, 'M', 'j'),
+    (0x1D5C4, 'M', 'k'),
+    (0x1D5C5, 'M', 'l'),
+    (0x1D5C6, 'M', 'm'),
+    ]
+
+def _seg_65() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D5C7, 'M', 'n'),
+    (0x1D5C8, 'M', 'o'),
+    (0x1D5C9, 'M', 'p'),
+    (0x1D5CA, 'M', 'q'),
+    (0x1D5CB, 'M', 'r'),
+    (0x1D5CC, 'M', 's'),
+    (0x1D5CD, 'M', 't'),
+    (0x1D5CE, 'M', 'u'),
+    (0x1D5CF, 'M', 'v'),
+    (0x1D5D0, 'M', 'w'),
+    (0x1D5D1, 'M', 'x'),
+    (0x1D5D2, 'M', 'y'),
+    (0x1D5D3, 'M', 'z'),
+    (0x1D5D4, 'M', 'a'),
+    (0x1D5D5, 'M', 'b'),
+    (0x1D5D6, 'M', 'c'),
+    (0x1D5D7, 'M', 'd'),
+    (0x1D5D8, 'M', 'e'),
+    (0x1D5D9, 'M', 'f'),
+    (0x1D5DA, 'M', 'g'),
+    (0x1D5DB, 'M', 'h'),
+    (0x1D5DC, 'M', 'i'),
+    (0x1D5DD, 'M', 'j'),
+    (0x1D5DE, 'M', 'k'),
+    (0x1D5DF, 'M', 'l'),
+    (0x1D5E0, 'M', 'm'),
+    (0x1D5E1, 'M', 'n'),
+    (0x1D5E2, 'M', 'o'),
+    (0x1D5E3, 'M', 'p'),
+    (0x1D5E4, 'M', 'q'),
+    (0x1D5E5, 'M', 'r'),
+    (0x1D5E6, 'M', 's'),
+    (0x1D5E7, 'M', 't'),
+    (0x1D5E8, 'M', 'u'),
+    (0x1D5E9, 'M', 'v'),
+    (0x1D5EA, 'M', 'w'),
+    (0x1D5EB, 'M', 'x'),
+    (0x1D5EC, 'M', 'y'),
+    (0x1D5ED, 'M', 'z'),
+    (0x1D5EE, 'M', 'a'),
+    (0x1D5EF, 'M', 'b'),
+    (0x1D5F0, 'M', 'c'),
+    (0x1D5F1, 'M', 'd'),
+    (0x1D5F2, 'M', 'e'),
+    (0x1D5F3, 'M', 'f'),
+    (0x1D5F4, 'M', 'g'),
+    (0x1D5F5, 'M', 'h'),
+    (0x1D5F6, 'M', 'i'),
+    (0x1D5F7, 'M', 'j'),
+    (0x1D5F8, 'M', 'k'),
+    (0x1D5F9, 'M', 'l'),
+    (0x1D5FA, 'M', 'm'),
+    (0x1D5FB, 'M', 'n'),
+    (0x1D5FC, 'M', 'o'),
+    (0x1D5FD, 'M', 'p'),
+    (0x1D5FE, 'M', 'q'),
+    (0x1D5FF, 'M', 'r'),
+    (0x1D600, 'M', 's'),
+    (0x1D601, 'M', 't'),
+    (0x1D602, 'M', 'u'),
+    (0x1D603, 'M', 'v'),
+    (0x1D604, 'M', 'w'),
+    (0x1D605, 'M', 'x'),
+    (0x1D606, 'M', 'y'),
+    (0x1D607, 'M', 'z'),
+    (0x1D608, 'M', 'a'),
+    (0x1D609, 'M', 'b'),
+    (0x1D60A, 'M', 'c'),
+    (0x1D60B, 'M', 'd'),
+    (0x1D60C, 'M', 'e'),
+    (0x1D60D, 'M', 'f'),
+    (0x1D60E, 'M', 'g'),
+    (0x1D60F, 'M', 'h'),
+    (0x1D610, 'M', 'i'),
+    (0x1D611, 'M', 'j'),
+    (0x1D612, 'M', 'k'),
+    (0x1D613, 'M', 'l'),
+    (0x1D614, 'M', 'm'),
+    (0x1D615, 'M', 'n'),
+    (0x1D616, 'M', 'o'),
+    (0x1D617, 'M', 'p'),
+    (0x1D618, 'M', 'q'),
+    (0x1D619, 'M', 'r'),
+    (0x1D61A, 'M', 's'),
+    (0x1D61B, 'M', 't'),
+    (0x1D61C, 'M', 'u'),
+    (0x1D61D, 'M', 'v'),
+    (0x1D61E, 'M', 'w'),
+    (0x1D61F, 'M', 'x'),
+    (0x1D620, 'M', 'y'),
+    (0x1D621, 'M', 'z'),
+    (0x1D622, 'M', 'a'),
+    (0x1D623, 'M', 'b'),
+    (0x1D624, 'M', 'c'),
+    (0x1D625, 'M', 'd'),
+    (0x1D626, 'M', 'e'),
+    (0x1D627, 'M', 'f'),
+    (0x1D628, 'M', 'g'),
+    (0x1D629, 'M', 'h'),
+    (0x1D62A, 'M', 'i'),
+    ]
+
+def _seg_66() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D62B, 'M', 'j'),
+    (0x1D62C, 'M', 'k'),
+    (0x1D62D, 'M', 'l'),
+    (0x1D62E, 'M', 'm'),
+    (0x1D62F, 'M', 'n'),
+    (0x1D630, 'M', 'o'),
+    (0x1D631, 'M', 'p'),
+    (0x1D632, 'M', 'q'),
+    (0x1D633, 'M', 'r'),
+    (0x1D634, 'M', 's'),
+    (0x1D635, 'M', 't'),
+    (0x1D636, 'M', 'u'),
+    (0x1D637, 'M', 'v'),
+    (0x1D638, 'M', 'w'),
+    (0x1D639, 'M', 'x'),
+    (0x1D63A, 'M', 'y'),
+    (0x1D63B, 'M', 'z'),
+    (0x1D63C, 'M', 'a'),
+    (0x1D63D, 'M', 'b'),
+    (0x1D63E, 'M', 'c'),
+    (0x1D63F, 'M', 'd'),
+    (0x1D640, 'M', 'e'),
+    (0x1D641, 'M', 'f'),
+    (0x1D642, 'M', 'g'),
+    (0x1D643, 'M', 'h'),
+    (0x1D644, 'M', 'i'),
+    (0x1D645, 'M', 'j'),
+    (0x1D646, 'M', 'k'),
+    (0x1D647, 'M', 'l'),
+    (0x1D648, 'M', 'm'),
+    (0x1D649, 'M', 'n'),
+    (0x1D64A, 'M', 'o'),
+    (0x1D64B, 'M', 'p'),
+    (0x1D64C, 'M', 'q'),
+    (0x1D64D, 'M', 'r'),
+    (0x1D64E, 'M', 's'),
+    (0x1D64F, 'M', 't'),
+    (0x1D650, 'M', 'u'),
+    (0x1D651, 'M', 'v'),
+    (0x1D652, 'M', 'w'),
+    (0x1D653, 'M', 'x'),
+    (0x1D654, 'M', 'y'),
+    (0x1D655, 'M', 'z'),
+    (0x1D656, 'M', 'a'),
+    (0x1D657, 'M', 'b'),
+    (0x1D658, 'M', 'c'),
+    (0x1D659, 'M', 'd'),
+    (0x1D65A, 'M', 'e'),
+    (0x1D65B, 'M', 'f'),
+    (0x1D65C, 'M', 'g'),
+    (0x1D65D, 'M', 'h'),
+    (0x1D65E, 'M', 'i'),
+    (0x1D65F, 'M', 'j'),
+    (0x1D660, 'M', 'k'),
+    (0x1D661, 'M', 'l'),
+    (0x1D662, 'M', 'm'),
+    (0x1D663, 'M', 'n'),
+    (0x1D664, 'M', 'o'),
+    (0x1D665, 'M', 'p'),
+    (0x1D666, 'M', 'q'),
+    (0x1D667, 'M', 'r'),
+    (0x1D668, 'M', 's'),
+    (0x1D669, 'M', 't'),
+    (0x1D66A, 'M', 'u'),
+    (0x1D66B, 'M', 'v'),
+    (0x1D66C, 'M', 'w'),
+    (0x1D66D, 'M', 'x'),
+    (0x1D66E, 'M', 'y'),
+    (0x1D66F, 'M', 'z'),
+    (0x1D670, 'M', 'a'),
+    (0x1D671, 'M', 'b'),
+    (0x1D672, 'M', 'c'),
+    (0x1D673, 'M', 'd'),
+    (0x1D674, 'M', 'e'),
+    (0x1D675, 'M', 'f'),
+    (0x1D676, 'M', 'g'),
+    (0x1D677, 'M', 'h'),
+    (0x1D678, 'M', 'i'),
+    (0x1D679, 'M', 'j'),
+    (0x1D67A, 'M', 'k'),
+    (0x1D67B, 'M', 'l'),
+    (0x1D67C, 'M', 'm'),
+    (0x1D67D, 'M', 'n'),
+    (0x1D67E, 'M', 'o'),
+    (0x1D67F, 'M', 'p'),
+    (0x1D680, 'M', 'q'),
+    (0x1D681, 'M', 'r'),
+    (0x1D682, 'M', 's'),
+    (0x1D683, 'M', 't'),
+    (0x1D684, 'M', 'u'),
+    (0x1D685, 'M', 'v'),
+    (0x1D686, 'M', 'w'),
+    (0x1D687, 'M', 'x'),
+    (0x1D688, 'M', 'y'),
+    (0x1D689, 'M', 'z'),
+    (0x1D68A, 'M', 'a'),
+    (0x1D68B, 'M', 'b'),
+    (0x1D68C, 'M', 'c'),
+    (0x1D68D, 'M', 'd'),
+    (0x1D68E, 'M', 'e'),
+    ]
+
+def _seg_67() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D68F, 'M', 'f'),
+    (0x1D690, 'M', 'g'),
+    (0x1D691, 'M', 'h'),
+    (0x1D692, 'M', 'i'),
+    (0x1D693, 'M', 'j'),
+    (0x1D694, 'M', 'k'),
+    (0x1D695, 'M', 'l'),
+    (0x1D696, 'M', 'm'),
+    (0x1D697, 'M', 'n'),
+    (0x1D698, 'M', 'o'),
+    (0x1D699, 'M', 'p'),
+    (0x1D69A, 'M', 'q'),
+    (0x1D69B, 'M', 'r'),
+    (0x1D69C, 'M', 's'),
+    (0x1D69D, 'M', 't'),
+    (0x1D69E, 'M', 'u'),
+    (0x1D69F, 'M', 'v'),
+    (0x1D6A0, 'M', 'w'),
+    (0x1D6A1, 'M', 'x'),
+    (0x1D6A2, 'M', 'y'),
+    (0x1D6A3, 'M', 'z'),
+    (0x1D6A4, 'M', 'ı'),
+    (0x1D6A5, 'M', 'ȷ'),
+    (0x1D6A6, 'X'),
+    (0x1D6A8, 'M', 'α'),
+    (0x1D6A9, 'M', 'β'),
+    (0x1D6AA, 'M', 'γ'),
+    (0x1D6AB, 'M', 'δ'),
+    (0x1D6AC, 'M', 'ε'),
+    (0x1D6AD, 'M', 'ζ'),
+    (0x1D6AE, 'M', 'η'),
+    (0x1D6AF, 'M', 'θ'),
+    (0x1D6B0, 'M', 'ι'),
+    (0x1D6B1, 'M', 'κ'),
+    (0x1D6B2, 'M', 'λ'),
+    (0x1D6B3, 'M', 'μ'),
+    (0x1D6B4, 'M', 'ν'),
+    (0x1D6B5, 'M', 'ξ'),
+    (0x1D6B6, 'M', 'ο'),
+    (0x1D6B7, 'M', 'π'),
+    (0x1D6B8, 'M', 'ρ'),
+    (0x1D6B9, 'M', 'θ'),
+    (0x1D6BA, 'M', 'σ'),
+    (0x1D6BB, 'M', 'τ'),
+    (0x1D6BC, 'M', 'υ'),
+    (0x1D6BD, 'M', 'φ'),
+    (0x1D6BE, 'M', 'χ'),
+    (0x1D6BF, 'M', 'ψ'),
+    (0x1D6C0, 'M', 'ω'),
+    (0x1D6C1, 'M', '∇'),
+    (0x1D6C2, 'M', 'α'),
+    (0x1D6C3, 'M', 'β'),
+    (0x1D6C4, 'M', 'γ'),
+    (0x1D6C5, 'M', 'δ'),
+    (0x1D6C6, 'M', 'ε'),
+    (0x1D6C7, 'M', 'ζ'),
+    (0x1D6C8, 'M', 'η'),
+    (0x1D6C9, 'M', 'θ'),
+    (0x1D6CA, 'M', 'ι'),
+    (0x1D6CB, 'M', 'κ'),
+    (0x1D6CC, 'M', 'λ'),
+    (0x1D6CD, 'M', 'μ'),
+    (0x1D6CE, 'M', 'ν'),
+    (0x1D6CF, 'M', 'ξ'),
+    (0x1D6D0, 'M', 'ο'),
+    (0x1D6D1, 'M', 'π'),
+    (0x1D6D2, 'M', 'ρ'),
+    (0x1D6D3, 'M', 'σ'),
+    (0x1D6D5, 'M', 'τ'),
+    (0x1D6D6, 'M', 'υ'),
+    (0x1D6D7, 'M', 'φ'),
+    (0x1D6D8, 'M', 'χ'),
+    (0x1D6D9, 'M', 'ψ'),
+    (0x1D6DA, 'M', 'ω'),
+    (0x1D6DB, 'M', '∂'),
+    (0x1D6DC, 'M', 'ε'),
+    (0x1D6DD, 'M', 'θ'),
+    (0x1D6DE, 'M', 'κ'),
+    (0x1D6DF, 'M', 'φ'),
+    (0x1D6E0, 'M', 'ρ'),
+    (0x1D6E1, 'M', 'π'),
+    (0x1D6E2, 'M', 'α'),
+    (0x1D6E3, 'M', 'β'),
+    (0x1D6E4, 'M', 'γ'),
+    (0x1D6E5, 'M', 'δ'),
+    (0x1D6E6, 'M', 'ε'),
+    (0x1D6E7, 'M', 'ζ'),
+    (0x1D6E8, 'M', 'η'),
+    (0x1D6E9, 'M', 'θ'),
+    (0x1D6EA, 'M', 'ι'),
+    (0x1D6EB, 'M', 'κ'),
+    (0x1D6EC, 'M', 'λ'),
+    (0x1D6ED, 'M', 'μ'),
+    (0x1D6EE, 'M', 'ν'),
+    (0x1D6EF, 'M', 'ξ'),
+    (0x1D6F0, 'M', 'ο'),
+    (0x1D6F1, 'M', 'π'),
+    (0x1D6F2, 'M', 'ρ'),
+    (0x1D6F3, 'M', 'θ'),
+    (0x1D6F4, 'M', 'σ'),
+    ]
+
+def _seg_68() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D6F5, 'M', 'τ'),
+    (0x1D6F6, 'M', 'υ'),
+    (0x1D6F7, 'M', 'φ'),
+    (0x1D6F8, 'M', 'χ'),
+    (0x1D6F9, 'M', 'ψ'),
+    (0x1D6FA, 'M', 'ω'),
+    (0x1D6FB, 'M', '∇'),
+    (0x1D6FC, 'M', 'α'),
+    (0x1D6FD, 'M', 'β'),
+    (0x1D6FE, 'M', 'γ'),
+    (0x1D6FF, 'M', 'δ'),
+    (0x1D700, 'M', 'ε'),
+    (0x1D701, 'M', 'ζ'),
+    (0x1D702, 'M', 'η'),
+    (0x1D703, 'M', 'θ'),
+    (0x1D704, 'M', 'ι'),
+    (0x1D705, 'M', 'κ'),
+    (0x1D706, 'M', 'λ'),
+    (0x1D707, 'M', 'μ'),
+    (0x1D708, 'M', 'ν'),
+    (0x1D709, 'M', 'ξ'),
+    (0x1D70A, 'M', 'ο'),
+    (0x1D70B, 'M', 'π'),
+    (0x1D70C, 'M', 'ρ'),
+    (0x1D70D, 'M', 'σ'),
+    (0x1D70F, 'M', 'τ'),
+    (0x1D710, 'M', 'υ'),
+    (0x1D711, 'M', 'φ'),
+    (0x1D712, 'M', 'χ'),
+    (0x1D713, 'M', 'ψ'),
+    (0x1D714, 'M', 'ω'),
+    (0x1D715, 'M', '∂'),
+    (0x1D716, 'M', 'ε'),
+    (0x1D717, 'M', 'θ'),
+    (0x1D718, 'M', 'κ'),
+    (0x1D719, 'M', 'φ'),
+    (0x1D71A, 'M', 'ρ'),
+    (0x1D71B, 'M', 'π'),
+    (0x1D71C, 'M', 'α'),
+    (0x1D71D, 'M', 'β'),
+    (0x1D71E, 'M', 'γ'),
+    (0x1D71F, 'M', 'δ'),
+    (0x1D720, 'M', 'ε'),
+    (0x1D721, 'M', 'ζ'),
+    (0x1D722, 'M', 'η'),
+    (0x1D723, 'M', 'θ'),
+    (0x1D724, 'M', 'ι'),
+    (0x1D725, 'M', 'κ'),
+    (0x1D726, 'M', 'λ'),
+    (0x1D727, 'M', 'μ'),
+    (0x1D728, 'M', 'ν'),
+    (0x1D729, 'M', 'ξ'),
+    (0x1D72A, 'M', 'ο'),
+    (0x1D72B, 'M', 'π'),
+    (0x1D72C, 'M', 'ρ'),
+    (0x1D72D, 'M', 'θ'),
+    (0x1D72E, 'M', 'σ'),
+    (0x1D72F, 'M', 'τ'),
+    (0x1D730, 'M', 'υ'),
+    (0x1D731, 'M', 'φ'),
+    (0x1D732, 'M', 'χ'),
+    (0x1D733, 'M', 'ψ'),
+    (0x1D734, 'M', 'ω'),
+    (0x1D735, 'M', '∇'),
+    (0x1D736, 'M', 'α'),
+    (0x1D737, 'M', 'β'),
+    (0x1D738, 'M', 'γ'),
+    (0x1D739, 'M', 'δ'),
+    (0x1D73A, 'M', 'ε'),
+    (0x1D73B, 'M', 'ζ'),
+    (0x1D73C, 'M', 'η'),
+    (0x1D73D, 'M', 'θ'),
+    (0x1D73E, 'M', 'ι'),
+    (0x1D73F, 'M', 'κ'),
+    (0x1D740, 'M', 'λ'),
+    (0x1D741, 'M', 'μ'),
+    (0x1D742, 'M', 'ν'),
+    (0x1D743, 'M', 'ξ'),
+    (0x1D744, 'M', 'ο'),
+    (0x1D745, 'M', 'π'),
+    (0x1D746, 'M', 'ρ'),
+    (0x1D747, 'M', 'σ'),
+    (0x1D749, 'M', 'τ'),
+    (0x1D74A, 'M', 'υ'),
+    (0x1D74B, 'M', 'φ'),
+    (0x1D74C, 'M', 'χ'),
+    (0x1D74D, 'M', 'ψ'),
+    (0x1D74E, 'M', 'ω'),
+    (0x1D74F, 'M', '∂'),
+    (0x1D750, 'M', 'ε'),
+    (0x1D751, 'M', 'θ'),
+    (0x1D752, 'M', 'κ'),
+    (0x1D753, 'M', 'φ'),
+    (0x1D754, 'M', 'ρ'),
+    (0x1D755, 'M', 'π'),
+    (0x1D756, 'M', 'α'),
+    (0x1D757, 'M', 'β'),
+    (0x1D758, 'M', 'γ'),
+    (0x1D759, 'M', 'δ'),
+    (0x1D75A, 'M', 'ε'),
+    ]
+
+def _seg_69() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D75B, 'M', 'ζ'),
+    (0x1D75C, 'M', 'η'),
+    (0x1D75D, 'M', 'θ'),
+    (0x1D75E, 'M', 'ι'),
+    (0x1D75F, 'M', 'κ'),
+    (0x1D760, 'M', 'λ'),
+    (0x1D761, 'M', 'μ'),
+    (0x1D762, 'M', 'ν'),
+    (0x1D763, 'M', 'ξ'),
+    (0x1D764, 'M', 'ο'),
+    (0x1D765, 'M', 'π'),
+    (0x1D766, 'M', 'ρ'),
+    (0x1D767, 'M', 'θ'),
+    (0x1D768, 'M', 'σ'),
+    (0x1D769, 'M', 'τ'),
+    (0x1D76A, 'M', 'υ'),
+    (0x1D76B, 'M', 'φ'),
+    (0x1D76C, 'M', 'χ'),
+    (0x1D76D, 'M', 'ψ'),
+    (0x1D76E, 'M', 'ω'),
+    (0x1D76F, 'M', '∇'),
+    (0x1D770, 'M', 'α'),
+    (0x1D771, 'M', 'β'),
+    (0x1D772, 'M', 'γ'),
+    (0x1D773, 'M', 'δ'),
+    (0x1D774, 'M', 'ε'),
+    (0x1D775, 'M', 'ζ'),
+    (0x1D776, 'M', 'η'),
+    (0x1D777, 'M', 'θ'),
+    (0x1D778, 'M', 'ι'),
+    (0x1D779, 'M', 'κ'),
+    (0x1D77A, 'M', 'λ'),
+    (0x1D77B, 'M', 'μ'),
+    (0x1D77C, 'M', 'ν'),
+    (0x1D77D, 'M', 'ξ'),
+    (0x1D77E, 'M', 'ο'),
+    (0x1D77F, 'M', 'π'),
+    (0x1D780, 'M', 'ρ'),
+    (0x1D781, 'M', 'σ'),
+    (0x1D783, 'M', 'τ'),
+    (0x1D784, 'M', 'υ'),
+    (0x1D785, 'M', 'φ'),
+    (0x1D786, 'M', 'χ'),
+    (0x1D787, 'M', 'ψ'),
+    (0x1D788, 'M', 'ω'),
+    (0x1D789, 'M', '∂'),
+    (0x1D78A, 'M', 'ε'),
+    (0x1D78B, 'M', 'θ'),
+    (0x1D78C, 'M', 'κ'),
+    (0x1D78D, 'M', 'φ'),
+    (0x1D78E, 'M', 'ρ'),
+    (0x1D78F, 'M', 'π'),
+    (0x1D790, 'M', 'α'),
+    (0x1D791, 'M', 'β'),
+    (0x1D792, 'M', 'γ'),
+    (0x1D793, 'M', 'δ'),
+    (0x1D794, 'M', 'ε'),
+    (0x1D795, 'M', 'ζ'),
+    (0x1D796, 'M', 'η'),
+    (0x1D797, 'M', 'θ'),
+    (0x1D798, 'M', 'ι'),
+    (0x1D799, 'M', 'κ'),
+    (0x1D79A, 'M', 'λ'),
+    (0x1D79B, 'M', 'μ'),
+    (0x1D79C, 'M', 'ν'),
+    (0x1D79D, 'M', 'ξ'),
+    (0x1D79E, 'M', 'ο'),
+    (0x1D79F, 'M', 'π'),
+    (0x1D7A0, 'M', 'ρ'),
+    (0x1D7A1, 'M', 'θ'),
+    (0x1D7A2, 'M', 'σ'),
+    (0x1D7A3, 'M', 'τ'),
+    (0x1D7A4, 'M', 'υ'),
+    (0x1D7A5, 'M', 'φ'),
+    (0x1D7A6, 'M', 'χ'),
+    (0x1D7A7, 'M', 'ψ'),
+    (0x1D7A8, 'M', 'ω'),
+    (0x1D7A9, 'M', '∇'),
+    (0x1D7AA, 'M', 'α'),
+    (0x1D7AB, 'M', 'β'),
+    (0x1D7AC, 'M', 'γ'),
+    (0x1D7AD, 'M', 'δ'),
+    (0x1D7AE, 'M', 'ε'),
+    (0x1D7AF, 'M', 'ζ'),
+    (0x1D7B0, 'M', 'η'),
+    (0x1D7B1, 'M', 'θ'),
+    (0x1D7B2, 'M', 'ι'),
+    (0x1D7B3, 'M', 'κ'),
+    (0x1D7B4, 'M', 'λ'),
+    (0x1D7B5, 'M', 'μ'),
+    (0x1D7B6, 'M', 'ν'),
+    (0x1D7B7, 'M', 'ξ'),
+    (0x1D7B8, 'M', 'ο'),
+    (0x1D7B9, 'M', 'π'),
+    (0x1D7BA, 'M', 'ρ'),
+    (0x1D7BB, 'M', 'σ'),
+    (0x1D7BD, 'M', 'τ'),
+    (0x1D7BE, 'M', 'υ'),
+    (0x1D7BF, 'M', 'φ'),
+    (0x1D7C0, 'M', 'χ'),
+    ]
+
+def _seg_70() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D7C1, 'M', 'ψ'),
+    (0x1D7C2, 'M', 'ω'),
+    (0x1D7C3, 'M', '∂'),
+    (0x1D7C4, 'M', 'ε'),
+    (0x1D7C5, 'M', 'θ'),
+    (0x1D7C6, 'M', 'κ'),
+    (0x1D7C7, 'M', 'φ'),
+    (0x1D7C8, 'M', 'ρ'),
+    (0x1D7C9, 'M', 'π'),
+    (0x1D7CA, 'M', 'ϝ'),
+    (0x1D7CC, 'X'),
+    (0x1D7CE, 'M', '0'),
+    (0x1D7CF, 'M', '1'),
+    (0x1D7D0, 'M', '2'),
+    (0x1D7D1, 'M', '3'),
+    (0x1D7D2, 'M', '4'),
+    (0x1D7D3, 'M', '5'),
+    (0x1D7D4, 'M', '6'),
+    (0x1D7D5, 'M', '7'),
+    (0x1D7D6, 'M', '8'),
+    (0x1D7D7, 'M', '9'),
+    (0x1D7D8, 'M', '0'),
+    (0x1D7D9, 'M', '1'),
+    (0x1D7DA, 'M', '2'),
+    (0x1D7DB, 'M', '3'),
+    (0x1D7DC, 'M', '4'),
+    (0x1D7DD, 'M', '5'),
+    (0x1D7DE, 'M', '6'),
+    (0x1D7DF, 'M', '7'),
+    (0x1D7E0, 'M', '8'),
+    (0x1D7E1, 'M', '9'),
+    (0x1D7E2, 'M', '0'),
+    (0x1D7E3, 'M', '1'),
+    (0x1D7E4, 'M', '2'),
+    (0x1D7E5, 'M', '3'),
+    (0x1D7E6, 'M', '4'),
+    (0x1D7E7, 'M', '5'),
+    (0x1D7E8, 'M', '6'),
+    (0x1D7E9, 'M', '7'),
+    (0x1D7EA, 'M', '8'),
+    (0x1D7EB, 'M', '9'),
+    (0x1D7EC, 'M', '0'),
+    (0x1D7ED, 'M', '1'),
+    (0x1D7EE, 'M', '2'),
+    (0x1D7EF, 'M', '3'),
+    (0x1D7F0, 'M', '4'),
+    (0x1D7F1, 'M', '5'),
+    (0x1D7F2, 'M', '6'),
+    (0x1D7F3, 'M', '7'),
+    (0x1D7F4, 'M', '8'),
+    (0x1D7F5, 'M', '9'),
+    (0x1D7F6, 'M', '0'),
+    (0x1D7F7, 'M', '1'),
+    (0x1D7F8, 'M', '2'),
+    (0x1D7F9, 'M', '3'),
+    (0x1D7FA, 'M', '4'),
+    (0x1D7FB, 'M', '5'),
+    (0x1D7FC, 'M', '6'),
+    (0x1D7FD, 'M', '7'),
+    (0x1D7FE, 'M', '8'),
+    (0x1D7FF, 'M', '9'),
+    (0x1D800, 'V'),
+    (0x1DA8C, 'X'),
+    (0x1DA9B, 'V'),
+    (0x1DAA0, 'X'),
+    (0x1DAA1, 'V'),
+    (0x1DAB0, 'X'),
+    (0x1DF00, 'V'),
+    (0x1DF1F, 'X'),
+    (0x1E000, 'V'),
+    (0x1E007, 'X'),
+    (0x1E008, 'V'),
+    (0x1E019, 'X'),
+    (0x1E01B, 'V'),
+    (0x1E022, 'X'),
+    (0x1E023, 'V'),
+    (0x1E025, 'X'),
+    (0x1E026, 'V'),
+    (0x1E02B, 'X'),
+    (0x1E100, 'V'),
+    (0x1E12D, 'X'),
+    (0x1E130, 'V'),
+    (0x1E13E, 'X'),
+    (0x1E140, 'V'),
+    (0x1E14A, 'X'),
+    (0x1E14E, 'V'),
+    (0x1E150, 'X'),
+    (0x1E290, 'V'),
+    (0x1E2AF, 'X'),
+    (0x1E2C0, 'V'),
+    (0x1E2FA, 'X'),
+    (0x1E2FF, 'V'),
+    (0x1E300, 'X'),
+    (0x1E7E0, 'V'),
+    (0x1E7E7, 'X'),
+    (0x1E7E8, 'V'),
+    (0x1E7EC, 'X'),
+    (0x1E7ED, 'V'),
+    (0x1E7EF, 'X'),
+    (0x1E7F0, 'V'),
+    ]
+
+def _seg_71() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1E7FF, 'X'),
+    (0x1E800, 'V'),
+    (0x1E8C5, 'X'),
+    (0x1E8C7, 'V'),
+    (0x1E8D7, 'X'),
+    (0x1E900, 'M', '𞤢'),
+    (0x1E901, 'M', '𞤣'),
+    (0x1E902, 'M', '𞤤'),
+    (0x1E903, 'M', '𞤥'),
+    (0x1E904, 'M', '𞤦'),
+    (0x1E905, 'M', '𞤧'),
+    (0x1E906, 'M', '𞤨'),
+    (0x1E907, 'M', '𞤩'),
+    (0x1E908, 'M', '𞤪'),
+    (0x1E909, 'M', '𞤫'),
+    (0x1E90A, 'M', '𞤬'),
+    (0x1E90B, 'M', '𞤭'),
+    (0x1E90C, 'M', '𞤮'),
+    (0x1E90D, 'M', '𞤯'),
+    (0x1E90E, 'M', '𞤰'),
+    (0x1E90F, 'M', '𞤱'),
+    (0x1E910, 'M', '𞤲'),
+    (0x1E911, 'M', '𞤳'),
+    (0x1E912, 'M', '𞤴'),
+    (0x1E913, 'M', '𞤵'),
+    (0x1E914, 'M', '𞤶'),
+    (0x1E915, 'M', '𞤷'),
+    (0x1E916, 'M', '𞤸'),
+    (0x1E917, 'M', '𞤹'),
+    (0x1E918, 'M', '𞤺'),
+    (0x1E919, 'M', '𞤻'),
+    (0x1E91A, 'M', '𞤼'),
+    (0x1E91B, 'M', '𞤽'),
+    (0x1E91C, 'M', '𞤾'),
+    (0x1E91D, 'M', '𞤿'),
+    (0x1E91E, 'M', '𞥀'),
+    (0x1E91F, 'M', '𞥁'),
+    (0x1E920, 'M', '𞥂'),
+    (0x1E921, 'M', '𞥃'),
+    (0x1E922, 'V'),
+    (0x1E94C, 'X'),
+    (0x1E950, 'V'),
+    (0x1E95A, 'X'),
+    (0x1E95E, 'V'),
+    (0x1E960, 'X'),
+    (0x1EC71, 'V'),
+    (0x1ECB5, 'X'),
+    (0x1ED01, 'V'),
+    (0x1ED3E, 'X'),
+    (0x1EE00, 'M', 'ا'),
+    (0x1EE01, 'M', 'ب'),
+    (0x1EE02, 'M', 'ج'),
+    (0x1EE03, 'M', 'د'),
+    (0x1EE04, 'X'),
+    (0x1EE05, 'M', 'و'),
+    (0x1EE06, 'M', 'ز'),
+    (0x1EE07, 'M', 'ح'),
+    (0x1EE08, 'M', 'ط'),
+    (0x1EE09, 'M', 'ي'),
+    (0x1EE0A, 'M', 'ك'),
+    (0x1EE0B, 'M', 'ل'),
+    (0x1EE0C, 'M', 'م'),
+    (0x1EE0D, 'M', 'ن'),
+    (0x1EE0E, 'M', 'س'),
+    (0x1EE0F, 'M', 'ع'),
+    (0x1EE10, 'M', 'ف'),
+    (0x1EE11, 'M', 'ص'),
+    (0x1EE12, 'M', 'ق'),
+    (0x1EE13, 'M', 'ر'),
+    (0x1EE14, 'M', 'ش'),
+    (0x1EE15, 'M', 'ت'),
+    (0x1EE16, 'M', 'ث'),
+    (0x1EE17, 'M', 'خ'),
+    (0x1EE18, 'M', 'ذ'),
+    (0x1EE19, 'M', 'ض'),
+    (0x1EE1A, 'M', 'ظ'),
+    (0x1EE1B, 'M', 'غ'),
+    (0x1EE1C, 'M', 'ٮ'),
+    (0x1EE1D, 'M', 'ں'),
+    (0x1EE1E, 'M', 'ڡ'),
+    (0x1EE1F, 'M', 'ٯ'),
+    (0x1EE20, 'X'),
+    (0x1EE21, 'M', 'ب'),
+    (0x1EE22, 'M', 'ج'),
+    (0x1EE23, 'X'),
+    (0x1EE24, 'M', 'ه'),
+    (0x1EE25, 'X'),
+    (0x1EE27, 'M', 'ح'),
+    (0x1EE28, 'X'),
+    (0x1EE29, 'M', 'ي'),
+    (0x1EE2A, 'M', 'ك'),
+    (0x1EE2B, 'M', 'ل'),
+    (0x1EE2C, 'M', 'م'),
+    (0x1EE2D, 'M', 'ن'),
+    (0x1EE2E, 'M', 'س'),
+    (0x1EE2F, 'M', 'ع'),
+    (0x1EE30, 'M', 'ف'),
+    (0x1EE31, 'M', 'ص'),
+    (0x1EE32, 'M', 'ق'),
+    (0x1EE33, 'X'),
+    ]
+
+def _seg_72() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1EE34, 'M', 'ش'),
+    (0x1EE35, 'M', 'ت'),
+    (0x1EE36, 'M', 'ث'),
+    (0x1EE37, 'M', 'خ'),
+    (0x1EE38, 'X'),
+    (0x1EE39, 'M', 'ض'),
+    (0x1EE3A, 'X'),
+    (0x1EE3B, 'M', 'غ'),
+    (0x1EE3C, 'X'),
+    (0x1EE42, 'M', 'ج'),
+    (0x1EE43, 'X'),
+    (0x1EE47, 'M', 'ح'),
+    (0x1EE48, 'X'),
+    (0x1EE49, 'M', 'ي'),
+    (0x1EE4A, 'X'),
+    (0x1EE4B, 'M', 'ل'),
+    (0x1EE4C, 'X'),
+    (0x1EE4D, 'M', 'ن'),
+    (0x1EE4E, 'M', 'س'),
+    (0x1EE4F, 'M', 'ع'),
+    (0x1EE50, 'X'),
+    (0x1EE51, 'M', 'ص'),
+    (0x1EE52, 'M', 'ق'),
+    (0x1EE53, 'X'),
+    (0x1EE54, 'M', 'ش'),
+    (0x1EE55, 'X'),
+    (0x1EE57, 'M', 'خ'),
+    (0x1EE58, 'X'),
+    (0x1EE59, 'M', 'ض'),
+    (0x1EE5A, 'X'),
+    (0x1EE5B, 'M', 'غ'),
+    (0x1EE5C, 'X'),
+    (0x1EE5D, 'M', 'ں'),
+    (0x1EE5E, 'X'),
+    (0x1EE5F, 'M', 'ٯ'),
+    (0x1EE60, 'X'),
+    (0x1EE61, 'M', 'ب'),
+    (0x1EE62, 'M', 'ج'),
+    (0x1EE63, 'X'),
+    (0x1EE64, 'M', 'ه'),
+    (0x1EE65, 'X'),
+    (0x1EE67, 'M', 'ح'),
+    (0x1EE68, 'M', 'ط'),
+    (0x1EE69, 'M', 'ي'),
+    (0x1EE6A, 'M', 'ك'),
+    (0x1EE6B, 'X'),
+    (0x1EE6C, 'M', 'م'),
+    (0x1EE6D, 'M', 'ن'),
+    (0x1EE6E, 'M', 'س'),
+    (0x1EE6F, 'M', 'ع'),
+    (0x1EE70, 'M', 'ف'),
+    (0x1EE71, 'M', 'ص'),
+    (0x1EE72, 'M', 'ق'),
+    (0x1EE73, 'X'),
+    (0x1EE74, 'M', 'ش'),
+    (0x1EE75, 'M', 'ت'),
+    (0x1EE76, 'M', 'ث'),
+    (0x1EE77, 'M', 'خ'),
+    (0x1EE78, 'X'),
+    (0x1EE79, 'M', 'ض'),
+    (0x1EE7A, 'M', 'ظ'),
+    (0x1EE7B, 'M', 'غ'),
+    (0x1EE7C, 'M', 'ٮ'),
+    (0x1EE7D, 'X'),
+    (0x1EE7E, 'M', 'ڡ'),
+    (0x1EE7F, 'X'),
+    (0x1EE80, 'M', 'ا'),
+    (0x1EE81, 'M', 'ب'),
+    (0x1EE82, 'M', 'ج'),
+    (0x1EE83, 'M', 'د'),
+    (0x1EE84, 'M', 'ه'),
+    (0x1EE85, 'M', 'و'),
+    (0x1EE86, 'M', 'ز'),
+    (0x1EE87, 'M', 'ح'),
+    (0x1EE88, 'M', 'ط'),
+    (0x1EE89, 'M', 'ي'),
+    (0x1EE8A, 'X'),
+    (0x1EE8B, 'M', 'ل'),
+    (0x1EE8C, 'M', 'م'),
+    (0x1EE8D, 'M', 'ن'),
+    (0x1EE8E, 'M', 'س'),
+    (0x1EE8F, 'M', 'ع'),
+    (0x1EE90, 'M', 'ف'),
+    (0x1EE91, 'M', 'ص'),
+    (0x1EE92, 'M', 'ق'),
+    (0x1EE93, 'M', 'ر'),
+    (0x1EE94, 'M', 'ش'),
+    (0x1EE95, 'M', 'ت'),
+    (0x1EE96, 'M', 'ث'),
+    (0x1EE97, 'M', 'خ'),
+    (0x1EE98, 'M', 'ذ'),
+    (0x1EE99, 'M', 'ض'),
+    (0x1EE9A, 'M', 'ظ'),
+    (0x1EE9B, 'M', 'غ'),
+    (0x1EE9C, 'X'),
+    (0x1EEA1, 'M', 'ب'),
+    (0x1EEA2, 'M', 'ج'),
+    (0x1EEA3, 'M', 'د'),
+    (0x1EEA4, 'X'),
+    (0x1EEA5, 'M', 'و'),
+    ]
+
+def _seg_73() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1EEA6, 'M', 'ز'),
+    (0x1EEA7, 'M', 'ح'),
+    (0x1EEA8, 'M', 'ط'),
+    (0x1EEA9, 'M', 'ي'),
+    (0x1EEAA, 'X'),
+    (0x1EEAB, 'M', 'ل'),
+    (0x1EEAC, 'M', 'م'),
+    (0x1EEAD, 'M', 'ن'),
+    (0x1EEAE, 'M', 'س'),
+    (0x1EEAF, 'M', 'ع'),
+    (0x1EEB0, 'M', 'ف'),
+    (0x1EEB1, 'M', 'ص'),
+    (0x1EEB2, 'M', 'ق'),
+    (0x1EEB3, 'M', 'ر'),
+    (0x1EEB4, 'M', 'ش'),
+    (0x1EEB5, 'M', 'ت'),
+    (0x1EEB6, 'M', 'ث'),
+    (0x1EEB7, 'M', 'خ'),
+    (0x1EEB8, 'M', 'ذ'),
+    (0x1EEB9, 'M', 'ض'),
+    (0x1EEBA, 'M', 'ظ'),
+    (0x1EEBB, 'M', 'غ'),
+    (0x1EEBC, 'X'),
+    (0x1EEF0, 'V'),
+    (0x1EEF2, 'X'),
+    (0x1F000, 'V'),
+    (0x1F02C, 'X'),
+    (0x1F030, 'V'),
+    (0x1F094, 'X'),
+    (0x1F0A0, 'V'),
+    (0x1F0AF, 'X'),
+    (0x1F0B1, 'V'),
+    (0x1F0C0, 'X'),
+    (0x1F0C1, 'V'),
+    (0x1F0D0, 'X'),
+    (0x1F0D1, 'V'),
+    (0x1F0F6, 'X'),
+    (0x1F101, '3', '0,'),
+    (0x1F102, '3', '1,'),
+    (0x1F103, '3', '2,'),
+    (0x1F104, '3', '3,'),
+    (0x1F105, '3', '4,'),
+    (0x1F106, '3', '5,'),
+    (0x1F107, '3', '6,'),
+    (0x1F108, '3', '7,'),
+    (0x1F109, '3', '8,'),
+    (0x1F10A, '3', '9,'),
+    (0x1F10B, 'V'),
+    (0x1F110, '3', '(a)'),
+    (0x1F111, '3', '(b)'),
+    (0x1F112, '3', '(c)'),
+    (0x1F113, '3', '(d)'),
+    (0x1F114, '3', '(e)'),
+    (0x1F115, '3', '(f)'),
+    (0x1F116, '3', '(g)'),
+    (0x1F117, '3', '(h)'),
+    (0x1F118, '3', '(i)'),
+    (0x1F119, '3', '(j)'),
+    (0x1F11A, '3', '(k)'),
+    (0x1F11B, '3', '(l)'),
+    (0x1F11C, '3', '(m)'),
+    (0x1F11D, '3', '(n)'),
+    (0x1F11E, '3', '(o)'),
+    (0x1F11F, '3', '(p)'),
+    (0x1F120, '3', '(q)'),
+    (0x1F121, '3', '(r)'),
+    (0x1F122, '3', '(s)'),
+    (0x1F123, '3', '(t)'),
+    (0x1F124, '3', '(u)'),
+    (0x1F125, '3', '(v)'),
+    (0x1F126, '3', '(w)'),
+    (0x1F127, '3', '(x)'),
+    (0x1F128, '3', '(y)'),
+    (0x1F129, '3', '(z)'),
+    (0x1F12A, 'M', '〔s〕'),
+    (0x1F12B, 'M', 'c'),
+    (0x1F12C, 'M', 'r'),
+    (0x1F12D, 'M', 'cd'),
+    (0x1F12E, 'M', 'wz'),
+    (0x1F12F, 'V'),
+    (0x1F130, 'M', 'a'),
+    (0x1F131, 'M', 'b'),
+    (0x1F132, 'M', 'c'),
+    (0x1F133, 'M', 'd'),
+    (0x1F134, 'M', 'e'),
+    (0x1F135, 'M', 'f'),
+    (0x1F136, 'M', 'g'),
+    (0x1F137, 'M', 'h'),
+    (0x1F138, 'M', 'i'),
+    (0x1F139, 'M', 'j'),
+    (0x1F13A, 'M', 'k'),
+    (0x1F13B, 'M', 'l'),
+    (0x1F13C, 'M', 'm'),
+    (0x1F13D, 'M', 'n'),
+    (0x1F13E, 'M', 'o'),
+    (0x1F13F, 'M', 'p'),
+    (0x1F140, 'M', 'q'),
+    (0x1F141, 'M', 'r'),
+    (0x1F142, 'M', 's'),
+    (0x1F143, 'M', 't'),
+    ]
+
+def _seg_74() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1F144, 'M', 'u'),
+    (0x1F145, 'M', 'v'),
+    (0x1F146, 'M', 'w'),
+    (0x1F147, 'M', 'x'),
+    (0x1F148, 'M', 'y'),
+    (0x1F149, 'M', 'z'),
+    (0x1F14A, 'M', 'hv'),
+    (0x1F14B, 'M', 'mv'),
+    (0x1F14C, 'M', 'sd'),
+    (0x1F14D, 'M', 'ss'),
+    (0x1F14E, 'M', 'ppv'),
+    (0x1F14F, 'M', 'wc'),
+    (0x1F150, 'V'),
+    (0x1F16A, 'M', 'mc'),
+    (0x1F16B, 'M', 'md'),
+    (0x1F16C, 'M', 'mr'),
+    (0x1F16D, 'V'),
+    (0x1F190, 'M', 'dj'),
+    (0x1F191, 'V'),
+    (0x1F1AE, 'X'),
+    (0x1F1E6, 'V'),
+    (0x1F200, 'M', 'ほか'),
+    (0x1F201, 'M', 'ココ'),
+    (0x1F202, 'M', 'サ'),
+    (0x1F203, 'X'),
+    (0x1F210, 'M', '手'),
+    (0x1F211, 'M', '字'),
+    (0x1F212, 'M', '双'),
+    (0x1F213, 'M', 'デ'),
+    (0x1F214, 'M', '二'),
+    (0x1F215, 'M', '多'),
+    (0x1F216, 'M', '解'),
+    (0x1F217, 'M', '天'),
+    (0x1F218, 'M', '交'),
+    (0x1F219, 'M', '映'),
+    (0x1F21A, 'M', '無'),
+    (0x1F21B, 'M', '料'),
+    (0x1F21C, 'M', '前'),
+    (0x1F21D, 'M', '後'),
+    (0x1F21E, 'M', '再'),
+    (0x1F21F, 'M', '新'),
+    (0x1F220, 'M', '初'),
+    (0x1F221, 'M', '終'),
+    (0x1F222, 'M', '生'),
+    (0x1F223, 'M', '販'),
+    (0x1F224, 'M', '声'),
+    (0x1F225, 'M', '吹'),
+    (0x1F226, 'M', '演'),
+    (0x1F227, 'M', '投'),
+    (0x1F228, 'M', '捕'),
+    (0x1F229, 'M', '一'),
+    (0x1F22A, 'M', '三'),
+    (0x1F22B, 'M', '遊'),
+    (0x1F22C, 'M', '左'),
+    (0x1F22D, 'M', '中'),
+    (0x1F22E, 'M', '右'),
+    (0x1F22F, 'M', '指'),
+    (0x1F230, 'M', '走'),
+    (0x1F231, 'M', '打'),
+    (0x1F232, 'M', '禁'),
+    (0x1F233, 'M', '空'),
+    (0x1F234, 'M', '合'),
+    (0x1F235, 'M', '満'),
+    (0x1F236, 'M', '有'),
+    (0x1F237, 'M', '月'),
+    (0x1F238, 'M', '申'),
+    (0x1F239, 'M', '割'),
+    (0x1F23A, 'M', '営'),
+    (0x1F23B, 'M', '配'),
+    (0x1F23C, 'X'),
+    (0x1F240, 'M', '〔本〕'),
+    (0x1F241, 'M', '〔三〕'),
+    (0x1F242, 'M', '〔二〕'),
+    (0x1F243, 'M', '〔安〕'),
+    (0x1F244, 'M', '〔点〕'),
+    (0x1F245, 'M', '〔打〕'),
+    (0x1F246, 'M', '〔盗〕'),
+    (0x1F247, 'M', '〔勝〕'),
+    (0x1F248, 'M', '〔敗〕'),
+    (0x1F249, 'X'),
+    (0x1F250, 'M', '得'),
+    (0x1F251, 'M', '可'),
+    (0x1F252, 'X'),
+    (0x1F260, 'V'),
+    (0x1F266, 'X'),
+    (0x1F300, 'V'),
+    (0x1F6D8, 'X'),
+    (0x1F6DD, 'V'),
+    (0x1F6ED, 'X'),
+    (0x1F6F0, 'V'),
+    (0x1F6FD, 'X'),
+    (0x1F700, 'V'),
+    (0x1F774, 'X'),
+    (0x1F780, 'V'),
+    (0x1F7D9, 'X'),
+    (0x1F7E0, 'V'),
+    (0x1F7EC, 'X'),
+    (0x1F7F0, 'V'),
+    (0x1F7F1, 'X'),
+    (0x1F800, 'V'),
+    ]
+
+def _seg_75() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1F80C, 'X'),
+    (0x1F810, 'V'),
+    (0x1F848, 'X'),
+    (0x1F850, 'V'),
+    (0x1F85A, 'X'),
+    (0x1F860, 'V'),
+    (0x1F888, 'X'),
+    (0x1F890, 'V'),
+    (0x1F8AE, 'X'),
+    (0x1F8B0, 'V'),
+    (0x1F8B2, 'X'),
+    (0x1F900, 'V'),
+    (0x1FA54, 'X'),
+    (0x1FA60, 'V'),
+    (0x1FA6E, 'X'),
+    (0x1FA70, 'V'),
+    (0x1FA75, 'X'),
+    (0x1FA78, 'V'),
+    (0x1FA7D, 'X'),
+    (0x1FA80, 'V'),
+    (0x1FA87, 'X'),
+    (0x1FA90, 'V'),
+    (0x1FAAD, 'X'),
+    (0x1FAB0, 'V'),
+    (0x1FABB, 'X'),
+    (0x1FAC0, 'V'),
+    (0x1FAC6, 'X'),
+    (0x1FAD0, 'V'),
+    (0x1FADA, 'X'),
+    (0x1FAE0, 'V'),
+    (0x1FAE8, 'X'),
+    (0x1FAF0, 'V'),
+    (0x1FAF7, 'X'),
+    (0x1FB00, 'V'),
+    (0x1FB93, 'X'),
+    (0x1FB94, 'V'),
+    (0x1FBCB, 'X'),
+    (0x1FBF0, 'M', '0'),
+    (0x1FBF1, 'M', '1'),
+    (0x1FBF2, 'M', '2'),
+    (0x1FBF3, 'M', '3'),
+    (0x1FBF4, 'M', '4'),
+    (0x1FBF5, 'M', '5'),
+    (0x1FBF6, 'M', '6'),
+    (0x1FBF7, 'M', '7'),
+    (0x1FBF8, 'M', '8'),
+    (0x1FBF9, 'M', '9'),
+    (0x1FBFA, 'X'),
+    (0x20000, 'V'),
+    (0x2A6E0, 'X'),
+    (0x2A700, 'V'),
+    (0x2B739, 'X'),
+    (0x2B740, 'V'),
+    (0x2B81E, 'X'),
+    (0x2B820, 'V'),
+    (0x2CEA2, 'X'),
+    (0x2CEB0, 'V'),
+    (0x2EBE1, 'X'),
+    (0x2F800, 'M', '丽'),
+    (0x2F801, 'M', '丸'),
+    (0x2F802, 'M', '乁'),
+    (0x2F803, 'M', '𠄢'),
+    (0x2F804, 'M', '你'),
+    (0x2F805, 'M', '侮'),
+    (0x2F806, 'M', '侻'),
+    (0x2F807, 'M', '倂'),
+    (0x2F808, 'M', '偺'),
+    (0x2F809, 'M', '備'),
+    (0x2F80A, 'M', '僧'),
+    (0x2F80B, 'M', '像'),
+    (0x2F80C, 'M', '㒞'),
+    (0x2F80D, 'M', '𠘺'),
+    (0x2F80E, 'M', '免'),
+    (0x2F80F, 'M', '兔'),
+    (0x2F810, 'M', '兤'),
+    (0x2F811, 'M', '具'),
+    (0x2F812, 'M', '𠔜'),
+    (0x2F813, 'M', '㒹'),
+    (0x2F814, 'M', '內'),
+    (0x2F815, 'M', '再'),
+    (0x2F816, 'M', '𠕋'),
+    (0x2F817, 'M', '冗'),
+    (0x2F818, 'M', '冤'),
+    (0x2F819, 'M', '仌'),
+    (0x2F81A, 'M', '冬'),
+    (0x2F81B, 'M', '况'),
+    (0x2F81C, 'M', '𩇟'),
+    (0x2F81D, 'M', '凵'),
+    (0x2F81E, 'M', '刃'),
+    (0x2F81F, 'M', '㓟'),
+    (0x2F820, 'M', '刻'),
+    (0x2F821, 'M', '剆'),
+    (0x2F822, 'M', '割'),
+    (0x2F823, 'M', '剷'),
+    (0x2F824, 'M', '㔕'),
+    (0x2F825, 'M', '勇'),
+    (0x2F826, 'M', '勉'),
+    (0x2F827, 'M', '勤'),
+    (0x2F828, 'M', '勺'),
+    (0x2F829, 'M', '包'),
+    ]
+
+def _seg_76() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F82A, 'M', '匆'),
+    (0x2F82B, 'M', '北'),
+    (0x2F82C, 'M', '卉'),
+    (0x2F82D, 'M', '卑'),
+    (0x2F82E, 'M', '博'),
+    (0x2F82F, 'M', '即'),
+    (0x2F830, 'M', '卽'),
+    (0x2F831, 'M', '卿'),
+    (0x2F834, 'M', '𠨬'),
+    (0x2F835, 'M', '灰'),
+    (0x2F836, 'M', '及'),
+    (0x2F837, 'M', '叟'),
+    (0x2F838, 'M', '𠭣'),
+    (0x2F839, 'M', '叫'),
+    (0x2F83A, 'M', '叱'),
+    (0x2F83B, 'M', '吆'),
+    (0x2F83C, 'M', '咞'),
+    (0x2F83D, 'M', '吸'),
+    (0x2F83E, 'M', '呈'),
+    (0x2F83F, 'M', '周'),
+    (0x2F840, 'M', '咢'),
+    (0x2F841, 'M', '哶'),
+    (0x2F842, 'M', '唐'),
+    (0x2F843, 'M', '啓'),
+    (0x2F844, 'M', '啣'),
+    (0x2F845, 'M', '善'),
+    (0x2F847, 'M', '喙'),
+    (0x2F848, 'M', '喫'),
+    (0x2F849, 'M', '喳'),
+    (0x2F84A, 'M', '嗂'),
+    (0x2F84B, 'M', '圖'),
+    (0x2F84C, 'M', '嘆'),
+    (0x2F84D, 'M', '圗'),
+    (0x2F84E, 'M', '噑'),
+    (0x2F84F, 'M', '噴'),
+    (0x2F850, 'M', '切'),
+    (0x2F851, 'M', '壮'),
+    (0x2F852, 'M', '城'),
+    (0x2F853, 'M', '埴'),
+    (0x2F854, 'M', '堍'),
+    (0x2F855, 'M', '型'),
+    (0x2F856, 'M', '堲'),
+    (0x2F857, 'M', '報'),
+    (0x2F858, 'M', '墬'),
+    (0x2F859, 'M', '𡓤'),
+    (0x2F85A, 'M', '売'),
+    (0x2F85B, 'M', '壷'),
+    (0x2F85C, 'M', '夆'),
+    (0x2F85D, 'M', '多'),
+    (0x2F85E, 'M', '夢'),
+    (0x2F85F, 'M', '奢'),
+    (0x2F860, 'M', '𡚨'),
+    (0x2F861, 'M', '𡛪'),
+    (0x2F862, 'M', '姬'),
+    (0x2F863, 'M', '娛'),
+    (0x2F864, 'M', '娧'),
+    (0x2F865, 'M', '姘'),
+    (0x2F866, 'M', '婦'),
+    (0x2F867, 'M', '㛮'),
+    (0x2F868, 'X'),
+    (0x2F869, 'M', '嬈'),
+    (0x2F86A, 'M', '嬾'),
+    (0x2F86C, 'M', '𡧈'),
+    (0x2F86D, 'M', '寃'),
+    (0x2F86E, 'M', '寘'),
+    (0x2F86F, 'M', '寧'),
+    (0x2F870, 'M', '寳'),
+    (0x2F871, 'M', '𡬘'),
+    (0x2F872, 'M', '寿'),
+    (0x2F873, 'M', '将'),
+    (0x2F874, 'X'),
+    (0x2F875, 'M', '尢'),
+    (0x2F876, 'M', '㞁'),
+    (0x2F877, 'M', '屠'),
+    (0x2F878, 'M', '屮'),
+    (0x2F879, 'M', '峀'),
+    (0x2F87A, 'M', '岍'),
+    (0x2F87B, 'M', '𡷤'),
+    (0x2F87C, 'M', '嵃'),
+    (0x2F87D, 'M', '𡷦'),
+    (0x2F87E, 'M', '嵮'),
+    (0x2F87F, 'M', '嵫'),
+    (0x2F880, 'M', '嵼'),
+    (0x2F881, 'M', '巡'),
+    (0x2F882, 'M', '巢'),
+    (0x2F883, 'M', '㠯'),
+    (0x2F884, 'M', '巽'),
+    (0x2F885, 'M', '帨'),
+    (0x2F886, 'M', '帽'),
+    (0x2F887, 'M', '幩'),
+    (0x2F888, 'M', '㡢'),
+    (0x2F889, 'M', '𢆃'),
+    (0x2F88A, 'M', '㡼'),
+    (0x2F88B, 'M', '庰'),
+    (0x2F88C, 'M', '庳'),
+    (0x2F88D, 'M', '庶'),
+    (0x2F88E, 'M', '廊'),
+    (0x2F88F, 'M', '𪎒'),
+    (0x2F890, 'M', '廾'),
+    (0x2F891, 'M', '𢌱'),
+    ]
+
+def _seg_77() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F893, 'M', '舁'),
+    (0x2F894, 'M', '弢'),
+    (0x2F896, 'M', '㣇'),
+    (0x2F897, 'M', '𣊸'),
+    (0x2F898, 'M', '𦇚'),
+    (0x2F899, 'M', '形'),
+    (0x2F89A, 'M', '彫'),
+    (0x2F89B, 'M', '㣣'),
+    (0x2F89C, 'M', '徚'),
+    (0x2F89D, 'M', '忍'),
+    (0x2F89E, 'M', '志'),
+    (0x2F89F, 'M', '忹'),
+    (0x2F8A0, 'M', '悁'),
+    (0x2F8A1, 'M', '㤺'),
+    (0x2F8A2, 'M', '㤜'),
+    (0x2F8A3, 'M', '悔'),
+    (0x2F8A4, 'M', '𢛔'),
+    (0x2F8A5, 'M', '惇'),
+    (0x2F8A6, 'M', '慈'),
+    (0x2F8A7, 'M', '慌'),
+    (0x2F8A8, 'M', '慎'),
+    (0x2F8A9, 'M', '慌'),
+    (0x2F8AA, 'M', '慺'),
+    (0x2F8AB, 'M', '憎'),
+    (0x2F8AC, 'M', '憲'),
+    (0x2F8AD, 'M', '憤'),
+    (0x2F8AE, 'M', '憯'),
+    (0x2F8AF, 'M', '懞'),
+    (0x2F8B0, 'M', '懲'),
+    (0x2F8B1, 'M', '懶'),
+    (0x2F8B2, 'M', '成'),
+    (0x2F8B3, 'M', '戛'),
+    (0x2F8B4, 'M', '扝'),
+    (0x2F8B5, 'M', '抱'),
+    (0x2F8B6, 'M', '拔'),
+    (0x2F8B7, 'M', '捐'),
+    (0x2F8B8, 'M', '𢬌'),
+    (0x2F8B9, 'M', '挽'),
+    (0x2F8BA, 'M', '拼'),
+    (0x2F8BB, 'M', '捨'),
+    (0x2F8BC, 'M', '掃'),
+    (0x2F8BD, 'M', '揤'),
+    (0x2F8BE, 'M', '𢯱'),
+    (0x2F8BF, 'M', '搢'),
+    (0x2F8C0, 'M', '揅'),
+    (0x2F8C1, 'M', '掩'),
+    (0x2F8C2, 'M', '㨮'),
+    (0x2F8C3, 'M', '摩'),
+    (0x2F8C4, 'M', '摾'),
+    (0x2F8C5, 'M', '撝'),
+    (0x2F8C6, 'M', '摷'),
+    (0x2F8C7, 'M', '㩬'),
+    (0x2F8C8, 'M', '敏'),
+    (0x2F8C9, 'M', '敬'),
+    (0x2F8CA, 'M', '𣀊'),
+    (0x2F8CB, 'M', '旣'),
+    (0x2F8CC, 'M', '書'),
+    (0x2F8CD, 'M', '晉'),
+    (0x2F8CE, 'M', '㬙'),
+    (0x2F8CF, 'M', '暑'),
+    (0x2F8D0, 'M', '㬈'),
+    (0x2F8D1, 'M', '㫤'),
+    (0x2F8D2, 'M', '冒'),
+    (0x2F8D3, 'M', '冕'),
+    (0x2F8D4, 'M', '最'),
+    (0x2F8D5, 'M', '暜'),
+    (0x2F8D6, 'M', '肭'),
+    (0x2F8D7, 'M', '䏙'),
+    (0x2F8D8, 'M', '朗'),
+    (0x2F8D9, 'M', '望'),
+    (0x2F8DA, 'M', '朡'),
+    (0x2F8DB, 'M', '杞'),
+    (0x2F8DC, 'M', '杓'),
+    (0x2F8DD, 'M', '𣏃'),
+    (0x2F8DE, 'M', '㭉'),
+    (0x2F8DF, 'M', '柺'),
+    (0x2F8E0, 'M', '枅'),
+    (0x2F8E1, 'M', '桒'),
+    (0x2F8E2, 'M', '梅'),
+    (0x2F8E3, 'M', '𣑭'),
+    (0x2F8E4, 'M', '梎'),
+    (0x2F8E5, 'M', '栟'),
+    (0x2F8E6, 'M', '椔'),
+    (0x2F8E7, 'M', '㮝'),
+    (0x2F8E8, 'M', '楂'),
+    (0x2F8E9, 'M', '榣'),
+    (0x2F8EA, 'M', '槪'),
+    (0x2F8EB, 'M', '檨'),
+    (0x2F8EC, 'M', '𣚣'),
+    (0x2F8ED, 'M', '櫛'),
+    (0x2F8EE, 'M', '㰘'),
+    (0x2F8EF, 'M', '次'),
+    (0x2F8F0, 'M', '𣢧'),
+    (0x2F8F1, 'M', '歔'),
+    (0x2F8F2, 'M', '㱎'),
+    (0x2F8F3, 'M', '歲'),
+    (0x2F8F4, 'M', '殟'),
+    (0x2F8F5, 'M', '殺'),
+    (0x2F8F6, 'M', '殻'),
+    (0x2F8F7, 'M', '𣪍'),
+    ]
+
+def _seg_78() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F8F8, 'M', '𡴋'),
+    (0x2F8F9, 'M', '𣫺'),
+    (0x2F8FA, 'M', '汎'),
+    (0x2F8FB, 'M', '𣲼'),
+    (0x2F8FC, 'M', '沿'),
+    (0x2F8FD, 'M', '泍'),
+    (0x2F8FE, 'M', '汧'),
+    (0x2F8FF, 'M', '洖'),
+    (0x2F900, 'M', '派'),
+    (0x2F901, 'M', '海'),
+    (0x2F902, 'M', '流'),
+    (0x2F903, 'M', '浩'),
+    (0x2F904, 'M', '浸'),
+    (0x2F905, 'M', '涅'),
+    (0x2F906, 'M', '𣴞'),
+    (0x2F907, 'M', '洴'),
+    (0x2F908, 'M', '港'),
+    (0x2F909, 'M', '湮'),
+    (0x2F90A, 'M', '㴳'),
+    (0x2F90B, 'M', '滋'),
+    (0x2F90C, 'M', '滇'),
+    (0x2F90D, 'M', '𣻑'),
+    (0x2F90E, 'M', '淹'),
+    (0x2F90F, 'M', '潮'),
+    (0x2F910, 'M', '𣽞'),
+    (0x2F911, 'M', '𣾎'),
+    (0x2F912, 'M', '濆'),
+    (0x2F913, 'M', '瀹'),
+    (0x2F914, 'M', '瀞'),
+    (0x2F915, 'M', '瀛'),
+    (0x2F916, 'M', '㶖'),
+    (0x2F917, 'M', '灊'),
+    (0x2F918, 'M', '災'),
+    (0x2F919, 'M', '灷'),
+    (0x2F91A, 'M', '炭'),
+    (0x2F91B, 'M', '𠔥'),
+    (0x2F91C, 'M', '煅'),
+    (0x2F91D, 'M', '𤉣'),
+    (0x2F91E, 'M', '熜'),
+    (0x2F91F, 'X'),
+    (0x2F920, 'M', '爨'),
+    (0x2F921, 'M', '爵'),
+    (0x2F922, 'M', '牐'),
+    (0x2F923, 'M', '𤘈'),
+    (0x2F924, 'M', '犀'),
+    (0x2F925, 'M', '犕'),
+    (0x2F926, 'M', '𤜵'),
+    (0x2F927, 'M', '𤠔'),
+    (0x2F928, 'M', '獺'),
+    (0x2F929, 'M', '王'),
+    (0x2F92A, 'M', '㺬'),
+    (0x2F92B, 'M', '玥'),
+    (0x2F92C, 'M', '㺸'),
+    (0x2F92E, 'M', '瑇'),
+    (0x2F92F, 'M', '瑜'),
+    (0x2F930, 'M', '瑱'),
+    (0x2F931, 'M', '璅'),
+    (0x2F932, 'M', '瓊'),
+    (0x2F933, 'M', '㼛'),
+    (0x2F934, 'M', '甤'),
+    (0x2F935, 'M', '𤰶'),
+    (0x2F936, 'M', '甾'),
+    (0x2F937, 'M', '𤲒'),
+    (0x2F938, 'M', '異'),
+    (0x2F939, 'M', '𢆟'),
+    (0x2F93A, 'M', '瘐'),
+    (0x2F93B, 'M', '𤾡'),
+    (0x2F93C, 'M', '𤾸'),
+    (0x2F93D, 'M', '𥁄'),
+    (0x2F93E, 'M', '㿼'),
+    (0x2F93F, 'M', '䀈'),
+    (0x2F940, 'M', '直'),
+    (0x2F941, 'M', '𥃳'),
+    (0x2F942, 'M', '𥃲'),
+    (0x2F943, 'M', '𥄙'),
+    (0x2F944, 'M', '𥄳'),
+    (0x2F945, 'M', '眞'),
+    (0x2F946, 'M', '真'),
+    (0x2F948, 'M', '睊'),
+    (0x2F949, 'M', '䀹'),
+    (0x2F94A, 'M', '瞋'),
+    (0x2F94B, 'M', '䁆'),
+    (0x2F94C, 'M', '䂖'),
+    (0x2F94D, 'M', '𥐝'),
+    (0x2F94E, 'M', '硎'),
+    (0x2F94F, 'M', '碌'),
+    (0x2F950, 'M', '磌'),
+    (0x2F951, 'M', '䃣'),
+    (0x2F952, 'M', '𥘦'),
+    (0x2F953, 'M', '祖'),
+    (0x2F954, 'M', '𥚚'),
+    (0x2F955, 'M', '𥛅'),
+    (0x2F956, 'M', '福'),
+    (0x2F957, 'M', '秫'),
+    (0x2F958, 'M', '䄯'),
+    (0x2F959, 'M', '穀'),
+    (0x2F95A, 'M', '穊'),
+    (0x2F95B, 'M', '穏'),
+    (0x2F95C, 'M', '𥥼'),
+    (0x2F95D, 'M', '𥪧'),
+    ]
+
+def _seg_79() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F95F, 'X'),
+    (0x2F960, 'M', '䈂'),
+    (0x2F961, 'M', '𥮫'),
+    (0x2F962, 'M', '篆'),
+    (0x2F963, 'M', '築'),
+    (0x2F964, 'M', '䈧'),
+    (0x2F965, 'M', '𥲀'),
+    (0x2F966, 'M', '糒'),
+    (0x2F967, 'M', '䊠'),
+    (0x2F968, 'M', '糨'),
+    (0x2F969, 'M', '糣'),
+    (0x2F96A, 'M', '紀'),
+    (0x2F96B, 'M', '𥾆'),
+    (0x2F96C, 'M', '絣'),
+    (0x2F96D, 'M', '䌁'),
+    (0x2F96E, 'M', '緇'),
+    (0x2F96F, 'M', '縂'),
+    (0x2F970, 'M', '繅'),
+    (0x2F971, 'M', '䌴'),
+    (0x2F972, 'M', '𦈨'),
+    (0x2F973, 'M', '𦉇'),
+    (0x2F974, 'M', '䍙'),
+    (0x2F975, 'M', '𦋙'),
+    (0x2F976, 'M', '罺'),
+    (0x2F977, 'M', '𦌾'),
+    (0x2F978, 'M', '羕'),
+    (0x2F979, 'M', '翺'),
+    (0x2F97A, 'M', '者'),
+    (0x2F97B, 'M', '𦓚'),
+    (0x2F97C, 'M', '𦔣'),
+    (0x2F97D, 'M', '聠'),
+    (0x2F97E, 'M', '𦖨'),
+    (0x2F97F, 'M', '聰'),
+    (0x2F980, 'M', '𣍟'),
+    (0x2F981, 'M', '䏕'),
+    (0x2F982, 'M', '育'),
+    (0x2F983, 'M', '脃'),
+    (0x2F984, 'M', '䐋'),
+    (0x2F985, 'M', '脾'),
+    (0x2F986, 'M', '媵'),
+    (0x2F987, 'M', '𦞧'),
+    (0x2F988, 'M', '𦞵'),
+    (0x2F989, 'M', '𣎓'),
+    (0x2F98A, 'M', '𣎜'),
+    (0x2F98B, 'M', '舁'),
+    (0x2F98C, 'M', '舄'),
+    (0x2F98D, 'M', '辞'),
+    (0x2F98E, 'M', '䑫'),
+    (0x2F98F, 'M', '芑'),
+    (0x2F990, 'M', '芋'),
+    (0x2F991, 'M', '芝'),
+    (0x2F992, 'M', '劳'),
+    (0x2F993, 'M', '花'),
+    (0x2F994, 'M', '芳'),
+    (0x2F995, 'M', '芽'),
+    (0x2F996, 'M', '苦'),
+    (0x2F997, 'M', '𦬼'),
+    (0x2F998, 'M', '若'),
+    (0x2F999, 'M', '茝'),
+    (0x2F99A, 'M', '荣'),
+    (0x2F99B, 'M', '莭'),
+    (0x2F99C, 'M', '茣'),
+    (0x2F99D, 'M', '莽'),
+    (0x2F99E, 'M', '菧'),
+    (0x2F99F, 'M', '著'),
+    (0x2F9A0, 'M', '荓'),
+    (0x2F9A1, 'M', '菊'),
+    (0x2F9A2, 'M', '菌'),
+    (0x2F9A3, 'M', '菜'),
+    (0x2F9A4, 'M', '𦰶'),
+    (0x2F9A5, 'M', '𦵫'),
+    (0x2F9A6, 'M', '𦳕'),
+    (0x2F9A7, 'M', '䔫'),
+    (0x2F9A8, 'M', '蓱'),
+    (0x2F9A9, 'M', '蓳'),
+    (0x2F9AA, 'M', '蔖'),
+    (0x2F9AB, 'M', '𧏊'),
+    (0x2F9AC, 'M', '蕤'),
+    (0x2F9AD, 'M', '𦼬'),
+    (0x2F9AE, 'M', '䕝'),
+    (0x2F9AF, 'M', '䕡'),
+    (0x2F9B0, 'M', '𦾱'),
+    (0x2F9B1, 'M', '𧃒'),
+    (0x2F9B2, 'M', '䕫'),
+    (0x2F9B3, 'M', '虐'),
+    (0x2F9B4, 'M', '虜'),
+    (0x2F9B5, 'M', '虧'),
+    (0x2F9B6, 'M', '虩'),
+    (0x2F9B7, 'M', '蚩'),
+    (0x2F9B8, 'M', '蚈'),
+    (0x2F9B9, 'M', '蜎'),
+    (0x2F9BA, 'M', '蛢'),
+    (0x2F9BB, 'M', '蝹'),
+    (0x2F9BC, 'M', '蜨'),
+    (0x2F9BD, 'M', '蝫'),
+    (0x2F9BE, 'M', '螆'),
+    (0x2F9BF, 'X'),
+    (0x2F9C0, 'M', '蟡'),
+    (0x2F9C1, 'M', '蠁'),
+    (0x2F9C2, 'M', '䗹'),
+    ]
+
+def _seg_80() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F9C3, 'M', '衠'),
+    (0x2F9C4, 'M', '衣'),
+    (0x2F9C5, 'M', '𧙧'),
+    (0x2F9C6, 'M', '裗'),
+    (0x2F9C7, 'M', '裞'),
+    (0x2F9C8, 'M', '䘵'),
+    (0x2F9C9, 'M', '裺'),
+    (0x2F9CA, 'M', '㒻'),
+    (0x2F9CB, 'M', '𧢮'),
+    (0x2F9CC, 'M', '𧥦'),
+    (0x2F9CD, 'M', '䚾'),
+    (0x2F9CE, 'M', '䛇'),
+    (0x2F9CF, 'M', '誠'),
+    (0x2F9D0, 'M', '諭'),
+    (0x2F9D1, 'M', '變'),
+    (0x2F9D2, 'M', '豕'),
+    (0x2F9D3, 'M', '𧲨'),
+    (0x2F9D4, 'M', '貫'),
+    (0x2F9D5, 'M', '賁'),
+    (0x2F9D6, 'M', '贛'),
+    (0x2F9D7, 'M', '起'),
+    (0x2F9D8, 'M', '𧼯'),
+    (0x2F9D9, 'M', '𠠄'),
+    (0x2F9DA, 'M', '跋'),
+    (0x2F9DB, 'M', '趼'),
+    (0x2F9DC, 'M', '跰'),
+    (0x2F9DD, 'M', '𠣞'),
+    (0x2F9DE, 'M', '軔'),
+    (0x2F9DF, 'M', '輸'),
+    (0x2F9E0, 'M', '𨗒'),
+    (0x2F9E1, 'M', '𨗭'),
+    (0x2F9E2, 'M', '邔'),
+    (0x2F9E3, 'M', '郱'),
+    (0x2F9E4, 'M', '鄑'),
+    (0x2F9E5, 'M', '𨜮'),
+    (0x2F9E6, 'M', '鄛'),
+    (0x2F9E7, 'M', '鈸'),
+    (0x2F9E8, 'M', '鋗'),
+    (0x2F9E9, 'M', '鋘'),
+    (0x2F9EA, 'M', '鉼'),
+    (0x2F9EB, 'M', '鏹'),
+    (0x2F9EC, 'M', '鐕'),
+    (0x2F9ED, 'M', '𨯺'),
+    (0x2F9EE, 'M', '開'),
+    (0x2F9EF, 'M', '䦕'),
+    (0x2F9F0, 'M', '閷'),
+    (0x2F9F1, 'M', '𨵷'),
+    (0x2F9F2, 'M', '䧦'),
+    (0x2F9F3, 'M', '雃'),
+    (0x2F9F4, 'M', '嶲'),
+    (0x2F9F5, 'M', '霣'),
+    (0x2F9F6, 'M', '𩅅'),
+    (0x2F9F7, 'M', '𩈚'),
+    (0x2F9F8, 'M', '䩮'),
+    (0x2F9F9, 'M', '䩶'),
+    (0x2F9FA, 'M', '韠'),
+    (0x2F9FB, 'M', '𩐊'),
+    (0x2F9FC, 'M', '䪲'),
+    (0x2F9FD, 'M', '𩒖'),
+    (0x2F9FE, 'M', '頋'),
+    (0x2FA00, 'M', '頩'),
+    (0x2FA01, 'M', '𩖶'),
+    (0x2FA02, 'M', '飢'),
+    (0x2FA03, 'M', '䬳'),
+    (0x2FA04, 'M', '餩'),
+    (0x2FA05, 'M', '馧'),
+    (0x2FA06, 'M', '駂'),
+    (0x2FA07, 'M', '駾'),
+    (0x2FA08, 'M', '䯎'),
+    (0x2FA09, 'M', '𩬰'),
+    (0x2FA0A, 'M', '鬒'),
+    (0x2FA0B, 'M', '鱀'),
+    (0x2FA0C, 'M', '鳽'),
+    (0x2FA0D, 'M', '䳎'),
+    (0x2FA0E, 'M', '䳭'),
+    (0x2FA0F, 'M', '鵧'),
+    (0x2FA10, 'M', '𪃎'),
+    (0x2FA11, 'M', '䳸'),
+    (0x2FA12, 'M', '𪄅'),
+    (0x2FA13, 'M', '𪈎'),
+    (0x2FA14, 'M', '𪊑'),
+    (0x2FA15, 'M', '麻'),
+    (0x2FA16, 'M', '䵖'),
+    (0x2FA17, 'M', '黹'),
+    (0x2FA18, 'M', '黾'),
+    (0x2FA19, 'M', '鼅'),
+    (0x2FA1A, 'M', '鼏'),
+    (0x2FA1B, 'M', '鼖'),
+    (0x2FA1C, 'M', '鼻'),
+    (0x2FA1D, 'M', '𪘀'),
+    (0x2FA1E, 'X'),
+    (0x30000, 'V'),
+    (0x3134B, 'X'),
+    (0xE0100, 'I'),
+    (0xE01F0, 'X'),
+    ]
+
+uts46data = tuple(
+    _seg_0()
+    + _seg_1()
+    + _seg_2()
+    + _seg_3()
+    + _seg_4()
+    + _seg_5()
+    + _seg_6()
+    + _seg_7()
+    + _seg_8()
+    + _seg_9()
+    + _seg_10()
+    + _seg_11()
+    + _seg_12()
+    + _seg_13()
+    + _seg_14()
+    + _seg_15()
+    + _seg_16()
+    + _seg_17()
+    + _seg_18()
+    + _seg_19()
+    + _seg_20()
+    + _seg_21()
+    + _seg_22()
+    + _seg_23()
+    + _seg_24()
+    + _seg_25()
+    + _seg_26()
+    + _seg_27()
+    + _seg_28()
+    + _seg_29()
+    + _seg_30()
+    + _seg_31()
+    + _seg_32()
+    + _seg_33()
+    + _seg_34()
+    + _seg_35()
+    + _seg_36()
+    + _seg_37()
+    + _seg_38()
+    + _seg_39()
+    + _seg_40()
+    + _seg_41()
+    + _seg_42()
+    + _seg_43()
+    + _seg_44()
+    + _seg_45()
+    + _seg_46()
+    + _seg_47()
+    + _seg_48()
+    + _seg_49()
+    + _seg_50()
+    + _seg_51()
+    + _seg_52()
+    + _seg_53()
+    + _seg_54()
+    + _seg_55()
+    + _seg_56()
+    + _seg_57()
+    + _seg_58()
+    + _seg_59()
+    + _seg_60()
+    + _seg_61()
+    + _seg_62()
+    + _seg_63()
+    + _seg_64()
+    + _seg_65()
+    + _seg_66()
+    + _seg_67()
+    + _seg_68()
+    + _seg_69()
+    + _seg_70()
+    + _seg_71()
+    + _seg_72()
+    + _seg_73()
+    + _seg_74()
+    + _seg_75()
+    + _seg_76()
+    + _seg_77()
+    + _seg_78()
+    + _seg_79()
+    + _seg_80()
+)  # type: Tuple[Union[Tuple[int, str], Tuple[int, str, str]], ...]
diff --git a/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/LICENSE
new file mode 100644
index 0000000..31ecdfb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/LICENSE
@@ -0,0 +1,19 @@
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+     
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+ 
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+
diff --git a/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/METADATA
new file mode 100644
index 0000000..c078a75
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/METADATA
@@ -0,0 +1,78 @@
+Metadata-Version: 2.1
+Name: iniconfig
+Version: 1.1.1
+Summary: iniconfig: brain-dead simple config-ini parsing
+Home-page: http://github.com/RonnyPfannschmidt/iniconfig
+Author: Ronny Pfannschmidt, Holger Krekel
+Author-email: opensource@ronnypfannschmidt.de, holger.krekel@gmail.com
+License: MIT License
+Platform: unix
+Platform: linux
+Platform: osx
+Platform: cygwin
+Platform: win32
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+
+iniconfig: brain-dead simple parsing of ini files
+=======================================================
+
+iniconfig is a small and simple INI-file parser module
+having a unique set of features:
+
+* tested against Python2.4 across to Python3.2, Jython, PyPy
+* maintains order of sections and entries
+* supports multi-line values with or without line-continuations
+* supports "#" comments everywhere
+* raises errors with proper line-numbers
+* no bells and whistles like automatic substitutions
+* iniconfig raises an Error if two sections have the same name.
+
+If you encounter issues or have feature wishes please report them to:
+
+    http://github.com/RonnyPfannschmidt/iniconfig/issues
+
+Basic Example
+===================================
+
+If you have an ini file like this::
+
+    # content of example.ini
+    [section1] # comment
+    name1=value1  # comment
+    name1b=value1,value2  # comment
+
+    [section2]
+    name2=
+        line1
+        line2
+
+then you can do::
+
+    >>> import iniconfig
+    >>> ini = iniconfig.IniConfig("example.ini")
+    >>> ini['section1']['name1'] # raises KeyError if not exists
+    'value1'
+    >>> ini.get('section1', 'name1b', [], lambda x: x.split(","))
+    ['value1', 'value2']
+    >>> ini.get('section1', 'notexist', [], lambda x: x.split(","))
+    []
+    >>> [x.name for x in list(ini)]
+    ['section1', 'section2']
+    >>> list(list(ini)[0].items())
+    [('name1', 'value1'), ('name1b', 'value1,value2')]
+    >>> 'section1' in ini
+    True
+    >>> 'inexistendsection' in ini
+    False
+
+
diff --git a/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/RECORD
new file mode 100644
index 0000000..a666252
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/RECORD
@@ -0,0 +1,9 @@
+iniconfig/__init__.py,sha256=-pBe5AF_6aAwo1CxJQ8i_zJq6ejc6IxHta7qk2tNJhY,5208
+iniconfig/__init__.pyi,sha256=-4KOctzq28ohRmTZsqlH6aylyFqsNKxYqtk1dteypi4,1205
+iniconfig/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iniconfig-1.1.1.dist-info/LICENSE,sha256=KvaAw570k_uCgwNW0dPfGstaBgM8ui3sehniHKp3qGY,1061
+iniconfig-1.1.1.dist-info/METADATA,sha256=_4-oFKpRXuZv5rzepScpXRwhq6DzqsgbnA5ZpgMUMcs,2405
+iniconfig-1.1.1.dist-info/WHEEL,sha256=ADKeyaGyKF5DwBNE0sRE5pvW-bSkFMJfBuhzZ3rceP4,110
+iniconfig-1.1.1.dist-info/top_level.txt,sha256=7KfM0fugdlToj9UW7enKXk2HYALQD8qHiyKtjhSzgN8,10
+iniconfig-1.1.1.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+iniconfig-1.1.1.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/WHEEL
new file mode 100644
index 0000000..6d38aa0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.35.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/top_level.txt
new file mode 100644
index 0000000..9dda536
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/iniconfig-1.1.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+iniconfig
diff --git a/myenv/lib/python3.9/site-packages/iniconfig/__init__.py b/myenv/lib/python3.9/site-packages/iniconfig/__init__.py
new file mode 100644
index 0000000..6ad9eaf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/iniconfig/__init__.py
@@ -0,0 +1,165 @@
+""" brain-dead simple parser for ini-style files.
+(C) Ronny Pfannschmidt, Holger Krekel -- MIT licensed
+"""
+__all__ = ['IniConfig', 'ParseError']
+
+COMMENTCHARS = "#;"
+
+
+class ParseError(Exception):
+    def __init__(self, path, lineno, msg):
+        Exception.__init__(self, path, lineno, msg)
+        self.path = path
+        self.lineno = lineno
+        self.msg = msg
+
+    def __str__(self):
+        return "%s:%s: %s" % (self.path, self.lineno+1, self.msg)
+
+
+class SectionWrapper(object):
+    def __init__(self, config, name):
+        self.config = config
+        self.name = name
+
+    def lineof(self, name):
+        return self.config.lineof(self.name, name)
+
+    def get(self, key, default=None, convert=str):
+        return self.config.get(self.name, key,
+                               convert=convert, default=default)
+
+    def __getitem__(self, key):
+        return self.config.sections[self.name][key]
+
+    def __iter__(self):
+        section = self.config.sections.get(self.name, [])
+
+        def lineof(key):
+            return self.config.lineof(self.name, key)
+        for name in sorted(section, key=lineof):
+            yield name
+
+    def items(self):
+        for name in self:
+            yield name, self[name]
+
+
+class IniConfig(object):
+    def __init__(self, path, data=None):
+        self.path = str(path)  # convenience
+        if data is None:
+            f = open(self.path)
+            try:
+                tokens = self._parse(iter(f))
+            finally:
+                f.close()
+        else:
+            tokens = self._parse(data.splitlines(True))
+
+        self._sources = {}
+        self.sections = {}
+
+        for lineno, section, name, value in tokens:
+            if section is None:
+                self._raise(lineno, 'no section header defined')
+            self._sources[section, name] = lineno
+            if name is None:
+                if section in self.sections:
+                    self._raise(lineno, 'duplicate section %r' % (section, ))
+                self.sections[section] = {}
+            else:
+                if name in self.sections[section]:
+                    self._raise(lineno, 'duplicate name %r' % (name, ))
+                self.sections[section][name] = value
+
+    def _raise(self, lineno, msg):
+        raise ParseError(self.path, lineno, msg)
+
+    def _parse(self, line_iter):
+        result = []
+        section = None
+        for lineno, line in enumerate(line_iter):
+            name, data = self._parseline(line, lineno)
+            # new value
+            if name is not None and data is not None:
+                result.append((lineno, section, name, data))
+            # new section
+            elif name is not None and data is None:
+                if not name:
+                    self._raise(lineno, 'empty section name')
+                section = name
+                result.append((lineno, section, None, None))
+            # continuation
+            elif name is None and data is not None:
+                if not result:
+                    self._raise(lineno, 'unexpected value continuation')
+                last = result.pop()
+                last_name, last_data = last[-2:]
+                if last_name is None:
+                    self._raise(lineno, 'unexpected value continuation')
+
+                if last_data:
+                    data = '%s\n%s' % (last_data, data)
+                result.append(last[:-1] + (data,))
+        return result
+
+    def _parseline(self, line, lineno):
+        # blank lines
+        if iscommentline(line):
+            line = ""
+        else:
+            line = line.rstrip()
+        if not line:
+            return None, None
+        # section
+        if line[0] == '[':
+            realline = line
+            for c in COMMENTCHARS:
+                line = line.split(c)[0].rstrip()
+            if line[-1] == "]":
+                return line[1:-1], None
+            return None, realline.strip()
+        # value
+        elif not line[0].isspace():
+            try:
+                name, value = line.split('=', 1)
+                if ":" in name:
+                    raise ValueError()
+            except ValueError:
+                try:
+                    name, value = line.split(":", 1)
+                except ValueError:
+                    self._raise(lineno, 'unexpected line: %r' % line)
+            return name.strip(), value.strip()
+        # continuation
+        else:
+            return None, line.strip()
+
+    def lineof(self, section, name=None):
+        lineno = self._sources.get((section, name))
+        if lineno is not None:
+            return lineno + 1
+
+    def get(self, section, name, default=None, convert=str):
+        try:
+            return convert(self.sections[section][name])
+        except KeyError:
+            return default
+
+    def __getitem__(self, name):
+        if name not in self.sections:
+            raise KeyError(name)
+        return SectionWrapper(self, name)
+
+    def __iter__(self):
+        for name in sorted(self.sections, key=self.lineof):
+            yield SectionWrapper(self, name)
+
+    def __contains__(self, arg):
+        return arg in self.sections
+
+
+def iscommentline(line):
+    c = line.lstrip()[:1]
+    return c in COMMENTCHARS
diff --git a/myenv/lib/python3.9/site-packages/iniconfig/__init__.pyi b/myenv/lib/python3.9/site-packages/iniconfig/__init__.pyi
new file mode 100644
index 0000000..b6284be
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/iniconfig/__init__.pyi
@@ -0,0 +1,31 @@
+from typing import Callable, Iterator, Mapping, Optional, Tuple, TypeVar, Union
+from typing_extensions import Final
+
+_D = TypeVar('_D')
+_T = TypeVar('_T')
+
+class ParseError(Exception):
+    # Private __init__.
+    path: Final[str]
+    lineno: Final[int]
+    msg: Final[str]
+
+class SectionWrapper:
+    # Private __init__.
+    config: Final[IniConfig]
+    name: Final[str]
+    def __getitem__(self, key: str) -> str: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def get(self, key: str, default: _D = ..., convert: Callable[[str], _T] = ...) -> Union[_T, _D]: ...
+    def items(self) -> Iterator[Tuple[str, str]]: ...
+    def lineof(self, name: str) -> Optional[int]: ...
+
+class IniConfig:
+    path: Final[str]
+    sections: Final[Mapping[str, Mapping[str, str]]]
+    def __init__(self, path: str, data: Optional[str] = None): ...
+    def __contains__(self, arg: str) -> bool: ...
+    def __getitem__(self, name: str) -> SectionWrapper: ...
+    def __iter__(self) -> Iterator[SectionWrapper]: ...
+    def get(self, section: str, name: str, default: _D = ..., convert: Callable[[str], _T] = ...) -> Union[_T, _D]: ...
+    def lineof(self, section: str, name: Optional[str] = ...) -> Optional[int]: ...
diff --git a/myenv/lib/python3.9/site-packages/iniconfig/py.typed b/myenv/lib/python3.9/site-packages/iniconfig/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/LICENSE
new file mode 100644
index 0000000..b5083a5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Timothy Edmund Crosley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/METADATA
new file mode 100644
index 0000000..f0e1eaf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/METADATA
@@ -0,0 +1,397 @@
+Metadata-Version: 2.1
+Name: isort
+Version: 5.10.1
+Summary: A Python utility / library to sort Python imports.
+Home-page: https://pycqa.github.io/isort/
+License: MIT
+Keywords: Refactor,Lint,Imports,Sort,Clean
+Author: Timothy Crosley
+Author-email: timothy.crosley@gmail.com
+Requires-Python: >=3.6.1,<4.0
+Classifier: Development Status :: 6 - Mature
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Provides-Extra: colors
+Provides-Extra: pipfile_deprecated_finder
+Provides-Extra: plugins
+Provides-Extra: requirements_deprecated_finder
+Requires-Dist: colorama (>=0.4.3,<0.5.0); extra == "colors"
+Requires-Dist: pip-api; extra == "requirements_deprecated_finder"
+Requires-Dist: pipreqs; extra == "pipfile_deprecated_finder" or extra == "requirements_deprecated_finder"
+Requires-Dist: requirementslib; extra == "pipfile_deprecated_finder"
+Requires-Dist: setuptools; extra == "plugins"
+Project-URL: Changelog, https://github.com/pycqa/isort/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://pycqa.github.io/isort/
+Project-URL: Repository, https://github.com/pycqa/isort
+Description-Content-Type: text/markdown
+
+[![isort - isort your imports, so you don't have to.](https://raw.githubusercontent.com/pycqa/isort/main/art/logo_large.png)](https://pycqa.github.io/isort/)
+
+------------------------------------------------------------------------
+
+[![PyPI version](https://badge.fury.io/py/isort.svg)](https://badge.fury.io/py/isort)
+[![Test Status](https://github.com/pycqa/isort/workflows/Test/badge.svg?branch=develop)](https://github.com/pycqa/isort/actions?query=workflow%3ATest)
+[![Lint Status](https://github.com/pycqa/isort/workflows/Lint/badge.svg?branch=develop)](https://github.com/pycqa/isort/actions?query=workflow%3ALint)
+[![Code coverage Status](https://codecov.io/gh/pycqa/isort/branch/main/graph/badge.svg)](https://codecov.io/gh/pycqa/isort)
+[![License](https://img.shields.io/github/license/mashape/apistatus.svg)](https://pypi.org/project/isort/)
+[![Join the chat at https://gitter.im/timothycrosley/isort](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/timothycrosley/isort?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Downloads](https://pepy.tech/badge/isort)](https://pepy.tech/project/isort)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
+[![DeepSource](https://static.deepsource.io/deepsource-badge-light-mini.svg)](https://deepsource.io/gh/pycqa/isort/?ref=repository-badge)
+_________________
+
+[Read Latest Documentation](https://pycqa.github.io/isort/) - [Browse GitHub Code Repository](https://github.com/pycqa/isort/)
+_________________
+
+isort your imports, so you don't have to.
+
+isort is a Python utility / library to sort imports alphabetically, and
+automatically separated into sections and by type. It provides a command line
+utility, Python library and [plugins for various
+editors](https://github.com/pycqa/isort/wiki/isort-Plugins) to
+quickly sort all your imports. It requires Python 3.6+ to run but
+supports formatting Python 2 code too.
+
+- [Try isort now from your browser!](https://pycqa.github.io/isort/docs/quick_start/0.-try.html)
+- [Using black? See the isort and black compatibility guide.](https://pycqa.github.io/isort/docs/configuration/black_compatibility.html)
+- [isort has official support for pre-commit!](https://pycqa.github.io/isort/docs/configuration/pre-commit.html)
+
+![Example Usage](https://raw.github.com/pycqa/isort/main/example.gif)
+
+Before isort:
+
+```python
+from my_lib import Object
+
+import os
+
+from my_lib import Object3
+
+from my_lib import Object2
+
+import sys
+
+from third_party import lib15, lib1, lib2, lib3, lib4, lib5, lib6, lib7, lib8, lib9, lib10, lib11, lib12, lib13, lib14
+
+import sys
+
+from __future__ import absolute_import
+
+from third_party import lib3
+
+print("Hey")
+print("yo")
+```
+
+After isort:
+
+```python
+from __future__ import absolute_import
+
+import os
+import sys
+
+from third_party import (lib1, lib2, lib3, lib4, lib5, lib6, lib7, lib8,
+                         lib9, lib10, lib11, lib12, lib13, lib14, lib15)
+
+from my_lib import Object, Object2, Object3
+
+print("Hey")
+print("yo")
+```
+
+## Installing isort
+
+Installing isort is as simple as:
+
+```bash
+pip install isort
+```
+
+Install isort with requirements.txt support:
+
+```bash
+pip install isort[requirements_deprecated_finder]
+```
+
+Install isort with Pipfile support:
+
+```bash
+pip install isort[pipfile_deprecated_finder]
+```
+
+Install isort with both formats support:
+
+```bash
+pip install isort[requirements_deprecated_finder,pipfile_deprecated_finder]
+```
+
+## Using isort
+
+**From the command line**:
+
+To run on specific files:
+
+```bash
+isort mypythonfile.py mypythonfile2.py
+```
+
+To apply recursively:
+
+```bash
+isort .
+```
+
+If [globstar](https://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html)
+is enabled, `isort .` is equivalent to:
+
+```bash
+isort **/*.py
+```
+
+To view proposed changes without applying them:
+
+```bash
+isort mypythonfile.py --diff
+```
+
+Finally, to atomically run isort against a project, only applying
+changes if they don't introduce syntax errors:
+
+```bash
+isort --atomic .
+```
+
+(Note: this is disabled by default, as it prevents isort from
+running against code written using a different version of Python.)
+
+**From within Python**:
+
+```python
+import isort
+
+isort.file("pythonfile.py")
+```
+
+or:
+
+```python
+import isort
+
+sorted_code = isort.code("import b\nimport a\n")
+```
+
+## Installing isort's for your preferred text editor
+
+Several plugins have been written that enable to use isort from within a
+variety of text-editors. You can find a full list of them [on the isort
+wiki](https://github.com/pycqa/isort/wiki/isort-Plugins).
+Additionally, I will enthusiastically accept pull requests that include
+plugins for other text editors and add documentation for them as I am
+notified.
+
+## Multi line output modes
+
+You will notice above the \"multi\_line\_output\" setting. This setting
+defines how from imports wrap when they extend past the line\_length
+limit and has [12 possible settings](https://pycqa.github.io/isort/docs/configuration/multi_line_output_modes.html).
+
+## Indentation
+
+To change the how constant indents appear - simply change the
+indent property with the following accepted formats:
+
+-   Number of spaces you would like. For example: 4 would cause standard
+    4 space indentation.
+-   Tab
+-   A verbatim string with quotes around it.
+
+For example:
+
+```python
+"    "
+```
+
+is equivalent to 4.
+
+For the import styles that use parentheses, you can control whether or
+not to include a trailing comma after the last import with the
+`include_trailing_comma` option (defaults to `False`).
+
+## Intelligently Balanced Multi-line Imports
+
+As of isort 3.1.0 support for balanced multi-line imports has been
+added. With this enabled isort will dynamically change the import length
+to the one that produces the most balanced grid, while staying below the
+maximum import length defined.
+
+Example:
+
+```python
+from __future__ import (absolute_import, division,
+                        print_function, unicode_literals)
+```
+
+Will be produced instead of:
+
+```python
+from __future__ import (absolute_import, division, print_function,
+                        unicode_literals)
+```
+
+To enable this set `balanced_wrapping` to `True` in your config or pass
+the `-e` option into the command line utility.
+
+## Custom Sections and Ordering
+
+isort provides configuration options to change almost every aspect of how
+imports are organized, ordered, or grouped together in sections.
+
+[Click here](https://pycqa.github.io/isort/docs/configuration/custom_sections_and_ordering.html) for an overview of all these options.
+
+## Skip processing of imports (outside of configuration)
+
+To make isort ignore a single import simply add a comment at the end of
+the import line containing the text `isort:skip`:
+
+```python
+import module  # isort:skip
+```
+
+or:
+
+```python
+from xyz import (abc,  # isort:skip
+                 yo,
+                 hey)
+```
+
+To make isort skip an entire file simply add `isort:skip_file` to the
+module's doc string:
+
+```python
+""" my_module.py
+    Best module ever
+
+   isort:skip_file
+"""
+
+import b
+import a
+```
+
+## Adding or removing an import from multiple files
+
+isort can be ran or configured to add / remove imports automatically.
+
+[See a complete guide here.](https://pycqa.github.io/isort/docs/configuration/add_or_remove_imports.html)
+
+## Using isort to verify code
+
+The `--check-only` option
+-------------------------
+
+isort can also be used to verify that code is correctly formatted
+by running it with `-c`. Any files that contain incorrectly sorted
+and/or formatted imports will be outputted to `stderr`.
+
+```bash
+isort **/*.py -c -v
+
+SUCCESS: /home/timothy/Projects/Open_Source/isort/isort_kate_plugin.py Everything Looks Good!
+ERROR: /home/timothy/Projects/Open_Source/isort/isort/isort.py Imports are incorrectly sorted.
+```
+
+One great place this can be used is with a pre-commit git hook, such as
+this one by \@acdha:
+
+<https://gist.github.com/acdha/8717683>
+
+This can help to ensure a certain level of code quality throughout a
+project.
+
+## Git hook
+
+isort provides a hook function that can be integrated into your Git
+pre-commit script to check Python code before committing.
+
+[More info here.](https://pycqa.github.io/isort/docs/configuration/git_hook.html)
+
+## Setuptools integration
+
+Upon installation, isort enables a `setuptools` command that checks
+Python files declared by your project.
+
+[More info here.](https://pycqa.github.io/isort/docs/configuration/setuptools_integration.html)
+
+## Spread the word
+
+[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
+
+Place this badge at the top of your repository to let others know your project uses isort.
+
+For README.md:
+
+```markdown
+[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
+```
+
+Or README.rst:
+
+```rst
+.. image:: https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336
+    :target: https://pycqa.github.io/isort/
+```
+
+## Security contact information
+
+To report a security vulnerability, please use the [Tidelift security
+contact](https://tidelift.com/security). Tidelift will coordinate the
+fix and disclosure.
+
+## Why isort?
+
+isort simply stands for import sort. It was originally called
+"sortImports" however I got tired of typing the extra characters and
+came to the realization camelCase is not pythonic.
+
+I wrote isort because in an organization I used to work in the manager
+came in one day and decided all code must have alphabetically sorted
+imports. The code base was huge - and he meant for us to do it by hand.
+However, being a programmer - I\'m too lazy to spend 8 hours mindlessly
+performing a function, but not too lazy to spend 16 hours automating it.
+I was given permission to open source sortImports and here we are :)
+
+------------------------------------------------------------------------
+
+[Get professionally supported isort with the Tidelift
+Subscription](https://tidelift.com/subscription/pkg/pypi-isort?utm_source=pypi-isort&utm_medium=referral&utm_campaign=readme)
+
+Professional support for isort is available as part of the [Tidelift
+Subscription](https://tidelift.com/subscription/pkg/pypi-isort?utm_source=pypi-isort&utm_medium=referral&utm_campaign=readme).
+Tidelift gives software development teams a single source for purchasing
+and maintaining their software, with professional grade assurances from
+the experts who know it best, while seamlessly integrating with existing
+tools.
+
+------------------------------------------------------------------------
+
+Thanks and I hope you find isort useful!
+
+~Timothy Crosley
+
diff --git a/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/RECORD
new file mode 100644
index 0000000..c79fd95
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/RECORD
@@ -0,0 +1,56 @@
+../../../bin/isort,sha256=KfvFH3JNYk3-tOrA4GG5mzM73j9nYhy6_4F6kpJA-XI,250
+../../../bin/isort-identify-imports,sha256=KSx7OLQsR8I593zsKTwH4dggYk6CoT8Bn0ZOxMx71TQ,284
+isort/__init__.py,sha256=5S6lmnFHXlZbzl7ni97ZANzkXePqKPkRUaMJyul3dIo,871
+isort/__main__.py,sha256=iK0trzN9CCXpQX-XPZDZ9JVkm2Lc0q0oiAgsa6FkJb4,36
+isort/_future/__init__.py,sha256=3Ftum0fE5cZdBaVuRCgjt8LDwZXa8jWV6g7r3_-Uzdk,310
+isort/_future/_dataclasses.py,sha256=-jj1nXvPe02i6emtxyb1xyYmbp1_2-_8xYk64Z7lV3Q,44114
+isort/_vendored/tomli/LICENSE,sha256=uAgWsNUwuKzLTCIReDeQmEpuO2GSLCte6S8zcqsnQv4,1072
+isort/_vendored/tomli/__init__.py,sha256=Y3N65pvphV_EF4k2qKiq_vYcohIUHhT05GzdRc0TOy8,213
+isort/_vendored/tomli/_parser.py,sha256=fhOEEYZATanBBAn-hyy0Au_aZbdqXfdKB8mGTvI1W3k,21397
+isort/_vendored/tomli/_re.py,sha256=0nrY6tQHUyJWcIf1IJwgqn0Zfhoi_dvSrn9NOY6fg5M,2833
+isort/_vendored/tomli/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+isort/_version.py,sha256=hJ77ITgc8GY6imxoql15eKMxOxScd8uLLH4ZpFYieGQ,23
+isort/api.py,sha256=oMtq_RH63175YWKUYAO_2E2feHn5l-8VXqDpTe_DbLo,26162
+isort/comments.py,sha256=6tLt0QRuSQvo-tpgTTM4oJKk-oqaE8MOTA95l89LtQQ,933
+isort/core.py,sha256=CE6a_7DVoAHXudHxsbXZ-z9bWoTAnzv57QBI7rHO_ig,20844
+isort/deprecated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+isort/deprecated/finders.py,sha256=nMAZwPKS7RoBOaFznKFm1IpyMzfdD6-tx3PRDmpY_dg,14812
+isort/exceptions.py,sha256=xmUyF5uS1K_rtlMDWoaAmtD_PA0B82u6rqgxgEjUjcw,7060
+isort/files.py,sha256=3wRqIAAquCCTF5aPzpzoDsWBvrTy49vqG11hAFseJD8,1589
+isort/format.py,sha256=Uv57ipCbGkQCXoTSxz3dWswMleTYjpNoEg-9Kek9_LY,5446
+isort/hooks.py,sha256=RAMAxwWNoXEka98HoDLkSqEkOprMkhb3wTIgd72f9xE,3131
+isort/identify.py,sha256=Q58HB4BRrOgdbiWuk6y_olcPnLaGIYazJyGvVheG7Y0,8373
+isort/io.py,sha256=HbNX5hwNOmO-QRV0u6weRShzvxpQVXiUuteFPN8XMsI,2275
+isort/literal.py,sha256=a5J_dWzd5hH6S-dan4BJdT0afTcKKHmKIZDceibVHWw,3685
+isort/logo.py,sha256=cL3al79O7O0G2viqRMRfBPp0qtRZmJw2nHSCZw8XWdQ,388
+isort/main.py,sha256=LFFm6Nd4KVGQ6KFaRDHPupfCCO4NANzqgFwjflZMg8Q,46322
+isort/output.py,sha256=_npuUogd9jSZx1-fuAuKIc8Lsc-EqqdGX3zPgZoj7jc,27007
+isort/parse.py,sha256=F7Xee3sHoMV8nlCGKsxH5ItH6hpxO9UpnSGfXk9dwPE,25094
+isort/place.py,sha256=ET3U_bUEDEM11TTKOn8Xwv9qG46uR7jZHqNV61dIz14,5173
+isort/profiles.py,sha256=BY68PIpf3s7305A2_JNkmFhMf6vXfGOat9KjESE_TI4,2119
+isort/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+isort/pylama_isort.py,sha256=vNP7jAxZy7ryZR4hotynA4JCzAxLtbasT9AYpZiiClk,1308
+isort/sections.py,sha256=xG5bwU4tOIKUmeBBhZ45EIfjP8HgDOx796bPvD5zWCw,297
+isort/settings.py,sha256=JxYUFLsb_GlYUeE_q3h91SwG9NI22f854DUKQWY6J7s,35418
+isort/setuptools_commands.py,sha256=YKDnILlXUYCayYxDh0boVQnk1C0c-NodhCnnGn6Arrw,2299
+isort/sorting.py,sha256=uZDt7sdG2HWmzAlekigvsEfj-e45ng8Kr1wwU7iKJig,4515
+isort/stdlibs/__init__.py,sha256=K0xJY1m9azaV2m_QwZ84mGe0hpe-6HhXUzvgSLLB_Xo,92
+isort/stdlibs/all.py,sha256=n8Es1WK6UlupYyVvf1PDjGbionqix-afC3LkY8nzTcw,57
+isort/stdlibs/py2.py,sha256=dTgWTa7ggz1cwN8fuI9eIs9-5nTmkRxG_uO61CGwfXI,41
+isort/stdlibs/py27.py,sha256=QriKfttNSHsjaRtDfR5WXytjzf7Xi7p9lxiOOcmA2JM,4504
+isort/stdlibs/py3.py,sha256=yWfPnYFgxosQqoRQAIoXn4quZKLE8w7KTm3aar7g7PQ,143
+isort/stdlibs/py310.py,sha256=oVYf6cuEEKXlEdEDdowa3D5rsVOMR-MnSkq6xZa_ntM,3263
+isort/stdlibs/py35.py,sha256=dA_eWId8Q5yOj76zuzT1mEKDeB4FmekKLBNBL7EHV_k,3295
+isort/stdlibs/py36.py,sha256=iuXIDLcFrSviMMSOP4PoKWCG5BveMnZbFravpduSUss,3310
+isort/stdlibs/py37.py,sha256=dLxxRerCvb4O9vrifTg5KWgO0L3a6AQB13haK_tSBRw,3334
+isort/stdlibs/py38.py,sha256=xsUSUZD5XUYX0PIuf9A3bSMD4ZcbfPyzqJqCudSfhaU,3319
+isort/stdlibs/py39.py,sha256=tlVRkhoDpoNJxJd803NdTt_hgzzuukJMkUQMgpE-vlA,3307
+isort/utils.py,sha256=5EEZUfZyyWcJLk2qnNF8ObDib_qPU4zwEQvWjpKRgb0,2413
+isort/wrap.py,sha256=o7_kcpPXUKpzh-Cna3XY__S50TdZI39R3j4hl6iSqkA,6068
+isort/wrap_modes.py,sha256=3N-izkXBrd-QU2CyEbqxuKVHuuhB-ulqzDYF7DV6wNk,13569
+isort-5.10.1.dist-info/entry_points.txt,sha256=stP-G7UtFo06wllIxS1jKbEJpc4u_3WPiLh_r13BGcc,213
+isort-5.10.1.dist-info/LICENSE,sha256=BjKUABw9Uj26y6ud1UrCKZgnVsyvWSylMkCysM3YIGU,1089
+isort-5.10.1.dist-info/WHEEL,sha256=SrtnPGVTMeYWttls9xnWA01eUhCZ3ufFdJUYb1J3r-U,83
+isort-5.10.1.dist-info/METADATA,sha256=Rgh0fARMrFFqafPC_HunYdNYGxjFQYZuW0B9-g-5mKs,12702
+isort-5.10.1.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+isort-5.10.1.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/WHEEL
new file mode 100644
index 0000000..caca394
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry 1.0.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/entry_points.txt
new file mode 100644
index 0000000..21bc432
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort-5.10.1.dist-info/entry_points.txt
@@ -0,0 +1,10 @@
+[console_scripts]
+isort=isort.main:main
+isort-identify-imports=isort.main:identify_imports_main
+
+[distutils.commands]
+isort=isort.setuptools_commands:ISortCommand
+
+[pylama.linter]
+isort=isort.pylama_isort:Linter
+
diff --git a/myenv/lib/python3.9/site-packages/isort/__init__.py b/myenv/lib/python3.9/site-packages/isort/__init__.py
new file mode 100644
index 0000000..e0754da
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/__init__.py
@@ -0,0 +1,38 @@
+"""Defines the public isort interface"""
+__all__ = (
+    "Config",
+    "ImportKey",
+    "__version__",
+    "check_code",
+    "check_file",
+    "check_stream",
+    "code",
+    "file",
+    "find_imports_in_code",
+    "find_imports_in_file",
+    "find_imports_in_paths",
+    "find_imports_in_stream",
+    "place_module",
+    "place_module_with_reason",
+    "settings",
+    "stream",
+)
+
+from . import settings
+from ._version import __version__
+from .api import ImportKey
+from .api import check_code_string as check_code
+from .api import (
+    check_file,
+    check_stream,
+    find_imports_in_code,
+    find_imports_in_file,
+    find_imports_in_paths,
+    find_imports_in_stream,
+    place_module,
+    place_module_with_reason,
+)
+from .api import sort_code_string as code
+from .api import sort_file as file
+from .api import sort_stream as stream
+from .settings import Config
diff --git a/myenv/lib/python3.9/site-packages/isort/__main__.py b/myenv/lib/python3.9/site-packages/isort/__main__.py
new file mode 100644
index 0000000..94b1d05
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/__main__.py
@@ -0,0 +1,3 @@
+from isort.main import main
+
+main()
diff --git a/myenv/lib/python3.9/site-packages/isort/_future/__init__.py b/myenv/lib/python3.9/site-packages/isort/_future/__init__.py
new file mode 100644
index 0000000..4802853
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/_future/__init__.py
@@ -0,0 +1,12 @@
+import sys
+
+if sys.version_info.major <= 3 and sys.version_info.minor <= 6:
+    from . import _dataclasses as dataclasses
+
+else:
+    import dataclasses  # type: ignore
+
+dataclass = dataclasses.dataclass  # type: ignore
+field = dataclasses.field  # type: ignore
+
+__all__ = ["dataclasses", "dataclass", "field"]
diff --git a/myenv/lib/python3.9/site-packages/isort/_future/_dataclasses.py b/myenv/lib/python3.9/site-packages/isort/_future/_dataclasses.py
new file mode 100644
index 0000000..71962e2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/_future/_dataclasses.py
@@ -0,0 +1,1209 @@
+# type: ignore
+# flake8: noqa
+# flake8: noqa
+"""Backport of Python3.7 dataclasses Library
+
+Taken directly from here: https://github.com/ericvsmith/dataclasses
+Licensed under the Apache License: https://github.com/ericvsmith/dataclasses/blob/master/LICENSE.txt
+
+Needed due to isorts strict no non-optional requirements stance.
+
+TODO: Remove once isort only supports 3.7+
+"""
+import copy
+import inspect
+import keyword
+import re
+import sys
+import types
+
+__all__ = [
+    "dataclass",
+    "field",
+    "Field",
+    "FrozenInstanceError",
+    "InitVar",
+    "MISSING",
+    # Helper functions.
+    "fields",
+    "asdict",
+    "astuple",
+    "make_dataclass",
+    "replace",
+    "is_dataclass",
+]
+
+# Conditions for adding methods.  The boxes indicate what action the
+# dataclass decorator takes.  For all of these tables, when I talk
+# about init=, repr=, eq=, order=, unsafe_hash=, or frozen=, I'm
+# referring to the arguments to the @dataclass decorator.  When
+# checking if a dunder method already exists, I mean check for an
+# entry in the class's __dict__.  I never check to see if an attribute
+# is defined in a base class.
+
+# Key:
+# +=========+=========================================+
+# + Value   | Meaning                                 |
+# +=========+=========================================+
+# | <blank> | No action: no method is added.          |
+# +---------+-----------------------------------------+
+# | add     | Generated method is added.              |
+# +---------+-----------------------------------------+
+# | raise   | TypeError is raised.                    |
+# +---------+-----------------------------------------+
+# | None    | Attribute is set to None.               |
+# +=========+=========================================+
+
+# __init__
+#
+#   +--- init= parameter
+#   |
+#   v     |       |       |
+#         |  no   |  yes  |  <--- class has __init__ in __dict__?
+# +=======+=======+=======+
+# | False |       |       |
+# +-------+-------+-------+
+# | True  | add   |       |  <- the default
+# +=======+=======+=======+
+
+# __repr__
+#
+#    +--- repr= parameter
+#    |
+#    v    |       |       |
+#         |  no   |  yes  |  <--- class has __repr__ in __dict__?
+# +=======+=======+=======+
+# | False |       |       |
+# +-------+-------+-------+
+# | True  | add   |       |  <- the default
+# +=======+=======+=======+
+
+
+# __setattr__
+# __delattr__
+#
+#    +--- frozen= parameter
+#    |
+#    v    |       |       |
+#         |  no   |  yes  |  <--- class has __setattr__ or __delattr__ in __dict__?
+# +=======+=======+=======+
+# | False |       |       |  <- the default
+# +-------+-------+-------+
+# | True  | add   | raise |
+# +=======+=======+=======+
+# Raise because not adding these methods would break the "frozen-ness"
+# of the class.
+
+# __eq__
+#
+#    +--- eq= parameter
+#    |
+#    v    |       |       |
+#         |  no   |  yes  |  <--- class has __eq__ in __dict__?
+# +=======+=======+=======+
+# | False |       |       |
+# +-------+-------+-------+
+# | True  | add   |       |  <- the default
+# +=======+=======+=======+
+
+# __lt__
+# __le__
+# __gt__
+# __ge__
+#
+#    +--- order= parameter
+#    |
+#    v    |       |       |
+#         |  no   |  yes  |  <--- class has any comparison method in __dict__?
+# +=======+=======+=======+
+# | False |       |       |  <- the default
+# +-------+-------+-------+
+# | True  | add   | raise |
+# +=======+=======+=======+
+# Raise because to allow this case would interfere with using
+# functools.total_ordering.
+
+# __hash__
+
+#    +------------------- unsafe_hash= parameter
+#    |       +----------- eq= parameter
+#    |       |       +--- frozen= parameter
+#    |       |       |
+#    v       v       v    |        |        |
+#                         |   no   |  yes   |  <--- class has explicitly defined __hash__
+# +=======+=======+=======+========+========+
+# | False | False | False |        |        | No __eq__, use the base class __hash__
+# +-------+-------+-------+--------+--------+
+# | False | False | True  |        |        | No __eq__, use the base class __hash__
+# +-------+-------+-------+--------+--------+
+# | False | True  | False | None   |        | <-- the default, not hashable
+# +-------+-------+-------+--------+--------+
+# | False | True  | True  | add    |        | Frozen, so hashable, allows override
+# +-------+-------+-------+--------+--------+
+# | True  | False | False | add    | raise  | Has no __eq__, but hashable
+# +-------+-------+-------+--------+--------+
+# | True  | False | True  | add    | raise  | Has no __eq__, but hashable
+# +-------+-------+-------+--------+--------+
+# | True  | True  | False | add    | raise  | Not frozen, but hashable
+# +-------+-------+-------+--------+--------+
+# | True  | True  | True  | add    | raise  | Frozen, so hashable
+# +=======+=======+=======+========+========+
+# For boxes that are blank, __hash__ is untouched and therefore
+# inherited from the base class.  If the base is object, then
+# id-based hashing is used.
+#
+# Note that a class may already have __hash__=None if it specified an
+# __eq__ method in the class body (not one that was created by
+# @dataclass).
+#
+# See _hash_action (below) for a coded version of this table.
+
+
+# Raised when an attempt is made to modify a frozen class.
+class FrozenInstanceError(AttributeError):
+    pass
+
+
+# A sentinel object for default values to signal that a default
+# factory will be used.  This is given a nice repr() which will appear
+# in the function signature of dataclasses' constructors.
+class _HAS_DEFAULT_FACTORY_CLASS:
+    def __repr__(self):
+        return "<factory>"
+
+
+_HAS_DEFAULT_FACTORY = _HAS_DEFAULT_FACTORY_CLASS()
+
+# A sentinel object to detect if a parameter is supplied or not.  Use
+# a class to give it a better repr.
+class _MISSING_TYPE:
+    pass
+
+
+MISSING = _MISSING_TYPE()
+
+# Since most per-field metadata will be unused, create an empty
+# read-only proxy that can be shared among all fields.
+_EMPTY_METADATA = types.MappingProxyType({})
+
+# Markers for the various kinds of fields and pseudo-fields.
+class _FIELD_BASE:
+    def __init__(self, name):
+        self.name = name
+
+    def __repr__(self):
+        return self.name
+
+
+_FIELD = _FIELD_BASE("_FIELD")
+_FIELD_CLASSVAR = _FIELD_BASE("_FIELD_CLASSVAR")
+_FIELD_INITVAR = _FIELD_BASE("_FIELD_INITVAR")
+
+# The name of an attribute on the class where we store the Field
+# objects.  Also used to check if a class is a Data Class.
+_FIELDS = "__dataclass_fields__"
+
+# The name of an attribute on the class that stores the parameters to
+# @dataclass.
+_PARAMS = "__dataclass_params__"
+
+# The name of the function, that if it exists, is called at the end of
+# __init__.
+_POST_INIT_NAME = "__post_init__"
+
+# String regex that string annotations for ClassVar or InitVar must match.
+# Allows "identifier.identifier[" or "identifier[".
+# https://bugs.python.org/issue33453 for details.
+_MODULE_IDENTIFIER_RE = re.compile(r"^(?:\s*(\w+)\s*\.)?\s*(\w+)")
+
+
+class _InitVarMeta(type):
+    def __getitem__(self, params):
+        return self
+
+
+class InitVar(metaclass=_InitVarMeta):
+    pass
+
+
+# Instances of Field are only ever created from within this module,
+# and only from the field() function, although Field instances are
+# exposed externally as (conceptually) read-only objects.
+#
+# name and type are filled in after the fact, not in __init__.
+# They're not known at the time this class is instantiated, but it's
+# convenient if they're available later.
+#
+# When cls._FIELDS is filled in with a list of Field objects, the name
+# and type fields will have been populated.
+class Field:
+    __slots__ = (
+        "name",
+        "type",
+        "default",
+        "default_factory",
+        "repr",
+        "hash",
+        "init",
+        "compare",
+        "metadata",
+        "_field_type",  # Private: not to be used by user code.
+    )
+
+    def __init__(self, default, default_factory, init, repr, hash, compare, metadata):
+        self.name = None
+        self.type = None
+        self.default = default
+        self.default_factory = default_factory
+        self.init = init
+        self.repr = repr
+        self.hash = hash
+        self.compare = compare
+        self.metadata = (
+            _EMPTY_METADATA
+            if metadata is None or len(metadata) == 0
+            else types.MappingProxyType(metadata)
+        )
+        self._field_type = None
+
+    def __repr__(self):
+        return (
+            "Field("
+            f"name={self.name!r},"
+            f"type={self.type!r},"
+            f"default={self.default!r},"
+            f"default_factory={self.default_factory!r},"
+            f"init={self.init!r},"
+            f"repr={self.repr!r},"
+            f"hash={self.hash!r},"
+            f"compare={self.compare!r},"
+            f"metadata={self.metadata!r},"
+            f"_field_type={self._field_type}"
+            ")"
+        )
+
+    # This is used to support the PEP 487 __set_name__ protocol in the
+    # case where we're using a field that contains a descriptor as a
+    # default value.  For details on __set_name__, see
+    # https://www.python.org/dev/peps/pep-0487/#implementation-details.
+    #
+    # Note that in _process_class, this Field object is overwritten
+    # with the default value, so the end result is a descriptor that
+    # had __set_name__ called on it at the right time.
+    def __set_name__(self, owner, name):
+        func = getattr(type(self.default), "__set_name__", None)
+        if func:
+            # There is a __set_name__ method on the descriptor, call
+            # it.
+            func(self.default, owner, name)
+
+
+class _DataclassParams:
+    __slots__ = ("init", "repr", "eq", "order", "unsafe_hash", "frozen")
+
+    def __init__(self, init, repr, eq, order, unsafe_hash, frozen):
+        self.init = init
+        self.repr = repr
+        self.eq = eq
+        self.order = order
+        self.unsafe_hash = unsafe_hash
+        self.frozen = frozen
+
+    def __repr__(self):
+        return (
+            "_DataclassParams("
+            f"init={self.init!r},"
+            f"repr={self.repr!r},"
+            f"eq={self.eq!r},"
+            f"order={self.order!r},"
+            f"unsafe_hash={self.unsafe_hash!r},"
+            f"frozen={self.frozen!r}"
+            ")"
+        )
+
+
+# This function is used instead of exposing Field creation directly,
+# so that a type checker can be told (via overloads) that this is a
+# function whose type depends on its parameters.
+def field(
+    *,
+    default=MISSING,
+    default_factory=MISSING,
+    init=True,
+    repr=True,
+    hash=None,
+    compare=True,
+    metadata=None,
+):
+    """Return an object to identify dataclass fields.
+    default is the default value of the field.  default_factory is a
+    0-argument function called to initialize a field's value.  If init
+    is True, the field will be a parameter to the class's __init__()
+    function.  If repr is True, the field will be included in the
+    object's repr().  If hash is True, the field will be included in
+    the object's hash().  If compare is True, the field will be used
+    in comparison functions.  metadata, if specified, must be a
+    mapping which is stored but not otherwise examined by dataclass.
+    It is an error to specify both default and default_factory.
+    """
+
+    if default is not MISSING and default_factory is not MISSING:
+        raise ValueError("cannot specify both default and default_factory")
+    return Field(default, default_factory, init, repr, hash, compare, metadata)
+
+
+def _tuple_str(obj_name, fields):
+    # Return a string representing each field of obj_name as a tuple
+    # member.  So, if fields is ['x', 'y'] and obj_name is "self",
+    # return "(self.x,self.y)".
+
+    # Special case for the 0-tuple.
+    if not fields:
+        return "()"
+    # Note the trailing comma, needed if this turns out to be a 1-tuple.
+    return f'({",".join(f"{obj_name}.{f.name}" for f in fields)},)'
+
+
+def _create_fn(name, args, body, *, globals=None, locals=None, return_type=MISSING):
+    # Note that we mutate locals when exec() is called.  Caller
+    # beware!  The only callers are internal to this module, so no
+    # worries about external callers.
+    if locals is None:
+        locals = {}
+    return_annotation = ""
+    if return_type is not MISSING:
+        locals["_return_type"] = return_type
+        return_annotation = "->_return_type"
+    args = ",".join(args)
+    body = "\n".join(f" {b}" for b in body)
+
+    # Compute the text of the entire function.
+    txt = f"def {name}({args}){return_annotation}:\n{body}"
+
+    exec(txt, globals, locals)  # nosec
+    return locals[name]
+
+
+def _field_assign(frozen, name, value, self_name):
+    # If we're a frozen class, then assign to our fields in __init__
+    # via object.__setattr__.  Otherwise, just use a simple
+    # assignment.
+    #
+    # self_name is what "self" is called in this function: don't
+    # hard-code "self", since that might be a field name.
+    if frozen:
+        return f"object.__setattr__({self_name},{name!r},{value})"
+    return f"{self_name}.{name}={value}"
+
+
+def _field_init(f, frozen, globals, self_name):
+    # Return the text of the line in the body of __init__ that will
+    # initialize this field.
+
+    default_name = f"_dflt_{f.name}"
+    if f.default_factory is not MISSING:
+        if f.init:
+            # This field has a default factory.  If a parameter is
+            # given, use it.  If not, call the factory.
+            globals[default_name] = f.default_factory
+            value = f"{default_name}() " f"if {f.name} is _HAS_DEFAULT_FACTORY " f"else {f.name}"
+        else:
+            # This is a field that's not in the __init__ params, but
+            # has a default factory function.  It needs to be
+            # initialized here by calling the factory function,
+            # because there's no other way to initialize it.
+
+            # For a field initialized with a default=defaultvalue, the
+            # class dict just has the default value
+            # (cls.fieldname=defaultvalue).  But that won't work for a
+            # default factory, the factory must be called in __init__
+            # and we must assign that to self.fieldname.  We can't
+            # fall back to the class dict's value, both because it's
+            # not set, and because it might be different per-class
+            # (which, after all, is why we have a factory function!).
+
+            globals[default_name] = f.default_factory
+            value = f"{default_name}()"
+    else:
+        # No default factory.
+        if f.init:
+            if f.default is MISSING:
+                # There's no default, just do an assignment.
+                value = f.name
+            elif f.default is not MISSING:
+                globals[default_name] = f.default
+                value = f.name
+        else:
+            # This field does not need initialization.  Signify that
+            # to the caller by returning None.
+            return None
+
+    # Only test this now, so that we can create variables for the
+    # default.  However, return None to signify that we're not going
+    # to actually do the assignment statement for InitVars.
+    if f._field_type == _FIELD_INITVAR:
+        return None
+
+    # Now, actually generate the field assignment.
+    return _field_assign(frozen, f.name, value, self_name)
+
+
+def _init_param(f):
+    # Return the __init__ parameter string for this field.  For
+    # example, the equivalent of 'x:int=3' (except instead of 'int',
+    # reference a variable set to int, and instead of '3', reference a
+    # variable set to 3).
+    if f.default is MISSING and f.default_factory is MISSING:
+        # There's no default, and no default_factory, just output the
+        # variable name and type.
+        default = ""
+    elif f.default is not MISSING:
+        # There's a default, this will be the name that's used to look
+        # it up.
+        default = f"=_dflt_{f.name}"
+    elif f.default_factory is not MISSING:
+        # There's a factory function.  Set a marker.
+        default = "=_HAS_DEFAULT_FACTORY"
+    return f"{f.name}:_type_{f.name}{default}"
+
+
+def _init_fn(fields, frozen, has_post_init, self_name):
+    # fields contains both real fields and InitVar pseudo-fields.
+
+    # Make sure we don't have fields without defaults following fields
+    # with defaults.  This actually would be caught when exec-ing the
+    # function source code, but catching it here gives a better error
+    # message, and future-proofs us in case we build up the function
+    # using ast.
+    seen_default = False
+    for f in fields:
+        # Only consider fields in the __init__ call.
+        if f.init:
+            if not (f.default is MISSING and f.default_factory is MISSING):
+                seen_default = True
+            elif seen_default:
+                raise TypeError(f"non-default argument {f.name!r} " "follows default argument")
+
+    globals = {"MISSING": MISSING, "_HAS_DEFAULT_FACTORY": _HAS_DEFAULT_FACTORY}
+
+    body_lines = []
+    for f in fields:
+        line = _field_init(f, frozen, globals, self_name)
+        # line is None means that this field doesn't require
+        # initialization (it's a pseudo-field).  Just skip it.
+        if line:
+            body_lines.append(line)
+
+    # Does this class have a post-init function?
+    if has_post_init:
+        params_str = ",".join(f.name for f in fields if f._field_type is _FIELD_INITVAR)
+        body_lines.append(f"{self_name}.{_POST_INIT_NAME}({params_str})")
+
+    # If no body lines, use 'pass'.
+    if not body_lines:
+        body_lines = ["pass"]
+
+    locals = {f"_type_{f.name}": f.type for f in fields}
+    return _create_fn(
+        "__init__",
+        [self_name] + [_init_param(f) for f in fields if f.init],
+        body_lines,
+        locals=locals,
+        globals=globals,
+        return_type=None,
+    )
+
+
+def _repr_fn(fields):
+    return _create_fn(
+        "__repr__",
+        ("self",),
+        [
+            'return self.__class__.__qualname__ + f"('
+            + ", ".join(f"{f.name}={{self.{f.name}!r}}" for f in fields)
+            + ')"'
+        ],
+    )
+
+
+def _frozen_get_del_attr(cls, fields):
+    # XXX: globals is modified on the first call to _create_fn, then
+    # the modified version is used in the second call.  Is this okay?
+    globals = {"cls": cls, "FrozenInstanceError": FrozenInstanceError}
+    if fields:
+        fields_str = "(" + ",".join(repr(f.name) for f in fields) + ",)"
+    else:
+        # Special case for the zero-length tuple.
+        fields_str = "()"
+    return (
+        _create_fn(
+            "__setattr__",
+            ("self", "name", "value"),
+            (
+                f"if type(self) is cls or name in {fields_str}:",
+                ' raise FrozenInstanceError(f"cannot assign to field {name!r}")',
+                f"super(cls, self).__setattr__(name, value)",
+            ),
+            globals=globals,
+        ),
+        _create_fn(
+            "__delattr__",
+            ("self", "name"),
+            (
+                f"if type(self) is cls or name in {fields_str}:",
+                ' raise FrozenInstanceError(f"cannot delete field {name!r}")',
+                f"super(cls, self).__delattr__(name)",
+            ),
+            globals=globals,
+        ),
+    )
+
+
+def _cmp_fn(name, op, self_tuple, other_tuple):
+    # Create a comparison function.  If the fields in the object are
+    # named 'x' and 'y', then self_tuple is the string
+    # '(self.x,self.y)' and other_tuple is the string
+    # '(other.x,other.y)'.
+
+    return _create_fn(
+        name,
+        ("self", "other"),
+        [
+            "if other.__class__ is self.__class__:",
+            f" return {self_tuple}{op}{other_tuple}",
+            "return NotImplemented",
+        ],
+    )
+
+
+def _hash_fn(fields):
+    self_tuple = _tuple_str("self", fields)
+    return _create_fn("__hash__", ("self",), [f"return hash({self_tuple})"])
+
+
+def _is_classvar(a_type, typing):
+    # This test uses a typing internal class, but it's the best way to
+    # test if this is a ClassVar.
+    return type(a_type) is typing._ClassVar
+
+
+def _is_initvar(a_type, dataclasses):
+    # The module we're checking against is the module we're
+    # currently in (dataclasses.py).
+    return a_type is dataclasses.InitVar
+
+
+def _is_type(annotation, cls, a_module, a_type, is_type_predicate):
+    # Given a type annotation string, does it refer to a_type in
+    # a_module?  For example, when checking that annotation denotes a
+    # ClassVar, then a_module is typing, and a_type is
+    # typing.ClassVar.
+
+    # It's possible to look up a_module given a_type, but it involves
+    # looking in sys.modules (again!), and seems like a waste since
+    # the caller already knows a_module.
+
+    # - annotation is a string type annotation
+    # - cls is the class that this annotation was found in
+    # - a_module is the module we want to match
+    # - a_type is the type in that module we want to match
+    # - is_type_predicate is a function called with (obj, a_module)
+    #   that determines if obj is of the desired type.
+
+    # Since this test does not do a local namespace lookup (and
+    # instead only a module (global) lookup), there are some things it
+    # gets wrong.
+
+    # With string annotations, cv0 will be detected as a ClassVar:
+    #   CV = ClassVar
+    #   @dataclass
+    #   class C0:
+    #     cv0: CV
+
+    # But in this example cv1 will not be detected as a ClassVar:
+    #   @dataclass
+    #   class C1:
+    #     CV = ClassVar
+    #     cv1: CV
+
+    # In C1, the code in this function (_is_type) will look up "CV" in
+    # the module and not find it, so it will not consider cv1 as a
+    # ClassVar.  This is a fairly obscure corner case, and the best
+    # way to fix it would be to eval() the string "CV" with the
+    # correct global and local namespaces.  However that would involve
+    # a eval() penalty for every single field of every dataclass
+    # that's defined.  It was judged not worth it.
+
+    match = _MODULE_IDENTIFIER_RE.match(annotation)
+    if match:
+        ns = None
+        module_name = match.group(1)
+        if not module_name:
+            # No module name, assume the class's module did
+            # "from dataclasses import InitVar".
+            ns = sys.modules.get(cls.__module__).__dict__
+        else:
+            # Look up module_name in the class's module.
+            module = sys.modules.get(cls.__module__)
+            if module and module.__dict__.get(module_name) is a_module:
+                ns = sys.modules.get(a_type.__module__).__dict__
+        if ns and is_type_predicate(ns.get(match.group(2)), a_module):
+            return True
+    return False
+
+
+def _get_field(cls, a_name, a_type):
+    # Return a Field object for this field name and type.  ClassVars
+    # and InitVars are also returned, but marked as such (see
+    # f._field_type).
+
+    # If the default value isn't derived from Field, then it's only a
+    # normal default value.  Convert it to a Field().
+    default = getattr(cls, a_name, MISSING)
+    if isinstance(default, Field):
+        f = default
+    else:
+        if isinstance(default, types.MemberDescriptorType):
+            # This is a field in __slots__, so it has no default value.
+            default = MISSING
+        f = field(default=default)
+
+    # Only at this point do we know the name and the type.  Set them.
+    f.name = a_name
+    f.type = a_type
+
+    # Assume it's a normal field until proven otherwise.  We're next
+    # going to decide if it's a ClassVar or InitVar, everything else
+    # is just a normal field.
+    f._field_type = _FIELD
+
+    # In addition to checking for actual types here, also check for
+    # string annotations.  get_type_hints() won't always work for us
+    # (see https://github.com/python/typing/issues/508 for example),
+    # plus it's expensive and would require an eval for every string
+    # annotation.  So, make a best effort to see if this is a ClassVar
+    # or InitVar using regex's and checking that the thing referenced
+    # is actually of the correct type.
+
+    # For the complete discussion, see https://bugs.python.org/issue33453
+
+    # If typing has not been imported, then it's impossible for any
+    # annotation to be a ClassVar.  So, only look for ClassVar if
+    # typing has been imported by any module (not necessarily cls's
+    # module).
+    typing = sys.modules.get("typing")
+    if typing:
+        if _is_classvar(a_type, typing) or (
+            isinstance(f.type, str) and _is_type(f.type, cls, typing, typing.ClassVar, _is_classvar)
+        ):
+            f._field_type = _FIELD_CLASSVAR
+
+    # If the type is InitVar, or if it's a matching string annotation,
+    # then it's an InitVar.
+    if f._field_type is _FIELD:
+        # The module we're checking against is the module we're
+        # currently in (dataclasses.py).
+        dataclasses = sys.modules[__name__]
+        if _is_initvar(a_type, dataclasses) or (
+            isinstance(f.type, str)
+            and _is_type(f.type, cls, dataclasses, dataclasses.InitVar, _is_initvar)
+        ):
+            f._field_type = _FIELD_INITVAR
+
+    # Validations for individual fields.  This is delayed until now,
+    # instead of in the Field() constructor, since only here do we
+    # know the field name, which allows for better error reporting.
+
+    # Special restrictions for ClassVar and InitVar.
+    if f._field_type in (_FIELD_CLASSVAR, _FIELD_INITVAR):
+        if f.default_factory is not MISSING:
+            raise TypeError(f"field {f.name} cannot have a " "default factory")
+        # Should I check for other field settings? default_factory
+        # seems the most serious to check for.  Maybe add others.  For
+        # example, how about init=False (or really,
+        # init=<not-the-default-init-value>)?  It makes no sense for
+        # ClassVar and InitVar to specify init=<anything>.
+
+    # For real fields, disallow mutable defaults for known types.
+    if f._field_type is _FIELD and isinstance(f.default, (list, dict, set)):
+        raise ValueError(
+            f"mutable default {type(f.default)} for field "
+            f"{f.name} is not allowed: use default_factory"
+        )
+
+    return f
+
+
+def _set_new_attribute(cls, name, value):
+    # Never overwrites an existing attribute.  Returns True if the
+    # attribute already exists.
+    if name in cls.__dict__:
+        return True
+    setattr(cls, name, value)
+    return False
+
+
+# Decide if/how we're going to create a hash function.  Key is
+# (unsafe_hash, eq, frozen, does-hash-exist).  Value is the action to
+# take.  The common case is to do nothing, so instead of providing a
+# function that is a no-op, use None to signify that.
+
+
+def _hash_set_none(cls, fields):
+    return None
+
+
+def _hash_add(cls, fields):
+    flds = [f for f in fields if (f.compare if f.hash is None else f.hash)]
+    return _hash_fn(flds)
+
+
+def _hash_exception(cls, fields):
+    # Raise an exception.
+    raise TypeError(f"Cannot overwrite attribute __hash__ " f"in class {cls.__name__}")
+
+
+#
+#                +-------------------------------------- unsafe_hash?
+#                |      +------------------------------- eq?
+#                |      |      +------------------------ frozen?
+#                |      |      |      +----------------  has-explicit-hash?
+#                |      |      |      |
+#                |      |      |      |        +-------  action
+#                |      |      |      |        |
+#                v      v      v      v        v
+_hash_action = {
+    (False, False, False, False): None,
+    (False, False, False, True): None,
+    (False, False, True, False): None,
+    (False, False, True, True): None,
+    (False, True, False, False): _hash_set_none,
+    (False, True, False, True): None,
+    (False, True, True, False): _hash_add,
+    (False, True, True, True): None,
+    (True, False, False, False): _hash_add,
+    (True, False, False, True): _hash_exception,
+    (True, False, True, False): _hash_add,
+    (True, False, True, True): _hash_exception,
+    (True, True, False, False): _hash_add,
+    (True, True, False, True): _hash_exception,
+    (True, True, True, False): _hash_add,
+    (True, True, True, True): _hash_exception,
+}
+# See https://bugs.python.org/issue32929#msg312829 for an if-statement
+# version of this table.
+
+
+def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen):
+    # Now that dicts retain insertion order, there's no reason to use
+    # an ordered dict.  I am leveraging that ordering here, because
+    # derived class fields overwrite base class fields, but the order
+    # is defined by the base class, which is found first.
+    fields = {}
+
+    setattr(cls, _PARAMS, _DataclassParams(init, repr, eq, order, unsafe_hash, frozen))
+
+    # Find our base classes in reverse MRO order, and exclude
+    # ourselves.  In reversed order so that more derived classes
+    # override earlier field definitions in base classes.  As long as
+    # we're iterating over them, see if any are frozen.
+    any_frozen_base = False
+    has_dataclass_bases = False
+    for b in cls.__mro__[-1:0:-1]:
+        # Only process classes that have been processed by our
+        # decorator.  That is, they have a _FIELDS attribute.
+        base_fields = getattr(b, _FIELDS, None)
+        if base_fields:
+            has_dataclass_bases = True
+            for f in base_fields.values():
+                fields[f.name] = f
+            if getattr(b, _PARAMS).frozen:
+                any_frozen_base = True
+
+    # Annotations that are defined in this class (not in base
+    # classes).  If __annotations__ isn't present, then this class
+    # adds no new annotations.  We use this to compute fields that are
+    # added by this class.
+    #
+    # Fields are found from cls_annotations, which is guaranteed to be
+    # ordered.  Default values are from class attributes, if a field
+    # has a default.  If the default value is a Field(), then it
+    # contains additional info beyond (and possibly including) the
+    # actual default value.  Pseudo-fields ClassVars and InitVars are
+    # included, despite the fact that they're not real fields.  That's
+    # dealt with later.
+    cls_annotations = cls.__dict__.get("__annotations__", {})
+
+    # Now find fields in our class.  While doing so, validate some
+    # things, and set the default values (as class attributes) where
+    # we can.
+    cls_fields = [_get_field(cls, name, type) for name, type in cls_annotations.items()]
+    for f in cls_fields:
+        fields[f.name] = f
+
+        # If the class attribute (which is the default value for this
+        # field) exists and is of type 'Field', replace it with the
+        # real default.  This is so that normal class introspection
+        # sees a real default value, not a Field.
+        if isinstance(getattr(cls, f.name, None), Field):
+            if f.default is MISSING:
+                # If there's no default, delete the class attribute.
+                # This happens if we specify field(repr=False), for
+                # example (that is, we specified a field object, but
+                # no default value).  Also if we're using a default
+                # factory.  The class attribute should not be set at
+                # all in the post-processed class.
+                delattr(cls, f.name)
+            else:
+                setattr(cls, f.name, f.default)
+
+    # Do we have any Field members that don't also have annotations?
+    for name, value in cls.__dict__.items():
+        if isinstance(value, Field) and not name in cls_annotations:
+            raise TypeError(f"{name!r} is a field but has no type annotation")
+
+    # Check rules that apply if we are derived from any dataclasses.
+    if has_dataclass_bases:
+        # Raise an exception if any of our bases are frozen, but we're not.
+        if any_frozen_base and not frozen:
+            raise TypeError("cannot inherit non-frozen dataclass from a " "frozen one")
+
+        # Raise an exception if we're frozen, but none of our bases are.
+        if not any_frozen_base and frozen:
+            raise TypeError("cannot inherit frozen dataclass from a " "non-frozen one")
+
+    # Remember all of the fields on our class (including bases).  This
+    # also marks this class as being a dataclass.
+    setattr(cls, _FIELDS, fields)
+
+    # Was this class defined with an explicit __hash__?  Note that if
+    # __eq__ is defined in this class, then python will automatically
+    # set __hash__ to None.  This is a heuristic, as it's possible
+    # that such a __hash__ == None was not auto-generated, but it
+    # close enough.
+    class_hash = cls.__dict__.get("__hash__", MISSING)
+    has_explicit_hash = not (
+        class_hash is MISSING or (class_hash is None and "__eq__" in cls.__dict__)
+    )
+
+    # If we're generating ordering methods, we must be generating the
+    # eq methods.
+    if order and not eq:
+        raise ValueError("eq must be true if order is true")
+
+    if init:
+        # Does this class have a post-init function?
+        has_post_init = hasattr(cls, _POST_INIT_NAME)
+
+        # Include InitVars and regular fields (so, not ClassVars).
+        flds = [f for f in fields.values() if f._field_type in (_FIELD, _FIELD_INITVAR)]
+        _set_new_attribute(
+            cls,
+            "__init__",
+            _init_fn(
+                flds,
+                frozen,
+                has_post_init,
+                # The name to use for the "self"
+                # param in __init__.  Use "self"
+                # if possible.
+                "__dataclass_self__" if "self" in fields else "self",
+            ),
+        )
+
+    # Get the fields as a list, and include only real fields.  This is
+    # used in all of the following methods.
+    field_list = [f for f in fields.values() if f._field_type is _FIELD]
+
+    if repr:
+        flds = [f for f in field_list if f.repr]
+        _set_new_attribute(cls, "__repr__", _repr_fn(flds))
+
+    if eq:
+        # Create _eq__ method.  There's no need for a __ne__ method,
+        # since python will call __eq__ and negate it.
+        flds = [f for f in field_list if f.compare]
+        self_tuple = _tuple_str("self", flds)
+        other_tuple = _tuple_str("other", flds)
+        _set_new_attribute(cls, "__eq__", _cmp_fn("__eq__", "==", self_tuple, other_tuple))
+
+    if order:
+        # Create and set the ordering methods.
+        flds = [f for f in field_list if f.compare]
+        self_tuple = _tuple_str("self", flds)
+        other_tuple = _tuple_str("other", flds)
+        for name, op in [("__lt__", "<"), ("__le__", "<="), ("__gt__", ">"), ("__ge__", ">=")]:
+            if _set_new_attribute(cls, name, _cmp_fn(name, op, self_tuple, other_tuple)):
+                raise TypeError(
+                    f"Cannot overwrite attribute {name} "
+                    f"in class {cls.__name__}. Consider using "
+                    "functools.total_ordering"
+                )
+
+    if frozen:
+        for fn in _frozen_get_del_attr(cls, field_list):
+            if _set_new_attribute(cls, fn.__name__, fn):
+                raise TypeError(
+                    f"Cannot overwrite attribute {fn.__name__} " f"in class {cls.__name__}"
+                )
+
+    # Decide if/how we're going to create a hash function.
+    hash_action = _hash_action[bool(unsafe_hash), bool(eq), bool(frozen), has_explicit_hash]
+    if hash_action:
+        # No need to call _set_new_attribute here, since by the time
+        # we're here the overwriting is unconditional.
+        cls.__hash__ = hash_action(cls, field_list)
+
+    if not getattr(cls, "__doc__"):
+        # Create a class doc-string.
+        cls.__doc__ = cls.__name__ + str(inspect.signature(cls)).replace(" -> None", "")
+
+    return cls
+
+
+# _cls should never be specified by keyword, so start it with an
+# underscore.  The presence of _cls is used to detect if this
+# decorator is being called with parameters or not.
+def dataclass(
+    _cls=None, *, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False
+):
+    """Returns the same class as was passed in, with dunder methods
+    added based on the fields defined in the class.
+    Examines PEP 526 __annotations__ to determine fields.
+    If init is true, an __init__() method is added to the class. If
+    repr is true, a __repr__() method is added. If order is true, rich
+    comparison dunder methods are added. If unsafe_hash is true, a
+    __hash__() method function is added. If frozen is true, fields may
+    not be assigned to after instance creation.
+    """
+
+    def wrap(cls):
+        return _process_class(cls, init, repr, eq, order, unsafe_hash, frozen)
+
+    # See if we're being called as @dataclass or @dataclass().
+    if _cls is None:
+        # We're called with parens.
+        return wrap
+
+    # We're called as @dataclass without parens.
+    return wrap(_cls)
+
+
+def fields(class_or_instance):
+    """Return a tuple describing the fields of this dataclass.
+    Accepts a dataclass or an instance of one. Tuple elements are of
+    type Field.
+    """
+
+    # Might it be worth caching this, per class?
+    try:
+        fields = getattr(class_or_instance, _FIELDS)
+    except AttributeError:
+        raise TypeError("must be called with a dataclass type or instance")
+
+    # Exclude pseudo-fields.  Note that fields is sorted by insertion
+    # order, so the order of the tuple is as the fields were defined.
+    return tuple(f for f in fields.values() if f._field_type is _FIELD)
+
+
+def _is_dataclass_instance(obj):
+    """Returns True if obj is an instance of a dataclass."""
+    return not isinstance(obj, type) and hasattr(obj, _FIELDS)
+
+
+def is_dataclass(obj):
+    """Returns True if obj is a dataclass or an instance of a
+    dataclass."""
+    return hasattr(obj, _FIELDS)
+
+
+def asdict(obj, *, dict_factory=dict):
+    """Return the fields of a dataclass instance as a new dictionary mapping
+    field names to field values.
+    Example usage:
+      @dataclass
+      class C:
+          x: int
+          y: int
+      c = C(1, 2)
+      assert asdict(c) == {'x': 1, 'y': 2}
+    If given, 'dict_factory' will be used instead of built-in dict.
+    The function applies recursively to field values that are
+    dataclass instances. This will also look into built-in containers:
+    tuples, lists, and dicts.
+    """
+    if not _is_dataclass_instance(obj):
+        raise TypeError("asdict() should be called on dataclass instances")
+    return _asdict_inner(obj, dict_factory)
+
+
+def _asdict_inner(obj, dict_factory):
+    if _is_dataclass_instance(obj):
+        result = []
+        for f in fields(obj):
+            value = _asdict_inner(getattr(obj, f.name), dict_factory)
+            result.append((f.name, value))
+        return dict_factory(result)
+    elif isinstance(obj, (list, tuple)):
+        return type(obj)(_asdict_inner(v, dict_factory) for v in obj)
+    elif isinstance(obj, dict):
+        return type(obj)(
+            (_asdict_inner(k, dict_factory), _asdict_inner(v, dict_factory)) for k, v in obj.items()
+        )
+    else:
+        return copy.deepcopy(obj)
+
+
+def astuple(obj, *, tuple_factory=tuple):
+    """Return the fields of a dataclass instance as a new tuple of field values.
+    Example usage::
+      @dataclass
+      class C:
+          x: int
+          y: int
+    c = C(1, 2)
+    assert astuple(c) == (1, 2)
+    If given, 'tuple_factory' will be used instead of built-in tuple.
+    The function applies recursively to field values that are
+    dataclass instances. This will also look into built-in containers:
+    tuples, lists, and dicts.
+    """
+
+    if not _is_dataclass_instance(obj):
+        raise TypeError("astuple() should be called on dataclass instances")
+    return _astuple_inner(obj, tuple_factory)
+
+
+def _astuple_inner(obj, tuple_factory):
+    if _is_dataclass_instance(obj):
+        result = []
+        for f in fields(obj):
+            value = _astuple_inner(getattr(obj, f.name), tuple_factory)
+            result.append(value)
+        return tuple_factory(result)
+    elif isinstance(obj, (list, tuple)):
+        return type(obj)(_astuple_inner(v, tuple_factory) for v in obj)
+    elif isinstance(obj, dict):
+        return type(obj)(
+            (_astuple_inner(k, tuple_factory), _astuple_inner(v, tuple_factory))
+            for k, v in obj.items()
+        )
+    else:
+        return copy.deepcopy(obj)
+
+
+def make_dataclass(
+    cls_name,
+    fields,
+    *,
+    bases=(),
+    namespace=None,
+    init=True,
+    repr=True,
+    eq=True,
+    order=False,
+    unsafe_hash=False,
+    frozen=False,
+):
+    """Return a new dynamically created dataclass.
+    The dataclass name will be 'cls_name'.  'fields' is an iterable
+    of either (name), (name, type) or (name, type, Field) objects. If type is
+    omitted, use the string 'typing.Any'.  Field objects are created by
+    the equivalent of calling 'field(name, type [, Field-info])'.
+      C = make_dataclass('C', ['x', ('y', int), ('z', int, field(init=False))], bases=(Base,))
+    is equivalent to:
+      @dataclass
+      class C(Base):
+          x: 'typing.Any'
+          y: int
+          z: int = field(init=False)
+    For the bases and namespace parameters, see the builtin type() function.
+    The parameters init, repr, eq, order, unsafe_hash, and frozen are passed to
+    dataclass().
+    """
+
+    if namespace is None:
+        namespace = {}
+    else:
+        # Copy namespace since we're going to mutate it.
+        namespace = namespace.copy()
+
+    # While we're looking through the field names, validate that they
+    # are identifiers, are not keywords, and not duplicates.
+    seen = set()
+    anns = {}
+    for item in fields:
+        if isinstance(item, str):
+            name = item
+            tp = "typing.Any"
+        elif len(item) == 2:
+            (
+                name,
+                tp,
+            ) = item
+        elif len(item) == 3:
+            name, tp, spec = item
+            namespace[name] = spec
+        else:
+            raise TypeError(f"Invalid field: {item!r}")
+
+        if not isinstance(name, str) or not name.isidentifier():
+            raise TypeError(f"Field names must be valid identifiers: {name!r}")
+        if keyword.iskeyword(name):
+            raise TypeError(f"Field names must not be keywords: {name!r}")
+        if name in seen:
+            raise TypeError(f"Field name duplicated: {name!r}")
+
+        seen.add(name)
+        anns[name] = tp
+
+    namespace["__annotations__"] = anns
+    # We use `types.new_class()` instead of simply `type()` to allow dynamic creation
+    # of generic dataclassses.
+    cls = types.new_class(cls_name, bases, {}, lambda ns: ns.update(namespace))
+    return dataclass(
+        cls, init=init, repr=repr, eq=eq, order=order, unsafe_hash=unsafe_hash, frozen=frozen
+    )
+
+
+def replace(obj, **changes):
+    """Return a new object replacing specified fields with new values.
+    This is especially useful for frozen classes.  Example usage:
+      @dataclass(frozen=True)
+      class C:
+          x: int
+          y: int
+      c = C(1, 2)
+      c1 = replace(c, x=3)
+      assert c1.x == 3 and c1.y == 2
+    """
+
+    # We're going to mutate 'changes', but that's okay because it's a
+    # new dict, even if called with 'replace(obj, **my_changes)'.
+
+    if not _is_dataclass_instance(obj):
+        raise TypeError("replace() should be called on dataclass instances")
+
+    # It's an error to have init=False fields in 'changes'.
+    # If a field is not in 'changes', read its value from the provided obj.
+
+    for f in getattr(obj, _FIELDS).values():
+        if not f.init:
+            # Error if this field is specified in changes.
+            if f.name in changes:
+                raise ValueError(
+                    f"field {f.name} is declared with "
+                    "init=False, it cannot be specified with "
+                    "replace()"
+                )
+            continue
+
+        if f.name not in changes:
+            changes[f.name] = getattr(obj, f.name)
+
+    # Create the new object, which calls __init__() and
+    # __post_init__() (if defined), using all of the init fields we've
+    # added and/or left in 'changes'.  If there are values supplied in
+    # changes that aren't fields, this will correctly raise a
+    # TypeError.
+    return obj.__class__(**changes)
diff --git a/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/LICENSE b/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/LICENSE
new file mode 100644
index 0000000..e859590
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Taneli Hukkinen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/__init__.py b/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/__init__.py
new file mode 100644
index 0000000..5b9f247
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/__init__.py
@@ -0,0 +1,6 @@
+"""A lil' TOML parser."""
+
+__all__ = ("loads", "load", "TOMLDecodeError")
+__version__ = "1.2.0"  # DO NOT EDIT THIS LINE MANUALLY. LET bump2version UTILITY DO IT
+
+from ._parser import TOMLDecodeError, load, loads
diff --git a/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/_parser.py b/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/_parser.py
new file mode 100644
index 0000000..156848f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/_parser.py
@@ -0,0 +1,650 @@
+import string
+import warnings
+from types import MappingProxyType
+from typing import IO, Any, Callable, Dict, FrozenSet, Iterable, NamedTuple, Optional, Tuple
+
+from ._re import (
+    RE_DATETIME,
+    RE_LOCALTIME,
+    RE_NUMBER,
+    match_to_datetime,
+    match_to_localtime,
+    match_to_number,
+)
+
+ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
+
+# Neither of these sets include quotation mark or backslash. They are
+# currently handled as separate cases in the parser functions.
+ILLEGAL_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t")
+ILLEGAL_MULTILINE_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t\n\r")
+
+ILLEGAL_LITERAL_STR_CHARS = ILLEGAL_BASIC_STR_CHARS
+ILLEGAL_MULTILINE_LITERAL_STR_CHARS = ASCII_CTRL - frozenset("\t\n")
+
+ILLEGAL_COMMENT_CHARS = ILLEGAL_BASIC_STR_CHARS
+
+TOML_WS = frozenset(" \t")
+TOML_WS_AND_NEWLINE = TOML_WS | frozenset("\n")
+BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + "-_")
+KEY_INITIAL_CHARS = BARE_KEY_CHARS | frozenset("\"'")
+HEXDIGIT_CHARS = frozenset(string.hexdigits)
+
+BASIC_STR_ESCAPE_REPLACEMENTS = MappingProxyType(
+    {
+        "\\b": "\u0008",  # backspace
+        "\\t": "\u0009",  # tab
+        "\\n": "\u000A",  # linefeed
+        "\\f": "\u000C",  # form feed
+        "\\r": "\u000D",  # carriage return
+        '\\"': "\u0022",  # quote
+        "\\\\": "\u005C",  # backslash
+    }
+)
+
+# Type annotations
+ParseFloat = Callable[[str], Any]
+Key = Tuple[str, ...]
+Pos = int
+
+
+class TOMLDecodeError(ValueError):
+    """An error raised if a document is not valid TOML."""
+
+
+def load(fp: IO, *, parse_float: ParseFloat = float) -> Dict[str, Any]:
+    """Parse TOML from a file object."""
+    s = fp.read()
+    if isinstance(s, bytes):
+        s = s.decode()
+    else:
+        warnings.warn(
+            "Text file object support is deprecated in favor of binary file objects."
+            ' Use `open("foo.toml", "rb")` to open the file in binary mode.',
+            DeprecationWarning,
+        )
+    return loads(s, parse_float=parse_float)
+
+
+def loads(s: str, *, parse_float: ParseFloat = float) -> Dict[str, Any]:  # noqa: C901
+    """Parse TOML from a string."""
+
+    # The spec allows converting "\r\n" to "\n", even in string
+    # literals. Let's do so to simplify parsing.
+    src = s.replace("\r\n", "\n")
+    pos = 0
+    out = Output(NestedDict(), Flags())
+    header: Key = ()
+
+    # Parse one statement at a time
+    # (typically means one line in TOML source)
+    while True:
+        # 1. Skip line leading whitespace
+        pos = skip_chars(src, pos, TOML_WS)
+
+        # 2. Parse rules. Expect one of the following:
+        #    - end of file
+        #    - end of line
+        #    - comment
+        #    - key/value pair
+        #    - append dict to list (and move to its namespace)
+        #    - create dict (and move to its namespace)
+        # Skip trailing whitespace when applicable.
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char == "\n":
+            pos += 1
+            continue
+        if char in KEY_INITIAL_CHARS:
+            pos = key_value_rule(src, pos, out, header, parse_float)
+            pos = skip_chars(src, pos, TOML_WS)
+        elif char == "[":
+            try:
+                second_char: Optional[str] = src[pos + 1]
+            except IndexError:
+                second_char = None
+            if second_char == "[":
+                pos, header = create_list_rule(src, pos, out)
+            else:
+                pos, header = create_dict_rule(src, pos, out)
+            pos = skip_chars(src, pos, TOML_WS)
+        elif char != "#":
+            raise suffixed_err(src, pos, "Invalid statement")
+
+        # 3. Skip comment
+        pos = skip_comment(src, pos)
+
+        # 4. Expect end of line or end of file
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char != "\n":
+            raise suffixed_err(src, pos, "Expected newline or end of document after a statement")
+        pos += 1
+
+    return out.data.dict
+
+
+class Flags:
+    """Flags that map to parsed keys/namespaces."""
+
+    # Marks an immutable namespace (inline array or inline table).
+    FROZEN = 0
+    # Marks a nest that has been explicitly created and can no longer
+    # be opened using the "[table]" syntax.
+    EXPLICIT_NEST = 1
+
+    def __init__(self) -> None:
+        self._flags: Dict[str, dict] = {}
+
+    def unset_all(self, key: Key) -> None:
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return
+            cont = cont[k]["nested"]
+        cont.pop(key[-1], None)
+
+    def set_for_relative_key(self, head_key: Key, rel_key: Key, flag: int) -> None:
+        cont = self._flags
+        for k in head_key:
+            if k not in cont:
+                cont[k] = {"flags": set(), "recursive_flags": set(), "nested": {}}
+            cont = cont[k]["nested"]
+        for k in rel_key:
+            if k in cont:
+                cont[k]["flags"].add(flag)
+            else:
+                cont[k] = {"flags": {flag}, "recursive_flags": set(), "nested": {}}
+            cont = cont[k]["nested"]
+
+    def set(self, key: Key, flag: int, *, recursive: bool) -> None:  # noqa: A003
+        cont = self._flags
+        key_parent, key_stem = key[:-1], key[-1]
+        for k in key_parent:
+            if k not in cont:
+                cont[k] = {"flags": set(), "recursive_flags": set(), "nested": {}}
+            cont = cont[k]["nested"]
+        if key_stem not in cont:
+            cont[key_stem] = {"flags": set(), "recursive_flags": set(), "nested": {}}
+        cont[key_stem]["recursive_flags" if recursive else "flags"].add(flag)
+
+    def is_(self, key: Key, flag: int) -> bool:
+        if not key:
+            return False  # document root has no flags
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return False
+            inner_cont = cont[k]
+            if flag in inner_cont["recursive_flags"]:
+                return True
+            cont = inner_cont["nested"]
+        key_stem = key[-1]
+        if key_stem in cont:
+            cont = cont[key_stem]
+            return flag in cont["flags"] or flag in cont["recursive_flags"]
+        return False
+
+
+class NestedDict:
+    def __init__(self) -> None:
+        # The parsed content of the TOML document
+        self.dict: Dict[str, Any] = {}
+
+    def get_or_create_nest(
+        self,
+        key: Key,
+        *,
+        access_lists: bool = True,
+    ) -> dict:
+        cont: Any = self.dict
+        for k in key:
+            if k not in cont:
+                cont[k] = {}
+            cont = cont[k]
+            if access_lists and isinstance(cont, list):
+                cont = cont[-1]
+            if not isinstance(cont, dict):
+                raise KeyError("There is no nest behind this key")
+        return cont
+
+    def append_nest_to_list(self, key: Key) -> None:
+        cont = self.get_or_create_nest(key[:-1])
+        last_key = key[-1]
+        if last_key in cont:
+            list_ = cont[last_key]
+            if not isinstance(list_, list):
+                raise KeyError("An object other than list found behind this key")
+            list_.append({})
+        else:
+            cont[last_key] = [{}]
+
+
+class Output(NamedTuple):
+    data: NestedDict
+    flags: Flags
+
+
+def skip_chars(src: str, pos: Pos, chars: Iterable[str]) -> Pos:
+    try:
+        while src[pos] in chars:
+            pos += 1
+    except IndexError:
+        pass
+    return pos
+
+
+def skip_until(
+    src: str,
+    pos: Pos,
+    expect: str,
+    *,
+    error_on: FrozenSet[str],
+    error_on_eof: bool,
+) -> Pos:
+    try:
+        new_pos = src.index(expect, pos)
+    except ValueError:
+        new_pos = len(src)
+        if error_on_eof:
+            raise suffixed_err(src, new_pos, f'Expected "{expect!r}"')
+
+    if not error_on.isdisjoint(src[pos:new_pos]):
+        while src[pos] not in error_on:
+            pos += 1
+        raise suffixed_err(src, pos, f'Found invalid character "{src[pos]!r}"')
+    return new_pos
+
+
+def skip_comment(src: str, pos: Pos) -> Pos:
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char == "#":
+        return skip_until(src, pos + 1, "\n", error_on=ILLEGAL_COMMENT_CHARS, error_on_eof=False)
+    return pos
+
+
+def skip_comments_and_array_ws(src: str, pos: Pos) -> Pos:
+    while True:
+        pos_before_skip = pos
+        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        pos = skip_comment(src, pos)
+        if pos == pos_before_skip:
+            return pos
+
+
+def create_dict_rule(src: str, pos: Pos, out: Output) -> Tuple[Pos, Key]:
+    pos += 1  # Skip "["
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, key = parse_key(src, pos)
+
+    if out.flags.is_(key, Flags.EXPLICIT_NEST) or out.flags.is_(key, Flags.FROZEN):
+        raise suffixed_err(src, pos, f"Can not declare {key} twice")
+    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.get_or_create_nest(key)
+    except KeyError:
+        raise suffixed_err(src, pos, "Can not overwrite a value")
+
+    if not src.startswith("]", pos):
+        raise suffixed_err(src, pos, 'Expected "]" at the end of a table declaration')
+    return pos + 1, key
+
+
+def create_list_rule(src: str, pos: Pos, out: Output) -> Tuple[Pos, Key]:
+    pos += 2  # Skip "[["
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, key = parse_key(src, pos)
+
+    if out.flags.is_(key, Flags.FROZEN):
+        raise suffixed_err(src, pos, f"Can not mutate immutable namespace {key}")
+    # Free the namespace now that it points to another empty list item...
+    out.flags.unset_all(key)
+    # ...but this key precisely is still prohibited from table declaration
+    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.append_nest_to_list(key)
+    except KeyError:
+        raise suffixed_err(src, pos, "Can not overwrite a value")
+
+    if not src.startswith("]]", pos):
+        raise suffixed_err(src, pos, 'Expected "]]" at the end of an array declaration')
+    return pos + 2, key
+
+
+def key_value_rule(src: str, pos: Pos, out: Output, header: Key, parse_float: ParseFloat) -> Pos:
+    pos, key, value = parse_key_value_pair(src, pos, parse_float)
+    key_parent, key_stem = key[:-1], key[-1]
+    abs_key_parent = header + key_parent
+
+    if out.flags.is_(abs_key_parent, Flags.FROZEN):
+        raise suffixed_err(src, pos, f"Can not mutate immutable namespace {abs_key_parent}")
+    # Containers in the relative path can't be opened with the table syntax after this
+    out.flags.set_for_relative_key(header, key, Flags.EXPLICIT_NEST)
+    try:
+        nest = out.data.get_or_create_nest(abs_key_parent)
+    except KeyError:
+        raise suffixed_err(src, pos, "Can not overwrite a value")
+    if key_stem in nest:
+        raise suffixed_err(src, pos, "Can not overwrite a value")
+    # Mark inline table and array namespaces recursively immutable
+    if isinstance(value, (dict, list)):
+        out.flags.set(header + key, Flags.FROZEN, recursive=True)
+    nest[key_stem] = value
+    return pos
+
+
+def parse_key_value_pair(src: str, pos: Pos, parse_float: ParseFloat) -> Tuple[Pos, Key, Any]:
+    pos, key = parse_key(src, pos)
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char != "=":
+        raise suffixed_err(src, pos, 'Expected "=" after a key in a key/value pair')
+    pos += 1
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, value = parse_value(src, pos, parse_float)
+    return pos, key, value
+
+
+def parse_key(src: str, pos: Pos) -> Tuple[Pos, Key]:
+    pos, key_part = parse_key_part(src, pos)
+    key: Key = (key_part,)
+    pos = skip_chars(src, pos, TOML_WS)
+    while True:
+        try:
+            char: Optional[str] = src[pos]
+        except IndexError:
+            char = None
+        if char != ".":
+            return pos, key
+        pos += 1
+        pos = skip_chars(src, pos, TOML_WS)
+        pos, key_part = parse_key_part(src, pos)
+        key += (key_part,)
+        pos = skip_chars(src, pos, TOML_WS)
+
+
+def parse_key_part(src: str, pos: Pos) -> Tuple[Pos, str]:
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char in BARE_KEY_CHARS:
+        start_pos = pos
+        pos = skip_chars(src, pos, BARE_KEY_CHARS)
+        return pos, src[start_pos:pos]
+    if char == "'":
+        return parse_literal_str(src, pos)
+    if char == '"':
+        return parse_one_line_basic_str(src, pos)
+    raise suffixed_err(src, pos, "Invalid initial character for a key part")
+
+
+def parse_one_line_basic_str(src: str, pos: Pos) -> Tuple[Pos, str]:
+    pos += 1
+    return parse_basic_str(src, pos, multiline=False)
+
+
+def parse_array(src: str, pos: Pos, parse_float: ParseFloat) -> Tuple[Pos, list]:
+    pos += 1
+    array: list = []
+
+    pos = skip_comments_and_array_ws(src, pos)
+    if src.startswith("]", pos):
+        return pos + 1, array
+    while True:
+        pos, val = parse_value(src, pos, parse_float)
+        array.append(val)
+        pos = skip_comments_and_array_ws(src, pos)
+
+        c = src[pos : pos + 1]
+        if c == "]":
+            return pos + 1, array
+        if c != ",":
+            raise suffixed_err(src, pos, "Unclosed array")
+        pos += 1
+
+        pos = skip_comments_and_array_ws(src, pos)
+        if src.startswith("]", pos):
+            return pos + 1, array
+
+
+def parse_inline_table(src: str, pos: Pos, parse_float: ParseFloat) -> Tuple[Pos, dict]:
+    pos += 1
+    nested_dict = NestedDict()
+    flags = Flags()
+
+    pos = skip_chars(src, pos, TOML_WS)
+    if src.startswith("}", pos):
+        return pos + 1, nested_dict.dict
+    while True:
+        pos, key, value = parse_key_value_pair(src, pos, parse_float)
+        key_parent, key_stem = key[:-1], key[-1]
+        if flags.is_(key, Flags.FROZEN):
+            raise suffixed_err(src, pos, f"Can not mutate immutable namespace {key}")
+        try:
+            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
+        except KeyError:
+            raise suffixed_err(src, pos, "Can not overwrite a value")
+        if key_stem in nest:
+            raise suffixed_err(src, pos, f'Duplicate inline table key "{key_stem}"')
+        nest[key_stem] = value
+        pos = skip_chars(src, pos, TOML_WS)
+        c = src[pos : pos + 1]
+        if c == "}":
+            return pos + 1, nested_dict.dict
+        if c != ",":
+            raise suffixed_err(src, pos, "Unclosed inline table")
+        if isinstance(value, (dict, list)):
+            flags.set(key, Flags.FROZEN, recursive=True)
+        pos += 1
+        pos = skip_chars(src, pos, TOML_WS)
+
+
+def parse_basic_str_escape(  # noqa: C901
+    src: str, pos: Pos, *, multiline: bool = False
+) -> Tuple[Pos, str]:
+    escape_id = src[pos : pos + 2]
+    pos += 2
+    if multiline and escape_id in {"\\ ", "\\\t", "\\\n"}:
+        # Skip whitespace until next non-whitespace character or end of
+        # the doc. Error if non-whitespace is found before newline.
+        if escape_id != "\\\n":
+            pos = skip_chars(src, pos, TOML_WS)
+            try:
+                char = src[pos]
+            except IndexError:
+                return pos, ""
+            if char != "\n":
+                raise suffixed_err(src, pos, 'Unescaped "\\" in a string')
+            pos += 1
+        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        return pos, ""
+    if escape_id == "\\u":
+        return parse_hex_char(src, pos, 4)
+    if escape_id == "\\U":
+        return parse_hex_char(src, pos, 8)
+    try:
+        return pos, BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
+    except KeyError:
+        if len(escape_id) != 2:
+            raise suffixed_err(src, pos, "Unterminated string")
+        raise suffixed_err(src, pos, 'Unescaped "\\" in a string')
+
+
+def parse_basic_str_escape_multiline(src: str, pos: Pos) -> Tuple[Pos, str]:
+    return parse_basic_str_escape(src, pos, multiline=True)
+
+
+def parse_hex_char(src: str, pos: Pos, hex_len: int) -> Tuple[Pos, str]:
+    hex_str = src[pos : pos + hex_len]
+    if len(hex_str) != hex_len or not HEXDIGIT_CHARS.issuperset(hex_str):
+        raise suffixed_err(src, pos, "Invalid hex value")
+    pos += hex_len
+    hex_int = int(hex_str, 16)
+    if not is_unicode_scalar_value(hex_int):
+        raise suffixed_err(src, pos, "Escaped character is not a Unicode scalar value")
+    return pos, chr(hex_int)
+
+
+def parse_literal_str(src: str, pos: Pos) -> Tuple[Pos, str]:
+    pos += 1  # Skip starting apostrophe
+    start_pos = pos
+    pos = skip_until(src, pos, "'", error_on=ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True)
+    return pos + 1, src[start_pos:pos]  # Skip ending apostrophe
+
+
+def parse_multiline_str(src: str, pos: Pos, *, literal: bool) -> Tuple[Pos, str]:
+    pos += 3
+    if src.startswith("\n", pos):
+        pos += 1
+
+    if literal:
+        delim = "'"
+        end_pos = skip_until(
+            src,
+            pos,
+            "'''",
+            error_on=ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
+            error_on_eof=True,
+        )
+        result = src[pos:end_pos]
+        pos = end_pos + 3
+    else:
+        delim = '"'
+        pos, result = parse_basic_str(src, pos, multiline=True)
+
+    # Add at maximum two extra apostrophes/quotes if the end sequence
+    # is 4 or 5 chars long instead of just 3.
+    if not src.startswith(delim, pos):
+        return pos, result
+    pos += 1
+    if not src.startswith(delim, pos):
+        return pos, result + delim
+    pos += 1
+    return pos, result + (delim * 2)
+
+
+def parse_basic_str(src: str, pos: Pos, *, multiline: bool) -> Tuple[Pos, str]:
+    if multiline:
+        error_on = ILLEGAL_MULTILINE_BASIC_STR_CHARS
+        parse_escapes = parse_basic_str_escape_multiline
+    else:
+        error_on = ILLEGAL_BASIC_STR_CHARS
+        parse_escapes = parse_basic_str_escape
+    result = ""
+    start_pos = pos
+    while True:
+        try:
+            char = src[pos]
+        except IndexError:
+            raise suffixed_err(src, pos, "Unterminated string")
+        if char == '"':
+            if not multiline:
+                return pos + 1, result + src[start_pos:pos]
+            if src.startswith('"""', pos):
+                return pos + 3, result + src[start_pos:pos]
+            pos += 1
+            continue
+        if char == "\\":
+            result += src[start_pos:pos]
+            pos, parsed_escape = parse_escapes(src, pos)
+            result += parsed_escape
+            start_pos = pos
+            continue
+        if char in error_on:
+            raise suffixed_err(src, pos, f'Illegal character "{char!r}"')
+        pos += 1
+
+
+def parse_value(src: str, pos: Pos, parse_float: ParseFloat) -> Tuple[Pos, Any]:  # noqa: C901
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+
+    # Basic strings
+    if char == '"':
+        if src.startswith('"""', pos):
+            return parse_multiline_str(src, pos, literal=False)
+        return parse_one_line_basic_str(src, pos)
+
+    # Literal strings
+    if char == "'":
+        if src.startswith("'''", pos):
+            return parse_multiline_str(src, pos, literal=True)
+        return parse_literal_str(src, pos)
+
+    # Booleans
+    if char == "t":
+        if src.startswith("true", pos):
+            return pos + 4, True
+    if char == "f":
+        if src.startswith("false", pos):
+            return pos + 5, False
+
+    # Dates and times
+    datetime_match = RE_DATETIME.match(src, pos)
+    if datetime_match:
+        try:
+            datetime_obj = match_to_datetime(datetime_match)
+        except ValueError:
+            raise suffixed_err(src, pos, "Invalid date or datetime")
+        return datetime_match.end(), datetime_obj
+    localtime_match = RE_LOCALTIME.match(src, pos)
+    if localtime_match:
+        return localtime_match.end(), match_to_localtime(localtime_match)
+
+    # Integers and "normal" floats.
+    # The regex will greedily match any type starting with a decimal
+    # char, so needs to be located after handling of dates and times.
+    number_match = RE_NUMBER.match(src, pos)
+    if number_match:
+        return number_match.end(), match_to_number(number_match, parse_float)
+
+    # Arrays
+    if char == "[":
+        return parse_array(src, pos, parse_float)
+
+    # Inline tables
+    if char == "{":
+        return parse_inline_table(src, pos, parse_float)
+
+    # Special floats
+    first_three = src[pos : pos + 3]
+    if first_three in {"inf", "nan"}:
+        return pos + 3, parse_float(first_three)
+    first_four = src[pos : pos + 4]
+    if first_four in {"-inf", "+inf", "-nan", "+nan"}:
+        return pos + 4, parse_float(first_four)
+
+    raise suffixed_err(src, pos, "Invalid value")
+
+
+def suffixed_err(src: str, pos: Pos, msg: str) -> TOMLDecodeError:
+    """Return a `TOMLDecodeError` where error message is suffixed with
+    coordinates in source."""
+
+    def coord_repr(src: str, pos: Pos) -> str:
+        if pos >= len(src):
+            return "end of document"
+        line = src.count("\n", 0, pos) + 1
+        if line == 1:
+            column = pos + 1
+        else:
+            column = pos - src.rindex("\n", 0, pos)
+        return f"line {line}, column {column}"
+
+    return TOMLDecodeError(f"{msg} (at {coord_repr(src, pos)})")
+
+
+def is_unicode_scalar_value(codepoint: int) -> bool:
+    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
diff --git a/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/_re.py b/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/_re.py
new file mode 100644
index 0000000..c8b06f0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/_re.py
@@ -0,0 +1,100 @@
+import re
+from datetime import date, datetime, time, timedelta, timezone, tzinfo
+from functools import lru_cache
+from typing import TYPE_CHECKING, Any, Optional, Union
+
+if TYPE_CHECKING:
+    from tomli._parser import ParseFloat
+
+# E.g.
+# - 00:32:00.999999
+# - 00:32:00
+_TIME_RE_STR = r"([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.([0-9]{1,6})[0-9]*)?"
+
+RE_NUMBER = re.compile(
+    r"""
+0
+(?:
+    x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*   # hex
+    |
+    b[01](?:_?[01])*                 # bin
+    |
+    o[0-7](?:_?[0-7])*               # oct
+)
+|
+[+-]?(?:0|[1-9](?:_?[0-9])*)         # dec, integer part
+(?P<floatpart>
+    (?:\.[0-9](?:_?[0-9])*)?         # optional fractional part
+    (?:[eE][+-]?[0-9](?:_?[0-9])*)?  # optional exponent part
+)
+""",
+    flags=re.VERBOSE,
+)
+RE_LOCALTIME = re.compile(_TIME_RE_STR)
+RE_DATETIME = re.compile(
+    fr"""
+([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])  # date, e.g. 1988-10-27
+(?:
+    [T ]
+    {_TIME_RE_STR}
+    (?:(Z)|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))?     # optional time offset
+)?
+""",
+    flags=re.VERBOSE,
+)
+
+
+def match_to_datetime(match: "re.Match") -> Union[datetime, date]:
+    """Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`.
+
+    Raises ValueError if the match does not correspond to a valid date
+    or datetime.
+    """
+    (
+        year_str,
+        month_str,
+        day_str,
+        hour_str,
+        minute_str,
+        sec_str,
+        micros_str,
+        zulu_time,
+        offset_sign_str,
+        offset_hour_str,
+        offset_minute_str,
+    ) = match.groups()
+    year, month, day = int(year_str), int(month_str), int(day_str)
+    if hour_str is None:
+        return date(year, month, day)
+    hour, minute, sec = int(hour_str), int(minute_str), int(sec_str)
+    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
+    if offset_sign_str:
+        tz: Optional[tzinfo] = cached_tz(offset_hour_str, offset_minute_str, offset_sign_str)
+    elif zulu_time:
+        tz = timezone.utc
+    else:  # local date-time
+        tz = None
+    return datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)
+
+
+@lru_cache(maxsize=None)
+def cached_tz(hour_str: str, minute_str: str, sign_str: str) -> timezone:
+    sign = 1 if sign_str == "+" else -1
+    return timezone(
+        timedelta(
+            hours=sign * int(hour_str),
+            minutes=sign * int(minute_str),
+        )
+    )
+
+
+def match_to_localtime(match: "re.Match") -> time:
+    hour_str, minute_str, sec_str, micros_str = match.groups()
+    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
+    return time(int(hour_str), int(minute_str), int(sec_str), micros)
+
+
+def match_to_number(match: "re.Match", parse_float: "ParseFloat") -> Any:
+    if match.group("floatpart"):
+        return parse_float(match.group())
+    return int(match.group(), 0)
diff --git a/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/py.typed b/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/py.typed
new file mode 100644
index 0000000..7632ecf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/_vendored/tomli/py.typed
@@ -0,0 +1 @@
+# Marker file for PEP 561
diff --git a/myenv/lib/python3.9/site-packages/isort/_version.py b/myenv/lib/python3.9/site-packages/isort/_version.py
new file mode 100644
index 0000000..0561ca3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/_version.py
@@ -0,0 +1 @@
+__version__ = "5.10.1"
diff --git a/myenv/lib/python3.9/site-packages/isort/api.py b/myenv/lib/python3.9/site-packages/isort/api.py
new file mode 100644
index 0000000..636f117
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/api.py
@@ -0,0 +1,651 @@
+__all__ = (
+    "ImportKey",
+    "check_code_string",
+    "check_file",
+    "check_stream",
+    "find_imports_in_code",
+    "find_imports_in_file",
+    "find_imports_in_paths",
+    "find_imports_in_stream",
+    "place_module",
+    "place_module_with_reason",
+    "sort_code_string",
+    "sort_file",
+    "sort_stream",
+)
+
+import contextlib
+import shutil
+import sys
+from enum import Enum
+from io import StringIO
+from itertools import chain
+from pathlib import Path
+from typing import Any, Iterator, Optional, Set, TextIO, Union, cast
+from warnings import warn
+
+from isort import core
+
+from . import files, identify, io
+from .exceptions import (
+    ExistingSyntaxErrors,
+    FileSkipComment,
+    FileSkipSetting,
+    IntroducedSyntaxErrors,
+)
+from .format import ask_whether_to_apply_changes_to_file, create_terminal_printer, show_unified_diff
+from .io import Empty, File
+from .place import module as place_module  # noqa: F401
+from .place import module_with_reason as place_module_with_reason  # noqa: F401
+from .settings import CYTHON_EXTENSIONS, DEFAULT_CONFIG, Config
+
+
+class ImportKey(Enum):
+    """Defines how to key an individual import, generally for deduping.
+
+    Import keys are defined from less to more specific:
+
+    from x.y import z as a
+    ______| |        |    |
+       |    |        |    |
+    PACKAGE |        |    |
+    ________|        |    |
+          |          |    |
+        MODULE       |    |
+    _________________|    |
+              |           |
+           ATTRIBUTE      |
+    ______________________|
+                  |
+                ALIAS
+    """
+
+    PACKAGE = 1
+    MODULE = 2
+    ATTRIBUTE = 3
+    ALIAS = 4
+
+
+def sort_code_string(
+    code: str,
+    extension: Optional[str] = None,
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    disregard_skip: bool = False,
+    show_diff: Union[bool, TextIO] = False,
+    **config_kwargs: Any,
+) -> str:
+    """Sorts any imports within the provided code string, returning a new string with them sorted.
+
+    - **code**: The string of code with imports that need to be sorted.
+    - **extension**: The file extension that contains imports. Defaults to filename extension or py.
+    - **config**: The config object to use when sorting imports.
+    - **file_path**: The disk location where the code string was pulled from.
+    - **disregard_skip**: set to `True` if you want to ignore a skip set in config for this file.
+    - **show_diff**: If `True` the changes that need to be done will be printed to stdout, if a
+    TextIO stream is provided results will be written to it, otherwise no diff will be computed.
+    - ****config_kwargs**: Any config modifications.
+    """
+    input_stream = StringIO(code)
+    output_stream = StringIO()
+    config = _config(path=file_path, config=config, **config_kwargs)
+    sort_stream(
+        input_stream,
+        output_stream,
+        extension=extension,
+        config=config,
+        file_path=file_path,
+        disregard_skip=disregard_skip,
+        show_diff=show_diff,
+    )
+    output_stream.seek(0)
+    return output_stream.read()
+
+
+def check_code_string(
+    code: str,
+    show_diff: Union[bool, TextIO] = False,
+    extension: Optional[str] = None,
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    disregard_skip: bool = False,
+    **config_kwargs: Any,
+) -> bool:
+    """Checks the order, format, and categorization of imports within the provided code string.
+    Returns `True` if everything is correct, otherwise `False`.
+
+    - **code**: The string of code with imports that need to be sorted.
+    - **show_diff**: If `True` the changes that need to be done will be printed to stdout, if a
+    TextIO stream is provided results will be written to it, otherwise no diff will be computed.
+    - **extension**: The file extension that contains imports. Defaults to filename extension or py.
+    - **config**: The config object to use when sorting imports.
+    - **file_path**: The disk location where the code string was pulled from.
+    - **disregard_skip**: set to `True` if you want to ignore a skip set in config for this file.
+    - ****config_kwargs**: Any config modifications.
+    """
+    config = _config(path=file_path, config=config, **config_kwargs)
+    return check_stream(
+        StringIO(code),
+        show_diff=show_diff,
+        extension=extension,
+        config=config,
+        file_path=file_path,
+        disregard_skip=disregard_skip,
+    )
+
+
+def sort_stream(
+    input_stream: TextIO,
+    output_stream: TextIO,
+    extension: Optional[str] = None,
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    disregard_skip: bool = False,
+    show_diff: Union[bool, TextIO] = False,
+    raise_on_skip: bool = True,
+    **config_kwargs: Any,
+) -> bool:
+    """Sorts any imports within the provided code stream, outputs to the provided output stream.
+     Returns `True` if anything is modified from the original input stream, otherwise `False`.
+
+    - **input_stream**: The stream of code with imports that need to be sorted.
+    - **output_stream**: The stream where sorted imports should be written to.
+    - **extension**: The file extension that contains imports. Defaults to filename extension or py.
+    - **config**: The config object to use when sorting imports.
+    - **file_path**: The disk location where the code string was pulled from.
+    - **disregard_skip**: set to `True` if you want to ignore a skip set in config for this file.
+    - **show_diff**: If `True` the changes that need to be done will be printed to stdout, if a
+    TextIO stream is provided results will be written to it, otherwise no diff will be computed.
+    - ****config_kwargs**: Any config modifications.
+    """
+    extension = extension or (file_path and file_path.suffix.lstrip(".")) or "py"
+    if show_diff:
+        _output_stream = StringIO()
+        _input_stream = StringIO(input_stream.read())
+        changed = sort_stream(
+            input_stream=_input_stream,
+            output_stream=_output_stream,
+            extension=extension,
+            config=config,
+            file_path=file_path,
+            disregard_skip=disregard_skip,
+            raise_on_skip=raise_on_skip,
+            **config_kwargs,
+        )
+        _output_stream.seek(0)
+        _input_stream.seek(0)
+        show_unified_diff(
+            file_input=_input_stream.read(),
+            file_output=_output_stream.read(),
+            file_path=file_path,
+            output=output_stream if show_diff is True else cast(TextIO, show_diff),
+            color_output=config.color_output,
+        )
+        return changed
+
+    config = _config(path=file_path, config=config, **config_kwargs)
+    content_source = str(file_path or "Passed in content")
+    if not disregard_skip and file_path and config.is_skipped(file_path):
+        raise FileSkipSetting(content_source)
+
+    _internal_output = output_stream
+
+    if config.atomic:
+        try:
+            file_content = input_stream.read()
+            compile(file_content, content_source, "exec", 0, 1)
+        except SyntaxError:
+            if extension not in CYTHON_EXTENSIONS:
+                raise ExistingSyntaxErrors(content_source)
+            if config.verbose:
+                warn(
+                    f"{content_source} Python AST errors found but ignored due to Cython extension"
+                )
+        input_stream = StringIO(file_content)
+
+        if not output_stream.readable():
+            _internal_output = StringIO()
+
+    try:
+        changed = core.process(
+            input_stream,
+            _internal_output,
+            extension=extension,
+            config=config,
+            raise_on_skip=raise_on_skip,
+        )
+    except FileSkipComment:
+        raise FileSkipComment(content_source)
+
+    if config.atomic:
+        _internal_output.seek(0)
+        try:
+            compile(_internal_output.read(), content_source, "exec", 0, 1)
+            _internal_output.seek(0)
+        except SyntaxError:  # pragma: no cover
+            if extension not in CYTHON_EXTENSIONS:
+                raise IntroducedSyntaxErrors(content_source)
+            if config.verbose:
+                warn(
+                    f"{content_source} Python AST errors found but ignored due to Cython extension"
+                )
+        if _internal_output != output_stream:
+            output_stream.write(_internal_output.read())
+
+    return changed
+
+
+def check_stream(
+    input_stream: TextIO,
+    show_diff: Union[bool, TextIO] = False,
+    extension: Optional[str] = None,
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    disregard_skip: bool = False,
+    **config_kwargs: Any,
+) -> bool:
+    """Checks any imports within the provided code stream, returning `False` if any unsorted or
+    incorrectly imports are found or `True` if no problems are identified.
+
+    - **input_stream**: The stream of code with imports that need to be sorted.
+    - **show_diff**: If `True` the changes that need to be done will be printed to stdout, if a
+    TextIO stream is provided results will be written to it, otherwise no diff will be computed.
+    - **extension**: The file extension that contains imports. Defaults to filename extension or py.
+    - **config**: The config object to use when sorting imports.
+    - **file_path**: The disk location where the code string was pulled from.
+    - **disregard_skip**: set to `True` if you want to ignore a skip set in config for this file.
+    - ****config_kwargs**: Any config modifications.
+    """
+    config = _config(path=file_path, config=config, **config_kwargs)
+
+    if show_diff:
+        input_stream = StringIO(input_stream.read())
+
+    changed: bool = sort_stream(
+        input_stream=input_stream,
+        output_stream=Empty,
+        extension=extension,
+        config=config,
+        file_path=file_path,
+        disregard_skip=disregard_skip,
+    )
+    printer = create_terminal_printer(
+        color=config.color_output, error=config.format_error, success=config.format_success
+    )
+    if not changed:
+        if config.verbose and not config.only_modified:
+            printer.success(f"{file_path or ''} Everything Looks Good!")
+        return True
+
+    printer.error(f"{file_path or ''} Imports are incorrectly sorted and/or formatted.")
+    if show_diff:
+        output_stream = StringIO()
+        input_stream.seek(0)
+        file_contents = input_stream.read()
+        sort_stream(
+            input_stream=StringIO(file_contents),
+            output_stream=output_stream,
+            extension=extension,
+            config=config,
+            file_path=file_path,
+            disregard_skip=disregard_skip,
+        )
+        output_stream.seek(0)
+
+        show_unified_diff(
+            file_input=file_contents,
+            file_output=output_stream.read(),
+            file_path=file_path,
+            output=None if show_diff is True else cast(TextIO, show_diff),
+            color_output=config.color_output,
+        )
+    return False
+
+
+def check_file(
+    filename: Union[str, Path],
+    show_diff: Union[bool, TextIO] = False,
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    disregard_skip: bool = True,
+    extension: Optional[str] = None,
+    **config_kwargs: Any,
+) -> bool:
+    """Checks any imports within the provided file, returning `False` if any unsorted or
+    incorrectly imports are found or `True` if no problems are identified.
+
+    - **filename**: The name or Path of the file to check.
+    - **show_diff**: If `True` the changes that need to be done will be printed to stdout, if a
+    TextIO stream is provided results will be written to it, otherwise no diff will be computed.
+    - **config**: The config object to use when sorting imports.
+    - **file_path**: The disk location where the code string was pulled from.
+    - **disregard_skip**: set to `True` if you want to ignore a skip set in config for this file.
+    - **extension**: The file extension that contains imports. Defaults to filename extension or py.
+    - ****config_kwargs**: Any config modifications.
+    """
+    file_config: Config = config
+
+    if "config_trie" in config_kwargs:
+        config_trie = config_kwargs.pop("config_trie", None)
+        if config_trie:
+            config_info = config_trie.search(filename)
+            if config.verbose:
+                print(f"{config_info[0]} used for file {filename}")
+
+            file_config = Config(**config_info[1])
+
+    with io.File.read(filename) as source_file:
+        return check_stream(
+            source_file.stream,
+            show_diff=show_diff,
+            extension=extension,
+            config=file_config,
+            file_path=file_path or source_file.path,
+            disregard_skip=disregard_skip,
+            **config_kwargs,
+        )
+
+
+def _tmp_file(source_file: File) -> Path:
+    return source_file.path.with_suffix(source_file.path.suffix + ".isorted")
+
+
+@contextlib.contextmanager
+def _in_memory_output_stream_context() -> Iterator[TextIO]:
+    yield StringIO(newline=None)
+
+
+@contextlib.contextmanager
+def _file_output_stream_context(filename: Union[str, Path], source_file: File) -> Iterator[TextIO]:
+    tmp_file = _tmp_file(source_file)
+    with tmp_file.open("w+", encoding=source_file.encoding, newline="") as output_stream:
+        shutil.copymode(filename, tmp_file)
+        yield output_stream
+
+
+def sort_file(
+    filename: Union[str, Path],
+    extension: Optional[str] = None,
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    disregard_skip: bool = True,
+    ask_to_apply: bool = False,
+    show_diff: Union[bool, TextIO] = False,
+    write_to_stdout: bool = False,
+    output: Optional[TextIO] = None,
+    **config_kwargs: Any,
+) -> bool:
+    """Sorts and formats any groups of imports imports within the provided file or Path.
+     Returns `True` if the file has been changed, otherwise `False`.
+
+    - **filename**: The name or Path of the file to format.
+    - **extension**: The file extension that contains imports. Defaults to filename extension or py.
+    - **config**: The config object to use when sorting imports.
+    - **file_path**: The disk location where the code string was pulled from.
+    - **disregard_skip**: set to `True` if you want to ignore a skip set in config for this file.
+    - **ask_to_apply**: If `True`, prompt before applying any changes.
+    - **show_diff**: If `True` the changes that need to be done will be printed to stdout, if a
+    TextIO stream is provided results will be written to it, otherwise no diff will be computed.
+    - **write_to_stdout**: If `True`, write to stdout instead of the input file.
+    - **output**: If a TextIO is provided, results will be written there rather than replacing
+    the original file content.
+    - ****config_kwargs**: Any config modifications.
+    """
+    file_config: Config = config
+
+    if "config_trie" in config_kwargs:
+        config_trie = config_kwargs.pop("config_trie", None)
+        if config_trie:
+            config_info = config_trie.search(filename)
+            if config.verbose:
+                print(f"{config_info[0]} used for file {filename}")
+
+            file_config = Config(**config_info[1])
+
+    with io.File.read(filename) as source_file:
+        actual_file_path = file_path or source_file.path
+        config = _config(path=actual_file_path, config=file_config, **config_kwargs)
+        changed: bool = False
+        try:
+            if write_to_stdout:
+                changed = sort_stream(
+                    input_stream=source_file.stream,
+                    output_stream=sys.stdout,
+                    config=config,
+                    file_path=actual_file_path,
+                    disregard_skip=disregard_skip,
+                    extension=extension,
+                )
+            else:
+                if output is None:
+                    try:
+                        if config.overwrite_in_place:
+                            output_stream_context = _in_memory_output_stream_context()
+                        else:
+                            output_stream_context = _file_output_stream_context(
+                                filename, source_file
+                            )
+                        with output_stream_context as output_stream:
+                            changed = sort_stream(
+                                input_stream=source_file.stream,
+                                output_stream=output_stream,
+                                config=config,
+                                file_path=actual_file_path,
+                                disregard_skip=disregard_skip,
+                                extension=extension,
+                            )
+                            output_stream.seek(0)
+                            if changed:
+                                if show_diff or ask_to_apply:
+                                    source_file.stream.seek(0)
+                                    show_unified_diff(
+                                        file_input=source_file.stream.read(),
+                                        file_output=output_stream.read(),
+                                        file_path=actual_file_path,
+                                        output=None
+                                        if show_diff is True
+                                        else cast(TextIO, show_diff),
+                                        color_output=config.color_output,
+                                    )
+                                    if show_diff or (
+                                        ask_to_apply
+                                        and not ask_whether_to_apply_changes_to_file(
+                                            str(source_file.path)
+                                        )
+                                    ):
+                                        return False
+                                source_file.stream.close()
+                                if config.overwrite_in_place:
+                                    output_stream.seek(0)
+                                    with source_file.path.open("w") as fs:
+                                        shutil.copyfileobj(output_stream, fs)
+                        if changed:
+                            if not config.overwrite_in_place:
+                                tmp_file = _tmp_file(source_file)
+                                tmp_file.replace(source_file.path)
+                            if not config.quiet:
+                                print(f"Fixing {source_file.path}")
+                    finally:
+                        try:  # Python 3.8+: use `missing_ok=True` instead of try except.
+                            if not config.overwrite_in_place:  # pragma: no branch
+                                tmp_file = _tmp_file(source_file)
+                                tmp_file.unlink()
+                        except FileNotFoundError:
+                            pass  # pragma: no cover
+                else:
+                    changed = sort_stream(
+                        input_stream=source_file.stream,
+                        output_stream=output,
+                        config=config,
+                        file_path=actual_file_path,
+                        disregard_skip=disregard_skip,
+                        extension=extension,
+                    )
+                    if changed and show_diff:
+                        source_file.stream.seek(0)
+                        output.seek(0)
+                        show_unified_diff(
+                            file_input=source_file.stream.read(),
+                            file_output=output.read(),
+                            file_path=actual_file_path,
+                            output=None if show_diff is True else cast(TextIO, show_diff),
+                            color_output=config.color_output,
+                        )
+                    source_file.stream.close()
+
+        except ExistingSyntaxErrors:
+            warn(f"{actual_file_path} unable to sort due to existing syntax errors")
+        except IntroducedSyntaxErrors:  # pragma: no cover
+            warn(f"{actual_file_path} unable to sort as isort introduces new syntax errors")
+
+        return changed
+
+
+def find_imports_in_code(
+    code: str,
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    unique: Union[bool, ImportKey] = False,
+    top_only: bool = False,
+    **config_kwargs: Any,
+) -> Iterator[identify.Import]:
+    """Finds and returns all imports within the provided code string.
+
+    - **code**: The string of code with imports that need to be sorted.
+    - **config**: The config object to use when sorting imports.
+    - **file_path**: The disk location where the code string was pulled from.
+    - **unique**: If True, only the first instance of an import is returned.
+    - **top_only**: If True, only return imports that occur before the first function or class.
+    - ****config_kwargs**: Any config modifications.
+    """
+    yield from find_imports_in_stream(
+        input_stream=StringIO(code),
+        config=config,
+        file_path=file_path,
+        unique=unique,
+        top_only=top_only,
+        **config_kwargs,
+    )
+
+
+def find_imports_in_stream(
+    input_stream: TextIO,
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    unique: Union[bool, ImportKey] = False,
+    top_only: bool = False,
+    _seen: Optional[Set[str]] = None,
+    **config_kwargs: Any,
+) -> Iterator[identify.Import]:
+    """Finds and returns all imports within the provided code stream.
+
+    - **input_stream**: The stream of code with imports that need to be sorted.
+    - **config**: The config object to use when sorting imports.
+    - **file_path**: The disk location where the code string was pulled from.
+    - **unique**: If True, only the first instance of an import is returned.
+    - **top_only**: If True, only return imports that occur before the first function or class.
+    - **_seen**: An optional set of imports already seen. Generally meant only for internal use.
+    - ****config_kwargs**: Any config modifications.
+    """
+    config = _config(config=config, **config_kwargs)
+    identified_imports = identify.imports(
+        input_stream, config=config, file_path=file_path, top_only=top_only
+    )
+    if not unique:
+        yield from identified_imports
+
+    seen: Set[str] = set() if _seen is None else _seen
+    for identified_import in identified_imports:
+        if unique in (True, ImportKey.ALIAS):
+            key = identified_import.statement()
+        elif unique == ImportKey.ATTRIBUTE:
+            key = f"{identified_import.module}.{identified_import.attribute}"
+        elif unique == ImportKey.MODULE:
+            key = identified_import.module
+        elif unique == ImportKey.PACKAGE:  # pragma: no branch # type checking ensures this
+            key = identified_import.module.split(".")[0]
+
+        if key and key not in seen:
+            seen.add(key)
+            yield identified_import
+
+
+def find_imports_in_file(
+    filename: Union[str, Path],
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    unique: Union[bool, ImportKey] = False,
+    top_only: bool = False,
+    **config_kwargs: Any,
+) -> Iterator[identify.Import]:
+    """Finds and returns all imports within the provided source file.
+
+    - **filename**: The name or Path of the file to look for imports in.
+    - **extension**: The file extension that contains imports. Defaults to filename extension or py.
+    - **config**: The config object to use when sorting imports.
+    - **file_path**: The disk location where the code string was pulled from.
+    - **unique**: If True, only the first instance of an import is returned.
+    - **top_only**: If True, only return imports that occur before the first function or class.
+    - ****config_kwargs**: Any config modifications.
+    """
+    with io.File.read(filename) as source_file:
+        yield from find_imports_in_stream(
+            input_stream=source_file.stream,
+            config=config,
+            file_path=file_path or source_file.path,
+            unique=unique,
+            top_only=top_only,
+            **config_kwargs,
+        )
+
+
+def find_imports_in_paths(
+    paths: Iterator[Union[str, Path]],
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    unique: Union[bool, ImportKey] = False,
+    top_only: bool = False,
+    **config_kwargs: Any,
+) -> Iterator[identify.Import]:
+    """Finds and returns all imports within the provided source paths.
+
+    - **paths**: A collection of paths to recursively look for imports within.
+    - **extension**: The file extension that contains imports. Defaults to filename extension or py.
+    - **config**: The config object to use when sorting imports.
+    - **file_path**: The disk location where the code string was pulled from.
+    - **unique**: If True, only the first instance of an import is returned.
+    - **top_only**: If True, only return imports that occur before the first function or class.
+    - ****config_kwargs**: Any config modifications.
+    """
+    config = _config(config=config, **config_kwargs)
+    seen: Optional[Set[str]] = set() if unique else None
+    yield from chain(
+        *(
+            find_imports_in_file(
+                file_name, unique=unique, config=config, top_only=top_only, _seen=seen
+            )
+            for file_name in files.find(map(str, paths), config, [], [])
+        )
+    )
+
+
+def _config(
+    path: Optional[Path] = None, config: Config = DEFAULT_CONFIG, **config_kwargs: Any
+) -> Config:
+    if path and (
+        config is DEFAULT_CONFIG
+        and "settings_path" not in config_kwargs
+        and "settings_file" not in config_kwargs
+    ):
+        config_kwargs["settings_path"] = path
+
+    if config_kwargs:
+        if config is not DEFAULT_CONFIG:
+            raise ValueError(
+                "You can either specify custom configuration options using kwargs or "
+                "passing in a Config object. Not Both!"
+            )
+
+        config = Config(**config_kwargs)
+
+    return config
diff --git a/myenv/lib/python3.9/site-packages/isort/comments.py b/myenv/lib/python3.9/site-packages/isort/comments.py
new file mode 100644
index 0000000..55c3da6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/comments.py
@@ -0,0 +1,32 @@
+from typing import List, Optional, Tuple
+
+
+def parse(line: str) -> Tuple[str, str]:
+    """Parses import lines for comments and returns back the
+    import statement and the associated comment.
+    """
+    comment_start = line.find("#")
+    if comment_start != -1:
+        return (line[:comment_start], line[comment_start + 1 :].strip())
+
+    return (line, "")
+
+
+def add_to_line(
+    comments: Optional[List[str]],
+    original_string: str = "",
+    removed: bool = False,
+    comment_prefix: str = "",
+) -> str:
+    """Returns a string with comments added if removed is not set."""
+    if removed:
+        return parse(original_string)[0]
+
+    if not comments:
+        return original_string
+
+    unique_comments: List[str] = []
+    for comment in comments:
+        if comment not in unique_comments:
+            unique_comments.append(comment)
+    return f"{parse(original_string)[0]}{comment_prefix} {'; '.join(unique_comments)}"
diff --git a/myenv/lib/python3.9/site-packages/isort/core.py b/myenv/lib/python3.9/site-packages/isort/core.py
new file mode 100644
index 0000000..c0bcd36
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/core.py
@@ -0,0 +1,476 @@
+import textwrap
+from io import StringIO
+from itertools import chain
+from typing import List, TextIO, Union
+
+import isort.literal
+from isort.settings import DEFAULT_CONFIG, Config
+
+from . import output, parse
+from .exceptions import FileSkipComment
+from .format import format_natural, remove_whitespace
+from .settings import FILE_SKIP_COMMENTS
+
+CIMPORT_IDENTIFIERS = ("cimport ", "cimport*", "from.cimport")
+IMPORT_START_IDENTIFIERS = ("from ", "from.import", "import ", "import*") + CIMPORT_IDENTIFIERS
+DOCSTRING_INDICATORS = ('"""', "'''")
+COMMENT_INDICATORS = DOCSTRING_INDICATORS + ("'", '"', "#")
+CODE_SORT_COMMENTS = (
+    "# isort: list",
+    "# isort: dict",
+    "# isort: set",
+    "# isort: unique-list",
+    "# isort: tuple",
+    "# isort: unique-tuple",
+    "# isort: assignments",
+)
+
+
+def process(
+    input_stream: TextIO,
+    output_stream: TextIO,
+    extension: str = "py",
+    raise_on_skip: bool = True,
+    config: Config = DEFAULT_CONFIG,
+) -> bool:
+    """Parses stream identifying sections of contiguous imports and sorting them
+
+    Code with unsorted imports is read from the provided `input_stream`, sorted and then
+    outputted to the specified `output_stream`.
+
+    - `input_stream`: Text stream with unsorted import sections.
+    - `output_stream`: Text stream to output sorted inputs into.
+    - `config`: Config settings to use when sorting imports. Defaults settings.
+        - *Default*: `isort.settings.DEFAULT_CONFIG`.
+    - `extension`: The file extension or file extension rules that should be used.
+        - *Default*: `"py"`.
+        - *Choices*: `["py", "pyi", "pyx"]`.
+
+    Returns `True` if there were changes that needed to be made (errors present) from what
+    was provided in the input_stream, otherwise `False`.
+    """
+    line_separator: str = config.line_ending
+    add_imports: List[str] = [format_natural(addition) for addition in config.add_imports]
+    import_section: str = ""
+    next_import_section: str = ""
+    next_cimports: bool = False
+    in_quote: str = ""
+    was_in_quote: bool = False
+    first_comment_index_start: int = -1
+    first_comment_index_end: int = -1
+    contains_imports: bool = False
+    in_top_comment: bool = False
+    first_import_section: bool = True
+    indent: str = ""
+    isort_off: bool = False
+    skip_file: bool = False
+    code_sorting: Union[bool, str] = False
+    code_sorting_section: str = ""
+    code_sorting_indent: str = ""
+    cimports: bool = False
+    made_changes: bool = False
+    stripped_line: str = ""
+    end_of_file: bool = False
+    verbose_output: List[str] = []
+
+    if config.float_to_top:
+        new_input = ""
+        current = ""
+        isort_off = False
+        for line in chain(input_stream, (None,)):
+            if isort_off and line is not None:
+                if line == "# isort: on\n":
+                    isort_off = False
+                new_input += line
+            elif line in ("# isort: split\n", "# isort: off\n", None) or str(line).endswith(
+                "# isort: split\n"
+            ):
+                if line == "# isort: off\n":
+                    isort_off = True
+                if current:
+                    if add_imports:
+                        add_line_separator = line_separator or "\n"
+                        current += add_line_separator + add_line_separator.join(add_imports)
+                        add_imports = []
+                    parsed = parse.file_contents(current, config=config)
+                    verbose_output += parsed.verbose_output
+                    extra_space = ""
+                    while current and current[-1] == "\n":
+                        extra_space += "\n"
+                        current = current[:-1]
+                    extra_space = extra_space.replace("\n", "", 1)
+                    sorted_output = output.sorted_imports(
+                        parsed, config, extension, import_type="import"
+                    )
+                    made_changes = made_changes or _has_changed(
+                        before=current,
+                        after=sorted_output,
+                        line_separator=parsed.line_separator,
+                        ignore_whitespace=config.ignore_whitespace,
+                    )
+                    new_input += sorted_output
+                    new_input += extra_space
+                    current = ""
+                new_input += line or ""
+            else:
+                current += line or ""
+
+        input_stream = StringIO(new_input)
+
+    for index, line in enumerate(chain(input_stream, (None,))):
+        if line is None:
+            if index == 0 and not config.force_adds:
+                return False
+
+            not_imports = True
+            end_of_file = True
+            line = ""
+            if not line_separator:
+                line_separator = "\n"
+
+            if code_sorting and code_sorting_section:
+                sorted_code = textwrap.indent(
+                    isort.literal.assignment(
+                        code_sorting_section,
+                        str(code_sorting),
+                        extension,
+                        config=_indented_config(config, indent),
+                    ),
+                    code_sorting_indent,
+                )
+                made_changes = made_changes or _has_changed(
+                    before=code_sorting_section,
+                    after=sorted_code,
+                    line_separator=line_separator,
+                    ignore_whitespace=config.ignore_whitespace,
+                )
+                output_stream.write(sorted_code)
+        else:
+            stripped_line = line.strip()
+            if stripped_line and not line_separator:
+                line_separator = line[len(line.rstrip()) :].replace(" ", "").replace("\t", "")
+
+            for file_skip_comment in FILE_SKIP_COMMENTS:
+                if file_skip_comment in line:
+                    if raise_on_skip:
+                        raise FileSkipComment("Passed in content")
+                    isort_off = True
+                    skip_file = True
+
+            if not in_quote:
+                if stripped_line == "# isort: off":
+                    isort_off = True
+                elif stripped_line.startswith("# isort: dont-add-imports"):
+                    add_imports = []
+                elif stripped_line.startswith("# isort: dont-add-import:"):
+                    import_not_to_add = stripped_line.split("# isort: dont-add-import:", 1)[
+                        1
+                    ].strip()
+                    add_imports = [
+                        import_to_add
+                        for import_to_add in add_imports
+                        if not import_to_add == import_not_to_add
+                    ]
+
+            if (
+                (index == 0 or (index in (1, 2) and not contains_imports))
+                and stripped_line.startswith("#")
+                and stripped_line not in config.section_comments
+                and stripped_line not in CODE_SORT_COMMENTS
+            ):
+                in_top_comment = True
+            elif in_top_comment and (
+                not line.startswith("#")
+                or stripped_line in config.section_comments
+                or stripped_line in CODE_SORT_COMMENTS
+            ):
+                in_top_comment = False
+                first_comment_index_end = index - 1
+
+            was_in_quote = bool(in_quote)
+            if (not stripped_line.startswith("#") or in_quote) and '"' in line or "'" in line:
+                char_index = 0
+                if first_comment_index_start == -1 and (
+                    line.startswith('"') or line.startswith("'")
+                ):
+                    first_comment_index_start = index
+                while char_index < len(line):
+                    if line[char_index] == "\\":
+                        char_index += 1
+                    elif in_quote:
+                        if line[char_index : char_index + len(in_quote)] == in_quote:
+                            in_quote = ""
+                            if first_comment_index_end < first_comment_index_start:
+                                first_comment_index_end = index
+                    elif line[char_index] in ("'", '"'):
+                        long_quote = line[char_index : char_index + 3]
+                        if long_quote in ('"""', "'''"):
+                            in_quote = long_quote
+                            char_index += 2
+                        else:
+                            in_quote = line[char_index]
+                    elif line[char_index] == "#":
+                        break
+                    char_index += 1
+
+            not_imports = bool(in_quote) or was_in_quote or in_top_comment or isort_off
+            if not (in_quote or was_in_quote or in_top_comment):
+                if isort_off:
+                    if not skip_file and stripped_line == "# isort: on":
+                        isort_off = False
+                elif stripped_line.endswith("# isort: split"):
+                    not_imports = True
+                elif stripped_line in CODE_SORT_COMMENTS:
+                    code_sorting = stripped_line.split("isort: ")[1].strip()
+                    code_sorting_indent = line[: -len(line.lstrip())]
+                    not_imports = True
+                elif code_sorting:
+                    if not stripped_line:
+                        sorted_code = textwrap.indent(
+                            isort.literal.assignment(
+                                code_sorting_section,
+                                str(code_sorting),
+                                extension,
+                                config=_indented_config(config, indent),
+                            ),
+                            code_sorting_indent,
+                        )
+                        made_changes = made_changes or _has_changed(
+                            before=code_sorting_section,
+                            after=sorted_code,
+                            line_separator=line_separator,
+                            ignore_whitespace=config.ignore_whitespace,
+                        )
+                        output_stream.write(sorted_code)
+                        not_imports = True
+                        code_sorting = False
+                        code_sorting_section = ""
+                        code_sorting_indent = ""
+                    else:
+                        code_sorting_section += line
+                        line = ""
+                elif (
+                    stripped_line in config.section_comments
+                    or stripped_line in config.section_comments_end
+                ):
+                    if import_section and not contains_imports:
+                        output_stream.write(import_section)
+                        import_section = line
+                        not_imports = False
+                    else:
+                        import_section += line
+                    indent = line[: -len(line.lstrip())]
+                elif not (stripped_line or contains_imports):
+                    not_imports = True
+                elif (
+                    not stripped_line
+                    or stripped_line.startswith("#")
+                    and (not indent or indent + line.lstrip() == line)
+                    and not config.treat_all_comments_as_code
+                    and stripped_line not in config.treat_comments_as_code
+                ):
+                    import_section += line
+                elif stripped_line.startswith(IMPORT_START_IDENTIFIERS):
+                    new_indent = line[: -len(line.lstrip())]
+                    import_statement = line
+                    stripped_line = line.strip().split("#")[0]
+                    while stripped_line.endswith("\\") or (
+                        "(" in stripped_line and ")" not in stripped_line
+                    ):
+                        if stripped_line.endswith("\\"):
+                            while stripped_line and stripped_line.endswith("\\"):
+                                line = input_stream.readline()
+                                stripped_line = line.strip().split("#")[0]
+                                import_statement += line
+                        else:
+                            while ")" not in stripped_line:
+                                line = input_stream.readline()
+                                stripped_line = line.strip().split("#")[0]
+                                import_statement += line
+
+                    if (
+                        import_statement.lstrip().startswith("from")
+                        and "import" not in import_statement
+                    ):
+                        line = import_statement
+                        not_imports = True
+                    else:
+                        did_contain_imports = contains_imports
+                        contains_imports = True
+
+                        cimport_statement: bool = False
+                        if (
+                            import_statement.lstrip().startswith(CIMPORT_IDENTIFIERS)
+                            or " cimport " in import_statement
+                            or " cimport*" in import_statement
+                            or " cimport(" in import_statement
+                            or ".cimport" in import_statement
+                        ):
+                            cimport_statement = True
+
+                        if cimport_statement != cimports or (
+                            new_indent != indent
+                            and import_section
+                            and (not did_contain_imports or len(new_indent) < len(indent))
+                        ):
+                            indent = new_indent
+                            if import_section:
+                                next_cimports = cimport_statement
+                                next_import_section = import_statement
+                                import_statement = ""
+                                not_imports = True
+                                line = ""
+                            else:
+                                cimports = cimport_statement
+                        else:
+                            if new_indent != indent:
+                                if import_section and did_contain_imports:
+                                    import_statement = indent + import_statement.lstrip()
+                                else:
+                                    indent = new_indent
+                        import_section += import_statement
+                else:
+                    not_imports = True
+
+        if not_imports:
+            raw_import_section: str = import_section
+            if (
+                add_imports
+                and (stripped_line or end_of_file)
+                and not config.append_only
+                and not in_top_comment
+                and not was_in_quote
+                and not import_section
+                and not line.lstrip().startswith(COMMENT_INDICATORS)
+                and not (line.rstrip().endswith(DOCSTRING_INDICATORS) and "=" not in line)
+            ):
+                add_line_separator = line_separator or "\n"
+                import_section = add_line_separator.join(add_imports) + add_line_separator
+                if end_of_file and index != 0:
+                    output_stream.write(add_line_separator)
+                contains_imports = True
+                add_imports = []
+
+            if next_import_section and not import_section:  # pragma: no cover
+                raw_import_section = import_section = next_import_section
+                next_import_section = ""
+
+            if import_section:
+                if add_imports and (contains_imports or not config.append_only) and not indent:
+                    import_section = (
+                        line_separator.join(add_imports) + line_separator + import_section
+                    )
+                    contains_imports = True
+                    add_imports = []
+
+                if not indent:
+                    import_section += line
+                    raw_import_section += line
+                if not contains_imports:
+                    output_stream.write(import_section)
+
+                else:
+                    leading_whitespace = import_section[: -len(import_section.lstrip())]
+                    trailing_whitespace = import_section[len(import_section.rstrip()) :]
+                    if first_import_section and not import_section.lstrip(
+                        line_separator
+                    ).startswith(COMMENT_INDICATORS):
+                        import_section = import_section.lstrip(line_separator)
+                        raw_import_section = raw_import_section.lstrip(line_separator)
+                        first_import_section = False
+
+                    if indent:
+                        import_section = "".join(
+                            line[len(indent) :] for line in import_section.splitlines(keepends=True)
+                        )
+
+                    parsed_content = parse.file_contents(import_section, config=config)
+                    verbose_output += parsed_content.verbose_output
+
+                    sorted_import_section = output.sorted_imports(
+                        parsed_content,
+                        _indented_config(config, indent),
+                        extension,
+                        import_type="cimport" if cimports else "import",
+                    )
+                    if not (import_section.strip() and not sorted_import_section):
+                        if indent:
+                            sorted_import_section = (
+                                leading_whitespace
+                                + textwrap.indent(sorted_import_section, indent).strip()
+                                + trailing_whitespace
+                            )
+
+                        made_changes = made_changes or _has_changed(
+                            before=raw_import_section,
+                            after=sorted_import_section,
+                            line_separator=line_separator,
+                            ignore_whitespace=config.ignore_whitespace,
+                        )
+                        output_stream.write(sorted_import_section)
+                        if not line and not indent and next_import_section:
+                            output_stream.write(line_separator)
+
+                if indent:
+                    output_stream.write(line)
+                    if not next_import_section:
+                        indent = ""
+
+                if next_import_section:
+                    cimports = next_cimports
+                    contains_imports = True
+                else:
+                    contains_imports = False
+                import_section = next_import_section
+                next_import_section = ""
+            else:
+                output_stream.write(line)
+                not_imports = False
+
+            if stripped_line and not in_quote and not import_section and not next_import_section:
+                if stripped_line == "yield":
+                    while not stripped_line or stripped_line == "yield":
+                        new_line = input_stream.readline()
+                        if not new_line:
+                            break
+
+                        output_stream.write(new_line)
+                        stripped_line = new_line.strip().split("#")[0]
+
+                if stripped_line.startswith("raise") or stripped_line.startswith("yield"):
+                    while stripped_line.endswith("\\"):
+                        new_line = input_stream.readline()
+                        if not new_line:
+                            break
+
+                        output_stream.write(new_line)
+                        stripped_line = new_line.strip().split("#")[0]
+
+    if made_changes and config.only_modified:
+        for output_str in verbose_output:
+            print(output_str)
+
+    return made_changes
+
+
+def _indented_config(config: Config, indent: str) -> Config:
+    if not indent:
+        return config
+
+    return Config(
+        config=config,
+        line_length=max(config.line_length - len(indent), 0),
+        wrap_length=max(config.wrap_length - len(indent), 0),
+        lines_after_imports=1,
+        import_headings=config.import_headings if config.indented_import_headings else {},
+        import_footers=config.import_footers if config.indented_import_headings else {},
+    )
+
+
+def _has_changed(before: str, after: str, line_separator: str, ignore_whitespace: bool) -> bool:
+    if ignore_whitespace:
+        return (
+            remove_whitespace(before, line_separator=line_separator).strip()
+            != remove_whitespace(after, line_separator=line_separator).strip()
+        )
+    return before.strip() != after.strip()
diff --git a/myenv/lib/python3.9/site-packages/isort/deprecated/__init__.py b/myenv/lib/python3.9/site-packages/isort/deprecated/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/isort/deprecated/finders.py b/myenv/lib/python3.9/site-packages/isort/deprecated/finders.py
new file mode 100644
index 0000000..52bd7cf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/deprecated/finders.py
@@ -0,0 +1,415 @@
+"""Finders try to find right section for passed module name"""
+import importlib.machinery
+import inspect
+import os
+import os.path
+import re
+import sys
+import sysconfig
+from abc import ABCMeta, abstractmethod
+from contextlib import contextmanager
+from fnmatch import fnmatch
+from functools import lru_cache
+from glob import glob
+from pathlib import Path
+from typing import Dict, Iterable, Iterator, List, Optional, Pattern, Sequence, Tuple, Type
+
+from isort import sections
+from isort.settings import KNOWN_SECTION_MAPPING, Config
+from isort.utils import exists_case_sensitive
+
+try:
+    from pipreqs import pipreqs  # type: ignore
+
+except ImportError:
+    pipreqs = None
+
+try:
+    from pip_api import parse_requirements  # type: ignore
+
+except ImportError:
+    parse_requirements = None
+
+try:
+    from requirementslib import Pipfile  # type: ignore
+
+except ImportError:
+    Pipfile = None
+
+
+@contextmanager
+def chdir(path: str) -> Iterator[None]:
+    """Context manager for changing dir and restoring previous workdir after exit."""
+    curdir = os.getcwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(curdir)
+
+
+class BaseFinder(metaclass=ABCMeta):
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    @abstractmethod
+    def find(self, module_name: str) -> Optional[str]:
+        raise NotImplementedError
+
+
+class ForcedSeparateFinder(BaseFinder):
+    def find(self, module_name: str) -> Optional[str]:
+        for forced_separate in self.config.forced_separate:
+            # Ensure all forced_separate patterns will match to end of string
+            path_glob = forced_separate
+            if not forced_separate.endswith("*"):
+                path_glob = "%s*" % forced_separate
+
+            if fnmatch(module_name, path_glob) or fnmatch(module_name, "." + path_glob):
+                return forced_separate
+        return None
+
+
+class LocalFinder(BaseFinder):
+    def find(self, module_name: str) -> Optional[str]:
+        if module_name.startswith("."):
+            return "LOCALFOLDER"
+        return None
+
+
+class KnownPatternFinder(BaseFinder):
+    def __init__(self, config: Config) -> None:
+        super().__init__(config)
+
+        self.known_patterns: List[Tuple[Pattern[str], str]] = []
+        for placement in reversed(config.sections):
+            known_placement = KNOWN_SECTION_MAPPING.get(placement, placement).lower()
+            config_key = f"known_{known_placement}"
+            known_patterns = list(
+                getattr(self.config, config_key, self.config.known_other.get(known_placement, []))
+            )
+            known_patterns = [
+                pattern
+                for known_pattern in known_patterns
+                for pattern in self._parse_known_pattern(known_pattern)
+            ]
+            for known_pattern in known_patterns:
+                regexp = "^" + known_pattern.replace("*", ".*").replace("?", ".?") + "$"
+                self.known_patterns.append((re.compile(regexp), placement))
+
+    def _parse_known_pattern(self, pattern: str) -> List[str]:
+        """Expand pattern if identified as a directory and return found sub packages"""
+        if pattern.endswith(os.path.sep):
+            patterns = [
+                filename
+                for filename in os.listdir(os.path.join(self.config.directory, pattern))
+                if os.path.isdir(os.path.join(self.config.directory, pattern, filename))
+            ]
+        else:
+            patterns = [pattern]
+
+        return patterns
+
+    def find(self, module_name: str) -> Optional[str]:
+        # Try to find most specific placement instruction match (if any)
+        parts = module_name.split(".")
+        module_names_to_check = (".".join(parts[:first_k]) for first_k in range(len(parts), 0, -1))
+        for module_name_to_check in module_names_to_check:
+            for pattern, placement in self.known_patterns:
+                if pattern.match(module_name_to_check):
+                    return placement
+        return None
+
+
+class PathFinder(BaseFinder):
+    def __init__(self, config: Config, path: str = ".") -> None:
+        super().__init__(config)
+
+        # restore the original import path (i.e. not the path to bin/isort)
+        root_dir = os.path.abspath(path)
+        src_dir = f"{root_dir}/src"
+        self.paths = [root_dir, src_dir]
+
+        # virtual env
+        self.virtual_env = self.config.virtual_env or os.environ.get("VIRTUAL_ENV")
+        if self.virtual_env:
+            self.virtual_env = os.path.realpath(self.virtual_env)
+        self.virtual_env_src = ""
+        if self.virtual_env:
+            self.virtual_env_src = f"{self.virtual_env}/src/"
+            for venv_path in glob(f"{self.virtual_env}/lib/python*/site-packages"):
+                if venv_path not in self.paths:
+                    self.paths.append(venv_path)
+            for nested_venv_path in glob(f"{self.virtual_env}/lib/python*/*/site-packages"):
+                if nested_venv_path not in self.paths:
+                    self.paths.append(nested_venv_path)
+            for venv_src_path in glob(f"{self.virtual_env}/src/*"):
+                if os.path.isdir(venv_src_path):
+                    self.paths.append(venv_src_path)
+
+        # conda
+        self.conda_env = self.config.conda_env or os.environ.get("CONDA_PREFIX") or ""
+        if self.conda_env:
+            self.conda_env = os.path.realpath(self.conda_env)
+            for conda_path in glob(f"{self.conda_env}/lib/python*/site-packages"):
+                if conda_path not in self.paths:
+                    self.paths.append(conda_path)
+            for nested_conda_path in glob(f"{self.conda_env}/lib/python*/*/site-packages"):
+                if nested_conda_path not in self.paths:
+                    self.paths.append(nested_conda_path)
+
+        # handle case-insensitive paths on windows
+        self.stdlib_lib_prefix = os.path.normcase(sysconfig.get_paths()["stdlib"])
+        if self.stdlib_lib_prefix not in self.paths:
+            self.paths.append(self.stdlib_lib_prefix)
+
+        # add system paths
+        for system_path in sys.path[1:]:
+            if system_path not in self.paths:
+                self.paths.append(system_path)
+
+    def find(self, module_name: str) -> Optional[str]:
+        for prefix in self.paths:
+            package_path = "/".join((prefix, module_name.split(".")[0]))
+            path_obj = Path(package_path).resolve()
+            is_module = (
+                exists_case_sensitive(package_path + ".py")
+                or any(
+                    exists_case_sensitive(package_path + ext_suffix)
+                    for ext_suffix in importlib.machinery.EXTENSION_SUFFIXES
+                )
+                or exists_case_sensitive(package_path + "/__init__.py")
+            )
+            is_package = exists_case_sensitive(package_path) and os.path.isdir(package_path)
+            if is_module or is_package:
+                if (
+                    "site-packages" in prefix
+                    or "dist-packages" in prefix
+                    or (self.virtual_env and self.virtual_env_src in prefix)
+                ):
+                    return sections.THIRDPARTY
+                if os.path.normcase(prefix) == self.stdlib_lib_prefix:
+                    return sections.STDLIB
+                if self.conda_env and self.conda_env in prefix:
+                    return sections.THIRDPARTY
+                for src_path in self.config.src_paths:
+                    if src_path in path_obj.parents and not self.config.is_skipped(path_obj):
+                        return sections.FIRSTPARTY
+
+                if os.path.normcase(prefix).startswith(self.stdlib_lib_prefix):
+                    return sections.STDLIB  # pragma: no cover - edge case for one OS. Hard to test.
+
+                return self.config.default_section
+        return None
+
+
+class ReqsBaseFinder(BaseFinder):
+    enabled = False
+
+    def __init__(self, config: Config, path: str = ".") -> None:
+        super().__init__(config)
+        self.path = path
+        if self.enabled:
+            self.mapping = self._load_mapping()
+            self.names = self._load_names()
+
+    @abstractmethod
+    def _get_names(self, path: str) -> Iterator[str]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _get_files_from_dir(self, path: str) -> Iterator[str]:
+        raise NotImplementedError
+
+    @staticmethod
+    def _load_mapping() -> Optional[Dict[str, str]]:
+        """Return list of mappings `package_name -> module_name`
+
+        Example:
+            django-haystack -> haystack
+        """
+        if not pipreqs:
+            return None
+        path = os.path.dirname(inspect.getfile(pipreqs))
+        path = os.path.join(path, "mapping")
+        with open(path) as f:
+            mappings: Dict[str, str] = {}  # pypi_name: import_name
+            for line in f:
+                import_name, _, pypi_name = line.strip().partition(":")
+                mappings[pypi_name] = import_name
+            return mappings
+            # return dict(tuple(line.strip().split(":")[::-1]) for line in f)
+
+    def _load_names(self) -> List[str]:
+        """Return list of thirdparty modules from requirements"""
+        names = []
+        for path in self._get_files():
+            for name in self._get_names(path):
+                names.append(self._normalize_name(name))
+        return names
+
+    @staticmethod
+    def _get_parents(path: str) -> Iterator[str]:
+        prev = ""
+        while path != prev:
+            prev = path
+            yield path
+            path = os.path.dirname(path)
+
+    def _get_files(self) -> Iterator[str]:
+        """Return paths to all requirements files"""
+        path = os.path.abspath(self.path)
+        if os.path.isfile(path):
+            path = os.path.dirname(path)
+
+        for path in self._get_parents(path):
+            yield from self._get_files_from_dir(path)
+
+    def _normalize_name(self, name: str) -> str:
+        """Convert package name to module name
+
+        Examples:
+            Django -> django
+            django-haystack -> django_haystack
+            Flask-RESTFul -> flask_restful
+        """
+        if self.mapping:
+            name = self.mapping.get(name.replace("-", "_"), name)
+        return name.lower().replace("-", "_")
+
+    def find(self, module_name: str) -> Optional[str]:
+        # required lib not installed yet
+        if not self.enabled:
+            return None
+
+        module_name, _sep, _submodules = module_name.partition(".")
+        module_name = module_name.lower()
+        if not module_name:
+            return None
+
+        for name in self.names:
+            if module_name == name:
+                return sections.THIRDPARTY
+        return None
+
+
+class RequirementsFinder(ReqsBaseFinder):
+    exts = (".txt", ".in")
+    enabled = bool(parse_requirements)
+
+    def _get_files_from_dir(self, path: str) -> Iterator[str]:
+        """Return paths to requirements files from passed dir."""
+        yield from self._get_files_from_dir_cached(path)
+
+    @classmethod
+    @lru_cache(maxsize=16)
+    def _get_files_from_dir_cached(cls, path: str) -> List[str]:
+        results = []
+
+        for fname in os.listdir(path):
+            if "requirements" not in fname:
+                continue
+            full_path = os.path.join(path, fname)
+
+            # *requirements*/*.{txt,in}
+            if os.path.isdir(full_path):
+                for subfile_name in os.listdir(full_path):
+                    for ext in cls.exts:
+                        if subfile_name.endswith(ext):
+                            results.append(os.path.join(full_path, subfile_name))
+                continue
+
+            # *requirements*.{txt,in}
+            if os.path.isfile(full_path):
+                for ext in cls.exts:
+                    if fname.endswith(ext):
+                        results.append(full_path)
+                        break
+
+        return results
+
+    def _get_names(self, path: str) -> Iterator[str]:
+        """Load required packages from path to requirements file"""
+        yield from self._get_names_cached(path)
+
+    @classmethod
+    @lru_cache(maxsize=16)
+    def _get_names_cached(cls, path: str) -> List[str]:
+        result = []
+
+        with chdir(os.path.dirname(path)):
+            requirements = parse_requirements(path)
+            for req in requirements.values():
+                if req.name:
+                    result.append(req.name)
+
+        return result
+
+
+class PipfileFinder(ReqsBaseFinder):
+    enabled = bool(Pipfile)
+
+    def _get_names(self, path: str) -> Iterator[str]:
+        with chdir(path):
+            project = Pipfile.load(path)
+            for req in project.packages:
+                yield req.name
+
+    def _get_files_from_dir(self, path: str) -> Iterator[str]:
+        if "Pipfile" in os.listdir(path):
+            yield path
+
+
+class DefaultFinder(BaseFinder):
+    def find(self, module_name: str) -> Optional[str]:
+        return self.config.default_section
+
+
+class FindersManager:
+    _default_finders_classes: Sequence[Type[BaseFinder]] = (
+        ForcedSeparateFinder,
+        LocalFinder,
+        KnownPatternFinder,
+        PathFinder,
+        PipfileFinder,
+        RequirementsFinder,
+        DefaultFinder,
+    )
+
+    def __init__(
+        self, config: Config, finder_classes: Optional[Iterable[Type[BaseFinder]]] = None
+    ) -> None:
+        self.verbose: bool = config.verbose
+
+        if finder_classes is None:
+            finder_classes = self._default_finders_classes
+        finders: List[BaseFinder] = []
+        for finder_cls in finder_classes:
+            try:
+                finders.append(finder_cls(config))
+            except Exception as exception:
+                # if one finder fails to instantiate isort can continue using the rest
+                if self.verbose:
+                    print(
+                        (
+                            f"{finder_cls.__name__} encountered an error ({exception}) during "
+                            "instantiation and cannot be used"
+                        )
+                    )
+        self.finders: Tuple[BaseFinder, ...] = tuple(finders)
+
+    def find(self, module_name: str) -> Optional[str]:
+        for finder in self.finders:
+            try:
+                section = finder.find(module_name)
+                if section is not None:
+                    return section
+            except Exception as exception:
+                # isort has to be able to keep trying to identify the correct
+                # import section even if one approach fails
+                if self.verbose:
+                    print(
+                        f"{finder.__class__.__name__} encountered an error ({exception}) while "
+                        f"trying to identify the {module_name} module"
+                    )
+        return None
diff --git a/myenv/lib/python3.9/site-packages/isort/exceptions.py b/myenv/lib/python3.9/site-packages/isort/exceptions.py
new file mode 100644
index 0000000..6be8240
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/exceptions.py
@@ -0,0 +1,197 @@
+"""All isort specific exception classes should be defined here"""
+from functools import partial
+from pathlib import Path
+from typing import Any, Dict, List, Type, Union
+
+from .profiles import profiles
+
+
+class ISortError(Exception):
+    """Base isort exception object from which all isort sourced exceptions should inherit"""
+
+    def __reduce__(self):  # type: ignore
+        return (partial(type(self), **self.__dict__), ())
+
+
+class InvalidSettingsPath(ISortError):
+    """Raised when a settings path is provided that is neither a valid file or directory"""
+
+    def __init__(self, settings_path: str):
+        super().__init__(
+            f"isort was told to use the settings_path: {settings_path} as the base directory or "
+            "file that represents the starting point of config file discovery, but it does not "
+            "exist."
+        )
+        self.settings_path = settings_path
+
+
+class ExistingSyntaxErrors(ISortError):
+    """Raised when isort is told to sort imports within code that has existing syntax errors"""
+
+    def __init__(self, file_path: str):
+        super().__init__(
+            f"isort was told to sort imports within code that contains syntax errors: "
+            f"{file_path}."
+        )
+        self.file_path = file_path
+
+
+class IntroducedSyntaxErrors(ISortError):
+    """Raised when isort has introduced a syntax error in the process of sorting imports"""
+
+    def __init__(self, file_path: str):
+        super().__init__(
+            f"isort introduced syntax errors when attempting to sort the imports contained within "
+            f"{file_path}."
+        )
+        self.file_path = file_path
+
+
+class FileSkipped(ISortError):
+    """Should be raised when a file is skipped for any reason"""
+
+    def __init__(self, message: str, file_path: str):
+        super().__init__(message)
+        self.message = message
+        self.file_path = file_path
+
+
+class FileSkipComment(FileSkipped):
+    """Raised when an entire file is skipped due to a isort skip file comment"""
+
+    def __init__(self, file_path: str, **kwargs: str):
+        super().__init__(
+            f"{file_path} contains a file skip comment and was skipped.", file_path=file_path
+        )
+
+
+class FileSkipSetting(FileSkipped):
+    """Raised when an entire file is skipped due to provided isort settings"""
+
+    def __init__(self, file_path: str, **kwargs: str):
+        super().__init__(
+            f"{file_path} was skipped as it's listed in 'skip' setting"
+            " or matches a glob in 'skip_glob' setting",
+            file_path=file_path,
+        )
+
+
+class ProfileDoesNotExist(ISortError):
+    """Raised when a profile is set by the user that doesn't exist"""
+
+    def __init__(self, profile: str):
+        super().__init__(
+            f"Specified profile of {profile} does not exist. "
+            f"Available profiles: {','.join(profiles)}."
+        )
+        self.profile = profile
+
+
+class SortingFunctionDoesNotExist(ISortError):
+    """Raised when the specified sorting function isn't available"""
+
+    def __init__(self, sort_order: str, available_sort_orders: List[str]):
+        super().__init__(
+            f"Specified sort_order of {sort_order} does not exist. "
+            f"Available sort_orders: {','.join(available_sort_orders)}."
+        )
+        self.sort_order = sort_order
+        self.available_sort_orders = available_sort_orders
+
+
+class FormattingPluginDoesNotExist(ISortError):
+    """Raised when a formatting plugin is set by the user that doesn't exist"""
+
+    def __init__(self, formatter: str):
+        super().__init__(f"Specified formatting plugin of {formatter} does not exist. ")
+        self.formatter = formatter
+
+
+class LiteralParsingFailure(ISortError):
+    """Raised when one of isorts literal sorting comments is used but isort can't parse the
+    the given data structure.
+    """
+
+    def __init__(self, code: str, original_error: Union[Exception, Type[Exception]]):
+        super().__init__(
+            f"isort failed to parse the given literal {code}. It's important to note "
+            "that isort literal sorting only supports simple literals parsable by "
+            f"ast.literal_eval which gave the exception of {original_error}."
+        )
+        self.code = code
+        self.original_error = original_error
+
+
+class LiteralSortTypeMismatch(ISortError):
+    """Raised when an isort literal sorting comment is used, with a type that doesn't match the
+    supplied data structure's type.
+    """
+
+    def __init__(self, kind: type, expected_kind: type):
+        super().__init__(
+            f"isort was told to sort a literal of type {expected_kind} but was given "
+            f"a literal of type {kind}."
+        )
+        self.kind = kind
+        self.expected_kind = expected_kind
+
+
+class AssignmentsFormatMismatch(ISortError):
+    """Raised when isort is told to sort assignments but the format of the assignment section
+    doesn't match isort's expectation.
+    """
+
+    def __init__(self, code: str):
+        super().__init__(
+            "isort was told to sort a section of assignments, however the given code:\n\n"
+            f"{code}\n\n"
+            "Does not match isort's strict single line formatting requirement for assignment "
+            "sorting:\n\n"
+            "{variable_name} = {value}\n"
+            "{variable_name2} = {value2}\n"
+            "...\n\n"
+        )
+        self.code = code
+
+
+class UnsupportedSettings(ISortError):
+    """Raised when settings are passed into isort (either from config, CLI, or runtime)
+    that it doesn't support.
+    """
+
+    @staticmethod
+    def _format_option(name: str, value: Any, source: str) -> str:
+        return f"\t- {name} = {value}  (source: '{source}')"
+
+    def __init__(self, unsupported_settings: Dict[str, Dict[str, str]]):
+        errors = "\n".join(
+            self._format_option(name, **option) for name, option in unsupported_settings.items()
+        )
+
+        super().__init__(
+            "isort was provided settings that it doesn't support:\n\n"
+            f"{errors}\n\n"
+            "For a complete and up-to-date listing of supported settings see: "
+            "https://pycqa.github.io/isort/docs/configuration/options.\n"
+        )
+        self.unsupported_settings = unsupported_settings
+
+
+class UnsupportedEncoding(ISortError):
+    """Raised when isort encounters an encoding error while trying to read a file"""
+
+    def __init__(self, filename: Union[str, Path]):
+        super().__init__(f"Unknown or unsupported encoding in {filename}")
+        self.filename = filename
+
+
+class MissingSection(ISortError):
+    """Raised when isort encounters an import that matches a section that is not defined"""
+
+    def __init__(self, import_module: str, section: str):
+        super().__init__(
+            f"Found {import_module} import while parsing, but {section} was not included "
+            "in the `sections` setting of your config. Please add it before continuing\n"
+            "See https://pycqa.github.io/isort/#custom-sections-and-ordering "
+            "for more info."
+        )
diff --git a/myenv/lib/python3.9/site-packages/isort/files.py b/myenv/lib/python3.9/site-packages/isort/files.py
new file mode 100644
index 0000000..28a916c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/files.py
@@ -0,0 +1,41 @@
+import os
+from pathlib import Path
+from typing import Iterable, Iterator, List, Set
+
+from isort.settings import Config
+
+
+def find(
+    paths: Iterable[str], config: Config, skipped: List[str], broken: List[str]
+) -> Iterator[str]:
+    """Fines and provides an iterator for all Python source files defined in paths."""
+    visited_dirs: Set[Path] = set()
+
+    for path in paths:
+        if os.path.isdir(path):
+            for dirpath, dirnames, filenames in os.walk(
+                path, topdown=True, followlinks=config.follow_links
+            ):
+                base_path = Path(dirpath)
+                for dirname in list(dirnames):
+                    full_path = base_path / dirname
+                    resolved_path = full_path.resolve()
+                    if config.is_skipped(full_path):
+                        skipped.append(dirname)
+                        dirnames.remove(dirname)
+                    else:
+                        if resolved_path in visited_dirs:  # pragma: no cover
+                            dirnames.remove(dirname)
+                    visited_dirs.add(resolved_path)
+
+                for filename in filenames:
+                    filepath = os.path.join(dirpath, filename)
+                    if config.is_supported_filetype(filepath):
+                        if config.is_skipped(Path(os.path.abspath(filepath))):
+                            skipped.append(filename)
+                        else:
+                            yield filepath
+        elif not os.path.exists(path):
+            broken.append(path)
+        else:
+            yield path
diff --git a/myenv/lib/python3.9/site-packages/isort/format.py b/myenv/lib/python3.9/site-packages/isort/format.py
new file mode 100644
index 0000000..3a7c1e0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/format.py
@@ -0,0 +1,156 @@
+import re
+import sys
+from datetime import datetime
+from difflib import unified_diff
+from pathlib import Path
+from typing import Optional, TextIO
+
+try:
+    import colorama
+except ImportError:
+    colorama_unavailable = True
+else:
+    colorama_unavailable = False
+    colorama.init(strip=False)
+
+
+ADDED_LINE_PATTERN = re.compile(r"\+[^+]")
+REMOVED_LINE_PATTERN = re.compile(r"-[^-]")
+
+
+def format_simplified(import_line: str) -> str:
+    import_line = import_line.strip()
+    if import_line.startswith("from "):
+        import_line = import_line.replace("from ", "")
+        import_line = import_line.replace(" import ", ".")
+    elif import_line.startswith("import "):
+        import_line = import_line.replace("import ", "")
+
+    return import_line
+
+
+def format_natural(import_line: str) -> str:
+    import_line = import_line.strip()
+    if not import_line.startswith("from ") and not import_line.startswith("import "):
+        if "." not in import_line:
+            return f"import {import_line}"
+        parts = import_line.split(".")
+        end = parts.pop(-1)
+        return f"from {'.'.join(parts)} import {end}"
+
+    return import_line
+
+
+def show_unified_diff(
+    *,
+    file_input: str,
+    file_output: str,
+    file_path: Optional[Path],
+    output: Optional[TextIO] = None,
+    color_output: bool = False,
+) -> None:
+    """Shows a unified_diff for the provided input and output against the provided file path.
+
+    - **file_input**: A string that represents the contents of a file before changes.
+    - **file_output**: A string that represents the contents of a file after changes.
+    - **file_path**: A Path object that represents the file path of the file being changed.
+    - **output**: A stream to output the diff to. If non is provided uses sys.stdout.
+    - **color_output**: Use color in output if True.
+    """
+    printer = create_terminal_printer(color_output, output)
+    file_name = "" if file_path is None else str(file_path)
+    file_mtime = str(
+        datetime.now() if file_path is None else datetime.fromtimestamp(file_path.stat().st_mtime)
+    )
+    unified_diff_lines = unified_diff(
+        file_input.splitlines(keepends=True),
+        file_output.splitlines(keepends=True),
+        fromfile=file_name + ":before",
+        tofile=file_name + ":after",
+        fromfiledate=file_mtime,
+        tofiledate=str(datetime.now()),
+    )
+    for line in unified_diff_lines:
+        printer.diff_line(line)
+
+
+def ask_whether_to_apply_changes_to_file(file_path: str) -> bool:
+    answer = None
+    while answer not in ("yes", "y", "no", "n", "quit", "q"):
+        answer = input(f"Apply suggested changes to '{file_path}' [y/n/q]? ")  # nosec
+        answer = answer.lower()
+        if answer in ("no", "n"):
+            return False
+        if answer in ("quit", "q"):
+            sys.exit(1)
+    return True
+
+
+def remove_whitespace(content: str, line_separator: str = "\n") -> str:
+    content = content.replace(line_separator, "").replace(" ", "").replace("\x0c", "")
+    return content
+
+
+class BasicPrinter:
+    ERROR = "ERROR"
+    SUCCESS = "SUCCESS"
+
+    def __init__(self, error: str, success: str, output: Optional[TextIO] = None):
+        self.output = output or sys.stdout
+        self.success_message = success
+        self.error_message = error
+
+    def success(self, message: str) -> None:
+        print(self.success_message.format(success=self.SUCCESS, message=message), file=self.output)
+
+    def error(self, message: str) -> None:
+        print(self.error_message.format(error=self.ERROR, message=message), file=sys.stderr)
+
+    def diff_line(self, line: str) -> None:
+        self.output.write(line)
+
+
+class ColoramaPrinter(BasicPrinter):
+    def __init__(self, error: str, success: str, output: Optional[TextIO]):
+        super().__init__(error, success, output=output)
+
+        # Note: this constants are instance variables instead ofs class variables
+        # because they refer to colorama which might not be installed.
+        self.ERROR = self.style_text("ERROR", colorama.Fore.RED)
+        self.SUCCESS = self.style_text("SUCCESS", colorama.Fore.GREEN)
+        self.ADDED_LINE = colorama.Fore.GREEN
+        self.REMOVED_LINE = colorama.Fore.RED
+
+    @staticmethod
+    def style_text(text: str, style: Optional[str] = None) -> str:
+        if style is None:
+            return text
+        return style + text + str(colorama.Style.RESET_ALL)
+
+    def diff_line(self, line: str) -> None:
+        style = None
+        if re.match(ADDED_LINE_PATTERN, line):
+            style = self.ADDED_LINE
+        elif re.match(REMOVED_LINE_PATTERN, line):
+            style = self.REMOVED_LINE
+        self.output.write(self.style_text(line, style))
+
+
+def create_terminal_printer(
+    color: bool, output: Optional[TextIO] = None, error: str = "", success: str = ""
+) -> BasicPrinter:
+    if color and colorama_unavailable:
+        no_colorama_message = (
+            "\n"
+            "Sorry, but to use --color (color_output) the colorama python package is required.\n\n"
+            "Reference: https://pypi.org/project/colorama/\n\n"
+            "You can either install it separately on your system or as the colors extra "
+            "for isort. Ex: \n\n"
+            "$ pip install isort[colors]\n"
+        )
+        print(no_colorama_message, file=sys.stderr)
+        sys.exit(1)
+
+    return (
+        ColoramaPrinter(error, success, output) if color else BasicPrinter(error, success, output)
+    )
diff --git a/myenv/lib/python3.9/site-packages/isort/hooks.py b/myenv/lib/python3.9/site-packages/isort/hooks.py
new file mode 100644
index 0000000..135886f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/hooks.py
@@ -0,0 +1,86 @@
+"""Defines a git hook to allow pre-commit warnings and errors about import order.
+
+usage:
+    exit_code = git_hook(strict=True|False, modify=True|False)
+"""
+import os
+import subprocess  # nosec - Needed for hook
+from pathlib import Path
+from typing import List
+
+from isort import Config, api, exceptions
+
+
+def get_output(command: List[str]) -> str:
+    """Run a command and return raw output
+
+    :param str command: the command to run
+    :returns: the stdout output of the command
+    """
+    result = subprocess.run(command, stdout=subprocess.PIPE, check=True)  # nosec - trusted input
+    return result.stdout.decode()
+
+
+def get_lines(command: List[str]) -> List[str]:
+    """Run a command and return lines of output
+
+    :param str command: the command to run
+    :returns: list of whitespace-stripped lines output by command
+    """
+    stdout = get_output(command)
+    return [line.strip() for line in stdout.splitlines()]
+
+
+def git_hook(
+    strict: bool = False, modify: bool = False, lazy: bool = False, settings_file: str = ""
+) -> int:
+    """Git pre-commit hook to check staged files for isort errors
+
+    :param bool strict - if True, return number of errors on exit,
+        causing the hook to fail. If False, return zero so it will
+        just act as a warning.
+    :param bool modify - if True, fix the sources if they are not
+        sorted properly. If False, only report result without
+        modifying anything.
+    :param bool lazy - if True, also check/fix unstaged files.
+        This is useful if you frequently use ``git commit -a`` for example.
+        If False, only check/fix the staged files for isort errors.
+    :param str settings_file - A path to a file to be used as
+                               the configuration file for this run.
+        When settings_file is the empty string, the configuration file
+        will be searched starting at the directory containing the first
+        staged file, if any, and going upward in the directory structure.
+
+    :return number of errors if in strict mode, 0 otherwise.
+    """
+    # Get list of files modified and staged
+    diff_cmd = ["git", "diff-index", "--cached", "--name-only", "--diff-filter=ACMRTUXB", "HEAD"]
+    if lazy:
+        diff_cmd.remove("--cached")
+
+    files_modified = get_lines(diff_cmd)
+    if not files_modified:
+        return 0
+
+    errors = 0
+    config = Config(
+        settings_file=settings_file,
+        settings_path=os.path.dirname(os.path.abspath(files_modified[0])),
+    )
+    for filename in files_modified:
+        if filename.endswith(".py"):
+            # Get the staged contents of the file
+            staged_cmd = ["git", "show", f":{filename}"]
+            staged_contents = get_output(staged_cmd)
+
+            try:
+                if not api.check_code_string(
+                    staged_contents, file_path=Path(filename), config=config
+                ):
+                    errors += 1
+                    if modify:
+                        api.sort_file(filename, config=config)
+            except exceptions.FileSkipped:  # pragma: no cover
+                pass
+
+    return errors if strict else 0
diff --git a/myenv/lib/python3.9/site-packages/isort/identify.py b/myenv/lib/python3.9/site-packages/isort/identify.py
new file mode 100644
index 0000000..e45fcb3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/identify.py
@@ -0,0 +1,206 @@
+"""Fast stream based import identification.
+Eventually this will likely replace parse.py
+"""
+from functools import partial
+from pathlib import Path
+from typing import Iterator, NamedTuple, Optional, TextIO, Tuple
+
+from isort.parse import _normalize_line, _strip_syntax, skip_line
+
+from .comments import parse as parse_comments
+from .settings import DEFAULT_CONFIG, Config
+
+STATEMENT_DECLARATIONS: Tuple[str, ...] = ("def ", "cdef ", "cpdef ", "class ", "@", "async def")
+
+
+class Import(NamedTuple):
+    line_number: int
+    indented: bool
+    module: str
+    attribute: Optional[str] = None
+    alias: Optional[str] = None
+    cimport: bool = False
+    file_path: Optional[Path] = None
+
+    def statement(self) -> str:
+        import_cmd = "cimport" if self.cimport else "import"
+        if self.attribute:
+            import_string = f"from {self.module} {import_cmd} {self.attribute}"
+        else:
+            import_string = f"{import_cmd} {self.module}"
+        if self.alias:
+            import_string += f" as {self.alias}"
+        return import_string
+
+    def __str__(self) -> str:
+        return (
+            f"{self.file_path or ''}:{self.line_number} "
+            f"{'indented ' if self.indented else ''}{self.statement()}"
+        )
+
+
+def imports(
+    input_stream: TextIO,
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    top_only: bool = False,
+) -> Iterator[Import]:
+    """Parses a python file taking out and categorizing imports."""
+    in_quote = ""
+
+    indexed_input = enumerate(input_stream)
+    for index, raw_line in indexed_input:
+        (skipping_line, in_quote) = skip_line(
+            raw_line, in_quote=in_quote, index=index, section_comments=config.section_comments
+        )
+
+        if top_only and not in_quote and raw_line.startswith(STATEMENT_DECLARATIONS):
+            break
+        if skipping_line:
+            continue
+
+        stripped_line = raw_line.strip().split("#")[0]
+        if stripped_line.startswith("raise") or stripped_line.startswith("yield"):
+            if stripped_line == "yield":
+                while not stripped_line or stripped_line == "yield":
+                    try:
+                        index, next_line = next(indexed_input)
+                    except StopIteration:
+                        break
+
+                    stripped_line = next_line.strip().split("#")[0]
+            while stripped_line.endswith("\\"):
+                try:
+                    index, next_line = next(indexed_input)
+                except StopIteration:
+                    break
+
+                stripped_line = next_line.strip().split("#")[0]
+            continue  # pragma: no cover
+
+        line, *end_of_line_comment = raw_line.split("#", 1)
+        statements = [line.strip() for line in line.split(";")]
+        if end_of_line_comment:
+            statements[-1] = f"{statements[-1]}#{end_of_line_comment[0]}"
+
+        for statement in statements:
+            line, _raw_line = _normalize_line(statement)
+            if line.startswith(("import ", "cimport ")):
+                type_of_import = "straight"
+            elif line.startswith("from "):
+                type_of_import = "from"
+            else:
+                continue  # pragma: no cover
+
+            import_string, _ = parse_comments(line)
+            normalized_import_string = (
+                import_string.replace("import(", "import (").replace("\\", " ").replace("\n", " ")
+            )
+            cimports: bool = (
+                " cimport " in normalized_import_string
+                or normalized_import_string.startswith("cimport")
+            )
+            identified_import = partial(
+                Import,
+                index + 1,  # line numbers use 1 based indexing
+                raw_line.startswith((" ", "\t")),
+                cimport=cimports,
+                file_path=file_path,
+            )
+
+            if "(" in line.split("#", 1)[0]:
+                while not line.split("#")[0].strip().endswith(")"):
+                    try:
+                        index, next_line = next(indexed_input)
+                    except StopIteration:
+                        break
+
+                    line, _ = parse_comments(next_line)
+                    import_string += "\n" + line
+            else:
+                while line.strip().endswith("\\"):
+                    try:
+                        index, next_line = next(indexed_input)
+                    except StopIteration:
+                        break
+
+                    line, _ = parse_comments(next_line)
+
+                    # Still need to check for parentheses after an escaped line
+                    if "(" in line.split("#")[0] and ")" not in line.split("#")[0]:
+                        import_string += "\n" + line
+
+                        while not line.split("#")[0].strip().endswith(")"):
+                            try:
+                                index, next_line = next(indexed_input)
+                            except StopIteration:
+                                break
+                            line, _ = parse_comments(next_line)
+                            import_string += "\n" + line
+                    else:
+                        if import_string.strip().endswith(
+                            (" import", " cimport")
+                        ) or line.strip().startswith(("import ", "cimport ")):
+                            import_string += "\n" + line
+                        else:
+                            import_string = (
+                                import_string.rstrip().rstrip("\\") + " " + line.lstrip()
+                            )
+
+            if type_of_import == "from":
+                import_string = (
+                    import_string.replace("import(", "import (")
+                    .replace("\\", " ")
+                    .replace("\n", " ")
+                )
+                parts = import_string.split(" cimport " if cimports else " import ")
+
+                from_import = parts[0].split(" ")
+                import_string = (" cimport " if cimports else " import ").join(
+                    [from_import[0] + " " + "".join(from_import[1:])] + parts[1:]
+                )
+
+            just_imports = [
+                item.replace("{|", "{ ").replace("|}", " }")
+                for item in _strip_syntax(import_string).split()
+            ]
+
+            direct_imports = just_imports[1:]
+            top_level_module = ""
+            if "as" in just_imports and (just_imports.index("as") + 1) < len(just_imports):
+                while "as" in just_imports:
+                    attribute = None
+                    as_index = just_imports.index("as")
+                    if type_of_import == "from":
+                        attribute = just_imports[as_index - 1]
+                        top_level_module = just_imports[0]
+                        module = top_level_module + "." + attribute
+                        alias = just_imports[as_index + 1]
+                        direct_imports.remove(attribute)
+                        direct_imports.remove(alias)
+                        direct_imports.remove("as")
+                        just_imports[1:] = direct_imports
+                        if attribute == alias and config.remove_redundant_aliases:
+                            yield identified_import(top_level_module, attribute)
+                        else:
+                            yield identified_import(top_level_module, attribute, alias=alias)
+
+                    else:
+                        module = just_imports[as_index - 1]
+                        alias = just_imports[as_index + 1]
+                        just_imports.remove(alias)
+                        just_imports.remove("as")
+                        just_imports.remove(module)
+                        if module == alias and config.remove_redundant_aliases:
+                            yield identified_import(module)
+                        else:
+                            yield identified_import(module, alias=alias)
+
+            if just_imports:
+                if type_of_import == "from":
+                    module = just_imports.pop(0)
+                    for attribute in just_imports:
+                        yield identified_import(module, attribute)
+                else:
+                    for module in just_imports:
+                        yield identified_import(module)
diff --git a/myenv/lib/python3.9/site-packages/isort/io.py b/myenv/lib/python3.9/site-packages/isort/io.py
new file mode 100644
index 0000000..e7a74bf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/io.py
@@ -0,0 +1,73 @@
+"""Defines any IO utilities used by isort"""
+import re
+import tokenize
+from contextlib import contextmanager
+from io import BytesIO, StringIO, TextIOWrapper
+from pathlib import Path
+from typing import Any, Callable, Iterator, TextIO, Union
+
+from isort._future import dataclass
+from isort.exceptions import UnsupportedEncoding
+
+_ENCODING_PATTERN = re.compile(br"^[ \t\f]*#.*?coding[:=][ \t]*([-_.a-zA-Z0-9]+)")
+
+
+@dataclass(frozen=True)
+class File:
+    stream: TextIO
+    path: Path
+    encoding: str
+
+    @staticmethod
+    def detect_encoding(filename: Union[str, Path], readline: Callable[[], bytes]) -> str:
+        try:
+            return tokenize.detect_encoding(readline)[0]
+        except Exception:
+            raise UnsupportedEncoding(filename)
+
+    @staticmethod
+    def from_contents(contents: str, filename: str) -> "File":
+        encoding = File.detect_encoding(filename, BytesIO(contents.encode("utf-8")).readline)
+        return File(  # type: ignore
+            stream=StringIO(contents), path=Path(filename).resolve(), encoding=encoding
+        )
+
+    @property
+    def extension(self) -> str:
+        return self.path.suffix.lstrip(".")
+
+    @staticmethod
+    def _open(filename: Union[str, Path]) -> TextIOWrapper:
+        """Open a file in read only mode using the encoding detected by
+        detect_encoding().
+        """
+        buffer = open(filename, "rb")
+        try:
+            encoding = File.detect_encoding(filename, buffer.readline)
+            buffer.seek(0)
+            text = TextIOWrapper(buffer, encoding, line_buffering=True, newline="")
+            text.mode = "r"  # type: ignore
+            return text
+        except Exception:
+            buffer.close()
+            raise
+
+    @staticmethod
+    @contextmanager
+    def read(filename: Union[str, Path]) -> Iterator["File"]:
+        file_path = Path(filename).resolve()
+        stream = None
+        try:
+            stream = File._open(file_path)
+            yield File(stream=stream, path=file_path, encoding=stream.encoding)  # type: ignore
+        finally:
+            if stream is not None:
+                stream.close()
+
+
+class _EmptyIO(StringIO):
+    def write(self, *args: Any, **kwargs: Any) -> None:  # type: ignore # skipcq: PTC-W0049
+        pass
+
+
+Empty = _EmptyIO()
diff --git a/myenv/lib/python3.9/site-packages/isort/literal.py b/myenv/lib/python3.9/site-packages/isort/literal.py
new file mode 100644
index 0000000..62feea1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/literal.py
@@ -0,0 +1,113 @@
+import ast
+from pprint import PrettyPrinter
+from typing import Any, Callable, Dict, List, Set, Tuple
+
+from isort.exceptions import (
+    AssignmentsFormatMismatch,
+    LiteralParsingFailure,
+    LiteralSortTypeMismatch,
+)
+from isort.settings import DEFAULT_CONFIG, Config
+
+
+class ISortPrettyPrinter(PrettyPrinter):
+    """an isort customized pretty printer for sorted literals"""
+
+    def __init__(self, config: Config):
+        super().__init__(width=config.line_length, compact=True)
+
+
+type_mapping: Dict[str, Tuple[type, Callable[[Any, ISortPrettyPrinter], str]]] = {}
+
+
+def assignments(code: str) -> str:
+    values = {}
+    for line in code.splitlines(keepends=True):
+        if not line.strip():
+            continue
+        if " = " not in line:
+            raise AssignmentsFormatMismatch(code)
+        variable_name, value = line.split(" = ", 1)
+        values[variable_name] = value
+
+    return "".join(
+        f"{variable_name} = {values[variable_name]}" for variable_name in sorted(values.keys())
+    )
+
+
+def assignment(code: str, sort_type: str, extension: str, config: Config = DEFAULT_CONFIG) -> str:
+    """Sorts the literal present within the provided code against the provided sort type,
+    returning the sorted representation of the source code.
+    """
+    if sort_type == "assignments":
+        return assignments(code)
+    if sort_type not in type_mapping:
+        raise ValueError(
+            "Trying to sort using an undefined sort_type. "
+            f"Defined sort types are {', '.join(type_mapping.keys())}."
+        )
+
+    variable_name, literal = code.split(" = ")
+    variable_name = variable_name.lstrip()
+    try:
+        value = ast.literal_eval(literal)
+    except Exception as error:
+        raise LiteralParsingFailure(code, error)
+
+    expected_type, sort_function = type_mapping[sort_type]
+    if type(value) != expected_type:
+        raise LiteralSortTypeMismatch(type(value), expected_type)
+
+    printer = ISortPrettyPrinter(config)
+    sorted_value_code = f"{variable_name} = {sort_function(value, printer)}"
+    if config.formatting_function:
+        sorted_value_code = config.formatting_function(
+            sorted_value_code, extension, config
+        ).rstrip()
+
+    sorted_value_code += code[len(code.rstrip()) :]
+    return sorted_value_code
+
+
+def register_type(
+    name: str, kind: type
+) -> Callable[[Callable[[Any, ISortPrettyPrinter], str]], Callable[[Any, ISortPrettyPrinter], str]]:
+    """Registers a new literal sort type."""
+
+    def wrap(
+        function: Callable[[Any, ISortPrettyPrinter], str]
+    ) -> Callable[[Any, ISortPrettyPrinter], str]:
+        type_mapping[name] = (kind, function)
+        return function
+
+    return wrap
+
+
+@register_type("dict", dict)
+def _dict(value: Dict[Any, Any], printer: ISortPrettyPrinter) -> str:
+    return printer.pformat(dict(sorted(value.items(), key=lambda item: item[1])))  # type: ignore
+
+
+@register_type("list", list)
+def _list(value: List[Any], printer: ISortPrettyPrinter) -> str:
+    return printer.pformat(sorted(value))
+
+
+@register_type("unique-list", list)
+def _unique_list(value: List[Any], printer: ISortPrettyPrinter) -> str:
+    return printer.pformat(list(sorted(set(value))))
+
+
+@register_type("set", set)
+def _set(value: Set[Any], printer: ISortPrettyPrinter) -> str:
+    return "{" + printer.pformat(tuple(sorted(value)))[1:-1] + "}"
+
+
+@register_type("tuple", tuple)
+def _tuple(value: Tuple[Any, ...], printer: ISortPrettyPrinter) -> str:
+    return printer.pformat(tuple(sorted(value)))
+
+
+@register_type("unique-tuple", tuple)
+def _unique_tuple(value: Tuple[Any, ...], printer: ISortPrettyPrinter) -> str:
+    return printer.pformat(tuple(sorted(set(value))))
diff --git a/myenv/lib/python3.9/site-packages/isort/logo.py b/myenv/lib/python3.9/site-packages/isort/logo.py
new file mode 100644
index 0000000..6377d86
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/logo.py
@@ -0,0 +1,19 @@
+from ._version import __version__
+
+ASCII_ART = rf"""
+                 _                 _
+                (_) ___  ___  _ __| |_
+                | |/ _/ / _ \/ '__  _/
+                | |\__ \/\_\/| |  | |_
+                |_|\___/\___/\_/   \_/
+
+      isort your imports, so you don't have to.
+
+                    VERSION {__version__}
+"""
+
+__doc__ = f"""
+```python
+{ASCII_ART}
+```
+"""
diff --git a/myenv/lib/python3.9/site-packages/isort/main.py b/myenv/lib/python3.9/site-packages/isort/main.py
new file mode 100644
index 0000000..3d0c09d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/main.py
@@ -0,0 +1,1285 @@
+"""Tool for sorting imports alphabetically, and automatically separated into sections."""
+import argparse
+import functools
+import json
+import os
+import sys
+from gettext import gettext as _
+from io import TextIOWrapper
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Union
+from warnings import warn
+
+from . import __version__, api, files, sections
+from .exceptions import FileSkipped, ISortError, UnsupportedEncoding
+from .format import create_terminal_printer
+from .logo import ASCII_ART
+from .profiles import profiles
+from .settings import VALID_PY_TARGETS, Config, find_all_configs
+from .utils import Trie
+from .wrap_modes import WrapModes
+
+DEPRECATED_SINGLE_DASH_ARGS = {
+    "-ac",
+    "-af",
+    "-ca",
+    "-cs",
+    "-df",
+    "-ds",
+    "-dt",
+    "-fas",
+    "-fass",
+    "-ff",
+    "-fgw",
+    "-fss",
+    "-lai",
+    "-lbt",
+    "-le",
+    "-ls",
+    "-nis",
+    "-nlb",
+    "-ot",
+    "-rr",
+    "-sd",
+    "-sg",
+    "-sl",
+    "-sp",
+    "-tc",
+    "-wl",
+    "-ws",
+}
+QUICK_GUIDE = f"""
+{ASCII_ART}
+
+Nothing to do: no files or paths have have been passed in!
+
+Try one of the following:
+
+    `isort .` - sort all Python files, starting from the current directory, recursively.
+    `isort . --interactive` - Do the same, but ask before making any changes.
+    `isort . --check --diff` - Check to see if imports are correctly sorted within this project.
+    `isort --help` - In-depth information about isort's available command-line options.
+
+Visit https://pycqa.github.io/isort/ for complete information about how to use isort.
+"""
+
+
+class SortAttempt:
+    def __init__(self, incorrectly_sorted: bool, skipped: bool, supported_encoding: bool) -> None:
+        self.incorrectly_sorted = incorrectly_sorted
+        self.skipped = skipped
+        self.supported_encoding = supported_encoding
+
+
+def sort_imports(
+    file_name: str,
+    config: Config,
+    check: bool = False,
+    ask_to_apply: bool = False,
+    write_to_stdout: bool = False,
+    **kwargs: Any,
+) -> Optional[SortAttempt]:
+    incorrectly_sorted: bool = False
+    skipped: bool = False
+    try:
+        if check:
+            try:
+                incorrectly_sorted = not api.check_file(file_name, config=config, **kwargs)
+            except FileSkipped:
+                skipped = True
+            return SortAttempt(incorrectly_sorted, skipped, True)
+
+        try:
+            incorrectly_sorted = not api.sort_file(
+                file_name,
+                config=config,
+                ask_to_apply=ask_to_apply,
+                write_to_stdout=write_to_stdout,
+                **kwargs,
+            )
+        except FileSkipped:
+            skipped = True
+        return SortAttempt(incorrectly_sorted, skipped, True)
+    except (OSError, ValueError) as error:
+        warn(f"Unable to parse file {file_name} due to {error}")
+        return None
+    except UnsupportedEncoding:
+        if config.verbose:
+            warn(f"Encoding not supported for {file_name}")
+        return SortAttempt(incorrectly_sorted, skipped, False)
+    except ISortError as error:
+        _print_hard_fail(config, message=str(error))
+        sys.exit(1)
+    except Exception:
+        _print_hard_fail(config, offending_file=file_name)
+        raise
+
+
+def _print_hard_fail(
+    config: Config, offending_file: Optional[str] = None, message: Optional[str] = None
+) -> None:
+    """Fail on unrecoverable exception with custom message."""
+    message = message or (
+        f"Unrecoverable exception thrown when parsing {offending_file or ''}!"
+        "This should NEVER happen.\n"
+        "If encountered, please open an issue: https://github.com/PyCQA/isort/issues/new"
+    )
+    printer = create_terminal_printer(
+        color=config.color_output, error=config.format_error, success=config.format_success
+    )
+    printer.error(message)
+
+
+def _build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Sort Python import definitions alphabetically "
+        "within logical sections. Run with no arguments to see a quick "
+        "start guide, otherwise, one or more files/directories/stdin must be provided. "
+        "Use `-` as the first argument to represent stdin. Use --interactive to use the pre 5.0.0 "
+        "interactive behavior."
+        " "
+        "If you've used isort 4 but are new to isort 5, see the upgrading guide: "
+        "https://pycqa.github.io/isort/docs/upgrade_guides/5.0.0.html",
+        add_help=False,  # prevent help option from appearing in "optional arguments" group
+    )
+
+    general_group = parser.add_argument_group("general options")
+    target_group = parser.add_argument_group("target options")
+    output_group = parser.add_argument_group("general output options")
+    inline_args_group = output_group.add_mutually_exclusive_group()
+    section_group = parser.add_argument_group("section output options")
+    deprecated_group = parser.add_argument_group("deprecated options")
+
+    general_group.add_argument(
+        "-h",
+        "--help",
+        action="help",
+        default=argparse.SUPPRESS,
+        help=_("show this help message and exit"),
+    )
+    general_group.add_argument(
+        "-V",
+        "--version",
+        action="store_true",
+        dest="show_version",
+        help="Displays the currently installed version of isort.",
+    )
+    general_group.add_argument(
+        "--vn",
+        "--version-number",
+        action="version",
+        version=__version__,
+        help="Returns just the current version number without the logo",
+    )
+    general_group.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        dest="verbose",
+        help="Shows verbose output, such as when files are skipped or when a check is successful.",
+    )
+    general_group.add_argument(
+        "--only-modified",
+        "--om",
+        dest="only_modified",
+        action="store_true",
+        help="Suppresses verbose output for non-modified files.",
+    )
+    general_group.add_argument(
+        "--dedup-headings",
+        dest="dedup_headings",
+        action="store_true",
+        help="Tells isort to only show an identical custom import heading comment once, even if"
+        " there are multiple sections with the comment set.",
+    )
+    general_group.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        dest="quiet",
+        help="Shows extra quiet output, only errors are outputted.",
+    )
+    general_group.add_argument(
+        "-d",
+        "--stdout",
+        help="Force resulting output to stdout, instead of in-place.",
+        dest="write_to_stdout",
+        action="store_true",
+    )
+    general_group.add_argument(
+        "--overwrite-in-place",
+        help="Tells isort to overwrite in place using the same file handle. "
+        "Comes at a performance and memory usage penalty over its standard "
+        "approach but ensures all file flags and modes stay unchanged.",
+        dest="overwrite_in_place",
+        action="store_true",
+    )
+    general_group.add_argument(
+        "--show-config",
+        dest="show_config",
+        action="store_true",
+        help="See isort's determined config, as well as sources of config options.",
+    )
+    general_group.add_argument(
+        "--show-files",
+        dest="show_files",
+        action="store_true",
+        help="See the files isort will be run against with the current config options.",
+    )
+    general_group.add_argument(
+        "--df",
+        "--diff",
+        dest="show_diff",
+        action="store_true",
+        help="Prints a diff of all the changes isort would make to a file, instead of "
+        "changing it in place",
+    )
+    general_group.add_argument(
+        "-c",
+        "--check-only",
+        "--check",
+        action="store_true",
+        dest="check",
+        help="Checks the file for unsorted / unformatted imports and prints them to the "
+        "command line without modifying the file. Returns 0 when nothing would change and "
+        "returns 1 when the file would be reformatted.",
+    )
+    general_group.add_argument(
+        "--ws",
+        "--ignore-whitespace",
+        action="store_true",
+        dest="ignore_whitespace",
+        help="Tells isort to ignore whitespace differences when --check-only is being used.",
+    )
+    general_group.add_argument(
+        "--sp",
+        "--settings-path",
+        "--settings-file",
+        "--settings",
+        dest="settings_path",
+        help="Explicitly set the settings path or file instead of auto determining "
+        "based on file location.",
+    )
+    general_group.add_argument(
+        "--cr",
+        "--config-root",
+        dest="config_root",
+        help="Explicitly set the config root for resolving all configs. When used "
+        "with the --resolve-all-configs flag, isort will look at all sub-folders "
+        "in this config root to resolve config files and sort files based on the "
+        "closest available config(if any)",
+    )
+    general_group.add_argument(
+        "--resolve-all-configs",
+        dest="resolve_all_configs",
+        action="store_true",
+        help="Tells isort to resolve the configs for all sub-directories "
+        "and sort files in terms of its closest config files.",
+    )
+    general_group.add_argument(
+        "--profile",
+        dest="profile",
+        type=str,
+        help="Base profile type to use for configuration. "
+        f"Profiles include: {', '.join(profiles.keys())}. As well as any shared profiles.",
+    )
+    general_group.add_argument(
+        "--old-finders",
+        "--magic-placement",
+        dest="old_finders",
+        action="store_true",
+        help="Use the old deprecated finder logic that relies on environment introspection magic.",
+    )
+    general_group.add_argument(
+        "-j",
+        "--jobs",
+        help="Number of files to process in parallel.",
+        dest="jobs",
+        type=int,
+        nargs="?",
+        const=-1,
+    )
+    general_group.add_argument(
+        "--ac",
+        "--atomic",
+        dest="atomic",
+        action="store_true",
+        help="Ensures the output doesn't save if the resulting file contains syntax errors.",
+    )
+    general_group.add_argument(
+        "--interactive",
+        dest="ask_to_apply",
+        action="store_true",
+        help="Tells isort to apply changes interactively.",
+    )
+    general_group.add_argument(
+        "--format-error",
+        dest="format_error",
+        help="Override the format used to print errors.",
+    )
+    general_group.add_argument(
+        "--format-success",
+        dest="format_success",
+        help="Override the format used to print success.",
+    )
+
+    target_group.add_argument(
+        "files", nargs="*", help="One or more Python source files that need their imports sorted."
+    )
+    target_group.add_argument(
+        "--filter-files",
+        dest="filter_files",
+        action="store_true",
+        help="Tells isort to filter files even when they are explicitly passed in as "
+        "part of the CLI command.",
+    )
+    target_group.add_argument(
+        "-s",
+        "--skip",
+        help="Files that isort should skip over. If you want to skip multiple "
+        "files you should specify twice: --skip file1 --skip file2. Values can be "
+        "file names, directory names or file paths. To skip all files in a nested path "
+        "use --skip-glob.",
+        dest="skip",
+        action="append",
+    )
+    target_group.add_argument(
+        "--extend-skip",
+        help="Extends --skip to add additional files that isort should skip over. "
+        "If you want to skip multiple "
+        "files you should specify twice: --skip file1 --skip file2. Values can be "
+        "file names, directory names or file paths. To skip all files in a nested path "
+        "use --skip-glob.",
+        dest="extend_skip",
+        action="append",
+    )
+    target_group.add_argument(
+        "--sg",
+        "--skip-glob",
+        help="Files that isort should skip over.",
+        dest="skip_glob",
+        action="append",
+    )
+    target_group.add_argument(
+        "--extend-skip-glob",
+        help="Additional files that isort should skip over (extending --skip-glob).",
+        dest="extend_skip_glob",
+        action="append",
+    )
+    target_group.add_argument(
+        "--gitignore",
+        "--skip-gitignore",
+        action="store_true",
+        dest="skip_gitignore",
+        help="Treat project as a git repository and ignore files listed in .gitignore."
+        "\nNOTE: This requires git to be installed and accessible from the same shell as isort.",
+    )
+    target_group.add_argument(
+        "--ext",
+        "--extension",
+        "--supported-extension",
+        dest="supported_extensions",
+        action="append",
+        help="Specifies what extensions isort can be run against.",
+    )
+    target_group.add_argument(
+        "--blocked-extension",
+        dest="blocked_extensions",
+        action="append",
+        help="Specifies what extensions isort can never be run against.",
+    )
+    target_group.add_argument(
+        "--dont-follow-links",
+        dest="dont_follow_links",
+        action="store_true",
+        help="Tells isort not to follow symlinks that are encountered when running recursively.",
+    )
+    target_group.add_argument(
+        "--filename",
+        dest="filename",
+        help="Provide the filename associated with a stream.",
+    )
+    target_group.add_argument(
+        "--allow-root",
+        action="store_true",
+        default=False,
+        help="Tells isort not to treat / specially, allowing it to be run against the root dir.",
+    )
+
+    output_group.add_argument(
+        "-a",
+        "--add-import",
+        dest="add_imports",
+        action="append",
+        help="Adds the specified import line to all files, "
+        "automatically determining correct placement.",
+    )
+    output_group.add_argument(
+        "--append",
+        "--append-only",
+        dest="append_only",
+        action="store_true",
+        help="Only adds the imports specified in --add-import if the file"
+        " contains existing imports.",
+    )
+    output_group.add_argument(
+        "--af",
+        "--force-adds",
+        dest="force_adds",
+        action="store_true",
+        help="Forces import adds even if the original file is empty.",
+    )
+    output_group.add_argument(
+        "--rm",
+        "--remove-import",
+        dest="remove_imports",
+        action="append",
+        help="Removes the specified import from all files.",
+    )
+    output_group.add_argument(
+        "--float-to-top",
+        dest="float_to_top",
+        action="store_true",
+        help="Causes all non-indented imports to float to the top of the file having its imports "
+        "sorted (immediately below the top of file comment).\n"
+        "This can be an excellent shortcut for collecting imports every once in a while "
+        "when you place them in the middle of a file to avoid context switching.\n\n"
+        "*NOTE*: It currently doesn't work with cimports and introduces some extra over-head "
+        "and a performance penalty.",
+    )
+    output_group.add_argument(
+        "--dont-float-to-top",
+        dest="dont_float_to_top",
+        action="store_true",
+        help="Forces --float-to-top setting off. See --float-to-top for more information.",
+    )
+    output_group.add_argument(
+        "--ca",
+        "--combine-as",
+        dest="combine_as_imports",
+        action="store_true",
+        help="Combines as imports on the same line.",
+    )
+    output_group.add_argument(
+        "--cs",
+        "--combine-star",
+        dest="combine_star",
+        action="store_true",
+        help="Ensures that if a star import is present, "
+        "nothing else is imported from that namespace.",
+    )
+    output_group.add_argument(
+        "-e",
+        "--balanced",
+        dest="balanced_wrapping",
+        action="store_true",
+        help="Balances wrapping to produce the most consistent line length possible",
+    )
+    output_group.add_argument(
+        "--ff",
+        "--from-first",
+        dest="from_first",
+        action="store_true",
+        help="Switches the typical ordering preference, "
+        "showing from imports first then straight ones.",
+    )
+    output_group.add_argument(
+        "--fgw",
+        "--force-grid-wrap",
+        nargs="?",
+        const=2,
+        type=int,
+        dest="force_grid_wrap",
+        help="Force number of from imports (defaults to 2 when passed as CLI flag without value) "
+        "to be grid wrapped regardless of line "
+        "length. If 0 is passed in (the global default) only line length is considered.",
+    )
+    output_group.add_argument(
+        "-i",
+        "--indent",
+        help='String to place for indents defaults to "    " (4 spaces).',
+        dest="indent",
+        type=str,
+    )
+    output_group.add_argument(
+        "--lbi", "--lines-before-imports", dest="lines_before_imports", type=int
+    )
+    output_group.add_argument(
+        "--lai", "--lines-after-imports", dest="lines_after_imports", type=int
+    )
+    output_group.add_argument(
+        "--lbt", "--lines-between-types", dest="lines_between_types", type=int
+    )
+    output_group.add_argument(
+        "--le",
+        "--line-ending",
+        dest="line_ending",
+        help="Forces line endings to the specified value. "
+        "If not set, values will be guessed per-file.",
+    )
+    output_group.add_argument(
+        "--ls",
+        "--length-sort",
+        help="Sort imports by their string length.",
+        dest="length_sort",
+        action="store_true",
+    )
+    output_group.add_argument(
+        "--lss",
+        "--length-sort-straight",
+        help="Sort straight imports by their string length. Similar to `length_sort` "
+        "but applies only to straight imports and doesn't affect from imports.",
+        dest="length_sort_straight",
+        action="store_true",
+    )
+    output_group.add_argument(
+        "-m",
+        "--multi-line",
+        dest="multi_line_output",
+        choices=list(WrapModes.__members__.keys())
+        + [str(mode.value) for mode in WrapModes.__members__.values()],
+        type=str,
+        help="Multi line output (0-grid, 1-vertical, 2-hanging, 3-vert-hanging, 4-vert-grid, "
+        "5-vert-grid-grouped, 6-deprecated-alias-for-5, 7-noqa, "
+        "8-vertical-hanging-indent-bracket, 9-vertical-prefix-from-module-import, "
+        "10-hanging-indent-with-parentheses).",
+    )
+    output_group.add_argument(
+        "-n",
+        "--ensure-newline-before-comments",
+        dest="ensure_newline_before_comments",
+        action="store_true",
+        help="Inserts a blank line before a comment following an import.",
+    )
+    inline_args_group.add_argument(
+        "--nis",
+        "--no-inline-sort",
+        dest="no_inline_sort",
+        action="store_true",
+        help="Leaves `from` imports with multiple imports 'as-is' "
+        "(e.g. `from foo import a, c ,b`).",
+    )
+    output_group.add_argument(
+        "--ot",
+        "--order-by-type",
+        dest="order_by_type",
+        action="store_true",
+        help="Order imports by type, which is determined by case, in addition to alphabetically.\n"
+        "\n**NOTE**: type here refers to the implied type from the import name capitalization.\n"
+        ' isort does not do type introspection for the imports. These "types" are simply: '
+        "CONSTANT_VARIABLE, CamelCaseClass, variable_or_function. If your project follows PEP8"
+        " or a related coding standard and has many imports this is a good default, otherwise you "
+        "likely will want to turn it off. From the CLI the `--dont-order-by-type` option will turn "
+        "this off.",
+    )
+    output_group.add_argument(
+        "--dt",
+        "--dont-order-by-type",
+        dest="dont_order_by_type",
+        action="store_true",
+        help="Don't order imports by type, which is determined by case, in addition to "
+        "alphabetically.\n\n"
+        "**NOTE**: type here refers to the implied type from the import name capitalization.\n"
+        ' isort does not do type introspection for the imports. These "types" are simply: '
+        "CONSTANT_VARIABLE, CamelCaseClass, variable_or_function. If your project follows PEP8"
+        " or a related coding standard and has many imports this is a good default. You can turn "
+        "this on from the CLI using `--order-by-type`.",
+    )
+    output_group.add_argument(
+        "--rr",
+        "--reverse-relative",
+        dest="reverse_relative",
+        action="store_true",
+        help="Reverse order of relative imports.",
+    )
+    output_group.add_argument(
+        "--reverse-sort",
+        dest="reverse_sort",
+        action="store_true",
+        help="Reverses the ordering of imports.",
+    )
+    output_group.add_argument(
+        "--sort-order",
+        dest="sort_order",
+        help="Specify sorting function. Can be built in (natural[default] = force numbers "
+        "to be sequential, native = Python's built-in sorted function) or an installable plugin.",
+    )
+    inline_args_group.add_argument(
+        "--sl",
+        "--force-single-line-imports",
+        dest="force_single_line",
+        action="store_true",
+        help="Forces all from imports to appear on their own line",
+    )
+    output_group.add_argument(
+        "--nsl",
+        "--single-line-exclusions",
+        help="One or more modules to exclude from the single line rule.",
+        dest="single_line_exclusions",
+        action="append",
+    )
+    output_group.add_argument(
+        "--tc",
+        "--trailing-comma",
+        dest="include_trailing_comma",
+        action="store_true",
+        help="Includes a trailing comma on multi line imports that include parentheses.",
+    )
+    output_group.add_argument(
+        "--up",
+        "--use-parentheses",
+        dest="use_parentheses",
+        action="store_true",
+        help="Use parentheses for line continuation on length limit instead of slashes."
+        " **NOTE**: This is separate from wrap modes, and only affects how individual lines that "
+        " are too long get continued, not sections of multiple imports.",
+    )
+    output_group.add_argument(
+        "-l",
+        "-w",
+        "--line-length",
+        "--line-width",
+        help="The max length of an import line (used for wrapping long imports).",
+        dest="line_length",
+        type=int,
+    )
+    output_group.add_argument(
+        "--wl",
+        "--wrap-length",
+        dest="wrap_length",
+        type=int,
+        help="Specifies how long lines that are wrapped should be, if not set line_length is used."
+        "\nNOTE: wrap_length must be LOWER than or equal to line_length.",
+    )
+    output_group.add_argument(
+        "--case-sensitive",
+        dest="case_sensitive",
+        action="store_true",
+        help="Tells isort to include casing when sorting module names",
+    )
+    output_group.add_argument(
+        "--remove-redundant-aliases",
+        dest="remove_redundant_aliases",
+        action="store_true",
+        help=(
+            "Tells isort to remove redundant aliases from imports, such as `import os as os`."
+            " This defaults to `False` simply because some projects use these seemingly useless "
+            " aliases to signify intent and change behaviour."
+        ),
+    )
+    output_group.add_argument(
+        "--honor-noqa",
+        dest="honor_noqa",
+        action="store_true",
+        help="Tells isort to honor noqa comments to enforce skipping those comments.",
+    )
+    output_group.add_argument(
+        "--treat-comment-as-code",
+        dest="treat_comments_as_code",
+        action="append",
+        help="Tells isort to treat the specified single line comment(s) as if they are code.",
+    )
+    output_group.add_argument(
+        "--treat-all-comment-as-code",
+        dest="treat_all_comments_as_code",
+        action="store_true",
+        help="Tells isort to treat all single line comments as if they are code.",
+    )
+    output_group.add_argument(
+        "--formatter",
+        dest="formatter",
+        type=str,
+        help="Specifies the name of a formatting plugin to use when producing output.",
+    )
+    output_group.add_argument(
+        "--color",
+        dest="color_output",
+        action="store_true",
+        help="Tells isort to use color in terminal output.",
+    )
+    output_group.add_argument(
+        "--ext-format",
+        dest="ext_format",
+        help="Tells isort to format the given files according to an extensions formatting rules.",
+    )
+    output_group.add_argument(
+        "--star-first",
+        help="Forces star imports above others to avoid overriding directly imported variables.",
+        dest="star_first",
+        action="store_true",
+    )
+
+    section_group.add_argument(
+        "--sd",
+        "--section-default",
+        dest="default_section",
+        help="Sets the default section for import options: " + str(sections.DEFAULT),
+    )
+    section_group.add_argument(
+        "--only-sections",
+        "--os",
+        dest="only_sections",
+        action="store_true",
+        help="Causes imports to be sorted based on their sections like STDLIB, THIRDPARTY, etc. "
+        "Within sections, the imports are ordered by their import style and the imports with "
+        "the same style maintain their relative positions.",
+    )
+    section_group.add_argument(
+        "--ds",
+        "--no-sections",
+        help="Put all imports into the same section bucket",
+        dest="no_sections",
+        action="store_true",
+    )
+    section_group.add_argument(
+        "--fas",
+        "--force-alphabetical-sort",
+        action="store_true",
+        dest="force_alphabetical_sort",
+        help="Force all imports to be sorted as a single section",
+    )
+    section_group.add_argument(
+        "--fss",
+        "--force-sort-within-sections",
+        action="store_true",
+        dest="force_sort_within_sections",
+        help="Don't sort straight-style imports (like import sys) before from-style imports "
+        "(like from itertools import groupby). Instead, sort the imports by module, "
+        "independent of import style.",
+    )
+    section_group.add_argument(
+        "--hcss",
+        "--honor-case-in-force-sorted-sections",
+        action="store_true",
+        dest="honor_case_in_force_sorted_sections",
+        help="Honor `--case-sensitive` when `--force-sort-within-sections` is being used. "
+        "Without this option set, `--order-by-type` decides module name ordering too.",
+    )
+    section_group.add_argument(
+        "--srss",
+        "--sort-relative-in-force-sorted-sections",
+        action="store_true",
+        dest="sort_relative_in_force_sorted_sections",
+        help="When using `--force-sort-within-sections`, sort relative imports the same "
+        "way as they are sorted when not using that setting.",
+    )
+    section_group.add_argument(
+        "--fass",
+        "--force-alphabetical-sort-within-sections",
+        action="store_true",
+        dest="force_alphabetical_sort_within_sections",
+        help="Force all imports to be sorted alphabetically within a section",
+    )
+    section_group.add_argument(
+        "-t",
+        "--top",
+        help="Force specific imports to the top of their appropriate section.",
+        dest="force_to_top",
+        action="append",
+    )
+    section_group.add_argument(
+        "--combine-straight-imports",
+        "--csi",
+        dest="combine_straight_imports",
+        action="store_true",
+        help="Combines all the bare straight imports of the same section in a single line. "
+        "Won't work with sections which have 'as' imports",
+    )
+    section_group.add_argument(
+        "--nlb",
+        "--no-lines-before",
+        help="Sections which should not be split with previous by empty lines",
+        dest="no_lines_before",
+        action="append",
+    )
+    section_group.add_argument(
+        "--src",
+        "--src-path",
+        dest="src_paths",
+        action="append",
+        help="Add an explicitly defined source path "
+        "(modules within src paths have their imports automatically categorized as first_party)."
+        " Glob expansion (`*` and `**`) is supported for this option.",
+    )
+    section_group.add_argument(
+        "-b",
+        "--builtin",
+        dest="known_standard_library",
+        action="append",
+        help="Force isort to recognize a module as part of Python's standard library.",
+    )
+    section_group.add_argument(
+        "--extra-builtin",
+        dest="extra_standard_library",
+        action="append",
+        help="Extra modules to be included in the list of ones in Python's standard library.",
+    )
+    section_group.add_argument(
+        "-f",
+        "--future",
+        dest="known_future_library",
+        action="append",
+        help="Force isort to recognize a module as part of Python's internal future compatibility "
+        "libraries. WARNING: this overrides the behavior of __future__ handling and therefore"
+        " can result in code that can't execute. If you're looking to add dependencies such "
+        "as six, a better option is to create another section below --future using custom "
+        "sections. See: https://github.com/PyCQA/isort#custom-sections-and-ordering and the "
+        "discussion here: https://github.com/PyCQA/isort/issues/1463.",
+    )
+    section_group.add_argument(
+        "-o",
+        "--thirdparty",
+        dest="known_third_party",
+        action="append",
+        help="Force isort to recognize a module as being part of a third party library.",
+    )
+    section_group.add_argument(
+        "-p",
+        "--project",
+        dest="known_first_party",
+        action="append",
+        help="Force isort to recognize a module as being part of the current python project.",
+    )
+    section_group.add_argument(
+        "--known-local-folder",
+        dest="known_local_folder",
+        action="append",
+        help="Force isort to recognize a module as being a local folder. "
+        "Generally, this is reserved for relative imports (from . import module).",
+    )
+    section_group.add_argument(
+        "--virtual-env",
+        dest="virtual_env",
+        help="Virtual environment to use for determining whether a package is third-party",
+    )
+    section_group.add_argument(
+        "--conda-env",
+        dest="conda_env",
+        help="Conda environment to use for determining whether a package is third-party",
+    )
+    section_group.add_argument(
+        "--py",
+        "--python-version",
+        action="store",
+        dest="py_version",
+        choices=tuple(VALID_PY_TARGETS) + ("auto",),
+        help="Tells isort to set the known standard library based on the specified Python "
+        "version. Default is to assume any Python 3 version could be the target, and use a union "
+        "of all stdlib modules across versions. If auto is specified, the version of the "
+        "interpreter used to run isort "
+        f"(currently: {sys.version_info.major}{sys.version_info.minor}) will be used.",
+    )
+
+    # deprecated options
+    deprecated_group.add_argument(
+        "--recursive",
+        dest="deprecated_flags",
+        action="append_const",
+        const="--recursive",
+        help=argparse.SUPPRESS,
+    )
+    deprecated_group.add_argument(
+        "-rc", dest="deprecated_flags", action="append_const", const="-rc", help=argparse.SUPPRESS
+    )
+    deprecated_group.add_argument(
+        "--dont-skip",
+        dest="deprecated_flags",
+        action="append_const",
+        const="--dont-skip",
+        help=argparse.SUPPRESS,
+    )
+    deprecated_group.add_argument(
+        "-ns", dest="deprecated_flags", action="append_const", const="-ns", help=argparse.SUPPRESS
+    )
+    deprecated_group.add_argument(
+        "--apply",
+        dest="deprecated_flags",
+        action="append_const",
+        const="--apply",
+        help=argparse.SUPPRESS,
+    )
+    deprecated_group.add_argument(
+        "-k",
+        "--keep-direct-and-as",
+        dest="deprecated_flags",
+        action="append_const",
+        const="--keep-direct-and-as",
+        help=argparse.SUPPRESS,
+    )
+
+    return parser
+
+
+def parse_args(argv: Optional[Sequence[str]] = None) -> Dict[str, Any]:
+    argv = sys.argv[1:] if argv is None else list(argv)
+    remapped_deprecated_args = []
+    for index, arg in enumerate(argv):
+        if arg in DEPRECATED_SINGLE_DASH_ARGS:
+            remapped_deprecated_args.append(arg)
+            argv[index] = f"-{arg}"
+
+    parser = _build_arg_parser()
+    arguments = {key: value for key, value in vars(parser.parse_args(argv)).items() if value}
+    if remapped_deprecated_args:
+        arguments["remapped_deprecated_args"] = remapped_deprecated_args
+    if "dont_order_by_type" in arguments:
+        arguments["order_by_type"] = False
+        del arguments["dont_order_by_type"]
+    if "dont_follow_links" in arguments:
+        arguments["follow_links"] = False
+        del arguments["dont_follow_links"]
+    if "dont_float_to_top" in arguments:
+        del arguments["dont_float_to_top"]
+        if arguments.get("float_to_top", False):
+            sys.exit("Can't set both --float-to-top and --dont-float-to-top.")
+        else:
+            arguments["float_to_top"] = False
+    multi_line_output = arguments.get("multi_line_output", None)
+    if multi_line_output:
+        if multi_line_output.isdigit():
+            arguments["multi_line_output"] = WrapModes(int(multi_line_output))
+        else:
+            arguments["multi_line_output"] = WrapModes[multi_line_output]
+
+    return arguments
+
+
+def _preconvert(item: Any) -> Union[str, List[Any]]:
+    """Preconverts objects from native types into JSONifyiable types"""
+    if isinstance(item, (set, frozenset)):
+        return list(item)
+    if isinstance(item, WrapModes):
+        return str(item.name)
+    if isinstance(item, Path):
+        return str(item)
+    if callable(item) and hasattr(item, "__name__"):
+        return str(item.__name__)
+    raise TypeError("Unserializable object {} of type {}".format(item, type(item)))
+
+
+def identify_imports_main(
+    argv: Optional[Sequence[str]] = None, stdin: Optional[TextIOWrapper] = None
+) -> None:
+    parser = argparse.ArgumentParser(
+        description="Get all import definitions from a given file."
+        "Use `-` as the first argument to represent stdin."
+    )
+    parser.add_argument(
+        "files", nargs="+", help="One or more Python source files that need their imports sorted."
+    )
+    parser.add_argument(
+        "--top-only",
+        action="store_true",
+        default=False,
+        help="Only identify imports that occur in before functions or classes.",
+    )
+
+    target_group = parser.add_argument_group("target options")
+    target_group.add_argument(
+        "--follow-links",
+        action="store_true",
+        default=False,
+        help="Tells isort to follow symlinks that are encountered when running recursively.",
+    )
+
+    uniqueness = parser.add_mutually_exclusive_group()
+    uniqueness.add_argument(
+        "--unique",
+        action="store_true",
+        default=False,
+        help="If true, isort will only identify unique imports.",
+    )
+    uniqueness.add_argument(
+        "--packages",
+        dest="unique",
+        action="store_const",
+        const=api.ImportKey.PACKAGE,
+        default=False,
+        help="If true, isort will only identify the unique top level modules imported.",
+    )
+    uniqueness.add_argument(
+        "--modules",
+        dest="unique",
+        action="store_const",
+        const=api.ImportKey.MODULE,
+        default=False,
+        help="If true, isort will only identify the unique modules imported.",
+    )
+    uniqueness.add_argument(
+        "--attributes",
+        dest="unique",
+        action="store_const",
+        const=api.ImportKey.ATTRIBUTE,
+        default=False,
+        help="If true, isort will only identify the unique attributes imported.",
+    )
+
+    arguments = parser.parse_args(argv)
+
+    file_names = arguments.files
+    if file_names == ["-"]:
+        identified_imports = api.find_imports_in_stream(
+            sys.stdin if stdin is None else stdin,
+            unique=arguments.unique,
+            top_only=arguments.top_only,
+            follow_links=arguments.follow_links,
+        )
+    else:
+        identified_imports = api.find_imports_in_paths(
+            file_names,
+            unique=arguments.unique,
+            top_only=arguments.top_only,
+            follow_links=arguments.follow_links,
+        )
+
+    for identified_import in identified_imports:
+        if arguments.unique == api.ImportKey.PACKAGE:
+            print(identified_import.module.split(".")[0])
+        elif arguments.unique == api.ImportKey.MODULE:
+            print(identified_import.module)
+        elif arguments.unique == api.ImportKey.ATTRIBUTE:
+            print(f"{identified_import.module}.{identified_import.attribute}")
+        else:
+            print(str(identified_import))
+
+
+def main(argv: Optional[Sequence[str]] = None, stdin: Optional[TextIOWrapper] = None) -> None:
+    arguments = parse_args(argv)
+    if arguments.get("show_version"):
+        print(ASCII_ART)
+        return
+
+    show_config: bool = arguments.pop("show_config", False)
+    show_files: bool = arguments.pop("show_files", False)
+    if show_config and show_files:
+        sys.exit("Error: either specify show-config or show-files not both.")
+
+    if "settings_path" in arguments:
+        if os.path.isfile(arguments["settings_path"]):
+            arguments["settings_file"] = os.path.abspath(arguments["settings_path"])
+            arguments["settings_path"] = os.path.dirname(arguments["settings_file"])
+        else:
+            arguments["settings_path"] = os.path.abspath(arguments["settings_path"])
+
+    if "virtual_env" in arguments:
+        venv = arguments["virtual_env"]
+        arguments["virtual_env"] = os.path.abspath(venv)
+        if not os.path.isdir(arguments["virtual_env"]):
+            warn(f"virtual_env dir does not exist: {arguments['virtual_env']}")
+
+    file_names = arguments.pop("files", [])
+    if not file_names and not show_config:
+        print(QUICK_GUIDE)
+        if arguments:
+            sys.exit("Error: arguments passed in without any paths or content.")
+        return
+    if "settings_path" not in arguments:
+        arguments["settings_path"] = (
+            os.path.abspath(file_names[0] if file_names else ".") or os.getcwd()
+        )
+        if not os.path.isdir(arguments["settings_path"]):
+            arguments["settings_path"] = os.path.dirname(arguments["settings_path"])
+
+    config_dict = arguments.copy()
+    ask_to_apply = config_dict.pop("ask_to_apply", False)
+    jobs = config_dict.pop("jobs", None)
+    check = config_dict.pop("check", False)
+    show_diff = config_dict.pop("show_diff", False)
+    write_to_stdout = config_dict.pop("write_to_stdout", False)
+    deprecated_flags = config_dict.pop("deprecated_flags", False)
+    remapped_deprecated_args = config_dict.pop("remapped_deprecated_args", False)
+    stream_filename = config_dict.pop("filename", None)
+    ext_format = config_dict.pop("ext_format", None)
+    allow_root = config_dict.pop("allow_root", None)
+    resolve_all_configs = config_dict.pop("resolve_all_configs", False)
+    wrong_sorted_files = False
+    all_attempt_broken = False
+    no_valid_encodings = False
+
+    config_trie: Optional[Trie] = None
+    if resolve_all_configs:
+        config_trie = find_all_configs(config_dict.pop("config_root", "."))
+
+    if "src_paths" in config_dict:
+        config_dict["src_paths"] = {
+            Path(src_path).resolve() for src_path in config_dict.get("src_paths", ())
+        }
+
+    config = Config(**config_dict)
+    if show_config:
+        print(json.dumps(config.__dict__, indent=4, separators=(",", ": "), default=_preconvert))
+        return
+    if file_names == ["-"]:
+        file_path = Path(stream_filename) if stream_filename else None
+        if show_files:
+            sys.exit("Error: can't show files for streaming input.")
+
+        input_stream = sys.stdin if stdin is None else stdin
+        if check:
+            incorrectly_sorted = not api.check_stream(
+                input_stream=input_stream,
+                config=config,
+                show_diff=show_diff,
+                file_path=file_path,
+                extension=ext_format,
+            )
+
+            wrong_sorted_files = incorrectly_sorted
+        else:
+            try:
+                api.sort_stream(
+                    input_stream=input_stream,
+                    output_stream=sys.stdout,
+                    config=config,
+                    show_diff=show_diff,
+                    file_path=file_path,
+                    extension=ext_format,
+                    raise_on_skip=False,
+                )
+            except FileSkipped:
+                sys.stdout.write(input_stream.read())
+    elif "/" in file_names and not allow_root:
+        printer = create_terminal_printer(
+            color=config.color_output, error=config.format_error, success=config.format_success
+        )
+        printer.error("it is dangerous to operate recursively on '/'")
+        printer.error("use --allow-root to override this failsafe")
+        sys.exit(1)
+    else:
+        if stream_filename:
+            printer = create_terminal_printer(
+                color=config.color_output, error=config.format_error, success=config.format_success
+            )
+            printer.error("Filename override is intended only for stream (-) sorting.")
+            sys.exit(1)
+        skipped: List[str] = []
+        broken: List[str] = []
+
+        if config.filter_files:
+            filtered_files = []
+            for file_name in file_names:
+                if config.is_skipped(Path(file_name)):
+                    skipped.append(file_name)
+                else:
+                    filtered_files.append(file_name)
+            file_names = filtered_files
+
+        file_names = files.find(file_names, config, skipped, broken)
+        if show_files:
+            for file_name in file_names:
+                print(file_name)
+            return
+        num_skipped = 0
+        num_broken = 0
+        num_invalid_encoding = 0
+        if config.verbose:
+            print(ASCII_ART)
+
+        if jobs:
+            import multiprocessing
+
+            executor = multiprocessing.Pool(jobs if jobs > 0 else multiprocessing.cpu_count())
+            attempt_iterator = executor.imap(
+                functools.partial(
+                    sort_imports,
+                    config=config,
+                    check=check,
+                    ask_to_apply=ask_to_apply,
+                    write_to_stdout=write_to_stdout,
+                    extension=ext_format,
+                    config_trie=config_trie,
+                ),
+                file_names,
+            )
+        else:
+            # https://github.com/python/typeshed/pull/2814
+            attempt_iterator = (
+                sort_imports(  # type: ignore
+                    file_name,
+                    config=config,
+                    check=check,
+                    ask_to_apply=ask_to_apply,
+                    show_diff=show_diff,
+                    write_to_stdout=write_to_stdout,
+                    extension=ext_format,
+                    config_trie=config_trie,
+                )
+                for file_name in file_names
+            )
+
+        # If any files passed in are missing considered as error, should be removed
+        is_no_attempt = True
+        any_encoding_valid = False
+        for sort_attempt in attempt_iterator:
+            if not sort_attempt:
+                continue  # pragma: no cover - shouldn't happen, satisfies type constraint
+            incorrectly_sorted = sort_attempt.incorrectly_sorted
+            if arguments.get("check", False) and incorrectly_sorted:
+                wrong_sorted_files = True
+            if sort_attempt.skipped:
+                num_skipped += (
+                    1  # pragma: no cover - shouldn't happen, due to skip in iter_source_code
+                )
+
+            if not sort_attempt.supported_encoding:
+                num_invalid_encoding += 1
+            else:
+                any_encoding_valid = True
+
+            is_no_attempt = False
+
+        num_skipped += len(skipped)
+        if num_skipped and not config.quiet:
+            if config.verbose:
+                for was_skipped in skipped:
+                    print(
+                        f"{was_skipped} was skipped as it's listed in 'skip' setting, "
+                        "matches a glob in 'skip_glob' setting, or is in a .gitignore file with "
+                        "--skip-gitignore enabled."
+                    )
+            print(f"Skipped {num_skipped} files")
+
+        num_broken += len(broken)
+        if num_broken and not config.quiet:
+            if config.verbose:
+                for was_broken in broken:
+                    warn(f"{was_broken} was broken path, make sure it exists correctly")
+            print(f"Broken {num_broken} paths")
+
+        if num_broken > 0 and is_no_attempt:
+            all_attempt_broken = True
+        if num_invalid_encoding > 0 and not any_encoding_valid:
+            no_valid_encodings = True
+
+    if not config.quiet and (remapped_deprecated_args or deprecated_flags):
+        if remapped_deprecated_args:
+            warn(
+                "W0502: The following deprecated single dash CLI flags were used and translated: "
+                f"{', '.join(remapped_deprecated_args)}!"
+            )
+        if deprecated_flags:
+            warn(
+                "W0501: The following deprecated CLI flags were used and ignored: "
+                f"{', '.join(deprecated_flags)}!"
+            )
+        warn(
+            "W0500: Please see the 5.0.0 Upgrade guide: "
+            "https://pycqa.github.io/isort/docs/upgrade_guides/5.0.0.html"
+        )
+
+    if wrong_sorted_files:
+        sys.exit(1)
+
+    if all_attempt_broken:
+        sys.exit(1)
+
+    if no_valid_encodings:
+        printer = create_terminal_printer(
+            color=config.color_output, error=config.format_error, success=config.format_success
+        )
+        printer.error("No valid encodings.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/myenv/lib/python3.9/site-packages/isort/output.py b/myenv/lib/python3.9/site-packages/isort/output.py
new file mode 100644
index 0000000..d049daf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/output.py
@@ -0,0 +1,655 @@
+import copy
+import itertools
+from functools import partial
+from typing import Any, Iterable, List, Optional, Set, Tuple, Type
+
+from isort.format import format_simplified
+
+from . import parse, sorting, wrap
+from .comments import add_to_line as with_comments
+from .identify import STATEMENT_DECLARATIONS
+from .settings import DEFAULT_CONFIG, Config
+
+
+def sorted_imports(
+    parsed: parse.ParsedContent,
+    config: Config = DEFAULT_CONFIG,
+    extension: str = "py",
+    import_type: str = "import",
+) -> str:
+    """Adds the imports back to the file.
+
+    (at the index of the first import) sorted alphabetically and split between groups
+
+    """
+    if parsed.import_index == -1:
+        return _output_as_string(parsed.lines_without_imports, parsed.line_separator)
+
+    formatted_output: List[str] = parsed.lines_without_imports.copy()
+    remove_imports = [format_simplified(removal) for removal in config.remove_imports]
+
+    sections: Iterable[str] = itertools.chain(parsed.sections, config.forced_separate)
+
+    if config.no_sections:
+        parsed.imports["no_sections"] = {"straight": {}, "from": {}}
+        base_sections: Tuple[str, ...] = ()
+        for section in sections:
+            if section == "FUTURE":
+                base_sections = ("FUTURE",)
+                continue
+            parsed.imports["no_sections"]["straight"].update(
+                parsed.imports[section].get("straight", {})
+            )
+            parsed.imports["no_sections"]["from"].update(parsed.imports[section].get("from", {}))
+        sections = base_sections + ("no_sections",)
+
+    output: List[str] = []
+    seen_headings: Set[str] = set()
+    pending_lines_before = False
+    for section in sections:
+        straight_modules = parsed.imports[section]["straight"]
+        if not config.only_sections:
+            straight_modules = sorting.sort(
+                config,
+                straight_modules,
+                key=lambda key: sorting.module_key(
+                    key, config, section_name=section, straight_import=True
+                ),
+                reverse=config.reverse_sort,
+            )
+
+        from_modules = parsed.imports[section]["from"]
+        if not config.only_sections:
+            from_modules = sorting.sort(
+                config,
+                from_modules,
+                key=lambda key: sorting.module_key(key, config, section_name=section),
+                reverse=config.reverse_sort,
+            )
+
+            if config.star_first:
+                star_modules = []
+                other_modules = []
+                for module in from_modules:
+                    if "*" in parsed.imports[section]["from"][module]:
+                        star_modules.append(module)
+                    else:
+                        other_modules.append(module)
+                from_modules = star_modules + other_modules
+
+        straight_imports = _with_straight_imports(
+            parsed, config, straight_modules, section, remove_imports, import_type
+        )
+        from_imports = _with_from_imports(
+            parsed, config, from_modules, section, remove_imports, import_type
+        )
+
+        lines_between = [""] * (
+            config.lines_between_types if from_modules and straight_modules else 0
+        )
+        if config.from_first:
+            section_output = from_imports + lines_between + straight_imports
+        else:
+            section_output = straight_imports + lines_between + from_imports
+
+        if config.force_sort_within_sections:
+            # collapse comments
+            comments_above = []
+            new_section_output: List[str] = []
+            for line in section_output:
+                if not line:
+                    continue
+                if line.startswith("#"):
+                    comments_above.append(line)
+                elif comments_above:
+                    new_section_output.append(_LineWithComments(line, comments_above))
+                    comments_above = []
+                else:
+                    new_section_output.append(line)
+            # only_sections options is not imposed if force_sort_within_sections is True
+            new_section_output = sorting.sort(
+                config,
+                new_section_output,
+                key=partial(sorting.section_key, config=config),
+                reverse=config.reverse_sort,
+            )
+
+            # uncollapse comments
+            section_output = []
+            for line in new_section_output:
+                comments = getattr(line, "comments", ())
+                if comments:
+                    section_output.extend(comments)
+                section_output.append(str(line))
+
+        section_name = section
+        no_lines_before = section_name in config.no_lines_before
+
+        if section_output:
+            if section_name in parsed.place_imports:
+                parsed.place_imports[section_name] = section_output
+                continue
+
+            section_title = config.import_headings.get(section_name.lower(), "")
+            if section_title and section_title not in seen_headings:
+                if config.dedup_headings:
+                    seen_headings.add(section_title)
+                section_comment = f"# {section_title}"
+                if section_comment not in parsed.lines_without_imports[0:1]:  # pragma: no branch
+                    section_output.insert(0, section_comment)
+
+            section_footer = config.import_footers.get(section_name.lower(), "")
+            if section_footer and section_footer not in seen_headings:
+                if config.dedup_headings:
+                    seen_headings.add(section_footer)
+                section_comment_end = f"# {section_footer}"
+                if (
+                    section_comment_end not in parsed.lines_without_imports[-1:]
+                ):  # pragma: no branch
+                    section_output.append("")  # Empty line for black compatibility
+                    section_output.append(section_comment_end)
+
+            if pending_lines_before or not no_lines_before:
+                output += [""] * config.lines_between_sections
+
+            output += section_output
+
+            pending_lines_before = False
+        else:
+            pending_lines_before = pending_lines_before or not no_lines_before
+
+    if config.ensure_newline_before_comments:
+        output = _ensure_newline_before_comment(output)
+
+    while output and output[-1].strip() == "":
+        output.pop()  # pragma: no cover
+    while output and output[0].strip() == "":
+        output.pop(0)
+
+    if config.formatting_function:
+        output = config.formatting_function(
+            parsed.line_separator.join(output), extension, config
+        ).splitlines()
+
+    output_at = 0
+    if parsed.import_index < parsed.original_line_count:
+        output_at = parsed.import_index
+    formatted_output[output_at:0] = output
+
+    if output:
+        imports_tail = output_at + len(output)
+        while [
+            character.strip() for character in formatted_output[imports_tail : imports_tail + 1]
+        ] == [""]:
+            formatted_output.pop(imports_tail)
+
+        if len(formatted_output) > imports_tail:
+            next_construct = ""
+            tail = formatted_output[imports_tail:]
+
+            for index, line in enumerate(tail):  # pragma: no branch
+                should_skip, in_quote, *_ = parse.skip_line(
+                    line,
+                    in_quote="",
+                    index=len(formatted_output),
+                    section_comments=config.section_comments,
+                    needs_import=False,
+                )
+                if not should_skip and line.strip():
+                    if (
+                        line.strip().startswith("#")
+                        and len(tail) > (index + 1)
+                        and tail[index + 1].strip()
+                    ):
+                        continue
+                    next_construct = line
+                    break
+                if in_quote:  # pragma: no branch
+                    next_construct = line
+                    break
+
+            if config.lines_after_imports != -1:
+                formatted_output[imports_tail:0] = [
+                    "" for line in range(config.lines_after_imports)
+                ]
+            elif extension != "pyi" and next_construct.startswith(STATEMENT_DECLARATIONS):
+                formatted_output[imports_tail:0] = ["", ""]
+            else:
+                formatted_output[imports_tail:0] = [""]
+
+            if config.lines_before_imports != -1:
+                formatted_output[:0] = ["" for line in range(config.lines_before_imports)]
+
+    if parsed.place_imports:
+        new_out_lines = []
+        for index, line in enumerate(formatted_output):
+            new_out_lines.append(line)
+            if line in parsed.import_placements:
+                new_out_lines.extend(parsed.place_imports[parsed.import_placements[line]])
+                if (
+                    len(formatted_output) <= (index + 1)
+                    or formatted_output[index + 1].strip() != ""
+                ):
+                    new_out_lines.append("")
+        formatted_output = new_out_lines
+
+    return _output_as_string(formatted_output, parsed.line_separator)
+
+
+def _with_from_imports(
+    parsed: parse.ParsedContent,
+    config: Config,
+    from_modules: Iterable[str],
+    section: str,
+    remove_imports: List[str],
+    import_type: str,
+) -> List[str]:
+    output: List[str] = []
+    for module in from_modules:
+        if module in remove_imports:
+            continue
+
+        import_start = f"from {module} {import_type} "
+        from_imports = list(parsed.imports[section]["from"][module])
+        if (
+            not config.no_inline_sort
+            or (config.force_single_line and module not in config.single_line_exclusions)
+        ) and not config.only_sections:
+            from_imports = sorting.sort(
+                config,
+                from_imports,
+                key=lambda key: sorting.module_key(
+                    key,
+                    config,
+                    True,
+                    config.force_alphabetical_sort_within_sections,
+                    section_name=section,
+                ),
+                reverse=config.reverse_sort,
+            )
+        if remove_imports:
+            from_imports = [
+                line for line in from_imports if f"{module}.{line}" not in remove_imports
+            ]
+
+        sub_modules = [f"{module}.{from_import}" for from_import in from_imports]
+        as_imports = {
+            from_import: [
+                f"{from_import} as {as_module}" for as_module in parsed.as_map["from"][sub_module]
+            ]
+            for from_import, sub_module in zip(from_imports, sub_modules)
+            if sub_module in parsed.as_map["from"]
+        }
+        if config.combine_as_imports and not ("*" in from_imports and config.combine_star):
+            if not config.no_inline_sort:
+                for as_import in as_imports:
+                    if not config.only_sections:
+                        as_imports[as_import] = sorting.sort(config, as_imports[as_import])
+            for from_import in copy.copy(from_imports):
+                if from_import in as_imports:
+                    idx = from_imports.index(from_import)
+                    if parsed.imports[section]["from"][module][from_import]:
+                        from_imports[(idx + 1) : (idx + 1)] = as_imports.pop(from_import)
+                    else:
+                        from_imports[idx : (idx + 1)] = as_imports.pop(from_import)
+
+        only_show_as_imports = False
+        comments = parsed.categorized_comments["from"].pop(module, ())
+        above_comments = parsed.categorized_comments["above"]["from"].pop(module, None)
+        while from_imports:
+            if above_comments:
+                output.extend(above_comments)
+                above_comments = None
+
+            if "*" in from_imports and config.combine_star:
+                import_statement = wrap.line(
+                    with_comments(
+                        _with_star_comments(parsed, module, list(comments or ())),
+                        f"{import_start}*",
+                        removed=config.ignore_comments,
+                        comment_prefix=config.comment_prefix,
+                    ),
+                    parsed.line_separator,
+                    config,
+                )
+                from_imports = [
+                    from_import for from_import in from_imports if from_import in as_imports
+                ]
+                only_show_as_imports = True
+            elif config.force_single_line and module not in config.single_line_exclusions:
+                import_statement = ""
+                while from_imports:
+                    from_import = from_imports.pop(0)
+                    single_import_line = with_comments(
+                        comments,
+                        import_start + from_import,
+                        removed=config.ignore_comments,
+                        comment_prefix=config.comment_prefix,
+                    )
+                    comment = (
+                        parsed.categorized_comments["nested"].get(module, {}).pop(from_import, None)
+                    )
+                    if comment:
+                        single_import_line += (
+                            f"{comments and ';' or config.comment_prefix} " f"{comment}"
+                        )
+                    if from_import in as_imports:
+                        if (
+                            parsed.imports[section]["from"][module][from_import]
+                            and not only_show_as_imports
+                        ):
+                            output.append(
+                                wrap.line(single_import_line, parsed.line_separator, config)
+                            )
+                        from_comments = parsed.categorized_comments["straight"].get(
+                            f"{module}.{from_import}"
+                        )
+
+                        if not config.only_sections:
+                            output.extend(
+                                with_comments(
+                                    from_comments,
+                                    wrap.line(
+                                        import_start + as_import, parsed.line_separator, config
+                                    ),
+                                    removed=config.ignore_comments,
+                                    comment_prefix=config.comment_prefix,
+                                )
+                                for as_import in sorting.sort(config, as_imports[from_import])
+                            )
+
+                        else:
+                            output.extend(
+                                with_comments(
+                                    from_comments,
+                                    wrap.line(
+                                        import_start + as_import, parsed.line_separator, config
+                                    ),
+                                    removed=config.ignore_comments,
+                                    comment_prefix=config.comment_prefix,
+                                )
+                                for as_import in as_imports[from_import]
+                            )
+                    else:
+                        output.append(wrap.line(single_import_line, parsed.line_separator, config))
+                    comments = None
+            else:
+                while from_imports and from_imports[0] in as_imports:
+                    from_import = from_imports.pop(0)
+
+                    if not config.only_sections:
+                        as_imports[from_import] = sorting.sort(config, as_imports[from_import])
+                    from_comments = (
+                        parsed.categorized_comments["straight"].get(f"{module}.{from_import}") or []
+                    )
+                    if (
+                        parsed.imports[section]["from"][module][from_import]
+                        and not only_show_as_imports
+                    ):
+                        specific_comment = (
+                            parsed.categorized_comments["nested"]
+                            .get(module, {})
+                            .pop(from_import, None)
+                        )
+                        if specific_comment:
+                            from_comments.append(specific_comment)
+                        output.append(
+                            wrap.line(
+                                with_comments(
+                                    from_comments,
+                                    import_start + from_import,
+                                    removed=config.ignore_comments,
+                                    comment_prefix=config.comment_prefix,
+                                ),
+                                parsed.line_separator,
+                                config,
+                            )
+                        )
+                        from_comments = []
+
+                    for as_import in as_imports[from_import]:
+                        specific_comment = (
+                            parsed.categorized_comments["nested"]
+                            .get(module, {})
+                            .pop(as_import, None)
+                        )
+                        if specific_comment:
+                            from_comments.append(specific_comment)
+
+                        output.append(
+                            wrap.line(
+                                with_comments(
+                                    from_comments,
+                                    import_start + as_import,
+                                    removed=config.ignore_comments,
+                                    comment_prefix=config.comment_prefix,
+                                ),
+                                parsed.line_separator,
+                                config,
+                            )
+                        )
+
+                        from_comments = []
+
+                if "*" in from_imports:
+                    output.append(
+                        with_comments(
+                            _with_star_comments(parsed, module, []),
+                            f"{import_start}*",
+                            removed=config.ignore_comments,
+                            comment_prefix=config.comment_prefix,
+                        )
+                    )
+                    from_imports.remove("*")
+
+                for from_import in copy.copy(from_imports):
+                    comment = (
+                        parsed.categorized_comments["nested"].get(module, {}).pop(from_import, None)
+                    )
+                    if comment:
+                        from_imports.remove(from_import)
+                        if from_imports:
+                            use_comments = []
+                        else:
+                            use_comments = comments
+                            comments = None
+                        single_import_line = with_comments(
+                            use_comments,
+                            import_start + from_import,
+                            removed=config.ignore_comments,
+                            comment_prefix=config.comment_prefix,
+                        )
+                        single_import_line += (
+                            f"{use_comments and ';' or config.comment_prefix} " f"{comment}"
+                        )
+                        output.append(wrap.line(single_import_line, parsed.line_separator, config))
+
+                from_import_section = []
+                while from_imports and (
+                    from_imports[0] not in as_imports
+                    or (
+                        config.combine_as_imports
+                        and parsed.imports[section]["from"][module][from_import]
+                    )
+                ):
+                    from_import_section.append(from_imports.pop(0))
+                if config.combine_as_imports:
+                    comments = (comments or []) + list(
+                        parsed.categorized_comments["from"].pop(f"{module}.__combined_as__", ())
+                    )
+                import_statement = with_comments(
+                    comments,
+                    import_start + (", ").join(from_import_section),
+                    removed=config.ignore_comments,
+                    comment_prefix=config.comment_prefix,
+                )
+                if not from_import_section:
+                    import_statement = ""
+
+                do_multiline_reformat = False
+
+                force_grid_wrap = config.force_grid_wrap
+                if force_grid_wrap and len(from_import_section) >= force_grid_wrap:
+                    do_multiline_reformat = True
+
+                if len(import_statement) > config.line_length and len(from_import_section) > 1:
+                    do_multiline_reformat = True
+
+                # If line too long AND have imports AND we are
+                # NOT using GRID or VERTICAL wrap modes
+                if (
+                    len(import_statement) > config.line_length
+                    and len(from_import_section) > 0
+                    and config.multi_line_output
+                    not in (wrap.Modes.GRID, wrap.Modes.VERTICAL)  # type: ignore
+                ):
+                    do_multiline_reformat = True
+
+                if do_multiline_reformat:
+                    import_statement = wrap.import_statement(
+                        import_start=import_start,
+                        from_imports=from_import_section,
+                        comments=comments,
+                        line_separator=parsed.line_separator,
+                        config=config,
+                    )
+                    if config.multi_line_output == wrap.Modes.GRID:  # type: ignore
+                        other_import_statement = wrap.import_statement(
+                            import_start=import_start,
+                            from_imports=from_import_section,
+                            comments=comments,
+                            line_separator=parsed.line_separator,
+                            config=config,
+                            multi_line_output=wrap.Modes.VERTICAL_GRID,  # type: ignore
+                        )
+                        if (
+                            max(
+                                len(import_line)
+                                for import_line in import_statement.split(parsed.line_separator)
+                            )
+                            > config.line_length
+                        ):
+                            import_statement = other_import_statement
+                if not do_multiline_reformat and len(import_statement) > config.line_length:
+                    import_statement = wrap.line(import_statement, parsed.line_separator, config)
+
+            if import_statement:
+                output.append(import_statement)
+    return output
+
+
+def _with_straight_imports(
+    parsed: parse.ParsedContent,
+    config: Config,
+    straight_modules: Iterable[str],
+    section: str,
+    remove_imports: List[str],
+    import_type: str,
+) -> List[str]:
+    output: List[str] = []
+
+    as_imports = any((module in parsed.as_map["straight"] for module in straight_modules))
+
+    # combine_straight_imports only works for bare imports, 'as' imports not included
+    if config.combine_straight_imports and not as_imports:
+        if not straight_modules:
+            return []
+
+        above_comments: List[str] = []
+        inline_comments: List[str] = []
+
+        for module in straight_modules:
+            if module in parsed.categorized_comments["above"]["straight"]:
+                above_comments.extend(parsed.categorized_comments["above"]["straight"].pop(module))
+            if module in parsed.categorized_comments["straight"]:
+                inline_comments.extend(parsed.categorized_comments["straight"][module])
+
+        combined_straight_imports = ", ".join(straight_modules)
+        if inline_comments:
+            combined_inline_comments = " ".join(inline_comments)
+        else:
+            combined_inline_comments = ""
+
+        output.extend(above_comments)
+
+        if combined_inline_comments:
+            output.append(
+                f"{import_type} {combined_straight_imports}  # {combined_inline_comments}"
+            )
+        else:
+            output.append(f"{import_type} {combined_straight_imports}")
+
+        return output
+
+    for module in straight_modules:
+        if module in remove_imports:
+            continue
+
+        import_definition = []
+        if module in parsed.as_map["straight"]:
+            if parsed.imports[section]["straight"][module]:
+                import_definition.append((f"{import_type} {module}", module))
+            import_definition.extend(
+                (f"{import_type} {module} as {as_import}", f"{module} as {as_import}")
+                for as_import in parsed.as_map["straight"][module]
+            )
+        else:
+            import_definition.append((f"{import_type} {module}", module))
+
+        comments_above = parsed.categorized_comments["above"]["straight"].pop(module, None)
+        if comments_above:
+            output.extend(comments_above)
+        output.extend(
+            with_comments(
+                parsed.categorized_comments["straight"].get(imodule),
+                idef,
+                removed=config.ignore_comments,
+                comment_prefix=config.comment_prefix,
+            )
+            for idef, imodule in import_definition
+        )
+
+    return output
+
+
+def _output_as_string(lines: List[str], line_separator: str) -> str:
+    return line_separator.join(_normalize_empty_lines(lines))
+
+
+def _normalize_empty_lines(lines: List[str]) -> List[str]:
+    while lines and lines[-1].strip() == "":
+        lines.pop(-1)
+
+    lines.append("")
+    return lines
+
+
+class _LineWithComments(str):
+    comments: List[str]
+
+    def __new__(
+        cls: Type["_LineWithComments"], value: Any, comments: List[str]
+    ) -> "_LineWithComments":
+        instance = super().__new__(cls, value)
+        instance.comments = comments
+        return instance
+
+
+def _ensure_newline_before_comment(output: List[str]) -> List[str]:
+    new_output: List[str] = []
+
+    def is_comment(line: Optional[str]) -> bool:
+        return line.startswith("#") if line else False
+
+    for line, prev_line in zip(output, [None] + output):  # type: ignore
+        if is_comment(line) and prev_line != "" and not is_comment(prev_line):
+            new_output.append("")
+        new_output.append(line)
+    return new_output
+
+
+def _with_star_comments(parsed: parse.ParsedContent, module: str, comments: List[str]) -> List[str]:
+    star_comment = parsed.categorized_comments["nested"].get(module, {}).pop("*", None)
+    if star_comment:
+        return comments + [star_comment]
+    return comments
diff --git a/myenv/lib/python3.9/site-packages/isort/parse.py b/myenv/lib/python3.9/site-packages/isort/parse.py
new file mode 100644
index 0000000..7fc6c8e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/parse.py
@@ -0,0 +1,590 @@
+"""Defines parsing functions used by isort for parsing import definitions"""
+from collections import OrderedDict, defaultdict
+from functools import partial
+from itertools import chain
+from typing import TYPE_CHECKING, Any, Dict, List, NamedTuple, Optional, Tuple
+from warnings import warn
+
+from . import place
+from .comments import parse as parse_comments
+from .exceptions import MissingSection
+from .settings import DEFAULT_CONFIG, Config
+
+if TYPE_CHECKING:
+    from mypy_extensions import TypedDict
+
+    CommentsAboveDict = TypedDict(
+        "CommentsAboveDict", {"straight": Dict[str, Any], "from": Dict[str, Any]}
+    )
+
+    CommentsDict = TypedDict(
+        "CommentsDict",
+        {
+            "from": Dict[str, Any],
+            "straight": Dict[str, Any],
+            "nested": Dict[str, Any],
+            "above": CommentsAboveDict,
+        },
+    )
+
+
+def _infer_line_separator(contents: str) -> str:
+    if "\r\n" in contents:
+        return "\r\n"
+    if "\r" in contents:
+        return "\r"
+    return "\n"
+
+
+def _normalize_line(raw_line: str) -> Tuple[str, str]:
+    """Normalizes import related statements in the provided line.
+
+    Returns (normalized_line: str, raw_line: str)
+    """
+    line = raw_line.replace("from.import ", "from . import ")
+    line = line.replace("from.cimport ", "from . cimport ")
+    line = line.replace("import*", "import *")
+    line = line.replace(" .import ", " . import ")
+    line = line.replace(" .cimport ", " . cimport ")
+    line = line.replace("\t", " ")
+    return (line, raw_line)
+
+
+def import_type(line: str, config: Config = DEFAULT_CONFIG) -> Optional[str]:
+    """If the current line is an import line it will return its type (from or straight)"""
+    if config.honor_noqa and line.lower().rstrip().endswith("noqa"):
+        return None
+    if "isort:skip" in line or "isort: skip" in line or "isort: split" in line:
+        return None
+    if line.startswith(("import ", "cimport ")):
+        return "straight"
+    if line.startswith("from "):
+        return "from"
+    return None
+
+
+def _strip_syntax(import_string: str) -> str:
+    import_string = import_string.replace("_import", "[[i]]")
+    import_string = import_string.replace("_cimport", "[[ci]]")
+    for remove_syntax in ["\\", "(", ")", ","]:
+        import_string = import_string.replace(remove_syntax, " ")
+    import_list = import_string.split()
+    for key in ("from", "import", "cimport"):
+        if key in import_list:
+            import_list.remove(key)
+    import_string = " ".join(import_list)
+    import_string = import_string.replace("[[i]]", "_import")
+    import_string = import_string.replace("[[ci]]", "_cimport")
+    return import_string.replace("{ ", "{|").replace(" }", "|}")
+
+
+def skip_line(
+    line: str,
+    in_quote: str,
+    index: int,
+    section_comments: Tuple[str, ...],
+    needs_import: bool = True,
+) -> Tuple[bool, str]:
+    """Determine if a given line should be skipped.
+
+    Returns back a tuple containing:
+
+    (skip_line: bool,
+     in_quote: str,)
+    """
+    should_skip = bool(in_quote)
+    if '"' in line or "'" in line:
+        char_index = 0
+        while char_index < len(line):
+            if line[char_index] == "\\":
+                char_index += 1
+            elif in_quote:
+                if line[char_index : char_index + len(in_quote)] == in_quote:
+                    in_quote = ""
+            elif line[char_index] in ("'", '"'):
+                long_quote = line[char_index : char_index + 3]
+                if long_quote in ('"""', "'''"):
+                    in_quote = long_quote
+                    char_index += 2
+                else:
+                    in_quote = line[char_index]
+            elif line[char_index] == "#":
+                break
+            char_index += 1
+
+    if ";" in line.split("#")[0] and needs_import:
+        for part in (part.strip() for part in line.split(";")):
+            if (
+                part
+                and not part.startswith("from ")
+                and not part.startswith(("import ", "cimport "))
+            ):
+                should_skip = True
+
+    return (bool(should_skip or in_quote), in_quote)
+
+
+class ParsedContent(NamedTuple):
+    in_lines: List[str]
+    lines_without_imports: List[str]
+    import_index: int
+    place_imports: Dict[str, List[str]]
+    import_placements: Dict[str, str]
+    as_map: Dict[str, Dict[str, List[str]]]
+    imports: Dict[str, Dict[str, Any]]
+    categorized_comments: "CommentsDict"
+    change_count: int
+    original_line_count: int
+    line_separator: str
+    sections: Any
+    verbose_output: List[str]
+
+
+def file_contents(contents: str, config: Config = DEFAULT_CONFIG) -> ParsedContent:
+    """Parses a python file taking out and categorizing imports."""
+    line_separator: str = config.line_ending or _infer_line_separator(contents)
+    in_lines = contents.splitlines()
+    if contents and contents[-1] in ("\n", "\r"):
+        in_lines.append("")
+
+    out_lines = []
+    original_line_count = len(in_lines)
+    if config.old_finders:
+        from .deprecated.finders import FindersManager
+
+        finder = FindersManager(config=config).find
+    else:
+        finder = partial(place.module, config=config)
+
+    line_count = len(in_lines)
+
+    place_imports: Dict[str, List[str]] = {}
+    import_placements: Dict[str, str] = {}
+    as_map: Dict[str, Dict[str, List[str]]] = {
+        "straight": defaultdict(list),
+        "from": defaultdict(list),
+    }
+    imports: OrderedDict[str, Dict[str, Any]] = OrderedDict()
+    verbose_output: List[str] = []
+
+    for section in chain(config.sections, config.forced_separate):
+        imports[section] = {"straight": OrderedDict(), "from": OrderedDict()}
+    categorized_comments: CommentsDict = {
+        "from": {},
+        "straight": {},
+        "nested": {},
+        "above": {"straight": {}, "from": {}},
+    }
+
+    index = 0
+    import_index = -1
+    in_quote = ""
+    while index < line_count:
+        line = in_lines[index]
+        index += 1
+        statement_index = index
+        (skipping_line, in_quote) = skip_line(
+            line, in_quote=in_quote, index=index, section_comments=config.section_comments
+        )
+
+        if (
+            line in config.section_comments or line in config.section_comments_end
+        ) and not skipping_line:
+            if import_index == -1:  # pragma: no branch
+                import_index = index - 1
+            continue
+
+        if "isort:imports-" in line and line.startswith("#"):
+            section = line.split("isort:imports-")[-1].split()[0].upper()
+            place_imports[section] = []
+            import_placements[line] = section
+        elif "isort: imports-" in line and line.startswith("#"):
+            section = line.split("isort: imports-")[-1].split()[0].upper()
+            place_imports[section] = []
+            import_placements[line] = section
+
+        if skipping_line:
+            out_lines.append(line)
+            continue
+
+        lstripped_line = line.lstrip()
+        if (
+            config.float_to_top
+            and import_index == -1
+            and line
+            and not in_quote
+            and not lstripped_line.startswith("#")
+            and not lstripped_line.startswith("'''")
+            and not lstripped_line.startswith('"""')
+        ):
+            if not lstripped_line.startswith("import") and not lstripped_line.startswith("from"):
+                import_index = index - 1
+                while import_index and not in_lines[import_index - 1]:
+                    import_index -= 1
+            else:
+                commentless = line.split("#", 1)[0].strip()
+                if (
+                    ("isort:skip" in line or "isort: skip" in line)
+                    and "(" in commentless
+                    and ")" not in commentless
+                ):
+                    import_index = index
+
+                    starting_line = line
+                    while "isort:skip" in starting_line or "isort: skip" in starting_line:
+                        commentless = starting_line.split("#", 1)[0]
+                        if (
+                            "(" in commentless
+                            and not commentless.rstrip().endswith(")")
+                            and import_index < line_count
+                        ):
+
+                            while import_index < line_count and not commentless.rstrip().endswith(
+                                ")"
+                            ):
+                                commentless = in_lines[import_index].split("#", 1)[0]
+                                import_index += 1
+                        else:
+                            import_index += 1
+
+                        if import_index >= line_count:
+                            break
+
+                        starting_line = in_lines[import_index]
+
+        line, *end_of_line_comment = line.split("#", 1)
+        if ";" in line:
+            statements = [line.strip() for line in line.split(";")]
+        else:
+            statements = [line]
+        if end_of_line_comment:
+            statements[-1] = f"{statements[-1]}#{end_of_line_comment[0]}"
+
+        for statement in statements:
+            line, raw_line = _normalize_line(statement)
+            type_of_import = import_type(line, config) or ""
+            raw_lines = [raw_line]
+            if not type_of_import:
+                out_lines.append(raw_line)
+                continue
+
+            if import_index == -1:
+                import_index = index - 1
+            nested_comments = {}
+            import_string, comment = parse_comments(line)
+            comments = [comment] if comment else []
+            line_parts = [part for part in _strip_syntax(import_string).strip().split(" ") if part]
+            if type_of_import == "from" and len(line_parts) == 2 and comments:
+                nested_comments[line_parts[-1]] = comments[0]
+
+            if "(" in line.split("#", 1)[0] and index < line_count:
+                while not line.split("#")[0].strip().endswith(")") and index < line_count:
+                    line, new_comment = parse_comments(in_lines[index])
+                    index += 1
+                    if new_comment:
+                        comments.append(new_comment)
+                    stripped_line = _strip_syntax(line).strip()
+                    if (
+                        type_of_import == "from"
+                        and stripped_line
+                        and " " not in stripped_line.replace(" as ", "")
+                        and new_comment
+                    ):
+                        nested_comments[stripped_line] = comments[-1]
+                    import_string += line_separator + line
+                    raw_lines.append(line)
+            else:
+                while line.strip().endswith("\\"):
+                    line, new_comment = parse_comments(in_lines[index])
+                    line = line.lstrip()
+                    index += 1
+                    if new_comment:
+                        comments.append(new_comment)
+
+                    # Still need to check for parentheses after an escaped line
+                    if (
+                        "(" in line.split("#")[0]
+                        and ")" not in line.split("#")[0]
+                        and index < line_count
+                    ):
+                        stripped_line = _strip_syntax(line).strip()
+                        if (
+                            type_of_import == "from"
+                            and stripped_line
+                            and " " not in stripped_line.replace(" as ", "")
+                            and new_comment
+                        ):
+                            nested_comments[stripped_line] = comments[-1]
+                        import_string += line_separator + line
+                        raw_lines.append(line)
+
+                        while not line.split("#")[0].strip().endswith(")") and index < line_count:
+                            line, new_comment = parse_comments(in_lines[index])
+                            index += 1
+                            if new_comment:
+                                comments.append(new_comment)
+                            stripped_line = _strip_syntax(line).strip()
+                            if (
+                                type_of_import == "from"
+                                and stripped_line
+                                and " " not in stripped_line.replace(" as ", "")
+                                and new_comment
+                            ):
+                                nested_comments[stripped_line] = comments[-1]
+                            import_string += line_separator + line
+                            raw_lines.append(line)
+
+                    stripped_line = _strip_syntax(line).strip()
+                    if (
+                        type_of_import == "from"
+                        and stripped_line
+                        and " " not in stripped_line.replace(" as ", "")
+                        and new_comment
+                    ):
+                        nested_comments[stripped_line] = comments[-1]
+                    if import_string.strip().endswith(
+                        (" import", " cimport")
+                    ) or line.strip().startswith(("import ", "cimport ")):
+                        import_string += line_separator + line
+                    else:
+                        import_string = import_string.rstrip().rstrip("\\") + " " + line.lstrip()
+
+            if type_of_import == "from":
+                cimports: bool
+                import_string = (
+                    import_string.replace("import(", "import (")
+                    .replace("\\", " ")
+                    .replace("\n", " ")
+                )
+                if "import " not in import_string:
+                    out_lines.extend(raw_lines)
+                    continue
+
+                if " cimport " in import_string:
+                    parts = import_string.split(" cimport ")
+                    cimports = True
+
+                else:
+                    parts = import_string.split(" import ")
+                    cimports = False
+
+                from_import = parts[0].split(" ")
+                import_string = (" cimport " if cimports else " import ").join(
+                    [from_import[0] + " " + "".join(from_import[1:])] + parts[1:]
+                )
+
+            just_imports = [
+                item.replace("{|", "{ ").replace("|}", " }")
+                for item in _strip_syntax(import_string).split()
+            ]
+
+            attach_comments_to: Optional[List[Any]] = None
+            direct_imports = just_imports[1:]
+            straight_import = True
+            top_level_module = ""
+            if "as" in just_imports and (just_imports.index("as") + 1) < len(just_imports):
+                straight_import = False
+                while "as" in just_imports:
+                    nested_module = None
+                    as_index = just_imports.index("as")
+                    if type_of_import == "from":
+                        nested_module = just_imports[as_index - 1]
+                        top_level_module = just_imports[0]
+                        module = top_level_module + "." + nested_module
+                        as_name = just_imports[as_index + 1]
+                        direct_imports.remove(nested_module)
+                        direct_imports.remove(as_name)
+                        direct_imports.remove("as")
+                        if nested_module == as_name and config.remove_redundant_aliases:
+                            pass
+                        elif as_name not in as_map["from"][module]:  # pragma: no branch
+                            as_map["from"][module].append(as_name)
+
+                        full_name = f"{nested_module} as {as_name}"
+                        associated_comment = nested_comments.get(full_name)
+                        if associated_comment:
+                            categorized_comments["nested"].setdefault(top_level_module, {})[
+                                full_name
+                            ] = associated_comment
+                            if associated_comment in comments:  # pragma: no branch
+                                comments.pop(comments.index(associated_comment))
+                    else:
+                        module = just_imports[as_index - 1]
+                        as_name = just_imports[as_index + 1]
+                        if module == as_name and config.remove_redundant_aliases:
+                            pass
+                        elif as_name not in as_map["straight"][module]:
+                            as_map["straight"][module].append(as_name)
+
+                    if comments and attach_comments_to is None:
+                        if nested_module and config.combine_as_imports:
+                            attach_comments_to = categorized_comments["from"].setdefault(
+                                f"{top_level_module}.__combined_as__", []
+                            )
+                        else:
+                            if type_of_import == "from" or (
+                                config.remove_redundant_aliases and as_name == module.split(".")[-1]
+                            ):
+                                attach_comments_to = categorized_comments["straight"].setdefault(
+                                    module, []
+                                )
+                            else:
+                                attach_comments_to = categorized_comments["straight"].setdefault(
+                                    f"{module} as {as_name}", []
+                                )
+                    del just_imports[as_index : as_index + 2]
+
+            if type_of_import == "from":
+                import_from = just_imports.pop(0)
+                placed_module = finder(import_from)
+                if config.verbose and not config.only_modified:
+                    print(f"from-type place_module for {import_from} returned {placed_module}")
+
+                elif config.verbose:
+                    verbose_output.append(
+                        f"from-type place_module for {import_from} returned {placed_module}"
+                    )
+                if placed_module == "":
+                    warn(
+                        f"could not place module {import_from} of line {line} --"
+                        " Do you need to define a default section?"
+                    )
+
+                if placed_module and placed_module not in imports:
+                    raise MissingSection(import_module=import_from, section=placed_module)
+
+                root = imports[placed_module][type_of_import]  # type: ignore
+                for import_name in just_imports:
+                    associated_comment = nested_comments.get(import_name)
+                    if associated_comment:
+                        categorized_comments["nested"].setdefault(import_from, {})[
+                            import_name
+                        ] = associated_comment
+                        if associated_comment in comments:  # pragma: no branch
+                            comments.pop(comments.index(associated_comment))
+                if (
+                    config.force_single_line
+                    and comments
+                    and attach_comments_to is None
+                    and len(just_imports) == 1
+                ):
+                    nested_from_comments = categorized_comments["nested"].setdefault(
+                        import_from, {}
+                    )
+                    existing_comment = nested_from_comments.get(just_imports[0], "")
+                    nested_from_comments[
+                        just_imports[0]
+                    ] = f"{existing_comment}{'; ' if existing_comment else ''}{'; '.join(comments)}"
+                    comments = []
+
+                if comments and attach_comments_to is None:
+                    attach_comments_to = categorized_comments["from"].setdefault(import_from, [])
+
+                if len(out_lines) > max(import_index, 1) - 1:
+                    last = out_lines[-1].rstrip() if out_lines else ""
+                    while (
+                        last.startswith("#")
+                        and not last.endswith('"""')
+                        and not last.endswith("'''")
+                        and "isort:imports-" not in last
+                        and "isort: imports-" not in last
+                        and not config.treat_all_comments_as_code
+                        and not last.strip() in config.treat_comments_as_code
+                    ):
+                        categorized_comments["above"]["from"].setdefault(import_from, []).insert(
+                            0, out_lines.pop(-1)
+                        )
+                        if out_lines:
+                            last = out_lines[-1].rstrip()
+                        else:
+                            last = ""
+                    if statement_index - 1 == import_index:  # pragma: no cover
+                        import_index -= len(
+                            categorized_comments["above"]["from"].get(import_from, [])
+                        )
+
+                if import_from not in root:
+                    root[import_from] = OrderedDict(
+                        (module, module in direct_imports) for module in just_imports
+                    )
+                else:
+                    root[import_from].update(
+                        (module, root[import_from].get(module, False) or module in direct_imports)
+                        for module in just_imports
+                    )
+
+                if comments and attach_comments_to is not None:
+                    attach_comments_to.extend(comments)
+            else:
+                if comments and attach_comments_to is not None:
+                    attach_comments_to.extend(comments)
+                    comments = []
+
+                for module in just_imports:
+                    if comments:
+                        categorized_comments["straight"][module] = comments
+                        comments = []
+
+                    if len(out_lines) > max(import_index, +1, 1) - 1:
+
+                        last = out_lines[-1].rstrip() if out_lines else ""
+                        while (
+                            last.startswith("#")
+                            and not last.endswith('"""')
+                            and not last.endswith("'''")
+                            and "isort:imports-" not in last
+                            and "isort: imports-" not in last
+                            and not config.treat_all_comments_as_code
+                            and not last.strip() in config.treat_comments_as_code
+                        ):
+                            categorized_comments["above"]["straight"].setdefault(module, []).insert(
+                                0, out_lines.pop(-1)
+                            )
+                            if out_lines:
+                                last = out_lines[-1].rstrip()
+                            else:
+                                last = ""
+                        if index - 1 == import_index:
+                            import_index -= len(
+                                categorized_comments["above"]["straight"].get(module, [])
+                            )
+                    placed_module = finder(module)
+                    if config.verbose and not config.only_modified:
+                        print(f"else-type place_module for {module} returned {placed_module}")
+
+                    elif config.verbose:
+                        verbose_output.append(
+                            f"else-type place_module for {module} returned {placed_module}"
+                        )
+                    if placed_module == "":
+                        warn(
+                            f"could not place module {module} of line {line} --"
+                            " Do you need to define a default section?"
+                        )
+                        imports.setdefault("", {"straight": OrderedDict(), "from": OrderedDict()})
+
+                    if placed_module and placed_module not in imports:
+                        raise MissingSection(import_module=module, section=placed_module)
+
+                    straight_import |= imports[placed_module][type_of_import].get(  # type: ignore
+                        module, False
+                    )
+                    imports[placed_module][type_of_import][module] = straight_import  # type: ignore
+
+    change_count = len(out_lines) - original_line_count
+
+    return ParsedContent(
+        in_lines=in_lines,
+        lines_without_imports=out_lines,
+        import_index=import_index,
+        place_imports=place_imports,
+        import_placements=import_placements,
+        as_map=as_map,
+        imports=imports,
+        categorized_comments=categorized_comments,
+        change_count=change_count,
+        original_line_count=original_line_count,
+        line_separator=line_separator,
+        sections=config.sections,
+        verbose_output=verbose_output,
+    )
diff --git a/myenv/lib/python3.9/site-packages/isort/place.py b/myenv/lib/python3.9/site-packages/isort/place.py
new file mode 100644
index 0000000..47a68c7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/place.py
@@ -0,0 +1,145 @@
+"""Contains all logic related to placing an import within a certain section."""
+import importlib
+from fnmatch import fnmatch
+from functools import lru_cache
+from pathlib import Path
+from typing import FrozenSet, Iterable, Optional, Tuple
+
+from isort import sections
+from isort.settings import DEFAULT_CONFIG, Config
+from isort.utils import exists_case_sensitive
+
+LOCAL = "LOCALFOLDER"
+
+
+def module(name: str, config: Config = DEFAULT_CONFIG) -> str:
+    """Returns the section placement for the given module name."""
+    return module_with_reason(name, config)[0]
+
+
+@lru_cache(maxsize=1000)
+def module_with_reason(name: str, config: Config = DEFAULT_CONFIG) -> Tuple[str, str]:
+    """Returns the section placement for the given module name alongside the reasoning."""
+    return (
+        _forced_separate(name, config)
+        or _local(name, config)
+        or _known_pattern(name, config)
+        or _src_path(name, config)
+        or (config.default_section, "Default option in Config or universal default.")
+    )
+
+
+def _forced_separate(name: str, config: Config) -> Optional[Tuple[str, str]]:
+    for forced_separate in config.forced_separate:
+        # Ensure all forced_separate patterns will match to end of string
+        path_glob = forced_separate
+        if not forced_separate.endswith("*"):
+            path_glob = "%s*" % forced_separate
+
+        if fnmatch(name, path_glob) or fnmatch(name, "." + path_glob):
+            return (forced_separate, f"Matched forced_separate ({forced_separate}) config value.")
+
+    return None
+
+
+def _local(name: str, config: Config) -> Optional[Tuple[str, str]]:
+    if name.startswith("."):
+        return (LOCAL, "Module name started with a dot.")
+
+    return None
+
+
+def _known_pattern(name: str, config: Config) -> Optional[Tuple[str, str]]:
+    parts = name.split(".")
+    module_names_to_check = (".".join(parts[:first_k]) for first_k in range(len(parts), 0, -1))
+    for module_name_to_check in module_names_to_check:
+        for pattern, placement in config.known_patterns:
+            if placement in config.sections and pattern.match(module_name_to_check):
+                return (placement, f"Matched configured known pattern {pattern}")
+
+    return None
+
+
+def _src_path(
+    name: str,
+    config: Config,
+    src_paths: Optional[Iterable[Path]] = None,
+    prefix: Tuple[str, ...] = (),
+) -> Optional[Tuple[str, str]]:
+    if src_paths is None:
+        src_paths = config.src_paths
+
+    root_module_name, *nested_module = name.split(".", 1)
+    new_prefix = prefix + (root_module_name,)
+    namespace = ".".join(new_prefix)
+
+    for src_path in src_paths:
+        module_path = (src_path / root_module_name).resolve()
+        if not prefix and not module_path.is_dir() and src_path.name == root_module_name:
+            module_path = src_path.resolve()
+        if nested_module and (
+            namespace in config.namespace_packages
+            or (
+                config.auto_identify_namespace_packages
+                and _is_namespace_package(module_path, config.supported_extensions)
+            )
+        ):
+            return _src_path(nested_module[0], config, (module_path,), new_prefix)
+        if (
+            _is_module(module_path)
+            or _is_package(module_path)
+            or _src_path_is_module(src_path, root_module_name)
+        ):
+            return (sections.FIRSTPARTY, f"Found in one of the configured src_paths: {src_path}.")
+
+    return None
+
+
+def _is_module(path: Path) -> bool:
+    return (
+        exists_case_sensitive(str(path.with_suffix(".py")))
+        or any(
+            exists_case_sensitive(str(path.with_suffix(ext_suffix)))
+            for ext_suffix in importlib.machinery.EXTENSION_SUFFIXES
+        )
+        or exists_case_sensitive(str(path / "__init__.py"))
+    )
+
+
+def _is_package(path: Path) -> bool:
+    return exists_case_sensitive(str(path)) and path.is_dir()
+
+
+def _is_namespace_package(path: Path, src_extensions: FrozenSet[str]) -> bool:
+    if not _is_package(path):
+        return False
+
+    init_file = path / "__init__.py"
+    if not init_file.exists():
+        filenames = [
+            filepath
+            for filepath in path.iterdir()
+            if filepath.suffix.lstrip(".") in src_extensions
+            or filepath.name.lower() in ("setup.cfg", "pyproject.toml")
+        ]
+        if filenames:
+            return False
+    else:
+        with init_file.open("rb") as open_init_file:
+            file_start = open_init_file.read(4096)
+            if (
+                b"__import__('pkg_resources').declare_namespace(__name__)" not in file_start
+                and b'__import__("pkg_resources").declare_namespace(__name__)' not in file_start
+                and b"__path__ = __import__('pkgutil').extend_path(__path__, __name__)"
+                not in file_start
+                and b'__path__ = __import__("pkgutil").extend_path(__path__, __name__)'
+                not in file_start
+            ):
+                return False
+    return True
+
+
+def _src_path_is_module(src_path: Path, module_name: str) -> bool:
+    return (
+        module_name == src_path.name and src_path.is_dir() and exists_case_sensitive(str(src_path))
+    )
diff --git a/myenv/lib/python3.9/site-packages/isort/profiles.py b/myenv/lib/python3.9/site-packages/isort/profiles.py
new file mode 100644
index 0000000..21d0646
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/profiles.py
@@ -0,0 +1,86 @@
+"""Common profiles are defined here to be easily used within a project using --profile {name}"""
+from typing import Any, Dict
+
+black = {
+    "multi_line_output": 3,
+    "include_trailing_comma": True,
+    "force_grid_wrap": 0,
+    "use_parentheses": True,
+    "ensure_newline_before_comments": True,
+    "line_length": 88,
+}
+django = {
+    "combine_as_imports": True,
+    "include_trailing_comma": True,
+    "multi_line_output": 5,
+    "line_length": 79,
+}
+pycharm = {
+    "multi_line_output": 3,
+    "force_grid_wrap": 2,
+    "lines_after_imports": 2,
+}
+google = {
+    "force_single_line": True,
+    "force_sort_within_sections": True,
+    "lexicographical": True,
+    "single_line_exclusions": ("typing",),
+    "order_by_type": False,
+    "group_by_package": True,
+}
+open_stack = {
+    "force_single_line": True,
+    "force_sort_within_sections": True,
+    "lexicographical": True,
+}
+plone = {
+    "force_alphabetical_sort": True,
+    "force_single_line": True,
+    "lines_after_imports": 2,
+    "line_length": 200,
+}
+attrs = {
+    "atomic": True,
+    "force_grid_wrap": 0,
+    "include_trailing_comma": True,
+    "lines_after_imports": 2,
+    "lines_between_types": 1,
+    "multi_line_output": 3,
+    "use_parentheses": True,
+}
+hug = {
+    "multi_line_output": 3,
+    "include_trailing_comma": True,
+    "force_grid_wrap": 0,
+    "use_parentheses": True,
+    "line_length": 100,
+}
+wemake = {
+    "multi_line_output": 3,
+    "include_trailing_comma": True,
+    "use_parentheses": True,
+    "line_length": 80,
+}
+appnexus = {
+    **black,
+    "force_sort_within_sections": True,
+    "order_by_type": False,
+    "case_sensitive": False,
+    "reverse_relative": True,
+    "sort_relative_in_force_sorted_sections": True,
+    "sections": ["FUTURE", "STDLIB", "THIRDPARTY", "FIRSTPARTY", "APPLICATION", "LOCALFOLDER"],
+    "no_lines_before": "LOCALFOLDER",
+}
+
+profiles: Dict[str, Dict[str, Any]] = {
+    "black": black,
+    "django": django,
+    "pycharm": pycharm,
+    "google": google,
+    "open_stack": open_stack,
+    "plone": plone,
+    "attrs": attrs,
+    "hug": hug,
+    "wemake": wemake,
+    "appnexus": appnexus,
+}
diff --git a/myenv/lib/python3.9/site-packages/isort/py.typed b/myenv/lib/python3.9/site-packages/isort/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/isort/pylama_isort.py b/myenv/lib/python3.9/site-packages/isort/pylama_isort.py
new file mode 100644
index 0000000..52da535
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/pylama_isort.py
@@ -0,0 +1,45 @@
+import os
+import sys
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator, List, Optional
+
+from pylama.lint import Linter as BaseLinter  # type: ignore
+
+from isort.exceptions import FileSkipped
+
+from . import api
+
+
+@contextmanager
+def suppress_stdout() -> Iterator[None]:
+    stdout = sys.stdout
+    with open(os.devnull, "w") as devnull:
+        sys.stdout = devnull
+        yield
+        sys.stdout = stdout
+
+
+class Linter(BaseLinter):  # type: ignore
+    def allow(self, path: str) -> bool:
+        """Determine if this path should be linted."""
+        return path.endswith(".py")
+
+    def run(
+        self, path: str, params: Optional[Dict[str, Any]] = None, **meta: Any
+    ) -> List[Dict[str, Any]]:
+        """Lint the file. Return an array of error dicts if appropriate."""
+        with suppress_stdout():
+            try:
+                if not api.check_file(path, disregard_skip=False, **params or {}):
+                    return [
+                        {
+                            "lnum": 0,
+                            "col": 0,
+                            "text": "Incorrectly sorted imports.",
+                            "type": "ISORT",
+                        }
+                    ]
+            except FileSkipped:
+                pass
+
+            return []
diff --git a/myenv/lib/python3.9/site-packages/isort/sections.py b/myenv/lib/python3.9/site-packages/isort/sections.py
new file mode 100644
index 0000000..f59db69
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/sections.py
@@ -0,0 +1,9 @@
+"""Defines all sections isort uses by default"""
+from typing import Tuple
+
+FUTURE: str = "FUTURE"
+STDLIB: str = "STDLIB"
+THIRDPARTY: str = "THIRDPARTY"
+FIRSTPARTY: str = "FIRSTPARTY"
+LOCALFOLDER: str = "LOCALFOLDER"
+DEFAULT: Tuple[str, ...] = (FUTURE, STDLIB, THIRDPARTY, FIRSTPARTY, LOCALFOLDER)
diff --git a/myenv/lib/python3.9/site-packages/isort/settings.py b/myenv/lib/python3.9/site-packages/isort/settings.py
new file mode 100644
index 0000000..681d7b4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/settings.py
@@ -0,0 +1,925 @@
+"""isort/settings.py.
+
+Defines how the default settings for isort should be loaded
+"""
+import configparser
+import fnmatch
+import os
+import posixpath
+import re
+import stat
+import subprocess  # nosec: Needed for gitignore support.
+import sys
+from functools import lru_cache
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    FrozenSet,
+    Iterable,
+    List,
+    Optional,
+    Pattern,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
+from warnings import warn
+
+from . import sorting, stdlibs
+from ._future import dataclass, field
+from .exceptions import (
+    FormattingPluginDoesNotExist,
+    InvalidSettingsPath,
+    ProfileDoesNotExist,
+    SortingFunctionDoesNotExist,
+    UnsupportedSettings,
+)
+from .profiles import profiles
+from .sections import DEFAULT as SECTION_DEFAULTS
+from .sections import FIRSTPARTY, FUTURE, LOCALFOLDER, STDLIB, THIRDPARTY
+from .utils import Trie
+from .wrap_modes import WrapModes
+from .wrap_modes import from_string as wrap_mode_from_string
+
+if TYPE_CHECKING:
+    tomli: Any
+else:
+    from ._vendored import tomli
+
+_SHEBANG_RE = re.compile(br"^#!.*\bpython[23w]?\b")
+CYTHON_EXTENSIONS = frozenset({"pyx", "pxd"})
+SUPPORTED_EXTENSIONS = frozenset({"py", "pyi", *CYTHON_EXTENSIONS})
+BLOCKED_EXTENSIONS = frozenset({"pex"})
+FILE_SKIP_COMMENTS: Tuple[str, ...] = (
+    "isort:" + "skip_file",
+    "isort: " + "skip_file",
+)  # Concatenated to avoid this file being skipped
+MAX_CONFIG_SEARCH_DEPTH: int = 25  # The number of parent directories to for a config file within
+STOP_CONFIG_SEARCH_ON_DIRS: Tuple[str, ...] = (".git", ".hg")
+VALID_PY_TARGETS: Tuple[str, ...] = tuple(
+    target.replace("py", "") for target in dir(stdlibs) if not target.startswith("_")
+)
+CONFIG_SOURCES: Tuple[str, ...] = (
+    ".isort.cfg",
+    "pyproject.toml",
+    "setup.cfg",
+    "tox.ini",
+    ".editorconfig",
+)
+DEFAULT_SKIP: FrozenSet[str] = frozenset(
+    {
+        ".venv",
+        "venv",
+        ".tox",
+        ".eggs",
+        ".git",
+        ".hg",
+        ".mypy_cache",
+        ".nox",
+        ".svn",
+        ".bzr",
+        "_build",
+        "buck-out",
+        "build",
+        "dist",
+        ".pants.d",
+        ".direnv",
+        "node_modules",
+        "__pypackages__",
+    }
+)
+
+CONFIG_SECTIONS: Dict[str, Tuple[str, ...]] = {
+    ".isort.cfg": ("settings", "isort"),
+    "pyproject.toml": ("tool.isort",),
+    "setup.cfg": ("isort", "tool:isort"),
+    "tox.ini": ("isort", "tool:isort"),
+    ".editorconfig": ("*", "*.py", "**.py", "*.{py}"),
+}
+FALLBACK_CONFIG_SECTIONS: Tuple[str, ...] = ("isort", "tool:isort", "tool.isort")
+
+IMPORT_HEADING_PREFIX = "import_heading_"
+IMPORT_FOOTER_PREFIX = "import_footer_"
+KNOWN_PREFIX = "known_"
+KNOWN_SECTION_MAPPING: Dict[str, str] = {
+    STDLIB: "STANDARD_LIBRARY",
+    FUTURE: "FUTURE_LIBRARY",
+    FIRSTPARTY: "FIRST_PARTY",
+    THIRDPARTY: "THIRD_PARTY",
+    LOCALFOLDER: "LOCAL_FOLDER",
+}
+
+RUNTIME_SOURCE = "runtime"
+
+DEPRECATED_SETTINGS = ("not_skip", "keep_direct_and_as_imports")
+
+_STR_BOOLEAN_MAPPING = {
+    "y": True,
+    "yes": True,
+    "t": True,
+    "on": True,
+    "1": True,
+    "true": True,
+    "n": False,
+    "no": False,
+    "f": False,
+    "off": False,
+    "0": False,
+    "false": False,
+}
+
+
+@dataclass(frozen=True)
+class _Config:
+    """Defines the data schema and defaults used for isort configuration.
+
+    NOTE: known lists, such as known_standard_library, are intentionally not complete as they are
+    dynamically determined later on.
+    """
+
+    py_version: str = "3"
+    force_to_top: FrozenSet[str] = frozenset()
+    skip: FrozenSet[str] = DEFAULT_SKIP
+    extend_skip: FrozenSet[str] = frozenset()
+    skip_glob: FrozenSet[str] = frozenset()
+    extend_skip_glob: FrozenSet[str] = frozenset()
+    skip_gitignore: bool = False
+    line_length: int = 79
+    wrap_length: int = 0
+    line_ending: str = ""
+    sections: Tuple[str, ...] = SECTION_DEFAULTS
+    no_sections: bool = False
+    known_future_library: FrozenSet[str] = frozenset(("__future__",))
+    known_third_party: FrozenSet[str] = frozenset()
+    known_first_party: FrozenSet[str] = frozenset()
+    known_local_folder: FrozenSet[str] = frozenset()
+    known_standard_library: FrozenSet[str] = frozenset()
+    extra_standard_library: FrozenSet[str] = frozenset()
+    known_other: Dict[str, FrozenSet[str]] = field(default_factory=dict)
+    multi_line_output: WrapModes = WrapModes.GRID  # type: ignore
+    forced_separate: Tuple[str, ...] = ()
+    indent: str = " " * 4
+    comment_prefix: str = "  #"
+    length_sort: bool = False
+    length_sort_straight: bool = False
+    length_sort_sections: FrozenSet[str] = frozenset()
+    add_imports: FrozenSet[str] = frozenset()
+    remove_imports: FrozenSet[str] = frozenset()
+    append_only: bool = False
+    reverse_relative: bool = False
+    force_single_line: bool = False
+    single_line_exclusions: Tuple[str, ...] = ()
+    default_section: str = THIRDPARTY
+    import_headings: Dict[str, str] = field(default_factory=dict)
+    import_footers: Dict[str, str] = field(default_factory=dict)
+    balanced_wrapping: bool = False
+    use_parentheses: bool = False
+    order_by_type: bool = True
+    atomic: bool = False
+    lines_before_imports: int = -1
+    lines_after_imports: int = -1
+    lines_between_sections: int = 1
+    lines_between_types: int = 0
+    combine_as_imports: bool = False
+    combine_star: bool = False
+    include_trailing_comma: bool = False
+    from_first: bool = False
+    verbose: bool = False
+    quiet: bool = False
+    force_adds: bool = False
+    force_alphabetical_sort_within_sections: bool = False
+    force_alphabetical_sort: bool = False
+    force_grid_wrap: int = 0
+    force_sort_within_sections: bool = False
+    lexicographical: bool = False
+    group_by_package: bool = False
+    ignore_whitespace: bool = False
+    no_lines_before: FrozenSet[str] = frozenset()
+    no_inline_sort: bool = False
+    ignore_comments: bool = False
+    case_sensitive: bool = False
+    sources: Tuple[Dict[str, Any], ...] = ()
+    virtual_env: str = ""
+    conda_env: str = ""
+    ensure_newline_before_comments: bool = False
+    directory: str = ""
+    profile: str = ""
+    honor_noqa: bool = False
+    src_paths: Tuple[Path, ...] = ()
+    old_finders: bool = False
+    remove_redundant_aliases: bool = False
+    float_to_top: bool = False
+    filter_files: bool = False
+    formatter: str = ""
+    formatting_function: Optional[Callable[[str, str, object], str]] = None
+    color_output: bool = False
+    treat_comments_as_code: FrozenSet[str] = frozenset()
+    treat_all_comments_as_code: bool = False
+    supported_extensions: FrozenSet[str] = SUPPORTED_EXTENSIONS
+    blocked_extensions: FrozenSet[str] = BLOCKED_EXTENSIONS
+    constants: FrozenSet[str] = frozenset()
+    classes: FrozenSet[str] = frozenset()
+    variables: FrozenSet[str] = frozenset()
+    dedup_headings: bool = False
+    only_sections: bool = False
+    only_modified: bool = False
+    combine_straight_imports: bool = False
+    auto_identify_namespace_packages: bool = True
+    namespace_packages: FrozenSet[str] = frozenset()
+    follow_links: bool = True
+    indented_import_headings: bool = True
+    honor_case_in_force_sorted_sections: bool = False
+    sort_relative_in_force_sorted_sections: bool = False
+    overwrite_in_place: bool = False
+    reverse_sort: bool = False
+    star_first: bool = False
+    import_dependencies = Dict[str, str]
+    git_ignore: Dict[Path, Set[Path]] = field(default_factory=dict)
+    format_error: str = "{error}: {message}"
+    format_success: str = "{success}: {message}"
+    sort_order: str = "natural"
+
+    def __post_init__(self) -> None:
+        py_version = self.py_version
+        if py_version == "auto":  # pragma: no cover
+            if sys.version_info.major == 2 and sys.version_info.minor <= 6:
+                py_version = "2"
+            elif sys.version_info.major == 3 and (
+                sys.version_info.minor <= 5 or sys.version_info.minor >= 10
+            ):
+                py_version = "3"
+            else:
+                py_version = f"{sys.version_info.major}{sys.version_info.minor}"
+
+        if py_version not in VALID_PY_TARGETS:
+            raise ValueError(
+                f"The python version {py_version} is not supported. "
+                "You can set a python version with the -py or --python-version flag. "
+                f"The following versions are supported: {VALID_PY_TARGETS}"
+            )
+
+        if py_version != "all":
+            object.__setattr__(self, "py_version", f"py{py_version}")
+
+        if not self.known_standard_library:
+            object.__setattr__(
+                self, "known_standard_library", frozenset(getattr(stdlibs, self.py_version).stdlib)
+            )
+
+        if self.multi_line_output == WrapModes.VERTICAL_GRID_GROUPED_NO_COMMA:  # type: ignore
+            vertical_grid_grouped = WrapModes.VERTICAL_GRID_GROUPED  # type: ignore
+            object.__setattr__(self, "multi_line_output", vertical_grid_grouped)
+        if self.force_alphabetical_sort:
+            object.__setattr__(self, "force_alphabetical_sort_within_sections", True)
+            object.__setattr__(self, "no_sections", True)
+            object.__setattr__(self, "lines_between_types", 1)
+            object.__setattr__(self, "from_first", True)
+        if self.wrap_length > self.line_length:
+            raise ValueError(
+                "wrap_length must be set lower than or equal to line_length: "
+                f"{self.wrap_length} > {self.line_length}."
+            )
+
+    def __hash__(self) -> int:
+        return id(self)
+
+
+_DEFAULT_SETTINGS = {**vars(_Config()), "source": "defaults"}
+
+
+class Config(_Config):
+    def __init__(
+        self,
+        settings_file: str = "",
+        settings_path: str = "",
+        config: Optional[_Config] = None,
+        **config_overrides: Any,
+    ):
+        self._known_patterns: Optional[List[Tuple[Pattern[str], str]]] = None
+        self._section_comments: Optional[Tuple[str, ...]] = None
+        self._section_comments_end: Optional[Tuple[str, ...]] = None
+        self._skips: Optional[FrozenSet[str]] = None
+        self._skip_globs: Optional[FrozenSet[str]] = None
+        self._sorting_function: Optional[Callable[..., List[str]]] = None
+
+        if config:
+            config_vars = vars(config).copy()
+            config_vars.update(config_overrides)
+            config_vars["py_version"] = config_vars["py_version"].replace("py", "")
+            config_vars.pop("_known_patterns")
+            config_vars.pop("_section_comments")
+            config_vars.pop("_section_comments_end")
+            config_vars.pop("_skips")
+            config_vars.pop("_skip_globs")
+            config_vars.pop("_sorting_function")
+            super().__init__(**config_vars)  # type: ignore
+            return
+
+        # We can't use self.quiet to conditionally show warnings before super.__init__() is called
+        # at the end of this method. _Config is also frozen so setting self.quiet isn't possible.
+        # Therefore we extract quiet early here in a variable and use that in warning conditions.
+        quiet = config_overrides.get("quiet", False)
+
+        sources: List[Dict[str, Any]] = [_DEFAULT_SETTINGS]
+
+        config_settings: Dict[str, Any]
+        project_root: str
+        if settings_file:
+            config_settings = _get_config_data(
+                settings_file,
+                CONFIG_SECTIONS.get(os.path.basename(settings_file), FALLBACK_CONFIG_SECTIONS),
+            )
+            project_root = os.path.dirname(settings_file)
+            if not config_settings and not quiet:
+                warn(
+                    f"A custom settings file was specified: {settings_file} but no configuration "
+                    "was found inside. This can happen when [settings] is used as the config "
+                    "header instead of [isort]. "
+                    "See: https://pycqa.github.io/isort/docs/configuration/config_files"
+                    "/#custom_config_files for more information."
+                )
+        elif settings_path:
+            if not os.path.exists(settings_path):
+                raise InvalidSettingsPath(settings_path)
+
+            settings_path = os.path.abspath(settings_path)
+            project_root, config_settings = _find_config(settings_path)
+        else:
+            config_settings = {}
+            project_root = os.getcwd()
+
+        profile_name = config_overrides.get("profile", config_settings.get("profile", ""))
+        profile: Dict[str, Any] = {}
+        if profile_name:
+            if profile_name not in profiles:
+                import pkg_resources
+
+                for plugin in pkg_resources.iter_entry_points("isort.profiles"):
+                    profiles.setdefault(plugin.name, plugin.load())
+
+            if profile_name not in profiles:
+                raise ProfileDoesNotExist(profile_name)
+
+            profile = profiles[profile_name].copy()
+            profile["source"] = f"{profile_name} profile"
+            sources.append(profile)
+
+        if config_settings:
+            sources.append(config_settings)
+        if config_overrides:
+            config_overrides["source"] = RUNTIME_SOURCE
+            sources.append(config_overrides)
+
+        combined_config = {**profile, **config_settings, **config_overrides}
+        if "indent" in combined_config:
+            indent = str(combined_config["indent"])
+            if indent.isdigit():
+                indent = " " * int(indent)
+            else:
+                indent = indent.strip("'").strip('"')
+                if indent.lower() == "tab":
+                    indent = "\t"
+            combined_config["indent"] = indent
+
+        known_other = {}
+        import_headings = {}
+        import_footers = {}
+        for key, value in tuple(combined_config.items()):
+            # Collect all known sections beyond those that have direct entries
+            if key.startswith(KNOWN_PREFIX) and key not in (
+                "known_standard_library",
+                "known_future_library",
+                "known_third_party",
+                "known_first_party",
+                "known_local_folder",
+            ):
+                import_heading = key[len(KNOWN_PREFIX) :].lower()
+                maps_to_section = import_heading.upper()
+                combined_config.pop(key)
+                if maps_to_section in KNOWN_SECTION_MAPPING:
+                    section_name = f"known_{KNOWN_SECTION_MAPPING[maps_to_section].lower()}"
+                    if section_name in combined_config and not quiet:
+                        warn(
+                            f"Can't set both {key} and {section_name} in the same config file.\n"
+                            f"Default to {section_name} if unsure."
+                            "\n\n"
+                            "See: https://pycqa.github.io/isort/"
+                            "#custom-sections-and-ordering."
+                        )
+                    else:
+                        combined_config[section_name] = frozenset(value)
+                else:
+                    known_other[import_heading] = frozenset(value)
+                    if maps_to_section not in combined_config.get("sections", ()) and not quiet:
+                        warn(
+                            f"`{key}` setting is defined, but {maps_to_section} is not"
+                            " included in `sections` config option:"
+                            f" {combined_config.get('sections', SECTION_DEFAULTS)}.\n\n"
+                            "See: https://pycqa.github.io/isort/"
+                            "#custom-sections-and-ordering."
+                        )
+            if key.startswith(IMPORT_HEADING_PREFIX):
+                import_headings[key[len(IMPORT_HEADING_PREFIX) :].lower()] = str(value)
+            if key.startswith(IMPORT_FOOTER_PREFIX):
+                import_footers[key[len(IMPORT_FOOTER_PREFIX) :].lower()] = str(value)
+
+            # Coerce all provided config values into their correct type
+            default_value = _DEFAULT_SETTINGS.get(key, None)
+            if default_value is None:
+                continue
+
+            combined_config[key] = type(default_value)(value)
+
+        for section in combined_config.get("sections", ()):
+            if section in SECTION_DEFAULTS:
+                continue
+
+            if not section.lower() in known_other:
+                config_keys = ", ".join(known_other.keys())
+                warn(
+                    f"`sections` setting includes {section}, but no known_{section.lower()} "
+                    "is defined. "
+                    f"The following known_SECTION config options are defined: {config_keys}."
+                )
+
+        if "directory" not in combined_config:
+            combined_config["directory"] = (
+                os.path.dirname(config_settings["source"])
+                if config_settings.get("source", None)
+                else os.getcwd()
+            )
+
+        path_root = Path(combined_config.get("directory", project_root)).resolve()
+        path_root = path_root if path_root.is_dir() else path_root.parent
+        if "src_paths" not in combined_config:
+            combined_config["src_paths"] = (path_root / "src", path_root)
+        else:
+            src_paths: List[Path] = []
+            for src_path in combined_config.get("src_paths", ()):
+                full_paths = (
+                    path_root.glob(src_path) if "*" in str(src_path) else [path_root / src_path]
+                )
+                for path in full_paths:
+                    if path not in src_paths:
+                        src_paths.append(path)
+
+            combined_config["src_paths"] = tuple(src_paths)
+
+        if "formatter" in combined_config:
+            import pkg_resources
+
+            for plugin in pkg_resources.iter_entry_points("isort.formatters"):
+                if plugin.name == combined_config["formatter"]:
+                    combined_config["formatting_function"] = plugin.load()
+                    break
+            else:
+                raise FormattingPluginDoesNotExist(combined_config["formatter"])
+
+        # Remove any config values that are used for creating config object but
+        # aren't defined in dataclass
+        combined_config.pop("source", None)
+        combined_config.pop("sources", None)
+        combined_config.pop("runtime_src_paths", None)
+
+        deprecated_options_used = [
+            option for option in combined_config if option in DEPRECATED_SETTINGS
+        ]
+        if deprecated_options_used:
+            for deprecated_option in deprecated_options_used:
+                combined_config.pop(deprecated_option)
+            if not quiet:
+                warn(
+                    "W0503: Deprecated config options were used: "
+                    f"{', '.join(deprecated_options_used)}."
+                    "Please see the 5.0.0 upgrade guide: "
+                    "https://pycqa.github.io/isort/docs/upgrade_guides/5.0.0.html"
+                )
+
+        if known_other:
+            combined_config["known_other"] = known_other
+        if import_headings:
+            for import_heading_key in import_headings:
+                combined_config.pop(f"{IMPORT_HEADING_PREFIX}{import_heading_key}")
+            combined_config["import_headings"] = import_headings
+        if import_footers:
+            for import_footer_key in import_footers:
+                combined_config.pop(f"{IMPORT_FOOTER_PREFIX}{import_footer_key}")
+            combined_config["import_footers"] = import_footers
+
+        unsupported_config_errors = {}
+        for option in set(combined_config.keys()).difference(
+            getattr(_Config, "__dataclass_fields__", {}).keys()
+        ):
+            for source in reversed(sources):
+                if option in source:
+                    unsupported_config_errors[option] = {
+                        "value": source[option],
+                        "source": source["source"],
+                    }
+        if unsupported_config_errors:
+            raise UnsupportedSettings(unsupported_config_errors)
+
+        super().__init__(sources=tuple(sources), **combined_config)  # type: ignore
+
+    def is_supported_filetype(self, file_name: str) -> bool:
+        _root, ext = os.path.splitext(file_name)
+        ext = ext.lstrip(".")
+        if ext in self.supported_extensions:
+            return True
+        if ext in self.blocked_extensions:
+            return False
+
+        # Skip editor backup files.
+        if file_name.endswith("~"):
+            return False
+
+        try:
+            if stat.S_ISFIFO(os.stat(file_name).st_mode):
+                return False
+        except OSError:
+            pass
+
+        try:
+            with open(file_name, "rb") as fp:
+                line = fp.readline(100)
+        except OSError:
+            return False
+        else:
+            return bool(_SHEBANG_RE.match(line))
+
+    def _check_folder_gitignore(self, folder: str) -> Optional[Path]:
+        env = {**os.environ, "LANG": "C.UTF-8"}
+        try:
+            topfolder_result = subprocess.check_output(  # nosec # skipcq: PYL-W1510
+                ["git", "-C", folder, "rev-parse", "--show-toplevel"], encoding="utf-8", env=env
+            )
+        except subprocess.CalledProcessError:
+            return None
+
+        git_folder = Path(topfolder_result.rstrip()).resolve()
+
+        files: List[str] = []
+        # don't check symlinks; either part of the repo and would be checked
+        # twice, or is external to the repo and git won't know anything about it
+        for root, _dirs, git_files in os.walk(git_folder, followlinks=False):
+            if ".git" in _dirs:
+                _dirs.remove(".git")
+            for git_file in git_files:
+                files.append(os.path.join(root, git_file))
+        git_options = ["-C", str(git_folder), "-c", "core.quotePath="]
+        try:
+            ignored = subprocess.check_output(  # nosec # skipcq: PYL-W1510
+                ["git", *git_options, "check-ignore", "-z", "--stdin", "--no-index"],
+                encoding="utf-8",
+                env=env,
+                input="\0".join(files),
+            )
+        except subprocess.CalledProcessError:
+            return None
+
+        self.git_ignore[git_folder] = {Path(f) for f in ignored.rstrip("\0").split("\0")}
+        return git_folder
+
+    def is_skipped(self, file_path: Path) -> bool:
+        """Returns True if the file and/or folder should be skipped based on current settings."""
+        if self.directory and Path(self.directory) in file_path.resolve().parents:
+            file_name = os.path.relpath(file_path.resolve(), self.directory)
+        else:
+            file_name = str(file_path)
+
+        os_path = str(file_path)
+
+        normalized_path = os_path.replace("\\", "/")
+        if normalized_path[1:2] == ":":
+            normalized_path = normalized_path[2:]
+
+        for skip_path in self.skips:
+            if posixpath.abspath(normalized_path) == posixpath.abspath(
+                skip_path.replace("\\", "/")
+            ):
+                return True
+
+        position = os.path.split(file_name)
+        while position[1]:
+            if position[1] in self.skips:
+                return True
+            position = os.path.split(position[0])
+
+        for sglob in self.skip_globs:
+            if fnmatch.fnmatch(file_name, sglob) or fnmatch.fnmatch("/" + file_name, sglob):
+                return True
+
+        if not (os.path.isfile(os_path) or os.path.isdir(os_path) or os.path.islink(os_path)):
+            return True
+
+        if self.skip_gitignore:
+            if file_path.name == ".git":  # pragma: no cover
+                return True
+
+            git_folder = None
+
+            file_paths = [file_path, file_path.resolve()]
+            for folder in self.git_ignore:
+                if any(folder in path.parents for path in file_paths):
+                    git_folder = folder
+                    break
+            else:
+                git_folder = self._check_folder_gitignore(str(file_path.parent))
+
+            if git_folder and any(path in self.git_ignore[git_folder] for path in file_paths):
+                return True
+
+        return False
+
+    @property
+    def known_patterns(self) -> List[Tuple[Pattern[str], str]]:
+        if self._known_patterns is not None:
+            return self._known_patterns
+
+        self._known_patterns = []
+        pattern_sections = [STDLIB] + [section for section in self.sections if section != STDLIB]
+        for placement in reversed(pattern_sections):
+            known_placement = KNOWN_SECTION_MAPPING.get(placement, placement).lower()
+            config_key = f"{KNOWN_PREFIX}{known_placement}"
+            known_modules = getattr(self, config_key, self.known_other.get(known_placement, ()))
+            extra_modules = getattr(self, f"extra_{known_placement}", ())
+            all_modules = set(extra_modules).union(known_modules)
+            known_patterns = [
+                pattern
+                for known_pattern in all_modules
+                for pattern in self._parse_known_pattern(known_pattern)
+            ]
+            for known_pattern in known_patterns:
+                regexp = "^" + known_pattern.replace("*", ".*").replace("?", ".?") + "$"
+                self._known_patterns.append((re.compile(regexp), placement))
+
+        return self._known_patterns
+
+    @property
+    def section_comments(self) -> Tuple[str, ...]:
+        if self._section_comments is not None:
+            return self._section_comments
+
+        self._section_comments = tuple(f"# {heading}" for heading in self.import_headings.values())
+        return self._section_comments
+
+    @property
+    def section_comments_end(self) -> Tuple[str, ...]:
+        if self._section_comments_end is not None:
+            return self._section_comments_end
+
+        self._section_comments_end = tuple(f"# {footer}" for footer in self.import_footers.values())
+        return self._section_comments_end
+
+    @property
+    def skips(self) -> FrozenSet[str]:
+        if self._skips is not None:
+            return self._skips
+
+        self._skips = self.skip.union(self.extend_skip)
+        return self._skips
+
+    @property
+    def skip_globs(self) -> FrozenSet[str]:
+        if self._skip_globs is not None:
+            return self._skip_globs
+
+        self._skip_globs = self.skip_glob.union(self.extend_skip_glob)
+        return self._skip_globs
+
+    @property
+    def sorting_function(self) -> Callable[..., List[str]]:
+        if self._sorting_function is not None:
+            return self._sorting_function
+
+        if self.sort_order == "natural":
+            self._sorting_function = sorting.naturally
+        elif self.sort_order == "native":
+            self._sorting_function = sorted
+        else:
+            available_sort_orders = ["natural", "native"]
+            import pkg_resources
+
+            for sort_plugin in pkg_resources.iter_entry_points("isort.sort_function"):
+                available_sort_orders.append(sort_plugin.name)
+                if sort_plugin.name == self.sort_order:
+                    self._sorting_function = sort_plugin.load()
+                    break
+            else:
+                raise SortingFunctionDoesNotExist(self.sort_order, available_sort_orders)
+
+        return self._sorting_function
+
+    def _parse_known_pattern(self, pattern: str) -> List[str]:
+        """Expand pattern if identified as a directory and return found sub packages"""
+        if pattern.endswith(os.path.sep):
+            patterns = [
+                filename
+                for filename in os.listdir(os.path.join(self.directory, pattern))
+                if os.path.isdir(os.path.join(self.directory, pattern, filename))
+            ]
+        else:
+            patterns = [pattern]
+
+        return patterns
+
+
+def _get_str_to_type_converter(setting_name: str) -> Union[Callable[[str], Any], Type[Any]]:
+    type_converter: Union[Callable[[str], Any], Type[Any]] = type(
+        _DEFAULT_SETTINGS.get(setting_name, "")
+    )
+    if type_converter == WrapModes:
+        type_converter = wrap_mode_from_string
+    return type_converter
+
+
+def _as_list(value: str) -> List[str]:
+    if isinstance(value, list):
+        return [item.strip() for item in value]
+    filtered = [item.strip() for item in value.replace("\n", ",").split(",") if item.strip()]
+    return filtered
+
+
+def _abspaths(cwd: str, values: Iterable[str]) -> Set[str]:
+    paths = {
+        os.path.join(cwd, value)
+        if not value.startswith(os.path.sep) and value.endswith(os.path.sep)
+        else value
+        for value in values
+    }
+    return paths
+
+
+@lru_cache()
+def _find_config(path: str) -> Tuple[str, Dict[str, Any]]:
+    current_directory = path
+    tries = 0
+    while current_directory and tries < MAX_CONFIG_SEARCH_DEPTH:
+        for config_file_name in CONFIG_SOURCES:
+            potential_config_file = os.path.join(current_directory, config_file_name)
+            if os.path.isfile(potential_config_file):
+                config_data: Dict[str, Any]
+                try:
+                    config_data = _get_config_data(
+                        potential_config_file, CONFIG_SECTIONS[config_file_name]
+                    )
+                except Exception:
+                    warn(f"Failed to pull configuration information from {potential_config_file}")
+                    config_data = {}
+                if config_data:
+                    return (current_directory, config_data)
+
+        for stop_dir in STOP_CONFIG_SEARCH_ON_DIRS:
+            if os.path.isdir(os.path.join(current_directory, stop_dir)):
+                return (current_directory, {})
+
+        new_directory = os.path.split(current_directory)[0]
+        if new_directory == current_directory:
+            break
+
+        current_directory = new_directory
+        tries += 1
+
+    return (path, {})
+
+
+@lru_cache()
+def find_all_configs(path: str) -> Trie:
+    """
+    Looks for config files in the path provided and in all of its sub-directories.
+    Parses and stores any config file encountered in a trie and returns the root of
+    the trie
+    """
+    trie_root = Trie("default", {})
+
+    for (dirpath, _, _) in os.walk(path):
+        for config_file_name in CONFIG_SOURCES:
+            potential_config_file = os.path.join(dirpath, config_file_name)
+            if os.path.isfile(potential_config_file):
+                config_data: Dict[str, Any]
+                try:
+                    config_data = _get_config_data(
+                        potential_config_file, CONFIG_SECTIONS[config_file_name]
+                    )
+                except Exception:
+                    warn(f"Failed to pull configuration information from {potential_config_file}")
+                    config_data = {}
+
+                if config_data:
+                    trie_root.insert(potential_config_file, config_data)
+                    break
+
+    return trie_root
+
+
+@lru_cache()
+def _get_config_data(file_path: str, sections: Tuple[str]) -> Dict[str, Any]:
+    settings: Dict[str, Any] = {}
+
+    if file_path.endswith(".toml"):
+        with open(file_path, "rb") as bin_config_file:
+            config = tomli.load(bin_config_file)
+        for section in sections:
+            config_section = config
+            for key in section.split("."):
+                config_section = config_section.get(key, {})
+            settings.update(config_section)
+    else:
+        with open(file_path, encoding="utf-8") as config_file:
+            if file_path.endswith(".editorconfig"):
+                line = "\n"
+                last_position = config_file.tell()
+                while line:
+                    line = config_file.readline()
+                    if "[" in line:
+                        config_file.seek(last_position)
+                        break
+                    last_position = config_file.tell()
+
+            config = configparser.ConfigParser(strict=False)
+            config.read_file(config_file)
+        for section in sections:
+            if section.startswith("*.{") and section.endswith("}"):
+                extension = section[len("*.{") : -1]
+                for config_key in config.keys():
+                    if (
+                        config_key.startswith("*.{")
+                        and config_key.endswith("}")
+                        and extension
+                        in map(
+                            lambda text: text.strip(), config_key[len("*.{") : -1].split(",")  # type: ignore # noqa
+                        )
+                    ):
+                        settings.update(config.items(config_key))
+
+            elif config.has_section(section):
+                settings.update(config.items(section))
+
+    if settings:
+        settings["source"] = file_path
+
+        if file_path.endswith(".editorconfig"):
+            indent_style = settings.pop("indent_style", "").strip()
+            indent_size = settings.pop("indent_size", "").strip()
+            if indent_size == "tab":
+                indent_size = settings.pop("tab_width", "").strip()
+
+            if indent_style == "space":
+                settings["indent"] = " " * (indent_size and int(indent_size) or 4)
+
+            elif indent_style == "tab":
+                settings["indent"] = "\t" * (indent_size and int(indent_size) or 1)
+
+            max_line_length = settings.pop("max_line_length", "").strip()
+            if max_line_length and (max_line_length == "off" or max_line_length.isdigit()):
+                settings["line_length"] = (
+                    float("inf") if max_line_length == "off" else int(max_line_length)
+                )
+            settings = {
+                key: value
+                for key, value in settings.items()
+                if key in _DEFAULT_SETTINGS.keys() or key.startswith(KNOWN_PREFIX)
+            }
+
+        for key, value in settings.items():
+            existing_value_type = _get_str_to_type_converter(key)
+            if existing_value_type == tuple:
+                settings[key] = tuple(_as_list(value))
+            elif existing_value_type == frozenset:
+                settings[key] = frozenset(_as_list(settings.get(key)))  # type: ignore
+            elif existing_value_type == bool:
+                # Only some configuration formats support native boolean values.
+                if not isinstance(value, bool):
+                    value = _as_bool(value)
+                settings[key] = value
+            elif key.startswith(KNOWN_PREFIX):
+                settings[key] = _abspaths(os.path.dirname(file_path), _as_list(value))
+            elif key == "force_grid_wrap":
+                try:
+                    result = existing_value_type(value)
+                except ValueError:  # backwards compatibility for true / false force grid wrap
+                    result = 0 if value.lower().strip() == "false" else 2
+                settings[key] = result
+            elif key == "comment_prefix":
+                settings[key] = str(value).strip("'").strip('"')
+            else:
+                settings[key] = existing_value_type(value)
+
+    return settings
+
+
+def _as_bool(value: str) -> bool:
+    """Given a string value that represents True or False, returns the Boolean equivalent.
+    Heavily inspired from distutils strtobool.
+    """
+    try:
+        return _STR_BOOLEAN_MAPPING[value.lower()]
+    except KeyError:
+        raise ValueError(f"invalid truth value {value}")
+
+
+DEFAULT_CONFIG = Config()
diff --git a/myenv/lib/python3.9/site-packages/isort/setuptools_commands.py b/myenv/lib/python3.9/site-packages/isort/setuptools_commands.py
new file mode 100644
index 0000000..d60deda
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/setuptools_commands.py
@@ -0,0 +1,61 @@
+import glob
+import os
+import sys
+from typing import Any, Dict, Iterator, List
+from warnings import warn
+
+import setuptools  # type: ignore
+
+from . import api
+from .settings import DEFAULT_CONFIG
+
+
+class ISortCommand(setuptools.Command):  # type: ignore
+    """The :class:`ISortCommand` class is used by setuptools to perform
+    imports checks on registered modules.
+    """
+
+    description = "Run isort on modules registered in setuptools"
+    user_options: List[Any] = []
+
+    def initialize_options(self) -> None:
+        default_settings = vars(DEFAULT_CONFIG).copy()
+        for key, value in default_settings.items():
+            setattr(self, key, value)
+
+    def finalize_options(self) -> None:
+        """Get options from config files."""
+        self.arguments: Dict[str, Any] = {}  # skipcq: PYL-W0201
+        self.arguments["settings_path"] = os.getcwd()
+
+    def distribution_files(self) -> Iterator[str]:
+        """Find distribution packages."""
+        # This is verbatim from flake8
+        if self.distribution.packages:  # pragma: no cover
+            package_dirs = self.distribution.package_dir or {}
+            for package in self.distribution.packages:
+                pkg_dir = package
+                if package in package_dirs:
+                    pkg_dir = package_dirs[package]
+                elif "" in package_dirs:  # pragma: no cover
+                    pkg_dir = package_dirs[""] + os.path.sep + pkg_dir
+                yield pkg_dir.replace(".", os.path.sep)
+
+        if self.distribution.py_modules:
+            for filename in self.distribution.py_modules:
+                yield "%s.py" % filename
+        # Don't miss the setup.py file itself
+        yield "setup.py"
+
+    def run(self) -> None:
+        arguments = self.arguments
+        wrong_sorted_files = False
+        for path in self.distribution_files():
+            for python_file in glob.iglob(os.path.join(path, "*.py")):
+                try:
+                    if not api.check_file(python_file, **arguments):
+                        wrong_sorted_files = True  # pragma: no cover
+                except OSError as error:  # pragma: no cover
+                    warn(f"Unable to parse file {python_file} due to {error}")
+        if wrong_sorted_files:
+            sys.exit(1)  # pragma: no cover
diff --git a/myenv/lib/python3.9/site-packages/isort/sorting.py b/myenv/lib/python3.9/site-packages/isort/sorting.py
new file mode 100644
index 0000000..22fdc38
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/sorting.py
@@ -0,0 +1,130 @@
+import re
+from typing import TYPE_CHECKING, Any, Callable, Iterable, List, Optional
+
+if TYPE_CHECKING:
+    from .settings import Config
+else:
+    Config = Any
+
+_import_line_intro_re = re.compile("^(?:from|import) ")
+_import_line_midline_import_re = re.compile(" import ")
+
+
+def module_key(
+    module_name: str,
+    config: Config,
+    sub_imports: bool = False,
+    ignore_case: bool = False,
+    section_name: Optional[Any] = None,
+    straight_import: Optional[bool] = False,
+) -> str:
+    match = re.match(r"^(\.+)\s*(.*)", module_name)
+    if match:
+        sep = " " if config.reverse_relative else "_"
+        module_name = sep.join(match.groups())
+
+    prefix = ""
+    if ignore_case:
+        module_name = str(module_name).lower()
+    else:
+        module_name = str(module_name)
+
+    if sub_imports and config.order_by_type:
+        if module_name in config.constants:
+            prefix = "A"
+        elif module_name in config.classes:
+            prefix = "B"
+        elif module_name in config.variables:
+            prefix = "C"
+        elif module_name.isupper() and len(module_name) > 1:  # see issue #376
+            prefix = "A"
+        elif module_name in config.classes or module_name[0:1].isupper():
+            prefix = "B"
+        else:
+            prefix = "C"
+    if not config.case_sensitive:
+        module_name = module_name.lower()
+
+    length_sort = (
+        config.length_sort
+        or (config.length_sort_straight and straight_import)
+        or str(section_name).lower() in config.length_sort_sections
+    )
+    _length_sort_maybe = (str(len(module_name)) + ":" + module_name) if length_sort else module_name
+    return f"{module_name in config.force_to_top and 'A' or 'B'}{prefix}{_length_sort_maybe}"
+
+
+def section_key(line: str, config: Config) -> str:
+    section = "B"
+
+    if (
+        not config.sort_relative_in_force_sorted_sections
+        and config.reverse_relative
+        and line.startswith("from .")
+    ):
+        match = re.match(r"^from (\.+)\s*(.*)", line)
+        if match:  # pragma: no cover - regex always matches if line starts with "from ."
+            line = f"from {' '.join(match.groups())}"
+    if config.group_by_package and line.strip().startswith("from"):
+        line = line.split(" import", 1)[0]
+
+    if config.lexicographical:
+        line = _import_line_intro_re.sub("", _import_line_midline_import_re.sub(".", line))
+    else:
+        line = re.sub("^from ", "", line)
+        line = re.sub("^import ", "", line)
+    if config.sort_relative_in_force_sorted_sections:
+        sep = " " if config.reverse_relative else "_"
+        line = re.sub(r"^(\.+)", fr"\1{sep}", line)
+    if line.split(" ")[0] in config.force_to_top:
+        section = "A"
+    # * If honor_case_in_force_sorted_sections is true, and case_sensitive and
+    #   order_by_type are different, only ignore case in part of the line.
+    # * Otherwise, let order_by_type decide the sorting of the whole line. This
+    #   is only "correct" if case_sensitive and order_by_type have the same value.
+    if config.honor_case_in_force_sorted_sections and config.case_sensitive != config.order_by_type:
+        split_module = line.split(" import ", 1)
+        if len(split_module) > 1:
+            module_name, names = split_module
+            if not config.case_sensitive:
+                module_name = module_name.lower()
+            if not config.order_by_type:
+                names = names.lower()
+            line = " import ".join([module_name, names])
+        elif not config.case_sensitive:
+            line = line.lower()
+    elif not config.order_by_type:
+        line = line.lower()
+
+    return f"{section}{len(line) if config.length_sort else ''}{line}"
+
+
+def sort(
+    config: Config,
+    to_sort: Iterable[str],
+    key: Optional[Callable[[str], Any]] = None,
+    reverse: bool = False,
+) -> List[str]:
+    return config.sorting_function(to_sort, key=key, reverse=reverse)
+
+
+def naturally(
+    to_sort: Iterable[str], key: Optional[Callable[[str], Any]] = None, reverse: bool = False
+) -> List[str]:
+    """Returns a naturally sorted list"""
+    if key is None:
+        key_callback = _natural_keys
+    else:
+
+        def key_callback(text: str) -> List[Any]:
+            return _natural_keys(key(text))  # type: ignore
+
+    return sorted(to_sort, key=key_callback, reverse=reverse)
+
+
+def _atoi(text: str) -> Any:
+    return int(text) if text.isdigit() else text
+
+
+def _natural_keys(text: str) -> List[Any]:
+    return [_atoi(c) for c in re.split(r"(\d+)", text)]
diff --git a/myenv/lib/python3.9/site-packages/isort/stdlibs/__init__.py b/myenv/lib/python3.9/site-packages/isort/stdlibs/__init__.py
new file mode 100644
index 0000000..7b00716
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/stdlibs/__init__.py
@@ -0,0 +1,2 @@
+from . import all as _all
+from . import py2, py3, py27, py35, py36, py37, py38, py39, py310
diff --git a/myenv/lib/python3.9/site-packages/isort/stdlibs/all.py b/myenv/lib/python3.9/site-packages/isort/stdlibs/all.py
new file mode 100644
index 0000000..08a365e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/stdlibs/all.py
@@ -0,0 +1,3 @@
+from . import py2, py3
+
+stdlib = py2.stdlib | py3.stdlib
diff --git a/myenv/lib/python3.9/site-packages/isort/stdlibs/py2.py b/myenv/lib/python3.9/site-packages/isort/stdlibs/py2.py
new file mode 100644
index 0000000..74af019
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/stdlibs/py2.py
@@ -0,0 +1,3 @@
+from . import py27
+
+stdlib = py27.stdlib
diff --git a/myenv/lib/python3.9/site-packages/isort/stdlibs/py27.py b/myenv/lib/python3.9/site-packages/isort/stdlibs/py27.py
new file mode 100644
index 0000000..a9bc99d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/stdlibs/py27.py
@@ -0,0 +1,301 @@
+"""
+File contains the standard library of Python 2.7.
+
+DO NOT EDIT. If the standard library changes, a new list should be created
+using the mkstdlibs.py script.
+"""
+
+stdlib = {
+    "AL",
+    "BaseHTTPServer",
+    "Bastion",
+    "CGIHTTPServer",
+    "Carbon",
+    "ColorPicker",
+    "ConfigParser",
+    "Cookie",
+    "DEVICE",
+    "DocXMLRPCServer",
+    "EasyDialogs",
+    "FL",
+    "FrameWork",
+    "GL",
+    "HTMLParser",
+    "MacOS",
+    "MimeWriter",
+    "MiniAEFrame",
+    "Nav",
+    "PixMapWrapper",
+    "Queue",
+    "SUNAUDIODEV",
+    "ScrolledText",
+    "SimpleHTTPServer",
+    "SimpleXMLRPCServer",
+    "SocketServer",
+    "StringIO",
+    "Tix",
+    "Tkinter",
+    "UserDict",
+    "UserList",
+    "UserString",
+    "W",
+    "__builtin__",
+    "_ast",
+    "_winreg",
+    "abc",
+    "aepack",
+    "aetools",
+    "aetypes",
+    "aifc",
+    "al",
+    "anydbm",
+    "applesingle",
+    "argparse",
+    "array",
+    "ast",
+    "asynchat",
+    "asyncore",
+    "atexit",
+    "audioop",
+    "autoGIL",
+    "base64",
+    "bdb",
+    "binascii",
+    "binhex",
+    "bisect",
+    "bsddb",
+    "buildtools",
+    "bz2",
+    "cPickle",
+    "cProfile",
+    "cStringIO",
+    "calendar",
+    "cd",
+    "cfmfile",
+    "cgi",
+    "cgitb",
+    "chunk",
+    "cmath",
+    "cmd",
+    "code",
+    "codecs",
+    "codeop",
+    "collections",
+    "colorsys",
+    "commands",
+    "compileall",
+    "compiler",
+    "contextlib",
+    "cookielib",
+    "copy",
+    "copy_reg",
+    "crypt",
+    "csv",
+    "ctypes",
+    "curses",
+    "datetime",
+    "dbhash",
+    "dbm",
+    "decimal",
+    "difflib",
+    "dircache",
+    "dis",
+    "distutils",
+    "dl",
+    "doctest",
+    "dumbdbm",
+    "dummy_thread",
+    "dummy_threading",
+    "email",
+    "encodings",
+    "ensurepip",
+    "errno",
+    "exceptions",
+    "fcntl",
+    "filecmp",
+    "fileinput",
+    "findertools",
+    "fl",
+    "flp",
+    "fm",
+    "fnmatch",
+    "formatter",
+    "fpectl",
+    "fpformat",
+    "fractions",
+    "ftplib",
+    "functools",
+    "future_builtins",
+    "gc",
+    "gdbm",
+    "gensuitemodule",
+    "getopt",
+    "getpass",
+    "gettext",
+    "gl",
+    "glob",
+    "grp",
+    "gzip",
+    "hashlib",
+    "heapq",
+    "hmac",
+    "hotshot",
+    "htmlentitydefs",
+    "htmllib",
+    "httplib",
+    "ic",
+    "icopen",
+    "imageop",
+    "imaplib",
+    "imgfile",
+    "imghdr",
+    "imp",
+    "importlib",
+    "imputil",
+    "inspect",
+    "io",
+    "itertools",
+    "jpeg",
+    "json",
+    "keyword",
+    "lib2to3",
+    "linecache",
+    "locale",
+    "logging",
+    "macerrors",
+    "macostools",
+    "macpath",
+    "macresource",
+    "mailbox",
+    "mailcap",
+    "marshal",
+    "math",
+    "md5",
+    "mhlib",
+    "mimetools",
+    "mimetypes",
+    "mimify",
+    "mmap",
+    "modulefinder",
+    "msilib",
+    "msvcrt",
+    "multifile",
+    "multiprocessing",
+    "mutex",
+    "netrc",
+    "new",
+    "nis",
+    "nntplib",
+    "ntpath",
+    "numbers",
+    "operator",
+    "optparse",
+    "os",
+    "ossaudiodev",
+    "parser",
+    "pdb",
+    "pickle",
+    "pickletools",
+    "pipes",
+    "pkgutil",
+    "platform",
+    "plistlib",
+    "popen2",
+    "poplib",
+    "posix",
+    "posixfile",
+    "posixpath",
+    "pprint",
+    "profile",
+    "pstats",
+    "pty",
+    "pwd",
+    "py_compile",
+    "pyclbr",
+    "pydoc",
+    "quopri",
+    "random",
+    "re",
+    "readline",
+    "resource",
+    "rexec",
+    "rfc822",
+    "rlcompleter",
+    "robotparser",
+    "runpy",
+    "sched",
+    "select",
+    "sets",
+    "sgmllib",
+    "sha",
+    "shelve",
+    "shlex",
+    "shutil",
+    "signal",
+    "site",
+    "smtpd",
+    "smtplib",
+    "sndhdr",
+    "socket",
+    "spwd",
+    "sqlite3",
+    "sre",
+    "sre_compile",
+    "sre_constants",
+    "sre_parse",
+    "ssl",
+    "stat",
+    "statvfs",
+    "string",
+    "stringprep",
+    "struct",
+    "subprocess",
+    "sunau",
+    "sunaudiodev",
+    "symbol",
+    "symtable",
+    "sys",
+    "sysconfig",
+    "syslog",
+    "tabnanny",
+    "tarfile",
+    "telnetlib",
+    "tempfile",
+    "termios",
+    "test",
+    "textwrap",
+    "thread",
+    "threading",
+    "time",
+    "timeit",
+    "token",
+    "tokenize",
+    "trace",
+    "traceback",
+    "ttk",
+    "tty",
+    "turtle",
+    "types",
+    "unicodedata",
+    "unittest",
+    "urllib",
+    "urllib2",
+    "urlparse",
+    "user",
+    "uu",
+    "uuid",
+    "videoreader",
+    "warnings",
+    "wave",
+    "weakref",
+    "webbrowser",
+    "whichdb",
+    "winsound",
+    "wsgiref",
+    "xdrlib",
+    "xml",
+    "xmlrpclib",
+    "zipfile",
+    "zipimport",
+    "zlib",
+}
diff --git a/myenv/lib/python3.9/site-packages/isort/stdlibs/py3.py b/myenv/lib/python3.9/site-packages/isort/stdlibs/py3.py
new file mode 100644
index 0000000..4e0b5ee
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/stdlibs/py3.py
@@ -0,0 +1,3 @@
+from . import py35, py36, py37, py38, py39, py310
+
+stdlib = py35.stdlib | py36.stdlib | py37.stdlib | py38.stdlib | py39.stdlib | py310.stdlib
diff --git a/myenv/lib/python3.9/site-packages/isort/stdlibs/py310.py b/myenv/lib/python3.9/site-packages/isort/stdlibs/py310.py
new file mode 100644
index 0000000..1db2755
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/stdlibs/py310.py
@@ -0,0 +1,221 @@
+"""
+File contains the standard library of Python 3.10.
+
+DO NOT EDIT. If the standard library changes, a new list should be created
+using the mkstdlibs.py script.
+"""
+
+stdlib = {
+    "_ast",
+    "_thread",
+    "abc",
+    "aifc",
+    "argparse",
+    "array",
+    "ast",
+    "asynchat",
+    "asyncio",
+    "asyncore",
+    "atexit",
+    "audioop",
+    "base64",
+    "bdb",
+    "binascii",
+    "binhex",
+    "bisect",
+    "builtins",
+    "bz2",
+    "cProfile",
+    "calendar",
+    "cgi",
+    "cgitb",
+    "chunk",
+    "cmath",
+    "cmd",
+    "code",
+    "codecs",
+    "codeop",
+    "collections",
+    "colorsys",
+    "compileall",
+    "concurrent",
+    "configparser",
+    "contextlib",
+    "contextvars",
+    "copy",
+    "copyreg",
+    "crypt",
+    "csv",
+    "ctypes",
+    "curses",
+    "dataclasses",
+    "datetime",
+    "dbm",
+    "decimal",
+    "difflib",
+    "dis",
+    "distutils",
+    "doctest",
+    "email",
+    "encodings",
+    "ensurepip",
+    "enum",
+    "errno",
+    "faulthandler",
+    "fcntl",
+    "filecmp",
+    "fileinput",
+    "fnmatch",
+    "fractions",
+    "ftplib",
+    "functools",
+    "gc",
+    "getopt",
+    "getpass",
+    "gettext",
+    "glob",
+    "graphlib",
+    "grp",
+    "gzip",
+    "hashlib",
+    "heapq",
+    "hmac",
+    "html",
+    "http",
+    "imaplib",
+    "imghdr",
+    "imp",
+    "importlib",
+    "inspect",
+    "io",
+    "ipaddress",
+    "itertools",
+    "json",
+    "keyword",
+    "lib2to3",
+    "linecache",
+    "locale",
+    "logging",
+    "lzma",
+    "mailbox",
+    "mailcap",
+    "marshal",
+    "math",
+    "mimetypes",
+    "mmap",
+    "modulefinder",
+    "msilib",
+    "msvcrt",
+    "multiprocessing",
+    "netrc",
+    "nis",
+    "nntplib",
+    "ntpath",
+    "numbers",
+    "operator",
+    "optparse",
+    "os",
+    "ossaudiodev",
+    "pathlib",
+    "pdb",
+    "pickle",
+    "pickletools",
+    "pipes",
+    "pkgutil",
+    "platform",
+    "plistlib",
+    "poplib",
+    "posix",
+    "posixpath",
+    "pprint",
+    "profile",
+    "pstats",
+    "pty",
+    "pwd",
+    "py_compile",
+    "pyclbr",
+    "pydoc",
+    "queue",
+    "quopri",
+    "random",
+    "re",
+    "readline",
+    "reprlib",
+    "resource",
+    "rlcompleter",
+    "runpy",
+    "sched",
+    "secrets",
+    "select",
+    "selectors",
+    "shelve",
+    "shlex",
+    "shutil",
+    "signal",
+    "site",
+    "smtpd",
+    "smtplib",
+    "sndhdr",
+    "socket",
+    "socketserver",
+    "spwd",
+    "sqlite3",
+    "sre",
+    "sre_compile",
+    "sre_constants",
+    "sre_parse",
+    "ssl",
+    "stat",
+    "statistics",
+    "string",
+    "stringprep",
+    "struct",
+    "subprocess",
+    "sunau",
+    "symtable",
+    "sys",
+    "sysconfig",
+    "syslog",
+    "tabnanny",
+    "tarfile",
+    "telnetlib",
+    "tempfile",
+    "termios",
+    "test",
+    "textwrap",
+    "threading",
+    "time",
+    "timeit",
+    "tkinter",
+    "token",
+    "tokenize",
+    "trace",
+    "traceback",
+    "tracemalloc",
+    "tty",
+    "turtle",
+    "turtledemo",
+    "types",
+    "typing",
+    "unicodedata",
+    "unittest",
+    "urllib",
+    "uu",
+    "uuid",
+    "venv",
+    "warnings",
+    "wave",
+    "weakref",
+    "webbrowser",
+    "winreg",
+    "winsound",
+    "wsgiref",
+    "xdrlib",
+    "xml",
+    "xmlrpc",
+    "zipapp",
+    "zipfile",
+    "zipimport",
+    "zlib",
+    "zoneinfo",
+}
diff --git a/myenv/lib/python3.9/site-packages/isort/stdlibs/py35.py b/myenv/lib/python3.9/site-packages/isort/stdlibs/py35.py
new file mode 100644
index 0000000..29ab9ae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/stdlibs/py35.py
@@ -0,0 +1,223 @@
+"""
+File contains the standard library of Python 3.5.
+
+DO NOT EDIT. If the standard library changes, a new list should be created
+using the mkstdlibs.py script.
+"""
+
+stdlib = {
+    "_ast",
+    "_dummy_thread",
+    "_thread",
+    "abc",
+    "aifc",
+    "argparse",
+    "array",
+    "ast",
+    "asynchat",
+    "asyncio",
+    "asyncore",
+    "atexit",
+    "audioop",
+    "base64",
+    "bdb",
+    "binascii",
+    "binhex",
+    "bisect",
+    "builtins",
+    "bz2",
+    "cProfile",
+    "calendar",
+    "cgi",
+    "cgitb",
+    "chunk",
+    "cmath",
+    "cmd",
+    "code",
+    "codecs",
+    "codeop",
+    "collections",
+    "colorsys",
+    "compileall",
+    "concurrent",
+    "configparser",
+    "contextlib",
+    "copy",
+    "copyreg",
+    "crypt",
+    "csv",
+    "ctypes",
+    "curses",
+    "datetime",
+    "dbm",
+    "decimal",
+    "difflib",
+    "dis",
+    "distutils",
+    "doctest",
+    "dummy_threading",
+    "email",
+    "encodings",
+    "ensurepip",
+    "enum",
+    "errno",
+    "faulthandler",
+    "fcntl",
+    "filecmp",
+    "fileinput",
+    "fnmatch",
+    "formatter",
+    "fpectl",
+    "fractions",
+    "ftplib",
+    "functools",
+    "gc",
+    "getopt",
+    "getpass",
+    "gettext",
+    "glob",
+    "grp",
+    "gzip",
+    "hashlib",
+    "heapq",
+    "hmac",
+    "html",
+    "http",
+    "imaplib",
+    "imghdr",
+    "imp",
+    "importlib",
+    "inspect",
+    "io",
+    "ipaddress",
+    "itertools",
+    "json",
+    "keyword",
+    "lib2to3",
+    "linecache",
+    "locale",
+    "logging",
+    "lzma",
+    "macpath",
+    "mailbox",
+    "mailcap",
+    "marshal",
+    "math",
+    "mimetypes",
+    "mmap",
+    "modulefinder",
+    "msilib",
+    "msvcrt",
+    "multiprocessing",
+    "netrc",
+    "nis",
+    "nntplib",
+    "ntpath",
+    "numbers",
+    "operator",
+    "optparse",
+    "os",
+    "ossaudiodev",
+    "parser",
+    "pathlib",
+    "pdb",
+    "pickle",
+    "pickletools",
+    "pipes",
+    "pkgutil",
+    "platform",
+    "plistlib",
+    "poplib",
+    "posix",
+    "posixpath",
+    "pprint",
+    "profile",
+    "pstats",
+    "pty",
+    "pwd",
+    "py_compile",
+    "pyclbr",
+    "pydoc",
+    "queue",
+    "quopri",
+    "random",
+    "re",
+    "readline",
+    "reprlib",
+    "resource",
+    "rlcompleter",
+    "runpy",
+    "sched",
+    "select",
+    "selectors",
+    "shelve",
+    "shlex",
+    "shutil",
+    "signal",
+    "site",
+    "smtpd",
+    "smtplib",
+    "sndhdr",
+    "socket",
+    "socketserver",
+    "spwd",
+    "sqlite3",
+    "sre",
+    "sre_compile",
+    "sre_constants",
+    "sre_parse",
+    "ssl",
+    "stat",
+    "statistics",
+    "string",
+    "stringprep",
+    "struct",
+    "subprocess",
+    "sunau",
+    "symbol",
+    "symtable",
+    "sys",
+    "sysconfig",
+    "syslog",
+    "tabnanny",
+    "tarfile",
+    "telnetlib",
+    "tempfile",
+    "termios",
+    "test",
+    "textwrap",
+    "threading",
+    "time",
+    "timeit",
+    "tkinter",
+    "token",
+    "tokenize",
+    "trace",
+    "traceback",
+    "tracemalloc",
+    "tty",
+    "turtle",
+    "turtledemo",
+    "types",
+    "typing",
+    "unicodedata",
+    "unittest",
+    "urllib",
+    "uu",
+    "uuid",
+    "venv",
+    "warnings",
+    "wave",
+    "weakref",
+    "webbrowser",
+    "winreg",
+    "winsound",
+    "wsgiref",
+    "xdrlib",
+    "xml",
+    "xmlrpc",
+    "zipapp",
+    "zipfile",
+    "zipimport",
+    "zlib",
+}
diff --git a/myenv/lib/python3.9/site-packages/isort/stdlibs/py36.py b/myenv/lib/python3.9/site-packages/isort/stdlibs/py36.py
new file mode 100644
index 0000000..59ebd24
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/stdlibs/py36.py
@@ -0,0 +1,224 @@
+"""
+File contains the standard library of Python 3.6.
+
+DO NOT EDIT. If the standard library changes, a new list should be created
+using the mkstdlibs.py script.
+"""
+
+stdlib = {
+    "_ast",
+    "_dummy_thread",
+    "_thread",
+    "abc",
+    "aifc",
+    "argparse",
+    "array",
+    "ast",
+    "asynchat",
+    "asyncio",
+    "asyncore",
+    "atexit",
+    "audioop",
+    "base64",
+    "bdb",
+    "binascii",
+    "binhex",
+    "bisect",
+    "builtins",
+    "bz2",
+    "cProfile",
+    "calendar",
+    "cgi",
+    "cgitb",
+    "chunk",
+    "cmath",
+    "cmd",
+    "code",
+    "codecs",
+    "codeop",
+    "collections",
+    "colorsys",
+    "compileall",
+    "concurrent",
+    "configparser",
+    "contextlib",
+    "copy",
+    "copyreg",
+    "crypt",
+    "csv",
+    "ctypes",
+    "curses",
+    "datetime",
+    "dbm",
+    "decimal",
+    "difflib",
+    "dis",
+    "distutils",
+    "doctest",
+    "dummy_threading",
+    "email",
+    "encodings",
+    "ensurepip",
+    "enum",
+    "errno",
+    "faulthandler",
+    "fcntl",
+    "filecmp",
+    "fileinput",
+    "fnmatch",
+    "formatter",
+    "fpectl",
+    "fractions",
+    "ftplib",
+    "functools",
+    "gc",
+    "getopt",
+    "getpass",
+    "gettext",
+    "glob",
+    "grp",
+    "gzip",
+    "hashlib",
+    "heapq",
+    "hmac",
+    "html",
+    "http",
+    "imaplib",
+    "imghdr",
+    "imp",
+    "importlib",
+    "inspect",
+    "io",
+    "ipaddress",
+    "itertools",
+    "json",
+    "keyword",
+    "lib2to3",
+    "linecache",
+    "locale",
+    "logging",
+    "lzma",
+    "macpath",
+    "mailbox",
+    "mailcap",
+    "marshal",
+    "math",
+    "mimetypes",
+    "mmap",
+    "modulefinder",
+    "msilib",
+    "msvcrt",
+    "multiprocessing",
+    "netrc",
+    "nis",
+    "nntplib",
+    "ntpath",
+    "numbers",
+    "operator",
+    "optparse",
+    "os",
+    "ossaudiodev",
+    "parser",
+    "pathlib",
+    "pdb",
+    "pickle",
+    "pickletools",
+    "pipes",
+    "pkgutil",
+    "platform",
+    "plistlib",
+    "poplib",
+    "posix",
+    "posixpath",
+    "pprint",
+    "profile",
+    "pstats",
+    "pty",
+    "pwd",
+    "py_compile",
+    "pyclbr",
+    "pydoc",
+    "queue",
+    "quopri",
+    "random",
+    "re",
+    "readline",
+    "reprlib",
+    "resource",
+    "rlcompleter",
+    "runpy",
+    "sched",
+    "secrets",
+    "select",
+    "selectors",
+    "shelve",
+    "shlex",
+    "shutil",
+    "signal",
+    "site",
+    "smtpd",
+    "smtplib",
+    "sndhdr",
+    "socket",
+    "socketserver",
+    "spwd",
+    "sqlite3",
+    "sre",
+    "sre_compile",
+    "sre_constants",
+    "sre_parse",
+    "ssl",
+    "stat",
+    "statistics",
+    "string",
+    "stringprep",
+    "struct",
+    "subprocess",
+    "sunau",
+    "symbol",
+    "symtable",
+    "sys",
+    "sysconfig",
+    "syslog",
+    "tabnanny",
+    "tarfile",
+    "telnetlib",
+    "tempfile",
+    "termios",
+    "test",
+    "textwrap",
+    "threading",
+    "time",
+    "timeit",
+    "tkinter",
+    "token",
+    "tokenize",
+    "trace",
+    "traceback",
+    "tracemalloc",
+    "tty",
+    "turtle",
+    "turtledemo",
+    "types",
+    "typing",
+    "unicodedata",
+    "unittest",
+    "urllib",
+    "uu",
+    "uuid",
+    "venv",
+    "warnings",
+    "wave",
+    "weakref",
+    "webbrowser",
+    "winreg",
+    "winsound",
+    "wsgiref",
+    "xdrlib",
+    "xml",
+    "xmlrpc",
+    "zipapp",
+    "zipfile",
+    "zipimport",
+    "zlib",
+}
diff --git a/myenv/lib/python3.9/site-packages/isort/stdlibs/py37.py b/myenv/lib/python3.9/site-packages/isort/stdlibs/py37.py
new file mode 100644
index 0000000..e0ad122
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/stdlibs/py37.py
@@ -0,0 +1,225 @@
+"""
+File contains the standard library of Python 3.7.
+
+DO NOT EDIT. If the standard library changes, a new list should be created
+using the mkstdlibs.py script.
+"""
+
+stdlib = {
+    "_ast",
+    "_dummy_thread",
+    "_thread",
+    "abc",
+    "aifc",
+    "argparse",
+    "array",
+    "ast",
+    "asynchat",
+    "asyncio",
+    "asyncore",
+    "atexit",
+    "audioop",
+    "base64",
+    "bdb",
+    "binascii",
+    "binhex",
+    "bisect",
+    "builtins",
+    "bz2",
+    "cProfile",
+    "calendar",
+    "cgi",
+    "cgitb",
+    "chunk",
+    "cmath",
+    "cmd",
+    "code",
+    "codecs",
+    "codeop",
+    "collections",
+    "colorsys",
+    "compileall",
+    "concurrent",
+    "configparser",
+    "contextlib",
+    "contextvars",
+    "copy",
+    "copyreg",
+    "crypt",
+    "csv",
+    "ctypes",
+    "curses",
+    "dataclasses",
+    "datetime",
+    "dbm",
+    "decimal",
+    "difflib",
+    "dis",
+    "distutils",
+    "doctest",
+    "dummy_threading",
+    "email",
+    "encodings",
+    "ensurepip",
+    "enum",
+    "errno",
+    "faulthandler",
+    "fcntl",
+    "filecmp",
+    "fileinput",
+    "fnmatch",
+    "formatter",
+    "fractions",
+    "ftplib",
+    "functools",
+    "gc",
+    "getopt",
+    "getpass",
+    "gettext",
+    "glob",
+    "grp",
+    "gzip",
+    "hashlib",
+    "heapq",
+    "hmac",
+    "html",
+    "http",
+    "imaplib",
+    "imghdr",
+    "imp",
+    "importlib",
+    "inspect",
+    "io",
+    "ipaddress",
+    "itertools",
+    "json",
+    "keyword",
+    "lib2to3",
+    "linecache",
+    "locale",
+    "logging",
+    "lzma",
+    "macpath",
+    "mailbox",
+    "mailcap",
+    "marshal",
+    "math",
+    "mimetypes",
+    "mmap",
+    "modulefinder",
+    "msilib",
+    "msvcrt",
+    "multiprocessing",
+    "netrc",
+    "nis",
+    "nntplib",
+    "ntpath",
+    "numbers",
+    "operator",
+    "optparse",
+    "os",
+    "ossaudiodev",
+    "parser",
+    "pathlib",
+    "pdb",
+    "pickle",
+    "pickletools",
+    "pipes",
+    "pkgutil",
+    "platform",
+    "plistlib",
+    "poplib",
+    "posix",
+    "posixpath",
+    "pprint",
+    "profile",
+    "pstats",
+    "pty",
+    "pwd",
+    "py_compile",
+    "pyclbr",
+    "pydoc",
+    "queue",
+    "quopri",
+    "random",
+    "re",
+    "readline",
+    "reprlib",
+    "resource",
+    "rlcompleter",
+    "runpy",
+    "sched",
+    "secrets",
+    "select",
+    "selectors",
+    "shelve",
+    "shlex",
+    "shutil",
+    "signal",
+    "site",
+    "smtpd",
+    "smtplib",
+    "sndhdr",
+    "socket",
+    "socketserver",
+    "spwd",
+    "sqlite3",
+    "sre",
+    "sre_compile",
+    "sre_constants",
+    "sre_parse",
+    "ssl",
+    "stat",
+    "statistics",
+    "string",
+    "stringprep",
+    "struct",
+    "subprocess",
+    "sunau",
+    "symbol",
+    "symtable",
+    "sys",
+    "sysconfig",
+    "syslog",
+    "tabnanny",
+    "tarfile",
+    "telnetlib",
+    "tempfile",
+    "termios",
+    "test",
+    "textwrap",
+    "threading",
+    "time",
+    "timeit",
+    "tkinter",
+    "token",
+    "tokenize",
+    "trace",
+    "traceback",
+    "tracemalloc",
+    "tty",
+    "turtle",
+    "turtledemo",
+    "types",
+    "typing",
+    "unicodedata",
+    "unittest",
+    "urllib",
+    "uu",
+    "uuid",
+    "venv",
+    "warnings",
+    "wave",
+    "weakref",
+    "webbrowser",
+    "winreg",
+    "winsound",
+    "wsgiref",
+    "xdrlib",
+    "xml",
+    "xmlrpc",
+    "zipapp",
+    "zipfile",
+    "zipimport",
+    "zlib",
+}
diff --git a/myenv/lib/python3.9/site-packages/isort/stdlibs/py38.py b/myenv/lib/python3.9/site-packages/isort/stdlibs/py38.py
new file mode 100644
index 0000000..3d89fd2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/stdlibs/py38.py
@@ -0,0 +1,224 @@
+"""
+File contains the standard library of Python 3.8.
+
+DO NOT EDIT. If the standard library changes, a new list should be created
+using the mkstdlibs.py script.
+"""
+
+stdlib = {
+    "_ast",
+    "_dummy_thread",
+    "_thread",
+    "abc",
+    "aifc",
+    "argparse",
+    "array",
+    "ast",
+    "asynchat",
+    "asyncio",
+    "asyncore",
+    "atexit",
+    "audioop",
+    "base64",
+    "bdb",
+    "binascii",
+    "binhex",
+    "bisect",
+    "builtins",
+    "bz2",
+    "cProfile",
+    "calendar",
+    "cgi",
+    "cgitb",
+    "chunk",
+    "cmath",
+    "cmd",
+    "code",
+    "codecs",
+    "codeop",
+    "collections",
+    "colorsys",
+    "compileall",
+    "concurrent",
+    "configparser",
+    "contextlib",
+    "contextvars",
+    "copy",
+    "copyreg",
+    "crypt",
+    "csv",
+    "ctypes",
+    "curses",
+    "dataclasses",
+    "datetime",
+    "dbm",
+    "decimal",
+    "difflib",
+    "dis",
+    "distutils",
+    "doctest",
+    "dummy_threading",
+    "email",
+    "encodings",
+    "ensurepip",
+    "enum",
+    "errno",
+    "faulthandler",
+    "fcntl",
+    "filecmp",
+    "fileinput",
+    "fnmatch",
+    "formatter",
+    "fractions",
+    "ftplib",
+    "functools",
+    "gc",
+    "getopt",
+    "getpass",
+    "gettext",
+    "glob",
+    "grp",
+    "gzip",
+    "hashlib",
+    "heapq",
+    "hmac",
+    "html",
+    "http",
+    "imaplib",
+    "imghdr",
+    "imp",
+    "importlib",
+    "inspect",
+    "io",
+    "ipaddress",
+    "itertools",
+    "json",
+    "keyword",
+    "lib2to3",
+    "linecache",
+    "locale",
+    "logging",
+    "lzma",
+    "mailbox",
+    "mailcap",
+    "marshal",
+    "math",
+    "mimetypes",
+    "mmap",
+    "modulefinder",
+    "msilib",
+    "msvcrt",
+    "multiprocessing",
+    "netrc",
+    "nis",
+    "nntplib",
+    "ntpath",
+    "numbers",
+    "operator",
+    "optparse",
+    "os",
+    "ossaudiodev",
+    "parser",
+    "pathlib",
+    "pdb",
+    "pickle",
+    "pickletools",
+    "pipes",
+    "pkgutil",
+    "platform",
+    "plistlib",
+    "poplib",
+    "posix",
+    "posixpath",
+    "pprint",
+    "profile",
+    "pstats",
+    "pty",
+    "pwd",
+    "py_compile",
+    "pyclbr",
+    "pydoc",
+    "queue",
+    "quopri",
+    "random",
+    "re",
+    "readline",
+    "reprlib",
+    "resource",
+    "rlcompleter",
+    "runpy",
+    "sched",
+    "secrets",
+    "select",
+    "selectors",
+    "shelve",
+    "shlex",
+    "shutil",
+    "signal",
+    "site",
+    "smtpd",
+    "smtplib",
+    "sndhdr",
+    "socket",
+    "socketserver",
+    "spwd",
+    "sqlite3",
+    "sre",
+    "sre_compile",
+    "sre_constants",
+    "sre_parse",
+    "ssl",
+    "stat",
+    "statistics",
+    "string",
+    "stringprep",
+    "struct",
+    "subprocess",
+    "sunau",
+    "symbol",
+    "symtable",
+    "sys",
+    "sysconfig",
+    "syslog",
+    "tabnanny",
+    "tarfile",
+    "telnetlib",
+    "tempfile",
+    "termios",
+    "test",
+    "textwrap",
+    "threading",
+    "time",
+    "timeit",
+    "tkinter",
+    "token",
+    "tokenize",
+    "trace",
+    "traceback",
+    "tracemalloc",
+    "tty",
+    "turtle",
+    "turtledemo",
+    "types",
+    "typing",
+    "unicodedata",
+    "unittest",
+    "urllib",
+    "uu",
+    "uuid",
+    "venv",
+    "warnings",
+    "wave",
+    "weakref",
+    "webbrowser",
+    "winreg",
+    "winsound",
+    "wsgiref",
+    "xdrlib",
+    "xml",
+    "xmlrpc",
+    "zipapp",
+    "zipfile",
+    "zipimport",
+    "zlib",
+}
diff --git a/myenv/lib/python3.9/site-packages/isort/stdlibs/py39.py b/myenv/lib/python3.9/site-packages/isort/stdlibs/py39.py
new file mode 100644
index 0000000..4b7dd59
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/stdlibs/py39.py
@@ -0,0 +1,224 @@
+"""
+File contains the standard library of Python 3.9.
+
+DO NOT EDIT. If the standard library changes, a new list should be created
+using the mkstdlibs.py script.
+"""
+
+stdlib = {
+    "_ast",
+    "_thread",
+    "abc",
+    "aifc",
+    "argparse",
+    "array",
+    "ast",
+    "asynchat",
+    "asyncio",
+    "asyncore",
+    "atexit",
+    "audioop",
+    "base64",
+    "bdb",
+    "binascii",
+    "binhex",
+    "bisect",
+    "builtins",
+    "bz2",
+    "cProfile",
+    "calendar",
+    "cgi",
+    "cgitb",
+    "chunk",
+    "cmath",
+    "cmd",
+    "code",
+    "codecs",
+    "codeop",
+    "collections",
+    "colorsys",
+    "compileall",
+    "concurrent",
+    "configparser",
+    "contextlib",
+    "contextvars",
+    "copy",
+    "copyreg",
+    "crypt",
+    "csv",
+    "ctypes",
+    "curses",
+    "dataclasses",
+    "datetime",
+    "dbm",
+    "decimal",
+    "difflib",
+    "dis",
+    "distutils",
+    "doctest",
+    "email",
+    "encodings",
+    "ensurepip",
+    "enum",
+    "errno",
+    "faulthandler",
+    "fcntl",
+    "filecmp",
+    "fileinput",
+    "fnmatch",
+    "formatter",
+    "fractions",
+    "ftplib",
+    "functools",
+    "gc",
+    "getopt",
+    "getpass",
+    "gettext",
+    "glob",
+    "graphlib",
+    "grp",
+    "gzip",
+    "hashlib",
+    "heapq",
+    "hmac",
+    "html",
+    "http",
+    "imaplib",
+    "imghdr",
+    "imp",
+    "importlib",
+    "inspect",
+    "io",
+    "ipaddress",
+    "itertools",
+    "json",
+    "keyword",
+    "lib2to3",
+    "linecache",
+    "locale",
+    "logging",
+    "lzma",
+    "mailbox",
+    "mailcap",
+    "marshal",
+    "math",
+    "mimetypes",
+    "mmap",
+    "modulefinder",
+    "msilib",
+    "msvcrt",
+    "multiprocessing",
+    "netrc",
+    "nis",
+    "nntplib",
+    "ntpath",
+    "numbers",
+    "operator",
+    "optparse",
+    "os",
+    "ossaudiodev",
+    "parser",
+    "pathlib",
+    "pdb",
+    "pickle",
+    "pickletools",
+    "pipes",
+    "pkgutil",
+    "platform",
+    "plistlib",
+    "poplib",
+    "posix",
+    "posixpath",
+    "pprint",
+    "profile",
+    "pstats",
+    "pty",
+    "pwd",
+    "py_compile",
+    "pyclbr",
+    "pydoc",
+    "queue",
+    "quopri",
+    "random",
+    "re",
+    "readline",
+    "reprlib",
+    "resource",
+    "rlcompleter",
+    "runpy",
+    "sched",
+    "secrets",
+    "select",
+    "selectors",
+    "shelve",
+    "shlex",
+    "shutil",
+    "signal",
+    "site",
+    "smtpd",
+    "smtplib",
+    "sndhdr",
+    "socket",
+    "socketserver",
+    "spwd",
+    "sqlite3",
+    "sre",
+    "sre_compile",
+    "sre_constants",
+    "sre_parse",
+    "ssl",
+    "stat",
+    "statistics",
+    "string",
+    "stringprep",
+    "struct",
+    "subprocess",
+    "sunau",
+    "symbol",
+    "symtable",
+    "sys",
+    "sysconfig",
+    "syslog",
+    "tabnanny",
+    "tarfile",
+    "telnetlib",
+    "tempfile",
+    "termios",
+    "test",
+    "textwrap",
+    "threading",
+    "time",
+    "timeit",
+    "tkinter",
+    "token",
+    "tokenize",
+    "trace",
+    "traceback",
+    "tracemalloc",
+    "tty",
+    "turtle",
+    "turtledemo",
+    "types",
+    "typing",
+    "unicodedata",
+    "unittest",
+    "urllib",
+    "uu",
+    "uuid",
+    "venv",
+    "warnings",
+    "wave",
+    "weakref",
+    "webbrowser",
+    "winreg",
+    "winsound",
+    "wsgiref",
+    "xdrlib",
+    "xml",
+    "xmlrpc",
+    "zipapp",
+    "zipfile",
+    "zipimport",
+    "zlib",
+    "zoneinfo",
+}
diff --git a/myenv/lib/python3.9/site-packages/isort/utils.py b/myenv/lib/python3.9/site-packages/isort/utils.py
new file mode 100644
index 0000000..339c86f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/utils.py
@@ -0,0 +1,72 @@
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+
+
+class TrieNode:
+    def __init__(self, config_file: str = "", config_data: Optional[Dict[str, Any]] = None) -> None:
+        if not config_data:
+            config_data = {}
+
+        self.nodes: Dict[str, TrieNode] = {}
+        self.config_info: Tuple[str, Dict[str, Any]] = (config_file, config_data)
+
+
+class Trie:
+    """
+    A prefix tree to store the paths of all config files and to search the nearest config
+    associated with each file
+    """
+
+    def __init__(self, config_file: str = "", config_data: Optional[Dict[str, Any]] = None) -> None:
+        self.root: TrieNode = TrieNode(config_file, config_data)
+
+    def insert(self, config_file: str, config_data: Dict[str, Any]) -> None:
+        resolved_config_path_as_tuple = Path(config_file).parent.resolve().parts
+
+        temp = self.root
+
+        for path in resolved_config_path_as_tuple:
+            if path not in temp.nodes:
+                temp.nodes[path] = TrieNode()
+
+            temp = temp.nodes[path]
+
+        temp.config_info = (config_file, config_data)
+
+    def search(self, filename: str) -> Tuple[str, Dict[str, Any]]:
+        """
+        Returns the closest config relative to filename by doing a depth
+        first search on the prefix tree.
+        """
+        resolved_file_path_as_tuple = Path(filename).resolve().parts
+
+        temp = self.root
+
+        last_stored_config: Tuple[str, Dict[str, Any]] = ("", {})
+
+        for path in resolved_file_path_as_tuple:
+            if temp.config_info[0]:
+                last_stored_config = temp.config_info
+
+            if path not in temp.nodes:
+                break
+
+            temp = temp.nodes[path]
+
+        return last_stored_config
+
+
+def exists_case_sensitive(path: str) -> bool:
+    """Returns if the given path exists and also matches the case on Windows.
+
+    When finding files that can be imported, it is important for the cases to match because while
+    file os.path.exists("module.py") and os.path.exists("MODULE.py") both return True on Windows,
+    Python can only import using the case of the real file.
+    """
+    result = os.path.exists(path)
+    if (sys.platform.startswith("win") or sys.platform == "darwin") and result:  # pragma: no cover
+        directory, basename = os.path.split(path)
+        result = basename in os.listdir(directory)
+    return result
diff --git a/myenv/lib/python3.9/site-packages/isort/wrap.py b/myenv/lib/python3.9/site-packages/isort/wrap.py
new file mode 100644
index 0000000..5fb4631
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/wrap.py
@@ -0,0 +1,139 @@
+import copy
+import re
+from typing import List, Optional, Sequence
+
+from .settings import DEFAULT_CONFIG, Config
+from .wrap_modes import WrapModes as Modes
+from .wrap_modes import formatter_from_string
+
+
+def import_statement(
+    import_start: str,
+    from_imports: List[str],
+    comments: Sequence[str] = (),
+    line_separator: str = "\n",
+    config: Config = DEFAULT_CONFIG,
+    multi_line_output: Optional[Modes] = None,
+) -> str:
+    """Returns a multi-line wrapped form of the provided from import statement."""
+    formatter = formatter_from_string((multi_line_output or config.multi_line_output).name)
+    dynamic_indent = " " * (len(import_start) + 1)
+    indent = config.indent
+    line_length = config.wrap_length or config.line_length
+    statement = formatter(
+        statement=import_start,
+        imports=copy.copy(from_imports),
+        white_space=dynamic_indent,
+        indent=indent,
+        line_length=line_length,
+        comments=comments,
+        line_separator=line_separator,
+        comment_prefix=config.comment_prefix,
+        include_trailing_comma=config.include_trailing_comma,
+        remove_comments=config.ignore_comments,
+    )
+    if config.balanced_wrapping:
+        lines = statement.split(line_separator)
+        line_count = len(lines)
+        if len(lines) > 1:
+            minimum_length = min(len(line) for line in lines[:-1])
+        else:
+            minimum_length = 0
+        new_import_statement = statement
+        while len(lines[-1]) < minimum_length and len(lines) == line_count and line_length > 10:
+            statement = new_import_statement
+            line_length -= 1
+            new_import_statement = formatter(
+                statement=import_start,
+                imports=copy.copy(from_imports),
+                white_space=dynamic_indent,
+                indent=indent,
+                line_length=line_length,
+                comments=comments,
+                line_separator=line_separator,
+                comment_prefix=config.comment_prefix,
+                include_trailing_comma=config.include_trailing_comma,
+                remove_comments=config.ignore_comments,
+            )
+            lines = new_import_statement.split(line_separator)
+    if statement.count(line_separator) == 0:
+        return _wrap_line(statement, line_separator, config)
+    return statement
+
+
+def line(content: str, line_separator: str, config: Config = DEFAULT_CONFIG) -> str:
+    """Returns a line wrapped to the specified line-length, if possible."""
+    wrap_mode = config.multi_line_output
+    if len(content) > config.line_length and wrap_mode != Modes.NOQA:  # type: ignore
+        line_without_comment = content
+        comment = None
+        if "#" in content:
+            line_without_comment, comment = content.split("#", 1)
+        for splitter in ("import ", ".", "as "):
+            exp = r"\b" + re.escape(splitter) + r"\b"
+            if re.search(exp, line_without_comment) and not line_without_comment.strip().startswith(
+                splitter
+            ):
+                line_parts = re.split(exp, line_without_comment)
+                if comment and not (config.use_parentheses and "noqa" in comment):
+                    _comma_maybe = (
+                        ","
+                        if (
+                            config.include_trailing_comma
+                            and config.use_parentheses
+                            and not line_without_comment.rstrip().endswith(",")
+                        )
+                        else ""
+                    )
+                    line_parts[
+                        -1
+                    ] = f"{line_parts[-1].strip()}{_comma_maybe}{config.comment_prefix}{comment}"
+                next_line = []
+                while (len(content) + 2) > (
+                    config.wrap_length or config.line_length
+                ) and line_parts:
+                    next_line.append(line_parts.pop())
+                    content = splitter.join(line_parts)
+                if not content:
+                    content = next_line.pop()
+
+                cont_line = _wrap_line(
+                    config.indent + splitter.join(next_line).lstrip(),
+                    line_separator,
+                    config,
+                )
+                if config.use_parentheses:
+                    if splitter == "as ":
+                        output = f"{content}{splitter}{cont_line.lstrip()}"
+                    else:
+                        _comma = "," if config.include_trailing_comma and not comment else ""
+
+                        if wrap_mode in (
+                            Modes.VERTICAL_HANGING_INDENT,  # type: ignore
+                            Modes.VERTICAL_GRID_GROUPED,  # type: ignore
+                        ):
+                            _separator = line_separator
+                        else:
+                            _separator = ""
+                        _comment = ""
+                        if comment and "noqa" in comment:
+                            _comment = f"{config.comment_prefix}{comment}"
+                            cont_line = cont_line.rstrip()
+                            _comma = "," if config.include_trailing_comma else ""
+                        output = (
+                            f"{content}{splitter}({_comment}"
+                            f"{line_separator}{cont_line}{_comma}{_separator})"
+                        )
+                    lines = output.split(line_separator)
+                    if config.comment_prefix in lines[-1] and lines[-1].endswith(")"):
+                        content, comment = lines[-1].split(config.comment_prefix, 1)
+                        lines[-1] = content + ")" + config.comment_prefix + comment[:-1]
+                    return line_separator.join(lines)
+                return f"{content}{splitter}\\{line_separator}{cont_line}"
+    elif len(content) > config.line_length and wrap_mode == Modes.NOQA and "# NOQA" not in content:  # type: ignore
+        return f"{content}{config.comment_prefix} NOQA"
+
+    return content
+
+
+_wrap_line = line
diff --git a/myenv/lib/python3.9/site-packages/isort/wrap_modes.py b/myenv/lib/python3.9/site-packages/isort/wrap_modes.py
new file mode 100644
index 0000000..6ea2801
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/isort/wrap_modes.py
@@ -0,0 +1,376 @@
+"""Defines all wrap modes that can be used when outputting formatted imports"""
+import enum
+from inspect import signature
+from typing import Any, Callable, Dict, List
+
+import isort.comments
+
+_wrap_modes: Dict[str, Callable[..., str]] = {}
+
+
+def from_string(value: str) -> "WrapModes":
+    return getattr(WrapModes, str(value), None) or WrapModes(int(value))
+
+
+def formatter_from_string(name: str) -> Callable[..., str]:
+    return _wrap_modes.get(name.upper(), grid)
+
+
+def _wrap_mode_interface(
+    statement: str,
+    imports: List[str],
+    white_space: str,
+    indent: str,
+    line_length: int,
+    comments: List[str],
+    line_separator: str,
+    comment_prefix: str,
+    include_trailing_comma: bool,
+    remove_comments: bool,
+) -> str:
+    """Defines the common interface used by all wrap mode functions"""
+    return ""
+
+
+def _wrap_mode(function: Callable[..., str]) -> Callable[..., str]:
+    """Registers an individual wrap mode. Function name and order are significant and used for
+    creating enum.
+    """
+    _wrap_modes[function.__name__.upper()] = function
+    function.__signature__ = signature(_wrap_mode_interface)  # type: ignore
+    function.__annotations__ = _wrap_mode_interface.__annotations__
+    return function
+
+
+@_wrap_mode
+def grid(**interface: Any) -> str:
+    if not interface["imports"]:
+        return ""
+
+    interface["statement"] += "(" + interface["imports"].pop(0)
+    while interface["imports"]:
+        next_import = interface["imports"].pop(0)
+        next_statement = isort.comments.add_to_line(
+            interface["comments"],
+            interface["statement"] + ", " + next_import,
+            removed=interface["remove_comments"],
+            comment_prefix=interface["comment_prefix"],
+        )
+        if (
+            len(next_statement.split(interface["line_separator"])[-1]) + 1
+            > interface["line_length"]
+        ):
+            lines = [f"{interface['white_space']}{next_import.split(' ')[0]}"]
+            for part in next_import.split(" ")[1:]:
+                new_line = f"{lines[-1]} {part}"
+                if len(new_line) + 1 > interface["line_length"]:
+                    lines.append(f"{interface['white_space']}{part}")
+                else:
+                    lines[-1] = new_line
+            next_import = interface["line_separator"].join(lines)
+            interface["statement"] = (
+                isort.comments.add_to_line(
+                    interface["comments"],
+                    f"{interface['statement']},",
+                    removed=interface["remove_comments"],
+                    comment_prefix=interface["comment_prefix"],
+                )
+                + f"{interface['line_separator']}{next_import}"
+            )
+            interface["comments"] = []
+        else:
+            interface["statement"] += ", " + next_import
+    return f"{interface['statement']}{',' if interface['include_trailing_comma'] else ''})"
+
+
+@_wrap_mode
+def vertical(**interface: Any) -> str:
+    if not interface["imports"]:
+        return ""
+
+    first_import = (
+        isort.comments.add_to_line(
+            interface["comments"],
+            interface["imports"].pop(0) + ",",
+            removed=interface["remove_comments"],
+            comment_prefix=interface["comment_prefix"],
+        )
+        + interface["line_separator"]
+        + interface["white_space"]
+    )
+
+    _imports = ("," + interface["line_separator"] + interface["white_space"]).join(
+        interface["imports"]
+    )
+    _comma_maybe = "," if interface["include_trailing_comma"] else ""
+    return f"{interface['statement']}({first_import}{_imports}{_comma_maybe})"
+
+
+def _hanging_indent_end_line(line: str) -> str:
+    if not line.endswith(" "):
+        line += " "
+    return line + "\\"
+
+
+@_wrap_mode
+def hanging_indent(**interface: Any) -> str:
+    if not interface["imports"]:
+        return ""
+
+    line_length_limit = interface["line_length"] - 3
+
+    next_import = interface["imports"].pop(0)
+    next_statement = interface["statement"] + next_import
+    # Check for first import
+    if len(next_statement) > line_length_limit:
+        next_statement = (
+            _hanging_indent_end_line(interface["statement"])
+            + interface["line_separator"]
+            + interface["indent"]
+            + next_import
+        )
+
+    interface["statement"] = next_statement
+    while interface["imports"]:
+        next_import = interface["imports"].pop(0)
+        next_statement = interface["statement"] + ", " + next_import
+        if len(next_statement.split(interface["line_separator"])[-1]) > line_length_limit:
+            next_statement = (
+                _hanging_indent_end_line(interface["statement"] + ",")
+                + f"{interface['line_separator']}{interface['indent']}{next_import}"
+            )
+        interface["statement"] = next_statement
+
+    interface[
+        "statement"
+    ] = f"{interface['statement']}{',' if interface['include_trailing_comma'] else ''}"
+    if interface["comments"]:
+        statement_with_comments = isort.comments.add_to_line(
+            interface["comments"],
+            interface["statement"],
+            removed=interface["remove_comments"],
+            comment_prefix=interface["comment_prefix"],
+        )
+        if len(statement_with_comments.split(interface["line_separator"])[-1]) <= (
+            line_length_limit + 2
+        ):
+            return statement_with_comments
+        return (
+            _hanging_indent_end_line(interface["statement"])
+            + str(interface["line_separator"])
+            + isort.comments.add_to_line(
+                interface["comments"],
+                interface["indent"],
+                removed=interface["remove_comments"],
+                comment_prefix=interface["comment_prefix"].lstrip(),
+            )
+        )
+    return str(interface["statement"])
+
+
+@_wrap_mode
+def vertical_hanging_indent(**interface: Any) -> str:
+    _line_with_comments = isort.comments.add_to_line(
+        interface["comments"],
+        "",
+        removed=interface["remove_comments"],
+        comment_prefix=interface["comment_prefix"],
+    )
+    _imports = ("," + interface["line_separator"] + interface["indent"]).join(interface["imports"])
+    _comma_maybe = "," if interface["include_trailing_comma"] else ""
+    return (
+        f"{interface['statement']}({_line_with_comments}{interface['line_separator']}"
+        f"{interface['indent']}{_imports}{_comma_maybe}{interface['line_separator']})"
+    )
+
+
+def _vertical_grid_common(need_trailing_char: bool, **interface: Any) -> str:
+    if not interface["imports"]:
+        return ""
+
+    interface["statement"] += (
+        isort.comments.add_to_line(
+            interface["comments"],
+            "(",
+            removed=interface["remove_comments"],
+            comment_prefix=interface["comment_prefix"],
+        )
+        + interface["line_separator"]
+        + interface["indent"]
+        + interface["imports"].pop(0)
+    )
+    while interface["imports"]:
+        next_import = interface["imports"].pop(0)
+        next_statement = f"{interface['statement']}, {next_import}"
+        current_line_length = len(next_statement.split(interface["line_separator"])[-1])
+        if interface["imports"] or interface["include_trailing_comma"]:
+            # We need to account for a comma after this import.
+            current_line_length += 1
+        if not interface["imports"] and need_trailing_char:
+            # We need to account for a closing ) we're going to add.
+            current_line_length += 1
+        if current_line_length > interface["line_length"]:
+            next_statement = (
+                f"{interface['statement']},{interface['line_separator']}"
+                f"{interface['indent']}{next_import}"
+            )
+        interface["statement"] = next_statement
+    if interface["include_trailing_comma"]:
+        interface["statement"] += ","
+    return str(interface["statement"])
+
+
+@_wrap_mode
+def vertical_grid(**interface: Any) -> str:
+    return _vertical_grid_common(need_trailing_char=True, **interface) + ")"
+
+
+@_wrap_mode
+def vertical_grid_grouped(**interface: Any) -> str:
+    return (
+        _vertical_grid_common(need_trailing_char=False, **interface)
+        + str(interface["line_separator"])
+        + ")"
+    )
+
+
+@_wrap_mode
+def vertical_grid_grouped_no_comma(**interface: Any) -> str:
+    # This is a deprecated alias for vertical_grid_grouped above. This function
+    # needs to exist for backwards compatibility but should never get called.
+    raise NotImplementedError
+
+
+@_wrap_mode
+def noqa(**interface: Any) -> str:
+    _imports = ", ".join(interface["imports"])
+    retval = f"{interface['statement']}{_imports}"
+    comment_str = " ".join(interface["comments"])
+    if interface["comments"]:
+        if (
+            len(retval) + len(interface["comment_prefix"]) + 1 + len(comment_str)
+            <= interface["line_length"]
+        ):
+            return f"{retval}{interface['comment_prefix']} {comment_str}"
+        if "NOQA" in interface["comments"]:
+            return f"{retval}{interface['comment_prefix']} {comment_str}"
+        return f"{retval}{interface['comment_prefix']} NOQA {comment_str}"
+
+    if len(retval) <= interface["line_length"]:
+        return retval
+    return f"{retval}{interface['comment_prefix']} NOQA"
+
+
+@_wrap_mode
+def vertical_hanging_indent_bracket(**interface: Any) -> str:
+    if not interface["imports"]:
+        return ""
+    statement = vertical_hanging_indent(**interface)
+    return f'{statement[:-1]}{interface["indent"]})'
+
+
+@_wrap_mode
+def vertical_prefix_from_module_import(**interface: Any) -> str:
+    if not interface["imports"]:
+        return ""
+
+    prefix_statement = interface["statement"]
+    output_statement = prefix_statement + interface["imports"].pop(0)
+    comments = interface["comments"]
+
+    statement = output_statement
+    statement_with_comments = ""
+    for next_import in interface["imports"]:
+        statement = statement + ", " + next_import
+        statement_with_comments = isort.comments.add_to_line(
+            comments,
+            statement,
+            removed=interface["remove_comments"],
+            comment_prefix=interface["comment_prefix"],
+        )
+        if (
+            len(statement_with_comments.split(interface["line_separator"])[-1]) + 1
+            > interface["line_length"]
+        ):
+            statement = (
+                isort.comments.add_to_line(
+                    comments,
+                    output_statement,
+                    removed=interface["remove_comments"],
+                    comment_prefix=interface["comment_prefix"],
+                )
+                + f"{interface['line_separator']}{prefix_statement}{next_import}"
+            )
+            comments = []
+        output_statement = statement
+
+    if comments and statement_with_comments:
+        output_statement = statement_with_comments
+    return str(output_statement)
+
+
+@_wrap_mode
+def hanging_indent_with_parentheses(**interface: Any) -> str:
+    if not interface["imports"]:
+        return ""
+
+    line_length_limit = interface["line_length"] - 1
+
+    interface["statement"] += "("
+    next_import = interface["imports"].pop(0)
+    next_statement = interface["statement"] + next_import
+    # Check for first import
+    if len(next_statement) > line_length_limit:
+        next_statement = (
+            isort.comments.add_to_line(
+                interface["comments"],
+                interface["statement"],
+                removed=interface["remove_comments"],
+                comment_prefix=interface["comment_prefix"],
+            )
+            + f"{interface['line_separator']}{interface['indent']}{next_import}"
+        )
+        interface["comments"] = []
+    interface["statement"] = next_statement
+    while interface["imports"]:
+        next_import = interface["imports"].pop(0)
+        if (
+            not interface["line_separator"] in interface["statement"]
+            and "#" in interface["statement"]
+        ):  # pragma: no cover # TODO: fix, this is because of test run inconsistency.
+            line, comments = interface["statement"].split("#", 1)
+            next_statement = (
+                f"{line.rstrip()}, {next_import}{interface['comment_prefix']}{comments}"
+            )
+        else:
+            next_statement = isort.comments.add_to_line(
+                interface["comments"],
+                interface["statement"] + ", " + next_import,
+                removed=interface["remove_comments"],
+                comment_prefix=interface["comment_prefix"],
+            )
+        current_line = next_statement.split(interface["line_separator"])[-1]
+        if len(current_line) > line_length_limit:
+            next_statement = (
+                isort.comments.add_to_line(
+                    interface["comments"],
+                    interface["statement"] + ",",
+                    removed=interface["remove_comments"],
+                    comment_prefix=interface["comment_prefix"],
+                )
+                + f"{interface['line_separator']}{interface['indent']}{next_import}"
+            )
+            interface["comments"] = []
+        interface["statement"] = next_statement
+    return f"{interface['statement']}{',' if interface['include_trailing_comma'] else ''})"
+
+
+@_wrap_mode
+def backslash_grid(**interface: Any) -> str:
+    interface["indent"] = interface["white_space"][:-1]
+    return hanging_indent(**interface)
+
+
+WrapModes = enum.Enum(  # type: ignore
+    "WrapModes", {wrap_mode: index for index, wrap_mode in enumerate(_wrap_modes.keys())}
+)
diff --git a/myenv/lib/python3.9/site-packages/jose/__init__.py b/myenv/lib/python3.9/site-packages/jose/__init__.py
new file mode 100644
index 0000000..054baa7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/__init__.py
@@ -0,0 +1,10 @@
+__version__ = "3.3.0"
+__author__ = "Michael Davis"
+__license__ = "MIT"
+__copyright__ = "Copyright 2016 Michael Davis"
+
+
+from .exceptions import ExpiredSignatureError  # noqa: F401
+from .exceptions import JOSEError  # noqa: F401
+from .exceptions import JWSError  # noqa: F401
+from .exceptions import JWTError  # noqa: F401
diff --git a/myenv/lib/python3.9/site-packages/jose/backends/__init__.py b/myenv/lib/python3.9/site-packages/jose/backends/__init__.py
new file mode 100644
index 0000000..e7bba69
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/backends/__init__.py
@@ -0,0 +1,32 @@
+try:
+    from jose.backends.cryptography_backend import get_random_bytes  # noqa: F401
+except ImportError:
+    try:
+        from jose.backends.pycrypto_backend import get_random_bytes  # noqa: F401
+    except ImportError:
+        from jose.backends.native import get_random_bytes  # noqa: F401
+
+try:
+    from jose.backends.cryptography_backend import CryptographyRSAKey as RSAKey  # noqa: F401
+except ImportError:
+    try:
+        from jose.backends.rsa_backend import RSAKey  # noqa: F401
+    except ImportError:
+        RSAKey = None
+
+try:
+    from jose.backends.cryptography_backend import CryptographyECKey as ECKey  # noqa: F401
+except ImportError:
+    from jose.backends.ecdsa_backend import ECDSAECKey as ECKey  # noqa: F401
+
+try:
+    from jose.backends.cryptography_backend import CryptographyAESKey as AESKey  # noqa: F401
+except ImportError:
+    AESKey = None
+
+try:
+    from jose.backends.cryptography_backend import CryptographyHMACKey as HMACKey  # noqa: F401
+except ImportError:
+    from jose.backends.native import HMACKey  # noqa: F401
+
+from .base import DIRKey  # noqa: F401
diff --git a/myenv/lib/python3.9/site-packages/jose/backends/_asn1.py b/myenv/lib/python3.9/site-packages/jose/backends/_asn1.py
new file mode 100644
index 0000000..af5fa8b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/backends/_asn1.py
@@ -0,0 +1,83 @@
+"""ASN1 encoding helpers for converting between PKCS1 and PKCS8.
+
+Required by rsa_backend but not cryptography_backend.
+"""
+from pyasn1.codec.der import decoder, encoder
+from pyasn1.type import namedtype, univ
+
+RSA_ENCRYPTION_ASN1_OID = "1.2.840.113549.1.1.1"
+
+
+class RsaAlgorithmIdentifier(univ.Sequence):
+    """ASN1 structure for recording RSA PrivateKeyAlgorithm identifiers."""
+
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("rsaEncryption", univ.ObjectIdentifier()), namedtype.NamedType("parameters", univ.Null())
+    )
+
+
+class PKCS8PrivateKey(univ.Sequence):
+    """ASN1 structure for recording PKCS8 private keys."""
+
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("version", univ.Integer()),
+        namedtype.NamedType("privateKeyAlgorithm", RsaAlgorithmIdentifier()),
+        namedtype.NamedType("privateKey", univ.OctetString()),
+    )
+
+
+class PublicKeyInfo(univ.Sequence):
+    """ASN1 structure for recording PKCS8 public keys."""
+
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("algorithm", RsaAlgorithmIdentifier()), namedtype.NamedType("publicKey", univ.BitString())
+    )
+
+
+def rsa_private_key_pkcs8_to_pkcs1(pkcs8_key):
+    """Convert a PKCS8-encoded RSA private key to PKCS1."""
+    decoded_values = decoder.decode(pkcs8_key, asn1Spec=PKCS8PrivateKey())
+
+    try:
+        decoded_key = decoded_values[0]
+    except IndexError:
+        raise ValueError("Invalid private key encoding")
+
+    return decoded_key["privateKey"]
+
+
+def rsa_private_key_pkcs1_to_pkcs8(pkcs1_key):
+    """Convert a PKCS1-encoded RSA private key to PKCS8."""
+    algorithm = RsaAlgorithmIdentifier()
+    algorithm["rsaEncryption"] = RSA_ENCRYPTION_ASN1_OID
+
+    pkcs8_key = PKCS8PrivateKey()
+    pkcs8_key["version"] = 0
+    pkcs8_key["privateKeyAlgorithm"] = algorithm
+    pkcs8_key["privateKey"] = pkcs1_key
+
+    return encoder.encode(pkcs8_key)
+
+
+def rsa_public_key_pkcs1_to_pkcs8(pkcs1_key):
+    """Convert a PKCS1-encoded RSA private key to PKCS8."""
+    algorithm = RsaAlgorithmIdentifier()
+    algorithm["rsaEncryption"] = RSA_ENCRYPTION_ASN1_OID
+
+    pkcs8_key = PublicKeyInfo()
+    pkcs8_key["algorithm"] = algorithm
+    pkcs8_key["publicKey"] = univ.BitString.fromOctetString(pkcs1_key)
+
+    return encoder.encode(pkcs8_key)
+
+
+def rsa_public_key_pkcs8_to_pkcs1(pkcs8_key):
+    """Convert a PKCS8-encoded RSA private key to PKCS1."""
+    decoded_values = decoder.decode(pkcs8_key, asn1Spec=PublicKeyInfo())
+
+    try:
+        decoded_key = decoded_values[0]
+    except IndexError:
+        raise ValueError("Invalid public key encoding.")
+
+    return decoded_key["publicKey"].asOctets()
diff --git a/myenv/lib/python3.9/site-packages/jose/backends/base.py b/myenv/lib/python3.9/site-packages/jose/backends/base.py
new file mode 100644
index 0000000..b000a52
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/backends/base.py
@@ -0,0 +1,89 @@
+from ..utils import base64url_encode, ensure_binary
+
+
+class Key:
+    """
+    A simple interface for implementing JWK keys.
+    """
+
+    def __init__(self, key, algorithm):
+        pass
+
+    def sign(self, msg):
+        raise NotImplementedError()
+
+    def verify(self, msg, sig):
+        raise NotImplementedError()
+
+    def public_key(self):
+        raise NotImplementedError()
+
+    def to_pem(self):
+        raise NotImplementedError()
+
+    def to_dict(self):
+        raise NotImplementedError()
+
+    def encrypt(self, plain_text, aad=None):
+        """
+        Encrypt the plain text and generate an auth tag if appropriate
+
+        Args:
+            plain_text (bytes): Data to encrypt
+            aad (bytes, optional): Authenticated Additional Data if key's algorithm supports auth mode
+
+        Returns:
+            (bytes, bytes, bytes): IV, cipher text, and auth tag
+        """
+        raise NotImplementedError()
+
+    def decrypt(self, cipher_text, iv=None, aad=None, tag=None):
+        """
+        Decrypt the cipher text and validate the auth tag if present
+        Args:
+            cipher_text (bytes): Cipher text to decrypt
+            iv (bytes): IV if block mode
+            aad (bytes): Additional Authenticated Data to verify if auth mode
+            tag (bytes): Authentication tag if auth mode
+
+        Returns:
+            bytes: Decrypted value
+        """
+        raise NotImplementedError()
+
+    def wrap_key(self, key_data):
+        """
+        Wrap the the plain text key data
+
+        Args:
+            key_data (bytes): Key data to wrap
+
+        Returns:
+            bytes: Wrapped key
+        """
+        raise NotImplementedError()
+
+    def unwrap_key(self, wrapped_key):
+        """
+        Unwrap the the wrapped key data
+
+        Args:
+            wrapped_key (bytes): Wrapped key data to unwrap
+
+        Returns:
+            bytes: Unwrapped key
+        """
+        raise NotImplementedError()
+
+
+class DIRKey(Key):
+    def __init__(self, key_data, algorithm):
+        self._key = ensure_binary(key_data)
+        self._alg = algorithm
+
+    def to_dict(self):
+        return {
+            "alg": self._alg,
+            "kty": "oct",
+            "k": base64url_encode(self._key),
+        }
diff --git a/myenv/lib/python3.9/site-packages/jose/backends/cryptography_backend.py b/myenv/lib/python3.9/site-packages/jose/backends/cryptography_backend.py
new file mode 100644
index 0000000..abd2426
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/backends/cryptography_backend.py
@@ -0,0 +1,605 @@
+import math
+import warnings
+
+from cryptography.exceptions import InvalidSignature, InvalidTag
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.bindings.openssl.binding import Binding
+from cryptography.hazmat.primitives import hashes, hmac, serialization
+from cryptography.hazmat.primitives.asymmetric import ec, padding, rsa
+from cryptography.hazmat.primitives.asymmetric.utils import decode_dss_signature, encode_dss_signature
+from cryptography.hazmat.primitives.ciphers import Cipher, aead, algorithms, modes
+from cryptography.hazmat.primitives.keywrap import InvalidUnwrap, aes_key_unwrap, aes_key_wrap
+from cryptography.hazmat.primitives.padding import PKCS7
+from cryptography.hazmat.primitives.serialization import load_pem_private_key, load_pem_public_key
+from cryptography.utils import int_to_bytes
+from cryptography.x509 import load_pem_x509_certificate
+
+from ..constants import ALGORITHMS
+from ..exceptions import JWEError, JWKError
+from ..utils import base64_to_long, base64url_decode, base64url_encode, ensure_binary, long_to_base64
+from .base import Key
+
+_binding = None
+
+
+def get_random_bytes(num_bytes):
+    """
+    Get random bytes
+
+    Currently, Cryptography returns OS random bytes. If you want OpenSSL
+    generated random bytes, you'll have to switch the RAND engine after
+    initializing the OpenSSL backend
+    Args:
+        num_bytes (int): Number of random bytes to generate and return
+    Returns:
+        bytes: Random bytes
+    """
+    global _binding
+
+    if _binding is None:
+        _binding = Binding()
+
+    buf = _binding.ffi.new("char[]", num_bytes)
+    _binding.lib.RAND_bytes(buf, num_bytes)
+    rand_bytes = _binding.ffi.buffer(buf, num_bytes)[:]
+    return rand_bytes
+
+
+class CryptographyECKey(Key):
+    SHA256 = hashes.SHA256
+    SHA384 = hashes.SHA384
+    SHA512 = hashes.SHA512
+
+    def __init__(self, key, algorithm, cryptography_backend=default_backend):
+        if algorithm not in ALGORITHMS.EC:
+            raise JWKError("hash_alg: %s is not a valid hash algorithm" % algorithm)
+
+        self.hash_alg = {
+            ALGORITHMS.ES256: self.SHA256,
+            ALGORITHMS.ES384: self.SHA384,
+            ALGORITHMS.ES512: self.SHA512,
+        }.get(algorithm)
+        self._algorithm = algorithm
+
+        self.cryptography_backend = cryptography_backend
+
+        if hasattr(key, "public_bytes") or hasattr(key, "private_bytes"):
+            self.prepared_key = key
+            return
+
+        if hasattr(key, "to_pem"):
+            # convert to PEM and let cryptography below load it as PEM
+            key = key.to_pem().decode("utf-8")
+
+        if isinstance(key, dict):
+            self.prepared_key = self._process_jwk(key)
+            return
+
+        if isinstance(key, str):
+            key = key.encode("utf-8")
+
+        if isinstance(key, bytes):
+            # Attempt to load key. We don't know if it's
+            # a Public Key or a Private Key, so we try
+            # the Public Key first.
+            try:
+                try:
+                    key = load_pem_public_key(key, self.cryptography_backend())
+                except ValueError:
+                    key = load_pem_private_key(key, password=None, backend=self.cryptography_backend())
+            except Exception as e:
+                raise JWKError(e)
+
+            self.prepared_key = key
+            return
+
+        raise JWKError("Unable to parse an ECKey from key: %s" % key)
+
+    def _process_jwk(self, jwk_dict):
+        if not jwk_dict.get("kty") == "EC":
+            raise JWKError("Incorrect key type. Expected: 'EC', Received: %s" % jwk_dict.get("kty"))
+
+        if not all(k in jwk_dict for k in ["x", "y", "crv"]):
+            raise JWKError("Mandatory parameters are missing")
+
+        x = base64_to_long(jwk_dict.get("x"))
+        y = base64_to_long(jwk_dict.get("y"))
+        curve = {
+            "P-256": ec.SECP256R1,
+            "P-384": ec.SECP384R1,
+            "P-521": ec.SECP521R1,
+        }[jwk_dict["crv"]]
+
+        public = ec.EllipticCurvePublicNumbers(x, y, curve())
+
+        if "d" in jwk_dict:
+            d = base64_to_long(jwk_dict.get("d"))
+            private = ec.EllipticCurvePrivateNumbers(d, public)
+
+            return private.private_key(self.cryptography_backend())
+        else:
+            return public.public_key(self.cryptography_backend())
+
+    def _sig_component_length(self):
+        """Determine the correct serialization length for an encoded signature component.
+
+        This is the number of bytes required to encode the maximum key value.
+        """
+        return int(math.ceil(self.prepared_key.key_size / 8.0))
+
+    def _der_to_raw(self, der_signature):
+        """Convert signature from DER encoding to RAW encoding."""
+        r, s = decode_dss_signature(der_signature)
+        component_length = self._sig_component_length()
+        return int_to_bytes(r, component_length) + int_to_bytes(s, component_length)
+
+    def _raw_to_der(self, raw_signature):
+        """Convert signature from RAW encoding to DER encoding."""
+        component_length = self._sig_component_length()
+        if len(raw_signature) != int(2 * component_length):
+            raise ValueError("Invalid signature")
+
+        r_bytes = raw_signature[:component_length]
+        s_bytes = raw_signature[component_length:]
+        r = int.from_bytes(r_bytes, "big")
+        s = int.from_bytes(s_bytes, "big")
+        return encode_dss_signature(r, s)
+
+    def sign(self, msg):
+        if self.hash_alg.digest_size * 8 > self.prepared_key.curve.key_size:
+            raise TypeError(
+                "this curve (%s) is too short "
+                "for your digest (%d)" % (self.prepared_key.curve.name, 8 * self.hash_alg.digest_size)
+            )
+        signature = self.prepared_key.sign(msg, ec.ECDSA(self.hash_alg()))
+        return self._der_to_raw(signature)
+
+    def verify(self, msg, sig):
+        try:
+            signature = self._raw_to_der(sig)
+            self.prepared_key.verify(signature, msg, ec.ECDSA(self.hash_alg()))
+            return True
+        except Exception:
+            return False
+
+    def is_public(self):
+        return hasattr(self.prepared_key, "public_bytes")
+
+    def public_key(self):
+        if self.is_public():
+            return self
+        return self.__class__(self.prepared_key.public_key(), self._algorithm)
+
+    def to_pem(self):
+        if self.is_public():
+            pem = self.prepared_key.public_bytes(
+                encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo
+            )
+            return pem
+        pem = self.prepared_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.TraditionalOpenSSL,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+        return pem
+
+    def to_dict(self):
+        if not self.is_public():
+            public_key = self.prepared_key.public_key()
+        else:
+            public_key = self.prepared_key
+
+        crv = {
+            "secp256r1": "P-256",
+            "secp384r1": "P-384",
+            "secp521r1": "P-521",
+        }[self.prepared_key.curve.name]
+
+        # Calculate the key size in bytes. Section 6.2.1.2 and 6.2.1.3 of
+        # RFC7518 prescribes that the 'x', 'y' and 'd' parameters of the curve
+        # points must be encoded as octed-strings of this length.
+        key_size = (self.prepared_key.curve.key_size + 7) // 8
+
+        data = {
+            "alg": self._algorithm,
+            "kty": "EC",
+            "crv": crv,
+            "x": long_to_base64(public_key.public_numbers().x, size=key_size).decode("ASCII"),
+            "y": long_to_base64(public_key.public_numbers().y, size=key_size).decode("ASCII"),
+        }
+
+        if not self.is_public():
+            private_value = self.prepared_key.private_numbers().private_value
+            data["d"] = long_to_base64(private_value, size=key_size).decode("ASCII")
+
+        return data
+
+
+class CryptographyRSAKey(Key):
+    SHA256 = hashes.SHA256
+    SHA384 = hashes.SHA384
+    SHA512 = hashes.SHA512
+
+    RSA1_5 = padding.PKCS1v15()
+    RSA_OAEP = padding.OAEP(padding.MGF1(hashes.SHA1()), hashes.SHA1(), None)
+    RSA_OAEP_256 = padding.OAEP(padding.MGF1(hashes.SHA256()), hashes.SHA256(), None)
+
+    def __init__(self, key, algorithm, cryptography_backend=default_backend):
+        if algorithm not in ALGORITHMS.RSA:
+            raise JWKError("hash_alg: %s is not a valid hash algorithm" % algorithm)
+
+        self.hash_alg = {
+            ALGORITHMS.RS256: self.SHA256,
+            ALGORITHMS.RS384: self.SHA384,
+            ALGORITHMS.RS512: self.SHA512,
+        }.get(algorithm)
+        self._algorithm = algorithm
+
+        self.padding = {
+            ALGORITHMS.RSA1_5: self.RSA1_5,
+            ALGORITHMS.RSA_OAEP: self.RSA_OAEP,
+            ALGORITHMS.RSA_OAEP_256: self.RSA_OAEP_256,
+        }.get(algorithm)
+
+        self.cryptography_backend = cryptography_backend
+
+        # if it conforms to RSAPublicKey interface
+        if hasattr(key, "public_bytes") and hasattr(key, "public_numbers"):
+            self.prepared_key = key
+            return
+
+        if isinstance(key, dict):
+            self.prepared_key = self._process_jwk(key)
+            return
+
+        if isinstance(key, str):
+            key = key.encode("utf-8")
+
+        if isinstance(key, bytes):
+            try:
+                if key.startswith(b"-----BEGIN CERTIFICATE-----"):
+                    self._process_cert(key)
+                    return
+
+                try:
+                    self.prepared_key = load_pem_public_key(key, self.cryptography_backend())
+                except ValueError:
+                    self.prepared_key = load_pem_private_key(key, password=None, backend=self.cryptography_backend())
+            except Exception as e:
+                raise JWKError(e)
+            return
+
+        raise JWKError("Unable to parse an RSA_JWK from key: %s" % key)
+
+    def _process_jwk(self, jwk_dict):
+        if not jwk_dict.get("kty") == "RSA":
+            raise JWKError("Incorrect key type. Expected: 'RSA', Received: %s" % jwk_dict.get("kty"))
+
+        e = base64_to_long(jwk_dict.get("e", 256))
+        n = base64_to_long(jwk_dict.get("n"))
+        public = rsa.RSAPublicNumbers(e, n)
+
+        if "d" not in jwk_dict:
+            return public.public_key(self.cryptography_backend())
+        else:
+            # This is a private key.
+            d = base64_to_long(jwk_dict.get("d"))
+
+            extra_params = ["p", "q", "dp", "dq", "qi"]
+
+            if any(k in jwk_dict for k in extra_params):
+                # Precomputed private key parameters are available.
+                if not all(k in jwk_dict for k in extra_params):
+                    # These values must be present when 'p' is according to
+                    # Section 6.3.2 of RFC7518, so if they are not we raise
+                    # an error.
+                    raise JWKError("Precomputed private key parameters are incomplete.")
+
+                p = base64_to_long(jwk_dict["p"])
+                q = base64_to_long(jwk_dict["q"])
+                dp = base64_to_long(jwk_dict["dp"])
+                dq = base64_to_long(jwk_dict["dq"])
+                qi = base64_to_long(jwk_dict["qi"])
+            else:
+                # The precomputed private key parameters are not available,
+                # so we use cryptography's API to fill them in.
+                p, q = rsa.rsa_recover_prime_factors(n, e, d)
+                dp = rsa.rsa_crt_dmp1(d, p)
+                dq = rsa.rsa_crt_dmq1(d, q)
+                qi = rsa.rsa_crt_iqmp(p, q)
+
+            private = rsa.RSAPrivateNumbers(p, q, d, dp, dq, qi, public)
+
+            return private.private_key(self.cryptography_backend())
+
+    def _process_cert(self, key):
+        key = load_pem_x509_certificate(key, self.cryptography_backend())
+        self.prepared_key = key.public_key()
+
+    def sign(self, msg):
+        try:
+            signature = self.prepared_key.sign(msg, padding.PKCS1v15(), self.hash_alg())
+        except Exception as e:
+            raise JWKError(e)
+        return signature
+
+    def verify(self, msg, sig):
+        if not self.is_public():
+            warnings.warn("Attempting to verify a message with a private key. " "This is not recommended.")
+
+        try:
+            self.public_key().prepared_key.verify(sig, msg, padding.PKCS1v15(), self.hash_alg())
+            return True
+        except InvalidSignature:
+            return False
+
+    def is_public(self):
+        return hasattr(self.prepared_key, "public_bytes")
+
+    def public_key(self):
+        if self.is_public():
+            return self
+        return self.__class__(self.prepared_key.public_key(), self._algorithm)
+
+    def to_pem(self, pem_format="PKCS8"):
+        if self.is_public():
+            if pem_format == "PKCS8":
+                fmt = serialization.PublicFormat.SubjectPublicKeyInfo
+            elif pem_format == "PKCS1":
+                fmt = serialization.PublicFormat.PKCS1
+            else:
+                raise ValueError("Invalid format specified: %r" % pem_format)
+            pem = self.prepared_key.public_bytes(encoding=serialization.Encoding.PEM, format=fmt)
+            return pem
+
+        if pem_format == "PKCS8":
+            fmt = serialization.PrivateFormat.PKCS8
+        elif pem_format == "PKCS1":
+            fmt = serialization.PrivateFormat.TraditionalOpenSSL
+        else:
+            raise ValueError("Invalid format specified: %r" % pem_format)
+
+        return self.prepared_key.private_bytes(
+            encoding=serialization.Encoding.PEM, format=fmt, encryption_algorithm=serialization.NoEncryption()
+        )
+
+    def to_dict(self):
+        if not self.is_public():
+            public_key = self.prepared_key.public_key()
+        else:
+            public_key = self.prepared_key
+
+        data = {
+            "alg": self._algorithm,
+            "kty": "RSA",
+            "n": long_to_base64(public_key.public_numbers().n).decode("ASCII"),
+            "e": long_to_base64(public_key.public_numbers().e).decode("ASCII"),
+        }
+
+        if not self.is_public():
+            data.update(
+                {
+                    "d": long_to_base64(self.prepared_key.private_numbers().d).decode("ASCII"),
+                    "p": long_to_base64(self.prepared_key.private_numbers().p).decode("ASCII"),
+                    "q": long_to_base64(self.prepared_key.private_numbers().q).decode("ASCII"),
+                    "dp": long_to_base64(self.prepared_key.private_numbers().dmp1).decode("ASCII"),
+                    "dq": long_to_base64(self.prepared_key.private_numbers().dmq1).decode("ASCII"),
+                    "qi": long_to_base64(self.prepared_key.private_numbers().iqmp).decode("ASCII"),
+                }
+            )
+
+        return data
+
+    def wrap_key(self, key_data):
+        try:
+            wrapped_key = self.prepared_key.encrypt(key_data, self.padding)
+        except Exception as e:
+            raise JWEError(e)
+
+        return wrapped_key
+
+    def unwrap_key(self, wrapped_key):
+        try:
+            unwrapped_key = self.prepared_key.decrypt(wrapped_key, self.padding)
+            return unwrapped_key
+        except Exception as e:
+            raise JWEError(e)
+
+
+class CryptographyAESKey(Key):
+    KEY_128 = (ALGORITHMS.A128GCM, ALGORITHMS.A128GCMKW, ALGORITHMS.A128KW, ALGORITHMS.A128CBC)
+    KEY_192 = (ALGORITHMS.A192GCM, ALGORITHMS.A192GCMKW, ALGORITHMS.A192KW, ALGORITHMS.A192CBC)
+    KEY_256 = (
+        ALGORITHMS.A256GCM,
+        ALGORITHMS.A256GCMKW,
+        ALGORITHMS.A256KW,
+        ALGORITHMS.A128CBC_HS256,
+        ALGORITHMS.A256CBC,
+    )
+    KEY_384 = (ALGORITHMS.A192CBC_HS384,)
+    KEY_512 = (ALGORITHMS.A256CBC_HS512,)
+
+    AES_KW_ALGS = (ALGORITHMS.A128KW, ALGORITHMS.A192KW, ALGORITHMS.A256KW)
+
+    MODES = {
+        ALGORITHMS.A128GCM: modes.GCM,
+        ALGORITHMS.A192GCM: modes.GCM,
+        ALGORITHMS.A256GCM: modes.GCM,
+        ALGORITHMS.A128CBC_HS256: modes.CBC,
+        ALGORITHMS.A192CBC_HS384: modes.CBC,
+        ALGORITHMS.A256CBC_HS512: modes.CBC,
+        ALGORITHMS.A128CBC: modes.CBC,
+        ALGORITHMS.A192CBC: modes.CBC,
+        ALGORITHMS.A256CBC: modes.CBC,
+        ALGORITHMS.A128GCMKW: modes.GCM,
+        ALGORITHMS.A192GCMKW: modes.GCM,
+        ALGORITHMS.A256GCMKW: modes.GCM,
+        ALGORITHMS.A128KW: None,
+        ALGORITHMS.A192KW: None,
+        ALGORITHMS.A256KW: None,
+    }
+
+    def __init__(self, key, algorithm):
+        if algorithm not in ALGORITHMS.AES:
+            raise JWKError("%s is not a valid AES algorithm" % algorithm)
+        if algorithm not in ALGORITHMS.SUPPORTED.union(ALGORITHMS.AES_PSEUDO):
+            raise JWKError("%s is not a supported algorithm" % algorithm)
+
+        self._algorithm = algorithm
+        self._mode = self.MODES.get(self._algorithm)
+
+        if algorithm in self.KEY_128 and len(key) != 16:
+            raise JWKError(f"Key must be 128 bit for alg {algorithm}")
+        elif algorithm in self.KEY_192 and len(key) != 24:
+            raise JWKError(f"Key must be 192 bit for alg {algorithm}")
+        elif algorithm in self.KEY_256 and len(key) != 32:
+            raise JWKError(f"Key must be 256 bit for alg {algorithm}")
+        elif algorithm in self.KEY_384 and len(key) != 48:
+            raise JWKError(f"Key must be 384 bit for alg {algorithm}")
+        elif algorithm in self.KEY_512 and len(key) != 64:
+            raise JWKError(f"Key must be 512 bit for alg {algorithm}")
+
+        self._key = key
+
+    def to_dict(self):
+        data = {"alg": self._algorithm, "kty": "oct", "k": base64url_encode(self._key)}
+        return data
+
+    def encrypt(self, plain_text, aad=None):
+        plain_text = ensure_binary(plain_text)
+        try:
+            iv = get_random_bytes(algorithms.AES.block_size // 8)
+            mode = self._mode(iv)
+            if mode.name == "GCM":
+                cipher = aead.AESGCM(self._key)
+                cipher_text_and_tag = cipher.encrypt(iv, plain_text, aad)
+                cipher_text = cipher_text_and_tag[: len(cipher_text_and_tag) - 16]
+                auth_tag = cipher_text_and_tag[-16:]
+            else:
+                cipher = Cipher(algorithms.AES(self._key), mode, backend=default_backend())
+                encryptor = cipher.encryptor()
+                padder = PKCS7(algorithms.AES.block_size).padder()
+                padded_data = padder.update(plain_text)
+                padded_data += padder.finalize()
+                cipher_text = encryptor.update(padded_data) + encryptor.finalize()
+                auth_tag = None
+            return iv, cipher_text, auth_tag
+        except Exception as e:
+            raise JWEError(e)
+
+    def decrypt(self, cipher_text, iv=None, aad=None, tag=None):
+        cipher_text = ensure_binary(cipher_text)
+        try:
+            iv = ensure_binary(iv)
+            mode = self._mode(iv)
+            if mode.name == "GCM":
+                if tag is None:
+                    raise ValueError("tag cannot be None")
+                cipher = aead.AESGCM(self._key)
+                cipher_text_and_tag = cipher_text + tag
+                try:
+                    plain_text = cipher.decrypt(iv, cipher_text_and_tag, aad)
+                except InvalidTag:
+                    raise JWEError("Invalid JWE Auth Tag")
+            else:
+                cipher = Cipher(algorithms.AES(self._key), mode, backend=default_backend())
+                decryptor = cipher.decryptor()
+                padded_plain_text = decryptor.update(cipher_text)
+                padded_plain_text += decryptor.finalize()
+                unpadder = PKCS7(algorithms.AES.block_size).unpadder()
+                plain_text = unpadder.update(padded_plain_text)
+                plain_text += unpadder.finalize()
+
+            return plain_text
+        except Exception as e:
+            raise JWEError(e)
+
+    def wrap_key(self, key_data):
+        key_data = ensure_binary(key_data)
+        cipher_text = aes_key_wrap(self._key, key_data, default_backend())
+        return cipher_text  # IV, cipher text, auth tag
+
+    def unwrap_key(self, wrapped_key):
+        wrapped_key = ensure_binary(wrapped_key)
+        try:
+            plain_text = aes_key_unwrap(self._key, wrapped_key, default_backend())
+        except InvalidUnwrap as cause:
+            raise JWEError(cause)
+        return plain_text
+
+
+class CryptographyHMACKey(Key):
+    """
+    Performs signing and verification operations using HMAC
+    and the specified hash function.
+    """
+
+    ALG_MAP = {ALGORITHMS.HS256: hashes.SHA256(), ALGORITHMS.HS384: hashes.SHA384(), ALGORITHMS.HS512: hashes.SHA512()}
+
+    def __init__(self, key, algorithm):
+        if algorithm not in ALGORITHMS.HMAC:
+            raise JWKError("hash_alg: %s is not a valid hash algorithm" % algorithm)
+        self._algorithm = algorithm
+        self._hash_alg = self.ALG_MAP.get(algorithm)
+
+        if isinstance(key, dict):
+            self.prepared_key = self._process_jwk(key)
+            return
+
+        if not isinstance(key, str) and not isinstance(key, bytes):
+            raise JWKError("Expecting a string- or bytes-formatted key.")
+
+        if isinstance(key, str):
+            key = key.encode("utf-8")
+
+        invalid_strings = [
+            b"-----BEGIN PUBLIC KEY-----",
+            b"-----BEGIN RSA PUBLIC KEY-----",
+            b"-----BEGIN CERTIFICATE-----",
+            b"ssh-rsa",
+        ]
+
+        if any(string_value in key for string_value in invalid_strings):
+            raise JWKError(
+                "The specified key is an asymmetric key or x509 certificate and"
+                " should not be used as an HMAC secret."
+            )
+
+        self.prepared_key = key
+
+    def _process_jwk(self, jwk_dict):
+        if not jwk_dict.get("kty") == "oct":
+            raise JWKError("Incorrect key type. Expected: 'oct', Received: %s" % jwk_dict.get("kty"))
+
+        k = jwk_dict.get("k")
+        k = k.encode("utf-8")
+        k = bytes(k)
+        k = base64url_decode(k)
+
+        return k
+
+    def to_dict(self):
+        return {
+            "alg": self._algorithm,
+            "kty": "oct",
+            "k": base64url_encode(self.prepared_key).decode("ASCII"),
+        }
+
+    def sign(self, msg):
+        msg = ensure_binary(msg)
+        h = hmac.HMAC(self.prepared_key, self._hash_alg, backend=default_backend())
+        h.update(msg)
+        signature = h.finalize()
+        return signature
+
+    def verify(self, msg, sig):
+        msg = ensure_binary(msg)
+        sig = ensure_binary(sig)
+        h = hmac.HMAC(self.prepared_key, self._hash_alg, backend=default_backend())
+        h.update(msg)
+        try:
+            h.verify(sig)
+            verified = True
+        except InvalidSignature:
+            verified = False
+        return verified
diff --git a/myenv/lib/python3.9/site-packages/jose/backends/ecdsa_backend.py b/myenv/lib/python3.9/site-packages/jose/backends/ecdsa_backend.py
new file mode 100644
index 0000000..756c7ea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/backends/ecdsa_backend.py
@@ -0,0 +1,150 @@
+import hashlib
+
+import ecdsa
+
+from jose.backends.base import Key
+from jose.constants import ALGORITHMS
+from jose.exceptions import JWKError
+from jose.utils import base64_to_long, long_to_base64
+
+
+class ECDSAECKey(Key):
+    """
+    Performs signing and verification operations using
+    ECDSA and the specified hash function
+
+    This class requires the ecdsa package to be installed.
+
+    This is based off of the implementation in PyJWT 0.3.2
+    """
+
+    SHA256 = hashlib.sha256
+    SHA384 = hashlib.sha384
+    SHA512 = hashlib.sha512
+
+    CURVE_MAP = {
+        SHA256: ecdsa.curves.NIST256p,
+        SHA384: ecdsa.curves.NIST384p,
+        SHA512: ecdsa.curves.NIST521p,
+    }
+    CURVE_NAMES = (
+        (ecdsa.curves.NIST256p, "P-256"),
+        (ecdsa.curves.NIST384p, "P-384"),
+        (ecdsa.curves.NIST521p, "P-521"),
+    )
+
+    def __init__(self, key, algorithm):
+        if algorithm not in ALGORITHMS.EC:
+            raise JWKError("hash_alg: %s is not a valid hash algorithm" % algorithm)
+
+        self.hash_alg = {
+            ALGORITHMS.ES256: self.SHA256,
+            ALGORITHMS.ES384: self.SHA384,
+            ALGORITHMS.ES512: self.SHA512,
+        }.get(algorithm)
+        self._algorithm = algorithm
+
+        self.curve = self.CURVE_MAP.get(self.hash_alg)
+
+        if isinstance(key, (ecdsa.SigningKey, ecdsa.VerifyingKey)):
+            self.prepared_key = key
+            return
+
+        if isinstance(key, dict):
+            self.prepared_key = self._process_jwk(key)
+            return
+
+        if isinstance(key, str):
+            key = key.encode("utf-8")
+
+        if isinstance(key, bytes):
+            # Attempt to load key. We don't know if it's
+            # a Signing Key or a Verifying Key, so we try
+            # the Verifying Key first.
+            try:
+                key = ecdsa.VerifyingKey.from_pem(key)
+            except ecdsa.der.UnexpectedDER:
+                key = ecdsa.SigningKey.from_pem(key)
+            except Exception as e:
+                raise JWKError(e)
+
+            self.prepared_key = key
+            return
+
+        raise JWKError("Unable to parse an ECKey from key: %s" % key)
+
+    def _process_jwk(self, jwk_dict):
+        if not jwk_dict.get("kty") == "EC":
+            raise JWKError("Incorrect key type. Expected: 'EC', Received: %s" % jwk_dict.get("kty"))
+
+        if not all(k in jwk_dict for k in ["x", "y", "crv"]):
+            raise JWKError("Mandatory parameters are missing")
+
+        if "d" in jwk_dict:
+            # We are dealing with a private key; the secret exponent is enough
+            # to create an ecdsa key.
+            d = base64_to_long(jwk_dict.get("d"))
+            return ecdsa.keys.SigningKey.from_secret_exponent(d, self.curve)
+        else:
+            x = base64_to_long(jwk_dict.get("x"))
+            y = base64_to_long(jwk_dict.get("y"))
+
+            if not ecdsa.ecdsa.point_is_valid(self.curve.generator, x, y):
+                raise JWKError(f"Point: {x}, {y} is not a valid point")
+
+            point = ecdsa.ellipticcurve.Point(self.curve.curve, x, y, self.curve.order)
+            return ecdsa.keys.VerifyingKey.from_public_point(point, self.curve)
+
+    def sign(self, msg):
+        return self.prepared_key.sign(
+            msg, hashfunc=self.hash_alg, sigencode=ecdsa.util.sigencode_string, allow_truncate=False
+        )
+
+    def verify(self, msg, sig):
+        try:
+            return self.prepared_key.verify(
+                sig, msg, hashfunc=self.hash_alg, sigdecode=ecdsa.util.sigdecode_string, allow_truncate=False
+            )
+        except Exception:
+            return False
+
+    def is_public(self):
+        return isinstance(self.prepared_key, ecdsa.VerifyingKey)
+
+    def public_key(self):
+        if self.is_public():
+            return self
+        return self.__class__(self.prepared_key.get_verifying_key(), self._algorithm)
+
+    def to_pem(self):
+        return self.prepared_key.to_pem()
+
+    def to_dict(self):
+        if not self.is_public():
+            public_key = self.prepared_key.get_verifying_key()
+        else:
+            public_key = self.prepared_key
+        crv = None
+        for key, value in self.CURVE_NAMES:
+            if key == self.prepared_key.curve:
+                crv = value
+        if not crv:
+            raise KeyError(f"Can't match {self.prepared_key.curve}")
+
+        # Calculate the key size in bytes. Section 6.2.1.2 and 6.2.1.3 of
+        # RFC7518 prescribes that the 'x', 'y' and 'd' parameters of the curve
+        # points must be encoded as octed-strings of this length.
+        key_size = self.prepared_key.curve.baselen
+
+        data = {
+            "alg": self._algorithm,
+            "kty": "EC",
+            "crv": crv,
+            "x": long_to_base64(public_key.pubkey.point.x(), size=key_size).decode("ASCII"),
+            "y": long_to_base64(public_key.pubkey.point.y(), size=key_size).decode("ASCII"),
+        }
+
+        if not self.is_public():
+            data["d"] = long_to_base64(self.prepared_key.privkey.secret_multiplier, size=key_size).decode("ASCII")
+
+        return data
diff --git a/myenv/lib/python3.9/site-packages/jose/backends/native.py b/myenv/lib/python3.9/site-packages/jose/backends/native.py
new file mode 100644
index 0000000..eb3a6ae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/backends/native.py
@@ -0,0 +1,76 @@
+import hashlib
+import hmac
+import os
+
+from jose.backends.base import Key
+from jose.constants import ALGORITHMS
+from jose.exceptions import JWKError
+from jose.utils import base64url_decode, base64url_encode
+
+
+def get_random_bytes(num_bytes):
+    return bytes(os.urandom(num_bytes))
+
+
+class HMACKey(Key):
+    """
+    Performs signing and verification operations using HMAC
+    and the specified hash function.
+    """
+
+    HASHES = {ALGORITHMS.HS256: hashlib.sha256, ALGORITHMS.HS384: hashlib.sha384, ALGORITHMS.HS512: hashlib.sha512}
+
+    def __init__(self, key, algorithm):
+        if algorithm not in ALGORITHMS.HMAC:
+            raise JWKError("hash_alg: %s is not a valid hash algorithm" % algorithm)
+        self._algorithm = algorithm
+        self._hash_alg = self.HASHES.get(algorithm)
+
+        if isinstance(key, dict):
+            self.prepared_key = self._process_jwk(key)
+            return
+
+        if not isinstance(key, str) and not isinstance(key, bytes):
+            raise JWKError("Expecting a string- or bytes-formatted key.")
+
+        if isinstance(key, str):
+            key = key.encode("utf-8")
+
+        invalid_strings = [
+            b"-----BEGIN PUBLIC KEY-----",
+            b"-----BEGIN RSA PUBLIC KEY-----",
+            b"-----BEGIN CERTIFICATE-----",
+            b"ssh-rsa",
+        ]
+
+        if any(string_value in key for string_value in invalid_strings):
+            raise JWKError(
+                "The specified key is an asymmetric key or x509 certificate and"
+                " should not be used as an HMAC secret."
+            )
+
+        self.prepared_key = key
+
+    def _process_jwk(self, jwk_dict):
+        if not jwk_dict.get("kty") == "oct":
+            raise JWKError("Incorrect key type. Expected: 'oct', Received: %s" % jwk_dict.get("kty"))
+
+        k = jwk_dict.get("k")
+        k = k.encode("utf-8")
+        k = bytes(k)
+        k = base64url_decode(k)
+
+        return k
+
+    def sign(self, msg):
+        return hmac.new(self.prepared_key, msg, self._hash_alg).digest()
+
+    def verify(self, msg, sig):
+        return hmac.compare_digest(sig, self.sign(msg))
+
+    def to_dict(self):
+        return {
+            "alg": self._algorithm,
+            "kty": "oct",
+            "k": base64url_encode(self.prepared_key).decode("ASCII"),
+        }
diff --git a/myenv/lib/python3.9/site-packages/jose/backends/rsa_backend.py b/myenv/lib/python3.9/site-packages/jose/backends/rsa_backend.py
new file mode 100644
index 0000000..4e8ccf1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/backends/rsa_backend.py
@@ -0,0 +1,284 @@
+import binascii
+import warnings
+
+import rsa as pyrsa
+import rsa.pem as pyrsa_pem
+from pyasn1.error import PyAsn1Error
+from rsa import DecryptionError
+
+from jose.backends._asn1 import (
+    rsa_private_key_pkcs1_to_pkcs8,
+    rsa_private_key_pkcs8_to_pkcs1,
+    rsa_public_key_pkcs1_to_pkcs8,
+)
+from jose.backends.base import Key
+from jose.constants import ALGORITHMS
+from jose.exceptions import JWEError, JWKError
+from jose.utils import base64_to_long, long_to_base64
+
+ALGORITHMS.SUPPORTED.remove(ALGORITHMS.RSA_OAEP)  # RSA OAEP not supported
+
+LEGACY_INVALID_PKCS8_RSA_HEADER = binascii.unhexlify(
+    "30"  # sequence
+    "8204BD"  # DER-encoded sequence contents length of 1213 bytes -- INCORRECT STATIC LENGTH
+    "020100"  # integer: 0 -- Version
+    "30"  # sequence
+    "0D"  # DER-encoded sequence contents length of 13 bytes -- PrivateKeyAlgorithmIdentifier
+    "06092A864886F70D010101"  # OID -- rsaEncryption
+    "0500"  # NULL -- parameters
+)
+ASN1_SEQUENCE_ID = binascii.unhexlify("30")
+RSA_ENCRYPTION_ASN1_OID = "1.2.840.113549.1.1.1"
+
+# Functions gcd and rsa_recover_prime_factors were copied from cryptography 1.9
+# to enable pure python rsa module to be in compliance with section 6.3.1 of RFC7518
+# which requires only private exponent (d) for private key.
+
+
+def _gcd(a, b):
+    """Calculate the Greatest Common Divisor of a and b.
+
+    Unless b==0, the result will have the same sign as b (so that when
+    b is divided by it, the result comes out positive).
+    """
+    while b:
+        a, b = b, (a % b)
+    return a
+
+
+# Controls the number of iterations rsa_recover_prime_factors will perform
+# to obtain the prime factors. Each iteration increments by 2 so the actual
+# maximum attempts is half this number.
+_MAX_RECOVERY_ATTEMPTS = 1000
+
+
+def _rsa_recover_prime_factors(n, e, d):
+    """
+    Compute factors p and q from the private exponent d. We assume that n has
+    no more than two factors. This function is adapted from code in PyCrypto.
+    """
+    # See 8.2.2(i) in Handbook of Applied Cryptography.
+    ktot = d * e - 1
+    # The quantity d*e-1 is a multiple of phi(n), even,
+    # and can be represented as t*2^s.
+    t = ktot
+    while t % 2 == 0:
+        t = t // 2
+    # Cycle through all multiplicative inverses in Zn.
+    # The algorithm is non-deterministic, but there is a 50% chance
+    # any candidate a leads to successful factoring.
+    # See "Digitalized Signatures and Public Key Functions as Intractable
+    # as Factorization", M. Rabin, 1979
+    spotted = False
+    a = 2
+    while not spotted and a < _MAX_RECOVERY_ATTEMPTS:
+        k = t
+        # Cycle through all values a^{t*2^i}=a^k
+        while k < ktot:
+            cand = pow(a, k, n)
+            # Check if a^k is a non-trivial root of unity (mod n)
+            if cand != 1 and cand != (n - 1) and pow(cand, 2, n) == 1:
+                # We have found a number such that (cand-1)(cand+1)=0 (mod n).
+                # Either of the terms divides n.
+                p = _gcd(cand + 1, n)
+                spotted = True
+                break
+            k *= 2
+        # This value was not any good... let's try another!
+        a += 2
+    if not spotted:
+        raise ValueError("Unable to compute factors p and q from exponent d.")
+    # Found !
+    q, r = divmod(n, p)
+    assert r == 0
+    p, q = sorted((p, q), reverse=True)
+    return (p, q)
+
+
+def pem_to_spki(pem, fmt="PKCS8"):
+    key = RSAKey(pem, ALGORITHMS.RS256)
+    return key.to_pem(fmt)
+
+
+def _legacy_private_key_pkcs8_to_pkcs1(pkcs8_key):
+    """Legacy RSA private key PKCS8-to-PKCS1 conversion.
+
+    .. warning::
+
+        This is incorrect parsing and only works because the legacy PKCS1-to-PKCS8
+        encoding was also incorrect.
+    """
+    # Only allow this processing if the prefix matches
+    # AND the following byte indicates an ASN1 sequence,
+    # as we would expect with the legacy encoding.
+    if not pkcs8_key.startswith(LEGACY_INVALID_PKCS8_RSA_HEADER + ASN1_SEQUENCE_ID):
+        raise ValueError("Invalid private key encoding")
+
+    return pkcs8_key[len(LEGACY_INVALID_PKCS8_RSA_HEADER) :]
+
+
+class RSAKey(Key):
+    SHA256 = "SHA-256"
+    SHA384 = "SHA-384"
+    SHA512 = "SHA-512"
+
+    def __init__(self, key, algorithm):
+        if algorithm not in ALGORITHMS.RSA:
+            raise JWKError("hash_alg: %s is not a valid hash algorithm" % algorithm)
+
+        if algorithm in ALGORITHMS.RSA_KW and algorithm != ALGORITHMS.RSA1_5:
+            raise JWKError("alg: %s is not supported by the RSA backend" % algorithm)
+
+        self.hash_alg = {
+            ALGORITHMS.RS256: self.SHA256,
+            ALGORITHMS.RS384: self.SHA384,
+            ALGORITHMS.RS512: self.SHA512,
+        }.get(algorithm)
+        self._algorithm = algorithm
+
+        if isinstance(key, dict):
+            self._prepared_key = self._process_jwk(key)
+            return
+
+        if isinstance(key, (pyrsa.PublicKey, pyrsa.PrivateKey)):
+            self._prepared_key = key
+            return
+
+        if isinstance(key, str):
+            key = key.encode("utf-8")
+
+        if isinstance(key, bytes):
+            try:
+                self._prepared_key = pyrsa.PublicKey.load_pkcs1(key)
+            except ValueError:
+                try:
+                    self._prepared_key = pyrsa.PublicKey.load_pkcs1_openssl_pem(key)
+                except ValueError:
+                    try:
+                        self._prepared_key = pyrsa.PrivateKey.load_pkcs1(key)
+                    except ValueError:
+                        try:
+                            der = pyrsa_pem.load_pem(key, b"PRIVATE KEY")
+                            try:
+                                pkcs1_key = rsa_private_key_pkcs8_to_pkcs1(der)
+                            except PyAsn1Error:
+                                # If the key was encoded using the old, invalid,
+                                # encoding then pyasn1 will throw an error attempting
+                                # to parse the key.
+                                pkcs1_key = _legacy_private_key_pkcs8_to_pkcs1(der)
+                            self._prepared_key = pyrsa.PrivateKey.load_pkcs1(pkcs1_key, format="DER")
+                        except ValueError as e:
+                            raise JWKError(e)
+            return
+        raise JWKError("Unable to parse an RSA_JWK from key: %s" % key)
+
+    def _process_jwk(self, jwk_dict):
+        if not jwk_dict.get("kty") == "RSA":
+            raise JWKError("Incorrect key type. Expected: 'RSA', Received: %s" % jwk_dict.get("kty"))
+
+        e = base64_to_long(jwk_dict.get("e"))
+        n = base64_to_long(jwk_dict.get("n"))
+
+        if "d" not in jwk_dict:
+            return pyrsa.PublicKey(e=e, n=n)
+        else:
+            d = base64_to_long(jwk_dict.get("d"))
+            extra_params = ["p", "q", "dp", "dq", "qi"]
+
+            if any(k in jwk_dict for k in extra_params):
+                # Precomputed private key parameters are available.
+                if not all(k in jwk_dict for k in extra_params):
+                    # These values must be present when 'p' is according to
+                    # Section 6.3.2 of RFC7518, so if they are not we raise
+                    # an error.
+                    raise JWKError("Precomputed private key parameters are incomplete.")
+
+                p = base64_to_long(jwk_dict["p"])
+                q = base64_to_long(jwk_dict["q"])
+                return pyrsa.PrivateKey(e=e, n=n, d=d, p=p, q=q)
+            else:
+                p, q = _rsa_recover_prime_factors(n, e, d)
+                return pyrsa.PrivateKey(n=n, e=e, d=d, p=p, q=q)
+
+    def sign(self, msg):
+        return pyrsa.sign(msg, self._prepared_key, self.hash_alg)
+
+    def verify(self, msg, sig):
+        if not self.is_public():
+            warnings.warn("Attempting to verify a message with a private key. " "This is not recommended.")
+        try:
+            pyrsa.verify(msg, sig, self._prepared_key)
+            return True
+        except pyrsa.pkcs1.VerificationError:
+            return False
+
+    def is_public(self):
+        return isinstance(self._prepared_key, pyrsa.PublicKey)
+
+    def public_key(self):
+        if isinstance(self._prepared_key, pyrsa.PublicKey):
+            return self
+        return self.__class__(pyrsa.PublicKey(n=self._prepared_key.n, e=self._prepared_key.e), self._algorithm)
+
+    def to_pem(self, pem_format="PKCS8"):
+
+        if isinstance(self._prepared_key, pyrsa.PrivateKey):
+            der = self._prepared_key.save_pkcs1(format="DER")
+            if pem_format == "PKCS8":
+                pkcs8_der = rsa_private_key_pkcs1_to_pkcs8(der)
+                pem = pyrsa_pem.save_pem(pkcs8_der, pem_marker="PRIVATE KEY")
+            elif pem_format == "PKCS1":
+                pem = pyrsa_pem.save_pem(der, pem_marker="RSA PRIVATE KEY")
+            else:
+                raise ValueError(f"Invalid pem format specified: {pem_format!r}")
+        else:
+            if pem_format == "PKCS8":
+                pkcs1_der = self._prepared_key.save_pkcs1(format="DER")
+                pkcs8_der = rsa_public_key_pkcs1_to_pkcs8(pkcs1_der)
+                pem = pyrsa_pem.save_pem(pkcs8_der, pem_marker="PUBLIC KEY")
+            elif pem_format == "PKCS1":
+                der = self._prepared_key.save_pkcs1(format="DER")
+                pem = pyrsa_pem.save_pem(der, pem_marker="RSA PUBLIC KEY")
+            else:
+                raise ValueError(f"Invalid pem format specified: {pem_format!r}")
+        return pem
+
+    def to_dict(self):
+        if not self.is_public():
+            public_key = self.public_key()._prepared_key
+        else:
+            public_key = self._prepared_key
+
+        data = {
+            "alg": self._algorithm,
+            "kty": "RSA",
+            "n": long_to_base64(public_key.n).decode("ASCII"),
+            "e": long_to_base64(public_key.e).decode("ASCII"),
+        }
+
+        if not self.is_public():
+            data.update(
+                {
+                    "d": long_to_base64(self._prepared_key.d).decode("ASCII"),
+                    "p": long_to_base64(self._prepared_key.p).decode("ASCII"),
+                    "q": long_to_base64(self._prepared_key.q).decode("ASCII"),
+                    "dp": long_to_base64(self._prepared_key.exp1).decode("ASCII"),
+                    "dq": long_to_base64(self._prepared_key.exp2).decode("ASCII"),
+                    "qi": long_to_base64(self._prepared_key.coef).decode("ASCII"),
+                }
+            )
+
+        return data
+
+    def wrap_key(self, key_data):
+        if not self.is_public():
+            warnings.warn("Attempting to encrypt a message with a private key." " This is not recommended.")
+        wrapped_key = pyrsa.encrypt(key_data, self._prepared_key)
+        return wrapped_key
+
+    def unwrap_key(self, wrapped_key):
+        try:
+            unwrapped_key = pyrsa.decrypt(wrapped_key, self._prepared_key)
+        except DecryptionError as e:
+            raise JWEError(e)
+        return unwrapped_key
diff --git a/myenv/lib/python3.9/site-packages/jose/constants.py b/myenv/lib/python3.9/site-packages/jose/constants.py
new file mode 100644
index 0000000..ab4d74d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/constants.py
@@ -0,0 +1,98 @@
+import hashlib
+
+
+class Algorithms:
+    # DS Algorithms
+    NONE = "none"
+    HS256 = "HS256"
+    HS384 = "HS384"
+    HS512 = "HS512"
+    RS256 = "RS256"
+    RS384 = "RS384"
+    RS512 = "RS512"
+    ES256 = "ES256"
+    ES384 = "ES384"
+    ES512 = "ES512"
+
+    # Content Encryption Algorithms
+    A128CBC_HS256 = "A128CBC-HS256"
+    A192CBC_HS384 = "A192CBC-HS384"
+    A256CBC_HS512 = "A256CBC-HS512"
+    A128GCM = "A128GCM"
+    A192GCM = "A192GCM"
+    A256GCM = "A256GCM"
+
+    # Pseudo algorithm for encryption
+    A128CBC = "A128CBC"
+    A192CBC = "A192CBC"
+    A256CBC = "A256CBC"
+
+    # CEK Encryption Algorithms
+    DIR = "dir"
+    RSA1_5 = "RSA1_5"
+    RSA_OAEP = "RSA-OAEP"
+    RSA_OAEP_256 = "RSA-OAEP-256"
+    A128KW = "A128KW"
+    A192KW = "A192KW"
+    A256KW = "A256KW"
+    ECDH_ES = "ECDH-ES"
+    ECDH_ES_A128KW = "ECDH-ES+A128KW"
+    ECDH_ES_A192KW = "ECDH-ES+A192KW"
+    ECDH_ES_A256KW = "ECDH-ES+A256KW"
+    A128GCMKW = "A128GCMKW"
+    A192GCMKW = "A192GCMKW"
+    A256GCMKW = "A256GCMKW"
+    PBES2_HS256_A128KW = "PBES2-HS256+A128KW"
+    PBES2_HS384_A192KW = "PBES2-HS384+A192KW"
+    PBES2_HS512_A256KW = "PBES2-HS512+A256KW"
+
+    # Compression Algorithms
+    DEF = "DEF"
+
+    HMAC = {HS256, HS384, HS512}
+    RSA_DS = {RS256, RS384, RS512}
+    RSA_KW = {RSA1_5, RSA_OAEP, RSA_OAEP_256}
+    RSA = RSA_DS.union(RSA_KW)
+    EC_DS = {ES256, ES384, ES512}
+    EC_KW = {ECDH_ES, ECDH_ES_A128KW, ECDH_ES_A192KW, ECDH_ES_A256KW}
+    EC = EC_DS.union(EC_KW)
+    AES_PSEUDO = {A128CBC, A192CBC, A256CBC, A128GCM, A192GCM, A256GCM}
+    AES_JWE_ENC = {A128CBC_HS256, A192CBC_HS384, A256CBC_HS512, A128GCM, A192GCM, A256GCM}
+    AES_ENC = AES_JWE_ENC.union(AES_PSEUDO)
+    AES_KW = {A128KW, A192KW, A256KW}
+    AEC_GCM_KW = {A128GCMKW, A192GCMKW, A256GCMKW}
+    AES = AES_ENC.union(AES_KW)
+    PBES2_KW = {PBES2_HS256_A128KW, PBES2_HS384_A192KW, PBES2_HS512_A256KW}
+
+    HMAC_AUTH_TAG = {A128CBC_HS256, A192CBC_HS384, A256CBC_HS512}
+    GCM = {A128GCM, A192GCM, A256GCM}
+
+    SUPPORTED = HMAC.union(RSA_DS).union(EC_DS).union([DIR]).union(AES_JWE_ENC).union(RSA_KW).union(AES_KW)
+
+    ALL = SUPPORTED.union([NONE]).union(AEC_GCM_KW).union(EC_KW).union(PBES2_KW)
+
+    HASHES = {
+        HS256: hashlib.sha256,
+        HS384: hashlib.sha384,
+        HS512: hashlib.sha512,
+        RS256: hashlib.sha256,
+        RS384: hashlib.sha384,
+        RS512: hashlib.sha512,
+        ES256: hashlib.sha256,
+        ES384: hashlib.sha384,
+        ES512: hashlib.sha512,
+    }
+
+    KEYS = {}
+
+
+ALGORITHMS = Algorithms()
+
+
+class Zips:
+    DEF = "DEF"
+    NONE = None
+    SUPPORTED = {DEF, NONE}
+
+
+ZIPS = Zips()
diff --git a/myenv/lib/python3.9/site-packages/jose/exceptions.py b/myenv/lib/python3.9/site-packages/jose/exceptions.py
new file mode 100644
index 0000000..e8edc3b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/exceptions.py
@@ -0,0 +1,59 @@
+class JOSEError(Exception):
+    pass
+
+
+class JWSError(JOSEError):
+    pass
+
+
+class JWSSignatureError(JWSError):
+    pass
+
+
+class JWSAlgorithmError(JWSError):
+    pass
+
+
+class JWTError(JOSEError):
+    pass
+
+
+class JWTClaimsError(JWTError):
+    pass
+
+
+class ExpiredSignatureError(JWTError):
+    pass
+
+
+class JWKError(JOSEError):
+    pass
+
+
+class JWEError(JOSEError):
+    """Base error for all JWE errors"""
+
+    pass
+
+
+class JWEParseError(JWEError):
+    """Could not parse the JWE string provided"""
+
+    pass
+
+
+class JWEInvalidAuth(JWEError):
+    """
+    The authentication tag did not match the protected sections of the
+    JWE string provided
+    """
+
+    pass
+
+
+class JWEAlgorithmUnsupportedError(JWEError):
+    """
+    The JWE algorithm is not supported by the backend
+    """
+
+    pass
diff --git a/myenv/lib/python3.9/site-packages/jose/jwe.py b/myenv/lib/python3.9/site-packages/jose/jwe.py
new file mode 100644
index 0000000..2c387ff
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/jwe.py
@@ -0,0 +1,607 @@
+import binascii
+import json
+import zlib
+from collections.abc import Mapping
+from struct import pack
+
+from . import jwk
+from .backends import get_random_bytes
+from .constants import ALGORITHMS, ZIPS
+from .exceptions import JWEError, JWEParseError
+from .utils import base64url_decode, base64url_encode, ensure_binary
+
+
+def encrypt(plaintext, key, encryption=ALGORITHMS.A256GCM, algorithm=ALGORITHMS.DIR, zip=None, cty=None, kid=None):
+    """Encrypts plaintext and returns a JWE cmpact serialization string.
+
+    Args:
+        plaintext (bytes): A bytes object to encrypt
+        key (str or dict): The key(s) to use for encrypting the content. Can be
+            individual JWK or JWK set.
+        encryption (str, optional): The content encryption algorithm used to
+            perform authenticated encryption on the plaintext to produce the
+            ciphertext and the Authentication Tag.  Defaults to A256GCM.
+        algorithm (str, optional): The cryptographic algorithm used
+            to encrypt or determine the value of the CEK.  Defaults to dir.
+        zip (str, optional): The compression algorithm) applied to the
+            plaintext before encryption. Defaults to None.
+        cty (str, optional): The media type for the secured content.
+            See http://www.iana.org/assignments/media-types/media-types.xhtml
+        kid (str, optional): Key ID for the provided key
+
+    Returns:
+        bytes: The string representation of the header, encrypted key,
+            initialization vector, ciphertext, and authentication tag.
+
+    Raises:
+        JWEError: If there is an error signing the token.
+
+    Examples:
+        >>> from jose import jwe
+        >>> jwe.encrypt('Hello, World!', 'asecret128bitkey', algorithm='dir', encryption='A128GCM')
+        'eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4R0NNIn0..McILMB3dYsNJSuhcDzQshA.OfX9H_mcUpHDeRM4IA.CcnTWqaqxNsjT4eCaUABSg'
+
+    """
+    plaintext = ensure_binary(plaintext)  # Make sure it's bytes
+    if algorithm not in ALGORITHMS.SUPPORTED:
+        raise JWEError("Algorithm %s not supported." % algorithm)
+    if encryption not in ALGORITHMS.SUPPORTED:
+        raise JWEError("Algorithm %s not supported." % encryption)
+    key = jwk.construct(key, algorithm)
+    encoded_header = _encoded_header(algorithm, encryption, zip, cty, kid)
+
+    plaintext = _compress(zip, plaintext)
+    enc_cek, iv, cipher_text, auth_tag = _encrypt_and_auth(key, algorithm, encryption, zip, plaintext, encoded_header)
+
+    jwe_string = _jwe_compact_serialize(encoded_header, enc_cek, iv, cipher_text, auth_tag)
+    return jwe_string
+
+
+def decrypt(jwe_str, key):
+    """Decrypts a JWE compact serialized string and returns the plaintext.
+
+    Args:
+        jwe_str (str): A JWE to be decrypt.
+        key (str or dict): A key to attempt to decrypt the payload with. Can be
+            individual JWK or JWK set.
+
+    Returns:
+        bytes: The plaintext bytes, assuming the authentication tag is valid.
+
+    Raises:
+        JWEError: If there is an exception verifying the token.
+
+    Examples:
+        >>> from jose import jwe
+        >>> jwe.decrypt(jwe_string, 'asecret128bitkey')
+        'Hello, World!'
+    """
+    header, encoded_header, encrypted_key, iv, cipher_text, auth_tag = _jwe_compact_deserialize(jwe_str)
+
+    # Verify that the implementation understands and can process all
+    # fields that it is required to support, whether required by this
+    # specification, by the algorithms being used, or by the "crit"
+    # Header Parameter value, and that the values of those parameters
+    # are also understood and supported.
+
+    try:
+        # Determine the Key Management Mode employed by the algorithm
+        # specified by the "alg" (algorithm) Header Parameter.
+        alg = header["alg"]
+        enc = header["enc"]
+        if alg not in ALGORITHMS.SUPPORTED:
+            raise JWEError("Algorithm %s not supported." % alg)
+        if enc not in ALGORITHMS.SUPPORTED:
+            raise JWEError("Algorithm %s not supported." % enc)
+
+    except KeyError:
+        raise JWEParseError("alg and enc headers are required!")
+
+    # Verify that the JWE uses a key known to the recipient.
+    key = jwk.construct(key, alg)
+
+    # When Direct Key Agreement or Key Agreement with Key Wrapping are
+    # employed, use the key agreement algorithm to compute the value
+    # of the agreed upon key.  When Direct Key Agreement is employed,
+    # let the CEK be the agreed upon key.  When Key Agreement with Key
+    # Wrapping is employed, the agreed upon key will be used to
+    # decrypt the JWE Encrypted Key.
+    #
+    # When Key Wrapping, Key Encryption, or Key Agreement with Key
+    # Wrapping are employed, decrypt the JWE Encrypted Key to produce
+    # the CEK.  The CEK MUST have a length equal to that required for
+    # the content encryption algorithm.  Note that when there are
+    # multiple recipients, each recipient will only be able to decrypt
+    # JWE Encrypted Key values that were encrypted to a key in that
+    # recipient's possession.  It is therefore normal to only be able
+    # to decrypt one of the per-recipient JWE Encrypted Key values to
+    # obtain the CEK value.  Also, see Section 11.5 for security
+    # considerations on mitigating timing attacks.
+    if alg == ALGORITHMS.DIR:
+        # When Direct Key Agreement or Direct Encryption are employed,
+        # verify that the JWE Encrypted Key value is an empty octet
+        # sequence.
+
+        # Record whether the CEK could be successfully determined for this
+        # recipient or not.
+        cek_valid = encrypted_key == b""
+
+        # When Direct Encryption is employed, let the CEK be the shared
+        # symmetric key.
+        cek_bytes = _get_key_bytes_from_key(key)
+    else:
+        try:
+            cek_bytes = key.unwrap_key(encrypted_key)
+
+            # Record whether the CEK could be successfully determined for this
+            # recipient or not.
+            cek_valid = True
+        except NotImplementedError:
+            raise JWEError(f"alg {alg} is not implemented")
+        except Exception:
+            # Record whether the CEK could be successfully determined for this
+            # recipient or not.
+            cek_valid = False
+
+            # To mitigate the attacks described in RFC 3218 [RFC3218], the
+            # recipient MUST NOT distinguish between format, padding, and length
+            # errors of encrypted keys.  It is strongly recommended, in the event
+            # of receiving an improperly formatted key, that the recipient
+            # substitute a randomly generated CEK and proceed to the next step, to
+            # mitigate timing attacks.
+            cek_bytes = _get_random_cek_bytes_for_enc(enc)
+
+    # Compute the Encoded Protected Header value BASE64URL(UTF8(JWE
+    # Protected Header)).  If the JWE Protected Header is not present
+    # (which can only happen when using the JWE JSON Serialization and
+    # no "protected" member is present), let this value be the empty
+    # string.
+    protected_header = encoded_header
+
+    # Let the Additional Authenticated Data encryption parameter be
+    # ASCII(Encoded Protected Header).  However, if a JWE AAD value is
+    # present (which can only be the case when using the JWE JSON
+    # Serialization), instead let the Additional Authenticated Data
+    # encryption parameter be ASCII(Encoded Protected Header || '.' ||
+    # BASE64URL(JWE AAD)).
+    aad = protected_header
+
+    # Decrypt the JWE Ciphertext using the CEK, the JWE Initialization
+    # Vector, the Additional Authenticated Data value, and the JWE
+    # Authentication Tag (which is the Authentication Tag input to the
+    # calculation) using the specified content encryption algorithm,
+    # returning the decrypted plaintext and validating the JWE
+    # Authentication Tag in the manner specified for the algorithm,
+    # rejecting the input without emitting any decrypted output if the
+    # JWE Authentication Tag is incorrect.
+    try:
+        plain_text = _decrypt_and_auth(cek_bytes, enc, cipher_text, iv, aad, auth_tag)
+    except NotImplementedError:
+        raise JWEError(f"enc {enc} is not implemented")
+    except Exception as e:
+        raise JWEError(e)
+
+    # If a "zip" parameter was included, uncompress the decrypted
+    # plaintext using the specified compression algorithm.
+    if plain_text is not None:
+        plain_text = _decompress(header.get("zip"), plain_text)
+
+    return plain_text if cek_valid else None
+
+
+def get_unverified_header(jwe_str):
+    """Returns the decoded headers without verification of any kind.
+
+    Args:
+        jwe_str (str): A compact serialized JWE to decode the headers from.
+
+    Returns:
+        dict: The dict representation of the JWE headers.
+
+    Raises:
+        JWEError: If there is an exception decoding the JWE.
+    """
+    header = _jwe_compact_deserialize(jwe_str)[0]
+    return header
+
+
+def _decrypt_and_auth(cek_bytes, enc, cipher_text, iv, aad, auth_tag):
+    """
+    Decrypt and verify the data
+
+    Args:
+        cek_bytes (bytes): cek to derive encryption and possible auth key to
+            verify the auth tag
+        cipher_text (bytes): Encrypted data
+        iv (bytes): Initialization vector (iv) used to encrypt data
+        aad (bytes): Additional Authenticated Data used to verify the data
+        auth_tag (bytes): Authentication ntag to verify the data
+
+    Returns:
+        (bytes): Decrypted data
+    """
+    # Decrypt the JWE Ciphertext using the CEK, the JWE Initialization
+    # Vector, the Additional Authenticated Data value, and the JWE
+    # Authentication Tag (which is the Authentication Tag input to the
+    # calculation) using the specified content encryption algorithm,
+    # returning the decrypted plaintext
+    # and validating the JWE
+    # Authentication Tag in the manner specified for the algorithm,
+    if enc in ALGORITHMS.HMAC_AUTH_TAG:
+        encryption_key, mac_key, key_len = _get_encryption_key_mac_key_and_key_length_from_cek(cek_bytes, enc)
+        auth_tag_check = _auth_tag(cipher_text, iv, aad, mac_key, key_len)
+    elif enc in ALGORITHMS.GCM:
+        encryption_key = jwk.construct(cek_bytes, enc)
+        auth_tag_check = auth_tag  # GCM check auth on decrypt
+    else:
+        raise NotImplementedError(f"enc {enc} is not implemented!")
+
+    plaintext = encryption_key.decrypt(cipher_text, iv, aad, auth_tag)
+    if auth_tag != auth_tag_check:
+        raise JWEError("Invalid JWE Auth Tag")
+
+    return plaintext
+
+
+def _get_encryption_key_mac_key_and_key_length_from_cek(cek_bytes, enc):
+    derived_key_len = len(cek_bytes) // 2
+    mac_key_bytes = cek_bytes[0:derived_key_len]
+    mac_key = _get_hmac_key(enc, mac_key_bytes)
+    encryption_key_bytes = cek_bytes[-derived_key_len:]
+    encryption_alg, _ = enc.split("-")
+    encryption_key = jwk.construct(encryption_key_bytes, encryption_alg)
+    return encryption_key, mac_key, derived_key_len
+
+
+def _jwe_compact_deserialize(jwe_bytes):
+    """
+    Deserialize and verify the header and segments are appropriate.
+
+    Args:
+        jwe_bytes (bytes): The compact serialized JWE
+    Returns:
+        (dict, bytes, bytes, bytes, bytes, bytes)
+    """
+
+    # Base64url decode the encoded representations of the JWE
+    # Protected Header, the JWE Encrypted Key, the JWE Initialization
+    # Vector, the JWE Ciphertext, the JWE Authentication Tag, and the
+    # JWE AAD, following the restriction that no line breaks,
+    # whitespace, or other additional characters have been used.
+    jwe_bytes = ensure_binary(jwe_bytes)
+    try:
+        header_segment, encrypted_key_segment, iv_segment, cipher_text_segment, auth_tag_segment = jwe_bytes.split(
+            b".", 4
+        )
+        header_data = base64url_decode(header_segment)
+    except ValueError:
+        raise JWEParseError("Not enough segments")
+    except (TypeError, binascii.Error):
+        raise JWEParseError("Invalid header")
+
+    # Verify that the octet sequence resulting from decoding the
+    # encoded JWE Protected Header is a UTF-8-encoded representation
+    # of a completely valid JSON object conforming to RFC 7159
+    # [RFC7159]; let the JWE Protected Header be this JSON object.
+    #
+    # If using the JWE Compact Serialization, let the JOSE Header be
+    # the JWE Protected Header.  Otherwise, when using the JWE JSON
+    # Serialization, let the JOSE Header be the union of the members
+    # of the JWE Protected Header, the JWE Shared Unprotected Header
+    # and the corresponding JWE Per-Recipient Unprotected Header, all
+    # of which must be completely valid JSON objects.  During this
+    # step, verify that the resulting JOSE Header does not contain
+    # duplicate Header Parameter names.  When using the JWE JSON
+    # Serialization, this restriction includes that the same Header
+    # Parameter name also MUST NOT occur in distinct JSON object
+    # values that together comprise the JOSE Header.
+
+    try:
+        header = json.loads(header_data)
+    except ValueError as e:
+        raise JWEParseError(f"Invalid header string: {e}")
+
+    if not isinstance(header, Mapping):
+        raise JWEParseError("Invalid header string: must be a json object")
+
+    try:
+        encrypted_key = base64url_decode(encrypted_key_segment)
+    except (TypeError, binascii.Error):
+        raise JWEParseError("Invalid encrypted key")
+
+    try:
+        iv = base64url_decode(iv_segment)
+    except (TypeError, binascii.Error):
+        raise JWEParseError("Invalid IV")
+
+    try:
+        ciphertext = base64url_decode(cipher_text_segment)
+    except (TypeError, binascii.Error):
+        raise JWEParseError("Invalid cyphertext")
+
+    try:
+        auth_tag = base64url_decode(auth_tag_segment)
+    except (TypeError, binascii.Error):
+        raise JWEParseError("Invalid auth tag")
+
+    return header, header_segment, encrypted_key, iv, ciphertext, auth_tag
+
+
+def _encoded_header(alg, enc, zip, cty, kid):
+    """
+    Generate an appropriate JOSE header based on the values provided
+    Args:
+        alg (str): Key wrap/negotiation algorithm
+        enc (str): Encryption algorithm
+        zip (str): Compression method
+        cty (str): Content type of the encrypted data
+        kid (str): ID for the key used for the operation
+
+    Returns:
+        bytes: JSON object of header based on input
+    """
+    header = {"alg": alg, "enc": enc}
+    if zip:
+        header["zip"] = zip
+    if cty:
+        header["cty"] = cty
+    if kid:
+        header["kid"] = kid
+    json_header = json.dumps(
+        header,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+    return base64url_encode(json_header)
+
+
+def _big_endian(int_val):
+    return pack("!Q", int_val)
+
+
+def _encrypt_and_auth(key, alg, enc, zip, plaintext, aad):
+    """
+    Generate a content encryption key (cek) and initialization
+    vector (iv) based on enc and alg, compress the plaintext based on zip,
+    encrypt the compressed plaintext using the cek and iv based on enc
+
+    Args:
+        key (Key): The key provided for encryption
+        alg (str): The algorithm use for key wrap/negotiation
+        enc (str): The encryption algorithm with which to encrypt the plaintext
+        zip (str): The compression algorithm with which to compress the plaintext
+        plaintext (bytes): The data to encrypt
+        aad (str): Additional authentication data utilized for generating an
+                    auth tag
+
+    Returns:
+          (bytes, bytes, bytes, bytes): A tuple of the following data
+                                 (key wrapped cek, iv, cipher text, auth tag)
+    """
+    try:
+        cek_bytes, kw_cek = _get_cek(enc, alg, key)
+    except NotImplementedError:
+        raise JWEError(f"alg {alg} is not implemented")
+
+    if enc in ALGORITHMS.HMAC_AUTH_TAG:
+        encryption_key, mac_key, key_len = _get_encryption_key_mac_key_and_key_length_from_cek(cek_bytes, enc)
+        iv, ciphertext, tag = encryption_key.encrypt(plaintext, aad)
+        auth_tag = _auth_tag(ciphertext, iv, aad, mac_key, key_len)
+    elif enc in ALGORITHMS.GCM:
+        encryption_key = jwk.construct(cek_bytes, enc)
+        iv, ciphertext, auth_tag = encryption_key.encrypt(plaintext, aad)
+    else:
+        raise NotImplementedError(f"enc {enc} is not implemented!")
+
+    return kw_cek, iv, ciphertext, auth_tag
+
+
+def _get_hmac_key(enc, mac_key_bytes):
+    """
+    Get an HMACKey for the provided encryption algorithm and key bytes
+
+    Args:
+        enc (str): Encryption algorithm
+        mac_key_bytes (bytes): vytes for the HMAC key
+
+    Returns:
+         (HMACKey): The key to perform HMAC actions
+    """
+    _, hash_alg = enc.split("-")
+    mac_key = jwk.construct(mac_key_bytes, hash_alg)
+    return mac_key
+
+
+def _compress(zip, plaintext):
+    """
+    Compress the plaintext based on the algorithm supplied
+
+    Args:
+        zip (str): Compression Algorithm
+        plaintext (bytes): plaintext to compress
+
+    Returns:
+        (bytes): Compressed plaintext
+    """
+    if zip not in ZIPS.SUPPORTED:
+        raise NotImplementedError("ZIP {} is not supported!")
+    if zip is None:
+        compressed = plaintext
+    elif zip == ZIPS.DEF:
+        compressed = zlib.compress(plaintext)
+    else:
+        raise NotImplementedError("ZIP {} is not implemented!")
+    return compressed
+
+
+def _decompress(zip, compressed):
+    """
+    Decompress the plaintext based on the algorithm supplied
+
+    Args:
+        zip (str): Compression Algorithm
+        plaintext (bytes): plaintext to decompress
+
+    Returns:
+        (bytes): Compressed plaintext
+    """
+    if zip not in ZIPS.SUPPORTED:
+        raise NotImplementedError("ZIP {} is not supported!")
+    if zip is None:
+        decompressed = compressed
+    elif zip == ZIPS.DEF:
+        decompressed = zlib.decompress(compressed)
+    else:
+        raise NotImplementedError("ZIP {} is not implemented!")
+    return decompressed
+
+
+def _get_cek(enc, alg, key):
+    """
+    Get the content encryption key
+
+    Args:
+        enc (str): Encryption algorithm
+        alg (str): kwy wrap/negotiation algorithm
+        key (Key): Key provided to encryption method
+
+    Return:
+        (bytes, bytes): Tuple of (cek bytes and wrapped cek)
+    """
+    if alg == ALGORITHMS.DIR:
+        cek, wrapped_cek = _get_direct_key_wrap_cek(key)
+    else:
+        cek, wrapped_cek = _get_key_wrap_cek(enc, key)
+
+    return cek, wrapped_cek
+
+
+def _get_direct_key_wrap_cek(key):
+    """
+    Get the cek and wrapped cek from the encryption key direct
+
+    Args:
+        key (Key): Key provided to encryption method
+
+    Return:
+        (Key, bytes): Tuple of (cek Key object and wrapped cek)
+    """
+    # Get the JWK data to determine how to derive the cek
+    jwk_data = key.to_dict()
+    if jwk_data["kty"] == "oct":
+        # Get the last half of an octal key as the cek
+        cek_bytes = _get_key_bytes_from_key(key)
+        wrapped_cek = b""
+    else:
+        raise NotImplementedError("JWK type {} not supported!".format(jwk_data["kty"]))
+    return cek_bytes, wrapped_cek
+
+
+def _get_key_bytes_from_key(key):
+    """
+    Get the raw key bytes from a Key object
+
+    Args:
+        key (Key): Key from which to extract the raw key bytes
+    Returns:
+        (bytes) key data
+    """
+    jwk_data = key.to_dict()
+    encoded_key = jwk_data["k"]
+    cek_bytes = base64url_decode(encoded_key)
+    return cek_bytes
+
+
+def _get_key_wrap_cek(enc, key):
+    """_get_rsa_key_wrap_cek
+    Get the content encryption key for RSA key wrap
+
+    Args:
+        enc (str): Encryption algorithm
+        key (Key): Key provided to encryption method
+
+    Returns:
+        (Key, bytes): Tuple of (cek Key object and wrapped cek)
+    """
+    cek_bytes = _get_random_cek_bytes_for_enc(enc)
+    wrapped_cek = key.wrap_key(cek_bytes)
+    return cek_bytes, wrapped_cek
+
+
+def _get_random_cek_bytes_for_enc(enc):
+    """
+    Get the random cek bytes based on the encryptionn algorithm
+
+    Args:
+        enc (str): Encryption algorithm
+
+    Returns:
+        (bytes) random bytes for cek key
+    """
+    if enc == ALGORITHMS.A128GCM:
+        num_bits = 128
+    elif enc == ALGORITHMS.A192GCM:
+        num_bits = 192
+    elif enc in (ALGORITHMS.A128CBC_HS256, ALGORITHMS.A256GCM):
+        num_bits = 256
+    elif enc == ALGORITHMS.A192CBC_HS384:
+        num_bits = 384
+    elif enc == ALGORITHMS.A256CBC_HS512:
+        num_bits = 512
+    else:
+        raise NotImplementedError(f"{enc} not supported")
+    cek_bytes = get_random_bytes(num_bits // 8)
+    return cek_bytes
+
+
+def _auth_tag(ciphertext, iv, aad, mac_key, tag_length):
+    """
+    Get ann auth tag from the provided data
+
+    Args:
+        ciphertext (bytes): Encrypted value
+        iv (bytes): Initialization vector
+        aad (bytes): Additional Authenticated Data
+        mac_key (bytes): Key to use in generating the MAC
+        tag_length (int): How log the tag should be
+
+    Returns:
+        (bytes) Auth tag
+    """
+    al = _big_endian(len(aad) * 8)
+    auth_tag_input = aad + iv + ciphertext + al
+    signature = mac_key.sign(auth_tag_input)
+    auth_tag = signature[0:tag_length]
+    return auth_tag
+
+
+def _jwe_compact_serialize(encoded_header, encrypted_cek, iv, cipher_text, auth_tag):
+    """
+    Generate a compact serialized JWE
+
+    Args:
+        encoded_header (bytes): Base64 URL Encoded JWE header JSON
+        encrypted_cek (bytes): Encrypted content encryption key (cek)
+        iv (bytes): Initialization vector (IV)
+        cipher_text (bytes): Cipher text
+        auth_tag (bytes): JWE Auth Tag
+
+    Returns:
+        (str): JWE compact serialized string
+    """
+    cipher_text = ensure_binary(cipher_text)
+    encoded_encrypted_cek = base64url_encode(encrypted_cek)
+    encoded_iv = base64url_encode(iv)
+    encoded_cipher_text = base64url_encode(cipher_text)
+    encoded_auth_tag = base64url_encode(auth_tag)
+    return (
+        encoded_header
+        + b"."
+        + encoded_encrypted_cek
+        + b"."
+        + encoded_iv
+        + b"."
+        + encoded_cipher_text
+        + b"."
+        + encoded_auth_tag
+    )
diff --git a/myenv/lib/python3.9/site-packages/jose/jwk.py b/myenv/lib/python3.9/site-packages/jose/jwk.py
new file mode 100644
index 0000000..7afc054
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/jwk.py
@@ -0,0 +1,79 @@
+from jose.backends.base import Key
+from jose.constants import ALGORITHMS
+from jose.exceptions import JWKError
+
+try:
+    from jose.backends import RSAKey  # noqa: F401
+except ImportError:
+    pass
+
+try:
+    from jose.backends import ECKey  # noqa: F401
+except ImportError:
+    pass
+
+try:
+    from jose.backends import AESKey  # noqa: F401
+except ImportError:
+    pass
+
+try:
+    from jose.backends import DIRKey  # noqa: F401
+except ImportError:
+    pass
+
+try:
+    from jose.backends import HMACKey  # noqa: F401
+except ImportError:
+    pass
+
+
+def get_key(algorithm):
+    if algorithm in ALGORITHMS.KEYS:
+        return ALGORITHMS.KEYS[algorithm]
+    elif algorithm in ALGORITHMS.HMAC:  # noqa: F811
+        return HMACKey
+    elif algorithm in ALGORITHMS.RSA:
+        from jose.backends import RSAKey  # noqa: F811
+
+        return RSAKey
+    elif algorithm in ALGORITHMS.EC:
+        from jose.backends import ECKey  # noqa: F811
+
+        return ECKey
+    elif algorithm in ALGORITHMS.AES:
+        from jose.backends import AESKey  # noqa: F811
+
+        return AESKey
+    elif algorithm == ALGORITHMS.DIR:
+        from jose.backends import DIRKey  # noqa: F811
+
+        return DIRKey
+    return None
+
+
+def register_key(algorithm, key_class):
+    if not issubclass(key_class, Key):
+        raise TypeError("Key class is not a subclass of jwk.Key")
+    ALGORITHMS.KEYS[algorithm] = key_class
+    ALGORITHMS.SUPPORTED.add(algorithm)
+    return True
+
+
+def construct(key_data, algorithm=None):
+    """
+    Construct a Key object for the given algorithm with the given
+    key_data.
+    """
+
+    # Allow for pulling the algorithm off of the passed in jwk.
+    if not algorithm and isinstance(key_data, dict):
+        algorithm = key_data.get("alg", None)
+
+    if not algorithm:
+        raise JWKError("Unable to find an algorithm for key: %s" % key_data)
+
+    key_class = get_key(algorithm)
+    if not key_class:
+        raise JWKError("Unable to find an algorithm for key: %s" % key_data)
+    return key_class(key_data, algorithm)
diff --git a/myenv/lib/python3.9/site-packages/jose/jws.py b/myenv/lib/python3.9/site-packages/jose/jws.py
new file mode 100644
index 0000000..bfaf6bd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/jws.py
@@ -0,0 +1,266 @@
+import binascii
+import json
+from collections.abc import Iterable, Mapping
+
+from jose import jwk
+from jose.backends.base import Key
+from jose.constants import ALGORITHMS
+from jose.exceptions import JWSError, JWSSignatureError
+from jose.utils import base64url_decode, base64url_encode
+
+
+def sign(payload, key, headers=None, algorithm=ALGORITHMS.HS256):
+    """Signs a claims set and returns a JWS string.
+
+    Args:
+        payload (str or dict): A string to sign
+        key (str or dict): The key to use for signing the claim set. Can be
+            individual JWK or JWK set.
+        headers (dict, optional): A set of headers that will be added to
+            the default headers.  Any headers that are added as additional
+            headers will override the default headers.
+        algorithm (str, optional): The algorithm to use for signing the
+            the claims.  Defaults to HS256.
+
+    Returns:
+        str: The string representation of the header, claims, and signature.
+
+    Raises:
+        JWSError: If there is an error signing the token.
+
+    Examples:
+
+        >>> jws.sign({'a': 'b'}, 'secret', algorithm='HS256')
+        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhIjoiYiJ9.jiMyrsmD8AoHWeQgmxZ5yq8z0lXS67_QGs52AzC8Ru8'
+
+    """
+
+    if algorithm not in ALGORITHMS.SUPPORTED:
+        raise JWSError("Algorithm %s not supported." % algorithm)
+
+    encoded_header = _encode_header(algorithm, additional_headers=headers)
+    encoded_payload = _encode_payload(payload)
+    signed_output = _sign_header_and_claims(encoded_header, encoded_payload, algorithm, key)
+
+    return signed_output
+
+
+def verify(token, key, algorithms, verify=True):
+    """Verifies a JWS string's signature.
+
+    Args:
+        token (str): A signed JWS to be verified.
+        key (str or dict): A key to attempt to verify the payload with. Can be
+            individual JWK or JWK set.
+        algorithms (str or list): Valid algorithms that should be used to verify the JWS.
+
+    Returns:
+        str: The str representation of the payload, assuming the signature is valid.
+
+    Raises:
+        JWSError: If there is an exception verifying a token.
+
+    Examples:
+
+        >>> token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhIjoiYiJ9.jiMyrsmD8AoHWeQgmxZ5yq8z0lXS67_QGs52AzC8Ru8'
+        >>> jws.verify(token, 'secret', algorithms='HS256')
+
+    """
+
+    header, payload, signing_input, signature = _load(token)
+
+    if verify:
+        _verify_signature(signing_input, header, signature, key, algorithms)
+
+    return payload
+
+
+def get_unverified_header(token):
+    """Returns the decoded headers without verification of any kind.
+
+    Args:
+        token (str): A signed JWS to decode the headers from.
+
+    Returns:
+        dict: The dict representation of the token headers.
+
+    Raises:
+        JWSError: If there is an exception decoding the token.
+    """
+    header, claims, signing_input, signature = _load(token)
+    return header
+
+
+def get_unverified_headers(token):
+    """Returns the decoded headers without verification of any kind.
+
+    This is simply a wrapper of get_unverified_header() for backwards
+    compatibility.
+
+    Args:
+        token (str): A signed JWS to decode the headers from.
+
+    Returns:
+        dict: The dict representation of the token headers.
+
+    Raises:
+        JWSError: If there is an exception decoding the token.
+    """
+    return get_unverified_header(token)
+
+
+def get_unverified_claims(token):
+    """Returns the decoded claims without verification of any kind.
+
+    Args:
+        token (str): A signed JWS to decode the headers from.
+
+    Returns:
+        str: The str representation of the token claims.
+
+    Raises:
+        JWSError: If there is an exception decoding the token.
+    """
+    header, claims, signing_input, signature = _load(token)
+    return claims
+
+
+def _encode_header(algorithm, additional_headers=None):
+    header = {"typ": "JWT", "alg": algorithm}
+
+    if additional_headers:
+        header.update(additional_headers)
+
+    json_header = json.dumps(
+        header,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+
+    return base64url_encode(json_header)
+
+
+def _encode_payload(payload):
+    if isinstance(payload, Mapping):
+        try:
+            payload = json.dumps(
+                payload,
+                separators=(",", ":"),
+            ).encode("utf-8")
+        except ValueError:
+            pass
+
+    return base64url_encode(payload)
+
+
+def _sign_header_and_claims(encoded_header, encoded_claims, algorithm, key):
+    signing_input = b".".join([encoded_header, encoded_claims])
+    try:
+        if not isinstance(key, Key):
+            key = jwk.construct(key, algorithm)
+        signature = key.sign(signing_input)
+    except Exception as e:
+        raise JWSError(e)
+
+    encoded_signature = base64url_encode(signature)
+
+    encoded_string = b".".join([encoded_header, encoded_claims, encoded_signature])
+
+    return encoded_string.decode("utf-8")
+
+
+def _load(jwt):
+    if isinstance(jwt, str):
+        jwt = jwt.encode("utf-8")
+    try:
+        signing_input, crypto_segment = jwt.rsplit(b".", 1)
+        header_segment, claims_segment = signing_input.split(b".", 1)
+        header_data = base64url_decode(header_segment)
+    except ValueError:
+        raise JWSError("Not enough segments")
+    except (TypeError, binascii.Error):
+        raise JWSError("Invalid header padding")
+
+    try:
+        header = json.loads(header_data.decode("utf-8"))
+    except ValueError as e:
+        raise JWSError("Invalid header string: %s" % e)
+
+    if not isinstance(header, Mapping):
+        raise JWSError("Invalid header string: must be a json object")
+
+    try:
+        payload = base64url_decode(claims_segment)
+    except (TypeError, binascii.Error):
+        raise JWSError("Invalid payload padding")
+
+    try:
+        signature = base64url_decode(crypto_segment)
+    except (TypeError, binascii.Error):
+        raise JWSError("Invalid crypto padding")
+
+    return (header, payload, signing_input, signature)
+
+
+def _sig_matches_keys(keys, signing_input, signature, alg):
+    for key in keys:
+        if not isinstance(key, Key):
+            key = jwk.construct(key, alg)
+        try:
+            if key.verify(signing_input, signature):
+                return True
+        except Exception:
+            pass
+    return False
+
+
+def _get_keys(key):
+
+    if isinstance(key, Key):
+        return (key,)
+
+    try:
+        key = json.loads(key, parse_int=str, parse_float=str)
+    except Exception:
+        pass
+
+    if isinstance(key, Mapping):
+        if "keys" in key:
+            # JWK Set per RFC 7517
+            return key["keys"]
+        elif "kty" in key:
+            # Individual JWK per RFC 7517
+            return (key,)
+        else:
+            # Some other mapping. Firebase uses just dict of kid, cert pairs
+            values = key.values()
+            if values:
+                return values
+            return (key,)
+
+    # Iterable but not text or mapping => list- or tuple-like
+    elif isinstance(key, Iterable) and not (isinstance(key, str) or isinstance(key, bytes)):
+        return key
+
+    # Scalar value, wrap in tuple.
+    else:
+        return (key,)
+
+
+def _verify_signature(signing_input, header, signature, key="", algorithms=None):
+
+    alg = header.get("alg")
+    if not alg:
+        raise JWSError("No algorithm was specified in the JWS header.")
+
+    if algorithms is not None and alg not in algorithms:
+        raise JWSError("The specified alg value is not allowed")
+
+    keys = _get_keys(key)
+    try:
+        if not _sig_matches_keys(keys, signing_input, signature, alg):
+            raise JWSSignatureError()
+    except JWSSignatureError:
+        raise JWSError("Signature verification failed.")
+    except JWSError:
+        raise JWSError("Invalid or unsupported algorithm: %s" % alg)
diff --git a/myenv/lib/python3.9/site-packages/jose/jwt.py b/myenv/lib/python3.9/site-packages/jose/jwt.py
new file mode 100644
index 0000000..3f2142e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/jwt.py
@@ -0,0 +1,496 @@
+import json
+from calendar import timegm
+from collections.abc import Mapping
+from datetime import datetime, timedelta
+
+from jose import jws
+
+from .constants import ALGORITHMS
+from .exceptions import ExpiredSignatureError, JWSError, JWTClaimsError, JWTError
+from .utils import calculate_at_hash, timedelta_total_seconds
+
+
+def encode(claims, key, algorithm=ALGORITHMS.HS256, headers=None, access_token=None):
+    """Encodes a claims set and returns a JWT string.
+
+    JWTs are JWS signed objects with a few reserved claims.
+
+    Args:
+        claims (dict): A claims set to sign
+        key (str or dict): The key to use for signing the claim set. Can be
+            individual JWK or JWK set.
+        algorithm (str, optional): The algorithm to use for signing the
+            the claims.  Defaults to HS256.
+        headers (dict, optional): A set of headers that will be added to
+            the default headers.  Any headers that are added as additional
+            headers will override the default headers.
+        access_token (str, optional): If present, the 'at_hash' claim will
+            be calculated and added to the claims present in the 'claims'
+            parameter.
+
+    Returns:
+        str: The string representation of the header, claims, and signature.
+
+    Raises:
+        JWTError: If there is an error encoding the claims.
+
+    Examples:
+
+        >>> jwt.encode({'a': 'b'}, 'secret', algorithm='HS256')
+        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhIjoiYiJ9.jiMyrsmD8AoHWeQgmxZ5yq8z0lXS67_QGs52AzC8Ru8'
+
+    """
+
+    for time_claim in ["exp", "iat", "nbf"]:
+
+        # Convert datetime to a intDate value in known time-format claims
+        if isinstance(claims.get(time_claim), datetime):
+            claims[time_claim] = timegm(claims[time_claim].utctimetuple())
+
+    if access_token:
+        claims["at_hash"] = calculate_at_hash(access_token, ALGORITHMS.HASHES[algorithm])
+
+    return jws.sign(claims, key, headers=headers, algorithm=algorithm)
+
+
+def decode(token, key, algorithms=None, options=None, audience=None, issuer=None, subject=None, access_token=None):
+    """Verifies a JWT string's signature and validates reserved claims.
+
+    Args:
+        token (str): A signed JWS to be verified.
+        key (str or dict): A key to attempt to verify the payload with. Can be
+            individual JWK or JWK set.
+        algorithms (str or list): Valid algorithms that should be used to verify the JWS.
+        audience (str): The intended audience of the token.  If the "aud" claim is
+            included in the claim set, then the audience must be included and must equal
+            the provided claim.
+        issuer (str or iterable): Acceptable value(s) for the issuer of the token.
+            If the "iss" claim is included in the claim set, then the issuer must be
+            given and the claim in the token must be among the acceptable values.
+        subject (str): The subject of the token.  If the "sub" claim is
+            included in the claim set, then the subject must be included and must equal
+            the provided claim.
+        access_token (str): An access token string. If the "at_hash" claim is included in the
+            claim set, then the access_token must be included, and it must match
+            the "at_hash" claim.
+        options (dict): A dictionary of options for skipping validation steps.
+
+            defaults = {
+                'verify_signature': True,
+                'verify_aud': True,
+                'verify_iat': True,
+                'verify_exp': True,
+                'verify_nbf': True,
+                'verify_iss': True,
+                'verify_sub': True,
+                'verify_jti': True,
+                'verify_at_hash': True,
+                'require_aud': False,
+                'require_iat': False,
+                'require_exp': False,
+                'require_nbf': False,
+                'require_iss': False,
+                'require_sub': False,
+                'require_jti': False,
+                'require_at_hash': False,
+                'leeway': 0,
+            }
+
+    Returns:
+        dict: The dict representation of the claims set, assuming the signature is valid
+            and all requested data validation passes.
+
+    Raises:
+        JWTError: If the signature is invalid in any way.
+        ExpiredSignatureError: If the signature has expired.
+        JWTClaimsError: If any claim is invalid in any way.
+
+    Examples:
+
+        >>> payload = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhIjoiYiJ9.jiMyrsmD8AoHWeQgmxZ5yq8z0lXS67_QGs52AzC8Ru8'
+        >>> jwt.decode(payload, 'secret', algorithms='HS256')
+
+    """
+
+    defaults = {
+        "verify_signature": True,
+        "verify_aud": True,
+        "verify_iat": True,
+        "verify_exp": True,
+        "verify_nbf": True,
+        "verify_iss": True,
+        "verify_sub": True,
+        "verify_jti": True,
+        "verify_at_hash": True,
+        "require_aud": False,
+        "require_iat": False,
+        "require_exp": False,
+        "require_nbf": False,
+        "require_iss": False,
+        "require_sub": False,
+        "require_jti": False,
+        "require_at_hash": False,
+        "leeway": 0,
+    }
+
+    if options:
+        defaults.update(options)
+
+    verify_signature = defaults.get("verify_signature", True)
+
+    try:
+        payload = jws.verify(token, key, algorithms, verify=verify_signature)
+    except JWSError as e:
+        raise JWTError(e)
+
+    # Needed for at_hash verification
+    algorithm = jws.get_unverified_header(token)["alg"]
+
+    try:
+        claims = json.loads(payload.decode("utf-8"))
+    except ValueError as e:
+        raise JWTError("Invalid payload string: %s" % e)
+
+    if not isinstance(claims, Mapping):
+        raise JWTError("Invalid payload string: must be a json object")
+
+    _validate_claims(
+        claims,
+        audience=audience,
+        issuer=issuer,
+        subject=subject,
+        algorithm=algorithm,
+        access_token=access_token,
+        options=defaults,
+    )
+
+    return claims
+
+
+def get_unverified_header(token):
+    """Returns the decoded headers without verification of any kind.
+
+    Args:
+        token (str): A signed JWT to decode the headers from.
+
+    Returns:
+        dict: The dict representation of the token headers.
+
+    Raises:
+        JWTError: If there is an exception decoding the token.
+    """
+    try:
+        headers = jws.get_unverified_headers(token)
+    except Exception:
+        raise JWTError("Error decoding token headers.")
+
+    return headers
+
+
+def get_unverified_headers(token):
+    """Returns the decoded headers without verification of any kind.
+
+    This is simply a wrapper of get_unverified_header() for backwards
+    compatibility.
+
+    Args:
+        token (str): A signed JWT to decode the headers from.
+
+    Returns:
+        dict: The dict representation of the token headers.
+
+    Raises:
+        JWTError: If there is an exception decoding the token.
+    """
+    return get_unverified_header(token)
+
+
+def get_unverified_claims(token):
+    """Returns the decoded claims without verification of any kind.
+
+    Args:
+        token (str): A signed JWT to decode the headers from.
+
+    Returns:
+        dict: The dict representation of the token claims.
+
+    Raises:
+        JWTError: If there is an exception decoding the token.
+    """
+    try:
+        claims = jws.get_unverified_claims(token)
+    except Exception:
+        raise JWTError("Error decoding token claims.")
+
+    try:
+        claims = json.loads(claims.decode("utf-8"))
+    except ValueError as e:
+        raise JWTError("Invalid claims string: %s" % e)
+
+    if not isinstance(claims, Mapping):
+        raise JWTError("Invalid claims string: must be a json object")
+
+    return claims
+
+
+def _validate_iat(claims):
+    """Validates that the 'iat' claim is valid.
+
+    The "iat" (issued at) claim identifies the time at which the JWT was
+    issued.  This claim can be used to determine the age of the JWT.  Its
+    value MUST be a number containing a NumericDate value.  Use of this
+    claim is OPTIONAL.
+
+    Args:
+        claims (dict): The claims dictionary to validate.
+    """
+
+    if "iat" not in claims:
+        return
+
+    try:
+        int(claims["iat"])
+    except ValueError:
+        raise JWTClaimsError("Issued At claim (iat) must be an integer.")
+
+
+def _validate_nbf(claims, leeway=0):
+    """Validates that the 'nbf' claim is valid.
+
+    The "nbf" (not before) claim identifies the time before which the JWT
+    MUST NOT be accepted for processing.  The processing of the "nbf"
+    claim requires that the current date/time MUST be after or equal to
+    the not-before date/time listed in the "nbf" claim.  Implementers MAY
+    provide for some small leeway, usually no more than a few minutes, to
+    account for clock skew.  Its value MUST be a number containing a
+    NumericDate value.  Use of this claim is OPTIONAL.
+
+    Args:
+        claims (dict): The claims dictionary to validate.
+        leeway (int): The number of seconds of skew that is allowed.
+    """
+
+    if "nbf" not in claims:
+        return
+
+    try:
+        nbf = int(claims["nbf"])
+    except ValueError:
+        raise JWTClaimsError("Not Before claim (nbf) must be an integer.")
+
+    now = timegm(datetime.utcnow().utctimetuple())
+
+    if nbf > (now + leeway):
+        raise JWTClaimsError("The token is not yet valid (nbf)")
+
+
+def _validate_exp(claims, leeway=0):
+    """Validates that the 'exp' claim is valid.
+
+    The "exp" (expiration time) claim identifies the expiration time on
+    or after which the JWT MUST NOT be accepted for processing.  The
+    processing of the "exp" claim requires that the current date/time
+    MUST be before the expiration date/time listed in the "exp" claim.
+    Implementers MAY provide for some small leeway, usually no more than
+    a few minutes, to account for clock skew.  Its value MUST be a number
+    containing a NumericDate value.  Use of this claim is OPTIONAL.
+
+    Args:
+        claims (dict): The claims dictionary to validate.
+        leeway (int): The number of seconds of skew that is allowed.
+    """
+
+    if "exp" not in claims:
+        return
+
+    try:
+        exp = int(claims["exp"])
+    except ValueError:
+        raise JWTClaimsError("Expiration Time claim (exp) must be an integer.")
+
+    now = timegm(datetime.utcnow().utctimetuple())
+
+    if exp < (now - leeway):
+        raise ExpiredSignatureError("Signature has expired.")
+
+
+def _validate_aud(claims, audience=None):
+    """Validates that the 'aud' claim is valid.
+
+    The "aud" (audience) claim identifies the recipients that the JWT is
+    intended for.  Each principal intended to process the JWT MUST
+    identify itself with a value in the audience claim.  If the principal
+    processing the claim does not identify itself with a value in the
+    "aud" claim when this claim is present, then the JWT MUST be
+    rejected.  In the general case, the "aud" value is an array of case-
+    sensitive strings, each containing a StringOrURI value.  In the
+    special case when the JWT has one audience, the "aud" value MAY be a
+    single case-sensitive string containing a StringOrURI value.  The
+    interpretation of audience values is generally application specific.
+    Use of this claim is OPTIONAL.
+
+    Args:
+        claims (dict): The claims dictionary to validate.
+        audience (str): The audience that is verifying the token.
+    """
+
+    if "aud" not in claims:
+        # if audience:
+        #     raise JWTError('Audience claim expected, but not in claims')
+        return
+
+    audience_claims = claims["aud"]
+    if isinstance(audience_claims, str):
+        audience_claims = [audience_claims]
+    if not isinstance(audience_claims, list):
+        raise JWTClaimsError("Invalid claim format in token")
+    if any(not isinstance(c, str) for c in audience_claims):
+        raise JWTClaimsError("Invalid claim format in token")
+    if audience not in audience_claims:
+        raise JWTClaimsError("Invalid audience")
+
+
+def _validate_iss(claims, issuer=None):
+    """Validates that the 'iss' claim is valid.
+
+    The "iss" (issuer) claim identifies the principal that issued the
+    JWT.  The processing of this claim is generally application specific.
+    The "iss" value is a case-sensitive string containing a StringOrURI
+    value.  Use of this claim is OPTIONAL.
+
+    Args:
+        claims (dict): The claims dictionary to validate.
+        issuer (str or iterable): Acceptable value(s) for the issuer that
+                                  signed the token.
+    """
+
+    if issuer is not None:
+        if isinstance(issuer, str):
+            issuer = (issuer,)
+        if claims.get("iss") not in issuer:
+            raise JWTClaimsError("Invalid issuer")
+
+
+def _validate_sub(claims, subject=None):
+    """Validates that the 'sub' claim is valid.
+
+    The "sub" (subject) claim identifies the principal that is the
+    subject of the JWT.  The claims in a JWT are normally statements
+    about the subject.  The subject value MUST either be scoped to be
+    locally unique in the context of the issuer or be globally unique.
+    The processing of this claim is generally application specific.  The
+    "sub" value is a case-sensitive string containing a StringOrURI
+    value.  Use of this claim is OPTIONAL.
+
+    Args:
+        claims (dict): The claims dictionary to validate.
+        subject (str): The subject of the token.
+    """
+
+    if "sub" not in claims:
+        return
+
+    if not isinstance(claims["sub"], str):
+        raise JWTClaimsError("Subject must be a string.")
+
+    if subject is not None:
+        if claims.get("sub") != subject:
+            raise JWTClaimsError("Invalid subject")
+
+
+def _validate_jti(claims):
+    """Validates that the 'jti' claim is valid.
+
+    The "jti" (JWT ID) claim provides a unique identifier for the JWT.
+    The identifier value MUST be assigned in a manner that ensures that
+    there is a negligible probability that the same value will be
+    accidentally assigned to a different data object; if the application
+    uses multiple issuers, collisions MUST be prevented among values
+    produced by different issuers as well.  The "jti" claim can be used
+    to prevent the JWT from being replayed.  The "jti" value is a case-
+    sensitive string.  Use of this claim is OPTIONAL.
+
+    Args:
+        claims (dict): The claims dictionary to validate.
+    """
+    if "jti" not in claims:
+        return
+
+    if not isinstance(claims["jti"], str):
+        raise JWTClaimsError("JWT ID must be a string.")
+
+
+def _validate_at_hash(claims, access_token, algorithm):
+    """
+    Validates that the 'at_hash' is valid.
+
+    Its value is the base64url encoding of the left-most half of the hash
+    of the octets of the ASCII representation of the access_token value,
+    where the hash algorithm used is the hash algorithm used in the alg
+    Header Parameter of the ID Token's JOSE Header. For instance, if the
+    alg is RS256, hash the access_token value with SHA-256, then take the
+    left-most 128 bits and base64url encode them. The at_hash value is a
+    case sensitive string.  Use of this claim is OPTIONAL.
+
+    Args:
+      claims (dict): The claims dictionary to validate.
+      access_token (str): The access token returned by the OpenID Provider.
+      algorithm (str): The algorithm used to sign the JWT, as specified by
+          the token headers.
+    """
+    if "at_hash" not in claims:
+        return
+
+    if not access_token:
+        msg = "No access_token provided to compare against at_hash claim."
+        raise JWTClaimsError(msg)
+
+    try:
+        expected_hash = calculate_at_hash(access_token, ALGORITHMS.HASHES[algorithm])
+    except (TypeError, ValueError):
+        msg = "Unable to calculate at_hash to verify against token claims."
+        raise JWTClaimsError(msg)
+
+    if claims["at_hash"] != expected_hash:
+        raise JWTClaimsError("at_hash claim does not match access_token.")
+
+
+def _validate_claims(claims, audience=None, issuer=None, subject=None, algorithm=None, access_token=None, options=None):
+
+    leeway = options.get("leeway", 0)
+
+    if isinstance(leeway, timedelta):
+        leeway = timedelta_total_seconds(leeway)
+    required_claims = [e[len("require_") :] for e in options.keys() if e.startswith("require_") and options[e]]
+    for require_claim in required_claims:
+        if require_claim not in claims:
+            raise JWTError('missing required key "%s" among claims' % require_claim)
+        else:
+            options["verify_" + require_claim] = True  # override verify when required
+
+    if not isinstance(audience, ((str,), type(None))):
+        raise JWTError("audience must be a string or None")
+
+    if options.get("verify_iat"):
+        _validate_iat(claims)
+
+    if options.get("verify_nbf"):
+        _validate_nbf(claims, leeway=leeway)
+
+    if options.get("verify_exp"):
+        _validate_exp(claims, leeway=leeway)
+
+    if options.get("verify_aud"):
+        _validate_aud(claims, audience=audience)
+
+    if options.get("verify_iss"):
+        _validate_iss(claims, issuer=issuer)
+
+    if options.get("verify_sub"):
+        _validate_sub(claims, subject=subject)
+
+    if options.get("verify_jti"):
+        _validate_jti(claims)
+
+    if options.get("verify_at_hash"):
+        _validate_at_hash(claims, access_token, algorithm)
diff --git a/myenv/lib/python3.9/site-packages/jose/utils.py b/myenv/lib/python3.9/site-packages/jose/utils.py
new file mode 100644
index 0000000..fcef885
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/jose/utils.py
@@ -0,0 +1,108 @@
+import base64
+import struct
+
+# Piggyback of the backends implementation of the function that converts a long
+# to a bytes stream. Some plumbing is necessary to have the signatures match.
+try:
+    from cryptography.utils import int_to_bytes as _long_to_bytes
+
+    def long_to_bytes(n, blocksize=0):
+        return _long_to_bytes(n, blocksize or None)
+
+
+except ImportError:
+    from ecdsa.ecdsa import int_to_string as _long_to_bytes
+
+    def long_to_bytes(n, blocksize=0):
+        ret = _long_to_bytes(n)
+        if blocksize == 0:
+            return ret
+        else:
+            assert len(ret) <= blocksize
+            padding = blocksize - len(ret)
+            return b"\x00" * padding + ret
+
+
+def long_to_base64(data, size=0):
+    return base64.urlsafe_b64encode(long_to_bytes(data, size)).strip(b"=")
+
+
+def int_arr_to_long(arr):
+    return int("".join(["%02x" % byte for byte in arr]), 16)
+
+
+def base64_to_long(data):
+    if isinstance(data, str):
+        data = data.encode("ascii")
+
+    # urlsafe_b64decode will happily convert b64encoded data
+    _d = base64.urlsafe_b64decode(bytes(data) + b"==")
+    return int_arr_to_long(struct.unpack("%sB" % len(_d), _d))
+
+
+def calculate_at_hash(access_token, hash_alg):
+    """Helper method for calculating an access token
+    hash, as described in http://openid.net/specs/openid-connect-core-1_0.html#CodeIDToken
+
+    Its value is the base64url encoding of the left-most half of the hash of the octets
+    of the ASCII representation of the access_token value, where the hash algorithm
+    used is the hash algorithm used in the alg Header Parameter of the ID Token's JOSE
+    Header. For instance, if the alg is RS256, hash the access_token value with SHA-256,
+    then take the left-most 128 bits and base64url encode them. The at_hash value is a
+    case sensitive string.
+
+    Args:
+        access_token (str): An access token string.
+        hash_alg (callable): A callable returning a hash object, e.g. hashlib.sha256
+
+    """
+    hash_digest = hash_alg(access_token.encode("utf-8")).digest()
+    cut_at = int(len(hash_digest) / 2)
+    truncated = hash_digest[:cut_at]
+    at_hash = base64url_encode(truncated)
+    return at_hash.decode("utf-8")
+
+
+def base64url_decode(input):
+    """Helper method to base64url_decode a string.
+
+    Args:
+        input (str): A base64url_encoded string to decode.
+
+    """
+    rem = len(input) % 4
+
+    if rem > 0:
+        input += b"=" * (4 - rem)
+
+    return base64.urlsafe_b64decode(input)
+
+
+def base64url_encode(input):
+    """Helper method to base64url_encode a string.
+
+    Args:
+        input (str): A base64url_encoded string to encode.
+
+    """
+    return base64.urlsafe_b64encode(input).replace(b"=", b"")
+
+
+def timedelta_total_seconds(delta):
+    """Helper method to determine the total number of seconds
+    from a timedelta.
+
+    Args:
+        delta (timedelta): A timedelta to convert to seconds.
+    """
+    return delta.days * 24 * 60 * 60 + delta.seconds
+
+
+def ensure_binary(s):
+    """Coerce **s** to bytes."""
+
+    if isinstance(s, bytes):
+        return s
+    if isinstance(s, str):
+        return s.encode("utf-8", "strict")
+    raise TypeError(f"not expecting type '{type(s)}'")
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/AUTHORS.rst b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/AUTHORS.rst
new file mode 100644
index 0000000..dbc0324
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/AUTHORS.rst
@@ -0,0 +1,10 @@
+
+Authors
+=======
+
+* Ionel Cristian Mărieș - https://blog.ionelmc.ro
+* Alvin Chow - https://github.com/alvinchow86
+* Astrum Kuo - https://github.com/xowenx
+* Erik M. Bray - http://iguananaut.net
+* Ran Benita - https://github.com/bluetech
+* "hugovk" - https://github.com/hugovk
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/LICENSE
new file mode 100644
index 0000000..de39b84
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/LICENSE
@@ -0,0 +1,21 @@
+BSD 2-Clause License
+
+Copyright (c) 2014-2019, Ionel Cristian Mărieș
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/METADATA
new file mode 100644
index 0000000..c7a3bd4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/METADATA
@@ -0,0 +1,219 @@
+Metadata-Version: 2.1
+Name: lazy-object-proxy
+Version: 1.7.1
+Summary: A fast and thorough lazy object proxy.
+Home-page: https://github.com/ionelmc/python-lazy-object-proxy
+Author: Ionel Cristian Mărieș
+Author-email: contact@ionelmc.ro
+License: BSD-2-Clause
+Project-URL: Documentation, https://python-lazy-object-proxy.readthedocs.io/
+Project-URL: Changelog, https://python-lazy-object-proxy.readthedocs.io/en/latest/changelog.html
+Project-URL: Issue Tracker, https://github.com/ionelmc/python-lazy-object-proxy/issues
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: Unix
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Utilities
+Requires-Python: >=3.6
+License-File: LICENSE
+License-File: AUTHORS.rst
+
+========
+Overview
+========
+
+
+
+A fast and thorough lazy object proxy.
+
+* Free software: BSD 2-Clause License
+
+Note that this is based on `wrapt`_'s ObjectProxy with one big change: it calls a function the first time the proxy object is
+used, while `wrapt.ObjectProxy` just forwards the method calls to the target object.
+
+In other words, you use `lazy-object-proxy` when you only have the object way later and you use `wrapt.ObjectProxy` when you
+want to override few methods (by subclassing) and forward everything else to the target object.
+
+Example::
+
+    import lazy_object_proxy
+
+    def expensive_func():
+        from time import sleep
+        print('starting calculation')
+        # just as example for a very slow computation
+        sleep(2)
+        print('finished calculation')
+        # return the result of the calculation
+        return 10
+
+    obj = lazy_object_proxy.Proxy(expensive_func)
+    # function is called only when object is actually used
+    print(obj)  # now expensive_func is called
+
+    print(obj)  # the result without calling the expensive_func
+
+Installation
+============
+
+::
+
+    pip install lazy-object-proxy
+
+Documentation
+=============
+
+https://python-lazy-object-proxy.readthedocs.io/
+
+Development
+===========
+
+To run all the tests run::
+
+    tox
+
+Acknowledgements
+================
+
+This project is based on some code from `wrapt`_ as you can see in the git history.
+
+.. _wrapt: https://github.com/GrahamDumpleton/wrapt
+
+
+Changelog
+=========
+
+1.7.1 (2021-12-15)
+------------------
+
+
+* Removed most of the Python 2 support code and fixed ``python_requires`` to require at least Python 3.6.
+
+  Note that 1.7.0 has been yanked because it could not install on Python 2.7.
+  Installing lazy-object-proxy on Python 2.7 should automatically fall back to the 1.6.0 release now.
+
+1.7.0 (2021-12-15)
+------------------
+
+* Switched CI to GitHub Actions, this has a couple consequences:
+
+  * Support for Python 2.7 is dropped. You can still install it there but it's not tested anymore and
+    Python 2 specific handling will be removed at some point.
+  * Linux wheels are now provided in `musllinux` and `manylinux2014` variants.
+
+* Fixed ``__index__`` to fallback to ``int`` if the wrapped object doesn't have an ``__index__`` method.
+  This prevents situations where code using a proxy would otherwise likely just call ``int`` had the object
+  not have an ``__index__`` method.
+
+1.6.0 (2021-03-22)
+------------------
+
+* Added support for async special methods (``__aiter__``, ``__anext__``,
+  ``__await__``, ``__aenter__``, ``__aexit__``).
+  These are used in the ``async for``, ``await` and ``async with`` statements.
+
+  Note that ``__await__`` returns a wrapper that tries to emulate the crazy
+  stuff going on in the ceval loop, so there will be a small performance overhead.
+* Added the ``__resolved__`` property. You can use it to check if the factory has
+  been called.
+
+1.5.2 (2020-11-26)
+------------------
+
+* Added Python 3.9 wheels.
+* Removed Python 2.7 Windows wheels
+  (not supported on newest image with Python 3.9).
+
+1.5.1 (2020-07-22)
+------------------
+
+* Added ARM64 wheels (manylinux2014).
+
+1.5.0 (2020-06-05)
+------------------
+
+* Added support for ``__fspath__``.
+* Dropped support for Python 3.4.
+
+1.4.3 (2019-10-26)
+------------------
+
+* Added binary wheels for Python 3.8.
+* Fixed license metadata.
+
+1.4.2 (2019-08-22)
+------------------
+
+* Included a ``pyproject.toml`` to allow users install the sdist with old python/setuptools, as the
+  setuptools-scm dep will be fetched by pip instead of setuptools.
+  Fixes `#30 <https://github.com/ionelmc/python-lazy-object-proxy/issues/30>`_.
+
+1.4.1 (2019-05-10)
+------------------
+
+* Fixed wheels being built with ``-coverage`` cflags. No more issues about bogus ``cext.gcda`` files.
+* Removed useless C file from wheels.
+* Changed ``setup.py`` to use setuptools-scm.
+
+1.4.0 (2019-05-05)
+------------------
+
+* Fixed ``__mod__`` for the slots backend. Contributed by Ran Benita in
+  `#28 <https://github.com/ionelmc/python-lazy-object-proxy/pull/28>`_.
+* Dropped support for Python 2.6 and 3.3. Contributed by "hugovk" in
+  `#24 <https://github.com/ionelmc/python-lazy-object-proxy/pull/24>`_.
+
+1.3.1 (2017-05-05)
+------------------
+
+* Fix broken release (``sdist`` had a broken ``MANIFEST.in``).
+
+1.3.0 (2017-05-02)
+------------------
+
+* Speed up arithmetic operations involving ``cext.Proxy`` subclasses.
+
+1.2.2 (2016-04-14)
+------------------
+
+* Added `manylinux <https://www.python.org/dev/peps/pep-0513/>`_ wheels.
+* Minor cleanup in readme.
+
+1.2.1 (2015-08-18)
+------------------
+
+* Fix a memory leak (the wrapped object would get bogus references). Contributed by Astrum Kuo in
+  `#10 <https://github.com/ionelmc/python-lazy-object-proxy/pull/10>`_.
+
+1.2.0 (2015-07-06)
+------------------
+
+* Don't instantiate the object when __repr__ is called. This aids with debugging (allows one to see exactly in
+  what state the proxy is).
+
+1.1.0 (2015-07-05)
+------------------
+
+* Added support for pickling. The pickled value is going to be the wrapped object *without* any Proxy container.
+* Fixed a memory management issue in the C extension (reference cycles weren't garbage collected due to improper
+  handling in the C extension). Contributed by Alvin Chow in
+  `#8 <https://github.com/ionelmc/python-lazy-object-proxy/pull/8>`_.
+
+1.0.2 (2015-04-11)
+-----------------------------------------
+
+* First release on PyPI.
+
+
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/RECORD
new file mode 100644
index 0000000..ecf8fb5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/RECORD
@@ -0,0 +1,15 @@
+lazy_object_proxy-1.7.1.dist-info/LICENSE,sha256=W-1KNkH2bsSNuN7SNqKV8z2H0CkxXzYXZVhUzw1wxUA,1329
+lazy_object_proxy-1.7.1.dist-info/WHEEL,sha256=JIE30nfOWUuazI4Vcfiuv_cYm-SkZCh6YOqQQjhm90A,109
+lazy_object_proxy-1.7.1.dist-info/AUTHORS.rst,sha256=8CeCjODba0S8UczLyZBPhpO_J6NMZ9Hz_fE1A1uNe9Y,278
+lazy_object_proxy-1.7.1.dist-info/top_level.txt,sha256=UNH-FQB-j_8bYqPz3gD90kHvaC42TQqY0thHSnbaa0k,18
+lazy_object_proxy-1.7.1.dist-info/METADATA,sha256=KJk7PYeMIqprrKYkxWq-fpA821iYHa8A91WgF2g57Zo,6826
+lazy_object_proxy/compat.py,sha256=W9iIrb9SWePDvo5tYCyY_VMoFoZ84nUux_tyLoDqonw,286
+lazy_object_proxy/_version.py,sha256=zX3KLJe3jAcA2G4CTqjCQedyBec7fH8geOYCwS-1kEM,142
+lazy_object_proxy/slots.py,sha256=X9W_-wZ8_9-ielG6xZ9IKAysKQnutd5ErqXN2CsgfX4,12502
+lazy_object_proxy/__init__.py,sha256=XSO_JFYBxkLI52LzafR6-VCPdnABiRzo34pPeSIMt8Y,410
+lazy_object_proxy/cext.cpython-39-darwin.so,sha256=y3lZfsCYdvy6eLKBtYgQovoJKQ0Rs5fjhjhG4x8b7b8,65584
+lazy_object_proxy/utils.py,sha256=i-7kGag3tORs8M1nYFColM-ZZLPur7KKRxVG7ytEJSI,587
+lazy_object_proxy/utils_py3.py,sha256=aFemNo5BMbOscJWwRII8CUOORSJQmMKwCzpDxmfgHJo,912
+lazy_object_proxy/simple.py,sha256=uFmj46FZ-xukOaDUYnL6nUKK5P33Zzh683irFrswpF0,9092
+lazy_object_proxy-1.7.1.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+lazy_object_proxy-1.7.1.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/WHEEL
new file mode 100644
index 0000000..9c3644e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_9_x86_64
+
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/top_level.txt
new file mode 100644
index 0000000..bdf032e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy-1.7.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+lazy_object_proxy
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy/__init__.py b/myenv/lib/python3.9/site-packages/lazy_object_proxy/__init__.py
new file mode 100644
index 0000000..0c1ef47
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy/__init__.py
@@ -0,0 +1,23 @@
+try:
+    import copy_reg as copyreg
+except ImportError:
+    import copyreg
+
+from .utils import identity
+
+copyreg.constructor(identity)
+
+try:
+    from .cext import Proxy
+    from .cext import identity
+except ImportError:
+    from .slots import Proxy
+else:
+    copyreg.constructor(identity)
+
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = '1.7.1'
+
+__all__ = "Proxy",
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy/_version.py b/myenv/lib/python3.9/site-packages/lazy_object_proxy/_version.py
new file mode 100644
index 0000000..e00aa2f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy/_version.py
@@ -0,0 +1,5 @@
+# coding: utf-8
+# file generated by setuptools_scm
+# don't change, don't track in version control
+version = '1.7.1'
+version_tuple = (1, 7, 1)
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy/cext.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/lazy_object_proxy/cext.cpython-39-darwin.so
new file mode 100755
index 0000000..423f95a
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/lazy_object_proxy/cext.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy/compat.py b/myenv/lib/python3.9/site-packages/lazy_object_proxy/compat.py
new file mode 100644
index 0000000..e950fdf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy/compat.py
@@ -0,0 +1,14 @@
+import sys
+
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    string_types = str, bytes
+else:
+    string_types = basestring,  # noqa: F821
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    return meta("NewBase", bases, {})
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy/simple.py b/myenv/lib/python3.9/site-packages/lazy_object_proxy/simple.py
new file mode 100644
index 0000000..724998d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy/simple.py
@@ -0,0 +1,278 @@
+import operator
+
+from .compat import PY2
+from .compat import PY3
+from .compat import string_types
+from .compat import with_metaclass
+from .utils import await_
+from .utils import cached_property
+from .utils import identity
+
+
+def make_proxy_method(code):
+    def proxy_wrapper(self, *args):
+        return code(self.__wrapped__, *args)
+
+    return proxy_wrapper
+
+
+class _ProxyMethods(object):
+    # We use properties to override the values of __module__ and
+    # __doc__. If we add these in ObjectProxy, the derived class
+    # __dict__ will still be setup to have string variants of these
+    # attributes and the rules of descriptors means that they appear to
+    # take precedence over the properties in the base class. To avoid
+    # that, we copy the properties into the derived class type itself
+    # via a meta class. In that way the properties will always take
+    # precedence.
+
+    @property
+    def __module__(self):
+        return self.__wrapped__.__module__
+
+    @__module__.setter
+    def __module__(self, value):
+        self.__wrapped__.__module__ = value
+
+    @property
+    def __doc__(self):
+        return self.__wrapped__.__doc__
+
+    @__doc__.setter
+    def __doc__(self, value):
+        self.__wrapped__.__doc__ = value
+
+    # Need to also propagate the special __weakref__ attribute for case
+    # where decorating classes which will define this. If do not define
+    # it and use a function like inspect.getmembers() on a decorator
+    # class it will fail. This can't be in the derived classes.
+
+    @property
+    def __weakref__(self):
+        return self.__wrapped__.__weakref__
+
+
+class _ProxyMetaType(type):
+    def __new__(cls, name, bases, dictionary):
+        # Copy our special properties into the class so that they
+        # always take precedence over attributes of the same name added
+        # during construction of a derived class. This is to save
+        # duplicating the implementation for them in all derived classes.
+
+        dictionary.update(vars(_ProxyMethods))
+        dictionary.pop('__dict__')
+
+        return type.__new__(cls, name, bases, dictionary)
+
+
+class Proxy(with_metaclass(_ProxyMetaType)):
+    __factory__ = None
+
+    def __init__(self, factory):
+        self.__dict__['__factory__'] = factory
+
+    @property
+    def __resolved__(self):
+        return '__wrapped__' in self.__dict__
+
+    @cached_property
+    def __wrapped__(self):
+        self = self.__dict__
+        if '__factory__' in self:
+            factory = self['__factory__']
+            return factory()
+        else:
+            raise ValueError("Proxy hasn't been initiated: __factory__ is missing.")
+
+    __name__ = property(make_proxy_method(operator.attrgetter('__name__')))
+    __class__ = property(make_proxy_method(operator.attrgetter('__class__')))
+    __annotations__ = property(make_proxy_method(operator.attrgetter('__anotations__')))
+    __dir__ = make_proxy_method(dir)
+    __str__ = make_proxy_method(str)
+
+    if PY3:
+        __bytes__ = make_proxy_method(bytes)
+
+    def __repr__(self, __getattr__=object.__getattribute__):
+        if '__wrapped__' in self.__dict__:
+            return '<{} at 0x{:x} wrapping {!r} at 0x{:x} with factory {!r}>'.format(
+                type(self).__name__, id(self),
+                self.__wrapped__, id(self.__wrapped__),
+                self.__factory__
+            )
+        else:
+            return '<{} at 0x{:x} with factory {!r}>'.format(
+                type(self).__name__, id(self),
+                self.__factory__
+            )
+
+    def __fspath__(self):
+        wrapped = self.__wrapped__
+        if isinstance(wrapped, string_types):
+            return wrapped
+        else:
+            fspath = getattr(wrapped, '__fspath__', None)
+            if fspath is None:
+                return wrapped
+            else:
+                return fspath()
+
+    __reversed__ = make_proxy_method(reversed)
+
+    if PY3:
+        __round__ = make_proxy_method(round)
+
+    __lt__ = make_proxy_method(operator.lt)
+    __le__ = make_proxy_method(operator.le)
+    __eq__ = make_proxy_method(operator.eq)
+    __ne__ = make_proxy_method(operator.ne)
+    __gt__ = make_proxy_method(operator.gt)
+    __ge__ = make_proxy_method(operator.ge)
+    __hash__ = make_proxy_method(hash)
+    __nonzero__ = make_proxy_method(bool)
+    __bool__ = make_proxy_method(bool)
+
+    def __setattr__(self, name, value):
+        if hasattr(type(self), name):
+            self.__dict__[name] = value
+        else:
+            setattr(self.__wrapped__, name, value)
+
+    def __getattr__(self, name):
+        if name in ('__wrapped__', '__factory__'):
+            raise AttributeError(name)
+        else:
+            return getattr(self.__wrapped__, name)
+
+    def __delattr__(self, name):
+        if hasattr(type(self), name):
+            del self.__dict__[name]
+        else:
+            delattr(self.__wrapped__, name)
+
+    __add__ = make_proxy_method(operator.add)
+    __sub__ = make_proxy_method(operator.sub)
+    __mul__ = make_proxy_method(operator.mul)
+    __div__ = make_proxy_method(operator.div if PY2 else operator.truediv)
+    __truediv__ = make_proxy_method(operator.truediv)
+    __floordiv__ = make_proxy_method(operator.floordiv)
+    __mod__ = make_proxy_method(operator.mod)
+    __divmod__ = make_proxy_method(divmod)
+    __pow__ = make_proxy_method(pow)
+    __lshift__ = make_proxy_method(operator.lshift)
+    __rshift__ = make_proxy_method(operator.rshift)
+    __and__ = make_proxy_method(operator.and_)
+    __xor__ = make_proxy_method(operator.xor)
+    __or__ = make_proxy_method(operator.or_)
+
+    def __radd__(self, other):
+        return other + self.__wrapped__
+
+    def __rsub__(self, other):
+        return other - self.__wrapped__
+
+    def __rmul__(self, other):
+        return other * self.__wrapped__
+
+    def __rdiv__(self, other):
+        return operator.div(other, self.__wrapped__)
+
+    def __rtruediv__(self, other):
+        return operator.truediv(other, self.__wrapped__)
+
+    def __rfloordiv__(self, other):
+        return other // self.__wrapped__
+
+    def __rmod__(self, other):
+        return other % self.__wrapped__
+
+    def __rdivmod__(self, other):
+        return divmod(other, self.__wrapped__)
+
+    def __rpow__(self, other, *args):
+        return pow(other, self.__wrapped__, *args)
+
+    def __rlshift__(self, other):
+        return other << self.__wrapped__
+
+    def __rrshift__(self, other):
+        return other >> self.__wrapped__
+
+    def __rand__(self, other):
+        return other & self.__wrapped__
+
+    def __rxor__(self, other):
+        return other ^ self.__wrapped__
+
+    def __ror__(self, other):
+        return other | self.__wrapped__
+
+    __iadd__ = make_proxy_method(operator.iadd)
+    __isub__ = make_proxy_method(operator.isub)
+    __imul__ = make_proxy_method(operator.imul)
+    __idiv__ = make_proxy_method(operator.idiv if PY2 else operator.itruediv)
+    __itruediv__ = make_proxy_method(operator.itruediv)
+    __ifloordiv__ = make_proxy_method(operator.ifloordiv)
+    __imod__ = make_proxy_method(operator.imod)
+    __ipow__ = make_proxy_method(operator.ipow)
+    __ilshift__ = make_proxy_method(operator.ilshift)
+    __irshift__ = make_proxy_method(operator.irshift)
+    __iand__ = make_proxy_method(operator.iand)
+    __ixor__ = make_proxy_method(operator.ixor)
+    __ior__ = make_proxy_method(operator.ior)
+    __neg__ = make_proxy_method(operator.neg)
+    __pos__ = make_proxy_method(operator.pos)
+    __abs__ = make_proxy_method(operator.abs)
+    __invert__ = make_proxy_method(operator.invert)
+
+    __int__ = make_proxy_method(int)
+
+    if PY2:
+        __long__ = make_proxy_method(long)  # noqa
+
+    __float__ = make_proxy_method(float)
+    __oct__ = make_proxy_method(oct)
+    __hex__ = make_proxy_method(hex)
+
+    def __index__(self):
+        if hasattr(self.__wrapped__, '__index__'):
+            return operator.index(self.__wrapped__)
+        else:
+            return int(self.__wrapped__)
+
+    __len__ = make_proxy_method(len)
+    __contains__ = make_proxy_method(operator.contains)
+    __getitem__ = make_proxy_method(operator.getitem)
+    __setitem__ = make_proxy_method(operator.setitem)
+    __delitem__ = make_proxy_method(operator.delitem)
+
+    if PY2:
+        __getslice__ = make_proxy_method(operator.getslice)
+        __setslice__ = make_proxy_method(operator.setslice)
+        __delslice__ = make_proxy_method(operator.delslice)
+
+    def __enter__(self):
+        return self.__wrapped__.__enter__()
+
+    def __exit__(self, *args, **kwargs):
+        return self.__wrapped__.__exit__(*args, **kwargs)
+
+    __iter__ = make_proxy_method(iter)
+
+    def __call__(self, *args, **kwargs):
+        return self.__wrapped__(*args, **kwargs)
+
+    def __reduce__(self):
+        return identity, (self.__wrapped__,)
+
+    def __reduce_ex__(self, protocol):
+        return identity, (self.__wrapped__,)
+
+    if await_:
+        from .utils import __aenter__
+        from .utils import __aexit__
+        from .utils import __aiter__
+        from .utils import __anext__
+        from .utils import __await__
+
+        __aiter__, __anext__, __await__, __aenter__, __aexit__  # noqa
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy/slots.py b/myenv/lib/python3.9/site-packages/lazy_object_proxy/slots.py
new file mode 100644
index 0000000..24d2f7e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy/slots.py
@@ -0,0 +1,452 @@
+import operator
+
+from .compat import PY2
+from .compat import PY3
+from .compat import string_types
+from .compat import with_metaclass
+from .utils import await_
+from .utils import identity
+
+
+class _ProxyMethods(object):
+    # We use properties to override the values of __module__ and
+    # __doc__. If we add these in ObjectProxy, the derived class
+    # __dict__ will still be setup to have string variants of these
+    # attributes and the rules of descriptors means that they appear to
+    # take precedence over the properties in the base class. To avoid
+    # that, we copy the properties into the derived class type itself
+    # via a meta class. In that way the properties will always take
+    # precedence.
+
+    @property
+    def __module__(self):
+        return self.__wrapped__.__module__
+
+    @__module__.setter
+    def __module__(self, value):
+        self.__wrapped__.__module__ = value
+
+    @property
+    def __doc__(self):
+        return self.__wrapped__.__doc__
+
+    @__doc__.setter
+    def __doc__(self, value):
+        self.__wrapped__.__doc__ = value
+
+    # We similar use a property for __dict__. We need __dict__ to be
+    # explicit to ensure that vars() works as expected.
+
+    @property
+    def __dict__(self):
+        return self.__wrapped__.__dict__
+
+    # Need to also propagate the special __weakref__ attribute for case
+    # where decorating classes which will define this. If do not define
+    # it and use a function like inspect.getmembers() on a decorator
+    # class it will fail. This can't be in the derived classes.
+
+    @property
+    def __weakref__(self):
+        return self.__wrapped__.__weakref__
+
+
+class _ProxyMetaType(type):
+    def __new__(cls, name, bases, dictionary):
+        # Copy our special properties into the class so that they
+        # always take precedence over attributes of the same name added
+        # during construction of a derived class. This is to save
+        # duplicating the implementation for them in all derived classes.
+
+        dictionary.update(vars(_ProxyMethods))
+
+        return type.__new__(cls, name, bases, dictionary)
+
+
+class Proxy(with_metaclass(_ProxyMetaType)):
+    """
+    A proxy implementation in pure Python, using slots. You can subclass this to add
+    local methods or attributes, or enable __dict__.
+
+    The most important internals:
+
+    * ``__factory__`` is the callback that "materializes" the object we proxy to.
+    * ``__target__`` will contain the object we proxy to, once it's "materialized".
+    * ``__resolved__`` is a boolean, `True` if factory was called.
+    * ``__wrapped__`` is a property that does either:
+
+      * return ``__target__`` if it's set.
+      * calls ``__factory__``, saves result to ``__target__`` and returns said result.
+    """
+
+    __slots__ = '__target__', '__factory__'
+
+    def __init__(self, factory):
+        object.__setattr__(self, '__factory__', factory)
+
+    @property
+    def __resolved__(self, __getattr__=object.__getattribute__):
+        try:
+            __getattr__(self, '__target__')
+        except AttributeError:
+            return False
+        else:
+            return True
+
+    @property
+    def __wrapped__(self, __getattr__=object.__getattribute__, __setattr__=object.__setattr__,
+                    __delattr__=object.__delattr__):
+        try:
+            return __getattr__(self, '__target__')
+        except AttributeError:
+            try:
+                factory = __getattr__(self, '__factory__')
+            except AttributeError:
+                raise ValueError("Proxy hasn't been initiated: __factory__ is missing.")
+            target = factory()
+            __setattr__(self, '__target__', target)
+            return target
+
+    @__wrapped__.deleter
+    def __wrapped__(self, __delattr__=object.__delattr__):
+        __delattr__(self, '__target__')
+
+    @__wrapped__.setter
+    def __wrapped__(self, target, __setattr__=object.__setattr__):
+        __setattr__(self, '__target__', target)
+
+    @property
+    def __name__(self):
+        return self.__wrapped__.__name__
+
+    @__name__.setter
+    def __name__(self, value):
+        self.__wrapped__.__name__ = value
+
+    @property
+    def __class__(self):
+        return self.__wrapped__.__class__
+
+    @__class__.setter  # noqa: F811
+    def __class__(self, value):  # noqa: F811
+        self.__wrapped__.__class__ = value
+
+    @property
+    def __annotations__(self):
+        return self.__wrapped__.__anotations__
+
+    @__annotations__.setter
+    def __annotations__(self, value):
+        self.__wrapped__.__annotations__ = value
+
+    def __dir__(self):
+        return dir(self.__wrapped__)
+
+    def __str__(self):
+        return str(self.__wrapped__)
+
+    if PY3:
+        def __bytes__(self):
+            return bytes(self.__wrapped__)
+
+    def __repr__(self, __getattr__=object.__getattribute__):
+        try:
+            target = __getattr__(self, '__target__')
+        except AttributeError:
+            return '<{} at 0x{:x} with factory {!r}>'.format(
+                type(self).__name__, id(self),
+                self.__factory__
+            )
+        else:
+            return '<{} at 0x{:x} wrapping {!r} at 0x{:x} with factory {!r}>'.format(
+                type(self).__name__, id(self),
+                target, id(target),
+                self.__factory__
+            )
+
+    def __fspath__(self):
+        wrapped = self.__wrapped__
+        if isinstance(wrapped, string_types):
+            return wrapped
+        else:
+            fspath = getattr(wrapped, '__fspath__', None)
+            if fspath is None:
+                return wrapped
+            else:
+                return fspath()
+
+    def __reversed__(self):
+        return reversed(self.__wrapped__)
+
+    if PY3:
+        def __round__(self):
+            return round(self.__wrapped__)
+
+    def __lt__(self, other):
+        return self.__wrapped__ < other
+
+    def __le__(self, other):
+        return self.__wrapped__ <= other
+
+    def __eq__(self, other):
+        return self.__wrapped__ == other
+
+    def __ne__(self, other):
+        return self.__wrapped__ != other
+
+    def __gt__(self, other):
+        return self.__wrapped__ > other
+
+    def __ge__(self, other):
+        return self.__wrapped__ >= other
+
+    def __hash__(self):
+        return hash(self.__wrapped__)
+
+    def __nonzero__(self):
+        return bool(self.__wrapped__)
+
+    def __bool__(self):
+        return bool(self.__wrapped__)
+
+    def __setattr__(self, name, value, __setattr__=object.__setattr__):
+        if hasattr(type(self), name):
+            __setattr__(self, name, value)
+        else:
+            setattr(self.__wrapped__, name, value)
+
+    def __getattr__(self, name):
+        if name in ('__wrapped__', '__factory__'):
+            raise AttributeError(name)
+        else:
+            return getattr(self.__wrapped__, name)
+
+    def __delattr__(self, name, __delattr__=object.__delattr__):
+        if hasattr(type(self), name):
+            __delattr__(self, name)
+        else:
+            delattr(self.__wrapped__, name)
+
+    def __add__(self, other):
+        return self.__wrapped__ + other
+
+    def __sub__(self, other):
+        return self.__wrapped__ - other
+
+    def __mul__(self, other):
+        return self.__wrapped__ * other
+
+    def __div__(self, other):
+        return operator.div(self.__wrapped__, other)
+
+    def __truediv__(self, other):
+        return operator.truediv(self.__wrapped__, other)
+
+    def __floordiv__(self, other):
+        return self.__wrapped__ // other
+
+    def __mod__(self, other):
+        return self.__wrapped__ % other
+
+    def __divmod__(self, other):
+        return divmod(self.__wrapped__, other)
+
+    def __pow__(self, other, *args):
+        return pow(self.__wrapped__, other, *args)
+
+    def __lshift__(self, other):
+        return self.__wrapped__ << other
+
+    def __rshift__(self, other):
+        return self.__wrapped__ >> other
+
+    def __and__(self, other):
+        return self.__wrapped__ & other
+
+    def __xor__(self, other):
+        return self.__wrapped__ ^ other
+
+    def __or__(self, other):
+        return self.__wrapped__ | other
+
+    def __radd__(self, other):
+        return other + self.__wrapped__
+
+    def __rsub__(self, other):
+        return other - self.__wrapped__
+
+    def __rmul__(self, other):
+        return other * self.__wrapped__
+
+    def __rdiv__(self, other):
+        return operator.div(other, self.__wrapped__)
+
+    def __rtruediv__(self, other):
+        return operator.truediv(other, self.__wrapped__)
+
+    def __rfloordiv__(self, other):
+        return other // self.__wrapped__
+
+    def __rmod__(self, other):
+        return other % self.__wrapped__
+
+    def __rdivmod__(self, other):
+        return divmod(other, self.__wrapped__)
+
+    def __rpow__(self, other, *args):
+        return pow(other, self.__wrapped__, *args)
+
+    def __rlshift__(self, other):
+        return other << self.__wrapped__
+
+    def __rrshift__(self, other):
+        return other >> self.__wrapped__
+
+    def __rand__(self, other):
+        return other & self.__wrapped__
+
+    def __rxor__(self, other):
+        return other ^ self.__wrapped__
+
+    def __ror__(self, other):
+        return other | self.__wrapped__
+
+    def __iadd__(self, other):
+        self.__wrapped__ += other
+        return self
+
+    def __isub__(self, other):
+        self.__wrapped__ -= other
+        return self
+
+    def __imul__(self, other):
+        self.__wrapped__ *= other
+        return self
+
+    def __idiv__(self, other):
+        self.__wrapped__ = operator.idiv(self.__wrapped__, other)
+        return self
+
+    def __itruediv__(self, other):
+        self.__wrapped__ = operator.itruediv(self.__wrapped__, other)
+        return self
+
+    def __ifloordiv__(self, other):
+        self.__wrapped__ //= other
+        return self
+
+    def __imod__(self, other):
+        self.__wrapped__ %= other
+        return self
+
+    def __ipow__(self, other):
+        self.__wrapped__ **= other
+        return self
+
+    def __ilshift__(self, other):
+        self.__wrapped__ <<= other
+        return self
+
+    def __irshift__(self, other):
+        self.__wrapped__ >>= other
+        return self
+
+    def __iand__(self, other):
+        self.__wrapped__ &= other
+        return self
+
+    def __ixor__(self, other):
+        self.__wrapped__ ^= other
+        return self
+
+    def __ior__(self, other):
+        self.__wrapped__ |= other
+        return self
+
+    def __neg__(self):
+        return -self.__wrapped__
+
+    def __pos__(self):
+        return +self.__wrapped__
+
+    def __abs__(self):
+        return abs(self.__wrapped__)
+
+    def __invert__(self):
+        return ~self.__wrapped__
+
+    def __int__(self):
+        return int(self.__wrapped__)
+
+    if PY2:
+        def __long__(self):
+            return long(self.__wrapped__)  # noqa
+
+    def __float__(self):
+        return float(self.__wrapped__)
+
+    def __oct__(self):
+        return oct(self.__wrapped__)
+
+    def __hex__(self):
+        return hex(self.__wrapped__)
+
+    def __index__(self):
+        if hasattr(self.__wrapped__, '__index__'):
+            return operator.index(self.__wrapped__)
+        else:
+            return int(self.__wrapped__)
+
+    def __len__(self):
+        return len(self.__wrapped__)
+
+    def __contains__(self, value):
+        return value in self.__wrapped__
+
+    def __getitem__(self, key):
+        return self.__wrapped__[key]
+
+    def __setitem__(self, key, value):
+        self.__wrapped__[key] = value
+
+    def __delitem__(self, key):
+        del self.__wrapped__[key]
+
+    def __getslice__(self, i, j):
+        return self.__wrapped__[i:j]
+
+    def __setslice__(self, i, j, value):
+        self.__wrapped__[i:j] = value
+
+    def __delslice__(self, i, j):
+        del self.__wrapped__[i:j]
+
+    def __enter__(self):
+        return self.__wrapped__.__enter__()
+
+    def __exit__(self, *args, **kwargs):
+        return self.__wrapped__.__exit__(*args, **kwargs)
+
+    def __iter__(self):
+        return iter(self.__wrapped__)
+
+    def __next__(self):
+        return next(self.__wrapped__)
+
+    def __call__(self, *args, **kwargs):
+        return self.__wrapped__(*args, **kwargs)
+
+    def __reduce__(self):
+        return identity, (self.__wrapped__,)
+
+    def __reduce_ex__(self, protocol):
+        return identity, (self.__wrapped__,)
+
+    if await_:
+        from .utils import __aenter__
+        from .utils import __aexit__
+        from .utils import __aiter__
+        from .utils import __anext__
+        from .utils import __await__
+
+        __aiter__, __anext__, __await__, __aenter__, __aexit__  # noqa
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy/utils.py b/myenv/lib/python3.9/site-packages/lazy_object_proxy/utils.py
new file mode 100644
index 0000000..3307abe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy/utils.py
@@ -0,0 +1,25 @@
+ # flake8: noqa
+try:
+    from .utils_py3 import __aenter__
+    from .utils_py3 import __aexit__
+    from .utils_py3 import __aiter__
+    from .utils_py3 import __anext__
+    from .utils_py3 import __await__
+    from .utils_py3 import await_
+except (ImportError, SyntaxError):
+    await_ = None
+
+
+def identity(obj):
+    return obj
+
+
+class cached_property(object):
+    def __init__(self, func):
+        self.func = func
+
+    def __get__(self, obj, cls):
+        if obj is None:
+            return self
+        value = obj.__dict__[self.func.__name__] = self.func(obj)
+        return value
diff --git a/myenv/lib/python3.9/site-packages/lazy_object_proxy/utils_py3.py b/myenv/lib/python3.9/site-packages/lazy_object_proxy/utils_py3.py
new file mode 100644
index 0000000..101f270
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/lazy_object_proxy/utils_py3.py
@@ -0,0 +1,44 @@
+from collections.abc import Awaitable
+from inspect import CO_ITERABLE_COROUTINE
+from types import CoroutineType
+from types import GeneratorType
+
+
+async def do_await(obj):
+    return await obj
+
+
+def do_yield_from(gen):
+    return (yield from gen)
+
+
+def await_(obj):
+    obj_type = type(obj)
+    if (
+        obj_type is CoroutineType or
+        obj_type is GeneratorType and bool(obj.gi_code.co_flags & CO_ITERABLE_COROUTINE) or
+        isinstance(obj, Awaitable)
+    ):
+        return do_await(obj).__await__()
+    else:
+        return do_yield_from(obj)
+
+
+def __aiter__(self):
+    return self.__wrapped__.__aiter__()
+
+
+async def __anext__(self):
+    return await self.__wrapped__.__anext__()
+
+
+def __await__(self):
+    return await_(self.__wrapped__)
+
+
+def __aenter__(self):
+    return self.__wrapped__.__aenter__()
+
+
+def __aexit__(self, *args, **kwargs):
+    return self.__wrapped__.__aexit__(*args, **kwargs)
diff --git a/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/LICENSE
new file mode 100644
index 0000000..8fd356e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/LICENSE
@@ -0,0 +1,25 @@
+Copyright © <year> Ned Batchelder
+Copyright © 2011-2013 Tarek Ziade <tarek@ziade.org>
+Copyright © 2013 Florent Xicluna <florent.xicluna@gmail.com>
+
+Licensed under the terms of the Expat License
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation files
+(the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/METADATA
new file mode 100644
index 0000000..e25facd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/METADATA
@@ -0,0 +1,199 @@
+Metadata-Version: 2.1
+Name: mccabe
+Version: 0.7.0
+Summary: McCabe checker, plugin for flake8
+Home-page: https://github.com/pycqa/mccabe
+Author: Tarek Ziade
+Author-email: tarek@ziade.org
+Maintainer: Ian Stapleton Cordasco
+Maintainer-email: graffatcolmingov@gmail.com
+License: Expat license
+Keywords: flake8 mccabe
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.6
+License-File: LICENSE
+
+McCabe complexity checker
+=========================
+
+Ned's script to check McCabe complexity.
+
+This module provides a plugin for ``flake8``, the Python code checker.
+
+
+Installation
+------------
+
+You can install, upgrade, or uninstall ``mccabe`` with these commands::
+
+  $ pip install mccabe
+  $ pip install --upgrade mccabe
+  $ pip uninstall mccabe
+
+
+Standalone script
+-----------------
+
+The complexity checker can be used directly::
+
+  $ python -m mccabe --min 5 mccabe.py
+  ("185:1: 'PathGraphingAstVisitor.visitIf'", 5)
+  ("71:1: 'PathGraph.to_dot'", 5)
+  ("245:1: 'McCabeChecker.run'", 5)
+  ("283:1: 'main'", 7)
+  ("203:1: 'PathGraphingAstVisitor.visitTryExcept'", 5)
+  ("257:1: 'get_code_complexity'", 5)
+
+
+Plugin for Flake8
+-----------------
+
+When both ``flake8 2+`` and ``mccabe`` are installed, the plugin is
+available in ``flake8``::
+
+  $ flake8 --version
+  2.0 (pep8: 1.4.2, pyflakes: 0.6.1, mccabe: 0.2)
+
+By default the plugin is disabled.  Use the ``--max-complexity`` switch to
+enable it.  It will emit a warning if the McCabe complexity of a function is
+higher than the provided value::
+
+    $ flake8 --max-complexity 10 coolproject
+    ...
+    coolproject/mod.py:1204:1: C901 'CoolFactory.prepare' is too complex (14)
+
+This feature is quite useful for detecting over-complex code.  According to McCabe,
+anything that goes beyond 10 is too complex.
+
+Flake8 has many features that mccabe does not provide. Flake8 allows users to
+ignore violations reported by plugins with ``# noqa``. Read more about this in
+`their documentation
+<http://flake8.pycqa.org/en/latest/user/violations.html#in-line-ignoring-errors>`__.
+To silence violations reported by ``mccabe``, place your ``# noqa: C901`` on
+the function definition line, where the error is reported for (possibly a
+decorator).
+
+
+Links
+-----
+
+* Feedback and ideas: http://mail.python.org/mailman/listinfo/code-quality
+
+* Cyclomatic complexity: http://en.wikipedia.org/wiki/Cyclomatic_complexity
+
+* Ned Batchelder's script:
+  http://nedbatchelder.com/blog/200803/python_code_complexity_microtool.html
+
+* McCabe complexity: http://en.wikipedia.org/wiki/Cyclomatic_complexity
+
+
+Changes
+-------
+
+0.7.0 - 2021-01-23
+``````````````````
+
+* Drop support for all versions of Python lower than 3.6
+
+* Add support for Python 3.8, 3.9, and 3.10
+
+* Fix option declaration for Flake8
+
+0.6.1 - 2017-01-26
+``````````````````
+
+* Fix signature for ``PathGraphingAstVisitor.default`` to match the signature
+  for ``ASTVisitor``
+
+0.6.0 - 2017-01-23
+``````````````````
+
+* Add support for Python 3.6
+
+* Fix handling for missing statement types
+
+0.5.3 - 2016-12-14
+``````````````````
+
+* Report actual column number of violation instead of the start of the line
+
+0.5.2 - 2016-07-31
+``````````````````
+
+* When opening files ourselves, make sure we always name the file variable
+
+0.5.1 - 2016-07-28
+``````````````````
+
+* Set default maximum complexity to -1 on the class itself
+
+0.5.0 - 2016-05-30
+``````````````````
+
+* PyCon 2016 PDX release
+
+* Add support for Flake8 3.0
+
+0.4.0 - 2016-01-27
+``````````````````
+
+* Stop testing on Python 3.2
+
+* Add support for async/await keywords on Python 3.5 from PEP 0492
+
+0.3.1 - 2015-06-14
+``````````````````
+
+* Include ``test_mccabe.py`` in releases.
+
+* Always coerce the ``max_complexity`` value from Flake8's entry-point to an
+  integer.
+
+0.3 - 2014-12-17
+````````````````
+
+* Computation was wrong: the mccabe complexity starts at 1, not 2.
+
+* The ``max-complexity`` value is now inclusive.  E.g.: if the
+  value is 10 and the reported complexity is 10, then it passes.
+
+* Add tests.
+
+
+0.2.1 - 2013-04-03
+``````````````````
+
+* Do not require ``setuptools`` in setup.py.  It works around an issue
+  with ``pip`` and Python 3.
+
+
+0.2 - 2013-02-22
+````````````````
+
+* Rename project to ``mccabe``.
+
+* Provide ``flake8.extension`` setuptools entry point.
+
+* Read ``max-complexity`` from the configuration file.
+
+* Rename argument ``min_complexity`` to ``threshold``.
+
+
+0.1 - 2013-02-11
+````````````````
+* First release
+
+
diff --git a/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/RECORD
new file mode 100644
index 0000000..0aba4cb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/RECORD
@@ -0,0 +1,8 @@
+mccabe.py,sha256=g_kB8oPilNLemdOirPaZymQyyjqAH0kowrncUQaaw00,10654
+mccabe-0.7.0.dist-info/LICENSE,sha256=EPvAA8uvims89xlbgNrJbIba85ADmyq_bntuc1r9fXQ,1221
+mccabe-0.7.0.dist-info/METADATA,sha256=oMxU_cw4ev2Q23YTL3NRg4pebHSqlrbF_DSSs-cpfBE,5035
+mccabe-0.7.0.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
+mccabe-0.7.0.dist-info/entry_points.txt,sha256=N2NH182GXTUyTm8r8XMgadb9C-CRa5dUr1k8OC91uGE,47
+mccabe-0.7.0.dist-info/top_level.txt,sha256=21cXuqZE-lpcfAqqANvX9EjI1ED1p8zcViv064u3RKA,7
+mccabe-0.7.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+mccabe-0.7.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/WHEEL
new file mode 100644
index 0000000..0b18a28
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/entry_points.txt
new file mode 100644
index 0000000..cc6645b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/entry_points.txt
@@ -0,0 +1,3 @@
+[flake8.extension]
+C90 = mccabe:McCabeChecker
+
diff --git a/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/top_level.txt
new file mode 100644
index 0000000..8831b36
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mccabe-0.7.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+mccabe
diff --git a/myenv/lib/python3.9/site-packages/mccabe.py b/myenv/lib/python3.9/site-packages/mccabe.py
new file mode 100644
index 0000000..5746504
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mccabe.py
@@ -0,0 +1,346 @@
+""" Meager code path measurement tool.
+    Ned Batchelder
+    http://nedbatchelder.com/blog/200803/python_code_complexity_microtool.html
+    MIT License.
+"""
+from __future__ import with_statement
+
+import optparse
+import sys
+import tokenize
+
+from collections import defaultdict
+try:
+    import ast
+    from ast import iter_child_nodes
+except ImportError:   # Python 2.5
+    from flake8.util import ast, iter_child_nodes
+
+__version__ = '0.7.0'
+
+
+class ASTVisitor(object):
+    """Performs a depth-first walk of the AST."""
+
+    def __init__(self):
+        self.node = None
+        self._cache = {}
+
+    def default(self, node, *args):
+        for child in iter_child_nodes(node):
+            self.dispatch(child, *args)
+
+    def dispatch(self, node, *args):
+        self.node = node
+        klass = node.__class__
+        meth = self._cache.get(klass)
+        if meth is None:
+            className = klass.__name__
+            meth = getattr(self.visitor, 'visit' + className, self.default)
+            self._cache[klass] = meth
+        return meth(node, *args)
+
+    def preorder(self, tree, visitor, *args):
+        """Do preorder walk of tree using visitor"""
+        self.visitor = visitor
+        visitor.visit = self.dispatch
+        self.dispatch(tree, *args)  # XXX *args make sense?
+
+
+class PathNode(object):
+    def __init__(self, name, look="circle"):
+        self.name = name
+        self.look = look
+
+    def to_dot(self):
+        print('node [shape=%s,label="%s"] %d;' % (
+            self.look, self.name, self.dot_id()))
+
+    def dot_id(self):
+        return id(self)
+
+
+class PathGraph(object):
+    def __init__(self, name, entity, lineno, column=0):
+        self.name = name
+        self.entity = entity
+        self.lineno = lineno
+        self.column = column
+        self.nodes = defaultdict(list)
+
+    def connect(self, n1, n2):
+        self.nodes[n1].append(n2)
+        # Ensure that the destination node is always counted.
+        self.nodes[n2] = []
+
+    def to_dot(self):
+        print('subgraph {')
+        for node in self.nodes:
+            node.to_dot()
+        for node, nexts in self.nodes.items():
+            for next in nexts:
+                print('%s -- %s;' % (node.dot_id(), next.dot_id()))
+        print('}')
+
+    def complexity(self):
+        """ Return the McCabe complexity for the graph.
+            V-E+2
+        """
+        num_edges = sum([len(n) for n in self.nodes.values()])
+        num_nodes = len(self.nodes)
+        return num_edges - num_nodes + 2
+
+
+class PathGraphingAstVisitor(ASTVisitor):
+    """ A visitor for a parsed Abstract Syntax Tree which finds executable
+        statements.
+    """
+
+    def __init__(self):
+        super(PathGraphingAstVisitor, self).__init__()
+        self.classname = ""
+        self.graphs = {}
+        self.reset()
+
+    def reset(self):
+        self.graph = None
+        self.tail = None
+
+    def dispatch_list(self, node_list):
+        for node in node_list:
+            self.dispatch(node)
+
+    def visitFunctionDef(self, node):
+
+        if self.classname:
+            entity = '%s%s' % (self.classname, node.name)
+        else:
+            entity = node.name
+
+        name = '%d:%d: %r' % (node.lineno, node.col_offset, entity)
+
+        if self.graph is not None:
+            # closure
+            pathnode = self.appendPathNode(name)
+            self.tail = pathnode
+            self.dispatch_list(node.body)
+            bottom = PathNode("", look='point')
+            self.graph.connect(self.tail, bottom)
+            self.graph.connect(pathnode, bottom)
+            self.tail = bottom
+        else:
+            self.graph = PathGraph(name, entity, node.lineno, node.col_offset)
+            pathnode = PathNode(name)
+            self.tail = pathnode
+            self.dispatch_list(node.body)
+            self.graphs["%s%s" % (self.classname, node.name)] = self.graph
+            self.reset()
+
+    visitAsyncFunctionDef = visitFunctionDef
+
+    def visitClassDef(self, node):
+        old_classname = self.classname
+        self.classname += node.name + "."
+        self.dispatch_list(node.body)
+        self.classname = old_classname
+
+    def appendPathNode(self, name):
+        if not self.tail:
+            return
+        pathnode = PathNode(name)
+        self.graph.connect(self.tail, pathnode)
+        self.tail = pathnode
+        return pathnode
+
+    def visitSimpleStatement(self, node):
+        if node.lineno is None:
+            lineno = 0
+        else:
+            lineno = node.lineno
+        name = "Stmt %d" % lineno
+        self.appendPathNode(name)
+
+    def default(self, node, *args):
+        if isinstance(node, ast.stmt):
+            self.visitSimpleStatement(node)
+        else:
+            super(PathGraphingAstVisitor, self).default(node, *args)
+
+    def visitLoop(self, node):
+        name = "Loop %d" % node.lineno
+        self._subgraph(node, name)
+
+    visitAsyncFor = visitFor = visitWhile = visitLoop
+
+    def visitIf(self, node):
+        name = "If %d" % node.lineno
+        self._subgraph(node, name)
+
+    def _subgraph(self, node, name, extra_blocks=()):
+        """create the subgraphs representing any `if` and `for` statements"""
+        if self.graph is None:
+            # global loop
+            self.graph = PathGraph(name, name, node.lineno, node.col_offset)
+            pathnode = PathNode(name)
+            self._subgraph_parse(node, pathnode, extra_blocks)
+            self.graphs["%s%s" % (self.classname, name)] = self.graph
+            self.reset()
+        else:
+            pathnode = self.appendPathNode(name)
+            self._subgraph_parse(node, pathnode, extra_blocks)
+
+    def _subgraph_parse(self, node, pathnode, extra_blocks):
+        """parse the body and any `else` block of `if` and `for` statements"""
+        loose_ends = []
+        self.tail = pathnode
+        self.dispatch_list(node.body)
+        loose_ends.append(self.tail)
+        for extra in extra_blocks:
+            self.tail = pathnode
+            self.dispatch_list(extra.body)
+            loose_ends.append(self.tail)
+        if node.orelse:
+            self.tail = pathnode
+            self.dispatch_list(node.orelse)
+            loose_ends.append(self.tail)
+        else:
+            loose_ends.append(pathnode)
+        if pathnode:
+            bottom = PathNode("", look='point')
+            for le in loose_ends:
+                self.graph.connect(le, bottom)
+            self.tail = bottom
+
+    def visitTryExcept(self, node):
+        name = "TryExcept %d" % node.lineno
+        self._subgraph(node, name, extra_blocks=node.handlers)
+
+    visitTry = visitTryExcept
+
+    def visitWith(self, node):
+        name = "With %d" % node.lineno
+        self.appendPathNode(name)
+        self.dispatch_list(node.body)
+
+    visitAsyncWith = visitWith
+
+
+class McCabeChecker(object):
+    """McCabe cyclomatic complexity checker."""
+    name = 'mccabe'
+    version = __version__
+    _code = 'C901'
+    _error_tmpl = "C901 %r is too complex (%d)"
+    max_complexity = -1
+
+    def __init__(self, tree, filename):
+        self.tree = tree
+
+    @classmethod
+    def add_options(cls, parser):
+        flag = '--max-complexity'
+        kwargs = {
+            'default': -1,
+            'action': 'store',
+            'type': int,
+            'help': 'McCabe complexity threshold',
+            'parse_from_config': 'True',
+        }
+        config_opts = getattr(parser, 'config_options', None)
+        if isinstance(config_opts, list):
+            # Flake8 2.x
+            kwargs.pop('parse_from_config')
+            parser.add_option(flag, **kwargs)
+            parser.config_options.append('max-complexity')
+        else:
+            parser.add_option(flag, **kwargs)
+
+    @classmethod
+    def parse_options(cls, options):
+        cls.max_complexity = int(options.max_complexity)
+
+    def run(self):
+        if self.max_complexity < 0:
+            return
+        visitor = PathGraphingAstVisitor()
+        visitor.preorder(self.tree, visitor)
+        for graph in visitor.graphs.values():
+            if graph.complexity() > self.max_complexity:
+                text = self._error_tmpl % (graph.entity, graph.complexity())
+                yield graph.lineno, graph.column, text, type(self)
+
+
+def get_code_complexity(code, threshold=7, filename='stdin'):
+    try:
+        tree = compile(code, filename, "exec", ast.PyCF_ONLY_AST)
+    except SyntaxError:
+        e = sys.exc_info()[1]
+        sys.stderr.write("Unable to parse %s: %s\n" % (filename, e))
+        return 0
+
+    complx = []
+    McCabeChecker.max_complexity = threshold
+    for lineno, offset, text, check in McCabeChecker(tree, filename).run():
+        complx.append('%s:%d:1: %s' % (filename, lineno, text))
+
+    if len(complx) == 0:
+        return 0
+    print('\n'.join(complx))
+    return len(complx)
+
+
+def get_module_complexity(module_path, threshold=7):
+    """Returns the complexity of a module"""
+    code = _read(module_path)
+    return get_code_complexity(code, threshold, filename=module_path)
+
+
+def _read(filename):
+    if (2, 5) < sys.version_info < (3, 0):
+        with open(filename, 'rU') as f:
+            return f.read()
+    elif (3, 0) <= sys.version_info < (4, 0):
+        """Read the source code."""
+        try:
+            with open(filename, 'rb') as f:
+                (encoding, _) = tokenize.detect_encoding(f.readline)
+        except (LookupError, SyntaxError, UnicodeError):
+            # Fall back if file encoding is improperly declared
+            with open(filename, encoding='latin-1') as f:
+                return f.read()
+        with open(filename, 'r', encoding=encoding) as f:
+            return f.read()
+
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv[1:]
+    opar = optparse.OptionParser()
+    opar.add_option("-d", "--dot", dest="dot",
+                    help="output a graphviz dot file", action="store_true")
+    opar.add_option("-m", "--min", dest="threshold",
+                    help="minimum complexity for output", type="int",
+                    default=1)
+
+    options, args = opar.parse_args(argv)
+
+    code = _read(args[0])
+    tree = compile(code, args[0], "exec", ast.PyCF_ONLY_AST)
+    visitor = PathGraphingAstVisitor()
+    visitor.preorder(tree, visitor)
+
+    if options.dot:
+        print('graph {')
+        for graph in visitor.graphs.values():
+            if (not options.threshold or
+                    graph.complexity() >= options.threshold):
+                graph.to_dot()
+        print('}')
+    else:
+        for graph in visitor.graphs.values():
+            if graph.complexity() >= options.threshold:
+                print(graph.name, graph.complexity())
+
+
+if __name__ == '__main__':
+    main(sys.argv[1:])
diff --git a/myenv/lib/python3.9/site-packages/multipart/__init__.py b/myenv/lib/python3.9/site-packages/multipart/__init__.py
new file mode 100644
index 0000000..cbe9211
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/multipart/__init__.py
@@ -0,0 +1,19 @@
+from __future__ import absolute_import
+import sys
+
+# This is the canonical package information.
+__author__    = 'Andrew Dunham'
+__license__   = 'Apache'
+__copyright__ = "Copyright (c) 2012-2013, Andrew Dunham"
+
+# We get the version from a sub-file that can be automatically generated.
+from ._version import __version__
+
+from .multipart import (
+    FormParser,
+    MultipartParser,
+    QuerystringParser,
+    OctetStreamParser,
+    create_form_parser,
+    parse_form,
+)
diff --git a/myenv/lib/python3.9/site-packages/multipart/_version.py b/myenv/lib/python3.9/site-packages/multipart/_version.py
new file mode 100644
index 0000000..eead319
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/multipart/_version.py
@@ -0,0 +1 @@
+__version__ = '0.0.5'
diff --git a/myenv/lib/python3.9/site-packages/multipart/decoders.py b/myenv/lib/python3.9/site-packages/multipart/decoders.py
new file mode 100644
index 0000000..06cb23f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/multipart/decoders.py
@@ -0,0 +1,171 @@
+import base64
+import binascii
+
+from .exceptions import Base64Error, DecodeError
+
+
+class Base64Decoder(object):
+    """This object provides an interface to decode a stream of Base64 data.  It
+    is instantiated with an "underlying object", and whenever a write()
+    operation is performed, it will decode the incoming data as Base64, and
+    call write() on the underlying object.  This is primarily used for decoding
+    form data encoded as Base64, but can be used for other purposes::
+
+        from multipart.decoders import Base64Decoder
+        fd = open("notb64.txt", "wb")
+        decoder = Base64Decoder(fd)
+        try:
+            decoder.write("Zm9vYmFy")       # "foobar" in Base64
+            decoder.finalize()
+        finally:
+            decoder.close()
+
+        # The contents of "notb64.txt" should be "foobar".
+
+    This object will also pass all finalize() and close() calls to the
+    underlying object, if the underlying object supports them.
+
+    Note that this class maintains a cache of base64 chunks, so that a write of
+    arbitrary size can be performed.  You must call :meth:`finalize` on this
+    object after all writes are completed to ensure that all data is flushed
+    to the underlying object.
+
+    :param underlying: the underlying object to pass writes to
+    """
+
+    def __init__(self, underlying):
+        self.cache = bytearray()
+        self.underlying = underlying
+
+    def write(self, data):
+        """Takes any input data provided, decodes it as base64, and passes it
+        on to the underlying object.  If the data provided is invalid base64
+        data, then this method will raise
+        a :class:`multipart.exceptions.DecodeError`
+
+        :param data: base64 data to decode
+        """
+
+        # Prepend any cache info to our data.
+        if len(self.cache) > 0:
+            data = self.cache + data
+
+        # Slice off a string that's a multiple of 4.
+        decode_len = (len(data) // 4) * 4
+        val = data[:decode_len]
+
+        # Decode and write, if we have any.
+        if len(val) > 0:
+            try:
+                decoded = base64.b64decode(val)
+            except Base64Error:
+                raise DecodeError('There was an error raised while decoding '
+                                  'base64-encoded data.')
+
+            self.underlying.write(decoded)
+
+        # Get the remaining bytes and save in our cache.
+        remaining_len = len(data) % 4
+        if remaining_len > 0:
+            self.cache = data[-remaining_len:]
+        else:
+            self.cache = b''
+
+        # Return the length of the data to indicate no error.
+        return len(data)
+
+    def close(self):
+        """Close this decoder.  If the underlying object has a `close()`
+        method, this function will call it.
+        """
+        if hasattr(self.underlying, 'close'):
+            self.underlying.close()
+
+    def finalize(self):
+        """Finalize this object.  This should be called when no more data
+        should be written to the stream.  This function can raise a
+        :class:`multipart.exceptions.DecodeError` if there is some remaining
+        data in the cache.
+
+        If the underlying object has a `finalize()` method, this function will
+        call it.
+        """
+        if len(self.cache) > 0:
+            raise DecodeError('There are %d bytes remaining in the '
+                              'Base64Decoder cache when finalize() is called'
+                              % len(self.cache))
+
+        if hasattr(self.underlying, 'finalize'):
+            self.underlying.finalize()
+
+    def __repr__(self):
+        return "%s(underlying=%r)" % (self.__class__.__name__, self.underlying)
+
+
+class QuotedPrintableDecoder(object):
+    """This object provides an interface to decode a stream of quoted-printable
+    data.  It is instantiated with an "underlying object", in the same manner
+    as the :class:`multipart.decoders.Base64Decoder` class.  This class behaves
+    in exactly the same way, including maintaining a cache of quoted-printable
+    chunks.
+
+    :param underlying: the underlying object to pass writes to
+    """
+    def __init__(self, underlying):
+        self.cache = b''
+        self.underlying = underlying
+
+    def write(self, data):
+        """Takes any input data provided, decodes it as quoted-printable, and
+        passes it on to the underlying object.
+
+        :param data: quoted-printable data to decode
+        """
+        # Prepend any cache info to our data.
+        if len(self.cache) > 0:
+            data = self.cache + data
+
+        # If the last 2 characters have an '=' sign in it, then we won't be
+        # able to decode the encoded value and we'll need to save it for the
+        # next decoding step.
+        if data[-2:].find(b'=') != -1:
+            enc, rest = data[:-2], data[-2:]
+        else:
+            enc = data
+            rest = b''
+
+        # Encode and write, if we have data.
+        if len(enc) > 0:
+            self.underlying.write(binascii.a2b_qp(enc))
+
+        # Save remaining in cache.
+        self.cache = rest
+        return len(data)
+
+    def close(self):
+        """Close this decoder.  If the underlying object has a `close()`
+        method, this function will call it.
+        """
+        if hasattr(self.underlying, 'close'):
+            self.underlying.close()
+
+    def finalize(self):
+        """Finalize this object.  This should be called when no more data
+        should be written to the stream.  This function will not raise any
+        exceptions, but it may write more data to the underlying object if
+        there is data remaining in the cache.
+
+        If the underlying object has a `finalize()` method, this function will
+        call it.
+        """
+        # If we have a cache, write and then remove it.
+        if len(self.cache) > 0:
+            self.underlying.write(binascii.a2b_qp(self.cache))
+            self.cache = b''
+
+        # Finalize our underlying stream.
+        if hasattr(self.underlying, 'finalize'):
+            self.underlying.finalize()
+
+    def __repr__(self):
+        return "%s(underlying=%r)" % (self.__class__.__name__, self.underlying)
diff --git a/myenv/lib/python3.9/site-packages/multipart/exceptions.py b/myenv/lib/python3.9/site-packages/multipart/exceptions.py
new file mode 100644
index 0000000..98c5867
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/multipart/exceptions.py
@@ -0,0 +1,58 @@
+import binascii
+
+from six import PY3
+
+
+class FormParserError(ValueError):
+    """Base error class for our form parser."""
+    pass
+
+
+class ParseError(FormParserError):
+    """This exception (or a subclass) is raised when there is an error while
+    parsing something.
+    """
+
+    #: This is the offset in the input data chunk (*NOT* the overall stream) in
+    #: which the parse error occured.  It will be -1 if not specified.
+    offset = -1
+
+
+class MultipartParseError(ParseError):
+    """This is a specific error that is raised when the MultipartParser detects
+    an error while parsing.
+    """
+    pass
+
+
+class QuerystringParseError(ParseError):
+    """This is a specific error that is raised when the QuerystringParser
+    detects an error while parsing.
+    """
+    pass
+
+
+class DecodeError(ParseError):
+    """This exception is raised when there is a decoding error - for example
+    with the Base64Decoder or QuotedPrintableDecoder.
+    """
+    pass
+
+
+# On Python 3.3, IOError is the same as OSError, so we don't want to inherit
+# from both of them.  We handle this case below.
+if IOError is not OSError:      # pragma: no cover
+    class FileError(FormParserError, IOError, OSError):
+        """Exception class for problems with the File class."""
+        pass
+else:                           # pragma: no cover
+    class FileError(FormParserError, OSError):
+        """Exception class for problems with the File class."""
+        pass
+
+# We check which version of Python we're on to figure out what error we need
+# to catch for invalid Base64.
+if PY3:                         # pragma: no cover
+    Base64Error = binascii.Error
+else:                           # pragma: no cover
+    Base64Error = TypeError
diff --git a/myenv/lib/python3.9/site-packages/multipart/multipart.py b/myenv/lib/python3.9/site-packages/multipart/multipart.py
new file mode 100644
index 0000000..27aaecb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/multipart/multipart.py
@@ -0,0 +1,1911 @@
+from __future__ import with_statement, absolute_import, print_function
+
+from six import (
+    binary_type,
+    text_type,
+    PY3,
+)
+
+from .decoders import *
+from .exceptions import *
+
+try:
+    from urlparse import parse_qs
+except ImportError:
+    from urllib.parse import parse_qs
+
+import os
+import re
+import sys
+import shutil
+import logging
+import tempfile
+from io import BytesIO
+from numbers import Number
+
+# Unique missing object.
+_missing = object()
+
+# States for the querystring parser.
+STATE_BEFORE_FIELD = 0
+STATE_FIELD_NAME   = 1
+STATE_FIELD_DATA   = 2
+
+# States for the multipart parser
+STATE_START                     = 0
+STATE_START_BOUNDARY            = 1
+STATE_HEADER_FIELD_START        = 2
+STATE_HEADER_FIELD              = 3
+STATE_HEADER_VALUE_START        = 4
+STATE_HEADER_VALUE              = 5
+STATE_HEADER_VALUE_ALMOST_DONE  = 6
+STATE_HEADERS_ALMOST_DONE       = 7
+STATE_PART_DATA_START           = 8
+STATE_PART_DATA                 = 9
+STATE_PART_DATA_END             = 10
+STATE_END                       = 11
+
+STATES = [
+    "START",
+    "START_BOUNDARY", "HEADER_FEILD_START", "HEADER_FIELD", "HEADER_VALUE_START", "HEADER_VALUE",
+    "HEADER_VALUE_ALMOST_DONE", "HEADRES_ALMOST_DONE", "PART_DATA_START", "PART_DATA", "PART_DATA_END", "END"
+]
+
+
+# Flags for the multipart parser.
+FLAG_PART_BOUNDARY              = 1
+FLAG_LAST_BOUNDARY              = 2
+
+# Get constants.  Since iterating over a str on Python 2 gives you a 1-length
+# string, but iterating over a bytes object on Python 3 gives you an integer,
+# we need to save these constants.
+CR = b'\r'[0]
+LF = b'\n'[0]
+COLON = b':'[0]
+SPACE = b' '[0]
+HYPHEN = b'-'[0]
+AMPERSAND = b'&'[0]
+SEMICOLON = b';'[0]
+LOWER_A = b'a'[0]
+LOWER_Z = b'z'[0]
+NULL = b'\x00'[0]
+
+# Lower-casing a character is different, because of the difference between
+# str on Py2, and bytes on Py3.  Same with getting the ordinal value of a byte,
+# and joining a list of bytes together.
+# These functions abstract that.
+if PY3:                         # pragma: no cover
+    lower_char = lambda c: c | 0x20
+    ord_char = lambda c: c
+    join_bytes = lambda b: bytes(list(b))
+else:                           # pragma: no cover
+    lower_char = lambda c: c.lower()
+    ord_char = lambda c: ord(c)
+    join_bytes = lambda b: b''.join(list(b))
+
+# These are regexes for parsing header values.
+SPECIAL_CHARS = re.escape(b'()<>@,;:\\"/[]?={} \t')
+QUOTED_STR = br'"(?:\\.|[^"])*"'
+VALUE_STR = br'(?:[^' + SPECIAL_CHARS + br']+|' + QUOTED_STR + br')'
+OPTION_RE_STR = (
+    br'(?:;|^)\s*([^' + SPECIAL_CHARS + br']+)\s*=\s*(' + VALUE_STR + br')'
+)
+OPTION_RE = re.compile(OPTION_RE_STR)
+QUOTE = b'"'[0]
+
+
+def parse_options_header(value):
+    """
+    Parses a Content-Type header into a value in the following format:
+        (content_type, {parameters})
+    """
+    if not value:
+        return (b'', {})
+
+    # If we are passed a string, we assume that it conforms to WSGI and does
+    # not contain any code point that's not in latin-1.
+    if isinstance(value, text_type):            # pragma: no cover
+        value = value.encode('latin-1')
+
+    # If we have no options, return the string as-is.
+    if b';' not in value:
+        return (value.lower().strip(), {})
+
+    # Split at the first semicolon, to get our value and then options.
+    ctype, rest = value.split(b';', 1)
+    options = {}
+
+    # Parse the options.
+    for match in OPTION_RE.finditer(rest):
+        key = match.group(1).lower()
+        value = match.group(2)
+        if value[0] == QUOTE and value[-1] == QUOTE:
+            # Unquote the value.
+            value = value[1:-1]
+            value = value.replace(b'\\\\', b'\\').replace(b'\\"', b'"')
+
+        # If the value is a filename, we need to fix a bug on IE6 that sends
+        # the full file path instead of the filename.
+        if key == b'filename':
+            if value[1:3] == b':\\' or value[:2] == b'\\\\':
+                value = value.split(b'\\')[-1]
+
+        options[key] = value
+
+    return ctype, options
+
+
+class Field(object):
+    """A Field object represents a (parsed) form field.  It represents a single
+    field with a corresponding name and value.
+
+    The name that a :class:`Field` will be instantiated with is the same name
+    that would be found in the following HTML::
+
+        <input name="name_goes_here" type="text"/>
+
+    This class defines two methods, :meth:`on_data` and :meth:`on_end`, that
+    will be called when data is written to the Field, and when the Field is
+    finalized, respectively.
+
+    :param name: the name of the form field
+    """
+    def __init__(self, name):
+        self._name = name
+        self._value = []
+
+        # We cache the joined version of _value for speed.
+        self._cache = _missing
+
+    @classmethod
+    def from_value(klass, name, value):
+        """Create an instance of a :class:`Field`, and set the corresponding
+        value - either None or an actual value.  This method will also
+        finalize the Field itself.
+
+        :param name: the name of the form field
+        :param value: the value of the form field - either a bytestring or
+                      None
+        """
+
+        f = klass(name)
+        if value is None:
+            f.set_none()
+        else:
+            f.write(value)
+        f.finalize()
+        return f
+
+    def write(self, data):
+        """Write some data into the form field.
+
+        :param data: a bytestring
+        """
+        return self.on_data(data)
+
+    def on_data(self, data):
+        """This method is a callback that will be called whenever data is
+        written to the Field.
+
+        :param data: a bytestring
+        """
+        self._value.append(data)
+        self._cache = _missing
+        return len(data)
+
+    def on_end(self):
+        """This method is called whenever the Field is finalized.
+        """
+        if self._cache is _missing:
+            self._cache = b''.join(self._value)
+
+    def finalize(self):
+        """Finalize the form field.
+        """
+        self.on_end()
+
+    def close(self):
+        """Close the Field object.  This will free any underlying cache.
+        """
+        # Free our value array.
+        if self._cache is _missing:
+            self._cache = b''.join(self._value)
+
+        del self._value
+
+    def set_none(self):
+        """Some fields in a querystring can possibly have a value of None - for
+        example, the string "foo&bar=&baz=asdf" will have a field with the
+        name "foo" and value None, one with name "bar" and value "", and one
+        with name "baz" and value "asdf".  Since the write() interface doesn't
+        support writing None, this function will set the field value to None.
+        """
+        self._cache = None
+
+    @property
+    def field_name(self):
+        """This property returns the name of the field."""
+        return self._name
+
+    @property
+    def value(self):
+        """This property returns the value of the form field."""
+        if self._cache is _missing:
+            self._cache = b''.join(self._value)
+
+        return self._cache
+
+    def __eq__(self, other):
+        if isinstance(other, Field):
+            return (
+                self.field_name == other.field_name and
+                self.value == other.value
+            )
+        else:
+            return NotImplemented
+
+    def __repr__(self):
+        if len(self.value) > 97:
+            # We get the repr, and then insert three dots before the final
+            # quote.
+            v = repr(self.value[:97])[:-1] + "...'"
+        else:
+            v = repr(self.value)
+
+        return "%s(field_name=%r, value=%s)" % (
+            self.__class__.__name__,
+            self.field_name,
+            v
+        )
+
+
+class File(object):
+    """This class represents an uploaded file.  It handles writing file data to
+    either an in-memory file or a temporary file on-disk, if the optional
+    threshold is passed.
+
+    There are some options that can be passed to the File to change behavior
+    of the class.  Valid options are as follows:
+
+    .. list-table::
+       :widths: 15 5 5 30
+       :header-rows: 1
+
+       * - Name
+         - Type
+         - Default
+         - Description
+       * - UPLOAD_DIR
+         - `str`
+         - None
+         - The directory to store uploaded files in.  If this is None, a
+           temporary file will be created in the system's standard location.
+       * - UPLOAD_DELETE_TMP
+         - `bool`
+         - True
+         - Delete automatically created TMP file
+       * - UPLOAD_KEEP_FILENAME
+         - `bool`
+         - False
+         - Whether or not to keep the filename of the uploaded file.  If True,
+           then the filename will be converted to a safe representation (e.g.
+           by removing any invalid path segments), and then saved with the
+           same name).  Otherwise, a temporary name will be used.
+       * - UPLOAD_KEEP_EXTENSIONS
+         - `bool`
+         - False
+         - Whether or not to keep the uploaded file's extension.  If False, the
+           file will be saved with the default temporary extension (usually
+           ".tmp").  Otherwise, the file's extension will be maintained.  Note
+           that this will properly combine with the UPLOAD_KEEP_FILENAME
+           setting.
+       * - MAX_MEMORY_FILE_SIZE
+         - `int`
+         - 1 MiB
+         - The maximum number of bytes of a File to keep in memory.  By
+           default, the contents of a File are kept into memory until a certain
+           limit is reached, after which the contents of the File are written
+           to a temporary file.  This behavior can be disabled by setting this
+           value to an appropriately large value (or, for example, infinity,
+           such as `float('inf')`.
+
+    :param file_name: The name of the file that this :class:`File` represents
+
+    :param field_name: The field name that uploaded this file.  Note that this
+                       can be None, if, for example, the file was uploaded
+                       with Content-Type application/octet-stream
+
+    :param config: The configuration for this File.  See above for valid
+                   configuration keys and their corresponding values.
+    """
+    def __init__(self, file_name, field_name=None, config={}):
+        # Save configuration, set other variables default.
+        self.logger = logging.getLogger(__name__)
+        self._config = config
+        self._in_memory = True
+        self._bytes_written = 0
+        self._fileobj = BytesIO()
+
+        # Save the provided field/file name.
+        self._field_name = field_name
+        self._file_name = file_name
+
+        # Our actual file name is None by default, since, depending on our
+        # config, we may not actually use the provided name.
+        self._actual_file_name = None
+
+        # Split the extension from the filename.
+        if file_name is not None:
+            base, ext = os.path.splitext(file_name)
+            self._file_base = base
+            self._ext = ext
+
+    @property
+    def field_name(self):
+        """The form field associated with this file.  May be None if there isn't
+        one, for example when we have an application/octet-stream upload.
+        """
+        return self._field_name
+
+    @property
+    def file_name(self):
+        """The file name given in the upload request.
+        """
+        return self._file_name
+
+    @property
+    def actual_file_name(self):
+        """The file name that this file is saved as.  Will be None if it's not
+        currently saved on disk.
+        """
+        return self._actual_file_name
+
+    @property
+    def file_object(self):
+        """The file object that we're currently writing to.  Note that this
+        will either be an instance of a :class:`io.BytesIO`, or a regular file
+        object.
+        """
+        return self._fileobj
+
+    @property
+    def size(self):
+        """The total size of this file, counted as the number of bytes that
+        currently have been written to the file.
+        """
+        return self._bytes_written
+
+    @property
+    def in_memory(self):
+        """A boolean representing whether or not this file object is currently
+        stored in-memory or on-disk.
+        """
+        return self._in_memory
+
+    def flush_to_disk(self):
+        """If the file is already on-disk, do nothing.  Otherwise, copy from
+        the in-memory buffer to a disk file, and then reassign our internal
+        file object to this new disk file.
+
+        Note that if you attempt to flush a file that is already on-disk, a
+        warning will be logged to this module's logger.
+        """
+        if not self._in_memory:
+            self.logger.warning(
+                "Trying to flush to disk when we're not in memory"
+            )
+            return
+
+        # Go back to the start of our file.
+        self._fileobj.seek(0)
+
+        # Open a new file.
+        new_file = self._get_disk_file()
+
+        # Copy the file objects.
+        shutil.copyfileobj(self._fileobj, new_file)
+
+        # Seek to the new position in our new file.
+        new_file.seek(self._bytes_written)
+
+        # Reassign the fileobject.
+        old_fileobj = self._fileobj
+        self._fileobj = new_file
+
+        # We're no longer in memory.
+        self._in_memory = False
+
+        # Close the old file object.
+        old_fileobj.close()
+
+    def _get_disk_file(self):
+        """This function is responsible for getting a file object on-disk for us.
+        """
+        self.logger.info("Opening a file on disk")
+
+        file_dir = self._config.get('UPLOAD_DIR')
+        keep_filename = self._config.get('UPLOAD_KEEP_FILENAME', False)
+        keep_extensions = self._config.get('UPLOAD_KEEP_EXTENSIONS', False)
+        delete_tmp = self._config.get('UPLOAD_DELETE_TMP', True)
+
+        # If we have a directory and are to keep the filename...
+        if file_dir is not None and keep_filename:
+            self.logger.info("Saving with filename in: %r", file_dir)
+
+            # Build our filename.
+            # TODO: what happens if we don't have a filename?
+            fname = self._file_base
+            if keep_extensions:
+                fname = fname + self._ext
+
+            path = os.path.join(file_dir, fname)
+            try:
+                self.logger.info("Opening file: %r", path)
+                tmp_file = open(path, 'w+b')
+            except (IOError, OSError) as e:
+                tmp_file = None
+
+                self.logger.exception("Error opening temporary file")
+                raise FileError("Error opening temporary file: %r" % path)
+        else:
+            # Build options array.
+            # Note that on Python 3, tempfile doesn't support byte names.  We
+            # encode our paths using the default filesystem encoding.
+            options = {}
+            if keep_extensions:
+                ext = self._ext
+                if isinstance(ext, binary_type):
+                    ext = ext.decode(sys.getfilesystemencoding())
+
+                options['suffix'] = ext
+            if file_dir is not None:
+                d = file_dir
+                if isinstance(d, binary_type):
+                    d = d.decode(sys.getfilesystemencoding())
+
+                options['dir'] = d
+            options['delete'] = delete_tmp
+
+            # Create a temporary (named) file with the appropriate settings.
+            self.logger.info("Creating a temporary file with options: %r",
+                             options)
+            try:
+                tmp_file = tempfile.NamedTemporaryFile(**options)
+            except (IOError, OSError):
+                self.logger.exception("Error creating named temporary file")
+                raise FileError("Error creating named temporary file")
+
+            fname = tmp_file.name
+
+            # Encode filename as bytes.
+            if isinstance(fname, text_type):
+                fname = fname.encode(sys.getfilesystemencoding())
+
+        self._actual_file_name = fname
+        return tmp_file
+
+    def write(self, data):
+        """Write some data to the File.
+
+        :param data: a bytestring
+        """
+        return self.on_data(data)
+
+    def on_data(self, data):
+        """This method is a callback that will be called whenever data is
+        written to the File.
+
+        :param data: a bytestring
+        """
+        pos = self._fileobj.tell()
+        bwritten = self._fileobj.write(data)
+        # true file objects write  returns None
+        if bwritten is None:
+            bwritten = self._fileobj.tell() - pos
+
+        # If the bytes written isn't the same as the length, just return.
+        if bwritten != len(data):
+            self.logger.warning("bwritten != len(data) (%d != %d)", bwritten,
+                                len(data))
+            return bwritten
+
+        # Keep track of how many bytes we've written.
+        self._bytes_written += bwritten
+
+        # If we're in-memory and are over our limit, we create a file.
+        if (self._in_memory and
+                self._config.get('MAX_MEMORY_FILE_SIZE') is not None and
+                (self._bytes_written >
+                 self._config.get('MAX_MEMORY_FILE_SIZE'))):
+            self.logger.info("Flushing to disk")
+            self.flush_to_disk()
+
+        # Return the number of bytes written.
+        return bwritten
+
+    def on_end(self):
+        """This method is called whenever the Field is finalized.
+        """
+        # Flush the underlying file object
+        self._fileobj.flush()
+
+    def finalize(self):
+        """Finalize the form file.  This will not close the underlying file,
+        but simply signal that we are finished writing to the File.
+        """
+        self.on_end()
+
+    def close(self):
+        """Close the File object.  This will actually close the underlying
+        file object (whether it's a :class:`io.BytesIO` or an actual file
+        object).
+        """
+        self._fileobj.close()
+
+    def __repr__(self):
+        return "%s(file_name=%r, field_name=%r)" % (
+            self.__class__.__name__,
+            self.file_name,
+            self.field_name
+        )
+
+
+class BaseParser(object):
+    """This class is the base class for all parsers.  It contains the logic for
+    calling and adding callbacks.
+
+    A callback can be one of two different forms.  "Notification callbacks" are
+    callbacks that are called when something happens - for example, when a new
+    part of a multipart message is encountered by the parser.  "Data callbacks"
+    are called when we get some sort of data - for example, part of the body of
+    a multipart chunk.  Notification callbacks are called with no parameters,
+    whereas data callbacks are called with three, as follows::
+
+        data_callback(data, start, end)
+
+    The "data" parameter is a bytestring (i.e. "foo" on Python 2, or b"foo" on
+    Python 3).  "start" and "end" are integer indexes into the "data" string
+    that represent the data of interest.  Thus, in a data callback, the slice
+    `data[start:end]` represents the data that the callback is "interested in".
+    The callback is not passed a copy of the data, since copying severely hurts
+    performance.
+    """
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+
+    def callback(self, name, data=None, start=None, end=None):
+        """This function calls a provided callback with some data.  If the
+        callback is not set, will do nothing.
+
+        :param name: The name of the callback to call (as a string).
+
+        :param data: Data to pass to the callback.  If None, then it is
+                     assumed that the callback is a notification callback,
+                     and no parameters are given.
+
+        :param end: An integer that is passed to the data callback.
+
+        :param start: An integer that is passed to the data callback.
+        """
+        name = "on_" + name
+        func = self.callbacks.get(name)
+        if func is None:
+            return
+
+        # Depending on whether we're given a buffer...
+        if data is not None:
+            # Don't do anything if we have start == end.
+            if start is not None and start == end:
+                return
+
+            self.logger.debug("Calling %s with data[%d:%d]", name, start, end)
+            func(data, start, end)
+        else:
+            self.logger.debug("Calling %s with no data", name)
+            func()
+
+    def set_callback(self, name, new_func):
+        """Update the function for a callback.  Removes from the callbacks dict
+        if new_func is None.
+
+        :param name: The name of the callback to call (as a string).
+
+        :param new_func: The new function for the callback.  If None, then the
+                         callback will be removed (with no error if it does not
+                         exist).
+        """
+        if new_func is None:
+            self.callbacks.pop('on_' + name, None)
+        else:
+            self.callbacks['on_' + name] = new_func
+
+    def close(self):
+        pass                # pragma: no cover
+
+    def finalize(self):
+        pass                # pragma: no cover
+
+    def __repr__(self):
+        return "%s()" % self.__class__.__name__
+
+
+class OctetStreamParser(BaseParser):
+    """This parser parses an octet-stream request body and calls callbacks when
+    incoming data is received.  Callbacks are as follows:
+
+    .. list-table::
+       :widths: 15 10 30
+       :header-rows: 1
+
+       * - Callback Name
+         - Parameters
+         - Description
+       * - on_start
+         - None
+         - Called when the first data is parsed.
+       * - on_data
+         - data, start, end
+         - Called for each data chunk that is parsed.
+       * - on_end
+         - None
+         - Called when the parser is finished parsing all data.
+
+    :param callbacks: A dictionary of callbacks.  See the documentation for
+                      :class:`BaseParser`.
+
+    :param max_size: The maximum size of body to parse.  Defaults to infinity -
+                     i.e. unbounded.
+    """
+    def __init__(self, callbacks={}, max_size=float('inf')):
+        super(OctetStreamParser, self).__init__()
+        self.callbacks = callbacks
+        self._started = False
+
+        if not isinstance(max_size, Number) or max_size < 1:
+            raise ValueError("max_size must be a positive number, not %r" %
+                             max_size)
+        self.max_size = max_size
+        self._current_size = 0
+
+    def write(self, data):
+        """Write some data to the parser, which will perform size verification,
+        and then pass the data to the underlying callback.
+
+        :param data: a bytestring
+        """
+        if not self._started:
+            self.callback('start')
+            self._started = True
+
+        # Truncate data length.
+        data_len = len(data)
+        if (self._current_size + data_len) > self.max_size:
+            # We truncate the length of data that we are to process.
+            new_size = int(self.max_size - self._current_size)
+            self.logger.warning("Current size is %d (max %d), so truncating "
+                                "data length from %d to %d",
+                                self._current_size, self.max_size, data_len,
+                                new_size)
+            data_len = new_size
+
+        # Increment size, then callback, in case there's an exception.
+        self._current_size += data_len
+        self.callback('data', data, 0, data_len)
+        return data_len
+
+    def finalize(self):
+        """Finalize this parser, which signals to that we are finished parsing,
+        and sends the on_end callback.
+        """
+        self.callback('end')
+
+    def __repr__(self):
+        return "%s()" % self.__class__.__name__
+
+
+class QuerystringParser(BaseParser):
+    """This is a streaming querystring parser.  It will consume data, and call
+    the callbacks given when it has data.
+
+    .. list-table::
+       :widths: 15 10 30
+       :header-rows: 1
+
+       * - Callback Name
+         - Parameters
+         - Description
+       * - on_field_start
+         - None
+         - Called when a new field is encountered.
+       * - on_field_name
+         - data, start, end
+         - Called when a portion of a field's name is encountered.
+       * - on_field_data
+         - data, start, end
+         - Called when a portion of a field's data is encountered.
+       * - on_field_end
+         - None
+         - Called when the end of a field is encountered.
+       * - on_end
+         - None
+         - Called when the parser is finished parsing all data.
+
+    :param callbacks: A dictionary of callbacks.  See the documentation for
+                      :class:`BaseParser`.
+
+    :param strict_parsing: Whether or not to parse the body strictly.  Defaults
+                           to False.  If this is set to True, then the behavior
+                           of the parser changes as the following: if a field
+                           has a value with an equal sign (e.g. "foo=bar", or
+                           "foo="), it is always included.  If a field has no
+                           equals sign (e.g. "...&name&..."), it will be
+                           treated as an error if 'strict_parsing' is True,
+                           otherwise included.  If an error is encountered,
+                           then a
+                           :class:`multipart.exceptions.QuerystringParseError`
+                           will be raised.
+
+    :param max_size: The maximum size of body to parse.  Defaults to infinity -
+                     i.e. unbounded.
+    """
+    def __init__(self, callbacks={}, strict_parsing=False,
+                 max_size=float('inf')):
+        super(QuerystringParser, self).__init__()
+        self.state = STATE_BEFORE_FIELD
+        self._found_sep = False
+
+        self.callbacks = callbacks
+
+        # Max-size stuff
+        if not isinstance(max_size, Number) or max_size < 1:
+            raise ValueError("max_size must be a positive number, not %r" %
+                             max_size)
+        self.max_size = max_size
+        self._current_size = 0
+
+        # Should parsing be strict?
+        self.strict_parsing = strict_parsing
+
+    def write(self, data):
+        """Write some data to the parser, which will perform size verification,
+        parse into either a field name or value, and then pass the
+        corresponding data to the underlying callback.  If an error is
+        encountered while parsing, a QuerystringParseError will be raised.  The
+        "offset" attribute of the raised exception will be set to the offset in
+        the input data chunk (NOT the overall stream) that caused the error.
+
+        :param data: a bytestring
+        """
+        # Handle sizing.
+        data_len = len(data)
+        if (self._current_size + data_len) > self.max_size:
+            # We truncate the length of data that we are to process.
+            new_size = int(self.max_size - self._current_size)
+            self.logger.warning("Current size is %d (max %d), so truncating "
+                                "data length from %d to %d",
+                                self._current_size, self.max_size, data_len,
+                                new_size)
+            data_len = new_size
+
+        l = 0
+        try:
+            l = self._internal_write(data, data_len)
+        finally:
+            self._current_size += l
+
+        return l
+
+    def _internal_write(self, data, length):
+        state = self.state
+        strict_parsing = self.strict_parsing
+        found_sep = self._found_sep
+
+        i = 0
+        while i < length:
+            ch = data[i]
+
+            # Depending on our state...
+            if state == STATE_BEFORE_FIELD:
+                # If the 'found_sep' flag is set, we've already encountered
+                # and skipped a single seperator.  If so, we check our strict
+                # parsing flag and decide what to do.  Otherwise, we haven't
+                # yet reached a seperator, and thus, if we do, we need to skip
+                # it as it will be the boundary between fields that's supposed
+                # to be there.
+                if ch == AMPERSAND or ch == SEMICOLON:
+                    if found_sep:
+                        # If we're parsing strictly, we disallow blank chunks.
+                        if strict_parsing:
+                            e = QuerystringParseError(
+                                "Skipping duplicate ampersand/semicolon at "
+                                "%d" % i
+                            )
+                            e.offset = i
+                            raise e
+                        else:
+                            self.logger.debug("Skipping duplicate ampersand/"
+                                         "semicolon at %d", i)
+                    else:
+                        # This case is when we're skipping the (first)
+                        # seperator between fields, so we just set our flag
+                        # and continue on.
+                        found_sep = True
+                else:
+                    # Emit a field-start event, and go to that state.  Also,
+                    # reset the "found_sep" flag, for the next time we get to
+                    # this state.
+                    self.callback('field_start')
+                    i -= 1
+                    state = STATE_FIELD_NAME
+                    found_sep = False
+
+            elif state == STATE_FIELD_NAME:
+                # Try and find a seperator - we ensure that, if we do, we only
+                # look for the equal sign before it.
+                sep_pos = data.find(b'&', i)
+                if sep_pos == -1:
+                    sep_pos = data.find(b';', i)
+
+                # See if we can find an equals sign in the remaining data.  If
+                # so, we can immedately emit the field name and jump to the
+                # data state.
+                if sep_pos != -1:
+                    equals_pos = data.find(b'=', i, sep_pos)
+                else:
+                    equals_pos = data.find(b'=', i)
+
+                if equals_pos != -1:
+                    # Emit this name.
+                    self.callback('field_name', data, i, equals_pos)
+
+                    # Jump i to this position.  Note that it will then have 1
+                    # added to it below, which means the next iteration of this
+                    # loop will inspect the character after the equals sign.
+                    i = equals_pos
+                    state = STATE_FIELD_DATA
+                else:
+                    # No equals sign found.
+                    if not strict_parsing:
+                        # See also comments in the STATE_FIELD_DATA case below.
+                        # If we found the seperator, we emit the name and just
+                        # end - there's no data callback at all (not even with
+                        # a blank value).
+                        if sep_pos != -1:
+                            self.callback('field_name', data, i, sep_pos)
+                            self.callback('field_end')
+
+                            i = sep_pos - 1
+                            state = STATE_BEFORE_FIELD
+                        else:
+                            # Otherwise, no seperator in this block, so the
+                            # rest of this chunk must be a name.
+                            self.callback('field_name', data, i, length)
+                            i = length
+
+                    else:
+                        # We're parsing strictly.  If we find a seperator,
+                        # this is an error - we require an equals sign.
+                        if sep_pos != -1:
+                            e =  QuerystringParseError(
+                                "When strict_parsing is True, we require an "
+                                "equals sign in all field chunks. Did not "
+                                "find one in the chunk that starts at %d" %
+                                (i,)
+                            )
+                            e.offset = i
+                            raise e
+
+                        # No seperator in the rest of this chunk, so it's just
+                        # a field name.
+                        self.callback('field_name', data, i, length)
+                        i = length
+
+            elif state == STATE_FIELD_DATA:
+                # Try finding either an ampersand or a semicolon after this
+                # position.
+                sep_pos = data.find(b'&', i)
+                if sep_pos == -1:
+                    sep_pos = data.find(b';', i)
+
+                # If we found it, callback this bit as data and then go back
+                # to expecting to find a field.
+                if sep_pos != -1:
+                    self.callback('field_data', data, i, sep_pos)
+                    self.callback('field_end')
+
+                    # Note that we go to the seperator, which brings us to the
+                    # "before field" state.  This allows us to properly emit
+                    # "field_start" events only when we actually have data for
+                    # a field of some sort.
+                    i = sep_pos - 1
+                    state = STATE_BEFORE_FIELD
+
+                # Otherwise, emit the rest as data and finish.
+                else:
+                    self.callback('field_data', data, i, length)
+                    i = length
+
+            else:                   # pragma: no cover (error case)
+                msg = "Reached an unknown state %d at %d" % (state, i)
+                self.logger.warning(msg)
+                e = QuerystringParseError(msg)
+                e.offset = i
+                raise e
+
+            i += 1
+
+        self.state = state
+        self._found_sep = found_sep
+        return len(data)
+
+    def finalize(self):
+        """Finalize this parser, which signals to that we are finished parsing,
+        if we're still in the middle of a field, an on_field_end callback, and
+        then the on_end callback.
+        """
+        # If we're currently in the middle of a field, we finish it.
+        if self.state == STATE_FIELD_DATA:
+            self.callback('field_end')
+        self.callback('end')
+
+    def __repr__(self):
+        return "%s(keep_blank_values=%r, strict_parsing=%r, max_size=%r)" % (
+            self.__class__.__name__,
+            self.keep_blank_values, self.strict_parsing, self.max_size
+        )
+
+
+class MultipartParser(BaseParser):
+    """This class is a streaming multipart/form-data parser.
+
+    .. list-table::
+       :widths: 15 10 30
+       :header-rows: 1
+
+       * - Callback Name
+         - Parameters
+         - Description
+       * - on_part_begin
+         - None
+         - Called when a new part of the multipart message is encountered.
+       * - on_part_data
+         - data, start, end
+         - Called when a portion of a part's data is encountered.
+       * - on_part_end
+         - None
+         - Called when the end of a part is reached.
+       * - on_header_begin
+         - None
+         - Called when we've found a new header in a part of a multipart
+           message
+       * - on_header_field
+         - data, start, end
+         - Called each time an additional portion of a header is read (i.e. the
+           part of the header that is before the colon; the "Foo" in
+           "Foo: Bar").
+       * - on_header_value
+         - data, start, end
+         - Called when we get data for a header.
+       * - on_header_end
+         - None
+         - Called when the current header is finished - i.e. we've reached the
+           newline at the end of the header.
+       * - on_headers_finished
+         - None
+         - Called when all headers are finished, and before the part data
+           starts.
+       * - on_end
+         - None
+         - Called when the parser is finished parsing all data.
+
+
+    :param boundary: The multipart boundary.  This is required, and must match
+                     what is given in the HTTP request - usually in the
+                     Content-Type header.
+
+    :param callbacks: A dictionary of callbacks.  See the documentation for
+                      :class:`BaseParser`.
+
+    :param max_size: The maximum size of body to parse.  Defaults to infinity -
+                     i.e. unbounded.
+    """
+
+    def __init__(self, boundary, callbacks={}, max_size=float('inf')):
+        # Initialize parser state.
+        super(MultipartParser, self).__init__()
+        self.state = STATE_START
+        self.index = self.flags = 0
+
+        self.callbacks = callbacks
+
+        if not isinstance(max_size, Number) or max_size < 1:
+            raise ValueError("max_size must be a positive number, not %r" %
+                             max_size)
+        self.max_size = max_size
+        self._current_size = 0
+
+        # Setup marks.  These are used to track the state of data recieved.
+        self.marks = {}
+
+        # TODO: Actually use this rather than the dumb version we currently use
+        # # Precompute the skip table for the Boyer-Moore-Horspool algorithm.
+        # skip = [len(boundary) for x in range(256)]
+        # for i in range(len(boundary) - 1):
+        #     skip[ord_char(boundary[i])] = len(boundary) - i - 1
+        #
+        # # We use a tuple since it's a constant, and marginally faster.
+        # self.skip = tuple(skip)
+
+        # Save our boundary.
+        if isinstance(boundary, text_type):         # pragma: no cover
+            boundary = boundary.encode('latin-1')
+        self.boundary = b'\r\n--' + boundary
+
+        # Get a set of characters that belong to our boundary.
+        self.boundary_chars = frozenset(self.boundary)
+
+        # We also create a lookbehind list.
+        # Note: the +8 is since we can have, at maximum, "\r\n--" + boundary +
+        # "--\r\n" at the final boundary, and the length of '\r\n--' and
+        # '--\r\n' is 8 bytes.
+        self.lookbehind = [NULL for x in range(len(boundary) + 8)]
+
+    def write(self, data):
+        """Write some data to the parser, which will perform size verification,
+        and then parse the data into the appropriate location (e.g. header,
+        data, etc.), and pass this on to the underlying callback.  If an error
+        is encountered, a MultipartParseError will be raised.  The "offset"
+        attribute on the raised exception will be set to the offset of the byte
+        in the input chunk that caused the error.
+
+        :param data: a bytestring
+        """
+        # Handle sizing.
+        data_len = len(data)
+        if (self._current_size + data_len) > self.max_size:
+            # We truncate the length of data that we are to process.
+            new_size = int(self.max_size - self._current_size)
+            self.logger.warning("Current size is %d (max %d), so truncating "
+                                "data length from %d to %d",
+                                self._current_size, self.max_size, data_len,
+                                new_size)
+            data_len = new_size
+
+        l = 0
+        try:
+            l = self._internal_write(data, data_len)
+        finally:
+            self._current_size += l
+
+        return l
+
+    def _internal_write(self, data, length):
+        # Get values from locals.
+        boundary = self.boundary
+
+        # Get our state, flags and index.  These are persisted between calls to
+        # this function.
+        state = self.state
+        index = self.index
+        flags = self.flags
+
+        # Our index defaults to 0.
+        i = 0
+
+        # Set a mark.
+        def set_mark(name):
+            self.marks[name] = i
+
+        # Remove a mark.
+        def delete_mark(name, reset=False):
+            self.marks.pop(name, None)
+
+        # Helper function that makes calling a callback with data easier. The
+        # 'remaining' parameter will callback from the marked value until the
+        # end of the buffer, and reset the mark, instead of deleting it.  This
+        # is used at the end of the function to call our callbacks with any
+        # remaining data in this chunk.
+        def data_callback(name, remaining=False):
+            marked_index = self.marks.get(name)
+            if marked_index is None:
+                return
+
+            # If we're getting remaining data, we ignore the current i value
+            # and just call with the remaining data.
+            if remaining:
+                self.callback(name, data, marked_index, length)
+                self.marks[name] = 0
+
+            # Otherwise, we call it from the mark to the current byte we're
+            # processing.
+            else:
+                self.callback(name, data, marked_index, i)
+                self.marks.pop(name, None)
+
+        # For each byte...
+        while i < length:
+            c = data[i]
+
+            if state == STATE_START:
+                # Skip leading newlines
+                if c == CR or c == LF:
+                    i += 1
+                    self.logger.debug("Skipping leading CR/LF at %d", i)
+                    continue
+
+                # index is used as in index into our boundary.  Set to 0.
+                index = 0
+
+                # Move to the next state, but decrement i so that we re-process
+                # this character.
+                state = STATE_START_BOUNDARY
+                i -= 1
+
+            elif state == STATE_START_BOUNDARY:
+                # Check to ensure that the last 2 characters in our boundary
+                # are CRLF.
+                if index == len(boundary) - 2:
+                    if c != CR:
+                        # Error!
+                        msg = "Did not find CR at end of boundary (%d)" % (i,)
+                        self.logger.warning(msg)
+                        e = MultipartParseError(msg)
+                        e.offset = i
+                        raise e
+
+                    index += 1
+
+                elif index == len(boundary) - 2 + 1:
+                    if c != LF:
+                        msg = "Did not find LF at end of boundary (%d)" % (i,)
+                        self.logger.warning(msg)
+                        e = MultipartParseError(msg)
+                        e.offset = i
+                        raise e
+
+                    # The index is now used for indexing into our boundary.
+                    index = 0
+
+                    # Callback for the start of a part.
+                    self.callback('part_begin')
+
+                    # Move to the next character and state.
+                    state = STATE_HEADER_FIELD_START
+
+                else:
+                    # Check to ensure our boundary matches
+                    if c != boundary[index + 2]:
+                        msg = "Did not find boundary character %r at index " \
+                              "%d" % (c, index + 2)
+                        self.logger.warning(msg)
+                        e = MultipartParseError(msg)
+                        e.offset = i
+                        raise e
+
+                    # Increment index into boundary and continue.
+                    index += 1
+
+            elif state == STATE_HEADER_FIELD_START:
+                # Mark the start of a header field here, reset the index, and
+                # continue parsing our header field.
+                index = 0
+
+                # Set a mark of our header field.
+                set_mark('header_field')
+
+                # Move to parsing header fields.
+                state = STATE_HEADER_FIELD
+                i -= 1
+
+            elif state == STATE_HEADER_FIELD:
+                # If we've reached a CR at the beginning of a header, it means
+                # that we've reached the second of 2 newlines, and so there are
+                # no more headers to parse.
+                if c == CR:
+                    delete_mark('header_field')
+                    state = STATE_HEADERS_ALMOST_DONE
+                    i += 1
+                    continue
+
+                # Increment our index in the header.
+                index += 1
+
+                # Do nothing if we encounter a hyphen.
+                if c == HYPHEN:
+                    pass
+
+                # If we've reached a colon, we're done with this header.
+                elif c == COLON:
+                    # A 0-length header is an error.
+                    if index == 1:
+                        msg = "Found 0-length header at %d" % (i,)
+                        self.logger.warning(msg)
+                        e = MultipartParseError(msg)
+                        e.offset = i
+                        raise e
+
+                    # Call our callback with the header field.
+                    data_callback('header_field')
+
+                    # Move to parsing the header value.
+                    state = STATE_HEADER_VALUE_START
+
+                else:
+                    # Lower-case this character, and ensure that it is in fact
+                    # a valid letter.  If not, it's an error.
+                    cl = lower_char(c)
+                    if cl < LOWER_A or cl > LOWER_Z:
+                        msg = "Found non-alphanumeric character %r in " \
+                              "header at %d" % (c, i)
+                        self.logger.warning(msg)
+                        e = MultipartParseError(msg)
+                        e.offset = i
+                        raise e
+
+            elif state == STATE_HEADER_VALUE_START:
+                # Skip leading spaces.
+                if c == SPACE:
+                    i += 1
+                    continue
+
+                # Mark the start of the header value.
+                set_mark('header_value')
+
+                # Move to the header-value state, reprocessing this character.
+                state = STATE_HEADER_VALUE
+                i -= 1
+
+            elif state == STATE_HEADER_VALUE:
+                # If we've got a CR, we're nearly done our headers.  Otherwise,
+                # we do nothing and just move past this character.
+                if c == CR:
+                    data_callback('header_value')
+                    self.callback('header_end')
+                    state = STATE_HEADER_VALUE_ALMOST_DONE
+
+            elif state == STATE_HEADER_VALUE_ALMOST_DONE:
+                # The last character should be a LF.  If not, it's an error.
+                if c != LF:
+                    msg = "Did not find LF character at end of header " \
+                          "(found %r)" % (c,)
+                    self.logger.warning(msg)
+                    e = MultipartParseError(msg)
+                    e.offset = i
+                    raise e
+
+                # Move back to the start of another header.  Note that if that
+                # state detects ANOTHER newline, it'll trigger the end of our
+                # headers.
+                state = STATE_HEADER_FIELD_START
+
+            elif state == STATE_HEADERS_ALMOST_DONE:
+                # We're almost done our headers.  This is reached when we parse
+                # a CR at the beginning of a header, so our next character
+                # should be a LF, or it's an error.
+                if c != LF:
+                    msg = "Did not find LF at end of headers (found %r)" % (c,)
+                    self.logger.warning(msg)
+                    e = MultipartParseError(msg)
+                    e.offset = i
+                    raise e
+
+                self.callback('headers_finished')
+                state = STATE_PART_DATA_START
+
+            elif state == STATE_PART_DATA_START:
+                # Mark the start of our part data.
+                set_mark('part_data')
+
+                # Start processing part data, including this character.
+                state = STATE_PART_DATA
+                i -= 1
+
+            elif state == STATE_PART_DATA:
+                # We're processing our part data right now.  During this, we
+                # need to efficiently search for our boundary, since any data
+                # on any number of lines can be a part of the current data.
+                # We use the Boyer-Moore-Horspool algorithm to efficiently
+                # search through the remainder of the buffer looking for our
+                # boundary.
+
+                # Save the current value of our index.  We use this in case we
+                # find part of a boundary, but it doesn't match fully.
+                prev_index = index
+
+                # Set up variables.
+                boundary_length = len(boundary)
+                boundary_end = boundary_length - 1
+                data_length = length
+                boundary_chars = self.boundary_chars
+
+                # If our index is 0, we're starting a new part, so start our
+                # search.
+                if index == 0:
+                    # Search forward until we either hit the end of our buffer,
+                    # or reach a character that's in our boundary.
+                    i += boundary_end
+                    while i < data_length - 1 and data[i] not in boundary_chars:
+                        i += boundary_length
+
+                    # Reset i back the length of our boundary, which is the
+                    # earliest possible location that could be our match (i.e.
+                    # if we've just broken out of our loop since we saw the
+                    # last character in our boundary)
+                    i -= boundary_end
+                    c = data[i]
+
+                # Now, we have a couple of cases here.  If our index is before
+                # the end of the boundary...
+                if index < boundary_length:
+                    # If the character matches...
+                    if boundary[index] == c:
+                        # If we found a match for our boundary, we send the
+                        # existing data.
+                        if index == 0:
+                            data_callback('part_data')
+
+                        # The current character matches, so continue!
+                        index += 1
+                    else:
+                        index = 0
+
+                # Our index is equal to the length of our boundary!
+                elif index == boundary_length:
+                    # First we increment it.
+                    index += 1
+
+                    # Now, if we've reached a newline, we need to set this as
+                    # the potential end of our boundary.
+                    if c == CR:
+                        flags |= FLAG_PART_BOUNDARY
+
+                    # Otherwise, if this is a hyphen, we might be at the last
+                    # of all boundaries.
+                    elif c == HYPHEN:
+                        flags |= FLAG_LAST_BOUNDARY
+
+                    # Otherwise, we reset our index, since this isn't either a
+                    # newline or a hyphen.
+                    else:
+                        index = 0
+
+                # Our index is right after the part boundary, which should be
+                # a LF.
+                elif index == boundary_length + 1:
+                    # If we're at a part boundary (i.e. we've seen a CR
+                    # character already)...
+                    if flags & FLAG_PART_BOUNDARY:
+                        # We need a LF character next.
+                        if c == LF:
+                            # Unset the part boundary flag.
+                            flags &= (~FLAG_PART_BOUNDARY)
+
+                            # Callback indicating that we've reached the end of
+                            # a part, and are starting a new one.
+                            self.callback('part_end')
+                            self.callback('part_begin')
+
+                            # Move to parsing new headers.
+                            index = 0
+                            state = STATE_HEADER_FIELD_START
+                            i += 1
+                            continue
+
+                        # We didn't find an LF character, so no match.  Reset
+                        # our index and clear our flag.
+                        index = 0
+                        flags &= (~FLAG_PART_BOUNDARY)
+
+                    # Otherwise, if we're at the last boundary (i.e. we've
+                    # seen a hyphen already)...
+                    elif flags & FLAG_LAST_BOUNDARY:
+                        # We need a second hyphen here.
+                        if c == HYPHEN:
+                            # Callback to end the current part, and then the
+                            # message.
+                            self.callback('part_end')
+                            self.callback('end')
+                            state = STATE_END
+                        else:
+                            # No match, so reset index.
+                            index = 0
+
+                # If we have an index, we need to keep this byte for later, in
+                # case we can't match the full boundary.
+                if index > 0:
+                    self.lookbehind[index - 1] = c
+
+                # Otherwise, our index is 0.  If the previous index is not, it
+                # means we reset something, and we need to take the data we
+                # thought was part of our boundary and send it along as actual
+                # data.
+                elif prev_index > 0:
+                    # Callback to write the saved data.
+                    lb_data = join_bytes(self.lookbehind)
+                    self.callback('part_data', lb_data, 0, prev_index)
+
+                    # Overwrite our previous index.
+                    prev_index = 0
+
+                    # Re-set our mark for part data.
+                    set_mark('part_data')
+
+                    # Re-consider the current character, since this could be
+                    # the start of the boundary itself.
+                    i -= 1
+
+            elif state == STATE_END:
+                # Do nothing and just consume a byte in the end state.
+                if c not in (CR, LF):
+                    self.logger.warning("Consuming a byte '0x%x' in the end state", c)
+
+            else:                   # pragma: no cover (error case)
+                # We got into a strange state somehow!  Just stop processing.
+                msg = "Reached an unknown state %d at %d" % (state, i)
+                self.logger.warning(msg)
+                e = MultipartParseError(msg)
+                e.offset = i
+                raise e
+
+            # Move to the next byte.
+            i += 1
+
+        # We call our callbacks with any remaining data.  Note that we pass
+        # the 'remaining' flag, which sets the mark back to 0 instead of
+        # deleting it, if it's found.  This is because, if the mark is found
+        # at this point, we assume that there's data for one of these things
+        # that has been parsed, but not yet emitted.  And, as such, it implies
+        # that we haven't yet reached the end of this 'thing'.  So, by setting
+        # the mark to 0, we cause any data callbacks that take place in future
+        # calls to this function to start from the beginning of that buffer.
+        data_callback('header_field', True)
+        data_callback('header_value', True)
+        data_callback('part_data', True)
+
+        # Save values to locals.
+        self.state = state
+        self.index = index
+        self.flags = flags
+
+        # Return our data length to indicate no errors, and that we processed
+        # all of it.
+        return length
+
+    def finalize(self):
+        """Finalize this parser, which signals to that we are finished parsing.
+
+        Note: It does not currently, but in the future, it will verify that we
+        are in the final state of the parser (i.e. the end of the multipart
+        message is well-formed), and, if not, throw an error.
+        """
+        # TODO: verify that we're in the state STATE_END, otherwise throw an
+        # error or otherwise state that we're not finished parsing.
+        pass
+
+    def __repr__(self):
+        return "%s(boundary=%r)" % (self.__class__.__name__, self.boundary)
+
+
+class FormParser(object):
+    """This class is the all-in-one form parser.  Given all the information
+    necessary to parse a form, it will instantiate the correct parser, create
+    the proper :class:`Field` and :class:`File` classes to store the data that
+    is parsed, and call the two given callbacks with each field and file as
+    they become available.
+
+    :param content_type: The Content-Type of the incoming request.  This is
+                         used to select the appropriate parser.
+
+    :param on_field: The callback to call when a field has been parsed and is
+                     ready for usage.  See above for parameters.
+
+    :param on_file: The callback to call when a file has been parsed and is
+                    ready for usage.  See above for parameters.
+
+    :param on_end: An optional callback to call when all fields and files in a
+                   request has been parsed.  Can be None.
+
+    :param boundary: If the request is a multipart/form-data request, this
+                     should be the boundary of the request, as given in the
+                     Content-Type header, as a bytestring.
+
+    :param file_name: If the request is of type application/octet-stream, then
+                      the body of the request will not contain any information
+                      about the uploaded file.  In such cases, you can provide
+                      the file name of the uploaded file manually.
+
+    :param FileClass: The class to use for uploaded files.  Defaults to
+                      :class:`File`, but you can provide your own class if you
+                      wish to customize behaviour.  The class will be
+                      instantiated as FileClass(file_name, field_name), and it
+                      must provide the folllowing functions::
+                          file_instance.write(data)
+                          file_instance.finalize()
+                          file_instance.close()
+
+    :param FieldClass: The class to use for uploaded fields.  Defaults to
+                       :class:`Field`, but you can provide your own class if
+                       you wish to customize behaviour.  The class will be
+                       instantiated as FieldClass(field_name), and it must
+                       provide the folllowing functions::
+                           field_instance.write(data)
+                           field_instance.finalize()
+                           field_instance.close()
+
+    :param config: Configuration to use for this FormParser.  The default
+                   values are taken from the DEFAULT_CONFIG value, and then
+                   any keys present in this dictionary will overwrite the
+                   default values.
+
+    """
+    #: This is the default configuration for our form parser.
+    #: Note: all file sizes should be in bytes.
+    DEFAULT_CONFIG = {
+        'MAX_BODY_SIZE': float('inf'),
+        'MAX_MEMORY_FILE_SIZE': 1 * 1024 * 1024,
+        'UPLOAD_DIR': None,
+        'UPLOAD_KEEP_FILENAME': False,
+        'UPLOAD_KEEP_EXTENSIONS': False,
+
+        # Error on invalid Content-Transfer-Encoding?
+        'UPLOAD_ERROR_ON_BAD_CTE': False,
+    }
+
+    def __init__(self, content_type, on_field, on_file, on_end=None,
+                 boundary=None, file_name=None, FileClass=File,
+                 FieldClass=Field, config={}):
+
+        self.logger = logging.getLogger(__name__)
+
+        # Save variables.
+        self.content_type = content_type
+        self.boundary = boundary
+        self.bytes_received = 0
+        self.parser = None
+
+        # Save callbacks.
+        self.on_field = on_field
+        self.on_file = on_file
+        self.on_end = on_end
+
+        # Save classes.
+        self.FileClass = File
+        self.FieldClass = Field
+
+        # Set configuration options.
+        self.config = self.DEFAULT_CONFIG.copy()
+        self.config.update(config)
+
+        # Depending on the Content-Type, we instantiate the correct parser.
+        if content_type == 'application/octet-stream':
+            # Work around the lack of 'nonlocal' in Py2
+            class vars(object):
+                f = None
+
+            def on_start():
+                vars.f = FileClass(file_name, None, config=self.config)
+
+            def on_data(data, start, end):
+                vars.f.write(data[start:end])
+
+            def on_end():
+                # Finalize the file itself.
+                vars.f.finalize()
+
+                # Call our callback.
+                on_file(vars.f)
+
+                # Call the on-end callback.
+                if self.on_end is not None:
+                    self.on_end()
+
+            callbacks = {
+                'on_start': on_start,
+                'on_data': on_data,
+                'on_end': on_end,
+            }
+
+            # Instantiate an octet-stream parser
+            parser = OctetStreamParser(callbacks,
+                                       max_size=self.config['MAX_BODY_SIZE'])
+
+        elif (content_type == 'application/x-www-form-urlencoded' or
+              content_type == 'application/x-url-encoded'):
+
+            name_buffer = []
+
+            class vars(object):
+                f = None
+
+            def on_field_start():
+                pass
+
+            def on_field_name(data, start, end):
+                name_buffer.append(data[start:end])
+
+            def on_field_data(data, start, end):
+                if vars.f is None:
+                    vars.f = FieldClass(b''.join(name_buffer))
+                    del name_buffer[:]
+                vars.f.write(data[start:end])
+
+            def on_field_end():
+                # Finalize and call callback.
+                if vars.f is None:
+                    # If we get here, it's because there was no field data.
+                    # We create a field, set it to None, and then continue.
+                    vars.f = FieldClass(b''.join(name_buffer))
+                    del name_buffer[:]
+                    vars.f.set_none()
+
+                vars.f.finalize()
+                on_field(vars.f)
+                vars.f = None
+
+            def on_end():
+                if self.on_end is not None:
+                    self.on_end()
+
+            # Setup callbacks.
+            callbacks = {
+                'on_field_start': on_field_start,
+                'on_field_name': on_field_name,
+                'on_field_data': on_field_data,
+                'on_field_end': on_field_end,
+                'on_end': on_end,
+            }
+
+            # Instantiate parser.
+            parser = QuerystringParser(
+                callbacks=callbacks,
+                max_size=self.config['MAX_BODY_SIZE']
+            )
+
+        elif content_type == 'multipart/form-data':
+            if boundary is None:
+                self.logger.error("No boundary given")
+                raise FormParserError("No boundary given")
+
+            header_name = []
+            header_value = []
+            headers = {}
+
+            # No 'nonlocal' on Python 2 :-(
+            class vars(object):
+                f = None
+                writer = None
+                is_file = False
+
+            def on_part_begin():
+                pass
+
+            def on_part_data(data, start, end):
+                bytes_processed = vars.writer.write(data[start:end])
+                # TODO: check for error here.
+                return bytes_processed
+
+            def on_part_end():
+                vars.f.finalize()
+                if vars.is_file:
+                    on_file(vars.f)
+                else:
+                    on_field(vars.f)
+
+            def on_header_field(data, start, end):
+                header_name.append(data[start:end])
+
+            def on_header_value(data, start, end):
+                header_value.append(data[start:end])
+
+            def on_header_end():
+                headers[b''.join(header_name)] = b''.join(header_value)
+                del header_name[:]
+                del header_value[:]
+
+            def on_headers_finished():
+                # Reset the 'is file' flag.
+                vars.is_file = False
+
+                # Parse the content-disposition header.
+                # TODO: handle mixed case
+                content_disp = headers.get(b'Content-Disposition')
+                disp, options = parse_options_header(content_disp)
+
+                # Get the field and filename.
+                field_name = options.get(b'name')
+                file_name = options.get(b'filename')
+                # TODO: check for errors
+
+                # Create the proper class.
+                if file_name is None:
+                    vars.f = FieldClass(field_name)
+                else:
+                    vars.f = FileClass(file_name, field_name, config=self.config)
+                    vars.is_file = True
+
+                # Parse the given Content-Transfer-Encoding to determine what
+                # we need to do with the incoming data.
+                # TODO: check that we properly handle 8bit / 7bit encoding.
+                transfer_encoding = headers.get(b'Content-Transfer-Encoding',
+                                                b'7bit')
+
+                if (transfer_encoding == b'binary' or
+                        transfer_encoding == b'8bit' or
+                        transfer_encoding == b'7bit'):
+                    vars.writer = vars.f
+
+                elif transfer_encoding == b'base64':
+                    vars.writer = Base64Decoder(vars.f)
+
+                elif transfer_encoding == b'quoted-printable':
+                    vars.writer = QuotedPrintableDecoder(vars.f)
+
+                else:
+                    self.logger.warning("Unknown Content-Transfer-Encoding: "
+                                        "%r", transfer_encoding)
+                    if self.config['UPLOAD_ERROR_ON_BAD_CTE']:
+                        raise FormParserError(
+                            'Unknown Content-Transfer-Encoding "{0}"'.format(
+                                transfer_encoding
+                            )
+                        )
+                    else:
+                        # If we aren't erroring, then we just treat this as an
+                        # unencoded Content-Transfer-Encoding.
+                        vars.writer = vars.f
+
+            def on_end():
+                vars.writer.finalize()
+                if self.on_end is not None:
+                    self.on_end()
+
+            # These are our callbacks for the parser.
+            callbacks = {
+                'on_part_begin': on_part_begin,
+                'on_part_data': on_part_data,
+                'on_part_end': on_part_end,
+                'on_header_field': on_header_field,
+                'on_header_value': on_header_value,
+                'on_header_end': on_header_end,
+                'on_headers_finished': on_headers_finished,
+                'on_end': on_end,
+            }
+
+            # Instantiate a multipart parser.
+            parser = MultipartParser(boundary, callbacks,
+                                     max_size=self.config['MAX_BODY_SIZE'])
+
+        else:
+            self.logger.warning("Unknown Content-Type: %r", content_type)
+            raise FormParserError("Unknown Content-Type: {0}".format(
+                content_type
+            ))
+
+        self.parser = parser
+
+    def write(self, data):
+        """Write some data.  The parser will forward this to the appropriate
+        underlying parser.
+
+        :param data: a bytestring
+        """
+        self.bytes_received += len(data)
+        # TODO: check the parser's return value for errors?
+        return self.parser.write(data)
+
+    def finalize(self):
+        """Finalize the parser."""
+        if self.parser is not None and hasattr(self.parser, 'finalize'):
+            self.parser.finalize()
+
+    def close(self):
+        """Close the parser."""
+        if self.parser is not None and hasattr(self.parser, 'close'):
+            self.parser.close()
+
+    def __repr__(self):
+        return "%s(content_type=%r, parser=%r)" % (
+            self.__class__.__name__,
+            self.content_type,
+            self.parser,
+        )
+
+
+def create_form_parser(headers, on_field, on_file, trust_x_headers=False,
+                       config={}):
+    """This function is a helper function to aid in creating a FormParser
+    instances.  Given a dictionary-like headers object, it will determine
+    the correct information needed, instantiate a FormParser with the
+    appropriate values and given callbacks, and then return the corresponding
+    parser.
+
+    :param headers: A dictionary-like object of HTTP headers.  The only
+                    required header is Content-Type.
+
+    :param on_field: Callback to call with each parsed field.
+
+    :param on_file: Callback to call with each parsed file.
+
+    :param trust_x_headers: Whether or not to trust information received from
+                            certain X-Headers - for example, the file name from
+                            X-File-Name.
+
+    :param config: Configuration variables to pass to the FormParser.
+    """
+    content_type = headers.get('Content-Type')
+    if content_type is None:
+        logging.getLogger(__name__).warning("No Content-Type header given")
+        raise ValueError("No Content-Type header given!")
+
+    # Boundaries are optional (the FormParser will raise if one is needed
+    # but not given).
+    content_type, params = parse_options_header(content_type)
+    boundary = params.get(b'boundary')
+
+    # We need content_type to be a string, not a bytes object.
+    content_type = content_type.decode('latin-1')
+
+    # File names are optional.
+    file_name = headers.get('X-File-Name')
+
+    # Instantiate a form parser.
+    form_parser = FormParser(content_type,
+                             on_field,
+                             on_file,
+                             boundary=boundary,
+                             file_name=file_name,
+                             config=config)
+
+    # Return our parser.
+    return form_parser
+
+
+def parse_form(headers, input_stream, on_field, on_file, chunk_size=1048576,
+               **kwargs):
+    """This function is useful if you just want to parse a request body,
+    without too much work.  Pass it a dictionary-like object of the request's
+    headers, and a file-like object for the input stream, along with two
+    callbacks that will get called whenever a field or file is parsed.
+
+    :param headers: A dictionary-like object of HTTP headers.  The only
+                    required header is Content-Type.
+
+    :param input_stream: A file-like object that represents the request body.
+                         The read() method must return bytestrings.
+
+    :param on_field: Callback to call with each parsed field.
+
+    :param on_file: Callback to call with each parsed file.
+
+    :param chunk_size: The maximum size to read from the input stream and write
+                       to the parser at one time.  Defaults to 1 MiB.
+    """
+
+    # Create our form parser.
+    parser = create_form_parser(headers, on_field, on_file)
+
+    # Read chunks of 100KiB and write to the parser, but never read more than
+    # the given Content-Length, if any.
+    content_length = headers.get('Content-Length')
+    if content_length is not None:
+        content_length = int(content_length)
+    else:
+        content_length = float('inf')
+    bytes_read = 0
+
+    while True:
+        # Read only up to the Content-Length given.
+        max_readable = min(content_length - bytes_read, 1048576)
+        buff = input_stream.read(max_readable)
+
+        # Write to the parser and update our length.
+        parser.write(buff)
+        bytes_read += len(buff)
+
+        # If we get a buffer that's smaller than the size requested, or if we
+        # have read up to our content length, we're done.
+        if len(buff) != max_readable or bytes_read == content_length:
+            break
+
+    # Tell our parser that we're done writing data.
+    parser.finalize()
diff --git a/myenv/lib/python3.9/site-packages/multipart/tests/__init__.py b/myenv/lib/python3.9/site-packages/multipart/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/multipart/tests/compat.py b/myenv/lib/python3.9/site-packages/multipart/tests/compat.py
new file mode 100644
index 0000000..7a3479e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/multipart/tests/compat.py
@@ -0,0 +1,138 @@
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+
+import os
+import re
+import sys
+import types
+import functools
+
+
+def ensure_in_path(path):
+    """
+    Ensure that a given path is in the sys.path array
+    """
+    if not os.path.isdir(path):
+        raise RuntimeError('Tried to add nonexisting path')
+
+    def _samefile(x, y):
+        try:
+            return os.path.samefile(x, y)
+        except (IOError, OSError):
+            return False
+        except AttributeError:
+            # Probably on Windows.
+            path1 = os.path.abspath(x).lower()
+            path2 = os.path.abspath(y).lower()
+            return path1 == path2
+
+    # Remove existing copies of it.
+    for pth in sys.path:
+        if _samefile(pth, path):
+            sys.path.remove(pth)
+
+    # Add it at the beginning.
+    sys.path.insert(0, path)
+
+
+# Check if pytest is imported.  If so, we use it to create marking decorators.
+# If not, we just create a function that does nothing.
+try:
+    import pytest
+except ImportError:
+    pytest = None
+
+if pytest is not None:
+    slow_test = pytest.mark.slow_test
+    xfail = pytest.mark.xfail
+
+else:
+    slow_test = lambda x: x
+
+    def xfail(*args, **kwargs):
+        if len(args) > 0 and isinstance(args[0], types.FunctionType):
+            return args[0]
+
+        return lambda x: x
+
+
+# We don't use the py.test parametrizing function, since it seems to break
+# with unittest.TestCase subclasses.
+def parametrize(field_names, field_values):
+    # If we're not given a list of field names, we make it.
+    if not isinstance(field_names, (tuple, list)):
+        field_names = (field_names,)
+        field_values = [(val,) for val in field_values]
+
+    # Create a decorator that saves this list of field names and values on the
+    # function for later parametrizing.
+    def decorator(func):
+        func.__dict__['param_names'] = field_names
+        func.__dict__['param_values'] = field_values
+        return func
+
+    return decorator
+
+
+# This is a metaclass that actually performs the parametrization.
+class ParametrizingMetaclass(type):
+    IDENTIFIER_RE = re.compile('[^A-Za-z0-9]')
+
+    def __new__(klass, name, bases, attrs):
+        new_attrs = attrs.copy()
+        for attr_name, attr in attrs.items():
+            # We only care about functions
+            if not isinstance(attr, types.FunctionType):
+                continue
+
+            param_names = attr.__dict__.pop('param_names', None)
+            param_values = attr.__dict__.pop('param_values', None)
+            if param_names is None or param_values is None:
+                continue
+
+            # Create multiple copies of the function.
+            for i, values in enumerate(param_values):
+                assert len(param_names) == len(values)
+
+                # Get a repr of the values, and fix it to be a valid identifier
+                human = '_'.join(
+                    [klass.IDENTIFIER_RE.sub('', repr(x)) for x in values]
+                )
+
+                # Create a new name.
+                # new_name = attr.__name__ + "_%d" % i
+                new_name = attr.__name__ + "__" + human
+
+                # Create a replacement function.
+                def create_new_func(func, names, values):
+                    # Create a kwargs dictionary.
+                    kwargs = dict(zip(names, values))
+
+                    @functools.wraps(func)
+                    def new_func(self):
+                        return func(self, **kwargs)
+
+                    # Manually set the name and return the new function.
+                    new_func.__name__ = new_name
+                    return new_func
+
+                # Actually create the new function.
+                new_func = create_new_func(attr, param_names, values)
+
+                # Save this new function in our attrs dict.
+                new_attrs[new_name] = new_func
+
+            # Remove the old attribute from our new dictionary.
+            del new_attrs[attr_name]
+
+        # We create the class as normal, except we use our new attributes.
+        return type.__new__(klass, name, bases, new_attrs)
+
+
+# This is a class decorator that actually applies the above metaclass.
+def parametrize_class(klass):
+    return ParametrizingMetaclass(klass.__name__,
+                                  klass.__bases__,
+                                  klass.__dict__)
diff --git a/myenv/lib/python3.9/site-packages/multipart/tests/test_multipart.py b/myenv/lib/python3.9/site-packages/multipart/tests/test_multipart.py
new file mode 100644
index 0000000..dbb7ff1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/multipart/tests/test_multipart.py
@@ -0,0 +1,1306 @@
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import glob
+import yaml
+import base64
+import random
+import tempfile
+from .compat import (
+    parametrize,
+    parametrize_class,
+    slow_test,
+    unittest,
+)
+from io import BytesIO
+from six import binary_type, text_type
+
+from mock import MagicMock, Mock, patch
+
+from ..multipart import *
+
+
+# Get the current directory for our later test cases.
+curr_dir = os.path.abspath(os.path.dirname(__file__))
+
+
+def force_bytes(val):
+    if isinstance(val, text_type):
+        val = val.encode(sys.getfilesystemencoding())
+
+    return val
+
+
+class TestField(unittest.TestCase):
+    def setUp(self):
+        self.f = Field('foo')
+
+    def test_name(self):
+        self.assertEqual(self.f.field_name, 'foo')
+
+    def test_data(self):
+        self.f.write(b'test123')
+        self.assertEqual(self.f.value, b'test123')
+
+    def test_cache_expiration(self):
+        self.f.write(b'test')
+        self.assertEqual(self.f.value, b'test')
+        self.f.write(b'123')
+        self.assertEqual(self.f.value, b'test123')
+
+    def test_finalize(self):
+        self.f.write(b'test123')
+        self.f.finalize()
+        self.assertEqual(self.f.value, b'test123')
+
+    def test_close(self):
+        self.f.write(b'test123')
+        self.f.close()
+        self.assertEqual(self.f.value, b'test123')
+
+    def test_from_value(self):
+        f = Field.from_value(b'name', b'value')
+        self.assertEqual(f.field_name, b'name')
+        self.assertEqual(f.value, b'value')
+
+        f2 = Field.from_value(b'name', None)
+        self.assertEqual(f2.value, None)
+
+    def test_equality(self):
+        f1 = Field.from_value(b'name', b'value')
+        f2 = Field.from_value(b'name', b'value')
+
+        self.assertEqual(f1, f2)
+
+    def test_equality_with_other(self):
+        f = Field.from_value(b'foo', b'bar')
+        self.assertFalse(f == b'foo')
+        self.assertFalse(b'foo' == f)
+
+    def test_set_none(self):
+        f = Field(b'foo')
+        self.assertEqual(f.value, b'')
+
+        f.set_none()
+        self.assertEqual(f.value, None)
+
+
+class TestFile(unittest.TestCase):
+    def setUp(self):
+        self.c = {}
+        self.d = force_bytes(tempfile.mkdtemp())
+        self.f = File(b'foo.txt', config=self.c)
+
+    def assert_data(self, data):
+        f = self.f.file_object
+        f.seek(0)
+        self.assertEqual(f.read(), data)
+        f.seek(0)
+        f.truncate()
+
+    def assert_exists(self):
+        full_path = os.path.join(self.d, self.f.actual_file_name)
+        self.assertTrue(os.path.exists(full_path))
+
+    def test_simple(self):
+        self.f.write(b'foobar')
+        self.assert_data(b'foobar')
+
+    def test_invalid_write(self):
+        m = Mock()
+        m.write.return_value = 5
+        self.f._fileobj = m
+        v = self.f.write(b'foobar')
+        self.assertEqual(v, 5)
+
+    def test_file_fallback(self):
+        self.c['MAX_MEMORY_FILE_SIZE'] = 1
+
+        self.f.write(b'1')
+        self.assertTrue(self.f.in_memory)
+        self.assert_data(b'1')
+
+        self.f.write(b'123')
+        self.assertFalse(self.f.in_memory)
+        self.assert_data(b'123')
+
+        # Test flushing too.
+        old_obj = self.f.file_object
+        self.f.flush_to_disk()
+        self.assertFalse(self.f.in_memory)
+        self.assertIs(self.f.file_object, old_obj)
+
+    def test_file_fallback_with_data(self):
+        self.c['MAX_MEMORY_FILE_SIZE'] = 10
+
+        self.f.write(b'1' * 10)
+        self.assertTrue(self.f.in_memory)
+
+        self.f.write(b'2' * 10)
+        self.assertFalse(self.f.in_memory)
+
+        self.assert_data(b'11111111112222222222')
+
+    def test_file_name(self):
+        # Write to this dir.
+        self.c['UPLOAD_DIR'] = self.d
+        self.c['MAX_MEMORY_FILE_SIZE'] = 10
+
+        # Write.
+        self.f.write(b'12345678901')
+        self.assertFalse(self.f.in_memory)
+
+        # Assert that the file exists
+        self.assertIsNotNone(self.f.actual_file_name)
+        self.assert_exists()
+
+    def test_file_full_name(self):
+        # Write to this dir.
+        self.c['UPLOAD_DIR'] = self.d
+        self.c['UPLOAD_KEEP_FILENAME'] = True
+        self.c['MAX_MEMORY_FILE_SIZE'] = 10
+
+        # Write.
+        self.f.write(b'12345678901')
+        self.assertFalse(self.f.in_memory)
+
+        # Assert that the file exists
+        self.assertEqual(self.f.actual_file_name, b'foo')
+        self.assert_exists()
+
+    def test_file_full_name_with_ext(self):
+        self.c['UPLOAD_DIR'] = self.d
+        self.c['UPLOAD_KEEP_FILENAME'] = True
+        self.c['UPLOAD_KEEP_EXTENSIONS'] = True
+        self.c['MAX_MEMORY_FILE_SIZE'] = 10
+
+        # Write.
+        self.f.write(b'12345678901')
+        self.assertFalse(self.f.in_memory)
+
+        # Assert that the file exists
+        self.assertEqual(self.f.actual_file_name, b'foo.txt')
+        self.assert_exists()
+
+    def test_file_full_name_with_ext(self):
+        self.c['UPLOAD_DIR'] = self.d
+        self.c['UPLOAD_KEEP_FILENAME'] = True
+        self.c['UPLOAD_KEEP_EXTENSIONS'] = True
+        self.c['MAX_MEMORY_FILE_SIZE'] = 10
+
+        # Write.
+        self.f.write(b'12345678901')
+        self.assertFalse(self.f.in_memory)
+
+        # Assert that the file exists
+        self.assertEqual(self.f.actual_file_name, b'foo.txt')
+        self.assert_exists()
+
+    def test_no_dir_with_extension(self):
+        self.c['UPLOAD_KEEP_EXTENSIONS'] = True
+        self.c['MAX_MEMORY_FILE_SIZE'] = 10
+
+        # Write.
+        self.f.write(b'12345678901')
+        self.assertFalse(self.f.in_memory)
+
+        # Assert that the file exists
+        ext = os.path.splitext(self.f.actual_file_name)[1]
+        self.assertEqual(ext, b'.txt')
+        self.assert_exists()
+
+    def test_invalid_dir_with_name(self):
+        # Write to this dir.
+        self.c['UPLOAD_DIR'] = force_bytes(os.path.join('/', 'tmp', 'notexisting'))
+        self.c['UPLOAD_KEEP_FILENAME'] = True
+        self.c['MAX_MEMORY_FILE_SIZE'] = 5
+
+        # Write.
+        with self.assertRaises(FileError):
+            self.f.write(b'1234567890')
+
+    def test_invalid_dir_no_name(self):
+        # Write to this dir.
+        self.c['UPLOAD_DIR'] = force_bytes(os.path.join('/', 'tmp', 'notexisting'))
+        self.c['UPLOAD_KEEP_FILENAME'] = False
+        self.c['MAX_MEMORY_FILE_SIZE'] = 5
+
+        # Write.
+        with self.assertRaises(FileError):
+            self.f.write(b'1234567890')
+
+    # TODO: test uploading two files with the same name.
+
+
+class TestParseOptionsHeader(unittest.TestCase):
+    def test_simple(self):
+        t, p = parse_options_header('application/json')
+        self.assertEqual(t, b'application/json')
+        self.assertEqual(p, {})
+
+    def test_blank(self):
+        t, p = parse_options_header('')
+        self.assertEqual(t, b'')
+        self.assertEqual(p, {})
+
+    def test_single_param(self):
+        t, p = parse_options_header('application/json;par=val')
+        self.assertEqual(t, b'application/json')
+        self.assertEqual(p, {b'par': b'val'})
+
+    def test_single_param_with_spaces(self):
+        t, p = parse_options_header(b'application/json;     par=val')
+        self.assertEqual(t, b'application/json')
+        self.assertEqual(p, {b'par': b'val'})
+
+    def test_multiple_params(self):
+        t, p = parse_options_header(b'application/json;par=val;asdf=foo')
+        self.assertEqual(t, b'application/json')
+        self.assertEqual(p, {b'par': b'val', b'asdf': b'foo'})
+
+    def test_quoted_param(self):
+        t, p = parse_options_header(b'application/json;param="quoted"')
+        self.assertEqual(t, b'application/json')
+        self.assertEqual(p, {b'param': b'quoted'})
+
+    def test_quoted_param_with_semicolon(self):
+        t, p = parse_options_header(b'application/json;param="quoted;with;semicolons"')
+        self.assertEqual(p[b'param'], b'quoted;with;semicolons')
+
+    def test_quoted_param_with_escapes(self):
+        t, p = parse_options_header(b'application/json;param="This \\" is \\" a \\" quote"')
+        self.assertEqual(p[b'param'], b'This " is " a " quote')
+
+    def test_handles_ie6_bug(self):
+        t, p = parse_options_header(b'text/plain; filename="C:\\this\\is\\a\\path\\file.txt"')
+
+        self.assertEqual(p[b'filename'], b'file.txt')
+
+
+class TestBaseParser(unittest.TestCase):
+    def setUp(self):
+        self.b = BaseParser()
+        self.b.callbacks = {}
+
+    def test_callbacks(self):
+        # The stupid list-ness is to get around lack of nonlocal on py2
+        l = [0]
+        def on_foo():
+            l[0] += 1
+
+        self.b.set_callback('foo', on_foo)
+        self.b.callback('foo')
+        self.assertEqual(l[0], 1)
+
+        self.b.set_callback('foo', None)
+        self.b.callback('foo')
+        self.assertEqual(l[0], 1)
+
+
+class TestQuerystringParser(unittest.TestCase):
+    def assert_fields(self, *args, **kwargs):
+        if kwargs.pop('finalize', True):
+            self.p.finalize()
+
+        self.assertEqual(self.f, list(args))
+        if kwargs.get('reset', True):
+            self.f = []
+
+    def setUp(self):
+        self.reset()
+
+    def reset(self):
+        self.f = []
+
+        name_buffer = []
+        data_buffer = []
+
+        def on_field_name(data, start, end):
+            name_buffer.append(data[start:end])
+
+        def on_field_data(data, start, end):
+            data_buffer.append(data[start:end])
+
+        def on_field_end():
+            self.f.append((
+                b''.join(name_buffer),
+                b''.join(data_buffer)
+            ))
+
+            del name_buffer[:]
+            del data_buffer[:]
+
+        callbacks = {
+            'on_field_name': on_field_name,
+            'on_field_data': on_field_data,
+            'on_field_end': on_field_end
+        }
+
+        self.p = QuerystringParser(callbacks)
+
+    def test_simple_querystring(self):
+        self.p.write(b'foo=bar')
+
+        self.assert_fields((b'foo', b'bar'))
+
+    def test_querystring_blank_beginning(self):
+        self.p.write(b'&foo=bar')
+
+        self.assert_fields((b'foo', b'bar'))
+
+    def test_querystring_blank_end(self):
+        self.p.write(b'foo=bar&')
+
+        self.assert_fields((b'foo', b'bar'))
+
+    def test_multiple_querystring(self):
+        self.p.write(b'foo=bar&asdf=baz')
+
+        self.assert_fields(
+            (b'foo', b'bar'),
+            (b'asdf', b'baz')
+        )
+
+    def test_streaming_simple(self):
+        self.p.write(b'foo=bar&')
+        self.assert_fields(
+            (b'foo', b'bar'),
+            finalize=False
+        )
+
+        self.p.write(b'asdf=baz')
+        self.assert_fields(
+            (b'asdf', b'baz')
+        )
+
+    def test_streaming_break(self):
+        self.p.write(b'foo=one')
+        self.assert_fields(finalize=False)
+
+        self.p.write(b'two')
+        self.assert_fields(finalize=False)
+
+        self.p.write(b'three')
+        self.assert_fields(finalize=False)
+
+        self.p.write(b'&asd')
+        self.assert_fields(
+            (b'foo', b'onetwothree'),
+            finalize=False
+        )
+
+        self.p.write(b'f=baz')
+        self.assert_fields(
+            (b'asdf', b'baz')
+        )
+
+    def test_semicolon_seperator(self):
+        self.p.write(b'foo=bar;asdf=baz')
+
+        self.assert_fields(
+            (b'foo', b'bar'),
+            (b'asdf', b'baz')
+        )
+
+    def test_too_large_field(self):
+        self.p.max_size = 15
+
+        # Note: len = 8
+        self.p.write(b"foo=bar&")
+        self.assert_fields((b'foo', b'bar'), finalize=False)
+
+        # Note: len = 8, only 7 bytes processed
+        self.p.write(b'a=123456')
+        self.assert_fields((b'a', b'12345'))
+
+    def test_invalid_max_size(self):
+        with self.assertRaises(ValueError):
+            p = QuerystringParser(max_size=-100)
+
+    def test_strict_parsing_pass(self):
+        data = b'foo=bar&another=asdf'
+        for first, last in split_all(data):
+            self.reset()
+            self.p.strict_parsing = True
+
+            print("%r / %r" % (first, last))
+
+            self.p.write(first)
+            self.p.write(last)
+            self.assert_fields((b'foo', b'bar'), (b'another', b'asdf'))
+
+    def test_strict_parsing_fail_double_sep(self):
+        data = b'foo=bar&&another=asdf'
+        for first, last in split_all(data):
+            self.reset()
+            self.p.strict_parsing = True
+
+            cnt = 0
+            with self.assertRaises(QuerystringParseError) as cm:
+                cnt += self.p.write(first)
+                cnt += self.p.write(last)
+                self.p.finalize()
+
+            # The offset should occur at 8 bytes into the data (as a whole),
+            # so we calculate the offset into the chunk.
+            if cm is not None:
+                self.assertEqual(cm.exception.offset, 8 - cnt)
+
+    def test_double_sep(self):
+        data = b'foo=bar&&another=asdf'
+        for first, last in split_all(data):
+            print(" %r / %r " % (first, last))
+            self.reset()
+
+            cnt = 0
+            cnt += self.p.write(first)
+            cnt += self.p.write(last)
+
+            self.assert_fields((b'foo', b'bar'), (b'another', b'asdf'))
+
+    def test_strict_parsing_fail_no_value(self):
+        self.p.strict_parsing = True
+        with self.assertRaises(QuerystringParseError) as cm:
+            self.p.write(b'foo=bar&blank&another=asdf')
+
+        if cm is not None:
+            self.assertEqual(cm.exception.offset, 8)
+
+    def test_success_no_value(self):
+        self.p.write(b'foo=bar&blank&another=asdf')
+        self.assert_fields(
+            (b'foo', b'bar'),
+            (b'blank', b''),
+            (b'another', b'asdf')
+        )
+
+
+class TestOctetStreamParser(unittest.TestCase):
+    def setUp(self):
+        self.d = []
+        self.started = 0
+        self.finished = 0
+
+        def on_start():
+            self.started += 1
+
+        def on_data(data, start, end):
+            self.d.append(data[start:end])
+
+        def on_end():
+            self.finished += 1
+
+        callbacks = {
+            'on_start': on_start,
+            'on_data': on_data,
+            'on_end': on_end
+        }
+
+        self.p = OctetStreamParser(callbacks)
+
+    def assert_data(self, data, finalize=True):
+        self.assertEqual(b''.join(self.d), data)
+        self.d = []
+
+    def assert_started(self, val=True):
+        if val:
+            self.assertEqual(self.started, 1)
+        else:
+            self.assertEqual(self.started, 0)
+
+    def assert_finished(self, val=True):
+        if val:
+            self.assertEqual(self.finished, 1)
+        else:
+            self.assertEqual(self.finished, 0)
+
+    def test_simple(self):
+        # Assert is not started
+        self.assert_started(False)
+
+        # Write something, it should then be started + have data
+        self.p.write(b'foobar')
+        self.assert_started()
+        self.assert_data(b'foobar')
+
+        # Finalize, and check
+        self.assert_finished(False)
+        self.p.finalize()
+        self.assert_finished()
+
+    def test_multiple_chunks(self):
+        self.p.write(b'foo')
+        self.p.write(b'bar')
+        self.p.write(b'baz')
+        self.p.finalize()
+
+        self.assert_data(b'foobarbaz')
+        self.assert_finished()
+
+    def test_max_size(self):
+        self.p.max_size = 5
+
+        self.p.write(b'0123456789')
+        self.p.finalize()
+
+        self.assert_data(b'01234')
+        self.assert_finished()
+
+    def test_invalid_max_size(self):
+        with self.assertRaises(ValueError):
+            q = OctetStreamParser(max_size='foo')
+
+
+class TestBase64Decoder(unittest.TestCase):
+    # Note: base64('foobar') == 'Zm9vYmFy'
+    def setUp(self):
+        self.f = BytesIO()
+        self.d = Base64Decoder(self.f)
+
+    def assert_data(self, data, finalize=True):
+        if finalize:
+            self.d.finalize()
+
+        self.f.seek(0)
+        self.assertEqual(self.f.read(), data)
+        self.f.seek(0)
+        self.f.truncate()
+
+    def test_simple(self):
+        self.d.write(b'Zm9vYmFy')
+        self.assert_data(b'foobar')
+
+    def test_bad(self):
+        with self.assertRaises(DecodeError):
+            self.d.write(b'Zm9v!mFy')
+
+    def test_split_properly(self):
+        self.d.write(b'Zm9v')
+        self.d.write(b'YmFy')
+        self.assert_data(b'foobar')
+
+    def test_bad_split(self):
+        buff = b'Zm9v'
+        for i in range(1, 4):
+            first, second = buff[:i], buff[i:]
+
+            self.setUp()
+            self.d.write(first)
+            self.d.write(second)
+            self.assert_data(b'foo')
+
+    def test_long_bad_split(self):
+        buff = b'Zm9vYmFy'
+        for i in range(5, 8):
+            first, second = buff[:i], buff[i:]
+
+            self.setUp()
+            self.d.write(first)
+            self.d.write(second)
+            self.assert_data(b'foobar')
+
+    def test_close_and_finalize(self):
+        parser = Mock()
+        f = Base64Decoder(parser)
+
+        f.finalize()
+        parser.finalize.assert_called_once_with()
+
+        f.close()
+        parser.close.assert_called_once_with()
+
+    def test_bad_length(self):
+        self.d.write(b'Zm9vYmF')        # missing ending 'y'
+
+        with self.assertRaises(DecodeError):
+            self.d.finalize()
+
+
+class TestQuotedPrintableDecoder(unittest.TestCase):
+    def setUp(self):
+        self.f = BytesIO()
+        self.d = QuotedPrintableDecoder(self.f)
+
+    def assert_data(self, data, finalize=True):
+        if finalize:
+            self.d.finalize()
+
+        self.f.seek(0)
+        self.assertEqual(self.f.read(), data)
+        self.f.seek(0)
+        self.f.truncate()
+
+    def test_simple(self):
+        self.d.write(b'foobar')
+        self.assert_data(b'foobar')
+
+    def test_with_escape(self):
+        self.d.write(b'foo=3Dbar')
+        self.assert_data(b'foo=bar')
+
+    def test_with_newline_escape(self):
+        self.d.write(b'foo=\r\nbar')
+        self.assert_data(b'foobar')
+
+    def test_with_only_newline_escape(self):
+        self.d.write(b'foo=\nbar')
+        self.assert_data(b'foobar')
+
+    def test_with_split_escape(self):
+        self.d.write(b'foo=3')
+        self.d.write(b'Dbar')
+        self.assert_data(b'foo=bar')
+
+    def test_with_split_newline_escape_1(self):
+        self.d.write(b'foo=\r')
+        self.d.write(b'\nbar')
+        self.assert_data(b'foobar')
+
+    def test_with_split_newline_escape_2(self):
+        self.d.write(b'foo=')
+        self.d.write(b'\r\nbar')
+        self.assert_data(b'foobar')
+
+    def test_close_and_finalize(self):
+        parser = Mock()
+        f = QuotedPrintableDecoder(parser)
+
+        f.finalize()
+        parser.finalize.assert_called_once_with()
+
+        f.close()
+        parser.close.assert_called_once_with()
+
+    def test_not_aligned(self):
+        """
+        https://github.com/andrew-d/python-multipart/issues/6
+        """
+        self.d.write(b'=3AX')
+        self.assert_data(b':X')
+
+        # Additional offset tests
+        self.d.write(b'=3')
+        self.d.write(b'AX')
+        self.assert_data(b':X')
+
+        self.d.write(b'q=3AX')
+        self.assert_data(b'q:X')
+
+
+# Load our list of HTTP test cases.
+http_tests_dir = os.path.join(curr_dir, 'test_data', 'http')
+
+# Read in all test cases and load them.
+NON_PARAMETRIZED_TESTS = set(['single_field_blocks'])
+http_tests = []
+for f in os.listdir(http_tests_dir):
+    # Only load the HTTP test cases.
+    fname, ext = os.path.splitext(f)
+    if fname in NON_PARAMETRIZED_TESTS:
+        continue
+
+    if ext == '.http':
+        # Get the YAML file and load it too.
+        yaml_file = os.path.join(http_tests_dir, fname + '.yaml')
+
+        # Load both.
+        with open(os.path.join(http_tests_dir, f), 'rb') as f:
+            test_data = f.read()
+
+        with open(yaml_file, 'rb') as f:
+            yaml_data = yaml.load(f)
+
+        http_tests.append({
+            'name': fname,
+            'test': test_data,
+            'result': yaml_data
+        })
+
+
+def split_all(val):
+    """
+    This function will split an array all possible ways.  For example:
+        split_all([1,2,3,4])
+    will give:
+        ([1], [2,3,4]), ([1,2], [3,4]), ([1,2,3], [4])
+    """
+    for i in range(1, len(val) - 1):
+        yield (val[:i], val[i:])
+
+
+@parametrize_class
+class TestFormParser(unittest.TestCase):
+    def make(self, boundary, config={}):
+        self.ended = False
+        self.files = []
+        self.fields = []
+
+        def on_field(f):
+            self.fields.append(f)
+
+        def on_file(f):
+            self.files.append(f)
+
+        def on_end():
+            self.ended = True
+
+        # Get a form-parser instance.
+        self.f = FormParser('multipart/form-data', on_field, on_file, on_end,
+                            boundary=boundary, config=config)
+
+    def assert_file_data(self, f, data):
+        o = f.file_object
+        o.seek(0)
+        file_data = o.read()
+        self.assertEqual(file_data, data)
+
+    def assert_file(self, field_name, file_name, data):
+        # Find this file.
+        found = None
+        for f in self.files:
+            if f.field_name == field_name:
+                found = f
+                break
+
+        # Assert that we found it.
+        self.assertIsNotNone(found)
+
+        try:
+            # Assert about this file.
+            self.assert_file_data(found, data)
+            self.assertEqual(found.file_name, file_name)
+
+            # Remove it from our list.
+            self.files.remove(found)
+        finally:
+            # Close our file
+            found.close()
+
+    def assert_field(self, name, value):
+        # Find this field in our fields list.
+        found = None
+        for f in self.fields:
+            if f.field_name == name:
+                found = f
+                break
+
+        # Assert that it exists and matches.
+        self.assertIsNotNone(found)
+        self.assertEqual(value, found.value)
+
+        # Remove it for future iterations.
+        self.fields.remove(found)
+
+    @parametrize('param', http_tests)
+    def test_http(self, param):
+        # Firstly, create our parser with the given boundary.
+        boundary = param['result']['boundary']
+        if isinstance(boundary, text_type):
+            boundary = boundary.encode('latin-1')
+        self.make(boundary)
+
+        # Now, we feed the parser with data.
+        exc = None
+        try:
+            processed = self.f.write(param['test'])
+            self.f.finalize()
+        except MultipartParseError as e:
+            processed = 0
+            exc = e
+
+        # print(repr(param))
+        # print("")
+        # print(repr(self.fields))
+        # print(repr(self.files))
+
+        # Do we expect an error?
+        if 'error' in param['result']['expected']:
+            self.assertIsNotNone(exc)
+            self.assertEqual(param['result']['expected']['error'], exc.offset)
+            return
+
+        # No error!
+        self.assertEqual(processed, len(param['test']))
+
+        # Assert that the parser gave us the appropriate fields/files.
+        for e in param['result']['expected']:
+            # Get our type and name.
+            type = e['type']
+            name = e['name'].encode('latin-1')
+
+            if type == 'field':
+                self.assert_field(name, e['data'])
+
+            elif type == 'file':
+                self.assert_file(
+                    name,
+                    e['file_name'].encode('latin-1'),
+                    e['data']
+                )
+
+            else:
+                assert False
+
+    def test_random_splitting(self):
+        """
+        This test runs a simple multipart body with one field and one file
+        through every possible split.
+        """
+        # Load test data.
+        test_file = 'single_field_single_file.http'
+        with open(os.path.join(http_tests_dir, test_file), 'rb') as f:
+            test_data = f.read()
+
+        # We split the file through all cases.
+        for first, last in split_all(test_data):
+            # Create form parser.
+            self.make('boundary')
+
+            # Feed with data in 2 chunks.
+            i = 0
+            i += self.f.write(first)
+            i += self.f.write(last)
+            self.f.finalize()
+
+            # Assert we processed everything.
+            self.assertEqual(i, len(test_data))
+
+            # Assert that our file and field are here.
+            self.assert_field(b'field', b'test1')
+            self.assert_file(b'file', b'file.txt', b'test2')
+
+    def test_feed_single_bytes(self):
+        """
+        This test parses a simple multipart body 1 byte at a time.
+        """
+        # Load test data.
+        test_file = 'single_field_single_file.http'
+        with open(os.path.join(http_tests_dir, test_file), 'rb') as f:
+            test_data = f.read()
+
+        # Create form parser.
+        self.make('boundary')
+
+        # Write all bytes.
+        # NOTE: Can't simply do `for b in test_data`, since that gives
+        # an integer when iterating over a bytes object on Python 3.
+        i = 0
+        for x in range(len(test_data)):
+            b = test_data[x:x + 1]
+            i += self.f.write(b)
+
+        self.f.finalize()
+
+        # Assert we processed everything.
+        self.assertEqual(i, len(test_data))
+
+        # Assert that our file and field are here.
+        self.assert_field(b'field', b'test1')
+        self.assert_file(b'file', b'file.txt', b'test2')
+
+    def test_feed_blocks(self):
+        """
+        This test parses a simple multipart body 1 byte at a time.
+        """
+        # Load test data.
+        test_file = 'single_field_blocks.http'
+        with open(os.path.join(http_tests_dir, test_file), 'rb') as f:
+            test_data = f.read()
+
+        for c in range(1, len(test_data) + 1):
+            # Skip first `d` bytes - not interesting
+            for d in range(c):
+
+                # Create form parser.
+                self.make('boundary')
+                # Skip
+                i = 0
+                self.f.write(test_data[:d])
+                i += d
+                for x in range(d, len(test_data), c):
+                    # Write a chunk to achieve condition
+                    #     `i == data_length - 1`
+                    # in boundary search loop (multipatr.py:1302)
+                    b = test_data[x:x + c]
+                    i += self.f.write(b)
+
+                self.f.finalize()
+
+                # Assert we processed everything.
+                self.assertEqual(i, len(test_data))
+
+                # Assert that our field is here.
+                self.assert_field(b'field',
+                                  b'0123456789ABCDEFGHIJ0123456789ABCDEFGHIJ')
+
+    @slow_test
+    def test_request_body_fuzz(self):
+        """
+        This test randomly fuzzes the request body to ensure that no strange
+        exceptions are raised and we don't end up in a strange state.  The
+        fuzzing consists of randomly doing one of the following:
+            - Adding a random byte at a random offset
+            - Randomly deleting a single byte
+            - Randomly swapping two bytes
+        """
+        # Load test data.
+        test_file = 'single_field_single_file.http'
+        with open(os.path.join(http_tests_dir, test_file), 'rb') as f:
+            test_data = f.read()
+
+        iterations = 1000
+        successes = 0
+        failures = 0
+        exceptions = 0
+
+        print("Running %d iterations of fuzz testing:" % (iterations,))
+        for i in range(iterations):
+            # Create a bytearray to mutate.
+            fuzz_data = bytearray(test_data)
+
+            # Pick what we're supposed to do.
+            choice = random.choice([1, 2, 3])
+            if choice == 1:
+                # Add a random byte.
+                i = random.randrange(len(test_data))
+                b = random.randrange(256)
+
+                fuzz_data.insert(i, b)
+                msg = "Inserting byte %r at offset %d" % (b, i)
+
+            elif choice == 2:
+                # Remove a random byte.
+                i = random.randrange(len(test_data))
+                del fuzz_data[i]
+
+                msg = "Deleting byte at offset %d" % (i,)
+
+            elif choice == 3:
+                # Swap two bytes.
+                i = random.randrange(len(test_data) - 1)
+                fuzz_data[i], fuzz_data[i + 1] = fuzz_data[i + 1], fuzz_data[i]
+
+                msg = "Swapping bytes %d and %d" % (i, i + 1)
+
+            # Print message, so if this crashes, we can inspect the output.
+            print("  " + msg)
+
+            # Create form parser.
+            self.make('boundary')
+
+            # Feed with data, and ignore form parser exceptions.
+            i = 0
+            try:
+                i = self.f.write(bytes(fuzz_data))
+                self.f.finalize()
+            except FormParserError:
+                exceptions += 1
+            else:
+                if i == len(fuzz_data):
+                    successes += 1
+                else:
+                    failures += 1
+
+        print("--------------------------------------------------")
+        print("Successes:  %d" % (successes,))
+        print("Failures:   %d" % (failures,))
+        print("Exceptions: %d" % (exceptions,))
+
+    @slow_test
+    def test_request_body_fuzz_random_data(self):
+        """
+        This test will fuzz the multipart parser with some number of iterations
+        of randomly-generated data.
+        """
+        iterations = 1000
+        successes = 0
+        failures = 0
+        exceptions = 0
+
+        print("Running %d iterations of fuzz testing:" % (iterations,))
+        for i in range(iterations):
+            data_size = random.randrange(100, 4096)
+            data = os.urandom(data_size)
+            print("  Testing with %d random bytes..." % (data_size,))
+
+            # Create form parser.
+            self.make('boundary')
+
+            # Feed with data, and ignore form parser exceptions.
+            i = 0
+            try:
+                i = self.f.write(bytes(data))
+                self.f.finalize()
+            except FormParserError:
+                exceptions += 1
+            else:
+                if i == len(data):
+                    successes += 1
+                else:
+                    failures += 1
+
+        print("--------------------------------------------------")
+        print("Successes:  %d" % (successes,))
+        print("Failures:   %d" % (failures,))
+        print("Exceptions: %d" % (exceptions,))
+
+    def test_bad_start_boundary(self):
+        self.make('boundary')
+        data = b'--boundary\rfoobar'
+        with self.assertRaises(MultipartParseError):
+            self.f.write(data)
+
+        self.make('boundary')
+        data = b'--boundaryfoobar'
+        with self.assertRaises(MultipartParseError):
+            i = self.f.write(data)
+
+    def test_octet_stream(self):
+        files = []
+        def on_file(f):
+            files.append(f)
+        on_field = Mock()
+        on_end = Mock()
+
+        f = FormParser('application/octet-stream', on_field, on_file, on_end=on_end, file_name=b'foo.txt')
+        self.assertTrue(isinstance(f.parser, OctetStreamParser))
+
+        f.write(b'test')
+        f.write(b'1234')
+        f.finalize()
+
+        # Assert that we only recieved a single file, with the right data, and that we're done.
+        self.assertFalse(on_field.called)
+        self.assertEqual(len(files), 1)
+        self.assert_file_data(files[0], b'test1234')
+        self.assertTrue(on_end.called)
+
+    def test_querystring(self):
+        fields = []
+        def on_field(f):
+            fields.append(f)
+        on_file = Mock()
+        on_end = Mock()
+
+        def simple_test(f):
+            # Reset tracking.
+            del fields[:]
+            on_file.reset_mock()
+            on_end.reset_mock()
+
+            # Write test data.
+            f.write(b'foo=bar')
+            f.write(b'&test=asdf')
+            f.finalize()
+
+            # Assert we only recieved 2 fields...
+            self.assertFalse(on_file.called)
+            self.assertEqual(len(fields), 2)
+
+            # ...assert that we have the correct data...
+            self.assertEqual(fields[0].field_name, b'foo')
+            self.assertEqual(fields[0].value, b'bar')
+
+            self.assertEqual(fields[1].field_name, b'test')
+            self.assertEqual(fields[1].value, b'asdf')
+
+            # ... and assert that we've finished.
+            self.assertTrue(on_end.called)
+
+        f = FormParser('application/x-www-form-urlencoded', on_field, on_file, on_end=on_end)
+        self.assertTrue(isinstance(f.parser, QuerystringParser))
+        simple_test(f)
+
+        f = FormParser('application/x-url-encoded', on_field, on_file, on_end=on_end)
+        self.assertTrue(isinstance(f.parser, QuerystringParser))
+        simple_test(f)
+
+    def test_close_methods(self):
+        parser = Mock()
+        f = FormParser('application/x-url-encoded', None, None)
+        f.parser = parser
+
+        f.finalize()
+        parser.finalize.assert_called_once_with()
+
+        f.close()
+        parser.close.assert_called_once_with()
+
+    def test_bad_content_type(self):
+        # We should raise a ValueError for a bad Content-Type
+        with self.assertRaises(ValueError):
+            f = FormParser('application/bad', None, None)
+
+    def test_no_boundary_given(self):
+        # We should raise a FormParserError when parsing a multipart message
+        # without a boundary.
+        with self.assertRaises(FormParserError):
+            f = FormParser('multipart/form-data', None, None)
+
+    def test_bad_content_transfer_encoding(self):
+        data = b'----boundary\r\nContent-Disposition: form-data; name="file"; filename="test.txt"\r\nContent-Type: text/plain\r\nContent-Transfer-Encoding: badstuff\r\n\r\nTest\r\n----boundary--\r\n'
+
+        files = []
+        def on_file(f):
+            files.append(f)
+        on_field = Mock()
+        on_end = Mock()
+
+        # Test with erroring.
+        config = {'UPLOAD_ERROR_ON_BAD_CTE': True}
+        f = FormParser('multipart/form-data', on_field, on_file,
+                       on_end=on_end, boundary='--boundary', config=config)
+
+        with self.assertRaises(FormParserError):
+            f.write(data)
+            f.finalize()
+
+        # Test without erroring.
+        config = {'UPLOAD_ERROR_ON_BAD_CTE': False}
+        f = FormParser('multipart/form-data', on_field, on_file,
+                       on_end=on_end, boundary='--boundary', config=config)
+
+        f.write(data)
+        f.finalize()
+        self.assert_file_data(files[0], b'Test')
+
+    def test_handles_None_fields(self):
+        fields = []
+        def on_field(f):
+            fields.append(f)
+        on_file = Mock()
+        on_end = Mock()
+
+        f = FormParser('application/x-www-form-urlencoded', on_field, on_file, on_end=on_end)
+        f.write(b'foo=bar&another&baz=asdf')
+        f.finalize()
+
+        self.assertEqual(fields[0].field_name, b'foo')
+        self.assertEqual(fields[0].value, b'bar')
+
+        self.assertEqual(fields[1].field_name, b'another')
+        self.assertEqual(fields[1].value, None)
+
+        self.assertEqual(fields[2].field_name, b'baz')
+        self.assertEqual(fields[2].value, b'asdf')
+
+    def test_max_size_multipart(self):
+        # Load test data.
+        test_file = 'single_field_single_file.http'
+        with open(os.path.join(http_tests_dir, test_file), 'rb') as f:
+            test_data = f.read()
+
+        # Create form parser.
+        self.make('boundary')
+
+        # Set the maximum length that we can process to be halfway through the
+        # given data.
+        self.f.parser.max_size = len(test_data) / 2
+
+        i = self.f.write(test_data)
+        self.f.finalize()
+
+        # Assert we processed the correct amount.
+        self.assertEqual(i, len(test_data) / 2)
+
+    def test_max_size_form_parser(self):
+        # Load test data.
+        test_file = 'single_field_single_file.http'
+        with open(os.path.join(http_tests_dir, test_file), 'rb') as f:
+            test_data = f.read()
+
+        # Create form parser setting the maximum length that we can process to
+        # be halfway through the given data.
+        size = len(test_data) / 2
+        self.make('boundary', config={'MAX_BODY_SIZE': size})
+
+        i = self.f.write(test_data)
+        self.f.finalize()
+
+        # Assert we processed the correct amount.
+        self.assertEqual(i, len(test_data) / 2)
+
+    def test_octet_stream_max_size(self):
+        files = []
+        def on_file(f):
+            files.append(f)
+        on_field = Mock()
+        on_end = Mock()
+
+        f = FormParser('application/octet-stream', on_field, on_file,
+                       on_end=on_end, file_name=b'foo.txt',
+                       config={'MAX_BODY_SIZE': 10})
+
+        f.write(b'0123456789012345689')
+        f.finalize()
+
+        self.assert_file_data(files[0], b'0123456789')
+
+    def test_invalid_max_size_multipart(self):
+        with self.assertRaises(ValueError):
+            q = MultipartParser(b'bound', max_size='foo')
+
+
+class TestHelperFunctions(unittest.TestCase):
+    def test_create_form_parser(self):
+        r = create_form_parser({'Content-Type': 'application/octet-stream'},
+                               None, None)
+        self.assertTrue(isinstance(r, FormParser))
+
+    def test_create_form_parser_error(self):
+        headers = {}
+        with self.assertRaises(ValueError):
+            create_form_parser(headers, None, None)
+
+    def test_parse_form(self):
+        on_field = Mock()
+        on_file = Mock()
+
+        parse_form(
+            {'Content-Type': 'application/octet-stream',
+             },
+            BytesIO(b'123456789012345'),
+            on_field,
+            on_file
+        )
+
+        on_file.assert_called_once()
+
+        # Assert that the first argument of the call (a File object) has size
+        # 15 - i.e. all data is written.
+        self.assertEqual(on_file.call_args[0][0].size, 15)
+
+    def test_parse_form_content_length(self):
+        files = []
+        def on_file(file):
+            files.append(file)
+
+        parse_form(
+            {'Content-Type': 'application/octet-stream',
+             'Content-Length': '10'
+             },
+            BytesIO(b'123456789012345'),
+            None,
+            on_file
+        )
+
+        self.assertEqual(len(files), 1)
+        self.assertEqual(files[0].size, 10)
+
+
+
+def suite():
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(TestFile))
+    suite.addTest(unittest.makeSuite(TestParseOptionsHeader))
+    suite.addTest(unittest.makeSuite(TestBaseParser))
+    suite.addTest(unittest.makeSuite(TestQuerystringParser))
+    suite.addTest(unittest.makeSuite(TestOctetStreamParser))
+    suite.addTest(unittest.makeSuite(TestBase64Decoder))
+    suite.addTest(unittest.makeSuite(TestQuotedPrintableDecoder))
+    suite.addTest(unittest.makeSuite(TestFormParser))
+    suite.addTest(unittest.makeSuite(TestHelperFunctions))
+
+    return suite
+
diff --git a/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/LICENSE
new file mode 100644
index 0000000..bdb7786
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/LICENSE
@@ -0,0 +1,27 @@
+Mypy extensions are licensed under the terms of the MIT license, reproduced below.
+
+= = = = =
+
+The MIT License
+
+Copyright (c) 2016-2017 Jukka Lehtosalo and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+= = = = =
diff --git a/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/METADATA b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/METADATA
new file mode 100644
index 0000000..8892543
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/METADATA
@@ -0,0 +1,31 @@
+Metadata-Version: 2.1
+Name: mypy-extensions
+Version: 0.4.3
+Summary: Experimental type system extensions for programs checked with the mypy typechecker.
+Home-page: https://github.com/python/mypy_extensions
+Author: The mypy developers
+Author-email: jukka.lehtosalo@iki.fi
+License: MIT License
+Platform: UNKNOWN
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Software Development
+Requires-Dist: typing (>=3.5.3) ; python_version < "3.5"
+
+Mypy Extensions
+===============
+
+The "mypy_extensions" module defines experimental extensions to the
+standard "typing" module that are supported by the mypy typechecker.
+
+
diff --git a/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/RECORD b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/RECORD
new file mode 100644
index 0000000..a9a14f1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/RECORD
@@ -0,0 +1,7 @@
+mypy_extensions.py,sha256=zuwlHRPtDPLvzoQv9-FSryoLKAkKaDIpu14-js2gHOE,5078
+mypy_extensions-0.4.3.dist-info/LICENSE,sha256=pQRQ2h1TzXd7gM7XfFj_lqvgzNh5cGvRQsPsIOJF8LQ,1204
+mypy_extensions-0.4.3.dist-info/METADATA,sha256=6AEHeULt1o9wXmnlSNSu3QeQcx4Ywq8OKhB689SG0p4,1155
+mypy_extensions-0.4.3.dist-info/WHEEL,sha256=8zNYZbwQSXoB9IfXOjPfeNwvAsALAjffgk27FqvCWbo,110
+mypy_extensions-0.4.3.dist-info/top_level.txt,sha256=TllnGWqDoFMhKyTiX9peoF1VC1wmkRgILHdebnubEb8,16
+mypy_extensions-0.4.3.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+mypy_extensions-0.4.3.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/WHEEL
new file mode 100644
index 0000000..8b701e9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.33.6)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/top_level.txt
new file mode 100644
index 0000000..ee21665
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mypy_extensions-0.4.3.dist-info/top_level.txt
@@ -0,0 +1 @@
+mypy_extensions
diff --git a/myenv/lib/python3.9/site-packages/mypy_extensions.py b/myenv/lib/python3.9/site-packages/mypy_extensions.py
new file mode 100644
index 0000000..5f9d88e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/mypy_extensions.py
@@ -0,0 +1,166 @@
+"""Defines experimental extensions to the standard "typing" module that are
+supported by the mypy typechecker.
+
+Example usage:
+    from mypy_extensions import TypedDict
+"""
+
+from typing import Any
+
+# NOTE: This module must support Python 2.7 in addition to Python 3.x
+
+import sys
+# _type_check is NOT a part of public typing API, it is used here only to mimic
+# the (convenient) behavior of types provided by typing module.
+from typing import _type_check  # type: ignore
+
+
+def _check_fails(cls, other):
+    try:
+        if sys._getframe(1).f_globals['__name__'] not in ['abc', 'functools', 'typing']:
+            # Typed dicts are only for static structural subtyping.
+            raise TypeError('TypedDict does not support instance and class checks')
+    except (AttributeError, ValueError):
+        pass
+    return False
+
+
+def _dict_new(cls, *args, **kwargs):
+    return dict(*args, **kwargs)
+
+
+def _typeddict_new(cls, _typename, _fields=None, **kwargs):
+    total = kwargs.pop('total', True)
+    if _fields is None:
+        _fields = kwargs
+    elif kwargs:
+        raise TypeError("TypedDict takes either a dict or keyword arguments,"
+                        " but not both")
+
+    ns = {'__annotations__': dict(_fields), '__total__': total}
+    try:
+        # Setting correct module is necessary to make typed dict classes pickleable.
+        ns['__module__'] = sys._getframe(1).f_globals.get('__name__', '__main__')
+    except (AttributeError, ValueError):
+        pass
+
+    return _TypedDictMeta(_typename, (), ns)
+
+
+class _TypedDictMeta(type):
+    def __new__(cls, name, bases, ns, total=True):
+        # Create new typed dict class object.
+        # This method is called directly when TypedDict is subclassed,
+        # or via _typeddict_new when TypedDict is instantiated. This way
+        # TypedDict supports all three syntaxes described in its docstring.
+        # Subclasses and instances of TypedDict return actual dictionaries
+        # via _dict_new.
+        ns['__new__'] = _typeddict_new if name == 'TypedDict' else _dict_new
+        tp_dict = super(_TypedDictMeta, cls).__new__(cls, name, (dict,), ns)
+
+        anns = ns.get('__annotations__', {})
+        msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type"
+        anns = {n: _type_check(tp, msg) for n, tp in anns.items()}
+        for base in bases:
+            anns.update(base.__dict__.get('__annotations__', {}))
+        tp_dict.__annotations__ = anns
+        if not hasattr(tp_dict, '__total__'):
+            tp_dict.__total__ = total
+        return tp_dict
+
+    __instancecheck__ = __subclasscheck__ = _check_fails
+
+
+TypedDict = _TypedDictMeta('TypedDict', (dict,), {})
+TypedDict.__module__ = __name__
+TypedDict.__doc__ = \
+    """A simple typed name space. At runtime it is equivalent to a plain dict.
+
+    TypedDict creates a dictionary type that expects all of its
+    instances to have a certain set of keys, with each key
+    associated with a value of a consistent type. This expectation
+    is not checked at runtime but is only enforced by typecheckers.
+    Usage::
+
+        Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
+        a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
+        b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check
+        assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')
+
+    The type info could be accessed via Point2D.__annotations__. TypedDict
+    supports two additional equivalent forms::
+
+        Point2D = TypedDict('Point2D', x=int, y=int, label=str)
+
+        class Point2D(TypedDict):
+            x: int
+            y: int
+            label: str
+
+    The latter syntax is only supported in Python 3.6+, while two other
+    syntax forms work for Python 2.7 and 3.2+
+    """
+
+# Argument constructors for making more-detailed Callables. These all just
+# return their type argument, to make them complete noops in terms of the
+# `typing` module.
+
+
+def Arg(type=Any, name=None):
+    """A normal positional argument"""
+    return type
+
+
+def DefaultArg(type=Any, name=None):
+    """A positional argument with a default value"""
+    return type
+
+
+def NamedArg(type=Any, name=None):
+    """A keyword-only argument"""
+    return type
+
+
+def DefaultNamedArg(type=Any, name=None):
+    """A keyword-only argument with a default value"""
+    return type
+
+
+def VarArg(type=Any):
+    """A *args-style variadic positional argument"""
+    return type
+
+
+def KwArg(type=Any):
+    """A **kwargs-style variadic keyword argument"""
+    return type
+
+
+# Return type that indicates a function does not return
+class NoReturn: pass
+
+
+def trait(cls):
+    return cls
+
+
+def mypyc_attr(*attrs, **kwattrs):
+    return lambda x: x
+
+
+# TODO: We may want to try to properly apply this to any type
+# variables left over...
+class _FlexibleAliasClsApplied:
+    def __init__(self, val):
+        self.val = val
+
+    def __getitem__(self, args):
+        return self.val
+
+
+class _FlexibleAliasCls:
+    def __getitem__(self, args):
+        return _FlexibleAliasClsApplied(args[-1])
+
+
+FlexibleAlias = _FlexibleAliasCls()
diff --git a/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/LICENSE.txt b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/LICENSE.txt
new file mode 100644
index 0000000..a274a66
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/LICENSE.txt
@@ -0,0 +1,37 @@
+NetworkX is distributed with the 3-clause BSD license.
+
+::
+
+   Copyright (C) 2004-2022, NetworkX Developers
+   Aric Hagberg <hagberg@lanl.gov>
+   Dan Schult <dschult@colgate.edu>
+   Pieter Swart <swart@lanl.gov>
+   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 NetworkX Developers nor the names of its
+       contributors may be used to endorse or promote products derived
+       from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/METADATA b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/METADATA
new file mode 100644
index 0000000..dc385d7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/METADATA
@@ -0,0 +1,131 @@
+Metadata-Version: 2.1
+Name: networkx
+Version: 2.8.5
+Summary: Python package for creating and manipulating graphs and networks
+Home-page: https://networkx.org/
+Author: Aric Hagberg
+Author-email: hagberg@lanl.gov
+Maintainer: NetworkX Developers
+Maintainer-email: networkx-discuss@googlegroups.com
+Project-URL: Bug Tracker, https://github.com/networkx/networkx/issues
+Project-URL: Documentation, https://networkx.org/documentation/stable/
+Project-URL: Source Code, https://github.com/networkx/networkx
+Keywords: Networks,Graph Theory,Mathematics,network,graph,discrete mathematics,math
+Platform: Linux
+Platform: Mac OSX
+Platform: Windows
+Platform: Unix
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+License-File: LICENSE.txt
+Provides-Extra: default
+Requires-Dist: numpy (>=1.19) ; extra == 'default'
+Requires-Dist: scipy (>=1.8) ; extra == 'default'
+Requires-Dist: matplotlib (>=3.4) ; extra == 'default'
+Requires-Dist: pandas (>=1.3) ; extra == 'default'
+Provides-Extra: developer
+Requires-Dist: pre-commit (>=2.19) ; extra == 'developer'
+Requires-Dist: mypy (>=0.960) ; extra == 'developer'
+Provides-Extra: doc
+Requires-Dist: sphinx (>=5) ; extra == 'doc'
+Requires-Dist: pydata-sphinx-theme (>=0.9) ; extra == 'doc'
+Requires-Dist: sphinx-gallery (>=0.10) ; extra == 'doc'
+Requires-Dist: numpydoc (>=1.4) ; extra == 'doc'
+Requires-Dist: pillow (>=9.1) ; extra == 'doc'
+Requires-Dist: nb2plots (>=0.6) ; extra == 'doc'
+Requires-Dist: texext (>=0.6.6) ; extra == 'doc'
+Provides-Extra: extra
+Requires-Dist: lxml (>=4.6) ; extra == 'extra'
+Requires-Dist: pygraphviz (>=1.9) ; extra == 'extra'
+Requires-Dist: pydot (>=1.4.2) ; extra == 'extra'
+Requires-Dist: sympy (>=1.10) ; extra == 'extra'
+Provides-Extra: test
+Requires-Dist: pytest (>=7.1) ; extra == 'test'
+Requires-Dist: pytest-cov (>=3.0) ; extra == 'test'
+Requires-Dist: codecov (>=2.1) ; extra == 'test'
+
+NetworkX
+========
+
+.. image:: https://github.com/networkx/networkx/workflows/test/badge.svg?tag=networkx-2.8.5
+  :target: https://github.com/networkx/networkx/actions?query=branch%3Anetworkx-2.8.5
+
+.. image:: https://codecov.io/gh/networkx/networkx/branch/main/graph/badge.svg
+   :target: https://app.codecov.io/gh/networkx/networkx/branch/main
+   
+.. image:: https://img.shields.io/github/labels/networkx/networkx/Good%20First%20Issue?color=green&label=Contribute%20&style=flat-square
+   :target: https://github.com/networkx/networkx/issues?q=is%3Aopen+is%3Aissue+label%3A%22Good+First+Issue%22
+   
+
+NetworkX is a Python package for the creation, manipulation,
+and study of the structure, dynamics, and functions
+of complex networks.
+
+- **Website (including documentation):** https://networkx.org
+- **Mailing list:** https://groups.google.com/forum/#!forum/networkx-discuss
+- **Source:** https://github.com/networkx/networkx
+- **Bug reports:** https://github.com/networkx/networkx/issues
+- **Tutorial:** https://networkx.org/documentation/latest/tutorial.html
+- **GitHub Discussions:** https://github.com/networkx/networkx/discussions
+
+Simple example
+--------------
+
+Find the shortest path between two nodes in an undirected graph:
+
+.. code:: pycon
+
+    >>> import networkx as nx
+    >>> G = nx.Graph()
+    >>> G.add_edge("A", "B", weight=4)
+    >>> G.add_edge("B", "D", weight=2)
+    >>> G.add_edge("A", "C", weight=3)
+    >>> G.add_edge("C", "D", weight=4)
+    >>> nx.shortest_path(G, "A", "D", weight="weight")
+    ['A', 'B', 'D']
+
+Install
+-------
+
+Install the latest version of NetworkX::
+
+    $ pip install networkx
+
+Install with all optional dependencies::
+
+    $ pip install networkx[all]
+
+For additional details, please see `INSTALL.rst`.
+
+Bugs
+----
+
+Please report any bugs that you find `here <https://github.com/networkx/networkx/issues>`_.
+Or, even better, fork the repository on `GitHub <https://github.com/networkx/networkx>`_
+and create a pull request (PR). We welcome all changes, big or small, and we
+will help you make the PR if you are new to `git` (just ask on the issue and/or
+see `CONTRIBUTING.rst`).
+
+License
+-------
+
+Released under the 3-Clause BSD license (see `LICENSE.txt`)::
+
+   Copyright (C) 2004-2022 NetworkX Developers
+   Aric Hagberg <hagberg@lanl.gov>
+   Dan Schult <dschult@colgate.edu>
+   Pieter Swart <swart@lanl.gov>
diff --git a/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/RECORD b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/RECORD
new file mode 100644
index 0000000..81f3cf2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/RECORD
@@ -0,0 +1,644 @@
+networkx/__init__.py,sha256=MovMyewNUEF1O6pE02yVCvVjVdZntb0rksfnBC1tgiY,2939
+networkx/conftest.py,sha256=JXFOt642CF00x-Ov8PFmw_XzTtlrpt1CNvJWzSKrG1k,12271
+networkx/convert.py,sha256=ZBOGJBt4e8hKBH-Rr7xdertkWHyv57HAU-jBdN1VBIE,15858
+networkx/convert_matrix.py,sha256=r80YqseF6JglHFwZqDixXxueom7_PChnu_esHGLw05o,56245
+networkx/exception.py,sha256=5v8tPTpYcuu3OFgSitgC8-wMUGNwfgxZog2gsBNeRPk,3537
+networkx/lazy_imports.py,sha256=3PZ69R_MO23e3U8-6M37bpfXQ6lx5ywV61sETo4k9Cg,5777
+networkx/relabel.py,sha256=WQZv_Gil6Bh5oX8imiw4foZQdw6yMQhtYWFNNRHEPJg,10010
+networkx/algorithms/__init__.py,sha256=eJ_V2reAkgQo0cvUYnADoZt5iTe0fhe9he2zrA6pGEs,6364
+networkx/algorithms/asteroidal.py,sha256=rdFr50v0T9t5VtNN1z74NQ0COgtstlBR4W1BTPoatC8,5810
+networkx/algorithms/boundary.py,sha256=UXpJDuXRvEv6GDY1BFULHyPJJK0rXx-K5XN491KYpgg,4695
+networkx/algorithms/bridges.py,sha256=a8WCc02kWwhu3F1POie0Jzhlo0yH80MlOIl9DjJq0Ws,5886
+networkx/algorithms/chains.py,sha256=NFjIqQYheEmX0Hwyk9bBt3aCQ2WSWe2eMODGXKZ0cGo,6769
+networkx/algorithms/chordal.py,sha256=D71-vEWs8-I096n_vpUuONVIHcLxNQhRkMQS8zhKcgI,14376
+networkx/algorithms/clique.py,sha256=pEBXbMVV2db69hHYXeux9IJwhzIgiyqwBu06jAmvuJs,26631
+networkx/algorithms/cluster.py,sha256=6voNVbLepilh6HQggtn0JB3iiyA0xoVEHNmdOoG_Uq4,18789
+networkx/algorithms/communicability_alg.py,sha256=ClwaQ5CH0loQJCXtutMCDwqNStNqo0B4eOQECoXs7UM,4551
+networkx/algorithms/core.py,sha256=QsAvXtz0YtF9d10mh_4hKzJ6Hb0uWf3Aq1Sa8Xh37XY,15869
+networkx/algorithms/covering.py,sha256=my5V4PHT3zHLK0QvanEqQn65jJ5_nNVy6ul_0wHRT18,5262
+networkx/algorithms/cuts.py,sha256=HCrDvHqAAMcXqPXaW4qh5TKFM4wVbGnCVIOv4EDL6rs,9722
+networkx/algorithms/cycles.py,sha256=HKG2fERA6_6ZrMQvBvoNcOkYyKn6WE6JB-RhFKOFlmw,21677
+networkx/algorithms/d_separation.py,sha256=RhTA7HwR_NUOVvi6BOBuH5n9L6Fv7Z52DMcPmSn0GSc,4165
+networkx/algorithms/dag.py,sha256=nPMzzIKxPnaI8vo86Q3NmiSRIcMkyz8VDC-Ecu14hVE,34557
+networkx/algorithms/distance_measures.py,sha256=MXpBzHD_xoioe19B13h9ftzV40_Yf-jD7B-0phpQBEI,22803
+networkx/algorithms/distance_regular.py,sha256=DARGJQPSdf_xxoInuEBBKN4kun0Izu-LGX8c1-hiuvk,6872
+networkx/algorithms/dominance.py,sha256=lK7FRWAr6TiENtmuTniW1q7KesopvW6kJLKqNR5-SeI,3394
+networkx/algorithms/dominating.py,sha256=lvyePsQ08fGU9OdZZ5oi_d7P_lg7HR5xn8CNdpWxNP8,2647
+networkx/algorithms/efficiency_measures.py,sha256=y21IgKH5o-IZhdka0_4J0naw1XIXkxa3ymEBey75KEw,4277
+networkx/algorithms/euler.py,sha256=HMAahIPnIXzFW6tMKnWgW0jnYQ5hzR2CWByfK612pzg,13600
+networkx/algorithms/graph_hashing.py,sha256=rQN5evPVZBCnuJHjJ7Fvf0znSuS6PZHX0wTsrnvp4gI,11392
+networkx/algorithms/graphical.py,sha256=r4a7Sk8GSDYvZlKs0I8pOvpCWAZspCAFvNM9O2WtrOk,13449
+networkx/algorithms/hierarchy.py,sha256=afmel-XstPOVjn5B3Pc4G2ejclgStf4Bk8zdWOSgWHw,1502
+networkx/algorithms/hybrid.py,sha256=U6hyTathxCYfenAnDBiqQm46r1zPDbTUdRI--yzg6TA,6152
+networkx/algorithms/isolate.py,sha256=oZU25X5zEKCnwnVMS7BFXnTckS7jwXkyTuI5T6TooME,2261
+networkx/algorithms/link_prediction.py,sha256=QOei1_-_sL8FqTLyB-fEcwgUnbhQ_RdwiqpYzJBUZM8,19792
+networkx/algorithms/lowest_common_ancestors.py,sha256=Cez4vbJK2vws3LwTPiFADtkwG_eGIXSU9qTWQbe-IK0,14013
+networkx/algorithms/matching.py,sha256=fope8XNIJMJtmO7SdxNfTsmE0rdQeq0ovWjpNpx2DCk,42801
+networkx/algorithms/mis.py,sha256=oUWPZAew3zVsW9DKcblo7mOt2dUUfdrsucSlz56jdok,2325
+networkx/algorithms/moral.py,sha256=tVX5HD9h8qmygjMSufsVrcYiUkpLMUdhDE_mWLw5WYo,1475
+networkx/algorithms/non_randomness.py,sha256=-hL-zHvyjj0Bpr8E2xj0rwbr7CPYUbXdicggpenIGrg,2858
+networkx/algorithms/planar_drawing.py,sha256=vSlP1AToiIzaZPYmNJfTOLouJHndjZWzK2O7bbpNOo0,16320
+networkx/algorithms/planarity.py,sha256=nOX-8mUnFRJrZc9DtsRsMIMZ_anJoftjZU91sXxqlgs,39410
+networkx/algorithms/polynomials.py,sha256=tlbLcpQaYp1XVA7uQPasBHe15AuScZpVXPgzTX75xKI,10826
+networkx/algorithms/reciprocity.py,sha256=1iv5v1GkWu6cAorGxpiBmS5jzh_BkVi8XZaXtuLr7ms,2796
+networkx/algorithms/regular.py,sha256=oI3fx0ZoHceX_WYe1J-7IxhLtLVahkNZIhqv1HVXNJ8,6205
+networkx/algorithms/richclub.py,sha256=6twv21qc43m2N5j9zPwLOWZh7BeDwCN8XTdtx_Ph5KY,4152
+networkx/algorithms/similarity.py,sha256=UpxBU63wyQeMqcWIxTUP6jh3F4DAty9aizoEBZ8pAkE,59768
+networkx/algorithms/simple_paths.py,sha256=5rOnA5bQ_nJCoBiX9eiJQC1OHY5moe9thp9YaM0Hp8w,29763
+networkx/algorithms/smallworld.py,sha256=re54UBdlwcXH2pHqmp3AoBf-lHGeSNe5AM1t7rliObw,13085
+networkx/algorithms/smetric.py,sha256=SXz5CHN9f2fQ_k4DJAW_iGgMgUs3pKHsvLx2Yk5wGfY,1177
+networkx/algorithms/sparsifiers.py,sha256=QETW6i73_YyvmM_bCm-53A3ln_YV926Cq2DzKY526X8,10038
+networkx/algorithms/structuralholes.py,sha256=FGO23J0-m8Dgkt8RgRWLy_v1wvO8wQ0mv96R2pxf1xI,9146
+networkx/algorithms/summarization.py,sha256=HzWpV8v0nc_z9njfvjGTUTZCk177IOqE6BltbN-Z79A,22926
+networkx/algorithms/swap.py,sha256=259xQ_uOB9e9KKqlJ4wprlARSfaThJM2ax1nbPEJ2os,9819
+networkx/algorithms/threshold.py,sha256=VCME2hzhkwnXGNqfaYSrCG0x8l63i_FH-N7zNl5CeNs,31010
+networkx/algorithms/tournament.py,sha256=hDrl96Nf5huz66YJsDuV9ruRrRFFTGKJDctQq9fj4ls,11584
+networkx/algorithms/triads.py,sha256=U5t8GatjmTraeuxltj8ocvqCY-iiostYzKgIBRmdyzc,13476
+networkx/algorithms/vitality.py,sha256=f1fAmEm1n7JE6TMBix9iFPmK9EOtgGg0YuRj8BYZnGM,2296
+networkx/algorithms/voronoi.py,sha256=BFykl7dsAXeQGDrK-Z6-sGbsyaQUYMXkkzZTcN_Pa78,3158
+networkx/algorithms/wiener.py,sha256=b_W7Beo_MKyetq6o8w2jLu0v8okmfX3n9F4Bc_NTi-M,2270
+networkx/algorithms/approximation/__init__.py,sha256=hwi6EOHU1OJEDOxYr8USLexbUOubH76aiU9P4WRDZrw,1197
+networkx/algorithms/approximation/clique.py,sha256=t-G-wOQ3SFcCOWSrmH8pKmPhtnp2UouXM4HctPshVNc,7181
+networkx/algorithms/approximation/clustering_coefficient.py,sha256=mfgwpJN1Jk9da7KLBOMNqXiU187r3WoUQLxiTwlI9gw,2009
+networkx/algorithms/approximation/connectivity.py,sha256=lfjwwTlS_JC--GJBC4Lu65XO50Jz3vpKwhAqTE2lwEs,12716
+networkx/algorithms/approximation/distance_measures.py,sha256=6q6J3VRqxAkqqh_d519mItyjfhdgTqS8xePHo4D3ZWI,5550
+networkx/algorithms/approximation/dominating_set.py,sha256=1WAJnJ8AFyFSNO7TLAsJ0fFIVcIPoYhupRDhcJsDpb0,4143
+networkx/algorithms/approximation/kcomponents.py,sha256=fsRl3wBAe5LTQGftJ71OFIMN4k1XGH9JZlsOUJC03QE,13223
+networkx/algorithms/approximation/matching.py,sha256=iN-ofr7Gs1XkCHSAxc5HkwSrHkMyUY7i7bTPQkIuR-o,1155
+networkx/algorithms/approximation/maxcut.py,sha256=DD1mktczrwD79NR3A0bAegXWSld_47rpQfJtZr09Mdk,3594
+networkx/algorithms/approximation/ramsey.py,sha256=mD3edR4mp8qyjV1oFp6vV3yX0w7LbOuOsj94LmRNDYA,1339
+networkx/algorithms/approximation/steinertree.py,sha256=X0IpQh3972Wl1qubybz3sNQb4BW6LJ1uidb9ZUEQNXU,3376
+networkx/algorithms/approximation/traveling_salesman.py,sha256=eg2zjSJimcv_pnJrdcObmEFJWN48vC-lMto1v74-VKs,54262
+networkx/algorithms/approximation/treewidth.py,sha256=YekIUcogCMMvy2zR9aQsA866A5nSFr0ySTEzP7gDCc0,8019
+networkx/algorithms/approximation/vertex_cover.py,sha256=GroE2Vc_Ieq4kUpj-pDQqlCTR-0PGqcZ9T33qV77xZ0,2741
+networkx/algorithms/approximation/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/approximation/tests/test_approx_clust_coeff.py,sha256=PGOVEKf2BcJu1vvjZrgTlBBpwM8V6t7yCANjyS9nWF0,1171
+networkx/algorithms/approximation/tests/test_clique.py,sha256=JZ_ja03aVU7vnZ42Joy1ze0vjdcm_CnDhD96Z4W_Dcc,3022
+networkx/algorithms/approximation/tests/test_connectivity.py,sha256=gDG6tsgP3ux7Dgu0x7r0nso7_yknIxicV42Gq0It5pc,5952
+networkx/algorithms/approximation/tests/test_distance_measures.py,sha256=GSyupA_jqSc_pLPSMnZFNcBgZc8-KFWgt6Q7uFegTqg,2024
+networkx/algorithms/approximation/tests/test_dominating_set.py,sha256=Rtdsu-0KjZMS2Qj4fd3nJgHDHxASDrwS907_TyaHUVw,2296
+networkx/algorithms/approximation/tests/test_kcomponents.py,sha256=MCQ1tNiFQrl0-MutM1N_Q6QHYEWCvDQ6cRM_Y7V3dDw,9213
+networkx/algorithms/approximation/tests/test_matching.py,sha256=nitZncaM0605kaIu1NO6_5TFV2--nohUCO46XTD_lnM,186
+networkx/algorithms/approximation/tests/test_maxcut.py,sha256=R0tx_0mP0vWKX564j4qoiljnG3Mn0XhGAhFRYOZEcHM,2430
+networkx/algorithms/approximation/tests/test_ramsey.py,sha256=2oJFufDcKZNFvRVmt66nLvuHC95c4b8ey-nrANKOluw,1142
+networkx/algorithms/approximation/tests/test_steinertree.py,sha256=g4Wvx6u8HNa8Q5XY-R_KCbY8vcKXMuOz8lC6zAJ7Vv0,3145
+networkx/algorithms/approximation/tests/test_traveling_salesman.py,sha256=LSAquDfYaz_MxM1Tb4uYM_XNCh8_tJINcUSxFOFrJ_U,30699
+networkx/algorithms/approximation/tests/test_treewidth.py,sha256=1AwP3bgaEG4JrrlG0cbjMcxirlKH4vk-weaP2isdDXM,8949
+networkx/algorithms/approximation/tests/test_vertex_cover.py,sha256=FobHNhG9CAMeB_AOEprUs-7XQdPoc1YvfmXhozDZ8pM,1942
+networkx/algorithms/assortativity/__init__.py,sha256=ov3HRRbeYB_6Qezvxp1OTl77GBpw-EWkWGUzgfT8G9c,294
+networkx/algorithms/assortativity/connectivity.py,sha256=eR-PMTFyY8fktn_nUZ2LLblEsoktAMFyGmdN_eXQfVc,4815
+networkx/algorithms/assortativity/correlation.py,sha256=KOOfrFosgyeTOz3zKeqh31o1f1WgssbESCmIWP1v3qc,8529
+networkx/algorithms/assortativity/mixing.py,sha256=VhbJxGlBRa_KrGmxfq9da5mibxnbg5Fl1PODfaWIwPo,9094
+networkx/algorithms/assortativity/neighbor_degree.py,sha256=qe33xcO9SNMNTbb3c9e0q-whYDcVl_O5fi2Pzke2p5s,5243
+networkx/algorithms/assortativity/pairs.py,sha256=hleMyWgHoy8hXV8ZOIqGJ_ChZQ2oVlukYfPvkaT9SQg,3297
+networkx/algorithms/assortativity/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/assortativity/tests/base_test.py,sha256=DjNszEwQzYDPXvEIHTyVAExE6WoUEWtR2kgz_ATfgWo,2724
+networkx/algorithms/assortativity/tests/test_connectivity.py,sha256=HQGuZTnGab1yWaKLilXwwIg-GgSR7alMcH-0CcLXszE,5092
+networkx/algorithms/assortativity/tests/test_correlation.py,sha256=qS0Nv7rqKEYDrsrGkOfpm49jXi-D7YKs39dwkcdLxCM,4527
+networkx/algorithms/assortativity/tests/test_mixing.py,sha256=8zS_xTryZ7_MPmsbRgcaeiPfpnwzhqH8TbYS4f_pEbI,6903
+networkx/algorithms/assortativity/tests/test_neighbor_degree.py,sha256=AFlcIF0CoTD2F_j5i1AHeOFJzvyEn7Z4ww2axdT0D3E,3706
+networkx/algorithms/assortativity/tests/test_pairs.py,sha256=t05qP_-gfkbiR6aTLtE1owYl9otBSsuJcRkuZsa63UQ,3008
+networkx/algorithms/bipartite/__init__.py,sha256=P6prxqUpq0T1xikH3DLNggcGxEEf6gu6z8tcwd3Pbq0,3768
+networkx/algorithms/bipartite/basic.py,sha256=VY0cmgU2KHSklcvJ8xvZAZLzOk7jan3HZ2dg0TMuf4Y,8220
+networkx/algorithms/bipartite/centrality.py,sha256=cabaDLe_RxmYKd3Aa93PeRdH7TvlKKQsBMbSp9kaRH4,8412
+networkx/algorithms/bipartite/cluster.py,sha256=W0ZfqKOwz-UazQ6niOkr4S5xlcvsvVSMFHhFV96EmqE,6845
+networkx/algorithms/bipartite/covering.py,sha256=-_fHiWsMuzF8KrmpeOXFWiQctkKq2jiIlbHIN0u_HdM,2091
+networkx/algorithms/bipartite/edgelist.py,sha256=OQ8hTszNynjYVbhVS0ilgobEPvcIIhisivu9B1cTGw8,11198
+networkx/algorithms/bipartite/generators.py,sha256=pnyIACA6E5BXRGea7KvgXJYWzrcAQxRqWwTn2hYmfcc,19961
+networkx/algorithms/bipartite/matching.py,sha256=l7sahM0AhZ0GGmYj0m1xiRGCcd4Dfr-pc07pD6SL6GY,21273
+networkx/algorithms/bipartite/matrix.py,sha256=GJWEfVMwqfet589UNvDaZnJVdvQQYcVFSNqGu80CnUI,6382
+networkx/algorithms/bipartite/projection.py,sha256=XR81J4o7eUiBCMZV3JsqXq4tmE1ZYyVZEdE6t8xvMxY,17304
+networkx/algorithms/bipartite/redundancy.py,sha256=U6oV3JS6hxoMuqSznTr7Wp3iH90pkzXA5kuVWTutYzU,3479
+networkx/algorithms/bipartite/spectral.py,sha256=DqX2CJNvUIdEwblNbMIhCBb3LsEP5Gvk-yRytP0vlg4,1890
+networkx/algorithms/bipartite/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/bipartite/tests/test_basic.py,sha256=gzbtsQqPi85BznX5REdGBBJVyr9aH4nO06c3eEI4634,4291
+networkx/algorithms/bipartite/tests/test_centrality.py,sha256=gIXOB8ZP-uO9r5Cp23Yng_C4o-qCUKM_48GzFrlCWQ0,5901
+networkx/algorithms/bipartite/tests/test_cluster.py,sha256=8aJH5Ac8QbuknAA65w0rXUHwAjqqEImEYUyrt5pboM4,2809
+networkx/algorithms/bipartite/tests/test_covering.py,sha256=SbnZQTZY3jjt9Ncv--Q0tG7ywATk4vem2FPx7rV_Ixg,1229
+networkx/algorithms/bipartite/tests/test_edgelist.py,sha256=1_9UI5pv6qbD696ibnmSzf1rVLmWeYrRohZ_Xazg3Yg,6486
+networkx/algorithms/bipartite/tests/test_generators.py,sha256=GLMThTKIfZ96NwTxIL0P0o0OAESZFfnySRkRjtKhao8,12794
+networkx/algorithms/bipartite/tests/test_matching.py,sha256=xDP9qjK1xlfu1eVFGAOi6sk_w1AgWvMp5p2vBmz5J1w,11967
+networkx/algorithms/bipartite/tests/test_matrix.py,sha256=EoqQKTMcPPPPUZYTzc-AAtl5F77qT0X3FI3E1tYppxM,2900
+networkx/algorithms/bipartite/tests/test_project.py,sha256=Hx6P2NQII1O9-cF3GgHqfIZxUfyNjUtZ7i5-beAu4mM,14714
+networkx/algorithms/bipartite/tests/test_redundancy.py,sha256=F6z_h713fkLOAEhR_4LXWaRdP1amduCQYiVESGml61A,785
+networkx/algorithms/bipartite/tests/test_spectral_bipartivity.py,sha256=HZr6gYzQEpMTjnm7IaIne3lN9yr7pkKwYQXh8ljj9SY,2359
+networkx/algorithms/centrality/__init__.py,sha256=SQty4JnRqEKKomu9sE99VcVTouO5A_B0QUUicUIbY60,533
+networkx/algorithms/centrality/betweenness.py,sha256=em6GYnXMzvu1PdX0roN1eAIUTtaw6r8cHDvH6156_o8,14324
+networkx/algorithms/centrality/betweenness_subset.py,sha256=k7RNfHSR-2ZmK3UhhHD0ExibXGxjp8Iaa_BfEPCphIg,9655
+networkx/algorithms/centrality/closeness.py,sha256=2caNHg1O4ZnbmX-GOSBYDbsY2yMvCzGRj0wl1f3Lu10,10201
+networkx/algorithms/centrality/current_flow_betweenness.py,sha256=R_QKBxJuEN8jMPd0b-rbGrKfIowQ1Tk4lfhW-8RlhOM,11766
+networkx/algorithms/centrality/current_flow_betweenness_subset.py,sha256=1x3rUl2FdtWVdvY8uWGh_yme6Eyy4kamK40jApZqPwI,7976
+networkx/algorithms/centrality/current_flow_closeness.py,sha256=wqSzFa1CRsiJyqr5M0DpJXtfSPyxqqM9cIwpg5lfbao,3316
+networkx/algorithms/centrality/degree_alg.py,sha256=P1wQno5RrAK0jnZm9ZDO3UBcAoNIoygEmfCXURmO7Z4,3239
+networkx/algorithms/centrality/dispersion.py,sha256=WzE9_ECrM7K0QGTqgwTJJ-cvU2c-D41FMlZ8OYNr9Sg,3318
+networkx/algorithms/centrality/eigenvector.py,sha256=4NDbPe7NRS075XW4WwsJnZcuNngYlVxmGKjWT1-H_JU,8150
+networkx/algorithms/centrality/flow_matrix.py,sha256=GoXCdw0Cno58Fgv3wdfGJYQ2FkMiUIUI03486OyvE44,3919
+networkx/algorithms/centrality/group.py,sha256=VY7FcOQegFhCgEZ3mOmAGaAymBEWCntxYB6qriYjNt0,27731
+networkx/algorithms/centrality/harmonic.py,sha256=CbLCDYB54B-YqCGgEBsDLkC03SW-s0KitYhsbIN4J88,2589
+networkx/algorithms/centrality/katz.py,sha256=_FUTkTRHF73MdMkIBIumGndSF24XnoFNjSJMN-5nVOc,10674
+networkx/algorithms/centrality/load.py,sha256=2FAn5AO-KfWlkfTxcMJ0z9XDr2dmFjCIafsLJvaCyiQ,6801
+networkx/algorithms/centrality/percolation.py,sha256=KEs6W66WxXQaWlboYLziVhpVO_bGt4iSP4MTj3t2AA4,4088
+networkx/algorithms/centrality/reaching.py,sha256=JB4NXxR8QBiACGNS3ACJkyFsM1jEHumm9O5EXc5kKXI,6947
+networkx/algorithms/centrality/second_order.py,sha256=v7GhTeIRcRPevAc89MPNjkUp8CnTRfOJhNKQf4AGHlg,4728
+networkx/algorithms/centrality/subgraph_alg.py,sha256=3T8X153DaTttL7NSeZXuo1Vn8nC1rzc-tXgtoiEwdcA,9506
+networkx/algorithms/centrality/trophic.py,sha256=3wjkoPEWEgHXHp1i_t08sq4M4JNTGtc8iybNK_rPliE,4549
+networkx/algorithms/centrality/voterank_alg.py,sha256=OllLOtaPLPoBpbWobUXKS9UrGGKSy7tfFwUdr6IoR5I,3191
+networkx/algorithms/centrality/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/centrality/tests/test_betweenness_centrality.py,sha256=pKoPAP1hnQSgrOxYeW5-LdUiFDANiwTn_NdOdgccbo8,26795
+networkx/algorithms/centrality/tests/test_betweenness_centrality_subset.py,sha256=wW2PkIEQe-DQu2lCnRchlch2Jl2oh9stOESUbRM_gDM,8388
+networkx/algorithms/centrality/tests/test_closeness_centrality.py,sha256=XWZivyLjxYlF41U4ktUmvULC2PMvxKs2U6BHDXRZVdE,10209
+networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality.py,sha256=Wvu6wi3BPpsJPLyleV0OQhK_c7W7JTOSfGZCeYqzYPs,7204
+networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality_subset.py,sha256=JfRGgPuiF-vJu5fc2_pcJYREEboxcK_dmy-np39c4Aw,5839
+networkx/algorithms/centrality/tests/test_current_flow_closeness.py,sha256=E5LdZVJL2KNbfPeBbAVGOLCoE53ZaWTFqx4GdjL2pbg,1153
+networkx/algorithms/centrality/tests/test_degree_centrality.py,sha256=EKduYez3hTUWixAW0NN89l_a7A9j3XhF9ZYCOG4QKls,4106
+networkx/algorithms/centrality/tests/test_dispersion.py,sha256=YB67oQmolVh6PgEvrXApHrOJlK-f1TUGKPymSk6j2WE,1605
+networkx/algorithms/centrality/tests/test_eigenvector_centrality.py,sha256=BzZWTPAKHoWo0GnKfG2OCVuAzqK8djsZ44DSCHQxazY,4634
+networkx/algorithms/centrality/tests/test_group.py,sha256=YmWifoTgw2gSS5BnA9G2T_Voauk_WG6v90JrZEt-Kjk,8686
+networkx/algorithms/centrality/tests/test_harmonic_centrality.py,sha256=wYP0msmB5hh5OMIxPl9t0G4QSpG3Brxw98Kh9BrRoag,3658
+networkx/algorithms/centrality/tests/test_katz_centrality.py,sha256=hI2uNM3_LJhlEbWbiq4iB6L_NsTt_6XCfI6jl9yG6ik,11247
+networkx/algorithms/centrality/tests/test_load_centrality.py,sha256=eOBgwPIyaShzibQ61jEQNlIpEd8-Kh6iauRmmUupyO4,11080
+networkx/algorithms/centrality/tests/test_percolation_centrality.py,sha256=JRuGdrzHwhvsjCe2YKq7povPVWsanKOAXIia0_-KfCU,2699
+networkx/algorithms/centrality/tests/test_reaching.py,sha256=RxNFfPsMfbYpPLZcg2RWWKMWKqE9MFcN0JvjCnOgpKA,3865
+networkx/algorithms/centrality/tests/test_second_order_centrality.py,sha256=xqfVYRYPSv7x0AwUFlkoE1_m8xxG60koN-ychM6lrwE,1921
+networkx/algorithms/centrality/tests/test_subgraph.py,sha256=vhE9Uh-_Hlk49k-ny6ORHCgqk7LWH8OHIYOEYM96uz0,3729
+networkx/algorithms/centrality/tests/test_trophic.py,sha256=AzV6rwcTa4b4tcenoKh95o6VF-z7w75l81ZOdhhi6yE,8705
+networkx/algorithms/centrality/tests/test_voterank.py,sha256=7sNbtXv3578jKtCTPY4LTwR0LUIQq1u_qcWL5Lqm1Kw,1592
+networkx/algorithms/coloring/__init__.py,sha256=P1cmqrAjcaCdObkNZ1e6Hp__ZpxBAhQx0iIipOVW8jg,182
+networkx/algorithms/coloring/equitable_coloring.py,sha256=w82VwGjfpvry3j9h9zpgtcuAGJQNG3FtYUbJl4z2Umk,16571
+networkx/algorithms/coloring/greedy_coloring.py,sha256=BIE4ibWUD9mJtytevadGTSfiKGJA6wPi_iHjWm1SjQ0,19573
+networkx/algorithms/coloring/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/coloring/tests/test_coloring.py,sha256=p_84Boj4XK1BAVwTEvQoO3rUjMjzBoEDA9b5X8m5zeY,20631
+networkx/algorithms/community/__init__.py,sha256=SqTYf-Rsu4-4qOA4s_1pPz-eFx_AAHA01X5qm_LX3TE,1245
+networkx/algorithms/community/asyn_fluid.py,sha256=j2YyD_crV2o3ufiMsiFvItnAedqO4wW-ptG2LlyQFsc,5829
+networkx/algorithms/community/centrality.py,sha256=8L0Cq1upur2Bt6BgEDxqQR1MdRvYoDclWsrL7rUd0nw,6497
+networkx/algorithms/community/community_utils.py,sha256=_jpb_2iem4BoS8tDFKohvgOEl4Fyv0LcwvYJiHpwi5w,867
+networkx/algorithms/community/kclique.py,sha256=Yw4kW2Yn2Ru10RAJ_0xtMyhRIhiol_t9m_hjy_4mbHM,2487
+networkx/algorithms/community/kernighan_lin.py,sha256=AsKOcF07J6-ZYy9nkDDxnAblU43MrlwsqiUw_-hMYRw,4264
+networkx/algorithms/community/label_propagation.py,sha256=QbLnbpZLDTVVEkCFHInz4RzJrcXjaYx-yZgcDRQlwPY,7209
+networkx/algorithms/community/louvain.py,sha256=XHqCYWdWfi3sTIgxfjLoNGZ1hzkMapiFLHY0HWj5wnU,13576
+networkx/algorithms/community/lukes.py,sha256=m3uLqjY7LAONgAVknzp-XtpDW72rcjdERzcaD2mpsWU,8048
+networkx/algorithms/community/modularity_max.py,sha256=XMIkXc1vdgzTnl5w_rvBNWoee6WklKLjru_esf9o1RU,19281
+networkx/algorithms/community/quality.py,sha256=oEkmGVeMYpeVwjWLhVdveIOc-rAVxdyj0Szvy0HFnwE,14610
+networkx/algorithms/community/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/community/tests/test_asyn_fluid.py,sha256=YVLh9HVky72n9oywcIuVMGJPjJ97ga5O8E_l3qI8bnU,3046
+networkx/algorithms/community/tests/test_centrality.py,sha256=L0S-Dz8MKefObM9m0gFfZhxcfaQ4iwDNq-kovC9UEQc,2922
+networkx/algorithms/community/tests/test_kclique.py,sha256=LpHZPexPoLnrMmJXDxYSLr7XbjIRhiEAdZaSXJFa8fI,2407
+networkx/algorithms/community/tests/test_kernighan_lin.py,sha256=s8bK53Y1a87zvlZ1AJE-QJ2vItnbscSOlHQSrMpetGI,2709
+networkx/algorithms/community/tests/test_label_propagation.py,sha256=-SmqnH_9L8pbLW7NkGxg52Qrjm9j98W3zTe0xY8pcoc,5035
+networkx/algorithms/community/tests/test_louvain.py,sha256=rpn6896mZdz3EjBS0awwxch4hsNStSbo3-XKAXK_0Fk,4781
+networkx/algorithms/community/tests/test_lukes.py,sha256=PpFaCFeiUWhcW0k6A0cPjcIH4yF4cFhjivMw3-AoBZw,3951
+networkx/algorithms/community/tests/test_modularity_max.py,sha256=IaWS3VO-QbVTYTF780xpgKP-TUWyDIi8erya4UbbEzg,10373
+networkx/algorithms/community/tests/test_quality.py,sha256=FlL8fW0Gs-w_Y28Bd7tIqWJFImIz0pB7FEubgeB4VdA,5615
+networkx/algorithms/community/tests/test_utils.py,sha256=WLBssBjJR2ihRIVu78022n2O8Qv8xuLlJqz47kWP3SA,670
+networkx/algorithms/components/__init__.py,sha256=Dt74KZWp_cJ_j0lL5hd_S50_hia5DKcC2SjuRnubr6M,173
+networkx/algorithms/components/attracting.py,sha256=3HRqyJ3HrCOFVNZn_sdcgixIvhfp5BOsVxKk0CALrAU,2657
+networkx/algorithms/components/biconnected.py,sha256=MIDPAAFM5vsViksdzNpH-bpZI9ezKVilBB-FOzYFjQA,12501
+networkx/algorithms/components/connected.py,sha256=a1z8iYqMOLyRMoRhxqry0xm0t8uW5IFkFp1ahRPnUms,4147
+networkx/algorithms/components/semiconnected.py,sha256=JzUqo-WMBDw8dow8TAOZ8w2ARpTn_e_crKbJB_5vnWI,1588
+networkx/algorithms/components/strongly_connected.py,sha256=1VZbq98LKnECUvj46a92Fr8QNfo9ZATAAFyI7KnoCfw,11201
+networkx/algorithms/components/weakly_connected.py,sha256=ZsBSLEe4elp2qPipBPWFhAuIdXuvWFL_cOb9IgtF2oM,4074
+networkx/algorithms/components/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/components/tests/test_attracting.py,sha256=b3N3ZR9E5gLSQWGgaqhcRfRs4KBW6GnnkVYeAjdxC_o,2243
+networkx/algorithms/components/tests/test_biconnected.py,sha256=N-J-dgBgI77ytYUUrXjduLxtDydH7jS-af98fyPBkYc,6036
+networkx/algorithms/components/tests/test_connected.py,sha256=805NWi0g8doZ3WUguSY59ITrPSuE5J-VTj5j7l9xWsc,3675
+networkx/algorithms/components/tests/test_semiconnected.py,sha256=q860lIxZF5M2JmDwwdzy-SGSXnrillOefMx23GcJpw0,1792
+networkx/algorithms/components/tests/test_strongly_connected.py,sha256=r-H5xAbZiK0k-SGstJPy00xzlA0I9ym5spCGhRJjLvA,6554
+networkx/algorithms/components/tests/test_weakly_connected.py,sha256=yi23wxW2Vw6JOMqaWMEuqNRxnleriuAQrZ5JGWE48Jk,2887
+networkx/algorithms/connectivity/__init__.py,sha256=VuUXTkagxX-tHjgmeYJ3K4Eq_luK6kSpv1nZwiwGFd8,281
+networkx/algorithms/connectivity/connectivity.py,sha256=6FnncJG1-syvQk5_ToG2swxEqD04dVM6MX2O9hDMbEs,29734
+networkx/algorithms/connectivity/cuts.py,sha256=qp1kb9DGg3EDj-i-Z4hJCozgdNBMcZyz9nzkNOOovD8,22640
+networkx/algorithms/connectivity/disjoint_paths.py,sha256=H39ge1ZmxGK4TEYxES1_fLLoqUvgUANf_rgS3PchLIE,14425
+networkx/algorithms/connectivity/edge_augmentation.py,sha256=XP1zZb0Lp2-uySoLHA3iZ5Pqr-qPwOawY3qetrLOm9Q,43788
+networkx/algorithms/connectivity/edge_kcomponents.py,sha256=TM0EnginLyOgYifqcCVWrB-SNB5kg2s1cSO9mc85hlo,20687
+networkx/algorithms/connectivity/kcomponents.py,sha256=nLMMqfL5VwDcmQm_Vd1faoaAOU5JcgaLjPW9dj1nDLQ,8222
+networkx/algorithms/connectivity/kcutsets.py,sha256=454eDEjD6l1rI6pMR711LtGxE-GNpUM46YpqXRxqepU,9330
+networkx/algorithms/connectivity/stoerwagner.py,sha256=uP4AWBMqBZDfSzzoj2Wa989ykO6pNMPVdMDE6aeK7Ww,5340
+networkx/algorithms/connectivity/utils.py,sha256=mx7_WRUDm-VWVt5PgbnSMH9MbX0pW-adFrS-UNY7U3s,3144
+networkx/algorithms/connectivity/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/connectivity/tests/test_connectivity.py,sha256=PLOwCLA2ZyGsmCLeGqM9r8lEIIfYvJ5T-ZXxIafGDYo,15029
+networkx/algorithms/connectivity/tests/test_cuts.py,sha256=aYAluKaswU-HHx6iZnWx-MI-kwNJ7uXXA39Jx79IWiA,10358
+networkx/algorithms/connectivity/tests/test_disjoint_paths.py,sha256=0IqgdjbNpE3ziWREV8vOdjWHF7cx57BKrenqf8CfR3Y,8399
+networkx/algorithms/connectivity/tests/test_edge_augmentation.py,sha256=-26SQv4AW5oJoRc6RymCQDmeVHcTmc5KwcmetDLEXWQ,15522
+networkx/algorithms/connectivity/tests/test_edge_kcomponents.py,sha256=CZ26Dy91WOUqhw1X73mqLGX-WHWzBBIeBCgrp6KK4Zo,16453
+networkx/algorithms/connectivity/tests/test_kcomponents.py,sha256=ohoSX8GACeszRZdzTiNuWXSFitfU9DzP0hqllS2gvMU,8554
+networkx/algorithms/connectivity/tests/test_kcutsets.py,sha256=qzrxmW3-KEnkNvkP-nWtSQj40_pfzUFadDvv2bjGDT4,8488
+networkx/algorithms/connectivity/tests/test_stoer_wagner.py,sha256=A291C30_t2CI1erPCqN1W0DoAj3zqNA8fThPIj4Rku0,3011
+networkx/algorithms/flow/__init__.py,sha256=rVtMUy6dViPLewjDRntmn15QF0bQwiDdQbZZx9j7Drc,341
+networkx/algorithms/flow/boykovkolmogorov.py,sha256=KkcNNdbeipyuWMJ-UCJP326asD4uVtGsDKiTGYZrLos,13238
+networkx/algorithms/flow/capacityscaling.py,sha256=KeoOIrdZ_Ak_3b3KoEOF-o0LMGGdiceJE8FfamddRxE,14373
+networkx/algorithms/flow/dinitz_alg.py,sha256=u9_fgyD_B8MTHG6ZoExR5HR6G1HNR46uVRWp7c82JRE,7108
+networkx/algorithms/flow/edmondskarp.py,sha256=yidyYmtZNSPTarE1KuU1L53srNPq_VGXU_lIaGaeHcE,7956
+networkx/algorithms/flow/gomory_hu.py,sha256=YZajBDibtu1IX0_P47Bye_wXM9y1vGwiSfzeOO-rqB4,6267
+networkx/algorithms/flow/maxflow.py,sha256=BNqpMcMkqfG-EpnIiGpEmXXgA5GKfdoTM-GgrQTAnHI,22715
+networkx/algorithms/flow/mincost.py,sha256=1xn5I2z66BIBGTwNs_LspRICBTFqf-zdRD_3cqXy788,11968
+networkx/algorithms/flow/networksimplex.py,sha256=M-fkIp_OTaMmXKEwd8WPiYdA1Nhmjj1raZhlgGgC_l8,25089
+networkx/algorithms/flow/preflowpush.py,sha256=x1EUeTLeaTaPK0s1f6CIVxhQ7UBHvLUB37S8wc7WKis,15621
+networkx/algorithms/flow/shortestaugmentingpath.py,sha256=fOTpKT_wW3CHMZbAFkDiCsiYZ2OXlfTR15nxZ9I2QnA,10272
+networkx/algorithms/flow/utils.py,sha256=bugJtMMGob7Yz48xg8POSR_hG-yQd8k-SISiAOI7oWw,5743
+networkx/algorithms/flow/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/flow/tests/gl1.gpickle.bz2,sha256=z4-BzrXqruFiGqYLiS2D5ZamFz9vZRc1m2ef89qhsPg,44623
+networkx/algorithms/flow/tests/gw1.gpickle.bz2,sha256=b3nw6Q-kxR7HkWXxWWPh7YlHdXbga8qmeuYiwmBBGTE,42248
+networkx/algorithms/flow/tests/netgen-2.gpickle.bz2,sha256=OxfmbN7ajtuNHexyYmx38fZd1GdeP3bcL8T9hKoDjjA,18972
+networkx/algorithms/flow/tests/test_gomory_hu.py,sha256=aWtbI3AHofIK6LDJnmj9UH1QOfulXsi5NyB7bNyV2Vw,4471
+networkx/algorithms/flow/tests/test_maxflow.py,sha256=NJK_V40GHZtsM8DR-sLpMeNFHp46K8KcMj-pSYI8zdQ,18425
+networkx/algorithms/flow/tests/test_maxflow_large_graph.py,sha256=w7kDHC3qJeD1vO538jMTlVJRx5_2Fe8HfINeY71_7TU,4504
+networkx/algorithms/flow/tests/test_mincost.py,sha256=fSF6LI098og2G7qA_dlNFirSr6jOoKDeg3Ju0pUnrck,17665
+networkx/algorithms/flow/tests/test_networksimplex.py,sha256=E2iJrte1jS1-ODBQIBx7EbDL-uh4WXB4nv0LME52cu8,11975
+networkx/algorithms/flow/tests/wlm3.gpickle.bz2,sha256=zKy6Hg-_swvsNh8OSOyIyZnTR0_Npd35O9RErOF8-g4,88132
+networkx/algorithms/isomorphism/__init__.py,sha256=pODZ0ELhrxvY-qfcxL7FQcPPBfc6C9o39BcbFMs5O8E,354
+networkx/algorithms/isomorphism/ismags.py,sha256=ZmDQpO63by6ElTKvVk4-boy45JdP3UAYcHTSHja_r14,43599
+networkx/algorithms/isomorphism/isomorph.py,sha256=qHL_PU4ewMn7bt0d1qIaE3TEc6ZZCura8STinQ_h2ks,6382
+networkx/algorithms/isomorphism/isomorphvf2.py,sha256=PuPRVjHHtYJD4jeqOLsx-cvyz1tfjiL32_3ufWc1ff8,40556
+networkx/algorithms/isomorphism/matchhelpers.py,sha256=VN4eQjwhjOCHZsIKMziH0yr5yQlceOg2lnCnn8Gl2E0,10936
+networkx/algorithms/isomorphism/temporalisomorphvf2.py,sha256=N6yS-OSO_bqprlQgyNEGu27log0nG4RFqmQlAZny6zg,10949
+networkx/algorithms/isomorphism/tree_isomorphism.py,sha256=MNKPIHdA1q05AmYv9z_rLWAeW6-_msWiXOLO-UJcbw4,9258
+networkx/algorithms/isomorphism/vf2userfunc.py,sha256=jdvaGLziSM2XURVfxbRjMDX84i_8ewpY7di-u67cXBI,7496
+networkx/algorithms/isomorphism/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/isomorphism/tests/iso_r01_s80.A99,sha256=hKzMtYLUR8Oqp9pmJR6RwG7qo31aNPZcnXy4KHDGhqU,1442
+networkx/algorithms/isomorphism/tests/iso_r01_s80.B99,sha256=AHx_W2xG4JEcz1xKoN5TwCHVE6-UO2PiMByynkd4TPE,1442
+networkx/algorithms/isomorphism/tests/si2_b06_m200.A99,sha256=NVnPFA52amNl3qM55G1V9eL9ZlP9NwugBlPf-zekTFU,310
+networkx/algorithms/isomorphism/tests/si2_b06_m200.B99,sha256=-clIDp05LFNRHA2BghhGTeyuXDqBBqA9XpEzpB7Ku7M,1602
+networkx/algorithms/isomorphism/tests/test_ismags.py,sha256=NBuHegns9BFxZCrelBg1ZbJ1c21ZPH49doBnHsJxLvM,10616
+networkx/algorithms/isomorphism/tests/test_isomorphism.py,sha256=1GZmmqNWk605Qq9h55V_5SfEKPM50Ceq6DSICdh6ufs,1663
+networkx/algorithms/isomorphism/tests/test_isomorphvf2.py,sha256=lCC5KSNMfyEMSA4q1Xa41k2BTfmr2u2n6ImsDcupiC8,11480
+networkx/algorithms/isomorphism/tests/test_match_helpers.py,sha256=ocp3pd_JSCLHAp_mtsipu1XqehOgQCMuuhWEeRG5U7g,2456
+networkx/algorithms/isomorphism/tests/test_temporalisomorphvf2.py,sha256=DZy2zAt74jiTAM-jGK5H9aGRn1ZsMgQl9K5UNsu178Y,7346
+networkx/algorithms/isomorphism/tests/test_tree_isomorphism.py,sha256=NOrZQCy9nJFMeG-2oJGgsSAiq8sqItXhVqsOeH4bRh0,7154
+networkx/algorithms/isomorphism/tests/test_vf2userfunc.py,sha256=qOKeCm46kqdLO02H3wxMm2wEHzFQBdUFDdh_kC0KHwM,6630
+networkx/algorithms/link_analysis/__init__.py,sha256=UkcgTDdzsIu-jsJ4jBwP8sF2CsRPC1YcZZT-q5Wlj3I,118
+networkx/algorithms/link_analysis/hits_alg.py,sha256=3xuTVFDQN2VYz8qGVG2TmJ6cQreZm8GY3ZvjyDkAXus,11889
+networkx/algorithms/link_analysis/pagerank_alg.py,sha256=ItC0SgX5TR6b8uQP3eOl4fjZVjArLaiaV_F3eroo0VU,17691
+networkx/algorithms/link_analysis/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/link_analysis/tests/test_hits.py,sha256=qpjWeMHkNsepx_Al08wrHZpXYb5NRYgvliRDGEH2TWg,2953
+networkx/algorithms/link_analysis/tests/test_pagerank.py,sha256=QmYxqxmQaisUU3Dht9XY0NkHL4xmbuu7l83Gt4mS8LM,7562
+networkx/algorithms/minors/__init__.py,sha256=ceeKdsZ6U1H40ED-KmtVGkbADxeWMTVG07Ja8P7N_Pg,587
+networkx/algorithms/minors/contraction.py,sha256=t-RNVWgXjhqbNYUebJC7mZLpUZJAfFU4ju_WJrZ7Y-M,21746
+networkx/algorithms/minors/tests/test_contraction.py,sha256=EjNPMSAR_agCn6jclpx8ojhDg4G9FPVmQfpvgyiprMA,15918
+networkx/algorithms/node_classification/__init__.py,sha256=ZCwCp9_7nCD1d_7pwzXU3F9vT13uKhY7wtmRzrZKYQw,1748
+networkx/algorithms/node_classification/hmn.py,sha256=GFlPFKPQtfb1_SzXtVVnK2Gbepa2vPQdsGG_8j897kU,2603
+networkx/algorithms/node_classification/lgc.py,sha256=QDv7oMECQCz9G7tjwXUHcwL6WxiVpzxRe4IYcYrfP24,2722
+networkx/algorithms/node_classification/utils.py,sha256=oFTTByxlC-VjnwazPBpdwyIzEWEylEtFiDKkTc7NqSE,1023
+networkx/algorithms/operators/__init__.py,sha256=dJ3xOXvHxSzzM3-YcfvjGTJ_ndxULF1TybkIRzUS87Y,201
+networkx/algorithms/operators/all.py,sha256=kzyYsQHxPZ1JZO91u58kriq_vqNejd8Eaeu4rRsmoEk,6741
+networkx/algorithms/operators/binary.py,sha256=DT_vht6aj62yAlXrK4V9sgmAkMUgitvL397lnHwBM3g,11979
+networkx/algorithms/operators/product.py,sha256=ny5SSemJ5I6Gt7eIl3aDxStsIjq4TPWWx896mR06wpk,13857
+networkx/algorithms/operators/unary.py,sha256=D647RNItgvd05brXLA7VQxEQ1uTsg1PMAzSZshFxkfw,1717
+networkx/algorithms/operators/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/operators/tests/test_all.py,sha256=_WolA1dki0JqeDjLSXMbdGnUkxrP7WJKKIi30OEHQYA,7371
+networkx/algorithms/operators/tests/test_binary.py,sha256=_v7Tu9jzkjI5UYMp3SPKKswXIRqvrBZmwOJKh__b7jE,12033
+networkx/algorithms/operators/tests/test_product.py,sha256=EYTajjizRtZUjQk8o3vjPGoyfs4cDyevLyblCO6RsJI,13188
+networkx/algorithms/operators/tests/test_unary.py,sha256=UZdzbt5GI9hnflEizUWXihGqBWmSFJDkzjwVv6wziQE,1415
+networkx/algorithms/shortest_paths/__init__.py,sha256=Rmxtsje-mPdQyeYhE8TP2NId-iZEOu4eAsWhVRm2Xqk,285
+networkx/algorithms/shortest_paths/astar.py,sha256=Yk0U976Uq4HNsaaC7M7pw1zRyzw8NpptX12WMBYVHrE,6990
+networkx/algorithms/shortest_paths/dense.py,sha256=dxDu2puBcMzLlvxemBK-KSr3LUbyGzErTmXdj1Po-ok,7300
+networkx/algorithms/shortest_paths/generic.py,sha256=5TIjfQnbWdbhD5bS_oZJ9WwrEHFKHTX2K4-KrK9wwFg,20139
+networkx/algorithms/shortest_paths/unweighted.py,sha256=z7Fs94f8R-jeBLH2TAZOQBKEMqQGt_czeI07_1WUUNM,14220
+networkx/algorithms/shortest_paths/weighted.py,sha256=7KA42oSuVrdPY3k9z5yEAMu2xriPv_EobxxlkEYtvO4,80039
+networkx/algorithms/shortest_paths/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/shortest_paths/tests/test_astar.py,sha256=CWFKGGoqhDMBA6pQP-osmHzmfuf1PxYKp1otgR0UV94,5507
+networkx/algorithms/shortest_paths/tests/test_dense.py,sha256=ievl4gu3Exl_31hp4OKcsAGPb3g3_xFUM4t3NnvrG_A,6747
+networkx/algorithms/shortest_paths/tests/test_dense_numpy.py,sha256=BNwXCe2wgNPE8o35-shPsFj8l19c_QG6Ye8tkIGphf8,2300
+networkx/algorithms/shortest_paths/tests/test_generic.py,sha256=5xmZuWeBaIKlzxp4Y1C_ADhNkJfCwUQSczFB-ezdKu8,15463
+networkx/algorithms/shortest_paths/tests/test_unweighted.py,sha256=H2j_MaafTzx2U-biPiViuFPOdk0H50s80HlGQaXBaAA,4601
+networkx/algorithms/shortest_paths/tests/test_weighted.py,sha256=D4MHcUhgYueBAAUccAmESnlcLAHBsd75kuUCiQ0vfg0,33263
+networkx/algorithms/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/tests/test_asteroidal.py,sha256=uMY1UbtYj5pHEwZbCBT5Ep_jVv1uDa7rSXLWVKUkcWk,503
+networkx/algorithms/tests/test_boundary.py,sha256=ebnJRPyYZOjKE5x0PfXXbiEWA9w4mZtL1j19Lh46WtI,6227
+networkx/algorithms/tests/test_bridges.py,sha256=1STJG5IFSe1rnr64BKrnE7Gm__oCAHxOSHBwl-z97rY,2513
+networkx/algorithms/tests/test_chains.py,sha256=akKRVr3itHTDEll3t1QGhjElAWLWgqI6yiX8vQYJ5f0,4086
+networkx/algorithms/tests/test_chordal.py,sha256=tY-lw79emVZ27jb-zNpufDWiObdeZODWm5YbvI-meeo,4458
+networkx/algorithms/tests/test_clique.py,sha256=BT9VStBBVLLT5-mD2HB0E_HiwzcbmoBVISQRhs7VCpc,10519
+networkx/algorithms/tests/test_cluster.py,sha256=AltwLWAblpSLa-24KvNuxYxM2IeVl5p2d-kozA9QJ-0,15595
+networkx/algorithms/tests/test_communicability.py,sha256=dUKeV-abTQqHfNZY4lelu7aBR1fVgNrMCpKrE5V1P9Y,2939
+networkx/algorithms/tests/test_core.py,sha256=l29lU66JqKCmzdrt5ZnuHJ0Sy0Vu_pYGZRiPClMOm1k,6581
+networkx/algorithms/tests/test_covering.py,sha256=FZw0-_mOwDS7pMFH4tKOZ1YJ7te5i7DTS8Ji62flqO8,2417
+networkx/algorithms/tests/test_cuts.py,sha256=2Ir5xyIG4cTC4Dgg1cceLXaEFiOCJ60ZTDDn33vz0Ns,5377
+networkx/algorithms/tests/test_cycles.py,sha256=NjHzk9QxldNf7NV25F_U4rT-U1B4rdUCrqVnRa5I1Ng,11758
+networkx/algorithms/tests/test_d_separation.py,sha256=wFRwZdvSAi4b9FDfWEIE93Lhc73kv44eyQq4rwrvevg,4312
+networkx/algorithms/tests/test_dag.py,sha256=RGAtEBz_HxpsD3hjXZY9Sh71C3Un1j_j4cb4V7_6Dho,25805
+networkx/algorithms/tests/test_distance_measures.py,sha256=2Z3tTpwpOehI4h9diSHmwPGO7oyG8zxswJkTaxPFAnE,8478
+networkx/algorithms/tests/test_distance_regular.py,sha256=pPZ2CPKo4QLjhxlcJhBQZif6-_2qwfh1kpbrN_mu5tg,2312
+networkx/algorithms/tests/test_dominance.py,sha256=ZeLzdelMFDPBdKnFykUAG565gs5ySUbEhdBMT3HX3hQ,9388
+networkx/algorithms/tests/test_dominating.py,sha256=hyta7ln6BbHaGlpEUla6jVzh2PRuSjvujLSGXrmwZbc,1228
+networkx/algorithms/tests/test_efficiency.py,sha256=QKWMvyjCG1Byt-oNp7Rz_qxnVeT77Zk27lrzI1qH0mA,1894
+networkx/algorithms/tests/test_euler.py,sha256=Q0GeWkKTyqEaLAJLM7kuyVrcYF_n73MiM13x8o5iJ0Y,10038
+networkx/algorithms/tests/test_graph_hashing.py,sha256=duR9DQLUpRuy9bv0ZKQPt9gy9WxiX_K0-BVMlnF-WHY,23517
+networkx/algorithms/tests/test_graphical.py,sha256=iwaAV-LLxzxdrQFHD7zYGzRdwhKiWIzHSlMypu0BF9w,5370
+networkx/algorithms/tests/test_hierarchy.py,sha256=g3-0pNfzRo-RDW1BsiLXxyi2LwWIJukXx2i4JCpN2fg,941
+networkx/algorithms/tests/test_hybrid.py,sha256=kQLzaMoqZcKFaJ3D7PKbY2O-FX59XDZ1pN5un8My-tk,720
+networkx/algorithms/tests/test_isolate.py,sha256=LyR0YYHJDH5vppQzGzGiJK-aaIV17_Jmla8dMf93olg,555
+networkx/algorithms/tests/test_link_prediction.py,sha256=7c322xESYdH5WEA0TsMw4Jcc_-lqfIsj-SjXP6Y0TVc,19442
+networkx/algorithms/tests/test_lowest_common_ancestors.py,sha256=BeuSAX3wqel2mn40cu1FehcvecRGeuCw1plWQFY-oZA,10922
+networkx/algorithms/tests/test_matching.py,sha256=MwQxn_YPJ_TzKabKjLUZfORbtDaXPh8jQtP35RkO6Eo,18836
+networkx/algorithms/tests/test_max_weight_clique.py,sha256=iYLkDGzYAmZ06IcT-0Rtay7UyjJ0A2y7ilXUTjDFg44,6742
+networkx/algorithms/tests/test_mis.py,sha256=F8cf09mvzG3A_omw6wWR1-j9i8WUmpGI9BwGdi2bHes,1875
+networkx/algorithms/tests/test_moral.py,sha256=15PZgkx7O9aXQB1npQ2JNqBBkEqPPP2RfeZzKqY-GNU,452
+networkx/algorithms/tests/test_node_classification.py,sha256=ZGa_uSd6tRqDS775mrPaRLbIr5CDQEMS8qw1frO_pEU,4669
+networkx/algorithms/tests/test_node_classification_deprecations.py,sha256=5UcqqCFIZUiFZ1NsDhTQnMcecbQxFEe6qlzgNGDmPTQ,1286
+networkx/algorithms/tests/test_non_randomness.py,sha256=-8s-fJLYRxVNp7QpaMe5Dxrxi0kvewY78d4ja-nXNBk,782
+networkx/algorithms/tests/test_planar_drawing.py,sha256=FrpNWiGxNzBokpSZHfa8q55UyRn0v7gzwgUmNcMvT7I,8775
+networkx/algorithms/tests/test_planarity.py,sha256=Ts63BD2k38lWA8tDv95YkMFfskHHdZizmroeh5WYEgk,13169
+networkx/algorithms/tests/test_polynomials.py,sha256=baI0Kua1pRngRC6Scm5gRRwi1bl0iET5_Xxo3AZTP3A,1983
+networkx/algorithms/tests/test_reciprocity.py,sha256=MkdZ2w_7i0UPK6PdnStULwmzAt7RAe9xS0_BWxiK05s,1297
+networkx/algorithms/tests/test_regular.py,sha256=zGf7Mmh7XPtwunOoeTfgiICnfsVeCEbMop3NrDgIfqY,2457
+networkx/algorithms/tests/test_richclub.py,sha256=lugmYnRVZz37WWFVaZuVnfuOIZTCddIk1KxNoeNnPYY,2258
+networkx/algorithms/tests/test_similarity.py,sha256=Lrg6NjvE369HDxna5LwsvCPFjYpOx97Q0RjMQ-Iyskc,32195
+networkx/algorithms/tests/test_simple_paths.py,sha256=YT1PSijWs22dxoUI_lfzYOj1ukr--kNEtie-TGZXKF8,24008
+networkx/algorithms/tests/test_smallworld.py,sha256=ReQRXdtXRCRc9YTOATYz_CyOEL5YYiU73GZme_gpjrU,2153
+networkx/algorithms/tests/test_smetric.py,sha256=x2LR9IyimDRC29a0uBnPeBCxptSK90NLN6GQYAH9nRc,426
+networkx/algorithms/tests/test_sparsifiers.py,sha256=A12V4ljWxvXaSFJ73mHSFK2YNO-k8ax6Me4yEWTsI4s,4043
+networkx/algorithms/tests/test_structuralholes.py,sha256=p2PogSKedBHR1bT6x-tuj8aqV3L3tr842v6Z8QozYRI,5228
+networkx/algorithms/tests/test_summarization.py,sha256=msFYq5KWCMT4sK6qXhn_ZItJwlvaANqEGP_bhOl0atY,21393
+networkx/algorithms/tests/test_swap.py,sha256=SIQRGQv9E8phEzrxQKkx0GP-tyiwFEWnkONF06H6VtU,3067
+networkx/algorithms/tests/test_threshold.py,sha256=n3dSpE3amPa49C4MsAffSpZ259saTU0c-1mMzERrh84,9760
+networkx/algorithms/tests/test_tournament.py,sha256=xxmLb9Lrmjkh9tKmyv2yYJrhB2PHWh-Bq71M-d1NjQo,4158
+networkx/algorithms/tests/test_triads.py,sha256=td8v-_0JiLvV0ZW6ADqE8V5iy5p9wfH-jYJtrA-LJ-Y,8952
+networkx/algorithms/tests/test_vitality.py,sha256=p5lPWCtVMtbvxDw6TJUaf8vpb0zKPoz5pND722xiypQ,1380
+networkx/algorithms/tests/test_voronoi.py,sha256=M4B6JtkJUw56ULEWRs1kyVEUsroNrnb5FBq9OioAyHM,3477
+networkx/algorithms/tests/test_wiener.py,sha256=NJJbXZ9L5ZeFGQpCpvYVWFNqyX3amkbuDQEBL7wCixw,2080
+networkx/algorithms/traversal/__init__.py,sha256=YtFrfNjciqTOI6jGePQaJ01tRSEQXTHqTGGNhDEDb_8,142
+networkx/algorithms/traversal/beamsearch.py,sha256=2iRO5_t4ZweZ2Jg9nBshRBOdWkcb8KB-fDgTFyhviRo,3388
+networkx/algorithms/traversal/breadth_first_search.py,sha256=xB5bwg8qRfndDMRrz8lA5XI-kawbNjt_f7KsK8gVgyY,12930
+networkx/algorithms/traversal/depth_first_search.py,sha256=1ladJNGDxeu0aRved6IG1EWU8lcxJJBm1b_JZWJ-2oc,12842
+networkx/algorithms/traversal/edgebfs.py,sha256=7eVnh6dqqpoCAW_dNIACvWgBj1-RytVGBft9V8Qr8eE,6233
+networkx/algorithms/traversal/edgedfs.py,sha256=sqssJqQ3M-xDdU1sPdxMd_VDQcxymYMv-wKnSEZEHOE,5938
+networkx/algorithms/traversal/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/traversal/tests/test_beamsearch.py,sha256=XutDm5yWOB6lU0p_Wtd6RSSOdd7OfBMkhvQ70wxzb6w,897
+networkx/algorithms/traversal/tests/test_bfs.py,sha256=nm9WzJgBwB_AuPDQD5DKkZc5vpj8Xks08sSf-dL4E9o,4060
+networkx/algorithms/traversal/tests/test_dfs.py,sha256=_pk1X-gJr3eIZGKulPmP2apz6K0AMSrs21cijyRI0vU,5487
+networkx/algorithms/traversal/tests/test_edgebfs.py,sha256=8oplCu0fct3QipT0JB0-292EA2aOm8zWlMkPedfe6iY,4702
+networkx/algorithms/traversal/tests/test_edgedfs.py,sha256=HGmC3GUYSn9XLMHQpdefdE6g-Uh3KqbmgEEXBcckdYc,4775
+networkx/algorithms/tree/__init__.py,sha256=wm_FjX3G7hqJfyNmeEaJsRjZI-8Kkv0Nb5jAmQNXzSc,149
+networkx/algorithms/tree/branchings.py,sha256=lrFHGdFFgkEHrFY_D5j9BoDZoZVmxa2rE6KSpYWTVJQ,36255
+networkx/algorithms/tree/coding.py,sha256=RrzQtnGmZilhyXeVVMWYLGmdMMkh0wZHtF5MMTRdRbo,12987
+networkx/algorithms/tree/decomposition.py,sha256=9FoC5jiOM_TbrKs3MlV3NZZ5t8t8a3Qbya88vlM6igM,3034
+networkx/algorithms/tree/mst.py,sha256=hd4GDW3CcV76dv9lZhsS0m5G2Li-sRwGy6zv4U7e1_g,39261
+networkx/algorithms/tree/operations.py,sha256=bAIIsuZ5CJQOFtMzG6ZIEEiE23QGzu1eIY7uqLuu7LA,3499
+networkx/algorithms/tree/recognition.py,sha256=u36v_SVmQ2W77gB55vvsU6ayG12zYwKOGHPwVxvSnRY,7497
+networkx/algorithms/tree/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/tree/tests/test_branchings.py,sha256=-jSj7I0dCOxcK3kTnXQRu-NDOWOQH7tzXlOZqkJcRKk,15249
+networkx/algorithms/tree/tests/test_coding.py,sha256=f3A5dvfkWImC6Jp2qkuw2Sz3whOsabnaOfu6Eh9r65I,3954
+networkx/algorithms/tree/tests/test_decomposition.py,sha256=vnl_xoQzi1LnlZL25vXOZWwvaWmon3-x222OKt4eDqE,1871
+networkx/algorithms/tree/tests/test_mst.py,sha256=Pgym7C6ZMb5npBbQbIf6aZ4bjfkYaLoHTRx0fJ2GV4I,21428
+networkx/algorithms/tree/tests/test_operations.py,sha256=0IevbCpr0F6AQBLlxbp5qSO9ENf-y1lg1ZkZxuWpHfc,1124
+networkx/algorithms/tree/tests/test_recognition.py,sha256=1Wz3PHAvAkt2Q_00HUXcfabRY0E63VBwNREAeWoz9N0,4173
+networkx/classes/__init__.py,sha256=AzOWEJxd7rt8jdPvdMmPdKvhbQTksRvSN86TGRS8HnU,335
+networkx/classes/coreviews.py,sha256=i0EEXzpKsW3W62_aP83JrHOxhlaS5K0xZiVE7IBBFCM,15471
+networkx/classes/digraph.py,sha256=YDnFAxhtaMYOyWfipiCu_x62BLlFldgNalDJQ_yBgEs,44427
+networkx/classes/filters.py,sha256=47OFApfkvvohVMoZ2v9sniM6sgv9rka869BDwmbdww4,1715
+networkx/classes/function.py,sha256=jXB672qCM3kNUWjTJG7_Rj7IqXYTRvrLJCqdkWj6Ync,35449
+networkx/classes/graph.py,sha256=whquojGtufS_LgPbPVKtiNUOgDQqzyNTPfIs6gu8HUQ,65984
+networkx/classes/graphviews.py,sha256=p-TcscD--cuB9zn4LdmsfohdUFn3izL30J-88MSb-To,6567
+networkx/classes/multidigraph.py,sha256=GFEH-3FWb1hlNjSeQgSlciLs0zTMt2XWDZAJSnvgCQs,35867
+networkx/classes/multigraph.py,sha256=Mt6njKgMg1gjVC33LMRlbEH1yEuYNOlIwH5fLZfC6K4,45810
+networkx/classes/ordered.py,sha256=RxgDUaJMlO887FsXws4SiPib7hCB6kUCAdCz0vwqRGg,5405
+networkx/classes/reportviews.py,sha256=H9BCIugWdoAsAsQO1F0oDbjNCQIdyI4JltQbqVc8Mb4,45714
+networkx/classes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/classes/tests/historical_tests.py,sha256=mMQy3mZ9o5ybkTUvtcl6eFflcCX4Ocntb1L35MOwZ08,16173
+networkx/classes/tests/test_coreviews.py,sha256=KcvLfvPXgIKYJrW97M5I6HgJrbHa3mb60CQc3QlV3Bc,15409
+networkx/classes/tests/test_digraph.py,sha256=3OgbdTjpyaZBi6SIoUdH3p2c6ia0d0UpJmC1qs7R9Ak,12059
+networkx/classes/tests/test_digraph_historical.py,sha256=xb2sylutpDIPXM1stcGW-tsW0xFOPQ-WZ7UbqapHEm0,3689
+networkx/classes/tests/test_filters.py,sha256=fBLig8z548gsBBlQw6VJdGZb4IcqJj7_0mi2Fd2ncEM,5851
+networkx/classes/tests/test_function.py,sha256=aYAhSFHAhH2L_LCyrfxLEt1aYcItYAEwq9NyzDblzOs,26327
+networkx/classes/tests/test_graph.py,sha256=2PsivQzvN3od05YOtKRsqQe2NXGLibf-npnwaNP_RQ0,29739
+networkx/classes/tests/test_graph_historical.py,sha256=-jf961vQCuQLyly0ju50q9dbzWG5m2OAs9H6IVS670c,273
+networkx/classes/tests/test_graphviews.py,sha256=7PaY2AuqgCb-TS1pvjkf51GZMsTY179XUxLGRNTx-M0,11524
+networkx/classes/tests/test_multidigraph.py,sha256=nyCRNuIURmk3wFKnLfuPIb9BI5Rjkwd4gjmt5kwc8FE,16034
+networkx/classes/tests/test_multigraph.py,sha256=9z0ocdUGW0kq_zL2XQgBrdNecTQwwys6h-5GbaxgGr8,18568
+networkx/classes/tests/test_ordered.py,sha256=QlDQyKzstSOUQWfIMSMl3hTq9e65pWNYhLlH2U0xkRI,1148
+networkx/classes/tests/test_reportviews.py,sha256=ek-FMPYupoFUFIP-Yv3aJXDYmPs4jcYhreZOrI7Rn88,41317
+networkx/classes/tests/test_special.py,sha256=Uq25h522f3ndVE7P8jc4IwghGggLK6vkP-MtxNoVgJY,5760
+networkx/classes/tests/test_subgraphviews.py,sha256=yEhUPLdS7fW7gLuZzEyQu6zGWnBGvS0GbUbYpuDHTHA,13192
+networkx/drawing/__init__.py,sha256=rwVeOR7MCDwBUhXnx5VyiP0YfXkCeT7waocuqwXEPw8,136
+networkx/drawing/layout.py,sha256=U3hFZNtAarnHtNrnUCEnDXw-f71QhGFT7jGvTveTV4w,35778
+networkx/drawing/nx_agraph.py,sha256=SKICRNITffboFQN-m_bo4sxKteiHTdqHBpKTQybf48M,14699
+networkx/drawing/nx_pydot.py,sha256=icNbna-3F2kXQGGtnjO4oKiH368Cc4Dtbozuv-kHsVg,14091
+networkx/drawing/nx_pylab.py,sha256=Hj4Bl4hZgr5lBin2goU4jvvkaqQ_-v4oUNotsu6es6c,48387
+networkx/drawing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/drawing/tests/test_agraph.py,sha256=LM4XfZ1C7MPdNDYgqhy3ImHIafIIp4RgetDVe14khv0,8633
+networkx/drawing/tests/test_layout.py,sha256=fhL7o4pi1FT5t32FsWHMimTCeyOuFC4CcaunDreNsdw,17005
+networkx/drawing/tests/test_pydot.py,sha256=zxq8cyjl0ANJg63aXv87D1xvsju6wHQGPt94C8AFLB0,6241
+networkx/drawing/tests/test_pylab.py,sha256=06GFkbfc4KAX4Dq9VoNzlamyAWMlutyLQJyuQ-SdQQo,26085
+networkx/drawing/tests/baseline/test_house_with_colors.png,sha256=FQi9pIRFwjq4gvgB8cDdBHL5euQUJFw6sQlABf2kRVo,21918
+networkx/generators/__init__.py,sha256=vgbZl18dH6eXOnKI60TJjxrVRsfg-PSPo16i7OSEMr8,1272
+networkx/generators/atlas.dat.gz,sha256=c_xBbfAWSSNgd1HLdZ9K6B3rX2VQvyW-Wcht47dH5B0,8887
+networkx/generators/atlas.py,sha256=f0276nWepfl7P5nbCmZ6Fcd8zntPbRuZKxoQqweM0C4,5548
+networkx/generators/classic.py,sha256=mvK7lT0Y6LX1ipgwk2guIDj_Th1QQtccrae_qJr5_6o,23801
+networkx/generators/cographs.py,sha256=4ebIRwmgDiffa2ofAVGolkpnxQzN1xfkq0r1crnwpEE,1844
+networkx/generators/community.py,sha256=jI-PGI-mC6mubahXRIwj-qJDz9nRX4VE8vMDNosoTGY,34429
+networkx/generators/degree_seq.py,sha256=B3_2OW9EK-u_UHz9vjChwDNTPZG1TrRLMoeYYwGz-Wo,29817
+networkx/generators/directed.py,sha256=Ukdw9h3taJGO3x0zEAIzMsw0n5B5ZOAk2BqcKl-jrpk,16676
+networkx/generators/duplication.py,sha256=qpX1nx37qtJt2NN9EOJQJqusFJLLNpzJmLJ8aE0mkhM,4959
+networkx/generators/ego.py,sha256=CbIbzM9Dxk8OM48Xw4Qu9AwoL9J9SeEzvc5KWXaomHg,1836
+networkx/generators/expanders.py,sha256=Q-fnJKbIc_XXHaHOk9D4rVLXJKHk2Yg6ZgrMfoEJk88,6191
+networkx/generators/geometric.py,sha256=NvQSapYw2pgEbDlI2FwmfX2gxmwoHzP5HjDQesdKxyk,29482
+networkx/generators/harary_graph.py,sha256=zDhVtwJJkr-UjOY8jGhuvPQ7b_Mjve7XpLNNA4I2cLo,6072
+networkx/generators/internet_as_graphs.py,sha256=MyaBr9iRyTDij94ukTKZJUTFrx3X792VcquDnm-bzqs,14128
+networkx/generators/intersection.py,sha256=n2molGcwS9tE7Lo65clvJqTynymOmtqXrn5jQPKpTbQ,3947
+networkx/generators/interval_graph.py,sha256=5bV5ZL66tsDazbbe2IZY3uZFqLoTAqj39F1HJKvvct4,2186
+networkx/generators/joint_degree_seq.py,sha256=LGV7USEfG-t6zUzfip1xnCAgAVn5qkaLAgi1zHt8-50,24785
+networkx/generators/lattice.py,sha256=qDwNX7eSXsn0YKiV42aF_7sjGLyov0N-uBsMRmTgbRs,13222
+networkx/generators/line.py,sha256=CFqpIqDUhDNQKn4eK43aOAS_bqddRpqf-P8l6RM9MhA,17654
+networkx/generators/mycielski.py,sha256=aWhsBSq5fagkxfRqN45Gswpo64jv9lSu9A_g2mMV2P0,3225
+networkx/generators/nonisomorphic_trees.py,sha256=GZJaC09tck-8vtzxH1px9RJTcl8B5WbWaC9ldqTA_MQ,5180
+networkx/generators/random_clustered.py,sha256=DBWtgWQT4gHX7mb4iZjRhfDMEfcoWGzIynEOBQp2cZ4,4132
+networkx/generators/random_graphs.py,sha256=eGaNxx06z3gJrv64vGcoeyXKBKqjYVXMmd8g29y23nA,44337
+networkx/generators/small.py,sha256=-MKuw9rirnVQP5C2JWM78nLq0onGr2Y2i8xlif0p5J8,30426
+networkx/generators/social.py,sha256=ghaDZVhcuUneZ1PS6mkMERgk8yPGAOGU9fHJgy7lAWo,22759
+networkx/generators/spectral_graph_forge.py,sha256=sZnPxv8jKs43Y0gCaHKqZrC-_BEunYaZqKyzKaWl9zU,4246
+networkx/generators/stochastic.py,sha256=5H1kxP4za36KRkfXF8CGGg_X15GtCfQdx-6gzXdHtok,1840
+networkx/generators/sudoku.py,sha256=sc2oGk0vvSmmSzlyHWCntJ8_fXvh9VomeJ-0v6p8yew,4243
+networkx/generators/trees.py,sha256=ayXZBWb6uUgHWFG5kYkZAtV6yC3vy-5_7gS75J_CtJ4,14146
+networkx/generators/triads.py,sha256=OAVGc07yKJ2d2IAvSF94z8f1KHgFS9lMeC7HoWCn8V0,2184
+networkx/generators/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/generators/tests/test_atlas.py,sha256=nwXJL4O5jUqhTwqhkPxHY8s3KXHQTDEdsfbg4MsSzVQ,2530
+networkx/generators/tests/test_classic.py,sha256=5iBXKn9DZKvxmtpqWwF7LEpV4TRcSK9iRaeBGagjjUw,19550
+networkx/generators/tests/test_cographs.py,sha256=DkiQzP69sjw3QtjWVX2XV0EXoOuEvR42dixPWwuawSE,460
+networkx/generators/tests/test_community.py,sha256=-8AKUr10zQ_KZKoGud00ypxsby7-YNGoO80qibw8h5E,8681
+networkx/generators/tests/test_degree_seq.py,sha256=xCcfFEHee6AzVdRKHZOZBEHbv03UC8PDYAWM9BON3sc,7106
+networkx/generators/tests/test_directed.py,sha256=fGzUOVnwNR1aOv-9R6caYQeT-xZ_Ea1v6qPFxi19swE,4179
+networkx/generators/tests/test_duplication.py,sha256=IIzcHEfHp0NHsH7GTXSb4E4kgXAlt83q4IMibfx2FBw,1915
+networkx/generators/tests/test_ego.py,sha256=8v1Qjmkli9wIhhUuqzgqCzysr0C1Z2C3oJMCUoNvgY4,1327
+networkx/generators/tests/test_expanders.py,sha256=aYS2zuodq7AeVISebU_O_QIFxIPBgto8J-vEsaqPhy8,2389
+networkx/generators/tests/test_geometric.py,sha256=3ZHjCZJC9DH8jKO5I19h_TisEwVYQC21ADE7LJreclc,11237
+networkx/generators/tests/test_harary_graph.py,sha256=_k00U6jwuGSLu444Cb4q4zRaLV7ufNWNTHJBMOnFmf4,4958
+networkx/generators/tests/test_internet_as_graphs.py,sha256=lR3_KuyETCVxPnRaNeks0sEcNljHmi2ohOYkxaplgmM,7137
+networkx/generators/tests/test_intersection.py,sha256=hcIit5fKfOn3VjMhz9KqovZK9tzxZfmC6ezvA7gZAvM,819
+networkx/generators/tests/test_interval_graph.py,sha256=-1yXDZDW-ygmNva9Bu-TsS_SYGLcW1KJplwZHFFYyWM,4278
+networkx/generators/tests/test_joint_degree_seq.py,sha256=fHK-hW_9aGdf13AlnvoZZmNMTik8CXPoJelmhSzzcXM,4272
+networkx/generators/tests/test_lattice.py,sha256=EFhg_eA-q9x2e56FMIT_Jw3ZXqhjW1yt6Iy-EhUIzzU,9292
+networkx/generators/tests/test_line.py,sha256=f_6YjUGctdlw6ZbSZqoFVpBfTWZLKsW4w8TE5RfLnZ4,8471
+networkx/generators/tests/test_mycielski.py,sha256=cAg2J6o_RrbwEdAc0vCuSF6zeS6w1KT4leTM0vkIeoA,822
+networkx/generators/tests/test_nonisomorphic_trees.py,sha256=Y_qWyj_qZU9O_DC4BHEVD9xnIEALCmfdmZAYJjTxUYE,2384
+networkx/generators/tests/test_random_clustered.py,sha256=LTfigb1swnYWS59OJoBmNcjFcUjsodnHVOwFxBXl7xg,979
+networkx/generators/tests/test_random_graphs.py,sha256=kA2Qo-DbbnBDN8PVcbE9-y22L7JD4B56DfaNU52myY8,12827
+networkx/generators/tests/test_small.py,sha256=yXMFFqC2IWlW_KSvt77H_JYE1i8P-7kmiB7FgR1_iZQ,7354
+networkx/generators/tests/test_spectral_graph_forge.py,sha256=x4jyTiQiydaUPWYaGsNFsIB47PAzSSwQYCNXGa2B4SU,1594
+networkx/generators/tests/test_stochastic.py,sha256=nPupQ2mG2oy22gGCs1dPFg4nZHYObsQZ1bBxTXTsEG0,1822
+networkx/generators/tests/test_sudoku.py,sha256=dgOmk-B7MxCVkbHdZzsLZppQ61FAArVy4McSVL8Afzo,1968
+networkx/generators/tests/test_trees.py,sha256=6FIXOXkiYs4_fr7HCq5q8TcQ87ML_73fZNqT8VI2hVA,2901
+networkx/generators/tests/test_triads.py,sha256=mgpHFf0Z34CqtnXgkdf7gK1dC77ppYAqwviXsaU1HVs,332
+networkx/linalg/__init__.py,sha256=7iyNZ_YYBnlsW8zSfhUgvEkywOrUWfpIuyS86ZOKlG8,568
+networkx/linalg/algebraicconnectivity.py,sha256=yRu4HOy1EWdk5jSWTRV1vnSumYvIwsd28ffCyh1BPFA,18281
+networkx/linalg/attrmatrix.py,sha256=Swp4TdcOo7OWvJEdwdSvmZBCeI56SxJQpmc4GSLnmEI,15658
+networkx/linalg/bethehessianmatrix.py,sha256=_Ni1dtnow03zj9J3OENlrqK08_p2e9FOKBOwIiQzIIk,2996
+networkx/linalg/graphmatrix.py,sha256=srUndtkU9U6I6VSFDrm9MgH6qm1SChIJ5RYaY1g1maE,6071
+networkx/linalg/laplacianmatrix.py,sha256=aPJPMP-WT85hy6jZcC6w9m7S2_gOQP2_3Fz3fb_sSQc,13986
+networkx/linalg/modularitymatrix.py,sha256=7hgSPeoMrkDFKOETaMgw9inYJ2T8uSlHeoIib2r3fKA,5119
+networkx/linalg/spectrum.py,sha256=Iek8aRJw_TPVGiyxVyKGCmVLCVOxb3ukvBXp6X1Lhxk,3876
+networkx/linalg/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/linalg/tests/test_algebraic_connectivity.py,sha256=I9kbAwLsGvVUt_1bAwHcp4UmqSg_peWv41j37bg5EUo,13344
+networkx/linalg/tests/test_attrmatrix.py,sha256=XD3YuPc5yXKWbhwVSI8YiV_wABWM-rLtwf1uwwWlnI0,2833
+networkx/linalg/tests/test_bethehessian.py,sha256=0r-Do902ywV10TyqTlIJ2Ls3iMqM6sSs2PZbod7kWBM,1327
+networkx/linalg/tests/test_graphmatrix.py,sha256=0cMwzfK6gX7yGCtwRpVXcUn0RWDQDH-HALM5volWA20,9090
+networkx/linalg/tests/test_laplacian.py,sha256=K8p2upJTJLfNHfAf0B9ohPXBZ4k_2VMpSvIc-jXZ_rM,9934
+networkx/linalg/tests/test_modularity.py,sha256=mfKUvwc3bj6Rud1aG4oK3Eu1qg12o6cB8-pv5ZFicYY,3115
+networkx/linalg/tests/test_spectrum.py,sha256=agP2DsiEIvtkNUkT94mdPtJjwnobnjMTUOwjIQa4giA,2828
+networkx/readwrite/__init__.py,sha256=smim3hE7gh6EUjVvCP2rypK0Lgb30y5LOWfgnl79kq4,2490
+networkx/readwrite/adjlist.py,sha256=U4Fit0feX6snGWKqfLslqcTT6EL638_YeZfxnSWTkFM,7743
+networkx/readwrite/edgelist.py,sha256=cV6lWh70mU_W5uBDl_VywZIugIJaRAu9IhoQ2Rthzjo,14079
+networkx/readwrite/gexf.py,sha256=AEtYSWVBRmsiBuF0C5G8z7YbQ0pQRIbQkK--zKj7IMY,39511
+networkx/readwrite/gml.py,sha256=T1xccYR11GzZBXsNOM-4_jYcQbOjQydxc8Z3ECppygg,30016
+networkx/readwrite/gpickle.py,sha256=hiL8LmPRtOWWwUSaPYLzxEtK_pen-GQff70SYL-XXLo,2985
+networkx/readwrite/graph6.py,sha256=3N50F0-58G4YohISmgV2G9emKDBUpfHcKhomYGYHhNE,11277
+networkx/readwrite/graphml.py,sha256=OtynmKyxpS-1V8stzwuIQrk0K3FYZci5eGbuTglRhHM,39163
+networkx/readwrite/leda.py,sha256=RSM1kW6F7HWkWliXeBTEMA_3rgXmRfX63MGM_d3DHUU,2712
+networkx/readwrite/multiline_adjlist.py,sha256=LEBRqDIUjxqeeYb-OiL64fDCPagmYVUA0uj0PMFJFcY,11201
+networkx/readwrite/nx_shp.py,sha256=RoING1m00mCFQ3w7YFgmxV_uClb8_MbXw2nba8acLB0,12183
+networkx/readwrite/nx_yaml.py,sha256=fEhgNB23RPNN_upmkPsRvZ2aUtQPC3vJegkRSrVKeS8,2174
+networkx/readwrite/p2g.py,sha256=QzjBrvkRR7_BlIM7fzzQeBBbDo0t4mHttJ1SYQg40Wg,2995
+networkx/readwrite/pajek.py,sha256=EDiFLozCQJb19g-D5EXpNBO2a1Ago2iro07Wp0xUkNE,8636
+networkx/readwrite/sparse6.py,sha256=0dGmYXB-_wPnJ_A0SHb0CvkTCoM9vw0ge4-ZjgOlCB4,10193
+networkx/readwrite/text.py,sha256=7h437jkHOxid7-DMl09Zsy1bzigTGVWLsribapfCG_I,6498
+networkx/readwrite/json_graph/__init__.py,sha256=6U_kUzFQRiTn_wtklqdxSJ1O7DLykeS6EPLIc-u0Dk4,724
+networkx/readwrite/json_graph/adjacency.py,sha256=2g2cn9OmwSihhFAJesPdhmU6yIC9Gp6x0reuhKxzjAM,4745
+networkx/readwrite/json_graph/cytoscape.py,sha256=fAT2T4c0IQvAMT9wmAw5eJMjbwJ2T_sAWoMsdLtX61A,8142
+networkx/readwrite/json_graph/jit.py,sha256=xuURaJrdy4gMgwlLIAUiezNM_OCwsalgin8og2qofVc,3082
+networkx/readwrite/json_graph/node_link.py,sha256=1bjjTqnQotI3bee5PxPl1HnhLvB-KCF5zQxcqQ77THE,6111
+networkx/readwrite/json_graph/tree.py,sha256=dXtA1N16m-at8UdZXtZwy2oI05OdmoNpHiglJCWVeuk,6750
+networkx/readwrite/json_graph/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/readwrite/json_graph/tests/test_adjacency.py,sha256=fIhI53yZlt4_8xSpCLy8-z0K132QTmiVLr49bHfKG5Y,1766
+networkx/readwrite/json_graph/tests/test_cytoscape.py,sha256=dDVWM8IYP4xJPp8Jaqv_p3Bg6TkdbM2aAEEK7GDXcRQ,2548
+networkx/readwrite/json_graph/tests/test_jit.py,sha256=_JpDVaWHwQSPsOCgPRZ7BPBvp8VtVNXOruV7uAz2w78,2068
+networkx/readwrite/json_graph/tests/test_node_link.py,sha256=YrEUySBplVAWbLfU73p4nJNYl7gq6SDkgkx0mm-0lXA,3177
+networkx/readwrite/json_graph/tests/test_tree.py,sha256=xhXn1hsh2mN5AlYpFFod4_vReWWC5n8KnpMXzq82Tpw,1887
+networkx/readwrite/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/readwrite/tests/test_adjlist.py,sha256=dLEv3txnBrHYxajOYAQhA8CA7axiuPw1ECbaHL5p338,9922
+networkx/readwrite/tests/test_edgelist.py,sha256=l_o1-VbHFMIkNwOLWDdekoprzrfMEDf-tYhIKoxTG3c,9997
+networkx/readwrite/tests/test_getattr_nxyaml_removal.py,sha256=OBwlS280q6jFsrM7DY1MFmKLqHQZSlEswH7P0aY28bE,1005
+networkx/readwrite/tests/test_gexf.py,sha256=PLphmfUB8fYGJCt3EM-rVkqXjHJaCF1GNFN7qccyrxM,18928
+networkx/readwrite/tests/test_gml.py,sha256=stS4rg6N4-YBBYNVOagxSnwL2kXFr2DX-7oQBiE4Mns,20182
+networkx/readwrite/tests/test_gpickle.py,sha256=kr_-moaOpvzk1N5VkuW-biJroHA_kCKH11Va-7Z6jT4,2143
+networkx/readwrite/tests/test_graph6.py,sha256=IjBpfTr-czBLHb8UT_JzvOTBROpnOf5TKKkfCnEeQT8,6069
+networkx/readwrite/tests/test_graphml.py,sha256=vGbgGGZEMtQa4-Cjhxv6lj1GiIjVtZYdARsisdAccQQ,67496
+networkx/readwrite/tests/test_leda.py,sha256=_5F4nLLQ1oAZQMZtTQoFncZL0Oc-IsztFBglEdQeH3k,1392
+networkx/readwrite/tests/test_p2g.py,sha256=mtO2mA_2qeV7q8tQz9jf1fuo13blIhLW0SUKb_4S7j0,1327
+networkx/readwrite/tests/test_pajek.py,sha256=XTsnaCaYjroysCHlTsYwMGGrDR0B1MRwWkA-WXbAXTg,4703
+networkx/readwrite/tests/test_shp.py,sha256=w6MnK1LlVNLTPS5d2ufVynN7B537Vfm9RWxlluLu8nM,9166
+networkx/readwrite/tests/test_sparse6.py,sha256=fLpTG0YgcptNOpUipcCcVlni5i8IyC21kkk3ZeD0XhM,5470
+networkx/readwrite/tests/test_text.py,sha256=oEKc-VO5vk3E5XkACtpybaf1xUIcdAoETDkK5LZFiPM,7933
+networkx/testing/__init__.py,sha256=7r6YEG1MsWE913m_gOxgwLaENn0d8oW58qyYDnCjlQA,75
+networkx/testing/test.py,sha256=50q8FPBi5Uks6rwzu58yIZ8XXttuDtG7TvU5h1m0WXg,934
+networkx/testing/utils.py,sha256=WsN3scG0pYJhueHG97wItgMf8htJqcQTwdNDQRI2CMM,1491
+networkx/testing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/testing/tests/test_utils.py,sha256=jDmedlD9406YVdccNmRtiM4VEHuzRGRrbiKMB6UsA6Q,4953
+networkx/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/tests/test_all_random_functions.py,sha256=V1ETv6d-3wbbrinZHGUrjWQ6WOi1G4evQCdWJB87KZQ,8643
+networkx/tests/test_convert.py,sha256=cZJhrpPscLfvDOz4zJqhcq1IUJlJil-JQbiH3__16lU,12752
+networkx/tests/test_convert_numpy.py,sha256=mL7nQ2IezZtdb99IwBQb3iUoI5vP_AjBPOAaVWYu2qY,25240
+networkx/tests/test_convert_pandas.py,sha256=rNZ8UZiZN-9TBNVtFFj2BnY4Qb8lnetvcJndBBn1Nac,12259
+networkx/tests/test_convert_scipy.py,sha256=edYqfKczdlX5HqTNZs1HS8_uhVsbQCN2lzp9IzSxWoU,10880
+networkx/tests/test_exceptions.py,sha256=XYkpPzqMepSw3MPRUJN5LcFsUsy3YT_fiRDhm0OeAeQ,927
+networkx/tests/test_import.py,sha256=Gm4ujfH9JkQtDrSjOlwXXXUuubI057wskKLCkF6Z92k,220
+networkx/tests/test_lazy_imports.py,sha256=hq-0vf78aLRkIMOviEW-nowtAfZ3A778McPZaFKmn5w,2663
+networkx/tests/test_relabel.py,sha256=XNRvVrLwRaHJSuXxBidxl5ojcFGs6l4kHwtCNtgLykI,12448
+networkx/utils/__init__.py,sha256=2FD4Wn9_6sbJFpNCB3bGVKcNvvAn7BOT-dDSH_qvLEc,272
+networkx/utils/contextmanagers.py,sha256=7WkfpRXxITV6xlm-Fo2Gc3b4DJNzMNRFIedN3Tzrnlg,1269
+networkx/utils/decorators.py,sha256=DKBd2zd6ndFbgpQzLr5OVs5QP_Ka78s8QEmMDr1gIds,46493
+networkx/utils/heaps.py,sha256=rb-eoEAgSx0t2EjUj09XgzpIQzdneZIT2p6opJw8TLI,10414
+networkx/utils/mapped_queue.py,sha256=Oj1L2DyqhGZ1TFhcHyJq5IK8ZTkvm3VNmh4F1zsYX7M,9138
+networkx/utils/misc.py,sha256=1MOrkvjftO3xuWwz0Zjftu-he7pkwXBbt__nm2ZIBFA,20390
+networkx/utils/random_sequence.py,sha256=ADFgbqUxPF6bcCQ7jJeUWoWSOI5w8zMDfMY-6yHmQW4,4240
+networkx/utils/rcm.py,sha256=Sx3iAwZvrzW-eMoQb2-ZprwmXeGFSMaNwpI6xBOEKvs,4629
+networkx/utils/union_find.py,sha256=PFEk5AyjSq8piU1E1qD4MIoaBWmeBLp1OTwkLeDTmmk,3323
+networkx/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/utils/tests/test__init.py,sha256=QE0i-lNE4pG2eYjB2mZ0uw7jPD-7TdL7Y9p73JoWQmo,363
+networkx/utils/tests/test_contextmanager.py,sha256=ewa7A464FOmm0uZD-kD4iN_9zEcQNwZJPIin0lE9u_c,310
+networkx/utils/tests/test_decorators.py,sha256=Waol9jmnOXS1FAHgE_6yK6zPUOk8zmOTVDePuknwG8E,13642
+networkx/utils/tests/test_heaps.py,sha256=qCuWMzpcMH1Gwu014CAams78o151QD5YL0mB1fz16Yw,3711
+networkx/utils/tests/test_mapped_queue.py,sha256=x4xxZR4CbaSiLyMBahgGt7eBS0BtIx6CYo3sXXM-LgM,6338
+networkx/utils/tests/test_misc.py,sha256=mJ3cXfQmRfWCO9Jn4Jqi1OEo-s5CfruvTi2ZxFFSPbM,9664
+networkx/utils/tests/test_random_sequence.py,sha256=Ou-IeCFybibZuycoin5gUQzzC-iy5yanZFmrqvdGt6Q,925
+networkx/utils/tests/test_rcm.py,sha256=UvUAkgmQMGk_Nn94TJyQsle4A5SLQFqMQWld1tiQ2lk,1421
+networkx/utils/tests/test_unionfind.py,sha256=j-DF5XyeJzq1hoeAgN5Nye2Au7EPD040t8oS4Aw2IwU,1579
+../../../share/doc/networkx-2.8.5/LICENSE.txt,sha256=qun4CfsaFZLtcun1LfEM-tj-ImuNTSg4X5DdQ0HOcRk,1763
+../../../share/doc/networkx-2.8.5/examples/README.txt,sha256=4fcFf8kOy3-lR9Mt5JabLTrR5CJU-TwR0qykp4WJaPs,185
+../../../share/doc/networkx-2.8.5/examples/3d_drawing/README.txt,sha256=s5-t1C9VR7xuGe6I6LoAHyLZypgxt6nacxqhlFV_cq0,22
+../../../share/doc/networkx-2.8.5/examples/3d_drawing/mayavi2_spring.py,sha256=m3CEGHEYxTwuWe4jObonMM7ZS62hdEBvas-SW1UCvrk,934
+../../../share/doc/networkx-2.8.5/examples/3d_drawing/plot_basic.py,sha256=PWG-R4COK5xRUpO9fzuYp7jIRkPqPINe9ThiSas1PA8,1149
+../../../share/doc/networkx-2.8.5/examples/algorithms/README.txt,sha256=xn-_KUQ8ego4sNw2nrr4axL38uzGmSgO1jiK3kC0_X4,22
+../../../share/doc/networkx-2.8.5/examples/algorithms/WormNet.v3.benchmark.txt,sha256=UvbM0_uQawr_W5rjxhICvH_W8n01FBiX8T-le19ufr8,1346746
+../../../share/doc/networkx-2.8.5/examples/algorithms/hartford_drug.edgelist,sha256=Nwzo8P1bWNq1e_JEodTLFgUCx80bpkg4PhtSd3G8aZk,2335
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_beam_search.py,sha256=SmksU_kiGquXokBB6midxx9IDFSph9SfZK9FKH4Z6O4,4119
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_betweenness_centrality.py,sha256=y4AnvUdMdUe39X-gGIGRohIHPwN4oSaf6Y2te7E5OsY,2122
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_blockmodel.py,sha256=wvdheWrt-KcX2e_zMARdPwOJHlDLKM8H8aCVkIx2gbM,2679
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_circuits.py,sha256=f56Ct7i_s5ImJ71OMAg8BPqcFYQygdEQnTzrAgl7fW8,3496
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_davis_club.py,sha256=YrUUnaWm82MEE4qoGeCfmUWmHqV7vpDBckDSmFn5T8U,1201
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_dedensification.py,sha256=BdXLYidxo-5swuseC8viiIQwNB-lqshQ6EdLU_vQsP4,2250
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_iterated_dynamical_systems.py,sha256=AXlEyF2UPtHosV8rZcmL_KjWOMOoDV-2dm7YzOT54Ro,5996
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_krackhardt_centrality.py,sha256=Ff4MdZyWKlnQ0HZuPinRrlAQlBtW_tOIeXZXn5CBY4w,637
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_parallel_betweenness.py,sha256=AVQaNwga0QPUrr3qr3g2hOupyKsf-jp08Dvw4gLz7M0,2453
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_rcm.py,sha256=nu4JylMqrESBo36J9O6dayk5cQjQ147-UISNzvK6r6E,1039
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_snap.py,sha256=02GOuZxjHHo0h8eO8ErhktIFFw4FFnOx8CVkt8uIaTI,3088
+../../../share/doc/networkx-2.8.5/examples/algorithms/plot_subgraphs.py,sha256=F-3_AjHvqZidxoJfyMIkfmZHkAEoroQrJM9GW7tJeSg,6474
+../../../share/doc/networkx-2.8.5/examples/basic/README.txt,sha256=SZoFiP7cQAXsOc0zCWRT7NsGznY1aiAk-0zD8dXsaPY,12
+../../../share/doc/networkx-2.8.5/examples/basic/plot_properties.py,sha256=NIoZX3qYpbb1R_mfgrYnldFwe1qOWYQgjfZZGhUHovk,1065
+../../../share/doc/networkx-2.8.5/examples/basic/plot_read_write.py,sha256=AN5KVYbINladQ3IEODapTqT-4hRCteonClbhUEvbUYM,525
+../../../share/doc/networkx-2.8.5/examples/basic/plot_simple_graph.py,sha256=1QGvIhSGRNJAi4lLzpE_W1q4OMzn0DpdCJpbEZgqeUw,1240
+../../../share/doc/networkx-2.8.5/examples/drawing/README.txt,sha256=DoWMcDCC_TTjREqBqc_YMatITP1_2lHp7Rv5IxrM2bA,16
+../../../share/doc/networkx-2.8.5/examples/drawing/chess_masters_WCC.pgn.bz2,sha256=2e-170bYxxtpmUW4mrs4UEnsF89vIfJWJYOk8gYYGew,100224
+../../../share/doc/networkx-2.8.5/examples/drawing/knuth_miles.txt.gz,sha256=e-sV93FBC11m7Rdn-4K_uGoPTNgt3dtkMuyvQ0ovTZU,20317
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_chess_masters.py,sha256=7OZXxlTA8TKyyis7L6yJuqZYNSmzdszmRVNln1BSgrg,4583
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_custom_node_icons.py,sha256=2y_68MamGfIQhpM3YFHSxYqMqzLl4CnhzaqKDKFs4jI,2139
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_degree.py,sha256=US7sGbPQsyVccE3URvirRAHM9t6W_QfWgmkGin2O8Bc,1556
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_directed.py,sha256=Wyzt-aq3seUJVVmiEgPEzXP7YWatFTKDHNc3LvVtwwQ,1108
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_edge_colormap.py,sha256=3cTm9jX3vh635lGtLMmjwR2FJHlxa87WVK0GoU80zxA,441
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_ego_graph.py,sha256=E_LRplVi2knRK9hDuO1z2DvIfvV3uTMp0t4G2kVuDa0,910
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_eigenvalues.py,sha256=cu1VnGCbPgotHgqMzoixOdGNKzZ0rIVn9WjKKweuRhw,544
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_four_grids.py,sha256=P6LJaQLA-9_78LVyHkxdRHlLHj6s-vL21NkOiINjsxk,1054
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_house_with_colors.py,sha256=Bs1z9SqsQ5DMV2a8X8rXU6qpSyUyqvnH-O7y5nBsOks,665
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_knuth_miles.py,sha256=2i4voltKotkkbn_jiiHYaCxAkbJEliMpkQivVL8aKw4,4111
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_labels_and_colors.py,sha256=GtcCrvzGiuyRdeN2_gCH6WCpvtUgUGU2EXqXtMVOkRE,1243
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_multipartite_graph.py,sha256=0X0-mrxVEJD51i16mc5mLTQL0z6ix82NdYQs2ha_ZWs,995
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_node_colormap.py,sha256=Lgc9GuyL9F1sBtcA5pUMnrjdIbPoO3EESyAjLn4e5xg,288
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_rainbow_coloring.py,sha256=pjlo110knte-vQhfryAIQXTlQHBgL8jQBdij9KNZApk,2172
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_random_geometric_graph.py,sha256=HVfm2eKbzs5NcV0p0DxYJmpQ0V_z2ayykrWG3F1vftM,938
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_sampson.py,sha256=FYwBC6iCL6chHnnKCRgQk1WwkL2CcEBs9oq1RWBBCgA,1228
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_selfloops.py,sha256=x-1Ma-TlydzoU7VWahWynKMFACn1OcuR_Uwzk6LaZog,753
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_simple_path.py,sha256=QA26fUWDPmJT_4s1Mo-wG9LWKTyCXPIe-0mRJYXAW5w,252
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_spectral_grid.py,sha256=JhYZQcyrsKHvJfQR_9X4pBaKS7kaM0qvGFzbunqQzq0,1592
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_tsp.py,sha256=g-0NDgIPXQANaqfS3GufbvAoiaS0Y4s6O4TWSjQk5Vc,1301
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_unix_email.py,sha256=tZJBr60SvQSYf1OcrHGi6Oxwmev_skQzUsLUwuGb8wM,1968
+../../../share/doc/networkx-2.8.5/examples/drawing/plot_weighted_graph.py,sha256=HqH3lkhg62XD6ytrhi-nhBCiB6i0tcBv30rwxcQfIqw,1124
+../../../share/doc/networkx-2.8.5/examples/drawing/unix_email.mbox,sha256=i20mxjWonqmAbgbr1qBNIG9BTb3qQt0WQ7YLfHUwu9U,1709
+../../../share/doc/networkx-2.8.5/examples/graph/README.txt,sha256=etRvcBQG30Fb6dIiQZaYHbnl1a6Tz_peks4MqXKwRhg,12
+../../../share/doc/networkx-2.8.5/examples/graph/plot_degree_sequence.py,sha256=TyzJyRmLHsaXEJ8IivYF416SggsM8lZE-zYxEdkngfo,799
+../../../share/doc/networkx-2.8.5/examples/graph/plot_erdos_renyi.py,sha256=lvwPtraq5q-vuuOyrlZFYABXfbfM47dR89S2k1h9GZ8,841
+../../../share/doc/networkx-2.8.5/examples/graph/plot_expected_degree_sequence.py,sha256=DWIyy0S3eBZksKAdk9dL9unIa1Cfw0rQiTcm8if0Qak,496
+../../../share/doc/networkx-2.8.5/examples/graph/plot_football.py,sha256=Dj0-gyMVUw80vyMIOqA5sFBzddL8t1R7BzIFoD1S1o8,1171
+../../../share/doc/networkx-2.8.5/examples/graph/plot_karate_club.py,sha256=6H2R2SRxZ6ZpCtIC7CUl0fhgdJuorZpo4NOok7ThFYk,494
+../../../share/doc/networkx-2.8.5/examples/graph/plot_morse_trie.py,sha256=w8sFNW1XaVm6Q4XBahxl2IArm3fVyUwTHQM2ZA-AjbU,2965
+../../../share/doc/networkx-2.8.5/examples/graph/plot_napoleon_russian_campaign.py,sha256=WS4ETV1ESBi8tCcPp6pe0uXvFiFht_xNx-hgK1TcTn0,2901
+../../../share/doc/networkx-2.8.5/examples/graph/plot_roget.py,sha256=jHuZLofFw7gTwxzMiNtwewnn3nh4SMeW8SvgabnSnx0,2126
+../../../share/doc/networkx-2.8.5/examples/graph/plot_words.py,sha256=Q-4VlEdCya3ik8kLgp2H4vIk5GP3hmWkH6Y9cLw0LQM,2683
+../../../share/doc/networkx-2.8.5/examples/graph/roget_dat.txt.gz,sha256=XhxtczVtfkcdZxE4P7KWs9ENRy3mvub739cXKdkgBk0,15758
+../../../share/doc/networkx-2.8.5/examples/graph/words_dat.txt.gz,sha256=nuZl5rQHvOTxrOvZjbLg0tIHXvbYGSIB5bwxuXZXcQA,33695
+../../../share/doc/networkx-2.8.5/examples/subclass/README.txt,sha256=9DLXetYO600sLeOY_fFc8Msnli8-qQrVbGB2f5gP20g,18
+../../../share/doc/networkx-2.8.5/examples/subclass/plot_antigraph.py,sha256=yImsNH9uoXJLAe8v37cDr0bR9DtjvQTESXozFEse12w,6023
+../../../share/doc/networkx-2.8.5/examples/subclass/plot_printgraph.py,sha256=-IZlxW9m8nRfqS16AAhWP5u_YGPKq005MjL0diyBcc8,2292
+networkx-2.8.5.dist-info/LICENSE.txt,sha256=qun4CfsaFZLtcun1LfEM-tj-ImuNTSg4X5DdQ0HOcRk,1763
+networkx-2.8.5.dist-info/METADATA,sha256=3ax0xIRcItYCi7YqISxtFJWZuW1p_3v_SIsDy1y2EBk,5010
+networkx-2.8.5.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+networkx-2.8.5.dist-info/top_level.txt,sha256=s3Mk-7KOlu-kD39w8Xg_KXoP5Z_MVvgB-upkyuOE4Hk,9
+networkx-2.8.5.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+networkx-2.8.5.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/WHEEL
new file mode 100644
index 0000000..becc9a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/top_level.txt
new file mode 100644
index 0000000..4d07dfe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx-2.8.5.dist-info/top_level.txt
@@ -0,0 +1 @@
+networkx
diff --git a/myenv/lib/python3.9/site-packages/networkx/__init__.py b/myenv/lib/python3.9/site-packages/networkx/__init__.py
new file mode 100644
index 0000000..165b0a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/__init__.py
@@ -0,0 +1,90 @@
+"""
+NetworkX
+========
+
+NetworkX is a Python package for the creation, manipulation, and study of the
+structure, dynamics, and functions of complex networks.
+
+See https://networkx.org for complete documentation.
+"""
+
+__version__ = "2.8.5"
+
+
+def __getattr__(name):
+    """Remove functions and provide informative error messages."""
+    if name == "nx_yaml":
+        raise ImportError(
+            "\nThe nx_yaml module has been removed from NetworkX.\n"
+            "Please use the `yaml` package directly for working with yaml data.\n"
+            "For example, a networkx.Graph `G` can be written to and loaded\n"
+            "from a yaml file with:\n\n"
+            "    import yaml\n\n"
+            "    with open('path_to_yaml_file', 'w') as fh:\n"
+            "        yaml.dump(G, fh)\n"
+            "    with open('path_to_yaml_file', 'r') as fh:\n"
+            "        G = yaml.load(fh, Loader=yaml.Loader)\n\n"
+            "Note that yaml.Loader is considered insecure - see the pyyaml\n"
+            "documentation for further details.\n\n"
+            "This message will be removed in NetworkX 3.0."
+        )
+    if name == "read_yaml":
+        raise ImportError(
+            "\nread_yaml has been removed from NetworkX, please use `yaml`\n"
+            "directly:\n\n"
+            "    import yaml\n\n"
+            "    with open('path', 'r') as fh:\n"
+            "        yaml.load(fh, Loader=yaml.Loader)\n\n"
+            "Note that yaml.Loader is considered insecure - see the pyyaml\n"
+            "documentation for further details.\n\n"
+            "This message will be removed in NetworkX 3.0."
+        )
+    if name == "write_yaml":
+        raise ImportError(
+            "\nwrite_yaml has been removed from NetworkX, please use `yaml`\n"
+            "directly:\n\n"
+            "    import yaml\n\n"
+            "    with open('path_for_yaml_output', 'w') as fh:\n"
+            "        yaml.dump(G_to_be_yaml, fh)\n\n"
+            "This message will be removed in NetworkX 3.0."
+        )
+    raise AttributeError(f"module {__name__} has no attribute {name}")
+
+
+# These are imported in order as listed
+from networkx.lazy_imports import _lazy_import
+
+from networkx.exception import *
+
+from networkx import utils
+
+from networkx import classes
+from networkx.classes import filters
+from networkx.classes import *
+
+from networkx import convert
+from networkx.convert import *
+
+from networkx import convert_matrix
+from networkx.convert_matrix import *
+
+from networkx import relabel
+from networkx.relabel import *
+
+from networkx import generators
+from networkx.generators import *
+
+from networkx import readwrite
+from networkx.readwrite import *
+
+# Need to test with SciPy, when available
+from networkx import algorithms
+from networkx.algorithms import *
+
+from networkx import linalg
+from networkx.linalg import *
+
+from networkx.testing.test import run as test
+
+from networkx import drawing
+from networkx.drawing import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/__init__.py
new file mode 100644
index 0000000..9fa60b9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/__init__.py
@@ -0,0 +1,129 @@
+from networkx.algorithms.assortativity import *
+from networkx.algorithms.asteroidal import *
+from networkx.algorithms.boundary import *
+from networkx.algorithms.bridges import *
+from networkx.algorithms.chains import *
+from networkx.algorithms.centrality import *
+from networkx.algorithms.chordal import *
+from networkx.algorithms.cluster import *
+from networkx.algorithms.clique import *
+from networkx.algorithms.communicability_alg import *
+from networkx.algorithms.components import *
+from networkx.algorithms.coloring import *
+from networkx.algorithms.core import *
+from networkx.algorithms.covering import *
+from networkx.algorithms.cycles import *
+from networkx.algorithms.cuts import *
+from networkx.algorithms.d_separation import *
+from networkx.algorithms.dag import *
+from networkx.algorithms.distance_measures import *
+from networkx.algorithms.distance_regular import *
+from networkx.algorithms.dominance import *
+from networkx.algorithms.dominating import *
+from networkx.algorithms.efficiency_measures import *
+from networkx.algorithms.euler import *
+from networkx.algorithms.graphical import *
+from networkx.algorithms.hierarchy import *
+from networkx.algorithms.hybrid import *
+from networkx.algorithms.link_analysis import *
+from networkx.algorithms.link_prediction import *
+from networkx.algorithms.lowest_common_ancestors import *
+from networkx.algorithms.isolate import *
+from networkx.algorithms.matching import *
+from networkx.algorithms.minors import *
+from networkx.algorithms.mis import *
+from networkx.algorithms.moral import *
+from networkx.algorithms.non_randomness import *
+from networkx.algorithms.operators import *
+from networkx.algorithms.planarity import *
+from networkx.algorithms.planar_drawing import *
+from networkx.algorithms.reciprocity import *
+from networkx.algorithms.regular import *
+from networkx.algorithms.richclub import *
+from networkx.algorithms.shortest_paths import *
+from networkx.algorithms.similarity import *
+from networkx.algorithms.graph_hashing import *
+from networkx.algorithms.simple_paths import *
+from networkx.algorithms.smallworld import *
+from networkx.algorithms.smetric import *
+from networkx.algorithms.structuralholes import *
+from networkx.algorithms.sparsifiers import *
+from networkx.algorithms.summarization import *
+from networkx.algorithms.swap import *
+from networkx.algorithms.traversal import *
+from networkx.algorithms.triads import *
+from networkx.algorithms.vitality import *
+from networkx.algorithms.voronoi import *
+from networkx.algorithms.wiener import *
+from networkx.algorithms.polynomials import *
+
+# Make certain subpackages available to the user as direct imports from
+# the `networkx` namespace.
+from networkx.algorithms import approximation
+from networkx.algorithms import assortativity
+from networkx.algorithms import bipartite
+from networkx.algorithms import node_classification
+from networkx.algorithms import centrality
+from networkx.algorithms import chordal
+from networkx.algorithms import cluster
+from networkx.algorithms import clique
+from networkx.algorithms import components
+from networkx.algorithms import connectivity
+from networkx.algorithms import community
+from networkx.algorithms import coloring
+from networkx.algorithms import flow
+from networkx.algorithms import isomorphism
+from networkx.algorithms import link_analysis
+from networkx.algorithms import lowest_common_ancestors
+from networkx.algorithms import operators
+from networkx.algorithms import shortest_paths
+from networkx.algorithms import tournament
+from networkx.algorithms import traversal
+from networkx.algorithms import tree
+
+# Make certain functions from some of the previous subpackages available
+# to the user as direct imports from the `networkx` namespace.
+from networkx.algorithms.bipartite import complete_bipartite_graph
+from networkx.algorithms.bipartite import is_bipartite
+from networkx.algorithms.bipartite import project
+from networkx.algorithms.bipartite import projected_graph
+from networkx.algorithms.connectivity import all_pairs_node_connectivity
+from networkx.algorithms.connectivity import all_node_cuts
+from networkx.algorithms.connectivity import average_node_connectivity
+from networkx.algorithms.connectivity import edge_connectivity
+from networkx.algorithms.connectivity import edge_disjoint_paths
+from networkx.algorithms.connectivity import k_components
+from networkx.algorithms.connectivity import k_edge_components
+from networkx.algorithms.connectivity import k_edge_subgraphs
+from networkx.algorithms.connectivity import k_edge_augmentation
+from networkx.algorithms.connectivity import is_k_edge_connected
+from networkx.algorithms.connectivity import minimum_edge_cut
+from networkx.algorithms.connectivity import minimum_node_cut
+from networkx.algorithms.connectivity import node_connectivity
+from networkx.algorithms.connectivity import node_disjoint_paths
+from networkx.algorithms.connectivity import stoer_wagner
+from networkx.algorithms.flow import capacity_scaling
+from networkx.algorithms.flow import cost_of_flow
+from networkx.algorithms.flow import gomory_hu_tree
+from networkx.algorithms.flow import max_flow_min_cost
+from networkx.algorithms.flow import maximum_flow
+from networkx.algorithms.flow import maximum_flow_value
+from networkx.algorithms.flow import min_cost_flow
+from networkx.algorithms.flow import min_cost_flow_cost
+from networkx.algorithms.flow import minimum_cut
+from networkx.algorithms.flow import minimum_cut_value
+from networkx.algorithms.flow import network_simplex
+from networkx.algorithms.isomorphism import could_be_isomorphic
+from networkx.algorithms.isomorphism import fast_could_be_isomorphic
+from networkx.algorithms.isomorphism import faster_could_be_isomorphic
+from networkx.algorithms.isomorphism import is_isomorphic
+from networkx.algorithms.tree.branchings import maximum_branching
+from networkx.algorithms.tree.branchings import maximum_spanning_arborescence
+from networkx.algorithms.tree.branchings import minimum_branching
+from networkx.algorithms.tree.branchings import minimum_spanning_arborescence
+from networkx.algorithms.tree.branchings import ArborescenceIterator
+from networkx.algorithms.tree.coding import *
+from networkx.algorithms.tree.decomposition import *
+from networkx.algorithms.tree.mst import *
+from networkx.algorithms.tree.operations import *
+from networkx.algorithms.tree.recognition import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/__init__.py
new file mode 100644
index 0000000..13fc21f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/__init__.py
@@ -0,0 +1,24 @@
+"""Approximations of graph properties and Heuristic methods for optimization.
+
+    .. warning:: These functions are not imported in the top-level of ``networkx``
+
+    These functions can be accessed using
+    ``networkx.approximation.function_name``
+
+    They can be imported using ``from networkx.algorithms import approximation``
+    or ``from networkx.algorithms.approximation import function_name``
+
+"""
+from networkx.algorithms.approximation.clustering_coefficient import *
+from networkx.algorithms.approximation.clique import *
+from networkx.algorithms.approximation.connectivity import *
+from networkx.algorithms.approximation.distance_measures import *
+from networkx.algorithms.approximation.dominating_set import *
+from networkx.algorithms.approximation.kcomponents import *
+from networkx.algorithms.approximation.matching import *
+from networkx.algorithms.approximation.ramsey import *
+from networkx.algorithms.approximation.steinertree import *
+from networkx.algorithms.approximation.traveling_salesman import *
+from networkx.algorithms.approximation.treewidth import *
+from networkx.algorithms.approximation.vertex_cover import *
+from networkx.algorithms.approximation.maxcut import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/clique.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/clique.py
new file mode 100644
index 0000000..7228636
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/clique.py
@@ -0,0 +1,233 @@
+"""Functions for computing large cliques and maximum independent sets."""
+import networkx as nx
+from networkx.algorithms.approximation import ramsey
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "clique_removal",
+    "max_clique",
+    "large_clique_size",
+    "maximum_independent_set",
+]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def maximum_independent_set(G):
+    """Returns an approximate maximum independent set.
+
+    Independent set or stable set is a set of vertices in a graph, no two of
+    which are adjacent. That is, it is a set I of vertices such that for every
+    two vertices in I, there is no edge connecting the two. Equivalently, each
+    edge in the graph has at most one endpoint in I. The size of an independent
+    set is the number of vertices it contains [1]_.
+
+    A maximum independent set is a largest independent set for a given graph G
+    and its size is denoted $\\alpha(G)$. The problem of finding such a set is called
+    the maximum independent set problem and is an NP-hard optimization problem.
+    As such, it is unlikely that there exists an efficient algorithm for finding
+    a maximum independent set of a graph.
+
+    The Independent Set algorithm is based on [2]_.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    Returns
+    -------
+    iset : Set
+        The apx-maximum independent set
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
+
+    Notes
+    -----
+    Finds the $O(|V|/(log|V|)^2)$ apx of independent set in the worst case.
+
+    References
+    ----------
+    .. [1] `Wikipedia: Independent set
+        <https://en.wikipedia.org/wiki/Independent_set_(graph_theory)>`_
+    .. [2] Boppana, R., & Halldórsson, M. M. (1992).
+       Approximating maximum independent sets by excluding subgraphs.
+       BIT Numerical Mathematics, 32(2), 180–196. Springer.
+    """
+    iset, _ = clique_removal(G)
+    return iset
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def max_clique(G):
+    r"""Find the Maximum Clique
+
+    Finds the $O(|V|/(log|V|)^2)$ apx of maximum clique/independent set
+    in the worst case.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    Returns
+    -------
+    clique : set
+        The apx-maximum clique of the graph
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
+
+    Notes
+    -----
+    A clique in an undirected graph G = (V, E) is a subset of the vertex set
+    `C \subseteq V` such that for every two vertices in C there exists an edge
+    connecting the two. This is equivalent to saying that the subgraph
+    induced by C is complete (in some cases, the term clique may also refer
+    to the subgraph).
+
+    A maximum clique is a clique of the largest possible size in a given graph.
+    The clique number `\omega(G)` of a graph G is the number of
+    vertices in a maximum clique in G. The intersection number of
+    G is the smallest number of cliques that together cover all edges of G.
+
+    https://en.wikipedia.org/wiki/Maximum_clique
+
+    References
+    ----------
+    .. [1] Boppana, R., & Halldórsson, M. M. (1992).
+        Approximating maximum independent sets by excluding subgraphs.
+        BIT Numerical Mathematics, 32(2), 180–196. Springer.
+        doi:10.1007/BF01994876
+    """
+    if G is None:
+        raise ValueError("Expected NetworkX graph!")
+
+    # finding the maximum clique in a graph is equivalent to finding
+    # the independent set in the complementary graph
+    cgraph = nx.complement(G)
+    iset, _ = clique_removal(cgraph)
+    return iset
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def clique_removal(G):
+    r"""Repeatedly remove cliques from the graph.
+
+    Results in a $O(|V|/(\log |V|)^2)$ approximation of maximum clique
+    and independent set. Returns the largest independent set found, along
+    with found maximal cliques.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    Returns
+    -------
+    max_ind_cliques : (set, list) tuple
+        2-tuple of Maximal Independent Set and list of maximal cliques (sets).
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
+
+    References
+    ----------
+    .. [1] Boppana, R., & Halldórsson, M. M. (1992).
+        Approximating maximum independent sets by excluding subgraphs.
+        BIT Numerical Mathematics, 32(2), 180–196. Springer.
+    """
+    graph = G.copy()
+    c_i, i_i = ramsey.ramsey_R2(graph)
+    cliques = [c_i]
+    isets = [i_i]
+    while graph:
+        graph.remove_nodes_from(c_i)
+        c_i, i_i = ramsey.ramsey_R2(graph)
+        if c_i:
+            cliques.append(c_i)
+        if i_i:
+            isets.append(i_i)
+    # Determine the largest independent set as measured by cardinality.
+    maxiset = max(isets, key=len)
+    return maxiset, cliques
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def large_clique_size(G):
+    """Find the size of a large clique in a graph.
+
+    A *clique* is a subset of nodes in which each pair of nodes is
+    adjacent. This function is a heuristic for finding the size of a
+    large clique in the graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    k: integer
+       The size of a large clique in the graph.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
+
+    Notes
+    -----
+    This implementation is from [1]_. Its worst case time complexity is
+    :math:`O(n d^2)`, where *n* is the number of nodes in the graph and
+    *d* is the maximum degree.
+
+    This function is a heuristic, which means it may work well in
+    practice, but there is no rigorous mathematical guarantee on the
+    ratio between the returned number and the actual largest clique size
+    in the graph.
+
+    References
+    ----------
+    .. [1] Pattabiraman, Bharath, et al.
+       "Fast Algorithms for the Maximum Clique Problem on Massive Graphs
+       with Applications to Overlapping Community Detection."
+       *Internet Mathematics* 11.4-5 (2015): 421--448.
+       <https://doi.org/10.1080/15427951.2014.986778>
+
+    See also
+    --------
+
+    :func:`networkx.algorithms.approximation.clique.max_clique`
+        A function that returns an approximate maximum clique with a
+        guarantee on the approximation ratio.
+
+    :mod:`networkx.algorithms.clique`
+        Functions for finding the exact maximum clique in a graph.
+
+    """
+    degrees = G.degree
+
+    def _clique_heuristic(G, U, size, best_size):
+        if not U:
+            return max(best_size, size)
+        u = max(U, key=degrees)
+        U.remove(u)
+        N_prime = {v for v in G[u] if degrees[v] >= best_size}
+        return _clique_heuristic(G, U & N_prime, size + 1, best_size)
+
+    best_size = 0
+    nodes = (u for u in G if degrees[u] >= best_size)
+    for u in nodes:
+        neighbors = {v for v in G[u] if degrees[v] >= best_size}
+        best_size = _clique_heuristic(G, neighbors, 1, best_size)
+    return best_size
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/clustering_coefficient.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/clustering_coefficient.py
new file mode 100644
index 0000000..d37a754
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/clustering_coefficient.py
@@ -0,0 +1,64 @@
+from networkx.utils import not_implemented_for, py_random_state
+
+__all__ = ["average_clustering"]
+
+
+@py_random_state(2)
+@not_implemented_for("directed")
+def average_clustering(G, trials=1000, seed=None):
+    r"""Estimates the average clustering coefficient of G.
+
+    The local clustering of each node in `G` is the fraction of triangles
+    that actually exist over all possible triangles in its neighborhood.
+    The average clustering coefficient of a graph `G` is the mean of
+    local clusterings.
+
+    This function finds an approximate average clustering coefficient
+    for G by repeating `n` times (defined in `trials`) the following
+    experiment: choose a node at random, choose two of its neighbors
+    at random, and check if they are connected. The approximate
+    coefficient is the fraction of triangles found over the number
+    of trials [1]_.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    trials : integer
+        Number of trials to perform (default 1000).
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    c : float
+        Approximated average clustering coefficient.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import approximation
+    >>> G = nx.erdos_renyi_graph(10, 0.2, seed=10)
+    >>> approximation.average_clustering(G, trials=1000, seed=10)
+    0.214
+
+    References
+    ----------
+    .. [1] Schank, Thomas, and Dorothea Wagner. Approximating clustering
+       coefficient and transitivity. Universität Karlsruhe, Fakultät für
+       Informatik, 2004.
+       https://doi.org/10.5445/IR/1000001239
+
+    """
+    n = len(G)
+    triangles = 0
+    nodes = list(G)
+    for i in [int(seed.random() * n) for i in range(trials)]:
+        nbrs = list(G[nodes[i]])
+        if len(nbrs) < 2:
+            continue
+        u, v = seed.sample(nbrs, 2)
+        if u in G[v]:
+            triangles += 1
+    return triangles / trials
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/connectivity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/connectivity.py
new file mode 100644
index 0000000..0634751
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/connectivity.py
@@ -0,0 +1,401 @@
+""" Fast approximation for node connectivity
+"""
+import itertools
+from operator import itemgetter
+
+import networkx as nx
+
+__all__ = [
+    "local_node_connectivity",
+    "node_connectivity",
+    "all_pairs_node_connectivity",
+]
+
+
+def local_node_connectivity(G, source, target, cutoff=None):
+    """Compute node connectivity between source and target.
+
+    Pairwise or local node connectivity between two distinct and nonadjacent
+    nodes is the minimum number of nodes that must be removed (minimum
+    separating cutset) to disconnect them. By Menger's theorem, this is equal
+    to the number of node independent paths (paths that share no nodes other
+    than source and target). Which is what we compute in this function.
+
+    This algorithm is a fast approximation that gives an strict lower
+    bound on the actual number of node independent paths between two nodes [1]_.
+    It works for both directed and undirected graphs.
+
+    Parameters
+    ----------
+
+    G : NetworkX graph
+
+    source : node
+        Starting node for node connectivity
+
+    target : node
+        Ending node for node connectivity
+
+    cutoff : integer
+        Maximum node connectivity to consider. If None, the minimum degree
+        of source or target is used as a cutoff. Default value None.
+
+    Returns
+    -------
+    k: integer
+       pairwise node connectivity
+
+    Examples
+    --------
+    >>> # Platonic octahedral graph has node connectivity 4
+    >>> # for each non adjacent node pair
+    >>> from networkx.algorithms import approximation as approx
+    >>> G = nx.octahedral_graph()
+    >>> approx.local_node_connectivity(G, 0, 5)
+    4
+
+    Notes
+    -----
+    This algorithm [1]_ finds node independents paths between two nodes by
+    computing their shortest path using BFS, marking the nodes of the path
+    found as 'used' and then searching other shortest paths excluding the
+    nodes marked as used until no more paths exist. It is not exact because
+    a shortest path could use nodes that, if the path were longer, may belong
+    to two different node independent paths. Thus it only guarantees an
+    strict lower bound on node connectivity.
+
+    Note that the authors propose a further refinement, losing accuracy and
+    gaining speed, which is not implemented yet.
+
+    See also
+    --------
+    all_pairs_node_connectivity
+    node_connectivity
+
+    References
+    ----------
+    .. [1] White, Douglas R., and Mark Newman. 2001 A Fast Algorithm for
+        Node-Independent Paths. Santa Fe Institute Working Paper #01-07-035
+        http://eclectic.ss.uci.edu/~drwhite/working.pdf
+
+    """
+    if target == source:
+        raise nx.NetworkXError("source and target have to be different nodes.")
+
+    # Maximum possible node independent paths
+    if G.is_directed():
+        possible = min(G.out_degree(source), G.in_degree(target))
+    else:
+        possible = min(G.degree(source), G.degree(target))
+
+    K = 0
+    if not possible:
+        return K
+
+    if cutoff is None:
+        cutoff = float("inf")
+
+    exclude = set()
+    for i in range(min(possible, cutoff)):
+        try:
+            path = _bidirectional_shortest_path(G, source, target, exclude)
+            exclude.update(set(path))
+            K += 1
+        except nx.NetworkXNoPath:
+            break
+
+    return K
+
+
+def node_connectivity(G, s=None, t=None):
+    r"""Returns an approximation for node connectivity for a graph or digraph G.
+
+    Node connectivity is equal to the minimum number of nodes that
+    must be removed to disconnect G or render it trivial. By Menger's theorem,
+    this is equal to the number of node independent paths (paths that
+    share no nodes other than source and target).
+
+    If source and target nodes are provided, this function returns the
+    local node connectivity: the minimum number of nodes that must be
+    removed to break all paths from source to target in G.
+
+    This algorithm is based on a fast approximation that gives an strict lower
+    bound on the actual number of node independent paths between two nodes [1]_.
+    It works for both directed and undirected graphs.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    s : node
+        Source node. Optional. Default value: None.
+
+    t : node
+        Target node. Optional. Default value: None.
+
+    Returns
+    -------
+    K : integer
+        Node connectivity of G, or local node connectivity if source
+        and target are provided.
+
+    Examples
+    --------
+    >>> # Platonic octahedral graph is 4-node-connected
+    >>> from networkx.algorithms import approximation as approx
+    >>> G = nx.octahedral_graph()
+    >>> approx.node_connectivity(G)
+    4
+
+    Notes
+    -----
+    This algorithm [1]_ finds node independents paths between two nodes by
+    computing their shortest path using BFS, marking the nodes of the path
+    found as 'used' and then searching other shortest paths excluding the
+    nodes marked as used until no more paths exist. It is not exact because
+    a shortest path could use nodes that, if the path were longer, may belong
+    to two different node independent paths. Thus it only guarantees an
+    strict lower bound on node connectivity.
+
+    See also
+    --------
+    all_pairs_node_connectivity
+    local_node_connectivity
+
+    References
+    ----------
+    .. [1] White, Douglas R., and Mark Newman. 2001 A Fast Algorithm for
+        Node-Independent Paths. Santa Fe Institute Working Paper #01-07-035
+        http://eclectic.ss.uci.edu/~drwhite/working.pdf
+
+    """
+    if (s is not None and t is None) or (s is None and t is not None):
+        raise nx.NetworkXError("Both source and target must be specified.")
+
+    # Local node connectivity
+    if s is not None and t is not None:
+        if s not in G:
+            raise nx.NetworkXError(f"node {s} not in graph")
+        if t not in G:
+            raise nx.NetworkXError(f"node {t} not in graph")
+        return local_node_connectivity(G, s, t)
+
+    # Global node connectivity
+    if G.is_directed():
+        connected_func = nx.is_weakly_connected
+        iter_func = itertools.permutations
+
+        def neighbors(v):
+            return itertools.chain(G.predecessors(v), G.successors(v))
+
+    else:
+        connected_func = nx.is_connected
+        iter_func = itertools.combinations
+        neighbors = G.neighbors
+
+    if not connected_func(G):
+        return 0
+
+    # Choose a node with minimum degree
+    v, minimum_degree = min(G.degree(), key=itemgetter(1))
+    # Node connectivity is bounded by minimum degree
+    K = minimum_degree
+    # compute local node connectivity with all non-neighbors nodes
+    # and store the minimum
+    for w in set(G) - set(neighbors(v)) - {v}:
+        K = min(K, local_node_connectivity(G, v, w, cutoff=K))
+    # Same for non adjacent pairs of neighbors of v
+    for x, y in iter_func(neighbors(v), 2):
+        if y not in G[x] and x != y:
+            K = min(K, local_node_connectivity(G, x, y, cutoff=K))
+    return K
+
+
+def all_pairs_node_connectivity(G, nbunch=None, cutoff=None):
+    """Compute node connectivity between all pairs of nodes.
+
+    Pairwise or local node connectivity between two distinct and nonadjacent
+    nodes is the minimum number of nodes that must be removed (minimum
+    separating cutset) to disconnect them. By Menger's theorem, this is equal
+    to the number of node independent paths (paths that share no nodes other
+    than source and target). Which is what we compute in this function.
+
+    This algorithm is a fast approximation that gives an strict lower
+    bound on the actual number of node independent paths between two nodes [1]_.
+    It works for both directed and undirected graphs.
+
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    nbunch: container
+        Container of nodes. If provided node connectivity will be computed
+        only over pairs of nodes in nbunch.
+
+    cutoff : integer
+        Maximum node connectivity to consider. If None, the minimum degree
+        of source or target is used as a cutoff in each pair of nodes.
+        Default value None.
+
+    Returns
+    -------
+    K : dictionary
+        Dictionary, keyed by source and target, of pairwise node connectivity
+
+    See Also
+    --------
+    local_node_connectivity
+    node_connectivity
+
+    References
+    ----------
+    .. [1] White, Douglas R., and Mark Newman. 2001 A Fast Algorithm for
+        Node-Independent Paths. Santa Fe Institute Working Paper #01-07-035
+        http://eclectic.ss.uci.edu/~drwhite/working.pdf
+    """
+    if nbunch is None:
+        nbunch = G
+    else:
+        nbunch = set(nbunch)
+
+    directed = G.is_directed()
+    if directed:
+        iter_func = itertools.permutations
+    else:
+        iter_func = itertools.combinations
+
+    all_pairs = {n: {} for n in nbunch}
+
+    for u, v in iter_func(nbunch, 2):
+        k = local_node_connectivity(G, u, v, cutoff=cutoff)
+        all_pairs[u][v] = k
+        if not directed:
+            all_pairs[v][u] = k
+
+    return all_pairs
+
+
+def _bidirectional_shortest_path(G, source, target, exclude):
+    """Returns shortest path between source and target ignoring nodes in the
+    container 'exclude'.
+
+    Parameters
+    ----------
+
+    G : NetworkX graph
+
+    source : node
+        Starting node for path
+
+    target : node
+        Ending node for path
+
+    exclude: container
+        Container for nodes to exclude from the search for shortest paths
+
+    Returns
+    -------
+    path: list
+        Shortest path between source and target ignoring nodes in 'exclude'
+
+    Raises
+    ------
+    NetworkXNoPath
+        If there is no path or if nodes are adjacent and have only one path
+        between them
+
+    Notes
+    -----
+    This function and its helper are originally from
+    networkx.algorithms.shortest_paths.unweighted and are modified to
+    accept the extra parameter 'exclude', which is a container for nodes
+    already used in other paths that should be ignored.
+
+    References
+    ----------
+    .. [1] White, Douglas R., and Mark Newman. 2001 A Fast Algorithm for
+        Node-Independent Paths. Santa Fe Institute Working Paper #01-07-035
+        http://eclectic.ss.uci.edu/~drwhite/working.pdf
+
+    """
+    # call helper to do the real work
+    results = _bidirectional_pred_succ(G, source, target, exclude)
+    pred, succ, w = results
+
+    # build path from pred+w+succ
+    path = []
+    # from source to w
+    while w is not None:
+        path.append(w)
+        w = pred[w]
+    path.reverse()
+    # from w to target
+    w = succ[path[-1]]
+    while w is not None:
+        path.append(w)
+        w = succ[w]
+
+    return path
+
+
+def _bidirectional_pred_succ(G, source, target, exclude):
+    # does BFS from both source and target and meets in the middle
+    # excludes nodes in the container "exclude" from the search
+    if source is None or target is None:
+        raise nx.NetworkXException(
+            "Bidirectional shortest path called without source or target"
+        )
+    if target == source:
+        return ({target: None}, {source: None}, source)
+
+    # handle either directed or undirected
+    if G.is_directed():
+        Gpred = G.predecessors
+        Gsucc = G.successors
+    else:
+        Gpred = G.neighbors
+        Gsucc = G.neighbors
+
+    # predecesssor and successors in search
+    pred = {source: None}
+    succ = {target: None}
+
+    # initialize fringes, start with forward
+    forward_fringe = [source]
+    reverse_fringe = [target]
+
+    level = 0
+
+    while forward_fringe and reverse_fringe:
+        # Make sure that we iterate one step forward and one step backwards
+        # thus source and target will only trigger "found path" when they are
+        # adjacent and then they can be safely included in the container 'exclude'
+        level += 1
+        if not level % 2 == 0:
+            this_level = forward_fringe
+            forward_fringe = []
+            for v in this_level:
+                for w in Gsucc(v):
+                    if w in exclude:
+                        continue
+                    if w not in pred:
+                        forward_fringe.append(w)
+                        pred[w] = v
+                    if w in succ:
+                        return pred, succ, w  # found path
+        else:
+            this_level = reverse_fringe
+            reverse_fringe = []
+            for v in this_level:
+                for w in Gpred(v):
+                    if w in exclude:
+                        continue
+                    if w not in succ:
+                        succ[w] = v
+                        reverse_fringe.append(w)
+                    if w in pred:
+                        return pred, succ, w  # found path
+
+    raise nx.NetworkXNoPath(f"No path between {source} and {target}.")
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/distance_measures.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/distance_measures.py
new file mode 100644
index 0000000..c5666b2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/distance_measures.py
@@ -0,0 +1,140 @@
+"""Distance measures approximated metrics."""
+
+import networkx as nx
+from networkx.utils.decorators import py_random_state
+
+__all__ = ["diameter"]
+
+
+@py_random_state(1)
+def diameter(G, seed=None):
+    """Returns a lower bound on the diameter of the graph G.
+
+    The function computes a lower bound on the diameter (i.e., the maximum eccentricity)
+    of a directed or undirected graph G. The procedure used varies depending on the graph
+    being directed or not.
+
+    If G is an `undirected` graph, then the function uses the `2-sweep` algorithm [1]_.
+    The main idea is to pick the farthest node from a random node and return its eccentricity.
+
+    Otherwise, if G is a `directed` graph, the function uses the `2-dSweep` algorithm [2]_,
+    The procedure starts by selecting a random source node $s$ from which it performs a
+    forward and a backward BFS. Let $a_1$ and $a_2$ be the farthest nodes in the forward and
+    backward cases, respectively. Then, it computes the backward eccentricity of $a_1$ using
+    a backward BFS and the forward eccentricity of $a_2$ using a forward BFS.
+    Finally, it returns the best lower bound between the two.
+
+    In both cases, the time complexity is linear with respect to the size of G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    d : integer
+       Lower Bound on the Diameter of G
+
+    Raises
+    ------
+    NetworkXError
+        If the graph is empty or
+        If the graph is undirected and not connected or
+        If the graph is directed and not strongly connected.
+
+    See Also
+    --------
+    networkx.algorithms.distance_measures.diameter
+
+    References
+    ----------
+    .. [1] Magnien, Clémence, Matthieu Latapy, and Michel Habib.
+       *Fast computation of empirically tight bounds for the diameter of massive graphs.*
+       Journal of Experimental Algorithmics (JEA), 2009.
+       https://arxiv.org/pdf/0904.2728.pdf
+    .. [2] Crescenzi, Pierluigi, Roberto Grossi, Leonardo Lanzi, and Andrea Marino.
+       *On computing the diameter of real-world directed (weighted) graphs.*
+       International Symposium on Experimental Algorithms. Springer, Berlin, Heidelberg, 2012.
+       https://courses.cs.ut.ee/MTAT.03.238/2014_fall/uploads/Main/diameter.pdf
+    """
+    # if G is empty
+    if not G:
+        raise nx.NetworkXError("Expected non-empty NetworkX graph!")
+    # if there's only a node
+    if G.number_of_nodes() == 1:
+        return 0
+    # if G is directed
+    if G.is_directed():
+        return _two_sweep_directed(G, seed)
+    # else if G is undirected
+    return _two_sweep_undirected(G, seed)
+
+
+def _two_sweep_undirected(G, seed):
+    """Helper function for finding a lower bound on the diameter
+        for undirected Graphs.
+
+        The idea is to pick the farthest node from a random node
+        and return its eccentricity.
+
+        ``G`` is a NetworkX undirected graph.
+
+    .. note::
+
+        ``seed`` is a random.Random or numpy.random.RandomState instance
+    """
+    # select a random source node
+    source = seed.choice(list(G))
+    # get the distances to the other nodes
+    distances = nx.shortest_path_length(G, source)
+    # if some nodes have not been visited, then the graph is not connected
+    if len(distances) != len(G):
+        raise nx.NetworkXError("Graph not connected.")
+    # take a node that is (one of) the farthest nodes from the source
+    *_, node = distances
+    # return the eccentricity of the node
+    return nx.eccentricity(G, node)
+
+
+def _two_sweep_directed(G, seed):
+    """Helper function for finding a lower bound on the diameter
+        for directed Graphs.
+
+        It implements 2-dSweep, the directed version of the 2-sweep algorithm.
+        The algorithm follows the following steps.
+        1. Select a source node $s$ at random.
+        2. Perform a forward BFS from $s$ to select a node $a_1$ at the maximum
+        distance from the source, and compute $LB_1$, the backward eccentricity of $a_1$.
+        3. Perform a backward BFS from $s$ to select a node $a_2$ at the maximum
+        distance from the source, and compute $LB_2$, the forward eccentricity of $a_2$.
+        4. Return the maximum between $LB_1$ and $LB_2$.
+
+        ``G`` is a NetworkX directed graph.
+
+    .. note::
+
+        ``seed`` is a random.Random or numpy.random.RandomState instance
+    """
+    # get a new digraph G' with the edges reversed in the opposite direction
+    G_reversed = G.reverse()
+    # select a random source node
+    source = seed.choice(list(G))
+    # compute forward distances from source
+    forward_distances = nx.shortest_path_length(G, source)
+    # compute backward distances  from source
+    backward_distances = nx.shortest_path_length(G_reversed, source)
+    # if either the source can't reach every node or not every node
+    # can reach the source, then the graph is not strongly connected
+    n = len(G)
+    if len(forward_distances) != n or len(backward_distances) != n:
+        raise nx.NetworkXError("DiGraph not strongly connected.")
+    # take a node a_1 at the maximum distance from the source in G
+    *_, a_1 = forward_distances
+    # take a node a_2 at the maximum distance from the source in G_reversed
+    *_, a_2 = backward_distances
+    # return the max between the backward eccentricity of a_1 and the forward eccentricity of a_2
+    return max(nx.eccentricity(G_reversed, a_1), nx.eccentricity(G, a_2))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/dominating_set.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/dominating_set.py
new file mode 100644
index 0000000..7685323
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/dominating_set.py
@@ -0,0 +1,123 @@
+"""Functions for finding node and edge dominating sets.
+
+A `dominating set`_ for an undirected graph *G* with vertex set *V*
+and edge set *E* is a subset *D* of *V* such that every vertex not in
+*D* is adjacent to at least one member of *D*. An `edge dominating set`_
+is a subset *F* of *E* such that every edge not in *F* is
+incident to an endpoint of at least one edge in *F*.
+
+.. _dominating set: https://en.wikipedia.org/wiki/Dominating_set
+.. _edge dominating set: https://en.wikipedia.org/wiki/Edge_dominating_set
+
+"""
+
+from ...utils import not_implemented_for
+from ..matching import maximal_matching
+
+__all__ = ["min_weighted_dominating_set", "min_edge_dominating_set"]
+
+
+# TODO Why doesn't this algorithm work for directed graphs?
+@not_implemented_for("directed")
+def min_weighted_dominating_set(G, weight=None):
+    r"""Returns a dominating set that approximates the minimum weight node
+    dominating set.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph.
+
+    weight : string
+        The node attribute storing the weight of an node. If provided,
+        the node attribute with this key must be a number for each
+        node. If not provided, each node is assumed to have weight one.
+
+    Returns
+    -------
+    min_weight_dominating_set : set
+        A set of nodes, the sum of whose weights is no more than `(\log
+        w(V)) w(V^*)`, where `w(V)` denotes the sum of the weights of
+        each node in the graph and `w(V^*)` denotes the sum of the
+        weights of each node in the minimum weight dominating set.
+
+    Notes
+    -----
+    This algorithm computes an approximate minimum weighted dominating
+    set for the graph `G`. The returned solution has weight `(\log
+    w(V)) w(V^*)`, where `w(V)` denotes the sum of the weights of each
+    node in the graph and `w(V^*)` denotes the sum of the weights of
+    each node in the minimum weight dominating set for the graph.
+
+    This implementation of the algorithm runs in $O(m)$ time, where $m$
+    is the number of edges in the graph.
+
+    References
+    ----------
+    .. [1] Vazirani, Vijay V.
+           *Approximation Algorithms*.
+           Springer Science & Business Media, 2001.
+
+    """
+    # The unique dominating set for the null graph is the empty set.
+    if len(G) == 0:
+        return set()
+
+    # This is the dominating set that will eventually be returned.
+    dom_set = set()
+
+    def _cost(node_and_neighborhood):
+        """Returns the cost-effectiveness of greedily choosing the given
+        node.
+
+        `node_and_neighborhood` is a two-tuple comprising a node and its
+        closed neighborhood.
+
+        """
+        v, neighborhood = node_and_neighborhood
+        return G.nodes[v].get(weight, 1) / len(neighborhood - dom_set)
+
+    # This is a set of all vertices not already covered by the
+    # dominating set.
+    vertices = set(G)
+    # This is a dictionary mapping each node to the closed neighborhood
+    # of that node.
+    neighborhoods = {v: {v} | set(G[v]) for v in G}
+
+    # Continue until all vertices are adjacent to some node in the
+    # dominating set.
+    while vertices:
+        # Find the most cost-effective node to add, along with its
+        # closed neighborhood.
+        dom_node, min_set = min(neighborhoods.items(), key=_cost)
+        # Add the node to the dominating set and reduce the remaining
+        # set of nodes to cover.
+        dom_set.add(dom_node)
+        del neighborhoods[dom_node]
+        vertices -= min_set
+
+    return dom_set
+
+
+def min_edge_dominating_set(G):
+    r"""Returns minimum cardinality edge dominating set.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+      Undirected graph
+
+    Returns
+    -------
+    min_edge_dominating_set : set
+      Returns a set of dominating edges whose size is no more than 2 * OPT.
+
+    Notes
+    -----
+    The algorithm computes an approximate solution to the edge dominating set
+    problem. The result is no more than 2 * OPT in terms of size of the set.
+    Runtime of the algorithm is $O(|E|)$.
+    """
+    if not G:
+        raise ValueError("Expected non-empty NetworkX graph!")
+    return maximal_matching(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/kcomponents.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/kcomponents.py
new file mode 100644
index 0000000..239cc0f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/kcomponents.py
@@ -0,0 +1,368 @@
+""" Fast approximation for k-component structure
+"""
+import itertools
+from collections import defaultdict
+from collections.abc import Mapping
+from functools import cached_property
+
+import networkx as nx
+from networkx.algorithms.approximation import local_node_connectivity
+from networkx.exception import NetworkXError
+from networkx.utils import not_implemented_for
+
+__all__ = ["k_components"]
+
+
+@not_implemented_for("directed")
+def k_components(G, min_density=0.95):
+    r"""Returns the approximate k-component structure of a graph G.
+
+    A `k`-component is a maximal subgraph of a graph G that has, at least,
+    node connectivity `k`: we need to remove at least `k` nodes to break it
+    into more components. `k`-components have an inherent hierarchical
+    structure because they are nested in terms of connectivity: a connected
+    graph can contain several 2-components, each of which can contain
+    one or more 3-components, and so forth.
+
+    This implementation is based on the fast heuristics to approximate
+    the `k`-component structure of a graph [1]_. Which, in turn, it is based on
+    a fast approximation algorithm for finding good lower bounds of the number
+    of node independent paths between two nodes [2]_.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    min_density : Float
+        Density relaxation threshold. Default value 0.95
+
+    Returns
+    -------
+    k_components : dict
+        Dictionary with connectivity level `k` as key and a list of
+        sets of nodes that form a k-component of level `k` as values.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is directed.
+
+    Examples
+    --------
+    >>> # Petersen graph has 10 nodes and it is triconnected, thus all
+    >>> # nodes are in a single component on all three connectivity levels
+    >>> from networkx.algorithms import approximation as apxa
+    >>> G = nx.petersen_graph()
+    >>> k_components = apxa.k_components(G)
+
+    Notes
+    -----
+    The logic of the approximation algorithm for computing the `k`-component
+    structure [1]_ is based on repeatedly applying simple and fast algorithms
+    for `k`-cores and biconnected components in order to narrow down the
+    number of pairs of nodes over which we have to compute White and Newman's
+    approximation algorithm for finding node independent paths [2]_. More
+    formally, this algorithm is based on Whitney's theorem, which states
+    an inclusion relation among node connectivity, edge connectivity, and
+    minimum degree for any graph G. This theorem implies that every
+    `k`-component is nested inside a `k`-edge-component, which in turn,
+    is contained in a `k`-core. Thus, this algorithm computes node independent
+    paths among pairs of nodes in each biconnected part of each `k`-core,
+    and repeats this procedure for each `k` from 3 to the maximal core number
+    of a node in the input graph.
+
+    Because, in practice, many nodes of the core of level `k` inside a
+    bicomponent actually are part of a component of level k, the auxiliary
+    graph needed for the algorithm is likely to be very dense. Thus, we use
+    a complement graph data structure (see `AntiGraph`) to save memory.
+    AntiGraph only stores information of the edges that are *not* present
+    in the actual auxiliary graph. When applying algorithms to this
+    complement graph data structure, it behaves as if it were the dense
+    version.
+
+    See also
+    --------
+    k_components
+
+    References
+    ----------
+    .. [1]  Torrents, J. and F. Ferraro (2015) Structural Cohesion:
+            Visualization and Heuristics for Fast Computation.
+            https://arxiv.org/pdf/1503.04476v1
+
+    .. [2]  White, Douglas R., and Mark Newman (2001) A Fast Algorithm for
+            Node-Independent Paths. Santa Fe Institute Working Paper #01-07-035
+            https://www.santafe.edu/research/results/working-papers/fast-approximation-algorithms-for-finding-node-ind
+
+    .. [3]  Moody, J. and D. White (2003). Social cohesion and embeddedness:
+            A hierarchical conception of social groups.
+            American Sociological Review 68(1), 103--28.
+            https://doi.org/10.2307/3088904
+
+    """
+    # Dictionary with connectivity level (k) as keys and a list of
+    # sets of nodes that form a k-component as values
+    k_components = defaultdict(list)
+    # make a few functions local for speed
+    node_connectivity = local_node_connectivity
+    k_core = nx.k_core
+    core_number = nx.core_number
+    biconnected_components = nx.biconnected_components
+    combinations = itertools.combinations
+    # Exact solution for k = {1,2}
+    # There is a linear time algorithm for triconnectivity, if we had an
+    # implementation available we could start from k = 4.
+    for component in nx.connected_components(G):
+        # isolated nodes have connectivity 0
+        comp = set(component)
+        if len(comp) > 1:
+            k_components[1].append(comp)
+    for bicomponent in nx.biconnected_components(G):
+        # avoid considering dyads as bicomponents
+        bicomp = set(bicomponent)
+        if len(bicomp) > 2:
+            k_components[2].append(bicomp)
+    # There is no k-component of k > maximum core number
+    # \kappa(G) <= \lambda(G) <= \delta(G)
+    g_cnumber = core_number(G)
+    max_core = max(g_cnumber.values())
+    for k in range(3, max_core + 1):
+        C = k_core(G, k, core_number=g_cnumber)
+        for nodes in biconnected_components(C):
+            # Build a subgraph SG induced by the nodes that are part of
+            # each biconnected component of the k-core subgraph C.
+            if len(nodes) < k:
+                continue
+            SG = G.subgraph(nodes)
+            # Build auxiliary graph
+            H = _AntiGraph()
+            H.add_nodes_from(SG.nodes())
+            for u, v in combinations(SG, 2):
+                K = node_connectivity(SG, u, v, cutoff=k)
+                if k > K:
+                    H.add_edge(u, v)
+            for h_nodes in biconnected_components(H):
+                if len(h_nodes) <= k:
+                    continue
+                SH = H.subgraph(h_nodes)
+                for Gc in _cliques_heuristic(SG, SH, k, min_density):
+                    for k_nodes in biconnected_components(Gc):
+                        Gk = nx.k_core(SG.subgraph(k_nodes), k)
+                        if len(Gk) <= k:
+                            continue
+                        k_components[k].append(set(Gk))
+    return k_components
+
+
+def _cliques_heuristic(G, H, k, min_density):
+    h_cnumber = nx.core_number(H)
+    for i, c_value in enumerate(sorted(set(h_cnumber.values()), reverse=True)):
+        cands = {n for n, c in h_cnumber.items() if c == c_value}
+        # Skip checking for overlap for the highest core value
+        if i == 0:
+            overlap = False
+        else:
+            overlap = set.intersection(
+                *[{x for x in H[n] if x not in cands} for n in cands]
+            )
+        if overlap and len(overlap) < k:
+            SH = H.subgraph(cands | overlap)
+        else:
+            SH = H.subgraph(cands)
+        sh_cnumber = nx.core_number(SH)
+        SG = nx.k_core(G.subgraph(SH), k)
+        while not (_same(sh_cnumber) and nx.density(SH) >= min_density):
+            # This subgraph must be writable => .copy()
+            SH = H.subgraph(SG).copy()
+            if len(SH) <= k:
+                break
+            sh_cnumber = nx.core_number(SH)
+            sh_deg = dict(SH.degree())
+            min_deg = min(sh_deg.values())
+            SH.remove_nodes_from(n for n, d in sh_deg.items() if d == min_deg)
+            SG = nx.k_core(G.subgraph(SH), k)
+        else:
+            yield SG
+
+
+def _same(measure, tol=0):
+    vals = set(measure.values())
+    if (max(vals) - min(vals)) <= tol:
+        return True
+    return False
+
+
+class _AntiGraph(nx.Graph):
+    """
+    Class for complement graphs.
+
+    The main goal is to be able to work with big and dense graphs with
+    a low memory footprint.
+
+    In this class you add the edges that *do not exist* in the dense graph,
+    the report methods of the class return the neighbors, the edges and
+    the degree as if it was the dense graph. Thus it's possible to use
+    an instance of this class with some of NetworkX functions. In this
+    case we only use k-core, connected_components, and biconnected_components.
+    """
+
+    all_edge_dict = {"weight": 1}
+
+    def single_edge_dict(self):
+        return self.all_edge_dict
+
+    edge_attr_dict_factory = single_edge_dict  # type: ignore
+
+    def __getitem__(self, n):
+        """Returns a dict of neighbors of node n in the dense graph.
+
+        Parameters
+        ----------
+        n : node
+           A node in the graph.
+
+        Returns
+        -------
+        adj_dict : dictionary
+           The adjacency dictionary for nodes connected to n.
+
+        """
+        all_edge_dict = self.all_edge_dict
+        return {
+            node: all_edge_dict for node in set(self._adj) - set(self._adj[n]) - {n}
+        }
+
+    def neighbors(self, n):
+        """Returns an iterator over all neighbors of node n in the
+        dense graph.
+        """
+        try:
+            return iter(set(self._adj) - set(self._adj[n]) - {n})
+        except KeyError as err:
+            raise NetworkXError(f"The node {n} is not in the graph.") from err
+
+    class AntiAtlasView(Mapping):
+        """An adjacency inner dict for AntiGraph"""
+
+        def __init__(self, graph, node):
+            self._graph = graph
+            self._atlas = graph._adj[node]
+            self._node = node
+
+        def __len__(self):
+            return len(self._graph) - len(self._atlas) - 1
+
+        def __iter__(self):
+            return (n for n in self._graph if n not in self._atlas and n != self._node)
+
+        def __getitem__(self, nbr):
+            nbrs = set(self._graph._adj) - set(self._atlas) - {self._node}
+            if nbr in nbrs:
+                return self._graph.all_edge_dict
+            raise KeyError(nbr)
+
+    class AntiAdjacencyView(AntiAtlasView):
+        """An adjacency outer dict for AntiGraph"""
+
+        def __init__(self, graph):
+            self._graph = graph
+            self._atlas = graph._adj
+
+        def __len__(self):
+            return len(self._atlas)
+
+        def __iter__(self):
+            return iter(self._graph)
+
+        def __getitem__(self, node):
+            if node not in self._graph:
+                raise KeyError(node)
+            return self._graph.AntiAtlasView(self._graph, node)
+
+    @cached_property
+    def adj(self):
+        return self.AntiAdjacencyView(self)
+
+    def subgraph(self, nodes):
+        """This subgraph method returns a full AntiGraph. Not a View"""
+        nodes = set(nodes)
+        G = _AntiGraph()
+        G.add_nodes_from(nodes)
+        for n in G:
+            Gnbrs = G.adjlist_inner_dict_factory()
+            G._adj[n] = Gnbrs
+            for nbr, d in self._adj[n].items():
+                if nbr in G._adj:
+                    Gnbrs[nbr] = d
+                    G._adj[nbr][n] = d
+        G.graph = self.graph
+        return G
+
+    class AntiDegreeView(nx.reportviews.DegreeView):
+        def __iter__(self):
+            all_nodes = set(self._succ)
+            for n in self._nodes:
+                nbrs = all_nodes - set(self._succ[n]) - {n}
+                yield (n, len(nbrs))
+
+        def __getitem__(self, n):
+            nbrs = set(self._succ) - set(self._succ[n]) - {n}
+            # AntiGraph is a ThinGraph so all edges have weight 1
+            return len(nbrs) + (n in nbrs)
+
+    @cached_property
+    def degree(self):
+        """Returns an iterator for (node, degree) and degree for single node.
+
+        The node degree is the number of edges adjacent to the node.
+
+        Parameters
+        ----------
+        nbunch : iterable container, optional (default=all nodes)
+            A container of nodes.  The container will be iterated
+            through once.
+
+        weight : string or None, optional (default=None)
+           The edge attribute that holds the numerical value used
+           as a weight.  If None, then each edge has weight 1.
+           The degree is the sum of the edge weights adjacent to the node.
+
+        Returns
+        -------
+        deg:
+            Degree of the node, if a single node is passed as argument.
+        nd_iter : an iterator
+            The iterator returns two-tuples of (node, degree).
+
+        See Also
+        --------
+        degree
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)
+        >>> G.degree(0)  # node 0 with degree 1
+        1
+        >>> list(G.degree([0, 1]))
+        [(0, 1), (1, 2)]
+
+        """
+        return self.AntiDegreeView(self)
+
+    def adjacency(self):
+        """Returns an iterator of (node, adjacency set) tuples for all nodes
+           in the dense graph.
+
+        This is the fastest way to look at every edge.
+        For directed graphs, only outgoing adjacencies are included.
+
+        Returns
+        -------
+        adj_iter : iterator
+           An iterator of (node, adjacency set) for all nodes in
+           the graph.
+
+        """
+        for n in self._adj:
+            yield (n, set(self._adj) - set(self._adj[n]) - {n})
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/matching.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/matching.py
new file mode 100644
index 0000000..17a52ed
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/matching.py
@@ -0,0 +1,42 @@
+"""
+**************
+Graph Matching
+**************
+
+Given a graph G = (V,E), a matching M in G is a set of pairwise non-adjacent
+edges; that is, no two edges share a common vertex.
+
+`Wikipedia: Matching <https://en.wikipedia.org/wiki/Matching_(graph_theory)>`_
+"""
+import networkx as nx
+
+__all__ = ["min_maximal_matching"]
+
+
+def min_maximal_matching(G):
+    r"""Returns the minimum maximal matching of G. That is, out of all maximal
+    matchings of the graph G, the smallest is returned.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+      Undirected graph
+
+    Returns
+    -------
+    min_maximal_matching : set
+      Returns a set of edges such that no two edges share a common endpoint
+      and every edge not in the set shares some common endpoint in the set.
+      Cardinality will be 2*OPT in the worst case.
+
+    Notes
+    -----
+    The algorithm computes an approximate solution fo the minimum maximal
+    cardinality matching problem. The solution is no more than 2 * OPT in size.
+    Runtime is $O(|E|)$.
+
+    References
+    ----------
+    .. [1] Vazirani, Vijay Approximation Algorithms (2001)
+    """
+    return nx.maximal_matching(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/maxcut.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/maxcut.py
new file mode 100644
index 0000000..59dfa63
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/maxcut.py
@@ -0,0 +1,111 @@
+import networkx as nx
+from networkx.utils.decorators import not_implemented_for, py_random_state
+
+__all__ = ["randomized_partitioning", "one_exchange"]
+
+
+@not_implemented_for("directed", "multigraph")
+@py_random_state(1)
+def randomized_partitioning(G, seed=None, p=0.5, weight=None):
+    """Compute a random partitioning of the graph nodes and its cut value.
+
+    A partitioning is calculated by observing each node
+    and deciding to add it to the partition with probability `p`,
+    returning a random cut and its corresponding value (the
+    sum of weights of edges connecting different partitions).
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    p : scalar
+        Probability for each node to be part of the first partition.
+        Should be in [0,1]
+
+    weight : object
+        Edge attribute key to use as weight. If not specified, edges
+        have weight one.
+
+    Returns
+    -------
+    cut_size : scalar
+        Value of the minimum cut.
+
+    partition : pair of node sets
+        A partitioning of the nodes that defines a minimum cut.
+    """
+    cut = {node for node in G.nodes() if seed.random() < p}
+    cut_size = nx.algorithms.cut_size(G, cut, weight=weight)
+    partition = (cut, G.nodes - cut)
+    return cut_size, partition
+
+
+def _swap_node_partition(cut, node):
+    return cut - {node} if node in cut else cut.union({node})
+
+
+@not_implemented_for("directed", "multigraph")
+@py_random_state(2)
+def one_exchange(G, initial_cut=None, seed=None, weight=None):
+    """Compute a partitioning of the graphs nodes and the corresponding cut value.
+
+    Use a greedy one exchange strategy to find a locally maximal cut
+    and its value, it works by finding the best node (one that gives
+    the highest gain to the cut value) to add to the current cut
+    and repeats this process until no improvement can be made.
+
+    Parameters
+    ----------
+    G : networkx Graph
+        Graph to find a maximum cut for.
+
+    initial_cut : set
+        Cut to use as a starting point. If not supplied the algorithm
+        starts with an empty cut.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    weight : object
+        Edge attribute key to use as weight. If not specified, edges
+        have weight one.
+
+    Returns
+    -------
+    cut_value : scalar
+        Value of the maximum cut.
+
+    partition : pair of node sets
+        A partitioning of the nodes that defines a maximum cut.
+    """
+    if initial_cut is None:
+        initial_cut = set()
+    cut = set(initial_cut)
+    current_cut_size = nx.algorithms.cut_size(G, cut, weight=weight)
+    while True:
+        nodes = list(G.nodes())
+        # Shuffling the nodes ensures random tie-breaks in the following call to max
+        seed.shuffle(nodes)
+        best_node_to_swap = max(
+            nodes,
+            key=lambda v: nx.algorithms.cut_size(
+                G, _swap_node_partition(cut, v), weight=weight
+            ),
+            default=None,
+        )
+        potential_cut = _swap_node_partition(cut, best_node_to_swap)
+        potential_cut_size = nx.algorithms.cut_size(G, potential_cut, weight=weight)
+
+        if potential_cut_size > current_cut_size:
+            cut = potential_cut
+            current_cut_size = potential_cut_size
+        else:
+            break
+
+    partition = (cut, G.nodes - cut)
+    return current_cut_size, partition
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/ramsey.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/ramsey.py
new file mode 100644
index 0000000..1692477
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/ramsey.py
@@ -0,0 +1,51 @@
+"""
+Ramsey numbers.
+"""
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+from ...utils import arbitrary_element
+
+__all__ = ["ramsey_R2"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def ramsey_R2(G):
+    r"""Compute the largest clique and largest independent set in `G`.
+
+    This can be used to estimate bounds for the 2-color
+    Ramsey number `R(2;s,t)` for `G`.
+
+    This is a recursive implementation which could run into trouble
+    for large recursions. Note that self-loop edges are ignored.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    Returns
+    -------
+    max_pair : (set, set) tuple
+        Maximum clique, Maximum independent set.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
+    """
+    if not G:
+        return set(), set()
+
+    node = arbitrary_element(G)
+    nbrs = (nbr for nbr in nx.all_neighbors(G, node) if nbr != node)
+    nnbrs = nx.non_neighbors(G, node)
+    c_1, i_1 = ramsey_R2(G.subgraph(nbrs).copy())
+    c_2, i_2 = ramsey_R2(G.subgraph(nnbrs).copy())
+
+    c_1.add(node)
+    i_2.add(node)
+    # Choose the larger of the two cliques and the larger of the two
+    # independent sets, according to cardinality.
+    return max(c_1, c_2, key=len), max(i_1, i_2, key=len)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/steinertree.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/steinertree.py
new file mode 100644
index 0000000..496098b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/steinertree.py
@@ -0,0 +1,104 @@
+from itertools import chain
+
+import networkx as nx
+from networkx.utils import not_implemented_for, pairwise
+
+__all__ = ["metric_closure", "steiner_tree"]
+
+
+@not_implemented_for("directed")
+def metric_closure(G, weight="weight"):
+    """Return the metric closure of a graph.
+
+    The metric closure of a graph *G* is the complete graph in which each edge
+    is weighted by the shortest path distance between the nodes in *G* .
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    NetworkX graph
+        Metric closure of the graph `G`.
+
+    """
+    M = nx.Graph()
+
+    Gnodes = set(G)
+
+    # check for connected graph while processing first node
+    all_paths_iter = nx.all_pairs_dijkstra(G, weight=weight)
+    u, (distance, path) = next(all_paths_iter)
+    if Gnodes - set(distance):
+        msg = "G is not a connected graph. metric_closure is not defined."
+        raise nx.NetworkXError(msg)
+    Gnodes.remove(u)
+    for v in Gnodes:
+        M.add_edge(u, v, distance=distance[v], path=path[v])
+
+    # first node done -- now process the rest
+    for u, (distance, path) in all_paths_iter:
+        Gnodes.remove(u)
+        for v in Gnodes:
+            M.add_edge(u, v, distance=distance[v], path=path[v])
+
+    return M
+
+
+@not_implemented_for("directed")
+def steiner_tree(G, terminal_nodes, weight="weight"):
+    """Return an approximation to the minimum Steiner tree of a graph.
+
+    The minimum Steiner tree of `G` w.r.t a set of `terminal_nodes`
+    is a tree within `G` that spans those nodes and has minimum size
+    (sum of edge weights) among all such trees.
+
+    The minimum Steiner tree can be approximated by computing the minimum
+    spanning tree of the subgraph of the metric closure of *G* induced by the
+    terminal nodes, where the metric closure of *G* is the complete graph in
+    which each edge is weighted by the shortest path distance between the
+    nodes in *G* .
+    This algorithm produces a tree whose weight is within a (2 - (2 / t))
+    factor of the weight of the optimal Steiner tree where *t* is number of
+    terminal nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    terminal_nodes : list
+         A list of terminal nodes for which minimum steiner tree is
+         to be found.
+
+    Returns
+    -------
+    NetworkX graph
+        Approximation to the minimum steiner tree of `G` induced by
+        `terminal_nodes` .
+
+    Notes
+    -----
+    For multigraphs, the edge between two nodes with minimum weight is the
+    edge put into the Steiner tree.
+
+
+    References
+    ----------
+    .. [1] Steiner_tree_problem on Wikipedia.
+       https://en.wikipedia.org/wiki/Steiner_tree_problem
+    """
+    # H is the subgraph induced by terminal_nodes in the metric closure M of G.
+    M = metric_closure(G, weight=weight)
+    H = M.subgraph(terminal_nodes)
+    # Use the 'distance' attribute of each edge provided by M.
+    mst_edges = nx.minimum_spanning_edges(H, weight="distance", data=True)
+    # Create an iterator over each edge in each shortest path; repeats are okay
+    edges = chain.from_iterable(pairwise(d["path"]) for u, v, d in mst_edges)
+    # For multigraph we should add the minimal weight edge keys
+    if G.is_multigraph():
+        edges = (
+            (u, v, min(G[u][v], key=lambda k: G[u][v][k][weight])) for u, v in edges
+        )
+    T = G.edge_subgraph(edges)
+    return T
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_approx_clust_coeff.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_approx_clust_coeff.py
new file mode 100644
index 0000000..5eab5c1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_approx_clust_coeff.py
@@ -0,0 +1,41 @@
+import networkx as nx
+from networkx.algorithms.approximation import average_clustering
+
+# This approximation has to be exact in regular graphs
+# with no triangles or with all possible triangles.
+
+
+def test_petersen():
+    # Actual coefficient is 0
+    G = nx.petersen_graph()
+    assert average_clustering(G, trials=len(G) // 2) == nx.average_clustering(G)
+
+
+def test_petersen_seed():
+    # Actual coefficient is 0
+    G = nx.petersen_graph()
+    assert average_clustering(G, trials=len(G) // 2, seed=1) == nx.average_clustering(G)
+
+
+def test_tetrahedral():
+    # Actual coefficient is 1
+    G = nx.tetrahedral_graph()
+    assert average_clustering(G, trials=len(G) // 2) == nx.average_clustering(G)
+
+
+def test_dodecahedral():
+    # Actual coefficient is 0
+    G = nx.dodecahedral_graph()
+    assert average_clustering(G, trials=len(G) // 2) == nx.average_clustering(G)
+
+
+def test_empty():
+    G = nx.empty_graph(5)
+    assert average_clustering(G, trials=len(G) // 2) == 0
+
+
+def test_complete():
+    G = nx.complete_graph(5)
+    assert average_clustering(G, trials=len(G) // 2) == 1
+    G = nx.complete_graph(7)
+    assert average_clustering(G, trials=len(G) // 2) == 1
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_clique.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_clique.py
new file mode 100644
index 0000000..ebda285
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_clique.py
@@ -0,0 +1,113 @@
+"""Unit tests for the :mod:`networkx.algorithms.approximation.clique` module."""
+
+
+import networkx as nx
+from networkx.algorithms.approximation import (
+    clique_removal,
+    large_clique_size,
+    max_clique,
+    maximum_independent_set,
+)
+
+
+def is_independent_set(G, nodes):
+    """Returns True if and only if `nodes` is a clique in `G`.
+
+    `G` is a NetworkX graph. `nodes` is an iterable of nodes in
+    `G`.
+
+    """
+    return G.subgraph(nodes).number_of_edges() == 0
+
+
+def is_clique(G, nodes):
+    """Returns True if and only if `nodes` is an independent set
+    in `G`.
+
+    `G` is an undirected simple graph. `nodes` is an iterable of
+    nodes in `G`.
+
+    """
+    H = G.subgraph(nodes)
+    n = len(H)
+    return H.number_of_edges() == n * (n - 1) // 2
+
+
+class TestCliqueRemoval:
+    """Unit tests for the
+    :func:`~networkx.algorithms.approximation.clique_removal` function.
+
+    """
+
+    def test_trivial_graph(self):
+        G = nx.trivial_graph()
+        independent_set, cliques = clique_removal(G)
+        assert is_independent_set(G, independent_set)
+        assert all(is_clique(G, clique) for clique in cliques)
+        # In fact, we should only have 1-cliques, that is, singleton nodes.
+        assert all(len(clique) == 1 for clique in cliques)
+
+    def test_complete_graph(self):
+        G = nx.complete_graph(10)
+        independent_set, cliques = clique_removal(G)
+        assert is_independent_set(G, independent_set)
+        assert all(is_clique(G, clique) for clique in cliques)
+
+    def test_barbell_graph(self):
+        G = nx.barbell_graph(10, 5)
+        independent_set, cliques = clique_removal(G)
+        assert is_independent_set(G, independent_set)
+        assert all(is_clique(G, clique) for clique in cliques)
+
+
+class TestMaxClique:
+    """Unit tests for the :func:`networkx.algorithms.approximation.max_clique`
+    function.
+
+    """
+
+    def test_null_graph(self):
+        G = nx.null_graph()
+        assert len(max_clique(G)) == 0
+
+    def test_complete_graph(self):
+        graph = nx.complete_graph(30)
+        # this should return the entire graph
+        mc = max_clique(graph)
+        assert 30 == len(mc)
+
+    def test_maximal_by_cardinality(self):
+        """Tests that the maximal clique is computed according to maximum
+        cardinality of the sets.
+
+        For more information, see pull request #1531.
+
+        """
+        G = nx.complete_graph(5)
+        G.add_edge(4, 5)
+        clique = max_clique(G)
+        assert len(clique) > 1
+
+        G = nx.lollipop_graph(30, 2)
+        clique = max_clique(G)
+        assert len(clique) > 2
+
+
+def test_large_clique_size():
+    G = nx.complete_graph(9)
+    nx.add_cycle(G, [9, 10, 11])
+    G.add_edge(8, 9)
+    G.add_edge(1, 12)
+    G.add_node(13)
+
+    assert large_clique_size(G) == 9
+    G.remove_node(5)
+    assert large_clique_size(G) == 8
+    G.remove_edge(2, 3)
+    assert large_clique_size(G) == 7
+
+
+def test_independent_set():
+    # smoke test
+    G = nx.Graph()
+    assert len(maximum_independent_set(G)) == 0
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_connectivity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_connectivity.py
new file mode 100644
index 0000000..887db20
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_connectivity.py
@@ -0,0 +1,199 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms import approximation as approx
+
+
+def test_global_node_connectivity():
+    # Figure 1 chapter on Connectivity
+    G = nx.Graph()
+    G.add_edges_from(
+        [
+            (1, 2),
+            (1, 3),
+            (1, 4),
+            (1, 5),
+            (2, 3),
+            (2, 6),
+            (3, 4),
+            (3, 6),
+            (4, 6),
+            (4, 7),
+            (5, 7),
+            (6, 8),
+            (6, 9),
+            (7, 8),
+            (7, 10),
+            (8, 11),
+            (9, 10),
+            (9, 11),
+            (10, 11),
+        ]
+    )
+    assert 2 == approx.local_node_connectivity(G, 1, 11)
+    assert 2 == approx.node_connectivity(G)
+    assert 2 == approx.node_connectivity(G, 1, 11)
+
+
+def test_white_harary1():
+    # Figure 1b white and harary (2001)
+    # A graph with high adhesion (edge connectivity) and low cohesion
+    # (node connectivity)
+    G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4))
+    G.remove_node(7)
+    for i in range(4, 7):
+        G.add_edge(0, i)
+    G = nx.disjoint_union(G, nx.complete_graph(4))
+    G.remove_node(G.order() - 1)
+    for i in range(7, 10):
+        G.add_edge(0, i)
+    assert 1 == approx.node_connectivity(G)
+
+
+def test_complete_graphs():
+    for n in range(5, 25, 5):
+        G = nx.complete_graph(n)
+        assert n - 1 == approx.node_connectivity(G)
+        assert n - 1 == approx.node_connectivity(G, 0, 3)
+
+
+def test_empty_graphs():
+    for k in range(5, 25, 5):
+        G = nx.empty_graph(k)
+        assert 0 == approx.node_connectivity(G)
+        assert 0 == approx.node_connectivity(G, 0, 3)
+
+
+def test_petersen():
+    G = nx.petersen_graph()
+    assert 3 == approx.node_connectivity(G)
+    assert 3 == approx.node_connectivity(G, 0, 5)
+
+
+# Approximation fails with tutte graph
+# def test_tutte():
+#    G = nx.tutte_graph()
+#    assert_equal(3, approx.node_connectivity(G))
+
+
+def test_dodecahedral():
+    G = nx.dodecahedral_graph()
+    assert 3 == approx.node_connectivity(G)
+    assert 3 == approx.node_connectivity(G, 0, 5)
+
+
+def test_octahedral():
+    G = nx.octahedral_graph()
+    assert 4 == approx.node_connectivity(G)
+    assert 4 == approx.node_connectivity(G, 0, 5)
+
+
+# Approximation can fail with icosahedral graph depending
+# on iteration order.
+# def test_icosahedral():
+#    G=nx.icosahedral_graph()
+#    assert_equal(5, approx.node_connectivity(G))
+#    assert_equal(5, approx.node_connectivity(G, 0, 5))
+
+
+def test_only_source():
+    G = nx.complete_graph(5)
+    pytest.raises(nx.NetworkXError, approx.node_connectivity, G, s=0)
+
+
+def test_only_target():
+    G = nx.complete_graph(5)
+    pytest.raises(nx.NetworkXError, approx.node_connectivity, G, t=0)
+
+
+def test_missing_source():
+    G = nx.path_graph(4)
+    pytest.raises(nx.NetworkXError, approx.node_connectivity, G, 10, 1)
+
+
+def test_missing_target():
+    G = nx.path_graph(4)
+    pytest.raises(nx.NetworkXError, approx.node_connectivity, G, 1, 10)
+
+
+def test_source_equals_target():
+    G = nx.complete_graph(5)
+    pytest.raises(nx.NetworkXError, approx.local_node_connectivity, G, 0, 0)
+
+
+def test_directed_node_connectivity():
+    G = nx.cycle_graph(10, create_using=nx.DiGraph())  # only one direction
+    D = nx.cycle_graph(10).to_directed()  # 2 reciprocal edges
+    assert 1 == approx.node_connectivity(G)
+    assert 1 == approx.node_connectivity(G, 1, 4)
+    assert 2 == approx.node_connectivity(D)
+    assert 2 == approx.node_connectivity(D, 1, 4)
+
+
+class TestAllPairsNodeConnectivityApprox:
+    @classmethod
+    def setup_class(cls):
+        cls.path = nx.path_graph(7)
+        cls.directed_path = nx.path_graph(7, create_using=nx.DiGraph())
+        cls.cycle = nx.cycle_graph(7)
+        cls.directed_cycle = nx.cycle_graph(7, create_using=nx.DiGraph())
+        cls.gnp = nx.gnp_random_graph(30, 0.1)
+        cls.directed_gnp = nx.gnp_random_graph(30, 0.1, directed=True)
+        cls.K20 = nx.complete_graph(20)
+        cls.K10 = nx.complete_graph(10)
+        cls.K5 = nx.complete_graph(5)
+        cls.G_list = [
+            cls.path,
+            cls.directed_path,
+            cls.cycle,
+            cls.directed_cycle,
+            cls.gnp,
+            cls.directed_gnp,
+            cls.K10,
+            cls.K5,
+            cls.K20,
+        ]
+
+    def test_cycles(self):
+        K_undir = approx.all_pairs_node_connectivity(self.cycle)
+        for source in K_undir:
+            for target, k in K_undir[source].items():
+                assert k == 2
+        K_dir = approx.all_pairs_node_connectivity(self.directed_cycle)
+        for source in K_dir:
+            for target, k in K_dir[source].items():
+                assert k == 1
+
+    def test_complete(self):
+        for G in [self.K10, self.K5, self.K20]:
+            K = approx.all_pairs_node_connectivity(G)
+            for source in K:
+                for target, k in K[source].items():
+                    assert k == len(G) - 1
+
+    def test_paths(self):
+        K_undir = approx.all_pairs_node_connectivity(self.path)
+        for source in K_undir:
+            for target, k in K_undir[source].items():
+                assert k == 1
+        K_dir = approx.all_pairs_node_connectivity(self.directed_path)
+        for source in K_dir:
+            for target, k in K_dir[source].items():
+                if source < target:
+                    assert k == 1
+                else:
+                    assert k == 0
+
+    def test_cutoff(self):
+        for G in [self.K10, self.K5, self.K20]:
+            for mp in [2, 3, 4]:
+                paths = approx.all_pairs_node_connectivity(G, cutoff=mp)
+                for source in paths:
+                    for target, K in paths[source].items():
+                        assert K == mp
+
+    def test_all_pairs_connectivity_nbunch(self):
+        G = nx.complete_graph(5)
+        nbunch = [0, 2, 3]
+        C = approx.all_pairs_node_connectivity(G, nbunch=nbunch)
+        assert len(C) == len(nbunch)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_distance_measures.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_distance_measures.py
new file mode 100644
index 0000000..8125150
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_distance_measures.py
@@ -0,0 +1,60 @@
+"""Unit tests for the :mod:`networkx.algorithms.approximation.distance_measures` module.
+"""
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.approximation import diameter
+
+
+class TestDiameter:
+    """Unit tests for the approximate diameter function
+    :func:`~networkx.algorithms.approximation.distance_measures.diameter`.
+    """
+
+    def test_null_graph(self):
+        """Test empty graph."""
+        G = nx.null_graph()
+        with pytest.raises(
+            nx.NetworkXError, match="Expected non-empty NetworkX graph!"
+        ):
+            diameter(G)
+
+    def test_undirected_non_connected(self):
+        """Test an undirected disconnected graph."""
+        graph = nx.path_graph(10)
+        graph.remove_edge(3, 4)
+        with pytest.raises(nx.NetworkXError, match="Graph not connected."):
+            diameter(graph)
+
+    def test_directed_non_strongly_connected(self):
+        """Test a directed non strongly connected graph."""
+        graph = nx.path_graph(10, create_using=nx.DiGraph())
+        with pytest.raises(nx.NetworkXError, match="DiGraph not strongly connected."):
+            diameter(graph)
+
+    def test_complete_undirected_graph(self):
+        """Test a complete undirected graph."""
+        graph = nx.complete_graph(10)
+        assert diameter(graph) == 1
+
+    def test_complete_directed_graph(self):
+        """Test a complete directed graph."""
+        graph = nx.complete_graph(10, create_using=nx.DiGraph())
+        assert diameter(graph) == 1
+
+    def test_undirected_path_graph(self):
+        """Test an undirected path graph with 10 nodes."""
+        graph = nx.path_graph(10)
+        assert diameter(graph) == 9
+
+    def test_directed_path_graph(self):
+        """Test a directed path graph with 10 nodes."""
+        graph = nx.path_graph(10).to_directed()
+        assert diameter(graph) == 9
+
+    def test_single_node(self):
+        """Test a graph which contains just a node."""
+        graph = nx.Graph()
+        graph.add_node(1)
+        assert diameter(graph) == 0
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_dominating_set.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_dominating_set.py
new file mode 100644
index 0000000..892ce34
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_dominating_set.py
@@ -0,0 +1,67 @@
+import networkx as nx
+from networkx.algorithms.approximation import (
+    min_edge_dominating_set,
+    min_weighted_dominating_set,
+)
+
+
+class TestMinWeightDominatingSet:
+    def test_min_weighted_dominating_set(self):
+        graph = nx.Graph()
+        graph.add_edge(1, 2)
+        graph.add_edge(1, 5)
+        graph.add_edge(2, 3)
+        graph.add_edge(2, 5)
+        graph.add_edge(3, 4)
+        graph.add_edge(3, 6)
+        graph.add_edge(5, 6)
+
+        vertices = {1, 2, 3, 4, 5, 6}
+        # due to ties, this might be hard to test tight bounds
+        dom_set = min_weighted_dominating_set(graph)
+        for vertex in vertices - dom_set:
+            neighbors = set(graph.neighbors(vertex))
+            assert len(neighbors & dom_set) > 0, "Non dominating set found!"
+
+    def test_star_graph(self):
+        """Tests that an approximate dominating set for the star graph,
+        even when the center node does not have the smallest integer
+        label, gives just the center node.
+
+        For more information, see #1527.
+
+        """
+        # Create a star graph in which the center node has the highest
+        # label instead of the lowest.
+        G = nx.star_graph(10)
+        G = nx.relabel_nodes(G, {0: 9, 9: 0})
+        assert min_weighted_dominating_set(G) == {9}
+
+    def test_min_edge_dominating_set(self):
+        graph = nx.path_graph(5)
+        dom_set = min_edge_dominating_set(graph)
+
+        # this is a crappy way to test, but good enough for now.
+        for edge in graph.edges():
+            if edge in dom_set:
+                continue
+            else:
+                u, v = edge
+                found = False
+                for dom_edge in dom_set:
+                    found |= u == dom_edge[0] or u == dom_edge[1]
+                assert found, "Non adjacent edge found!"
+
+        graph = nx.complete_graph(10)
+        dom_set = min_edge_dominating_set(graph)
+
+        # this is a crappy way to test, but good enough for now.
+        for edge in graph.edges():
+            if edge in dom_set:
+                continue
+            else:
+                u, v = edge
+                found = False
+                for dom_edge in dom_set:
+                    found |= u == dom_edge[0] or u == dom_edge[1]
+                assert found, "Non adjacent edge found!"
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_kcomponents.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_kcomponents.py
new file mode 100644
index 0000000..6b28031
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_kcomponents.py
@@ -0,0 +1,301 @@
+# Test for approximation to k-components algorithm
+import pytest
+
+import networkx as nx
+from networkx.algorithms.approximation import k_components
+from networkx.algorithms.approximation.kcomponents import _AntiGraph, _same
+
+
+def build_k_number_dict(k_components):
+    k_num = {}
+    for k, comps in sorted(k_components.items()):
+        for comp in comps:
+            for node in comp:
+                k_num[node] = k
+    return k_num
+
+
+##
+# Some nice synthetic graphs
+##
+
+
+def graph_example_1():
+    G = nx.convert_node_labels_to_integers(
+        nx.grid_graph([5, 5]), label_attribute="labels"
+    )
+    rlabels = nx.get_node_attributes(G, "labels")
+    labels = {v: k for k, v in rlabels.items()}
+
+    for nodes in [
+        (labels[(0, 0)], labels[(1, 0)]),
+        (labels[(0, 4)], labels[(1, 4)]),
+        (labels[(3, 0)], labels[(4, 0)]),
+        (labels[(3, 4)], labels[(4, 4)]),
+    ]:
+        new_node = G.order() + 1
+        # Petersen graph is triconnected
+        P = nx.petersen_graph()
+        G = nx.disjoint_union(G, P)
+        # Add two edges between the grid and P
+        G.add_edge(new_node + 1, nodes[0])
+        G.add_edge(new_node, nodes[1])
+        # K5 is 4-connected
+        K = nx.complete_graph(5)
+        G = nx.disjoint_union(G, K)
+        # Add three edges between P and K5
+        G.add_edge(new_node + 2, new_node + 11)
+        G.add_edge(new_node + 3, new_node + 12)
+        G.add_edge(new_node + 4, new_node + 13)
+        # Add another K5 sharing a node
+        G = nx.disjoint_union(G, K)
+        nbrs = G[new_node + 10]
+        G.remove_node(new_node + 10)
+        for nbr in nbrs:
+            G.add_edge(new_node + 17, nbr)
+        G.add_edge(new_node + 16, new_node + 5)
+    return G
+
+
+def torrents_and_ferraro_graph():
+    G = nx.convert_node_labels_to_integers(
+        nx.grid_graph([5, 5]), label_attribute="labels"
+    )
+    rlabels = nx.get_node_attributes(G, "labels")
+    labels = {v: k for k, v in rlabels.items()}
+
+    for nodes in [(labels[(0, 4)], labels[(1, 4)]), (labels[(3, 4)], labels[(4, 4)])]:
+        new_node = G.order() + 1
+        # Petersen graph is triconnected
+        P = nx.petersen_graph()
+        G = nx.disjoint_union(G, P)
+        # Add two edges between the grid and P
+        G.add_edge(new_node + 1, nodes[0])
+        G.add_edge(new_node, nodes[1])
+        # K5 is 4-connected
+        K = nx.complete_graph(5)
+        G = nx.disjoint_union(G, K)
+        # Add three edges between P and K5
+        G.add_edge(new_node + 2, new_node + 11)
+        G.add_edge(new_node + 3, new_node + 12)
+        G.add_edge(new_node + 4, new_node + 13)
+        # Add another K5 sharing a node
+        G = nx.disjoint_union(G, K)
+        nbrs = G[new_node + 10]
+        G.remove_node(new_node + 10)
+        for nbr in nbrs:
+            G.add_edge(new_node + 17, nbr)
+        # Commenting this makes the graph not biconnected !!
+        # This stupid mistake make one reviewer very angry :P
+        G.add_edge(new_node + 16, new_node + 8)
+
+    for nodes in [(labels[(0, 0)], labels[(1, 0)]), (labels[(3, 0)], labels[(4, 0)])]:
+        new_node = G.order() + 1
+        # Petersen graph is triconnected
+        P = nx.petersen_graph()
+        G = nx.disjoint_union(G, P)
+        # Add two edges between the grid and P
+        G.add_edge(new_node + 1, nodes[0])
+        G.add_edge(new_node, nodes[1])
+        # K5 is 4-connected
+        K = nx.complete_graph(5)
+        G = nx.disjoint_union(G, K)
+        # Add three edges between P and K5
+        G.add_edge(new_node + 2, new_node + 11)
+        G.add_edge(new_node + 3, new_node + 12)
+        G.add_edge(new_node + 4, new_node + 13)
+        # Add another K5 sharing two nodes
+        G = nx.disjoint_union(G, K)
+        nbrs = G[new_node + 10]
+        G.remove_node(new_node + 10)
+        for nbr in nbrs:
+            G.add_edge(new_node + 17, nbr)
+        nbrs2 = G[new_node + 9]
+        G.remove_node(new_node + 9)
+        for nbr in nbrs2:
+            G.add_edge(new_node + 18, nbr)
+    return G
+
+
+# Helper function
+
+
+def _check_connectivity(G):
+    result = k_components(G)
+    for k, components in result.items():
+        if k < 3:
+            continue
+        for component in components:
+            C = G.subgraph(component)
+            K = nx.node_connectivity(C)
+            assert K >= k
+
+
+def test_torrents_and_ferraro_graph():
+    G = torrents_and_ferraro_graph()
+    _check_connectivity(G)
+
+
+def test_example_1():
+    G = graph_example_1()
+    _check_connectivity(G)
+
+
+def test_karate_0():
+    G = nx.karate_club_graph()
+    _check_connectivity(G)
+
+
+def test_karate_1():
+    karate_k_num = {
+        0: 4,
+        1: 4,
+        2: 4,
+        3: 4,
+        4: 3,
+        5: 3,
+        6: 3,
+        7: 4,
+        8: 4,
+        9: 2,
+        10: 3,
+        11: 1,
+        12: 2,
+        13: 4,
+        14: 2,
+        15: 2,
+        16: 2,
+        17: 2,
+        18: 2,
+        19: 3,
+        20: 2,
+        21: 2,
+        22: 2,
+        23: 3,
+        24: 3,
+        25: 3,
+        26: 2,
+        27: 3,
+        28: 3,
+        29: 3,
+        30: 4,
+        31: 3,
+        32: 4,
+        33: 4,
+    }
+    approx_karate_k_num = karate_k_num.copy()
+    approx_karate_k_num[24] = 2
+    approx_karate_k_num[25] = 2
+    G = nx.karate_club_graph()
+    k_comps = k_components(G)
+    k_num = build_k_number_dict(k_comps)
+    assert k_num in (karate_k_num, approx_karate_k_num)
+
+
+def test_example_1_detail_3_and_4():
+    G = graph_example_1()
+    result = k_components(G)
+    # In this example graph there are 8 3-components, 4 with 15 nodes
+    # and 4 with 5 nodes.
+    assert len(result[3]) == 8
+    assert len([c for c in result[3] if len(c) == 15]) == 4
+    assert len([c for c in result[3] if len(c) == 5]) == 4
+    # There are also 8 4-components all with 5 nodes.
+    assert len(result[4]) == 8
+    assert all(len(c) == 5 for c in result[4])
+    # Finally check that the k-components detected have actually node
+    # connectivity >= k.
+    for k, components in result.items():
+        if k < 3:
+            continue
+        for component in components:
+            K = nx.node_connectivity(G.subgraph(component))
+            assert K >= k
+
+
+def test_directed():
+    with pytest.raises(nx.NetworkXNotImplemented):
+        G = nx.gnp_random_graph(10, 0.4, directed=True)
+        kc = k_components(G)
+
+
+def test_same():
+    equal = {"A": 2, "B": 2, "C": 2}
+    slightly_different = {"A": 2, "B": 1, "C": 2}
+    different = {"A": 2, "B": 8, "C": 18}
+    assert _same(equal)
+    assert not _same(slightly_different)
+    assert _same(slightly_different, tol=1)
+    assert not _same(different)
+    assert not _same(different, tol=4)
+
+
+class TestAntiGraph:
+    @classmethod
+    def setup_class(cls):
+        cls.Gnp = nx.gnp_random_graph(20, 0.8)
+        cls.Anp = _AntiGraph(nx.complement(cls.Gnp))
+        cls.Gd = nx.davis_southern_women_graph()
+        cls.Ad = _AntiGraph(nx.complement(cls.Gd))
+        cls.Gk = nx.karate_club_graph()
+        cls.Ak = _AntiGraph(nx.complement(cls.Gk))
+        cls.GA = [(cls.Gnp, cls.Anp), (cls.Gd, cls.Ad), (cls.Gk, cls.Ak)]
+
+    def test_size(self):
+        for G, A in self.GA:
+            n = G.order()
+            s = len(list(G.edges())) + len(list(A.edges()))
+            assert s == (n * (n - 1)) / 2
+
+    def test_degree(self):
+        for G, A in self.GA:
+            assert sorted(G.degree()) == sorted(A.degree())
+
+    def test_core_number(self):
+        for G, A in self.GA:
+            assert nx.core_number(G) == nx.core_number(A)
+
+    def test_connected_components(self):
+        for G, A in self.GA:
+            gc = [set(c) for c in nx.connected_components(G)]
+            ac = [set(c) for c in nx.connected_components(A)]
+            for comp in ac:
+                assert comp in gc
+
+    def test_adj(self):
+        for G, A in self.GA:
+            for n, nbrs in G.adj.items():
+                a_adj = sorted((n, sorted(ad)) for n, ad in A.adj.items())
+                g_adj = sorted((n, sorted(ad)) for n, ad in G.adj.items())
+                assert a_adj == g_adj
+
+    def test_adjacency(self):
+        for G, A in self.GA:
+            a_adj = list(A.adjacency())
+            for n, nbrs in G.adjacency():
+                assert (n, set(nbrs)) in a_adj
+
+    def test_neighbors(self):
+        for G, A in self.GA:
+            node = list(G.nodes())[0]
+            assert set(G.neighbors(node)) == set(A.neighbors(node))
+
+    def test_node_not_in_graph(self):
+        for G, A in self.GA:
+            node = "non_existent_node"
+            pytest.raises(nx.NetworkXError, A.neighbors, node)
+            pytest.raises(nx.NetworkXError, G.neighbors, node)
+
+    def test_degree_thingraph(self):
+        for G, A in self.GA:
+            node = list(G.nodes())[0]
+            nodes = list(G.nodes())[1:4]
+            assert G.degree(node) == A.degree(node)
+            assert sum(d for n, d in G.degree()) == sum(d for n, d in A.degree())
+            # AntiGraph is a ThinGraph, so all the weights are 1
+            assert sum(d for n, d in A.degree()) == sum(
+                d for n, d in A.degree(weight="weight")
+            )
+            assert sum(d for n, d in G.degree(nodes)) == sum(
+                d for n, d in A.degree(nodes)
+            )
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_matching.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_matching.py
new file mode 100644
index 0000000..f50da3d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_matching.py
@@ -0,0 +1,8 @@
+import networkx as nx
+import networkx.algorithms.approximation as a
+
+
+def test_min_maximal_matching():
+    # smoke test
+    G = nx.Graph()
+    assert len(a.min_maximal_matching(G)) == 0
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_maxcut.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_maxcut.py
new file mode 100644
index 0000000..ec75b59
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_maxcut.py
@@ -0,0 +1,82 @@
+import random
+
+import networkx as nx
+from networkx.algorithms.approximation import maxcut
+
+
+def _is_valid_cut(G, set1, set2):
+    union = set1.union(set2)
+    assert union == set(G.nodes)
+    assert len(set1) + len(set2) == G.number_of_nodes()
+
+
+def _cut_is_locally_optimal(G, cut_size, set1):
+    # test if cut can be locally improved
+    for i, node in enumerate(set1):
+        cut_size_without_node = nx.algorithms.cut_size(
+            G, set1 - {node}, weight="weight"
+        )
+        assert cut_size_without_node <= cut_size
+
+
+def test_random_partitioning():
+    G = nx.complete_graph(5)
+    _, (set1, set2) = maxcut.randomized_partitioning(G, seed=5)
+    _is_valid_cut(G, set1, set2)
+
+
+def test_random_partitioning_all_to_one():
+    G = nx.complete_graph(5)
+    _, (set1, set2) = maxcut.randomized_partitioning(G, p=1)
+    _is_valid_cut(G, set1, set2)
+    assert len(set1) == G.number_of_nodes()
+    assert len(set2) == 0
+
+
+def test_one_exchange_basic():
+    G = nx.complete_graph(5)
+    random.seed(5)
+    for (u, v, w) in G.edges(data=True):
+        w["weight"] = random.randrange(-100, 100, 1) / 10
+
+    initial_cut = set(random.sample(sorted(G.nodes()), k=5))
+    cut_size, (set1, set2) = maxcut.one_exchange(
+        G, initial_cut, weight="weight", seed=5
+    )
+
+    _is_valid_cut(G, set1, set2)
+    _cut_is_locally_optimal(G, cut_size, set1)
+
+
+def test_one_exchange_optimal():
+    # Greedy one exchange should find the optimal solution for this graph (14)
+    G = nx.Graph()
+    G.add_edge(1, 2, weight=3)
+    G.add_edge(1, 3, weight=3)
+    G.add_edge(1, 4, weight=3)
+    G.add_edge(1, 5, weight=3)
+    G.add_edge(2, 3, weight=5)
+
+    cut_size, (set1, set2) = maxcut.one_exchange(G, weight="weight", seed=5)
+
+    _is_valid_cut(G, set1, set2)
+    _cut_is_locally_optimal(G, cut_size, set1)
+    # check global optimality
+    assert cut_size == 14
+
+
+def test_negative_weights():
+    G = nx.complete_graph(5)
+    random.seed(5)
+    for (u, v, w) in G.edges(data=True):
+        w["weight"] = -1 * random.random()
+
+    initial_cut = set(random.sample(sorted(G.nodes()), k=5))
+    cut_size, (set1, set2) = maxcut.one_exchange(G, initial_cut, weight="weight")
+
+    # make sure it is a valid cut
+    _is_valid_cut(G, set1, set2)
+    # check local optimality
+    _cut_is_locally_optimal(G, cut_size, set1)
+    # test that all nodes are in the same partition
+    assert len(set1) == len(G.nodes) or len(set2) == len(G.nodes)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_ramsey.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_ramsey.py
new file mode 100644
index 0000000..856a8ef
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_ramsey.py
@@ -0,0 +1,31 @@
+import networkx as nx
+import networkx.algorithms.approximation as apxa
+
+
+def test_ramsey():
+    # this should only find the complete graph
+    graph = nx.complete_graph(10)
+    c, i = apxa.ramsey_R2(graph)
+    cdens = nx.density(graph.subgraph(c))
+    assert cdens == 1.0, "clique not correctly found by ramsey!"
+    idens = nx.density(graph.subgraph(i))
+    assert idens == 0.0, "i-set not correctly found by ramsey!"
+
+    # this trival graph has no cliques. should just find i-sets
+    graph = nx.trivial_graph()
+    c, i = apxa.ramsey_R2(graph)
+    assert c == {0}, "clique not correctly found by ramsey!"
+    assert i == {0}, "i-set not correctly found by ramsey!"
+
+    graph = nx.barbell_graph(10, 5, nx.Graph())
+    c, i = apxa.ramsey_R2(graph)
+    cdens = nx.density(graph.subgraph(c))
+    assert cdens == 1.0, "clique not correctly found by ramsey!"
+    idens = nx.density(graph.subgraph(i))
+    assert idens == 0.0, "i-set not correctly found by ramsey!"
+
+    # add self-loops and test again
+    graph.add_edges_from([(n, n) for n in range(0, len(graph), 2)])
+    cc, ii = apxa.ramsey_R2(graph)
+    assert cc == c
+    assert ii == i
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_steinertree.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_steinertree.py
new file mode 100644
index 0000000..d58eb66
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_steinertree.py
@@ -0,0 +1,83 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms.approximation.steinertree import metric_closure, steiner_tree
+from networkx.utils import edges_equal
+
+
+class TestSteinerTree:
+    @classmethod
+    def setup_class(cls):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=10)
+        G.add_edge(2, 3, weight=10)
+        G.add_edge(3, 4, weight=10)
+        G.add_edge(4, 5, weight=10)
+        G.add_edge(5, 6, weight=10)
+        G.add_edge(2, 7, weight=1)
+        G.add_edge(7, 5, weight=1)
+        cls.G = G
+        cls.term_nodes = [1, 2, 3, 4, 5]
+
+    def test_connected_metric_closure(self):
+        G = self.G.copy()
+        G.add_node(100)
+        pytest.raises(nx.NetworkXError, metric_closure, G)
+
+    def test_metric_closure(self):
+        M = metric_closure(self.G)
+        mc = [
+            (1, 2, {"distance": 10, "path": [1, 2]}),
+            (1, 3, {"distance": 20, "path": [1, 2, 3]}),
+            (1, 4, {"distance": 22, "path": [1, 2, 7, 5, 4]}),
+            (1, 5, {"distance": 12, "path": [1, 2, 7, 5]}),
+            (1, 6, {"distance": 22, "path": [1, 2, 7, 5, 6]}),
+            (1, 7, {"distance": 11, "path": [1, 2, 7]}),
+            (2, 3, {"distance": 10, "path": [2, 3]}),
+            (2, 4, {"distance": 12, "path": [2, 7, 5, 4]}),
+            (2, 5, {"distance": 2, "path": [2, 7, 5]}),
+            (2, 6, {"distance": 12, "path": [2, 7, 5, 6]}),
+            (2, 7, {"distance": 1, "path": [2, 7]}),
+            (3, 4, {"distance": 10, "path": [3, 4]}),
+            (3, 5, {"distance": 12, "path": [3, 2, 7, 5]}),
+            (3, 6, {"distance": 22, "path": [3, 2, 7, 5, 6]}),
+            (3, 7, {"distance": 11, "path": [3, 2, 7]}),
+            (4, 5, {"distance": 10, "path": [4, 5]}),
+            (4, 6, {"distance": 20, "path": [4, 5, 6]}),
+            (4, 7, {"distance": 11, "path": [4, 5, 7]}),
+            (5, 6, {"distance": 10, "path": [5, 6]}),
+            (5, 7, {"distance": 1, "path": [5, 7]}),
+            (6, 7, {"distance": 11, "path": [6, 5, 7]}),
+        ]
+        assert edges_equal(list(M.edges(data=True)), mc)
+
+    def test_steiner_tree(self):
+        S = steiner_tree(self.G, self.term_nodes)
+        expected_steiner_tree = [
+            (1, 2, {"weight": 10}),
+            (2, 3, {"weight": 10}),
+            (2, 7, {"weight": 1}),
+            (3, 4, {"weight": 10}),
+            (5, 7, {"weight": 1}),
+        ]
+        assert edges_equal(list(S.edges(data=True)), expected_steiner_tree)
+
+    def test_multigraph_steiner_tree(self):
+        G = nx.MultiGraph()
+        G.add_edges_from(
+            [
+                (1, 2, 0, {"weight": 1}),
+                (2, 3, 0, {"weight": 999}),
+                (2, 3, 1, {"weight": 1}),
+                (3, 4, 0, {"weight": 1}),
+                (3, 5, 0, {"weight": 1}),
+            ]
+        )
+        terminal_nodes = [2, 4, 5]
+        expected_edges = [
+            (2, 3, 1, {"weight": 1}),  # edge with key 1 has lower weight
+            (3, 4, 0, {"weight": 1}),
+            (3, 5, 0, {"weight": 1}),
+        ]
+        T = steiner_tree(G, terminal_nodes)
+        assert edges_equal(T.edges(data=True, keys=True), expected_edges)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_traveling_salesman.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_traveling_salesman.py
new file mode 100644
index 0000000..6f9b3b0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_traveling_salesman.py
@@ -0,0 +1,963 @@
+"""Unit tests for the traveling_salesman module."""
+import random
+
+import pytest
+
+import networkx as nx
+import networkx.algorithms.approximation as nx_app
+
+pairwise = nx.utils.pairwise
+
+
+def test_christofides_hamiltonian():
+    random.seed(42)
+    G = nx.complete_graph(20)
+    for (u, v) in G.edges():
+        G[u][v]["weight"] = random.randint(0, 10)
+
+    H = nx.Graph()
+    H.add_edges_from(pairwise(nx_app.christofides(G)))
+    H.remove_edges_from(nx.find_cycle(H))
+    assert len(H.edges) == 0
+
+    tree = nx.minimum_spanning_tree(G, weight="weight")
+    H = nx.Graph()
+    H.add_edges_from(pairwise(nx_app.christofides(G, tree)))
+    H.remove_edges_from(nx.find_cycle(H))
+    assert len(H.edges) == 0
+
+
+def test_christofides_incomplete_graph():
+    G = nx.complete_graph(10)
+    G.remove_edge(0, 1)
+    pytest.raises(nx.NetworkXError, nx_app.christofides, G)
+
+
+def test_christofides_ignore_selfloops():
+    G = nx.complete_graph(5)
+    G.add_edge(3, 3)
+    cycle = nx_app.christofides(G)
+    assert len(cycle) - 1 == len(G) == len(set(cycle))
+
+
+# set up graphs for other tests
+class TestBase:
+    @classmethod
+    def setup_class(cls):
+        cls.DG = nx.DiGraph()
+        cls.DG.add_weighted_edges_from(
+            {
+                ("A", "B", 3),
+                ("A", "C", 17),
+                ("A", "D", 14),
+                ("B", "A", 3),
+                ("B", "C", 12),
+                ("B", "D", 16),
+                ("C", "A", 13),
+                ("C", "B", 12),
+                ("C", "D", 4),
+                ("D", "A", 14),
+                ("D", "B", 15),
+                ("D", "C", 2),
+            }
+        )
+        cls.DG_cycle = ["D", "C", "B", "A", "D"]
+        cls.DG_cost = 31.0
+
+        cls.DG2 = nx.DiGraph()
+        cls.DG2.add_weighted_edges_from(
+            {
+                ("A", "B", 3),
+                ("A", "C", 17),
+                ("A", "D", 14),
+                ("B", "A", 30),
+                ("B", "C", 2),
+                ("B", "D", 16),
+                ("C", "A", 33),
+                ("C", "B", 32),
+                ("C", "D", 34),
+                ("D", "A", 14),
+                ("D", "B", 15),
+                ("D", "C", 2),
+            }
+        )
+        cls.DG2_cycle = ["D", "A", "B", "C", "D"]
+        cls.DG2_cost = 53.0
+
+        cls.unweightedUG = nx.complete_graph(5, nx.Graph())
+        cls.unweightedDG = nx.complete_graph(5, nx.DiGraph())
+
+        cls.incompleteUG = nx.Graph()
+        cls.incompleteUG.add_weighted_edges_from({(0, 1, 1), (1, 2, 3)})
+        cls.incompleteDG = nx.DiGraph()
+        cls.incompleteDG.add_weighted_edges_from({(0, 1, 1), (1, 2, 3)})
+
+        cls.UG = nx.Graph()
+        cls.UG.add_weighted_edges_from(
+            {
+                ("A", "B", 3),
+                ("A", "C", 17),
+                ("A", "D", 14),
+                ("B", "C", 12),
+                ("B", "D", 16),
+                ("C", "D", 4),
+            }
+        )
+        cls.UG_cycle = ["D", "C", "B", "A", "D"]
+        cls.UG_cost = 33.0
+
+        cls.UG2 = nx.Graph()
+        cls.UG2.add_weighted_edges_from(
+            {
+                ("A", "B", 1),
+                ("A", "C", 15),
+                ("A", "D", 5),
+                ("B", "C", 16),
+                ("B", "D", 8),
+                ("C", "D", 3),
+            }
+        )
+        cls.UG2_cycle = ["D", "C", "B", "A", "D"]
+        cls.UG2_cost = 25.0
+
+
+def validate_solution(soln, cost, exp_soln, exp_cost):
+    assert soln == exp_soln
+    assert cost == exp_cost
+
+
+def validate_symmetric_solution(soln, cost, exp_soln, exp_cost):
+    assert soln == exp_soln or soln == exp_soln[::-1]
+    assert cost == exp_cost
+
+
+class TestGreedyTSP(TestBase):
+    def test_greedy(self):
+        cycle = nx_app.greedy_tsp(self.DG, source="D")
+        cost = sum(self.DG[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, ["D", "C", "B", "A", "D"], 31.0)
+
+        cycle = nx_app.greedy_tsp(self.DG2, source="D")
+        cost = sum(self.DG2[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, ["D", "C", "B", "A", "D"], 78.0)
+
+        cycle = nx_app.greedy_tsp(self.UG, source="D")
+        cost = sum(self.UG[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, ["D", "C", "B", "A", "D"], 33.0)
+
+        cycle = nx_app.greedy_tsp(self.UG2, source="D")
+        cost = sum(self.UG2[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, ["D", "C", "A", "B", "D"], 27.0)
+
+    def test_not_complete_graph(self):
+        pytest.raises(nx.NetworkXError, nx_app.greedy_tsp, self.incompleteUG)
+        pytest.raises(nx.NetworkXError, nx_app.greedy_tsp, self.incompleteDG)
+
+    def test_not_weighted_graph(self):
+        nx_app.greedy_tsp(self.unweightedUG)
+        nx_app.greedy_tsp(self.unweightedDG)
+
+    def test_two_nodes(self):
+        G = nx.Graph()
+        G.add_weighted_edges_from({(1, 2, 1)})
+        cycle = nx_app.greedy_tsp(G)
+        cost = sum(G[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, [1, 2, 1], 2)
+
+    def test_ignore_selfloops(self):
+        G = nx.complete_graph(5)
+        G.add_edge(3, 3)
+        cycle = nx_app.greedy_tsp(G)
+        assert len(cycle) - 1 == len(G) == len(set(cycle))
+
+
+class TestSimulatedAnnealingTSP(TestBase):
+    tsp = staticmethod(nx_app.simulated_annealing_tsp)
+
+    def test_simulated_annealing_directed(self):
+        cycle = self.tsp(self.DG, "greedy", source="D", seed=42)
+        cost = sum(self.DG[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, self.DG_cycle, self.DG_cost)
+
+        initial_sol = ["D", "B", "A", "C", "D"]
+        cycle = self.tsp(self.DG, initial_sol, source="D", seed=42)
+        cost = sum(self.DG[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, self.DG_cycle, self.DG_cost)
+
+        initial_sol = ["D", "A", "C", "B", "D"]
+        cycle = self.tsp(self.DG, initial_sol, move="1-0", source="D", seed=42)
+        cost = sum(self.DG[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, self.DG_cycle, self.DG_cost)
+
+        cycle = self.tsp(self.DG2, "greedy", source="D", seed=42)
+        cost = sum(self.DG2[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, self.DG2_cycle, self.DG2_cost)
+
+        cycle = self.tsp(self.DG2, "greedy", move="1-0", source="D", seed=42)
+        cost = sum(self.DG2[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, self.DG2_cycle, self.DG2_cost)
+
+    def test_simulated_annealing_undirected(self):
+        cycle = self.tsp(self.UG, "greedy", source="D", seed=42)
+        cost = sum(self.UG[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, self.UG_cycle, self.UG_cost)
+
+        cycle = self.tsp(self.UG2, "greedy", source="D", seed=42)
+        cost = sum(self.UG2[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_symmetric_solution(cycle, cost, self.UG2_cycle, self.UG2_cost)
+
+        cycle = self.tsp(self.UG2, "greedy", move="1-0", source="D", seed=42)
+        cost = sum(self.UG2[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_symmetric_solution(cycle, cost, self.UG2_cycle, self.UG2_cost)
+
+    def test_error_on_input_order_mistake(self):
+        # see issue #4846 https://github.com/networkx/networkx/issues/4846
+        pytest.raises(TypeError, self.tsp, self.UG, weight="weight")
+        pytest.raises(nx.NetworkXError, self.tsp, self.UG, "weight")
+
+    def test_not_complete_graph(self):
+        pytest.raises(nx.NetworkXError, self.tsp, self.incompleteUG, "greedy", source=0)
+        pytest.raises(nx.NetworkXError, self.tsp, self.incompleteDG, "greedy", source=0)
+
+    def test_ignore_selfloops(self):
+        G = nx.complete_graph(5)
+        G.add_edge(3, 3)
+        cycle = self.tsp(G, "greedy")
+        assert len(cycle) - 1 == len(G) == len(set(cycle))
+
+    def test_not_weighted_graph(self):
+        self.tsp(self.unweightedUG, "greedy")
+        self.tsp(self.unweightedDG, "greedy")
+
+    def test_two_nodes(self):
+        G = nx.Graph()
+        G.add_weighted_edges_from({(1, 2, 1)})
+
+        cycle = self.tsp(G, "greedy", source=1, seed=42)
+        cost = sum(G[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, [1, 2, 1], 2)
+
+        cycle = self.tsp(G, [1, 2, 1], source=1, seed=42)
+        cost = sum(G[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        validate_solution(cycle, cost, [1, 2, 1], 2)
+
+    def test_failure_of_costs_too_high_when_iterations_low(self):
+        # Simulated Annealing Version:
+        # set number of moves low and alpha high
+        cycle = self.tsp(
+            self.DG2, "greedy", source="D", move="1-0", alpha=1, N_inner=1, seed=42
+        )
+        cost = sum(self.DG2[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        print(cycle, cost)
+        assert cost > self.DG2_cost
+
+        # Try with an incorrect initial guess
+        initial_sol = ["D", "A", "B", "C", "D"]
+        cycle = self.tsp(
+            self.DG,
+            initial_sol,
+            source="D",
+            move="1-0",
+            alpha=0.1,
+            N_inner=1,
+            max_iterations=1,
+            seed=42,
+        )
+        cost = sum(self.DG[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        print(cycle, cost)
+        assert cost > self.DG_cost
+
+
+class TestThresholdAcceptingTSP(TestSimulatedAnnealingTSP):
+    tsp = staticmethod(nx_app.threshold_accepting_tsp)
+
+    def test_failure_of_costs_too_high_when_iterations_low(self):
+        # Threshold Version:
+        # set number of moves low and number of iterations low
+        cycle = self.tsp(
+            self.DG2,
+            "greedy",
+            source="D",
+            move="1-0",
+            N_inner=1,
+            max_iterations=1,
+            seed=4,
+        )
+        cost = sum(self.DG2[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        assert cost > self.DG2_cost
+
+        # set threshold too low
+        initial_sol = ["D", "A", "B", "C", "D"]
+        cycle = self.tsp(
+            self.DG, initial_sol, source="D", move="1-0", threshold=-3, seed=42
+        )
+        cost = sum(self.DG[n][nbr]["weight"] for n, nbr in pairwise(cycle))
+        assert cost > self.DG_cost
+
+
+# Tests for function traveling_salesman_problem
+def test_TSP_method():
+    G = nx.cycle_graph(9)
+    G[4][5]["weight"] = 10
+
+    def my_tsp_method(G, weight):
+        return nx_app.simulated_annealing_tsp(G, "greedy", weight, source=4, seed=1)
+
+    path = nx_app.traveling_salesman_problem(G, method=my_tsp_method, cycle=False)
+    print(path)
+    assert path == [4, 3, 2, 1, 0, 8, 7, 6, 5]
+
+
+def test_TSP_unweighted():
+    G = nx.cycle_graph(9)
+    path = nx_app.traveling_salesman_problem(G, nodes=[3, 6], cycle=False)
+    assert path in ([3, 4, 5, 6], [6, 5, 4, 3])
+
+    cycle = nx_app.traveling_salesman_problem(G, nodes=[3, 6])
+    assert cycle in ([3, 4, 5, 6, 5, 4, 3], [6, 5, 4, 3, 4, 5, 6])
+
+
+def test_TSP_weighted():
+    G = nx.cycle_graph(9)
+    G[0][1]["weight"] = 2
+    G[1][2]["weight"] = 2
+    G[2][3]["weight"] = 2
+    G[3][4]["weight"] = 4
+    G[4][5]["weight"] = 5
+    G[5][6]["weight"] = 4
+    G[6][7]["weight"] = 2
+    G[7][8]["weight"] = 2
+    G[8][0]["weight"] = 2
+    tsp = nx_app.traveling_salesman_problem
+
+    # path between 3 and 6
+    expected_paths = ([3, 2, 1, 0, 8, 7, 6], [6, 7, 8, 0, 1, 2, 3])
+    # cycle between 3 and 6
+    expected_cycles = (
+        [3, 2, 1, 0, 8, 7, 6, 7, 8, 0, 1, 2, 3],
+        [6, 7, 8, 0, 1, 2, 3, 2, 1, 0, 8, 7, 6],
+    )
+    # path through all nodes
+    expected_tourpaths = ([5, 6, 7, 8, 0, 1, 2, 3, 4], [4, 3, 2, 1, 0, 8, 7, 6, 5])
+
+    # Check default method
+    cycle = tsp(G, nodes=[3, 6], weight="weight")
+    assert cycle in expected_cycles
+
+    path = tsp(G, nodes=[3, 6], weight="weight", cycle=False)
+    assert path in expected_paths
+
+    tourpath = tsp(G, weight="weight", cycle=False)
+    assert tourpath in expected_tourpaths
+
+    # Check all methods
+    methods = [
+        nx_app.christofides,
+        nx_app.greedy_tsp,
+        lambda G, wt: nx_app.simulated_annealing_tsp(G, "greedy", weight=wt),
+        lambda G, wt: nx_app.threshold_accepting_tsp(G, "greedy", weight=wt),
+    ]
+    for method in methods:
+        cycle = tsp(G, nodes=[3, 6], weight="weight", method=method)
+        assert cycle in expected_cycles
+
+        path = tsp(G, nodes=[3, 6], weight="weight", method=method, cycle=False)
+        assert path in expected_paths
+
+        tourpath = tsp(G, weight="weight", method=method, cycle=False)
+        assert tourpath in expected_tourpaths
+
+
+def test_TSP_incomplete_graph_short_path():
+    G = nx.cycle_graph(9)
+    G.add_edges_from([(4, 9), (9, 10), (10, 11), (11, 0)])
+    G[4][5]["weight"] = 5
+
+    cycle = nx_app.traveling_salesman_problem(G)
+    print(cycle)
+    assert len(cycle) == 17 and len(set(cycle)) == 12
+
+    # make sure that cutting one edge out of complete graph formulation
+    # cuts out many edges out of the path of the TSP
+    path = nx_app.traveling_salesman_problem(G, cycle=False)
+    print(path)
+    assert len(path) == 13 and len(set(path)) == 12
+
+
+def test_held_karp_ascent():
+    """
+    Test the Held-Karp relaxation with the ascent method
+    """
+    import networkx.algorithms.approximation.traveling_salesman as tsp
+
+    np = pytest.importorskip("numpy")
+    pytest.importorskip("scipy")
+
+    # Adjacency matrix from page 1153 of the 1970 Held and Karp paper
+    # which have been edited to be directional, but also symmetric
+    G_array = np.array(
+        [
+            [0, 97, 60, 73, 17, 52],
+            [97, 0, 41, 52, 90, 30],
+            [60, 41, 0, 21, 35, 41],
+            [73, 52, 21, 0, 95, 46],
+            [17, 90, 35, 95, 0, 81],
+            [52, 30, 41, 46, 81, 0],
+        ]
+    )
+
+    solution_edges = [(1, 3), (2, 4), (3, 2), (4, 0), (5, 1), (0, 5)]
+
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+    opt_hk, z_star = tsp.held_karp_ascent(G)
+
+    # Check that the optimal weights are the same
+    assert round(opt_hk, 2) == 207.00
+    # Check that the z_stars are the same
+    solution = nx.DiGraph()
+    solution.add_edges_from(solution_edges)
+    assert nx.utils.edges_equal(z_star.edges, solution.edges)
+
+
+def test_ascent_fractional_solution():
+    """
+    Test the ascent method using a modified version of Figure 2 on page 1140
+    in 'The Traveling Salesman Problem and Minimum Spanning Trees' by Held and
+    Karp
+    """
+    import networkx.algorithms.approximation.traveling_salesman as tsp
+
+    np = pytest.importorskip("numpy")
+    pytest.importorskip("scipy")
+
+    # This version of Figure 2 has all of the edge weights multiplied by 100
+    # and is a complete directed graph with infinite edge weights for the
+    # edges not listed in the original graph
+    G_array = np.array(
+        [
+            [0, 100, 100, 100000, 100000, 1],
+            [100, 0, 100, 100000, 1, 100000],
+            [100, 100, 0, 1, 100000, 100000],
+            [100000, 100000, 1, 0, 100, 100],
+            [100000, 1, 100000, 100, 0, 100],
+            [1, 100000, 100000, 100, 100, 0],
+        ]
+    )
+
+    solution_z_star = {
+        (0, 1): 5 / 12,
+        (0, 2): 5 / 12,
+        (0, 5): 5 / 6,
+        (1, 0): 5 / 12,
+        (1, 2): 1 / 3,
+        (1, 4): 5 / 6,
+        (2, 0): 5 / 12,
+        (2, 1): 1 / 3,
+        (2, 3): 5 / 6,
+        (3, 2): 5 / 6,
+        (3, 4): 1 / 3,
+        (3, 5): 1 / 2,
+        (4, 1): 5 / 6,
+        (4, 3): 1 / 3,
+        (4, 5): 1 / 2,
+        (5, 0): 5 / 6,
+        (5, 3): 1 / 2,
+        (5, 4): 1 / 2,
+    }
+
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+    opt_hk, z_star = tsp.held_karp_ascent(G)
+
+    # Check that the optimal weights are the same
+    assert round(opt_hk, 2) == 303.00
+    # Check that the z_stars are the same
+    assert {key: round(z_star[key], 4) for key in z_star} == {
+        key: round(solution_z_star[key], 4) for key in solution_z_star
+    }
+
+
+def test_ascent_method_asymmetric():
+    """
+    Tests the ascent method using a truly asymmetric graph for which the
+    solution has been brute forced
+    """
+    import networkx.algorithms.approximation.traveling_salesman as tsp
+
+    np = pytest.importorskip("numpy")
+    pytest.importorskip("scipy")
+
+    G_array = np.array(
+        [
+            [0, 26, 63, 59, 69, 31, 41],
+            [62, 0, 91, 53, 75, 87, 47],
+            [47, 82, 0, 90, 15, 9, 18],
+            [68, 19, 5, 0, 58, 34, 93],
+            [11, 58, 53, 55, 0, 61, 79],
+            [88, 75, 13, 76, 98, 0, 40],
+            [41, 61, 55, 88, 46, 45, 0],
+        ]
+    )
+
+    solution_edges = [(0, 1), (1, 3), (3, 2), (2, 5), (5, 6), (4, 0), (6, 4)]
+
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+    opt_hk, z_star = tsp.held_karp_ascent(G)
+
+    # Check that the optimal weights are the same
+    assert round(opt_hk, 2) == 190.00
+    # Check that the z_stars match.
+    solution = nx.DiGraph()
+    solution.add_edges_from(solution_edges)
+    assert nx.utils.edges_equal(z_star.edges, solution.edges)
+
+
+def test_ascent_method_asymmetric_2():
+    """
+    Tests the ascent method using a truly asymmetric graph for which the
+    solution has been brute forced
+    """
+    import networkx.algorithms.approximation.traveling_salesman as tsp
+
+    np = pytest.importorskip("numpy")
+    pytest.importorskip("scipy")
+
+    G_array = np.array(
+        [
+            [0, 45, 39, 92, 29, 31],
+            [72, 0, 4, 12, 21, 60],
+            [81, 6, 0, 98, 70, 53],
+            [49, 71, 59, 0, 98, 94],
+            [74, 95, 24, 43, 0, 47],
+            [56, 43, 3, 65, 22, 0],
+        ]
+    )
+
+    solution_edges = [(0, 5), (5, 4), (1, 3), (3, 0), (2, 1), (4, 2)]
+
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+    opt_hk, z_star = tsp.held_karp_ascent(G)
+
+    # Check that the optimal weights are the same
+    assert round(opt_hk, 2) == 144.00
+    # Check that the z_stars match.
+    solution = nx.DiGraph()
+    solution.add_edges_from(solution_edges)
+    assert nx.utils.edges_equal(z_star.edges, solution.edges)
+
+
+def test_held_karp_ascent_asymmetric_3():
+    """
+    Tests the ascent method using a truly asymmetric graph with a fractional
+    solution for which the solution has been brute forced.
+
+    In this graph their are two different optimal, integral solutions (which
+    are also the overall atsp solutions) to the Held Karp relaxation. However,
+    this particular graph has two different tours of optimal value and the
+    possible solutions in the held_karp_ascent function are not stored in an
+    ordered data structure.
+    """
+    import networkx.algorithms.approximation.traveling_salesman as tsp
+
+    np = pytest.importorskip("numpy")
+    pytest.importorskip("scipy")
+
+    G_array = np.array(
+        [
+            [0, 1, 5, 2, 7, 4],
+            [7, 0, 7, 7, 1, 4],
+            [4, 7, 0, 9, 2, 1],
+            [7, 2, 7, 0, 4, 4],
+            [5, 5, 4, 4, 0, 3],
+            [3, 9, 1, 3, 4, 0],
+        ]
+    )
+
+    solution1_edges = [(0, 3), (1, 4), (2, 5), (3, 1), (4, 2), (5, 0)]
+
+    solution2_edges = [(0, 3), (3, 1), (1, 4), (4, 5), (2, 0), (5, 2)]
+
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+    opt_hk, z_star = tsp.held_karp_ascent(G)
+
+    assert round(opt_hk, 2) == 13.00
+    # Check that the z_stars are the same
+    solution1 = nx.DiGraph()
+    solution1.add_edges_from(solution1_edges)
+    solution2 = nx.DiGraph()
+    solution2.add_edges_from(solution2_edges)
+    assert nx.utils.edges_equal(z_star.edges, solution1.edges) or nx.utils.edges_equal(
+        z_star.edges, solution2.edges
+    )
+
+
+def test_held_karp_ascent_fractional_asymmetric():
+    """
+    Tests the ascent method using a truly asymmetric graph with a fractional
+    solution for which the solution has been brute forced
+    """
+    import networkx.algorithms.approximation.traveling_salesman as tsp
+
+    np = pytest.importorskip("numpy")
+    pytest.importorskip("scipy")
+
+    G_array = np.array(
+        [
+            [0, 100, 150, 100000, 100000, 1],
+            [150, 0, 100, 100000, 1, 100000],
+            [100, 150, 0, 1, 100000, 100000],
+            [100000, 100000, 1, 0, 150, 100],
+            [100000, 2, 100000, 100, 0, 150],
+            [2, 100000, 100000, 150, 100, 0],
+        ]
+    )
+
+    solution_z_star = {
+        (0, 1): 5 / 12,
+        (0, 2): 5 / 12,
+        (0, 5): 5 / 6,
+        (1, 0): 5 / 12,
+        (1, 2): 5 / 12,
+        (1, 4): 5 / 6,
+        (2, 0): 5 / 12,
+        (2, 1): 5 / 12,
+        (2, 3): 5 / 6,
+        (3, 2): 5 / 6,
+        (3, 4): 5 / 12,
+        (3, 5): 5 / 12,
+        (4, 1): 5 / 6,
+        (4, 3): 5 / 12,
+        (4, 5): 5 / 12,
+        (5, 0): 5 / 6,
+        (5, 3): 5 / 12,
+        (5, 4): 5 / 12,
+    }
+
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+    opt_hk, z_star = tsp.held_karp_ascent(G)
+
+    # Check that the optimal weights are the same
+    assert round(opt_hk, 2) == 304.00
+    # Check that the z_stars are the same
+    assert {key: round(z_star[key], 4) for key in z_star} == {
+        key: round(solution_z_star[key], 4) for key in solution_z_star
+    }
+
+
+def test_spanning_tree_distribution():
+    """
+    Test that we can create an exponential distribution of spanning trees such
+    that the probability of each tree is proportional to the product of edge
+    weights.
+
+    Results of this test have been confirmed with hypothesis testing from the
+    created distribution.
+
+    This test uses the symmetric, fractional Held Karp solution.
+    """
+    import networkx.algorithms.approximation.traveling_salesman as tsp
+
+    pytest.importorskip("numpy")
+    pytest.importorskip("scipy")
+
+    z_star = {
+        (0, 1): 5 / 12,
+        (0, 2): 5 / 12,
+        (0, 5): 5 / 6,
+        (1, 0): 5 / 12,
+        (1, 2): 1 / 3,
+        (1, 4): 5 / 6,
+        (2, 0): 5 / 12,
+        (2, 1): 1 / 3,
+        (2, 3): 5 / 6,
+        (3, 2): 5 / 6,
+        (3, 4): 1 / 3,
+        (3, 5): 1 / 2,
+        (4, 1): 5 / 6,
+        (4, 3): 1 / 3,
+        (4, 5): 1 / 2,
+        (5, 0): 5 / 6,
+        (5, 3): 1 / 2,
+        (5, 4): 1 / 2,
+    }
+
+    solution_gamma = {
+        (0, 1): -0.6383,
+        (0, 2): -0.6827,
+        (0, 5): 0,
+        (1, 2): -1.0781,
+        (1, 4): 0,
+        (2, 3): 0,
+        (5, 3): -0.2820,
+        (5, 4): -0.3327,
+        (4, 3): -0.9927,
+    }
+
+    # The undirected support of z_star
+    G = nx.MultiGraph()
+    for u, v in z_star:
+        if (u, v) in G.edges or (v, u) in G.edges:
+            continue
+        G.add_edge(u, v)
+
+    gamma = tsp.spanning_tree_distribution(G, z_star)
+
+    assert {key: round(gamma[key], 4) for key in gamma} == solution_gamma
+
+
+def test_asadpour_tsp():
+    """
+    Test the complete asadpour tsp algorithm with the fractional, symmetric
+    Held Karp solution. This test also uses an incomplete graph as input.
+    """
+    # This version of Figure 2 has all of the edge weights multiplied by 100
+    # and the 0 weight edges have a weight of 1.
+    pytest.importorskip("numpy")
+    pytest.importorskip("scipy")
+
+    edge_list = [
+        (0, 1, 100),
+        (0, 2, 100),
+        (0, 5, 1),
+        (1, 2, 100),
+        (1, 4, 1),
+        (2, 3, 1),
+        (3, 4, 100),
+        (3, 5, 100),
+        (4, 5, 100),
+        (1, 0, 100),
+        (2, 0, 100),
+        (5, 0, 1),
+        (2, 1, 100),
+        (4, 1, 1),
+        (3, 2, 1),
+        (4, 3, 100),
+        (5, 3, 100),
+        (5, 4, 100),
+    ]
+
+    G = nx.DiGraph()
+    G.add_weighted_edges_from(edge_list)
+
+    def fixed_asadpour(G, weight):
+        return nx_app.asadpour_atsp(G, weight, 19)
+
+    tour = nx_app.traveling_salesman_problem(G, weight="weight", method=fixed_asadpour)
+
+    # Check that the returned list is a valid tour. Because this is an
+    # incomplete graph, the conditions are not as strict. We need the tour to
+    #
+    #   Start and end at the same node
+    #   Pass through every vertex at least once
+    #   Have a total cost at most ln(6) / ln(ln(6)) = 3.0723 times the optimal
+    #
+    # For the second condition it is possible to have the tour pass through the
+    # same vertex more then. Imagine that the tour on the complete version takes
+    # an edge not in the original graph. In the output this is substituted with
+    # the shortest path between those vertices, allowing vertices to appear more
+    # than once.
+    #
+    # However, we are using a fixed random number generator so we know what the
+    # expected tour is.
+    expected_tours = [[1, 4, 5, 0, 2, 3, 2, 1], [3, 2, 0, 1, 4, 5, 3]]
+
+    assert tour in expected_tours
+
+
+def test_asadpour_real_world():
+    """
+    This test uses airline prices between the six largest cities in the US.
+
+        * New York City -> JFK
+        * Los Angeles -> LAX
+        * Chicago -> ORD
+        * Houston -> IAH
+        * Phoenix -> PHX
+        * Philadelphia -> PHL
+
+    Flight prices from August 2021 using Delta or American airlines to get
+    nonstop flight. The brute force solution found the optimal tour to cost $872
+
+    This test also uses the `source` keyword argument to ensure that the tour
+    always starts at city 0.
+    """
+    np = pytest.importorskip("numpy")
+    pytest.importorskip("scipy")
+
+    G_array = np.array(
+        [
+            # JFK  LAX  ORD  IAH  PHX  PHL
+            [0, 243, 199, 208, 169, 183],  # JFK
+            [277, 0, 217, 123, 127, 252],  # LAX
+            [297, 197, 0, 197, 123, 177],  # ORD
+            [303, 169, 197, 0, 117, 117],  # IAH
+            [257, 127, 160, 117, 0, 319],  # PHX
+            [183, 332, 217, 117, 319, 0],  # PHL
+        ]
+    )
+
+    node_map = {0: "JFK", 1: "LAX", 2: "ORD", 3: "IAH", 4: "PHX", 5: "PHL"}
+
+    expected_tours = [
+        ["JFK", "LAX", "PHX", "ORD", "IAH", "PHL", "JFK"],
+        ["JFK", "ORD", "PHX", "LAX", "IAH", "PHL", "JFK"],
+    ]
+
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+    nx.relabel_nodes(G, node_map, copy=False)
+
+    def fixed_asadpour(G, weight):
+        return nx_app.asadpour_atsp(G, weight, 37, source="JFK")
+
+    tour = nx_app.traveling_salesman_problem(G, weight="weight", method=fixed_asadpour)
+
+    assert tour in expected_tours
+
+
+def test_asadpour_real_world_path():
+    """
+    This test uses airline prices between the six largest cities in the US. This
+    time using a path, not a cycle.
+
+        * New York City -> JFK
+        * Los Angeles -> LAX
+        * Chicago -> ORD
+        * Houston -> IAH
+        * Phoenix -> PHX
+        * Philadelphia -> PHL
+
+    Flight prices from August 2021 using Delta or American airlines to get
+    nonstop flight. The brute force solution found the optimal tour to cost $872
+    """
+    np = pytest.importorskip("numpy")
+    pytest.importorskip("scipy")
+
+    G_array = np.array(
+        [
+            # JFK  LAX  ORD  IAH  PHX  PHL
+            [0, 243, 199, 208, 169, 183],  # JFK
+            [277, 0, 217, 123, 127, 252],  # LAX
+            [297, 197, 0, 197, 123, 177],  # ORD
+            [303, 169, 197, 0, 117, 117],  # IAH
+            [257, 127, 160, 117, 0, 319],  # PHX
+            [183, 332, 217, 117, 319, 0],  # PHL
+        ]
+    )
+
+    node_map = {0: "JFK", 1: "LAX", 2: "ORD", 3: "IAH", 4: "PHX", 5: "PHL"}
+
+    expected_paths = [
+        ["ORD", "PHX", "LAX", "IAH", "PHL", "JFK"],
+        ["JFK", "PHL", "IAH", "ORD", "PHX", "LAX"],
+    ]
+
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+    nx.relabel_nodes(G, node_map, copy=False)
+
+    def fixed_asadpour(G, weight):
+        return nx_app.asadpour_atsp(G, weight, 56)
+
+    path = nx_app.traveling_salesman_problem(
+        G, weight="weight", cycle=False, method=fixed_asadpour
+    )
+
+    assert path in expected_paths
+
+
+def test_asadpour_disconnected_graph():
+    """
+    Test that the proper exception is raised when asadpour_atsp is given an
+    disconnected graph.
+    """
+
+    G = nx.complete_graph(4, create_using=nx.DiGraph)
+    # have to set edge weights so that if the exception is not raised, the
+    # function will complete and we will fail the test
+    nx.set_edge_attributes(G, 1, "weight")
+    G.add_node(5)
+
+    pytest.raises(nx.NetworkXError, nx_app.asadpour_atsp, G)
+
+
+def test_asadpour_incomplete_graph():
+    """
+    Test that the proper exception is raised when asadpour_atsp is given an
+    incomplete graph
+    """
+
+    G = nx.complete_graph(4, create_using=nx.DiGraph)
+    # have to set edge weights so that if the exception is not raised, the
+    # function will complete and we will fail the test
+    nx.set_edge_attributes(G, 1, "weight")
+    G.remove_edge(0, 1)
+
+    pytest.raises(nx.NetworkXError, nx_app.asadpour_atsp, G)
+
+
+def test_asadpour_empty_graph():
+    """
+    Test the asadpour_atsp function with an empty graph
+    """
+    G = nx.DiGraph()
+
+    pytest.raises(nx.NetworkXError, nx_app.asadpour_atsp, G)
+
+
+@pytest.mark.slow
+def test_asadpour_integral_held_karp():
+    """
+    This test uses an integral held karp solution and the held karp function
+    will return a graph rather than a dict, bypassing most of the asadpour
+    algorithm.
+
+    At first glance, this test probably doesn't look like it ensures that we
+    skip the rest of the asadpour algorithm, but it does. We are not fixing a
+    see for the random number generator, so if we sample any spanning trees
+    the approximation would be different basically every time this test is
+    executed but it is not since held karp is deterministic and we do not
+    reach the portion of the code with the dependence on random numbers.
+    """
+    np = pytest.importorskip("numpy")
+
+    G_array = np.array(
+        [
+            [0, 26, 63, 59, 69, 31, 41],
+            [62, 0, 91, 53, 75, 87, 47],
+            [47, 82, 0, 90, 15, 9, 18],
+            [68, 19, 5, 0, 58, 34, 93],
+            [11, 58, 53, 55, 0, 61, 79],
+            [88, 75, 13, 76, 98, 0, 40],
+            [41, 61, 55, 88, 46, 45, 0],
+        ]
+    )
+
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+
+    for _ in range(2):
+        tour = nx_app.traveling_salesman_problem(G, method=nx_app.asadpour_atsp)
+
+        assert [1, 3, 2, 5, 2, 6, 4, 0, 1] == tour
+
+
+def test_directed_tsp_impossible():
+    """
+    Test the asadpour algorithm with a graph without a hamiltonian circuit
+    """
+    pytest.importorskip("numpy")
+
+    # In this graph, once we leave node 0 we cannot return
+    edges = [
+        (0, 1, 10),
+        (0, 2, 11),
+        (0, 3, 12),
+        (1, 2, 4),
+        (1, 3, 6),
+        (2, 1, 3),
+        (2, 3, 2),
+        (3, 1, 5),
+        (3, 2, 1),
+    ]
+
+    G = nx.DiGraph()
+    G.add_weighted_edges_from(edges)
+
+    pytest.raises(nx.NetworkXError, nx_app.traveling_salesman_problem, G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_treewidth.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_treewidth.py
new file mode 100644
index 0000000..37619db
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_treewidth.py
@@ -0,0 +1,274 @@
+import itertools
+
+import networkx as nx
+from networkx.algorithms.approximation import (
+    treewidth_min_degree,
+    treewidth_min_fill_in,
+)
+from networkx.algorithms.approximation.treewidth import (
+    MinDegreeHeuristic,
+    min_fill_in_heuristic,
+)
+
+
+def is_tree_decomp(graph, decomp):
+    """Check if the given tree decomposition is valid."""
+    for x in graph.nodes():
+        appear_once = False
+        for bag in decomp.nodes():
+            if x in bag:
+                appear_once = True
+                break
+        assert appear_once
+
+    # Check if each connected pair of nodes are at least once together in a bag
+    for (x, y) in graph.edges():
+        appear_together = False
+        for bag in decomp.nodes():
+            if x in bag and y in bag:
+                appear_together = True
+                break
+        assert appear_together
+
+    # Check if the nodes associated with vertex v form a connected subset of T
+    for v in graph.nodes():
+        subset = []
+        for bag in decomp.nodes():
+            if v in bag:
+                subset.append(bag)
+        sub_graph = decomp.subgraph(subset)
+        assert nx.is_connected(sub_graph)
+
+
+class TestTreewidthMinDegree:
+    """Unit tests for the min_degree function"""
+
+    @classmethod
+    def setup_class(cls):
+        """Setup for different kinds of trees"""
+        cls.complete = nx.Graph()
+        cls.complete.add_edge(1, 2)
+        cls.complete.add_edge(2, 3)
+        cls.complete.add_edge(1, 3)
+
+        cls.small_tree = nx.Graph()
+        cls.small_tree.add_edge(1, 3)
+        cls.small_tree.add_edge(4, 3)
+        cls.small_tree.add_edge(2, 3)
+        cls.small_tree.add_edge(3, 5)
+        cls.small_tree.add_edge(5, 6)
+        cls.small_tree.add_edge(5, 7)
+        cls.small_tree.add_edge(6, 7)
+
+        cls.deterministic_graph = nx.Graph()
+        cls.deterministic_graph.add_edge(0, 1)  # deg(0) = 1
+
+        cls.deterministic_graph.add_edge(1, 2)  # deg(1) = 2
+
+        cls.deterministic_graph.add_edge(2, 3)
+        cls.deterministic_graph.add_edge(2, 4)  # deg(2) = 3
+
+        cls.deterministic_graph.add_edge(3, 4)
+        cls.deterministic_graph.add_edge(3, 5)
+        cls.deterministic_graph.add_edge(3, 6)  # deg(3) = 4
+
+        cls.deterministic_graph.add_edge(4, 5)
+        cls.deterministic_graph.add_edge(4, 6)
+        cls.deterministic_graph.add_edge(4, 7)  # deg(4) = 5
+
+        cls.deterministic_graph.add_edge(5, 6)
+        cls.deterministic_graph.add_edge(5, 7)
+        cls.deterministic_graph.add_edge(5, 8)
+        cls.deterministic_graph.add_edge(5, 9)  # deg(5) = 6
+
+        cls.deterministic_graph.add_edge(6, 7)
+        cls.deterministic_graph.add_edge(6, 8)
+        cls.deterministic_graph.add_edge(6, 9)  # deg(6) = 6
+
+        cls.deterministic_graph.add_edge(7, 8)
+        cls.deterministic_graph.add_edge(7, 9)  # deg(7) = 5
+
+        cls.deterministic_graph.add_edge(8, 9)  # deg(8) = 4
+
+    def test_petersen_graph(self):
+        """Test Petersen graph tree decomposition result"""
+        G = nx.petersen_graph()
+        _, decomp = treewidth_min_degree(G)
+        is_tree_decomp(G, decomp)
+
+    def test_small_tree_treewidth(self):
+        """Test small tree
+
+        Test if the computed treewidth of the known self.small_tree is 2.
+        As we know which value we can expect from our heuristic, values other
+        than two are regressions
+        """
+        G = self.small_tree
+        # the order of removal should be [1,2,4]3[5,6,7]
+        # (with [] denoting any order of the containing nodes)
+        # resulting in treewidth 2 for the heuristic
+        treewidth, _ = treewidth_min_fill_in(G)
+        assert treewidth == 2
+
+    def test_heuristic_abort(self):
+        """Test heuristic abort condition for fully connected graph"""
+        graph = {}
+        for u in self.complete:
+            graph[u] = set()
+            for v in self.complete[u]:
+                if u != v:  # ignore self-loop
+                    graph[u].add(v)
+
+        deg_heuristic = MinDegreeHeuristic(graph)
+        node = deg_heuristic.best_node(graph)
+        if node is None:
+            pass
+        else:
+            assert False
+
+    def test_empty_graph(self):
+        """Test empty graph"""
+        G = nx.Graph()
+        _, _ = treewidth_min_degree(G)
+
+    def test_two_component_graph(self):
+        """Test empty graph"""
+        G = nx.Graph()
+        G.add_node(1)
+        G.add_node(2)
+        treewidth, _ = treewidth_min_degree(G)
+        assert treewidth == 0
+
+    def test_heuristic_first_steps(self):
+        """Test first steps of min_degree heuristic"""
+        graph = {
+            n: set(self.deterministic_graph[n]) - {n} for n in self.deterministic_graph
+        }
+        deg_heuristic = MinDegreeHeuristic(graph)
+        elim_node = deg_heuristic.best_node(graph)
+        print(f"Graph {graph}:")
+        steps = []
+
+        while elim_node is not None:
+            print(f"Removing {elim_node}:")
+            steps.append(elim_node)
+            nbrs = graph[elim_node]
+
+            for u, v in itertools.permutations(nbrs, 2):
+                if v not in graph[u]:
+                    graph[u].add(v)
+
+            for u in graph:
+                if elim_node in graph[u]:
+                    graph[u].remove(elim_node)
+
+            del graph[elim_node]
+            print(f"Graph {graph}:")
+            elim_node = deg_heuristic.best_node(graph)
+
+        # check only the first 5 elements for equality
+        assert steps[:5] == [0, 1, 2, 3, 4]
+
+
+class TestTreewidthMinFillIn:
+    """Unit tests for the treewidth_min_fill_in function."""
+
+    @classmethod
+    def setup_class(cls):
+        """Setup for different kinds of trees"""
+        cls.complete = nx.Graph()
+        cls.complete.add_edge(1, 2)
+        cls.complete.add_edge(2, 3)
+        cls.complete.add_edge(1, 3)
+
+        cls.small_tree = nx.Graph()
+        cls.small_tree.add_edge(1, 2)
+        cls.small_tree.add_edge(2, 3)
+        cls.small_tree.add_edge(3, 4)
+        cls.small_tree.add_edge(1, 4)
+        cls.small_tree.add_edge(2, 4)
+        cls.small_tree.add_edge(4, 5)
+        cls.small_tree.add_edge(5, 6)
+        cls.small_tree.add_edge(5, 7)
+        cls.small_tree.add_edge(6, 7)
+
+        cls.deterministic_graph = nx.Graph()
+        cls.deterministic_graph.add_edge(1, 2)
+        cls.deterministic_graph.add_edge(1, 3)
+        cls.deterministic_graph.add_edge(3, 4)
+        cls.deterministic_graph.add_edge(2, 4)
+        cls.deterministic_graph.add_edge(3, 5)
+        cls.deterministic_graph.add_edge(4, 5)
+        cls.deterministic_graph.add_edge(3, 6)
+        cls.deterministic_graph.add_edge(5, 6)
+
+    def test_petersen_graph(self):
+        """Test Petersen graph tree decomposition result"""
+        G = nx.petersen_graph()
+        _, decomp = treewidth_min_fill_in(G)
+        is_tree_decomp(G, decomp)
+
+    def test_small_tree_treewidth(self):
+        """Test if the computed treewidth of the known self.small_tree is 2"""
+        G = self.small_tree
+        # the order of removal should be [1,2,4]3[5,6,7]
+        # (with [] denoting any order of the containing nodes)
+        # resulting in treewidth 2 for the heuristic
+        treewidth, _ = treewidth_min_fill_in(G)
+        assert treewidth == 2
+
+    def test_heuristic_abort(self):
+        """Test if min_fill_in returns None for fully connected graph"""
+        graph = {}
+        for u in self.complete:
+            graph[u] = set()
+            for v in self.complete[u]:
+                if u != v:  # ignore self-loop
+                    graph[u].add(v)
+        next_node = min_fill_in_heuristic(graph)
+        if next_node is None:
+            pass
+        else:
+            assert False
+
+    def test_empty_graph(self):
+        """Test empty graph"""
+        G = nx.Graph()
+        _, _ = treewidth_min_fill_in(G)
+
+    def test_two_component_graph(self):
+        """Test empty graph"""
+        G = nx.Graph()
+        G.add_node(1)
+        G.add_node(2)
+        treewidth, _ = treewidth_min_fill_in(G)
+        assert treewidth == 0
+
+    def test_heuristic_first_steps(self):
+        """Test first steps of min_fill_in heuristic"""
+        graph = {
+            n: set(self.deterministic_graph[n]) - {n} for n in self.deterministic_graph
+        }
+        print(f"Graph {graph}:")
+        elim_node = min_fill_in_heuristic(graph)
+        steps = []
+
+        while elim_node is not None:
+            print(f"Removing {elim_node}:")
+            steps.append(elim_node)
+            nbrs = graph[elim_node]
+
+            for u, v in itertools.permutations(nbrs, 2):
+                if v not in graph[u]:
+                    graph[u].add(v)
+
+            for u in graph:
+                if elim_node in graph[u]:
+                    graph[u].remove(elim_node)
+
+            del graph[elim_node]
+            print(f"Graph {graph}:")
+            elim_node = min_fill_in_heuristic(graph)
+
+        # check only the first 2 elements for equality
+        assert steps[:2] == [6, 5]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_vertex_cover.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_vertex_cover.py
new file mode 100644
index 0000000..5cc5a38
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/tests/test_vertex_cover.py
@@ -0,0 +1,68 @@
+import networkx as nx
+from networkx.algorithms.approximation import min_weighted_vertex_cover
+
+
+def is_cover(G, node_cover):
+    return all({u, v} & node_cover for u, v in G.edges())
+
+
+class TestMWVC:
+    """Unit tests for the approximate minimum weighted vertex cover
+    function,
+    :func:`~networkx.algorithms.approximation.vertex_cover.min_weighted_vertex_cover`.
+
+    """
+
+    def test_unweighted_directed(self):
+        # Create a star graph in which half the nodes are directed in
+        # and half are directed out.
+        G = nx.DiGraph()
+        G.add_edges_from((0, v) for v in range(1, 26))
+        G.add_edges_from((v, 0) for v in range(26, 51))
+        cover = min_weighted_vertex_cover(G)
+        assert 1 == len(cover)
+        assert is_cover(G, cover)
+
+    def test_unweighted_undirected(self):
+        # create a simple star graph
+        size = 50
+        sg = nx.star_graph(size)
+        cover = min_weighted_vertex_cover(sg)
+        assert 1 == len(cover)
+        assert is_cover(sg, cover)
+
+    def test_weighted(self):
+        wg = nx.Graph()
+        wg.add_node(0, weight=10)
+        wg.add_node(1, weight=1)
+        wg.add_node(2, weight=1)
+        wg.add_node(3, weight=1)
+        wg.add_node(4, weight=1)
+
+        wg.add_edge(0, 1)
+        wg.add_edge(0, 2)
+        wg.add_edge(0, 3)
+        wg.add_edge(0, 4)
+
+        wg.add_edge(1, 2)
+        wg.add_edge(2, 3)
+        wg.add_edge(3, 4)
+        wg.add_edge(4, 1)
+
+        cover = min_weighted_vertex_cover(wg, weight="weight")
+        csum = sum(wg.nodes[node]["weight"] for node in cover)
+        assert 4 == csum
+        assert is_cover(wg, cover)
+
+    def test_unweighted_self_loop(self):
+        slg = nx.Graph()
+        slg.add_node(0)
+        slg.add_node(1)
+        slg.add_node(2)
+
+        slg.add_edge(0, 1)
+        slg.add_edge(2, 2)
+
+        cover = min_weighted_vertex_cover(slg)
+        assert 2 == len(cover)
+        assert is_cover(slg, cover)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/traveling_salesman.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/traveling_salesman.py
new file mode 100644
index 0000000..806c8b7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/traveling_salesman.py
@@ -0,0 +1,1434 @@
+"""
+=================================
+Travelling Salesman Problem (TSP)
+=================================
+
+Implementation of approximate algorithms
+for solving and approximating the TSP problem.
+
+Categories of algorithms which are implemented:
+
+- Christofides (provides a 3/2-approximation of TSP)
+- Greedy
+- Simulated Annealing (SA)
+- Threshold Accepting (TA)
+- Asadpour Asymmetric Traveling Salesman Algorithm
+
+The Travelling Salesman Problem tries to find, given the weight
+(distance) between all points where a salesman has to visit, the
+route so that:
+
+- The total distance (cost) which the salesman travels is minimized.
+- The salesman returns to the starting point.
+- Note that for a complete graph, the salesman visits each point once.
+
+The function `travelling_salesman_problem` allows for incomplete
+graphs by finding all-pairs shortest paths, effectively converting
+the problem to a complete graph problem. It calls one of the
+approximate methods on that problem and then converts the result
+back to the original graph using the previously found shortest paths.
+
+TSP is an NP-hard problem in combinatorial optimization,
+important in operations research and theoretical computer science.
+
+http://en.wikipedia.org/wiki/Travelling_salesman_problem
+"""
+import math
+
+import networkx as nx
+from networkx.algorithms.tree.mst import random_spanning_tree
+from networkx.utils import not_implemented_for, pairwise, py_random_state
+
+__all__ = [
+    "traveling_salesman_problem",
+    "christofides",
+    "asadpour_atsp",
+    "greedy_tsp",
+    "simulated_annealing_tsp",
+    "threshold_accepting_tsp",
+]
+
+
+def swap_two_nodes(soln, seed):
+    """Swap two nodes in `soln` to give a neighbor solution.
+
+    Parameters
+    ----------
+    soln : list of nodes
+        Current cycle of nodes
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    list
+        The solution after move is applied. (A neighbor solution.)
+
+    Notes
+    -----
+        This function assumes that the incoming list `soln` is a cycle
+        (that the first and last element are the same) and also that
+        we don't want any move to change the first node in the list
+        (and thus not the last node either).
+
+        The input list is changed as well as returned. Make a copy if needed.
+
+    See Also
+    --------
+        move_one_node
+    """
+    a, b = seed.sample(range(1, len(soln) - 1), k=2)
+    soln[a], soln[b] = soln[b], soln[a]
+    return soln
+
+
+def move_one_node(soln, seed):
+    """Move one node to another position to give a neighbor solution.
+
+    The node to move and the position to move to are chosen randomly.
+    The first and last nodes are left untouched as soln must be a cycle
+    starting at that node.
+
+    Parameters
+    ----------
+    soln : list of nodes
+        Current cycle of nodes
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    list
+        The solution after move is applied. (A neighbor solution.)
+
+    Notes
+    -----
+        This function assumes that the incoming list `soln` is a cycle
+        (that the first and last element are the same) and also that
+        we don't want any move to change the first node in the list
+        (and thus not the last node either).
+
+        The input list is changed as well as returned. Make a copy if needed.
+
+    See Also
+    --------
+        swap_two_nodes
+    """
+    a, b = seed.sample(range(1, len(soln) - 1), k=2)
+    soln.insert(b, soln.pop(a))
+    return soln
+
+
+@not_implemented_for("directed")
+def christofides(G, weight="weight", tree=None):
+    """Approximate a solution of the traveling salesman problem
+
+    Compute a 3/2-approximation of the traveling salesman problem
+    in a complete undirected graph using Christofides [1]_ algorithm.
+
+    Parameters
+    ----------
+    G : Graph
+        `G` should be a complete weighted undirected graph.
+        The distance between all pairs of nodes should be included.
+
+    weight : string, optional (default="weight")
+        Edge data key corresponding to the edge weight.
+        If any edge does not have this attribute the weight is set to 1.
+
+    tree : NetworkX graph or None (default: None)
+        A minimum spanning tree of G. Or, if None, the minimum spanning
+        tree is computed using :func:`networkx.minimum_spanning_tree`
+
+    Returns
+    -------
+    list
+        List of nodes in `G` along a cycle with a 3/2-approximation of
+        the minimal Hamiltonian cycle.
+
+    References
+    ----------
+    .. [1] Christofides, Nicos. "Worst-case analysis of a new heuristic for
+       the travelling salesman problem." No. RR-388. Carnegie-Mellon Univ
+       Pittsburgh Pa Management Sciences Research Group, 1976.
+    """
+    # Remove selfloops if necessary
+    loop_nodes = nx.nodes_with_selfloops(G)
+    try:
+        node = next(loop_nodes)
+    except StopIteration:
+        pass
+    else:
+        G = G.copy()
+        G.remove_edge(node, node)
+        G.remove_edges_from((n, n) for n in loop_nodes)
+    # Check that G is a complete graph
+    N = len(G) - 1
+    # This check ignores selfloops which is what we want here.
+    if any(len(nbrdict) != N for n, nbrdict in G.adj.items()):
+        raise nx.NetworkXError("G must be a complete graph.")
+
+    if tree is None:
+        tree = nx.minimum_spanning_tree(G, weight=weight)
+    L = G.copy()
+    L.remove_nodes_from([v for v, degree in tree.degree if not (degree % 2)])
+    MG = nx.MultiGraph()
+    MG.add_edges_from(tree.edges)
+    edges = nx.min_weight_matching(L, maxcardinality=True, weight=weight)
+    MG.add_edges_from(edges)
+    return _shortcutting(nx.eulerian_circuit(MG))
+
+
+def _shortcutting(circuit):
+    """Remove duplicate nodes in the path"""
+    nodes = []
+    for u, v in circuit:
+        if v in nodes:
+            continue
+        if not nodes:
+            nodes.append(u)
+        nodes.append(v)
+    nodes.append(nodes[0])
+    return nodes
+
+
+def traveling_salesman_problem(G, weight="weight", nodes=None, cycle=True, method=None):
+    """Find the shortest path in `G` connecting specified nodes
+
+    This function allows approximate solution to the traveling salesman
+    problem on networks that are not complete graphs and/or where the
+    salesman does not need to visit all nodes.
+
+    This function proceeds in two steps. First, it creates a complete
+    graph using the all-pairs shortest_paths between nodes in `nodes`.
+    Edge weights in the new graph are the lengths of the paths
+    between each pair of nodes in the original graph.
+    Second, an algorithm (default: `christofides` for undirected and
+    `asadpour_atsp` for directed) is used to approximate the minimal Hamiltonian
+    cycle on this new graph. The available algorithms are:
+
+     - christofides
+     - greedy_tsp
+     - simulated_annealing_tsp
+     - threshold_accepting_tsp
+     - asadpour_atsp
+
+    Once the Hamiltonian Cycle is found, this function post-processes to
+    accommodate the structure of the original graph. If `cycle` is ``False``,
+    the biggest weight edge is removed to make a Hamiltonian path.
+    Then each edge on the new complete graph used for that analysis is
+    replaced by the shortest_path between those nodes on the original graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A possibly weighted graph
+
+    nodes : collection of nodes (default=G.nodes)
+        collection (list, set, etc.) of nodes to visit
+
+    weight : string, optional (default="weight")
+        Edge data key corresponding to the edge weight.
+        If any edge does not have this attribute the weight is set to 1.
+
+    cycle : bool (default: True)
+        Indicates whether a cycle should be returned, or a path.
+        Note: the cycle is the approximate minimal cycle.
+        The path simply removes the biggest edge in that cycle.
+
+    method : function (default: None)
+        A function that returns a cycle on all nodes and approximates
+        the solution to the traveling salesman problem on a complete
+        graph. The returned cycle is then used to find a corresponding
+        solution on `G`. `method` should be callable; take inputs
+        `G`, and `weight`; and return a list of nodes along the cycle.
+
+        Provided options include :func:`christofides`, :func:`greedy_tsp`,
+        :func:`simulated_annealing_tsp` and :func:`threshold_accepting_tsp`.
+
+        If `method is None`: use :func:`christofides` for undirected `G` and
+        :func:`threshold_accepting_tsp` for directed `G`.
+
+        To specify parameters for these provided functions, construct lambda
+        functions that state the specific value. `method` must have 2 inputs.
+        (See examples).
+
+    Returns
+    -------
+    list
+        List of nodes in `G` along a path with an approximation of the minimal
+        path through `nodes`.
+
+
+    Raises
+    ------
+    NetworkXError
+        If `G` is a directed graph it has to be strongly connected or the
+        complete version cannot be generated.
+
+    Examples
+    --------
+    >>> tsp = nx.approximation.traveling_salesman_problem
+    >>> G = nx.cycle_graph(9)
+    >>> G[4][5]["weight"] = 5  # all other weights are 1
+    >>> tsp(G, nodes=[3, 6])
+    [3, 2, 1, 0, 8, 7, 6, 7, 8, 0, 1, 2, 3]
+    >>> path = tsp(G, cycle=False)
+    >>> path in ([4, 3, 2, 1, 0, 8, 7, 6, 5], [5, 6, 7, 8, 0, 1, 2, 3, 4])
+    True
+
+    Build (curry) your own function to provide parameter values to the methods.
+
+    >>> SA_tsp = nx.approximation.simulated_annealing_tsp
+    >>> method = lambda G, wt: SA_tsp(G, "greedy", weight=wt, temp=500)
+    >>> path = tsp(G, cycle=False, method=method)
+    >>> path in ([4, 3, 2, 1, 0, 8, 7, 6, 5], [5, 6, 7, 8, 0, 1, 2, 3, 4])
+    True
+
+    """
+    if method is None:
+        if G.is_directed():
+            method = asadpour_atsp
+        else:
+            method = christofides
+    if nodes is None:
+        nodes = list(G.nodes)
+
+    dist = {}
+    path = {}
+    for n, (d, p) in nx.all_pairs_dijkstra(G, weight=weight):
+        dist[n] = d
+        path[n] = p
+
+    if G.is_directed():
+        # If the graph is not strongly connected, raise an exception
+        if not nx.is_strongly_connected(G):
+            raise nx.NetworkXError("G is not strongly connected")
+        GG = nx.DiGraph()
+    else:
+        GG = nx.Graph()
+    for u in nodes:
+        for v in nodes:
+            if u == v:
+                continue
+            GG.add_edge(u, v, weight=dist[u][v])
+    best_GG = method(GG, weight)
+
+    if not cycle:
+        # find and remove the biggest edge
+        (u, v) = max(pairwise(best_GG), key=lambda x: dist[x[0]][x[1]])
+        pos = best_GG.index(u) + 1
+        while best_GG[pos] != v:
+            pos = best_GG[pos:].index(u) + 1
+        best_GG = best_GG[pos:-1] + best_GG[:pos]
+
+    best_path = []
+    for u, v in pairwise(best_GG):
+        best_path.extend(path[u][v][:-1])
+    best_path.append(v)
+    return best_path
+
+
+@not_implemented_for("undirected")
+@py_random_state(2)
+def asadpour_atsp(G, weight="weight", seed=None, source=None):
+    """
+    Returns an approximate solution to the traveling salesman problem.
+
+    This approximate solution is one of the best known approximations for the
+    asymmetric traveling salesman problem developed by Asadpour et al,
+    [1]_. The algorithm first solves the Held-Karp relaxation to find a lower
+    bound for the weight of the cycle. Next, it constructs an exponential
+    distribution of undirected spanning trees where the probability of an
+    edge being in the tree corresponds to the weight of that edge using a
+    maximum entropy rounding scheme. Next we sample that distribution
+    $2 \\lceil \\ln n \\rceil$ times and save the minimum sampled tree once the
+    direction of the arcs is added back to the edges. Finally, we augment
+    then short circuit that graph to find the approximate tour for the
+    salesman.
+
+    Parameters
+    ----------
+    G : nx.DiGraph
+        The graph should be a complete weighted directed graph. The
+        distance between all paris of nodes should be included and the triangle
+        inequality should hold. That is, the direct edge between any two nodes
+        should be the path of least cost.
+
+    weight : string, optional (default="weight")
+        Edge data key corresponding to the edge weight.
+        If any edge does not have this attribute the weight is set to 1.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    source : node label (default=`None`)
+        If given, return the cycle starting and ending at the given node.
+
+    Returns
+    -------
+    cycle : list of nodes
+        Returns the cycle (list of nodes) that a salesman can follow to minimize
+        the total weight of the trip.
+
+    Raises
+    ------
+    NetworkXError
+        If `G` is not complete or has less than two nodes, the algorithm raises
+        an exception.
+
+    NetworkXError
+        If `source` is not `None` and is not a node in `G`, the algorithm raises
+        an exception.
+
+    NetworkXNotImplemented
+        If `G` is an undirected graph.
+
+    References
+    ----------
+    .. [1] A. Asadpour, M. X. Goemans, A. Madry, S. O. Gharan, and A. Saberi,
+       An o(log n/log log n)-approximation algorithm for the asymmetric
+       traveling salesman problem, Operations research, 65 (2017),
+       pp. 1043–1061
+
+    Examples
+    --------
+    >>> import networkx as nx
+    >>> import networkx.algorithms.approximation as approx
+    >>> G = nx.complete_graph(3, create_using=nx.DiGraph)
+    >>> nx.set_edge_attributes(G, {(0, 1): 2, (1, 2): 2, (2, 0): 2, (0, 2): 1, (2, 1): 1, (1, 0): 1}, "weight")
+    >>> tour = approx.asadpour_atsp(G,source=0)
+    >>> tour
+    [0, 2, 1, 0]
+    """
+    from math import ceil, exp
+    from math import log as ln
+
+    # Check that G is a complete graph
+    N = len(G) - 1
+    if N < 2:
+        raise nx.NetworkXError("G must have at least two nodes")
+    # This check ignores selfloops which is what we want here.
+    if any(len(nbrdict) - (n in nbrdict) != N for n, nbrdict in G.adj.items()):
+        raise nx.NetworkXError("G is not a complete DiGraph")
+    # Check that the source vertex, if given, is in the graph
+    if source is not None and source not in G.nodes:
+        raise nx.NetworkXError("Given source node not in G.")
+
+    opt_hk, z_star = held_karp_ascent(G, weight)
+
+    # Test to see if the ascent method found an integer solution or a fractional
+    # solution. If it is integral then z_star is a nx.Graph, otherwise it is
+    # a dict
+    if not isinstance(z_star, dict):
+        # Here we are using the shortcutting method to go from the list of edges
+        # returned from eularian_circuit to a list of nodes
+        return _shortcutting(nx.eulerian_circuit(z_star, source=source))
+
+    # Create the undirected support of z_star
+    z_support = nx.MultiGraph()
+    for u, v in z_star:
+        if (u, v) not in z_support.edges:
+            edge_weight = min(G[u][v][weight], G[v][u][weight])
+            z_support.add_edge(u, v, **{weight: edge_weight})
+
+    # Create the exponential distribution of spanning trees
+    gamma = spanning_tree_distribution(z_support, z_star)
+
+    # Write the lambda values to the edges of z_support
+    z_support = nx.Graph(z_support)
+    lambda_dict = {(u, v): exp(gamma[(u, v)]) for u, v in z_support.edges()}
+    nx.set_edge_attributes(z_support, lambda_dict, "weight")
+    del gamma, lambda_dict
+
+    # Sample 2 * ceil( ln(n) ) spanning trees and record the minimum one
+    minimum_sampled_tree = None
+    minimum_sampled_tree_weight = math.inf
+    for _ in range(2 * ceil(ln(G.number_of_nodes()))):
+        sampled_tree = random_spanning_tree(z_support, "weight", seed=seed)
+        sampled_tree_weight = sampled_tree.size(weight)
+        if sampled_tree_weight < minimum_sampled_tree_weight:
+            minimum_sampled_tree = sampled_tree.copy()
+            minimum_sampled_tree_weight = sampled_tree_weight
+
+    # Orient the edges in that tree to keep the cost of the tree the same.
+    t_star = nx.MultiDiGraph()
+    for u, v, d in minimum_sampled_tree.edges(data=weight):
+        if d == G[u][v][weight]:
+            t_star.add_edge(u, v, **{weight: d})
+        else:
+            t_star.add_edge(v, u, **{weight: d})
+
+    # Find the node demands needed to neutralize the flow of t_star in G
+    node_demands = {n: t_star.out_degree(n) - t_star.in_degree(n) for n in t_star}
+    nx.set_node_attributes(G, node_demands, "demand")
+
+    # Find the min_cost_flow
+    flow_dict = nx.min_cost_flow(G, "demand")
+
+    # Build the flow into t_star
+    for source, values in flow_dict.items():
+        for target in values:
+            if (source, target) not in t_star.edges and values[target] > 0:
+                # IF values[target] > 0 we have to add that many edges
+                for _ in range(values[target]):
+                    t_star.add_edge(source, target)
+
+    # Return the shortcut eulerian circuit
+    circuit = nx.eulerian_circuit(t_star, source=source)
+    return _shortcutting(circuit)
+
+
+def held_karp_ascent(G, weight="weight"):
+    """
+    Minimizes the Held-Karp relaxation of the TSP for `G`
+
+    Solves the Held-Karp relaxation of the input complete digraph and scales
+    the output solution for use in the Asadpour [1]_ ASTP algorithm.
+
+    The Held-Karp relaxation defines the lower bound for solutions to the
+    ATSP, although it does return a fractional solution. This is used in the
+    Asadpour algorithm as an initial solution which is later rounded to a
+    integral tree within the spanning tree polytopes. This function solves
+    the relaxation with the branch and bound method in [2]_.
+
+    Parameters
+    ----------
+    G : nx.DiGraph
+        The graph should be a complete weighted directed graph.
+        The distance between all paris of nodes should be included.
+
+    weight : string, optional (default="weight")
+        Edge data key corresponding to the edge weight.
+        If any edge does not have this attribute the weight is set to 1.
+
+    Returns
+    -------
+    OPT : float
+        The cost for the optimal solution to the Held-Karp relaxation
+    z : dict or nx.Graph
+        A symmetrized and scaled version of the optimal solution to the
+        Held-Karp relaxation for use in the Asadpour algorithm.
+
+        If an integral solution is found, then that is an optimal solution for
+        the ATSP problem and that is returned instead.
+
+    References
+    ----------
+    .. [1] A. Asadpour, M. X. Goemans, A. Madry, S. O. Gharan, and A. Saberi,
+       An o(log n/log log n)-approximation algorithm for the asymmetric
+       traveling salesman problem, Operations research, 65 (2017),
+       pp. 1043–1061
+
+    .. [2] M. Held, R. M. Karp, The traveling-salesman problem and minimum
+           spanning trees, Operations Research, 1970-11-01, Vol. 18 (6),
+           pp.1138-1162
+    """
+    import numpy as np
+    import scipy.optimize as optimize
+
+    def k_pi():
+        """
+        Find the set of minimum 1-Arborescences for G at point pi.
+
+        Returns
+        -------
+        Set
+            The set of minimum 1-Arborescences
+        """
+        # Create a copy of G without vertex 1.
+        G_1 = G.copy()
+        minimum_1_arborescences = set()
+        minimum_1_arborescence_weight = math.inf
+
+        # node is node '1' in the Held and Karp paper
+        n = next(G.__iter__())
+        G_1.remove_node(n)
+
+        # Iterate over the spanning arborescences of the graph until we know
+        # that we have found the minimum 1-arborescences. My proposed strategy
+        # is to find the most extensive root to connect to from 'node 1' and
+        # the least expensive one. We then iterate over arborescences until
+        # the cost of the basic arborescence is the cost of the minimum one
+        # plus the difference between the most and least expensive roots,
+        # that way the cost of connecting 'node 1' will by definition not by
+        # minimum
+        min_root = {"node": None, weight: math.inf}
+        max_root = {"node": None, weight: -math.inf}
+        for u, v, d in G.edges(n, data=True):
+            if d[weight] < min_root[weight]:
+                min_root = {"node": v, weight: d[weight]}
+            if d[weight] > max_root[weight]:
+                max_root = {"node": v, weight: d[weight]}
+
+        min_in_edge = min(G.in_edges(n, data=True), key=lambda x: x[2][weight])
+        min_root[weight] = min_root[weight] + min_in_edge[2][weight]
+        max_root[weight] = max_root[weight] + min_in_edge[2][weight]
+
+        min_arb_weight = math.inf
+        for arb in nx.ArborescenceIterator(G_1):
+            arb_weight = arb.size(weight)
+            if min_arb_weight == math.inf:
+                min_arb_weight = arb_weight
+            elif arb_weight > min_arb_weight + max_root[weight] - min_root[weight]:
+                break
+            # We have to pick the root node of the arborescence for the out
+            # edge of the first vertex as that is the only node without an
+            # edge directed into it.
+            for N, deg in arb.in_degree:
+                if deg == 0:
+                    # root found
+                    arb.add_edge(n, N, **{weight: G[n][N][weight]})
+                    arb_weight += G[n][N][weight]
+                    break
+
+            # We can pick the minimum weight in-edge for the vertex with
+            # a cycle. If there are multiple edges with the same, minimum
+            # weight, We need to add all of them.
+            #
+            # Delete the edge (N, v) so that we cannot pick it.
+            edge_data = G[N][n]
+            G.remove_edge(N, n)
+            min_weight = min(G.in_edges(n, data=weight), key=lambda x: x[2])[2]
+            min_edges = [
+                (u, v, d) for u, v, d in G.in_edges(n, data=weight) if d == min_weight
+            ]
+            for u, v, d in min_edges:
+                new_arb = arb.copy()
+                new_arb.add_edge(u, v, **{weight: d})
+                new_arb_weight = arb_weight + d
+                # Check to see the weight of the arborescence, if it is a
+                # new minimum, clear all of the old potential minimum
+                # 1-arborescences and add this is the only one. If its
+                # weight is above the known minimum, do not add it.
+                if new_arb_weight < minimum_1_arborescence_weight:
+                    minimum_1_arborescences.clear()
+                    minimum_1_arborescence_weight = new_arb_weight
+                # We have a 1-arborescence, add it to the set
+                if new_arb_weight == minimum_1_arborescence_weight:
+                    minimum_1_arborescences.add(new_arb)
+            G.add_edge(N, n, **edge_data)
+
+        return minimum_1_arborescences
+
+    def direction_of_ascent():
+        """
+        Find the direction of ascent at point pi.
+
+        See [1]_ for more information.
+
+        Returns
+        -------
+        dict
+            A mapping from the nodes of the graph which represents the direction
+            of ascent.
+
+        References
+        ----------
+        .. [1] M. Held, R. M. Karp, The traveling-salesman problem and minimum
+           spanning trees, Operations Research, 1970-11-01, Vol. 18 (6),
+           pp.1138-1162
+        """
+        # 1. Set d equal to the zero n-vector.
+        d = {}
+        for n in G:
+            d[n] = 0
+        del n
+        # 2. Find a 1-Aborescence T^k such that k is in K(pi, d).
+        minimum_1_arborescences = k_pi()
+        while True:
+            # Reduce K(pi) to K(pi, d)
+            # Find the arborescence in K(pi) which increases the lest in
+            # direction d
+            min_k_d_weight = math.inf
+            min_k_d = None
+            for arborescence in minimum_1_arborescences:
+                weighted_cost = 0
+                for n, deg in arborescence.degree:
+                    weighted_cost += d[n] * (deg - 2)
+                if weighted_cost < min_k_d_weight:
+                    min_k_d_weight = weighted_cost
+                    min_k_d = arborescence
+
+            # 3. If sum of d_i * v_{i, k} is greater than zero, terminate
+            if min_k_d_weight > 0:
+                return d, min_k_d
+            # 4. d_i = d_i + v_{i, k}
+            for n, deg in min_k_d.degree:
+                d[n] += deg - 2
+            # Check that we do not need to terminate because the direction
+            # of ascent does not exist. This is done with linear
+            # programming.
+            c = np.full(len(minimum_1_arborescences), -1, dtype=int)
+            a_eq = np.empty((len(G) + 1, len(minimum_1_arborescences)), dtype=int)
+            b_eq = np.zeros(len(G) + 1, dtype=int)
+            b_eq[len(G)] = 1
+            for arb_count, arborescence in enumerate(minimum_1_arborescences):
+                n_count = len(G) - 1
+                for n, deg in arborescence.degree:
+                    a_eq[n_count][arb_count] = deg - 2
+                    n_count -= 1
+                a_eq[len(G)][arb_count] = 1
+            program_result = optimize.linprog(c, A_eq=a_eq, b_eq=b_eq)
+            # If the constants exist, then the direction of ascent doesn't
+            if program_result.success:
+                # There is no direction of ascent
+                return None, minimum_1_arborescences
+
+            # 5. GO TO 2
+
+    def find_epsilon(k, d):
+        """
+        Given the direction of ascent at pi, find the maximum distance we can go
+        in that direction.
+
+        Parameters
+        ----------
+        k_xy : set
+            The set of 1-arborescences which have the minimum rate of increase
+            in the direction of ascent
+
+        d : dict
+            The direction of ascent
+
+        Returns
+        -------
+        float
+            The distance we can travel in direction `d`
+        """
+        min_epsilon = math.inf
+        for e_u, e_v, e_w in G.edges(data=weight):
+            if (e_u, e_v) in k.edges:
+                continue
+            # Now, I have found a condition which MUST be true for the edges to
+            # be a valid substitute. The edge in the graph which is the
+            # substitute is the one with the same terminated end. This can be
+            # checked rather simply.
+            #
+            # Find the edge within k which is the substitute. Because k is a
+            # 1-arborescence, we know that they is only one such edges
+            # leading into every vertex.
+            if len(k.in_edges(e_v, data=weight)) > 1:
+                raise Exception
+            sub_u, sub_v, sub_w = next(k.in_edges(e_v, data=weight).__iter__())
+            k.add_edge(e_u, e_v, **{weight: e_w})
+            k.remove_edge(sub_u, sub_v)
+            if (
+                max(d for n, d in k.in_degree()) <= 1
+                and len(G) == k.number_of_edges()
+                and nx.is_weakly_connected(k)
+            ):
+                # Ascent method calculation
+                if d[sub_u] == d[e_u] or sub_w == e_w:
+                    # Revert to the original graph
+                    k.remove_edge(e_u, e_v)
+                    k.add_edge(sub_u, sub_v, **{weight: sub_w})
+                    continue
+                epsilon = (sub_w - e_w) / (d[e_u] - d[sub_u])
+                if 0 < epsilon < min_epsilon:
+                    min_epsilon = epsilon
+            # Revert to the original graph
+            k.remove_edge(e_u, e_v)
+            k.add_edge(sub_u, sub_v, **{weight: sub_w})
+
+        return min_epsilon
+
+    # I have to know that the elements in pi correspond to the correct elements
+    # in the direction of ascent, even if the node labels are not integers.
+    # Thus, I will use dictionaries to made that mapping.
+    pi_dict = {}
+    for n in G:
+        pi_dict[n] = 0
+    del n
+    original_edge_weights = {}
+    for u, v, d in G.edges(data=True):
+        original_edge_weights[(u, v)] = d[weight]
+    dir_ascent, k_d = direction_of_ascent()
+    while dir_ascent is not None:
+        max_distance = find_epsilon(k_d, dir_ascent)
+        for n, v in dir_ascent.items():
+            pi_dict[n] += max_distance * v
+        for u, v, d in G.edges(data=True):
+            d[weight] = original_edge_weights[(u, v)] + pi_dict[u]
+        dir_ascent, k_d = direction_of_ascent()
+    # k_d is no longer an individual 1-arborescence but rather a set of
+    # minimal 1-arborescences at the maximum point of the polytope and should
+    # be reflected as such
+    k_max = k_d
+
+    # Search for a cycle within k_max. If a cycle exists, return it as the
+    # solution
+    for k in k_max:
+        if len([n for n in k if k.degree(n) == 2]) == G.order():
+            # Tour found
+            return k.size(weight), k
+
+    # Write the original edge weights back to G and every member of k_max at
+    # the maximum point. Also average the number of times that edge appears in
+    # the set of minimal 1-arborescences.
+    x_star = {}
+    size_k_max = len(k_max)
+    for u, v, d in G.edges(data=True):
+        edge_count = 0
+        d[weight] = original_edge_weights[(u, v)]
+        for k in k_max:
+            if (u, v) in k.edges():
+                edge_count += 1
+                k[u][v][weight] = original_edge_weights[(u, v)]
+        x_star[(u, v)] = edge_count / size_k_max
+    # Now symmetrize the edges in x_star and scale them according to (5) in
+    # reference [1]
+    z_star = {}
+    scale_factor = (G.order() - 1) / G.order()
+    for u, v in x_star.keys():
+        frequency = x_star[(u, v)] + x_star[(v, u)]
+        if frequency > 0:
+            z_star[(u, v)] = scale_factor * frequency
+    del x_star
+    # Return the optimal weight and the z dict
+    return next(k_max.__iter__()).size(weight), z_star
+
+
+def spanning_tree_distribution(G, z):
+    """
+    Find the asadpour exponential distribution of spanning trees.
+
+    Solves the Maximum Entropy Convex Program in the Asadpour algorithm [1]_
+    using the approach in section 7 to build an exponential distribution of
+    undirected spanning trees.
+
+    This algorithm ensures that the probability of any edge in a spanning
+    tree is proportional to the sum of the probabilities of the tress
+    containing that edge over the sum of the probabilities of all spanning
+    trees of the graph.
+
+    Parameters
+    ----------
+    G : nx.MultiGraph
+        The undirected support graph for the Held Karp relaxation
+
+    z : dict
+        The output of `held_karp_ascent()`, a scaled version of the Held-Karp
+        solution.
+
+    Returns
+    -------
+    gamma : dict
+        The probability distribution which approximately preserves the marginal
+        probabilities of `z`.
+    """
+    from math import exp
+    from math import log as ln
+
+    def q(e):
+        """
+        The value of q(e) is described in the Asadpour paper is "the
+        probability that edge e will be included in a spanning tree T that is
+        chosen with probability proportional to exp(gamma(T))" which
+        basically means that it is the total probability of the edge appearing
+        across the whole distribution.
+
+        Parameters
+        ----------
+        e : tuple
+            The `(u, v)` tuple describing the edge we are interested in
+
+        Returns
+        -------
+        float
+            The probability that a spanning tree chosen according to the
+            current values of gamma will include edge `e`.
+        """
+        # Create the laplacian matrices
+        for u, v, d in G.edges(data=True):
+            d[lambda_key] = exp(gamma[(u, v)])
+        G_Kirchhoff = nx.total_spanning_tree_weight(G, lambda_key)
+        G_e = nx.contracted_edge(G, e, self_loops=False)
+        G_e_Kirchhoff = nx.total_spanning_tree_weight(G_e, lambda_key)
+
+        # Multiply by the weight of the contracted edge since it is not included
+        # in the total weight of the contracted graph.
+        return exp(gamma[(e[0], e[1])]) * G_e_Kirchhoff / G_Kirchhoff
+
+    # initialize gamma to the zero dict
+    gamma = {}
+    for u, v, _ in G.edges:
+        gamma[(u, v)] = 0
+
+    # set epsilon
+    EPSILON = 0.2
+
+    # pick an edge attribute name that is unlikely to be in the graph
+    lambda_key = "spanning_tree_distribution's secret attribute name for lambda"
+
+    while True:
+        # We need to know that know that no values of q_e are greater than
+        # (1 + epsilon) * z_e, however changing one gamma value can increase the
+        # value of a different q_e, so we have to complete the for loop without
+        # changing anything for the condition to be meet
+        in_range_count = 0
+        # Search for an edge with q_e > (1 + epsilon) * z_e
+        for u, v in gamma:
+            e = (u, v)
+            q_e = q(e)
+            z_e = z[e]
+            if q_e > (1 + EPSILON) * z_e:
+                delta = ln(
+                    (q_e * (1 - (1 + EPSILON / 2) * z_e))
+                    / ((1 - q_e) * (1 + EPSILON / 2) * z_e)
+                )
+                gamma[e] -= delta
+                # Check that delta had the desired effect
+                new_q_e = q(e)
+                desired_q_e = (1 + EPSILON / 2) * z_e
+                if round(new_q_e, 8) != round(desired_q_e, 8):
+                    raise nx.NetworkXError(
+                        f"Unable to modify probability for edge ({u}, {v})"
+                    )
+            else:
+                in_range_count += 1
+        # Check if the for loop terminated without changing any gamma
+        if in_range_count == len(gamma):
+            break
+
+    # Remove the new edge attributes
+    for _, _, d in G.edges(data=True):
+        if lambda_key in d:
+            del d[lambda_key]
+
+    return gamma
+
+
+def greedy_tsp(G, weight="weight", source=None):
+    """Return a low cost cycle starting at `source` and its cost.
+
+    This approximates a solution to the traveling salesman problem.
+    It finds a cycle of all the nodes that a salesman can visit in order
+    to visit many nodes while minimizing total distance.
+    It uses a simple greedy algorithm.
+    In essence, this function returns a large cycle given a source point
+    for which the total cost of the cycle is minimized.
+
+    Parameters
+    ----------
+    G : Graph
+        The Graph should be a complete weighted undirected graph.
+        The distance between all pairs of nodes should be included.
+
+    weight : string, optional (default="weight")
+        Edge data key corresponding to the edge weight.
+        If any edge does not have this attribute the weight is set to 1.
+
+    source : node, optional (default: first node in list(G))
+        Starting node.  If None, defaults to ``next(iter(G))``
+
+    Returns
+    -------
+    cycle : list of nodes
+        Returns the cycle (list of nodes) that a salesman
+        can follow to minimize total weight of the trip.
+
+    Raises
+    ------
+    NetworkXError
+        If `G` is not complete, the algorithm raises an exception.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import approximation as approx
+    >>> G = nx.DiGraph()
+    >>> G.add_weighted_edges_from({
+    ...     ("A", "B", 3), ("A", "C", 17), ("A", "D", 14), ("B", "A", 3),
+    ...     ("B", "C", 12), ("B", "D", 16), ("C", "A", 13),("C", "B", 12),
+    ...     ("C", "D", 4), ("D", "A", 14), ("D", "B", 15), ("D", "C", 2)
+    ... })
+    >>> cycle = approx.greedy_tsp(G, source="D")
+    >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle))
+    >>> cycle
+    ['D', 'C', 'B', 'A', 'D']
+    >>> cost
+    31
+
+    Notes
+    -----
+    This implementation of a greedy algorithm is based on the following:
+
+    - The algorithm adds a node to the solution at every iteration.
+    - The algorithm selects a node not already in the cycle whose connection
+      to the previous node adds the least cost to the cycle.
+
+    A greedy algorithm does not always give the best solution.
+    However, it can construct a first feasible solution which can
+    be passed as a parameter to an iterative improvement algorithm such
+    as Simulated Annealing, or Threshold Accepting.
+
+    Time complexity: It has a running time $O(|V|^2)$
+    """
+    # Check that G is a complete graph
+    N = len(G) - 1
+    # This check ignores selfloops which is what we want here.
+    if any(len(nbrdict) - (n in nbrdict) != N for n, nbrdict in G.adj.items()):
+        raise nx.NetworkXError("G must be a complete graph.")
+
+    if source is None:
+        source = nx.utils.arbitrary_element(G)
+
+    if G.number_of_nodes() == 2:
+        neighbor = next(G.neighbors(source))
+        return [source, neighbor, source]
+
+    nodeset = set(G)
+    nodeset.remove(source)
+    cycle = [source]
+    next_node = source
+    while nodeset:
+        nbrdict = G[next_node]
+        next_node = min(nodeset, key=lambda n: nbrdict[n].get(weight, 1))
+        cycle.append(next_node)
+        nodeset.remove(next_node)
+    cycle.append(cycle[0])
+    return cycle
+
+
+@py_random_state(9)
+def simulated_annealing_tsp(
+    G,
+    init_cycle,
+    weight="weight",
+    source=None,
+    temp=100,
+    move="1-1",
+    max_iterations=10,
+    N_inner=100,
+    alpha=0.01,
+    seed=None,
+):
+    """Returns an approximate solution to the traveling salesman problem.
+
+    This function uses simulated annealing to approximate the minimal cost
+    cycle through the nodes. Starting from a suboptimal solution, simulated
+    annealing perturbs that solution, occasionally accepting changes that make
+    the solution worse to escape from a locally optimal solution. The chance
+    of accepting such changes decreases over the iterations to encourage
+    an optimal result.  In summary, the function returns a cycle starting
+    at `source` for which the total cost is minimized. It also returns the cost.
+
+    The chance of accepting a proposed change is related to a parameter called
+    the temperature (annealing has a physical analogue of steel hardening
+    as it cools). As the temperature is reduced, the chance of moves that
+    increase cost goes down.
+
+    Parameters
+    ----------
+    G : Graph
+        `G` should be a complete weighted undirected graph.
+        The distance between all pairs of nodes should be included.
+
+    init_cycle : list of all nodes or "greedy"
+        The initial solution (a cycle through all nodes returning to the start).
+        This argument has no default to make you think about it.
+        If "greedy", use `greedy_tsp(G, weight)`.
+        Other common starting cycles are `list(G) + [next(iter(G))]` or the final
+        result of `simulated_annealing_tsp` when doing `threshold_accepting_tsp`.
+
+    weight : string, optional (default="weight")
+        Edge data key corresponding to the edge weight.
+        If any edge does not have this attribute the weight is set to 1.
+
+    source : node, optional (default: first node in list(G))
+        Starting node.  If None, defaults to ``next(iter(G))``
+
+    temp : int, optional (default=100)
+        The algorithm's temperature parameter. It represents the initial
+        value of temperature
+
+    move : "1-1" or "1-0" or function, optional (default="1-1")
+        Indicator of what move to use when finding new trial solutions.
+        Strings indicate two special built-in moves:
+
+        - "1-1": 1-1 exchange which transposes the position
+          of two elements of the current solution.
+          The function called is :func:`swap_two_nodes`.
+          For example if we apply 1-1 exchange in the solution
+          ``A = [3, 2, 1, 4, 3]``
+          we can get the following by the transposition of 1 and 4 elements:
+          ``A' = [3, 2, 4, 1, 3]``
+        - "1-0": 1-0 exchange which moves an node in the solution
+          to a new position.
+          The function called is :func:`move_one_node`.
+          For example if we apply 1-0 exchange in the solution
+          ``A = [3, 2, 1, 4, 3]``
+          we can transfer the fourth element to the second position:
+          ``A' = [3, 4, 2, 1, 3]``
+
+        You may provide your own functions to enact a move from
+        one solution to a neighbor solution. The function must take
+        the solution as input along with a `seed` input to control
+        random number generation (see the `seed` input here).
+        Your function should maintain the solution as a cycle with
+        equal first and last node and all others appearing once.
+        Your function should return the new solution.
+
+    max_iterations : int, optional (default=10)
+        Declared done when this number of consecutive iterations of
+        the outer loop occurs without any change in the best cost solution.
+
+    N_inner : int, optional (default=100)
+        The number of iterations of the inner loop.
+
+    alpha : float between (0, 1), optional (default=0.01)
+        Percentage of temperature decrease in each iteration
+        of outer loop
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    cycle : list of nodes
+        Returns the cycle (list of nodes) that a salesman
+        can follow to minimize total weight of the trip.
+
+    Raises
+    ------
+    NetworkXError
+        If `G` is not complete the algorithm raises an exception.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import approximation as approx
+    >>> G = nx.DiGraph()
+    >>> G.add_weighted_edges_from({
+    ...     ("A", "B", 3), ("A", "C", 17), ("A", "D", 14), ("B", "A", 3),
+    ...     ("B", "C", 12), ("B", "D", 16), ("C", "A", 13),("C", "B", 12),
+    ...     ("C", "D", 4), ("D", "A", 14), ("D", "B", 15), ("D", "C", 2)
+    ... })
+    >>> cycle = approx.simulated_annealing_tsp(G, "greedy", source="D")
+    >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle))
+    >>> cycle
+    ['D', 'C', 'B', 'A', 'D']
+    >>> cost
+    31
+    >>> incycle = ["D", "B", "A", "C", "D"]
+    >>> cycle = approx.simulated_annealing_tsp(G, incycle, source="D")
+    >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle))
+    >>> cycle
+    ['D', 'C', 'B', 'A', 'D']
+    >>> cost
+    31
+
+    Notes
+    -----
+    Simulated Annealing is a metaheuristic local search algorithm.
+    The main characteristic of this algorithm is that it accepts
+    even solutions which lead to the increase of the cost in order
+    to escape from low quality local optimal solutions.
+
+    This algorithm needs an initial solution. If not provided, it is
+    constructed by a simple greedy algorithm. At every iteration, the
+    algorithm selects thoughtfully a neighbor solution.
+    Consider $c(x)$ cost of current solution and $c(x')$ cost of a
+    neighbor solution.
+    If $c(x') - c(x) <= 0$ then the neighbor solution becomes the current
+    solution for the next iteration. Otherwise, the algorithm accepts
+    the neighbor solution with probability $p = exp - ([c(x') - c(x)] / temp)$.
+    Otherwise the current solution is retained.
+
+    `temp` is a parameter of the algorithm and represents temperature.
+
+    Time complexity:
+    For $N_i$ iterations of the inner loop and $N_o$ iterations of the
+    outer loop, this algorithm has running time $O(N_i * N_o * |V|)$.
+
+    For more information and how the algorithm is inspired see:
+    http://en.wikipedia.org/wiki/Simulated_annealing
+    """
+    if move == "1-1":
+        move = swap_two_nodes
+    elif move == "1-0":
+        move = move_one_node
+    if init_cycle == "greedy":
+        # Construct an initial solution using a greedy algorithm.
+        cycle = greedy_tsp(G, weight=weight, source=source)
+        if G.number_of_nodes() == 2:
+            return cycle
+
+    else:
+        cycle = list(init_cycle)
+        if source is None:
+            source = cycle[0]
+        elif source != cycle[0]:
+            raise nx.NetworkXError("source must be first node in init_cycle")
+        if cycle[0] != cycle[-1]:
+            raise nx.NetworkXError("init_cycle must be a cycle. (return to start)")
+
+        if len(cycle) - 1 != len(G) or len(set(G.nbunch_iter(cycle))) != len(G):
+            raise nx.NetworkXError("init_cycle should be a cycle over all nodes in G.")
+
+        # Check that G is a complete graph
+        N = len(G) - 1
+        # This check ignores selfloops which is what we want here.
+        if any(len(nbrdict) - (n in nbrdict) != N for n, nbrdict in G.adj.items()):
+            raise nx.NetworkXError("G must be a complete graph.")
+
+        if G.number_of_nodes() == 2:
+            neighbor = next(G.neighbors(source))
+            return [source, neighbor, source]
+
+    # Find the cost of initial solution
+    cost = sum(G[u][v].get(weight, 1) for u, v in pairwise(cycle))
+
+    count = 0
+    best_cycle = cycle.copy()
+    best_cost = cost
+    while count <= max_iterations and temp > 0:
+        count += 1
+        for i in range(N_inner):
+            adj_sol = move(cycle, seed)
+            adj_cost = sum(G[u][v].get(weight, 1) for u, v in pairwise(adj_sol))
+            delta = adj_cost - cost
+            if delta <= 0:
+                # Set current solution the adjacent solution.
+                cycle = adj_sol
+                cost = adj_cost
+
+                if cost < best_cost:
+                    count = 0
+                    best_cycle = cycle.copy()
+                    best_cost = cost
+            else:
+                # Accept even a worse solution with probability p.
+                p = math.exp(-delta / temp)
+                if p >= seed.random():
+                    cycle = adj_sol
+                    cost = adj_cost
+        temp -= temp * alpha
+
+    return best_cycle
+
+
+@py_random_state(9)
+def threshold_accepting_tsp(
+    G,
+    init_cycle,
+    weight="weight",
+    source=None,
+    threshold=1,
+    move="1-1",
+    max_iterations=10,
+    N_inner=100,
+    alpha=0.1,
+    seed=None,
+):
+    """Returns an approximate solution to the traveling salesman problem.
+
+    This function uses threshold accepting methods to approximate the minimal cost
+    cycle through the nodes. Starting from a suboptimal solution, threshold
+    accepting methods perturb that solution, accepting any changes that make
+    the solution no worse than increasing by a threshold amount. Improvements
+    in cost are accepted, but so are changes leading to small increases in cost.
+    This allows the solution to leave suboptimal local minima in solution space.
+    The threshold is decreased slowly as iterations proceed helping to ensure
+    an optimum. In summary, the function returns a cycle starting at `source`
+    for which the total cost is minimized.
+
+    Parameters
+    ----------
+    G : Graph
+        `G` should be a complete weighted undirected graph.
+        The distance between all pairs of nodes should be included.
+
+    init_cycle : list or "greedy"
+        The initial solution (a cycle through all nodes returning to the start).
+        This argument has no default to make you think about it.
+        If "greedy", use `greedy_tsp(G, weight)`.
+        Other common starting cycles are `list(G) + [next(iter(G))]` or the final
+        result of `simulated_annealing_tsp` when doing `threshold_accepting_tsp`.
+
+    weight : string, optional (default="weight")
+        Edge data key corresponding to the edge weight.
+        If any edge does not have this attribute the weight is set to 1.
+
+    source : node, optional (default: first node in list(G))
+        Starting node.  If None, defaults to ``next(iter(G))``
+
+    threshold : int, optional (default=1)
+        The algorithm's threshold parameter. It represents the initial
+        threshold's value
+
+    move : "1-1" or "1-0" or function, optional (default="1-1")
+        Indicator of what move to use when finding new trial solutions.
+        Strings indicate two special built-in moves:
+
+        - "1-1": 1-1 exchange which transposes the position
+          of two elements of the current solution.
+          The function called is :func:`swap_two_nodes`.
+          For example if we apply 1-1 exchange in the solution
+          ``A = [3, 2, 1, 4, 3]``
+          we can get the following by the transposition of 1 and 4 elements:
+          ``A' = [3, 2, 4, 1, 3]``
+        - "1-0": 1-0 exchange which moves an node in the solution
+          to a new position.
+          The function called is :func:`move_one_node`.
+          For example if we apply 1-0 exchange in the solution
+          ``A = [3, 2, 1, 4, 3]``
+          we can transfer the fourth element to the second position:
+          ``A' = [3, 4, 2, 1, 3]``
+
+        You may provide your own functions to enact a move from
+        one solution to a neighbor solution. The function must take
+        the solution as input along with a `seed` input to control
+        random number generation (see the `seed` input here).
+        Your function should maintain the solution as a cycle with
+        equal first and last node and all others appearing once.
+        Your function should return the new solution.
+
+    max_iterations : int, optional (default=10)
+        Declared done when this number of consecutive iterations of
+        the outer loop occurs without any change in the best cost solution.
+
+    N_inner : int, optional (default=100)
+        The number of iterations of the inner loop.
+
+    alpha : float between (0, 1), optional (default=0.1)
+        Percentage of threshold decrease when there is at
+        least one acceptance of a neighbor solution.
+        If no inner loop moves are accepted the threshold remains unchanged.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    cycle : list of nodes
+        Returns the cycle (list of nodes) that a salesman
+        can follow to minimize total weight of the trip.
+
+    Raises
+    ------
+    NetworkXError
+        If `G` is not complete the algorithm raises an exception.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import approximation as approx
+    >>> G = nx.DiGraph()
+    >>> G.add_weighted_edges_from({
+    ...     ("A", "B", 3), ("A", "C", 17), ("A", "D", 14), ("B", "A", 3),
+    ...     ("B", "C", 12), ("B", "D", 16), ("C", "A", 13),("C", "B", 12),
+    ...     ("C", "D", 4), ("D", "A", 14), ("D", "B", 15), ("D", "C", 2)
+    ... })
+    >>> cycle = approx.threshold_accepting_tsp(G, "greedy", source="D")
+    >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle))
+    >>> cycle
+    ['D', 'C', 'B', 'A', 'D']
+    >>> cost
+    31
+    >>> incycle = ["D", "B", "A", "C", "D"]
+    >>> cycle = approx.threshold_accepting_tsp(G, incycle, source="D")
+    >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle))
+    >>> cycle
+    ['D', 'C', 'B', 'A', 'D']
+    >>> cost
+    31
+
+    Notes
+    -----
+    Threshold Accepting is a metaheuristic local search algorithm.
+    The main characteristic of this algorithm is that it accepts
+    even solutions which lead to the increase of the cost in order
+    to escape from low quality local optimal solutions.
+
+    This algorithm needs an initial solution. This solution can be
+    constructed by a simple greedy algorithm. At every iteration, it
+    selects thoughtfully a neighbor solution.
+    Consider $c(x)$ cost of current solution and $c(x')$ cost of
+    neighbor solution.
+    If $c(x') - c(x) <= threshold$ then the neighbor solution becomes the current
+    solution for the next iteration, where the threshold is named threshold.
+
+    In comparison to the Simulated Annealing algorithm, the Threshold
+    Accepting algorithm does not accept very low quality solutions
+    (due to the presence of the threshold value). In the case of
+    Simulated Annealing, even a very low quality solution can
+    be accepted with probability $p$.
+
+    Time complexity:
+    It has a running time $O(m * n * |V|)$ where $m$ and $n$ are the number
+    of times the outer and inner loop run respectively.
+
+    For more information and how algorithm is inspired see:
+    https://doi.org/10.1016/0021-9991(90)90201-B
+
+    See Also
+    --------
+    simulated_annealing_tsp
+
+    """
+    if move == "1-1":
+        move = swap_two_nodes
+    elif move == "1-0":
+        move = move_one_node
+    if init_cycle == "greedy":
+        # Construct an initial solution using a greedy algorithm.
+        cycle = greedy_tsp(G, weight=weight, source=source)
+        if G.number_of_nodes() == 2:
+            return cycle
+
+    else:
+        cycle = list(init_cycle)
+        if source is None:
+            source = cycle[0]
+        elif source != cycle[0]:
+            raise nx.NetworkXError("source must be first node in init_cycle")
+        if cycle[0] != cycle[-1]:
+            raise nx.NetworkXError("init_cycle must be a cycle. (return to start)")
+
+        if len(cycle) - 1 != len(G) or len(set(G.nbunch_iter(cycle))) != len(G):
+            raise nx.NetworkXError("init_cycle is not all and only nodes.")
+
+        # Check that G is a complete graph
+        N = len(G) - 1
+        # This check ignores selfloops which is what we want here.
+        if any(len(nbrdict) - (n in nbrdict) != N for n, nbrdict in G.adj.items()):
+            raise nx.NetworkXError("G must be a complete graph.")
+
+        if G.number_of_nodes() == 2:
+            neighbor = list(G.neighbors(source))[0]
+            return [source, neighbor, source]
+
+    # Find the cost of initial solution
+    cost = sum(G[u][v].get(weight, 1) for u, v in pairwise(cycle))
+
+    count = 0
+    best_cycle = cycle.copy()
+    best_cost = cost
+    while count <= max_iterations:
+        count += 1
+        accepted = False
+        for i in range(N_inner):
+            adj_sol = move(cycle, seed)
+            adj_cost = sum(G[u][v].get(weight, 1) for u, v in pairwise(adj_sol))
+            delta = adj_cost - cost
+            if delta <= threshold:
+                accepted = True
+
+                # Set current solution the adjacent solution.
+                cycle = adj_sol
+                cost = adj_cost
+
+                if cost < best_cost:
+                    count = 0
+                    best_cycle = cycle.copy()
+                    best_cost = cost
+        if accepted:
+            threshold -= threshold * alpha
+
+    return best_cycle
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/treewidth.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/treewidth.py
new file mode 100644
index 0000000..61fb1e7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/treewidth.py
@@ -0,0 +1,249 @@
+"""Functions for computing treewidth decomposition.
+
+Treewidth of an undirected graph is a number associated with the graph.
+It can be defined as the size of the largest vertex set (bag) in a tree
+decomposition of the graph minus one.
+
+`Wikipedia: Treewidth <https://en.wikipedia.org/wiki/Treewidth>`_
+
+The notions of treewidth and tree decomposition have gained their
+attractiveness partly because many graph and network problems that are
+intractable (e.g., NP-hard) on arbitrary graphs become efficiently
+solvable (e.g., with a linear time algorithm) when the treewidth of the
+input graphs is bounded by a constant [1]_ [2]_.
+
+There are two different functions for computing a tree decomposition:
+:func:`treewidth_min_degree` and :func:`treewidth_min_fill_in`.
+
+.. [1] Hans L. Bodlaender and Arie M. C. A. Koster. 2010. "Treewidth
+      computations I.Upper bounds". Inf. Comput. 208, 3 (March 2010),259-275.
+      http://dx.doi.org/10.1016/j.ic.2009.03.008
+
+.. [2] Hans L. Bodlaender. "Discovering Treewidth". Institute of Information
+      and Computing Sciences, Utrecht University.
+      Technical Report UU-CS-2005-018.
+      http://www.cs.uu.nl
+
+.. [3] K. Wang, Z. Lu, and J. Hicks *Treewidth*.
+      https://web.archive.org/web/20210507025929/http://web.eecs.utk.edu/~cphill25/cs594_spring2015_projects/treewidth.pdf
+
+"""
+
+import itertools
+import sys
+from heapq import heapify, heappop, heappush
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["treewidth_min_degree", "treewidth_min_fill_in"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def treewidth_min_degree(G):
+    """Returns a treewidth decomposition using the Minimum Degree heuristic.
+
+    The heuristic chooses the nodes according to their degree, i.e., first
+    the node with the lowest degree is chosen, then the graph is updated
+    and the corresponding node is removed. Next, a new node with the lowest
+    degree is chosen, and so on.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    Treewidth decomposition : (int, Graph) tuple
+          2-tuple with treewidth and the corresponding decomposed tree.
+    """
+    deg_heuristic = MinDegreeHeuristic(G)
+    return treewidth_decomp(G, lambda graph: deg_heuristic.best_node(graph))
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def treewidth_min_fill_in(G):
+    """Returns a treewidth decomposition using the Minimum Fill-in heuristic.
+
+    The heuristic chooses a node from the graph, where the number of edges
+    added turning the neighbourhood of the chosen node into clique is as
+    small as possible.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    Treewidth decomposition : (int, Graph) tuple
+        2-tuple with treewidth and the corresponding decomposed tree.
+    """
+    return treewidth_decomp(G, min_fill_in_heuristic)
+
+
+class MinDegreeHeuristic:
+    """Implements the Minimum Degree heuristic.
+
+    The heuristic chooses the nodes according to their degree
+    (number of neighbours), i.e., first the node with the lowest degree is
+    chosen, then the graph is updated and the corresponding node is
+    removed. Next, a new node with the lowest degree is chosen, and so on.
+    """
+
+    def __init__(self, graph):
+        self._graph = graph
+
+        # nodes that have to be updated in the heap before each iteration
+        self._update_nodes = []
+
+        self._degreeq = []  # a heapq with 2-tuples (degree,node)
+
+        # build heap with initial degrees
+        for n in graph:
+            self._degreeq.append((len(graph[n]), n))
+        heapify(self._degreeq)
+
+    def best_node(self, graph):
+        # update nodes in self._update_nodes
+        for n in self._update_nodes:
+            # insert changed degrees into degreeq
+            heappush(self._degreeq, (len(graph[n]), n))
+
+        # get the next valid (minimum degree) node
+        while self._degreeq:
+            (min_degree, elim_node) = heappop(self._degreeq)
+            if elim_node not in graph or len(graph[elim_node]) != min_degree:
+                # outdated entry in degreeq
+                continue
+            elif min_degree == len(graph) - 1:
+                # fully connected: abort condition
+                return None
+
+            # remember to update nodes in the heap before getting the next node
+            self._update_nodes = graph[elim_node]
+            return elim_node
+
+        # the heap is empty: abort
+        return None
+
+
+def min_fill_in_heuristic(graph):
+    """Implements the Minimum Degree heuristic.
+
+    Returns the node from the graph, where the number of edges added when
+    turning the neighbourhood of the chosen node into clique is as small as
+    possible. This algorithm chooses the nodes using the Minimum Fill-In
+    heuristic. The running time of the algorithm is :math:`O(V^3)` and it uses
+    additional constant memory."""
+
+    if len(graph) == 0:
+        return None
+
+    min_fill_in_node = None
+
+    min_fill_in = sys.maxsize
+
+    # create sorted list of (degree, node)
+    degree_list = [(len(graph[node]), node) for node in graph]
+    degree_list.sort()
+
+    # abort condition
+    min_degree = degree_list[0][0]
+    if min_degree == len(graph) - 1:
+        return None
+
+    for (_, node) in degree_list:
+        num_fill_in = 0
+        nbrs = graph[node]
+        for nbr in nbrs:
+            # count how many nodes in nbrs current nbr is not connected to
+            # subtract 1 for the node itself
+            num_fill_in += len(nbrs - graph[nbr]) - 1
+            if num_fill_in >= 2 * min_fill_in:
+                break
+
+        num_fill_in /= 2  # divide by 2 because of double counting
+
+        if num_fill_in < min_fill_in:  # update min-fill-in node
+            if num_fill_in == 0:
+                return node
+            min_fill_in = num_fill_in
+            min_fill_in_node = node
+
+    return min_fill_in_node
+
+
+def treewidth_decomp(G, heuristic=min_fill_in_heuristic):
+    """Returns a treewidth decomposition using the passed heuristic.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+    heuristic : heuristic function
+
+    Returns
+    -------
+    Treewidth decomposition : (int, Graph) tuple
+        2-tuple with treewidth and the corresponding decomposed tree.
+    """
+
+    # make dict-of-sets structure
+    graph = {n: set(G[n]) - {n} for n in G}
+
+    # stack containing nodes and neighbors in the order from the heuristic
+    node_stack = []
+
+    # get first node from heuristic
+    elim_node = heuristic(graph)
+    while elim_node is not None:
+        # connect all neighbours with each other
+        nbrs = graph[elim_node]
+        for u, v in itertools.permutations(nbrs, 2):
+            if v not in graph[u]:
+                graph[u].add(v)
+
+        # push node and its current neighbors on stack
+        node_stack.append((elim_node, nbrs))
+
+        # remove node from graph
+        for u in graph[elim_node]:
+            graph[u].remove(elim_node)
+
+        del graph[elim_node]
+        elim_node = heuristic(graph)
+
+    # the abort condition is met; put all remaining nodes into one bag
+    decomp = nx.Graph()
+    first_bag = frozenset(graph.keys())
+    decomp.add_node(first_bag)
+
+    treewidth = len(first_bag) - 1
+
+    while node_stack:
+        # get node and its neighbors from the stack
+        (curr_node, nbrs) = node_stack.pop()
+
+        # find a bag all neighbors are in
+        old_bag = None
+        for bag in decomp.nodes:
+            if nbrs <= bag:
+                old_bag = bag
+                break
+
+        if old_bag is None:
+            # no old_bag was found: just connect to the first_bag
+            old_bag = first_bag
+
+        # create new node for decomposition
+        nbrs.add(curr_node)
+        new_bag = frozenset(nbrs)
+
+        # update treewidth
+        treewidth = max(treewidth, len(new_bag) - 1)
+
+        # add edge to decomposition (implicitly also adds the new node)
+        decomp.add_edge(old_bag, new_bag)
+
+    return treewidth, decomp
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/vertex_cover.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/vertex_cover.py
new file mode 100644
index 0000000..d117c73
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/approximation/vertex_cover.py
@@ -0,0 +1,80 @@
+"""Functions for computing an approximate minimum weight vertex cover.
+
+A |vertex cover|_ is a subset of nodes such that each edge in the graph
+is incident to at least one node in the subset.
+
+.. _vertex cover: https://en.wikipedia.org/wiki/Vertex_cover
+.. |vertex cover| replace:: *vertex cover*
+
+"""
+
+__all__ = ["min_weighted_vertex_cover"]
+
+
+def min_weighted_vertex_cover(G, weight=None):
+    r"""Returns an approximate minimum weighted vertex cover.
+
+    The set of nodes returned by this function is guaranteed to be a
+    vertex cover, and the total weight of the set is guaranteed to be at
+    most twice the total weight of the minimum weight vertex cover. In
+    other words,
+
+    .. math::
+
+       w(S) \leq 2 * w(S^*),
+
+    where $S$ is the vertex cover returned by this function,
+    $S^*$ is the vertex cover of minimum weight out of all vertex
+    covers of the graph, and $w$ is the function that computes the
+    sum of the weights of each node in that given set.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight : string, optional (default = None)
+        If None, every node has weight 1. If a string, use this node
+        attribute as the node weight. A node without this attribute is
+        assumed to have weight 1.
+
+    Returns
+    -------
+    min_weighted_cover : set
+        Returns a set of nodes whose weight sum is no more than twice
+        the weight sum of the minimum weight vertex cover.
+
+    Notes
+    -----
+    For a directed graph, a vertex cover has the same definition: a set
+    of nodes such that each edge in the graph is incident to at least
+    one node in the set. Whether the node is the head or tail of the
+    directed edge is ignored.
+
+    This is the local-ratio algorithm for computing an approximate
+    vertex cover. The algorithm greedily reduces the costs over edges,
+    iteratively building a cover. The worst-case runtime of this
+    implementation is $O(m \log n)$, where $n$ is the number
+    of nodes and $m$ the number of edges in the graph.
+
+    References
+    ----------
+    .. [1] Bar-Yehuda, R., and Even, S. (1985). "A local-ratio theorem for
+       approximating the weighted vertex cover problem."
+       *Annals of Discrete Mathematics*, 25, 27–46
+       <http://www.cs.technion.ac.il/~reuven/PDF/vc_lr.pdf>
+
+    """
+    cost = dict(G.nodes(data=weight, default=1))
+    # While there are uncovered edges, choose an uncovered and update
+    # the cost of the remaining edges.
+    cover = set()
+    for u, v in G.edges():
+        if u in cover or v in cover:
+            continue
+        if cost[u] <= cost[v]:
+            cover.add(u)
+            cost[v] -= cost[u]
+        else:
+            cover.add(v)
+            cost[u] -= cost[v]
+    return cover
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/__init__.py
new file mode 100644
index 0000000..4d98886
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/__init__.py
@@ -0,0 +1,5 @@
+from networkx.algorithms.assortativity.connectivity import *
+from networkx.algorithms.assortativity.correlation import *
+from networkx.algorithms.assortativity.mixing import *
+from networkx.algorithms.assortativity.neighbor_degree import *
+from networkx.algorithms.assortativity.pairs import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/connectivity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/connectivity.py
new file mode 100644
index 0000000..ad05418
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/connectivity.py
@@ -0,0 +1,139 @@
+from collections import defaultdict
+
+import networkx as nx
+
+__all__ = ["average_degree_connectivity", "k_nearest_neighbors"]
+
+
+def average_degree_connectivity(
+    G, source="in+out", target="in+out", nodes=None, weight=None
+):
+    r"""Compute the average degree connectivity of graph.
+
+    The average degree connectivity is the average nearest neighbor degree of
+    nodes with degree k. For weighted graphs, an analogous measure can
+    be computed using the weighted average neighbors degree defined in
+    [1]_, for a node `i`, as
+
+    .. math::
+
+        k_{nn,i}^{w} = \frac{1}{s_i} \sum_{j \in N(i)} w_{ij} k_j
+
+    where `s_i` is the weighted degree of node `i`,
+    `w_{ij}` is the weight of the edge that links `i` and `j`,
+    and `N(i)` are the neighbors of node `i`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source :  "in"|"out"|"in+out" (default:"in+out")
+       Directed graphs only. Use "in"- or "out"-degree for source node.
+
+    target : "in"|"out"|"in+out" (default:"in+out"
+       Directed graphs only. Use "in"- or "out"-degree for target node.
+
+    nodes : list or iterable (optional)
+        Compute neighbor connectivity for these nodes. The default is all
+        nodes.
+
+    weight : string or None, optional (default=None)
+       The edge attribute that holds the numerical value used as a weight.
+       If None, then each edge has weight 1.
+
+    Returns
+    -------
+    d : dict
+       A dictionary keyed by degree k with the value of average connectivity.
+
+    Raises
+    ------
+    NetworkXError
+        If either `source` or `target` are not one of 'in',
+        'out', or 'in+out'.
+        If either `source` or `target` is passed for an undirected graph.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> G.edges[1, 2]["weight"] = 3
+    >>> nx.average_degree_connectivity(G)
+    {1: 2.0, 2: 1.5}
+    >>> nx.average_degree_connectivity(G, weight="weight")
+    {1: 2.0, 2: 1.75}
+
+    See Also
+    --------
+    average_neighbor_degree
+
+    References
+    ----------
+    .. [1] A. Barrat, M. Barthélemy, R. Pastor-Satorras, and A. Vespignani,
+       "The architecture of complex weighted networks".
+       PNAS 101 (11): 3747–3752 (2004).
+    """
+    # First, determine the type of neighbors and the type of degree to use.
+    if G.is_directed():
+        if source not in ("in", "out", "in+out"):
+            raise nx.NetworkXError('source must be one of "in", "out", or "in+out"')
+        if target not in ("in", "out", "in+out"):
+            raise nx.NetworkXError('target must be one of "in", "out", or "in+out"')
+        direction = {"out": G.out_degree, "in": G.in_degree, "in+out": G.degree}
+        neighbor_funcs = {
+            "out": G.successors,
+            "in": G.predecessors,
+            "in+out": G.neighbors,
+        }
+        source_degree = direction[source]
+        target_degree = direction[target]
+        neighbors = neighbor_funcs[source]
+        # `reverse` indicates whether to look at the in-edge when
+        # computing the weight of an edge.
+        reverse = source == "in"
+    else:
+        if source != "in+out" or target != "in+out":
+            raise nx.NetworkXError(
+                f"source and target arguments are only supported for directed graphs"
+            )
+        source_degree = G.degree
+        target_degree = G.degree
+        neighbors = G.neighbors
+        reverse = False
+    dsum = defaultdict(int)
+    dnorm = defaultdict(int)
+    # Check if `source_nodes` is actually a single node in the graph.
+    source_nodes = source_degree(nodes)
+    if nodes in G:
+        source_nodes = [(nodes, source_degree(nodes))]
+    for n, k in source_nodes:
+        nbrdeg = target_degree(neighbors(n))
+        if weight is None:
+            s = sum(d for n, d in nbrdeg)
+        else:  # weight nbr degree by weight of (n,nbr) edge
+            if reverse:
+                s = sum(G[nbr][n].get(weight, 1) * d for nbr, d in nbrdeg)
+            else:
+                s = sum(G[n][nbr].get(weight, 1) * d for nbr, d in nbrdeg)
+        dnorm[k] += source_degree(n, weight=weight)
+        dsum[k] += s
+
+    # normalize
+    return {k: avg if dnorm[k] == 0 else avg / dnorm[k] for k, avg in dsum.items()}
+
+
+def k_nearest_neighbors(G, source="in+out", target="in+out", nodes=None, weight=None):
+    """Compute the average degree connectivity of graph.
+
+    .. deprecated 2.6
+
+      k_nearest_neighbors function is deprecated and will be removed in v3.0.
+      Use `average_degree_connectivity` instead.
+    """
+    import warnings
+
+    msg = (
+        "k_nearest_neighbors function is deprecated and will be removed in v3.0.\n"
+        "Use `average_degree_connectivity` instead."
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    return average_degree_connectivity(G, source, target, nodes, weight)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/correlation.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/correlation.py
new file mode 100644
index 0000000..19ea04e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/correlation.py
@@ -0,0 +1,298 @@
+"""Node assortativity coefficients and correlation measures.
+"""
+from networkx.algorithms.assortativity.mixing import (
+    attribute_mixing_matrix,
+    degree_mixing_matrix,
+)
+from networkx.algorithms.assortativity.pairs import node_degree_xy
+
+__all__ = [
+    "degree_pearson_correlation_coefficient",
+    "degree_assortativity_coefficient",
+    "attribute_assortativity_coefficient",
+    "numeric_assortativity_coefficient",
+]
+
+
+def degree_assortativity_coefficient(G, x="out", y="in", weight=None, nodes=None):
+    """Compute degree assortativity of graph.
+
+    Assortativity measures the similarity of connections
+    in the graph with respect to the node degree.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    x: string ('in','out')
+       The degree type for source node (directed graphs only).
+
+    y: string ('in','out')
+       The degree type for target node (directed graphs only).
+
+    weight: string or None, optional (default=None)
+       The edge attribute that holds the numerical value used
+       as a weight.  If None, then each edge has weight 1.
+       The degree is the sum of the edge weights adjacent to the node.
+
+    nodes: list or iterable (optional)
+        Compute degree assortativity only for nodes in container.
+        The default is all nodes.
+
+    Returns
+    -------
+    r : float
+       Assortativity of graph by degree.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> r = nx.degree_assortativity_coefficient(G)
+    >>> print(f"{r:3.1f}")
+    -0.5
+
+    See Also
+    --------
+    attribute_assortativity_coefficient
+    numeric_assortativity_coefficient
+    degree_mixing_dict
+    degree_mixing_matrix
+
+    Notes
+    -----
+    This computes Eq. (21) in Ref. [1]_ , where e is the joint
+    probability distribution (mixing matrix) of the degrees.  If G is
+    directed than the matrix e is the joint probability of the
+    user-specified degree type for the source and target.
+
+    References
+    ----------
+    .. [1] M. E. J. Newman, Mixing patterns in networks,
+       Physical Review E, 67 026126, 2003
+    .. [2] Foster, J.G., Foster, D.V., Grassberger, P. & Paczuski, M.
+       Edge direction and the structure of networks, PNAS 107, 10815-20 (2010).
+    """
+    if nodes is None:
+        nodes = G.nodes
+
+    degrees = None
+
+    if G.is_directed():
+        indeg = (
+            {d for _, d in G.in_degree(nodes, weight=weight)}
+            if "in" in (x, y)
+            else set()
+        )
+        outdeg = (
+            {d for _, d in G.out_degree(nodes, weight=weight)}
+            if "out" in (x, y)
+            else set()
+        )
+        degrees = set.union(indeg, outdeg)
+    else:
+        degrees = {d for _, d in G.degree(nodes, weight=weight)}
+
+    mapping = {d: i for i, d, in enumerate(degrees)}
+    M = degree_mixing_matrix(G, x=x, y=y, nodes=nodes, weight=weight, mapping=mapping)
+
+    return _numeric_ac(M, mapping=mapping)
+
+
+def degree_pearson_correlation_coefficient(G, x="out", y="in", weight=None, nodes=None):
+    """Compute degree assortativity of graph.
+
+    Assortativity measures the similarity of connections
+    in the graph with respect to the node degree.
+
+    This is the same as degree_assortativity_coefficient but uses the
+    potentially faster scipy.stats.pearsonr function.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    x: string ('in','out')
+       The degree type for source node (directed graphs only).
+
+    y: string ('in','out')
+       The degree type for target node (directed graphs only).
+
+    weight: string or None, optional (default=None)
+       The edge attribute that holds the numerical value used
+       as a weight.  If None, then each edge has weight 1.
+       The degree is the sum of the edge weights adjacent to the node.
+
+    nodes: list or iterable (optional)
+        Compute pearson correlation of degrees only for specified nodes.
+        The default is all nodes.
+
+    Returns
+    -------
+    r : float
+       Assortativity of graph by degree.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> r = nx.degree_pearson_correlation_coefficient(G)
+    >>> print(f"{r:3.1f}")
+    -0.5
+
+    Notes
+    -----
+    This calls scipy.stats.pearsonr.
+
+    References
+    ----------
+    .. [1] M. E. J. Newman, Mixing patterns in networks
+           Physical Review E, 67 026126, 2003
+    .. [2] Foster, J.G., Foster, D.V., Grassberger, P. & Paczuski, M.
+       Edge direction and the structure of networks, PNAS 107, 10815-20 (2010).
+    """
+    import scipy as sp
+    import scipy.stats  # call as sp.stats
+
+    xy = node_degree_xy(G, x=x, y=y, nodes=nodes, weight=weight)
+    x, y = zip(*xy)
+    return sp.stats.pearsonr(x, y)[0]
+
+
+def attribute_assortativity_coefficient(G, attribute, nodes=None):
+    """Compute assortativity for node attributes.
+
+    Assortativity measures the similarity of connections
+    in the graph with respect to the given attribute.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    attribute : string
+        Node attribute key
+
+    nodes: list or iterable (optional)
+        Compute attribute assortativity for nodes in container.
+        The default is all nodes.
+
+    Returns
+    -------
+    r: float
+       Assortativity of graph for given attribute
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_nodes_from([0, 1], color="red")
+    >>> G.add_nodes_from([2, 3], color="blue")
+    >>> G.add_edges_from([(0, 1), (2, 3)])
+    >>> print(nx.attribute_assortativity_coefficient(G, "color"))
+    1.0
+
+    Notes
+    -----
+    This computes Eq. (2) in Ref. [1]_ , (trace(M)-sum(M^2))/(1-sum(M^2)),
+    where M is the joint probability distribution (mixing matrix)
+    of the specified attribute.
+
+    References
+    ----------
+    .. [1] M. E. J. Newman, Mixing patterns in networks,
+       Physical Review E, 67 026126, 2003
+    """
+    M = attribute_mixing_matrix(G, attribute, nodes)
+    return attribute_ac(M)
+
+
+def numeric_assortativity_coefficient(G, attribute, nodes=None):
+    """Compute assortativity for numerical node attributes.
+
+    Assortativity measures the similarity of connections
+    in the graph with respect to the given numeric attribute.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    attribute : string
+        Node attribute key.
+
+    nodes: list or iterable (optional)
+        Compute numeric assortativity only for attributes of nodes in
+        container. The default is all nodes.
+
+    Returns
+    -------
+    r: float
+       Assortativity of graph for given attribute
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_nodes_from([0, 1], size=2)
+    >>> G.add_nodes_from([2, 3], size=3)
+    >>> G.add_edges_from([(0, 1), (2, 3)])
+    >>> print(nx.numeric_assortativity_coefficient(G, "size"))
+    1.0
+
+    Notes
+    -----
+    This computes Eq. (21) in Ref. [1]_ , which is the Pearson correlation
+    coefficient of the specified (scalar valued) attribute across edges.
+
+    References
+    ----------
+    .. [1] M. E. J. Newman, Mixing patterns in networks
+           Physical Review E, 67 026126, 2003
+    """
+    if nodes is None:
+        nodes = G.nodes
+    vals = {G.nodes[n][attribute] for n in nodes}
+    mapping = {d: i for i, d, in enumerate(vals)}
+    M = attribute_mixing_matrix(G, attribute, nodes, mapping)
+    return _numeric_ac(M, mapping)
+
+
+def attribute_ac(M):
+    """Compute assortativity for attribute matrix M.
+
+    Parameters
+    ----------
+    M : numpy.ndarray
+        2D ndarray representing the attribute mixing matrix.
+
+    Notes
+    -----
+    This computes Eq. (2) in Ref. [1]_ , (trace(e)-sum(e^2))/(1-sum(e^2)),
+    where e is the joint probability distribution (mixing matrix)
+    of the specified attribute.
+
+    References
+    ----------
+    .. [1] M. E. J. Newman, Mixing patterns in networks,
+       Physical Review E, 67 026126, 2003
+    """
+    if M.sum() != 1.0:
+        M = M / M.sum()
+    s = (M @ M).sum()
+    t = M.trace()
+    r = (t - s) / (1 - s)
+    return r
+
+
+def _numeric_ac(M, mapping):
+    # M is a 2D numpy array
+    # numeric assortativity coefficient, pearsonr
+    import numpy as np
+
+    if M.sum() != 1.0:
+        M = M / M.sum()
+    x = np.array(list(mapping.keys()))
+    y = x  # x and y have the same support
+    idx = list(mapping.values())
+    a = M.sum(axis=0)
+    b = M.sum(axis=1)
+    vara = (a[idx] * x**2).sum() - ((a[idx] * x).sum()) ** 2
+    varb = (b[idx] * y**2).sum() - ((b[idx] * y).sum()) ** 2
+    xy = np.outer(x, y)
+    ab = np.outer(a[idx], b[idx])
+    return (xy * (M - ab)).sum() / np.sqrt(vara * varb)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/mixing.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/mixing.py
new file mode 100644
index 0000000..f457d75
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/mixing.py
@@ -0,0 +1,298 @@
+"""
+Mixing matrices for node attributes and degree.
+"""
+from networkx.algorithms.assortativity.pairs import node_attribute_xy, node_degree_xy
+from networkx.utils import dict_to_numpy_array
+
+__all__ = [
+    "attribute_mixing_matrix",
+    "attribute_mixing_dict",
+    "degree_mixing_matrix",
+    "degree_mixing_dict",
+    "numeric_mixing_matrix",
+    "mixing_dict",
+]
+
+
+def attribute_mixing_dict(G, attribute, nodes=None, normalized=False):
+    """Returns dictionary representation of mixing matrix for attribute.
+
+    Parameters
+    ----------
+    G : graph
+       NetworkX graph object.
+
+    attribute : string
+       Node attribute key.
+
+    nodes: list or iterable (optional)
+        Unse nodes in container to build the dict. The default is all nodes.
+
+    normalized : bool (default=False)
+       Return counts if False or probabilities if True.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_nodes_from([0, 1], color="red")
+    >>> G.add_nodes_from([2, 3], color="blue")
+    >>> G.add_edge(1, 3)
+    >>> d = nx.attribute_mixing_dict(G, "color")
+    >>> print(d["red"]["blue"])
+    1
+    >>> print(d["blue"]["red"])  # d symmetric for undirected graphs
+    1
+
+    Returns
+    -------
+    d : dictionary
+       Counts or joint probability of occurrence of attribute pairs.
+    """
+    xy_iter = node_attribute_xy(G, attribute, nodes)
+    return mixing_dict(xy_iter, normalized=normalized)
+
+
+def attribute_mixing_matrix(G, attribute, nodes=None, mapping=None, normalized=True):
+    """Returns mixing matrix for attribute.
+
+    Parameters
+    ----------
+    G : graph
+       NetworkX graph object.
+
+    attribute : string
+       Node attribute key.
+
+    nodes: list or iterable (optional)
+        Use only nodes in container to build the matrix. The default is
+        all nodes.
+
+    mapping : dictionary, optional
+       Mapping from node attribute to integer index in matrix.
+       If not specified, an arbitrary ordering will be used.
+
+    normalized : bool (default=True)
+       Return counts if False or probabilities if True.
+
+    Returns
+    -------
+    m: numpy array
+       Counts or joint probability of occurrence of attribute pairs.
+
+    Notes
+    -----
+    If each node has a unique attribute value, the unnormalized mixing matrix
+    will be equal to the adjacency matrix. To get a denser mixing matrix,
+    the rounding can be performed to form groups of nodes with equal values.
+    For example, the exact height of persons in cm (180.79155222, 163.9080892,
+    163.30095355, 167.99016217, 168.21590163, ...) can be rounded to (180, 163,
+    163, 168, 168, ...).
+
+    Definitions of attribute mixing matrix vary on whether the matrix
+    should include rows for attribute values that don't arise. Here we
+    do not include such empty-rows. But you can force them to appear
+    by inputting a `mapping` that includes those values.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(3)
+    >>> gender = {0: 'male', 1: 'female', 2: 'female'}
+    >>> nx.set_node_attributes(G, gender, 'gender')
+    >>> mapping = {'male': 0, 'female': 1}
+    >>> mix_mat = nx.attribute_mixing_matrix(G, 'gender', mapping=mapping)
+    >>> # mixing from male nodes to female nodes
+    >>> mix_mat[mapping['male'], mapping['female']]
+    0.25
+    """
+    d = attribute_mixing_dict(G, attribute, nodes)
+    a = dict_to_numpy_array(d, mapping=mapping)
+    if normalized:
+        a = a / a.sum()
+    return a
+
+
+def degree_mixing_dict(G, x="out", y="in", weight=None, nodes=None, normalized=False):
+    """Returns dictionary representation of mixing matrix for degree.
+
+    Parameters
+    ----------
+    G : graph
+        NetworkX graph object.
+
+    x: string ('in','out')
+       The degree type for source node (directed graphs only).
+
+    y: string ('in','out')
+       The degree type for target node (directed graphs only).
+
+    weight: string or None, optional (default=None)
+       The edge attribute that holds the numerical value used
+       as a weight.  If None, then each edge has weight 1.
+       The degree is the sum of the edge weights adjacent to the node.
+
+    normalized : bool (default=False)
+        Return counts if False or probabilities if True.
+
+    Returns
+    -------
+    d: dictionary
+       Counts or joint probability of occurrence of degree pairs.
+    """
+    xy_iter = node_degree_xy(G, x=x, y=y, nodes=nodes, weight=weight)
+    return mixing_dict(xy_iter, normalized=normalized)
+
+
+def degree_mixing_matrix(
+    G, x="out", y="in", weight=None, nodes=None, normalized=True, mapping=None
+):
+    """Returns mixing matrix for attribute.
+
+    Parameters
+    ----------
+    G : graph
+       NetworkX graph object.
+
+    x: string ('in','out')
+       The degree type for source node (directed graphs only).
+
+    y: string ('in','out')
+       The degree type for target node (directed graphs only).
+
+    nodes: list or iterable (optional)
+        Build the matrix using only nodes in container.
+        The default is all nodes.
+
+    weight: string or None, optional (default=None)
+       The edge attribute that holds the numerical value used
+       as a weight.  If None, then each edge has weight 1.
+       The degree is the sum of the edge weights adjacent to the node.
+
+    normalized : bool (default=True)
+       Return counts if False or probabilities if True.
+
+    mapping : dictionary, optional
+       Mapping from node degree to integer index in matrix.
+       If not specified, an arbitrary ordering will be used.
+
+    Returns
+    -------
+    m: numpy array
+       Counts, or joint probability, of occurrence of node degree.
+
+    Notes
+    -----
+    Definitions of degree mixing matrix vary on whether the matrix
+    should include rows for degree values that don't arise. Here we
+    do not include such empty-rows. But you can force them to appear
+    by inputting a `mapping` that includes those values. See examples.
+
+    Examples
+    --------
+    >>> G = nx.star_graph(3)
+    >>> mix_mat = nx.degree_mixing_matrix(G)
+    >>> mix_mat[0, 1]  # mixing from node degree 1 to node degree 3
+    0.5
+
+    If you want every possible degree to appear as a row, even if no nodes
+    have that degree, use `mapping` as follows,
+
+    >>> max_degree = max(deg for n, deg in G.degree)
+    >>> mapping = {x: x for x in range(max_degree + 1)} # identity mapping
+    >>> mix_mat = nx.degree_mixing_matrix(G, mapping=mapping)
+    >>> mix_mat[3, 1]  # mixing from node degree 3 to node degree 1
+    0.5
+    """
+    d = degree_mixing_dict(G, x=x, y=y, nodes=nodes, weight=weight)
+    a = dict_to_numpy_array(d, mapping=mapping)
+    if normalized:
+        a = a / a.sum()
+    return a
+
+
+def numeric_mixing_matrix(G, attribute, nodes=None, normalized=True, mapping=None):
+    """Returns numeric mixing matrix for attribute.
+
+    .. deprecated:: 2.6
+
+       numeric_mixing_matrix is deprecated and will be removed in 3.0.
+       Use `attribute_mixing_matrix` instead.
+
+    Parameters
+    ----------
+    G : graph
+       NetworkX graph object.
+
+    attribute : string
+       Node attribute key.
+
+    nodes: list or iterable (optional)
+        Build the matrix only with nodes in container. The default is all nodes.
+
+    normalized : bool (default=True)
+       Return counts if False or probabilities if True.
+
+    mapping : dictionary, optional
+       Mapping from node attribute to integer index in matrix.
+       If not specified, an arbitrary ordering will be used.
+
+    Notes
+    -----
+    If each node has a unique attribute value, the unnormalized mixing matrix
+    will be equal to the adjacency matrix. To get a denser mixing matrix,
+    the rounding can be performed to form groups of nodes with equal values.
+    For example, the exact height of persons in cm (180.79155222, 163.9080892,
+    163.30095355, 167.99016217, 168.21590163, ...) can be rounded to (180, 163,
+    163, 168, 168, ...).
+
+    Returns
+    -------
+    m: numpy array
+       Counts, or joint, probability of occurrence of node attribute pairs.
+    """
+    import warnings
+
+    msg = (
+        "numeric_mixing_matrix is deprecated and will be removed in v3.0.\n"
+        "Use `attribute_mixing_matrix` instead."
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    return attribute_mixing_matrix(
+        G, attribute, nodes=nodes, normalized=normalized, mapping=mapping
+    )
+
+
+def mixing_dict(xy, normalized=False):
+    """Returns a dictionary representation of mixing matrix.
+
+    Parameters
+    ----------
+    xy : list or container of two-tuples
+       Pairs of (x,y) items.
+
+    attribute : string
+       Node attribute key
+
+    normalized : bool (default=False)
+       Return counts if False or probabilities if True.
+
+    Returns
+    -------
+    d: dictionary
+       Counts or Joint probability of occurrence of values in xy.
+    """
+    d = {}
+    psum = 0.0
+    for x, y in xy:
+        if x not in d:
+            d[x] = {}
+        if y not in d:
+            d[y] = {}
+        v = d[x].get(y, 0)
+        d[x][y] = v + 1
+        psum += 1
+
+    if normalized:
+        for _, jdict in d.items():
+            for j in jdict:
+                jdict[j] /= psum
+    return d
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/neighbor_degree.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/neighbor_degree.py
new file mode 100644
index 0000000..74a39b1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/neighbor_degree.py
@@ -0,0 +1,159 @@
+import networkx as nx
+
+__all__ = ["average_neighbor_degree"]
+
+
+def average_neighbor_degree(G, source="out", target="out", nodes=None, weight=None):
+    r"""Returns the average degree of the neighborhood of each node.
+
+    In an undirected graph, the neighborhood `N(i)` of node `i` contains the
+    nodes that are connected to `i` by an edge.
+
+    For directed graphs, `N(i)` is defined according to the parameter `source`:
+
+        - if source is 'in', then `N(i)` consists of predecessors of node `i`.
+        - if source is 'out', then `N(i)` consists of successors of node `i`.
+        - if source is 'in+out', then `N(i)` is both predecessors and successors.
+
+    The average neighborhood degree of a node `i` is
+
+    .. math::
+
+        k_{nn,i} = \frac{1}{|N(i)|} \sum_{j \in N(i)} k_j
+
+    where `N(i)` are the neighbors of node `i` and `k_j` is
+    the degree of node `j` which belongs to `N(i)`. For weighted
+    graphs, an analogous measure can be defined [1]_,
+
+    .. math::
+
+        k_{nn,i}^{w} = \frac{1}{s_i} \sum_{j \in N(i)} w_{ij} k_j
+
+    where `s_i` is the weighted degree of node `i`, `w_{ij}`
+    is the weight of the edge that links `i` and `j` and
+    `N(i)` are the neighbors of node `i`.
+
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : string ("in"|"out"|"in+out"), optional (default="out")
+       Directed graphs only.
+       Use "in"- or "out"-neighbors of source node.
+
+    target : string ("in"|"out"|"in+out"), optional (default="out")
+       Directed graphs only.
+       Use "in"- or "out"-degree for target node.
+
+    nodes : list or iterable, optional (default=G.nodes)
+        Compute neighbor degree only for specified nodes.
+
+    weight : string or None, optional (default=None)
+       The edge attribute that holds the numerical value used as a weight.
+       If None, then each edge has weight 1.
+
+    Returns
+    -------
+    d: dict
+       A dictionary keyed by node to the average degree of its neighbors.
+
+    Raises
+    ------
+    NetworkXError
+        If either `source` or `target` are not one of 'in', 'out', or 'in+out'.
+        If either `source` or `target` is passed for an undirected graph.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> G.edges[0, 1]["weight"] = 5
+    >>> G.edges[2, 3]["weight"] = 3
+
+    >>> nx.average_neighbor_degree(G)
+    {0: 2.0, 1: 1.5, 2: 1.5, 3: 2.0}
+    >>> nx.average_neighbor_degree(G, weight="weight")
+    {0: 2.0, 1: 1.1666666666666667, 2: 1.25, 3: 2.0}
+
+    >>> G = nx.DiGraph()
+    >>> nx.add_path(G, [0, 1, 2, 3])
+    >>> nx.average_neighbor_degree(G, source="in", target="in")
+    {0: 0.0, 1: 0.0, 2: 1.0, 3: 1.0}
+
+    >>> nx.average_neighbor_degree(G, source="out", target="out")
+    {0: 1.0, 1: 1.0, 2: 0.0, 3: 0.0}
+
+    See Also
+    --------
+    average_degree_connectivity
+
+    References
+    ----------
+    .. [1] A. Barrat, M. Barthélemy, R. Pastor-Satorras, and A. Vespignani,
+       "The architecture of complex weighted networks".
+       PNAS 101 (11): 3747–3752 (2004).
+    """
+    if G.is_directed():
+        if source == "in":
+            source_degree = G.in_degree
+        elif source == "out":
+            source_degree = G.out_degree
+        elif source == "in+out":
+            source_degree = G.degree
+        else:
+            raise nx.NetworkXError(
+                f"source argument {source} must be 'in', 'out' or 'in+out'"
+            )
+
+        if target == "in":
+            target_degree = G.in_degree
+        elif target == "out":
+            target_degree = G.out_degree
+        elif target == "in+out":
+            target_degree = G.degree
+        else:
+            raise nx.NetworkXError(
+                f"target argument {target} must be 'in', 'out' or 'in+out'"
+            )
+    else:
+        if source != "out" or target != "out":
+            raise nx.NetworkXError(
+                f"source and target arguments are only supported for directed graphs"
+            )
+        source_degree = target_degree = G.degree
+
+    # precompute target degrees -- should *not* be weighted degree
+    t_deg = dict(target_degree())
+
+    # Set up both predecessor and successor neighbor dicts leaving empty if not needed
+    G_P = G_S = {n: {} for n in G}
+    if G.is_directed():
+        # "in" or "in+out" cases: G_P contains predecessors
+        if "in" in source:
+            G_P = G.pred
+        # "out" or "in+out" cases: G_S contains successors
+        if "out" in source:
+            G_S = G.succ
+    else:
+        # undirected leave G_P empty but G_S is the adjacency
+        G_S = G.adj
+
+    # Main loop: Compute average degree of neighbors
+    avg = {}
+    for n, deg in source_degree(nodes, weight=weight):
+        # handle degree zero average
+        if deg == 0:
+            avg[n] = 0.0
+            continue
+
+        # we sum over both G_P and G_S, but one of the two is usually empty.
+        if weight is None:
+            avg[n] = (
+                sum(t_deg[nbr] for nbr in G_S[n]) + sum(t_deg[nbr] for nbr in G_P[n])
+            ) / deg
+        else:
+            avg[n] = (
+                sum(dd.get(weight, 1) * t_deg[nbr] for nbr, dd in G_S[n].items())
+                + sum(dd.get(weight, 1) * t_deg[nbr] for nbr, dd in G_P[n].items())
+            ) / deg
+    return avg
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/pairs.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/pairs.py
new file mode 100644
index 0000000..4c0be7a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/pairs.py
@@ -0,0 +1,114 @@
+"""Generators of  x-y pairs of node data."""
+__all__ = ["node_attribute_xy", "node_degree_xy"]
+
+
+def node_attribute_xy(G, attribute, nodes=None):
+    """Returns iterator of node-attribute pairs for all edges in G.
+
+    Parameters
+    ----------
+    G: NetworkX graph
+
+    attribute: key
+       The node attribute key.
+
+    nodes: list or iterable (optional)
+        Use only edges that are incident to specified nodes.
+        The default is all nodes.
+
+    Returns
+    -------
+    (x, y): 2-tuple
+        Generates 2-tuple of (attribute, attribute) values.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_node(1, color="red")
+    >>> G.add_node(2, color="blue")
+    >>> G.add_edge(1, 2)
+    >>> list(nx.node_attribute_xy(G, "color"))
+    [('red', 'blue')]
+
+    Notes
+    -----
+    For undirected graphs each edge is produced twice, once for each edge
+    representation (u, v) and (v, u), with the exception of self-loop edges
+    which only appear once.
+    """
+    if nodes is None:
+        nodes = set(G)
+    else:
+        nodes = set(nodes)
+    Gnodes = G.nodes
+    for u, nbrsdict in G.adjacency():
+        if u not in nodes:
+            continue
+        uattr = Gnodes[u].get(attribute, None)
+        if G.is_multigraph():
+            for v, keys in nbrsdict.items():
+                vattr = Gnodes[v].get(attribute, None)
+                for _ in keys:
+                    yield (uattr, vattr)
+        else:
+            for v in nbrsdict:
+                vattr = Gnodes[v].get(attribute, None)
+                yield (uattr, vattr)
+
+
+def node_degree_xy(G, x="out", y="in", weight=None, nodes=None):
+    """Generate node degree-degree pairs for edges in G.
+
+    Parameters
+    ----------
+    G: NetworkX graph
+
+    x: string ('in','out')
+       The degree type for source node (directed graphs only).
+
+    y: string ('in','out')
+       The degree type for target node (directed graphs only).
+
+    weight: string or None, optional (default=None)
+       The edge attribute that holds the numerical value used
+       as a weight.  If None, then each edge has weight 1.
+       The degree is the sum of the edge weights adjacent to the node.
+
+    nodes: list or iterable (optional)
+        Use only edges that are adjacency to specified nodes.
+        The default is all nodes.
+
+    Returns
+    -------
+    (x, y): 2-tuple
+        Generates 2-tuple of (degree, degree) values.
+
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_edge(1, 2)
+    >>> list(nx.node_degree_xy(G, x="out", y="in"))
+    [(1, 1)]
+    >>> list(nx.node_degree_xy(G, x="in", y="out"))
+    [(0, 0)]
+
+    Notes
+    -----
+    For undirected graphs each edge is produced twice, once for each edge
+    representation (u, v) and (v, u), with the exception of self-loop edges
+    which only appear once.
+    """
+    nodes = set(G) if nodes is None else set(nodes)
+    if G.is_directed():
+        direction = {"out": G.out_degree, "in": G.in_degree}
+        xdeg = direction[x]
+        ydeg = direction[y]
+    else:
+        xdeg = ydeg = G.degree
+
+    for u, degu in xdeg(nodes, weight=weight):
+        # use G.edges to treat multigraphs correctly
+        neighbors = (nbr for _, nbr in G.edges(u) if nbr in nodes)
+        for _, degv in ydeg(neighbors, weight=weight):
+            yield degu, degv
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/base_test.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/base_test.py
new file mode 100644
index 0000000..73bb32d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/base_test.py
@@ -0,0 +1,85 @@
+import networkx as nx
+
+
+class BaseTestAttributeMixing:
+    @classmethod
+    def setup_class(cls):
+        G = nx.Graph()
+        G.add_nodes_from([0, 1], fish="one")
+        G.add_nodes_from([2, 3], fish="two")
+        G.add_nodes_from([4], fish="red")
+        G.add_nodes_from([5], fish="blue")
+        G.add_edges_from([(0, 1), (2, 3), (0, 4), (2, 5)])
+        cls.G = G
+
+        D = nx.DiGraph()
+        D.add_nodes_from([0, 1], fish="one")
+        D.add_nodes_from([2, 3], fish="two")
+        D.add_nodes_from([4], fish="red")
+        D.add_nodes_from([5], fish="blue")
+        D.add_edges_from([(0, 1), (2, 3), (0, 4), (2, 5)])
+        cls.D = D
+
+        M = nx.MultiGraph()
+        M.add_nodes_from([0, 1], fish="one")
+        M.add_nodes_from([2, 3], fish="two")
+        M.add_nodes_from([4], fish="red")
+        M.add_nodes_from([5], fish="blue")
+        M.add_edges_from([(0, 1), (0, 1), (2, 3)])
+        cls.M = M
+
+        S = nx.Graph()
+        S.add_nodes_from([0, 1], fish="one")
+        S.add_nodes_from([2, 3], fish="two")
+        S.add_nodes_from([4], fish="red")
+        S.add_nodes_from([5], fish="blue")
+        S.add_edge(0, 0)
+        S.add_edge(2, 2)
+        cls.S = S
+
+
+class BaseTestDegreeMixing:
+    @classmethod
+    def setup_class(cls):
+        cls.P4 = nx.path_graph(4)
+        cls.D = nx.DiGraph()
+        cls.D.add_edges_from([(0, 2), (0, 3), (1, 3), (2, 3)])
+        cls.D2 = nx.DiGraph()
+        cls.D2.add_edges_from([(0, 3), (1, 0), (1, 2), (2, 4), (4, 1), (4, 3), (4, 2)])
+        cls.M = nx.MultiGraph()
+        nx.add_path(cls.M, range(4))
+        cls.M.add_edge(0, 1)
+        cls.S = nx.Graph()
+        cls.S.add_edges_from([(0, 0), (1, 1)])
+        cls.W = nx.Graph()
+        cls.W.add_edges_from([(0, 3), (1, 3), (2, 3)], weight=0.5)
+        cls.W.add_edge(0, 2, weight=1)
+        S1 = nx.star_graph(4)
+        S2 = nx.star_graph(4)
+        cls.DS = nx.disjoint_union(S1, S2)
+        cls.DS.add_edge(4, 5)
+
+
+class BaseTestNumericMixing:
+    @classmethod
+    def setup_class(cls):
+        N = nx.Graph()
+        N.add_nodes_from([0, 1], margin=-2)
+        N.add_nodes_from([2, 3], margin=-2)
+        N.add_nodes_from([4], margin=-3)
+        N.add_nodes_from([5], margin=-4)
+        N.add_edges_from([(0, 1), (2, 3), (0, 4), (2, 5)])
+        cls.N = N
+
+        F = nx.Graph()
+        F.add_edges_from([(0, 3), (1, 3), (2, 3)], weight=0.5)
+        F.add_edge(0, 2, weight=1)
+        nx.set_node_attributes(F, dict(F.degree(weight="weight")), "margin")
+        cls.F = F
+
+        M = nx.Graph()
+        M.add_nodes_from([1, 2], margin=-1)
+        M.add_nodes_from([3], margin=1)
+        M.add_nodes_from([4], margin=2)
+        M.add_edges_from([(3, 4), (1, 2), (1, 3)])
+        cls.M = M
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_connectivity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_connectivity.py
new file mode 100644
index 0000000..c8fae23
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_connectivity.py
@@ -0,0 +1,145 @@
+from itertools import permutations
+
+import pytest
+
+import networkx as nx
+
+
+class TestNeighborConnectivity:
+    def test_degree_p4(self):
+        G = nx.path_graph(4)
+        answer = {1: 2.0, 2: 1.5}
+        nd = nx.average_degree_connectivity(G)
+        assert nd == answer
+
+        D = G.to_directed()
+        answer = {2: 2.0, 4: 1.5}
+        nd = nx.average_degree_connectivity(D)
+        assert nd == answer
+
+        answer = {1: 2.0, 2: 1.5}
+        D = G.to_directed()
+        nd = nx.average_degree_connectivity(D, source="in", target="in")
+        assert nd == answer
+
+        D = G.to_directed()
+        nd = nx.average_degree_connectivity(D, source="in", target="in")
+        assert nd == answer
+
+    def test_degree_p4_weighted(self):
+        G = nx.path_graph(4)
+        G[1][2]["weight"] = 4
+        answer = {1: 2.0, 2: 1.8}
+        nd = nx.average_degree_connectivity(G, weight="weight")
+        assert nd == answer
+        answer = {1: 2.0, 2: 1.5}
+        nd = nx.average_degree_connectivity(G)
+        assert nd == answer
+
+        D = G.to_directed()
+        answer = {2: 2.0, 4: 1.8}
+        nd = nx.average_degree_connectivity(D, weight="weight")
+        assert nd == answer
+
+        answer = {1: 2.0, 2: 1.8}
+        D = G.to_directed()
+        nd = nx.average_degree_connectivity(
+            D, weight="weight", source="in", target="in"
+        )
+        assert nd == answer
+
+        D = G.to_directed()
+        nd = nx.average_degree_connectivity(
+            D, source="in", target="out", weight="weight"
+        )
+        assert nd == answer
+
+    def test_weight_keyword(self):
+        G = nx.path_graph(4)
+        G[1][2]["other"] = 4
+        answer = {1: 2.0, 2: 1.8}
+        nd = nx.average_degree_connectivity(G, weight="other")
+        assert nd == answer
+        answer = {1: 2.0, 2: 1.5}
+        nd = nx.average_degree_connectivity(G, weight=None)
+        assert nd == answer
+
+        D = G.to_directed()
+        answer = {2: 2.0, 4: 1.8}
+        nd = nx.average_degree_connectivity(D, weight="other")
+        assert nd == answer
+
+        answer = {1: 2.0, 2: 1.8}
+        D = G.to_directed()
+        nd = nx.average_degree_connectivity(D, weight="other", source="in", target="in")
+        assert nd == answer
+
+        D = G.to_directed()
+        nd = nx.average_degree_connectivity(D, weight="other", source="in", target="in")
+        assert nd == answer
+
+    def test_degree_barrat(self):
+        G = nx.star_graph(5)
+        G.add_edges_from([(5, 6), (5, 7), (5, 8), (5, 9)])
+        G[0][5]["weight"] = 5
+        nd = nx.average_degree_connectivity(G)[5]
+        assert nd == 1.8
+        nd = nx.average_degree_connectivity(G, weight="weight")[5]
+        assert nd == pytest.approx(3.222222, abs=1e-5)
+        nd = nx.k_nearest_neighbors(G, weight="weight")[5]
+        assert nd == pytest.approx(3.222222, abs=1e-5)
+
+    def test_zero_deg(self):
+        G = nx.DiGraph()
+        G.add_edge(1, 2)
+        G.add_edge(1, 3)
+        G.add_edge(1, 4)
+        c = nx.average_degree_connectivity(G)
+        assert c == {1: 0, 3: 1}
+        c = nx.average_degree_connectivity(G, source="in", target="in")
+        assert c == {0: 0, 1: 0}
+        c = nx.average_degree_connectivity(G, source="in", target="out")
+        assert c == {0: 0, 1: 3}
+        c = nx.average_degree_connectivity(G, source="in", target="in+out")
+        assert c == {0: 0, 1: 3}
+        c = nx.average_degree_connectivity(G, source="out", target="out")
+        assert c == {0: 0, 3: 0}
+        c = nx.average_degree_connectivity(G, source="out", target="in")
+        assert c == {0: 0, 3: 1}
+        c = nx.average_degree_connectivity(G, source="out", target="in+out")
+        assert c == {0: 0, 3: 1}
+
+    def test_in_out_weight(self):
+        G = nx.DiGraph()
+        G.add_edge(1, 2, weight=1)
+        G.add_edge(1, 3, weight=1)
+        G.add_edge(3, 1, weight=1)
+        for s, t in permutations(["in", "out", "in+out"], 2):
+            c = nx.average_degree_connectivity(G, source=s, target=t)
+            cw = nx.average_degree_connectivity(G, source=s, target=t, weight="weight")
+            assert c == cw
+
+    def test_invalid_source(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.DiGraph()
+            nx.average_degree_connectivity(G, source="bogus")
+
+    def test_invalid_target(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.DiGraph()
+            nx.average_degree_connectivity(G, target="bogus")
+
+    def test_invalid_undirected_graph(self):
+        G = nx.Graph()
+        with pytest.raises(nx.NetworkXError):
+            nx.average_degree_connectivity(G, target="bogus")
+        with pytest.raises(nx.NetworkXError):
+            nx.average_degree_connectivity(G, source="bogus")
+
+    def test_single_node(self):
+        # TODO Is this really the intended behavior for providing a
+        # single node as the argument `nodes`? Shouldn't the function
+        # just return the connectivity value itself?
+        G = nx.trivial_graph()
+        conn = nx.average_degree_connectivity(G, nodes=0)
+        assert conn == {0: 0}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_correlation.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_correlation.py
new file mode 100644
index 0000000..ffba703
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_correlation.py
@@ -0,0 +1,114 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+
+import networkx as nx
+from networkx.algorithms.assortativity.correlation import attribute_ac
+
+from .base_test import (
+    BaseTestAttributeMixing,
+    BaseTestDegreeMixing,
+    BaseTestNumericMixing,
+)
+
+
+class TestDegreeMixingCorrelation(BaseTestDegreeMixing):
+    def test_degree_assortativity_undirected(self):
+        r = nx.degree_assortativity_coefficient(self.P4)
+        np.testing.assert_almost_equal(r, -1.0 / 2, decimal=4)
+
+    def test_degree_assortativity_directed(self):
+        r = nx.degree_assortativity_coefficient(self.D)
+        np.testing.assert_almost_equal(r, -0.57735, decimal=4)
+
+    def test_degree_assortativity_directed2(self):
+        """Test degree assortativity for a directed graph where the set of
+        in/out degree does not equal the total degree."""
+        r = nx.degree_assortativity_coefficient(self.D2)
+        np.testing.assert_almost_equal(r, 0.14852, decimal=4)
+
+    def test_degree_assortativity_multigraph(self):
+        r = nx.degree_assortativity_coefficient(self.M)
+        np.testing.assert_almost_equal(r, -1.0 / 7.0, decimal=4)
+
+    def test_degree_pearson_assortativity_undirected(self):
+        r = nx.degree_pearson_correlation_coefficient(self.P4)
+        np.testing.assert_almost_equal(r, -1.0 / 2, decimal=4)
+
+    def test_degree_pearson_assortativity_directed(self):
+        r = nx.degree_pearson_correlation_coefficient(self.D)
+        np.testing.assert_almost_equal(r, -0.57735, decimal=4)
+
+    def test_degree_pearson_assortativity_directed2(self):
+        """Test degree assortativity with Pearson for a directed graph where
+        the set of in/out degree does not equal the total degree."""
+        r = nx.degree_pearson_correlation_coefficient(self.D2)
+        np.testing.assert_almost_equal(r, 0.14852, decimal=4)
+
+    def test_degree_pearson_assortativity_multigraph(self):
+        r = nx.degree_pearson_correlation_coefficient(self.M)
+        np.testing.assert_almost_equal(r, -1.0 / 7.0, decimal=4)
+
+    def test_degree_assortativity_weighted(self):
+        r = nx.degree_assortativity_coefficient(self.W, weight="weight")
+        np.testing.assert_almost_equal(r, -0.1429, decimal=4)
+
+    def test_degree_assortativity_double_star(self):
+        r = nx.degree_assortativity_coefficient(self.DS)
+        np.testing.assert_almost_equal(r, -0.9339, decimal=4)
+
+
+class TestAttributeMixingCorrelation(BaseTestAttributeMixing):
+    def test_attribute_assortativity_undirected(self):
+        r = nx.attribute_assortativity_coefficient(self.G, "fish")
+        assert r == 6.0 / 22.0
+
+    def test_attribute_assortativity_directed(self):
+        r = nx.attribute_assortativity_coefficient(self.D, "fish")
+        assert r == 1.0 / 3.0
+
+    def test_attribute_assortativity_multigraph(self):
+        r = nx.attribute_assortativity_coefficient(self.M, "fish")
+        assert r == 1.0
+
+    def test_attribute_assortativity_coefficient(self):
+        # from "Mixing patterns in networks"
+        # fmt: off
+        a = np.array([[0.258, 0.016, 0.035, 0.013],
+                      [0.012, 0.157, 0.058, 0.019],
+                      [0.013, 0.023, 0.306, 0.035],
+                      [0.005, 0.007, 0.024, 0.016]])
+        # fmt: on
+        r = attribute_ac(a)
+        np.testing.assert_almost_equal(r, 0.623, decimal=3)
+
+    def test_attribute_assortativity_coefficient2(self):
+        # fmt: off
+        a = np.array([[0.18, 0.02, 0.01, 0.03],
+                      [0.02, 0.20, 0.03, 0.02],
+                      [0.01, 0.03, 0.16, 0.01],
+                      [0.03, 0.02, 0.01, 0.22]])
+        # fmt: on
+        r = attribute_ac(a)
+        np.testing.assert_almost_equal(r, 0.68, decimal=2)
+
+    def test_attribute_assortativity(self):
+        a = np.array([[50, 50, 0], [50, 50, 0], [0, 0, 2]])
+        r = attribute_ac(a)
+        np.testing.assert_almost_equal(r, 0.029, decimal=3)
+
+
+class TestNumericMixingCorrelation(BaseTestNumericMixing):
+    def test_numeric_assortativity_negative(self):
+        r = nx.numeric_assortativity_coefficient(self.N, "margin")
+        np.testing.assert_almost_equal(r, -0.2903, decimal=4)
+
+    def test_numeric_assortativity_float(self):
+        r = nx.numeric_assortativity_coefficient(self.F, "margin")
+        np.testing.assert_almost_equal(r, -0.1429, decimal=4)
+
+    def test_numeric_assortativity_mixed(self):
+        r = nx.numeric_assortativity_coefficient(self.M, "margin")
+        np.testing.assert_almost_equal(r, 0.4340, decimal=4)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_mixing.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_mixing.py
new file mode 100644
index 0000000..cb4ae07
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_mixing.py
@@ -0,0 +1,182 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+
+
+import networkx as nx
+
+from .base_test import (
+    BaseTestAttributeMixing,
+    BaseTestDegreeMixing,
+    BaseTestNumericMixing,
+)
+
+
+class TestDegreeMixingDict(BaseTestDegreeMixing):
+    def test_degree_mixing_dict_undirected(self):
+        d = nx.degree_mixing_dict(self.P4)
+        d_result = {1: {2: 2}, 2: {1: 2, 2: 2}}
+        assert d == d_result
+
+    def test_degree_mixing_dict_undirected_normalized(self):
+        d = nx.degree_mixing_dict(self.P4, normalized=True)
+        d_result = {1: {2: 1.0 / 3}, 2: {1: 1.0 / 3, 2: 1.0 / 3}}
+        assert d == d_result
+
+    def test_degree_mixing_dict_directed(self):
+        d = nx.degree_mixing_dict(self.D)
+        print(d)
+        d_result = {1: {3: 2}, 2: {1: 1, 3: 1}, 3: {}}
+        assert d == d_result
+
+    def test_degree_mixing_dict_multigraph(self):
+        d = nx.degree_mixing_dict(self.M)
+        d_result = {1: {2: 1}, 2: {1: 1, 3: 3}, 3: {2: 3}}
+        assert d == d_result
+
+    def test_degree_mixing_dict_weighted(self):
+        d = nx.degree_mixing_dict(self.W, weight="weight")
+        d_result = {0.5: {1.5: 1}, 1.5: {1.5: 6, 0.5: 1}}
+        assert d == d_result
+
+
+class TestDegreeMixingMatrix(BaseTestDegreeMixing):
+    def test_degree_mixing_matrix_undirected(self):
+        # fmt: off
+        a_result = np.array([[0, 2],
+                             [2, 2]]
+                            )
+        # fmt: on
+        a = nx.degree_mixing_matrix(self.P4, normalized=False)
+        np.testing.assert_equal(a, a_result)
+        a = nx.degree_mixing_matrix(self.P4)
+        np.testing.assert_equal(a, a_result / a_result.sum())
+
+    def test_degree_mixing_matrix_directed(self):
+        # fmt: off
+        a_result = np.array([[0, 0, 2],
+                             [1, 0, 1],
+                             [0, 0, 0]]
+                            )
+        # fmt: on
+        a = nx.degree_mixing_matrix(self.D, normalized=False)
+        np.testing.assert_equal(a, a_result)
+        a = nx.degree_mixing_matrix(self.D)
+        np.testing.assert_equal(a, a_result / a_result.sum())
+
+    def test_degree_mixing_matrix_multigraph(self):
+        # fmt: off
+        a_result = np.array([[0, 1, 0],
+                             [1, 0, 3],
+                             [0, 3, 0]]
+                            )
+        # fmt: on
+        a = nx.degree_mixing_matrix(self.M, normalized=False)
+        np.testing.assert_equal(a, a_result)
+        a = nx.degree_mixing_matrix(self.M)
+        np.testing.assert_equal(a, a_result / a_result.sum())
+
+    def test_degree_mixing_matrix_selfloop(self):
+        # fmt: off
+        a_result = np.array([[2]])
+        # fmt: on
+        a = nx.degree_mixing_matrix(self.S, normalized=False)
+        np.testing.assert_equal(a, a_result)
+        a = nx.degree_mixing_matrix(self.S)
+        np.testing.assert_equal(a, a_result / a_result.sum())
+
+    def test_degree_mixing_matrix_weighted(self):
+        a_result = np.array([[0.0, 1.0], [1.0, 6.0]])
+        a = nx.degree_mixing_matrix(self.W, weight="weight", normalized=False)
+        np.testing.assert_equal(a, a_result)
+        a = nx.degree_mixing_matrix(self.W, weight="weight")
+        np.testing.assert_equal(a, a_result / float(a_result.sum()))
+
+    def test_degree_mixing_matrix_mapping(self):
+        a_result = np.array([[6.0, 1.0], [1.0, 0.0]])
+        mapping = {0.5: 1, 1.5: 0}
+        a = nx.degree_mixing_matrix(
+            self.W, weight="weight", normalized=False, mapping=mapping
+        )
+        np.testing.assert_equal(a, a_result)
+
+
+class TestAttributeMixingDict(BaseTestAttributeMixing):
+    def test_attribute_mixing_dict_undirected(self):
+        d = nx.attribute_mixing_dict(self.G, "fish")
+        d_result = {
+            "one": {"one": 2, "red": 1},
+            "two": {"two": 2, "blue": 1},
+            "red": {"one": 1},
+            "blue": {"two": 1},
+        }
+        assert d == d_result
+
+    def test_attribute_mixing_dict_directed(self):
+        d = nx.attribute_mixing_dict(self.D, "fish")
+        d_result = {
+            "one": {"one": 1, "red": 1},
+            "two": {"two": 1, "blue": 1},
+            "red": {},
+            "blue": {},
+        }
+        assert d == d_result
+
+    def test_attribute_mixing_dict_multigraph(self):
+        d = nx.attribute_mixing_dict(self.M, "fish")
+        d_result = {"one": {"one": 4}, "two": {"two": 2}}
+        assert d == d_result
+
+
+class TestAttributeMixingMatrix(BaseTestAttributeMixing):
+    def test_attribute_mixing_matrix_undirected(self):
+        mapping = {"one": 0, "two": 1, "red": 2, "blue": 3}
+        a_result = np.array([[2, 0, 1, 0], [0, 2, 0, 1], [1, 0, 0, 0], [0, 1, 0, 0]])
+        a = nx.attribute_mixing_matrix(
+            self.G, "fish", mapping=mapping, normalized=False
+        )
+        np.testing.assert_equal(a, a_result)
+        a = nx.attribute_mixing_matrix(self.G, "fish", mapping=mapping)
+        np.testing.assert_equal(a, a_result / a_result.sum())
+
+    def test_attribute_mixing_matrix_directed(self):
+        mapping = {"one": 0, "two": 1, "red": 2, "blue": 3}
+        a_result = np.array([[1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0]])
+        a = nx.attribute_mixing_matrix(
+            self.D, "fish", mapping=mapping, normalized=False
+        )
+        np.testing.assert_equal(a, a_result)
+        a = nx.attribute_mixing_matrix(self.D, "fish", mapping=mapping)
+        np.testing.assert_equal(a, a_result / a_result.sum())
+
+    def test_attribute_mixing_matrix_multigraph(self):
+        mapping = {"one": 0, "two": 1, "red": 2, "blue": 3}
+        a_result = np.array([[4, 0, 0, 0], [0, 2, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
+        a = nx.attribute_mixing_matrix(
+            self.M, "fish", mapping=mapping, normalized=False
+        )
+        np.testing.assert_equal(a, a_result)
+        a = nx.attribute_mixing_matrix(self.M, "fish", mapping=mapping)
+        np.testing.assert_equal(a, a_result / a_result.sum())
+
+
+class TestNumericMixingMatrix(BaseTestNumericMixing):
+    def test_numeric_mixing_matrix_negative(self):
+        mapping = {-2: 0, -3: 1, -4: 2}
+        a_result = np.array([[4.0, 1.0, 1.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]])
+        a = nx.numeric_mixing_matrix(
+            self.N, "margin", mapping=mapping, normalized=False
+        )
+        np.testing.assert_equal(a, a_result)
+        a = nx.numeric_mixing_matrix(self.N, "margin", mapping=mapping)
+        np.testing.assert_equal(a, a_result / float(a_result.sum()))
+
+    def test_numeric_mixing_matrix_float(self):
+        mapping = {0.5: 1, 1.5: 0}
+        a_result = np.array([[6.0, 1.0], [1.0, 0.0]])
+        a = nx.numeric_mixing_matrix(
+            self.F, "margin", mapping=mapping, normalized=False
+        )
+        np.testing.assert_equal(a, a_result)
+        a = nx.numeric_mixing_matrix(self.F, "margin", mapping=mapping)
+        np.testing.assert_equal(a, a_result / a_result.sum())
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_neighbor_degree.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_neighbor_degree.py
new file mode 100644
index 0000000..27abbb0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_neighbor_degree.py
@@ -0,0 +1,104 @@
+import pytest
+
+import networkx as nx
+
+
+class TestAverageNeighbor:
+    def test_degree_p4(self):
+        G = nx.path_graph(4)
+        answer = {0: 2, 1: 1.5, 2: 1.5, 3: 2}
+        nd = nx.average_neighbor_degree(G)
+        assert nd == answer
+
+        D = G.to_directed()
+        nd = nx.average_neighbor_degree(D)
+        assert nd == answer
+
+        D = nx.DiGraph(G.edges(data=True))
+        nd = nx.average_neighbor_degree(D)
+        assert nd == {0: 1, 1: 1, 2: 0, 3: 0}
+        nd = nx.average_neighbor_degree(D, "in", "out")
+        assert nd == {0: 0, 1: 1, 2: 1, 3: 1}
+        nd = nx.average_neighbor_degree(D, "out", "in")
+        assert nd == {0: 1, 1: 1, 2: 1, 3: 0}
+        nd = nx.average_neighbor_degree(D, "in", "in")
+        assert nd == {0: 0, 1: 0, 2: 1, 3: 1}
+
+    def test_degree_p4_weighted(self):
+        G = nx.path_graph(4)
+        G[1][2]["weight"] = 4
+        answer = {0: 2, 1: 1.8, 2: 1.8, 3: 2}
+        nd = nx.average_neighbor_degree(G, weight="weight")
+        assert nd == answer
+
+        D = G.to_directed()
+        nd = nx.average_neighbor_degree(D, weight="weight")
+        assert nd == answer
+
+        D = nx.DiGraph(G.edges(data=True))
+        print(D.edges(data=True))
+        nd = nx.average_neighbor_degree(D, weight="weight")
+        assert nd == {0: 1, 1: 1, 2: 0, 3: 0}
+        nd = nx.average_neighbor_degree(D, "out", "out", weight="weight")
+        assert nd == {0: 1, 1: 1, 2: 0, 3: 0}
+        nd = nx.average_neighbor_degree(D, "in", "in", weight="weight")
+        assert nd == {0: 0, 1: 0, 2: 1, 3: 1}
+        nd = nx.average_neighbor_degree(D, "in", "out", weight="weight")
+        assert nd == {0: 0, 1: 1, 2: 1, 3: 1}
+        nd = nx.average_neighbor_degree(D, "out", "in", weight="weight")
+        assert nd == {0: 1, 1: 1, 2: 1, 3: 0}
+
+        D = G.to_directed()
+        nd = nx.average_neighbor_degree(D, weight="weight")
+        assert nd == answer
+        nd = nx.average_neighbor_degree(D, source="out", target="out", weight="weight")
+        assert nd == answer
+
+        D = G.to_directed()
+        nd = nx.average_neighbor_degree(D, source="in", target="in", weight="weight")
+        assert nd == answer
+
+    def test_degree_k4(self):
+        G = nx.complete_graph(4)
+        answer = {0: 3, 1: 3, 2: 3, 3: 3}
+        nd = nx.average_neighbor_degree(G)
+        assert nd == answer
+
+        D = G.to_directed()
+        nd = nx.average_neighbor_degree(D)
+        assert nd == answer
+
+        D = G.to_directed()
+        nd = nx.average_neighbor_degree(D)
+        assert nd == answer
+
+        D = G.to_directed()
+        nd = nx.average_neighbor_degree(D, source="in", target="in")
+        assert nd == answer
+
+    def test_degree_k4_nodes(self):
+        G = nx.complete_graph(4)
+        answer = {1: 3.0, 2: 3.0}
+        nd = nx.average_neighbor_degree(G, nodes=[1, 2])
+        assert nd == answer
+
+    def test_degree_barrat(self):
+        G = nx.star_graph(5)
+        G.add_edges_from([(5, 6), (5, 7), (5, 8), (5, 9)])
+        G[0][5]["weight"] = 5
+        nd = nx.average_neighbor_degree(G)[5]
+        assert nd == 1.8
+        nd = nx.average_neighbor_degree(G, weight="weight")[5]
+        assert nd == pytest.approx(3.222222, abs=1e-5)
+
+    def test_error_invalid_source_target(self):
+        G = nx.path_graph(4)
+        with pytest.raises(nx.NetworkXError):
+            nx.average_neighbor_degree(G, "error")
+        with pytest.raises(nx.NetworkXError):
+            nx.average_neighbor_degree(G, "in", "error")
+        G = G.to_directed()
+        with pytest.raises(nx.NetworkXError):
+            nx.average_neighbor_degree(G, "error")
+        with pytest.raises(nx.NetworkXError):
+            nx.average_neighbor_degree(G, "in", "error")
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_pairs.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_pairs.py
new file mode 100644
index 0000000..3984292
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/assortativity/tests/test_pairs.py
@@ -0,0 +1,87 @@
+import networkx as nx
+
+from .base_test import BaseTestAttributeMixing, BaseTestDegreeMixing
+
+
+class TestAttributeMixingXY(BaseTestAttributeMixing):
+    def test_node_attribute_xy_undirected(self):
+        attrxy = sorted(nx.node_attribute_xy(self.G, "fish"))
+        attrxy_result = sorted(
+            [
+                ("one", "one"),
+                ("one", "one"),
+                ("two", "two"),
+                ("two", "two"),
+                ("one", "red"),
+                ("red", "one"),
+                ("blue", "two"),
+                ("two", "blue"),
+            ]
+        )
+        assert attrxy == attrxy_result
+
+    def test_node_attribute_xy_undirected_nodes(self):
+        attrxy = sorted(nx.node_attribute_xy(self.G, "fish", nodes=["one", "yellow"]))
+        attrxy_result = sorted([])
+        assert attrxy == attrxy_result
+
+    def test_node_attribute_xy_directed(self):
+        attrxy = sorted(nx.node_attribute_xy(self.D, "fish"))
+        attrxy_result = sorted(
+            [("one", "one"), ("two", "two"), ("one", "red"), ("two", "blue")]
+        )
+        assert attrxy == attrxy_result
+
+    def test_node_attribute_xy_multigraph(self):
+        attrxy = sorted(nx.node_attribute_xy(self.M, "fish"))
+        attrxy_result = [
+            ("one", "one"),
+            ("one", "one"),
+            ("one", "one"),
+            ("one", "one"),
+            ("two", "two"),
+            ("two", "two"),
+        ]
+        assert attrxy == attrxy_result
+
+    def test_node_attribute_xy_selfloop(self):
+        attrxy = sorted(nx.node_attribute_xy(self.S, "fish"))
+        attrxy_result = [("one", "one"), ("two", "two")]
+        assert attrxy == attrxy_result
+
+
+class TestDegreeMixingXY(BaseTestDegreeMixing):
+    def test_node_degree_xy_undirected(self):
+        xy = sorted(nx.node_degree_xy(self.P4))
+        xy_result = sorted([(1, 2), (2, 1), (2, 2), (2, 2), (1, 2), (2, 1)])
+        assert xy == xy_result
+
+    def test_node_degree_xy_undirected_nodes(self):
+        xy = sorted(nx.node_degree_xy(self.P4, nodes=[0, 1, -1]))
+        xy_result = sorted([(1, 2), (2, 1)])
+        assert xy == xy_result
+
+    def test_node_degree_xy_directed(self):
+        xy = sorted(nx.node_degree_xy(self.D))
+        xy_result = sorted([(2, 1), (2, 3), (1, 3), (1, 3)])
+        assert xy == xy_result
+
+    def test_node_degree_xy_multigraph(self):
+        xy = sorted(nx.node_degree_xy(self.M))
+        xy_result = sorted(
+            [(2, 3), (2, 3), (3, 2), (3, 2), (2, 3), (3, 2), (1, 2), (2, 1)]
+        )
+        assert xy == xy_result
+
+    def test_node_degree_xy_selfloop(self):
+        xy = sorted(nx.node_degree_xy(self.S))
+        xy_result = sorted([(2, 2), (2, 2)])
+        assert xy == xy_result
+
+    def test_node_degree_xy_weighted(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=7)
+        G.add_edge(2, 3, weight=10)
+        xy = sorted(nx.node_degree_xy(G, weight="weight"))
+        xy_result = sorted([(7, 17), (17, 10), (17, 7), (10, 17)])
+        assert xy == xy_result
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/asteroidal.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/asteroidal.py
new file mode 100644
index 0000000..8dfa933
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/asteroidal.py
@@ -0,0 +1,167 @@
+"""
+Algorithms for asteroidal triples and asteroidal numbers in graphs.
+
+An asteroidal triple in a graph G is a set of three non-adjacent vertices
+u, v and w such that there exist a path between any two of them that avoids
+closed neighborhood of the third. More formally, v_j, v_k belongs to the same
+connected component of G - N[v_i], where N[v_i] denotes the closed neighborhood
+of v_i. A graph which does not contain any asteroidal triples is called
+an AT-free graph. The class of AT-free graphs is a graph class for which
+many NP-complete problems are solvable in polynomial time. Amongst them,
+independent set and coloring.
+"""
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["is_at_free", "find_asteroidal_triple"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def find_asteroidal_triple(G):
+    r"""Find an asteroidal triple in the given graph.
+
+    An asteroidal triple is a triple of non-adjacent vertices such that
+    there exists a path between any two of them which avoids the closed
+    neighborhood of the third. It checks all independent triples of vertices
+    and whether they are an asteroidal triple or not. This is done with the
+    help of a data structure called a component structure.
+    A component structure encodes information about which vertices belongs to
+    the same connected component when the closed neighborhood of a given vertex
+    is removed from the graph. The algorithm used to check is the trivial
+    one, outlined in [1]_, which has a runtime of
+    :math:`O(|V||\overline{E} + |V||E|)`, where the second term is the
+    creation of the component structure.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        The graph to check whether is AT-free or not
+
+    Returns
+    -------
+    list or None
+        An asteroidal triple is returned as a list of nodes. If no asteroidal
+        triple exists, i.e. the graph is AT-free, then None is returned.
+        The returned value depends on the certificate parameter. The default
+        option is a bool which is True if the graph is AT-free, i.e. the
+        given graph contains no asteroidal triples, and False otherwise, i.e.
+        if the graph contains at least one asteroidal triple.
+
+    Notes
+    -----
+    The component structure and the algorithm is described in [1]_. The current
+    implementation implements the trivial algorithm for simple graphs.
+
+    References
+    ----------
+    .. [1] Ekkehard Köhler,
+       "Recognizing Graphs without asteroidal triples",
+       Journal of Discrete Algorithms 2, pages 439-452, 2004.
+       https://www.sciencedirect.com/science/article/pii/S157086670400019X
+    """
+    V = set(G.nodes)
+
+    if len(V) < 6:
+        # An asteroidal triple cannot exist in a graph with 5 or less vertices.
+        return None
+
+    component_structure = create_component_structure(G)
+    E_complement = set(nx.complement(G).edges)
+
+    for e in E_complement:
+        u = e[0]
+        v = e[1]
+        u_neighborhood = set(G[u]).union([u])
+        v_neighborhood = set(G[v]).union([v])
+        union_of_neighborhoods = u_neighborhood.union(v_neighborhood)
+        for w in V - union_of_neighborhoods:
+            # Check for each pair of vertices whether they belong to the
+            # same connected component when the closed neighborhood of the
+            # third is removed.
+            if (
+                component_structure[u][v] == component_structure[u][w]
+                and component_structure[v][u] == component_structure[v][w]
+                and component_structure[w][u] == component_structure[w][v]
+            ):
+                return [u, v, w]
+    return None
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def is_at_free(G):
+    """Check if a graph is AT-free.
+
+    The method uses the `find_asteroidal_triple` method to recognize
+    an AT-free graph. If no asteroidal triple is found the graph is
+    AT-free and True is returned. If at least one asteroidal triple is
+    found the graph is not AT-free and False is returned.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        The graph to check whether is AT-free or not.
+
+    Returns
+    -------
+    bool
+        True if G is AT-free and False otherwise.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (4, 5)])
+    >>> nx.is_at_free(G)
+    True
+
+    >>> G = nx.cycle_graph(6)
+    >>> nx.is_at_free(G)
+    False
+    """
+    return find_asteroidal_triple(G) is None
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def create_component_structure(G):
+    r"""Create component structure for G.
+
+    A *component structure* is an `nxn` array, denoted `c`, where `n` is
+    the number of vertices,  where each row and column corresponds to a vertex.
+
+    .. math::
+        c_{uv} = \begin{cases} 0, if v \in N[u] \\
+            k, if v \in component k of G \setminus N[u] \end{cases}
+
+    Where `k` is an arbitrary label for each component. The structure is used
+    to simplify the detection of asteroidal triples.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        Undirected, simple graph.
+
+    Returns
+    -------
+    component_structure : dictionary
+        A dictionary of dictionaries, keyed by pairs of vertices.
+
+    """
+    V = set(G.nodes)
+    component_structure = {}
+    for v in V:
+        label = 0
+        closed_neighborhood = set(G[v]).union({v})
+        row_dict = {}
+        for u in closed_neighborhood:
+            row_dict[u] = 0
+
+        G_reduced = G.subgraph(set(G.nodes) - closed_neighborhood)
+        for cc in nx.connected_components(G_reduced):
+            label += 1
+            for u in cc:
+                row_dict[u] = label
+
+        component_structure[v] = row_dict
+
+    return component_structure
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/__init__.py
new file mode 100644
index 0000000..09e5a38
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/__init__.py
@@ -0,0 +1,86 @@
+r""" This module provides functions and operations for bipartite
+graphs.  Bipartite graphs `B = (U, V, E)` have two node sets `U,V` and edges in
+`E` that only connect nodes from opposite sets. It is common in the literature
+to use an spatial analogy referring to the two node sets as top and bottom nodes.
+
+The bipartite algorithms are not imported into the networkx namespace
+at the top level so the easiest way to use them is with:
+
+>>> from networkx.algorithms import bipartite
+
+NetworkX does not have a custom bipartite graph class but the Graph()
+or DiGraph() classes can be used to represent bipartite graphs. However,
+you have to keep track of which set each node belongs to, and make
+sure that there is no edge between nodes of the same set. The convention used
+in NetworkX is to use a node attribute named `bipartite` with values 0 or 1 to
+identify the sets each node belongs to. This convention is not enforced in
+the source code of bipartite functions, it's only a recommendation.
+
+For example:
+
+>>> B = nx.Graph()
+>>> # Add nodes with the node attribute "bipartite"
+>>> B.add_nodes_from([1, 2, 3, 4], bipartite=0)
+>>> B.add_nodes_from(["a", "b", "c"], bipartite=1)
+>>> # Add edges only between nodes of opposite node sets
+>>> B.add_edges_from([(1, "a"), (1, "b"), (2, "b"), (2, "c"), (3, "c"), (4, "a")])
+
+Many algorithms of the bipartite module of NetworkX require, as an argument, a
+container with all the nodes that belong to one set, in addition to the bipartite
+graph `B`. The functions in the bipartite package do not check that the node set
+is actually correct nor that the input graph is actually bipartite.
+If `B` is connected, you can find the two node sets using a two-coloring
+algorithm:
+
+>>> nx.is_connected(B)
+True
+>>> bottom_nodes, top_nodes = bipartite.sets(B)
+
+However, if the input graph is not connected, there are more than one possible
+colorations. This is the reason why we require the user to pass a container
+with all nodes of one bipartite node set as an argument to most bipartite
+functions. In the face of ambiguity, we refuse the temptation to guess and
+raise an :exc:`AmbiguousSolution <networkx.AmbiguousSolution>`
+Exception if the input graph for
+:func:`bipartite.sets <networkx.algorithms.bipartite.basic.sets>`
+is disconnected.
+
+Using the `bipartite` node attribute, you can easily get the two node sets:
+
+>>> top_nodes = {n for n, d in B.nodes(data=True) if d["bipartite"] == 0}
+>>> bottom_nodes = set(B) - top_nodes
+
+So you can easily use the bipartite algorithms that require, as an argument, a
+container with all nodes that belong to one node set:
+
+>>> print(round(bipartite.density(B, bottom_nodes), 2))
+0.5
+>>> G = bipartite.projected_graph(B, top_nodes)
+
+All bipartite graph generators in NetworkX build bipartite graphs with the
+`bipartite` node attribute. Thus, you can use the same approach:
+
+>>> RB = bipartite.random_graph(5, 7, 0.2)
+>>> RB_top = {n for n, d in RB.nodes(data=True) if d["bipartite"] == 0}
+>>> RB_bottom = set(RB) - RB_top
+>>> list(RB_top)
+[0, 1, 2, 3, 4]
+>>> list(RB_bottom)
+[5, 6, 7, 8, 9, 10, 11]
+
+For other bipartite graph generators see
+:mod:`Generators <networkx.algorithms.bipartite.generators>`.
+
+"""
+
+from networkx.algorithms.bipartite.basic import *
+from networkx.algorithms.bipartite.centrality import *
+from networkx.algorithms.bipartite.cluster import *
+from networkx.algorithms.bipartite.covering import *
+from networkx.algorithms.bipartite.edgelist import *
+from networkx.algorithms.bipartite.matching import *
+from networkx.algorithms.bipartite.matrix import *
+from networkx.algorithms.bipartite.projection import *
+from networkx.algorithms.bipartite.redundancy import *
+from networkx.algorithms.bipartite.spectral import *
+from networkx.algorithms.bipartite.generators import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/basic.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/basic.py
new file mode 100644
index 0000000..ac4686a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/basic.py
@@ -0,0 +1,315 @@
+"""
+==========================
+Bipartite Graph Algorithms
+==========================
+"""
+import networkx as nx
+from networkx.algorithms.components import connected_components
+from networkx.exception import AmbiguousSolution
+
+__all__ = [
+    "is_bipartite",
+    "is_bipartite_node_set",
+    "color",
+    "sets",
+    "density",
+    "degrees",
+]
+
+
+def color(G):
+    """Returns a two-coloring of the graph.
+
+    Raises an exception if the graph is not bipartite.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    color : dictionary
+        A dictionary keyed by node with a 1 or 0 as data for each node color.
+
+    Raises
+    ------
+    NetworkXError
+        If the graph is not two-colorable.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.path_graph(4)
+    >>> c = bipartite.color(G)
+    >>> print(c)
+    {0: 1, 1: 0, 2: 1, 3: 0}
+
+    You can use this to set a node attribute indicating the biparite set:
+
+    >>> nx.set_node_attributes(G, c, "bipartite")
+    >>> print(G.nodes[0]["bipartite"])
+    1
+    >>> print(G.nodes[1]["bipartite"])
+    0
+    """
+    if G.is_directed():
+        import itertools
+
+        def neighbors(v):
+            return itertools.chain.from_iterable([G.predecessors(v), G.successors(v)])
+
+    else:
+        neighbors = G.neighbors
+
+    color = {}
+    for n in G:  # handle disconnected graphs
+        if n in color or len(G[n]) == 0:  # skip isolates
+            continue
+        queue = [n]
+        color[n] = 1  # nodes seen with color (1 or 0)
+        while queue:
+            v = queue.pop()
+            c = 1 - color[v]  # opposite color of node v
+            for w in neighbors(v):
+                if w in color:
+                    if color[w] == color[v]:
+                        raise nx.NetworkXError("Graph is not bipartite.")
+                else:
+                    color[w] = c
+                    queue.append(w)
+    # color isolates with 0
+    color.update(dict.fromkeys(nx.isolates(G), 0))
+    return color
+
+
+def is_bipartite(G):
+    """Returns True if graph G is bipartite, False if not.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.path_graph(4)
+    >>> print(bipartite.is_bipartite(G))
+    True
+
+    See Also
+    --------
+    color, is_bipartite_node_set
+    """
+    try:
+        color(G)
+        return True
+    except nx.NetworkXError:
+        return False
+
+
+def is_bipartite_node_set(G, nodes):
+    """Returns True if nodes and G/nodes are a bipartition of G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    nodes: list or container
+      Check if nodes are a one of a bipartite set.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.path_graph(4)
+    >>> X = set([1, 3])
+    >>> bipartite.is_bipartite_node_set(G, X)
+    True
+
+    Notes
+    -----
+    An exception is raised if the input nodes are not distinct, because in this
+    case some bipartite algorithms will yield incorrect results.
+    For connected graphs the bipartite sets are unique.  This function handles
+    disconnected graphs.
+    """
+    S = set(nodes)
+
+    if len(S) < len(nodes):
+        # this should maybe just return False?
+        raise AmbiguousSolution(
+            "The input node set contains duplicates.\n"
+            "This may lead to incorrect results when using it in bipartite algorithms.\n"
+            "Consider using set(nodes) as the input"
+        )
+
+    for CC in (G.subgraph(c).copy() for c in connected_components(G)):
+        X, Y = sets(CC)
+        if not (
+            (X.issubset(S) and Y.isdisjoint(S)) or (Y.issubset(S) and X.isdisjoint(S))
+        ):
+            return False
+    return True
+
+
+def sets(G, top_nodes=None):
+    """Returns bipartite node sets of graph G.
+
+    Raises an exception if the graph is not bipartite or if the input
+    graph is disconnected and thus more than one valid solution exists.
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    top_nodes : container, optional
+      Container with all nodes in one bipartite node set. If not supplied
+      it will be computed. But if more than one solution exists an exception
+      will be raised.
+
+    Returns
+    -------
+    X : set
+      Nodes from one side of the bipartite graph.
+    Y : set
+      Nodes from the other side.
+
+    Raises
+    ------
+    AmbiguousSolution
+      Raised if the input bipartite graph is disconnected and no container
+      with all nodes in one bipartite set is provided. When determining
+      the nodes in each bipartite set more than one valid solution is
+      possible if the input graph is disconnected.
+    NetworkXError
+      Raised if the input graph is not bipartite.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.path_graph(4)
+    >>> X, Y = bipartite.sets(G)
+    >>> list(X)
+    [0, 2]
+    >>> list(Y)
+    [1, 3]
+
+    See Also
+    --------
+    color
+
+    """
+    if G.is_directed():
+        is_connected = nx.is_weakly_connected
+    else:
+        is_connected = nx.is_connected
+    if top_nodes is not None:
+        X = set(top_nodes)
+        Y = set(G) - X
+    else:
+        if not is_connected(G):
+            msg = "Disconnected graph: Ambiguous solution for bipartite sets."
+            raise nx.AmbiguousSolution(msg)
+        c = color(G)
+        X = {n for n, is_top in c.items() if is_top}
+        Y = {n for n, is_top in c.items() if not is_top}
+    return (X, Y)
+
+
+def density(B, nodes):
+    """Returns density of bipartite graph B.
+
+    Parameters
+    ----------
+    B : NetworkX graph
+
+    nodes: list or container
+      Nodes in one node set of the bipartite graph.
+
+    Returns
+    -------
+    d : float
+       The bipartite density
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.complete_bipartite_graph(3, 2)
+    >>> X = set([0, 1, 2])
+    >>> bipartite.density(G, X)
+    1.0
+    >>> Y = set([3, 4])
+    >>> bipartite.density(G, Y)
+    1.0
+
+    Notes
+    -----
+    The container of nodes passed as argument must contain all nodes
+    in one of the two bipartite node sets to avoid ambiguity in the
+    case of disconnected graphs.
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    See Also
+    --------
+    color
+    """
+    n = len(B)
+    m = nx.number_of_edges(B)
+    nb = len(nodes)
+    nt = n - nb
+    if m == 0:  # includes cases n==0 and n==1
+        d = 0.0
+    else:
+        if B.is_directed():
+            d = m / (2 * nb * nt)
+        else:
+            d = m / (nb * nt)
+    return d
+
+
+def degrees(B, nodes, weight=None):
+    """Returns the degrees of the two node sets in the bipartite graph B.
+
+    Parameters
+    ----------
+    B : NetworkX graph
+
+    nodes: list or container
+      Nodes in one node set of the bipartite graph.
+
+    weight : string or None, optional (default=None)
+       The edge attribute that holds the numerical value used as a weight.
+       If None, then each edge has weight 1.
+       The degree is the sum of the edge weights adjacent to the node.
+
+    Returns
+    -------
+    (degX,degY) : tuple of dictionaries
+       The degrees of the two bipartite sets as dictionaries keyed by node.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.complete_bipartite_graph(3, 2)
+    >>> Y = set([3, 4])
+    >>> degX, degY = bipartite.degrees(G, Y)
+    >>> dict(degX)
+    {0: 2, 1: 2, 2: 2}
+
+    Notes
+    -----
+    The container of nodes passed as argument must contain all nodes
+    in one of the two bipartite node sets to avoid ambiguity in the
+    case of disconnected graphs.
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    See Also
+    --------
+    color, density
+    """
+    bottom = set(nodes)
+    top = set(B) - bottom
+    return (B.degree(top, weight), B.degree(bottom, weight))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/centrality.py
new file mode 100644
index 0000000..3eab834
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/centrality.py
@@ -0,0 +1,266 @@
+import networkx as nx
+
+__all__ = ["degree_centrality", "betweenness_centrality", "closeness_centrality"]
+
+
+def degree_centrality(G, nodes):
+    r"""Compute the degree centrality for nodes in a bipartite network.
+
+    The degree centrality for a node `v` is the fraction of nodes
+    connected to it.
+
+    Parameters
+    ----------
+    G : graph
+       A bipartite network
+
+    nodes : list or container
+      Container with all nodes in one bipartite node set.
+
+    Returns
+    -------
+    centrality : dictionary
+       Dictionary keyed by node with bipartite degree centrality as the value.
+
+    See Also
+    --------
+    betweenness_centrality
+    closeness_centrality
+    :func:`~networkx.algorithms.bipartite.basic.sets`
+    :func:`~networkx.algorithms.bipartite.basic.is_bipartite`
+
+    Notes
+    -----
+    The nodes input parameter must contain all nodes in one bipartite node set,
+    but the dictionary returned contains all nodes from both bipartite node
+    sets. See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    For unipartite networks, the degree centrality values are
+    normalized by dividing by the maximum possible degree (which is
+    `n-1` where `n` is the number of nodes in G).
+
+    In the bipartite case, the maximum possible degree of a node in a
+    bipartite node set is the number of nodes in the opposite node set
+    [1]_.  The degree centrality for a node `v` in the bipartite
+    sets `U` with `n` nodes and `V` with `m` nodes is
+
+    .. math::
+
+        d_{v} = \frac{deg(v)}{m}, \mbox{for} v \in U ,
+
+        d_{v} = \frac{deg(v)}{n}, \mbox{for} v \in V ,
+
+
+    where `deg(v)` is the degree of node `v`.
+
+    References
+    ----------
+    .. [1] Borgatti, S.P. and Halgin, D. In press. "Analyzing Affiliation
+        Networks". In Carrington, P. and Scott, J. (eds) The Sage Handbook
+        of Social Network Analysis. Sage Publications.
+        https://dx.doi.org/10.4135/9781446294413.n28
+    """
+    top = set(nodes)
+    bottom = set(G) - top
+    s = 1.0 / len(bottom)
+    centrality = {n: d * s for n, d in G.degree(top)}
+    s = 1.0 / len(top)
+    centrality.update({n: d * s for n, d in G.degree(bottom)})
+    return centrality
+
+
+def betweenness_centrality(G, nodes):
+    r"""Compute betweenness centrality for nodes in a bipartite network.
+
+    Betweenness centrality of a node `v` is the sum of the
+    fraction of all-pairs shortest paths that pass through `v`.
+
+    Values of betweenness are normalized by the maximum possible
+    value which for bipartite graphs is limited by the relative size
+    of the two node sets [1]_.
+
+    Let `n` be the number of nodes in the node set `U` and
+    `m` be the number of nodes in the node set `V`, then
+    nodes in `U` are normalized by dividing by
+
+    .. math::
+
+       \frac{1}{2} [m^2 (s + 1)^2 + m (s + 1)(2t - s - 1) - t (2s - t + 3)] ,
+
+    where
+
+    .. math::
+
+        s = (n - 1) \div m , t = (n - 1) \mod m ,
+
+    and nodes in `V` are normalized by dividing by
+
+    .. math::
+
+        \frac{1}{2} [n^2 (p + 1)^2 + n (p + 1)(2r - p - 1) - r (2p - r + 3)] ,
+
+    where,
+
+    .. math::
+
+        p = (m - 1) \div n , r = (m - 1) \mod n .
+
+    Parameters
+    ----------
+    G : graph
+        A bipartite graph
+
+    nodes : list or container
+        Container with all nodes in one bipartite node set.
+
+    Returns
+    -------
+    betweenness : dictionary
+        Dictionary keyed by node with bipartite betweenness centrality
+        as the value.
+
+    See Also
+    --------
+    degree_centrality
+    closeness_centrality
+    :func:`~networkx.algorithms.bipartite.basic.sets`
+    :func:`~networkx.algorithms.bipartite.basic.is_bipartite`
+
+    Notes
+    -----
+    The nodes input parameter must contain all nodes in one bipartite node set,
+    but the dictionary returned contains all nodes from both node sets.
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+
+    References
+    ----------
+    .. [1] Borgatti, S.P. and Halgin, D. In press. "Analyzing Affiliation
+        Networks". In Carrington, P. and Scott, J. (eds) The Sage Handbook
+        of Social Network Analysis. Sage Publications.
+        https://dx.doi.org/10.4135/9781446294413.n28
+    """
+    top = set(nodes)
+    bottom = set(G) - top
+    n = len(top)
+    m = len(bottom)
+    s, t = divmod(n - 1, m)
+    bet_max_top = (
+        ((m**2) * ((s + 1) ** 2))
+        + (m * (s + 1) * (2 * t - s - 1))
+        - (t * ((2 * s) - t + 3))
+    ) / 2.0
+    p, r = divmod(m - 1, n)
+    bet_max_bot = (
+        ((n**2) * ((p + 1) ** 2))
+        + (n * (p + 1) * (2 * r - p - 1))
+        - (r * ((2 * p) - r + 3))
+    ) / 2.0
+    betweenness = nx.betweenness_centrality(G, normalized=False, weight=None)
+    for node in top:
+        betweenness[node] /= bet_max_top
+    for node in bottom:
+        betweenness[node] /= bet_max_bot
+    return betweenness
+
+
+def closeness_centrality(G, nodes, normalized=True):
+    r"""Compute the closeness centrality for nodes in a bipartite network.
+
+    The closeness of a node is the distance to all other nodes in the
+    graph or in the case that the graph is not connected to all other nodes
+    in the connected component containing that node.
+
+    Parameters
+    ----------
+    G : graph
+        A bipartite network
+
+    nodes : list or container
+        Container with all nodes in one bipartite node set.
+
+    normalized : bool, optional
+      If True (default) normalize by connected component size.
+
+    Returns
+    -------
+    closeness : dictionary
+        Dictionary keyed by node with bipartite closeness centrality
+        as the value.
+
+    See Also
+    --------
+    betweenness_centrality
+    degree_centrality
+    :func:`~networkx.algorithms.bipartite.basic.sets`
+    :func:`~networkx.algorithms.bipartite.basic.is_bipartite`
+
+    Notes
+    -----
+    The nodes input parameter must contain all nodes in one bipartite node set,
+    but the dictionary returned contains all nodes from both node sets.
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+
+    Closeness centrality is normalized by the minimum distance possible.
+    In the bipartite case the minimum distance for a node in one bipartite
+    node set is 1 from all nodes in the other node set and 2 from all
+    other nodes in its own set [1]_. Thus the closeness centrality
+    for node `v`  in the two bipartite sets `U` with
+    `n` nodes and `V` with `m` nodes is
+
+    .. math::
+
+        c_{v} = \frac{m + 2(n - 1)}{d}, \mbox{for} v \in U,
+
+        c_{v} = \frac{n + 2(m - 1)}{d}, \mbox{for} v \in V,
+
+    where `d` is the sum of the distances from `v` to all
+    other nodes.
+
+    Higher values of closeness  indicate higher centrality.
+
+    As in the unipartite case, setting normalized=True causes the
+    values to normalized further to n-1 / size(G)-1 where n is the
+    number of nodes in the connected part of graph containing the
+    node.  If the graph is not completely connected, this algorithm
+    computes the closeness centrality for each connected part
+    separately.
+
+    References
+    ----------
+    .. [1] Borgatti, S.P. and Halgin, D. In press. "Analyzing Affiliation
+        Networks". In Carrington, P. and Scott, J. (eds) The Sage Handbook
+        of Social Network Analysis. Sage Publications.
+        https://dx.doi.org/10.4135/9781446294413.n28
+    """
+    closeness = {}
+    path_length = nx.single_source_shortest_path_length
+    top = set(nodes)
+    bottom = set(G) - top
+    n = len(top)
+    m = len(bottom)
+    for node in top:
+        sp = dict(path_length(G, node))
+        totsp = sum(sp.values())
+        if totsp > 0.0 and len(G) > 1:
+            closeness[node] = (m + 2 * (n - 1)) / totsp
+            if normalized:
+                s = (len(sp) - 1) / (len(G) - 1)
+                closeness[node] *= s
+        else:
+            closeness[node] = 0.0
+    for node in bottom:
+        sp = dict(path_length(G, node))
+        totsp = sum(sp.values())
+        if totsp > 0.0 and len(G) > 1:
+            closeness[node] = (n + 2 * (m - 1)) / totsp
+            if normalized:
+                s = (len(sp) - 1) / (len(G) - 1)
+                closeness[node] *= s
+        else:
+            closeness[node] = 0.0
+    return closeness
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/cluster.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/cluster.py
new file mode 100644
index 0000000..4b61cb9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/cluster.py
@@ -0,0 +1,277 @@
+"""Functions for computing clustering of pairs
+
+"""
+
+import itertools
+
+import networkx as nx
+
+__all__ = [
+    "clustering",
+    "average_clustering",
+    "latapy_clustering",
+    "robins_alexander_clustering",
+]
+
+
+def cc_dot(nu, nv):
+    return len(nu & nv) / len(nu | nv)
+
+
+def cc_max(nu, nv):
+    return len(nu & nv) / max(len(nu), len(nv))
+
+
+def cc_min(nu, nv):
+    return len(nu & nv) / min(len(nu), len(nv))
+
+
+modes = {"dot": cc_dot, "min": cc_min, "max": cc_max}
+
+
+def latapy_clustering(G, nodes=None, mode="dot"):
+    r"""Compute a bipartite clustering coefficient for nodes.
+
+    The bipartie clustering coefficient is a measure of local density
+    of connections defined as [1]_:
+
+    .. math::
+
+       c_u = \frac{\sum_{v \in N(N(u))} c_{uv} }{|N(N(u))|}
+
+    where `N(N(u))` are the second order neighbors of `u` in `G` excluding `u`,
+    and `c_{uv}` is the pairwise clustering coefficient between nodes
+    `u` and `v`.
+
+    The mode selects the function for `c_{uv}` which can be:
+
+    `dot`:
+
+    .. math::
+
+       c_{uv}=\frac{|N(u)\cap N(v)|}{|N(u) \cup N(v)|}
+
+    `min`:
+
+    .. math::
+
+       c_{uv}=\frac{|N(u)\cap N(v)|}{min(|N(u)|,|N(v)|)}
+
+    `max`:
+
+    .. math::
+
+       c_{uv}=\frac{|N(u)\cap N(v)|}{max(|N(u)|,|N(v)|)}
+
+
+    Parameters
+    ----------
+    G : graph
+        A bipartite graph
+
+    nodes : list or iterable (optional)
+        Compute bipartite clustering for these nodes. The default
+        is all nodes in G.
+
+    mode : string
+        The pariwise bipartite clustering method to be used in the computation.
+        It must be "dot", "max", or "min".
+
+    Returns
+    -------
+    clustering : dictionary
+        A dictionary keyed by node with the clustering coefficient value.
+
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.path_graph(4)  # path graphs are bipartite
+    >>> c = bipartite.clustering(G)
+    >>> c[0]
+    0.5
+    >>> c = bipartite.clustering(G, mode="min")
+    >>> c[0]
+    1.0
+
+    See Also
+    --------
+    robins_alexander_clustering
+    average_clustering
+    networkx.algorithms.cluster.square_clustering
+
+    References
+    ----------
+    .. [1] Latapy, Matthieu, Clémence Magnien, and Nathalie Del Vecchio (2008).
+       Basic notions for the analysis of large two-mode networks.
+       Social Networks 30(1), 31--48.
+    """
+    if not nx.algorithms.bipartite.is_bipartite(G):
+        raise nx.NetworkXError("Graph is not bipartite")
+
+    try:
+        cc_func = modes[mode]
+    except KeyError as err:
+        raise nx.NetworkXError(
+            "Mode for bipartite clustering must be: dot, min or max"
+        ) from err
+
+    if nodes is None:
+        nodes = G
+    ccs = {}
+    for v in nodes:
+        cc = 0.0
+        nbrs2 = {u for nbr in G[v] for u in G[nbr]} - {v}
+        for u in nbrs2:
+            cc += cc_func(set(G[u]), set(G[v]))
+        if cc > 0.0:  # len(nbrs2)>0
+            cc /= len(nbrs2)
+        ccs[v] = cc
+    return ccs
+
+
+clustering = latapy_clustering
+
+
+def average_clustering(G, nodes=None, mode="dot"):
+    r"""Compute the average bipartite clustering coefficient.
+
+    A clustering coefficient for the whole graph is the average,
+
+    .. math::
+
+       C = \frac{1}{n}\sum_{v \in G} c_v,
+
+    where `n` is the number of nodes in `G`.
+
+    Similar measures for the two bipartite sets can be defined [1]_
+
+    .. math::
+
+       C_X = \frac{1}{|X|}\sum_{v \in X} c_v,
+
+    where `X` is a bipartite set of `G`.
+
+    Parameters
+    ----------
+    G : graph
+        a bipartite graph
+
+    nodes : list or iterable, optional
+        A container of nodes to use in computing the average.
+        The nodes should be either the entire graph (the default) or one of the
+        bipartite sets.
+
+    mode : string
+        The pariwise bipartite clustering method.
+        It must be "dot", "max", or "min"
+
+    Returns
+    -------
+    clustering : float
+       The average bipartite clustering for the given set of nodes or the
+       entire graph if no nodes are specified.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.star_graph(3)  # star graphs are bipartite
+    >>> bipartite.average_clustering(G)
+    0.75
+    >>> X, Y = bipartite.sets(G)
+    >>> bipartite.average_clustering(G, X)
+    0.0
+    >>> bipartite.average_clustering(G, Y)
+    1.0
+
+    See Also
+    --------
+    clustering
+
+    Notes
+    -----
+    The container of nodes passed to this function must contain all of the nodes
+    in one of the bipartite sets ("top" or "bottom") in order to compute
+    the correct average bipartite clustering coefficients.
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+
+    References
+    ----------
+    .. [1] Latapy, Matthieu, Clémence Magnien, and Nathalie Del Vecchio (2008).
+        Basic notions for the analysis of large two-mode networks.
+        Social Networks 30(1), 31--48.
+    """
+    if nodes is None:
+        nodes = G
+    ccs = latapy_clustering(G, nodes=nodes, mode=mode)
+    return sum(ccs[v] for v in nodes) / len(nodes)
+
+
+def robins_alexander_clustering(G):
+    r"""Compute the bipartite clustering of G.
+
+    Robins and Alexander [1]_ defined bipartite clustering coefficient as
+    four times the number of four cycles `C_4` divided by the number of
+    three paths `L_3` in a bipartite graph:
+
+    .. math::
+
+       CC_4 = \frac{4 * C_4}{L_3}
+
+    Parameters
+    ----------
+    G : graph
+        a bipartite graph
+
+    Returns
+    -------
+    clustering : float
+       The Robins and Alexander bipartite clustering for the input graph.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.davis_southern_women_graph()
+    >>> print(round(bipartite.robins_alexander_clustering(G), 3))
+    0.468
+
+    See Also
+    --------
+    latapy_clustering
+    networkx.algorithms.cluster.square_clustering
+
+    References
+    ----------
+    .. [1] Robins, G. and M. Alexander (2004). Small worlds among interlocking
+           directors: Network structure and distance in bipartite graphs.
+           Computational & Mathematical Organization Theory 10(1), 69–94.
+
+    """
+    if G.order() < 4 or G.size() < 3:
+        return 0
+    L_3 = _threepaths(G)
+    if L_3 == 0:
+        return 0
+    C_4 = _four_cycles(G)
+    return (4.0 * C_4) / L_3
+
+
+def _four_cycles(G):
+    cycles = 0
+    for v in G:
+        for u, w in itertools.combinations(G[v], 2):
+            cycles += len((set(G[u]) & set(G[w])) - {v})
+    return cycles / 4
+
+
+def _threepaths(G):
+    paths = 0
+    for v in G:
+        for u in G[v]:
+            for w in set(G[u]) - {v}:
+                paths += len(set(G[w]) - {v, u})
+    # Divide by two because we count each three path twice
+    # one for each possible starting point
+    return paths / 2
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/covering.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/covering.py
new file mode 100644
index 0000000..2802dbc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/covering.py
@@ -0,0 +1,55 @@
+""" Functions related to graph covers."""
+
+from networkx.algorithms.bipartite.matching import hopcroft_karp_matching
+from networkx.algorithms.covering import min_edge_cover as _min_edge_cover
+from networkx.utils import not_implemented_for
+
+__all__ = ["min_edge_cover"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def min_edge_cover(G, matching_algorithm=None):
+    """Returns a set of edges which constitutes
+    the minimum edge cover of the graph.
+
+    The smallest edge cover can be found in polynomial time by finding
+    a maximum matching and extending it greedily so that all nodes
+    are covered.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected bipartite graph.
+
+    matching_algorithm : function
+        A function that returns a maximum cardinality matching in a
+        given bipartite graph. The function must take one input, the
+        graph ``G``, and return a dictionary mapping each node to its
+        mate. If not specified,
+        :func:`~networkx.algorithms.bipartite.matching.hopcroft_karp_matching`
+        will be used. Other possibilities include
+        :func:`~networkx.algorithms.bipartite.matching.eppstein_matching`,
+
+    Returns
+    -------
+    set
+        A set of the edges in a minimum edge cover of the graph, given as
+        pairs of nodes. It contains both the edges `(u, v)` and `(v, u)`
+        for given nodes `u` and `v` among the edges of minimum edge cover.
+
+    Notes
+    -----
+    An edge cover of a graph is a set of edges such that every node of
+    the graph is incident to at least one edge of the set.
+    A minimum edge cover is an edge covering of smallest cardinality.
+
+    Due to its implementation, the worst-case running time of this algorithm
+    is bounded by the worst-case running time of the function
+    ``matching_algorithm``.
+    """
+    if G.order() == 0:  # Special case for the empty graph
+        return set()
+    if matching_algorithm is None:
+        matching_algorithm = hopcroft_karp_matching
+    return _min_edge_cover(G, matching_algorithm=matching_algorithm)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/edgelist.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/edgelist.py
new file mode 100644
index 0000000..5d183f4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/edgelist.py
@@ -0,0 +1,357 @@
+"""
+********************
+Bipartite Edge Lists
+********************
+Read and write NetworkX graphs as bipartite edge lists.
+
+Format
+------
+You can read or write three formats of edge lists with these functions.
+
+Node pairs with no data::
+
+ 1 2
+
+Python dictionary as data::
+
+ 1 2 {'weight':7, 'color':'green'}
+
+Arbitrary data::
+
+ 1 2 7 green
+
+For each edge (u, v) the node u is assigned to part 0 and the node v to part 1.
+"""
+__all__ = ["generate_edgelist", "write_edgelist", "parse_edgelist", "read_edgelist"]
+
+import networkx as nx
+from networkx.utils import not_implemented_for, open_file
+
+
+@open_file(1, mode="wb")
+def write_edgelist(G, path, comments="#", delimiter=" ", data=True, encoding="utf-8"):
+    """Write a bipartite graph as a list of edges.
+
+    Parameters
+    ----------
+    G : Graph
+       A NetworkX bipartite graph
+    path : file or string
+       File or filename to write. If a file is provided, it must be
+       opened in 'wb' mode. Filenames ending in .gz or .bz2 will be compressed.
+    comments : string, optional
+       The character used to indicate the start of a comment
+    delimiter : string, optional
+       The string used to separate values.  The default is whitespace.
+    data : bool or list, optional
+       If False write no edge data.
+       If True write a string representation of the edge data dictionary..
+       If a list (or other iterable) is provided, write the  keys specified
+       in the list.
+    encoding: string, optional
+       Specify which encoding to use when writing file.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> G.add_nodes_from([0, 2], bipartite=0)
+    >>> G.add_nodes_from([1, 3], bipartite=1)
+    >>> nx.write_edgelist(G, "test.edgelist")
+    >>> fh = open("test.edgelist", "wb")
+    >>> nx.write_edgelist(G, fh)
+    >>> nx.write_edgelist(G, "test.edgelist.gz")
+    >>> nx.write_edgelist(G, "test.edgelist.gz", data=False)
+
+    >>> G = nx.Graph()
+    >>> G.add_edge(1, 2, weight=7, color="red")
+    >>> nx.write_edgelist(G, "test.edgelist", data=False)
+    >>> nx.write_edgelist(G, "test.edgelist", data=["color"])
+    >>> nx.write_edgelist(G, "test.edgelist", data=["color", "weight"])
+
+    See Also
+    --------
+    write_edgelist
+    generate_edgelist
+    """
+    for line in generate_edgelist(G, delimiter, data):
+        line += "\n"
+        path.write(line.encode(encoding))
+
+
+@not_implemented_for("directed")
+def generate_edgelist(G, delimiter=" ", data=True):
+    """Generate a single line of the bipartite graph G in edge list format.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       The graph is assumed to have node attribute `part` set to 0,1 representing
+       the two graph parts
+
+    delimiter : string, optional
+       Separator for node labels
+
+    data : bool or list of keys
+       If False generate no edge data.  If True use a dictionary
+       representation of edge data.  If a list of keys use a list of data
+       values corresponding to the keys.
+
+    Returns
+    -------
+    lines : string
+        Lines of data in adjlist format.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.path_graph(4)
+    >>> G.add_nodes_from([0, 2], bipartite=0)
+    >>> G.add_nodes_from([1, 3], bipartite=1)
+    >>> G[1][2]["weight"] = 3
+    >>> G[2][3]["capacity"] = 12
+    >>> for line in bipartite.generate_edgelist(G, data=False):
+    ...     print(line)
+    0 1
+    2 1
+    2 3
+
+    >>> for line in bipartite.generate_edgelist(G):
+    ...     print(line)
+    0 1 {}
+    2 1 {'weight': 3}
+    2 3 {'capacity': 12}
+
+    >>> for line in bipartite.generate_edgelist(G, data=["weight"]):
+    ...     print(line)
+    0 1
+    2 1 3
+    2 3
+    """
+    try:
+        part0 = [n for n, d in G.nodes.items() if d["bipartite"] == 0]
+    except BaseException as err:
+        raise AttributeError("Missing node attribute `bipartite`") from err
+    if data is True or data is False:
+        for n in part0:
+            for edge in G.edges(n, data=data):
+                yield delimiter.join(map(str, edge))
+    else:
+        for n in part0:
+            for u, v, d in G.edges(n, data=True):
+                edge = [u, v]
+                try:
+                    edge.extend(d[k] for k in data)
+                except KeyError:
+                    pass  # missing data for this edge, should warn?
+                yield delimiter.join(map(str, edge))
+
+
+def parse_edgelist(
+    lines, comments="#", delimiter=None, create_using=None, nodetype=None, data=True
+):
+    """Parse lines of an edge list representation of a bipartite graph.
+
+    Parameters
+    ----------
+    lines : list or iterator of strings
+        Input data in edgelist format
+    comments : string, optional
+       Marker for comment lines
+    delimiter : string, optional
+       Separator for node labels
+    create_using: NetworkX graph container, optional
+       Use given NetworkX graph for holding nodes or edges.
+    nodetype : Python type, optional
+       Convert nodes to this type.
+    data : bool or list of (label,type) tuples
+       If False generate no edge data or if True use a dictionary
+       representation of edge data or a list tuples specifying dictionary
+       key names and types for edge data.
+
+    Returns
+    -------
+    G: NetworkX Graph
+        The bipartite graph corresponding to lines
+
+    Examples
+    --------
+    Edgelist with no data:
+
+    >>> from networkx.algorithms import bipartite
+    >>> lines = ["1 2", "2 3", "3 4"]
+    >>> G = bipartite.parse_edgelist(lines, nodetype=int)
+    >>> sorted(G.nodes())
+    [1, 2, 3, 4]
+    >>> sorted(G.nodes(data=True))
+    [(1, {'bipartite': 0}), (2, {'bipartite': 0}), (3, {'bipartite': 0}), (4, {'bipartite': 1})]
+    >>> sorted(G.edges())
+    [(1, 2), (2, 3), (3, 4)]
+
+    Edgelist with data in Python dictionary representation:
+
+    >>> lines = ["1 2 {'weight':3}", "2 3 {'weight':27}", "3 4 {'weight':3.0}"]
+    >>> G = bipartite.parse_edgelist(lines, nodetype=int)
+    >>> sorted(G.nodes())
+    [1, 2, 3, 4]
+    >>> sorted(G.edges(data=True))
+    [(1, 2, {'weight': 3}), (2, 3, {'weight': 27}), (3, 4, {'weight': 3.0})]
+
+    Edgelist with data in a list:
+
+    >>> lines = ["1 2 3", "2 3 27", "3 4 3.0"]
+    >>> G = bipartite.parse_edgelist(lines, nodetype=int, data=(("weight", float),))
+    >>> sorted(G.nodes())
+    [1, 2, 3, 4]
+    >>> sorted(G.edges(data=True))
+    [(1, 2, {'weight': 3.0}), (2, 3, {'weight': 27.0}), (3, 4, {'weight': 3.0})]
+
+    See Also
+    --------
+    """
+    from ast import literal_eval
+
+    G = nx.empty_graph(0, create_using)
+    for line in lines:
+        p = line.find(comments)
+        if p >= 0:
+            line = line[:p]
+        if not len(line):
+            continue
+        # split line, should have 2 or more
+        s = line.strip().split(delimiter)
+        if len(s) < 2:
+            continue
+        u = s.pop(0)
+        v = s.pop(0)
+        d = s
+        if nodetype is not None:
+            try:
+                u = nodetype(u)
+                v = nodetype(v)
+            except BaseException as err:
+                raise TypeError(
+                    f"Failed to convert nodes {u},{v} " f"to type {nodetype}."
+                ) from err
+
+        if len(d) == 0 or data is False:
+            # no data or data type specified
+            edgedata = {}
+        elif data is True:
+            # no edge types specified
+            try:  # try to evaluate as dictionary
+                edgedata = dict(literal_eval(" ".join(d)))
+            except BaseException as err:
+                raise TypeError(
+                    f"Failed to convert edge data ({d})" f"to dictionary."
+                ) from err
+        else:
+            # convert edge data to dictionary with specified keys and type
+            if len(d) != len(data):
+                raise IndexError(
+                    f"Edge data {d} and data_keys {data} are not the same length"
+                )
+            edgedata = {}
+            for (edge_key, edge_type), edge_value in zip(data, d):
+                try:
+                    edge_value = edge_type(edge_value)
+                except BaseException as err:
+                    raise TypeError(
+                        f"Failed to convert {edge_key} data "
+                        f"{edge_value} to type {edge_type}."
+                    ) from err
+                edgedata.update({edge_key: edge_value})
+        G.add_node(u, bipartite=0)
+        G.add_node(v, bipartite=1)
+        G.add_edge(u, v, **edgedata)
+    return G
+
+
+@open_file(0, mode="rb")
+def read_edgelist(
+    path,
+    comments="#",
+    delimiter=None,
+    create_using=None,
+    nodetype=None,
+    data=True,
+    edgetype=None,
+    encoding="utf-8",
+):
+    """Read a bipartite graph from a list of edges.
+
+    Parameters
+    ----------
+    path : file or string
+       File or filename to read. If a file is provided, it must be
+       opened in 'rb' mode.
+       Filenames ending in .gz or .bz2 will be uncompressed.
+    comments : string, optional
+       The character used to indicate the start of a comment.
+    delimiter : string, optional
+       The string used to separate values.  The default is whitespace.
+    create_using : Graph container, optional,
+       Use specified container to build graph.  The default is networkx.Graph,
+       an undirected graph.
+    nodetype : int, float, str, Python type, optional
+       Convert node data from strings to specified type
+    data : bool or list of (label,type) tuples
+       Tuples specifying dictionary key names and types for edge data
+    edgetype : int, float, str, Python type, optional OBSOLETE
+       Convert edge data from strings to specified type and use as 'weight'
+    encoding: string, optional
+       Specify which encoding to use when reading file.
+
+    Returns
+    -------
+    G : graph
+       A networkx Graph or other type specified with create_using
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.path_graph(4)
+    >>> G.add_nodes_from([0, 2], bipartite=0)
+    >>> G.add_nodes_from([1, 3], bipartite=1)
+    >>> bipartite.write_edgelist(G, "test.edgelist")
+    >>> G = bipartite.read_edgelist("test.edgelist")
+
+    >>> fh = open("test.edgelist", "rb")
+    >>> G = bipartite.read_edgelist(fh)
+    >>> fh.close()
+
+    >>> G = bipartite.read_edgelist("test.edgelist", nodetype=int)
+
+    Edgelist with data in a list:
+
+    >>> textline = "1 2 3"
+    >>> fh = open("test.edgelist", "w")
+    >>> d = fh.write(textline)
+    >>> fh.close()
+    >>> G = bipartite.read_edgelist(
+    ...     "test.edgelist", nodetype=int, data=(("weight", float),)
+    ... )
+    >>> list(G)
+    [1, 2]
+    >>> list(G.edges(data=True))
+    [(1, 2, {'weight': 3.0})]
+
+    See parse_edgelist() for more examples of formatting.
+
+    See Also
+    --------
+    parse_edgelist
+
+    Notes
+    -----
+    Since nodes must be hashable, the function nodetype must return hashable
+    types (e.g. int, float, str, frozenset - or tuples of those, etc.)
+    """
+    lines = (line.decode(encoding) for line in path)
+    return parse_edgelist(
+        lines,
+        comments=comments,
+        delimiter=delimiter,
+        create_using=create_using,
+        nodetype=nodetype,
+        data=data,
+    )
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/generators.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/generators.py
new file mode 100644
index 0000000..eddd61b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/generators.py
@@ -0,0 +1,595 @@
+"""
+Generators and functions for bipartite graphs.
+"""
+import math
+import numbers
+from functools import reduce
+
+import networkx as nx
+from networkx.utils import nodes_or_number, py_random_state
+
+__all__ = [
+    "configuration_model",
+    "havel_hakimi_graph",
+    "reverse_havel_hakimi_graph",
+    "alternating_havel_hakimi_graph",
+    "preferential_attachment_graph",
+    "random_graph",
+    "gnmk_random_graph",
+    "complete_bipartite_graph",
+]
+
+
+@nodes_or_number([0, 1])
+def complete_bipartite_graph(n1, n2, create_using=None):
+    """Returns the complete bipartite graph `K_{n_1,n_2}`.
+
+    The graph is composed of two partitions with nodes 0 to (n1 - 1)
+    in the first and nodes n1 to (n1 + n2 - 1) in the second.
+    Each node in the first is connected to each node in the second.
+
+    Parameters
+    ----------
+    n1, n2 : integer or iterable container of nodes
+        If integers, nodes are from `range(n1)` and `range(n1, n1 + n2)`.
+        If a container, the elements are the nodes.
+    create_using : NetworkX graph instance, (default: nx.Graph)
+       Return graph of this type.
+
+    Notes
+    -----
+    Nodes are the integers 0 to `n1 + n2 - 1` unless either n1 or n2 are
+    containers of nodes. If only one of n1 or n2 are integers, that
+    integer is replaced by `range` of that integer.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.complete_bipartite_graph
+    """
+    G = nx.empty_graph(0, create_using)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    n1, top = n1
+    n2, bottom = n2
+    if isinstance(n1, numbers.Integral) and isinstance(n2, numbers.Integral):
+        bottom = [n1 + i for i in bottom]
+    G.add_nodes_from(top, bipartite=0)
+    G.add_nodes_from(bottom, bipartite=1)
+    if len(G) != len(top) + len(bottom):
+        raise nx.NetworkXError("Inputs n1 and n2 must contain distinct nodes")
+    G.add_edges_from((u, v) for u in top for v in bottom)
+    G.graph["name"] = f"complete_bipartite_graph({n1}, {n2})"
+    return G
+
+
+@py_random_state(3)
+def configuration_model(aseq, bseq, create_using=None, seed=None):
+    """Returns a random bipartite graph from two given degree sequences.
+
+    Parameters
+    ----------
+    aseq : list
+       Degree sequence for node set A.
+    bseq : list
+       Degree sequence for node set B.
+    create_using : NetworkX graph instance, optional
+       Return graph of this type.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1).
+    Nodes from set A are connected to nodes in set B by choosing
+    randomly from the possible free stubs, one in A and one in B.
+
+    Notes
+    -----
+    The sum of the two sequences must be equal: sum(aseq)=sum(bseq)
+    If no graph type is specified use MultiGraph with parallel edges.
+    If you want a graph with no parallel edges use create_using=Graph()
+    but then the resulting degree sequences might not be exact.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.configuration_model
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    # length and sum of each sequence
+    lena = len(aseq)
+    lenb = len(bseq)
+    suma = sum(aseq)
+    sumb = sum(bseq)
+
+    if not suma == sumb:
+        raise nx.NetworkXError(
+            f"invalid degree sequences, sum(aseq)!=sum(bseq),{suma},{sumb}"
+        )
+
+    G = _add_nodes_with_bipartite_label(G, lena, lenb)
+
+    if len(aseq) == 0 or max(aseq) == 0:
+        return G  # done if no edges
+
+    # build lists of degree-repeated vertex numbers
+    stubs = [[v] * aseq[v] for v in range(0, lena)]
+    astubs = [x for subseq in stubs for x in subseq]
+
+    stubs = [[v] * bseq[v - lena] for v in range(lena, lena + lenb)]
+    bstubs = [x for subseq in stubs for x in subseq]
+
+    # shuffle lists
+    seed.shuffle(astubs)
+    seed.shuffle(bstubs)
+
+    G.add_edges_from([astubs[i], bstubs[i]] for i in range(suma))
+
+    G.name = "bipartite_configuration_model"
+    return G
+
+
+def havel_hakimi_graph(aseq, bseq, create_using=None):
+    """Returns a bipartite graph from two given degree sequences using a
+    Havel-Hakimi style construction.
+
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1).
+    Nodes from the set A are connected to nodes in the set B by
+    connecting the highest degree nodes in set A to the highest degree
+    nodes in set B until all stubs are connected.
+
+    Parameters
+    ----------
+    aseq : list
+       Degree sequence for node set A.
+    bseq : list
+       Degree sequence for node set B.
+    create_using : NetworkX graph instance, optional
+       Return graph of this type.
+
+    Notes
+    -----
+    The sum of the two sequences must be equal: sum(aseq)=sum(bseq)
+    If no graph type is specified use MultiGraph with parallel edges.
+    If you want a graph with no parallel edges use create_using=Graph()
+    but then the resulting degree sequences might not be exact.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.havel_hakimi_graph
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    # length of the each sequence
+    naseq = len(aseq)
+    nbseq = len(bseq)
+
+    suma = sum(aseq)
+    sumb = sum(bseq)
+
+    if not suma == sumb:
+        raise nx.NetworkXError(
+            f"invalid degree sequences, sum(aseq)!=sum(bseq),{suma},{sumb}"
+        )
+
+    G = _add_nodes_with_bipartite_label(G, naseq, nbseq)
+
+    if len(aseq) == 0 or max(aseq) == 0:
+        return G  # done if no edges
+
+    # build list of degree-repeated vertex numbers
+    astubs = [[aseq[v], v] for v in range(0, naseq)]
+    bstubs = [[bseq[v - naseq], v] for v in range(naseq, naseq + nbseq)]
+    astubs.sort()
+    while astubs:
+        (degree, u) = astubs.pop()  # take of largest degree node in the a set
+        if degree == 0:
+            break  # done, all are zero
+        # connect the source to largest degree nodes in the b set
+        bstubs.sort()
+        for target in bstubs[-degree:]:
+            v = target[1]
+            G.add_edge(u, v)
+            target[0] -= 1  # note this updates bstubs too.
+            if target[0] == 0:
+                bstubs.remove(target)
+
+    G.name = "bipartite_havel_hakimi_graph"
+    return G
+
+
+def reverse_havel_hakimi_graph(aseq, bseq, create_using=None):
+    """Returns a bipartite graph from two given degree sequences using a
+    Havel-Hakimi style construction.
+
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1).
+    Nodes from set A are connected to nodes in the set B by connecting
+    the highest degree nodes in set A to the lowest degree nodes in
+    set B until all stubs are connected.
+
+    Parameters
+    ----------
+    aseq : list
+       Degree sequence for node set A.
+    bseq : list
+       Degree sequence for node set B.
+    create_using : NetworkX graph instance, optional
+       Return graph of this type.
+
+    Notes
+    -----
+    The sum of the two sequences must be equal: sum(aseq)=sum(bseq)
+    If no graph type is specified use MultiGraph with parallel edges.
+    If you want a graph with no parallel edges use create_using=Graph()
+    but then the resulting degree sequences might not be exact.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.reverse_havel_hakimi_graph
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    # length of the each sequence
+    lena = len(aseq)
+    lenb = len(bseq)
+    suma = sum(aseq)
+    sumb = sum(bseq)
+
+    if not suma == sumb:
+        raise nx.NetworkXError(
+            f"invalid degree sequences, sum(aseq)!=sum(bseq),{suma},{sumb}"
+        )
+
+    G = _add_nodes_with_bipartite_label(G, lena, lenb)
+
+    if len(aseq) == 0 or max(aseq) == 0:
+        return G  # done if no edges
+
+    # build list of degree-repeated vertex numbers
+    astubs = [[aseq[v], v] for v in range(0, lena)]
+    bstubs = [[bseq[v - lena], v] for v in range(lena, lena + lenb)]
+    astubs.sort()
+    bstubs.sort()
+    while astubs:
+        (degree, u) = astubs.pop()  # take of largest degree node in the a set
+        if degree == 0:
+            break  # done, all are zero
+        # connect the source to the smallest degree nodes in the b set
+        for target in bstubs[0:degree]:
+            v = target[1]
+            G.add_edge(u, v)
+            target[0] -= 1  # note this updates bstubs too.
+            if target[0] == 0:
+                bstubs.remove(target)
+
+    G.name = "bipartite_reverse_havel_hakimi_graph"
+    return G
+
+
+def alternating_havel_hakimi_graph(aseq, bseq, create_using=None):
+    """Returns a bipartite graph from two given degree sequences using
+    an alternating Havel-Hakimi style construction.
+
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1).
+    Nodes from the set A are connected to nodes in the set B by
+    connecting the highest degree nodes in set A to alternatively the
+    highest and the lowest degree nodes in set B until all stubs are
+    connected.
+
+    Parameters
+    ----------
+    aseq : list
+       Degree sequence for node set A.
+    bseq : list
+       Degree sequence for node set B.
+    create_using : NetworkX graph instance, optional
+       Return graph of this type.
+
+    Notes
+    -----
+    The sum of the two sequences must be equal: sum(aseq)=sum(bseq)
+    If no graph type is specified use MultiGraph with parallel edges.
+    If you want a graph with no parallel edges use create_using=Graph()
+    but then the resulting degree sequences might not be exact.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.alternating_havel_hakimi_graph
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    # length of the each sequence
+    naseq = len(aseq)
+    nbseq = len(bseq)
+    suma = sum(aseq)
+    sumb = sum(bseq)
+
+    if not suma == sumb:
+        raise nx.NetworkXError(
+            f"invalid degree sequences, sum(aseq)!=sum(bseq),{suma},{sumb}"
+        )
+
+    G = _add_nodes_with_bipartite_label(G, naseq, nbseq)
+
+    if len(aseq) == 0 or max(aseq) == 0:
+        return G  # done if no edges
+    # build list of degree-repeated vertex numbers
+    astubs = [[aseq[v], v] for v in range(0, naseq)]
+    bstubs = [[bseq[v - naseq], v] for v in range(naseq, naseq + nbseq)]
+    while astubs:
+        astubs.sort()
+        (degree, u) = astubs.pop()  # take of largest degree node in the a set
+        if degree == 0:
+            break  # done, all are zero
+        bstubs.sort()
+        small = bstubs[0 : degree // 2]  # add these low degree targets
+        large = bstubs[(-degree + degree // 2) :]  # now high degree targets
+        stubs = [x for z in zip(large, small) for x in z]  # combine, sorry
+        if len(stubs) < len(small) + len(large):  # check for zip truncation
+            stubs.append(large.pop())
+        for target in stubs:
+            v = target[1]
+            G.add_edge(u, v)
+            target[0] -= 1  # note this updates bstubs too.
+            if target[0] == 0:
+                bstubs.remove(target)
+
+    G.name = "bipartite_alternating_havel_hakimi_graph"
+    return G
+
+
+@py_random_state(3)
+def preferential_attachment_graph(aseq, p, create_using=None, seed=None):
+    """Create a bipartite graph with a preferential attachment model from
+    a given single degree sequence.
+
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (len(aseq) - 1) and set B has nodes starting with node len(aseq).
+    The number of nodes in set B is random.
+
+    Parameters
+    ----------
+    aseq : list
+       Degree sequence for node set A.
+    p :  float
+       Probability that a new bottom node is added.
+    create_using : NetworkX graph instance, optional
+       Return graph of this type.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    References
+    ----------
+    .. [1] Guillaume, J.L. and Latapy, M.,
+       Bipartite graphs as models of complex networks.
+       Physica A: Statistical Mechanics and its Applications,
+       2006, 371(2), pp.795-813.
+    .. [2] Jean-Loup Guillaume and Matthieu Latapy,
+       Bipartite structure of all complex networks,
+       Inf. Process. Lett. 90, 2004, pg. 215-221
+       https://doi.org/10.1016/j.ipl.2004.03.007
+
+    Notes
+    -----
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.preferential_attachment_graph
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    if p > 1:
+        raise nx.NetworkXError(f"probability {p} > 1")
+
+    naseq = len(aseq)
+    G = _add_nodes_with_bipartite_label(G, naseq, 0)
+    vv = [[v] * aseq[v] for v in range(0, naseq)]
+    while vv:
+        while vv[0]:
+            source = vv[0][0]
+            vv[0].remove(source)
+            if seed.random() < p or len(G) == naseq:
+                target = len(G)
+                G.add_node(target, bipartite=1)
+                G.add_edge(source, target)
+            else:
+                bb = [[b] * G.degree(b) for b in range(naseq, len(G))]
+                # flatten the list of lists into a list.
+                bbstubs = reduce(lambda x, y: x + y, bb)
+                # choose preferentially a bottom node.
+                target = seed.choice(bbstubs)
+                G.add_node(target, bipartite=1)
+                G.add_edge(source, target)
+        vv.remove(vv[0])
+    G.name = "bipartite_preferential_attachment_model"
+    return G
+
+
+@py_random_state(3)
+def random_graph(n, m, p, seed=None, directed=False):
+    """Returns a bipartite random graph.
+
+    This is a bipartite version of the binomial (Erdős-Rényi) graph.
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (n - 1) and set B has nodes n to (n + m - 1).
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes in the first bipartite set.
+    m : int
+        The number of nodes in the second bipartite set.
+    p : float
+        Probability for edge creation.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    directed : bool, optional (default=False)
+        If True return a directed graph
+
+    Notes
+    -----
+    The bipartite random graph algorithm chooses each of the n*m (undirected)
+    or 2*nm (directed) possible edges with probability p.
+
+    This algorithm is $O(n+m)$ where $m$ is the expected number of edges.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.random_graph
+
+    See Also
+    --------
+    gnp_random_graph, configuration_model
+
+    References
+    ----------
+    .. [1] Vladimir Batagelj and Ulrik Brandes,
+       "Efficient generation of large random networks",
+       Phys. Rev. E, 71, 036113, 2005.
+    """
+    G = nx.Graph()
+    G = _add_nodes_with_bipartite_label(G, n, m)
+    if directed:
+        G = nx.DiGraph(G)
+    G.name = f"fast_gnp_random_graph({n},{m},{p})"
+
+    if p <= 0:
+        return G
+    if p >= 1:
+        return nx.complete_bipartite_graph(n, m)
+
+    lp = math.log(1.0 - p)
+
+    v = 0
+    w = -1
+    while v < n:
+        lr = math.log(1.0 - seed.random())
+        w = w + 1 + int(lr / lp)
+        while w >= m and v < n:
+            w = w - m
+            v = v + 1
+        if v < n:
+            G.add_edge(v, n + w)
+
+    if directed:
+        # use the same algorithm to
+        # add edges from the "m" to "n" set
+        v = 0
+        w = -1
+        while v < n:
+            lr = math.log(1.0 - seed.random())
+            w = w + 1 + int(lr / lp)
+            while w >= m and v < n:
+                w = w - m
+                v = v + 1
+            if v < n:
+                G.add_edge(n + w, v)
+
+    return G
+
+
+@py_random_state(3)
+def gnmk_random_graph(n, m, k, seed=None, directed=False):
+    """Returns a random bipartite graph G_{n,m,k}.
+
+    Produces a bipartite graph chosen randomly out of the set of all graphs
+    with n top nodes, m bottom nodes, and k edges.
+    The graph is composed of two sets of nodes.
+    Set A has nodes 0 to (n - 1) and set B has nodes n to (n + m - 1).
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes in the first bipartite set.
+    m : int
+        The number of nodes in the second bipartite set.
+    k : int
+        The number of edges
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    directed : bool, optional (default=False)
+        If True return a directed graph
+
+    Examples
+    --------
+    from nx.algorithms import bipartite
+    G = bipartite.gnmk_random_graph(10,20,50)
+
+    See Also
+    --------
+    gnm_random_graph
+
+    Notes
+    -----
+    If k > m * n then a complete bipartite graph is returned.
+
+    This graph is a bipartite version of the `G_{nm}` random graph model.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.gnmk_random_graph
+    """
+    G = nx.Graph()
+    G = _add_nodes_with_bipartite_label(G, n, m)
+    if directed:
+        G = nx.DiGraph(G)
+    G.name = f"bipartite_gnm_random_graph({n},{m},{k})"
+    if n == 1 or m == 1:
+        return G
+    max_edges = n * m  # max_edges for bipartite networks
+    if k >= max_edges:  # Maybe we should raise an exception here
+        return nx.complete_bipartite_graph(n, m, create_using=G)
+
+    top = [n for n, d in G.nodes(data=True) if d["bipartite"] == 0]
+    bottom = list(set(G) - set(top))
+    edge_count = 0
+    while edge_count < k:
+        # generate random edge,u,v
+        u = seed.choice(top)
+        v = seed.choice(bottom)
+        if v in G[u]:
+            continue
+        else:
+            G.add_edge(u, v)
+            edge_count += 1
+    return G
+
+
+def _add_nodes_with_bipartite_label(G, lena, lenb):
+    G.add_nodes_from(range(0, lena + lenb))
+    b = dict(zip(range(0, lena), [0] * lena))
+    b.update(dict(zip(range(lena, lena + lenb), [1] * lenb)))
+    nx.set_node_attributes(G, b, "bipartite")
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/matching.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/matching.py
new file mode 100644
index 0000000..48a22f9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/matching.py
@@ -0,0 +1,579 @@
+# This module uses material from the Wikipedia article Hopcroft--Karp algorithm
+# <https://en.wikipedia.org/wiki/Hopcroft%E2%80%93Karp_algorithm>, accessed on
+# January 3, 2015, which is released under the Creative Commons
+# Attribution-Share-Alike License 3.0
+# <http://creativecommons.org/licenses/by-sa/3.0/>. That article includes
+# pseudocode, which has been translated into the corresponding Python code.
+#
+# Portions of this module use code from David Eppstein's Python Algorithms and
+# Data Structures (PADS) library, which is dedicated to the public domain (for
+# proof, see <http://www.ics.uci.edu/~eppstein/PADS/ABOUT-PADS.txt>).
+"""Provides functions for computing maximum cardinality matchings and minimum
+weight full matchings in a bipartite graph.
+
+If you don't care about the particular implementation of the maximum matching
+algorithm, simply use the :func:`maximum_matching`. If you do care, you can
+import one of the named maximum matching algorithms directly.
+
+For example, to find a maximum matching in the complete bipartite graph with
+two vertices on the left and three vertices on the right:
+
+>>> G = nx.complete_bipartite_graph(2, 3)
+>>> left, right = nx.bipartite.sets(G)
+>>> list(left)
+[0, 1]
+>>> list(right)
+[2, 3, 4]
+>>> nx.bipartite.maximum_matching(G)
+{0: 2, 1: 3, 2: 0, 3: 1}
+
+The dictionary returned by :func:`maximum_matching` includes a mapping for
+vertices in both the left and right vertex sets.
+
+Similarly, :func:`minimum_weight_full_matching` produces, for a complete
+weighted bipartite graph, a matching whose cardinality is the cardinality of
+the smaller of the two partitions, and for which the sum of the weights of the
+edges included in the matching is minimal.
+
+"""
+import collections
+import itertools
+
+import networkx as nx
+from networkx.algorithms.bipartite import sets as bipartite_sets
+from networkx.algorithms.bipartite.matrix import biadjacency_matrix
+
+__all__ = [
+    "maximum_matching",
+    "hopcroft_karp_matching",
+    "eppstein_matching",
+    "to_vertex_cover",
+    "minimum_weight_full_matching",
+]
+
+INFINITY = float("inf")
+
+
+def hopcroft_karp_matching(G, top_nodes=None):
+    """Returns the maximum cardinality matching of the bipartite graph `G`.
+
+    A matching is a set of edges that do not share any nodes. A maximum
+    cardinality matching is a matching with the most edges possible. It
+    is not always unique. Finding a matching in a bipartite graph can be
+    treated as a networkx flow problem.
+
+    The functions ``hopcroft_karp_matching`` and ``maximum_matching``
+    are aliases of the same function.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+      Undirected bipartite graph
+
+    top_nodes : container of nodes
+
+      Container with all nodes in one bipartite node set. If not supplied
+      it will be computed. But if more than one solution exists an exception
+      will be raised.
+
+    Returns
+    -------
+    matches : dictionary
+
+      The matching is returned as a dictionary, `matches`, such that
+      ``matches[v] == w`` if node `v` is matched to node `w`. Unmatched
+      nodes do not occur as a key in `matches`.
+
+    Raises
+    ------
+    AmbiguousSolution
+      Raised if the input bipartite graph is disconnected and no container
+      with all nodes in one bipartite set is provided. When determining
+      the nodes in each bipartite set more than one valid solution is
+      possible if the input graph is disconnected.
+
+    Notes
+    -----
+    This function is implemented with the `Hopcroft--Karp matching algorithm
+    <https://en.wikipedia.org/wiki/Hopcroft%E2%80%93Karp_algorithm>`_ for
+    bipartite graphs.
+
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    See Also
+    --------
+    maximum_matching
+    hopcroft_karp_matching
+    eppstein_matching
+
+    References
+    ----------
+    .. [1] John E. Hopcroft and Richard M. Karp. "An n^{5 / 2} Algorithm for
+       Maximum Matchings in Bipartite Graphs" In: **SIAM Journal of Computing**
+       2.4 (1973), pp. 225--231. <https://doi.org/10.1137/0202019>.
+
+    """
+    # First we define some auxiliary search functions.
+    #
+    # If you are a human reading these auxiliary search functions, the "global"
+    # variables `leftmatches`, `rightmatches`, `distances`, etc. are defined
+    # below the functions, so that they are initialized close to the initial
+    # invocation of the search functions.
+    def breadth_first_search():
+        for v in left:
+            if leftmatches[v] is None:
+                distances[v] = 0
+                queue.append(v)
+            else:
+                distances[v] = INFINITY
+        distances[None] = INFINITY
+        while queue:
+            v = queue.popleft()
+            if distances[v] < distances[None]:
+                for u in G[v]:
+                    if distances[rightmatches[u]] is INFINITY:
+                        distances[rightmatches[u]] = distances[v] + 1
+                        queue.append(rightmatches[u])
+        return distances[None] is not INFINITY
+
+    def depth_first_search(v):
+        if v is not None:
+            for u in G[v]:
+                if distances[rightmatches[u]] == distances[v] + 1:
+                    if depth_first_search(rightmatches[u]):
+                        rightmatches[u] = v
+                        leftmatches[v] = u
+                        return True
+            distances[v] = INFINITY
+            return False
+        return True
+
+    # Initialize the "global" variables that maintain state during the search.
+    left, right = bipartite_sets(G, top_nodes)
+    leftmatches = {v: None for v in left}
+    rightmatches = {v: None for v in right}
+    distances = {}
+    queue = collections.deque()
+
+    # Implementation note: this counter is incremented as pairs are matched but
+    # it is currently not used elsewhere in the computation.
+    num_matched_pairs = 0
+    while breadth_first_search():
+        for v in left:
+            if leftmatches[v] is None:
+                if depth_first_search(v):
+                    num_matched_pairs += 1
+
+    # Strip the entries matched to `None`.
+    leftmatches = {k: v for k, v in leftmatches.items() if v is not None}
+    rightmatches = {k: v for k, v in rightmatches.items() if v is not None}
+
+    # At this point, the left matches and the right matches are inverses of one
+    # another. In other words,
+    #
+    #     leftmatches == {v, k for k, v in rightmatches.items()}
+    #
+    # Finally, we combine both the left matches and right matches.
+    return dict(itertools.chain(leftmatches.items(), rightmatches.items()))
+
+
+def eppstein_matching(G, top_nodes=None):
+    """Returns the maximum cardinality matching of the bipartite graph `G`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+      Undirected bipartite graph
+
+    top_nodes : container
+
+      Container with all nodes in one bipartite node set. If not supplied
+      it will be computed. But if more than one solution exists an exception
+      will be raised.
+
+    Returns
+    -------
+    matches : dictionary
+
+      The matching is returned as a dictionary, `matching`, such that
+      ``matching[v] == w`` if node `v` is matched to node `w`. Unmatched
+      nodes do not occur as a key in `matching`.
+
+    Raises
+    ------
+    AmbiguousSolution
+      Raised if the input bipartite graph is disconnected and no container
+      with all nodes in one bipartite set is provided. When determining
+      the nodes in each bipartite set more than one valid solution is
+      possible if the input graph is disconnected.
+
+    Notes
+    -----
+    This function is implemented with David Eppstein's version of the algorithm
+    Hopcroft--Karp algorithm (see :func:`hopcroft_karp_matching`), which
+    originally appeared in the `Python Algorithms and Data Structures library
+    (PADS) <http://www.ics.uci.edu/~eppstein/PADS/ABOUT-PADS.txt>`_.
+
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    See Also
+    --------
+
+    hopcroft_karp_matching
+
+    """
+    # Due to its original implementation, a directed graph is needed
+    # so that the two sets of bipartite nodes can be distinguished
+    left, right = bipartite_sets(G, top_nodes)
+    G = nx.DiGraph(G.edges(left))
+    # initialize greedy matching (redundant, but faster than full search)
+    matching = {}
+    for u in G:
+        for v in G[u]:
+            if v not in matching:
+                matching[v] = u
+                break
+    while True:
+        # structure residual graph into layers
+        # pred[u] gives the neighbor in the previous layer for u in U
+        # preds[v] gives a list of neighbors in the previous layer for v in V
+        # unmatched gives a list of unmatched vertices in final layer of V,
+        # and is also used as a flag value for pred[u] when u is in the first
+        # layer
+        preds = {}
+        unmatched = []
+        pred = {u: unmatched for u in G}
+        for v in matching:
+            del pred[matching[v]]
+        layer = list(pred)
+
+        # repeatedly extend layering structure by another pair of layers
+        while layer and not unmatched:
+            newLayer = {}
+            for u in layer:
+                for v in G[u]:
+                    if v not in preds:
+                        newLayer.setdefault(v, []).append(u)
+            layer = []
+            for v in newLayer:
+                preds[v] = newLayer[v]
+                if v in matching:
+                    layer.append(matching[v])
+                    pred[matching[v]] = v
+                else:
+                    unmatched.append(v)
+
+        # did we finish layering without finding any alternating paths?
+        if not unmatched:
+            unlayered = {}
+            for u in G:
+                # TODO Why is extra inner loop necessary?
+                for v in G[u]:
+                    if v not in preds:
+                        unlayered[v] = None
+            # TODO Originally, this function returned a three-tuple:
+            #
+            #     return (matching, list(pred), list(unlayered))
+            #
+            # For some reason, the documentation for this function
+            # indicated that the second and third elements of the returned
+            # three-tuple would be the vertices in the left and right vertex
+            # sets, respectively, that are also in the maximum independent set.
+            # However, what I think the author meant was that the second
+            # element is the list of vertices that were unmatched and the third
+            # element was the list of vertices that were matched. Since that
+            # seems to be the case, they don't really need to be returned,
+            # since that information can be inferred from the matching
+            # dictionary.
+
+            # All the matched nodes must be a key in the dictionary
+            for key in matching.copy():
+                matching[matching[key]] = key
+            return matching
+
+        # recursively search backward through layers to find alternating paths
+        # recursion returns true if found path, false otherwise
+        def recurse(v):
+            if v in preds:
+                L = preds.pop(v)
+                for u in L:
+                    if u in pred:
+                        pu = pred.pop(u)
+                        if pu is unmatched or recurse(pu):
+                            matching[v] = u
+                            return True
+            return False
+
+        for v in unmatched:
+            recurse(v)
+
+
+def _is_connected_by_alternating_path(G, v, matched_edges, unmatched_edges, targets):
+    """Returns True if and only if the vertex `v` is connected to one of
+    the target vertices by an alternating path in `G`.
+
+    An *alternating path* is a path in which every other edge is in the
+    specified maximum matching (and the remaining edges in the path are not in
+    the matching). An alternating path may have matched edges in the even
+    positions or in the odd positions, as long as the edges alternate between
+    'matched' and 'unmatched'.
+
+    `G` is an undirected bipartite NetworkX graph.
+
+    `v` is a vertex in `G`.
+
+    `matched_edges` is a set of edges present in a maximum matching in `G`.
+
+    `unmatched_edges` is a set of edges not present in a maximum
+    matching in `G`.
+
+    `targets` is a set of vertices.
+
+    """
+
+    def _alternating_dfs(u, along_matched=True):
+        """Returns True if and only if `u` is connected to one of the
+        targets by an alternating path.
+
+        `u` is a vertex in the graph `G`.
+
+        If `along_matched` is True, this step of the depth-first search
+        will continue only through edges in the given matching. Otherwise, it
+        will continue only through edges *not* in the given matching.
+
+        """
+        visited = set()
+        # Follow matched edges when depth is even,
+        # and follow unmatched edges when depth is odd.
+        initial_depth = 0 if along_matched else 1
+        stack = [(u, iter(G[u]), initial_depth)]
+        while stack:
+            parent, children, depth = stack[-1]
+            valid_edges = matched_edges if depth % 2 else unmatched_edges
+            try:
+                child = next(children)
+                if child not in visited:
+                    if (parent, child) in valid_edges or (child, parent) in valid_edges:
+                        if child in targets:
+                            return True
+                        visited.add(child)
+                        stack.append((child, iter(G[child]), depth + 1))
+            except StopIteration:
+                stack.pop()
+        return False
+
+    # Check for alternating paths starting with edges in the matching, then
+    # check for alternating paths starting with edges not in the
+    # matching.
+    return _alternating_dfs(v, along_matched=True) or _alternating_dfs(
+        v, along_matched=False
+    )
+
+
+def _connected_by_alternating_paths(G, matching, targets):
+    """Returns the set of vertices that are connected to one of the target
+    vertices by an alternating path in `G` or are themselves a target.
+
+    An *alternating path* is a path in which every other edge is in the
+    specified maximum matching (and the remaining edges in the path are not in
+    the matching). An alternating path may have matched edges in the even
+    positions or in the odd positions, as long as the edges alternate between
+    'matched' and 'unmatched'.
+
+    `G` is an undirected bipartite NetworkX graph.
+
+    `matching` is a dictionary representing a maximum matching in `G`, as
+    returned by, for example, :func:`maximum_matching`.
+
+    `targets` is a set of vertices.
+
+    """
+    # Get the set of matched edges and the set of unmatched edges. Only include
+    # one version of each undirected edge (for example, include edge (1, 2) but
+    # not edge (2, 1)). Using frozensets as an intermediary step we do not
+    # require nodes to be orderable.
+    edge_sets = {frozenset((u, v)) for u, v in matching.items()}
+    matched_edges = {tuple(edge) for edge in edge_sets}
+    unmatched_edges = {
+        (u, v) for (u, v) in G.edges() if frozenset((u, v)) not in edge_sets
+    }
+
+    return {
+        v
+        for v in G
+        if v in targets
+        or _is_connected_by_alternating_path(
+            G, v, matched_edges, unmatched_edges, targets
+        )
+    }
+
+
+def to_vertex_cover(G, matching, top_nodes=None):
+    """Returns the minimum vertex cover corresponding to the given maximum
+    matching of the bipartite graph `G`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+      Undirected bipartite graph
+
+    matching : dictionary
+
+      A dictionary whose keys are vertices in `G` and whose values are the
+      distinct neighbors comprising the maximum matching for `G`, as returned
+      by, for example, :func:`maximum_matching`. The dictionary *must*
+      represent the maximum matching.
+
+    top_nodes : container
+
+      Container with all nodes in one bipartite node set. If not supplied
+      it will be computed. But if more than one solution exists an exception
+      will be raised.
+
+    Returns
+    -------
+    vertex_cover : :class:`set`
+
+      The minimum vertex cover in `G`.
+
+    Raises
+    ------
+    AmbiguousSolution
+      Raised if the input bipartite graph is disconnected and no container
+      with all nodes in one bipartite set is provided. When determining
+      the nodes in each bipartite set more than one valid solution is
+      possible if the input graph is disconnected.
+
+    Notes
+    -----
+    This function is implemented using the procedure guaranteed by `Konig's
+    theorem
+    <https://en.wikipedia.org/wiki/K%C3%B6nig%27s_theorem_%28graph_theory%29>`_,
+    which proves an equivalence between a maximum matching and a minimum vertex
+    cover in bipartite graphs.
+
+    Since a minimum vertex cover is the complement of a maximum independent set
+    for any graph, one can compute the maximum independent set of a bipartite
+    graph this way:
+
+    >>> G = nx.complete_bipartite_graph(2, 3)
+    >>> matching = nx.bipartite.maximum_matching(G)
+    >>> vertex_cover = nx.bipartite.to_vertex_cover(G, matching)
+    >>> independent_set = set(G) - vertex_cover
+    >>> print(list(independent_set))
+    [2, 3, 4]
+
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    """
+    # This is a Python implementation of the algorithm described at
+    # <https://en.wikipedia.org/wiki/K%C3%B6nig%27s_theorem_%28graph_theory%29#Proof>.
+    L, R = bipartite_sets(G, top_nodes)
+    # Let U be the set of unmatched vertices in the left vertex set.
+    unmatched_vertices = set(G) - set(matching)
+    U = unmatched_vertices & L
+    # Let Z be the set of vertices that are either in U or are connected to U
+    # by alternating paths.
+    Z = _connected_by_alternating_paths(G, matching, U)
+    # At this point, every edge either has a right endpoint in Z or a left
+    # endpoint not in Z. This gives us the vertex cover.
+    return (L - Z) | (R & Z)
+
+
+#: Returns the maximum cardinality matching in the given bipartite graph.
+#:
+#: This function is simply an alias for :func:`hopcroft_karp_matching`.
+maximum_matching = hopcroft_karp_matching
+
+
+def minimum_weight_full_matching(G, top_nodes=None, weight="weight"):
+    r"""Returns a minimum weight full matching of the bipartite graph `G`.
+
+    Let :math:`G = ((U, V), E)` be a weighted bipartite graph with real weights
+    :math:`w : E \to \mathbb{R}`. This function then produces a matching
+    :math:`M \subseteq E` with cardinality
+
+    .. math::
+       \lvert M \rvert = \min(\lvert U \rvert, \lvert V \rvert),
+
+    which minimizes the sum of the weights of the edges included in the
+    matching, :math:`\sum_{e \in M} w(e)`, or raises an error if no such
+    matching exists.
+
+    When :math:`\lvert U \rvert = \lvert V \rvert`, this is commonly
+    referred to as a perfect matching; here, since we allow
+    :math:`\lvert U \rvert` and :math:`\lvert V \rvert` to differ, we
+    follow Karp [1]_ and refer to the matching as *full*.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+      Undirected bipartite graph
+
+    top_nodes : container
+
+      Container with all nodes in one bipartite node set. If not supplied
+      it will be computed.
+
+    weight : string, optional (default='weight')
+
+       The edge data key used to provide each value in the matrix.
+
+    Returns
+    -------
+    matches : dictionary
+
+      The matching is returned as a dictionary, `matches`, such that
+      ``matches[v] == w`` if node `v` is matched to node `w`. Unmatched
+      nodes do not occur as a key in `matches`.
+
+    Raises
+    ------
+    ValueError
+      Raised if no full matching exists.
+
+    ImportError
+      Raised if SciPy is not available.
+
+    Notes
+    -----
+    The problem of determining a minimum weight full matching is also known as
+    the rectangular linear assignment problem. This implementation defers the
+    calculation of the assignment to SciPy.
+
+    References
+    ----------
+    .. [1] Richard Manning Karp:
+       An algorithm to Solve the m x n Assignment Problem in Expected Time
+       O(mn log n).
+       Networks, 10(2):143–152, 1980.
+
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.optimize  # call as sp.optimize
+
+    left, right = nx.bipartite.sets(G, top_nodes)
+    U = list(left)
+    V = list(right)
+    # We explicitly create the biadjancency matrix having infinities
+    # where edges are missing (as opposed to zeros, which is what one would
+    # get by using toarray on the sparse matrix).
+    weights_sparse = biadjacency_matrix(
+        G, row_order=U, column_order=V, weight=weight, format="coo"
+    )
+    weights = np.full(weights_sparse.shape, np.inf)
+    weights[weights_sparse.row, weights_sparse.col] = weights_sparse.data
+    left_matches = sp.optimize.linear_sum_assignment(weights)
+    d = {U[u]: V[v] for u, v in zip(*left_matches)}
+    # d will contain the matching from edges in left to right; we need to
+    # add the ones from right to left as well.
+    d.update({v: u for u, v in d.items()})
+    return d
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/matrix.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/matrix.py
new file mode 100644
index 0000000..276d3e4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/matrix.py
@@ -0,0 +1,174 @@
+"""
+====================
+Biadjacency matrices
+====================
+"""
+import itertools
+
+import networkx as nx
+from networkx.convert_matrix import _generate_weighted_edges
+
+__all__ = ["biadjacency_matrix", "from_biadjacency_matrix"]
+
+
+def biadjacency_matrix(
+    G, row_order, column_order=None, dtype=None, weight="weight", format="csr"
+):
+    r"""Returns the biadjacency matrix of the bipartite graph G.
+
+    Let `G = (U, V, E)` be a bipartite graph with node sets
+    `U = u_{1},...,u_{r}` and `V = v_{1},...,v_{s}`. The biadjacency
+    matrix [1]_ is the `r` x `s` matrix `B` in which `b_{i,j} = 1`
+    if, and only if, `(u_i, v_j) \in E`. If the parameter `weight` is
+    not `None` and matches the name of an edge attribute, its value is
+    used instead of 1.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    row_order : list of nodes
+       The rows of the matrix are ordered according to the list of nodes.
+
+    column_order : list, optional
+       The columns of the matrix are ordered according to the list of nodes.
+       If column_order is None, then the ordering of columns is arbitrary.
+
+    dtype : NumPy data-type, optional
+        A valid NumPy dtype used to initialize the array. If None, then the
+        NumPy default is used.
+
+    weight : string or None, optional (default='weight')
+       The edge data key used to provide each value in the matrix.
+       If None, then each edge has weight 1.
+
+    format : str in {'bsr', 'csr', 'csc', 'coo', 'lil', 'dia', 'dok'}
+        The type of the matrix to be returned (default 'csr').  For
+        some algorithms different implementations of sparse matrices
+        can perform better.  See [2]_ for details.
+
+    Returns
+    -------
+    M : SciPy sparse matrix
+        Biadjacency matrix representation of the bipartite graph G.
+
+    Notes
+    -----
+    No attempt is made to check that the input graph is bipartite.
+
+    For directed bipartite graphs only successors are considered as neighbors.
+    To obtain an adjacency matrix with ones (or weight values) for both
+    predecessors and successors you have to generate two biadjacency matrices
+    where the rows of one of them are the columns of the other, and then add
+    one to the transpose of the other.
+
+    See Also
+    --------
+    adjacency_matrix
+    from_biadjacency_matrix
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Adjacency_matrix#Adjacency_matrix_of_a_bipartite_graph
+    .. [2] Scipy Dev. References, "Sparse Matrices",
+       https://docs.scipy.org/doc/scipy/reference/sparse.html
+    """
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    nlen = len(row_order)
+    if nlen == 0:
+        raise nx.NetworkXError("row_order is empty list")
+    if len(row_order) != len(set(row_order)):
+        msg = "Ambiguous ordering: `row_order` contained duplicates."
+        raise nx.NetworkXError(msg)
+    if column_order is None:
+        column_order = list(set(G) - set(row_order))
+    mlen = len(column_order)
+    if len(column_order) != len(set(column_order)):
+        msg = "Ambiguous ordering: `column_order` contained duplicates."
+        raise nx.NetworkXError(msg)
+
+    row_index = dict(zip(row_order, itertools.count()))
+    col_index = dict(zip(column_order, itertools.count()))
+
+    if G.number_of_edges() == 0:
+        row, col, data = [], [], []
+    else:
+        row, col, data = zip(
+            *(
+                (row_index[u], col_index[v], d.get(weight, 1))
+                for u, v, d in G.edges(row_order, data=True)
+                if u in row_index and v in col_index
+            )
+        )
+    # TODO: change coo_matrix -> coo_array for NX 3.0
+    A = sp.sparse.coo_matrix((data, (row, col)), shape=(nlen, mlen), dtype=dtype)
+    try:
+        import warnings
+
+        warnings.warn(
+            "biadjacency_matrix will return a scipy.sparse array instead of a matrix in NetworkX 3.0",
+            FutureWarning,
+            stacklevel=2,
+        )
+        return A.asformat(format)
+    except ValueError as err:
+        raise nx.NetworkXError(f"Unknown sparse array format: {format}") from err
+
+
+def from_biadjacency_matrix(A, create_using=None, edge_attribute="weight"):
+    r"""Creates a new bipartite graph from a biadjacency matrix given as a
+    SciPy sparse matrix.
+
+    Parameters
+    ----------
+    A: scipy sparse matrix
+      A biadjacency matrix representation of a graph
+
+    create_using: NetworkX graph
+       Use specified graph for result.  The default is Graph()
+
+    edge_attribute: string
+       Name of edge attribute to store matrix numeric value. The data will
+       have the same type as the matrix entry (int, float, (real,imag)).
+
+    Notes
+    -----
+    The nodes are labeled with the attribute `bipartite` set to an integer
+    0 or 1 representing membership in part 0 or part 1 of the bipartite graph.
+
+    If `create_using` is an instance of :class:`networkx.MultiGraph` or
+    :class:`networkx.MultiDiGraph` and the entries of `A` are of
+    type :class:`int`, then this function returns a multigraph (of the same
+    type as `create_using`) with parallel edges. In this case, `edge_attribute`
+    will be ignored.
+
+    See Also
+    --------
+    biadjacency_matrix
+    from_numpy_array
+
+    References
+    ----------
+    [1] https://en.wikipedia.org/wiki/Adjacency_matrix#Adjacency_matrix_of_a_bipartite_graph
+    """
+    G = nx.empty_graph(0, create_using)
+    n, m = A.shape
+    # Make sure we get even the isolated nodes of the graph.
+    G.add_nodes_from(range(n), bipartite=0)
+    G.add_nodes_from(range(n, n + m), bipartite=1)
+    # Create an iterable over (u, v, w) triples and for each triple, add an
+    # edge from u to v with weight w.
+    triples = ((u, n + v, d) for (u, v, d) in _generate_weighted_edges(A))
+    # If the entries in the adjacency matrix are integers and the graph is a
+    # multigraph, then create parallel edges, each with weight 1, for each
+    # entry in the adjacency matrix. Otherwise, create one edge for each
+    # positive entry in the adjacency matrix and set the weight of that edge to
+    # be the entry in the matrix.
+    if A.dtype.kind in ("i", "u") and G.is_multigraph():
+        chain = itertools.chain.from_iterable
+        triples = chain(((u, v, 1) for d in range(w)) for (u, v, w) in triples)
+    G.add_weighted_edges_from(triples, weight=edge_attribute)
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/projection.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/projection.py
new file mode 100644
index 0000000..8864195
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/projection.py
@@ -0,0 +1,538 @@
+"""One-mode (unipartite) projections of bipartite graphs."""
+import networkx as nx
+from networkx.exception import NetworkXAlgorithmError
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "project",
+    "projected_graph",
+    "weighted_projected_graph",
+    "collaboration_weighted_projected_graph",
+    "overlap_weighted_projected_graph",
+    "generic_weighted_projected_graph",
+]
+
+
+def projected_graph(B, nodes, multigraph=False):
+    r"""Returns the projection of B onto one of its node sets.
+
+    Returns the graph G that is the projection of the bipartite graph B
+    onto the specified nodes. They retain their attributes and are connected
+    in G if they have a common neighbor in B.
+
+    Parameters
+    ----------
+    B : NetworkX graph
+      The input graph should be bipartite.
+
+    nodes : list or iterable
+      Nodes to project onto (the "bottom" nodes).
+
+    multigraph: bool (default=False)
+       If True return a multigraph where the multiple edges represent multiple
+       shared neighbors.  They edge key in the multigraph is assigned to the
+       label of the neighbor.
+
+    Returns
+    -------
+    Graph : NetworkX graph or multigraph
+       A graph that is the projection onto the given nodes.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> B = nx.path_graph(4)
+    >>> G = bipartite.projected_graph(B, [1, 3])
+    >>> list(G)
+    [1, 3]
+    >>> list(G.edges())
+    [(1, 3)]
+
+    If nodes `a`, and `b` are connected through both nodes 1 and 2 then
+    building a multigraph results in two edges in the projection onto
+    [`a`, `b`]:
+
+    >>> B = nx.Graph()
+    >>> B.add_edges_from([("a", 1), ("b", 1), ("a", 2), ("b", 2)])
+    >>> G = bipartite.projected_graph(B, ["a", "b"], multigraph=True)
+    >>> print([sorted((u, v)) for u, v in G.edges()])
+    [['a', 'b'], ['a', 'b']]
+
+    Notes
+    -----
+    No attempt is made to verify that the input graph B is bipartite.
+    Returns a simple graph that is the projection of the bipartite graph B
+    onto the set of nodes given in list nodes.  If multigraph=True then
+    a multigraph is returned with an edge for every shared neighbor.
+
+    Directed graphs are allowed as input.  The output will also then
+    be a directed graph with edges if there is a directed path between
+    the nodes.
+
+    The graph and node properties are (shallow) copied to the projected graph.
+
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    See Also
+    --------
+    is_bipartite,
+    is_bipartite_node_set,
+    sets,
+    weighted_projected_graph,
+    collaboration_weighted_projected_graph,
+    overlap_weighted_projected_graph,
+    generic_weighted_projected_graph
+    """
+    if B.is_multigraph():
+        raise nx.NetworkXError("not defined for multigraphs")
+    if B.is_directed():
+        directed = True
+        if multigraph:
+            G = nx.MultiDiGraph()
+        else:
+            G = nx.DiGraph()
+    else:
+        directed = False
+        if multigraph:
+            G = nx.MultiGraph()
+        else:
+            G = nx.Graph()
+    G.graph.update(B.graph)
+    G.add_nodes_from((n, B.nodes[n]) for n in nodes)
+    for u in nodes:
+        nbrs2 = {v for nbr in B[u] for v in B[nbr] if v != u}
+        if multigraph:
+            for n in nbrs2:
+                if directed:
+                    links = set(B[u]) & set(B.pred[n])
+                else:
+                    links = set(B[u]) & set(B[n])
+                for l in links:
+                    if not G.has_edge(u, n, l):
+                        G.add_edge(u, n, key=l)
+        else:
+            G.add_edges_from((u, n) for n in nbrs2)
+    return G
+
+
+@not_implemented_for("multigraph")
+def weighted_projected_graph(B, nodes, ratio=False):
+    r"""Returns a weighted projection of B onto one of its node sets.
+
+    The weighted projected graph is the projection of the bipartite
+    network B onto the specified nodes with weights representing the
+    number of shared neighbors or the ratio between actual shared
+    neighbors and possible shared neighbors if ``ratio is True`` [1]_.
+    The nodes retain their attributes and are connected in the resulting
+    graph if they have an edge to a common node in the original graph.
+
+    Parameters
+    ----------
+    B : NetworkX graph
+        The input graph should be bipartite.
+
+    nodes : list or iterable
+        Distinct nodes to project onto (the "bottom" nodes).
+
+    ratio: Bool (default=False)
+        If True, edge weight is the ratio between actual shared neighbors
+        and maximum possible shared neighbors (i.e., the size of the other
+        node set). If False, edges weight is the number of shared neighbors.
+
+    Returns
+    -------
+    Graph : NetworkX graph
+       A graph that is the projection onto the given nodes.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> B = nx.path_graph(4)
+    >>> G = bipartite.weighted_projected_graph(B, [1, 3])
+    >>> list(G)
+    [1, 3]
+    >>> list(G.edges(data=True))
+    [(1, 3, {'weight': 1})]
+    >>> G = bipartite.weighted_projected_graph(B, [1, 3], ratio=True)
+    >>> list(G.edges(data=True))
+    [(1, 3, {'weight': 0.5})]
+
+    Notes
+    -----
+    No attempt is made to verify that the input graph B is bipartite, or that
+    the input nodes are distinct. However, if the length of the input nodes is
+    greater than or equal to the nodes in the graph B, an exception is raised.
+    If the nodes are not distinct but don't raise this error, the output weights
+    will be incorrect.
+    The graph and node properties are (shallow) copied to the projected graph.
+
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    See Also
+    --------
+    is_bipartite,
+    is_bipartite_node_set,
+    sets,
+    collaboration_weighted_projected_graph,
+    overlap_weighted_projected_graph,
+    generic_weighted_projected_graph
+    projected_graph
+
+    References
+    ----------
+    .. [1] Borgatti, S.P. and Halgin, D. In press. "Analyzing Affiliation
+        Networks". In Carrington, P. and Scott, J. (eds) The Sage Handbook
+        of Social Network Analysis. Sage Publications.
+    """
+    if B.is_directed():
+        pred = B.pred
+        G = nx.DiGraph()
+    else:
+        pred = B.adj
+        G = nx.Graph()
+    G.graph.update(B.graph)
+    G.add_nodes_from((n, B.nodes[n]) for n in nodes)
+    n_top = len(B) - len(nodes)
+
+    if n_top < 1:
+        raise NetworkXAlgorithmError(
+            f"the size of the nodes to project onto ({len(nodes)}) is >= the graph size ({len(B)}).\n"
+            "They are either not a valid bipartite partition or contain duplicates"
+        )
+
+    for u in nodes:
+        unbrs = set(B[u])
+        nbrs2 = {n for nbr in unbrs for n in B[nbr]} - {u}
+        for v in nbrs2:
+            vnbrs = set(pred[v])
+            common = unbrs & vnbrs
+            if not ratio:
+                weight = len(common)
+            else:
+                weight = len(common) / n_top
+            G.add_edge(u, v, weight=weight)
+    return G
+
+
+@not_implemented_for("multigraph")
+def collaboration_weighted_projected_graph(B, nodes):
+    r"""Newman's weighted projection of B onto one of its node sets.
+
+    The collaboration weighted projection is the projection of the
+    bipartite network B onto the specified nodes with weights assigned
+    using Newman's collaboration model [1]_:
+
+    .. math::
+
+        w_{u, v} = \sum_k \frac{\delta_{u}^{k} \delta_{v}^{k}}{d_k - 1}
+
+    where `u` and `v` are nodes from the bottom bipartite node set,
+    and `k` is a node of the top node set.
+    The value `d_k` is the degree of node `k` in the bipartite
+    network and `\delta_{u}^{k}` is 1 if node `u` is
+    linked to node `k` in the original bipartite graph or 0 otherwise.
+
+    The nodes retain their attributes and are connected in the resulting
+    graph if have an edge to a common node in the original bipartite
+    graph.
+
+    Parameters
+    ----------
+    B : NetworkX graph
+      The input graph should be bipartite.
+
+    nodes : list or iterable
+      Nodes to project onto (the "bottom" nodes).
+
+    Returns
+    -------
+    Graph : NetworkX graph
+       A graph that is the projection onto the given nodes.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> B = nx.path_graph(5)
+    >>> B.add_edge(1, 5)
+    >>> G = bipartite.collaboration_weighted_projected_graph(B, [0, 2, 4, 5])
+    >>> list(G)
+    [0, 2, 4, 5]
+    >>> for edge in sorted(G.edges(data=True)):
+    ...     print(edge)
+    ...
+    (0, 2, {'weight': 0.5})
+    (0, 5, {'weight': 0.5})
+    (2, 4, {'weight': 1.0})
+    (2, 5, {'weight': 0.5})
+
+    Notes
+    -----
+    No attempt is made to verify that the input graph B is bipartite.
+    The graph and node properties are (shallow) copied to the projected graph.
+
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    See Also
+    --------
+    is_bipartite,
+    is_bipartite_node_set,
+    sets,
+    weighted_projected_graph,
+    overlap_weighted_projected_graph,
+    generic_weighted_projected_graph,
+    projected_graph
+
+    References
+    ----------
+    .. [1] Scientific collaboration networks: II.
+        Shortest paths, weighted networks, and centrality,
+        M. E. J. Newman, Phys. Rev. E 64, 016132 (2001).
+    """
+    if B.is_directed():
+        pred = B.pred
+        G = nx.DiGraph()
+    else:
+        pred = B.adj
+        G = nx.Graph()
+    G.graph.update(B.graph)
+    G.add_nodes_from((n, B.nodes[n]) for n in nodes)
+    for u in nodes:
+        unbrs = set(B[u])
+        nbrs2 = {n for nbr in unbrs for n in B[nbr] if n != u}
+        for v in nbrs2:
+            vnbrs = set(pred[v])
+            common_degree = (len(B[n]) for n in unbrs & vnbrs)
+            weight = sum(1.0 / (deg - 1) for deg in common_degree if deg > 1)
+            G.add_edge(u, v, weight=weight)
+    return G
+
+
+@not_implemented_for("multigraph")
+def overlap_weighted_projected_graph(B, nodes, jaccard=True):
+    r"""Overlap weighted projection of B onto one of its node sets.
+
+    The overlap weighted projection is the projection of the bipartite
+    network B onto the specified nodes with weights representing
+    the Jaccard index between the neighborhoods of the two nodes in the
+    original bipartite network [1]_:
+
+    .. math::
+
+        w_{v, u} = \frac{|N(u) \cap N(v)|}{|N(u) \cup N(v)|}
+
+    or if the parameter 'jaccard' is False, the fraction of common
+    neighbors by minimum of both nodes degree in the original
+    bipartite graph [1]_:
+
+    .. math::
+
+        w_{v, u} = \frac{|N(u) \cap N(v)|}{min(|N(u)|, |N(v)|)}
+
+    The nodes retain their attributes and are connected in the resulting
+    graph if have an edge to a common node in the original bipartite graph.
+
+    Parameters
+    ----------
+    B : NetworkX graph
+        The input graph should be bipartite.
+
+    nodes : list or iterable
+        Nodes to project onto (the "bottom" nodes).
+
+    jaccard: Bool (default=True)
+
+    Returns
+    -------
+    Graph : NetworkX graph
+       A graph that is the projection onto the given nodes.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> B = nx.path_graph(5)
+    >>> nodes = [0, 2, 4]
+    >>> G = bipartite.overlap_weighted_projected_graph(B, nodes)
+    >>> list(G)
+    [0, 2, 4]
+    >>> list(G.edges(data=True))
+    [(0, 2, {'weight': 0.5}), (2, 4, {'weight': 0.5})]
+    >>> G = bipartite.overlap_weighted_projected_graph(B, nodes, jaccard=False)
+    >>> list(G.edges(data=True))
+    [(0, 2, {'weight': 1.0}), (2, 4, {'weight': 1.0})]
+
+    Notes
+    -----
+    No attempt is made to verify that the input graph B is bipartite.
+    The graph and node properties are (shallow) copied to the projected graph.
+
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    See Also
+    --------
+    is_bipartite,
+    is_bipartite_node_set,
+    sets,
+    weighted_projected_graph,
+    collaboration_weighted_projected_graph,
+    generic_weighted_projected_graph,
+    projected_graph
+
+    References
+    ----------
+    .. [1] Borgatti, S.P. and Halgin, D. In press. Analyzing Affiliation
+        Networks. In Carrington, P. and Scott, J. (eds) The Sage Handbook
+        of Social Network Analysis. Sage Publications.
+
+    """
+    if B.is_directed():
+        pred = B.pred
+        G = nx.DiGraph()
+    else:
+        pred = B.adj
+        G = nx.Graph()
+    G.graph.update(B.graph)
+    G.add_nodes_from((n, B.nodes[n]) for n in nodes)
+    for u in nodes:
+        unbrs = set(B[u])
+        nbrs2 = {n for nbr in unbrs for n in B[nbr]} - {u}
+        for v in nbrs2:
+            vnbrs = set(pred[v])
+            if jaccard:
+                wt = len(unbrs & vnbrs) / len(unbrs | vnbrs)
+            else:
+                wt = len(unbrs & vnbrs) / min(len(unbrs), len(vnbrs))
+            G.add_edge(u, v, weight=wt)
+    return G
+
+
+@not_implemented_for("multigraph")
+def generic_weighted_projected_graph(B, nodes, weight_function=None):
+    r"""Weighted projection of B with a user-specified weight function.
+
+    The bipartite network B is projected on to the specified nodes
+    with weights computed by a user-specified function.  This function
+    must accept as a parameter the neighborhood sets of two nodes and
+    return an integer or a float.
+
+    The nodes retain their attributes and are connected in the resulting graph
+    if they have an edge to a common node in the original graph.
+
+    Parameters
+    ----------
+    B : NetworkX graph
+        The input graph should be bipartite.
+
+    nodes : list or iterable
+        Nodes to project onto (the "bottom" nodes).
+
+    weight_function : function
+        This function must accept as parameters the same input graph
+        that this function, and two nodes; and return an integer or a float.
+        The default function computes the number of shared neighbors.
+
+    Returns
+    -------
+    Graph : NetworkX graph
+       A graph that is the projection onto the given nodes.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> # Define some custom weight functions
+    >>> def jaccard(G, u, v):
+    ...     unbrs = set(G[u])
+    ...     vnbrs = set(G[v])
+    ...     return float(len(unbrs & vnbrs)) / len(unbrs | vnbrs)
+    ...
+    >>> def my_weight(G, u, v, weight="weight"):
+    ...     w = 0
+    ...     for nbr in set(G[u]) & set(G[v]):
+    ...         w += G[u][nbr].get(weight, 1) + G[v][nbr].get(weight, 1)
+    ...     return w
+    ...
+    >>> # A complete bipartite graph with 4 nodes and 4 edges
+    >>> B = nx.complete_bipartite_graph(2, 2)
+    >>> # Add some arbitrary weight to the edges
+    >>> for i, (u, v) in enumerate(B.edges()):
+    ...     B.edges[u, v]["weight"] = i + 1
+    ...
+    >>> for edge in B.edges(data=True):
+    ...     print(edge)
+    ...
+    (0, 2, {'weight': 1})
+    (0, 3, {'weight': 2})
+    (1, 2, {'weight': 3})
+    (1, 3, {'weight': 4})
+    >>> # By default, the weight is the number of shared neighbors
+    >>> G = bipartite.generic_weighted_projected_graph(B, [0, 1])
+    >>> print(list(G.edges(data=True)))
+    [(0, 1, {'weight': 2})]
+    >>> # To specify a custom weight function use the weight_function parameter
+    >>> G = bipartite.generic_weighted_projected_graph(
+    ...     B, [0, 1], weight_function=jaccard
+    ... )
+    >>> print(list(G.edges(data=True)))
+    [(0, 1, {'weight': 1.0})]
+    >>> G = bipartite.generic_weighted_projected_graph(
+    ...     B, [0, 1], weight_function=my_weight
+    ... )
+    >>> print(list(G.edges(data=True)))
+    [(0, 1, {'weight': 10})]
+
+    Notes
+    -----
+    No attempt is made to verify that the input graph B is bipartite.
+    The graph and node properties are (shallow) copied to the projected graph.
+
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+    See Also
+    --------
+    is_bipartite,
+    is_bipartite_node_set,
+    sets,
+    weighted_projected_graph,
+    collaboration_weighted_projected_graph,
+    overlap_weighted_projected_graph,
+    projected_graph
+
+    """
+    if B.is_directed():
+        pred = B.pred
+        G = nx.DiGraph()
+    else:
+        pred = B.adj
+        G = nx.Graph()
+    if weight_function is None:
+
+        def weight_function(G, u, v):
+            # Notice that we use set(pred[v]) for handling the directed case.
+            return len(set(G[u]) & set(pred[v]))
+
+    G.graph.update(B.graph)
+    G.add_nodes_from((n, B.nodes[n]) for n in nodes)
+    for u in nodes:
+        nbrs2 = {n for nbr in set(B[u]) for n in B[nbr]} - {u}
+        for v in nbrs2:
+            weight = weight_function(B, u, v)
+            G.add_edge(u, v, weight=weight)
+    return G
+
+
+def project(B, nodes, create_using=None):
+    import warnings
+
+    warnings.warn(
+        (
+            "networkx.project is deprecated and will be removed"
+            "in NetworkX 3.0, use networkx.projected_graph instead."
+        ),
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return projected_graph(B, nodes)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/redundancy.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/redundancy.py
new file mode 100644
index 0000000..55de063
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/redundancy.py
@@ -0,0 +1,111 @@
+"""Node redundancy for bipartite graphs."""
+from itertools import combinations
+
+from networkx import NetworkXError
+
+__all__ = ["node_redundancy"]
+
+
+def node_redundancy(G, nodes=None):
+    r"""Computes the node redundancy coefficients for the nodes in the bipartite
+    graph `G`.
+
+    The redundancy coefficient of a node `v` is the fraction of pairs of
+    neighbors of `v` that are both linked to other nodes. In a one-mode
+    projection these nodes would be linked together even if `v` were
+    not there.
+
+    More formally, for any vertex `v`, the *redundancy coefficient of `v`* is
+    defined by
+
+    .. math::
+
+        rc(v) = \frac{|\{\{u, w\} \subseteq N(v),
+        \: \exists v' \neq  v,\: (v',u) \in E\:
+        \mathrm{and}\: (v',w) \in E\}|}{ \frac{|N(v)|(|N(v)|-1)}{2}},
+
+    where `N(v)` is the set of neighbors of `v` in `G`.
+
+    Parameters
+    ----------
+    G : graph
+        A bipartite graph
+
+    nodes : list or iterable (optional)
+        Compute redundancy for these nodes. The default is all nodes in G.
+
+    Returns
+    -------
+    redundancy : dictionary
+        A dictionary keyed by node with the node redundancy value.
+
+    Examples
+    --------
+    Compute the redundancy coefficient of each node in a graph::
+
+        >>> from networkx.algorithms import bipartite
+        >>> G = nx.cycle_graph(4)
+        >>> rc = bipartite.node_redundancy(G)
+        >>> rc[0]
+        1.0
+
+    Compute the average redundancy for the graph::
+
+        >>> from networkx.algorithms import bipartite
+        >>> G = nx.cycle_graph(4)
+        >>> rc = bipartite.node_redundancy(G)
+        >>> sum(rc.values()) / len(G)
+        1.0
+
+    Compute the average redundancy for a set of nodes::
+
+        >>> from networkx.algorithms import bipartite
+        >>> G = nx.cycle_graph(4)
+        >>> rc = bipartite.node_redundancy(G)
+        >>> nodes = [0, 2]
+        >>> sum(rc[n] for n in nodes) / len(nodes)
+        1.0
+
+    Raises
+    ------
+    NetworkXError
+        If any of the nodes in the graph (or in `nodes`, if specified) has
+        (out-)degree less than two (which would result in division by zero,
+        according to the definition of the redundancy coefficient).
+
+    References
+    ----------
+    .. [1] Latapy, Matthieu, Clémence Magnien, and Nathalie Del Vecchio (2008).
+       Basic notions for the analysis of large two-mode networks.
+       Social Networks 30(1), 31--48.
+
+    """
+    if nodes is None:
+        nodes = G
+    if any(len(G[v]) < 2 for v in nodes):
+        raise NetworkXError(
+            "Cannot compute redundancy coefficient for a node"
+            " that has fewer than two neighbors."
+        )
+    # TODO This can be trivially parallelized.
+    return {v: _node_redundancy(G, v) for v in nodes}
+
+
+def _node_redundancy(G, v):
+    """Returns the redundancy of the node `v` in the bipartite graph `G`.
+
+    If `G` is a graph with `n` nodes, the redundancy of a node is the ratio
+    of the "overlap" of `v` to the maximum possible overlap of `v`
+    according to its degree. The overlap of `v` is the number of pairs of
+    neighbors that have mutual neighbors themselves, other than `v`.
+
+    `v` must have at least two neighbors in `G`.
+
+    """
+    n = len(G[v])
+    # TODO On Python 3, we could just use `G[u].keys() & G[w].keys()` instead
+    # of instantiating the entire sets.
+    overlap = sum(
+        1 for (u, w) in combinations(G[v], 2) if (set(G[u]) & set(G[w])) - {v}
+    )
+    return (2 * overlap) / (n * (n - 1))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/spectral.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/spectral.py
new file mode 100644
index 0000000..290893f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/spectral.py
@@ -0,0 +1,68 @@
+"""
+Spectral bipartivity measure.
+"""
+import networkx as nx
+
+__all__ = ["spectral_bipartivity"]
+
+
+def spectral_bipartivity(G, nodes=None, weight="weight"):
+    """Returns the spectral bipartivity.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    nodes : list or container  optional(default is all nodes)
+      Nodes to return value of spectral bipartivity contribution.
+
+    weight : string or None  optional (default = 'weight')
+      Edge data key to use for edge weights. If None, weights set to 1.
+
+    Returns
+    -------
+    sb : float or dict
+       A single number if the keyword nodes is not specified, or
+       a dictionary keyed by node with the spectral bipartivity contribution
+       of that node as the value.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.path_graph(4)
+    >>> bipartite.spectral_bipartivity(G)
+    1.0
+
+    Notes
+    -----
+    This implementation uses Numpy (dense) matrices which are not efficient
+    for storing large sparse graphs.
+
+    See Also
+    --------
+    color
+
+    References
+    ----------
+    .. [1] E. Estrada and J. A. Rodríguez-Velázquez, "Spectral measures of
+       bipartivity in complex networks", PhysRev E 72, 046105 (2005)
+    """
+    import scipy as sp
+    import scipy.linalg  # call as sp.linalg
+
+    nodelist = list(G)  # ordering of nodes in matrix
+    A = nx.to_numpy_array(G, nodelist, weight=weight)
+    expA = sp.linalg.expm(A)
+    expmA = sp.linalg.expm(-A)
+    coshA = 0.5 * (expA + expmA)
+    if nodes is None:
+        # return single number for entire graph
+        return coshA.diagonal().sum() / expA.diagonal().sum()
+    else:
+        # contribution for individual nodes
+        index = dict(zip(nodelist, range(len(nodelist))))
+        sb = {}
+        for n in nodes:
+            i = index[n]
+            sb[n] = coshA[i, i] / expA[i, i]
+        return sb
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_basic.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_basic.py
new file mode 100644
index 0000000..655506b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_basic.py
@@ -0,0 +1,125 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms import bipartite
+
+
+class TestBipartiteBasic:
+    def test_is_bipartite(self):
+        assert bipartite.is_bipartite(nx.path_graph(4))
+        assert bipartite.is_bipartite(nx.DiGraph([(1, 0)]))
+        assert not bipartite.is_bipartite(nx.complete_graph(3))
+
+    def test_bipartite_color(self):
+        G = nx.path_graph(4)
+        c = bipartite.color(G)
+        assert c == {0: 1, 1: 0, 2: 1, 3: 0}
+
+    def test_not_bipartite_color(self):
+        with pytest.raises(nx.NetworkXError):
+            c = bipartite.color(nx.complete_graph(4))
+
+    def test_bipartite_directed(self):
+        G = bipartite.random_graph(10, 10, 0.1, directed=True)
+        assert bipartite.is_bipartite(G)
+
+    def test_bipartite_sets(self):
+        G = nx.path_graph(4)
+        X, Y = bipartite.sets(G)
+        assert X == {0, 2}
+        assert Y == {1, 3}
+
+    def test_bipartite_sets_directed(self):
+        G = nx.path_graph(4)
+        D = G.to_directed()
+        X, Y = bipartite.sets(D)
+        assert X == {0, 2}
+        assert Y == {1, 3}
+
+    def test_bipartite_sets_given_top_nodes(self):
+        G = nx.path_graph(4)
+        top_nodes = [0, 2]
+        X, Y = bipartite.sets(G, top_nodes)
+        assert X == {0, 2}
+        assert Y == {1, 3}
+
+    def test_bipartite_sets_disconnected(self):
+        with pytest.raises(nx.AmbiguousSolution):
+            G = nx.path_graph(4)
+            G.add_edges_from([(5, 6), (6, 7)])
+            X, Y = bipartite.sets(G)
+
+    def test_is_bipartite_node_set(self):
+        G = nx.path_graph(4)
+
+        with pytest.raises(nx.AmbiguousSolution):
+            bipartite.is_bipartite_node_set(G, [1, 1, 2, 3])
+
+        assert bipartite.is_bipartite_node_set(G, [0, 2])
+        assert bipartite.is_bipartite_node_set(G, [1, 3])
+        assert not bipartite.is_bipartite_node_set(G, [1, 2])
+        G.add_edge(10, 20)
+        assert bipartite.is_bipartite_node_set(G, [0, 2, 10])
+        assert bipartite.is_bipartite_node_set(G, [0, 2, 20])
+        assert bipartite.is_bipartite_node_set(G, [1, 3, 10])
+        assert bipartite.is_bipartite_node_set(G, [1, 3, 20])
+
+    def test_bipartite_density(self):
+        G = nx.path_graph(5)
+        X, Y = bipartite.sets(G)
+        density = len(list(G.edges())) / (len(X) * len(Y))
+        assert bipartite.density(G, X) == density
+        D = nx.DiGraph(G.edges())
+        assert bipartite.density(D, X) == density / 2.0
+        assert bipartite.density(nx.Graph(), {}) == 0.0
+
+    def test_bipartite_degrees(self):
+        G = nx.path_graph(5)
+        X = {1, 3}
+        Y = {0, 2, 4}
+        u, d = bipartite.degrees(G, Y)
+        assert dict(u) == {1: 2, 3: 2}
+        assert dict(d) == {0: 1, 2: 2, 4: 1}
+
+    def test_bipartite_weighted_degrees(self):
+        G = nx.path_graph(5)
+        G.add_edge(0, 1, weight=0.1, other=0.2)
+        X = {1, 3}
+        Y = {0, 2, 4}
+        u, d = bipartite.degrees(G, Y, weight="weight")
+        assert dict(u) == {1: 1.1, 3: 2}
+        assert dict(d) == {0: 0.1, 2: 2, 4: 1}
+        u, d = bipartite.degrees(G, Y, weight="other")
+        assert dict(u) == {1: 1.2, 3: 2}
+        assert dict(d) == {0: 0.2, 2: 2, 4: 1}
+
+    def test_biadjacency_matrix_weight(self):
+        pytest.importorskip("scipy")
+        G = nx.path_graph(5)
+        G.add_edge(0, 1, weight=2, other=4)
+        X = [1, 3]
+        Y = [0, 2, 4]
+        M = bipartite.biadjacency_matrix(G, X, weight="weight")
+        assert M[0, 0] == 2
+        M = bipartite.biadjacency_matrix(G, X, weight="other")
+        assert M[0, 0] == 4
+
+    def test_biadjacency_matrix(self):
+        pytest.importorskip("scipy")
+        tops = [2, 5, 10]
+        bots = [5, 10, 15]
+        for i in range(len(tops)):
+            G = bipartite.random_graph(tops[i], bots[i], 0.2)
+            top = [n for n, d in G.nodes(data=True) if d["bipartite"] == 0]
+            M = bipartite.biadjacency_matrix(G, top)
+            assert M.shape[0] == tops[i]
+            assert M.shape[1] == bots[i]
+
+    def test_biadjacency_matrix_order(self):
+        pytest.importorskip("scipy")
+        G = nx.path_graph(5)
+        G.add_edge(0, 1, weight=2)
+        X = [3, 1]
+        Y = [4, 2, 0]
+        M = bipartite.biadjacency_matrix(G, X, Y, weight="weight")
+        assert M[1, 2] == 2
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_centrality.py
new file mode 100644
index 0000000..50ac906
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_centrality.py
@@ -0,0 +1,176 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms import bipartite
+
+
+class TestBipartiteCentrality:
+    @classmethod
+    def setup_class(cls):
+        cls.P4 = nx.path_graph(4)
+        cls.K3 = nx.complete_bipartite_graph(3, 3)
+        cls.C4 = nx.cycle_graph(4)
+        cls.davis = nx.davis_southern_women_graph()
+        cls.top_nodes = [
+            n for n, d in cls.davis.nodes(data=True) if d["bipartite"] == 0
+        ]
+
+    def test_degree_centrality(self):
+        d = bipartite.degree_centrality(self.P4, [1, 3])
+        answer = {0: 0.5, 1: 1.0, 2: 1.0, 3: 0.5}
+        assert d == answer
+        d = bipartite.degree_centrality(self.K3, [0, 1, 2])
+        answer = {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0, 5: 1.0}
+        assert d == answer
+        d = bipartite.degree_centrality(self.C4, [0, 2])
+        answer = {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0}
+        assert d == answer
+
+    def test_betweenness_centrality(self):
+        c = bipartite.betweenness_centrality(self.P4, [1, 3])
+        answer = {0: 0.0, 1: 1.0, 2: 1.0, 3: 0.0}
+        assert c == answer
+        c = bipartite.betweenness_centrality(self.K3, [0, 1, 2])
+        answer = {0: 0.125, 1: 0.125, 2: 0.125, 3: 0.125, 4: 0.125, 5: 0.125}
+        assert c == answer
+        c = bipartite.betweenness_centrality(self.C4, [0, 2])
+        answer = {0: 0.25, 1: 0.25, 2: 0.25, 3: 0.25}
+        assert c == answer
+
+    def test_closeness_centrality(self):
+        c = bipartite.closeness_centrality(self.P4, [1, 3])
+        answer = {0: 2.0 / 3, 1: 1.0, 2: 1.0, 3: 2.0 / 3}
+        assert c == answer
+        c = bipartite.closeness_centrality(self.K3, [0, 1, 2])
+        answer = {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0, 5: 1.0}
+        assert c == answer
+        c = bipartite.closeness_centrality(self.C4, [0, 2])
+        answer = {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0}
+        assert c == answer
+        G = nx.Graph()
+        G.add_node(0)
+        G.add_node(1)
+        c = bipartite.closeness_centrality(G, [0])
+        assert c == {0: 0.0, 1: 0.0}
+        c = bipartite.closeness_centrality(G, [1])
+        assert c == {0: 0.0, 1: 0.0}
+
+    def test_davis_degree_centrality(self):
+        G = self.davis
+        deg = bipartite.degree_centrality(G, self.top_nodes)
+        answer = {
+            "E8": 0.78,
+            "E9": 0.67,
+            "E7": 0.56,
+            "Nora Fayette": 0.57,
+            "Evelyn Jefferson": 0.57,
+            "Theresa Anderson": 0.57,
+            "E6": 0.44,
+            "Sylvia Avondale": 0.50,
+            "Laura Mandeville": 0.50,
+            "Brenda Rogers": 0.50,
+            "Katherina Rogers": 0.43,
+            "E5": 0.44,
+            "Helen Lloyd": 0.36,
+            "E3": 0.33,
+            "Ruth DeSand": 0.29,
+            "Verne Sanderson": 0.29,
+            "E12": 0.33,
+            "Myra Liddel": 0.29,
+            "E11": 0.22,
+            "Eleanor Nye": 0.29,
+            "Frances Anderson": 0.29,
+            "Pearl Oglethorpe": 0.21,
+            "E4": 0.22,
+            "Charlotte McDowd": 0.29,
+            "E10": 0.28,
+            "Olivia Carleton": 0.14,
+            "Flora Price": 0.14,
+            "E2": 0.17,
+            "E1": 0.17,
+            "Dorothy Murchison": 0.14,
+            "E13": 0.17,
+            "E14": 0.17,
+        }
+        for node, value in answer.items():
+            assert value == pytest.approx(deg[node], abs=1e-2)
+
+    def test_davis_betweenness_centrality(self):
+        G = self.davis
+        bet = bipartite.betweenness_centrality(G, self.top_nodes)
+        answer = {
+            "E8": 0.24,
+            "E9": 0.23,
+            "E7": 0.13,
+            "Nora Fayette": 0.11,
+            "Evelyn Jefferson": 0.10,
+            "Theresa Anderson": 0.09,
+            "E6": 0.07,
+            "Sylvia Avondale": 0.07,
+            "Laura Mandeville": 0.05,
+            "Brenda Rogers": 0.05,
+            "Katherina Rogers": 0.05,
+            "E5": 0.04,
+            "Helen Lloyd": 0.04,
+            "E3": 0.02,
+            "Ruth DeSand": 0.02,
+            "Verne Sanderson": 0.02,
+            "E12": 0.02,
+            "Myra Liddel": 0.02,
+            "E11": 0.02,
+            "Eleanor Nye": 0.01,
+            "Frances Anderson": 0.01,
+            "Pearl Oglethorpe": 0.01,
+            "E4": 0.01,
+            "Charlotte McDowd": 0.01,
+            "E10": 0.01,
+            "Olivia Carleton": 0.01,
+            "Flora Price": 0.01,
+            "E2": 0.00,
+            "E1": 0.00,
+            "Dorothy Murchison": 0.00,
+            "E13": 0.00,
+            "E14": 0.00,
+        }
+        for node, value in answer.items():
+            assert value == pytest.approx(bet[node], abs=1e-2)
+
+    def test_davis_closeness_centrality(self):
+        G = self.davis
+        clos = bipartite.closeness_centrality(G, self.top_nodes)
+        answer = {
+            "E8": 0.85,
+            "E9": 0.79,
+            "E7": 0.73,
+            "Nora Fayette": 0.80,
+            "Evelyn Jefferson": 0.80,
+            "Theresa Anderson": 0.80,
+            "E6": 0.69,
+            "Sylvia Avondale": 0.77,
+            "Laura Mandeville": 0.73,
+            "Brenda Rogers": 0.73,
+            "Katherina Rogers": 0.73,
+            "E5": 0.59,
+            "Helen Lloyd": 0.73,
+            "E3": 0.56,
+            "Ruth DeSand": 0.71,
+            "Verne Sanderson": 0.71,
+            "E12": 0.56,
+            "Myra Liddel": 0.69,
+            "E11": 0.54,
+            "Eleanor Nye": 0.67,
+            "Frances Anderson": 0.67,
+            "Pearl Oglethorpe": 0.67,
+            "E4": 0.54,
+            "Charlotte McDowd": 0.60,
+            "E10": 0.55,
+            "Olivia Carleton": 0.59,
+            "Flora Price": 0.59,
+            "E2": 0.52,
+            "E1": 0.52,
+            "Dorothy Murchison": 0.65,
+            "E13": 0.52,
+            "E14": 0.52,
+        }
+        for node, value in answer.items():
+            assert value == pytest.approx(clos[node], abs=1e-2)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_cluster.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_cluster.py
new file mode 100644
index 0000000..e33e6c0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_cluster.py
@@ -0,0 +1,84 @@
+import pytest
+
+import networkx as nx
+import networkx.algorithms.bipartite as bipartite
+from networkx.algorithms.bipartite.cluster import cc_dot, cc_max, cc_min
+
+
+def test_pairwise_bipartite_cc_functions():
+    # Test functions for different kinds of bipartite clustering coefficients
+    # between pairs of nodes using 3 example graphs from figure 5 p. 40
+    # Latapy et al (2008)
+    G1 = nx.Graph([(0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (1, 5), (1, 6), (1, 7)])
+    G2 = nx.Graph([(0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (1, 5)])
+    G3 = nx.Graph(
+        [(0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9)]
+    )
+    result = {
+        0: [1 / 3.0, 2 / 3.0, 2 / 5.0],
+        1: [1 / 2.0, 2 / 3.0, 2 / 3.0],
+        2: [2 / 8.0, 2 / 5.0, 2 / 5.0],
+    }
+    for i, G in enumerate([G1, G2, G3]):
+        assert bipartite.is_bipartite(G)
+        assert cc_dot(set(G[0]), set(G[1])) == result[i][0]
+        assert cc_min(set(G[0]), set(G[1])) == result[i][1]
+        assert cc_max(set(G[0]), set(G[1])) == result[i][2]
+
+
+def test_star_graph():
+    G = nx.star_graph(3)
+    # all modes are the same
+    answer = {0: 0, 1: 1, 2: 1, 3: 1}
+    assert bipartite.clustering(G, mode="dot") == answer
+    assert bipartite.clustering(G, mode="min") == answer
+    assert bipartite.clustering(G, mode="max") == answer
+
+
+def test_not_bipartite():
+    with pytest.raises(nx.NetworkXError):
+        bipartite.clustering(nx.complete_graph(4))
+
+
+def test_bad_mode():
+    with pytest.raises(nx.NetworkXError):
+        bipartite.clustering(nx.path_graph(4), mode="foo")
+
+
+def test_path_graph():
+    G = nx.path_graph(4)
+    answer = {0: 0.5, 1: 0.5, 2: 0.5, 3: 0.5}
+    assert bipartite.clustering(G, mode="dot") == answer
+    assert bipartite.clustering(G, mode="max") == answer
+    answer = {0: 1, 1: 1, 2: 1, 3: 1}
+    assert bipartite.clustering(G, mode="min") == answer
+
+
+def test_average_path_graph():
+    G = nx.path_graph(4)
+    assert bipartite.average_clustering(G, mode="dot") == 0.5
+    assert bipartite.average_clustering(G, mode="max") == 0.5
+    assert bipartite.average_clustering(G, mode="min") == 1
+
+
+def test_ra_clustering_davis():
+    G = nx.davis_southern_women_graph()
+    cc4 = round(bipartite.robins_alexander_clustering(G), 3)
+    assert cc4 == 0.468
+
+
+def test_ra_clustering_square():
+    G = nx.path_graph(4)
+    G.add_edge(0, 3)
+    assert bipartite.robins_alexander_clustering(G) == 1.0
+
+
+def test_ra_clustering_zero():
+    G = nx.Graph()
+    assert bipartite.robins_alexander_clustering(G) == 0
+    G.add_nodes_from(range(4))
+    assert bipartite.robins_alexander_clustering(G) == 0
+    G.add_edges_from([(0, 1), (2, 3), (3, 4)])
+    assert bipartite.robins_alexander_clustering(G) == 0
+    G.add_edge(1, 2)
+    assert bipartite.robins_alexander_clustering(G) == 0
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_covering.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_covering.py
new file mode 100644
index 0000000..2f1b02e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_covering.py
@@ -0,0 +1,33 @@
+import networkx as nx
+import networkx.algorithms.bipartite as bipartite
+
+
+class TestMinEdgeCover:
+    """Tests for :func:`networkx.algorithms.bipartite.min_edge_cover`"""
+
+    def test_empty_graph(self):
+        G = nx.Graph()
+        assert bipartite.min_edge_cover(G) == set()
+
+    def test_graph_single_edge(self):
+        G = nx.Graph()
+        G.add_edge(0, 1)
+        assert bipartite.min_edge_cover(G) == {(0, 1), (1, 0)}
+
+    def test_bipartite_default(self):
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3, 4], bipartite=0)
+        G.add_nodes_from(["a", "b", "c"], bipartite=1)
+        G.add_edges_from([(1, "a"), (1, "b"), (2, "b"), (2, "c"), (3, "c"), (4, "a")])
+        min_cover = bipartite.min_edge_cover(G)
+        assert nx.is_edge_cover(G, min_cover)
+        assert len(min_cover) == 8
+
+    def test_bipartite_explicit(self):
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3, 4], bipartite=0)
+        G.add_nodes_from(["a", "b", "c"], bipartite=1)
+        G.add_edges_from([(1, "a"), (1, "b"), (2, "b"), (2, "c"), (3, "c"), (4, "a")])
+        min_cover = bipartite.min_edge_cover(G, bipartite.eppstein_matching)
+        assert nx.is_edge_cover(G, min_cover)
+        assert len(min_cover) == 8
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_edgelist.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_edgelist.py
new file mode 100644
index 0000000..9cf0c43
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_edgelist.py
@@ -0,0 +1,192 @@
+"""
+    Unit tests for bipartite edgelists.
+"""
+import io
+import os
+import tempfile
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms import bipartite
+from networkx.utils import edges_equal, graphs_equal, nodes_equal
+
+
+class TestEdgelist:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.Graph(name="test")
+        e = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("a", "f")]
+        cls.G.add_edges_from(e)
+        cls.G.add_nodes_from(["a", "c", "e"], bipartite=0)
+        cls.G.add_nodes_from(["b", "d", "f"], bipartite=1)
+        cls.G.add_node("g", bipartite=0)
+        cls.DG = nx.DiGraph(cls.G)
+        cls.MG = nx.MultiGraph()
+        cls.MG.add_edges_from([(1, 2), (1, 2), (1, 2)])
+        cls.MG.add_node(1, bipartite=0)
+        cls.MG.add_node(2, bipartite=1)
+
+    def test_read_edgelist_1(self):
+        s = b"""\
+# comment line
+1 2
+# comment line
+2 3
+"""
+        bytesIO = io.BytesIO(s)
+        G = bipartite.read_edgelist(bytesIO, nodetype=int)
+        assert edges_equal(G.edges(), [(1, 2), (2, 3)])
+
+    def test_read_edgelist_3(self):
+        s = b"""\
+# comment line
+1 2 {'weight':2.0}
+# comment line
+2 3 {'weight':3.0}
+"""
+        bytesIO = io.BytesIO(s)
+        G = bipartite.read_edgelist(bytesIO, nodetype=int, data=False)
+        assert edges_equal(G.edges(), [(1, 2), (2, 3)])
+
+        bytesIO = io.BytesIO(s)
+        G = bipartite.read_edgelist(bytesIO, nodetype=int, data=True)
+        assert edges_equal(
+            G.edges(data=True), [(1, 2, {"weight": 2.0}), (2, 3, {"weight": 3.0})]
+        )
+
+    def test_write_edgelist_1(self):
+        fh = io.BytesIO()
+        G = nx.Graph()
+        G.add_edges_from([(1, 2), (2, 3)])
+        G.add_node(1, bipartite=0)
+        G.add_node(2, bipartite=1)
+        G.add_node(3, bipartite=0)
+        bipartite.write_edgelist(G, fh, data=False)
+        fh.seek(0)
+        assert fh.read() == b"1 2\n3 2\n"
+
+    def test_write_edgelist_2(self):
+        fh = io.BytesIO()
+        G = nx.Graph()
+        G.add_edges_from([(1, 2), (2, 3)])
+        G.add_node(1, bipartite=0)
+        G.add_node(2, bipartite=1)
+        G.add_node(3, bipartite=0)
+        bipartite.write_edgelist(G, fh, data=True)
+        fh.seek(0)
+        assert fh.read() == b"1 2 {}\n3 2 {}\n"
+
+    def test_write_edgelist_3(self):
+        fh = io.BytesIO()
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=2.0)
+        G.add_edge(2, 3, weight=3.0)
+        G.add_node(1, bipartite=0)
+        G.add_node(2, bipartite=1)
+        G.add_node(3, bipartite=0)
+        bipartite.write_edgelist(G, fh, data=True)
+        fh.seek(0)
+        assert fh.read() == b"1 2 {'weight': 2.0}\n3 2 {'weight': 3.0}\n"
+
+    def test_write_edgelist_4(self):
+        fh = io.BytesIO()
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=2.0)
+        G.add_edge(2, 3, weight=3.0)
+        G.add_node(1, bipartite=0)
+        G.add_node(2, bipartite=1)
+        G.add_node(3, bipartite=0)
+        bipartite.write_edgelist(G, fh, data=[("weight")])
+        fh.seek(0)
+        assert fh.read() == b"1 2 2.0\n3 2 3.0\n"
+
+    def test_unicode(self):
+        G = nx.Graph()
+        name1 = chr(2344) + chr(123) + chr(6543)
+        name2 = chr(5543) + chr(1543) + chr(324)
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        G.add_node(name1, bipartite=0)
+        G.add_node("Radiohead", bipartite=1)
+        fd, fname = tempfile.mkstemp()
+        bipartite.write_edgelist(G, fname)
+        H = bipartite.read_edgelist(fname)
+        assert graphs_equal(G, H)
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_latin1_issue(self):
+        G = nx.Graph()
+        name1 = chr(2344) + chr(123) + chr(6543)
+        name2 = chr(5543) + chr(1543) + chr(324)
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        G.add_node(name1, bipartite=0)
+        G.add_node("Radiohead", bipartite=1)
+        fd, fname = tempfile.mkstemp()
+        pytest.raises(
+            UnicodeEncodeError, bipartite.write_edgelist, G, fname, encoding="latin-1"
+        )
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_latin1(self):
+        G = nx.Graph()
+        name1 = "Bj" + chr(246) + "rk"
+        name2 = chr(220) + "ber"
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        G.add_node(name1, bipartite=0)
+        G.add_node("Radiohead", bipartite=1)
+        fd, fname = tempfile.mkstemp()
+        bipartite.write_edgelist(G, fname, encoding="latin-1")
+        H = bipartite.read_edgelist(fname, encoding="latin-1")
+        assert graphs_equal(G, H)
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_edgelist_graph(self):
+        G = self.G
+        (fd, fname) = tempfile.mkstemp()
+        bipartite.write_edgelist(G, fname)
+        H = bipartite.read_edgelist(fname)
+        H2 = bipartite.read_edgelist(fname)
+        assert H is not H2  # they should be different graphs
+        G.remove_node("g")  # isolated nodes are not written in edgelist
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_edgelist_integers(self):
+        G = nx.convert_node_labels_to_integers(self.G)
+        (fd, fname) = tempfile.mkstemp()
+        bipartite.write_edgelist(G, fname)
+        H = bipartite.read_edgelist(fname, nodetype=int)
+        # isolated nodes are not written in edgelist
+        G.remove_nodes_from(list(nx.isolates(G)))
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_edgelist_multigraph(self):
+        G = self.MG
+        (fd, fname) = tempfile.mkstemp()
+        bipartite.write_edgelist(G, fname)
+        H = bipartite.read_edgelist(fname, nodetype=int, create_using=nx.MultiGraph())
+        H2 = bipartite.read_edgelist(fname, nodetype=int, create_using=nx.MultiGraph())
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_empty_digraph(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            bytesIO = io.BytesIO()
+            bipartite.write_edgelist(nx.DiGraph(), bytesIO)
+
+    def test_raise_attribute(self):
+        with pytest.raises(AttributeError):
+            G = nx.path_graph(4)
+            bytesIO = io.BytesIO()
+            bipartite.write_edgelist(G, bytesIO)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_generators.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_generators.py
new file mode 100644
index 0000000..5f3b84c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_generators.py
@@ -0,0 +1,400 @@
+import numbers
+
+import pytest
+
+import networkx as nx
+
+from ..generators import (
+    alternating_havel_hakimi_graph,
+    complete_bipartite_graph,
+    configuration_model,
+    gnmk_random_graph,
+    havel_hakimi_graph,
+    preferential_attachment_graph,
+    random_graph,
+    reverse_havel_hakimi_graph,
+)
+
+"""
+Generators - Bipartite
+----------------------
+"""
+
+
+class TestGeneratorsBipartite:
+    def test_complete_bipartite_graph(self):
+        G = complete_bipartite_graph(0, 0)
+        assert nx.is_isomorphic(G, nx.null_graph())
+
+        for i in [1, 5]:
+            G = complete_bipartite_graph(i, 0)
+            assert nx.is_isomorphic(G, nx.empty_graph(i))
+            G = complete_bipartite_graph(0, i)
+            assert nx.is_isomorphic(G, nx.empty_graph(i))
+
+        G = complete_bipartite_graph(2, 2)
+        assert nx.is_isomorphic(G, nx.cycle_graph(4))
+
+        G = complete_bipartite_graph(1, 5)
+        assert nx.is_isomorphic(G, nx.star_graph(5))
+
+        G = complete_bipartite_graph(5, 1)
+        assert nx.is_isomorphic(G, nx.star_graph(5))
+
+        # complete_bipartite_graph(m1,m2) is a connected graph with
+        # m1+m2 nodes and  m1*m2 edges
+        for m1, m2 in [(5, 11), (7, 3)]:
+            G = complete_bipartite_graph(m1, m2)
+            assert nx.number_of_nodes(G) == m1 + m2
+            assert nx.number_of_edges(G) == m1 * m2
+
+        with pytest.raises(nx.NetworkXError):
+            complete_bipartite_graph(7, 3, create_using=nx.DiGraph)
+        with pytest.raises(nx.NetworkXError):
+            complete_bipartite_graph(7, 3, create_using=nx.MultiDiGraph)
+
+        mG = complete_bipartite_graph(7, 3, create_using=nx.MultiGraph)
+        assert mG.is_multigraph()
+        assert sorted(mG.edges()) == sorted(G.edges())
+
+        mG = complete_bipartite_graph(7, 3, create_using=nx.MultiGraph)
+        assert mG.is_multigraph()
+        assert sorted(mG.edges()) == sorted(G.edges())
+
+        mG = complete_bipartite_graph(7, 3)  # default to Graph
+        assert sorted(mG.edges()) == sorted(G.edges())
+        assert not mG.is_multigraph()
+        assert not mG.is_directed()
+
+        # specify nodes rather than number of nodes
+        for n1, n2 in [([1, 2], "ab"), (3, 2), (3, "ab"), ("ab", 3)]:
+            G = complete_bipartite_graph(n1, n2)
+            if isinstance(n1, numbers.Integral):
+                if isinstance(n2, numbers.Integral):
+                    n2 = range(n1, n1 + n2)
+                n1 = range(n1)
+            elif isinstance(n2, numbers.Integral):
+                n2 = range(n2)
+            edges = {(u, v) for u in n1 for v in n2}
+            assert edges == set(G.edges)
+            assert G.size() == len(edges)
+
+        # raise when node sets are not distinct
+        for n1, n2 in [([1, 2], 3), (3, [1, 2]), ("abc", "bcd")]:
+            pytest.raises(nx.NetworkXError, complete_bipartite_graph, n1, n2)
+
+    def test_configuration_model(self):
+        aseq = []
+        bseq = []
+        G = configuration_model(aseq, bseq)
+        assert len(G) == 0
+
+        aseq = [0, 0]
+        bseq = [0, 0]
+        G = configuration_model(aseq, bseq)
+        assert len(G) == 4
+        assert G.number_of_edges() == 0
+
+        aseq = [3, 3, 3, 3]
+        bseq = [2, 2, 2, 2, 2]
+        pytest.raises(nx.NetworkXError, configuration_model, aseq, bseq)
+
+        aseq = [3, 3, 3, 3]
+        bseq = [2, 2, 2, 2, 2, 2]
+        G = configuration_model(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 2, 2, 2]
+        bseq = [3, 3, 3, 3]
+        G = configuration_model(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 1, 1, 1]
+        bseq = [3, 3, 3]
+        G = configuration_model(aseq, bseq)
+        assert G.is_multigraph()
+        assert not G.is_directed()
+        assert sorted(d for n, d in G.degree()) == [1, 1, 1, 2, 2, 2, 3, 3, 3]
+
+        GU = nx.projected_graph(nx.Graph(G), range(len(aseq)))
+        assert GU.number_of_nodes() == 6
+
+        GD = nx.projected_graph(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
+        assert GD.number_of_nodes() == 3
+
+        G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
+        assert not G.is_multigraph()
+        assert not G.is_directed()
+
+        pytest.raises(
+            nx.NetworkXError, configuration_model, aseq, bseq, create_using=nx.DiGraph()
+        )
+        pytest.raises(
+            nx.NetworkXError, configuration_model, aseq, bseq, create_using=nx.DiGraph
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            configuration_model,
+            aseq,
+            bseq,
+            create_using=nx.MultiDiGraph,
+        )
+
+    def test_havel_hakimi_graph(self):
+        aseq = []
+        bseq = []
+        G = havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 0
+
+        aseq = [0, 0]
+        bseq = [0, 0]
+        G = havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 4
+        assert G.number_of_edges() == 0
+
+        aseq = [3, 3, 3, 3]
+        bseq = [2, 2, 2, 2, 2]
+        pytest.raises(nx.NetworkXError, havel_hakimi_graph, aseq, bseq)
+
+        bseq = [2, 2, 2, 2, 2, 2]
+        G = havel_hakimi_graph(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 2, 2, 2]
+        bseq = [3, 3, 3, 3]
+        G = havel_hakimi_graph(aseq, bseq)
+        assert G.is_multigraph()
+        assert not G.is_directed()
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        GU = nx.projected_graph(nx.Graph(G), range(len(aseq)))
+        assert GU.number_of_nodes() == 6
+
+        GD = nx.projected_graph(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
+        assert GD.number_of_nodes() == 4
+
+        G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
+        assert not G.is_multigraph()
+        assert not G.is_directed()
+
+        pytest.raises(
+            nx.NetworkXError, havel_hakimi_graph, aseq, bseq, create_using=nx.DiGraph
+        )
+        pytest.raises(
+            nx.NetworkXError, havel_hakimi_graph, aseq, bseq, create_using=nx.DiGraph
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.MultiDiGraph,
+        )
+
+    def test_reverse_havel_hakimi_graph(self):
+        aseq = []
+        bseq = []
+        G = reverse_havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 0
+
+        aseq = [0, 0]
+        bseq = [0, 0]
+        G = reverse_havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 4
+        assert G.number_of_edges() == 0
+
+        aseq = [3, 3, 3, 3]
+        bseq = [2, 2, 2, 2, 2]
+        pytest.raises(nx.NetworkXError, reverse_havel_hakimi_graph, aseq, bseq)
+
+        bseq = [2, 2, 2, 2, 2, 2]
+        G = reverse_havel_hakimi_graph(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 2, 2, 2]
+        bseq = [3, 3, 3, 3]
+        G = reverse_havel_hakimi_graph(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 1, 1, 1]
+        bseq = [3, 3, 3]
+        G = reverse_havel_hakimi_graph(aseq, bseq)
+        assert G.is_multigraph()
+        assert not G.is_directed()
+        assert sorted(d for n, d in G.degree()) == [1, 1, 1, 2, 2, 2, 3, 3, 3]
+
+        GU = nx.projected_graph(nx.Graph(G), range(len(aseq)))
+        assert GU.number_of_nodes() == 6
+
+        GD = nx.projected_graph(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
+        assert GD.number_of_nodes() == 3
+
+        G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
+        assert not G.is_multigraph()
+        assert not G.is_directed()
+
+        pytest.raises(
+            nx.NetworkXError,
+            reverse_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.DiGraph,
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            reverse_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.DiGraph,
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            reverse_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.MultiDiGraph,
+        )
+
+    def test_alternating_havel_hakimi_graph(self):
+        aseq = []
+        bseq = []
+        G = alternating_havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 0
+
+        aseq = [0, 0]
+        bseq = [0, 0]
+        G = alternating_havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 4
+        assert G.number_of_edges() == 0
+
+        aseq = [3, 3, 3, 3]
+        bseq = [2, 2, 2, 2, 2]
+        pytest.raises(nx.NetworkXError, alternating_havel_hakimi_graph, aseq, bseq)
+
+        bseq = [2, 2, 2, 2, 2, 2]
+        G = alternating_havel_hakimi_graph(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 2, 2, 2]
+        bseq = [3, 3, 3, 3]
+        G = alternating_havel_hakimi_graph(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 1, 1, 1]
+        bseq = [3, 3, 3]
+        G = alternating_havel_hakimi_graph(aseq, bseq)
+        assert G.is_multigraph()
+        assert not G.is_directed()
+        assert sorted(d for n, d in G.degree()) == [1, 1, 1, 2, 2, 2, 3, 3, 3]
+
+        GU = nx.projected_graph(nx.Graph(G), range(len(aseq)))
+        assert GU.number_of_nodes() == 6
+
+        GD = nx.projected_graph(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
+        assert GD.number_of_nodes() == 3
+
+        G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
+        assert not G.is_multigraph()
+        assert not G.is_directed()
+
+        pytest.raises(
+            nx.NetworkXError,
+            alternating_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.DiGraph,
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            alternating_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.DiGraph,
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            alternating_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.MultiDiGraph,
+        )
+
+    def test_preferential_attachment(self):
+        aseq = [3, 2, 1, 1]
+        G = preferential_attachment_graph(aseq, 0.5)
+        assert G.is_multigraph()
+        assert not G.is_directed()
+
+        G = preferential_attachment_graph(aseq, 0.5, create_using=nx.Graph)
+        assert not G.is_multigraph()
+        assert not G.is_directed()
+
+        pytest.raises(
+            nx.NetworkXError,
+            preferential_attachment_graph,
+            aseq,
+            0.5,
+            create_using=nx.DiGraph(),
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            preferential_attachment_graph,
+            aseq,
+            0.5,
+            create_using=nx.DiGraph(),
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            preferential_attachment_graph,
+            aseq,
+            0.5,
+            create_using=nx.DiGraph(),
+        )
+
+    def test_random_graph(self):
+        n = 10
+        m = 20
+        G = random_graph(n, m, 0.9)
+        assert len(G) == 30
+        assert nx.is_bipartite(G)
+        X, Y = nx.algorithms.bipartite.sets(G)
+        assert set(range(n)) == X
+        assert set(range(n, n + m)) == Y
+
+    def test_random_digraph(self):
+        n = 10
+        m = 20
+        G = random_graph(n, m, 0.9, directed=True)
+        assert len(G) == 30
+        assert nx.is_bipartite(G)
+        X, Y = nx.algorithms.bipartite.sets(G)
+        assert set(range(n)) == X
+        assert set(range(n, n + m)) == Y
+
+    def test_gnmk_random_graph(self):
+        n = 10
+        m = 20
+        edges = 100
+        # set seed because sometimes it is not connected
+        # which raises an error in bipartite.sets(G) below.
+        G = gnmk_random_graph(n, m, edges, seed=1234)
+        assert len(G) == n + m
+        assert nx.is_bipartite(G)
+        X, Y = nx.algorithms.bipartite.sets(G)
+        # print(X)
+        assert set(range(n)) == X
+        assert set(range(n, n + m)) == Y
+        assert edges == len(list(G.edges()))
+
+    def test_gnmk_random_graph_complete(self):
+        n = 10
+        m = 20
+        edges = 200
+        G = gnmk_random_graph(n, m, edges)
+        assert len(G) == n + m
+        assert nx.is_bipartite(G)
+        X, Y = nx.algorithms.bipartite.sets(G)
+        # print(X)
+        assert set(range(n)) == X
+        assert set(range(n, n + m)) == Y
+        assert edges == len(list(G.edges()))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_matching.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_matching.py
new file mode 100644
index 0000000..116da84
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_matching.py
@@ -0,0 +1,326 @@
+"""Unit tests for the :mod:`networkx.algorithms.bipartite.matching` module."""
+import itertools
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.bipartite.matching import (
+    eppstein_matching,
+    hopcroft_karp_matching,
+    maximum_matching,
+    minimum_weight_full_matching,
+    to_vertex_cover,
+)
+
+
+class TestMatching:
+    """Tests for bipartite matching algorithms."""
+
+    def setup(self):
+        """Creates a bipartite graph for use in testing matching algorithms.
+
+        The bipartite graph has a maximum cardinality matching that leaves
+        vertex 1 and vertex 10 unmatched. The first six numbers are the left
+        vertices and the next six numbers are the right vertices.
+
+        """
+        self.simple_graph = nx.complete_bipartite_graph(2, 3)
+        self.simple_solution = {0: 2, 1: 3, 2: 0, 3: 1}
+
+        edges = [(0, 7), (0, 8), (2, 6), (2, 9), (3, 8), (4, 8), (4, 9), (5, 11)]
+        self.top_nodes = set(range(6))
+        self.graph = nx.Graph()
+        self.graph.add_nodes_from(range(12))
+        self.graph.add_edges_from(edges)
+
+        # Example bipartite graph from issue 2127
+        G = nx.Graph()
+        G.add_nodes_from(
+            [
+                (1, "C"),
+                (1, "B"),
+                (0, "G"),
+                (1, "F"),
+                (1, "E"),
+                (0, "C"),
+                (1, "D"),
+                (1, "I"),
+                (0, "A"),
+                (0, "D"),
+                (0, "F"),
+                (0, "E"),
+                (0, "H"),
+                (1, "G"),
+                (1, "A"),
+                (0, "I"),
+                (0, "B"),
+                (1, "H"),
+            ]
+        )
+        G.add_edge((1, "C"), (0, "A"))
+        G.add_edge((1, "B"), (0, "A"))
+        G.add_edge((0, "G"), (1, "I"))
+        G.add_edge((0, "G"), (1, "H"))
+        G.add_edge((1, "F"), (0, "A"))
+        G.add_edge((1, "F"), (0, "C"))
+        G.add_edge((1, "F"), (0, "E"))
+        G.add_edge((1, "E"), (0, "A"))
+        G.add_edge((1, "E"), (0, "C"))
+        G.add_edge((0, "C"), (1, "D"))
+        G.add_edge((0, "C"), (1, "I"))
+        G.add_edge((0, "C"), (1, "G"))
+        G.add_edge((0, "C"), (1, "H"))
+        G.add_edge((1, "D"), (0, "A"))
+        G.add_edge((1, "I"), (0, "A"))
+        G.add_edge((1, "I"), (0, "E"))
+        G.add_edge((0, "A"), (1, "G"))
+        G.add_edge((0, "A"), (1, "H"))
+        G.add_edge((0, "E"), (1, "G"))
+        G.add_edge((0, "E"), (1, "H"))
+        self.disconnected_graph = G
+
+    def check_match(self, matching):
+        """Asserts that the matching is what we expect from the bipartite graph
+        constructed in the :meth:`setup` fixture.
+
+        """
+        # For the sake of brevity, rename `matching` to `M`.
+        M = matching
+        matched_vertices = frozenset(itertools.chain(*M.items()))
+        # Assert that the maximum number of vertices (10) is matched.
+        assert matched_vertices == frozenset(range(12)) - {1, 10}
+        # Assert that no vertex appears in two edges, or in other words, that
+        # the matching (u, v) and (v, u) both appear in the matching
+        # dictionary.
+        assert all(u == M[M[u]] for u in range(12) if u in M)
+
+    def check_vertex_cover(self, vertices):
+        """Asserts that the given set of vertices is the vertex cover we
+        expected from the bipartite graph constructed in the :meth:`setup`
+        fixture.
+
+        """
+        # By Konig's theorem, the number of edges in a maximum matching equals
+        # the number of vertices in a minimum vertex cover.
+        assert len(vertices) == 5
+        # Assert that the set is truly a vertex cover.
+        for (u, v) in self.graph.edges():
+            assert u in vertices or v in vertices
+        # TODO Assert that the vertices are the correct ones.
+
+    def test_eppstein_matching(self):
+        """Tests that David Eppstein's implementation of the Hopcroft--Karp
+        algorithm produces a maximum cardinality matching.
+
+        """
+        self.check_match(eppstein_matching(self.graph, self.top_nodes))
+
+    def test_hopcroft_karp_matching(self):
+        """Tests that the Hopcroft--Karp algorithm produces a maximum
+        cardinality matching in a bipartite graph.
+
+        """
+        self.check_match(hopcroft_karp_matching(self.graph, self.top_nodes))
+
+    def test_to_vertex_cover(self):
+        """Test for converting a maximum matching to a minimum vertex cover."""
+        matching = maximum_matching(self.graph, self.top_nodes)
+        vertex_cover = to_vertex_cover(self.graph, matching, self.top_nodes)
+        self.check_vertex_cover(vertex_cover)
+
+    def test_eppstein_matching_simple(self):
+        match = eppstein_matching(self.simple_graph)
+        assert match == self.simple_solution
+
+    def test_hopcroft_karp_matching_simple(self):
+        match = hopcroft_karp_matching(self.simple_graph)
+        assert match == self.simple_solution
+
+    def test_eppstein_matching_disconnected(self):
+        with pytest.raises(nx.AmbiguousSolution):
+            match = eppstein_matching(self.disconnected_graph)
+
+    def test_hopcroft_karp_matching_disconnected(self):
+        with pytest.raises(nx.AmbiguousSolution):
+            match = hopcroft_karp_matching(self.disconnected_graph)
+
+    def test_issue_2127(self):
+        """Test from issue 2127"""
+        # Build the example DAG
+        G = nx.DiGraph()
+        G.add_edge("A", "C")
+        G.add_edge("A", "B")
+        G.add_edge("C", "E")
+        G.add_edge("C", "D")
+        G.add_edge("E", "G")
+        G.add_edge("E", "F")
+        G.add_edge("G", "I")
+        G.add_edge("G", "H")
+
+        tc = nx.transitive_closure(G)
+        btc = nx.Graph()
+
+        # Create a bipartite graph based on the transitive closure of G
+        for v in tc.nodes():
+            btc.add_node((0, v))
+            btc.add_node((1, v))
+
+        for u, v in tc.edges():
+            btc.add_edge((0, u), (1, v))
+
+        top_nodes = {n for n in btc if n[0] == 0}
+        matching = hopcroft_karp_matching(btc, top_nodes)
+        vertex_cover = to_vertex_cover(btc, matching, top_nodes)
+        independent_set = set(G) - {v for _, v in vertex_cover}
+        assert {"B", "D", "F", "I", "H"} == independent_set
+
+    def test_vertex_cover_issue_2384(self):
+        G = nx.Graph([(0, 3), (1, 3), (1, 4), (2, 3)])
+        matching = maximum_matching(G)
+        vertex_cover = to_vertex_cover(G, matching)
+        for u, v in G.edges():
+            assert u in vertex_cover or v in vertex_cover
+
+    def test_vertex_cover_issue_3306(self):
+        G = nx.Graph()
+        edges = [(0, 2), (1, 0), (1, 1), (1, 2), (2, 2)]
+        G.add_edges_from([((i, "L"), (j, "R")) for i, j in edges])
+
+        matching = maximum_matching(G)
+        vertex_cover = to_vertex_cover(G, matching)
+        for u, v in G.edges():
+            assert u in vertex_cover or v in vertex_cover
+
+    def test_unorderable_nodes(self):
+        a = object()
+        b = object()
+        c = object()
+        d = object()
+        e = object()
+        G = nx.Graph([(a, d), (b, d), (b, e), (c, d)])
+        matching = maximum_matching(G)
+        vertex_cover = to_vertex_cover(G, matching)
+        for u, v in G.edges():
+            assert u in vertex_cover or v in vertex_cover
+
+
+def test_eppstein_matching():
+    """Test in accordance to issue #1927"""
+    G = nx.Graph()
+    G.add_nodes_from(["a", 2, 3, 4], bipartite=0)
+    G.add_nodes_from([1, "b", "c"], bipartite=1)
+    G.add_edges_from([("a", 1), ("a", "b"), (2, "b"), (2, "c"), (3, "c"), (4, 1)])
+    matching = eppstein_matching(G)
+    assert len(matching) == len(maximum_matching(G))
+    assert all(x in set(matching.keys()) for x in set(matching.values()))
+
+
+class TestMinimumWeightFullMatching:
+    @classmethod
+    def setup_class(cls):
+        pytest.importorskip("scipy")
+
+    def test_minimum_weight_full_matching_incomplete_graph(self):
+        B = nx.Graph()
+        B.add_nodes_from([1, 2], bipartite=0)
+        B.add_nodes_from([3, 4], bipartite=1)
+        B.add_edge(1, 4, weight=100)
+        B.add_edge(2, 3, weight=100)
+        B.add_edge(2, 4, weight=50)
+        matching = minimum_weight_full_matching(B)
+        assert matching == {1: 4, 2: 3, 4: 1, 3: 2}
+
+    def test_minimum_weight_full_matching_with_no_full_matching(self):
+        B = nx.Graph()
+        B.add_nodes_from([1, 2, 3], bipartite=0)
+        B.add_nodes_from([4, 5, 6], bipartite=1)
+        B.add_edge(1, 4, weight=100)
+        B.add_edge(2, 4, weight=100)
+        B.add_edge(3, 4, weight=50)
+        B.add_edge(3, 5, weight=50)
+        B.add_edge(3, 6, weight=50)
+        with pytest.raises(ValueError):
+            minimum_weight_full_matching(B)
+
+    def test_minimum_weight_full_matching_square(self):
+        G = nx.complete_bipartite_graph(3, 3)
+        G.add_edge(0, 3, weight=400)
+        G.add_edge(0, 4, weight=150)
+        G.add_edge(0, 5, weight=400)
+        G.add_edge(1, 3, weight=400)
+        G.add_edge(1, 4, weight=450)
+        G.add_edge(1, 5, weight=600)
+        G.add_edge(2, 3, weight=300)
+        G.add_edge(2, 4, weight=225)
+        G.add_edge(2, 5, weight=300)
+        matching = minimum_weight_full_matching(G)
+        assert matching == {0: 4, 1: 3, 2: 5, 4: 0, 3: 1, 5: 2}
+
+    def test_minimum_weight_full_matching_smaller_left(self):
+        G = nx.complete_bipartite_graph(3, 4)
+        G.add_edge(0, 3, weight=400)
+        G.add_edge(0, 4, weight=150)
+        G.add_edge(0, 5, weight=400)
+        G.add_edge(0, 6, weight=1)
+        G.add_edge(1, 3, weight=400)
+        G.add_edge(1, 4, weight=450)
+        G.add_edge(1, 5, weight=600)
+        G.add_edge(1, 6, weight=2)
+        G.add_edge(2, 3, weight=300)
+        G.add_edge(2, 4, weight=225)
+        G.add_edge(2, 5, weight=290)
+        G.add_edge(2, 6, weight=3)
+        matching = minimum_weight_full_matching(G)
+        assert matching == {0: 4, 1: 6, 2: 5, 4: 0, 5: 2, 6: 1}
+
+    def test_minimum_weight_full_matching_smaller_top_nodes_right(self):
+        G = nx.complete_bipartite_graph(3, 4)
+        G.add_edge(0, 3, weight=400)
+        G.add_edge(0, 4, weight=150)
+        G.add_edge(0, 5, weight=400)
+        G.add_edge(0, 6, weight=1)
+        G.add_edge(1, 3, weight=400)
+        G.add_edge(1, 4, weight=450)
+        G.add_edge(1, 5, weight=600)
+        G.add_edge(1, 6, weight=2)
+        G.add_edge(2, 3, weight=300)
+        G.add_edge(2, 4, weight=225)
+        G.add_edge(2, 5, weight=290)
+        G.add_edge(2, 6, weight=3)
+        matching = minimum_weight_full_matching(G, top_nodes=[3, 4, 5, 6])
+        assert matching == {0: 4, 1: 6, 2: 5, 4: 0, 5: 2, 6: 1}
+
+    def test_minimum_weight_full_matching_smaller_right(self):
+        G = nx.complete_bipartite_graph(4, 3)
+        G.add_edge(0, 4, weight=400)
+        G.add_edge(0, 5, weight=400)
+        G.add_edge(0, 6, weight=300)
+        G.add_edge(1, 4, weight=150)
+        G.add_edge(1, 5, weight=450)
+        G.add_edge(1, 6, weight=225)
+        G.add_edge(2, 4, weight=400)
+        G.add_edge(2, 5, weight=600)
+        G.add_edge(2, 6, weight=290)
+        G.add_edge(3, 4, weight=1)
+        G.add_edge(3, 5, weight=2)
+        G.add_edge(3, 6, weight=3)
+        matching = minimum_weight_full_matching(G)
+        assert matching == {1: 4, 2: 6, 3: 5, 4: 1, 5: 3, 6: 2}
+
+    def test_minimum_weight_full_matching_negative_weights(self):
+        G = nx.complete_bipartite_graph(2, 2)
+        G.add_edge(0, 2, weight=-2)
+        G.add_edge(0, 3, weight=0.2)
+        G.add_edge(1, 2, weight=-2)
+        G.add_edge(1, 3, weight=0.3)
+        matching = minimum_weight_full_matching(G)
+        assert matching == {0: 3, 1: 2, 2: 1, 3: 0}
+
+    def test_minimum_weight_full_matching_different_weight_key(self):
+        G = nx.complete_bipartite_graph(2, 2)
+        G.add_edge(0, 2, mass=2)
+        G.add_edge(0, 3, mass=0.2)
+        G.add_edge(1, 2, mass=1)
+        G.add_edge(1, 3, mass=2)
+        matching = minimum_weight_full_matching(G, weight="mass")
+        assert matching == {0: 3, 1: 2, 2: 1, 3: 0}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_matrix.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_matrix.py
new file mode 100644
index 0000000..393b71e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_matrix.py
@@ -0,0 +1,79 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+sp = pytest.importorskip("scipy")
+sparse = pytest.importorskip("scipy.sparse")
+
+
+import networkx as nx
+from networkx.algorithms import bipartite
+from networkx.utils import edges_equal
+
+
+class TestBiadjacencyMatrix:
+    def test_biadjacency_matrix_weight(self):
+        G = nx.path_graph(5)
+        G.add_edge(0, 1, weight=2, other=4)
+        X = [1, 3]
+        Y = [0, 2, 4]
+        M = bipartite.biadjacency_matrix(G, X, weight="weight")
+        assert M[0, 0] == 2
+        M = bipartite.biadjacency_matrix(G, X, weight="other")
+        assert M[0, 0] == 4
+
+    def test_biadjacency_matrix(self):
+        tops = [2, 5, 10]
+        bots = [5, 10, 15]
+        for i in range(len(tops)):
+            G = bipartite.random_graph(tops[i], bots[i], 0.2)
+            top = [n for n, d in G.nodes(data=True) if d["bipartite"] == 0]
+            M = bipartite.biadjacency_matrix(G, top)
+            assert M.shape[0] == tops[i]
+            assert M.shape[1] == bots[i]
+
+    def test_biadjacency_matrix_order(self):
+        G = nx.path_graph(5)
+        G.add_edge(0, 1, weight=2)
+        X = [3, 1]
+        Y = [4, 2, 0]
+        M = bipartite.biadjacency_matrix(G, X, Y, weight="weight")
+        assert M[1, 2] == 2
+
+    def test_null_graph(self):
+        with pytest.raises(nx.NetworkXError):
+            bipartite.biadjacency_matrix(nx.Graph(), [])
+
+    def test_empty_graph(self):
+        with pytest.raises(nx.NetworkXError):
+            bipartite.biadjacency_matrix(nx.Graph([(1, 0)]), [])
+
+    def test_duplicate_row(self):
+        with pytest.raises(nx.NetworkXError):
+            bipartite.biadjacency_matrix(nx.Graph([(1, 0)]), [1, 1])
+
+    def test_duplicate_col(self):
+        with pytest.raises(nx.NetworkXError):
+            bipartite.biadjacency_matrix(nx.Graph([(1, 0)]), [0], [1, 1])
+
+    def test_format_keyword(self):
+        with pytest.raises(nx.NetworkXError):
+            bipartite.biadjacency_matrix(nx.Graph([(1, 0)]), [0], format="foo")
+
+    def test_from_biadjacency_roundtrip(self):
+        B1 = nx.path_graph(5)
+        M = bipartite.biadjacency_matrix(B1, [0, 2, 4])
+        B2 = bipartite.from_biadjacency_matrix(M)
+        assert nx.is_isomorphic(B1, B2)
+
+    def test_from_biadjacency_weight(self):
+        M = sparse.csc_matrix([[1, 2], [0, 3]])
+        B = bipartite.from_biadjacency_matrix(M)
+        assert edges_equal(B.edges(), [(0, 2), (0, 3), (1, 3)])
+        B = bipartite.from_biadjacency_matrix(M, edge_attribute="weight")
+        e = [(0, 2, {"weight": 1}), (0, 3, {"weight": 2}), (1, 3, {"weight": 3})]
+        assert edges_equal(B.edges(data=True), e)
+
+    def test_from_biadjacency_multigraph(self):
+        M = sparse.csc_matrix([[1, 2], [0, 3]])
+        B = bipartite.from_biadjacency_matrix(M, create_using=nx.MultiGraph())
+        assert edges_equal(B.edges(), [(0, 2), (0, 3), (0, 3), (1, 3), (1, 3), (1, 3)])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_project.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_project.py
new file mode 100644
index 0000000..74f8059
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_project.py
@@ -0,0 +1,398 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms import bipartite
+from networkx.utils import edges_equal, nodes_equal
+
+
+class TestBipartiteProject:
+    def test_path_projected_graph(self):
+        G = nx.path_graph(4)
+        P = bipartite.projected_graph(G, [1, 3])
+        assert nodes_equal(list(P), [1, 3])
+        assert edges_equal(list(P.edges()), [(1, 3)])
+        P = bipartite.projected_graph(G, [0, 2])
+        assert nodes_equal(list(P), [0, 2])
+        assert edges_equal(list(P.edges()), [(0, 2)])
+
+    def test_path_projected_properties_graph(self):
+        G = nx.path_graph(4)
+        G.add_node(1, name="one")
+        G.add_node(2, name="two")
+        P = bipartite.projected_graph(G, [1, 3])
+        assert nodes_equal(list(P), [1, 3])
+        assert edges_equal(list(P.edges()), [(1, 3)])
+        assert P.nodes[1]["name"] == G.nodes[1]["name"]
+        P = bipartite.projected_graph(G, [0, 2])
+        assert nodes_equal(list(P), [0, 2])
+        assert edges_equal(list(P.edges()), [(0, 2)])
+        assert P.nodes[2]["name"] == G.nodes[2]["name"]
+
+    def test_path_collaboration_projected_graph(self):
+        G = nx.path_graph(4)
+        P = bipartite.collaboration_weighted_projected_graph(G, [1, 3])
+        assert nodes_equal(list(P), [1, 3])
+        assert edges_equal(list(P.edges()), [(1, 3)])
+        P[1][3]["weight"] = 1
+        P = bipartite.collaboration_weighted_projected_graph(G, [0, 2])
+        assert nodes_equal(list(P), [0, 2])
+        assert edges_equal(list(P.edges()), [(0, 2)])
+        P[0][2]["weight"] = 1
+
+    def test_directed_path_collaboration_projected_graph(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(4))
+        P = bipartite.collaboration_weighted_projected_graph(G, [1, 3])
+        assert nodes_equal(list(P), [1, 3])
+        assert edges_equal(list(P.edges()), [(1, 3)])
+        P[1][3]["weight"] = 1
+        P = bipartite.collaboration_weighted_projected_graph(G, [0, 2])
+        assert nodes_equal(list(P), [0, 2])
+        assert edges_equal(list(P.edges()), [(0, 2)])
+        P[0][2]["weight"] = 1
+
+    def test_path_weighted_projected_graph(self):
+        G = nx.path_graph(4)
+
+        with pytest.raises(nx.NetworkXAlgorithmError):
+            bipartite.weighted_projected_graph(G, [1, 2, 3, 3])
+
+        P = bipartite.weighted_projected_graph(G, [1, 3])
+        assert nodes_equal(list(P), [1, 3])
+        assert edges_equal(list(P.edges()), [(1, 3)])
+        P[1][3]["weight"] = 1
+        P = bipartite.weighted_projected_graph(G, [0, 2])
+        assert nodes_equal(list(P), [0, 2])
+        assert edges_equal(list(P.edges()), [(0, 2)])
+        P[0][2]["weight"] = 1
+
+    def test_path_weighted_projected_directed_graph(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(4))
+        P = bipartite.weighted_projected_graph(G, [1, 3])
+        assert nodes_equal(list(P), [1, 3])
+        assert edges_equal(list(P.edges()), [(1, 3)])
+        P[1][3]["weight"] = 1
+        P = bipartite.weighted_projected_graph(G, [0, 2])
+        assert nodes_equal(list(P), [0, 2])
+        assert edges_equal(list(P.edges()), [(0, 2)])
+        P[0][2]["weight"] = 1
+
+    def test_star_projected_graph(self):
+        G = nx.star_graph(3)
+        P = bipartite.projected_graph(G, [1, 2, 3])
+        assert nodes_equal(list(P), [1, 2, 3])
+        assert edges_equal(list(P.edges()), [(1, 2), (1, 3), (2, 3)])
+        P = bipartite.weighted_projected_graph(G, [1, 2, 3])
+        assert nodes_equal(list(P), [1, 2, 3])
+        assert edges_equal(list(P.edges()), [(1, 2), (1, 3), (2, 3)])
+
+        P = bipartite.projected_graph(G, [0])
+        assert nodes_equal(list(P), [0])
+        assert edges_equal(list(P.edges()), [])
+
+    def test_project_multigraph(self):
+        G = nx.Graph()
+        G.add_edge("a", 1)
+        G.add_edge("b", 1)
+        G.add_edge("a", 2)
+        G.add_edge("b", 2)
+        P = bipartite.projected_graph(G, "ab")
+        assert edges_equal(list(P.edges()), [("a", "b")])
+        P = bipartite.weighted_projected_graph(G, "ab")
+        assert edges_equal(list(P.edges()), [("a", "b")])
+        P = bipartite.projected_graph(G, "ab", multigraph=True)
+        assert edges_equal(list(P.edges()), [("a", "b"), ("a", "b")])
+
+    def test_project_collaboration(self):
+        G = nx.Graph()
+        G.add_edge("a", 1)
+        G.add_edge("b", 1)
+        G.add_edge("b", 2)
+        G.add_edge("c", 2)
+        G.add_edge("c", 3)
+        G.add_edge("c", 4)
+        G.add_edge("b", 4)
+        P = bipartite.collaboration_weighted_projected_graph(G, "abc")
+        assert P["a"]["b"]["weight"] == 1
+        assert P["b"]["c"]["weight"] == 2
+
+    def test_directed_projection(self):
+        G = nx.DiGraph()
+        G.add_edge("A", 1)
+        G.add_edge(1, "B")
+        G.add_edge("A", 2)
+        G.add_edge("B", 2)
+        P = bipartite.projected_graph(G, "AB")
+        assert edges_equal(list(P.edges()), [("A", "B")])
+        P = bipartite.weighted_projected_graph(G, "AB")
+        assert edges_equal(list(P.edges()), [("A", "B")])
+        assert P["A"]["B"]["weight"] == 1
+
+        P = bipartite.projected_graph(G, "AB", multigraph=True)
+        assert edges_equal(list(P.edges()), [("A", "B")])
+
+        G = nx.DiGraph()
+        G.add_edge("A", 1)
+        G.add_edge(1, "B")
+        G.add_edge("A", 2)
+        G.add_edge(2, "B")
+        P = bipartite.projected_graph(G, "AB")
+        assert edges_equal(list(P.edges()), [("A", "B")])
+        P = bipartite.weighted_projected_graph(G, "AB")
+        assert edges_equal(list(P.edges()), [("A", "B")])
+        assert P["A"]["B"]["weight"] == 2
+
+        P = bipartite.projected_graph(G, "AB", multigraph=True)
+        assert edges_equal(list(P.edges()), [("A", "B"), ("A", "B")])
+
+
+class TestBipartiteWeightedProjection:
+    @classmethod
+    def setup_class(cls):
+        # Tore Opsahl's example
+        # http://toreopsahl.com/2009/05/01/projecting-two-mode-networks-onto-weighted-one-mode-networks/
+        cls.G = nx.Graph()
+        cls.G.add_edge("A", 1)
+        cls.G.add_edge("A", 2)
+        cls.G.add_edge("B", 1)
+        cls.G.add_edge("B", 2)
+        cls.G.add_edge("B", 3)
+        cls.G.add_edge("B", 4)
+        cls.G.add_edge("B", 5)
+        cls.G.add_edge("C", 1)
+        cls.G.add_edge("D", 3)
+        cls.G.add_edge("E", 4)
+        cls.G.add_edge("E", 5)
+        cls.G.add_edge("E", 6)
+        cls.G.add_edge("F", 6)
+        # Graph based on figure 6 from Newman (2001)
+        cls.N = nx.Graph()
+        cls.N.add_edge("A", 1)
+        cls.N.add_edge("A", 2)
+        cls.N.add_edge("A", 3)
+        cls.N.add_edge("B", 1)
+        cls.N.add_edge("B", 2)
+        cls.N.add_edge("B", 3)
+        cls.N.add_edge("C", 1)
+        cls.N.add_edge("D", 1)
+        cls.N.add_edge("E", 3)
+
+    def test_project_weighted_shared(self):
+        edges = [
+            ("A", "B", 2),
+            ("A", "C", 1),
+            ("B", "C", 1),
+            ("B", "D", 1),
+            ("B", "E", 2),
+            ("E", "F", 1),
+        ]
+        Panswer = nx.Graph()
+        Panswer.add_weighted_edges_from(edges)
+        P = bipartite.weighted_projected_graph(self.G, "ABCDEF")
+        assert edges_equal(list(P.edges()), Panswer.edges())
+        for u, v in list(P.edges()):
+            assert P[u][v]["weight"] == Panswer[u][v]["weight"]
+
+        edges = [
+            ("A", "B", 3),
+            ("A", "E", 1),
+            ("A", "C", 1),
+            ("A", "D", 1),
+            ("B", "E", 1),
+            ("B", "C", 1),
+            ("B", "D", 1),
+            ("C", "D", 1),
+        ]
+        Panswer = nx.Graph()
+        Panswer.add_weighted_edges_from(edges)
+        P = bipartite.weighted_projected_graph(self.N, "ABCDE")
+        assert edges_equal(list(P.edges()), Panswer.edges())
+        for u, v in list(P.edges()):
+            assert P[u][v]["weight"] == Panswer[u][v]["weight"]
+
+    def test_project_weighted_newman(self):
+        edges = [
+            ("A", "B", 1.5),
+            ("A", "C", 0.5),
+            ("B", "C", 0.5),
+            ("B", "D", 1),
+            ("B", "E", 2),
+            ("E", "F", 1),
+        ]
+        Panswer = nx.Graph()
+        Panswer.add_weighted_edges_from(edges)
+        P = bipartite.collaboration_weighted_projected_graph(self.G, "ABCDEF")
+        assert edges_equal(list(P.edges()), Panswer.edges())
+        for u, v in list(P.edges()):
+            assert P[u][v]["weight"] == Panswer[u][v]["weight"]
+
+        edges = [
+            ("A", "B", 11 / 6.0),
+            ("A", "E", 1 / 2.0),
+            ("A", "C", 1 / 3.0),
+            ("A", "D", 1 / 3.0),
+            ("B", "E", 1 / 2.0),
+            ("B", "C", 1 / 3.0),
+            ("B", "D", 1 / 3.0),
+            ("C", "D", 1 / 3.0),
+        ]
+        Panswer = nx.Graph()
+        Panswer.add_weighted_edges_from(edges)
+        P = bipartite.collaboration_weighted_projected_graph(self.N, "ABCDE")
+        assert edges_equal(list(P.edges()), Panswer.edges())
+        for u, v in list(P.edges()):
+            assert P[u][v]["weight"] == Panswer[u][v]["weight"]
+
+    def test_project_weighted_ratio(self):
+        edges = [
+            ("A", "B", 2 / 6.0),
+            ("A", "C", 1 / 6.0),
+            ("B", "C", 1 / 6.0),
+            ("B", "D", 1 / 6.0),
+            ("B", "E", 2 / 6.0),
+            ("E", "F", 1 / 6.0),
+        ]
+        Panswer = nx.Graph()
+        Panswer.add_weighted_edges_from(edges)
+        P = bipartite.weighted_projected_graph(self.G, "ABCDEF", ratio=True)
+        assert edges_equal(list(P.edges()), Panswer.edges())
+        for u, v in list(P.edges()):
+            assert P[u][v]["weight"] == Panswer[u][v]["weight"]
+
+        edges = [
+            ("A", "B", 3 / 3.0),
+            ("A", "E", 1 / 3.0),
+            ("A", "C", 1 / 3.0),
+            ("A", "D", 1 / 3.0),
+            ("B", "E", 1 / 3.0),
+            ("B", "C", 1 / 3.0),
+            ("B", "D", 1 / 3.0),
+            ("C", "D", 1 / 3.0),
+        ]
+        Panswer = nx.Graph()
+        Panswer.add_weighted_edges_from(edges)
+        P = bipartite.weighted_projected_graph(self.N, "ABCDE", ratio=True)
+        assert edges_equal(list(P.edges()), Panswer.edges())
+        for u, v in list(P.edges()):
+            assert P[u][v]["weight"] == Panswer[u][v]["weight"]
+
+    def test_project_weighted_overlap(self):
+        edges = [
+            ("A", "B", 2 / 2.0),
+            ("A", "C", 1 / 1.0),
+            ("B", "C", 1 / 1.0),
+            ("B", "D", 1 / 1.0),
+            ("B", "E", 2 / 3.0),
+            ("E", "F", 1 / 1.0),
+        ]
+        Panswer = nx.Graph()
+        Panswer.add_weighted_edges_from(edges)
+        P = bipartite.overlap_weighted_projected_graph(self.G, "ABCDEF", jaccard=False)
+        assert edges_equal(list(P.edges()), Panswer.edges())
+        for u, v in list(P.edges()):
+            assert P[u][v]["weight"] == Panswer[u][v]["weight"]
+
+        edges = [
+            ("A", "B", 3 / 3.0),
+            ("A", "E", 1 / 1.0),
+            ("A", "C", 1 / 1.0),
+            ("A", "D", 1 / 1.0),
+            ("B", "E", 1 / 1.0),
+            ("B", "C", 1 / 1.0),
+            ("B", "D", 1 / 1.0),
+            ("C", "D", 1 / 1.0),
+        ]
+        Panswer = nx.Graph()
+        Panswer.add_weighted_edges_from(edges)
+        P = bipartite.overlap_weighted_projected_graph(self.N, "ABCDE", jaccard=False)
+        assert edges_equal(list(P.edges()), Panswer.edges())
+        for u, v in list(P.edges()):
+            assert P[u][v]["weight"] == Panswer[u][v]["weight"]
+
+    def test_project_weighted_jaccard(self):
+        edges = [
+            ("A", "B", 2 / 5.0),
+            ("A", "C", 1 / 2.0),
+            ("B", "C", 1 / 5.0),
+            ("B", "D", 1 / 5.0),
+            ("B", "E", 2 / 6.0),
+            ("E", "F", 1 / 3.0),
+        ]
+        Panswer = nx.Graph()
+        Panswer.add_weighted_edges_from(edges)
+        P = bipartite.overlap_weighted_projected_graph(self.G, "ABCDEF")
+        assert edges_equal(list(P.edges()), Panswer.edges())
+        for u, v in list(P.edges()):
+            assert P[u][v]["weight"] == Panswer[u][v]["weight"]
+
+        edges = [
+            ("A", "B", 3 / 3.0),
+            ("A", "E", 1 / 3.0),
+            ("A", "C", 1 / 3.0),
+            ("A", "D", 1 / 3.0),
+            ("B", "E", 1 / 3.0),
+            ("B", "C", 1 / 3.0),
+            ("B", "D", 1 / 3.0),
+            ("C", "D", 1 / 1.0),
+        ]
+        Panswer = nx.Graph()
+        Panswer.add_weighted_edges_from(edges)
+        P = bipartite.overlap_weighted_projected_graph(self.N, "ABCDE")
+        assert edges_equal(list(P.edges()), Panswer.edges())
+        for u, v in P.edges():
+            assert P[u][v]["weight"] == Panswer[u][v]["weight"]
+
+    def test_generic_weighted_projected_graph_simple(self):
+        def shared(G, u, v):
+            return len(set(G[u]) & set(G[v]))
+
+        B = nx.path_graph(5)
+        G = bipartite.generic_weighted_projected_graph(
+            B, [0, 2, 4], weight_function=shared
+        )
+        assert nodes_equal(list(G), [0, 2, 4])
+        assert edges_equal(
+            list(list(G.edges(data=True))),
+            [(0, 2, {"weight": 1}), (2, 4, {"weight": 1})],
+        )
+
+        G = bipartite.generic_weighted_projected_graph(B, [0, 2, 4])
+        assert nodes_equal(list(G), [0, 2, 4])
+        assert edges_equal(
+            list(list(G.edges(data=True))),
+            [(0, 2, {"weight": 1}), (2, 4, {"weight": 1})],
+        )
+        B = nx.DiGraph()
+        nx.add_path(B, range(5))
+        G = bipartite.generic_weighted_projected_graph(B, [0, 2, 4])
+        assert nodes_equal(list(G), [0, 2, 4])
+        assert edges_equal(
+            list(G.edges(data=True)), [(0, 2, {"weight": 1}), (2, 4, {"weight": 1})]
+        )
+
+    def test_generic_weighted_projected_graph_custom(self):
+        def jaccard(G, u, v):
+            unbrs = set(G[u])
+            vnbrs = set(G[v])
+            return len(unbrs & vnbrs) / len(unbrs | vnbrs)
+
+        def my_weight(G, u, v, weight="weight"):
+            w = 0
+            for nbr in set(G[u]) & set(G[v]):
+                w += G.edges[u, nbr].get(weight, 1) + G.edges[v, nbr].get(weight, 1)
+            return w
+
+        B = nx.bipartite.complete_bipartite_graph(2, 2)
+        for i, (u, v) in enumerate(B.edges()):
+            B.edges[u, v]["weight"] = i + 1
+        G = bipartite.generic_weighted_projected_graph(
+            B, [0, 1], weight_function=jaccard
+        )
+        assert edges_equal(list(G.edges(data=True)), [(0, 1, {"weight": 1.0})])
+        G = bipartite.generic_weighted_projected_graph(
+            B, [0, 1], weight_function=my_weight
+        )
+        assert edges_equal(list(G.edges(data=True)), [(0, 1, {"weight": 10})])
+        G = bipartite.generic_weighted_projected_graph(B, [0, 1])
+        assert edges_equal(list(G.edges(data=True)), [(0, 1, {"weight": 2})])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_redundancy.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_redundancy.py
new file mode 100644
index 0000000..8c04e95
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_redundancy.py
@@ -0,0 +1,31 @@
+"""Unit tests for the :mod:`networkx.algorithms.bipartite.redundancy` module.
+
+"""
+
+import pytest
+
+from networkx import NetworkXError, cycle_graph
+from networkx.algorithms.bipartite import complete_bipartite_graph, node_redundancy
+
+
+def test_no_redundant_nodes():
+    G = complete_bipartite_graph(2, 2)
+    rc = node_redundancy(G)
+    assert all(redundancy == 1 for redundancy in rc.values())
+
+
+def test_redundant_nodes():
+    G = cycle_graph(6)
+    edge = {0, 3}
+    G.add_edge(*edge)
+    redundancy = node_redundancy(G)
+    for v in edge:
+        assert redundancy[v] == 2 / 3
+    for v in set(G) - edge:
+        assert redundancy[v] == 1
+
+
+def test_not_enough_neighbors():
+    with pytest.raises(NetworkXError):
+        G = complete_bipartite_graph(1, 2)
+        node_redundancy(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_spectral_bipartivity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_spectral_bipartivity.py
new file mode 100644
index 0000000..0cdc2d6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_spectral_bipartivity.py
@@ -0,0 +1,81 @@
+import pytest
+
+pytest.importorskip("scipy")
+
+import networkx as nx
+from networkx.algorithms.bipartite import spectral_bipartivity as sb
+
+# Examples from Figure 1
+# E. Estrada and J. A. Rodríguez-Velázquez, "Spectral measures of
+# bipartivity in complex networks", PhysRev E 72, 046105 (2005)
+
+
+class TestSpectralBipartivity:
+    def test_star_like(self):
+        # star-like
+
+        G = nx.star_graph(2)
+        G.add_edge(1, 2)
+        assert sb(G) == pytest.approx(0.843, abs=1e-3)
+
+        G = nx.star_graph(3)
+        G.add_edge(1, 2)
+        assert sb(G) == pytest.approx(0.871, abs=1e-3)
+
+        G = nx.star_graph(4)
+        G.add_edge(1, 2)
+        assert sb(G) == pytest.approx(0.890, abs=1e-3)
+
+    def test_k23_like(self):
+        # K2,3-like
+        G = nx.complete_bipartite_graph(2, 3)
+        G.add_edge(0, 1)
+        assert sb(G) == pytest.approx(0.769, abs=1e-3)
+
+        G = nx.complete_bipartite_graph(2, 3)
+        G.add_edge(2, 4)
+        assert sb(G) == pytest.approx(0.829, abs=1e-3)
+
+        G = nx.complete_bipartite_graph(2, 3)
+        G.add_edge(2, 4)
+        G.add_edge(3, 4)
+        assert sb(G) == pytest.approx(0.731, abs=1e-3)
+
+        G = nx.complete_bipartite_graph(2, 3)
+        G.add_edge(0, 1)
+        G.add_edge(2, 4)
+        assert sb(G) == pytest.approx(0.692, abs=1e-3)
+
+        G = nx.complete_bipartite_graph(2, 3)
+        G.add_edge(2, 4)
+        G.add_edge(3, 4)
+        G.add_edge(0, 1)
+        assert sb(G) == pytest.approx(0.645, abs=1e-3)
+
+        G = nx.complete_bipartite_graph(2, 3)
+        G.add_edge(2, 4)
+        G.add_edge(3, 4)
+        G.add_edge(2, 3)
+        assert sb(G) == pytest.approx(0.645, abs=1e-3)
+
+        G = nx.complete_bipartite_graph(2, 3)
+        G.add_edge(2, 4)
+        G.add_edge(3, 4)
+        G.add_edge(2, 3)
+        G.add_edge(0, 1)
+        assert sb(G) == pytest.approx(0.597, abs=1e-3)
+
+    def test_single_nodes(self):
+
+        # single nodes
+        G = nx.complete_bipartite_graph(2, 3)
+        G.add_edge(2, 4)
+        sbn = sb(G, nodes=[1, 2])
+        assert sbn[1] == pytest.approx(0.85, abs=1e-2)
+        assert sbn[2] == pytest.approx(0.77, abs=1e-2)
+
+        G = nx.complete_bipartite_graph(2, 3)
+        G.add_edge(0, 1)
+        sbn = sb(G, nodes=[1, 2])
+        assert sbn[1] == pytest.approx(0.73, abs=1e-2)
+        assert sbn[2] == pytest.approx(0.82, abs=1e-2)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/boundary.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/boundary.py
new file mode 100644
index 0000000..25c1e28
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/boundary.py
@@ -0,0 +1,135 @@
+"""Routines to find the boundary of a set of nodes.
+
+An edge boundary is a set of edges, each of which has exactly one
+endpoint in a given set of nodes (or, in the case of directed graphs,
+the set of edges whose source node is in the set).
+
+A node boundary of a set *S* of nodes is the set of (out-)neighbors of
+nodes in *S* that are outside *S*.
+
+"""
+from itertools import chain
+
+__all__ = ["edge_boundary", "node_boundary"]
+
+
+def edge_boundary(G, nbunch1, nbunch2=None, data=False, keys=False, default=None):
+    """Returns the edge boundary of `nbunch1`.
+
+    The *edge boundary* of a set *S* with respect to a set *T* is the
+    set of edges (*u*, *v*) such that *u* is in *S* and *v* is in *T*.
+    If *T* is not specified, it is assumed to be the set of all nodes
+    not in *S*.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    nbunch1 : iterable
+        Iterable of nodes in the graph representing the set of nodes
+        whose edge boundary will be returned. (This is the set *S* from
+        the definition above.)
+
+    nbunch2 : iterable
+        Iterable of nodes representing the target (or "exterior") set of
+        nodes. (This is the set *T* from the definition above.) If not
+        specified, this is assumed to be the set of all nodes in `G`
+        not in `nbunch1`.
+
+    keys : bool
+        This parameter has the same meaning as in
+        :meth:`MultiGraph.edges`.
+
+    data : bool or object
+        This parameter has the same meaning as in
+        :meth:`MultiGraph.edges`.
+
+    default : object
+        This parameter has the same meaning as in
+        :meth:`MultiGraph.edges`.
+
+    Returns
+    -------
+    iterator
+        An iterator over the edges in the boundary of `nbunch1` with
+        respect to `nbunch2`. If `keys`, `data`, or `default`
+        are specified and `G` is a multigraph, then edges are returned
+        with keys and/or data, as in :meth:`MultiGraph.edges`.
+
+    Notes
+    -----
+    Any element of `nbunch` that is not in the graph `G` will be
+    ignored.
+
+    `nbunch1` and `nbunch2` are usually meant to be disjoint, but in
+    the interest of speed and generality, that is not required here.
+
+    """
+    nset1 = {n for n in nbunch1 if n in G}
+    # Here we create an iterator over edges incident to nodes in the set
+    # `nset1`. The `Graph.edges()` method does not provide a guarantee
+    # on the orientation of the edges, so our algorithm below must
+    # handle the case in which exactly one orientation, either (u, v) or
+    # (v, u), appears in this iterable.
+    if G.is_multigraph():
+        edges = G.edges(nset1, data=data, keys=keys, default=default)
+    else:
+        edges = G.edges(nset1, data=data, default=default)
+    # If `nbunch2` is not provided, then it is assumed to be the set
+    # complement of `nbunch1`. For the sake of efficiency, this is
+    # implemented by using the `not in` operator, instead of by creating
+    # an additional set and using the `in` operator.
+    if nbunch2 is None:
+        return (e for e in edges if (e[0] in nset1) ^ (e[1] in nset1))
+    nset2 = set(nbunch2)
+    return (
+        e
+        for e in edges
+        if (e[0] in nset1 and e[1] in nset2) or (e[1] in nset1 and e[0] in nset2)
+    )
+
+
+def node_boundary(G, nbunch1, nbunch2=None):
+    """Returns the node boundary of `nbunch1`.
+
+    The *node boundary* of a set *S* with respect to a set *T* is the
+    set of nodes *v* in *T* such that for some *u* in *S*, there is an
+    edge joining *u* to *v*. If *T* is not specified, it is assumed to
+    be the set of all nodes not in *S*.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    nbunch1 : iterable
+        Iterable of nodes in the graph representing the set of nodes
+        whose node boundary will be returned. (This is the set *S* from
+        the definition above.)
+
+    nbunch2 : iterable
+        Iterable of nodes representing the target (or "exterior") set of
+        nodes. (This is the set *T* from the definition above.) If not
+        specified, this is assumed to be the set of all nodes in `G`
+        not in `nbunch1`.
+
+    Returns
+    -------
+    set
+        The node boundary of `nbunch1` with respect to `nbunch2`.
+
+    Notes
+    -----
+    Any element of `nbunch` that is not in the graph `G` will be
+    ignored.
+
+    `nbunch1` and `nbunch2` are usually meant to be disjoint, but in
+    the interest of speed and generality, that is not required here.
+
+    """
+    nset1 = {n for n in nbunch1 if n in G}
+    bdy = set(chain.from_iterable(G[v] for v in nset1)) - nset1
+    # If `nbunch2` is not specified, it is assumed to be the set
+    # complement of `nbunch1`.
+    if nbunch2 is not None:
+        bdy &= set(nbunch2)
+    return bdy
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/bridges.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/bridges.py
new file mode 100644
index 0000000..eda4a4f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/bridges.py
@@ -0,0 +1,199 @@
+"""Bridge-finding algorithms."""
+from itertools import chain
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["bridges", "has_bridges", "local_bridges"]
+
+
+@not_implemented_for("directed")
+def bridges(G, root=None):
+    """Generate all bridges in a graph.
+
+    A *bridge* in a graph is an edge whose removal causes the number of
+    connected components of the graph to increase.  Equivalently, a bridge is an
+    edge that does not belong to any cycle. Bridges are also known as cut-edges,
+    isthmuses, or cut arcs.
+
+    Parameters
+    ----------
+    G : undirected graph
+
+    root : node (optional)
+       A node in the graph `G`. If specified, only the bridges in the
+       connected component containing this node will be returned.
+
+    Yields
+    ------
+    e : edge
+       An edge in the graph whose removal disconnects the graph (or
+       causes the number of connected components to increase).
+
+    Raises
+    ------
+    NodeNotFound
+       If `root` is not in the graph `G`.
+
+    NetworkXNotImplemented
+        If `G` is a directed graph.
+
+    Examples
+    --------
+    The barbell graph with parameter zero has a single bridge:
+
+    >>> G = nx.barbell_graph(10, 0)
+    >>> list(nx.bridges(G))
+    [(9, 10)]
+
+    Notes
+    -----
+    This is an implementation of the algorithm described in [1]_.  An edge is a
+    bridge if and only if it is not contained in any chain. Chains are found
+    using the :func:`networkx.chain_decomposition` function.
+
+    The algorithm described in [1]_ requires a simple graph. If the provided
+    graph is a multigraph, we convert it to a simple graph and verify that any
+    bridges discovered by the chain decomposition algorithm are not multi-edges.
+
+    Ignoring polylogarithmic factors, the worst-case time complexity is the
+    same as the :func:`networkx.chain_decomposition` function,
+    $O(m + n)$, where $n$ is the number of nodes in the graph and $m$ is
+    the number of edges.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Bridge_%28graph_theory%29#Bridge-Finding_with_Chain_Decompositions
+    """
+    multigraph = G.is_multigraph()
+    H = nx.Graph(G) if multigraph else G
+    chains = nx.chain_decomposition(H, root=root)
+    chain_edges = set(chain.from_iterable(chains))
+    for u, v in H.edges():
+        if (u, v) not in chain_edges and (v, u) not in chain_edges:
+            if multigraph and len(G[u][v]) > 1:
+                continue
+            yield u, v
+
+
+@not_implemented_for("directed")
+def has_bridges(G, root=None):
+    """Decide whether a graph has any bridges.
+
+    A *bridge* in a graph is an edge whose removal causes the number of
+    connected components of the graph to increase.
+
+    Parameters
+    ----------
+    G : undirected graph
+
+    root : node (optional)
+       A node in the graph `G`. If specified, only the bridges in the
+       connected component containing this node will be considered.
+
+    Returns
+    -------
+    bool
+       Whether the graph (or the connected component containing `root`)
+       has any bridges.
+
+    Raises
+    ------
+    NodeNotFound
+       If `root` is not in the graph `G`.
+
+    NetworkXNotImplemented
+        If `G` is a directed graph.
+
+    Examples
+    --------
+    The barbell graph with parameter zero has a single bridge::
+
+        >>> G = nx.barbell_graph(10, 0)
+        >>> nx.has_bridges(G)
+        True
+
+    On the other hand, the cycle graph has no bridges::
+
+        >>> G = nx.cycle_graph(5)
+        >>> nx.has_bridges(G)
+        False
+
+    Notes
+    -----
+    This implementation uses the :func:`networkx.bridges` function, so
+    it shares its worst-case time complexity, $O(m + n)$, ignoring
+    polylogarithmic factors, where $n$ is the number of nodes in the
+    graph and $m$ is the number of edges.
+
+    """
+    try:
+        next(bridges(G))
+    except StopIteration:
+        return False
+    else:
+        return True
+
+
+@not_implemented_for("multigraph")
+@not_implemented_for("directed")
+def local_bridges(G, with_span=True, weight=None):
+    """Iterate over local bridges of `G` optionally computing the span
+
+    A *local bridge* is an edge whose endpoints have no common neighbors.
+    That is, the edge is not part of a triangle in the graph.
+
+    The *span* of a *local bridge* is the shortest path length between
+    the endpoints if the local bridge is removed.
+
+    Parameters
+    ----------
+    G : undirected graph
+
+    with_span : bool
+        If True, yield a 3-tuple `(u, v, span)`
+
+    weight : function, string or None (default: None)
+        If function, used to compute edge weights for the span.
+        If string, the edge data attribute used in calculating span.
+        If None, all edges have weight 1.
+
+    Yields
+    ------
+    e : edge
+        The local bridges as an edge 2-tuple of nodes `(u, v)` or
+        as a 3-tuple `(u, v, span)` when `with_span is True`.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is a directed graph or multigraph.
+
+    Examples
+    --------
+    A cycle graph has every edge a local bridge with span N-1.
+
+       >>> G = nx.cycle_graph(9)
+       >>> (0, 8, 8) in set(nx.local_bridges(G))
+       True
+    """
+    if with_span is not True:
+        for u, v in G.edges:
+            if not (set(G[u]) & set(G[v])):
+                yield u, v
+    else:
+        wt = nx.weighted._weight_function(G, weight)
+        for u, v in G.edges:
+            if not (set(G[u]) & set(G[v])):
+                enodes = {u, v}
+
+                def hide_edge(n, nbr, d):
+                    if n not in enodes or nbr not in enodes:
+                        return wt(n, nbr, d)
+                    return None
+
+                try:
+                    span = nx.shortest_path_length(G, u, v, weight=hide_edge)
+                    yield u, v, span
+                except nx.NetworkXNoPath:
+                    yield u, v, float("inf")
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/__init__.py
new file mode 100644
index 0000000..cf07fe2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/__init__.py
@@ -0,0 +1,19 @@
+from .betweenness import *
+from .betweenness_subset import *
+from .closeness import *
+from .current_flow_betweenness import *
+from .current_flow_betweenness_subset import *
+from .current_flow_closeness import *
+from .degree_alg import *
+from .dispersion import *
+from .eigenvector import *
+from .group import *
+from .harmonic import *
+from .katz import *
+from .load import *
+from .percolation import *
+from .reaching import *
+from .second_order import *
+from .subgraph_alg import *
+from .trophic import *
+from .voterank_alg import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/betweenness.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/betweenness.py
new file mode 100644
index 0000000..54b7db9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/betweenness.py
@@ -0,0 +1,436 @@
+"""Betweenness centrality measures."""
+import warnings
+from collections import deque
+from heapq import heappop, heappush
+from itertools import count
+
+from networkx.algorithms.shortest_paths.weighted import _weight_function
+from networkx.utils import py_random_state
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = ["betweenness_centrality", "edge_betweenness_centrality", "edge_betweenness"]
+
+
+@py_random_state(5)
+def betweenness_centrality(
+    G, k=None, normalized=True, weight=None, endpoints=False, seed=None
+):
+    r"""Compute the shortest-path betweenness centrality for nodes.
+
+    Betweenness centrality of a node $v$ is the sum of the
+    fraction of all-pairs shortest paths that pass through $v$
+
+    .. math::
+
+       c_B(v) =\sum_{s,t \in V} \frac{\sigma(s, t|v)}{\sigma(s, t)}
+
+    where $V$ is the set of nodes, $\sigma(s, t)$ is the number of
+    shortest $(s, t)$-paths,  and $\sigma(s, t|v)$ is the number of
+    those paths  passing through some  node $v$ other than $s, t$.
+    If $s = t$, $\sigma(s, t) = 1$, and if $v \in {s, t}$,
+    $\sigma(s, t|v) = 0$ [2]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.
+
+    k : int, optional (default=None)
+      If k is not None use k node samples to estimate betweenness.
+      The value of k <= n where n is the number of nodes in the graph.
+      Higher values give better approximation.
+
+    normalized : bool, optional
+      If True the betweenness values are normalized by `2/((n-1)(n-2))`
+      for graphs, and `1/((n-1)(n-2))` for directed graphs where `n`
+      is the number of nodes in G.
+
+    weight : None or string, optional (default=None)
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+      Weights are used to calculate weighted shortest paths, so they are
+      interpreted as distances.
+
+    endpoints : bool, optional
+      If True include the endpoints in the shortest path counts.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+        Note that this is only used if k is not None.
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with betweenness centrality as the value.
+
+    See Also
+    --------
+    edge_betweenness_centrality
+    load_centrality
+
+    Notes
+    -----
+    The algorithm is from Ulrik Brandes [1]_.
+    See [4]_ for the original first published version and [2]_ for details on
+    algorithms for variations and related metrics.
+
+    For approximate betweenness calculations set k=#samples to use
+    k nodes ("pivots") to estimate the betweenness values. For an estimate
+    of the number of pivots needed see [3]_.
+
+    For weighted graphs the edge weights must be greater than zero.
+    Zero edge weights can produce an infinite number of equal length
+    paths between pairs of nodes.
+
+    The total number of paths between source and target is counted
+    differently for directed and undirected graphs. Directed paths
+    are easy to count. Undirected paths are tricky: should a path
+    from "u" to "v" count as 1 undirected path or as 2 directed paths?
+
+    For betweenness_centrality we report the number of undirected
+    paths when G is undirected.
+
+    For betweenness_centrality_subset the reporting is different.
+    If the source and target subsets are the same, then we want
+    to count undirected paths. But if the source and target subsets
+    differ -- for example, if sources is {0} and targets is {1},
+    then we are only counting the paths in one direction. They are
+    undirected paths but we are counting them in a directed way.
+    To count them as undirected paths, each should count as half a path.
+
+    References
+    ----------
+    .. [1] Ulrik Brandes:
+       A Faster Algorithm for Betweenness Centrality.
+       Journal of Mathematical Sociology 25(2):163-177, 2001.
+       https://doi.org/10.1080/0022250X.2001.9990249
+    .. [2] Ulrik Brandes:
+       On Variants of Shortest-Path Betweenness
+       Centrality and their Generic Computation.
+       Social Networks 30(2):136-145, 2008.
+       https://doi.org/10.1016/j.socnet.2007.11.001
+    .. [3] Ulrik Brandes and Christian Pich:
+       Centrality Estimation in Large Networks.
+       International Journal of Bifurcation and Chaos 17(7):2303-2318, 2007.
+       https://dx.doi.org/10.1142/S0218127407018403
+    .. [4] Linton C. Freeman:
+       A set of measures of centrality based on betweenness.
+       Sociometry 40: 35–41, 1977
+       https://doi.org/10.2307/3033543
+    """
+    betweenness = dict.fromkeys(G, 0.0)  # b[v]=0 for v in G
+    if k is None:
+        nodes = G
+    else:
+        nodes = seed.sample(list(G.nodes()), k)
+    for s in nodes:
+        # single source shortest paths
+        if weight is None:  # use BFS
+            S, P, sigma, _ = _single_source_shortest_path_basic(G, s)
+        else:  # use Dijkstra's algorithm
+            S, P, sigma, _ = _single_source_dijkstra_path_basic(G, s, weight)
+        # accumulation
+        if endpoints:
+            betweenness, _ = _accumulate_endpoints(betweenness, S, P, sigma, s)
+        else:
+            betweenness, _ = _accumulate_basic(betweenness, S, P, sigma, s)
+    # rescaling
+    betweenness = _rescale(
+        betweenness,
+        len(G),
+        normalized=normalized,
+        directed=G.is_directed(),
+        k=k,
+        endpoints=endpoints,
+    )
+    return betweenness
+
+
+@py_random_state(4)
+def edge_betweenness_centrality(G, k=None, normalized=True, weight=None, seed=None):
+    r"""Compute betweenness centrality for edges.
+
+    Betweenness centrality of an edge $e$ is the sum of the
+    fraction of all-pairs shortest paths that pass through $e$
+
+    .. math::
+
+       c_B(e) =\sum_{s,t \in V} \frac{\sigma(s, t|e)}{\sigma(s, t)}
+
+    where $V$ is the set of nodes, $\sigma(s, t)$ is the number of
+    shortest $(s, t)$-paths, and $\sigma(s, t|e)$ is the number of
+    those paths passing through edge $e$ [2]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.
+
+    k : int, optional (default=None)
+      If k is not None use k node samples to estimate betweenness.
+      The value of k <= n where n is the number of nodes in the graph.
+      Higher values give better approximation.
+
+    normalized : bool, optional
+      If True the betweenness values are normalized by $2/(n(n-1))$
+      for graphs, and $1/(n(n-1))$ for directed graphs where $n$
+      is the number of nodes in G.
+
+    weight : None or string, optional (default=None)
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+      Weights are used to calculate weighted shortest paths, so they are
+      interpreted as distances.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+        Note that this is only used if k is not None.
+
+    Returns
+    -------
+    edges : dictionary
+       Dictionary of edges with betweenness centrality as the value.
+
+    See Also
+    --------
+    betweenness_centrality
+    edge_load
+
+    Notes
+    -----
+    The algorithm is from Ulrik Brandes [1]_.
+
+    For weighted graphs the edge weights must be greater than zero.
+    Zero edge weights can produce an infinite number of equal length
+    paths between pairs of nodes.
+
+    References
+    ----------
+    .. [1]  A Faster Algorithm for Betweenness Centrality. Ulrik Brandes,
+       Journal of Mathematical Sociology 25(2):163-177, 2001.
+       https://doi.org/10.1080/0022250X.2001.9990249
+    .. [2] Ulrik Brandes: On Variants of Shortest-Path Betweenness
+       Centrality and their Generic Computation.
+       Social Networks 30(2):136-145, 2008.
+       https://doi.org/10.1016/j.socnet.2007.11.001
+    """
+    betweenness = dict.fromkeys(G, 0.0)  # b[v]=0 for v in G
+    # b[e]=0 for e in G.edges()
+    betweenness.update(dict.fromkeys(G.edges(), 0.0))
+    if k is None:
+        nodes = G
+    else:
+        nodes = seed.sample(G.nodes(), k)
+    for s in nodes:
+        # single source shortest paths
+        if weight is None:  # use BFS
+            S, P, sigma, _ = _single_source_shortest_path_basic(G, s)
+        else:  # use Dijkstra's algorithm
+            S, P, sigma, _ = _single_source_dijkstra_path_basic(G, s, weight)
+        # accumulation
+        betweenness = _accumulate_edges(betweenness, S, P, sigma, s)
+    # rescaling
+    for n in G:  # remove nodes to only return edges
+        del betweenness[n]
+    betweenness = _rescale_e(
+        betweenness, len(G), normalized=normalized, directed=G.is_directed()
+    )
+    if G.is_multigraph():
+        betweenness = _add_edge_keys(G, betweenness, weight=weight)
+    return betweenness
+
+
+# obsolete name
+def edge_betweenness(G, k=None, normalized=True, weight=None, seed=None):
+    warnings.warn(
+        "edge_betweeness is replaced by edge_betweenness_centrality", DeprecationWarning
+    )
+    return edge_betweenness_centrality(G, k, normalized, weight, seed)
+
+
+# helpers for betweenness centrality
+
+
+def _single_source_shortest_path_basic(G, s):
+    S = []
+    P = {}
+    for v in G:
+        P[v] = []
+    sigma = dict.fromkeys(G, 0.0)  # sigma[v]=0 for v in G
+    D = {}
+    sigma[s] = 1.0
+    D[s] = 0
+    Q = deque([s])
+    while Q:  # use BFS to find shortest paths
+        v = Q.popleft()
+        S.append(v)
+        Dv = D[v]
+        sigmav = sigma[v]
+        for w in G[v]:
+            if w not in D:
+                Q.append(w)
+                D[w] = Dv + 1
+            if D[w] == Dv + 1:  # this is a shortest path, count paths
+                sigma[w] += sigmav
+                P[w].append(v)  # predecessors
+    return S, P, sigma, D
+
+
+def _single_source_dijkstra_path_basic(G, s, weight):
+    weight = _weight_function(G, weight)
+    # modified from Eppstein
+    S = []
+    P = {}
+    for v in G:
+        P[v] = []
+    sigma = dict.fromkeys(G, 0.0)  # sigma[v]=0 for v in G
+    D = {}
+    sigma[s] = 1.0
+    push = heappush
+    pop = heappop
+    seen = {s: 0}
+    c = count()
+    Q = []  # use Q as heap with (distance,node id) tuples
+    push(Q, (0, next(c), s, s))
+    while Q:
+        (dist, _, pred, v) = pop(Q)
+        if v in D:
+            continue  # already searched this node.
+        sigma[v] += sigma[pred]  # count paths
+        S.append(v)
+        D[v] = dist
+        for w, edgedata in G[v].items():
+            vw_dist = dist + weight(v, w, edgedata)
+            if w not in D and (w not in seen or vw_dist < seen[w]):
+                seen[w] = vw_dist
+                push(Q, (vw_dist, next(c), v, w))
+                sigma[w] = 0.0
+                P[w] = [v]
+            elif vw_dist == seen[w]:  # handle equal paths
+                sigma[w] += sigma[v]
+                P[w].append(v)
+    return S, P, sigma, D
+
+
+def _accumulate_basic(betweenness, S, P, sigma, s):
+    delta = dict.fromkeys(S, 0)
+    while S:
+        w = S.pop()
+        coeff = (1 + delta[w]) / sigma[w]
+        for v in P[w]:
+            delta[v] += sigma[v] * coeff
+        if w != s:
+            betweenness[w] += delta[w]
+    return betweenness, delta
+
+
+def _accumulate_endpoints(betweenness, S, P, sigma, s):
+    betweenness[s] += len(S) - 1
+    delta = dict.fromkeys(S, 0)
+    while S:
+        w = S.pop()
+        coeff = (1 + delta[w]) / sigma[w]
+        for v in P[w]:
+            delta[v] += sigma[v] * coeff
+        if w != s:
+            betweenness[w] += delta[w] + 1
+    return betweenness, delta
+
+
+def _accumulate_edges(betweenness, S, P, sigma, s):
+    delta = dict.fromkeys(S, 0)
+    while S:
+        w = S.pop()
+        coeff = (1 + delta[w]) / sigma[w]
+        for v in P[w]:
+            c = sigma[v] * coeff
+            if (v, w) not in betweenness:
+                betweenness[(w, v)] += c
+            else:
+                betweenness[(v, w)] += c
+            delta[v] += c
+        if w != s:
+            betweenness[w] += delta[w]
+    return betweenness
+
+
+def _rescale(betweenness, n, normalized, directed=False, k=None, endpoints=False):
+    if normalized:
+        if endpoints:
+            if n < 2:
+                scale = None  # no normalization
+            else:
+                # Scale factor should include endpoint nodes
+                scale = 1 / (n * (n - 1))
+        elif n <= 2:
+            scale = None  # no normalization b=0 for all nodes
+        else:
+            scale = 1 / ((n - 1) * (n - 2))
+    else:  # rescale by 2 for undirected graphs
+        if not directed:
+            scale = 0.5
+        else:
+            scale = None
+    if scale is not None:
+        if k is not None:
+            scale = scale * n / k
+        for v in betweenness:
+            betweenness[v] *= scale
+    return betweenness
+
+
+def _rescale_e(betweenness, n, normalized, directed=False, k=None):
+    if normalized:
+        if n <= 1:
+            scale = None  # no normalization b=0 for all nodes
+        else:
+            scale = 1 / (n * (n - 1))
+    else:  # rescale by 2 for undirected graphs
+        if not directed:
+            scale = 0.5
+        else:
+            scale = None
+    if scale is not None:
+        if k is not None:
+            scale = scale * n / k
+        for v in betweenness:
+            betweenness[v] *= scale
+    return betweenness
+
+
+@not_implemented_for("graph")
+def _add_edge_keys(G, betweenness, weight=None):
+    r"""Adds the corrected betweenness centrality (BC) values for multigraphs.
+
+    Parameters
+    ----------
+    G : NetworkX graph.
+
+    betweenness : dictionary
+        Dictionary mapping adjacent node tuples to betweenness centrality values.
+
+    weight : string or function
+        See `_weight_function` for details. Defaults to `None`.
+
+    Returns
+    -------
+    edges : dictionary
+        The parameter `betweenness` including edges with keys and their
+        betweenness centrality values.
+
+    The BC value is divided among edges of equal weight.
+    """
+    _weight = _weight_function(G, weight)
+
+    edge_bc = dict.fromkeys(G.edges, 0.0)
+    for u, v in betweenness:
+        d = G[u][v]
+        wt = _weight(u, v, d)
+        keys = [k for k in d if _weight(u, v, {k: d[k]}) == wt]
+        bc = betweenness[(u, v)] / len(keys)
+        for k in keys:
+            edge_bc[(u, v, k)] = bc
+
+    return edge_bc
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/betweenness_subset.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/betweenness_subset.py
new file mode 100644
index 0000000..6b6958f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/betweenness_subset.py
@@ -0,0 +1,282 @@
+"""Betweenness centrality measures for subsets of nodes."""
+import warnings
+
+from networkx.algorithms.centrality.betweenness import _add_edge_keys
+from networkx.algorithms.centrality.betweenness import (
+    _single_source_dijkstra_path_basic as dijkstra,
+)
+from networkx.algorithms.centrality.betweenness import (
+    _single_source_shortest_path_basic as shortest_path,
+)
+
+__all__ = [
+    "betweenness_centrality_subset",
+    "betweenness_centrality_source",
+    "edge_betweenness_centrality_subset",
+]
+
+
+def betweenness_centrality_subset(G, sources, targets, normalized=False, weight=None):
+    r"""Compute betweenness centrality for a subset of nodes.
+
+    .. math::
+
+       c_B(v) =\sum_{s\in S, t \in T} \frac{\sigma(s, t|v)}{\sigma(s, t)}
+
+    where $S$ is the set of sources, $T$ is the set of targets,
+    $\sigma(s, t)$ is the number of shortest $(s, t)$-paths,
+    and $\sigma(s, t|v)$ is the number of those paths
+    passing through some  node $v$ other than $s, t$.
+    If $s = t$, $\sigma(s, t) = 1$,
+    and if $v \in {s, t}$, $\sigma(s, t|v) = 0$ [2]_.
+
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.
+
+    sources: list of nodes
+      Nodes to use as sources for shortest paths in betweenness
+
+    targets: list of nodes
+      Nodes to use as targets for shortest paths in betweenness
+
+    normalized : bool, optional
+      If True the betweenness values are normalized by $2/((n-1)(n-2))$
+      for graphs, and $1/((n-1)(n-2))$ for directed graphs where $n$
+      is the number of nodes in G.
+
+    weight : None or string, optional (default=None)
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+      Weights are used to calculate weighted shortest paths, so they are
+      interpreted as distances.
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with betweenness centrality as the value.
+
+    See Also
+    --------
+    edge_betweenness_centrality
+    load_centrality
+
+    Notes
+    -----
+    The basic algorithm is from [1]_.
+
+    For weighted graphs the edge weights must be greater than zero.
+    Zero edge weights can produce an infinite number of equal length
+    paths between pairs of nodes.
+
+    The normalization might seem a little strange but it is
+    designed to make betweenness_centrality(G) be the same as
+    betweenness_centrality_subset(G,sources=G.nodes(),targets=G.nodes()).
+
+    The total number of paths between source and target is counted
+    differently for directed and undirected graphs. Directed paths
+    are easy to count. Undirected paths are tricky: should a path
+    from "u" to "v" count as 1 undirected path or as 2 directed paths?
+
+    For betweenness_centrality we report the number of undirected
+    paths when G is undirected.
+
+    For betweenness_centrality_subset the reporting is different.
+    If the source and target subsets are the same, then we want
+    to count undirected paths. But if the source and target subsets
+    differ -- for example, if sources is {0} and targets is {1},
+    then we are only counting the paths in one direction. They are
+    undirected paths but we are counting them in a directed way.
+    To count them as undirected paths, each should count as half a path.
+
+    References
+    ----------
+    .. [1] Ulrik Brandes, A Faster Algorithm for Betweenness Centrality.
+       Journal of Mathematical Sociology 25(2):163-177, 2001.
+       https://doi.org/10.1080/0022250X.2001.9990249
+    .. [2] Ulrik Brandes: On Variants of Shortest-Path Betweenness
+       Centrality and their Generic Computation.
+       Social Networks 30(2):136-145, 2008.
+       https://doi.org/10.1016/j.socnet.2007.11.001
+    """
+    b = dict.fromkeys(G, 0.0)  # b[v]=0 for v in G
+    for s in sources:
+        # single source shortest paths
+        if weight is None:  # use BFS
+            S, P, sigma, _ = shortest_path(G, s)
+        else:  # use Dijkstra's algorithm
+            S, P, sigma, _ = dijkstra(G, s, weight)
+        b = _accumulate_subset(b, S, P, sigma, s, targets)
+    b = _rescale(b, len(G), normalized=normalized, directed=G.is_directed())
+    return b
+
+
+def edge_betweenness_centrality_subset(
+    G, sources, targets, normalized=False, weight=None
+):
+    r"""Compute betweenness centrality for edges for a subset of nodes.
+
+    .. math::
+
+       c_B(v) =\sum_{s\in S,t \in T} \frac{\sigma(s, t|e)}{\sigma(s, t)}
+
+    where $S$ is the set of sources, $T$ is the set of targets,
+    $\sigma(s, t)$ is the number of shortest $(s, t)$-paths,
+    and $\sigma(s, t|e)$ is the number of those paths
+    passing through edge $e$ [2]_.
+
+    Parameters
+    ----------
+    G : graph
+      A networkx graph.
+
+    sources: list of nodes
+      Nodes to use as sources for shortest paths in betweenness
+
+    targets: list of nodes
+      Nodes to use as targets for shortest paths in betweenness
+
+    normalized : bool, optional
+      If True the betweenness values are normalized by `2/(n(n-1))`
+      for graphs, and `1/(n(n-1))` for directed graphs where `n`
+      is the number of nodes in G.
+
+    weight : None or string, optional (default=None)
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+      Weights are used to calculate weighted shortest paths, so they are
+      interpreted as distances.
+
+    Returns
+    -------
+    edges : dictionary
+       Dictionary of edges with Betweenness centrality as the value.
+
+    See Also
+    --------
+    betweenness_centrality
+    edge_load
+
+    Notes
+    -----
+    The basic algorithm is from [1]_.
+
+    For weighted graphs the edge weights must be greater than zero.
+    Zero edge weights can produce an infinite number of equal length
+    paths between pairs of nodes.
+
+    The normalization might seem a little strange but it is the same
+    as in edge_betweenness_centrality() and is designed to make
+    edge_betweenness_centrality(G) be the same as
+    edge_betweenness_centrality_subset(G,sources=G.nodes(),targets=G.nodes()).
+
+    References
+    ----------
+    .. [1] Ulrik Brandes, A Faster Algorithm for Betweenness Centrality.
+       Journal of Mathematical Sociology 25(2):163-177, 2001.
+       https://doi.org/10.1080/0022250X.2001.9990249
+    .. [2] Ulrik Brandes: On Variants of Shortest-Path Betweenness
+       Centrality and their Generic Computation.
+       Social Networks 30(2):136-145, 2008.
+       https://doi.org/10.1016/j.socnet.2007.11.001
+    """
+    b = dict.fromkeys(G, 0.0)  # b[v]=0 for v in G
+    b.update(dict.fromkeys(G.edges(), 0.0))  # b[e] for e in G.edges()
+    for s in sources:
+        # single source shortest paths
+        if weight is None:  # use BFS
+            S, P, sigma, _ = shortest_path(G, s)
+        else:  # use Dijkstra's algorithm
+            S, P, sigma, _ = dijkstra(G, s, weight)
+        b = _accumulate_edges_subset(b, S, P, sigma, s, targets)
+    for n in G:  # remove nodes to only return edges
+        del b[n]
+    b = _rescale_e(b, len(G), normalized=normalized, directed=G.is_directed())
+    if G.is_multigraph():
+        b = _add_edge_keys(G, b, weight=weight)
+    return b
+
+
+# obsolete name
+def betweenness_centrality_source(G, normalized=True, weight=None, sources=None):
+    msg = "betweenness_centrality_source --> betweenness_centrality_subset"
+    warnings.warn(msg, DeprecationWarning)
+    if sources is None:
+        sources = G.nodes()
+    targets = list(G)
+    return betweenness_centrality_subset(G, sources, targets, normalized, weight)
+
+
+def _accumulate_subset(betweenness, S, P, sigma, s, targets):
+    delta = dict.fromkeys(S, 0.0)
+    target_set = set(targets) - {s}
+    while S:
+        w = S.pop()
+        if w in target_set:
+            coeff = (delta[w] + 1.0) / sigma[w]
+        else:
+            coeff = delta[w] / sigma[w]
+        for v in P[w]:
+            delta[v] += sigma[v] * coeff
+        if w != s:
+            betweenness[w] += delta[w]
+    return betweenness
+
+
+def _accumulate_edges_subset(betweenness, S, P, sigma, s, targets):
+    """edge_betweenness_centrality_subset helper."""
+    delta = dict.fromkeys(S, 0)
+    target_set = set(targets)
+    while S:
+        w = S.pop()
+        for v in P[w]:
+            if w in target_set:
+                c = (sigma[v] / sigma[w]) * (1.0 + delta[w])
+            else:
+                c = delta[w] / len(P[w])
+            if (v, w) not in betweenness:
+                betweenness[(w, v)] += c
+            else:
+                betweenness[(v, w)] += c
+            delta[v] += c
+        if w != s:
+            betweenness[w] += delta[w]
+    return betweenness
+
+
+def _rescale(betweenness, n, normalized, directed=False):
+    """betweenness_centrality_subset helper."""
+    if normalized:
+        if n <= 2:
+            scale = None  # no normalization b=0 for all nodes
+        else:
+            scale = 1.0 / ((n - 1) * (n - 2))
+    else:  # rescale by 2 for undirected graphs
+        if not directed:
+            scale = 0.5
+        else:
+            scale = None
+    if scale is not None:
+        for v in betweenness:
+            betweenness[v] *= scale
+    return betweenness
+
+
+def _rescale_e(betweenness, n, normalized, directed=False):
+    """edge_betweenness_centrality_subset helper."""
+    if normalized:
+        if n <= 1:
+            scale = None  # no normalization b=0 for all nodes
+        else:
+            scale = 1.0 / (n * (n - 1))
+    else:  # rescale by 2 for undirected graphs
+        if not directed:
+            scale = 0.5
+        else:
+            scale = None
+    if scale is not None:
+        for v in betweenness:
+            betweenness[v] *= scale
+    return betweenness
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/closeness.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/closeness.py
new file mode 100644
index 0000000..4fc2caa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/closeness.py
@@ -0,0 +1,279 @@
+"""
+Closeness centrality measures.
+"""
+import functools
+
+import networkx as nx
+from networkx.exception import NetworkXError
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = ["closeness_centrality", "incremental_closeness_centrality"]
+
+
+def closeness_centrality(G, u=None, distance=None, wf_improved=True):
+    r"""Compute closeness centrality for nodes.
+
+    Closeness centrality [1]_ of a node `u` is the reciprocal of the
+    average shortest path distance to `u` over all `n-1` reachable nodes.
+
+    .. math::
+
+        C(u) = \frac{n - 1}{\sum_{v=1}^{n-1} d(v, u)},
+
+    where `d(v, u)` is the shortest-path distance between `v` and `u`,
+    and `n-1` is the number of nodes reachable from `u`. Notice that the
+    closeness distance function computes the incoming distance to `u`
+    for directed graphs. To use outward distance, act on `G.reverse()`.
+
+    Notice that higher values of closeness indicate higher centrality.
+
+    Wasserman and Faust propose an improved formula for graphs with
+    more than one connected component. The result is "a ratio of the
+    fraction of actors in the group who are reachable, to the average
+    distance" from the reachable actors [2]_. You might think this
+    scale factor is inverted but it is not. As is, nodes from small
+    components receive a smaller closeness value. Letting `N` denote
+    the number of nodes in the graph,
+
+    .. math::
+
+        C_{WF}(u) = \frac{n-1}{N-1} \frac{n - 1}{\sum_{v=1}^{n-1} d(v, u)},
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    u : node, optional
+      Return only the value for node u
+
+    distance : edge attribute key, optional (default=None)
+      Use the specified edge attribute as the edge distance in shortest
+      path calculations.  If `None` (the default) all edges have a distance of 1.
+      Absent edge attributes are assigned a distance of 1. Note that no check
+      is performed to ensure that edges have the provided attribute.
+
+    wf_improved : bool, optional (default=True)
+      If True, scale by the fraction of nodes reachable. This gives the
+      Wasserman and Faust improved formula. For single component graphs
+      it is the same as the original formula.
+
+    Returns
+    -------
+    nodes : dictionary
+      Dictionary of nodes with closeness centrality as the value.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3)])
+    >>> nx.closeness_centrality(G)
+    {0: 1.0, 1: 1.0, 2: 0.75, 3: 0.75}
+
+    See Also
+    --------
+    betweenness_centrality, load_centrality, eigenvector_centrality,
+    degree_centrality, incremental_closeness_centrality
+
+    Notes
+    -----
+    The closeness centrality is normalized to `(n-1)/(|G|-1)` where
+    `n` is the number of nodes in the connected part of graph
+    containing the node.  If the graph is not completely connected,
+    this algorithm computes the closeness centrality for each
+    connected part separately scaled by that parts size.
+
+    If the 'distance' keyword is set to an edge attribute key then the
+    shortest-path length will be computed using Dijkstra's algorithm with
+    that edge attribute as the edge weight.
+
+    The closeness centrality uses *inward* distance to a node, not outward.
+    If you want to use outword distances apply the function to `G.reverse()`
+
+    In NetworkX 2.2 and earlier a bug caused Dijkstra's algorithm to use the
+    outward distance rather than the inward distance. If you use a 'distance'
+    keyword and a DiGraph, your results will change between v2.2 and v2.3.
+
+    References
+    ----------
+    .. [1] Linton C. Freeman: Centrality in networks: I.
+       Conceptual clarification. Social Networks 1:215-239, 1979.
+       https://doi.org/10.1016/0378-8733(78)90021-7
+    .. [2] pg. 201 of Wasserman, S. and Faust, K.,
+       Social Network Analysis: Methods and Applications, 1994,
+       Cambridge University Press.
+    """
+    if G.is_directed():
+        G = G.reverse()  # create a reversed graph view
+
+    if distance is not None:
+        # use Dijkstra's algorithm with specified attribute as edge weight
+        path_length = functools.partial(
+            nx.single_source_dijkstra_path_length, weight=distance
+        )
+    else:
+        path_length = nx.single_source_shortest_path_length
+
+    if u is None:
+        nodes = G.nodes
+    else:
+        nodes = [u]
+    closeness_dict = {}
+    for n in nodes:
+        sp = path_length(G, n)
+        totsp = sum(sp.values())
+        len_G = len(G)
+        _closeness_centrality = 0.0
+        if totsp > 0.0 and len_G > 1:
+            _closeness_centrality = (len(sp) - 1.0) / totsp
+            # normalize to number of nodes-1 in connected part
+            if wf_improved:
+                s = (len(sp) - 1.0) / (len_G - 1)
+                _closeness_centrality *= s
+        closeness_dict[n] = _closeness_centrality
+    if u is not None:
+        return closeness_dict[u]
+    return closeness_dict
+
+
+@not_implemented_for("directed")
+def incremental_closeness_centrality(
+    G, edge, prev_cc=None, insertion=True, wf_improved=True
+):
+    r"""Incremental closeness centrality for nodes.
+
+    Compute closeness centrality for nodes using level-based work filtering
+    as described in Incremental Algorithms for Closeness Centrality by Sariyuce et al.
+
+    Level-based work filtering detects unnecessary updates to the closeness
+    centrality and filters them out.
+
+    ---
+    From "Incremental Algorithms for Closeness Centrality":
+
+    Theorem 1: Let :math:`G = (V, E)` be a graph and u and v be two vertices in V
+    such that there is no edge (u, v) in E. Let :math:`G' = (V, E \cup uv)`
+    Then :math:`cc[s] = cc'[s]` if and only if :math:`\left|dG(s, u) - dG(s, v)\right| \leq 1`.
+
+    Where :math:`dG(u, v)` denotes the length of the shortest path between
+    two vertices u, v in a graph G, cc[s] is the closeness centrality for a
+    vertex s in V, and cc'[s] is the closeness centrality for a
+    vertex s in V, with the (u, v) edge added.
+    ---
+
+    We use Theorem 1 to filter out updates when adding or removing an edge.
+    When adding an edge (u, v), we compute the shortest path lengths from all
+    other nodes to u and to v before the node is added. When removing an edge,
+    we compute the shortest path lengths after the edge is removed. Then we
+    apply Theorem 1 to use previously computed closeness centrality for nodes
+    where :math:`\left|dG(s, u) - dG(s, v)\right| \leq 1`. This works only for
+    undirected, unweighted graphs; the distance argument is not supported.
+
+    Closeness centrality [1]_ of a node `u` is the reciprocal of the
+    sum of the shortest path distances from `u` to all `n-1` other nodes.
+    Since the sum of distances depends on the number of nodes in the
+    graph, closeness is normalized by the sum of minimum possible
+    distances `n-1`.
+
+    .. math::
+
+        C(u) = \frac{n - 1}{\sum_{v=1}^{n-1} d(v, u)},
+
+    where `d(v, u)` is the shortest-path distance between `v` and `u`,
+    and `n` is the number of nodes in the graph.
+
+    Notice that higher values of closeness indicate higher centrality.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    edge : tuple
+      The modified edge (u, v) in the graph.
+
+    prev_cc : dictionary
+      The previous closeness centrality for all nodes in the graph.
+
+    insertion : bool, optional
+      If True (default) the edge was inserted, otherwise it was deleted from the graph.
+
+    wf_improved : bool, optional (default=True)
+      If True, scale by the fraction of nodes reachable. This gives the
+      Wasserman and Faust improved formula. For single component graphs
+      it is the same as the original formula.
+
+    Returns
+    -------
+    nodes : dictionary
+      Dictionary of nodes with closeness centrality as the value.
+
+    See Also
+    --------
+    betweenness_centrality, load_centrality, eigenvector_centrality,
+    degree_centrality, closeness_centrality
+
+    Notes
+    -----
+    The closeness centrality is normalized to `(n-1)/(|G|-1)` where
+    `n` is the number of nodes in the connected part of graph
+    containing the node.  If the graph is not completely connected,
+    this algorithm computes the closeness centrality for each
+    connected part separately.
+
+    References
+    ----------
+    .. [1] Freeman, L.C., 1979. Centrality in networks: I.
+       Conceptual clarification.  Social Networks 1, 215--239.
+       https://doi.org/10.1016/0378-8733(78)90021-7
+    .. [2] Sariyuce, A.E. ; Kaya, K. ; Saule, E. ; Catalyiirek, U.V. Incremental
+       Algorithms for Closeness Centrality. 2013 IEEE International Conference on Big Data
+       http://sariyuce.com/papers/bigdata13.pdf
+    """
+    if prev_cc is not None and set(prev_cc.keys()) != set(G.nodes()):
+        raise NetworkXError("prev_cc and G do not have the same nodes")
+
+    # Unpack edge
+    (u, v) = edge
+    path_length = nx.single_source_shortest_path_length
+
+    if insertion:
+        # For edge insertion, we want shortest paths before the edge is inserted
+        du = path_length(G, u)
+        dv = path_length(G, v)
+
+        G.add_edge(u, v)
+    else:
+        G.remove_edge(u, v)
+
+        # For edge removal, we want shortest paths after the edge is removed
+        du = path_length(G, u)
+        dv = path_length(G, v)
+
+    if prev_cc is None:
+        return nx.closeness_centrality(G)
+
+    nodes = G.nodes()
+    closeness_dict = {}
+    for n in nodes:
+        if n in du and n in dv and abs(du[n] - dv[n]) <= 1:
+            closeness_dict[n] = prev_cc[n]
+        else:
+            sp = path_length(G, n)
+            totsp = sum(sp.values())
+            len_G = len(G)
+            _closeness_centrality = 0.0
+            if totsp > 0.0 and len_G > 1:
+                _closeness_centrality = (len(sp) - 1.0) / totsp
+                # normalize to number of nodes-1 in connected part
+                if wf_improved:
+                    s = (len(sp) - 1.0) / (len_G - 1)
+                    _closeness_centrality *= s
+            closeness_dict[n] = _closeness_centrality
+
+    # Leave the graph as we found it
+    if insertion:
+        G.remove_edge(u, v)
+    else:
+        G.add_edge(u, v)
+
+    return closeness_dict
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/current_flow_betweenness.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/current_flow_betweenness.py
new file mode 100644
index 0000000..a18b81c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/current_flow_betweenness.py
@@ -0,0 +1,340 @@
+"""Current-flow betweenness centrality measures."""
+import networkx as nx
+from networkx.algorithms.centrality.flow_matrix import (
+    CGInverseLaplacian,
+    FullInverseLaplacian,
+    SuperLUInverseLaplacian,
+    flow_matrix_row,
+)
+from networkx.utils import (
+    not_implemented_for,
+    py_random_state,
+    reverse_cuthill_mckee_ordering,
+)
+
+__all__ = [
+    "current_flow_betweenness_centrality",
+    "approximate_current_flow_betweenness_centrality",
+    "edge_current_flow_betweenness_centrality",
+]
+
+
+@py_random_state(7)
+@not_implemented_for("directed")
+def approximate_current_flow_betweenness_centrality(
+    G,
+    normalized=True,
+    weight=None,
+    dtype=float,
+    solver="full",
+    epsilon=0.5,
+    kmax=10000,
+    seed=None,
+):
+    r"""Compute the approximate current-flow betweenness centrality for nodes.
+
+    Approximates the current-flow betweenness centrality within absolute
+    error of epsilon with high probability [1]_.
+
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    normalized : bool, optional (default=True)
+      If True the betweenness values are normalized by 2/[(n-1)(n-2)] where
+      n is the number of nodes in G.
+
+    weight : string or None, optional (default=None)
+      Key for edge data used as the edge weight.
+      If None, then use 1 as each edge weight.
+      The weight reflects the capacity or the strength of the
+      edge.
+
+    dtype : data type (float)
+      Default data type for internal matrices.
+      Set to np.float32 for lower memory consumption.
+
+    solver : string (default='full')
+       Type of linear solver to use for computing the flow matrix.
+       Options are "full" (uses most memory), "lu" (recommended), and
+       "cg" (uses least memory).
+
+    epsilon: float
+        Absolute error tolerance.
+
+    kmax: int
+       Maximum number of sample node pairs to use for approximation.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with betweenness centrality as the value.
+
+    See Also
+    --------
+    current_flow_betweenness_centrality
+
+    Notes
+    -----
+    The running time is $O((1/\epsilon^2)m{\sqrt k} \log n)$
+    and the space required is $O(m)$ for $n$ nodes and $m$ edges.
+
+    If the edges have a 'weight' attribute they will be used as
+    weights in this algorithm.  Unspecified weights are set to 1.
+
+    References
+    ----------
+    .. [1] Ulrik Brandes and Daniel Fleischer:
+       Centrality Measures Based on Current Flow.
+       Proc. 22nd Symp. Theoretical Aspects of Computer Science (STACS '05).
+       LNCS 3404, pp. 533-544. Springer-Verlag, 2005.
+       https://doi.org/10.1007/978-3-540-31856-9_44
+    """
+    import numpy as np
+
+    if not nx.is_connected(G):
+        raise nx.NetworkXError("Graph not connected.")
+    solvername = {
+        "full": FullInverseLaplacian,
+        "lu": SuperLUInverseLaplacian,
+        "cg": CGInverseLaplacian,
+    }
+    n = G.number_of_nodes()
+    ordering = list(reverse_cuthill_mckee_ordering(G))
+    # make a copy with integer labels according to rcm ordering
+    # this could be done without a copy if we really wanted to
+    H = nx.relabel_nodes(G, dict(zip(ordering, range(n))))
+    L = nx.laplacian_matrix(H, nodelist=range(n), weight=weight).asformat("csc")
+    L = L.astype(dtype)
+    C = solvername[solver](L, dtype=dtype)  # initialize solver
+    betweenness = dict.fromkeys(H, 0.0)
+    nb = (n - 1.0) * (n - 2.0)  # normalization factor
+    cstar = n * (n - 1) / nb
+    l = 1  # parameter in approximation, adjustable
+    k = l * int(np.ceil((cstar / epsilon) ** 2 * np.log(n)))
+    if k > kmax:
+        msg = f"Number random pairs k>kmax ({k}>{kmax}) "
+        raise nx.NetworkXError(msg, "Increase kmax or epsilon")
+    cstar2k = cstar / (2 * k)
+    for _ in range(k):
+        s, t = pair = seed.sample(range(n), 2)
+        b = np.zeros(n, dtype=dtype)
+        b[s] = 1
+        b[t] = -1
+        p = C.solve(b)
+        for v in H:
+            if v in pair:
+                continue
+            for nbr in H[v]:
+                w = H[v][nbr].get(weight, 1.0)
+                betweenness[v] += w * np.abs(p[v] - p[nbr]) * cstar2k
+    if normalized:
+        factor = 1.0
+    else:
+        factor = nb / 2.0
+    # remap to original node names and "unnormalize" if required
+    return {ordering[k]: v * factor for k, v in betweenness.items()}
+
+
+@not_implemented_for("directed")
+def current_flow_betweenness_centrality(
+    G, normalized=True, weight=None, dtype=float, solver="full"
+):
+    r"""Compute current-flow betweenness centrality for nodes.
+
+    Current-flow betweenness centrality uses an electrical current
+    model for information spreading in contrast to betweenness
+    centrality which uses shortest paths.
+
+    Current-flow betweenness centrality is also known as
+    random-walk betweenness centrality [2]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    normalized : bool, optional (default=True)
+      If True the betweenness values are normalized by 2/[(n-1)(n-2)] where
+      n is the number of nodes in G.
+
+    weight : string or None, optional (default=None)
+      Key for edge data used as the edge weight.
+      If None, then use 1 as each edge weight.
+      The weight reflects the capacity or the strength of the
+      edge.
+
+    dtype : data type (float)
+      Default data type for internal matrices.
+      Set to np.float32 for lower memory consumption.
+
+    solver : string (default='full')
+       Type of linear solver to use for computing the flow matrix.
+       Options are "full" (uses most memory), "lu" (recommended), and
+       "cg" (uses least memory).
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with betweenness centrality as the value.
+
+    See Also
+    --------
+    approximate_current_flow_betweenness_centrality
+    betweenness_centrality
+    edge_betweenness_centrality
+    edge_current_flow_betweenness_centrality
+
+    Notes
+    -----
+    Current-flow betweenness can be computed in  $O(I(n-1)+mn \log n)$
+    time [1]_, where $I(n-1)$ is the time needed to compute the
+    inverse Laplacian.  For a full matrix this is $O(n^3)$ but using
+    sparse methods you can achieve $O(nm{\sqrt k})$ where $k$ is the
+    Laplacian matrix condition number.
+
+    The space required is $O(nw)$ where $w$ is the width of the sparse
+    Laplacian matrix.  Worse case is $w=n$ for $O(n^2)$.
+
+    If the edges have a 'weight' attribute they will be used as
+    weights in this algorithm.  Unspecified weights are set to 1.
+
+    References
+    ----------
+    .. [1] Centrality Measures Based on Current Flow.
+       Ulrik Brandes and Daniel Fleischer,
+       Proc. 22nd Symp. Theoretical Aspects of Computer Science (STACS '05).
+       LNCS 3404, pp. 533-544. Springer-Verlag, 2005.
+       https://doi.org/10.1007/978-3-540-31856-9_44
+
+    .. [2] A measure of betweenness centrality based on random walks,
+       M. E. J. Newman, Social Networks 27, 39-54 (2005).
+    """
+    if not nx.is_connected(G):
+        raise nx.NetworkXError("Graph not connected.")
+    n = G.number_of_nodes()
+    ordering = list(reverse_cuthill_mckee_ordering(G))
+    # make a copy with integer labels according to rcm ordering
+    # this could be done without a copy if we really wanted to
+    H = nx.relabel_nodes(G, dict(zip(ordering, range(n))))
+    betweenness = dict.fromkeys(H, 0.0)  # b[v]=0 for v in H
+    for row, (s, t) in flow_matrix_row(H, weight=weight, dtype=dtype, solver=solver):
+        pos = dict(zip(row.argsort()[::-1], range(n)))
+        for i in range(n):
+            betweenness[s] += (i - pos[i]) * row[i]
+            betweenness[t] += (n - i - 1 - pos[i]) * row[i]
+    if normalized:
+        nb = (n - 1.0) * (n - 2.0)  # normalization factor
+    else:
+        nb = 2.0
+    for v in H:
+        betweenness[v] = float((betweenness[v] - v) * 2.0 / nb)
+    return {ordering[k]: v for k, v in betweenness.items()}
+
+
+@not_implemented_for("directed")
+def edge_current_flow_betweenness_centrality(
+    G, normalized=True, weight=None, dtype=float, solver="full"
+):
+    r"""Compute current-flow betweenness centrality for edges.
+
+    Current-flow betweenness centrality uses an electrical current
+    model for information spreading in contrast to betweenness
+    centrality which uses shortest paths.
+
+    Current-flow betweenness centrality is also known as
+    random-walk betweenness centrality [2]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    normalized : bool, optional (default=True)
+      If True the betweenness values are normalized by 2/[(n-1)(n-2)] where
+      n is the number of nodes in G.
+
+    weight : string or None, optional (default=None)
+      Key for edge data used as the edge weight.
+      If None, then use 1 as each edge weight.
+      The weight reflects the capacity or the strength of the
+      edge.
+
+    dtype : data type (default=float)
+      Default data type for internal matrices.
+      Set to np.float32 for lower memory consumption.
+
+    solver : string (default='full')
+       Type of linear solver to use for computing the flow matrix.
+       Options are "full" (uses most memory), "lu" (recommended), and
+       "cg" (uses least memory).
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of edge tuples with betweenness centrality as the value.
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support DiGraphs.
+        If the input graph is an instance of DiGraph class, NetworkXError
+        is raised.
+
+    See Also
+    --------
+    betweenness_centrality
+    edge_betweenness_centrality
+    current_flow_betweenness_centrality
+
+    Notes
+    -----
+    Current-flow betweenness can be computed in $O(I(n-1)+mn \log n)$
+    time [1]_, where $I(n-1)$ is the time needed to compute the
+    inverse Laplacian.  For a full matrix this is $O(n^3)$ but using
+    sparse methods you can achieve $O(nm{\sqrt k})$ where $k$ is the
+    Laplacian matrix condition number.
+
+    The space required is $O(nw)$ where $w$ is the width of the sparse
+    Laplacian matrix.  Worse case is $w=n$ for $O(n^2)$.
+
+    If the edges have a 'weight' attribute they will be used as
+    weights in this algorithm.  Unspecified weights are set to 1.
+
+    References
+    ----------
+    .. [1] Centrality Measures Based on Current Flow.
+       Ulrik Brandes and Daniel Fleischer,
+       Proc. 22nd Symp. Theoretical Aspects of Computer Science (STACS '05).
+       LNCS 3404, pp. 533-544. Springer-Verlag, 2005.
+       https://doi.org/10.1007/978-3-540-31856-9_44
+
+    .. [2] A measure of betweenness centrality based on random walks,
+       M. E. J. Newman, Social Networks 27, 39-54 (2005).
+    """
+    if not nx.is_connected(G):
+        raise nx.NetworkXError("Graph not connected.")
+    n = G.number_of_nodes()
+    ordering = list(reverse_cuthill_mckee_ordering(G))
+    # make a copy with integer labels according to rcm ordering
+    # this could be done without a copy if we really wanted to
+    H = nx.relabel_nodes(G, dict(zip(ordering, range(n))))
+    edges = (tuple(sorted((u, v))) for u, v in H.edges())
+    betweenness = dict.fromkeys(edges, 0.0)
+    if normalized:
+        nb = (n - 1.0) * (n - 2.0)  # normalization factor
+    else:
+        nb = 2.0
+    for row, (e) in flow_matrix_row(H, weight=weight, dtype=dtype, solver=solver):
+        pos = dict(zip(row.argsort()[::-1], range(1, n + 1)))
+        for i in range(n):
+            betweenness[e] += (i + 1 - pos[i]) * row[i]
+            betweenness[e] += (n - i - pos[i]) * row[i]
+        betweenness[e] /= nb
+    return {(ordering[s], ordering[t]): v for (s, t), v in betweenness.items()}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/current_flow_betweenness_subset.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/current_flow_betweenness_subset.py
new file mode 100644
index 0000000..37e5a78
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/current_flow_betweenness_subset.py
@@ -0,0 +1,224 @@
+"""Current-flow betweenness centrality measures for subsets of nodes."""
+import networkx as nx
+from networkx.algorithms.centrality.flow_matrix import flow_matrix_row
+from networkx.utils import not_implemented_for, reverse_cuthill_mckee_ordering
+
+__all__ = [
+    "current_flow_betweenness_centrality_subset",
+    "edge_current_flow_betweenness_centrality_subset",
+]
+
+
+@not_implemented_for("directed")
+def current_flow_betweenness_centrality_subset(
+    G, sources, targets, normalized=True, weight=None, dtype=float, solver="lu"
+):
+    r"""Compute current-flow betweenness centrality for subsets of nodes.
+
+    Current-flow betweenness centrality uses an electrical current
+    model for information spreading in contrast to betweenness
+    centrality which uses shortest paths.
+
+    Current-flow betweenness centrality is also known as
+    random-walk betweenness centrality [2]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    sources: list of nodes
+      Nodes to use as sources for current
+
+    targets: list of nodes
+      Nodes to use as sinks for current
+
+    normalized : bool, optional (default=True)
+      If True the betweenness values are normalized by b=b/(n-1)(n-2) where
+      n is the number of nodes in G.
+
+    weight : string or None, optional (default=None)
+      Key for edge data used as the edge weight.
+      If None, then use 1 as each edge weight.
+      The weight reflects the capacity or the strength of the
+      edge.
+
+    dtype: data type (float)
+      Default data type for internal matrices.
+      Set to np.float32 for lower memory consumption.
+
+    solver: string (default='lu')
+       Type of linear solver to use for computing the flow matrix.
+       Options are "full" (uses most memory), "lu" (recommended), and
+       "cg" (uses least memory).
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with betweenness centrality as the value.
+
+    See Also
+    --------
+    approximate_current_flow_betweenness_centrality
+    betweenness_centrality
+    edge_betweenness_centrality
+    edge_current_flow_betweenness_centrality
+
+    Notes
+    -----
+    Current-flow betweenness can be computed in $O(I(n-1)+mn \log n)$
+    time [1]_, where $I(n-1)$ is the time needed to compute the
+    inverse Laplacian.  For a full matrix this is $O(n^3)$ but using
+    sparse methods you can achieve $O(nm{\sqrt k})$ where $k$ is the
+    Laplacian matrix condition number.
+
+    The space required is $O(nw)$ where $w$ is the width of the sparse
+    Laplacian matrix.  Worse case is $w=n$ for $O(n^2)$.
+
+    If the edges have a 'weight' attribute they will be used as
+    weights in this algorithm.  Unspecified weights are set to 1.
+
+    References
+    ----------
+    .. [1] Centrality Measures Based on Current Flow.
+       Ulrik Brandes and Daniel Fleischer,
+       Proc. 22nd Symp. Theoretical Aspects of Computer Science (STACS '05).
+       LNCS 3404, pp. 533-544. Springer-Verlag, 2005.
+       https://doi.org/10.1007/978-3-540-31856-9_44
+
+    .. [2] A measure of betweenness centrality based on random walks,
+       M. E. J. Newman, Social Networks 27, 39-54 (2005).
+    """
+    import numpy as np
+
+    from networkx.utils import reverse_cuthill_mckee_ordering
+
+    if not nx.is_connected(G):
+        raise nx.NetworkXError("Graph not connected.")
+    n = G.number_of_nodes()
+    ordering = list(reverse_cuthill_mckee_ordering(G))
+    # make a copy with integer labels according to rcm ordering
+    # this could be done without a copy if we really wanted to
+    mapping = dict(zip(ordering, range(n)))
+    H = nx.relabel_nodes(G, mapping)
+    betweenness = dict.fromkeys(H, 0.0)  # b[v]=0 for v in H
+    for row, (s, t) in flow_matrix_row(H, weight=weight, dtype=dtype, solver=solver):
+        for ss in sources:
+            i = mapping[ss]
+            for tt in targets:
+                j = mapping[tt]
+                betweenness[s] += 0.5 * np.abs(row[i] - row[j])
+                betweenness[t] += 0.5 * np.abs(row[i] - row[j])
+    if normalized:
+        nb = (n - 1.0) * (n - 2.0)  # normalization factor
+    else:
+        nb = 2.0
+    for v in H:
+        betweenness[v] = betweenness[v] / nb + 1.0 / (2 - n)
+    return {ordering[k]: v for k, v in betweenness.items()}
+
+
+@not_implemented_for("directed")
+def edge_current_flow_betweenness_centrality_subset(
+    G, sources, targets, normalized=True, weight=None, dtype=float, solver="lu"
+):
+    r"""Compute current-flow betweenness centrality for edges using subsets
+    of nodes.
+
+    Current-flow betweenness centrality uses an electrical current
+    model for information spreading in contrast to betweenness
+    centrality which uses shortest paths.
+
+    Current-flow betweenness centrality is also known as
+    random-walk betweenness centrality [2]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    sources: list of nodes
+      Nodes to use as sources for current
+
+    targets: list of nodes
+      Nodes to use as sinks for current
+
+    normalized : bool, optional (default=True)
+      If True the betweenness values are normalized by b=b/(n-1)(n-2) where
+      n is the number of nodes in G.
+
+    weight : string or None, optional (default=None)
+      Key for edge data used as the edge weight.
+      If None, then use 1 as each edge weight.
+      The weight reflects the capacity or the strength of the
+      edge.
+
+    dtype: data type (float)
+      Default data type for internal matrices.
+      Set to np.float32 for lower memory consumption.
+
+    solver: string (default='lu')
+       Type of linear solver to use for computing the flow matrix.
+       Options are "full" (uses most memory), "lu" (recommended), and
+       "cg" (uses least memory).
+
+    Returns
+    -------
+    nodes : dict
+       Dictionary of edge tuples with betweenness centrality as the value.
+
+    See Also
+    --------
+    betweenness_centrality
+    edge_betweenness_centrality
+    current_flow_betweenness_centrality
+
+    Notes
+    -----
+    Current-flow betweenness can be computed in $O(I(n-1)+mn \log n)$
+    time [1]_, where $I(n-1)$ is the time needed to compute the
+    inverse Laplacian.  For a full matrix this is $O(n^3)$ but using
+    sparse methods you can achieve $O(nm{\sqrt k})$ where $k$ is the
+    Laplacian matrix condition number.
+
+    The space required is $O(nw)$ where $w$ is the width of the sparse
+    Laplacian matrix.  Worse case is $w=n$ for $O(n^2)$.
+
+    If the edges have a 'weight' attribute they will be used as
+    weights in this algorithm.  Unspecified weights are set to 1.
+
+    References
+    ----------
+    .. [1] Centrality Measures Based on Current Flow.
+       Ulrik Brandes and Daniel Fleischer,
+       Proc. 22nd Symp. Theoretical Aspects of Computer Science (STACS '05).
+       LNCS 3404, pp. 533-544. Springer-Verlag, 2005.
+       https://doi.org/10.1007/978-3-540-31856-9_44
+
+    .. [2] A measure of betweenness centrality based on random walks,
+       M. E. J. Newman, Social Networks 27, 39-54 (2005).
+    """
+    import numpy as np
+
+    if not nx.is_connected(G):
+        raise nx.NetworkXError("Graph not connected.")
+    n = G.number_of_nodes()
+    ordering = list(reverse_cuthill_mckee_ordering(G))
+    # make a copy with integer labels according to rcm ordering
+    # this could be done without a copy if we really wanted to
+    mapping = dict(zip(ordering, range(n)))
+    H = nx.relabel_nodes(G, mapping)
+    edges = (tuple(sorted((u, v))) for u, v in H.edges())
+    betweenness = dict.fromkeys(edges, 0.0)
+    if normalized:
+        nb = (n - 1.0) * (n - 2.0)  # normalization factor
+    else:
+        nb = 2.0
+    for row, (e) in flow_matrix_row(H, weight=weight, dtype=dtype, solver=solver):
+        for ss in sources:
+            i = mapping[ss]
+            for tt in targets:
+                j = mapping[tt]
+                betweenness[e] += 0.5 * np.abs(row[i] - row[j])
+        betweenness[e] /= nb
+    return {(ordering[s], ordering[t]): v for (s, t), v in betweenness.items()}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/current_flow_closeness.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/current_flow_closeness.py
new file mode 100644
index 0000000..b6b64c8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/current_flow_closeness.py
@@ -0,0 +1,96 @@
+"""Current-flow closeness centrality measures."""
+import networkx as nx
+from networkx.algorithms.centrality.flow_matrix import (
+    CGInverseLaplacian,
+    FullInverseLaplacian,
+    SuperLUInverseLaplacian,
+)
+from networkx.utils import not_implemented_for, reverse_cuthill_mckee_ordering
+
+__all__ = ["current_flow_closeness_centrality", "information_centrality"]
+
+
+@not_implemented_for("directed")
+def current_flow_closeness_centrality(G, weight=None, dtype=float, solver="lu"):
+    """Compute current-flow closeness centrality for nodes.
+
+    Current-flow closeness centrality is variant of closeness
+    centrality based on effective resistance between nodes in
+    a network. This metric is also known as information centrality.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.
+
+    weight : None or string, optional (default=None)
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+      The weight reflects the capacity or the strength of the
+      edge.
+
+    dtype: data type (default=float)
+      Default data type for internal matrices.
+      Set to np.float32 for lower memory consumption.
+
+    solver: string (default='lu')
+       Type of linear solver to use for computing the flow matrix.
+       Options are "full" (uses most memory), "lu" (recommended), and
+       "cg" (uses least memory).
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with current flow closeness centrality as the value.
+
+    See Also
+    --------
+    closeness_centrality
+
+    Notes
+    -----
+    The algorithm is from Brandes [1]_.
+
+    See also [2]_ for the original definition of information centrality.
+
+    References
+    ----------
+    .. [1] Ulrik Brandes and Daniel Fleischer,
+       Centrality Measures Based on Current Flow.
+       Proc. 22nd Symp. Theoretical Aspects of Computer Science (STACS '05).
+       LNCS 3404, pp. 533-544. Springer-Verlag, 2005.
+       https://doi.org/10.1007/978-3-540-31856-9_44
+
+    .. [2] Karen Stephenson and Marvin Zelen:
+       Rethinking centrality: Methods and examples.
+       Social Networks 11(1):1-37, 1989.
+       https://doi.org/10.1016/0378-8733(89)90016-6
+    """
+    if not nx.is_connected(G):
+        raise nx.NetworkXError("Graph not connected.")
+    solvername = {
+        "full": FullInverseLaplacian,
+        "lu": SuperLUInverseLaplacian,
+        "cg": CGInverseLaplacian,
+    }
+    n = G.number_of_nodes()
+    ordering = list(reverse_cuthill_mckee_ordering(G))
+    # make a copy with integer labels according to rcm ordering
+    # this could be done without a copy if we really wanted to
+    H = nx.relabel_nodes(G, dict(zip(ordering, range(n))))
+    betweenness = dict.fromkeys(H, 0.0)  # b[v]=0 for v in H
+    n = H.number_of_nodes()
+    L = nx.laplacian_matrix(H, nodelist=range(n), weight=weight).asformat("csc")
+    L = L.astype(dtype)
+    C2 = solvername[solver](L, width=1, dtype=dtype)  # initialize solver
+    for v in H:
+        col = C2.get_row(v)
+        for w in H:
+            betweenness[v] += col[v] - 2 * col[w]
+            betweenness[w] += col[v]
+    for v in H:
+        betweenness[v] = 1 / (betweenness[v])
+    return {ordering[k]: v for k, v in betweenness.items()}
+
+
+information_centrality = current_flow_closeness_centrality
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/degree_alg.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/degree_alg.py
new file mode 100644
index 0000000..a7e7b92
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/degree_alg.py
@@ -0,0 +1,127 @@
+"""Degree centrality measures."""
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = ["degree_centrality", "in_degree_centrality", "out_degree_centrality"]
+
+
+def degree_centrality(G):
+    """Compute the degree centrality for nodes.
+
+    The degree centrality for a node v is the fraction of nodes it
+    is connected to.
+
+    Parameters
+    ----------
+    G : graph
+      A networkx graph
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with degree centrality as the value.
+
+    See Also
+    --------
+    betweenness_centrality, load_centrality, eigenvector_centrality
+
+    Notes
+    -----
+    The degree centrality values are normalized by dividing by the maximum
+    possible degree in a simple graph n-1 where n is the number of nodes in G.
+
+    For multigraphs or graphs with self loops the maximum degree might
+    be higher than n-1 and values of degree centrality greater than 1
+    are possible.
+    """
+    if len(G) <= 1:
+        return {n: 1 for n in G}
+
+    s = 1.0 / (len(G) - 1.0)
+    centrality = {n: d * s for n, d in G.degree()}
+    return centrality
+
+
+@not_implemented_for("undirected")
+def in_degree_centrality(G):
+    """Compute the in-degree centrality for nodes.
+
+    The in-degree centrality for a node v is the fraction of nodes its
+    incoming edges are connected to.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph
+
+    Returns
+    -------
+    nodes : dictionary
+        Dictionary of nodes with in-degree centrality as values.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is undirected.
+
+    See Also
+    --------
+    degree_centrality, out_degree_centrality
+
+    Notes
+    -----
+    The degree centrality values are normalized by dividing by the maximum
+    possible degree in a simple graph n-1 where n is the number of nodes in G.
+
+    For multigraphs or graphs with self loops the maximum degree might
+    be higher than n-1 and values of degree centrality greater than 1
+    are possible.
+    """
+    if len(G) <= 1:
+        return {n: 1 for n in G}
+
+    s = 1.0 / (len(G) - 1.0)
+    centrality = {n: d * s for n, d in G.in_degree()}
+    return centrality
+
+
+@not_implemented_for("undirected")
+def out_degree_centrality(G):
+    """Compute the out-degree centrality for nodes.
+
+    The out-degree centrality for a node v is the fraction of nodes its
+    outgoing edges are connected to.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph
+
+    Returns
+    -------
+    nodes : dictionary
+        Dictionary of nodes with out-degree centrality as values.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is undirected.
+
+    See Also
+    --------
+    degree_centrality, in_degree_centrality
+
+    Notes
+    -----
+    The degree centrality values are normalized by dividing by the maximum
+    possible degree in a simple graph n-1 where n is the number of nodes in G.
+
+    For multigraphs or graphs with self loops the maximum degree might
+    be higher than n-1 and values of degree centrality greater than 1
+    are possible.
+    """
+    if len(G) <= 1:
+        return {n: 1 for n in G}
+
+    s = 1.0 / (len(G) - 1.0)
+    centrality = {n: d * s for n, d in G.out_degree()}
+    return centrality
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/dispersion.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/dispersion.py
new file mode 100644
index 0000000..8005670
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/dispersion.py
@@ -0,0 +1,97 @@
+from itertools import combinations
+
+__all__ = ["dispersion"]
+
+
+def dispersion(G, u=None, v=None, normalized=True, alpha=1.0, b=0.0, c=0.0):
+    r"""Calculate dispersion between `u` and `v` in `G`.
+
+    A link between two actors (`u` and `v`) has a high dispersion when their
+    mutual ties (`s` and `t`) are not well connected with each other.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph.
+    u : node, optional
+        The source for the dispersion score (e.g. ego node of the network).
+    v : node, optional
+        The target of the dispersion score if specified.
+    normalized : bool
+        If True (default) normalize by the embededness of the nodes (u and v).
+
+    Returns
+    -------
+    nodes : dictionary
+        If u (v) is specified, returns a dictionary of nodes with dispersion
+        score for all "target" ("source") nodes. If neither u nor v is
+        specified, returns a dictionary of dictionaries for all nodes 'u' in the
+        graph with a dispersion score for each node 'v'.
+
+    Notes
+    -----
+    This implementation follows Lars Backstrom and Jon Kleinberg [1]_. Typical
+    usage would be to run dispersion on the ego network $G_u$ if $u$ were
+    specified.  Running :func:`dispersion` with neither $u$ nor $v$ specified
+    can take some time to complete.
+
+    References
+    ----------
+    .. [1] Romantic Partnerships and the Dispersion of Social Ties:
+        A Network Analysis of Relationship Status on Facebook.
+        Lars Backstrom, Jon Kleinberg.
+        https://arxiv.org/pdf/1310.6753v1.pdf
+
+    """
+
+    def _dispersion(G_u, u, v):
+        """dispersion for all nodes 'v' in a ego network G_u of node 'u'"""
+        u_nbrs = set(G_u[u])
+        ST = {n for n in G_u[v] if n in u_nbrs}
+        set_uv = {u, v}
+        # all possible ties of connections that u and b share
+        possib = combinations(ST, 2)
+        total = 0
+        for (s, t) in possib:
+            # neighbors of s that are in G_u, not including u and v
+            nbrs_s = u_nbrs.intersection(G_u[s]) - set_uv
+            # s and t are not directly connected
+            if t not in nbrs_s:
+                # s and t do not share a connection
+                if nbrs_s.isdisjoint(G_u[t]):
+                    # tick for disp(u, v)
+                    total += 1
+        # neighbors that u and v share
+        embededness = len(ST)
+
+        dispersion_val = total
+        if normalized:
+            dispersion_val = (total + b) ** alpha
+            if embededness + c != 0:
+                dispersion_val /= embededness + c
+
+        return dispersion_val
+
+    if u is None:
+        # v and u are not specified
+        if v is None:
+            results = {n: {} for n in G}
+            for u in G:
+                for v in G[u]:
+                    results[u][v] = _dispersion(G, u, v)
+        # u is not specified, but v is
+        else:
+            results = dict.fromkeys(G[v], {})
+            for u in G[v]:
+                results[u] = _dispersion(G, v, u)
+    else:
+        # u is specified with no target v
+        if v is None:
+            results = dict.fromkeys(G[u], {})
+            for v in G[u]:
+                results[v] = _dispersion(G, u, v)
+        # both u and v are specified
+        else:
+            results = _dispersion(G, u, v)
+
+    return results
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/eigenvector.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/eigenvector.py
new file mode 100644
index 0000000..f55cedb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/eigenvector.py
@@ -0,0 +1,229 @@
+"""Functions for computing eigenvector centrality."""
+import math
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["eigenvector_centrality", "eigenvector_centrality_numpy"]
+
+
+@not_implemented_for("multigraph")
+def eigenvector_centrality(G, max_iter=100, tol=1.0e-6, nstart=None, weight=None):
+    r"""Compute the eigenvector centrality for the graph `G`.
+
+    Eigenvector centrality computes the centrality for a node based on the
+    centrality of its neighbors. The eigenvector centrality for node $i$ is
+    the $i$-th element of the vector $x$ defined by the equation
+
+    .. math::
+
+        Ax = \lambda x
+
+    where $A$ is the adjacency matrix of the graph `G` with eigenvalue
+    $\lambda$. By virtue of the Perron–Frobenius theorem, there is a unique
+    solution $x$, all of whose entries are positive, if $\lambda$ is the
+    largest eigenvalue of the adjacency matrix $A$ ([2]_).
+
+    Parameters
+    ----------
+    G : graph
+      A networkx graph
+
+    max_iter : integer, optional (default=100)
+      Maximum number of iterations in power method.
+
+    tol : float, optional (default=1.0e-6)
+      Error tolerance used to check convergence in power method iteration.
+
+    nstart : dictionary, optional (default=None)
+      Starting value of eigenvector iteration for each node.
+
+    weight : None or string, optional (default=None)
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+      In this measure the weight is interpreted as the connection strength.
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with eigenvector centrality as the value.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> centrality = nx.eigenvector_centrality(G)
+    >>> sorted((v, f"{c:0.2f}") for v, c in centrality.items())
+    [(0, '0.37'), (1, '0.60'), (2, '0.60'), (3, '0.37')]
+
+    Raises
+    ------
+    NetworkXPointlessConcept
+        If the graph `G` is the null graph.
+
+    NetworkXError
+        If each value in `nstart` is zero.
+
+    PowerIterationFailedConvergence
+        If the algorithm fails to converge to the specified tolerance
+        within the specified number of iterations of the power iteration
+        method.
+
+    See Also
+    --------
+    eigenvector_centrality_numpy
+    pagerank
+    hits
+
+    Notes
+    -----
+    The measure was introduced by [1]_ and is discussed in [2]_.
+
+    The power iteration method is used to compute the eigenvector and
+    convergence is **not** guaranteed. Our method stops after ``max_iter``
+    iterations or when the change in the computed vector between two
+    iterations is smaller than an error tolerance of
+    ``G.number_of_nodes() * tol``. This implementation uses ($A + I$)
+    rather than the adjacency matrix $A$ because it shifts the spectrum
+    to enable discerning the correct eigenvector even for networks with
+    multiple dominant eigenvalues.
+
+    For directed graphs this is "left" eigenvector centrality which corresponds
+    to the in-edges in the graph. For out-edges eigenvector centrality
+    first reverse the graph with ``G.reverse()``.
+
+    References
+    ----------
+    .. [1] Phillip Bonacich.
+       "Power and Centrality: A Family of Measures."
+       *American Journal of Sociology* 92(5):1170–1182, 1986
+       <http://www.leonidzhukov.net/hse/2014/socialnetworks/papers/Bonacich-Centrality.pdf>
+    .. [2] Mark E. J. Newman.
+       *Networks: An Introduction.*
+       Oxford University Press, USA, 2010, pp. 169.
+
+    """
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept(
+            "cannot compute centrality for the null graph"
+        )
+    # If no initial vector is provided, start with the all-ones vector.
+    if nstart is None:
+        nstart = {v: 1 for v in G}
+    if all(v == 0 for v in nstart.values()):
+        raise nx.NetworkXError("initial vector cannot have all zero values")
+    # Normalize the initial vector so that each entry is in [0, 1]. This is
+    # guaranteed to never have a divide-by-zero error by the previous line.
+    nstart_sum = sum(nstart.values())
+    x = {k: v / nstart_sum for k, v in nstart.items()}
+    nnodes = G.number_of_nodes()
+    # make up to max_iter iterations
+    for _ in range(max_iter):
+        xlast = x
+        x = xlast.copy()  # Start with xlast times I to iterate with (A+I)
+        # do the multiplication y^T = x^T A (left eigenvector)
+        for n in x:
+            for nbr in G[n]:
+                w = G[n][nbr].get(weight, 1) if weight else 1
+                x[nbr] += xlast[n] * w
+        # Normalize the vector. The normalization denominator `norm`
+        # should never be zero by the Perron--Frobenius
+        # theorem. However, in case it is due to numerical error, we
+        # assume the norm to be one instead.
+        norm = math.hypot(*x.values()) or 1
+        x = {k: v / norm for k, v in x.items()}
+        # Check for convergence (in the L_1 norm).
+        if sum(abs(x[n] - xlast[n]) for n in x) < nnodes * tol:
+            return x
+    raise nx.PowerIterationFailedConvergence(max_iter)
+
+
+def eigenvector_centrality_numpy(G, weight=None, max_iter=50, tol=0):
+    r"""Compute the eigenvector centrality for the graph G.
+
+    Eigenvector centrality computes the centrality for a node based on the
+    centrality of its neighbors. The eigenvector centrality for node $i$ is
+
+    .. math::
+
+        Ax = \lambda x
+
+    where $A$ is the adjacency matrix of the graph G with eigenvalue $\lambda$.
+    By virtue of the Perron–Frobenius theorem, there is a unique and positive
+    solution if $\lambda$ is the largest eigenvalue associated with the
+    eigenvector of the adjacency matrix $A$ ([2]_).
+
+    Parameters
+    ----------
+    G : graph
+      A networkx graph
+
+    weight : None or string, optional (default=None)
+      The name of the edge attribute used as weight.
+      If None, all edge weights are considered equal.
+      In this measure the weight is interpreted as the connection strength.
+    max_iter : integer, optional (default=100)
+      Maximum number of iterations in power method.
+
+    tol : float, optional (default=1.0e-6)
+       Relative accuracy for eigenvalues (stopping criterion).
+       The default value of 0 implies machine precision.
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with eigenvector centrality as the value.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> centrality = nx.eigenvector_centrality_numpy(G)
+    >>> print([f"{node} {centrality[node]:0.2f}" for node in centrality])
+    ['0 0.37', '1 0.60', '2 0.60', '3 0.37']
+
+    See Also
+    --------
+    eigenvector_centrality
+    pagerank
+    hits
+
+    Notes
+    -----
+    The measure was introduced by [1]_.
+
+    This algorithm uses the SciPy sparse eigenvalue solver (ARPACK) to
+    find the largest eigenvalue/eigenvector pair.
+
+    For directed graphs this is "left" eigenvector centrality which corresponds
+    to the in-edges in the graph. For out-edges eigenvector centrality
+    first reverse the graph with ``G.reverse()``.
+
+    Raises
+    ------
+    NetworkXPointlessConcept
+        If the graph ``G`` is the null graph.
+
+    References
+    ----------
+    .. [1] Phillip Bonacich:
+       Power and Centrality: A Family of Measures.
+       American Journal of Sociology 92(5):1170–1182, 1986
+       http://www.leonidzhukov.net/hse/2014/socialnetworks/papers/Bonacich-Centrality.pdf
+    .. [2] Mark E. J. Newman:
+       Networks: An Introduction.
+       Oxford University Press, USA, 2010, pp. 169.
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse.linalg  # call as sp.sparse.linalg
+
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept(
+            "cannot compute centrality for the null graph"
+        )
+    M = nx.to_scipy_sparse_array(G, nodelist=list(G), weight=weight, dtype=float)
+    _, eigenvector = sp.sparse.linalg.eigs(
+        M.T, k=1, which="LR", maxiter=max_iter, tol=tol
+    )
+    largest = eigenvector.flatten().real
+    norm = np.sign(largest.sum()) * sp.linalg.norm(largest)
+    return dict(zip(G, largest / norm))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/flow_matrix.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/flow_matrix.py
new file mode 100644
index 0000000..fcd6568
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/flow_matrix.py
@@ -0,0 +1,131 @@
+# Helpers for current-flow betweenness and current-flow closness
+# Lazy computations for inverse Laplacian and flow-matrix rows.
+import networkx as nx
+
+
+def flow_matrix_row(G, weight=None, dtype=float, solver="lu"):
+    # Generate a row of the current-flow matrix
+    import numpy as np
+
+    solvername = {
+        "full": FullInverseLaplacian,
+        "lu": SuperLUInverseLaplacian,
+        "cg": CGInverseLaplacian,
+    }
+    n = G.number_of_nodes()
+    L = nx.laplacian_matrix(G, nodelist=range(n), weight=weight).asformat("csc")
+    L = L.astype(dtype)
+    C = solvername[solver](L, dtype=dtype)  # initialize solver
+    w = C.w  # w is the Laplacian matrix width
+    # row-by-row flow matrix
+    for u, v in sorted(sorted((u, v)) for u, v in G.edges()):
+        B = np.zeros(w, dtype=dtype)
+        c = G[u][v].get(weight, 1.0)
+        B[u % w] = c
+        B[v % w] = -c
+        # get only the rows needed in the inverse laplacian
+        # and multiply to get the flow matrix row
+        row = B @ C.get_rows(u, v)
+        yield row, (u, v)
+
+
+# Class to compute the inverse laplacian only for specified rows
+# Allows computation of the current-flow matrix without storing entire
+# inverse laplacian matrix
+class InverseLaplacian:
+    def __init__(self, L, width=None, dtype=None):
+        global np
+        import numpy as np
+
+        (n, n) = L.shape
+        self.dtype = dtype
+        self.n = n
+        if width is None:
+            self.w = self.width(L)
+        else:
+            self.w = width
+        self.C = np.zeros((self.w, n), dtype=dtype)
+        self.L1 = L[1:, 1:]
+        self.init_solver(L)
+
+    def init_solver(self, L):
+        pass
+
+    def solve(self, r):
+        raise nx.NetworkXError("Implement solver")
+
+    def solve_inverse(self, r):
+        raise nx.NetworkXError("Implement solver")
+
+    def get_rows(self, r1, r2):
+        for r in range(r1, r2 + 1):
+            self.C[r % self.w, 1:] = self.solve_inverse(r)
+        return self.C
+
+    def get_row(self, r):
+        self.C[r % self.w, 1:] = self.solve_inverse(r)
+        return self.C[r % self.w]
+
+    def width(self, L):
+        m = 0
+        for i, row in enumerate(L):
+            w = 0
+            x, y = np.nonzero(row)
+            if len(y) > 0:
+                v = y - i
+                w = v.max() - v.min() + 1
+                m = max(w, m)
+        return m
+
+
+class FullInverseLaplacian(InverseLaplacian):
+    def init_solver(self, L):
+        self.IL = np.zeros(L.shape, dtype=self.dtype)
+        self.IL[1:, 1:] = np.linalg.inv(self.L1.todense())
+
+    def solve(self, rhs):
+        s = np.zeros(rhs.shape, dtype=self.dtype)
+        s = self.IL @ rhs
+        return s
+
+    def solve_inverse(self, r):
+        return self.IL[r, 1:]
+
+
+class SuperLUInverseLaplacian(InverseLaplacian):
+    def init_solver(self, L):
+        import scipy as sp
+        import scipy.sparse.linalg  # call as sp.sparse.linalg
+
+        self.lusolve = sp.sparse.linalg.factorized(self.L1.tocsc())
+
+    def solve_inverse(self, r):
+        rhs = np.zeros(self.n, dtype=self.dtype)
+        rhs[r] = 1
+        return self.lusolve(rhs[1:])
+
+    def solve(self, rhs):
+        s = np.zeros(rhs.shape, dtype=self.dtype)
+        s[1:] = self.lusolve(rhs[1:])
+        return s
+
+
+class CGInverseLaplacian(InverseLaplacian):
+    def init_solver(self, L):
+        global sp
+        import scipy as sp
+        import scipy.sparse.linalg  # call as sp.sparse.linalg
+
+        ilu = sp.sparse.linalg.spilu(self.L1.tocsc())
+        n = self.n - 1
+        self.M = sp.sparse.linalg.LinearOperator(shape=(n, n), matvec=ilu.solve)
+
+    def solve(self, rhs):
+        s = np.zeros(rhs.shape, dtype=self.dtype)
+        s[1:] = sp.sparse.linalg.cg(self.L1, rhs[1:], M=self.M, atol=0)[0]
+        return s
+
+    def solve_inverse(self, r):
+        rhs = np.zeros(self.n, self.dtype)
+        rhs[r] = 1
+        return sp.sparse.linalg.cg(self.L1, rhs[1:], M=self.M, atol=0)[0]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/group.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/group.py
new file mode 100644
index 0000000..5d4e43a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/group.py
@@ -0,0 +1,779 @@
+"""Group centrality measures."""
+from copy import deepcopy
+
+import networkx as nx
+from networkx.algorithms.centrality.betweenness import (
+    _accumulate_endpoints,
+    _single_source_dijkstra_path_basic,
+    _single_source_shortest_path_basic,
+)
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = [
+    "group_betweenness_centrality",
+    "group_closeness_centrality",
+    "group_degree_centrality",
+    "group_in_degree_centrality",
+    "group_out_degree_centrality",
+    "prominent_group",
+]
+
+
+def group_betweenness_centrality(G, C, normalized=True, weight=None, endpoints=False):
+    r"""Compute the group betweenness centrality for a group of nodes.
+
+    Group betweenness centrality of a group of nodes $C$ is the sum of the
+    fraction of all-pairs shortest paths that pass through any vertex in $C$
+
+    .. math::
+
+       c_B(v) =\sum_{s,t \in V} \frac{\sigma(s, t|v)}{\sigma(s, t)}
+
+    where $V$ is the set of nodes, $\sigma(s, t)$ is the number of
+    shortest $(s, t)$-paths, and $\sigma(s, t|C)$ is the number of
+    those paths passing through some node in group $C$. Note that
+    $(s, t)$ are not members of the group ($V-C$ is the set of nodes
+    in $V$ that are not in $C$).
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.
+
+    C : list or set or list of lists or list of sets
+      A group or a list of groups containing nodes which belong to G, for which group betweenness
+      centrality is to be calculated.
+
+    normalized : bool, optional (default=True)
+      If True, group betweenness is normalized by `1/((|V|-|C|)(|V|-|C|-1))`
+      where `|V|` is the number of nodes in G and `|C|` is the number of nodes in C.
+
+    weight : None or string, optional (default=None)
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+      The weight of an edge is treated as the length or distance between the two sides.
+
+    endpoints : bool, optional (default=False)
+      If True include the endpoints in the shortest path counts.
+
+    Raises
+    ------
+    NodeNotFound
+       If node(s) in C are not present in G.
+
+    Returns
+    -------
+    betweenness : list of floats or float
+       If C is a single group then return a float. If C is a list with
+       several groups then return a list of group betweenness centralities.
+
+    See Also
+    --------
+    betweenness_centrality
+
+    Notes
+    -----
+    Group betweenness centrality is described in [1]_ and its importance discussed in [3]_.
+    The initial implementation of the algorithm is mentioned in [2]_. This function uses
+    an improved algorithm presented in [4]_.
+
+    The number of nodes in the group must be a maximum of n - 2 where `n`
+    is the total number of nodes in the graph.
+
+    For weighted graphs the edge weights must be greater than zero.
+    Zero edge weights can produce an infinite number of equal length
+    paths between pairs of nodes.
+
+    The total number of paths between source and target is counted
+    differently for directed and undirected graphs. Directed paths
+    between "u" and "v" are counted as two possible paths (one each
+    direction) while undirected paths between "u" and "v" are counted
+    as one path. Said another way, the sum in the expression above is
+    over all ``s != t`` for directed graphs and for ``s < t`` for undirected graphs.
+
+
+    References
+    ----------
+    .. [1] M G Everett and S P Borgatti:
+       The Centrality of Groups and Classes.
+       Journal of Mathematical Sociology. 23(3): 181-201. 1999.
+       http://www.analytictech.com/borgatti/group_centrality.htm
+    .. [2] Ulrik Brandes:
+       On Variants of Shortest-Path Betweenness
+       Centrality and their Generic Computation.
+       Social Networks 30(2):136-145, 2008.
+       http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.72.9610&rep=rep1&type=pdf
+    .. [3] Sourav Medya et. al.:
+       Group Centrality Maximization via Network Design.
+       SIAM International Conference on Data Mining, SDM 2018, 126–134.
+       https://sites.cs.ucsb.edu/~arlei/pubs/sdm18.pdf
+    .. [4] Rami Puzis, Yuval Elovici, and Shlomi Dolev.
+       "Fast algorithm for successive computation of group betweenness centrality."
+       https://journals.aps.org/pre/pdf/10.1103/PhysRevE.76.056709
+
+    """
+    GBC = []  # initialize betweenness
+    list_of_groups = True
+    #  check weather C contains one or many groups
+    if any(el in G for el in C):
+        C = [C]
+        list_of_groups = False
+    set_v = {node for group in C for node in group}
+    if set_v - G.nodes:  # element(s) of C not in G
+        raise nx.NodeNotFound(f"The node(s) {set_v - G.nodes} are in C but not in G.")
+
+    # pre-processing
+    PB, sigma, D = _group_preprocessing(G, set_v, weight)
+
+    # the algorithm for each group
+    for group in C:
+        group = set(group)  # set of nodes in group
+        # initialize the matrices of the sigma and the PB
+        GBC_group = 0
+        sigma_m = deepcopy(sigma)
+        PB_m = deepcopy(PB)
+        sigma_m_v = deepcopy(sigma_m)
+        PB_m_v = deepcopy(PB_m)
+        for v in group:
+            GBC_group += PB_m[v][v]
+            for x in group:
+                for y in group:
+                    dxvy = 0
+                    dxyv = 0
+                    dvxy = 0
+                    if not (
+                        sigma_m[x][y] == 0 or sigma_m[x][v] == 0 or sigma_m[v][y] == 0
+                    ):
+                        if D[x][v] == D[x][y] + D[y][v]:
+                            dxyv = sigma_m[x][y] * sigma_m[y][v] / sigma_m[x][v]
+                        if D[x][y] == D[x][v] + D[v][y]:
+                            dxvy = sigma_m[x][v] * sigma_m[v][y] / sigma_m[x][y]
+                        if D[v][y] == D[v][x] + D[x][y]:
+                            dvxy = sigma_m[v][x] * sigma[x][y] / sigma[v][y]
+                    sigma_m_v[x][y] = sigma_m[x][y] * (1 - dxvy)
+                    PB_m_v[x][y] = PB_m[x][y] - PB_m[x][y] * dxvy
+                    if y != v:
+                        PB_m_v[x][y] -= PB_m[x][v] * dxyv
+                    if x != v:
+                        PB_m_v[x][y] -= PB_m[v][y] * dvxy
+            sigma_m, sigma_m_v = sigma_m_v, sigma_m
+            PB_m, PB_m_v = PB_m_v, PB_m
+
+        # endpoints
+        v, c = len(G), len(group)
+        if not endpoints:
+            scale = 0
+            # if the graph is connected then subtract the endpoints from
+            # the count for all the nodes in the graph. else count how many
+            # nodes are connected to the group's nodes and subtract that.
+            if nx.is_directed(G):
+                if nx.is_strongly_connected(G):
+                    scale = c * (2 * v - c - 1)
+            elif nx.is_connected(G):
+                scale = c * (2 * v - c - 1)
+            if scale == 0:
+                for group_node1 in group:
+                    for node in D[group_node1]:
+                        if node != group_node1:
+                            if node in group:
+                                scale += 1
+                            else:
+                                scale += 2
+            GBC_group -= scale
+
+        # normalized
+        if normalized:
+            scale = 1 / ((v - c) * (v - c - 1))
+            GBC_group *= scale
+
+        # If undirected than count only the undirected edges
+        elif not G.is_directed():
+            GBC_group /= 2
+
+        GBC.append(GBC_group)
+    if list_of_groups:
+        return GBC
+    return GBC[0]
+
+
+def _group_preprocessing(G, set_v, weight):
+    sigma = {}
+    delta = {}
+    D = {}
+    betweenness = dict.fromkeys(G, 0)
+    for s in G:
+        if weight is None:  # use BFS
+            S, P, sigma[s], D[s] = _single_source_shortest_path_basic(G, s)
+        else:  # use Dijkstra's algorithm
+            S, P, sigma[s], D[s] = _single_source_dijkstra_path_basic(G, s, weight)
+        betweenness, delta[s] = _accumulate_endpoints(betweenness, S, P, sigma[s], s)
+        for i in delta[s].keys():  # add the paths from s to i and rescale sigma
+            if s != i:
+                delta[s][i] += 1
+            if weight is not None:
+                sigma[s][i] = sigma[s][i] / 2
+    # building the path betweenness matrix only for nodes that appear in the group
+    PB = dict.fromkeys(G)
+    for group_node1 in set_v:
+        PB[group_node1] = dict.fromkeys(G, 0.0)
+        for group_node2 in set_v:
+            if group_node2 not in D[group_node1]:
+                continue
+            for node in G:
+                # if node is connected to the two group nodes than continue
+                if group_node2 in D[node] and group_node1 in D[node]:
+                    if (
+                        D[node][group_node2]
+                        == D[node][group_node1] + D[group_node1][group_node2]
+                    ):
+                        PB[group_node1][group_node2] += (
+                            delta[node][group_node2]
+                            * sigma[node][group_node1]
+                            * sigma[group_node1][group_node2]
+                            / sigma[node][group_node2]
+                        )
+    return PB, sigma, D
+
+
+def prominent_group(
+    G, k, weight=None, C=None, endpoints=False, normalized=True, greedy=False
+):
+    r"""Find the prominent group of size $k$ in graph $G$. The prominence of the
+    group is evaluated by the group betweenness centrality.
+
+    Group betweenness centrality of a group of nodes $C$ is the sum of the
+    fraction of all-pairs shortest paths that pass through any vertex in $C$
+
+    .. math::
+
+       c_B(v) =\sum_{s,t \in V} \frac{\sigma(s, t|v)}{\sigma(s, t)}
+
+    where $V$ is the set of nodes, $\sigma(s, t)$ is the number of
+    shortest $(s, t)$-paths, and $\sigma(s, t|C)$ is the number of
+    those paths passing through some node in group $C$. Note that
+    $(s, t)$ are not members of the group ($V-C$ is the set of nodes
+    in $V$ that are not in $C$).
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph.
+
+    k : int
+       The number of nodes in the group.
+
+    normalized : bool, optional (default=True)
+       If True, group betweenness is normalized by ``1/((|V|-|C|)(|V|-|C|-1))``
+       where ``|V|`` is the number of nodes in G and ``|C|`` is the number of
+       nodes in C.
+
+    weight : None or string, optional (default=None)
+       If None, all edge weights are considered equal.
+       Otherwise holds the name of the edge attribute used as weight.
+       The weight of an edge is treated as the length or distance between the two sides.
+
+    endpoints : bool, optional (default=False)
+       If True include the endpoints in the shortest path counts.
+
+    C : list or set, optional (default=None)
+       list of nodes which won't be candidates of the prominent group.
+
+    greedy : bool, optional (default=False)
+       Using a naive greedy algorithm in order to find non-optimal prominent
+       group. For scale free networks the results are negligibly below the optimal
+       results.
+
+    Raises
+    ------
+    NodeNotFound
+       If node(s) in C are not present in G.
+
+    Returns
+    -------
+    max_GBC : float
+       The group betweenness centrality of the prominent group.
+
+    max_group : list
+        The list of nodes in the prominent group.
+
+    See Also
+    --------
+    betweenness_centrality, group_betweenness_centrality
+
+    Notes
+    -----
+    Group betweenness centrality is described in [1]_ and its importance discussed in [3]_.
+    The algorithm is described in [2]_ and is based on techniques mentioned in [4]_.
+
+    The number of nodes in the group must be a maximum of ``n - 2`` where ``n``
+    is the total number of nodes in the graph.
+
+    For weighted graphs the edge weights must be greater than zero.
+    Zero edge weights can produce an infinite number of equal length
+    paths between pairs of nodes.
+
+    The total number of paths between source and target is counted
+    differently for directed and undirected graphs. Directed paths
+    between "u" and "v" are counted as two possible paths (one each
+    direction) while undirected paths between "u" and "v" are counted
+    as one path. Said another way, the sum in the expression above is
+    over all ``s != t`` for directed graphs and for ``s < t`` for undirected graphs.
+
+    References
+    ----------
+    .. [1] M G Everett and S P Borgatti:
+       The Centrality of Groups and Classes.
+       Journal of Mathematical Sociology. 23(3): 181-201. 1999.
+       http://www.analytictech.com/borgatti/group_centrality.htm
+    .. [2] Rami Puzis, Yuval Elovici, and Shlomi Dolev:
+       "Finding the Most Prominent Group in Complex Networks"
+       AI communications 20(4): 287-296, 2007.
+       https://www.researchgate.net/profile/Rami_Puzis2/publication/220308855
+    .. [3] Sourav Medya et. al.:
+       Group Centrality Maximization via Network Design.
+       SIAM International Conference on Data Mining, SDM 2018, 126–134.
+       https://sites.cs.ucsb.edu/~arlei/pubs/sdm18.pdf
+    .. [4] Rami Puzis, Yuval Elovici, and Shlomi Dolev.
+       "Fast algorithm for successive computation of group betweenness centrality."
+       https://journals.aps.org/pre/pdf/10.1103/PhysRevE.76.056709
+    """
+    import numpy as np
+    import pandas as pd
+
+    if C is not None:
+        C = set(C)
+        if C - G.nodes:  # element(s) of C not in G
+            raise nx.NodeNotFound(f"The node(s) {C - G.nodes} are in C but not in G.")
+        nodes = list(G.nodes - C)
+    else:
+        nodes = list(G.nodes)
+    DF_tree = nx.Graph()
+    PB, sigma, D = _group_preprocessing(G, nodes, weight)
+    betweenness = pd.DataFrame.from_dict(PB)
+    if C is not None:
+        for node in C:
+            # remove from the betweenness all the nodes not part of the group
+            betweenness.drop(index=node, inplace=True)
+            betweenness.drop(columns=node, inplace=True)
+    CL = [node for _, node in sorted(zip(np.diag(betweenness), nodes), reverse=True)]
+    max_GBC = 0
+    max_group = []
+    DF_tree.add_node(
+        1,
+        CL=CL,
+        betweenness=betweenness,
+        GBC=0,
+        GM=[],
+        sigma=sigma,
+        cont=dict(zip(nodes, np.diag(betweenness))),
+    )
+
+    # the algorithm
+    DF_tree.nodes[1]["heu"] = 0
+    for i in range(k):
+        DF_tree.nodes[1]["heu"] += DF_tree.nodes[1]["cont"][DF_tree.nodes[1]["CL"][i]]
+    max_GBC, DF_tree, max_group = _dfbnb(
+        G, k, DF_tree, max_GBC, 1, D, max_group, nodes, greedy
+    )
+
+    v = len(G)
+    if not endpoints:
+        scale = 0
+        # if the graph is connected then subtract the endpoints from
+        # the count for all the nodes in the graph. else count how many
+        # nodes are connected to the group's nodes and subtract that.
+        if nx.is_directed(G):
+            if nx.is_strongly_connected(G):
+                scale = k * (2 * v - k - 1)
+        elif nx.is_connected(G):
+            scale = k * (2 * v - k - 1)
+        if scale == 0:
+            for group_node1 in max_group:
+                for node in D[group_node1]:
+                    if node != group_node1:
+                        if node in max_group:
+                            scale += 1
+                        else:
+                            scale += 2
+        max_GBC -= scale
+
+    # normalized
+    if normalized:
+        scale = 1 / ((v - k) * (v - k - 1))
+        max_GBC *= scale
+
+    # If undirected then count only the undirected edges
+    elif not G.is_directed():
+        max_GBC /= 2
+    max_GBC = float("%.2f" % max_GBC)
+    return max_GBC, max_group
+
+
+def _dfbnb(G, k, DF_tree, max_GBC, root, D, max_group, nodes, greedy):
+    # stopping condition - if we found a group of size k and with higher GBC then prune
+    if len(DF_tree.nodes[root]["GM"]) == k and DF_tree.nodes[root]["GBC"] > max_GBC:
+        return DF_tree.nodes[root]["GBC"], DF_tree, DF_tree.nodes[root]["GM"]
+    # stopping condition - if the size of group members equal to k or there are less than
+    # k - |GM| in the candidate list or the heuristic function plus the GBC is bellow the
+    # maximal GBC found then prune
+    if (
+        len(DF_tree.nodes[root]["GM"]) == k
+        or len(DF_tree.nodes[root]["CL"]) <= k - len(DF_tree.nodes[root]["GM"])
+        or DF_tree.nodes[root]["GBC"] + DF_tree.nodes[root]["heu"] <= max_GBC
+    ):
+        return max_GBC, DF_tree, max_group
+
+    # finding the heuristic of both children
+    node_p, node_m, DF_tree = _heuristic(k, root, DF_tree, D, nodes, greedy)
+
+    # finding the child with the bigger heuristic + GBC and expand
+    # that node first if greedy then only expand the plus node
+    if greedy:
+        max_GBC, DF_tree, max_group = _dfbnb(
+            G, k, DF_tree, max_GBC, node_p, D, max_group, nodes, greedy
+        )
+
+    elif (
+        DF_tree.nodes[node_p]["GBC"] + DF_tree.nodes[node_p]["heu"]
+        > DF_tree.nodes[node_m]["GBC"] + DF_tree.nodes[node_m]["heu"]
+    ):
+        max_GBC, DF_tree, max_group = _dfbnb(
+            G, k, DF_tree, max_GBC, node_p, D, max_group, nodes, greedy
+        )
+        max_GBC, DF_tree, max_group = _dfbnb(
+            G, k, DF_tree, max_GBC, node_m, D, max_group, nodes, greedy
+        )
+    else:
+        max_GBC, DF_tree, max_group = _dfbnb(
+            G, k, DF_tree, max_GBC, node_m, D, max_group, nodes, greedy
+        )
+        max_GBC, DF_tree, max_group = _dfbnb(
+            G, k, DF_tree, max_GBC, node_p, D, max_group, nodes, greedy
+        )
+    return max_GBC, DF_tree, max_group
+
+
+def _heuristic(k, root, DF_tree, D, nodes, greedy):
+    import numpy as np
+
+    # This helper function add two nodes to DF_tree - one left son and the
+    # other right son, finds their heuristic, CL, GBC, and GM
+    node_p = DF_tree.number_of_nodes() + 1
+    node_m = DF_tree.number_of_nodes() + 2
+    added_node = DF_tree.nodes[root]["CL"][0]
+
+    # adding the plus node
+    DF_tree.add_nodes_from([(node_p, deepcopy(DF_tree.nodes[root]))])
+    DF_tree.nodes[node_p]["GM"].append(added_node)
+    DF_tree.nodes[node_p]["GBC"] += DF_tree.nodes[node_p]["cont"][added_node]
+    root_node = DF_tree.nodes[root]
+    for x in nodes:
+        for y in nodes:
+            dxvy = 0
+            dxyv = 0
+            dvxy = 0
+            if not (
+                root_node["sigma"][x][y] == 0
+                or root_node["sigma"][x][added_node] == 0
+                or root_node["sigma"][added_node][y] == 0
+            ):
+                if D[x][added_node] == D[x][y] + D[y][added_node]:
+                    dxyv = (
+                        root_node["sigma"][x][y]
+                        * root_node["sigma"][y][added_node]
+                        / root_node["sigma"][x][added_node]
+                    )
+                if D[x][y] == D[x][added_node] + D[added_node][y]:
+                    dxvy = (
+                        root_node["sigma"][x][added_node]
+                        * root_node["sigma"][added_node][y]
+                        / root_node["sigma"][x][y]
+                    )
+                if D[added_node][y] == D[added_node][x] + D[x][y]:
+                    dvxy = (
+                        root_node["sigma"][added_node][x]
+                        * root_node["sigma"][x][y]
+                        / root_node["sigma"][added_node][y]
+                    )
+            DF_tree.nodes[node_p]["sigma"][x][y] = root_node["sigma"][x][y] * (1 - dxvy)
+            DF_tree.nodes[node_p]["betweenness"][x][y] = (
+                root_node["betweenness"][x][y] - root_node["betweenness"][x][y] * dxvy
+            )
+            if y != added_node:
+                DF_tree.nodes[node_p]["betweenness"][x][y] -= (
+                    root_node["betweenness"][x][added_node] * dxyv
+                )
+            if x != added_node:
+                DF_tree.nodes[node_p]["betweenness"][x][y] -= (
+                    root_node["betweenness"][added_node][y] * dvxy
+                )
+
+    DF_tree.nodes[node_p]["CL"] = [
+        node
+        for _, node in sorted(
+            zip(np.diag(DF_tree.nodes[node_p]["betweenness"]), nodes), reverse=True
+        )
+        if node not in DF_tree.nodes[node_p]["GM"]
+    ]
+    DF_tree.nodes[node_p]["cont"] = dict(
+        zip(nodes, np.diag(DF_tree.nodes[node_p]["betweenness"]))
+    )
+    DF_tree.nodes[node_p]["heu"] = 0
+    for i in range(k - len(DF_tree.nodes[node_p]["GM"])):
+        DF_tree.nodes[node_p]["heu"] += DF_tree.nodes[node_p]["cont"][
+            DF_tree.nodes[node_p]["CL"][i]
+        ]
+
+    # adding the minus node - don't insert the first node in the CL to GM
+    # Insert minus node only if isn't greedy type algorithm
+    if not greedy:
+        DF_tree.add_nodes_from([(node_m, deepcopy(DF_tree.nodes[root]))])
+        DF_tree.nodes[node_m]["CL"].pop(0)
+        DF_tree.nodes[node_m]["cont"].pop(added_node)
+        DF_tree.nodes[node_m]["heu"] = 0
+        for i in range(k - len(DF_tree.nodes[node_m]["GM"])):
+            DF_tree.nodes[node_m]["heu"] += DF_tree.nodes[node_m]["cont"][
+                DF_tree.nodes[node_m]["CL"][i]
+            ]
+    else:
+        node_m = None
+
+    return node_p, node_m, DF_tree
+
+
+def group_closeness_centrality(G, S, weight=None):
+    r"""Compute the group closeness centrality for a group of nodes.
+
+    Group closeness centrality of a group of nodes $S$ is a measure
+    of how close the group is to the other nodes in the graph.
+
+    .. math::
+
+       c_{close}(S) = \frac{|V-S|}{\sum_{v \in V-S} d_{S, v}}
+
+       d_{S, v} = min_{u \in S} (d_{u, v})
+
+    where $V$ is the set of nodes, $d_{S, v}$ is the distance of
+    the group $S$ from $v$ defined as above. ($V-S$ is the set of nodes
+    in $V$ that are not in $S$).
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph.
+
+    S : list or set
+       S is a group of nodes which belong to G, for which group closeness
+       centrality is to be calculated.
+
+    weight : None or string, optional (default=None)
+       If None, all edge weights are considered equal.
+       Otherwise holds the name of the edge attribute used as weight.
+       The weight of an edge is treated as the length or distance between the two sides.
+
+    Raises
+    ------
+    NodeNotFound
+       If node(s) in S are not present in G.
+
+    Returns
+    -------
+    closeness : float
+       Group closeness centrality of the group S.
+
+    See Also
+    --------
+    closeness_centrality
+
+    Notes
+    -----
+    The measure was introduced in [1]_.
+    The formula implemented here is described in [2]_.
+
+    Higher values of closeness indicate greater centrality.
+
+    It is assumed that 1 / 0 is 0 (required in the case of directed graphs,
+    or when a shortest path length is 0).
+
+    The number of nodes in the group must be a maximum of n - 1 where `n`
+    is the total number of nodes in the graph.
+
+    For directed graphs, the incoming distance is utilized here. To use the
+    outward distance, act on `G.reverse()`.
+
+    For weighted graphs the edge weights must be greater than zero.
+    Zero edge weights can produce an infinite number of equal length
+    paths between pairs of nodes.
+
+    References
+    ----------
+    .. [1] M G Everett and S P Borgatti:
+       The Centrality of Groups and Classes.
+       Journal of Mathematical Sociology. 23(3): 181-201. 1999.
+       http://www.analytictech.com/borgatti/group_centrality.htm
+    .. [2] J. Zhao et. al.:
+       Measuring and Maximizing Group Closeness Centrality over
+       Disk Resident Graphs.
+       WWWConference Proceedings, 2014. 689-694.
+       https://doi.org/10.1145/2567948.2579356
+    """
+    if G.is_directed():
+        G = G.reverse()  # reverse view
+    closeness = 0  # initialize to 0
+    V = set(G)  # set of nodes in G
+    S = set(S)  # set of nodes in group S
+    V_S = V - S  # set of nodes in V but not S
+    shortest_path_lengths = nx.multi_source_dijkstra_path_length(G, S, weight=weight)
+    # accumulation
+    for v in V_S:
+        try:
+            closeness += shortest_path_lengths[v]
+        except KeyError:  # no path exists
+            closeness += 0
+    try:
+        closeness = len(V_S) / closeness
+    except ZeroDivisionError:  # 1 / 0 assumed as 0
+        closeness = 0
+    return closeness
+
+
+def group_degree_centrality(G, S):
+    """Compute the group degree centrality for a group of nodes.
+
+    Group degree centrality of a group of nodes $S$ is the fraction
+    of non-group members connected to group members.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph.
+
+    S : list or set
+       S is a group of nodes which belong to G, for which group degree
+       centrality is to be calculated.
+
+    Raises
+    ------
+    NetworkXError
+       If node(s) in S are not in G.
+
+    Returns
+    -------
+    centrality : float
+       Group degree centrality of the group S.
+
+    See Also
+    --------
+    degree_centrality
+    group_in_degree_centrality
+    group_out_degree_centrality
+
+    Notes
+    -----
+    The measure was introduced in [1]_.
+
+    The number of nodes in the group must be a maximum of n - 1 where `n`
+    is the total number of nodes in the graph.
+
+    References
+    ----------
+    .. [1] M G Everett and S P Borgatti:
+       The Centrality of Groups and Classes.
+       Journal of Mathematical Sociology. 23(3): 181-201. 1999.
+       http://www.analytictech.com/borgatti/group_centrality.htm
+    """
+    centrality = len(set().union(*list(set(G.neighbors(i)) for i in S)) - set(S))
+    centrality /= len(G.nodes()) - len(S)
+    return centrality
+
+
+@not_implemented_for("undirected")
+def group_in_degree_centrality(G, S):
+    """Compute the group in-degree centrality for a group of nodes.
+
+    Group in-degree centrality of a group of nodes $S$ is the fraction
+    of non-group members connected to group members by incoming edges.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph.
+
+    S : list or set
+       S is a group of nodes which belong to G, for which group in-degree
+       centrality is to be calculated.
+
+    Returns
+    -------
+    centrality : float
+       Group in-degree centrality of the group S.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+       If G is undirected.
+
+    NodeNotFound
+       If node(s) in S are not in G.
+
+    See Also
+    --------
+    degree_centrality
+    group_degree_centrality
+    group_out_degree_centrality
+
+    Notes
+    -----
+    The number of nodes in the group must be a maximum of n - 1 where `n`
+    is the total number of nodes in the graph.
+
+    `G.neighbors(i)` gives nodes with an outward edge from i, in a DiGraph,
+    so for group in-degree centrality, the reverse graph is used.
+    """
+    return group_degree_centrality(G.reverse(), S)
+
+
+@not_implemented_for("undirected")
+def group_out_degree_centrality(G, S):
+    """Compute the group out-degree centrality for a group of nodes.
+
+    Group out-degree centrality of a group of nodes $S$ is the fraction
+    of non-group members connected to group members by outgoing edges.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph.
+
+    S : list or set
+       S is a group of nodes which belong to G, for which group in-degree
+       centrality is to be calculated.
+
+    Returns
+    -------
+    centrality : float
+       Group out-degree centrality of the group S.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+       If G is undirected.
+
+    NodeNotFound
+       If node(s) in S are not in G.
+
+    See Also
+    --------
+    degree_centrality
+    group_degree_centrality
+    group_in_degree_centrality
+
+    Notes
+    -----
+    The number of nodes in the group must be a maximum of n - 1 where `n`
+    is the total number of nodes in the graph.
+
+    `G.neighbors(i)` gives nodes with an outward edge from i, in a DiGraph,
+    so for group out-degree centrality, the graph itself is used.
+    """
+    return group_degree_centrality(G, S)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/harmonic.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/harmonic.py
new file mode 100644
index 0000000..96e995d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/harmonic.py
@@ -0,0 +1,79 @@
+"""Functions for computing the harmonic centrality of a graph."""
+from functools import partial
+
+import networkx as nx
+
+__all__ = ["harmonic_centrality"]
+
+
+def harmonic_centrality(G, nbunch=None, distance=None, sources=None):
+    r"""Compute harmonic centrality for nodes.
+
+    Harmonic centrality [1]_ of a node `u` is the sum of the reciprocal
+    of the shortest path distances from all other nodes to `u`
+
+    .. math::
+
+        C(u) = \sum_{v \neq u} \frac{1}{d(v, u)}
+
+    where `d(v, u)` is the shortest-path distance between `v` and `u`.
+
+    If `sources` is given as an argument, the returned harmonic centrality
+    values are calculated as the sum of the reciprocals of the shortest
+    path distances from the nodes specified in `sources` to `u` instead
+    of from all nodes to `u`.
+
+    Notice that higher values indicate higher centrality.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    nbunch : container (default: all nodes in G)
+      Container of nodes for which harmonic centrality values are calculated.
+
+    sources : container (default: all nodes in G)
+      Container of nodes `v` over which reciprocal distances are computed.
+      Nodes not in `G` are silently ignored.
+
+    distance : edge attribute key, optional (default=None)
+      Use the specified edge attribute as the edge distance in shortest
+      path calculations.  If `None`, then each edge will have distance equal to 1.
+
+    Returns
+    -------
+    nodes : dictionary
+      Dictionary of nodes with harmonic centrality as the value.
+
+    See Also
+    --------
+    betweenness_centrality, load_centrality, eigenvector_centrality,
+    degree_centrality, closeness_centrality
+
+    Notes
+    -----
+    If the 'distance' keyword is set to an edge attribute key then the
+    shortest-path length will be computed using Dijkstra's algorithm with
+    that edge attribute as the edge weight.
+
+    References
+    ----------
+    .. [1] Boldi, Paolo, and Sebastiano Vigna. "Axioms for centrality."
+           Internet Mathematics 10.3-4 (2014): 222-262.
+    """
+
+    nbunch = set(G.nbunch_iter(nbunch)) if nbunch is not None else set(G.nodes)
+    sources = set(G.nbunch_iter(sources)) if sources is not None else G.nodes
+
+    spl = partial(nx.shortest_path_length, G, weight=distance)
+    centrality = {u: 0 for u in nbunch}
+    for v in sources:
+        dist = spl(v)
+        for u in nbunch.intersection(dist):
+            d = dist[u]
+            if d == 0:  # handle u == v and edges with 0 weight
+                continue
+            centrality[u] += 1 / d
+
+    return centrality
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/katz.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/katz.py
new file mode 100644
index 0000000..fd0bb93
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/katz.py
@@ -0,0 +1,333 @@
+"""Katz centrality."""
+import math
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["katz_centrality", "katz_centrality_numpy"]
+
+
+@not_implemented_for("multigraph")
+def katz_centrality(
+    G,
+    alpha=0.1,
+    beta=1.0,
+    max_iter=1000,
+    tol=1.0e-6,
+    nstart=None,
+    normalized=True,
+    weight=None,
+):
+    r"""Compute the Katz centrality for the nodes of the graph G.
+
+    Katz centrality computes the centrality for a node based on the centrality
+    of its neighbors. It is a generalization of the eigenvector centrality. The
+    Katz centrality for node $i$ is
+
+    .. math::
+
+        x_i = \alpha \sum_{j} A_{ij} x_j + \beta,
+
+    where $A$ is the adjacency matrix of graph G with eigenvalues $\lambda$.
+
+    The parameter $\beta$ controls the initial centrality and
+
+    .. math::
+
+        \alpha < \frac{1}{\lambda_{\max}}.
+
+    Katz centrality computes the relative influence of a node within a
+    network by measuring the number of the immediate neighbors (first
+    degree nodes) and also all other nodes in the network that connect
+    to the node under consideration through these immediate neighbors.
+
+    Extra weight can be provided to immediate neighbors through the
+    parameter $\beta$.  Connections made with distant neighbors
+    are, however, penalized by an attenuation factor $\alpha$ which
+    should be strictly less than the inverse largest eigenvalue of the
+    adjacency matrix in order for the Katz centrality to be computed
+    correctly. More information is provided in [1]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.
+
+    alpha : float
+      Attenuation factor
+
+    beta : scalar or dictionary, optional (default=1.0)
+      Weight attributed to the immediate neighborhood. If not a scalar, the
+      dictionary must have an value for every node.
+
+    max_iter : integer, optional (default=1000)
+      Maximum number of iterations in power method.
+
+    tol : float, optional (default=1.0e-6)
+      Error tolerance used to check convergence in power method iteration.
+
+    nstart : dictionary, optional
+      Starting value of Katz iteration for each node.
+
+    normalized : bool, optional (default=True)
+      If True normalize the resulting values.
+
+    weight : None or string, optional (default=None)
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+      In this measure the weight is interpreted as the connection strength.
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with Katz centrality as the value.
+
+    Raises
+    ------
+    NetworkXError
+       If the parameter `beta` is not a scalar but lacks a value for at least
+       one node
+
+    PowerIterationFailedConvergence
+        If the algorithm fails to converge to the specified tolerance
+        within the specified number of iterations of the power iteration
+        method.
+
+    Examples
+    --------
+    >>> import math
+    >>> G = nx.path_graph(4)
+    >>> phi = (1 + math.sqrt(5)) / 2.0  # largest eigenvalue of adj matrix
+    >>> centrality = nx.katz_centrality(G, 1 / phi - 0.01)
+    >>> for n, c in sorted(centrality.items()):
+    ...     print(f"{n} {c:.2f}")
+    0 0.37
+    1 0.60
+    2 0.60
+    3 0.37
+
+    See Also
+    --------
+    katz_centrality_numpy
+    eigenvector_centrality
+    eigenvector_centrality_numpy
+    pagerank
+    hits
+
+    Notes
+    -----
+    Katz centrality was introduced by [2]_.
+
+    This algorithm it uses the power method to find the eigenvector
+    corresponding to the largest eigenvalue of the adjacency matrix of ``G``.
+    The parameter ``alpha`` should be strictly less than the inverse of largest
+    eigenvalue of the adjacency matrix for the algorithm to converge.
+    You can use ``max(nx.adjacency_spectrum(G))`` to get $\lambda_{\max}$ the largest
+    eigenvalue of the adjacency matrix.
+    The iteration will stop after ``max_iter`` iterations or an error tolerance of
+    ``number_of_nodes(G) * tol`` has been reached.
+
+    When $\alpha = 1/\lambda_{\max}$ and $\beta=0$, Katz centrality is the same
+    as eigenvector centrality.
+
+    For directed graphs this finds "left" eigenvectors which corresponds
+    to the in-edges in the graph. For out-edges Katz centrality
+    first reverse the graph with ``G.reverse()``.
+
+    References
+    ----------
+    .. [1] Mark E. J. Newman:
+       Networks: An Introduction.
+       Oxford University Press, USA, 2010, p. 720.
+    .. [2] Leo Katz:
+       A New Status Index Derived from Sociometric Index.
+       Psychometrika 18(1):39–43, 1953
+       https://link.springer.com/content/pdf/10.1007/BF02289026.pdf
+    """
+    if len(G) == 0:
+        return {}
+
+    nnodes = G.number_of_nodes()
+
+    if nstart is None:
+        # choose starting vector with entries of 0
+        x = {n: 0 for n in G}
+    else:
+        x = nstart
+
+    try:
+        b = dict.fromkeys(G, float(beta))
+    except (TypeError, ValueError, AttributeError) as err:
+        b = beta
+        if set(beta) != set(G):
+            raise nx.NetworkXError(
+                "beta dictionary " "must have a value for every node"
+            ) from err
+
+    # make up to max_iter iterations
+    for _ in range(max_iter):
+        xlast = x
+        x = dict.fromkeys(xlast, 0)
+        # do the multiplication y^T = Alpha * x^T A - Beta
+        for n in x:
+            for nbr in G[n]:
+                x[nbr] += xlast[n] * G[n][nbr].get(weight, 1)
+        for n in x:
+            x[n] = alpha * x[n] + b[n]
+
+        # check convergence
+        error = sum(abs(x[n] - xlast[n]) for n in x)
+        if error < nnodes * tol:
+            if normalized:
+                # normalize vector
+                try:
+                    s = 1.0 / math.hypot(*x.values())
+                # this should never be zero?
+                except ZeroDivisionError:
+                    s = 1.0
+            else:
+                s = 1
+            for n in x:
+                x[n] *= s
+            return x
+    raise nx.PowerIterationFailedConvergence(max_iter)
+
+
+@not_implemented_for("multigraph")
+def katz_centrality_numpy(G, alpha=0.1, beta=1.0, normalized=True, weight=None):
+    r"""Compute the Katz centrality for the graph G.
+
+    Katz centrality computes the centrality for a node based on the centrality
+    of its neighbors. It is a generalization of the eigenvector centrality. The
+    Katz centrality for node $i$ is
+
+    .. math::
+
+        x_i = \alpha \sum_{j} A_{ij} x_j + \beta,
+
+    where $A$ is the adjacency matrix of graph G with eigenvalues $\lambda$.
+
+    The parameter $\beta$ controls the initial centrality and
+
+    .. math::
+
+        \alpha < \frac{1}{\lambda_{\max}}.
+
+    Katz centrality computes the relative influence of a node within a
+    network by measuring the number of the immediate neighbors (first
+    degree nodes) and also all other nodes in the network that connect
+    to the node under consideration through these immediate neighbors.
+
+    Extra weight can be provided to immediate neighbors through the
+    parameter $\beta$.  Connections made with distant neighbors
+    are, however, penalized by an attenuation factor $\alpha$ which
+    should be strictly less than the inverse largest eigenvalue of the
+    adjacency matrix in order for the Katz centrality to be computed
+    correctly. More information is provided in [1]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    alpha : float
+      Attenuation factor
+
+    beta : scalar or dictionary, optional (default=1.0)
+      Weight attributed to the immediate neighborhood. If not a scalar the
+      dictionary must have an value for every node.
+
+    normalized : bool
+      If True normalize the resulting values.
+
+    weight : None or string, optional
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+      In this measure the weight is interpreted as the connection strength.
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with Katz centrality as the value.
+
+    Raises
+    ------
+    NetworkXError
+       If the parameter `beta` is not a scalar but lacks a value for at least
+       one node
+
+    Examples
+    --------
+    >>> import math
+    >>> G = nx.path_graph(4)
+    >>> phi = (1 + math.sqrt(5)) / 2.0  # largest eigenvalue of adj matrix
+    >>> centrality = nx.katz_centrality_numpy(G, 1 / phi)
+    >>> for n, c in sorted(centrality.items()):
+    ...     print(f"{n} {c:.2f}")
+    0 0.37
+    1 0.60
+    2 0.60
+    3 0.37
+
+    See Also
+    --------
+    katz_centrality
+    eigenvector_centrality_numpy
+    eigenvector_centrality
+    pagerank
+    hits
+
+    Notes
+    -----
+    Katz centrality was introduced by [2]_.
+
+    This algorithm uses a direct linear solver to solve the above equation.
+    The parameter ``alpha`` should be strictly less than the inverse of largest
+    eigenvalue of the adjacency matrix for there to be a solution.
+    You can use ``max(nx.adjacency_spectrum(G))`` to get $\lambda_{\max}$ the largest
+    eigenvalue of the adjacency matrix.
+
+    When $\alpha = 1/\lambda_{\max}$ and $\beta=0$, Katz centrality is the same
+    as eigenvector centrality.
+
+    For directed graphs this finds "left" eigenvectors which corresponds
+    to the in-edges in the graph. For out-edges Katz centrality
+    first reverse the graph with ``G.reverse()``.
+
+    References
+    ----------
+    .. [1] Mark E. J. Newman:
+       Networks: An Introduction.
+       Oxford University Press, USA, 2010, p. 173.
+    .. [2] Leo Katz:
+       A New Status Index Derived from Sociometric Index.
+       Psychometrika 18(1):39–43, 1953
+       https://link.springer.com/content/pdf/10.1007/BF02289026.pdf
+    """
+    import numpy as np
+
+    if len(G) == 0:
+        return {}
+    try:
+        nodelist = beta.keys()
+        if set(nodelist) != set(G):
+            raise nx.NetworkXError(
+                "beta dictionary " "must have a value for every node"
+            )
+        b = np.array(list(beta.values()), dtype=float)
+    except AttributeError:
+        nodelist = list(G)
+        try:
+            b = np.ones((len(nodelist), 1)) * beta
+        except (TypeError, ValueError, AttributeError) as err:
+            raise nx.NetworkXError("beta must be a number") from err
+
+    A = nx.adjacency_matrix(G, nodelist=nodelist, weight=weight).todense().T
+    n = A.shape[0]
+    centrality = np.linalg.solve(np.eye(n, n) - (alpha * A), b)
+    if normalized:
+        norm = np.sign(sum(centrality)) * np.linalg.norm(centrality)
+    else:
+        norm = 1.0
+    centrality = dict(zip(nodelist, map(float, centrality / norm)))
+    return centrality
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/load.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/load.py
new file mode 100644
index 0000000..c27c5fd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/load.py
@@ -0,0 +1,197 @@
+"""Load centrality."""
+from operator import itemgetter
+
+import networkx as nx
+
+__all__ = ["load_centrality", "edge_load_centrality"]
+
+
+def newman_betweenness_centrality(G, v=None, cutoff=None, normalized=True, weight=None):
+    """Compute load centrality for nodes.
+
+    The load centrality of a node is the fraction of all shortest
+    paths that pass through that node.
+
+    Parameters
+    ----------
+    G : graph
+      A networkx graph.
+
+    normalized : bool, optional (default=True)
+      If True the betweenness values are normalized by b=b/(n-1)(n-2) where
+      n is the number of nodes in G.
+
+    weight : None or string, optional (default=None)
+      If None, edge weights are ignored.
+      Otherwise holds the name of the edge attribute used as weight.
+      The weight of an edge is treated as the length or distance between the two sides.
+
+    cutoff : bool, optional (default=None)
+      If specified, only consider paths of length <= cutoff.
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with centrality as the value.
+
+    See Also
+    --------
+    betweenness_centrality
+
+    Notes
+    -----
+    Load centrality is slightly different than betweenness. It was originally
+    introduced by [2]_. For this load algorithm see [1]_.
+
+    References
+    ----------
+    .. [1] Mark E. J. Newman:
+       Scientific collaboration networks. II.
+       Shortest paths, weighted networks, and centrality.
+       Physical Review E 64, 016132, 2001.
+       http://journals.aps.org/pre/abstract/10.1103/PhysRevE.64.016132
+    .. [2] Kwang-Il Goh, Byungnam Kahng and Doochul Kim
+       Universal behavior of Load Distribution in Scale-Free Networks.
+       Physical Review Letters 87(27):1–4, 2001.
+       https://doi.org/10.1103/PhysRevLett.87.278701
+    """
+    if v is not None:  # only one node
+        betweenness = 0.0
+        for source in G:
+            ubetween = _node_betweenness(G, source, cutoff, False, weight)
+            betweenness += ubetween[v] if v in ubetween else 0
+        if normalized:
+            order = G.order()
+            if order <= 2:
+                return betweenness  # no normalization b=0 for all nodes
+            betweenness *= 1.0 / ((order - 1) * (order - 2))
+    else:
+        betweenness = {}.fromkeys(G, 0.0)
+        for source in betweenness:
+            ubetween = _node_betweenness(G, source, cutoff, False, weight)
+            for vk in ubetween:
+                betweenness[vk] += ubetween[vk]
+        if normalized:
+            order = G.order()
+            if order <= 2:
+                return betweenness  # no normalization b=0 for all nodes
+            scale = 1.0 / ((order - 1) * (order - 2))
+            for v in betweenness:
+                betweenness[v] *= scale
+    return betweenness  # all nodes
+
+
+def _node_betweenness(G, source, cutoff=False, normalized=True, weight=None):
+    """Node betweenness_centrality helper:
+
+    See betweenness_centrality for what you probably want.
+    This actually computes "load" and not betweenness.
+    See https://networkx.lanl.gov/ticket/103
+
+    This calculates the load of each node for paths from a single source.
+    (The fraction of number of shortests paths from source that go
+    through each node.)
+
+    To get the load for a node you need to do all-pairs shortest paths.
+
+    If weight is not None then use Dijkstra for finding shortest paths.
+    """
+    # get the predecessor and path length data
+    if weight is None:
+        (pred, length) = nx.predecessor(G, source, cutoff=cutoff, return_seen=True)
+    else:
+        (pred, length) = nx.dijkstra_predecessor_and_distance(G, source, cutoff, weight)
+
+    # order the nodes by path length
+    onodes = [(l, vert) for (vert, l) in length.items()]
+    onodes.sort()
+    onodes[:] = [vert for (l, vert) in onodes if l > 0]
+
+    # initialize betweenness
+    between = {}.fromkeys(length, 1.0)
+
+    while onodes:
+        v = onodes.pop()
+        if v in pred:
+            num_paths = len(pred[v])  # Discount betweenness if more than
+            for x in pred[v]:  # one shortest path.
+                if x == source:  # stop if hit source because all remaining v
+                    break  # also have pred[v]==[source]
+                between[x] += between[v] / num_paths
+    #  remove source
+    for v in between:
+        between[v] -= 1
+    # rescale to be between 0 and 1
+    if normalized:
+        l = len(between)
+        if l > 2:
+            # scale by 1/the number of possible paths
+            scale = 1 / ((l - 1) * (l - 2))
+            for v in between:
+                between[v] *= scale
+    return between
+
+
+load_centrality = newman_betweenness_centrality
+
+
+def edge_load_centrality(G, cutoff=False):
+    """Compute edge load.
+
+    WARNING: This concept of edge load has not been analysed
+    or discussed outside of NetworkX that we know of.
+    It is based loosely on load_centrality in the sense that
+    it counts the number of shortest paths which cross each edge.
+    This function is for demonstration and testing purposes.
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    cutoff : bool, optional (default=False)
+        If specified, only consider paths of length <= cutoff.
+
+    Returns
+    -------
+    A dict keyed by edge 2-tuple to the number of shortest paths
+    which use that edge. Where more than one path is shortest
+    the count is divided equally among paths.
+    """
+    betweenness = {}
+    for u, v in G.edges():
+        betweenness[(u, v)] = 0.0
+        betweenness[(v, u)] = 0.0
+
+    for source in G:
+        ubetween = _edge_betweenness(G, source, cutoff=cutoff)
+        for e, ubetweenv in ubetween.items():
+            betweenness[e] += ubetweenv  # cumulative total
+    return betweenness
+
+
+def _edge_betweenness(G, source, nodes=None, cutoff=False):
+    """Edge betweenness helper."""
+    # get the predecessor data
+    (pred, length) = nx.predecessor(G, source, cutoff=cutoff, return_seen=True)
+    # order the nodes by path length
+    onodes = [n for n, d in sorted(length.items(), key=itemgetter(1))]
+    # initialize betweenness, doesn't account for any edge weights
+    between = {}
+    for u, v in G.edges(nodes):
+        between[(u, v)] = 1.0
+        between[(v, u)] = 1.0
+
+    while onodes:  # work through all paths
+        v = onodes.pop()
+        if v in pred:
+            # Discount betweenness if more than one shortest path.
+            num_paths = len(pred[v])
+            for w in pred[v]:
+                if w in pred:
+                    # Discount betweenness, mult path
+                    num_paths = len(pred[w])
+                    for x in pred[w]:
+                        between[(w, x)] += between[(v, w)] / num_paths
+                        between[(x, w)] += between[(w, v)] / num_paths
+    return between
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/percolation.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/percolation.py
new file mode 100644
index 0000000..4d70338
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/percolation.py
@@ -0,0 +1,124 @@
+"""Percolation centrality measures."""
+
+import networkx as nx
+from networkx.algorithms.centrality.betweenness import (
+    _single_source_dijkstra_path_basic as dijkstra,
+)
+from networkx.algorithms.centrality.betweenness import (
+    _single_source_shortest_path_basic as shortest_path,
+)
+
+__all__ = ["percolation_centrality"]
+
+
+def percolation_centrality(G, attribute="percolation", states=None, weight=None):
+    r"""Compute the percolation centrality for nodes.
+
+    Percolation centrality of a node $v$, at a given time, is defined
+    as the proportion of ‘percolated paths’ that go through that node.
+
+    This measure quantifies relative impact of nodes based on their
+    topological connectivity, as well as their percolation states.
+
+    Percolation states of nodes are used to depict network percolation
+    scenarios (such as during infection transmission in a social network
+    of individuals, spreading of computer viruses on computer networks, or
+    transmission of disease over a network of towns) over time. In this
+    measure usually the percolation state is expressed as a decimal
+    between 0.0 and 1.0.
+
+    When all nodes are in the same percolated state this measure is
+    equivalent to betweenness centrality.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.
+
+    attribute : None or string, optional (default='percolation')
+      Name of the node attribute to use for percolation state, used
+      if `states` is None.
+
+    states : None or dict, optional (default=None)
+      Specify percolation states for the nodes, nodes as keys states
+      as values.
+
+    weight : None or string, optional (default=None)
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+      The weight of an edge is treated as the length or distance between the two sides.
+
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with percolation centrality as the value.
+
+    See Also
+    --------
+    betweenness_centrality
+
+    Notes
+    -----
+    The algorithm is from Mahendra Piraveenan, Mikhail Prokopenko, and
+    Liaquat Hossain [1]_
+    Pair dependecies are calculated and accumulated using [2]_
+
+    For weighted graphs the edge weights must be greater than zero.
+    Zero edge weights can produce an infinite number of equal length
+    paths between pairs of nodes.
+
+    References
+    ----------
+    .. [1] Mahendra Piraveenan, Mikhail Prokopenko, Liaquat Hossain
+       Percolation Centrality: Quantifying Graph-Theoretic Impact of Nodes
+       during Percolation in Networks
+       http://journals.plos.org/plosone/article?id=10.1371/journal.pone.0053095
+    .. [2] Ulrik Brandes:
+       A Faster Algorithm for Betweenness Centrality.
+       Journal of Mathematical Sociology 25(2):163-177, 2001.
+       https://doi.org/10.1080/0022250X.2001.9990249
+    """
+    percolation = dict.fromkeys(G, 0.0)  # b[v]=0 for v in G
+
+    nodes = G
+
+    if states is None:
+        states = nx.get_node_attributes(nodes, attribute)
+
+    # sum of all percolation states
+    p_sigma_x_t = 0.0
+    for v in states.values():
+        p_sigma_x_t += v
+
+    for s in nodes:
+        # single source shortest paths
+        if weight is None:  # use BFS
+            S, P, sigma, _ = shortest_path(G, s)
+        else:  # use Dijkstra's algorithm
+            S, P, sigma, _ = dijkstra(G, s, weight)
+        # accumulation
+        percolation = _accumulate_percolation(
+            percolation, S, P, sigma, s, states, p_sigma_x_t
+        )
+
+    n = len(G)
+
+    for v in percolation:
+        percolation[v] *= 1 / (n - 2)
+
+    return percolation
+
+
+def _accumulate_percolation(percolation, S, P, sigma, s, states, p_sigma_x_t):
+    delta = dict.fromkeys(S, 0)
+    while S:
+        w = S.pop()
+        coeff = (1 + delta[w]) / sigma[w]
+        for v in P[w]:
+            delta[v] += sigma[v] * coeff
+        if w != s:
+            # percolation weight
+            pw_s_w = states[s] / (p_sigma_x_t - states[w])
+            percolation[w] += delta[w] * pw_s_w
+    return percolation
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/reaching.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/reaching.py
new file mode 100644
index 0000000..3f3fb48
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/reaching.py
@@ -0,0 +1,204 @@
+"""Functions for computing reaching centrality of a node or a graph."""
+
+import networkx as nx
+from networkx.utils import pairwise
+
+__all__ = ["global_reaching_centrality", "local_reaching_centrality"]
+
+
+def _average_weight(G, path, weight=None):
+    """Returns the average weight of an edge in a weighted path.
+
+    Parameters
+    ----------
+    G : graph
+      A networkx graph.
+
+    path: list
+      A list of vertices that define the path.
+
+    weight : None or string, optional (default=None)
+      If None, edge weights are ignored.  Then the average weight of an edge
+      is assumed to be the multiplicative inverse of the length of the path.
+      Otherwise holds the name of the edge attribute used as weight.
+    """
+    path_length = len(path) - 1
+    if path_length <= 0:
+        return 0
+    if weight is None:
+        return 1 / path_length
+    total_weight = sum(G.edges[i, j][weight] for i, j in pairwise(path))
+    return total_weight / path_length
+
+
+def global_reaching_centrality(G, weight=None, normalized=True):
+    """Returns the global reaching centrality of a directed graph.
+
+    The *global reaching centrality* of a weighted directed graph is the
+    average over all nodes of the difference between the local reaching
+    centrality of the node and the greatest local reaching centrality of
+    any node in the graph [1]_. For more information on the local
+    reaching centrality, see :func:`local_reaching_centrality`.
+    Informally, the local reaching centrality is the proportion of the
+    graph that is reachable from the neighbors of the node.
+
+    Parameters
+    ----------
+    G : DiGraph
+        A networkx DiGraph.
+
+    weight : None or string, optional (default=None)
+        Attribute to use for edge weights. If ``None``, each edge weight
+        is assumed to be one. A higher weight implies a stronger
+        connection between nodes and a *shorter* path length.
+
+    normalized : bool, optional (default=True)
+        Whether to normalize the edge weights by the total sum of edge
+        weights.
+
+    Returns
+    -------
+    h : float
+        The global reaching centrality of the graph.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_edge(1, 2)
+    >>> G.add_edge(1, 3)
+    >>> nx.global_reaching_centrality(G)
+    1.0
+    >>> G.add_edge(3, 2)
+    >>> nx.global_reaching_centrality(G)
+    0.75
+
+    See also
+    --------
+    local_reaching_centrality
+
+    References
+    ----------
+    .. [1] Mones, Enys, Lilla Vicsek, and Tamás Vicsek.
+           "Hierarchy Measure for Complex Networks."
+           *PLoS ONE* 7.3 (2012): e33799.
+           https://doi.org/10.1371/journal.pone.0033799
+    """
+    if nx.is_negatively_weighted(G, weight=weight):
+        raise nx.NetworkXError("edge weights must be positive")
+    total_weight = G.size(weight=weight)
+    if total_weight <= 0:
+        raise nx.NetworkXError("Size of G must be positive")
+
+    # If provided, weights must be interpreted as connection strength
+    # (so higher weights are more likely to be chosen). However, the
+    # shortest path algorithms in NetworkX assume the provided "weight"
+    # is actually a distance (so edges with higher weight are less
+    # likely to be chosen). Therefore we need to invert the weights when
+    # computing shortest paths.
+    #
+    # If weight is None, we leave it as-is so that the shortest path
+    # algorithm can use a faster, unweighted algorithm.
+    if weight is not None:
+
+        def as_distance(u, v, d):
+            return total_weight / d.get(weight, 1)
+
+        shortest_paths = nx.shortest_path(G, weight=as_distance)
+    else:
+        shortest_paths = nx.shortest_path(G)
+
+    centrality = local_reaching_centrality
+    # TODO This can be trivially parallelized.
+    lrc = [
+        centrality(G, node, paths=paths, weight=weight, normalized=normalized)
+        for node, paths in shortest_paths.items()
+    ]
+
+    max_lrc = max(lrc)
+    return sum(max_lrc - c for c in lrc) / (len(G) - 1)
+
+
+def local_reaching_centrality(G, v, paths=None, weight=None, normalized=True):
+    """Returns the local reaching centrality of a node in a directed
+    graph.
+
+    The *local reaching centrality* of a node in a directed graph is the
+    proportion of other nodes reachable from that node [1]_.
+
+    Parameters
+    ----------
+    G : DiGraph
+        A NetworkX DiGraph.
+
+    v : node
+        A node in the directed graph `G`.
+
+    paths : dictionary (default=None)
+        If this is not `None` it must be a dictionary representation
+        of single-source shortest paths, as computed by, for example,
+        :func:`networkx.shortest_path` with source node `v`. Use this
+        keyword argument if you intend to invoke this function many
+        times but don't want the paths to be recomputed each time.
+
+    weight : None or string, optional (default=None)
+        Attribute to use for edge weights.  If `None`, each edge weight
+        is assumed to be one. A higher weight implies a stronger
+        connection between nodes and a *shorter* path length.
+
+    normalized : bool, optional (default=True)
+        Whether to normalize the edge weights by the total sum of edge
+        weights.
+
+    Returns
+    -------
+    h : float
+        The local reaching centrality of the node ``v`` in the graph
+        ``G``.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_edges_from([(1, 2), (1, 3)])
+    >>> nx.local_reaching_centrality(G, 3)
+    0.0
+    >>> G.add_edge(3, 2)
+    >>> nx.local_reaching_centrality(G, 3)
+    0.5
+
+    See also
+    --------
+    global_reaching_centrality
+
+    References
+    ----------
+    .. [1] Mones, Enys, Lilla Vicsek, and Tamás Vicsek.
+           "Hierarchy Measure for Complex Networks."
+           *PLoS ONE* 7.3 (2012): e33799.
+           https://doi.org/10.1371/journal.pone.0033799
+    """
+    if paths is None:
+        if nx.is_negatively_weighted(G, weight=weight):
+            raise nx.NetworkXError("edge weights must be positive")
+        total_weight = G.size(weight=weight)
+        if total_weight <= 0:
+            raise nx.NetworkXError("Size of G must be positive")
+        if weight is not None:
+            # Interpret weights as lengths.
+            def as_distance(u, v, d):
+                return total_weight / d.get(weight, 1)
+
+            paths = nx.shortest_path(G, source=v, weight=as_distance)
+        else:
+            paths = nx.shortest_path(G, source=v)
+    # If the graph is unweighted, simply return the proportion of nodes
+    # reachable from the source node ``v``.
+    if weight is None and G.is_directed():
+        return (len(paths) - 1) / (len(G) - 1)
+    if normalized and weight is not None:
+        norm = G.size(weight=weight) / G.size()
+    else:
+        norm = 1
+    # TODO This can be trivially parallelized.
+    avgw = (_average_weight(G, path, weight=weight) for path in paths.values())
+    sum_avg_weight = sum(avgw) / norm
+    return sum_avg_weight / (len(G) - 1)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/second_order.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/second_order.py
new file mode 100644
index 0000000..3acd69e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/second_order.py
@@ -0,0 +1,133 @@
+"""Copyright (c) 2015 – Thomson Licensing, SAS
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted (subject to the limitations in the
+disclaimer below) 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 Thomson Licensing, or Technicolor, nor the names
+of its contributors may be used to endorse or promote products derived
+from this software without specific prior written permission.
+
+NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
+GRANTED BY THIS LICENSE.  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.
+"""
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+# Authors: Erwan Le Merrer (erwan.lemerrer@technicolor.com)
+
+__all__ = ["second_order_centrality"]
+
+
+@not_implemented_for("directed")
+def second_order_centrality(G):
+    """Compute the second order centrality for nodes of G.
+
+    The second order centrality of a given node is the standard deviation of
+    the return times to that node of a perpetual random walk on G:
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX connected and undirected graph.
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary keyed by node with second order centrality as the value.
+
+    Examples
+    --------
+    >>> G = nx.star_graph(10)
+    >>> soc = nx.second_order_centrality(G)
+    >>> print(sorted(soc.items(), key=lambda x: x[1])[0][0])  # pick first id
+    0
+
+    Raises
+    ------
+    NetworkXException
+        If the graph G is empty, non connected or has negative weights.
+
+    See Also
+    --------
+    betweenness_centrality
+
+    Notes
+    -----
+    Lower values of second order centrality indicate higher centrality.
+
+    The algorithm is from Kermarrec, Le Merrer, Sericola and Trédan [1]_.
+
+    This code implements the analytical version of the algorithm, i.e.,
+    there is no simulation of a random walk process involved. The random walk
+    is here unbiased (corresponding to eq 6 of the paper [1]_), thus the
+    centrality values are the standard deviations for random walk return times
+    on the transformed input graph G (equal in-degree at each nodes by adding
+    self-loops).
+
+    Complexity of this implementation, made to run locally on a single machine,
+    is O(n^3), with n the size of G, which makes it viable only for small
+    graphs.
+
+    References
+    ----------
+    .. [1] Anne-Marie Kermarrec, Erwan Le Merrer, Bruno Sericola, Gilles Trédan
+       "Second order centrality: Distributed assessment of nodes criticity in
+       complex networks", Elsevier Computer Communications 34(5):619-628, 2011.
+    """
+    import numpy as np
+
+    n = len(G)
+
+    if n == 0:
+        raise nx.NetworkXException("Empty graph.")
+    if not nx.is_connected(G):
+        raise nx.NetworkXException("Non connected graph.")
+    if any(d.get("weight", 0) < 0 for u, v, d in G.edges(data=True)):
+        raise nx.NetworkXException("Graph has negative edge weights.")
+
+    # balancing G for Metropolis-Hastings random walks
+    G = nx.DiGraph(G)
+    in_deg = dict(G.in_degree(weight="weight"))
+    d_max = max(in_deg.values())
+    for i, deg in in_deg.items():
+        if deg < d_max:
+            G.add_edge(i, i, weight=d_max - deg)
+
+    P = nx.to_numpy_array(G)
+    P /= P.sum(axis=1)[:, np.newaxis]  # to transition probability matrix
+
+    def _Qj(P, j):
+        P = P.copy()
+        P[:, j] = 0
+        return P
+
+    M = np.empty([n, n])
+
+    for i in range(n):
+        M[:, i] = np.linalg.solve(
+            np.identity(n) - _Qj(P, i), np.ones([n, 1])[:, 0]
+        )  # eq 3
+
+    return dict(
+        zip(G.nodes, [np.sqrt(2 * np.sum(M[:, i]) - n * (n + 1)) for i in range(n)])
+    )  # eq 6
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/subgraph_alg.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/subgraph_alg.py
new file mode 100644
index 0000000..0f52d51
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/subgraph_alg.py
@@ -0,0 +1,338 @@
+"""
+Subraph centrality and communicability betweenness.
+"""
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "subgraph_centrality_exp",
+    "subgraph_centrality",
+    "communicability_betweenness_centrality",
+    "estrada_index",
+]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def subgraph_centrality_exp(G):
+    r"""Returns the subgraph centrality for each node of G.
+
+    Subgraph centrality  of a node `n` is the sum of weighted closed
+    walks of all lengths starting and ending at node `n`. The weights
+    decrease with path length. Each closed walk is associated with a
+    connected subgraph ([1]_).
+
+    Parameters
+    ----------
+    G: graph
+
+    Returns
+    -------
+    nodes:dictionary
+        Dictionary of nodes with subgraph centrality as the value.
+
+    Raises
+    ------
+    NetworkXError
+        If the graph is not undirected and simple.
+
+    See Also
+    --------
+    subgraph_centrality:
+        Alternative algorithm of the subgraph centrality for each node of G.
+
+    Notes
+    -----
+    This version of the algorithm exponentiates the adjacency matrix.
+
+    The subgraph centrality of a node `u` in G can be found using
+    the matrix exponential of the adjacency matrix of G [1]_,
+
+    .. math::
+
+        SC(u)=(e^A)_{uu} .
+
+    References
+    ----------
+    .. [1] Ernesto Estrada, Juan A. Rodriguez-Velazquez,
+       "Subgraph centrality in complex networks",
+       Physical Review E 71, 056103 (2005).
+       https://arxiv.org/abs/cond-mat/0504730
+
+    Examples
+    --------
+    (Example from [1]_)
+    >>> G = nx.Graph(
+    ...     [
+    ...         (1, 2),
+    ...         (1, 5),
+    ...         (1, 8),
+    ...         (2, 3),
+    ...         (2, 8),
+    ...         (3, 4),
+    ...         (3, 6),
+    ...         (4, 5),
+    ...         (4, 7),
+    ...         (5, 6),
+    ...         (6, 7),
+    ...         (7, 8),
+    ...     ]
+    ... )
+    >>> sc = nx.subgraph_centrality_exp(G)
+    >>> print([f"{node} {sc[node]:0.2f}" for node in sorted(sc)])
+    ['1 3.90', '2 3.90', '3 3.64', '4 3.71', '5 3.64', '6 3.71', '7 3.64', '8 3.90']
+    """
+    # alternative implementation that calculates the matrix exponential
+    import scipy as sp
+    import scipy.linalg  # call as sp.linalg
+
+    nodelist = list(G)  # ordering of nodes in matrix
+    A = nx.to_numpy_array(G, nodelist)
+    # convert to 0-1 matrix
+    A[A != 0.0] = 1
+    expA = sp.linalg.expm(A)
+    # convert diagonal to dictionary keyed by node
+    sc = dict(zip(nodelist, map(float, expA.diagonal())))
+    return sc
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def subgraph_centrality(G):
+    r"""Returns subgraph centrality for each node in G.
+
+    Subgraph centrality  of a node `n` is the sum of weighted closed
+    walks of all lengths starting and ending at node `n`. The weights
+    decrease with path length. Each closed walk is associated with a
+    connected subgraph ([1]_).
+
+    Parameters
+    ----------
+    G: graph
+
+    Returns
+    -------
+    nodes : dictionary
+       Dictionary of nodes with subgraph centrality as the value.
+
+    Raises
+    ------
+    NetworkXError
+       If the graph is not undirected and simple.
+
+    See Also
+    --------
+    subgraph_centrality_exp:
+        Alternative algorithm of the subgraph centrality for each node of G.
+
+    Notes
+    -----
+    This version of the algorithm computes eigenvalues and eigenvectors
+    of the adjacency matrix.
+
+    Subgraph centrality of a node `u` in G can be found using
+    a spectral decomposition of the adjacency matrix [1]_,
+
+    .. math::
+
+       SC(u)=\sum_{j=1}^{N}(v_{j}^{u})^2 e^{\lambda_{j}},
+
+    where `v_j` is an eigenvector of the adjacency matrix `A` of G
+    corresponding to the eigenvalue `\lambda_j`.
+
+    Examples
+    --------
+    (Example from [1]_)
+    >>> G = nx.Graph(
+    ...     [
+    ...         (1, 2),
+    ...         (1, 5),
+    ...         (1, 8),
+    ...         (2, 3),
+    ...         (2, 8),
+    ...         (3, 4),
+    ...         (3, 6),
+    ...         (4, 5),
+    ...         (4, 7),
+    ...         (5, 6),
+    ...         (6, 7),
+    ...         (7, 8),
+    ...     ]
+    ... )
+    >>> sc = nx.subgraph_centrality(G)
+    >>> print([f"{node} {sc[node]:0.2f}" for node in sorted(sc)])
+    ['1 3.90', '2 3.90', '3 3.64', '4 3.71', '5 3.64', '6 3.71', '7 3.64', '8 3.90']
+
+    References
+    ----------
+    .. [1] Ernesto Estrada, Juan A. Rodriguez-Velazquez,
+       "Subgraph centrality in complex networks",
+       Physical Review E 71, 056103 (2005).
+       https://arxiv.org/abs/cond-mat/0504730
+
+    """
+    import numpy as np
+
+    nodelist = list(G)  # ordering of nodes in matrix
+    A = nx.to_numpy_array(G, nodelist)
+    # convert to 0-1 matrix
+    A[np.nonzero(A)] = 1
+    w, v = np.linalg.eigh(A)
+    vsquare = np.array(v) ** 2
+    expw = np.exp(w)
+    xg = vsquare @ expw
+    # convert vector dictionary keyed by node
+    sc = dict(zip(nodelist, map(float, xg)))
+    return sc
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def communicability_betweenness_centrality(G):
+    r"""Returns subgraph communicability for all pairs of nodes in G.
+
+    Communicability betweenness measure makes use of the number of walks
+    connecting every pair of nodes as the basis of a betweenness centrality
+    measure.
+
+    Parameters
+    ----------
+    G: graph
+
+    Returns
+    -------
+    nodes : dictionary
+        Dictionary of nodes with communicability betweenness as the value.
+
+    Raises
+    ------
+    NetworkXError
+        If the graph is not undirected and simple.
+
+    Notes
+    -----
+    Let `G=(V,E)` be a simple undirected graph with `n` nodes and `m` edges,
+    and `A` denote the adjacency matrix of `G`.
+
+    Let `G(r)=(V,E(r))` be the graph resulting from
+    removing all edges connected to node `r` but not the node itself.
+
+    The adjacency matrix for `G(r)` is `A+E(r)`,  where `E(r)` has nonzeros
+    only in row and column `r`.
+
+    The subraph betweenness of a node `r`  is [1]_
+
+    .. math::
+
+         \omega_{r} = \frac{1}{C}\sum_{p}\sum_{q}\frac{G_{prq}}{G_{pq}},
+         p\neq q, q\neq r,
+
+    where
+    `G_{prq}=(e^{A}_{pq} - (e^{A+E(r)})_{pq}`  is the number of walks
+    involving node r,
+    `G_{pq}=(e^{A})_{pq}` is the number of closed walks starting
+    at node `p` and ending at node `q`,
+    and `C=(n-1)^{2}-(n-1)` is a normalization factor equal to the
+    number of terms in the sum.
+
+    The resulting `\omega_{r}` takes values between zero and one.
+    The lower bound cannot be attained for a connected
+    graph, and the upper bound is attained in the star graph.
+
+    References
+    ----------
+    .. [1] Ernesto Estrada, Desmond J. Higham, Naomichi Hatano,
+       "Communicability Betweenness in Complex Networks"
+       Physica A 388 (2009) 764-774.
+       https://arxiv.org/abs/0905.4102
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (1, 2), (1, 5), (5, 4), (2, 4), (2, 3), (4, 3), (3, 6)])
+    >>> cbc = nx.communicability_betweenness_centrality(G)
+    >>> print([f"{node} {cbc[node]:0.2f}" for node in sorted(cbc)])
+    ['0 0.03', '1 0.45', '2 0.51', '3 0.45', '4 0.40', '5 0.19', '6 0.03']
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.linalg  # call as sp.linalg
+
+    nodelist = list(G)  # ordering of nodes in matrix
+    n = len(nodelist)
+    A = nx.to_numpy_array(G, nodelist)
+    # convert to 0-1 matrix
+    A[np.nonzero(A)] = 1
+    expA = sp.linalg.expm(A)
+    mapping = dict(zip(nodelist, range(n)))
+    cbc = {}
+    for v in G:
+        # remove row and col of node v
+        i = mapping[v]
+        row = A[i, :].copy()
+        col = A[:, i].copy()
+        A[i, :] = 0
+        A[:, i] = 0
+        B = (expA - sp.linalg.expm(A)) / expA
+        # sum with row/col of node v and diag set to zero
+        B[i, :] = 0
+        B[:, i] = 0
+        B -= np.diag(np.diag(B))
+        cbc[v] = B.sum()
+        # put row and col back
+        A[i, :] = row
+        A[:, i] = col
+    # rescale when more than two nodes
+    order = len(cbc)
+    if order > 2:
+        scale = 1.0 / ((order - 1.0) ** 2 - (order - 1.0))
+        for v in cbc:
+            cbc[v] *= scale
+    return cbc
+
+
+def estrada_index(G):
+    r"""Returns the Estrada index of a the graph G.
+
+    The Estrada Index is a topological index of folding or 3D "compactness" ([1]_).
+
+    Parameters
+    ----------
+    G: graph
+
+    Returns
+    -------
+    estrada index: float
+
+    Raises
+    ------
+    NetworkXError
+        If the graph is not undirected and simple.
+
+    Notes
+    -----
+    Let `G=(V,E)` be a simple undirected graph with `n` nodes  and let
+    `\lambda_{1}\leq\lambda_{2}\leq\cdots\lambda_{n}`
+    be a non-increasing ordering of the eigenvalues of its adjacency
+    matrix `A`. The Estrada index is ([1]_, [2]_)
+
+    .. math::
+        EE(G)=\sum_{j=1}^n e^{\lambda _j}.
+
+    References
+    ----------
+    .. [1] E. Estrada, "Characterization of 3D molecular structure",
+       Chem. Phys. Lett. 319, 713 (2000).
+       https://doi.org/10.1016/S0009-2614(00)00158-5
+    .. [2] José Antonio de la Peñaa, Ivan Gutman, Juan Rada,
+       "Estimating the Estrada index",
+       Linear Algebra and its Applications. 427, 1 (2007).
+       https://doi.org/10.1016/j.laa.2007.06.020
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (1, 2), (1, 5), (5, 4), (2, 4), (2, 3), (4, 3), (3, 6)])
+    >>> ei = nx.estrada_index(G)
+    >>> print(f"{ei:0.5}")
+    20.55
+    """
+    return sum(subgraph_centrality(G).values())
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_betweenness_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_betweenness_centrality.py
new file mode 100644
index 0000000..4c059cf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_betweenness_centrality.py
@@ -0,0 +1,780 @@
+import pytest
+
+import networkx as nx
+
+
+def weighted_G():
+    G = nx.Graph()
+    G.add_edge(0, 1, weight=3)
+    G.add_edge(0, 2, weight=2)
+    G.add_edge(0, 3, weight=6)
+    G.add_edge(0, 4, weight=4)
+    G.add_edge(1, 3, weight=5)
+    G.add_edge(1, 5, weight=5)
+    G.add_edge(2, 4, weight=1)
+    G.add_edge(3, 4, weight=2)
+    G.add_edge(3, 5, weight=1)
+    G.add_edge(4, 5, weight=4)
+    return G
+
+
+class TestBetweennessCentrality:
+    def test_K5(self):
+        """Betweenness centrality: K5"""
+        G = nx.complete_graph(5)
+        b = nx.betweenness_centrality(G, weight=None, normalized=False)
+        b_answer = {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_K5_endpoints(self):
+        """Betweenness centrality: K5 endpoints"""
+        G = nx.complete_graph(5)
+        b = nx.betweenness_centrality(G, weight=None, normalized=False, endpoints=True)
+        b_answer = {0: 4.0, 1: 4.0, 2: 4.0, 3: 4.0, 4: 4.0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        # normalized = True case
+        b = nx.betweenness_centrality(G, weight=None, normalized=True, endpoints=True)
+        b_answer = {0: 0.4, 1: 0.4, 2: 0.4, 3: 0.4, 4: 0.4}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P3_normalized(self):
+        """Betweenness centrality: P3 normalized"""
+        G = nx.path_graph(3)
+        b = nx.betweenness_centrality(G, weight=None, normalized=True)
+        b_answer = {0: 0.0, 1: 1.0, 2: 0.0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P3(self):
+        """Betweenness centrality: P3"""
+        G = nx.path_graph(3)
+        b_answer = {0: 0.0, 1: 1.0, 2: 0.0}
+        b = nx.betweenness_centrality(G, weight=None, normalized=False)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_sample_from_P3(self):
+        """Betweenness centrality: P3 sample"""
+        G = nx.path_graph(3)
+        b_answer = {0: 0.0, 1: 1.0, 2: 0.0}
+        b = nx.betweenness_centrality(G, k=3, weight=None, normalized=False, seed=1)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        b = nx.betweenness_centrality(G, k=2, weight=None, normalized=False, seed=1)
+        # python versions give different results with same seed
+        b_approx1 = {0: 0.0, 1: 1.5, 2: 0.0}
+        b_approx2 = {0: 0.0, 1: 0.75, 2: 0.0}
+        for n in sorted(G):
+            assert b[n] in (b_approx1[n], b_approx2[n])
+
+    def test_P3_endpoints(self):
+        """Betweenness centrality: P3 endpoints"""
+        G = nx.path_graph(3)
+        b_answer = {0: 2.0, 1: 3.0, 2: 2.0}
+        b = nx.betweenness_centrality(G, weight=None, normalized=False, endpoints=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        # normalized = True case
+        b_answer = {0: 2 / 3, 1: 1.0, 2: 2 / 3}
+        b = nx.betweenness_centrality(G, weight=None, normalized=True, endpoints=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_krackhardt_kite_graph(self):
+        """Betweenness centrality: Krackhardt kite graph"""
+        G = nx.krackhardt_kite_graph()
+        b_answer = {
+            0: 1.667,
+            1: 1.667,
+            2: 0.000,
+            3: 7.333,
+            4: 0.000,
+            5: 16.667,
+            6: 16.667,
+            7: 28.000,
+            8: 16.000,
+            9: 0.000,
+        }
+        for b in b_answer:
+            b_answer[b] /= 2
+        b = nx.betweenness_centrality(G, weight=None, normalized=False)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_krackhardt_kite_graph_normalized(self):
+        """Betweenness centrality: Krackhardt kite graph normalized"""
+        G = nx.krackhardt_kite_graph()
+        b_answer = {
+            0: 0.023,
+            1: 0.023,
+            2: 0.000,
+            3: 0.102,
+            4: 0.000,
+            5: 0.231,
+            6: 0.231,
+            7: 0.389,
+            8: 0.222,
+            9: 0.000,
+        }
+        b = nx.betweenness_centrality(G, weight=None, normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_florentine_families_graph(self):
+        """Betweenness centrality: Florentine families graph"""
+        G = nx.florentine_families_graph()
+        b_answer = {
+            "Acciaiuoli": 0.000,
+            "Albizzi": 0.212,
+            "Barbadori": 0.093,
+            "Bischeri": 0.104,
+            "Castellani": 0.055,
+            "Ginori": 0.000,
+            "Guadagni": 0.255,
+            "Lamberteschi": 0.000,
+            "Medici": 0.522,
+            "Pazzi": 0.000,
+            "Peruzzi": 0.022,
+            "Ridolfi": 0.114,
+            "Salviati": 0.143,
+            "Strozzi": 0.103,
+            "Tornabuoni": 0.092,
+        }
+
+        b = nx.betweenness_centrality(G, weight=None, normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_les_miserables_graph(self):
+        """Betweenness centrality: Les Miserables graph"""
+        G = nx.les_miserables_graph()
+        b_answer = {
+            "Napoleon": 0.000,
+            "Myriel": 0.177,
+            "MlleBaptistine": 0.000,
+            "MmeMagloire": 0.000,
+            "CountessDeLo": 0.000,
+            "Geborand": 0.000,
+            "Champtercier": 0.000,
+            "Cravatte": 0.000,
+            "Count": 0.000,
+            "OldMan": 0.000,
+            "Valjean": 0.570,
+            "Labarre": 0.000,
+            "Marguerite": 0.000,
+            "MmeDeR": 0.000,
+            "Isabeau": 0.000,
+            "Gervais": 0.000,
+            "Listolier": 0.000,
+            "Tholomyes": 0.041,
+            "Fameuil": 0.000,
+            "Blacheville": 0.000,
+            "Favourite": 0.000,
+            "Dahlia": 0.000,
+            "Zephine": 0.000,
+            "Fantine": 0.130,
+            "MmeThenardier": 0.029,
+            "Thenardier": 0.075,
+            "Cosette": 0.024,
+            "Javert": 0.054,
+            "Fauchelevent": 0.026,
+            "Bamatabois": 0.008,
+            "Perpetue": 0.000,
+            "Simplice": 0.009,
+            "Scaufflaire": 0.000,
+            "Woman1": 0.000,
+            "Judge": 0.000,
+            "Champmathieu": 0.000,
+            "Brevet": 0.000,
+            "Chenildieu": 0.000,
+            "Cochepaille": 0.000,
+            "Pontmercy": 0.007,
+            "Boulatruelle": 0.000,
+            "Eponine": 0.011,
+            "Anzelma": 0.000,
+            "Woman2": 0.000,
+            "MotherInnocent": 0.000,
+            "Gribier": 0.000,
+            "MmeBurgon": 0.026,
+            "Jondrette": 0.000,
+            "Gavroche": 0.165,
+            "Gillenormand": 0.020,
+            "Magnon": 0.000,
+            "MlleGillenormand": 0.048,
+            "MmePontmercy": 0.000,
+            "MlleVaubois": 0.000,
+            "LtGillenormand": 0.000,
+            "Marius": 0.132,
+            "BaronessT": 0.000,
+            "Mabeuf": 0.028,
+            "Enjolras": 0.043,
+            "Combeferre": 0.001,
+            "Prouvaire": 0.000,
+            "Feuilly": 0.001,
+            "Courfeyrac": 0.005,
+            "Bahorel": 0.002,
+            "Bossuet": 0.031,
+            "Joly": 0.002,
+            "Grantaire": 0.000,
+            "MotherPlutarch": 0.000,
+            "Gueulemer": 0.005,
+            "Babet": 0.005,
+            "Claquesous": 0.005,
+            "Montparnasse": 0.004,
+            "Toussaint": 0.000,
+            "Child1": 0.000,
+            "Child2": 0.000,
+            "Brujon": 0.000,
+            "MmeHucheloup": 0.000,
+        }
+
+        b = nx.betweenness_centrality(G, weight=None, normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_ladder_graph(self):
+        """Betweenness centrality: Ladder graph"""
+        G = nx.Graph()  # ladder_graph(3)
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (4, 5), (3, 5)])
+        b_answer = {0: 1.667, 1: 1.667, 2: 6.667, 3: 6.667, 4: 1.667, 5: 1.667}
+        for b in b_answer:
+            b_answer[b] /= 2
+        b = nx.betweenness_centrality(G, weight=None, normalized=False)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_disconnected_path(self):
+        """Betweenness centrality: disconnected path"""
+        G = nx.Graph()
+        nx.add_path(G, [0, 1, 2])
+        nx.add_path(G, [3, 4, 5, 6])
+        b_answer = {0: 0, 1: 1, 2: 0, 3: 0, 4: 2, 5: 2, 6: 0}
+        b = nx.betweenness_centrality(G, weight=None, normalized=False)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_disconnected_path_endpoints(self):
+        """Betweenness centrality: disconnected path endpoints"""
+        G = nx.Graph()
+        nx.add_path(G, [0, 1, 2])
+        nx.add_path(G, [3, 4, 5, 6])
+        b_answer = {0: 2, 1: 3, 2: 2, 3: 3, 4: 5, 5: 5, 6: 3}
+        b = nx.betweenness_centrality(G, weight=None, normalized=False, endpoints=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        # normalized = True case
+        b = nx.betweenness_centrality(G, weight=None, normalized=True, endpoints=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n] / 21, abs=1e-7)
+
+    def test_directed_path(self):
+        """Betweenness centrality: directed path"""
+        G = nx.DiGraph()
+        nx.add_path(G, [0, 1, 2])
+        b = nx.betweenness_centrality(G, weight=None, normalized=False)
+        b_answer = {0: 0.0, 1: 1.0, 2: 0.0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_directed_path_normalized(self):
+        """Betweenness centrality: directed path normalized"""
+        G = nx.DiGraph()
+        nx.add_path(G, [0, 1, 2])
+        b = nx.betweenness_centrality(G, weight=None, normalized=True)
+        b_answer = {0: 0.0, 1: 0.5, 2: 0.0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+
+class TestWeightedBetweennessCentrality:
+    def test_K5(self):
+        """Weighted betweenness centrality: K5"""
+        G = nx.complete_graph(5)
+        b = nx.betweenness_centrality(G, weight="weight", normalized=False)
+        b_answer = {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P3_normalized(self):
+        """Weighted betweenness centrality: P3 normalized"""
+        G = nx.path_graph(3)
+        b = nx.betweenness_centrality(G, weight="weight", normalized=True)
+        b_answer = {0: 0.0, 1: 1.0, 2: 0.0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P3(self):
+        """Weighted betweenness centrality: P3"""
+        G = nx.path_graph(3)
+        b_answer = {0: 0.0, 1: 1.0, 2: 0.0}
+        b = nx.betweenness_centrality(G, weight="weight", normalized=False)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_krackhardt_kite_graph(self):
+        """Weighted betweenness centrality: Krackhardt kite graph"""
+        G = nx.krackhardt_kite_graph()
+        b_answer = {
+            0: 1.667,
+            1: 1.667,
+            2: 0.000,
+            3: 7.333,
+            4: 0.000,
+            5: 16.667,
+            6: 16.667,
+            7: 28.000,
+            8: 16.000,
+            9: 0.000,
+        }
+        for b in b_answer:
+            b_answer[b] /= 2
+
+        b = nx.betweenness_centrality(G, weight="weight", normalized=False)
+
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_krackhardt_kite_graph_normalized(self):
+        """Weighted betweenness centrality:
+        Krackhardt kite graph normalized
+        """
+        G = nx.krackhardt_kite_graph()
+        b_answer = {
+            0: 0.023,
+            1: 0.023,
+            2: 0.000,
+            3: 0.102,
+            4: 0.000,
+            5: 0.231,
+            6: 0.231,
+            7: 0.389,
+            8: 0.222,
+            9: 0.000,
+        }
+        b = nx.betweenness_centrality(G, weight="weight", normalized=True)
+
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_florentine_families_graph(self):
+        """Weighted betweenness centrality:
+        Florentine families graph"""
+        G = nx.florentine_families_graph()
+        b_answer = {
+            "Acciaiuoli": 0.000,
+            "Albizzi": 0.212,
+            "Barbadori": 0.093,
+            "Bischeri": 0.104,
+            "Castellani": 0.055,
+            "Ginori": 0.000,
+            "Guadagni": 0.255,
+            "Lamberteschi": 0.000,
+            "Medici": 0.522,
+            "Pazzi": 0.000,
+            "Peruzzi": 0.022,
+            "Ridolfi": 0.114,
+            "Salviati": 0.143,
+            "Strozzi": 0.103,
+            "Tornabuoni": 0.092,
+        }
+
+        b = nx.betweenness_centrality(G, weight="weight", normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_les_miserables_graph(self):
+        """Weighted betweenness centrality: Les Miserables graph"""
+        G = nx.les_miserables_graph()
+        b_answer = {
+            "Napoleon": 0.000,
+            "Myriel": 0.177,
+            "MlleBaptistine": 0.000,
+            "MmeMagloire": 0.000,
+            "CountessDeLo": 0.000,
+            "Geborand": 0.000,
+            "Champtercier": 0.000,
+            "Cravatte": 0.000,
+            "Count": 0.000,
+            "OldMan": 0.000,
+            "Valjean": 0.454,
+            "Labarre": 0.000,
+            "Marguerite": 0.009,
+            "MmeDeR": 0.000,
+            "Isabeau": 0.000,
+            "Gervais": 0.000,
+            "Listolier": 0.000,
+            "Tholomyes": 0.066,
+            "Fameuil": 0.000,
+            "Blacheville": 0.000,
+            "Favourite": 0.000,
+            "Dahlia": 0.000,
+            "Zephine": 0.000,
+            "Fantine": 0.114,
+            "MmeThenardier": 0.046,
+            "Thenardier": 0.129,
+            "Cosette": 0.075,
+            "Javert": 0.193,
+            "Fauchelevent": 0.026,
+            "Bamatabois": 0.080,
+            "Perpetue": 0.000,
+            "Simplice": 0.001,
+            "Scaufflaire": 0.000,
+            "Woman1": 0.000,
+            "Judge": 0.000,
+            "Champmathieu": 0.000,
+            "Brevet": 0.000,
+            "Chenildieu": 0.000,
+            "Cochepaille": 0.000,
+            "Pontmercy": 0.023,
+            "Boulatruelle": 0.000,
+            "Eponine": 0.023,
+            "Anzelma": 0.000,
+            "Woman2": 0.000,
+            "MotherInnocent": 0.000,
+            "Gribier": 0.000,
+            "MmeBurgon": 0.026,
+            "Jondrette": 0.000,
+            "Gavroche": 0.285,
+            "Gillenormand": 0.024,
+            "Magnon": 0.005,
+            "MlleGillenormand": 0.036,
+            "MmePontmercy": 0.005,
+            "MlleVaubois": 0.000,
+            "LtGillenormand": 0.015,
+            "Marius": 0.072,
+            "BaronessT": 0.004,
+            "Mabeuf": 0.089,
+            "Enjolras": 0.003,
+            "Combeferre": 0.000,
+            "Prouvaire": 0.000,
+            "Feuilly": 0.004,
+            "Courfeyrac": 0.001,
+            "Bahorel": 0.007,
+            "Bossuet": 0.028,
+            "Joly": 0.000,
+            "Grantaire": 0.036,
+            "MotherPlutarch": 0.000,
+            "Gueulemer": 0.025,
+            "Babet": 0.015,
+            "Claquesous": 0.042,
+            "Montparnasse": 0.050,
+            "Toussaint": 0.011,
+            "Child1": 0.000,
+            "Child2": 0.000,
+            "Brujon": 0.002,
+            "MmeHucheloup": 0.034,
+        }
+
+        b = nx.betweenness_centrality(G, weight="weight", normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_ladder_graph(self):
+        """Weighted betweenness centrality: Ladder graph"""
+        G = nx.Graph()  # ladder_graph(3)
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (4, 5), (3, 5)])
+        b_answer = {0: 1.667, 1: 1.667, 2: 6.667, 3: 6.667, 4: 1.667, 5: 1.667}
+        for b in b_answer:
+            b_answer[b] /= 2
+        b = nx.betweenness_centrality(G, weight="weight", normalized=False)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_G(self):
+        """Weighted betweenness centrality: G"""
+        G = weighted_G()
+        b_answer = {0: 2.0, 1: 0.0, 2: 4.0, 3: 3.0, 4: 4.0, 5: 0.0}
+        b = nx.betweenness_centrality(G, weight="weight", normalized=False)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_G2(self):
+        """Weighted betweenness centrality: G2"""
+        G = nx.DiGraph()
+        G.add_weighted_edges_from(
+            [
+                ("s", "u", 10),
+                ("s", "x", 5),
+                ("u", "v", 1),
+                ("u", "x", 2),
+                ("v", "y", 1),
+                ("x", "u", 3),
+                ("x", "v", 5),
+                ("x", "y", 2),
+                ("y", "s", 7),
+                ("y", "v", 6),
+            ]
+        )
+
+        b_answer = {"y": 5.0, "x": 5.0, "s": 4.0, "u": 2.0, "v": 2.0}
+
+        b = nx.betweenness_centrality(G, weight="weight", normalized=False)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_G3(self):
+        """Weighted betweenness centrality: G3"""
+        G = nx.MultiGraph(weighted_G())
+        es = list(G.edges(data=True))[::2]  # duplicate every other edge
+        G.add_edges_from(es)
+        b_answer = {0: 2.0, 1: 0.0, 2: 4.0, 3: 3.0, 4: 4.0, 5: 0.0}
+        b = nx.betweenness_centrality(G, weight="weight", normalized=False)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_G4(self):
+        """Weighted betweenness centrality: G4"""
+        G = nx.MultiDiGraph()
+        G.add_weighted_edges_from(
+            [
+                ("s", "u", 10),
+                ("s", "x", 5),
+                ("s", "x", 6),
+                ("u", "v", 1),
+                ("u", "x", 2),
+                ("v", "y", 1),
+                ("v", "y", 1),
+                ("x", "u", 3),
+                ("x", "v", 5),
+                ("x", "y", 2),
+                ("x", "y", 3),
+                ("y", "s", 7),
+                ("y", "v", 6),
+                ("y", "v", 6),
+            ]
+        )
+
+        b_answer = {"y": 5.0, "x": 5.0, "s": 4.0, "u": 2.0, "v": 2.0}
+
+        b = nx.betweenness_centrality(G, weight="weight", normalized=False)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+
+class TestEdgeBetweennessCentrality:
+    def test_K5(self):
+        """Edge betweenness centrality: K5"""
+        G = nx.complete_graph(5)
+        b = nx.edge_betweenness_centrality(G, weight=None, normalized=False)
+        b_answer = dict.fromkeys(G.edges(), 1)
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_normalized_K5(self):
+        """Edge betweenness centrality: K5"""
+        G = nx.complete_graph(5)
+        b = nx.edge_betweenness_centrality(G, weight=None, normalized=True)
+        b_answer = dict.fromkeys(G.edges(), 1 / 10)
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_C4(self):
+        """Edge betweenness centrality: C4"""
+        G = nx.cycle_graph(4)
+        b = nx.edge_betweenness_centrality(G, weight=None, normalized=True)
+        b_answer = {(0, 1): 2, (0, 3): 2, (1, 2): 2, (2, 3): 2}
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n] / 6, abs=1e-7)
+
+    def test_P4(self):
+        """Edge betweenness centrality: P4"""
+        G = nx.path_graph(4)
+        b = nx.edge_betweenness_centrality(G, weight=None, normalized=False)
+        b_answer = {(0, 1): 3, (1, 2): 4, (2, 3): 3}
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_normalized_P4(self):
+        """Edge betweenness centrality: P4"""
+        G = nx.path_graph(4)
+        b = nx.edge_betweenness_centrality(G, weight=None, normalized=True)
+        b_answer = {(0, 1): 3, (1, 2): 4, (2, 3): 3}
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n] / 6, abs=1e-7)
+
+    def test_balanced_tree(self):
+        """Edge betweenness centrality: balanced tree"""
+        G = nx.balanced_tree(r=2, h=2)
+        b = nx.edge_betweenness_centrality(G, weight=None, normalized=False)
+        b_answer = {(0, 1): 12, (0, 2): 12, (1, 3): 6, (1, 4): 6, (2, 5): 6, (2, 6): 6}
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+
+class TestWeightedEdgeBetweennessCentrality:
+    def test_K5(self):
+        """Edge betweenness centrality: K5"""
+        G = nx.complete_graph(5)
+        b = nx.edge_betweenness_centrality(G, weight="weight", normalized=False)
+        b_answer = dict.fromkeys(G.edges(), 1)
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_C4(self):
+        """Edge betweenness centrality: C4"""
+        G = nx.cycle_graph(4)
+        b = nx.edge_betweenness_centrality(G, weight="weight", normalized=False)
+        b_answer = {(0, 1): 2, (0, 3): 2, (1, 2): 2, (2, 3): 2}
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P4(self):
+        """Edge betweenness centrality: P4"""
+        G = nx.path_graph(4)
+        b = nx.edge_betweenness_centrality(G, weight="weight", normalized=False)
+        b_answer = {(0, 1): 3, (1, 2): 4, (2, 3): 3}
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_balanced_tree(self):
+        """Edge betweenness centrality: balanced tree"""
+        G = nx.balanced_tree(r=2, h=2)
+        b = nx.edge_betweenness_centrality(G, weight="weight", normalized=False)
+        b_answer = {(0, 1): 12, (0, 2): 12, (1, 3): 6, (1, 4): 6, (2, 5): 6, (2, 6): 6}
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_weighted_graph(self):
+        """Edge betweenness centrality: weighted"""
+        eList = [
+            (0, 1, 5),
+            (0, 2, 4),
+            (0, 3, 3),
+            (0, 4, 2),
+            (1, 2, 4),
+            (1, 3, 1),
+            (1, 4, 3),
+            (2, 4, 5),
+            (3, 4, 4),
+        ]
+        G = nx.Graph()
+        G.add_weighted_edges_from(eList)
+        b = nx.edge_betweenness_centrality(G, weight="weight", normalized=False)
+        b_answer = {
+            (0, 1): 0.0,
+            (0, 2): 1.0,
+            (0, 3): 2.0,
+            (0, 4): 1.0,
+            (1, 2): 2.0,
+            (1, 3): 3.5,
+            (1, 4): 1.5,
+            (2, 4): 1.0,
+            (3, 4): 0.5,
+        }
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_normalized_weighted_graph(self):
+        """Edge betweenness centrality: normalized weighted"""
+        eList = [
+            (0, 1, 5),
+            (0, 2, 4),
+            (0, 3, 3),
+            (0, 4, 2),
+            (1, 2, 4),
+            (1, 3, 1),
+            (1, 4, 3),
+            (2, 4, 5),
+            (3, 4, 4),
+        ]
+        G = nx.Graph()
+        G.add_weighted_edges_from(eList)
+        b = nx.edge_betweenness_centrality(G, weight="weight", normalized=True)
+        b_answer = {
+            (0, 1): 0.0,
+            (0, 2): 1.0,
+            (0, 3): 2.0,
+            (0, 4): 1.0,
+            (1, 2): 2.0,
+            (1, 3): 3.5,
+            (1, 4): 1.5,
+            (2, 4): 1.0,
+            (3, 4): 0.5,
+        }
+        norm = len(G) * (len(G) - 1) / 2
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n] / norm, abs=1e-7)
+
+    def test_weighted_multigraph(self):
+        """Edge betweenness centrality: weighted multigraph"""
+        eList = [
+            (0, 1, 5),
+            (0, 1, 4),
+            (0, 2, 4),
+            (0, 3, 3),
+            (0, 3, 3),
+            (0, 4, 2),
+            (1, 2, 4),
+            (1, 3, 1),
+            (1, 3, 2),
+            (1, 4, 3),
+            (1, 4, 4),
+            (2, 4, 5),
+            (3, 4, 4),
+            (3, 4, 4),
+        ]
+        G = nx.MultiGraph()
+        G.add_weighted_edges_from(eList)
+        b = nx.edge_betweenness_centrality(G, weight="weight", normalized=False)
+        b_answer = {
+            (0, 1, 0): 0.0,
+            (0, 1, 1): 0.5,
+            (0, 2, 0): 1.0,
+            (0, 3, 0): 0.75,
+            (0, 3, 1): 0.75,
+            (0, 4, 0): 1.0,
+            (1, 2, 0): 2.0,
+            (1, 3, 0): 3.0,
+            (1, 3, 1): 0.0,
+            (1, 4, 0): 1.5,
+            (1, 4, 1): 0.0,
+            (2, 4, 0): 1.0,
+            (3, 4, 0): 0.25,
+            (3, 4, 1): 0.25,
+        }
+        for n in sorted(G.edges(keys=True)):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_normalized_weighted_multigraph(self):
+        """Edge betweenness centrality: normalized weighted multigraph"""
+        eList = [
+            (0, 1, 5),
+            (0, 1, 4),
+            (0, 2, 4),
+            (0, 3, 3),
+            (0, 3, 3),
+            (0, 4, 2),
+            (1, 2, 4),
+            (1, 3, 1),
+            (1, 3, 2),
+            (1, 4, 3),
+            (1, 4, 4),
+            (2, 4, 5),
+            (3, 4, 4),
+            (3, 4, 4),
+        ]
+        G = nx.MultiGraph()
+        G.add_weighted_edges_from(eList)
+        b = nx.edge_betweenness_centrality(G, weight="weight", normalized=True)
+        b_answer = {
+            (0, 1, 0): 0.0,
+            (0, 1, 1): 0.5,
+            (0, 2, 0): 1.0,
+            (0, 3, 0): 0.75,
+            (0, 3, 1): 0.75,
+            (0, 4, 0): 1.0,
+            (1, 2, 0): 2.0,
+            (1, 3, 0): 3.0,
+            (1, 3, 1): 0.0,
+            (1, 4, 0): 1.5,
+            (1, 4, 1): 0.0,
+            (2, 4, 0): 1.0,
+            (3, 4, 0): 0.25,
+            (3, 4, 1): 0.25,
+        }
+        norm = len(G) * (len(G) - 1) / 2
+        for n in sorted(G.edges(keys=True)):
+            assert b[n] == pytest.approx(b_answer[n] / norm, abs=1e-7)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_betweenness_centrality_subset.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_betweenness_centrality_subset.py
new file mode 100644
index 0000000..6b66b8a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_betweenness_centrality_subset.py
@@ -0,0 +1,227 @@
+import pytest
+
+import networkx as nx
+
+
+class TestSubsetBetweennessCentrality:
+    def test_K5(self):
+        """Betweenness Centrality Subset: K5"""
+        G = nx.complete_graph(5)
+        b = nx.betweenness_centrality_subset(
+            G, sources=[0], targets=[1, 3], weight=None
+        )
+        b_answer = {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P5_directed(self):
+        """Betweenness Centrality Subset: P5 directed"""
+        G = nx.DiGraph()
+        nx.add_path(G, range(5))
+        b_answer = {0: 0, 1: 1, 2: 1, 3: 0, 4: 0, 5: 0}
+        b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3], weight=None)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P5(self):
+        """Betweenness Centrality Subset: P5"""
+        G = nx.Graph()
+        nx.add_path(G, range(5))
+        b_answer = {0: 0, 1: 0.5, 2: 0.5, 3: 0, 4: 0, 5: 0}
+        b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3], weight=None)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P5_multiple_target(self):
+        """Betweenness Centrality Subset: P5 multiple target"""
+        G = nx.Graph()
+        nx.add_path(G, range(5))
+        b_answer = {0: 0, 1: 1, 2: 1, 3: 0.5, 4: 0, 5: 0}
+        b = nx.betweenness_centrality_subset(
+            G, sources=[0], targets=[3, 4], weight=None
+        )
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_box(self):
+        """Betweenness Centrality Subset: box"""
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
+        b_answer = {0: 0, 1: 0.25, 2: 0.25, 3: 0}
+        b = nx.betweenness_centrality_subset(G, sources=[0], targets=[3], weight=None)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_box_and_path(self):
+        """Betweenness Centrality Subset: box and path"""
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (4, 5)])
+        b_answer = {0: 0, 1: 0.5, 2: 0.5, 3: 0.5, 4: 0, 5: 0}
+        b = nx.betweenness_centrality_subset(
+            G, sources=[0], targets=[3, 4], weight=None
+        )
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_box_and_path2(self):
+        """Betweenness Centrality Subset: box and path multiple target"""
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (1, 2), (2, 3), (1, 20), (20, 3), (3, 4)])
+        b_answer = {0: 0, 1: 1.0, 2: 0.5, 20: 0.5, 3: 0.5, 4: 0}
+        b = nx.betweenness_centrality_subset(
+            G, sources=[0], targets=[3, 4], weight=None
+        )
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_diamond_multi_path(self):
+        """Betweenness Centrality Subset: Diamond Multi Path"""
+        G = nx.Graph()
+        G.add_edges_from(
+            [
+                (1, 2),
+                (1, 3),
+                (1, 4),
+                (1, 5),
+                (1, 10),
+                (10, 11),
+                (11, 12),
+                (12, 9),
+                (2, 6),
+                (3, 6),
+                (4, 6),
+                (5, 7),
+                (7, 8),
+                (6, 8),
+                (8, 9),
+            ]
+        )
+        b = nx.betweenness_centrality_subset(G, sources=[1], targets=[9], weight=None)
+
+        expected_b = {
+            1: 0,
+            2: 1.0 / 10,
+            3: 1.0 / 10,
+            4: 1.0 / 10,
+            5: 1.0 / 10,
+            6: 3.0 / 10,
+            7: 1.0 / 10,
+            8: 4.0 / 10,
+            9: 0,
+            10: 1.0 / 10,
+            11: 1.0 / 10,
+            12: 1.0 / 10,
+        }
+
+        for n in sorted(G):
+            assert b[n] == pytest.approx(expected_b[n], abs=1e-7)
+
+
+class TestBetweennessCentralitySources:
+    def test_K5(self):
+        """Betweenness Centrality Sources: K5"""
+        G = nx.complete_graph(5)
+        b = nx.betweenness_centrality_source(G, weight=None, normalized=False)
+        b_answer = {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P3(self):
+        """Betweenness Centrality Sources: P3"""
+        G = nx.path_graph(3)
+        b_answer = {0: 0.0, 1: 1.0, 2: 0.0}
+        b = nx.betweenness_centrality_source(G, weight=None, normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+
+class TestEdgeSubsetBetweennessCentrality:
+    def test_K5(self):
+        """Edge betweenness subset centrality: K5"""
+        G = nx.complete_graph(5)
+        b = nx.edge_betweenness_centrality_subset(
+            G, sources=[0], targets=[1, 3], weight=None
+        )
+        b_answer = dict.fromkeys(G.edges(), 0)
+        b_answer[(0, 3)] = b_answer[(0, 1)] = 0.5
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P5_directed(self):
+        """Edge betweenness subset centrality: P5 directed"""
+        G = nx.DiGraph()
+        nx.add_path(G, range(5))
+        b_answer = dict.fromkeys(G.edges(), 0)
+        b_answer[(0, 1)] = b_answer[(1, 2)] = b_answer[(2, 3)] = 1
+        b = nx.edge_betweenness_centrality_subset(
+            G, sources=[0], targets=[3], weight=None
+        )
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P5(self):
+        """Edge betweenness subset centrality: P5"""
+        G = nx.Graph()
+        nx.add_path(G, range(5))
+        b_answer = dict.fromkeys(G.edges(), 0)
+        b_answer[(0, 1)] = b_answer[(1, 2)] = b_answer[(2, 3)] = 0.5
+        b = nx.edge_betweenness_centrality_subset(
+            G, sources=[0], targets=[3], weight=None
+        )
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P5_multiple_target(self):
+        """Edge betweenness subset centrality: P5 multiple target"""
+        G = nx.Graph()
+        nx.add_path(G, range(5))
+        b_answer = dict.fromkeys(G.edges(), 0)
+        b_answer[(0, 1)] = b_answer[(1, 2)] = b_answer[(2, 3)] = 1
+        b_answer[(3, 4)] = 0.5
+        b = nx.edge_betweenness_centrality_subset(
+            G, sources=[0], targets=[3, 4], weight=None
+        )
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_box(self):
+        """Edge betweenness subset centrality: box"""
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
+        b_answer = dict.fromkeys(G.edges(), 0)
+        b_answer[(0, 1)] = b_answer[(0, 2)] = 0.25
+        b_answer[(1, 3)] = b_answer[(2, 3)] = 0.25
+        b = nx.edge_betweenness_centrality_subset(
+            G, sources=[0], targets=[3], weight=None
+        )
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_box_and_path(self):
+        """Edge betweenness subset centrality: box and path"""
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (4, 5)])
+        b_answer = dict.fromkeys(G.edges(), 0)
+        b_answer[(0, 1)] = b_answer[(0, 2)] = 0.5
+        b_answer[(1, 3)] = b_answer[(2, 3)] = 0.5
+        b_answer[(3, 4)] = 0.5
+        b = nx.edge_betweenness_centrality_subset(
+            G, sources=[0], targets=[3, 4], weight=None
+        )
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_box_and_path2(self):
+        """Edge betweenness subset centrality: box and path multiple target"""
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (1, 2), (2, 3), (1, 20), (20, 3), (3, 4)])
+        b_answer = dict.fromkeys(G.edges(), 0)
+        b_answer[(0, 1)] = 1.0
+        b_answer[(1, 20)] = b_answer[(3, 20)] = 0.5
+        b_answer[(1, 2)] = b_answer[(2, 3)] = 0.5
+        b_answer[(3, 4)] = 0.5
+        b = nx.edge_betweenness_centrality_subset(
+            G, sources=[0], targets=[3, 4], weight=None
+        )
+        for n in sorted(G.edges()):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_closeness_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_closeness_centrality.py
new file mode 100644
index 0000000..d274206
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_closeness_centrality.py
@@ -0,0 +1,306 @@
+"""
+Tests for closeness centrality.
+"""
+import pytest
+
+import networkx as nx
+
+
+class TestClosenessCentrality:
+    @classmethod
+    def setup_class(cls):
+        cls.K = nx.krackhardt_kite_graph()
+        cls.P3 = nx.path_graph(3)
+        cls.P4 = nx.path_graph(4)
+        cls.K5 = nx.complete_graph(5)
+
+        cls.C4 = nx.cycle_graph(4)
+        cls.T = nx.balanced_tree(r=2, h=2)
+        cls.Gb = nx.Graph()
+        cls.Gb.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (4, 5), (3, 5)])
+
+        F = nx.florentine_families_graph()
+        cls.F = F
+
+        cls.LM = nx.les_miserables_graph()
+
+        # Create random undirected, unweighted graph for testing incremental version
+        cls.undirected_G = nx.fast_gnp_random_graph(n=100, p=0.6, seed=123)
+        cls.undirected_G_cc = nx.closeness_centrality(cls.undirected_G)
+
+    def test_wf_improved(self):
+        G = nx.union(self.P4, nx.path_graph([4, 5, 6]))
+        c = nx.closeness_centrality(G)
+        cwf = nx.closeness_centrality(G, wf_improved=False)
+        res = {0: 0.25, 1: 0.375, 2: 0.375, 3: 0.25, 4: 0.222, 5: 0.333, 6: 0.222}
+        wf_res = {0: 0.5, 1: 0.75, 2: 0.75, 3: 0.5, 4: 0.667, 5: 1.0, 6: 0.667}
+        for n in G:
+            assert c[n] == pytest.approx(res[n], abs=1e-3)
+            assert cwf[n] == pytest.approx(wf_res[n], abs=1e-3)
+
+    def test_digraph(self):
+        G = nx.path_graph(3, create_using=nx.DiGraph())
+        c = nx.closeness_centrality(G)
+        cr = nx.closeness_centrality(G.reverse())
+        d = {0: 0.0, 1: 0.500, 2: 0.667}
+        dr = {0: 0.667, 1: 0.500, 2: 0.0}
+        for n in sorted(self.P3):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+            assert cr[n] == pytest.approx(dr[n], abs=1e-3)
+
+    def test_k5_closeness(self):
+        c = nx.closeness_centrality(self.K5)
+        d = {0: 1.000, 1: 1.000, 2: 1.000, 3: 1.000, 4: 1.000}
+        for n in sorted(self.K5):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_p3_closeness(self):
+        c = nx.closeness_centrality(self.P3)
+        d = {0: 0.667, 1: 1.000, 2: 0.667}
+        for n in sorted(self.P3):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_krackhardt_closeness(self):
+        c = nx.closeness_centrality(self.K)
+        d = {
+            0: 0.529,
+            1: 0.529,
+            2: 0.500,
+            3: 0.600,
+            4: 0.500,
+            5: 0.643,
+            6: 0.643,
+            7: 0.600,
+            8: 0.429,
+            9: 0.310,
+        }
+        for n in sorted(self.K):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_florentine_families_closeness(self):
+        c = nx.closeness_centrality(self.F)
+        d = {
+            "Acciaiuoli": 0.368,
+            "Albizzi": 0.483,
+            "Barbadori": 0.4375,
+            "Bischeri": 0.400,
+            "Castellani": 0.389,
+            "Ginori": 0.333,
+            "Guadagni": 0.467,
+            "Lamberteschi": 0.326,
+            "Medici": 0.560,
+            "Pazzi": 0.286,
+            "Peruzzi": 0.368,
+            "Ridolfi": 0.500,
+            "Salviati": 0.389,
+            "Strozzi": 0.4375,
+            "Tornabuoni": 0.483,
+        }
+        for n in sorted(self.F):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_les_miserables_closeness(self):
+        c = nx.closeness_centrality(self.LM)
+        d = {
+            "Napoleon": 0.302,
+            "Myriel": 0.429,
+            "MlleBaptistine": 0.413,
+            "MmeMagloire": 0.413,
+            "CountessDeLo": 0.302,
+            "Geborand": 0.302,
+            "Champtercier": 0.302,
+            "Cravatte": 0.302,
+            "Count": 0.302,
+            "OldMan": 0.302,
+            "Valjean": 0.644,
+            "Labarre": 0.394,
+            "Marguerite": 0.413,
+            "MmeDeR": 0.394,
+            "Isabeau": 0.394,
+            "Gervais": 0.394,
+            "Listolier": 0.341,
+            "Tholomyes": 0.392,
+            "Fameuil": 0.341,
+            "Blacheville": 0.341,
+            "Favourite": 0.341,
+            "Dahlia": 0.341,
+            "Zephine": 0.341,
+            "Fantine": 0.461,
+            "MmeThenardier": 0.461,
+            "Thenardier": 0.517,
+            "Cosette": 0.478,
+            "Javert": 0.517,
+            "Fauchelevent": 0.402,
+            "Bamatabois": 0.427,
+            "Perpetue": 0.318,
+            "Simplice": 0.418,
+            "Scaufflaire": 0.394,
+            "Woman1": 0.396,
+            "Judge": 0.404,
+            "Champmathieu": 0.404,
+            "Brevet": 0.404,
+            "Chenildieu": 0.404,
+            "Cochepaille": 0.404,
+            "Pontmercy": 0.373,
+            "Boulatruelle": 0.342,
+            "Eponine": 0.396,
+            "Anzelma": 0.352,
+            "Woman2": 0.402,
+            "MotherInnocent": 0.398,
+            "Gribier": 0.288,
+            "MmeBurgon": 0.344,
+            "Jondrette": 0.257,
+            "Gavroche": 0.514,
+            "Gillenormand": 0.442,
+            "Magnon": 0.335,
+            "MlleGillenormand": 0.442,
+            "MmePontmercy": 0.315,
+            "MlleVaubois": 0.308,
+            "LtGillenormand": 0.365,
+            "Marius": 0.531,
+            "BaronessT": 0.352,
+            "Mabeuf": 0.396,
+            "Enjolras": 0.481,
+            "Combeferre": 0.392,
+            "Prouvaire": 0.357,
+            "Feuilly": 0.392,
+            "Courfeyrac": 0.400,
+            "Bahorel": 0.394,
+            "Bossuet": 0.475,
+            "Joly": 0.394,
+            "Grantaire": 0.358,
+            "MotherPlutarch": 0.285,
+            "Gueulemer": 0.463,
+            "Babet": 0.463,
+            "Claquesous": 0.452,
+            "Montparnasse": 0.458,
+            "Toussaint": 0.402,
+            "Child1": 0.342,
+            "Child2": 0.342,
+            "Brujon": 0.380,
+            "MmeHucheloup": 0.353,
+        }
+        for n in sorted(self.LM):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_weighted_closeness(self):
+        edges = [
+            ("s", "u", 10),
+            ("s", "x", 5),
+            ("u", "v", 1),
+            ("u", "x", 2),
+            ("v", "y", 1),
+            ("x", "u", 3),
+            ("x", "v", 5),
+            ("x", "y", 2),
+            ("y", "s", 7),
+            ("y", "v", 6),
+        ]
+        XG = nx.Graph()
+        XG.add_weighted_edges_from(edges)
+        c = nx.closeness_centrality(XG, distance="weight")
+        d = {"y": 0.200, "x": 0.286, "s": 0.138, "u": 0.235, "v": 0.200}
+        for n in sorted(XG):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    #
+    # Tests for incremental closeness centrality.
+    #
+    @staticmethod
+    def pick_add_edge(g):
+        u = nx.utils.arbitrary_element(g)
+        possible_nodes = set(g.nodes())
+        neighbors = list(g.neighbors(u)) + [u]
+        possible_nodes.difference_update(neighbors)
+        v = nx.utils.arbitrary_element(possible_nodes)
+        return (u, v)
+
+    @staticmethod
+    def pick_remove_edge(g):
+        u = nx.utils.arbitrary_element(g)
+        possible_nodes = list(g.neighbors(u))
+        v = nx.utils.arbitrary_element(possible_nodes)
+        return (u, v)
+
+    def test_directed_raises(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            dir_G = nx.gn_graph(n=5)
+            prev_cc = None
+            edge = self.pick_add_edge(dir_G)
+            insert = True
+            nx.incremental_closeness_centrality(dir_G, edge, prev_cc, insert)
+
+    def test_wrong_size_prev_cc_raises(self):
+        with pytest.raises(nx.NetworkXError):
+            G = self.undirected_G.copy()
+            edge = self.pick_add_edge(G)
+            insert = True
+            prev_cc = self.undirected_G_cc.copy()
+            prev_cc.pop(0)
+            nx.incremental_closeness_centrality(G, edge, prev_cc, insert)
+
+    def test_wrong_nodes_prev_cc_raises(self):
+        with pytest.raises(nx.NetworkXError):
+            G = self.undirected_G.copy()
+            edge = self.pick_add_edge(G)
+            insert = True
+            prev_cc = self.undirected_G_cc.copy()
+            num_nodes = len(prev_cc)
+            prev_cc.pop(0)
+            prev_cc[num_nodes] = 0.5
+            nx.incremental_closeness_centrality(G, edge, prev_cc, insert)
+
+    def test_zero_centrality(self):
+        G = nx.path_graph(3)
+        prev_cc = nx.closeness_centrality(G)
+        edge = self.pick_remove_edge(G)
+        test_cc = nx.incremental_closeness_centrality(G, edge, prev_cc, insertion=False)
+        G.remove_edges_from([edge])
+        real_cc = nx.closeness_centrality(G)
+        shared_items = set(test_cc.items()) & set(real_cc.items())
+        assert len(shared_items) == len(real_cc)
+        assert 0 in test_cc.values()
+
+    def test_incremental(self):
+        # Check that incremental and regular give same output
+        G = self.undirected_G.copy()
+        prev_cc = None
+        for i in range(5):
+            if i % 2 == 0:
+                # Remove an edge
+                insert = False
+                edge = self.pick_remove_edge(G)
+            else:
+                # Add an edge
+                insert = True
+                edge = self.pick_add_edge(G)
+
+            # start = timeit.default_timer()
+            test_cc = nx.incremental_closeness_centrality(G, edge, prev_cc, insert)
+            # inc_elapsed = (timeit.default_timer() - start)
+            # print(f"incremental time: {inc_elapsed}")
+
+            if insert:
+                G.add_edges_from([edge])
+            else:
+                G.remove_edges_from([edge])
+
+            # start = timeit.default_timer()
+            real_cc = nx.closeness_centrality(G)
+            # reg_elapsed = (timeit.default_timer() - start)
+            # print(f"regular time: {reg_elapsed}")
+            # Example output:
+            # incremental time: 0.208
+            # regular time: 0.276
+            # incremental time: 0.00683
+            # regular time: 0.260
+            # incremental time: 0.0224
+            # regular time: 0.278
+            # incremental time: 0.00804
+            # regular time: 0.208
+            # incremental time: 0.00947
+            # regular time: 0.188
+
+            assert set(test_cc.items()) == set(real_cc.items())
+
+            prev_cc = test_cc
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality.py
new file mode 100644
index 0000000..e9f5179
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality.py
@@ -0,0 +1,177 @@
+import pytest
+
+import networkx as nx
+from networkx import approximate_current_flow_betweenness_centrality as approximate_cfbc
+from networkx import edge_current_flow_betweenness_centrality as edge_current_flow
+
+np = pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+
+class TestFlowBetweennessCentrality:
+    def test_K4_normalized(self):
+        """Betweenness centrality: K4"""
+        G = nx.complete_graph(4)
+        b = nx.current_flow_betweenness_centrality(G, normalized=True)
+        b_answer = {0: 0.25, 1: 0.25, 2: 0.25, 3: 0.25}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        G.add_edge(0, 1, weight=0.5, other=0.3)
+        b = nx.current_flow_betweenness_centrality(G, normalized=True, weight=None)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        wb_answer = {0: 0.2222222, 1: 0.2222222, 2: 0.30555555, 3: 0.30555555}
+        b = nx.current_flow_betweenness_centrality(G, normalized=True, weight="weight")
+        for n in sorted(G):
+            assert b[n] == pytest.approx(wb_answer[n], abs=1e-7)
+        wb_answer = {0: 0.2051282, 1: 0.2051282, 2: 0.33974358, 3: 0.33974358}
+        b = nx.current_flow_betweenness_centrality(G, normalized=True, weight="other")
+        for n in sorted(G):
+            assert b[n] == pytest.approx(wb_answer[n], abs=1e-7)
+
+    def test_K4(self):
+        """Betweenness centrality: K4"""
+        G = nx.complete_graph(4)
+        for solver in ["full", "lu", "cg"]:
+            b = nx.current_flow_betweenness_centrality(
+                G, normalized=False, solver=solver
+            )
+            b_answer = {0: 0.75, 1: 0.75, 2: 0.75, 3: 0.75}
+            for n in sorted(G):
+                assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P4_normalized(self):
+        """Betweenness centrality: P4 normalized"""
+        G = nx.path_graph(4)
+        b = nx.current_flow_betweenness_centrality(G, normalized=True)
+        b_answer = {0: 0, 1: 2.0 / 3, 2: 2.0 / 3, 3: 0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P4(self):
+        """Betweenness centrality: P4"""
+        G = nx.path_graph(4)
+        b = nx.current_flow_betweenness_centrality(G, normalized=False)
+        b_answer = {0: 0, 1: 2, 2: 2, 3: 0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_star(self):
+        """Betweenness centrality: star"""
+        G = nx.Graph()
+        nx.add_star(G, ["a", "b", "c", "d"])
+        b = nx.current_flow_betweenness_centrality(G, normalized=True)
+        b_answer = {"a": 1.0, "b": 0.0, "c": 0.0, "d": 0.0}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_solvers2(self):
+        """Betweenness centrality: alternate solvers"""
+        G = nx.complete_graph(4)
+        for solver in ["full", "lu", "cg"]:
+            b = nx.current_flow_betweenness_centrality(
+                G, normalized=False, solver=solver
+            )
+            b_answer = {0: 0.75, 1: 0.75, 2: 0.75, 3: 0.75}
+            for n in sorted(G):
+                assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+
+class TestApproximateFlowBetweennessCentrality:
+    def test_K4_normalized(self):
+        "Approximate current-flow betweenness centrality: K4 normalized"
+        G = nx.complete_graph(4)
+        b = nx.current_flow_betweenness_centrality(G, normalized=True)
+        epsilon = 0.1
+        ba = approximate_cfbc(G, normalized=True, epsilon=0.5 * epsilon)
+        for n in sorted(G):
+            np.testing.assert_allclose(b[n], ba[n], atol=epsilon)
+
+    def test_K4(self):
+        "Approximate current-flow betweenness centrality: K4"
+        G = nx.complete_graph(4)
+        b = nx.current_flow_betweenness_centrality(G, normalized=False)
+        epsilon = 0.1
+        ba = approximate_cfbc(G, normalized=False, epsilon=0.5 * epsilon)
+        for n in sorted(G):
+            np.testing.assert_allclose(b[n], ba[n], atol=epsilon * len(G) ** 2)
+
+    def test_star(self):
+        "Approximate current-flow betweenness centrality: star"
+        G = nx.Graph()
+        nx.add_star(G, ["a", "b", "c", "d"])
+        b = nx.current_flow_betweenness_centrality(G, normalized=True)
+        epsilon = 0.1
+        ba = approximate_cfbc(G, normalized=True, epsilon=0.5 * epsilon)
+        for n in sorted(G):
+            np.testing.assert_allclose(b[n], ba[n], atol=epsilon)
+
+    def test_grid(self):
+        "Approximate current-flow betweenness centrality: 2d grid"
+        G = nx.grid_2d_graph(4, 4)
+        b = nx.current_flow_betweenness_centrality(G, normalized=True)
+        epsilon = 0.1
+        ba = approximate_cfbc(G, normalized=True, epsilon=0.5 * epsilon)
+        for n in sorted(G):
+            np.testing.assert_allclose(b[n], ba[n], atol=epsilon)
+
+    def test_seed(self):
+        G = nx.complete_graph(4)
+        b = approximate_cfbc(G, normalized=False, epsilon=0.05, seed=1)
+        b_answer = {0: 0.75, 1: 0.75, 2: 0.75, 3: 0.75}
+        for n in sorted(G):
+            np.testing.assert_allclose(b[n], b_answer[n], atol=0.1)
+
+    def test_solvers(self):
+        "Approximate current-flow betweenness centrality: solvers"
+        G = nx.complete_graph(4)
+        epsilon = 0.1
+        for solver in ["full", "lu", "cg"]:
+            b = approximate_cfbc(
+                G, normalized=False, solver=solver, epsilon=0.5 * epsilon
+            )
+            b_answer = {0: 0.75, 1: 0.75, 2: 0.75, 3: 0.75}
+            for n in sorted(G):
+                np.testing.assert_allclose(b[n], b_answer[n], atol=epsilon)
+
+
+class TestWeightedFlowBetweennessCentrality:
+    pass
+
+
+class TestEdgeFlowBetweennessCentrality:
+    def test_K4(self):
+        """Edge flow betweenness centrality: K4"""
+        G = nx.complete_graph(4)
+        b = edge_current_flow(G, normalized=True)
+        b_answer = dict.fromkeys(G.edges(), 0.25)
+        for (s, t), v1 in b_answer.items():
+            v2 = b.get((s, t), b.get((t, s)))
+            assert v1 == pytest.approx(v2, abs=1e-7)
+
+    def test_K4_normalized(self):
+        """Edge flow betweenness centrality: K4"""
+        G = nx.complete_graph(4)
+        b = edge_current_flow(G, normalized=False)
+        b_answer = dict.fromkeys(G.edges(), 0.75)
+        for (s, t), v1 in b_answer.items():
+            v2 = b.get((s, t), b.get((t, s)))
+            assert v1 == pytest.approx(v2, abs=1e-7)
+
+    def test_C4(self):
+        """Edge flow betweenness centrality: C4"""
+        G = nx.cycle_graph(4)
+        b = edge_current_flow(G, normalized=False)
+        b_answer = {(0, 1): 1.25, (0, 3): 1.25, (1, 2): 1.25, (2, 3): 1.25}
+        for (s, t), v1 in b_answer.items():
+            v2 = b.get((s, t), b.get((t, s)))
+            assert v1 == pytest.approx(v2, abs=1e-7)
+
+    def test_P4(self):
+        """Edge betweenness centrality: P4"""
+        G = nx.path_graph(4)
+        b = edge_current_flow(G, normalized=False)
+        b_answer = {(0, 1): 1.5, (1, 2): 2.0, (2, 3): 1.5}
+        for (s, t), v1 in b_answer.items():
+            v2 = b.get((s, t), b.get((t, s)))
+            assert v1 == pytest.approx(v2, abs=1e-7)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality_subset.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality_subset.py
new file mode 100644
index 0000000..7b1611b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality_subset.py
@@ -0,0 +1,147 @@
+import pytest
+
+pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+from networkx import edge_current_flow_betweenness_centrality as edge_current_flow
+from networkx import (
+    edge_current_flow_betweenness_centrality_subset as edge_current_flow_subset,
+)
+
+
+class TestFlowBetweennessCentrality:
+    def test_K4_normalized(self):
+        """Betweenness centrality: K4"""
+        G = nx.complete_graph(4)
+        b = nx.current_flow_betweenness_centrality_subset(
+            G, list(G), list(G), normalized=True
+        )
+        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_K4(self):
+        """Betweenness centrality: K4"""
+        G = nx.complete_graph(4)
+        b = nx.current_flow_betweenness_centrality_subset(
+            G, list(G), list(G), normalized=True
+        )
+        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        # test weighted network
+        G.add_edge(0, 1, weight=0.5, other=0.3)
+        b = nx.current_flow_betweenness_centrality_subset(
+            G, list(G), list(G), normalized=True, weight=None
+        )
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        b = nx.current_flow_betweenness_centrality_subset(
+            G, list(G), list(G), normalized=True
+        )
+        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        b = nx.current_flow_betweenness_centrality_subset(
+            G, list(G), list(G), normalized=True, weight="other"
+        )
+        b_answer = nx.current_flow_betweenness_centrality(
+            G, normalized=True, weight="other"
+        )
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P4_normalized(self):
+        """Betweenness centrality: P4 normalized"""
+        G = nx.path_graph(4)
+        b = nx.current_flow_betweenness_centrality_subset(
+            G, list(G), list(G), normalized=True
+        )
+        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P4(self):
+        """Betweenness centrality: P4"""
+        G = nx.path_graph(4)
+        b = nx.current_flow_betweenness_centrality_subset(
+            G, list(G), list(G), normalized=True
+        )
+        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_star(self):
+        """Betweenness centrality: star"""
+        G = nx.Graph()
+        nx.add_star(G, ["a", "b", "c", "d"])
+        b = nx.current_flow_betweenness_centrality_subset(
+            G, list(G), list(G), normalized=True
+        )
+        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+
+# class TestWeightedFlowBetweennessCentrality():
+#     pass
+
+
+class TestEdgeFlowBetweennessCentrality:
+    def test_K4_normalized(self):
+        """Betweenness centrality: K4"""
+        G = nx.complete_graph(4)
+        b = edge_current_flow_subset(G, list(G), list(G), normalized=True)
+        b_answer = edge_current_flow(G, normalized=True)
+        for (s, t), v1 in b_answer.items():
+            v2 = b.get((s, t), b.get((t, s)))
+            assert v1 == pytest.approx(v2, abs=1e-7)
+
+    def test_K4(self):
+        """Betweenness centrality: K4"""
+        G = nx.complete_graph(4)
+        b = edge_current_flow_subset(G, list(G), list(G), normalized=False)
+        b_answer = edge_current_flow(G, normalized=False)
+        for (s, t), v1 in b_answer.items():
+            v2 = b.get((s, t), b.get((t, s)))
+            assert v1 == pytest.approx(v2, abs=1e-7)
+        # test weighted network
+        G.add_edge(0, 1, weight=0.5, other=0.3)
+        b = edge_current_flow_subset(G, list(G), list(G), normalized=False, weight=None)
+        # weight is None => same as unweighted network
+        for (s, t), v1 in b_answer.items():
+            v2 = b.get((s, t), b.get((t, s)))
+            assert v1 == pytest.approx(v2, abs=1e-7)
+
+        b = edge_current_flow_subset(G, list(G), list(G), normalized=False)
+        b_answer = edge_current_flow(G, normalized=False)
+        for (s, t), v1 in b_answer.items():
+            v2 = b.get((s, t), b.get((t, s)))
+            assert v1 == pytest.approx(v2, abs=1e-7)
+
+        b = edge_current_flow_subset(
+            G, list(G), list(G), normalized=False, weight="other"
+        )
+        b_answer = edge_current_flow(G, normalized=False, weight="other")
+        for (s, t), v1 in b_answer.items():
+            v2 = b.get((s, t), b.get((t, s)))
+            assert v1 == pytest.approx(v2, abs=1e-7)
+
+    def test_C4(self):
+        """Edge betweenness centrality: C4"""
+        G = nx.cycle_graph(4)
+        b = edge_current_flow_subset(G, list(G), list(G), normalized=True)
+        b_answer = edge_current_flow(G, normalized=True)
+        for (s, t), v1 in b_answer.items():
+            v2 = b.get((s, t), b.get((t, s)))
+            assert v1 == pytest.approx(v2, abs=1e-7)
+
+    def test_P4(self):
+        """Edge betweenness centrality: P4"""
+        G = nx.path_graph(4)
+        b = edge_current_flow_subset(G, list(G), list(G), normalized=True)
+        b_answer = edge_current_flow(G, normalized=True)
+        for (s, t), v1 in b_answer.items():
+            v2 = b.get((s, t), b.get((t, s)))
+            assert v1 == pytest.approx(v2, abs=1e-7)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_current_flow_closeness.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_current_flow_closeness.py
new file mode 100644
index 0000000..24a916a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_current_flow_closeness.py
@@ -0,0 +1,37 @@
+import pytest
+
+pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+
+
+class TestFlowClosenessCentrality:
+    def test_K4(self):
+        """Closeness centrality: K4"""
+        G = nx.complete_graph(4)
+        b = nx.current_flow_closeness_centrality(G)
+        b_answer = {0: 2.0 / 3, 1: 2.0 / 3, 2: 2.0 / 3, 3: 2.0 / 3}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P4(self):
+        """Closeness centrality: P4"""
+        G = nx.path_graph(4)
+        b = nx.current_flow_closeness_centrality(G)
+        b_answer = {0: 1.0 / 6, 1: 1.0 / 4, 2: 1.0 / 4, 3: 1.0 / 6}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_star(self):
+        """Closeness centrality: star"""
+        G = nx.Graph()
+        nx.add_star(G, ["a", "b", "c", "d"])
+        b = nx.current_flow_closeness_centrality(G)
+        b_answer = {"a": 1.0 / 3, "b": 0.6 / 3, "c": 0.6 / 3, "d": 0.6 / 3}
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+
+class TestWeightedFlowClosenessCentrality:
+    pass
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_degree_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_degree_centrality.py
new file mode 100644
index 0000000..591df6a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_degree_centrality.py
@@ -0,0 +1,145 @@
+"""
+    Unit tests for degree centrality.
+"""
+
+import pytest
+
+import networkx as nx
+
+
+class TestDegreeCentrality:
+    def setup_method(self):
+
+        self.K = nx.krackhardt_kite_graph()
+        self.P3 = nx.path_graph(3)
+        self.K5 = nx.complete_graph(5)
+
+        F = nx.Graph()  # Florentine families
+        F.add_edge("Acciaiuoli", "Medici")
+        F.add_edge("Castellani", "Peruzzi")
+        F.add_edge("Castellani", "Strozzi")
+        F.add_edge("Castellani", "Barbadori")
+        F.add_edge("Medici", "Barbadori")
+        F.add_edge("Medici", "Ridolfi")
+        F.add_edge("Medici", "Tornabuoni")
+        F.add_edge("Medici", "Albizzi")
+        F.add_edge("Medici", "Salviati")
+        F.add_edge("Salviati", "Pazzi")
+        F.add_edge("Peruzzi", "Strozzi")
+        F.add_edge("Peruzzi", "Bischeri")
+        F.add_edge("Strozzi", "Ridolfi")
+        F.add_edge("Strozzi", "Bischeri")
+        F.add_edge("Ridolfi", "Tornabuoni")
+        F.add_edge("Tornabuoni", "Guadagni")
+        F.add_edge("Albizzi", "Ginori")
+        F.add_edge("Albizzi", "Guadagni")
+        F.add_edge("Bischeri", "Guadagni")
+        F.add_edge("Guadagni", "Lamberteschi")
+        self.F = F
+
+        G = nx.DiGraph()
+        G.add_edge(0, 5)
+        G.add_edge(1, 5)
+        G.add_edge(2, 5)
+        G.add_edge(3, 5)
+        G.add_edge(4, 5)
+        G.add_edge(5, 6)
+        G.add_edge(5, 7)
+        G.add_edge(5, 8)
+        self.G = G
+
+    def test_degree_centrality_1(self):
+        d = nx.degree_centrality(self.K5)
+        exact = dict(zip(range(5), [1] * 5))
+        for n, dc in d.items():
+            assert exact[n] == pytest.approx(dc, abs=1e-7)
+
+    def test_degree_centrality_2(self):
+        d = nx.degree_centrality(self.P3)
+        exact = {0: 0.5, 1: 1, 2: 0.5}
+        for n, dc in d.items():
+            assert exact[n] == pytest.approx(dc, abs=1e-7)
+
+    def test_degree_centrality_3(self):
+        d = nx.degree_centrality(self.K)
+        exact = {
+            0: 0.444,
+            1: 0.444,
+            2: 0.333,
+            3: 0.667,
+            4: 0.333,
+            5: 0.556,
+            6: 0.556,
+            7: 0.333,
+            8: 0.222,
+            9: 0.111,
+        }
+        for n, dc in d.items():
+            assert exact[n] == pytest.approx(float(f"{dc:.3f}"), abs=1e-7)
+
+    def test_degree_centrality_4(self):
+        d = nx.degree_centrality(self.F)
+        names = sorted(self.F.nodes())
+        dcs = [
+            0.071,
+            0.214,
+            0.143,
+            0.214,
+            0.214,
+            0.071,
+            0.286,
+            0.071,
+            0.429,
+            0.071,
+            0.214,
+            0.214,
+            0.143,
+            0.286,
+            0.214,
+        ]
+        exact = dict(zip(names, dcs))
+        for n, dc in d.items():
+            assert exact[n] == pytest.approx(float(f"{dc:.3f}"), abs=1e-7)
+
+    def test_indegree_centrality(self):
+        d = nx.in_degree_centrality(self.G)
+        exact = {
+            0: 0.0,
+            1: 0.0,
+            2: 0.0,
+            3: 0.0,
+            4: 0.0,
+            5: 0.625,
+            6: 0.125,
+            7: 0.125,
+            8: 0.125,
+        }
+        for n, dc in d.items():
+            assert exact[n] == pytest.approx(dc, abs=1e-7)
+
+    def test_outdegree_centrality(self):
+        d = nx.out_degree_centrality(self.G)
+        exact = {
+            0: 0.125,
+            1: 0.125,
+            2: 0.125,
+            3: 0.125,
+            4: 0.125,
+            5: 0.375,
+            6: 0.0,
+            7: 0.0,
+            8: 0.0,
+        }
+        for n, dc in d.items():
+            assert exact[n] == pytest.approx(dc, abs=1e-7)
+
+    def test_small_graph_centrality(self):
+        G = nx.empty_graph(create_using=nx.DiGraph)
+        assert {} == nx.degree_centrality(G)
+        assert {} == nx.out_degree_centrality(G)
+        assert {} == nx.in_degree_centrality(G)
+
+        G = nx.empty_graph(1, create_using=nx.DiGraph)
+        assert {0: 1} == nx.degree_centrality(G)
+        assert {0: 1} == nx.out_degree_centrality(G)
+        assert {0: 1} == nx.in_degree_centrality(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_dispersion.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_dispersion.py
new file mode 100644
index 0000000..2aac0de
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_dispersion.py
@@ -0,0 +1,66 @@
+import networkx as nx
+
+
+def small_ego_G():
+    """The sample network from https://arxiv.org/pdf/1310.6753v1.pdf"""
+    edges = [
+        ("a", "b"),
+        ("a", "c"),
+        ("b", "c"),
+        ("b", "d"),
+        ("b", "e"),
+        ("b", "f"),
+        ("c", "d"),
+        ("c", "f"),
+        ("c", "h"),
+        ("d", "f"),
+        ("e", "f"),
+        ("f", "h"),
+        ("h", "j"),
+        ("h", "k"),
+        ("i", "j"),
+        ("i", "k"),
+        ("j", "k"),
+        ("u", "a"),
+        ("u", "b"),
+        ("u", "c"),
+        ("u", "d"),
+        ("u", "e"),
+        ("u", "f"),
+        ("u", "g"),
+        ("u", "h"),
+        ("u", "i"),
+        ("u", "j"),
+        ("u", "k"),
+    ]
+    G = nx.Graph()
+    G.add_edges_from(edges)
+
+    return G
+
+
+class TestDispersion:
+    def test_article(self):
+        """our algorithm matches article's"""
+        G = small_ego_G()
+        disp_uh = nx.dispersion(G, "u", "h", normalized=False)
+        disp_ub = nx.dispersion(G, "u", "b", normalized=False)
+        assert disp_uh == 4
+        assert disp_ub == 1
+
+    def test_results_length(self):
+        """there is a result for every node"""
+        G = small_ego_G()
+        disp = nx.dispersion(G)
+        disp_Gu = nx.dispersion(G, "u")
+        disp_uv = nx.dispersion(G, "u", "h")
+        assert len(disp) == len(G)
+        assert len(disp_Gu) == len(G) - 1
+        assert isinstance(disp_uv, float)
+
+    def test_impossible_things(self):
+        G = nx.karate_club_graph()
+        disp = nx.dispersion(G)
+        for u in disp:
+            for v in disp[u]:
+                assert disp[u][v] >= 0
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_eigenvector_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_eigenvector_centrality.py
new file mode 100644
index 0000000..7a44aff
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_eigenvector_centrality.py
@@ -0,0 +1,168 @@
+import math
+
+import pytest
+
+np = pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+
+import networkx as nx
+
+
+class TestEigenvectorCentrality:
+    def test_K5(self):
+        """Eigenvector centrality: K5"""
+        G = nx.complete_graph(5)
+        b = nx.eigenvector_centrality(G)
+        v = math.sqrt(1 / 5.0)
+        b_answer = dict.fromkeys(G, v)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        nstart = {n: 1 for n in G}
+        b = nx.eigenvector_centrality(G, nstart=nstart)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+        b = nx.eigenvector_centrality_numpy(G)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_P3(self):
+        """Eigenvector centrality: P3"""
+        G = nx.path_graph(3)
+        b_answer = {0: 0.5, 1: 0.7071, 2: 0.5}
+        b = nx.eigenvector_centrality_numpy(G)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
+        b = nx.eigenvector_centrality(G)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
+
+    def test_P3_unweighted(self):
+        """Eigenvector centrality: P3"""
+        G = nx.path_graph(3)
+        b_answer = {0: 0.5, 1: 0.7071, 2: 0.5}
+        b = nx.eigenvector_centrality_numpy(G, weight=None)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
+
+    def test_maxiter(self):
+        with pytest.raises(nx.PowerIterationFailedConvergence):
+            G = nx.path_graph(3)
+            nx.eigenvector_centrality(G, max_iter=0)
+
+
+class TestEigenvectorCentralityDirected:
+    @classmethod
+    def setup_class(cls):
+        G = nx.DiGraph()
+
+        edges = [
+            (1, 2),
+            (1, 3),
+            (2, 4),
+            (3, 2),
+            (3, 5),
+            (4, 2),
+            (4, 5),
+            (4, 6),
+            (5, 6),
+            (5, 7),
+            (5, 8),
+            (6, 8),
+            (7, 1),
+            (7, 5),
+            (7, 8),
+            (8, 6),
+            (8, 7),
+        ]
+
+        G.add_edges_from(edges, weight=2.0)
+        cls.G = G.reverse()
+        cls.G.evc = [
+            0.25368793,
+            0.19576478,
+            0.32817092,
+            0.40430835,
+            0.48199885,
+            0.15724483,
+            0.51346196,
+            0.32475403,
+        ]
+
+        H = nx.DiGraph()
+
+        edges = [
+            (1, 2),
+            (1, 3),
+            (2, 4),
+            (3, 2),
+            (3, 5),
+            (4, 2),
+            (4, 5),
+            (4, 6),
+            (5, 6),
+            (5, 7),
+            (5, 8),
+            (6, 8),
+            (7, 1),
+            (7, 5),
+            (7, 8),
+            (8, 6),
+            (8, 7),
+        ]
+
+        G.add_edges_from(edges)
+        cls.H = G.reverse()
+        cls.H.evc = [
+            0.25368793,
+            0.19576478,
+            0.32817092,
+            0.40430835,
+            0.48199885,
+            0.15724483,
+            0.51346196,
+            0.32475403,
+        ]
+
+    def test_eigenvector_centrality_weighted(self):
+        G = self.G
+        p = nx.eigenvector_centrality(G)
+        for (a, b) in zip(list(p.values()), self.G.evc):
+            assert a == pytest.approx(b, abs=1e-4)
+
+    def test_eigenvector_centrality_weighted_numpy(self):
+        G = self.G
+        p = nx.eigenvector_centrality_numpy(G)
+        for (a, b) in zip(list(p.values()), self.G.evc):
+            assert a == pytest.approx(b, abs=1e-7)
+
+    def test_eigenvector_centrality_unweighted(self):
+        G = self.H
+        p = nx.eigenvector_centrality(G)
+        for (a, b) in zip(list(p.values()), self.G.evc):
+            assert a == pytest.approx(b, abs=1e-4)
+
+    def test_eigenvector_centrality_unweighted_numpy(self):
+        G = self.H
+        p = nx.eigenvector_centrality_numpy(G)
+        for (a, b) in zip(list(p.values()), self.G.evc):
+            assert a == pytest.approx(b, abs=1e-7)
+
+
+class TestEigenvectorCentralityExceptions:
+    def test_multigraph(self):
+        with pytest.raises(nx.NetworkXException):
+            nx.eigenvector_centrality(nx.MultiGraph())
+
+    def test_multigraph_numpy(self):
+        with pytest.raises(nx.NetworkXException):
+            nx.eigenvector_centrality_numpy(nx.MultiGraph())
+
+    def test_empty(self):
+        with pytest.raises(nx.NetworkXException):
+            nx.eigenvector_centrality(nx.Graph())
+
+    def test_empty_numpy(self):
+        with pytest.raises(nx.NetworkXException):
+            nx.eigenvector_centrality_numpy(nx.Graph())
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_group.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_group.py
new file mode 100644
index 0000000..3f5559d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_group.py
@@ -0,0 +1,278 @@
+"""
+Tests for Group Centrality Measures
+"""
+
+
+import pytest
+
+import networkx as nx
+
+
+class TestGroupBetweennessCentrality:
+    def test_group_betweenness_single_node(self):
+        """
+        Group betweenness centrality for single node group
+        """
+        G = nx.path_graph(5)
+        C = [1]
+        b = nx.group_betweenness_centrality(
+            G, C, weight=None, normalized=False, endpoints=False
+        )
+        b_answer = 3.0
+        assert b == b_answer
+
+    def test_group_betweenness_with_endpoints(self):
+        """
+        Group betweenness centrality for single node group
+        """
+        G = nx.path_graph(5)
+        C = [1]
+        b = nx.group_betweenness_centrality(
+            G, C, weight=None, normalized=False, endpoints=True
+        )
+        b_answer = 7.0
+        assert b == b_answer
+
+    def test_group_betweenness_normalized(self):
+        """
+        Group betweenness centrality for group with more than
+        1 node and normalized
+        """
+        G = nx.path_graph(5)
+        C = [1, 3]
+        b = nx.group_betweenness_centrality(
+            G, C, weight=None, normalized=True, endpoints=False
+        )
+        b_answer = 1.0
+        assert b == b_answer
+
+    def test_two_group_betweenness_value_zero(self):
+        """
+        Group betweenness centrality value of 0
+        """
+        G = nx.cycle_graph(7)
+        C = [[0, 1, 6], [0, 1, 5]]
+        b = nx.group_betweenness_centrality(G, C, weight=None, normalized=False)
+        b_answer = [0.0, 3.0]
+        assert b == b_answer
+
+    def test_group_betweenness_value_zero(self):
+        """
+        Group betweenness centrality value of 0
+        """
+        G = nx.cycle_graph(6)
+        C = [0, 1, 5]
+        b = nx.group_betweenness_centrality(G, C, weight=None, normalized=False)
+        b_answer = 0.0
+        assert b == b_answer
+
+    def test_group_betweenness_disconnected_graph(self):
+        """
+        Group betweenness centrality in a disconnected graph
+        """
+        G = nx.path_graph(5)
+        G.remove_edge(0, 1)
+        C = [1]
+        b = nx.group_betweenness_centrality(G, C, weight=None, normalized=False)
+        b_answer = 0.0
+        assert b == b_answer
+
+    def test_group_betweenness_node_not_in_graph(self):
+        """
+        Node(s) in C not in graph, raises NodeNotFound exception
+        """
+        with pytest.raises(nx.NodeNotFound):
+            nx.group_betweenness_centrality(nx.path_graph(5), [4, 7, 8])
+
+    def test_group_betweenness_directed_weighted(self):
+        """
+        Group betweenness centrality in a directed and weighted graph
+        """
+        G = nx.DiGraph()
+        G.add_edge(1, 0, weight=1)
+        G.add_edge(0, 2, weight=2)
+        G.add_edge(1, 2, weight=3)
+        G.add_edge(3, 1, weight=4)
+        G.add_edge(2, 3, weight=1)
+        G.add_edge(4, 3, weight=6)
+        G.add_edge(2, 4, weight=7)
+        C = [1, 2]
+        b = nx.group_betweenness_centrality(G, C, weight="weight", normalized=False)
+        b_answer = 5.0
+        assert b == b_answer
+
+
+class TestProminentGroup:
+    np = pytest.importorskip("numpy")
+    pd = pytest.importorskip("pandas")
+
+    def test_prominent_group_single_node(self):
+        """
+        Prominent group for single node
+        """
+        G = nx.path_graph(5)
+        k = 1
+        b, g = nx.prominent_group(G, k, normalized=False, endpoints=False)
+        b_answer, g_answer = 4.0, [2]
+        assert b == b_answer and g == g_answer
+
+    def test_prominent_group_with_c(self):
+        """
+        Prominent group without some nodes
+        """
+        G = nx.path_graph(5)
+        k = 1
+        b, g = nx.prominent_group(G, k, normalized=False, C=[2])
+        b_answer, g_answer = 3.0, [1]
+        assert b == b_answer and g == g_answer
+
+    def test_prominent_group_normalized_endpoints(self):
+        """
+        Prominent group with normalized result, with endpoints
+        """
+        G = nx.cycle_graph(7)
+        k = 2
+        b, g = nx.prominent_group(G, k, normalized=True, endpoints=True)
+        b_answer, g_answer = 1.7, [2, 5]
+        assert b == b_answer and g == g_answer
+
+    def test_prominent_group_disconnected_graph(self):
+        """
+        Prominent group of disconnected graph
+        """
+        G = nx.path_graph(6)
+        G.remove_edge(0, 1)
+        k = 1
+        b, g = nx.prominent_group(G, k, weight=None, normalized=False)
+        b_answer, g_answer = 4.0, [3]
+        assert b == b_answer and g == g_answer
+
+    def test_prominent_group_node_not_in_graph(self):
+        """
+        Node(s) in C not in graph, raises NodeNotFound exception
+        """
+        with pytest.raises(nx.NodeNotFound):
+            nx.prominent_group(nx.path_graph(5), 1, C=[10])
+
+    def test_group_betweenness_directed_weighted(self):
+        """
+        Group betweenness centrality in a directed and weighted graph
+        """
+        G = nx.DiGraph()
+        G.add_edge(1, 0, weight=1)
+        G.add_edge(0, 2, weight=2)
+        G.add_edge(1, 2, weight=3)
+        G.add_edge(3, 1, weight=4)
+        G.add_edge(2, 3, weight=1)
+        G.add_edge(4, 3, weight=6)
+        G.add_edge(2, 4, weight=7)
+        k = 2
+        b, g = nx.prominent_group(G, k, weight="weight", normalized=False)
+        b_answer, g_answer = 5.0, [1, 2]
+        assert b == b_answer and g == g_answer
+
+    def test_prominent_group_greedy_algorithm(self):
+        """
+        Group betweenness centrality in a greedy algorithm
+        """
+        G = nx.cycle_graph(7)
+        k = 2
+        b, g = nx.prominent_group(G, k, normalized=True, endpoints=True, greedy=True)
+        b_answer, g_answer = 1.7, [6, 3]
+        assert b == b_answer and g == g_answer
+
+
+class TestGroupClosenessCentrality:
+    def test_group_closeness_single_node(self):
+        """
+        Group closeness centrality for a single node group
+        """
+        G = nx.path_graph(5)
+        c = nx.group_closeness_centrality(G, [1])
+        c_answer = nx.closeness_centrality(G, 1)
+        assert c == c_answer
+
+    def test_group_closeness_disconnected(self):
+        """
+        Group closeness centrality for a disconnected graph
+        """
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3, 4])
+        c = nx.group_closeness_centrality(G, [1, 2])
+        c_answer = 0
+        assert c == c_answer
+
+    def test_group_closeness_multiple_node(self):
+        """
+        Group closeness centrality for a group with more than
+        1 node
+        """
+        G = nx.path_graph(4)
+        c = nx.group_closeness_centrality(G, [1, 2])
+        c_answer = 1
+        assert c == c_answer
+
+    def test_group_closeness_node_not_in_graph(self):
+        """
+        Node(s) in S not in graph, raises NodeNotFound exception
+        """
+        with pytest.raises(nx.NodeNotFound):
+            nx.group_closeness_centrality(nx.path_graph(5), [6, 7, 8])
+
+
+class TestGroupDegreeCentrality:
+    def test_group_degree_centrality_single_node(self):
+        """
+        Group degree centrality for a single node group
+        """
+        G = nx.path_graph(4)
+        d = nx.group_degree_centrality(G, [1])
+        d_answer = nx.degree_centrality(G)[1]
+        assert d == d_answer
+
+    def test_group_degree_centrality_multiple_node(self):
+        """
+        Group degree centrality for group with more than
+        1 node
+        """
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8])
+        G.add_edges_from(
+            [(1, 2), (1, 3), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5)]
+        )
+        d = nx.group_degree_centrality(G, [1, 2])
+        d_answer = 1
+        assert d == d_answer
+
+    def test_group_in_degree_centrality(self):
+        """
+        Group in-degree centrality in a DiGraph
+        """
+        G = nx.DiGraph()
+        G.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8])
+        G.add_edges_from(
+            [(1, 2), (1, 3), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5)]
+        )
+        d = nx.group_in_degree_centrality(G, [1, 2])
+        d_answer = 0
+        assert d == d_answer
+
+    def test_group_out_degree_centrality(self):
+        """
+        Group out-degree centrality in a DiGraph
+        """
+        G = nx.DiGraph()
+        G.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8])
+        G.add_edges_from(
+            [(1, 2), (1, 3), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5)]
+        )
+        d = nx.group_out_degree_centrality(G, [1, 2])
+        d_answer = 1
+        assert d == d_answer
+
+    def test_group_degree_centrality_node_not_in_graph(self):
+        """
+        Node(s) in S not in graph, raises NetworkXError
+        """
+        with pytest.raises(nx.NetworkXError):
+            nx.group_degree_centrality(nx.path_graph(5), [6, 7, 8])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_harmonic_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_harmonic_centrality.py
new file mode 100644
index 0000000..450356e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_harmonic_centrality.py
@@ -0,0 +1,115 @@
+"""
+Tests for degree centrality.
+"""
+import pytest
+
+import networkx as nx
+from networkx.algorithms.centrality import harmonic_centrality
+
+
+class TestClosenessCentrality:
+    @classmethod
+    def setup_class(cls):
+        cls.P3 = nx.path_graph(3)
+        cls.P4 = nx.path_graph(4)
+        cls.K5 = nx.complete_graph(5)
+
+        cls.C4 = nx.cycle_graph(4)
+        cls.C4_directed = nx.cycle_graph(4, create_using=nx.DiGraph)
+
+        cls.C5 = nx.cycle_graph(5)
+
+        cls.T = nx.balanced_tree(r=2, h=2)
+
+        cls.Gb = nx.DiGraph()
+        cls.Gb.add_edges_from([(0, 1), (0, 2), (0, 4), (2, 1), (2, 3), (4, 3)])
+
+    def test_p3_harmonic(self):
+        c = harmonic_centrality(self.P3)
+        d = {0: 1.5, 1: 2, 2: 1.5}
+        for n in sorted(self.P3):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_p4_harmonic(self):
+        c = harmonic_centrality(self.P4)
+        d = {0: 1.8333333, 1: 2.5, 2: 2.5, 3: 1.8333333}
+        for n in sorted(self.P4):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_clique_complete(self):
+        c = harmonic_centrality(self.K5)
+        d = {0: 4, 1: 4, 2: 4, 3: 4, 4: 4}
+        for n in sorted(self.P3):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_cycle_C4(self):
+        c = harmonic_centrality(self.C4)
+        d = {0: 2.5, 1: 2.5, 2: 2.5, 3: 2.5}
+        for n in sorted(self.C4):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_cycle_C5(self):
+        c = harmonic_centrality(self.C5)
+        d = {0: 3, 1: 3, 2: 3, 3: 3, 4: 3, 5: 4}
+        for n in sorted(self.C5):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_bal_tree(self):
+        c = harmonic_centrality(self.T)
+        d = {0: 4.0, 1: 4.1666, 2: 4.1666, 3: 2.8333, 4: 2.8333, 5: 2.8333, 6: 2.8333}
+        for n in sorted(self.T):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_exampleGraph(self):
+        c = harmonic_centrality(self.Gb)
+        d = {0: 0, 1: 2, 2: 1, 3: 2.5, 4: 1}
+        for n in sorted(self.Gb):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_weighted_harmonic(self):
+        XG = nx.DiGraph()
+        XG.add_weighted_edges_from(
+            [
+                ("a", "b", 10),
+                ("d", "c", 5),
+                ("a", "c", 1),
+                ("e", "f", 2),
+                ("f", "c", 1),
+                ("a", "f", 3),
+            ]
+        )
+        c = harmonic_centrality(XG, distance="weight")
+        d = {"a": 0, "b": 0.1, "c": 2.533, "d": 0, "e": 0, "f": 0.83333}
+        for n in sorted(XG):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_empty(self):
+        G = nx.DiGraph()
+        c = harmonic_centrality(G, distance="weight")
+        d = {}
+        assert c == d
+
+    def test_singleton(self):
+        G = nx.DiGraph()
+        G.add_node(0)
+        c = harmonic_centrality(G, distance="weight")
+        d = {0: 0}
+        assert c == d
+
+    def test_cycle_c4_directed(self):
+        c = harmonic_centrality(self.C4_directed, nbunch=[0, 1], sources=[1, 2])
+        d = {0: 0.833, 1: 0.333}
+        for n in [0, 1]:
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_p3_harmonic_subset(self):
+        c = harmonic_centrality(self.P3, sources=[0, 1])
+        d = {0: 1, 1: 1, 2: 1.5}
+        for n in self.P3:
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_p4_harmonic_subset(self):
+        c = harmonic_centrality(self.P4, nbunch=[2, 3], sources=[0, 1])
+        d = {2: 1.5, 3: 0.8333333}
+        for n in [2, 3]:
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_katz_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_katz_centrality.py
new file mode 100644
index 0000000..2511453
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_katz_centrality.py
@@ -0,0 +1,345 @@
+import math
+
+import pytest
+
+import networkx as nx
+
+
+class TestKatzCentrality:
+    def test_K5(self):
+        """Katz centrality: K5"""
+        G = nx.complete_graph(5)
+        alpha = 0.1
+        b = nx.katz_centrality(G, alpha)
+        v = math.sqrt(1 / 5.0)
+        b_answer = dict.fromkeys(G, v)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        nstart = {n: 1 for n in G}
+        b = nx.katz_centrality(G, alpha, nstart=nstart)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+
+    def test_P3(self):
+        """Katz centrality: P3"""
+        alpha = 0.1
+        G = nx.path_graph(3)
+        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
+        b = nx.katz_centrality(G, alpha)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
+
+    def test_maxiter(self):
+        with pytest.raises(nx.PowerIterationFailedConvergence):
+            nx.katz_centrality(nx.path_graph(3), 0.1, max_iter=0)
+
+    def test_beta_as_scalar(self):
+        alpha = 0.1
+        beta = 0.1
+        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
+        G = nx.path_graph(3)
+        b = nx.katz_centrality(G, alpha, beta)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
+
+    def test_beta_as_dict(self):
+        alpha = 0.1
+        beta = {0: 1.0, 1: 1.0, 2: 1.0}
+        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
+        G = nx.path_graph(3)
+        b = nx.katz_centrality(G, alpha, beta)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
+
+    def test_multiple_alpha(self):
+        alpha_list = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]
+        for alpha in alpha_list:
+            b_answer = {
+                0.1: {
+                    0: 0.5598852584152165,
+                    1: 0.6107839182711449,
+                    2: 0.5598852584152162,
+                },
+                0.2: {
+                    0: 0.5454545454545454,
+                    1: 0.6363636363636365,
+                    2: 0.5454545454545454,
+                },
+                0.3: {
+                    0: 0.5333964609104419,
+                    1: 0.6564879518897746,
+                    2: 0.5333964609104419,
+                },
+                0.4: {
+                    0: 0.5232045649263551,
+                    1: 0.6726915834767423,
+                    2: 0.5232045649263551,
+                },
+                0.5: {
+                    0: 0.5144957746691622,
+                    1: 0.6859943117075809,
+                    2: 0.5144957746691622,
+                },
+                0.6: {
+                    0: 0.5069794004195823,
+                    1: 0.6970966755769258,
+                    2: 0.5069794004195823,
+                },
+            }
+            G = nx.path_graph(3)
+            b = nx.katz_centrality(G, alpha)
+            for n in sorted(G):
+                assert b[n] == pytest.approx(b_answer[alpha][n], abs=1e-4)
+
+    def test_multigraph(self):
+        with pytest.raises(nx.NetworkXException):
+            nx.katz_centrality(nx.MultiGraph(), 0.1)
+
+    def test_empty(self):
+        e = nx.katz_centrality(nx.Graph(), 0.1)
+        assert e == {}
+
+    def test_bad_beta(self):
+        with pytest.raises(nx.NetworkXException):
+            G = nx.Graph([(0, 1)])
+            beta = {0: 77}
+            nx.katz_centrality(G, 0.1, beta=beta)
+
+    def test_bad_beta_numbe(self):
+        with pytest.raises(nx.NetworkXException):
+            G = nx.Graph([(0, 1)])
+            nx.katz_centrality(G, 0.1, beta="foo")
+
+
+class TestKatzCentralityNumpy:
+    @classmethod
+    def setup_class(cls):
+        global np
+        np = pytest.importorskip("numpy")
+        pytest.importorskip("scipy")
+
+    def test_K5(self):
+        """Katz centrality: K5"""
+        G = nx.complete_graph(5)
+        alpha = 0.1
+        b = nx.katz_centrality(G, alpha)
+        v = math.sqrt(1 / 5.0)
+        b_answer = dict.fromkeys(G, v)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        b = nx.eigenvector_centrality_numpy(G)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_P3(self):
+        """Katz centrality: P3"""
+        alpha = 0.1
+        G = nx.path_graph(3)
+        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
+        b = nx.katz_centrality_numpy(G, alpha)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
+
+    def test_beta_as_scalar(self):
+        alpha = 0.1
+        beta = 0.1
+        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
+        G = nx.path_graph(3)
+        b = nx.katz_centrality_numpy(G, alpha, beta)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
+
+    def test_beta_as_dict(self):
+        alpha = 0.1
+        beta = {0: 1.0, 1: 1.0, 2: 1.0}
+        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
+        G = nx.path_graph(3)
+        b = nx.katz_centrality_numpy(G, alpha, beta)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
+
+    def test_multiple_alpha(self):
+        alpha_list = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]
+        for alpha in alpha_list:
+            b_answer = {
+                0.1: {
+                    0: 0.5598852584152165,
+                    1: 0.6107839182711449,
+                    2: 0.5598852584152162,
+                },
+                0.2: {
+                    0: 0.5454545454545454,
+                    1: 0.6363636363636365,
+                    2: 0.5454545454545454,
+                },
+                0.3: {
+                    0: 0.5333964609104419,
+                    1: 0.6564879518897746,
+                    2: 0.5333964609104419,
+                },
+                0.4: {
+                    0: 0.5232045649263551,
+                    1: 0.6726915834767423,
+                    2: 0.5232045649263551,
+                },
+                0.5: {
+                    0: 0.5144957746691622,
+                    1: 0.6859943117075809,
+                    2: 0.5144957746691622,
+                },
+                0.6: {
+                    0: 0.5069794004195823,
+                    1: 0.6970966755769258,
+                    2: 0.5069794004195823,
+                },
+            }
+            G = nx.path_graph(3)
+            b = nx.katz_centrality_numpy(G, alpha)
+            for n in sorted(G):
+                assert b[n] == pytest.approx(b_answer[alpha][n], abs=1e-4)
+
+    def test_multigraph(self):
+        with pytest.raises(nx.NetworkXException):
+            nx.katz_centrality(nx.MultiGraph(), 0.1)
+
+    def test_empty(self):
+        e = nx.katz_centrality(nx.Graph(), 0.1)
+        assert e == {}
+
+    def test_bad_beta(self):
+        with pytest.raises(nx.NetworkXException):
+            G = nx.Graph([(0, 1)])
+            beta = {0: 77}
+            nx.katz_centrality_numpy(G, 0.1, beta=beta)
+
+    def test_bad_beta_numbe(self):
+        with pytest.raises(nx.NetworkXException):
+            G = nx.Graph([(0, 1)])
+            nx.katz_centrality_numpy(G, 0.1, beta="foo")
+
+    def test_K5_unweighted(self):
+        """Katz centrality: K5"""
+        G = nx.complete_graph(5)
+        alpha = 0.1
+        b = nx.katz_centrality(G, alpha, weight=None)
+        v = math.sqrt(1 / 5.0)
+        b_answer = dict.fromkeys(G, v)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
+        b = nx.eigenvector_centrality_numpy(G, weight=None)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+    def test_P3_unweighted(self):
+        """Katz centrality: P3"""
+        alpha = 0.1
+        G = nx.path_graph(3)
+        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
+        b = nx.katz_centrality_numpy(G, alpha, weight=None)
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
+
+
+class TestKatzCentralityDirected:
+    @classmethod
+    def setup_class(cls):
+        G = nx.DiGraph()
+        edges = [
+            (1, 2),
+            (1, 3),
+            (2, 4),
+            (3, 2),
+            (3, 5),
+            (4, 2),
+            (4, 5),
+            (4, 6),
+            (5, 6),
+            (5, 7),
+            (5, 8),
+            (6, 8),
+            (7, 1),
+            (7, 5),
+            (7, 8),
+            (8, 6),
+            (8, 7),
+        ]
+        G.add_edges_from(edges, weight=2.0)
+        cls.G = G.reverse()
+        cls.G.alpha = 0.1
+        cls.G.evc = [
+            0.3289589783189635,
+            0.2832077296243516,
+            0.3425906003685471,
+            0.3970420865198392,
+            0.41074871061646284,
+            0.272257430756461,
+            0.4201989685435462,
+            0.34229059218038554,
+        ]
+
+        H = nx.DiGraph(edges)
+        cls.H = G.reverse()
+        cls.H.alpha = 0.1
+        cls.H.evc = [
+            0.3289589783189635,
+            0.2832077296243516,
+            0.3425906003685471,
+            0.3970420865198392,
+            0.41074871061646284,
+            0.272257430756461,
+            0.4201989685435462,
+            0.34229059218038554,
+        ]
+
+    def test_katz_centrality_weighted(self):
+        G = self.G
+        alpha = self.G.alpha
+        p = nx.katz_centrality(G, alpha, weight="weight")
+        for (a, b) in zip(list(p.values()), self.G.evc):
+            assert a == pytest.approx(b, abs=1e-7)
+
+    def test_katz_centrality_unweighted(self):
+        H = self.H
+        alpha = self.H.alpha
+        p = nx.katz_centrality(H, alpha, weight="weight")
+        for (a, b) in zip(list(p.values()), self.H.evc):
+            assert a == pytest.approx(b, abs=1e-7)
+
+
+class TestKatzCentralityDirectedNumpy(TestKatzCentralityDirected):
+    @classmethod
+    def setup_class(cls):
+        global np
+        np = pytest.importorskip("numpy")
+        pytest.importorskip("scipy")
+        super().setup_class()
+
+    def test_katz_centrality_weighted(self):
+        G = self.G
+        alpha = self.G.alpha
+        p = nx.katz_centrality_numpy(G, alpha, weight="weight")
+        for (a, b) in zip(list(p.values()), self.G.evc):
+            assert a == pytest.approx(b, abs=1e-7)
+
+    def test_katz_centrality_unweighted(self):
+        H = self.H
+        alpha = self.H.alpha
+        p = nx.katz_centrality_numpy(H, alpha, weight="weight")
+        for (a, b) in zip(list(p.values()), self.H.evc):
+            assert a == pytest.approx(b, abs=1e-7)
+
+
+class TestKatzEigenvectorVKatz:
+    @classmethod
+    def setup_class(cls):
+        global np
+        np = pytest.importorskip("numpy")
+        pytest.importorskip("scipy")
+
+    def test_eigenvector_v_katz_random(self):
+        G = nx.gnp_random_graph(10, 0.5, seed=1234)
+        l = max(np.linalg.eigvals(nx.adjacency_matrix(G).todense()))
+        e = nx.eigenvector_centrality_numpy(G)
+        k = nx.katz_centrality_numpy(G, 1.0 / l)
+        for n in G:
+            assert e[n] == pytest.approx(k[n], abs=1e-7)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_load_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_load_centrality.py
new file mode 100644
index 0000000..065b4fd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_load_centrality.py
@@ -0,0 +1,337 @@
+import pytest
+
+import networkx as nx
+
+
+class TestLoadCentrality:
+    @classmethod
+    def setup_class(cls):
+
+        G = nx.Graph()
+        G.add_edge(0, 1, weight=3)
+        G.add_edge(0, 2, weight=2)
+        G.add_edge(0, 3, weight=6)
+        G.add_edge(0, 4, weight=4)
+        G.add_edge(1, 3, weight=5)
+        G.add_edge(1, 5, weight=5)
+        G.add_edge(2, 4, weight=1)
+        G.add_edge(3, 4, weight=2)
+        G.add_edge(3, 5, weight=1)
+        G.add_edge(4, 5, weight=4)
+        cls.G = G
+        cls.exact_weighted = {0: 4.0, 1: 0.0, 2: 8.0, 3: 6.0, 4: 8.0, 5: 0.0}
+        cls.K = nx.krackhardt_kite_graph()
+        cls.P3 = nx.path_graph(3)
+        cls.P4 = nx.path_graph(4)
+        cls.K5 = nx.complete_graph(5)
+
+        cls.C4 = nx.cycle_graph(4)
+        cls.T = nx.balanced_tree(r=2, h=2)
+        cls.Gb = nx.Graph()
+        cls.Gb.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (4, 5), (3, 5)])
+        cls.F = nx.florentine_families_graph()
+        cls.LM = nx.les_miserables_graph()
+        cls.D = nx.cycle_graph(3, create_using=nx.DiGraph())
+        cls.D.add_edges_from([(3, 0), (4, 3)])
+
+    def test_not_strongly_connected(self):
+        b = nx.load_centrality(self.D)
+        result = {0: 5.0 / 12, 1: 1.0 / 4, 2: 1.0 / 12, 3: 1.0 / 4, 4: 0.000}
+        for n in sorted(self.D):
+            assert result[n] == pytest.approx(b[n], abs=1e-3)
+            assert result[n] == pytest.approx(nx.load_centrality(self.D, n), abs=1e-3)
+
+    def test_weighted_load(self):
+        b = nx.load_centrality(self.G, weight="weight", normalized=False)
+        for n in sorted(self.G):
+            assert b[n] == self.exact_weighted[n]
+
+    def test_k5_load(self):
+        G = self.K5
+        c = nx.load_centrality(G)
+        d = {0: 0.000, 1: 0.000, 2: 0.000, 3: 0.000, 4: 0.000}
+        for n in sorted(G):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_p3_load(self):
+        G = self.P3
+        c = nx.load_centrality(G)
+        d = {0: 0.000, 1: 1.000, 2: 0.000}
+        for n in sorted(G):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+        c = nx.load_centrality(G, v=1)
+        assert c == pytest.approx(1.0, abs=1e-7)
+        c = nx.load_centrality(G, v=1, normalized=True)
+        assert c == pytest.approx(1.0, abs=1e-7)
+
+    def test_p2_load(self):
+        G = nx.path_graph(2)
+        c = nx.load_centrality(G)
+        d = {0: 0.000, 1: 0.000}
+        for n in sorted(G):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_krackhardt_load(self):
+        G = self.K
+        c = nx.load_centrality(G)
+        d = {
+            0: 0.023,
+            1: 0.023,
+            2: 0.000,
+            3: 0.102,
+            4: 0.000,
+            5: 0.231,
+            6: 0.231,
+            7: 0.389,
+            8: 0.222,
+            9: 0.000,
+        }
+        for n in sorted(G):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_florentine_families_load(self):
+        G = self.F
+        c = nx.load_centrality(G)
+        d = {
+            "Acciaiuoli": 0.000,
+            "Albizzi": 0.211,
+            "Barbadori": 0.093,
+            "Bischeri": 0.104,
+            "Castellani": 0.055,
+            "Ginori": 0.000,
+            "Guadagni": 0.251,
+            "Lamberteschi": 0.000,
+            "Medici": 0.522,
+            "Pazzi": 0.000,
+            "Peruzzi": 0.022,
+            "Ridolfi": 0.117,
+            "Salviati": 0.143,
+            "Strozzi": 0.106,
+            "Tornabuoni": 0.090,
+        }
+        for n in sorted(G):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_les_miserables_load(self):
+        G = self.LM
+        c = nx.load_centrality(G)
+        d = {
+            "Napoleon": 0.000,
+            "Myriel": 0.177,
+            "MlleBaptistine": 0.000,
+            "MmeMagloire": 0.000,
+            "CountessDeLo": 0.000,
+            "Geborand": 0.000,
+            "Champtercier": 0.000,
+            "Cravatte": 0.000,
+            "Count": 0.000,
+            "OldMan": 0.000,
+            "Valjean": 0.567,
+            "Labarre": 0.000,
+            "Marguerite": 0.000,
+            "MmeDeR": 0.000,
+            "Isabeau": 0.000,
+            "Gervais": 0.000,
+            "Listolier": 0.000,
+            "Tholomyes": 0.043,
+            "Fameuil": 0.000,
+            "Blacheville": 0.000,
+            "Favourite": 0.000,
+            "Dahlia": 0.000,
+            "Zephine": 0.000,
+            "Fantine": 0.128,
+            "MmeThenardier": 0.029,
+            "Thenardier": 0.075,
+            "Cosette": 0.024,
+            "Javert": 0.054,
+            "Fauchelevent": 0.026,
+            "Bamatabois": 0.008,
+            "Perpetue": 0.000,
+            "Simplice": 0.009,
+            "Scaufflaire": 0.000,
+            "Woman1": 0.000,
+            "Judge": 0.000,
+            "Champmathieu": 0.000,
+            "Brevet": 0.000,
+            "Chenildieu": 0.000,
+            "Cochepaille": 0.000,
+            "Pontmercy": 0.007,
+            "Boulatruelle": 0.000,
+            "Eponine": 0.012,
+            "Anzelma": 0.000,
+            "Woman2": 0.000,
+            "MotherInnocent": 0.000,
+            "Gribier": 0.000,
+            "MmeBurgon": 0.026,
+            "Jondrette": 0.000,
+            "Gavroche": 0.164,
+            "Gillenormand": 0.021,
+            "Magnon": 0.000,
+            "MlleGillenormand": 0.047,
+            "MmePontmercy": 0.000,
+            "MlleVaubois": 0.000,
+            "LtGillenormand": 0.000,
+            "Marius": 0.133,
+            "BaronessT": 0.000,
+            "Mabeuf": 0.028,
+            "Enjolras": 0.041,
+            "Combeferre": 0.001,
+            "Prouvaire": 0.000,
+            "Feuilly": 0.001,
+            "Courfeyrac": 0.006,
+            "Bahorel": 0.002,
+            "Bossuet": 0.032,
+            "Joly": 0.002,
+            "Grantaire": 0.000,
+            "MotherPlutarch": 0.000,
+            "Gueulemer": 0.005,
+            "Babet": 0.005,
+            "Claquesous": 0.005,
+            "Montparnasse": 0.004,
+            "Toussaint": 0.000,
+            "Child1": 0.000,
+            "Child2": 0.000,
+            "Brujon": 0.000,
+            "MmeHucheloup": 0.000,
+        }
+        for n in sorted(G):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_unnormalized_k5_load(self):
+        G = self.K5
+        c = nx.load_centrality(G, normalized=False)
+        d = {0: 0.000, 1: 0.000, 2: 0.000, 3: 0.000, 4: 0.000}
+        for n in sorted(G):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_unnormalized_p3_load(self):
+        G = self.P3
+        c = nx.load_centrality(G, normalized=False)
+        d = {0: 0.000, 1: 2.000, 2: 0.000}
+        for n in sorted(G):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_unnormalized_krackhardt_load(self):
+        G = self.K
+        c = nx.load_centrality(G, normalized=False)
+        d = {
+            0: 1.667,
+            1: 1.667,
+            2: 0.000,
+            3: 7.333,
+            4: 0.000,
+            5: 16.667,
+            6: 16.667,
+            7: 28.000,
+            8: 16.000,
+            9: 0.000,
+        }
+
+        for n in sorted(G):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_unnormalized_florentine_families_load(self):
+        G = self.F
+        c = nx.load_centrality(G, normalized=False)
+
+        d = {
+            "Acciaiuoli": 0.000,
+            "Albizzi": 38.333,
+            "Barbadori": 17.000,
+            "Bischeri": 19.000,
+            "Castellani": 10.000,
+            "Ginori": 0.000,
+            "Guadagni": 45.667,
+            "Lamberteschi": 0.000,
+            "Medici": 95.000,
+            "Pazzi": 0.000,
+            "Peruzzi": 4.000,
+            "Ridolfi": 21.333,
+            "Salviati": 26.000,
+            "Strozzi": 19.333,
+            "Tornabuoni": 16.333,
+        }
+        for n in sorted(G):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_load_betweenness_difference(self):
+        # Difference Between Load and Betweenness
+        # --------------------------------------- The smallest graph
+        # that shows the difference between load and betweenness is
+        # G=ladder_graph(3) (Graph B below)
+
+        # Graph A and B are from Tao Zhou, Jian-Guo Liu, Bing-Hong
+        # Wang: Comment on "Scientific collaboration
+        # networks. II. Shortest paths, weighted networks, and
+        # centrality". https://arxiv.org/pdf/physics/0511084
+
+        # Notice that unlike here, their calculation adds to 1 to the
+        # betweennes of every node i for every path from i to every
+        # other node.  This is exactly what it should be, based on
+        # Eqn. (1) in their paper: the eqn is B(v) = \sum_{s\neq t,
+        # s\neq v}{\frac{\sigma_{st}(v)}{\sigma_{st}}}, therefore,
+        # they allow v to be the target node.
+
+        # We follow Brandes 2001, who follows Freeman 1977 that make
+        # the sum for betweenness of v exclude paths where v is either
+        # the source or target node.  To agree with their numbers, we
+        # must additionally, remove edge (4,8) from the graph, see AC
+        # example following (there is a mistake in the figure in their
+        # paper - personal communication).
+
+        # A = nx.Graph()
+        # A.add_edges_from([(0,1), (1,2), (1,3), (2,4),
+        #                  (3,5), (4,6), (4,7), (4,8),
+        #                  (5,8), (6,9), (7,9), (8,9)])
+        B = nx.Graph()  # ladder_graph(3)
+        B.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (4, 5), (3, 5)])
+        c = nx.load_centrality(B, normalized=False)
+        d = {0: 1.750, 1: 1.750, 2: 6.500, 3: 6.500, 4: 1.750, 5: 1.750}
+        for n in sorted(B):
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_c4_edge_load(self):
+        G = self.C4
+        c = nx.edge_load_centrality(G)
+        d = {(0, 1): 6.000, (0, 3): 6.000, (1, 2): 6.000, (2, 3): 6.000}
+        for n in G.edges():
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_p4_edge_load(self):
+        G = self.P4
+        c = nx.edge_load_centrality(G)
+        d = {(0, 1): 6.000, (1, 2): 8.000, (2, 3): 6.000}
+        for n in G.edges():
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_k5_edge_load(self):
+        G = self.K5
+        c = nx.edge_load_centrality(G)
+        d = {
+            (0, 1): 5.000,
+            (0, 2): 5.000,
+            (0, 3): 5.000,
+            (0, 4): 5.000,
+            (1, 2): 5.000,
+            (1, 3): 5.000,
+            (1, 4): 5.000,
+            (2, 3): 5.000,
+            (2, 4): 5.000,
+            (3, 4): 5.000,
+        }
+        for n in G.edges():
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
+
+    def test_tree_edge_load(self):
+        G = self.T
+        c = nx.edge_load_centrality(G)
+        d = {
+            (0, 1): 24.000,
+            (0, 2): 24.000,
+            (1, 3): 12.000,
+            (1, 4): 12.000,
+            (2, 5): 12.000,
+            (2, 6): 12.000,
+        }
+        for n in G.edges():
+            assert c[n] == pytest.approx(d[n], abs=1e-3)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_percolation_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_percolation_centrality.py
new file mode 100644
index 0000000..e675845
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_percolation_centrality.py
@@ -0,0 +1,82 @@
+import pytest
+
+import networkx as nx
+
+
+def example1a_G():
+    G = nx.Graph()
+    G.add_node(1, percolation=0.1)
+    G.add_node(2, percolation=0.2)
+    G.add_node(3, percolation=0.2)
+    G.add_node(4, percolation=0.2)
+    G.add_node(5, percolation=0.3)
+    G.add_node(6, percolation=0.2)
+    G.add_node(7, percolation=0.5)
+    G.add_node(8, percolation=0.5)
+    G.add_edges_from([(1, 4), (2, 4), (3, 4), (4, 5), (5, 6), (6, 7), (6, 8)])
+    return G
+
+
+def example1b_G():
+    G = nx.Graph()
+    G.add_node(1, percolation=0.3)
+    G.add_node(2, percolation=0.5)
+    G.add_node(3, percolation=0.5)
+    G.add_node(4, percolation=0.2)
+    G.add_node(5, percolation=0.3)
+    G.add_node(6, percolation=0.2)
+    G.add_node(7, percolation=0.1)
+    G.add_node(8, percolation=0.1)
+    G.add_edges_from([(1, 4), (2, 4), (3, 4), (4, 5), (5, 6), (6, 7), (6, 8)])
+    return G
+
+
+class TestPercolationCentrality:
+    def test_percolation_example1a(self):
+        """percolation centrality: example 1a"""
+        G = example1a_G()
+        p = nx.percolation_centrality(G)
+        p_answer = {4: 0.625, 6: 0.667}
+        for n, k in p_answer.items():
+            assert p[n] == pytest.approx(k, abs=1e-3)
+
+    def test_percolation_example1b(self):
+        """percolation centrality: example 1a"""
+        G = example1b_G()
+        p = nx.percolation_centrality(G)
+        p_answer = {4: 0.825, 6: 0.4}
+        for n, k in p_answer.items():
+            assert p[n] == pytest.approx(k, abs=1e-3)
+
+    def test_converge_to_betweenness(self):
+        """percolation centrality: should converge to betweenness
+        centrality when all nodes are percolated the same"""
+        # taken from betweenness test test_florentine_families_graph
+        G = nx.florentine_families_graph()
+        b_answer = {
+            "Acciaiuoli": 0.000,
+            "Albizzi": 0.212,
+            "Barbadori": 0.093,
+            "Bischeri": 0.104,
+            "Castellani": 0.055,
+            "Ginori": 0.000,
+            "Guadagni": 0.255,
+            "Lamberteschi": 0.000,
+            "Medici": 0.522,
+            "Pazzi": 0.000,
+            "Peruzzi": 0.022,
+            "Ridolfi": 0.114,
+            "Salviati": 0.143,
+            "Strozzi": 0.103,
+            "Tornabuoni": 0.092,
+        }
+
+        p_states = {k: 1.0 for k, v in b_answer.items()}
+        p_answer = nx.percolation_centrality(G, states=p_states)
+        for n in sorted(G):
+            assert p_answer[n] == pytest.approx(b_answer[n], abs=1e-3)
+
+        p_states = {k: 0.3 for k, v in b_answer.items()}
+        p_answer = nx.percolation_centrality(G, states=p_states)
+        for n in sorted(G):
+            assert p_answer[n] == pytest.approx(b_answer[n], abs=1e-3)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_reaching.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_reaching.py
new file mode 100644
index 0000000..86ae8a9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_reaching.py
@@ -0,0 +1,109 @@
+"""Unit tests for the :mod:`networkx.algorithms.centrality.reaching` module."""
+import pytest
+
+import networkx as nx
+
+
+class TestGlobalReachingCentrality:
+    """Unit tests for the global reaching centrality function."""
+
+    def test_non_positive_weights(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.DiGraph()
+            nx.global_reaching_centrality(G, weight="weight")
+
+    def test_negatively_weighted(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.Graph()
+            G.add_weighted_edges_from([(0, 1, -2), (1, 2, +1)])
+            nx.global_reaching_centrality(G, weight="weight")
+
+    def test_directed_star(self):
+        G = nx.DiGraph()
+        G.add_weighted_edges_from([(1, 2, 0.5), (1, 3, 0.5)])
+        grc = nx.global_reaching_centrality
+        assert grc(G, normalized=False, weight="weight") == 0.5
+        assert grc(G) == 1
+
+    def test_undirected_unweighted_star(self):
+        G = nx.star_graph(2)
+        grc = nx.global_reaching_centrality
+        assert grc(G, normalized=False, weight=None) == 0.25
+
+    def test_undirected_weighted_star(self):
+        G = nx.Graph()
+        G.add_weighted_edges_from([(1, 2, 1), (1, 3, 2)])
+        grc = nx.global_reaching_centrality
+        assert grc(G, normalized=False, weight="weight") == 0.375
+
+    def test_cycle_directed_unweighted(self):
+        G = nx.DiGraph()
+        G.add_edge(1, 2)
+        G.add_edge(2, 1)
+        assert nx.global_reaching_centrality(G, weight=None) == 0
+
+    def test_cycle_undirected_unweighted(self):
+        G = nx.Graph()
+        G.add_edge(1, 2)
+        assert nx.global_reaching_centrality(G, weight=None) == 0
+
+    def test_cycle_directed_weighted(self):
+        G = nx.DiGraph()
+        G.add_weighted_edges_from([(1, 2, 1), (2, 1, 1)])
+        assert nx.global_reaching_centrality(G) == 0
+
+    def test_cycle_undirected_weighted(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=1)
+        grc = nx.global_reaching_centrality
+        assert grc(G, normalized=False) == 0
+
+    def test_directed_weighted(self):
+        G = nx.DiGraph()
+        G.add_edge("A", "B", weight=5)
+        G.add_edge("B", "C", weight=1)
+        G.add_edge("B", "D", weight=0.25)
+        G.add_edge("D", "E", weight=1)
+
+        denom = len(G) - 1
+        A_local = sum([5, 3, 2.625, 2.0833333333333]) / denom
+        B_local = sum([1, 0.25, 0.625]) / denom
+        C_local = 0
+        D_local = sum([1]) / denom
+        E_local = 0
+
+        local_reach_ctrs = [A_local, C_local, B_local, D_local, E_local]
+        max_local = max(local_reach_ctrs)
+        expected = sum(max_local - lrc for lrc in local_reach_ctrs) / denom
+        grc = nx.global_reaching_centrality
+        actual = grc(G, normalized=False, weight="weight")
+        assert expected == pytest.approx(actual, abs=1e-7)
+
+
+class TestLocalReachingCentrality:
+    """Unit tests for the local reaching centrality function."""
+
+    def test_non_positive_weights(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.DiGraph()
+            G.add_weighted_edges_from([(0, 1, 0)])
+            nx.local_reaching_centrality(G, 0, weight="weight")
+
+    def test_negatively_weighted(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.Graph()
+            G.add_weighted_edges_from([(0, 1, -2), (1, 2, +1)])
+            nx.local_reaching_centrality(G, 0, weight="weight")
+
+    def test_undirected_unweighted_star(self):
+        G = nx.star_graph(2)
+        grc = nx.local_reaching_centrality
+        assert grc(G, 1, weight=None, normalized=False) == 0.75
+
+    def test_undirected_weighted_star(self):
+        G = nx.Graph()
+        G.add_weighted_edges_from([(1, 2, 1), (1, 3, 2)])
+        centrality = nx.local_reaching_centrality(
+            G, 1, normalized=False, weight="weight"
+        )
+        assert centrality == 1.5
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_second_order_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_second_order_centrality.py
new file mode 100644
index 0000000..903bbe9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_second_order_centrality.py
@@ -0,0 +1,67 @@
+"""
+Tests for second order centrality.
+"""
+
+import pytest
+
+pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+
+
+class TestSecondOrderCentrality:
+    def test_empty(self):
+        with pytest.raises(nx.NetworkXException):
+            G = nx.empty_graph()
+            nx.second_order_centrality(G)
+
+    def test_non_connected(self):
+        with pytest.raises(nx.NetworkXException):
+            G = nx.Graph()
+            G.add_node(0)
+            G.add_node(1)
+            nx.second_order_centrality(G)
+
+    def test_non_negative_edge_weights(self):
+        with pytest.raises(nx.NetworkXException):
+            G = nx.path_graph(2)
+            G.add_edge(0, 1, weight=-1)
+            nx.second_order_centrality(G)
+
+    def test_one_node_graph(self):
+        """Second order centrality: single node"""
+        G = nx.Graph()
+        G.add_node(0)
+        G.add_edge(0, 0)
+        assert nx.second_order_centrality(G)[0] == 0
+
+    def test_P3(self):
+        """Second order centrality: line graph, as defined in paper"""
+        G = nx.path_graph(3)
+        b_answer = {0: 3.741, 1: 1.414, 2: 3.741}
+
+        b = nx.second_order_centrality(G)
+
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-2)
+
+    def test_K3(self):
+        """Second order centrality: complete graph, as defined in paper"""
+        G = nx.complete_graph(3)
+        b_answer = {0: 1.414, 1: 1.414, 2: 1.414}
+
+        b = nx.second_order_centrality(G)
+
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-2)
+
+    def test_ring_graph(self):
+        """Second order centrality: ring graph, as defined in paper"""
+        G = nx.cycle_graph(5)
+        b_answer = {0: 4.472, 1: 4.472, 2: 4.472, 3: 4.472, 4: 4.472}
+
+        b = nx.second_order_centrality(G)
+
+        for n in sorted(G):
+            assert b[n] == pytest.approx(b_answer[n], abs=1e-2)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_subgraph.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_subgraph.py
new file mode 100644
index 0000000..7109275
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_subgraph.py
@@ -0,0 +1,110 @@
+import pytest
+
+pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+from networkx.algorithms.centrality.subgraph_alg import (
+    communicability_betweenness_centrality,
+    estrada_index,
+    subgraph_centrality,
+    subgraph_centrality_exp,
+)
+
+
+class TestSubgraph:
+    def test_subgraph_centrality(self):
+        answer = {0: 1.5430806348152433, 1: 1.5430806348152433}
+        result = subgraph_centrality(nx.path_graph(2))
+        for k, v in result.items():
+            assert answer[k] == pytest.approx(v, abs=1e-7)
+
+        answer1 = {
+            "1": 1.6445956054135658,
+            "Albert": 2.4368257358712189,
+            "Aric": 2.4368257358712193,
+            "Dan": 3.1306328496328168,
+            "Franck": 2.3876142275231915,
+        }
+        G1 = nx.Graph(
+            [
+                ("Franck", "Aric"),
+                ("Aric", "Dan"),
+                ("Dan", "Albert"),
+                ("Albert", "Franck"),
+                ("Dan", "1"),
+                ("Franck", "Albert"),
+            ]
+        )
+        result1 = subgraph_centrality(G1)
+        for k, v in result1.items():
+            assert answer1[k] == pytest.approx(v, abs=1e-7)
+        result1 = subgraph_centrality_exp(G1)
+        for k, v in result1.items():
+            assert answer1[k] == pytest.approx(v, abs=1e-7)
+
+    def test_subgraph_centrality_big_graph(self):
+        g199 = nx.complete_graph(199)
+        g200 = nx.complete_graph(200)
+
+        comm199 = nx.subgraph_centrality(g199)
+        comm199_exp = nx.subgraph_centrality_exp(g199)
+
+        comm200 = nx.subgraph_centrality(g200)
+        comm200_exp = nx.subgraph_centrality_exp(g200)
+
+    def test_communicability_betweenness_centrality_small(self):
+        result = communicability_betweenness_centrality(nx.path_graph(2))
+        assert result == {0: 0, 1: 0}
+
+        result = communicability_betweenness_centrality(nx.path_graph(1))
+        assert result == {0: 0}
+
+        result = communicability_betweenness_centrality(nx.path_graph(0))
+        assert result == {}
+
+        answer = {0: 0.1411224421177313, 1: 1.0, 2: 0.1411224421177313}
+        result = communicability_betweenness_centrality(nx.path_graph(3))
+        for k, v in result.items():
+            assert answer[k] == pytest.approx(v, abs=1e-7)
+
+        result = communicability_betweenness_centrality(nx.complete_graph(3))
+        for k, v in result.items():
+            assert 0.49786143366223296 == pytest.approx(v, abs=1e-7)
+
+    def test_communicability_betweenness_centrality(self):
+        answer = {
+            0: 0.07017447951484615,
+            1: 0.71565598701107991,
+            2: 0.71565598701107991,
+            3: 0.07017447951484615,
+        }
+        result = communicability_betweenness_centrality(nx.path_graph(4))
+        for k, v in result.items():
+            assert answer[k] == pytest.approx(v, abs=1e-7)
+
+        answer1 = {
+            "1": 0.060039074193949521,
+            "Albert": 0.315470761661372,
+            "Aric": 0.31547076166137211,
+            "Dan": 0.68297778678316201,
+            "Franck": 0.21977926617449497,
+        }
+        G1 = nx.Graph(
+            [
+                ("Franck", "Aric"),
+                ("Aric", "Dan"),
+                ("Dan", "Albert"),
+                ("Albert", "Franck"),
+                ("Dan", "1"),
+                ("Franck", "Albert"),
+            ]
+        )
+        result1 = communicability_betweenness_centrality(G1)
+        for k, v in result1.items():
+            assert answer1[k] == pytest.approx(v, abs=1e-7)
+
+    def test_estrada_index(self):
+        answer = 1041.2470334195475
+        result = estrada_index(nx.karate_club_graph())
+        assert answer == pytest.approx(result, abs=1e-7)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_trophic.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_trophic.py
new file mode 100644
index 0000000..f1d6813
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_trophic.py
@@ -0,0 +1,302 @@
+"""Test trophic levels, trophic differences and trophic coherence
+"""
+import pytest
+
+np = pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+
+
+def test_trophic_levels():
+    """Trivial example"""
+    G = nx.DiGraph()
+    G.add_edge("a", "b")
+    G.add_edge("b", "c")
+
+    d = nx.trophic_levels(G)
+    assert d == {"a": 1, "b": 2, "c": 3}
+
+
+def test_trophic_levels_levine():
+    """Example from Figure 5 in Stephen Levine (1980) J. theor. Biol. 83,
+    195-207
+    """
+    S = nx.DiGraph()
+    S.add_edge(1, 2, weight=1.0)
+    S.add_edge(1, 3, weight=0.2)
+    S.add_edge(1, 4, weight=0.8)
+    S.add_edge(2, 3, weight=0.2)
+    S.add_edge(2, 5, weight=0.3)
+    S.add_edge(4, 3, weight=0.6)
+    S.add_edge(4, 5, weight=0.7)
+    S.add_edge(5, 4, weight=0.2)
+
+    # save copy for later, test intermediate implementation details first
+    S2 = S.copy()
+
+    # drop nodes of in-degree zero
+    z = [nid for nid, d in S.in_degree if d == 0]
+    for nid in z:
+        S.remove_node(nid)
+
+    # find adjacency matrix
+    q = nx.linalg.graphmatrix.adjacency_matrix(S).T
+
+    # fmt: off
+    expected_q = np.array([
+        [0, 0, 0., 0],
+        [0.2, 0, 0.6, 0],
+        [0, 0, 0, 0.2],
+        [0.3, 0, 0.7, 0]
+    ])
+    # fmt: on
+    assert np.array_equal(q.todense(), expected_q)
+
+    # must be square, size of number of nodes
+    assert len(q.shape) == 2
+    assert q.shape[0] == q.shape[1]
+    assert q.shape[0] == len(S)
+
+    nn = q.shape[0]
+
+    i = np.eye(nn)
+    n = np.linalg.inv(i - q)
+    y = np.asarray(n) @ np.ones(nn)
+
+    expected_y = np.array([1, 2.07906977, 1.46511628, 2.3255814])
+    assert np.allclose(y, expected_y)
+
+    expected_d = {1: 1, 2: 2, 3: 3.07906977, 4: 2.46511628, 5: 3.3255814}
+
+    d = nx.trophic_levels(S2)
+
+    for nid, level in d.items():
+        expected_level = expected_d[nid]
+        assert expected_level == pytest.approx(level, abs=1e-7)
+
+
+def test_trophic_levels_simple():
+    matrix_a = np.array([[0, 0], [1, 0]])
+    G = nx.from_numpy_array(matrix_a, create_using=nx.DiGraph)
+    d = nx.trophic_levels(G)
+    assert d[0] == pytest.approx(2, abs=1e-7)
+    assert d[1] == pytest.approx(1, abs=1e-7)
+
+
+def test_trophic_levels_more_complex():
+    # fmt: off
+    matrix = np.array([
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+        [0, 0, 0, 1],
+        [0, 0, 0, 0]
+    ])
+    # fmt: on
+    G = nx.from_numpy_array(matrix, create_using=nx.DiGraph)
+    d = nx.trophic_levels(G)
+    expected_result = [1, 2, 3, 4]
+    for ind in range(4):
+        assert d[ind] == pytest.approx(expected_result[ind], abs=1e-7)
+
+    # fmt: off
+    matrix = np.array([
+        [0, 1, 1, 0],
+        [0, 0, 1, 1],
+        [0, 0, 0, 1],
+        [0, 0, 0, 0]
+    ])
+    # fmt: on
+    G = nx.from_numpy_array(matrix, create_using=nx.DiGraph)
+    d = nx.trophic_levels(G)
+
+    expected_result = [1, 2, 2.5, 3.25]
+    print("Calculated result: ", d)
+    print("Expected Result: ", expected_result)
+
+    for ind in range(4):
+        assert d[ind] == pytest.approx(expected_result[ind], abs=1e-7)
+
+
+def test_trophic_levels_even_more_complex():
+    # fmt: off
+    # Another, bigger matrix
+    matrix = np.array([
+        [0, 0, 0, 0, 0],
+        [0, 1, 0, 1, 0],
+        [1, 0, 0, 0, 0],
+        [0, 1, 0, 0, 0],
+        [0, 0, 0, 1, 0]
+    ])
+    # Generated this linear system using pen and paper:
+    K = np.array([
+        [1, 0, -1, 0, 0],
+        [0, 0.5, 0, -0.5, 0],
+        [0, 0, 1, 0, 0],
+        [0, -0.5, 0, 1, -0.5],
+        [0, 0, 0, 0, 1],
+    ])
+    # fmt: on
+    result_1 = np.ravel(np.linalg.inv(K) @ np.ones(5))
+    G = nx.from_numpy_array(matrix, create_using=nx.DiGraph)
+    result_2 = nx.trophic_levels(G)
+
+    for ind in range(5):
+        assert result_1[ind] == pytest.approx(result_2[ind], abs=1e-7)
+
+
+def test_trophic_levels_singular_matrix():
+    """Should raise an error with graphs with only non-basal nodes"""
+    matrix = np.identity(4)
+    G = nx.from_numpy_array(matrix, create_using=nx.DiGraph)
+    with pytest.raises(nx.NetworkXError) as e:
+        nx.trophic_levels(G)
+    msg = (
+        "Trophic levels are only defined for graphs where every node "
+        + "has a path from a basal node (basal nodes are nodes with no "
+        + "incoming edges)."
+    )
+    assert msg in str(e.value)
+
+
+def test_trophic_levels_singular_with_basal():
+    """Should fail to compute if there are any parts of the graph which are not
+    reachable from any basal node (with in-degree zero).
+    """
+    G = nx.DiGraph()
+    # a has in-degree zero
+    G.add_edge("a", "b")
+
+    # b is one level above a, c and d
+    G.add_edge("c", "b")
+    G.add_edge("d", "b")
+
+    # c and d form a loop, neither are reachable from a
+    G.add_edge("c", "d")
+    G.add_edge("d", "c")
+
+    with pytest.raises(nx.NetworkXError) as e:
+        nx.trophic_levels(G)
+    msg = (
+        "Trophic levels are only defined for graphs where every node "
+        + "has a path from a basal node (basal nodes are nodes with no "
+        + "incoming edges)."
+    )
+    assert msg in str(e.value)
+
+    # if self-loops are allowed, smaller example:
+    G = nx.DiGraph()
+    G.add_edge("a", "b")  # a has in-degree zero
+    G.add_edge("c", "b")  # b is one level above a and c
+    G.add_edge("c", "c")  # c has a self-loop
+    with pytest.raises(nx.NetworkXError) as e:
+        nx.trophic_levels(G)
+    msg = (
+        "Trophic levels are only defined for graphs where every node "
+        + "has a path from a basal node (basal nodes are nodes with no "
+        + "incoming edges)."
+    )
+    assert msg in str(e.value)
+
+
+def test_trophic_differences():
+    matrix_a = np.array([[0, 1], [0, 0]])
+    G = nx.from_numpy_array(matrix_a, create_using=nx.DiGraph)
+    diffs = nx.trophic_differences(G)
+    assert diffs[(0, 1)] == pytest.approx(1, abs=1e-7)
+
+    # fmt: off
+    matrix_b = np.array([
+        [0, 1, 1, 0],
+        [0, 0, 1, 1],
+        [0, 0, 0, 1],
+        [0, 0, 0, 0]
+    ])
+    # fmt: on
+    G = nx.from_numpy_array(matrix_b, create_using=nx.DiGraph)
+    diffs = nx.trophic_differences(G)
+
+    assert diffs[(0, 1)] == pytest.approx(1, abs=1e-7)
+    assert diffs[(0, 2)] == pytest.approx(1.5, abs=1e-7)
+    assert diffs[(1, 2)] == pytest.approx(0.5, abs=1e-7)
+    assert diffs[(1, 3)] == pytest.approx(1.25, abs=1e-7)
+    assert diffs[(2, 3)] == pytest.approx(0.75, abs=1e-7)
+
+
+def test_trophic_incoherence_parameter_no_cannibalism():
+    matrix_a = np.array([[0, 1], [0, 0]])
+    G = nx.from_numpy_array(matrix_a, create_using=nx.DiGraph)
+    q = nx.trophic_incoherence_parameter(G, cannibalism=False)
+    assert q == pytest.approx(0, abs=1e-7)
+
+    # fmt: off
+    matrix_b = np.array([
+        [0, 1, 1, 0],
+        [0, 0, 1, 1],
+        [0, 0, 0, 1],
+        [0, 0, 0, 0]
+    ])
+    # fmt: on
+    G = nx.from_numpy_array(matrix_b, create_using=nx.DiGraph)
+    q = nx.trophic_incoherence_parameter(G, cannibalism=False)
+    assert q == pytest.approx(np.std([1, 1.5, 0.5, 0.75, 1.25]), abs=1e-7)
+
+    # fmt: off
+    matrix_c = np.array([
+        [0, 1, 1, 0],
+        [0, 1, 1, 1],
+        [0, 0, 0, 1],
+        [0, 0, 0, 1]
+    ])
+    # fmt: on
+    G = nx.from_numpy_array(matrix_c, create_using=nx.DiGraph)
+    q = nx.trophic_incoherence_parameter(G, cannibalism=False)
+    # Ignore the -link
+    assert q == pytest.approx(np.std([1, 1.5, 0.5, 0.75, 1.25]), abs=1e-7)
+
+    # no self-loops case
+    # fmt: off
+    matrix_d = np.array([
+        [0, 1, 1, 0],
+        [0, 0, 1, 1],
+        [0, 0, 0, 1],
+        [0, 0, 0, 0]
+    ])
+    # fmt: on
+    G = nx.from_numpy_array(matrix_d, create_using=nx.DiGraph)
+    q = nx.trophic_incoherence_parameter(G, cannibalism=False)
+    # Ignore the -link
+    assert q == pytest.approx(np.std([1, 1.5, 0.5, 0.75, 1.25]), abs=1e-7)
+
+
+def test_trophic_incoherence_parameter_cannibalism():
+    matrix_a = np.array([[0, 1], [0, 0]])
+    G = nx.from_numpy_array(matrix_a, create_using=nx.DiGraph)
+    q = nx.trophic_incoherence_parameter(G, cannibalism=True)
+    assert q == pytest.approx(0, abs=1e-7)
+
+    # fmt: off
+    matrix_b = np.array([
+        [0, 0, 0, 0, 0],
+        [0, 1, 0, 1, 0],
+        [1, 0, 0, 0, 0],
+        [0, 1, 0, 0, 0],
+        [0, 0, 0, 1, 0]
+    ])
+    # fmt: on
+    G = nx.from_numpy_array(matrix_b, create_using=nx.DiGraph)
+    q = nx.trophic_incoherence_parameter(G, cannibalism=True)
+    assert q == pytest.approx(2, abs=1e-7)
+
+    # fmt: off
+    matrix_c = np.array([
+        [0, 1, 1, 0],
+        [0, 0, 1, 1],
+        [0, 0, 0, 1],
+        [0, 0, 0, 0]
+    ])
+    # fmt: on
+    G = nx.from_numpy_array(matrix_c, create_using=nx.DiGraph)
+    q = nx.trophic_incoherence_parameter(G, cannibalism=True)
+    # Ignore the -link
+    assert q == pytest.approx(np.std([1, 1.5, 0.5, 0.75, 1.25]), abs=1e-7)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_voterank.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_voterank.py
new file mode 100644
index 0000000..aa653ae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/tests/test_voterank.py
@@ -0,0 +1,61 @@
+"""
+    Unit tests for VoteRank.
+"""
+
+
+import networkx as nx
+
+
+class TestVoteRankCentrality:
+    # Example Graph present in reference paper
+    def test_voterank_centrality_1(self):
+        G = nx.Graph()
+        G.add_edges_from(
+            [
+                (7, 8),
+                (7, 5),
+                (7, 9),
+                (5, 0),
+                (0, 1),
+                (0, 2),
+                (0, 3),
+                (0, 4),
+                (1, 6),
+                (2, 6),
+                (3, 6),
+                (4, 6),
+            ]
+        )
+        assert [0, 7, 6] == nx.voterank(G)
+
+    # Graph unit test
+    def test_voterank_centrality_2(self):
+        G = nx.florentine_families_graph()
+        d = nx.voterank(G, 4)
+        exact = ["Medici", "Strozzi", "Guadagni", "Castellani"]
+        assert exact == d
+
+    # DiGraph unit test
+    def test_voterank_centrality_3(self):
+        G = nx.gnc_graph(10, seed=7)
+        d = nx.voterank(G, 4)
+        exact = [3, 6, 8]
+        assert exact == d
+
+    # MultiGraph unit test
+    def test_voterank_centrality_4(self):
+        G = nx.MultiGraph()
+        G.add_edges_from(
+            [(0, 1), (0, 1), (1, 2), (2, 5), (2, 5), (5, 6), (5, 6), (2, 4), (4, 3)]
+        )
+        exact = [2, 1, 5, 4]
+        assert exact == nx.voterank(G)
+
+    # MultiDiGraph unit test
+    def test_voterank_centrality_5(self):
+        G = nx.MultiDiGraph()
+        G.add_edges_from(
+            [(0, 1), (0, 1), (1, 2), (2, 5), (2, 5), (5, 6), (5, 6), (2, 4), (4, 3)]
+        )
+        exact = [2, 0, 5, 4]
+        assert exact == nx.voterank(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/trophic.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/trophic.py
new file mode 100644
index 0000000..b7b1073
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/trophic.py
@@ -0,0 +1,159 @@
+"""Trophic levels"""
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["trophic_levels", "trophic_differences", "trophic_incoherence_parameter"]
+
+
+@not_implemented_for("undirected")
+def trophic_levels(G, weight="weight"):
+    r"""Compute the trophic levels of nodes.
+
+    The trophic level of a node $i$ is
+
+    .. math::
+
+        s_i = 1 + \frac{1}{k^{in}_i} \sum_{j} a_{ij} s_j
+
+    where $k^{in}_i$ is the in-degree of i
+
+    .. math::
+
+        k^{in}_i = \sum_{j} a_{ij}
+
+    and nodes with $k^{in}_i = 0$ have $s_i = 1$ by convention.
+
+    These are calculated using the method outlined in Levine [1]_.
+
+    Parameters
+    ----------
+    G : DiGraph
+        A directed networkx graph
+
+    Returns
+    -------
+    nodes : dict
+        Dictionary of nodes with trophic level as the value.
+
+    References
+    ----------
+    .. [1] Stephen Levine (1980) J. theor. Biol. 83, 195-207
+    """
+    import numpy as np
+
+    # find adjacency matrix
+    a = nx.adjacency_matrix(G, weight=weight).T.toarray()
+
+    # drop rows/columns where in-degree is zero
+    rowsum = np.sum(a, axis=1)
+    p = a[rowsum != 0][:, rowsum != 0]
+    # normalise so sum of in-degree weights is 1 along each row
+    p = p / rowsum[rowsum != 0][:, np.newaxis]
+
+    # calculate trophic levels
+    nn = p.shape[0]
+    i = np.eye(nn)
+    try:
+        n = np.linalg.inv(i - p)
+    except np.linalg.LinAlgError as err:
+        # LinAlgError is raised when there is a non-basal node
+        msg = (
+            "Trophic levels are only defined for graphs where every "
+            + "node has a path from a basal node (basal nodes are nodes "
+            + "with no incoming edges)."
+        )
+        raise nx.NetworkXError(msg) from err
+    y = n.sum(axis=1) + 1
+
+    levels = {}
+
+    # all nodes with in-degree zero have trophic level == 1
+    zero_node_ids = (node_id for node_id, degree in G.in_degree if degree == 0)
+    for node_id in zero_node_ids:
+        levels[node_id] = 1
+
+    # all other nodes have levels as calculated
+    nonzero_node_ids = (node_id for node_id, degree in G.in_degree if degree != 0)
+    for i, node_id in enumerate(nonzero_node_ids):
+        levels[node_id] = y[i]
+
+    return levels
+
+
+@not_implemented_for("undirected")
+def trophic_differences(G, weight="weight"):
+    r"""Compute the trophic differences of the edges of a directed graph.
+
+    The trophic difference $x_ij$ for each edge is defined in Johnson et al.
+    [1]_ as:
+
+    .. math::
+        x_ij = s_j - s_i
+
+    Where $s_i$ is the trophic level of node $i$.
+
+    Parameters
+    ----------
+    G : DiGraph
+        A directed networkx graph
+
+    Returns
+    -------
+    diffs : dict
+        Dictionary of edges with trophic differences as the value.
+
+    References
+    ----------
+    .. [1] Samuel Johnson, Virginia Dominguez-Garcia, Luca Donetti, Miguel A.
+        Munoz (2014) PNAS "Trophic coherence determines food-web stability"
+    """
+    levels = trophic_levels(G, weight=weight)
+    diffs = {}
+    for u, v in G.edges:
+        diffs[(u, v)] = levels[v] - levels[u]
+    return diffs
+
+
+@not_implemented_for("undirected")
+def trophic_incoherence_parameter(G, weight="weight", cannibalism=False):
+    r"""Compute the trophic incoherence parameter of a graph.
+
+    Trophic coherence is defined as the homogeneity of the distribution of
+    trophic distances: the more similar, the more coherent. This is measured by
+    the standard deviation of the trophic differences and referred to as the
+    trophic incoherence parameter $q$ by [1].
+
+    Parameters
+    ----------
+    G : DiGraph
+        A directed networkx graph
+
+    cannibalism: Boolean
+        If set to False, self edges are not considered in the calculation
+
+    Returns
+    -------
+    trophic_incoherence_parameter : float
+        The trophic coherence of a graph
+
+    References
+    ----------
+    .. [1] Samuel Johnson, Virginia Dominguez-Garcia, Luca Donetti, Miguel A.
+        Munoz (2014) PNAS "Trophic coherence determines food-web stability"
+    """
+    import numpy as np
+
+    if cannibalism:
+        diffs = trophic_differences(G, weight=weight)
+    else:
+        # If no cannibalism, remove self-edges
+        self_loops = list(nx.selfloop_edges(G))
+        if self_loops:
+            # Make a copy so we do not change G's edges in memory
+            G_2 = G.copy()
+            G_2.remove_edges_from(self_loops)
+        else:
+            # Avoid copy otherwise
+            G_2 = G
+        diffs = trophic_differences(G_2, weight=weight)
+    return np.std(list(diffs.values()))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/voterank_alg.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/voterank_alg.py
new file mode 100644
index 0000000..c28df58
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/centrality/voterank_alg.py
@@ -0,0 +1,92 @@
+"""Algorithm to select influential nodes in a graph using VoteRank."""
+
+__all__ = ["voterank"]
+
+
+def voterank(G, number_of_nodes=None):
+    """Select a list of influential nodes in a graph using VoteRank algorithm
+
+    VoteRank [1]_ computes a ranking of the nodes in a graph G based on a
+    voting scheme. With VoteRank, all nodes vote for each of its in-neighbours
+    and the node with the highest votes is elected iteratively. The voting
+    ability of out-neighbors of elected nodes is decreased in subsequent turns.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph.
+
+    number_of_nodes : integer, optional
+        Number of ranked nodes to extract (default all nodes).
+
+    Returns
+    -------
+    voterank : list
+        Ordered list of computed seeds.
+        Only nodes with positive number of votes are returned.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2), (0, 3), (1, 4)])
+    >>> nx.voterank(G)
+    [0, 1]
+
+    The algorithm can be used both for undirected and directed graphs.
+    However, the directed version is different in two ways:
+    (i) nodes only vote for their in-neighbors and
+    (ii) only the voting ability of elected node and its out-neighbors are updated:
+
+    >>> G = nx.DiGraph([(0, 1), (2, 1), (2, 3), (3, 4)])
+    >>> nx.voterank(G)
+    [2, 3]
+
+    Notes
+    -----
+    Each edge is treated independently in case of multigraphs.
+
+    References
+    ----------
+    .. [1] Zhang, J.-X. et al. (2016).
+        Identifying a set of influential spreaders in complex networks.
+        Sci. Rep. 6, 27823; doi: 10.1038/srep27823.
+    """
+    influential_nodes = []
+    vote_rank = {}
+    if len(G) == 0:
+        return influential_nodes
+    if number_of_nodes is None or number_of_nodes > len(G):
+        number_of_nodes = len(G)
+    if G.is_directed():
+        # For directed graphs compute average out-degree
+        avgDegree = sum(deg for _, deg in G.out_degree()) / len(G)
+    else:
+        # For undirected graphs compute average degree
+        avgDegree = sum(deg for _, deg in G.degree()) / len(G)
+    # step 1 - initiate all nodes to (0,1) (score, voting ability)
+    for n in G.nodes():
+        vote_rank[n] = [0, 1]
+    # Repeat steps 1b to 4 until num_seeds are elected.
+    for _ in range(number_of_nodes):
+        # step 1b - reset rank
+        for n in G.nodes():
+            vote_rank[n][0] = 0
+        # step 2 - vote
+        for n, nbr in G.edges():
+            # In directed graphs nodes only vote for their in-neighbors
+            vote_rank[n][0] += vote_rank[nbr][1]
+            if not G.is_directed():
+                vote_rank[nbr][0] += vote_rank[n][1]
+        for n in influential_nodes:
+            vote_rank[n][0] = 0
+        # step 3 - select top node
+        n = max(G.nodes, key=lambda x: vote_rank[x][0])
+        if vote_rank[n][0] == 0:
+            return influential_nodes
+        influential_nodes.append(n)
+        # weaken the selected node
+        vote_rank[n] = [0, 0]
+        # step 4 - update voterank properties
+        for _, nbr in G.edges(n):
+            vote_rank[nbr][1] -= 1 / avgDegree
+            vote_rank[nbr][1] = max(vote_rank[nbr][1], 0)
+    return influential_nodes
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/chains.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/chains.py
new file mode 100644
index 0000000..2018c88
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/chains.py
@@ -0,0 +1,167 @@
+"""Functions for finding chains in a graph."""
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["chain_decomposition"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def chain_decomposition(G, root=None):
+    """Returns the chain decomposition of a graph.
+
+    The *chain decomposition* of a graph with respect a depth-first
+    search tree is a set of cycles or paths derived from the set of
+    fundamental cycles of the tree in the following manner. Consider
+    each fundamental cycle with respect to the given tree, represented
+    as a list of edges beginning with the nontree edge oriented away
+    from the root of the tree. For each fundamental cycle, if it
+    overlaps with any previous fundamental cycle, just take the initial
+    non-overlapping segment, which is a path instead of a cycle. Each
+    cycle or path is called a *chain*. For more information, see [1]_.
+
+    Parameters
+    ----------
+    G : undirected graph
+
+    root : node (optional)
+       A node in the graph `G`. If specified, only the chain
+       decomposition for the connected component containing this node
+       will be returned. This node indicates the root of the depth-first
+       search tree.
+
+    Yields
+    ------
+    chain : list
+       A list of edges representing a chain. There is no guarantee on
+       the orientation of the edges in each chain (for example, if a
+       chain includes the edge joining nodes 1 and 2, the chain may
+       include either (1, 2) or (2, 1)).
+
+    Raises
+    ------
+    NodeNotFound
+       If `root` is not in the graph `G`.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (1, 4), (3, 4), (3, 5), (4, 5)])
+    >>> list(nx.chain_decomposition(G))
+    [[(4, 5), (5, 3), (3, 4)]]
+
+    Notes
+    -----
+    The worst-case running time of this implementation is linear in the
+    number of nodes and number of edges [1]_.
+
+    References
+    ----------
+    .. [1] Jens M. Schmidt (2013). "A simple test on 2-vertex-
+       and 2-edge-connectivity." *Information Processing Letters*,
+       113, 241–244. Elsevier. <https://doi.org/10.1016/j.ipl.2013.01.016>
+
+    """
+
+    def _dfs_cycle_forest(G, root=None):
+        """Builds a directed graph composed of cycles from the given graph.
+
+        `G` is an undirected simple graph. `root` is a node in the graph
+        from which the depth-first search is started.
+
+        This function returns both the depth-first search cycle graph
+        (as a :class:`~networkx.DiGraph`) and the list of nodes in
+        depth-first preorder. The depth-first search cycle graph is a
+        directed graph whose edges are the edges of `G` oriented toward
+        the root if the edge is a tree edge and away from the root if
+        the edge is a non-tree edge. If `root` is not specified, this
+        performs a depth-first search on each connected component of `G`
+        and returns a directed forest instead.
+
+        If `root` is not in the graph, this raises :exc:`KeyError`.
+
+        """
+        # Create a directed graph from the depth-first search tree with
+        # root node `root` in which tree edges are directed toward the
+        # root and nontree edges are directed away from the root. For
+        # each node with an incident nontree edge, this creates a
+        # directed cycle starting with the nontree edge and returning to
+        # that node.
+        #
+        # The `parent` node attribute stores the parent of each node in
+        # the DFS tree. The `nontree` edge attribute indicates whether
+        # the edge is a tree edge or a nontree edge.
+        #
+        # We also store the order of the nodes found in the depth-first
+        # search in the `nodes` list.
+        H = nx.DiGraph()
+        nodes = []
+        for u, v, d in nx.dfs_labeled_edges(G, source=root):
+            if d == "forward":
+                # `dfs_labeled_edges()` yields (root, root, 'forward')
+                # if it is beginning the search on a new connected
+                # component.
+                if u == v:
+                    H.add_node(v, parent=None)
+                    nodes.append(v)
+                else:
+                    H.add_node(v, parent=u)
+                    H.add_edge(v, u, nontree=False)
+                    nodes.append(v)
+            # `dfs_labeled_edges` considers nontree edges in both
+            # orientations, so we need to not add the edge if it its
+            # other orientation has been added.
+            elif d == "nontree" and v not in H[u]:
+                H.add_edge(v, u, nontree=True)
+            else:
+                # Do nothing on 'reverse' edges; we only care about
+                # forward and nontree edges.
+                pass
+        return H, nodes
+
+    def _build_chain(G, u, v, visited):
+        """Generate the chain starting from the given nontree edge.
+
+        `G` is a DFS cycle graph as constructed by
+        :func:`_dfs_cycle_graph`. The edge (`u`, `v`) is a nontree edge
+        that begins a chain. `visited` is a set representing the nodes
+        in `G` that have already been visited.
+
+        This function yields the edges in an initial segment of the
+        fundamental cycle of `G` starting with the nontree edge (`u`,
+        `v`) that includes all the edges up until the first node that
+        appears in `visited`. The tree edges are given by the 'parent'
+        node attribute. The `visited` set is updated to add each node in
+        an edge yielded by this function.
+
+        """
+        while v not in visited:
+            yield u, v
+            visited.add(v)
+            u, v = v, G.nodes[v]["parent"]
+        yield u, v
+
+    # Create a directed version of H that has the DFS edges directed
+    # toward the root and the nontree edges directed away from the root
+    # (in each connected component).
+    H, nodes = _dfs_cycle_forest(G, root)
+
+    # Visit the nodes again in DFS order. For each node, and for each
+    # nontree edge leaving that node, compute the fundamental cycle for
+    # that nontree edge starting with that edge. If the fundamental
+    # cycle overlaps with any visited nodes, just take the prefix of the
+    # cycle up to the point of visited nodes.
+    #
+    # We repeat this process for each connected component (implicitly,
+    # since `nodes` already has a list of the nodes grouped by connected
+    # component).
+    visited = set()
+    for u in nodes:
+        visited.add(u)
+        # For each nontree edge going out of node u...
+        edges = ((u, v) for u, v, d in H.out_edges(u, data="nontree") if d)
+        for u, v in edges:
+            # Create the cycle or cycle prefix starting with the
+            # nontree edge.
+            chain = list(_build_chain(H, u, v, visited))
+            yield chain
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/chordal.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/chordal.py
new file mode 100644
index 0000000..ad17ef7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/chordal.py
@@ -0,0 +1,476 @@
+"""
+Algorithms for chordal graphs.
+
+A graph is chordal if every cycle of length at least 4 has a chord
+(an edge joining two nodes not adjacent in the cycle).
+https://en.wikipedia.org/wiki/Chordal_graph
+"""
+import sys
+import warnings
+
+import networkx as nx
+from networkx.algorithms.components import connected_components
+from networkx.utils import arbitrary_element, not_implemented_for
+
+__all__ = [
+    "is_chordal",
+    "find_induced_nodes",
+    "chordal_graph_cliques",
+    "chordal_graph_treewidth",
+    "NetworkXTreewidthBoundExceeded",
+    "complete_to_chordal_graph",
+]
+
+
+class NetworkXTreewidthBoundExceeded(nx.NetworkXException):
+    """Exception raised when a treewidth bound has been provided and it has
+    been exceeded"""
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def is_chordal(G):
+    """Checks whether G is a chordal graph.
+
+    A graph is chordal if every cycle of length at least 4 has a chord
+    (an edge joining two nodes not adjacent in the cycle).
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.
+
+    Returns
+    -------
+    chordal : bool
+      True if G is a chordal graph and False otherwise.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
+
+    Examples
+    --------
+    >>> e = [
+    ...     (1, 2),
+    ...     (1, 3),
+    ...     (2, 3),
+    ...     (2, 4),
+    ...     (3, 4),
+    ...     (3, 5),
+    ...     (3, 6),
+    ...     (4, 5),
+    ...     (4, 6),
+    ...     (5, 6),
+    ... ]
+    >>> G = nx.Graph(e)
+    >>> nx.is_chordal(G)
+    True
+
+    Notes
+    -----
+    The routine tries to go through every node following maximum cardinality
+    search. It returns False when it finds that the separator for any node
+    is not a clique.  Based on the algorithms in [1]_.
+
+    References
+    ----------
+    .. [1] R. E. Tarjan and M. Yannakakis, Simple linear-time algorithms
+       to test chordality of graphs, test acyclicity of hypergraphs, and
+       selectively reduce acyclic hypergraphs, SIAM J. Comput., 13 (1984),
+       pp. 566–579.
+    """
+    return len(_find_chordality_breaker(G)) == 0
+
+
+def find_induced_nodes(G, s, t, treewidth_bound=sys.maxsize):
+    """Returns the set of induced nodes in the path from s to t.
+
+    Parameters
+    ----------
+    G : graph
+      A chordal NetworkX graph
+    s : node
+        Source node to look for induced nodes
+    t : node
+        Destination node to look for induced nodes
+    treewidth_bound: float
+        Maximum treewidth acceptable for the graph H. The search
+        for induced nodes will end as soon as the treewidth_bound is exceeded.
+
+    Returns
+    -------
+    induced_nodes : Set of nodes
+        The set of induced nodes in the path from s to t in G
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
+        If the input graph is an instance of one of these classes, a
+        :exc:`NetworkXError` is raised.
+        The algorithm can only be applied to chordal graphs. If the input
+        graph is found to be non-chordal, a :exc:`NetworkXError` is raised.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G = nx.generators.classic.path_graph(10)
+    >>> induced_nodes = nx.find_induced_nodes(G, 1, 9, 2)
+    >>> sorted(induced_nodes)
+    [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+    Notes
+    -----
+    G must be a chordal graph and (s,t) an edge that is not in G.
+
+    If a treewidth_bound is provided, the search for induced nodes will end
+    as soon as the treewidth_bound is exceeded.
+
+    The algorithm is inspired by Algorithm 4 in [1]_.
+    A formal definition of induced node can also be found on that reference.
+
+    References
+    ----------
+    .. [1] Learning Bounded Treewidth Bayesian Networks.
+       Gal Elidan, Stephen Gould; JMLR, 9(Dec):2699--2731, 2008.
+       http://jmlr.csail.mit.edu/papers/volume9/elidan08a/elidan08a.pdf
+    """
+    if not is_chordal(G):
+        raise nx.NetworkXError("Input graph is not chordal.")
+
+    H = nx.Graph(G)
+    H.add_edge(s, t)
+    induced_nodes = set()
+    triplet = _find_chordality_breaker(H, s, treewidth_bound)
+    while triplet:
+        (u, v, w) = triplet
+        induced_nodes.update(triplet)
+        for n in triplet:
+            if n != s:
+                H.add_edge(s, n)
+        triplet = _find_chordality_breaker(H, s, treewidth_bound)
+    if induced_nodes:
+        # Add t and the second node in the induced path from s to t.
+        induced_nodes.add(t)
+        for u in G[s]:
+            if len(induced_nodes & set(G[u])) == 2:
+                induced_nodes.add(u)
+                break
+    return induced_nodes
+
+
+def chordal_graph_cliques(G):
+    """Returns the set of maximal cliques of a chordal graph.
+
+    The algorithm breaks the graph in connected components and performs a
+    maximum cardinality search in each component to get the cliques.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    Returns
+    -------
+    cliques : A set containing the maximal cliques in G.
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
+        The algorithm can only be applied to chordal graphs. If the input
+        graph is found to be non-chordal, a :exc:`NetworkXError` is raised.
+
+    Examples
+    --------
+    >>> e = [
+    ...     (1, 2),
+    ...     (1, 3),
+    ...     (2, 3),
+    ...     (2, 4),
+    ...     (3, 4),
+    ...     (3, 5),
+    ...     (3, 6),
+    ...     (4, 5),
+    ...     (4, 6),
+    ...     (5, 6),
+    ...     (7, 8),
+    ... ]
+    >>> G = nx.Graph(e)
+    >>> G.add_node(9)
+    >>> setlist = nx.chordal_graph_cliques(G)
+    """
+    msg = "This will return a generator in 3.0."
+    warnings.warn(msg, DeprecationWarning)
+    return {c for c in _chordal_graph_cliques(G)}
+
+
+def chordal_graph_treewidth(G):
+    """Returns the treewidth of the chordal graph G.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    Returns
+    -------
+    treewidth : int
+        The size of the largest clique in the graph minus one.
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
+        The algorithm can only be applied to chordal graphs. If the input
+        graph is found to be non-chordal, a :exc:`NetworkXError` is raised.
+
+    Examples
+    --------
+    >>> e = [
+    ...     (1, 2),
+    ...     (1, 3),
+    ...     (2, 3),
+    ...     (2, 4),
+    ...     (3, 4),
+    ...     (3, 5),
+    ...     (3, 6),
+    ...     (4, 5),
+    ...     (4, 6),
+    ...     (5, 6),
+    ...     (7, 8),
+    ... ]
+    >>> G = nx.Graph(e)
+    >>> G.add_node(9)
+    >>> nx.chordal_graph_treewidth(G)
+    3
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Tree_decomposition#Treewidth
+    """
+    if not is_chordal(G):
+        raise nx.NetworkXError("Input graph is not chordal.")
+
+    max_clique = -1
+    for clique in nx.chordal_graph_cliques(G):
+        max_clique = max(max_clique, len(clique))
+    return max_clique - 1
+
+
+def _is_complete_graph(G):
+    """Returns True if G is a complete graph."""
+    if nx.number_of_selfloops(G) > 0:
+        raise nx.NetworkXError("Self loop found in _is_complete_graph()")
+    n = G.number_of_nodes()
+    if n < 2:
+        return True
+    e = G.number_of_edges()
+    max_edges = (n * (n - 1)) / 2
+    return e == max_edges
+
+
+def _find_missing_edge(G):
+    """Given a non-complete graph G, returns a missing edge."""
+    nodes = set(G)
+    for u in G:
+        missing = nodes - set(list(G[u].keys()) + [u])
+        if missing:
+            return (u, missing.pop())
+
+
+def _max_cardinality_node(G, choices, wanna_connect):
+    """Returns a the node in choices that has more connections in G
+    to nodes in wanna_connect.
+    """
+    max_number = -1
+    for x in choices:
+        number = len([y for y in G[x] if y in wanna_connect])
+        if number > max_number:
+            max_number = number
+            max_cardinality_node = x
+    return max_cardinality_node
+
+
+def _find_chordality_breaker(G, s=None, treewidth_bound=sys.maxsize):
+    """Given a graph G, starts a max cardinality search
+    (starting from s if s is given and from an arbitrary node otherwise)
+    trying to find a non-chordal cycle.
+
+    If it does find one, it returns (u,v,w) where u,v,w are the three
+    nodes that together with s are involved in the cycle.
+    """
+    if nx.number_of_selfloops(G) > 0:
+        raise nx.NetworkXError("Input graph is not chordal.")
+    unnumbered = set(G)
+    if s is None:
+        s = arbitrary_element(G)
+    unnumbered.remove(s)
+    numbered = {s}
+    current_treewidth = -1
+    while unnumbered:  # and current_treewidth <= treewidth_bound:
+        v = _max_cardinality_node(G, unnumbered, numbered)
+        unnumbered.remove(v)
+        numbered.add(v)
+        clique_wanna_be = set(G[v]) & numbered
+        sg = G.subgraph(clique_wanna_be)
+        if _is_complete_graph(sg):
+            # The graph seems to be chordal by now. We update the treewidth
+            current_treewidth = max(current_treewidth, len(clique_wanna_be))
+            if current_treewidth > treewidth_bound:
+                raise nx.NetworkXTreewidthBoundExceeded(
+                    f"treewidth_bound exceeded: {current_treewidth}"
+                )
+        else:
+            # sg is not a clique,
+            # look for an edge that is not included in sg
+            (u, w) = _find_missing_edge(sg)
+            return (u, v, w)
+    return ()
+
+
+def _chordal_graph_cliques(G):
+    """Returns all maximal cliques of a chordal graph.
+
+    The algorithm breaks the graph in connected components and performs a
+    maximum cardinality search in each component to get the cliques.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    Returns
+    -------
+    iterator
+        An iterator over maximal cliques, each of which is a frozenset of
+        nodes in `G`. The order of cliques is arbitrary.
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
+        The algorithm can only be applied to chordal graphs. If the input
+        graph is found to be non-chordal, a :exc:`NetworkXError` is raised.
+
+    Examples
+    --------
+    >>> e = [
+    ...     (1, 2),
+    ...     (1, 3),
+    ...     (2, 3),
+    ...     (2, 4),
+    ...     (3, 4),
+    ...     (3, 5),
+    ...     (3, 6),
+    ...     (4, 5),
+    ...     (4, 6),
+    ...     (5, 6),
+    ...     (7, 8),
+    ... ]
+    >>> G = nx.Graph(e)
+    >>> G.add_node(9)
+    >>> cliques = [c for c in _chordal_graph_cliques(G)]
+    >>> cliques[0]
+    frozenset({1, 2, 3})
+    """
+    for C in (G.subgraph(c).copy() for c in connected_components(G)):
+        if C.number_of_nodes() == 1:
+            if nx.number_of_selfloops(C) > 0:
+                raise nx.NetworkXError("Input graph is not chordal.")
+            yield frozenset(C.nodes())
+        else:
+            unnumbered = set(C.nodes())
+            v = arbitrary_element(C)
+            unnumbered.remove(v)
+            numbered = {v}
+            clique_wanna_be = {v}
+            while unnumbered:
+                v = _max_cardinality_node(C, unnumbered, numbered)
+                unnumbered.remove(v)
+                numbered.add(v)
+                new_clique_wanna_be = set(C.neighbors(v)) & numbered
+                sg = C.subgraph(clique_wanna_be)
+                if _is_complete_graph(sg):
+                    new_clique_wanna_be.add(v)
+                    if not new_clique_wanna_be >= clique_wanna_be:
+                        yield frozenset(clique_wanna_be)
+                    clique_wanna_be = new_clique_wanna_be
+                else:
+                    raise nx.NetworkXError("Input graph is not chordal.")
+            yield frozenset(clique_wanna_be)
+
+
+@not_implemented_for("directed")
+def complete_to_chordal_graph(G):
+    """Return a copy of G completed to a chordal graph
+
+    Adds edges to a copy of G to create a chordal graph. A graph G=(V,E) is
+    called chordal if for each cycle with length bigger than 3, there exist
+    two non-adjacent nodes connected by an edge (called a chord).
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    Returns
+    -------
+    H : NetworkX graph
+        The chordal enhancement of G
+    alpha : Dictionary
+            The elimination ordering of nodes of G
+
+    Notes
+    -----
+    There are different approaches to calculate the chordal
+    enhancement of a graph. The algorithm used here is called
+    MCS-M and gives at least minimal (local) triangulation of graph. Note
+    that this triangulation is not necessarily a global minimum.
+
+    https://en.wikipedia.org/wiki/Chordal_graph
+
+    References
+    ----------
+    .. [1] Berry, Anne & Blair, Jean & Heggernes, Pinar & Peyton, Barry. (2004)
+           Maximum Cardinality Search for Computing Minimal Triangulations of
+           Graphs.  Algorithmica. 39. 287-298. 10.1007/s00453-004-1084-3.
+
+    Examples
+    --------
+    >>> from networkx.algorithms.chordal import complete_to_chordal_graph
+    >>> G = nx.wheel_graph(10)
+    >>> H, alpha = complete_to_chordal_graph(G)
+    """
+    H = G.copy()
+    alpha = {node: 0 for node in H}
+    if nx.is_chordal(H):
+        return H, alpha
+    chords = set()
+    weight = {node: 0 for node in H.nodes()}
+    unnumbered_nodes = list(H.nodes())
+    for i in range(len(H.nodes()), 0, -1):
+        # get the node in unnumbered_nodes with the maximum weight
+        z = max(unnumbered_nodes, key=lambda node: weight[node])
+        unnumbered_nodes.remove(z)
+        alpha[z] = i
+        update_nodes = []
+        for y in unnumbered_nodes:
+            if G.has_edge(y, z):
+                update_nodes.append(y)
+            else:
+                # y_weight will be bigger than node weights between y and z
+                y_weight = weight[y]
+                lower_nodes = [
+                    node for node in unnumbered_nodes if weight[node] < y_weight
+                ]
+                if nx.has_path(H.subgraph(lower_nodes + [z, y]), y, z):
+                    update_nodes.append(y)
+                    chords.add((z, y))
+        # during calculation of paths the weights should not be updated
+        for node in update_nodes:
+            weight[node] += 1
+    H.add_edges_from(chords)
+    return H, alpha
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/clique.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/clique.py
new file mode 100644
index 0000000..afdaa47
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/clique.py
@@ -0,0 +1,776 @@
+"""Functions for finding and manipulating cliques.
+
+Finding the largest clique in a graph is NP-complete problem, so most of
+these algorithms have an exponential running time; for more information,
+see the Wikipedia article on the clique problem [1]_.
+
+.. [1] clique problem:: https://en.wikipedia.org/wiki/Clique_problem
+
+"""
+from collections import defaultdict, deque
+from itertools import chain, combinations, islice
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "find_cliques",
+    "find_cliques_recursive",
+    "make_max_clique_graph",
+    "make_clique_bipartite",
+    "graph_clique_number",
+    "graph_number_of_cliques",
+    "node_clique_number",
+    "number_of_cliques",
+    "cliques_containing_node",
+    "enumerate_all_cliques",
+    "max_weight_clique",
+]
+
+
+@not_implemented_for("directed")
+def enumerate_all_cliques(G):
+    """Returns all cliques in an undirected graph.
+
+    This function returns an iterator over cliques, each of which is a
+    list of nodes. The iteration is ordered by cardinality of the
+    cliques: first all cliques of size one, then all cliques of size
+    two, etc.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+
+    Returns
+    -------
+    iterator
+        An iterator over cliques, each of which is a list of nodes in
+        `G`. The cliques are ordered according to size.
+
+    Notes
+    -----
+    To obtain a list of all cliques, use
+    `list(enumerate_all_cliques(G))`. However, be aware that in the
+    worst-case, the length of this list can be exponential in the number
+    of nodes in the graph (for example, when the graph is the complete
+    graph). This function avoids storing all cliques in memory by only
+    keeping current candidate node lists in memory during its search.
+
+    The implementation is adapted from the algorithm by Zhang, et
+    al. (2005) [1]_ to output all cliques discovered.
+
+    This algorithm ignores self-loops and parallel edges, since cliques
+    are not conventionally defined with such edges.
+
+    References
+    ----------
+    .. [1] Yun Zhang, Abu-Khzam, F.N., Baldwin, N.E., Chesler, E.J.,
+           Langston, M.A., Samatova, N.F.,
+           "Genome-Scale Computational Approaches to Memory-Intensive
+           Applications in Systems Biology".
+           *Supercomputing*, 2005. Proceedings of the ACM/IEEE SC 2005
+           Conference, pp. 12, 12--18 Nov. 2005.
+           <https://doi.org/10.1109/SC.2005.29>.
+
+    """
+    index = {}
+    nbrs = {}
+    for u in G:
+        index[u] = len(index)
+        # Neighbors of u that appear after u in the iteration order of G.
+        nbrs[u] = {v for v in G[u] if v not in index}
+
+    queue = deque(([u], sorted(nbrs[u], key=index.__getitem__)) for u in G)
+    # Loop invariants:
+    # 1. len(base) is nondecreasing.
+    # 2. (base + cnbrs) is sorted with respect to the iteration order of G.
+    # 3. cnbrs is a set of common neighbors of nodes in base.
+    while queue:
+        base, cnbrs = map(list, queue.popleft())
+        yield base
+        for i, u in enumerate(cnbrs):
+            # Use generators to reduce memory consumption.
+            queue.append(
+                (
+                    chain(base, [u]),
+                    filter(nbrs[u].__contains__, islice(cnbrs, i + 1, None)),
+                )
+            )
+
+
+@not_implemented_for("directed")
+def find_cliques(G, nodes=None):
+    """Returns all maximal cliques in an undirected graph.
+
+    For each node *n*, a *maximal clique for n* is a largest complete
+    subgraph containing *n*. The largest maximal clique is sometimes
+    called the *maximum clique*.
+
+    This function returns an iterator over cliques, each of which is a
+    list of nodes. It is an iterative implementation, so should not
+    suffer from recursion depth issues.
+
+    This function accepts a list of `nodes` and only the maximal cliques
+    containing all of these `nodes` are returned. It can considerably speed up
+    the running time if some specific cliques are desired.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+
+    nodes : list, optional (default=None)
+        If provided, only yield *maximal cliques* containing all nodes in `nodes`.
+        If `nodes` isn't a clique itself, a ValueError is raised.
+
+    Returns
+    -------
+    iterator
+        An iterator over maximal cliques, each of which is a list of
+        nodes in `G`. If `nodes` is provided, only the maximal cliques
+        containing all the nodes in `nodes` are returned. The order of
+        cliques is arbitrary.
+
+    Raises
+    ------
+    ValueError
+        If `nodes` is not a clique.
+
+    See Also
+    --------
+    find_cliques_recursive
+        A recursive version of the same algorithm.
+
+    Notes
+    -----
+    To obtain a list of all maximal cliques, use
+    `list(find_cliques(G))`. However, be aware that in the worst-case,
+    the length of this list can be exponential in the number of nodes in
+    the graph. This function avoids storing all cliques in memory by
+    only keeping current candidate node lists in memory during its search.
+
+    This implementation is based on the algorithm published by Bron and
+    Kerbosch (1973) [1]_, as adapted by Tomita, Tanaka and Takahashi
+    (2006) [2]_ and discussed in Cazals and Karande (2008) [3]_. It
+    essentially unrolls the recursion used in the references to avoid
+    issues of recursion stack depth (for a recursive implementation, see
+    :func:`find_cliques_recursive`).
+
+    This algorithm ignores self-loops and parallel edges, since cliques
+    are not conventionally defined with such edges.
+
+    References
+    ----------
+    .. [1] Bron, C. and Kerbosch, J.
+       "Algorithm 457: finding all cliques of an undirected graph".
+       *Communications of the ACM* 16, 9 (Sep. 1973), 575--577.
+       <http://portal.acm.org/citation.cfm?doid=362342.362367>
+
+    .. [2] Etsuji Tomita, Akira Tanaka, Haruhisa Takahashi,
+       "The worst-case time complexity for generating all maximal
+       cliques and computational experiments",
+       *Theoretical Computer Science*, Volume 363, Issue 1,
+       Computing and Combinatorics,
+       10th Annual International Conference on
+       Computing and Combinatorics (COCOON 2004), 25 October 2006, Pages 28--42
+       <https://doi.org/10.1016/j.tcs.2006.06.015>
+
+    .. [3] F. Cazals, C. Karande,
+       "A note on the problem of reporting maximal cliques",
+       *Theoretical Computer Science*,
+       Volume 407, Issues 1--3, 6 November 2008, Pages 564--568,
+       <https://doi.org/10.1016/j.tcs.2008.05.010>
+
+    """
+    if len(G) == 0:
+        return
+
+    adj = {u: {v for v in G[u] if v != u} for u in G}
+
+    # Initialize Q with the given nodes and subg, cand with their nbrs
+    Q = nodes[:] if nodes is not None else []
+    cand = set(G)
+    for node in Q:
+        if node not in cand:
+            raise ValueError(f"The given `nodes` {nodes} do not form a clique")
+        cand &= adj[node]
+
+    if not cand:
+        yield Q[:]
+        return
+
+    subg = cand.copy()
+    stack = []
+    Q.append(None)
+
+    u = max(subg, key=lambda u: len(cand & adj[u]))
+    ext_u = cand - adj[u]
+
+    try:
+        while True:
+            if ext_u:
+                q = ext_u.pop()
+                cand.remove(q)
+                Q[-1] = q
+                adj_q = adj[q]
+                subg_q = subg & adj_q
+                if not subg_q:
+                    yield Q[:]
+                else:
+                    cand_q = cand & adj_q
+                    if cand_q:
+                        stack.append((subg, cand, ext_u))
+                        Q.append(None)
+                        subg = subg_q
+                        cand = cand_q
+                        u = max(subg, key=lambda u: len(cand & adj[u]))
+                        ext_u = cand - adj[u]
+            else:
+                Q.pop()
+                subg, cand, ext_u = stack.pop()
+    except IndexError:
+        pass
+
+
+# TODO Should this also be not implemented for directed graphs?
+def find_cliques_recursive(G, nodes=None):
+    """Returns all maximal cliques in a graph.
+
+    For each node *v*, a *maximal clique for v* is a largest complete
+    subgraph containing *v*. The largest maximal clique is sometimes
+    called the *maximum clique*.
+
+    This function returns an iterator over cliques, each of which is a
+    list of nodes. It is a recursive implementation, so may suffer from
+    recursion depth issues, but is included for pedagogical reasons.
+    For a non-recursive implementation, see :func:`find_cliques`.
+
+    This function accepts a list of `nodes` and only the maximal cliques
+    containing all of these `nodes` are returned. It can considerably speed up
+    the running time if some specific cliques are desired.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    nodes : list, optional (default=None)
+        If provided, only yield *maximal cliques* containing all nodes in `nodes`.
+        If `nodes` isn't a clique itself, a ValueError is raised.
+
+    Returns
+    -------
+    iterator
+        An iterator over maximal cliques, each of which is a list of
+        nodes in `G`. If `nodes` is provided, only the maximal cliques
+        containing all the nodes in `nodes` are yielded. The order of
+        cliques is arbitrary.
+
+    Raises
+    ------
+    ValueError
+        If `nodes` is not a clique.
+
+    See Also
+    --------
+    find_cliques
+        An iterative version of the same algorithm.
+
+    Notes
+    -----
+    To obtain a list of all maximal cliques, use
+    `list(find_cliques_recursive(G))`. However, be aware that in the
+    worst-case, the length of this list can be exponential in the number
+    of nodes in the graph. This function avoids storing all cliques in memory
+    by only keeping current candidate node lists in memory during its search.
+
+    This implementation is based on the algorithm published by Bron and
+    Kerbosch (1973) [1]_, as adapted by Tomita, Tanaka and Takahashi
+    (2006) [2]_ and discussed in Cazals and Karande (2008) [3]_. For a
+    non-recursive implementation, see :func:`find_cliques`.
+
+    This algorithm ignores self-loops and parallel edges, since cliques
+    are not conventionally defined with such edges.
+
+    References
+    ----------
+    .. [1] Bron, C. and Kerbosch, J.
+       "Algorithm 457: finding all cliques of an undirected graph".
+       *Communications of the ACM* 16, 9 (Sep. 1973), 575--577.
+       <http://portal.acm.org/citation.cfm?doid=362342.362367>
+
+    .. [2] Etsuji Tomita, Akira Tanaka, Haruhisa Takahashi,
+       "The worst-case time complexity for generating all maximal
+       cliques and computational experiments",
+       *Theoretical Computer Science*, Volume 363, Issue 1,
+       Computing and Combinatorics,
+       10th Annual International Conference on
+       Computing and Combinatorics (COCOON 2004), 25 October 2006, Pages 28--42
+       <https://doi.org/10.1016/j.tcs.2006.06.015>
+
+    .. [3] F. Cazals, C. Karande,
+       "A note on the problem of reporting maximal cliques",
+       *Theoretical Computer Science*,
+       Volume 407, Issues 1--3, 6 November 2008, Pages 564--568,
+       <https://doi.org/10.1016/j.tcs.2008.05.010>
+
+    """
+    if len(G) == 0:
+        return iter([])
+
+    adj = {u: {v for v in G[u] if v != u} for u in G}
+
+    # Initialize Q with the given nodes and subg, cand with their nbrs
+    Q = nodes[:] if nodes is not None else []
+    cand_init = set(G)
+    for node in Q:
+        if node not in cand_init:
+            raise ValueError(f"The given `nodes` {nodes} do not form a clique")
+        cand_init &= adj[node]
+
+    if not cand_init:
+        return iter([Q])
+
+    subg_init = cand_init.copy()
+
+    def expand(subg, cand):
+        u = max(subg, key=lambda u: len(cand & adj[u]))
+        for q in cand - adj[u]:
+            cand.remove(q)
+            Q.append(q)
+            adj_q = adj[q]
+            subg_q = subg & adj_q
+            if not subg_q:
+                yield Q[:]
+            else:
+                cand_q = cand & adj_q
+                if cand_q:
+                    yield from expand(subg_q, cand_q)
+            Q.pop()
+
+    return expand(subg_init, cand_init)
+
+
+def make_max_clique_graph(G, create_using=None):
+    """Returns the maximal clique graph of the given graph.
+
+    The nodes of the maximal clique graph of `G` are the cliques of
+    `G` and an edge joins two cliques if the cliques are not disjoint.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    NetworkX graph
+        A graph whose nodes are the cliques of `G` and whose edges
+        join two cliques if they are not disjoint.
+
+    Notes
+    -----
+    This function behaves like the following code::
+
+        import networkx as nx
+        G = nx.make_clique_bipartite(G)
+        cliques = [v for v in G.nodes() if G.nodes[v]['bipartite'] == 0]
+        G = nx.bipartite.projected_graph(G, cliques)
+        G = nx.relabel_nodes(G, {-v: v - 1 for v in G})
+
+    It should be faster, though, since it skips all the intermediate
+    steps.
+
+    """
+    if create_using is None:
+        B = G.__class__()
+    else:
+        B = nx.empty_graph(0, create_using)
+    cliques = list(enumerate(set(c) for c in find_cliques(G)))
+    # Add a numbered node for each clique.
+    B.add_nodes_from(i for i, c in cliques)
+    # Join cliques by an edge if they share a node.
+    clique_pairs = combinations(cliques, 2)
+    B.add_edges_from((i, j) for (i, c1), (j, c2) in clique_pairs if c1 & c2)
+    return B
+
+
+def make_clique_bipartite(G, fpos=None, create_using=None, name=None):
+    """Returns the bipartite clique graph corresponding to `G`.
+
+    In the returned bipartite graph, the "bottom" nodes are the nodes of
+    `G` and the "top" nodes represent the maximal cliques of `G`.
+    There is an edge from node *v* to clique *C* in the returned graph
+    if and only if *v* is an element of *C*.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+
+    fpos : bool
+        If True or not None, the returned graph will have an
+        additional attribute, `pos`, a dictionary mapping node to
+        position in the Euclidean plane.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    NetworkX graph
+        A bipartite graph whose "bottom" set is the nodes of the graph
+        `G`, whose "top" set is the cliques of `G`, and whose edges
+        join nodes of `G` to the cliques that contain them.
+
+        The nodes of the graph `G` have the node attribute
+        'bipartite' set to 1 and the nodes representing cliques
+        have the node attribute 'bipartite' set to 0, as is the
+        convention for bipartite graphs in NetworkX.
+
+    """
+    B = nx.empty_graph(0, create_using)
+    B.clear()
+    # The "bottom" nodes in the bipartite graph are the nodes of the
+    # original graph, G.
+    B.add_nodes_from(G, bipartite=1)
+    for i, cl in enumerate(find_cliques(G)):
+        # The "top" nodes in the bipartite graph are the cliques. These
+        # nodes get negative numbers as labels.
+        name = -i - 1
+        B.add_node(name, bipartite=0)
+        B.add_edges_from((v, name) for v in cl)
+    return B
+
+
+def graph_clique_number(G, cliques=None):
+    """Returns the clique number of the graph.
+
+    The *clique number* of a graph is the size of the largest clique in
+    the graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+
+    cliques : list
+        A list of cliques, each of which is itself a list of nodes. If
+        not specified, the list of all cliques will be computed, as by
+        :func:`find_cliques`.
+
+    Returns
+    -------
+    int
+        The size of the largest clique in `G`.
+
+    Notes
+    -----
+    You should provide `cliques` if you have already computed the list
+    of maximal cliques, in order to avoid an exponential time search for
+    maximal cliques.
+
+    """
+    if len(G.nodes) < 1:
+        return 0
+    if cliques is None:
+        cliques = find_cliques(G)
+    return max([len(c) for c in cliques] or [1])
+
+
+def graph_number_of_cliques(G, cliques=None):
+    """Returns the number of maximal cliques in the graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+
+    cliques : list
+        A list of cliques, each of which is itself a list of nodes. If
+        not specified, the list of all cliques will be computed, as by
+        :func:`find_cliques`.
+
+    Returns
+    -------
+    int
+        The number of maximal cliques in `G`.
+
+    Notes
+    -----
+    You should provide `cliques` if you have already computed the list
+    of maximal cliques, in order to avoid an exponential time search for
+    maximal cliques.
+
+    """
+    if cliques is None:
+        cliques = list(find_cliques(G))
+    return len(cliques)
+
+
+def node_clique_number(G, nodes=None, cliques=None, separate_nodes=False):
+    """Returns the size of the largest maximal clique containing each given node.
+
+    Returns a single or list depending on input nodes.
+    An optional list of cliques can be input if already computed.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+
+    cliques : list, optional (default=None)
+        A list of cliques, each of which is itself a list of nodes.
+        If not specified, the list of all cliques will be computed
+        using :func:`find_cliques`.
+
+    Returns
+    -------
+    int or dict
+        If `nodes` is a single node, returns the size of the
+        largest maximal clique in `G` containing that node.
+        Otherwise return a dict keyed by node to the size
+        of the largest maximal clique containing that node.
+
+    See Also
+    --------
+    find_cliques
+        find_cliques yields the maximal cliques of G.
+        It accepts a `nodes` argument which restricts consideration to
+        maximal cliques containing all the given `nodes`.
+        The search for the cliques is optimized for `nodes`.
+    """
+    if cliques is None:
+        if nodes is not None:
+            # Use ego_graph to decrease size of graph
+            # check for single node
+            if nodes in G:
+                return max(len(c) for c in find_cliques(nx.ego_graph(G, nodes)))
+            # handle multiple nodes
+            return {
+                n: max(len(c) for c in find_cliques(nx.ego_graph(G, n))) for n in nodes
+            }
+
+        # nodes is None--find all cliques
+        cliques = list(find_cliques(G))
+
+    # single node requested
+    if nodes in G:
+        return max(len(c) for c in cliques if nodes in c)
+
+    # multiple nodes requested
+    # preprocess all nodes (faster than one at a time for even 2 nodes)
+    size_for_n = defaultdict(int)
+    for c in cliques:
+        size_of_c = len(c)
+        for n in c:
+            if size_for_n[n] < size_of_c:
+                size_for_n[n] = size_of_c
+    if nodes is None:
+        return size_for_n
+    return {n: size_for_n[n] for n in nodes}
+
+
+def number_of_cliques(G, nodes=None, cliques=None):
+    """Returns the number of maximal cliques for each node.
+
+    Returns a single or list depending on input nodes.
+    Optional list of cliques can be input if already computed.
+    """
+    if cliques is None:
+        cliques = list(find_cliques(G))
+
+    if nodes is None:
+        nodes = list(G.nodes())  # none, get entire graph
+
+    if not isinstance(nodes, list):  # check for a list
+        v = nodes
+        # assume it is a single value
+        numcliq = len([1 for c in cliques if v in c])
+    else:
+        numcliq = {}
+        for v in nodes:
+            numcliq[v] = len([1 for c in cliques if v in c])
+    return numcliq
+
+
+def cliques_containing_node(G, nodes=None, cliques=None):
+    """Returns a list of cliques containing the given node.
+
+    Returns a single list or list of lists depending on input nodes.
+    Optional list of cliques can be input if already computed.
+    """
+    if cliques is None:
+        cliques = list(find_cliques(G))
+
+    if nodes is None:
+        nodes = list(G.nodes())  # none, get entire graph
+
+    if not isinstance(nodes, list):  # check for a list
+        v = nodes
+        # assume it is a single value
+        vcliques = [c for c in cliques if v in c]
+    else:
+        vcliques = {}
+        for v in nodes:
+            vcliques[v] = [c for c in cliques if v in c]
+    return vcliques
+
+
+class MaxWeightClique:
+    """A class for the maximum weight clique algorithm.
+
+    This class is a helper for the `max_weight_clique` function.  The class
+    should not normally be used directly.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The undirected graph for which a maximum weight clique is sought
+    weight : string or None, optional (default='weight')
+        The node attribute that holds the integer value used as a weight.
+        If None, then each node has weight 1.
+
+    Attributes
+    ----------
+    G : NetworkX graph
+        The undirected graph for which a maximum weight clique is sought
+    node_weights: dict
+        The weight of each node
+    incumbent_nodes : list
+        The nodes of the incumbent clique (the best clique found so far)
+    incumbent_weight: int
+        The weight of the incumbent clique
+    """
+
+    def __init__(self, G, weight):
+        self.G = G
+        self.incumbent_nodes = []
+        self.incumbent_weight = 0
+
+        if weight is None:
+            self.node_weights = {v: 1 for v in G.nodes()}
+        else:
+            for v in G.nodes():
+                if weight not in G.nodes[v]:
+                    errmsg = f"Node {v!r} does not have the requested weight field."
+                    raise KeyError(errmsg)
+                if not isinstance(G.nodes[v][weight], int):
+                    errmsg = f"The {weight!r} field of node {v!r} is not an integer."
+                    raise ValueError(errmsg)
+            self.node_weights = {v: G.nodes[v][weight] for v in G.nodes()}
+
+    def update_incumbent_if_improved(self, C, C_weight):
+        """Update the incumbent if the node set C has greater weight.
+
+        C is assumed to be a clique.
+        """
+        if C_weight > self.incumbent_weight:
+            self.incumbent_nodes = C[:]
+            self.incumbent_weight = C_weight
+
+    def greedily_find_independent_set(self, P):
+        """Greedily find an independent set of nodes from a set of
+        nodes P."""
+        independent_set = []
+        P = P[:]
+        while P:
+            v = P[0]
+            independent_set.append(v)
+            P = [w for w in P if v != w and not self.G.has_edge(v, w)]
+        return independent_set
+
+    def find_branching_nodes(self, P, target):
+        """Find a set of nodes to branch on."""
+        residual_wt = {v: self.node_weights[v] for v in P}
+        total_wt = 0
+        P = P[:]
+        while P:
+            independent_set = self.greedily_find_independent_set(P)
+            min_wt_in_class = min(residual_wt[v] for v in independent_set)
+            total_wt += min_wt_in_class
+            if total_wt > target:
+                break
+            for v in independent_set:
+                residual_wt[v] -= min_wt_in_class
+            P = [v for v in P if residual_wt[v] != 0]
+        return P
+
+    def expand(self, C, C_weight, P):
+        """Look for the best clique that contains all the nodes in C and zero or
+        more of the nodes in P, backtracking if it can be shown that no such
+        clique has greater weight than the incumbent.
+        """
+        self.update_incumbent_if_improved(C, C_weight)
+        branching_nodes = self.find_branching_nodes(P, self.incumbent_weight - C_weight)
+        while branching_nodes:
+            v = branching_nodes.pop()
+            P.remove(v)
+            new_C = C + [v]
+            new_C_weight = C_weight + self.node_weights[v]
+            new_P = [w for w in P if self.G.has_edge(v, w)]
+            self.expand(new_C, new_C_weight, new_P)
+
+    def find_max_weight_clique(self):
+        """Find a maximum weight clique."""
+        # Sort nodes in reverse order of degree for speed
+        nodes = sorted(self.G.nodes(), key=lambda v: self.G.degree(v), reverse=True)
+        nodes = [v for v in nodes if self.node_weights[v] > 0]
+        self.expand([], 0, nodes)
+
+
+@not_implemented_for("directed")
+def max_weight_clique(G, weight="weight"):
+    """Find a maximum weight clique in G.
+
+    A *clique* in a graph is a set of nodes such that every two distinct nodes
+    are adjacent.  The *weight* of a clique is the sum of the weights of its
+    nodes.  A *maximum weight clique* of graph G is a clique C in G such that
+    no clique in G has weight greater than the weight of C.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+    weight : string or None, optional (default='weight')
+        The node attribute that holds the integer value used as a weight.
+        If None, then each node has weight 1.
+
+    Returns
+    -------
+    clique : list
+        the nodes of a maximum weight clique
+    weight : int
+        the weight of a maximum weight clique
+
+    Notes
+    -----
+    The implementation is recursive, and therefore it may run into recursion
+    depth issues if G contains a clique whose number of nodes is close to the
+    recursion depth limit.
+
+    At each search node, the algorithm greedily constructs a weighted
+    independent set cover of part of the graph in order to find a small set of
+    nodes on which to branch.  The algorithm is very similar to the algorithm
+    of Tavares et al. [1]_, other than the fact that the NetworkX version does
+    not use bitsets.  This style of algorithm for maximum weight clique (and
+    maximum weight independent set, which is the same problem but on the
+    complement graph) has a decades-long history.  See Algorithm B of Warren
+    and Hicks [2]_ and the references in that paper.
+
+    References
+    ----------
+    .. [1] Tavares, W.A., Neto, M.B.C., Rodrigues, C.D., Michelon, P.: Um
+           algoritmo de branch and bound para o problema da clique máxima
+           ponderada.  Proceedings of XLVII SBPO 1 (2015).
+
+    .. [2] Warrent, Jeffrey S, Hicks, Illya V.: Combinatorial Branch-and-Bound
+           for the Maximum Weight Independent Set Problem.  Technical Report,
+           Texas A&M University (2016).
+    """
+
+    mwc = MaxWeightClique(G, weight)
+    mwc.find_max_weight_clique()
+    return mwc.incumbent_nodes, mwc.incumbent_weight
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/cluster.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/cluster.py
new file mode 100644
index 0000000..1421fef
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/cluster.py
@@ -0,0 +1,568 @@
+"""Algorithms to characterize the number of triangles in a graph."""
+
+from collections import Counter
+from itertools import chain, combinations
+
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "triangles",
+    "average_clustering",
+    "clustering",
+    "transitivity",
+    "square_clustering",
+    "generalized_degree",
+]
+
+
+@not_implemented_for("directed")
+def triangles(G, nodes=None):
+    """Compute the number of triangles.
+
+    Finds the number of triangles that include a node as one vertex.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    nodes : container of nodes, optional (default= all nodes in G)
+       Compute triangles for nodes in this container.
+
+    Returns
+    -------
+    out : dictionary
+       Number of triangles keyed by node label.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> print(nx.triangles(G, 0))
+    6
+    >>> print(nx.triangles(G))
+    {0: 6, 1: 6, 2: 6, 3: 6, 4: 6}
+    >>> print(list(nx.triangles(G, (0, 1)).values()))
+    [6, 6]
+
+    Notes
+    -----
+    When computing triangles for the entire graph each triangle is counted
+    three times, once at each node.  Self loops are ignored.
+
+    """
+    # If `nodes` represents a single node in the graph, return only its number
+    # of triangles.
+    if nodes in G:
+        return next(_triangles_and_degree_iter(G, nodes))[2] // 2
+    # Otherwise, `nodes` represents an iterable of nodes, so return a
+    # dictionary mapping node to number of triangles.
+    return {v: t // 2 for v, d, t, _ in _triangles_and_degree_iter(G, nodes)}
+
+
+@not_implemented_for("multigraph")
+def _triangles_and_degree_iter(G, nodes=None):
+    """Return an iterator of (node, degree, triangles, generalized degree).
+
+    This double counts triangles so you may want to divide by 2.
+    See degree(), triangles() and generalized_degree() for definitions
+    and details.
+
+    """
+    if nodes is None:
+        nodes_nbrs = G.adj.items()
+    else:
+        nodes_nbrs = ((n, G[n]) for n in G.nbunch_iter(nodes))
+
+    for v, v_nbrs in nodes_nbrs:
+        vs = set(v_nbrs) - {v}
+        gen_degree = Counter(len(vs & (set(G[w]) - {w})) for w in vs)
+        ntriangles = sum(k * val for k, val in gen_degree.items())
+        yield (v, len(vs), ntriangles, gen_degree)
+
+
+@not_implemented_for("multigraph")
+def _weighted_triangles_and_degree_iter(G, nodes=None, weight="weight"):
+    """Return an iterator of (node, degree, weighted_triangles).
+
+    Used for weighted clustering.
+    Note: this returns the geometric average weight of edges in the triangle.
+    Also, each triangle is counted twice (each direction).
+    So you may want to divide by 2.
+
+    """
+    import numpy as np
+
+    if weight is None or G.number_of_edges() == 0:
+        max_weight = 1
+    else:
+        max_weight = max(d.get(weight, 1) for u, v, d in G.edges(data=True))
+    if nodes is None:
+        nodes_nbrs = G.adj.items()
+    else:
+        nodes_nbrs = ((n, G[n]) for n in G.nbunch_iter(nodes))
+
+    def wt(u, v):
+        return G[u][v].get(weight, 1) / max_weight
+
+    for i, nbrs in nodes_nbrs:
+        inbrs = set(nbrs) - {i}
+        weighted_triangles = 0
+        seen = set()
+        for j in inbrs:
+            seen.add(j)
+            # This avoids counting twice -- we double at the end.
+            jnbrs = set(G[j]) - seen
+            # Only compute the edge weight once, before the inner inner
+            # loop.
+            wij = wt(i, j)
+            weighted_triangles += sum(
+                np.cbrt([(wij * wt(j, k) * wt(k, i)) for k in inbrs & jnbrs])
+            )
+        yield (i, len(inbrs), 2 * weighted_triangles)
+
+
+@not_implemented_for("multigraph")
+def _directed_triangles_and_degree_iter(G, nodes=None):
+    """Return an iterator of
+    (node, total_degree, reciprocal_degree, directed_triangles).
+
+    Used for directed clustering.
+    Note that unlike `_triangles_and_degree_iter()`, this function counts
+    directed triangles so does not count triangles twice.
+
+    """
+    nodes_nbrs = ((n, G._pred[n], G._succ[n]) for n in G.nbunch_iter(nodes))
+
+    for i, preds, succs in nodes_nbrs:
+        ipreds = set(preds) - {i}
+        isuccs = set(succs) - {i}
+
+        directed_triangles = 0
+        for j in chain(ipreds, isuccs):
+            jpreds = set(G._pred[j]) - {j}
+            jsuccs = set(G._succ[j]) - {j}
+            directed_triangles += sum(
+                1
+                for k in chain(
+                    (ipreds & jpreds),
+                    (ipreds & jsuccs),
+                    (isuccs & jpreds),
+                    (isuccs & jsuccs),
+                )
+            )
+        dtotal = len(ipreds) + len(isuccs)
+        dbidirectional = len(ipreds & isuccs)
+        yield (i, dtotal, dbidirectional, directed_triangles)
+
+
+@not_implemented_for("multigraph")
+def _directed_weighted_triangles_and_degree_iter(G, nodes=None, weight="weight"):
+    """Return an iterator of
+    (node, total_degree, reciprocal_degree, directed_weighted_triangles).
+
+    Used for directed weighted clustering.
+    Note that unlike `_weighted_triangles_and_degree_iter()`, this function counts
+    directed triangles so does not count triangles twice.
+
+    """
+    import numpy as np
+
+    if weight is None or G.number_of_edges() == 0:
+        max_weight = 1
+    else:
+        max_weight = max(d.get(weight, 1) for u, v, d in G.edges(data=True))
+
+    nodes_nbrs = ((n, G._pred[n], G._succ[n]) for n in G.nbunch_iter(nodes))
+
+    def wt(u, v):
+        return G[u][v].get(weight, 1) / max_weight
+
+    for i, preds, succs in nodes_nbrs:
+        ipreds = set(preds) - {i}
+        isuccs = set(succs) - {i}
+
+        directed_triangles = 0
+        for j in ipreds:
+            jpreds = set(G._pred[j]) - {j}
+            jsuccs = set(G._succ[j]) - {j}
+            directed_triangles += sum(
+                np.cbrt([(wt(j, i) * wt(k, i) * wt(k, j)) for k in ipreds & jpreds])
+            )
+            directed_triangles += sum(
+                np.cbrt([(wt(j, i) * wt(k, i) * wt(j, k)) for k in ipreds & jsuccs])
+            )
+            directed_triangles += sum(
+                np.cbrt([(wt(j, i) * wt(i, k) * wt(k, j)) for k in isuccs & jpreds])
+            )
+            directed_triangles += sum(
+                np.cbrt([(wt(j, i) * wt(i, k) * wt(j, k)) for k in isuccs & jsuccs])
+            )
+
+        for j in isuccs:
+            jpreds = set(G._pred[j]) - {j}
+            jsuccs = set(G._succ[j]) - {j}
+            directed_triangles += sum(
+                np.cbrt([(wt(i, j) * wt(k, i) * wt(k, j)) for k in ipreds & jpreds])
+            )
+            directed_triangles += sum(
+                np.cbrt([(wt(i, j) * wt(k, i) * wt(j, k)) for k in ipreds & jsuccs])
+            )
+            directed_triangles += sum(
+                np.cbrt([(wt(i, j) * wt(i, k) * wt(k, j)) for k in isuccs & jpreds])
+            )
+            directed_triangles += sum(
+                np.cbrt([(wt(i, j) * wt(i, k) * wt(j, k)) for k in isuccs & jsuccs])
+            )
+
+        dtotal = len(ipreds) + len(isuccs)
+        dbidirectional = len(ipreds & isuccs)
+        yield (i, dtotal, dbidirectional, directed_triangles)
+
+
+def average_clustering(G, nodes=None, weight=None, count_zeros=True):
+    r"""Compute the average clustering coefficient for the graph G.
+
+    The clustering coefficient for the graph is the average,
+
+    .. math::
+
+       C = \frac{1}{n}\sum_{v \in G} c_v,
+
+    where :math:`n` is the number of nodes in `G`.
+
+    Parameters
+    ----------
+    G : graph
+
+    nodes : container of nodes, optional (default=all nodes in G)
+       Compute average clustering for nodes in this container.
+
+    weight : string or None, optional (default=None)
+       The edge attribute that holds the numerical value used as a weight.
+       If None, then each edge has weight 1.
+
+    count_zeros : bool
+       If False include only the nodes with nonzero clustering in the average.
+
+    Returns
+    -------
+    avg : float
+       Average clustering
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> print(nx.average_clustering(G))
+    1.0
+
+    Notes
+    -----
+    This is a space saving routine; it might be faster
+    to use the clustering function to get a list and then take the average.
+
+    Self loops are ignored.
+
+    References
+    ----------
+    .. [1] Generalizations of the clustering coefficient to weighted
+       complex networks by J. Saramäki, M. Kivelä, J.-P. Onnela,
+       K. Kaski, and J. Kertész, Physical Review E, 75 027105 (2007).
+       http://jponnela.com/web_documents/a9.pdf
+    .. [2] Marcus Kaiser,  Mean clustering coefficients: the role of isolated
+       nodes and leafs on clustering measures for small-world networks.
+       https://arxiv.org/abs/0802.2512
+    """
+    c = clustering(G, nodes, weight=weight).values()
+    if not count_zeros:
+        c = [v for v in c if abs(v) > 0]
+    return sum(c) / len(c)
+
+
+def clustering(G, nodes=None, weight=None):
+    r"""Compute the clustering coefficient for nodes.
+
+    For unweighted graphs, the clustering of a node :math:`u`
+    is the fraction of possible triangles through that node that exist,
+
+    .. math::
+
+      c_u = \frac{2 T(u)}{deg(u)(deg(u)-1)},
+
+    where :math:`T(u)` is the number of triangles through node :math:`u` and
+    :math:`deg(u)` is the degree of :math:`u`.
+
+    For weighted graphs, there are several ways to define clustering [1]_.
+    the one used here is defined
+    as the geometric average of the subgraph edge weights [2]_,
+
+    .. math::
+
+       c_u = \frac{1}{deg(u)(deg(u)-1))}
+             \sum_{vw} (\hat{w}_{uv} \hat{w}_{uw} \hat{w}_{vw})^{1/3}.
+
+    The edge weights :math:`\hat{w}_{uv}` are normalized by the maximum weight
+    in the network :math:`\hat{w}_{uv} = w_{uv}/\max(w)`.
+
+    The value of :math:`c_u` is assigned to 0 if :math:`deg(u) < 2`.
+
+    Additionally, this weighted definition has been generalized to support negative edge weights [3]_.
+
+    For directed graphs, the clustering is similarly defined as the fraction
+    of all possible directed triangles or geometric average of the subgraph
+    edge weights for unweighted and weighted directed graph respectively [4]_.
+
+    .. math::
+
+       c_u = \frac{2}{deg^{tot}(u)(deg^{tot}(u)-1) - 2deg^{\leftrightarrow}(u)}
+             T(u),
+
+    where :math:`T(u)` is the number of directed triangles through node
+    :math:`u`, :math:`deg^{tot}(u)` is the sum of in degree and out degree of
+    :math:`u` and :math:`deg^{\leftrightarrow}(u)` is the reciprocal degree of
+    :math:`u`.
+
+
+    Parameters
+    ----------
+    G : graph
+
+    nodes : container of nodes, optional (default=all nodes in G)
+       Compute clustering for nodes in this container.
+
+    weight : string or None, optional (default=None)
+       The edge attribute that holds the numerical value used as a weight.
+       If None, then each edge has weight 1.
+
+    Returns
+    -------
+    out : float, or dictionary
+       Clustering coefficient at specified nodes
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> print(nx.clustering(G, 0))
+    1.0
+    >>> print(nx.clustering(G))
+    {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0}
+
+    Notes
+    -----
+    Self loops are ignored.
+
+    References
+    ----------
+    .. [1] Generalizations of the clustering coefficient to weighted
+       complex networks by J. Saramäki, M. Kivelä, J.-P. Onnela,
+       K. Kaski, and J. Kertész, Physical Review E, 75 027105 (2007).
+       http://jponnela.com/web_documents/a9.pdf
+    .. [2] Intensity and coherence of motifs in weighted complex
+       networks by J. P. Onnela, J. Saramäki, J. Kertész, and K. Kaski,
+       Physical Review E, 71(6), 065103 (2005).
+    .. [3] Generalization of Clustering Coefficients to Signed Correlation Networks
+       by G. Costantini and M. Perugini, PloS one, 9(2), e88669 (2014).
+    .. [4] Clustering in complex directed networks by G. Fagiolo,
+       Physical Review E, 76(2), 026107 (2007).
+    """
+    if G.is_directed():
+        if weight is not None:
+            td_iter = _directed_weighted_triangles_and_degree_iter(G, nodes, weight)
+            clusterc = {
+                v: 0 if t == 0 else t / ((dt * (dt - 1) - 2 * db) * 2)
+                for v, dt, db, t in td_iter
+            }
+        else:
+            td_iter = _directed_triangles_and_degree_iter(G, nodes)
+            clusterc = {
+                v: 0 if t == 0 else t / ((dt * (dt - 1) - 2 * db) * 2)
+                for v, dt, db, t in td_iter
+            }
+    else:
+        # The formula 2*T/(d*(d-1)) from docs is t/(d*(d-1)) here b/c t==2*T
+        if weight is not None:
+            td_iter = _weighted_triangles_and_degree_iter(G, nodes, weight)
+            clusterc = {v: 0 if t == 0 else t / (d * (d - 1)) for v, d, t in td_iter}
+        else:
+            td_iter = _triangles_and_degree_iter(G, nodes)
+            clusterc = {v: 0 if t == 0 else t / (d * (d - 1)) for v, d, t, _ in td_iter}
+    if nodes in G:
+        # Return the value of the sole entry in the dictionary.
+        return clusterc[nodes]
+    return clusterc
+
+
+def transitivity(G):
+    r"""Compute graph transitivity, the fraction of all possible triangles
+    present in G.
+
+    Possible triangles are identified by the number of "triads"
+    (two edges with a shared vertex).
+
+    The transitivity is
+
+    .. math::
+
+        T = 3\frac{\#triangles}{\#triads}.
+
+    Parameters
+    ----------
+    G : graph
+
+    Returns
+    -------
+    out : float
+       Transitivity
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> print(nx.transitivity(G))
+    1.0
+    """
+    triangles_contri = [
+        (t, d * (d - 1)) for v, d, t, _ in _triangles_and_degree_iter(G)
+    ]
+    # If the graph is empty
+    if len(triangles_contri) == 0:
+        return 0
+    triangles, contri = map(sum, zip(*triangles_contri))
+    return 0 if triangles == 0 else triangles / contri
+
+
+def square_clustering(G, nodes=None):
+    r"""Compute the squares clustering coefficient for nodes.
+
+    For each node return the fraction of possible squares that exist at
+    the node [1]_
+
+    .. math::
+       C_4(v) = \frac{ \sum_{u=1}^{k_v}
+       \sum_{w=u+1}^{k_v} q_v(u,w) }{ \sum_{u=1}^{k_v}
+       \sum_{w=u+1}^{k_v} [a_v(u,w) + q_v(u,w)]},
+
+    where :math:`q_v(u,w)` are the number of common neighbors of :math:`u` and
+    :math:`w` other than :math:`v` (ie squares), and :math:`a_v(u,w) = (k_u -
+    (1+q_v(u,w)+\theta_{uv})) + (k_w - (1+q_v(u,w)+\theta_{uw}))`, where
+    :math:`\theta_{uw} = 1` if :math:`u` and :math:`w` are connected and 0
+    otherwise. [2]_
+
+    Parameters
+    ----------
+    G : graph
+
+    nodes : container of nodes, optional (default=all nodes in G)
+       Compute clustering for nodes in this container.
+
+    Returns
+    -------
+    c4 : dictionary
+       A dictionary keyed by node with the square clustering coefficient value.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> print(nx.square_clustering(G, 0))
+    1.0
+    >>> print(nx.square_clustering(G))
+    {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0}
+
+    Notes
+    -----
+    While :math:`C_3(v)` (triangle clustering) gives the probability that
+    two neighbors of node v are connected with each other, :math:`C_4(v)` is
+    the probability that two neighbors of node v share a common
+    neighbor different from v. This algorithm can be applied to both
+    bipartite and unipartite networks.
+
+    References
+    ----------
+    .. [1] Pedro G. Lind, Marta C. González, and Hans J. Herrmann. 2005
+        Cycles and clustering in bipartite networks.
+        Physical Review E (72) 056127.
+    .. [2] Zhang, Peng et al. Clustering Coefficient and Community Structure of
+        Bipartite Networks. Physica A: Statistical Mechanics and its Applications 387.27 (2008): 6869–6875.
+        https://arxiv.org/abs/0710.0117v1
+    """
+    if nodes is None:
+        node_iter = G
+    else:
+        node_iter = G.nbunch_iter(nodes)
+    clustering = {}
+    for v in node_iter:
+        clustering[v] = 0
+        potential = 0
+        for u, w in combinations(G[v], 2):
+            squares = len((set(G[u]) & set(G[w])) - {v})
+            clustering[v] += squares
+            degm = squares + 1
+            if w in G[u]:
+                degm += 1
+            potential += (len(G[u]) - degm) + (len(G[w]) - degm) + squares
+        if potential > 0:
+            clustering[v] /= potential
+    if nodes in G:
+        # Return the value of the sole entry in the dictionary.
+        return clustering[nodes]
+    return clustering
+
+
+@not_implemented_for("directed")
+def generalized_degree(G, nodes=None):
+    r"""Compute the generalized degree for nodes.
+
+    For each node, the generalized degree shows how many edges of given
+    triangle multiplicity the node is connected to. The triangle multiplicity
+    of an edge is the number of triangles an edge participates in. The
+    generalized degree of node :math:`i` can be written as a vector
+    :math:`\mathbf{k}_i=(k_i^{(0)}, \dotsc, k_i^{(N-2)})` where
+    :math:`k_i^{(j)}` is the number of edges attached to node :math:`i` that
+    participate in :math:`j` triangles.
+
+    Parameters
+    ----------
+    G : graph
+
+    nodes : container of nodes, optional (default=all nodes in G)
+       Compute the generalized degree for nodes in this container.
+
+    Returns
+    -------
+    out : Counter, or dictionary of Counters
+       Generalized degree of specified nodes. The Counter is keyed by edge
+       triangle multiplicity.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> print(nx.generalized_degree(G, 0))
+    Counter({3: 4})
+    >>> print(nx.generalized_degree(G))
+    {0: Counter({3: 4}), 1: Counter({3: 4}), 2: Counter({3: 4}), 3: Counter({3: 4}), 4: Counter({3: 4})}
+
+    To recover the number of triangles attached to a node:
+
+    >>> k1 = nx.generalized_degree(G, 0)
+    >>> sum([k * v for k, v in k1.items()]) / 2 == nx.triangles(G, 0)
+    True
+
+    Notes
+    -----
+    In a network of N nodes, the highest triangle multiplicty an edge can have
+    is N-2.
+
+    The return value does not include a `zero` entry if no edges of a
+    particular triangle multiplicity are present.
+
+    The number of triangles node :math:`i` is attached to can be recovered from
+    the generalized degree :math:`\mathbf{k}_i=(k_i^{(0)}, \dotsc,
+    k_i^{(N-2)})` by :math:`(k_i^{(1)}+2k_i^{(2)}+\dotsc +(N-2)k_i^{(N-2)})/2`.
+
+    References
+    ----------
+    .. [1] Networks with arbitrary edge multiplicities by V. Zlatić,
+        D. Garlaschelli and G. Caldarelli, EPL (Europhysics Letters),
+        Volume 97, Number 2 (2012).
+        https://iopscience.iop.org/article/10.1209/0295-5075/97/28005
+    """
+    if nodes in G:
+        return next(_triangles_and_degree_iter(G, nodes))[3]
+    return {v: gd for v, d, t, gd in _triangles_and_degree_iter(G, nodes)}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/__init__.py
new file mode 100644
index 0000000..39381d9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/__init__.py
@@ -0,0 +1,4 @@
+from networkx.algorithms.coloring.greedy_coloring import *
+from networkx.algorithms.coloring.equitable_coloring import equitable_color
+
+__all__ = ["greedy_color", "equitable_color"]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/equitable_coloring.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/equitable_coloring.py
new file mode 100644
index 0000000..3072a0a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/equitable_coloring.py
@@ -0,0 +1,515 @@
+"""
+Equitable coloring of graphs with bounded degree.
+"""
+
+from collections import defaultdict
+
+import networkx as nx
+
+__all__ = ["equitable_color"]
+
+
+def is_coloring(G, coloring):
+    """Determine if the coloring is a valid coloring for the graph G."""
+    # Verify that the coloring is valid.
+    for (s, d) in G.edges:
+        if coloring[s] == coloring[d]:
+            return False
+    return True
+
+
+def is_equitable(G, coloring, num_colors=None):
+    """Determines if the coloring is valid and equitable for the graph G."""
+
+    if not is_coloring(G, coloring):
+        return False
+
+    # Verify whether it is equitable.
+    color_set_size = defaultdict(int)
+    for color in coloring.values():
+        color_set_size[color] += 1
+
+    if num_colors is not None:
+        for color in range(num_colors):
+            if color not in color_set_size:
+                # These colors do not have any vertices attached to them.
+                color_set_size[color] = 0
+
+    # If there are more than 2 distinct values, the coloring cannot be equitable
+    all_set_sizes = set(color_set_size.values())
+    if len(all_set_sizes) == 0 and num_colors is None:  # Was an empty graph
+        return True
+    elif len(all_set_sizes) == 1:
+        return True
+    elif len(all_set_sizes) == 2:
+        a, b = list(all_set_sizes)
+        return abs(a - b) <= 1
+    else:  # len(all_set_sizes) > 2:
+        return False
+
+
+def make_C_from_F(F):
+    C = defaultdict(lambda: [])
+    for node, color in F.items():
+        C[color].append(node)
+
+    return C
+
+
+def make_N_from_L_C(L, C):
+    nodes = L.keys()
+    colors = C.keys()
+    return {
+        (node, color): sum(1 for v in L[node] if v in C[color])
+        for node in nodes
+        for color in colors
+    }
+
+
+def make_H_from_C_N(C, N):
+    return {
+        (c1, c2): sum(1 for node in C[c1] if N[(node, c2)] == 0)
+        for c1 in C.keys()
+        for c2 in C.keys()
+    }
+
+
+def change_color(u, X, Y, N, H, F, C, L):
+    """Change the color of 'u' from X to Y and update N, H, F, C."""
+    assert F[u] == X and X != Y
+
+    # Change the class of 'u' from X to Y
+    F[u] = Y
+
+    for k in C.keys():
+        # 'u' witnesses an edge from k -> Y instead of from k -> X now.
+        if N[u, k] == 0:
+            H[(X, k)] -= 1
+            H[(Y, k)] += 1
+
+    for v in L[u]:
+        # 'v' has lost a neighbor in X and gained one in Y
+        N[(v, X)] -= 1
+        N[(v, Y)] += 1
+
+        if N[(v, X)] == 0:
+            # 'v' witnesses F[v] -> X
+            H[(F[v], X)] += 1
+
+        if N[(v, Y)] == 1:
+            # 'v' no longer witnesses F[v] -> Y
+            H[(F[v], Y)] -= 1
+
+    C[X].remove(u)
+    C[Y].append(u)
+
+
+def move_witnesses(src_color, dst_color, N, H, F, C, T_cal, L):
+    """Move witness along a path from src_color to dst_color."""
+    X = src_color
+    while X != dst_color:
+        Y = T_cal[X]
+        # Move _any_ witness from X to Y = T_cal[X]
+        w = next(x for x in C[X] if N[(x, Y)] == 0)
+        change_color(w, X, Y, N=N, H=H, F=F, C=C, L=L)
+        X = Y
+
+
+def pad_graph(G, num_colors):
+    """Add a disconnected complete clique K_p such that the number of nodes in
+    the graph becomes a multiple of `num_colors`.
+
+    Assumes that the graph's nodes are labelled using integers.
+
+    Returns the number of nodes with each color.
+    """
+
+    n_ = len(G)
+    r = num_colors - 1
+
+    # Ensure that the number of nodes in G is a multiple of (r + 1)
+    s = n_ // (r + 1)
+    if n_ != s * (r + 1):
+        p = (r + 1) - n_ % (r + 1)
+        s += 1
+
+        # Complete graph K_p between (imaginary) nodes [n_, ... , n_ + p]
+        K = nx.relabel_nodes(nx.complete_graph(p), {idx: idx + n_ for idx in range(p)})
+        G.add_edges_from(K.edges)
+
+    return s
+
+
+def procedure_P(V_minus, V_plus, N, H, F, C, L, excluded_colors=None):
+    """Procedure P as described in the paper."""
+
+    if excluded_colors is None:
+        excluded_colors = set()
+
+    A_cal = set()
+    T_cal = {}
+    R_cal = []
+
+    # BFS to determine A_cal, i.e. colors reachable from V-
+    reachable = [V_minus]
+    marked = set(reachable)
+    idx = 0
+
+    while idx < len(reachable):
+        pop = reachable[idx]
+        idx += 1
+
+        A_cal.add(pop)
+        R_cal.append(pop)
+
+        # TODO: Checking whether a color has been visited can be made faster by
+        # using a look-up table instead of testing for membership in a set by a
+        # logarithmic factor.
+        next_layer = []
+        for k in C.keys():
+            if (
+                H[(k, pop)] > 0
+                and k not in A_cal
+                and k not in excluded_colors
+                and k not in marked
+            ):
+                next_layer.append(k)
+
+        for dst in next_layer:
+            # Record that `dst` can reach `pop`
+            T_cal[dst] = pop
+
+        marked.update(next_layer)
+        reachable.extend(next_layer)
+
+    # Variables for the algorithm
+    b = len(C) - len(A_cal)
+
+    if V_plus in A_cal:
+        # Easy case: V+ is in A_cal
+        # Move one node from V+ to V- using T_cal to find the parents.
+        move_witnesses(V_plus, V_minus, N=N, H=H, F=F, C=C, T_cal=T_cal, L=L)
+    else:
+        # If there is a solo edge, we can resolve the situation by
+        # moving witnesses from B to A, making G[A] equitable and then
+        # recursively balancing G[B - w] with a different V_minus and
+        # but the same V_plus.
+
+        A_0 = set()
+        A_cal_0 = set()
+        num_terminal_sets_found = 0
+        made_equitable = False
+
+        for W_1 in R_cal[::-1]:
+
+            for v in C[W_1]:
+                X = None
+
+                for U in C.keys():
+                    if N[(v, U)] == 0 and U in A_cal and U != W_1:
+                        X = U
+
+                # v does not witness an edge in H[A_cal]
+                if X is None:
+                    continue
+
+                for U in C.keys():
+                    # Note: Departing from the paper here.
+                    if N[(v, U)] >= 1 and U not in A_cal:
+                        X_prime = U
+                        w = v
+
+                        try:
+                            # Finding the solo neighbor of w in X_prime
+                            y = next(
+                                node
+                                for node in L[w]
+                                if F[node] == X_prime and N[(node, W_1)] == 1
+                            )
+                        except StopIteration:
+                            pass
+                        else:
+                            W = W_1
+
+                            # Move w from W to X, now X has one extra node.
+                            change_color(w, W, X, N=N, H=H, F=F, C=C, L=L)
+
+                            # Move witness from X to V_minus, making the coloring
+                            # equitable.
+                            move_witnesses(
+                                src_color=X,
+                                dst_color=V_minus,
+                                N=N,
+                                H=H,
+                                F=F,
+                                C=C,
+                                T_cal=T_cal,
+                                L=L,
+                            )
+
+                            # Move y from X_prime to W, making W the correct size.
+                            change_color(y, X_prime, W, N=N, H=H, F=F, C=C, L=L)
+
+                            # Then call the procedure on G[B - y]
+                            procedure_P(
+                                V_minus=X_prime,
+                                V_plus=V_plus,
+                                N=N,
+                                H=H,
+                                C=C,
+                                F=F,
+                                L=L,
+                                excluded_colors=excluded_colors.union(A_cal),
+                            )
+                            made_equitable = True
+                            break
+
+                if made_equitable:
+                    break
+            else:
+                # No node in W_1 was found such that
+                # it had a solo-neighbor.
+                A_cal_0.add(W_1)
+                A_0.update(C[W_1])
+                num_terminal_sets_found += 1
+
+            if num_terminal_sets_found == b:
+                # Otherwise, construct the maximal independent set and find
+                # a pair of z_1, z_2 as in Case II.
+
+                # BFS to determine B_cal': the set of colors reachable from V+
+                B_cal_prime = set()
+                T_cal_prime = {}
+
+                reachable = [V_plus]
+                marked = set(reachable)
+                idx = 0
+                while idx < len(reachable):
+                    pop = reachable[idx]
+                    idx += 1
+
+                    B_cal_prime.add(pop)
+
+                    # No need to check for excluded_colors here because
+                    # they only exclude colors from A_cal
+                    next_layer = [
+                        k
+                        for k in C.keys()
+                        if H[(pop, k)] > 0 and k not in B_cal_prime and k not in marked
+                    ]
+
+                    for dst in next_layer:
+                        T_cal_prime[pop] = dst
+
+                    marked.update(next_layer)
+                    reachable.extend(next_layer)
+
+                # Construct the independent set of G[B']
+                I_set = set()
+                I_covered = set()
+                W_covering = {}
+
+                B_prime = [node for k in B_cal_prime for node in C[k]]
+
+                # Add the nodes in V_plus to I first.
+                for z in C[V_plus] + B_prime:
+                    if z in I_covered or F[z] not in B_cal_prime:
+                        continue
+
+                    I_set.add(z)
+                    I_covered.add(z)
+                    I_covered.update([nbr for nbr in L[z]])
+
+                    for w in L[z]:
+                        if F[w] in A_cal_0 and N[(z, F[w])] == 1:
+                            if w not in W_covering:
+                                W_covering[w] = z
+                            else:
+                                # Found z1, z2 which have the same solo
+                                # neighbor in some W
+                                z_1 = W_covering[w]
+                                # z_2 = z
+
+                                Z = F[z_1]
+                                W = F[w]
+
+                                # shift nodes along W, V-
+                                move_witnesses(
+                                    W, V_minus, N=N, H=H, F=F, C=C, T_cal=T_cal, L=L
+                                )
+
+                                # shift nodes along V+ to Z
+                                move_witnesses(
+                                    V_plus,
+                                    Z,
+                                    N=N,
+                                    H=H,
+                                    F=F,
+                                    C=C,
+                                    T_cal=T_cal_prime,
+                                    L=L,
+                                )
+
+                                # change color of z_1 to W
+                                change_color(z_1, Z, W, N=N, H=H, F=F, C=C, L=L)
+
+                                # change color of w to some color in B_cal
+                                W_plus = next(
+                                    k
+                                    for k in C.keys()
+                                    if N[(w, k)] == 0 and k not in A_cal
+                                )
+                                change_color(w, W, W_plus, N=N, H=H, F=F, C=C, L=L)
+
+                                # recurse with G[B \cup W*]
+                                excluded_colors.update(
+                                    [
+                                        k
+                                        for k in C.keys()
+                                        if k != W and k not in B_cal_prime
+                                    ]
+                                )
+                                procedure_P(
+                                    V_minus=W,
+                                    V_plus=W_plus,
+                                    N=N,
+                                    H=H,
+                                    C=C,
+                                    F=F,
+                                    L=L,
+                                    excluded_colors=excluded_colors,
+                                )
+
+                                made_equitable = True
+                                break
+
+                    if made_equitable:
+                        break
+                else:
+                    assert False, (
+                        "Must find a w which is the solo neighbor "
+                        "of two vertices in B_cal_prime."
+                    )
+
+            if made_equitable:
+                break
+
+
+def equitable_color(G, num_colors):
+    """Provides equitable (r + 1)-coloring for nodes of G in O(r * n^2) time
+    if deg(G) <= r. The algorithm is described in [1]_.
+
+    Attempts to color a graph using r colors, where no neighbors of a node
+    can have same color as the node itself and the number of nodes with each
+    color differ by at most 1.
+
+    Parameters
+    ----------
+    G : networkX graph
+       The nodes of this graph will be colored.
+
+    num_colors : number of colors to use
+       This number must be at least one more than the maximum degree of nodes
+       in the graph.
+
+    Returns
+    -------
+    A dictionary with keys representing nodes and values representing
+    corresponding coloring.
+
+    Examples
+    --------
+    >>> G = nx.cycle_graph(4)
+    >>> d = nx.coloring.equitable_color(G, num_colors=3)
+    >>> nx.algorithms.coloring.equitable_coloring.is_equitable(G, d)
+    True
+
+    Raises
+    ------
+    NetworkXAlgorithmError
+        If the maximum degree of the graph ``G`` is greater than
+        ``num_colors``.
+
+    References
+    ----------
+    .. [1] Kierstead, H. A., Kostochka, A. V., Mydlarz, M., & Szemerédi, E.
+        (2010). A fast algorithm for equitable coloring. Combinatorica, 30(2),
+        217-224.
+    """
+
+    # Map nodes to integers for simplicity later.
+    nodes_to_int = {}
+    int_to_nodes = {}
+
+    for idx, node in enumerate(G.nodes):
+        nodes_to_int[node] = idx
+        int_to_nodes[idx] = node
+
+    G = nx.relabel_nodes(G, nodes_to_int, copy=True)
+
+    # Basic graph statistics and sanity check.
+    if len(G.nodes) > 0:
+        r_ = max(G.degree(node) for node in G.nodes)
+    else:
+        r_ = 0
+
+    if r_ >= num_colors:
+        raise nx.NetworkXAlgorithmError(
+            f"Graph has maximum degree {r_}, needs "
+            f"{r_ + 1} (> {num_colors}) colors for guaranteed coloring."
+        )
+
+    # Ensure that the number of nodes in G is a multiple of (r + 1)
+    pad_graph(G, num_colors)
+
+    # Starting the algorithm.
+    # L = {node: list(G.neighbors(node)) for node in G.nodes}
+    L_ = {node: [] for node in G.nodes}
+
+    # Arbitrary equitable allocation of colors to nodes.
+    F = {node: idx % num_colors for idx, node in enumerate(G.nodes)}
+
+    C = make_C_from_F(F)
+
+    # The neighborhood is empty initially.
+    N = make_N_from_L_C(L_, C)
+
+    # Currently all nodes witness all edges.
+    H = make_H_from_C_N(C, N)
+
+    # Start of algorithm.
+    edges_seen = set()
+
+    for u in sorted(G.nodes):
+        for v in sorted(G.neighbors(u)):
+
+            # Do not double count edges if (v, u) has already been seen.
+            if (v, u) in edges_seen:
+                continue
+
+            edges_seen.add((u, v))
+
+            L_[u].append(v)
+            L_[v].append(u)
+
+            N[(u, F[v])] += 1
+            N[(v, F[u])] += 1
+
+            if F[u] != F[v]:
+                # Were 'u' and 'v' witnesses for F[u] -> F[v] or F[v] -> F[u]?
+                if N[(u, F[v])] == 1:
+                    H[F[u], F[v]] -= 1  # u cannot witness an edge between F[u], F[v]
+
+                if N[(v, F[u])] == 1:
+                    H[F[v], F[u]] -= 1  # v cannot witness an edge between F[v], F[u]
+
+        if N[(u, F[u])] != 0:
+            # Find the first color where 'u' does not have any neighbors.
+            Y = next(k for k in C.keys() if N[(u, k)] == 0)
+            X = F[u]
+            change_color(u, X, Y, N=N, H=H, F=F, C=C, L=L_)
+
+            # Procedure P
+            procedure_P(V_minus=X, V_plus=Y, N=N, H=H, F=F, C=C, L=L_)
+
+    return {int_to_nodes[x]: F[x] for x in int_to_nodes}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/greedy_coloring.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/greedy_coloring.py
new file mode 100644
index 0000000..329746c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/greedy_coloring.py
@@ -0,0 +1,550 @@
+"""
+Greedy graph coloring using various strategies.
+"""
+import itertools
+from collections import defaultdict, deque
+
+import networkx as nx
+from networkx.utils import arbitrary_element, py_random_state
+
+__all__ = [
+    "greedy_color",
+    "strategy_connected_sequential",
+    "strategy_connected_sequential_bfs",
+    "strategy_connected_sequential_dfs",
+    "strategy_independent_set",
+    "strategy_largest_first",
+    "strategy_random_sequential",
+    "strategy_saturation_largest_first",
+    "strategy_smallest_last",
+]
+
+
+def strategy_largest_first(G, colors):
+    """Returns a list of the nodes of ``G`` in decreasing order by
+    degree.
+
+    ``G`` is a NetworkX graph. ``colors`` is ignored.
+
+    """
+    return sorted(G, key=G.degree, reverse=True)
+
+
+@py_random_state(2)
+def strategy_random_sequential(G, colors, seed=None):
+    """Returns a random permutation of the nodes of ``G`` as a list.
+
+    ``G`` is a NetworkX graph. ``colors`` is ignored.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    """
+    nodes = list(G)
+    seed.shuffle(nodes)
+    return nodes
+
+
+def strategy_smallest_last(G, colors):
+    """Returns a deque of the nodes of ``G``, "smallest" last.
+
+    Specifically, the degrees of each node are tracked in a bucket queue.
+    From this, the node of minimum degree is repeatedly popped from the
+    graph, updating its neighbors' degrees.
+
+    ``G`` is a NetworkX graph. ``colors`` is ignored.
+
+    This implementation of the strategy runs in $O(n + m)$ time
+    (ignoring polylogarithmic factors), where $n$ is the number of nodes
+    and $m$ is the number of edges.
+
+    This strategy is related to :func:`strategy_independent_set`: if we
+    interpret each node removed as an independent set of size one, then
+    this strategy chooses an independent set of size one instead of a
+    maximal independent set.
+
+    """
+    H = G.copy()
+    result = deque()
+
+    # Build initial degree list (i.e. the bucket queue data structure)
+    degrees = defaultdict(set)  # set(), for fast random-access removals
+    lbound = float("inf")
+    for node, d in H.degree():
+        degrees[d].add(node)
+        lbound = min(lbound, d)  # Lower bound on min-degree.
+
+    def find_min_degree():
+        # Save time by starting the iterator at `lbound`, not 0.
+        # The value that we find will be our new `lbound`, which we set later.
+        return next(d for d in itertools.count(lbound) if d in degrees)
+
+    for _ in G:
+        # Pop a min-degree node and add it to the list.
+        min_degree = find_min_degree()
+        u = degrees[min_degree].pop()
+        if not degrees[min_degree]:  # Clean up the degree list.
+            del degrees[min_degree]
+        result.appendleft(u)
+
+        # Update degrees of removed node's neighbors.
+        for v in H[u]:
+            degree = H.degree(v)
+            degrees[degree].remove(v)
+            if not degrees[degree]:  # Clean up the degree list.
+                del degrees[degree]
+            degrees[degree - 1].add(v)
+
+        # Finally, remove the node.
+        H.remove_node(u)
+        lbound = min_degree - 1  # Subtract 1 in case of tied neighbors.
+
+    return result
+
+
+def _maximal_independent_set(G):
+    """Returns a maximal independent set of nodes in ``G`` by repeatedly
+    choosing an independent node of minimum degree (with respect to the
+    subgraph of unchosen nodes).
+
+    """
+    result = set()
+    remaining = set(G)
+    while remaining:
+        G = G.subgraph(remaining)
+        v = min(remaining, key=G.degree)
+        result.add(v)
+        remaining -= set(G[v]) | {v}
+    return result
+
+
+def strategy_independent_set(G, colors):
+    """Uses a greedy independent set removal strategy to determine the
+    colors.
+
+    This function updates ``colors`` **in-place** and return ``None``,
+    unlike the other strategy functions in this module.
+
+    This algorithm repeatedly finds and removes a maximal independent
+    set, assigning each node in the set an unused color.
+
+    ``G`` is a NetworkX graph.
+
+    This strategy is related to :func:`strategy_smallest_last`: in that
+    strategy, an independent set of size one is chosen at each step
+    instead of a maximal independent set.
+
+    """
+    remaining_nodes = set(G)
+    while len(remaining_nodes) > 0:
+        nodes = _maximal_independent_set(G.subgraph(remaining_nodes))
+        remaining_nodes -= nodes
+        yield from nodes
+
+
+def strategy_connected_sequential_bfs(G, colors):
+    """Returns an iterable over nodes in ``G`` in the order given by a
+    breadth-first traversal.
+
+    The generated sequence has the property that for each node except
+    the first, at least one neighbor appeared earlier in the sequence.
+
+    ``G`` is a NetworkX graph. ``colors`` is ignored.
+
+    """
+    return strategy_connected_sequential(G, colors, "bfs")
+
+
+def strategy_connected_sequential_dfs(G, colors):
+    """Returns an iterable over nodes in ``G`` in the order given by a
+    depth-first traversal.
+
+    The generated sequence has the property that for each node except
+    the first, at least one neighbor appeared earlier in the sequence.
+
+    ``G`` is a NetworkX graph. ``colors`` is ignored.
+
+    """
+    return strategy_connected_sequential(G, colors, "dfs")
+
+
+def strategy_connected_sequential(G, colors, traversal="bfs"):
+    """Returns an iterable over nodes in ``G`` in the order given by a
+    breadth-first or depth-first traversal.
+
+    ``traversal`` must be one of the strings ``'dfs'`` or ``'bfs'``,
+    representing depth-first traversal or breadth-first traversal,
+    respectively.
+
+    The generated sequence has the property that for each node except
+    the first, at least one neighbor appeared earlier in the sequence.
+
+    ``G`` is a NetworkX graph. ``colors`` is ignored.
+
+    """
+    if traversal == "bfs":
+        traverse = nx.bfs_edges
+    elif traversal == "dfs":
+        traverse = nx.dfs_edges
+    else:
+        raise nx.NetworkXError(
+            "Please specify one of the strings 'bfs' or"
+            " 'dfs' for connected sequential ordering"
+        )
+    for component in nx.connected_components(G):
+        source = arbitrary_element(component)
+        # Yield the source node, then all the nodes in the specified
+        # traversal order.
+        yield source
+        for (_, end) in traverse(G.subgraph(component), source):
+            yield end
+
+
+def strategy_saturation_largest_first(G, colors):
+    """Iterates over all the nodes of ``G`` in "saturation order" (also
+    known as "DSATUR").
+
+    ``G`` is a NetworkX graph. ``colors`` is a dictionary mapping nodes of
+    ``G`` to colors, for those nodes that have already been colored.
+
+    """
+    distinct_colors = {v: set() for v in G}
+    for i in range(len(G)):
+        # On the first time through, simply choose the node of highest degree.
+        if i == 0:
+            node = max(G, key=G.degree)
+            yield node
+            # Add the color 0 to the distinct colors set for each
+            # neighbors of that node.
+            for v in G[node]:
+                distinct_colors[v].add(0)
+        else:
+            # Compute the maximum saturation and the set of nodes that
+            # achieve that saturation.
+            saturation = {
+                v: len(c) for v, c in distinct_colors.items() if v not in colors
+            }
+            # Yield the node with the highest saturation, and break ties by
+            # degree.
+            node = max(saturation, key=lambda v: (saturation[v], G.degree(v)))
+            yield node
+            # Update the distinct color sets for the neighbors.
+            color = colors[node]
+            for v in G[node]:
+                distinct_colors[v].add(color)
+
+
+#: Dictionary mapping name of a strategy as a string to the strategy function.
+STRATEGIES = {
+    "largest_first": strategy_largest_first,
+    "random_sequential": strategy_random_sequential,
+    "smallest_last": strategy_smallest_last,
+    "independent_set": strategy_independent_set,
+    "connected_sequential_bfs": strategy_connected_sequential_bfs,
+    "connected_sequential_dfs": strategy_connected_sequential_dfs,
+    "connected_sequential": strategy_connected_sequential,
+    "saturation_largest_first": strategy_saturation_largest_first,
+    "DSATUR": strategy_saturation_largest_first,
+}
+
+
+def greedy_color(G, strategy="largest_first", interchange=False):
+    """Color a graph using various strategies of greedy graph coloring.
+
+    Attempts to color a graph using as few colors as possible, where no
+    neighbours of a node can have same color as the node itself. The
+    given strategy determines the order in which nodes are colored.
+
+    The strategies are described in [1]_, and smallest-last is based on
+    [2]_.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    strategy : string or function(G, colors)
+       A function (or a string representing a function) that provides
+       the coloring strategy, by returning nodes in the ordering they
+       should be colored. ``G`` is the graph, and ``colors`` is a
+       dictionary of the currently assigned colors, keyed by nodes. The
+       function must return an iterable over all the nodes in ``G``.
+
+       If the strategy function is an iterator generator (that is, a
+       function with ``yield`` statements), keep in mind that the
+       ``colors`` dictionary will be updated after each ``yield``, since
+       this function chooses colors greedily.
+
+       If ``strategy`` is a string, it must be one of the following,
+       each of which represents one of the built-in strategy functions.
+
+       * ``'largest_first'``
+       * ``'random_sequential'``
+       * ``'smallest_last'``
+       * ``'independent_set'``
+       * ``'connected_sequential_bfs'``
+       * ``'connected_sequential_dfs'``
+       * ``'connected_sequential'`` (alias for the previous strategy)
+       * ``'saturation_largest_first'``
+       * ``'DSATUR'`` (alias for the previous strategy)
+
+    interchange: bool
+       Will use the color interchange algorithm described by [3]_ if set
+       to ``True``.
+
+       Note that ``saturation_largest_first`` and ``independent_set``
+       do not work with interchange. Furthermore, if you use
+       interchange with your own strategy function, you cannot rely
+       on the values in the ``colors`` argument.
+
+    Returns
+    -------
+    A dictionary with keys representing nodes and values representing
+    corresponding coloring.
+
+    Examples
+    --------
+    >>> G = nx.cycle_graph(4)
+    >>> d = nx.coloring.greedy_color(G, strategy="largest_first")
+    >>> d in [{0: 0, 1: 1, 2: 0, 3: 1}, {0: 1, 1: 0, 2: 1, 3: 0}]
+    True
+
+    Raises
+    ------
+    NetworkXPointlessConcept
+        If ``strategy`` is ``saturation_largest_first`` or
+        ``independent_set`` and ``interchange`` is ``True``.
+
+    References
+    ----------
+    .. [1] Adrian Kosowski, and Krzysztof Manuszewski,
+       Classical Coloring of Graphs, Graph Colorings, 2-19, 2004.
+       ISBN 0-8218-3458-4.
+    .. [2] David W. Matula, and Leland L. Beck, "Smallest-last
+       ordering and clustering and graph coloring algorithms." *J. ACM* 30,
+       3 (July 1983), 417–427. <https://doi.org/10.1145/2402.322385>
+    .. [3] Maciej M. Sysło, Narsingh Deo, Janusz S. Kowalik,
+       Discrete Optimization Algorithms with Pascal Programs, 415-424, 1983.
+       ISBN 0-486-45353-7.
+
+    """
+    if len(G) == 0:
+        return {}
+    # Determine the strategy provided by the caller.
+    strategy = STRATEGIES.get(strategy, strategy)
+    if not callable(strategy):
+        raise nx.NetworkXError(
+            "strategy must be callable or a valid string. " f"{strategy} not valid."
+        )
+    # Perform some validation on the arguments before executing any
+    # strategy functions.
+    if interchange:
+        if strategy is strategy_independent_set:
+            msg = "interchange cannot be used with independent_set"
+            raise nx.NetworkXPointlessConcept(msg)
+        if strategy is strategy_saturation_largest_first:
+            msg = "interchange cannot be used with" " saturation_largest_first"
+            raise nx.NetworkXPointlessConcept(msg)
+    colors = {}
+    nodes = strategy(G, colors)
+    if interchange:
+        return _greedy_coloring_with_interchange(G, nodes)
+    for u in nodes:
+        # Set to keep track of colors of neighbours
+        neighbour_colors = {colors[v] for v in G[u] if v in colors}
+        # Find the first unused color.
+        for color in itertools.count():
+            if color not in neighbour_colors:
+                break
+        # Assign the new color to the current node.
+        colors[u] = color
+    return colors
+
+
+# Tools for coloring with interchanges
+class _Node:
+    __slots__ = ["node_id", "color", "adj_list", "adj_color"]
+
+    def __init__(self, node_id, n):
+        self.node_id = node_id
+        self.color = -1
+        self.adj_list = None
+        self.adj_color = [None for _ in range(n)]
+
+    def __repr__(self):
+        return (
+            f"Node_id: {self.node_id}, Color: {self.color}, "
+            f"Adj_list: ({self.adj_list}), adj_color: ({self.adj_color})"
+        )
+
+    def assign_color(self, adj_entry, color):
+        adj_entry.col_prev = None
+        adj_entry.col_next = self.adj_color[color]
+        self.adj_color[color] = adj_entry
+        if adj_entry.col_next is not None:
+            adj_entry.col_next.col_prev = adj_entry
+
+    def clear_color(self, adj_entry, color):
+        if adj_entry.col_prev is None:
+            self.adj_color[color] = adj_entry.col_next
+        else:
+            adj_entry.col_prev.col_next = adj_entry.col_next
+        if adj_entry.col_next is not None:
+            adj_entry.col_next.col_prev = adj_entry.col_prev
+
+    def iter_neighbors(self):
+        adj_node = self.adj_list
+        while adj_node is not None:
+            yield adj_node
+            adj_node = adj_node.next
+
+    def iter_neighbors_color(self, color):
+        adj_color_node = self.adj_color[color]
+        while adj_color_node is not None:
+            yield adj_color_node.node_id
+            adj_color_node = adj_color_node.col_next
+
+
+class _AdjEntry:
+    __slots__ = ["node_id", "next", "mate", "col_next", "col_prev"]
+
+    def __init__(self, node_id):
+        self.node_id = node_id
+        self.next = None
+        self.mate = None
+        self.col_next = None
+        self.col_prev = None
+
+    def __repr__(self):
+        col_next = None if self.col_next is None else self.col_next.node_id
+        col_prev = None if self.col_prev is None else self.col_prev.node_id
+        return (
+            f"Node_id: {self.node_id}, Next: ({self.next}), "
+            f"Mate: ({self.mate.node_id}), "
+            f"col_next: ({col_next}), col_prev: ({col_prev})"
+        )
+
+
+def _greedy_coloring_with_interchange(G, nodes):
+    """Return a coloring for `orginal_graph` using interchange approach
+
+    This procedure is an adaption of the algorithm described by [1]_,
+    and is an implementation of coloring with interchange. Please be
+    advised, that the datastructures used are rather complex because
+    they are optimized to minimize the time spent identifying
+    subcomponents of the graph, which are possible candidates for color
+    interchange.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The graph to be colored
+
+    nodes : list
+        nodes ordered using the strategy of choice
+
+    Returns
+    -------
+    dict :
+        A dictionary keyed by node to a color value
+
+    References
+    ----------
+    .. [1] Maciej M. Syslo, Narsingh Deo, Janusz S. Kowalik,
+       Discrete Optimization Algorithms with Pascal Programs, 415-424, 1983.
+       ISBN 0-486-45353-7.
+    """
+    n = len(G)
+
+    graph = {node: _Node(node, n) for node in G}
+
+    for (node1, node2) in G.edges():
+        adj_entry1 = _AdjEntry(node2)
+        adj_entry2 = _AdjEntry(node1)
+        adj_entry1.mate = adj_entry2
+        adj_entry2.mate = adj_entry1
+        node1_head = graph[node1].adj_list
+        adj_entry1.next = node1_head
+        graph[node1].adj_list = adj_entry1
+        node2_head = graph[node2].adj_list
+        adj_entry2.next = node2_head
+        graph[node2].adj_list = adj_entry2
+
+    k = 0
+    for node in nodes:
+        # Find the smallest possible, unused color
+        neighbors = graph[node].iter_neighbors()
+        col_used = {graph[adj_node.node_id].color for adj_node in neighbors}
+        col_used.discard(-1)
+        k1 = next(itertools.dropwhile(lambda x: x in col_used, itertools.count()))
+
+        # k1 is now the lowest available color
+        if k1 > k:
+            connected = True
+            visited = set()
+            col1 = -1
+            col2 = -1
+            while connected and col1 < k:
+                col1 += 1
+                neighbor_cols = graph[node].iter_neighbors_color(col1)
+                col1_adj = [it for it in neighbor_cols]
+
+                col2 = col1
+                while connected and col2 < k:
+                    col2 += 1
+                    visited = set(col1_adj)
+                    frontier = list(col1_adj)
+                    i = 0
+                    while i < len(frontier):
+                        search_node = frontier[i]
+                        i += 1
+                        col_opp = col2 if graph[search_node].color == col1 else col1
+                        neighbor_cols = graph[search_node].iter_neighbors_color(col_opp)
+
+                        for neighbor in neighbor_cols:
+                            if neighbor not in visited:
+                                visited.add(neighbor)
+                                frontier.append(neighbor)
+
+                    # Search if node is not adj to any col2 vertex
+                    connected = (
+                        len(
+                            visited.intersection(graph[node].iter_neighbors_color(col2))
+                        )
+                        > 0
+                    )
+
+            # If connected is false then we can swap !!!
+            if not connected:
+                # Update all the nodes in the component
+                for search_node in visited:
+                    graph[search_node].color = (
+                        col2 if graph[search_node].color == col1 else col1
+                    )
+                    col2_adj = graph[search_node].adj_color[col2]
+                    graph[search_node].adj_color[col2] = graph[search_node].adj_color[
+                        col1
+                    ]
+                    graph[search_node].adj_color[col1] = col2_adj
+
+                # Update all the neighboring nodes
+                for search_node in visited:
+                    col = graph[search_node].color
+                    col_opp = col1 if col == col2 else col2
+                    for adj_node in graph[search_node].iter_neighbors():
+                        if graph[adj_node.node_id].color != col_opp:
+                            # Direct reference to entry
+                            adj_mate = adj_node.mate
+                            graph[adj_node.node_id].clear_color(adj_mate, col_opp)
+                            graph[adj_node.node_id].assign_color(adj_mate, col)
+                k1 = col1
+
+        # We can color this node color k1
+        graph[node].color = k1
+        k = max(k1, k)
+
+        # Update the neighbors of this node
+        for adj_node in graph[node].iter_neighbors():
+            adj_mate = adj_node.mate
+            graph[adj_node.node_id].assign_color(adj_mate, k1)
+
+    return {node.node_id: node.color for node in graph.values()}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/tests/test_coloring.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/tests/test_coloring.py
new file mode 100644
index 0000000..cc422e3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/coloring/tests/test_coloring.py
@@ -0,0 +1,793 @@
+"""Greedy coloring test suite.
+
+"""
+
+import pytest
+
+import networkx as nx
+
+is_coloring = nx.algorithms.coloring.equitable_coloring.is_coloring
+is_equitable = nx.algorithms.coloring.equitable_coloring.is_equitable
+
+
+ALL_STRATEGIES = [
+    "largest_first",
+    "random_sequential",
+    "smallest_last",
+    "independent_set",
+    "connected_sequential_bfs",
+    "connected_sequential_dfs",
+    "connected_sequential",
+    "saturation_largest_first",
+    "DSATUR",
+]
+
+# List of strategies where interchange=True results in an error
+INTERCHANGE_INVALID = ["independent_set", "saturation_largest_first", "DSATUR"]
+
+
+class TestColoring:
+    def test_basic_cases(self):
+        def check_basic_case(graph_func, n_nodes, strategy, interchange):
+            graph = graph_func()
+            coloring = nx.coloring.greedy_color(
+                graph, strategy=strategy, interchange=interchange
+            )
+            assert verify_length(coloring, n_nodes)
+            assert verify_coloring(graph, coloring)
+
+        for graph_func, n_nodes in BASIC_TEST_CASES.items():
+            for interchange in [True, False]:
+                for strategy in ALL_STRATEGIES:
+                    check_basic_case(graph_func, n_nodes, strategy, False)
+                    if strategy not in INTERCHANGE_INVALID:
+                        check_basic_case(graph_func, n_nodes, strategy, True)
+
+    def test_special_cases(self):
+        def check_special_case(strategy, graph_func, interchange, colors):
+            graph = graph_func()
+            coloring = nx.coloring.greedy_color(
+                graph, strategy=strategy, interchange=interchange
+            )
+            if not hasattr(colors, "__len__"):
+                colors = [colors]
+            assert any(verify_length(coloring, n_colors) for n_colors in colors)
+            assert verify_coloring(graph, coloring)
+
+        for strategy, arglist in SPECIAL_TEST_CASES.items():
+            for args in arglist:
+                check_special_case(strategy, args[0], args[1], args[2])
+
+    def test_interchange_invalid(self):
+        graph = one_node_graph()
+        for strategy in INTERCHANGE_INVALID:
+            pytest.raises(
+                nx.NetworkXPointlessConcept,
+                nx.coloring.greedy_color,
+                graph,
+                strategy=strategy,
+                interchange=True,
+            )
+
+    def test_bad_inputs(self):
+        graph = one_node_graph()
+        pytest.raises(
+            nx.NetworkXError,
+            nx.coloring.greedy_color,
+            graph,
+            strategy="invalid strategy",
+        )
+
+    def test_strategy_as_function(self):
+        graph = lf_shc()
+        colors_1 = nx.coloring.greedy_color(graph, "largest_first")
+        colors_2 = nx.coloring.greedy_color(graph, nx.coloring.strategy_largest_first)
+        assert colors_1 == colors_2
+
+    def test_seed_argument(self):
+        graph = lf_shc()
+        rs = nx.coloring.strategy_random_sequential
+        c1 = nx.coloring.greedy_color(graph, lambda g, c: rs(g, c, seed=1))
+        for u, v in graph.edges:
+            assert c1[u] != c1[v]
+
+    def test_is_coloring(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (1, 2)])
+        coloring = {0: 0, 1: 1, 2: 0}
+        assert is_coloring(G, coloring)
+
+        coloring[0] = 1
+        assert not is_coloring(G, coloring)
+        assert not is_equitable(G, coloring)
+
+    def test_is_equitable(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (1, 2)])
+        coloring = {0: 0, 1: 1, 2: 0}
+        assert is_equitable(G, coloring)
+
+        G.add_edges_from([(2, 3), (2, 4), (2, 5)])
+        coloring[3] = 1
+        coloring[4] = 1
+        coloring[5] = 1
+        assert is_coloring(G, coloring)
+        assert not is_equitable(G, coloring)
+
+    def test_num_colors(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (0, 3)])
+        pytest.raises(nx.NetworkXAlgorithmError, nx.coloring.equitable_color, G, 2)
+
+    def test_equitable_color(self):
+        G = nx.fast_gnp_random_graph(n=10, p=0.2, seed=42)
+        coloring = nx.coloring.equitable_color(G, max_degree(G) + 1)
+        assert is_equitable(G, coloring)
+
+    def test_equitable_color_empty(self):
+        G = nx.empty_graph()
+        coloring = nx.coloring.equitable_color(G, max_degree(G) + 1)
+        assert is_equitable(G, coloring)
+
+    def test_equitable_color_large(self):
+        G = nx.fast_gnp_random_graph(100, 0.1, seed=42)
+        coloring = nx.coloring.equitable_color(G, max_degree(G) + 1)
+        assert is_equitable(G, coloring, num_colors=max_degree(G) + 1)
+
+    def test_case_V_plus_not_in_A_cal(self):
+        # Hand crafted case to avoid the easy case.
+        L = {
+            0: [2, 5],
+            1: [3, 4],
+            2: [0, 8],
+            3: [1, 7],
+            4: [1, 6],
+            5: [0, 6],
+            6: [4, 5],
+            7: [3],
+            8: [2],
+        }
+
+        F = {
+            # Color 0
+            0: 0,
+            1: 0,
+            # Color 1
+            2: 1,
+            3: 1,
+            4: 1,
+            5: 1,
+            # Color 2
+            6: 2,
+            7: 2,
+            8: 2,
+        }
+
+        C = nx.algorithms.coloring.equitable_coloring.make_C_from_F(F)
+        N = nx.algorithms.coloring.equitable_coloring.make_N_from_L_C(L, C)
+        H = nx.algorithms.coloring.equitable_coloring.make_H_from_C_N(C, N)
+
+        nx.algorithms.coloring.equitable_coloring.procedure_P(
+            V_minus=0, V_plus=1, N=N, H=H, F=F, C=C, L=L
+        )
+        check_state(L=L, N=N, H=H, F=F, C=C)
+
+    def test_cast_no_solo(self):
+        L = {
+            0: [8, 9],
+            1: [10, 11],
+            2: [8],
+            3: [9],
+            4: [10, 11],
+            5: [8],
+            6: [9],
+            7: [10, 11],
+            8: [0, 2, 5],
+            9: [0, 3, 6],
+            10: [1, 4, 7],
+            11: [1, 4, 7],
+        }
+
+        F = {0: 0, 1: 0, 2: 2, 3: 2, 4: 2, 5: 3, 6: 3, 7: 3, 8: 1, 9: 1, 10: 1, 11: 1}
+
+        C = nx.algorithms.coloring.equitable_coloring.make_C_from_F(F)
+        N = nx.algorithms.coloring.equitable_coloring.make_N_from_L_C(L, C)
+        H = nx.algorithms.coloring.equitable_coloring.make_H_from_C_N(C, N)
+
+        nx.algorithms.coloring.equitable_coloring.procedure_P(
+            V_minus=0, V_plus=1, N=N, H=H, F=F, C=C, L=L
+        )
+        check_state(L=L, N=N, H=H, F=F, C=C)
+
+    def test_hard_prob(self):
+        # Tests for two levels of recursion.
+        num_colors, s = 5, 5
+
+        G = nx.Graph()
+        G.add_edges_from(
+            [
+                (0, 10),
+                (0, 11),
+                (0, 12),
+                (0, 23),
+                (10, 4),
+                (10, 9),
+                (10, 20),
+                (11, 4),
+                (11, 8),
+                (11, 16),
+                (12, 9),
+                (12, 22),
+                (12, 23),
+                (23, 7),
+                (1, 17),
+                (1, 18),
+                (1, 19),
+                (1, 24),
+                (17, 5),
+                (17, 13),
+                (17, 22),
+                (18, 5),
+                (19, 5),
+                (19, 6),
+                (19, 8),
+                (24, 7),
+                (24, 16),
+                (2, 4),
+                (2, 13),
+                (2, 14),
+                (2, 15),
+                (4, 6),
+                (13, 5),
+                (13, 21),
+                (14, 6),
+                (14, 15),
+                (15, 6),
+                (15, 21),
+                (3, 16),
+                (3, 20),
+                (3, 21),
+                (3, 22),
+                (16, 8),
+                (20, 8),
+                (21, 9),
+                (22, 7),
+            ]
+        )
+        F = {node: node // s for node in range(num_colors * s)}
+        F[s - 1] = num_colors - 1
+
+        params = make_params_from_graph(G=G, F=F)
+
+        nx.algorithms.coloring.equitable_coloring.procedure_P(
+            V_minus=0, V_plus=num_colors - 1, **params
+        )
+        check_state(**params)
+
+    def test_hardest_prob(self):
+        # Tests for two levels of recursion.
+        num_colors, s = 10, 4
+
+        G = nx.Graph()
+        G.add_edges_from(
+            [
+                (0, 19),
+                (0, 24),
+                (0, 29),
+                (0, 30),
+                (0, 35),
+                (19, 3),
+                (19, 7),
+                (19, 9),
+                (19, 15),
+                (19, 21),
+                (19, 24),
+                (19, 30),
+                (19, 38),
+                (24, 5),
+                (24, 11),
+                (24, 13),
+                (24, 20),
+                (24, 30),
+                (24, 37),
+                (24, 38),
+                (29, 6),
+                (29, 10),
+                (29, 13),
+                (29, 15),
+                (29, 16),
+                (29, 17),
+                (29, 20),
+                (29, 26),
+                (30, 6),
+                (30, 10),
+                (30, 15),
+                (30, 22),
+                (30, 23),
+                (30, 39),
+                (35, 6),
+                (35, 9),
+                (35, 14),
+                (35, 18),
+                (35, 22),
+                (35, 23),
+                (35, 25),
+                (35, 27),
+                (1, 20),
+                (1, 26),
+                (1, 31),
+                (1, 34),
+                (1, 38),
+                (20, 4),
+                (20, 8),
+                (20, 14),
+                (20, 18),
+                (20, 28),
+                (20, 33),
+                (26, 7),
+                (26, 10),
+                (26, 14),
+                (26, 18),
+                (26, 21),
+                (26, 32),
+                (26, 39),
+                (31, 5),
+                (31, 8),
+                (31, 13),
+                (31, 16),
+                (31, 17),
+                (31, 21),
+                (31, 25),
+                (31, 27),
+                (34, 7),
+                (34, 8),
+                (34, 13),
+                (34, 18),
+                (34, 22),
+                (34, 23),
+                (34, 25),
+                (34, 27),
+                (38, 4),
+                (38, 9),
+                (38, 12),
+                (38, 14),
+                (38, 21),
+                (38, 27),
+                (2, 3),
+                (2, 18),
+                (2, 21),
+                (2, 28),
+                (2, 32),
+                (2, 33),
+                (2, 36),
+                (2, 37),
+                (2, 39),
+                (3, 5),
+                (3, 9),
+                (3, 13),
+                (3, 22),
+                (3, 23),
+                (3, 25),
+                (3, 27),
+                (18, 6),
+                (18, 11),
+                (18, 15),
+                (18, 39),
+                (21, 4),
+                (21, 10),
+                (21, 14),
+                (21, 36),
+                (28, 6),
+                (28, 10),
+                (28, 14),
+                (28, 16),
+                (28, 17),
+                (28, 25),
+                (28, 27),
+                (32, 5),
+                (32, 10),
+                (32, 12),
+                (32, 16),
+                (32, 17),
+                (32, 22),
+                (32, 23),
+                (33, 7),
+                (33, 10),
+                (33, 12),
+                (33, 16),
+                (33, 17),
+                (33, 25),
+                (33, 27),
+                (36, 5),
+                (36, 8),
+                (36, 15),
+                (36, 16),
+                (36, 17),
+                (36, 25),
+                (36, 27),
+                (37, 5),
+                (37, 11),
+                (37, 15),
+                (37, 16),
+                (37, 17),
+                (37, 22),
+                (37, 23),
+                (39, 7),
+                (39, 8),
+                (39, 15),
+                (39, 22),
+                (39, 23),
+            ]
+        )
+        F = {node: node // s for node in range(num_colors * s)}
+        F[s - 1] = num_colors - 1  # V- = 0, V+ = num_colors - 1
+
+        params = make_params_from_graph(G=G, F=F)
+
+        nx.algorithms.coloring.equitable_coloring.procedure_P(
+            V_minus=0, V_plus=num_colors - 1, **params
+        )
+        check_state(**params)
+
+
+#  ############################  Utility functions ############################
+def verify_coloring(graph, coloring):
+    for node in graph.nodes():
+        if node not in coloring:
+            return False
+
+        color = coloring[node]
+        for neighbor in graph.neighbors(node):
+            if coloring[neighbor] == color:
+                return False
+
+    return True
+
+
+def verify_length(coloring, expected):
+    coloring = dict_to_sets(coloring)
+    return len(coloring) == expected
+
+
+def dict_to_sets(colors):
+    if len(colors) == 0:
+        return []
+
+    k = max(colors.values()) + 1
+    sets = [set() for _ in range(k)]
+
+    for (node, color) in colors.items():
+        sets[color].add(node)
+
+    return sets
+
+
+#  ############################  Graph Generation ############################
+
+
+def empty_graph():
+    return nx.Graph()
+
+
+def one_node_graph():
+    graph = nx.Graph()
+    graph.add_nodes_from([1])
+    return graph
+
+
+def two_node_graph():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2])
+    graph.add_edges_from([(1, 2)])
+    return graph
+
+
+def three_node_clique():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3])
+    graph.add_edges_from([(1, 2), (1, 3), (2, 3)])
+    return graph
+
+
+def disconnected():
+    graph = nx.Graph()
+    graph.add_edges_from([(1, 2), (2, 3), (4, 5), (5, 6)])
+    return graph
+
+
+def rs_shc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4])
+    graph.add_edges_from([(1, 2), (2, 3), (3, 4)])
+    return graph
+
+
+def slf_shc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6, 7])
+    graph.add_edges_from(
+        [(1, 2), (1, 5), (1, 6), (2, 3), (2, 7), (3, 4), (3, 7), (4, 5), (4, 6), (5, 6)]
+    )
+    return graph
+
+
+def slf_hc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8])
+    graph.add_edges_from(
+        [
+            (1, 2),
+            (1, 3),
+            (1, 4),
+            (1, 5),
+            (2, 3),
+            (2, 4),
+            (2, 6),
+            (5, 7),
+            (5, 8),
+            (6, 7),
+            (6, 8),
+            (7, 8),
+        ]
+    )
+    return graph
+
+
+def lf_shc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6])
+    graph.add_edges_from([(6, 1), (1, 4), (4, 3), (3, 2), (2, 5)])
+    return graph
+
+
+def lf_hc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6, 7])
+    graph.add_edges_from(
+        [
+            (1, 7),
+            (1, 6),
+            (1, 3),
+            (1, 4),
+            (7, 2),
+            (2, 6),
+            (2, 3),
+            (2, 5),
+            (5, 3),
+            (5, 4),
+            (4, 3),
+        ]
+    )
+    return graph
+
+
+def sl_shc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6])
+    graph.add_edges_from(
+        [(1, 2), (1, 3), (2, 3), (1, 4), (2, 5), (3, 6), (4, 5), (4, 6), (5, 6)]
+    )
+    return graph
+
+
+def sl_hc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8])
+    graph.add_edges_from(
+        [
+            (1, 2),
+            (1, 3),
+            (1, 5),
+            (1, 7),
+            (2, 3),
+            (2, 4),
+            (2, 8),
+            (8, 4),
+            (8, 6),
+            (8, 7),
+            (7, 5),
+            (7, 6),
+            (3, 4),
+            (4, 6),
+            (6, 5),
+            (5, 3),
+        ]
+    )
+    return graph
+
+
+def gis_shc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4])
+    graph.add_edges_from([(1, 2), (2, 3), (3, 4)])
+    return graph
+
+
+def gis_hc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6])
+    graph.add_edges_from([(1, 5), (2, 5), (3, 6), (4, 6), (5, 6)])
+    return graph
+
+
+def cs_shc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5])
+    graph.add_edges_from([(1, 2), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (4, 5)])
+    return graph
+
+
+def rsi_shc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6])
+    graph.add_edges_from(
+        [(1, 2), (1, 5), (1, 6), (2, 3), (3, 4), (4, 5), (4, 6), (5, 6)]
+    )
+    return graph
+
+
+def lfi_shc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6, 7])
+    graph.add_edges_from(
+        [(1, 2), (1, 5), (1, 6), (2, 3), (2, 7), (3, 4), (3, 7), (4, 5), (4, 6), (5, 6)]
+    )
+    return graph
+
+
+def lfi_hc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8, 9])
+    graph.add_edges_from(
+        [
+            (1, 2),
+            (1, 5),
+            (1, 6),
+            (1, 7),
+            (2, 3),
+            (2, 8),
+            (2, 9),
+            (3, 4),
+            (3, 8),
+            (3, 9),
+            (4, 5),
+            (4, 6),
+            (4, 7),
+            (5, 6),
+        ]
+    )
+    return graph
+
+
+def sli_shc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6, 7])
+    graph.add_edges_from(
+        [
+            (1, 2),
+            (1, 3),
+            (1, 5),
+            (1, 7),
+            (2, 3),
+            (2, 6),
+            (3, 4),
+            (4, 5),
+            (4, 6),
+            (5, 7),
+            (6, 7),
+        ]
+    )
+    return graph
+
+
+def sli_hc():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8, 9])
+    graph.add_edges_from(
+        [
+            (1, 2),
+            (1, 3),
+            (1, 4),
+            (1, 5),
+            (2, 3),
+            (2, 7),
+            (2, 8),
+            (2, 9),
+            (3, 6),
+            (3, 7),
+            (3, 9),
+            (4, 5),
+            (4, 6),
+            (4, 8),
+            (4, 9),
+            (5, 6),
+            (5, 7),
+            (5, 8),
+            (6, 7),
+            (6, 9),
+            (7, 8),
+            (8, 9),
+        ]
+    )
+    return graph
+
+
+# --------------------------------------------------------------------------
+# Basic tests for all strategies
+# For each basic graph function, specify the number of expected colors.
+BASIC_TEST_CASES = {
+    empty_graph: 0,
+    one_node_graph: 1,
+    two_node_graph: 2,
+    disconnected: 2,
+    three_node_clique: 3,
+}
+
+
+# --------------------------------------------------------------------------
+# Special test cases. Each strategy has a list of tuples of the form
+# (graph function, interchange, valid # of colors)
+SPECIAL_TEST_CASES = {
+    "random_sequential": [
+        (rs_shc, False, (2, 3)),
+        (rs_shc, True, 2),
+        (rsi_shc, True, (3, 4)),
+    ],
+    "saturation_largest_first": [(slf_shc, False, (3, 4)), (slf_hc, False, 4)],
+    "largest_first": [
+        (lf_shc, False, (2, 3)),
+        (lf_hc, False, 4),
+        (lf_shc, True, 2),
+        (lf_hc, True, 3),
+        (lfi_shc, True, (3, 4)),
+        (lfi_hc, True, 4),
+    ],
+    "smallest_last": [
+        (sl_shc, False, (3, 4)),
+        (sl_hc, False, 5),
+        (sl_shc, True, 3),
+        (sl_hc, True, 4),
+        (sli_shc, True, (3, 4)),
+        (sli_hc, True, 5),
+    ],
+    "independent_set": [(gis_shc, False, (2, 3)), (gis_hc, False, 3)],
+    "connected_sequential": [(cs_shc, False, (3, 4)), (cs_shc, True, 3)],
+    "connected_sequential_dfs": [(cs_shc, False, (3, 4))],
+}
+
+
+# --------------------------------------------------------------------------
+# Helper functions to test
+# (graph function, interchange, valid # of colors)
+
+
+def check_state(L, N, H, F, C):
+    s = len(C[0])
+    num_colors = len(C.keys())
+
+    assert all(u in L[v] for u in L.keys() for v in L[u])
+    assert all(F[u] != F[v] for u in L.keys() for v in L[u])
+    assert all(len(L[u]) < num_colors for u in L.keys())
+    assert all(len(C[x]) == s for x in C)
+    assert all(H[(c1, c2)] >= 0 for c1 in C.keys() for c2 in C.keys())
+    assert all(N[(u, F[u])] == 0 for u in F.keys())
+
+
+def max_degree(G):
+    """Get the maximum degree of any node in G."""
+    return max(G.degree(node) for node in G.nodes) if len(G.nodes) > 0 else 0
+
+
+def make_params_from_graph(G, F):
+    """Returns {N, L, H, C} from the given graph."""
+    num_nodes = len(G)
+    L = {u: [] for u in range(num_nodes)}
+    for (u, v) in G.edges:
+        L[u].append(v)
+        L[v].append(u)
+
+    C = nx.algorithms.coloring.equitable_coloring.make_C_from_F(F)
+    N = nx.algorithms.coloring.equitable_coloring.make_N_from_L_C(L, C)
+    H = nx.algorithms.coloring.equitable_coloring.make_H_from_C_N(C, N)
+
+    return {"N": N, "F": F, "C": C, "H": H, "L": L}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/communicability_alg.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/communicability_alg.py
new file mode 100644
index 0000000..ba4b4ab
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/communicability_alg.py
@@ -0,0 +1,161 @@
+"""
+Communicability.
+"""
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["communicability", "communicability_exp"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def communicability(G):
+    r"""Returns communicability between all pairs of nodes in G.
+
+    The communicability between pairs of nodes in G is the sum of
+    walks of different lengths starting at node u and ending at node v.
+
+    Parameters
+    ----------
+    G: graph
+
+    Returns
+    -------
+    comm: dictionary of dictionaries
+        Dictionary of dictionaries keyed by nodes with communicability
+        as the value.
+
+    Raises
+    ------
+    NetworkXError
+       If the graph is not undirected and simple.
+
+    See Also
+    --------
+    communicability_exp:
+       Communicability between all pairs of nodes in G  using spectral
+       decomposition.
+    communicability_betweenness_centrality:
+       Communicability betweeness centrality for each node in G.
+
+    Notes
+    -----
+    This algorithm uses a spectral decomposition of the adjacency matrix.
+    Let G=(V,E) be a simple undirected graph.  Using the connection between
+    the powers  of the adjacency matrix and the number of walks in the graph,
+    the communicability  between nodes `u` and `v` based on the graph spectrum
+    is [1]_
+
+    .. math::
+        C(u,v)=\sum_{j=1}^{n}\phi_{j}(u)\phi_{j}(v)e^{\lambda_{j}},
+
+    where `\phi_{j}(u)` is the `u\rm{th}` element of the `j\rm{th}` orthonormal
+    eigenvector of the adjacency matrix associated with the eigenvalue
+    `\lambda_{j}`.
+
+    References
+    ----------
+    .. [1] Ernesto Estrada, Naomichi Hatano,
+       "Communicability in complex networks",
+       Phys. Rev. E 77, 036111 (2008).
+       https://arxiv.org/abs/0707.0756
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (1, 2), (1, 5), (5, 4), (2, 4), (2, 3), (4, 3), (3, 6)])
+    >>> c = nx.communicability(G)
+    """
+    import numpy as np
+
+    nodelist = list(G)  # ordering of nodes in matrix
+    A = nx.to_numpy_array(G, nodelist)
+    # convert to 0-1 matrix
+    A[A != 0.0] = 1
+    w, vec = np.linalg.eigh(A)
+    expw = np.exp(w)
+    mapping = dict(zip(nodelist, range(len(nodelist))))
+    c = {}
+    # computing communicabilities
+    for u in G:
+        c[u] = {}
+        for v in G:
+            s = 0
+            p = mapping[u]
+            q = mapping[v]
+            for j in range(len(nodelist)):
+                s += vec[:, j][p] * vec[:, j][q] * expw[j]
+            c[u][v] = float(s)
+    return c
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def communicability_exp(G):
+    r"""Returns communicability between all pairs of nodes in G.
+
+    Communicability between pair of node (u,v) of node in G is the sum of
+    walks of different lengths starting at node u and ending at node v.
+
+    Parameters
+    ----------
+    G: graph
+
+    Returns
+    -------
+    comm: dictionary of dictionaries
+        Dictionary of dictionaries keyed by nodes with communicability
+        as the value.
+
+    Raises
+    ------
+    NetworkXError
+        If the graph is not undirected and simple.
+
+    See Also
+    --------
+    communicability:
+       Communicability between pairs of nodes in G.
+    communicability_betweenness_centrality:
+       Communicability betweeness centrality for each node in G.
+
+    Notes
+    -----
+    This algorithm uses matrix exponentiation of the adjacency matrix.
+
+    Let G=(V,E) be a simple undirected graph.  Using the connection between
+    the powers  of the adjacency matrix and the number of walks in the graph,
+    the communicability between nodes u and v is [1]_,
+
+    .. math::
+        C(u,v) = (e^A)_{uv},
+
+    where `A` is the adjacency matrix of G.
+
+    References
+    ----------
+    .. [1] Ernesto Estrada, Naomichi Hatano,
+       "Communicability in complex networks",
+       Phys. Rev. E 77, 036111 (2008).
+       https://arxiv.org/abs/0707.0756
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (1, 2), (1, 5), (5, 4), (2, 4), (2, 3), (4, 3), (3, 6)])
+    >>> c = nx.communicability_exp(G)
+    """
+    import scipy as sp
+    import scipy.linalg  # call as sp.linalg
+
+    nodelist = list(G)  # ordering of nodes in matrix
+    A = nx.to_numpy_array(G, nodelist)
+    # convert to 0-1 matrix
+    A[A != 0.0] = 1
+    # communicability matrix
+    expA = sp.linalg.expm(A)
+    mapping = dict(zip(nodelist, range(len(nodelist))))
+    c = {}
+    for u in G:
+        c[u] = {}
+        for v in G:
+            c[u][v] = float(expA[mapping[u], mapping[v]])
+    return c
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/__init__.py
new file mode 100644
index 0000000..9aea405
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/__init__.py
@@ -0,0 +1,26 @@
+"""Functions for computing and measuring community structure.
+
+The functions in this class are not imported into the top-level
+:mod:`networkx` namespace. You can access these functions by importing
+the :mod:`networkx.algorithms.community` module, then accessing the
+functions as attributes of ``community``. For example::
+
+    >>> from networkx.algorithms import community
+    >>> G = nx.barbell_graph(5, 1)
+    >>> communities_generator = community.girvan_newman(G)
+    >>> top_level_communities = next(communities_generator)
+    >>> next_level_communities = next(communities_generator)
+    >>> sorted(map(sorted, next_level_communities))
+    [[0, 1, 2, 3, 4], [5], [6, 7, 8, 9, 10]]
+
+"""
+from networkx.algorithms.community.asyn_fluid import *
+from networkx.algorithms.community.centrality import *
+from networkx.algorithms.community.kclique import *
+from networkx.algorithms.community.kernighan_lin import *
+from networkx.algorithms.community.label_propagation import *
+from networkx.algorithms.community.lukes import *
+from networkx.algorithms.community.modularity_max import *
+from networkx.algorithms.community.quality import *
+from networkx.algorithms.community.community_utils import *
+from networkx.algorithms.community.louvain import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/asyn_fluid.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/asyn_fluid.py
new file mode 100644
index 0000000..3d723be
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/asyn_fluid.py
@@ -0,0 +1,147 @@
+"""Asynchronous Fluid Communities algorithm for community detection."""
+
+from collections import Counter
+
+from networkx.algorithms.components import is_connected
+from networkx.exception import NetworkXError
+from networkx.utils import groups, not_implemented_for, py_random_state
+
+__all__ = ["asyn_fluidc"]
+
+
+@py_random_state(3)
+@not_implemented_for("directed", "multigraph")
+def asyn_fluidc(G, k, max_iter=100, seed=None):
+    """Returns communities in `G` as detected by Fluid Communities algorithm.
+
+    The asynchronous fluid communities algorithm is described in
+    [1]_. The algorithm is based on the simple idea of fluids interacting
+    in an environment, expanding and pushing each other. Its initialization is
+    random, so found communities may vary on different executions.
+
+    The algorithm proceeds as follows. First each of the initial k communities
+    is initialized in a random vertex in the graph. Then the algorithm iterates
+    over all vertices in a random order, updating the community of each vertex
+    based on its own community and the communities of its neighbours. This
+    process is performed several times until convergence.
+    At all times, each community has a total density of 1, which is equally
+    distributed among the vertices it contains. If a vertex changes of
+    community, vertex densities of affected communities are adjusted
+    immediately. When a complete iteration over all vertices is done, such that
+    no vertex changes the community it belongs to, the algorithm has converged
+    and returns.
+
+    This is the original version of the algorithm described in [1]_.
+    Unfortunately, it does not support weighted graphs yet.
+
+    Parameters
+    ----------
+    G : Graph
+
+    k : integer
+        The number of communities to be found.
+
+    max_iter : integer
+        The number of maximum iterations allowed. By default 100.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    communities : iterable
+        Iterable of communities given as sets of nodes.
+
+    Notes
+    -----
+    k variable is not an optional argument.
+
+    References
+    ----------
+    .. [1] Parés F., Garcia-Gasulla D. et al. "Fluid Communities: A
+       Competitive and Highly Scalable Community Detection Algorithm".
+       [https://arxiv.org/pdf/1703.09307.pdf].
+    """
+    # Initial checks
+    if not isinstance(k, int):
+        raise NetworkXError("k must be an integer.")
+    if not k > 0:
+        raise NetworkXError("k must be greater than 0.")
+    if not is_connected(G):
+        raise NetworkXError("Fluid Communities require connected Graphs.")
+    if len(G) < k:
+        raise NetworkXError("k cannot be bigger than the number of nodes.")
+    # Initialization
+    max_density = 1.0
+    vertices = list(G)
+    seed.shuffle(vertices)
+    communities = {n: i for i, n in enumerate(vertices[:k])}
+    density = {}
+    com_to_numvertices = {}
+    for vertex in communities.keys():
+        com_to_numvertices[communities[vertex]] = 1
+        density[communities[vertex]] = max_density
+    # Set up control variables and start iterating
+    iter_count = 0
+    cont = True
+    while cont:
+        cont = False
+        iter_count += 1
+        # Loop over all vertices in graph in a random order
+        vertices = list(G)
+        seed.shuffle(vertices)
+        for vertex in vertices:
+            # Updating rule
+            com_counter = Counter()
+            # Take into account self vertex community
+            try:
+                com_counter.update({communities[vertex]: density[communities[vertex]]})
+            except KeyError:
+                pass
+            # Gather neighbour vertex communities
+            for v in G[vertex]:
+                try:
+                    com_counter.update({communities[v]: density[communities[v]]})
+                except KeyError:
+                    continue
+            # Check which is the community with highest density
+            new_com = -1
+            if len(com_counter.keys()) > 0:
+                max_freq = max(com_counter.values())
+                best_communities = [
+                    com
+                    for com, freq in com_counter.items()
+                    if (max_freq - freq) < 0.0001
+                ]
+                # If actual vertex com in best communities, it is preserved
+                try:
+                    if communities[vertex] in best_communities:
+                        new_com = communities[vertex]
+                except KeyError:
+                    pass
+                # If vertex community changes...
+                if new_com == -1:
+                    # Set flag of non-convergence
+                    cont = True
+                    # Randomly chose a new community from candidates
+                    new_com = seed.choice(best_communities)
+                    # Update previous community status
+                    try:
+                        com_to_numvertices[communities[vertex]] -= 1
+                        density[communities[vertex]] = (
+                            max_density / com_to_numvertices[communities[vertex]]
+                        )
+                    except KeyError:
+                        pass
+                    # Update new community status
+                    communities[vertex] = new_com
+                    com_to_numvertices[communities[vertex]] += 1
+                    density[communities[vertex]] = (
+                        max_density / com_to_numvertices[communities[vertex]]
+                    )
+        # If maximum iterations reached --> output actual results
+        if iter_count > max_iter:
+            break
+    # Return results by grouping communities as list of vertices
+    return iter(groups(communities).values())
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/centrality.py
new file mode 100644
index 0000000..926cd9a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/centrality.py
@@ -0,0 +1,170 @@
+"""Functions for computing communities based on centrality notions."""
+
+import networkx as nx
+
+__all__ = ["girvan_newman"]
+
+
+def girvan_newman(G, most_valuable_edge=None):
+    """Finds communities in a graph using the Girvan–Newman method.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    most_valuable_edge : function
+        Function that takes a graph as input and outputs an edge. The
+        edge returned by this function will be recomputed and removed at
+        each iteration of the algorithm.
+
+        If not specified, the edge with the highest
+        :func:`networkx.edge_betweenness_centrality` will be used.
+
+    Returns
+    -------
+    iterator
+        Iterator over tuples of sets of nodes in `G`. Each set of node
+        is a community, each tuple is a sequence of communities at a
+        particular level of the algorithm.
+
+    Examples
+    --------
+    To get the first pair of communities::
+
+        >>> G = nx.path_graph(10)
+        >>> comp = girvan_newman(G)
+        >>> tuple(sorted(c) for c in next(comp))
+        ([0, 1, 2, 3, 4], [5, 6, 7, 8, 9])
+
+    To get only the first *k* tuples of communities, use
+    :func:`itertools.islice`::
+
+        >>> import itertools
+        >>> G = nx.path_graph(8)
+        >>> k = 2
+        >>> comp = girvan_newman(G)
+        >>> for communities in itertools.islice(comp, k):
+        ...     print(tuple(sorted(c) for c in communities))
+        ...
+        ([0, 1, 2, 3], [4, 5, 6, 7])
+        ([0, 1], [2, 3], [4, 5, 6, 7])
+
+    To stop getting tuples of communities once the number of communities
+    is greater than *k*, use :func:`itertools.takewhile`::
+
+        >>> import itertools
+        >>> G = nx.path_graph(8)
+        >>> k = 4
+        >>> comp = girvan_newman(G)
+        >>> limited = itertools.takewhile(lambda c: len(c) <= k, comp)
+        >>> for communities in limited:
+        ...     print(tuple(sorted(c) for c in communities))
+        ...
+        ([0, 1, 2, 3], [4, 5, 6, 7])
+        ([0, 1], [2, 3], [4, 5, 6, 7])
+        ([0, 1], [2, 3], [4, 5], [6, 7])
+
+    To just choose an edge to remove based on the weight::
+
+        >>> from operator import itemgetter
+        >>> G = nx.path_graph(10)
+        >>> edges = G.edges()
+        >>> nx.set_edge_attributes(G, {(u, v): v for u, v in edges}, "weight")
+        >>> def heaviest(G):
+        ...     u, v, w = max(G.edges(data="weight"), key=itemgetter(2))
+        ...     return (u, v)
+        ...
+        >>> comp = girvan_newman(G, most_valuable_edge=heaviest)
+        >>> tuple(sorted(c) for c in next(comp))
+        ([0, 1, 2, 3, 4, 5, 6, 7, 8], [9])
+
+    To utilize edge weights when choosing an edge with, for example, the
+    highest betweenness centrality::
+
+        >>> from networkx import edge_betweenness_centrality as betweenness
+        >>> def most_central_edge(G):
+        ...     centrality = betweenness(G, weight="weight")
+        ...     return max(centrality, key=centrality.get)
+        ...
+        >>> G = nx.path_graph(10)
+        >>> comp = girvan_newman(G, most_valuable_edge=most_central_edge)
+        >>> tuple(sorted(c) for c in next(comp))
+        ([0, 1, 2, 3, 4], [5, 6, 7, 8, 9])
+
+    To specify a different ranking algorithm for edges, use the
+    `most_valuable_edge` keyword argument::
+
+        >>> from networkx import edge_betweenness_centrality
+        >>> from random import random
+        >>> def most_central_edge(G):
+        ...     centrality = edge_betweenness_centrality(G)
+        ...     max_cent = max(centrality.values())
+        ...     # Scale the centrality values so they are between 0 and 1,
+        ...     # and add some random noise.
+        ...     centrality = {e: c / max_cent for e, c in centrality.items()}
+        ...     # Add some random noise.
+        ...     centrality = {e: c + random() for e, c in centrality.items()}
+        ...     return max(centrality, key=centrality.get)
+        ...
+        >>> G = nx.path_graph(10)
+        >>> comp = girvan_newman(G, most_valuable_edge=most_central_edge)
+
+    Notes
+    -----
+    The Girvan–Newman algorithm detects communities by progressively
+    removing edges from the original graph. The algorithm removes the
+    "most valuable" edge, traditionally the edge with the highest
+    betweenness centrality, at each step. As the graph breaks down into
+    pieces, the tightly knit community structure is exposed and the
+    result can be depicted as a dendrogram.
+
+    """
+    # If the graph is already empty, simply return its connected
+    # components.
+    if G.number_of_edges() == 0:
+        yield tuple(nx.connected_components(G))
+        return
+    # If no function is provided for computing the most valuable edge,
+    # use the edge betweenness centrality.
+    if most_valuable_edge is None:
+
+        def most_valuable_edge(G):
+            """Returns the edge with the highest betweenness centrality
+            in the graph `G`.
+
+            """
+            # We have guaranteed that the graph is non-empty, so this
+            # dictionary will never be empty.
+            betweenness = nx.edge_betweenness_centrality(G)
+            return max(betweenness, key=betweenness.get)
+
+    # The copy of G here must include the edge weight data.
+    g = G.copy().to_undirected()
+    # Self-loops must be removed because their removal has no effect on
+    # the connected components of the graph.
+    g.remove_edges_from(nx.selfloop_edges(g))
+    while g.number_of_edges() > 0:
+        yield _without_most_central_edges(g, most_valuable_edge)
+
+
+def _without_most_central_edges(G, most_valuable_edge):
+    """Returns the connected components of the graph that results from
+    repeatedly removing the most "valuable" edge in the graph.
+
+    `G` must be a non-empty graph. This function modifies the graph `G`
+    in-place; that is, it removes edges on the graph `G`.
+
+    `most_valuable_edge` is a function that takes the graph `G` as input
+    (or a subgraph with one or more edges of `G` removed) and returns an
+    edge. That edge will be removed and this process will be repeated
+    until the number of connected components in the graph increases.
+
+    """
+    original_num_components = nx.number_connected_components(G)
+    num_new_components = original_num_components
+    while num_new_components <= original_num_components:
+        edge = most_valuable_edge(G)
+        G.remove_edge(*edge)
+        new_components = tuple(nx.connected_components(G))
+        num_new_components = len(new_components)
+    return new_components
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/community_utils.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/community_utils.py
new file mode 100644
index 0000000..f06fcf4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/community_utils.py
@@ -0,0 +1,27 @@
+"""Helper functions for community-finding algorithms."""
+
+__all__ = ["is_partition"]
+
+
+def is_partition(G, communities):
+    """Returns *True* if `communities` is a partition of the nodes of `G`.
+
+    A partition of a universe set is a family of pairwise disjoint sets
+    whose union is the entire universe set.
+
+    Parameters
+    ----------
+    G : NetworkX graph.
+
+    communities : list or iterable of sets of nodes
+        If not a list, the iterable is converted internally to a list.
+        If it is an iterator it is exhausted.
+
+    """
+    # Alternate implementation:
+    # return all(sum(1 if v in c else 0 for c in communities) == 1 for v in G)
+    if not isinstance(communities, list):
+        communities = list(communities)
+    nodes = {n for c in communities for n in c if n in G}
+
+    return len(G) == len(nodes) == sum(len(c) for c in communities)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/kclique.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/kclique.py
new file mode 100644
index 0000000..804b1c9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/kclique.py
@@ -0,0 +1,79 @@
+from collections import defaultdict
+
+import networkx as nx
+
+__all__ = ["k_clique_communities"]
+
+
+def k_clique_communities(G, k, cliques=None):
+    """Find k-clique communities in graph using the percolation method.
+
+    A k-clique community is the union of all cliques of size k that
+    can be reached through adjacent (sharing k-1 nodes) k-cliques.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    k : int
+       Size of smallest clique
+
+    cliques: list or generator
+       Precomputed cliques (use networkx.find_cliques(G))
+
+    Returns
+    -------
+    Yields sets of nodes, one for each k-clique community.
+
+    Examples
+    --------
+    >>> from networkx.algorithms.community import k_clique_communities
+    >>> G = nx.complete_graph(5)
+    >>> K5 = nx.convert_node_labels_to_integers(G, first_label=2)
+    >>> G.add_edges_from(K5.edges())
+    >>> c = list(k_clique_communities(G, 4))
+    >>> sorted(list(c[0]))
+    [0, 1, 2, 3, 4, 5, 6]
+    >>> list(k_clique_communities(G, 6))
+    []
+
+    References
+    ----------
+    .. [1] Gergely Palla, Imre Derényi, Illés Farkas1, and Tamás Vicsek,
+       Uncovering the overlapping community structure of complex networks
+       in nature and society Nature 435, 814-818, 2005,
+       doi:10.1038/nature03607
+    """
+    if k < 2:
+        raise nx.NetworkXError(f"k={k}, k must be greater than 1.")
+    if cliques is None:
+        cliques = nx.find_cliques(G)
+    cliques = [frozenset(c) for c in cliques if len(c) >= k]
+
+    # First index which nodes are in which cliques
+    membership_dict = defaultdict(list)
+    for clique in cliques:
+        for node in clique:
+            membership_dict[node].append(clique)
+
+    # For each clique, see which adjacent cliques percolate
+    perc_graph = nx.Graph()
+    perc_graph.add_nodes_from(cliques)
+    for clique in cliques:
+        for adj_clique in _get_adjacent_cliques(clique, membership_dict):
+            if len(clique.intersection(adj_clique)) >= (k - 1):
+                perc_graph.add_edge(clique, adj_clique)
+
+    # Connected components of clique graph with perc edges
+    # are the percolated cliques
+    for component in nx.connected_components(perc_graph):
+        yield (frozenset.union(*component))
+
+
+def _get_adjacent_cliques(clique, membership_dict):
+    adjacent_cliques = set()
+    for n in clique:
+        for adj_clique in membership_dict[n]:
+            if clique != adj_clique:
+                adjacent_cliques.add(adj_clique)
+    return adjacent_cliques
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/kernighan_lin.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/kernighan_lin.py
new file mode 100644
index 0000000..2ae22e3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/kernighan_lin.py
@@ -0,0 +1,137 @@
+"""Functions for computing the Kernighan–Lin bipartition algorithm."""
+
+from itertools import count
+
+import networkx as nx
+from networkx.algorithms.community.community_utils import is_partition
+from networkx.utils import BinaryHeap, not_implemented_for, py_random_state
+
+__all__ = ["kernighan_lin_bisection"]
+
+
+def _kernighan_lin_sweep(edges, side):
+    """
+    This is a modified form of Kernighan-Lin, which moves single nodes at a
+    time, alternating between sides to keep the bisection balanced.  We keep
+    two min-heaps of swap costs to make optimal-next-move selection fast.
+    """
+    costs0, costs1 = costs = BinaryHeap(), BinaryHeap()
+    for u, side_u, edges_u in zip(count(), side, edges):
+        cost_u = sum(w if side[v] else -w for v, w in edges_u)
+        costs[side_u].insert(u, cost_u if side_u else -cost_u)
+
+    def _update_costs(costs_x, x):
+        for y, w in edges[x]:
+            costs_y = costs[side[y]]
+            cost_y = costs_y.get(y)
+            if cost_y is not None:
+                cost_y += 2 * (-w if costs_x is costs_y else w)
+                costs_y.insert(y, cost_y, True)
+
+    i = 0
+    totcost = 0
+    while costs0 and costs1:
+        u, cost_u = costs0.pop()
+        _update_costs(costs0, u)
+        v, cost_v = costs1.pop()
+        _update_costs(costs1, v)
+        totcost += cost_u + cost_v
+        i += 1
+        yield totcost, i, (u, v)
+
+
+@py_random_state(4)
+@not_implemented_for("directed")
+def kernighan_lin_bisection(G, partition=None, max_iter=10, weight="weight", seed=None):
+    """Partition a graph into two blocks using the Kernighan–Lin
+    algorithm.
+
+    This algorithm partitions a network into two sets by iteratively
+    swapping pairs of nodes to reduce the edge cut between the two sets.  The
+    pairs are chosen according to a modified form of Kernighan-Lin, which
+    moves node individually, alternating between sides to keep the bisection
+    balanced.
+
+    Parameters
+    ----------
+    G : graph
+
+    partition : tuple
+        Pair of iterables containing an initial partition. If not
+        specified, a random balanced partition is used.
+
+    max_iter : int
+        Maximum number of times to attempt swaps to find an
+        improvemement before giving up.
+
+    weight : key
+        Edge data key to use as weight. If None, the weights are all
+        set to one.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+        Only used if partition is None
+
+    Returns
+    -------
+    partition : tuple
+        A pair of sets of nodes representing the bipartition.
+
+    Raises
+    ------
+    NetworkXError
+        If partition is not a valid partition of the nodes of the graph.
+
+    References
+    ----------
+    .. [1] Kernighan, B. W.; Lin, Shen (1970).
+       "An efficient heuristic procedure for partitioning graphs."
+       *Bell Systems Technical Journal* 49: 291--307.
+       Oxford University Press 2011.
+
+    """
+    n = len(G)
+    labels = list(G)
+    seed.shuffle(labels)
+    index = {v: i for i, v in enumerate(labels)}
+
+    if partition is None:
+        side = [0] * (n // 2) + [1] * ((n + 1) // 2)
+    else:
+        try:
+            A, B = partition
+        except (TypeError, ValueError) as err:
+            raise nx.NetworkXError("partition must be two sets") from err
+        if not is_partition(G, (A, B)):
+            raise nx.NetworkXError("partition invalid")
+        side = [0] * n
+        for a in A:
+            side[index[a]] = 1
+
+    if G.is_multigraph():
+        edges = [
+            [
+                (index[u], sum(e.get(weight, 1) for e in d.values()))
+                for u, d in G[v].items()
+            ]
+            for v in labels
+        ]
+    else:
+        edges = [
+            [(index[u], e.get(weight, 1)) for u, e in G[v].items()] for v in labels
+        ]
+
+    for i in range(max_iter):
+        costs = list(_kernighan_lin_sweep(edges, side))
+        min_cost, min_i, _ = min(costs)
+        if min_cost >= 0:
+            break
+
+        for _, _, (u, v) in costs[:min_i]:
+            side[u] = 1
+            side[v] = 0
+
+    A = {u for u, s in zip(labels, side) if s == 0}
+    B = {u for u, s in zip(labels, side) if s == 1}
+    return A, B
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/label_propagation.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/label_propagation.py
new file mode 100644
index 0000000..09c07c2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/label_propagation.py
@@ -0,0 +1,209 @@
+"""
+Label propagation community detection algorithms.
+"""
+from collections import Counter, defaultdict
+
+import networkx as nx
+from networkx.utils import groups, not_implemented_for, py_random_state
+
+__all__ = ["label_propagation_communities", "asyn_lpa_communities"]
+
+
+@py_random_state(2)
+def asyn_lpa_communities(G, weight=None, seed=None):
+    """Returns communities in `G` as detected by asynchronous label
+    propagation.
+
+    The asynchronous label propagation algorithm is described in
+    [1]_. The algorithm is probabilistic and the found communities may
+    vary on different executions.
+
+    The algorithm proceeds as follows. After initializing each node with
+    a unique label, the algorithm repeatedly sets the label of a node to
+    be the label that appears most frequently among that nodes
+    neighbors. The algorithm halts when each node has the label that
+    appears most frequently among its neighbors. The algorithm is
+    asynchronous because each node is updated without waiting for
+    updates on the remaining nodes.
+
+    This generalized version of the algorithm in [1]_ accepts edge
+    weights.
+
+    Parameters
+    ----------
+    G : Graph
+
+    weight : string
+        The edge attribute representing the weight of an edge.
+        If None, each edge is assumed to have weight one. In this
+        algorithm, the weight of an edge is used in determining the
+        frequency with which a label appears among the neighbors of a
+        node: a higher weight means the label appears more often.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    communities : iterable
+        Iterable of communities given as sets of nodes.
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+
+    References
+    ----------
+    .. [1] Raghavan, Usha Nandini, Réka Albert, and Soundar Kumara. "Near
+           linear time algorithm to detect community structures in large-scale
+           networks." Physical Review E 76.3 (2007): 036106.
+    """
+
+    labels = {n: i for i, n in enumerate(G)}
+    cont = True
+
+    while cont:
+        cont = False
+        nodes = list(G)
+        seed.shuffle(nodes)
+
+        for node in nodes:
+
+            if not G[node]:
+                continue
+
+            # Get label frequencies among adjacent nodes.
+            # Depending on the order they are processed in,
+            # some nodes will be in iteration t and others in t-1,
+            # making the algorithm asynchronous.
+            if weight is None:
+                # initialising a Counter from an iterator of labels is
+                # faster for getting unweighted label frequencies
+                label_freq = Counter(map(labels.get, G[node]))
+            else:
+                # updating a defaultdict is substantially faster
+                # for getting weighted label frequencies
+                label_freq = defaultdict(float)
+                for _, v, wt in G.edges(node, data=weight, default=1):
+                    label_freq[labels[v]] += wt
+
+            # Get the labels that appear with maximum frequency.
+            max_freq = max(label_freq.values())
+            best_labels = [
+                label for label, freq in label_freq.items() if freq == max_freq
+            ]
+
+            # If the node does not have one of the maximum frequency labels,
+            # randomly choose one of them and update the node's label.
+            # Continue the iteration as long as at least one node
+            # doesn't have a maximum frequency label.
+            if labels[node] not in best_labels:
+                labels[node] = seed.choice(best_labels)
+                cont = True
+
+    yield from groups(labels).values()
+
+
+@not_implemented_for("directed")
+def label_propagation_communities(G):
+    """Generates community sets determined by label propagation
+
+    Finds communities in `G` using a semi-synchronous label propagation
+    method [1]_. This method combines the advantages of both the synchronous
+    and asynchronous models. Not implemented for directed graphs.
+
+    Parameters
+    ----------
+    G : graph
+        An undirected NetworkX graph.
+
+    Returns
+    -------
+    communities : iterable
+        A dict_values object that contains a set of nodes for each community.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+       If the graph is directed
+
+    References
+    ----------
+    .. [1] Cordasco, G., & Gargano, L. (2010, December). Community detection
+       via semi-synchronous label propagation algorithms. In Business
+       Applications of Social Network Analysis (BASNA), 2010 IEEE International
+       Workshop on (pp. 1-8). IEEE.
+    """
+    coloring = _color_network(G)
+    # Create a unique label for each node in the graph
+    labeling = {v: k for k, v in enumerate(G)}
+    while not _labeling_complete(labeling, G):
+        # Update the labels of every node with the same color.
+        for color, nodes in coloring.items():
+            for n in nodes:
+                _update_label(n, labeling, G)
+
+    clusters = defaultdict(set)
+    for node, label in labeling.items():
+        clusters[label].add(node)
+    return clusters.values()
+
+
+def _color_network(G):
+    """Colors the network so that neighboring nodes all have distinct colors.
+
+    Returns a dict keyed by color to a set of nodes with that color.
+    """
+    coloring = dict()  # color => set(node)
+    colors = nx.coloring.greedy_color(G)
+    for node, color in colors.items():
+        if color in coloring:
+            coloring[color].add(node)
+        else:
+            coloring[color] = {node}
+    return coloring
+
+
+def _labeling_complete(labeling, G):
+    """Determines whether or not LPA is done.
+
+    Label propagation is complete when all nodes have a label that is
+    in the set of highest frequency labels amongst its neighbors.
+
+    Nodes with no neighbors are considered complete.
+    """
+    return all(
+        labeling[v] in _most_frequent_labels(v, labeling, G) for v in G if len(G[v]) > 0
+    )
+
+
+def _most_frequent_labels(node, labeling, G):
+    """Returns a set of all labels with maximum frequency in `labeling`.
+
+    Input `labeling` should be a dict keyed by node to labels.
+    """
+    if not G[node]:
+        # Nodes with no neighbors are themselves a community and are labeled
+        # accordingly, hence the immediate if statement.
+        return {labeling[node]}
+
+    # Compute the frequencies of all neighbours of node
+    freqs = Counter(labeling[q] for q in G[node])
+    max_freq = max(freqs.values())
+    return {label for label, freq in freqs.items() if freq == max_freq}
+
+
+def _update_label(node, labeling, G):
+    """Updates the label of a node using the Prec-Max tie breaking algorithm
+
+    The algorithm is explained in: 'Community Detection via Semi-Synchronous
+    Label Propagation Algorithms' Cordasco and Gargano, 2011
+    """
+    high_labels = _most_frequent_labels(node, labeling, G)
+    if len(high_labels) == 1:
+        labeling[node] = high_labels.pop()
+    elif len(high_labels) > 1:
+        # Prec-Max
+        if labeling[node] not in high_labels:
+            labeling[node] = max(high_labels)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/louvain.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/louvain.py
new file mode 100644
index 0000000..e3ad78b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/louvain.py
@@ -0,0 +1,350 @@
+"""Function for detecting communities based on Louvain Community Detection
+Algorithm"""
+
+from collections import defaultdict, deque
+
+import networkx as nx
+from networkx.algorithms.community import modularity
+from networkx.utils import py_random_state
+
+__all__ = ["louvain_communities", "louvain_partitions"]
+
+
+@py_random_state("seed")
+def louvain_communities(
+    G, weight="weight", resolution=1, threshold=0.0000001, seed=None
+):
+    r"""Find the best partition of a graph using the Louvain Community Detection
+    Algorithm.
+
+    Louvain Community Detection Algorithm is a simple method to extract the community
+    structure of a network. This is a heuristic method based on modularity optimization. [1]_
+
+    The algorithm works in 2 steps. On the first step it assigns every node to be
+    in its own community and then for each node it tries to find the maximum positive
+    modularity gain by moving each node to all of its neighbor communities. If no positive
+    gain is achieved the node remains in its original community.
+
+    The modularity gain obtained by moving an isolated node $i$ into a community $C$ can
+    easily be calculated by the following formula (combining [1]_ [2]_ and some algebra):
+
+    .. math::
+        \Delta Q = \frac{k_{i,in}}{2m} - \gamma\frac{ \Sigma_{tot} \cdot k_i}{2m^2}
+
+    where $m$ is the size of the graph, $k_{i,in}$ is the sum of the weights of the links
+    from $i$ to nodes in $C$, $k_i$ is the sum of the weights of the links incident to node $i$,
+    $\Sigma_{tot}$ is the sum of the weights of the links incident to nodes in $C$ and $\gamma$
+    is the resolution parameter.
+
+    For the directed case the modularity gain can be computed using this formula according to [3]_
+
+    .. math::
+        \Delta Q = \frac{k_{i,in}}{m}
+        - \gamma\frac{k_i^{out} \cdot\Sigma_{tot}^{in} + k_i^{in} \cdot \Sigma_{tot}^{out}}{m^2}
+
+    where $k_i^{out}$, $k_i^{in}$ are the outer and inner weighted degrees of node $i$ and
+    $\Sigma_{tot}^{in}$, $\Sigma_{tot}^{out}$ are the sum of in-going and out-going links incident
+    to nodes in $C$.
+
+    The first phase continues until no individual move can improve the modularity.
+
+    The second phase consists in building a new network whose nodes are now the communities
+    found in the first phase. To do so, the weights of the links between the new nodes are given by
+    the sum of the weight of the links between nodes in the corresponding two communities. Once this
+    phase is complete it is possible to reapply the first phase creating bigger communities with
+    increased modularity.
+
+    The above two phases are executed until no modularity gain is achieved (or is less than
+    the `threshold`).
+
+    Parameters
+    ----------
+    G : NetworkX graph
+    weight : string or None, optional (default="weight")
+        The name of an edge attribute that holds the numerical value
+        used as a weight. If None then each edge has weight 1.
+    resolution : float, optional (default=1)
+        If resolution is less than 1, the algorithm favors larger communities.
+        Greater than 1 favors smaller communities
+    threshold : float, optional (default=0.0000001)
+        Modularity gain threshold for each level. If the gain of modularity
+        between 2 levels of the algorithm is less than the given threshold
+        then the algorithm stops and returns the resulting communities.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    list
+        A list of sets (partition of `G`). Each set represents one community and contains
+        all the nodes that constitute it.
+
+    Examples
+    --------
+    >>> import networkx as nx
+    >>> import networkx.algorithms.community as nx_comm
+    >>> G = nx.petersen_graph()
+    >>> nx_comm.louvain_communities(G, seed=123)
+    [{0, 4, 5, 7, 9}, {1, 2, 3, 6, 8}]
+
+    Notes
+    -----
+    The order in which the nodes are considered can affect the final output. In the algorithm
+    the ordering happens using a random shuffle.
+
+    References
+    ----------
+    .. [1] Blondel, V.D. et al. Fast unfolding of communities in
+       large networks. J. Stat. Mech 10008, 1-12(2008). https://doi.org/10.1088/1742-5468/2008/10/P10008
+    .. [2] Traag, V.A., Waltman, L. & van Eck, N.J. From Louvain to Leiden: guaranteeing
+       well-connected communities. Sci Rep 9, 5233 (2019). https://doi.org/10.1038/s41598-019-41695-z
+    .. [3] Nicolas Dugué, Anthony Perez. Directed Louvain : maximizing modularity in directed networks.
+        [Research Report] Université d’Orléans. 2015. hal-01231784. https://hal.archives-ouvertes.fr/hal-01231784
+
+    See Also
+    --------
+    louvain_partitions
+    """
+
+    d = louvain_partitions(G, weight, resolution, threshold, seed)
+    q = deque(d, maxlen=1)
+    return q.pop()
+
+
+@py_random_state("seed")
+def louvain_partitions(
+    G, weight="weight", resolution=1, threshold=0.0000001, seed=None
+):
+    """Yields partitions for each level of the Louvain Community Detection Algorithm
+
+    Louvain Community Detection Algorithm is a simple method to extract the community
+    structure of a network. This is a heuristic method based on modularity optimization. [1]_
+
+    The partitions at each level (step of the algorithm) form a dendogram of communities.
+    A dendrogram is a diagram representing a tree and each level represents
+    a partition of the G graph. The top level contains the smallest communities
+    and as you traverse to the bottom of the tree the communities get bigger
+    and the overal modularity increases making the partition better.
+
+    Each level is generated by executing the two phases of the Louvain Community
+    Detection Algorithm.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+    weight : string or None, optional (default="weight")
+     The name of an edge attribute that holds the numerical value
+     used as a weight. If None then each edge has weight 1.
+    resolution : float, optional (default=1)
+        If resolution is less than 1, the algorithm favors larger communities.
+        Greater than 1 favors smaller communities
+    threshold : float, optional (default=0.0000001)
+     Modularity gain threshold for each level. If the gain of modularity
+     between 2 levels of the algorithm is less than the given threshold
+     then the algorithm stops and returns the resulting communities.
+    seed : integer, random_state, or None (default)
+     Indicator of random number generation state.
+     See :ref:`Randomness<randomness>`.
+
+    Yields
+    ------
+    list
+        A list of sets (partition of `G`). Each set represents one community and contains
+        all the nodes that constitute it.
+
+    References
+    ----------
+    .. [1] Blondel, V.D. et al. Fast unfolding of communities in
+       large networks. J. Stat. Mech 10008, 1-12(2008)
+
+    See Also
+    --------
+    louvain_communities
+    """
+
+    partition = [{u} for u in G.nodes()]
+    mod = modularity(G, partition, resolution=resolution, weight=weight)
+    is_directed = G.is_directed()
+    if G.is_multigraph():
+        graph = _convert_multigraph(G, weight, is_directed)
+    else:
+        graph = G.__class__()
+        graph.add_nodes_from(G)
+        graph.add_weighted_edges_from(G.edges(data=weight, default=1))
+
+    m = graph.size(weight="weight")
+    partition, inner_partition, improvement = _one_level(
+        graph, m, partition, resolution, is_directed, seed
+    )
+    improvement = True
+    while improvement:
+        yield partition
+        new_mod = modularity(
+            graph, inner_partition, resolution=resolution, weight="weight"
+        )
+        if new_mod - mod <= threshold:
+            return
+        mod = new_mod
+        graph = _gen_graph(graph, inner_partition)
+        partition, inner_partition, improvement = _one_level(
+            graph, m, partition, resolution, is_directed, seed
+        )
+
+
+def _one_level(G, m, partition, resolution=1, is_directed=False, seed=None):
+    """Calculate one level of the Louvain partitions tree
+
+    Parameters
+    ----------
+    G : NetworkX Graph/DiGraph
+        The graph from which to detect communities
+    m : number
+        The size of the graph `G`.
+    partition : list of sets of nodes
+        A valid partition of the graph `G`
+    resolution : positive number
+        The resolution parameter for computing the modularity of a partition
+    is_directed : bool
+        True if `G` is a directed graph.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    """
+    node2com = {u: i for i, u in enumerate(G.nodes())}
+    inner_partition = [{u} for u in G.nodes()]
+    if is_directed:
+        in_degrees = dict(G.in_degree(weight="weight"))
+        out_degrees = dict(G.out_degree(weight="weight"))
+        Stot_in = [deg for deg in in_degrees.values()]
+        Stot_out = [deg for deg in out_degrees.values()]
+        # Calculate weights for both in and out neighbours
+        nbrs = {}
+        for u in G:
+            nbrs[u] = defaultdict(float)
+            for _, n, wt in G.out_edges(u, data="weight"):
+                nbrs[u][n] += wt
+            for n, _, wt in G.in_edges(u, data="weight"):
+                nbrs[u][n] += wt
+    else:
+        degrees = dict(G.degree(weight="weight"))
+        Stot = [deg for deg in degrees.values()]
+        nbrs = {u: {v: data["weight"] for v, data in G[u].items() if v != u} for u in G}
+    rand_nodes = list(G.nodes)
+    seed.shuffle(rand_nodes)
+    nb_moves = 1
+    improvement = False
+    while nb_moves > 0:
+        nb_moves = 0
+        for u in rand_nodes:
+            best_mod = 0
+            best_com = node2com[u]
+            weights2com = _neighbor_weights(nbrs[u], node2com)
+            if is_directed:
+                in_degree = in_degrees[u]
+                out_degree = out_degrees[u]
+                Stot_in[best_com] -= in_degree
+                Stot_out[best_com] -= out_degree
+                remove_cost = (
+                    -weights2com[best_com] / m
+                    + resolution
+                    * (out_degree * Stot_in[best_com] + in_degree * Stot_out[best_com])
+                    / m**2
+                )
+            else:
+                degree = degrees[u]
+                Stot[best_com] -= degree
+                remove_cost = -weights2com[best_com] / m + resolution * (
+                    Stot[best_com] * degree
+                ) / (2 * m**2)
+            for nbr_com, wt in weights2com.items():
+                if is_directed:
+                    gain = (
+                        remove_cost
+                        + wt / m
+                        - resolution
+                        * (
+                            out_degree * Stot_in[nbr_com]
+                            + in_degree * Stot_out[nbr_com]
+                        )
+                        / m**2
+                    )
+                else:
+                    gain = (
+                        remove_cost
+                        + wt / m
+                        - resolution * (Stot[nbr_com] * degree) / (2 * m**2)
+                    )
+                if gain > best_mod:
+                    best_mod = gain
+                    best_com = nbr_com
+            if is_directed:
+                Stot_in[best_com] += in_degree
+                Stot_out[best_com] += out_degree
+            else:
+                Stot[best_com] += degree
+            if best_com != node2com[u]:
+                com = G.nodes[u].get("nodes", {u})
+                partition[node2com[u]].difference_update(com)
+                inner_partition[node2com[u]].remove(u)
+                partition[best_com].update(com)
+                inner_partition[best_com].add(u)
+                improvement = True
+                nb_moves += 1
+                node2com[u] = best_com
+    partition = list(filter(len, partition))
+    inner_partition = list(filter(len, inner_partition))
+    return partition, inner_partition, improvement
+
+
+def _neighbor_weights(nbrs, node2com):
+    """Calculate weights between node and its neighbor communities.
+
+    Parameters
+    ----------
+    nbrs : dictionary
+           Dictionary with nodes' neighbours as keys and their edge weight as value.
+    node2com : dictionary
+           Dictionary with all graph's nodes as keys and their community index as value.
+
+    """
+    weights = defaultdict(float)
+    for nbr, wt in nbrs.items():
+        weights[node2com[nbr]] += wt
+    return weights
+
+
+def _gen_graph(G, partition):
+    """Generate a new graph based on the partitions of a given graph"""
+    H = G.__class__()
+    node2com = {}
+    for i, part in enumerate(partition):
+        nodes = set()
+        for node in part:
+            node2com[node] = i
+            nodes.update(G.nodes[node].get("nodes", {node}))
+        H.add_node(i, nodes=nodes)
+
+    for node1, node2, wt in G.edges(data=True):
+        wt = wt["weight"]
+        com1 = node2com[node1]
+        com2 = node2com[node2]
+        temp = H.get_edge_data(com1, com2, {"weight": 0})["weight"]
+        H.add_edge(com1, com2, **{"weight": wt + temp})
+    return H
+
+
+def _convert_multigraph(G, weight, is_directed):
+    """Convert a Multigraph to normal Graph"""
+    if is_directed:
+        H = nx.DiGraph()
+    else:
+        H = nx.Graph()
+    H.add_nodes_from(G)
+    for u, v, wt in G.edges(data=weight, default=1):
+        if H.has_edge(u, v):
+            H[u][v]["weight"] += wt
+        else:
+            H.add_edge(u, v, weight=wt)
+    return H
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/lukes.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/lukes.py
new file mode 100644
index 0000000..b34077a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/lukes.py
@@ -0,0 +1,227 @@
+"""Lukes Algorithm for exact optimal weighted tree partitioning."""
+
+from copy import deepcopy
+from functools import lru_cache
+from random import choice
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["lukes_partitioning"]
+
+D_EDGE_W = "weight"
+D_EDGE_VALUE = 1.0
+D_NODE_W = "weight"
+D_NODE_VALUE = 1
+PKEY = "partitions"
+CLUSTER_EVAL_CACHE_SIZE = 2048
+
+
+def _split_n_from(n, min_size_of_first_part):
+    # splits j in two parts of which the first is at least
+    # the second argument
+    assert n >= min_size_of_first_part
+    for p1 in range(min_size_of_first_part, n + 1):
+        yield p1, n - p1
+
+
+def lukes_partitioning(G, max_size, node_weight=None, edge_weight=None):
+
+    """Optimal partitioning of a weighted tree using the Lukes algorithm.
+
+    This algorithm partitions a connected, acyclic graph featuring integer
+    node weights and float edge weights. The resulting clusters are such
+    that the total weight of the nodes in each cluster does not exceed
+    max_size and that the weight of the edges that are cut by the partition
+    is minimum. The algorithm is based on LUKES[1].
+
+    Parameters
+    ----------
+    G : graph
+
+    max_size : int
+        Maximum weight a partition can have in terms of sum of
+        node_weight for all nodes in the partition
+
+    edge_weight : key
+        Edge data key to use as weight. If None, the weights are all
+        set to one.
+
+    node_weight : key
+        Node data key to use as weight. If None, the weights are all
+        set to one. The data must be int.
+
+    Returns
+    -------
+    partition : list
+        A list of sets of nodes representing the clusters of the
+        partition.
+
+    Raises
+    ------
+    NotATree
+        If G is not a tree.
+    TypeError
+        If any of the values of node_weight is not int.
+
+    References
+    ----------
+    .. Lukes, J. A. (1974).
+       "Efficient Algorithm for the Partitioning of Trees."
+       IBM Journal of Research and Development, 18(3), 217–224.
+
+    """
+    # First sanity check and tree preparation
+    if not nx.is_tree(G):
+        raise nx.NotATree("lukes_partitioning works only on trees")
+    else:
+        if nx.is_directed(G):
+            root = [n for n, d in G.in_degree() if d == 0]
+            assert len(root) == 1
+            root = root[0]
+            t_G = deepcopy(G)
+        else:
+            root = choice(list(G.nodes))
+            # this has the desirable side effect of not inheriting attributes
+            t_G = nx.dfs_tree(G, root)
+
+    # Since we do not want to screw up the original graph,
+    # if we have a blank attribute, we make a deepcopy
+    if edge_weight is None or node_weight is None:
+        safe_G = deepcopy(G)
+        if edge_weight is None:
+            nx.set_edge_attributes(safe_G, D_EDGE_VALUE, D_EDGE_W)
+            edge_weight = D_EDGE_W
+        if node_weight is None:
+            nx.set_node_attributes(safe_G, D_NODE_VALUE, D_NODE_W)
+            node_weight = D_NODE_W
+    else:
+        safe_G = G
+
+    # Second sanity check
+    # The values of node_weight MUST BE int.
+    # I cannot see any room for duck typing without incurring serious
+    # danger of subtle bugs.
+    all_n_attr = nx.get_node_attributes(safe_G, node_weight).values()
+    for x in all_n_attr:
+        if not isinstance(x, int):
+            raise TypeError(
+                "lukes_partitioning needs integer "
+                f"values for node_weight ({node_weight})"
+            )
+
+    # SUBROUTINES -----------------------
+    # these functions are defined here for two reasons:
+    # - brevity: we can leverage global "safe_G"
+    # - caching: signatures are hashable
+
+    @not_implemented_for("undirected")
+    # this is intended to be called only on t_G
+    def _leaves(gr):
+        for x in gr.nodes:
+            if not nx.descendants(gr, x):
+                yield x
+
+    @not_implemented_for("undirected")
+    def _a_parent_of_leaves_only(gr):
+        tleaves = set(_leaves(gr))
+        for n in set(gr.nodes) - tleaves:
+            if all([x in tleaves for x in nx.descendants(gr, n)]):
+                return n
+
+    @lru_cache(CLUSTER_EVAL_CACHE_SIZE)
+    def _value_of_cluster(cluster):
+        valid_edges = [e for e in safe_G.edges if e[0] in cluster and e[1] in cluster]
+        return sum(safe_G.edges[e][edge_weight] for e in valid_edges)
+
+    def _value_of_partition(partition):
+        return sum(_value_of_cluster(frozenset(c)) for c in partition)
+
+    @lru_cache(CLUSTER_EVAL_CACHE_SIZE)
+    def _weight_of_cluster(cluster):
+        return sum(safe_G.nodes[n][node_weight] for n in cluster)
+
+    def _pivot(partition, node):
+        ccx = [c for c in partition if node in c]
+        assert len(ccx) == 1
+        return ccx[0]
+
+    def _concatenate_or_merge(partition_1, partition_2, x, i, ref_weigth):
+
+        ccx = _pivot(partition_1, x)
+        cci = _pivot(partition_2, i)
+        merged_xi = ccx.union(cci)
+
+        # We first check if we can do the merge.
+        # If so, we do the actual calculations, otherwise we concatenate
+        if _weight_of_cluster(frozenset(merged_xi)) <= ref_weigth:
+            cp1 = list(filter(lambda x: x != ccx, partition_1))
+            cp2 = list(filter(lambda x: x != cci, partition_2))
+
+            option_2 = [merged_xi] + cp1 + cp2
+            return option_2, _value_of_partition(option_2)
+        else:
+            option_1 = partition_1 + partition_2
+            return option_1, _value_of_partition(option_1)
+
+    # INITIALIZATION -----------------------
+    leaves = set(_leaves(t_G))
+    for lv in leaves:
+        t_G.nodes[lv][PKEY] = dict()
+        slot = safe_G.nodes[lv][node_weight]
+        t_G.nodes[lv][PKEY][slot] = [{lv}]
+        t_G.nodes[lv][PKEY][0] = [{lv}]
+
+    for inner in [x for x in t_G.nodes if x not in leaves]:
+        t_G.nodes[inner][PKEY] = dict()
+        slot = safe_G.nodes[inner][node_weight]
+        t_G.nodes[inner][PKEY][slot] = [{inner}]
+
+    # CORE ALGORITHM -----------------------
+    while True:
+        x_node = _a_parent_of_leaves_only(t_G)
+        weight_of_x = safe_G.nodes[x_node][node_weight]
+        best_value = 0
+        best_partition = None
+        bp_buffer = dict()
+        x_descendants = nx.descendants(t_G, x_node)
+        for i_node in x_descendants:
+            for j in range(weight_of_x, max_size + 1):
+                for a, b in _split_n_from(j, weight_of_x):
+                    if (
+                        a not in t_G.nodes[x_node][PKEY].keys()
+                        or b not in t_G.nodes[i_node][PKEY].keys()
+                    ):
+                        # it's not possible to form this particular weight sum
+                        continue
+
+                    part1 = t_G.nodes[x_node][PKEY][a]
+                    part2 = t_G.nodes[i_node][PKEY][b]
+                    part, value = _concatenate_or_merge(part1, part2, x_node, i_node, j)
+
+                    if j not in bp_buffer.keys() or bp_buffer[j][1] < value:
+                        # we annotate in the buffer the best partition for j
+                        bp_buffer[j] = part, value
+
+                    # we also keep track of the overall best partition
+                    if best_value <= value:
+                        best_value = value
+                        best_partition = part
+
+            # as illustrated in Lukes, once we finished a child, we can
+            # discharge the partitions we found into the graph
+            # (the key phrase is make all x == x')
+            # so that they are used by the subsequent children
+            for w, (best_part_for_vl, vl) in bp_buffer.items():
+                t_G.nodes[x_node][PKEY][w] = best_part_for_vl
+            bp_buffer.clear()
+
+        # the absolute best partition for this node
+        # across all weights has to be stored at 0
+        t_G.nodes[x_node][PKEY][0] = best_partition
+        t_G.remove_nodes_from(x_descendants)
+
+        if x_node == root:
+            # the 0-labeled partition of root
+            # is the optimal one for the whole tree
+            return t_G.nodes[root][PKEY][0]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/modularity_max.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/modularity_max.py
new file mode 100644
index 0000000..67a4961
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/modularity_max.py
@@ -0,0 +1,474 @@
+"""Functions for detecting communities based on modularity."""
+
+from collections import defaultdict
+
+import networkx as nx
+from networkx.algorithms.community.quality import modularity
+from networkx.utils import not_implemented_for
+from networkx.utils.mapped_queue import MappedQueue
+
+__all__ = [
+    "greedy_modularity_communities",
+    "naive_greedy_modularity_communities",
+    "_naive_greedy_modularity_communities",
+]
+
+
+def _greedy_modularity_communities_generator(G, weight=None, resolution=1):
+    r"""Yield community partitions of G and the modularity change at each step.
+
+    This function performs Clauset-Newman-Moore greedy modularity maximization [2]_
+    At each step of the process it yields the change in modularity that will occur in
+    the next step followed by yielding the new community partition after that step.
+
+    Greedy modularity maximization begins with each node in its own community
+    and repeatedly joins the pair of communities that lead to the largest
+    modularity until one community contains all nodes (the partition has one set).
+
+    This function maximizes the generalized modularity, where `resolution`
+    is the resolution parameter, often expressed as $\gamma$.
+    See :func:`~networkx.algorithms.community.quality.modularity`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight : string or None, optional (default=None)
+        The name of an edge attribute that holds the numerical value used
+        as a weight.  If None, then each edge has weight 1.
+        The degree is the sum of the edge weights adjacent to the node.
+
+    resolution : float (default=1)
+        If resolution is less than 1, modularity favors larger communities.
+        Greater than 1 favors smaller communities.
+
+    Yields
+    ------
+    Alternating yield statements produce the following two objects:
+
+    communities: dict_values
+        A dict_values of frozensets of nodes, one for each community.
+        This represents a partition of the nodes of the graph into communities.
+        The first yield is the partition with each node in its own community.
+
+    dq: float
+        The change in modularity when merging the next two communities
+        that leads to the largest modularity.
+
+    See Also
+    --------
+    modularity
+
+    References
+    ----------
+    .. [1] Newman, M. E. J. "Networks: An Introduction", page 224
+       Oxford University Press 2011.
+    .. [2] Clauset, A., Newman, M. E., & Moore, C.
+       "Finding community structure in very large networks."
+       Physical Review E 70(6), 2004.
+    .. [3] Reichardt and Bornholdt "Statistical Mechanics of Community
+       Detection" Phys. Rev. E74, 2006.
+    .. [4] Newman, M. E. J."Analysis of weighted networks"
+       Physical Review E 70(5 Pt 2):056131, 2004.
+    """
+    directed = G.is_directed()
+    N = G.number_of_nodes()
+
+    # Count edges (or the sum of edge-weights for weighted graphs)
+    m = G.size(weight)
+    q0 = 1 / m
+
+    # Calculate degrees (notation from the papers)
+    # a : the fraction of (weighted) out-degree for each node
+    # b : the fraction of (weighted) in-degree for each node
+    if directed:
+        a = {node: deg_out * q0 for node, deg_out in G.out_degree(weight=weight)}
+        b = {node: deg_in * q0 for node, deg_in in G.in_degree(weight=weight)}
+    else:
+        a = b = {node: deg * q0 * 0.5 for node, deg in G.degree(weight=weight)}
+
+    # this preliminary step collects the edge weights for each node pair
+    # It handles multigraph and digraph and works fine for graph.
+    dq_dict = defaultdict(lambda: defaultdict(float))
+    for u, v, wt in G.edges(data=weight, default=1):
+        if u == v:
+            continue
+        dq_dict[u][v] += wt
+        dq_dict[v][u] += wt
+
+    # now scale and subtract the expected edge-weights term
+    for u, nbrdict in dq_dict.items():
+        for v, wt in nbrdict.items():
+            dq_dict[u][v] = q0 * wt - resolution * (a[u] * b[v] + b[u] * a[v])
+
+    # Use -dq to get a max_heap instead of a min_heap
+    # dq_heap holds a heap for each node's neighbors
+    dq_heap = {u: MappedQueue({(u, v): -dq for v, dq in dq_dict[u].items()}) for u in G}
+    # H -> all_dq_heap holds a heap with the best items for each node
+    H = MappedQueue([dq_heap[n].heap[0] for n in G if len(dq_heap[n]) > 0])
+
+    # Initialize single-node communities
+    communities = {n: frozenset([n]) for n in G}
+    yield communities.values()
+
+    # Merge the two communities that lead to the largest modularity
+    while len(H) > 1:
+        # Find best merge
+        # Remove from heap of row maxes
+        # Ties will be broken by choosing the pair with lowest min community id
+        try:
+            negdq, u, v = H.pop()
+        except IndexError:
+            break
+        dq = -negdq
+        yield dq
+        # Remove best merge from row u heap
+        dq_heap[u].pop()
+        # Push new row max onto H
+        if len(dq_heap[u]) > 0:
+            H.push(dq_heap[u].heap[0])
+        # If this element was also at the root of row v, we need to remove the
+        # duplicate entry from H
+        if dq_heap[v].heap[0] == (v, u):
+            H.remove((v, u))
+            # Remove best merge from row v heap
+            dq_heap[v].remove((v, u))
+            # Push new row max onto H
+            if len(dq_heap[v]) > 0:
+                H.push(dq_heap[v].heap[0])
+        else:
+            # Duplicate wasn't in H, just remove from row v heap
+            dq_heap[v].remove((v, u))
+
+        # Perform merge
+        communities[v] = frozenset(communities[u] | communities[v])
+        del communities[u]
+
+        # Get neighbor communities connected to the merged communities
+        u_nbrs = set(dq_dict[u])
+        v_nbrs = set(dq_dict[v])
+        all_nbrs = (u_nbrs | v_nbrs) - {u, v}
+        both_nbrs = u_nbrs & v_nbrs
+        # Update dq for merge of u into v
+        for w in all_nbrs:
+            # Calculate new dq value
+            if w in both_nbrs:
+                dq_vw = dq_dict[v][w] + dq_dict[u][w]
+            elif w in v_nbrs:
+                dq_vw = dq_dict[v][w] - resolution * (a[u] * b[w] + a[w] * b[u])
+            else:  # w in u_nbrs
+                dq_vw = dq_dict[u][w] - resolution * (a[v] * b[w] + a[w] * b[v])
+            # Update rows v and w
+            for row, col in [(v, w), (w, v)]:
+                dq_heap_row = dq_heap[row]
+                # Update dict for v,w only (u is removed below)
+                dq_dict[row][col] = dq_vw
+                # Save old max of per-row heap
+                if len(dq_heap_row) > 0:
+                    d_oldmax = dq_heap_row.heap[0]
+                else:
+                    d_oldmax = None
+                # Add/update heaps
+                d = (row, col)
+                d_negdq = -dq_vw
+                # Save old value for finding heap index
+                if w in v_nbrs:
+                    # Update existing element in per-row heap
+                    dq_heap_row.update(d, d, priority=d_negdq)
+                else:
+                    # We're creating a new nonzero element, add to heap
+                    dq_heap_row.push(d, priority=d_negdq)
+                # Update heap of row maxes if necessary
+                if d_oldmax is None:
+                    # No entries previously in this row, push new max
+                    H.push(d, priority=d_negdq)
+                else:
+                    # We've updated an entry in this row, has the max changed?
+                    row_max = dq_heap_row.heap[0]
+                    if d_oldmax != row_max or d_oldmax.priority != row_max.priority:
+                        H.update(d_oldmax, row_max)
+
+        # Remove row/col u from dq_dict matrix
+        for w in dq_dict[u]:
+            # Remove from dict
+            dq_old = dq_dict[w][u]
+            del dq_dict[w][u]
+            # Remove from heaps if we haven't already
+            if w != v:
+                # Remove both row and column
+                for row, col in [(w, u), (u, w)]:
+                    dq_heap_row = dq_heap[row]
+                    # Check if replaced dq is row max
+                    d_old = (row, col)
+                    if dq_heap_row.heap[0] == d_old:
+                        # Update per-row heap and heap of row maxes
+                        dq_heap_row.remove(d_old)
+                        H.remove(d_old)
+                        # Update row max
+                        if len(dq_heap_row) > 0:
+                            H.push(dq_heap_row.heap[0])
+                    else:
+                        # Only update per-row heap
+                        dq_heap_row.remove(d_old)
+
+        del dq_dict[u]
+        # Mark row u as deleted, but keep placeholder
+        dq_heap[u] = MappedQueue()
+        # Merge u into v and update a
+        a[v] += a[u]
+        a[u] = 0
+        if directed:
+            b[v] += b[u]
+            b[u] = 0
+
+        yield communities.values()
+
+
+def greedy_modularity_communities(
+    G, weight=None, resolution=1, cutoff=1, best_n=None, n_communities=None
+):
+    r"""Find communities in G using greedy modularity maximization.
+
+    This function uses Clauset-Newman-Moore greedy modularity maximization [2]_
+    to find the community partition with the largest modularity.
+
+    Greedy modularity maximization begins with each node in its own community
+    and repeatedly joins the pair of communities that lead to the largest
+    modularity until no futher increase in modularity is possible (a maximum).
+    Two keyword arguments adjust the stopping condition. `cutoff` is a lower
+    limit on the number of communities so you can stop the process before
+    reaching a maximum (used to save computation time). `best_n` is an upper
+    limit on the number of communities so you can make the process continue
+    until at most n communities remain even if the maximum modularity occurs
+    for more. To obtain exactly n communities, set both `cutoff` and `best_n` to n.
+
+    This function maximizes the generalized modularity, where `resolution`
+    is the resolution parameter, often expressed as $\gamma$.
+    See :func:`~networkx.algorithms.community.quality.modularity`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight : string or None, optional (default=None)
+        The name of an edge attribute that holds the numerical value used
+        as a weight.  If None, then each edge has weight 1.
+        The degree is the sum of the edge weights adjacent to the node.
+
+    resolution : float, optional (default=1)
+        If resolution is less than 1, modularity favors larger communities.
+        Greater than 1 favors smaller communities.
+
+    cutoff : int, optional (default=1)
+        A minimum number of communities below which the merging process stops.
+        The process stops at this number of communities even if modularity
+        is not maximized. The goal is to let the user stop the process early.
+        The process stops before the cutoff if it finds a maximum of modularity.
+
+    best_n : int or None, optional (default=None)
+        A maximum number of communities above which the merging process will
+        not stop. This forces community merging to continue after modularity
+        starts to decrease until `best_n` communities remain.
+        If ``None``, don't force it to continue beyond a maximum.
+
+    n_communities : int or None, optional (default=None)
+
+        .. deprecated:: 3.0
+           The `n_communities` parameter is deprecated - use `cutoff` and/or
+           `best_n` to set bounds on the desired number of communities instead.
+
+        A minimum number of communities below which the merging process stops.
+        The process stops at this number of communities even if modularity
+        is not maximized. The goal is to let the user stop the process early.
+        The process stops before the cutoff if it finds a maximum of modularity.
+
+    Raises
+    ------
+    ValueError : If the `cutoff` or `best_n`  value is not in the range
+        ``[1, G.number_of_nodes()]``, or if `best_n` < `cutoff`.
+        Also raised if `cutoff` is used with the deprecated `n_communities`
+        parameter.
+
+    Returns
+    -------
+    communities: list
+        A list of frozensets of nodes, one for each community.
+        Sorted by length with largest communities first.
+
+    Examples
+    --------
+    >>> from networkx.algorithms.community import greedy_modularity_communities
+    >>> G = nx.karate_club_graph()
+    >>> c = greedy_modularity_communities(G)
+    >>> sorted(c[0])
+    [8, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33]
+
+    See Also
+    --------
+    modularity
+
+    References
+    ----------
+    .. [1] Newman, M. E. J. "Networks: An Introduction", page 224
+       Oxford University Press 2011.
+    .. [2] Clauset, A., Newman, M. E., & Moore, C.
+       "Finding community structure in very large networks."
+       Physical Review E 70(6), 2004.
+    .. [3] Reichardt and Bornholdt "Statistical Mechanics of Community
+       Detection" Phys. Rev. E74, 2006.
+    .. [4] Newman, M. E. J."Analysis of weighted networks"
+       Physical Review E 70(5 Pt 2):056131, 2004.
+    """
+    if (cutoff < 1) or (cutoff > G.number_of_nodes()):
+        raise ValueError(f"cutoff must be between 1 and {len(G)}. Got {cutoff}.")
+    if best_n is not None:
+        if (best_n < 1) or (best_n > G.number_of_nodes()):
+            raise ValueError(f"best_n must be between 1 and {len(G)}. Got {best_n}.")
+        if best_n < cutoff:
+            raise ValueError(f"Must have best_n >= cutoff. Got {best_n} < {cutoff}")
+        if best_n == 1:
+            return [set(G)]
+    else:
+        best_n = G.number_of_nodes()
+    if n_communities is not None:
+        import warnings
+
+        warnings.warn(
+            "kwarg ``n_communities`` in greedy_modularity_communities is deprecated"
+            "and will be removed in version 3.0.   Use ``cutoff`` instead.",
+            DeprecationWarning,
+        )
+        if cutoff == 1:
+            cutoff = n_communities
+        else:
+            raise ValueError(f"Can not set both n_communities and cutoff.")
+
+    # retrieve generator object to construct output
+    community_gen = _greedy_modularity_communities_generator(
+        G, weight=weight, resolution=resolution
+    )
+
+    # construct the first best community
+    communities = next(community_gen)
+
+    # continue merging communities until one of the breaking criteria is satisfied
+    while len(communities) > cutoff:
+        try:
+            dq = next(community_gen)
+        # StopIteration occurs when communities are the connected components
+        except StopIteration:
+            communities = sorted(communities, key=len, reverse=True)
+            # if best_n requires more merging, merge big sets for highest modularity
+            while len(communities) > best_n:
+                comm1, comm2, *rest = communities
+                communities = [comm1 ^ comm2]
+                communities.extend(rest)
+            return communities
+
+        # keep going unless max_mod is reached or best_n says to merge more
+        if dq < 0 and len(communities) <= best_n:
+            break
+        communities = next(community_gen)
+
+    return sorted(communities, key=len, reverse=True)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def naive_greedy_modularity_communities(G, resolution=1, weight=None):
+    r"""Find communities in G using greedy modularity maximization.
+
+    This implementation is O(n^4), much slower than alternatives, but it is
+    provided as an easy-to-understand reference implementation.
+
+    Greedy modularity maximization begins with each node in its own community
+    and joins the pair of communities that most increases modularity until no
+    such pair exists.
+
+    This function maximizes the generalized modularity, where `resolution`
+    is the resolution parameter, often expressed as $\gamma$.
+    See :func:`~networkx.algorithms.community.quality.modularity`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    resolution : float (default=1)
+        If resolution is less than 1, modularity favors larger communities.
+        Greater than 1 favors smaller communities.
+
+    weight : string or None, optional (default=None)
+        The name of an edge attribute that holds the numerical value used
+        as a weight.  If None, then each edge has weight 1.
+        The degree is the sum of the edge weights adjacent to the node.
+
+    Returns
+    -------
+    list
+        A list of sets of nodes, one for each community.
+        Sorted by length with largest communities first.
+
+    Examples
+    --------
+    >>> from networkx.algorithms.community import \
+    ... naive_greedy_modularity_communities
+    >>> G = nx.karate_club_graph()
+    >>> c = naive_greedy_modularity_communities(G)
+    >>> sorted(c[0])
+    [8, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33]
+
+    See Also
+    --------
+    greedy_modularity_communities
+    modularity
+    """
+    # First create one community for each node
+    communities = list(frozenset([u]) for u in G.nodes())
+    # Track merges
+    merges = []
+    # Greedily merge communities until no improvement is possible
+    old_modularity = None
+    new_modularity = modularity(G, communities, resolution=resolution, weight=weight)
+    while old_modularity is None or new_modularity > old_modularity:
+        # Save modularity for comparison
+        old_modularity = new_modularity
+        # Find best pair to merge
+        trial_communities = list(communities)
+        to_merge = None
+        for i, u in enumerate(communities):
+            for j, v in enumerate(communities):
+                # Skip i==j and empty communities
+                if j <= i or len(u) == 0 or len(v) == 0:
+                    continue
+                # Merge communities u and v
+                trial_communities[j] = u | v
+                trial_communities[i] = frozenset([])
+                trial_modularity = modularity(
+                    G, trial_communities, resolution=resolution, weight=weight
+                )
+                if trial_modularity >= new_modularity:
+                    # Check if strictly better or tie
+                    if trial_modularity > new_modularity:
+                        # Found new best, save modularity and group indexes
+                        new_modularity = trial_modularity
+                        to_merge = (i, j, new_modularity - old_modularity)
+                    elif to_merge and min(i, j) < min(to_merge[0], to_merge[1]):
+                        # Break ties by choosing pair with lowest min id
+                        new_modularity = trial_modularity
+                        to_merge = (i, j, new_modularity - old_modularity)
+                # Un-merge
+                trial_communities[i] = u
+                trial_communities[j] = v
+        if to_merge is not None:
+            # If the best merge improves modularity, use it
+            merges.append(to_merge)
+            i, j, dq = to_merge
+            u, v = communities[i], communities[j]
+            communities[j] = u | v
+            communities[i] = frozenset([])
+    # Remove empty communities and sort
+    return sorted((c for c in communities if len(c) > 0), key=len, reverse=True)
+
+
+# old name
+_naive_greedy_modularity_communities = naive_greedy_modularity_communities
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/quality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/quality.py
new file mode 100644
index 0000000..7de8059
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/quality.py
@@ -0,0 +1,443 @@
+"""Functions for measuring the quality of a partition (into
+communities).
+
+"""
+
+from itertools import combinations
+
+import networkx as nx
+from networkx import NetworkXError
+from networkx.algorithms.community.community_utils import is_partition
+from networkx.utils import not_implemented_for
+from networkx.utils.decorators import argmap
+
+__all__ = ["coverage", "modularity", "performance", "partition_quality"]
+
+
+class NotAPartition(NetworkXError):
+    """Raised if a given collection is not a partition."""
+
+    def __init__(self, G, collection):
+        msg = f"{G} is not a valid partition of the graph {collection}"
+        super().__init__(msg)
+
+
+def _require_partition(G, partition):
+    """Decorator to check that a valid partition is input to a function
+
+    Raises :exc:`networkx.NetworkXError` if the partition is not valid.
+
+    This decorator should be used on functions whose first two arguments
+    are a graph and a partition of the nodes of that graph (in that
+    order)::
+
+        >>> @require_partition
+        ... def foo(G, partition):
+        ...     print("partition is valid!")
+        ...
+        >>> G = nx.complete_graph(5)
+        >>> partition = [{0, 1}, {2, 3}, {4}]
+        >>> foo(G, partition)
+        partition is valid!
+        >>> partition = [{0}, {2, 3}, {4}]
+        >>> foo(G, partition)
+        Traceback (most recent call last):
+          ...
+        networkx.exception.NetworkXError: `partition` is not a valid partition of the nodes of G
+        >>> partition = [{0, 1}, {1, 2, 3}, {4}]
+        >>> foo(G, partition)
+        Traceback (most recent call last):
+          ...
+        networkx.exception.NetworkXError: `partition` is not a valid partition of the nodes of G
+
+    """
+    if is_partition(G, partition):
+        return G, partition
+    raise nx.NetworkXError("`partition` is not a valid partition of the nodes of G")
+
+
+require_partition = argmap(_require_partition, (0, 1))
+
+
+def intra_community_edges(G, partition):
+    """Returns the number of intra-community edges for a partition of `G`.
+
+    Parameters
+    ----------
+    G : NetworkX graph.
+
+    partition : iterable of sets of nodes
+        This must be a partition of the nodes of `G`.
+
+    The "intra-community edges" are those edges joining a pair of nodes
+    in the same block of the partition.
+
+    """
+    return sum(G.subgraph(block).size() for block in partition)
+
+
+def inter_community_edges(G, partition):
+    """Returns the number of inter-community edges for a partition of `G`.
+    according to the given
+    partition of the nodes of `G`.
+
+    Parameters
+    ----------
+    G : NetworkX graph.
+
+    partition : iterable of sets of nodes
+        This must be a partition of the nodes of `G`.
+
+    The *inter-community edges* are those edges joining a pair of nodes
+    in different blocks of the partition.
+
+    Implementation note: this function creates an intermediate graph
+    that may require the same amount of memory as that of `G`.
+
+    """
+    # Alternate implementation that does not require constructing a new
+    # graph object (but does require constructing an affiliation
+    # dictionary):
+    #
+    #     aff = dict(chain.from_iterable(((v, block) for v in block)
+    #                                    for block in partition))
+    #     return sum(1 for u, v in G.edges() if aff[u] != aff[v])
+    #
+    MG = nx.MultiDiGraph if G.is_directed() else nx.MultiGraph
+    return nx.quotient_graph(G, partition, create_using=MG).size()
+
+
+def inter_community_non_edges(G, partition):
+    """Returns the number of inter-community non-edges according to the
+    given partition of the nodes of `G`.
+
+    Parameters
+    ----------
+    G : NetworkX graph.
+
+    partition : iterable of sets of nodes
+        This must be a partition of the nodes of `G`.
+
+    A *non-edge* is a pair of nodes (undirected if `G` is undirected)
+    that are not adjacent in `G`. The *inter-community non-edges* are
+    those non-edges on a pair of nodes in different blocks of the
+    partition.
+
+    Implementation note: this function creates two intermediate graphs,
+    which may require up to twice the amount of memory as required to
+    store `G`.
+
+    """
+    # Alternate implementation that does not require constructing two
+    # new graph objects (but does require constructing an affiliation
+    # dictionary):
+    #
+    #     aff = dict(chain.from_iterable(((v, block) for v in block)
+    #                                    for block in partition))
+    #     return sum(1 for u, v in nx.non_edges(G) if aff[u] != aff[v])
+    #
+    return inter_community_edges(nx.complement(G), partition)
+
+
+@not_implemented_for("multigraph")
+@require_partition
+def performance(G, partition):
+    """Returns the performance of a partition.
+
+    .. deprecated:: 2.6
+       Use `partition_quality` instead.
+
+    The *performance* of a partition is the number of
+    intra-community edges plus inter-community non-edges divided by the total
+    number of potential edges.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A simple graph (directed or undirected).
+
+    partition : sequence
+        Partition of the nodes of `G`, represented as a sequence of
+        sets of nodes. Each block of the partition represents a
+        community.
+
+    Returns
+    -------
+    float
+        The performance of the partition, as defined above.
+
+    Raises
+    ------
+    NetworkXError
+        If `partition` is not a valid partition of the nodes of `G`.
+
+    References
+    ----------
+    .. [1] Santo Fortunato.
+           "Community Detection in Graphs".
+           *Physical Reports*, Volume 486, Issue 3--5 pp. 75--174
+           <https://arxiv.org/abs/0906.0612>
+
+    """
+    # Compute the number of intra-community edges and inter-community
+    # edges.
+    intra_edges = intra_community_edges(G, partition)
+    inter_edges = inter_community_non_edges(G, partition)
+    # Compute the number of edges in the complete graph (directed or
+    # undirected, as it depends on `G`) on `n` nodes.
+    #
+    # (If `G` is an undirected graph, we divide by two since we have
+    # double-counted each potential edge. We use integer division since
+    # `total_pairs` is guaranteed to be even.)
+    n = len(G)
+    total_pairs = n * (n - 1)
+    if not G.is_directed():
+        total_pairs //= 2
+    return (intra_edges + inter_edges) / total_pairs
+
+
+@require_partition
+def coverage(G, partition):
+    """Returns the coverage of a partition.
+
+    .. deprecated:: 2.6
+       Use `partition_quality` instead.
+
+    The *coverage* of a partition is the ratio of the number of
+    intra-community edges to the total number of edges in the graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    partition : sequence
+        Partition of the nodes of `G`, represented as a sequence of
+        sets of nodes. Each block of the partition represents a
+        community.
+
+    Returns
+    -------
+    float
+        The coverage of the partition, as defined above.
+
+    Raises
+    ------
+    NetworkXError
+        If `partition` is not a valid partition of the nodes of `G`.
+
+    Notes
+    -----
+    If `G` is a multigraph, the multiplicity of edges is counted.
+
+    References
+    ----------
+    .. [1] Santo Fortunato.
+           "Community Detection in Graphs".
+           *Physical Reports*, Volume 486, Issue 3--5 pp. 75--174
+           <https://arxiv.org/abs/0906.0612>
+
+    """
+    intra_edges = intra_community_edges(G, partition)
+    total_edges = G.number_of_edges()
+    return intra_edges / total_edges
+
+
+def modularity(G, communities, weight="weight", resolution=1):
+    r"""Returns the modularity of the given partition of the graph.
+
+    Modularity is defined in [1]_ as
+
+    .. math::
+        Q = \frac{1}{2m} \sum_{ij} \left( A_{ij} - \gamma\frac{k_ik_j}{2m}\right)
+            \delta(c_i,c_j)
+
+    where $m$ is the number of edges, $A$ is the adjacency matrix of `G`,
+    $k_i$ is the degree of $i$, $\gamma$ is the resolution parameter,
+    and $\delta(c_i, c_j)$ is 1 if $i$ and $j$ are in the same community else 0.
+
+    According to [2]_ (and verified by some algebra) this can be reduced to
+
+    .. math::
+       Q = \sum_{c=1}^{n}
+       \left[ \frac{L_c}{m} - \gamma\left( \frac{k_c}{2m} \right) ^2 \right]
+
+    where the sum iterates over all communities $c$, $m$ is the number of edges,
+    $L_c$ is the number of intra-community links for community $c$,
+    $k_c$ is the sum of degrees of the nodes in community $c$,
+    and $\gamma$ is the resolution parameter.
+
+    The resolution parameter sets an arbitrary tradeoff between intra-group
+    edges and inter-group edges. More complex grouping patterns can be
+    discovered by analyzing the same network with multiple values of gamma
+    and then combining the results [3]_. That said, it is very common to
+    simply use gamma=1. More on the choice of gamma is in [4]_.
+
+    The second formula is the one actually used in calculation of the modularity.
+    For directed graphs the second formula replaces $k_c$ with $k^{in}_c k^{out}_c$.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+
+    communities : list or iterable of set of nodes
+        These node sets must represent a partition of G's nodes.
+
+    weight : string or None, optional (default="weight")
+        The edge attribute that holds the numerical value used
+        as a weight. If None or an edge does not have that attribute,
+        then that edge has weight 1.
+
+    resolution : float (default=1)
+        If resolution is less than 1, modularity favors larger communities.
+        Greater than 1 favors smaller communities.
+
+    Returns
+    -------
+    Q : float
+        The modularity of the paritition.
+
+    Raises
+    ------
+    NotAPartition
+        If `communities` is not a partition of the nodes of `G`.
+
+    Examples
+    --------
+    >>> import networkx.algorithms.community as nx_comm
+    >>> G = nx.barbell_graph(3, 0)
+    >>> nx_comm.modularity(G, [{0, 1, 2}, {3, 4, 5}])
+    0.35714285714285715
+    >>> nx_comm.modularity(G, nx_comm.label_propagation_communities(G))
+    0.35714285714285715
+
+    References
+    ----------
+    .. [1] M. E. J. Newman "Networks: An Introduction", page 224.
+       Oxford University Press, 2011.
+    .. [2] Clauset, Aaron, Mark EJ Newman, and Cristopher Moore.
+       "Finding community structure in very large networks."
+       Phys. Rev. E 70.6 (2004). <https://arxiv.org/abs/cond-mat/0408187>
+    .. [3] Reichardt and Bornholdt "Statistical Mechanics of Community Detection"
+       Phys. Rev. E 74, 016110, 2006. https://doi.org/10.1103/PhysRevE.74.016110
+    .. [4] M. E. J. Newman, "Equivalence between modularity optimization and
+       maximum likelihood methods for community detection"
+       Phys. Rev. E 94, 052315, 2016. https://doi.org/10.1103/PhysRevE.94.052315
+
+    """
+    if not isinstance(communities, list):
+        communities = list(communities)
+    if not is_partition(G, communities):
+        raise NotAPartition(G, communities)
+
+    directed = G.is_directed()
+    if directed:
+        out_degree = dict(G.out_degree(weight=weight))
+        in_degree = dict(G.in_degree(weight=weight))
+        m = sum(out_degree.values())
+        norm = 1 / m**2
+    else:
+        out_degree = in_degree = dict(G.degree(weight=weight))
+        deg_sum = sum(out_degree.values())
+        m = deg_sum / 2
+        norm = 1 / deg_sum**2
+
+    def community_contribution(community):
+        comm = set(community)
+        L_c = sum(wt for u, v, wt in G.edges(comm, data=weight, default=1) if v in comm)
+
+        out_degree_sum = sum(out_degree[u] for u in comm)
+        in_degree_sum = sum(in_degree[u] for u in comm) if directed else out_degree_sum
+
+        return L_c / m - resolution * out_degree_sum * in_degree_sum * norm
+
+    return sum(map(community_contribution, communities))
+
+
+@require_partition
+def partition_quality(G, partition):
+    """Returns the coverage and performance of a partition of G.
+
+    The *coverage* of a partition is the ratio of the number of
+    intra-community edges to the total number of edges in the graph.
+
+    The *performance* of a partition is the number of
+    intra-community edges plus inter-community non-edges divided by the total
+    number of potential edges.
+
+    This algorithm has complexity $O(C^2 + L)$ where C is the number of communities and L is the number of links.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    partition : sequence
+        Partition of the nodes of `G`, represented as a sequence of
+        sets of nodes (blocks). Each block of the partition represents a
+        community.
+
+    Returns
+    -------
+    (float, float)
+        The (coverage, performance) tuple of the partition, as defined above.
+
+    Raises
+    ------
+    NetworkXError
+        If `partition` is not a valid partition of the nodes of `G`.
+
+    Notes
+    -----
+    If `G` is a multigraph;
+        - for coverage, the multiplicity of edges is counted
+        - for performance, the result is -1 (total number of possible edges is not defined)
+
+    References
+    ----------
+    .. [1] Santo Fortunato.
+           "Community Detection in Graphs".
+           *Physical Reports*, Volume 486, Issue 3--5 pp. 75--174
+           <https://arxiv.org/abs/0906.0612>
+    """
+
+    node_community = {}
+    for i, community in enumerate(partition):
+        for node in community:
+            node_community[node] = i
+
+    # `performance` is not defined for multigraphs
+    if not G.is_multigraph():
+        # Iterate over the communities, quadratic, to calculate `possible_inter_community_edges`
+        possible_inter_community_edges = sum(
+            len(p1) * len(p2) for p1, p2 in combinations(partition, 2)
+        )
+
+        if G.is_directed():
+            possible_inter_community_edges *= 2
+    else:
+        possible_inter_community_edges = 0
+
+    # Compute the number of edges in the complete graph -- `n` nodes,
+    # directed or undirected, depending on `G`
+    n = len(G)
+    total_pairs = n * (n - 1)
+    if not G.is_directed():
+        total_pairs //= 2
+
+    intra_community_edges = 0
+    inter_community_non_edges = possible_inter_community_edges
+
+    # Iterate over the links to count `intra_community_edges` and `inter_community_non_edges`
+    for e in G.edges():
+        if node_community[e[0]] == node_community[e[1]]:
+            intra_community_edges += 1
+        else:
+            inter_community_non_edges -= 1
+
+    coverage = intra_community_edges / len(G.edges)
+
+    if G.is_multigraph():
+        performance = -1.0
+    else:
+        performance = (intra_community_edges + inter_community_non_edges) / total_pairs
+
+    return coverage, performance
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_asyn_fluid.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_asyn_fluid.py
new file mode 100644
index 0000000..f87e367
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_asyn_fluid.py
@@ -0,0 +1,128 @@
+import pytest
+
+from networkx import Graph, NetworkXError
+from networkx.algorithms.community.asyn_fluid import asyn_fluidc
+
+
+def test_exceptions():
+    test = Graph()
+    test.add_node("a")
+    pytest.raises(NetworkXError, asyn_fluidc, test, "hi")
+    pytest.raises(NetworkXError, asyn_fluidc, test, -1)
+    pytest.raises(NetworkXError, asyn_fluidc, test, 3)
+    test.add_node("b")
+    pytest.raises(NetworkXError, asyn_fluidc, test, 1)
+
+
+def test_single_node():
+    test = Graph()
+
+    test.add_node("a")
+
+    # ground truth
+    ground_truth = {frozenset(["a"])}
+
+    communities = asyn_fluidc(test, 1)
+    result = {frozenset(c) for c in communities}
+    assert result == ground_truth
+
+
+def test_two_nodes():
+    test = Graph()
+
+    test.add_edge("a", "b")
+
+    # ground truth
+    ground_truth = {frozenset(["a"]), frozenset(["b"])}
+
+    communities = asyn_fluidc(test, 2)
+    result = {frozenset(c) for c in communities}
+    assert result == ground_truth
+
+
+def test_two_clique_communities():
+    test = Graph()
+
+    # c1
+    test.add_edge("a", "b")
+    test.add_edge("a", "c")
+    test.add_edge("b", "c")
+
+    # connection
+    test.add_edge("c", "d")
+
+    # c2
+    test.add_edge("d", "e")
+    test.add_edge("d", "f")
+    test.add_edge("f", "e")
+
+    # ground truth
+    ground_truth = {frozenset(["a", "c", "b"]), frozenset(["e", "d", "f"])}
+
+    communities = asyn_fluidc(test, 2, seed=7)
+    result = {frozenset(c) for c in communities}
+    assert result == ground_truth
+
+
+def test_five_clique_ring():
+    test = Graph()
+
+    # c1
+    test.add_edge("1a", "1b")
+    test.add_edge("1a", "1c")
+    test.add_edge("1a", "1d")
+    test.add_edge("1b", "1c")
+    test.add_edge("1b", "1d")
+    test.add_edge("1c", "1d")
+
+    # c2
+    test.add_edge("2a", "2b")
+    test.add_edge("2a", "2c")
+    test.add_edge("2a", "2d")
+    test.add_edge("2b", "2c")
+    test.add_edge("2b", "2d")
+    test.add_edge("2c", "2d")
+
+    # c3
+    test.add_edge("3a", "3b")
+    test.add_edge("3a", "3c")
+    test.add_edge("3a", "3d")
+    test.add_edge("3b", "3c")
+    test.add_edge("3b", "3d")
+    test.add_edge("3c", "3d")
+
+    # c4
+    test.add_edge("4a", "4b")
+    test.add_edge("4a", "4c")
+    test.add_edge("4a", "4d")
+    test.add_edge("4b", "4c")
+    test.add_edge("4b", "4d")
+    test.add_edge("4c", "4d")
+
+    # c5
+    test.add_edge("5a", "5b")
+    test.add_edge("5a", "5c")
+    test.add_edge("5a", "5d")
+    test.add_edge("5b", "5c")
+    test.add_edge("5b", "5d")
+    test.add_edge("5c", "5d")
+
+    # connections
+    test.add_edge("1a", "2c")
+    test.add_edge("2a", "3c")
+    test.add_edge("3a", "4c")
+    test.add_edge("4a", "5c")
+    test.add_edge("5a", "1c")
+
+    # ground truth
+    ground_truth = {
+        frozenset(["1a", "1b", "1c", "1d"]),
+        frozenset(["2a", "2b", "2c", "2d"]),
+        frozenset(["3a", "3b", "3c", "3d"]),
+        frozenset(["4a", "4b", "4c", "4d"]),
+        frozenset(["5a", "5b", "5c", "5d"]),
+    }
+
+    communities = asyn_fluidc(test, 5, seed=9)
+    result = {frozenset(c) for c in communities}
+    assert result == ground_truth
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_centrality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_centrality.py
new file mode 100644
index 0000000..43b6d2b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_centrality.py
@@ -0,0 +1,85 @@
+"""Unit tests for the :mod:`networkx.algorithms.community.centrality`
+module.
+
+"""
+from operator import itemgetter
+
+import networkx as nx
+from networkx.algorithms.community import girvan_newman
+
+
+def set_of_sets(iterable):
+    return set(map(frozenset, iterable))
+
+
+def validate_communities(result, expected):
+    assert set_of_sets(result) == set_of_sets(expected)
+
+
+def validate_possible_communities(result, *expected):
+    assert any(set_of_sets(result) == set_of_sets(p) for p in expected)
+
+
+class TestGirvanNewman:
+    """Unit tests for the
+    :func:`networkx.algorithms.community.centrality.girvan_newman`
+    function.
+
+    """
+
+    def test_no_edges(self):
+        G = nx.empty_graph(3)
+        communities = list(girvan_newman(G))
+        assert len(communities) == 1
+        validate_communities(communities[0], [{0}, {1}, {2}])
+
+    def test_undirected(self):
+        # Start with the graph .-.-.-.
+        G = nx.path_graph(4)
+        communities = list(girvan_newman(G))
+        assert len(communities) == 3
+        # After one removal, we get the graph .-. .-.
+        validate_communities(communities[0], [{0, 1}, {2, 3}])
+        # After the next, we get the graph .-. . ., but there are two
+        # symmetric possible versions.
+        validate_possible_communities(
+            communities[1], [{0}, {1}, {2, 3}], [{0, 1}, {2}, {3}]
+        )
+        # After the last removal, we always get the empty graph.
+        validate_communities(communities[2], [{0}, {1}, {2}, {3}])
+
+    def test_directed(self):
+        G = nx.DiGraph(nx.path_graph(4))
+        communities = list(girvan_newman(G))
+        assert len(communities) == 3
+        validate_communities(communities[0], [{0, 1}, {2, 3}])
+        validate_possible_communities(
+            communities[1], [{0}, {1}, {2, 3}], [{0, 1}, {2}, {3}]
+        )
+        validate_communities(communities[2], [{0}, {1}, {2}, {3}])
+
+    def test_selfloops(self):
+        G = nx.path_graph(4)
+        G.add_edge(0, 0)
+        G.add_edge(2, 2)
+        communities = list(girvan_newman(G))
+        assert len(communities) == 3
+        validate_communities(communities[0], [{0, 1}, {2, 3}])
+        validate_possible_communities(
+            communities[1], [{0}, {1}, {2, 3}], [{0, 1}, {2}, {3}]
+        )
+        validate_communities(communities[2], [{0}, {1}, {2}, {3}])
+
+    def test_most_valuable_edge(self):
+        G = nx.Graph()
+        G.add_weighted_edges_from([(0, 1, 3), (1, 2, 2), (2, 3, 1)])
+        # Let the most valuable edge be the one with the highest weight.
+
+        def heaviest(G):
+            return max(G.edges(data="weight"), key=itemgetter(2))[:2]
+
+        communities = list(girvan_newman(G, heaviest))
+        assert len(communities) == 3
+        validate_communities(communities[0], [{0}, {1, 2, 3}])
+        validate_communities(communities[1], [{0}, {1}, {2, 3}])
+        validate_communities(communities[2], [{0}, {1}, {2}, {3}])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_kclique.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_kclique.py
new file mode 100644
index 0000000..ffac175
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_kclique.py
@@ -0,0 +1,92 @@
+from itertools import combinations
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.community import k_clique_communities
+
+
+def test_overlapping_K5():
+    G = nx.Graph()
+    G.add_edges_from(combinations(range(5), 2))  # Add a five clique
+    G.add_edges_from(combinations(range(2, 7), 2))  # Add another five clique
+    c = list(k_clique_communities(G, 4))
+    assert c == [frozenset(range(7))]
+    c = set(k_clique_communities(G, 5))
+    assert c == {frozenset(range(5)), frozenset(range(2, 7))}
+
+
+def test_isolated_K5():
+    G = nx.Graph()
+    G.add_edges_from(combinations(range(0, 5), 2))  # Add a five clique
+    G.add_edges_from(combinations(range(5, 10), 2))  # Add another five clique
+    c = set(k_clique_communities(G, 5))
+    assert c == {frozenset(range(5)), frozenset(range(5, 10))}
+
+
+class TestZacharyKarateClub:
+    def setup(self):
+        self.G = nx.karate_club_graph()
+
+    def _check_communities(self, k, expected):
+        communities = set(k_clique_communities(self.G, k))
+        assert communities == expected
+
+    def test_k2(self):
+        # clique percolation with k=2 is just connected components
+        expected = {frozenset(self.G)}
+        self._check_communities(2, expected)
+
+    def test_k3(self):
+        comm1 = [
+            0,
+            1,
+            2,
+            3,
+            7,
+            8,
+            12,
+            13,
+            14,
+            15,
+            17,
+            18,
+            19,
+            20,
+            21,
+            22,
+            23,
+            26,
+            27,
+            28,
+            29,
+            30,
+            31,
+            32,
+            33,
+        ]
+        comm2 = [0, 4, 5, 6, 10, 16]
+        comm3 = [24, 25, 31]
+        expected = {frozenset(comm1), frozenset(comm2), frozenset(comm3)}
+        self._check_communities(3, expected)
+
+    def test_k4(self):
+        expected = {
+            frozenset([0, 1, 2, 3, 7, 13]),
+            frozenset([8, 32, 30, 33]),
+            frozenset([32, 33, 29, 23]),
+        }
+        self._check_communities(4, expected)
+
+    def test_k5(self):
+        expected = {frozenset([0, 1, 2, 3, 7, 13])}
+        self._check_communities(5, expected)
+
+    def test_k6(self):
+        expected = set()
+        self._check_communities(6, expected)
+
+
+def test_bad_k():
+    with pytest.raises(nx.NetworkXError):
+        list(k_clique_communities(nx.Graph(), 1))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_kernighan_lin.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_kernighan_lin.py
new file mode 100644
index 0000000..3dc5554
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_kernighan_lin.py
@@ -0,0 +1,91 @@
+"""Unit tests for the :mod:`networkx.algorithms.community.kernighan_lin`
+module.
+"""
+from itertools import permutations
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.community import kernighan_lin_bisection
+
+
+def assert_partition_equal(x, y):
+    assert set(map(frozenset, x)) == set(map(frozenset, y))
+
+
+def test_partition():
+    G = nx.barbell_graph(3, 0)
+    C = kernighan_lin_bisection(G)
+    assert_partition_equal(C, [{0, 1, 2}, {3, 4, 5}])
+
+
+def test_partition_argument():
+    G = nx.barbell_graph(3, 0)
+    partition = [{0, 1, 2}, {3, 4, 5}]
+    C = kernighan_lin_bisection(G, partition)
+    assert_partition_equal(C, partition)
+
+
+def test_partition_argument_non_integer_nodes():
+    G = nx.Graph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+    partition = ({"A", "B"}, {"C", "D"})
+    C = kernighan_lin_bisection(G, partition)
+    assert_partition_equal(C, partition)
+
+
+def test_seed_argument():
+    G = nx.barbell_graph(3, 0)
+    C = kernighan_lin_bisection(G, seed=1)
+    assert_partition_equal(C, [{0, 1, 2}, {3, 4, 5}])
+
+
+def test_non_disjoint_partition():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.barbell_graph(3, 0)
+        partition = ({0, 1, 2}, {2, 3, 4, 5})
+        kernighan_lin_bisection(G, partition)
+
+
+def test_too_many_blocks():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.barbell_graph(3, 0)
+        partition = ({0, 1}, {2}, {3, 4, 5})
+        kernighan_lin_bisection(G, partition)
+
+
+def test_multigraph():
+    G = nx.cycle_graph(4)
+    M = nx.MultiGraph(G.edges())
+    M.add_edges_from(G.edges())
+    M.remove_edge(1, 2)
+    for labels in permutations(range(4)):
+        mapping = dict(zip(M, labels))
+        A, B = kernighan_lin_bisection(nx.relabel_nodes(M, mapping), seed=0)
+        assert_partition_equal(
+            [A, B], [{mapping[0], mapping[1]}, {mapping[2], mapping[3]}]
+        )
+
+
+def test_max_iter_argument():
+    G = nx.Graph(
+        [
+            ("A", "B", {"weight": 1}),
+            ("A", "C", {"weight": 2}),
+            ("A", "D", {"weight": 3}),
+            ("A", "E", {"weight": 2}),
+            ("A", "F", {"weight": 4}),
+            ("B", "C", {"weight": 1}),
+            ("B", "D", {"weight": 4}),
+            ("B", "E", {"weight": 2}),
+            ("B", "F", {"weight": 1}),
+            ("C", "D", {"weight": 3}),
+            ("C", "E", {"weight": 2}),
+            ("C", "F", {"weight": 1}),
+            ("D", "E", {"weight": 4}),
+            ("D", "F", {"weight": 3}),
+            ("E", "F", {"weight": 2}),
+        ]
+    )
+    partition = ({"A", "B", "C"}, {"D", "E", "F"})
+    C = kernighan_lin_bisection(G, partition, max_iter=1)
+    assert_partition_equal(C, ({"A", "F", "C"}, {"D", "E", "B"}))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_label_propagation.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_label_propagation.py
new file mode 100644
index 0000000..44e4489
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_label_propagation.py
@@ -0,0 +1,163 @@
+from itertools import chain, combinations
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.community import (
+    asyn_lpa_communities,
+    label_propagation_communities,
+)
+
+
+def test_directed_not_supported():
+    with pytest.raises(nx.NetworkXNotImplemented):
+        # not supported for directed graphs
+        test = nx.DiGraph()
+        test.add_edge("a", "b")
+        test.add_edge("a", "c")
+        test.add_edge("b", "d")
+        result = label_propagation_communities(test)
+
+
+def test_iterator_vs_iterable():
+    G = nx.empty_graph("a")
+    assert list(label_propagation_communities(G)) == [{"a"}]
+    for community in label_propagation_communities(G):
+        assert community == {"a"}
+    pytest.raises(TypeError, next, label_propagation_communities(G))
+
+
+def test_one_node():
+    test = nx.Graph()
+    test.add_node("a")
+
+    # The expected communities are:
+    ground_truth = {frozenset(["a"])}
+
+    communities = label_propagation_communities(test)
+    result = {frozenset(c) for c in communities}
+    assert result == ground_truth
+
+
+def test_unconnected_communities():
+    test = nx.Graph()
+    # community 1
+    test.add_edge("a", "c")
+    test.add_edge("a", "d")
+    test.add_edge("d", "c")
+    # community 2
+    test.add_edge("b", "e")
+    test.add_edge("e", "f")
+    test.add_edge("f", "b")
+
+    # The expected communities are:
+    ground_truth = {frozenset(["a", "c", "d"]), frozenset(["b", "e", "f"])}
+
+    communities = label_propagation_communities(test)
+    result = {frozenset(c) for c in communities}
+    assert result == ground_truth
+
+
+def test_connected_communities():
+    test = nx.Graph()
+    # community 1
+    test.add_edge("a", "b")
+    test.add_edge("c", "a")
+    test.add_edge("c", "b")
+    test.add_edge("d", "a")
+    test.add_edge("d", "b")
+    test.add_edge("d", "c")
+    test.add_edge("e", "a")
+    test.add_edge("e", "b")
+    test.add_edge("e", "c")
+    test.add_edge("e", "d")
+    # community 2
+    test.add_edge("1", "2")
+    test.add_edge("3", "1")
+    test.add_edge("3", "2")
+    test.add_edge("4", "1")
+    test.add_edge("4", "2")
+    test.add_edge("4", "3")
+    test.add_edge("5", "1")
+    test.add_edge("5", "2")
+    test.add_edge("5", "3")
+    test.add_edge("5", "4")
+    # edge between community 1 and 2
+    test.add_edge("a", "1")
+    # community 3
+    test.add_edge("x", "y")
+    # community 4 with only a single node
+    test.add_node("z")
+
+    # The expected communities are:
+    ground_truth1 = {
+        frozenset(["a", "b", "c", "d", "e"]),
+        frozenset(["1", "2", "3", "4", "5"]),
+        frozenset(["x", "y"]),
+        frozenset(["z"]),
+    }
+    ground_truth2 = {
+        frozenset(["a", "b", "c", "d", "e", "1", "2", "3", "4", "5"]),
+        frozenset(["x", "y"]),
+        frozenset(["z"]),
+    }
+    ground_truth = (ground_truth1, ground_truth2)
+
+    communities = label_propagation_communities(test)
+    result = {frozenset(c) for c in communities}
+    assert result in ground_truth
+
+
+def test_termination():
+    # ensure termination of asyn_lpa_communities in two cases
+    # that led to an endless loop in a previous version
+    test1 = nx.karate_club_graph()
+    test2 = nx.caveman_graph(2, 10)
+    test2.add_edges_from([(0, 20), (20, 10)])
+    asyn_lpa_communities(test1)
+    asyn_lpa_communities(test2)
+
+
+class TestAsynLpaCommunities:
+    def _check_communities(self, G, expected):
+        """Checks that the communities computed from the given graph ``G``
+        using the :func:`~networkx.asyn_lpa_communities` function match
+        the set of nodes given in ``expected``.
+
+        ``expected`` must be a :class:`set` of :class:`frozenset`
+        instances, each element of which is a node in the graph.
+
+        """
+        communities = asyn_lpa_communities(G)
+        result = {frozenset(c) for c in communities}
+        assert result == expected
+
+    def test_null_graph(self):
+        G = nx.null_graph()
+        ground_truth = set()
+        self._check_communities(G, ground_truth)
+
+    def test_single_node(self):
+        G = nx.empty_graph(1)
+        ground_truth = {frozenset([0])}
+        self._check_communities(G, ground_truth)
+
+    def test_simple_communities(self):
+        # This graph is the disjoint union of two triangles.
+        G = nx.Graph(["ab", "ac", "bc", "de", "df", "fe"])
+        ground_truth = {frozenset("abc"), frozenset("def")}
+        self._check_communities(G, ground_truth)
+
+    def test_seed_argument(self):
+        G = nx.Graph(["ab", "ac", "bc", "de", "df", "fe"])
+        ground_truth = {frozenset("abc"), frozenset("def")}
+        communities = asyn_lpa_communities(G, seed=1)
+        result = {frozenset(c) for c in communities}
+        assert result == ground_truth
+
+    def test_several_communities(self):
+        # This graph is the disjoint union of five triangles.
+        ground_truth = {frozenset(range(3 * i, 3 * (i + 1))) for i in range(5)}
+        edges = chain.from_iterable(combinations(c, 2) for c in ground_truth)
+        G = nx.Graph(edges)
+        self._check_communities(G, ground_truth)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_louvain.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_louvain.py
new file mode 100644
index 0000000..dc285b8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_louvain.py
@@ -0,0 +1,181 @@
+import networkx as nx
+from networkx.algorithms.community import (
+    is_partition,
+    louvain_communities,
+    modularity,
+    partition_quality,
+)
+
+
+def test_modularity_increase():
+    G = nx.LFR_benchmark_graph(
+        250, 3, 1.5, 0.009, average_degree=5, min_community=20, seed=10
+    )
+    partition = [{u} for u in G.nodes()]
+    mod = modularity(G, partition)
+    partition = louvain_communities(G)
+
+    assert modularity(G, partition) > mod
+
+
+def test_valid_partition():
+    G = nx.LFR_benchmark_graph(
+        250, 3, 1.5, 0.009, average_degree=5, min_community=20, seed=10
+    )
+    H = G.to_directed()
+    partition = louvain_communities(G)
+    partition2 = louvain_communities(H)
+
+    assert is_partition(G, partition)
+    assert is_partition(H, partition2)
+
+
+def test_partition():
+    G = nx.karate_club_graph()
+    part = [
+        {0, 1, 2, 3, 7, 9, 11, 12, 13, 17, 19, 21},
+        {16, 4, 5, 6, 10},
+        {23, 25, 27, 28, 24, 31},
+        {32, 33, 8, 14, 15, 18, 20, 22, 26, 29, 30},
+    ]
+    partition = louvain_communities(G, seed=2, weight=None)
+
+    assert part == partition
+
+
+def test_directed_partition():
+    """
+    Test 2 cases that were looping infinitely
+    from issues #5175 and #5704
+    """
+    G = nx.DiGraph()
+    H = nx.DiGraph()
+    G.add_nodes_from(range(10))
+    H.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
+    G_edges = [
+        (0, 2),
+        (0, 1),
+        (1, 0),
+        (2, 1),
+        (2, 0),
+        (3, 4),
+        (4, 3),
+        (7, 8),
+        (8, 7),
+        (9, 10),
+        (10, 9),
+    ]
+    H_edges = [
+        (1, 2),
+        (1, 6),
+        (1, 9),
+        (2, 3),
+        (2, 4),
+        (2, 5),
+        (3, 4),
+        (4, 3),
+        (4, 5),
+        (5, 4),
+        (6, 7),
+        (6, 8),
+        (9, 10),
+        (9, 11),
+        (10, 11),
+        (11, 10),
+    ]
+    G.add_edges_from(G_edges)
+    H.add_edges_from(H_edges)
+
+    G_expected_partition = [{0, 1, 2}, {3, 4}, {5}, {6}, {8, 7}, {9, 10}]
+    G_partition = louvain_communities(G, seed=123, weight=None)
+
+    H_expected_partition = [{2, 3, 4, 5}, {8, 1, 6, 7}, {9, 10, 11}]
+    H_partition = louvain_communities(H, seed=123, weight=None)
+
+    assert G_partition == G_expected_partition
+    assert H_partition == H_expected_partition
+
+
+def test_none_weight_param():
+    G = nx.karate_club_graph()
+    nx.set_edge_attributes(
+        G, {edge: i * i for i, edge in enumerate(G.edges)}, name="foo"
+    )
+
+    part = [
+        {0, 1, 2, 3, 7, 9, 11, 12, 13, 17, 19, 21},
+        {16, 4, 5, 6, 10},
+        {23, 25, 27, 28, 24, 31},
+        {32, 33, 8, 14, 15, 18, 20, 22, 26, 29, 30},
+    ]
+    partition1 = louvain_communities(G, weight=None, seed=2)
+    partition2 = louvain_communities(G, weight="foo", seed=2)
+    partition3 = louvain_communities(G, weight="weight", seed=2)
+
+    assert part == partition1
+    assert part != partition2
+    assert part != partition3
+    assert partition2 != partition3
+
+
+def test_quality():
+    G = nx.LFR_benchmark_graph(
+        250, 3, 1.5, 0.009, average_degree=5, min_community=20, seed=10
+    )
+    H = nx.gn_graph(200, seed=1234)
+    I = nx.MultiGraph(G)
+    J = nx.MultiDiGraph(H)
+
+    partition = louvain_communities(G)
+    partition2 = louvain_communities(H)
+    partition3 = louvain_communities(I)
+    partition4 = louvain_communities(J)
+
+    quality = partition_quality(G, partition)[0]
+    quality2 = partition_quality(H, partition2)[0]
+    quality3 = partition_quality(I, partition3)[0]
+    quality4 = partition_quality(J, partition4)[0]
+
+    assert quality >= 0.65
+    assert quality2 >= 0.65
+    assert quality3 >= 0.65
+    assert quality4 >= 0.65
+
+
+def test_multigraph():
+    G = nx.karate_club_graph()
+    H = nx.MultiGraph(G)
+    G.add_edge(0, 1, weight=10)
+    H.add_edge(0, 1, weight=9)
+    G.add_edge(0, 9, foo=20)
+    H.add_edge(0, 9, foo=20)
+
+    partition1 = louvain_communities(G, seed=1234)
+    partition2 = louvain_communities(H, seed=1234)
+    partition3 = louvain_communities(H, weight="foo", seed=1234)
+
+    assert partition1 == partition2 != partition3
+
+
+def test_resolution():
+    G = nx.LFR_benchmark_graph(
+        250, 3, 1.5, 0.009, average_degree=5, min_community=20, seed=10
+    )
+
+    partition1 = louvain_communities(G, resolution=0.5, seed=12)
+    partition2 = louvain_communities(G, seed=12)
+    partition3 = louvain_communities(G, resolution=2, seed=12)
+
+    assert len(partition1) <= len(partition2) <= len(partition3)
+
+
+def test_threshold():
+    G = nx.LFR_benchmark_graph(
+        250, 3, 1.5, 0.009, average_degree=5, min_community=20, seed=10
+    )
+    partition1 = louvain_communities(G, threshold=0.3, seed=2)
+    partition2 = louvain_communities(G, seed=2)
+    mod1 = modularity(G, partition1)
+    mod2 = modularity(G, partition2)
+
+    assert mod1 < mod2
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_lukes.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_lukes.py
new file mode 100644
index 0000000..80e2de3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_lukes.py
@@ -0,0 +1,154 @@
+from itertools import product
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.community import lukes_partitioning
+
+EWL = "e_weight"
+NWL = "n_weight"
+
+
+# first test from the Lukes original paper
+def paper_1_case(float_edge_wt=False, explicit_node_wt=True, directed=False):
+
+    # problem-specific constants
+    limit = 3
+
+    # configuration
+    if float_edge_wt:
+        shift = 0.001
+    else:
+        shift = 0
+
+    if directed:
+        example_1 = nx.DiGraph()
+    else:
+        example_1 = nx.Graph()
+
+    # graph creation
+    example_1.add_edge(1, 2, **{EWL: 3 + shift})
+    example_1.add_edge(1, 4, **{EWL: 2 + shift})
+    example_1.add_edge(2, 3, **{EWL: 4 + shift})
+    example_1.add_edge(2, 5, **{EWL: 6 + shift})
+
+    # node weights
+    if explicit_node_wt:
+        nx.set_node_attributes(example_1, 1, NWL)
+        wtu = NWL
+    else:
+        wtu = None
+
+    # partitioning
+    clusters_1 = {
+        frozenset(x)
+        for x in lukes_partitioning(example_1, limit, node_weight=wtu, edge_weight=EWL)
+    }
+
+    return clusters_1
+
+
+# second test from the Lukes original paper
+def paper_2_case(explicit_edge_wt=True, directed=False):
+
+    # problem specific constants
+    byte_block_size = 32
+
+    # configuration
+    if directed:
+        example_2 = nx.DiGraph()
+    else:
+        example_2 = nx.Graph()
+
+    if explicit_edge_wt:
+        edic = {EWL: 1}
+        wtu = EWL
+    else:
+        edic = {}
+        wtu = None
+
+    # graph creation
+    example_2.add_edge("name", "home_address", **edic)
+    example_2.add_edge("name", "education", **edic)
+    example_2.add_edge("education", "bs", **edic)
+    example_2.add_edge("education", "ms", **edic)
+    example_2.add_edge("education", "phd", **edic)
+    example_2.add_edge("name", "telephone", **edic)
+    example_2.add_edge("telephone", "home", **edic)
+    example_2.add_edge("telephone", "office", **edic)
+    example_2.add_edge("office", "no1", **edic)
+    example_2.add_edge("office", "no2", **edic)
+
+    example_2.nodes["name"][NWL] = 20
+    example_2.nodes["education"][NWL] = 10
+    example_2.nodes["bs"][NWL] = 1
+    example_2.nodes["ms"][NWL] = 1
+    example_2.nodes["phd"][NWL] = 1
+    example_2.nodes["home_address"][NWL] = 8
+    example_2.nodes["telephone"][NWL] = 8
+    example_2.nodes["home"][NWL] = 8
+    example_2.nodes["office"][NWL] = 4
+    example_2.nodes["no1"][NWL] = 1
+    example_2.nodes["no2"][NWL] = 1
+
+    # partitioning
+    clusters_2 = {
+        frozenset(x)
+        for x in lukes_partitioning(
+            example_2, byte_block_size, node_weight=NWL, edge_weight=wtu
+        )
+    }
+
+    return clusters_2
+
+
+def test_paper_1_case():
+    ground_truth = {frozenset([1, 4]), frozenset([2, 3, 5])}
+
+    tf = (True, False)
+    for flt, nwt, drc in product(tf, tf, tf):
+        part = paper_1_case(flt, nwt, drc)
+        assert part == ground_truth
+
+
+def test_paper_2_case():
+    ground_truth = {
+        frozenset(["education", "bs", "ms", "phd"]),
+        frozenset(["name", "home_address"]),
+        frozenset(["telephone", "home", "office", "no1", "no2"]),
+    }
+
+    tf = (True, False)
+    for ewt, drc in product(tf, tf):
+        part = paper_2_case(ewt, drc)
+        assert part == ground_truth
+
+
+def test_mandatory_tree():
+    not_a_tree = nx.complete_graph(4)
+
+    with pytest.raises(nx.NotATree):
+        lukes_partitioning(not_a_tree, 5)
+
+
+def test_mandatory_integrality():
+
+    byte_block_size = 32
+
+    ex_1_broken = nx.DiGraph()
+
+    ex_1_broken.add_edge(1, 2, **{EWL: 3.2})
+    ex_1_broken.add_edge(1, 4, **{EWL: 2.4})
+    ex_1_broken.add_edge(2, 3, **{EWL: 4.0})
+    ex_1_broken.add_edge(2, 5, **{EWL: 6.3})
+
+    ex_1_broken.nodes[1][NWL] = 1.2  # !
+    ex_1_broken.nodes[2][NWL] = 1
+    ex_1_broken.nodes[3][NWL] = 1
+    ex_1_broken.nodes[4][NWL] = 1
+    ex_1_broken.nodes[5][NWL] = 2
+
+    with pytest.raises(TypeError):
+        lukes_partitioning(
+            ex_1_broken, byte_block_size, node_weight=NWL, edge_weight=EWL
+        )
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_modularity_max.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_modularity_max.py
new file mode 100644
index 0000000..acdb19d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_modularity_max.py
@@ -0,0 +1,333 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms.community import (
+    greedy_modularity_communities,
+    naive_greedy_modularity_communities,
+)
+
+
+@pytest.mark.parametrize(
+    "func", (greedy_modularity_communities, naive_greedy_modularity_communities)
+)
+def test_modularity_communities(func):
+    G = nx.karate_club_graph()
+    john_a = frozenset(
+        [8, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33]
+    )
+    mr_hi = frozenset([0, 4, 5, 6, 10, 11, 16, 19])
+    overlap = frozenset([1, 2, 3, 7, 9, 12, 13, 17, 21])
+    expected = {john_a, overlap, mr_hi}
+    assert set(func(G, weight=None)) == expected
+
+
+@pytest.mark.parametrize(
+    "func", (greedy_modularity_communities, naive_greedy_modularity_communities)
+)
+def test_modularity_communities_categorical_labels(func):
+    # Using other than 0-starting contiguous integers as node-labels.
+    G = nx.Graph(
+        [
+            ("a", "b"),
+            ("a", "c"),
+            ("b", "c"),
+            ("b", "d"),  # inter-community edge
+            ("d", "e"),
+            ("d", "f"),
+            ("d", "g"),
+            ("f", "g"),
+            ("d", "e"),
+            ("f", "e"),
+        ]
+    )
+    expected = {frozenset({"f", "g", "e", "d"}), frozenset({"a", "b", "c"})}
+    assert set(func(G)) == expected
+
+
+def test_greedy_modularity_communities_components():
+    # Test for gh-5530
+    G = nx.Graph([(0, 1), (2, 3), (4, 5), (5, 6)])
+    # usual case with 3 components
+    assert greedy_modularity_communities(G) == [{4, 5, 6}, {0, 1}, {2, 3}]
+    # best_n can make the algorithm continue even when modularity goes down
+    assert greedy_modularity_communities(G, best_n=3) == [{4, 5, 6}, {0, 1}, {2, 3}]
+    assert greedy_modularity_communities(G, best_n=2) == [{0, 1, 4, 5, 6}, {2, 3}]
+    assert greedy_modularity_communities(G, best_n=1) == [{0, 1, 2, 3, 4, 5, 6}]
+
+
+def test_greedy_modularity_communities_relabeled():
+    # Test for gh-4966
+    G = nx.balanced_tree(2, 2)
+    mapping = {0: "a", 1: "b", 2: "c", 3: "d", 4: "e", 5: "f", 6: "g", 7: "h"}
+    G = nx.relabel_nodes(G, mapping)
+    expected = [frozenset({"e", "d", "a", "b"}), frozenset({"c", "f", "g"})]
+    assert greedy_modularity_communities(G) == expected
+
+
+def test_greedy_modularity_communities_directed():
+    G = nx.DiGraph(
+        [
+            ("a", "b"),
+            ("a", "c"),
+            ("b", "c"),
+            ("b", "d"),  # inter-community edge
+            ("d", "e"),
+            ("d", "f"),
+            ("d", "g"),
+            ("f", "g"),
+            ("d", "e"),
+            ("f", "e"),
+        ]
+    )
+    expected = [frozenset({"f", "g", "e", "d"}), frozenset({"a", "b", "c"})]
+    assert greedy_modularity_communities(G) == expected
+
+    # with loops
+    G = nx.DiGraph()
+    G.add_edges_from(
+        [(1, 1), (1, 2), (1, 3), (2, 3), (1, 4), (4, 4), (5, 5), (4, 5), (4, 6), (5, 6)]
+    )
+    expected = [frozenset({1, 2, 3}), frozenset({4, 5, 6})]
+    assert greedy_modularity_communities(G) == expected
+
+
+@pytest.mark.parametrize(
+    "func", (greedy_modularity_communities, naive_greedy_modularity_communities)
+)
+def test_modularity_communities_weighted(func):
+    G = nx.balanced_tree(2, 3)
+    for (a, b) in G.edges:
+        if ((a == 1) or (a == 2)) and (b != 0):
+            G[a][b]["weight"] = 10.0
+        else:
+            G[a][b]["weight"] = 1.0
+
+    expected = [{0, 1, 3, 4, 7, 8, 9, 10}, {2, 5, 6, 11, 12, 13, 14}]
+
+    assert func(G, weight="weight") == expected
+    assert func(G, weight="weight", resolution=0.9) == expected
+    assert func(G, weight="weight", resolution=0.3) == expected
+    assert func(G, weight="weight", resolution=1.1) != expected
+
+
+def test_modularity_communities_floating_point():
+    # check for floating point error when used as key in the mapped_queue dict.
+    # Test for gh-4992 and gh-5000
+    G = nx.Graph()
+    G.add_weighted_edges_from(
+        [(0, 1, 12), (1, 4, 71), (2, 3, 15), (2, 4, 10), (3, 6, 13)]
+    )
+    expected = [{0, 1, 4}, {2, 3, 6}]
+    assert greedy_modularity_communities(G, weight="weight") == expected
+    assert (
+        greedy_modularity_communities(G, weight="weight", resolution=0.99) == expected
+    )
+
+
+def test_modularity_communities_directed_weighted():
+    G = nx.DiGraph()
+    G.add_weighted_edges_from(
+        [
+            (1, 2, 5),
+            (1, 3, 3),
+            (2, 3, 6),
+            (2, 6, 1),
+            (1, 4, 1),
+            (4, 5, 3),
+            (4, 6, 7),
+            (5, 6, 2),
+            (5, 7, 5),
+            (5, 8, 4),
+            (6, 8, 3),
+        ]
+    )
+    expected = [frozenset({4, 5, 6, 7, 8}), frozenset({1, 2, 3})]
+    assert greedy_modularity_communities(G, weight="weight") == expected
+
+    # A large weight of the edge (2, 6) causes 6 to change group, even if it shares
+    # only one connection with the new group and 3 with the old one.
+    G[2][6]["weight"] = 20
+    expected = [frozenset({1, 2, 3, 6}), frozenset({4, 5, 7, 8})]
+    assert greedy_modularity_communities(G, weight="weight") == expected
+
+
+def test_greedy_modularity_communities_multigraph():
+    G = nx.MultiGraph()
+    G.add_edges_from(
+        [
+            (1, 2),
+            (1, 2),
+            (1, 3),
+            (2, 3),
+            (1, 4),
+            (2, 4),
+            (4, 5),
+            (5, 6),
+            (5, 7),
+            (5, 7),
+            (6, 7),
+            (7, 8),
+            (5, 8),
+        ]
+    )
+    expected = [frozenset({1, 2, 3, 4}), frozenset({5, 6, 7, 8})]
+    assert greedy_modularity_communities(G) == expected
+
+    # Converting (4, 5) into a multi-edge causes node 4 to change group.
+    G.add_edge(4, 5)
+    expected = [frozenset({4, 5, 6, 7, 8}), frozenset({1, 2, 3})]
+    assert greedy_modularity_communities(G) == expected
+
+
+def test_greedy_modularity_communities_multigraph_weighted():
+    G = nx.MultiGraph()
+    G.add_weighted_edges_from(
+        [
+            (1, 2, 5),
+            (1, 2, 3),
+            (1, 3, 6),
+            (1, 3, 6),
+            (2, 3, 4),
+            (1, 4, 1),
+            (1, 4, 1),
+            (2, 4, 3),
+            (2, 4, 3),
+            (4, 5, 1),
+            (5, 6, 3),
+            (5, 6, 7),
+            (5, 6, 4),
+            (5, 7, 9),
+            (5, 7, 9),
+            (6, 7, 8),
+            (7, 8, 2),
+            (7, 8, 2),
+            (5, 8, 6),
+            (5, 8, 6),
+        ]
+    )
+    expected = [frozenset({1, 2, 3, 4}), frozenset({5, 6, 7, 8})]
+    assert greedy_modularity_communities(G, weight="weight") == expected
+
+    # Adding multi-edge (4, 5, 16) causes node 4 to change group.
+    G.add_edge(4, 5, weight=16)
+    expected = [frozenset({4, 5, 6, 7, 8}), frozenset({1, 2, 3})]
+    assert greedy_modularity_communities(G, weight="weight") == expected
+
+    # Increasing the weight of edge (1, 4) causes node 4 to return to the former group.
+    G[1][4][1]["weight"] = 3
+    expected = [frozenset({1, 2, 3, 4}), frozenset({5, 6, 7, 8})]
+    assert greedy_modularity_communities(G, weight="weight") == expected
+
+
+def test_greed_modularity_communities_multidigraph():
+    G = nx.MultiDiGraph()
+    G.add_edges_from(
+        [
+            (1, 2),
+            (1, 2),
+            (3, 1),
+            (2, 3),
+            (2, 3),
+            (3, 2),
+            (1, 4),
+            (2, 4),
+            (4, 2),
+            (4, 5),
+            (5, 6),
+            (5, 6),
+            (6, 5),
+            (5, 7),
+            (6, 7),
+            (7, 8),
+            (5, 8),
+            (8, 4),
+        ]
+    )
+    expected = [frozenset({1, 2, 3, 4}), frozenset({5, 6, 7, 8})]
+    assert greedy_modularity_communities(G, weight="weight") == expected
+
+
+def test_greed_modularity_communities_multidigraph_weighted():
+    G = nx.MultiDiGraph()
+    G.add_weighted_edges_from(
+        [
+            (1, 2, 5),
+            (1, 2, 3),
+            (3, 1, 6),
+            (1, 3, 6),
+            (3, 2, 4),
+            (1, 4, 2),
+            (1, 4, 5),
+            (2, 4, 3),
+            (3, 2, 8),
+            (4, 2, 3),
+            (4, 3, 5),
+            (4, 5, 2),
+            (5, 6, 3),
+            (5, 6, 7),
+            (6, 5, 4),
+            (5, 7, 9),
+            (5, 7, 9),
+            (7, 6, 8),
+            (7, 8, 2),
+            (8, 7, 2),
+            (5, 8, 6),
+            (5, 8, 6),
+        ]
+    )
+    expected = [frozenset({1, 2, 3, 4}), frozenset({5, 6, 7, 8})]
+    assert greedy_modularity_communities(G, weight="weight") == expected
+
+
+def test_resolution_parameter_impact():
+    G = nx.barbell_graph(5, 3)
+
+    gamma = 1
+    expected = [frozenset(range(5)), frozenset(range(8, 13)), frozenset(range(5, 8))]
+    assert greedy_modularity_communities(G, resolution=gamma) == expected
+    assert naive_greedy_modularity_communities(G, resolution=gamma) == expected
+
+    gamma = 2.5
+    expected = [{0, 1, 2, 3}, {9, 10, 11, 12}, {5, 6, 7}, {4}, {8}]
+    assert greedy_modularity_communities(G, resolution=gamma) == expected
+    assert naive_greedy_modularity_communities(G, resolution=gamma) == expected
+
+    gamma = 0.3
+    expected = [frozenset(range(8)), frozenset(range(8, 13))]
+    assert greedy_modularity_communities(G, resolution=gamma) == expected
+    assert naive_greedy_modularity_communities(G, resolution=gamma) == expected
+
+
+def test_cutoff_parameter():
+    G = nx.circular_ladder_graph(4)
+
+    # No aggregation:
+    expected = [{k} for k in range(8)]
+    assert greedy_modularity_communities(G, cutoff=8) == expected
+
+    # Aggregation to half order (number of nodes)
+    expected = [{k, k + 1} for k in range(0, 8, 2)]
+    assert greedy_modularity_communities(G, cutoff=4) == expected
+
+    # Default aggregation case (here, 2 communities emerge)
+    expected = [frozenset(range(0, 4)), frozenset(range(4, 8))]
+    assert greedy_modularity_communities(G, cutoff=1) == expected
+
+
+def test_best_n():
+    G = nx.barbell_graph(5, 3)
+
+    # Same result as without enforcing cutoff:
+    best_n = 3
+    expected = [frozenset(range(5)), frozenset(range(8, 13)), frozenset(range(5, 8))]
+    assert greedy_modularity_communities(G, best_n=best_n) == expected
+
+    # One additional merging step:
+    best_n = 2
+    expected = [frozenset(range(8)), frozenset(range(8, 13))]
+    assert greedy_modularity_communities(G, best_n=best_n) == expected
+
+    # Two additional merging steps:
+    best_n = 1
+    expected = [frozenset(range(0, 13))]
+    assert greedy_modularity_communities(G, best_n=best_n) == expected
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_quality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_quality.py
new file mode 100644
index 0000000..1d6aeb8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_quality.py
@@ -0,0 +1,147 @@
+"""Unit tests for the :mod:`networkx.algorithms.community.quality`
+module.
+
+"""
+import pytest
+
+import networkx as nx
+from networkx import barbell_graph
+from networkx.algorithms.community import (
+    coverage,
+    modularity,
+    partition_quality,
+    performance,
+)
+from networkx.algorithms.community.quality import inter_community_edges
+
+
+class TestPerformance:
+    """Unit tests for the :func:`performance` function."""
+
+    def test_bad_partition(self):
+        """Tests that a poor partition has a low performance measure."""
+        G = barbell_graph(3, 0)
+        partition = [{0, 1, 4}, {2, 3, 5}]
+        assert 8 / 15 == pytest.approx(performance(G, partition), abs=1e-7)
+        assert 8 / 15 == pytest.approx(partition_quality(G, partition)[1], abs=1e-7)
+
+    def test_good_partition(self):
+        """Tests that a good partition has a high performance measure."""
+        G = barbell_graph(3, 0)
+        partition = [{0, 1, 2}, {3, 4, 5}]
+        assert 14 / 15 == pytest.approx(performance(G, partition), abs=1e-7)
+        assert 14 / 15 == pytest.approx(partition_quality(G, partition)[1], abs=1e-7)
+
+
+class TestCoverage:
+    """Unit tests for the :func:`coverage` function."""
+
+    def test_bad_partition(self):
+        """Tests that a poor partition has a low coverage measure."""
+        G = barbell_graph(3, 0)
+        partition = [{0, 1, 4}, {2, 3, 5}]
+        assert 3 / 7 == pytest.approx(coverage(G, partition), abs=1e-7)
+        assert 3 / 7 == pytest.approx(partition_quality(G, partition)[0], abs=1e-7)
+
+    def test_good_partition(self):
+        """Tests that a good partition has a high coverage measure."""
+        G = barbell_graph(3, 0)
+        partition = [{0, 1, 2}, {3, 4, 5}]
+        assert 6 / 7 == pytest.approx(coverage(G, partition), abs=1e-7)
+        assert 6 / 7 == pytest.approx(partition_quality(G, partition)[0], abs=1e-7)
+
+
+def test_modularity():
+    G = nx.barbell_graph(3, 0)
+    C = [{0, 1, 4}, {2, 3, 5}]
+    assert (-16 / (14**2)) == pytest.approx(modularity(G, C), abs=1e-7)
+    C = [{0, 1, 2}, {3, 4, 5}]
+    assert (35 * 2) / (14**2) == pytest.approx(modularity(G, C), abs=1e-7)
+
+    n = 1000
+    G = nx.erdos_renyi_graph(n, 0.09, seed=42, directed=True)
+    C = [set(range(n // 2)), set(range(n // 2, n))]
+    assert 0.00017154251389292754 == pytest.approx(modularity(G, C), abs=1e-7)
+
+    G = nx.margulis_gabber_galil_graph(10)
+    mid_value = G.number_of_nodes() // 2
+    nodes = list(G.nodes)
+    C = [set(nodes[:mid_value]), set(nodes[mid_value:])]
+    assert 0.13 == pytest.approx(modularity(G, C), abs=1e-7)
+
+    G = nx.DiGraph()
+    G.add_edges_from([(2, 1), (2, 3), (3, 4)])
+    C = [{1, 2}, {3, 4}]
+    assert 2 / 9 == pytest.approx(modularity(G, C), abs=1e-7)
+
+
+def test_modularity_resolution():
+    G = nx.barbell_graph(3, 0)
+    C = [{0, 1, 4}, {2, 3, 5}]
+    assert modularity(G, C) == pytest.approx(3 / 7 - 100 / 14**2)
+    gamma = 2
+    result = modularity(G, C, resolution=gamma)
+    assert result == pytest.approx(3 / 7 - gamma * 100 / 14**2)
+    gamma = 0.2
+    result = modularity(G, C, resolution=gamma)
+    assert result == pytest.approx(3 / 7 - gamma * 100 / 14**2)
+
+    C = [{0, 1, 2}, {3, 4, 5}]
+    assert modularity(G, C) == pytest.approx(6 / 7 - 98 / 14**2)
+    gamma = 2
+    result = modularity(G, C, resolution=gamma)
+    assert result == pytest.approx(6 / 7 - gamma * 98 / 14**2)
+    gamma = 0.2
+    result = modularity(G, C, resolution=gamma)
+    assert result == pytest.approx(6 / 7 - gamma * 98 / 14**2)
+
+    G = nx.barbell_graph(5, 3)
+    C = [frozenset(range(5)), frozenset(range(8, 13)), frozenset(range(5, 8))]
+    gamma = 1
+    result = modularity(G, C, resolution=gamma)
+    # This C is maximal for gamma=1:  modularity = 0.518229
+    assert result == pytest.approx((22 / 24) - gamma * (918 / (48**2)))
+    gamma = 2
+    result = modularity(G, C, resolution=gamma)
+    assert result == pytest.approx((22 / 24) - gamma * (918 / (48**2)))
+    gamma = 0.2
+    result = modularity(G, C, resolution=gamma)
+    assert result == pytest.approx((22 / 24) - gamma * (918 / (48**2)))
+
+    C = [{0, 1, 2, 3}, {9, 10, 11, 12}, {5, 6, 7}, {4}, {8}]
+    gamma = 1
+    result = modularity(G, C, resolution=gamma)
+    assert result == pytest.approx((14 / 24) - gamma * (598 / (48**2)))
+    gamma = 2.5
+    result = modularity(G, C, resolution=gamma)
+    # This C is maximal for gamma=2.5:  modularity = -0.06553819
+    assert result == pytest.approx((14 / 24) - gamma * (598 / (48**2)))
+    gamma = 0.2
+    result = modularity(G, C, resolution=gamma)
+    assert result == pytest.approx((14 / 24) - gamma * (598 / (48**2)))
+
+    C = [frozenset(range(8)), frozenset(range(8, 13))]
+    gamma = 1
+    result = modularity(G, C, resolution=gamma)
+    assert result == pytest.approx((23 / 24) - gamma * (1170 / (48**2)))
+    gamma = 2
+    result = modularity(G, C, resolution=gamma)
+    assert result == pytest.approx((23 / 24) - gamma * (1170 / (48**2)))
+    gamma = 0.3
+    result = modularity(G, C, resolution=gamma)
+    # This C is maximal for gamma=0.3:  modularity = 0.805990
+    assert result == pytest.approx((23 / 24) - gamma * (1170 / (48**2)))
+
+
+def test_inter_community_edges_with_digraphs():
+    G = nx.complete_graph(2, create_using=nx.DiGraph())
+    partition = [{0}, {1}]
+    assert inter_community_edges(G, partition) == 2
+
+    G = nx.complete_graph(10, create_using=nx.DiGraph())
+    partition = [{0}, {1, 2}, {3, 4, 5}, {6, 7, 8, 9}]
+    assert inter_community_edges(G, partition) == 70
+
+    G = nx.cycle_graph(4, create_using=nx.DiGraph())
+    partition = [{0, 1}, {2, 3}]
+    assert inter_community_edges(G, partition) == 2
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_utils.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_utils.py
new file mode 100644
index 0000000..a031782
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/community/tests/test_utils.py
@@ -0,0 +1,29 @@
+"""Unit tests for the :mod:`networkx.algorithms.community.utils` module.
+
+"""
+
+import networkx as nx
+from networkx.algorithms.community import is_partition
+
+
+def test_is_partition():
+    G = nx.empty_graph(3)
+    assert is_partition(G, [{0, 1}, {2}])
+    assert is_partition(G, ({0, 1}, {2}))
+    assert is_partition(G, ([0, 1], [2]))
+    assert is_partition(G, [[0, 1], [2]])
+
+
+def test_not_covering():
+    G = nx.empty_graph(3)
+    assert not is_partition(G, [{0}, {1}])
+
+
+def test_not_disjoint():
+    G = nx.empty_graph(3)
+    assert not is_partition(G, [{0, 1}, {1, 2}])
+
+
+def test_not_node():
+    G = nx.empty_graph(3)
+    assert not is_partition(G, [{0, 1}, {3}])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/__init__.py
new file mode 100644
index 0000000..f9ae2ca
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/__init__.py
@@ -0,0 +1,6 @@
+from .connected import *
+from .strongly_connected import *
+from .weakly_connected import *
+from .attracting import *
+from .biconnected import *
+from .semiconnected import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/attracting.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/attracting.py
new file mode 100644
index 0000000..8d2cd8b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/attracting.py
@@ -0,0 +1,111 @@
+"""Attracting components."""
+import networkx as nx
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = [
+    "number_attracting_components",
+    "attracting_components",
+    "is_attracting_component",
+]
+
+
+@not_implemented_for("undirected")
+def attracting_components(G):
+    """Generates the attracting components in `G`.
+
+    An attracting component in a directed graph `G` is a strongly connected
+    component with the property that a random walker on the graph will never
+    leave the component, once it enters the component.
+
+    The nodes in attracting components can also be thought of as recurrent
+    nodes.  If a random walker enters the attractor containing the node, then
+    the node will be visited infinitely often.
+
+    To obtain induced subgraphs on each component use:
+    ``(G.subgraph(c).copy() for c in attracting_components(G))``
+
+    Parameters
+    ----------
+    G : DiGraph, MultiDiGraph
+        The graph to be analyzed.
+
+    Returns
+    -------
+    attractors : generator of sets
+        A generator of sets of nodes, one for each attracting component of G.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is undirected.
+
+    See Also
+    --------
+    number_attracting_components
+    is_attracting_component
+
+    """
+    scc = list(nx.strongly_connected_components(G))
+    cG = nx.condensation(G, scc)
+    for n in cG:
+        if cG.out_degree(n) == 0:
+            yield scc[n]
+
+
+@not_implemented_for("undirected")
+def number_attracting_components(G):
+    """Returns the number of attracting components in `G`.
+
+    Parameters
+    ----------
+    G : DiGraph, MultiDiGraph
+        The graph to be analyzed.
+
+    Returns
+    -------
+    n : int
+        The number of attracting components in G.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is undirected.
+
+    See Also
+    --------
+    attracting_components
+    is_attracting_component
+
+    """
+    return sum(1 for ac in attracting_components(G))
+
+
+@not_implemented_for("undirected")
+def is_attracting_component(G):
+    """Returns True if `G` consists of a single attracting component.
+
+    Parameters
+    ----------
+    G : DiGraph, MultiDiGraph
+        The graph to be analyzed.
+
+    Returns
+    -------
+    attracting : bool
+        True if `G` has a single attracting component. Otherwise, False.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is undirected.
+
+    See Also
+    --------
+    attracting_components
+    number_attracting_components
+
+    """
+    ac = list(attracting_components(G))
+    if len(ac) == 1:
+        return len(ac[0]) == len(G)
+    return False
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/biconnected.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/biconnected.py
new file mode 100644
index 0000000..1eebe8a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/biconnected.py
@@ -0,0 +1,382 @@
+"""Biconnected components and articulation points."""
+from itertools import chain
+
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = [
+    "biconnected_components",
+    "biconnected_component_edges",
+    "is_biconnected",
+    "articulation_points",
+]
+
+
+@not_implemented_for("directed")
+def is_biconnected(G):
+    """Returns True if the graph is biconnected, False otherwise.
+
+    A graph is biconnected if, and only if, it cannot be disconnected by
+    removing only one node (and all edges incident on that node).  If
+    removing a node increases the number of disconnected components
+    in the graph, that node is called an articulation point, or cut
+    vertex.  A biconnected graph has no articulation points.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        An undirected graph.
+
+    Returns
+    -------
+    biconnected : bool
+        True if the graph is biconnected, False otherwise.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is not undirected.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> print(nx.is_biconnected(G))
+    False
+    >>> G.add_edge(0, 3)
+    >>> print(nx.is_biconnected(G))
+    True
+
+    See Also
+    --------
+    biconnected_components
+    articulation_points
+    biconnected_component_edges
+    is_strongly_connected
+    is_weakly_connected
+    is_connected
+    is_semiconnected
+
+    Notes
+    -----
+    The algorithm to find articulation points and biconnected
+    components is implemented using a non-recursive depth-first-search
+    (DFS) that keeps track of the highest level that back edges reach
+    in the DFS tree.  A node `n` is an articulation point if, and only
+    if, there exists a subtree rooted at `n` such that there is no
+    back edge from any successor of `n` that links to a predecessor of
+    `n` in the DFS tree.  By keeping track of all the edges traversed
+    by the DFS we can obtain the biconnected components because all
+    edges of a bicomponent will be traversed consecutively between
+    articulation points.
+
+    References
+    ----------
+    .. [1] Hopcroft, J.; Tarjan, R. (1973).
+       "Efficient algorithms for graph manipulation".
+       Communications of the ACM 16: 372–378. doi:10.1145/362248.362272
+
+    """
+    bccs = biconnected_components(G)
+    try:
+        bcc = next(bccs)
+    except StopIteration:
+        # No bicomponents (empty graph?)
+        return False
+    try:
+        next(bccs)
+    except StopIteration:
+        # Only one bicomponent
+        return len(bcc) == len(G)
+    else:
+        # Multiple bicomponents
+        return False
+
+
+@not_implemented_for("directed")
+def biconnected_component_edges(G):
+    """Returns a generator of lists of edges, one list for each biconnected
+    component of the input graph.
+
+    Biconnected components are maximal subgraphs such that the removal of a
+    node (and all edges incident on that node) will not disconnect the
+    subgraph.  Note that nodes may be part of more than one biconnected
+    component.  Those nodes are articulation points, or cut vertices.
+    However, each edge belongs to one, and only one, biconnected component.
+
+    Notice that by convention a dyad is considered a biconnected component.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        An undirected graph.
+
+    Returns
+    -------
+    edges : generator of lists
+        Generator of lists of edges, one list for each bicomponent.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is not undirected.
+
+    Examples
+    --------
+    >>> G = nx.barbell_graph(4, 2)
+    >>> print(nx.is_biconnected(G))
+    False
+    >>> bicomponents_edges = list(nx.biconnected_component_edges(G))
+    >>> len(bicomponents_edges)
+    5
+    >>> G.add_edge(2, 8)
+    >>> print(nx.is_biconnected(G))
+    True
+    >>> bicomponents_edges = list(nx.biconnected_component_edges(G))
+    >>> len(bicomponents_edges)
+    1
+
+    See Also
+    --------
+    is_biconnected,
+    biconnected_components,
+    articulation_points,
+
+    Notes
+    -----
+    The algorithm to find articulation points and biconnected
+    components is implemented using a non-recursive depth-first-search
+    (DFS) that keeps track of the highest level that back edges reach
+    in the DFS tree.  A node `n` is an articulation point if, and only
+    if, there exists a subtree rooted at `n` such that there is no
+    back edge from any successor of `n` that links to a predecessor of
+    `n` in the DFS tree.  By keeping track of all the edges traversed
+    by the DFS we can obtain the biconnected components because all
+    edges of a bicomponent will be traversed consecutively between
+    articulation points.
+
+    References
+    ----------
+    .. [1] Hopcroft, J.; Tarjan, R. (1973).
+           "Efficient algorithms for graph manipulation".
+           Communications of the ACM 16: 372–378. doi:10.1145/362248.362272
+
+    """
+    yield from _biconnected_dfs(G, components=True)
+
+
+@not_implemented_for("directed")
+def biconnected_components(G):
+    """Returns a generator of sets of nodes, one set for each biconnected
+    component of the graph
+
+    Biconnected components are maximal subgraphs such that the removal of a
+    node (and all edges incident on that node) will not disconnect the
+    subgraph. Note that nodes may be part of more than one biconnected
+    component.  Those nodes are articulation points, or cut vertices.  The
+    removal of articulation points will increase the number of connected
+    components of the graph.
+
+    Notice that by convention a dyad is considered a biconnected component.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        An undirected graph.
+
+    Returns
+    -------
+    nodes : generator
+        Generator of sets of nodes, one set for each biconnected component.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is not undirected.
+
+    Examples
+    --------
+    >>> G = nx.lollipop_graph(5, 1)
+    >>> print(nx.is_biconnected(G))
+    False
+    >>> bicomponents = list(nx.biconnected_components(G))
+    >>> len(bicomponents)
+    2
+    >>> G.add_edge(0, 5)
+    >>> print(nx.is_biconnected(G))
+    True
+    >>> bicomponents = list(nx.biconnected_components(G))
+    >>> len(bicomponents)
+    1
+
+    You can generate a sorted list of biconnected components, largest
+    first, using sort.
+
+    >>> G.remove_edge(0, 5)
+    >>> [len(c) for c in sorted(nx.biconnected_components(G), key=len, reverse=True)]
+    [5, 2]
+
+    If you only want the largest connected component, it's more
+    efficient to use max instead of sort.
+
+    >>> Gc = max(nx.biconnected_components(G), key=len)
+
+    To create the components as subgraphs use:
+    ``(G.subgraph(c).copy() for c in biconnected_components(G))``
+
+    See Also
+    --------
+    is_biconnected
+    articulation_points
+    biconnected_component_edges
+    k_components : this function is a special case where k=2
+    bridge_components : similar to this function, but is defined using
+        2-edge-connectivity instead of 2-node-connectivity.
+
+    Notes
+    -----
+    The algorithm to find articulation points and biconnected
+    components is implemented using a non-recursive depth-first-search
+    (DFS) that keeps track of the highest level that back edges reach
+    in the DFS tree.  A node `n` is an articulation point if, and only
+    if, there exists a subtree rooted at `n` such that there is no
+    back edge from any successor of `n` that links to a predecessor of
+    `n` in the DFS tree.  By keeping track of all the edges traversed
+    by the DFS we can obtain the biconnected components because all
+    edges of a bicomponent will be traversed consecutively between
+    articulation points.
+
+    References
+    ----------
+    .. [1] Hopcroft, J.; Tarjan, R. (1973).
+           "Efficient algorithms for graph manipulation".
+           Communications of the ACM 16: 372–378. doi:10.1145/362248.362272
+
+    """
+    for comp in _biconnected_dfs(G, components=True):
+        yield set(chain.from_iterable(comp))
+
+
+@not_implemented_for("directed")
+def articulation_points(G):
+    """Yield the articulation points, or cut vertices, of a graph.
+
+    An articulation point or cut vertex is any node whose removal (along with
+    all its incident edges) increases the number of connected components of
+    a graph.  An undirected connected graph without articulation points is
+    biconnected. Articulation points belong to more than one biconnected
+    component of a graph.
+
+    Notice that by convention a dyad is considered a biconnected component.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        An undirected graph.
+
+    Yields
+    ------
+    node
+        An articulation point in the graph.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is not undirected.
+
+    Examples
+    --------
+
+    >>> G = nx.barbell_graph(4, 2)
+    >>> print(nx.is_biconnected(G))
+    False
+    >>> len(list(nx.articulation_points(G)))
+    4
+    >>> G.add_edge(2, 8)
+    >>> print(nx.is_biconnected(G))
+    True
+    >>> len(list(nx.articulation_points(G)))
+    0
+
+    See Also
+    --------
+    is_biconnected
+    biconnected_components
+    biconnected_component_edges
+
+    Notes
+    -----
+    The algorithm to find articulation points and biconnected
+    components is implemented using a non-recursive depth-first-search
+    (DFS) that keeps track of the highest level that back edges reach
+    in the DFS tree.  A node `n` is an articulation point if, and only
+    if, there exists a subtree rooted at `n` such that there is no
+    back edge from any successor of `n` that links to a predecessor of
+    `n` in the DFS tree.  By keeping track of all the edges traversed
+    by the DFS we can obtain the biconnected components because all
+    edges of a bicomponent will be traversed consecutively between
+    articulation points.
+
+    References
+    ----------
+    .. [1] Hopcroft, J.; Tarjan, R. (1973).
+           "Efficient algorithms for graph manipulation".
+           Communications of the ACM 16: 372–378. doi:10.1145/362248.362272
+
+    """
+    seen = set()
+    for articulation in _biconnected_dfs(G, components=False):
+        if articulation not in seen:
+            seen.add(articulation)
+            yield articulation
+
+
+@not_implemented_for("directed")
+def _biconnected_dfs(G, components=True):
+    # depth-first search algorithm to generate articulation points
+    # and biconnected components
+    visited = set()
+    for start in G:
+        if start in visited:
+            continue
+        discovery = {start: 0}  # time of first discovery of node during search
+        low = {start: 0}
+        root_children = 0
+        visited.add(start)
+        edge_stack = []
+        stack = [(start, start, iter(G[start]))]
+        while stack:
+            grandparent, parent, children = stack[-1]
+            try:
+                child = next(children)
+                if grandparent == child:
+                    continue
+                if child in visited:
+                    if discovery[child] <= discovery[parent]:  # back edge
+                        low[parent] = min(low[parent], discovery[child])
+                        if components:
+                            edge_stack.append((parent, child))
+                else:
+                    low[child] = discovery[child] = len(discovery)
+                    visited.add(child)
+                    stack.append((parent, child, iter(G[child])))
+                    if components:
+                        edge_stack.append((parent, child))
+            except StopIteration:
+                stack.pop()
+                if len(stack) > 1:
+                    if low[parent] >= discovery[grandparent]:
+                        if components:
+                            ind = edge_stack.index((grandparent, parent))
+                            yield edge_stack[ind:]
+                            edge_stack = edge_stack[:ind]
+                        else:
+                            yield grandparent
+                    low[grandparent] = min(low[parent], low[grandparent])
+                elif stack:  # length 1 so grandparent is root
+                    root_children += 1
+                    if components:
+                        ind = edge_stack.index((grandparent, parent))
+                        yield edge_stack[ind:]
+        if not components:
+            # root node is articulation point if it has more than 1 child
+            if root_children > 1:
+                yield start
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/connected.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/connected.py
new file mode 100644
index 0000000..e6b122e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/connected.py
@@ -0,0 +1,200 @@
+"""Connected components."""
+import networkx as nx
+from networkx.utils.decorators import not_implemented_for
+
+from ...utils import arbitrary_element
+
+__all__ = [
+    "number_connected_components",
+    "connected_components",
+    "is_connected",
+    "node_connected_component",
+]
+
+
+@not_implemented_for("directed")
+def connected_components(G):
+    """Generate connected components.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph
+
+    Returns
+    -------
+    comp : generator of sets
+       A generator of sets of nodes, one for each component of G.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is directed.
+
+    Examples
+    --------
+    Generate a sorted list of connected components, largest first.
+
+    >>> G = nx.path_graph(4)
+    >>> nx.add_path(G, [10, 11, 12])
+    >>> [len(c) for c in sorted(nx.connected_components(G), key=len, reverse=True)]
+    [4, 3]
+
+    If you only want the largest connected component, it's more
+    efficient to use max instead of sort.
+
+    >>> largest_cc = max(nx.connected_components(G), key=len)
+
+    To create the induced subgraph of each component use:
+
+    >>> S = [G.subgraph(c).copy() for c in nx.connected_components(G)]
+
+    See Also
+    --------
+    strongly_connected_components
+    weakly_connected_components
+
+    Notes
+    -----
+    For undirected graphs only.
+
+    """
+    seen = set()
+    for v in G:
+        if v not in seen:
+            c = _plain_bfs(G, v)
+            seen.update(c)
+            yield c
+
+
+def number_connected_components(G):
+    """Returns the number of connected components.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    Returns
+    -------
+    n : integer
+       Number of connected components
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (1, 2), (5, 6), (3, 4)])
+    >>> nx.number_connected_components(G)
+    3
+
+    See Also
+    --------
+    connected_components
+    number_weakly_connected_components
+    number_strongly_connected_components
+
+    Notes
+    -----
+    For undirected graphs only.
+
+    """
+    return sum(1 for cc in connected_components(G))
+
+
+@not_implemented_for("directed")
+def is_connected(G):
+    """Returns True if the graph is connected, False otherwise.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+       An undirected graph.
+
+    Returns
+    -------
+    connected : bool
+      True if the graph is connected, false otherwise.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is directed.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> print(nx.is_connected(G))
+    True
+
+    See Also
+    --------
+    is_strongly_connected
+    is_weakly_connected
+    is_semiconnected
+    is_biconnected
+    connected_components
+
+    Notes
+    -----
+    For undirected graphs only.
+
+    """
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept(
+            "Connectivity is undefined ", "for the null graph."
+        )
+    return sum(1 for node in _plain_bfs(G, arbitrary_element(G))) == len(G)
+
+
+@not_implemented_for("directed")
+def node_connected_component(G, n):
+    """Returns the set of nodes in the component of graph containing node n.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+       An undirected graph.
+
+    n : node label
+       A node in G
+
+    Returns
+    -------
+    comp : set
+       A set of nodes in the component of G containing node n.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is directed.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (1, 2), (5, 6), (3, 4)])
+    >>> nx.node_connected_component(G, 0)  # nodes of component that contains node 0
+    {0, 1, 2}
+
+    See Also
+    --------
+    connected_components
+
+    Notes
+    -----
+    For undirected graphs only.
+
+    """
+    return _plain_bfs(G, n)
+
+
+def _plain_bfs(G, source):
+    """A fast BFS node generator"""
+    G_adj = G.adj
+    seen = set()
+    nextlevel = {source}
+    while nextlevel:
+        thislevel = nextlevel
+        nextlevel = set()
+        for v in thislevel:
+            if v not in seen:
+                seen.add(v)
+                nextlevel.update(G_adj[v])
+    return seen
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/semiconnected.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/semiconnected.py
new file mode 100644
index 0000000..9603f9d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/semiconnected.py
@@ -0,0 +1,64 @@
+"""Semiconnectedness."""
+import networkx as nx
+from networkx.utils import not_implemented_for, pairwise
+
+__all__ = ["is_semiconnected"]
+
+
+@not_implemented_for("undirected")
+def is_semiconnected(G, topo_order=None):
+    """Returns True if the graph is semiconnected, False otherwise.
+
+    A graph is semiconnected if, and only if, for any pair of nodes, either one
+    is reachable from the other, or they are mutually reachable.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A directed graph.
+
+    topo_order: list or tuple, optional
+        A topological order for G (if None, the function will compute one)
+
+    Returns
+    -------
+    semiconnected : bool
+        True if the graph is semiconnected, False otherwise.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is undirected.
+
+    NetworkXPointlessConcept
+        If the graph is empty.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4, create_using=nx.DiGraph())
+    >>> print(nx.is_semiconnected(G))
+    True
+    >>> G = nx.DiGraph([(1, 2), (3, 2)])
+    >>> print(nx.is_semiconnected(G))
+    False
+
+    See Also
+    --------
+    is_strongly_connected
+    is_weakly_connected
+    is_connected
+    is_biconnected
+    """
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept(
+            "Connectivity is undefined for the null graph."
+        )
+
+    if not nx.is_weakly_connected(G):
+        return False
+
+    G = nx.condensation(G)
+    if topo_order is None:
+        topo_order = nx.topological_sort(G)
+
+    return all(G.has_edge(u, v) for u, v in pairwise(topo_order))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/strongly_connected.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/strongly_connected.py
new file mode 100644
index 0000000..edb33d3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/strongly_connected.py
@@ -0,0 +1,414 @@
+"""Strongly connected components."""
+import networkx as nx
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = [
+    "number_strongly_connected_components",
+    "strongly_connected_components",
+    "is_strongly_connected",
+    "strongly_connected_components_recursive",
+    "kosaraju_strongly_connected_components",
+    "condensation",
+]
+
+
+@not_implemented_for("undirected")
+def strongly_connected_components(G):
+    """Generate nodes in strongly connected components of graph.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        A directed graph.
+
+    Returns
+    -------
+    comp : generator of sets
+        A generator of sets of nodes, one for each strongly connected
+        component of G.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is undirected.
+
+    Examples
+    --------
+    Generate a sorted list of strongly connected components, largest first.
+
+    >>> G = nx.cycle_graph(4, create_using=nx.DiGraph())
+    >>> nx.add_cycle(G, [10, 11, 12])
+    >>> [
+    ...     len(c)
+    ...     for c in sorted(nx.strongly_connected_components(G), key=len, reverse=True)
+    ... ]
+    [4, 3]
+
+    If you only want the largest component, it's more efficient to
+    use max instead of sort.
+
+    >>> largest = max(nx.strongly_connected_components(G), key=len)
+
+    See Also
+    --------
+    connected_components
+    weakly_connected_components
+    kosaraju_strongly_connected_components
+
+    Notes
+    -----
+    Uses Tarjan's algorithm[1]_ with Nuutila's modifications[2]_.
+    Nonrecursive version of algorithm.
+
+    References
+    ----------
+    .. [1] Depth-first search and linear graph algorithms, R. Tarjan
+       SIAM Journal of Computing 1(2):146-160, (1972).
+
+    .. [2] On finding the strongly connected components in a directed graph.
+       E. Nuutila and E. Soisalon-Soinen
+       Information Processing Letters 49(1): 9-14, (1994)..
+
+    """
+    preorder = {}
+    lowlink = {}
+    scc_found = set()
+    scc_queue = []
+    i = 0  # Preorder counter
+    neighbors = {v: iter(G[v]) for v in G}
+    for source in G:
+        if source not in scc_found:
+            queue = [source]
+            while queue:
+                v = queue[-1]
+                if v not in preorder:
+                    i = i + 1
+                    preorder[v] = i
+                done = True
+                for w in neighbors[v]:
+                    if w not in preorder:
+                        queue.append(w)
+                        done = False
+                        break
+                if done:
+                    lowlink[v] = preorder[v]
+                    for w in G[v]:
+                        if w not in scc_found:
+                            if preorder[w] > preorder[v]:
+                                lowlink[v] = min([lowlink[v], lowlink[w]])
+                            else:
+                                lowlink[v] = min([lowlink[v], preorder[w]])
+                    queue.pop()
+                    if lowlink[v] == preorder[v]:
+                        scc = {v}
+                        while scc_queue and preorder[scc_queue[-1]] > preorder[v]:
+                            k = scc_queue.pop()
+                            scc.add(k)
+                        scc_found.update(scc)
+                        yield scc
+                    else:
+                        scc_queue.append(v)
+
+
+@not_implemented_for("undirected")
+def kosaraju_strongly_connected_components(G, source=None):
+    """Generate nodes in strongly connected components of graph.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        A directed graph.
+
+    Returns
+    -------
+    comp : generator of sets
+        A generator of sets of nodes, one for each strongly connected
+        component of G.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is undirected.
+
+    Examples
+    --------
+    Generate a sorted list of strongly connected components, largest first.
+
+    >>> G = nx.cycle_graph(4, create_using=nx.DiGraph())
+    >>> nx.add_cycle(G, [10, 11, 12])
+    >>> [
+    ...     len(c)
+    ...     for c in sorted(
+    ...         nx.kosaraju_strongly_connected_components(G), key=len, reverse=True
+    ...     )
+    ... ]
+    [4, 3]
+
+    If you only want the largest component, it's more efficient to
+    use max instead of sort.
+
+    >>> largest = max(nx.kosaraju_strongly_connected_components(G), key=len)
+
+    See Also
+    --------
+    strongly_connected_components
+
+    Notes
+    -----
+    Uses Kosaraju's algorithm.
+
+    """
+    post = list(nx.dfs_postorder_nodes(G.reverse(copy=False), source=source))
+
+    seen = set()
+    while post:
+        r = post.pop()
+        if r in seen:
+            continue
+        c = nx.dfs_preorder_nodes(G, r)
+        new = {v for v in c if v not in seen}
+        seen.update(new)
+        yield new
+
+
+@not_implemented_for("undirected")
+def strongly_connected_components_recursive(G):
+    """Generate nodes in strongly connected components of graph.
+
+    Recursive version of algorithm.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        A directed graph.
+
+    Returns
+    -------
+    comp : generator of sets
+        A generator of sets of nodes, one for each strongly connected
+        component of G.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is undirected.
+
+    Examples
+    --------
+    Generate a sorted list of strongly connected components, largest first.
+
+    >>> G = nx.cycle_graph(4, create_using=nx.DiGraph())
+    >>> nx.add_cycle(G, [10, 11, 12])
+    >>> [
+    ...     len(c)
+    ...     for c in sorted(
+    ...         nx.strongly_connected_components_recursive(G), key=len, reverse=True
+    ...     )
+    ... ]
+    [4, 3]
+
+    If you only want the largest component, it's more efficient to
+    use max instead of sort.
+
+    >>> largest = max(nx.strongly_connected_components_recursive(G), key=len)
+
+    To create the induced subgraph of the components use:
+    >>> S = [G.subgraph(c).copy() for c in nx.weakly_connected_components(G)]
+
+    See Also
+    --------
+    connected_components
+
+    Notes
+    -----
+    Uses Tarjan's algorithm[1]_ with Nuutila's modifications[2]_.
+
+    References
+    ----------
+    .. [1] Depth-first search and linear graph algorithms, R. Tarjan
+       SIAM Journal of Computing 1(2):146-160, (1972).
+
+    .. [2] On finding the strongly connected components in a directed graph.
+       E. Nuutila and E. Soisalon-Soinen
+       Information Processing Letters 49(1): 9-14, (1994)..
+
+    """
+
+    def visit(v, cnt):
+        root[v] = cnt
+        visited[v] = cnt
+        cnt += 1
+        stack.append(v)
+        for w in G[v]:
+            if w not in visited:
+                yield from visit(w, cnt)
+            if w not in component:
+                root[v] = min(root[v], root[w])
+        if root[v] == visited[v]:
+            component[v] = root[v]
+            tmpc = {v}  # hold nodes in this component
+            while stack[-1] != v:
+                w = stack.pop()
+                component[w] = root[v]
+                tmpc.add(w)
+            stack.remove(v)
+            yield tmpc
+
+    visited = {}
+    component = {}
+    root = {}
+    cnt = 0
+    stack = []
+    for source in G:
+        if source not in visited:
+            yield from visit(source, cnt)
+
+
+@not_implemented_for("undirected")
+def number_strongly_connected_components(G):
+    """Returns number of strongly connected components in graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A directed graph.
+
+    Returns
+    -------
+    n : integer
+       Number of strongly connected components
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is undirected.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 0), (2, 3), (4, 5), (3, 4), (5, 6), (6, 3), (6, 7)])
+    >>> nx.number_strongly_connected_components(G)
+    3
+
+    See Also
+    --------
+    strongly_connected_components
+    number_connected_components
+    number_weakly_connected_components
+
+    Notes
+    -----
+    For directed graphs only.
+    """
+    return sum(1 for scc in strongly_connected_components(G))
+
+
+@not_implemented_for("undirected")
+def is_strongly_connected(G):
+    """Test directed graph for strong connectivity.
+
+    A directed graph is strongly connected if and only if every vertex in
+    the graph is reachable from every other vertex.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+       A directed graph.
+
+    Returns
+    -------
+    connected : bool
+      True if the graph is strongly connected, False otherwise.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 0), (2, 4), (4, 2)])
+    >>> nx.is_strongly_connected(G)
+    True
+    >>> G.remove_edge(2, 3)
+    >>> nx.is_strongly_connected(G)
+    False
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is undirected.
+
+    See Also
+    --------
+    is_weakly_connected
+    is_semiconnected
+    is_connected
+    is_biconnected
+    strongly_connected_components
+
+    Notes
+    -----
+    For directed graphs only.
+    """
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept(
+            """Connectivity is undefined for the null graph."""
+        )
+
+    return len(next(strongly_connected_components(G))) == len(G)
+
+
+@not_implemented_for("undirected")
+def condensation(G, scc=None):
+    """Returns the condensation of G.
+
+    The condensation of G is the graph with each of the strongly connected
+    components contracted into a single node.
+
+    Parameters
+    ----------
+    G : NetworkX DiGraph
+       A directed graph.
+
+    scc:  list or generator (optional, default=None)
+       Strongly connected components. If provided, the elements in
+       `scc` must partition the nodes in `G`. If not provided, it will be
+       calculated as scc=nx.strongly_connected_components(G).
+
+    Returns
+    -------
+    C : NetworkX DiGraph
+       The condensation graph C of G.  The node labels are integers
+       corresponding to the index of the component in the list of
+       strongly connected components of G.  C has a graph attribute named
+       'mapping' with a dictionary mapping the original nodes to the
+       nodes in C to which they belong.  Each node in C also has a node
+       attribute 'members' with the set of original nodes in G that
+       form the SCC that the node in C represents.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is undirected.
+
+    Notes
+    -----
+    After contracting all strongly connected components to a single node,
+    the resulting graph is a directed acyclic graph.
+
+    """
+    if scc is None:
+        scc = nx.strongly_connected_components(G)
+    mapping = {}
+    members = {}
+    C = nx.DiGraph()
+    # Add mapping dict as graph attribute
+    C.graph["mapping"] = mapping
+    if len(G) == 0:
+        return C
+    for i, component in enumerate(scc):
+        members[i] = component
+        mapping.update((n, i) for n in component)
+    number_of_components = i + 1
+    C.add_nodes_from(range(number_of_components))
+    C.add_edges_from(
+        (mapping[u], mapping[v]) for u, v in G.edges() if mapping[u] != mapping[v]
+    )
+    # Add a list of members (ie original nodes) to each node (ie scc) in C.
+    nx.set_node_attributes(C, members, "members")
+    return C
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_attracting.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_attracting.py
new file mode 100644
index 0000000..336c40d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_attracting.py
@@ -0,0 +1,70 @@
+import pytest
+
+import networkx as nx
+from networkx import NetworkXNotImplemented
+
+
+class TestAttractingComponents:
+    @classmethod
+    def setup_class(cls):
+        cls.G1 = nx.DiGraph()
+        cls.G1.add_edges_from(
+            [
+                (5, 11),
+                (11, 2),
+                (11, 9),
+                (11, 10),
+                (7, 11),
+                (7, 8),
+                (8, 9),
+                (3, 8),
+                (3, 10),
+            ]
+        )
+        cls.G2 = nx.DiGraph()
+        cls.G2.add_edges_from([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1)])
+
+        cls.G3 = nx.DiGraph()
+        cls.G3.add_edges_from([(0, 1), (1, 2), (2, 1), (0, 3), (3, 4), (4, 3)])
+
+        cls.G4 = nx.DiGraph()
+
+    def test_attracting_components(self):
+        ac = list(nx.attracting_components(self.G1))
+        assert {2} in ac
+        assert {9} in ac
+        assert {10} in ac
+
+        ac = list(nx.attracting_components(self.G2))
+        ac = [tuple(sorted(x)) for x in ac]
+        assert ac == [(1, 2)]
+
+        ac = list(nx.attracting_components(self.G3))
+        ac = [tuple(sorted(x)) for x in ac]
+        assert (1, 2) in ac
+        assert (3, 4) in ac
+        assert len(ac) == 2
+
+        ac = list(nx.attracting_components(self.G4))
+        assert ac == []
+
+    def test_number_attacting_components(self):
+        assert nx.number_attracting_components(self.G1) == 3
+        assert nx.number_attracting_components(self.G2) == 1
+        assert nx.number_attracting_components(self.G3) == 2
+        assert nx.number_attracting_components(self.G4) == 0
+
+    def test_is_attracting_component(self):
+        assert not nx.is_attracting_component(self.G1)
+        assert not nx.is_attracting_component(self.G2)
+        assert not nx.is_attracting_component(self.G3)
+        g2 = self.G3.subgraph([1, 2])
+        assert nx.is_attracting_component(g2)
+        assert not nx.is_attracting_component(self.G4)
+
+    def test_connected_raise(self):
+        G = nx.Graph()
+        with pytest.raises(NetworkXNotImplemented):
+            next(nx.attracting_components(G))
+        pytest.raises(NetworkXNotImplemented, nx.number_attracting_components, G)
+        pytest.raises(NetworkXNotImplemented, nx.is_attracting_component, G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_biconnected.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_biconnected.py
new file mode 100644
index 0000000..19d2d88
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_biconnected.py
@@ -0,0 +1,248 @@
+import pytest
+
+import networkx as nx
+from networkx import NetworkXNotImplemented
+
+
+def assert_components_edges_equal(x, y):
+    sx = {frozenset(frozenset(e) for e in c) for c in x}
+    sy = {frozenset(frozenset(e) for e in c) for c in y}
+    assert sx == sy
+
+
+def assert_components_equal(x, y):
+    sx = {frozenset(c) for c in x}
+    sy = {frozenset(c) for c in y}
+    assert sx == sy
+
+
+def test_barbell():
+    G = nx.barbell_graph(8, 4)
+    nx.add_path(G, [7, 20, 21, 22])
+    nx.add_cycle(G, [22, 23, 24, 25])
+    pts = set(nx.articulation_points(G))
+    assert pts == {7, 8, 9, 10, 11, 12, 20, 21, 22}
+
+    answer = [
+        {12, 13, 14, 15, 16, 17, 18, 19},
+        {0, 1, 2, 3, 4, 5, 6, 7},
+        {22, 23, 24, 25},
+        {11, 12},
+        {10, 11},
+        {9, 10},
+        {8, 9},
+        {7, 8},
+        {21, 22},
+        {20, 21},
+        {7, 20},
+    ]
+    assert_components_equal(list(nx.biconnected_components(G)), answer)
+
+    G.add_edge(2, 17)
+    pts = set(nx.articulation_points(G))
+    assert pts == {7, 20, 21, 22}
+
+
+def test_articulation_points_repetitions():
+    G = nx.Graph()
+    G.add_edges_from([(0, 1), (1, 2), (1, 3)])
+    assert list(nx.articulation_points(G)) == [1]
+
+
+def test_articulation_points_cycle():
+    G = nx.cycle_graph(3)
+    nx.add_cycle(G, [1, 3, 4])
+    pts = set(nx.articulation_points(G))
+    assert pts == {1}
+
+
+def test_is_biconnected():
+    G = nx.cycle_graph(3)
+    assert nx.is_biconnected(G)
+    nx.add_cycle(G, [1, 3, 4])
+    assert not nx.is_biconnected(G)
+
+
+def test_empty_is_biconnected():
+    G = nx.empty_graph(5)
+    assert not nx.is_biconnected(G)
+    G.add_edge(0, 1)
+    assert not nx.is_biconnected(G)
+
+
+def test_biconnected_components_cycle():
+    G = nx.cycle_graph(3)
+    nx.add_cycle(G, [1, 3, 4])
+    answer = [{0, 1, 2}, {1, 3, 4}]
+    assert_components_equal(list(nx.biconnected_components(G)), answer)
+
+
+def test_biconnected_components1():
+    # graph example from
+    # https://web.archive.org/web/20121229123447/http://www.ibluemojo.com/school/articul_algorithm.html
+    edges = [
+        (0, 1),
+        (0, 5),
+        (0, 6),
+        (0, 14),
+        (1, 5),
+        (1, 6),
+        (1, 14),
+        (2, 4),
+        (2, 10),
+        (3, 4),
+        (3, 15),
+        (4, 6),
+        (4, 7),
+        (4, 10),
+        (5, 14),
+        (6, 14),
+        (7, 9),
+        (8, 9),
+        (8, 12),
+        (8, 13),
+        (10, 15),
+        (11, 12),
+        (11, 13),
+        (12, 13),
+    ]
+    G = nx.Graph(edges)
+    pts = set(nx.articulation_points(G))
+    assert pts == {4, 6, 7, 8, 9}
+    comps = list(nx.biconnected_component_edges(G))
+    answer = [
+        [(3, 4), (15, 3), (10, 15), (10, 4), (2, 10), (4, 2)],
+        [(13, 12), (13, 8), (11, 13), (12, 11), (8, 12)],
+        [(9, 8)],
+        [(7, 9)],
+        [(4, 7)],
+        [(6, 4)],
+        [(14, 0), (5, 1), (5, 0), (14, 5), (14, 1), (6, 14), (6, 0), (1, 6), (0, 1)],
+    ]
+    assert_components_edges_equal(comps, answer)
+
+
+def test_biconnected_components2():
+    G = nx.Graph()
+    nx.add_cycle(G, "ABC")
+    nx.add_cycle(G, "CDE")
+    nx.add_cycle(G, "FIJHG")
+    nx.add_cycle(G, "GIJ")
+    G.add_edge("E", "G")
+    comps = list(nx.biconnected_component_edges(G))
+    answer = [
+        [
+            tuple("GF"),
+            tuple("FI"),
+            tuple("IG"),
+            tuple("IJ"),
+            tuple("JG"),
+            tuple("JH"),
+            tuple("HG"),
+        ],
+        [tuple("EG")],
+        [tuple("CD"), tuple("DE"), tuple("CE")],
+        [tuple("AB"), tuple("BC"), tuple("AC")],
+    ]
+    assert_components_edges_equal(comps, answer)
+
+
+def test_biconnected_davis():
+    D = nx.davis_southern_women_graph()
+    bcc = list(nx.biconnected_components(D))[0]
+    assert set(D) == bcc  # All nodes in a giant bicomponent
+    # So no articulation points
+    assert len(list(nx.articulation_points(D))) == 0
+
+
+def test_biconnected_karate():
+    K = nx.karate_club_graph()
+    answer = [
+        {
+            0,
+            1,
+            2,
+            3,
+            7,
+            8,
+            9,
+            12,
+            13,
+            14,
+            15,
+            17,
+            18,
+            19,
+            20,
+            21,
+            22,
+            23,
+            24,
+            25,
+            26,
+            27,
+            28,
+            29,
+            30,
+            31,
+            32,
+            33,
+        },
+        {0, 4, 5, 6, 10, 16},
+        {0, 11},
+    ]
+    bcc = list(nx.biconnected_components(K))
+    assert_components_equal(bcc, answer)
+    assert set(nx.articulation_points(K)) == {0}
+
+
+def test_biconnected_eppstein():
+    # tests from http://www.ics.uci.edu/~eppstein/PADS/Biconnectivity.py
+    G1 = nx.Graph(
+        {
+            0: [1, 2, 5],
+            1: [0, 5],
+            2: [0, 3, 4],
+            3: [2, 4, 5, 6],
+            4: [2, 3, 5, 6],
+            5: [0, 1, 3, 4],
+            6: [3, 4],
+        }
+    )
+    G2 = nx.Graph(
+        {
+            0: [2, 5],
+            1: [3, 8],
+            2: [0, 3, 5],
+            3: [1, 2, 6, 8],
+            4: [7],
+            5: [0, 2],
+            6: [3, 8],
+            7: [4],
+            8: [1, 3, 6],
+        }
+    )
+    assert nx.is_biconnected(G1)
+    assert not nx.is_biconnected(G2)
+    answer_G2 = [{1, 3, 6, 8}, {0, 2, 5}, {2, 3}, {4, 7}]
+    bcc = list(nx.biconnected_components(G2))
+    assert_components_equal(bcc, answer_G2)
+
+
+def test_null_graph():
+    G = nx.Graph()
+    assert not nx.is_biconnected(G)
+    assert list(nx.biconnected_components(G)) == []
+    assert list(nx.biconnected_component_edges(G)) == []
+    assert list(nx.articulation_points(G)) == []
+
+
+def test_connected_raise():
+    DG = nx.DiGraph()
+    with pytest.raises(NetworkXNotImplemented):
+        next(nx.biconnected_components(DG))
+    with pytest.raises(NetworkXNotImplemented):
+        next(nx.biconnected_component_edges(DG))
+    with pytest.raises(NetworkXNotImplemented):
+        next(nx.articulation_points(DG))
+    pytest.raises(NetworkXNotImplemented, nx.is_biconnected, DG)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_connected.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_connected.py
new file mode 100644
index 0000000..bf3954e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_connected.py
@@ -0,0 +1,113 @@
+import pytest
+
+import networkx as nx
+from networkx import NetworkXNotImplemented
+from networkx import convert_node_labels_to_integers as cnlti
+
+
+class TestConnected:
+    @classmethod
+    def setup_class(cls):
+        G1 = cnlti(nx.grid_2d_graph(2, 2), first_label=0, ordering="sorted")
+        G2 = cnlti(nx.lollipop_graph(3, 3), first_label=4, ordering="sorted")
+        G3 = cnlti(nx.house_graph(), first_label=10, ordering="sorted")
+        cls.G = nx.union(G1, G2)
+        cls.G = nx.union(cls.G, G3)
+        cls.DG = nx.DiGraph([(1, 2), (1, 3), (2, 3)])
+        cls.grid = cnlti(nx.grid_2d_graph(4, 4), first_label=1)
+
+        cls.gc = []
+        G = nx.DiGraph()
+        G.add_edges_from(
+            [
+                (1, 2),
+                (2, 3),
+                (2, 8),
+                (3, 4),
+                (3, 7),
+                (4, 5),
+                (5, 3),
+                (5, 6),
+                (7, 4),
+                (7, 6),
+                (8, 1),
+                (8, 7),
+            ]
+        )
+        C = [[3, 4, 5, 7], [1, 2, 8], [6]]
+        cls.gc.append((G, C))
+
+        G = nx.DiGraph()
+        G.add_edges_from([(1, 2), (1, 3), (1, 4), (4, 2), (3, 4), (2, 3)])
+        C = [[2, 3, 4], [1]]
+        cls.gc.append((G, C))
+
+        G = nx.DiGraph()
+        G.add_edges_from([(1, 2), (2, 3), (3, 2), (2, 1)])
+        C = [[1, 2, 3]]
+        cls.gc.append((G, C))
+
+        # Eppstein's tests
+        G = nx.DiGraph({0: [1], 1: [2, 3], 2: [4, 5], 3: [4, 5], 4: [6], 5: [], 6: []})
+        C = [[0], [1], [2], [3], [4], [5], [6]]
+        cls.gc.append((G, C))
+
+        G = nx.DiGraph({0: [1], 1: [2, 3, 4], 2: [0, 3], 3: [4], 4: [3]})
+        C = [[0, 1, 2], [3, 4]]
+        cls.gc.append((G, C))
+
+        G = nx.DiGraph()
+        C = []
+        cls.gc.append((G, C))
+
+    def test_connected_components(self):
+        cc = nx.connected_components
+        G = self.G
+        C = {
+            frozenset([0, 1, 2, 3]),
+            frozenset([4, 5, 6, 7, 8, 9]),
+            frozenset([10, 11, 12, 13, 14]),
+        }
+        assert {frozenset(g) for g in cc(G)} == C
+
+    def test_number_connected_components(self):
+        ncc = nx.number_connected_components
+        assert ncc(self.G) == 3
+
+    def test_number_connected_components2(self):
+        ncc = nx.number_connected_components
+        assert ncc(self.grid) == 1
+
+    def test_connected_components2(self):
+        cc = nx.connected_components
+        G = self.grid
+        C = {frozenset([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])}
+        assert {frozenset(g) for g in cc(G)} == C
+
+    def test_node_connected_components(self):
+        ncc = nx.node_connected_component
+        G = self.grid
+        C = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
+        assert ncc(G, 1) == C
+
+    def test_is_connected(self):
+        assert nx.is_connected(self.grid)
+        G = nx.Graph()
+        G.add_nodes_from([1, 2])
+        assert not nx.is_connected(G)
+
+    def test_connected_raise(self):
+        with pytest.raises(NetworkXNotImplemented):
+            next(nx.connected_components(self.DG))
+        pytest.raises(NetworkXNotImplemented, nx.number_connected_components, self.DG)
+        pytest.raises(NetworkXNotImplemented, nx.node_connected_component, self.DG, 1)
+        pytest.raises(NetworkXNotImplemented, nx.is_connected, self.DG)
+        pytest.raises(nx.NetworkXPointlessConcept, nx.is_connected, nx.Graph())
+
+    def test_connected_mutability(self):
+        G = self.grid
+        seen = set()
+        for component in nx.connected_components(G):
+            assert len(seen & component) == 0
+            seen.update(component)
+            component.clear()
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_semiconnected.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_semiconnected.py
new file mode 100644
index 0000000..6376bbf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_semiconnected.py
@@ -0,0 +1,55 @@
+from itertools import chain
+
+import pytest
+
+import networkx as nx
+
+
+class TestIsSemiconnected:
+    def test_undirected(self):
+        pytest.raises(nx.NetworkXNotImplemented, nx.is_semiconnected, nx.Graph())
+        pytest.raises(nx.NetworkXNotImplemented, nx.is_semiconnected, nx.MultiGraph())
+
+    def test_empty(self):
+        pytest.raises(nx.NetworkXPointlessConcept, nx.is_semiconnected, nx.DiGraph())
+        pytest.raises(
+            nx.NetworkXPointlessConcept, nx.is_semiconnected, nx.MultiDiGraph()
+        )
+
+    def test_single_node_graph(self):
+        G = nx.DiGraph()
+        G.add_node(0)
+        assert nx.is_semiconnected(G)
+
+    def test_path(self):
+        G = nx.path_graph(100, create_using=nx.DiGraph())
+        assert nx.is_semiconnected(G)
+        G.add_edge(100, 99)
+        assert not nx.is_semiconnected(G)
+
+    def test_cycle(self):
+        G = nx.cycle_graph(100, create_using=nx.DiGraph())
+        assert nx.is_semiconnected(G)
+        G = nx.path_graph(100, create_using=nx.DiGraph())
+        G.add_edge(0, 99)
+        assert nx.is_semiconnected(G)
+
+    def test_tree(self):
+        G = nx.DiGraph()
+        G.add_edges_from(
+            chain.from_iterable([(i, 2 * i + 1), (i, 2 * i + 2)] for i in range(100))
+        )
+        assert not nx.is_semiconnected(G)
+
+    def test_dumbbell(self):
+        G = nx.cycle_graph(100, create_using=nx.DiGraph())
+        G.add_edges_from((i + 100, (i + 1) % 100 + 100) for i in range(100))
+        assert not nx.is_semiconnected(G)  # G is disconnected.
+        G.add_edge(100, 99)
+        assert nx.is_semiconnected(G)
+
+    def test_alternating_path(self):
+        G = nx.DiGraph(
+            chain.from_iterable([(i, i - 1), (i, i + 1)] for i in range(0, 100, 2))
+        )
+        assert not nx.is_semiconnected(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_strongly_connected.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_strongly_connected.py
new file mode 100644
index 0000000..ab4e893
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_strongly_connected.py
@@ -0,0 +1,205 @@
+import pytest
+
+import networkx as nx
+from networkx import NetworkXNotImplemented
+
+
+class TestStronglyConnected:
+    @classmethod
+    def setup_class(cls):
+        cls.gc = []
+        G = nx.DiGraph()
+        G.add_edges_from(
+            [
+                (1, 2),
+                (2, 3),
+                (2, 8),
+                (3, 4),
+                (3, 7),
+                (4, 5),
+                (5, 3),
+                (5, 6),
+                (7, 4),
+                (7, 6),
+                (8, 1),
+                (8, 7),
+            ]
+        )
+        C = {frozenset([3, 4, 5, 7]), frozenset([1, 2, 8]), frozenset([6])}
+        cls.gc.append((G, C))
+
+        G = nx.DiGraph()
+        G.add_edges_from([(1, 2), (1, 3), (1, 4), (4, 2), (3, 4), (2, 3)])
+        C = {frozenset([2, 3, 4]), frozenset([1])}
+        cls.gc.append((G, C))
+
+        G = nx.DiGraph()
+        G.add_edges_from([(1, 2), (2, 3), (3, 2), (2, 1)])
+        C = {frozenset([1, 2, 3])}
+        cls.gc.append((G, C))
+
+        # Eppstein's tests
+        G = nx.DiGraph({0: [1], 1: [2, 3], 2: [4, 5], 3: [4, 5], 4: [6], 5: [], 6: []})
+        C = {
+            frozenset([0]),
+            frozenset([1]),
+            frozenset([2]),
+            frozenset([3]),
+            frozenset([4]),
+            frozenset([5]),
+            frozenset([6]),
+        }
+        cls.gc.append((G, C))
+
+        G = nx.DiGraph({0: [1], 1: [2, 3, 4], 2: [0, 3], 3: [4], 4: [3]})
+        C = {frozenset([0, 1, 2]), frozenset([3, 4])}
+        cls.gc.append((G, C))
+
+    def test_tarjan(self):
+        scc = nx.strongly_connected_components
+        for G, C in self.gc:
+            assert {frozenset(g) for g in scc(G)} == C
+
+    def test_tarjan_recursive(self):
+        scc = nx.strongly_connected_components_recursive
+        for G, C in self.gc:
+            assert {frozenset(g) for g in scc(G)} == C
+
+    def test_kosaraju(self):
+        scc = nx.kosaraju_strongly_connected_components
+        for G, C in self.gc:
+            assert {frozenset(g) for g in scc(G)} == C
+
+    def test_number_strongly_connected_components(self):
+        ncc = nx.number_strongly_connected_components
+        for G, C in self.gc:
+            assert ncc(G) == len(C)
+
+    def test_is_strongly_connected(self):
+        for G, C in self.gc:
+            if len(C) == 1:
+                assert nx.is_strongly_connected(G)
+            else:
+                assert not nx.is_strongly_connected(G)
+
+    def test_contract_scc1(self):
+        G = nx.DiGraph()
+        G.add_edges_from(
+            [
+                (1, 2),
+                (2, 3),
+                (2, 11),
+                (2, 12),
+                (3, 4),
+                (4, 3),
+                (4, 5),
+                (5, 6),
+                (6, 5),
+                (6, 7),
+                (7, 8),
+                (7, 9),
+                (7, 10),
+                (8, 9),
+                (9, 7),
+                (10, 6),
+                (11, 2),
+                (11, 4),
+                (11, 6),
+                (12, 6),
+                (12, 11),
+            ]
+        )
+        scc = list(nx.strongly_connected_components(G))
+        cG = nx.condensation(G, scc)
+        # DAG
+        assert nx.is_directed_acyclic_graph(cG)
+        # nodes
+        assert sorted(cG.nodes()) == [0, 1, 2, 3]
+        # edges
+        mapping = {}
+        for i, component in enumerate(scc):
+            for n in component:
+                mapping[n] = i
+        edge = (mapping[2], mapping[3])
+        assert cG.has_edge(*edge)
+        edge = (mapping[2], mapping[5])
+        assert cG.has_edge(*edge)
+        edge = (mapping[3], mapping[5])
+        assert cG.has_edge(*edge)
+
+    def test_contract_scc_isolate(self):
+        # Bug found and fixed in [1687].
+        G = nx.DiGraph()
+        G.add_edge(1, 2)
+        G.add_edge(2, 1)
+        scc = list(nx.strongly_connected_components(G))
+        cG = nx.condensation(G, scc)
+        assert list(cG.nodes()) == [0]
+        assert list(cG.edges()) == []
+
+    def test_contract_scc_edge(self):
+        G = nx.DiGraph()
+        G.add_edge(1, 2)
+        G.add_edge(2, 1)
+        G.add_edge(2, 3)
+        G.add_edge(3, 4)
+        G.add_edge(4, 3)
+        scc = list(nx.strongly_connected_components(G))
+        cG = nx.condensation(G, scc)
+        assert sorted(cG.nodes()) == [0, 1]
+        if 1 in scc[0]:
+            edge = (0, 1)
+        else:
+            edge = (1, 0)
+        assert list(cG.edges()) == [edge]
+
+    def test_condensation_mapping_and_members(self):
+        G, C = self.gc[1]
+        C = sorted(C, key=len, reverse=True)
+        cG = nx.condensation(G)
+        mapping = cG.graph["mapping"]
+        assert all(n in G for n in mapping)
+        assert all(0 == cN for n, cN in mapping.items() if n in C[0])
+        assert all(1 == cN for n, cN in mapping.items() if n in C[1])
+        for n, d in cG.nodes(data=True):
+            assert set(C[n]) == cG.nodes[n]["members"]
+
+    def test_null_graph(self):
+        G = nx.DiGraph()
+        assert list(nx.strongly_connected_components(G)) == []
+        assert list(nx.kosaraju_strongly_connected_components(G)) == []
+        assert list(nx.strongly_connected_components_recursive(G)) == []
+        assert len(nx.condensation(G)) == 0
+        pytest.raises(
+            nx.NetworkXPointlessConcept, nx.is_strongly_connected, nx.DiGraph()
+        )
+
+    def test_connected_raise(self):
+        G = nx.Graph()
+        with pytest.raises(NetworkXNotImplemented):
+            next(nx.strongly_connected_components(G))
+        with pytest.raises(NetworkXNotImplemented):
+            next(nx.kosaraju_strongly_connected_components(G))
+        with pytest.raises(NetworkXNotImplemented):
+            next(nx.strongly_connected_components_recursive(G))
+        pytest.raises(NetworkXNotImplemented, nx.is_strongly_connected, G)
+        pytest.raises(
+            nx.NetworkXPointlessConcept, nx.is_strongly_connected, nx.DiGraph()
+        )
+        pytest.raises(NetworkXNotImplemented, nx.condensation, G)
+
+    strong_cc_methods = (
+        nx.strongly_connected_components,
+        nx.kosaraju_strongly_connected_components,
+        nx.strongly_connected_components_recursive,
+    )
+
+    @pytest.mark.parametrize("get_components", strong_cc_methods)
+    def test_connected_mutability(self, get_components):
+        DG = nx.path_graph(5, create_using=nx.DiGraph)
+        G = nx.disjoint_union(DG, DG)
+        seen = set()
+        for component in get_components(G):
+            assert len(seen & component) == 0
+            seen.update(component)
+            component.clear()
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_weakly_connected.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_weakly_connected.py
new file mode 100644
index 0000000..e313263
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/tests/test_weakly_connected.py
@@ -0,0 +1,90 @@
+import pytest
+
+import networkx as nx
+from networkx import NetworkXNotImplemented
+
+
+class TestWeaklyConnected:
+    @classmethod
+    def setup_class(cls):
+        cls.gc = []
+        G = nx.DiGraph()
+        G.add_edges_from(
+            [
+                (1, 2),
+                (2, 3),
+                (2, 8),
+                (3, 4),
+                (3, 7),
+                (4, 5),
+                (5, 3),
+                (5, 6),
+                (7, 4),
+                (7, 6),
+                (8, 1),
+                (8, 7),
+            ]
+        )
+        C = [[3, 4, 5, 7], [1, 2, 8], [6]]
+        cls.gc.append((G, C))
+
+        G = nx.DiGraph()
+        G.add_edges_from([(1, 2), (1, 3), (1, 4), (4, 2), (3, 4), (2, 3)])
+        C = [[2, 3, 4], [1]]
+        cls.gc.append((G, C))
+
+        G = nx.DiGraph()
+        G.add_edges_from([(1, 2), (2, 3), (3, 2), (2, 1)])
+        C = [[1, 2, 3]]
+        cls.gc.append((G, C))
+
+        # Eppstein's tests
+        G = nx.DiGraph({0: [1], 1: [2, 3], 2: [4, 5], 3: [4, 5], 4: [6], 5: [], 6: []})
+        C = [[0], [1], [2], [3], [4], [5], [6]]
+        cls.gc.append((G, C))
+
+        G = nx.DiGraph({0: [1], 1: [2, 3, 4], 2: [0, 3], 3: [4], 4: [3]})
+        C = [[0, 1, 2], [3, 4]]
+        cls.gc.append((G, C))
+
+    def test_weakly_connected_components(self):
+        for G, C in self.gc:
+            U = G.to_undirected()
+            w = {frozenset(g) for g in nx.weakly_connected_components(G)}
+            c = {frozenset(g) for g in nx.connected_components(U)}
+            assert w == c
+
+    def test_number_weakly_connected_components(self):
+        for G, C in self.gc:
+            U = G.to_undirected()
+            w = nx.number_weakly_connected_components(G)
+            c = nx.number_connected_components(U)
+            assert w == c
+
+    def test_is_weakly_connected(self):
+        for G, C in self.gc:
+            U = G.to_undirected()
+            assert nx.is_weakly_connected(G) == nx.is_connected(U)
+
+    def test_null_graph(self):
+        G = nx.DiGraph()
+        assert list(nx.weakly_connected_components(G)) == []
+        assert nx.number_weakly_connected_components(G) == 0
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            next(nx.is_weakly_connected(G))
+
+    def test_connected_raise(self):
+        G = nx.Graph()
+        with pytest.raises(NetworkXNotImplemented):
+            next(nx.weakly_connected_components(G))
+        pytest.raises(NetworkXNotImplemented, nx.number_weakly_connected_components, G)
+        pytest.raises(NetworkXNotImplemented, nx.is_weakly_connected, G)
+
+    def test_connected_mutability(self):
+        DG = nx.path_graph(5, create_using=nx.DiGraph)
+        G = nx.disjoint_union(DG, DG)
+        seen = set()
+        for component in nx.weakly_connected_components(G):
+            assert len(seen & component) == 0
+            seen.update(component)
+            component.clear()
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/components/weakly_connected.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/weakly_connected.py
new file mode 100644
index 0000000..822719a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/components/weakly_connected.py
@@ -0,0 +1,184 @@
+"""Weakly connected components."""
+import networkx as nx
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = [
+    "number_weakly_connected_components",
+    "weakly_connected_components",
+    "is_weakly_connected",
+]
+
+
+@not_implemented_for("undirected")
+def weakly_connected_components(G):
+    """Generate weakly connected components of G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A directed graph
+
+    Returns
+    -------
+    comp : generator of sets
+        A generator of sets of nodes, one for each weakly connected
+        component of G.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is undirected.
+
+    Examples
+    --------
+    Generate a sorted list of weakly connected components, largest first.
+
+    >>> G = nx.path_graph(4, create_using=nx.DiGraph())
+    >>> nx.add_path(G, [10, 11, 12])
+    >>> [
+    ...     len(c)
+    ...     for c in sorted(nx.weakly_connected_components(G), key=len, reverse=True)
+    ... ]
+    [4, 3]
+
+    If you only want the largest component, it's more efficient to
+    use max instead of sort:
+
+    >>> largest_cc = max(nx.weakly_connected_components(G), key=len)
+
+    See Also
+    --------
+    connected_components
+    strongly_connected_components
+
+    Notes
+    -----
+    For directed graphs only.
+
+    """
+    seen = set()
+    for v in G:
+        if v not in seen:
+            c = set(_plain_bfs(G, v))
+            seen.update(c)
+            yield c
+
+
+@not_implemented_for("undirected")
+def number_weakly_connected_components(G):
+    """Returns the number of weakly connected components in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A directed graph.
+
+    Returns
+    -------
+    n : integer
+        Number of weakly connected components
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is undirected.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph([(0, 1), (2, 1), (3, 4)])
+    >>> nx.number_weakly_connected_components(G)
+    2
+
+    See Also
+    --------
+    weakly_connected_components
+    number_connected_components
+    number_strongly_connected_components
+
+    Notes
+    -----
+    For directed graphs only.
+
+    """
+    return sum(1 for wcc in weakly_connected_components(G))
+
+
+@not_implemented_for("undirected")
+def is_weakly_connected(G):
+    """Test directed graph for weak connectivity.
+
+    A directed graph is weakly connected if and only if the graph
+    is connected when the direction of the edge between nodes is ignored.
+
+    Note that if a graph is strongly connected (i.e. the graph is connected
+    even when we account for directionality), it is by definition weakly
+    connected as well.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        A directed graph.
+
+    Returns
+    -------
+    connected : bool
+        True if the graph is weakly connected, False otherwise.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is undirected.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph([(0, 1), (2, 1)])
+    >>> G.add_node(3)
+    >>> nx.is_weakly_connected(G)  # node 3 is not connected to the graph
+    False
+    >>> G.add_edge(2, 3)
+    >>> nx.is_weakly_connected(G)
+    True
+
+    See Also
+    --------
+    is_strongly_connected
+    is_semiconnected
+    is_connected
+    is_biconnected
+    weakly_connected_components
+
+    Notes
+    -----
+    For directed graphs only.
+
+    """
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept(
+            """Connectivity is undefined for the null graph."""
+        )
+
+    return len(next(weakly_connected_components(G))) == len(G)
+
+
+def _plain_bfs(G, source):
+    """A fast BFS node generator
+
+    The direction of the edge between nodes is ignored.
+
+    For directed graphs only.
+
+    """
+    Gsucc = G.succ
+    Gpred = G.pred
+
+    seen = set()
+    nextlevel = {source}
+    while nextlevel:
+        thislevel = nextlevel
+        nextlevel = set()
+        for v in thislevel:
+            if v not in seen:
+                seen.add(v)
+                nextlevel.update(Gsucc[v])
+                nextlevel.update(Gpred[v])
+                yield v
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/__init__.py
new file mode 100644
index 0000000..15bc5ab
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/__init__.py
@@ -0,0 +1,11 @@
+"""Connectivity and cut algorithms
+"""
+from .connectivity import *
+from .cuts import *
+from .edge_augmentation import *
+from .edge_kcomponents import *
+from .disjoint_paths import *
+from .kcomponents import *
+from .kcutsets import *
+from .stoerwagner import *
+from .utils import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/connectivity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/connectivity.py
new file mode 100644
index 0000000..b782031
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/connectivity.py
@@ -0,0 +1,818 @@
+"""
+Flow based connectivity algorithms
+"""
+
+import itertools
+from operator import itemgetter
+
+import networkx as nx
+
+# Define the default maximum flow function to use in all flow based
+# connectivity algorithms.
+from networkx.algorithms.flow import (
+    boykov_kolmogorov,
+    build_residual_network,
+    dinitz,
+    edmonds_karp,
+    shortest_augmenting_path,
+)
+
+default_flow_func = edmonds_karp
+
+from .utils import build_auxiliary_edge_connectivity, build_auxiliary_node_connectivity
+
+__all__ = [
+    "average_node_connectivity",
+    "local_node_connectivity",
+    "node_connectivity",
+    "local_edge_connectivity",
+    "edge_connectivity",
+    "all_pairs_node_connectivity",
+]
+
+
+def local_node_connectivity(
+    G, s, t, flow_func=None, auxiliary=None, residual=None, cutoff=None
+):
+    r"""Computes local node connectivity for nodes s and t.
+
+    Local node connectivity for two non adjacent nodes s and t is the
+    minimum number of nodes that must be removed (along with their incident
+    edges) to disconnect them.
+
+    This is a flow based implementation of node connectivity. We compute the
+    maximum flow on an auxiliary digraph build from the original input
+    graph (see below for details).
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    s : node
+        Source node
+
+    t : node
+        Target node
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. See below for details. The choice
+        of the default function may change from version to version and
+        should not be relied on. Default value: None.
+
+    auxiliary : NetworkX DiGraph
+        Auxiliary digraph to compute flow based node connectivity. It has
+        to have a graph attribute called mapping with a dictionary mapping
+        node names in G and in the auxiliary digraph. If provided
+        it will be reused instead of recreated. Default value: None.
+
+    residual : NetworkX DiGraph
+        Residual network to compute maximum flow. If provided it will be
+        reused instead of recreated. Default value: None.
+
+    cutoff : integer, float
+        If specified, the maximum flow algorithm will terminate when the
+        flow value reaches or exceeds the cutoff. This is only for the
+        algorithms that support the cutoff parameter: :meth:`edmonds_karp`
+        and :meth:`shortest_augmenting_path`. Other algorithms will ignore
+        this parameter. Default value: None.
+
+    Returns
+    -------
+    K : integer
+        local node connectivity for nodes s and t
+
+    Examples
+    --------
+    This function is not imported in the base NetworkX namespace, so you
+    have to explicitly import it from the connectivity package:
+
+    >>> from networkx.algorithms.connectivity import local_node_connectivity
+
+    We use in this example the platonic icosahedral graph, which has node
+    connectivity 5.
+
+    >>> G = nx.icosahedral_graph()
+    >>> local_node_connectivity(G, 0, 6)
+    5
+
+    If you need to compute local connectivity on several pairs of
+    nodes in the same graph, it is recommended that you reuse the
+    data structures that NetworkX uses in the computation: the
+    auxiliary digraph for node connectivity, and the residual
+    network for the underlying maximum flow computation.
+
+    Example of how to compute local node connectivity among
+    all pairs of nodes of the platonic icosahedral graph reusing
+    the data structures.
+
+    >>> import itertools
+    >>> # You also have to explicitly import the function for
+    >>> # building the auxiliary digraph from the connectivity package
+    >>> from networkx.algorithms.connectivity import build_auxiliary_node_connectivity
+    ...
+    >>> H = build_auxiliary_node_connectivity(G)
+    >>> # And the function for building the residual network from the
+    >>> # flow package
+    >>> from networkx.algorithms.flow import build_residual_network
+    >>> # Note that the auxiliary digraph has an edge attribute named capacity
+    >>> R = build_residual_network(H, "capacity")
+    >>> result = dict.fromkeys(G, dict())
+    >>> # Reuse the auxiliary digraph and the residual network by passing them
+    >>> # as parameters
+    >>> for u, v in itertools.combinations(G, 2):
+    ...     k = local_node_connectivity(G, u, v, auxiliary=H, residual=R)
+    ...     result[u][v] = k
+    ...
+    >>> all(result[u][v] == 5 for u, v in itertools.combinations(G, 2))
+    True
+
+    You can also use alternative flow algorithms for computing node
+    connectivity. For instance, in dense networks the algorithm
+    :meth:`shortest_augmenting_path` will usually perform better than
+    the default :meth:`edmonds_karp` which is faster for sparse
+    networks with highly skewed degree distributions. Alternative flow
+    functions have to be explicitly imported from the flow package.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> local_node_connectivity(G, 0, 6, flow_func=shortest_augmenting_path)
+    5
+
+    Notes
+    -----
+    This is a flow based implementation of node connectivity. We compute the
+    maximum flow using, by default, the :meth:`edmonds_karp` algorithm (see:
+    :meth:`maximum_flow`) on an auxiliary digraph build from the original
+    input graph:
+
+    For an undirected graph G having `n` nodes and `m` edges we derive a
+    directed graph H with `2n` nodes and `2m+n` arcs by replacing each
+    original node `v` with two nodes `v_A`, `v_B` linked by an (internal)
+    arc in H. Then for each edge (`u`, `v`) in G we add two arcs
+    (`u_B`, `v_A`) and (`v_B`, `u_A`) in H. Finally we set the attribute
+    capacity = 1 for each arc in H [1]_ .
+
+    For a directed graph G having `n` nodes and `m` arcs we derive a
+    directed graph H with `2n` nodes and `m+n` arcs by replacing each
+    original node `v` with two nodes `v_A`, `v_B` linked by an (internal)
+    arc (`v_A`, `v_B`) in H. Then for each arc (`u`, `v`) in G we add one arc
+    (`u_B`, `v_A`) in H. Finally we set the attribute capacity = 1 for
+    each arc in H.
+
+    This is equal to the local node connectivity because the value of
+    a maximum s-t-flow is equal to the capacity of a minimum s-t-cut.
+
+    See also
+    --------
+    :meth:`local_edge_connectivity`
+    :meth:`node_connectivity`
+    :meth:`minimum_node_cut`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    References
+    ----------
+    .. [1] Kammer, Frank and Hanjo Taubig. Graph Connectivity. in Brandes and
+        Erlebach, 'Network Analysis: Methodological Foundations', Lecture
+        Notes in Computer Science, Volume 3418, Springer-Verlag, 2005.
+        http://www.informatik.uni-augsburg.de/thi/personen/kammer/Graph_Connectivity.pdf
+
+    """
+    if flow_func is None:
+        flow_func = default_flow_func
+
+    if auxiliary is None:
+        H = build_auxiliary_node_connectivity(G)
+    else:
+        H = auxiliary
+
+    mapping = H.graph.get("mapping", None)
+    if mapping is None:
+        raise nx.NetworkXError("Invalid auxiliary digraph.")
+
+    kwargs = dict(flow_func=flow_func, residual=residual)
+    if flow_func is shortest_augmenting_path:
+        kwargs["cutoff"] = cutoff
+        kwargs["two_phase"] = True
+    elif flow_func is edmonds_karp:
+        kwargs["cutoff"] = cutoff
+    elif flow_func is dinitz:
+        kwargs["cutoff"] = cutoff
+    elif flow_func is boykov_kolmogorov:
+        kwargs["cutoff"] = cutoff
+
+    return nx.maximum_flow_value(H, f"{mapping[s]}B", f"{mapping[t]}A", **kwargs)
+
+
+def node_connectivity(G, s=None, t=None, flow_func=None):
+    r"""Returns node connectivity for a graph or digraph G.
+
+    Node connectivity is equal to the minimum number of nodes that
+    must be removed to disconnect G or render it trivial. If source
+    and target nodes are provided, this function returns the local node
+    connectivity: the minimum number of nodes that must be removed to break
+    all paths from source to target in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    s : node
+        Source node. Optional. Default value: None.
+
+    t : node
+        Target node. Optional. Default value: None.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. See below for details. The
+        choice of the default function may change from version
+        to version and should not be relied on. Default value: None.
+
+    Returns
+    -------
+    K : integer
+        Node connectivity of G, or local node connectivity if source
+        and target are provided.
+
+    Examples
+    --------
+    >>> # Platonic icosahedral graph is 5-node-connected
+    >>> G = nx.icosahedral_graph()
+    >>> nx.node_connectivity(G)
+    5
+
+    You can use alternative flow algorithms for the underlying maximum
+    flow computation. In dense networks the algorithm
+    :meth:`shortest_augmenting_path` will usually perform better
+    than the default :meth:`edmonds_karp`, which is faster for
+    sparse networks with highly skewed degree distributions. Alternative
+    flow functions have to be explicitly imported from the flow package.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> nx.node_connectivity(G, flow_func=shortest_augmenting_path)
+    5
+
+    If you specify a pair of nodes (source and target) as parameters,
+    this function returns the value of local node connectivity.
+
+    >>> nx.node_connectivity(G, 3, 7)
+    5
+
+    If you need to perform several local computations among different
+    pairs of nodes on the same graph, it is recommended that you reuse
+    the data structures used in the maximum flow computations. See
+    :meth:`local_node_connectivity` for details.
+
+    Notes
+    -----
+    This is a flow based implementation of node connectivity. The
+    algorithm works by solving $O((n-\delta-1+\delta(\delta-1)/2))$
+    maximum flow problems on an auxiliary digraph. Where $\delta$
+    is the minimum degree of G. For details about the auxiliary
+    digraph and the computation of local node connectivity see
+    :meth:`local_node_connectivity`. This implementation is based
+    on algorithm 11 in [1]_.
+
+    See also
+    --------
+    :meth:`local_node_connectivity`
+    :meth:`edge_connectivity`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    References
+    ----------
+    .. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms.
+        http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
+
+    """
+    if (s is not None and t is None) or (s is None and t is not None):
+        raise nx.NetworkXError("Both source and target must be specified.")
+
+    # Local node connectivity
+    if s is not None and t is not None:
+        if s not in G:
+            raise nx.NetworkXError(f"node {s} not in graph")
+        if t not in G:
+            raise nx.NetworkXError(f"node {t} not in graph")
+        return local_node_connectivity(G, s, t, flow_func=flow_func)
+
+    # Global node connectivity
+    if G.is_directed():
+        if not nx.is_weakly_connected(G):
+            return 0
+        iter_func = itertools.permutations
+        # It is necessary to consider both predecessors
+        # and successors for directed graphs
+
+        def neighbors(v):
+            return itertools.chain.from_iterable([G.predecessors(v), G.successors(v)])
+
+    else:
+        if not nx.is_connected(G):
+            return 0
+        iter_func = itertools.combinations
+        neighbors = G.neighbors
+
+    # Reuse the auxiliary digraph and the residual network
+    H = build_auxiliary_node_connectivity(G)
+    R = build_residual_network(H, "capacity")
+    kwargs = dict(flow_func=flow_func, auxiliary=H, residual=R)
+
+    # Pick a node with minimum degree
+    # Node connectivity is bounded by degree.
+    v, K = min(G.degree(), key=itemgetter(1))
+    # compute local node connectivity with all its non-neighbors nodes
+    for w in set(G) - set(neighbors(v)) - {v}:
+        kwargs["cutoff"] = K
+        K = min(K, local_node_connectivity(G, v, w, **kwargs))
+    # Also for non adjacent pairs of neighbors of v
+    for x, y in iter_func(neighbors(v), 2):
+        if y in G[x]:
+            continue
+        kwargs["cutoff"] = K
+        K = min(K, local_node_connectivity(G, x, y, **kwargs))
+
+    return K
+
+
+def average_node_connectivity(G, flow_func=None):
+    r"""Returns the average connectivity of a graph G.
+
+    The average connectivity `\bar{\kappa}` of a graph G is the average
+    of local node connectivity over all pairs of nodes of G [1]_ .
+
+    .. math::
+
+        \bar{\kappa}(G) = \frac{\sum_{u,v} \kappa_{G}(u,v)}{{n \choose 2}}
+
+    Parameters
+    ----------
+
+    G : NetworkX graph
+        Undirected graph
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. See :meth:`local_node_connectivity`
+        for details. The choice of the default function may change from
+        version to version and should not be relied on. Default value: None.
+
+    Returns
+    -------
+    K : float
+        Average node connectivity
+
+    See also
+    --------
+    :meth:`local_node_connectivity`
+    :meth:`node_connectivity`
+    :meth:`edge_connectivity`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    References
+    ----------
+    .. [1]  Beineke, L., O. Oellermann, and R. Pippert (2002). The average
+            connectivity of a graph. Discrete mathematics 252(1-3), 31-45.
+            http://www.sciencedirect.com/science/article/pii/S0012365X01001807
+
+    """
+    if G.is_directed():
+        iter_func = itertools.permutations
+    else:
+        iter_func = itertools.combinations
+
+    # Reuse the auxiliary digraph and the residual network
+    H = build_auxiliary_node_connectivity(G)
+    R = build_residual_network(H, "capacity")
+    kwargs = dict(flow_func=flow_func, auxiliary=H, residual=R)
+
+    num, den = 0, 0
+    for u, v in iter_func(G, 2):
+        num += local_node_connectivity(G, u, v, **kwargs)
+        den += 1
+
+    if den == 0:  # Null Graph
+        return 0
+    return num / den
+
+
+def all_pairs_node_connectivity(G, nbunch=None, flow_func=None):
+    """Compute node connectivity between all pairs of nodes of G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    nbunch: container
+        Container of nodes. If provided node connectivity will be computed
+        only over pairs of nodes in nbunch.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. See below for details. The
+        choice of the default function may change from version
+        to version and should not be relied on. Default value: None.
+
+    Returns
+    -------
+    all_pairs : dict
+        A dictionary with node connectivity between all pairs of nodes
+        in G, or in nbunch if provided.
+
+    See also
+    --------
+    :meth:`local_node_connectivity`
+    :meth:`edge_connectivity`
+    :meth:`local_edge_connectivity`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    """
+    if nbunch is None:
+        nbunch = G
+    else:
+        nbunch = set(nbunch)
+
+    directed = G.is_directed()
+    if directed:
+        iter_func = itertools.permutations
+    else:
+        iter_func = itertools.combinations
+
+    all_pairs = {n: {} for n in nbunch}
+
+    # Reuse auxiliary digraph and residual network
+    H = build_auxiliary_node_connectivity(G)
+    mapping = H.graph["mapping"]
+    R = build_residual_network(H, "capacity")
+    kwargs = dict(flow_func=flow_func, auxiliary=H, residual=R)
+
+    for u, v in iter_func(nbunch, 2):
+        K = local_node_connectivity(G, u, v, **kwargs)
+        all_pairs[u][v] = K
+        if not directed:
+            all_pairs[v][u] = K
+
+    return all_pairs
+
+
+def local_edge_connectivity(
+    G, s, t, flow_func=None, auxiliary=None, residual=None, cutoff=None
+):
+    r"""Returns local edge connectivity for nodes s and t in G.
+
+    Local edge connectivity for two nodes s and t is the minimum number
+    of edges that must be removed to disconnect them.
+
+    This is a flow based implementation of edge connectivity. We compute the
+    maximum flow on an auxiliary digraph build from the original
+    network (see below for details). This is equal to the local edge
+    connectivity because the value of a maximum s-t-flow is equal to the
+    capacity of a minimum s-t-cut (Ford and Fulkerson theorem) [1]_ .
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected or directed graph
+
+    s : node
+        Source node
+
+    t : node
+        Target node
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. See below for details. The
+        choice of the default function may change from version
+        to version and should not be relied on. Default value: None.
+
+    auxiliary : NetworkX DiGraph
+        Auxiliary digraph for computing flow based edge connectivity. If
+        provided it will be reused instead of recreated. Default value: None.
+
+    residual : NetworkX DiGraph
+        Residual network to compute maximum flow. If provided it will be
+        reused instead of recreated. Default value: None.
+
+    cutoff : integer, float
+        If specified, the maximum flow algorithm will terminate when the
+        flow value reaches or exceeds the cutoff. This is only for the
+        algorithms that support the cutoff parameter: :meth:`edmonds_karp`
+        and :meth:`shortest_augmenting_path`. Other algorithms will ignore
+        this parameter. Default value: None.
+
+    Returns
+    -------
+    K : integer
+        local edge connectivity for nodes s and t.
+
+    Examples
+    --------
+    This function is not imported in the base NetworkX namespace, so you
+    have to explicitly import it from the connectivity package:
+
+    >>> from networkx.algorithms.connectivity import local_edge_connectivity
+
+    We use in this example the platonic icosahedral graph, which has edge
+    connectivity 5.
+
+    >>> G = nx.icosahedral_graph()
+    >>> local_edge_connectivity(G, 0, 6)
+    5
+
+    If you need to compute local connectivity on several pairs of
+    nodes in the same graph, it is recommended that you reuse the
+    data structures that NetworkX uses in the computation: the
+    auxiliary digraph for edge connectivity, and the residual
+    network for the underlying maximum flow computation.
+
+    Example of how to compute local edge connectivity among
+    all pairs of nodes of the platonic icosahedral graph reusing
+    the data structures.
+
+    >>> import itertools
+    >>> # You also have to explicitly import the function for
+    >>> # building the auxiliary digraph from the connectivity package
+    >>> from networkx.algorithms.connectivity import build_auxiliary_edge_connectivity
+    >>> H = build_auxiliary_edge_connectivity(G)
+    >>> # And the function for building the residual network from the
+    >>> # flow package
+    >>> from networkx.algorithms.flow import build_residual_network
+    >>> # Note that the auxiliary digraph has an edge attribute named capacity
+    >>> R = build_residual_network(H, "capacity")
+    >>> result = dict.fromkeys(G, dict())
+    >>> # Reuse the auxiliary digraph and the residual network by passing them
+    >>> # as parameters
+    >>> for u, v in itertools.combinations(G, 2):
+    ...     k = local_edge_connectivity(G, u, v, auxiliary=H, residual=R)
+    ...     result[u][v] = k
+    >>> all(result[u][v] == 5 for u, v in itertools.combinations(G, 2))
+    True
+
+    You can also use alternative flow algorithms for computing edge
+    connectivity. For instance, in dense networks the algorithm
+    :meth:`shortest_augmenting_path` will usually perform better than
+    the default :meth:`edmonds_karp` which is faster for sparse
+    networks with highly skewed degree distributions. Alternative flow
+    functions have to be explicitly imported from the flow package.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> local_edge_connectivity(G, 0, 6, flow_func=shortest_augmenting_path)
+    5
+
+    Notes
+    -----
+    This is a flow based implementation of edge connectivity. We compute the
+    maximum flow using, by default, the :meth:`edmonds_karp` algorithm on an
+    auxiliary digraph build from the original input graph:
+
+    If the input graph is undirected, we replace each edge (`u`,`v`) with
+    two reciprocal arcs (`u`, `v`) and (`v`, `u`) and then we set the attribute
+    'capacity' for each arc to 1. If the input graph is directed we simply
+    add the 'capacity' attribute. This is an implementation of algorithm 1
+    in [1]_.
+
+    The maximum flow in the auxiliary network is equal to the local edge
+    connectivity because the value of a maximum s-t-flow is equal to the
+    capacity of a minimum s-t-cut (Ford and Fulkerson theorem).
+
+    See also
+    --------
+    :meth:`edge_connectivity`
+    :meth:`local_node_connectivity`
+    :meth:`node_connectivity`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    References
+    ----------
+    .. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms.
+        http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
+
+    """
+    if flow_func is None:
+        flow_func = default_flow_func
+
+    if auxiliary is None:
+        H = build_auxiliary_edge_connectivity(G)
+    else:
+        H = auxiliary
+
+    kwargs = dict(flow_func=flow_func, residual=residual)
+    if flow_func is shortest_augmenting_path:
+        kwargs["cutoff"] = cutoff
+        kwargs["two_phase"] = True
+    elif flow_func is edmonds_karp:
+        kwargs["cutoff"] = cutoff
+    elif flow_func is dinitz:
+        kwargs["cutoff"] = cutoff
+    elif flow_func is boykov_kolmogorov:
+        kwargs["cutoff"] = cutoff
+
+    return nx.maximum_flow_value(H, s, t, **kwargs)
+
+
+def edge_connectivity(G, s=None, t=None, flow_func=None, cutoff=None):
+    r"""Returns the edge connectivity of the graph or digraph G.
+
+    The edge connectivity is equal to the minimum number of edges that
+    must be removed to disconnect G or render it trivial. If source
+    and target nodes are provided, this function returns the local edge
+    connectivity: the minimum number of edges that must be removed to
+    break all paths from source to target in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected or directed graph
+
+    s : node
+        Source node. Optional. Default value: None.
+
+    t : node
+        Target node. Optional. Default value: None.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. See below for details. The
+        choice of the default function may change from version
+        to version and should not be relied on. Default value: None.
+
+    cutoff : integer, float
+        If specified, the maximum flow algorithm will terminate when the
+        flow value reaches or exceeds the cutoff. This is only for the
+        algorithms that support the cutoff parameter: e.g., :meth:`edmonds_karp`
+        and :meth:`shortest_augmenting_path`. Other algorithms will ignore
+        this parameter. Default value: None.
+
+    Returns
+    -------
+    K : integer
+        Edge connectivity for G, or local edge connectivity if source
+        and target were provided
+
+    Examples
+    --------
+    >>> # Platonic icosahedral graph is 5-edge-connected
+    >>> G = nx.icosahedral_graph()
+    >>> nx.edge_connectivity(G)
+    5
+
+    You can use alternative flow algorithms for the underlying
+    maximum flow computation. In dense networks the algorithm
+    :meth:`shortest_augmenting_path` will usually perform better
+    than the default :meth:`edmonds_karp`, which is faster for
+    sparse networks with highly skewed degree distributions.
+    Alternative flow functions have to be explicitly imported
+    from the flow package.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> nx.edge_connectivity(G, flow_func=shortest_augmenting_path)
+    5
+
+    If you specify a pair of nodes (source and target) as parameters,
+    this function returns the value of local edge connectivity.
+
+    >>> nx.edge_connectivity(G, 3, 7)
+    5
+
+    If you need to perform several local computations among different
+    pairs of nodes on the same graph, it is recommended that you reuse
+    the data structures used in the maximum flow computations. See
+    :meth:`local_edge_connectivity` for details.
+
+    Notes
+    -----
+    This is a flow based implementation of global edge connectivity.
+    For undirected graphs the algorithm works by finding a 'small'
+    dominating set of nodes of G (see algorithm 7 in [1]_ ) and
+    computing local maximum flow (see :meth:`local_edge_connectivity`)
+    between an arbitrary node in the dominating set and the rest of
+    nodes in it. This is an implementation of algorithm 6 in [1]_ .
+    For directed graphs, the algorithm does n calls to the maximum
+    flow function. This is an implementation of algorithm 8 in [1]_ .
+
+    See also
+    --------
+    :meth:`local_edge_connectivity`
+    :meth:`local_node_connectivity`
+    :meth:`node_connectivity`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+    :meth:`k_edge_components`
+    :meth:`k_edge_subgraphs`
+
+    References
+    ----------
+    .. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms.
+        http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
+
+    """
+    if (s is not None and t is None) or (s is None and t is not None):
+        raise nx.NetworkXError("Both source and target must be specified.")
+
+    # Local edge connectivity
+    if s is not None and t is not None:
+        if s not in G:
+            raise nx.NetworkXError(f"node {s} not in graph")
+        if t not in G:
+            raise nx.NetworkXError(f"node {t} not in graph")
+        return local_edge_connectivity(G, s, t, flow_func=flow_func, cutoff=cutoff)
+
+    # Global edge connectivity
+    # reuse auxiliary digraph and residual network
+    H = build_auxiliary_edge_connectivity(G)
+    R = build_residual_network(H, "capacity")
+    kwargs = dict(flow_func=flow_func, auxiliary=H, residual=R)
+
+    if G.is_directed():
+        # Algorithm 8 in [1]
+        if not nx.is_weakly_connected(G):
+            return 0
+
+        # initial value for \lambda is minimum degree
+        L = min(d for n, d in G.degree())
+        nodes = list(G)
+        n = len(nodes)
+
+        if cutoff is not None:
+            L = min(cutoff, L)
+
+        for i in range(n):
+            kwargs["cutoff"] = L
+            try:
+                L = min(L, local_edge_connectivity(G, nodes[i], nodes[i + 1], **kwargs))
+            except IndexError:  # last node!
+                L = min(L, local_edge_connectivity(G, nodes[i], nodes[0], **kwargs))
+        return L
+    else:  # undirected
+        # Algorithm 6 in [1]
+        if not nx.is_connected(G):
+            return 0
+
+        # initial value for \lambda is minimum degree
+        L = min(d for n, d in G.degree())
+
+        if cutoff is not None:
+            L = min(cutoff, L)
+
+        # A dominating set is \lambda-covering
+        # We need a dominating set with at least two nodes
+        for node in G:
+            D = nx.dominating_set(G, start_with=node)
+            v = D.pop()
+            if D:
+                break
+        else:
+            # in complete graphs the dominating sets will always be of one node
+            # thus we return min degree
+            return L
+
+        for w in D:
+            kwargs["cutoff"] = L
+            L = min(L, local_edge_connectivity(G, v, w, **kwargs))
+
+        return L
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/cuts.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/cuts.py
new file mode 100644
index 0000000..92495b1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/cuts.py
@@ -0,0 +1,599 @@
+"""
+Flow based cut algorithms
+"""
+import itertools
+
+import networkx as nx
+
+# Define the default maximum flow function to use in all flow based
+# cut algorithms.
+from networkx.algorithms.flow import build_residual_network, edmonds_karp
+
+default_flow_func = edmonds_karp
+
+from .utils import build_auxiliary_edge_connectivity, build_auxiliary_node_connectivity
+
+__all__ = [
+    "minimum_st_node_cut",
+    "minimum_node_cut",
+    "minimum_st_edge_cut",
+    "minimum_edge_cut",
+]
+
+
+def minimum_st_edge_cut(G, s, t, flow_func=None, auxiliary=None, residual=None):
+    """Returns the edges of the cut-set of a minimum (s, t)-cut.
+
+    This function returns the set of edges of minimum cardinality that,
+    if removed, would destroy all paths among source and target in G.
+    Edge weights are not considered. See :meth:`minimum_cut` for
+    computing minimum cuts considering edge weights.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    s : node
+        Source node for the flow.
+
+    t : node
+        Sink node for the flow.
+
+    auxiliary : NetworkX DiGraph
+        Auxiliary digraph to compute flow based node connectivity. It has
+        to have a graph attribute called mapping with a dictionary mapping
+        node names in G and in the auxiliary digraph. If provided
+        it will be reused instead of recreated. Default value: None.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. See :meth:`node_connectivity` for
+        details. The choice of the default function may change from version
+        to version and should not be relied on. Default value: None.
+
+    residual : NetworkX DiGraph
+        Residual network to compute maximum flow. If provided it will be
+        reused instead of recreated. Default value: None.
+
+    Returns
+    -------
+    cutset : set
+        Set of edges that, if removed from the graph, will disconnect it.
+
+    See also
+    --------
+    :meth:`minimum_cut`
+    :meth:`minimum_node_cut`
+    :meth:`minimum_edge_cut`
+    :meth:`stoer_wagner`
+    :meth:`node_connectivity`
+    :meth:`edge_connectivity`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    Examples
+    --------
+    This function is not imported in the base NetworkX namespace, so you
+    have to explicitly import it from the connectivity package:
+
+    >>> from networkx.algorithms.connectivity import minimum_st_edge_cut
+
+    We use in this example the platonic icosahedral graph, which has edge
+    connectivity 5.
+
+    >>> G = nx.icosahedral_graph()
+    >>> len(minimum_st_edge_cut(G, 0, 6))
+    5
+
+    If you need to compute local edge cuts on several pairs of
+    nodes in the same graph, it is recommended that you reuse the
+    data structures that NetworkX uses in the computation: the
+    auxiliary digraph for edge connectivity, and the residual
+    network for the underlying maximum flow computation.
+
+    Example of how to compute local edge cuts among all pairs of
+    nodes of the platonic icosahedral graph reusing the data
+    structures.
+
+    >>> import itertools
+    >>> # You also have to explicitly import the function for
+    >>> # building the auxiliary digraph from the connectivity package
+    >>> from networkx.algorithms.connectivity import build_auxiliary_edge_connectivity
+    >>> H = build_auxiliary_edge_connectivity(G)
+    >>> # And the function for building the residual network from the
+    >>> # flow package
+    >>> from networkx.algorithms.flow import build_residual_network
+    >>> # Note that the auxiliary digraph has an edge attribute named capacity
+    >>> R = build_residual_network(H, "capacity")
+    >>> result = dict.fromkeys(G, dict())
+    >>> # Reuse the auxiliary digraph and the residual network by passing them
+    >>> # as parameters
+    >>> for u, v in itertools.combinations(G, 2):
+    ...     k = len(minimum_st_edge_cut(G, u, v, auxiliary=H, residual=R))
+    ...     result[u][v] = k
+    >>> all(result[u][v] == 5 for u, v in itertools.combinations(G, 2))
+    True
+
+    You can also use alternative flow algorithms for computing edge
+    cuts. For instance, in dense networks the algorithm
+    :meth:`shortest_augmenting_path` will usually perform better than
+    the default :meth:`edmonds_karp` which is faster for sparse
+    networks with highly skewed degree distributions. Alternative flow
+    functions have to be explicitly imported from the flow package.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> len(minimum_st_edge_cut(G, 0, 6, flow_func=shortest_augmenting_path))
+    5
+
+    """
+    if flow_func is None:
+        flow_func = default_flow_func
+
+    if auxiliary is None:
+        H = build_auxiliary_edge_connectivity(G)
+    else:
+        H = auxiliary
+
+    kwargs = dict(capacity="capacity", flow_func=flow_func, residual=residual)
+
+    cut_value, partition = nx.minimum_cut(H, s, t, **kwargs)
+    reachable, non_reachable = partition
+    # Any edge in the original graph linking the two sets in the
+    # partition is part of the edge cutset
+    cutset = set()
+    for u, nbrs in ((n, G[n]) for n in reachable):
+        cutset.update((u, v) for v in nbrs if v in non_reachable)
+
+    return cutset
+
+
+def minimum_st_node_cut(G, s, t, flow_func=None, auxiliary=None, residual=None):
+    r"""Returns a set of nodes of minimum cardinality that disconnect source
+    from target in G.
+
+    This function returns the set of nodes of minimum cardinality that,
+    if removed, would destroy all paths among source and target in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    s : node
+        Source node.
+
+    t : node
+        Target node.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. See below for details. The choice
+        of the default function may change from version to version and
+        should not be relied on. Default value: None.
+
+    auxiliary : NetworkX DiGraph
+        Auxiliary digraph to compute flow based node connectivity. It has
+        to have a graph attribute called mapping with a dictionary mapping
+        node names in G and in the auxiliary digraph. If provided
+        it will be reused instead of recreated. Default value: None.
+
+    residual : NetworkX DiGraph
+        Residual network to compute maximum flow. If provided it will be
+        reused instead of recreated. Default value: None.
+
+    Returns
+    -------
+    cutset : set
+        Set of nodes that, if removed, would destroy all paths between
+        source and target in G.
+
+    Examples
+    --------
+    This function is not imported in the base NetworkX namespace, so you
+    have to explicitly import it from the connectivity package:
+
+    >>> from networkx.algorithms.connectivity import minimum_st_node_cut
+
+    We use in this example the platonic icosahedral graph, which has node
+    connectivity 5.
+
+    >>> G = nx.icosahedral_graph()
+    >>> len(minimum_st_node_cut(G, 0, 6))
+    5
+
+    If you need to compute local st cuts between several pairs of
+    nodes in the same graph, it is recommended that you reuse the
+    data structures that NetworkX uses in the computation: the
+    auxiliary digraph for node connectivity and node cuts, and the
+    residual network for the underlying maximum flow computation.
+
+    Example of how to compute local st node cuts reusing the data
+    structures:
+
+    >>> # You also have to explicitly import the function for
+    >>> # building the auxiliary digraph from the connectivity package
+    >>> from networkx.algorithms.connectivity import build_auxiliary_node_connectivity
+    >>> H = build_auxiliary_node_connectivity(G)
+    >>> # And the function for building the residual network from the
+    >>> # flow package
+    >>> from networkx.algorithms.flow import build_residual_network
+    >>> # Note that the auxiliary digraph has an edge attribute named capacity
+    >>> R = build_residual_network(H, "capacity")
+    >>> # Reuse the auxiliary digraph and the residual network by passing them
+    >>> # as parameters
+    >>> len(minimum_st_node_cut(G, 0, 6, auxiliary=H, residual=R))
+    5
+
+    You can also use alternative flow algorithms for computing minimum st
+    node cuts. For instance, in dense networks the algorithm
+    :meth:`shortest_augmenting_path` will usually perform better than
+    the default :meth:`edmonds_karp` which is faster for sparse
+    networks with highly skewed degree distributions. Alternative flow
+    functions have to be explicitly imported from the flow package.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> len(minimum_st_node_cut(G, 0, 6, flow_func=shortest_augmenting_path))
+    5
+
+    Notes
+    -----
+    This is a flow based implementation of minimum node cut. The algorithm
+    is based in solving a number of maximum flow computations to determine
+    the capacity of the minimum cut on an auxiliary directed network that
+    corresponds to the minimum node cut of G. It handles both directed
+    and undirected graphs. This implementation is based on algorithm 11
+    in [1]_.
+
+    See also
+    --------
+    :meth:`minimum_node_cut`
+    :meth:`minimum_edge_cut`
+    :meth:`stoer_wagner`
+    :meth:`node_connectivity`
+    :meth:`edge_connectivity`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    References
+    ----------
+    .. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms.
+        http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
+
+    """
+    if auxiliary is None:
+        H = build_auxiliary_node_connectivity(G)
+    else:
+        H = auxiliary
+
+    mapping = H.graph.get("mapping", None)
+    if mapping is None:
+        raise nx.NetworkXError("Invalid auxiliary digraph.")
+    if G.has_edge(s, t) or G.has_edge(t, s):
+        return {}
+    kwargs = dict(flow_func=flow_func, residual=residual, auxiliary=H)
+
+    # The edge cut in the auxiliary digraph corresponds to the node cut in the
+    # original graph.
+    edge_cut = minimum_st_edge_cut(H, f"{mapping[s]}B", f"{mapping[t]}A", **kwargs)
+    # Each node in the original graph maps to two nodes of the auxiliary graph
+    node_cut = {H.nodes[node]["id"] for edge in edge_cut for node in edge}
+    return node_cut - {s, t}
+
+
+def minimum_node_cut(G, s=None, t=None, flow_func=None):
+    r"""Returns a set of nodes of minimum cardinality that disconnects G.
+
+    If source and target nodes are provided, this function returns the
+    set of nodes of minimum cardinality that, if removed, would destroy
+    all paths among source and target in G. If not, it returns a set
+    of nodes of minimum cardinality that disconnects G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    s : node
+        Source node. Optional. Default value: None.
+
+    t : node
+        Target node. Optional. Default value: None.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. See below for details. The
+        choice of the default function may change from version
+        to version and should not be relied on. Default value: None.
+
+    Returns
+    -------
+    cutset : set
+        Set of nodes that, if removed, would disconnect G. If source
+        and target nodes are provided, the set contains the nodes that
+        if removed, would destroy all paths between source and target.
+
+    Examples
+    --------
+    >>> # Platonic icosahedral graph has node connectivity 5
+    >>> G = nx.icosahedral_graph()
+    >>> node_cut = nx.minimum_node_cut(G)
+    >>> len(node_cut)
+    5
+
+    You can use alternative flow algorithms for the underlying maximum
+    flow computation. In dense networks the algorithm
+    :meth:`shortest_augmenting_path` will usually perform better
+    than the default :meth:`edmonds_karp`, which is faster for
+    sparse networks with highly skewed degree distributions. Alternative
+    flow functions have to be explicitly imported from the flow package.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> node_cut == nx.minimum_node_cut(G, flow_func=shortest_augmenting_path)
+    True
+
+    If you specify a pair of nodes (source and target) as parameters,
+    this function returns a local st node cut.
+
+    >>> len(nx.minimum_node_cut(G, 3, 7))
+    5
+
+    If you need to perform several local st cuts among different
+    pairs of nodes on the same graph, it is recommended that you reuse
+    the data structures used in the maximum flow computations. See
+    :meth:`minimum_st_node_cut` for details.
+
+    Notes
+    -----
+    This is a flow based implementation of minimum node cut. The algorithm
+    is based in solving a number of maximum flow computations to determine
+    the capacity of the minimum cut on an auxiliary directed network that
+    corresponds to the minimum node cut of G. It handles both directed
+    and undirected graphs. This implementation is based on algorithm 11
+    in [1]_.
+
+    See also
+    --------
+    :meth:`minimum_st_node_cut`
+    :meth:`minimum_cut`
+    :meth:`minimum_edge_cut`
+    :meth:`stoer_wagner`
+    :meth:`node_connectivity`
+    :meth:`edge_connectivity`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    References
+    ----------
+    .. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms.
+        http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
+
+    """
+    if (s is not None and t is None) or (s is None and t is not None):
+        raise nx.NetworkXError("Both source and target must be specified.")
+
+    # Local minimum node cut.
+    if s is not None and t is not None:
+        if s not in G:
+            raise nx.NetworkXError(f"node {s} not in graph")
+        if t not in G:
+            raise nx.NetworkXError(f"node {t} not in graph")
+        return minimum_st_node_cut(G, s, t, flow_func=flow_func)
+
+    # Global minimum node cut.
+    # Analog to the algorithm 11 for global node connectivity in [1].
+    if G.is_directed():
+        if not nx.is_weakly_connected(G):
+            raise nx.NetworkXError("Input graph is not connected")
+        iter_func = itertools.permutations
+
+        def neighbors(v):
+            return itertools.chain.from_iterable([G.predecessors(v), G.successors(v)])
+
+    else:
+        if not nx.is_connected(G):
+            raise nx.NetworkXError("Input graph is not connected")
+        iter_func = itertools.combinations
+        neighbors = G.neighbors
+
+    # Reuse the auxiliary digraph and the residual network.
+    H = build_auxiliary_node_connectivity(G)
+    R = build_residual_network(H, "capacity")
+    kwargs = dict(flow_func=flow_func, auxiliary=H, residual=R)
+
+    # Choose a node with minimum degree.
+    v = min(G, key=G.degree)
+    # Initial node cutset is all neighbors of the node with minimum degree.
+    min_cut = set(G[v])
+    # Compute st node cuts between v and all its non-neighbors nodes in G.
+    for w in set(G) - set(neighbors(v)) - {v}:
+        this_cut = minimum_st_node_cut(G, v, w, **kwargs)
+        if len(min_cut) >= len(this_cut):
+            min_cut = this_cut
+    # Also for non adjacent pairs of neighbors of v.
+    for x, y in iter_func(neighbors(v), 2):
+        if y in G[x]:
+            continue
+        this_cut = minimum_st_node_cut(G, x, y, **kwargs)
+        if len(min_cut) >= len(this_cut):
+            min_cut = this_cut
+
+    return min_cut
+
+
+def minimum_edge_cut(G, s=None, t=None, flow_func=None):
+    r"""Returns a set of edges of minimum cardinality that disconnects G.
+
+    If source and target nodes are provided, this function returns the
+    set of edges of minimum cardinality that, if removed, would break
+    all paths among source and target in G. If not, it returns a set of
+    edges of minimum cardinality that disconnects G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    s : node
+        Source node. Optional. Default value: None.
+
+    t : node
+        Target node. Optional. Default value: None.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. See below for details. The
+        choice of the default function may change from version
+        to version and should not be relied on. Default value: None.
+
+    Returns
+    -------
+    cutset : set
+        Set of edges that, if removed, would disconnect G. If source
+        and target nodes are provided, the set contains the edges that
+        if removed, would destroy all paths between source and target.
+
+    Examples
+    --------
+    >>> # Platonic icosahedral graph has edge connectivity 5
+    >>> G = nx.icosahedral_graph()
+    >>> len(nx.minimum_edge_cut(G))
+    5
+
+    You can use alternative flow algorithms for the underlying
+    maximum flow computation. In dense networks the algorithm
+    :meth:`shortest_augmenting_path` will usually perform better
+    than the default :meth:`edmonds_karp`, which is faster for
+    sparse networks with highly skewed degree distributions.
+    Alternative flow functions have to be explicitly imported
+    from the flow package.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> len(nx.minimum_edge_cut(G, flow_func=shortest_augmenting_path))
+    5
+
+    If you specify a pair of nodes (source and target) as parameters,
+    this function returns the value of local edge connectivity.
+
+    >>> nx.edge_connectivity(G, 3, 7)
+    5
+
+    If you need to perform several local computations among different
+    pairs of nodes on the same graph, it is recommended that you reuse
+    the data structures used in the maximum flow computations. See
+    :meth:`local_edge_connectivity` for details.
+
+    Notes
+    -----
+    This is a flow based implementation of minimum edge cut. For
+    undirected graphs the algorithm works by finding a 'small' dominating
+    set of nodes of G (see algorithm 7 in [1]_) and computing the maximum
+    flow between an arbitrary node in the dominating set and the rest of
+    nodes in it. This is an implementation of algorithm 6 in [1]_. For
+    directed graphs, the algorithm does n calls to the max flow function.
+    The function raises an error if the directed graph is not weakly
+    connected and returns an empty set if it is weakly connected.
+    It is an implementation of algorithm 8 in [1]_.
+
+    See also
+    --------
+    :meth:`minimum_st_edge_cut`
+    :meth:`minimum_node_cut`
+    :meth:`stoer_wagner`
+    :meth:`node_connectivity`
+    :meth:`edge_connectivity`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    References
+    ----------
+    .. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms.
+        http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
+
+    """
+    if (s is not None and t is None) or (s is None and t is not None):
+        raise nx.NetworkXError("Both source and target must be specified.")
+
+    # reuse auxiliary digraph and residual network
+    H = build_auxiliary_edge_connectivity(G)
+    R = build_residual_network(H, "capacity")
+    kwargs = dict(flow_func=flow_func, residual=R, auxiliary=H)
+
+    # Local minimum edge cut if s and t are not None
+    if s is not None and t is not None:
+        if s not in G:
+            raise nx.NetworkXError(f"node {s} not in graph")
+        if t not in G:
+            raise nx.NetworkXError(f"node {t} not in graph")
+        return minimum_st_edge_cut(H, s, t, **kwargs)
+
+    # Global minimum edge cut
+    # Analog to the algorithm for global edge connectivity
+    if G.is_directed():
+        # Based on algorithm 8 in [1]
+        if not nx.is_weakly_connected(G):
+            raise nx.NetworkXError("Input graph is not connected")
+
+        # Initial cutset is all edges of a node with minimum degree
+        node = min(G, key=G.degree)
+        min_cut = set(G.edges(node))
+        nodes = list(G)
+        n = len(nodes)
+        for i in range(n):
+            try:
+                this_cut = minimum_st_edge_cut(H, nodes[i], nodes[i + 1], **kwargs)
+                if len(this_cut) <= len(min_cut):
+                    min_cut = this_cut
+            except IndexError:  # Last node!
+                this_cut = minimum_st_edge_cut(H, nodes[i], nodes[0], **kwargs)
+                if len(this_cut) <= len(min_cut):
+                    min_cut = this_cut
+
+        return min_cut
+
+    else:  # undirected
+        # Based on algorithm 6 in [1]
+        if not nx.is_connected(G):
+            raise nx.NetworkXError("Input graph is not connected")
+
+        # Initial cutset is all edges of a node with minimum degree
+        node = min(G, key=G.degree)
+        min_cut = set(G.edges(node))
+        # A dominating set is \lambda-covering
+        # We need a dominating set with at least two nodes
+        for node in G:
+            D = nx.dominating_set(G, start_with=node)
+            v = D.pop()
+            if D:
+                break
+        else:
+            # in complete graphs the dominating set will always be of one node
+            # thus we return min_cut, which now contains the edges of a node
+            # with minimum degree
+            return min_cut
+        for w in D:
+            this_cut = minimum_st_edge_cut(H, v, w, **kwargs)
+            if len(this_cut) <= len(min_cut):
+                min_cut = this_cut
+
+        return min_cut
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/disjoint_paths.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/disjoint_paths.py
new file mode 100644
index 0000000..378a709
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/disjoint_paths.py
@@ -0,0 +1,394 @@
+"""Flow based node and edge disjoint paths."""
+import networkx as nx
+
+# Define the default maximum flow function to use for the undelying
+# maximum flow computations
+from networkx.algorithms.flow import (
+    edmonds_karp,
+    preflow_push,
+    shortest_augmenting_path,
+)
+from networkx.exception import NetworkXNoPath
+
+default_flow_func = edmonds_karp
+from itertools import filterfalse as _filterfalse
+
+# Functions to build auxiliary data structures.
+from .utils import build_auxiliary_edge_connectivity, build_auxiliary_node_connectivity
+
+__all__ = ["edge_disjoint_paths", "node_disjoint_paths"]
+
+
+def edge_disjoint_paths(
+    G, s, t, flow_func=None, cutoff=None, auxiliary=None, residual=None
+):
+    """Returns the edges disjoint paths between source and target.
+
+    Edge disjoint paths are paths that do not share any edge. The
+    number of edge disjoint paths between source and target is equal
+    to their edge connectivity.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    s : node
+        Source node for the flow.
+
+    t : node
+        Sink node for the flow.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. The choice of the default function
+        may change from version to version and should not be relied on.
+        Default value: None.
+
+    cutoff : int
+        Maximum number of paths to yield. Some of the maximum flow
+        algorithms, such as :meth:`edmonds_karp` (the default) and
+        :meth:`shortest_augmenting_path` support the cutoff parameter,
+        and will terminate when the flow value reaches or exceeds the
+        cutoff. Other algorithms will ignore this parameter.
+        Default value: None.
+
+    auxiliary : NetworkX DiGraph
+        Auxiliary digraph to compute flow based edge connectivity. It has
+        to have a graph attribute called mapping with a dictionary mapping
+        node names in G and in the auxiliary digraph. If provided
+        it will be reused instead of recreated. Default value: None.
+
+    residual : NetworkX DiGraph
+        Residual network to compute maximum flow. If provided it will be
+        reused instead of recreated. Default value: None.
+
+    Returns
+    -------
+    paths : generator
+        A generator of edge independent paths.
+
+    Raises
+    ------
+    NetworkXNoPath
+        If there is no path between source and target.
+
+    NetworkXError
+        If source or target are not in the graph G.
+
+    See also
+    --------
+    :meth:`node_disjoint_paths`
+    :meth:`edge_connectivity`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    Examples
+    --------
+    We use in this example the platonic icosahedral graph, which has node
+    edge connectivity 5, thus there are 5 edge disjoint paths between any
+    pair of nodes.
+
+    >>> G = nx.icosahedral_graph()
+    >>> len(list(nx.edge_disjoint_paths(G, 0, 6)))
+    5
+
+
+    If you need to compute edge disjoint paths on several pairs of
+    nodes in the same graph, it is recommended that you reuse the
+    data structures that NetworkX uses in the computation: the
+    auxiliary digraph for edge connectivity, and the residual
+    network for the underlying maximum flow computation.
+
+    Example of how to compute edge disjoint paths among all pairs of
+    nodes of the platonic icosahedral graph reusing the data
+    structures.
+
+    >>> import itertools
+    >>> # You also have to explicitly import the function for
+    >>> # building the auxiliary digraph from the connectivity package
+    >>> from networkx.algorithms.connectivity import build_auxiliary_edge_connectivity
+    >>> H = build_auxiliary_edge_connectivity(G)
+    >>> # And the function for building the residual network from the
+    >>> # flow package
+    >>> from networkx.algorithms.flow import build_residual_network
+    >>> # Note that the auxiliary digraph has an edge attribute named capacity
+    >>> R = build_residual_network(H, "capacity")
+    >>> result = {n: {} for n in G}
+    >>> # Reuse the auxiliary digraph and the residual network by passing them
+    >>> # as arguments
+    >>> for u, v in itertools.combinations(G, 2):
+    ...     k = len(list(nx.edge_disjoint_paths(G, u, v, auxiliary=H, residual=R)))
+    ...     result[u][v] = k
+    >>> all(result[u][v] == 5 for u, v in itertools.combinations(G, 2))
+    True
+
+    You can also use alternative flow algorithms for computing edge disjoint
+    paths. For instance, in dense networks the algorithm
+    :meth:`shortest_augmenting_path` will usually perform better than
+    the default :meth:`edmonds_karp` which is faster for sparse
+    networks with highly skewed degree distributions. Alternative flow
+    functions have to be explicitly imported from the flow package.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> len(list(nx.edge_disjoint_paths(G, 0, 6, flow_func=shortest_augmenting_path)))
+    5
+
+    Notes
+    -----
+    This is a flow based implementation of edge disjoint paths. We compute
+    the maximum flow between source and target on an auxiliary directed
+    network. The saturated edges in the residual network after running the
+    maximum flow algorithm correspond to edge disjoint paths between source
+    and target in the original network. This function handles both directed
+    and undirected graphs, and can use all flow algorithms from NetworkX flow
+    package.
+
+    """
+    if s not in G:
+        raise nx.NetworkXError(f"node {s} not in graph")
+    if t not in G:
+        raise nx.NetworkXError(f"node {t} not in graph")
+
+    if flow_func is None:
+        flow_func = default_flow_func
+
+    if auxiliary is None:
+        H = build_auxiliary_edge_connectivity(G)
+    else:
+        H = auxiliary
+
+    # Maximum possible edge disjoint paths
+    possible = min(H.out_degree(s), H.in_degree(t))
+    if not possible:
+        raise NetworkXNoPath
+
+    if cutoff is None:
+        cutoff = possible
+    else:
+        cutoff = min(cutoff, possible)
+
+    # Compute maximum flow between source and target. Flow functions in
+    # NetworkX return a residual network.
+    kwargs = dict(
+        capacity="capacity", residual=residual, cutoff=cutoff, value_only=True
+    )
+    if flow_func is preflow_push:
+        del kwargs["cutoff"]
+    if flow_func is shortest_augmenting_path:
+        kwargs["two_phase"] = True
+    R = flow_func(H, s, t, **kwargs)
+
+    if R.graph["flow_value"] == 0:
+        raise NetworkXNoPath
+
+    # Saturated edges in the residual network form the edge disjoint paths
+    # between source and target
+    cutset = [
+        (u, v)
+        for u, v, d in R.edges(data=True)
+        if d["capacity"] == d["flow"] and d["flow"] > 0
+    ]
+    # This is equivalent of what flow.utils.build_flow_dict returns, but
+    # only for the nodes with saturated edges and without reporting 0 flows.
+    flow_dict = {n: {} for edge in cutset for n in edge}
+    for u, v in cutset:
+        flow_dict[u][v] = 1
+
+    # Rebuild the edge disjoint paths from the flow dictionary.
+    paths_found = 0
+    for v in list(flow_dict[s]):
+        if paths_found >= cutoff:
+            # preflow_push does not support cutoff: we have to
+            # keep track of the paths founds and stop at cutoff.
+            break
+        path = [s]
+        if v == t:
+            path.append(v)
+            yield path
+            continue
+        u = v
+        while u != t:
+            path.append(u)
+            try:
+                u, _ = flow_dict[u].popitem()
+            except KeyError:
+                break
+        else:
+            path.append(t)
+            yield path
+            paths_found += 1
+
+
+def node_disjoint_paths(
+    G, s, t, flow_func=None, cutoff=None, auxiliary=None, residual=None
+):
+    r"""Computes node disjoint paths between source and target.
+
+    Node disjoint paths are paths that only share their first and last
+    nodes. The number of node independent paths between two nodes is
+    equal to their local node connectivity.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    s : node
+        Source node.
+
+    t : node
+        Target node.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes.
+        The function has to accept at least three parameters: a Digraph,
+        a source node, and a target node. And return a residual network
+        that follows NetworkX conventions (see :meth:`maximum_flow` for
+        details). If flow_func is None, the default maximum flow function
+        (:meth:`edmonds_karp`) is used. See below for details. The choice
+        of the default function may change from version to version and
+        should not be relied on. Default value: None.
+
+    cutoff : int
+        Maximum number of paths to yield. Some of the maximum flow
+        algorithms, such as :meth:`edmonds_karp` (the default) and
+        :meth:`shortest_augmenting_path` support the cutoff parameter,
+        and will terminate when the flow value reaches or exceeds the
+        cutoff. Other algorithms will ignore this parameter.
+        Default value: None.
+
+    auxiliary : NetworkX DiGraph
+        Auxiliary digraph to compute flow based node connectivity. It has
+        to have a graph attribute called mapping with a dictionary mapping
+        node names in G and in the auxiliary digraph. If provided
+        it will be reused instead of recreated. Default value: None.
+
+    residual : NetworkX DiGraph
+        Residual network to compute maximum flow. If provided it will be
+        reused instead of recreated. Default value: None.
+
+    Returns
+    -------
+    paths : generator
+        Generator of node disjoint paths.
+
+    Raises
+    ------
+    NetworkXNoPath
+        If there is no path between source and target.
+
+    NetworkXError
+        If source or target are not in the graph G.
+
+    Examples
+    --------
+    We use in this example the platonic icosahedral graph, which has node
+    connectivity 5, thus there are 5 node disjoint paths between any pair
+    of non neighbor nodes.
+
+    >>> G = nx.icosahedral_graph()
+    >>> len(list(nx.node_disjoint_paths(G, 0, 6)))
+    5
+
+    If you need to compute node disjoint paths between several pairs of
+    nodes in the same graph, it is recommended that you reuse the
+    data structures that NetworkX uses in the computation: the
+    auxiliary digraph for node connectivity and node cuts, and the
+    residual network for the underlying maximum flow computation.
+
+    Example of how to compute node disjoint paths reusing the data
+    structures:
+
+    >>> # You also have to explicitly import the function for
+    >>> # building the auxiliary digraph from the connectivity package
+    >>> from networkx.algorithms.connectivity import build_auxiliary_node_connectivity
+    >>> H = build_auxiliary_node_connectivity(G)
+    >>> # And the function for building the residual network from the
+    >>> # flow package
+    >>> from networkx.algorithms.flow import build_residual_network
+    >>> # Note that the auxiliary digraph has an edge attribute named capacity
+    >>> R = build_residual_network(H, "capacity")
+    >>> # Reuse the auxiliary digraph and the residual network by passing them
+    >>> # as arguments
+    >>> len(list(nx.node_disjoint_paths(G, 0, 6, auxiliary=H, residual=R)))
+    5
+
+    You can also use alternative flow algorithms for computing node disjoint
+    paths. For instance, in dense networks the algorithm
+    :meth:`shortest_augmenting_path` will usually perform better than
+    the default :meth:`edmonds_karp` which is faster for sparse
+    networks with highly skewed degree distributions. Alternative flow
+    functions have to be explicitly imported from the flow package.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> len(list(nx.node_disjoint_paths(G, 0, 6, flow_func=shortest_augmenting_path)))
+    5
+
+    Notes
+    -----
+    This is a flow based implementation of node disjoint paths. We compute
+    the maximum flow between source and target on an auxiliary directed
+    network. The saturated edges in the residual network after running the
+    maximum flow algorithm correspond to node disjoint paths between source
+    and target in the original network. This function handles both directed
+    and undirected graphs, and can use all flow algorithms from NetworkX flow
+    package.
+
+    See also
+    --------
+    :meth:`edge_disjoint_paths`
+    :meth:`node_connectivity`
+    :meth:`maximum_flow`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    """
+    if s not in G:
+        raise nx.NetworkXError(f"node {s} not in graph")
+    if t not in G:
+        raise nx.NetworkXError(f"node {t} not in graph")
+
+    if auxiliary is None:
+        H = build_auxiliary_node_connectivity(G)
+    else:
+        H = auxiliary
+
+    mapping = H.graph.get("mapping", None)
+    if mapping is None:
+        raise nx.NetworkXError("Invalid auxiliary digraph.")
+
+    # Maximum possible edge disjoint paths
+    possible = min(H.out_degree(f"{mapping[s]}B"), H.in_degree(f"{mapping[t]}A"))
+    if not possible:
+        raise NetworkXNoPath
+
+    if cutoff is None:
+        cutoff = possible
+    else:
+        cutoff = min(cutoff, possible)
+
+    kwargs = dict(flow_func=flow_func, residual=residual, auxiliary=H, cutoff=cutoff)
+
+    # The edge disjoint paths in the auxiliary digraph correspond to the node
+    # disjoint paths in the original graph.
+    paths_edges = edge_disjoint_paths(H, f"{mapping[s]}B", f"{mapping[t]}A", **kwargs)
+    for path in paths_edges:
+        # Each node in the original graph maps to two nodes in auxiliary graph
+        yield list(_unique_everseen(H.nodes[node]["id"] for node in path))
+
+
+def _unique_everseen(iterable):
+    # Adapted from https://docs.python.org/3/library/itertools.html examples
+    "List unique elements, preserving order. Remember all elements ever seen."
+    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
+    seen = set()
+    seen_add = seen.add
+    for element in _filterfalse(seen.__contains__, iterable):
+        seen_add(element)
+        yield element
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/edge_augmentation.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/edge_augmentation.py
new file mode 100644
index 0000000..a8c5e83
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/edge_augmentation.py
@@ -0,0 +1,1256 @@
+"""
+Algorithms for finding k-edge-augmentations
+
+A k-edge-augmentation is a set of edges, that once added to a graph, ensures
+that the graph is k-edge-connected; i.e. the graph cannot be disconnected
+unless k or more edges are removed.  Typically, the goal is to find the
+augmentation with minimum weight.  In general, it is not guaranteed that a
+k-edge-augmentation exists.
+
+See Also
+--------
+:mod:`edge_kcomponents` : algorithms for finding k-edge-connected components
+:mod:`connectivity` : algorithms for determening edge connectivity.
+"""
+import itertools as it
+import math
+from collections import defaultdict, namedtuple
+
+import networkx as nx
+from networkx.utils import not_implemented_for, py_random_state
+
+__all__ = ["k_edge_augmentation", "is_k_edge_connected", "is_locally_k_edge_connected"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def is_k_edge_connected(G, k):
+    """Tests to see if a graph is k-edge-connected.
+
+    Is it impossible to disconnect the graph by removing fewer than k edges?
+    If so, then G is k-edge-connected.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    k : integer
+        edge connectivity to test for
+
+    Returns
+    -------
+    boolean
+        True if G is k-edge-connected.
+
+    See Also
+    --------
+    :func:`is_locally_k_edge_connected`
+
+    Examples
+    --------
+    >>> G = nx.barbell_graph(10, 0)
+    >>> nx.is_k_edge_connected(G, k=1)
+    True
+    >>> nx.is_k_edge_connected(G, k=2)
+    False
+    """
+    if k < 1:
+        raise ValueError(f"k must be positive, not {k}")
+    # First try to quickly determine if G is not k-edge-connected
+    if G.number_of_nodes() < k + 1:
+        return False
+    elif any(d < k for n, d in G.degree()):
+        return False
+    else:
+        # Otherwise perform the full check
+        if k == 1:
+            return nx.is_connected(G)
+        elif k == 2:
+            return not nx.has_bridges(G)
+        else:
+            return nx.edge_connectivity(G, cutoff=k) >= k
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def is_locally_k_edge_connected(G, s, t, k):
+    """Tests to see if an edge in a graph is locally k-edge-connected.
+
+    Is it impossible to disconnect s and t by removing fewer than k edges?
+    If so, then s and t are locally k-edge-connected in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    s : node
+        Source node
+
+    t : node
+        Target node
+
+    k : integer
+        local edge connectivity for nodes s and t
+
+    Returns
+    -------
+    boolean
+        True if s and t are locally k-edge-connected in G.
+
+    See Also
+    --------
+    :func:`is_k_edge_connected`
+
+    Examples
+    --------
+    >>> from networkx.algorithms.connectivity import is_locally_k_edge_connected
+    >>> G = nx.barbell_graph(10, 0)
+    >>> is_locally_k_edge_connected(G, 5, 15, k=1)
+    True
+    >>> is_locally_k_edge_connected(G, 5, 15, k=2)
+    False
+    >>> is_locally_k_edge_connected(G, 1, 5, k=2)
+    True
+    """
+    if k < 1:
+        raise ValueError(f"k must be positive, not {k}")
+
+    # First try to quickly determine s, t is not k-locally-edge-connected in G
+    if G.degree(s) < k or G.degree(t) < k:
+        return False
+    else:
+        # Otherwise perform the full check
+        if k == 1:
+            return nx.has_path(G, s, t)
+        else:
+            localk = nx.connectivity.local_edge_connectivity(G, s, t, cutoff=k)
+            return localk >= k
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def k_edge_augmentation(G, k, avail=None, weight=None, partial=False):
+    """Finds set of edges to k-edge-connect G.
+
+    Adding edges from the augmentation to G make it impossible to disconnect G
+    unless k or more edges are removed. This function uses the most efficient
+    function available (depending on the value of k and if the problem is
+    weighted or unweighted) to search for a minimum weight subset of available
+    edges that k-edge-connects G. In general, finding a k-edge-augmentation is
+    NP-hard, so solutions are not guaranteed to be minimal. Furthermore, a
+    k-edge-augmentation may not exist.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    k : integer
+        Desired edge connectivity
+
+    avail : dict or a set of 2 or 3 tuples
+        The available edges that can be used in the augmentation.
+
+        If unspecified, then all edges in the complement of G are available.
+        Otherwise, each item is an available edge (with an optional weight).
+
+        In the unweighted case, each item is an edge ``(u, v)``.
+
+        In the weighted case, each item is a 3-tuple ``(u, v, d)`` or a dict
+        with items ``(u, v): d``.  The third item, ``d``, can be a dictionary
+        or a real number.  If ``d`` is a dictionary ``d[weight]``
+        correspondings to the weight.
+
+    weight : string
+        key to use to find weights if ``avail`` is a set of 3-tuples where the
+        third item in each tuple is a dictionary.
+
+    partial : boolean
+        If partial is True and no feasible k-edge-augmentation exists, then all
+        a partial k-edge-augmentation is generated. Adding the edges in a
+        partial augmentation to G, minimizes the number of k-edge-connected
+        components and maximizes the edge connectivity between those
+        components. For details, see :func:`partial_k_edge_augmentation`.
+
+    Yields
+    ------
+    edge : tuple
+        Edges that, once added to G, would cause G to become k-edge-connected.
+        If partial is False, an error is raised if this is not possible.
+        Otherwise, generated edges form a partial augmentation, which
+        k-edge-connects any part of G where it is possible, and maximally
+        connects the remaining parts.
+
+    Raises
+    ------
+    NetworkXUnfeasible
+        If partial is False and no k-edge-augmentation exists.
+
+    NetworkXNotImplemented
+        If the input graph is directed or a multigraph.
+
+    ValueError:
+        If k is less than 1
+
+    Notes
+    -----
+    When k=1 this returns an optimal solution.
+
+    When k=2 and ``avail`` is None, this returns an optimal solution.
+    Otherwise when k=2, this returns a 2-approximation of the optimal solution.
+
+    For k>3, this problem is NP-hard and this uses a randomized algorithm that
+        produces a feasible solution, but provides no guarantees on the
+        solution weight.
+
+    Examples
+    --------
+    >>> # Unweighted cases
+    >>> G = nx.path_graph((1, 2, 3, 4))
+    >>> G.add_node(5)
+    >>> sorted(nx.k_edge_augmentation(G, k=1))
+    [(1, 5)]
+    >>> sorted(nx.k_edge_augmentation(G, k=2))
+    [(1, 5), (5, 4)]
+    >>> sorted(nx.k_edge_augmentation(G, k=3))
+    [(1, 4), (1, 5), (2, 5), (3, 5), (4, 5)]
+    >>> complement = list(nx.k_edge_augmentation(G, k=5, partial=True))
+    >>> G.add_edges_from(complement)
+    >>> nx.edge_connectivity(G)
+    4
+
+    >>> # Weighted cases
+    >>> G = nx.path_graph((1, 2, 3, 4))
+    >>> G.add_node(5)
+    >>> # avail can be a tuple with a dict
+    >>> avail = [(1, 5, {"weight": 11}), (2, 5, {"weight": 10})]
+    >>> sorted(nx.k_edge_augmentation(G, k=1, avail=avail, weight="weight"))
+    [(2, 5)]
+    >>> # or avail can be a 3-tuple with a real number
+    >>> avail = [(1, 5, 11), (2, 5, 10), (4, 3, 1), (4, 5, 51)]
+    >>> sorted(nx.k_edge_augmentation(G, k=2, avail=avail))
+    [(1, 5), (2, 5), (4, 5)]
+    >>> # or avail can be a dict
+    >>> avail = {(1, 5): 11, (2, 5): 10, (4, 3): 1, (4, 5): 51}
+    >>> sorted(nx.k_edge_augmentation(G, k=2, avail=avail))
+    [(1, 5), (2, 5), (4, 5)]
+    >>> # If augmentation is infeasible, then a partial solution can be found
+    >>> avail = {(1, 5): 11}
+    >>> sorted(nx.k_edge_augmentation(G, k=2, avail=avail, partial=True))
+    [(1, 5)]
+    """
+    try:
+        if k <= 0:
+            raise ValueError(f"k must be a positive integer, not {k}")
+        elif G.number_of_nodes() < k + 1:
+            msg = f"impossible to {k} connect in graph with less than {k + 1} nodes"
+            raise nx.NetworkXUnfeasible(msg)
+        elif avail is not None and len(avail) == 0:
+            if not nx.is_k_edge_connected(G, k):
+                raise nx.NetworkXUnfeasible("no available edges")
+            aug_edges = []
+        elif k == 1:
+            aug_edges = one_edge_augmentation(
+                G, avail=avail, weight=weight, partial=partial
+            )
+        elif k == 2:
+            aug_edges = bridge_augmentation(G, avail=avail, weight=weight)
+        else:
+            # raise NotImplementedError(f'not implemented for k>2. k={k}')
+            aug_edges = greedy_k_edge_augmentation(
+                G, k=k, avail=avail, weight=weight, seed=0
+            )
+        # Do eager evaulation so we can catch any exceptions
+        # Before executing partial code.
+        yield from list(aug_edges)
+    except nx.NetworkXUnfeasible:
+        if partial:
+            # Return all available edges
+            if avail is None:
+                aug_edges = complement_edges(G)
+            else:
+                # If we can't k-edge-connect the entire graph, try to
+                # k-edge-connect as much as possible
+                aug_edges = partial_k_edge_augmentation(
+                    G, k=k, avail=avail, weight=weight
+                )
+            yield from aug_edges
+        else:
+            raise
+
+
+def partial_k_edge_augmentation(G, k, avail, weight=None):
+    """Finds augmentation that k-edge-connects as much of the graph as possible.
+
+    When a k-edge-augmentation is not possible, we can still try to find a
+    small set of edges that partially k-edge-connects as much of the graph as
+    possible. All possible edges are generated between remaining parts.
+    This minimizes the number of k-edge-connected subgraphs in the resulting
+    graph and maxmizes the edge connectivity between those subgraphs.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    k : integer
+        Desired edge connectivity
+
+    avail : dict or a set of 2 or 3 tuples
+        For more details, see :func:`k_edge_augmentation`.
+
+    weight : string
+        key to use to find weights if ``avail`` is a set of 3-tuples.
+        For more details, see :func:`k_edge_augmentation`.
+
+    Yields
+    ------
+    edge : tuple
+        Edges in the partial augmentation of G. These edges k-edge-connect any
+        part of G where it is possible, and maximally connects the remaining
+        parts. In other words, all edges from avail are generated except for
+        those within subgraphs that have already become k-edge-connected.
+
+    Notes
+    -----
+    Construct H that augments G with all edges in avail.
+    Find the k-edge-subgraphs of H.
+    For each k-edge-subgraph, if the number of nodes is more than k, then find
+    the k-edge-augmentation of that graph and add it to the solution. Then add
+    all edges in avail between k-edge subgraphs to the solution.
+
+    See Also
+    --------
+    :func:`k_edge_augmentation`
+
+    Examples
+    --------
+    >>> G = nx.path_graph((1, 2, 3, 4, 5, 6, 7))
+    >>> G.add_node(8)
+    >>> avail = [(1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (3, 5), (1, 8)]
+    >>> sorted(partial_k_edge_augmentation(G, k=2, avail=avail))
+    [(1, 5), (1, 8)]
+    """
+
+    def _edges_between_disjoint(H, only1, only2):
+        """finds edges between disjoint nodes"""
+        only1_adj = {u: set(H.adj[u]) for u in only1}
+        for u, neighbs in only1_adj.items():
+            # Find the neighbors of u in only1 that are also in only2
+            neighbs12 = neighbs.intersection(only2)
+            for v in neighbs12:
+                yield (u, v)
+
+    avail_uv, avail_w = _unpack_available_edges(avail, weight=weight, G=G)
+
+    # Find which parts of the graph can be k-edge-connected
+    H = G.copy()
+    H.add_edges_from(
+        (
+            (u, v, {"weight": w, "generator": (u, v)})
+            for (u, v), w in zip(avail, avail_w)
+        )
+    )
+    k_edge_subgraphs = list(nx.k_edge_subgraphs(H, k=k))
+
+    # Generate edges to k-edge-connect internal subgraphs
+    for nodes in k_edge_subgraphs:
+        if len(nodes) > 1:
+            # Get the k-edge-connected subgraph
+            C = H.subgraph(nodes).copy()
+            # Find the internal edges that were available
+            sub_avail = {
+                d["generator"]: d["weight"]
+                for (u, v, d) in C.edges(data=True)
+                if "generator" in d
+            }
+            # Remove potential augmenting edges
+            C.remove_edges_from(sub_avail.keys())
+            # Find a subset of these edges that makes the compoment
+            # k-edge-connected and ignore the rest
+            yield from nx.k_edge_augmentation(C, k=k, avail=sub_avail)
+
+    # Generate all edges between CCs that could not be k-edge-connected
+    for cc1, cc2 in it.combinations(k_edge_subgraphs, 2):
+        for (u, v) in _edges_between_disjoint(H, cc1, cc2):
+            d = H.get_edge_data(u, v)
+            edge = d.get("generator", None)
+            if edge is not None:
+                yield edge
+
+
+@not_implemented_for("multigraph")
+@not_implemented_for("directed")
+def one_edge_augmentation(G, avail=None, weight=None, partial=False):
+    """Finds minimum weight set of edges to connect G.
+
+    Equivalent to :func:`k_edge_augmentation` when k=1. Adding the resulting
+    edges to G will make it 1-edge-connected. The solution is optimal for both
+    weighted and non-weighted variants.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    avail : dict or a set of 2 or 3 tuples
+        For more details, see :func:`k_edge_augmentation`.
+
+    weight : string
+        key to use to find weights if ``avail`` is a set of 3-tuples.
+        For more details, see :func:`k_edge_augmentation`.
+
+    partial : boolean
+        If partial is True and no feasible k-edge-augmentation exists, then the
+        augmenting edges minimize the number of connected components.
+
+    Yields
+    ------
+    edge : tuple
+        Edges in the one-augmentation of G
+
+    Raises
+    ------
+    NetworkXUnfeasible
+        If partial is False and no one-edge-augmentation exists.
+
+    Notes
+    -----
+    Uses either :func:`unconstrained_one_edge_augmentation` or
+    :func:`weighted_one_edge_augmentation` depending on whether ``avail`` is
+    specified. Both algorithms are based on finding a minimum spanning tree.
+    As such both algorithms find optimal solutions and run in linear time.
+
+    See Also
+    --------
+    :func:`k_edge_augmentation`
+    """
+    if avail is None:
+        return unconstrained_one_edge_augmentation(G)
+    else:
+        return weighted_one_edge_augmentation(
+            G, avail=avail, weight=weight, partial=partial
+        )
+
+
+@not_implemented_for("multigraph")
+@not_implemented_for("directed")
+def bridge_augmentation(G, avail=None, weight=None):
+    """Finds the a set of edges that bridge connects G.
+
+    Equivalent to :func:`k_edge_augmentation` when k=2, and partial=False.
+    Adding the resulting edges to G will make it 2-edge-connected.  If no
+    constraints are specified the returned set of edges is minimum an optimal,
+    otherwise the solution is approximated.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    avail : dict or a set of 2 or 3 tuples
+        For more details, see :func:`k_edge_augmentation`.
+
+    weight : string
+        key to use to find weights if ``avail`` is a set of 3-tuples.
+        For more details, see :func:`k_edge_augmentation`.
+
+    Yields
+    ------
+    edge : tuple
+        Edges in the bridge-augmentation of G
+
+    Raises
+    ------
+    NetworkXUnfeasible
+        If no bridge-augmentation exists.
+
+    Notes
+    -----
+    If there are no constraints the solution can be computed in linear time
+    using :func:`unconstrained_bridge_augmentation`. Otherwise, the problem
+    becomes NP-hard and is the solution is approximated by
+    :func:`weighted_bridge_augmentation`.
+
+    See Also
+    --------
+    :func:`k_edge_augmentation`
+    """
+    if G.number_of_nodes() < 3:
+        raise nx.NetworkXUnfeasible("impossible to bridge connect less than 3 nodes")
+    if avail is None:
+        return unconstrained_bridge_augmentation(G)
+    else:
+        return weighted_bridge_augmentation(G, avail, weight=weight)
+
+
+# --- Algorithms and Helpers ---
+
+
+def _ordered(u, v):
+    """Returns the nodes in an undirected edge in lower-triangular order"""
+    return (u, v) if u < v else (v, u)
+
+
+def _unpack_available_edges(avail, weight=None, G=None):
+    """Helper to separate avail into edges and corresponding weights"""
+    if weight is None:
+        weight = "weight"
+    if isinstance(avail, dict):
+        avail_uv = list(avail.keys())
+        avail_w = list(avail.values())
+    else:
+
+        def _try_getitem(d):
+            try:
+                return d[weight]
+            except TypeError:
+                return d
+
+        avail_uv = [tup[0:2] for tup in avail]
+        avail_w = [1 if len(tup) == 2 else _try_getitem(tup[-1]) for tup in avail]
+
+    if G is not None:
+        # Edges already in the graph are filtered
+        flags = [not G.has_edge(u, v) for u, v in avail_uv]
+        avail_uv = list(it.compress(avail_uv, flags))
+        avail_w = list(it.compress(avail_w, flags))
+    return avail_uv, avail_w
+
+
+MetaEdge = namedtuple("MetaEdge", ("meta_uv", "uv", "w"))
+
+
+def _lightest_meta_edges(mapping, avail_uv, avail_w):
+    """Maps available edges in the original graph to edges in the metagraph.
+
+    Parameters
+    ----------
+    mapping : dict
+        mapping produced by :func:`collapse`, that maps each node in the
+        original graph to a node in the meta graph
+
+    avail_uv : list
+        list of edges
+
+    avail_w : list
+        list of edge weights
+
+    Notes
+    -----
+    Each node in the metagraph is a k-edge-connected component in the original
+    graph.  We don't care about any edge within the same k-edge-connected
+    component, so we ignore self edges.  We also are only intereseted in the
+    minimum weight edge bridging each k-edge-connected component so, we group
+    the edges by meta-edge and take the lightest in each group.
+
+    Examples
+    --------
+    >>> # Each group represents a meta-node
+    >>> groups = ([1, 2, 3], [4, 5], [6])
+    >>> mapping = {n: meta_n for meta_n, ns in enumerate(groups) for n in ns}
+    >>> avail_uv = [(1, 2), (3, 6), (1, 4), (5, 2), (6, 1), (2, 6), (3, 1)]
+    >>> avail_w = [20, 99, 20, 15, 50, 99, 20]
+    >>> sorted(_lightest_meta_edges(mapping, avail_uv, avail_w))
+    [MetaEdge(meta_uv=(0, 1), uv=(5, 2), w=15), MetaEdge(meta_uv=(0, 2), uv=(6, 1), w=50)]
+    """
+    grouped_wuv = defaultdict(list)
+    for w, (u, v) in zip(avail_w, avail_uv):
+        # Order the meta-edge so it can be used as a dict key
+        meta_uv = _ordered(mapping[u], mapping[v])
+        # Group each available edge using the meta-edge as a key
+        grouped_wuv[meta_uv].append((w, u, v))
+
+    # Now that all available edges are grouped, choose one per group
+    for (mu, mv), choices_wuv in grouped_wuv.items():
+        # Ignore available edges within the same meta-node
+        if mu != mv:
+            # Choose the lightest available edge belonging to each meta-edge
+            w, u, v = min(choices_wuv)
+            yield MetaEdge((mu, mv), (u, v), w)
+
+
+def unconstrained_one_edge_augmentation(G):
+    """Finds the smallest set of edges to connect G.
+
+    This is a variant of the unweighted MST problem.
+    If G is not empty, a feasible solution always exists.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    Yields
+    ------
+    edge : tuple
+        Edges in the one-edge-augmentation of G
+
+    See Also
+    --------
+    :func:`one_edge_augmentation`
+    :func:`k_edge_augmentation`
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (2, 3), (4, 5)])
+    >>> G.add_nodes_from([6, 7, 8])
+    >>> sorted(unconstrained_one_edge_augmentation(G))
+    [(1, 4), (4, 6), (6, 7), (7, 8)]
+    """
+    ccs1 = list(nx.connected_components(G))
+    C = collapse(G, ccs1)
+    # When we are not constrained, we can just make a meta graph tree.
+    meta_nodes = list(C.nodes())
+    # build a path in the metagraph
+    meta_aug = list(zip(meta_nodes, meta_nodes[1:]))
+    # map that path to the original graph
+    inverse = defaultdict(list)
+    for k, v in C.graph["mapping"].items():
+        inverse[v].append(k)
+    for mu, mv in meta_aug:
+        yield (inverse[mu][0], inverse[mv][0])
+
+
+def weighted_one_edge_augmentation(G, avail, weight=None, partial=False):
+    """Finds the minimum weight set of edges to connect G if one exists.
+
+    This is a variant of the weighted MST problem.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    avail : dict or a set of 2 or 3 tuples
+        For more details, see :func:`k_edge_augmentation`.
+
+    weight : string
+        key to use to find weights if ``avail`` is a set of 3-tuples.
+        For more details, see :func:`k_edge_augmentation`.
+
+    partial : boolean
+        If partial is True and no feasible k-edge-augmentation exists, then the
+        augmenting edges minimize the number of connected components.
+
+    Yields
+    ------
+    edge : tuple
+        Edges in the subset of avail chosen to connect G.
+
+    See Also
+    --------
+    :func:`one_edge_augmentation`
+    :func:`k_edge_augmentation`
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (2, 3), (4, 5)])
+    >>> G.add_nodes_from([6, 7, 8])
+    >>> # any edge not in avail has an implicit weight of infinity
+    >>> avail = [(1, 3), (1, 5), (4, 7), (4, 8), (6, 1), (8, 1), (8, 2)]
+    >>> sorted(weighted_one_edge_augmentation(G, avail))
+    [(1, 5), (4, 7), (6, 1), (8, 1)]
+    >>> # find another solution by giving large weights to edges in the
+    >>> # previous solution (note some of the old edges must be used)
+    >>> avail = [(1, 3), (1, 5, 99), (4, 7, 9), (6, 1, 99), (8, 1, 99), (8, 2)]
+    >>> sorted(weighted_one_edge_augmentation(G, avail))
+    [(1, 5), (4, 7), (6, 1), (8, 2)]
+    """
+    avail_uv, avail_w = _unpack_available_edges(avail, weight=weight, G=G)
+    # Collapse CCs in the original graph into nodes in a metagraph
+    # Then find an MST of the metagraph instead of the original graph
+    C = collapse(G, nx.connected_components(G))
+    mapping = C.graph["mapping"]
+    # Assign each available edge to an edge in the metagraph
+    candidate_mapping = _lightest_meta_edges(mapping, avail_uv, avail_w)
+    # nx.set_edge_attributes(C, name='weight', values=0)
+    C.add_edges_from(
+        (mu, mv, {"weight": w, "generator": uv})
+        for (mu, mv), uv, w in candidate_mapping
+    )
+    # Find MST of the meta graph
+    meta_mst = nx.minimum_spanning_tree(C)
+    if not partial and not nx.is_connected(meta_mst):
+        raise nx.NetworkXUnfeasible("Not possible to connect G with available edges")
+    # Yield the edge that generated the meta-edge
+    for mu, mv, d in meta_mst.edges(data=True):
+        if "generator" in d:
+            edge = d["generator"]
+            yield edge
+
+
+def unconstrained_bridge_augmentation(G):
+    """Finds an optimal 2-edge-augmentation of G using the fewest edges.
+
+    This is an implementation of the algorithm detailed in [1]_.
+    The basic idea is to construct a meta-graph of bridge-ccs, connect leaf
+    nodes of the trees to connect the entire graph, and finally connect the
+    leafs of the tree in dfs-preorder to bridge connect the entire graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    Yields
+    ------
+    edge : tuple
+        Edges in the bridge augmentation of G
+
+    Notes
+    -----
+    Input: a graph G.
+    First find the bridge components of G and collapse each bridge-cc into a
+    node of a metagraph graph C, which is guaranteed to be a forest of trees.
+
+    C contains p "leafs" --- nodes with exactly one incident edge.
+    C contains q "isolated nodes" --- nodes with no incident edges.
+
+    Theorem: If p + q > 1, then at least :math:`ceil(p / 2) + q` edges are
+        needed to bridge connect C. This algorithm achieves this min number.
+
+    The method first adds enough edges to make G into a tree and then pairs
+    leafs in a simple fashion.
+
+    Let n be the number of trees in C. Let v(i) be an isolated vertex in the
+    i-th tree if one exists, otherwise it is a pair of distinct leafs nodes
+    in the i-th tree. Alternating edges from these sets (i.e.  adding edges
+    A1 = [(v(i)[0], v(i + 1)[1]), v(i + 1)[0], v(i + 2)[1])...]) connects C
+    into a tree T. This tree has p' = p + 2q - 2(n -1) leafs and no isolated
+    vertices. A1 has n - 1 edges. The next step finds ceil(p' / 2) edges to
+    biconnect any tree with p' leafs.
+
+    Convert T into an arborescence T' by picking an arbitrary root node with
+    degree >= 2 and directing all edges away from the root. Note the
+    implementation implicitly constructs T'.
+
+    The leafs of T are the nodes with no existing edges in T'.
+    Order the leafs of T' by DFS prorder. Then break this list in half
+    and add the zipped pairs to A2.
+
+    The set A = A1 + A2 is the minimum augmentation in the metagraph.
+
+    To convert this to edges in the original graph
+
+    References
+    ----------
+    .. [1] Eswaran, Kapali P., and R. Endre Tarjan. (1975) Augmentation problems.
+        http://epubs.siam.org/doi/abs/10.1137/0205044
+
+    See Also
+    --------
+    :func:`bridge_augmentation`
+    :func:`k_edge_augmentation`
+
+    Examples
+    --------
+    >>> G = nx.path_graph((1, 2, 3, 4, 5, 6, 7))
+    >>> sorted(unconstrained_bridge_augmentation(G))
+    [(1, 7)]
+    >>> G = nx.path_graph((1, 2, 3, 2, 4, 5, 6, 7))
+    >>> sorted(unconstrained_bridge_augmentation(G))
+    [(1, 3), (3, 7)]
+    >>> G = nx.Graph([(0, 1), (0, 2), (1, 2)])
+    >>> G.add_node(4)
+    >>> sorted(unconstrained_bridge_augmentation(G))
+    [(1, 4), (4, 0)]
+    """
+    # -----
+    # Mapping of terms from (Eswaran and Tarjan):
+    #     G = G_0 - the input graph
+    #     C = G_0' - the bridge condensation of G. (This is a forest of trees)
+    #     A1 = A_1 - the edges to connect the forest into a tree
+    #         leaf = pendant - a node with degree of 1
+
+    #     alpha(v) = maps the node v in G to its meta-node in C
+    #     beta(x) = maps the meta-node x in C to any node in the bridge
+    #         component of G corresponding to x.
+
+    # find the 2-edge-connected components of G
+    bridge_ccs = list(nx.connectivity.bridge_components(G))
+    # condense G into an forest C
+    C = collapse(G, bridge_ccs)
+
+    # Choose pairs of distinct leaf nodes in each tree. If this is not
+    # possible then make a pair using the single isolated node in the tree.
+    vset1 = [
+        tuple(cc) * 2  # case1: an isolated node
+        if len(cc) == 1
+        else sorted(cc, key=C.degree)[0:2]  # case2: pair of leaf nodes
+        for cc in nx.connected_components(C)
+    ]
+    if len(vset1) > 1:
+        # Use this set to construct edges that connect C into a tree.
+        nodes1 = [vs[0] for vs in vset1]
+        nodes2 = [vs[1] for vs in vset1]
+        A1 = list(zip(nodes1[1:], nodes2))
+    else:
+        A1 = []
+    # Connect each tree in the forest to construct an arborescence
+    T = C.copy()
+    T.add_edges_from(A1)
+
+    # If there are only two leaf nodes, we simply connect them.
+    leafs = [n for n, d in T.degree() if d == 1]
+    if len(leafs) == 1:
+        A2 = []
+    if len(leafs) == 2:
+        A2 = [tuple(leafs)]
+    else:
+        # Choose an arbitrary non-leaf root
+        try:
+            root = next(n for n, d in T.degree() if d > 1)
+        except StopIteration:  # no nodes found with degree > 1
+            return
+        # order the leaves of C by (induced directed) preorder
+        v2 = [n for n in nx.dfs_preorder_nodes(T, root) if T.degree(n) == 1]
+        # connecting first half of the leafs in pre-order to the second
+        # half will bridge connect the tree with the fewest edges.
+        half = math.ceil(len(v2) / 2)
+        A2 = list(zip(v2[:half], v2[-half:]))
+
+    # collect the edges used to augment the original forest
+    aug_tree_edges = A1 + A2
+
+    # Construct the mapping (beta) from meta-nodes to regular nodes
+    inverse = defaultdict(list)
+    for k, v in C.graph["mapping"].items():
+        inverse[v].append(k)
+    # sort so we choose minimum degree nodes first
+    inverse = {
+        mu: sorted(mapped, key=lambda u: (G.degree(u), u))
+        for mu, mapped in inverse.items()
+    }
+
+    # For each meta-edge, map back to an arbitrary pair in the original graph
+    G2 = G.copy()
+    for mu, mv in aug_tree_edges:
+        # Find the first available edge that doesn't exist and return it
+        for u, v in it.product(inverse[mu], inverse[mv]):
+            if not G2.has_edge(u, v):
+                G2.add_edge(u, v)
+                yield u, v
+                break
+
+
+def weighted_bridge_augmentation(G, avail, weight=None):
+    """Finds an approximate min-weight 2-edge-augmentation of G.
+
+    This is an implementation of the approximation algorithm detailed in [1]_.
+    It chooses a set of edges from avail to add to G that renders it
+    2-edge-connected if such a subset exists.  This is done by finding a
+    minimum spanning arborescence of a specially constructed metagraph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    avail : set of 2 or 3 tuples.
+        candidate edges (with optional weights) to choose from
+
+    weight : string
+        key to use to find weights if avail is a set of 3-tuples where the
+        third item in each tuple is a dictionary.
+
+    Yields
+    ------
+    edge : tuple
+        Edges in the subset of avail chosen to bridge augment G.
+
+    Notes
+    -----
+    Finding a weighted 2-edge-augmentation is NP-hard.
+    Any edge not in ``avail`` is considered to have a weight of infinity.
+    The approximation factor is 2 if ``G`` is connected and 3 if it is not.
+    Runs in :math:`O(m + n log(n))` time
+
+    References
+    ----------
+    .. [1] Khuller, Samir, and Ramakrishna Thurimella. (1993) Approximation
+        algorithms for graph augmentation.
+        http://www.sciencedirect.com/science/article/pii/S0196677483710102
+
+    See Also
+    --------
+    :func:`bridge_augmentation`
+    :func:`k_edge_augmentation`
+
+    Examples
+    --------
+    >>> G = nx.path_graph((1, 2, 3, 4))
+    >>> # When the weights are equal, (1, 4) is the best
+    >>> avail = [(1, 4, 1), (1, 3, 1), (2, 4, 1)]
+    >>> sorted(weighted_bridge_augmentation(G, avail))
+    [(1, 4)]
+    >>> # Giving (1, 4) a high weight makes the two edge solution the best.
+    >>> avail = [(1, 4, 1000), (1, 3, 1), (2, 4, 1)]
+    >>> sorted(weighted_bridge_augmentation(G, avail))
+    [(1, 3), (2, 4)]
+    >>> # ------
+    >>> G = nx.path_graph((1, 2, 3, 4))
+    >>> G.add_node(5)
+    >>> avail = [(1, 5, 11), (2, 5, 10), (4, 3, 1), (4, 5, 1)]
+    >>> sorted(weighted_bridge_augmentation(G, avail=avail))
+    [(1, 5), (4, 5)]
+    >>> avail = [(1, 5, 11), (2, 5, 10), (4, 3, 1), (4, 5, 51)]
+    >>> sorted(weighted_bridge_augmentation(G, avail=avail))
+    [(1, 5), (2, 5), (4, 5)]
+    """
+
+    if weight is None:
+        weight = "weight"
+
+    # If input G is not connected the approximation factor increases to 3
+    if not nx.is_connected(G):
+        H = G.copy()
+        connectors = list(one_edge_augmentation(H, avail=avail, weight=weight))
+        H.add_edges_from(connectors)
+
+        yield from connectors
+    else:
+        connectors = []
+        H = G
+
+    if len(avail) == 0:
+        if nx.has_bridges(H):
+            raise nx.NetworkXUnfeasible("no augmentation possible")
+
+    avail_uv, avail_w = _unpack_available_edges(avail, weight=weight, G=H)
+
+    # Collapse input into a metagraph. Meta nodes are bridge-ccs
+    bridge_ccs = nx.connectivity.bridge_components(H)
+    C = collapse(H, bridge_ccs)
+
+    # Use the meta graph to shrink avail to a small feasible subset
+    mapping = C.graph["mapping"]
+    # Choose the minimum weight feasible edge in each group
+    meta_to_wuv = {
+        (mu, mv): (w, uv)
+        for (mu, mv), uv, w in _lightest_meta_edges(mapping, avail_uv, avail_w)
+    }
+
+    # Mapping of terms from (Khuller and Thurimella):
+    #     C         : G_0 = (V, E^0)
+    #        This is the metagraph where each node is a 2-edge-cc in G.
+    #        The edges in C represent bridges in the original graph.
+    #     (mu, mv)  : E - E^0  # they group both avail and given edges in E
+    #     T         : \Gamma
+    #     D         : G^D = (V, E_D)
+
+    #     The paper uses ancestor because children point to parents, which is
+    #     contrary to networkx standards.  So, we actually need to run
+    #     nx.least_common_ancestor on the reversed Tree.
+
+    # Pick an arbitrary leaf from C as the root
+    try:
+        root = next(n for n, d in C.degree() if d == 1)
+    except StopIteration:  # no nodes found with degree == 1
+        return
+    # Root C into a tree TR by directing all edges away from the root
+    # Note in their paper T directs edges towards the root
+    TR = nx.dfs_tree(C, root)
+
+    # Add to D the directed edges of T and set their weight to zero
+    # This indicates that it costs nothing to use edges that were given.
+    D = nx.reverse(TR).copy()
+
+    nx.set_edge_attributes(D, name="weight", values=0)
+
+    # The LCA of mu and mv in T is the shared ancestor of mu and mv that is
+    # located farthest from the root.
+    lca_gen = nx.tree_all_pairs_lowest_common_ancestor(
+        TR, root=root, pairs=meta_to_wuv.keys()
+    )
+
+    for (mu, mv), lca in lca_gen:
+        w, uv = meta_to_wuv[(mu, mv)]
+        if lca == mu:
+            # If u is an ancestor of v in TR, then add edge u->v to D
+            D.add_edge(lca, mv, weight=w, generator=uv)
+        elif lca == mv:
+            # If v is an ancestor of u in TR, then add edge v->u to D
+            D.add_edge(lca, mu, weight=w, generator=uv)
+        else:
+            # If neither u nor v is a ancestor of the other in TR
+            # let t = lca(TR, u, v) and add edges t->u and t->v
+            # Track the original edge that GENERATED these edges.
+            D.add_edge(lca, mu, weight=w, generator=uv)
+            D.add_edge(lca, mv, weight=w, generator=uv)
+
+    # Then compute a minimum rooted branching
+    try:
+        # Note the original edges must be directed towards to root for the
+        # branching to give us a bridge-augmentation.
+        A = _minimum_rooted_branching(D, root)
+    except nx.NetworkXException as err:
+        # If there is no branching then augmentation is not possible
+        raise nx.NetworkXUnfeasible("no 2-edge-augmentation possible") from err
+
+    # For each edge e, in the branching that did not belong to the directed
+    # tree T, add the corresponding edge that **GENERATED** it (this is not
+    # necesarilly e itself!)
+
+    # ensure the third case does not generate edges twice
+    bridge_connectors = set()
+    for mu, mv in A.edges():
+        data = D.get_edge_data(mu, mv)
+        if "generator" in data:
+            # Add the avail edge that generated the branching edge.
+            edge = data["generator"]
+            bridge_connectors.add(edge)
+
+    yield from bridge_connectors
+
+
+def _minimum_rooted_branching(D, root):
+    """Helper function to compute a minimum rooted branching (aka rooted
+    arborescence)
+
+    Before the branching can be computed, the directed graph must be rooted by
+    removing the predecessors of root.
+
+    A branching / arborescence of rooted graph G is a subgraph that contains a
+    directed path from the root to every other vertex. It is the directed
+    analog of the minimum spanning tree problem.
+
+    References
+    ----------
+    [1] Khuller, Samir (2002) Advanced Algorithms Lecture 24 Notes.
+    https://web.archive.org/web/20121030033722/https://www.cs.umd.edu/class/spring2011/cmsc651/lec07.pdf
+    """
+    rooted = D.copy()
+    # root the graph by removing all predecessors to `root`.
+    rooted.remove_edges_from([(u, root) for u in D.predecessors(root)])
+    # Then compute the branching / arborescence.
+    A = nx.minimum_spanning_arborescence(rooted)
+    return A
+
+
+def collapse(G, grouped_nodes):
+    """Collapses each group of nodes into a single node.
+
+    This is similar to condensation, but works on undirected graphs.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+
+    grouped_nodes:  list or generator
+       Grouping of nodes to collapse. The grouping must be disjoint.
+       If grouped_nodes are strongly_connected_components then this is
+       equivalent to :func:`condensation`.
+
+    Returns
+    -------
+    C : NetworkX Graph
+       The collapsed graph C of G with respect to the node grouping.  The node
+       labels are integers corresponding to the index of the component in the
+       list of grouped_nodes.  C has a graph attribute named 'mapping' with a
+       dictionary mapping the original nodes to the nodes in C to which they
+       belong.  Each node in C also has a node attribute 'members' with the set
+       of original nodes in G that form the group that the node in C
+       represents.
+
+    Examples
+    --------
+    >>> # Collapses a graph using disjoint groups, but not necesarilly connected
+    >>> G = nx.Graph([(1, 0), (2, 3), (3, 1), (3, 4), (4, 5), (5, 6), (5, 7)])
+    >>> G.add_node("A")
+    >>> grouped_nodes = [{0, 1, 2, 3}, {5, 6, 7}]
+    >>> C = collapse(G, grouped_nodes)
+    >>> members = nx.get_node_attributes(C, "members")
+    >>> sorted(members.keys())
+    [0, 1, 2, 3]
+    >>> member_values = set(map(frozenset, members.values()))
+    >>> assert {0, 1, 2, 3} in member_values
+    >>> assert {4} in member_values
+    >>> assert {5, 6, 7} in member_values
+    >>> assert {"A"} in member_values
+    """
+    mapping = {}
+    members = {}
+    C = G.__class__()
+    i = 0  # required if G is empty
+    remaining = set(G.nodes())
+    for i, group in enumerate(grouped_nodes):
+        group = set(group)
+        assert remaining.issuperset(
+            group
+        ), "grouped nodes must exist in G and be disjoint"
+        remaining.difference_update(group)
+        members[i] = group
+        mapping.update((n, i) for n in group)
+    # remaining nodes are in their own group
+    for i, node in enumerate(remaining, start=i + 1):
+        group = {node}
+        members[i] = group
+        mapping.update((n, i) for n in group)
+    number_of_groups = i + 1
+    C.add_nodes_from(range(number_of_groups))
+    C.add_edges_from(
+        (mapping[u], mapping[v]) for u, v in G.edges() if mapping[u] != mapping[v]
+    )
+    # Add a list of members (ie original nodes) to each node (ie scc) in C.
+    nx.set_node_attributes(C, name="members", values=members)
+    # Add mapping dict as graph attribute
+    C.graph["mapping"] = mapping
+    return C
+
+
+def complement_edges(G):
+    """Returns only the edges in the complement of G
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+
+    Yields
+    ------
+    edge : tuple
+        Edges in the complement of G
+
+    Examples
+    --------
+    >>> G = nx.path_graph((1, 2, 3, 4))
+    >>> sorted(complement_edges(G))
+    [(1, 3), (1, 4), (2, 4)]
+    >>> G = nx.path_graph((1, 2, 3, 4), nx.DiGraph())
+    >>> sorted(complement_edges(G))
+    [(1, 3), (1, 4), (2, 1), (2, 4), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3)]
+    >>> G = nx.complete_graph(1000)
+    >>> sorted(complement_edges(G))
+    []
+    """
+    G_adj = G._adj  # Store as a variable to eliminate attribute lookup
+    if G.is_directed():
+        for u, v in it.combinations(G.nodes(), 2):
+            if v not in G_adj[u]:
+                yield (u, v)
+            if u not in G_adj[v]:
+                yield (v, u)
+    else:
+        for u, v in it.combinations(G.nodes(), 2):
+            if v not in G_adj[u]:
+                yield (u, v)
+
+
+def _compat_shuffle(rng, input):
+    """wrapper around rng.shuffle for python 2 compatibility reasons"""
+    rng.shuffle(input)
+
+
+@py_random_state(4)
+@not_implemented_for("multigraph")
+@not_implemented_for("directed")
+def greedy_k_edge_augmentation(G, k, avail=None, weight=None, seed=None):
+    """Greedy algorithm for finding a k-edge-augmentation
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph.
+
+    k : integer
+        Desired edge connectivity
+
+    avail : dict or a set of 2 or 3 tuples
+        For more details, see :func:`k_edge_augmentation`.
+
+    weight : string
+        key to use to find weights if ``avail`` is a set of 3-tuples.
+        For more details, see :func:`k_edge_augmentation`.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Yields
+    ------
+    edge : tuple
+        Edges in the greedy augmentation of G
+
+    Notes
+    -----
+    The algorithm is simple. Edges are incrementally added between parts of the
+    graph that are not yet locally k-edge-connected. Then edges are from the
+    augmenting set are pruned as long as local-edge-connectivity is not broken.
+
+    This algorithm is greedy and does not provide optimality guarantees. It
+    exists only to provide :func:`k_edge_augmentation` with the ability to
+    generate a feasible solution for arbitrary k.
+
+    See Also
+    --------
+    :func:`k_edge_augmentation`
+
+    Examples
+    --------
+    >>> G = nx.path_graph((1, 2, 3, 4, 5, 6, 7))
+    >>> sorted(greedy_k_edge_augmentation(G, k=2))
+    [(1, 7)]
+    >>> sorted(greedy_k_edge_augmentation(G, k=1, avail=[]))
+    []
+    >>> G = nx.path_graph((1, 2, 3, 4, 5, 6, 7))
+    >>> avail = {(u, v): 1 for (u, v) in complement_edges(G)}
+    >>> # randomized pruning process can produce different solutions
+    >>> sorted(greedy_k_edge_augmentation(G, k=4, avail=avail, seed=2))
+    [(1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 4), (2, 6), (3, 7), (5, 7)]
+    >>> sorted(greedy_k_edge_augmentation(G, k=4, avail=avail, seed=3))
+    [(1, 3), (1, 5), (1, 6), (2, 4), (2, 6), (3, 7), (4, 7), (5, 7)]
+    """
+    # Result set
+    aug_edges = []
+
+    done = is_k_edge_connected(G, k)
+    if done:
+        return
+    if avail is None:
+        # all edges are available
+        avail_uv = list(complement_edges(G))
+        avail_w = [1] * len(avail_uv)
+    else:
+        # Get the unique set of unweighted edges
+        avail_uv, avail_w = _unpack_available_edges(avail, weight=weight, G=G)
+
+    # Greedy: order lightest edges. Use degree sum to tie-break
+    tiebreaker = [sum(map(G.degree, uv)) for uv in avail_uv]
+    avail_wduv = sorted(zip(avail_w, tiebreaker, avail_uv))
+    avail_uv = [uv for w, d, uv in avail_wduv]
+
+    # Incrementally add edges in until we are k-connected
+    H = G.copy()
+    for (u, v) in avail_uv:
+        done = False
+        if not is_locally_k_edge_connected(H, u, v, k=k):
+            # Only add edges in parts that are not yet locally k-edge-connected
+            aug_edges.append((u, v))
+            H.add_edge(u, v)
+            # Did adding this edge help?
+            if H.degree(u) >= k and H.degree(v) >= k:
+                done = is_k_edge_connected(H, k)
+        if done:
+            break
+
+    # Check for feasibility
+    if not done:
+        raise nx.NetworkXUnfeasible("not able to k-edge-connect with available edges")
+
+    # Randomized attempt to reduce the size of the solution
+    _compat_shuffle(seed, aug_edges)
+    for (u, v) in list(aug_edges):
+        # Don't remove if we know it would break connectivity
+        if H.degree(u) <= k or H.degree(v) <= k:
+            continue
+        H.remove_edge(u, v)
+        aug_edges.remove((u, v))
+        if not is_k_edge_connected(H, k=k):
+            # If removing this edge breaks feasibility, undo
+            H.add_edge(u, v)
+            aug_edges.append((u, v))
+
+    # Generate results
+    yield from aug_edges
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/edge_kcomponents.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/edge_kcomponents.py
new file mode 100644
index 0000000..a5d6977
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/edge_kcomponents.py
@@ -0,0 +1,581 @@
+"""
+Algorithms for finding k-edge-connected components and subgraphs.
+
+A k-edge-connected component (k-edge-cc) is a maximal set of nodes in G, such
+that all pairs of node have an edge-connectivity of at least k.
+
+A k-edge-connected subgraph (k-edge-subgraph) is a maximal set of nodes in G,
+such that the subgraph of G defined by the nodes has an edge-connectivity at
+least k.
+"""
+import itertools as it
+from functools import partial
+
+import networkx as nx
+from networkx.algorithms import bridges
+from networkx.utils import arbitrary_element, not_implemented_for
+
+__all__ = [
+    "k_edge_components",
+    "k_edge_subgraphs",
+    "bridge_components",
+    "EdgeComponentAuxGraph",
+]
+
+
+@not_implemented_for("multigraph")
+def k_edge_components(G, k):
+    """Generates nodes in each maximal k-edge-connected component in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    k : Integer
+        Desired edge connectivity
+
+    Returns
+    -------
+    k_edge_components : a generator of k-edge-ccs. Each set of returned nodes
+       will have k-edge-connectivity in the graph G.
+
+    See Also
+    --------
+    :func:`local_edge_connectivity`
+    :func:`k_edge_subgraphs` : similar to this function, but the subgraph
+        defined by the nodes must also have k-edge-connectivity.
+    :func:`k_components` : similar to this function, but uses node-connectivity
+        instead of edge-connectivity
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is a multigraph.
+
+    ValueError:
+        If k is less than 1
+
+    Notes
+    -----
+    Attempts to use the most efficient implementation available based on k.
+    If k=1, this is simply connected components for directed graphs and
+    connected components for undirected graphs.
+    If k=2 on an efficient bridge connected component algorithm from _[1] is
+    run based on the chain decomposition.
+    Otherwise, the algorithm from _[2] is used.
+
+    Examples
+    --------
+    >>> import itertools as it
+    >>> from networkx.utils import pairwise
+    >>> paths = [
+    ...     (1, 2, 4, 3, 1, 4),
+    ...     (5, 6, 7, 8, 5, 7, 8, 6),
+    ... ]
+    >>> G = nx.Graph()
+    >>> G.add_nodes_from(it.chain(*paths))
+    >>> G.add_edges_from(it.chain(*[pairwise(path) for path in paths]))
+    >>> # note this returns {1, 4} unlike k_edge_subgraphs
+    >>> sorted(map(sorted, nx.k_edge_components(G, k=3)))
+    [[1, 4], [2], [3], [5, 6, 7, 8]]
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Bridge_%28graph_theory%29
+    .. [2] Wang, Tianhao, et al. (2015) A simple algorithm for finding all
+        k-edge-connected components.
+        http://journals.plos.org/plosone/article?id=10.1371/journal.pone.0136264
+    """
+    # Compute k-edge-ccs using the most efficient algorithms available.
+    if k < 1:
+        raise ValueError("k cannot be less than 1")
+    if G.is_directed():
+        if k == 1:
+            return nx.strongly_connected_components(G)
+        else:
+            # TODO: investigate https://arxiv.org/abs/1412.6466 for k=2
+            aux_graph = EdgeComponentAuxGraph.construct(G)
+            return aux_graph.k_edge_components(k)
+    else:
+        if k == 1:
+            return nx.connected_components(G)
+        elif k == 2:
+            return bridge_components(G)
+        else:
+            aux_graph = EdgeComponentAuxGraph.construct(G)
+            return aux_graph.k_edge_components(k)
+
+
+@not_implemented_for("multigraph")
+def k_edge_subgraphs(G, k):
+    """Generates nodes in each maximal k-edge-connected subgraph in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    k : Integer
+        Desired edge connectivity
+
+    Returns
+    -------
+    k_edge_subgraphs : a generator of k-edge-subgraphs
+        Each k-edge-subgraph is a maximal set of nodes that defines a subgraph
+        of G that is k-edge-connected.
+
+    See Also
+    --------
+    :func:`edge_connectivity`
+    :func:`k_edge_components` : similar to this function, but nodes only
+        need to have k-edge-connctivity within the graph G and the subgraphs
+        might not be k-edge-connected.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is a multigraph.
+
+    ValueError:
+        If k is less than 1
+
+    Notes
+    -----
+    Attempts to use the most efficient implementation available based on k.
+    If k=1, or k=2 and the graph is undirected, then this simply calls
+    `k_edge_components`.  Otherwise the algorithm from _[1] is used.
+
+    Examples
+    --------
+    >>> import itertools as it
+    >>> from networkx.utils import pairwise
+    >>> paths = [
+    ...     (1, 2, 4, 3, 1, 4),
+    ...     (5, 6, 7, 8, 5, 7, 8, 6),
+    ... ]
+    >>> G = nx.Graph()
+    >>> G.add_nodes_from(it.chain(*paths))
+    >>> G.add_edges_from(it.chain(*[pairwise(path) for path in paths]))
+    >>> # note this does not return {1, 4} unlike k_edge_components
+    >>> sorted(map(sorted, nx.k_edge_subgraphs(G, k=3)))
+    [[1], [2], [3], [4], [5, 6, 7, 8]]
+
+    References
+    ----------
+    .. [1] Zhou, Liu, et al. (2012) Finding maximal k-edge-connected subgraphs
+        from a large graph.  ACM International Conference on Extending Database
+        Technology 2012 480-–491.
+        https://openproceedings.org/2012/conf/edbt/ZhouLYLCL12.pdf
+    """
+    if k < 1:
+        raise ValueError("k cannot be less than 1")
+    if G.is_directed():
+        if k <= 1:
+            # For directed graphs ,
+            # When k == 1, k-edge-ccs and k-edge-subgraphs are the same
+            return k_edge_components(G, k)
+        else:
+            return _k_edge_subgraphs_nodes(G, k)
+    else:
+        if k <= 2:
+            # For undirected graphs,
+            # when k <= 2, k-edge-ccs and k-edge-subgraphs are the same
+            return k_edge_components(G, k)
+        else:
+            return _k_edge_subgraphs_nodes(G, k)
+
+
+def _k_edge_subgraphs_nodes(G, k):
+    """Helper to get the nodes from the subgraphs.
+
+    This allows k_edge_subgraphs to return a generator.
+    """
+    for C in general_k_edge_subgraphs(G, k):
+        yield set(C.nodes())
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def bridge_components(G):
+    """Finds all bridge-connected components G.
+
+    Parameters
+    ----------
+    G : NetworkX undirected graph
+
+    Returns
+    -------
+    bridge_components : a generator of 2-edge-connected components
+
+
+    See Also
+    --------
+    :func:`k_edge_subgraphs` : this function is a special case for an
+        undirected graph where k=2.
+    :func:`biconnected_components` : similar to this function, but is defined
+        using 2-node-connectivity instead of 2-edge-connectivity.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is directed or a multigraph.
+
+    Notes
+    -----
+    Bridge-connected components are also known as 2-edge-connected components.
+
+    Examples
+    --------
+    >>> # The barbell graph with parameter zero has a single bridge
+    >>> G = nx.barbell_graph(5, 0)
+    >>> from networkx.algorithms.connectivity.edge_kcomponents import bridge_components
+    >>> sorted(map(sorted, bridge_components(G)))
+    [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
+    """
+    H = G.copy()
+    H.remove_edges_from(bridges(G))
+    yield from nx.connected_components(H)
+
+
+class EdgeComponentAuxGraph:
+    r"""A simple algorithm to find all k-edge-connected components in a graph.
+
+    Constructing the AuxillaryGraph (which may take some time) allows for the
+    k-edge-ccs to be found in linear time for arbitrary k.
+
+    Notes
+    -----
+    This implementation is based on [1]_. The idea is to construct an auxiliary
+    graph from which the k-edge-ccs can be extracted in linear time. The
+    auxiliary graph is constructed in $O(|V|\cdot F)$ operations, where F is the
+    complexity of max flow. Querying the components takes an additional $O(|V|)$
+    operations. This algorithm can be slow for large graphs, but it handles an
+    arbitrary k and works for both directed and undirected inputs.
+
+    The undirected case for k=1 is exactly connected components.
+    The undirected case for k=2 is exactly bridge connected components.
+    The directed case for k=1 is exactly strongly connected components.
+
+    References
+    ----------
+    .. [1] Wang, Tianhao, et al. (2015) A simple algorithm for finding all
+        k-edge-connected components.
+        http://journals.plos.org/plosone/article?id=10.1371/journal.pone.0136264
+
+    Examples
+    --------
+    >>> import itertools as it
+    >>> from networkx.utils import pairwise
+    >>> from networkx.algorithms.connectivity import EdgeComponentAuxGraph
+    >>> # Build an interesting graph with multiple levels of k-edge-ccs
+    >>> paths = [
+    ...     (1, 2, 3, 4, 1, 3, 4, 2),  # a 3-edge-cc (a 4 clique)
+    ...     (5, 6, 7, 5),  # a 2-edge-cc (a 3 clique)
+    ...     (1, 5),  # combine first two ccs into a 1-edge-cc
+    ...     (0,),  # add an additional disconnected 1-edge-cc
+    ... ]
+    >>> G = nx.Graph()
+    >>> G.add_nodes_from(it.chain(*paths))
+    >>> G.add_edges_from(it.chain(*[pairwise(path) for path in paths]))
+    >>> # Constructing the AuxGraph takes about O(n ** 4)
+    >>> aux_graph = EdgeComponentAuxGraph.construct(G)
+    >>> # Once constructed, querying takes O(n)
+    >>> sorted(map(sorted, aux_graph.k_edge_components(k=1)))
+    [[0], [1, 2, 3, 4, 5, 6, 7]]
+    >>> sorted(map(sorted, aux_graph.k_edge_components(k=2)))
+    [[0], [1, 2, 3, 4], [5, 6, 7]]
+    >>> sorted(map(sorted, aux_graph.k_edge_components(k=3)))
+    [[0], [1, 2, 3, 4], [5], [6], [7]]
+    >>> sorted(map(sorted, aux_graph.k_edge_components(k=4)))
+    [[0], [1], [2], [3], [4], [5], [6], [7]]
+
+    The auxiliary graph is primarilly used for k-edge-ccs but it
+    can also speed up the queries of k-edge-subgraphs by refining the
+    search space.
+
+    >>> import itertools as it
+    >>> from networkx.utils import pairwise
+    >>> from networkx.algorithms.connectivity import EdgeComponentAuxGraph
+    >>> paths = [
+    ...     (1, 2, 4, 3, 1, 4),
+    ... ]
+    >>> G = nx.Graph()
+    >>> G.add_nodes_from(it.chain(*paths))
+    >>> G.add_edges_from(it.chain(*[pairwise(path) for path in paths]))
+    >>> aux_graph = EdgeComponentAuxGraph.construct(G)
+    >>> sorted(map(sorted, aux_graph.k_edge_subgraphs(k=3)))
+    [[1], [2], [3], [4]]
+    >>> sorted(map(sorted, aux_graph.k_edge_components(k=3)))
+    [[1, 4], [2], [3]]
+    """
+
+    # @not_implemented_for('multigraph')  # TODO: fix decor for classmethods
+    @classmethod
+    def construct(EdgeComponentAuxGraph, G):
+        """Builds an auxiliary graph encoding edge-connectivity between nodes.
+
+        Notes
+        -----
+        Given G=(V, E), initialize an empty auxiliary graph A.
+        Choose an arbitrary source node s.  Initialize a set N of available
+        nodes (that can be used as the sink). The algorithm picks an
+        arbitrary node t from N - {s}, and then computes the minimum st-cut
+        (S, T) with value w. If G is directed the minimum of the st-cut or
+        the ts-cut is used instead. Then, the edge (s, t) is added to the
+        auxiliary graph with weight w. The algorithm is called recursively
+        first using S as the available nodes and s as the source, and then
+        using T and t. Recursion stops when the source is the only available
+        node.
+
+        Parameters
+        ----------
+        G : NetworkX graph
+        """
+        # workaround for classmethod decorator
+        not_implemented_for("multigraph")(lambda G: G)(G)
+
+        def _recursive_build(H, A, source, avail):
+            # Terminate once the flow has been compute to every node.
+            if {source} == avail:
+                return
+            # pick an arbitrary node as the sink
+            sink = arbitrary_element(avail - {source})
+            # find the minimum cut and its weight
+            value, (S, T) = nx.minimum_cut(H, source, sink)
+            if H.is_directed():
+                # check if the reverse direction has a smaller cut
+                value_, (T_, S_) = nx.minimum_cut(H, sink, source)
+                if value_ < value:
+                    value, S, T = value_, S_, T_
+            # add edge with weight of cut to the aux graph
+            A.add_edge(source, sink, weight=value)
+            # recursively call until all but one node is used
+            _recursive_build(H, A, source, avail.intersection(S))
+            _recursive_build(H, A, sink, avail.intersection(T))
+
+        # Copy input to ensure all edges have unit capacity
+        H = G.__class__()
+        H.add_nodes_from(G.nodes())
+        H.add_edges_from(G.edges(), capacity=1)
+
+        # A is the auxiliary graph to be constructed
+        # It is a weighted undirected tree
+        A = nx.Graph()
+
+        # Pick an arbitrary node as the source
+        if H.number_of_nodes() > 0:
+            source = arbitrary_element(H.nodes())
+            # Initialize a set of elements that can be chosen as the sink
+            avail = set(H.nodes())
+
+            # This constructs A
+            _recursive_build(H, A, source, avail)
+
+        # This class is a container the holds the auxiliary graph A and
+        # provides access the k_edge_components function.
+        self = EdgeComponentAuxGraph()
+        self.A = A
+        self.H = H
+        return self
+
+    def k_edge_components(self, k):
+        """Queries the auxiliary graph for k-edge-connected components.
+
+        Parameters
+        ----------
+        k : Integer
+            Desired edge connectivity
+
+        Returns
+        -------
+        k_edge_components : a generator of k-edge-ccs
+
+        Notes
+        -----
+        Given the auxiliary graph, the k-edge-connected components can be
+        determined in linear time by removing all edges with weights less than
+        k from the auxiliary graph.  The resulting connected components are the
+        k-edge-ccs in the original graph.
+        """
+        if k < 1:
+            raise ValueError("k cannot be less than 1")
+        A = self.A
+        # "traverse the auxiliary graph A and delete all edges with weights less
+        # than k"
+        aux_weights = nx.get_edge_attributes(A, "weight")
+        # Create a relevant graph with the auxiliary edges with weights >= k
+        R = nx.Graph()
+        R.add_nodes_from(A.nodes())
+        R.add_edges_from(e for e, w in aux_weights.items() if w >= k)
+
+        # Return the nodes that are k-edge-connected in the original graph
+        yield from nx.connected_components(R)
+
+    def k_edge_subgraphs(self, k):
+        """Queries the auxiliary graph for k-edge-connected subgraphs.
+
+        Parameters
+        ----------
+        k : Integer
+            Desired edge connectivity
+
+        Returns
+        -------
+        k_edge_subgraphs : a generator of k-edge-subgraphs
+
+        Notes
+        -----
+        Refines the k-edge-ccs into k-edge-subgraphs. The running time is more
+        than $O(|V|)$.
+
+        For single values of k it is faster to use `nx.k_edge_subgraphs`.
+        But for multiple values of k, it can be faster to build AuxGraph and
+        then use this method.
+        """
+        if k < 1:
+            raise ValueError("k cannot be less than 1")
+        H = self.H
+        A = self.A
+        # "traverse the auxiliary graph A and delete all edges with weights less
+        # than k"
+        aux_weights = nx.get_edge_attributes(A, "weight")
+        # Create a relevant graph with the auxiliary edges with weights >= k
+        R = nx.Graph()
+        R.add_nodes_from(A.nodes())
+        R.add_edges_from(e for e, w in aux_weights.items() if w >= k)
+
+        # Return the components whose subgraphs are k-edge-connected
+        for cc in nx.connected_components(R):
+            if len(cc) < k:
+                # Early return optimization
+                for node in cc:
+                    yield {node}
+            else:
+                # Call subgraph solution to refine the results
+                C = H.subgraph(cc)
+                yield from k_edge_subgraphs(C, k)
+
+
+def _low_degree_nodes(G, k, nbunch=None):
+    """Helper for finding nodes with degree less than k."""
+    # Nodes with degree less than k cannot be k-edge-connected.
+    if G.is_directed():
+        # Consider both in and out degree in the directed case
+        seen = set()
+        for node, degree in G.out_degree(nbunch):
+            if degree < k:
+                seen.add(node)
+                yield node
+        for node, degree in G.in_degree(nbunch):
+            if node not in seen and degree < k:
+                seen.add(node)
+                yield node
+    else:
+        # Only the degree matters in the undirected case
+        for node, degree in G.degree(nbunch):
+            if degree < k:
+                yield node
+
+
+def _high_degree_components(G, k):
+    """Helper for filtering components that can't be k-edge-connected.
+
+    Removes and generates each node with degree less than k.  Then generates
+    remaining components where all nodes have degree at least k.
+    """
+    # Iteravely remove parts of the graph that are not k-edge-connected
+    H = G.copy()
+    singletons = set(_low_degree_nodes(H, k))
+    while singletons:
+        # Only search neighbors of removed nodes
+        nbunch = set(it.chain.from_iterable(map(H.neighbors, singletons)))
+        nbunch.difference_update(singletons)
+        H.remove_nodes_from(singletons)
+        for node in singletons:
+            yield {node}
+        singletons = set(_low_degree_nodes(H, k, nbunch))
+
+    # Note: remaining connected components may not be k-edge-connected
+    if G.is_directed():
+        yield from nx.strongly_connected_components(H)
+    else:
+        yield from nx.connected_components(H)
+
+
+def general_k_edge_subgraphs(G, k):
+    """General algorithm to find all maximal k-edge-connected subgraphs in G.
+
+    Returns
+    -------
+    k_edge_subgraphs : a generator of nx.Graphs that are k-edge-subgraphs
+        Each k-edge-subgraph is a maximal set of nodes that defines a subgraph
+        of G that is k-edge-connected.
+
+    Notes
+    -----
+    Implementation of the basic algorithm from _[1].  The basic idea is to find
+    a global minimum cut of the graph. If the cut value is at least k, then the
+    graph is a k-edge-connected subgraph and can be added to the results.
+    Otherwise, the cut is used to split the graph in two and the procedure is
+    applied recursively. If the graph is just a single node, then it is also
+    added to the results. At the end, each result is either guaranteed to be
+    a single node or a subgraph of G that is k-edge-connected.
+
+    This implementation contains optimizations for reducing the number of calls
+    to max-flow, but there are other optimizations in _[1] that could be
+    implemented.
+
+    References
+    ----------
+    .. [1] Zhou, Liu, et al. (2012) Finding maximal k-edge-connected subgraphs
+        from a large graph.  ACM International Conference on Extending Database
+        Technology 2012 480-–491.
+        https://openproceedings.org/2012/conf/edbt/ZhouLYLCL12.pdf
+
+    Examples
+    --------
+    >>> from networkx.utils import pairwise
+    >>> paths = [
+    ...     (11, 12, 13, 14, 11, 13, 14, 12),  # a 4-clique
+    ...     (21, 22, 23, 24, 21, 23, 24, 22),  # another 4-clique
+    ...     # connect the cliques with high degree but low connectivity
+    ...     (50, 13),
+    ...     (12, 50, 22),
+    ...     (13, 102, 23),
+    ...     (14, 101, 24),
+    ... ]
+    >>> G = nx.Graph(it.chain(*[pairwise(path) for path in paths]))
+    >>> sorted(map(len, k_edge_subgraphs(G, k=3)))
+    [1, 1, 1, 4, 4]
+    """
+    if k < 1:
+        raise ValueError("k cannot be less than 1")
+
+    # Node pruning optimization (incorporates early return)
+    # find_ccs is either connected_components/strongly_connected_components
+    find_ccs = partial(_high_degree_components, k=k)
+
+    # Quick return optimization
+    if G.number_of_nodes() < k:
+        for node in G.nodes():
+            yield G.subgraph([node]).copy()
+        return
+
+    # Intermediate results
+    R0 = {G.subgraph(cc).copy() for cc in find_ccs(G)}
+    # Subdivide CCs in the intermediate results until they are k-conn
+    while R0:
+        G1 = R0.pop()
+        if G1.number_of_nodes() == 1:
+            yield G1
+        else:
+            # Find a global minimum cut
+            cut_edges = nx.minimum_edge_cut(G1)
+            cut_value = len(cut_edges)
+            if cut_value < k:
+                # G1 is not k-edge-connected, so subdivide it
+                G1.remove_edges_from(cut_edges)
+                for cc in find_ccs(G1):
+                    R0.add(G1.subgraph(cc).copy())
+            else:
+                # Otherwise we found a k-edge-connected subgraph
+                yield G1
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/kcomponents.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/kcomponents.py
new file mode 100644
index 0000000..4e88d32
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/kcomponents.py
@@ -0,0 +1,224 @@
+"""
+Moody and White algorithm for k-components
+"""
+from collections import defaultdict
+from itertools import combinations
+from operator import itemgetter
+
+import networkx as nx
+
+# Define the default maximum flow function.
+from networkx.algorithms.flow import edmonds_karp
+from networkx.utils import not_implemented_for
+
+default_flow_func = edmonds_karp
+
+__all__ = ["k_components"]
+
+
+@not_implemented_for("directed")
+def k_components(G, flow_func=None):
+    r"""Returns the k-component structure of a graph G.
+
+    A `k`-component is a maximal subgraph of a graph G that has, at least,
+    node connectivity `k`: we need to remove at least `k` nodes to break it
+    into more components. `k`-components have an inherent hierarchical
+    structure because they are nested in terms of connectivity: a connected
+    graph can contain several 2-components, each of which can contain
+    one or more 3-components, and so forth.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    flow_func : function
+        Function to perform the underlying flow computations. Default value
+        :meth:`edmonds_karp`. This function performs better in sparse graphs with
+        right tailed degree distributions. :meth:`shortest_augmenting_path` will
+        perform better in denser graphs.
+
+    Returns
+    -------
+    k_components : dict
+        Dictionary with all connectivity levels `k` in the input Graph as keys
+        and a list of sets of nodes that form a k-component of level `k` as
+        values.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the input graph is directed.
+
+    Examples
+    --------
+    >>> # Petersen graph has 10 nodes and it is triconnected, thus all
+    >>> # nodes are in a single component on all three connectivity levels
+    >>> G = nx.petersen_graph()
+    >>> k_components = nx.k_components(G)
+
+    Notes
+    -----
+    Moody and White [1]_ (appendix A) provide an algorithm for identifying
+    k-components in a graph, which is based on Kanevsky's algorithm [2]_
+    for finding all minimum-size node cut-sets of a graph (implemented in
+    :meth:`all_node_cuts` function):
+
+        1. Compute node connectivity, k, of the input graph G.
+
+        2. Identify all k-cutsets at the current level of connectivity using
+           Kanevsky's algorithm.
+
+        3. Generate new graph components based on the removal of
+           these cutsets. Nodes in a cutset belong to both sides
+           of the induced cut.
+
+        4. If the graph is neither complete nor trivial, return to 1;
+           else end.
+
+    This implementation also uses some heuristics (see [3]_ for details)
+    to speed up the computation.
+
+    See also
+    --------
+    node_connectivity
+    all_node_cuts
+    biconnected_components : special case of this function when k=2
+    k_edge_components : similar to this function, but uses edge-connectivity
+        instead of node-connectivity
+
+    References
+    ----------
+    .. [1]  Moody, J. and D. White (2003). Social cohesion and embeddedness:
+            A hierarchical conception of social groups.
+            American Sociological Review 68(1), 103--28.
+            http://www2.asanet.org/journals/ASRFeb03MoodyWhite.pdf
+
+    .. [2]  Kanevsky, A. (1993). Finding all minimum-size separating vertex
+            sets in a graph. Networks 23(6), 533--541.
+            http://onlinelibrary.wiley.com/doi/10.1002/net.3230230604/abstract
+
+    .. [3]  Torrents, J. and F. Ferraro (2015). Structural Cohesion:
+            Visualization and Heuristics for Fast Computation.
+            https://arxiv.org/pdf/1503.04476v1
+
+    """
+    # Dictionary with connectivity level (k) as keys and a list of
+    # sets of nodes that form a k-component as values. Note that
+    # k-compoents can overlap (but only k - 1 nodes).
+    k_components = defaultdict(list)
+    # Define default flow function
+    if flow_func is None:
+        flow_func = default_flow_func
+    # Bicomponents as a base to check for higher order k-components
+    for component in nx.connected_components(G):
+        # isolated nodes have connectivity 0
+        comp = set(component)
+        if len(comp) > 1:
+            k_components[1].append(comp)
+    bicomponents = [G.subgraph(c) for c in nx.biconnected_components(G)]
+    for bicomponent in bicomponents:
+        bicomp = set(bicomponent)
+        # avoid considering dyads as bicomponents
+        if len(bicomp) > 2:
+            k_components[2].append(bicomp)
+    for B in bicomponents:
+        if len(B) <= 2:
+            continue
+        k = nx.node_connectivity(B, flow_func=flow_func)
+        if k > 2:
+            k_components[k].append(set(B))
+        # Perform cuts in a DFS like order.
+        cuts = list(nx.all_node_cuts(B, k=k, flow_func=flow_func))
+        stack = [(k, _generate_partition(B, cuts, k))]
+        while stack:
+            (parent_k, partition) = stack[-1]
+            try:
+                nodes = next(partition)
+                C = B.subgraph(nodes)
+                this_k = nx.node_connectivity(C, flow_func=flow_func)
+                if this_k > parent_k and this_k > 2:
+                    k_components[this_k].append(set(C))
+                cuts = list(nx.all_node_cuts(C, k=this_k, flow_func=flow_func))
+                if cuts:
+                    stack.append((this_k, _generate_partition(C, cuts, this_k)))
+            except StopIteration:
+                stack.pop()
+
+    # This is necessary because k-components may only be reported at their
+    # maximum k level. But we want to return a dictionary in which keys are
+    # connectivity levels and values list of sets of components, without
+    # skipping any connectivity level. Also, it's possible that subsets of
+    # an already detected k-component appear at a level k. Checking for this
+    # in the while loop above penalizes the common case. Thus we also have to
+    # _consolidate all connectivity levels in _reconstruct_k_components.
+    return _reconstruct_k_components(k_components)
+
+
+def _consolidate(sets, k):
+    """Merge sets that share k or more elements.
+
+    See: http://rosettacode.org/wiki/Set_consolidation
+
+    The iterative python implementation posted there is
+    faster than this because of the overhead of building a
+    Graph and calling nx.connected_components, but it's not
+    clear for us if we can use it in NetworkX because there
+    is no licence for the code.
+
+    """
+    G = nx.Graph()
+    nodes = {i: s for i, s in enumerate(sets)}
+    G.add_nodes_from(nodes)
+    G.add_edges_from(
+        (u, v) for u, v in combinations(nodes, 2) if len(nodes[u] & nodes[v]) >= k
+    )
+    for component in nx.connected_components(G):
+        yield set.union(*[nodes[n] for n in component])
+
+
+def _generate_partition(G, cuts, k):
+    def has_nbrs_in_partition(G, node, partition):
+        for n in G[node]:
+            if n in partition:
+                return True
+        return False
+
+    components = []
+    nodes = {n for n, d in G.degree() if d > k} - {n for cut in cuts for n in cut}
+    H = G.subgraph(nodes)
+    for cc in nx.connected_components(H):
+        component = set(cc)
+        for cut in cuts:
+            for node in cut:
+                if has_nbrs_in_partition(G, node, cc):
+                    component.add(node)
+        if len(component) < G.order():
+            components.append(component)
+    yield from _consolidate(components, k + 1)
+
+
+def _reconstruct_k_components(k_comps):
+    result = dict()
+    max_k = max(k_comps)
+    for k in reversed(range(1, max_k + 1)):
+        if k == max_k:
+            result[k] = list(_consolidate(k_comps[k], k))
+        elif k not in k_comps:
+            result[k] = list(_consolidate(result[k + 1], k))
+        else:
+            nodes_at_k = set.union(*k_comps[k])
+            to_add = [c for c in result[k + 1] if any(n not in nodes_at_k for n in c)]
+            if to_add:
+                result[k] = list(_consolidate(k_comps[k] + to_add, k))
+            else:
+                result[k] = list(_consolidate(k_comps[k], k))
+    return result
+
+
+def build_k_number_dict(kcomps):
+    result = {}
+    for k, comps in sorted(kcomps.items(), key=itemgetter(0)):
+        for comp in comps:
+            for node in comp:
+                result[node] = k
+    return result
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/kcutsets.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/kcutsets.py
new file mode 100644
index 0000000..c3104c8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/kcutsets.py
@@ -0,0 +1,231 @@
+"""
+Kanevsky all minimum node k cutsets algorithm.
+"""
+import copy
+from collections import defaultdict
+from itertools import combinations
+from operator import itemgetter
+
+import networkx as nx
+from networkx.algorithms.flow import (
+    build_residual_network,
+    edmonds_karp,
+    shortest_augmenting_path,
+)
+
+from .utils import build_auxiliary_node_connectivity
+
+default_flow_func = edmonds_karp
+
+
+__all__ = ["all_node_cuts"]
+
+
+def all_node_cuts(G, k=None, flow_func=None):
+    r"""Returns all minimum k cutsets of an undirected graph G.
+
+    This implementation is based on Kanevsky's algorithm [1]_ for finding all
+    minimum-size node cut-sets of an undirected graph G; ie the set (or sets)
+    of nodes of cardinality equal to the node connectivity of G. Thus if
+    removed, would break G into two or more connected components.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    k : Integer
+        Node connectivity of the input graph. If k is None, then it is
+        computed. Default value: None.
+
+    flow_func : function
+        Function to perform the underlying flow computations. Default value
+        edmonds_karp. This function performs better in sparse graphs with
+        right tailed degree distributions. shortest_augmenting_path will
+        perform better in denser graphs.
+
+
+    Returns
+    -------
+    cuts : a generator of node cutsets
+        Each node cutset has cardinality equal to the node connectivity of
+        the input graph.
+
+    Examples
+    --------
+    >>> # A two-dimensional grid graph has 4 cutsets of cardinality 2
+    >>> G = nx.grid_2d_graph(5, 5)
+    >>> cutsets = list(nx.all_node_cuts(G))
+    >>> len(cutsets)
+    4
+    >>> all(2 == len(cutset) for cutset in cutsets)
+    True
+    >>> nx.node_connectivity(G)
+    2
+
+    Notes
+    -----
+    This implementation is based on the sequential algorithm for finding all
+    minimum-size separating vertex sets in a graph [1]_. The main idea is to
+    compute minimum cuts using local maximum flow computations among a set
+    of nodes of highest degree and all other non-adjacent nodes in the Graph.
+    Once we find a minimum cut, we add an edge between the high degree
+    node and the target node of the local maximum flow computation to make
+    sure that we will not find that minimum cut again.
+
+    See also
+    --------
+    node_connectivity
+    edmonds_karp
+    shortest_augmenting_path
+
+    References
+    ----------
+    .. [1]  Kanevsky, A. (1993). Finding all minimum-size separating vertex
+            sets in a graph. Networks 23(6), 533--541.
+            http://onlinelibrary.wiley.com/doi/10.1002/net.3230230604/abstract
+
+    """
+    if not nx.is_connected(G):
+        raise nx.NetworkXError("Input graph is disconnected.")
+
+    # Address some corner cases first.
+    # For complete Graphs
+    if nx.density(G) == 1:
+        for cut_set in combinations(G, len(G) - 1):
+            yield set(cut_set)
+        return
+    # Initialize data structures.
+    # Keep track of the cuts already computed so we do not repeat them.
+    seen = []
+    # Even-Tarjan reduction is what we call auxiliary digraph
+    # for node connectivity.
+    H = build_auxiliary_node_connectivity(G)
+    H_nodes = H.nodes  # for speed
+    mapping = H.graph["mapping"]
+    # Keep a copy of original predecessors, H will be modified later.
+    # Shallow copy is enough.
+    original_H_pred = copy.copy(H._pred)
+    R = build_residual_network(H, "capacity")
+    kwargs = dict(capacity="capacity", residual=R)
+    # Define default flow function
+    if flow_func is None:
+        flow_func = default_flow_func
+    if flow_func is shortest_augmenting_path:
+        kwargs["two_phase"] = True
+    # Begin the actual algorithm
+    # step 1: Find node connectivity k of G
+    if k is None:
+        k = nx.node_connectivity(G, flow_func=flow_func)
+    # step 2:
+    # Find k nodes with top degree, call it X:
+    X = {n for n, d in sorted(G.degree(), key=itemgetter(1), reverse=True)[:k]}
+    # Check if X is a k-node-cutset
+    if _is_separating_set(G, X):
+        seen.append(X)
+        yield X
+
+    for x in X:
+        # step 3: Compute local connectivity flow of x with all other
+        # non adjacent nodes in G
+        non_adjacent = set(G) - X - set(G[x])
+        for v in non_adjacent:
+            # step 4: compute maximum flow in an Even-Tarjan reduction H of G
+            # and step 5: build the associated residual network R
+            R = flow_func(H, f"{mapping[x]}B", f"{mapping[v]}A", **kwargs)
+            flow_value = R.graph["flow_value"]
+
+            if flow_value == k:
+                # Find the nodes incident to the flow.
+                E1 = flowed_edges = [
+                    (u, w) for (u, w, d) in R.edges(data=True) if d["flow"] != 0
+                ]
+                VE1 = incident_nodes = {n for edge in E1 for n in edge}
+                # Remove saturated edges form the residual network.
+                # Note that reversed edges are introduced with capacity 0
+                # in the residual graph and they need to be removed too.
+                saturated_edges = [
+                    (u, w, d)
+                    for (u, w, d) in R.edges(data=True)
+                    if d["capacity"] == d["flow"] or d["capacity"] == 0
+                ]
+                R.remove_edges_from(saturated_edges)
+                R_closure = nx.transitive_closure(R)
+                # step 6: shrink the strongly connected components of
+                # residual flow network R and call it L.
+                L = nx.condensation(R)
+                cmap = L.graph["mapping"]
+                inv_cmap = defaultdict(list)
+                for n, scc in cmap.items():
+                    inv_cmap[scc].append(n)
+                # Find the incident nodes in the condensed graph.
+                VE1 = {cmap[n] for n in VE1}
+                # step 7: Compute all antichains of L;
+                # they map to closed sets in H.
+                # Any edge in H that links a closed set is part of a cutset.
+                for antichain in nx.antichains(L):
+                    # Only antichains that are subsets of incident nodes counts.
+                    # Lemma 8 in reference.
+                    if not set(antichain).issubset(VE1):
+                        continue
+                    # Nodes in an antichain of the condensation graph of
+                    # the residual network map to a closed set of nodes that
+                    # define a node partition of the auxiliary digraph H
+                    # through taking all of antichain's predecessors in the
+                    # transitive closure.
+                    S = set()
+                    for scc in antichain:
+                        S.update(inv_cmap[scc])
+                    S_ancestors = set()
+                    for n in S:
+                        S_ancestors.update(R_closure._pred[n])
+                    S.update(S_ancestors)
+                    if f"{mapping[x]}B" not in S or f"{mapping[v]}A" in S:
+                        continue
+                    # Find the cutset that links the node partition (S,~S) in H
+                    cutset = set()
+                    for u in S:
+                        cutset.update((u, w) for w in original_H_pred[u] if w not in S)
+                    # The edges in H that form the cutset are internal edges
+                    # (ie edges that represent a node of the original graph G)
+                    if any([H_nodes[u]["id"] != H_nodes[w]["id"] for u, w in cutset]):
+                        continue
+                    node_cut = {H_nodes[u]["id"] for u, _ in cutset}
+
+                    if len(node_cut) == k:
+                        # The cut is invalid if it includes internal edges of
+                        # end nodes. The other half of Lemma 8 in ref.
+                        if x in node_cut or v in node_cut:
+                            continue
+                        if node_cut not in seen:
+                            yield node_cut
+                            seen.append(node_cut)
+
+                # Add an edge (x, v) to make sure that we do not
+                # find this cutset again. This is equivalent
+                # of adding the edge in the input graph
+                # G.add_edge(x, v) and then regenerate H and R:
+                # Add edges to the auxiliary digraph.
+                # See build_residual_network for convention we used
+                # in residual graphs.
+                H.add_edge(f"{mapping[x]}B", f"{mapping[v]}A", capacity=1)
+                H.add_edge(f"{mapping[v]}B", f"{mapping[x]}A", capacity=1)
+                # Add edges to the residual network.
+                R.add_edge(f"{mapping[x]}B", f"{mapping[v]}A", capacity=1)
+                R.add_edge(f"{mapping[v]}A", f"{mapping[x]}B", capacity=0)
+                R.add_edge(f"{mapping[v]}B", f"{mapping[x]}A", capacity=1)
+                R.add_edge(f"{mapping[x]}A", f"{mapping[v]}B", capacity=0)
+
+                # Add again the saturated edges to reuse the residual network
+                R.add_edges_from(saturated_edges)
+
+
+def _is_separating_set(G, cut):
+    """Assumes that the input graph is connected"""
+    if len(cut) == len(G) - 1:
+        return True
+
+    H = nx.restricted_view(G, cut, [])
+    if nx.is_connected(H):
+        return False
+    return True
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/stoerwagner.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/stoerwagner.py
new file mode 100644
index 0000000..7bdb79c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/stoerwagner.py
@@ -0,0 +1,149 @@
+"""
+Stoer-Wagner minimum cut algorithm.
+"""
+from itertools import islice
+
+import networkx as nx
+
+from ...utils import BinaryHeap, arbitrary_element, not_implemented_for
+
+__all__ = ["stoer_wagner"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def stoer_wagner(G, weight="weight", heap=BinaryHeap):
+    r"""Returns the weighted minimum edge cut using the Stoer-Wagner algorithm.
+
+    Determine the minimum edge cut of a connected graph using the
+    Stoer-Wagner algorithm. In weighted cases, all weights must be
+    nonnegative.
+
+    The running time of the algorithm depends on the type of heaps used:
+
+    ============== =============================================
+    Type of heap   Running time
+    ============== =============================================
+    Binary heap    $O(n (m + n) \log n)$
+    Fibonacci heap $O(nm + n^2 \log n)$
+    Pairing heap   $O(2^{2 \sqrt{\log \log n}} nm + n^2 \log n)$
+    ============== =============================================
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Edges of the graph are expected to have an attribute named by the
+        weight parameter below. If this attribute is not present, the edge is
+        considered to have unit weight.
+
+    weight : string
+        Name of the weight attribute of the edges. If the attribute is not
+        present, unit weight is assumed. Default value: 'weight'.
+
+    heap : class
+        Type of heap to be used in the algorithm. It should be a subclass of
+        :class:`MinHeap` or implement a compatible interface.
+
+        If a stock heap implementation is to be used, :class:`BinaryHeap` is
+        recommended over :class:`PairingHeap` for Python implementations without
+        optimized attribute accesses (e.g., CPython) despite a slower
+        asymptotic running time. For Python implementations with optimized
+        attribute accesses (e.g., PyPy), :class:`PairingHeap` provides better
+        performance. Default value: :class:`BinaryHeap`.
+
+    Returns
+    -------
+    cut_value : integer or float
+        The sum of weights of edges in a minimum cut.
+
+    partition : pair of node lists
+        A partitioning of the nodes that defines a minimum cut.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or a multigraph.
+
+    NetworkXError
+        If the graph has less than two nodes, is not connected or has a
+        negative-weighted edge.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_edge("x", "a", weight=3)
+    >>> G.add_edge("x", "b", weight=1)
+    >>> G.add_edge("a", "c", weight=3)
+    >>> G.add_edge("b", "c", weight=5)
+    >>> G.add_edge("b", "d", weight=4)
+    >>> G.add_edge("d", "e", weight=2)
+    >>> G.add_edge("c", "y", weight=2)
+    >>> G.add_edge("e", "y", weight=3)
+    >>> cut_value, partition = nx.stoer_wagner(G)
+    >>> cut_value
+    4
+    """
+    n = len(G)
+    if n < 2:
+        raise nx.NetworkXError("graph has less than two nodes.")
+    if not nx.is_connected(G):
+        raise nx.NetworkXError("graph is not connected.")
+
+    # Make a copy of the graph for internal use.
+    G = nx.Graph(
+        (u, v, {"weight": e.get(weight, 1)}) for u, v, e in G.edges(data=True) if u != v
+    )
+
+    for u, v, e in G.edges(data=True):
+        if e["weight"] < 0:
+            raise nx.NetworkXError("graph has a negative-weighted edge.")
+
+    cut_value = float("inf")
+    nodes = set(G)
+    contractions = []  # contracted node pairs
+
+    # Repeatedly pick a pair of nodes to contract until only one node is left.
+    for i in range(n - 1):
+        # Pick an arbitrary node u and create a set A = {u}.
+        u = arbitrary_element(G)
+        A = {u}
+        # Repeatedly pick the node "most tightly connected" to A and add it to
+        # A. The tightness of connectivity of a node not in A is defined by the
+        # of edges connecting it to nodes in A.
+        h = heap()  # min-heap emulating a max-heap
+        for v, e in G[u].items():
+            h.insert(v, -e["weight"])
+        # Repeat until all but one node has been added to A.
+        for j in range(n - i - 2):
+            u = h.pop()[0]
+            A.add(u)
+            for v, e in G[u].items():
+                if v not in A:
+                    h.insert(v, h.get(v, 0) - e["weight"])
+        # A and the remaining node v define a "cut of the phase". There is a
+        # minimum cut of the original graph that is also a cut of the phase.
+        # Due to contractions in earlier phases, v may in fact represent
+        # multiple nodes in the original graph.
+        v, w = h.min()
+        w = -w
+        if w < cut_value:
+            cut_value = w
+            best_phase = i
+        # Contract v and the last node added to A.
+        contractions.append((u, v))
+        for w, e in G[v].items():
+            if w != u:
+                if w not in G[u]:
+                    G.add_edge(u, w, weight=e["weight"])
+                else:
+                    G[u][w]["weight"] += e["weight"]
+        G.remove_node(v)
+
+    # Recover the optimal partitioning from the contractions.
+    G = nx.Graph(islice(contractions, best_phase))
+    v = contractions[best_phase][1]
+    G.add_node(v)
+    reachable = set(nx.single_source_shortest_path_length(G, v))
+    partition = (list(reachable), list(nodes - reachable))
+
+    return cut_value, partition
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_connectivity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_connectivity.py
new file mode 100644
index 0000000..a13aa07
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_connectivity.py
@@ -0,0 +1,421 @@
+import itertools
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms import flow
+from networkx.algorithms.connectivity import (
+    local_edge_connectivity,
+    local_node_connectivity,
+)
+
+flow_funcs = [
+    flow.boykov_kolmogorov,
+    flow.dinitz,
+    flow.edmonds_karp,
+    flow.preflow_push,
+    flow.shortest_augmenting_path,
+]
+
+
+# helper functions for tests
+
+
+def _generate_no_biconnected(max_attempts=50):
+    attempts = 0
+    while True:
+        G = nx.fast_gnp_random_graph(100, 0.0575, seed=42)
+        if nx.is_connected(G) and not nx.is_biconnected(G):
+            attempts = 0
+            yield G
+        else:
+            if attempts >= max_attempts:
+                msg = f"Tried {max_attempts} times: no suitable Graph."
+                raise Exception(msg)
+            else:
+                attempts += 1
+
+
+def test_average_connectivity():
+    # figure 1 from:
+    # Beineke, L., O. Oellermann, and R. Pippert (2002). The average
+    # connectivity of a graph. Discrete mathematics 252(1-3), 31-45
+    # http://www.sciencedirect.com/science/article/pii/S0012365X01001807
+    G1 = nx.path_graph(3)
+    G1.add_edges_from([(1, 3), (1, 4)])
+    G2 = nx.path_graph(3)
+    G2.add_edges_from([(1, 3), (1, 4), (0, 3), (0, 4), (3, 4)])
+    G3 = nx.Graph()
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert nx.average_node_connectivity(G1, **kwargs) == 1, errmsg
+        assert nx.average_node_connectivity(G2, **kwargs) == 2.2, errmsg
+        assert nx.average_node_connectivity(G3, **kwargs) == 0, errmsg
+
+
+def test_average_connectivity_directed():
+    G = nx.DiGraph([(1, 3), (1, 4), (1, 5)])
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert nx.average_node_connectivity(G) == 0.25, errmsg
+
+
+def test_articulation_points():
+    Ggen = _generate_no_biconnected()
+    for flow_func in flow_funcs:
+        for i in range(3):
+            G = next(Ggen)
+            errmsg = f"Assertion failed in function: {flow_func.__name__}"
+            assert nx.node_connectivity(G, flow_func=flow_func) == 1, errmsg
+
+
+def test_brandes_erlebach():
+    # Figure 1 chapter 7: Connectivity
+    # http://www.informatik.uni-augsburg.de/thi/personen/kammer/Graph_Connectivity.pdf
+    G = nx.Graph()
+    G.add_edges_from(
+        [
+            (1, 2),
+            (1, 3),
+            (1, 4),
+            (1, 5),
+            (2, 3),
+            (2, 6),
+            (3, 4),
+            (3, 6),
+            (4, 6),
+            (4, 7),
+            (5, 7),
+            (6, 8),
+            (6, 9),
+            (7, 8),
+            (7, 10),
+            (8, 11),
+            (9, 10),
+            (9, 11),
+            (10, 11),
+        ]
+    )
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert 3 == local_edge_connectivity(G, 1, 11, **kwargs), errmsg
+        assert 3 == nx.edge_connectivity(G, 1, 11, **kwargs), errmsg
+        assert 2 == local_node_connectivity(G, 1, 11, **kwargs), errmsg
+        assert 2 == nx.node_connectivity(G, 1, 11, **kwargs), errmsg
+        assert 2 == nx.edge_connectivity(G, **kwargs), errmsg
+        assert 2 == nx.node_connectivity(G, **kwargs), errmsg
+        if flow_func is flow.preflow_push:
+            assert 3 == nx.edge_connectivity(G, 1, 11, cutoff=2, **kwargs), errmsg
+        else:
+            assert 2 == nx.edge_connectivity(G, 1, 11, cutoff=2, **kwargs), errmsg
+
+
+def test_white_harary_1():
+    # Figure 1b white and harary (2001)
+    # https://doi.org/10.1111/0081-1750.00098
+    # A graph with high adhesion (edge connectivity) and low cohesion
+    # (vertex connectivity)
+    G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4))
+    G.remove_node(7)
+    for i in range(4, 7):
+        G.add_edge(0, i)
+    G = nx.disjoint_union(G, nx.complete_graph(4))
+    G.remove_node(G.order() - 1)
+    for i in range(7, 10):
+        G.add_edge(0, i)
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert 1 == nx.node_connectivity(G, flow_func=flow_func), errmsg
+        assert 3 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
+
+
+def test_white_harary_2():
+    # Figure 8 white and harary (2001)
+    # https://doi.org/10.1111/0081-1750.00098
+    G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4))
+    G.add_edge(0, 4)
+    # kappa <= lambda <= delta
+    assert 3 == min(nx.core_number(G).values())
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert 1 == nx.node_connectivity(G, flow_func=flow_func), errmsg
+        assert 1 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
+
+
+def test_complete_graphs():
+    for n in range(5, 20, 5):
+        for flow_func in flow_funcs:
+            G = nx.complete_graph(n)
+            errmsg = f"Assertion failed in function: {flow_func.__name__}"
+            assert n - 1 == nx.node_connectivity(G, flow_func=flow_func), errmsg
+            assert n - 1 == nx.node_connectivity(
+                G.to_directed(), flow_func=flow_func
+            ), errmsg
+            assert n - 1 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
+            assert n - 1 == nx.edge_connectivity(
+                G.to_directed(), flow_func=flow_func
+            ), errmsg
+
+
+def test_empty_graphs():
+    for k in range(5, 25, 5):
+        G = nx.empty_graph(k)
+        for flow_func in flow_funcs:
+            errmsg = f"Assertion failed in function: {flow_func.__name__}"
+            assert 0 == nx.node_connectivity(G, flow_func=flow_func), errmsg
+            assert 0 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
+
+
+def test_petersen():
+    G = nx.petersen_graph()
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert 3 == nx.node_connectivity(G, flow_func=flow_func), errmsg
+        assert 3 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
+
+
+def test_tutte():
+    G = nx.tutte_graph()
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert 3 == nx.node_connectivity(G, flow_func=flow_func), errmsg
+        assert 3 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
+
+
+def test_dodecahedral():
+    G = nx.dodecahedral_graph()
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert 3 == nx.node_connectivity(G, flow_func=flow_func), errmsg
+        assert 3 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
+
+
+def test_octahedral():
+    G = nx.octahedral_graph()
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert 4 == nx.node_connectivity(G, flow_func=flow_func), errmsg
+        assert 4 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
+
+
+def test_icosahedral():
+    G = nx.icosahedral_graph()
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert 5 == nx.node_connectivity(G, flow_func=flow_func), errmsg
+        assert 5 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
+
+
+def test_missing_source():
+    G = nx.path_graph(4)
+    for flow_func in flow_funcs:
+        pytest.raises(
+            nx.NetworkXError, nx.node_connectivity, G, 10, 1, flow_func=flow_func
+        )
+
+
+def test_missing_target():
+    G = nx.path_graph(4)
+    for flow_func in flow_funcs:
+        pytest.raises(
+            nx.NetworkXError, nx.node_connectivity, G, 1, 10, flow_func=flow_func
+        )
+
+
+def test_edge_missing_source():
+    G = nx.path_graph(4)
+    for flow_func in flow_funcs:
+        pytest.raises(
+            nx.NetworkXError, nx.edge_connectivity, G, 10, 1, flow_func=flow_func
+        )
+
+
+def test_edge_missing_target():
+    G = nx.path_graph(4)
+    for flow_func in flow_funcs:
+        pytest.raises(
+            nx.NetworkXError, nx.edge_connectivity, G, 1, 10, flow_func=flow_func
+        )
+
+
+def test_not_weakly_connected():
+    G = nx.DiGraph()
+    nx.add_path(G, [1, 2, 3])
+    nx.add_path(G, [4, 5])
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert nx.node_connectivity(G) == 0, errmsg
+        assert nx.edge_connectivity(G) == 0, errmsg
+
+
+def test_not_connected():
+    G = nx.Graph()
+    nx.add_path(G, [1, 2, 3])
+    nx.add_path(G, [4, 5])
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert nx.node_connectivity(G) == 0, errmsg
+        assert nx.edge_connectivity(G) == 0, errmsg
+
+
+def test_directed_edge_connectivity():
+    G = nx.cycle_graph(10, create_using=nx.DiGraph())  # only one direction
+    D = nx.cycle_graph(10).to_directed()  # 2 reciprocal edges
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        assert 1 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
+        assert 1 == local_edge_connectivity(G, 1, 4, flow_func=flow_func), errmsg
+        assert 1 == nx.edge_connectivity(G, 1, 4, flow_func=flow_func), errmsg
+        assert 2 == nx.edge_connectivity(D, flow_func=flow_func), errmsg
+        assert 2 == local_edge_connectivity(D, 1, 4, flow_func=flow_func), errmsg
+        assert 2 == nx.edge_connectivity(D, 1, 4, flow_func=flow_func), errmsg
+
+
+def test_cutoff():
+    G = nx.complete_graph(5)
+    for local_func in [local_edge_connectivity, local_node_connectivity]:
+        for flow_func in flow_funcs:
+            if flow_func is flow.preflow_push:
+                # cutoff is not supported by preflow_push
+                continue
+            for cutoff in [3, 2, 1]:
+                result = local_func(G, 0, 4, flow_func=flow_func, cutoff=cutoff)
+                assert cutoff == result, f"cutoff error in {flow_func.__name__}"
+
+
+def test_invalid_auxiliary():
+    G = nx.complete_graph(5)
+    pytest.raises(nx.NetworkXError, local_node_connectivity, G, 0, 3, auxiliary=G)
+
+
+def test_interface_only_source():
+    G = nx.complete_graph(5)
+    for interface_func in [nx.node_connectivity, nx.edge_connectivity]:
+        pytest.raises(nx.NetworkXError, interface_func, G, s=0)
+
+
+def test_interface_only_target():
+    G = nx.complete_graph(5)
+    for interface_func in [nx.node_connectivity, nx.edge_connectivity]:
+        pytest.raises(nx.NetworkXError, interface_func, G, t=3)
+
+
+def test_edge_connectivity_flow_vs_stoer_wagner():
+    graph_funcs = [nx.icosahedral_graph, nx.octahedral_graph, nx.dodecahedral_graph]
+    for graph_func in graph_funcs:
+        G = graph_func()
+        assert nx.stoer_wagner(G)[0] == nx.edge_connectivity(G)
+
+
+class TestAllPairsNodeConnectivity:
+    @classmethod
+    def setup_class(cls):
+        cls.path = nx.path_graph(7)
+        cls.directed_path = nx.path_graph(7, create_using=nx.DiGraph())
+        cls.cycle = nx.cycle_graph(7)
+        cls.directed_cycle = nx.cycle_graph(7, create_using=nx.DiGraph())
+        cls.gnp = nx.gnp_random_graph(30, 0.1, seed=42)
+        cls.directed_gnp = nx.gnp_random_graph(30, 0.1, directed=True, seed=42)
+        cls.K20 = nx.complete_graph(20)
+        cls.K10 = nx.complete_graph(10)
+        cls.K5 = nx.complete_graph(5)
+        cls.G_list = [
+            cls.path,
+            cls.directed_path,
+            cls.cycle,
+            cls.directed_cycle,
+            cls.gnp,
+            cls.directed_gnp,
+            cls.K10,
+            cls.K5,
+            cls.K20,
+        ]
+
+    def test_cycles(self):
+        K_undir = nx.all_pairs_node_connectivity(self.cycle)
+        for source in K_undir:
+            for target, k in K_undir[source].items():
+                assert k == 2
+        K_dir = nx.all_pairs_node_connectivity(self.directed_cycle)
+        for source in K_dir:
+            for target, k in K_dir[source].items():
+                assert k == 1
+
+    def test_complete(self):
+        for G in [self.K10, self.K5, self.K20]:
+            K = nx.all_pairs_node_connectivity(G)
+            for source in K:
+                for target, k in K[source].items():
+                    assert k == len(G) - 1
+
+    def test_paths(self):
+        K_undir = nx.all_pairs_node_connectivity(self.path)
+        for source in K_undir:
+            for target, k in K_undir[source].items():
+                assert k == 1
+        K_dir = nx.all_pairs_node_connectivity(self.directed_path)
+        for source in K_dir:
+            for target, k in K_dir[source].items():
+                if source < target:
+                    assert k == 1
+                else:
+                    assert k == 0
+
+    def test_all_pairs_connectivity_nbunch(self):
+        G = nx.complete_graph(5)
+        nbunch = [0, 2, 3]
+        C = nx.all_pairs_node_connectivity(G, nbunch=nbunch)
+        assert len(C) == len(nbunch)
+
+    def test_all_pairs_connectivity_icosahedral(self):
+        G = nx.icosahedral_graph()
+        C = nx.all_pairs_node_connectivity(G)
+        assert all(5 == C[u][v] for u, v in itertools.combinations(G, 2))
+
+    def test_all_pairs_connectivity(self):
+        G = nx.Graph()
+        nodes = [0, 1, 2, 3]
+        nx.add_path(G, nodes)
+        A = {n: {} for n in G}
+        for u, v in itertools.combinations(nodes, 2):
+            A[u][v] = A[v][u] = nx.node_connectivity(G, u, v)
+        C = nx.all_pairs_node_connectivity(G)
+        assert sorted((k, sorted(v)) for k, v in A.items()) == sorted(
+            (k, sorted(v)) for k, v in C.items()
+        )
+
+    def test_all_pairs_connectivity_directed(self):
+        G = nx.DiGraph()
+        nodes = [0, 1, 2, 3]
+        nx.add_path(G, nodes)
+        A = {n: {} for n in G}
+        for u, v in itertools.permutations(nodes, 2):
+            A[u][v] = nx.node_connectivity(G, u, v)
+        C = nx.all_pairs_node_connectivity(G)
+        assert sorted((k, sorted(v)) for k, v in A.items()) == sorted(
+            (k, sorted(v)) for k, v in C.items()
+        )
+
+    def test_all_pairs_connectivity_nbunch_combinations(self):
+        G = nx.complete_graph(5)
+        nbunch = [0, 2, 3]
+        A = {n: {} for n in nbunch}
+        for u, v in itertools.combinations(nbunch, 2):
+            A[u][v] = A[v][u] = nx.node_connectivity(G, u, v)
+        C = nx.all_pairs_node_connectivity(G, nbunch=nbunch)
+        assert sorted((k, sorted(v)) for k, v in A.items()) == sorted(
+            (k, sorted(v)) for k, v in C.items()
+        )
+
+    def test_all_pairs_connectivity_nbunch_iter(self):
+        G = nx.complete_graph(5)
+        nbunch = [0, 2, 3]
+        A = {n: {} for n in nbunch}
+        for u, v in itertools.combinations(nbunch, 2):
+            A[u][v] = A[v][u] = nx.node_connectivity(G, u, v)
+        C = nx.all_pairs_node_connectivity(G, nbunch=iter(nbunch))
+        assert sorted((k, sorted(v)) for k, v in A.items()) == sorted(
+            (k, sorted(v)) for k, v in C.items()
+        )
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_cuts.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_cuts.py
new file mode 100644
index 0000000..c4af519
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_cuts.py
@@ -0,0 +1,309 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms import flow
+from networkx.algorithms.connectivity import minimum_st_edge_cut, minimum_st_node_cut
+from networkx.utils import arbitrary_element
+
+flow_funcs = [
+    flow.boykov_kolmogorov,
+    flow.dinitz,
+    flow.edmonds_karp,
+    flow.preflow_push,
+    flow.shortest_augmenting_path,
+]
+
+# Tests for node and edge cutsets
+
+
+def _generate_no_biconnected(max_attempts=50):
+    attempts = 0
+    while True:
+        G = nx.fast_gnp_random_graph(100, 0.0575, seed=42)
+        if nx.is_connected(G) and not nx.is_biconnected(G):
+            attempts = 0
+            yield G
+        else:
+            if attempts >= max_attempts:
+                msg = f"Tried {attempts} times: no suitable Graph."
+                raise Exception(msg)
+            else:
+                attempts += 1
+
+
+def test_articulation_points():
+    Ggen = _generate_no_biconnected()
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        for i in range(1):  # change 1 to 3 or more for more realizations.
+            G = next(Ggen)
+            cut = nx.minimum_node_cut(G, flow_func=flow_func)
+            assert len(cut) == 1, errmsg
+            assert cut.pop() in set(nx.articulation_points(G)), errmsg
+
+
+def test_brandes_erlebach_book():
+    # Figure 1 chapter 7: Connectivity
+    # http://www.informatik.uni-augsburg.de/thi/personen/kammer/Graph_Connectivity.pdf
+    G = nx.Graph()
+    G.add_edges_from(
+        [
+            (1, 2),
+            (1, 3),
+            (1, 4),
+            (1, 5),
+            (2, 3),
+            (2, 6),
+            (3, 4),
+            (3, 6),
+            (4, 6),
+            (4, 7),
+            (5, 7),
+            (6, 8),
+            (6, 9),
+            (7, 8),
+            (7, 10),
+            (8, 11),
+            (9, 10),
+            (9, 11),
+            (10, 11),
+        ]
+    )
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        # edge cutsets
+        assert 3 == len(nx.minimum_edge_cut(G, 1, 11, **kwargs)), errmsg
+        edge_cut = nx.minimum_edge_cut(G, **kwargs)
+        # Node 5 has only two edges
+        assert 2 == len(edge_cut), errmsg
+        H = G.copy()
+        H.remove_edges_from(edge_cut)
+        assert not nx.is_connected(H), errmsg
+        # node cuts
+        assert {6, 7} == minimum_st_node_cut(G, 1, 11, **kwargs), errmsg
+        assert {6, 7} == nx.minimum_node_cut(G, 1, 11, **kwargs), errmsg
+        node_cut = nx.minimum_node_cut(G, **kwargs)
+        assert 2 == len(node_cut), errmsg
+        H = G.copy()
+        H.remove_nodes_from(node_cut)
+        assert not nx.is_connected(H), errmsg
+
+
+def test_white_harary_paper():
+    # Figure 1b white and harary (2001)
+    # https://doi.org/10.1111/0081-1750.00098
+    # A graph with high adhesion (edge connectivity) and low cohesion
+    # (node connectivity)
+    G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4))
+    G.remove_node(7)
+    for i in range(4, 7):
+        G.add_edge(0, i)
+    G = nx.disjoint_union(G, nx.complete_graph(4))
+    G.remove_node(G.order() - 1)
+    for i in range(7, 10):
+        G.add_edge(0, i)
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        # edge cuts
+        edge_cut = nx.minimum_edge_cut(G, **kwargs)
+        assert 3 == len(edge_cut), errmsg
+        H = G.copy()
+        H.remove_edges_from(edge_cut)
+        assert not nx.is_connected(H), errmsg
+        # node cuts
+        node_cut = nx.minimum_node_cut(G, **kwargs)
+        assert {0} == node_cut, errmsg
+        H = G.copy()
+        H.remove_nodes_from(node_cut)
+        assert not nx.is_connected(H), errmsg
+
+
+def test_petersen_cutset():
+    G = nx.petersen_graph()
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        # edge cuts
+        edge_cut = nx.minimum_edge_cut(G, **kwargs)
+        assert 3 == len(edge_cut), errmsg
+        H = G.copy()
+        H.remove_edges_from(edge_cut)
+        assert not nx.is_connected(H), errmsg
+        # node cuts
+        node_cut = nx.minimum_node_cut(G, **kwargs)
+        assert 3 == len(node_cut), errmsg
+        H = G.copy()
+        H.remove_nodes_from(node_cut)
+        assert not nx.is_connected(H), errmsg
+
+
+def test_octahedral_cutset():
+    G = nx.octahedral_graph()
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        # edge cuts
+        edge_cut = nx.minimum_edge_cut(G, **kwargs)
+        assert 4 == len(edge_cut), errmsg
+        H = G.copy()
+        H.remove_edges_from(edge_cut)
+        assert not nx.is_connected(H), errmsg
+        # node cuts
+        node_cut = nx.minimum_node_cut(G, **kwargs)
+        assert 4 == len(node_cut), errmsg
+        H = G.copy()
+        H.remove_nodes_from(node_cut)
+        assert not nx.is_connected(H), errmsg
+
+
+def test_icosahedral_cutset():
+    G = nx.icosahedral_graph()
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        # edge cuts
+        edge_cut = nx.minimum_edge_cut(G, **kwargs)
+        assert 5 == len(edge_cut), errmsg
+        H = G.copy()
+        H.remove_edges_from(edge_cut)
+        assert not nx.is_connected(H), errmsg
+        # node cuts
+        node_cut = nx.minimum_node_cut(G, **kwargs)
+        assert 5 == len(node_cut), errmsg
+        H = G.copy()
+        H.remove_nodes_from(node_cut)
+        assert not nx.is_connected(H), errmsg
+
+
+def test_node_cutset_exception():
+    G = nx.Graph()
+    G.add_edges_from([(1, 2), (3, 4)])
+    for flow_func in flow_funcs:
+        pytest.raises(nx.NetworkXError, nx.minimum_node_cut, G, flow_func=flow_func)
+
+
+def test_node_cutset_random_graphs():
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        for i in range(3):
+            G = nx.fast_gnp_random_graph(50, 0.25, seed=42)
+            if not nx.is_connected(G):
+                ccs = iter(nx.connected_components(G))
+                start = arbitrary_element(next(ccs))
+                G.add_edges_from((start, arbitrary_element(c)) for c in ccs)
+            cutset = nx.minimum_node_cut(G, flow_func=flow_func)
+            assert nx.node_connectivity(G) == len(cutset), errmsg
+            G.remove_nodes_from(cutset)
+            assert not nx.is_connected(G), errmsg
+
+
+def test_edge_cutset_random_graphs():
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        for i in range(3):
+            G = nx.fast_gnp_random_graph(50, 0.25, seed=42)
+            if not nx.is_connected(G):
+                ccs = iter(nx.connected_components(G))
+                start = arbitrary_element(next(ccs))
+                G.add_edges_from((start, arbitrary_element(c)) for c in ccs)
+            cutset = nx.minimum_edge_cut(G, flow_func=flow_func)
+            assert nx.edge_connectivity(G) == len(cutset), errmsg
+            G.remove_edges_from(cutset)
+            assert not nx.is_connected(G), errmsg
+
+
+def test_empty_graphs():
+    G = nx.Graph()
+    D = nx.DiGraph()
+    for interface_func in [nx.minimum_node_cut, nx.minimum_edge_cut]:
+        for flow_func in flow_funcs:
+            pytest.raises(
+                nx.NetworkXPointlessConcept, interface_func, G, flow_func=flow_func
+            )
+            pytest.raises(
+                nx.NetworkXPointlessConcept, interface_func, D, flow_func=flow_func
+            )
+
+
+def test_unbounded():
+    G = nx.complete_graph(5)
+    for flow_func in flow_funcs:
+        assert 4 == len(minimum_st_edge_cut(G, 1, 4, flow_func=flow_func))
+
+
+def test_missing_source():
+    G = nx.path_graph(4)
+    for interface_func in [nx.minimum_edge_cut, nx.minimum_node_cut]:
+        for flow_func in flow_funcs:
+            pytest.raises(
+                nx.NetworkXError, interface_func, G, 10, 1, flow_func=flow_func
+            )
+
+
+def test_missing_target():
+    G = nx.path_graph(4)
+    for interface_func in [nx.minimum_edge_cut, nx.minimum_node_cut]:
+        for flow_func in flow_funcs:
+            pytest.raises(
+                nx.NetworkXError, interface_func, G, 1, 10, flow_func=flow_func
+            )
+
+
+def test_not_weakly_connected():
+    G = nx.DiGraph()
+    nx.add_path(G, [1, 2, 3])
+    nx.add_path(G, [4, 5])
+    for interface_func in [nx.minimum_edge_cut, nx.minimum_node_cut]:
+        for flow_func in flow_funcs:
+            pytest.raises(nx.NetworkXError, interface_func, G, flow_func=flow_func)
+
+
+def test_not_connected():
+    G = nx.Graph()
+    nx.add_path(G, [1, 2, 3])
+    nx.add_path(G, [4, 5])
+    for interface_func in [nx.minimum_edge_cut, nx.minimum_node_cut]:
+        for flow_func in flow_funcs:
+            pytest.raises(nx.NetworkXError, interface_func, G, flow_func=flow_func)
+
+
+def tests_min_cut_complete():
+    G = nx.complete_graph(5)
+    for interface_func in [nx.minimum_edge_cut, nx.minimum_node_cut]:
+        for flow_func in flow_funcs:
+            assert 4 == len(interface_func(G, flow_func=flow_func))
+
+
+def tests_min_cut_complete_directed():
+    G = nx.complete_graph(5)
+    G = G.to_directed()
+    for interface_func in [nx.minimum_edge_cut, nx.minimum_node_cut]:
+        for flow_func in flow_funcs:
+            assert 4 == len(interface_func(G, flow_func=flow_func))
+
+
+def tests_minimum_st_node_cut():
+    G = nx.Graph()
+    G.add_nodes_from([0, 1, 2, 3, 7, 8, 11, 12])
+    G.add_edges_from([(7, 11), (1, 11), (1, 12), (12, 8), (0, 1)])
+    nodelist = minimum_st_node_cut(G, 7, 11)
+    assert nodelist == {}
+
+
+def test_invalid_auxiliary():
+    G = nx.complete_graph(5)
+    pytest.raises(nx.NetworkXError, minimum_st_node_cut, G, 0, 3, auxiliary=G)
+
+
+def test_interface_only_source():
+    G = nx.complete_graph(5)
+    for interface_func in [nx.minimum_node_cut, nx.minimum_edge_cut]:
+        pytest.raises(nx.NetworkXError, interface_func, G, s=0)
+
+
+def test_interface_only_target():
+    G = nx.complete_graph(5)
+    for interface_func in [nx.minimum_node_cut, nx.minimum_edge_cut]:
+        pytest.raises(nx.NetworkXError, interface_func, G, t=3)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_disjoint_paths.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_disjoint_paths.py
new file mode 100644
index 0000000..74bb3f2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_disjoint_paths.py
@@ -0,0 +1,249 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms import flow
+from networkx.utils import pairwise
+
+flow_funcs = [
+    flow.boykov_kolmogorov,
+    flow.edmonds_karp,
+    flow.dinitz,
+    flow.preflow_push,
+    flow.shortest_augmenting_path,
+]
+
+
+def is_path(G, path):
+    return all(v in G[u] for u, v in pairwise(path))
+
+
+def are_edge_disjoint_paths(G, paths):
+    if not paths:
+        return False
+    for path in paths:
+        assert is_path(G, path)
+    paths_edges = [list(pairwise(p)) for p in paths]
+    num_of_edges = sum(len(e) for e in paths_edges)
+    num_unique_edges = len(set.union(*[set(es) for es in paths_edges]))
+    if num_of_edges == num_unique_edges:
+        return True
+    return False
+
+
+def are_node_disjoint_paths(G, paths):
+    if not paths:
+        return False
+    for path in paths:
+        assert is_path(G, path)
+    # first and last nodes are source and target
+    st = {paths[0][0], paths[0][-1]}
+    num_of_nodes = len([n for path in paths for n in path if n not in st])
+    num_unique_nodes = len({n for path in paths for n in path if n not in st})
+    if num_of_nodes == num_unique_nodes:
+        return True
+    return False
+
+
+def test_graph_from_pr_2053():
+    G = nx.Graph()
+    G.add_edges_from(
+        [
+            ("A", "B"),
+            ("A", "D"),
+            ("A", "F"),
+            ("A", "G"),
+            ("B", "C"),
+            ("B", "D"),
+            ("B", "G"),
+            ("C", "D"),
+            ("C", "E"),
+            ("C", "Z"),
+            ("D", "E"),
+            ("D", "F"),
+            ("E", "F"),
+            ("E", "Z"),
+            ("F", "Z"),
+            ("G", "Z"),
+        ]
+    )
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        # edge disjoint paths
+        edge_paths = list(nx.edge_disjoint_paths(G, "A", "Z", **kwargs))
+        assert are_edge_disjoint_paths(G, edge_paths), errmsg
+        assert nx.edge_connectivity(G, "A", "Z") == len(edge_paths), errmsg
+        # node disjoint paths
+        node_paths = list(nx.node_disjoint_paths(G, "A", "Z", **kwargs))
+        assert are_node_disjoint_paths(G, node_paths), errmsg
+        assert nx.node_connectivity(G, "A", "Z") == len(node_paths), errmsg
+
+
+def test_florentine_families():
+    G = nx.florentine_families_graph()
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        # edge disjoint paths
+        edge_dpaths = list(nx.edge_disjoint_paths(G, "Medici", "Strozzi", **kwargs))
+        assert are_edge_disjoint_paths(G, edge_dpaths), errmsg
+        assert nx.edge_connectivity(G, "Medici", "Strozzi") == len(edge_dpaths), errmsg
+        # node disjoint paths
+        node_dpaths = list(nx.node_disjoint_paths(G, "Medici", "Strozzi", **kwargs))
+        assert are_node_disjoint_paths(G, node_dpaths), errmsg
+        assert nx.node_connectivity(G, "Medici", "Strozzi") == len(node_dpaths), errmsg
+
+
+def test_karate():
+    G = nx.karate_club_graph()
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        # edge disjoint paths
+        edge_dpaths = list(nx.edge_disjoint_paths(G, 0, 33, **kwargs))
+        assert are_edge_disjoint_paths(G, edge_dpaths), errmsg
+        assert nx.edge_connectivity(G, 0, 33) == len(edge_dpaths), errmsg
+        # node disjoint paths
+        node_dpaths = list(nx.node_disjoint_paths(G, 0, 33, **kwargs))
+        assert are_node_disjoint_paths(G, node_dpaths), errmsg
+        assert nx.node_connectivity(G, 0, 33) == len(node_dpaths), errmsg
+
+
+def test_petersen_disjoint_paths():
+    G = nx.petersen_graph()
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        # edge disjoint paths
+        edge_dpaths = list(nx.edge_disjoint_paths(G, 0, 6, **kwargs))
+        assert are_edge_disjoint_paths(G, edge_dpaths), errmsg
+        assert 3 == len(edge_dpaths), errmsg
+        # node disjoint paths
+        node_dpaths = list(nx.node_disjoint_paths(G, 0, 6, **kwargs))
+        assert are_node_disjoint_paths(G, node_dpaths), errmsg
+        assert 3 == len(node_dpaths), errmsg
+
+
+def test_octahedral_disjoint_paths():
+    G = nx.octahedral_graph()
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        # edge disjoint paths
+        edge_dpaths = list(nx.edge_disjoint_paths(G, 0, 5, **kwargs))
+        assert are_edge_disjoint_paths(G, edge_dpaths), errmsg
+        assert 4 == len(edge_dpaths), errmsg
+        # node disjoint paths
+        node_dpaths = list(nx.node_disjoint_paths(G, 0, 5, **kwargs))
+        assert are_node_disjoint_paths(G, node_dpaths), errmsg
+        assert 4 == len(node_dpaths), errmsg
+
+
+def test_icosahedral_disjoint_paths():
+    G = nx.icosahedral_graph()
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        # edge disjoint paths
+        edge_dpaths = list(nx.edge_disjoint_paths(G, 0, 6, **kwargs))
+        assert are_edge_disjoint_paths(G, edge_dpaths), errmsg
+        assert 5 == len(edge_dpaths), errmsg
+        # node disjoint paths
+        node_dpaths = list(nx.node_disjoint_paths(G, 0, 6, **kwargs))
+        assert are_node_disjoint_paths(G, node_dpaths), errmsg
+        assert 5 == len(node_dpaths), errmsg
+
+
+def test_cutoff_disjoint_paths():
+    G = nx.icosahedral_graph()
+    for flow_func in flow_funcs:
+        kwargs = dict(flow_func=flow_func)
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        for cutoff in [2, 4]:
+            kwargs["cutoff"] = cutoff
+            # edge disjoint paths
+            edge_dpaths = list(nx.edge_disjoint_paths(G, 0, 6, **kwargs))
+            assert are_edge_disjoint_paths(G, edge_dpaths), errmsg
+            assert cutoff == len(edge_dpaths), errmsg
+            # node disjoint paths
+            node_dpaths = list(nx.node_disjoint_paths(G, 0, 6, **kwargs))
+            assert are_node_disjoint_paths(G, node_dpaths), errmsg
+            assert cutoff == len(node_dpaths), errmsg
+
+
+def test_missing_source_edge_paths():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.path_graph(4)
+        list(nx.edge_disjoint_paths(G, 10, 1))
+
+
+def test_missing_source_node_paths():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.path_graph(4)
+        list(nx.node_disjoint_paths(G, 10, 1))
+
+
+def test_missing_target_edge_paths():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.path_graph(4)
+        list(nx.edge_disjoint_paths(G, 1, 10))
+
+
+def test_missing_target_node_paths():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.path_graph(4)
+        list(nx.node_disjoint_paths(G, 1, 10))
+
+
+def test_not_weakly_connected_edges():
+    with pytest.raises(nx.NetworkXNoPath):
+        G = nx.DiGraph()
+        nx.add_path(G, [1, 2, 3])
+        nx.add_path(G, [4, 5])
+        list(nx.edge_disjoint_paths(G, 1, 5))
+
+
+def test_not_weakly_connected_nodes():
+    with pytest.raises(nx.NetworkXNoPath):
+        G = nx.DiGraph()
+        nx.add_path(G, [1, 2, 3])
+        nx.add_path(G, [4, 5])
+        list(nx.node_disjoint_paths(G, 1, 5))
+
+
+def test_not_connected_edges():
+    with pytest.raises(nx.NetworkXNoPath):
+        G = nx.Graph()
+        nx.add_path(G, [1, 2, 3])
+        nx.add_path(G, [4, 5])
+        list(nx.edge_disjoint_paths(G, 1, 5))
+
+
+def test_not_connected_nodes():
+    with pytest.raises(nx.NetworkXNoPath):
+        G = nx.Graph()
+        nx.add_path(G, [1, 2, 3])
+        nx.add_path(G, [4, 5])
+        list(nx.node_disjoint_paths(G, 1, 5))
+
+
+def test_isolated_edges():
+    with pytest.raises(nx.NetworkXNoPath):
+        G = nx.Graph()
+        G.add_node(1)
+        nx.add_path(G, [4, 5])
+        list(nx.edge_disjoint_paths(G, 1, 5))
+
+
+def test_isolated_nodes():
+    with pytest.raises(nx.NetworkXNoPath):
+        G = nx.Graph()
+        G.add_node(1)
+        nx.add_path(G, [4, 5])
+        list(nx.node_disjoint_paths(G, 1, 5))
+
+
+def test_invalid_auxiliary():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.complete_graph(5)
+        list(nx.node_disjoint_paths(G, 0, 3, auxiliary=G))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_edge_augmentation.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_edge_augmentation.py
new file mode 100644
index 0000000..37ee297
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_edge_augmentation.py
@@ -0,0 +1,497 @@
+import itertools as it
+import random
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.connectivity import k_edge_augmentation
+from networkx.algorithms.connectivity.edge_augmentation import (
+    _unpack_available_edges,
+    collapse,
+    complement_edges,
+    is_k_edge_connected,
+    is_locally_k_edge_connected,
+)
+from networkx.utils import pairwise
+
+# This should be set to the largest k for which an efficient algorithm is
+# explicitly defined.
+MAX_EFFICIENT_K = 2
+
+
+def tarjan_bridge_graph():
+    # graph from tarjan paper
+    # RE Tarjan - "A note on finding the bridges of a graph"
+    # Information Processing Letters, 1974 - Elsevier
+    # doi:10.1016/0020-0190(74)90003-9.
+    # define 2-connected components and bridges
+    ccs = [
+        (1, 2, 4, 3, 1, 4),
+        (5, 6, 7, 5),
+        (8, 9, 10, 8),
+        (17, 18, 16, 15, 17),
+        (11, 12, 14, 13, 11, 14),
+    ]
+    bridges = [(4, 8), (3, 5), (3, 17)]
+    G = nx.Graph(it.chain(*(pairwise(path) for path in ccs + bridges)))
+    return G
+
+
+def test_weight_key():
+    G = nx.Graph()
+    G.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8, 9])
+    G.add_edges_from([(3, 8), (1, 2), (2, 3)])
+    impossible = {(3, 6), (3, 9)}
+    rng = random.Random(0)
+    avail_uv = list(set(complement_edges(G)) - impossible)
+    avail = [(u, v, {"cost": rng.random()}) for u, v in avail_uv]
+
+    _augment_and_check(G, k=1)
+    _augment_and_check(G, k=1, avail=avail_uv)
+    _augment_and_check(G, k=1, avail=avail, weight="cost")
+
+    _check_augmentations(G, avail, weight="cost")
+
+
+def test_is_locally_k_edge_connected_exceptions():
+    pytest.raises(nx.NetworkXNotImplemented, is_k_edge_connected, nx.DiGraph(), k=0)
+    pytest.raises(nx.NetworkXNotImplemented, is_k_edge_connected, nx.MultiGraph(), k=0)
+    pytest.raises(ValueError, is_k_edge_connected, nx.Graph(), k=0)
+
+
+def test_is_k_edge_connected():
+    G = nx.barbell_graph(10, 0)
+    assert is_k_edge_connected(G, k=1)
+    assert not is_k_edge_connected(G, k=2)
+
+    G = nx.Graph()
+    G.add_nodes_from([5, 15])
+    assert not is_k_edge_connected(G, k=1)
+    assert not is_k_edge_connected(G, k=2)
+
+    G = nx.complete_graph(5)
+    assert is_k_edge_connected(G, k=1)
+    assert is_k_edge_connected(G, k=2)
+    assert is_k_edge_connected(G, k=3)
+    assert is_k_edge_connected(G, k=4)
+
+
+def test_is_k_edge_connected_exceptions():
+    pytest.raises(
+        nx.NetworkXNotImplemented, is_locally_k_edge_connected, nx.DiGraph(), 1, 2, k=0
+    )
+    pytest.raises(
+        nx.NetworkXNotImplemented,
+        is_locally_k_edge_connected,
+        nx.MultiGraph(),
+        1,
+        2,
+        k=0,
+    )
+    pytest.raises(ValueError, is_locally_k_edge_connected, nx.Graph(), 1, 2, k=0)
+
+
+def test_is_locally_k_edge_connected():
+    G = nx.barbell_graph(10, 0)
+    assert is_locally_k_edge_connected(G, 5, 15, k=1)
+    assert not is_locally_k_edge_connected(G, 5, 15, k=2)
+
+    G = nx.Graph()
+    G.add_nodes_from([5, 15])
+    assert not is_locally_k_edge_connected(G, 5, 15, k=2)
+
+
+def test_null_graph():
+    G = nx.Graph()
+    _check_augmentations(G, max_k=MAX_EFFICIENT_K + 2)
+
+
+def test_cliques():
+    for n in range(1, 10):
+        G = nx.complete_graph(n)
+        _check_augmentations(G, max_k=MAX_EFFICIENT_K + 2)
+
+
+def test_clique_and_node():
+    for n in range(1, 10):
+        G = nx.complete_graph(n)
+        G.add_node(n + 1)
+        _check_augmentations(G, max_k=MAX_EFFICIENT_K + 2)
+
+
+def test_point_graph():
+    G = nx.Graph()
+    G.add_node(1)
+    _check_augmentations(G, max_k=MAX_EFFICIENT_K + 2)
+
+
+def test_edgeless_graph():
+    G = nx.Graph()
+    G.add_nodes_from([1, 2, 3, 4])
+    _check_augmentations(G)
+
+
+def test_invalid_k():
+    G = nx.Graph()
+    pytest.raises(ValueError, list, k_edge_augmentation(G, k=-1))
+    pytest.raises(ValueError, list, k_edge_augmentation(G, k=0))
+
+
+def test_unfeasible():
+    G = tarjan_bridge_graph()
+    pytest.raises(nx.NetworkXUnfeasible, list, k_edge_augmentation(G, k=1, avail=[]))
+
+    pytest.raises(nx.NetworkXUnfeasible, list, k_edge_augmentation(G, k=2, avail=[]))
+
+    pytest.raises(
+        nx.NetworkXUnfeasible, list, k_edge_augmentation(G, k=2, avail=[(7, 9)])
+    )
+
+    # partial solutions should not error if real solutions are infeasible
+    aug_edges = list(k_edge_augmentation(G, k=2, avail=[(7, 9)], partial=True))
+    assert aug_edges == [(7, 9)]
+
+    _check_augmentations(G, avail=[], max_k=MAX_EFFICIENT_K + 2)
+
+    _check_augmentations(G, avail=[(7, 9)], max_k=MAX_EFFICIENT_K + 2)
+
+
+def test_tarjan():
+    G = tarjan_bridge_graph()
+
+    aug_edges = set(_augment_and_check(G, k=2)[0])
+    print(f"aug_edges = {aug_edges!r}")
+    # can't assert edge exactly equality due to non-determinant edge order
+    # but we do know the size of the solution must be 3
+    assert len(aug_edges) == 3
+
+    avail = [
+        (9, 7),
+        (8, 5),
+        (2, 10),
+        (6, 13),
+        (11, 18),
+        (1, 17),
+        (2, 3),
+        (16, 17),
+        (18, 14),
+        (15, 14),
+    ]
+    aug_edges = set(_augment_and_check(G, avail=avail, k=2)[0])
+
+    # Can't assert exact length since approximation depends on the order of a
+    # dict traversal.
+    assert len(aug_edges) <= 3 * 2
+
+    _check_augmentations(G, avail)
+
+
+def test_configuration():
+    # seeds = [2718183590, 2470619828, 1694705158, 3001036531, 2401251497]
+    seeds = [1001, 1002, 1003, 1004]
+    for seed in seeds:
+        deg_seq = nx.random_powerlaw_tree_sequence(20, seed=seed, tries=5000)
+        G = nx.Graph(nx.configuration_model(deg_seq, seed=seed))
+        G.remove_edges_from(nx.selfloop_edges(G))
+        _check_augmentations(G)
+
+
+def test_shell():
+    # seeds = [2057382236, 3331169846, 1840105863, 476020778, 2247498425]
+    seeds = [18]
+    for seed in seeds:
+        constructor = [(12, 70, 0.8), (15, 40, 0.6)]
+        G = nx.random_shell_graph(constructor, seed=seed)
+        _check_augmentations(G)
+
+
+def test_karate():
+    G = nx.karate_club_graph()
+    _check_augmentations(G)
+
+
+def test_star():
+    G = nx.star_graph(3)
+    _check_augmentations(G)
+
+    G = nx.star_graph(5)
+    _check_augmentations(G)
+
+    G = nx.star_graph(10)
+    _check_augmentations(G)
+
+
+def test_barbell():
+    G = nx.barbell_graph(5, 0)
+    _check_augmentations(G)
+
+    G = nx.barbell_graph(5, 2)
+    _check_augmentations(G)
+
+    G = nx.barbell_graph(5, 3)
+    _check_augmentations(G)
+
+    G = nx.barbell_graph(5, 4)
+    _check_augmentations(G)
+
+
+def test_bridge():
+    G = nx.Graph([(2393, 2257), (2393, 2685), (2685, 2257), (1758, 2257)])
+    _check_augmentations(G)
+
+
+def test_gnp_augmentation():
+    rng = random.Random(0)
+    G = nx.gnp_random_graph(30, 0.005, seed=0)
+    # Randomly make edges available
+    avail = {
+        (u, v): 1 + rng.random() for u, v in complement_edges(G) if rng.random() < 0.25
+    }
+    _check_augmentations(G, avail)
+
+
+def _assert_solution_properties(G, aug_edges, avail_dict=None):
+    """Checks that aug_edges are consistently formatted"""
+    if avail_dict is not None:
+        assert all(
+            e in avail_dict for e in aug_edges
+        ), "when avail is specified aug-edges should be in avail"
+
+    unique_aug = set(map(tuple, map(sorted, aug_edges)))
+    unique_aug = list(map(tuple, map(sorted, aug_edges)))
+    assert len(aug_edges) == len(unique_aug), "edges should be unique"
+
+    assert not any(u == v for u, v in unique_aug), "should be no self-edges"
+
+    assert not any(
+        G.has_edge(u, v) for u, v in unique_aug
+    ), "aug edges and G.edges should be disjoint"
+
+
+def _augment_and_check(
+    G, k, avail=None, weight=None, verbose=False, orig_k=None, max_aug_k=None
+):
+    """
+    Does one specific augmentation and checks for properties of the result
+    """
+    if orig_k is None:
+        try:
+            orig_k = nx.edge_connectivity(G)
+        except nx.NetworkXPointlessConcept:
+            orig_k = 0
+    info = {}
+    try:
+        if avail is not None:
+            # ensure avail is in dict form
+            avail_dict = dict(zip(*_unpack_available_edges(avail, weight=weight)))
+        else:
+            avail_dict = None
+        try:
+            # Find the augmentation if possible
+            generator = nx.k_edge_augmentation(G, k=k, weight=weight, avail=avail)
+            assert not isinstance(generator, list), "should always return an iter"
+            aug_edges = []
+            for edge in generator:
+                aug_edges.append(edge)
+        except nx.NetworkXUnfeasible:
+            infeasible = True
+            info["infeasible"] = True
+            assert len(aug_edges) == 0, "should not generate anything if unfeasible"
+
+            if avail is None:
+                n_nodes = G.number_of_nodes()
+                assert n_nodes <= k, (
+                    "unconstrained cases are only unfeasible if |V| <= k. "
+                    f"Got |V|={n_nodes} and k={k}"
+                )
+            else:
+                if max_aug_k is None:
+                    G_aug_all = G.copy()
+                    G_aug_all.add_edges_from(avail_dict.keys())
+                    try:
+                        max_aug_k = nx.edge_connectivity(G_aug_all)
+                    except nx.NetworkXPointlessConcept:
+                        max_aug_k = 0
+
+                assert max_aug_k < k, (
+                    "avail should only be unfeasible if using all edges "
+                    "does not achieve k-edge-connectivity"
+                )
+
+            # Test for a partial solution
+            partial_edges = list(
+                nx.k_edge_augmentation(G, k=k, weight=weight, partial=True, avail=avail)
+            )
+
+            info["n_partial_edges"] = len(partial_edges)
+
+            if avail_dict is None:
+                assert set(partial_edges) == set(
+                    complement_edges(G)
+                ), "unweighted partial solutions should be the complement"
+            elif len(avail_dict) > 0:
+                H = G.copy()
+
+                # Find the partial / full augmented connectivity
+                H.add_edges_from(partial_edges)
+                partial_conn = nx.edge_connectivity(H)
+
+                H.add_edges_from(set(avail_dict.keys()))
+                full_conn = nx.edge_connectivity(H)
+
+                # Full connectivity should be no better than our partial
+                # solution.
+                assert (
+                    partial_conn == full_conn
+                ), "adding more edges should not increase k-conn"
+
+            # Find the new edge-connectivity after adding the augmenting edges
+            aug_edges = partial_edges
+        else:
+            infeasible = False
+
+        # Find the weight of the augmentation
+        num_edges = len(aug_edges)
+        if avail is not None:
+            total_weight = sum(avail_dict[e] for e in aug_edges)
+        else:
+            total_weight = num_edges
+
+        info["total_weight"] = total_weight
+        info["num_edges"] = num_edges
+
+        # Find the new edge-connectivity after adding the augmenting edges
+        G_aug = G.copy()
+        G_aug.add_edges_from(aug_edges)
+        try:
+            aug_k = nx.edge_connectivity(G_aug)
+        except nx.NetworkXPointlessConcept:
+            aug_k = 0
+        info["aug_k"] = aug_k
+
+        # Do checks
+        if not infeasible and orig_k < k:
+            assert info["aug_k"] >= k, f"connectivity should increase to k={k} or more"
+
+        assert info["aug_k"] >= orig_k, "augmenting should never reduce connectivity"
+
+        _assert_solution_properties(G, aug_edges, avail_dict)
+
+    except Exception:
+        info["failed"] = True
+        print(f"edges = {list(G.edges())}")
+        print(f"nodes = {list(G.nodes())}")
+        print(f"aug_edges = {list(aug_edges)}")
+        print(f"info  = {info}")
+        raise
+    else:
+        if verbose:
+            print(f"info  = {info}")
+
+    if infeasible:
+        aug_edges = None
+    return aug_edges, info
+
+
+def _check_augmentations(G, avail=None, max_k=None, weight=None, verbose=False):
+    """Helper to check weighted/unweighted cases with multiple values of k"""
+    # Using all available edges, find the maximum edge-connectivity
+    try:
+        orig_k = nx.edge_connectivity(G)
+    except nx.NetworkXPointlessConcept:
+        orig_k = 0
+
+    if avail is not None:
+        all_aug_edges = _unpack_available_edges(avail, weight=weight)[0]
+        G_aug_all = G.copy()
+        G_aug_all.add_edges_from(all_aug_edges)
+        try:
+            max_aug_k = nx.edge_connectivity(G_aug_all)
+        except nx.NetworkXPointlessConcept:
+            max_aug_k = 0
+    else:
+        max_aug_k = G.number_of_nodes() - 1
+
+    if max_k is None:
+        max_k = min(4, max_aug_k)
+
+    avail_uniform = {e: 1 for e in complement_edges(G)}
+
+    if verbose:
+        print("\n=== CHECK_AUGMENTATION ===")
+        print(f"G.number_of_nodes = {G.number_of_nodes()!r}")
+        print(f"G.number_of_edges = {G.number_of_edges()!r}")
+        print(f"max_k = {max_k!r}")
+        print(f"max_aug_k = {max_aug_k!r}")
+        print(f"orig_k = {orig_k!r}")
+
+    # check augmentation for multiple values of k
+    for k in range(1, max_k + 1):
+        if verbose:
+            print("---------------")
+            print(f"Checking k = {k}")
+
+        # Check the unweighted version
+        if verbose:
+            print("unweighted case")
+        aug_edges1, info1 = _augment_and_check(G, k=k, verbose=verbose, orig_k=orig_k)
+
+        # Check that the weighted version with all available edges and uniform
+        # weights gives a similar solution to the unweighted case.
+        if verbose:
+            print("weighted uniform case")
+        aug_edges2, info2 = _augment_and_check(
+            G,
+            k=k,
+            avail=avail_uniform,
+            verbose=verbose,
+            orig_k=orig_k,
+            max_aug_k=G.number_of_nodes() - 1,
+        )
+
+        # Check the weighted version
+        if avail is not None:
+            if verbose:
+                print("weighted case")
+            aug_edges3, info3 = _augment_and_check(
+                G,
+                k=k,
+                avail=avail,
+                weight=weight,
+                verbose=verbose,
+                max_aug_k=max_aug_k,
+                orig_k=orig_k,
+            )
+
+        if aug_edges1 is not None:
+            # Check approximation ratios
+            if k == 1:
+                # when k=1, both solutions should be optimal
+                assert info2["total_weight"] == info1["total_weight"]
+            if k == 2:
+                # when k=2, the weighted version is an approximation
+                if orig_k == 0:
+                    # the approximation ratio is 3 if G is not connected
+                    assert info2["total_weight"] <= info1["total_weight"] * 3
+                else:
+                    # the approximation ratio is 2 if G is was connected
+                    assert info2["total_weight"] <= info1["total_weight"] * 2
+                _check_unconstrained_bridge_property(G, info1)
+
+
+def _check_unconstrained_bridge_property(G, info1):
+    # Check Theorem 5 from Eswaran and Tarjan. (1975) Augmentation problems
+    import math
+
+    bridge_ccs = list(nx.connectivity.bridge_components(G))
+    # condense G into an forest C
+    C = collapse(G, bridge_ccs)
+
+    p = len([n for n, d in C.degree() if d == 1])  # leafs
+    q = len([n for n, d in C.degree() if d == 0])  # isolated
+    if p + q > 1:
+        size_target = math.ceil(p / 2) + q
+        size_aug = info1["num_edges"]
+        assert (
+            size_aug == size_target
+        ), "augmentation size is different from what theory predicts"
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_edge_kcomponents.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_edge_kcomponents.py
new file mode 100644
index 0000000..4a1f681
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_edge_kcomponents.py
@@ -0,0 +1,488 @@
+import itertools as it
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.connectivity import EdgeComponentAuxGraph, bridge_components
+from networkx.algorithms.connectivity.edge_kcomponents import general_k_edge_subgraphs
+from networkx.utils import pairwise
+
+# ----------------
+# Helper functions
+# ----------------
+
+
+def fset(list_of_sets):
+    """allows == to be used for list of sets"""
+    return set(map(frozenset, list_of_sets))
+
+
+def _assert_subgraph_edge_connectivity(G, ccs_subgraph, k):
+    """
+    tests properties of k-edge-connected subgraphs
+
+    the actual edge connectivity should be no less than k unless the cc is a
+    single node.
+    """
+    for cc in ccs_subgraph:
+        C = G.subgraph(cc)
+        if len(cc) > 1:
+            connectivity = nx.edge_connectivity(C)
+            assert connectivity >= k
+
+
+def _memo_connectivity(G, u, v, memo):
+    edge = (u, v)
+    if edge in memo:
+        return memo[edge]
+    if not G.is_directed():
+        redge = (v, u)
+        if redge in memo:
+            return memo[redge]
+    memo[edge] = nx.edge_connectivity(G, *edge)
+    return memo[edge]
+
+
+def _all_pairs_connectivity(G, cc, k, memo):
+    # Brute force check
+    for u, v in it.combinations(cc, 2):
+        # Use a memoization dict to save on computation
+        connectivity = _memo_connectivity(G, u, v, memo)
+        if G.is_directed():
+            connectivity = min(connectivity, _memo_connectivity(G, v, u, memo))
+        assert connectivity >= k
+
+
+def _assert_local_cc_edge_connectivity(G, ccs_local, k, memo):
+    """
+    tests properties of k-edge-connected components
+
+    the local edge connectivity between each pair of nodes in the original
+    graph should be no less than k unless the cc is a single node.
+    """
+    for cc in ccs_local:
+        if len(cc) > 1:
+            # Strategy for testing a bit faster: If the subgraph has high edge
+            # connectivity then it must have local connectivity
+            C = G.subgraph(cc)
+            connectivity = nx.edge_connectivity(C)
+            if connectivity < k:
+                # Otherwise do the brute force (with memoization) check
+                _all_pairs_connectivity(G, cc, k, memo)
+
+
+# Helper function
+def _check_edge_connectivity(G):
+    """
+    Helper - generates all k-edge-components using the aux graph.  Checks the
+    both local and subgraph edge connectivity of each cc. Also checks that
+    alternate methods of computing the k-edge-ccs generate the same result.
+    """
+    # Construct the auxiliary graph that can be used to make each k-cc or k-sub
+    aux_graph = EdgeComponentAuxGraph.construct(G)
+
+    # memoize the local connectivity in this graph
+    memo = {}
+
+    for k in it.count(1):
+        # Test "local" k-edge-components and k-edge-subgraphs
+        ccs_local = fset(aux_graph.k_edge_components(k))
+        ccs_subgraph = fset(aux_graph.k_edge_subgraphs(k))
+
+        # Check connectivity properties that should be guaranteed by the
+        # algorithms.
+        _assert_local_cc_edge_connectivity(G, ccs_local, k, memo)
+        _assert_subgraph_edge_connectivity(G, ccs_subgraph, k)
+
+        if k == 1 or k == 2 and not G.is_directed():
+            assert (
+                ccs_local == ccs_subgraph
+            ), "Subgraphs and components should be the same when k == 1 or (k == 2 and not G.directed())"
+
+        if G.is_directed():
+            # Test special case methods are the same as the aux graph
+            if k == 1:
+                alt_sccs = fset(nx.strongly_connected_components(G))
+                assert alt_sccs == ccs_local, "k=1 failed alt"
+                assert alt_sccs == ccs_subgraph, "k=1 failed alt"
+        else:
+            # Test special case methods are the same as the aux graph
+            if k == 1:
+                alt_ccs = fset(nx.connected_components(G))
+                assert alt_ccs == ccs_local, "k=1 failed alt"
+                assert alt_ccs == ccs_subgraph, "k=1 failed alt"
+            elif k == 2:
+                alt_bridge_ccs = fset(bridge_components(G))
+                assert alt_bridge_ccs == ccs_local, "k=2 failed alt"
+                assert alt_bridge_ccs == ccs_subgraph, "k=2 failed alt"
+            # if new methods for k == 3 or k == 4 are implemented add them here
+
+        # Check the general subgraph method works by itself
+        alt_subgraph_ccs = fset(
+            [set(C.nodes()) for C in general_k_edge_subgraphs(G, k=k)]
+        )
+        assert alt_subgraph_ccs == ccs_subgraph, "alt subgraph method failed"
+
+        # Stop once k is larger than all special case methods
+        # and we cannot break down ccs any further.
+        if k > 2 and all(len(cc) == 1 for cc in ccs_local):
+            break
+
+
+# ----------------
+# Misc tests
+# ----------------
+
+
+def test_zero_k_exception():
+    G = nx.Graph()
+    # functions that return generators error immediately
+    pytest.raises(ValueError, nx.k_edge_components, G, k=0)
+    pytest.raises(ValueError, nx.k_edge_subgraphs, G, k=0)
+
+    # actual generators only error when you get the first item
+    aux_graph = EdgeComponentAuxGraph.construct(G)
+    pytest.raises(ValueError, list, aux_graph.k_edge_components(k=0))
+    pytest.raises(ValueError, list, aux_graph.k_edge_subgraphs(k=0))
+
+    pytest.raises(ValueError, list, general_k_edge_subgraphs(G, k=0))
+
+
+def test_empty_input():
+    G = nx.Graph()
+    assert [] == list(nx.k_edge_components(G, k=5))
+    assert [] == list(nx.k_edge_subgraphs(G, k=5))
+
+    G = nx.DiGraph()
+    assert [] == list(nx.k_edge_components(G, k=5))
+    assert [] == list(nx.k_edge_subgraphs(G, k=5))
+
+
+def test_not_implemented():
+    G = nx.MultiGraph()
+    pytest.raises(nx.NetworkXNotImplemented, EdgeComponentAuxGraph.construct, G)
+    pytest.raises(nx.NetworkXNotImplemented, nx.k_edge_components, G, k=2)
+    pytest.raises(nx.NetworkXNotImplemented, nx.k_edge_subgraphs, G, k=2)
+    with pytest.raises(nx.NetworkXNotImplemented):
+        next(bridge_components(G))
+    with pytest.raises(nx.NetworkXNotImplemented):
+        next(bridge_components(nx.DiGraph()))
+
+
+def test_general_k_edge_subgraph_quick_return():
+    # tests quick return optimization
+    G = nx.Graph()
+    G.add_node(0)
+    subgraphs = list(general_k_edge_subgraphs(G, k=1))
+    assert len(subgraphs) == 1
+    for subgraph in subgraphs:
+        assert subgraph.number_of_nodes() == 1
+
+    G.add_node(1)
+    subgraphs = list(general_k_edge_subgraphs(G, k=1))
+    assert len(subgraphs) == 2
+    for subgraph in subgraphs:
+        assert subgraph.number_of_nodes() == 1
+
+
+# ----------------
+# Undirected tests
+# ----------------
+
+
+def test_random_gnp():
+    # seeds = [1550709854, 1309423156, 4208992358, 2785630813, 1915069929]
+    seeds = [12, 13]
+
+    for seed in seeds:
+        G = nx.gnp_random_graph(20, 0.2, seed=seed)
+        _check_edge_connectivity(G)
+
+
+def test_configuration():
+    # seeds = [2718183590, 2470619828, 1694705158, 3001036531, 2401251497]
+    seeds = [14, 15]
+    for seed in seeds:
+        deg_seq = nx.random_powerlaw_tree_sequence(20, seed=seed, tries=5000)
+        G = nx.Graph(nx.configuration_model(deg_seq, seed=seed))
+        G.remove_edges_from(nx.selfloop_edges(G))
+        _check_edge_connectivity(G)
+
+
+def test_shell():
+    # seeds = [2057382236, 3331169846, 1840105863, 476020778, 2247498425]
+    seeds = [20]
+    for seed in seeds:
+        constructor = [(12, 70, 0.8), (15, 40, 0.6)]
+        G = nx.random_shell_graph(constructor, seed=seed)
+        _check_edge_connectivity(G)
+
+
+def test_karate():
+    G = nx.karate_club_graph()
+    _check_edge_connectivity(G)
+
+
+def test_tarjan_bridge():
+    # graph from tarjan paper
+    # RE Tarjan - "A note on finding the bridges of a graph"
+    # Information Processing Letters, 1974 - Elsevier
+    # doi:10.1016/0020-0190(74)90003-9.
+    # define 2-connected components and bridges
+    ccs = [
+        (1, 2, 4, 3, 1, 4),
+        (5, 6, 7, 5),
+        (8, 9, 10, 8),
+        (17, 18, 16, 15, 17),
+        (11, 12, 14, 13, 11, 14),
+    ]
+    bridges = [(4, 8), (3, 5), (3, 17)]
+    G = nx.Graph(it.chain(*(pairwise(path) for path in ccs + bridges)))
+    _check_edge_connectivity(G)
+
+
+def test_bridge_cc():
+    # define 2-connected components and bridges
+    cc2 = [(1, 2, 4, 3, 1, 4), (8, 9, 10, 8), (11, 12, 13, 11)]
+    bridges = [(4, 8), (3, 5), (20, 21), (22, 23, 24)]
+    G = nx.Graph(it.chain(*(pairwise(path) for path in cc2 + bridges)))
+    bridge_ccs = fset(bridge_components(G))
+    target_ccs = fset(
+        [{1, 2, 3, 4}, {5}, {8, 9, 10}, {11, 12, 13}, {20}, {21}, {22}, {23}, {24}]
+    )
+    assert bridge_ccs == target_ccs
+    _check_edge_connectivity(G)
+
+
+def test_undirected_aux_graph():
+    # Graph similar to the one in
+    # http://journals.plos.org/plosone/article?id=10.1371/journal.pone.0136264
+    a, b, c, d, e, f, g, h, i = "abcdefghi"
+    paths = [
+        (a, d, b, f, c),
+        (a, e, b),
+        (a, e, b, c, g, b, a),
+        (c, b),
+        (f, g, f),
+        (h, i),
+    ]
+    G = nx.Graph(it.chain(*[pairwise(path) for path in paths]))
+    aux_graph = EdgeComponentAuxGraph.construct(G)
+
+    components_1 = fset(aux_graph.k_edge_subgraphs(k=1))
+    target_1 = fset([{a, b, c, d, e, f, g}, {h, i}])
+    assert target_1 == components_1
+
+    # Check that the undirected case for k=1 agrees with CCs
+    alt_1 = fset(nx.k_edge_subgraphs(G, k=1))
+    assert alt_1 == components_1
+
+    components_2 = fset(aux_graph.k_edge_subgraphs(k=2))
+    target_2 = fset([{a, b, c, d, e, f, g}, {h}, {i}])
+    assert target_2 == components_2
+
+    # Check that the undirected case for k=2 agrees with bridge components
+    alt_2 = fset(nx.k_edge_subgraphs(G, k=2))
+    assert alt_2 == components_2
+
+    components_3 = fset(aux_graph.k_edge_subgraphs(k=3))
+    target_3 = fset([{a}, {b, c, f, g}, {d}, {e}, {h}, {i}])
+    assert target_3 == components_3
+
+    components_4 = fset(aux_graph.k_edge_subgraphs(k=4))
+    target_4 = fset([{a}, {b}, {c}, {d}, {e}, {f}, {g}, {h}, {i}])
+    assert target_4 == components_4
+
+    _check_edge_connectivity(G)
+
+
+def test_local_subgraph_difference():
+    paths = [
+        (11, 12, 13, 14, 11, 13, 14, 12),  # first 4-clique
+        (21, 22, 23, 24, 21, 23, 24, 22),  # second 4-clique
+        # paths connecting each node of the 4 cliques
+        (11, 101, 21),
+        (12, 102, 22),
+        (13, 103, 23),
+        (14, 104, 24),
+    ]
+    G = nx.Graph(it.chain(*[pairwise(path) for path in paths]))
+    aux_graph = EdgeComponentAuxGraph.construct(G)
+
+    # Each clique is returned separately in k-edge-subgraphs
+    subgraph_ccs = fset(aux_graph.k_edge_subgraphs(3))
+    subgraph_target = fset(
+        [{101}, {102}, {103}, {104}, {21, 22, 23, 24}, {11, 12, 13, 14}]
+    )
+    assert subgraph_ccs == subgraph_target
+
+    # But in k-edge-ccs they are returned together
+    # because they are locally 3-edge-connected
+    local_ccs = fset(aux_graph.k_edge_components(3))
+    local_target = fset([{101}, {102}, {103}, {104}, {11, 12, 13, 14, 21, 22, 23, 24}])
+    assert local_ccs == local_target
+
+
+def test_local_subgraph_difference_directed():
+    dipaths = [(1, 2, 3, 4, 1), (1, 3, 1)]
+    G = nx.DiGraph(it.chain(*[pairwise(path) for path in dipaths]))
+
+    assert fset(nx.k_edge_components(G, k=1)) == fset(nx.k_edge_subgraphs(G, k=1))
+
+    # Unlike undirected graphs, when k=2, for directed graphs there is a case
+    # where the k-edge-ccs are not the same as the k-edge-subgraphs.
+    # (in directed graphs ccs and subgraphs are the same when k=2)
+    assert fset(nx.k_edge_components(G, k=2)) != fset(nx.k_edge_subgraphs(G, k=2))
+
+    assert fset(nx.k_edge_components(G, k=3)) == fset(nx.k_edge_subgraphs(G, k=3))
+
+    _check_edge_connectivity(G)
+
+
+def test_triangles():
+    paths = [
+        (11, 12, 13, 11),  # first 3-clique
+        (21, 22, 23, 21),  # second 3-clique
+        (11, 21),  # connected by an edge
+    ]
+    G = nx.Graph(it.chain(*[pairwise(path) for path in paths]))
+
+    # subgraph and ccs are the same in all cases here
+    assert fset(nx.k_edge_components(G, k=1)) == fset(nx.k_edge_subgraphs(G, k=1))
+
+    assert fset(nx.k_edge_components(G, k=2)) == fset(nx.k_edge_subgraphs(G, k=2))
+
+    assert fset(nx.k_edge_components(G, k=3)) == fset(nx.k_edge_subgraphs(G, k=3))
+
+    _check_edge_connectivity(G)
+
+
+def test_four_clique():
+    paths = [
+        (11, 12, 13, 14, 11, 13, 14, 12),  # first 4-clique
+        (21, 22, 23, 24, 21, 23, 24, 22),  # second 4-clique
+        # paths connecting the 4 cliques such that they are
+        # 3-connected in G, but not in the subgraph.
+        # Case where the nodes bridging them do not have degree less than 3.
+        (100, 13),
+        (12, 100, 22),
+        (13, 200, 23),
+        (14, 300, 24),
+    ]
+    G = nx.Graph(it.chain(*[pairwise(path) for path in paths]))
+
+    # The subgraphs and ccs are different for k=3
+    local_ccs = fset(nx.k_edge_components(G, k=3))
+    subgraphs = fset(nx.k_edge_subgraphs(G, k=3))
+    assert local_ccs != subgraphs
+
+    # The cliques ares in the same cc
+    clique1 = frozenset(paths[0])
+    clique2 = frozenset(paths[1])
+    assert clique1.union(clique2).union({100}) in local_ccs
+
+    # but different subgraphs
+    assert clique1 in subgraphs
+    assert clique2 in subgraphs
+
+    assert G.degree(100) == 3
+
+    _check_edge_connectivity(G)
+
+
+def test_five_clique():
+    # Make a graph that can be disconnected less than 4 edges, but no node has
+    # degree less than 4.
+    G = nx.disjoint_union(nx.complete_graph(5), nx.complete_graph(5))
+    paths = [
+        # add aux-connections
+        (1, 100, 6),
+        (2, 100, 7),
+        (3, 200, 8),
+        (4, 200, 100),
+    ]
+    G.add_edges_from(it.chain(*[pairwise(path) for path in paths]))
+    assert min(dict(nx.degree(G)).values()) == 4
+
+    # For k=3 they are the same
+    assert fset(nx.k_edge_components(G, k=3)) == fset(nx.k_edge_subgraphs(G, k=3))
+
+    # For k=4 they are the different
+    # the aux nodes are in the same CC as clique 1 but no the same subgraph
+    assert fset(nx.k_edge_components(G, k=4)) != fset(nx.k_edge_subgraphs(G, k=4))
+
+    # For k=5 they are not the same
+    assert fset(nx.k_edge_components(G, k=5)) != fset(nx.k_edge_subgraphs(G, k=5))
+
+    # For k=6 they are the same
+    assert fset(nx.k_edge_components(G, k=6)) == fset(nx.k_edge_subgraphs(G, k=6))
+    _check_edge_connectivity(G)
+
+
+# ----------------
+# Undirected tests
+# ----------------
+
+
+def test_directed_aux_graph():
+    # Graph similar to the one in
+    # http://journals.plos.org/plosone/article?id=10.1371/journal.pone.0136264
+    a, b, c, d, e, f, g, h, i = "abcdefghi"
+    dipaths = [
+        (a, d, b, f, c),
+        (a, e, b),
+        (a, e, b, c, g, b, a),
+        (c, b),
+        (f, g, f),
+        (h, i),
+    ]
+    G = nx.DiGraph(it.chain(*[pairwise(path) for path in dipaths]))
+    aux_graph = EdgeComponentAuxGraph.construct(G)
+
+    components_1 = fset(aux_graph.k_edge_subgraphs(k=1))
+    target_1 = fset([{a, b, c, d, e, f, g}, {h}, {i}])
+    assert target_1 == components_1
+
+    # Check that the directed case for k=1 agrees with SCCs
+    alt_1 = fset(nx.strongly_connected_components(G))
+    assert alt_1 == components_1
+
+    components_2 = fset(aux_graph.k_edge_subgraphs(k=2))
+    target_2 = fset([{i}, {e}, {d}, {b, c, f, g}, {h}, {a}])
+    assert target_2 == components_2
+
+    components_3 = fset(aux_graph.k_edge_subgraphs(k=3))
+    target_3 = fset([{a}, {b}, {c}, {d}, {e}, {f}, {g}, {h}, {i}])
+    assert target_3 == components_3
+
+
+def test_random_gnp_directed():
+    # seeds = [3894723670, 500186844, 267231174, 2181982262, 1116750056]
+    seeds = [21]
+    for seed in seeds:
+        G = nx.gnp_random_graph(20, 0.2, directed=True, seed=seed)
+        _check_edge_connectivity(G)
+
+
+def test_configuration_directed():
+    # seeds = [671221681, 2403749451, 124433910, 672335939, 1193127215]
+    seeds = [67]
+    for seed in seeds:
+        deg_seq = nx.random_powerlaw_tree_sequence(20, seed=seed, tries=5000)
+        G = nx.DiGraph(nx.configuration_model(deg_seq, seed=seed))
+        G.remove_edges_from(nx.selfloop_edges(G))
+        _check_edge_connectivity(G)
+
+
+def test_shell_directed():
+    # seeds = [3134027055, 4079264063, 1350769518, 1405643020, 530038094]
+    seeds = [31]
+    for seed in seeds:
+        constructor = [(12, 70, 0.8), (15, 40, 0.6)]
+        G = nx.random_shell_graph(constructor, seed=seed).to_directed()
+        _check_edge_connectivity(G)
+
+
+def test_karate_directed():
+    G = nx.karate_club_graph().to_directed()
+    _check_edge_connectivity(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_kcomponents.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_kcomponents.py
new file mode 100644
index 0000000..f4436ac
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_kcomponents.py
@@ -0,0 +1,296 @@
+# Test for Moody and White k-components algorithm
+import pytest
+
+import networkx as nx
+from networkx.algorithms.connectivity.kcomponents import (
+    _consolidate,
+    build_k_number_dict,
+)
+
+##
+# A nice synthetic graph
+##
+
+
+def torrents_and_ferraro_graph():
+    # Graph from https://arxiv.org/pdf/1503.04476v1 p.26
+    G = nx.convert_node_labels_to_integers(
+        nx.grid_graph([5, 5]), label_attribute="labels"
+    )
+    rlabels = nx.get_node_attributes(G, "labels")
+    labels = {v: k for k, v in rlabels.items()}
+
+    for nodes in [(labels[(0, 4)], labels[(1, 4)]), (labels[(3, 4)], labels[(4, 4)])]:
+        new_node = G.order() + 1
+        # Petersen graph is triconnected
+        P = nx.petersen_graph()
+        G = nx.disjoint_union(G, P)
+        # Add two edges between the grid and P
+        G.add_edge(new_node + 1, nodes[0])
+        G.add_edge(new_node, nodes[1])
+        # K5 is 4-connected
+        K = nx.complete_graph(5)
+        G = nx.disjoint_union(G, K)
+        # Add three edges between P and K5
+        G.add_edge(new_node + 2, new_node + 11)
+        G.add_edge(new_node + 3, new_node + 12)
+        G.add_edge(new_node + 4, new_node + 13)
+        # Add another K5 sharing a node
+        G = nx.disjoint_union(G, K)
+        nbrs = G[new_node + 10]
+        G.remove_node(new_node + 10)
+        for nbr in nbrs:
+            G.add_edge(new_node + 17, nbr)
+        # This edge makes the graph biconnected; it's
+        # needed because K5s share only one node.
+        G.add_edge(new_node + 16, new_node + 8)
+
+    for nodes in [(labels[(0, 0)], labels[(1, 0)]), (labels[(3, 0)], labels[(4, 0)])]:
+        new_node = G.order() + 1
+        # Petersen graph is triconnected
+        P = nx.petersen_graph()
+        G = nx.disjoint_union(G, P)
+        # Add two edges between the grid and P
+        G.add_edge(new_node + 1, nodes[0])
+        G.add_edge(new_node, nodes[1])
+        # K5 is 4-connected
+        K = nx.complete_graph(5)
+        G = nx.disjoint_union(G, K)
+        # Add three edges between P and K5
+        G.add_edge(new_node + 2, new_node + 11)
+        G.add_edge(new_node + 3, new_node + 12)
+        G.add_edge(new_node + 4, new_node + 13)
+        # Add another K5 sharing two nodes
+        G = nx.disjoint_union(G, K)
+        nbrs = G[new_node + 10]
+        G.remove_node(new_node + 10)
+        for nbr in nbrs:
+            G.add_edge(new_node + 17, nbr)
+        nbrs2 = G[new_node + 9]
+        G.remove_node(new_node + 9)
+        for nbr in nbrs2:
+            G.add_edge(new_node + 18, nbr)
+    return G
+
+
+def test_directed():
+    with pytest.raises(nx.NetworkXNotImplemented):
+        G = nx.gnp_random_graph(10, 0.2, directed=True, seed=42)
+        nx.k_components(G)
+
+
+# Helper function
+def _check_connectivity(G, k_components):
+    for k, components in k_components.items():
+        if k < 3:
+            continue
+        # check that k-components have node connectivity >= k.
+        for component in components:
+            C = G.subgraph(component)
+            K = nx.node_connectivity(C)
+            assert K >= k
+
+
+@pytest.mark.slow
+def test_torrents_and_ferraro_graph():
+    G = torrents_and_ferraro_graph()
+    result = nx.k_components(G)
+    _check_connectivity(G, result)
+
+    # In this example graph there are 8 3-components, 4 with 15 nodes
+    # and 4 with 5 nodes.
+    assert len(result[3]) == 8
+    assert len([c for c in result[3] if len(c) == 15]) == 4
+    assert len([c for c in result[3] if len(c) == 5]) == 4
+    # There are also 8 4-components all with 5 nodes.
+    assert len(result[4]) == 8
+    assert all(len(c) == 5 for c in result[4])
+
+
+@pytest.mark.slow
+def test_random_gnp():
+    G = nx.gnp_random_graph(50, 0.2, seed=42)
+    result = nx.k_components(G)
+    _check_connectivity(G, result)
+
+
+@pytest.mark.slow
+def test_shell():
+    constructor = [(20, 80, 0.8), (80, 180, 0.6)]
+    G = nx.random_shell_graph(constructor, seed=42)
+    result = nx.k_components(G)
+    _check_connectivity(G, result)
+
+
+def test_configuration():
+    deg_seq = nx.random_powerlaw_tree_sequence(100, tries=5, seed=72)
+    G = nx.Graph(nx.configuration_model(deg_seq))
+    G.remove_edges_from(nx.selfloop_edges(G))
+    result = nx.k_components(G)
+    _check_connectivity(G, result)
+
+
+def test_karate():
+    G = nx.karate_club_graph()
+    result = nx.k_components(G)
+    _check_connectivity(G, result)
+
+
+def test_karate_component_number():
+    karate_k_num = {
+        0: 4,
+        1: 4,
+        2: 4,
+        3: 4,
+        4: 3,
+        5: 3,
+        6: 3,
+        7: 4,
+        8: 4,
+        9: 2,
+        10: 3,
+        11: 1,
+        12: 2,
+        13: 4,
+        14: 2,
+        15: 2,
+        16: 2,
+        17: 2,
+        18: 2,
+        19: 3,
+        20: 2,
+        21: 2,
+        22: 2,
+        23: 3,
+        24: 3,
+        25: 3,
+        26: 2,
+        27: 3,
+        28: 3,
+        29: 3,
+        30: 4,
+        31: 3,
+        32: 4,
+        33: 4,
+    }
+    G = nx.karate_club_graph()
+    k_components = nx.k_components(G)
+    k_num = build_k_number_dict(k_components)
+    assert karate_k_num == k_num
+
+
+def test_davis_southern_women():
+    G = nx.davis_southern_women_graph()
+    result = nx.k_components(G)
+    _check_connectivity(G, result)
+
+
+def test_davis_southern_women_detail_3_and_4():
+    solution = {
+        3: [
+            {
+                "Nora Fayette",
+                "E10",
+                "Myra Liddel",
+                "E12",
+                "E14",
+                "Frances Anderson",
+                "Evelyn Jefferson",
+                "Ruth DeSand",
+                "Helen Lloyd",
+                "Eleanor Nye",
+                "E9",
+                "E8",
+                "E5",
+                "E4",
+                "E7",
+                "E6",
+                "E1",
+                "Verne Sanderson",
+                "E3",
+                "E2",
+                "Theresa Anderson",
+                "Pearl Oglethorpe",
+                "Katherina Rogers",
+                "Brenda Rogers",
+                "E13",
+                "Charlotte McDowd",
+                "Sylvia Avondale",
+                "Laura Mandeville",
+            }
+        ],
+        4: [
+            {
+                "Nora Fayette",
+                "E10",
+                "Verne Sanderson",
+                "E12",
+                "Frances Anderson",
+                "Evelyn Jefferson",
+                "Ruth DeSand",
+                "Helen Lloyd",
+                "Eleanor Nye",
+                "E9",
+                "E8",
+                "E5",
+                "E4",
+                "E7",
+                "E6",
+                "Myra Liddel",
+                "E3",
+                "Theresa Anderson",
+                "Katherina Rogers",
+                "Brenda Rogers",
+                "Charlotte McDowd",
+                "Sylvia Avondale",
+                "Laura Mandeville",
+            }
+        ],
+    }
+    G = nx.davis_southern_women_graph()
+    result = nx.k_components(G)
+    for k, components in result.items():
+        if k < 3:
+            continue
+        assert len(components) == len(solution[k])
+        for component in components:
+            assert component in solution[k]
+
+
+def test_set_consolidation_rosettacode():
+    # Tests from http://rosettacode.org/wiki/Set_consolidation
+    def list_of_sets_equal(result, solution):
+        assert {frozenset(s) for s in result} == {frozenset(s) for s in solution}
+
+    question = [{"A", "B"}, {"C", "D"}]
+    solution = [{"A", "B"}, {"C", "D"}]
+    list_of_sets_equal(_consolidate(question, 1), solution)
+    question = [{"A", "B"}, {"B", "C"}]
+    solution = [{"A", "B", "C"}]
+    list_of_sets_equal(_consolidate(question, 1), solution)
+    question = [{"A", "B"}, {"C", "D"}, {"D", "B"}]
+    solution = [{"A", "C", "B", "D"}]
+    list_of_sets_equal(_consolidate(question, 1), solution)
+    question = [{"H", "I", "K"}, {"A", "B"}, {"C", "D"}, {"D", "B"}, {"F", "G", "H"}]
+    solution = [{"A", "C", "B", "D"}, {"G", "F", "I", "H", "K"}]
+    list_of_sets_equal(_consolidate(question, 1), solution)
+    question = [
+        {"A", "H"},
+        {"H", "I", "K"},
+        {"A", "B"},
+        {"C", "D"},
+        {"D", "B"},
+        {"F", "G", "H"},
+    ]
+    solution = [{"A", "C", "B", "D", "G", "F", "I", "H", "K"}]
+    list_of_sets_equal(_consolidate(question, 1), solution)
+    question = [
+        {"H", "I", "K"},
+        {"A", "B"},
+        {"C", "D"},
+        {"D", "B"},
+        {"F", "G", "H"},
+        {"A", "H"},
+    ]
+    solution = [{"A", "C", "B", "D", "G", "F", "I", "H", "K"}]
+    list_of_sets_equal(_consolidate(question, 1), solution)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_kcutsets.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_kcutsets.py
new file mode 100644
index 0000000..91426f1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_kcutsets.py
@@ -0,0 +1,267 @@
+# Jordi Torrents
+# Test for k-cutsets
+import itertools
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms import flow
+from networkx.algorithms.connectivity.kcutsets import _is_separating_set
+
+MAX_CUTSETS_TO_TEST = 4  # originally 100. cut to decrease testing time
+
+flow_funcs = [
+    flow.boykov_kolmogorov,
+    flow.dinitz,
+    flow.edmonds_karp,
+    flow.preflow_push,
+    flow.shortest_augmenting_path,
+]
+
+
+##
+# Some nice synthetic graphs
+##
+def graph_example_1():
+    G = nx.convert_node_labels_to_integers(
+        nx.grid_graph([5, 5]), label_attribute="labels"
+    )
+    rlabels = nx.get_node_attributes(G, "labels")
+    labels = {v: k for k, v in rlabels.items()}
+
+    for nodes in [
+        (labels[(0, 0)], labels[(1, 0)]),
+        (labels[(0, 4)], labels[(1, 4)]),
+        (labels[(3, 0)], labels[(4, 0)]),
+        (labels[(3, 4)], labels[(4, 4)]),
+    ]:
+        new_node = G.order() + 1
+        # Petersen graph is triconnected
+        P = nx.petersen_graph()
+        G = nx.disjoint_union(G, P)
+        # Add two edges between the grid and P
+        G.add_edge(new_node + 1, nodes[0])
+        G.add_edge(new_node, nodes[1])
+        # K5 is 4-connected
+        K = nx.complete_graph(5)
+        G = nx.disjoint_union(G, K)
+        # Add three edges between P and K5
+        G.add_edge(new_node + 2, new_node + 11)
+        G.add_edge(new_node + 3, new_node + 12)
+        G.add_edge(new_node + 4, new_node + 13)
+        # Add another K5 sharing a node
+        G = nx.disjoint_union(G, K)
+        nbrs = G[new_node + 10]
+        G.remove_node(new_node + 10)
+        for nbr in nbrs:
+            G.add_edge(new_node + 17, nbr)
+        G.add_edge(new_node + 16, new_node + 5)
+    return G
+
+
+def torrents_and_ferraro_graph():
+    G = nx.convert_node_labels_to_integers(
+        nx.grid_graph([5, 5]), label_attribute="labels"
+    )
+    rlabels = nx.get_node_attributes(G, "labels")
+    labels = {v: k for k, v in rlabels.items()}
+
+    for nodes in [(labels[(0, 4)], labels[(1, 4)]), (labels[(3, 4)], labels[(4, 4)])]:
+        new_node = G.order() + 1
+        # Petersen graph is triconnected
+        P = nx.petersen_graph()
+        G = nx.disjoint_union(G, P)
+        # Add two edges between the grid and P
+        G.add_edge(new_node + 1, nodes[0])
+        G.add_edge(new_node, nodes[1])
+        # K5 is 4-connected
+        K = nx.complete_graph(5)
+        G = nx.disjoint_union(G, K)
+        # Add three edges between P and K5
+        G.add_edge(new_node + 2, new_node + 11)
+        G.add_edge(new_node + 3, new_node + 12)
+        G.add_edge(new_node + 4, new_node + 13)
+        # Add another K5 sharing a node
+        G = nx.disjoint_union(G, K)
+        nbrs = G[new_node + 10]
+        G.remove_node(new_node + 10)
+        for nbr in nbrs:
+            G.add_edge(new_node + 17, nbr)
+        # Commenting this makes the graph not biconnected !!
+        # This stupid mistake make one reviewer very angry :P
+        G.add_edge(new_node + 16, new_node + 8)
+
+    for nodes in [(labels[(0, 0)], labels[(1, 0)]), (labels[(3, 0)], labels[(4, 0)])]:
+        new_node = G.order() + 1
+        # Petersen graph is triconnected
+        P = nx.petersen_graph()
+        G = nx.disjoint_union(G, P)
+        # Add two edges between the grid and P
+        G.add_edge(new_node + 1, nodes[0])
+        G.add_edge(new_node, nodes[1])
+        # K5 is 4-connected
+        K = nx.complete_graph(5)
+        G = nx.disjoint_union(G, K)
+        # Add three edges between P and K5
+        G.add_edge(new_node + 2, new_node + 11)
+        G.add_edge(new_node + 3, new_node + 12)
+        G.add_edge(new_node + 4, new_node + 13)
+        # Add another K5 sharing two nodes
+        G = nx.disjoint_union(G, K)
+        nbrs = G[new_node + 10]
+        G.remove_node(new_node + 10)
+        for nbr in nbrs:
+            G.add_edge(new_node + 17, nbr)
+        nbrs2 = G[new_node + 9]
+        G.remove_node(new_node + 9)
+        for nbr in nbrs2:
+            G.add_edge(new_node + 18, nbr)
+    return G
+
+
+# Helper function
+def _check_separating_sets(G):
+    for cc in nx.connected_components(G):
+        if len(cc) < 3:
+            continue
+        Gc = G.subgraph(cc)
+        node_conn = nx.node_connectivity(Gc)
+        all_cuts = nx.all_node_cuts(Gc)
+        # Only test a limited number of cut sets to reduce test time.
+        for cut in itertools.islice(all_cuts, MAX_CUTSETS_TO_TEST):
+            assert node_conn == len(cut)
+            assert not nx.is_connected(nx.restricted_view(G, cut, []))
+
+
+@pytest.mark.slow
+def test_torrents_and_ferraro_graph():
+    G = torrents_and_ferraro_graph()
+    _check_separating_sets(G)
+
+
+def test_example_1():
+    G = graph_example_1()
+    _check_separating_sets(G)
+
+
+def test_random_gnp():
+    G = nx.gnp_random_graph(100, 0.1, seed=42)
+    _check_separating_sets(G)
+
+
+def test_shell():
+    constructor = [(20, 80, 0.8), (80, 180, 0.6)]
+    G = nx.random_shell_graph(constructor, seed=42)
+    _check_separating_sets(G)
+
+
+def test_configuration():
+    deg_seq = nx.random_powerlaw_tree_sequence(100, tries=5, seed=72)
+    G = nx.Graph(nx.configuration_model(deg_seq))
+    G.remove_edges_from(nx.selfloop_edges(G))
+    _check_separating_sets(G)
+
+
+def test_karate():
+    G = nx.karate_club_graph()
+    _check_separating_sets(G)
+
+
+def _generate_no_biconnected(max_attempts=50):
+    attempts = 0
+    while True:
+        G = nx.fast_gnp_random_graph(100, 0.0575, seed=42)
+        if nx.is_connected(G) and not nx.is_biconnected(G):
+            attempts = 0
+            yield G
+        else:
+            if attempts >= max_attempts:
+                msg = f"Tried {attempts} times: no suitable Graph."
+                raise Exception(msg)
+            else:
+                attempts += 1
+
+
+def test_articulation_points():
+    Ggen = _generate_no_biconnected()
+    for i in range(1):  # change 1 to 3 or more for more realizations.
+        G = next(Ggen)
+        articulation_points = list({a} for a in nx.articulation_points(G))
+        for cut in nx.all_node_cuts(G):
+            assert cut in articulation_points
+
+
+def test_grid_2d_graph():
+    # All minimum node cuts of a 2d grid
+    # are the four pairs of nodes that are
+    # neighbors of the four corner nodes.
+    G = nx.grid_2d_graph(5, 5)
+    solution = [{(0, 1), (1, 0)}, {(3, 0), (4, 1)}, {(3, 4), (4, 3)}, {(0, 3), (1, 4)}]
+    for cut in nx.all_node_cuts(G):
+        assert cut in solution
+
+
+def test_disconnected_graph():
+    G = nx.fast_gnp_random_graph(100, 0.01, seed=42)
+    cuts = nx.all_node_cuts(G)
+    pytest.raises(nx.NetworkXError, next, cuts)
+
+
+@pytest.mark.slow
+def test_alternative_flow_functions():
+    graphs = [nx.grid_2d_graph(4, 4), nx.cycle_graph(5)]
+    for G in graphs:
+        node_conn = nx.node_connectivity(G)
+        for flow_func in flow_funcs:
+            all_cuts = nx.all_node_cuts(G, flow_func=flow_func)
+            # Only test a limited number of cut sets to reduce test time.
+            for cut in itertools.islice(all_cuts, MAX_CUTSETS_TO_TEST):
+                assert node_conn == len(cut)
+                assert not nx.is_connected(nx.restricted_view(G, cut, []))
+
+
+def test_is_separating_set_complete_graph():
+    G = nx.complete_graph(5)
+    assert _is_separating_set(G, {0, 1, 2, 3})
+
+
+def test_is_separating_set():
+    for i in [5, 10, 15]:
+        G = nx.star_graph(i)
+        max_degree_node = max(G, key=G.degree)
+        assert _is_separating_set(G, {max_degree_node})
+
+
+def test_non_repeated_cuts():
+    # The algorithm was repeating the cut {0, 1} for the giant biconnected
+    # component of the Karate club graph.
+    K = nx.karate_club_graph()
+    bcc = max(list(nx.biconnected_components(K)), key=len)
+    G = K.subgraph(bcc)
+    solution = [{32, 33}, {2, 33}, {0, 3}, {0, 1}, {29, 33}]
+    cuts = list(nx.all_node_cuts(G))
+    if len(solution) != len(cuts):
+        print(nx.info(G))
+        print(f"Solution: {solution}")
+        print(f"Result: {cuts}")
+    assert len(solution) == len(cuts)
+    for cut in cuts:
+        assert cut in solution
+
+
+def test_cycle_graph():
+    G = nx.cycle_graph(5)
+    solution = [{0, 2}, {0, 3}, {1, 3}, {1, 4}, {2, 4}]
+    cuts = list(nx.all_node_cuts(G))
+    assert len(solution) == len(cuts)
+    for cut in cuts:
+        assert cut in solution
+
+
+def test_complete_graph():
+    G = nx.complete_graph(5)
+    solution = [{0, 1, 2, 3}, {0, 1, 2, 4}, {0, 1, 3, 4}, {0, 2, 3, 4}, {1, 2, 3, 4}]
+    cuts = list(nx.all_node_cuts(G))
+    assert len(solution) == len(cuts)
+    for cut in cuts:
+        assert cut in solution
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_stoer_wagner.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_stoer_wagner.py
new file mode 100644
index 0000000..2b9e2ba
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/tests/test_stoer_wagner.py
@@ -0,0 +1,102 @@
+from itertools import chain
+
+import pytest
+
+import networkx as nx
+
+
+def _check_partition(G, cut_value, partition, weight):
+    assert isinstance(partition, tuple)
+    assert len(partition) == 2
+    assert isinstance(partition[0], list)
+    assert isinstance(partition[1], list)
+    assert len(partition[0]) > 0
+    assert len(partition[1]) > 0
+    assert sum(map(len, partition)) == len(G)
+    assert set(chain.from_iterable(partition)) == set(G)
+    partition = tuple(map(set, partition))
+    w = 0
+    for u, v, e in G.edges(data=True):
+        if (u in partition[0]) == (v in partition[1]):
+            w += e.get(weight, 1)
+    assert w == cut_value
+
+
+def _test_stoer_wagner(G, answer, weight="weight"):
+    cut_value, partition = nx.stoer_wagner(G, weight, heap=nx.utils.PairingHeap)
+    assert cut_value == answer
+    _check_partition(G, cut_value, partition, weight)
+    cut_value, partition = nx.stoer_wagner(G, weight, heap=nx.utils.BinaryHeap)
+    assert cut_value == answer
+    _check_partition(G, cut_value, partition, weight)
+
+
+def test_graph1():
+    G = nx.Graph()
+    G.add_edge("x", "a", weight=3)
+    G.add_edge("x", "b", weight=1)
+    G.add_edge("a", "c", weight=3)
+    G.add_edge("b", "c", weight=5)
+    G.add_edge("b", "d", weight=4)
+    G.add_edge("d", "e", weight=2)
+    G.add_edge("c", "y", weight=2)
+    G.add_edge("e", "y", weight=3)
+    _test_stoer_wagner(G, 4)
+
+
+def test_graph2():
+    G = nx.Graph()
+    G.add_edge("x", "a")
+    G.add_edge("x", "b")
+    G.add_edge("a", "c")
+    G.add_edge("b", "c")
+    G.add_edge("b", "d")
+    G.add_edge("d", "e")
+    G.add_edge("c", "y")
+    G.add_edge("e", "y")
+    _test_stoer_wagner(G, 2)
+
+
+def test_graph3():
+    # Source:
+    # Stoer, M. and Wagner, F. (1997). "A simple min-cut algorithm". Journal of
+    # the ACM 44 (4), 585-591.
+    G = nx.Graph()
+    G.add_edge(1, 2, weight=2)
+    G.add_edge(1, 5, weight=3)
+    G.add_edge(2, 3, weight=3)
+    G.add_edge(2, 5, weight=2)
+    G.add_edge(2, 6, weight=2)
+    G.add_edge(3, 4, weight=4)
+    G.add_edge(3, 7, weight=2)
+    G.add_edge(4, 7, weight=2)
+    G.add_edge(4, 8, weight=2)
+    G.add_edge(5, 6, weight=3)
+    G.add_edge(6, 7, weight=1)
+    G.add_edge(7, 8, weight=3)
+    _test_stoer_wagner(G, 4)
+
+
+def test_weight_name():
+    G = nx.Graph()
+    G.add_edge(1, 2, weight=1, cost=8)
+    G.add_edge(1, 3, cost=2)
+    G.add_edge(2, 3, cost=4)
+    _test_stoer_wagner(G, 6, weight="cost")
+
+
+def test_exceptions():
+    G = nx.Graph()
+    pytest.raises(nx.NetworkXError, nx.stoer_wagner, G)
+    G.add_node(1)
+    pytest.raises(nx.NetworkXError, nx.stoer_wagner, G)
+    G.add_node(2)
+    pytest.raises(nx.NetworkXError, nx.stoer_wagner, G)
+    G.add_edge(1, 2, weight=-2)
+    pytest.raises(nx.NetworkXError, nx.stoer_wagner, G)
+    G = nx.DiGraph()
+    pytest.raises(nx.NetworkXNotImplemented, nx.stoer_wagner, G)
+    G = nx.MultiGraph()
+    pytest.raises(nx.NetworkXNotImplemented, nx.stoer_wagner, G)
+    G = nx.MultiDiGraph()
+    pytest.raises(nx.NetworkXNotImplemented, nx.stoer_wagner, G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/utils.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/utils.py
new file mode 100644
index 0000000..06d2fdc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/connectivity/utils.py
@@ -0,0 +1,85 @@
+"""
+Utilities for connectivity package
+"""
+import networkx as nx
+
+__all__ = ["build_auxiliary_node_connectivity", "build_auxiliary_edge_connectivity"]
+
+
+def build_auxiliary_node_connectivity(G):
+    r"""Creates a directed graph D from an undirected graph G to compute flow
+    based node connectivity.
+
+    For an undirected graph G having `n` nodes and `m` edges we derive a
+    directed graph D with `2n` nodes and `2m+n` arcs by replacing each
+    original node `v` with two nodes `vA`, `vB` linked by an (internal)
+    arc in D. Then for each edge (`u`, `v`) in G we add two arcs (`uB`, `vA`)
+    and (`vB`, `uA`) in D. Finally we set the attribute capacity = 1 for each
+    arc in D [1]_.
+
+    For a directed graph having `n` nodes and `m` arcs we derive a
+    directed graph D with `2n` nodes and `m+n` arcs by replacing each
+    original node `v` with two nodes `vA`, `vB` linked by an (internal)
+    arc (`vA`, `vB`) in D. Then for each arc (`u`, `v`) in G we add one
+    arc (`uB`, `vA`) in D. Finally we set the attribute capacity = 1 for
+    each arc in D.
+
+    A dictionary with a mapping between nodes in the original graph and the
+    auxiliary digraph is stored as a graph attribute: H.graph['mapping'].
+
+    References
+    ----------
+    .. [1] Kammer, Frank and Hanjo Taubig. Graph Connectivity. in Brandes and
+        Erlebach, 'Network Analysis: Methodological Foundations', Lecture
+        Notes in Computer Science, Volume 3418, Springer-Verlag, 2005.
+        https://doi.org/10.1007/978-3-540-31955-9_7
+
+    """
+    directed = G.is_directed()
+
+    mapping = {}
+    H = nx.DiGraph()
+
+    for i, node in enumerate(G):
+        mapping[node] = i
+        H.add_node(f"{i}A", id=node)
+        H.add_node(f"{i}B", id=node)
+        H.add_edge(f"{i}A", f"{i}B", capacity=1)
+
+    edges = []
+    for (source, target) in G.edges():
+        edges.append((f"{mapping[source]}B", f"{mapping[target]}A"))
+        if not directed:
+            edges.append((f"{mapping[target]}B", f"{mapping[source]}A"))
+    H.add_edges_from(edges, capacity=1)
+
+    # Store mapping as graph attribute
+    H.graph["mapping"] = mapping
+    return H
+
+
+def build_auxiliary_edge_connectivity(G):
+    """Auxiliary digraph for computing flow based edge connectivity
+
+    If the input graph is undirected, we replace each edge (`u`,`v`) with
+    two reciprocal arcs (`u`, `v`) and (`v`, `u`) and then we set the attribute
+    'capacity' for each arc to 1. If the input graph is directed we simply
+    add the 'capacity' attribute. Part of algorithm 1 in [1]_ .
+
+    References
+    ----------
+    .. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms. (this is a
+        chapter, look for the reference of the book).
+        http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
+    """
+    if G.is_directed():
+        H = nx.DiGraph()
+        H.add_nodes_from(G.nodes())
+        H.add_edges_from(G.edges(), capacity=1)
+        return H
+    else:
+        H = nx.DiGraph()
+        H.add_nodes_from(G.nodes())
+        for (source, target) in G.edges():
+            H.add_edges_from([(source, target), (target, source)], capacity=1)
+        return H
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/core.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/core.py
new file mode 100644
index 0000000..e39eb84
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/core.py
@@ -0,0 +1,544 @@
+"""
+Find the k-cores of a graph.
+
+The k-core is found by recursively pruning nodes with degrees less than k.
+
+See the following references for details:
+
+An O(m) Algorithm for Cores Decomposition of Networks
+Vladimir Batagelj and Matjaz Zaversnik, 2003.
+https://arxiv.org/abs/cs.DS/0310049
+
+Generalized Cores
+Vladimir Batagelj and Matjaz Zaversnik, 2002.
+https://arxiv.org/pdf/cs/0202039
+
+For directed graphs a more general notion is that of D-cores which
+looks at (k, l) restrictions on (in, out) degree. The (k, k) D-core
+is the k-core.
+
+D-cores: Measuring Collaboration of Directed Graphs Based on Degeneracy
+Christos Giatsidis, Dimitrios M. Thilikos, Michalis Vazirgiannis, ICDM 2011.
+http://www.graphdegeneracy.org/dcores_ICDM_2011.pdf
+
+Multi-scale structure and topological anomaly detection via a new network \
+statistic: The onion decomposition
+L. Hébert-Dufresne, J. A. Grochow, and A. Allard
+Scientific Reports 6, 31708 (2016)
+http://doi.org/10.1038/srep31708
+
+"""
+import networkx as nx
+from networkx.exception import NetworkXError
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "core_number",
+    "find_cores",
+    "k_core",
+    "k_shell",
+    "k_crust",
+    "k_corona",
+    "k_truss",
+    "onion_layers",
+]
+
+
+@not_implemented_for("multigraph")
+def core_number(G):
+    """Returns the core number for each vertex.
+
+    A k-core is a maximal subgraph that contains nodes of degree k or more.
+
+    The core number of a node is the largest value k of a k-core containing
+    that node.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph or directed graph
+
+    Returns
+    -------
+    core_number : dictionary
+       A dictionary keyed by node to the core number.
+
+    Raises
+    ------
+    NetworkXError
+        The k-core is not implemented for graphs with self loops
+        or parallel edges.
+
+    Notes
+    -----
+    Not implemented for graphs with parallel edges or self loops.
+
+    For directed graphs the node degree is defined to be the
+    in-degree + out-degree.
+
+    References
+    ----------
+    .. [1] An O(m) Algorithm for Cores Decomposition of Networks
+       Vladimir Batagelj and Matjaz Zaversnik, 2003.
+       https://arxiv.org/abs/cs.DS/0310049
+    """
+    if nx.number_of_selfloops(G) > 0:
+        msg = (
+            "Input graph has self loops which is not permitted; "
+            "Consider using G.remove_edges_from(nx.selfloop_edges(G))."
+        )
+        raise NetworkXError(msg)
+    degrees = dict(G.degree())
+    # Sort nodes by degree.
+    nodes = sorted(degrees, key=degrees.get)
+    bin_boundaries = [0]
+    curr_degree = 0
+    for i, v in enumerate(nodes):
+        if degrees[v] > curr_degree:
+            bin_boundaries.extend([i] * (degrees[v] - curr_degree))
+            curr_degree = degrees[v]
+    node_pos = {v: pos for pos, v in enumerate(nodes)}
+    # The initial guess for the core number of a node is its degree.
+    core = degrees
+    nbrs = {v: list(nx.all_neighbors(G, v)) for v in G}
+    for v in nodes:
+        for u in nbrs[v]:
+            if core[u] > core[v]:
+                nbrs[u].remove(v)
+                pos = node_pos[u]
+                bin_start = bin_boundaries[core[u]]
+                node_pos[u] = bin_start
+                node_pos[nodes[bin_start]] = pos
+                nodes[bin_start], nodes[pos] = nodes[pos], nodes[bin_start]
+                bin_boundaries[core[u]] += 1
+                core[u] -= 1
+    return core
+
+
+def find_cores(G):
+    import warnings
+
+    msg = (
+        "\nfind_cores is deprecated as of version 2.7 and will be removed "
+        "in version 3.0.\n"
+        "The find_cores function is renamed core_number\n"
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    return nx.core_number(G)
+
+
+def _core_subgraph(G, k_filter, k=None, core=None):
+    """Returns the subgraph induced by nodes passing filter `k_filter`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       The graph or directed graph to process
+    k_filter : filter function
+       This function filters the nodes chosen. It takes three inputs:
+       A node of G, the filter's cutoff, and the core dict of the graph.
+       The function should return a Boolean value.
+    k : int, optional
+      The order of the core. If not specified use the max core number.
+      This value is used as the cutoff for the filter.
+    core : dict, optional
+      Precomputed core numbers keyed by node for the graph `G`.
+      If not specified, the core numbers will be computed from `G`.
+
+    """
+    if core is None:
+        core = core_number(G)
+    if k is None:
+        k = max(core.values())
+    nodes = (v for v in core if k_filter(v, k, core))
+    return G.subgraph(nodes).copy()
+
+
+def k_core(G, k=None, core_number=None):
+    """Returns the k-core of G.
+
+    A k-core is a maximal subgraph that contains nodes of degree k or more.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+      A graph or directed graph
+    k : int, optional
+      The order of the core.  If not specified return the main core.
+    core_number : dictionary, optional
+      Precomputed core numbers for the graph G.
+
+    Returns
+    -------
+    G : NetworkX graph
+      The k-core subgraph
+
+    Raises
+    ------
+    NetworkXError
+      The k-core is not defined for graphs with self loops or parallel edges.
+
+    Notes
+    -----
+    The main core is the core with the largest degree.
+
+    Not implemented for graphs with parallel edges or self loops.
+
+    For directed graphs the node degree is defined to be the
+    in-degree + out-degree.
+
+    Graph, node, and edge attributes are copied to the subgraph.
+
+    See Also
+    --------
+    core_number
+
+    References
+    ----------
+    .. [1] An O(m) Algorithm for Cores Decomposition of Networks
+       Vladimir Batagelj and Matjaz Zaversnik,  2003.
+       https://arxiv.org/abs/cs.DS/0310049
+    """
+
+    def k_filter(v, k, c):
+        return c[v] >= k
+
+    return _core_subgraph(G, k_filter, k, core_number)
+
+
+def k_shell(G, k=None, core_number=None):
+    """Returns the k-shell of G.
+
+    The k-shell is the subgraph induced by nodes with core number k.
+    That is, nodes in the k-core that are not in the (k+1)-core.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+      A graph or directed graph.
+    k : int, optional
+      The order of the shell. If not specified return the outer shell.
+    core_number : dictionary, optional
+      Precomputed core numbers for the graph G.
+
+
+    Returns
+    -------
+    G : NetworkX graph
+       The k-shell subgraph
+
+    Raises
+    ------
+    NetworkXError
+        The k-shell is not implemented for graphs with self loops
+        or parallel edges.
+
+    Notes
+    -----
+    This is similar to k_corona but in that case only neighbors in the
+    k-core are considered.
+
+    Not implemented for graphs with parallel edges or self loops.
+
+    For directed graphs the node degree is defined to be the
+    in-degree + out-degree.
+
+    Graph, node, and edge attributes are copied to the subgraph.
+
+    See Also
+    --------
+    core_number
+    k_corona
+
+
+    References
+    ----------
+    .. [1] A model of Internet topology using k-shell decomposition
+       Shai Carmi, Shlomo Havlin, Scott Kirkpatrick, Yuval Shavitt,
+       and Eran Shir, PNAS  July 3, 2007   vol. 104  no. 27  11150-11154
+       http://www.pnas.org/content/104/27/11150.full
+    """
+
+    def k_filter(v, k, c):
+        return c[v] == k
+
+    return _core_subgraph(G, k_filter, k, core_number)
+
+
+def k_crust(G, k=None, core_number=None):
+    """Returns the k-crust of G.
+
+    The k-crust is the graph G with the edges of the k-core removed
+    and isolated nodes found after the removal of edges are also removed.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph or directed graph.
+    k : int, optional
+      The order of the shell.  If not specified return the main crust.
+    core_number : dictionary, optional
+      Precomputed core numbers for the graph G.
+
+    Returns
+    -------
+    G : NetworkX graph
+       The k-crust subgraph
+
+    Raises
+    ------
+    NetworkXError
+        The k-crust is not implemented for graphs with self loops
+        or parallel edges.
+
+    Notes
+    -----
+    This definition of k-crust is different than the definition in [1]_.
+    The k-crust in [1]_ is equivalent to the k+1 crust of this algorithm.
+
+    Not implemented for graphs with parallel edges or self loops.
+
+    For directed graphs the node degree is defined to be the
+    in-degree + out-degree.
+
+    Graph, node, and edge attributes are copied to the subgraph.
+
+    See Also
+    --------
+    core_number
+
+    References
+    ----------
+    .. [1] A model of Internet topology using k-shell decomposition
+       Shai Carmi, Shlomo Havlin, Scott Kirkpatrick, Yuval Shavitt,
+       and Eran Shir, PNAS  July 3, 2007   vol. 104  no. 27  11150-11154
+       http://www.pnas.org/content/104/27/11150.full
+    """
+    # Default for k is one less than in _core_subgraph, so just inline.
+    #    Filter is c[v] <= k
+    if core_number is None:
+        core_number = nx.core_number(G)
+    if k is None:
+        k = max(core_number.values()) - 1
+    nodes = (v for v in core_number if core_number[v] <= k)
+    return G.subgraph(nodes).copy()
+
+
+def k_corona(G, k, core_number=None):
+    """Returns the k-corona of G.
+
+    The k-corona is the subgraph of nodes in the k-core which have
+    exactly k neighbours in the k-core.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph or directed graph
+    k : int
+       The order of the corona.
+    core_number : dictionary, optional
+       Precomputed core numbers for the graph G.
+
+    Returns
+    -------
+    G : NetworkX graph
+       The k-corona subgraph
+
+    Raises
+    ------
+    NetworkXError
+        The k-cornoa is not defined for graphs with self loops or
+        parallel edges.
+
+    Notes
+    -----
+    Not implemented for graphs with parallel edges or self loops.
+
+    For directed graphs the node degree is defined to be the
+    in-degree + out-degree.
+
+    Graph, node, and edge attributes are copied to the subgraph.
+
+    See Also
+    --------
+    core_number
+
+    References
+    ----------
+    .. [1]  k -core (bootstrap) percolation on complex networks:
+       Critical phenomena and nonlocal effects,
+       A. V. Goltsev, S. N. Dorogovtsev, and J. F. F. Mendes,
+       Phys. Rev. E 73, 056101 (2006)
+       http://link.aps.org/doi/10.1103/PhysRevE.73.056101
+    """
+
+    def func(v, k, c):
+        return c[v] == k and k == sum(1 for w in G[v] if c[w] >= k)
+
+    return _core_subgraph(G, func, k, core_number)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def k_truss(G, k):
+    """Returns the k-truss of `G`.
+
+    The k-truss is the maximal induced subgraph of `G` which contains at least
+    three vertices where every edge is incident to at least `k-2` triangles.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+      An undirected graph
+    k : int
+      The order of the truss
+
+    Returns
+    -------
+    H : NetworkX graph
+      The k-truss subgraph
+
+    Raises
+    ------
+    NetworkXError
+
+      The k-truss is not defined for graphs with self loops or parallel edges
+      or directed graphs.
+
+    Notes
+    -----
+    A k-clique is a (k-2)-truss and a k-truss is a (k+1)-core.
+
+    Not implemented for digraphs or graphs with parallel edges or self loops.
+
+    Graph, node, and edge attributes are copied to the subgraph.
+
+    K-trusses were originally defined in [2] which states that the k-truss
+    is the maximal induced subgraph where each edge belongs to at least
+    `k-2` triangles. A more recent paper, [1], uses a slightly different
+    definition requiring that each edge belong to at least `k` triangles.
+    This implementation uses the original definition of `k-2` triangles.
+
+    References
+    ----------
+    .. [1] Bounds and Algorithms for k-truss. Paul Burkhardt, Vance Faber,
+       David G. Harris, 2018. https://arxiv.org/abs/1806.05523v2
+    .. [2] Trusses: Cohesive Subgraphs for Social Network Analysis. Jonathan
+       Cohen, 2005.
+    """
+    H = G.copy()
+
+    n_dropped = 1
+    while n_dropped > 0:
+        n_dropped = 0
+        to_drop = []
+        seen = set()
+        for u in H:
+            nbrs_u = set(H[u])
+            seen.add(u)
+            new_nbrs = [v for v in nbrs_u if v not in seen]
+            for v in new_nbrs:
+                if len(nbrs_u & set(H[v])) < (k - 2):
+                    to_drop.append((u, v))
+        H.remove_edges_from(to_drop)
+        n_dropped = len(to_drop)
+        H.remove_nodes_from(list(nx.isolates(H)))
+
+    return H
+
+
+@not_implemented_for("multigraph")
+@not_implemented_for("directed")
+def onion_layers(G):
+    """Returns the layer of each vertex in an onion decomposition of the graph.
+
+    The onion decomposition refines the k-core decomposition by providing
+    information on the internal organization of each k-shell. It is usually
+    used alongside the `core numbers`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A simple graph without self loops or parallel edges
+
+    Returns
+    -------
+    od_layers : dictionary
+        A dictionary keyed by vertex to the onion layer. The layers are
+        contiguous integers starting at 1.
+
+    Raises
+    ------
+    NetworkXError
+        The onion decomposition is not implemented for graphs with self loops
+        or parallel edges or for directed graphs.
+
+    Notes
+    -----
+    Not implemented for graphs with parallel edges or self loops.
+
+    Not implemented for directed graphs.
+
+    See Also
+    --------
+    core_number
+
+    References
+    ----------
+    .. [1] Multi-scale structure and topological anomaly detection via a new
+       network statistic: The onion decomposition
+       L. Hébert-Dufresne, J. A. Grochow, and A. Allard
+       Scientific Reports 6, 31708 (2016)
+       http://doi.org/10.1038/srep31708
+    .. [2] Percolation and the effective structure of complex networks
+       A. Allard and L. Hébert-Dufresne
+       Physical Review X 9, 011023 (2019)
+       http://doi.org/10.1103/PhysRevX.9.011023
+    """
+    if nx.number_of_selfloops(G) > 0:
+        msg = (
+            "Input graph contains self loops which is not permitted; "
+            "Consider using G.remove_edges_from(nx.selfloop_edges(G))."
+        )
+        raise NetworkXError(msg)
+    # Dictionaries to register the k-core/onion decompositions.
+    od_layers = {}
+    # Adjacency list
+    neighbors = {v: list(nx.all_neighbors(G, v)) for v in G}
+    # Effective degree of nodes.
+    degrees = dict(G.degree())
+    # Performs the onion decomposition.
+    current_core = 1
+    current_layer = 1
+    # Sets vertices of degree 0 to layer 1, if any.
+    isolated_nodes = [v for v in nx.isolates(G)]
+    if len(isolated_nodes) > 0:
+        for v in isolated_nodes:
+            od_layers[v] = current_layer
+            degrees.pop(v)
+        current_layer = 2
+    # Finds the layer for the remaining nodes.
+    while len(degrees) > 0:
+        # Sets the order for looking at nodes.
+        nodes = sorted(degrees, key=degrees.get)
+        # Sets properly the current core.
+        min_degree = degrees[nodes[0]]
+        if min_degree > current_core:
+            current_core = min_degree
+        # Identifies vertices in the current layer.
+        this_layer = []
+        for n in nodes:
+            if degrees[n] > current_core:
+                break
+            this_layer.append(n)
+        # Identifies the core/layer of the vertices in the current layer.
+        for v in this_layer:
+            od_layers[v] = current_layer
+            for n in neighbors[v]:
+                neighbors[n].remove(v)
+                degrees[n] = degrees[n] - 1
+            degrees.pop(v)
+        # Updates the layer count.
+        current_layer = current_layer + 1
+    # Returns the dictionaries containing the onion layer of each vertices.
+    return od_layers
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/covering.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/covering.py
new file mode 100644
index 0000000..b683128
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/covering.py
@@ -0,0 +1,140 @@
+""" Functions related to graph covers."""
+
+from functools import partial
+from itertools import chain
+
+import networkx as nx
+from networkx.utils import arbitrary_element, not_implemented_for
+
+__all__ = ["min_edge_cover", "is_edge_cover"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def min_edge_cover(G, matching_algorithm=None):
+    """Returns the min cardinality edge cover of the graph as a set of edges.
+
+    A smallest edge cover can be found in polynomial time by finding
+    a maximum matching and extending it greedily so that all nodes
+    are covered. This function follows that process. A maximum matching
+    algorithm can be specified for the first step of the algorithm.
+    The resulting set may return a set with one 2-tuple for each edge,
+    (the usual case) or with both 2-tuples `(u, v)` and `(v, u)` for
+    each edge. The latter is only done when a bipartite matching algorithm
+    is specified as `matching_algorithm`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+
+    matching_algorithm : function
+        A function that returns a maximum cardinality matching for `G`.
+        The function must take one input, the graph `G`, and return
+        either a set of edges (with only one direction for the pair of nodes)
+        or a dictionary mapping each node to its mate. If not specified,
+        :func:`~networkx.algorithms.matching.max_weight_matching` is used.
+        Common bipartite matching functions include
+        :func:`~networkx.algorithms.bipartite.matching.hopcroft_karp_matching`
+        or
+        :func:`~networkx.algorithms.bipartite.matching.eppstein_matching`.
+
+    Returns
+    -------
+    min_cover : set
+
+        A set of the edges in a minimum edge cover in the form of tuples.
+        It contains only one of the equivalent 2-tuples `(u, v)` and `(v, u)`
+        for each edge. If a bipartite method is used to compute the matching,
+        the returned set contains both the 2-tuples `(u, v)` and `(v, u)`
+        for each edge of a minimum edge cover.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3)])
+    >>> sorted(nx.min_edge_cover(G))
+    [(2, 1), (3, 0)]
+
+    Notes
+    -----
+    An edge cover of a graph is a set of edges such that every node of
+    the graph is incident to at least one edge of the set.
+    The minimum edge cover is an edge covering of smallest cardinality.
+
+    Due to its implementation, the worst-case running time of this algorithm
+    is bounded by the worst-case running time of the function
+    ``matching_algorithm``.
+
+    Minimum edge cover for `G` can also be found using the `min_edge_covering`
+    function in :mod:`networkx.algorithms.bipartite.covering` which is
+    simply this function with a default matching algorithm of
+    :func:`~networkx.algorithms.bipartite.matching.hopcraft_karp_matching`
+    """
+    if len(G) == 0:
+        return set()
+    if nx.number_of_isolates(G) > 0:
+        # ``min_cover`` does not exist as there is an isolated node
+        raise nx.NetworkXException(
+            "Graph has a node with no edge incident on it, " "so no edge cover exists."
+        )
+    if matching_algorithm is None:
+        matching_algorithm = partial(nx.max_weight_matching, maxcardinality=True)
+    maximum_matching = matching_algorithm(G)
+    # ``min_cover`` is superset of ``maximum_matching``
+    try:
+        # bipartite matching algs return dict so convert if needed
+        min_cover = set(maximum_matching.items())
+        bipartite_cover = True
+    except AttributeError:
+        min_cover = maximum_matching
+        bipartite_cover = False
+    # iterate for uncovered nodes
+    uncovered_nodes = set(G) - {v for u, v in min_cover} - {u for u, v in min_cover}
+    for v in uncovered_nodes:
+        # Since `v` is uncovered, each edge incident to `v` will join it
+        # with a covered node (otherwise, if there were an edge joining
+        # uncovered nodes `u` and `v`, the maximum matching algorithm
+        # would have found it), so we can choose an arbitrary edge
+        # incident to `v`. (This applies only in a simple graph, not a
+        # multigraph.)
+        u = arbitrary_element(G[v])
+        min_cover.add((u, v))
+        if bipartite_cover:
+            min_cover.add((v, u))
+    return min_cover
+
+
+@not_implemented_for("directed")
+def is_edge_cover(G, cover):
+    """Decides whether a set of edges is a valid edge cover of the graph.
+
+    Given a set of edges, whether it is an edge covering can
+    be decided if we just check whether all nodes of the graph
+    has an edge from the set, incident on it.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected bipartite graph.
+
+    cover : set
+        Set of edges to be checked.
+
+    Returns
+    -------
+    bool
+        Whether the set of edges is a valid edge cover of the graph.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3)])
+    >>> cover = {(2, 1), (3, 0)}
+    >>> nx.is_edge_cover(G, cover)
+    True
+
+    Notes
+    -----
+    An edge cover of a graph is a set of edges such that every node of
+    the graph is incident to at least one edge of the set.
+    """
+    return set(G) <= set(chain.from_iterable(cover))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/cuts.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/cuts.py
new file mode 100644
index 0000000..ae1cb02
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/cuts.py
@@ -0,0 +1,392 @@
+"""Functions for finding and evaluating cuts in a graph.
+
+"""
+
+from itertools import chain
+
+import networkx as nx
+
+__all__ = [
+    "boundary_expansion",
+    "conductance",
+    "cut_size",
+    "edge_expansion",
+    "mixing_expansion",
+    "node_expansion",
+    "normalized_cut_size",
+    "volume",
+]
+
+
+# TODO STILL NEED TO UPDATE ALL THE DOCUMENTATION!
+
+
+def cut_size(G, S, T=None, weight=None):
+    """Returns the size of the cut between two sets of nodes.
+
+    A *cut* is a partition of the nodes of a graph into two sets. The
+    *cut size* is the sum of the weights of the edges "between" the two
+    sets of nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    S : collection
+        A collection of nodes in `G`.
+
+    T : collection
+        A collection of nodes in `G`. If not specified, this is taken to
+        be the set complement of `S`.
+
+    weight : object
+        Edge attribute key to use as weight. If not specified, edges
+        have weight one.
+
+    Returns
+    -------
+    number
+        Total weight of all edges from nodes in set `S` to nodes in
+        set `T` (and, in the case of directed graphs, all edges from
+        nodes in `T` to nodes in `S`).
+
+    Examples
+    --------
+    In the graph with two cliques joined by a single edges, the natural
+    bipartition of the graph into two blocks, one for each clique,
+    yields a cut of weight one::
+
+        >>> G = nx.barbell_graph(3, 0)
+        >>> S = {0, 1, 2}
+        >>> T = {3, 4, 5}
+        >>> nx.cut_size(G, S, T)
+        1
+
+    Each parallel edge in a multigraph is counted when determining the
+    cut size::
+
+        >>> G = nx.MultiGraph(["ab", "ab"])
+        >>> S = {"a"}
+        >>> T = {"b"}
+        >>> nx.cut_size(G, S, T)
+        2
+
+    Notes
+    -----
+    In a multigraph, the cut size is the total weight of edges including
+    multiplicity.
+
+    """
+    edges = nx.edge_boundary(G, S, T, data=weight, default=1)
+    if G.is_directed():
+        edges = chain(edges, nx.edge_boundary(G, T, S, data=weight, default=1))
+    return sum(weight for u, v, weight in edges)
+
+
+def volume(G, S, weight=None):
+    """Returns the volume of a set of nodes.
+
+    The *volume* of a set *S* is the sum of the (out-)degrees of nodes
+    in *S* (taking into account parallel edges in multigraphs). [1]
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    S : collection
+        A collection of nodes in `G`.
+
+    weight : object
+        Edge attribute key to use as weight. If not specified, edges
+        have weight one.
+
+    Returns
+    -------
+    number
+        The volume of the set of nodes represented by `S` in the graph
+        `G`.
+
+    See also
+    --------
+    conductance
+    cut_size
+    edge_expansion
+    edge_boundary
+    normalized_cut_size
+
+    References
+    ----------
+    .. [1] David Gleich.
+           *Hierarchical Directed Spectral Graph Partitioning*.
+           <https://www.cs.purdue.edu/homes/dgleich/publications/Gleich%202005%20-%20hierarchical%20directed%20spectral.pdf>
+
+    """
+    degree = G.out_degree if G.is_directed() else G.degree
+    return sum(d for v, d in degree(S, weight=weight))
+
+
+def normalized_cut_size(G, S, T=None, weight=None):
+    """Returns the normalized size of the cut between two sets of nodes.
+
+    The *normalized cut size* is the cut size times the sum of the
+    reciprocal sizes of the volumes of the two sets. [1]
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    S : collection
+        A collection of nodes in `G`.
+
+    T : collection
+        A collection of nodes in `G`.
+
+    weight : object
+        Edge attribute key to use as weight. If not specified, edges
+        have weight one.
+
+    Returns
+    -------
+    number
+        The normalized cut size between the two sets `S` and `T`.
+
+    Notes
+    -----
+    In a multigraph, the cut size is the total weight of edges including
+    multiplicity.
+
+    See also
+    --------
+    conductance
+    cut_size
+    edge_expansion
+    volume
+
+    References
+    ----------
+    .. [1] David Gleich.
+           *Hierarchical Directed Spectral Graph Partitioning*.
+           <https://www.cs.purdue.edu/homes/dgleich/publications/Gleich%202005%20-%20hierarchical%20directed%20spectral.pdf>
+
+    """
+    if T is None:
+        T = set(G) - set(S)
+    num_cut_edges = cut_size(G, S, T=T, weight=weight)
+    volume_S = volume(G, S, weight=weight)
+    volume_T = volume(G, T, weight=weight)
+    return num_cut_edges * ((1 / volume_S) + (1 / volume_T))
+
+
+def conductance(G, S, T=None, weight=None):
+    """Returns the conductance of two sets of nodes.
+
+    The *conductance* is the quotient of the cut size and the smaller of
+    the volumes of the two sets. [1]
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    S : collection
+        A collection of nodes in `G`.
+
+    T : collection
+        A collection of nodes in `G`.
+
+    weight : object
+        Edge attribute key to use as weight. If not specified, edges
+        have weight one.
+
+    Returns
+    -------
+    number
+        The conductance between the two sets `S` and `T`.
+
+    See also
+    --------
+    cut_size
+    edge_expansion
+    normalized_cut_size
+    volume
+
+    References
+    ----------
+    .. [1] David Gleich.
+           *Hierarchical Directed Spectral Graph Partitioning*.
+           <https://www.cs.purdue.edu/homes/dgleich/publications/Gleich%202005%20-%20hierarchical%20directed%20spectral.pdf>
+
+    """
+    if T is None:
+        T = set(G) - set(S)
+    num_cut_edges = cut_size(G, S, T, weight=weight)
+    volume_S = volume(G, S, weight=weight)
+    volume_T = volume(G, T, weight=weight)
+    return num_cut_edges / min(volume_S, volume_T)
+
+
+def edge_expansion(G, S, T=None, weight=None):
+    """Returns the edge expansion between two node sets.
+
+    The *edge expansion* is the quotient of the cut size and the smaller
+    of the cardinalities of the two sets. [1]
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    S : collection
+        A collection of nodes in `G`.
+
+    T : collection
+        A collection of nodes in `G`.
+
+    weight : object
+        Edge attribute key to use as weight. If not specified, edges
+        have weight one.
+
+    Returns
+    -------
+    number
+        The edge expansion between the two sets `S` and `T`.
+
+    See also
+    --------
+    boundary_expansion
+    mixing_expansion
+    node_expansion
+
+    References
+    ----------
+    .. [1] Fan Chung.
+           *Spectral Graph Theory*.
+           (CBMS Regional Conference Series in Mathematics, No. 92),
+           American Mathematical Society, 1997, ISBN 0-8218-0315-8
+           <http://www.math.ucsd.edu/~fan/research/revised.html>
+
+    """
+    if T is None:
+        T = set(G) - set(S)
+    num_cut_edges = cut_size(G, S, T=T, weight=weight)
+    return num_cut_edges / min(len(S), len(T))
+
+
+def mixing_expansion(G, S, T=None, weight=None):
+    """Returns the mixing expansion between two node sets.
+
+    The *mixing expansion* is the quotient of the cut size and twice the
+    number of edges in the graph. [1]
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    S : collection
+        A collection of nodes in `G`.
+
+    T : collection
+        A collection of nodes in `G`.
+
+    weight : object
+        Edge attribute key to use as weight. If not specified, edges
+        have weight one.
+
+    Returns
+    -------
+    number
+        The mixing expansion between the two sets `S` and `T`.
+
+    See also
+    --------
+    boundary_expansion
+    edge_expansion
+    node_expansion
+
+    References
+    ----------
+    .. [1] Vadhan, Salil P.
+           "Pseudorandomness."
+           *Foundations and Trends
+           in Theoretical Computer Science* 7.1–3 (2011): 1–336.
+           <https://doi.org/10.1561/0400000010>
+
+    """
+    num_cut_edges = cut_size(G, S, T=T, weight=weight)
+    num_total_edges = G.number_of_edges()
+    return num_cut_edges / (2 * num_total_edges)
+
+
+# TODO What is the generalization to two arguments, S and T? Does the
+# denominator become `min(len(S), len(T))`?
+def node_expansion(G, S):
+    """Returns the node expansion of the set `S`.
+
+    The *node expansion* is the quotient of the size of the node
+    boundary of *S* and the cardinality of *S*. [1]
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    S : collection
+        A collection of nodes in `G`.
+
+    Returns
+    -------
+    number
+        The node expansion of the set `S`.
+
+    See also
+    --------
+    boundary_expansion
+    edge_expansion
+    mixing_expansion
+
+    References
+    ----------
+    .. [1] Vadhan, Salil P.
+           "Pseudorandomness."
+           *Foundations and Trends
+           in Theoretical Computer Science* 7.1–3 (2011): 1–336.
+           <https://doi.org/10.1561/0400000010>
+
+    """
+    neighborhood = set(chain.from_iterable(G.neighbors(v) for v in S))
+    return len(neighborhood) / len(S)
+
+
+# TODO What is the generalization to two arguments, S and T? Does the
+# denominator become `min(len(S), len(T))`?
+def boundary_expansion(G, S):
+    """Returns the boundary expansion of the set `S`.
+
+    The *boundary expansion* is the quotient of the size
+    of the node boundary and the cardinality of *S*. [1]
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    S : collection
+        A collection of nodes in `G`.
+
+    Returns
+    -------
+    number
+        The boundary expansion of the set `S`.
+
+    See also
+    --------
+    edge_expansion
+    mixing_expansion
+    node_expansion
+
+    References
+    ----------
+    .. [1] Vadhan, Salil P.
+           "Pseudorandomness."
+           *Foundations and Trends in Theoretical Computer Science*
+           7.1–3 (2011): 1–336.
+           <https://doi.org/10.1561/0400000010>
+
+    """
+    return len(nx.node_boundary(G, S)) / len(S)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/cycles.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/cycles.py
new file mode 100644
index 0000000..48d32ae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/cycles.py
@@ -0,0 +1,617 @@
+"""
+========================
+Cycle finding algorithms
+========================
+"""
+
+from collections import defaultdict
+
+import networkx as nx
+from networkx.utils import not_implemented_for, pairwise
+
+__all__ = [
+    "cycle_basis",
+    "simple_cycles",
+    "recursive_simple_cycles",
+    "find_cycle",
+    "minimum_cycle_basis",
+]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def cycle_basis(G, root=None):
+    """Returns a list of cycles which form a basis for cycles of G.
+
+    A basis for cycles of a network is a minimal collection of
+    cycles such that any cycle in the network can be written
+    as a sum of cycles in the basis.  Here summation of cycles
+    is defined as "exclusive or" of the edges. Cycle bases are
+    useful, e.g. when deriving equations for electric circuits
+    using Kirchhoff's Laws.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    root : node, optional
+       Specify starting node for basis.
+
+    Returns
+    -------
+    A list of cycle lists.  Each cycle list is a list of nodes
+    which forms a cycle (loop) in G.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> nx.add_cycle(G, [0, 1, 2, 3])
+    >>> nx.add_cycle(G, [0, 3, 4, 5])
+    >>> print(nx.cycle_basis(G, 0))
+    [[3, 4, 5, 0], [1, 2, 3, 0]]
+
+    Notes
+    -----
+    This is adapted from algorithm CACM 491 [1]_.
+
+    References
+    ----------
+    .. [1] Paton, K. An algorithm for finding a fundamental set of
+       cycles of a graph. Comm. ACM 12, 9 (Sept 1969), 514-518.
+
+    See Also
+    --------
+    simple_cycles
+    """
+    gnodes = set(G.nodes())
+    cycles = []
+    while gnodes:  # loop over connected components
+        if root is None:
+            root = gnodes.pop()
+        stack = [root]
+        pred = {root: root}
+        used = {root: set()}
+        while stack:  # walk the spanning tree finding cycles
+            z = stack.pop()  # use last-in so cycles easier to find
+            zused = used[z]
+            for nbr in G[z]:
+                if nbr not in used:  # new node
+                    pred[nbr] = z
+                    stack.append(nbr)
+                    used[nbr] = {z}
+                elif nbr == z:  # self loops
+                    cycles.append([z])
+                elif nbr not in zused:  # found a cycle
+                    pn = used[nbr]
+                    cycle = [nbr, z]
+                    p = pred[z]
+                    while p not in pn:
+                        cycle.append(p)
+                        p = pred[p]
+                    cycle.append(p)
+                    cycles.append(cycle)
+                    used[nbr].add(z)
+        gnodes -= set(pred)
+        root = None
+    return cycles
+
+
+@not_implemented_for("undirected")
+def simple_cycles(G):
+    """Find simple cycles (elementary circuits) of a directed graph.
+
+    A `simple cycle`, or `elementary circuit`, is a closed path where
+    no node appears twice. Two elementary circuits are distinct if they
+    are not cyclic permutations of each other.
+
+    This is a nonrecursive, iterator/generator version of Johnson's
+    algorithm [1]_.  There may be better algorithms for some cases [2]_ [3]_.
+
+    Parameters
+    ----------
+    G : NetworkX DiGraph
+       A directed graph
+
+    Yields
+    ------
+    list of nodes
+       Each cycle is represented by a list of nodes along the cycle.
+
+    Examples
+    --------
+    >>> edges = [(0, 0), (0, 1), (0, 2), (1, 2), (2, 0), (2, 1), (2, 2)]
+    >>> G = nx.DiGraph(edges)
+    >>> sorted(nx.simple_cycles(G))
+    [[0], [0, 1, 2], [0, 2], [1, 2], [2]]
+
+    To filter the cycles so that they don't include certain nodes or edges,
+    copy your graph and eliminate those nodes or edges before calling.
+    For example, to exclude self-loops from the above example:
+
+    >>> H = G.copy()
+    >>> H.remove_edges_from(nx.selfloop_edges(G))
+    >>> sorted(nx.simple_cycles(H))
+    [[0, 1, 2], [0, 2], [1, 2]]
+
+    Notes
+    -----
+    The implementation follows pp. 79-80 in [1]_.
+
+    The time complexity is $O((n+e)(c+1))$ for $n$ nodes, $e$ edges and $c$
+    elementary circuits.
+
+    References
+    ----------
+    .. [1] Finding all the elementary circuits of a directed graph.
+       D. B. Johnson, SIAM Journal on Computing 4, no. 1, 77-84, 1975.
+       https://doi.org/10.1137/0204007
+    .. [2] Enumerating the cycles of a digraph: a new preprocessing strategy.
+       G. Loizou and P. Thanish, Information Sciences, v. 27, 163-182, 1982.
+    .. [3] A search strategy for the elementary cycles of a directed graph.
+       J.L. Szwarcfiter and P.E. Lauer, BIT NUMERICAL MATHEMATICS,
+       v. 16, no. 2, 192-204, 1976.
+
+    See Also
+    --------
+    cycle_basis
+    """
+
+    def _unblock(thisnode, blocked, B):
+        stack = {thisnode}
+        while stack:
+            node = stack.pop()
+            if node in blocked:
+                blocked.remove(node)
+                stack.update(B[node])
+                B[node].clear()
+
+    # Johnson's algorithm requires some ordering of the nodes.
+    # We assign the arbitrary ordering given by the strongly connected comps
+    # There is no need to track the ordering as each node removed as processed.
+    # Also we save the actual graph so we can mutate it. We only take the
+    # edges because we do not want to copy edge and node attributes here.
+    subG = type(G)(G.edges())
+    sccs = [scc for scc in nx.strongly_connected_components(subG) if len(scc) > 1]
+
+    # Johnson's algorithm exclude self cycle edges like (v, v)
+    # To be backward compatible, we record those cycles in advance
+    # and then remove from subG
+    for v in subG:
+        if subG.has_edge(v, v):
+            yield [v]
+            subG.remove_edge(v, v)
+
+    while sccs:
+        scc = sccs.pop()
+        sccG = subG.subgraph(scc)
+        # order of scc determines ordering of nodes
+        startnode = scc.pop()
+        # Processing node runs "circuit" routine from recursive version
+        path = [startnode]
+        blocked = set()  # vertex: blocked from search?
+        closed = set()  # nodes involved in a cycle
+        blocked.add(startnode)
+        B = defaultdict(set)  # graph portions that yield no elementary circuit
+        stack = [(startnode, list(sccG[startnode]))]  # sccG gives comp nbrs
+        while stack:
+            thisnode, nbrs = stack[-1]
+            if nbrs:
+                nextnode = nbrs.pop()
+                if nextnode == startnode:
+                    yield path[:]
+                    closed.update(path)
+                #                        print "Found a cycle", path, closed
+                elif nextnode not in blocked:
+                    path.append(nextnode)
+                    stack.append((nextnode, list(sccG[nextnode])))
+                    closed.discard(nextnode)
+                    blocked.add(nextnode)
+                    continue
+            # done with nextnode... look for more neighbors
+            if not nbrs:  # no more nbrs
+                if thisnode in closed:
+                    _unblock(thisnode, blocked, B)
+                else:
+                    for nbr in sccG[thisnode]:
+                        if thisnode not in B[nbr]:
+                            B[nbr].add(thisnode)
+                stack.pop()
+                #                assert path[-1] == thisnode
+                path.pop()
+        # done processing this node
+        H = subG.subgraph(scc)  # make smaller to avoid work in SCC routine
+        sccs.extend(scc for scc in nx.strongly_connected_components(H) if len(scc) > 1)
+
+
+@not_implemented_for("undirected")
+def recursive_simple_cycles(G):
+    """Find simple cycles (elementary circuits) of a directed graph.
+
+    A `simple cycle`, or `elementary circuit`, is a closed path where
+    no node appears twice. Two elementary circuits are distinct if they
+    are not cyclic permutations of each other.
+
+    This version uses a recursive algorithm to build a list of cycles.
+    You should probably use the iterator version called simple_cycles().
+    Warning: This recursive version uses lots of RAM!
+    It appears in NetworkX for pedagogical value.
+
+    Parameters
+    ----------
+    G : NetworkX DiGraph
+       A directed graph
+
+    Returns
+    -------
+    A list of cycles, where each cycle is represented by a list of nodes
+    along the cycle.
+
+    Example:
+
+    >>> edges = [(0, 0), (0, 1), (0, 2), (1, 2), (2, 0), (2, 1), (2, 2)]
+    >>> G = nx.DiGraph(edges)
+    >>> nx.recursive_simple_cycles(G)
+    [[0], [2], [0, 1, 2], [0, 2], [1, 2]]
+
+    Notes
+    -----
+    The implementation follows pp. 79-80 in [1]_.
+
+    The time complexity is $O((n+e)(c+1))$ for $n$ nodes, $e$ edges and $c$
+    elementary circuits.
+
+    References
+    ----------
+    .. [1] Finding all the elementary circuits of a directed graph.
+       D. B. Johnson, SIAM Journal on Computing 4, no. 1, 77-84, 1975.
+       https://doi.org/10.1137/0204007
+
+    See Also
+    --------
+    simple_cycles, cycle_basis
+    """
+    # Jon Olav Vik, 2010-08-09
+    def _unblock(thisnode):
+        """Recursively unblock and remove nodes from B[thisnode]."""
+        if blocked[thisnode]:
+            blocked[thisnode] = False
+            while B[thisnode]:
+                _unblock(B[thisnode].pop())
+
+    def circuit(thisnode, startnode, component):
+        closed = False  # set to True if elementary path is closed
+        path.append(thisnode)
+        blocked[thisnode] = True
+        for nextnode in component[thisnode]:  # direct successors of thisnode
+            if nextnode == startnode:
+                result.append(path[:])
+                closed = True
+            elif not blocked[nextnode]:
+                if circuit(nextnode, startnode, component):
+                    closed = True
+        if closed:
+            _unblock(thisnode)
+        else:
+            for nextnode in component[thisnode]:
+                if thisnode not in B[nextnode]:  # TODO: use set for speedup?
+                    B[nextnode].append(thisnode)
+        path.pop()  # remove thisnode from path
+        return closed
+
+    path = []  # stack of nodes in current path
+    blocked = defaultdict(bool)  # vertex: blocked from search?
+    B = defaultdict(list)  # graph portions that yield no elementary circuit
+    result = []  # list to accumulate the circuits found
+
+    # Johnson's algorithm exclude self cycle edges like (v, v)
+    # To be backward compatible, we record those cycles in advance
+    # and then remove from subG
+    for v in G:
+        if G.has_edge(v, v):
+            result.append([v])
+            G.remove_edge(v, v)
+
+    # Johnson's algorithm requires some ordering of the nodes.
+    # They might not be sortable so we assign an arbitrary ordering.
+    ordering = dict(zip(G, range(len(G))))
+    for s in ordering:
+        # Build the subgraph induced by s and following nodes in the ordering
+        subgraph = G.subgraph(node for node in G if ordering[node] >= ordering[s])
+        # Find the strongly connected component in the subgraph
+        # that contains the least node according to the ordering
+        strongcomp = nx.strongly_connected_components(subgraph)
+        mincomp = min(strongcomp, key=lambda ns: min(ordering[n] for n in ns))
+        component = G.subgraph(mincomp)
+        if len(component) > 1:
+            # smallest node in the component according to the ordering
+            startnode = min(component, key=ordering.__getitem__)
+            for node in component:
+                blocked[node] = False
+                B[node][:] = []
+            dummy = circuit(startnode, startnode, component)
+    return result
+
+
+def find_cycle(G, source=None, orientation=None):
+    """Returns a cycle found via depth-first traversal.
+
+    The cycle is a list of edges indicating the cyclic path.
+    Orientation of directed edges is controlled by `orientation`.
+
+    Parameters
+    ----------
+    G : graph
+        A directed/undirected graph/multigraph.
+
+    source : node, list of nodes
+        The node from which the traversal begins. If None, then a source
+        is chosen arbitrarily and repeatedly until all edges from each node in
+        the graph are searched.
+
+    orientation : None | 'original' | 'reverse' | 'ignore' (default: None)
+        For directed graphs and directed multigraphs, edge traversals need not
+        respect the original orientation of the edges.
+        When set to 'reverse' every edge is traversed in the reverse direction.
+        When set to 'ignore', every edge is treated as undirected.
+        When set to 'original', every edge is treated as directed.
+        In all three cases, the yielded edge tuples add a last entry to
+        indicate the direction in which that edge was traversed.
+        If orientation is None, the yielded edge has no direction indicated.
+        The direction is respected, but not reported.
+
+    Returns
+    -------
+    edges : directed edges
+        A list of directed edges indicating the path taken for the loop.
+        If no cycle is found, then an exception is raised.
+        For graphs, an edge is of the form `(u, v)` where `u` and `v`
+        are the tail and head of the edge as determined by the traversal.
+        For multigraphs, an edge is of the form `(u, v, key)`, where `key` is
+        the key of the edge. When the graph is directed, then `u` and `v`
+        are always in the order of the actual directed edge.
+        If orientation is not None then the edge tuple is extended to include
+        the direction of traversal ('forward' or 'reverse') on that edge.
+
+    Raises
+    ------
+    NetworkXNoCycle
+        If no cycle was found.
+
+    Examples
+    --------
+    In this example, we construct a DAG and find, in the first call, that there
+    are no directed cycles, and so an exception is raised. In the second call,
+    we ignore edge orientations and find that there is an undirected cycle.
+    Note that the second call finds a directed cycle while effectively
+    traversing an undirected graph, and so, we found an "undirected cycle".
+    This means that this DAG structure does not form a directed tree (which
+    is also known as a polytree).
+
+    >>> G = nx.DiGraph([(0, 1), (0, 2), (1, 2)])
+    >>> nx.find_cycle(G, orientation="original")
+    Traceback (most recent call last):
+        ...
+    networkx.exception.NetworkXNoCycle: No cycle found.
+    >>> list(nx.find_cycle(G, orientation="ignore"))
+    [(0, 1, 'forward'), (1, 2, 'forward'), (0, 2, 'reverse')]
+
+    See Also
+    --------
+    simple_cycles
+    """
+    if not G.is_directed() or orientation in (None, "original"):
+
+        def tailhead(edge):
+            return edge[:2]
+
+    elif orientation == "reverse":
+
+        def tailhead(edge):
+            return edge[1], edge[0]
+
+    elif orientation == "ignore":
+
+        def tailhead(edge):
+            if edge[-1] == "reverse":
+                return edge[1], edge[0]
+            return edge[:2]
+
+    explored = set()
+    cycle = []
+    final_node = None
+    for start_node in G.nbunch_iter(source):
+        if start_node in explored:
+            # No loop is possible.
+            continue
+
+        edges = []
+        # All nodes seen in this iteration of edge_dfs
+        seen = {start_node}
+        # Nodes in active path.
+        active_nodes = {start_node}
+        previous_head = None
+
+        for edge in nx.edge_dfs(G, start_node, orientation):
+            # Determine if this edge is a continuation of the active path.
+            tail, head = tailhead(edge)
+            if head in explored:
+                # Then we've already explored it. No loop is possible.
+                continue
+            if previous_head is not None and tail != previous_head:
+                # This edge results from backtracking.
+                # Pop until we get a node whose head equals the current tail.
+                # So for example, we might have:
+                #  (0, 1), (1, 2), (2, 3), (1, 4)
+                # which must become:
+                #  (0, 1), (1, 4)
+                while True:
+                    try:
+                        popped_edge = edges.pop()
+                    except IndexError:
+                        edges = []
+                        active_nodes = {tail}
+                        break
+                    else:
+                        popped_head = tailhead(popped_edge)[1]
+                        active_nodes.remove(popped_head)
+
+                    if edges:
+                        last_head = tailhead(edges[-1])[1]
+                        if tail == last_head:
+                            break
+            edges.append(edge)
+
+            if head in active_nodes:
+                # We have a loop!
+                cycle.extend(edges)
+                final_node = head
+                break
+            else:
+                seen.add(head)
+                active_nodes.add(head)
+                previous_head = head
+
+        if cycle:
+            break
+        else:
+            explored.update(seen)
+
+    else:
+        assert len(cycle) == 0
+        raise nx.exception.NetworkXNoCycle("No cycle found.")
+
+    # We now have a list of edges which ends on a cycle.
+    # So we need to remove from the beginning edges that are not relevant.
+
+    for i, edge in enumerate(cycle):
+        tail, head = tailhead(edge)
+        if tail == final_node:
+            break
+
+    return cycle[i:]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def minimum_cycle_basis(G, weight=None):
+    """Returns a minimum weight cycle basis for G
+
+    Minimum weight means a cycle basis for which the total weight
+    (length for unweighted graphs) of all the cycles is minimum.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    weight: string
+        name of the edge attribute to use for edge weights
+
+    Returns
+    -------
+    A list of cycle lists.  Each cycle list is a list of nodes
+    which forms a cycle (loop) in G. Note that the nodes are not
+    necessarily returned in a order by which they appear in the cycle
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> nx.add_cycle(G, [0, 1, 2, 3])
+    >>> nx.add_cycle(G, [0, 3, 4, 5])
+    >>> print([sorted(c) for c in nx.minimum_cycle_basis(G)])
+    [[0, 1, 2, 3], [0, 3, 4, 5]]
+
+    References:
+        [1] Kavitha, Telikepalli, et al. "An O(m^2n) Algorithm for
+        Minimum Cycle Basis of Graphs."
+        http://link.springer.com/article/10.1007/s00453-007-9064-z
+        [2] de Pina, J. 1995. Applications of shortest path methods.
+        Ph.D. thesis, University of Amsterdam, Netherlands
+
+    See Also
+    --------
+    simple_cycles, cycle_basis
+    """
+    # We first split the graph in commected subgraphs
+    return sum(
+        (_min_cycle_basis(G.subgraph(c), weight) for c in nx.connected_components(G)),
+        [],
+    )
+
+
+def _min_cycle_basis(comp, weight):
+    cb = []
+    # We  extract the edges not in a spanning tree. We do not really need a
+    # *minimum* spanning tree. That is why we call the next function with
+    # weight=None. Depending on implementation, it may be faster as well
+    spanning_tree_edges = list(nx.minimum_spanning_edges(comp, weight=None, data=False))
+    edges_excl = [frozenset(e) for e in comp.edges() if e not in spanning_tree_edges]
+    N = len(edges_excl)
+
+    # We maintain a set of vectors orthogonal to sofar found cycles
+    set_orth = [{edge} for edge in edges_excl]
+    for k in range(N):
+        # kth cycle is "parallel" to kth vector in set_orth
+        new_cycle = _min_cycle(comp, set_orth[k], weight=weight)
+        cb.append(list(set().union(*new_cycle)))
+        # now update set_orth so that k+1,k+2... th elements are
+        # orthogonal to the newly found cycle, as per [p. 336, 1]
+        base = set_orth[k]
+        set_orth[k + 1 :] = [
+            orth ^ base if len(orth & new_cycle) % 2 else orth
+            for orth in set_orth[k + 1 :]
+        ]
+    return cb
+
+
+def _min_cycle(G, orth, weight=None):
+    """
+    Computes the minimum weight cycle in G,
+    orthogonal to the vector orth as per [p. 338, 1]
+    """
+    T = nx.Graph()
+
+    nodes_idx = {node: idx for idx, node in enumerate(G.nodes())}
+    idx_nodes = {idx: node for node, idx in nodes_idx.items()}
+
+    nnodes = len(nodes_idx)
+
+    # Add 2 copies of each edge in G to T. If edge is in orth, add cross edge;
+    # otherwise in-plane edge
+    for u, v, data in G.edges(data=True):
+        uidx, vidx = nodes_idx[u], nodes_idx[v]
+        edge_w = data.get(weight, 1)
+        if frozenset((u, v)) in orth:
+            T.add_edges_from(
+                [(uidx, nnodes + vidx), (nnodes + uidx, vidx)], weight=edge_w
+            )
+        else:
+            T.add_edges_from(
+                [(uidx, vidx), (nnodes + uidx, nnodes + vidx)], weight=edge_w
+            )
+
+    all_shortest_pathlens = dict(nx.shortest_path_length(T, weight=weight))
+    cross_paths_w_lens = {
+        n: all_shortest_pathlens[n][nnodes + n] for n in range(nnodes)
+    }
+
+    # Now compute shortest paths in T, which translates to cyles in G
+    start = min(cross_paths_w_lens, key=cross_paths_w_lens.get)
+    end = nnodes + start
+    min_path = nx.shortest_path(T, source=start, target=end, weight="weight")
+
+    # Now we obtain the actual path, re-map nodes in T to those in G
+    min_path_nodes = [node if node < nnodes else node - nnodes for node in min_path]
+    # Now remove the edges that occur two times
+    mcycle_pruned = _path_to_cycle(min_path_nodes)
+
+    return {frozenset((idx_nodes[u], idx_nodes[v])) for u, v in mcycle_pruned}
+
+
+def _path_to_cycle(path):
+    """
+    Removes the edges from path that occur even number of times.
+    Returns a set of edges
+    """
+    edges = set()
+    for edge in pairwise(path):
+        # Toggle whether to keep the current edge.
+        edges ^= {edge}
+    return edges
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/d_separation.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/d_separation.py
new file mode 100644
index 0000000..caf26d0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/d_separation.py
@@ -0,0 +1,142 @@
+"""
+Algorithm for testing d-separation in DAGs.
+
+*d-separation* is a test for conditional independence in probability
+distributions that can be factorized using DAGs.  It is a purely
+graphical test that uses the underlying graph and makes no reference
+to the actual distribution parameters.  See [1]_ for a formal
+definition.
+
+The implementation is based on the conceptually simple linear time
+algorithm presented in [2]_.  Refer to [3]_, [4]_ for a couple of
+alternative algorithms.
+
+
+Examples
+--------
+
+>>>
+>>> # HMM graph with five states and observation nodes
+... g = nx.DiGraph()
+>>> g.add_edges_from(
+...     [
+...         ("S1", "S2"),
+...         ("S2", "S3"),
+...         ("S3", "S4"),
+...         ("S4", "S5"),
+...         ("S1", "O1"),
+...         ("S2", "O2"),
+...         ("S3", "O3"),
+...         ("S4", "O4"),
+...         ("S5", "O5"),
+...     ]
+... )
+>>>
+>>> # states/obs before 'S3' are d-separated from states/obs after 'S3'
+... nx.d_separated(g, {"S1", "S2", "O1", "O2"}, {"S4", "S5", "O4", "O5"}, {"S3"})
+True
+
+
+References
+----------
+
+.. [1] Pearl, J.  (2009).  Causality.  Cambridge: Cambridge University Press.
+
+.. [2] Darwiche, A.  (2009).  Modeling and reasoning with Bayesian networks. 
+   Cambridge: Cambridge University Press.
+
+.. [3] Shachter, R.  D.  (1998).
+   Bayes-ball: rational pastime (for determining irrelevance and requisite
+   information in belief networks and influence diagrams).
+   In , Proceedings of the Fourteenth Conference on Uncertainty in Artificial
+   Intelligence (pp.  480–487).
+   San Francisco, CA, USA: Morgan Kaufmann Publishers Inc.
+
+.. [4] Koller, D., & Friedman, N. (2009).
+   Probabilistic graphical models: principles and techniques. The MIT Press.
+
+"""
+
+from collections import deque
+
+import networkx as nx
+from networkx.utils import UnionFind, not_implemented_for
+
+__all__ = ["d_separated"]
+
+
+@not_implemented_for("undirected")
+def d_separated(G, x, y, z):
+    """
+    Return whether node sets ``x`` and ``y`` are d-separated by ``z``.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX DAG.
+
+    x : set
+        First set of nodes in ``G``.
+
+    y : set
+        Second set of nodes in ``G``.
+
+    z : set
+        Set of conditioning nodes in ``G``. Can be empty set.
+
+    Returns
+    -------
+    b : bool
+        A boolean that is true if ``x`` is d-separated from ``y`` given ``z`` in ``G``.
+
+    Raises
+    ------
+    NetworkXError
+        The *d-separation* test is commonly used with directed
+        graphical models which are acyclic.  Accordingly, the algorithm
+        raises a :exc:`NetworkXError` if the input graph is not a DAG.
+
+    NodeNotFound
+        If any of the input nodes are not found in the graph,
+        a :exc:`NodeNotFound` exception is raised.
+
+    """
+
+    if not nx.is_directed_acyclic_graph(G):
+        raise nx.NetworkXError("graph should be directed acyclic")
+
+    union_xyz = x.union(y).union(z)
+
+    if any(n not in G.nodes for n in union_xyz):
+        raise nx.NodeNotFound("one or more specified nodes not found in the graph")
+
+    G_copy = G.copy()
+
+    # transform the graph by removing leaves that are not in x | y | z
+    # until no more leaves can be removed.
+    leaves = deque([n for n in G_copy.nodes if G_copy.out_degree[n] == 0])
+    while len(leaves) > 0:
+        leaf = leaves.popleft()
+        if leaf not in union_xyz:
+            for p in G_copy.predecessors(leaf):
+                if G_copy.out_degree[p] == 1:
+                    leaves.append(p)
+            G_copy.remove_node(leaf)
+
+    # transform the graph by removing outgoing edges from the
+    # conditioning set.
+    edges_to_remove = list(G_copy.out_edges(z))
+    G_copy.remove_edges_from(edges_to_remove)
+
+    # use disjoint-set data structure to check if any node in `x`
+    # occurs in the same weakly connected component as a node in `y`.
+    disjoint_set = UnionFind(G_copy.nodes())
+    for component in nx.weakly_connected_components(G_copy):
+        disjoint_set.union(*component)
+    disjoint_set.union(*x)
+    disjoint_set.union(*y)
+
+    if x and y and disjoint_set[next(iter(x))] == disjoint_set[next(iter(y))]:
+        return False
+    else:
+        return True
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/dag.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/dag.py
new file mode 100644
index 0000000..c96032d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/dag.py
@@ -0,0 +1,1136 @@
+"""Algorithms for directed acyclic graphs (DAGs).
+
+Note that most of these functions are only guaranteed to work for DAGs.
+In general, these functions do not check for acyclic-ness, so it is up
+to the user to check for that.
+"""
+
+import heapq
+from collections import deque
+from functools import partial
+from itertools import chain, product, starmap
+from math import gcd
+
+import networkx as nx
+from networkx.utils import arbitrary_element, not_implemented_for, pairwise
+
+__all__ = [
+    "descendants",
+    "ancestors",
+    "topological_sort",
+    "lexicographical_topological_sort",
+    "all_topological_sorts",
+    "topological_generations",
+    "is_directed_acyclic_graph",
+    "is_aperiodic",
+    "transitive_closure",
+    "transitive_closure_dag",
+    "transitive_reduction",
+    "antichains",
+    "dag_longest_path",
+    "dag_longest_path_length",
+    "dag_to_branching",
+]
+
+chaini = chain.from_iterable
+
+
+def descendants(G, source):
+    """Returns all nodes reachable from `source` in `G`.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    source : node in `G`
+
+    Returns
+    -------
+    set()
+        The descendants of `source` in `G`
+
+    Raises
+    ------
+    NetworkXError
+        If node `source` is not in `G`.
+
+    Examples
+    --------
+    >>> DG = nx.path_graph(5, create_using=nx.DiGraph)
+    >>> sorted(list(nx.descendants(DG, 2)))
+    [3, 4]
+
+    See also
+    --------
+    ancestors
+    """
+    return {child for parent, child in nx.bfs_edges(G, source)}
+
+
+def ancestors(G, source):
+    """Returns all nodes having a path to `source` in `G`.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    source : node in `G`
+
+    Returns
+    -------
+    set()
+        The ancestors of `source` in `G`
+
+    Raises
+    ------
+    NetworkXError
+        If node `source` is not in `G`.
+
+    Examples
+    --------
+    >>> DG = nx.path_graph(5, create_using=nx.DiGraph)
+    >>> sorted(list(nx.ancestors(DG, 2)))
+    [0, 1]
+
+    See also
+    --------
+    descendants
+    """
+    return {child for parent, child in nx.bfs_edges(G, source, reverse=True)}
+
+
+def has_cycle(G):
+    """Decides whether the directed graph has a cycle."""
+    try:
+        # Feed the entire iterator into a zero-length deque.
+        deque(topological_sort(G), maxlen=0)
+    except nx.NetworkXUnfeasible:
+        return True
+    else:
+        return False
+
+
+def is_directed_acyclic_graph(G):
+    """Returns True if the graph `G` is a directed acyclic graph (DAG) or
+    False if not.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    bool
+        True if `G` is a DAG, False otherwise
+
+    Examples
+    --------
+    Undirected graph::
+
+        >>> G = nx.Graph([(1, 2), (2, 3)])
+        >>> nx.is_directed_acyclic_graph(G)
+        False
+
+    Directed graph with cycle::
+
+        >>> G = nx.DiGraph([(1, 2), (2, 3), (3, 1)])
+        >>> nx.is_directed_acyclic_graph(G)
+        False
+
+    Directed acyclic graph::
+
+        >>> G = nx.DiGraph([(1, 2), (2, 3)])
+        >>> nx.is_directed_acyclic_graph(G)
+        True
+
+    See also
+    --------
+    topological_sort
+    """
+    return G.is_directed() and not has_cycle(G)
+
+
+def topological_generations(G):
+    """Stratifies a DAG into generations.
+
+    A topological generation is node collection in which ancestors of a node in each
+    generation are guaranteed to be in a previous generation, and any descendants of
+    a node are guaranteed to be in a following generation. Nodes are guaranteed to
+    be in the earliest possible generation that they can belong to.
+
+    Parameters
+    ----------
+    G : NetworkX digraph
+        A directed acyclic graph (DAG)
+
+    Yields
+    ------
+    sets of nodes
+        Yields sets of nodes representing each generation.
+
+    Raises
+    ------
+    NetworkXError
+        Generations are defined for directed graphs only. If the graph
+        `G` is undirected, a :exc:`NetworkXError` is raised.
+
+    NetworkXUnfeasible
+        If `G` is not a directed acyclic graph (DAG) no topological generations
+        exist and a :exc:`NetworkXUnfeasible` exception is raised.  This can also
+        be raised if `G` is changed while the returned iterator is being processed
+
+    RuntimeError
+        If `G` is changed while the returned iterator is being processed.
+
+    Examples
+    --------
+    >>> DG = nx.DiGraph([(2, 1), (3, 1)])
+    >>> [sorted(generation) for generation in nx.topological_generations(DG)]
+    [[2, 3], [1]]
+
+    Notes
+    -----
+    The generation in which a node resides can also be determined by taking the
+    max-path-distance from the node to the farthest leaf node. That value can
+    be obtained with this function using `enumerate(topological_generations(G))`.
+
+    See also
+    --------
+    topological_sort
+    """
+    if not G.is_directed():
+        raise nx.NetworkXError("Topological sort not defined on undirected graphs.")
+
+    multigraph = G.is_multigraph()
+    indegree_map = {v: d for v, d in G.in_degree() if d > 0}
+    zero_indegree = [v for v, d in G.in_degree() if d == 0]
+
+    while zero_indegree:
+        this_generation = zero_indegree
+        zero_indegree = []
+        for node in this_generation:
+            if node not in G:
+                raise RuntimeError("Graph changed during iteration")
+            for child in G.neighbors(node):
+                try:
+                    indegree_map[child] -= len(G[node][child]) if multigraph else 1
+                except KeyError as err:
+                    raise RuntimeError("Graph changed during iteration") from err
+                if indegree_map[child] == 0:
+                    zero_indegree.append(child)
+                    del indegree_map[child]
+        yield this_generation
+
+    if indegree_map:
+        raise nx.NetworkXUnfeasible(
+            "Graph contains a cycle or graph changed during iteration"
+        )
+
+
+def topological_sort(G):
+    """Returns a generator of nodes in topologically sorted order.
+
+    A topological sort is a nonunique permutation of the nodes of a
+    directed graph such that an edge from u to v implies that u
+    appears before v in the topological sort order. This ordering is
+    valid only if the graph has no directed cycles.
+
+    Parameters
+    ----------
+    G : NetworkX digraph
+        A directed acyclic graph (DAG)
+
+    Yields
+    ------
+    nodes
+        Yields the nodes in topological sorted order.
+
+    Raises
+    ------
+    NetworkXError
+        Topological sort is defined for directed graphs only. If the graph `G`
+        is undirected, a :exc:`NetworkXError` is raised.
+
+    NetworkXUnfeasible
+        If `G` is not a directed acyclic graph (DAG) no topological sort exists
+        and a :exc:`NetworkXUnfeasible` exception is raised.  This can also be
+        raised if `G` is changed while the returned iterator is being processed
+
+    RuntimeError
+        If `G` is changed while the returned iterator is being processed.
+
+    Examples
+    --------
+    To get the reverse order of the topological sort:
+
+    >>> DG = nx.DiGraph([(1, 2), (2, 3)])
+    >>> list(reversed(list(nx.topological_sort(DG))))
+    [3, 2, 1]
+
+    If your DiGraph naturally has the edges representing tasks/inputs
+    and nodes representing people/processes that initiate tasks, then
+    topological_sort is not quite what you need. You will have to change
+    the tasks to nodes with dependence reflected by edges. The result is
+    a kind of topological sort of the edges. This can be done
+    with :func:`networkx.line_graph` as follows:
+
+    >>> list(nx.topological_sort(nx.line_graph(DG)))
+    [(1, 2), (2, 3)]
+
+    Notes
+    -----
+    This algorithm is based on a description and proof in
+    "Introduction to Algorithms: A Creative Approach" [1]_ .
+
+    See also
+    --------
+    is_directed_acyclic_graph, lexicographical_topological_sort
+
+    References
+    ----------
+    .. [1] Manber, U. (1989).
+       *Introduction to Algorithms - A Creative Approach.* Addison-Wesley.
+    """
+    for generation in nx.topological_generations(G):
+        yield from generation
+
+
+def lexicographical_topological_sort(G, key=None):
+    """Returns a generator of nodes in lexicographically topologically sorted
+    order.
+
+    A topological sort is a nonunique permutation of the nodes such that an
+    edge from u to v implies that u appears before v in the topological sort
+    order.
+
+    Parameters
+    ----------
+    G : NetworkX digraph
+        A directed acyclic graph (DAG)
+
+    key : function, optional
+        This function maps nodes to keys with which to resolve ambiguities in
+        the sort order.  Defaults to the identity function.
+
+    Yields
+    ------
+    nodes
+        Yields the nodes in lexicographical topological sort order.
+
+    Raises
+    ------
+    NetworkXError
+        Topological sort is defined for directed graphs only. If the graph `G`
+        is undirected, a :exc:`NetworkXError` is raised.
+
+    NetworkXUnfeasible
+        If `G` is not a directed acyclic graph (DAG) no topological sort exists
+        and a :exc:`NetworkXUnfeasible` exception is raised.  This can also be
+        raised if `G` is changed while the returned iterator is being processed
+
+    RuntimeError
+        If `G` is changed while the returned iterator is being processed.
+
+    Examples
+    --------
+    >>> DG = nx.DiGraph([(2, 1), (2, 5), (1, 3), (1, 4), (5, 4)])
+    >>> list(nx.lexicographical_topological_sort(DG))
+    [2, 1, 3, 5, 4]
+    >>> list(nx.lexicographical_topological_sort(DG, key=lambda x: -x))
+    [2, 5, 1, 4, 3]
+
+    Notes
+    -----
+    This algorithm is based on a description and proof in
+    "Introduction to Algorithms: A Creative Approach" [1]_ .
+
+    See also
+    --------
+    topological_sort
+
+    References
+    ----------
+    .. [1] Manber, U. (1989).
+       *Introduction to Algorithms - A Creative Approach.* Addison-Wesley.
+    """
+    if not G.is_directed():
+        msg = "Topological sort not defined on undirected graphs."
+        raise nx.NetworkXError(msg)
+
+    if key is None:
+
+        def key(node):
+            return node
+
+    nodeid_map = {n: i for i, n in enumerate(G)}
+
+    def create_tuple(node):
+        return key(node), nodeid_map[node], node
+
+    indegree_map = {v: d for v, d in G.in_degree() if d > 0}
+    # These nodes have zero indegree and ready to be returned.
+    zero_indegree = [create_tuple(v) for v, d in G.in_degree() if d == 0]
+    heapq.heapify(zero_indegree)
+
+    while zero_indegree:
+        _, _, node = heapq.heappop(zero_indegree)
+
+        if node not in G:
+            raise RuntimeError("Graph changed during iteration")
+        for _, child in G.edges(node):
+            try:
+                indegree_map[child] -= 1
+            except KeyError as err:
+                raise RuntimeError("Graph changed during iteration") from err
+            if indegree_map[child] == 0:
+                heapq.heappush(zero_indegree, create_tuple(child))
+                del indegree_map[child]
+
+        yield node
+
+    if indegree_map:
+        msg = "Graph contains a cycle or graph changed during iteration"
+        raise nx.NetworkXUnfeasible(msg)
+
+
+@not_implemented_for("undirected")
+def all_topological_sorts(G):
+    """Returns a generator of _all_ topological sorts of the directed graph G.
+
+    A topological sort is a nonunique permutation of the nodes such that an
+    edge from u to v implies that u appears before v in the topological sort
+    order.
+
+    Parameters
+    ----------
+    G : NetworkX DiGraph
+        A directed graph
+
+    Yields
+    ------
+    topological_sort_order : list
+        a list of nodes in `G`, representing one of the topological sort orders
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is not directed
+    NetworkXUnfeasible
+        If `G` is not acyclic
+
+    Examples
+    --------
+    To enumerate all topological sorts of directed graph:
+
+    >>> DG = nx.DiGraph([(1, 2), (2, 3), (2, 4)])
+    >>> list(nx.all_topological_sorts(DG))
+    [[1, 2, 4, 3], [1, 2, 3, 4]]
+
+    Notes
+    -----
+    Implements an iterative version of the algorithm given in [1].
+
+    References
+    ----------
+    .. [1] Knuth, Donald E., Szwarcfiter, Jayme L. (1974).
+       "A Structured Program to Generate All Topological Sorting Arrangements"
+       Information Processing Letters, Volume 2, Issue 6, 1974, Pages 153-157,
+       ISSN 0020-0190,
+       https://doi.org/10.1016/0020-0190(74)90001-5.
+       Elsevier (North-Holland), Amsterdam
+    """
+    if not G.is_directed():
+        raise nx.NetworkXError("Topological sort not defined on undirected graphs.")
+
+    # the names of count and D are chosen to match the global variables in [1]
+    # number of edges originating in a vertex v
+    count = dict(G.in_degree())
+    # vertices with indegree 0
+    D = deque([v for v, d in G.in_degree() if d == 0])
+    # stack of first value chosen at a position k in the topological sort
+    bases = []
+    current_sort = []
+
+    # do-while construct
+    while True:
+        assert all([count[v] == 0 for v in D])
+
+        if len(current_sort) == len(G):
+            yield list(current_sort)
+
+            # clean-up stack
+            while len(current_sort) > 0:
+                assert len(bases) == len(current_sort)
+                q = current_sort.pop()
+
+                # "restores" all edges (q, x)
+                # NOTE: it is important to iterate over edges instead
+                # of successors, so count is updated correctly in multigraphs
+                for _, j in G.out_edges(q):
+                    count[j] += 1
+                    assert count[j] >= 0
+                # remove entries from D
+                while len(D) > 0 and count[D[-1]] > 0:
+                    D.pop()
+
+                # corresponds to a circular shift of the values in D
+                # if the first value chosen (the base) is in the first
+                # position of D again, we are done and need to consider the
+                # previous condition
+                D.appendleft(q)
+                if D[-1] == bases[-1]:
+                    # all possible values have been chosen at current position
+                    # remove corresponding marker
+                    bases.pop()
+                else:
+                    # there are still elements that have not been fixed
+                    # at the current position in the topological sort
+                    # stop removing elements, escape inner loop
+                    break
+
+        else:
+            if len(D) == 0:
+                raise nx.NetworkXUnfeasible("Graph contains a cycle.")
+
+            # choose next node
+            q = D.pop()
+            # "erase" all edges (q, x)
+            # NOTE: it is important to iterate over edges instead
+            # of successors, so count is updated correctly in multigraphs
+            for _, j in G.out_edges(q):
+                count[j] -= 1
+                assert count[j] >= 0
+                if count[j] == 0:
+                    D.append(j)
+            current_sort.append(q)
+
+            # base for current position might _not_ be fixed yet
+            if len(bases) < len(current_sort):
+                bases.append(q)
+
+        if len(bases) == 0:
+            break
+
+
+def is_aperiodic(G):
+    """Returns True if `G` is aperiodic.
+
+    A directed graph is aperiodic if there is no integer k > 1 that
+    divides the length of every cycle in the graph.
+
+    Parameters
+    ----------
+    G : NetworkX DiGraph
+        A directed graph
+
+    Returns
+    -------
+    bool
+        True if the graph is aperiodic False otherwise
+
+    Raises
+    ------
+    NetworkXError
+        If `G` is not directed
+
+    Examples
+    --------
+    A graph consisting of one cycle, the length of which is 2. Therefore ``k = 2``
+    divides the length of every cycle in the graph and thus the graph
+    is *not aperiodic*::
+
+        >>> DG = nx.DiGraph([(1, 2), (2, 1)])
+        >>> nx.is_aperiodic(DG)
+        False
+
+    A graph consisting of two cycles: one of length 2 and the other of length 3.
+    The cycle lengths are coprime, so there is no single value of k where ``k > 1``
+    that divides each cycle length and therefore the graph is *aperiodic*::
+
+        >>> DG = nx.DiGraph([(1, 2), (2, 3), (3, 1), (1, 4), (4, 1)])
+        >>> nx.is_aperiodic(DG)
+        True
+
+    A graph consisting of two cycles: one of length 2 and the other of length 4.
+    The lengths of the cycles share a common factor ``k = 2``, and therefore
+    the graph is *not aperiodic*::
+
+        >>> DG = nx.DiGraph([(1, 2), (2, 1), (3, 4), (4, 5), (5, 6), (6, 3)])
+        >>> nx.is_aperiodic(DG)
+        False
+
+    An acyclic graph, therefore the graph is *not aperiodic*::
+
+        >>> DG = nx.DiGraph([(1, 2), (2, 3)])
+        >>> nx.is_aperiodic(DG)
+        False
+
+    Notes
+    -----
+    This uses the method outlined in [1]_, which runs in $O(m)$ time
+    given $m$ edges in `G`. Note that a graph is not aperiodic if it is
+    acyclic as every integer trivial divides length 0 cycles.
+
+    References
+    ----------
+    .. [1] Jarvis, J. P.; Shier, D. R. (1996),
+       "Graph-theoretic analysis of finite Markov chains,"
+       in Shier, D. R.; Wallenius, K. T., Applied Mathematical Modeling:
+       A Multidisciplinary Approach, CRC Press.
+    """
+    if not G.is_directed():
+        raise nx.NetworkXError("is_aperiodic not defined for undirected graphs")
+
+    s = arbitrary_element(G)
+    levels = {s: 0}
+    this_level = [s]
+    g = 0
+    lev = 1
+    while this_level:
+        next_level = []
+        for u in this_level:
+            for v in G[u]:
+                if v in levels:  # Non-Tree Edge
+                    g = gcd(g, levels[u] - levels[v] + 1)
+                else:  # Tree Edge
+                    next_level.append(v)
+                    levels[v] = lev
+        this_level = next_level
+        lev += 1
+    if len(levels) == len(G):  # All nodes in tree
+        return g == 1
+    else:
+        return g == 1 and nx.is_aperiodic(G.subgraph(set(G) - set(levels)))
+
+
+def transitive_closure(G, reflexive=False):
+    """Returns transitive closure of a graph
+
+    The transitive closure of G = (V,E) is a graph G+ = (V,E+) such that
+    for all v, w in V there is an edge (v, w) in E+ if and only if there
+    is a path from v to w in G.
+
+    Handling of paths from v to v has some flexibility within this definition.
+    A reflexive transitive closure creates a self-loop for the path
+    from v to v of length 0. The usual transitive closure creates a
+    self-loop only if a cycle exists (a path from v to v with length > 0).
+    We also allow an option for no self-loops.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        A directed/undirected graph/multigraph.
+    reflexive : Bool or None, optional (default: False)
+        Determines when cycles create self-loops in the Transitive Closure.
+        If True, trivial cycles (length 0) create self-loops. The result
+        is a reflexive transitive closure of G.
+        If False (the default) non-trivial cycles create self-loops.
+        If None, self-loops are not created.
+
+    Returns
+    -------
+    NetworkX graph
+        The transitive closure of `G`
+
+    Raises
+    ------
+    NetworkXError
+        If `reflexive` not in `{None, True, False}`
+
+    Examples
+    --------
+    The treatment of trivial (i.e. length 0) cycles is controlled by the
+    `reflexive` parameter.
+
+    Trivial (i.e. length 0) cycles do not create self-loops when
+    ``reflexive=False`` (the default)::
+
+        >>> DG = nx.DiGraph([(1, 2), (2, 3)])
+        >>> TC = nx.transitive_closure(DG, reflexive=False)
+        >>> TC.edges()
+        OutEdgeView([(1, 2), (1, 3), (2, 3)])
+
+    However, nontrivial (i.e. length greater then 0) cycles create self-loops
+    when ``reflexive=False`` (the default)::
+
+        >>> DG = nx.DiGraph([(1, 2), (2, 3), (3, 1)])
+        >>> TC = nx.transitive_closure(DG, reflexive=False)
+        >>> TC.edges()
+        OutEdgeView([(1, 2), (1, 3), (1, 1), (2, 3), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3)])
+
+    Trivial cycles (length 0) create self-loops when ``reflexive=True``::
+
+        >>> DG = nx.DiGraph([(1, 2), (2, 3)])
+        >>> TC = nx.transitive_closure(DG, reflexive=True)
+        >>> TC.edges()
+        OutEdgeView([(1, 2), (1, 1), (1, 3), (2, 3), (2, 2), (3, 3)])
+
+    And the third option is not to create self-loops at all when ``reflexive=None``::
+
+        >>> DG = nx.DiGraph([(1, 2), (2, 3), (3, 1)])
+        >>> TC = nx.transitive_closure(DG, reflexive=None)
+        >>> TC.edges()
+        OutEdgeView([(1, 2), (1, 3), (2, 3), (2, 1), (3, 1), (3, 2)])
+
+    References
+    ----------
+    .. [1] https://www.ics.uci.edu/~eppstein/PADS/PartialOrder.py
+    """
+    TC = G.copy()
+
+    if reflexive not in {None, True, False}:
+        raise nx.NetworkXError("Incorrect value for the parameter `reflexive`")
+
+    for v in G:
+        if reflexive is None:
+            TC.add_edges_from((v, u) for u in nx.descendants(G, v) if u not in TC[v])
+        elif reflexive is True:
+            TC.add_edges_from(
+                (v, u) for u in nx.descendants(G, v) | {v} if u not in TC[v]
+            )
+        elif reflexive is False:
+            TC.add_edges_from((v, e[1]) for e in nx.edge_bfs(G, v) if e[1] not in TC[v])
+
+    return TC
+
+
+@not_implemented_for("undirected")
+def transitive_closure_dag(G, topo_order=None):
+    """Returns the transitive closure of a directed acyclic graph.
+
+    This function is faster than the function `transitive_closure`, but fails
+    if the graph has a cycle.
+
+    The transitive closure of G = (V,E) is a graph G+ = (V,E+) such that
+    for all v, w in V there is an edge (v, w) in E+ if and only if there
+    is a non-null path from v to w in G.
+
+    Parameters
+    ----------
+    G : NetworkX DiGraph
+        A directed acyclic graph (DAG)
+
+    topo_order: list or tuple, optional
+        A topological order for G (if None, the function will compute one)
+
+    Returns
+    -------
+    NetworkX DiGraph
+        The transitive closure of `G`
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is not directed
+    NetworkXUnfeasible
+        If `G` has a cycle
+
+    Examples
+    --------
+    >>> DG = nx.DiGraph([(1, 2), (2, 3)])
+    >>> TC = nx.transitive_closure_dag(DG)
+    >>> TC.edges()
+    OutEdgeView([(1, 2), (1, 3), (2, 3)])
+
+    Notes
+    -----
+    This algorithm is probably simple enough to be well-known but I didn't find
+    a mention in the literature.
+    """
+    if topo_order is None:
+        topo_order = list(topological_sort(G))
+
+    TC = G.copy()
+
+    # idea: traverse vertices following a reverse topological order, connecting
+    # each vertex to its descendants at distance 2 as we go
+    for v in reversed(topo_order):
+        TC.add_edges_from((v, u) for u in nx.descendants_at_distance(TC, v, 2))
+
+    return TC
+
+
+@not_implemented_for("undirected")
+def transitive_reduction(G):
+    """Returns transitive reduction of a directed graph
+
+    The transitive reduction of G = (V,E) is a graph G- = (V,E-) such that
+    for all v,w in V there is an edge (v,w) in E- if and only if (v,w) is
+    in E and there is no path from v to w in G with length greater than 1.
+
+    Parameters
+    ----------
+    G : NetworkX DiGraph
+        A directed acyclic graph (DAG)
+
+    Returns
+    -------
+    NetworkX DiGraph
+        The transitive reduction of `G`
+
+    Raises
+    ------
+    NetworkXError
+        If `G` is not a directed acyclic graph (DAG) transitive reduction is
+        not uniquely defined and a :exc:`NetworkXError` exception is raised.
+
+    Examples
+    --------
+    To perform transitive reduction on a DiGraph:
+
+    >>> DG = nx.DiGraph([(1, 2), (2, 3), (1, 3)])
+    >>> TR = nx.transitive_reduction(DG)
+    >>> list(TR.edges)
+    [(1, 2), (2, 3)]
+
+    To avoid unnecessary data copies, this implementation does not return a
+    DiGraph with node/edge data.
+    To perform transitive reduction on a DiGraph and transfer node/edge data:
+
+    >>> DG = nx.DiGraph()
+    >>> DG.add_edges_from([(1, 2), (2, 3), (1, 3)], color='red')
+    >>> TR = nx.transitive_reduction(DG)
+    >>> TR.add_nodes_from(DG.nodes(data=True))
+    >>> TR.add_edges_from((u, v, DG.edges[u, v]) for u, v in TR.edges)
+    >>> list(TR.edges(data=True))
+    [(1, 2, {'color': 'red'}), (2, 3, {'color': 'red'})]
+
+    References
+    ----------
+    https://en.wikipedia.org/wiki/Transitive_reduction
+
+    """
+    if not is_directed_acyclic_graph(G):
+        msg = "Directed Acyclic Graph required for transitive_reduction"
+        raise nx.NetworkXError(msg)
+    TR = nx.DiGraph()
+    TR.add_nodes_from(G.nodes())
+    descendants = {}
+    # count before removing set stored in descendants
+    check_count = dict(G.in_degree)
+    for u in G:
+        u_nbrs = set(G[u])
+        for v in G[u]:
+            if v in u_nbrs:
+                if v not in descendants:
+                    descendants[v] = {y for x, y in nx.dfs_edges(G, v)}
+                u_nbrs -= descendants[v]
+            check_count[v] -= 1
+            if check_count[v] == 0:
+                del descendants[v]
+        TR.add_edges_from((u, v) for v in u_nbrs)
+    return TR
+
+
+@not_implemented_for("undirected")
+def antichains(G, topo_order=None):
+    """Generates antichains from a directed acyclic graph (DAG).
+
+    An antichain is a subset of a partially ordered set such that any
+    two elements in the subset are incomparable.
+
+    Parameters
+    ----------
+    G : NetworkX DiGraph
+        A directed acyclic graph (DAG)
+
+    topo_order: list or tuple, optional
+        A topological order for G (if None, the function will compute one)
+
+    Yields
+    ------
+    antichain : list
+        a list of nodes in `G` representing an antichain
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is not directed
+
+    NetworkXUnfeasible
+        If `G` contains a cycle
+
+    Examples
+    --------
+    >>> DG = nx.DiGraph([(1, 2), (1, 3)])
+    >>> list(nx.antichains(DG))
+    [[], [3], [2], [2, 3], [1]]
+
+    Notes
+    -----
+    This function was originally developed by Peter Jipsen and Franco Saliola
+    for the SAGE project. It's included in NetworkX with permission from the
+    authors. Original SAGE code at:
+
+    https://github.com/sagemath/sage/blob/master/src/sage/combinat/posets/hasse_diagram.py
+
+    References
+    ----------
+    .. [1] Free Lattices, by R. Freese, J. Jezek and J. B. Nation,
+       AMS, Vol 42, 1995, p. 226.
+    """
+    if topo_order is None:
+        topo_order = list(nx.topological_sort(G))
+
+    TC = nx.transitive_closure_dag(G, topo_order)
+    antichains_stacks = [([], list(reversed(topo_order)))]
+
+    while antichains_stacks:
+        (antichain, stack) = antichains_stacks.pop()
+        # Invariant:
+        #  - the elements of antichain are independent
+        #  - the elements of stack are independent from those of antichain
+        yield antichain
+        while stack:
+            x = stack.pop()
+            new_antichain = antichain + [x]
+            new_stack = [t for t in stack if not ((t in TC[x]) or (x in TC[t]))]
+            antichains_stacks.append((new_antichain, new_stack))
+
+
+@not_implemented_for("undirected")
+def dag_longest_path(G, weight="weight", default_weight=1, topo_order=None):
+    """Returns the longest path in a directed acyclic graph (DAG).
+
+    If `G` has edges with `weight` attribute the edge data are used as
+    weight values.
+
+    Parameters
+    ----------
+    G : NetworkX DiGraph
+        A directed acyclic graph (DAG)
+
+    weight : str, optional
+        Edge data key to use for weight
+
+    default_weight : int, optional
+        The weight of edges that do not have a weight attribute
+
+    topo_order: list or tuple, optional
+        A topological order for `G` (if None, the function will compute one)
+
+    Returns
+    -------
+    list
+        Longest path
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is not directed
+
+    Examples
+    --------
+    >>> DG = nx.DiGraph([(0, 1, {'cost':1}), (1, 2, {'cost':1}), (0, 2, {'cost':42})])
+    >>> list(nx.all_simple_paths(DG, 0, 2))
+    [[0, 1, 2], [0, 2]]
+    >>> nx.dag_longest_path(DG)
+    [0, 1, 2]
+    >>> nx.dag_longest_path(DG, weight="cost")
+    [0, 2]
+
+    In the case where multiple valid topological orderings exist, `topo_order`
+    can be used to specify a specific ordering:
+
+    >>> DG = nx.DiGraph([(0, 1), (0, 2)])
+    >>> sorted(nx.all_topological_sorts(DG))  # Valid topological orderings
+    [[0, 1, 2], [0, 2, 1]]
+    >>> nx.dag_longest_path(DG, topo_order=[0, 1, 2])
+    [0, 1]
+    >>> nx.dag_longest_path(DG, topo_order=[0, 2, 1])
+    [0, 2]
+
+    See also
+    --------
+    dag_longest_path_length
+
+    """
+    if not G:
+        return []
+
+    if topo_order is None:
+        topo_order = nx.topological_sort(G)
+
+    dist = {}  # stores {v : (length, u)}
+    for v in topo_order:
+        us = [
+            (dist[u][0] + data.get(weight, default_weight), u)
+            for u, data in G.pred[v].items()
+        ]
+
+        # Use the best predecessor if there is one and its distance is
+        # non-negative, otherwise terminate.
+        maxu = max(us, key=lambda x: x[0]) if us else (0, v)
+        dist[v] = maxu if maxu[0] >= 0 else (0, v)
+
+    u = None
+    v = max(dist, key=lambda x: dist[x][0])
+    path = []
+    while u != v:
+        path.append(v)
+        u = v
+        v = dist[v][1]
+
+    path.reverse()
+    return path
+
+
+@not_implemented_for("undirected")
+def dag_longest_path_length(G, weight="weight", default_weight=1):
+    """Returns the longest path length in a DAG
+
+    Parameters
+    ----------
+    G : NetworkX DiGraph
+        A directed acyclic graph (DAG)
+
+    weight : string, optional
+        Edge data key to use for weight
+
+    default_weight : int, optional
+        The weight of edges that do not have a weight attribute
+
+    Returns
+    -------
+    int
+        Longest path length
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is not directed
+
+    Examples
+    --------
+    >>> DG = nx.DiGraph([(0, 1, {'cost':1}), (1, 2, {'cost':1}), (0, 2, {'cost':42})])
+    >>> list(nx.all_simple_paths(DG, 0, 2))
+    [[0, 1, 2], [0, 2]]
+    >>> nx.dag_longest_path_length(DG)
+    2
+    >>> nx.dag_longest_path_length(DG, weight="cost")
+    42
+
+    See also
+    --------
+    dag_longest_path
+    """
+    path = nx.dag_longest_path(G, weight, default_weight)
+    path_length = 0
+    for (u, v) in pairwise(path):
+        path_length += G[u][v].get(weight, default_weight)
+
+    return path_length
+
+
+def root_to_leaf_paths(G):
+    """Yields root-to-leaf paths in a directed acyclic graph.
+
+    `G` must be a directed acyclic graph. If not, the behavior of this
+    function is undefined. A "root" in this graph is a node of in-degree
+    zero and a "leaf" a node of out-degree zero.
+
+    When invoked, this function iterates over each path from any root to
+    any leaf. A path is a list of nodes.
+
+    """
+    roots = (v for v, d in G.in_degree() if d == 0)
+    leaves = (v for v, d in G.out_degree() if d == 0)
+    all_paths = partial(nx.all_simple_paths, G)
+    # TODO In Python 3, this would be better as `yield from ...`.
+    return chaini(starmap(all_paths, product(roots, leaves)))
+
+
+@not_implemented_for("multigraph")
+@not_implemented_for("undirected")
+def dag_to_branching(G):
+    """Returns a branching representing all (overlapping) paths from
+    root nodes to leaf nodes in the given directed acyclic graph.
+
+    As described in :mod:`networkx.algorithms.tree.recognition`, a
+    *branching* is a directed forest in which each node has at most one
+    parent. In other words, a branching is a disjoint union of
+    *arborescences*. For this function, each node of in-degree zero in
+    `G` becomes a root of one of the arborescences, and there will be
+    one leaf node for each distinct path from that root to a leaf node
+    in `G`.
+
+    Each node `v` in `G` with *k* parents becomes *k* distinct nodes in
+    the returned branching, one for each parent, and the sub-DAG rooted
+    at `v` is duplicated for each copy. The algorithm then recurses on
+    the children of each copy of `v`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A directed acyclic graph.
+
+    Returns
+    -------
+    DiGraph
+        The branching in which there is a bijection between root-to-leaf
+        paths in `G` (in which multiple paths may share the same leaf)
+        and root-to-leaf paths in the branching (in which there is a
+        unique path from a root to a leaf).
+
+        Each node has an attribute 'source' whose value is the original
+        node to which this node corresponds. No other graph, node, or
+        edge attributes are copied into this new graph.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is not directed, or if `G` is a multigraph.
+
+    HasACycle
+        If `G` is not acyclic.
+
+    Examples
+    --------
+    To examine which nodes in the returned branching were produced by
+    which original node in the directed acyclic graph, we can collect
+    the mapping from source node to new nodes into a dictionary. For
+    example, consider the directed diamond graph::
+
+        >>> from collections import defaultdict
+        >>> from operator import itemgetter
+        >>>
+        >>> G = nx.DiGraph(nx.utils.pairwise("abd"))
+        >>> G.add_edges_from(nx.utils.pairwise("acd"))
+        >>> B = nx.dag_to_branching(G)
+        >>>
+        >>> sources = defaultdict(set)
+        >>> for v, source in B.nodes(data="source"):
+        ...     sources[source].add(v)
+        >>> len(sources["a"])
+        1
+        >>> len(sources["d"])
+        2
+
+    To copy node attributes from the original graph to the new graph,
+    you can use a dictionary like the one constructed in the above
+    example::
+
+        >>> for source, nodes in sources.items():
+        ...     for v in nodes:
+        ...         B.nodes[v].update(G.nodes[source])
+
+    Notes
+    -----
+    This function is not idempotent in the sense that the node labels in
+    the returned branching may be uniquely generated each time the
+    function is invoked. In fact, the node labels may not be integers;
+    in order to relabel the nodes to be more readable, you can use the
+    :func:`networkx.convert_node_labels_to_integers` function.
+
+    The current implementation of this function uses
+    :func:`networkx.prefix_tree`, so it is subject to the limitations of
+    that function.
+
+    """
+    if has_cycle(G):
+        msg = "dag_to_branching is only defined for acyclic graphs"
+        raise nx.HasACycle(msg)
+    paths = root_to_leaf_paths(G)
+    B = nx.prefix_tree(paths)
+    # Remove the synthetic `root`(0) and `NIL`(-1) nodes from the tree
+    B.remove_node(0)
+    B.remove_node(-1)
+    return B
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/distance_measures.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/distance_measures.py
new file mode 100644
index 0000000..3f59a2a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/distance_measures.py
@@ -0,0 +1,707 @@
+"""Graph diameter, radius, eccentricity and other properties."""
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "extrema_bounding",
+    "eccentricity",
+    "diameter",
+    "radius",
+    "periphery",
+    "center",
+    "barycenter",
+    "resistance_distance",
+]
+
+
+def extrema_bounding(G, compute="diameter"):
+    """Compute requested extreme distance metric of undirected graph G
+
+    .. deprecated:: 2.8
+
+       extrema_bounding is deprecated and will be removed in NetworkX 3.0.
+       Use the corresponding distance measure with the `usebounds=True` option
+       instead.
+
+    Computation is based on smart lower and upper bounds, and in practice
+    linear in the number of nodes, rather than quadratic (except for some
+    border cases such as complete graphs or circle shaped graphs).
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph
+
+    compute : string denoting the requesting metric
+       "diameter" for the maximal eccentricity value,
+       "radius" for the minimal eccentricity value,
+       "periphery" for the set of nodes with eccentricity equal to the diameter,
+       "center" for the set of nodes with eccentricity equal to the radius,
+       "eccentricities" for the maximum distance from each node to all other nodes in G
+
+    Returns
+    -------
+    value : value of the requested metric
+       int for "diameter" and "radius" or
+       list of nodes for "center" and "periphery" or
+       dictionary of eccentricity values keyed by node for "eccentricities"
+
+    Raises
+    ------
+    NetworkXError
+        If the graph consists of multiple components
+    ValueError
+        If `compute` is not one of "diameter", "radius", "periphery", "center",
+        or "eccentricities".
+
+    Notes
+    -----
+    This algorithm was proposed in the following papers:
+
+    F.W. Takes and W.A. Kosters, Determining the Diameter of Small World
+    Networks, in Proceedings of the 20th ACM International Conference on
+    Information and Knowledge Management (CIKM 2011), pp. 1191-1196, 2011.
+    doi: https://doi.org/10.1145/2063576.2063748
+
+    F.W. Takes and W.A. Kosters, Computing the Eccentricity Distribution of
+    Large Graphs, Algorithms 6(1): 100-118, 2013.
+    doi: https://doi.org/10.3390/a6010100
+
+    M. Borassi, P. Crescenzi, M. Habib, W.A. Kosters, A. Marino and F.W. Takes,
+    Fast Graph Diameter and Radius BFS-Based Computation in (Weakly Connected)
+    Real-World Graphs, Theoretical Computer Science 586: 59-80, 2015.
+    doi: https://doi.org/10.1016/j.tcs.2015.02.033
+    """
+    import warnings
+
+    msg = "extrema_bounding is deprecated and will be removed in networkx 3.0\n"
+    # NOTE: _extrema_bounding does input checking, so it is skipped here
+    if compute in {"diameter", "radius", "periphery", "center"}:
+        msg += f"Use nx.{compute}(G, usebounds=True) instead."
+    if compute == "eccentricities":
+        msg += f"Use nx.eccentricity(G) instead."
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+
+    return _extrema_bounding(G, compute=compute)
+
+
+def _extrema_bounding(G, compute="diameter"):
+    """Compute requested extreme distance metric of undirected graph G
+
+    Computation is based on smart lower and upper bounds, and in practice
+    linear in the number of nodes, rather than quadratic (except for some
+    border cases such as complete graphs or circle shaped graphs).
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph
+
+    compute : string denoting the requesting metric
+       "diameter" for the maximal eccentricity value,
+       "radius" for the minimal eccentricity value,
+       "periphery" for the set of nodes with eccentricity equal to the diameter,
+       "center" for the set of nodes with eccentricity equal to the radius,
+       "eccentricities" for the maximum distance from each node to all other nodes in G
+
+    Returns
+    -------
+    value : value of the requested metric
+       int for "diameter" and "radius" or
+       list of nodes for "center" and "periphery" or
+       dictionary of eccentricity values keyed by node for "eccentricities"
+
+    Raises
+    ------
+    NetworkXError
+        If the graph consists of multiple components
+    ValueError
+        If `compute` is not one of "diameter", "radius", "periphery", "center", or "eccentricities".
+    Notes
+    -----
+    This algorithm was proposed in the following papers:
+
+    F.W. Takes and W.A. Kosters, Determining the Diameter of Small World
+    Networks, in Proceedings of the 20th ACM International Conference on
+    Information and Knowledge Management (CIKM 2011), pp. 1191-1196, 2011.
+    doi: https://doi.org/10.1145/2063576.2063748
+
+    F.W. Takes and W.A. Kosters, Computing the Eccentricity Distribution of
+    Large Graphs, Algorithms 6(1): 100-118, 2013.
+    doi: https://doi.org/10.3390/a6010100
+
+    M. Borassi, P. Crescenzi, M. Habib, W.A. Kosters, A. Marino and F.W. Takes,
+    Fast Graph Diameter and Radius BFS-Based Computation in (Weakly Connected)
+    Real-World Graphs, Theoretical Computer Science 586: 59-80, 2015.
+    doi: https://doi.org/10.1016/j.tcs.2015.02.033
+    """
+
+    # init variables
+    degrees = dict(G.degree())  # start with the highest degree node
+    minlowernode = max(degrees, key=degrees.get)
+    N = len(degrees)  # number of nodes
+    # alternate between smallest lower and largest upper bound
+    high = False
+    # status variables
+    ecc_lower = dict.fromkeys(G, 0)
+    ecc_upper = dict.fromkeys(G, N)
+    candidates = set(G)
+
+    # (re)set bound extremes
+    minlower = N
+    maxlower = 0
+    minupper = N
+    maxupper = 0
+
+    # repeat the following until there are no more candidates
+    while candidates:
+        if high:
+            current = maxuppernode  # select node with largest upper bound
+        else:
+            current = minlowernode  # select node with smallest lower bound
+        high = not high
+
+        # get distances from/to current node and derive eccentricity
+        dist = dict(nx.single_source_shortest_path_length(G, current))
+        if len(dist) != N:
+            msg = "Cannot compute metric because graph is not connected."
+            raise nx.NetworkXError(msg)
+        current_ecc = max(dist.values())
+
+        # print status update
+        #        print ("ecc of " + str(current) + " (" + str(ecc_lower[current]) + "/"
+        #        + str(ecc_upper[current]) + ", deg: " + str(dist[current]) + ") is "
+        #        + str(current_ecc))
+        #        print(ecc_upper)
+
+        # (re)set bound extremes
+        maxuppernode = None
+        minlowernode = None
+
+        # update node bounds
+        for i in candidates:
+            # update eccentricity bounds
+            d = dist[i]
+            ecc_lower[i] = low = max(ecc_lower[i], max(d, (current_ecc - d)))
+            ecc_upper[i] = upp = min(ecc_upper[i], current_ecc + d)
+
+            # update min/max values of lower and upper bounds
+            minlower = min(ecc_lower[i], minlower)
+            maxlower = max(ecc_lower[i], maxlower)
+            minupper = min(ecc_upper[i], minupper)
+            maxupper = max(ecc_upper[i], maxupper)
+
+        # update candidate set
+        if compute == "diameter":
+            ruled_out = {
+                i
+                for i in candidates
+                if ecc_upper[i] <= maxlower and 2 * ecc_lower[i] >= maxupper
+            }
+        elif compute == "radius":
+            ruled_out = {
+                i
+                for i in candidates
+                if ecc_lower[i] >= minupper and ecc_upper[i] + 1 <= 2 * minlower
+            }
+        elif compute == "periphery":
+            ruled_out = {
+                i
+                for i in candidates
+                if ecc_upper[i] < maxlower
+                and (maxlower == maxupper or ecc_lower[i] > maxupper)
+            }
+        elif compute == "center":
+            ruled_out = {
+                i
+                for i in candidates
+                if ecc_lower[i] > minupper
+                and (minlower == minupper or ecc_upper[i] + 1 < 2 * minlower)
+            }
+        elif compute == "eccentricities":
+            ruled_out = set()
+        else:
+            msg = "compute must be one of 'diameter', 'radius', 'periphery', 'center', 'eccentricities'"
+            raise ValueError(msg)
+
+        ruled_out.update(i for i in candidates if ecc_lower[i] == ecc_upper[i])
+        candidates -= ruled_out
+
+        #        for i in ruled_out:
+        #            print("removing %g: ecc_u: %g maxl: %g ecc_l: %g maxu: %g"%
+        #                    (i,ecc_upper[i],maxlower,ecc_lower[i],maxupper))
+        #        print("node %g: ecc_u: %g maxl: %g ecc_l: %g maxu: %g"%
+        #                    (4,ecc_upper[4],maxlower,ecc_lower[4],maxupper))
+        #        print("NODE 4: %g"%(ecc_upper[4] <= maxlower))
+        #        print("NODE 4: %g"%(2 * ecc_lower[4] >= maxupper))
+        #        print("NODE 4: %g"%(ecc_upper[4] <= maxlower
+        #                            and 2 * ecc_lower[4] >= maxupper))
+
+        # updating maxuppernode and minlowernode for selection in next round
+        for i in candidates:
+            if (
+                minlowernode is None
+                or (
+                    ecc_lower[i] == ecc_lower[minlowernode]
+                    and degrees[i] > degrees[minlowernode]
+                )
+                or (ecc_lower[i] < ecc_lower[minlowernode])
+            ):
+                minlowernode = i
+
+            if (
+                maxuppernode is None
+                or (
+                    ecc_upper[i] == ecc_upper[maxuppernode]
+                    and degrees[i] > degrees[maxuppernode]
+                )
+                or (ecc_upper[i] > ecc_upper[maxuppernode])
+            ):
+                maxuppernode = i
+
+        # print status update
+    #        print (" min=" + str(minlower) + "/" + str(minupper) +
+    #        " max=" + str(maxlower) + "/" + str(maxupper) +
+    #        " candidates: " + str(len(candidates)))
+    #        print("cand:",candidates)
+    #        print("ecc_l",ecc_lower)
+    #        print("ecc_u",ecc_upper)
+    #        wait = input("press Enter to continue")
+
+    # return the correct value of the requested metric
+    if compute == "diameter":
+        return maxlower
+    elif compute == "radius":
+        return minupper
+    elif compute == "periphery":
+        p = [v for v in G if ecc_lower[v] == maxlower]
+        return p
+    elif compute == "center":
+        c = [v for v in G if ecc_upper[v] == minupper]
+        return c
+    elif compute == "eccentricities":
+        return ecc_lower
+    return None
+
+
+def eccentricity(G, v=None, sp=None):
+    """Returns the eccentricity of nodes in G.
+
+    The eccentricity of a node v is the maximum distance from v to
+    all other nodes in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph
+
+    v : node, optional
+       Return value of specified node
+
+    sp : dict of dicts, optional
+       All pairs shortest path lengths as a dictionary of dictionaries
+
+    Returns
+    -------
+    ecc : dictionary
+       A dictionary of eccentricity values keyed by node.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)])
+    >>> dict(nx.eccentricity(G))
+    {1: 2, 2: 3, 3: 2, 4: 2, 5: 3}
+
+    >>> dict(nx.eccentricity(G, v=[1, 5]))  # This returns the eccentrity of node 1 & 5
+    {1: 2, 5: 3}
+
+    """
+    #    if v is None:                # none, use entire graph
+    #        nodes=G.nodes()
+    #    elif v in G:               # is v a single node
+    #        nodes=[v]
+    #    else:                      # assume v is a container of nodes
+    #        nodes=v
+    order = G.order()
+
+    e = {}
+    for n in G.nbunch_iter(v):
+        if sp is None:
+            length = nx.single_source_shortest_path_length(G, n)
+            L = len(length)
+        else:
+            try:
+                length = sp[n]
+                L = len(length)
+            except TypeError as err:
+                raise nx.NetworkXError('Format of "sp" is invalid.') from err
+        if L != order:
+            if G.is_directed():
+                msg = (
+                    "Found infinite path length because the digraph is not"
+                    " strongly connected"
+                )
+            else:
+                msg = "Found infinite path length because the graph is not" " connected"
+            raise nx.NetworkXError(msg)
+
+        e[n] = max(length.values())
+
+    if v in G:
+        return e[v]  # return single value
+    else:
+        return e
+
+
+def diameter(G, e=None, usebounds=False):
+    """Returns the diameter of the graph G.
+
+    The diameter is the maximum eccentricity.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph
+
+    e : eccentricity dictionary, optional
+      A precomputed dictionary of eccentricities.
+
+    Returns
+    -------
+    d : integer
+       Diameter of graph
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)])
+    >>> nx.diameter(G)
+    3
+
+    See Also
+    --------
+    eccentricity
+    """
+    if usebounds is True and e is None and not G.is_directed():
+        return _extrema_bounding(G, compute="diameter")
+    if e is None:
+        e = eccentricity(G)
+    return max(e.values())
+
+
+def periphery(G, e=None, usebounds=False):
+    """Returns the periphery of the graph G.
+
+    The periphery is the set of nodes with eccentricity equal to the diameter.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph
+
+    e : eccentricity dictionary, optional
+      A precomputed dictionary of eccentricities.
+
+    Returns
+    -------
+    p : list
+       List of nodes in periphery
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)])
+    >>> nx.periphery(G)
+    [2, 5]
+
+    See Also
+    --------
+    barycenter
+    center
+    """
+    if usebounds is True and e is None and not G.is_directed():
+        return _extrema_bounding(G, compute="periphery")
+    if e is None:
+        e = eccentricity(G)
+    diameter = max(e.values())
+    p = [v for v in e if e[v] == diameter]
+    return p
+
+
+def radius(G, e=None, usebounds=False):
+    """Returns the radius of the graph G.
+
+    The radius is the minimum eccentricity.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph
+
+    e : eccentricity dictionary, optional
+      A precomputed dictionary of eccentricities.
+
+    Returns
+    -------
+    r : integer
+       Radius of graph
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)])
+    >>> nx.radius(G)
+    2
+
+    """
+    if usebounds is True and e is None and not G.is_directed():
+        return _extrema_bounding(G, compute="radius")
+    if e is None:
+        e = eccentricity(G)
+    return min(e.values())
+
+
+def center(G, e=None, usebounds=False):
+    """Returns the center of the graph G.
+
+    The center is the set of nodes with eccentricity equal to radius.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph
+
+    e : eccentricity dictionary, optional
+      A precomputed dictionary of eccentricities.
+
+    Returns
+    -------
+    c : list
+       List of nodes in center
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)])
+    >>> list(nx.center(G))
+    [1, 3, 4]
+
+    See Also
+    --------
+    barycenter
+    periphery
+    """
+    if usebounds is True and e is None and not G.is_directed():
+        return _extrema_bounding(G, compute="center")
+    if e is None:
+        e = eccentricity(G)
+    radius = min(e.values())
+    p = [v for v in e if e[v] == radius]
+    return p
+
+
+def barycenter(G, weight=None, attr=None, sp=None):
+    r"""Calculate barycenter of a connected graph, optionally with edge weights.
+
+    The :dfn:`barycenter` a
+    :func:`connected <networkx.algorithms.components.is_connected>` graph
+    :math:`G` is the subgraph induced by the set of its nodes :math:`v`
+    minimizing the objective function
+
+    .. math::
+
+        \sum_{u \in V(G)} d_G(u, v),
+
+    where :math:`d_G` is the (possibly weighted) :func:`path length
+    <networkx.algorithms.shortest_paths.generic.shortest_path_length>`.
+    The barycenter is also called the :dfn:`median`. See [West01]_, p. 78.
+
+    Parameters
+    ----------
+    G : :class:`networkx.Graph`
+        The connected graph :math:`G`.
+    weight : :class:`str`, optional
+        Passed through to
+        :func:`~networkx.algorithms.shortest_paths.generic.shortest_path_length`.
+    attr : :class:`str`, optional
+        If given, write the value of the objective function to each node's
+        `attr` attribute. Otherwise do not store the value.
+    sp : dict of dicts, optional
+       All pairs shortest path lengths as a dictionary of dictionaries
+
+    Returns
+    -------
+    list
+        Nodes of `G` that induce the barycenter of `G`.
+
+    Raises
+    ------
+    NetworkXNoPath
+        If `G` is disconnected. `G` may appear disconnected to
+        :func:`barycenter` if `sp` is given but is missing shortest path
+        lengths for any pairs.
+    ValueError
+        If `sp` and `weight` are both given.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)])
+    >>> nx.barycenter(G)
+    [1, 3, 4]
+
+    See Also
+    --------
+    center
+    periphery
+    """
+    if sp is None:
+        sp = nx.shortest_path_length(G, weight=weight)
+    else:
+        sp = sp.items()
+        if weight is not None:
+            raise ValueError("Cannot use both sp, weight arguments together")
+    smallest, barycenter_vertices, n = float("inf"), [], len(G)
+    for v, dists in sp:
+        if len(dists) < n:
+            raise nx.NetworkXNoPath(
+                f"Input graph {G} is disconnected, so every induced subgraph "
+                "has infinite barycentricity."
+            )
+        barycentricity = sum(dists.values())
+        if attr is not None:
+            G.nodes[v][attr] = barycentricity
+        if barycentricity < smallest:
+            smallest = barycentricity
+            barycenter_vertices = [v]
+        elif barycentricity == smallest:
+            barycenter_vertices.append(v)
+    return barycenter_vertices
+
+
+def _count_lu_permutations(perm_array):
+    """Counts the number of permutations in SuperLU perm_c or perm_r"""
+    perm_cnt = 0
+    arr = perm_array.tolist()
+    for i in range(len(arr)):
+        if i != arr[i]:
+            perm_cnt += 1
+            n = arr.index(i)
+            arr[n] = arr[i]
+            arr[i] = i
+
+    return perm_cnt
+
+
+@not_implemented_for("directed")
+def resistance_distance(G, nodeA, nodeB, weight=None, invert_weight=True):
+    """Returns the resistance distance between node A and node B on graph G.
+
+    The resistance distance between two nodes of a graph is akin to treating
+    the graph as a grid of resistorses with a resistance equal to the provided
+    weight.
+
+    If weight is not provided, then a weight of 1 is used for all edges.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph
+
+    nodeA : node
+      A node within graph G.
+
+    nodeB : node
+      A node within graph G, exclusive of Node A.
+
+    weight : string or None, optional (default=None)
+       The edge data key used to compute the resistance distance.
+       If None, then each edge has weight 1.
+
+    invert_weight : boolean (default=True)
+        Proper calculation of resistance distance requires building the
+        Laplacian matrix with the reciprocal of the weight. Not required
+        if the weight is already inverted. Weight cannot be zero.
+
+    Returns
+    -------
+    rd : float
+       Value of effective resistance distance
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)])
+    >>> nx.resistance_distance(G, 1, 3)
+    0.625
+
+    Notes
+    -----
+    Overview discussion:
+    * https://en.wikipedia.org/wiki/Resistance_distance
+    * http://mathworld.wolfram.com/ResistanceDistance.html
+
+    Additional details:
+    Vaya Sapobi Samui Vos, “Methods for determining the effective resistance,” M.S.,
+    Mathematisch Instituut, Universiteit Leiden, Leiden, Netherlands, 2016
+    Available: `Link to thesis <https://www.universiteitleiden.nl/binaries/content/assets/science/mi/scripties/master/vos_vaya_master.pdf>`_
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse.linalg  # call as sp.sparse.linalg
+
+    if not nx.is_connected(G):
+        msg = "Graph G must be strongly connected."
+        raise nx.NetworkXError(msg)
+    elif nodeA not in G:
+        msg = "Node A is not in graph G."
+        raise nx.NetworkXError(msg)
+    elif nodeB not in G:
+        msg = "Node B is not in graph G."
+        raise nx.NetworkXError(msg)
+    elif nodeA == nodeB:
+        msg = "Node A and Node B cannot be the same."
+        raise nx.NetworkXError(msg)
+
+    G = G.copy()
+    node_list = list(G)
+
+    if invert_weight and weight is not None:
+        if G.is_multigraph():
+            for (u, v, k, d) in G.edges(keys=True, data=True):
+                d[weight] = 1 / d[weight]
+        else:
+            for (u, v, d) in G.edges(data=True):
+                d[weight] = 1 / d[weight]
+    # Replace with collapsing topology or approximated zero?
+
+    # Using determinants to compute the effective resistance is more memory
+    # efficent than directly calculating the psuedo-inverse
+    L = nx.laplacian_matrix(G, node_list, weight=weight).asformat("csc")
+    indices = list(range(L.shape[0]))
+    # w/ nodeA removed
+    indices.remove(node_list.index(nodeA))
+    L_a = L[indices, :][:, indices]
+    # Both nodeA and nodeB removed
+    indices.remove(node_list.index(nodeB))
+    L_ab = L[indices, :][:, indices]
+
+    # Factorize Laplacian submatrixes and extract diagonals
+    # Order the diagonals to minimize the likelihood over overflows
+    # during computing the determinant
+    lu_a = sp.sparse.linalg.splu(L_a, options=dict(SymmetricMode=True))
+    LdiagA = lu_a.U.diagonal()
+    LdiagA_s = np.product(np.sign(LdiagA)) * np.product(lu_a.L.diagonal())
+    LdiagA_s *= (-1) ** _count_lu_permutations(lu_a.perm_r)
+    LdiagA_s *= (-1) ** _count_lu_permutations(lu_a.perm_c)
+    LdiagA = np.absolute(LdiagA)
+    LdiagA = np.sort(LdiagA)
+
+    lu_ab = sp.sparse.linalg.splu(L_ab, options=dict(SymmetricMode=True))
+    LdiagAB = lu_ab.U.diagonal()
+    LdiagAB_s = np.product(np.sign(LdiagAB)) * np.product(lu_ab.L.diagonal())
+    LdiagAB_s *= (-1) ** _count_lu_permutations(lu_ab.perm_r)
+    LdiagAB_s *= (-1) ** _count_lu_permutations(lu_ab.perm_c)
+    LdiagAB = np.absolute(LdiagAB)
+    LdiagAB = np.sort(LdiagAB)
+
+    # Calculate the ratio of determinant, rd = det(L_ab)/det(L_a)
+    Ldet = np.product(np.divide(np.append(LdiagAB, [1]), LdiagA))
+    rd = Ldet * LdiagAB_s / LdiagA_s
+
+    return rd
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/distance_regular.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/distance_regular.py
new file mode 100644
index 0000000..bef9f01
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/distance_regular.py
@@ -0,0 +1,231 @@
+"""
+=======================
+Distance-regular graphs
+=======================
+"""
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+from .distance_measures import diameter
+
+__all__ = [
+    "is_distance_regular",
+    "is_strongly_regular",
+    "intersection_array",
+    "global_parameters",
+]
+
+
+def is_distance_regular(G):
+    """Returns True if the graph is distance regular, False otherwise.
+
+    A connected graph G is distance-regular if for any nodes x,y
+    and any integers i,j=0,1,...,d (where d is the graph
+    diameter), the number of vertices at distance i from x and
+    distance j from y depends only on i,j and the graph distance
+    between x and y, independently of the choice of x and y.
+
+    Parameters
+    ----------
+    G: Networkx graph (undirected)
+
+    Returns
+    -------
+    bool
+      True if the graph is Distance Regular, False otherwise
+
+    Examples
+    --------
+    >>> G = nx.hypercube_graph(6)
+    >>> nx.is_distance_regular(G)
+    True
+
+    See Also
+    --------
+    intersection_array, global_parameters
+
+    Notes
+    -----
+    For undirected and simple graphs only
+
+    References
+    ----------
+    .. [1] Brouwer, A. E.; Cohen, A. M.; and Neumaier, A.
+        Distance-Regular Graphs. New York: Springer-Verlag, 1989.
+    .. [2] Weisstein, Eric W. "Distance-Regular Graph."
+        http://mathworld.wolfram.com/Distance-RegularGraph.html
+
+    """
+    try:
+        intersection_array(G)
+        return True
+    except nx.NetworkXError:
+        return False
+
+
+def global_parameters(b, c):
+    """Returns global parameters for a given intersection array.
+
+    Given a distance-regular graph G with integers b_i, c_i,i = 0,....,d
+    such that for any 2 vertices x,y in G at a distance i=d(x,y), there
+    are exactly c_i neighbors of y at a distance of i-1 from x and b_i
+    neighbors of y at a distance of i+1 from x.
+
+    Thus, a distance regular graph has the global parameters,
+    [[c_0,a_0,b_0],[c_1,a_1,b_1],......,[c_d,a_d,b_d]] for the
+    intersection array  [b_0,b_1,.....b_{d-1};c_1,c_2,.....c_d]
+    where a_i+b_i+c_i=k , k= degree of every vertex.
+
+    Parameters
+    ----------
+    b : list
+
+    c : list
+
+    Returns
+    -------
+    iterable
+       An iterable over three tuples.
+
+    Examples
+    --------
+    >>> G = nx.dodecahedral_graph()
+    >>> b, c = nx.intersection_array(G)
+    >>> list(nx.global_parameters(b, c))
+    [(0, 0, 3), (1, 0, 2), (1, 1, 1), (1, 1, 1), (2, 0, 1), (3, 0, 0)]
+
+    References
+    ----------
+    .. [1] Weisstein, Eric W. "Global Parameters."
+       From MathWorld--A Wolfram Web Resource.
+       http://mathworld.wolfram.com/GlobalParameters.html
+
+    See Also
+    --------
+    intersection_array
+    """
+    return ((y, b[0] - x - y, x) for x, y in zip(b + [0], [0] + c))
+
+
+@not_implemented_for("directed", "multigraph")
+def intersection_array(G):
+    """Returns the intersection array of a distance-regular graph.
+
+    Given a distance-regular graph G with integers b_i, c_i,i = 0,....,d
+    such that for any 2 vertices x,y in G at a distance i=d(x,y), there
+    are exactly c_i neighbors of y at a distance of i-1 from x and b_i
+    neighbors of y at a distance of i+1 from x.
+
+    A distance regular graph's intersection array is given by,
+    [b_0,b_1,.....b_{d-1};c_1,c_2,.....c_d]
+
+    Parameters
+    ----------
+    G: Networkx graph (undirected)
+
+    Returns
+    -------
+    b,c: tuple of lists
+
+    Examples
+    --------
+    >>> G = nx.icosahedral_graph()
+    >>> nx.intersection_array(G)
+    ([5, 2, 1], [1, 2, 5])
+
+    References
+    ----------
+    .. [1] Weisstein, Eric W. "Intersection Array."
+       From MathWorld--A Wolfram Web Resource.
+       http://mathworld.wolfram.com/IntersectionArray.html
+
+    See Also
+    --------
+    global_parameters
+    """
+    # test for regular graph (all degrees must be equal)
+    degree = iter(G.degree())
+    (_, k) = next(degree)
+    for _, knext in degree:
+        if knext != k:
+            raise nx.NetworkXError("Graph is not distance regular.")
+        k = knext
+    path_length = dict(nx.all_pairs_shortest_path_length(G))
+    diameter = max(max(path_length[n].values()) for n in path_length)
+    bint = {}  # 'b' intersection array
+    cint = {}  # 'c' intersection array
+    for u in G:
+        for v in G:
+            try:
+                i = path_length[u][v]
+            except KeyError as err:  # graph must be connected
+                raise nx.NetworkXError("Graph is not distance regular.") from err
+            # number of neighbors of v at a distance of i-1 from u
+            c = len([n for n in G[v] if path_length[n][u] == i - 1])
+            # number of neighbors of v at a distance of i+1 from u
+            b = len([n for n in G[v] if path_length[n][u] == i + 1])
+            # b,c are independent of u and v
+            if cint.get(i, c) != c or bint.get(i, b) != b:
+                raise nx.NetworkXError("Graph is not distance regular")
+            bint[i] = b
+            cint[i] = c
+    return (
+        [bint.get(j, 0) for j in range(diameter)],
+        [cint.get(j + 1, 0) for j in range(diameter)],
+    )
+
+
+# TODO There is a definition for directed strongly regular graphs.
+@not_implemented_for("directed", "multigraph")
+def is_strongly_regular(G):
+    """Returns True if and only if the given graph is strongly
+    regular.
+
+    An undirected graph is *strongly regular* if
+
+    * it is regular,
+    * each pair of adjacent vertices has the same number of neighbors in
+      common,
+    * each pair of nonadjacent vertices has the same number of neighbors
+      in common.
+
+    Each strongly regular graph is a distance-regular graph.
+    Conversely, if a distance-regular graph has diameter two, then it is
+    a strongly regular graph. For more information on distance-regular
+    graphs, see :func:`is_distance_regular`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+
+    Returns
+    -------
+    bool
+        Whether `G` is strongly regular.
+
+    Examples
+    --------
+
+    The cycle graph on five vertices is strongly regular. It is
+    two-regular, each pair of adjacent vertices has no shared neighbors,
+    and each pair of nonadjacent vertices has one shared neighbor::
+
+        >>> G = nx.cycle_graph(5)
+        >>> nx.is_strongly_regular(G)
+        True
+
+    """
+    # Here is an alternate implementation based directly on the
+    # definition of strongly regular graphs:
+    #
+    #     return (all_equal(G.degree().values())
+    #             and all_equal(len(common_neighbors(G, u, v))
+    #                           for u, v in G.edges())
+    #             and all_equal(len(common_neighbors(G, u, v))
+    #                           for u, v in non_edges(G)))
+    #
+    # We instead use the fact that a distance-regular graph of diameter
+    # two is strongly regular.
+    return is_distance_regular(G) and diameter(G) == 2
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/dominance.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/dominance.py
new file mode 100644
index 0000000..cd119ba
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/dominance.py
@@ -0,0 +1,133 @@
+"""
+Dominance algorithms.
+"""
+
+from functools import reduce
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["immediate_dominators", "dominance_frontiers"]
+
+
+@not_implemented_for("undirected")
+def immediate_dominators(G, start):
+    """Returns the immediate dominators of all nodes of a directed graph.
+
+    Parameters
+    ----------
+    G : a DiGraph or MultiDiGraph
+        The graph where dominance is to be computed.
+
+    start : node
+        The start node of dominance computation.
+
+    Returns
+    -------
+    idom : dict keyed by nodes
+        A dict containing the immediate dominators of each node reachable from
+        `start`.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is undirected.
+
+    NetworkXError
+        If `start` is not in `G`.
+
+    Notes
+    -----
+    Except for `start`, the immediate dominators are the parents of their
+    corresponding nodes in the dominator tree.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph([(1, 2), (1, 3), (2, 5), (3, 4), (4, 5)])
+    >>> sorted(nx.immediate_dominators(G, 1).items())
+    [(1, 1), (2, 1), (3, 1), (4, 3), (5, 1)]
+
+    References
+    ----------
+    .. [1] K. D. Cooper, T. J. Harvey, and K. Kennedy.
+           A simple, fast dominance algorithm.
+           Software Practice & Experience, 4:110, 2001.
+    """
+    if start not in G:
+        raise nx.NetworkXError("start is not in G")
+
+    idom = {start: start}
+
+    order = list(nx.dfs_postorder_nodes(G, start))
+    dfn = {u: i for i, u in enumerate(order)}
+    order.pop()
+    order.reverse()
+
+    def intersect(u, v):
+        while u != v:
+            while dfn[u] < dfn[v]:
+                u = idom[u]
+            while dfn[u] > dfn[v]:
+                v = idom[v]
+        return u
+
+    changed = True
+    while changed:
+        changed = False
+        for u in order:
+            new_idom = reduce(intersect, (v for v in G.pred[u] if v in idom))
+            if u not in idom or idom[u] != new_idom:
+                idom[u] = new_idom
+                changed = True
+
+    return idom
+
+
+def dominance_frontiers(G, start):
+    """Returns the dominance frontiers of all nodes of a directed graph.
+
+    Parameters
+    ----------
+    G : a DiGraph or MultiDiGraph
+        The graph where dominance is to be computed.
+
+    start : node
+        The start node of dominance computation.
+
+    Returns
+    -------
+    df : dict keyed by nodes
+        A dict containing the dominance frontiers of each node reachable from
+        `start` as lists.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is undirected.
+
+    NetworkXError
+        If `start` is not in `G`.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph([(1, 2), (1, 3), (2, 5), (3, 4), (4, 5)])
+    >>> sorted((u, sorted(df)) for u, df in nx.dominance_frontiers(G, 1).items())
+    [(1, []), (2, [5]), (3, [5]), (4, [5]), (5, [])]
+
+    References
+    ----------
+    .. [1] K. D. Cooper, T. J. Harvey, and K. Kennedy.
+           A simple, fast dominance algorithm.
+           Software Practice & Experience, 4:110, 2001.
+    """
+    idom = nx.immediate_dominators(G, start)
+
+    df = {u: set() for u in idom}
+    for u in idom:
+        if len(G.pred[u]) >= 2:
+            for v in G.pred[u]:
+                if v in idom:
+                    while v != idom[u]:
+                        df[v].add(u)
+                        v = idom[v]
+    return df
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/dominating.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/dominating.py
new file mode 100644
index 0000000..32fff4d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/dominating.py
@@ -0,0 +1,92 @@
+"""Functions for computing dominating sets in a graph."""
+from itertools import chain
+
+import networkx as nx
+from networkx.utils import arbitrary_element
+
+__all__ = ["dominating_set", "is_dominating_set"]
+
+
+def dominating_set(G, start_with=None):
+    r"""Finds a dominating set for the graph G.
+
+    A *dominating set* for a graph with node set *V* is a subset *D* of
+    *V* such that every node not in *D* is adjacent to at least one
+    member of *D* [1]_.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    start_with : node (default=None)
+        Node to use as a starting point for the algorithm.
+
+    Returns
+    -------
+    D : set
+        A dominating set for G.
+
+    Notes
+    -----
+    This function is an implementation of algorithm 7 in [2]_ which
+    finds some dominating set, not necessarily the smallest one.
+
+    See also
+    --------
+    is_dominating_set
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Dominating_set
+
+    .. [2] Abdol-Hossein Esfahanian. Connectivity Algorithms.
+        http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
+
+    """
+    all_nodes = set(G)
+    if start_with is None:
+        start_with = arbitrary_element(all_nodes)
+    if start_with not in G:
+        raise nx.NetworkXError(f"node {start_with} is not in G")
+    dominating_set = {start_with}
+    dominated_nodes = set(G[start_with])
+    remaining_nodes = all_nodes - dominated_nodes - dominating_set
+    while remaining_nodes:
+        # Choose an arbitrary node and determine its undominated neighbors.
+        v = remaining_nodes.pop()
+        undominated_neighbors = set(G[v]) - dominating_set
+        # Add the node to the dominating set and the neighbors to the
+        # dominated set. Finally, remove all of those nodes from the set
+        # of remaining nodes.
+        dominating_set.add(v)
+        dominated_nodes |= undominated_neighbors
+        remaining_nodes -= undominated_neighbors
+    return dominating_set
+
+
+def is_dominating_set(G, nbunch):
+    """Checks if `nbunch` is a dominating set for `G`.
+
+    A *dominating set* for a graph with node set *V* is a subset *D* of
+    *V* such that every node not in *D* is adjacent to at least one
+    member of *D* [1]_.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    nbunch : iterable
+        An iterable of nodes in the graph `G`.
+
+    See also
+    --------
+    dominating_set
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Dominating_set
+
+    """
+    testset = {n for n in nbunch if n in G}
+    nbrs = set(chain.from_iterable(G[n] for n in testset))
+    return len(set(G) - testset - nbrs) == 0
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/efficiency_measures.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/efficiency_measures.py
new file mode 100644
index 0000000..45f19cd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/efficiency_measures.py
@@ -0,0 +1,147 @@
+"""Provides functions for computing the efficiency of nodes and graphs."""
+
+import networkx as nx
+from networkx.exception import NetworkXNoPath
+
+from ..utils import not_implemented_for
+
+__all__ = ["efficiency", "local_efficiency", "global_efficiency"]
+
+
+@not_implemented_for("directed")
+def efficiency(G, u, v):
+    """Returns the efficiency of a pair of nodes in a graph.
+
+    The *efficiency* of a pair of nodes is the multiplicative inverse of the
+    shortest path distance between the nodes [1]_. Returns 0 if no path
+    between nodes.
+
+    Parameters
+    ----------
+    G : :class:`networkx.Graph`
+        An undirected graph for which to compute the average local efficiency.
+    u, v : node
+        Nodes in the graph ``G``.
+
+    Returns
+    -------
+    float
+        Multiplicative inverse of the shortest path distance between the nodes.
+
+    Notes
+    -----
+    Edge weights are ignored when computing the shortest path distances.
+
+    See also
+    --------
+    local_efficiency
+    global_efficiency
+
+    References
+    ----------
+    .. [1] Latora, Vito, and Massimo Marchiori.
+           "Efficient behavior of small-world networks."
+           *Physical Review Letters* 87.19 (2001): 198701.
+           <https://doi.org/10.1103/PhysRevLett.87.198701>
+
+    """
+    try:
+        eff = 1 / nx.shortest_path_length(G, u, v)
+    except NetworkXNoPath:
+        eff = 0
+    return eff
+
+
+@not_implemented_for("directed")
+def global_efficiency(G):
+    """Returns the average global efficiency of the graph.
+
+    The *efficiency* of a pair of nodes in a graph is the multiplicative
+    inverse of the shortest path distance between the nodes. The *average
+    global efficiency* of a graph is the average efficiency of all pairs of
+    nodes [1]_.
+
+    Parameters
+    ----------
+    G : :class:`networkx.Graph`
+        An undirected graph for which to compute the average global efficiency.
+
+    Returns
+    -------
+    float
+        The average global efficiency of the graph.
+
+    Notes
+    -----
+    Edge weights are ignored when computing the shortest path distances.
+
+    See also
+    --------
+    local_efficiency
+
+    References
+    ----------
+    .. [1] Latora, Vito, and Massimo Marchiori.
+           "Efficient behavior of small-world networks."
+           *Physical Review Letters* 87.19 (2001): 198701.
+           <https://doi.org/10.1103/PhysRevLett.87.198701>
+
+    """
+    n = len(G)
+    denom = n * (n - 1)
+    if denom != 0:
+        lengths = nx.all_pairs_shortest_path_length(G)
+        g_eff = 0
+        for source, targets in lengths:
+            for target, distance in targets.items():
+                if distance > 0:
+                    g_eff += 1 / distance
+        g_eff /= denom
+        # g_eff = sum(1 / d for s, tgts in lengths
+        #                   for t, d in tgts.items() if d > 0) / denom
+    else:
+        g_eff = 0
+    # TODO This can be made more efficient by computing all pairs shortest
+    # path lengths in parallel.
+    return g_eff
+
+
+@not_implemented_for("directed")
+def local_efficiency(G):
+    """Returns the average local efficiency of the graph.
+
+    The *efficiency* of a pair of nodes in a graph is the multiplicative
+    inverse of the shortest path distance between the nodes. The *local
+    efficiency* of a node in the graph is the average global efficiency of the
+    subgraph induced by the neighbors of the node. The *average local
+    efficiency* is the average of the local efficiencies of each node [1]_.
+
+    Parameters
+    ----------
+    G : :class:`networkx.Graph`
+        An undirected graph for which to compute the average local efficiency.
+
+    Returns
+    -------
+    float
+        The average local efficiency of the graph.
+
+    Notes
+    -----
+    Edge weights are ignored when computing the shortest path distances.
+
+    See also
+    --------
+    global_efficiency
+
+    References
+    ----------
+    .. [1] Latora, Vito, and Massimo Marchiori.
+           "Efficient behavior of small-world networks."
+           *Physical Review Letters* 87.19 (2001): 198701.
+           <https://doi.org/10.1103/PhysRevLett.87.198701>
+
+    """
+    # TODO This summation can be trivially parallelized.
+    efficiency_list = (global_efficiency(G.subgraph(G[v])) for v in G)
+    return sum(efficiency_list) / len(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/euler.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/euler.py
new file mode 100644
index 0000000..4643a9f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/euler.py
@@ -0,0 +1,452 @@
+"""
+Eulerian circuits and graphs.
+"""
+from itertools import combinations
+
+import networkx as nx
+
+from ..utils import arbitrary_element, not_implemented_for
+
+__all__ = [
+    "is_eulerian",
+    "eulerian_circuit",
+    "eulerize",
+    "is_semieulerian",
+    "has_eulerian_path",
+    "eulerian_path",
+]
+
+
+def is_eulerian(G):
+    """Returns True if and only if `G` is Eulerian.
+
+    A graph is *Eulerian* if it has an Eulerian circuit. An *Eulerian
+    circuit* is a closed walk that includes each edge of a graph exactly
+    once.
+
+    Graphs with isolated vertices (i.e. vertices with zero degree) are not
+    considered to have Eulerian circuits. Therefore, if the graph is not
+    connected (or not strongly connected, for directed graphs), this function
+    returns False.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph, either directed or undirected.
+
+    Examples
+    --------
+    >>> nx.is_eulerian(nx.DiGraph({0: [3], 1: [2], 2: [3], 3: [0, 1]}))
+    True
+    >>> nx.is_eulerian(nx.complete_graph(5))
+    True
+    >>> nx.is_eulerian(nx.petersen_graph())
+    False
+
+    If you prefer to allow graphs with isolated vertices to have Eulerian circuits,
+    you can first remove such vertices and then call `is_eulerian` as below example shows.
+
+    >>> G = nx.Graph([(0, 1), (1, 2), (0, 2)])
+    >>> G.add_node(3)
+    >>> nx.is_eulerian(G)
+    False
+
+    >>> G.remove_nodes_from(list(nx.isolates(G)))
+    >>> nx.is_eulerian(G)
+    True
+
+
+    """
+    if G.is_directed():
+        # Every node must have equal in degree and out degree and the
+        # graph must be strongly connected
+        return all(
+            G.in_degree(n) == G.out_degree(n) for n in G
+        ) and nx.is_strongly_connected(G)
+    # An undirected Eulerian graph has no vertices of odd degree and
+    # must be connected.
+    return all(d % 2 == 0 for v, d in G.degree()) and nx.is_connected(G)
+
+
+def is_semieulerian(G):
+    """Return True iff `G` is semi-Eulerian.
+
+    G is semi-Eulerian if it has an Eulerian path but no Eulerian circuit.
+
+    See Also
+    --------
+    has_eulerian_path
+    is_eulerian
+    """
+    return has_eulerian_path(G) and not is_eulerian(G)
+
+
+def _find_path_start(G):
+    """Return a suitable starting vertex for an Eulerian path.
+
+    If no path exists, return None.
+    """
+    if not has_eulerian_path(G):
+        return None
+
+    if is_eulerian(G):
+        return arbitrary_element(G)
+
+    if G.is_directed():
+        v1, v2 = (v for v in G if G.in_degree(v) != G.out_degree(v))
+        # Determines which is the 'start' node (as opposed to the 'end')
+        if G.out_degree(v1) > G.in_degree(v1):
+            return v1
+        else:
+            return v2
+
+    else:
+        # In an undirected graph randomly choose one of the possibilities
+        start = [v for v in G if G.degree(v) % 2 != 0][0]
+        return start
+
+
+def _simplegraph_eulerian_circuit(G, source):
+    if G.is_directed():
+        degree = G.out_degree
+        edges = G.out_edges
+    else:
+        degree = G.degree
+        edges = G.edges
+    vertex_stack = [source]
+    last_vertex = None
+    while vertex_stack:
+        current_vertex = vertex_stack[-1]
+        if degree(current_vertex) == 0:
+            if last_vertex is not None:
+                yield (last_vertex, current_vertex)
+            last_vertex = current_vertex
+            vertex_stack.pop()
+        else:
+            _, next_vertex = arbitrary_element(edges(current_vertex))
+            vertex_stack.append(next_vertex)
+            G.remove_edge(current_vertex, next_vertex)
+
+
+def _multigraph_eulerian_circuit(G, source):
+    if G.is_directed():
+        degree = G.out_degree
+        edges = G.out_edges
+    else:
+        degree = G.degree
+        edges = G.edges
+    vertex_stack = [(source, None)]
+    last_vertex = None
+    last_key = None
+    while vertex_stack:
+        current_vertex, current_key = vertex_stack[-1]
+        if degree(current_vertex) == 0:
+            if last_vertex is not None:
+                yield (last_vertex, current_vertex, last_key)
+            last_vertex, last_key = current_vertex, current_key
+            vertex_stack.pop()
+        else:
+            triple = arbitrary_element(edges(current_vertex, keys=True))
+            _, next_vertex, next_key = triple
+            vertex_stack.append((next_vertex, next_key))
+            G.remove_edge(current_vertex, next_vertex, next_key)
+
+
+def eulerian_circuit(G, source=None, keys=False):
+    """Returns an iterator over the edges of an Eulerian circuit in `G`.
+
+    An *Eulerian circuit* is a closed walk that includes each edge of a
+    graph exactly once.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph, either directed or undirected.
+
+    source : node, optional
+       Starting node for circuit.
+
+    keys : bool
+       If False, edges generated by this function will be of the form
+       ``(u, v)``. Otherwise, edges will be of the form ``(u, v, k)``.
+       This option is ignored unless `G` is a multigraph.
+
+    Returns
+    -------
+    edges : iterator
+       An iterator over edges in the Eulerian circuit.
+
+    Raises
+    ------
+    NetworkXError
+       If the graph is not Eulerian.
+
+    See Also
+    --------
+    is_eulerian
+
+    Notes
+    -----
+    This is a linear time implementation of an algorithm adapted from [1]_.
+
+    For general information about Euler tours, see [2]_.
+
+    References
+    ----------
+    .. [1] J. Edmonds, E. L. Johnson.
+       Matching, Euler tours and the Chinese postman.
+       Mathematical programming, Volume 5, Issue 1 (1973), 111-114.
+    .. [2] https://en.wikipedia.org/wiki/Eulerian_path
+
+    Examples
+    --------
+    To get an Eulerian circuit in an undirected graph::
+
+        >>> G = nx.complete_graph(3)
+        >>> list(nx.eulerian_circuit(G))
+        [(0, 2), (2, 1), (1, 0)]
+        >>> list(nx.eulerian_circuit(G, source=1))
+        [(1, 2), (2, 0), (0, 1)]
+
+    To get the sequence of vertices in an Eulerian circuit::
+
+        >>> [u for u, v in nx.eulerian_circuit(G)]
+        [0, 2, 1]
+
+    """
+    if not is_eulerian(G):
+        raise nx.NetworkXError("G is not Eulerian.")
+    if G.is_directed():
+        G = G.reverse()
+    else:
+        G = G.copy()
+    if source is None:
+        source = arbitrary_element(G)
+    if G.is_multigraph():
+        for u, v, k in _multigraph_eulerian_circuit(G, source):
+            if keys:
+                yield u, v, k
+            else:
+                yield u, v
+    else:
+        yield from _simplegraph_eulerian_circuit(G, source)
+
+
+def has_eulerian_path(G, source=None):
+    """Return True iff `G` has an Eulerian path.
+
+    An Eulerian path is a path in a graph which uses each edge of a graph
+    exactly once. If `source` is specified, then this function checks
+    whether an Eulerian path that starts at node `source` exists.
+
+    A directed graph has an Eulerian path iff:
+        - at most one vertex has out_degree - in_degree = 1,
+        - at most one vertex has in_degree - out_degree = 1,
+        - every other vertex has equal in_degree and out_degree,
+        - and all of its vertices belong to a single connected
+          component of the underlying undirected graph.
+
+    If `source` is not None, an Eulerian path starting at `source` exists if no
+    other node has out_degree - in_degree = 1. This is equivalent to either
+    there exists an Eulerian circuit or `source` has out_degree - in_degree = 1
+    and the conditions above hold.
+
+    An undirected graph has an Eulerian path iff:
+        - exactly zero or two vertices have odd degree,
+        - and all of its vertices belong to a single connected component.
+
+    If `source` is not None, an Eulerian path starting at `source` exists if
+    either there exists an Eulerian circuit or `source` has an odd degree and the
+    conditions above hold.
+
+    Graphs with isolated vertices (i.e. vertices with zero degree) are not considered
+    to have an Eulerian path. Therefore, if the graph is not connected (or not strongly
+    connected, for directed graphs), this function returns False.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        The graph to find an euler path in.
+
+    source : node, optional
+        Starting node for path.
+
+    Returns
+    -------
+    Bool : True if G has an Eulerian path.
+
+    Example
+    -------
+    If you prefer to allow graphs with isolated vertices to have Eulerian path,
+    you can first remove such vertices and then call `has_eulerian_path` as below example shows.
+
+    >>> G = nx.Graph([(0, 1), (1, 2), (0, 2)])
+    >>> G.add_node(3)
+    >>> nx.has_eulerian_path(G)
+    False
+
+    >>> G.remove_nodes_from(list(nx.isolates(G)))
+    >>> nx.has_eulerian_path(G)
+    True
+
+    See Also
+    --------
+    is_eulerian
+    eulerian_path
+    """
+    if nx.is_eulerian(G):
+        return True
+
+    if G.is_directed():
+        ins = G.in_degree
+        outs = G.out_degree
+        # Since we know it is not eulerian, outs - ins must be 1 for source
+        if source is not None and outs[source] - ins[source] != 1:
+            return False
+
+        unbalanced_ins = 0
+        unbalanced_outs = 0
+        for v in G:
+            if ins[v] - outs[v] == 1:
+                unbalanced_ins += 1
+            elif outs[v] - ins[v] == 1:
+                unbalanced_outs += 1
+            elif ins[v] != outs[v]:
+                return False
+
+        return (
+            unbalanced_ins <= 1 and unbalanced_outs <= 1 and nx.is_weakly_connected(G)
+        )
+    else:
+        # We know it is not eulerian, so degree of source must be odd.
+        if source is not None and G.degree[source] % 2 != 1:
+            return False
+
+        # Sum is 2 since we know it is not eulerian (which implies sum is 0)
+        return sum(d % 2 == 1 for v, d in G.degree()) == 2 and nx.is_connected(G)
+
+
+def eulerian_path(G, source=None, keys=False):
+    """Return an iterator over the edges of an Eulerian path in `G`.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        The graph in which to look for an eulerian path.
+    source : node or None (default: None)
+        The node at which to start the search. None means search over all
+        starting nodes.
+    keys : Bool (default: False)
+        Indicates whether to yield edge 3-tuples (u, v, edge_key).
+        The default yields edge 2-tuples
+
+    Yields
+    ------
+    Edge tuples along the eulerian path.
+
+    Warning: If `source` provided is not the start node of an Euler path
+    will raise error even if an Euler Path exists.
+    """
+    if not has_eulerian_path(G, source):
+        raise nx.NetworkXError("Graph has no Eulerian paths.")
+    if G.is_directed():
+        G = G.reverse()
+        if source is None or nx.is_eulerian(G) is False:
+            source = _find_path_start(G)
+        if G.is_multigraph():
+            for u, v, k in _multigraph_eulerian_circuit(G, source):
+                if keys:
+                    yield u, v, k
+                else:
+                    yield u, v
+        else:
+            yield from _simplegraph_eulerian_circuit(G, source)
+    else:
+        G = G.copy()
+        if source is None:
+            source = _find_path_start(G)
+        if G.is_multigraph():
+            if keys:
+                yield from reversed(
+                    [(v, u, k) for u, v, k in _multigraph_eulerian_circuit(G, source)]
+                )
+            else:
+                yield from reversed(
+                    [(v, u) for u, v, k in _multigraph_eulerian_circuit(G, source)]
+                )
+        else:
+            yield from reversed(
+                [(v, u) for u, v in _simplegraph_eulerian_circuit(G, source)]
+            )
+
+
+@not_implemented_for("directed")
+def eulerize(G):
+    """Transforms a graph into an Eulerian graph
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       An undirected graph
+
+    Returns
+    -------
+    G : NetworkX multigraph
+
+    Raises
+    ------
+    NetworkXError
+       If the graph is not connected.
+
+    See Also
+    --------
+    is_eulerian
+    eulerian_circuit
+
+    References
+    ----------
+    .. [1] J. Edmonds, E. L. Johnson.
+       Matching, Euler tours and the Chinese postman.
+       Mathematical programming, Volume 5, Issue 1 (1973), 111-114.
+    .. [2] https://en.wikipedia.org/wiki/Eulerian_path
+    .. [3] http://web.math.princeton.edu/math_alive/5/Notes1.pdf
+
+    Examples
+    --------
+        >>> G = nx.complete_graph(10)
+        >>> H = nx.eulerize(G)
+        >>> nx.is_eulerian(H)
+        True
+
+    """
+    if G.order() == 0:
+        raise nx.NetworkXPointlessConcept("Cannot Eulerize null graph")
+    if not nx.is_connected(G):
+        raise nx.NetworkXError("G is not connected")
+    odd_degree_nodes = [n for n, d in G.degree() if d % 2 == 1]
+    G = nx.MultiGraph(G)
+    if len(odd_degree_nodes) == 0:
+        return G
+
+    # get all shortest paths between vertices of odd degree
+    odd_deg_pairs_paths = [
+        (m, {n: nx.shortest_path(G, source=m, target=n)})
+        for m, n in combinations(odd_degree_nodes, 2)
+    ]
+
+    # use inverse path lengths as edge-weights in a new graph
+    # store the paths in the graph for easy indexing later
+    Gp = nx.Graph()
+    for n, Ps in odd_deg_pairs_paths:
+        for m, P in Ps.items():
+            if n != m:
+                Gp.add_edge(m, n, weight=1 / len(P), path=P)
+
+    # find the minimum weight matching of edges in the weighted graph
+    best_matching = nx.Graph(list(nx.max_weight_matching(Gp)))
+
+    # duplicate each edge along each path in the set of paths in Gp
+    for m, n in best_matching.edges():
+        path = Gp[m][n]["path"]
+        G.add_edges_from(nx.utils.pairwise(path))
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/__init__.py
new file mode 100644
index 0000000..c5d19ab
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/__init__.py
@@ -0,0 +1,11 @@
+from .maxflow import *
+from .mincost import *
+from .boykovkolmogorov import *
+from .dinitz_alg import *
+from .edmondskarp import *
+from .gomory_hu import *
+from .preflowpush import *
+from .shortestaugmentingpath import *
+from .capacityscaling import *
+from .networksimplex import *
+from .utils import build_flow_dict, build_residual_network
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/boykovkolmogorov.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/boykovkolmogorov.py
new file mode 100644
index 0000000..fd96681
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/boykovkolmogorov.py
@@ -0,0 +1,367 @@
+"""
+Boykov-Kolmogorov algorithm for maximum flow problems.
+"""
+from collections import deque
+from operator import itemgetter
+
+import networkx as nx
+from networkx.algorithms.flow.utils import build_residual_network
+
+__all__ = ["boykov_kolmogorov"]
+
+
+def boykov_kolmogorov(
+    G, s, t, capacity="capacity", residual=None, value_only=False, cutoff=None
+):
+    r"""Find a maximum single-commodity flow using Boykov-Kolmogorov algorithm.
+
+    This function returns the residual network resulting after computing
+    the maximum flow. See below for details about the conventions
+    NetworkX uses for defining residual networks.
+
+    This algorithm has worse case complexity $O(n^2 m |C|)$ for $n$ nodes, $m$
+    edges, and $|C|$ the cost of the minimum cut [1]_. This implementation
+    uses the marking heuristic defined in [2]_ which improves its running
+    time in many practical problems.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Edges of the graph are expected to have an attribute called
+        'capacity'. If this attribute is not present, the edge is
+        considered to have infinite capacity.
+
+    s : node
+        Source node for the flow.
+
+    t : node
+        Sink node for the flow.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    residual : NetworkX graph
+        Residual network on which the algorithm is to be executed. If None, a
+        new residual network is created. Default value: None.
+
+    value_only : bool
+        If True compute only the value of the maximum flow. This parameter
+        will be ignored by this algorithm because it is not applicable.
+
+    cutoff : integer, float
+        If specified, the algorithm will terminate when the flow value reaches
+        or exceeds the cutoff. In this case, it may be unable to immediately
+        determine a minimum cut. Default value: None.
+
+    Returns
+    -------
+    R : NetworkX DiGraph
+        Residual network after computing the maximum flow.
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support MultiGraph and MultiDiGraph. If
+        the input graph is an instance of one of these two classes, a
+        NetworkXError is raised.
+
+    NetworkXUnbounded
+        If the graph has a path of infinite capacity, the value of a
+        feasible flow on the graph is unbounded above and the function
+        raises a NetworkXUnbounded.
+
+    See also
+    --------
+    :meth:`maximum_flow`
+    :meth:`minimum_cut`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    Notes
+    -----
+    The residual network :samp:`R` from an input graph :samp:`G` has the
+    same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair
+    of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a
+    self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists
+    in :samp:`G`.
+
+    For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']`
+    is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists
+    in :samp:`G` or zero otherwise. If the capacity is infinite,
+    :samp:`R[u][v]['capacity']` will have a high arbitrary finite value
+    that does not affect the solution of the problem. This value is stored in
+    :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`,
+    :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and
+    satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`.
+
+    The flow value, defined as the total flow into :samp:`t`, the sink, is
+    stored in :samp:`R.graph['flow_value']`. If :samp:`cutoff` is not
+    specified, reachability to :samp:`t` using only edges :samp:`(u, v)` such
+    that :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum
+    :samp:`s`-:samp:`t` cut.
+
+    Examples
+    --------
+    >>> from networkx.algorithms.flow import boykov_kolmogorov
+
+    The functions that implement flow algorithms and output a residual
+    network, such as this one, are not imported to the base NetworkX
+    namespace, so you have to explicitly import them from the flow package.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_edge("x", "a", capacity=3.0)
+    >>> G.add_edge("x", "b", capacity=1.0)
+    >>> G.add_edge("a", "c", capacity=3.0)
+    >>> G.add_edge("b", "c", capacity=5.0)
+    >>> G.add_edge("b", "d", capacity=4.0)
+    >>> G.add_edge("d", "e", capacity=2.0)
+    >>> G.add_edge("c", "y", capacity=2.0)
+    >>> G.add_edge("e", "y", capacity=3.0)
+    >>> R = boykov_kolmogorov(G, "x", "y")
+    >>> flow_value = nx.maximum_flow_value(G, "x", "y")
+    >>> flow_value
+    3.0
+    >>> flow_value == R.graph["flow_value"]
+    True
+
+    A nice feature of the Boykov-Kolmogorov algorithm is that a partition
+    of the nodes that defines a minimum cut can be easily computed based
+    on the search trees used during the algorithm. These trees are stored
+    in the graph attribute `trees` of the residual network.
+
+    >>> source_tree, target_tree = R.graph["trees"]
+    >>> partition = (set(source_tree), set(G) - set(source_tree))
+
+    Or equivalently:
+
+    >>> partition = (set(G) - set(target_tree), set(target_tree))
+
+    References
+    ----------
+    .. [1] Boykov, Y., & Kolmogorov, V. (2004). An experimental comparison
+           of min-cut/max-flow algorithms for energy minimization in vision.
+           Pattern Analysis and Machine Intelligence, IEEE Transactions on,
+           26(9), 1124-1137.
+           https://doi.org/10.1109/TPAMI.2004.60
+
+    .. [2] Vladimir Kolmogorov. Graph-based Algorithms for Multi-camera
+           Reconstruction Problem. PhD thesis, Cornell University, CS Department,
+           2003. pp. 109-114.
+           https://web.archive.org/web/20170809091249/https://pub.ist.ac.at/~vnk/papers/thesis.pdf
+
+    """
+    R = boykov_kolmogorov_impl(G, s, t, capacity, residual, cutoff)
+    R.graph["algorithm"] = "boykov_kolmogorov"
+    return R
+
+
+def boykov_kolmogorov_impl(G, s, t, capacity, residual, cutoff):
+    if s not in G:
+        raise nx.NetworkXError(f"node {str(s)} not in graph")
+    if t not in G:
+        raise nx.NetworkXError(f"node {str(t)} not in graph")
+    if s == t:
+        raise nx.NetworkXError("source and sink are the same node")
+
+    if residual is None:
+        R = build_residual_network(G, capacity)
+    else:
+        R = residual
+
+    # Initialize/reset the residual network.
+    # This is way too slow
+    # nx.set_edge_attributes(R, 0, 'flow')
+    for u in R:
+        for e in R[u].values():
+            e["flow"] = 0
+
+    # Use an arbitrary high value as infinite. It is computed
+    # when building the residual network.
+    INF = R.graph["inf"]
+
+    if cutoff is None:
+        cutoff = INF
+
+    R_succ = R.succ
+    R_pred = R.pred
+
+    def grow():
+        """Bidirectional breadth-first search for the growth stage.
+
+        Returns a connecting edge, that is and edge that connects
+        a node from the source search tree with a node from the
+        target search tree.
+        The first node in the connecting edge is always from the
+        source tree and the last node from the target tree.
+        """
+        while active:
+            u = active[0]
+            if u in source_tree:
+                this_tree = source_tree
+                other_tree = target_tree
+                neighbors = R_succ
+            else:
+                this_tree = target_tree
+                other_tree = source_tree
+                neighbors = R_pred
+            for v, attr in neighbors[u].items():
+                if attr["capacity"] - attr["flow"] > 0:
+                    if v not in this_tree:
+                        if v in other_tree:
+                            return (u, v) if this_tree is source_tree else (v, u)
+                        this_tree[v] = u
+                        dist[v] = dist[u] + 1
+                        timestamp[v] = timestamp[u]
+                        active.append(v)
+                    elif v in this_tree and _is_closer(u, v):
+                        this_tree[v] = u
+                        dist[v] = dist[u] + 1
+                        timestamp[v] = timestamp[u]
+            _ = active.popleft()
+        return None, None
+
+    def augment(u, v):
+        """Augmentation stage.
+
+        Reconstruct path and determine its residual capacity.
+        We start from a connecting edge, which links a node
+        from the source tree to a node from the target tree.
+        The connecting edge is the output of the grow function
+        and the input of this function.
+        """
+        attr = R_succ[u][v]
+        flow = min(INF, attr["capacity"] - attr["flow"])
+        path = [u]
+        # Trace a path from u to s in source_tree.
+        w = u
+        while w != s:
+            n = w
+            w = source_tree[n]
+            attr = R_pred[n][w]
+            flow = min(flow, attr["capacity"] - attr["flow"])
+            path.append(w)
+        path.reverse()
+        # Trace a path from v to t in target_tree.
+        path.append(v)
+        w = v
+        while w != t:
+            n = w
+            w = target_tree[n]
+            attr = R_succ[n][w]
+            flow = min(flow, attr["capacity"] - attr["flow"])
+            path.append(w)
+        # Augment flow along the path and check for saturated edges.
+        it = iter(path)
+        u = next(it)
+        these_orphans = []
+        for v in it:
+            R_succ[u][v]["flow"] += flow
+            R_succ[v][u]["flow"] -= flow
+            if R_succ[u][v]["flow"] == R_succ[u][v]["capacity"]:
+                if v in source_tree:
+                    source_tree[v] = None
+                    these_orphans.append(v)
+                if u in target_tree:
+                    target_tree[u] = None
+                    these_orphans.append(u)
+            u = v
+        orphans.extend(sorted(these_orphans, key=dist.get))
+        return flow
+
+    def adopt():
+        """Adoption stage.
+
+        Reconstruct search trees by adopting or discarding orphans.
+        During augmentation stage some edges got saturated and thus
+        the source and target search trees broke down to forests, with
+        orphans as roots of some of its trees. We have to reconstruct
+        the search trees rooted to source and target before we can grow
+        them again.
+        """
+        while orphans:
+            u = orphans.popleft()
+            if u in source_tree:
+                tree = source_tree
+                neighbors = R_pred
+            else:
+                tree = target_tree
+                neighbors = R_succ
+            nbrs = ((n, attr, dist[n]) for n, attr in neighbors[u].items() if n in tree)
+            for v, attr, d in sorted(nbrs, key=itemgetter(2)):
+                if attr["capacity"] - attr["flow"] > 0:
+                    if _has_valid_root(v, tree):
+                        tree[u] = v
+                        dist[u] = dist[v] + 1
+                        timestamp[u] = time
+                        break
+            else:
+                nbrs = (
+                    (n, attr, dist[n]) for n, attr in neighbors[u].items() if n in tree
+                )
+                for v, attr, d in sorted(nbrs, key=itemgetter(2)):
+                    if attr["capacity"] - attr["flow"] > 0:
+                        if v not in active:
+                            active.append(v)
+                    if tree[v] == u:
+                        tree[v] = None
+                        orphans.appendleft(v)
+                if u in active:
+                    active.remove(u)
+                del tree[u]
+
+    def _has_valid_root(n, tree):
+        path = []
+        v = n
+        while v is not None:
+            path.append(v)
+            if v == s or v == t:
+                base_dist = 0
+                break
+            elif timestamp[v] == time:
+                base_dist = dist[v]
+                break
+            v = tree[v]
+        else:
+            return False
+        length = len(path)
+        for i, u in enumerate(path, 1):
+            dist[u] = base_dist + length - i
+            timestamp[u] = time
+        return True
+
+    def _is_closer(u, v):
+        return timestamp[v] <= timestamp[u] and dist[v] > dist[u] + 1
+
+    source_tree = {s: None}
+    target_tree = {t: None}
+    active = deque([s, t])
+    orphans = deque()
+    flow_value = 0
+    # data structures for the marking heuristic
+    time = 1
+    timestamp = {s: time, t: time}
+    dist = {s: 0, t: 0}
+    while flow_value < cutoff:
+        # Growth stage
+        u, v = grow()
+        if u is None:
+            break
+        time += 1
+        # Augmentation stage
+        flow_value += augment(u, v)
+        # Adoption stage
+        adopt()
+
+    if flow_value * 2 > INF:
+        raise nx.NetworkXUnbounded("Infinite capacity path, flow unbounded above.")
+
+    # Add source and target tree in a graph attribute.
+    # A partition that defines a minimum cut can be directly
+    # computed from the search trees as explained in the docstrings.
+    R.graph["trees"] = (source_tree, target_tree)
+    # Add the standard flow_value graph attribute.
+    R.graph["flow_value"] = flow_value
+    return R
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/capacityscaling.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/capacityscaling.py
new file mode 100644
index 0000000..b565077
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/capacityscaling.py
@@ -0,0 +1,404 @@
+"""
+Capacity scaling minimum cost flow algorithm.
+"""
+
+__all__ = ["capacity_scaling"]
+
+from itertools import chain
+from math import log
+
+import networkx as nx
+
+from ...utils import BinaryHeap, arbitrary_element, not_implemented_for
+
+
+def _detect_unboundedness(R):
+    """Detect infinite-capacity negative cycles."""
+    G = nx.DiGraph()
+    G.add_nodes_from(R)
+
+    # Value simulating infinity.
+    inf = R.graph["inf"]
+    # True infinity.
+    f_inf = float("inf")
+    for u in R:
+        for v, e in R[u].items():
+            # Compute the minimum weight of infinite-capacity (u, v) edges.
+            w = f_inf
+            for k, e in e.items():
+                if e["capacity"] == inf:
+                    w = min(w, e["weight"])
+            if w != f_inf:
+                G.add_edge(u, v, weight=w)
+
+    if nx.negative_edge_cycle(G):
+        raise nx.NetworkXUnbounded(
+            "Negative cost cycle of infinite capacity found. "
+            "Min cost flow may be unbounded below."
+        )
+
+
+@not_implemented_for("undirected")
+def _build_residual_network(G, demand, capacity, weight):
+    """Build a residual network and initialize a zero flow."""
+    if sum(G.nodes[u].get(demand, 0) for u in G) != 0:
+        raise nx.NetworkXUnfeasible("Sum of the demands should be 0.")
+
+    R = nx.MultiDiGraph()
+    R.add_nodes_from(
+        (u, {"excess": -G.nodes[u].get(demand, 0), "potential": 0}) for u in G
+    )
+
+    inf = float("inf")
+    # Detect selfloops with infinite capacities and negative weights.
+    for u, v, e in nx.selfloop_edges(G, data=True):
+        if e.get(weight, 0) < 0 and e.get(capacity, inf) == inf:
+            raise nx.NetworkXUnbounded(
+                "Negative cost cycle of infinite capacity found. "
+                "Min cost flow may be unbounded below."
+            )
+
+    # Extract edges with positive capacities. Self loops excluded.
+    if G.is_multigraph():
+        edge_list = [
+            (u, v, k, e)
+            for u, v, k, e in G.edges(data=True, keys=True)
+            if u != v and e.get(capacity, inf) > 0
+        ]
+    else:
+        edge_list = [
+            (u, v, 0, e)
+            for u, v, e in G.edges(data=True)
+            if u != v and e.get(capacity, inf) > 0
+        ]
+    # Simulate infinity with the larger of the sum of absolute node imbalances
+    # the sum of finite edge capacities or any positive value if both sums are
+    # zero. This allows the infinite-capacity edges to be distinguished for
+    # unboundedness detection and directly participate in residual capacity
+    # calculation.
+    inf = (
+        max(
+            sum(abs(R.nodes[u]["excess"]) for u in R),
+            2
+            * sum(
+                e[capacity]
+                for u, v, k, e in edge_list
+                if capacity in e and e[capacity] != inf
+            ),
+        )
+        or 1
+    )
+    for u, v, k, e in edge_list:
+        r = min(e.get(capacity, inf), inf)
+        w = e.get(weight, 0)
+        # Add both (u, v) and (v, u) into the residual network marked with the
+        # original key. (key[1] == True) indicates the (u, v) is in the
+        # original network.
+        R.add_edge(u, v, key=(k, True), capacity=r, weight=w, flow=0)
+        R.add_edge(v, u, key=(k, False), capacity=0, weight=-w, flow=0)
+
+    # Record the value simulating infinity.
+    R.graph["inf"] = inf
+
+    _detect_unboundedness(R)
+
+    return R
+
+
+def _build_flow_dict(G, R, capacity, weight):
+    """Build a flow dictionary from a residual network."""
+    inf = float("inf")
+    flow_dict = {}
+    if G.is_multigraph():
+        for u in G:
+            flow_dict[u] = {}
+            for v, es in G[u].items():
+                flow_dict[u][v] = {
+                    # Always saturate negative selfloops.
+                    k: (
+                        0
+                        if (
+                            u != v or e.get(capacity, inf) <= 0 or e.get(weight, 0) >= 0
+                        )
+                        else e[capacity]
+                    )
+                    for k, e in es.items()
+                }
+            for v, es in R[u].items():
+                if v in flow_dict[u]:
+                    flow_dict[u][v].update(
+                        (k[0], e["flow"]) for k, e in es.items() if e["flow"] > 0
+                    )
+    else:
+        for u in G:
+            flow_dict[u] = {
+                # Always saturate negative selfloops.
+                v: (
+                    0
+                    if (u != v or e.get(capacity, inf) <= 0 or e.get(weight, 0) >= 0)
+                    else e[capacity]
+                )
+                for v, e in G[u].items()
+            }
+            flow_dict[u].update(
+                (v, e["flow"])
+                for v, es in R[u].items()
+                for e in es.values()
+                if e["flow"] > 0
+            )
+    return flow_dict
+
+
+def capacity_scaling(
+    G, demand="demand", capacity="capacity", weight="weight", heap=BinaryHeap
+):
+    r"""Find a minimum cost flow satisfying all demands in digraph G.
+
+    This is a capacity scaling successive shortest augmenting path algorithm.
+
+    G is a digraph with edge costs and capacities and in which nodes
+    have demand, i.e., they want to send or receive some amount of
+    flow. A negative demand means that the node wants to send flow, a
+    positive demand means that the node want to receive flow. A flow on
+    the digraph G satisfies all demand if the net flow into each node
+    is equal to the demand of that node.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        DiGraph or MultiDiGraph on which a minimum cost flow satisfying all
+        demands is to be found.
+
+    demand : string
+        Nodes of the graph G are expected to have an attribute demand
+        that indicates how much flow a node wants to send (negative
+        demand) or receive (positive demand). Note that the sum of the
+        demands should be 0 otherwise the problem in not feasible. If
+        this attribute is not present, a node is considered to have 0
+        demand. Default value: 'demand'.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    weight : string
+        Edges of the graph G are expected to have an attribute weight
+        that indicates the cost incurred by sending one unit of flow on
+        that edge. If not present, the weight is considered to be 0.
+        Default value: 'weight'.
+
+    heap : class
+        Type of heap to be used in the algorithm. It should be a subclass of
+        :class:`MinHeap` or implement a compatible interface.
+
+        If a stock heap implementation is to be used, :class:`BinaryHeap` is
+        recommended over :class:`PairingHeap` for Python implementations without
+        optimized attribute accesses (e.g., CPython) despite a slower
+        asymptotic running time. For Python implementations with optimized
+        attribute accesses (e.g., PyPy), :class:`PairingHeap` provides better
+        performance. Default value: :class:`BinaryHeap`.
+
+    Returns
+    -------
+    flowCost : integer
+        Cost of a minimum cost flow satisfying all demands.
+
+    flowDict : dictionary
+        If G is a digraph, a dict-of-dicts keyed by nodes such that
+        flowDict[u][v] is the flow on edge (u, v).
+        If G is a MultiDiGraph, a dict-of-dicts-of-dicts keyed by nodes
+        so that flowDict[u][v][key] is the flow on edge (u, v, key).
+
+    Raises
+    ------
+    NetworkXError
+        This exception is raised if the input graph is not directed,
+        not connected.
+
+    NetworkXUnfeasible
+        This exception is raised in the following situations:
+
+            * The sum of the demands is not zero. Then, there is no
+              flow satisfying all demands.
+            * There is no flow satisfying all demand.
+
+    NetworkXUnbounded
+        This exception is raised if the digraph G has a cycle of
+        negative cost and infinite capacity. Then, the cost of a flow
+        satisfying all demands is unbounded below.
+
+    Notes
+    -----
+    This algorithm does not work if edge weights are floating-point numbers.
+
+    See also
+    --------
+    :meth:`network_simplex`
+
+    Examples
+    --------
+    A simple example of a min cost flow problem.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_node("a", demand=-5)
+    >>> G.add_node("d", demand=5)
+    >>> G.add_edge("a", "b", weight=3, capacity=4)
+    >>> G.add_edge("a", "c", weight=6, capacity=10)
+    >>> G.add_edge("b", "d", weight=1, capacity=9)
+    >>> G.add_edge("c", "d", weight=2, capacity=5)
+    >>> flowCost, flowDict = nx.capacity_scaling(G)
+    >>> flowCost
+    24
+    >>> flowDict
+    {'a': {'b': 4, 'c': 1}, 'd': {}, 'b': {'d': 4}, 'c': {'d': 1}}
+
+    It is possible to change the name of the attributes used for the
+    algorithm.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_node("p", spam=-4)
+    >>> G.add_node("q", spam=2)
+    >>> G.add_node("a", spam=-2)
+    >>> G.add_node("d", spam=-1)
+    >>> G.add_node("t", spam=2)
+    >>> G.add_node("w", spam=3)
+    >>> G.add_edge("p", "q", cost=7, vacancies=5)
+    >>> G.add_edge("p", "a", cost=1, vacancies=4)
+    >>> G.add_edge("q", "d", cost=2, vacancies=3)
+    >>> G.add_edge("t", "q", cost=1, vacancies=2)
+    >>> G.add_edge("a", "t", cost=2, vacancies=4)
+    >>> G.add_edge("d", "w", cost=3, vacancies=4)
+    >>> G.add_edge("t", "w", cost=4, vacancies=1)
+    >>> flowCost, flowDict = nx.capacity_scaling(
+    ...     G, demand="spam", capacity="vacancies", weight="cost"
+    ... )
+    >>> flowCost
+    37
+    >>> flowDict
+    {'p': {'q': 2, 'a': 2}, 'q': {'d': 1}, 'a': {'t': 4}, 'd': {'w': 2}, 't': {'q': 1, 'w': 1}, 'w': {}}
+    """
+    R = _build_residual_network(G, demand, capacity, weight)
+
+    inf = float("inf")
+    # Account cost of negative selfloops.
+    flow_cost = sum(
+        0
+        if e.get(capacity, inf) <= 0 or e.get(weight, 0) >= 0
+        else e[capacity] * e[weight]
+        for u, v, e in nx.selfloop_edges(G, data=True)
+    )
+
+    # Determine the maxmimum edge capacity.
+    wmax = max(chain([-inf], (e["capacity"] for u, v, e in R.edges(data=True))))
+    if wmax == -inf:
+        # Residual network has no edges.
+        return flow_cost, _build_flow_dict(G, R, capacity, weight)
+
+    R_nodes = R.nodes
+    R_succ = R.succ
+
+    delta = 2 ** int(log(wmax, 2))
+    while delta >= 1:
+        # Saturate Δ-residual edges with negative reduced costs to achieve
+        # Δ-optimality.
+        for u in R:
+            p_u = R_nodes[u]["potential"]
+            for v, es in R_succ[u].items():
+                for k, e in es.items():
+                    flow = e["capacity"] - e["flow"]
+                    if e["weight"] - p_u + R_nodes[v]["potential"] < 0:
+                        flow = e["capacity"] - e["flow"]
+                        if flow >= delta:
+                            e["flow"] += flow
+                            R_succ[v][u][(k[0], not k[1])]["flow"] -= flow
+                            R_nodes[u]["excess"] -= flow
+                            R_nodes[v]["excess"] += flow
+        # Determine the Δ-active nodes.
+        S = set()
+        T = set()
+        S_add = S.add
+        S_remove = S.remove
+        T_add = T.add
+        T_remove = T.remove
+        for u in R:
+            excess = R_nodes[u]["excess"]
+            if excess >= delta:
+                S_add(u)
+            elif excess <= -delta:
+                T_add(u)
+        # Repeatedly augment flow from S to T along shortest paths until
+        # Δ-feasibility is achieved.
+        while S and T:
+            s = arbitrary_element(S)
+            t = None
+            # Search for a shortest path in terms of reduce costs from s to
+            # any t in T in the Δ-residual network.
+            d = {}
+            pred = {s: None}
+            h = heap()
+            h_insert = h.insert
+            h_get = h.get
+            h_insert(s, 0)
+            while h:
+                u, d_u = h.pop()
+                d[u] = d_u
+                if u in T:
+                    # Path found.
+                    t = u
+                    break
+                p_u = R_nodes[u]["potential"]
+                for v, es in R_succ[u].items():
+                    if v in d:
+                        continue
+                    wmin = inf
+                    # Find the minimum-weighted (u, v) Δ-residual edge.
+                    for k, e in es.items():
+                        if e["capacity"] - e["flow"] >= delta:
+                            w = e["weight"]
+                            if w < wmin:
+                                wmin = w
+                                kmin = k
+                                emin = e
+                    if wmin == inf:
+                        continue
+                    # Update the distance label of v.
+                    d_v = d_u + wmin - p_u + R_nodes[v]["potential"]
+                    if h_insert(v, d_v):
+                        pred[v] = (u, kmin, emin)
+            if t is not None:
+                # Augment Δ units of flow from s to t.
+                while u != s:
+                    v = u
+                    u, k, e = pred[v]
+                    e["flow"] += delta
+                    R_succ[v][u][(k[0], not k[1])]["flow"] -= delta
+                # Account node excess and deficit.
+                R_nodes[s]["excess"] -= delta
+                R_nodes[t]["excess"] += delta
+                if R_nodes[s]["excess"] < delta:
+                    S_remove(s)
+                if R_nodes[t]["excess"] > -delta:
+                    T_remove(t)
+                # Update node potentials.
+                d_t = d[t]
+                for u, d_u in d.items():
+                    R_nodes[u]["potential"] -= d_u - d_t
+            else:
+                # Path not found.
+                S_remove(s)
+        delta //= 2
+
+    if any(R.nodes[u]["excess"] != 0 for u in R):
+        raise nx.NetworkXUnfeasible("No flow satisfying all demands.")
+
+    # Calculate the flow cost.
+    for u in R:
+        for v, es in R_succ[u].items():
+            for e in es.values():
+                flow = e["flow"]
+                if flow > 0:
+                    flow_cost += flow * e["weight"]
+
+    return flow_cost, _build_flow_dict(G, R, capacity, weight)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/dinitz_alg.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/dinitz_alg.py
new file mode 100644
index 0000000..51860fa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/dinitz_alg.py
@@ -0,0 +1,211 @@
+"""
+Dinitz' algorithm for maximum flow problems.
+"""
+from collections import deque
+
+import networkx as nx
+from networkx.algorithms.flow.utils import build_residual_network
+from networkx.utils import pairwise
+
+__all__ = ["dinitz"]
+
+
+def dinitz(G, s, t, capacity="capacity", residual=None, value_only=False, cutoff=None):
+    """Find a maximum single-commodity flow using Dinitz' algorithm.
+
+    This function returns the residual network resulting after computing
+    the maximum flow. See below for details about the conventions
+    NetworkX uses for defining residual networks.
+
+    This algorithm has a running time of $O(n^2 m)$ for $n$ nodes and $m$
+    edges [1]_.
+
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Edges of the graph are expected to have an attribute called
+        'capacity'. If this attribute is not present, the edge is
+        considered to have infinite capacity.
+
+    s : node
+        Source node for the flow.
+
+    t : node
+        Sink node for the flow.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    residual : NetworkX graph
+        Residual network on which the algorithm is to be executed. If None, a
+        new residual network is created. Default value: None.
+
+    value_only : bool
+        If True compute only the value of the maximum flow. This parameter
+        will be ignored by this algorithm because it is not applicable.
+
+    cutoff : integer, float
+        If specified, the algorithm will terminate when the flow value reaches
+        or exceeds the cutoff. In this case, it may be unable to immediately
+        determine a minimum cut. Default value: None.
+
+    Returns
+    -------
+    R : NetworkX DiGraph
+        Residual network after computing the maximum flow.
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support MultiGraph and MultiDiGraph. If
+        the input graph is an instance of one of these two classes, a
+        NetworkXError is raised.
+
+    NetworkXUnbounded
+        If the graph has a path of infinite capacity, the value of a
+        feasible flow on the graph is unbounded above and the function
+        raises a NetworkXUnbounded.
+
+    See also
+    --------
+    :meth:`maximum_flow`
+    :meth:`minimum_cut`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    Notes
+    -----
+    The residual network :samp:`R` from an input graph :samp:`G` has the
+    same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair
+    of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a
+    self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists
+    in :samp:`G`.
+
+    For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']`
+    is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists
+    in :samp:`G` or zero otherwise. If the capacity is infinite,
+    :samp:`R[u][v]['capacity']` will have a high arbitrary finite value
+    that does not affect the solution of the problem. This value is stored in
+    :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`,
+    :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and
+    satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`.
+
+    The flow value, defined as the total flow into :samp:`t`, the sink, is
+    stored in :samp:`R.graph['flow_value']`. If :samp:`cutoff` is not
+    specified, reachability to :samp:`t` using only edges :samp:`(u, v)` such
+    that :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum
+    :samp:`s`-:samp:`t` cut.
+
+    Examples
+    --------
+    >>> from networkx.algorithms.flow import dinitz
+
+    The functions that implement flow algorithms and output a residual
+    network, such as this one, are not imported to the base NetworkX
+    namespace, so you have to explicitly import them from the flow package.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_edge("x", "a", capacity=3.0)
+    >>> G.add_edge("x", "b", capacity=1.0)
+    >>> G.add_edge("a", "c", capacity=3.0)
+    >>> G.add_edge("b", "c", capacity=5.0)
+    >>> G.add_edge("b", "d", capacity=4.0)
+    >>> G.add_edge("d", "e", capacity=2.0)
+    >>> G.add_edge("c", "y", capacity=2.0)
+    >>> G.add_edge("e", "y", capacity=3.0)
+    >>> R = dinitz(G, "x", "y")
+    >>> flow_value = nx.maximum_flow_value(G, "x", "y")
+    >>> flow_value
+    3.0
+    >>> flow_value == R.graph["flow_value"]
+    True
+
+    References
+    ----------
+    .. [1] Dinitz' Algorithm: The Original Version and Even's Version.
+           2006. Yefim Dinitz. In Theoretical Computer Science. Lecture
+           Notes in Computer Science. Volume 3895. pp 218-240.
+           https://doi.org/10.1007/11685654_10
+
+    """
+    R = dinitz_impl(G, s, t, capacity, residual, cutoff)
+    R.graph["algorithm"] = "dinitz"
+    return R
+
+
+def dinitz_impl(G, s, t, capacity, residual, cutoff):
+    if s not in G:
+        raise nx.NetworkXError(f"node {str(s)} not in graph")
+    if t not in G:
+        raise nx.NetworkXError(f"node {str(t)} not in graph")
+    if s == t:
+        raise nx.NetworkXError("source and sink are the same node")
+
+    if residual is None:
+        R = build_residual_network(G, capacity)
+    else:
+        R = residual
+
+    # Initialize/reset the residual network.
+    for u in R:
+        for e in R[u].values():
+            e["flow"] = 0
+
+    # Use an arbitrary high value as infinite. It is computed
+    # when building the residual network.
+    INF = R.graph["inf"]
+
+    if cutoff is None:
+        cutoff = INF
+
+    R_succ = R.succ
+    R_pred = R.pred
+
+    def breath_first_search():
+        parents = {}
+        queue = deque([s])
+        while queue:
+            if t in parents:
+                break
+            u = queue.popleft()
+            for v in R_succ[u]:
+                attr = R_succ[u][v]
+                if v not in parents and attr["capacity"] - attr["flow"] > 0:
+                    parents[v] = u
+                    queue.append(v)
+        return parents
+
+    def depth_first_search(parents):
+        """Build a path using DFS starting from the sink"""
+        path = []
+        u = t
+        flow = INF
+        while u != s:
+            path.append(u)
+            v = parents[u]
+            flow = min(flow, R_pred[u][v]["capacity"] - R_pred[u][v]["flow"])
+            u = v
+        path.append(s)
+        # Augment the flow along the path found
+        if flow > 0:
+            for u, v in pairwise(path):
+                R_pred[u][v]["flow"] += flow
+                R_pred[v][u]["flow"] -= flow
+        return flow
+
+    flow_value = 0
+    while flow_value < cutoff:
+        parents = breath_first_search()
+        if t not in parents:
+            break
+        this_flow = depth_first_search(parents)
+        if this_flow * 2 > INF:
+            raise nx.NetworkXUnbounded("Infinite capacity path, flow unbounded above.")
+        flow_value += this_flow
+
+    R.graph["flow_value"] = flow_value
+    return R
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/edmondskarp.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/edmondskarp.py
new file mode 100644
index 0000000..ef5cc0c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/edmondskarp.py
@@ -0,0 +1,239 @@
+"""
+Edmonds-Karp algorithm for maximum flow problems.
+"""
+
+import networkx as nx
+from networkx.algorithms.flow.utils import build_residual_network
+
+__all__ = ["edmonds_karp"]
+
+
+def edmonds_karp_core(R, s, t, cutoff):
+    """Implementation of the Edmonds-Karp algorithm."""
+    R_nodes = R.nodes
+    R_pred = R.pred
+    R_succ = R.succ
+
+    inf = R.graph["inf"]
+
+    def augment(path):
+        """Augment flow along a path from s to t."""
+        # Determine the path residual capacity.
+        flow = inf
+        it = iter(path)
+        u = next(it)
+        for v in it:
+            attr = R_succ[u][v]
+            flow = min(flow, attr["capacity"] - attr["flow"])
+            u = v
+        if flow * 2 > inf:
+            raise nx.NetworkXUnbounded("Infinite capacity path, flow unbounded above.")
+        # Augment flow along the path.
+        it = iter(path)
+        u = next(it)
+        for v in it:
+            R_succ[u][v]["flow"] += flow
+            R_succ[v][u]["flow"] -= flow
+            u = v
+        return flow
+
+    def bidirectional_bfs():
+        """Bidirectional breadth-first search for an augmenting path."""
+        pred = {s: None}
+        q_s = [s]
+        succ = {t: None}
+        q_t = [t]
+        while True:
+            q = []
+            if len(q_s) <= len(q_t):
+                for u in q_s:
+                    for v, attr in R_succ[u].items():
+                        if v not in pred and attr["flow"] < attr["capacity"]:
+                            pred[v] = u
+                            if v in succ:
+                                return v, pred, succ
+                            q.append(v)
+                if not q:
+                    return None, None, None
+                q_s = q
+            else:
+                for u in q_t:
+                    for v, attr in R_pred[u].items():
+                        if v not in succ and attr["flow"] < attr["capacity"]:
+                            succ[v] = u
+                            if v in pred:
+                                return v, pred, succ
+                            q.append(v)
+                if not q:
+                    return None, None, None
+                q_t = q
+
+    # Look for shortest augmenting paths using breadth-first search.
+    flow_value = 0
+    while flow_value < cutoff:
+        v, pred, succ = bidirectional_bfs()
+        if pred is None:
+            break
+        path = [v]
+        # Trace a path from s to v.
+        u = v
+        while u != s:
+            u = pred[u]
+            path.append(u)
+        path.reverse()
+        # Trace a path from v to t.
+        u = v
+        while u != t:
+            u = succ[u]
+            path.append(u)
+        flow_value += augment(path)
+
+    return flow_value
+
+
+def edmonds_karp_impl(G, s, t, capacity, residual, cutoff):
+    """Implementation of the Edmonds-Karp algorithm."""
+    if s not in G:
+        raise nx.NetworkXError(f"node {str(s)} not in graph")
+    if t not in G:
+        raise nx.NetworkXError(f"node {str(t)} not in graph")
+    if s == t:
+        raise nx.NetworkXError("source and sink are the same node")
+
+    if residual is None:
+        R = build_residual_network(G, capacity)
+    else:
+        R = residual
+
+    # Initialize/reset the residual network.
+    for u in R:
+        for e in R[u].values():
+            e["flow"] = 0
+
+    if cutoff is None:
+        cutoff = float("inf")
+    R.graph["flow_value"] = edmonds_karp_core(R, s, t, cutoff)
+
+    return R
+
+
+def edmonds_karp(
+    G, s, t, capacity="capacity", residual=None, value_only=False, cutoff=None
+):
+    """Find a maximum single-commodity flow using the Edmonds-Karp algorithm.
+
+    This function returns the residual network resulting after computing
+    the maximum flow. See below for details about the conventions
+    NetworkX uses for defining residual networks.
+
+    This algorithm has a running time of $O(n m^2)$ for $n$ nodes and $m$
+    edges.
+
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Edges of the graph are expected to have an attribute called
+        'capacity'. If this attribute is not present, the edge is
+        considered to have infinite capacity.
+
+    s : node
+        Source node for the flow.
+
+    t : node
+        Sink node for the flow.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    residual : NetworkX graph
+        Residual network on which the algorithm is to be executed. If None, a
+        new residual network is created. Default value: None.
+
+    value_only : bool
+        If True compute only the value of the maximum flow. This parameter
+        will be ignored by this algorithm because it is not applicable.
+
+    cutoff : integer, float
+        If specified, the algorithm will terminate when the flow value reaches
+        or exceeds the cutoff. In this case, it may be unable to immediately
+        determine a minimum cut. Default value: None.
+
+    Returns
+    -------
+    R : NetworkX DiGraph
+        Residual network after computing the maximum flow.
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support MultiGraph and MultiDiGraph. If
+        the input graph is an instance of one of these two classes, a
+        NetworkXError is raised.
+
+    NetworkXUnbounded
+        If the graph has a path of infinite capacity, the value of a
+        feasible flow on the graph is unbounded above and the function
+        raises a NetworkXUnbounded.
+
+    See also
+    --------
+    :meth:`maximum_flow`
+    :meth:`minimum_cut`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    Notes
+    -----
+    The residual network :samp:`R` from an input graph :samp:`G` has the
+    same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair
+    of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a
+    self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists
+    in :samp:`G`.
+
+    For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']`
+    is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists
+    in :samp:`G` or zero otherwise. If the capacity is infinite,
+    :samp:`R[u][v]['capacity']` will have a high arbitrary finite value
+    that does not affect the solution of the problem. This value is stored in
+    :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`,
+    :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and
+    satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`.
+
+    The flow value, defined as the total flow into :samp:`t`, the sink, is
+    stored in :samp:`R.graph['flow_value']`. If :samp:`cutoff` is not
+    specified, reachability to :samp:`t` using only edges :samp:`(u, v)` such
+    that :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum
+    :samp:`s`-:samp:`t` cut.
+
+    Examples
+    --------
+    >>> from networkx.algorithms.flow import edmonds_karp
+
+    The functions that implement flow algorithms and output a residual
+    network, such as this one, are not imported to the base NetworkX
+    namespace, so you have to explicitly import them from the flow package.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_edge("x", "a", capacity=3.0)
+    >>> G.add_edge("x", "b", capacity=1.0)
+    >>> G.add_edge("a", "c", capacity=3.0)
+    >>> G.add_edge("b", "c", capacity=5.0)
+    >>> G.add_edge("b", "d", capacity=4.0)
+    >>> G.add_edge("d", "e", capacity=2.0)
+    >>> G.add_edge("c", "y", capacity=2.0)
+    >>> G.add_edge("e", "y", capacity=3.0)
+    >>> R = edmonds_karp(G, "x", "y")
+    >>> flow_value = nx.maximum_flow_value(G, "x", "y")
+    >>> flow_value
+    3.0
+    >>> flow_value == R.graph["flow_value"]
+    True
+
+    """
+    R = edmonds_karp_impl(G, s, t, capacity, residual, cutoff)
+    R.graph["algorithm"] = "edmonds_karp"
+    return R
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/gomory_hu.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/gomory_hu.py
new file mode 100644
index 0000000..f244339
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/gomory_hu.py
@@ -0,0 +1,176 @@
+"""
+Gomory-Hu tree of undirected Graphs.
+"""
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+from .edmondskarp import edmonds_karp
+from .utils import build_residual_network
+
+default_flow_func = edmonds_karp
+
+__all__ = ["gomory_hu_tree"]
+
+
+@not_implemented_for("directed")
+def gomory_hu_tree(G, capacity="capacity", flow_func=None):
+    r"""Returns the Gomory-Hu tree of an undirected graph G.
+
+    A Gomory-Hu tree of an undirected graph with capacities is a
+    weighted tree that represents the minimum s-t cuts for all s-t
+    pairs in the graph.
+
+    It only requires `n-1` minimum cut computations instead of the
+    obvious `n(n-1)/2`. The tree represents all s-t cuts as the
+    minimum cut value among any pair of nodes is the minimum edge
+    weight in the shortest path between the two nodes in the
+    Gomory-Hu tree.
+
+    The Gomory-Hu tree also has the property that removing the
+    edge with the minimum weight in the shortest path between
+    any two nodes leaves two connected components that form
+    a partition of the nodes in G that defines the minimum s-t
+    cut.
+
+    See Examples section below for details.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    flow_func : function
+        Function to perform the underlying flow computations. Default value
+        :func:`edmonds_karp`. This function performs better in sparse graphs
+        with right tailed degree distributions.
+        :func:`shortest_augmenting_path` will perform better in denser
+        graphs.
+
+    Returns
+    -------
+    Tree : NetworkX graph
+        A NetworkX graph representing the Gomory-Hu tree of the input graph.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        Raised if the input graph is directed.
+
+    NetworkXError
+        Raised if the input graph is an empty Graph.
+
+    Examples
+    --------
+    >>> G = nx.karate_club_graph()
+    >>> nx.set_edge_attributes(G, 1, "capacity")
+    >>> T = nx.gomory_hu_tree(G)
+    >>> # The value of the minimum cut between any pair
+    ... # of nodes in G is the minimum edge weight in the
+    ... # shortest path between the two nodes in the
+    ... # Gomory-Hu tree.
+    ... def minimum_edge_weight_in_shortest_path(T, u, v):
+    ...     path = nx.shortest_path(T, u, v, weight="weight")
+    ...     return min((T[u][v]["weight"], (u, v)) for (u, v) in zip(path, path[1:]))
+    >>> u, v = 0, 33
+    >>> cut_value, edge = minimum_edge_weight_in_shortest_path(T, u, v)
+    >>> cut_value
+    10
+    >>> nx.minimum_cut_value(G, u, v)
+    10
+    >>> # The Comory-Hu tree also has the property that removing the
+    ... # edge with the minimum weight in the shortest path between
+    ... # any two nodes leaves two connected components that form
+    ... # a partition of the nodes in G that defines the minimum s-t
+    ... # cut.
+    ... cut_value, edge = minimum_edge_weight_in_shortest_path(T, u, v)
+    >>> T.remove_edge(*edge)
+    >>> U, V = list(nx.connected_components(T))
+    >>> # Thus U and V form a partition that defines a minimum cut
+    ... # between u and v in G. You can compute the edge cut set,
+    ... # that is, the set of edges that if removed from G will
+    ... # disconnect u from v in G, with this information:
+    ... cutset = set()
+    >>> for x, nbrs in ((n, G[n]) for n in U):
+    ...     cutset.update((x, y) for y in nbrs if y in V)
+    >>> # Because we have set the capacities of all edges to 1
+    ... # the cutset contains ten edges
+    ... len(cutset)
+    10
+    >>> # You can use any maximum flow algorithm for the underlying
+    ... # flow computations using the argument flow_func
+    ... from networkx.algorithms import flow
+    >>> T = nx.gomory_hu_tree(G, flow_func=flow.boykov_kolmogorov)
+    >>> cut_value, edge = minimum_edge_weight_in_shortest_path(T, u, v)
+    >>> cut_value
+    10
+    >>> nx.minimum_cut_value(G, u, v, flow_func=flow.boykov_kolmogorov)
+    10
+
+    Notes
+    -----
+    This implementation is based on Gusfield approach [1]_ to compute
+    Comory-Hu trees, which does not require node contractions and has
+    the same computational complexity than the original method.
+
+    See also
+    --------
+    :func:`minimum_cut`
+    :func:`maximum_flow`
+
+    References
+    ----------
+    .. [1] Gusfield D: Very simple methods for all pairs network flow analysis.
+           SIAM J Comput 19(1):143-155, 1990.
+
+    """
+    if flow_func is None:
+        flow_func = default_flow_func
+
+    if len(G) == 0:  # empty graph
+        msg = "Empty Graph does not have a Gomory-Hu tree representation"
+        raise nx.NetworkXError(msg)
+
+    # Start the tree as a star graph with an arbitrary node at the center
+    tree = {}
+    labels = {}
+    iter_nodes = iter(G)
+    root = next(iter_nodes)
+    for n in iter_nodes:
+        tree[n] = root
+
+    # Reuse residual network
+    R = build_residual_network(G, capacity)
+
+    # For all the leaves in the star graph tree (that is n-1 nodes).
+    for source in tree:
+        # Find neighbor in the tree
+        target = tree[source]
+        # compute minimum cut
+        cut_value, partition = nx.minimum_cut(
+            G, source, target, capacity=capacity, flow_func=flow_func, residual=R
+        )
+        labels[(source, target)] = cut_value
+        # Update the tree
+        # Source will always be in partition[0] and target in partition[1]
+        for node in partition[0]:
+            if node != source and node in tree and tree[node] == target:
+                tree[node] = source
+                labels[node, source] = labels.get((node, target), cut_value)
+        #
+        if target != root and tree[target] in partition[0]:
+            labels[source, tree[target]] = labels[target, tree[target]]
+            labels[target, source] = cut_value
+            tree[source] = tree[target]
+            tree[target] = source
+
+    # Build the tree
+    T = nx.Graph()
+    T.add_nodes_from(G)
+    T.add_weighted_edges_from(((u, v, labels[u, v]) for u, v in tree.items()))
+    return T
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/maxflow.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/maxflow.py
new file mode 100644
index 0000000..8d2fb8f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/maxflow.py
@@ -0,0 +1,611 @@
+"""
+Maximum flow (and minimum cut) algorithms on capacitated graphs.
+"""
+import networkx as nx
+
+from .boykovkolmogorov import boykov_kolmogorov
+from .dinitz_alg import dinitz
+from .edmondskarp import edmonds_karp
+from .preflowpush import preflow_push
+from .shortestaugmentingpath import shortest_augmenting_path
+from .utils import build_flow_dict
+
+# Define the default flow function for computing maximum flow.
+default_flow_func = preflow_push
+# Functions that don't support cutoff for minimum cut computations.
+flow_funcs = [
+    boykov_kolmogorov,
+    dinitz,
+    edmonds_karp,
+    preflow_push,
+    shortest_augmenting_path,
+]
+
+__all__ = ["maximum_flow", "maximum_flow_value", "minimum_cut", "minimum_cut_value"]
+
+
+def maximum_flow(flowG, _s, _t, capacity="capacity", flow_func=None, **kwargs):
+    """Find a maximum single-commodity flow.
+
+    Parameters
+    ----------
+    flowG : NetworkX graph
+        Edges of the graph are expected to have an attribute called
+        'capacity'. If this attribute is not present, the edge is
+        considered to have infinite capacity.
+
+    _s : node
+        Source node for the flow.
+
+    _t : node
+        Sink node for the flow.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes
+        in a capacitated graph. The function has to accept at least three
+        parameters: a Graph or Digraph, a source node, and a target node.
+        And return a residual network that follows NetworkX conventions
+        (see Notes). If flow_func is None, the default maximum
+        flow function (:meth:`preflow_push`) is used. See below for
+        alternative algorithms. The choice of the default function may change
+        from version to version and should not be relied on. Default value:
+        None.
+
+    kwargs : Any other keyword parameter is passed to the function that
+        computes the maximum flow.
+
+    Returns
+    -------
+    flow_value : integer, float
+        Value of the maximum flow, i.e., net outflow from the source.
+
+    flow_dict : dict
+        A dictionary containing the value of the flow that went through
+        each edge.
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support MultiGraph and MultiDiGraph. If
+        the input graph is an instance of one of these two classes, a
+        NetworkXError is raised.
+
+    NetworkXUnbounded
+        If the graph has a path of infinite capacity, the value of a
+        feasible flow on the graph is unbounded above and the function
+        raises a NetworkXUnbounded.
+
+    See also
+    --------
+    :meth:`maximum_flow_value`
+    :meth:`minimum_cut`
+    :meth:`minimum_cut_value`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    Notes
+    -----
+    The function used in the flow_func parameter has to return a residual
+    network that follows NetworkX conventions:
+
+    The residual network :samp:`R` from an input graph :samp:`G` has the
+    same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair
+    of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a
+    self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists
+    in :samp:`G`.
+
+    For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']`
+    is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists
+    in :samp:`G` or zero otherwise. If the capacity is infinite,
+    :samp:`R[u][v]['capacity']` will have a high arbitrary finite value
+    that does not affect the solution of the problem. This value is stored in
+    :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`,
+    :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and
+    satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`.
+
+    The flow value, defined as the total flow into :samp:`t`, the sink, is
+    stored in :samp:`R.graph['flow_value']`. Reachability to :samp:`t` using
+    only edges :samp:`(u, v)` such that
+    :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum
+    :samp:`s`-:samp:`t` cut.
+
+    Specific algorithms may store extra data in :samp:`R`.
+
+    The function should supports an optional boolean parameter value_only. When
+    True, it can optionally terminate the algorithm as soon as the maximum flow
+    value and the minimum cut can be determined.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_edge("x", "a", capacity=3.0)
+    >>> G.add_edge("x", "b", capacity=1.0)
+    >>> G.add_edge("a", "c", capacity=3.0)
+    >>> G.add_edge("b", "c", capacity=5.0)
+    >>> G.add_edge("b", "d", capacity=4.0)
+    >>> G.add_edge("d", "e", capacity=2.0)
+    >>> G.add_edge("c", "y", capacity=2.0)
+    >>> G.add_edge("e", "y", capacity=3.0)
+
+    maximum_flow returns both the value of the maximum flow and a
+    dictionary with all flows.
+
+    >>> flow_value, flow_dict = nx.maximum_flow(G, "x", "y")
+    >>> flow_value
+    3.0
+    >>> print(flow_dict["x"]["b"])
+    1.0
+
+    You can also use alternative algorithms for computing the
+    maximum flow by using the flow_func parameter.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> flow_value == nx.maximum_flow(G, "x", "y", flow_func=shortest_augmenting_path)[
+    ...     0
+    ... ]
+    True
+
+    """
+    if flow_func is None:
+        if kwargs:
+            raise nx.NetworkXError(
+                "You have to explicitly set a flow_func if"
+                " you need to pass parameters via kwargs."
+            )
+        flow_func = default_flow_func
+
+    if not callable(flow_func):
+        raise nx.NetworkXError("flow_func has to be callable.")
+
+    R = flow_func(flowG, _s, _t, capacity=capacity, value_only=False, **kwargs)
+    flow_dict = build_flow_dict(flowG, R)
+
+    return (R.graph["flow_value"], flow_dict)
+
+
+def maximum_flow_value(flowG, _s, _t, capacity="capacity", flow_func=None, **kwargs):
+    """Find the value of maximum single-commodity flow.
+
+    Parameters
+    ----------
+    flowG : NetworkX graph
+        Edges of the graph are expected to have an attribute called
+        'capacity'. If this attribute is not present, the edge is
+        considered to have infinite capacity.
+
+    _s : node
+        Source node for the flow.
+
+    _t : node
+        Sink node for the flow.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes
+        in a capacitated graph. The function has to accept at least three
+        parameters: a Graph or Digraph, a source node, and a target node.
+        And return a residual network that follows NetworkX conventions
+        (see Notes). If flow_func is None, the default maximum
+        flow function (:meth:`preflow_push`) is used. See below for
+        alternative algorithms. The choice of the default function may change
+        from version to version and should not be relied on. Default value:
+        None.
+
+    kwargs : Any other keyword parameter is passed to the function that
+        computes the maximum flow.
+
+    Returns
+    -------
+    flow_value : integer, float
+        Value of the maximum flow, i.e., net outflow from the source.
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support MultiGraph and MultiDiGraph. If
+        the input graph is an instance of one of these two classes, a
+        NetworkXError is raised.
+
+    NetworkXUnbounded
+        If the graph has a path of infinite capacity, the value of a
+        feasible flow on the graph is unbounded above and the function
+        raises a NetworkXUnbounded.
+
+    See also
+    --------
+    :meth:`maximum_flow`
+    :meth:`minimum_cut`
+    :meth:`minimum_cut_value`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    Notes
+    -----
+    The function used in the flow_func parameter has to return a residual
+    network that follows NetworkX conventions:
+
+    The residual network :samp:`R` from an input graph :samp:`G` has the
+    same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair
+    of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a
+    self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists
+    in :samp:`G`.
+
+    For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']`
+    is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists
+    in :samp:`G` or zero otherwise. If the capacity is infinite,
+    :samp:`R[u][v]['capacity']` will have a high arbitrary finite value
+    that does not affect the solution of the problem. This value is stored in
+    :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`,
+    :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and
+    satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`.
+
+    The flow value, defined as the total flow into :samp:`t`, the sink, is
+    stored in :samp:`R.graph['flow_value']`. Reachability to :samp:`t` using
+    only edges :samp:`(u, v)` such that
+    :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum
+    :samp:`s`-:samp:`t` cut.
+
+    Specific algorithms may store extra data in :samp:`R`.
+
+    The function should supports an optional boolean parameter value_only. When
+    True, it can optionally terminate the algorithm as soon as the maximum flow
+    value and the minimum cut can be determined.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_edge("x", "a", capacity=3.0)
+    >>> G.add_edge("x", "b", capacity=1.0)
+    >>> G.add_edge("a", "c", capacity=3.0)
+    >>> G.add_edge("b", "c", capacity=5.0)
+    >>> G.add_edge("b", "d", capacity=4.0)
+    >>> G.add_edge("d", "e", capacity=2.0)
+    >>> G.add_edge("c", "y", capacity=2.0)
+    >>> G.add_edge("e", "y", capacity=3.0)
+
+    maximum_flow_value computes only the value of the
+    maximum flow:
+
+    >>> flow_value = nx.maximum_flow_value(G, "x", "y")
+    >>> flow_value
+    3.0
+
+    You can also use alternative algorithms for computing the
+    maximum flow by using the flow_func parameter.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> flow_value == nx.maximum_flow_value(
+    ...     G, "x", "y", flow_func=shortest_augmenting_path
+    ... )
+    True
+
+    """
+    if flow_func is None:
+        if kwargs:
+            raise nx.NetworkXError(
+                "You have to explicitly set a flow_func if"
+                " you need to pass parameters via kwargs."
+            )
+        flow_func = default_flow_func
+
+    if not callable(flow_func):
+        raise nx.NetworkXError("flow_func has to be callable.")
+
+    R = flow_func(flowG, _s, _t, capacity=capacity, value_only=True, **kwargs)
+
+    return R.graph["flow_value"]
+
+
+def minimum_cut(flowG, _s, _t, capacity="capacity", flow_func=None, **kwargs):
+    """Compute the value and the node partition of a minimum (s, t)-cut.
+
+    Use the max-flow min-cut theorem, i.e., the capacity of a minimum
+    capacity cut is equal to the flow value of a maximum flow.
+
+    Parameters
+    ----------
+    flowG : NetworkX graph
+        Edges of the graph are expected to have an attribute called
+        'capacity'. If this attribute is not present, the edge is
+        considered to have infinite capacity.
+
+    _s : node
+        Source node for the flow.
+
+    _t : node
+        Sink node for the flow.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes
+        in a capacitated graph. The function has to accept at least three
+        parameters: a Graph or Digraph, a source node, and a target node.
+        And return a residual network that follows NetworkX conventions
+        (see Notes). If flow_func is None, the default maximum
+        flow function (:meth:`preflow_push`) is used. See below for
+        alternative algorithms. The choice of the default function may change
+        from version to version and should not be relied on. Default value:
+        None.
+
+    kwargs : Any other keyword parameter is passed to the function that
+        computes the maximum flow.
+
+    Returns
+    -------
+    cut_value : integer, float
+        Value of the minimum cut.
+
+    partition : pair of node sets
+        A partitioning of the nodes that defines a minimum cut.
+
+    Raises
+    ------
+    NetworkXUnbounded
+        If the graph has a path of infinite capacity, all cuts have
+        infinite capacity and the function raises a NetworkXError.
+
+    See also
+    --------
+    :meth:`maximum_flow`
+    :meth:`maximum_flow_value`
+    :meth:`minimum_cut_value`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    Notes
+    -----
+    The function used in the flow_func parameter has to return a residual
+    network that follows NetworkX conventions:
+
+    The residual network :samp:`R` from an input graph :samp:`G` has the
+    same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair
+    of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a
+    self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists
+    in :samp:`G`.
+
+    For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']`
+    is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists
+    in :samp:`G` or zero otherwise. If the capacity is infinite,
+    :samp:`R[u][v]['capacity']` will have a high arbitrary finite value
+    that does not affect the solution of the problem. This value is stored in
+    :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`,
+    :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and
+    satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`.
+
+    The flow value, defined as the total flow into :samp:`t`, the sink, is
+    stored in :samp:`R.graph['flow_value']`. Reachability to :samp:`t` using
+    only edges :samp:`(u, v)` such that
+    :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum
+    :samp:`s`-:samp:`t` cut.
+
+    Specific algorithms may store extra data in :samp:`R`.
+
+    The function should supports an optional boolean parameter value_only. When
+    True, it can optionally terminate the algorithm as soon as the maximum flow
+    value and the minimum cut can be determined.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_edge("x", "a", capacity=3.0)
+    >>> G.add_edge("x", "b", capacity=1.0)
+    >>> G.add_edge("a", "c", capacity=3.0)
+    >>> G.add_edge("b", "c", capacity=5.0)
+    >>> G.add_edge("b", "d", capacity=4.0)
+    >>> G.add_edge("d", "e", capacity=2.0)
+    >>> G.add_edge("c", "y", capacity=2.0)
+    >>> G.add_edge("e", "y", capacity=3.0)
+
+    minimum_cut computes both the value of the
+    minimum cut and the node partition:
+
+    >>> cut_value, partition = nx.minimum_cut(G, "x", "y")
+    >>> reachable, non_reachable = partition
+
+    'partition' here is a tuple with the two sets of nodes that define
+    the minimum cut. You can compute the cut set of edges that induce
+    the minimum cut as follows:
+
+    >>> cutset = set()
+    >>> for u, nbrs in ((n, G[n]) for n in reachable):
+    ...     cutset.update((u, v) for v in nbrs if v in non_reachable)
+    >>> print(sorted(cutset))
+    [('c', 'y'), ('x', 'b')]
+    >>> cut_value == sum(G.edges[u, v]["capacity"] for (u, v) in cutset)
+    True
+
+    You can also use alternative algorithms for computing the
+    minimum cut by using the flow_func parameter.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> cut_value == nx.minimum_cut(G, "x", "y", flow_func=shortest_augmenting_path)[0]
+    True
+
+    """
+    if flow_func is None:
+        if kwargs:
+            raise nx.NetworkXError(
+                "You have to explicitly set a flow_func if"
+                " you need to pass parameters via kwargs."
+            )
+        flow_func = default_flow_func
+
+    if not callable(flow_func):
+        raise nx.NetworkXError("flow_func has to be callable.")
+
+    if kwargs.get("cutoff") is not None and flow_func in flow_funcs:
+        raise nx.NetworkXError("cutoff should not be specified.")
+
+    R = flow_func(flowG, _s, _t, capacity=capacity, value_only=True, **kwargs)
+    # Remove saturated edges from the residual network
+    cutset = [(u, v, d) for u, v, d in R.edges(data=True) if d["flow"] == d["capacity"]]
+    R.remove_edges_from(cutset)
+
+    # Then, reachable and non reachable nodes from source in the
+    # residual network form the node partition that defines
+    # the minimum cut.
+    non_reachable = set(dict(nx.shortest_path_length(R, target=_t)))
+    partition = (set(flowG) - non_reachable, non_reachable)
+    # Finally add again cutset edges to the residual network to make
+    # sure that it is reusable.
+    if cutset is not None:
+        R.add_edges_from(cutset)
+    return (R.graph["flow_value"], partition)
+
+
+def minimum_cut_value(flowG, _s, _t, capacity="capacity", flow_func=None, **kwargs):
+    """Compute the value of a minimum (s, t)-cut.
+
+    Use the max-flow min-cut theorem, i.e., the capacity of a minimum
+    capacity cut is equal to the flow value of a maximum flow.
+
+    Parameters
+    ----------
+    flowG : NetworkX graph
+        Edges of the graph are expected to have an attribute called
+        'capacity'. If this attribute is not present, the edge is
+        considered to have infinite capacity.
+
+    _s : node
+        Source node for the flow.
+
+    _t : node
+        Sink node for the flow.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    flow_func : function
+        A function for computing the maximum flow among a pair of nodes
+        in a capacitated graph. The function has to accept at least three
+        parameters: a Graph or Digraph, a source node, and a target node.
+        And return a residual network that follows NetworkX conventions
+        (see Notes). If flow_func is None, the default maximum
+        flow function (:meth:`preflow_push`) is used. See below for
+        alternative algorithms. The choice of the default function may change
+        from version to version and should not be relied on. Default value:
+        None.
+
+    kwargs : Any other keyword parameter is passed to the function that
+        computes the maximum flow.
+
+    Returns
+    -------
+    cut_value : integer, float
+        Value of the minimum cut.
+
+    Raises
+    ------
+    NetworkXUnbounded
+        If the graph has a path of infinite capacity, all cuts have
+        infinite capacity and the function raises a NetworkXError.
+
+    See also
+    --------
+    :meth:`maximum_flow`
+    :meth:`maximum_flow_value`
+    :meth:`minimum_cut`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+    :meth:`shortest_augmenting_path`
+
+    Notes
+    -----
+    The function used in the flow_func parameter has to return a residual
+    network that follows NetworkX conventions:
+
+    The residual network :samp:`R` from an input graph :samp:`G` has the
+    same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair
+    of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a
+    self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists
+    in :samp:`G`.
+
+    For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']`
+    is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists
+    in :samp:`G` or zero otherwise. If the capacity is infinite,
+    :samp:`R[u][v]['capacity']` will have a high arbitrary finite value
+    that does not affect the solution of the problem. This value is stored in
+    :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`,
+    :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and
+    satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`.
+
+    The flow value, defined as the total flow into :samp:`t`, the sink, is
+    stored in :samp:`R.graph['flow_value']`. Reachability to :samp:`t` using
+    only edges :samp:`(u, v)` such that
+    :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum
+    :samp:`s`-:samp:`t` cut.
+
+    Specific algorithms may store extra data in :samp:`R`.
+
+    The function should supports an optional boolean parameter value_only. When
+    True, it can optionally terminate the algorithm as soon as the maximum flow
+    value and the minimum cut can be determined.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_edge("x", "a", capacity=3.0)
+    >>> G.add_edge("x", "b", capacity=1.0)
+    >>> G.add_edge("a", "c", capacity=3.0)
+    >>> G.add_edge("b", "c", capacity=5.0)
+    >>> G.add_edge("b", "d", capacity=4.0)
+    >>> G.add_edge("d", "e", capacity=2.0)
+    >>> G.add_edge("c", "y", capacity=2.0)
+    >>> G.add_edge("e", "y", capacity=3.0)
+
+    minimum_cut_value computes only the value of the
+    minimum cut:
+
+    >>> cut_value = nx.minimum_cut_value(G, "x", "y")
+    >>> cut_value
+    3.0
+
+    You can also use alternative algorithms for computing the
+    minimum cut by using the flow_func parameter.
+
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+    >>> cut_value == nx.minimum_cut_value(
+    ...     G, "x", "y", flow_func=shortest_augmenting_path
+    ... )
+    True
+
+    """
+    if flow_func is None:
+        if kwargs:
+            raise nx.NetworkXError(
+                "You have to explicitly set a flow_func if"
+                " you need to pass parameters via kwargs."
+            )
+        flow_func = default_flow_func
+
+    if not callable(flow_func):
+        raise nx.NetworkXError("flow_func has to be callable.")
+
+    if kwargs.get("cutoff") is not None and flow_func in flow_funcs:
+        raise nx.NetworkXError("cutoff should not be specified.")
+
+    R = flow_func(flowG, _s, _t, capacity=capacity, value_only=True, **kwargs)
+
+    return R.graph["flow_value"]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/mincost.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/mincost.py
new file mode 100644
index 0000000..6089c71
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/mincost.py
@@ -0,0 +1,331 @@
+"""
+Minimum cost flow algorithms on directed connected graphs.
+"""
+
+__all__ = ["min_cost_flow_cost", "min_cost_flow", "cost_of_flow", "max_flow_min_cost"]
+
+import networkx as nx
+
+
+def min_cost_flow_cost(G, demand="demand", capacity="capacity", weight="weight"):
+    r"""Find the cost of a minimum cost flow satisfying all demands in digraph G.
+
+    G is a digraph with edge costs and capacities and in which nodes
+    have demand, i.e., they want to send or receive some amount of
+    flow. A negative demand means that the node wants to send flow, a
+    positive demand means that the node want to receive flow. A flow on
+    the digraph G satisfies all demand if the net flow into each node
+    is equal to the demand of that node.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        DiGraph on which a minimum cost flow satisfying all demands is
+        to be found.
+
+    demand : string
+        Nodes of the graph G are expected to have an attribute demand
+        that indicates how much flow a node wants to send (negative
+        demand) or receive (positive demand). Note that the sum of the
+        demands should be 0 otherwise the problem in not feasible. If
+        this attribute is not present, a node is considered to have 0
+        demand. Default value: 'demand'.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    weight : string
+        Edges of the graph G are expected to have an attribute weight
+        that indicates the cost incurred by sending one unit of flow on
+        that edge. If not present, the weight is considered to be 0.
+        Default value: 'weight'.
+
+    Returns
+    -------
+    flowCost : integer, float
+        Cost of a minimum cost flow satisfying all demands.
+
+    Raises
+    ------
+    NetworkXError
+        This exception is raised if the input graph is not directed or
+        not connected.
+
+    NetworkXUnfeasible
+        This exception is raised in the following situations:
+
+            * The sum of the demands is not zero. Then, there is no
+              flow satisfying all demands.
+            * There is no flow satisfying all demand.
+
+    NetworkXUnbounded
+        This exception is raised if the digraph G has a cycle of
+        negative cost and infinite capacity. Then, the cost of a flow
+        satisfying all demands is unbounded below.
+
+    See also
+    --------
+    cost_of_flow, max_flow_min_cost, min_cost_flow, network_simplex
+
+    Notes
+    -----
+    This algorithm is not guaranteed to work if edge weights or demands
+    are floating point numbers (overflows and roundoff errors can
+    cause problems). As a workaround you can use integer numbers by
+    multiplying the relevant edge attributes by a convenient
+    constant factor (eg 100).
+
+    Examples
+    --------
+    A simple example of a min cost flow problem.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_node("a", demand=-5)
+    >>> G.add_node("d", demand=5)
+    >>> G.add_edge("a", "b", weight=3, capacity=4)
+    >>> G.add_edge("a", "c", weight=6, capacity=10)
+    >>> G.add_edge("b", "d", weight=1, capacity=9)
+    >>> G.add_edge("c", "d", weight=2, capacity=5)
+    >>> flowCost = nx.min_cost_flow_cost(G)
+    >>> flowCost
+    24
+    """
+    return nx.network_simplex(G, demand=demand, capacity=capacity, weight=weight)[0]
+
+
+def min_cost_flow(G, demand="demand", capacity="capacity", weight="weight"):
+    r"""Returns a minimum cost flow satisfying all demands in digraph G.
+
+    G is a digraph with edge costs and capacities and in which nodes
+    have demand, i.e., they want to send or receive some amount of
+    flow. A negative demand means that the node wants to send flow, a
+    positive demand means that the node want to receive flow. A flow on
+    the digraph G satisfies all demand if the net flow into each node
+    is equal to the demand of that node.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        DiGraph on which a minimum cost flow satisfying all demands is
+        to be found.
+
+    demand : string
+        Nodes of the graph G are expected to have an attribute demand
+        that indicates how much flow a node wants to send (negative
+        demand) or receive (positive demand). Note that the sum of the
+        demands should be 0 otherwise the problem in not feasible. If
+        this attribute is not present, a node is considered to have 0
+        demand. Default value: 'demand'.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    weight : string
+        Edges of the graph G are expected to have an attribute weight
+        that indicates the cost incurred by sending one unit of flow on
+        that edge. If not present, the weight is considered to be 0.
+        Default value: 'weight'.
+
+    Returns
+    -------
+    flowDict : dictionary
+        Dictionary of dictionaries keyed by nodes such that
+        flowDict[u][v] is the flow edge (u, v).
+
+    Raises
+    ------
+    NetworkXError
+        This exception is raised if the input graph is not directed or
+        not connected.
+
+    NetworkXUnfeasible
+        This exception is raised in the following situations:
+
+            * The sum of the demands is not zero. Then, there is no
+              flow satisfying all demands.
+            * There is no flow satisfying all demand.
+
+    NetworkXUnbounded
+        This exception is raised if the digraph G has a cycle of
+        negative cost and infinite capacity. Then, the cost of a flow
+        satisfying all demands is unbounded below.
+
+    See also
+    --------
+    cost_of_flow, max_flow_min_cost, min_cost_flow_cost, network_simplex
+
+    Notes
+    -----
+    This algorithm is not guaranteed to work if edge weights or demands
+    are floating point numbers (overflows and roundoff errors can
+    cause problems). As a workaround you can use integer numbers by
+    multiplying the relevant edge attributes by a convenient
+    constant factor (eg 100).
+
+    Examples
+    --------
+    A simple example of a min cost flow problem.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_node("a", demand=-5)
+    >>> G.add_node("d", demand=5)
+    >>> G.add_edge("a", "b", weight=3, capacity=4)
+    >>> G.add_edge("a", "c", weight=6, capacity=10)
+    >>> G.add_edge("b", "d", weight=1, capacity=9)
+    >>> G.add_edge("c", "d", weight=2, capacity=5)
+    >>> flowDict = nx.min_cost_flow(G)
+    """
+    return nx.network_simplex(G, demand=demand, capacity=capacity, weight=weight)[1]
+
+
+def cost_of_flow(G, flowDict, weight="weight"):
+    """Compute the cost of the flow given by flowDict on graph G.
+
+    Note that this function does not check for the validity of the
+    flow flowDict. This function will fail if the graph G and the
+    flow don't have the same edge set.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        DiGraph on which a minimum cost flow satisfying all demands is
+        to be found.
+
+    weight : string
+        Edges of the graph G are expected to have an attribute weight
+        that indicates the cost incurred by sending one unit of flow on
+        that edge. If not present, the weight is considered to be 0.
+        Default value: 'weight'.
+
+    flowDict : dictionary
+        Dictionary of dictionaries keyed by nodes such that
+        flowDict[u][v] is the flow edge (u, v).
+
+    Returns
+    -------
+    cost : Integer, float
+        The total cost of the flow. This is given by the sum over all
+        edges of the product of the edge's flow and the edge's weight.
+
+    See also
+    --------
+    max_flow_min_cost, min_cost_flow, min_cost_flow_cost, network_simplex
+
+    Notes
+    -----
+    This algorithm is not guaranteed to work if edge weights or demands
+    are floating point numbers (overflows and roundoff errors can
+    cause problems). As a workaround you can use integer numbers by
+    multiplying the relevant edge attributes by a convenient
+    constant factor (eg 100).
+    """
+    return sum((flowDict[u][v] * d.get(weight, 0) for u, v, d in G.edges(data=True)))
+
+
+def max_flow_min_cost(G, s, t, capacity="capacity", weight="weight"):
+    """Returns a maximum (s, t)-flow of minimum cost.
+
+    G is a digraph with edge costs and capacities. There is a source
+    node s and a sink node t. This function finds a maximum flow from
+    s to t whose total cost is minimized.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        DiGraph on which a minimum cost flow satisfying all demands is
+        to be found.
+
+    s: node label
+        Source of the flow.
+
+    t: node label
+        Destination of the flow.
+
+    capacity: string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    weight: string
+        Edges of the graph G are expected to have an attribute weight
+        that indicates the cost incurred by sending one unit of flow on
+        that edge. If not present, the weight is considered to be 0.
+        Default value: 'weight'.
+
+    Returns
+    -------
+    flowDict: dictionary
+        Dictionary of dictionaries keyed by nodes such that
+        flowDict[u][v] is the flow edge (u, v).
+
+    Raises
+    ------
+    NetworkXError
+        This exception is raised if the input graph is not directed or
+        not connected.
+
+    NetworkXUnbounded
+        This exception is raised if there is an infinite capacity path
+        from s to t in G. In this case there is no maximum flow. This
+        exception is also raised if the digraph G has a cycle of
+        negative cost and infinite capacity. Then, the cost of a flow
+        is unbounded below.
+
+    See also
+    --------
+    cost_of_flow, min_cost_flow, min_cost_flow_cost, network_simplex
+
+    Notes
+    -----
+    This algorithm is not guaranteed to work if edge weights or demands
+    are floating point numbers (overflows and roundoff errors can
+    cause problems). As a workaround you can use integer numbers by
+    multiplying the relevant edge attributes by a convenient
+    constant factor (eg 100).
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_edges_from(
+    ...     [
+    ...         (1, 2, {"capacity": 12, "weight": 4}),
+    ...         (1, 3, {"capacity": 20, "weight": 6}),
+    ...         (2, 3, {"capacity": 6, "weight": -3}),
+    ...         (2, 6, {"capacity": 14, "weight": 1}),
+    ...         (3, 4, {"weight": 9}),
+    ...         (3, 5, {"capacity": 10, "weight": 5}),
+    ...         (4, 2, {"capacity": 19, "weight": 13}),
+    ...         (4, 5, {"capacity": 4, "weight": 0}),
+    ...         (5, 7, {"capacity": 28, "weight": 2}),
+    ...         (6, 5, {"capacity": 11, "weight": 1}),
+    ...         (6, 7, {"weight": 8}),
+    ...         (7, 4, {"capacity": 6, "weight": 6}),
+    ...     ]
+    ... )
+    >>> mincostFlow = nx.max_flow_min_cost(G, 1, 7)
+    >>> mincost = nx.cost_of_flow(G, mincostFlow)
+    >>> mincost
+    373
+    >>> from networkx.algorithms.flow import maximum_flow
+    >>> maxFlow = maximum_flow(G, 1, 7)[1]
+    >>> nx.cost_of_flow(G, maxFlow) >= mincost
+    True
+    >>> mincostFlowValue = sum((mincostFlow[u][7] for u in G.predecessors(7))) - sum(
+    ...     (mincostFlow[7][v] for v in G.successors(7))
+    ... )
+    >>> mincostFlowValue == nx.maximum_flow_value(G, 1, 7)
+    True
+
+    """
+    maxFlow = nx.maximum_flow_value(G, s, t, capacity=capacity)
+    H = nx.DiGraph(G)
+    H.add_node(s, demand=-maxFlow)
+    H.add_node(t, demand=maxFlow)
+    return min_cost_flow(H, capacity=capacity, weight=weight)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/networksimplex.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/networksimplex.py
new file mode 100644
index 0000000..3e2eaf5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/networksimplex.py
@@ -0,0 +1,664 @@
+"""
+Minimum cost flow algorithms on directed connected graphs.
+"""
+
+__all__ = ["network_simplex"]
+
+from itertools import chain, islice, repeat
+from math import ceil, sqrt
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+
+class _DataEssentialsAndFunctions:
+    def __init__(
+        self, G, multigraph, demand="demand", capacity="capacity", weight="weight"
+    ):
+
+        # Number all nodes and edges and hereafter reference them using ONLY their numbers
+        self.node_list = list(G)  # nodes
+        self.node_indices = {u: i for i, u in enumerate(self.node_list)}  # node indices
+        self.node_demands = [
+            G.nodes[u].get(demand, 0) for u in self.node_list
+        ]  # node demands
+
+        self.edge_sources = []  # edge sources
+        self.edge_targets = []  # edge targets
+        if multigraph:
+            self.edge_keys = []  # edge keys
+        self.edge_indices = {}  # edge indices
+        self.edge_capacities = []  # edge capacities
+        self.edge_weights = []  # edge weights
+
+        if not multigraph:
+            edges = G.edges(data=True)
+        else:
+            edges = G.edges(data=True, keys=True)
+
+        inf = float("inf")
+        edges = (e for e in edges if e[0] != e[1] and e[-1].get(capacity, inf) != 0)
+        for i, e in enumerate(edges):
+            self.edge_sources.append(self.node_indices[e[0]])
+            self.edge_targets.append(self.node_indices[e[1]])
+            if multigraph:
+                self.edge_keys.append(e[2])
+            self.edge_indices[e[:-1]] = i
+            self.edge_capacities.append(e[-1].get(capacity, inf))
+            self.edge_weights.append(e[-1].get(weight, 0))
+
+        # spanning tree specific data to be initialized
+
+        self.edge_count = None  # number of edges
+        self.edge_flow = None  # edge flows
+        self.node_potentials = None  # node potentials
+        self.parent = None  # parent nodes
+        self.parent_edge = None  # edges to parents
+        self.subtree_size = None  # subtree sizes
+        self.next_node_dft = None  # next nodes in depth-first thread
+        self.prev_node_dft = None  # previous nodes in depth-first thread
+        self.last_descendent_dft = None  # last descendants in depth-first thread
+        self._spanning_tree_initialized = (
+            False  # False until initialize_spanning_tree() is called
+        )
+
+    def initialize_spanning_tree(self, n, faux_inf):
+        self.edge_count = len(self.edge_indices)  # number of edges
+        self.edge_flow = list(
+            chain(repeat(0, self.edge_count), (abs(d) for d in self.node_demands))
+        )  # edge flows
+        self.node_potentials = [
+            faux_inf if d <= 0 else -faux_inf for d in self.node_demands
+        ]  # node potentials
+        self.parent = list(chain(repeat(-1, n), [None]))  # parent nodes
+        self.parent_edge = list(
+            range(self.edge_count, self.edge_count + n)
+        )  # edges to parents
+        self.subtree_size = list(chain(repeat(1, n), [n + 1]))  # subtree sizes
+        self.next_node_dft = list(
+            chain(range(1, n), [-1, 0])
+        )  # next nodes in depth-first thread
+        self.prev_node_dft = list(range(-1, n))  # previous nodes in depth-first thread
+        self.last_descendent_dft = list(
+            chain(range(n), [n - 1])
+        )  # last descendants in depth-first thread
+        self._spanning_tree_initialized = True  # True only if all the assignments pass
+
+    def find_apex(self, p, q):
+        """
+        Find the lowest common ancestor of nodes p and q in the spanning tree.
+        """
+        size_p = self.subtree_size[p]
+        size_q = self.subtree_size[q]
+        while True:
+            while size_p < size_q:
+                p = self.parent[p]
+                size_p = self.subtree_size[p]
+            while size_p > size_q:
+                q = self.parent[q]
+                size_q = self.subtree_size[q]
+            if size_p == size_q:
+                if p != q:
+                    p = self.parent[p]
+                    size_p = self.subtree_size[p]
+                    q = self.parent[q]
+                    size_q = self.subtree_size[q]
+                else:
+                    return p
+
+    def trace_path(self, p, w):
+        """
+        Returns the nodes and edges on the path from node p to its ancestor w.
+        """
+        Wn = [p]
+        We = []
+        while p != w:
+            We.append(self.parent_edge[p])
+            p = self.parent[p]
+            Wn.append(p)
+        return Wn, We
+
+    def find_cycle(self, i, p, q):
+        """
+        Returns the nodes and edges on the cycle containing edge i == (p, q)
+        when the latter is added to the spanning tree.
+
+        The cycle is oriented in the direction from p to q.
+        """
+        w = self.find_apex(p, q)
+        Wn, We = self.trace_path(p, w)
+        Wn.reverse()
+        We.reverse()
+        if We != [i]:
+            We.append(i)
+        WnR, WeR = self.trace_path(q, w)
+        del WnR[-1]
+        Wn += WnR
+        We += WeR
+        return Wn, We
+
+    def augment_flow(self, Wn, We, f):
+        """
+        Augment f units of flow along a cycle represented by Wn and We.
+        """
+        for i, p in zip(We, Wn):
+            if self.edge_sources[i] == p:
+                self.edge_flow[i] += f
+            else:
+                self.edge_flow[i] -= f
+
+    def trace_subtree(self, p):
+        """
+        Yield the nodes in the subtree rooted at a node p.
+        """
+        yield p
+        l = self.last_descendent_dft[p]
+        while p != l:
+            p = self.next_node_dft[p]
+            yield p
+
+    def remove_edge(self, s, t):
+        """
+        Remove an edge (s, t) where parent[t] == s from the spanning tree.
+        """
+        size_t = self.subtree_size[t]
+        prev_t = self.prev_node_dft[t]
+        last_t = self.last_descendent_dft[t]
+        next_last_t = self.next_node_dft[last_t]
+        # Remove (s, t).
+        self.parent[t] = None
+        self.parent_edge[t] = None
+        # Remove the subtree rooted at t from the depth-first thread.
+        self.next_node_dft[prev_t] = next_last_t
+        self.prev_node_dft[next_last_t] = prev_t
+        self.next_node_dft[last_t] = t
+        self.prev_node_dft[t] = last_t
+        # Update the subtree sizes and last descendants of the (old) acenstors
+        # of t.
+        while s is not None:
+            self.subtree_size[s] -= size_t
+            if self.last_descendent_dft[s] == last_t:
+                self.last_descendent_dft[s] = prev_t
+            s = self.parent[s]
+
+    def make_root(self, q):
+        """
+        Make a node q the root of its containing subtree.
+        """
+        ancestors = []
+        while q is not None:
+            ancestors.append(q)
+            q = self.parent[q]
+        ancestors.reverse()
+        for p, q in zip(ancestors, islice(ancestors, 1, None)):
+            size_p = self.subtree_size[p]
+            last_p = self.last_descendent_dft[p]
+            prev_q = self.prev_node_dft[q]
+            last_q = self.last_descendent_dft[q]
+            next_last_q = self.next_node_dft[last_q]
+            # Make p a child of q.
+            self.parent[p] = q
+            self.parent[q] = None
+            self.parent_edge[p] = self.parent_edge[q]
+            self.parent_edge[q] = None
+            self.subtree_size[p] = size_p - self.subtree_size[q]
+            self.subtree_size[q] = size_p
+            # Remove the subtree rooted at q from the depth-first thread.
+            self.next_node_dft[prev_q] = next_last_q
+            self.prev_node_dft[next_last_q] = prev_q
+            self.next_node_dft[last_q] = q
+            self.prev_node_dft[q] = last_q
+            if last_p == last_q:
+                self.last_descendent_dft[p] = prev_q
+                last_p = prev_q
+            # Add the remaining parts of the subtree rooted at p as a subtree
+            # of q in the depth-first thread.
+            self.prev_node_dft[p] = last_q
+            self.next_node_dft[last_q] = p
+            self.next_node_dft[last_p] = q
+            self.prev_node_dft[q] = last_p
+            self.last_descendent_dft[q] = last_p
+
+    def add_edge(self, i, p, q):
+        """
+        Add an edge (p, q) to the spanning tree where q is the root of a subtree.
+        """
+        last_p = self.last_descendent_dft[p]
+        next_last_p = self.next_node_dft[last_p]
+        size_q = self.subtree_size[q]
+        last_q = self.last_descendent_dft[q]
+        # Make q a child of p.
+        self.parent[q] = p
+        self.parent_edge[q] = i
+        # Insert the subtree rooted at q into the depth-first thread.
+        self.next_node_dft[last_p] = q
+        self.prev_node_dft[q] = last_p
+        self.prev_node_dft[next_last_p] = last_q
+        self.next_node_dft[last_q] = next_last_p
+        # Update the subtree sizes and last descendants of the (new) ancestors
+        # of q.
+        while p is not None:
+            self.subtree_size[p] += size_q
+            if self.last_descendent_dft[p] == last_p:
+                self.last_descendent_dft[p] = last_q
+            p = self.parent[p]
+
+    def update_potentials(self, i, p, q):
+        """
+        Update the potentials of the nodes in the subtree rooted at a node
+        q connected to its parent p by an edge i.
+        """
+        if q == self.edge_targets[i]:
+            d = self.node_potentials[p] - self.edge_weights[i] - self.node_potentials[q]
+        else:
+            d = self.node_potentials[p] + self.edge_weights[i] - self.node_potentials[q]
+        for q in self.trace_subtree(q):
+            self.node_potentials[q] += d
+
+    def reduced_cost(self, i):
+        """Returns the reduced cost of an edge i."""
+        c = (
+            self.edge_weights[i]
+            - self.node_potentials[self.edge_sources[i]]
+            + self.node_potentials[self.edge_targets[i]]
+        )
+        return c if self.edge_flow[i] == 0 else -c
+
+    def find_entering_edges(self):
+        """Yield entering edges until none can be found."""
+        if self.edge_count == 0:
+            return
+
+        # Entering edges are found by combining Dantzig's rule and Bland's
+        # rule. The edges are cyclically grouped into blocks of size B. Within
+        # each block, Dantzig's rule is applied to find an entering edge. The
+        # blocks to search is determined following Bland's rule.
+        B = int(ceil(sqrt(self.edge_count)))  # pivot block size
+        M = (self.edge_count + B - 1) // B  # number of blocks needed to cover all edges
+        m = 0  # number of consecutive blocks without eligible
+        # entering edges
+        f = 0  # first edge in block
+        while m < M:
+            # Determine the next block of edges.
+            l = f + B
+            if l <= self.edge_count:
+                edges = range(f, l)
+            else:
+                l -= self.edge_count
+                edges = chain(range(f, self.edge_count), range(l))
+            f = l
+            # Find the first edge with the lowest reduced cost.
+            i = min(edges, key=self.reduced_cost)
+            c = self.reduced_cost(i)
+            if c >= 0:
+                # No entering edge found in the current block.
+                m += 1
+            else:
+                # Entering edge found.
+                if self.edge_flow[i] == 0:
+                    p = self.edge_sources[i]
+                    q = self.edge_targets[i]
+                else:
+                    p = self.edge_targets[i]
+                    q = self.edge_sources[i]
+                yield i, p, q
+                m = 0
+        # All edges have nonnegative reduced costs. The current flow is
+        # optimal.
+
+    def residual_capacity(self, i, p):
+        """Returns the residual capacity of an edge i in the direction away
+        from its endpoint p.
+        """
+        return (
+            self.edge_capacities[i] - self.edge_flow[i]
+            if self.edge_sources[i] == p
+            else self.edge_flow[i]
+        )
+
+    def find_leaving_edge(self, Wn, We):
+        """Returns the leaving edge in a cycle represented by Wn and We."""
+        j, s = min(
+            zip(reversed(We), reversed(Wn)),
+            key=lambda i_p: self.residual_capacity(*i_p),
+        )
+        t = self.edge_targets[j] if self.edge_sources[j] == s else self.edge_sources[j]
+        return j, s, t
+
+
+@not_implemented_for("undirected")
+def network_simplex(G, demand="demand", capacity="capacity", weight="weight"):
+    r"""Find a minimum cost flow satisfying all demands in digraph G.
+
+    This is a primal network simplex algorithm that uses the leaving
+    arc rule to prevent cycling.
+
+    G is a digraph with edge costs and capacities and in which nodes
+    have demand, i.e., they want to send or receive some amount of
+    flow. A negative demand means that the node wants to send flow, a
+    positive demand means that the node want to receive flow. A flow on
+    the digraph G satisfies all demand if the net flow into each node
+    is equal to the demand of that node.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        DiGraph on which a minimum cost flow satisfying all demands is
+        to be found.
+
+    demand : string
+        Nodes of the graph G are expected to have an attribute demand
+        that indicates how much flow a node wants to send (negative
+        demand) or receive (positive demand). Note that the sum of the
+        demands should be 0 otherwise the problem in not feasible. If
+        this attribute is not present, a node is considered to have 0
+        demand. Default value: 'demand'.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    weight : string
+        Edges of the graph G are expected to have an attribute weight
+        that indicates the cost incurred by sending one unit of flow on
+        that edge. If not present, the weight is considered to be 0.
+        Default value: 'weight'.
+
+    Returns
+    -------
+    flowCost : integer, float
+        Cost of a minimum cost flow satisfying all demands.
+
+    flowDict : dictionary
+        Dictionary of dictionaries keyed by nodes such that
+        flowDict[u][v] is the flow edge (u, v).
+
+    Raises
+    ------
+    NetworkXError
+        This exception is raised if the input graph is not directed or
+        not connected.
+
+    NetworkXUnfeasible
+        This exception is raised in the following situations:
+
+            * The sum of the demands is not zero. Then, there is no
+              flow satisfying all demands.
+            * There is no flow satisfying all demand.
+
+    NetworkXUnbounded
+        This exception is raised if the digraph G has a cycle of
+        negative cost and infinite capacity. Then, the cost of a flow
+        satisfying all demands is unbounded below.
+
+    Notes
+    -----
+    This algorithm is not guaranteed to work if edge weights or demands
+    are floating point numbers (overflows and roundoff errors can
+    cause problems). As a workaround you can use integer numbers by
+    multiplying the relevant edge attributes by a convenient
+    constant factor (eg 100).
+
+    See also
+    --------
+    cost_of_flow, max_flow_min_cost, min_cost_flow, min_cost_flow_cost
+
+    Examples
+    --------
+    A simple example of a min cost flow problem.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_node("a", demand=-5)
+    >>> G.add_node("d", demand=5)
+    >>> G.add_edge("a", "b", weight=3, capacity=4)
+    >>> G.add_edge("a", "c", weight=6, capacity=10)
+    >>> G.add_edge("b", "d", weight=1, capacity=9)
+    >>> G.add_edge("c", "d", weight=2, capacity=5)
+    >>> flowCost, flowDict = nx.network_simplex(G)
+    >>> flowCost
+    24
+    >>> flowDict
+    {'a': {'b': 4, 'c': 1}, 'd': {}, 'b': {'d': 4}, 'c': {'d': 1}}
+
+    The mincost flow algorithm can also be used to solve shortest path
+    problems. To find the shortest path between two nodes u and v,
+    give all edges an infinite capacity, give node u a demand of -1 and
+    node v a demand a 1. Then run the network simplex. The value of a
+    min cost flow will be the distance between u and v and edges
+    carrying positive flow will indicate the path.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_weighted_edges_from(
+    ...     [
+    ...         ("s", "u", 10),
+    ...         ("s", "x", 5),
+    ...         ("u", "v", 1),
+    ...         ("u", "x", 2),
+    ...         ("v", "y", 1),
+    ...         ("x", "u", 3),
+    ...         ("x", "v", 5),
+    ...         ("x", "y", 2),
+    ...         ("y", "s", 7),
+    ...         ("y", "v", 6),
+    ...     ]
+    ... )
+    >>> G.add_node("s", demand=-1)
+    >>> G.add_node("v", demand=1)
+    >>> flowCost, flowDict = nx.network_simplex(G)
+    >>> flowCost == nx.shortest_path_length(G, "s", "v", weight="weight")
+    True
+    >>> sorted([(u, v) for u in flowDict for v in flowDict[u] if flowDict[u][v] > 0])
+    [('s', 'x'), ('u', 'v'), ('x', 'u')]
+    >>> nx.shortest_path(G, "s", "v", weight="weight")
+    ['s', 'x', 'u', 'v']
+
+    It is possible to change the name of the attributes used for the
+    algorithm.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_node("p", spam=-4)
+    >>> G.add_node("q", spam=2)
+    >>> G.add_node("a", spam=-2)
+    >>> G.add_node("d", spam=-1)
+    >>> G.add_node("t", spam=2)
+    >>> G.add_node("w", spam=3)
+    >>> G.add_edge("p", "q", cost=7, vacancies=5)
+    >>> G.add_edge("p", "a", cost=1, vacancies=4)
+    >>> G.add_edge("q", "d", cost=2, vacancies=3)
+    >>> G.add_edge("t", "q", cost=1, vacancies=2)
+    >>> G.add_edge("a", "t", cost=2, vacancies=4)
+    >>> G.add_edge("d", "w", cost=3, vacancies=4)
+    >>> G.add_edge("t", "w", cost=4, vacancies=1)
+    >>> flowCost, flowDict = nx.network_simplex(
+    ...     G, demand="spam", capacity="vacancies", weight="cost"
+    ... )
+    >>> flowCost
+    37
+    >>> flowDict
+    {'p': {'q': 2, 'a': 2}, 'q': {'d': 1}, 'a': {'t': 4}, 'd': {'w': 2}, 't': {'q': 1, 'w': 1}, 'w': {}}
+
+    References
+    ----------
+    .. [1] Z. Kiraly, P. Kovacs.
+           Efficient implementation of minimum-cost flow algorithms.
+           Acta Universitatis Sapientiae, Informatica 4(1):67--118. 2012.
+    .. [2] R. Barr, F. Glover, D. Klingman.
+           Enhancement of spanning tree labeling procedures for network
+           optimization.
+           INFOR 17(1):16--34. 1979.
+    """
+    ###########################################################################
+    # Problem essentials extraction and sanity check
+    ###########################################################################
+
+    if len(G) == 0:
+        raise nx.NetworkXError("graph has no nodes")
+
+    multigraph = G.is_multigraph()
+
+    # extracting data essential to problem
+    DEAF = _DataEssentialsAndFunctions(
+        G, multigraph, demand=demand, capacity=capacity, weight=weight
+    )
+
+    ###########################################################################
+    # Quick Error Detection
+    ###########################################################################
+
+    inf = float("inf")
+    for u, d in zip(DEAF.node_list, DEAF.node_demands):
+        if abs(d) == inf:
+            raise nx.NetworkXError(f"node {u!r} has infinite demand")
+    for e, w in zip(DEAF.edge_indices, DEAF.edge_weights):
+        if abs(w) == inf:
+            raise nx.NetworkXError(f"edge {e!r} has infinite weight")
+    if not multigraph:
+        edges = nx.selfloop_edges(G, data=True)
+    else:
+        edges = nx.selfloop_edges(G, data=True, keys=True)
+    for e in edges:
+        if abs(e[-1].get(weight, 0)) == inf:
+            raise nx.NetworkXError(f"edge {e[:-1]!r} has infinite weight")
+
+    ###########################################################################
+    # Quick Infeasibility Detection
+    ###########################################################################
+
+    if sum(DEAF.node_demands) != 0:
+        raise nx.NetworkXUnfeasible("total node demand is not zero")
+    for e, c in zip(DEAF.edge_indices, DEAF.edge_capacities):
+        if c < 0:
+            raise nx.NetworkXUnfeasible(f"edge {e!r} has negative capacity")
+    if not multigraph:
+        edges = nx.selfloop_edges(G, data=True)
+    else:
+        edges = nx.selfloop_edges(G, data=True, keys=True)
+    for e in edges:
+        if e[-1].get(capacity, inf) < 0:
+            raise nx.NetworkXUnfeasible(f"edge {e[:-1]!r} has negative capacity")
+
+    ###########################################################################
+    # Initialization
+    ###########################################################################
+
+    # Add a dummy node -1 and connect all existing nodes to it with infinite-
+    # capacity dummy edges. Node -1 will serve as the root of the
+    # spanning tree of the network simplex method. The new edges will used to
+    # trivially satisfy the node demands and create an initial strongly
+    # feasible spanning tree.
+    for i, d in enumerate(DEAF.node_demands):
+        # Must be greater-than here. Zero-demand nodes must have
+        # edges pointing towards the root to ensure strong feasibility.
+        if d > 0:
+            DEAF.edge_sources.append(-1)
+            DEAF.edge_targets.append(i)
+        else:
+            DEAF.edge_sources.append(i)
+            DEAF.edge_targets.append(-1)
+    faux_inf = (
+        3
+        * max(
+            chain(
+                [
+                    sum(c for c in DEAF.edge_capacities if c < inf),
+                    sum(abs(w) for w in DEAF.edge_weights),
+                ],
+                (abs(d) for d in DEAF.node_demands),
+            )
+        )
+        or 1
+    )
+
+    n = len(DEAF.node_list)  # number of nodes
+    DEAF.edge_weights.extend(repeat(faux_inf, n))
+    DEAF.edge_capacities.extend(repeat(faux_inf, n))
+
+    # Construct the initial spanning tree.
+    DEAF.initialize_spanning_tree(n, faux_inf)
+
+    ###########################################################################
+    # Pivot loop
+    ###########################################################################
+
+    for i, p, q in DEAF.find_entering_edges():
+        Wn, We = DEAF.find_cycle(i, p, q)
+        j, s, t = DEAF.find_leaving_edge(Wn, We)
+        DEAF.augment_flow(Wn, We, DEAF.residual_capacity(j, s))
+        # Do nothing more if the entering edge is the same as the leaving edge.
+        if i != j:
+            if DEAF.parent[t] != s:
+                # Ensure that s is the parent of t.
+                s, t = t, s
+            if We.index(i) > We.index(j):
+                # Ensure that q is in the subtree rooted at t.
+                p, q = q, p
+            DEAF.remove_edge(s, t)
+            DEAF.make_root(q)
+            DEAF.add_edge(i, p, q)
+            DEAF.update_potentials(i, p, q)
+
+    ###########################################################################
+    # Infeasibility and unboundedness detection
+    ###########################################################################
+
+    if any(DEAF.edge_flow[i] != 0 for i in range(-n, 0)):
+        raise nx.NetworkXUnfeasible("no flow satisfies all node demands")
+
+    if any(DEAF.edge_flow[i] * 2 >= faux_inf for i in range(DEAF.edge_count)) or any(
+        e[-1].get(capacity, inf) == inf and e[-1].get(weight, 0) < 0
+        for e in nx.selfloop_edges(G, data=True)
+    ):
+        raise nx.NetworkXUnbounded("negative cycle with infinite capacity found")
+
+    ###########################################################################
+    # Flow cost calculation and flow dict construction
+    ###########################################################################
+
+    del DEAF.edge_flow[DEAF.edge_count :]
+    flow_cost = sum(w * x for w, x in zip(DEAF.edge_weights, DEAF.edge_flow))
+    flow_dict = {n: {} for n in DEAF.node_list}
+
+    def add_entry(e):
+        """Add a flow dict entry."""
+        d = flow_dict[e[0]]
+        for k in e[1:-2]:
+            try:
+                d = d[k]
+            except KeyError:
+                t = {}
+                d[k] = t
+                d = t
+        d[e[-2]] = e[-1]
+
+    DEAF.edge_sources = (
+        DEAF.node_list[s] for s in DEAF.edge_sources
+    )  # Use original nodes.
+    DEAF.edge_targets = (
+        DEAF.node_list[t] for t in DEAF.edge_targets
+    )  # Use original nodes.
+    if not multigraph:
+        for e in zip(DEAF.edge_sources, DEAF.edge_targets, DEAF.edge_flow):
+            add_entry(e)
+        edges = G.edges(data=True)
+    else:
+        for e in zip(
+            DEAF.edge_sources, DEAF.edge_targets, DEAF.edge_keys, DEAF.edge_flow
+        ):
+            add_entry(e)
+        edges = G.edges(data=True, keys=True)
+    for e in edges:
+        if e[0] != e[1]:
+            if e[-1].get(capacity, inf) == 0:
+                add_entry(e[:-1] + (0,))
+        else:
+            w = e[-1].get(weight, 0)
+            if w >= 0:
+                add_entry(e[:-1] + (0,))
+            else:
+                c = e[-1][capacity]
+                flow_cost += w * c
+                add_entry(e[:-1] + (c,))
+
+    return flow_cost, flow_dict
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/preflowpush.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/preflowpush.py
new file mode 100644
index 0000000..aa6647b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/preflowpush.py
@@ -0,0 +1,423 @@
+"""
+Highest-label preflow-push algorithm for maximum flow problems.
+"""
+
+from collections import deque
+from itertools import islice
+
+import networkx as nx
+
+from ...utils import arbitrary_element
+from .utils import (
+    CurrentEdge,
+    GlobalRelabelThreshold,
+    Level,
+    build_residual_network,
+    detect_unboundedness,
+)
+
+__all__ = ["preflow_push"]
+
+
+def preflow_push_impl(G, s, t, capacity, residual, global_relabel_freq, value_only):
+    """Implementation of the highest-label preflow-push algorithm."""
+    if s not in G:
+        raise nx.NetworkXError(f"node {str(s)} not in graph")
+    if t not in G:
+        raise nx.NetworkXError(f"node {str(t)} not in graph")
+    if s == t:
+        raise nx.NetworkXError("source and sink are the same node")
+
+    if global_relabel_freq is None:
+        global_relabel_freq = 0
+    if global_relabel_freq < 0:
+        raise nx.NetworkXError("global_relabel_freq must be nonnegative.")
+
+    if residual is None:
+        R = build_residual_network(G, capacity)
+    else:
+        R = residual
+
+    detect_unboundedness(R, s, t)
+
+    R_nodes = R.nodes
+    R_pred = R.pred
+    R_succ = R.succ
+
+    # Initialize/reset the residual network.
+    for u in R:
+        R_nodes[u]["excess"] = 0
+        for e in R_succ[u].values():
+            e["flow"] = 0
+
+    def reverse_bfs(src):
+        """Perform a reverse breadth-first search from src in the residual
+        network.
+        """
+        heights = {src: 0}
+        q = deque([(src, 0)])
+        while q:
+            u, height = q.popleft()
+            height += 1
+            for v, attr in R_pred[u].items():
+                if v not in heights and attr["flow"] < attr["capacity"]:
+                    heights[v] = height
+                    q.append((v, height))
+        return heights
+
+    # Initialize heights of the nodes.
+    heights = reverse_bfs(t)
+
+    if s not in heights:
+        # t is not reachable from s in the residual network. The maximum flow
+        # must be zero.
+        R.graph["flow_value"] = 0
+        return R
+
+    n = len(R)
+    # max_height represents the height of the highest level below level n with
+    # at least one active node.
+    max_height = max(heights[u] for u in heights if u != s)
+    heights[s] = n
+
+    grt = GlobalRelabelThreshold(n, R.size(), global_relabel_freq)
+
+    # Initialize heights and 'current edge' data structures of the nodes.
+    for u in R:
+        R_nodes[u]["height"] = heights[u] if u in heights else n + 1
+        R_nodes[u]["curr_edge"] = CurrentEdge(R_succ[u])
+
+    def push(u, v, flow):
+        """Push flow units of flow from u to v."""
+        R_succ[u][v]["flow"] += flow
+        R_succ[v][u]["flow"] -= flow
+        R_nodes[u]["excess"] -= flow
+        R_nodes[v]["excess"] += flow
+
+    # The maximum flow must be nonzero now. Initialize the preflow by
+    # saturating all edges emanating from s.
+    for u, attr in R_succ[s].items():
+        flow = attr["capacity"]
+        if flow > 0:
+            push(s, u, flow)
+
+    # Partition nodes into levels.
+    levels = [Level() for i in range(2 * n)]
+    for u in R:
+        if u != s and u != t:
+            level = levels[R_nodes[u]["height"]]
+            if R_nodes[u]["excess"] > 0:
+                level.active.add(u)
+            else:
+                level.inactive.add(u)
+
+    def activate(v):
+        """Move a node from the inactive set to the active set of its level."""
+        if v != s and v != t:
+            level = levels[R_nodes[v]["height"]]
+            if v in level.inactive:
+                level.inactive.remove(v)
+                level.active.add(v)
+
+    def relabel(u):
+        """Relabel a node to create an admissible edge."""
+        grt.add_work(len(R_succ[u]))
+        return (
+            min(
+                R_nodes[v]["height"]
+                for v, attr in R_succ[u].items()
+                if attr["flow"] < attr["capacity"]
+            )
+            + 1
+        )
+
+    def discharge(u, is_phase1):
+        """Discharge a node until it becomes inactive or, during phase 1 (see
+        below), its height reaches at least n. The node is known to have the
+        largest height among active nodes.
+        """
+        height = R_nodes[u]["height"]
+        curr_edge = R_nodes[u]["curr_edge"]
+        # next_height represents the next height to examine after discharging
+        # the current node. During phase 1, it is capped to below n.
+        next_height = height
+        levels[height].active.remove(u)
+        while True:
+            v, attr = curr_edge.get()
+            if height == R_nodes[v]["height"] + 1 and attr["flow"] < attr["capacity"]:
+                flow = min(R_nodes[u]["excess"], attr["capacity"] - attr["flow"])
+                push(u, v, flow)
+                activate(v)
+                if R_nodes[u]["excess"] == 0:
+                    # The node has become inactive.
+                    levels[height].inactive.add(u)
+                    break
+            try:
+                curr_edge.move_to_next()
+            except StopIteration:
+                # We have run off the end of the adjacency list, and there can
+                # be no more admissible edges. Relabel the node to create one.
+                height = relabel(u)
+                if is_phase1 and height >= n - 1:
+                    # Although the node is still active, with a height at least
+                    # n - 1, it is now known to be on the s side of the minimum
+                    # s-t cut. Stop processing it until phase 2.
+                    levels[height].active.add(u)
+                    break
+                # The first relabel operation after global relabeling may not
+                # increase the height of the node since the 'current edge' data
+                # structure is not rewound. Use height instead of (height - 1)
+                # in case other active nodes at the same level are missed.
+                next_height = height
+        R_nodes[u]["height"] = height
+        return next_height
+
+    def gap_heuristic(height):
+        """Apply the gap heuristic."""
+        # Move all nodes at levels (height + 1) to max_height to level n + 1.
+        for level in islice(levels, height + 1, max_height + 1):
+            for u in level.active:
+                R_nodes[u]["height"] = n + 1
+            for u in level.inactive:
+                R_nodes[u]["height"] = n + 1
+            levels[n + 1].active.update(level.active)
+            level.active.clear()
+            levels[n + 1].inactive.update(level.inactive)
+            level.inactive.clear()
+
+    def global_relabel(from_sink):
+        """Apply the global relabeling heuristic."""
+        src = t if from_sink else s
+        heights = reverse_bfs(src)
+        if not from_sink:
+            # s must be reachable from t. Remove t explicitly.
+            del heights[t]
+        max_height = max(heights.values())
+        if from_sink:
+            # Also mark nodes from which t is unreachable for relabeling. This
+            # serves the same purpose as the gap heuristic.
+            for u in R:
+                if u not in heights and R_nodes[u]["height"] < n:
+                    heights[u] = n + 1
+        else:
+            # Shift the computed heights because the height of s is n.
+            for u in heights:
+                heights[u] += n
+            max_height += n
+        del heights[src]
+        for u, new_height in heights.items():
+            old_height = R_nodes[u]["height"]
+            if new_height != old_height:
+                if u in levels[old_height].active:
+                    levels[old_height].active.remove(u)
+                    levels[new_height].active.add(u)
+                else:
+                    levels[old_height].inactive.remove(u)
+                    levels[new_height].inactive.add(u)
+                R_nodes[u]["height"] = new_height
+        return max_height
+
+    # Phase 1: Find the maximum preflow by pushing as much flow as possible to
+    # t.
+
+    height = max_height
+    while height > 0:
+        # Discharge active nodes in the current level.
+        while True:
+            level = levels[height]
+            if not level.active:
+                # All active nodes in the current level have been discharged.
+                # Move to the next lower level.
+                height -= 1
+                break
+            # Record the old height and level for the gap heuristic.
+            old_height = height
+            old_level = level
+            u = arbitrary_element(level.active)
+            height = discharge(u, True)
+            if grt.is_reached():
+                # Global relabeling heuristic: Recompute the exact heights of
+                # all nodes.
+                height = global_relabel(True)
+                max_height = height
+                grt.clear_work()
+            elif not old_level.active and not old_level.inactive:
+                # Gap heuristic: If the level at old_height is empty (a 'gap'),
+                # a minimum cut has been identified. All nodes with heights
+                # above old_height can have their heights set to n + 1 and not
+                # be further processed before a maximum preflow is found.
+                gap_heuristic(old_height)
+                height = old_height - 1
+                max_height = height
+            else:
+                # Update the height of the highest level with at least one
+                # active node.
+                max_height = max(max_height, height)
+
+    # A maximum preflow has been found. The excess at t is the maximum flow
+    # value.
+    if value_only:
+        R.graph["flow_value"] = R_nodes[t]["excess"]
+        return R
+
+    # Phase 2: Convert the maximum preflow into a maximum flow by returning the
+    # excess to s.
+
+    # Relabel all nodes so that they have accurate heights.
+    height = global_relabel(False)
+    grt.clear_work()
+
+    # Continue to discharge the active nodes.
+    while height > n:
+        # Discharge active nodes in the current level.
+        while True:
+            level = levels[height]
+            if not level.active:
+                # All active nodes in the current level have been discharged.
+                # Move to the next lower level.
+                height -= 1
+                break
+            u = arbitrary_element(level.active)
+            height = discharge(u, False)
+            if grt.is_reached():
+                # Global relabeling heuristic.
+                height = global_relabel(False)
+                grt.clear_work()
+
+    R.graph["flow_value"] = R_nodes[t]["excess"]
+    return R
+
+
+def preflow_push(
+    G, s, t, capacity="capacity", residual=None, global_relabel_freq=1, value_only=False
+):
+    r"""Find a maximum single-commodity flow using the highest-label
+    preflow-push algorithm.
+
+    This function returns the residual network resulting after computing
+    the maximum flow. See below for details about the conventions
+    NetworkX uses for defining residual networks.
+
+    This algorithm has a running time of $O(n^2 \sqrt{m})$ for $n$ nodes and
+    $m$ edges.
+
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Edges of the graph are expected to have an attribute called
+        'capacity'. If this attribute is not present, the edge is
+        considered to have infinite capacity.
+
+    s : node
+        Source node for the flow.
+
+    t : node
+        Sink node for the flow.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    residual : NetworkX graph
+        Residual network on which the algorithm is to be executed. If None, a
+        new residual network is created. Default value: None.
+
+    global_relabel_freq : integer, float
+        Relative frequency of applying the global relabeling heuristic to speed
+        up the algorithm. If it is None, the heuristic is disabled. Default
+        value: 1.
+
+    value_only : bool
+        If False, compute a maximum flow; otherwise, compute a maximum preflow
+        which is enough for computing the maximum flow value. Default value:
+        False.
+
+    Returns
+    -------
+    R : NetworkX DiGraph
+        Residual network after computing the maximum flow.
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support MultiGraph and MultiDiGraph. If
+        the input graph is an instance of one of these two classes, a
+        NetworkXError is raised.
+
+    NetworkXUnbounded
+        If the graph has a path of infinite capacity, the value of a
+        feasible flow on the graph is unbounded above and the function
+        raises a NetworkXUnbounded.
+
+    See also
+    --------
+    :meth:`maximum_flow`
+    :meth:`minimum_cut`
+    :meth:`edmonds_karp`
+    :meth:`shortest_augmenting_path`
+
+    Notes
+    -----
+    The residual network :samp:`R` from an input graph :samp:`G` has the
+    same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair
+    of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a
+    self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists
+    in :samp:`G`. For each node :samp:`u` in :samp:`R`,
+    :samp:`R.nodes[u]['excess']` represents the difference between flow into
+    :samp:`u` and flow out of :samp:`u`.
+
+    For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']`
+    is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists
+    in :samp:`G` or zero otherwise. If the capacity is infinite,
+    :samp:`R[u][v]['capacity']` will have a high arbitrary finite value
+    that does not affect the solution of the problem. This value is stored in
+    :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`,
+    :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and
+    satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`.
+
+    The flow value, defined as the total flow into :samp:`t`, the sink, is
+    stored in :samp:`R.graph['flow_value']`. Reachability to :samp:`t` using
+    only edges :samp:`(u, v)` such that
+    :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum
+    :samp:`s`-:samp:`t` cut.
+
+    Examples
+    --------
+    >>> from networkx.algorithms.flow import preflow_push
+
+    The functions that implement flow algorithms and output a residual
+    network, such as this one, are not imported to the base NetworkX
+    namespace, so you have to explicitly import them from the flow package.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_edge("x", "a", capacity=3.0)
+    >>> G.add_edge("x", "b", capacity=1.0)
+    >>> G.add_edge("a", "c", capacity=3.0)
+    >>> G.add_edge("b", "c", capacity=5.0)
+    >>> G.add_edge("b", "d", capacity=4.0)
+    >>> G.add_edge("d", "e", capacity=2.0)
+    >>> G.add_edge("c", "y", capacity=2.0)
+    >>> G.add_edge("e", "y", capacity=3.0)
+    >>> R = preflow_push(G, "x", "y")
+    >>> flow_value = nx.maximum_flow_value(G, "x", "y")
+    >>> flow_value == R.graph["flow_value"]
+    True
+    >>> # preflow_push also stores the maximum flow value
+    >>> # in the excess attribute of the sink node t
+    >>> flow_value == R.nodes["y"]["excess"]
+    True
+    >>> # For some problems, you might only want to compute a
+    >>> # maximum preflow.
+    >>> R = preflow_push(G, "x", "y", value_only=True)
+    >>> flow_value == R.graph["flow_value"]
+    True
+    >>> flow_value == R.nodes["y"]["excess"]
+    True
+
+    """
+    R = preflow_push_impl(G, s, t, capacity, residual, global_relabel_freq, value_only)
+    R.graph["algorithm"] = "preflow_push"
+    return R
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/shortestaugmentingpath.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/shortestaugmentingpath.py
new file mode 100644
index 0000000..0a91cf4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/shortestaugmentingpath.py
@@ -0,0 +1,298 @@
+"""
+Shortest augmenting path algorithm for maximum flow problems.
+"""
+
+from collections import deque
+
+import networkx as nx
+
+from .edmondskarp import edmonds_karp_core
+from .utils import CurrentEdge, build_residual_network
+
+__all__ = ["shortest_augmenting_path"]
+
+
+def shortest_augmenting_path_impl(G, s, t, capacity, residual, two_phase, cutoff):
+    """Implementation of the shortest augmenting path algorithm."""
+    if s not in G:
+        raise nx.NetworkXError(f"node {str(s)} not in graph")
+    if t not in G:
+        raise nx.NetworkXError(f"node {str(t)} not in graph")
+    if s == t:
+        raise nx.NetworkXError("source and sink are the same node")
+
+    if residual is None:
+        R = build_residual_network(G, capacity)
+    else:
+        R = residual
+
+    R_nodes = R.nodes
+    R_pred = R.pred
+    R_succ = R.succ
+
+    # Initialize/reset the residual network.
+    for u in R:
+        for e in R_succ[u].values():
+            e["flow"] = 0
+
+    # Initialize heights of the nodes.
+    heights = {t: 0}
+    q = deque([(t, 0)])
+    while q:
+        u, height = q.popleft()
+        height += 1
+        for v, attr in R_pred[u].items():
+            if v not in heights and attr["flow"] < attr["capacity"]:
+                heights[v] = height
+                q.append((v, height))
+
+    if s not in heights:
+        # t is not reachable from s in the residual network. The maximum flow
+        # must be zero.
+        R.graph["flow_value"] = 0
+        return R
+
+    n = len(G)
+    m = R.size() / 2
+
+    # Initialize heights and 'current edge' data structures of the nodes.
+    for u in R:
+        R_nodes[u]["height"] = heights[u] if u in heights else n
+        R_nodes[u]["curr_edge"] = CurrentEdge(R_succ[u])
+
+    # Initialize counts of nodes in each level.
+    counts = [0] * (2 * n - 1)
+    for u in R:
+        counts[R_nodes[u]["height"]] += 1
+
+    inf = R.graph["inf"]
+
+    def augment(path):
+        """Augment flow along a path from s to t."""
+        # Determine the path residual capacity.
+        flow = inf
+        it = iter(path)
+        u = next(it)
+        for v in it:
+            attr = R_succ[u][v]
+            flow = min(flow, attr["capacity"] - attr["flow"])
+            u = v
+        if flow * 2 > inf:
+            raise nx.NetworkXUnbounded("Infinite capacity path, flow unbounded above.")
+        # Augment flow along the path.
+        it = iter(path)
+        u = next(it)
+        for v in it:
+            R_succ[u][v]["flow"] += flow
+            R_succ[v][u]["flow"] -= flow
+            u = v
+        return flow
+
+    def relabel(u):
+        """Relabel a node to create an admissible edge."""
+        height = n - 1
+        for v, attr in R_succ[u].items():
+            if attr["flow"] < attr["capacity"]:
+                height = min(height, R_nodes[v]["height"])
+        return height + 1
+
+    if cutoff is None:
+        cutoff = float("inf")
+
+    # Phase 1: Look for shortest augmenting paths using depth-first search.
+
+    flow_value = 0
+    path = [s]
+    u = s
+    d = n if not two_phase else int(min(m**0.5, 2 * n ** (2.0 / 3)))
+    done = R_nodes[s]["height"] >= d
+    while not done:
+        height = R_nodes[u]["height"]
+        curr_edge = R_nodes[u]["curr_edge"]
+        # Depth-first search for the next node on the path to t.
+        while True:
+            v, attr = curr_edge.get()
+            if height == R_nodes[v]["height"] + 1 and attr["flow"] < attr["capacity"]:
+                # Advance to the next node following an admissible edge.
+                path.append(v)
+                u = v
+                break
+            try:
+                curr_edge.move_to_next()
+            except StopIteration:
+                counts[height] -= 1
+                if counts[height] == 0:
+                    # Gap heuristic: If relabeling causes a level to become
+                    # empty, a minimum cut has been identified. The algorithm
+                    # can now be terminated.
+                    R.graph["flow_value"] = flow_value
+                    return R
+                height = relabel(u)
+                if u == s and height >= d:
+                    if not two_phase:
+                        # t is disconnected from s in the residual network. No
+                        # more augmenting paths exist.
+                        R.graph["flow_value"] = flow_value
+                        return R
+                    else:
+                        # t is at least d steps away from s. End of phase 1.
+                        done = True
+                        break
+                counts[height] += 1
+                R_nodes[u]["height"] = height
+                if u != s:
+                    # After relabeling, the last edge on the path is no longer
+                    # admissible. Retreat one step to look for an alternative.
+                    path.pop()
+                    u = path[-1]
+                    break
+        if u == t:
+            # t is reached. Augment flow along the path and reset it for a new
+            # depth-first search.
+            flow_value += augment(path)
+            if flow_value >= cutoff:
+                R.graph["flow_value"] = flow_value
+                return R
+            path = [s]
+            u = s
+
+    # Phase 2: Look for shortest augmenting paths using breadth-first search.
+    flow_value += edmonds_karp_core(R, s, t, cutoff - flow_value)
+
+    R.graph["flow_value"] = flow_value
+    return R
+
+
+def shortest_augmenting_path(
+    G,
+    s,
+    t,
+    capacity="capacity",
+    residual=None,
+    value_only=False,
+    two_phase=False,
+    cutoff=None,
+):
+    r"""Find a maximum single-commodity flow using the shortest augmenting path
+    algorithm.
+
+    This function returns the residual network resulting after computing
+    the maximum flow. See below for details about the conventions
+    NetworkX uses for defining residual networks.
+
+    This algorithm has a running time of $O(n^2 m)$ for $n$ nodes and $m$
+    edges.
+
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Edges of the graph are expected to have an attribute called
+        'capacity'. If this attribute is not present, the edge is
+        considered to have infinite capacity.
+
+    s : node
+        Source node for the flow.
+
+    t : node
+        Sink node for the flow.
+
+    capacity : string
+        Edges of the graph G are expected to have an attribute capacity
+        that indicates how much flow the edge can support. If this
+        attribute is not present, the edge is considered to have
+        infinite capacity. Default value: 'capacity'.
+
+    residual : NetworkX graph
+        Residual network on which the algorithm is to be executed. If None, a
+        new residual network is created. Default value: None.
+
+    value_only : bool
+        If True compute only the value of the maximum flow. This parameter
+        will be ignored by this algorithm because it is not applicable.
+
+    two_phase : bool
+        If True, a two-phase variant is used. The two-phase variant improves
+        the running time on unit-capacity networks from $O(nm)$ to
+        $O(\min(n^{2/3}, m^{1/2}) m)$. Default value: False.
+
+    cutoff : integer, float
+        If specified, the algorithm will terminate when the flow value reaches
+        or exceeds the cutoff. In this case, it may be unable to immediately
+        determine a minimum cut. Default value: None.
+
+    Returns
+    -------
+    R : NetworkX DiGraph
+        Residual network after computing the maximum flow.
+
+    Raises
+    ------
+    NetworkXError
+        The algorithm does not support MultiGraph and MultiDiGraph. If
+        the input graph is an instance of one of these two classes, a
+        NetworkXError is raised.
+
+    NetworkXUnbounded
+        If the graph has a path of infinite capacity, the value of a
+        feasible flow on the graph is unbounded above and the function
+        raises a NetworkXUnbounded.
+
+    See also
+    --------
+    :meth:`maximum_flow`
+    :meth:`minimum_cut`
+    :meth:`edmonds_karp`
+    :meth:`preflow_push`
+
+    Notes
+    -----
+    The residual network :samp:`R` from an input graph :samp:`G` has the
+    same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair
+    of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a
+    self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists
+    in :samp:`G`.
+
+    For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']`
+    is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists
+    in :samp:`G` or zero otherwise. If the capacity is infinite,
+    :samp:`R[u][v]['capacity']` will have a high arbitrary finite value
+    that does not affect the solution of the problem. This value is stored in
+    :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`,
+    :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and
+    satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`.
+
+    The flow value, defined as the total flow into :samp:`t`, the sink, is
+    stored in :samp:`R.graph['flow_value']`. If :samp:`cutoff` is not
+    specified, reachability to :samp:`t` using only edges :samp:`(u, v)` such
+    that :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum
+    :samp:`s`-:samp:`t` cut.
+
+    Examples
+    --------
+    >>> from networkx.algorithms.flow import shortest_augmenting_path
+
+    The functions that implement flow algorithms and output a residual
+    network, such as this one, are not imported to the base NetworkX
+    namespace, so you have to explicitly import them from the flow package.
+
+    >>> G = nx.DiGraph()
+    >>> G.add_edge("x", "a", capacity=3.0)
+    >>> G.add_edge("x", "b", capacity=1.0)
+    >>> G.add_edge("a", "c", capacity=3.0)
+    >>> G.add_edge("b", "c", capacity=5.0)
+    >>> G.add_edge("b", "d", capacity=4.0)
+    >>> G.add_edge("d", "e", capacity=2.0)
+    >>> G.add_edge("c", "y", capacity=2.0)
+    >>> G.add_edge("e", "y", capacity=3.0)
+    >>> R = shortest_augmenting_path(G, "x", "y")
+    >>> flow_value = nx.maximum_flow_value(G, "x", "y")
+    >>> flow_value
+    3.0
+    >>> flow_value == R.graph["flow_value"]
+    True
+
+    """
+    R = shortest_augmenting_path_impl(G, s, t, capacity, residual, two_phase, cutoff)
+    R.graph["algorithm"] = "shortest_augmenting_path"
+    return R
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/gl1.gpickle.bz2 b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/gl1.gpickle.bz2
new file mode 100644
index 0000000..e6ed574
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/gl1.gpickle.bz2 differ
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/gw1.gpickle.bz2 b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/gw1.gpickle.bz2
new file mode 100644
index 0000000..abd0e8a
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/gw1.gpickle.bz2 differ
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/netgen-2.gpickle.bz2 b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/netgen-2.gpickle.bz2
new file mode 100644
index 0000000..cd3ea80
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/netgen-2.gpickle.bz2 differ
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_gomory_hu.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_gomory_hu.py
new file mode 100644
index 0000000..1649ec8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_gomory_hu.py
@@ -0,0 +1,128 @@
+from itertools import combinations
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.flow import (
+    boykov_kolmogorov,
+    dinitz,
+    edmonds_karp,
+    preflow_push,
+    shortest_augmenting_path,
+)
+
+flow_funcs = [
+    boykov_kolmogorov,
+    dinitz,
+    edmonds_karp,
+    preflow_push,
+    shortest_augmenting_path,
+]
+
+
+class TestGomoryHuTree:
+    def minimum_edge_weight(self, T, u, v):
+        path = nx.shortest_path(T, u, v, weight="weight")
+        return min((T[u][v]["weight"], (u, v)) for (u, v) in zip(path, path[1:]))
+
+    def compute_cutset(self, G, T_orig, edge):
+        T = T_orig.copy()
+        T.remove_edge(*edge)
+        U, V = list(nx.connected_components(T))
+        cutset = set()
+        for x, nbrs in ((n, G[n]) for n in U):
+            cutset.update((x, y) for y in nbrs if y in V)
+        return cutset
+
+    def test_default_flow_function_karate_club_graph(self):
+        G = nx.karate_club_graph()
+        nx.set_edge_attributes(G, 1, "capacity")
+        T = nx.gomory_hu_tree(G)
+        assert nx.is_tree(T)
+        for u, v in combinations(G, 2):
+            cut_value, edge = self.minimum_edge_weight(T, u, v)
+            assert nx.minimum_cut_value(G, u, v) == cut_value
+
+    def test_karate_club_graph(self):
+        G = nx.karate_club_graph()
+        nx.set_edge_attributes(G, 1, "capacity")
+        for flow_func in flow_funcs:
+            T = nx.gomory_hu_tree(G, flow_func=flow_func)
+            assert nx.is_tree(T)
+            for u, v in combinations(G, 2):
+                cut_value, edge = self.minimum_edge_weight(T, u, v)
+                assert nx.minimum_cut_value(G, u, v) == cut_value
+
+    def test_davis_southern_women_graph(self):
+        G = nx.davis_southern_women_graph()
+        nx.set_edge_attributes(G, 1, "capacity")
+        for flow_func in flow_funcs:
+            T = nx.gomory_hu_tree(G, flow_func=flow_func)
+            assert nx.is_tree(T)
+            for u, v in combinations(G, 2):
+                cut_value, edge = self.minimum_edge_weight(T, u, v)
+                assert nx.minimum_cut_value(G, u, v) == cut_value
+
+    def test_florentine_families_graph(self):
+        G = nx.florentine_families_graph()
+        nx.set_edge_attributes(G, 1, "capacity")
+        for flow_func in flow_funcs:
+            T = nx.gomory_hu_tree(G, flow_func=flow_func)
+            assert nx.is_tree(T)
+            for u, v in combinations(G, 2):
+                cut_value, edge = self.minimum_edge_weight(T, u, v)
+                assert nx.minimum_cut_value(G, u, v) == cut_value
+
+    @pytest.mark.slow
+    def test_les_miserables_graph_cutset(self):
+        G = nx.les_miserables_graph()
+        nx.set_edge_attributes(G, 1, "capacity")
+        for flow_func in flow_funcs:
+            T = nx.gomory_hu_tree(G, flow_func=flow_func)
+            assert nx.is_tree(T)
+            for u, v in combinations(G, 2):
+                cut_value, edge = self.minimum_edge_weight(T, u, v)
+                assert nx.minimum_cut_value(G, u, v) == cut_value
+
+    def test_karate_club_graph_cutset(self):
+        G = nx.karate_club_graph()
+        nx.set_edge_attributes(G, 1, "capacity")
+        T = nx.gomory_hu_tree(G)
+        assert nx.is_tree(T)
+        u, v = 0, 33
+        cut_value, edge = self.minimum_edge_weight(T, u, v)
+        cutset = self.compute_cutset(G, T, edge)
+        assert cut_value == len(cutset)
+
+    def test_wikipedia_example(self):
+        # Example from https://en.wikipedia.org/wiki/Gomory%E2%80%93Hu_tree
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            (
+                (0, 1, 1),
+                (0, 2, 7),
+                (1, 2, 1),
+                (1, 3, 3),
+                (1, 4, 2),
+                (2, 4, 4),
+                (3, 4, 1),
+                (3, 5, 6),
+                (4, 5, 2),
+            )
+        )
+        for flow_func in flow_funcs:
+            T = nx.gomory_hu_tree(G, capacity="weight", flow_func=flow_func)
+            assert nx.is_tree(T)
+            for u, v in combinations(G, 2):
+                cut_value, edge = self.minimum_edge_weight(T, u, v)
+                assert nx.minimum_cut_value(G, u, v, capacity="weight") == cut_value
+
+    def test_directed_raises(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            G = nx.DiGraph()
+            T = nx.gomory_hu_tree(G)
+
+    def test_empty_raises(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.empty_graph()
+            T = nx.gomory_hu_tree(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_maxflow.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_maxflow.py
new file mode 100644
index 0000000..36bc5ec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_maxflow.py
@@ -0,0 +1,551 @@
+"""Maximum flow algorithms test suite.
+"""
+import pytest
+
+import networkx as nx
+from networkx.algorithms.flow import (
+    boykov_kolmogorov,
+    build_flow_dict,
+    build_residual_network,
+    dinitz,
+    edmonds_karp,
+    preflow_push,
+    shortest_augmenting_path,
+)
+
+flow_funcs = {
+    boykov_kolmogorov,
+    dinitz,
+    edmonds_karp,
+    preflow_push,
+    shortest_augmenting_path,
+}
+max_min_funcs = {nx.maximum_flow, nx.minimum_cut}
+flow_value_funcs = {nx.maximum_flow_value, nx.minimum_cut_value}
+interface_funcs = max_min_funcs & flow_value_funcs
+all_funcs = flow_funcs & interface_funcs
+
+
+def compute_cutset(G, partition):
+    reachable, non_reachable = partition
+    cutset = set()
+    for u, nbrs in ((n, G[n]) for n in reachable):
+        cutset.update((u, v) for v in nbrs if v in non_reachable)
+    return cutset
+
+
+def validate_flows(G, s, t, flowDict, solnValue, capacity, flow_func):
+    errmsg = f"Assertion failed in function: {flow_func.__name__}"
+    assert set(G) == set(flowDict), errmsg
+    for u in G:
+        assert set(G[u]) == set(flowDict[u]), errmsg
+    excess = {u: 0 for u in flowDict}
+    for u in flowDict:
+        for v, flow in flowDict[u].items():
+            if capacity in G[u][v]:
+                assert flow <= G[u][v][capacity]
+            assert flow >= 0, errmsg
+            excess[u] -= flow
+            excess[v] += flow
+    for u, exc in excess.items():
+        if u == s:
+            assert exc == -solnValue, errmsg
+        elif u == t:
+            assert exc == solnValue, errmsg
+        else:
+            assert exc == 0, errmsg
+
+
+def validate_cuts(G, s, t, solnValue, partition, capacity, flow_func):
+    errmsg = f"Assertion failed in function: {flow_func.__name__}"
+    assert all(n in G for n in partition[0]), errmsg
+    assert all(n in G for n in partition[1]), errmsg
+    cutset = compute_cutset(G, partition)
+    assert all(G.has_edge(u, v) for (u, v) in cutset), errmsg
+    assert solnValue == sum(G[u][v][capacity] for (u, v) in cutset), errmsg
+    H = G.copy()
+    H.remove_edges_from(cutset)
+    if not G.is_directed():
+        assert not nx.is_connected(H), errmsg
+    else:
+        assert not nx.is_strongly_connected(H), errmsg
+
+
+def compare_flows_and_cuts(G, s, t, solnFlows, solnValue, capacity="capacity"):
+    for flow_func in flow_funcs:
+        errmsg = f"Assertion failed in function: {flow_func.__name__}"
+        R = flow_func(G, s, t, capacity)
+        # Test both legacy and new implementations.
+        flow_value = R.graph["flow_value"]
+        flow_dict = build_flow_dict(G, R)
+        assert flow_value == solnValue, errmsg
+        validate_flows(G, s, t, flow_dict, solnValue, capacity, flow_func)
+        # Minimum cut
+        cut_value, partition = nx.minimum_cut(
+            G, s, t, capacity=capacity, flow_func=flow_func
+        )
+        validate_cuts(G, s, t, solnValue, partition, capacity, flow_func)
+
+
+class TestMaxflowMinCutCommon:
+    def test_graph1(self):
+        # Trivial undirected graph
+        G = nx.Graph()
+        G.add_edge(1, 2, capacity=1.0)
+
+        solnFlows = {1: {2: 1.0}, 2: {1: 1.0}}
+
+        compare_flows_and_cuts(G, 1, 2, solnFlows, 1.0)
+
+    def test_graph2(self):
+        # A more complex undirected graph
+        # adapted from www.topcoder.com/tc?module=Statc&d1=tutorials&d2=maxFlow
+        G = nx.Graph()
+        G.add_edge("x", "a", capacity=3.0)
+        G.add_edge("x", "b", capacity=1.0)
+        G.add_edge("a", "c", capacity=3.0)
+        G.add_edge("b", "c", capacity=5.0)
+        G.add_edge("b", "d", capacity=4.0)
+        G.add_edge("d", "e", capacity=2.0)
+        G.add_edge("c", "y", capacity=2.0)
+        G.add_edge("e", "y", capacity=3.0)
+
+        H = {
+            "x": {"a": 3, "b": 1},
+            "a": {"c": 3, "x": 3},
+            "b": {"c": 1, "d": 2, "x": 1},
+            "c": {"a": 3, "b": 1, "y": 2},
+            "d": {"b": 2, "e": 2},
+            "e": {"d": 2, "y": 2},
+            "y": {"c": 2, "e": 2},
+        }
+
+        compare_flows_and_cuts(G, "x", "y", H, 4.0)
+
+    def test_digraph1(self):
+        # The classic directed graph example
+        G = nx.DiGraph()
+        G.add_edge("a", "b", capacity=1000.0)
+        G.add_edge("a", "c", capacity=1000.0)
+        G.add_edge("b", "c", capacity=1.0)
+        G.add_edge("b", "d", capacity=1000.0)
+        G.add_edge("c", "d", capacity=1000.0)
+
+        H = {
+            "a": {"b": 1000.0, "c": 1000.0},
+            "b": {"c": 0, "d": 1000.0},
+            "c": {"d": 1000.0},
+            "d": {},
+        }
+
+        compare_flows_and_cuts(G, "a", "d", H, 2000.0)
+
+    def test_digraph2(self):
+        # An example in which some edges end up with zero flow.
+        G = nx.DiGraph()
+        G.add_edge("s", "b", capacity=2)
+        G.add_edge("s", "c", capacity=1)
+        G.add_edge("c", "d", capacity=1)
+        G.add_edge("d", "a", capacity=1)
+        G.add_edge("b", "a", capacity=2)
+        G.add_edge("a", "t", capacity=2)
+
+        H = {
+            "s": {"b": 2, "c": 0},
+            "c": {"d": 0},
+            "d": {"a": 0},
+            "b": {"a": 2},
+            "a": {"t": 2},
+            "t": {},
+        }
+
+        compare_flows_and_cuts(G, "s", "t", H, 2)
+
+    def test_digraph3(self):
+        # A directed graph example from Cormen et al.
+        G = nx.DiGraph()
+        G.add_edge("s", "v1", capacity=16.0)
+        G.add_edge("s", "v2", capacity=13.0)
+        G.add_edge("v1", "v2", capacity=10.0)
+        G.add_edge("v2", "v1", capacity=4.0)
+        G.add_edge("v1", "v3", capacity=12.0)
+        G.add_edge("v3", "v2", capacity=9.0)
+        G.add_edge("v2", "v4", capacity=14.0)
+        G.add_edge("v4", "v3", capacity=7.0)
+        G.add_edge("v3", "t", capacity=20.0)
+        G.add_edge("v4", "t", capacity=4.0)
+
+        H = {
+            "s": {"v1": 12.0, "v2": 11.0},
+            "v2": {"v1": 0, "v4": 11.0},
+            "v1": {"v2": 0, "v3": 12.0},
+            "v3": {"v2": 0, "t": 19.0},
+            "v4": {"v3": 7.0, "t": 4.0},
+            "t": {},
+        }
+
+        compare_flows_and_cuts(G, "s", "t", H, 23.0)
+
+    def test_digraph4(self):
+        # A more complex directed graph
+        # from www.topcoder.com/tc?module=Statc&d1=tutorials&d2=maxFlow
+        G = nx.DiGraph()
+        G.add_edge("x", "a", capacity=3.0)
+        G.add_edge("x", "b", capacity=1.0)
+        G.add_edge("a", "c", capacity=3.0)
+        G.add_edge("b", "c", capacity=5.0)
+        G.add_edge("b", "d", capacity=4.0)
+        G.add_edge("d", "e", capacity=2.0)
+        G.add_edge("c", "y", capacity=2.0)
+        G.add_edge("e", "y", capacity=3.0)
+
+        H = {
+            "x": {"a": 2.0, "b": 1.0},
+            "a": {"c": 2.0},
+            "b": {"c": 0, "d": 1.0},
+            "c": {"y": 2.0},
+            "d": {"e": 1.0},
+            "e": {"y": 1.0},
+            "y": {},
+        }
+
+        compare_flows_and_cuts(G, "x", "y", H, 3.0)
+
+    def test_wikipedia_dinitz_example(self):
+        # Nice example from https://en.wikipedia.org/wiki/Dinic's_algorithm
+        G = nx.DiGraph()
+        G.add_edge("s", 1, capacity=10)
+        G.add_edge("s", 2, capacity=10)
+        G.add_edge(1, 3, capacity=4)
+        G.add_edge(1, 4, capacity=8)
+        G.add_edge(1, 2, capacity=2)
+        G.add_edge(2, 4, capacity=9)
+        G.add_edge(3, "t", capacity=10)
+        G.add_edge(4, 3, capacity=6)
+        G.add_edge(4, "t", capacity=10)
+
+        solnFlows = {
+            1: {2: 0, 3: 4, 4: 6},
+            2: {4: 9},
+            3: {"t": 9},
+            4: {3: 5, "t": 10},
+            "s": {1: 10, 2: 9},
+            "t": {},
+        }
+
+        compare_flows_and_cuts(G, "s", "t", solnFlows, 19)
+
+    def test_optional_capacity(self):
+        # Test optional capacity parameter.
+        G = nx.DiGraph()
+        G.add_edge("x", "a", spam=3.0)
+        G.add_edge("x", "b", spam=1.0)
+        G.add_edge("a", "c", spam=3.0)
+        G.add_edge("b", "c", spam=5.0)
+        G.add_edge("b", "d", spam=4.0)
+        G.add_edge("d", "e", spam=2.0)
+        G.add_edge("c", "y", spam=2.0)
+        G.add_edge("e", "y", spam=3.0)
+
+        solnFlows = {
+            "x": {"a": 2.0, "b": 1.0},
+            "a": {"c": 2.0},
+            "b": {"c": 0, "d": 1.0},
+            "c": {"y": 2.0},
+            "d": {"e": 1.0},
+            "e": {"y": 1.0},
+            "y": {},
+        }
+        solnValue = 3.0
+        s = "x"
+        t = "y"
+
+        compare_flows_and_cuts(G, s, t, solnFlows, solnValue, capacity="spam")
+
+    def test_digraph_infcap_edges(self):
+        # DiGraph with infinite capacity edges
+        G = nx.DiGraph()
+        G.add_edge("s", "a")
+        G.add_edge("s", "b", capacity=30)
+        G.add_edge("a", "c", capacity=25)
+        G.add_edge("b", "c", capacity=12)
+        G.add_edge("a", "t", capacity=60)
+        G.add_edge("c", "t")
+
+        H = {
+            "s": {"a": 85, "b": 12},
+            "a": {"c": 25, "t": 60},
+            "b": {"c": 12},
+            "c": {"t": 37},
+            "t": {},
+        }
+
+        compare_flows_and_cuts(G, "s", "t", H, 97)
+
+        # DiGraph with infinite capacity digon
+        G = nx.DiGraph()
+        G.add_edge("s", "a", capacity=85)
+        G.add_edge("s", "b", capacity=30)
+        G.add_edge("a", "c")
+        G.add_edge("c", "a")
+        G.add_edge("b", "c", capacity=12)
+        G.add_edge("a", "t", capacity=60)
+        G.add_edge("c", "t", capacity=37)
+
+        H = {
+            "s": {"a": 85, "b": 12},
+            "a": {"c": 25, "t": 60},
+            "c": {"a": 0, "t": 37},
+            "b": {"c": 12},
+            "t": {},
+        }
+
+        compare_flows_and_cuts(G, "s", "t", H, 97)
+
+    def test_digraph_infcap_path(self):
+        # Graph with infinite capacity (s, t)-path
+        G = nx.DiGraph()
+        G.add_edge("s", "a")
+        G.add_edge("s", "b", capacity=30)
+        G.add_edge("a", "c")
+        G.add_edge("b", "c", capacity=12)
+        G.add_edge("a", "t", capacity=60)
+        G.add_edge("c", "t")
+
+        for flow_func in all_funcs:
+            pytest.raises(nx.NetworkXUnbounded, flow_func, G, "s", "t")
+
+    def test_graph_infcap_edges(self):
+        # Undirected graph with infinite capacity edges
+        G = nx.Graph()
+        G.add_edge("s", "a")
+        G.add_edge("s", "b", capacity=30)
+        G.add_edge("a", "c", capacity=25)
+        G.add_edge("b", "c", capacity=12)
+        G.add_edge("a", "t", capacity=60)
+        G.add_edge("c", "t")
+
+        H = {
+            "s": {"a": 85, "b": 12},
+            "a": {"c": 25, "s": 85, "t": 60},
+            "b": {"c": 12, "s": 12},
+            "c": {"a": 25, "b": 12, "t": 37},
+            "t": {"a": 60, "c": 37},
+        }
+
+        compare_flows_and_cuts(G, "s", "t", H, 97)
+
+    def test_digraph5(self):
+        # From ticket #429 by mfrasca.
+        G = nx.DiGraph()
+        G.add_edge("s", "a", capacity=2)
+        G.add_edge("s", "b", capacity=2)
+        G.add_edge("a", "b", capacity=5)
+        G.add_edge("a", "t", capacity=1)
+        G.add_edge("b", "a", capacity=1)
+        G.add_edge("b", "t", capacity=3)
+        flowSoln = {
+            "a": {"b": 1, "t": 1},
+            "b": {"a": 0, "t": 3},
+            "s": {"a": 2, "b": 2},
+            "t": {},
+        }
+        compare_flows_and_cuts(G, "s", "t", flowSoln, 4)
+
+    def test_disconnected(self):
+        G = nx.Graph()
+        G.add_weighted_edges_from([(0, 1, 1), (1, 2, 1), (2, 3, 1)], weight="capacity")
+        G.remove_node(1)
+        assert nx.maximum_flow_value(G, 0, 3) == 0
+        flowSoln = {0: {}, 2: {3: 0}, 3: {2: 0}}
+        compare_flows_and_cuts(G, 0, 3, flowSoln, 0)
+
+    def test_source_target_not_in_graph(self):
+        G = nx.Graph()
+        G.add_weighted_edges_from([(0, 1, 1), (1, 2, 1), (2, 3, 1)], weight="capacity")
+        G.remove_node(0)
+        for flow_func in all_funcs:
+            pytest.raises(nx.NetworkXError, flow_func, G, 0, 3)
+        G.add_weighted_edges_from([(0, 1, 1), (1, 2, 1), (2, 3, 1)], weight="capacity")
+        G.remove_node(3)
+        for flow_func in all_funcs:
+            pytest.raises(nx.NetworkXError, flow_func, G, 0, 3)
+
+    def test_source_target_coincide(self):
+        G = nx.Graph()
+        G.add_node(0)
+        for flow_func in all_funcs:
+            pytest.raises(nx.NetworkXError, flow_func, G, 0, 0)
+
+    def test_multigraphs_raise(self):
+        G = nx.MultiGraph()
+        M = nx.MultiDiGraph()
+        G.add_edges_from([(0, 1), (1, 0)], capacity=True)
+        for flow_func in all_funcs:
+            pytest.raises(nx.NetworkXError, flow_func, G, 0, 0)
+
+
+class TestMaxFlowMinCutInterface:
+    def setup(self):
+        G = nx.DiGraph()
+        G.add_edge("x", "a", capacity=3.0)
+        G.add_edge("x", "b", capacity=1.0)
+        G.add_edge("a", "c", capacity=3.0)
+        G.add_edge("b", "c", capacity=5.0)
+        G.add_edge("b", "d", capacity=4.0)
+        G.add_edge("d", "e", capacity=2.0)
+        G.add_edge("c", "y", capacity=2.0)
+        G.add_edge("e", "y", capacity=3.0)
+        self.G = G
+        H = nx.DiGraph()
+        H.add_edge(0, 1, capacity=1.0)
+        H.add_edge(1, 2, capacity=1.0)
+        self.H = H
+
+    def test_flow_func_not_callable(self):
+        elements = ["this_should_be_callable", 10, {1, 2, 3}]
+        G = nx.Graph()
+        G.add_weighted_edges_from([(0, 1, 1), (1, 2, 1), (2, 3, 1)], weight="capacity")
+        for flow_func in interface_funcs:
+            for element in elements:
+                pytest.raises(nx.NetworkXError, flow_func, G, 0, 1, flow_func=element)
+                pytest.raises(nx.NetworkXError, flow_func, G, 0, 1, flow_func=element)
+
+    def test_flow_func_parameters(self):
+        G = self.G
+        fv = 3.0
+        for interface_func in interface_funcs:
+            for flow_func in flow_funcs:
+                errmsg = (
+                    f"Assertion failed in function: {flow_func.__name__} "
+                    f"in interface {interface_func.__name__}"
+                )
+                result = interface_func(G, "x", "y", flow_func=flow_func)
+                if interface_func in max_min_funcs:
+                    result = result[0]
+                assert fv == result, errmsg
+
+    def test_minimum_cut_no_cutoff(self):
+        G = self.G
+        for flow_func in flow_funcs:
+            pytest.raises(
+                nx.NetworkXError,
+                nx.minimum_cut,
+                G,
+                "x",
+                "y",
+                flow_func=flow_func,
+                cutoff=1.0,
+            )
+            pytest.raises(
+                nx.NetworkXError,
+                nx.minimum_cut_value,
+                G,
+                "x",
+                "y",
+                flow_func=flow_func,
+                cutoff=1.0,
+            )
+
+    def test_kwargs(self):
+        G = self.H
+        fv = 1.0
+        to_test = (
+            (shortest_augmenting_path, dict(two_phase=True)),
+            (preflow_push, dict(global_relabel_freq=5)),
+        )
+        for interface_func in interface_funcs:
+            for flow_func, kwargs in to_test:
+                errmsg = (
+                    f"Assertion failed in function: {flow_func.__name__} "
+                    f"in interface {interface_func.__name__}"
+                )
+                result = interface_func(G, 0, 2, flow_func=flow_func, **kwargs)
+                if interface_func in max_min_funcs:
+                    result = result[0]
+                assert fv == result, errmsg
+
+    def test_kwargs_default_flow_func(self):
+        G = self.H
+        for interface_func in interface_funcs:
+            pytest.raises(
+                nx.NetworkXError, interface_func, G, 0, 1, global_relabel_freq=2
+            )
+
+    def test_reusing_residual(self):
+        G = self.G
+        fv = 3.0
+        s, t = "x", "y"
+        R = build_residual_network(G, "capacity")
+        for interface_func in interface_funcs:
+            for flow_func in flow_funcs:
+                errmsg = (
+                    f"Assertion failed in function: {flow_func.__name__} "
+                    f"in interface {interface_func.__name__}"
+                )
+                for i in range(3):
+                    result = interface_func(
+                        G, "x", "y", flow_func=flow_func, residual=R
+                    )
+                    if interface_func in max_min_funcs:
+                        result = result[0]
+                    assert fv == result, errmsg
+
+
+# Tests specific to one algorithm
+def test_preflow_push_global_relabel_freq():
+    G = nx.DiGraph()
+    G.add_edge(1, 2, capacity=1)
+    R = preflow_push(G, 1, 2, global_relabel_freq=None)
+    assert R.graph["flow_value"] == 1
+    pytest.raises(nx.NetworkXError, preflow_push, G, 1, 2, global_relabel_freq=-1)
+
+
+def test_preflow_push_makes_enough_space():
+    # From ticket #1542
+    G = nx.DiGraph()
+    nx.add_path(G, [0, 1, 3], capacity=1)
+    nx.add_path(G, [1, 2, 3], capacity=1)
+    R = preflow_push(G, 0, 3, value_only=False)
+    assert R.graph["flow_value"] == 1
+
+
+def test_shortest_augmenting_path_two_phase():
+    k = 5
+    p = 1000
+    G = nx.DiGraph()
+    for i in range(k):
+        G.add_edge("s", (i, 0), capacity=1)
+        nx.add_path(G, ((i, j) for j in range(p)), capacity=1)
+        G.add_edge((i, p - 1), "t", capacity=1)
+    R = shortest_augmenting_path(G, "s", "t", two_phase=True)
+    assert R.graph["flow_value"] == k
+    R = shortest_augmenting_path(G, "s", "t", two_phase=False)
+    assert R.graph["flow_value"] == k
+
+
+class TestCutoff:
+    def test_cutoff(self):
+        k = 5
+        p = 1000
+        G = nx.DiGraph()
+        for i in range(k):
+            G.add_edge("s", (i, 0), capacity=2)
+            nx.add_path(G, ((i, j) for j in range(p)), capacity=2)
+            G.add_edge((i, p - 1), "t", capacity=2)
+        R = shortest_augmenting_path(G, "s", "t", two_phase=True, cutoff=k)
+        assert k <= R.graph["flow_value"] <= (2 * k)
+        R = shortest_augmenting_path(G, "s", "t", two_phase=False, cutoff=k)
+        assert k <= R.graph["flow_value"] <= (2 * k)
+        R = edmonds_karp(G, "s", "t", cutoff=k)
+        assert k <= R.graph["flow_value"] <= (2 * k)
+
+    def test_complete_graph_cutoff(self):
+        G = nx.complete_graph(5)
+        nx.set_edge_attributes(G, {(u, v): 1 for u, v in G.edges()}, "capacity")
+        for flow_func in [shortest_augmenting_path, edmonds_karp]:
+            for cutoff in [3, 2, 1]:
+                result = nx.maximum_flow_value(
+                    G, 0, 4, flow_func=flow_func, cutoff=cutoff
+                )
+                assert cutoff == result, f"cutoff error in {flow_func.__name__}"
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_maxflow_large_graph.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_maxflow_large_graph.py
new file mode 100644
index 0000000..c62c0a9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_maxflow_large_graph.py
@@ -0,0 +1,149 @@
+"""Maximum flow algorithms test suite on large graphs.
+"""
+
+import os
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.flow import (
+    boykov_kolmogorov,
+    build_flow_dict,
+    build_residual_network,
+    dinitz,
+    edmonds_karp,
+    preflow_push,
+    shortest_augmenting_path,
+)
+
+flow_funcs = [
+    boykov_kolmogorov,
+    dinitz,
+    edmonds_karp,
+    preflow_push,
+    shortest_augmenting_path,
+]
+
+
+def gen_pyramid(N):
+    # This graph admits a flow of value 1 for which every arc is at
+    # capacity (except the arcs incident to the sink which have
+    # infinite capacity).
+    G = nx.DiGraph()
+
+    for i in range(N - 1):
+        cap = 1.0 / (i + 2)
+        for j in range(i + 1):
+            G.add_edge((i, j), (i + 1, j), capacity=cap)
+            cap = 1.0 / (i + 1) - cap
+            G.add_edge((i, j), (i + 1, j + 1), capacity=cap)
+            cap = 1.0 / (i + 2) - cap
+
+    for j in range(N):
+        G.add_edge((N - 1, j), "t")
+
+    return G
+
+
+def read_graph(name):
+    dirname = os.path.dirname(__file__)
+    path = os.path.join(dirname, name + ".gpickle.bz2")
+    return nx.read_gpickle(path)
+
+
+def validate_flows(G, s, t, soln_value, R, flow_func):
+    flow_value = R.graph["flow_value"]
+    flow_dict = build_flow_dict(G, R)
+    errmsg = f"Assertion failed in function: {flow_func.__name__}"
+    assert soln_value == flow_value, errmsg
+    assert set(G) == set(flow_dict), errmsg
+    for u in G:
+        assert set(G[u]) == set(flow_dict[u]), errmsg
+    excess = {u: 0 for u in flow_dict}
+    for u in flow_dict:
+        for v, flow in flow_dict[u].items():
+            assert flow <= G[u][v].get("capacity", float("inf")), errmsg
+            assert flow >= 0, errmsg
+            excess[u] -= flow
+            excess[v] += flow
+    for u, exc in excess.items():
+        if u == s:
+            assert exc == -soln_value, errmsg
+        elif u == t:
+            assert exc == soln_value, errmsg
+        else:
+            assert exc == 0, errmsg
+
+
+class TestMaxflowLargeGraph:
+    def test_complete_graph(self):
+        N = 50
+        G = nx.complete_graph(N)
+        nx.set_edge_attributes(G, 5, "capacity")
+        R = build_residual_network(G, "capacity")
+        kwargs = dict(residual=R)
+
+        for flow_func in flow_funcs:
+            kwargs["flow_func"] = flow_func
+            errmsg = f"Assertion failed in function: {flow_func.__name__}"
+            flow_value = nx.maximum_flow_value(G, 1, 2, **kwargs)
+            assert flow_value == 5 * (N - 1), errmsg
+
+    def test_pyramid(self):
+        N = 10
+        # N = 100 # this gives a graph with 5051 nodes
+        G = gen_pyramid(N)
+        R = build_residual_network(G, "capacity")
+        kwargs = dict(residual=R)
+
+        for flow_func in flow_funcs:
+            kwargs["flow_func"] = flow_func
+            errmsg = f"Assertion failed in function: {flow_func.__name__}"
+            flow_value = nx.maximum_flow_value(G, (0, 0), "t", **kwargs)
+            assert flow_value == pytest.approx(1.0, abs=1e-7)
+
+    def test_gl1(self):
+        G = read_graph("gl1")
+        s = 1
+        t = len(G)
+        R = build_residual_network(G, "capacity")
+        kwargs = dict(residual=R)
+
+        # do one flow_func to save time
+        flow_func = flow_funcs[0]
+        validate_flows(G, s, t, 156545, flow_func(G, s, t, **kwargs), flow_func)
+
+    #        for flow_func in flow_funcs:
+    #            validate_flows(G, s, t, 156545, flow_func(G, s, t, **kwargs),
+    #                           flow_func)
+
+    @pytest.mark.slow
+    def test_gw1(self):
+        G = read_graph("gw1")
+        s = 1
+        t = len(G)
+        R = build_residual_network(G, "capacity")
+        kwargs = dict(residual=R)
+
+        for flow_func in flow_funcs:
+            validate_flows(G, s, t, 1202018, flow_func(G, s, t, **kwargs), flow_func)
+
+    def test_wlm3(self):
+        G = read_graph("wlm3")
+        s = 1
+        t = len(G)
+        R = build_residual_network(G, "capacity")
+        kwargs = dict(residual=R)
+
+        # do one flow_func to save time
+        flow_func = flow_funcs[0]
+        validate_flows(G, s, t, 11875108, flow_func(G, s, t, **kwargs), flow_func)
+
+    #        for flow_func in flow_funcs:
+    #            validate_flows(G, s, t, 11875108, flow_func(G, s, t, **kwargs),
+    #                           flow_func)
+
+    def test_preflow_push_global_relabel(self):
+        G = read_graph("gw1")
+        R = preflow_push(G, 1, len(G), global_relabel_freq=50)
+        assert R.graph["flow_value"] == 1202018
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_mincost.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_mincost.py
new file mode 100644
index 0000000..5a8c2d7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_mincost.py
@@ -0,0 +1,469 @@
+import os
+
+import pytest
+
+import networkx as nx
+
+
+class TestMinCostFlow:
+    def test_simple_digraph(self):
+        G = nx.DiGraph()
+        G.add_node("a", demand=-5)
+        G.add_node("d", demand=5)
+        G.add_edge("a", "b", weight=3, capacity=4)
+        G.add_edge("a", "c", weight=6, capacity=10)
+        G.add_edge("b", "d", weight=1, capacity=9)
+        G.add_edge("c", "d", weight=2, capacity=5)
+        flowCost, H = nx.network_simplex(G)
+        soln = {"a": {"b": 4, "c": 1}, "b": {"d": 4}, "c": {"d": 1}, "d": {}}
+        assert flowCost == 24
+        assert nx.min_cost_flow_cost(G) == 24
+        assert H == soln
+        assert nx.min_cost_flow(G) == soln
+        assert nx.cost_of_flow(G, H) == 24
+
+        flowCost, H = nx.capacity_scaling(G)
+        assert flowCost == 24
+        assert nx.cost_of_flow(G, H) == 24
+        assert H == soln
+
+    def test_negcycle_infcap(self):
+        G = nx.DiGraph()
+        G.add_node("s", demand=-5)
+        G.add_node("t", demand=5)
+        G.add_edge("s", "a", weight=1, capacity=3)
+        G.add_edge("a", "b", weight=3)
+        G.add_edge("c", "a", weight=-6)
+        G.add_edge("b", "d", weight=1)
+        G.add_edge("d", "c", weight=-2)
+        G.add_edge("d", "t", weight=1, capacity=3)
+        pytest.raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
+        pytest.raises(nx.NetworkXUnbounded, nx.capacity_scaling, G)
+
+    def test_sum_demands_not_zero(self):
+        G = nx.DiGraph()
+        G.add_node("s", demand=-5)
+        G.add_node("t", demand=4)
+        G.add_edge("s", "a", weight=1, capacity=3)
+        G.add_edge("a", "b", weight=3)
+        G.add_edge("a", "c", weight=-6)
+        G.add_edge("b", "d", weight=1)
+        G.add_edge("c", "d", weight=-2)
+        G.add_edge("d", "t", weight=1, capacity=3)
+        pytest.raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
+        pytest.raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)
+
+    def test_no_flow_satisfying_demands(self):
+        G = nx.DiGraph()
+        G.add_node("s", demand=-5)
+        G.add_node("t", demand=5)
+        G.add_edge("s", "a", weight=1, capacity=3)
+        G.add_edge("a", "b", weight=3)
+        G.add_edge("a", "c", weight=-6)
+        G.add_edge("b", "d", weight=1)
+        G.add_edge("c", "d", weight=-2)
+        G.add_edge("d", "t", weight=1, capacity=3)
+        pytest.raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
+        pytest.raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)
+
+    def test_transshipment(self):
+        G = nx.DiGraph()
+        G.add_node("a", demand=1)
+        G.add_node("b", demand=-2)
+        G.add_node("c", demand=-2)
+        G.add_node("d", demand=3)
+        G.add_node("e", demand=-4)
+        G.add_node("f", demand=-4)
+        G.add_node("g", demand=3)
+        G.add_node("h", demand=2)
+        G.add_node("r", demand=3)
+        G.add_edge("a", "c", weight=3)
+        G.add_edge("r", "a", weight=2)
+        G.add_edge("b", "a", weight=9)
+        G.add_edge("r", "c", weight=0)
+        G.add_edge("b", "r", weight=-6)
+        G.add_edge("c", "d", weight=5)
+        G.add_edge("e", "r", weight=4)
+        G.add_edge("e", "f", weight=3)
+        G.add_edge("h", "b", weight=4)
+        G.add_edge("f", "d", weight=7)
+        G.add_edge("f", "h", weight=12)
+        G.add_edge("g", "d", weight=12)
+        G.add_edge("f", "g", weight=-1)
+        G.add_edge("h", "g", weight=-10)
+        flowCost, H = nx.network_simplex(G)
+        soln = {
+            "a": {"c": 0},
+            "b": {"a": 0, "r": 2},
+            "c": {"d": 3},
+            "d": {},
+            "e": {"r": 3, "f": 1},
+            "f": {"d": 0, "g": 3, "h": 2},
+            "g": {"d": 0},
+            "h": {"b": 0, "g": 0},
+            "r": {"a": 1, "c": 1},
+        }
+        assert flowCost == 41
+        assert nx.min_cost_flow_cost(G) == 41
+        assert H == soln
+        assert nx.min_cost_flow(G) == soln
+        assert nx.cost_of_flow(G, H) == 41
+
+        flowCost, H = nx.capacity_scaling(G)
+        assert flowCost == 41
+        assert nx.cost_of_flow(G, H) == 41
+        assert H == soln
+
+    def test_max_flow_min_cost(self):
+        G = nx.DiGraph()
+        G.add_edge("s", "a", bandwidth=6)
+        G.add_edge("s", "c", bandwidth=10, cost=10)
+        G.add_edge("a", "b", cost=6)
+        G.add_edge("b", "d", bandwidth=8, cost=7)
+        G.add_edge("c", "d", cost=10)
+        G.add_edge("d", "t", bandwidth=5, cost=5)
+        soln = {
+            "s": {"a": 5, "c": 0},
+            "a": {"b": 5},
+            "b": {"d": 5},
+            "c": {"d": 0},
+            "d": {"t": 5},
+            "t": {},
+        }
+        flow = nx.max_flow_min_cost(G, "s", "t", capacity="bandwidth", weight="cost")
+        assert flow == soln
+        assert nx.cost_of_flow(G, flow, weight="cost") == 90
+
+        G.add_edge("t", "s", cost=-100)
+        flowCost, flow = nx.capacity_scaling(G, capacity="bandwidth", weight="cost")
+        G.remove_edge("t", "s")
+        assert flowCost == -410
+        assert flow["t"]["s"] == 5
+        del flow["t"]["s"]
+        assert flow == soln
+        assert nx.cost_of_flow(G, flow, weight="cost") == 90
+
+    def test_digraph1(self):
+        # From Bradley, S. P., Hax, A. C. and Magnanti, T. L. Applied
+        # Mathematical Programming. Addison-Wesley, 1977.
+        G = nx.DiGraph()
+        G.add_node(1, demand=-20)
+        G.add_node(4, demand=5)
+        G.add_node(5, demand=15)
+        G.add_edges_from(
+            [
+                (1, 2, {"capacity": 15, "weight": 4}),
+                (1, 3, {"capacity": 8, "weight": 4}),
+                (2, 3, {"weight": 2}),
+                (2, 4, {"capacity": 4, "weight": 2}),
+                (2, 5, {"capacity": 10, "weight": 6}),
+                (3, 4, {"capacity": 15, "weight": 1}),
+                (3, 5, {"capacity": 5, "weight": 3}),
+                (4, 5, {"weight": 2}),
+                (5, 3, {"capacity": 4, "weight": 1}),
+            ]
+        )
+        flowCost, H = nx.network_simplex(G)
+        soln = {
+            1: {2: 12, 3: 8},
+            2: {3: 8, 4: 4, 5: 0},
+            3: {4: 11, 5: 5},
+            4: {5: 10},
+            5: {3: 0},
+        }
+        assert flowCost == 150
+        assert nx.min_cost_flow_cost(G) == 150
+        assert H == soln
+        assert nx.min_cost_flow(G) == soln
+        assert nx.cost_of_flow(G, H) == 150
+
+        flowCost, H = nx.capacity_scaling(G)
+        assert flowCost == 150
+        assert H == soln
+        assert nx.cost_of_flow(G, H) == 150
+
+    def test_digraph2(self):
+        # Example from ticket #430 from mfrasca. Original source:
+        # http://www.cs.princeton.edu/courses/archive/spr03/cs226/lectures/mincost.4up.pdf, slide 11.
+        G = nx.DiGraph()
+        G.add_edge("s", 1, capacity=12)
+        G.add_edge("s", 2, capacity=6)
+        G.add_edge("s", 3, capacity=14)
+        G.add_edge(1, 2, capacity=11, weight=4)
+        G.add_edge(2, 3, capacity=9, weight=6)
+        G.add_edge(1, 4, capacity=5, weight=5)
+        G.add_edge(1, 5, capacity=2, weight=12)
+        G.add_edge(2, 5, capacity=4, weight=4)
+        G.add_edge(2, 6, capacity=2, weight=6)
+        G.add_edge(3, 6, capacity=31, weight=3)
+        G.add_edge(4, 5, capacity=18, weight=4)
+        G.add_edge(5, 6, capacity=9, weight=5)
+        G.add_edge(4, "t", capacity=3)
+        G.add_edge(5, "t", capacity=7)
+        G.add_edge(6, "t", capacity=22)
+        flow = nx.max_flow_min_cost(G, "s", "t")
+        soln = {
+            1: {2: 6, 4: 5, 5: 1},
+            2: {3: 6, 5: 4, 6: 2},
+            3: {6: 20},
+            4: {5: 2, "t": 3},
+            5: {6: 0, "t": 7},
+            6: {"t": 22},
+            "s": {1: 12, 2: 6, 3: 14},
+            "t": {},
+        }
+        assert flow == soln
+
+        G.add_edge("t", "s", weight=-100)
+        flowCost, flow = nx.capacity_scaling(G)
+        G.remove_edge("t", "s")
+        assert flow["t"]["s"] == 32
+        assert flowCost == -3007
+        del flow["t"]["s"]
+        assert flow == soln
+        assert nx.cost_of_flow(G, flow) == 193
+
+    def test_digraph3(self):
+        """Combinatorial Optimization: Algorithms and Complexity,
+        Papadimitriou Steiglitz at page 140 has an example, 7.1, but that
+        admits multiple solutions, so I alter it a bit. From ticket #430
+        by mfrasca."""
+
+        G = nx.DiGraph()
+        G.add_edge("s", "a")
+        G["s"]["a"].update({0: 2, 1: 4})
+        G.add_edge("s", "b")
+        G["s"]["b"].update({0: 2, 1: 1})
+        G.add_edge("a", "b")
+        G["a"]["b"].update({0: 5, 1: 2})
+        G.add_edge("a", "t")
+        G["a"]["t"].update({0: 1, 1: 5})
+        G.add_edge("b", "a")
+        G["b"]["a"].update({0: 1, 1: 3})
+        G.add_edge("b", "t")
+        G["b"]["t"].update({0: 3, 1: 2})
+
+        "PS.ex.7.1: testing main function"
+        sol = nx.max_flow_min_cost(G, "s", "t", capacity=0, weight=1)
+        flow = sum(v for v in sol["s"].values())
+        assert 4 == flow
+        assert 23 == nx.cost_of_flow(G, sol, weight=1)
+        assert sol["s"] == {"a": 2, "b": 2}
+        assert sol["a"] == {"b": 1, "t": 1}
+        assert sol["b"] == {"a": 0, "t": 3}
+        assert sol["t"] == {}
+
+        G.add_edge("t", "s")
+        G["t"]["s"].update({1: -100})
+        flowCost, sol = nx.capacity_scaling(G, capacity=0, weight=1)
+        G.remove_edge("t", "s")
+        flow = sum(v for v in sol["s"].values())
+        assert 4 == flow
+        assert sol["t"]["s"] == 4
+        assert flowCost == -377
+        del sol["t"]["s"]
+        assert sol["s"] == {"a": 2, "b": 2}
+        assert sol["a"] == {"b": 1, "t": 1}
+        assert sol["b"] == {"a": 0, "t": 3}
+        assert sol["t"] == {}
+        assert nx.cost_of_flow(G, sol, weight=1) == 23
+
+    def test_zero_capacity_edges(self):
+        """Address issue raised in ticket #617 by arv."""
+        G = nx.DiGraph()
+        G.add_edges_from(
+            [
+                (1, 2, {"capacity": 1, "weight": 1}),
+                (1, 5, {"capacity": 1, "weight": 1}),
+                (2, 3, {"capacity": 0, "weight": 1}),
+                (2, 5, {"capacity": 1, "weight": 1}),
+                (5, 3, {"capacity": 2, "weight": 1}),
+                (5, 4, {"capacity": 0, "weight": 1}),
+                (3, 4, {"capacity": 2, "weight": 1}),
+            ]
+        )
+        G.nodes[1]["demand"] = -1
+        G.nodes[2]["demand"] = -1
+        G.nodes[4]["demand"] = 2
+
+        flowCost, H = nx.network_simplex(G)
+        soln = {1: {2: 0, 5: 1}, 2: {3: 0, 5: 1}, 3: {4: 2}, 4: {}, 5: {3: 2, 4: 0}}
+        assert flowCost == 6
+        assert nx.min_cost_flow_cost(G) == 6
+        assert H == soln
+        assert nx.min_cost_flow(G) == soln
+        assert nx.cost_of_flow(G, H) == 6
+
+        flowCost, H = nx.capacity_scaling(G)
+        assert flowCost == 6
+        assert H == soln
+        assert nx.cost_of_flow(G, H) == 6
+
+    def test_digon(self):
+        """Check if digons are handled properly. Taken from ticket
+        #618 by arv."""
+        nodes = [(1, {}), (2, {"demand": -4}), (3, {"demand": 4})]
+        edges = [
+            (1, 2, {"capacity": 3, "weight": 600000}),
+            (2, 1, {"capacity": 2, "weight": 0}),
+            (2, 3, {"capacity": 5, "weight": 714285}),
+            (3, 2, {"capacity": 2, "weight": 0}),
+        ]
+        G = nx.DiGraph(edges)
+        G.add_nodes_from(nodes)
+        flowCost, H = nx.network_simplex(G)
+        soln = {1: {2: 0}, 2: {1: 0, 3: 4}, 3: {2: 0}}
+        assert flowCost == 2857140
+        assert nx.min_cost_flow_cost(G) == 2857140
+        assert H == soln
+        assert nx.min_cost_flow(G) == soln
+        assert nx.cost_of_flow(G, H) == 2857140
+
+        flowCost, H = nx.capacity_scaling(G)
+        assert flowCost == 2857140
+        assert H == soln
+        assert nx.cost_of_flow(G, H) == 2857140
+
+    def test_deadend(self):
+        """Check if one-node cycles are handled properly. Taken from ticket
+        #2906 from @sshraven."""
+        G = nx.DiGraph()
+
+        G.add_nodes_from(range(5), demand=0)
+        G.nodes[4]["demand"] = -13
+        G.nodes[3]["demand"] = 13
+
+        G.add_edges_from([(0, 2), (0, 3), (2, 1)], capacity=20, weight=0.1)
+        pytest.raises(nx.NetworkXUnfeasible, nx.min_cost_flow, G)
+
+    def test_infinite_capacity_neg_digon(self):
+        """An infinite capacity negative cost digon results in an unbounded
+        instance."""
+        nodes = [(1, {}), (2, {"demand": -4}), (3, {"demand": 4})]
+        edges = [
+            (1, 2, {"weight": -600}),
+            (2, 1, {"weight": 0}),
+            (2, 3, {"capacity": 5, "weight": 714285}),
+            (3, 2, {"capacity": 2, "weight": 0}),
+        ]
+        G = nx.DiGraph(edges)
+        G.add_nodes_from(nodes)
+        pytest.raises(nx.NetworkXUnbounded, nx.network_simplex, G)
+        pytest.raises(nx.NetworkXUnbounded, nx.capacity_scaling, G)
+
+    def test_finite_capacity_neg_digon(self):
+        """The digon should receive the maximum amount of flow it can handle.
+        Taken from ticket #749 by @chuongdo."""
+        G = nx.DiGraph()
+        G.add_edge("a", "b", capacity=1, weight=-1)
+        G.add_edge("b", "a", capacity=1, weight=-1)
+        min_cost = -2
+        assert nx.min_cost_flow_cost(G) == min_cost
+
+        flowCost, H = nx.capacity_scaling(G)
+        assert flowCost == -2
+        assert H == {"a": {"b": 1}, "b": {"a": 1}}
+        assert nx.cost_of_flow(G, H) == -2
+
+    def test_multidigraph(self):
+        """Multidigraphs are acceptable."""
+        G = nx.MultiDiGraph()
+        G.add_weighted_edges_from([(1, 2, 1), (2, 3, 2)], weight="capacity")
+        flowCost, H = nx.network_simplex(G)
+        assert flowCost == 0
+        assert H == {1: {2: {0: 0}}, 2: {3: {0: 0}}, 3: {}}
+
+        flowCost, H = nx.capacity_scaling(G)
+        assert flowCost == 0
+        assert H == {1: {2: {0: 0}}, 2: {3: {0: 0}}, 3: {}}
+
+    def test_negative_selfloops(self):
+        """Negative selfloops should cause an exception if uncapacitated and
+        always be saturated otherwise.
+        """
+        G = nx.DiGraph()
+        G.add_edge(1, 1, weight=-1)
+        pytest.raises(nx.NetworkXUnbounded, nx.network_simplex, G)
+        pytest.raises(nx.NetworkXUnbounded, nx.capacity_scaling, G)
+        G[1][1]["capacity"] = 2
+        flowCost, H = nx.network_simplex(G)
+        assert flowCost == -2
+        assert H == {1: {1: 2}}
+        flowCost, H = nx.capacity_scaling(G)
+        assert flowCost == -2
+        assert H == {1: {1: 2}}
+
+        G = nx.MultiDiGraph()
+        G.add_edge(1, 1, "x", weight=-1)
+        G.add_edge(1, 1, "y", weight=1)
+        pytest.raises(nx.NetworkXUnbounded, nx.network_simplex, G)
+        pytest.raises(nx.NetworkXUnbounded, nx.capacity_scaling, G)
+        G[1][1]["x"]["capacity"] = 2
+        flowCost, H = nx.network_simplex(G)
+        assert flowCost == -2
+        assert H == {1: {1: {"x": 2, "y": 0}}}
+        flowCost, H = nx.capacity_scaling(G)
+        assert flowCost == -2
+        assert H == {1: {1: {"x": 2, "y": 0}}}
+
+    def test_bone_shaped(self):
+        # From #1283
+        G = nx.DiGraph()
+        G.add_node(0, demand=-4)
+        G.add_node(1, demand=2)
+        G.add_node(2, demand=2)
+        G.add_node(3, demand=4)
+        G.add_node(4, demand=-2)
+        G.add_node(5, demand=-2)
+        G.add_edge(0, 1, capacity=4)
+        G.add_edge(0, 2, capacity=4)
+        G.add_edge(4, 3, capacity=4)
+        G.add_edge(5, 3, capacity=4)
+        G.add_edge(0, 3, capacity=0)
+        flowCost, H = nx.network_simplex(G)
+        assert flowCost == 0
+        assert H == {0: {1: 2, 2: 2, 3: 0}, 1: {}, 2: {}, 3: {}, 4: {3: 2}, 5: {3: 2}}
+        flowCost, H = nx.capacity_scaling(G)
+        assert flowCost == 0
+        assert H == {0: {1: 2, 2: 2, 3: 0}, 1: {}, 2: {}, 3: {}, 4: {3: 2}, 5: {3: 2}}
+
+    def test_exceptions(self):
+        G = nx.Graph()
+        pytest.raises(nx.NetworkXNotImplemented, nx.network_simplex, G)
+        pytest.raises(nx.NetworkXNotImplemented, nx.capacity_scaling, G)
+        G = nx.MultiGraph()
+        pytest.raises(nx.NetworkXNotImplemented, nx.network_simplex, G)
+        pytest.raises(nx.NetworkXNotImplemented, nx.capacity_scaling, G)
+        G = nx.DiGraph()
+        pytest.raises(nx.NetworkXError, nx.network_simplex, G)
+        pytest.raises(nx.NetworkXError, nx.capacity_scaling, G)
+        G.add_node(0, demand=float("inf"))
+        pytest.raises(nx.NetworkXError, nx.network_simplex, G)
+        pytest.raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)
+        G.nodes[0]["demand"] = 0
+        G.add_node(1, demand=0)
+        G.add_edge(0, 1, weight=-float("inf"))
+        pytest.raises(nx.NetworkXError, nx.network_simplex, G)
+        pytest.raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)
+        G[0][1]["weight"] = 0
+        G.add_edge(0, 0, weight=float("inf"))
+        pytest.raises(nx.NetworkXError, nx.network_simplex, G)
+        # pytest.raises(nx.NetworkXError, nx.capacity_scaling, G)
+        G[0][0]["weight"] = 0
+        G[0][1]["capacity"] = -1
+        pytest.raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
+        # pytest.raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)
+        G[0][1]["capacity"] = 0
+        G[0][0]["capacity"] = -1
+        pytest.raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
+        # pytest.raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)
+
+    def test_large(self):
+        fname = os.path.join(os.path.dirname(__file__), "netgen-2.gpickle.bz2")
+        G = nx.read_gpickle(fname)
+        flowCost, flowDict = nx.network_simplex(G)
+        assert 6749969302 == flowCost
+        assert 6749969302 == nx.cost_of_flow(G, flowDict)
+        flowCost, flowDict = nx.capacity_scaling(G)
+        assert 6749969302 == flowCost
+        assert 6749969302 == nx.cost_of_flow(G, flowDict)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_networksimplex.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_networksimplex.py
new file mode 100644
index 0000000..0c25db9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/test_networksimplex.py
@@ -0,0 +1,379 @@
+import os
+
+import pytest
+
+import networkx as nx
+
+
+@pytest.fixture
+def simple_flow_graph():
+    G = nx.DiGraph()
+    G.add_node("a", demand=0)
+    G.add_node("b", demand=-5)
+    G.add_node("c", demand=50000000)
+    G.add_node("d", demand=-49999995)
+    G.add_edge("a", "b", weight=3, capacity=4)
+    G.add_edge("a", "c", weight=6, capacity=10)
+    G.add_edge("b", "d", weight=1, capacity=9)
+    G.add_edge("c", "d", weight=2, capacity=5)
+    return G
+
+
+@pytest.fixture
+def simple_no_flow_graph():
+    G = nx.DiGraph()
+    G.add_node("s", demand=-5)
+    G.add_node("t", demand=5)
+    G.add_edge("s", "a", weight=1, capacity=3)
+    G.add_edge("a", "b", weight=3)
+    G.add_edge("a", "c", weight=-6)
+    G.add_edge("b", "d", weight=1)
+    G.add_edge("c", "d", weight=-2)
+    G.add_edge("d", "t", weight=1, capacity=3)
+    return G
+
+
+def get_flowcost_from_flowdict(G, flowDict):
+    """Returns flow cost calculated from flow dictionary"""
+    flowCost = 0
+    for u in flowDict.keys():
+        for v in flowDict[u].keys():
+            flowCost += flowDict[u][v] * G[u][v]["weight"]
+    return flowCost
+
+
+def test_infinite_demand_raise(simple_flow_graph):
+    G = simple_flow_graph
+    inf = float("inf")
+    nx.set_node_attributes(G, {"a": {"demand": inf}})
+    pytest.raises(nx.NetworkXError, nx.network_simplex, G)
+
+
+def test_neg_infinite_demand_raise(simple_flow_graph):
+    G = simple_flow_graph
+    inf = float("inf")
+    nx.set_node_attributes(G, {"a": {"demand": -inf}})
+    pytest.raises(nx.NetworkXError, nx.network_simplex, G)
+
+
+def test_infinite_weight_raise(simple_flow_graph):
+    G = simple_flow_graph
+    inf = float("inf")
+    nx.set_edge_attributes(
+        G, {("a", "b"): {"weight": inf}, ("b", "d"): {"weight": inf}}
+    )
+    pytest.raises(nx.NetworkXError, nx.network_simplex, G)
+
+
+def test_nonzero_net_demand_raise(simple_flow_graph):
+    G = simple_flow_graph
+    nx.set_node_attributes(G, {"b": {"demand": -4}})
+    pytest.raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
+
+
+def test_negative_capacity_raise(simple_flow_graph):
+    G = simple_flow_graph
+    nx.set_edge_attributes(G, {("a", "b"): {"weight": 1}, ("b", "d"): {"capacity": -9}})
+    pytest.raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
+
+
+def test_no_flow_satisfying_demands(simple_no_flow_graph):
+    G = simple_no_flow_graph
+    pytest.raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
+
+
+def test_sum_demands_not_zero(simple_no_flow_graph):
+    G = simple_no_flow_graph
+    nx.set_node_attributes(G, {"t": {"demand": 4}})
+    pytest.raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
+
+
+def test_google_or_tools_example():
+    """
+    https://developers.google.com/optimization/flow/mincostflow
+    """
+    G = nx.DiGraph()
+    start_nodes = [0, 0, 1, 1, 1, 2, 2, 3, 4]
+    end_nodes = [1, 2, 2, 3, 4, 3, 4, 4, 2]
+    capacities = [15, 8, 20, 4, 10, 15, 4, 20, 5]
+    unit_costs = [4, 4, 2, 2, 6, 1, 3, 2, 3]
+    supplies = [20, 0, 0, -5, -15]
+    answer = 150
+
+    for i in range(len(supplies)):
+        G.add_node(i, demand=(-1) * supplies[i])  # supplies are negative of demand
+
+    for i in range(len(start_nodes)):
+        G.add_edge(
+            start_nodes[i], end_nodes[i], weight=unit_costs[i], capacity=capacities[i]
+        )
+
+    flowCost, flowDict = nx.network_simplex(G)
+    assert flowCost == answer
+    assert flowCost == get_flowcost_from_flowdict(G, flowDict)
+
+
+def test_google_or_tools_example2():
+    """
+    https://developers.google.com/optimization/flow/mincostflow
+    """
+    G = nx.DiGraph()
+    start_nodes = [0, 0, 1, 1, 1, 2, 2, 3, 4, 3]
+    end_nodes = [1, 2, 2, 3, 4, 3, 4, 4, 2, 5]
+    capacities = [15, 8, 20, 4, 10, 15, 4, 20, 5, 10]
+    unit_costs = [4, 4, 2, 2, 6, 1, 3, 2, 3, 4]
+    supplies = [23, 0, 0, -5, -15, -3]
+    answer = 183
+
+    for i in range(len(supplies)):
+        G.add_node(i, demand=(-1) * supplies[i])  # supplies are negative of demand
+
+    for i in range(len(start_nodes)):
+        G.add_edge(
+            start_nodes[i], end_nodes[i], weight=unit_costs[i], capacity=capacities[i]
+        )
+
+    flowCost, flowDict = nx.network_simplex(G)
+    assert flowCost == answer
+    assert flowCost == get_flowcost_from_flowdict(G, flowDict)
+
+
+def test_large():
+    fname = os.path.join(os.path.dirname(__file__), "netgen-2.gpickle.bz2")
+    G = nx.read_gpickle(fname)
+    flowCost, flowDict = nx.network_simplex(G)
+    assert 6749969302 == flowCost
+    assert 6749969302 == nx.cost_of_flow(G, flowDict)
+
+
+def test_simple_digraph():
+    G = nx.DiGraph()
+    G.add_node("a", demand=-5)
+    G.add_node("d", demand=5)
+    G.add_edge("a", "b", weight=3, capacity=4)
+    G.add_edge("a", "c", weight=6, capacity=10)
+    G.add_edge("b", "d", weight=1, capacity=9)
+    G.add_edge("c", "d", weight=2, capacity=5)
+    flowCost, H = nx.network_simplex(G)
+    soln = {"a": {"b": 4, "c": 1}, "b": {"d": 4}, "c": {"d": 1}, "d": {}}
+    assert flowCost == 24
+    assert nx.min_cost_flow_cost(G) == 24
+    assert H == soln
+
+
+def test_negcycle_infcap():
+    G = nx.DiGraph()
+    G.add_node("s", demand=-5)
+    G.add_node("t", demand=5)
+    G.add_edge("s", "a", weight=1, capacity=3)
+    G.add_edge("a", "b", weight=3)
+    G.add_edge("c", "a", weight=-6)
+    G.add_edge("b", "d", weight=1)
+    G.add_edge("d", "c", weight=-2)
+    G.add_edge("d", "t", weight=1, capacity=3)
+    pytest.raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
+
+
+def test_transshipment():
+    G = nx.DiGraph()
+    G.add_node("a", demand=1)
+    G.add_node("b", demand=-2)
+    G.add_node("c", demand=-2)
+    G.add_node("d", demand=3)
+    G.add_node("e", demand=-4)
+    G.add_node("f", demand=-4)
+    G.add_node("g", demand=3)
+    G.add_node("h", demand=2)
+    G.add_node("r", demand=3)
+    G.add_edge("a", "c", weight=3)
+    G.add_edge("r", "a", weight=2)
+    G.add_edge("b", "a", weight=9)
+    G.add_edge("r", "c", weight=0)
+    G.add_edge("b", "r", weight=-6)
+    G.add_edge("c", "d", weight=5)
+    G.add_edge("e", "r", weight=4)
+    G.add_edge("e", "f", weight=3)
+    G.add_edge("h", "b", weight=4)
+    G.add_edge("f", "d", weight=7)
+    G.add_edge("f", "h", weight=12)
+    G.add_edge("g", "d", weight=12)
+    G.add_edge("f", "g", weight=-1)
+    G.add_edge("h", "g", weight=-10)
+    flowCost, H = nx.network_simplex(G)
+    soln = {
+        "a": {"c": 0},
+        "b": {"a": 0, "r": 2},
+        "c": {"d": 3},
+        "d": {},
+        "e": {"r": 3, "f": 1},
+        "f": {"d": 0, "g": 3, "h": 2},
+        "g": {"d": 0},
+        "h": {"b": 0, "g": 0},
+        "r": {"a": 1, "c": 1},
+    }
+    assert flowCost == 41
+    assert H == soln
+
+
+def test_digraph1():
+    # From Bradley, S. P., Hax, A. C. and Magnanti, T. L. Applied
+    # Mathematical Programming. Addison-Wesley, 1977.
+    G = nx.DiGraph()
+    G.add_node(1, demand=-20)
+    G.add_node(4, demand=5)
+    G.add_node(5, demand=15)
+    G.add_edges_from(
+        [
+            (1, 2, {"capacity": 15, "weight": 4}),
+            (1, 3, {"capacity": 8, "weight": 4}),
+            (2, 3, {"weight": 2}),
+            (2, 4, {"capacity": 4, "weight": 2}),
+            (2, 5, {"capacity": 10, "weight": 6}),
+            (3, 4, {"capacity": 15, "weight": 1}),
+            (3, 5, {"capacity": 5, "weight": 3}),
+            (4, 5, {"weight": 2}),
+            (5, 3, {"capacity": 4, "weight": 1}),
+        ]
+    )
+    flowCost, H = nx.network_simplex(G)
+    soln = {
+        1: {2: 12, 3: 8},
+        2: {3: 8, 4: 4, 5: 0},
+        3: {4: 11, 5: 5},
+        4: {5: 10},
+        5: {3: 0},
+    }
+    assert flowCost == 150
+    assert nx.min_cost_flow_cost(G) == 150
+    assert H == soln
+
+
+def test_zero_capacity_edges():
+    """Address issue raised in ticket #617 by arv."""
+    G = nx.DiGraph()
+    G.add_edges_from(
+        [
+            (1, 2, {"capacity": 1, "weight": 1}),
+            (1, 5, {"capacity": 1, "weight": 1}),
+            (2, 3, {"capacity": 0, "weight": 1}),
+            (2, 5, {"capacity": 1, "weight": 1}),
+            (5, 3, {"capacity": 2, "weight": 1}),
+            (5, 4, {"capacity": 0, "weight": 1}),
+            (3, 4, {"capacity": 2, "weight": 1}),
+        ]
+    )
+    G.nodes[1]["demand"] = -1
+    G.nodes[2]["demand"] = -1
+    G.nodes[4]["demand"] = 2
+
+    flowCost, H = nx.network_simplex(G)
+    soln = {1: {2: 0, 5: 1}, 2: {3: 0, 5: 1}, 3: {4: 2}, 4: {}, 5: {3: 2, 4: 0}}
+    assert flowCost == 6
+    assert nx.min_cost_flow_cost(G) == 6
+    assert H == soln
+
+
+def test_digon():
+    """Check if digons are handled properly. Taken from ticket
+    #618 by arv."""
+    nodes = [(1, {}), (2, {"demand": -4}), (3, {"demand": 4})]
+    edges = [
+        (1, 2, {"capacity": 3, "weight": 600000}),
+        (2, 1, {"capacity": 2, "weight": 0}),
+        (2, 3, {"capacity": 5, "weight": 714285}),
+        (3, 2, {"capacity": 2, "weight": 0}),
+    ]
+    G = nx.DiGraph(edges)
+    G.add_nodes_from(nodes)
+    flowCost, H = nx.network_simplex(G)
+    soln = {1: {2: 0}, 2: {1: 0, 3: 4}, 3: {2: 0}}
+    assert flowCost == 2857140
+
+
+def test_deadend():
+    """Check if one-node cycles are handled properly. Taken from ticket
+    #2906 from @sshraven."""
+    G = nx.DiGraph()
+
+    G.add_nodes_from(range(5), demand=0)
+    G.nodes[4]["demand"] = -13
+    G.nodes[3]["demand"] = 13
+
+    G.add_edges_from([(0, 2), (0, 3), (2, 1)], capacity=20, weight=0.1)
+    pytest.raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
+
+
+def test_infinite_capacity_neg_digon():
+    """An infinite capacity negative cost digon results in an unbounded
+    instance."""
+    nodes = [(1, {}), (2, {"demand": -4}), (3, {"demand": 4})]
+    edges = [
+        (1, 2, {"weight": -600}),
+        (2, 1, {"weight": 0}),
+        (2, 3, {"capacity": 5, "weight": 714285}),
+        (3, 2, {"capacity": 2, "weight": 0}),
+    ]
+    G = nx.DiGraph(edges)
+    G.add_nodes_from(nodes)
+    pytest.raises(nx.NetworkXUnbounded, nx.network_simplex, G)
+
+
+def test_multidigraph():
+    """Multidigraphs are acceptable."""
+    G = nx.MultiDiGraph()
+    G.add_weighted_edges_from([(1, 2, 1), (2, 3, 2)], weight="capacity")
+    flowCost, H = nx.network_simplex(G)
+    assert flowCost == 0
+    assert H == {1: {2: {0: 0}}, 2: {3: {0: 0}}, 3: {}}
+
+
+def test_negative_selfloops():
+    """Negative selfloops should cause an exception if uncapacitated and
+    always be saturated otherwise.
+    """
+    G = nx.DiGraph()
+    G.add_edge(1, 1, weight=-1)
+    pytest.raises(nx.NetworkXUnbounded, nx.network_simplex, G)
+
+    G[1][1]["capacity"] = 2
+    flowCost, H = nx.network_simplex(G)
+    assert flowCost == -2
+    assert H == {1: {1: 2}}
+
+    G = nx.MultiDiGraph()
+    G.add_edge(1, 1, "x", weight=-1)
+    G.add_edge(1, 1, "y", weight=1)
+    pytest.raises(nx.NetworkXUnbounded, nx.network_simplex, G)
+
+    G[1][1]["x"]["capacity"] = 2
+    flowCost, H = nx.network_simplex(G)
+    assert flowCost == -2
+    assert H == {1: {1: {"x": 2, "y": 0}}}
+
+
+def test_bone_shaped():
+    # From #1283
+    G = nx.DiGraph()
+    G.add_node(0, demand=-4)
+    G.add_node(1, demand=2)
+    G.add_node(2, demand=2)
+    G.add_node(3, demand=4)
+    G.add_node(4, demand=-2)
+    G.add_node(5, demand=-2)
+    G.add_edge(0, 1, capacity=4)
+    G.add_edge(0, 2, capacity=4)
+    G.add_edge(4, 3, capacity=4)
+    G.add_edge(5, 3, capacity=4)
+    G.add_edge(0, 3, capacity=0)
+    flowCost, H = nx.network_simplex(G)
+    assert flowCost == 0
+    assert H == {0: {1: 2, 2: 2, 3: 0}, 1: {}, 2: {}, 3: {}, 4: {3: 2}, 5: {3: 2}}
+
+
+def test_graphs_type_exceptions():
+    G = nx.Graph()
+    pytest.raises(nx.NetworkXNotImplemented, nx.network_simplex, G)
+    G = nx.MultiGraph()
+    pytest.raises(nx.NetworkXNotImplemented, nx.network_simplex, G)
+    G = nx.DiGraph()
+    pytest.raises(nx.NetworkXError, nx.network_simplex, G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/wlm3.gpickle.bz2 b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/wlm3.gpickle.bz2
new file mode 100644
index 0000000..8ce935a
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/tests/wlm3.gpickle.bz2 differ
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/utils.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/utils.py
new file mode 100644
index 0000000..e1e3e6d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/flow/utils.py
@@ -0,0 +1,181 @@
+"""
+Utility classes and functions for network flow algorithms.
+"""
+
+from collections import deque
+
+import networkx as nx
+
+__all__ = [
+    "CurrentEdge",
+    "Level",
+    "GlobalRelabelThreshold",
+    "build_residual_network",
+    "detect_unboundedness",
+    "build_flow_dict",
+]
+
+
+class CurrentEdge:
+    """Mechanism for iterating over out-edges incident to a node in a circular
+    manner. StopIteration exception is raised when wraparound occurs.
+    """
+
+    __slots__ = ("_edges", "_it", "_curr")
+
+    def __init__(self, edges):
+        self._edges = edges
+        if self._edges:
+            self._rewind()
+
+    def get(self):
+        return self._curr
+
+    def move_to_next(self):
+        try:
+            self._curr = next(self._it)
+        except StopIteration:
+            self._rewind()
+            raise
+
+    def _rewind(self):
+        self._it = iter(self._edges.items())
+        self._curr = next(self._it)
+
+
+class Level:
+    """Active and inactive nodes in a level."""
+
+    __slots__ = ("active", "inactive")
+
+    def __init__(self):
+        self.active = set()
+        self.inactive = set()
+
+
+class GlobalRelabelThreshold:
+    """Measurement of work before the global relabeling heuristic should be
+    applied.
+    """
+
+    def __init__(self, n, m, freq):
+        self._threshold = (n + m) / freq if freq else float("inf")
+        self._work = 0
+
+    def add_work(self, work):
+        self._work += work
+
+    def is_reached(self):
+        return self._work >= self._threshold
+
+    def clear_work(self):
+        self._work = 0
+
+
+def build_residual_network(G, capacity):
+    """Build a residual network and initialize a zero flow.
+
+    The residual network :samp:`R` from an input graph :samp:`G` has the
+    same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair
+    of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a
+    self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists
+    in :samp:`G`.
+
+    For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']`
+    is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists
+    in :samp:`G` or zero otherwise. If the capacity is infinite,
+    :samp:`R[u][v]['capacity']` will have a high arbitrary finite value
+    that does not affect the solution of the problem. This value is stored in
+    :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`,
+    :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and
+    satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`.
+
+    The flow value, defined as the total flow into :samp:`t`, the sink, is
+    stored in :samp:`R.graph['flow_value']`. If :samp:`cutoff` is not
+    specified, reachability to :samp:`t` using only edges :samp:`(u, v)` such
+    that :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum
+    :samp:`s`-:samp:`t` cut.
+
+    """
+    if G.is_multigraph():
+        raise nx.NetworkXError("MultiGraph and MultiDiGraph not supported (yet).")
+
+    R = nx.DiGraph()
+    R.add_nodes_from(G)
+
+    inf = float("inf")
+    # Extract edges with positive capacities. Self loops excluded.
+    edge_list = [
+        (u, v, attr)
+        for u, v, attr in G.edges(data=True)
+        if u != v and attr.get(capacity, inf) > 0
+    ]
+    # Simulate infinity with three times the sum of the finite edge capacities
+    # or any positive value if the sum is zero. This allows the
+    # infinite-capacity edges to be distinguished for unboundedness detection
+    # and directly participate in residual capacity calculation. If the maximum
+    # flow is finite, these edges cannot appear in the minimum cut and thus
+    # guarantee correctness. Since the residual capacity of an
+    # infinite-capacity edge is always at least 2/3 of inf, while that of an
+    # finite-capacity edge is at most 1/3 of inf, if an operation moves more
+    # than 1/3 of inf units of flow to t, there must be an infinite-capacity
+    # s-t path in G.
+    inf = (
+        3
+        * sum(
+            attr[capacity]
+            for u, v, attr in edge_list
+            if capacity in attr and attr[capacity] != inf
+        )
+        or 1
+    )
+    if G.is_directed():
+        for u, v, attr in edge_list:
+            r = min(attr.get(capacity, inf), inf)
+            if not R.has_edge(u, v):
+                # Both (u, v) and (v, u) must be present in the residual
+                # network.
+                R.add_edge(u, v, capacity=r)
+                R.add_edge(v, u, capacity=0)
+            else:
+                # The edge (u, v) was added when (v, u) was visited.
+                R[u][v]["capacity"] = r
+    else:
+        for u, v, attr in edge_list:
+            # Add a pair of edges with equal residual capacities.
+            r = min(attr.get(capacity, inf), inf)
+            R.add_edge(u, v, capacity=r)
+            R.add_edge(v, u, capacity=r)
+
+    # Record the value simulating infinity.
+    R.graph["inf"] = inf
+
+    return R
+
+
+def detect_unboundedness(R, s, t):
+    """Detect an infinite-capacity s-t path in R."""
+    q = deque([s])
+    seen = {s}
+    inf = R.graph["inf"]
+    while q:
+        u = q.popleft()
+        for v, attr in R[u].items():
+            if attr["capacity"] == inf and v not in seen:
+                if v == t:
+                    raise nx.NetworkXUnbounded(
+                        "Infinite capacity path, flow unbounded above."
+                    )
+                seen.add(v)
+                q.append(v)
+
+
+def build_flow_dict(G, R):
+    """Build a flow dictionary from a residual network."""
+    flow_dict = {}
+    for u in G:
+        flow_dict[u] = {v: 0 for v in G[u]}
+        flow_dict[u].update(
+            (v, attr["flow"]) for v, attr in R[u].items() if attr["flow"] > 0
+        )
+    return flow_dict
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/graph_hashing.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/graph_hashing.py
new file mode 100644
index 0000000..b6e6312
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/graph_hashing.py
@@ -0,0 +1,304 @@
+"""
+Functions for hashing graphs to strings.
+Isomorphic graphs should be assigned identical hashes.
+For now, only Weisfeiler-Lehman hashing is implemented.
+"""
+
+from collections import Counter, defaultdict
+from hashlib import blake2b
+
+__all__ = ["weisfeiler_lehman_graph_hash", "weisfeiler_lehman_subgraph_hashes"]
+
+
+def _hash_label(label, digest_size):
+    return blake2b(label.encode("ascii"), digest_size=digest_size).hexdigest()
+
+
+def _init_node_labels(G, edge_attr, node_attr):
+    if node_attr:
+        return {u: str(dd[node_attr]) for u, dd in G.nodes(data=True)}
+    elif edge_attr:
+        return {u: "" for u in G}
+    else:
+        return {u: str(deg) for u, deg in G.degree()}
+
+
+def _neighborhood_aggregate(G, node, node_labels, edge_attr=None):
+    """
+    Compute new labels for given node by aggregating
+    the labels of each node's neighbors.
+    """
+    label_list = []
+    for nbr in G.neighbors(node):
+        prefix = "" if edge_attr is None else str(G[node][nbr][edge_attr])
+        label_list.append(prefix + node_labels[nbr])
+    return node_labels[node] + "".join(sorted(label_list))
+
+
+def weisfeiler_lehman_graph_hash(
+    G, edge_attr=None, node_attr=None, iterations=3, digest_size=16
+):
+    """Return Weisfeiler Lehman (WL) graph hash.
+
+    The function iteratively aggregates and hashes neighbourhoods of each node.
+    After each node's neighbors are hashed to obtain updated node labels,
+    a hashed histogram of resulting labels is returned as the final hash.
+
+    Hashes are identical for isomorphic graphs and strong guarantees that
+    non-isomorphic graphs will get different hashes. See [1]_ for details.
+
+    If no node or edge attributes are provided, the degree of each node
+    is used as its initial label.
+    Otherwise, node and/or edge labels are used to compute the hash.
+
+    Parameters
+    ----------
+    G: graph
+        The graph to be hashed.
+        Can have node and/or edge attributes. Can also have no attributes.
+    edge_attr: string, default=None
+        The key in edge attribute dictionary to be used for hashing.
+        If None, edge labels are ignored.
+    node_attr: string, default=None
+        The key in node attribute dictionary to be used for hashing.
+        If None, and no edge_attr given, use the degrees of the nodes as labels.
+    iterations: int, default=3
+        Number of neighbor aggregations to perform.
+        Should be larger for larger graphs.
+    digest_size: int, default=16
+        Size (in bits) of blake2b hash digest to use for hashing node labels.
+
+    Returns
+    -------
+    h : string
+        Hexadecimal string corresponding to hash of the input graph.
+
+    Examples
+    --------
+    Two graphs with edge attributes that are isomorphic, except for
+    differences in the edge labels.
+
+    >>> G1 = nx.Graph()
+    >>> G1.add_edges_from(
+    ...     [
+    ...         (1, 2, {"label": "A"}),
+    ...         (2, 3, {"label": "A"}),
+    ...         (3, 1, {"label": "A"}),
+    ...         (1, 4, {"label": "B"}),
+    ...     ]
+    ... )
+    >>> G2 = nx.Graph()
+    >>> G2.add_edges_from(
+    ...     [
+    ...         (5, 6, {"label": "B"}),
+    ...         (6, 7, {"label": "A"}),
+    ...         (7, 5, {"label": "A"}),
+    ...         (7, 8, {"label": "A"}),
+    ...     ]
+    ... )
+
+    Omitting the `edge_attr` option, results in identical hashes.
+
+    >>> nx.weisfeiler_lehman_graph_hash(G1)
+    '7bc4dde9a09d0b94c5097b219891d81a'
+    >>> nx.weisfeiler_lehman_graph_hash(G2)
+    '7bc4dde9a09d0b94c5097b219891d81a'
+
+    With edge labels, the graphs are no longer assigned
+    the same hash digest.
+
+    >>> nx.weisfeiler_lehman_graph_hash(G1, edge_attr="label")
+    'c653d85538bcf041d88c011f4f905f10'
+    >>> nx.weisfeiler_lehman_graph_hash(G2, edge_attr="label")
+    '3dcd84af1ca855d0eff3c978d88e7ec7'
+
+    Notes
+    -----
+    To return the WL hashes of each subgraph of a graph, use
+    `weisfeiler_lehman_subgraph_hashes`
+
+    Similarity between hashes does not imply similarity between graphs.
+
+    References
+    ----------
+    .. [1] Shervashidze, Nino, Pascal Schweitzer, Erik Jan Van Leeuwen,
+       Kurt Mehlhorn, and Karsten M. Borgwardt. Weisfeiler Lehman
+       Graph Kernels. Journal of Machine Learning Research. 2011.
+       http://www.jmlr.org/papers/volume12/shervashidze11a/shervashidze11a.pdf
+
+    See also
+    --------
+    weisfeiler_lehman_subgraph_hashes
+    """
+
+    def weisfeiler_lehman_step(G, labels, edge_attr=None):
+        """
+        Apply neighborhood aggregation to each node
+        in the graph.
+        Computes a dictionary with labels for each node.
+        """
+        new_labels = {}
+        for node in G.nodes():
+            label = _neighborhood_aggregate(G, node, labels, edge_attr=edge_attr)
+            new_labels[node] = _hash_label(label, digest_size)
+        return new_labels
+
+    # set initial node labels
+    node_labels = _init_node_labels(G, edge_attr, node_attr)
+
+    subgraph_hash_counts = []
+    for _ in range(iterations):
+        node_labels = weisfeiler_lehman_step(G, node_labels, edge_attr=edge_attr)
+        counter = Counter(node_labels.values())
+        # sort the counter, extend total counts
+        subgraph_hash_counts.extend(sorted(counter.items(), key=lambda x: x[0]))
+
+    # hash the final counter
+    return _hash_label(str(tuple(subgraph_hash_counts)), digest_size)
+
+
+def weisfeiler_lehman_subgraph_hashes(
+    G, edge_attr=None, node_attr=None, iterations=3, digest_size=16
+):
+    """
+    Return a dictionary of subgraph hashes by node.
+
+    The dictionary is keyed by node to a list of hashes in increasingly
+    sized induced subgraphs containing the nodes within 2*k edges
+    of the key node for increasing integer k until all nodes are included.
+
+    The function iteratively aggregates and hashes neighbourhoods of each node.
+    This is achieved for each step by replacing for each node its label from
+    the previous iteration with its hashed 1-hop neighborhood aggregate.
+    The new node label is then appended to a list of node labels for each
+    node.
+
+    To aggregate neighborhoods at each step for a node $n$, all labels of
+    nodes adjacent to $n$ are concatenated. If the `edge_attr` parameter is set,
+    labels for each neighboring node are prefixed with the value of this attribute
+    along the connecting edge from this neighbor to node $n$. The resulting string
+    is then hashed to compress this information into a fixed digest size.
+
+    Thus, at the $i$th iteration nodes within $2i$ distance influence any given
+    hashed node label. We can therefore say that at depth $i$ for node $n$
+    we have a hash for a subgraph induced by the $2i$-hop neighborhood of $n$.
+
+    Can be used to to create general Weisfeiler-Lehman graph kernels, or
+    generate features for graphs or nodes, for example to generate 'words' in a
+    graph as seen in the 'graph2vec' algorithm.
+    See [1]_ & [2]_ respectively for details.
+
+    Hashes are identical for isomorphic subgraphs and there exist strong
+    guarantees that non-isomorphic graphs will get different hashes.
+    See [1]_ for details.
+
+    If no node or edge attributes are provided, the degree of each node
+    is used as its initial label.
+    Otherwise, node and/or edge labels are used to compute the hash.
+
+    Parameters
+    ----------
+    G: graph
+        The graph to be hashed.
+        Can have node and/or edge attributes. Can also have no attributes.
+    edge_attr: string, default=None
+        The key in edge attribute dictionary to be used for hashing.
+        If None, edge labels are ignored.
+    node_attr: string, default=None
+        The key in node attribute dictionary to be used for hashing.
+        If None, and no edge_attr given, use the degrees of the nodes as labels.
+    iterations: int, default=3
+        Number of neighbor aggregations to perform.
+        Should be larger for larger graphs.
+    digest_size: int, default=16
+        Size (in bits) of blake2b hash digest to use for hashing node labels.
+        The default size is 16 bits
+
+    Returns
+    -------
+    node_subgraph_hashes : dict
+        A dictionary with each key given by a node in G, and each value given
+        by the subgraph hashes in order of depth from the key node.
+
+    Examples
+    --------
+    Finding similar nodes in different graphs:
+
+    >>> G1 = nx.Graph()
+    >>> G1.add_edges_from([
+    ...     (1, 2), (2, 3), (2, 4), (3, 5), (4, 6), (5, 7), (6, 7)
+    ... ])
+    >>> G2 = nx.Graph()
+    >>> G2.add_edges_from([
+    ...     (1, 3), (2, 3), (1, 6), (1, 5), (4, 6)
+    ... ])
+    >>> g1_hashes = nx.weisfeiler_lehman_subgraph_hashes(G1, iterations=3, digest_size=8)
+    >>> g2_hashes = nx.weisfeiler_lehman_subgraph_hashes(G2, iterations=3, digest_size=8)
+
+    Even though G1 and G2 are not isomorphic (they have different numbers of edges),
+    the hash sequence of depth 3 for node 1 in G1 and node 5 in G2 are similar:
+
+    >>> g1_hashes[1]
+    ['a93b64973cfc8897', 'db1b43ae35a1878f', '57872a7d2059c1c0']
+    >>> g2_hashes[5]
+    ['a93b64973cfc8897', 'db1b43ae35a1878f', '1716d2a4012fa4bc']
+
+    The first 2 WL subgraph hashes match. From this we can conclude that it's very
+    likely the neighborhood of 4 hops around these nodes are isomorphic: each
+    iteration aggregates 1-hop neighbourhoods meaning hashes at depth $n$ are influenced
+    by every node within $2n$ hops.
+
+    However the neighborhood of 6 hops is no longer isomorphic since their 3rd hash does
+    not match.
+
+    These nodes may be candidates to be classified together since their local topology
+    is similar.
+
+    Notes
+    -----
+    To hash the full graph when subgraph hashes are not needed, use
+    `weisfeiler_lehman_graph_hash` for efficiency.
+
+    Similarity between hashes does not imply similarity between graphs.
+
+    References
+    ----------
+    .. [1] Shervashidze, Nino, Pascal Schweitzer, Erik Jan Van Leeuwen,
+       Kurt Mehlhorn, and Karsten M. Borgwardt. Weisfeiler Lehman
+       Graph Kernels. Journal of Machine Learning Research. 2011.
+       http://www.jmlr.org/papers/volume12/shervashidze11a/shervashidze11a.pdf
+    .. [2] Annamalai Narayanan, Mahinthan Chandramohan, Rajasekar Venkatesan,
+       Lihui Chen, Yang Liu and Shantanu Jaiswa. graph2vec: Learning
+       Distributed Representations of Graphs. arXiv. 2017
+       https://arxiv.org/pdf/1707.05005.pdf
+
+    See also
+    --------
+    weisfeiler_lehman_graph_hash
+    """
+
+    def weisfeiler_lehman_step(G, labels, node_subgraph_hashes, edge_attr=None):
+        """
+        Apply neighborhood aggregation to each node
+        in the graph.
+        Computes a dictionary with labels for each node.
+        Appends the new hashed label to the dictionary of subgraph hashes
+        originating from and indexed by each node in G
+        """
+        new_labels = {}
+        for node in G.nodes():
+            label = _neighborhood_aggregate(G, node, labels, edge_attr=edge_attr)
+            hashed_label = _hash_label(label, digest_size)
+            new_labels[node] = hashed_label
+            node_subgraph_hashes[node].append(hashed_label)
+        return new_labels
+
+    node_labels = _init_node_labels(G, edge_attr, node_attr)
+
+    node_subgraph_hashes = defaultdict(list)
+    for _ in range(iterations):
+        node_labels = weisfeiler_lehman_step(
+            G, node_labels, node_subgraph_hashes, edge_attr
+        )
+
+    return dict(node_subgraph_hashes)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/graphical.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/graphical.py
new file mode 100644
index 0000000..da27e5f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/graphical.py
@@ -0,0 +1,405 @@
+"""Test sequences for graphiness.
+"""
+import heapq
+
+import networkx as nx
+
+__all__ = [
+    "is_graphical",
+    "is_multigraphical",
+    "is_pseudographical",
+    "is_digraphical",
+    "is_valid_degree_sequence_erdos_gallai",
+    "is_valid_degree_sequence_havel_hakimi",
+]
+
+
+def is_graphical(sequence, method="eg"):
+    """Returns True if sequence is a valid degree sequence.
+
+    A degree sequence is valid if some graph can realize it.
+
+    Parameters
+    ----------
+    sequence : list or iterable container
+        A sequence of integer node degrees
+
+    method : "eg" | "hh"  (default: 'eg')
+        The method used to validate the degree sequence.
+        "eg" corresponds to the Erdős-Gallai algorithm
+        [EG1960]_, [choudum1986]_, and
+        "hh" to the Havel-Hakimi algorithm
+        [havel1955]_, [hakimi1962]_, [CL1996]_.
+
+    Returns
+    -------
+    valid : bool
+        True if the sequence is a valid degree sequence and False if not.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> sequence = (d for n, d in G.degree())
+    >>> nx.is_graphical(sequence)
+    True
+
+    References
+    ----------
+    .. [EG1960] Erdős and Gallai, Mat. Lapok 11 264, 1960.
+    .. [choudum1986] S.A. Choudum. "A simple proof of the Erdős-Gallai theorem on
+       graph sequences." Bulletin of the Australian Mathematical Society, 33,
+       pp 67-70, 1986. https://doi.org/10.1017/S0004972700002872
+    .. [havel1955] Havel, V. "A Remark on the Existence of Finite Graphs"
+       Casopis Pest. Mat. 80, 477-480, 1955.
+    .. [hakimi1962] Hakimi, S. "On the Realizability of a Set of Integers as
+       Degrees of the Vertices of a Graph." SIAM J. Appl. Math. 10, 496-506, 1962.
+    .. [CL1996] G. Chartrand and L. Lesniak, "Graphs and Digraphs",
+       Chapman and Hall/CRC, 1996.
+    """
+    if method == "eg":
+        valid = is_valid_degree_sequence_erdos_gallai(list(sequence))
+    elif method == "hh":
+        valid = is_valid_degree_sequence_havel_hakimi(list(sequence))
+    else:
+        msg = "`method` must be 'eg' or 'hh'"
+        raise nx.NetworkXException(msg)
+    return valid
+
+
+def _basic_graphical_tests(deg_sequence):
+    # Sort and perform some simple tests on the sequence
+    deg_sequence = nx.utils.make_list_of_ints(deg_sequence)
+    p = len(deg_sequence)
+    num_degs = [0] * p
+    dmax, dmin, dsum, n = 0, p, 0, 0
+    for d in deg_sequence:
+        # Reject if degree is negative or larger than the sequence length
+        if d < 0 or d >= p:
+            raise nx.NetworkXUnfeasible
+        # Process only the non-zero integers
+        elif d > 0:
+            dmax, dmin, dsum, n = max(dmax, d), min(dmin, d), dsum + d, n + 1
+            num_degs[d] += 1
+    # Reject sequence if it has odd sum or is oversaturated
+    if dsum % 2 or dsum > n * (n - 1):
+        raise nx.NetworkXUnfeasible
+    return dmax, dmin, dsum, n, num_degs
+
+
+def is_valid_degree_sequence_havel_hakimi(deg_sequence):
+    r"""Returns True if deg_sequence can be realized by a simple graph.
+
+    The validation proceeds using the Havel-Hakimi theorem
+    [havel1955]_, [hakimi1962]_, [CL1996]_.
+    Worst-case run time is $O(s)$ where $s$ is the sum of the sequence.
+
+    Parameters
+    ----------
+    deg_sequence : list
+        A list of integers where each element specifies the degree of a node
+        in a graph.
+
+    Returns
+    -------
+    valid : bool
+        True if deg_sequence is graphical and False if not.
+
+    Notes
+    -----
+    The ZZ condition says that for the sequence d if
+
+    .. math::
+        |d| >= \frac{(\max(d) + \min(d) + 1)^2}{4*\min(d)}
+
+    then d is graphical.  This was shown in Theorem 6 in [1]_.
+
+    References
+    ----------
+    .. [1] I.E. Zverovich and V.E. Zverovich. "Contributions to the theory
+       of graphic sequences", Discrete Mathematics, 105, pp. 292-303 (1992).
+    .. [havel1955] Havel, V. "A Remark on the Existence of Finite Graphs"
+       Casopis Pest. Mat. 80, 477-480, 1955.
+    .. [hakimi1962] Hakimi, S. "On the Realizability of a Set of Integers as
+       Degrees of the Vertices of a Graph." SIAM J. Appl. Math. 10, 496-506, 1962.
+    .. [CL1996] G. Chartrand and L. Lesniak, "Graphs and Digraphs",
+       Chapman and Hall/CRC, 1996.
+    """
+    try:
+        dmax, dmin, dsum, n, num_degs = _basic_graphical_tests(deg_sequence)
+    except nx.NetworkXUnfeasible:
+        return False
+    # Accept if sequence has no non-zero degrees or passes the ZZ condition
+    if n == 0 or 4 * dmin * n >= (dmax + dmin + 1) * (dmax + dmin + 1):
+        return True
+
+    modstubs = [0] * (dmax + 1)
+    # Successively reduce degree sequence by removing the maximum degree
+    while n > 0:
+        # Retrieve the maximum degree in the sequence
+        while num_degs[dmax] == 0:
+            dmax -= 1
+        # If there are not enough stubs to connect to, then the sequence is
+        # not graphical
+        if dmax > n - 1:
+            return False
+
+        # Remove largest stub in list
+        num_degs[dmax], n = num_degs[dmax] - 1, n - 1
+        # Reduce the next dmax largest stubs
+        mslen = 0
+        k = dmax
+        for i in range(dmax):
+            while num_degs[k] == 0:
+                k -= 1
+            num_degs[k], n = num_degs[k] - 1, n - 1
+            if k > 1:
+                modstubs[mslen] = k - 1
+                mslen += 1
+        # Add back to the list any non-zero stubs that were removed
+        for i in range(mslen):
+            stub = modstubs[i]
+            num_degs[stub], n = num_degs[stub] + 1, n + 1
+    return True
+
+
+def is_valid_degree_sequence_erdos_gallai(deg_sequence):
+    r"""Returns True if deg_sequence can be realized by a simple graph.
+
+    The validation is done using the Erdős-Gallai theorem [EG1960]_.
+
+    Parameters
+    ----------
+    deg_sequence : list
+        A list of integers
+
+    Returns
+    -------
+    valid : bool
+        True if deg_sequence is graphical and False if not.
+
+    Notes
+    -----
+
+    This implementation uses an equivalent form of the Erdős-Gallai criterion.
+    Worst-case run time is $O(n)$ where $n$ is the length of the sequence.
+
+    Specifically, a sequence d is graphical if and only if the
+    sum of the sequence is even and for all strong indices k in the sequence,
+
+     .. math::
+
+       \sum_{i=1}^{k} d_i \leq k(k-1) + \sum_{j=k+1}^{n} \min(d_i,k)
+             = k(n-1) - ( k \sum_{j=0}^{k-1} n_j - \sum_{j=0}^{k-1} j n_j )
+
+    A strong index k is any index where d_k >= k and the value n_j is the
+    number of occurrences of j in d.  The maximal strong index is called the
+    Durfee index.
+
+    This particular rearrangement comes from the proof of Theorem 3 in [2]_.
+
+    The ZZ condition says that for the sequence d if
+
+    .. math::
+        |d| >= \frac{(\max(d) + \min(d) + 1)^2}{4*\min(d)}
+
+    then d is graphical.  This was shown in Theorem 6 in [2]_.
+
+    References
+    ----------
+    .. [1] A. Tripathi and S. Vijay. "A note on a theorem of Erdős & Gallai",
+       Discrete Mathematics, 265, pp. 417-420 (2003).
+    .. [2] I.E. Zverovich and V.E. Zverovich. "Contributions to the theory
+       of graphic sequences", Discrete Mathematics, 105, pp. 292-303 (1992).
+    .. [EG1960] Erdős and Gallai, Mat. Lapok 11 264, 1960.
+    """
+    try:
+        dmax, dmin, dsum, n, num_degs = _basic_graphical_tests(deg_sequence)
+    except nx.NetworkXUnfeasible:
+        return False
+    # Accept if sequence has no non-zero degrees or passes the ZZ condition
+    if n == 0 or 4 * dmin * n >= (dmax + dmin + 1) * (dmax + dmin + 1):
+        return True
+
+    # Perform the EG checks using the reformulation of Zverovich and Zverovich
+    k, sum_deg, sum_nj, sum_jnj = 0, 0, 0, 0
+    for dk in range(dmax, dmin - 1, -1):
+        if dk < k + 1:  # Check if already past Durfee index
+            return True
+        if num_degs[dk] > 0:
+            run_size = num_degs[dk]  # Process a run of identical-valued degrees
+            if dk < k + run_size:  # Check if end of run is past Durfee index
+                run_size = dk - k  # Adjust back to Durfee index
+            sum_deg += run_size * dk
+            for v in range(run_size):
+                sum_nj += num_degs[k + v]
+                sum_jnj += (k + v) * num_degs[k + v]
+            k += run_size
+            if sum_deg > k * (n - 1) - k * sum_nj + sum_jnj:
+                return False
+    return True
+
+
+def is_multigraphical(sequence):
+    """Returns True if some multigraph can realize the sequence.
+
+    Parameters
+    ----------
+    sequence : list
+        A list of integers
+
+    Returns
+    -------
+    valid : bool
+        True if deg_sequence is a multigraphic degree sequence and False if not.
+
+    Notes
+    -----
+    The worst-case run time is $O(n)$ where $n$ is the length of the sequence.
+
+    References
+    ----------
+    .. [1] S. L. Hakimi. "On the realizability of a set of integers as
+       degrees of the vertices of a linear graph", J. SIAM, 10, pp. 496-506
+       (1962).
+    """
+    try:
+        deg_sequence = nx.utils.make_list_of_ints(sequence)
+    except nx.NetworkXError:
+        return False
+    dsum, dmax = 0, 0
+    for d in deg_sequence:
+        if d < 0:
+            return False
+        dsum, dmax = dsum + d, max(dmax, d)
+    if dsum % 2 or dsum < 2 * dmax:
+        return False
+    return True
+
+
+def is_pseudographical(sequence):
+    """Returns True if some pseudograph can realize the sequence.
+
+    Every nonnegative integer sequence with an even sum is pseudographical
+    (see [1]_).
+
+    Parameters
+    ----------
+    sequence : list or iterable container
+        A sequence of integer node degrees
+
+    Returns
+    -------
+    valid : bool
+      True if the sequence is a pseudographic degree sequence and False if not.
+
+    Notes
+    -----
+    The worst-case run time is $O(n)$ where n is the length of the sequence.
+
+    References
+    ----------
+    .. [1] F. Boesch and F. Harary. "Line removal algorithms for graphs
+       and their degree lists", IEEE Trans. Circuits and Systems, CAS-23(12),
+       pp. 778-782 (1976).
+    """
+    try:
+        deg_sequence = nx.utils.make_list_of_ints(sequence)
+    except nx.NetworkXError:
+        return False
+    return sum(deg_sequence) % 2 == 0 and min(deg_sequence) >= 0
+
+
+def is_digraphical(in_sequence, out_sequence):
+    r"""Returns True if some directed graph can realize the in- and out-degree
+    sequences.
+
+    Parameters
+    ----------
+    in_sequence : list or iterable container
+        A sequence of integer node in-degrees
+
+    out_sequence : list or iterable container
+        A sequence of integer node out-degrees
+
+    Returns
+    -------
+    valid : bool
+      True if in and out-sequences are digraphic False if not.
+
+    Notes
+    -----
+    This algorithm is from Kleitman and Wang [1]_.
+    The worst case runtime is $O(s \times \log n)$ where $s$ and $n$ are the
+    sum and length of the sequences respectively.
+
+    References
+    ----------
+    .. [1] D.J. Kleitman and D.L. Wang
+       Algorithms for Constructing Graphs and Digraphs with Given Valences
+       and Factors, Discrete Mathematics, 6(1), pp. 79-88 (1973)
+    """
+    try:
+        in_deg_sequence = nx.utils.make_list_of_ints(in_sequence)
+        out_deg_sequence = nx.utils.make_list_of_ints(out_sequence)
+    except nx.NetworkXError:
+        return False
+    # Process the sequences and form two heaps to store degree pairs with
+    # either zero or non-zero out degrees
+    sumin, sumout, nin, nout = 0, 0, len(in_deg_sequence), len(out_deg_sequence)
+    maxn = max(nin, nout)
+    maxin = 0
+    if maxn == 0:
+        return True
+    stubheap, zeroheap = [], []
+    for n in range(maxn):
+        in_deg, out_deg = 0, 0
+        if n < nout:
+            out_deg = out_deg_sequence[n]
+        if n < nin:
+            in_deg = in_deg_sequence[n]
+        if in_deg < 0 or out_deg < 0:
+            return False
+        sumin, sumout, maxin = sumin + in_deg, sumout + out_deg, max(maxin, in_deg)
+        if in_deg > 0:
+            stubheap.append((-1 * out_deg, -1 * in_deg))
+        elif out_deg > 0:
+            zeroheap.append(-1 * out_deg)
+    if sumin != sumout:
+        return False
+    heapq.heapify(stubheap)
+    heapq.heapify(zeroheap)
+
+    modstubs = [(0, 0)] * (maxin + 1)
+    # Successively reduce degree sequence by removing the maximum out degree
+    while stubheap:
+        # Take the first value in the sequence with non-zero in degree
+        (freeout, freein) = heapq.heappop(stubheap)
+        freein *= -1
+        if freein > len(stubheap) + len(zeroheap):
+            return False
+
+        # Attach out stubs to the nodes with the most in stubs
+        mslen = 0
+        for i in range(freein):
+            if zeroheap and (not stubheap or stubheap[0][0] > zeroheap[0]):
+                stubout = heapq.heappop(zeroheap)
+                stubin = 0
+            else:
+                (stubout, stubin) = heapq.heappop(stubheap)
+            if stubout == 0:
+                return False
+            # Check if target is now totally connected
+            if stubout + 1 < 0 or stubin < 0:
+                modstubs[mslen] = (stubout + 1, stubin)
+                mslen += 1
+
+        # Add back the nodes to the heap that still have available stubs
+        for i in range(mslen):
+            stub = modstubs[i]
+            if stub[1] < 0:
+                heapq.heappush(stubheap, stub)
+            else:
+                heapq.heappush(zeroheap, stub[0])
+        if freeout < 0:
+            heapq.heappush(zeroheap, freeout)
+    return True
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/hierarchy.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/hierarchy.py
new file mode 100644
index 0000000..4a4bc29
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/hierarchy.py
@@ -0,0 +1,47 @@
+"""
+Flow Hierarchy.
+"""
+import networkx as nx
+
+__all__ = ["flow_hierarchy"]
+
+
+def flow_hierarchy(G, weight=None):
+    """Returns the flow hierarchy of a directed network.
+
+    Flow hierarchy is defined as the fraction of edges not participating
+    in cycles in a directed graph [1]_.
+
+    Parameters
+    ----------
+    G : DiGraph or MultiDiGraph
+       A directed graph
+
+    weight : key,optional (default=None)
+       Attribute to use for node weights. If None the weight defaults to 1.
+
+    Returns
+    -------
+    h : float
+       Flow hierarchy value
+
+    Notes
+    -----
+    The algorithm described in [1]_ computes the flow hierarchy through
+    exponentiation of the adjacency matrix.  This function implements an
+    alternative approach that finds strongly connected components.
+    An edge is in a cycle if and only if it is in a strongly connected
+    component, which can be found in $O(m)$ time using Tarjan's algorithm.
+
+    References
+    ----------
+    .. [1] Luo, J.; Magee, C.L. (2011),
+       Detecting evolving patterns of self-organizing networks by flow
+       hierarchy measurement, Complexity, Volume 16 Issue 6 53-61.
+       DOI: 10.1002/cplx.20368
+       http://web.mit.edu/~cmagee/www/documents/28-DetectingEvolvingPatterns_FlowHierarchy.pdf
+    """
+    if not G.is_directed():
+        raise nx.NetworkXError("G must be a digraph in flow_hierarchy")
+    scc = nx.strongly_connected_components(G)
+    return 1 - sum(G.subgraph(c).size(weight) for c in scc) / G.size(weight)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/hybrid.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/hybrid.py
new file mode 100644
index 0000000..d350fe2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/hybrid.py
@@ -0,0 +1,193 @@
+"""
+Provides functions for finding and testing for locally `(k, l)`-connected
+graphs.
+
+"""
+import copy
+
+import networkx as nx
+
+__all__ = ["kl_connected_subgraph", "is_kl_connected"]
+
+
+def kl_connected_subgraph(G, k, l, low_memory=False, same_as_graph=False):
+    """Returns the maximum locally `(k, l)`-connected subgraph of `G`.
+
+    A graph is locally `(k, l)`-connected if for each edge `(u, v)` in the
+    graph there are at least `l` edge-disjoint paths of length at most `k`
+    joining `u` to `v`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The graph in which to find a maximum locally `(k, l)`-connected
+        subgraph.
+
+    k : integer
+        The maximum length of paths to consider. A higher number means a looser
+        connectivity requirement.
+
+    l : integer
+        The number of edge-disjoint paths. A higher number means a stricter
+        connectivity requirement.
+
+    low_memory : bool
+        If this is True, this function uses an algorithm that uses slightly
+        more time but less memory.
+
+    same_as_graph : bool
+        If True then return a tuple of the form `(H, is_same)`,
+        where `H` is the maximum locally `(k, l)`-connected subgraph and
+        `is_same` is a Boolean representing whether `G` is locally `(k,
+        l)`-connected (and hence, whether `H` is simply a copy of the input
+        graph `G`).
+
+    Returns
+    -------
+    NetworkX graph or two-tuple
+        If `same_as_graph` is True, then this function returns a
+        two-tuple as described above. Otherwise, it returns only the maximum
+        locally `(k, l)`-connected subgraph.
+
+    See also
+    --------
+    is_kl_connected
+
+    References
+    ----------
+    .. [1] Chung, Fan and Linyuan Lu. "The Small World Phenomenon in Hybrid
+           Power Law Graphs." *Complex Networks*. Springer Berlin Heidelberg,
+           2004. 89--104.
+
+    """
+    H = copy.deepcopy(G)  # subgraph we construct by removing from G
+
+    graphOK = True
+    deleted_some = True  # hack to start off the while loop
+    while deleted_some:
+        deleted_some = False
+        # We use `for edge in list(H.edges()):` instead of
+        # `for edge in H.edges():` because we edit the graph `H` in
+        # the loop. Hence using an iterator will result in
+        # `RuntimeError: dictionary changed size during iteration`
+        for edge in list(H.edges()):
+            (u, v) = edge
+            # Get copy of graph needed for this search
+            if low_memory:
+                verts = {u, v}
+                for i in range(k):
+                    for w in verts.copy():
+                        verts.update(G[w])
+                G2 = G.subgraph(verts).copy()
+            else:
+                G2 = copy.deepcopy(G)
+            ###
+            path = [u, v]
+            cnt = 0
+            accept = 0
+            while path:
+                cnt += 1  # Found a path
+                if cnt >= l:
+                    accept = 1
+                    break
+                # record edges along this graph
+                prev = u
+                for w in path:
+                    if prev != w:
+                        G2.remove_edge(prev, w)
+                        prev = w
+                #                path = shortest_path(G2, u, v, k) # ??? should "Cutoff" be k+1?
+                try:
+                    path = nx.shortest_path(G2, u, v)  # ??? should "Cutoff" be k+1?
+                except nx.NetworkXNoPath:
+                    path = False
+            # No Other Paths
+            if accept == 0:
+                H.remove_edge(u, v)
+                deleted_some = True
+                if graphOK:
+                    graphOK = False
+    # We looked through all edges and removed none of them.
+    # So, H is the maximal (k,l)-connected subgraph of G
+    if same_as_graph:
+        return (H, graphOK)
+    return H
+
+
+def is_kl_connected(G, k, l, low_memory=False):
+    """Returns True if and only if `G` is locally `(k, l)`-connected.
+
+    A graph is locally `(k, l)`-connected if for each edge `(u, v)` in the
+    graph there are at least `l` edge-disjoint paths of length at most `k`
+    joining `u` to `v`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The graph to test for local `(k, l)`-connectedness.
+
+    k : integer
+        The maximum length of paths to consider. A higher number means a looser
+        connectivity requirement.
+
+    l : integer
+        The number of edge-disjoint paths. A higher number means a stricter
+        connectivity requirement.
+
+    low_memory : bool
+        If this is True, this function uses an algorithm that uses slightly
+        more time but less memory.
+
+    Returns
+    -------
+    bool
+        Whether the graph is locally `(k, l)`-connected subgraph.
+
+    See also
+    --------
+    kl_connected_subgraph
+
+    References
+    ----------
+    .. [1] Chung, Fan and Linyuan Lu. "The Small World Phenomenon in Hybrid
+           Power Law Graphs." *Complex Networks*. Springer Berlin Heidelberg,
+           2004. 89--104.
+
+    """
+    graphOK = True
+    for edge in G.edges():
+        (u, v) = edge
+        # Get copy of graph needed for this search
+        if low_memory:
+            verts = {u, v}
+            for i in range(k):
+                [verts.update(G.neighbors(w)) for w in verts.copy()]
+            G2 = G.subgraph(verts)
+        else:
+            G2 = copy.deepcopy(G)
+        ###
+        path = [u, v]
+        cnt = 0
+        accept = 0
+        while path:
+            cnt += 1  # Found a path
+            if cnt >= l:
+                accept = 1
+                break
+            # record edges along this graph
+            prev = u
+            for w in path:
+                if w != prev:
+                    G2.remove_edge(prev, w)
+                    prev = w
+            #            path = shortest_path(G2, u, v, k) # ??? should "Cutoff" be k+1?
+            try:
+                path = nx.shortest_path(G2, u, v)  # ??? should "Cutoff" be k+1?
+            except nx.NetworkXNoPath:
+                path = False
+        # No Other Paths
+        if accept == 0:
+            graphOK = False
+            break
+    # return status
+    return graphOK
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isolate.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isolate.py
new file mode 100644
index 0000000..e81e722
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isolate.py
@@ -0,0 +1,103 @@
+"""
+Functions for identifying isolate (degree zero) nodes.
+"""
+
+__all__ = ["is_isolate", "isolates", "number_of_isolates"]
+
+
+def is_isolate(G, n):
+    """Determines whether a node is an isolate.
+
+    An *isolate* is a node with no neighbors (that is, with degree
+    zero). For directed graphs, this means no in-neighbors and no
+    out-neighbors.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    n : node
+        A node in `G`.
+
+    Returns
+    -------
+    is_isolate : bool
+       True if and only if `n` has no neighbors.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_edge(1, 2)
+    >>> G.add_node(3)
+    >>> nx.is_isolate(G, 2)
+    False
+    >>> nx.is_isolate(G, 3)
+    True
+    """
+    return G.degree(n) == 0
+
+
+def isolates(G):
+    """Iterator over isolates in the graph.
+
+    An *isolate* is a node with no neighbors (that is, with degree
+    zero). For directed graphs, this means no in-neighbors and no
+    out-neighbors.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    iterator
+        An iterator over the isolates of `G`.
+
+    Examples
+    --------
+    To get a list of all isolates of a graph, use the :class:`list`
+    constructor::
+
+        >>> G = nx.Graph()
+        >>> G.add_edge(1, 2)
+        >>> G.add_node(3)
+        >>> list(nx.isolates(G))
+        [3]
+
+    To remove all isolates in the graph, first create a list of the
+    isolates, then use :meth:`Graph.remove_nodes_from`::
+
+        >>> G.remove_nodes_from(list(nx.isolates(G)))
+        >>> list(G)
+        [1, 2]
+
+    For digraphs, isolates have zero in-degree and zero out_degre::
+
+        >>> G = nx.DiGraph([(0, 1), (1, 2)])
+        >>> G.add_node(3)
+        >>> list(nx.isolates(G))
+        [3]
+
+    """
+    return (n for n, d in G.degree() if d == 0)
+
+
+def number_of_isolates(G):
+    """Returns the number of isolates in the graph.
+
+    An *isolate* is a node with no neighbors (that is, with degree
+    zero). For directed graphs, this means no in-neighbors and no
+    out-neighbors.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    int
+        The number of degree zero nodes in the graph `G`.
+
+    """
+    # TODO This can be parallelized.
+    return sum(1 for v in isolates(G))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/__init__.py
new file mode 100644
index 0000000..ddcedea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/__init__.py
@@ -0,0 +1,6 @@
+from networkx.algorithms.isomorphism.isomorph import *
+from networkx.algorithms.isomorphism.vf2userfunc import *
+from networkx.algorithms.isomorphism.matchhelpers import *
+from networkx.algorithms.isomorphism.temporalisomorphvf2 import *
+from networkx.algorithms.isomorphism.ismags import *
+from networkx.algorithms.isomorphism.tree_isomorphism import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/ismags.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/ismags.py
new file mode 100644
index 0000000..bfb5eea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/ismags.py
@@ -0,0 +1,1170 @@
+"""
+****************
+ISMAGS Algorithm
+****************
+
+Provides a Python implementation of the ISMAGS algorithm. [1]_
+
+It is capable of finding (subgraph) isomorphisms between two graphs, taking the
+symmetry of the subgraph into account. In most cases the VF2 algorithm is
+faster (at least on small graphs) than this implementation, but in some cases
+there is an exponential number of isomorphisms that are symmetrically
+equivalent. In that case, the ISMAGS algorithm will provide only one solution
+per symmetry group.
+
+>>> petersen = nx.petersen_graph()
+>>> ismags = nx.isomorphism.ISMAGS(petersen, petersen)
+>>> isomorphisms = list(ismags.isomorphisms_iter(symmetry=False))
+>>> len(isomorphisms)
+120
+>>> isomorphisms = list(ismags.isomorphisms_iter(symmetry=True))
+>>> answer = [{0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}]
+>>> answer == isomorphisms
+True
+
+In addition, this implementation also provides an interface to find the
+largest common induced subgraph [2]_ between any two graphs, again taking
+symmetry into account. Given `graph` and `subgraph` the algorithm will remove
+nodes from the `subgraph` until `subgraph` is isomorphic to a subgraph of
+`graph`. Since only the symmetry of `subgraph` is taken into account it is
+worth thinking about how you provide your graphs:
+
+>>> graph1 = nx.path_graph(4)
+>>> graph2 = nx.star_graph(3)
+>>> ismags = nx.isomorphism.ISMAGS(graph1, graph2)
+>>> ismags.is_isomorphic()
+False
+>>> largest_common_subgraph = list(ismags.largest_common_subgraph())
+>>> answer = [{1: 0, 0: 1, 2: 2}, {2: 0, 1: 1, 3: 2}]
+>>> answer == largest_common_subgraph
+True
+>>> ismags2 = nx.isomorphism.ISMAGS(graph2, graph1)
+>>> largest_common_subgraph = list(ismags2.largest_common_subgraph())
+>>> answer = [
+...     {1: 0, 0: 1, 2: 2},
+...     {1: 0, 0: 1, 3: 2},
+...     {2: 0, 0: 1, 1: 2},
+...     {2: 0, 0: 1, 3: 2},
+...     {3: 0, 0: 1, 1: 2},
+...     {3: 0, 0: 1, 2: 2},
+... ]
+>>> answer == largest_common_subgraph
+True
+
+However, when not taking symmetry into account, it doesn't matter:
+
+>>> largest_common_subgraph = list(ismags.largest_common_subgraph(symmetry=False))
+>>> answer = [
+...     {1: 0, 0: 1, 2: 2},
+...     {1: 0, 2: 1, 0: 2},
+...     {2: 0, 1: 1, 3: 2},
+...     {2: 0, 3: 1, 1: 2},
+...     {1: 0, 0: 1, 2: 3},
+...     {1: 0, 2: 1, 0: 3},
+...     {2: 0, 1: 1, 3: 3},
+...     {2: 0, 3: 1, 1: 3},
+...     {1: 0, 0: 2, 2: 3},
+...     {1: 0, 2: 2, 0: 3},
+...     {2: 0, 1: 2, 3: 3},
+...     {2: 0, 3: 2, 1: 3},
+... ]
+>>> answer == largest_common_subgraph
+True
+>>> largest_common_subgraph = list(ismags2.largest_common_subgraph(symmetry=False))
+>>> answer = [
+...     {1: 0, 0: 1, 2: 2},
+...     {1: 0, 0: 1, 3: 2},
+...     {2: 0, 0: 1, 1: 2},
+...     {2: 0, 0: 1, 3: 2},
+...     {3: 0, 0: 1, 1: 2},
+...     {3: 0, 0: 1, 2: 2},
+...     {1: 1, 0: 2, 2: 3},
+...     {1: 1, 0: 2, 3: 3},
+...     {2: 1, 0: 2, 1: 3},
+...     {2: 1, 0: 2, 3: 3},
+...     {3: 1, 0: 2, 1: 3},
+...     {3: 1, 0: 2, 2: 3},
+... ]
+>>> answer == largest_common_subgraph
+True
+
+Notes
+-----
+ - The current implementation works for undirected graphs only. The algorithm
+   in general should work for directed graphs as well though.
+ - Node keys for both provided graphs need to be fully orderable as well as
+   hashable.
+ - Node and edge equality is assumed to be transitive: if A is equal to B, and
+   B is equal to C, then A is equal to C.
+
+References
+----------
+    .. [1] M. Houbraken, S. Demeyer, T. Michoel, P. Audenaert, D. Colle,
+       M. Pickavet, "The Index-Based Subgraph Matching Algorithm with General
+       Symmetries (ISMAGS): Exploiting Symmetry for Faster Subgraph
+       Enumeration", PLoS One 9(5): e97896, 2014.
+       https://doi.org/10.1371/journal.pone.0097896
+    .. [2] https://en.wikipedia.org/wiki/Maximum_common_induced_subgraph
+"""
+
+__all__ = ["ISMAGS"]
+
+import itertools
+from collections import Counter, defaultdict
+from functools import reduce, wraps
+
+
+def are_all_equal(iterable):
+    """
+    Returns ``True`` if and only if all elements in `iterable` are equal; and
+    ``False`` otherwise.
+
+    Parameters
+    ----------
+    iterable: collections.abc.Iterable
+        The container whose elements will be checked.
+
+    Returns
+    -------
+    bool
+        ``True`` iff all elements in `iterable` compare equal, ``False``
+        otherwise.
+    """
+    try:
+        shape = iterable.shape
+    except AttributeError:
+        pass
+    else:
+        if len(shape) > 1:
+            message = "The function does not works on multidimension arrays."
+            raise NotImplementedError(message) from None
+
+    iterator = iter(iterable)
+    first = next(iterator, None)
+    return all(item == first for item in iterator)
+
+
+def make_partitions(items, test):
+    """
+    Partitions items into sets based on the outcome of ``test(item1, item2)``.
+    Pairs of items for which `test` returns `True` end up in the same set.
+
+    Parameters
+    ----------
+    items : collections.abc.Iterable[collections.abc.Hashable]
+        Items to partition
+    test : collections.abc.Callable[collections.abc.Hashable, collections.abc.Hashable]
+        A function that will be called with 2 arguments, taken from items.
+        Should return `True` if those 2 items need to end up in the same
+        partition, and `False` otherwise.
+
+    Returns
+    -------
+    list[set]
+        A list of sets, with each set containing part of the items in `items`,
+        such that ``all(test(*pair) for pair in  itertools.combinations(set, 2))
+        == True``
+
+    Notes
+    -----
+    The function `test` is assumed to be transitive: if ``test(a, b)`` and
+    ``test(b, c)`` return ``True``, then ``test(a, c)`` must also be ``True``.
+    """
+    partitions = []
+    for item in items:
+        for partition in partitions:
+            p_item = next(iter(partition))
+            if test(item, p_item):
+                partition.add(item)
+                break
+        else:  # No break
+            partitions.append({item})
+    return partitions
+
+
+def partition_to_color(partitions):
+    """
+    Creates a dictionary with for every item in partition for every partition
+    in partitions the index of partition in partitions.
+
+    Parameters
+    ----------
+    partitions: collections.abc.Sequence[collections.abc.Iterable]
+        As returned by :func:`make_partitions`.
+
+    Returns
+    -------
+    dict
+    """
+    colors = dict()
+    for color, keys in enumerate(partitions):
+        for key in keys:
+            colors[key] = color
+    return colors
+
+
+def intersect(collection_of_sets):
+    """
+    Given an collection of sets, returns the intersection of those sets.
+
+    Parameters
+    ----------
+    collection_of_sets: collections.abc.Collection[set]
+        A collection of sets.
+
+    Returns
+    -------
+    set
+        An intersection of all sets in `collection_of_sets`. Will have the same
+        type as the item initially taken from `collection_of_sets`.
+    """
+    collection_of_sets = list(collection_of_sets)
+    first = collection_of_sets.pop()
+    out = reduce(set.intersection, collection_of_sets, set(first))
+    return type(first)(out)
+
+
+class ISMAGS:
+    """
+    Implements the ISMAGS subgraph matching algorith. [1]_ ISMAGS stands for
+    "Index-based Subgraph Matching Algorithm with General Symmetries". As the
+    name implies, it is symmetry aware and will only generate non-symmetric
+    isomorphisms.
+
+    Notes
+    -----
+    The implementation imposes additional conditions compared to the VF2
+    algorithm on the graphs provided and the comparison functions
+    (:attr:`node_equality` and :attr:`edge_equality`):
+
+     - Node keys in both graphs must be orderable as well as hashable.
+     - Equality must be transitive: if A is equal to B, and B is equal to C,
+       then A must be equal to C.
+
+    Attributes
+    ----------
+    graph: networkx.Graph
+    subgraph: networkx.Graph
+    node_equality: collections.abc.Callable
+        The function called to see if two nodes should be considered equal.
+        It's signature looks like this:
+        ``f(graph1: networkx.Graph, node1, graph2: networkx.Graph, node2) -> bool``.
+        `node1` is a node in `graph1`, and `node2` a node in `graph2`.
+        Constructed from the argument `node_match`.
+    edge_equality: collections.abc.Callable
+        The function called to see if two edges should be considered equal.
+        It's signature looks like this:
+        ``f(graph1: networkx.Graph, edge1, graph2: networkx.Graph, edge2) -> bool``.
+        `edge1` is an edge in `graph1`, and `edge2` an edge in `graph2`.
+        Constructed from the argument `edge_match`.
+
+    References
+    ----------
+    .. [1] M. Houbraken, S. Demeyer, T. Michoel, P. Audenaert, D. Colle,
+       M. Pickavet, "The Index-Based Subgraph Matching Algorithm with General
+       Symmetries (ISMAGS): Exploiting Symmetry for Faster Subgraph
+       Enumeration", PLoS One 9(5): e97896, 2014.
+       https://doi.org/10.1371/journal.pone.0097896
+    """
+
+    def __init__(self, graph, subgraph, node_match=None, edge_match=None, cache=None):
+        """
+        Parameters
+        ----------
+        graph: networkx.Graph
+        subgraph: networkx.Graph
+        node_match: collections.abc.Callable or None
+            Function used to determine whether two nodes are equivalent. Its
+            signature should look like ``f(n1: dict, n2: dict) -> bool``, with
+            `n1` and `n2` node property dicts. See also
+            :func:`~networkx.algorithms.isomorphism.categorical_node_match` and
+            friends.
+            If `None`, all nodes are considered equal.
+        edge_match: collections.abc.Callable or None
+            Function used to determine whether two edges are equivalent. Its
+            signature should look like ``f(e1: dict, e2: dict) -> bool``, with
+            `e1` and `e2` edge property dicts. See also
+            :func:`~networkx.algorithms.isomorphism.categorical_edge_match` and
+            friends.
+            If `None`, all edges are considered equal.
+        cache: collections.abc.Mapping
+            A cache used for caching graph symmetries.
+        """
+        # TODO: graph and subgraph setter methods that invalidate the caches.
+        # TODO: allow for precomputed partitions and colors
+        self.graph = graph
+        self.subgraph = subgraph
+        self._symmetry_cache = cache
+        # Naming conventions are taken from the original paper. For your
+        # sanity:
+        #   sg: subgraph
+        #   g: graph
+        #   e: edge(s)
+        #   n: node(s)
+        # So: sgn means "subgraph nodes".
+        self._sgn_partitions_ = None
+        self._sge_partitions_ = None
+
+        self._sgn_colors_ = None
+        self._sge_colors_ = None
+
+        self._gn_partitions_ = None
+        self._ge_partitions_ = None
+
+        self._gn_colors_ = None
+        self._ge_colors_ = None
+
+        self._node_compat_ = None
+        self._edge_compat_ = None
+
+        if node_match is None:
+            self.node_equality = self._node_match_maker(lambda n1, n2: True)
+            self._sgn_partitions_ = [set(self.subgraph.nodes)]
+            self._gn_partitions_ = [set(self.graph.nodes)]
+            self._node_compat_ = {0: 0}
+        else:
+            self.node_equality = self._node_match_maker(node_match)
+        if edge_match is None:
+            self.edge_equality = self._edge_match_maker(lambda e1, e2: True)
+            self._sge_partitions_ = [set(self.subgraph.edges)]
+            self._ge_partitions_ = [set(self.graph.edges)]
+            self._edge_compat_ = {0: 0}
+        else:
+            self.edge_equality = self._edge_match_maker(edge_match)
+
+    @property
+    def _sgn_partitions(self):
+        if self._sgn_partitions_ is None:
+
+            def nodematch(node1, node2):
+                return self.node_equality(self.subgraph, node1, self.subgraph, node2)
+
+            self._sgn_partitions_ = make_partitions(self.subgraph.nodes, nodematch)
+        return self._sgn_partitions_
+
+    @property
+    def _sge_partitions(self):
+        if self._sge_partitions_ is None:
+
+            def edgematch(edge1, edge2):
+                return self.edge_equality(self.subgraph, edge1, self.subgraph, edge2)
+
+            self._sge_partitions_ = make_partitions(self.subgraph.edges, edgematch)
+        return self._sge_partitions_
+
+    @property
+    def _gn_partitions(self):
+        if self._gn_partitions_ is None:
+
+            def nodematch(node1, node2):
+                return self.node_equality(self.graph, node1, self.graph, node2)
+
+            self._gn_partitions_ = make_partitions(self.graph.nodes, nodematch)
+        return self._gn_partitions_
+
+    @property
+    def _ge_partitions(self):
+        if self._ge_partitions_ is None:
+
+            def edgematch(edge1, edge2):
+                return self.edge_equality(self.graph, edge1, self.graph, edge2)
+
+            self._ge_partitions_ = make_partitions(self.graph.edges, edgematch)
+        return self._ge_partitions_
+
+    @property
+    def _sgn_colors(self):
+        if self._sgn_colors_ is None:
+            self._sgn_colors_ = partition_to_color(self._sgn_partitions)
+        return self._sgn_colors_
+
+    @property
+    def _sge_colors(self):
+        if self._sge_colors_ is None:
+            self._sge_colors_ = partition_to_color(self._sge_partitions)
+        return self._sge_colors_
+
+    @property
+    def _gn_colors(self):
+        if self._gn_colors_ is None:
+            self._gn_colors_ = partition_to_color(self._gn_partitions)
+        return self._gn_colors_
+
+    @property
+    def _ge_colors(self):
+        if self._ge_colors_ is None:
+            self._ge_colors_ = partition_to_color(self._ge_partitions)
+        return self._ge_colors_
+
+    @property
+    def _node_compatibility(self):
+        if self._node_compat_ is not None:
+            return self._node_compat_
+        self._node_compat_ = {}
+        for sgn_part_color, gn_part_color in itertools.product(
+            range(len(self._sgn_partitions)), range(len(self._gn_partitions))
+        ):
+            sgn = next(iter(self._sgn_partitions[sgn_part_color]))
+            gn = next(iter(self._gn_partitions[gn_part_color]))
+            if self.node_equality(self.subgraph, sgn, self.graph, gn):
+                self._node_compat_[sgn_part_color] = gn_part_color
+        return self._node_compat_
+
+    @property
+    def _edge_compatibility(self):
+        if self._edge_compat_ is not None:
+            return self._edge_compat_
+        self._edge_compat_ = {}
+        for sge_part_color, ge_part_color in itertools.product(
+            range(len(self._sge_partitions)), range(len(self._ge_partitions))
+        ):
+            sge = next(iter(self._sge_partitions[sge_part_color]))
+            ge = next(iter(self._ge_partitions[ge_part_color]))
+            if self.edge_equality(self.subgraph, sge, self.graph, ge):
+                self._edge_compat_[sge_part_color] = ge_part_color
+        return self._edge_compat_
+
+    @staticmethod
+    def _node_match_maker(cmp):
+        @wraps(cmp)
+        def comparer(graph1, node1, graph2, node2):
+            return cmp(graph1.nodes[node1], graph2.nodes[node2])
+
+        return comparer
+
+    @staticmethod
+    def _edge_match_maker(cmp):
+        @wraps(cmp)
+        def comparer(graph1, edge1, graph2, edge2):
+            return cmp(graph1.edges[edge1], graph2.edges[edge2])
+
+        return comparer
+
+    def find_isomorphisms(self, symmetry=True):
+        """Find all subgraph isomorphisms between subgraph and graph
+
+        Finds isomorphisms where :attr:`subgraph` <= :attr:`graph`.
+
+        Parameters
+        ----------
+        symmetry: bool
+            Whether symmetry should be taken into account. If False, found
+            isomorphisms may be symmetrically equivalent.
+
+        Yields
+        ------
+        dict
+            The found isomorphism mappings of {graph_node: subgraph_node}.
+        """
+        # The networkx VF2 algorithm is slightly funny in when it yields an
+        # empty dict and when not.
+        if not self.subgraph:
+            yield {}
+            return
+        elif not self.graph:
+            return
+        elif len(self.graph) < len(self.subgraph):
+            return
+
+        if symmetry:
+            _, cosets = self.analyze_symmetry(
+                self.subgraph, self._sgn_partitions, self._sge_colors
+            )
+            constraints = self._make_constraints(cosets)
+        else:
+            constraints = []
+
+        candidates = self._find_nodecolor_candidates()
+        la_candidates = self._get_lookahead_candidates()
+        for sgn in self.subgraph:
+            extra_candidates = la_candidates[sgn]
+            if extra_candidates:
+                candidates[sgn] = candidates[sgn] | {frozenset(extra_candidates)}
+
+        if any(candidates.values()):
+            start_sgn = min(candidates, key=lambda n: min(candidates[n], key=len))
+            candidates[start_sgn] = (intersect(candidates[start_sgn]),)
+            yield from self._map_nodes(start_sgn, candidates, constraints)
+        else:
+            return
+
+    @staticmethod
+    def _find_neighbor_color_count(graph, node, node_color, edge_color):
+        """
+        For `node` in `graph`, count the number of edges of a specific color
+        it has to nodes of a specific color.
+        """
+        counts = Counter()
+        neighbors = graph[node]
+        for neighbor in neighbors:
+            n_color = node_color[neighbor]
+            if (node, neighbor) in edge_color:
+                e_color = edge_color[node, neighbor]
+            else:
+                e_color = edge_color[neighbor, node]
+            counts[e_color, n_color] += 1
+        return counts
+
+    def _get_lookahead_candidates(self):
+        """
+        Returns a mapping of {subgraph node: collection of graph nodes} for
+        which the graph nodes are feasible candidates for the subgraph node, as
+        determined by looking ahead one edge.
+        """
+        g_counts = {}
+        for gn in self.graph:
+            g_counts[gn] = self._find_neighbor_color_count(
+                self.graph, gn, self._gn_colors, self._ge_colors
+            )
+        candidates = defaultdict(set)
+        for sgn in self.subgraph:
+            sg_count = self._find_neighbor_color_count(
+                self.subgraph, sgn, self._sgn_colors, self._sge_colors
+            )
+            new_sg_count = Counter()
+            for (sge_color, sgn_color), count in sg_count.items():
+                try:
+                    ge_color = self._edge_compatibility[sge_color]
+                    gn_color = self._node_compatibility[sgn_color]
+                except KeyError:
+                    pass
+                else:
+                    new_sg_count[ge_color, gn_color] = count
+
+            for gn, g_count in g_counts.items():
+                if all(new_sg_count[x] <= g_count[x] for x in new_sg_count):
+                    # Valid candidate
+                    candidates[sgn].add(gn)
+        return candidates
+
+    def largest_common_subgraph(self, symmetry=True):
+        """
+        Find the largest common induced subgraphs between :attr:`subgraph` and
+        :attr:`graph`.
+
+        Parameters
+        ----------
+        symmetry: bool
+            Whether symmetry should be taken into account. If False, found
+            largest common subgraphs may be symmetrically equivalent.
+
+        Yields
+        ------
+        dict
+            The found isomorphism mappings of {graph_node: subgraph_node}.
+        """
+        # The networkx VF2 algorithm is slightly funny in when it yields an
+        # empty dict and when not.
+        if not self.subgraph:
+            yield {}
+            return
+        elif not self.graph:
+            return
+
+        if symmetry:
+            _, cosets = self.analyze_symmetry(
+                self.subgraph, self._sgn_partitions, self._sge_colors
+            )
+            constraints = self._make_constraints(cosets)
+        else:
+            constraints = []
+
+        candidates = self._find_nodecolor_candidates()
+
+        if any(candidates.values()):
+            yield from self._largest_common_subgraph(candidates, constraints)
+        else:
+            return
+
+    def analyze_symmetry(self, graph, node_partitions, edge_colors):
+        """
+        Find a minimal set of permutations and corresponding co-sets that
+        describe the symmetry of `graph`, given the node and edge equalities
+        given by `node_partitions` and `edge_colors`, respectively.
+
+        Parameters
+        ----------
+        graph : networkx.Graph
+            The graph whose symmetry should be analyzed.
+        node_partitions : list of sets
+            A list of sets containining node keys. Node keys in the same set
+            are considered equivalent. Every node key in `graph` should be in
+            exactly one of the sets. If all nodes are equivalent, this should
+            be ``[set(graph.nodes)]``.
+        edge_colors : dict mapping edges to their colors
+            A dict mapping every edge in `graph` to its corresponding color.
+            Edges with the same color are considered equivalent. If all edges
+            are equivalent, this should be ``{e: 0 for e in graph.edges}``.
+
+
+        Returns
+        -------
+        set[frozenset]
+            The found permutations. This is a set of frozensets of pairs of node
+            keys which can be exchanged without changing :attr:`subgraph`.
+        dict[collections.abc.Hashable, set[collections.abc.Hashable]]
+            The found co-sets. The co-sets is a dictionary of
+            ``{node key: set of node keys}``.
+            Every key-value pair describes which ``values`` can be interchanged
+            without changing nodes less than ``key``.
+        """
+        if self._symmetry_cache is not None:
+            key = hash(
+                (
+                    tuple(graph.nodes),
+                    tuple(graph.edges),
+                    tuple(map(tuple, node_partitions)),
+                    tuple(edge_colors.items()),
+                )
+            )
+            if key in self._symmetry_cache:
+                return self._symmetry_cache[key]
+        node_partitions = list(
+            self._refine_node_partitions(graph, node_partitions, edge_colors)
+        )
+        assert len(node_partitions) == 1
+        node_partitions = node_partitions[0]
+        permutations, cosets = self._process_ordered_pair_partitions(
+            graph, node_partitions, node_partitions, edge_colors
+        )
+        if self._symmetry_cache is not None:
+            self._symmetry_cache[key] = permutations, cosets
+        return permutations, cosets
+
+    def is_isomorphic(self, symmetry=False):
+        """
+        Returns True if :attr:`graph` is isomorphic to :attr:`subgraph` and
+        False otherwise.
+
+        Returns
+        -------
+        bool
+        """
+        return len(self.subgraph) == len(self.graph) and self.subgraph_is_isomorphic(
+            symmetry
+        )
+
+    def subgraph_is_isomorphic(self, symmetry=False):
+        """
+        Returns True if a subgraph of :attr:`graph` is isomorphic to
+        :attr:`subgraph` and False otherwise.
+
+        Returns
+        -------
+        bool
+        """
+        # symmetry=False, since we only need to know whether there is any
+        # example; figuring out all symmetry elements probably costs more time
+        # than it gains.
+        isom = next(self.subgraph_isomorphisms_iter(symmetry=symmetry), None)
+        return isom is not None
+
+    def isomorphisms_iter(self, symmetry=True):
+        """
+        Does the same as :meth:`find_isomorphisms` if :attr:`graph` and
+        :attr:`subgraph` have the same number of nodes.
+        """
+        if len(self.graph) == len(self.subgraph):
+            yield from self.subgraph_isomorphisms_iter(symmetry=symmetry)
+
+    def subgraph_isomorphisms_iter(self, symmetry=True):
+        """Alternative name for :meth:`find_isomorphisms`."""
+        return self.find_isomorphisms(symmetry)
+
+    def _find_nodecolor_candidates(self):
+        """
+        Per node in subgraph find all nodes in graph that have the same color.
+        """
+        candidates = defaultdict(set)
+        for sgn in self.subgraph.nodes:
+            sgn_color = self._sgn_colors[sgn]
+            if sgn_color in self._node_compatibility:
+                gn_color = self._node_compatibility[sgn_color]
+                candidates[sgn].add(frozenset(self._gn_partitions[gn_color]))
+            else:
+                candidates[sgn].add(frozenset())
+        candidates = dict(candidates)
+        for sgn, options in candidates.items():
+            candidates[sgn] = frozenset(options)
+        return candidates
+
+    @staticmethod
+    def _make_constraints(cosets):
+        """
+        Turn cosets into constraints.
+        """
+        constraints = []
+        for node_i, node_ts in cosets.items():
+            for node_t in node_ts:
+                if node_i != node_t:
+                    # Node i must be smaller than node t.
+                    constraints.append((node_i, node_t))
+        return constraints
+
+    @staticmethod
+    def _find_node_edge_color(graph, node_colors, edge_colors):
+        """
+        For every node in graph, come up with a color that combines 1) the
+        color of the node, and 2) the number of edges of a color to each type
+        of node.
+        """
+        counts = defaultdict(lambda: defaultdict(int))
+        for node1, node2 in graph.edges:
+            if (node1, node2) in edge_colors:
+                # FIXME directed graphs
+                ecolor = edge_colors[node1, node2]
+            else:
+                ecolor = edge_colors[node2, node1]
+            # Count per node how many edges it has of what color to nodes of
+            # what color
+            counts[node1][ecolor, node_colors[node2]] += 1
+            counts[node2][ecolor, node_colors[node1]] += 1
+
+        node_edge_colors = dict()
+        for node in graph.nodes:
+            node_edge_colors[node] = node_colors[node], set(counts[node].items())
+
+        return node_edge_colors
+
+    @staticmethod
+    def _get_permutations_by_length(items):
+        """
+        Get all permutations of items, but only permute items with the same
+        length.
+
+        >>> found = list(ISMAGS._get_permutations_by_length([[1], [2], [3, 4], [4, 5]]))
+        >>> answer = [
+        ...     (([1], [2]), ([3, 4], [4, 5])),
+        ...     (([1], [2]), ([4, 5], [3, 4])),
+        ...     (([2], [1]), ([3, 4], [4, 5])),
+        ...     (([2], [1]), ([4, 5], [3, 4])),
+        ... ]
+        >>> found == answer
+        True
+        """
+        by_len = defaultdict(list)
+        for item in items:
+            by_len[len(item)].append(item)
+
+        yield from itertools.product(
+            *(itertools.permutations(by_len[l]) for l in sorted(by_len))
+        )
+
+    @classmethod
+    def _refine_node_partitions(cls, graph, node_partitions, edge_colors, branch=False):
+        """
+        Given a partition of nodes in graph, make the partitions smaller such
+        that all nodes in a partition have 1) the same color, and 2) the same
+        number of edges to specific other partitions.
+        """
+
+        def equal_color(node1, node2):
+            return node_edge_colors[node1] == node_edge_colors[node2]
+
+        node_partitions = list(node_partitions)
+        node_colors = partition_to_color(node_partitions)
+        node_edge_colors = cls._find_node_edge_color(graph, node_colors, edge_colors)
+        if all(
+            are_all_equal(node_edge_colors[node] for node in partition)
+            for partition in node_partitions
+        ):
+            yield node_partitions
+            return
+
+        new_partitions = []
+        output = [new_partitions]
+        for partition in node_partitions:
+            if not are_all_equal(node_edge_colors[node] for node in partition):
+                refined = make_partitions(partition, equal_color)
+                if (
+                    branch
+                    and len(refined) != 1
+                    and len({len(r) for r in refined}) != len([len(r) for r in refined])
+                ):
+                    # This is where it breaks. There are multiple new cells
+                    # in refined with the same length, and their order
+                    # matters.
+                    # So option 1) Hit it with a big hammer and simply make all
+                    # orderings.
+                    permutations = cls._get_permutations_by_length(refined)
+                    new_output = []
+                    for n_p in output:
+                        for permutation in permutations:
+                            new_output.append(n_p + list(permutation[0]))
+                    output = new_output
+                else:
+                    for n_p in output:
+                        n_p.extend(sorted(refined, key=len))
+            else:
+                for n_p in output:
+                    n_p.append(partition)
+        for n_p in output:
+            yield from cls._refine_node_partitions(graph, n_p, edge_colors, branch)
+
+    def _edges_of_same_color(self, sgn1, sgn2):
+        """
+        Returns all edges in :attr:`graph` that have the same colour as the
+        edge between sgn1 and sgn2 in :attr:`subgraph`.
+        """
+        if (sgn1, sgn2) in self._sge_colors:
+            # FIXME directed graphs
+            sge_color = self._sge_colors[sgn1, sgn2]
+        else:
+            sge_color = self._sge_colors[sgn2, sgn1]
+        if sge_color in self._edge_compatibility:
+            ge_color = self._edge_compatibility[sge_color]
+            g_edges = self._ge_partitions[ge_color]
+        else:
+            g_edges = []
+        return g_edges
+
+    def _map_nodes(self, sgn, candidates, constraints, mapping=None, to_be_mapped=None):
+        """
+        Find all subgraph isomorphisms honoring constraints.
+        """
+        if mapping is None:
+            mapping = {}
+        else:
+            mapping = mapping.copy()
+        if to_be_mapped is None:
+            to_be_mapped = set(self.subgraph.nodes)
+
+        # Note, we modify candidates here. Doesn't seem to affect results, but
+        # remember this.
+        # candidates = candidates.copy()
+        sgn_candidates = intersect(candidates[sgn])
+        candidates[sgn] = frozenset([sgn_candidates])
+        for gn in sgn_candidates:
+            # We're going to try to map sgn to gn.
+            if gn in mapping.values() or sgn not in to_be_mapped:
+                # gn is already mapped to something
+                continue  # pragma: no cover
+
+            # REDUCTION and COMBINATION
+            mapping[sgn] = gn
+            # BASECASE
+            if to_be_mapped == set(mapping.keys()):
+                yield {v: k for k, v in mapping.items()}
+                continue
+            left_to_map = to_be_mapped - set(mapping.keys())
+
+            new_candidates = candidates.copy()
+            sgn_neighbours = set(self.subgraph[sgn])
+            not_gn_neighbours = set(self.graph.nodes) - set(self.graph[gn])
+            for sgn2 in left_to_map:
+                if sgn2 not in sgn_neighbours:
+                    gn2_options = not_gn_neighbours
+                else:
+                    # Get all edges to gn of the right color:
+                    g_edges = self._edges_of_same_color(sgn, sgn2)
+                    # FIXME directed graphs
+                    # And all nodes involved in those which are connected to gn
+                    gn2_options = {n for e in g_edges for n in e if gn in e}
+                # Node color compatibility should be taken care of by the
+                # initial candidate lists made by find_subgraphs
+
+                # Add gn2_options to the right collection. Since new_candidates
+                # is a dict of frozensets of frozensets of node indices it's
+                # a bit clunky. We can't do .add, and + also doesn't work. We
+                # could do |, but I deem union to be clearer.
+                new_candidates[sgn2] = new_candidates[sgn2].union(
+                    [frozenset(gn2_options)]
+                )
+
+                if (sgn, sgn2) in constraints:
+                    gn2_options = {gn2 for gn2 in self.graph if gn2 > gn}
+                elif (sgn2, sgn) in constraints:
+                    gn2_options = {gn2 for gn2 in self.graph if gn2 < gn}
+                else:
+                    continue  # pragma: no cover
+                new_candidates[sgn2] = new_candidates[sgn2].union(
+                    [frozenset(gn2_options)]
+                )
+
+            # The next node is the one that is unmapped and has fewest
+            # candidates
+            # Pylint disables because it's a one-shot function.
+            next_sgn = min(
+                left_to_map, key=lambda n: min(new_candidates[n], key=len)
+            )  # pylint: disable=cell-var-from-loop
+            yield from self._map_nodes(
+                next_sgn,
+                new_candidates,
+                constraints,
+                mapping=mapping,
+                to_be_mapped=to_be_mapped,
+            )
+            # Unmap sgn-gn. Strictly not necessary since it'd get overwritten
+            # when making a new mapping for sgn.
+            # del mapping[sgn]
+
+    def _largest_common_subgraph(self, candidates, constraints, to_be_mapped=None):
+        """
+        Find all largest common subgraphs honoring constraints.
+        """
+        if to_be_mapped is None:
+            to_be_mapped = {frozenset(self.subgraph.nodes)}
+
+        # The LCS problem is basically a repeated subgraph isomorphism problem
+        # with smaller and smaller subgraphs. We store the nodes that are
+        # "part of" the subgraph in to_be_mapped, and we make it a little
+        # smaller every iteration.
+
+        # pylint disable becuase it's guarded against by default value
+        current_size = len(
+            next(iter(to_be_mapped), [])
+        )  # pylint: disable=stop-iteration-return
+
+        found_iso = False
+        if current_size <= len(self.graph):
+            # There's no point in trying to find isomorphisms of
+            # graph >= subgraph if subgraph has more nodes than graph.
+
+            # Try the isomorphism first with the nodes with lowest ID. So sort
+            # them. Those are more likely to be part of the final
+            # correspondence. This makes finding the first answer(s) faster. In
+            # theory.
+            for nodes in sorted(to_be_mapped, key=sorted):
+                # Find the isomorphism between subgraph[to_be_mapped] <= graph
+                next_sgn = min(nodes, key=lambda n: min(candidates[n], key=len))
+                isomorphs = self._map_nodes(
+                    next_sgn, candidates, constraints, to_be_mapped=nodes
+                )
+
+                # This is effectively `yield from isomorphs`, except that we look
+                # whether an item was yielded.
+                try:
+                    item = next(isomorphs)
+                except StopIteration:
+                    pass
+                else:
+                    yield item
+                    yield from isomorphs
+                    found_iso = True
+
+        # BASECASE
+        if found_iso or current_size == 1:
+            # Shrinking has no point because either 1) we end up with a smaller
+            # common subgraph (and we want the largest), or 2) there'll be no
+            # more subgraph.
+            return
+
+        left_to_be_mapped = set()
+        for nodes in to_be_mapped:
+            for sgn in nodes:
+                # We're going to remove sgn from to_be_mapped, but subject to
+                # symmetry constraints. We know that for every constraint we
+                # have those subgraph nodes are equal. So whenever we would
+                # remove the lower part of a constraint, remove the higher
+                # instead. This is all dealth with by _remove_node. And because
+                # left_to_be_mapped is a set, we don't do double work.
+
+                # And finally, make the subgraph one node smaller.
+                # REDUCTION
+                new_nodes = self._remove_node(sgn, nodes, constraints)
+                left_to_be_mapped.add(new_nodes)
+        # COMBINATION
+        yield from self._largest_common_subgraph(
+            candidates, constraints, to_be_mapped=left_to_be_mapped
+        )
+
+    @staticmethod
+    def _remove_node(node, nodes, constraints):
+        """
+        Returns a new set where node has been removed from nodes, subject to
+        symmetry constraints. We know, that for every constraint we have
+        those subgraph nodes are equal. So whenever we would remove the
+        lower part of a constraint, remove the higher instead.
+        """
+        while True:
+            for low, high in constraints:
+                if low == node and high in nodes:
+                    node = high
+                    break
+            else:  # no break, couldn't find node in constraints
+                break
+        return frozenset(nodes - {node})
+
+    @staticmethod
+    def _find_permutations(top_partitions, bottom_partitions):
+        """
+        Return the pairs of top/bottom partitions where the partitions are
+        different. Ensures that all partitions in both top and bottom
+        partitions have size 1.
+        """
+        # Find permutations
+        permutations = set()
+        for top, bot in zip(top_partitions, bottom_partitions):
+            # top and bot have only one element
+            if len(top) != 1 or len(bot) != 1:
+                raise IndexError(
+                    "Not all nodes are coupled. This is"
+                    f" impossible: {top_partitions}, {bottom_partitions}"
+                )
+            if top != bot:
+                permutations.add(frozenset((next(iter(top)), next(iter(bot)))))
+        return permutations
+
+    @staticmethod
+    def _update_orbits(orbits, permutations):
+        """
+        Update orbits based on permutations. Orbits is modified in place.
+        For every pair of items in permutations their respective orbits are
+        merged.
+        """
+        for permutation in permutations:
+            node, node2 = permutation
+            # Find the orbits that contain node and node2, and replace the
+            # orbit containing node with the union
+            first = second = None
+            for idx, orbit in enumerate(orbits):
+                if first is not None and second is not None:
+                    break
+                if node in orbit:
+                    first = idx
+                if node2 in orbit:
+                    second = idx
+            if first != second:
+                orbits[first].update(orbits[second])
+                del orbits[second]
+
+    def _couple_nodes(
+        self,
+        top_partitions,
+        bottom_partitions,
+        pair_idx,
+        t_node,
+        b_node,
+        graph,
+        edge_colors,
+    ):
+        """
+        Generate new partitions from top and bottom_partitions where t_node is
+        coupled to b_node. pair_idx is the index of the partitions where t_ and
+        b_node can be found.
+        """
+        t_partition = top_partitions[pair_idx]
+        b_partition = bottom_partitions[pair_idx]
+        assert t_node in t_partition and b_node in b_partition
+        # Couple node to node2. This means they get their own partition
+        new_top_partitions = [top.copy() for top in top_partitions]
+        new_bottom_partitions = [bot.copy() for bot in bottom_partitions]
+        new_t_groups = {t_node}, t_partition - {t_node}
+        new_b_groups = {b_node}, b_partition - {b_node}
+        # Replace the old partitions with the coupled ones
+        del new_top_partitions[pair_idx]
+        del new_bottom_partitions[pair_idx]
+        new_top_partitions[pair_idx:pair_idx] = new_t_groups
+        new_bottom_partitions[pair_idx:pair_idx] = new_b_groups
+
+        new_top_partitions = self._refine_node_partitions(
+            graph, new_top_partitions, edge_colors
+        )
+        new_bottom_partitions = self._refine_node_partitions(
+            graph, new_bottom_partitions, edge_colors, branch=True
+        )
+        new_top_partitions = list(new_top_partitions)
+        assert len(new_top_partitions) == 1
+        new_top_partitions = new_top_partitions[0]
+        for bot in new_bottom_partitions:
+            yield list(new_top_partitions), bot
+
+    def _process_ordered_pair_partitions(
+        self,
+        graph,
+        top_partitions,
+        bottom_partitions,
+        edge_colors,
+        orbits=None,
+        cosets=None,
+    ):
+        """
+        Processes ordered pair partitions as per the reference paper. Finds and
+        returns all permutations and cosets that leave the graph unchanged.
+        """
+        if orbits is None:
+            orbits = [{node} for node in graph.nodes]
+        else:
+            # Note that we don't copy orbits when we are given one. This means
+            # we leak information between the recursive branches. This is
+            # intentional!
+            orbits = orbits
+        if cosets is None:
+            cosets = {}
+        else:
+            cosets = cosets.copy()
+
+        assert all(
+            len(t_p) == len(b_p) for t_p, b_p in zip(top_partitions, bottom_partitions)
+        )
+
+        # BASECASE
+        if all(len(top) == 1 for top in top_partitions):
+            # All nodes are mapped
+            permutations = self._find_permutations(top_partitions, bottom_partitions)
+            self._update_orbits(orbits, permutations)
+            if permutations:
+                return [permutations], cosets
+            else:
+                return [], cosets
+
+        permutations = []
+        unmapped_nodes = {
+            (node, idx)
+            for idx, t_partition in enumerate(top_partitions)
+            for node in t_partition
+            if len(t_partition) > 1
+        }
+        node, pair_idx = min(unmapped_nodes)
+        b_partition = bottom_partitions[pair_idx]
+
+        for node2 in sorted(b_partition):
+            if len(b_partition) == 1:
+                # Can never result in symmetry
+                continue
+            if node != node2 and any(
+                node in orbit and node2 in orbit for orbit in orbits
+            ):
+                # Orbit prune branch
+                continue
+            # REDUCTION
+            # Couple node to node2
+            partitions = self._couple_nodes(
+                top_partitions,
+                bottom_partitions,
+                pair_idx,
+                node,
+                node2,
+                graph,
+                edge_colors,
+            )
+            for opp in partitions:
+                new_top_partitions, new_bottom_partitions = opp
+
+                new_perms, new_cosets = self._process_ordered_pair_partitions(
+                    graph,
+                    new_top_partitions,
+                    new_bottom_partitions,
+                    edge_colors,
+                    orbits,
+                    cosets,
+                )
+                # COMBINATION
+                permutations += new_perms
+                cosets.update(new_cosets)
+
+        mapped = {
+            k
+            for top, bottom in zip(top_partitions, bottom_partitions)
+            for k in top
+            if len(top) == 1 and top == bottom
+        }
+        ks = {k for k in graph.nodes if k < node}
+        # Have all nodes with ID < node been mapped?
+        find_coset = ks <= mapped and node not in cosets
+        if find_coset:
+            # Find the orbit that contains node
+            for orbit in orbits:
+                if node in orbit:
+                    cosets[node] = orbit.copy()
+        return permutations, cosets
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/isomorph.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/isomorph.py
new file mode 100644
index 0000000..1b9a727
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/isomorph.py
@@ -0,0 +1,233 @@
+"""
+Graph isomorphism functions.
+"""
+import networkx as nx
+from networkx.exception import NetworkXError
+
+__all__ = [
+    "could_be_isomorphic",
+    "fast_could_be_isomorphic",
+    "faster_could_be_isomorphic",
+    "is_isomorphic",
+]
+
+
+def could_be_isomorphic(G1, G2):
+    """Returns False if graphs are definitely not isomorphic.
+    True does NOT guarantee isomorphism.
+
+    Parameters
+    ----------
+    G1, G2 : graphs
+       The two graphs G1 and G2 must be the same type.
+
+    Notes
+    -----
+    Checks for matching degree, triangle, and number of cliques sequences.
+    """
+
+    # Check global properties
+    if G1.order() != G2.order():
+        return False
+
+    # Check local properties
+    d1 = G1.degree()
+    t1 = nx.triangles(G1)
+    c1 = nx.number_of_cliques(G1)
+    props1 = [[d, t1[v], c1[v]] for v, d in d1]
+    props1.sort()
+
+    d2 = G2.degree()
+    t2 = nx.triangles(G2)
+    c2 = nx.number_of_cliques(G2)
+    props2 = [[d, t2[v], c2[v]] for v, d in d2]
+    props2.sort()
+
+    if props1 != props2:
+        return False
+
+    # OK...
+    return True
+
+
+graph_could_be_isomorphic = could_be_isomorphic
+
+
+def fast_could_be_isomorphic(G1, G2):
+    """Returns False if graphs are definitely not isomorphic.
+
+    True does NOT guarantee isomorphism.
+
+    Parameters
+    ----------
+    G1, G2 : graphs
+       The two graphs G1 and G2 must be the same type.
+
+    Notes
+    -----
+    Checks for matching degree and triangle sequences.
+    """
+    # Check global properties
+    if G1.order() != G2.order():
+        return False
+
+    # Check local properties
+    d1 = G1.degree()
+    t1 = nx.triangles(G1)
+    props1 = [[d, t1[v]] for v, d in d1]
+    props1.sort()
+
+    d2 = G2.degree()
+    t2 = nx.triangles(G2)
+    props2 = [[d, t2[v]] for v, d in d2]
+    props2.sort()
+
+    if props1 != props2:
+        return False
+
+    # OK...
+    return True
+
+
+fast_graph_could_be_isomorphic = fast_could_be_isomorphic
+
+
+def faster_could_be_isomorphic(G1, G2):
+    """Returns False if graphs are definitely not isomorphic.
+
+    True does NOT guarantee isomorphism.
+
+    Parameters
+    ----------
+    G1, G2 : graphs
+       The two graphs G1 and G2 must be the same type.
+
+    Notes
+    -----
+    Checks for matching degree sequences.
+    """
+    # Check global properties
+    if G1.order() != G2.order():
+        return False
+
+    # Check local properties
+    d1 = sorted(d for n, d in G1.degree())
+    d2 = sorted(d for n, d in G2.degree())
+
+    if d1 != d2:
+        return False
+
+    # OK...
+    return True
+
+
+faster_graph_could_be_isomorphic = faster_could_be_isomorphic
+
+
+def is_isomorphic(G1, G2, node_match=None, edge_match=None):
+    """Returns True if the graphs G1 and G2 are isomorphic and False otherwise.
+
+    Parameters
+    ----------
+    G1, G2: graphs
+        The two graphs G1 and G2 must be the same type.
+
+    node_match : callable
+        A function that returns True if node n1 in G1 and n2 in G2 should
+        be considered equal during the isomorphism test.
+        If node_match is not specified then node attributes are not considered.
+
+        The function will be called like
+
+           node_match(G1.nodes[n1], G2.nodes[n2]).
+
+        That is, the function will receive the node attribute dictionaries
+        for n1 and n2 as inputs.
+
+    edge_match : callable
+        A function that returns True if the edge attribute dictionary
+        for the pair of nodes (u1, v1) in G1 and (u2, v2) in G2 should
+        be considered equal during the isomorphism test.  If edge_match is
+        not specified then edge attributes are not considered.
+
+        The function will be called like
+
+           edge_match(G1[u1][v1], G2[u2][v2]).
+
+        That is, the function will receive the edge attribute dictionaries
+        of the edges under consideration.
+
+    Notes
+    -----
+    Uses the vf2 algorithm [1]_.
+
+    Examples
+    --------
+    >>> import networkx.algorithms.isomorphism as iso
+
+    For digraphs G1 and G2, using 'weight' edge attribute (default: 1)
+
+    >>> G1 = nx.DiGraph()
+    >>> G2 = nx.DiGraph()
+    >>> nx.add_path(G1, [1, 2, 3, 4], weight=1)
+    >>> nx.add_path(G2, [10, 20, 30, 40], weight=2)
+    >>> em = iso.numerical_edge_match("weight", 1)
+    >>> nx.is_isomorphic(G1, G2)  # no weights considered
+    True
+    >>> nx.is_isomorphic(G1, G2, edge_match=em)  # match weights
+    False
+
+    For multidigraphs G1 and G2, using 'fill' node attribute (default: '')
+
+    >>> G1 = nx.MultiDiGraph()
+    >>> G2 = nx.MultiDiGraph()
+    >>> G1.add_nodes_from([1, 2, 3], fill="red")
+    >>> G2.add_nodes_from([10, 20, 30, 40], fill="red")
+    >>> nx.add_path(G1, [1, 2, 3, 4], weight=3, linewidth=2.5)
+    >>> nx.add_path(G2, [10, 20, 30, 40], weight=3)
+    >>> nm = iso.categorical_node_match("fill", "red")
+    >>> nx.is_isomorphic(G1, G2, node_match=nm)
+    True
+
+    For multidigraphs G1 and G2, using 'weight' edge attribute (default: 7)
+
+    >>> G1.add_edge(1, 2, weight=7)
+    1
+    >>> G2.add_edge(10, 20)
+    1
+    >>> em = iso.numerical_multiedge_match("weight", 7, rtol=1e-6)
+    >>> nx.is_isomorphic(G1, G2, edge_match=em)
+    True
+
+    For multigraphs G1 and G2, using 'weight' and 'linewidth' edge attributes
+    with default values 7 and 2.5. Also using 'fill' node attribute with
+    default value 'red'.
+
+    >>> em = iso.numerical_multiedge_match(["weight", "linewidth"], [7, 2.5])
+    >>> nm = iso.categorical_node_match("fill", "red")
+    >>> nx.is_isomorphic(G1, G2, edge_match=em, node_match=nm)
+    True
+
+    See Also
+    --------
+    numerical_node_match, numerical_edge_match, numerical_multiedge_match
+    categorical_node_match, categorical_edge_match, categorical_multiedge_match
+
+    References
+    ----------
+    .. [1]  L. P. Cordella, P. Foggia, C. Sansone, M. Vento,
+       "An Improved Algorithm for Matching Large Graphs",
+       3rd IAPR-TC15 Workshop  on Graph-based Representations in
+       Pattern Recognition, Cuen, pp. 149-159, 2001.
+       https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.101.5342
+    """
+    if G1.is_directed() and G2.is_directed():
+        GM = nx.algorithms.isomorphism.DiGraphMatcher
+    elif (not G1.is_directed()) and (not G2.is_directed()):
+        GM = nx.algorithms.isomorphism.GraphMatcher
+    else:
+        raise NetworkXError("Graphs G1 and G2 are not of the same type.")
+
+    gm = GM(G1, G2, node_match=node_match, edge_match=edge_match)
+
+    return gm.is_isomorphic()
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/isomorphvf2.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/isomorphvf2.py
new file mode 100644
index 0000000..bcd478e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/isomorphvf2.py
@@ -0,0 +1,1061 @@
+"""
+*************
+VF2 Algorithm
+*************
+
+An implementation of VF2 algorithm for graph isomorphism testing.
+
+The simplest interface to use this module is to call networkx.is_isomorphic().
+
+Introduction
+------------
+
+The GraphMatcher and DiGraphMatcher are responsible for matching
+graphs or directed graphs in a predetermined manner.  This
+usually means a check for an isomorphism, though other checks
+are also possible.  For example, a subgraph of one graph
+can be checked for isomorphism to a second graph.
+
+Matching is done via syntactic feasibility. It is also possible
+to check for semantic feasibility. Feasibility, then, is defined
+as the logical AND of the two functions.
+
+To include a semantic check, the (Di)GraphMatcher class should be
+subclassed, and the semantic_feasibility() function should be
+redefined.  By default, the semantic feasibility function always
+returns True.  The effect of this is that semantics are not
+considered in the matching of G1 and G2.
+
+Examples
+--------
+
+Suppose G1 and G2 are isomorphic graphs. Verification is as follows:
+
+>>> from networkx.algorithms import isomorphism
+>>> G1 = nx.path_graph(4)
+>>> G2 = nx.path_graph(4)
+>>> GM = isomorphism.GraphMatcher(G1, G2)
+>>> GM.is_isomorphic()
+True
+
+GM.mapping stores the isomorphism mapping from G1 to G2.
+
+>>> GM.mapping
+{0: 0, 1: 1, 2: 2, 3: 3}
+
+
+Suppose G1 and G2 are isomorphic directed graphs.
+Verification is as follows:
+
+>>> G1 = nx.path_graph(4, create_using=nx.DiGraph())
+>>> G2 = nx.path_graph(4, create_using=nx.DiGraph())
+>>> DiGM = isomorphism.DiGraphMatcher(G1, G2)
+>>> DiGM.is_isomorphic()
+True
+
+DiGM.mapping stores the isomorphism mapping from G1 to G2.
+
+>>> DiGM.mapping
+{0: 0, 1: 1, 2: 2, 3: 3}
+
+
+
+Subgraph Isomorphism
+--------------------
+Graph theory literature can be ambiguous about the meaning of the
+above statement, and we seek to clarify it now.
+
+In the VF2 literature, a mapping M is said to be a graph-subgraph
+isomorphism iff M is an isomorphism between G2 and a subgraph of G1.
+Thus, to say that G1 and G2 are graph-subgraph isomorphic is to say
+that a subgraph of G1 is isomorphic to G2.
+
+Other literature uses the phrase 'subgraph isomorphic' as in 'G1 does
+not have a subgraph isomorphic to G2'.  Another use is as an in adverb
+for isomorphic.  Thus, to say that G1 and G2 are subgraph isomorphic
+is to say that a subgraph of G1 is isomorphic to G2.
+
+Finally, the term 'subgraph' can have multiple meanings. In this
+context, 'subgraph' always means a 'node-induced subgraph'. Edge-induced
+subgraph isomorphisms are not directly supported, but one should be
+able to perform the check by making use of nx.line_graph(). For
+subgraphs which are not induced, the term 'monomorphism' is preferred
+over 'isomorphism'.
+
+Let G=(N,E) be a graph with a set of nodes N and set of edges E.
+
+If G'=(N',E') is a subgraph, then:
+    N' is a subset of N
+    E' is a subset of E
+
+If G'=(N',E') is a node-induced subgraph, then:
+    N' is a subset of N
+    E' is the subset of edges in E relating nodes in N'
+
+If G'=(N',E') is an edge-induced subgraph, then:
+    N' is the subset of nodes in N related by edges in E'
+    E' is a subset of E
+
+If G'=(N',E') is a monomorphism, then:
+    N' is a subset of N
+    E' is a subset of the set of edges in E relating nodes in N'
+
+Note that if G' is a node-induced subgraph of G, then it is always a
+subgraph monomorphism of G, but the opposite is not always true, as a
+monomorphism can have fewer edges.
+
+References
+----------
+[1]   Luigi P. Cordella, Pasquale Foggia, Carlo Sansone, Mario Vento,
+      "A (Sub)Graph Isomorphism Algorithm for Matching Large Graphs",
+      IEEE Transactions on Pattern Analysis and Machine Intelligence,
+      vol. 26,  no. 10,  pp. 1367-1372,  Oct.,  2004.
+      http://ieeexplore.ieee.org/iel5/34/29305/01323804.pdf
+
+[2]   L. P. Cordella, P. Foggia, C. Sansone, M. Vento, "An Improved
+      Algorithm for Matching Large Graphs", 3rd IAPR-TC15 Workshop
+      on Graph-based Representations in Pattern Recognition, Cuen,
+      pp. 149-159, 2001.
+      https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.101.5342
+
+See Also
+--------
+syntactic_feasibility(), semantic_feasibility()
+
+Notes
+-----
+
+The implementation handles both directed and undirected graphs as well
+as multigraphs.
+
+In general, the subgraph isomorphism problem is NP-complete whereas the
+graph isomorphism problem is most likely not NP-complete (although no
+polynomial-time algorithm is known to exist).
+
+"""
+
+# This work was originally coded by Christopher Ellison
+# as part of the Computational Mechanics Python (CMPy) project.
+# James P. Crutchfield, principal investigator.
+# Complexity Sciences Center and Physics Department, UC Davis.
+
+import sys
+
+__all__ = ["GraphMatcher", "DiGraphMatcher"]
+
+
+class GraphMatcher:
+    """Implementation of VF2 algorithm for matching undirected graphs.
+
+    Suitable for Graph and MultiGraph instances.
+    """
+
+    def __init__(self, G1, G2):
+        """Initialize GraphMatcher.
+
+        Parameters
+        ----------
+        G1,G2: NetworkX Graph or MultiGraph instances.
+           The two graphs to check for isomorphism or monomorphism.
+
+        Examples
+        --------
+        To create a GraphMatcher which checks for syntactic feasibility:
+
+        >>> from networkx.algorithms import isomorphism
+        >>> G1 = nx.path_graph(4)
+        >>> G2 = nx.path_graph(4)
+        >>> GM = isomorphism.GraphMatcher(G1, G2)
+        """
+        self.G1 = G1
+        self.G2 = G2
+        self.G1_nodes = set(G1.nodes())
+        self.G2_nodes = set(G2.nodes())
+        self.G2_node_order = {n: i for i, n in enumerate(G2)}
+
+        # Set recursion limit.
+        self.old_recursion_limit = sys.getrecursionlimit()
+        expected_max_recursion_level = len(self.G2)
+        if self.old_recursion_limit < 1.5 * expected_max_recursion_level:
+            # Give some breathing room.
+            sys.setrecursionlimit(int(1.5 * expected_max_recursion_level))
+
+        # Declare that we will be searching for a graph-graph isomorphism.
+        self.test = "graph"
+
+        # Initialize state
+        self.initialize()
+
+    def reset_recursion_limit(self):
+        """Restores the recursion limit."""
+        # TODO:
+        # Currently, we use recursion and set the recursion level higher.
+        # It would be nice to restore the level, but because the
+        # (Di)GraphMatcher classes make use of cyclic references, garbage
+        # collection will never happen when we define __del__() to
+        # restore the recursion level. The result is a memory leak.
+        # So for now, we do not automatically restore the recursion level,
+        # and instead provide a method to do this manually. Eventually,
+        # we should turn this into a non-recursive implementation.
+        sys.setrecursionlimit(self.old_recursion_limit)
+
+    def candidate_pairs_iter(self):
+        """Iterator over candidate pairs of nodes in G1 and G2."""
+
+        # All computations are done using the current state!
+
+        G1_nodes = self.G1_nodes
+        G2_nodes = self.G2_nodes
+        min_key = self.G2_node_order.__getitem__
+
+        # First we compute the inout-terminal sets.
+        T1_inout = [node for node in self.inout_1 if node not in self.core_1]
+        T2_inout = [node for node in self.inout_2 if node not in self.core_2]
+
+        # If T1_inout and T2_inout are both nonempty.
+        # P(s) = T1_inout x {min T2_inout}
+        if T1_inout and T2_inout:
+            node_2 = min(T2_inout, key=min_key)
+            for node_1 in T1_inout:
+                yield node_1, node_2
+
+        else:
+            # If T1_inout and T2_inout were both empty....
+            # P(s) = (N_1 - M_1) x {min (N_2 - M_2)}
+            # if not (T1_inout or T2_inout):  # as suggested by  [2], incorrect
+            if 1:  # as inferred from [1], correct
+                # First we determine the candidate node for G2
+                other_node = min(G2_nodes - set(self.core_2), key=min_key)
+                for node in self.G1:
+                    if node not in self.core_1:
+                        yield node, other_node
+
+        # For all other cases, we don't have any candidate pairs.
+
+    def initialize(self):
+        """Reinitializes the state of the algorithm.
+
+        This method should be redefined if using something other than GMState.
+        If only subclassing GraphMatcher, a redefinition is not necessary.
+
+        """
+
+        # core_1[n] contains the index of the node paired with n, which is m,
+        #           provided n is in the mapping.
+        # core_2[m] contains the index of the node paired with m, which is n,
+        #           provided m is in the mapping.
+        self.core_1 = {}
+        self.core_2 = {}
+
+        # See the paper for definitions of M_x and T_x^{y}
+
+        # inout_1[n]  is non-zero if n is in M_1 or in T_1^{inout}
+        # inout_2[m]  is non-zero if m is in M_2 or in T_2^{inout}
+        #
+        # The value stored is the depth of the SSR tree when the node became
+        # part of the corresponding set.
+        self.inout_1 = {}
+        self.inout_2 = {}
+        # Practically, these sets simply store the nodes in the subgraph.
+
+        self.state = GMState(self)
+
+        # Provide a convenient way to access the isomorphism mapping.
+        self.mapping = self.core_1.copy()
+
+    def is_isomorphic(self):
+        """Returns True if G1 and G2 are isomorphic graphs."""
+
+        # Let's do two very quick checks!
+        # QUESTION: Should we call faster_graph_could_be_isomorphic(G1,G2)?
+        # For now, I just copy the code.
+
+        # Check global properties
+        if self.G1.order() != self.G2.order():
+            return False
+
+        # Check local properties
+        d1 = sorted(d for n, d in self.G1.degree())
+        d2 = sorted(d for n, d in self.G2.degree())
+        if d1 != d2:
+            return False
+
+        try:
+            x = next(self.isomorphisms_iter())
+            return True
+        except StopIteration:
+            return False
+
+    def isomorphisms_iter(self):
+        """Generator over isomorphisms between G1 and G2."""
+        # Declare that we are looking for a graph-graph isomorphism.
+        self.test = "graph"
+        self.initialize()
+        yield from self.match()
+
+    def match(self):
+        """Extends the isomorphism mapping.
+
+        This function is called recursively to determine if a complete
+        isomorphism can be found between G1 and G2.  It cleans up the class
+        variables after each recursive call. If an isomorphism is found,
+        we yield the mapping.
+
+        """
+        if len(self.core_1) == len(self.G2):
+            # Save the final mapping, otherwise garbage collection deletes it.
+            self.mapping = self.core_1.copy()
+            # The mapping is complete.
+            yield self.mapping
+        else:
+            for G1_node, G2_node in self.candidate_pairs_iter():
+                if self.syntactic_feasibility(G1_node, G2_node):
+                    if self.semantic_feasibility(G1_node, G2_node):
+                        # Recursive call, adding the feasible state.
+                        newstate = self.state.__class__(self, G1_node, G2_node)
+                        yield from self.match()
+
+                        # restore data structures
+                        newstate.restore()
+
+    def semantic_feasibility(self, G1_node, G2_node):
+        """Returns True if adding (G1_node, G2_node) is symantically feasible.
+
+        The semantic feasibility function should return True if it is
+        acceptable to add the candidate pair (G1_node, G2_node) to the current
+        partial isomorphism mapping.   The logic should focus on semantic
+        information contained in the edge data or a formalized node class.
+
+        By acceptable, we mean that the subsequent mapping can still become a
+        complete isomorphism mapping.  Thus, if adding the candidate pair
+        definitely makes it so that the subsequent mapping cannot become a
+        complete isomorphism mapping, then this function must return False.
+
+        The default semantic feasibility function always returns True. The
+        effect is that semantics are not considered in the matching of G1
+        and G2.
+
+        The semantic checks might differ based on the what type of test is
+        being performed.  A keyword description of the test is stored in
+        self.test.  Here is a quick description of the currently implemented
+        tests::
+
+          test='graph'
+            Indicates that the graph matcher is looking for a graph-graph
+            isomorphism.
+
+          test='subgraph'
+            Indicates that the graph matcher is looking for a subgraph-graph
+            isomorphism such that a subgraph of G1 is isomorphic to G2.
+
+          test='mono'
+            Indicates that the graph matcher is looking for a subgraph-graph
+            monomorphism such that a subgraph of G1 is monomorphic to G2.
+
+        Any subclass which redefines semantic_feasibility() must maintain
+        the above form to keep the match() method functional. Implementations
+        should consider multigraphs.
+        """
+        return True
+
+    def subgraph_is_isomorphic(self):
+        """Returns True if a subgraph of G1 is isomorphic to G2."""
+        try:
+            x = next(self.subgraph_isomorphisms_iter())
+            return True
+        except StopIteration:
+            return False
+
+    def subgraph_is_monomorphic(self):
+        """Returns True if a subgraph of G1 is monomorphic to G2."""
+        try:
+            x = next(self.subgraph_monomorphisms_iter())
+            return True
+        except StopIteration:
+            return False
+
+    #    subgraph_is_isomorphic.__doc__ += "\n" + subgraph.replace('\n','\n'+indent)
+
+    def subgraph_isomorphisms_iter(self):
+        """Generator over isomorphisms between a subgraph of G1 and G2."""
+        # Declare that we are looking for graph-subgraph isomorphism.
+        self.test = "subgraph"
+        self.initialize()
+        yield from self.match()
+
+    def subgraph_monomorphisms_iter(self):
+        """Generator over monomorphisms between a subgraph of G1 and G2."""
+        # Declare that we are looking for graph-subgraph monomorphism.
+        self.test = "mono"
+        self.initialize()
+        yield from self.match()
+
+    #    subgraph_isomorphisms_iter.__doc__ += "\n" + subgraph.replace('\n','\n'+indent)
+
+    def syntactic_feasibility(self, G1_node, G2_node):
+        """Returns True if adding (G1_node, G2_node) is syntactically feasible.
+
+        This function returns True if it is adding the candidate pair
+        to the current partial isomorphism/monomorphism mapping is allowable.
+        The addition is allowable if the inclusion of the candidate pair does
+        not make it impossible for an isomorphism/monomorphism to be found.
+        """
+
+        # The VF2 algorithm was designed to work with graphs having, at most,
+        # one edge connecting any two nodes.  This is not the case when
+        # dealing with an MultiGraphs.
+        #
+        # Basically, when we test the look-ahead rules R_neighbor, we will
+        # make sure that the number of edges are checked. We also add
+        # a R_self check to verify that the number of selfloops is acceptable.
+        #
+        # Users might be comparing Graph instances with MultiGraph instances.
+        # So the generic GraphMatcher class must work with MultiGraphs.
+        # Care must be taken since the value in the innermost dictionary is a
+        # singlet for Graph instances.  For MultiGraphs, the value in the
+        # innermost dictionary is a list.
+
+        ###
+        # Test at each step to get a return value as soon as possible.
+        ###
+
+        # Look ahead 0
+
+        # R_self
+
+        # The number of selfloops for G1_node must equal the number of
+        # self-loops for G2_node. Without this check, we would fail on
+        # R_neighbor at the next recursion level. But it is good to prune the
+        # search tree now.
+
+        if self.test == "mono":
+            if self.G1.number_of_edges(G1_node, G1_node) < self.G2.number_of_edges(
+                G2_node, G2_node
+            ):
+                return False
+        else:
+            if self.G1.number_of_edges(G1_node, G1_node) != self.G2.number_of_edges(
+                G2_node, G2_node
+            ):
+                return False
+
+        # R_neighbor
+
+        # For each neighbor n' of n in the partial mapping, the corresponding
+        # node m' is a neighbor of m, and vice versa. Also, the number of
+        # edges must be equal.
+        if self.test != "mono":
+            for neighbor in self.G1[G1_node]:
+                if neighbor in self.core_1:
+                    if not (self.core_1[neighbor] in self.G2[G2_node]):
+                        return False
+                    elif self.G1.number_of_edges(
+                        neighbor, G1_node
+                    ) != self.G2.number_of_edges(self.core_1[neighbor], G2_node):
+                        return False
+
+        for neighbor in self.G2[G2_node]:
+            if neighbor in self.core_2:
+                if not (self.core_2[neighbor] in self.G1[G1_node]):
+                    return False
+                elif self.test == "mono":
+                    if self.G1.number_of_edges(
+                        self.core_2[neighbor], G1_node
+                    ) < self.G2.number_of_edges(neighbor, G2_node):
+                        return False
+                else:
+                    if self.G1.number_of_edges(
+                        self.core_2[neighbor], G1_node
+                    ) != self.G2.number_of_edges(neighbor, G2_node):
+                        return False
+
+        if self.test != "mono":
+            # Look ahead 1
+
+            # R_terminout
+            # The number of neighbors of n in T_1^{inout} is equal to the
+            # number of neighbors of m that are in T_2^{inout}, and vice versa.
+            num1 = 0
+            for neighbor in self.G1[G1_node]:
+                if (neighbor in self.inout_1) and (neighbor not in self.core_1):
+                    num1 += 1
+            num2 = 0
+            for neighbor in self.G2[G2_node]:
+                if (neighbor in self.inout_2) and (neighbor not in self.core_2):
+                    num2 += 1
+            if self.test == "graph":
+                if not (num1 == num2):
+                    return False
+            else:  # self.test == 'subgraph'
+                if not (num1 >= num2):
+                    return False
+
+            # Look ahead 2
+
+            # R_new
+
+            # The number of neighbors of n that are neither in the core_1 nor
+            # T_1^{inout} is equal to the number of neighbors of m
+            # that are neither in core_2 nor T_2^{inout}.
+            num1 = 0
+            for neighbor in self.G1[G1_node]:
+                if neighbor not in self.inout_1:
+                    num1 += 1
+            num2 = 0
+            for neighbor in self.G2[G2_node]:
+                if neighbor not in self.inout_2:
+                    num2 += 1
+            if self.test == "graph":
+                if not (num1 == num2):
+                    return False
+            else:  # self.test == 'subgraph'
+                if not (num1 >= num2):
+                    return False
+
+        # Otherwise, this node pair is syntactically feasible!
+        return True
+
+
+class DiGraphMatcher(GraphMatcher):
+    """Implementation of VF2 algorithm for matching directed graphs.
+
+    Suitable for DiGraph and MultiDiGraph instances.
+    """
+
+    def __init__(self, G1, G2):
+        """Initialize DiGraphMatcher.
+
+        G1 and G2 should be nx.Graph or nx.MultiGraph instances.
+
+        Examples
+        --------
+        To create a GraphMatcher which checks for syntactic feasibility:
+
+        >>> from networkx.algorithms import isomorphism
+        >>> G1 = nx.DiGraph(nx.path_graph(4, create_using=nx.DiGraph()))
+        >>> G2 = nx.DiGraph(nx.path_graph(4, create_using=nx.DiGraph()))
+        >>> DiGM = isomorphism.DiGraphMatcher(G1, G2)
+        """
+        super().__init__(G1, G2)
+
+    def candidate_pairs_iter(self):
+        """Iterator over candidate pairs of nodes in G1 and G2."""
+
+        # All computations are done using the current state!
+
+        G1_nodes = self.G1_nodes
+        G2_nodes = self.G2_nodes
+        min_key = self.G2_node_order.__getitem__
+
+        # First we compute the out-terminal sets.
+        T1_out = [node for node in self.out_1 if node not in self.core_1]
+        T2_out = [node for node in self.out_2 if node not in self.core_2]
+
+        # If T1_out and T2_out are both nonempty.
+        # P(s) = T1_out x {min T2_out}
+        if T1_out and T2_out:
+            node_2 = min(T2_out, key=min_key)
+            for node_1 in T1_out:
+                yield node_1, node_2
+
+        # If T1_out and T2_out were both empty....
+        # We compute the in-terminal sets.
+
+        # elif not (T1_out or T2_out):   # as suggested by [2], incorrect
+        else:  # as suggested by [1], correct
+            T1_in = [node for node in self.in_1 if node not in self.core_1]
+            T2_in = [node for node in self.in_2 if node not in self.core_2]
+
+            # If T1_in and T2_in are both nonempty.
+            # P(s) = T1_out x {min T2_out}
+            if T1_in and T2_in:
+                node_2 = min(T2_in, key=min_key)
+                for node_1 in T1_in:
+                    yield node_1, node_2
+
+            # If all terminal sets are empty...
+            # P(s) = (N_1 - M_1) x {min (N_2 - M_2)}
+
+            # elif not (T1_in or T2_in):   # as suggested by  [2], incorrect
+            else:  # as inferred from [1], correct
+                node_2 = min(G2_nodes - set(self.core_2), key=min_key)
+                for node_1 in G1_nodes:
+                    if node_1 not in self.core_1:
+                        yield node_1, node_2
+
+        # For all other cases, we don't have any candidate pairs.
+
+    def initialize(self):
+        """Reinitializes the state of the algorithm.
+
+        This method should be redefined if using something other than DiGMState.
+        If only subclassing GraphMatcher, a redefinition is not necessary.
+        """
+
+        # core_1[n] contains the index of the node paired with n, which is m,
+        #           provided n is in the mapping.
+        # core_2[m] contains the index of the node paired with m, which is n,
+        #           provided m is in the mapping.
+        self.core_1 = {}
+        self.core_2 = {}
+
+        # See the paper for definitions of M_x and T_x^{y}
+
+        # in_1[n]  is non-zero if n is in M_1 or in T_1^{in}
+        # out_1[n] is non-zero if n is in M_1 or in T_1^{out}
+        #
+        # in_2[m]  is non-zero if m is in M_2 or in T_2^{in}
+        # out_2[m] is non-zero if m is in M_2 or in T_2^{out}
+        #
+        # The value stored is the depth of the search tree when the node became
+        # part of the corresponding set.
+        self.in_1 = {}
+        self.in_2 = {}
+        self.out_1 = {}
+        self.out_2 = {}
+
+        self.state = DiGMState(self)
+
+        # Provide a convenient way to access the isomorphism mapping.
+        self.mapping = self.core_1.copy()
+
+    def syntactic_feasibility(self, G1_node, G2_node):
+        """Returns True if adding (G1_node, G2_node) is syntactically feasible.
+
+        This function returns True if it is adding the candidate pair
+        to the current partial isomorphism/monomorphism mapping is allowable.
+        The addition is allowable if the inclusion of the candidate pair does
+        not make it impossible for an isomorphism/monomorphism to be found.
+        """
+
+        # The VF2 algorithm was designed to work with graphs having, at most,
+        # one edge connecting any two nodes.  This is not the case when
+        # dealing with an MultiGraphs.
+        #
+        # Basically, when we test the look-ahead rules R_pred and R_succ, we
+        # will make sure that the number of edges are checked.  We also add
+        # a R_self check to verify that the number of selfloops is acceptable.
+
+        # Users might be comparing DiGraph instances with MultiDiGraph
+        # instances. So the generic DiGraphMatcher class must work with
+        # MultiDiGraphs. Care must be taken since the value in the innermost
+        # dictionary is a singlet for DiGraph instances.  For MultiDiGraphs,
+        # the value in the innermost dictionary is a list.
+
+        ###
+        # Test at each step to get a return value as soon as possible.
+        ###
+
+        # Look ahead 0
+
+        # R_self
+
+        # The number of selfloops for G1_node must equal the number of
+        # self-loops for G2_node. Without this check, we would fail on R_pred
+        # at the next recursion level. This should prune the tree even further.
+        if self.test == "mono":
+            if self.G1.number_of_edges(G1_node, G1_node) < self.G2.number_of_edges(
+                G2_node, G2_node
+            ):
+                return False
+        else:
+            if self.G1.number_of_edges(G1_node, G1_node) != self.G2.number_of_edges(
+                G2_node, G2_node
+            ):
+                return False
+
+        # R_pred
+
+        # For each predecessor n' of n in the partial mapping, the
+        # corresponding node m' is a predecessor of m, and vice versa. Also,
+        # the number of edges must be equal
+        if self.test != "mono":
+            for predecessor in self.G1.pred[G1_node]:
+                if predecessor in self.core_1:
+                    if not (self.core_1[predecessor] in self.G2.pred[G2_node]):
+                        return False
+                    elif self.G1.number_of_edges(
+                        predecessor, G1_node
+                    ) != self.G2.number_of_edges(self.core_1[predecessor], G2_node):
+                        return False
+
+        for predecessor in self.G2.pred[G2_node]:
+            if predecessor in self.core_2:
+                if not (self.core_2[predecessor] in self.G1.pred[G1_node]):
+                    return False
+                elif self.test == "mono":
+                    if self.G1.number_of_edges(
+                        self.core_2[predecessor], G1_node
+                    ) < self.G2.number_of_edges(predecessor, G2_node):
+                        return False
+                else:
+                    if self.G1.number_of_edges(
+                        self.core_2[predecessor], G1_node
+                    ) != self.G2.number_of_edges(predecessor, G2_node):
+                        return False
+
+        # R_succ
+
+        # For each successor n' of n in the partial mapping, the corresponding
+        # node m' is a successor of m, and vice versa. Also, the number of
+        # edges must be equal.
+        if self.test != "mono":
+            for successor in self.G1[G1_node]:
+                if successor in self.core_1:
+                    if not (self.core_1[successor] in self.G2[G2_node]):
+                        return False
+                    elif self.G1.number_of_edges(
+                        G1_node, successor
+                    ) != self.G2.number_of_edges(G2_node, self.core_1[successor]):
+                        return False
+
+        for successor in self.G2[G2_node]:
+            if successor in self.core_2:
+                if not (self.core_2[successor] in self.G1[G1_node]):
+                    return False
+                elif self.test == "mono":
+                    if self.G1.number_of_edges(
+                        G1_node, self.core_2[successor]
+                    ) < self.G2.number_of_edges(G2_node, successor):
+                        return False
+                else:
+                    if self.G1.number_of_edges(
+                        G1_node, self.core_2[successor]
+                    ) != self.G2.number_of_edges(G2_node, successor):
+                        return False
+
+        if self.test != "mono":
+
+            # Look ahead 1
+
+            # R_termin
+            # The number of predecessors of n that are in T_1^{in} is equal to the
+            # number of predecessors of m that are in T_2^{in}.
+            num1 = 0
+            for predecessor in self.G1.pred[G1_node]:
+                if (predecessor in self.in_1) and (predecessor not in self.core_1):
+                    num1 += 1
+            num2 = 0
+            for predecessor in self.G2.pred[G2_node]:
+                if (predecessor in self.in_2) and (predecessor not in self.core_2):
+                    num2 += 1
+            if self.test == "graph":
+                if not (num1 == num2):
+                    return False
+            else:  # self.test == 'subgraph'
+                if not (num1 >= num2):
+                    return False
+
+            # The number of successors of n that are in T_1^{in} is equal to the
+            # number of successors of m that are in T_2^{in}.
+            num1 = 0
+            for successor in self.G1[G1_node]:
+                if (successor in self.in_1) and (successor not in self.core_1):
+                    num1 += 1
+            num2 = 0
+            for successor in self.G2[G2_node]:
+                if (successor in self.in_2) and (successor not in self.core_2):
+                    num2 += 1
+            if self.test == "graph":
+                if not (num1 == num2):
+                    return False
+            else:  # self.test == 'subgraph'
+                if not (num1 >= num2):
+                    return False
+
+            # R_termout
+
+            # The number of predecessors of n that are in T_1^{out} is equal to the
+            # number of predecessors of m that are in T_2^{out}.
+            num1 = 0
+            for predecessor in self.G1.pred[G1_node]:
+                if (predecessor in self.out_1) and (predecessor not in self.core_1):
+                    num1 += 1
+            num2 = 0
+            for predecessor in self.G2.pred[G2_node]:
+                if (predecessor in self.out_2) and (predecessor not in self.core_2):
+                    num2 += 1
+            if self.test == "graph":
+                if not (num1 == num2):
+                    return False
+            else:  # self.test == 'subgraph'
+                if not (num1 >= num2):
+                    return False
+
+            # The number of successors of n that are in T_1^{out} is equal to the
+            # number of successors of m that are in T_2^{out}.
+            num1 = 0
+            for successor in self.G1[G1_node]:
+                if (successor in self.out_1) and (successor not in self.core_1):
+                    num1 += 1
+            num2 = 0
+            for successor in self.G2[G2_node]:
+                if (successor in self.out_2) and (successor not in self.core_2):
+                    num2 += 1
+            if self.test == "graph":
+                if not (num1 == num2):
+                    return False
+            else:  # self.test == 'subgraph'
+                if not (num1 >= num2):
+                    return False
+
+            # Look ahead 2
+
+            # R_new
+
+            # The number of predecessors of n that are neither in the core_1 nor
+            # T_1^{in} nor T_1^{out} is equal to the number of predecessors of m
+            # that are neither in core_2 nor T_2^{in} nor T_2^{out}.
+            num1 = 0
+            for predecessor in self.G1.pred[G1_node]:
+                if (predecessor not in self.in_1) and (predecessor not in self.out_1):
+                    num1 += 1
+            num2 = 0
+            for predecessor in self.G2.pred[G2_node]:
+                if (predecessor not in self.in_2) and (predecessor not in self.out_2):
+                    num2 += 1
+            if self.test == "graph":
+                if not (num1 == num2):
+                    return False
+            else:  # self.test == 'subgraph'
+                if not (num1 >= num2):
+                    return False
+
+            # The number of successors of n that are neither in the core_1 nor
+            # T_1^{in} nor T_1^{out} is equal to the number of successors of m
+            # that are neither in core_2 nor T_2^{in} nor T_2^{out}.
+            num1 = 0
+            for successor in self.G1[G1_node]:
+                if (successor not in self.in_1) and (successor not in self.out_1):
+                    num1 += 1
+            num2 = 0
+            for successor in self.G2[G2_node]:
+                if (successor not in self.in_2) and (successor not in self.out_2):
+                    num2 += 1
+            if self.test == "graph":
+                if not (num1 == num2):
+                    return False
+            else:  # self.test == 'subgraph'
+                if not (num1 >= num2):
+                    return False
+
+        # Otherwise, this node pair is syntactically feasible!
+        return True
+
+
+class GMState:
+    """Internal representation of state for the GraphMatcher class.
+
+    This class is used internally by the GraphMatcher class.  It is used
+    only to store state specific data. There will be at most G2.order() of
+    these objects in memory at a time, due to the depth-first search
+    strategy employed by the VF2 algorithm.
+    """
+
+    def __init__(self, GM, G1_node=None, G2_node=None):
+        """Initializes GMState object.
+
+        Pass in the GraphMatcher to which this GMState belongs and the
+        new node pair that will be added to the GraphMatcher's current
+        isomorphism mapping.
+        """
+        self.GM = GM
+
+        # Initialize the last stored node pair.
+        self.G1_node = None
+        self.G2_node = None
+        self.depth = len(GM.core_1)
+
+        if G1_node is None or G2_node is None:
+            # Then we reset the class variables
+            GM.core_1 = {}
+            GM.core_2 = {}
+            GM.inout_1 = {}
+            GM.inout_2 = {}
+
+        # Watch out! G1_node == 0 should evaluate to True.
+        if G1_node is not None and G2_node is not None:
+            # Add the node pair to the isomorphism mapping.
+            GM.core_1[G1_node] = G2_node
+            GM.core_2[G2_node] = G1_node
+
+            # Store the node that was added last.
+            self.G1_node = G1_node
+            self.G2_node = G2_node
+
+            # Now we must update the other two vectors.
+            # We will add only if it is not in there already!
+            self.depth = len(GM.core_1)
+
+            # First we add the new nodes...
+            if G1_node not in GM.inout_1:
+                GM.inout_1[G1_node] = self.depth
+            if G2_node not in GM.inout_2:
+                GM.inout_2[G2_node] = self.depth
+
+            # Now we add every other node...
+
+            # Updates for T_1^{inout}
+            new_nodes = set()
+            for node in GM.core_1:
+                new_nodes.update(
+                    [neighbor for neighbor in GM.G1[node] if neighbor not in GM.core_1]
+                )
+            for node in new_nodes:
+                if node not in GM.inout_1:
+                    GM.inout_1[node] = self.depth
+
+            # Updates for T_2^{inout}
+            new_nodes = set()
+            for node in GM.core_2:
+                new_nodes.update(
+                    [neighbor for neighbor in GM.G2[node] if neighbor not in GM.core_2]
+                )
+            for node in new_nodes:
+                if node not in GM.inout_2:
+                    GM.inout_2[node] = self.depth
+
+    def restore(self):
+        """Deletes the GMState object and restores the class variables."""
+        # First we remove the node that was added from the core vectors.
+        # Watch out! G1_node == 0 should evaluate to True.
+        if self.G1_node is not None and self.G2_node is not None:
+            del self.GM.core_1[self.G1_node]
+            del self.GM.core_2[self.G2_node]
+
+        # Now we revert the other two vectors.
+        # Thus, we delete all entries which have this depth level.
+        for vector in (self.GM.inout_1, self.GM.inout_2):
+            for node in list(vector.keys()):
+                if vector[node] == self.depth:
+                    del vector[node]
+
+
+class DiGMState:
+    """Internal representation of state for the DiGraphMatcher class.
+
+    This class is used internally by the DiGraphMatcher class.  It is used
+    only to store state specific data. There will be at most G2.order() of
+    these objects in memory at a time, due to the depth-first search
+    strategy employed by the VF2 algorithm.
+
+    """
+
+    def __init__(self, GM, G1_node=None, G2_node=None):
+        """Initializes DiGMState object.
+
+        Pass in the DiGraphMatcher to which this DiGMState belongs and the
+        new node pair that will be added to the GraphMatcher's current
+        isomorphism mapping.
+        """
+        self.GM = GM
+
+        # Initialize the last stored node pair.
+        self.G1_node = None
+        self.G2_node = None
+        self.depth = len(GM.core_1)
+
+        if G1_node is None or G2_node is None:
+            # Then we reset the class variables
+            GM.core_1 = {}
+            GM.core_2 = {}
+            GM.in_1 = {}
+            GM.in_2 = {}
+            GM.out_1 = {}
+            GM.out_2 = {}
+
+        # Watch out! G1_node == 0 should evaluate to True.
+        if G1_node is not None and G2_node is not None:
+            # Add the node pair to the isomorphism mapping.
+            GM.core_1[G1_node] = G2_node
+            GM.core_2[G2_node] = G1_node
+
+            # Store the node that was added last.
+            self.G1_node = G1_node
+            self.G2_node = G2_node
+
+            # Now we must update the other four vectors.
+            # We will add only if it is not in there already!
+            self.depth = len(GM.core_1)
+
+            # First we add the new nodes...
+            for vector in (GM.in_1, GM.out_1):
+                if G1_node not in vector:
+                    vector[G1_node] = self.depth
+            for vector in (GM.in_2, GM.out_2):
+                if G2_node not in vector:
+                    vector[G2_node] = self.depth
+
+            # Now we add every other node...
+
+            # Updates for T_1^{in}
+            new_nodes = set()
+            for node in GM.core_1:
+                new_nodes.update(
+                    [
+                        predecessor
+                        for predecessor in GM.G1.predecessors(node)
+                        if predecessor not in GM.core_1
+                    ]
+                )
+            for node in new_nodes:
+                if node not in GM.in_1:
+                    GM.in_1[node] = self.depth
+
+            # Updates for T_2^{in}
+            new_nodes = set()
+            for node in GM.core_2:
+                new_nodes.update(
+                    [
+                        predecessor
+                        for predecessor in GM.G2.predecessors(node)
+                        if predecessor not in GM.core_2
+                    ]
+                )
+            for node in new_nodes:
+                if node not in GM.in_2:
+                    GM.in_2[node] = self.depth
+
+            # Updates for T_1^{out}
+            new_nodes = set()
+            for node in GM.core_1:
+                new_nodes.update(
+                    [
+                        successor
+                        for successor in GM.G1.successors(node)
+                        if successor not in GM.core_1
+                    ]
+                )
+            for node in new_nodes:
+                if node not in GM.out_1:
+                    GM.out_1[node] = self.depth
+
+            # Updates for T_2^{out}
+            new_nodes = set()
+            for node in GM.core_2:
+                new_nodes.update(
+                    [
+                        successor
+                        for successor in GM.G2.successors(node)
+                        if successor not in GM.core_2
+                    ]
+                )
+            for node in new_nodes:
+                if node not in GM.out_2:
+                    GM.out_2[node] = self.depth
+
+    def restore(self):
+        """Deletes the DiGMState object and restores the class variables."""
+
+        # First we remove the node that was added from the core vectors.
+        # Watch out! G1_node == 0 should evaluate to True.
+        if self.G1_node is not None and self.G2_node is not None:
+            del self.GM.core_1[self.G1_node]
+            del self.GM.core_2[self.G2_node]
+
+        # Now we revert the other four vectors.
+        # Thus, we delete all entries which have this depth level.
+        for vector in (self.GM.in_1, self.GM.in_2, self.GM.out_1, self.GM.out_2):
+            for node in list(vector.keys()):
+                if vector[node] == self.depth:
+                    del vector[node]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/matchhelpers.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/matchhelpers.py
new file mode 100644
index 0000000..9010e26
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/matchhelpers.py
@@ -0,0 +1,355 @@
+"""Functions which help end users define customize node_match and
+edge_match functions to use during isomorphism checks.
+"""
+import math
+import types
+from itertools import permutations
+
+__all__ = [
+    "categorical_node_match",
+    "categorical_edge_match",
+    "categorical_multiedge_match",
+    "numerical_node_match",
+    "numerical_edge_match",
+    "numerical_multiedge_match",
+    "generic_node_match",
+    "generic_edge_match",
+    "generic_multiedge_match",
+]
+
+
+def copyfunc(f, name=None):
+    """Returns a deepcopy of a function."""
+    return types.FunctionType(
+        f.__code__, f.__globals__, name or f.__name__, f.__defaults__, f.__closure__
+    )
+
+
+def allclose(x, y, rtol=1.0000000000000001e-05, atol=1e-08):
+    """Returns True if x and y are sufficiently close, elementwise.
+
+    Parameters
+    ----------
+    rtol : float
+        The relative error tolerance.
+    atol : float
+        The absolute error tolerance.
+
+    """
+    # assume finite weights, see numpy.allclose() for reference
+    for xi, yi in zip(x, y):
+        if not math.isclose(xi, yi, rel_tol=rtol, abs_tol=atol):
+            return False
+    return True
+
+
+categorical_doc = """
+Returns a comparison function for a categorical node attribute.
+
+The value(s) of the attr(s) must be hashable and comparable via the ==
+operator since they are placed into a set([]) object.  If the sets from
+G1 and G2 are the same, then the constructed function returns True.
+
+Parameters
+----------
+attr : string | list
+    The categorical node attribute to compare, or a list of categorical
+    node attributes to compare.
+default : value | list
+    The default value for the categorical node attribute, or a list of
+    default values for the categorical node attributes.
+
+Returns
+-------
+match : function
+    The customized, categorical `node_match` function.
+
+Examples
+--------
+>>> import networkx.algorithms.isomorphism as iso
+>>> nm = iso.categorical_node_match("size", 1)
+>>> nm = iso.categorical_node_match(["color", "size"], ["red", 2])
+
+"""
+
+
+def categorical_node_match(attr, default):
+    if isinstance(attr, str):
+
+        def match(data1, data2):
+            return data1.get(attr, default) == data2.get(attr, default)
+
+    else:
+        attrs = list(zip(attr, default))  # Python 3
+
+        def match(data1, data2):
+            return all(data1.get(attr, d) == data2.get(attr, d) for attr, d in attrs)
+
+    return match
+
+
+categorical_edge_match = copyfunc(categorical_node_match, "categorical_edge_match")
+
+
+def categorical_multiedge_match(attr, default):
+    if isinstance(attr, str):
+
+        def match(datasets1, datasets2):
+            values1 = {data.get(attr, default) for data in datasets1.values()}
+            values2 = {data.get(attr, default) for data in datasets2.values()}
+            return values1 == values2
+
+    else:
+        attrs = list(zip(attr, default))  # Python 3
+
+        def match(datasets1, datasets2):
+            values1 = set()
+            for data1 in datasets1.values():
+                x = tuple(data1.get(attr, d) for attr, d in attrs)
+                values1.add(x)
+            values2 = set()
+            for data2 in datasets2.values():
+                x = tuple(data2.get(attr, d) for attr, d in attrs)
+                values2.add(x)
+            return values1 == values2
+
+    return match
+
+
+# Docstrings for categorical functions.
+categorical_node_match.__doc__ = categorical_doc
+categorical_edge_match.__doc__ = categorical_doc.replace("node", "edge")
+tmpdoc = categorical_doc.replace("node", "edge")
+tmpdoc = tmpdoc.replace("categorical_edge_match", "categorical_multiedge_match")
+categorical_multiedge_match.__doc__ = tmpdoc
+
+
+numerical_doc = """
+Returns a comparison function for a numerical node attribute.
+
+The value(s) of the attr(s) must be numerical and sortable.  If the
+sorted list of values from G1 and G2 are the same within some
+tolerance, then the constructed function returns True.
+
+Parameters
+----------
+attr : string | list
+    The numerical node attribute to compare, or a list of numerical
+    node attributes to compare.
+default : value | list
+    The default value for the numerical node attribute, or a list of
+    default values for the numerical node attributes.
+rtol : float
+    The relative error tolerance.
+atol : float
+    The absolute error tolerance.
+
+Returns
+-------
+match : function
+    The customized, numerical `node_match` function.
+
+Examples
+--------
+>>> import networkx.algorithms.isomorphism as iso
+>>> nm = iso.numerical_node_match("weight", 1.0)
+>>> nm = iso.numerical_node_match(["weight", "linewidth"], [0.25, 0.5])
+
+"""
+
+
+def numerical_node_match(attr, default, rtol=1.0000000000000001e-05, atol=1e-08):
+    if isinstance(attr, str):
+
+        def match(data1, data2):
+            return math.isclose(
+                data1.get(attr, default),
+                data2.get(attr, default),
+                rel_tol=rtol,
+                abs_tol=atol,
+            )
+
+    else:
+        attrs = list(zip(attr, default))  # Python 3
+
+        def match(data1, data2):
+            values1 = [data1.get(attr, d) for attr, d in attrs]
+            values2 = [data2.get(attr, d) for attr, d in attrs]
+            return allclose(values1, values2, rtol=rtol, atol=atol)
+
+    return match
+
+
+numerical_edge_match = copyfunc(numerical_node_match, "numerical_edge_match")
+
+
+def numerical_multiedge_match(attr, default, rtol=1.0000000000000001e-05, atol=1e-08):
+    if isinstance(attr, str):
+
+        def match(datasets1, datasets2):
+            values1 = sorted(data.get(attr, default) for data in datasets1.values())
+            values2 = sorted(data.get(attr, default) for data in datasets2.values())
+            return allclose(values1, values2, rtol=rtol, atol=atol)
+
+    else:
+        attrs = list(zip(attr, default))  # Python 3
+
+        def match(datasets1, datasets2):
+            values1 = []
+            for data1 in datasets1.values():
+                x = tuple(data1.get(attr, d) for attr, d in attrs)
+                values1.append(x)
+            values2 = []
+            for data2 in datasets2.values():
+                x = tuple(data2.get(attr, d) for attr, d in attrs)
+                values2.append(x)
+            values1.sort()
+            values2.sort()
+            for xi, yi in zip(values1, values2):
+                if not allclose(xi, yi, rtol=rtol, atol=atol):
+                    return False
+            else:
+                return True
+
+    return match
+
+
+# Docstrings for numerical functions.
+numerical_node_match.__doc__ = numerical_doc
+numerical_edge_match.__doc__ = numerical_doc.replace("node", "edge")
+tmpdoc = numerical_doc.replace("node", "edge")
+tmpdoc = tmpdoc.replace("numerical_edge_match", "numerical_multiedge_match")
+numerical_multiedge_match.__doc__ = tmpdoc
+
+
+generic_doc = """
+Returns a comparison function for a generic attribute.
+
+The value(s) of the attr(s) are compared using the specified
+operators. If all the attributes are equal, then the constructed
+function returns True.
+
+Parameters
+----------
+attr : string | list
+    The node attribute to compare, or a list of node attributes
+    to compare.
+default : value | list
+    The default value for the node attribute, or a list of
+    default values for the node attributes.
+op : callable | list
+    The operator to use when comparing attribute values, or a list
+    of operators to use when comparing values for each attribute.
+
+Returns
+-------
+match : function
+    The customized, generic `node_match` function.
+
+Examples
+--------
+>>> from operator import eq
+>>> from math import isclose
+>>> from networkx.algorithms.isomorphism import generic_node_match
+>>> nm = generic_node_match("weight", 1.0, isclose)
+>>> nm = generic_node_match("color", "red", eq)
+>>> nm = generic_node_match(["weight", "color"], [1.0, "red"], [isclose, eq])
+
+"""
+
+
+def generic_node_match(attr, default, op):
+    if isinstance(attr, str):
+
+        def match(data1, data2):
+            return op(data1.get(attr, default), data2.get(attr, default))
+
+    else:
+        attrs = list(zip(attr, default, op))  # Python 3
+
+        def match(data1, data2):
+            for attr, d, operator in attrs:
+                if not operator(data1.get(attr, d), data2.get(attr, d)):
+                    return False
+            else:
+                return True
+
+    return match
+
+
+generic_edge_match = copyfunc(generic_node_match, "generic_edge_match")
+
+
+def generic_multiedge_match(attr, default, op):
+    """Returns a comparison function for a generic attribute.
+
+    The value(s) of the attr(s) are compared using the specified
+    operators. If all the attributes are equal, then the constructed
+    function returns True. Potentially, the constructed edge_match
+    function can be slow since it must verify that no isomorphism
+    exists between the multiedges before it returns False.
+
+    Parameters
+    ----------
+    attr : string | list
+        The edge attribute to compare, or a list of node attributes
+        to compare.
+    default : value | list
+        The default value for the edge attribute, or a list of
+        default values for the dgeattributes.
+    op : callable | list
+        The operator to use when comparing attribute values, or a list
+        of operators to use when comparing values for each attribute.
+
+    Returns
+    -------
+    match : function
+        The customized, generic `edge_match` function.
+
+    Examples
+    --------
+    >>> from operator import eq
+    >>> from math import isclose
+    >>> from networkx.algorithms.isomorphism import generic_node_match
+    >>> nm = generic_node_match("weight", 1.0, isclose)
+    >>> nm = generic_node_match("color", "red", eq)
+    >>> nm = generic_node_match(["weight", "color"], [1.0, "red"], [isclose, eq])
+    ...
+
+    """
+
+    # This is slow, but generic.
+    # We must test every possible isomorphism between the edges.
+    if isinstance(attr, str):
+        attr = [attr]
+        default = [default]
+        op = [op]
+    attrs = list(zip(attr, default))  # Python 3
+
+    def match(datasets1, datasets2):
+        values1 = []
+        for data1 in datasets1.values():
+            x = tuple(data1.get(attr, d) for attr, d in attrs)
+            values1.append(x)
+        values2 = []
+        for data2 in datasets2.values():
+            x = tuple(data2.get(attr, d) for attr, d in attrs)
+            values2.append(x)
+        for vals2 in permutations(values2):
+            for xi, yi in zip(values1, vals2):
+                if not all(map(lambda x, y, z: z(x, y), xi, yi, op)):
+                    # This is not an isomorphism, go to next permutation.
+                    break
+            else:
+                # Then we found an isomorphism.
+                return True
+        else:
+            # Then there are no isomorphisms between the multiedges.
+            return False
+
+    return match
+
+
+# Docstrings for numerical functions.
+generic_node_match.__doc__ = generic_doc
+generic_edge_match.__doc__ = generic_doc.replace("node", "edge")
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/temporalisomorphvf2.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/temporalisomorphvf2.py
new file mode 100644
index 0000000..853e7cd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/temporalisomorphvf2.py
@@ -0,0 +1,308 @@
+"""
+*****************************
+Time-respecting VF2 Algorithm
+*****************************
+
+An extension of the VF2 algorithm for time-respecting graph isomorphism
+testing in temporal graphs.
+
+A temporal graph is one in which edges contain a datetime attribute,
+denoting when interaction occurred between the incident nodes. A
+time-respecting subgraph of a temporal graph is a subgraph such that
+all interactions incident to a node occurred within a time threshold,
+delta, of each other. A directed time-respecting subgraph has the
+added constraint that incoming interactions to a node must precede
+outgoing interactions from the same node - this enforces a sense of
+directed flow.
+
+Introduction
+------------
+
+The TimeRespectingGraphMatcher and TimeRespectingDiGraphMatcher
+extend the GraphMatcher and DiGraphMatcher classes, respectively,
+to include temporal constraints on matches. This is achieved through
+a semantic check, via the semantic_feasibility() function.
+
+As well as including G1 (the graph in which to seek embeddings) and
+G2 (the subgraph structure of interest), the name of the temporal
+attribute on the edges and the time threshold, delta, must be supplied
+as arguments to the matching constructors.
+
+A delta of zero is the strictest temporal constraint on the match -
+only embeddings in which all interactions occur at the same time will
+be returned. A delta of one day will allow embeddings in which
+adjacent interactions occur up to a day apart.
+
+Examples
+--------
+
+Examples will be provided when the datetime type has been incorporated.
+
+
+Temporal Subgraph Isomorphism
+-----------------------------
+
+A brief discussion of the somewhat diverse current literature will be
+included here.
+
+References
+----------
+
+[1] Redmond, U. and Cunningham, P. Temporal subgraph isomorphism. In:
+The 2013 IEEE/ACM International Conference on Advances in Social
+Networks Analysis and Mining (ASONAM). Niagara Falls, Canada; 2013:
+pages 1451 - 1452. [65]
+
+For a discussion of the literature on temporal networks:
+
+[3] P. Holme and J. Saramaki. Temporal networks. Physics Reports,
+519(3):97–125, 2012.
+
+Notes
+-----
+
+Handles directed and undirected graphs and graphs with parallel edges.
+
+"""
+
+import networkx as nx
+
+from .isomorphvf2 import DiGraphMatcher, GraphMatcher
+
+__all__ = ["TimeRespectingGraphMatcher", "TimeRespectingDiGraphMatcher"]
+
+
+class TimeRespectingGraphMatcher(GraphMatcher):
+    def __init__(self, G1, G2, temporal_attribute_name, delta):
+        """Initialize TimeRespectingGraphMatcher.
+
+        G1 and G2 should be nx.Graph or nx.MultiGraph instances.
+
+        Examples
+        --------
+        To create a TimeRespectingGraphMatcher which checks for
+        syntactic and semantic feasibility:
+
+        >>> from networkx.algorithms import isomorphism
+        >>> from datetime import timedelta
+        >>> G1 = nx.Graph(nx.path_graph(4, create_using=nx.Graph()))
+
+        >>> G2 = nx.Graph(nx.path_graph(4, create_using=nx.Graph()))
+
+        >>> GM = isomorphism.TimeRespectingGraphMatcher(
+        ...     G1, G2, "date", timedelta(days=1)
+        ... )
+        """
+        self.temporal_attribute_name = temporal_attribute_name
+        self.delta = delta
+        super().__init__(G1, G2)
+
+    def one_hop(self, Gx, Gx_node, neighbors):
+        """
+        Edges one hop out from a node in the mapping should be
+        time-respecting with respect to each other.
+        """
+        dates = []
+        for n in neighbors:
+            if isinstance(Gx, nx.Graph):  # Graph G[u][v] returns the data dictionary.
+                dates.append(Gx[Gx_node][n][self.temporal_attribute_name])
+            else:  # MultiGraph G[u][v] returns a dictionary of key -> data dictionary.
+                for edge in Gx[Gx_node][
+                    n
+                ].values():  # Iterates all edges between node pair.
+                    dates.append(edge[self.temporal_attribute_name])
+        if any(x is None for x in dates):
+            raise ValueError("Datetime not supplied for at least one edge.")
+        return not dates or max(dates) - min(dates) <= self.delta
+
+    def two_hop(self, Gx, core_x, Gx_node, neighbors):
+        """
+        Paths of length 2 from Gx_node should be time-respecting.
+        """
+        return all(
+            self.one_hop(Gx, v, [n for n in Gx[v] if n in core_x] + [Gx_node])
+            for v in neighbors
+        )
+
+    def semantic_feasibility(self, G1_node, G2_node):
+        """Returns True if adding (G1_node, G2_node) is semantically
+        feasible.
+
+        Any subclass which redefines semantic_feasibility() must
+        maintain the self.tests if needed, to keep the match() method
+        functional. Implementations should consider multigraphs.
+        """
+        neighbors = [n for n in self.G1[G1_node] if n in self.core_1]
+        if not self.one_hop(self.G1, G1_node, neighbors):  # Fail fast on first node.
+            return False
+        if not self.two_hop(self.G1, self.core_1, G1_node, neighbors):
+            return False
+        # Otherwise, this node is semantically feasible!
+        return True
+
+
+class TimeRespectingDiGraphMatcher(DiGraphMatcher):
+    def __init__(self, G1, G2, temporal_attribute_name, delta):
+        """Initialize TimeRespectingDiGraphMatcher.
+
+        G1 and G2 should be nx.DiGraph or nx.MultiDiGraph instances.
+
+        Examples
+        --------
+        To create a TimeRespectingDiGraphMatcher which checks for
+        syntactic and semantic feasibility:
+
+        >>> from networkx.algorithms import isomorphism
+        >>> from datetime import timedelta
+        >>> G1 = nx.DiGraph(nx.path_graph(4, create_using=nx.DiGraph()))
+
+        >>> G2 = nx.DiGraph(nx.path_graph(4, create_using=nx.DiGraph()))
+
+        >>> GM = isomorphism.TimeRespectingDiGraphMatcher(
+        ...     G1, G2, "date", timedelta(days=1)
+        ... )
+        """
+        self.temporal_attribute_name = temporal_attribute_name
+        self.delta = delta
+        super().__init__(G1, G2)
+
+    def get_pred_dates(self, Gx, Gx_node, core_x, pred):
+        """
+        Get the dates of edges from predecessors.
+        """
+        pred_dates = []
+        if isinstance(Gx, nx.DiGraph):  # Graph G[u][v] returns the data dictionary.
+            for n in pred:
+                pred_dates.append(Gx[n][Gx_node][self.temporal_attribute_name])
+        else:  # MultiGraph G[u][v] returns a dictionary of key -> data dictionary.
+            for n in pred:
+                for edge in Gx[n][
+                    Gx_node
+                ].values():  # Iterates all edge data between node pair.
+                    pred_dates.append(edge[self.temporal_attribute_name])
+        return pred_dates
+
+    def get_succ_dates(self, Gx, Gx_node, core_x, succ):
+        """
+        Get the dates of edges to successors.
+        """
+        succ_dates = []
+        if isinstance(Gx, nx.DiGraph):  # Graph G[u][v] returns the data dictionary.
+            for n in succ:
+                succ_dates.append(Gx[Gx_node][n][self.temporal_attribute_name])
+        else:  # MultiGraph G[u][v] returns a dictionary of key -> data dictionary.
+            for n in succ:
+                for edge in Gx[Gx_node][
+                    n
+                ].values():  # Iterates all edge data between node pair.
+                    succ_dates.append(edge[self.temporal_attribute_name])
+        return succ_dates
+
+    def one_hop(self, Gx, Gx_node, core_x, pred, succ):
+        """
+        The ego node.
+        """
+        pred_dates = self.get_pred_dates(Gx, Gx_node, core_x, pred)
+        succ_dates = self.get_succ_dates(Gx, Gx_node, core_x, succ)
+        return self.test_one(pred_dates, succ_dates) and self.test_two(
+            pred_dates, succ_dates
+        )
+
+    def two_hop_pred(self, Gx, Gx_node, core_x, pred):
+        """
+        The predeccessors of the ego node.
+        """
+        return all(
+            self.one_hop(
+                Gx,
+                p,
+                core_x,
+                self.preds(Gx, core_x, p),
+                self.succs(Gx, core_x, p, Gx_node),
+            )
+            for p in pred
+        )
+
+    def two_hop_succ(self, Gx, Gx_node, core_x, succ):
+        """
+        The successors of the ego node.
+        """
+        return all(
+            self.one_hop(
+                Gx,
+                s,
+                core_x,
+                self.preds(Gx, core_x, s, Gx_node),
+                self.succs(Gx, core_x, s),
+            )
+            for s in succ
+        )
+
+    def preds(self, Gx, core_x, v, Gx_node=None):
+        pred = [n for n in Gx.predecessors(v) if n in core_x]
+        if Gx_node:
+            pred.append(Gx_node)
+        return pred
+
+    def succs(self, Gx, core_x, v, Gx_node=None):
+        succ = [n for n in Gx.successors(v) if n in core_x]
+        if Gx_node:
+            succ.append(Gx_node)
+        return succ
+
+    def test_one(self, pred_dates, succ_dates):
+        """
+        Edges one hop out from Gx_node in the mapping should be
+        time-respecting with respect to each other, regardless of
+        direction.
+        """
+        time_respecting = True
+        dates = pred_dates + succ_dates
+
+        if any(x is None for x in dates):
+            raise ValueError("Date or datetime not supplied for at least one edge.")
+
+        dates.sort()  # Small to large.
+        if 0 < len(dates) and not (dates[-1] - dates[0] <= self.delta):
+            time_respecting = False
+        return time_respecting
+
+    def test_two(self, pred_dates, succ_dates):
+        """
+        Edges from a dual Gx_node in the mapping should be ordered in
+        a time-respecting manner.
+        """
+        time_respecting = True
+        pred_dates.sort()
+        succ_dates.sort()
+        # First out before last in; negative of the necessary condition for time-respect.
+        if (
+            0 < len(succ_dates)
+            and 0 < len(pred_dates)
+            and succ_dates[0] < pred_dates[-1]
+        ):
+            time_respecting = False
+        return time_respecting
+
+    def semantic_feasibility(self, G1_node, G2_node):
+        """Returns True if adding (G1_node, G2_node) is semantically
+        feasible.
+
+        Any subclass which redefines semantic_feasibility() must
+        maintain the self.tests if needed, to keep the match() method
+        functional. Implementations should consider multigraphs.
+        """
+        pred, succ = (
+            [n for n in self.G1.predecessors(G1_node) if n in self.core_1],
+            [n for n in self.G1.successors(G1_node) if n in self.core_1],
+        )
+        if not self.one_hop(
+            self.G1, G1_node, self.core_1, pred, succ
+        ):  # Fail fast on first node.
+            return False
+        if not self.two_hop_pred(self.G1, G1_node, self.core_1, pred):
+            return False
+        if not self.two_hop_succ(self.G1, G1_node, self.core_1, succ):
+            return False
+        # Otherwise, this node is semantically feasible!
+        return True
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/iso_r01_s80.A99 b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/iso_r01_s80.A99
new file mode 100644
index 0000000..dac54f0
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/iso_r01_s80.A99 differ
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/iso_r01_s80.B99 b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/iso_r01_s80.B99
new file mode 100644
index 0000000..6c6af68
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/iso_r01_s80.B99 differ
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/si2_b06_m200.A99 b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/si2_b06_m200.A99
new file mode 100644
index 0000000..60c3a3c
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/si2_b06_m200.A99 differ
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/si2_b06_m200.B99 b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/si2_b06_m200.B99
new file mode 100644
index 0000000..0236872
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/si2_b06_m200.B99 differ
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_ismags.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_ismags.py
new file mode 100644
index 0000000..6fa4ab9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_ismags.py
@@ -0,0 +1,327 @@
+"""
+    Tests for ISMAGS isomorphism algorithm.
+"""
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms import isomorphism as iso
+
+
+def _matches_to_sets(matches):
+    """
+    Helper function to facilitate comparing collections of dictionaries in
+    which order does not matter.
+    """
+    return set(map(lambda m: frozenset(m.items()), matches))
+
+
+class TestSelfIsomorphism:
+    data = [
+        (
+            [
+                (0, dict(name="a")),
+                (1, dict(name="a")),
+                (2, dict(name="b")),
+                (3, dict(name="b")),
+                (4, dict(name="a")),
+                (5, dict(name="a")),
+            ],
+            [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
+        ),
+        (range(1, 5), [(1, 2), (2, 4), (4, 3), (3, 1)]),
+        (
+            [],
+            [
+                (0, 1),
+                (1, 2),
+                (2, 3),
+                (3, 4),
+                (4, 5),
+                (5, 0),
+                (0, 6),
+                (6, 7),
+                (2, 8),
+                (8, 9),
+                (4, 10),
+                (10, 11),
+            ],
+        ),
+        ([], [(0, 1), (1, 2), (1, 4), (2, 3), (3, 5), (3, 6)]),
+    ]
+
+    def test_self_isomorphism(self):
+        """
+        For some small, symmetric graphs, make sure that 1) they are isomorphic
+        to themselves, and 2) that only the identity mapping is found.
+        """
+        for node_data, edge_data in self.data:
+            graph = nx.Graph()
+            graph.add_nodes_from(node_data)
+            graph.add_edges_from(edge_data)
+
+            ismags = iso.ISMAGS(
+                graph, graph, node_match=iso.categorical_node_match("name", None)
+            )
+            assert ismags.is_isomorphic()
+            assert ismags.subgraph_is_isomorphic()
+            assert list(ismags.subgraph_isomorphisms_iter(symmetry=True)) == [
+                {n: n for n in graph.nodes}
+            ]
+
+    def test_edgecase_self_isomorphism(self):
+        """
+        This edgecase is one of the cases in which it is hard to find all
+        symmetry elements.
+        """
+        graph = nx.Graph()
+        nx.add_path(graph, range(5))
+        graph.add_edges_from([(2, 5), (5, 6)])
+
+        ismags = iso.ISMAGS(graph, graph)
+        ismags_answer = list(ismags.find_isomorphisms(True))
+        assert ismags_answer == [{n: n for n in graph.nodes}]
+
+        graph = nx.relabel_nodes(graph, {0: 0, 1: 1, 2: 2, 3: 3, 4: 6, 5: 4, 6: 5})
+        ismags = iso.ISMAGS(graph, graph)
+        ismags_answer = list(ismags.find_isomorphisms(True))
+        assert ismags_answer == [{n: n for n in graph.nodes}]
+
+    def test_directed_self_isomorphism(self):
+        """
+        For some small, directed, symmetric graphs, make sure that 1) they are
+        isomorphic to themselves, and 2) that only the identity mapping is
+        found.
+        """
+        for node_data, edge_data in self.data:
+            graph = nx.Graph()
+            graph.add_nodes_from(node_data)
+            graph.add_edges_from(edge_data)
+
+            ismags = iso.ISMAGS(
+                graph, graph, node_match=iso.categorical_node_match("name", None)
+            )
+            assert ismags.is_isomorphic()
+            assert ismags.subgraph_is_isomorphic()
+            assert list(ismags.subgraph_isomorphisms_iter(symmetry=True)) == [
+                {n: n for n in graph.nodes}
+            ]
+
+
+class TestSubgraphIsomorphism:
+    def test_isomorphism(self):
+        g1 = nx.Graph()
+        nx.add_cycle(g1, range(4))
+
+        g2 = nx.Graph()
+        nx.add_cycle(g2, range(4))
+        g2.add_edges_from([(n, m) for n, m in zip(g2, range(4, 8))])
+        ismags = iso.ISMAGS(g2, g1)
+        assert list(ismags.subgraph_isomorphisms_iter(symmetry=True)) == [
+            {n: n for n in g1.nodes}
+        ]
+
+    def test_isomorphism2(self):
+        g1 = nx.Graph()
+        nx.add_path(g1, range(3))
+
+        g2 = g1.copy()
+        g2.add_edge(1, 3)
+
+        ismags = iso.ISMAGS(g2, g1)
+        matches = ismags.subgraph_isomorphisms_iter(symmetry=True)
+        expected_symmetric = [
+            {0: 0, 1: 1, 2: 2},
+            {0: 0, 1: 1, 3: 2},
+            {2: 0, 1: 1, 3: 2},
+        ]
+        assert _matches_to_sets(matches) == _matches_to_sets(expected_symmetric)
+
+        matches = ismags.subgraph_isomorphisms_iter(symmetry=False)
+        expected_asymmetric = [
+            {0: 2, 1: 1, 2: 0},
+            {0: 2, 1: 1, 3: 0},
+            {2: 2, 1: 1, 3: 0},
+        ]
+        assert _matches_to_sets(matches) == _matches_to_sets(
+            expected_symmetric + expected_asymmetric
+        )
+
+    def test_labeled_nodes(self):
+        g1 = nx.Graph()
+        nx.add_cycle(g1, range(3))
+        g1.nodes[1]["attr"] = True
+
+        g2 = g1.copy()
+        g2.add_edge(1, 3)
+        ismags = iso.ISMAGS(g2, g1, node_match=lambda x, y: x == y)
+        matches = ismags.subgraph_isomorphisms_iter(symmetry=True)
+        expected_symmetric = [{0: 0, 1: 1, 2: 2}]
+        assert _matches_to_sets(matches) == _matches_to_sets(expected_symmetric)
+
+        matches = ismags.subgraph_isomorphisms_iter(symmetry=False)
+        expected_asymmetric = [{0: 2, 1: 1, 2: 0}]
+        assert _matches_to_sets(matches) == _matches_to_sets(
+            expected_symmetric + expected_asymmetric
+        )
+
+    def test_labeled_edges(self):
+        g1 = nx.Graph()
+        nx.add_cycle(g1, range(3))
+        g1.edges[1, 2]["attr"] = True
+
+        g2 = g1.copy()
+        g2.add_edge(1, 3)
+        ismags = iso.ISMAGS(g2, g1, edge_match=lambda x, y: x == y)
+        matches = ismags.subgraph_isomorphisms_iter(symmetry=True)
+        expected_symmetric = [{0: 0, 1: 1, 2: 2}]
+        assert _matches_to_sets(matches) == _matches_to_sets(expected_symmetric)
+
+        matches = ismags.subgraph_isomorphisms_iter(symmetry=False)
+        expected_asymmetric = [{1: 2, 0: 0, 2: 1}]
+        assert _matches_to_sets(matches) == _matches_to_sets(
+            expected_symmetric + expected_asymmetric
+        )
+
+
+class TestWikipediaExample:
+    # Nodes 'a', 'b', 'c' and 'd' form a column.
+    # Nodes 'g', 'h', 'i' and 'j' form a column.
+    g1edges = [
+        ["a", "g"],
+        ["a", "h"],
+        ["a", "i"],
+        ["b", "g"],
+        ["b", "h"],
+        ["b", "j"],
+        ["c", "g"],
+        ["c", "i"],
+        ["c", "j"],
+        ["d", "h"],
+        ["d", "i"],
+        ["d", "j"],
+    ]
+
+    # Nodes 1,2,3,4 form the clockwise corners of a large square.
+    # Nodes 5,6,7,8 form the clockwise corners of a small square
+    g2edges = [
+        [1, 2],
+        [2, 3],
+        [3, 4],
+        [4, 1],
+        [5, 6],
+        [6, 7],
+        [7, 8],
+        [8, 5],
+        [1, 5],
+        [2, 6],
+        [3, 7],
+        [4, 8],
+    ]
+
+    def test_graph(self):
+        g1 = nx.Graph()
+        g2 = nx.Graph()
+        g1.add_edges_from(self.g1edges)
+        g2.add_edges_from(self.g2edges)
+        gm = iso.ISMAGS(g1, g2)
+        assert gm.is_isomorphic()
+
+
+class TestLargestCommonSubgraph:
+    def test_mcis(self):
+        # Example graphs from DOI: 10.1002/spe.588
+        graph1 = nx.Graph()
+        graph1.add_edges_from([(1, 2), (2, 3), (2, 4), (3, 4), (4, 5)])
+        graph1.nodes[1]["color"] = 0
+
+        graph2 = nx.Graph()
+        graph2.add_edges_from(
+            [(1, 2), (2, 3), (2, 4), (3, 4), (3, 5), (5, 6), (5, 7), (6, 7)]
+        )
+        graph2.nodes[1]["color"] = 1
+        graph2.nodes[6]["color"] = 2
+        graph2.nodes[7]["color"] = 2
+
+        ismags = iso.ISMAGS(
+            graph1, graph2, node_match=iso.categorical_node_match("color", None)
+        )
+        assert list(ismags.subgraph_isomorphisms_iter(True)) == []
+        assert list(ismags.subgraph_isomorphisms_iter(False)) == []
+        found_mcis = _matches_to_sets(ismags.largest_common_subgraph())
+        expected = _matches_to_sets(
+            [{2: 2, 3: 4, 4: 3, 5: 5}, {2: 4, 3: 2, 4: 3, 5: 5}]
+        )
+        assert expected == found_mcis
+
+        ismags = iso.ISMAGS(
+            graph2, graph1, node_match=iso.categorical_node_match("color", None)
+        )
+        assert list(ismags.subgraph_isomorphisms_iter(True)) == []
+        assert list(ismags.subgraph_isomorphisms_iter(False)) == []
+        found_mcis = _matches_to_sets(ismags.largest_common_subgraph())
+        # Same answer, but reversed.
+        expected = _matches_to_sets(
+            [{2: 2, 3: 4, 4: 3, 5: 5}, {4: 2, 2: 3, 3: 4, 5: 5}]
+        )
+        assert expected == found_mcis
+
+    def test_symmetry_mcis(self):
+        graph1 = nx.Graph()
+        nx.add_path(graph1, range(4))
+
+        graph2 = nx.Graph()
+        nx.add_path(graph2, range(3))
+        graph2.add_edge(1, 3)
+
+        # Only the symmetry of graph2 is taken into account here.
+        ismags1 = iso.ISMAGS(
+            graph1, graph2, node_match=iso.categorical_node_match("color", None)
+        )
+        assert list(ismags1.subgraph_isomorphisms_iter(True)) == []
+        found_mcis = _matches_to_sets(ismags1.largest_common_subgraph())
+        expected = _matches_to_sets([{0: 0, 1: 1, 2: 2}, {1: 0, 3: 2, 2: 1}])
+        assert expected == found_mcis
+
+        # Only the symmetry of graph1 is taken into account here.
+        ismags2 = iso.ISMAGS(
+            graph2, graph1, node_match=iso.categorical_node_match("color", None)
+        )
+        assert list(ismags2.subgraph_isomorphisms_iter(True)) == []
+        found_mcis = _matches_to_sets(ismags2.largest_common_subgraph())
+        expected = _matches_to_sets(
+            [
+                {3: 2, 0: 0, 1: 1},
+                {2: 0, 0: 2, 1: 1},
+                {3: 0, 0: 2, 1: 1},
+                {3: 0, 1: 1, 2: 2},
+                {0: 0, 1: 1, 2: 2},
+                {2: 0, 3: 2, 1: 1},
+            ]
+        )
+
+        assert expected == found_mcis
+
+        found_mcis1 = _matches_to_sets(ismags1.largest_common_subgraph(False))
+        found_mcis2 = ismags2.largest_common_subgraph(False)
+        found_mcis2 = [{v: k for k, v in d.items()} for d in found_mcis2]
+        found_mcis2 = _matches_to_sets(found_mcis2)
+
+        expected = _matches_to_sets(
+            [
+                {3: 2, 1: 3, 2: 1},
+                {2: 0, 0: 2, 1: 1},
+                {1: 2, 3: 3, 2: 1},
+                {3: 0, 1: 3, 2: 1},
+                {0: 2, 2: 3, 1: 1},
+                {3: 0, 1: 2, 2: 1},
+                {2: 0, 0: 3, 1: 1},
+                {0: 0, 2: 3, 1: 1},
+                {1: 0, 3: 3, 2: 1},
+                {1: 0, 3: 2, 2: 1},
+                {0: 3, 1: 1, 2: 2},
+                {0: 0, 1: 1, 2: 2},
+            ]
+        )
+        assert expected == found_mcis1
+        assert expected == found_mcis2
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_isomorphism.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_isomorphism.py
new file mode 100644
index 0000000..c669040
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_isomorphism.py
@@ -0,0 +1,40 @@
+import networkx as nx
+from networkx.algorithms import isomorphism as iso
+
+
+class TestIsomorph:
+    @classmethod
+    def setup_class(cls):
+        cls.G1 = nx.Graph()
+        cls.G2 = nx.Graph()
+        cls.G3 = nx.Graph()
+        cls.G4 = nx.Graph()
+        cls.G5 = nx.Graph()
+        cls.G6 = nx.Graph()
+        cls.G1.add_edges_from([[1, 2], [1, 3], [1, 5], [2, 3]])
+        cls.G2.add_edges_from([[10, 20], [20, 30], [10, 30], [10, 50]])
+        cls.G3.add_edges_from([[1, 2], [1, 3], [1, 5], [2, 5]])
+        cls.G4.add_edges_from([[1, 2], [1, 3], [1, 5], [2, 4]])
+        cls.G5.add_edges_from([[1, 2], [1, 3]])
+        cls.G6.add_edges_from([[10, 20], [20, 30], [10, 30], [10, 50], [20, 50]])
+
+    def test_could_be_isomorphic(self):
+        assert iso.could_be_isomorphic(self.G1, self.G2)
+        assert iso.could_be_isomorphic(self.G1, self.G3)
+        assert not iso.could_be_isomorphic(self.G1, self.G4)
+        assert iso.could_be_isomorphic(self.G3, self.G2)
+        assert not iso.could_be_isomorphic(self.G1, self.G6)
+
+    def test_fast_could_be_isomorphic(self):
+        assert iso.fast_could_be_isomorphic(self.G3, self.G2)
+        assert not iso.fast_could_be_isomorphic(self.G3, self.G5)
+        assert not iso.fast_could_be_isomorphic(self.G1, self.G6)
+
+    def test_faster_could_be_isomorphic(self):
+        assert iso.faster_could_be_isomorphic(self.G3, self.G2)
+        assert not iso.faster_could_be_isomorphic(self.G3, self.G5)
+        assert not iso.faster_could_be_isomorphic(self.G1, self.G6)
+
+    def test_is_isomorphic(self):
+        assert iso.is_isomorphic(self.G1, self.G2)
+        assert not iso.is_isomorphic(self.G1, self.G4)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_isomorphvf2.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_isomorphvf2.py
new file mode 100644
index 0000000..5d3f41b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_isomorphvf2.py
@@ -0,0 +1,403 @@
+"""
+    Tests for VF2 isomorphism algorithm.
+"""
+
+import os
+import random
+import struct
+
+import networkx as nx
+from networkx.algorithms import isomorphism as iso
+
+
+class TestWikipediaExample:
+    # Source: https://en.wikipedia.org/wiki/Graph_isomorphism
+
+    # Nodes 'a', 'b', 'c' and 'd' form a column.
+    # Nodes 'g', 'h', 'i' and 'j' form a column.
+    g1edges = [
+        ["a", "g"],
+        ["a", "h"],
+        ["a", "i"],
+        ["b", "g"],
+        ["b", "h"],
+        ["b", "j"],
+        ["c", "g"],
+        ["c", "i"],
+        ["c", "j"],
+        ["d", "h"],
+        ["d", "i"],
+        ["d", "j"],
+    ]
+
+    # Nodes 1,2,3,4 form the clockwise corners of a large square.
+    # Nodes 5,6,7,8 form the clockwise corners of a small square
+    g2edges = [
+        [1, 2],
+        [2, 3],
+        [3, 4],
+        [4, 1],
+        [5, 6],
+        [6, 7],
+        [7, 8],
+        [8, 5],
+        [1, 5],
+        [2, 6],
+        [3, 7],
+        [4, 8],
+    ]
+
+    def test_graph(self):
+        g1 = nx.Graph()
+        g2 = nx.Graph()
+        g1.add_edges_from(self.g1edges)
+        g2.add_edges_from(self.g2edges)
+        gm = iso.GraphMatcher(g1, g2)
+        assert gm.is_isomorphic()
+        # Just testing some cases
+        assert gm.subgraph_is_monomorphic()
+
+        mapping = sorted(gm.mapping.items())
+
+    # this mapping is only one of the possibilies
+    # so this test needs to be reconsidered
+    #        isomap = [('a', 1), ('b', 6), ('c', 3), ('d', 8),
+    #                  ('g', 2), ('h', 5), ('i', 4), ('j', 7)]
+    #        assert_equal(mapping, isomap)
+
+    def test_subgraph(self):
+        g1 = nx.Graph()
+        g2 = nx.Graph()
+        g1.add_edges_from(self.g1edges)
+        g2.add_edges_from(self.g2edges)
+        g3 = g2.subgraph([1, 2, 3, 4])
+        gm = iso.GraphMatcher(g1, g3)
+        assert gm.subgraph_is_isomorphic()
+
+    def test_subgraph_mono(self):
+        g1 = nx.Graph()
+        g2 = nx.Graph()
+        g1.add_edges_from(self.g1edges)
+        g2.add_edges_from([[1, 2], [2, 3], [3, 4]])
+        gm = iso.GraphMatcher(g1, g2)
+        assert gm.subgraph_is_monomorphic()
+
+
+class TestVF2GraphDB:
+    # https://web.archive.org/web/20090303210205/http://amalfi.dis.unina.it/graph/db/
+
+    @staticmethod
+    def create_graph(filename):
+        """Creates a Graph instance from the filename."""
+
+        # The file is assumed to be in the format from the VF2 graph database.
+        # Each file is composed of 16-bit numbers (unsigned short int).
+        # So we will want to read 2 bytes at a time.
+
+        # We can read the number as follows:
+        #   number = struct.unpack('<H', file.read(2))
+        # This says, expect the data in little-endian encoding
+        # as an unsigned short int and unpack 2 bytes from the file.
+
+        fh = open(filename, mode="rb")
+
+        # Grab the number of nodes.
+        # Node numeration is 0-based, so the first node has index 0.
+        nodes = struct.unpack("<H", fh.read(2))[0]
+
+        graph = nx.Graph()
+        for from_node in range(nodes):
+            # Get the number of edges.
+            edges = struct.unpack("<H", fh.read(2))[0]
+            for edge in range(edges):
+                # Get the terminal node.
+                to_node = struct.unpack("<H", fh.read(2))[0]
+                graph.add_edge(from_node, to_node)
+
+        fh.close()
+        return graph
+
+    def test_graph(self):
+        head, tail = os.path.split(__file__)
+        g1 = self.create_graph(os.path.join(head, "iso_r01_s80.A99"))
+        g2 = self.create_graph(os.path.join(head, "iso_r01_s80.B99"))
+        gm = iso.GraphMatcher(g1, g2)
+        assert gm.is_isomorphic()
+
+    def test_subgraph(self):
+        # A is the subgraph
+        # B is the full graph
+        head, tail = os.path.split(__file__)
+        subgraph = self.create_graph(os.path.join(head, "si2_b06_m200.A99"))
+        graph = self.create_graph(os.path.join(head, "si2_b06_m200.B99"))
+        gm = iso.GraphMatcher(graph, subgraph)
+        assert gm.subgraph_is_isomorphic()
+        # Just testing some cases
+        assert gm.subgraph_is_monomorphic()
+
+    # There isn't a similar test implemented for subgraph monomorphism,
+    # feel free to create one.
+
+
+class TestAtlas:
+    @classmethod
+    def setup_class(cls):
+        global atlas
+        import networkx.generators.atlas as atlas
+
+        cls.GAG = atlas.graph_atlas_g()
+
+    def test_graph_atlas(self):
+        # Atlas = nx.graph_atlas_g()[0:208] # 208, 6 nodes or less
+        Atlas = self.GAG[0:100]
+        alphabet = list(range(26))
+        for graph in Atlas:
+            nlist = list(graph)
+            labels = alphabet[: len(nlist)]
+            for s in range(10):
+                random.shuffle(labels)
+                d = dict(zip(nlist, labels))
+                relabel = nx.relabel_nodes(graph, d)
+                gm = iso.GraphMatcher(graph, relabel)
+                assert gm.is_isomorphic()
+
+
+def test_multiedge():
+    # Simple test for multigraphs
+    # Need something much more rigorous
+    edges = [
+        (0, 1),
+        (1, 2),
+        (2, 3),
+        (3, 4),
+        (4, 5),
+        (5, 6),
+        (6, 7),
+        (7, 8),
+        (8, 9),
+        (9, 10),
+        (10, 11),
+        (10, 11),
+        (11, 12),
+        (11, 12),
+        (12, 13),
+        (12, 13),
+        (13, 14),
+        (13, 14),
+        (14, 15),
+        (14, 15),
+        (15, 16),
+        (15, 16),
+        (16, 17),
+        (16, 17),
+        (17, 18),
+        (17, 18),
+        (18, 19),
+        (18, 19),
+        (19, 0),
+        (19, 0),
+    ]
+    nodes = list(range(20))
+
+    for g1 in [nx.MultiGraph(), nx.MultiDiGraph()]:
+        g1.add_edges_from(edges)
+        for _ in range(10):
+            new_nodes = list(nodes)
+            random.shuffle(new_nodes)
+            d = dict(zip(nodes, new_nodes))
+            g2 = nx.relabel_nodes(g1, d)
+            if not g1.is_directed():
+                gm = iso.GraphMatcher(g1, g2)
+            else:
+                gm = iso.DiGraphMatcher(g1, g2)
+            assert gm.is_isomorphic()
+            # Testing if monomorphism works in multigraphs
+            assert gm.subgraph_is_monomorphic()
+
+
+def test_selfloop():
+    # Simple test for graphs with selfloops
+    edges = [
+        (0, 1),
+        (0, 2),
+        (1, 2),
+        (1, 3),
+        (2, 2),
+        (2, 4),
+        (3, 1),
+        (3, 2),
+        (4, 2),
+        (4, 5),
+        (5, 4),
+    ]
+    nodes = list(range(6))
+
+    for g1 in [nx.Graph(), nx.DiGraph()]:
+        g1.add_edges_from(edges)
+        for _ in range(100):
+            new_nodes = list(nodes)
+            random.shuffle(new_nodes)
+            d = dict(zip(nodes, new_nodes))
+            g2 = nx.relabel_nodes(g1, d)
+            if not g1.is_directed():
+                gm = iso.GraphMatcher(g1, g2)
+            else:
+                gm = iso.DiGraphMatcher(g1, g2)
+            assert gm.is_isomorphic()
+
+
+def test_selfloop_mono():
+    # Simple test for graphs with selfloops
+    edges0 = [
+        (0, 1),
+        (0, 2),
+        (1, 2),
+        (1, 3),
+        (2, 4),
+        (3, 1),
+        (3, 2),
+        (4, 2),
+        (4, 5),
+        (5, 4),
+    ]
+    edges = edges0 + [(2, 2)]
+    nodes = list(range(6))
+
+    for g1 in [nx.Graph(), nx.DiGraph()]:
+        g1.add_edges_from(edges)
+        for _ in range(100):
+            new_nodes = list(nodes)
+            random.shuffle(new_nodes)
+            d = dict(zip(nodes, new_nodes))
+            g2 = nx.relabel_nodes(g1, d)
+            g2.remove_edges_from(nx.selfloop_edges(g2))
+            if not g1.is_directed():
+                gm = iso.GraphMatcher(g2, g1)
+            else:
+                gm = iso.DiGraphMatcher(g2, g1)
+            assert not gm.subgraph_is_monomorphic()
+
+
+def test_isomorphism_iter1():
+    # As described in:
+    # http://groups.google.com/group/networkx-discuss/browse_thread/thread/2ff65c67f5e3b99f/d674544ebea359bb?fwc=1
+    g1 = nx.DiGraph()
+    g2 = nx.DiGraph()
+    g3 = nx.DiGraph()
+    g1.add_edge("A", "B")
+    g1.add_edge("B", "C")
+    g2.add_edge("Y", "Z")
+    g3.add_edge("Z", "Y")
+    gm12 = iso.DiGraphMatcher(g1, g2)
+    gm13 = iso.DiGraphMatcher(g1, g3)
+    x = list(gm12.subgraph_isomorphisms_iter())
+    y = list(gm13.subgraph_isomorphisms_iter())
+    assert {"A": "Y", "B": "Z"} in x
+    assert {"B": "Y", "C": "Z"} in x
+    assert {"A": "Z", "B": "Y"} in y
+    assert {"B": "Z", "C": "Y"} in y
+    assert len(x) == len(y)
+    assert len(x) == 2
+
+
+def test_monomorphism_iter1():
+    g1 = nx.DiGraph()
+    g2 = nx.DiGraph()
+    g1.add_edge("A", "B")
+    g1.add_edge("B", "C")
+    g1.add_edge("C", "A")
+    g2.add_edge("X", "Y")
+    g2.add_edge("Y", "Z")
+    gm12 = iso.DiGraphMatcher(g1, g2)
+    x = list(gm12.subgraph_monomorphisms_iter())
+    assert {"A": "X", "B": "Y", "C": "Z"} in x
+    assert {"A": "Y", "B": "Z", "C": "X"} in x
+    assert {"A": "Z", "B": "X", "C": "Y"} in x
+    assert len(x) == 3
+    gm21 = iso.DiGraphMatcher(g2, g1)
+    # Check if StopIteration exception returns False
+    assert not gm21.subgraph_is_monomorphic()
+
+
+def test_isomorphism_iter2():
+    # Path
+    for L in range(2, 10):
+        g1 = nx.path_graph(L)
+        gm = iso.GraphMatcher(g1, g1)
+        s = len(list(gm.isomorphisms_iter()))
+        assert s == 2
+    # Cycle
+    for L in range(3, 10):
+        g1 = nx.cycle_graph(L)
+        gm = iso.GraphMatcher(g1, g1)
+        s = len(list(gm.isomorphisms_iter()))
+        assert s == 2 * L
+
+
+def test_multiple():
+    # Verify that we can use the graph matcher multiple times
+    edges = [("A", "B"), ("B", "A"), ("B", "C")]
+    for g1, g2 in [(nx.Graph(), nx.Graph()), (nx.DiGraph(), nx.DiGraph())]:
+        g1.add_edges_from(edges)
+        g2.add_edges_from(edges)
+        g3 = nx.subgraph(g2, ["A", "B"])
+        if not g1.is_directed():
+            gmA = iso.GraphMatcher(g1, g2)
+            gmB = iso.GraphMatcher(g1, g3)
+        else:
+            gmA = iso.DiGraphMatcher(g1, g2)
+            gmB = iso.DiGraphMatcher(g1, g3)
+        assert gmA.is_isomorphic()
+        g2.remove_node("C")
+        if not g1.is_directed():
+            gmA = iso.GraphMatcher(g1, g2)
+        else:
+            gmA = iso.DiGraphMatcher(g1, g2)
+        assert gmA.subgraph_is_isomorphic()
+        assert gmB.subgraph_is_isomorphic()
+        assert gmA.subgraph_is_monomorphic()
+        assert gmB.subgraph_is_monomorphic()
+
+
+#        for m in [gmB.mapping, gmB.mapping]:
+#            assert_true(m['A'] == 'A')
+#            assert_true(m['B'] == 'B')
+#            assert_true('C' not in m)
+
+
+def test_noncomparable_nodes():
+    node1 = object()
+    node2 = object()
+    node3 = object()
+
+    # Graph
+    G = nx.path_graph([node1, node2, node3])
+    gm = iso.GraphMatcher(G, G)
+    assert gm.is_isomorphic()
+    # Just testing some cases
+    assert gm.subgraph_is_monomorphic()
+
+    # DiGraph
+    G = nx.path_graph([node1, node2, node3], create_using=nx.DiGraph)
+    H = nx.path_graph([node3, node2, node1], create_using=nx.DiGraph)
+    dgm = iso.DiGraphMatcher(G, H)
+    assert dgm.is_isomorphic()
+    # Just testing some cases
+    assert gm.subgraph_is_monomorphic()
+
+
+def test_monomorphism_edge_match():
+    G = nx.DiGraph()
+    G.add_node(1)
+    G.add_node(2)
+    G.add_edge(1, 2, label="A")
+    G.add_edge(2, 1, label="B")
+    G.add_edge(2, 2, label="C")
+
+    SG = nx.DiGraph()
+    SG.add_node(5)
+    SG.add_node(6)
+    SG.add_edge(5, 6, label="A")
+
+    gm = iso.DiGraphMatcher(G, SG, edge_match=iso.categorical_edge_match("label", None))
+    assert gm.subgraph_is_monomorphic()
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_match_helpers.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_match_helpers.py
new file mode 100644
index 0000000..8ecc242
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_match_helpers.py
@@ -0,0 +1,64 @@
+from operator import eq
+
+import networkx as nx
+from networkx.algorithms import isomorphism as iso
+
+
+def test_categorical_node_match():
+    nm = iso.categorical_node_match(["x", "y", "z"], [None] * 3)
+    assert nm(dict(x=1, y=2, z=3), dict(x=1, y=2, z=3))
+    assert not nm(dict(x=1, y=2, z=2), dict(x=1, y=2, z=1))
+
+
+class TestGenericMultiEdgeMatch:
+    def setup(self):
+        self.G1 = nx.MultiDiGraph()
+        self.G2 = nx.MultiDiGraph()
+        self.G3 = nx.MultiDiGraph()
+        self.G4 = nx.MultiDiGraph()
+        attr_dict1 = {"id": "edge1", "minFlow": 0, "maxFlow": 10}
+        attr_dict2 = {"id": "edge2", "minFlow": -3, "maxFlow": 7}
+        attr_dict3 = {"id": "edge3", "minFlow": 13, "maxFlow": 117}
+        attr_dict4 = {"id": "edge4", "minFlow": 13, "maxFlow": 117}
+        attr_dict5 = {"id": "edge5", "minFlow": 8, "maxFlow": 12}
+        attr_dict6 = {"id": "edge6", "minFlow": 8, "maxFlow": 12}
+        for attr_dict in [
+            attr_dict1,
+            attr_dict2,
+            attr_dict3,
+            attr_dict4,
+            attr_dict5,
+            attr_dict6,
+        ]:
+            self.G1.add_edge(1, 2, **attr_dict)
+        for attr_dict in [
+            attr_dict5,
+            attr_dict3,
+            attr_dict6,
+            attr_dict1,
+            attr_dict4,
+            attr_dict2,
+        ]:
+            self.G2.add_edge(2, 3, **attr_dict)
+        for attr_dict in [attr_dict3, attr_dict5]:
+            self.G3.add_edge(3, 4, **attr_dict)
+        for attr_dict in [attr_dict6, attr_dict4]:
+            self.G4.add_edge(4, 5, **attr_dict)
+
+    def test_generic_multiedge_match(self):
+        full_match = iso.generic_multiedge_match(
+            ["id", "flowMin", "flowMax"], [None] * 3, [eq] * 3
+        )
+        flow_match = iso.generic_multiedge_match(
+            ["flowMin", "flowMax"], [None] * 2, [eq] * 2
+        )
+        min_flow_match = iso.generic_multiedge_match("flowMin", None, eq)
+        id_match = iso.generic_multiedge_match("id", None, eq)
+        assert flow_match(self.G1[1][2], self.G2[2][3])
+        assert min_flow_match(self.G1[1][2], self.G2[2][3])
+        assert id_match(self.G1[1][2], self.G2[2][3])
+        assert full_match(self.G1[1][2], self.G2[2][3])
+        assert flow_match(self.G3[3][4], self.G4[4][5])
+        assert min_flow_match(self.G3[3][4], self.G4[4][5])
+        assert not id_match(self.G3[3][4], self.G4[4][5])
+        assert not full_match(self.G3[3][4], self.G4[4][5])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_temporalisomorphvf2.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_temporalisomorphvf2.py
new file mode 100644
index 0000000..cc95290
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_temporalisomorphvf2.py
@@ -0,0 +1,211 @@
+"""
+    Tests for the temporal aspect of the Temporal VF2 isomorphism algorithm.
+"""
+from datetime import date, datetime, timedelta
+
+import networkx as nx
+from networkx.algorithms import isomorphism as iso
+
+
+def provide_g1_edgelist():
+    return [(0, 1), (0, 2), (1, 2), (2, 4), (1, 3), (3, 4), (4, 5)]
+
+
+def put_same_time(G, att_name):
+    for e in G.edges(data=True):
+        e[2][att_name] = date(2015, 1, 1)
+    return G
+
+
+def put_same_datetime(G, att_name):
+    for e in G.edges(data=True):
+        e[2][att_name] = datetime(2015, 1, 1)
+    return G
+
+
+def put_sequence_time(G, att_name):
+    current_date = date(2015, 1, 1)
+    for e in G.edges(data=True):
+        current_date += timedelta(days=1)
+        e[2][att_name] = current_date
+    return G
+
+
+def put_time_config_0(G, att_name):
+    G[0][1][att_name] = date(2015, 1, 2)
+    G[0][2][att_name] = date(2015, 1, 2)
+    G[1][2][att_name] = date(2015, 1, 3)
+    G[1][3][att_name] = date(2015, 1, 1)
+    G[2][4][att_name] = date(2015, 1, 1)
+    G[3][4][att_name] = date(2015, 1, 3)
+    G[4][5][att_name] = date(2015, 1, 3)
+    return G
+
+
+def put_time_config_1(G, att_name):
+    G[0][1][att_name] = date(2015, 1, 2)
+    G[0][2][att_name] = date(2015, 1, 1)
+    G[1][2][att_name] = date(2015, 1, 3)
+    G[1][3][att_name] = date(2015, 1, 1)
+    G[2][4][att_name] = date(2015, 1, 2)
+    G[3][4][att_name] = date(2015, 1, 4)
+    G[4][5][att_name] = date(2015, 1, 3)
+    return G
+
+
+def put_time_config_2(G, att_name):
+    G[0][1][att_name] = date(2015, 1, 1)
+    G[0][2][att_name] = date(2015, 1, 1)
+    G[1][2][att_name] = date(2015, 1, 3)
+    G[1][3][att_name] = date(2015, 1, 2)
+    G[2][4][att_name] = date(2015, 1, 2)
+    G[3][4][att_name] = date(2015, 1, 3)
+    G[4][5][att_name] = date(2015, 1, 2)
+    return G
+
+
+class TestTimeRespectingGraphMatcher:
+    """
+    A test class for the undirected temporal graph matcher.
+    """
+
+    def provide_g1_topology(self):
+        G1 = nx.Graph()
+        G1.add_edges_from(provide_g1_edgelist())
+        return G1
+
+    def provide_g2_path_3edges(self):
+        G2 = nx.Graph()
+        G2.add_edges_from([(0, 1), (1, 2), (2, 3)])
+        return G2
+
+    def test_timdelta_zero_timeRespecting_returnsTrue(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "date"
+        G1 = put_same_time(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta()
+        gm = iso.TimeRespectingGraphMatcher(G1, G2, temporal_name, d)
+        assert gm.subgraph_is_isomorphic()
+
+    def test_timdelta_zero_datetime_timeRespecting_returnsTrue(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "date"
+        G1 = put_same_datetime(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta()
+        gm = iso.TimeRespectingGraphMatcher(G1, G2, temporal_name, d)
+        assert gm.subgraph_is_isomorphic()
+
+    def test_attNameStrange_timdelta_zero_timeRespecting_returnsTrue(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "strange_name"
+        G1 = put_same_time(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta()
+        gm = iso.TimeRespectingGraphMatcher(G1, G2, temporal_name, d)
+        assert gm.subgraph_is_isomorphic()
+
+    def test_notTimeRespecting_returnsFalse(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "date"
+        G1 = put_sequence_time(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta()
+        gm = iso.TimeRespectingGraphMatcher(G1, G2, temporal_name, d)
+        assert not gm.subgraph_is_isomorphic()
+
+    def test_timdelta_one_config0_returns_no_embeddings(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "date"
+        G1 = put_time_config_0(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta(days=1)
+        gm = iso.TimeRespectingGraphMatcher(G1, G2, temporal_name, d)
+        count_match = len(list(gm.subgraph_isomorphisms_iter()))
+        assert count_match == 0
+
+    def test_timdelta_one_config1_returns_four_embedding(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "date"
+        G1 = put_time_config_1(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta(days=1)
+        gm = iso.TimeRespectingGraphMatcher(G1, G2, temporal_name, d)
+        count_match = len(list(gm.subgraph_isomorphisms_iter()))
+        assert count_match == 4
+
+    def test_timdelta_one_config2_returns_ten_embeddings(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "date"
+        G1 = put_time_config_2(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta(days=1)
+        gm = iso.TimeRespectingGraphMatcher(G1, G2, temporal_name, d)
+        L = list(gm.subgraph_isomorphisms_iter())
+        count_match = len(list(gm.subgraph_isomorphisms_iter()))
+        assert count_match == 10
+
+
+class TestDiTimeRespectingGraphMatcher:
+    """
+    A test class for the directed time-respecting graph matcher.
+    """
+
+    def provide_g1_topology(self):
+        G1 = nx.DiGraph()
+        G1.add_edges_from(provide_g1_edgelist())
+        return G1
+
+    def provide_g2_path_3edges(self):
+        G2 = nx.DiGraph()
+        G2.add_edges_from([(0, 1), (1, 2), (2, 3)])
+        return G2
+
+    def test_timdelta_zero_same_dates_returns_true(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "date"
+        G1 = put_same_time(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta()
+        gm = iso.TimeRespectingDiGraphMatcher(G1, G2, temporal_name, d)
+        assert gm.subgraph_is_isomorphic()
+
+    def test_attNameStrange_timdelta_zero_same_dates_returns_true(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "strange"
+        G1 = put_same_time(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta()
+        gm = iso.TimeRespectingDiGraphMatcher(G1, G2, temporal_name, d)
+        assert gm.subgraph_is_isomorphic()
+
+    def test_timdelta_one_config0_returns_no_embeddings(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "date"
+        G1 = put_time_config_0(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta(days=1)
+        gm = iso.TimeRespectingDiGraphMatcher(G1, G2, temporal_name, d)
+        count_match = len(list(gm.subgraph_isomorphisms_iter()))
+        assert count_match == 0
+
+    def test_timdelta_one_config1_returns_one_embedding(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "date"
+        G1 = put_time_config_1(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta(days=1)
+        gm = iso.TimeRespectingDiGraphMatcher(G1, G2, temporal_name, d)
+        count_match = len(list(gm.subgraph_isomorphisms_iter()))
+        assert count_match == 1
+
+    def test_timdelta_one_config2_returns_two_embeddings(self):
+        G1 = self.provide_g1_topology()
+        temporal_name = "date"
+        G1 = put_time_config_2(G1, temporal_name)
+        G2 = self.provide_g2_path_3edges()
+        d = timedelta(days=1)
+        gm = iso.TimeRespectingDiGraphMatcher(G1, G2, temporal_name, d)
+        count_match = len(list(gm.subgraph_isomorphisms_iter()))
+        assert count_match == 2
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_tree_isomorphism.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_tree_isomorphism.py
new file mode 100644
index 0000000..1628bea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_tree_isomorphism.py
@@ -0,0 +1,289 @@
+import random
+import time
+
+import networkx as nx
+from networkx.algorithms.isomorphism.tree_isomorphism import (
+    rooted_tree_isomorphism,
+    tree_isomorphism,
+)
+from networkx.classes.function import is_directed
+
+
+# have this work for graph
+# given two trees (either the directed or undirected)
+# transform t2 according to the isomorphism
+# and confirm it is identical to t1
+# randomize the order of the edges when constructing
+def check_isomorphism(t1, t2, isomorphism):
+
+    # get the name of t1, given the name in t2
+    mapping = {v2: v1 for (v1, v2) in isomorphism}
+
+    # these should be the same
+    d1 = is_directed(t1)
+    d2 = is_directed(t2)
+    assert d1 == d2
+
+    edges_1 = []
+    for (u, v) in t1.edges():
+        if d1:
+            edges_1.append((u, v))
+        else:
+            # if not directed, then need to
+            # put the edge in a consistent direction
+            if u < v:
+                edges_1.append((u, v))
+            else:
+                edges_1.append((v, u))
+
+    edges_2 = []
+    for (u, v) in t2.edges():
+        # translate to names for t1
+        u = mapping[u]
+        v = mapping[v]
+        if d2:
+            edges_2.append((u, v))
+        else:
+            if u < v:
+                edges_2.append((u, v))
+            else:
+                edges_2.append((v, u))
+
+    return sorted(edges_1) == sorted(edges_2)
+
+
+def test_hardcoded():
+
+    print("hardcoded test")
+
+    # define a test problem
+    edges_1 = [
+        ("a", "b"),
+        ("a", "c"),
+        ("a", "d"),
+        ("b", "e"),
+        ("b", "f"),
+        ("e", "j"),
+        ("e", "k"),
+        ("c", "g"),
+        ("c", "h"),
+        ("g", "m"),
+        ("d", "i"),
+        ("f", "l"),
+    ]
+
+    edges_2 = [
+        ("v", "y"),
+        ("v", "z"),
+        ("u", "x"),
+        ("q", "u"),
+        ("q", "v"),
+        ("p", "t"),
+        ("n", "p"),
+        ("n", "q"),
+        ("n", "o"),
+        ("o", "r"),
+        ("o", "s"),
+        ("s", "w"),
+    ]
+
+    # there are two possible correct isomorphisms
+    # it currently returns isomorphism1
+    # but the second is also correct
+    isomorphism1 = [
+        ("a", "n"),
+        ("b", "q"),
+        ("c", "o"),
+        ("d", "p"),
+        ("e", "v"),
+        ("f", "u"),
+        ("g", "s"),
+        ("h", "r"),
+        ("i", "t"),
+        ("j", "y"),
+        ("k", "z"),
+        ("l", "x"),
+        ("m", "w"),
+    ]
+
+    # could swap y and z
+    isomorphism2 = [
+        ("a", "n"),
+        ("b", "q"),
+        ("c", "o"),
+        ("d", "p"),
+        ("e", "v"),
+        ("f", "u"),
+        ("g", "s"),
+        ("h", "r"),
+        ("i", "t"),
+        ("j", "z"),
+        ("k", "y"),
+        ("l", "x"),
+        ("m", "w"),
+    ]
+
+    t1 = nx.Graph()
+    t1.add_edges_from(edges_1)
+    root1 = "a"
+
+    t2 = nx.Graph()
+    t2.add_edges_from(edges_2)
+    root2 = "n"
+
+    isomorphism = sorted(rooted_tree_isomorphism(t1, root1, t2, root2))
+
+    # is correct by hand
+    assert (isomorphism == isomorphism1) or (isomorphism == isomorphism2)
+
+    # check algorithmically
+    assert check_isomorphism(t1, t2, isomorphism)
+
+    # try again as digraph
+    t1 = nx.DiGraph()
+    t1.add_edges_from(edges_1)
+    root1 = "a"
+
+    t2 = nx.DiGraph()
+    t2.add_edges_from(edges_2)
+    root2 = "n"
+
+    isomorphism = sorted(rooted_tree_isomorphism(t1, root1, t2, root2))
+
+    # is correct by hand
+    assert (isomorphism == isomorphism1) or (isomorphism == isomorphism2)
+
+    # check algorithmically
+    assert check_isomorphism(t1, t2, isomorphism)
+
+
+# randomly swap a tuple (a,b)
+def random_swap(t):
+    (a, b) = t
+    if random.randint(0, 1) == 1:
+        return (a, b)
+    else:
+        return (b, a)
+
+
+# given a tree t1, create a new tree t2
+# that is isomorphic to t1, with a known isomorphism
+# and test that our algorithm found the right one
+def positive_single_tree(t1):
+
+    assert nx.is_tree(t1)
+
+    nodes1 = [n for n in t1.nodes()]
+    # get a random permutation of this
+    nodes2 = nodes1.copy()
+    random.shuffle(nodes2)
+
+    # this is one isomorphism, however they may be multiple
+    # so we don't necessarily get this one back
+    someisomorphism = [(u, v) for (u, v) in zip(nodes1, nodes2)]
+
+    # map from old to new
+    map1to2 = {u: v for (u, v) in someisomorphism}
+
+    # get the edges with the transformed names
+    edges2 = [random_swap((map1to2[u], map1to2[v])) for (u, v) in t1.edges()]
+    # randomly permute, to ensure we're not relying on edge order somehow
+    random.shuffle(edges2)
+
+    # so t2 is isomorphic to t1
+    t2 = nx.Graph()
+    t2.add_edges_from(edges2)
+
+    # lets call our code to see if t1 and t2 are isomorphic
+    isomorphism = tree_isomorphism(t1, t2)
+
+    # make sure we got a correct solution
+    # although not necessarily someisomorphism
+    assert len(isomorphism) > 0
+    assert check_isomorphism(t1, t2, isomorphism)
+
+
+# run positive_single_tree over all the
+# non-isomorphic trees for k from 4 to maxk
+# k = 4 is the first level that has more than 1 non-isomorphic tree
+# k = 13 takes about 2.86 seconds to run on my laptop
+# larger values run slow down significantly
+# as the number of trees grows rapidly
+def test_positive(maxk=14):
+
+    print("positive test")
+
+    for k in range(2, maxk + 1):
+        start_time = time.time()
+        trial = 0
+        for t in nx.nonisomorphic_trees(k):
+            positive_single_tree(t)
+            trial += 1
+        print(k, trial, time.time() - start_time)
+
+
+# test the trivial case of a single node in each tree
+# note that nonisomorphic_trees doesn't work for k = 1
+def test_trivial():
+
+    print("trivial test")
+
+    # back to an undirected graph
+    t1 = nx.Graph()
+    t1.add_node("a")
+    root1 = "a"
+
+    t2 = nx.Graph()
+    t2.add_node("n")
+    root2 = "n"
+
+    isomorphism = rooted_tree_isomorphism(t1, root1, t2, root2)
+
+    assert isomorphism == [("a", "n")]
+
+    assert check_isomorphism(t1, t2, isomorphism)
+
+
+# test another trivial case where the two graphs have
+# different numbers of nodes
+def test_trivial_2():
+
+    print("trivial test 2")
+
+    edges_1 = [("a", "b"), ("a", "c")]
+
+    edges_2 = [("v", "y")]
+
+    t1 = nx.Graph()
+    t1.add_edges_from(edges_1)
+
+    t2 = nx.Graph()
+    t2.add_edges_from(edges_2)
+
+    isomorphism = tree_isomorphism(t1, t2)
+
+    # they cannot be isomorphic,
+    # since they have different numbers of nodes
+    assert isomorphism == []
+
+
+# the function nonisomorphic_trees generates all the non-isomorphic
+# trees of a given size.  Take each pair of these and verify that
+# they are not isomorphic
+# k = 4 is the first level that has more than 1 non-isomorphic tree
+# k = 11 takes about 4.76 seconds to run on my laptop
+# larger values run slow down significantly
+# as the number of trees grows rapidly
+def test_negative(maxk=11):
+
+    print("negative test")
+
+    for k in range(4, maxk + 1):
+        test_trees = list(nx.nonisomorphic_trees(k))
+        start_time = time.time()
+        trial = 0
+        for i in range(len(test_trees) - 1):
+            for j in range(i + 1, len(test_trees)):
+                trial += 1
+                assert tree_isomorphism(test_trees[i], test_trees[j]) == []
+        print(k, trial, time.time() - start_time)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_vf2userfunc.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_vf2userfunc.py
new file mode 100644
index 0000000..5a22d41
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tests/test_vf2userfunc.py
@@ -0,0 +1,201 @@
+"""
+    Tests for VF2 isomorphism algorithm for weighted graphs.
+"""
+
+import math
+from operator import eq
+
+import networkx as nx
+import networkx.algorithms.isomorphism as iso
+
+
+def test_simple():
+    # 16 simple tests
+    w = "weight"
+    edges = [(0, 0, 1), (0, 0, 1.5), (0, 1, 2), (1, 0, 3)]
+    for g1 in [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]:
+
+        g1.add_weighted_edges_from(edges)
+        g2 = g1.subgraph(g1.nodes())
+        if g1.is_multigraph():
+            em = iso.numerical_multiedge_match("weight", 1)
+        else:
+            em = iso.numerical_edge_match("weight", 1)
+        assert nx.is_isomorphic(g1, g2, edge_match=em)
+
+        for mod1, mod2 in [(False, True), (True, False), (True, True)]:
+            # mod1 tests a regular edge
+            # mod2 tests a selfloop
+            if g2.is_multigraph():
+                if mod1:
+                    data1 = {0: {"weight": 10}}
+                if mod2:
+                    data2 = {0: {"weight": 1}, 1: {"weight": 2.5}}
+            else:
+                if mod1:
+                    data1 = {"weight": 10}
+                if mod2:
+                    data2 = {"weight": 2.5}
+
+            g2 = g1.subgraph(g1.nodes()).copy()
+            if mod1:
+                if not g1.is_directed():
+                    g2._adj[1][0] = data1
+                    g2._adj[0][1] = data1
+                else:
+                    g2._succ[1][0] = data1
+                    g2._pred[0][1] = data1
+            if mod2:
+                if not g1.is_directed():
+                    g2._adj[0][0] = data2
+                else:
+                    g2._succ[0][0] = data2
+                    g2._pred[0][0] = data2
+
+            assert not nx.is_isomorphic(g1, g2, edge_match=em)
+
+
+def test_weightkey():
+    g1 = nx.DiGraph()
+    g2 = nx.DiGraph()
+
+    g1.add_edge("A", "B", weight=1)
+    g2.add_edge("C", "D", weight=0)
+
+    assert nx.is_isomorphic(g1, g2)
+    em = iso.numerical_edge_match("nonexistent attribute", 1)
+    assert nx.is_isomorphic(g1, g2, edge_match=em)
+    em = iso.numerical_edge_match("weight", 1)
+    assert not nx.is_isomorphic(g1, g2, edge_match=em)
+
+    g2 = nx.DiGraph()
+    g2.add_edge("C", "D")
+    assert nx.is_isomorphic(g1, g2, edge_match=em)
+
+
+class TestNodeMatch_Graph:
+    def setup_method(self):
+        self.g1 = nx.Graph()
+        self.g2 = nx.Graph()
+        self.build()
+
+    def build(self):
+        self.nm = iso.categorical_node_match("color", "")
+        self.em = iso.numerical_edge_match("weight", 1)
+
+        self.g1.add_node("A", color="red")
+        self.g2.add_node("C", color="blue")
+
+        self.g1.add_edge("A", "B", weight=1)
+        self.g2.add_edge("C", "D", weight=1)
+
+    def test_noweight_nocolor(self):
+        assert nx.is_isomorphic(self.g1, self.g2)
+
+    def test_color1(self):
+        assert not nx.is_isomorphic(self.g1, self.g2, node_match=self.nm)
+
+    def test_color2(self):
+        self.g1.nodes["A"]["color"] = "blue"
+        assert nx.is_isomorphic(self.g1, self.g2, node_match=self.nm)
+
+    def test_weight1(self):
+        assert nx.is_isomorphic(self.g1, self.g2, edge_match=self.em)
+
+    def test_weight2(self):
+        self.g1.add_edge("A", "B", weight=2)
+        assert not nx.is_isomorphic(self.g1, self.g2, edge_match=self.em)
+
+    def test_colorsandweights1(self):
+        iso = nx.is_isomorphic(self.g1, self.g2, node_match=self.nm, edge_match=self.em)
+        assert not iso
+
+    def test_colorsandweights2(self):
+        self.g1.nodes["A"]["color"] = "blue"
+        iso = nx.is_isomorphic(self.g1, self.g2, node_match=self.nm, edge_match=self.em)
+        assert iso
+
+    def test_colorsandweights3(self):
+        # make the weights disagree
+        self.g1.add_edge("A", "B", weight=2)
+        assert not nx.is_isomorphic(
+            self.g1, self.g2, node_match=self.nm, edge_match=self.em
+        )
+
+
+class TestEdgeMatch_MultiGraph:
+    def setup_method(self):
+        self.g1 = nx.MultiGraph()
+        self.g2 = nx.MultiGraph()
+        self.GM = iso.MultiGraphMatcher
+        self.build()
+
+    def build(self):
+        g1 = self.g1
+        g2 = self.g2
+
+        # We will assume integer weights only.
+        g1.add_edge("A", "B", color="green", weight=0, size=0.5)
+        g1.add_edge("A", "B", color="red", weight=1, size=0.35)
+        g1.add_edge("A", "B", color="red", weight=2, size=0.65)
+
+        g2.add_edge("C", "D", color="green", weight=1, size=0.5)
+        g2.add_edge("C", "D", color="red", weight=0, size=0.45)
+        g2.add_edge("C", "D", color="red", weight=2, size=0.65)
+
+        if g1.is_multigraph():
+            self.em = iso.numerical_multiedge_match("weight", 1)
+            self.emc = iso.categorical_multiedge_match("color", "")
+            self.emcm = iso.categorical_multiedge_match(["color", "weight"], ["", 1])
+            self.emg1 = iso.generic_multiedge_match("color", "red", eq)
+            self.emg2 = iso.generic_multiedge_match(
+                ["color", "weight", "size"],
+                ["red", 1, 0.5],
+                [eq, eq, math.isclose],
+            )
+        else:
+            self.em = iso.numerical_edge_match("weight", 1)
+            self.emc = iso.categorical_edge_match("color", "")
+            self.emcm = iso.categorical_edge_match(["color", "weight"], ["", 1])
+            self.emg1 = iso.generic_multiedge_match("color", "red", eq)
+            self.emg2 = iso.generic_edge_match(
+                ["color", "weight", "size"],
+                ["red", 1, 0.5],
+                [eq, eq, math.isclose],
+            )
+
+    def test_weights_only(self):
+        assert nx.is_isomorphic(self.g1, self.g2, edge_match=self.em)
+
+    def test_colors_only(self):
+        gm = self.GM(self.g1, self.g2, edge_match=self.emc)
+        assert gm.is_isomorphic()
+
+    def test_colorsandweights(self):
+        gm = self.GM(self.g1, self.g2, edge_match=self.emcm)
+        assert not gm.is_isomorphic()
+
+    def test_generic1(self):
+        gm = self.GM(self.g1, self.g2, edge_match=self.emg1)
+        assert gm.is_isomorphic()
+
+    def test_generic2(self):
+        gm = self.GM(self.g1, self.g2, edge_match=self.emg2)
+        assert not gm.is_isomorphic()
+
+
+class TestEdgeMatch_DiGraph(TestNodeMatch_Graph):
+    def setup_method(self):
+        TestNodeMatch_Graph.setup_method(self)
+        self.g1 = nx.DiGraph()
+        self.g2 = nx.DiGraph()
+        self.build()
+
+
+class TestEdgeMatch_MultiDiGraph(TestEdgeMatch_MultiGraph):
+    def setup_method(self):
+        TestEdgeMatch_MultiGraph.setup_method(self)
+        self.g1 = nx.MultiDiGraph()
+        self.g2 = nx.MultiDiGraph()
+        self.GM = iso.MultiDiGraphMatcher
+        self.build()
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tree_isomorphism.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tree_isomorphism.py
new file mode 100644
index 0000000..7e13d02
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/tree_isomorphism.py
@@ -0,0 +1,279 @@
+"""
+An algorithm for finding if two undirected trees are isomorphic,
+and if so returns an isomorphism between the two sets of nodes.
+
+This algorithm uses a routine to tell if two rooted trees (trees with a
+specified root node) are isomorphic, which may be independently useful.
+
+This implements an algorithm from:
+The Design and Analysis of Computer Algorithms
+by Aho, Hopcroft, and Ullman
+Addison-Wesley Publishing 1974
+Example 3.2 pp. 84-86.
+
+A more understandable version of this algorithm is described in:
+Homework Assignment 5
+McGill University SOCS 308-250B, Winter 2002
+by Matthew Suderman
+http://crypto.cs.mcgill.ca/~crepeau/CS250/2004/HW5+.pdf
+"""
+
+import networkx as nx
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = ["rooted_tree_isomorphism", "tree_isomorphism"]
+
+
+def root_trees(t1, root1, t2, root2):
+    """Create a single digraph dT of free trees t1 and t2
+    #   with roots root1 and root2 respectively
+    # rename the nodes with consecutive integers
+    # so that all nodes get a unique name between both trees
+
+    # our new "fake" root node is 0
+    # t1 is numbers from 1 ... n
+    # t2 is numbered from n+1 to 2n
+    """
+
+    dT = nx.DiGraph()
+
+    newroot1 = 1  # left root will be 1
+    newroot2 = nx.number_of_nodes(t1) + 1  # right will be n+1
+
+    # may be overlap in node names here so need separate maps
+    # given the old name, what is the new
+    namemap1 = {root1: newroot1}
+    namemap2 = {root2: newroot2}
+
+    # add an edge from our new root to root1 and root2
+    dT.add_edge(0, namemap1[root1])
+    dT.add_edge(0, namemap2[root2])
+
+    for i, (v1, v2) in enumerate(nx.bfs_edges(t1, root1)):
+        namemap1[v2] = i + namemap1[root1] + 1
+        dT.add_edge(namemap1[v1], namemap1[v2])
+
+    for i, (v1, v2) in enumerate(nx.bfs_edges(t2, root2)):
+        namemap2[v2] = i + namemap2[root2] + 1
+        dT.add_edge(namemap2[v1], namemap2[v2])
+
+    # now we really want the inverse of namemap1 and namemap2
+    # giving the old name given the new
+    # since the values of namemap1 and namemap2 are unique
+    # there won't be collisions
+    namemap = {}
+    for old, new in namemap1.items():
+        namemap[new] = old
+    for old, new in namemap2.items():
+        namemap[new] = old
+
+    return (dT, namemap, newroot1, newroot2)
+
+
+# figure out the level of each node, with 0 at root
+def assign_levels(G, root):
+    level = {}
+    level[root] = 0
+    for (v1, v2) in nx.bfs_edges(G, root):
+        level[v2] = level[v1] + 1
+
+    return level
+
+
+# now group the nodes at each level
+def group_by_levels(levels):
+    L = {}
+    for (n, lev) in levels.items():
+        if lev not in L:
+            L[lev] = []
+        L[lev].append(n)
+
+    return L
+
+
+# now lets get the isomorphism by walking the ordered_children
+def generate_isomorphism(v, w, M, ordered_children):
+    # make sure tree1 comes first
+    assert v < w
+    M.append((v, w))
+    for i, (x, y) in enumerate(zip(ordered_children[v], ordered_children[w])):
+        generate_isomorphism(x, y, M, ordered_children)
+
+
+def rooted_tree_isomorphism(t1, root1, t2, root2):
+    """
+    Given two rooted trees `t1` and `t2`,
+    with roots `root1` and `root2` respectivly
+    this routine will determine if they are isomorphic.
+
+    These trees may be either directed or undirected,
+    but if they are directed, all edges should flow from the root.
+
+    It returns the isomorphism, a mapping of the nodes of `t1` onto the nodes
+    of `t2`, such that two trees are then identical.
+
+    Note that two trees may have more than one isomorphism, and this
+    routine just returns one valid mapping.
+
+    Parameters
+    ----------
+    `t1` :  NetworkX graph
+        One of the trees being compared
+
+    `root1` : a node of `t1` which is the root of the tree
+
+    `t2` : undirected NetworkX graph
+        The other tree being compared
+
+    `root2` : a node of `t2` which is the root of the tree
+
+    This is a subroutine used to implement `tree_isomorphism`, but will
+    be somewhat faster if you already have rooted trees.
+
+    Returns
+    -------
+    isomorphism : list
+        A list of pairs in which the left element is a node in `t1`
+        and the right element is a node in `t2`.  The pairs are in
+        arbitrary order.  If the nodes in one tree is mapped to the names in
+        the other, then trees will be identical. Note that an isomorphism
+        will not necessarily be unique.
+
+        If `t1` and `t2` are not isomorphic, then it returns the empty list.
+    """
+
+    assert nx.is_tree(t1)
+    assert nx.is_tree(t2)
+
+    # get the rooted tree formed by combining them
+    # with unique names
+    (dT, namemap, newroot1, newroot2) = root_trees(t1, root1, t2, root2)
+
+    # compute the distance from the root, with 0 for our
+    levels = assign_levels(dT, 0)
+
+    # height
+    h = max(levels.values())
+
+    # collect nodes into a dict by level
+    L = group_by_levels(levels)
+
+    # each node has a label, initially set to 0
+    label = {v: 0 for v in dT}
+    # and also ordered_labels and ordered_children
+    # which will store ordered tuples
+    ordered_labels = {v: () for v in dT}
+    ordered_children = {v: () for v in dT}
+
+    # nothing to do on last level so start on h-1
+    # also nothing to do for our fake level 0, so skip that
+    for i in range(h - 1, 0, -1):
+        # update the ordered_labels and ordered_childen
+        # for any children
+        for v in L[i]:
+            # nothing to do if no children
+            if dT.out_degree(v) > 0:
+                # get all the pairs of labels and nodes of children
+                # and sort by labels
+                s = sorted((label[u], u) for u in dT.successors(v))
+
+                # invert to give a list of two tuples
+                # the sorted labels, and the corresponding children
+                ordered_labels[v], ordered_children[v] = list(zip(*s))
+
+        # now collect and sort the sorted ordered_labels
+        # for all nodes in L[i], carrying along the node
+        forlabel = sorted((ordered_labels[v], v) for v in L[i])
+
+        # now assign labels to these nodes, according to the sorted order
+        # starting from 0, where idential ordered_labels get the same label
+        current = 0
+        for i, (ol, v) in enumerate(forlabel):
+            # advance to next label if not 0, and different from previous
+            if (i != 0) and (ol != forlabel[i - 1][0]):
+                current += 1
+            label[v] = current
+
+    # they are isomorphic if the labels of newroot1 and newroot2 are 0
+    isomorphism = []
+    if label[newroot1] == 0 and label[newroot2] == 0:
+        generate_isomorphism(newroot1, newroot2, isomorphism, ordered_children)
+
+        # get the mapping back in terms of the old names
+        # return in sorted order for neatness
+        isomorphism = [(namemap[u], namemap[v]) for (u, v) in isomorphism]
+
+    return isomorphism
+
+
+@not_implemented_for("directed", "multigraph")
+def tree_isomorphism(t1, t2):
+    """
+    Given two undirected (or free) trees `t1` and `t2`,
+    this routine will determine if they are isomorphic.
+    It returns the isomorphism, a mapping of the nodes of `t1` onto the nodes
+    of `t2`, such that two trees are then identical.
+
+    Note that two trees may have more than one isomorphism, and this
+    routine just returns one valid mapping.
+
+    Parameters
+    ----------
+    t1 : undirected NetworkX graph
+        One of the trees being compared
+
+    t2 : undirected NetworkX graph
+        The other tree being compared
+
+    Returns
+    -------
+    isomorphism : list
+        A list of pairs in which the left element is a node in `t1`
+        and the right element is a node in `t2`.  The pairs are in
+        arbitrary order.  If the nodes in one tree is mapped to the names in
+        the other, then trees will be identical. Note that an isomorphism
+        will not necessarily be unique.
+
+        If `t1` and `t2` are not isomorphic, then it returns the empty list.
+
+    Notes
+    -----
+    This runs in O(n*log(n)) time for trees with n nodes.
+    """
+
+    assert nx.is_tree(t1)
+    assert nx.is_tree(t2)
+
+    # To be isomrophic, t1 and t2 must have the same number of nodes.
+    if nx.number_of_nodes(t1) != nx.number_of_nodes(t2):
+        return []
+
+    # Another shortcut is that the sorted degree sequences need to be the same.
+    degree_sequence1 = sorted(d for (n, d) in t1.degree())
+    degree_sequence2 = sorted(d for (n, d) in t2.degree())
+
+    if degree_sequence1 != degree_sequence2:
+        return []
+
+    # A tree can have either 1 or 2 centers.
+    # If the number doesn't match then t1 and t2 are not isomorphic.
+    center1 = nx.center(t1)
+    center2 = nx.center(t2)
+
+    if len(center1) != len(center2):
+        return []
+
+    # If there is only 1 center in each, then use it.
+    if len(center1) == 1:
+        return rooted_tree_isomorphism(t1, center1[0], t2, center2[0])
+
+    # If there both have 2 centers,  then try the first for t1
+    # with the first for t2.
+    attemps = rooted_tree_isomorphism(t1, center1[0], t2, center2[0])
+
+    # If that worked we're done.
+    if len(attemps) > 0:
+        return attemps
+
+    # Otherwise, try center1[0] with the center2[1], and see if that works
+    return rooted_tree_isomorphism(t1, center1[0], t2, center2[1])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/vf2userfunc.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/vf2userfunc.py
new file mode 100644
index 0000000..349129e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/isomorphism/vf2userfunc.py
@@ -0,0 +1,197 @@
+"""
+    Module to simplify the specification of user-defined equality functions for
+    node and edge attributes during isomorphism checks.
+
+    During the construction of an isomorphism, the algorithm considers two
+    candidate nodes n1 in G1 and n2 in G2.  The graphs G1 and G2 are then
+    compared with respect to properties involving n1 and n2, and if the outcome
+    is good, then the candidate nodes are considered isomorphic. NetworkX
+    provides a simple mechanism for users to extend the comparisons to include
+    node and edge attributes.
+
+    Node attributes are handled by the node_match keyword. When considering
+    n1 and n2, the algorithm passes their node attribute dictionaries to
+    node_match, and if it returns False, then n1 and n2 cannot be
+    considered to be isomorphic.
+
+    Edge attributes are handled by the edge_match keyword. When considering
+    n1 and n2, the algorithm must verify that outgoing edges from n1 are
+    commensurate with the outgoing edges for n2. If the graph is directed,
+    then a similar check is also performed for incoming edges.
+
+    Focusing only on outgoing edges, we consider pairs of nodes (n1, v1) from
+    G1 and (n2, v2) from G2. For graphs and digraphs, there is only one edge
+    between (n1, v1) and only one edge between (n2, v2). Those edge attribute
+    dictionaries are passed to edge_match, and if it returns False, then
+    n1 and n2 cannot be considered isomorphic. For multigraphs and
+    multidigraphs, there can be multiple edges between (n1, v1) and also
+    multiple edges between (n2, v2).  Now, there must exist an isomorphism
+    from "all the edges between (n1, v1)" to "all the edges between (n2, v2)".
+    So, all of the edge attribute dictionaries are passed to edge_match, and
+    it must determine if there is an isomorphism between the two sets of edges.
+"""
+
+from . import isomorphvf2 as vf2
+
+__all__ = ["GraphMatcher", "DiGraphMatcher", "MultiGraphMatcher", "MultiDiGraphMatcher"]
+
+
+def _semantic_feasibility(self, G1_node, G2_node):
+    """Returns True if mapping G1_node to G2_node is semantically feasible."""
+    # Make sure the nodes match
+    if self.node_match is not None:
+        nm = self.node_match(self.G1.nodes[G1_node], self.G2.nodes[G2_node])
+        if not nm:
+            return False
+
+    # Make sure the edges match
+    if self.edge_match is not None:
+
+        # Cached lookups
+        G1nbrs = self.G1_adj[G1_node]
+        G2nbrs = self.G2_adj[G2_node]
+        core_1 = self.core_1
+        edge_match = self.edge_match
+
+        for neighbor in G1nbrs:
+            # G1_node is not in core_1, so we must handle R_self separately
+            if neighbor == G1_node:
+                if G2_node in G2nbrs and not edge_match(
+                    G1nbrs[G1_node], G2nbrs[G2_node]
+                ):
+                    return False
+            elif neighbor in core_1:
+                G2_nbr = core_1[neighbor]
+                if G2_nbr in G2nbrs and not edge_match(
+                    G1nbrs[neighbor], G2nbrs[G2_nbr]
+                ):
+                    return False
+        # syntactic check has already verified that neighbors are symmetric
+
+    return True
+
+
+class GraphMatcher(vf2.GraphMatcher):
+    """VF2 isomorphism checker for undirected graphs."""
+
+    def __init__(self, G1, G2, node_match=None, edge_match=None):
+        """Initialize graph matcher.
+
+        Parameters
+        ----------
+        G1, G2: graph
+            The graphs to be tested.
+
+        node_match: callable
+            A function that returns True iff node n1 in G1 and n2 in G2
+            should be considered equal during the isomorphism test. The
+            function will be called like::
+
+               node_match(G1.nodes[n1], G2.nodes[n2])
+
+            That is, the function will receive the node attribute dictionaries
+            of the nodes under consideration. If None, then no attributes are
+            considered when testing for an isomorphism.
+
+        edge_match: callable
+            A function that returns True iff the edge attribute dictionary for
+            the pair of nodes (u1, v1) in G1 and (u2, v2) in G2 should be
+            considered equal during the isomorphism test. The function will be
+            called like::
+
+               edge_match(G1[u1][v1], G2[u2][v2])
+
+            That is, the function will receive the edge attribute dictionaries
+            of the edges under consideration. If None, then no attributes are
+            considered when testing for an isomorphism.
+
+        """
+        vf2.GraphMatcher.__init__(self, G1, G2)
+
+        self.node_match = node_match
+        self.edge_match = edge_match
+
+        # These will be modified during checks to minimize code repeat.
+        self.G1_adj = self.G1.adj
+        self.G2_adj = self.G2.adj
+
+    semantic_feasibility = _semantic_feasibility
+
+
+class DiGraphMatcher(vf2.DiGraphMatcher):
+    """VF2 isomorphism checker for directed graphs."""
+
+    def __init__(self, G1, G2, node_match=None, edge_match=None):
+        """Initialize graph matcher.
+
+        Parameters
+        ----------
+        G1, G2 : graph
+            The graphs to be tested.
+
+        node_match : callable
+            A function that returns True iff node n1 in G1 and n2 in G2
+            should be considered equal during the isomorphism test. The
+            function will be called like::
+
+               node_match(G1.nodes[n1], G2.nodes[n2])
+
+            That is, the function will receive the node attribute dictionaries
+            of the nodes under consideration. If None, then no attributes are
+            considered when testing for an isomorphism.
+
+        edge_match : callable
+            A function that returns True iff the edge attribute dictionary for
+            the pair of nodes (u1, v1) in G1 and (u2, v2) in G2 should be
+            considered equal during the isomorphism test. The function will be
+            called like::
+
+               edge_match(G1[u1][v1], G2[u2][v2])
+
+            That is, the function will receive the edge attribute dictionaries
+            of the edges under consideration. If None, then no attributes are
+            considered when testing for an isomorphism.
+
+        """
+        vf2.DiGraphMatcher.__init__(self, G1, G2)
+
+        self.node_match = node_match
+        self.edge_match = edge_match
+
+        # These will be modified during checks to minimize code repeat.
+        self.G1_adj = self.G1.adj
+        self.G2_adj = self.G2.adj
+
+    def semantic_feasibility(self, G1_node, G2_node):
+        """Returns True if mapping G1_node to G2_node is semantically feasible."""
+
+        # Test node_match and also test edge_match on successors
+        feasible = _semantic_feasibility(self, G1_node, G2_node)
+        if not feasible:
+            return False
+
+        # Test edge_match on predecessors
+        self.G1_adj = self.G1.pred
+        self.G2_adj = self.G2.pred
+        feasible = _semantic_feasibility(self, G1_node, G2_node)
+        self.G1_adj = self.G1.adj
+        self.G2_adj = self.G2.adj
+
+        return feasible
+
+
+# The "semantics" of edge_match are different for multi(di)graphs, but
+# the implementation is the same.  So, technically we do not need to
+# provide "multi" versions, but we do so to match NetworkX's base classes.
+
+
+class MultiGraphMatcher(GraphMatcher):
+    """VF2 isomorphism checker for undirected multigraphs."""
+
+    pass
+
+
+class MultiDiGraphMatcher(DiGraphMatcher):
+    """VF2 isomorphism checker for directed multigraphs."""
+
+    pass
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/__init__.py
new file mode 100644
index 0000000..6009f00
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/__init__.py
@@ -0,0 +1,2 @@
+from networkx.algorithms.link_analysis.hits_alg import *
+from networkx.algorithms.link_analysis.pagerank_alg import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/hits_alg.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/hits_alg.py
new file mode 100644
index 0000000..2deb3f4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/hits_alg.py
@@ -0,0 +1,399 @@
+"""Hubs and authorities analysis of graph structure.
+"""
+import networkx as nx
+
+__all__ = ["hits", "hits_numpy", "hits_scipy", "authority_matrix", "hub_matrix"]
+
+
+def hits(G, max_iter=100, tol=1.0e-8, nstart=None, normalized=True):
+    """Returns HITS hubs and authorities values for nodes.
+
+    The HITS algorithm computes two numbers for a node.
+    Authorities estimates the node value based on the incoming links.
+    Hubs estimates the node value based on outgoing links.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    max_iter : integer, optional
+      Maximum number of iterations in power method.
+
+    tol : float, optional
+      Error tolerance used to check convergence in power method iteration.
+
+    nstart : dictionary, optional
+      Starting value of each node for power method iteration.
+
+    normalized : bool (default=True)
+       Normalize results by the sum of all of the values.
+
+    Returns
+    -------
+    (hubs,authorities) : two-tuple of dictionaries
+       Two dictionaries keyed by node containing the hub and authority
+       values.
+
+    Raises
+    ------
+    PowerIterationFailedConvergence
+        If the algorithm fails to converge to the specified tolerance
+        within the specified number of iterations of the power iteration
+        method.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> h, a = nx.hits(G)
+
+    Notes
+    -----
+    The eigenvector calculation is done by the power iteration method
+    and has no guarantee of convergence.  The iteration will stop
+    after max_iter iterations or an error tolerance of
+    number_of_nodes(G)*tol has been reached.
+
+    The HITS algorithm was designed for directed graphs but this
+    algorithm does not check if the input graph is directed and will
+    execute on undirected graphs.
+
+    References
+    ----------
+    .. [1] A. Langville and C. Meyer,
+       "A survey of eigenvector methods of web information retrieval."
+       http://citeseer.ist.psu.edu/713792.html
+    .. [2] Jon Kleinberg,
+       Authoritative sources in a hyperlinked environment
+       Journal of the ACM 46 (5): 604-32, 1999.
+       doi:10.1145/324133.324140.
+       http://www.cs.cornell.edu/home/kleinber/auth.pdf.
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse.linalg  # call as sp.sparse.linalg
+
+    if len(G) == 0:
+        return {}, {}
+    A = nx.adjacency_matrix(G, nodelist=list(G), dtype=float)
+
+    if nstart is None:
+        _, _, vt = sp.sparse.linalg.svds(A, k=1, maxiter=max_iter, tol=tol)
+    else:
+        nstart = np.array(list(nstart.values()))
+        _, _, vt = sp.sparse.linalg.svds(A, k=1, v0=nstart, maxiter=max_iter, tol=tol)
+
+    a = vt.flatten().real
+    h = A @ a
+    if normalized:
+        h /= h.sum()
+        a /= a.sum()
+    hubs = dict(zip(G, map(float, h)))
+    authorities = dict(zip(G, map(float, a)))
+    return hubs, authorities
+
+
+def _hits_python(G, max_iter=100, tol=1.0e-8, nstart=None, normalized=True):
+    if isinstance(G, (nx.MultiGraph, nx.MultiDiGraph)):
+        raise Exception("hits() not defined for graphs with multiedges.")
+    if len(G) == 0:
+        return {}, {}
+    # choose fixed starting vector if not given
+    if nstart is None:
+        h = dict.fromkeys(G, 1.0 / G.number_of_nodes())
+    else:
+        h = nstart
+        # normalize starting vector
+        s = 1.0 / sum(h.values())
+        for k in h:
+            h[k] *= s
+    for _ in range(max_iter):  # power iteration: make up to max_iter iterations
+        hlast = h
+        h = dict.fromkeys(hlast.keys(), 0)
+        a = dict.fromkeys(hlast.keys(), 0)
+        # this "matrix multiply" looks odd because it is
+        # doing a left multiply a^T=hlast^T*G
+        for n in h:
+            for nbr in G[n]:
+                a[nbr] += hlast[n] * G[n][nbr].get("weight", 1)
+        # now multiply h=Ga
+        for n in h:
+            for nbr in G[n]:
+                h[n] += a[nbr] * G[n][nbr].get("weight", 1)
+        # normalize vector
+        s = 1.0 / max(h.values())
+        for n in h:
+            h[n] *= s
+        # normalize vector
+        s = 1.0 / max(a.values())
+        for n in a:
+            a[n] *= s
+        # check convergence, l1 norm
+        err = sum(abs(h[n] - hlast[n]) for n in h)
+        if err < tol:
+            break
+    else:
+        raise nx.PowerIterationFailedConvergence(max_iter)
+    if normalized:
+        s = 1.0 / sum(a.values())
+        for n in a:
+            a[n] *= s
+        s = 1.0 / sum(h.values())
+        for n in h:
+            h[n] *= s
+    return h, a
+
+
+def authority_matrix(G, nodelist=None):
+    """Returns the HITS authority matrix.
+
+    .. deprecated:: 2.6
+    """
+    import warnings
+
+    msg = (
+        "\nauthority_matrix is deprecated as of version 2.6 and will be removed "
+        "in version 3.0.\n"
+        "The authority matrix can be computed by::\n"
+        "    >>> M = nx.to_numpy_array(G, nodelist=nodelist)\n"
+        "    >>> M.T @ M"
+    )
+    warnings.warn(msg, DeprecationWarning)
+    M = nx.to_numpy_array(G, nodelist=nodelist)
+    return M.T @ M
+
+
+def hub_matrix(G, nodelist=None):
+    """Returns the HITS hub matrix.
+
+    .. deprecated:: 2.6
+    """
+    import warnings
+
+    msg = (
+        "\nhub_matrix is deprecated as of version 2.6 and will be removed "
+        "in version 3.0.\n"
+        "The hub matrix can be computed by::\n"
+        "    >>> M = nx.to_numpy_array(G, nodelist=nodelist)\n"
+        "    >>> M @ M.T"
+    )
+    warnings.warn(msg, DeprecationWarning)
+    M = nx.to_numpy_array(G, nodelist=nodelist)
+    return M @ M.T
+
+
+def hits_numpy(G, normalized=True):
+    """Returns HITS hubs and authorities values for nodes.
+
+    .. deprecated:: 2.6
+
+       hits_numpy is deprecated and will be removed in networkx 3.0.
+
+    The HITS algorithm computes two numbers for a node.
+    Authorities estimates the node value based on the incoming links.
+    Hubs estimates the node value based on outgoing links.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    normalized : bool (default=True)
+       Normalize results by the sum of all of the values.
+
+    Returns
+    -------
+    (hubs,authorities) : two-tuple of dictionaries
+       Two dictionaries keyed by node containing the hub and authority
+       values.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+
+    The `hubs` and `authorities` are given by the eigenvectors corresponding to the
+    maximum eigenvalues of the hubs_matrix and the authority_matrix, respectively.
+
+    The ``hubs`` and ``authority`` matrices are computed from the adjancency
+    matrix:
+
+    >>> adj_ary = nx.to_numpy_array(G)
+    >>> hubs_matrix = adj_ary @ adj_ary.T
+    >>> authority_matrix = adj_ary.T @ adj_ary
+
+    `hits_numpy` maps the eigenvector corresponding to the maximum eigenvalue
+    of the respective matrices to the nodes in `G`:
+
+    >>> hubs, authority = nx.hits_numpy(G)
+
+    Notes
+    -----
+    The eigenvector calculation uses NumPy's interface to LAPACK.
+
+    The HITS algorithm was designed for directed graphs but this
+    algorithm does not check if the input graph is directed and will
+    execute on undirected graphs.
+
+    References
+    ----------
+    .. [1] A. Langville and C. Meyer,
+       "A survey of eigenvector methods of web information retrieval."
+       http://citeseer.ist.psu.edu/713792.html
+    .. [2] Jon Kleinberg,
+       Authoritative sources in a hyperlinked environment
+       Journal of the ACM 46 (5): 604-32, 1999.
+       doi:10.1145/324133.324140.
+       http://www.cs.cornell.edu/home/kleinber/auth.pdf.
+    """
+    import warnings
+
+    import numpy as np
+
+    warnings.warn(
+        (
+            "networkx.hits_numpy is deprecated and will be removed"
+            "in NetworkX 3.0, use networkx.hits instead."
+        ),
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    if len(G) == 0:
+        return {}, {}
+    adj_ary = nx.to_numpy_array(G)
+    # Hub matrix
+    H = adj_ary @ adj_ary.T
+    e, ev = np.linalg.eig(H)
+    h = ev[:, np.argmax(e)]  # eigenvector corresponding to the maximum eigenvalue
+    # Authority matrix
+    A = adj_ary.T @ adj_ary
+    e, ev = np.linalg.eig(A)
+    a = ev[:, np.argmax(e)]  # eigenvector corresponding to the maximum eigenvalue
+    if normalized:
+        h /= h.sum()
+        a /= a.sum()
+    else:
+        h /= h.max()
+        a /= a.max()
+    hubs = dict(zip(G, map(float, h)))
+    authorities = dict(zip(G, map(float, a)))
+    return hubs, authorities
+
+
+def hits_scipy(G, max_iter=100, tol=1.0e-6, nstart=None, normalized=True):
+    """Returns HITS hubs and authorities values for nodes.
+
+    .. deprecated:: 2.6
+
+       hits_scipy is deprecated and will be removed in networkx 3.0
+
+    The HITS algorithm computes two numbers for a node.
+    Authorities estimates the node value based on the incoming links.
+    Hubs estimates the node value based on outgoing links.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    max_iter : integer, optional
+      Maximum number of iterations in power method.
+
+    tol : float, optional
+      Error tolerance used to check convergence in power method iteration.
+
+    nstart : dictionary, optional
+      Starting value of each node for power method iteration.
+
+    normalized : bool (default=True)
+       Normalize results by the sum of all of the values.
+
+    Returns
+    -------
+    (hubs,authorities) : two-tuple of dictionaries
+       Two dictionaries keyed by node containing the hub and authority
+       values.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> h, a = nx.hits(G)
+
+    Notes
+    -----
+    This implementation uses SciPy sparse matrices.
+
+    The eigenvector calculation is done by the power iteration method
+    and has no guarantee of convergence.  The iteration will stop
+    after max_iter iterations or an error tolerance of
+    number_of_nodes(G)*tol has been reached.
+
+    The HITS algorithm was designed for directed graphs but this
+    algorithm does not check if the input graph is directed and will
+    execute on undirected graphs.
+
+    Raises
+    ------
+    PowerIterationFailedConvergence
+        If the algorithm fails to converge to the specified tolerance
+        within the specified number of iterations of the power iteration
+        method.
+
+    References
+    ----------
+    .. [1] A. Langville and C. Meyer,
+       "A survey of eigenvector methods of web information retrieval."
+       http://citeseer.ist.psu.edu/713792.html
+    .. [2] Jon Kleinberg,
+       Authoritative sources in a hyperlinked environment
+       Journal of the ACM 46 (5): 604-632, 1999.
+       doi:10.1145/324133.324140.
+       http://www.cs.cornell.edu/home/kleinber/auth.pdf.
+    """
+    import warnings
+
+    import numpy as np
+
+    warnings.warn(
+        (
+            "networkx.hits_scipy is deprecated and will be removed"
+            "in NetworkX 3.0, use networkx.hits instead."
+        ),
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    if len(G) == 0:
+        return {}, {}
+    A = nx.to_scipy_sparse_array(G, nodelist=list(G))
+    (n, _) = A.shape  # should be square
+    ATA = A.T @ A  # authority matrix
+    # choose fixed starting vector if not given
+    if nstart is None:
+        x = np.ones((n, 1)) / n
+    else:
+        x = np.array([nstart.get(n, 0) for n in list(G)], dtype=float)
+        x /= x.sum()
+
+    # power iteration on authority matrix
+    i = 0
+    while True:
+        xlast = x
+        x = ATA @ x
+        x /= x.max()
+        # check convergence, l1 norm
+        err = np.absolute(x - xlast).sum()
+        if err < tol:
+            break
+        if i > max_iter:
+            raise nx.PowerIterationFailedConvergence(max_iter)
+        i += 1
+
+    a = x.flatten()
+    h = A @ a
+    if normalized:
+        h /= h.sum()
+        a /= a.sum()
+    hubs = dict(zip(G, map(float, h)))
+    authorities = dict(zip(G, map(float, a)))
+    return hubs, authorities
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/pagerank_alg.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/pagerank_alg.py
new file mode 100644
index 0000000..ece444c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/pagerank_alg.py
@@ -0,0 +1,508 @@
+"""PageRank analysis of graph structure. """
+from warnings import warn
+
+import networkx as nx
+
+__all__ = ["pagerank", "pagerank_numpy", "pagerank_scipy", "google_matrix"]
+
+
+def pagerank(
+    G,
+    alpha=0.85,
+    personalization=None,
+    max_iter=100,
+    tol=1.0e-6,
+    nstart=None,
+    weight="weight",
+    dangling=None,
+):
+    """Returns the PageRank of the nodes in the graph.
+
+    PageRank computes a ranking of the nodes in the graph G based on
+    the structure of the incoming links. It was originally designed as
+    an algorithm to rank web pages.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.  Undirected graphs will be converted to a directed
+      graph with two directed edges for each undirected edge.
+
+    alpha : float, optional
+      Damping parameter for PageRank, default=0.85.
+
+    personalization: dict, optional
+      The "personalization vector" consisting of a dictionary with a
+      key some subset of graph nodes and personalization value each of those.
+      At least one personalization value must be non-zero.
+      If not specfiied, a nodes personalization value will be zero.
+      By default, a uniform distribution is used.
+
+    max_iter : integer, optional
+      Maximum number of iterations in power method eigenvalue solver.
+
+    tol : float, optional
+      Error tolerance used to check convergence in power method solver.
+
+    nstart : dictionary, optional
+      Starting value of PageRank iteration for each node.
+
+    weight : key, optional
+      Edge data key to use as weight.  If None weights are set to 1.
+
+    dangling: dict, optional
+      The outedges to be assigned to any "dangling" nodes, i.e., nodes without
+      any outedges. The dict key is the node the outedge points to and the dict
+      value is the weight of that outedge. By default, dangling nodes are given
+      outedges according to the personalization vector (uniform if not
+      specified). This must be selected to result in an irreducible transition
+      matrix (see notes under google_matrix). It may be common to have the
+      dangling dict to be the same as the personalization dict.
+
+
+    Returns
+    -------
+    pagerank : dictionary
+       Dictionary of nodes with PageRank as value
+
+    Examples
+    --------
+    >>> G = nx.DiGraph(nx.path_graph(4))
+    >>> pr = nx.pagerank(G, alpha=0.9)
+
+    Notes
+    -----
+    The eigenvector calculation is done by the power iteration method
+    and has no guarantee of convergence.  The iteration will stop after
+    an error tolerance of ``len(G) * tol`` has been reached. If the
+    number of iterations exceed `max_iter`, a
+    :exc:`networkx.exception.PowerIterationFailedConvergence` exception
+    is raised.
+
+    The PageRank algorithm was designed for directed graphs but this
+    algorithm does not check if the input graph is directed and will
+    execute on undirected graphs by converting each edge in the
+    directed graph to two edges.
+
+    See Also
+    --------
+    pagerank_numpy, pagerank_scipy, google_matrix
+
+    Raises
+    ------
+    PowerIterationFailedConvergence
+        If the algorithm fails to converge to the specified tolerance
+        within the specified number of iterations of the power iteration
+        method.
+
+    References
+    ----------
+    .. [1] A. Langville and C. Meyer,
+       "A survey of eigenvector methods of web information retrieval."
+       http://citeseer.ist.psu.edu/713792.html
+    .. [2] Page, Lawrence; Brin, Sergey; Motwani, Rajeev and Winograd, Terry,
+       The PageRank citation ranking: Bringing order to the Web. 1999
+       http://dbpubs.stanford.edu:8090/pub/showDoc.Fulltext?lang=en&doc=1999-66&format=pdf
+
+    """
+    return pagerank_scipy(
+        G, alpha, personalization, max_iter, tol, nstart, weight, dangling
+    )
+
+
+def _pagerank_python(
+    G,
+    alpha=0.85,
+    personalization=None,
+    max_iter=100,
+    tol=1.0e-6,
+    nstart=None,
+    weight="weight",
+    dangling=None,
+):
+    if len(G) == 0:
+        return {}
+
+    D = G.to_directed()
+
+    # Create a copy in (right) stochastic form
+    W = nx.stochastic_graph(D, weight=weight)
+    N = W.number_of_nodes()
+
+    # Choose fixed starting vector if not given
+    if nstart is None:
+        x = dict.fromkeys(W, 1.0 / N)
+    else:
+        # Normalized nstart vector
+        s = sum(nstart.values())
+        x = {k: v / s for k, v in nstart.items()}
+
+    if personalization is None:
+        # Assign uniform personalization vector if not given
+        p = dict.fromkeys(W, 1.0 / N)
+    else:
+        s = sum(personalization.values())
+        p = {k: v / s for k, v in personalization.items()}
+
+    if dangling is None:
+        # Use personalization vector if dangling vector not specified
+        dangling_weights = p
+    else:
+        s = sum(dangling.values())
+        dangling_weights = {k: v / s for k, v in dangling.items()}
+    dangling_nodes = [n for n in W if W.out_degree(n, weight=weight) == 0.0]
+
+    # power iteration: make up to max_iter iterations
+    for _ in range(max_iter):
+        xlast = x
+        x = dict.fromkeys(xlast.keys(), 0)
+        danglesum = alpha * sum(xlast[n] for n in dangling_nodes)
+        for n in x:
+            # this matrix multiply looks odd because it is
+            # doing a left multiply x^T=xlast^T*W
+            for _, nbr, wt in W.edges(n, data=weight):
+                x[nbr] += alpha * xlast[n] * wt
+            x[n] += danglesum * dangling_weights.get(n, 0) + (1.0 - alpha) * p.get(n, 0)
+        # check convergence, l1 norm
+        err = sum(abs(x[n] - xlast[n]) for n in x)
+        if err < N * tol:
+            return x
+    raise nx.PowerIterationFailedConvergence(max_iter)
+
+
+def google_matrix(
+    G, alpha=0.85, personalization=None, nodelist=None, weight="weight", dangling=None
+):
+    """Returns the Google matrix of the graph.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.  Undirected graphs will be converted to a directed
+      graph with two directed edges for each undirected edge.
+
+    alpha : float
+      The damping factor.
+
+    personalization: dict, optional
+      The "personalization vector" consisting of a dictionary with a
+      key some subset of graph nodes and personalization value each of those.
+      At least one personalization value must be non-zero.
+      If not specfiied, a nodes personalization value will be zero.
+      By default, a uniform distribution is used.
+
+    nodelist : list, optional
+      The rows and columns are ordered according to the nodes in nodelist.
+      If nodelist is None, then the ordering is produced by G.nodes().
+
+    weight : key, optional
+      Edge data key to use as weight.  If None weights are set to 1.
+
+    dangling: dict, optional
+      The outedges to be assigned to any "dangling" nodes, i.e., nodes without
+      any outedges. The dict key is the node the outedge points to and the dict
+      value is the weight of that outedge. By default, dangling nodes are given
+      outedges according to the personalization vector (uniform if not
+      specified) This must be selected to result in an irreducible transition
+      matrix (see notes below). It may be common to have the dangling dict to
+      be the same as the personalization dict.
+
+    Returns
+    -------
+    A : NumPy matrix
+       Google matrix of the graph
+
+    Notes
+    -----
+    The matrix returned represents the transition matrix that describes the
+    Markov chain used in PageRank. For PageRank to converge to a unique
+    solution (i.e., a unique stationary distribution in a Markov chain), the
+    transition matrix must be irreducible. In other words, it must be that
+    there exists a path between every pair of nodes in the graph, or else there
+    is the potential of "rank sinks."
+
+    This implementation works with Multi(Di)Graphs. For multigraphs the
+    weight between two nodes is set to be the sum of all edge weights
+    between those nodes.
+
+    See Also
+    --------
+    pagerank, pagerank_numpy, pagerank_scipy
+    """
+    # TODO: Remove this warning in version 3.0
+    import warnings
+
+    import numpy as np
+
+    warnings.warn(
+        "google_matrix will return an np.ndarray instead of a np.matrix in\n"
+        "NetworkX version 3.0.",
+        FutureWarning,
+        stacklevel=2,
+    )
+
+    if nodelist is None:
+        nodelist = list(G)
+
+    A = nx.to_numpy_array(G, nodelist=nodelist, weight=weight)
+    N = len(G)
+    if N == 0:
+        # TODO: Remove np.asmatrix wrapper in version 3.0
+        return np.asmatrix(A)
+
+    # Personalization vector
+    if personalization is None:
+        p = np.repeat(1.0 / N, N)
+    else:
+        p = np.array([personalization.get(n, 0) for n in nodelist], dtype=float)
+        if p.sum() == 0:
+            raise ZeroDivisionError
+        p /= p.sum()
+
+    # Dangling nodes
+    if dangling is None:
+        dangling_weights = p
+    else:
+        # Convert the dangling dictionary into an array in nodelist order
+        dangling_weights = np.array([dangling.get(n, 0) for n in nodelist], dtype=float)
+        dangling_weights /= dangling_weights.sum()
+    dangling_nodes = np.where(A.sum(axis=1) == 0)[0]
+
+    # Assign dangling_weights to any dangling nodes (nodes with no out links)
+    A[dangling_nodes] = dangling_weights
+
+    A /= A.sum(axis=1)[:, np.newaxis]  # Normalize rows to sum to 1
+
+    # TODO: Remove np.asmatrix wrapper in version 3.0
+    return np.asmatrix(alpha * A + (1 - alpha) * p)
+
+
+def pagerank_numpy(G, alpha=0.85, personalization=None, weight="weight", dangling=None):
+    """Returns the PageRank of the nodes in the graph.
+
+    PageRank computes a ranking of the nodes in the graph G based on
+    the structure of the incoming links. It was originally designed as
+    an algorithm to rank web pages.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.  Undirected graphs will be converted to a directed
+      graph with two directed edges for each undirected edge.
+
+    alpha : float, optional
+      Damping parameter for PageRank, default=0.85.
+
+    personalization: dict, optional
+      The "personalization vector" consisting of a dictionary with a
+      key some subset of graph nodes and personalization value each of those.
+      At least one personalization value must be non-zero.
+      If not specfiied, a nodes personalization value will be zero.
+      By default, a uniform distribution is used.
+
+    weight : key, optional
+      Edge data key to use as weight.  If None weights are set to 1.
+
+    dangling: dict, optional
+      The outedges to be assigned to any "dangling" nodes, i.e., nodes without
+      any outedges. The dict key is the node the outedge points to and the dict
+      value is the weight of that outedge. By default, dangling nodes are given
+      outedges according to the personalization vector (uniform if not
+      specified) This must be selected to result in an irreducible transition
+      matrix (see notes under google_matrix). It may be common to have the
+      dangling dict to be the same as the personalization dict.
+
+    Returns
+    -------
+    pagerank : dictionary
+       Dictionary of nodes with PageRank as value.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph(nx.path_graph(4))
+    >>> pr = nx.pagerank_numpy(G, alpha=0.9)
+
+    Notes
+    -----
+    The eigenvector calculation uses NumPy's interface to the LAPACK
+    eigenvalue solvers.  This will be the fastest and most accurate
+    for small graphs.
+
+    This implementation works with Multi(Di)Graphs. For multigraphs the
+    weight between two nodes is set to be the sum of all edge weights
+    between those nodes.
+
+    See Also
+    --------
+    pagerank, pagerank_scipy, google_matrix
+
+    References
+    ----------
+    .. [1] A. Langville and C. Meyer,
+       "A survey of eigenvector methods of web information retrieval."
+       http://citeseer.ist.psu.edu/713792.html
+    .. [2] Page, Lawrence; Brin, Sergey; Motwani, Rajeev and Winograd, Terry,
+       The PageRank citation ranking: Bringing order to the Web. 1999
+       http://dbpubs.stanford.edu:8090/pub/showDoc.Fulltext?lang=en&doc=1999-66&format=pdf
+    """
+    msg = "networkx.pagerank_numpy is deprecated and will be removed in NetworkX 3.0, use networkx.pagerank instead."
+    warn(msg, DeprecationWarning, stacklevel=2)
+    import numpy as np
+
+    if len(G) == 0:
+        return {}
+    M = google_matrix(
+        G, alpha, personalization=personalization, weight=weight, dangling=dangling
+    )
+    # use numpy LAPACK solver
+    eigenvalues, eigenvectors = np.linalg.eig(M.T)
+    ind = np.argmax(eigenvalues)
+    # eigenvector of largest eigenvalue is at ind, normalized
+    largest = np.array(eigenvectors[:, ind]).flatten().real
+    norm = largest.sum()
+    return dict(zip(G, map(float, largest / norm)))
+
+
+def pagerank_scipy(
+    G,
+    alpha=0.85,
+    personalization=None,
+    max_iter=100,
+    tol=1.0e-6,
+    nstart=None,
+    weight="weight",
+    dangling=None,
+):
+    """Returns the PageRank of the nodes in the graph.
+
+    PageRank computes a ranking of the nodes in the graph G based on
+    the structure of the incoming links. It was originally designed as
+    an algorithm to rank web pages.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.  Undirected graphs will be converted to a directed
+      graph with two directed edges for each undirected edge.
+
+    alpha : float, optional
+      Damping parameter for PageRank, default=0.85.
+
+    personalization: dict, optional
+      The "personalization vector" consisting of a dictionary with a
+      key some subset of graph nodes and personalization value each of those.
+      At least one personalization value must be non-zero.
+      If not specfiied, a nodes personalization value will be zero.
+      By default, a uniform distribution is used.
+
+    max_iter : integer, optional
+      Maximum number of iterations in power method eigenvalue solver.
+
+    tol : float, optional
+      Error tolerance used to check convergence in power method solver.
+
+    nstart : dictionary, optional
+      Starting value of PageRank iteration for each node.
+
+    weight : key, optional
+      Edge data key to use as weight.  If None weights are set to 1.
+
+    dangling: dict, optional
+      The outedges to be assigned to any "dangling" nodes, i.e., nodes without
+      any outedges. The dict key is the node the outedge points to and the dict
+      value is the weight of that outedge. By default, dangling nodes are given
+      outedges according to the personalization vector (uniform if not
+      specified) This must be selected to result in an irreducible transition
+      matrix (see notes under google_matrix). It may be common to have the
+      dangling dict to be the same as the personalization dict.
+
+    Returns
+    -------
+    pagerank : dictionary
+       Dictionary of nodes with PageRank as value
+
+    Examples
+    --------
+    >>> G = nx.DiGraph(nx.path_graph(4))
+    >>> pr = nx.pagerank_scipy(G, alpha=0.9)
+
+    Notes
+    -----
+    The eigenvector calculation uses power iteration with a SciPy
+    sparse matrix representation.
+
+    This implementation works with Multi(Di)Graphs. For multigraphs the
+    weight between two nodes is set to be the sum of all edge weights
+    between those nodes.
+
+    See Also
+    --------
+    pagerank, pagerank_numpy, google_matrix
+
+    Raises
+    ------
+    PowerIterationFailedConvergence
+        If the algorithm fails to converge to the specified tolerance
+        within the specified number of iterations of the power iteration
+        method.
+
+    References
+    ----------
+    .. [1] A. Langville and C. Meyer,
+       "A survey of eigenvector methods of web information retrieval."
+       http://citeseer.ist.psu.edu/713792.html
+    .. [2] Page, Lawrence; Brin, Sergey; Motwani, Rajeev and Winograd, Terry,
+       The PageRank citation ranking: Bringing order to the Web. 1999
+       http://dbpubs.stanford.edu:8090/pub/showDoc.Fulltext?lang=en&doc=1999-66&format=pdf
+    """
+    msg = "networkx.pagerank_scipy is deprecated and will be removed in NetworkX 3.0, use networkx.pagerank instead."
+    warn(msg, DeprecationWarning, stacklevel=2)
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    N = len(G)
+    if N == 0:
+        return {}
+
+    nodelist = list(G)
+    A = nx.to_scipy_sparse_array(G, nodelist=nodelist, weight=weight, dtype=float)
+    S = A.sum(axis=1)
+    S[S != 0] = 1.0 / S[S != 0]
+    # TODO: csr_array
+    Q = sp.sparse.csr_array(sp.sparse.spdiags(S.T, 0, *A.shape))
+    A = Q @ A
+
+    # initial vector
+    if nstart is None:
+        x = np.repeat(1.0 / N, N)
+    else:
+        x = np.array([nstart.get(n, 0) for n in nodelist], dtype=float)
+        x /= x.sum()
+
+    # Personalization vector
+    if personalization is None:
+        p = np.repeat(1.0 / N, N)
+    else:
+        p = np.array([personalization.get(n, 0) for n in nodelist], dtype=float)
+        if p.sum() == 0:
+            raise ZeroDivisionError
+        p /= p.sum()
+    # Dangling nodes
+    if dangling is None:
+        dangling_weights = p
+    else:
+        # Convert the dangling dictionary into an array in nodelist order
+        dangling_weights = np.array([dangling.get(n, 0) for n in nodelist], dtype=float)
+        dangling_weights /= dangling_weights.sum()
+    is_dangling = np.where(S == 0)[0]
+
+    # power iteration: make up to max_iter iterations
+    for _ in range(max_iter):
+        xlast = x
+        x = alpha * (x @ A + sum(x[is_dangling]) * dangling_weights) + (1 - alpha) * p
+        # check convergence, l1 norm
+        err = np.absolute(x - xlast).sum()
+        if err < N * tol:
+            return dict(zip(nodelist, map(float, x)))
+    raise nx.PowerIterationFailedConvergence(max_iter)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/tests/test_hits.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/tests/test_hits.py
new file mode 100644
index 0000000..df5f0da
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/tests/test_hits.py
@@ -0,0 +1,89 @@
+import pytest
+
+import networkx as nx
+
+np = pytest.importorskip("numpy")
+sp = pytest.importorskip("scipy")
+import scipy.sparse  # call as sp.sparse
+
+from networkx.algorithms.link_analysis.hits_alg import _hits_python
+
+# Example from
+# A. Langville and C. Meyer, "A survey of eigenvector methods of web
+# information retrieval."  http://citeseer.ist.psu.edu/713792.html
+
+
+class TestHITS:
+    @classmethod
+    def setup_class(cls):
+
+        G = nx.DiGraph()
+
+        edges = [(1, 3), (1, 5), (2, 1), (3, 5), (5, 4), (5, 3), (6, 5)]
+
+        G.add_edges_from(edges, weight=1)
+        cls.G = G
+        cls.G.a = dict(
+            zip(sorted(G), [0.000000, 0.000000, 0.366025, 0.133975, 0.500000, 0.000000])
+        )
+        cls.G.h = dict(
+            zip(sorted(G), [0.366025, 0.000000, 0.211325, 0.000000, 0.211325, 0.211325])
+        )
+
+    def test_hits_numpy(self):
+        G = self.G
+        h, a = nx.hits_numpy(G)
+        for n in G:
+            assert h[n] == pytest.approx(G.h[n], abs=1e-4)
+        for n in G:
+            assert a[n] == pytest.approx(G.a[n], abs=1e-4)
+
+    @pytest.mark.parametrize("hits_alg", (nx.hits, nx.hits_scipy, _hits_python))
+    def test_hits(self, hits_alg):
+        G = self.G
+        h, a = hits_alg(G, tol=1.0e-08)
+        for n in G:
+            assert h[n] == pytest.approx(G.h[n], abs=1e-4)
+        for n in G:
+            assert a[n] == pytest.approx(G.a[n], abs=1e-4)
+        nstart = {i: 1.0 / 2 for i in G}
+        h, a = hits_alg(G, nstart=nstart)
+        for n in G:
+            assert h[n] == pytest.approx(G.h[n], abs=1e-4)
+        for n in G:
+            assert a[n] == pytest.approx(G.a[n], abs=1e-4)
+
+    def test_empty(self):
+        G = nx.Graph()
+        assert nx.hits(G) == ({}, {})
+        assert nx.hits_numpy(G) == ({}, {})
+        assert _hits_python(G) == ({}, {})
+        assert nx.hits_scipy(G) == ({}, {})
+        assert nx.authority_matrix(G).shape == (0, 0)
+        assert nx.hub_matrix(G).shape == (0, 0)
+
+    def test_hits_not_convergent(self):
+        G = nx.path_graph(50)
+        with pytest.raises(nx.PowerIterationFailedConvergence):
+            nx.hits_scipy(G, max_iter=1)
+        with pytest.raises(nx.PowerIterationFailedConvergence):
+            _hits_python(G, max_iter=1)
+        with pytest.raises(nx.PowerIterationFailedConvergence):
+            nx.hits_scipy(G, max_iter=0)
+        with pytest.raises(nx.PowerIterationFailedConvergence):
+            _hits_python(G, max_iter=0)
+        with pytest.raises(ValueError):
+            nx.hits(G, max_iter=0)
+        with pytest.raises(sp.sparse.linalg.ArpackNoConvergence):
+            nx.hits(G, max_iter=1)
+
+
+@pytest.mark.parametrize("hits_alg", (nx.hits_numpy, nx.hits_scipy))
+def test_deprecation_warnings(hits_alg):
+    """Make sure deprecation warnings are raised.
+
+    To be removed when deprecations expire.
+    """
+    G = nx.DiGraph(nx.path_graph(4))
+    with pytest.warns(DeprecationWarning):
+        hits_alg(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/tests/test_pagerank.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/tests/test_pagerank.py
new file mode 100644
index 0000000..4c9722f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_analysis/tests/test_pagerank.py
@@ -0,0 +1,220 @@
+import random
+
+import pytest
+
+import networkx as nx
+
+np = pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+from networkx.algorithms.link_analysis.pagerank_alg import _pagerank_python
+
+# Example from
+# A. Langville and C. Meyer, "A survey of eigenvector methods of web
+# information retrieval."  http://citeseer.ist.psu.edu/713792.html
+
+
+class TestPageRank:
+    @classmethod
+    def setup_class(cls):
+        G = nx.DiGraph()
+        edges = [
+            (1, 2),
+            (1, 3),
+            # 2 is a dangling node
+            (3, 1),
+            (3, 2),
+            (3, 5),
+            (4, 5),
+            (4, 6),
+            (5, 4),
+            (5, 6),
+            (6, 4),
+        ]
+        G.add_edges_from(edges)
+        cls.G = G
+        cls.G.pagerank = dict(
+            zip(
+                sorted(G),
+                [
+                    0.03721197,
+                    0.05395735,
+                    0.04150565,
+                    0.37508082,
+                    0.20599833,
+                    0.28624589,
+                ],
+            )
+        )
+        cls.dangling_node_index = 1
+        cls.dangling_edges = {1: 2, 2: 3, 3: 0, 4: 0, 5: 0, 6: 0}
+        cls.G.dangling_pagerank = dict(
+            zip(
+                sorted(G),
+                [0.10844518, 0.18618601, 0.0710892, 0.2683668, 0.15919783, 0.20671497],
+            )
+        )
+
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
+    def test_pagerank(self, alg):
+        G = self.G
+        p = alg(G, alpha=0.9, tol=1.0e-08)
+        for n in G:
+            assert p[n] == pytest.approx(G.pagerank[n], abs=1e-4)
+
+        nstart = {n: random.random() for n in G}
+        p = alg(G, alpha=0.9, tol=1.0e-08, nstart=nstart)
+        for n in G:
+            assert p[n] == pytest.approx(G.pagerank[n], abs=1e-4)
+
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
+    def test_pagerank_max_iter(self, alg):
+        with pytest.raises(nx.PowerIterationFailedConvergence):
+            alg(self.G, max_iter=0)
+
+    def test_numpy_pagerank(self):
+        G = self.G
+        p = nx.pagerank_numpy(G, alpha=0.9)
+        for n in G:
+            assert p[n] == pytest.approx(G.pagerank[n], abs=1e-4)
+
+    def test_google_matrix(self):
+        G = self.G
+        M = nx.google_matrix(G, alpha=0.9, nodelist=sorted(G))
+        _, ev = np.linalg.eig(M.T)
+        p = np.array(ev[:, 0] / ev[:, 0].sum())[:, 0]
+        for (a, b) in zip(p, self.G.pagerank.values()):
+            assert a == pytest.approx(b, abs=1e-7)
+
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python, nx.pagerank_numpy))
+    def test_personalization(self, alg):
+        G = nx.complete_graph(4)
+        personalize = {0: 1, 1: 1, 2: 4, 3: 4}
+        answer = {
+            0: 0.23246732615667579,
+            1: 0.23246732615667579,
+            2: 0.267532673843324,
+            3: 0.2675326738433241,
+        }
+        p = alg(G, alpha=0.85, personalization=personalize)
+        for n in G:
+            assert p[n] == pytest.approx(answer[n], abs=1e-4)
+
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python, nx.google_matrix))
+    def test_zero_personalization_vector(self, alg):
+        G = nx.complete_graph(4)
+        personalize = {0: 0, 1: 0, 2: 0, 3: 0}
+        pytest.raises(ZeroDivisionError, alg, G, personalization=personalize)
+
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
+    def test_one_nonzero_personalization_value(self, alg):
+        G = nx.complete_graph(4)
+        personalize = {0: 0, 1: 0, 2: 0, 3: 1}
+        answer = {
+            0: 0.22077931820379187,
+            1: 0.22077931820379187,
+            2: 0.22077931820379187,
+            3: 0.3376620453886241,
+        }
+        p = alg(G, alpha=0.85, personalization=personalize)
+        for n in G:
+            assert p[n] == pytest.approx(answer[n], abs=1e-4)
+
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
+    def test_incomplete_personalization(self, alg):
+        G = nx.complete_graph(4)
+        personalize = {3: 1}
+        answer = {
+            0: 0.22077931820379187,
+            1: 0.22077931820379187,
+            2: 0.22077931820379187,
+            3: 0.3376620453886241,
+        }
+        p = alg(G, alpha=0.85, personalization=personalize)
+        for n in G:
+            assert p[n] == pytest.approx(answer[n], abs=1e-4)
+
+    def test_dangling_matrix(self):
+        """
+        Tests that the google_matrix doesn't change except for the dangling
+        nodes.
+        """
+        G = self.G
+        dangling = self.dangling_edges
+        dangling_sum = sum(dangling.values())
+        M1 = nx.google_matrix(G, personalization=dangling)
+        M2 = nx.google_matrix(G, personalization=dangling, dangling=dangling)
+        for i in range(len(G)):
+            for j in range(len(G)):
+                if i == self.dangling_node_index and (j + 1) in dangling:
+                    assert M2[i, j] == pytest.approx(
+                        dangling[j + 1] / dangling_sum, abs=1e-4
+                    )
+                else:
+                    assert M2[i, j] == pytest.approx(M1[i, j], abs=1e-4)
+
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python, nx.pagerank_numpy))
+    def test_dangling_pagerank(self, alg):
+        pr = alg(self.G, dangling=self.dangling_edges)
+        for n in self.G:
+            assert pr[n] == pytest.approx(self.G.dangling_pagerank[n], abs=1e-4)
+
+    def test_empty(self):
+        G = nx.Graph()
+        assert nx.pagerank(G) == {}
+        assert _pagerank_python(G) == {}
+        assert nx.pagerank_numpy(G) == {}
+        assert nx.google_matrix(G).shape == (0, 0)
+
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
+    def test_multigraph(self, alg):
+        G = nx.MultiGraph()
+        G.add_edges_from([(1, 2), (1, 2), (1, 2), (2, 3), (2, 3), ("3", 3), ("3", 3)])
+        answer = {
+            1: 0.21066048614468322,
+            2: 0.3395308825985378,
+            3: 0.28933951385531687,
+            "3": 0.16046911740146227,
+        }
+        p = alg(G)
+        for n in G:
+            assert p[n] == pytest.approx(answer[n], abs=1e-4)
+
+
+class TestPageRankScipy(TestPageRank):
+    def test_scipy_pagerank(self):
+        G = self.G
+        p = nx.pagerank_scipy(G, alpha=0.9, tol=1.0e-08)
+        for n in G:
+            assert p[n] == pytest.approx(G.pagerank[n], abs=1e-4)
+        personalize = {n: random.random() for n in G}
+        p = nx.pagerank_scipy(G, alpha=0.9, tol=1.0e-08, personalization=personalize)
+
+        nstart = {n: random.random() for n in G}
+        p = nx.pagerank_scipy(G, alpha=0.9, tol=1.0e-08, nstart=nstart)
+        for n in G:
+            assert p[n] == pytest.approx(G.pagerank[n], abs=1e-4)
+
+    def test_scipy_pagerank_max_iter(self):
+        with pytest.raises(nx.PowerIterationFailedConvergence):
+            nx.pagerank_scipy(self.G, max_iter=0)
+
+    def test_dangling_scipy_pagerank(self):
+        pr = nx.pagerank_scipy(self.G, dangling=self.dangling_edges)
+        for n in self.G:
+            assert pr[n] == pytest.approx(self.G.dangling_pagerank[n], abs=1e-4)
+
+    def test_empty_scipy(self):
+        G = nx.Graph()
+        assert nx.pagerank_scipy(G) == {}
+
+
+@pytest.mark.parametrize("pagerank_alg", (nx.pagerank_numpy, nx.pagerank_scipy))
+def test_deprecation_warnings(pagerank_alg):
+    """Make sure deprecation warnings are raised.
+
+    To be removed when deprecations expire.
+    """
+    G = nx.DiGraph(nx.path_graph(4))
+    with pytest.warns(DeprecationWarning):
+        pagerank_alg(G, alpha=0.9)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/link_prediction.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_prediction.py
new file mode 100644
index 0000000..de29e24
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/link_prediction.py
@@ -0,0 +1,596 @@
+"""
+Link prediction algorithms.
+"""
+
+
+from math import log
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "resource_allocation_index",
+    "jaccard_coefficient",
+    "adamic_adar_index",
+    "preferential_attachment",
+    "cn_soundarajan_hopcroft",
+    "ra_index_soundarajan_hopcroft",
+    "within_inter_cluster",
+    "common_neighbor_centrality",
+]
+
+
+def _apply_prediction(G, func, ebunch=None):
+    """Applies the given function to each edge in the specified iterable
+    of edges.
+
+    `G` is an instance of :class:`networkx.Graph`.
+
+    `func` is a function on two inputs, each of which is a node in the
+    graph. The function can return anything, but it should return a
+    value representing a prediction of the likelihood of a "link"
+    joining the two nodes.
+
+    `ebunch` is an iterable of pairs of nodes. If not specified, all
+    non-edges in the graph `G` will be used.
+
+    """
+    if ebunch is None:
+        ebunch = nx.non_edges(G)
+    return ((u, v, func(u, v)) for u, v in ebunch)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def resource_allocation_index(G, ebunch=None):
+    r"""Compute the resource allocation index of all node pairs in ebunch.
+
+    Resource allocation index of `u` and `v` is defined as
+
+    .. math::
+
+        \sum_{w \in \Gamma(u) \cap \Gamma(v)} \frac{1}{|\Gamma(w)|}
+
+    where $\Gamma(u)$ denotes the set of neighbors of $u$.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX undirected graph.
+
+    ebunch : iterable of node pairs, optional (default = None)
+        Resource allocation index will be computed for each pair of
+        nodes given in the iterable. The pairs must be given as
+        2-tuples (u, v) where u and v are nodes in the graph. If ebunch
+        is None then all non-existent edges in the graph will be used.
+        Default value: None.
+
+    Returns
+    -------
+    piter : iterator
+        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
+        pair of nodes and p is their resource allocation index.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> preds = nx.resource_allocation_index(G, [(0, 1), (2, 3)])
+    >>> for u, v, p in preds:
+    ...     print(f"({u}, {v}) -> {p:.8f}")
+    (0, 1) -> 0.75000000
+    (2, 3) -> 0.75000000
+
+    References
+    ----------
+    .. [1] T. Zhou, L. Lu, Y.-C. Zhang.
+       Predicting missing links via local information.
+       Eur. Phys. J. B 71 (2009) 623.
+       https://arxiv.org/pdf/0901.0553.pdf
+    """
+
+    def predict(u, v):
+        return sum(1 / G.degree(w) for w in nx.common_neighbors(G, u, v))
+
+    return _apply_prediction(G, predict, ebunch)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def jaccard_coefficient(G, ebunch=None):
+    r"""Compute the Jaccard coefficient of all node pairs in ebunch.
+
+    Jaccard coefficient of nodes `u` and `v` is defined as
+
+    .. math::
+
+        \frac{|\Gamma(u) \cap \Gamma(v)|}{|\Gamma(u) \cup \Gamma(v)|}
+
+    where $\Gamma(u)$ denotes the set of neighbors of $u$.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX undirected graph.
+
+    ebunch : iterable of node pairs, optional (default = None)
+        Jaccard coefficient will be computed for each pair of nodes
+        given in the iterable. The pairs must be given as 2-tuples
+        (u, v) where u and v are nodes in the graph. If ebunch is None
+        then all non-existent edges in the graph will be used.
+        Default value: None.
+
+    Returns
+    -------
+    piter : iterator
+        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
+        pair of nodes and p is their Jaccard coefficient.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> preds = nx.jaccard_coefficient(G, [(0, 1), (2, 3)])
+    >>> for u, v, p in preds:
+    ...     print(f"({u}, {v}) -> {p:.8f}")
+    (0, 1) -> 0.60000000
+    (2, 3) -> 0.60000000
+
+    References
+    ----------
+    .. [1] D. Liben-Nowell, J. Kleinberg.
+           The Link Prediction Problem for Social Networks (2004).
+           http://www.cs.cornell.edu/home/kleinber/link-pred.pdf
+    """
+
+    def predict(u, v):
+        union_size = len(set(G[u]) | set(G[v]))
+        if union_size == 0:
+            return 0
+        return len(list(nx.common_neighbors(G, u, v))) / union_size
+
+    return _apply_prediction(G, predict, ebunch)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def adamic_adar_index(G, ebunch=None):
+    r"""Compute the Adamic-Adar index of all node pairs in ebunch.
+
+    Adamic-Adar index of `u` and `v` is defined as
+
+    .. math::
+
+        \sum_{w \in \Gamma(u) \cap \Gamma(v)} \frac{1}{\log |\Gamma(w)|}
+
+    where $\Gamma(u)$ denotes the set of neighbors of $u$.
+    This index leads to zero-division for nodes only connected via self-loops.
+    It is intended to be used when no self-loops are present.
+
+    Parameters
+    ----------
+    G : graph
+        NetworkX undirected graph.
+
+    ebunch : iterable of node pairs, optional (default = None)
+        Adamic-Adar index will be computed for each pair of nodes given
+        in the iterable. The pairs must be given as 2-tuples (u, v)
+        where u and v are nodes in the graph. If ebunch is None then all
+        non-existent edges in the graph will be used.
+        Default value: None.
+
+    Returns
+    -------
+    piter : iterator
+        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
+        pair of nodes and p is their Adamic-Adar index.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> preds = nx.adamic_adar_index(G, [(0, 1), (2, 3)])
+    >>> for u, v, p in preds:
+    ...     print(f"({u}, {v}) -> {p:.8f}")
+    (0, 1) -> 2.16404256
+    (2, 3) -> 2.16404256
+
+    References
+    ----------
+    .. [1] D. Liben-Nowell, J. Kleinberg.
+           The Link Prediction Problem for Social Networks (2004).
+           http://www.cs.cornell.edu/home/kleinber/link-pred.pdf
+    """
+
+    def predict(u, v):
+        return sum(1 / log(G.degree(w)) for w in nx.common_neighbors(G, u, v))
+
+    return _apply_prediction(G, predict, ebunch)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def common_neighbor_centrality(G, ebunch=None, alpha=0.8):
+    r"""Return the CCPA score for each pair of nodes.
+
+    Compute the Common Neighbor and Centrality based Parameterized Algorithm(CCPA)
+    score of all node pairs in ebunch.
+
+    CCPA score of `u` and `v` is defined as
+
+    .. math::
+
+        \alpha \cdot (|\Gamma (u){\cap }^{}\Gamma (v)|)+(1-\alpha )\cdot \frac{N}{{d}_{uv}}
+
+    where $\Gamma(u)$ denotes the set of neighbors of $u$, $\Gamma(v)$ denotes the
+    set of neighbors of $v$, $\alpha$ is  parameter varies between [0,1], $N$ denotes
+    total number of nodes in the Graph and ${d}_{uv}$ denotes shortest distance
+    between $u$ and $v$.
+
+    This algorithm is based on two vital properties of nodes, namely the number
+    of common neighbors and their centrality. Common neighbor refers to the common
+    nodes between two nodes. Centrality refers to the prestige that a node enjoys
+    in a network.
+
+    .. seealso::
+
+        :func:`common_neighbors`
+
+    Parameters
+    ----------
+    G : graph
+        NetworkX undirected graph.
+
+    ebunch : iterable of node pairs, optional (default = None)
+        Preferential attachment score will be computed for each pair of
+        nodes given in the iterable. The pairs must be given as
+        2-tuples (u, v) where u and v are nodes in the graph. If ebunch
+        is None then all non-existent edges in the graph will be used.
+        Default value: None.
+
+    alpha : Parameter defined for participation of Common Neighbor
+            and Centrality Algorithm share. Values for alpha should
+            normally be between 0 and 1. Default value set to 0.8
+            because author found better performance at 0.8 for all the
+            dataset.
+            Default value: 0.8
+
+
+    Returns
+    -------
+    piter : iterator
+        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
+        pair of nodes and p is their Common Neighbor and Centrality based
+        Parameterized Algorithm(CCPA) score.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> preds = nx.common_neighbor_centrality(G, [(0, 1), (2, 3)])
+    >>> for u, v, p in preds:
+    ...     print(f"({u}, {v}) -> {p}")
+    (0, 1) -> 3.4000000000000004
+    (2, 3) -> 3.4000000000000004
+
+    References
+    ----------
+    .. [1] Ahmad, I., Akhtar, M.U., Noor, S. et al.
+           Missing Link Prediction using Common Neighbor and Centrality based Parameterized Algorithm.
+           Sci Rep 10, 364 (2020).
+           https://doi.org/10.1038/s41598-019-57304-y
+    """
+
+    # When alpha == 1, the CCPA score simplifies to the number of common neighbors.
+    if alpha == 1:
+
+        def predict(u, v):
+            if u == v:
+                raise nx.NetworkXAlgorithmError("Self links are not supported")
+
+            return sum(1 for _ in nx.common_neighbors(G, u, v))
+
+    else:
+        spl = dict(nx.shortest_path_length(G))
+        inf = float("inf")
+
+        def predict(u, v):
+            if u == v:
+                raise nx.NetworkXAlgorithmError("Self links are not supported")
+            path_len = spl[u].get(v, inf)
+
+            return alpha * sum(1 for _ in nx.common_neighbors(G, u, v)) + (
+                1 - alpha
+            ) * (G.number_of_nodes() / path_len)
+
+    return _apply_prediction(G, predict, ebunch)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def preferential_attachment(G, ebunch=None):
+    r"""Compute the preferential attachment score of all node pairs in ebunch.
+
+    Preferential attachment score of `u` and `v` is defined as
+
+    .. math::
+
+        |\Gamma(u)| |\Gamma(v)|
+
+    where $\Gamma(u)$ denotes the set of neighbors of $u$.
+
+    Parameters
+    ----------
+    G : graph
+        NetworkX undirected graph.
+
+    ebunch : iterable of node pairs, optional (default = None)
+        Preferential attachment score will be computed for each pair of
+        nodes given in the iterable. The pairs must be given as
+        2-tuples (u, v) where u and v are nodes in the graph. If ebunch
+        is None then all non-existent edges in the graph will be used.
+        Default value: None.
+
+    Returns
+    -------
+    piter : iterator
+        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
+        pair of nodes and p is their preferential attachment score.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> preds = nx.preferential_attachment(G, [(0, 1), (2, 3)])
+    >>> for u, v, p in preds:
+    ...     print(f"({u}, {v}) -> {p}")
+    (0, 1) -> 16
+    (2, 3) -> 16
+
+    References
+    ----------
+    .. [1] D. Liben-Nowell, J. Kleinberg.
+           The Link Prediction Problem for Social Networks (2004).
+           http://www.cs.cornell.edu/home/kleinber/link-pred.pdf
+    """
+
+    def predict(u, v):
+        return G.degree(u) * G.degree(v)
+
+    return _apply_prediction(G, predict, ebunch)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def cn_soundarajan_hopcroft(G, ebunch=None, community="community"):
+    r"""Count the number of common neighbors of all node pairs in ebunch
+        using community information.
+
+    For two nodes $u$ and $v$, this function computes the number of
+    common neighbors and bonus one for each common neighbor belonging to
+    the same community as $u$ and $v$. Mathematically,
+
+    .. math::
+
+        |\Gamma(u) \cap \Gamma(v)| + \sum_{w \in \Gamma(u) \cap \Gamma(v)} f(w)
+
+    where $f(w)$ equals 1 if $w$ belongs to the same community as $u$
+    and $v$ or 0 otherwise and $\Gamma(u)$ denotes the set of
+    neighbors of $u$.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX undirected graph.
+
+    ebunch : iterable of node pairs, optional (default = None)
+        The score will be computed for each pair of nodes given in the
+        iterable. The pairs must be given as 2-tuples (u, v) where u
+        and v are nodes in the graph. If ebunch is None then all
+        non-existent edges in the graph will be used.
+        Default value: None.
+
+    community : string, optional (default = 'community')
+        Nodes attribute name containing the community information.
+        G[u][community] identifies which community u belongs to. Each
+        node belongs to at most one community. Default value: 'community'.
+
+    Returns
+    -------
+    piter : iterator
+        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
+        pair of nodes and p is their score.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(3)
+    >>> G.nodes[0]["community"] = 0
+    >>> G.nodes[1]["community"] = 0
+    >>> G.nodes[2]["community"] = 0
+    >>> preds = nx.cn_soundarajan_hopcroft(G, [(0, 2)])
+    >>> for u, v, p in preds:
+    ...     print(f"({u}, {v}) -> {p}")
+    (0, 2) -> 2
+
+    References
+    ----------
+    .. [1] Sucheta Soundarajan and John Hopcroft.
+       Using community information to improve the precision of link
+       prediction methods.
+       In Proceedings of the 21st international conference companion on
+       World Wide Web (WWW '12 Companion). ACM, New York, NY, USA, 607-608.
+       http://doi.acm.org/10.1145/2187980.2188150
+    """
+
+    def predict(u, v):
+        Cu = _community(G, u, community)
+        Cv = _community(G, v, community)
+        cnbors = list(nx.common_neighbors(G, u, v))
+        neighbors = (
+            sum(_community(G, w, community) == Cu for w in cnbors) if Cu == Cv else 0
+        )
+        return len(cnbors) + neighbors
+
+    return _apply_prediction(G, predict, ebunch)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def ra_index_soundarajan_hopcroft(G, ebunch=None, community="community"):
+    r"""Compute the resource allocation index of all node pairs in
+    ebunch using community information.
+
+    For two nodes $u$ and $v$, this function computes the resource
+    allocation index considering only common neighbors belonging to the
+    same community as $u$ and $v$. Mathematically,
+
+    .. math::
+
+        \sum_{w \in \Gamma(u) \cap \Gamma(v)} \frac{f(w)}{|\Gamma(w)|}
+
+    where $f(w)$ equals 1 if $w$ belongs to the same community as $u$
+    and $v$ or 0 otherwise and $\Gamma(u)$ denotes the set of
+    neighbors of $u$.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX undirected graph.
+
+    ebunch : iterable of node pairs, optional (default = None)
+        The score will be computed for each pair of nodes given in the
+        iterable. The pairs must be given as 2-tuples (u, v) where u
+        and v are nodes in the graph. If ebunch is None then all
+        non-existent edges in the graph will be used.
+        Default value: None.
+
+    community : string, optional (default = 'community')
+        Nodes attribute name containing the community information.
+        G[u][community] identifies which community u belongs to. Each
+        node belongs to at most one community. Default value: 'community'.
+
+    Returns
+    -------
+    piter : iterator
+        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
+        pair of nodes and p is their score.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
+    >>> G.nodes[0]["community"] = 0
+    >>> G.nodes[1]["community"] = 0
+    >>> G.nodes[2]["community"] = 1
+    >>> G.nodes[3]["community"] = 0
+    >>> preds = nx.ra_index_soundarajan_hopcroft(G, [(0, 3)])
+    >>> for u, v, p in preds:
+    ...     print(f"({u}, {v}) -> {p:.8f}")
+    (0, 3) -> 0.50000000
+
+    References
+    ----------
+    .. [1] Sucheta Soundarajan and John Hopcroft.
+       Using community information to improve the precision of link
+       prediction methods.
+       In Proceedings of the 21st international conference companion on
+       World Wide Web (WWW '12 Companion). ACM, New York, NY, USA, 607-608.
+       http://doi.acm.org/10.1145/2187980.2188150
+    """
+
+    def predict(u, v):
+        Cu = _community(G, u, community)
+        Cv = _community(G, v, community)
+        if Cu != Cv:
+            return 0
+        cnbors = nx.common_neighbors(G, u, v)
+        return sum(1 / G.degree(w) for w in cnbors if _community(G, w, community) == Cu)
+
+    return _apply_prediction(G, predict, ebunch)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def within_inter_cluster(G, ebunch=None, delta=0.001, community="community"):
+    """Compute the ratio of within- and inter-cluster common neighbors
+    of all node pairs in ebunch.
+
+    For two nodes `u` and `v`, if a common neighbor `w` belongs to the
+    same community as them, `w` is considered as within-cluster common
+    neighbor of `u` and `v`. Otherwise, it is considered as
+    inter-cluster common neighbor of `u` and `v`. The ratio between the
+    size of the set of within- and inter-cluster common neighbors is
+    defined as the WIC measure. [1]_
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX undirected graph.
+
+    ebunch : iterable of node pairs, optional (default = None)
+        The WIC measure will be computed for each pair of nodes given in
+        the iterable. The pairs must be given as 2-tuples (u, v) where
+        u and v are nodes in the graph. If ebunch is None then all
+        non-existent edges in the graph will be used.
+        Default value: None.
+
+    delta : float, optional (default = 0.001)
+        Value to prevent division by zero in case there is no
+        inter-cluster common neighbor between two nodes. See [1]_ for
+        details. Default value: 0.001.
+
+    community : string, optional (default = 'community')
+        Nodes attribute name containing the community information.
+        G[u][community] identifies which community u belongs to. Each
+        node belongs to at most one community. Default value: 'community'.
+
+    Returns
+    -------
+    piter : iterator
+        An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
+        pair of nodes and p is their WIC measure.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_edges_from([(0, 1), (0, 2), (0, 3), (1, 4), (2, 4), (3, 4)])
+    >>> G.nodes[0]["community"] = 0
+    >>> G.nodes[1]["community"] = 1
+    >>> G.nodes[2]["community"] = 0
+    >>> G.nodes[3]["community"] = 0
+    >>> G.nodes[4]["community"] = 0
+    >>> preds = nx.within_inter_cluster(G, [(0, 4)])
+    >>> for u, v, p in preds:
+    ...     print(f"({u}, {v}) -> {p:.8f}")
+    (0, 4) -> 1.99800200
+    >>> preds = nx.within_inter_cluster(G, [(0, 4)], delta=0.5)
+    >>> for u, v, p in preds:
+    ...     print(f"({u}, {v}) -> {p:.8f}")
+    (0, 4) -> 1.33333333
+
+    References
+    ----------
+    .. [1] Jorge Carlos Valverde-Rebaza and Alneu de Andrade Lopes.
+       Link prediction in complex networks based on cluster information.
+       In Proceedings of the 21st Brazilian conference on Advances in
+       Artificial Intelligence (SBIA'12)
+       https://doi.org/10.1007/978-3-642-34459-6_10
+    """
+    if delta <= 0:
+        raise nx.NetworkXAlgorithmError("Delta must be greater than zero")
+
+    def predict(u, v):
+        Cu = _community(G, u, community)
+        Cv = _community(G, v, community)
+        if Cu != Cv:
+            return 0
+        cnbors = set(nx.common_neighbors(G, u, v))
+        within = {w for w in cnbors if _community(G, w, community) == Cu}
+        inter = cnbors - within
+        return len(within) / (len(inter) + delta)
+
+    return _apply_prediction(G, predict, ebunch)
+
+
+def _community(G, u, community):
+    """Get the community of the given node."""
+    node_u = G.nodes[u]
+    try:
+        return node_u[community]
+    except KeyError as err:
+        raise nx.NetworkXAlgorithmError("No community information") from err
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/lowest_common_ancestors.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/lowest_common_ancestors.py
new file mode 100644
index 0000000..fa5c9db
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/lowest_common_ancestors.py
@@ -0,0 +1,365 @@
+"""Algorithms for finding the lowest common ancestor of trees and DAGs."""
+from collections import defaultdict
+from collections.abc import Mapping, Set
+from itertools import chain, count
+
+import networkx as nx
+from networkx.utils import UnionFind, arbitrary_element, not_implemented_for
+
+__all__ = [
+    "all_pairs_lowest_common_ancestor",
+    "tree_all_pairs_lowest_common_ancestor",
+    "lowest_common_ancestor",
+]
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def tree_all_pairs_lowest_common_ancestor(G, root=None, pairs=None):
+    r"""Yield the lowest common ancestor for sets of pairs in a tree.
+
+    Parameters
+    ----------
+    G : NetworkX directed graph (must be a tree)
+
+    root : node, optional (default: None)
+        The root of the subtree to operate on.
+        If None, assume the entire graph has exactly one source and use that.
+
+    pairs : iterable or iterator of pairs of nodes, optional (default: None)
+        The pairs of interest. If None, Defaults to all pairs of nodes
+        under `root` that have a lowest common ancestor.
+
+    Returns
+    -------
+    lcas : generator of tuples `((u, v), lca)` where `u` and `v` are nodes
+        in `pairs` and `lca` is their lowest common ancestor.
+
+    Notes
+    -----
+    Only defined on non-null trees represented with directed edges from
+    parents to children. Uses Tarjan's off-line lowest-common-ancestors
+    algorithm. Runs in time $O(4 \times (V + E + P))$ time, where 4 is the largest
+    value of the inverse Ackermann function likely to ever come up in actual
+    use, and $P$ is the number of pairs requested (or $V^2$ if all are needed).
+
+    Tarjan, R. E. (1979), "Applications of path compression on balanced trees",
+    Journal of the ACM 26 (4): 690-715, doi:10.1145/322154.322161.
+
+    See Also
+    --------
+    all_pairs_lowest_common_ancestor: similar routine for general DAGs
+    lowest_common_ancestor: just a single pair for general DAGs
+    """
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept("LCA meaningless on null graphs.")
+    elif None in G:
+        raise nx.NetworkXError("None is not a valid node.")
+
+    # Index pairs of interest for efficient lookup from either side.
+    if pairs is not None:
+        pair_dict = defaultdict(set)
+        # See note on all_pairs_lowest_common_ancestor.
+        if not isinstance(pairs, (Mapping, Set)):
+            pairs = set(pairs)
+        for u, v in pairs:
+            for n in (u, v):
+                if n not in G:
+                    msg = f"The node {str(n)} is not in the digraph."
+                    raise nx.NodeNotFound(msg)
+            pair_dict[u].add(v)
+            pair_dict[v].add(u)
+
+    # If root is not specified, find the exactly one node with in degree 0 and
+    # use it. Raise an error if none are found, or more than one is. Also check
+    # for any nodes with in degree larger than 1, which would imply G is not a
+    # tree.
+    if root is None:
+        for n, deg in G.in_degree:
+            if deg == 0:
+                if root is not None:
+                    msg = "No root specified and tree has multiple sources."
+                    raise nx.NetworkXError(msg)
+                root = n
+            elif deg > 1:
+                msg = "Tree LCA only defined on trees; use DAG routine."
+                raise nx.NetworkXError(msg)
+    if root is None:
+        raise nx.NetworkXError("Graph contains a cycle.")
+
+    # Iterative implementation of Tarjan's offline lca algorithm
+    # as described in CLRS on page 521 (2nd edition)/page 584 (3rd edition)
+    uf = UnionFind()
+    ancestors = {}
+    for node in G:
+        ancestors[node] = uf[node]
+
+    colors = defaultdict(bool)
+    for node in nx.dfs_postorder_nodes(G, root):
+        colors[node] = True
+        for v in pair_dict[node] if pairs is not None else G:
+            if colors[v]:
+                # If the user requested both directions of a pair, give it.
+                # Otherwise, just give one.
+                if pairs is not None and (node, v) in pairs:
+                    yield (node, v), ancestors[uf[v]]
+                if pairs is None or (v, node) in pairs:
+                    yield (v, node), ancestors[uf[v]]
+        if node != root:
+            parent = arbitrary_element(G.pred[node])
+            uf.union(parent, node)
+            ancestors[uf[parent]] = parent
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def lowest_common_ancestor(G, node1, node2, default=None):
+    """Compute the lowest common ancestor of the given pair of nodes.
+
+    Parameters
+    ----------
+    G : NetworkX directed graph
+
+    node1, node2 : nodes in the graph.
+
+    default : object
+        Returned if no common ancestor between `node1` and `node2`
+
+    Returns
+    -------
+    The lowest common ancestor of node1 and node2,
+    or default if they have no common ancestors.
+
+    Notes
+    -----
+    Only defined on non-null directed acyclic graphs.
+    Takes n log(n) time in the size of the graph.
+    See `all_pairs_lowest_common_ancestor` when you have
+    more than one pair of nodes of interest.
+
+    See Also
+    --------
+    tree_all_pairs_lowest_common_ancestor
+    all_pairs_lowest_common_ancestor
+    """
+    ans = list(all_pairs_lowest_common_ancestor(G, pairs=[(node1, node2)]))
+    if ans:
+        assert len(ans) == 1
+        return ans[0][1]
+    else:
+        return default
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def all_pairs_lowest_common_ancestor(G, pairs=None):
+    """Compute the lowest common ancestor for pairs of nodes.
+
+    Parameters
+    ----------
+    G : NetworkX directed graph
+
+    pairs : iterable of pairs of nodes, optional (default: all pairs)
+        The pairs of nodes of interest.
+        If None, will find the LCA of all pairs of nodes.
+
+    Returns
+    -------
+    An iterator over ((node1, node2), lca) where (node1, node2) are
+    the pairs specified and lca is a lowest common ancestor of the pair.
+    Note that for the default of all pairs in G, we consider
+    unordered pairs, e.g. you will not get both (b, a) and (a, b).
+
+    Notes
+    -----
+    Only defined on non-null directed acyclic graphs.
+
+    Uses the $O(n^3)$ ancestor-list algorithm from:
+    M. A. Bender, M. Farach-Colton, G. Pemmasani, S. Skiena, P. Sumazin.
+    "Lowest common ancestors in trees and directed acyclic graphs."
+    Journal of Algorithms, 57(2): 75-94, 2005.
+
+    See Also
+    --------
+    tree_all_pairs_lowest_common_ancestor
+    lowest_common_ancestor
+    """
+    if not nx.is_directed_acyclic_graph(G):
+        raise nx.NetworkXError("LCA only defined on directed acyclic graphs.")
+    elif len(G) == 0:
+        raise nx.NetworkXPointlessConcept("LCA meaningless on null graphs.")
+    elif None in G:
+        raise nx.NetworkXError("None is not a valid node.")
+
+    # The copy isn't ideal, neither is the switch-on-type, but without it users
+    # passing an iterable will encounter confusing errors, and itertools.tee
+    # does not appear to handle builtin types efficiently (IE, it materializes
+    # another buffer rather than just creating listoperators at the same
+    # offset). The Python documentation notes use of tee is unadvised when one
+    # is consumed before the other.
+    #
+    # This will always produce correct results and avoid unnecessary
+    # copies in many common cases.
+    #
+    if not isinstance(pairs, (Mapping, Set)) and pairs is not None:
+        pairs = set(pairs)
+
+    # Convert G into a dag with a single root by adding a node with edges to
+    # all sources iff necessary.
+    sources = [n for n, deg in G.in_degree if deg == 0]
+    if len(sources) == 1:
+        root = sources[0]
+        super_root = None
+    else:
+        G = G.copy()
+        # find unused node
+        root = -1
+        while root in G:
+            root -= 1
+        # use that as the super_root below all sources
+        super_root = root
+        for source in sources:
+            G.add_edge(root, source)
+
+    # Start by computing a spanning tree, and the DAG of all edges not in it.
+    # We will then use the tree lca algorithm on the spanning tree, and use
+    # the DAG to figure out the set of tree queries necessary.
+    spanning_tree = nx.dfs_tree(G, root)
+    dag = nx.DiGraph(
+        (u, v)
+        for u, v in G.edges
+        if u not in spanning_tree or v not in spanning_tree[u]
+    )
+
+    # Ensure that both the dag and the spanning tree contains all nodes in G,
+    # even nodes that are disconnected in the dag.
+    spanning_tree.add_nodes_from(G)
+    dag.add_nodes_from(G)
+
+    counter = count()
+
+    # Necessary to handle graphs consisting of a single node and no edges.
+    root_distance = {root: next(counter)}
+
+    for edge in nx.bfs_edges(spanning_tree, root):
+        for node in edge:
+            if node not in root_distance:
+                root_distance[node] = next(counter)
+
+    # Index the position of all nodes in the Euler tour so we can efficiently
+    # sort lists and merge in tour order.
+    euler_tour_pos = {}
+    for node in nx.depth_first_search.dfs_preorder_nodes(G, root):
+        if node not in euler_tour_pos:
+            euler_tour_pos[node] = next(counter)
+
+    # Generate the set of all nodes of interest in the pairs.
+    pairset = set()
+    if pairs is not None:
+        pairset = set(chain.from_iterable(pairs))
+
+    for n in pairset:
+        if n not in G:
+            msg = f"The node {str(n)} is not in the digraph."
+            raise nx.NodeNotFound(msg)
+
+    # Generate the transitive closure over the dag (not G) of all nodes, and
+    # sort each node's closure set by order of first appearance in the Euler
+    # tour.
+    ancestors = {}
+    for v in dag:
+        if pairs is None or v in pairset:
+            my_ancestors = nx.ancestors(G, v)
+            my_ancestors.add(v)
+            ancestors[v] = sorted(my_ancestors, key=euler_tour_pos.get)
+
+    def _compute_dag_lca_from_tree_values(tree_lca, dry_run):
+        """Iterate through the in-order merge for each pair of interest.
+
+        We do this to answer the user's query, but it is also used to
+        avoid generating unnecessary tree entries when the user only
+        needs some pairs.
+        """
+        for (node1, node2) in pairs if pairs is not None else tree_lca:
+            best_root_distance = None
+            best = None
+
+            indices = [0, 0]
+            ancestors_by_index = [ancestors[node1], ancestors[node2]]
+
+            def get_next_in_merged_lists(indices):
+                """Returns index of the list containing the next item
+
+                Next order refers to the merged order.
+                Index can be 0 or 1 (or None if exhausted).
+                """
+                index1, index2 = indices
+                if index1 >= len(ancestors[node1]) and index2 >= len(ancestors[node2]):
+                    return None
+                elif index1 >= len(ancestors[node1]):
+                    return 1
+                elif index2 >= len(ancestors[node2]):
+                    return 0
+                elif (
+                    euler_tour_pos[ancestors[node1][index1]]
+                    < euler_tour_pos[ancestors[node2][index2]]
+                ):
+                    return 0
+                else:
+                    return 1
+
+            # Find the LCA by iterating through the in-order merge of the two
+            # nodes of interests' ancestor sets. In principle, we need to
+            # consider all pairs in the Cartesian product of the ancestor sets,
+            # but by the restricted min range query reduction we are guaranteed
+            # that one of the pairs of interest is adjacent in the merged list
+            # iff one came from each list.
+            i = get_next_in_merged_lists(indices)
+            cur = ancestors_by_index[i][indices[i]], i
+            while i is not None:
+                prev = cur
+                indices[i] += 1
+                i = get_next_in_merged_lists(indices)
+                if i is not None:
+                    cur = ancestors_by_index[i][indices[i]], i
+
+                    # Two adjacent entries must not be from the same list
+                    # in order for their tree LCA to be considered.
+                    if cur[1] != prev[1]:
+                        tree_node1, tree_node2 = prev[0], cur[0]
+                        if (tree_node1, tree_node2) in tree_lca:
+                            ans = tree_lca[tree_node1, tree_node2]
+                        else:
+                            ans = tree_lca[tree_node2, tree_node1]
+                        if not dry_run and (
+                            best is None or root_distance[ans] > best_root_distance
+                        ):
+                            best_root_distance = root_distance[ans]
+                            best = ans
+
+            # If the LCA is super_root, there is no LCA in the user's graph.
+            if not dry_run and (super_root is None or best != super_root):
+                yield (node1, node2), best
+
+    # Generate the spanning tree lca for all pairs. This doesn't make sense to
+    # do incrementally since we are using a linear time offline algorithm for
+    # tree lca.
+    if pairs is None:
+        # We want all pairs so we'll need the entire tree.
+        tree_lca = dict(tree_all_pairs_lowest_common_ancestor(spanning_tree, root))
+    else:
+        # We only need the merged adjacent pairs by seeing which queries the
+        # algorithm needs then generating them in a single pass.
+        tree_lca = defaultdict(int)
+        for _ in _compute_dag_lca_from_tree_values(tree_lca, True):
+            pass
+
+        # Replace the bogus default tree values with the real ones.
+        for (pair, lca) in tree_all_pairs_lowest_common_ancestor(
+            spanning_tree, root, tree_lca
+        ):
+            tree_lca[pair] = lca
+
+    # All precomputations complete. Now we just need to give the user the pairs
+    # they asked for, or all pairs if they want them all.
+    return _compute_dag_lca_from_tree_values(tree_lca, False)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/matching.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/matching.py
new file mode 100644
index 0000000..a4e7e9c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/matching.py
@@ -0,0 +1,1123 @@
+"""Functions for computing and verifying matchings in a graph."""
+from collections import Counter
+from itertools import combinations, repeat
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "is_matching",
+    "is_maximal_matching",
+    "is_perfect_matching",
+    "max_weight_matching",
+    "min_weight_matching",
+    "maximal_matching",
+]
+
+
+@not_implemented_for("multigraph")
+@not_implemented_for("directed")
+def maximal_matching(G):
+    r"""Find a maximal matching in the graph.
+
+    A matching is a subset of edges in which no node occurs more than once.
+    A maximal matching cannot add more edges and still be a matching.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    Returns
+    -------
+    matching : set
+        A maximal matching of the graph.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (2, 3), (2, 4), (3, 5), (4, 5)])
+    >>> sorted(nx.maximal_matching(G))
+    [(1, 2), (3, 5)]
+
+    Notes
+    -----
+    The algorithm greedily selects a maximal matching M of the graph G
+    (i.e. no superset of M exists). It runs in $O(|E|)$ time.
+    """
+    matching = set()
+    nodes = set()
+    for edge in G.edges():
+        # If the edge isn't covered, add it to the matching
+        # then remove neighborhood of u and v from consideration.
+        u, v = edge
+        if u not in nodes and v not in nodes and u != v:
+            matching.add(edge)
+            nodes.update(edge)
+    return matching
+
+
+def matching_dict_to_set(matching):
+    """Converts matching dict format to matching set format
+
+    Converts a dictionary representing a matching (as returned by
+    :func:`max_weight_matching`) to a set representing a matching (as
+    returned by :func:`maximal_matching`).
+
+    In the definition of maximal matching adopted by NetworkX,
+    self-loops are not allowed, so the provided dictionary is expected
+    to never have any mapping from a key to itself. However, the
+    dictionary is expected to have mirrored key/value pairs, for
+    example, key ``u`` with value ``v`` and key ``v`` with value ``u``.
+
+    """
+    edges = set()
+    for edge in matching.items():
+        u, v = edge
+        if (v, u) in edges or edge in edges:
+            continue
+        if u == v:
+            raise nx.NetworkXError(f"Selfloops cannot appear in matchings {edge}")
+        edges.add(edge)
+    return edges
+
+
+def is_matching(G, matching):
+    """Return True if ``matching`` is a valid matching of ``G``
+
+    A *matching* in a graph is a set of edges in which no two distinct
+    edges share a common endpoint. Each node is incident to at most one
+    edge in the matching. The edges are said to be independent.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    matching : dict or set
+        A dictionary or set representing a matching. If a dictionary, it
+        must have ``matching[u] == v`` and ``matching[v] == u`` for each
+        edge ``(u, v)`` in the matching. If a set, it must have elements
+        of the form ``(u, v)``, where ``(u, v)`` is an edge in the
+        matching.
+
+    Returns
+    -------
+    bool
+        Whether the given set or dictionary represents a valid matching
+        in the graph.
+
+    Raises
+    ------
+    NetworkXError
+        If the proposed matching has an edge to a node not in G.
+        Or if the matching is not a collection of 2-tuple edges.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (2, 3), (2, 4), (3, 5), (4, 5)])
+    >>> nx.is_maximal_matching(G, {1: 3, 2: 4})  # using dict to represent matching
+    True
+
+    >>> nx.is_matching(G, {(1, 3), (2, 4)})  # using set to represent matching
+    True
+
+    """
+    if isinstance(matching, dict):
+        matching = matching_dict_to_set(matching)
+
+    nodes = set()
+    for edge in matching:
+        if len(edge) != 2:
+            raise nx.NetworkXError(f"matching has non-2-tuple edge {edge}")
+        u, v = edge
+        if u not in G or v not in G:
+            raise nx.NetworkXError(f"matching contains edge {edge} with node not in G")
+        if u == v:
+            return False
+        if not G.has_edge(u, v):
+            return False
+        if u in nodes or v in nodes:
+            return False
+        nodes.update(edge)
+    return True
+
+
+def is_maximal_matching(G, matching):
+    """Return True if ``matching`` is a maximal matching of ``G``
+
+    A *maximal matching* in a graph is a matching in which adding any
+    edge would cause the set to no longer be a valid matching.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    matching : dict or set
+        A dictionary or set representing a matching. If a dictionary, it
+        must have ``matching[u] == v`` and ``matching[v] == u`` for each
+        edge ``(u, v)`` in the matching. If a set, it must have elements
+        of the form ``(u, v)``, where ``(u, v)`` is an edge in the
+        matching.
+
+    Returns
+    -------
+    bool
+        Whether the given set or dictionary represents a valid maximal
+        matching in the graph.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (2, 3), (3, 4), (3, 5)])
+    >>> nx.is_maximal_matching(G, {(1, 2), (3, 4)})
+    True
+
+    """
+    if isinstance(matching, dict):
+        matching = matching_dict_to_set(matching)
+    # If the given set is not a matching, then it is not a maximal matching.
+    edges = set()
+    nodes = set()
+    for edge in matching:
+        if len(edge) != 2:
+            raise nx.NetworkXError(f"matching has non-2-tuple edge {edge}")
+        u, v = edge
+        if u not in G or v not in G:
+            raise nx.NetworkXError(f"matching contains edge {edge} with node not in G")
+        if u == v:
+            return False
+        if not G.has_edge(u, v):
+            return False
+        if u in nodes or v in nodes:
+            return False
+        nodes.update(edge)
+        edges.add(edge)
+        edges.add((v, u))
+    # A matching is maximal if adding any new edge from G to it
+    # causes the resulting set to match some node twice.
+    # Be careful to check for adding selfloops
+    for u, v in G.edges:
+        if (u, v) not in edges:
+            # could add edge (u, v) to edges and have a bigger matching
+            if u not in nodes and v not in nodes and u != v:
+                return False
+    return True
+
+
+def is_perfect_matching(G, matching):
+    """Return True if ``matching`` is a perfect matching for ``G``
+
+    A *perfect matching* in a graph is a matching in which exactly one edge
+    is incident upon each vertex.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    matching : dict or set
+        A dictionary or set representing a matching. If a dictionary, it
+        must have ``matching[u] == v`` and ``matching[v] == u`` for each
+        edge ``(u, v)`` in the matching. If a set, it must have elements
+        of the form ``(u, v)``, where ``(u, v)`` is an edge in the
+        matching.
+
+    Returns
+    -------
+    bool
+        Whether the given set or dictionary represents a valid perfect
+        matching in the graph.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (2, 3), (2, 4), (3, 5), (4, 5), (4, 6)])
+    >>> my_match = {1: 2, 3: 5, 4: 6}
+    >>> nx.is_perfect_matching(G, my_match)
+    True
+
+    """
+    if isinstance(matching, dict):
+        matching = matching_dict_to_set(matching)
+
+    nodes = set()
+    for edge in matching:
+        if len(edge) != 2:
+            raise nx.NetworkXError(f"matching has non-2-tuple edge {edge}")
+        u, v = edge
+        if u not in G or v not in G:
+            raise nx.NetworkXError(f"matching contains edge {edge} with node not in G")
+        if u == v:
+            return False
+        if not G.has_edge(u, v):
+            return False
+        if u in nodes or v in nodes:
+            return False
+        nodes.update(edge)
+    return len(nodes) == len(G)
+
+
+@not_implemented_for("multigraph")
+@not_implemented_for("directed")
+def min_weight_matching(G, maxcardinality=None, weight="weight"):
+    """Computing a minimum-weight maximal matching of G.
+
+    Use the maximum-weight algorithm with edge weights subtracted
+    from the maximum weight of all edges.
+
+    A matching is a subset of edges in which no node occurs more than once.
+    The weight of a matching is the sum of the weights of its edges.
+    A maximal matching cannot add more edges and still be a matching.
+    The cardinality of a matching is the number of matched edges.
+
+    This method replaces the edge weights with 1 plus the maximum edge weight
+    minus the original edge weight.
+
+    new_weight = (max_weight + 1) - edge_weight
+
+    then runs :func:`max_weight_matching` with the new weights.
+    The max weight matching with these new weights corresponds
+    to the min weight matching using the original weights.
+    Adding 1 to the max edge weight keeps all edge weights positive
+    and as integers if they started as integers.
+
+    You might worry that adding 1 to each weight would make the algorithm
+    favor matchings with more edges. But we use the parameter
+    `maxcardinality=True` in `max_weight_matching` to ensure that the
+    number of edges in the competing matchings are the same and thus
+    the optimum does not change due to changes in the number of edges.
+
+    Read the documentation of `max_weight_matching` for more information.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+      Undirected graph
+
+    maxcardinality: bool
+        .. deprecated:: 2.8
+            The `maxcardinality` parameter will be removed in v3.0.
+            It doesn't make sense to set it to False when looking for
+            a min weight matching because then we just return no edges.
+
+        If maxcardinality is True, compute the maximum-cardinality matching
+        with minimum weight among all maximum-cardinality matchings.
+
+    weight: string, optional (default='weight')
+       Edge data key corresponding to the edge weight.
+       If key not found, uses 1 as weight.
+
+    Returns
+    -------
+    matching : set
+        A minimal weight matching of the graph.
+
+    See Also
+    --------
+    max_weight_matching
+    """
+    if maxcardinality not in (True, None):
+        raise nx.NetworkXError(
+            "The argument maxcardinality does not make sense "
+            "in the context of minimum weight matchings."
+            "It is deprecated and will be removed in v3.0."
+        )
+    if len(G.edges) == 0:
+        return max_weight_matching(G, maxcardinality=True, weight=weight)
+    G_edges = G.edges(data=weight, default=1)
+    max_weight = 1 + max(w for _, _, w in G_edges)
+    InvG = nx.Graph()
+    edges = ((u, v, max_weight - w) for u, v, w in G_edges)
+    InvG.add_weighted_edges_from(edges, weight=weight)
+    return max_weight_matching(InvG, maxcardinality=True, weight=weight)
+
+
+@not_implemented_for("multigraph")
+@not_implemented_for("directed")
+def max_weight_matching(G, maxcardinality=False, weight="weight"):
+    """Compute a maximum-weighted matching of G.
+
+    A matching is a subset of edges in which no node occurs more than once.
+    The weight of a matching is the sum of the weights of its edges.
+    A maximal matching cannot add more edges and still be a matching.
+    The cardinality of a matching is the number of matched edges.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+      Undirected graph
+
+    maxcardinality: bool, optional (default=False)
+       If maxcardinality is True, compute the maximum-cardinality matching
+       with maximum weight among all maximum-cardinality matchings.
+
+    weight: string, optional (default='weight')
+       Edge data key corresponding to the edge weight.
+       If key not found, uses 1 as weight.
+
+
+    Returns
+    -------
+    matching : set
+        A maximal matching of the graph.
+
+     Examples
+    --------
+    >>> G = nx.Graph()
+    >>> edges = [(1, 2, 6), (1, 3, 2), (2, 3, 1), (2, 4, 7), (3, 5, 9), (4, 5, 3)]
+    >>> G.add_weighted_edges_from(edges)
+    >>> sorted(nx.max_weight_matching(G))
+    [(2, 4), (5, 3)]
+
+    Notes
+    -----
+    If G has edges with weight attributes the edge data are used as
+    weight values else the weights are assumed to be 1.
+
+    This function takes time O(number_of_nodes ** 3).
+
+    If all edge weights are integers, the algorithm uses only integer
+    computations.  If floating point weights are used, the algorithm
+    could return a slightly suboptimal matching due to numeric
+    precision errors.
+
+    This method is based on the "blossom" method for finding augmenting
+    paths and the "primal-dual" method for finding a matching of maximum
+    weight, both methods invented by Jack Edmonds [1]_.
+
+    Bipartite graphs can also be matched using the functions present in
+    :mod:`networkx.algorithms.bipartite.matching`.
+
+    References
+    ----------
+    .. [1] "Efficient Algorithms for Finding Maximum Matching in Graphs",
+       Zvi Galil, ACM Computing Surveys, 1986.
+    """
+    #
+    # The algorithm is taken from "Efficient Algorithms for Finding Maximum
+    # Matching in Graphs" by Zvi Galil, ACM Computing Surveys, 1986.
+    # It is based on the "blossom" method for finding augmenting paths and
+    # the "primal-dual" method for finding a matching of maximum weight, both
+    # methods invented by Jack Edmonds.
+    #
+    # A C program for maximum weight matching by Ed Rothberg was used
+    # extensively to validate this new code.
+    #
+    # Many terms used in the code comments are explained in the paper
+    # by Galil. You will probably need the paper to make sense of this code.
+    #
+
+    class NoNode:
+        """Dummy value which is different from any node."""
+
+        pass
+
+    class Blossom:
+        """Representation of a non-trivial blossom or sub-blossom."""
+
+        __slots__ = ["childs", "edges", "mybestedges"]
+
+        # b.childs is an ordered list of b's sub-blossoms, starting with
+        # the base and going round the blossom.
+
+        # b.edges is the list of b's connecting edges, such that
+        # b.edges[i] = (v, w) where v is a vertex in b.childs[i]
+        # and w is a vertex in b.childs[wrap(i+1)].
+
+        # If b is a top-level S-blossom,
+        # b.mybestedges is a list of least-slack edges to neighbouring
+        # S-blossoms, or None if no such list has been computed yet.
+        # This is used for efficient computation of delta3.
+
+        # Generate the blossom's leaf vertices.
+        def leaves(self):
+            for t in self.childs:
+                if isinstance(t, Blossom):
+                    yield from t.leaves()
+                else:
+                    yield t
+
+    # Get a list of vertices.
+    gnodes = list(G)
+    if not gnodes:
+        return set()  # don't bother with empty graphs
+
+    # Find the maximum edge weight.
+    maxweight = 0
+    allinteger = True
+    for i, j, d in G.edges(data=True):
+        wt = d.get(weight, 1)
+        if i != j and wt > maxweight:
+            maxweight = wt
+        allinteger = allinteger and (str(type(wt)).split("'")[1] in ("int", "long"))
+
+    # If v is a matched vertex, mate[v] is its partner vertex.
+    # If v is a single vertex, v does not occur as a key in mate.
+    # Initially all vertices are single; updated during augmentation.
+    mate = {}
+
+    # If b is a top-level blossom,
+    # label.get(b) is None if b is unlabeled (free),
+    #                 1 if b is an S-blossom,
+    #                 2 if b is a T-blossom.
+    # The label of a vertex is found by looking at the label of its top-level
+    # containing blossom.
+    # If v is a vertex inside a T-blossom, label[v] is 2 iff v is reachable
+    # from an S-vertex outside the blossom.
+    # Labels are assigned during a stage and reset after each augmentation.
+    label = {}
+
+    # If b is a labeled top-level blossom,
+    # labeledge[b] = (v, w) is the edge through which b obtained its label
+    # such that w is a vertex in b, or None if b's base vertex is single.
+    # If w is a vertex inside a T-blossom and label[w] == 2,
+    # labeledge[w] = (v, w) is an edge through which w is reachable from
+    # outside the blossom.
+    labeledge = {}
+
+    # If v is a vertex, inblossom[v] is the top-level blossom to which v
+    # belongs.
+    # If v is a top-level vertex, inblossom[v] == v since v is itself
+    # a (trivial) top-level blossom.
+    # Initially all vertices are top-level trivial blossoms.
+    inblossom = dict(zip(gnodes, gnodes))
+
+    # If b is a sub-blossom,
+    # blossomparent[b] is its immediate parent (sub-)blossom.
+    # If b is a top-level blossom, blossomparent[b] is None.
+    blossomparent = dict(zip(gnodes, repeat(None)))
+
+    # If b is a (sub-)blossom,
+    # blossombase[b] is its base VERTEX (i.e. recursive sub-blossom).
+    blossombase = dict(zip(gnodes, gnodes))
+
+    # If w is a free vertex (or an unreached vertex inside a T-blossom),
+    # bestedge[w] = (v, w) is the least-slack edge from an S-vertex,
+    # or None if there is no such edge.
+    # If b is a (possibly trivial) top-level S-blossom,
+    # bestedge[b] = (v, w) is the least-slack edge to a different S-blossom
+    # (v inside b), or None if there is no such edge.
+    # This is used for efficient computation of delta2 and delta3.
+    bestedge = {}
+
+    # If v is a vertex,
+    # dualvar[v] = 2 * u(v) where u(v) is the v's variable in the dual
+    # optimization problem (if all edge weights are integers, multiplication
+    # by two ensures that all values remain integers throughout the algorithm).
+    # Initially, u(v) = maxweight / 2.
+    dualvar = dict(zip(gnodes, repeat(maxweight)))
+
+    # If b is a non-trivial blossom,
+    # blossomdual[b] = z(b) where z(b) is b's variable in the dual
+    # optimization problem.
+    blossomdual = {}
+
+    # If (v, w) in allowedge or (w, v) in allowedg, then the edge
+    # (v, w) is known to have zero slack in the optimization problem;
+    # otherwise the edge may or may not have zero slack.
+    allowedge = {}
+
+    # Queue of newly discovered S-vertices.
+    queue = []
+
+    # Return 2 * slack of edge (v, w) (does not work inside blossoms).
+    def slack(v, w):
+        return dualvar[v] + dualvar[w] - 2 * G[v][w].get(weight, 1)
+
+    # Assign label t to the top-level blossom containing vertex w,
+    # coming through an edge from vertex v.
+    def assignLabel(w, t, v):
+        b = inblossom[w]
+        assert label.get(w) is None and label.get(b) is None
+        label[w] = label[b] = t
+        if v is not None:
+            labeledge[w] = labeledge[b] = (v, w)
+        else:
+            labeledge[w] = labeledge[b] = None
+        bestedge[w] = bestedge[b] = None
+        if t == 1:
+            # b became an S-vertex/blossom; add it(s vertices) to the queue.
+            if isinstance(b, Blossom):
+                queue.extend(b.leaves())
+            else:
+                queue.append(b)
+        elif t == 2:
+            # b became a T-vertex/blossom; assign label S to its mate.
+            # (If b is a non-trivial blossom, its base is the only vertex
+            # with an external mate.)
+            base = blossombase[b]
+            assignLabel(mate[base], 1, base)
+
+    # Trace back from vertices v and w to discover either a new blossom
+    # or an augmenting path. Return the base vertex of the new blossom,
+    # or NoNode if an augmenting path was found.
+    def scanBlossom(v, w):
+        # Trace back from v and w, placing breadcrumbs as we go.
+        path = []
+        base = NoNode
+        while v is not NoNode:
+            # Look for a breadcrumb in v's blossom or put a new breadcrumb.
+            b = inblossom[v]
+            if label[b] & 4:
+                base = blossombase[b]
+                break
+            assert label[b] == 1
+            path.append(b)
+            label[b] = 5
+            # Trace one step back.
+            if labeledge[b] is None:
+                # The base of blossom b is single; stop tracing this path.
+                assert blossombase[b] not in mate
+                v = NoNode
+            else:
+                assert labeledge[b][0] == mate[blossombase[b]]
+                v = labeledge[b][0]
+                b = inblossom[v]
+                assert label[b] == 2
+                # b is a T-blossom; trace one more step back.
+                v = labeledge[b][0]
+            # Swap v and w so that we alternate between both paths.
+            if w is not NoNode:
+                v, w = w, v
+        # Remove breadcrumbs.
+        for b in path:
+            label[b] = 1
+        # Return base vertex, if we found one.
+        return base
+
+    # Construct a new blossom with given base, through S-vertices v and w.
+    # Label the new blossom as S; set its dual variable to zero;
+    # relabel its T-vertices to S and add them to the queue.
+    def addBlossom(base, v, w):
+        bb = inblossom[base]
+        bv = inblossom[v]
+        bw = inblossom[w]
+        # Create blossom.
+        b = Blossom()
+        blossombase[b] = base
+        blossomparent[b] = None
+        blossomparent[bb] = b
+        # Make list of sub-blossoms and their interconnecting edge endpoints.
+        b.childs = path = []
+        b.edges = edgs = [(v, w)]
+        # Trace back from v to base.
+        while bv != bb:
+            # Add bv to the new blossom.
+            blossomparent[bv] = b
+            path.append(bv)
+            edgs.append(labeledge[bv])
+            assert label[bv] == 2 or (
+                label[bv] == 1 and labeledge[bv][0] == mate[blossombase[bv]]
+            )
+            # Trace one step back.
+            v = labeledge[bv][0]
+            bv = inblossom[v]
+        # Add base sub-blossom; reverse lists.
+        path.append(bb)
+        path.reverse()
+        edgs.reverse()
+        # Trace back from w to base.
+        while bw != bb:
+            # Add bw to the new blossom.
+            blossomparent[bw] = b
+            path.append(bw)
+            edgs.append((labeledge[bw][1], labeledge[bw][0]))
+            assert label[bw] == 2 or (
+                label[bw] == 1 and labeledge[bw][0] == mate[blossombase[bw]]
+            )
+            # Trace one step back.
+            w = labeledge[bw][0]
+            bw = inblossom[w]
+        # Set label to S.
+        assert label[bb] == 1
+        label[b] = 1
+        labeledge[b] = labeledge[bb]
+        # Set dual variable to zero.
+        blossomdual[b] = 0
+        # Relabel vertices.
+        for v in b.leaves():
+            if label[inblossom[v]] == 2:
+                # This T-vertex now turns into an S-vertex because it becomes
+                # part of an S-blossom; add it to the queue.
+                queue.append(v)
+            inblossom[v] = b
+        # Compute b.mybestedges.
+        bestedgeto = {}
+        for bv in path:
+            if isinstance(bv, Blossom):
+                if bv.mybestedges is not None:
+                    # Walk this subblossom's least-slack edges.
+                    nblist = bv.mybestedges
+                    # The sub-blossom won't need this data again.
+                    bv.mybestedges = None
+                else:
+                    # This subblossom does not have a list of least-slack
+                    # edges; get the information from the vertices.
+                    nblist = [
+                        (v, w) for v in bv.leaves() for w in G.neighbors(v) if v != w
+                    ]
+            else:
+                nblist = [(bv, w) for w in G.neighbors(bv) if bv != w]
+            for k in nblist:
+                (i, j) = k
+                if inblossom[j] == b:
+                    i, j = j, i
+                bj = inblossom[j]
+                if (
+                    bj != b
+                    and label.get(bj) == 1
+                    and ((bj not in bestedgeto) or slack(i, j) < slack(*bestedgeto[bj]))
+                ):
+                    bestedgeto[bj] = k
+            # Forget about least-slack edge of the subblossom.
+            bestedge[bv] = None
+        b.mybestedges = list(bestedgeto.values())
+        # Select bestedge[b].
+        mybestedge = None
+        bestedge[b] = None
+        for k in b.mybestedges:
+            kslack = slack(*k)
+            if mybestedge is None or kslack < mybestslack:
+                mybestedge = k
+                mybestslack = kslack
+        bestedge[b] = mybestedge
+
+    # Expand the given top-level blossom.
+    def expandBlossom(b, endstage):
+        # Convert sub-blossoms into top-level blossoms.
+        for s in b.childs:
+            blossomparent[s] = None
+            if isinstance(s, Blossom):
+                if endstage and blossomdual[s] == 0:
+                    # Recursively expand this sub-blossom.
+                    expandBlossom(s, endstage)
+                else:
+                    for v in s.leaves():
+                        inblossom[v] = s
+            else:
+                inblossom[s] = s
+        # If we expand a T-blossom during a stage, its sub-blossoms must be
+        # relabeled.
+        if (not endstage) and label.get(b) == 2:
+            # Start at the sub-blossom through which the expanding
+            # blossom obtained its label, and relabel sub-blossoms untili
+            # we reach the base.
+            # Figure out through which sub-blossom the expanding blossom
+            # obtained its label initially.
+            entrychild = inblossom[labeledge[b][1]]
+            # Decide in which direction we will go round the blossom.
+            j = b.childs.index(entrychild)
+            if j & 1:
+                # Start index is odd; go forward and wrap.
+                j -= len(b.childs)
+                jstep = 1
+            else:
+                # Start index is even; go backward.
+                jstep = -1
+            # Move along the blossom until we get to the base.
+            v, w = labeledge[b]
+            while j != 0:
+                # Relabel the T-sub-blossom.
+                if jstep == 1:
+                    p, q = b.edges[j]
+                else:
+                    q, p = b.edges[j - 1]
+                label[w] = None
+                label[q] = None
+                assignLabel(w, 2, v)
+                # Step to the next S-sub-blossom and note its forward edge.
+                allowedge[(p, q)] = allowedge[(q, p)] = True
+                j += jstep
+                if jstep == 1:
+                    v, w = b.edges[j]
+                else:
+                    w, v = b.edges[j - 1]
+                # Step to the next T-sub-blossom.
+                allowedge[(v, w)] = allowedge[(w, v)] = True
+                j += jstep
+            # Relabel the base T-sub-blossom WITHOUT stepping through to
+            # its mate (so don't call assignLabel).
+            bw = b.childs[j]
+            label[w] = label[bw] = 2
+            labeledge[w] = labeledge[bw] = (v, w)
+            bestedge[bw] = None
+            # Continue along the blossom until we get back to entrychild.
+            j += jstep
+            while b.childs[j] != entrychild:
+                # Examine the vertices of the sub-blossom to see whether
+                # it is reachable from a neighbouring S-vertex outside the
+                # expanding blossom.
+                bv = b.childs[j]
+                if label.get(bv) == 1:
+                    # This sub-blossom just got label S through one of its
+                    # neighbours; leave it be.
+                    j += jstep
+                    continue
+                if isinstance(bv, Blossom):
+                    for v in bv.leaves():
+                        if label.get(v):
+                            break
+                else:
+                    v = bv
+                # If the sub-blossom contains a reachable vertex, assign
+                # label T to the sub-blossom.
+                if label.get(v):
+                    assert label[v] == 2
+                    assert inblossom[v] == bv
+                    label[v] = None
+                    label[mate[blossombase[bv]]] = None
+                    assignLabel(v, 2, labeledge[v][0])
+                j += jstep
+        # Remove the expanded blossom entirely.
+        label.pop(b, None)
+        labeledge.pop(b, None)
+        bestedge.pop(b, None)
+        del blossomparent[b]
+        del blossombase[b]
+        del blossomdual[b]
+
+    # Swap matched/unmatched edges over an alternating path through blossom b
+    # between vertex v and the base vertex. Keep blossom bookkeeping
+    # consistent.
+    def augmentBlossom(b, v):
+        # Bubble up through the blossom tree from vertex v to an immediate
+        # sub-blossom of b.
+        t = v
+        while blossomparent[t] != b:
+            t = blossomparent[t]
+        # Recursively deal with the first sub-blossom.
+        if isinstance(t, Blossom):
+            augmentBlossom(t, v)
+        # Decide in which direction we will go round the blossom.
+        i = j = b.childs.index(t)
+        if i & 1:
+            # Start index is odd; go forward and wrap.
+            j -= len(b.childs)
+            jstep = 1
+        else:
+            # Start index is even; go backward.
+            jstep = -1
+        # Move along the blossom until we get to the base.
+        while j != 0:
+            # Step to the next sub-blossom and augment it recursively.
+            j += jstep
+            t = b.childs[j]
+            if jstep == 1:
+                w, x = b.edges[j]
+            else:
+                x, w = b.edges[j - 1]
+            if isinstance(t, Blossom):
+                augmentBlossom(t, w)
+            # Step to the next sub-blossom and augment it recursively.
+            j += jstep
+            t = b.childs[j]
+            if isinstance(t, Blossom):
+                augmentBlossom(t, x)
+            # Match the edge connecting those sub-blossoms.
+            mate[w] = x
+            mate[x] = w
+        # Rotate the list of sub-blossoms to put the new base at the front.
+        b.childs = b.childs[i:] + b.childs[:i]
+        b.edges = b.edges[i:] + b.edges[:i]
+        blossombase[b] = blossombase[b.childs[0]]
+        assert blossombase[b] == v
+
+    # Swap matched/unmatched edges over an alternating path between two
+    # single vertices. The augmenting path runs through S-vertices v and w.
+    def augmentMatching(v, w):
+        for (s, j) in ((v, w), (w, v)):
+            # Match vertex s to vertex j. Then trace back from s
+            # until we find a single vertex, swapping matched and unmatched
+            # edges as we go.
+            while 1:
+                bs = inblossom[s]
+                assert label[bs] == 1
+                assert (labeledge[bs] is None and blossombase[bs] not in mate) or (
+                    labeledge[bs][0] == mate[blossombase[bs]]
+                )
+                # Augment through the S-blossom from s to base.
+                if isinstance(bs, Blossom):
+                    augmentBlossom(bs, s)
+                # Update mate[s]
+                mate[s] = j
+                # Trace one step back.
+                if labeledge[bs] is None:
+                    # Reached single vertex; stop.
+                    break
+                t = labeledge[bs][0]
+                bt = inblossom[t]
+                assert label[bt] == 2
+                # Trace one more step back.
+                s, j = labeledge[bt]
+                # Augment through the T-blossom from j to base.
+                assert blossombase[bt] == t
+                if isinstance(bt, Blossom):
+                    augmentBlossom(bt, j)
+                # Update mate[j]
+                mate[j] = s
+
+    # Verify that the optimum solution has been reached.
+    def verifyOptimum():
+        if maxcardinality:
+            # Vertices may have negative dual;
+            # find a constant non-negative number to add to all vertex duals.
+            vdualoffset = max(0, -min(dualvar.values()))
+        else:
+            vdualoffset = 0
+        # 0. all dual variables are non-negative
+        assert min(dualvar.values()) + vdualoffset >= 0
+        assert len(blossomdual) == 0 or min(blossomdual.values()) >= 0
+        # 0. all edges have non-negative slack and
+        # 1. all matched edges have zero slack;
+        for i, j, d in G.edges(data=True):
+            wt = d.get(weight, 1)
+            if i == j:
+                continue  # ignore self-loops
+            s = dualvar[i] + dualvar[j] - 2 * wt
+            iblossoms = [i]
+            jblossoms = [j]
+            while blossomparent[iblossoms[-1]] is not None:
+                iblossoms.append(blossomparent[iblossoms[-1]])
+            while blossomparent[jblossoms[-1]] is not None:
+                jblossoms.append(blossomparent[jblossoms[-1]])
+            iblossoms.reverse()
+            jblossoms.reverse()
+            for (bi, bj) in zip(iblossoms, jblossoms):
+                if bi != bj:
+                    break
+                s += 2 * blossomdual[bi]
+            assert s >= 0
+            if mate.get(i) == j or mate.get(j) == i:
+                assert mate[i] == j and mate[j] == i
+                assert s == 0
+        # 2. all single vertices have zero dual value;
+        for v in gnodes:
+            assert (v in mate) or dualvar[v] + vdualoffset == 0
+        # 3. all blossoms with positive dual value are full.
+        for b in blossomdual:
+            if blossomdual[b] > 0:
+                assert len(b.edges) % 2 == 1
+                for (i, j) in b.edges[1::2]:
+                    assert mate[i] == j and mate[j] == i
+        # Ok.
+
+    # Main loop: continue until no further improvement is possible.
+    while 1:
+
+        # Each iteration of this loop is a "stage".
+        # A stage finds an augmenting path and uses that to improve
+        # the matching.
+
+        # Remove labels from top-level blossoms/vertices.
+        label.clear()
+        labeledge.clear()
+
+        # Forget all about least-slack edges.
+        bestedge.clear()
+        for b in blossomdual:
+            b.mybestedges = None
+
+        # Loss of labeling means that we can not be sure that currently
+        # allowable edges remain allowable throughout this stage.
+        allowedge.clear()
+
+        # Make queue empty.
+        queue[:] = []
+
+        # Label single blossoms/vertices with S and put them in the queue.
+        for v in gnodes:
+            if (v not in mate) and label.get(inblossom[v]) is None:
+                assignLabel(v, 1, None)
+
+        # Loop until we succeed in augmenting the matching.
+        augmented = 0
+        while 1:
+
+            # Each iteration of this loop is a "substage".
+            # A substage tries to find an augmenting path;
+            # if found, the path is used to improve the matching and
+            # the stage ends. If there is no augmenting path, the
+            # primal-dual method is used to pump some slack out of
+            # the dual variables.
+
+            # Continue labeling until all vertices which are reachable
+            # through an alternating path have got a label.
+            while queue and not augmented:
+
+                # Take an S vertex from the queue.
+                v = queue.pop()
+                assert label[inblossom[v]] == 1
+
+                # Scan its neighbours:
+                for w in G.neighbors(v):
+                    if w == v:
+                        continue  # ignore self-loops
+                    # w is a neighbour to v
+                    bv = inblossom[v]
+                    bw = inblossom[w]
+                    if bv == bw:
+                        # this edge is internal to a blossom; ignore it
+                        continue
+                    if (v, w) not in allowedge:
+                        kslack = slack(v, w)
+                        if kslack <= 0:
+                            # edge k has zero slack => it is allowable
+                            allowedge[(v, w)] = allowedge[(w, v)] = True
+                    if (v, w) in allowedge:
+                        if label.get(bw) is None:
+                            # (C1) w is a free vertex;
+                            # label w with T and label its mate with S (R12).
+                            assignLabel(w, 2, v)
+                        elif label.get(bw) == 1:
+                            # (C2) w is an S-vertex (not in the same blossom);
+                            # follow back-links to discover either an
+                            # augmenting path or a new blossom.
+                            base = scanBlossom(v, w)
+                            if base is not NoNode:
+                                # Found a new blossom; add it to the blossom
+                                # bookkeeping and turn it into an S-blossom.
+                                addBlossom(base, v, w)
+                            else:
+                                # Found an augmenting path; augment the
+                                # matching and end this stage.
+                                augmentMatching(v, w)
+                                augmented = 1
+                                break
+                        elif label.get(w) is None:
+                            # w is inside a T-blossom, but w itself has not
+                            # yet been reached from outside the blossom;
+                            # mark it as reached (we need this to relabel
+                            # during T-blossom expansion).
+                            assert label[bw] == 2
+                            label[w] = 2
+                            labeledge[w] = (v, w)
+                    elif label.get(bw) == 1:
+                        # keep track of the least-slack non-allowable edge to
+                        # a different S-blossom.
+                        if bestedge.get(bv) is None or kslack < slack(*bestedge[bv]):
+                            bestedge[bv] = (v, w)
+                    elif label.get(w) is None:
+                        # w is a free vertex (or an unreached vertex inside
+                        # a T-blossom) but we can not reach it yet;
+                        # keep track of the least-slack edge that reaches w.
+                        if bestedge.get(w) is None or kslack < slack(*bestedge[w]):
+                            bestedge[w] = (v, w)
+
+            if augmented:
+                break
+
+            # There is no augmenting path under these constraints;
+            # compute delta and reduce slack in the optimization problem.
+            # (Note that our vertex dual variables, edge slacks and delta's
+            # are pre-multiplied by two.)
+            deltatype = -1
+            delta = deltaedge = deltablossom = None
+
+            # Compute delta1: the minimum value of any vertex dual.
+            if not maxcardinality:
+                deltatype = 1
+                delta = min(dualvar.values())
+
+            # Compute delta2: the minimum slack on any edge between
+            # an S-vertex and a free vertex.
+            for v in G.nodes():
+                if label.get(inblossom[v]) is None and bestedge.get(v) is not None:
+                    d = slack(*bestedge[v])
+                    if deltatype == -1 or d < delta:
+                        delta = d
+                        deltatype = 2
+                        deltaedge = bestedge[v]
+
+            # Compute delta3: half the minimum slack on any edge between
+            # a pair of S-blossoms.
+            for b in blossomparent:
+                if (
+                    blossomparent[b] is None
+                    and label.get(b) == 1
+                    and bestedge.get(b) is not None
+                ):
+                    kslack = slack(*bestedge[b])
+                    if allinteger:
+                        assert (kslack % 2) == 0
+                        d = kslack // 2
+                    else:
+                        d = kslack / 2.0
+                    if deltatype == -1 or d < delta:
+                        delta = d
+                        deltatype = 3
+                        deltaedge = bestedge[b]
+
+            # Compute delta4: minimum z variable of any T-blossom.
+            for b in blossomdual:
+                if (
+                    blossomparent[b] is None
+                    and label.get(b) == 2
+                    and (deltatype == -1 or blossomdual[b] < delta)
+                ):
+                    delta = blossomdual[b]
+                    deltatype = 4
+                    deltablossom = b
+
+            if deltatype == -1:
+                # No further improvement possible; max-cardinality optimum
+                # reached. Do a final delta update to make the optimum
+                # verifyable.
+                assert maxcardinality
+                deltatype = 1
+                delta = max(0, min(dualvar.values()))
+
+            # Update dual variables according to delta.
+            for v in gnodes:
+                if label.get(inblossom[v]) == 1:
+                    # S-vertex: 2*u = 2*u - 2*delta
+                    dualvar[v] -= delta
+                elif label.get(inblossom[v]) == 2:
+                    # T-vertex: 2*u = 2*u + 2*delta
+                    dualvar[v] += delta
+            for b in blossomdual:
+                if blossomparent[b] is None:
+                    if label.get(b) == 1:
+                        # top-level S-blossom: z = z + 2*delta
+                        blossomdual[b] += delta
+                    elif label.get(b) == 2:
+                        # top-level T-blossom: z = z - 2*delta
+                        blossomdual[b] -= delta
+
+            # Take action at the point where minimum delta occurred.
+            if deltatype == 1:
+                # No further improvement possible; optimum reached.
+                break
+            elif deltatype == 2:
+                # Use the least-slack edge to continue the search.
+                (v, w) = deltaedge
+                assert label[inblossom[v]] == 1
+                allowedge[(v, w)] = allowedge[(w, v)] = True
+                queue.append(v)
+            elif deltatype == 3:
+                # Use the least-slack edge to continue the search.
+                (v, w) = deltaedge
+                allowedge[(v, w)] = allowedge[(w, v)] = True
+                assert label[inblossom[v]] == 1
+                queue.append(v)
+            elif deltatype == 4:
+                # Expand the least-z blossom.
+                expandBlossom(deltablossom, False)
+
+            # End of a this substage.
+
+        # Paranoia check that the matching is symmetric.
+        for v in mate:
+            assert mate[mate[v]] == v
+
+        # Stop when no more augmenting path can be found.
+        if not augmented:
+            break
+
+        # End of a stage; expand all S-blossoms which have zero dual.
+        for b in list(blossomdual.keys()):
+            if b not in blossomdual:
+                continue  # already expanded
+            if blossomparent[b] is None and label.get(b) == 1 and blossomdual[b] == 0:
+                expandBlossom(b, True)
+
+    # Verify that we reached the optimum solution (only for integer weights).
+    if allinteger:
+        verifyOptimum()
+
+    return matching_dict_to_set(mate)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/minors/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/minors/__init__.py
new file mode 100644
index 0000000..cf15ddb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/minors/__init__.py
@@ -0,0 +1,27 @@
+"""
+Subpackages related to graph-minor problems.
+
+In graph theory, an undirected graph H is called a minor of the graph G if H
+can be formed from G by deleting edges and vertices and by contracting edges
+[1]_.
+
+References
+----------
+.. [1] https://en.wikipedia.org/wiki/Graph_minor
+"""
+
+from networkx.algorithms.minors.contraction import (
+    contracted_edge,
+    contracted_nodes,
+    equivalence_classes,
+    identified_nodes,
+    quotient_graph,
+)
+
+__all__ = [
+    "contracted_edge",
+    "contracted_nodes",
+    "equivalence_classes",
+    "identified_nodes",
+    "quotient_graph",
+]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/minors/contraction.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/minors/contraction.py
new file mode 100644
index 0000000..72a0d70
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/minors/contraction.py
@@ -0,0 +1,600 @@
+"""Provides functions for computing minors of a graph."""
+from itertools import chain, combinations, permutations, product
+
+import networkx as nx
+from networkx import density
+from networkx.exception import NetworkXException
+from networkx.utils import arbitrary_element
+
+__all__ = [
+    "contracted_edge",
+    "contracted_nodes",
+    "equivalence_classes",
+    "identified_nodes",
+    "quotient_graph",
+]
+
+chaini = chain.from_iterable
+
+
+def equivalence_classes(iterable, relation):
+    """Returns equivalence classes of `relation` when applied to `iterable`.
+
+    The equivalence classes, or blocks, consist of objects from `iterable`
+    which are all equivalent. They are defined to be equivalent if the
+    `relation` function returns `True` when passed any two objects from that
+    class, and `False` otherwise. To define an equivalence relation the
+    function must be reflexive, symmetric and transitive.
+
+    Parameters
+    ----------
+    iterable : list, tuple, or set
+        An iterable of elements/nodes.
+
+    relation : function
+        A Boolean-valued function that implements an equivalence relation
+        (reflexive, symmetric, transitive binary relation) on the elements
+        of `iterable` - it must take two elements and return `True` if
+        they are related, or `False` if not.
+
+    Returns
+    -------
+    set of frozensets
+        A set of frozensets representing the partition induced by the equivalence
+        relation function `relation` on the elements of `iterable`. Each
+        member set in the return set represents an equivalence class, or
+        block, of the partition.
+
+        Duplicate elements will be ignored so it makes the most sense for
+        `iterable` to be a :class:`set`.
+
+    Notes
+    -----
+    This function does not check that `relation` represents an equivalence
+    relation. You can check that your equivalence classes provide a partition
+    using `is_partition`.
+
+    Examples
+    --------
+    Let `X` be the set of integers from `0` to `9`, and consider an equivalence
+    relation `R` on `X` of congruence modulo `3`: this means that two integers
+    `x` and `y` in `X` are equivalent under `R` if they leave the same
+    remainder when divided by `3`, i.e. `(x - y) mod 3 = 0`.
+
+    The equivalence classes of this relation are `{0, 3, 6, 9}`, `{1, 4, 7}`,
+    `{2, 5, 8}`: `0`, `3`, `6`, `9` are all divisible by `3` and leave zero
+    remainder; `1`, `4`, `7` leave remainder `1`; while `2`, `5` and `8` leave
+    remainder `2`. We can see this by calling `equivalence_classes` with
+    `X` and a function implementation of `R`.
+
+    >>> X = set(range(10))
+    >>> def mod3(x, y): return (x - y) % 3 == 0
+    >>> equivalence_classes(X, mod3)    # doctest: +SKIP
+    {frozenset({1, 4, 7}), frozenset({8, 2, 5}), frozenset({0, 9, 3, 6})}
+    """
+    # For simplicity of implementation, we initialize the return value as a
+    # list of lists, then convert it to a set of sets at the end of the
+    # function.
+    blocks = []
+    # Determine the equivalence class for each element of the iterable.
+    for y in iterable:
+        # Each element y must be in *exactly one* equivalence class.
+        #
+        # Each block is guaranteed to be non-empty
+        for block in blocks:
+            x = arbitrary_element(block)
+            if relation(x, y):
+                block.append(y)
+                break
+        else:
+            # If the element y is not part of any known equivalence class, it
+            # must be in its own, so we create a new singleton equivalence
+            # class for it.
+            blocks.append([y])
+    return {frozenset(block) for block in blocks}
+
+
+def quotient_graph(
+    G,
+    partition,
+    edge_relation=None,
+    node_data=None,
+    edge_data=None,
+    relabel=False,
+    create_using=None,
+):
+    """Returns the quotient graph of `G` under the specified equivalence
+    relation on nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The graph for which to return the quotient graph with the
+        specified node relation.
+
+    partition : function, or dict or list of lists, tuples or sets
+        If a function, this function must represent an equivalence
+        relation on the nodes of `G`. It must take two arguments *u*
+        and *v* and return True exactly when *u* and *v* are in the
+        same equivalence class. The equivalence classes form the nodes
+        in the returned graph.
+
+        If a dict of lists/tuples/sets, the keys can be any meaningful
+        block labels, but the values must be the block lists/tuples/sets
+        (one list/tuple/set per block), and the blocks must form a valid
+        partition of the nodes of the graph. That is, each node must be
+        in exactly one block of the partition.
+
+        If a list of sets, the list must form a valid partition of
+        the nodes of the graph. That is, each node must be in exactly
+        one block of the partition.
+
+    edge_relation : Boolean function with two arguments
+        This function must represent an edge relation on the *blocks* of
+        the `partition` of `G`. It must take two arguments, *B* and *C*,
+        each one a set of nodes, and return True exactly when there should be
+        an edge joining block *B* to block *C* in the returned graph.
+
+        If `edge_relation` is not specified, it is assumed to be the
+        following relation. Block *B* is related to block *C* if and
+        only if some node in *B* is adjacent to some node in *C*,
+        according to the edge set of `G`.
+
+    edge_data : function
+        This function takes two arguments, *B* and *C*, each one a set
+        of nodes, and must return a dictionary representing the edge
+        data attributes to set on the edge joining *B* and *C*, should
+        there be an edge joining *B* and *C* in the quotient graph (if
+        no such edge occurs in the quotient graph as determined by
+        `edge_relation`, then the output of this function is ignored).
+
+        If the quotient graph would be a multigraph, this function is
+        not applied, since the edge data from each edge in the graph
+        `G` appears in the edges of the quotient graph.
+
+    node_data : function
+        This function takes one argument, *B*, a set of nodes in `G`,
+        and must return a dictionary representing the node data
+        attributes to set on the node representing *B* in the quotient graph.
+        If None, the following node attributes will be set:
+
+        * 'graph', the subgraph of the graph `G` that this block
+          represents,
+        * 'nnodes', the number of nodes in this block,
+        * 'nedges', the number of edges within this block,
+        * 'density', the density of the subgraph of `G` that this
+          block represents.
+
+    relabel : bool
+        If True, relabel the nodes of the quotient graph to be
+        nonnegative integers. Otherwise, the nodes are identified with
+        :class:`frozenset` instances representing the blocks given in
+        `partition`.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    NetworkX graph
+        The quotient graph of `G` under the equivalence relation
+        specified by `partition`. If the partition were given as a
+        list of :class:`set` instances and `relabel` is False,
+        each node will be a :class:`frozenset` corresponding to the same
+        :class:`set`.
+
+    Raises
+    ------
+    NetworkXException
+        If the given partition is not a valid partition of the nodes of
+        `G`.
+
+    Examples
+    --------
+    The quotient graph of the complete bipartite graph under the "same
+    neighbors" equivalence relation is `K_2`. Under this relation, two nodes
+    are equivalent if they are not adjacent but have the same neighbor set.
+
+    >>> G = nx.complete_bipartite_graph(2, 3)
+    >>> same_neighbors = lambda u, v: (
+    ...     u not in G[v] and v not in G[u] and G[u] == G[v]
+    ... )
+    >>> Q = nx.quotient_graph(G, same_neighbors)
+    >>> K2 = nx.complete_graph(2)
+    >>> nx.is_isomorphic(Q, K2)
+    True
+
+    The quotient graph of a directed graph under the "same strongly connected
+    component" equivalence relation is the condensation of the graph (see
+    :func:`condensation`). This example comes from the Wikipedia article
+    *`Strongly connected component`_*.
+
+    >>> G = nx.DiGraph()
+    >>> edges = [
+    ...     "ab",
+    ...     "be",
+    ...     "bf",
+    ...     "bc",
+    ...     "cg",
+    ...     "cd",
+    ...     "dc",
+    ...     "dh",
+    ...     "ea",
+    ...     "ef",
+    ...     "fg",
+    ...     "gf",
+    ...     "hd",
+    ...     "hf",
+    ... ]
+    >>> G.add_edges_from(tuple(x) for x in edges)
+    >>> components = list(nx.strongly_connected_components(G))
+    >>> sorted(sorted(component) for component in components)
+    [['a', 'b', 'e'], ['c', 'd', 'h'], ['f', 'g']]
+    >>>
+    >>> C = nx.condensation(G, components)
+    >>> component_of = C.graph["mapping"]
+    >>> same_component = lambda u, v: component_of[u] == component_of[v]
+    >>> Q = nx.quotient_graph(G, same_component)
+    >>> nx.is_isomorphic(C, Q)
+    True
+
+    Node identification can be represented as the quotient of a graph under the
+    equivalence relation that places the two nodes in one block and each other
+    node in its own singleton block.
+
+    >>> K24 = nx.complete_bipartite_graph(2, 4)
+    >>> K34 = nx.complete_bipartite_graph(3, 4)
+    >>> C = nx.contracted_nodes(K34, 1, 2)
+    >>> nodes = {1, 2}
+    >>> is_contracted = lambda u, v: u in nodes and v in nodes
+    >>> Q = nx.quotient_graph(K34, is_contracted)
+    >>> nx.is_isomorphic(Q, C)
+    True
+    >>> nx.is_isomorphic(Q, K24)
+    True
+
+    The blockmodeling technique described in [1]_ can be implemented as a
+    quotient graph.
+
+    >>> G = nx.path_graph(6)
+    >>> partition = [{0, 1}, {2, 3}, {4, 5}]
+    >>> M = nx.quotient_graph(G, partition, relabel=True)
+    >>> list(M.edges())
+    [(0, 1), (1, 2)]
+
+    Here is the sample example but using partition as a dict of block sets.
+
+    >>> G = nx.path_graph(6)
+    >>> partition = {0: {0, 1}, 2: {2, 3}, 4: {4, 5}}
+    >>> M = nx.quotient_graph(G, partition, relabel=True)
+    >>> list(M.edges())
+    [(0, 1), (1, 2)]
+
+    Partitions can be represented in various ways:
+    ::
+
+        (0) a list/tuple/set of block lists/tuples/sets
+        (1) a dict with block labels as keys and blocks lists/tuples/sets as values
+        (2) a dict with block lists/tuples/sets as keys and block labels as values
+        (3) a function from nodes in the original iterable to block labels
+        (4) an equivalence relation function on the target iterable
+
+    As `quotient_graph` is designed to accept partitions represented as (0), (1) or
+    (4) only, the `equivalence_classes` function can be used to get the partitions
+    in the right form, in order to call `quotient_graph`.
+
+    .. _Strongly connected component: https://en.wikipedia.org/wiki/Strongly_connected_component
+
+    References
+    ----------
+    .. [1] Patrick Doreian, Vladimir Batagelj, and Anuska Ferligoj.
+           *Generalized Blockmodeling*.
+           Cambridge University Press, 2004.
+
+    """
+    # If the user provided an equivalence relation as a function to compute
+    # the blocks of the partition on the nodes of G induced by the
+    # equivalence relation.
+    if callable(partition):
+        # equivalence_classes always return partition of whole G.
+        partition = equivalence_classes(G, partition)
+        if not nx.community.is_partition(G, partition):
+            raise nx.NetworkXException(
+                "Input `partition` is not an equivalence relation for nodes of G"
+            )
+        return _quotient_graph(
+            G, partition, edge_relation, node_data, edge_data, relabel, create_using
+        )
+
+    # If the partition is a dict, it is assumed to be one where the keys are
+    # user-defined block labels, and values are block lists, tuples or sets.
+    if isinstance(partition, dict):
+        partition = [block for block in partition.values()]
+
+    # If the user provided partition as a collection of sets. Then we
+    # need to check if partition covers all of G nodes. If the answer
+    # is 'No' then we need to prepare suitable subgraph view.
+    partition_nodes = set().union(*partition)
+    if len(partition_nodes) != len(G):
+        G = G.subgraph(partition_nodes)
+    # Each node in the graph/subgraph must be in exactly one block.
+    if not nx.community.is_partition(G, partition):
+        raise NetworkXException("each node must be in exactly one part of `partition`")
+    return _quotient_graph(
+        G, partition, edge_relation, node_data, edge_data, relabel, create_using
+    )
+
+
+def _quotient_graph(
+    G,
+    partition,
+    edge_relation=None,
+    node_data=None,
+    edge_data=None,
+    relabel=False,
+    create_using=None,
+):
+    """Construct the quotient graph assuming input has been checked"""
+    if create_using is None:
+        H = G.__class__()
+    else:
+        H = nx.empty_graph(0, create_using)
+    # By default set some basic information about the subgraph that each block
+    # represents on the nodes in the quotient graph.
+    if node_data is None:
+
+        def node_data(b):
+            S = G.subgraph(b)
+            return dict(
+                graph=S, nnodes=len(S), nedges=S.number_of_edges(), density=density(S)
+            )
+
+    # Each block of the partition becomes a node in the quotient graph.
+    partition = [frozenset(b) for b in partition]
+    H.add_nodes_from((b, node_data(b)) for b in partition)
+    # By default, the edge relation is the relation defined as follows. B is
+    # adjacent to C if a node in B is adjacent to a node in C, according to the
+    # edge set of G.
+    #
+    # This is not a particularly efficient implementation of this relation:
+    # there are O(n^2) pairs to check and each check may require O(log n) time
+    # (to check set membership). This can certainly be parallelized.
+    if edge_relation is None:
+
+        def edge_relation(b, c):
+            return any(v in G[u] for u, v in product(b, c))
+
+    # By default, sum the weights of the edges joining pairs of nodes across
+    # blocks to get the weight of the edge joining those two blocks.
+    if edge_data is None:
+
+        def edge_data(b, c):
+            edgedata = (
+                d
+                for u, v, d in G.edges(b | c, data=True)
+                if (u in b and v in c) or (u in c and v in b)
+            )
+            return {"weight": sum(d.get("weight", 1) for d in edgedata)}
+
+    block_pairs = permutations(H, 2) if H.is_directed() else combinations(H, 2)
+    # In a multigraph, add one edge in the quotient graph for each edge
+    # in the original graph.
+    if H.is_multigraph():
+        edges = chaini(
+            (
+                (b, c, G.get_edge_data(u, v, default={}))
+                for u, v in product(b, c)
+                if v in G[u]
+            )
+            for b, c in block_pairs
+            if edge_relation(b, c)
+        )
+    # In a simple graph, apply the edge data function to each pair of
+    # blocks to determine the edge data attributes to apply to each edge
+    # in the quotient graph.
+    else:
+        edges = (
+            (b, c, edge_data(b, c)) for (b, c) in block_pairs if edge_relation(b, c)
+        )
+    H.add_edges_from(edges)
+    # If requested by the user, relabel the nodes to be integers,
+    # numbered in increasing order from zero in the same order as the
+    # iteration order of `partition`.
+    if relabel:
+        # Can't use nx.convert_node_labels_to_integers() here since we
+        # want the order of iteration to be the same for backward
+        # compatibility with the nx.blockmodel() function.
+        labels = {b: i for i, b in enumerate(partition)}
+        H = nx.relabel_nodes(H, labels)
+    return H
+
+
+def contracted_nodes(G, u, v, self_loops=True, copy=True):
+    """Returns the graph that results from contracting `u` and `v`.
+
+    Node contraction identifies the two nodes as a single node incident to any
+    edge that was incident to the original two nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The graph whose nodes will be contracted.
+
+    u, v : nodes
+        Must be nodes in `G`.
+
+    self_loops : Boolean
+        If this is True, any edges joining `u` and `v` in `G` become
+        self-loops on the new node in the returned graph.
+
+    copy : Boolean
+        If this is True (default True), make a copy of
+        `G` and return that instead of directly changing `G`.
+
+
+    Returns
+    -------
+    Networkx graph
+        If Copy is True,
+        A new graph object of the same type as `G` (leaving `G` unmodified)
+        with `u` and `v` identified in a single node. The right node `v`
+        will be merged into the node `u`, so only `u` will appear in the
+        returned graph.
+        If copy is False,
+        Modifies `G` with `u` and `v` identified in a single node.
+        The right node `v` will be merged into the node `u`, so
+        only `u` will appear in the returned graph.
+
+    Notes
+    -----
+    For multigraphs, the edge keys for the realigned edges may
+    not be the same as the edge keys for the old edges. This is
+    natural because edge keys are unique only within each pair of nodes.
+
+    For non-multigraphs where `u` and `v` are adjacent to a third node
+    `w`, the edge (`v`, `w`) will be contracted into the edge (`u`,
+    `w`) with its attributes stored into a "contraction" attribute.
+
+    This function is also available as `identified_nodes`.
+
+    Examples
+    --------
+    Contracting two nonadjacent nodes of the cycle graph on four nodes `C_4`
+    yields the path graph (ignoring parallel edges):
+
+    >>> G = nx.cycle_graph(4)
+    >>> M = nx.contracted_nodes(G, 1, 3)
+    >>> P3 = nx.path_graph(3)
+    >>> nx.is_isomorphic(M, P3)
+    True
+
+    >>> G = nx.MultiGraph(P3)
+    >>> M = nx.contracted_nodes(G, 0, 2)
+    >>> M.edges
+    MultiEdgeView([(0, 1, 0), (0, 1, 1)])
+
+    >>> G = nx.Graph([(1, 2), (2, 2)])
+    >>> H = nx.contracted_nodes(G, 1, 2, self_loops=False)
+    >>> list(H.nodes())
+    [1]
+    >>> list(H.edges())
+    [(1, 1)]
+
+    See Also
+    --------
+    contracted_edge
+    quotient_graph
+
+    """
+    # Copying has significant overhead and can be disabled if needed
+    if copy:
+        H = G.copy()
+    else:
+        H = G
+
+    # edge code uses G.edges(v) instead of G.adj[v] to handle multiedges
+    if H.is_directed():
+        edges_to_remap = chain(G.in_edges(v, data=True), G.out_edges(v, data=True))
+    else:
+        edges_to_remap = G.edges(v, data=True)
+
+    # If the H=G, the generators change as H changes
+    # This makes the edges_to_remap independent of H
+    if not copy:
+        edges_to_remap = list(edges_to_remap)
+
+    v_data = H.nodes[v]
+    H.remove_node(v)
+
+    for (prev_w, prev_x, d) in edges_to_remap:
+        w = prev_w if prev_w != v else u
+        x = prev_x if prev_x != v else u
+
+        if ({prev_w, prev_x} == {u, v}) and not self_loops:
+            continue
+
+        if not H.has_edge(w, x) or G.is_multigraph():
+            H.add_edge(w, x, **d)
+        else:
+            if "contraction" in H.edges[(w, x)]:
+                H.edges[(w, x)]["contraction"][(prev_w, prev_x)] = d
+            else:
+                H.edges[(w, x)]["contraction"] = {(prev_w, prev_x): d}
+
+    if "contraction" in H.nodes[u]:
+        H.nodes[u]["contraction"][v] = v_data
+    else:
+        H.nodes[u]["contraction"] = {v: v_data}
+    return H
+
+
+identified_nodes = contracted_nodes
+
+
+def contracted_edge(G, edge, self_loops=True, copy=True):
+    """Returns the graph that results from contracting the specified edge.
+
+    Edge contraction identifies the two endpoints of the edge as a single node
+    incident to any edge that was incident to the original two nodes. A graph
+    that results from edge contraction is called a *minor* of the original
+    graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       The graph whose edge will be contracted.
+
+    edge : tuple
+       Must be a pair of nodes in `G`.
+
+    self_loops : Boolean
+       If this is True, any edges (including `edge`) joining the
+       endpoints of `edge` in `G` become self-loops on the new node in the
+       returned graph.
+
+    copy : Boolean (default True)
+        If this is True, a the contraction will be performed on a copy of `G`,
+        otherwise the contraction will happen in place.
+
+    Returns
+    -------
+    Networkx graph
+       A new graph object of the same type as `G` (leaving `G` unmodified)
+       with endpoints of `edge` identified in a single node. The right node
+       of `edge` will be merged into the left one, so only the left one will
+       appear in the returned graph.
+
+    Raises
+    ------
+    ValueError
+       If `edge` is not an edge in `G`.
+
+    Examples
+    --------
+    Attempting to contract two nonadjacent nodes yields an error:
+
+    >>> G = nx.cycle_graph(4)
+    >>> nx.contracted_edge(G, (1, 3))
+    Traceback (most recent call last):
+      ...
+    ValueError: Edge (1, 3) does not exist in graph G; cannot contract it
+
+    Contracting two adjacent nodes in the cycle graph on *n* nodes yields the
+    cycle graph on *n - 1* nodes:
+
+    >>> C5 = nx.cycle_graph(5)
+    >>> C4 = nx.cycle_graph(4)
+    >>> M = nx.contracted_edge(C5, (0, 1), self_loops=False)
+    >>> nx.is_isomorphic(M, C4)
+    True
+
+    See also
+    --------
+    contracted_nodes
+    quotient_graph
+
+    """
+    u, v = edge[:2]
+    if not G.has_edge(u, v):
+        raise ValueError(f"Edge {edge} does not exist in graph G; cannot contract it")
+    return contracted_nodes(G, u, v, self_loops=self_loops, copy=copy)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/minors/tests/test_contraction.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/minors/tests/test_contraction.py
new file mode 100644
index 0000000..1dc4978
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/minors/tests/test_contraction.py
@@ -0,0 +1,422 @@
+"""Unit tests for the :mod:`networkx.algorithms.minors.contraction` module."""
+import pytest
+
+import networkx as nx
+from networkx.utils import arbitrary_element, edges_equal, nodes_equal
+
+
+class TestQuotient:
+    """Unit tests for computing quotient graphs."""
+
+    def test_quotient_graph_complete_multipartite(self):
+        """Tests that the quotient graph of the complete *n*-partite graph
+        under the "same neighbors" node relation is the complete graph on *n*
+        nodes.
+
+        """
+        G = nx.complete_multipartite_graph(2, 3, 4)
+        # Two nodes are equivalent if they are not adjacent but have the same
+        # neighbor set.
+
+        def same_neighbors(u, v):
+            return u not in G[v] and v not in G[u] and G[u] == G[v]
+
+        expected = nx.complete_graph(3)
+        actual = nx.quotient_graph(G, same_neighbors)
+        # It won't take too long to run a graph isomorphism algorithm on such
+        # small graphs.
+        assert nx.is_isomorphic(expected, actual)
+
+    def test_quotient_graph_complete_bipartite(self):
+        """Tests that the quotient graph of the complete bipartite graph under
+        the "same neighbors" node relation is `K_2`.
+
+        """
+        G = nx.complete_bipartite_graph(2, 3)
+        # Two nodes are equivalent if they are not adjacent but have the same
+        # neighbor set.
+
+        def same_neighbors(u, v):
+            return u not in G[v] and v not in G[u] and G[u] == G[v]
+
+        expected = nx.complete_graph(2)
+        actual = nx.quotient_graph(G, same_neighbors)
+        # It won't take too long to run a graph isomorphism algorithm on such
+        # small graphs.
+        assert nx.is_isomorphic(expected, actual)
+
+    def test_quotient_graph_edge_relation(self):
+        """Tests for specifying an alternate edge relation for the quotient
+        graph.
+
+        """
+        G = nx.path_graph(5)
+
+        def identity(u, v):
+            return u == v
+
+        def same_parity(b, c):
+            return arbitrary_element(b) % 2 == arbitrary_element(c) % 2
+
+        actual = nx.quotient_graph(G, identity, same_parity)
+        expected = nx.Graph()
+        expected.add_edges_from([(0, 2), (0, 4), (2, 4)])
+        expected.add_edge(1, 3)
+        assert nx.is_isomorphic(actual, expected)
+
+    def test_condensation_as_quotient(self):
+        """This tests that the condensation of a graph can be viewed as the
+        quotient graph under the "in the same connected component" equivalence
+        relation.
+
+        """
+        # This example graph comes from the file `test_strongly_connected.py`.
+        G = nx.DiGraph()
+        G.add_edges_from(
+            [
+                (1, 2),
+                (2, 3),
+                (2, 11),
+                (2, 12),
+                (3, 4),
+                (4, 3),
+                (4, 5),
+                (5, 6),
+                (6, 5),
+                (6, 7),
+                (7, 8),
+                (7, 9),
+                (7, 10),
+                (8, 9),
+                (9, 7),
+                (10, 6),
+                (11, 2),
+                (11, 4),
+                (11, 6),
+                (12, 6),
+                (12, 11),
+            ]
+        )
+        scc = list(nx.strongly_connected_components(G))
+        C = nx.condensation(G, scc)
+        component_of = C.graph["mapping"]
+        # Two nodes are equivalent if they are in the same connected component.
+
+        def same_component(u, v):
+            return component_of[u] == component_of[v]
+
+        Q = nx.quotient_graph(G, same_component)
+        assert nx.is_isomorphic(C, Q)
+
+    def test_path(self):
+        G = nx.path_graph(6)
+        partition = [{0, 1}, {2, 3}, {4, 5}]
+        M = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(M, [0, 1, 2])
+        assert edges_equal(M.edges(), [(0, 1), (1, 2)])
+        for n in M:
+            assert M.nodes[n]["nedges"] == 1
+            assert M.nodes[n]["nnodes"] == 2
+            assert M.nodes[n]["density"] == 1
+
+    def test_path__partition_provided_as_dict_of_lists(self):
+        G = nx.path_graph(6)
+        partition = {0: [0, 1], 2: [2, 3], 4: [4, 5]}
+        M = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(M, [0, 1, 2])
+        assert edges_equal(M.edges(), [(0, 1), (1, 2)])
+        for n in M:
+            assert M.nodes[n]["nedges"] == 1
+            assert M.nodes[n]["nnodes"] == 2
+            assert M.nodes[n]["density"] == 1
+
+    def test_path__partition_provided_as_dict_of_tuples(self):
+        G = nx.path_graph(6)
+        partition = {0: (0, 1), 2: (2, 3), 4: (4, 5)}
+        M = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(M, [0, 1, 2])
+        assert edges_equal(M.edges(), [(0, 1), (1, 2)])
+        for n in M:
+            assert M.nodes[n]["nedges"] == 1
+            assert M.nodes[n]["nnodes"] == 2
+            assert M.nodes[n]["density"] == 1
+
+    def test_path__partition_provided_as_dict_of_sets(self):
+        G = nx.path_graph(6)
+        partition = {0: {0, 1}, 2: {2, 3}, 4: {4, 5}}
+        M = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(M, [0, 1, 2])
+        assert edges_equal(M.edges(), [(0, 1), (1, 2)])
+        for n in M:
+            assert M.nodes[n]["nedges"] == 1
+            assert M.nodes[n]["nnodes"] == 2
+            assert M.nodes[n]["density"] == 1
+
+    def test_multigraph_path(self):
+        G = nx.MultiGraph(nx.path_graph(6))
+        partition = [{0, 1}, {2, 3}, {4, 5}]
+        M = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(M, [0, 1, 2])
+        assert edges_equal(M.edges(), [(0, 1), (1, 2)])
+        for n in M:
+            assert M.nodes[n]["nedges"] == 1
+            assert M.nodes[n]["nnodes"] == 2
+            assert M.nodes[n]["density"] == 1
+
+    def test_directed_path(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(6))
+        partition = [{0, 1}, {2, 3}, {4, 5}]
+        M = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(M, [0, 1, 2])
+        assert edges_equal(M.edges(), [(0, 1), (1, 2)])
+        for n in M:
+            assert M.nodes[n]["nedges"] == 1
+            assert M.nodes[n]["nnodes"] == 2
+            assert M.nodes[n]["density"] == 0.5
+
+    def test_directed_multigraph_path(self):
+        G = nx.MultiDiGraph()
+        nx.add_path(G, range(6))
+        partition = [{0, 1}, {2, 3}, {4, 5}]
+        M = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(M, [0, 1, 2])
+        assert edges_equal(M.edges(), [(0, 1), (1, 2)])
+        for n in M:
+            assert M.nodes[n]["nedges"] == 1
+            assert M.nodes[n]["nnodes"] == 2
+            assert M.nodes[n]["density"] == 0.5
+
+    def test_overlapping_blocks(self):
+        with pytest.raises(nx.NetworkXException):
+            G = nx.path_graph(6)
+            partition = [{0, 1, 2}, {2, 3}, {4, 5}]
+            nx.quotient_graph(G, partition)
+
+    def test_weighted_path(self):
+        G = nx.path_graph(6)
+        for i in range(5):
+            G[i][i + 1]["weight"] = i + 1
+        partition = [{0, 1}, {2, 3}, {4, 5}]
+        M = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(M, [0, 1, 2])
+        assert edges_equal(M.edges(), [(0, 1), (1, 2)])
+        assert M[0][1]["weight"] == 2
+        assert M[1][2]["weight"] == 4
+        for n in M:
+            assert M.nodes[n]["nedges"] == 1
+            assert M.nodes[n]["nnodes"] == 2
+            assert M.nodes[n]["density"] == 1
+
+    def test_barbell(self):
+        G = nx.barbell_graph(3, 0)
+        partition = [{0, 1, 2}, {3, 4, 5}]
+        M = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(M, [0, 1])
+        assert edges_equal(M.edges(), [(0, 1)])
+        for n in M:
+            assert M.nodes[n]["nedges"] == 3
+            assert M.nodes[n]["nnodes"] == 3
+            assert M.nodes[n]["density"] == 1
+
+    def test_barbell_plus(self):
+        G = nx.barbell_graph(3, 0)
+        # Add an extra edge joining the bells.
+        G.add_edge(0, 5)
+        partition = [{0, 1, 2}, {3, 4, 5}]
+        M = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(M, [0, 1])
+        assert edges_equal(M.edges(), [(0, 1)])
+        assert M[0][1]["weight"] == 2
+        for n in M:
+            assert M.nodes[n]["nedges"] == 3
+            assert M.nodes[n]["nnodes"] == 3
+            assert M.nodes[n]["density"] == 1
+
+    def test_blockmodel(self):
+        G = nx.path_graph(6)
+        partition = [[0, 1], [2, 3], [4, 5]]
+        M = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(M.nodes(), [0, 1, 2])
+        assert edges_equal(M.edges(), [(0, 1), (1, 2)])
+        for n in M.nodes():
+            assert M.nodes[n]["nedges"] == 1
+            assert M.nodes[n]["nnodes"] == 2
+            assert M.nodes[n]["density"] == 1.0
+
+    def test_multigraph_blockmodel(self):
+        G = nx.MultiGraph(nx.path_graph(6))
+        partition = [[0, 1], [2, 3], [4, 5]]
+        M = nx.quotient_graph(G, partition, create_using=nx.MultiGraph(), relabel=True)
+        assert nodes_equal(M.nodes(), [0, 1, 2])
+        assert edges_equal(M.edges(), [(0, 1), (1, 2)])
+        for n in M.nodes():
+            assert M.nodes[n]["nedges"] == 1
+            assert M.nodes[n]["nnodes"] == 2
+            assert M.nodes[n]["density"] == 1.0
+
+    def test_quotient_graph_incomplete_partition(self):
+        G = nx.path_graph(6)
+        partition = []
+        H = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(H.nodes(), [])
+        assert edges_equal(H.edges(), [])
+
+        partition = [[0, 1], [2, 3], [5]]
+        H = nx.quotient_graph(G, partition, relabel=True)
+        assert nodes_equal(H.nodes(), [0, 1, 2])
+        assert edges_equal(H.edges(), [(0, 1)])
+
+
+class TestContraction:
+    """Unit tests for node and edge contraction functions."""
+
+    def test_undirected_node_contraction(self):
+        """Tests for node contraction in an undirected graph."""
+        G = nx.cycle_graph(4)
+        actual = nx.contracted_nodes(G, 0, 1)
+        expected = nx.cycle_graph(3)
+        expected.add_edge(0, 0)
+        assert nx.is_isomorphic(actual, expected)
+
+    def test_directed_node_contraction(self):
+        """Tests for node contraction in a directed graph."""
+        G = nx.DiGraph(nx.cycle_graph(4))
+        actual = nx.contracted_nodes(G, 0, 1)
+        expected = nx.DiGraph(nx.cycle_graph(3))
+        expected.add_edge(0, 0)
+        expected.add_edge(0, 0)
+        assert nx.is_isomorphic(actual, expected)
+
+    def test_undirected_node_contraction_no_copy(self):
+        """Tests for node contraction in an undirected graph
+        by making changes in place."""
+        G = nx.cycle_graph(4)
+        actual = nx.contracted_nodes(G, 0, 1, copy=False)
+        expected = nx.cycle_graph(3)
+        expected.add_edge(0, 0)
+        assert nx.is_isomorphic(actual, G)
+        assert nx.is_isomorphic(actual, expected)
+
+    def test_directed_node_contraction_no_copy(self):
+        """Tests for node contraction in a directed graph
+        by making changes in place."""
+        G = nx.DiGraph(nx.cycle_graph(4))
+        actual = nx.contracted_nodes(G, 0, 1, copy=False)
+        expected = nx.DiGraph(nx.cycle_graph(3))
+        expected.add_edge(0, 0)
+        expected.add_edge(0, 0)
+        assert nx.is_isomorphic(actual, G)
+        assert nx.is_isomorphic(actual, expected)
+
+    def test_create_multigraph(self):
+        """Tests that using a MultiGraph creates multiple edges."""
+        G = nx.path_graph(3, create_using=nx.MultiGraph())
+        G.add_edge(0, 1)
+        G.add_edge(0, 0)
+        G.add_edge(0, 2)
+        actual = nx.contracted_nodes(G, 0, 2)
+        expected = nx.MultiGraph()
+        expected.add_edge(0, 1)
+        expected.add_edge(0, 1)
+        expected.add_edge(0, 1)
+        expected.add_edge(0, 0)
+        expected.add_edge(0, 0)
+        assert edges_equal(actual.edges, expected.edges)
+
+    def test_multigraph_keys(self):
+        """Tests that multiedge keys are reset in new graph."""
+        G = nx.path_graph(3, create_using=nx.MultiGraph())
+        G.add_edge(0, 1, 5)
+        G.add_edge(0, 0, 0)
+        G.add_edge(0, 2, 5)
+        actual = nx.contracted_nodes(G, 0, 2)
+        expected = nx.MultiGraph()
+        expected.add_edge(0, 1, 0)
+        expected.add_edge(0, 1, 5)
+        expected.add_edge(0, 1, 2)  # keyed as 2 b/c 2 edges already in G
+        expected.add_edge(0, 0, 0)
+        expected.add_edge(0, 0, 1)  # this comes from (0, 2, 5)
+        assert edges_equal(actual.edges, expected.edges)
+
+    def test_node_attributes(self):
+        """Tests that node contraction preserves node attributes."""
+        G = nx.cycle_graph(4)
+        # Add some data to the two nodes being contracted.
+        G.nodes[0]["foo"] = "bar"
+        G.nodes[1]["baz"] = "xyzzy"
+        actual = nx.contracted_nodes(G, 0, 1)
+        # We expect that contracting the nodes 0 and 1 in C_4 yields K_3, but
+        # with nodes labeled 0, 2, and 3, and with a self-loop on 0.
+        expected = nx.complete_graph(3)
+        expected = nx.relabel_nodes(expected, {1: 2, 2: 3})
+        expected.add_edge(0, 0)
+        cdict = {1: {"baz": "xyzzy"}}
+        expected.nodes[0].update(dict(foo="bar", contraction=cdict))
+        assert nx.is_isomorphic(actual, expected)
+        assert actual.nodes == expected.nodes
+
+    def test_edge_attributes(self):
+        """Tests that node contraction preserves edge attributes."""
+        # Shape: src1 --> dest <-- src2
+        G = nx.DiGraph([("src1", "dest"), ("src2", "dest")])
+        G["src1"]["dest"]["value"] = "src1-->dest"
+        G["src2"]["dest"]["value"] = "src2-->dest"
+        H = nx.MultiDiGraph(G)
+
+        G = nx.contracted_nodes(G, "src1", "src2")  # New Shape: src1 --> dest
+        assert G.edges[("src1", "dest")]["value"] == "src1-->dest"
+        assert (
+            G.edges[("src1", "dest")]["contraction"][("src2", "dest")]["value"]
+            == "src2-->dest"
+        )
+
+        H = nx.contracted_nodes(H, "src1", "src2")  # New Shape: src1 -(x2)-> dest
+        assert len(H.edges(("src1", "dest"))) == 2
+
+    def test_without_self_loops(self):
+        """Tests for node contraction without preserving self-loops."""
+        G = nx.cycle_graph(4)
+        actual = nx.contracted_nodes(G, 0, 1, self_loops=False)
+        expected = nx.complete_graph(3)
+        assert nx.is_isomorphic(actual, expected)
+
+    def test_contract_selfloop_graph(self):
+        """Tests for node contraction when nodes have selfloops."""
+        G = nx.cycle_graph(4)
+        G.add_edge(0, 0)
+        actual = nx.contracted_nodes(G, 0, 1)
+        expected = nx.complete_graph([0, 2, 3])
+        expected.add_edge(0, 0)
+        expected.add_edge(0, 0)
+        assert edges_equal(actual.edges, expected.edges)
+        actual = nx.contracted_nodes(G, 1, 0)
+        expected = nx.complete_graph([1, 2, 3])
+        expected.add_edge(1, 1)
+        expected.add_edge(1, 1)
+        assert edges_equal(actual.edges, expected.edges)
+
+    def test_undirected_edge_contraction(self):
+        """Tests for edge contraction in an undirected graph."""
+        G = nx.cycle_graph(4)
+        actual = nx.contracted_edge(G, (0, 1))
+        expected = nx.complete_graph(3)
+        expected.add_edge(0, 0)
+        assert nx.is_isomorphic(actual, expected)
+
+    def test_multigraph_edge_contraction(self):
+        """Tests for edge contraction in a multigraph"""
+        G = nx.cycle_graph(4)
+        actual = nx.contracted_edge(G, (0, 1, 0))
+        expected = nx.complete_graph(3)
+        expected.add_edge(0, 0)
+        assert nx.is_isomorphic(actual, expected)
+
+    def test_nonexistent_edge(self):
+        """Tests that attempting to contract a non-existent edge raises an
+        exception.
+
+        """
+        with pytest.raises(ValueError):
+            G = nx.cycle_graph(4)
+            nx.contracted_edge(G, (0, 2))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/mis.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/mis.py
new file mode 100644
index 0000000..540e9a0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/mis.py
@@ -0,0 +1,76 @@
+"""
+Algorithm to find a maximal (not maximum) independent set.
+
+"""
+import networkx as nx
+from networkx.utils import not_implemented_for, py_random_state
+
+__all__ = ["maximal_independent_set"]
+
+
+@py_random_state(2)
+@not_implemented_for("directed")
+def maximal_independent_set(G, nodes=None, seed=None):
+    """Returns a random maximal independent set guaranteed to contain
+    a given set of nodes.
+
+    An independent set is a set of nodes such that the subgraph
+    of G induced by these nodes contains no edges. A maximal
+    independent set is an independent set such that it is not possible
+    to add a new node and still get an independent set.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    nodes : list or iterable
+       Nodes that must be part of the independent set. This set of nodes
+       must be independent.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    indep_nodes : list
+       List of nodes that are part of a maximal independent set.
+
+    Raises
+    ------
+    NetworkXUnfeasible
+       If the nodes in the provided list are not part of the graph or
+       do not form an independent set, an exception is raised.
+
+    NetworkXNotImplemented
+        If `G` is directed.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> nx.maximal_independent_set(G)  # doctest: +SKIP
+    [4, 0, 2]
+    >>> nx.maximal_independent_set(G, [1])  # doctest: +SKIP
+    [1, 3]
+
+    Notes
+    -----
+    This algorithm does not solve the maximum independent set problem.
+
+    """
+    if not nodes:
+        nodes = {seed.choice(list(G))}
+    else:
+        nodes = set(nodes)
+    if not nodes.issubset(G):
+        raise nx.NetworkXUnfeasible(f"{nodes} is not a subset of the nodes of G")
+    neighbors = set.union(*[set(G.adj[v]) for v in nodes])
+    if set.intersection(neighbors, nodes):
+        raise nx.NetworkXUnfeasible(f"{nodes} is not an independent set of G")
+    indep_nodes = list(nodes)
+    available_nodes = set(G.nodes()).difference(neighbors.union(nodes))
+    while available_nodes:
+        node = seed.choice(list(available_nodes))
+        indep_nodes.append(node)
+        available_nodes.difference_update(list(G.adj[node]) + [node])
+    return indep_nodes
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/moral.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/moral.py
new file mode 100644
index 0000000..028160e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/moral.py
@@ -0,0 +1,57 @@
+r"""Function for computing the moral graph of a directed graph."""
+
+import itertools
+
+from networkx.utils import not_implemented_for
+
+__all__ = ["moral_graph"]
+
+
+@not_implemented_for("undirected")
+def moral_graph(G):
+    r"""Return the Moral Graph
+
+    Returns the moralized graph of a given directed graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Directed graph
+
+    Returns
+    -------
+    H : NetworkX graph
+        The undirected moralized graph of G
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is undirected.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph([(1, 2), (2, 3), (2, 5), (3, 4), (4, 3)])
+    >>> G_moral = nx.moral_graph(G)
+    >>> G_moral.edges()
+    EdgeView([(1, 2), (2, 3), (2, 5), (2, 4), (3, 4)])
+
+    Notes
+    -----
+    A moral graph is an undirected graph H = (V, E) generated from a
+    directed Graph, where if a node has more than one parent node, edges
+    between these parent nodes are inserted and all directed edges become
+    undirected.
+
+    https://en.wikipedia.org/wiki/Moral_graph
+
+    References
+    ----------
+    .. [1] Wray L. Buntine. 1995. Chain graphs for learning.
+           In Proceedings of the Eleventh conference on Uncertainty
+           in artificial intelligence (UAI'95)
+    """
+    H = G.to_undirected()
+    for preds in G.pred.values():
+        predecessors_combinations = itertools.combinations(preds, r=2)
+        H.add_edges_from(predecessors_combinations)
+    return H
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/__init__.py
new file mode 100644
index 0000000..23fa264
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/__init__.py
@@ -0,0 +1,52 @@
+""" This module provides the functions for node classification problem.
+
+The functions in this module are not imported
+into the top level `networkx` namespace.
+You can access these functions by importing
+the `networkx.algorithms.node_classification` modules,
+then accessing the functions as attributes of `node_classification`.
+For example:
+
+  >>> from networkx.algorithms import node_classification
+  >>> G = nx.path_graph(4)
+  >>> G.edges()
+  EdgeView([(0, 1), (1, 2), (2, 3)])
+  >>> G.nodes[0]["label"] = "A"
+  >>> G.nodes[3]["label"] = "B"
+  >>> node_classification.harmonic_function(G)
+  ['A', 'A', 'B', 'B']
+
+"""
+
+
+def __getattr__(name):
+    if name in ("hmn", "lgc"):
+        import warnings
+        import importlib
+
+        fn_name = (
+            "harmonic_function" if name == "hmn" else "local_and_global_consistency"
+        )
+        msg = (
+            f"The {name}  module is deprecated and will be removed in version 3.0.\n"
+            f"Access `{fn_name}` directly from `node_classification`:\n\n"
+            "    from networkx.algorithms import node_classification\n"
+            f"    node_classification.{fn_name}\n"
+        )
+        warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+        return importlib.import_module(
+            f".{name}", "networkx.algorithms.node_classification"
+        )
+    if name == "harmonic_function":
+        from .hmn import harmonic_function
+
+        return harmonic_function
+    if name == "local_and_global_consistency":
+        from .lgc import local_and_global_consistency
+
+        return local_and_global_consistency
+    raise AttributeError(f"module {__name__} has no attribute {name}")
+
+
+def __dir__():
+    return ["harmonic_function", "local_and_global_consistency"]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/hmn.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/hmn.py
new file mode 100644
index 0000000..727ee36
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/hmn.py
@@ -0,0 +1,88 @@
+"""Function for computing Harmonic function algorithm by Zhu et al.
+
+References
+----------
+Zhu, X., Ghahramani, Z., & Lafferty, J. (2003, August).
+Semi-supervised learning using gaussian fields and harmonic functions.
+In ICML (Vol. 3, pp. 912-919).
+"""
+import networkx as nx
+from networkx.algorithms.node_classification.utils import _get_label_info
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = ["harmonic_function"]
+
+
+@not_implemented_for("directed")
+def harmonic_function(G, max_iter=30, label_name="label"):
+    """Node classification by Harmonic function
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    max_iter : int
+        maximum number of iterations allowed
+    label_name : string
+        name of target labels to predict
+
+    Returns
+    -------
+    predicted : list
+        List of length ``len(G)`` with the predicted labels for each node.
+
+    Raises
+    ------
+    NetworkXError
+        If no nodes in `G` have attribute `label_name`.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import node_classification
+    >>> G = nx.path_graph(4)
+    >>> G.nodes[0]["label"] = "A"
+    >>> G.nodes[3]["label"] = "B"
+    >>> G.nodes(data=True)
+    NodeDataView({0: {'label': 'A'}, 1: {}, 2: {}, 3: {'label': 'B'}})
+    >>> G.edges()
+    EdgeView([(0, 1), (1, 2), (2, 3)])
+    >>> predicted = node_classification.harmonic_function(G)
+    >>> predicted
+    ['A', 'A', 'B', 'B']
+
+    References
+    ----------
+    Zhu, X., Ghahramani, Z., & Lafferty, J. (2003, August).
+    Semi-supervised learning using gaussian fields and harmonic functions.
+    In ICML (Vol. 3, pp. 912-919).
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    X = nx.to_scipy_sparse_array(G)  # adjacency matrix
+    labels, label_dict = _get_label_info(G, label_name)
+
+    if labels.shape[0] == 0:
+        raise nx.NetworkXError(
+            f"No node on the input graph is labeled by '{label_name}'."
+        )
+
+    n_samples = X.shape[0]
+    n_classes = label_dict.shape[0]
+    F = np.zeros((n_samples, n_classes))
+
+    # Build propagation matrix
+    degrees = X.sum(axis=0)
+    degrees[degrees == 0] = 1  # Avoid division by 0
+    # TODO: csr_array
+    D = sp.sparse.csr_array(sp.sparse.diags((1.0 / degrees), offsets=0))
+    P = (D @ X).tolil()
+    P[labels[:, 0]] = 0  # labels[:, 0] indicates IDs of labeled nodes
+    # Build base matrix
+    B = np.zeros((n_samples, n_classes))
+    B[labels[:, 0], labels[:, 1]] = 1
+
+    for _ in range(max_iter):
+        F = (P @ F) + B
+
+    return label_dict[np.argmax(F, axis=1)].tolist()
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/lgc.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/lgc.py
new file mode 100644
index 0000000..5324470
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/lgc.py
@@ -0,0 +1,89 @@
+"""Function for computing Local and global consistency algorithm by Zhou et al.
+
+References
+----------
+Zhou, D., Bousquet, O., Lal, T. N., Weston, J., & Schölkopf, B. (2004).
+Learning with local and global consistency.
+Advances in neural information processing systems, 16(16), 321-328.
+"""
+import networkx as nx
+from networkx.algorithms.node_classification.utils import _get_label_info
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = ["local_and_global_consistency"]
+
+
+@not_implemented_for("directed")
+def local_and_global_consistency(G, alpha=0.99, max_iter=30, label_name="label"):
+    """Node classification by Local and Global Consistency
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    alpha : float
+        Clamping factor
+    max_iter : int
+        Maximum number of iterations allowed
+    label_name : string
+        Name of target labels to predict
+
+    Returns
+    -------
+    predicted : list
+        List of length ``len(G)`` with the predicted labels for each node.
+
+    Raises
+    ------
+    NetworkXError
+        If no nodes in `G` have attribute `label_name`.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import node_classification
+    >>> G = nx.path_graph(4)
+    >>> G.nodes[0]["label"] = "A"
+    >>> G.nodes[3]["label"] = "B"
+    >>> G.nodes(data=True)
+    NodeDataView({0: {'label': 'A'}, 1: {}, 2: {}, 3: {'label': 'B'}})
+    >>> G.edges()
+    EdgeView([(0, 1), (1, 2), (2, 3)])
+    >>> predicted = node_classification.local_and_global_consistency(G)
+    >>> predicted
+    ['A', 'A', 'B', 'B']
+
+    References
+    ----------
+    Zhou, D., Bousquet, O., Lal, T. N., Weston, J., & Schölkopf, B. (2004).
+    Learning with local and global consistency.
+    Advances in neural information processing systems, 16(16), 321-328.
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    X = nx.to_scipy_sparse_array(G)  # adjacency matrix
+    labels, label_dict = _get_label_info(G, label_name)
+
+    if labels.shape[0] == 0:
+        raise nx.NetworkXError(
+            f"No node on the input graph is labeled by '{label_name}'."
+        )
+
+    n_samples = X.shape[0]
+    n_classes = label_dict.shape[0]
+    F = np.zeros((n_samples, n_classes))
+
+    # Build propagation matrix
+    degrees = X.sum(axis=0)
+    degrees[degrees == 0] = 1  # Avoid division by 0
+    # TODO: csr_array
+    D2 = np.sqrt(sp.sparse.csr_array(sp.sparse.diags((1.0 / degrees), offsets=0)))
+    P = alpha * ((D2 @ X) @ D2)
+    # Build base matrix
+    B = np.zeros((n_samples, n_classes))
+    B[labels[:, 0], labels[:, 1]] = 1 - alpha
+
+    for _ in range(max_iter):
+        F = (P @ F) + B
+
+    return label_dict[np.argmax(F, axis=1)].tolist()
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/utils.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/utils.py
new file mode 100644
index 0000000..f7d7ac2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/node_classification/utils.py
@@ -0,0 +1,34 @@
+def _get_label_info(G, label_name):
+    """Get and return information of labels from the input graph
+
+    Parameters
+    ----------
+    G : Network X graph
+    label_name : string
+        Name of the target label
+
+    Returns
+    ----------
+    labels : numpy array, shape = [n_labeled_samples, 2]
+        Array of pairs of labeled node ID and label ID
+    label_dict : numpy array, shape = [n_classes]
+        Array of labels
+        i-th element contains the label corresponding label ID `i`
+    """
+    import numpy as np
+
+    labels = []
+    label_to_id = {}
+    lid = 0
+    for i, n in enumerate(G.nodes(data=True)):
+        if label_name in n[1]:
+            label = n[1][label_name]
+            if label not in label_to_id:
+                label_to_id[label] = lid
+                lid += 1
+            labels.append([i, label_to_id[label]])
+    labels = np.array(labels)
+    label_dict = np.array(
+        [label for label, _ in sorted(label_to_id.items(), key=lambda x: x[1])]
+    )
+    return (labels, label_dict)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/non_randomness.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/non_randomness.py
new file mode 100644
index 0000000..e6953db
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/non_randomness.py
@@ -0,0 +1,95 @@
+r""" Computation of graph non-randomness
+"""
+
+import math
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["non_randomness"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def non_randomness(G, k=None, weight="weight"):
+    """Compute the non-randomness of graph G.
+
+    The first returned value nr is the sum of non-randomness values of all
+    edges within the graph (where the non-randomness of an edge tends to be
+    small when the two nodes linked by that edge are from two different
+    communities).
+
+    The second computed value nr_rd is a relative measure that indicates
+    to what extent graph G is different from random graphs in terms
+    of probability. When it is close to 0, the graph tends to be more
+    likely generated by an Erdos Renyi model.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Graph must be symmetric, connected, and without self-loops.
+
+    k : int
+        The number of communities in G.
+        If k is not set, the function will use a default community
+        detection algorithm to set it.
+
+    weight : string or None, optional (default=None)
+        The name of an edge attribute that holds the numerical value used
+        as a weight. If None, then each edge has weight 1, i.e., the graph is
+        binary.
+
+    Returns
+    -------
+    non-randomness : (float, float) tuple
+        Non-randomness, Relative non-randomness w.r.t.
+        Erdos Renyi random graphs.
+
+    Raises
+    ------
+    NetworkXException
+        if the input graph is not connected.
+    NetworkXError
+        if the input graph contains self-loops.
+
+    Examples
+    --------
+    >>> G = nx.karate_club_graph()
+    >>> nr, nr_rd = nx.non_randomness(G, 2)
+    >>> nr, nr_rd = nx.non_randomness(G, 2, 'weight')
+
+    Notes
+    -----
+    This computes Eq. (4.4) and (4.5) in Ref. [1]_.
+
+    If a weight field is passed, this algorithm will use the eigenvalues
+    of the weighted adjacency matrix to compute Eq. (4.4) and (4.5).
+
+    References
+    ----------
+    .. [1] Xiaowei Ying and Xintao Wu,
+           On Randomness Measures for Social Networks,
+           SIAM International Conference on Data Mining. 2009
+    """
+    import numpy as np
+
+    if not nx.is_connected(G):
+        raise nx.NetworkXException("Non connected graph.")
+    if len(list(nx.selfloop_edges(G))) > 0:
+        raise nx.NetworkXError("Graph must not contain self-loops")
+
+    if k is None:
+        k = len(tuple(nx.community.label_propagation_communities(G)))
+
+    # eq. 4.4
+    eigenvalues = np.linalg.eigvals(nx.to_numpy_array(G, weight=weight))
+    nr = np.real(np.sum(eigenvalues[:k]))
+
+    n = G.number_of_nodes()
+    m = G.number_of_edges()
+    p = (2 * k * m) / (n * (n - k))
+
+    # eq. 4.5
+    nr_rd = (nr - ((n - 2 * k) * p + k)) / math.sqrt(2 * k * p * (1 - p))
+
+    return nr, nr_rd
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/__init__.py
new file mode 100644
index 0000000..0ebc6ab
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/__init__.py
@@ -0,0 +1,4 @@
+from networkx.algorithms.operators.all import *
+from networkx.algorithms.operators.binary import *
+from networkx.algorithms.operators.product import *
+from networkx.algorithms.operators.unary import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/all.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/all.py
new file mode 100644
index 0000000..7d7c19c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/all.py
@@ -0,0 +1,253 @@
+"""Operations on many graphs.
+"""
+from itertools import zip_longest
+
+import networkx as nx
+
+__all__ = ["union_all", "compose_all", "disjoint_union_all", "intersection_all"]
+
+
+def union_all(graphs, rename=(None,)):
+    """Returns the union of all graphs.
+
+    The graphs must be disjoint, otherwise an exception is raised.
+
+    Parameters
+    ----------
+    graphs : list of graphs
+       List of NetworkX graphs
+
+    rename : bool , default=(None, None)
+       Node names of G and H can be changed by specifying the tuple
+       rename=('G-','H-') (for example).  Node "u" in G is then renamed
+       "G-u" and "v" in H is renamed "H-v".
+
+    Returns
+    -------
+    U : a graph with the same type as the first graph in list
+
+    Raises
+    ------
+    ValueError
+       If `graphs` is an empty list.
+
+    Notes
+    -----
+    To force a disjoint union with node relabeling, use
+    disjoint_union_all(G,H) or convert_node_labels_to integers().
+
+    Graph, edge, and node attributes are propagated to the union graph.
+    If a graph attribute is present in multiple graphs, then the value
+    from the last graph in the list with that attribute is used.
+
+    See Also
+    --------
+    union
+    disjoint_union_all
+    """
+    # collect the graphs in case an iterator was passed
+    graphs = list(graphs)
+
+    if not graphs:
+        raise ValueError("cannot apply union_all to an empty list")
+
+    U = graphs[0]
+
+    if any(G.is_multigraph() != U.is_multigraph() for G in graphs):
+        raise nx.NetworkXError("All graphs must be graphs or multigraphs.")
+
+    # rename graph to obtain disjoint node labels
+    def add_prefix(graph, prefix):
+        if prefix is None:
+            return graph
+
+        def label(x):
+            if isinstance(x, str):
+                name = prefix + x
+            else:
+                name = prefix + repr(x)
+            return name
+
+        return nx.relabel_nodes(graph, label)
+
+    graphs = [add_prefix(G, name) for G, name in zip_longest(graphs, rename)]
+
+    if sum(len(G) for G in graphs) != len(set().union(*graphs)):
+        raise nx.NetworkXError(
+            "The node sets of the graphs are not disjoint.",
+            "Use appropriate rename"
+            "=(G1prefix,G2prefix,...,GNprefix)"
+            "or use disjoint_union(G1,G2,...,GN).",
+        )
+
+    # Union is the same type as first graph
+    R = U.__class__()
+
+    # add graph attributes, later attributes take precedent over earlier ones
+    for G in graphs:
+        R.graph.update(G.graph)
+
+    # add nodes and attributes
+    for G in graphs:
+        R.add_nodes_from(G.nodes(data=True))
+
+    if U.is_multigraph():
+        for G in graphs:
+            R.add_edges_from(G.edges(keys=True, data=True))
+    else:
+        for G in graphs:
+            R.add_edges_from(G.edges(data=True))
+
+    return R
+
+
+def disjoint_union_all(graphs):
+    """Returns the disjoint union of all graphs.
+
+    This operation forces distinct integer node labels starting with 0
+    for the first graph in the list and numbering consecutively.
+
+    Parameters
+    ----------
+    graphs : list
+       List of NetworkX graphs
+
+    Returns
+    -------
+    U : A graph with the same type as the first graph in list
+
+    Raises
+    ------
+    ValueError
+       If `graphs` is an empty list.
+
+    Notes
+    -----
+    It is recommended that the graphs be either all directed or all undirected.
+
+    Graph, edge, and node attributes are propagated to the union graph.
+    If a graph attribute is present in multiple graphs, then the value
+    from the last graph in the list with that attribute is used.
+    """
+    graphs = list(graphs)
+
+    if not graphs:
+        raise ValueError("cannot apply disjoint_union_all to an empty list")
+
+    first_labels = [0]
+    for G in graphs[:-1]:
+        first_labels.append(len(G) + first_labels[-1])
+
+    relabeled = [
+        nx.convert_node_labels_to_integers(G, first_label=first_label)
+        for G, first_label in zip(graphs, first_labels)
+    ]
+    R = union_all(relabeled)
+    for G in graphs:
+        R.graph.update(G.graph)
+    return R
+
+
+def compose_all(graphs):
+    """Returns the composition of all graphs.
+
+    Composition is the simple union of the node sets and edge sets.
+    The node sets of the supplied graphs need not be disjoint.
+
+    Parameters
+    ----------
+    graphs : list
+       List of NetworkX graphs
+
+    Returns
+    -------
+    C : A graph with the same type as the first graph in list
+
+    Raises
+    ------
+    ValueError
+       If `graphs` is an empty list.
+
+    Notes
+    -----
+    It is recommended that the supplied graphs be either all directed or all
+    undirected.
+
+    Graph, edge, and node attributes are propagated to the union graph.
+    If a graph attribute is present in multiple graphs, then the value
+    from the last graph in the list with that attribute is used.
+    """
+    graphs = list(graphs)
+
+    if not graphs:
+        raise ValueError("cannot apply compose_all to an empty list")
+
+    U = graphs[0]
+
+    if any(G.is_multigraph() != U.is_multigraph() for G in graphs):
+        raise nx.NetworkXError("All graphs must be graphs or multigraphs.")
+
+    R = U.__class__()
+    # add graph attributes, H attributes take precedent over G attributes
+    for G in graphs:
+        R.graph.update(G.graph)
+
+    for G in graphs:
+        R.add_nodes_from(G.nodes(data=True))
+
+    if U.is_multigraph():
+        for G in graphs:
+            R.add_edges_from(G.edges(keys=True, data=True))
+    else:
+        for G in graphs:
+            R.add_edges_from(G.edges(data=True))
+    return R
+
+
+def intersection_all(graphs):
+    """Returns a new graph that contains only the nodes and the edges that exist in
+    all graphs.
+
+    Parameters
+    ----------
+    graphs : list
+       List of NetworkX graphs
+
+    Returns
+    -------
+    R : A new graph with the same type as the first graph in list
+
+    Raises
+    ------
+    ValueError
+       If `graphs` is an empty list.
+
+    Notes
+    -----
+    Attributes from the graph, nodes, and edges are not copied to the new
+    graph.
+    """
+    graphs = list(graphs)
+
+    if not graphs:
+        raise ValueError("cannot apply intersection_all to an empty list")
+
+    U = graphs[0]
+
+    if any(G.is_multigraph() != U.is_multigraph() for G in graphs):
+        raise nx.NetworkXError("All graphs must be graphs or multigraphs.")
+
+    # create new graph
+    node_intersection = set.intersection(*[set(G.nodes) for G in graphs])
+    R = U.__class__()
+    R.add_nodes_from(node_intersection)
+
+    if U.is_multigraph():
+        edge_sets = [set(G.edges(keys=True)) for G in graphs]
+    else:
+        edge_sets = [set(G.edges()) for G in graphs]
+
+    edge_intersection = set.intersection(*edge_sets)
+    R.add_edges_from(edge_intersection)
+
+    return R
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/binary.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/binary.py
new file mode 100644
index 0000000..fcd5933
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/binary.py
@@ -0,0 +1,424 @@
+"""
+Operations on graphs including union, intersection, difference.
+"""
+import networkx as nx
+
+__all__ = [
+    "union",
+    "compose",
+    "disjoint_union",
+    "intersection",
+    "difference",
+    "symmetric_difference",
+    "full_join",
+]
+
+
+def union(G, H, rename=(None, None), name=None):
+    """Return the union of graphs G and H.
+
+    Graphs G and H must be disjoint after the renaming takes place,
+    otherwise an exception is raised.
+
+    Parameters
+    ----------
+    G,H : graph
+       A NetworkX graph
+
+    rename : tuple , default=(None, None)
+       Node names of G and H can be changed by specifying the tuple
+       rename=('G-','H-') (for example).  Node "u" in G is then renamed
+       "G-u" and "v" in H is renamed "H-v".
+
+    name : string
+       Specify the name for the union graph
+
+       .. deprecated:: 2.7
+           This is deprecated and will be removed in version v3.0.
+
+    Returns
+    -------
+    U : A union graph with the same type as G.
+
+    Notes
+    -----
+    To force a disjoint union with node relabeling, use
+    disjoint_union(G,H) or convert_node_labels_to integers().
+
+    Graph, edge, and node attributes are propagated from G and H
+    to the union graph.  If a graph attribute is present in both
+    G and H the value from H is used.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2), (1, 2)])
+    >>> H = nx.Graph([(0, 1), (0, 3), (1, 3), (1, 2)])
+    >>> U = nx.union(G, H, rename=("G", "H"))
+    >>> U.nodes
+    NodeView(('G0', 'G1', 'G2', 'H0', 'H1', 'H3', 'H2'))
+    >>> U.edges
+    EdgeView([('G0', 'G1'), ('G0', 'G2'), ('G1', 'G2'), ('H0', 'H1'), ('H0', 'H3'), ('H1', 'H3'), ('H1', 'H2')])
+
+    See Also
+    --------
+    disjoint_union
+    """
+    if name is not None:
+        import warnings
+
+        warnings.warn(
+            "name parameter is deprecated and will be removed in version 3.0",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+    return nx.union_all([G, H], rename)
+
+
+def disjoint_union(G, H):
+    """Return the disjoint union of graphs G and H.
+
+    This algorithm forces distinct integer node labels.
+
+    Parameters
+    ----------
+    G,H : graph
+       A NetworkX graph
+
+    Returns
+    -------
+    U : A union graph with the same type as G.
+
+    Notes
+    -----
+    A new graph is created, of the same class as G.  It is recommended
+    that G and H be either both directed or both undirected.
+
+    The nodes of G are relabeled 0 to len(G)-1, and the nodes of H are
+    relabeled len(G) to len(G)+len(H)-1.
+
+    Graph, edge, and node attributes are propagated from G and H
+    to the union graph.  If a graph attribute is present in both
+    G and H the value from H is used.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2), (1, 2)])
+    >>> H = nx.Graph([(0, 3), (1, 2), (2, 3)])
+    >>> G.nodes[0]["key1"] = 5
+    >>> H.nodes[0]["key2"] = 10
+    >>> U = nx.disjoint_union(G, H)
+    >>> U.nodes(data=True)
+    NodeDataView({0: {'key1': 5}, 1: {}, 2: {}, 3: {'key2': 10}, 4: {}, 5: {}, 6: {}})
+    >>> U.edges
+    EdgeView([(0, 1), (0, 2), (1, 2), (3, 4), (4, 6), (5, 6)])
+    """
+    return nx.disjoint_union_all([G, H])
+
+
+def intersection(G, H):
+    """Returns a new graph that contains only the nodes and the edges that exist in
+    both G and H.
+
+    Parameters
+    ----------
+    G,H : graph
+       A NetworkX graph. G and H can have different node sets but must be both graphs or both multigraphs.
+
+    Raises
+    ------
+    NetworkXError
+        If one is a MultiGraph and the other one is a graph.
+
+    Returns
+    -------
+    GH : A new graph with the same type as G.
+
+    Notes
+    -----
+    Attributes from the graph, nodes, and edges are not copied to the new
+    graph.  If you want a new graph of the intersection of G and H
+    with the attributes (including edge data) from G use remove_nodes_from()
+    as follows
+
+    >>> G = nx.path_graph(3)
+    >>> H = nx.path_graph(5)
+    >>> R = G.copy()
+    >>> R.remove_nodes_from(n for n in G if n not in H)
+    >>> R.remove_edges_from(e for e in G.edges if e not in H.edges)
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2), (1, 2)])
+    >>> H = nx.Graph([(0, 3), (1, 2), (2, 3)])
+    >>> R = nx.intersection(G, H)
+    >>> R.nodes
+    NodeView((0, 1, 2))
+    >>> R.edges
+    EdgeView([(1, 2)])
+    """
+    return nx.intersection_all([G, H])
+
+
+def difference(G, H):
+    """Returns a new graph that contains the edges that exist in G but not in H.
+
+    The node sets of H and G must be the same.
+
+    Parameters
+    ----------
+    G,H : graph
+       A NetworkX graph. G and H must have the same node sets.
+
+    Returns
+    -------
+    D : A new graph with the same type as G.
+
+    Notes
+    -----
+    Attributes from the graph, nodes, and edges are not copied to the new
+    graph.  If you want a new graph of the difference of G and H with
+    the attributes (including edge data) from G use remove_nodes_from()
+    as follows:
+
+    >>> G = nx.path_graph(3)
+    >>> H = nx.path_graph(5)
+    >>> R = G.copy()
+    >>> R.remove_nodes_from(n for n in G if n in H)
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2), (1, 2), (1, 3)])
+    >>> H = nx.Graph([(0, 1), (1, 2), (0, 3)])
+    >>> R = nx.difference(G, H)
+    >>> R.nodes
+    NodeView((0, 1, 2, 3))
+    >>> R.edges
+    EdgeView([(0, 2), (1, 3)])
+    """
+    # create new graph
+    if not G.is_multigraph() == H.is_multigraph():
+        raise nx.NetworkXError("G and H must both be graphs or multigraphs.")
+    R = nx.create_empty_copy(G)
+
+    if set(G) != set(H):
+        raise nx.NetworkXError("Node sets of graphs not equal")
+
+    if G.is_multigraph():
+        edges = G.edges(keys=True)
+    else:
+        edges = G.edges()
+    for e in edges:
+        if not H.has_edge(*e):
+            R.add_edge(*e)
+    return R
+
+
+def symmetric_difference(G, H):
+    """Returns new graph with edges that exist in either G or H but not both.
+
+    The node sets of H and G must be the same.
+
+    Parameters
+    ----------
+    G,H : graph
+       A NetworkX graph.  G and H must have the same node sets.
+
+    Returns
+    -------
+    D : A new graph with the same type as G.
+
+    Notes
+    -----
+    Attributes from the graph, nodes, and edges are not copied to the new
+    graph.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2), (1, 2), (1, 3)])
+    >>> H = nx.Graph([(0, 1), (1, 2), (0, 3)])
+    >>> R = nx.symmetric_difference(G, H)
+    >>> R.nodes
+    NodeView((0, 1, 2, 3))
+    >>> R.edges
+    EdgeView([(0, 2), (0, 3), (1, 3)])
+    """
+    # create new graph
+    if not G.is_multigraph() == H.is_multigraph():
+        raise nx.NetworkXError("G and H must both be graphs or multigraphs.")
+    R = nx.create_empty_copy(G)
+
+    if set(G) != set(H):
+        raise nx.NetworkXError("Node sets of graphs not equal")
+
+    gnodes = set(G)  # set of nodes in G
+    hnodes = set(H)  # set of nodes in H
+    nodes = gnodes.symmetric_difference(hnodes)
+    R.add_nodes_from(nodes)
+
+    if G.is_multigraph():
+        edges = G.edges(keys=True)
+    else:
+        edges = G.edges()
+    # we could copy the data here but then this function doesn't
+    # match intersection and difference
+    for e in edges:
+        if not H.has_edge(*e):
+            R.add_edge(*e)
+
+    if H.is_multigraph():
+        edges = H.edges(keys=True)
+    else:
+        edges = H.edges()
+    for e in edges:
+        if not G.has_edge(*e):
+            R.add_edge(*e)
+    return R
+
+
+def compose(G, H):
+    """Returns a new graph of G composed with H.
+
+    Composition is the simple union of the node sets and edge sets.
+    The node sets of G and H do not need to be disjoint.
+
+    Parameters
+    ----------
+    G, H : graph
+       A NetworkX graph
+
+    Returns
+    -------
+    C: A new graph  with the same type as G
+
+    Notes
+    -----
+    It is recommended that G and H be either both directed or both undirected.
+    Attributes from H take precedent over attributes from G.
+
+    For MultiGraphs, the edges are identified by incident nodes AND edge-key.
+    This can cause surprises (i.e., edge `(1, 2)` may or may not be the same
+    in two graphs) if you use MultiGraph without keeping track of edge keys.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2)])
+    >>> H = nx.Graph([(0, 1), (1, 2)])
+    >>> R = nx.compose(G, H)
+    >>> R.nodes
+    NodeView((0, 1, 2))
+    >>> R.edges
+    EdgeView([(0, 1), (0, 2), (1, 2)])
+
+    By default, the attributes from `H` take precedent over attributes from `G`.
+    If you prefer another way of combining attributes, you can update them after the compose operation:
+
+    >>> G = nx.Graph([(0, 1, {'weight': 2.0}), (3, 0, {'weight': 100.0})])
+    >>> H = nx.Graph([(0, 1, {'weight': 10.0}), (1, 2, {'weight': -1.0})])
+    >>> nx.set_node_attributes(G, {0: 'dark', 1: 'light', 3: 'black'}, name='color')
+    >>> nx.set_node_attributes(H, {0: 'green', 1: 'orange', 2: 'yellow'}, name='color')
+    >>> GcomposeH = nx.compose(G, H)
+
+    Normally, color attribute values of nodes of GcomposeH come from H. We can workaround this as follows:
+
+    >>> node_data = {n: G.nodes[n]['color'] + " " + H.nodes[n]['color'] for n in G.nodes & H.nodes}
+    >>> nx.set_node_attributes(GcomposeH, node_data, 'color')
+    >>> print(GcomposeH.nodes[0]['color'])
+    dark green
+
+    >>> print(GcomposeH.nodes[3]['color'])
+    black
+
+    Similarly, we can update edge attributes after the compose operation in a way we prefer:
+
+    >>> edge_data = {e: G.edges[e]['weight'] * H.edges[e]['weight'] for e in G.edges & H.edges}
+    >>> nx.set_edge_attributes(GcomposeH, edge_data, 'weight')
+    >>> print(GcomposeH.edges[(0, 1)]['weight'])
+    20.0
+
+    >>> print(GcomposeH.edges[(3, 0)]['weight'])
+    100.0
+    """
+    return nx.compose_all([G, H])
+
+
+def full_join(G, H, rename=(None, None)):
+    """Returns the full join of graphs G and H.
+
+    Full join is the union of G and H in which all edges between
+    G and H are added.
+    The node sets of G and H must be disjoint,
+    otherwise an exception is raised.
+
+    Parameters
+    ----------
+    G, H : graph
+       A NetworkX graph
+
+    rename : tuple , default=(None, None)
+       Node names of G and H can be changed by specifying the tuple
+       rename=('G-','H-') (for example).  Node "u" in G is then renamed
+       "G-u" and "v" in H is renamed "H-v".
+
+    Returns
+    -------
+    U : The full join graph with the same type as G.
+
+    Notes
+    -----
+    It is recommended that G and H be either both directed or both undirected.
+
+    If G is directed, then edges from G to H are added as well as from H to G.
+
+    Note that full_join() does not produce parallel edges for MultiGraphs.
+
+    The full join operation of graphs G and H is the same as getting
+    their complement, performing a disjoint union, and finally getting
+    the complement of the resulting graph.
+
+    Graph, edge, and node attributes are propagated from G and H
+    to the union graph.  If a graph attribute is present in both
+    G and H the value from H is used.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2)])
+    >>> H = nx.Graph([(3, 4)])
+    >>> R = nx.full_join(G, H, rename=("G", "H"))
+    >>> R.nodes
+    NodeView(('G0', 'G1', 'G2', 'H3', 'H4'))
+    >>> R.edges
+    EdgeView([('G0', 'G1'), ('G0', 'G2'), ('G0', 'H3'), ('G0', 'H4'), ('G1', 'H3'), ('G1', 'H4'), ('G2', 'H3'), ('G2', 'H4'), ('H3', 'H4')])
+
+    See Also
+    --------
+    union
+    disjoint_union
+    """
+    R = union(G, H, rename)
+
+    def add_prefix(graph, prefix):
+        if prefix is None:
+            return graph
+
+        def label(x):
+            if isinstance(x, str):
+                name = prefix + x
+            else:
+                name = prefix + repr(x)
+            return name
+
+        return nx.relabel_nodes(graph, label)
+
+    G = add_prefix(G, rename[0])
+    H = add_prefix(H, rename[1])
+
+    for i in G:
+        for j in H:
+            R.add_edge(i, j)
+    if R.is_directed():
+        for i in H:
+            for j in G:
+                R.add_edge(i, j)
+
+    return R
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/product.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/product.py
new file mode 100644
index 0000000..4c56bbe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/product.py
@@ -0,0 +1,461 @@
+"""
+Graph products.
+"""
+from itertools import product
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "tensor_product",
+    "cartesian_product",
+    "lexicographic_product",
+    "strong_product",
+    "power",
+    "rooted_product",
+]
+
+
+def _dict_product(d1, d2):
+    return {k: (d1.get(k), d2.get(k)) for k in set(d1) | set(d2)}
+
+
+# Generators for producting graph products
+def _node_product(G, H):
+    for u, v in product(G, H):
+        yield ((u, v), _dict_product(G.nodes[u], H.nodes[v]))
+
+
+def _directed_edges_cross_edges(G, H):
+    if not G.is_multigraph() and not H.is_multigraph():
+        for u, v, c in G.edges(data=True):
+            for x, y, d in H.edges(data=True):
+                yield (u, x), (v, y), _dict_product(c, d)
+    if not G.is_multigraph() and H.is_multigraph():
+        for u, v, c in G.edges(data=True):
+            for x, y, k, d in H.edges(data=True, keys=True):
+                yield (u, x), (v, y), k, _dict_product(c, d)
+    if G.is_multigraph() and not H.is_multigraph():
+        for u, v, k, c in G.edges(data=True, keys=True):
+            for x, y, d in H.edges(data=True):
+                yield (u, x), (v, y), k, _dict_product(c, d)
+    if G.is_multigraph() and H.is_multigraph():
+        for u, v, j, c in G.edges(data=True, keys=True):
+            for x, y, k, d in H.edges(data=True, keys=True):
+                yield (u, x), (v, y), (j, k), _dict_product(c, d)
+
+
+def _undirected_edges_cross_edges(G, H):
+    if not G.is_multigraph() and not H.is_multigraph():
+        for u, v, c in G.edges(data=True):
+            for x, y, d in H.edges(data=True):
+                yield (v, x), (u, y), _dict_product(c, d)
+    if not G.is_multigraph() and H.is_multigraph():
+        for u, v, c in G.edges(data=True):
+            for x, y, k, d in H.edges(data=True, keys=True):
+                yield (v, x), (u, y), k, _dict_product(c, d)
+    if G.is_multigraph() and not H.is_multigraph():
+        for u, v, k, c in G.edges(data=True, keys=True):
+            for x, y, d in H.edges(data=True):
+                yield (v, x), (u, y), k, _dict_product(c, d)
+    if G.is_multigraph() and H.is_multigraph():
+        for u, v, j, c in G.edges(data=True, keys=True):
+            for x, y, k, d in H.edges(data=True, keys=True):
+                yield (v, x), (u, y), (j, k), _dict_product(c, d)
+
+
+def _edges_cross_nodes(G, H):
+    if G.is_multigraph():
+        for u, v, k, d in G.edges(data=True, keys=True):
+            for x in H:
+                yield (u, x), (v, x), k, d
+    else:
+        for u, v, d in G.edges(data=True):
+            for x in H:
+                if H.is_multigraph():
+                    yield (u, x), (v, x), None, d
+                else:
+                    yield (u, x), (v, x), d
+
+
+def _nodes_cross_edges(G, H):
+    if H.is_multigraph():
+        for x in G:
+            for u, v, k, d in H.edges(data=True, keys=True):
+                yield (x, u), (x, v), k, d
+    else:
+        for x in G:
+            for u, v, d in H.edges(data=True):
+                if G.is_multigraph():
+                    yield (x, u), (x, v), None, d
+                else:
+                    yield (x, u), (x, v), d
+
+
+def _edges_cross_nodes_and_nodes(G, H):
+    if G.is_multigraph():
+        for u, v, k, d in G.edges(data=True, keys=True):
+            for x in H:
+                for y in H:
+                    yield (u, x), (v, y), k, d
+    else:
+        for u, v, d in G.edges(data=True):
+            for x in H:
+                for y in H:
+                    if H.is_multigraph():
+                        yield (u, x), (v, y), None, d
+                    else:
+                        yield (u, x), (v, y), d
+
+
+def _init_product_graph(G, H):
+    if not G.is_directed() == H.is_directed():
+        msg = "G and H must be both directed or both undirected"
+        raise nx.NetworkXError(msg)
+    if G.is_multigraph() or H.is_multigraph():
+        GH = nx.MultiGraph()
+    else:
+        GH = nx.Graph()
+    if G.is_directed():
+        GH = GH.to_directed()
+    return GH
+
+
+def tensor_product(G, H):
+    r"""Returns the tensor product of G and H.
+
+    The tensor product $P$ of the graphs $G$ and $H$ has a node set that
+    is the tensor product of the node sets, $V(P)=V(G) \times V(H)$.
+    $P$ has an edge $((u,v), (x,y))$ if and only if $(u,x)$ is an edge in $G$
+    and $(v,y)$ is an edge in $H$.
+
+    Tensor product is sometimes also referred to as the categorical product,
+    direct product, cardinal product or conjunction.
+
+
+    Parameters
+    ----------
+    G, H: graphs
+     Networkx graphs.
+
+    Returns
+    -------
+    P: NetworkX graph
+     The tensor product of G and H. P will be a multi-graph if either G
+     or H is a multi-graph, will be a directed if G and H are directed,
+     and undirected if G and H are undirected.
+
+    Raises
+    ------
+    NetworkXError
+     If G and H are not both directed or both undirected.
+
+    Notes
+    -----
+    Node attributes in P are two-tuple of the G and H node attributes.
+    Missing attributes are assigned None.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> H = nx.Graph()
+    >>> G.add_node(0, a1=True)
+    >>> H.add_node("a", a2="Spam")
+    >>> P = nx.tensor_product(G, H)
+    >>> list(P)
+    [(0, 'a')]
+
+    Edge attributes and edge keys (for multigraphs) are also copied to the
+    new product graph
+    """
+    GH = _init_product_graph(G, H)
+    GH.add_nodes_from(_node_product(G, H))
+    GH.add_edges_from(_directed_edges_cross_edges(G, H))
+    if not GH.is_directed():
+        GH.add_edges_from(_undirected_edges_cross_edges(G, H))
+    return GH
+
+
+def cartesian_product(G, H):
+    r"""Returns the Cartesian product of G and H.
+
+    The Cartesian product $P$ of the graphs $G$ and $H$ has a node set that
+    is the Cartesian product of the node sets, $V(P)=V(G) \times V(H)$.
+    $P$ has an edge $((u,v),(x,y))$ if and only if either $u$ is equal to $x$
+    and both $v$ and $y$ are adjacent in $H$ or if $v$ is equal to $y$ and
+    both $u$ and $x$ are adjacent in $G$.
+
+    Parameters
+    ----------
+    G, H: graphs
+     Networkx graphs.
+
+    Returns
+    -------
+    P: NetworkX graph
+     The Cartesian product of G and H. P will be a multi-graph if either G
+     or H is a multi-graph. Will be a directed if G and H are directed,
+     and undirected if G and H are undirected.
+
+    Raises
+    ------
+    NetworkXError
+     If G and H are not both directed or both undirected.
+
+    Notes
+    -----
+    Node attributes in P are two-tuple of the G and H node attributes.
+    Missing attributes are assigned None.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> H = nx.Graph()
+    >>> G.add_node(0, a1=True)
+    >>> H.add_node("a", a2="Spam")
+    >>> P = nx.cartesian_product(G, H)
+    >>> list(P)
+    [(0, 'a')]
+
+    Edge attributes and edge keys (for multigraphs) are also copied to the
+    new product graph
+    """
+    GH = _init_product_graph(G, H)
+    GH.add_nodes_from(_node_product(G, H))
+    GH.add_edges_from(_edges_cross_nodes(G, H))
+    GH.add_edges_from(_nodes_cross_edges(G, H))
+    return GH
+
+
+def lexicographic_product(G, H):
+    r"""Returns the lexicographic product of G and H.
+
+    The lexicographical product $P$ of the graphs $G$ and $H$ has a node set
+    that is the Cartesian product of the node sets, $V(P)=V(G) \times V(H)$.
+    $P$ has an edge $((u,v), (x,y))$ if and only if $(u,v)$ is an edge in $G$
+    or $u==v$ and $(x,y)$ is an edge in $H$.
+
+    Parameters
+    ----------
+    G, H: graphs
+     Networkx graphs.
+
+    Returns
+    -------
+    P: NetworkX graph
+     The Cartesian product of G and H. P will be a multi-graph if either G
+     or H is a multi-graph. Will be a directed if G and H are directed,
+     and undirected if G and H are undirected.
+
+    Raises
+    ------
+    NetworkXError
+     If G and H are not both directed or both undirected.
+
+    Notes
+    -----
+    Node attributes in P are two-tuple of the G and H node attributes.
+    Missing attributes are assigned None.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> H = nx.Graph()
+    >>> G.add_node(0, a1=True)
+    >>> H.add_node("a", a2="Spam")
+    >>> P = nx.lexicographic_product(G, H)
+    >>> list(P)
+    [(0, 'a')]
+
+    Edge attributes and edge keys (for multigraphs) are also copied to the
+    new product graph
+    """
+    GH = _init_product_graph(G, H)
+    GH.add_nodes_from(_node_product(G, H))
+    # Edges in G regardless of H designation
+    GH.add_edges_from(_edges_cross_nodes_and_nodes(G, H))
+    # For each x in G, only if there is an edge in H
+    GH.add_edges_from(_nodes_cross_edges(G, H))
+    return GH
+
+
+def strong_product(G, H):
+    r"""Returns the strong product of G and H.
+
+    The strong product $P$ of the graphs $G$ and $H$ has a node set that
+    is the Cartesian product of the node sets, $V(P)=V(G) \times V(H)$.
+    $P$ has an edge $((u,v), (x,y))$ if and only if
+    $u==v$ and $(x,y)$ is an edge in $H$, or
+    $x==y$ and $(u,v)$ is an edge in $G$, or
+    $(u,v)$ is an edge in $G$ and $(x,y)$ is an edge in $H$.
+
+    Parameters
+    ----------
+    G, H: graphs
+     Networkx graphs.
+
+    Returns
+    -------
+    P: NetworkX graph
+     The Cartesian product of G and H. P will be a multi-graph if either G
+     or H is a multi-graph. Will be a directed if G and H are directed,
+     and undirected if G and H are undirected.
+
+    Raises
+    ------
+    NetworkXError
+     If G and H are not both directed or both undirected.
+
+    Notes
+    -----
+    Node attributes in P are two-tuple of the G and H node attributes.
+    Missing attributes are assigned None.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> H = nx.Graph()
+    >>> G.add_node(0, a1=True)
+    >>> H.add_node("a", a2="Spam")
+    >>> P = nx.strong_product(G, H)
+    >>> list(P)
+    [(0, 'a')]
+
+    Edge attributes and edge keys (for multigraphs) are also copied to the
+    new product graph
+    """
+    GH = _init_product_graph(G, H)
+    GH.add_nodes_from(_node_product(G, H))
+    GH.add_edges_from(_nodes_cross_edges(G, H))
+    GH.add_edges_from(_edges_cross_nodes(G, H))
+    GH.add_edges_from(_directed_edges_cross_edges(G, H))
+    if not GH.is_directed():
+        GH.add_edges_from(_undirected_edges_cross_edges(G, H))
+    return GH
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def power(G, k):
+    """Returns the specified power of a graph.
+
+    The $k$th power of a simple graph $G$, denoted $G^k$, is a
+    graph on the same set of nodes in which two distinct nodes $u$ and
+    $v$ are adjacent in $G^k$ if and only if the shortest path
+    distance between $u$ and $v$ in $G$ is at most $k$.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX simple graph object.
+
+    k : positive integer
+        The power to which to raise the graph `G`.
+
+    Returns
+    -------
+    NetworkX simple graph
+        `G` to the power `k`.
+
+    Raises
+    ------
+    ValueError
+        If the exponent `k` is not positive.
+
+    NetworkXNotImplemented
+        If `G` is not a simple graph.
+
+    Examples
+    --------
+    The number of edges will never decrease when taking successive
+    powers:
+
+    >>> G = nx.path_graph(4)
+    >>> list(nx.power(G, 2).edges)
+    [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3)]
+    >>> list(nx.power(G, 3).edges)
+    [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]
+
+    The `k`th power of a cycle graph on *n* nodes is the complete graph
+    on *n* nodes, if `k` is at least ``n // 2``:
+
+    >>> G = nx.cycle_graph(5)
+    >>> H = nx.complete_graph(5)
+    >>> nx.is_isomorphic(nx.power(G, 2), H)
+    True
+    >>> G = nx.cycle_graph(8)
+    >>> H = nx.complete_graph(8)
+    >>> nx.is_isomorphic(nx.power(G, 4), H)
+    True
+
+    References
+    ----------
+    .. [1] J. A. Bondy, U. S. R. Murty, *Graph Theory*. Springer, 2008.
+
+    Notes
+    -----
+    This definition of "power graph" comes from Exercise 3.1.6 of
+    *Graph Theory* by Bondy and Murty [1]_.
+
+    """
+    if k <= 0:
+        raise ValueError("k must be a positive integer")
+    H = nx.Graph()
+    H.add_nodes_from(G)
+    # update BFS code to ignore self loops.
+    for n in G:
+        seen = {}  # level (number of hops) when seen in BFS
+        level = 1  # the current level
+        nextlevel = G[n]
+        while nextlevel:
+            thislevel = nextlevel  # advance to next level
+            nextlevel = {}  # and start a new list (fringe)
+            for v in thislevel:
+                if v == n:  # avoid self loop
+                    continue
+                if v not in seen:
+                    seen[v] = level  # set the level of vertex v
+                    nextlevel.update(G[v])  # add neighbors of v
+            if k <= level:
+                break
+            level += 1
+        H.add_edges_from((n, nbr) for nbr in seen)
+    return H
+
+
+@not_implemented_for("multigraph")
+def rooted_product(G, H, root):
+    """Return the rooted product of graphs G and H rooted at root in H.
+
+    A new graph is constructed representing the rooted product of
+    the inputted graphs, G and H, with a root in H.
+    A rooted product duplicates H for each nodes in G with the root
+    of H corresponding to the node in G. Nodes are renamed as the direct
+    product of G and H. The result is a subgraph of the cartesian product.
+
+    Parameters
+    ----------
+    G,H : graph
+       A NetworkX graph
+    root : node
+       A node in H
+
+    Returns
+    -------
+    R : The rooted product of G and H with a specified root in H
+
+    Notes
+    -----
+    The nodes of R are the Cartesian Product of the nodes of G and H.
+    The nodes of G and H are not relabeled.
+    """
+    if root not in H:
+        raise nx.NetworkXError("root must be a vertex in H")
+
+    R = nx.Graph()
+    R.add_nodes_from(product(G, H))
+
+    R.add_edges_from(((e[0], root), (e[1], root)) for e in G.edges())
+    R.add_edges_from(((g, e[0]), (g, e[1])) for g in G for e in H.edges())
+
+    return R
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_all.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_all.py
new file mode 100644
index 0000000..e09791b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_all.py
@@ -0,0 +1,300 @@
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal
+
+
+def test_union_all_attributes():
+    g = nx.Graph()
+    g.add_node(0, x=4)
+    g.add_node(1, x=5)
+    g.add_edge(0, 1, size=5)
+    g.graph["name"] = "g"
+
+    h = g.copy()
+    h.graph["name"] = "h"
+    h.graph["attr"] = "attr"
+    h.nodes[0]["x"] = 7
+
+    j = g.copy()
+    j.graph["name"] = "j"
+    j.graph["attr"] = "attr"
+    j.nodes[0]["x"] = 7
+
+    ghj = nx.union_all([g, h, j], rename=("g", "h", "j"))
+    assert set(ghj.nodes()) == {"h0", "h1", "g0", "g1", "j0", "j1"}
+    for n in ghj:
+        graph, node = n
+        assert ghj.nodes[n] == eval(graph).nodes[int(node)]
+
+    assert ghj.graph["attr"] == "attr"
+    assert ghj.graph["name"] == "j"  # j graph attributes take precendent
+
+
+def test_intersection_all():
+    G = nx.Graph()
+    H = nx.Graph()
+    R = nx.Graph()
+    G.add_nodes_from([1, 2, 3, 4])
+    G.add_edge(1, 2)
+    G.add_edge(2, 3)
+    H.add_nodes_from([1, 2, 3, 4])
+    H.add_edge(2, 3)
+    H.add_edge(3, 4)
+    R.add_nodes_from([1, 2, 3, 4])
+    R.add_edge(2, 3)
+    R.add_edge(4, 1)
+    I = nx.intersection_all([G, H, R])
+    assert set(I.nodes()) == {1, 2, 3, 4}
+    assert sorted(I.edges()) == [(2, 3)]
+
+
+def test_intersection_all_different_node_sets():
+    G = nx.Graph()
+    H = nx.Graph()
+    R = nx.Graph()
+    G.add_nodes_from([1, 2, 3, 4, 6, 7])
+    G.add_edge(1, 2)
+    G.add_edge(2, 3)
+    G.add_edge(6, 7)
+    H.add_nodes_from([1, 2, 3, 4])
+    H.add_edge(2, 3)
+    H.add_edge(3, 4)
+    R.add_nodes_from([1, 2, 3, 4, 8, 9])
+    R.add_edge(2, 3)
+    R.add_edge(4, 1)
+    R.add_edge(8, 9)
+    I = nx.intersection_all([G, H, R])
+    assert set(I.nodes()) == {1, 2, 3, 4}
+    assert sorted(I.edges()) == [(2, 3)]
+
+
+def test_intersection_all_attributes():
+    g = nx.Graph()
+    g.add_node(0, x=4)
+    g.add_node(1, x=5)
+    g.add_edge(0, 1, size=5)
+    g.graph["name"] = "g"
+
+    h = g.copy()
+    h.graph["name"] = "h"
+    h.graph["attr"] = "attr"
+    h.nodes[0]["x"] = 7
+
+    gh = nx.intersection_all([g, h])
+    assert set(gh.nodes()) == set(g.nodes())
+    assert set(gh.nodes()) == set(h.nodes())
+    assert sorted(gh.edges()) == sorted(g.edges())
+
+
+def test_intersection_all_attributes_different_node_sets():
+    g = nx.Graph()
+    g.add_node(0, x=4)
+    g.add_node(1, x=5)
+    g.add_edge(0, 1, size=5)
+    g.graph["name"] = "g"
+
+    h = g.copy()
+    g.add_node(2)
+    h.graph["name"] = "h"
+    h.graph["attr"] = "attr"
+    h.nodes[0]["x"] = 7
+
+    gh = nx.intersection_all([g, h])
+    assert set(gh.nodes()) == set(h.nodes())
+    assert sorted(gh.edges()) == sorted(g.edges())
+
+
+def test_intersection_all_multigraph_attributes():
+    g = nx.MultiGraph()
+    g.add_edge(0, 1, key=0)
+    g.add_edge(0, 1, key=1)
+    g.add_edge(0, 1, key=2)
+    h = nx.MultiGraph()
+    h.add_edge(0, 1, key=0)
+    h.add_edge(0, 1, key=3)
+    gh = nx.intersection_all([g, h])
+    assert set(gh.nodes()) == set(g.nodes())
+    assert set(gh.nodes()) == set(h.nodes())
+    assert sorted(gh.edges()) == [(0, 1)]
+    assert sorted(gh.edges(keys=True)) == [(0, 1, 0)]
+
+
+def test_intersection_all_multigraph_attributes_different_node_sets():
+    g = nx.MultiGraph()
+    g.add_edge(0, 1, key=0)
+    g.add_edge(0, 1, key=1)
+    g.add_edge(0, 1, key=2)
+    g.add_edge(1, 2, key=1)
+    g.add_edge(1, 2, key=2)
+    h = nx.MultiGraph()
+    h.add_edge(0, 1, key=0)
+    h.add_edge(0, 1, key=3)
+    gh = nx.intersection_all([g, h])
+    assert set(gh.nodes()) == set(h.nodes())
+    assert sorted(gh.edges()) == [(0, 1)]
+    assert sorted(gh.edges(keys=True)) == [(0, 1, 0)]
+
+
+def test_union_all_and_compose_all():
+    K3 = nx.complete_graph(3)
+    P3 = nx.path_graph(3)
+
+    G1 = nx.DiGraph()
+    G1.add_edge("A", "B")
+    G1.add_edge("A", "C")
+    G1.add_edge("A", "D")
+    G2 = nx.DiGraph()
+    G2.add_edge("1", "2")
+    G2.add_edge("1", "3")
+    G2.add_edge("1", "4")
+
+    G = nx.union_all([G1, G2])
+    H = nx.compose_all([G1, G2])
+    assert edges_equal(G.edges(), H.edges())
+    assert not G.has_edge("A", "1")
+    pytest.raises(nx.NetworkXError, nx.union, K3, P3)
+    H1 = nx.union_all([H, G1], rename=("H", "G1"))
+    assert sorted(H1.nodes()) == [
+        "G1A",
+        "G1B",
+        "G1C",
+        "G1D",
+        "H1",
+        "H2",
+        "H3",
+        "H4",
+        "HA",
+        "HB",
+        "HC",
+        "HD",
+    ]
+
+    H2 = nx.union_all([H, G2], rename=("H", ""))
+    assert sorted(H2.nodes()) == [
+        "1",
+        "2",
+        "3",
+        "4",
+        "H1",
+        "H2",
+        "H3",
+        "H4",
+        "HA",
+        "HB",
+        "HC",
+        "HD",
+    ]
+
+    assert not H1.has_edge("NB", "NA")
+
+    G = nx.compose_all([G, G])
+    assert edges_equal(G.edges(), H.edges())
+
+    G2 = nx.union_all([G2, G2], rename=("", "copy"))
+    assert sorted(G2.nodes()) == [
+        "1",
+        "2",
+        "3",
+        "4",
+        "copy1",
+        "copy2",
+        "copy3",
+        "copy4",
+    ]
+
+    assert sorted(G2.neighbors("copy4")) == []
+    assert sorted(G2.neighbors("copy1")) == ["copy2", "copy3", "copy4"]
+    assert len(G) == 8
+    assert nx.number_of_edges(G) == 6
+
+    E = nx.disjoint_union_all([G, G])
+    assert len(E) == 16
+    assert nx.number_of_edges(E) == 12
+
+    E = nx.disjoint_union_all([G1, G2])
+    assert sorted(E.nodes()) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+
+    G1 = nx.DiGraph()
+    G1.add_edge("A", "B")
+    G2 = nx.DiGraph()
+    G2.add_edge(1, 2)
+    G3 = nx.DiGraph()
+    G3.add_edge(11, 22)
+    G4 = nx.union_all([G1, G2, G3], rename=("G1", "G2", "G3"))
+    assert sorted(G4.nodes()) == ["G1A", "G1B", "G21", "G22", "G311", "G322"]
+
+
+def test_union_all_multigraph():
+    G = nx.MultiGraph()
+    G.add_edge(1, 2, key=0)
+    G.add_edge(1, 2, key=1)
+    H = nx.MultiGraph()
+    H.add_edge(3, 4, key=0)
+    H.add_edge(3, 4, key=1)
+    GH = nx.union_all([G, H])
+    assert set(GH) == set(G) | set(H)
+    assert set(GH.edges(keys=True)) == set(G.edges(keys=True)) | set(H.edges(keys=True))
+
+
+def test_input_output():
+    l = [nx.Graph([(1, 2)]), nx.Graph([(3, 4)])]
+    U = nx.disjoint_union_all(l)
+    assert len(l) == 2
+    C = nx.compose_all(l)
+    assert len(l) == 2
+    l = [nx.Graph([(1, 2)]), nx.Graph([(1, 2)])]
+    R = nx.intersection_all(l)
+    assert len(l) == 2
+
+
+def test_mixed_type_union():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.Graph()
+        H = nx.MultiGraph()
+        I = nx.Graph()
+        U = nx.union_all([G, H, I])
+
+
+def test_mixed_type_disjoint_union():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.Graph()
+        H = nx.MultiGraph()
+        I = nx.Graph()
+        U = nx.disjoint_union_all([G, H, I])
+
+
+def test_mixed_type_intersection():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.Graph()
+        H = nx.MultiGraph()
+        I = nx.Graph()
+        U = nx.intersection_all([G, H, I])
+
+
+def test_mixed_type_compose():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.Graph()
+        H = nx.MultiGraph()
+        I = nx.Graph()
+        U = nx.compose_all([G, H, I])
+
+
+def test_empty_union():
+    with pytest.raises(ValueError):
+        nx.union_all([])
+
+
+def test_empty_disjoint_union():
+    with pytest.raises(ValueError):
+        nx.disjoint_union_all([])
+
+
+def test_empty_compose_all():
+    with pytest.raises(ValueError):
+        nx.compose_all([])
+
+
+def test_empty_intersection_all():
+    with pytest.raises(ValueError):
+        nx.intersection_all([])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_binary.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_binary.py
new file mode 100644
index 0000000..f11e159
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_binary.py
@@ -0,0 +1,448 @@
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal
+
+
+def test_union_attributes():
+    g = nx.Graph()
+    g.add_node(0, x=4)
+    g.add_node(1, x=5)
+    g.add_edge(0, 1, size=5)
+    g.graph["name"] = "g"
+
+    h = g.copy()
+    h.graph["name"] = "h"
+    h.graph["attr"] = "attr"
+    h.nodes[0]["x"] = 7
+
+    gh = nx.union(g, h, rename=("g", "h"))
+    assert set(gh.nodes()) == {"h0", "h1", "g0", "g1"}
+    for n in gh:
+        graph, node = n
+        assert gh.nodes[n] == eval(graph).nodes[int(node)]
+
+    assert gh.graph["attr"] == "attr"
+    assert gh.graph["name"] == "h"  # h graph attributes take precendent
+
+
+def test_intersection():
+    G = nx.Graph()
+    H = nx.Graph()
+    G.add_nodes_from([1, 2, 3, 4])
+    G.add_edge(1, 2)
+    G.add_edge(2, 3)
+    H.add_nodes_from([1, 2, 3, 4])
+    H.add_edge(2, 3)
+    H.add_edge(3, 4)
+    I = nx.intersection(G, H)
+    assert set(I.nodes()) == {1, 2, 3, 4}
+    assert sorted(I.edges()) == [(2, 3)]
+
+
+def test_intersection_node_sets_different():
+    G = nx.Graph()
+    H = nx.Graph()
+    G.add_nodes_from([1, 2, 3, 4, 7])
+    G.add_edge(1, 2)
+    G.add_edge(2, 3)
+    H.add_nodes_from([1, 2, 3, 4, 5, 6])
+    H.add_edge(2, 3)
+    H.add_edge(3, 4)
+    H.add_edge(5, 6)
+    I = nx.intersection(G, H)
+    assert set(I.nodes()) == {1, 2, 3, 4}
+    assert sorted(I.edges()) == [(2, 3)]
+
+
+def test_intersection_attributes():
+    g = nx.Graph()
+    g.add_node(0, x=4)
+    g.add_node(1, x=5)
+    g.add_edge(0, 1, size=5)
+    g.graph["name"] = "g"
+
+    h = g.copy()
+    h.graph["name"] = "h"
+    h.graph["attr"] = "attr"
+    h.nodes[0]["x"] = 7
+    gh = nx.intersection(g, h)
+
+    assert set(gh.nodes()) == set(g.nodes())
+    assert set(gh.nodes()) == set(h.nodes())
+    assert sorted(gh.edges()) == sorted(g.edges())
+
+
+def test_intersection_attributes_node_sets_different():
+    g = nx.Graph()
+    g.add_node(0, x=4)
+    g.add_node(1, x=5)
+    g.add_node(2, x=3)
+    g.add_edge(0, 1, size=5)
+    g.graph["name"] = "g"
+
+    h = g.copy()
+    h.graph["name"] = "h"
+    h.graph["attr"] = "attr"
+    h.nodes[0]["x"] = 7
+    h.remove_node(2)
+
+    gh = nx.intersection(g, h)
+    assert set(gh.nodes()) == set(h.nodes())
+    assert sorted(gh.edges()) == sorted(g.edges())
+
+
+def test_intersection_multigraph_attributes():
+    g = nx.MultiGraph()
+    g.add_edge(0, 1, key=0)
+    g.add_edge(0, 1, key=1)
+    g.add_edge(0, 1, key=2)
+    h = nx.MultiGraph()
+    h.add_edge(0, 1, key=0)
+    h.add_edge(0, 1, key=3)
+    gh = nx.intersection(g, h)
+    assert set(gh.nodes()) == set(g.nodes())
+    assert set(gh.nodes()) == set(h.nodes())
+    assert sorted(gh.edges()) == [(0, 1)]
+    assert sorted(gh.edges(keys=True)) == [(0, 1, 0)]
+
+
+def test_intersection_multigraph_attributes_node_set_different():
+    g = nx.MultiGraph()
+    g.add_edge(0, 1, key=0)
+    g.add_edge(0, 1, key=1)
+    g.add_edge(0, 1, key=2)
+    g.add_edge(0, 2, key=2)
+    g.add_edge(0, 2, key=1)
+    h = nx.MultiGraph()
+    h.add_edge(0, 1, key=0)
+    h.add_edge(0, 1, key=3)
+    gh = nx.intersection(g, h)
+    assert set(gh.nodes()) == set(h.nodes())
+    assert sorted(gh.edges()) == [(0, 1)]
+    assert sorted(gh.edges(keys=True)) == [(0, 1, 0)]
+
+
+def test_difference():
+    G = nx.Graph()
+    H = nx.Graph()
+    G.add_nodes_from([1, 2, 3, 4])
+    G.add_edge(1, 2)
+    G.add_edge(2, 3)
+    H.add_nodes_from([1, 2, 3, 4])
+    H.add_edge(2, 3)
+    H.add_edge(3, 4)
+    D = nx.difference(G, H)
+    assert set(D.nodes()) == {1, 2, 3, 4}
+    assert sorted(D.edges()) == [(1, 2)]
+    D = nx.difference(H, G)
+    assert set(D.nodes()) == {1, 2, 3, 4}
+    assert sorted(D.edges()) == [(3, 4)]
+    D = nx.symmetric_difference(G, H)
+    assert set(D.nodes()) == {1, 2, 3, 4}
+    assert sorted(D.edges()) == [(1, 2), (3, 4)]
+
+
+def test_difference2():
+    G = nx.Graph()
+    H = nx.Graph()
+    G.add_nodes_from([1, 2, 3, 4])
+    H.add_nodes_from([1, 2, 3, 4])
+    G.add_edge(1, 2)
+    H.add_edge(1, 2)
+    G.add_edge(2, 3)
+    D = nx.difference(G, H)
+    assert set(D.nodes()) == {1, 2, 3, 4}
+    assert sorted(D.edges()) == [(2, 3)]
+    D = nx.difference(H, G)
+    assert set(D.nodes()) == {1, 2, 3, 4}
+    assert sorted(D.edges()) == []
+    H.add_edge(3, 4)
+    D = nx.difference(H, G)
+    assert set(D.nodes()) == {1, 2, 3, 4}
+    assert sorted(D.edges()) == [(3, 4)]
+
+
+def test_difference_attributes():
+    g = nx.Graph()
+    g.add_node(0, x=4)
+    g.add_node(1, x=5)
+    g.add_edge(0, 1, size=5)
+    g.graph["name"] = "g"
+
+    h = g.copy()
+    h.graph["name"] = "h"
+    h.graph["attr"] = "attr"
+    h.nodes[0]["x"] = 7
+
+    gh = nx.difference(g, h)
+    assert set(gh.nodes()) == set(g.nodes())
+    assert set(gh.nodes()) == set(h.nodes())
+    assert sorted(gh.edges()) == []
+
+
+def test_difference_multigraph_attributes():
+    g = nx.MultiGraph()
+    g.add_edge(0, 1, key=0)
+    g.add_edge(0, 1, key=1)
+    g.add_edge(0, 1, key=2)
+    h = nx.MultiGraph()
+    h.add_edge(0, 1, key=0)
+    h.add_edge(0, 1, key=3)
+    gh = nx.difference(g, h)
+    assert set(gh.nodes()) == set(g.nodes())
+    assert set(gh.nodes()) == set(h.nodes())
+    assert sorted(gh.edges()) == [(0, 1), (0, 1)]
+    assert sorted(gh.edges(keys=True)) == [(0, 1, 1), (0, 1, 2)]
+
+
+def test_difference_raise():
+    G = nx.path_graph(4)
+    H = nx.path_graph(3)
+    pytest.raises(nx.NetworkXError, nx.difference, G, H)
+    pytest.raises(nx.NetworkXError, nx.symmetric_difference, G, H)
+
+
+def test_symmetric_difference_multigraph():
+    g = nx.MultiGraph()
+    g.add_edge(0, 1, key=0)
+    g.add_edge(0, 1, key=1)
+    g.add_edge(0, 1, key=2)
+    h = nx.MultiGraph()
+    h.add_edge(0, 1, key=0)
+    h.add_edge(0, 1, key=3)
+    gh = nx.symmetric_difference(g, h)
+    assert set(gh.nodes()) == set(g.nodes())
+    assert set(gh.nodes()) == set(h.nodes())
+    assert sorted(gh.edges()) == 3 * [(0, 1)]
+    assert sorted(sorted(e) for e in gh.edges(keys=True)) == [
+        [0, 1, 1],
+        [0, 1, 2],
+        [0, 1, 3],
+    ]
+
+
+def test_union_and_compose():
+    K3 = nx.complete_graph(3)
+    P3 = nx.path_graph(3)
+
+    G1 = nx.DiGraph()
+    G1.add_edge("A", "B")
+    G1.add_edge("A", "C")
+    G1.add_edge("A", "D")
+    G2 = nx.DiGraph()
+    G2.add_edge("1", "2")
+    G2.add_edge("1", "3")
+    G2.add_edge("1", "4")
+
+    G = nx.union(G1, G2)
+    H = nx.compose(G1, G2)
+    assert edges_equal(G.edges(), H.edges())
+    assert not G.has_edge("A", 1)
+    pytest.raises(nx.NetworkXError, nx.union, K3, P3)
+    H1 = nx.union(H, G1, rename=("H", "G1"))
+    assert sorted(H1.nodes()) == [
+        "G1A",
+        "G1B",
+        "G1C",
+        "G1D",
+        "H1",
+        "H2",
+        "H3",
+        "H4",
+        "HA",
+        "HB",
+        "HC",
+        "HD",
+    ]
+
+    H2 = nx.union(H, G2, rename=("H", ""))
+    assert sorted(H2.nodes()) == [
+        "1",
+        "2",
+        "3",
+        "4",
+        "H1",
+        "H2",
+        "H3",
+        "H4",
+        "HA",
+        "HB",
+        "HC",
+        "HD",
+    ]
+
+    assert not H1.has_edge("NB", "NA")
+
+    G = nx.compose(G, G)
+    assert edges_equal(G.edges(), H.edges())
+
+    G2 = nx.union(G2, G2, rename=("", "copy"))
+    assert sorted(G2.nodes()) == [
+        "1",
+        "2",
+        "3",
+        "4",
+        "copy1",
+        "copy2",
+        "copy3",
+        "copy4",
+    ]
+
+    assert sorted(G2.neighbors("copy4")) == []
+    assert sorted(G2.neighbors("copy1")) == ["copy2", "copy3", "copy4"]
+    assert len(G) == 8
+    assert nx.number_of_edges(G) == 6
+
+    E = nx.disjoint_union(G, G)
+    assert len(E) == 16
+    assert nx.number_of_edges(E) == 12
+
+    E = nx.disjoint_union(G1, G2)
+    assert sorted(E.nodes()) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+
+    G = nx.Graph()
+    H = nx.Graph()
+    G.add_nodes_from([(1, {"a1": 1})])
+    H.add_nodes_from([(1, {"b1": 1})])
+    R = nx.compose(G, H)
+    assert R.nodes == {1: {"a1": 1, "b1": 1}}
+
+
+def test_union_multigraph():
+    G = nx.MultiGraph()
+    G.add_edge(1, 2, key=0)
+    G.add_edge(1, 2, key=1)
+    H = nx.MultiGraph()
+    H.add_edge(3, 4, key=0)
+    H.add_edge(3, 4, key=1)
+    GH = nx.union(G, H)
+    assert set(GH) == set(G) | set(H)
+    assert set(GH.edges(keys=True)) == set(G.edges(keys=True)) | set(H.edges(keys=True))
+
+
+def test_disjoint_union_multigraph():
+    G = nx.MultiGraph()
+    G.add_edge(0, 1, key=0)
+    G.add_edge(0, 1, key=1)
+    H = nx.MultiGraph()
+    H.add_edge(2, 3, key=0)
+    H.add_edge(2, 3, key=1)
+    GH = nx.disjoint_union(G, H)
+    assert set(GH) == set(G) | set(H)
+    assert set(GH.edges(keys=True)) == set(G.edges(keys=True)) | set(H.edges(keys=True))
+
+
+def test_compose_multigraph():
+    G = nx.MultiGraph()
+    G.add_edge(1, 2, key=0)
+    G.add_edge(1, 2, key=1)
+    H = nx.MultiGraph()
+    H.add_edge(3, 4, key=0)
+    H.add_edge(3, 4, key=1)
+    GH = nx.compose(G, H)
+    assert set(GH) == set(G) | set(H)
+    assert set(GH.edges(keys=True)) == set(G.edges(keys=True)) | set(H.edges(keys=True))
+    H.add_edge(1, 2, key=2)
+    GH = nx.compose(G, H)
+    assert set(GH) == set(G) | set(H)
+    assert set(GH.edges(keys=True)) == set(G.edges(keys=True)) | set(H.edges(keys=True))
+
+
+def test_full_join_graph():
+    # Simple Graphs
+    G = nx.Graph()
+    G.add_node(0)
+    G.add_edge(1, 2)
+    H = nx.Graph()
+    H.add_edge(3, 4)
+
+    U = nx.full_join(G, H)
+    assert set(U) == set(G) | set(H)
+    assert len(U) == len(G) + len(H)
+    assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H)
+
+    # Rename
+    U = nx.full_join(G, H, rename=("g", "h"))
+    assert set(U) == {"g0", "g1", "g2", "h3", "h4"}
+    assert len(U) == len(G) + len(H)
+    assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H)
+
+    # Rename graphs with string-like nodes
+    G = nx.Graph()
+    G.add_node("a")
+    G.add_edge("b", "c")
+    H = nx.Graph()
+    H.add_edge("d", "e")
+
+    U = nx.full_join(G, H, rename=("g", "h"))
+    assert set(U) == {"ga", "gb", "gc", "hd", "he"}
+    assert len(U) == len(G) + len(H)
+    assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H)
+
+    # DiGraphs
+    G = nx.DiGraph()
+    G.add_node(0)
+    G.add_edge(1, 2)
+    H = nx.DiGraph()
+    H.add_edge(3, 4)
+
+    U = nx.full_join(G, H)
+    assert set(U) == set(G) | set(H)
+    assert len(U) == len(G) + len(H)
+    assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H) * 2
+
+    # DiGraphs Rename
+    U = nx.full_join(G, H, rename=("g", "h"))
+    assert set(U) == {"g0", "g1", "g2", "h3", "h4"}
+    assert len(U) == len(G) + len(H)
+    assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H) * 2
+
+
+def test_full_join_multigraph():
+    # MultiGraphs
+    G = nx.MultiGraph()
+    G.add_node(0)
+    G.add_edge(1, 2)
+    H = nx.MultiGraph()
+    H.add_edge(3, 4)
+
+    U = nx.full_join(G, H)
+    assert set(U) == set(G) | set(H)
+    assert len(U) == len(G) + len(H)
+    assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H)
+
+    # MultiGraphs rename
+    U = nx.full_join(G, H, rename=("g", "h"))
+    assert set(U) == {"g0", "g1", "g2", "h3", "h4"}
+    assert len(U) == len(G) + len(H)
+    assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H)
+
+    # MultiDiGraphs
+    G = nx.MultiDiGraph()
+    G.add_node(0)
+    G.add_edge(1, 2)
+    H = nx.MultiDiGraph()
+    H.add_edge(3, 4)
+
+    U = nx.full_join(G, H)
+    assert set(U) == set(G) | set(H)
+    assert len(U) == len(G) + len(H)
+    assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H) * 2
+
+    # MultiDiGraphs rename
+    U = nx.full_join(G, H, rename=("g", "h"))
+    assert set(U) == {"g0", "g1", "g2", "h3", "h4"}
+    assert len(U) == len(G) + len(H)
+    assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H) * 2
+
+
+def test_mixed_type_union():
+    G = nx.Graph()
+    H = nx.MultiGraph()
+    pytest.raises(nx.NetworkXError, nx.union, G, H)
+    pytest.raises(nx.NetworkXError, nx.disjoint_union, G, H)
+    pytest.raises(nx.NetworkXError, nx.intersection, G, H)
+    pytest.raises(nx.NetworkXError, nx.difference, G, H)
+    pytest.raises(nx.NetworkXError, nx.symmetric_difference, G, H)
+    pytest.raises(nx.NetworkXError, nx.compose, G, H)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_product.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_product.py
new file mode 100644
index 0000000..fb97756
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_product.py
@@ -0,0 +1,427 @@
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal
+
+
+def test_tensor_product_raises():
+    with pytest.raises(nx.NetworkXError):
+        P = nx.tensor_product(nx.DiGraph(), nx.Graph())
+
+
+def test_tensor_product_null():
+    null = nx.null_graph()
+    empty10 = nx.empty_graph(10)
+    K3 = nx.complete_graph(3)
+    K10 = nx.complete_graph(10)
+    P3 = nx.path_graph(3)
+    P10 = nx.path_graph(10)
+    # null graph
+    G = nx.tensor_product(null, null)
+    assert nx.is_isomorphic(G, null)
+    # null_graph X anything = null_graph and v.v.
+    G = nx.tensor_product(null, empty10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.tensor_product(null, K3)
+    assert nx.is_isomorphic(G, null)
+    G = nx.tensor_product(null, K10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.tensor_product(null, P3)
+    assert nx.is_isomorphic(G, null)
+    G = nx.tensor_product(null, P10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.tensor_product(empty10, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.tensor_product(K3, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.tensor_product(K10, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.tensor_product(P3, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.tensor_product(P10, null)
+    assert nx.is_isomorphic(G, null)
+
+
+def test_tensor_product_size():
+    P5 = nx.path_graph(5)
+    K3 = nx.complete_graph(3)
+    K5 = nx.complete_graph(5)
+
+    G = nx.tensor_product(P5, K3)
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.tensor_product(K3, K5)
+    assert nx.number_of_nodes(G) == 3 * 5
+
+
+def test_tensor_product_combinations():
+    # basic smoke test, more realistic tests would be useful
+    P5 = nx.path_graph(5)
+    K3 = nx.complete_graph(3)
+    G = nx.tensor_product(P5, K3)
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.tensor_product(P5, nx.MultiGraph(K3))
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.tensor_product(nx.MultiGraph(P5), K3)
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.tensor_product(nx.MultiGraph(P5), nx.MultiGraph(K3))
+    assert nx.number_of_nodes(G) == 5 * 3
+
+    G = nx.tensor_product(nx.DiGraph(P5), nx.DiGraph(K3))
+    assert nx.number_of_nodes(G) == 5 * 3
+
+
+def test_tensor_product_classic_result():
+    K2 = nx.complete_graph(2)
+    G = nx.petersen_graph()
+    G = nx.tensor_product(G, K2)
+    assert nx.is_isomorphic(G, nx.desargues_graph())
+
+    G = nx.cycle_graph(5)
+    G = nx.tensor_product(G, K2)
+    assert nx.is_isomorphic(G, nx.cycle_graph(10))
+
+    G = nx.tetrahedral_graph()
+    G = nx.tensor_product(G, K2)
+    assert nx.is_isomorphic(G, nx.cubical_graph())
+
+
+def test_tensor_product_random():
+    G = nx.erdos_renyi_graph(10, 2 / 10.0)
+    H = nx.erdos_renyi_graph(10, 2 / 10.0)
+    GH = nx.tensor_product(G, H)
+
+    for (u_G, u_H) in GH.nodes():
+        for (v_G, v_H) in GH.nodes():
+            if H.has_edge(u_H, v_H) and G.has_edge(u_G, v_G):
+                assert GH.has_edge((u_G, u_H), (v_G, v_H))
+            else:
+                assert not GH.has_edge((u_G, u_H), (v_G, v_H))
+
+
+def test_cartesian_product_multigraph():
+    G = nx.MultiGraph()
+    G.add_edge(1, 2, key=0)
+    G.add_edge(1, 2, key=1)
+    H = nx.MultiGraph()
+    H.add_edge(3, 4, key=0)
+    H.add_edge(3, 4, key=1)
+    GH = nx.cartesian_product(G, H)
+    assert set(GH) == {(1, 3), (2, 3), (2, 4), (1, 4)}
+    assert {(frozenset([u, v]), k) for u, v, k in GH.edges(keys=True)} == {
+        (frozenset([u, v]), k)
+        for u, v, k in [
+            ((1, 3), (2, 3), 0),
+            ((1, 3), (2, 3), 1),
+            ((1, 3), (1, 4), 0),
+            ((1, 3), (1, 4), 1),
+            ((2, 3), (2, 4), 0),
+            ((2, 3), (2, 4), 1),
+            ((2, 4), (1, 4), 0),
+            ((2, 4), (1, 4), 1),
+        ]
+    }
+
+
+def test_cartesian_product_raises():
+    with pytest.raises(nx.NetworkXError):
+        P = nx.cartesian_product(nx.DiGraph(), nx.Graph())
+
+
+def test_cartesian_product_null():
+    null = nx.null_graph()
+    empty10 = nx.empty_graph(10)
+    K3 = nx.complete_graph(3)
+    K10 = nx.complete_graph(10)
+    P3 = nx.path_graph(3)
+    P10 = nx.path_graph(10)
+    # null graph
+    G = nx.cartesian_product(null, null)
+    assert nx.is_isomorphic(G, null)
+    # null_graph X anything = null_graph and v.v.
+    G = nx.cartesian_product(null, empty10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.cartesian_product(null, K3)
+    assert nx.is_isomorphic(G, null)
+    G = nx.cartesian_product(null, K10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.cartesian_product(null, P3)
+    assert nx.is_isomorphic(G, null)
+    G = nx.cartesian_product(null, P10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.cartesian_product(empty10, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.cartesian_product(K3, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.cartesian_product(K10, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.cartesian_product(P3, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.cartesian_product(P10, null)
+    assert nx.is_isomorphic(G, null)
+
+
+def test_cartesian_product_size():
+    # order(GXH)=order(G)*order(H)
+    K5 = nx.complete_graph(5)
+    P5 = nx.path_graph(5)
+    K3 = nx.complete_graph(3)
+    G = nx.cartesian_product(P5, K3)
+    assert nx.number_of_nodes(G) == 5 * 3
+    assert nx.number_of_edges(G) == nx.number_of_edges(P5) * nx.number_of_nodes(
+        K3
+    ) + nx.number_of_edges(K3) * nx.number_of_nodes(P5)
+    G = nx.cartesian_product(K3, K5)
+    assert nx.number_of_nodes(G) == 3 * 5
+    assert nx.number_of_edges(G) == nx.number_of_edges(K5) * nx.number_of_nodes(
+        K3
+    ) + nx.number_of_edges(K3) * nx.number_of_nodes(K5)
+
+
+def test_cartesian_product_classic():
+    # test some classic product graphs
+    P2 = nx.path_graph(2)
+    P3 = nx.path_graph(3)
+    # cube = 2-path X 2-path
+    G = nx.cartesian_product(P2, P2)
+    G = nx.cartesian_product(P2, G)
+    assert nx.is_isomorphic(G, nx.cubical_graph())
+
+    # 3x3 grid
+    G = nx.cartesian_product(P3, P3)
+    assert nx.is_isomorphic(G, nx.grid_2d_graph(3, 3))
+
+
+def test_cartesian_product_random():
+    G = nx.erdos_renyi_graph(10, 2 / 10.0)
+    H = nx.erdos_renyi_graph(10, 2 / 10.0)
+    GH = nx.cartesian_product(G, H)
+
+    for (u_G, u_H) in GH.nodes():
+        for (v_G, v_H) in GH.nodes():
+            if (u_G == v_G and H.has_edge(u_H, v_H)) or (
+                u_H == v_H and G.has_edge(u_G, v_G)
+            ):
+                assert GH.has_edge((u_G, u_H), (v_G, v_H))
+            else:
+                assert not GH.has_edge((u_G, u_H), (v_G, v_H))
+
+
+def test_lexicographic_product_raises():
+    with pytest.raises(nx.NetworkXError):
+        P = nx.lexicographic_product(nx.DiGraph(), nx.Graph())
+
+
+def test_lexicographic_product_null():
+    null = nx.null_graph()
+    empty10 = nx.empty_graph(10)
+    K3 = nx.complete_graph(3)
+    K10 = nx.complete_graph(10)
+    P3 = nx.path_graph(3)
+    P10 = nx.path_graph(10)
+    # null graph
+    G = nx.lexicographic_product(null, null)
+    assert nx.is_isomorphic(G, null)
+    # null_graph X anything = null_graph and v.v.
+    G = nx.lexicographic_product(null, empty10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.lexicographic_product(null, K3)
+    assert nx.is_isomorphic(G, null)
+    G = nx.lexicographic_product(null, K10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.lexicographic_product(null, P3)
+    assert nx.is_isomorphic(G, null)
+    G = nx.lexicographic_product(null, P10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.lexicographic_product(empty10, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.lexicographic_product(K3, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.lexicographic_product(K10, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.lexicographic_product(P3, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.lexicographic_product(P10, null)
+    assert nx.is_isomorphic(G, null)
+
+
+def test_lexicographic_product_size():
+    K5 = nx.complete_graph(5)
+    P5 = nx.path_graph(5)
+    K3 = nx.complete_graph(3)
+    G = nx.lexicographic_product(P5, K3)
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.lexicographic_product(K3, K5)
+    assert nx.number_of_nodes(G) == 3 * 5
+
+
+def test_lexicographic_product_combinations():
+    P5 = nx.path_graph(5)
+    K3 = nx.complete_graph(3)
+    G = nx.lexicographic_product(P5, K3)
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.lexicographic_product(nx.MultiGraph(P5), K3)
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.lexicographic_product(P5, nx.MultiGraph(K3))
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.lexicographic_product(nx.MultiGraph(P5), nx.MultiGraph(K3))
+    assert nx.number_of_nodes(G) == 5 * 3
+
+    # No classic easily found classic results for lexicographic product
+
+
+def test_lexicographic_product_random():
+    G = nx.erdos_renyi_graph(10, 2 / 10.0)
+    H = nx.erdos_renyi_graph(10, 2 / 10.0)
+    GH = nx.lexicographic_product(G, H)
+
+    for (u_G, u_H) in GH.nodes():
+        for (v_G, v_H) in GH.nodes():
+            if G.has_edge(u_G, v_G) or (u_G == v_G and H.has_edge(u_H, v_H)):
+                assert GH.has_edge((u_G, u_H), (v_G, v_H))
+            else:
+                assert not GH.has_edge((u_G, u_H), (v_G, v_H))
+
+
+def test_strong_product_raises():
+    with pytest.raises(nx.NetworkXError):
+        P = nx.strong_product(nx.DiGraph(), nx.Graph())
+
+
+def test_strong_product_null():
+    null = nx.null_graph()
+    empty10 = nx.empty_graph(10)
+    K3 = nx.complete_graph(3)
+    K10 = nx.complete_graph(10)
+    P3 = nx.path_graph(3)
+    P10 = nx.path_graph(10)
+    # null graph
+    G = nx.strong_product(null, null)
+    assert nx.is_isomorphic(G, null)
+    # null_graph X anything = null_graph and v.v.
+    G = nx.strong_product(null, empty10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.strong_product(null, K3)
+    assert nx.is_isomorphic(G, null)
+    G = nx.strong_product(null, K10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.strong_product(null, P3)
+    assert nx.is_isomorphic(G, null)
+    G = nx.strong_product(null, P10)
+    assert nx.is_isomorphic(G, null)
+    G = nx.strong_product(empty10, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.strong_product(K3, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.strong_product(K10, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.strong_product(P3, null)
+    assert nx.is_isomorphic(G, null)
+    G = nx.strong_product(P10, null)
+    assert nx.is_isomorphic(G, null)
+
+
+def test_strong_product_size():
+    K5 = nx.complete_graph(5)
+    P5 = nx.path_graph(5)
+    K3 = nx.complete_graph(3)
+    G = nx.strong_product(P5, K3)
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.strong_product(K3, K5)
+    assert nx.number_of_nodes(G) == 3 * 5
+
+
+def test_strong_product_combinations():
+    P5 = nx.path_graph(5)
+    K3 = nx.complete_graph(3)
+    G = nx.strong_product(P5, K3)
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.strong_product(nx.MultiGraph(P5), K3)
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.strong_product(P5, nx.MultiGraph(K3))
+    assert nx.number_of_nodes(G) == 5 * 3
+    G = nx.strong_product(nx.MultiGraph(P5), nx.MultiGraph(K3))
+    assert nx.number_of_nodes(G) == 5 * 3
+
+    # No classic easily found classic results for strong product
+
+
+def test_strong_product_random():
+    G = nx.erdos_renyi_graph(10, 2 / 10.0)
+    H = nx.erdos_renyi_graph(10, 2 / 10.0)
+    GH = nx.strong_product(G, H)
+
+    for (u_G, u_H) in GH.nodes():
+        for (v_G, v_H) in GH.nodes():
+            if (
+                (u_G == v_G and H.has_edge(u_H, v_H))
+                or (u_H == v_H and G.has_edge(u_G, v_G))
+                or (G.has_edge(u_G, v_G) and H.has_edge(u_H, v_H))
+            ):
+                assert GH.has_edge((u_G, u_H), (v_G, v_H))
+            else:
+                assert not GH.has_edge((u_G, u_H), (v_G, v_H))
+
+
+def test_graph_power_raises():
+    with pytest.raises(nx.NetworkXNotImplemented):
+        nx.power(nx.MultiDiGraph(), 2)
+
+
+def test_graph_power():
+    # wikipedia example for graph power
+    G = nx.cycle_graph(7)
+    G.add_edge(6, 7)
+    G.add_edge(7, 8)
+    G.add_edge(8, 9)
+    G.add_edge(9, 2)
+    H = nx.power(G, 2)
+
+    assert edges_equal(
+        list(H.edges()),
+        [
+            (0, 1),
+            (0, 2),
+            (0, 5),
+            (0, 6),
+            (0, 7),
+            (1, 9),
+            (1, 2),
+            (1, 3),
+            (1, 6),
+            (2, 3),
+            (2, 4),
+            (2, 8),
+            (2, 9),
+            (3, 4),
+            (3, 5),
+            (3, 9),
+            (4, 5),
+            (4, 6),
+            (5, 6),
+            (5, 7),
+            (6, 7),
+            (6, 8),
+            (7, 8),
+            (7, 9),
+            (8, 9),
+        ],
+    )
+
+
+def test_graph_power_negative():
+    with pytest.raises(ValueError):
+        nx.power(nx.Graph(), -1)
+
+
+def test_rooted_product_raises():
+    with pytest.raises(nx.NetworkXError):
+        nx.rooted_product(nx.Graph(), nx.path_graph(2), 10)
+
+
+def test_rooted_product():
+    G = nx.cycle_graph(5)
+    H = nx.Graph()
+    H.add_edges_from([("a", "b"), ("b", "c"), ("b", "d")])
+    R = nx.rooted_product(G, H, "a")
+    assert len(R) == len(G) * len(H)
+    assert R.size() == G.size() + len(G) * H.size()
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_unary.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_unary.py
new file mode 100644
index 0000000..d68e55c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_unary.py
@@ -0,0 +1,55 @@
+import pytest
+
+import networkx as nx
+
+
+def test_complement():
+    null = nx.null_graph()
+    empty1 = nx.empty_graph(1)
+    empty10 = nx.empty_graph(10)
+    K3 = nx.complete_graph(3)
+    K5 = nx.complete_graph(5)
+    K10 = nx.complete_graph(10)
+    P2 = nx.path_graph(2)
+    P3 = nx.path_graph(3)
+    P5 = nx.path_graph(5)
+    P10 = nx.path_graph(10)
+    # complement of the complete graph is empty
+
+    G = nx.complement(K3)
+    assert nx.is_isomorphic(G, nx.empty_graph(3))
+    G = nx.complement(K5)
+    assert nx.is_isomorphic(G, nx.empty_graph(5))
+    # for any G, G=complement(complement(G))
+    P3cc = nx.complement(nx.complement(P3))
+    assert nx.is_isomorphic(P3, P3cc)
+    nullcc = nx.complement(nx.complement(null))
+    assert nx.is_isomorphic(null, nullcc)
+    b = nx.bull_graph()
+    bcc = nx.complement(nx.complement(b))
+    assert nx.is_isomorphic(b, bcc)
+
+
+def test_complement_2():
+    G1 = nx.DiGraph()
+    G1.add_edge("A", "B")
+    G1.add_edge("A", "C")
+    G1.add_edge("A", "D")
+    G1C = nx.complement(G1)
+    assert sorted(G1C.edges()) == [
+        ("B", "A"),
+        ("B", "C"),
+        ("B", "D"),
+        ("C", "A"),
+        ("C", "B"),
+        ("C", "D"),
+        ("D", "A"),
+        ("D", "B"),
+        ("D", "C"),
+    ]
+
+
+def test_reverse1():
+    # Other tests for reverse are done by the DiGraph and MultiDigraph.
+    G1 = nx.Graph()
+    pytest.raises(nx.NetworkXError, nx.reverse, G1)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/unary.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/unary.py
new file mode 100644
index 0000000..f522956
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/operators/unary.py
@@ -0,0 +1,74 @@
+"""Unary operations on graphs"""
+import networkx as nx
+
+__all__ = ["complement", "reverse"]
+
+
+def complement(G):
+    """Returns the graph complement of G.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    Returns
+    -------
+    GC : A new graph.
+
+    Notes
+    -----
+    Note that `complement` does not create self-loops and also
+    does not produce parallel edges for MultiGraphs.
+
+    Graph, node, and edge data are not propagated to the new graph.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (2, 3), (3, 4), (3, 5)])
+    >>> G_complement = nx.complement(G)
+    >>> G_complement.edges() # This shows the edges of the complemented graph
+    EdgeView([(1, 4), (1, 5), (2, 4), (2, 5), (4, 5)])
+
+    """
+    R = G.__class__()
+    R.add_nodes_from(G)
+    R.add_edges_from(
+        ((n, n2) for n, nbrs in G.adjacency() for n2 in G if n2 not in nbrs if n != n2)
+    )
+    return R
+
+
+def reverse(G, copy=True):
+    """Returns the reverse directed graph of G.
+
+    Parameters
+    ----------
+    G : directed graph
+        A NetworkX directed graph
+    copy : bool
+        If True, then a new graph is returned. If False, then the graph is
+        reversed in place.
+
+    Returns
+    -------
+    H : directed graph
+        The reversed G.
+
+    Raises
+    ------
+    NetworkXError
+        If graph is undirected.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph([(1, 2), (1, 3), (2, 3), (3, 4), (3, 5)])
+    >>> G_reversed = nx.reverse(G)
+    >>> G_reversed.edges()
+    OutEdgeView([(2, 1), (3, 1), (3, 2), (4, 3), (5, 3)])
+
+    """
+    if not G.is_directed():
+        raise nx.NetworkXError("Cannot reverse an undirected graph.")
+    else:
+        return G.reverse(copy=copy)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/planar_drawing.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/planar_drawing.py
new file mode 100644
index 0000000..acbef23
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/planar_drawing.py
@@ -0,0 +1,464 @@
+from collections import defaultdict
+
+import networkx as nx
+
+__all__ = ["combinatorial_embedding_to_pos"]
+
+
+def combinatorial_embedding_to_pos(embedding, fully_triangulate=False):
+    """Assigns every node a (x, y) position based on the given embedding
+
+    The algorithm iteratively inserts nodes of the input graph in a certain
+    order and rearranges previously inserted nodes so that the planar drawing
+    stays valid. This is done efficiently by only maintaining relative
+    positions during the node placements and calculating the absolute positions
+    at the end. For more information see [1]_.
+
+    Parameters
+    ----------
+    embedding : nx.PlanarEmbedding
+        This defines the order of the edges
+
+    fully_triangulate : bool
+        If set to True the algorithm adds edges to a copy of the input
+        embedding and makes it chordal.
+
+    Returns
+    -------
+    pos : dict
+        Maps each node to a tuple that defines the (x, y) position
+
+    References
+    ----------
+    .. [1] M. Chrobak and T.H. Payne:
+        A Linear-time Algorithm for Drawing a Planar Graph on a Grid 1989
+        http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.51.6677
+
+    """
+    if len(embedding.nodes()) < 4:
+        # Position the node in any triangle
+        default_positions = [(0, 0), (2, 0), (1, 1)]
+        pos = {}
+        for i, v in enumerate(embedding.nodes()):
+            pos[v] = default_positions[i]
+        return pos
+
+    embedding, outer_face = triangulate_embedding(embedding, fully_triangulate)
+
+    # The following dicts map a node to another node
+    # If a node is not in the key set it means that the node is not yet in G_k
+    # If a node maps to None then the corresponding subtree does not exist
+    left_t_child = {}
+    right_t_child = {}
+
+    # The following dicts map a node to an integer
+    delta_x = {}
+    y_coordinate = {}
+
+    node_list = get_canonical_ordering(embedding, outer_face)
+
+    # 1. Phase: Compute relative positions
+
+    # Initialization
+    v1, v2, v3 = node_list[0][0], node_list[1][0], node_list[2][0]
+
+    delta_x[v1] = 0
+    y_coordinate[v1] = 0
+    right_t_child[v1] = v3
+    left_t_child[v1] = None
+
+    delta_x[v2] = 1
+    y_coordinate[v2] = 0
+    right_t_child[v2] = None
+    left_t_child[v2] = None
+
+    delta_x[v3] = 1
+    y_coordinate[v3] = 1
+    right_t_child[v3] = v2
+    left_t_child[v3] = None
+
+    for k in range(3, len(node_list)):
+        vk, contour_neighbors = node_list[k]
+        wp = contour_neighbors[0]
+        wp1 = contour_neighbors[1]
+        wq = contour_neighbors[-1]
+        wq1 = contour_neighbors[-2]
+        adds_mult_tri = len(contour_neighbors) > 2
+
+        # Stretch gaps:
+        delta_x[wp1] += 1
+        delta_x[wq] += 1
+
+        delta_x_wp_wq = sum(delta_x[x] for x in contour_neighbors[1:])
+
+        # Adjust offsets
+        delta_x[vk] = (-y_coordinate[wp] + delta_x_wp_wq + y_coordinate[wq]) // 2
+        y_coordinate[vk] = (y_coordinate[wp] + delta_x_wp_wq + y_coordinate[wq]) // 2
+        delta_x[wq] = delta_x_wp_wq - delta_x[vk]
+        if adds_mult_tri:
+            delta_x[wp1] -= delta_x[vk]
+
+        # Install v_k:
+        right_t_child[wp] = vk
+        right_t_child[vk] = wq
+        if adds_mult_tri:
+            left_t_child[vk] = wp1
+            right_t_child[wq1] = None
+        else:
+            left_t_child[vk] = None
+
+    # 2. Phase: Set absolute positions
+    pos = dict()
+    pos[v1] = (0, y_coordinate[v1])
+    remaining_nodes = [v1]
+    while remaining_nodes:
+        parent_node = remaining_nodes.pop()
+
+        # Calculate position for left child
+        set_position(
+            parent_node, left_t_child, remaining_nodes, delta_x, y_coordinate, pos
+        )
+        # Calculate position for right child
+        set_position(
+            parent_node, right_t_child, remaining_nodes, delta_x, y_coordinate, pos
+        )
+    return pos
+
+
+def set_position(parent, tree, remaining_nodes, delta_x, y_coordinate, pos):
+    """Helper method to calculate the absolute position of nodes."""
+    child = tree[parent]
+    parent_node_x = pos[parent][0]
+    if child is not None:
+        # Calculate pos of child
+        child_x = parent_node_x + delta_x[child]
+        pos[child] = (child_x, y_coordinate[child])
+        # Remember to calculate pos of its children
+        remaining_nodes.append(child)
+
+
+def get_canonical_ordering(embedding, outer_face):
+    """Returns a canonical ordering of the nodes
+
+    The canonical ordering of nodes (v1, ..., vn) must fulfill the following
+    conditions:
+    (See Lemma 1 in [2]_)
+
+    - For the subgraph G_k of the input graph induced by v1, ..., vk it holds:
+        - 2-connected
+        - internally triangulated
+        - the edge (v1, v2) is part of the outer face
+    - For a node v(k+1) the following holds:
+        - The node v(k+1) is part of the outer face of G_k
+        - It has at least two neighbors in G_k
+        - All neighbors of v(k+1) in G_k lie consecutively on the outer face of
+          G_k (excluding the edge (v1, v2)).
+
+    The algorithm used here starts with G_n (containing all nodes). It first
+    selects the nodes v1 and v2. And then tries to find the order of the other
+    nodes by checking which node can be removed in order to fulfill the
+    conditions mentioned above. This is done by calculating the number of
+    chords of nodes on the outer face. For more information see [1]_.
+
+    Parameters
+    ----------
+    embedding : nx.PlanarEmbedding
+        The embedding must be triangulated
+    outer_face : list
+        The nodes on the outer face of the graph
+
+    Returns
+    -------
+    ordering : list
+        A list of tuples `(vk, wp_wq)`. Here `vk` is the node at this position
+        in the canonical ordering. The element `wp_wq` is a list of nodes that
+        make up the outer face of G_k.
+
+    References
+    ----------
+    .. [1] Steven Chaplick.
+        Canonical Orders of Planar Graphs and (some of) Their Applications 2015
+        https://wuecampus2.uni-wuerzburg.de/moodle/pluginfile.php/545727/mod_resource/content/0/vg-ss15-vl03-canonical-orders-druckversion.pdf
+    .. [2] M. Chrobak and T.H. Payne:
+        A Linear-time Algorithm for Drawing a Planar Graph on a Grid 1989
+        http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.51.6677
+
+    """
+    v1 = outer_face[0]
+    v2 = outer_face[1]
+    chords = defaultdict(int)  # Maps nodes to the number of their chords
+    marked_nodes = set()
+    ready_to_pick = set(outer_face)
+
+    # Initialize outer_face_ccw_nbr (do not include v1 -> v2)
+    outer_face_ccw_nbr = {}
+    prev_nbr = v2
+    for idx in range(2, len(outer_face)):
+        outer_face_ccw_nbr[prev_nbr] = outer_face[idx]
+        prev_nbr = outer_face[idx]
+    outer_face_ccw_nbr[prev_nbr] = v1
+
+    # Initialize outer_face_cw_nbr (do not include v2 -> v1)
+    outer_face_cw_nbr = {}
+    prev_nbr = v1
+    for idx in range(len(outer_face) - 1, 0, -1):
+        outer_face_cw_nbr[prev_nbr] = outer_face[idx]
+        prev_nbr = outer_face[idx]
+
+    def is_outer_face_nbr(x, y):
+        if x not in outer_face_ccw_nbr:
+            return outer_face_cw_nbr[x] == y
+        if x not in outer_face_cw_nbr:
+            return outer_face_ccw_nbr[x] == y
+        return outer_face_ccw_nbr[x] == y or outer_face_cw_nbr[x] == y
+
+    def is_on_outer_face(x):
+        return x not in marked_nodes and (x in outer_face_ccw_nbr.keys() or x == v1)
+
+    # Initialize number of chords
+    for v in outer_face:
+        for nbr in embedding.neighbors_cw_order(v):
+            if is_on_outer_face(nbr) and not is_outer_face_nbr(v, nbr):
+                chords[v] += 1
+                ready_to_pick.discard(v)
+
+    # Initialize canonical_ordering
+    canonical_ordering = [None] * len(embedding.nodes())  # type: list
+    canonical_ordering[0] = (v1, [])
+    canonical_ordering[1] = (v2, [])
+    ready_to_pick.discard(v1)
+    ready_to_pick.discard(v2)
+
+    for k in range(len(embedding.nodes()) - 1, 1, -1):
+        # 1. Pick v from ready_to_pick
+        v = ready_to_pick.pop()
+        marked_nodes.add(v)
+
+        # v has exactly two neighbors on the outer face (wp and wq)
+        wp = None
+        wq = None
+        # Iterate over neighbors of v to find wp and wq
+        nbr_iterator = iter(embedding.neighbors_cw_order(v))
+        while True:
+            nbr = next(nbr_iterator)
+            if nbr in marked_nodes:
+                # Only consider nodes that are not yet removed
+                continue
+            if is_on_outer_face(nbr):
+                # nbr is either wp or wq
+                if nbr == v1:
+                    wp = v1
+                elif nbr == v2:
+                    wq = v2
+                else:
+                    if outer_face_cw_nbr[nbr] == v:
+                        # nbr is wp
+                        wp = nbr
+                    else:
+                        # nbr is wq
+                        wq = nbr
+            if wp is not None and wq is not None:
+                # We don't need to iterate any further
+                break
+
+        # Obtain new nodes on outer face (neighbors of v from wp to wq)
+        wp_wq = [wp]
+        nbr = wp
+        while nbr != wq:
+            # Get next neighbor (clockwise on the outer face)
+            next_nbr = embedding[v][nbr]["ccw"]
+            wp_wq.append(next_nbr)
+            # Update outer face
+            outer_face_cw_nbr[nbr] = next_nbr
+            outer_face_ccw_nbr[next_nbr] = nbr
+            # Move to next neighbor of v
+            nbr = next_nbr
+
+        if len(wp_wq) == 2:
+            # There was a chord between wp and wq, decrease number of chords
+            chords[wp] -= 1
+            if chords[wp] == 0:
+                ready_to_pick.add(wp)
+            chords[wq] -= 1
+            if chords[wq] == 0:
+                ready_to_pick.add(wq)
+        else:
+            # Update all chords involving w_(p+1) to w_(q-1)
+            new_face_nodes = set(wp_wq[1:-1])
+            for w in new_face_nodes:
+                # If we do not find a chord for w later we can pick it next
+                ready_to_pick.add(w)
+                for nbr in embedding.neighbors_cw_order(w):
+                    if is_on_outer_face(nbr) and not is_outer_face_nbr(w, nbr):
+                        # There is a chord involving w
+                        chords[w] += 1
+                        ready_to_pick.discard(w)
+                        if nbr not in new_face_nodes:
+                            # Also increase chord for the neighbor
+                            # We only iterator over new_face_nodes
+                            chords[nbr] += 1
+                            ready_to_pick.discard(nbr)
+        # Set the canonical ordering node and the list of contour neighbors
+        canonical_ordering[k] = (v, wp_wq)
+
+    return canonical_ordering
+
+
+def triangulate_face(embedding, v1, v2):
+    """Triangulates the face given by half edge (v, w)
+
+    Parameters
+    ----------
+    embedding : nx.PlanarEmbedding
+    v1 : node
+        The half-edge (v1, v2) belongs to the face that gets triangulated
+    v2 : node
+    """
+    _, v3 = embedding.next_face_half_edge(v1, v2)
+    _, v4 = embedding.next_face_half_edge(v2, v3)
+    if v1 == v2 or v1 == v3:
+        # The component has less than 3 nodes
+        return
+    while v1 != v4:
+        # Add edge if not already present on other side
+        if embedding.has_edge(v1, v3):
+            # Cannot triangulate at this position
+            v1, v2, v3 = v2, v3, v4
+        else:
+            # Add edge for triangulation
+            embedding.add_half_edge_cw(v1, v3, v2)
+            embedding.add_half_edge_ccw(v3, v1, v2)
+            v1, v2, v3 = v1, v3, v4
+        # Get next node
+        _, v4 = embedding.next_face_half_edge(v2, v3)
+
+
+def triangulate_embedding(embedding, fully_triangulate=True):
+    """Triangulates the embedding.
+
+    Traverses faces of the embedding and adds edges to a copy of the
+    embedding to triangulate it.
+    The method also ensures that the resulting graph is 2-connected by adding
+    edges if the same vertex is contained twice on a path around a face.
+
+    Parameters
+    ----------
+    embedding : nx.PlanarEmbedding
+        The input graph must contain at least 3 nodes.
+
+    fully_triangulate : bool
+        If set to False the face with the most nodes is chooses as outer face.
+        This outer face does not get triangulated.
+
+    Returns
+    -------
+    (embedding, outer_face) : (nx.PlanarEmbedding, list) tuple
+        The element `embedding` is a new embedding containing all edges from
+        the input embedding and the additional edges to triangulate the graph.
+        The element `outer_face` is a list of nodes that lie on the outer face.
+        If the graph is fully triangulated these are three arbitrary connected
+        nodes.
+
+    """
+    if len(embedding.nodes) <= 1:
+        return embedding, list(embedding.nodes)
+    embedding = nx.PlanarEmbedding(embedding)
+
+    # Get a list with a node for each connected component
+    component_nodes = [next(iter(x)) for x in nx.connected_components(embedding)]
+
+    # 1. Make graph a single component (add edge between components)
+    for i in range(len(component_nodes) - 1):
+        v1 = component_nodes[i]
+        v2 = component_nodes[i + 1]
+        embedding.connect_components(v1, v2)
+
+    # 2. Calculate faces, ensure 2-connectedness and determine outer face
+    outer_face = []  # A face with the most number of nodes
+    face_list = []
+    edges_visited = set()  # Used to keep track of already visited faces
+    for v in embedding.nodes():
+        for w in embedding.neighbors_cw_order(v):
+            new_face = make_bi_connected(embedding, v, w, edges_visited)
+            if new_face:
+                # Found a new face
+                face_list.append(new_face)
+                if len(new_face) > len(outer_face):
+                    # The face is a candidate to be the outer face
+                    outer_face = new_face
+
+    # 3. Triangulate (internal) faces
+    for face in face_list:
+        if face is not outer_face or fully_triangulate:
+            # Triangulate this face
+            triangulate_face(embedding, face[0], face[1])
+
+    if fully_triangulate:
+        v1 = outer_face[0]
+        v2 = outer_face[1]
+        v3 = embedding[v2][v1]["ccw"]
+        outer_face = [v1, v2, v3]
+
+    return embedding, outer_face
+
+
+def make_bi_connected(embedding, starting_node, outgoing_node, edges_counted):
+    """Triangulate a face and make it 2-connected
+
+    This method also adds all edges on the face to `edges_counted`.
+
+    Parameters
+    ----------
+    embedding: nx.PlanarEmbedding
+        The embedding that defines the faces
+    starting_node : node
+        A node on the face
+    outgoing_node : node
+        A node such that the half edge (starting_node, outgoing_node) belongs
+        to the face
+    edges_counted: set
+        Set of all half-edges that belong to a face that have been visited
+
+    Returns
+    -------
+    face_nodes: list
+        A list of all nodes at the border of this face
+    """
+
+    # Check if the face has already been calculated
+    if (starting_node, outgoing_node) in edges_counted:
+        # This face was already counted
+        return []
+    edges_counted.add((starting_node, outgoing_node))
+
+    # Add all edges to edges_counted which have this face to their left
+    v1 = starting_node
+    v2 = outgoing_node
+    face_list = [starting_node]  # List of nodes around the face
+    face_set = set(face_list)  # Set for faster queries
+    _, v3 = embedding.next_face_half_edge(v1, v2)
+
+    # Move the nodes v1, v2, v3 around the face:
+    while v2 != starting_node or v3 != outgoing_node:
+        if v1 == v2:
+            raise nx.NetworkXException("Invalid half-edge")
+        # cycle is not completed yet
+        if v2 in face_set:
+            # v2 encountered twice: Add edge to ensure 2-connectedness
+            embedding.add_half_edge_cw(v1, v3, v2)
+            embedding.add_half_edge_ccw(v3, v1, v2)
+            edges_counted.add((v2, v3))
+            edges_counted.add((v3, v1))
+            v2 = v1
+        else:
+            face_set.add(v2)
+            face_list.append(v2)
+
+        # set next edge
+        v1 = v2
+        v2, v3 = embedding.next_face_half_edge(v2, v3)
+
+        # remember that this edge has been counted
+        edges_counted.add((v1, v2))
+
+    return face_list
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/planarity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/planarity.py
new file mode 100644
index 0000000..bcde0f3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/planarity.py
@@ -0,0 +1,1174 @@
+from collections import defaultdict
+
+import networkx as nx
+
+__all__ = ["check_planarity", "is_planar", "PlanarEmbedding"]
+
+
+def is_planar(G):
+    """Returns True if and only if `G` is planar.
+
+    A graph is *planar* iff it can be drawn in a plane without
+    any edge intersections.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    bool
+       Whether the graph is planar.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2)])
+    >>> nx.is_planar(G)
+    True
+    >>> nx.is_planar(nx.complete_graph(5))
+    False
+
+    See Also
+    --------
+    check_planarity :
+        Check if graph is planar *and* return a `PlanarEmbedding` instance if True.
+    """
+
+    return check_planarity(G, counterexample=False)[0]
+
+
+def check_planarity(G, counterexample=False):
+    """Check if a graph is planar and return a counterexample or an embedding.
+
+    A graph is planar iff it can be drawn in a plane without
+    any edge intersections.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+    counterexample : bool
+        A Kuratowski subgraph (to proof non planarity) is only returned if set
+        to true.
+
+    Returns
+    -------
+    (is_planar, certificate) : (bool, NetworkX graph) tuple
+        is_planar is true if the graph is planar.
+        If the graph is planar `certificate` is a PlanarEmbedding
+        otherwise it is a Kuratowski subgraph.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2)])
+    >>> is_planar, P = nx.check_planarity(G)
+    >>> print(is_planar)
+    True
+
+    When `G` is planar, a `PlanarEmbedding` instance is returned:
+
+    >>> P.get_data()
+    {0: [1, 2], 1: [0], 2: [0]}
+
+    Notes
+    -----
+    A (combinatorial) embedding consists of cyclic orderings of the incident
+    edges at each vertex. Given such an embedding there are multiple approaches
+    discussed in literature to drawing the graph (subject to various
+    constraints, e.g. integer coordinates), see e.g. [2].
+
+    The planarity check algorithm and extraction of the combinatorial embedding
+    is based on the Left-Right Planarity Test [1].
+
+    A counterexample is only generated if the corresponding parameter is set,
+    because the complexity of the counterexample generation is higher.
+
+    See also
+    --------
+    is_planar :
+        Check for planarity without creating a `PlanarEmbedding` or counterexample.
+
+    References
+    ----------
+    .. [1] Ulrik Brandes:
+        The Left-Right Planarity Test
+        2009
+        http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.217.9208
+    .. [2] Takao Nishizeki, Md Saidur Rahman:
+        Planar graph drawing
+        Lecture Notes Series on Computing: Volume 12
+        2004
+    """
+
+    planarity_state = LRPlanarity(G)
+    embedding = planarity_state.lr_planarity()
+    if embedding is None:
+        # graph is not planar
+        if counterexample:
+            return False, get_counterexample(G)
+        else:
+            return False, None
+    else:
+        # graph is planar
+        return True, embedding
+
+
+def check_planarity_recursive(G, counterexample=False):
+    """Recursive version of :meth:`check_planarity`."""
+    planarity_state = LRPlanarity(G)
+    embedding = planarity_state.lr_planarity_recursive()
+    if embedding is None:
+        # graph is not planar
+        if counterexample:
+            return False, get_counterexample_recursive(G)
+        else:
+            return False, None
+    else:
+        # graph is planar
+        return True, embedding
+
+
+def get_counterexample(G):
+    """Obtains a Kuratowski subgraph.
+
+    Raises nx.NetworkXException if G is planar.
+
+    The function removes edges such that the graph is still not planar.
+    At some point the removal of any edge would make the graph planar.
+    This subgraph must be a Kuratowski subgraph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    subgraph : NetworkX graph
+        A Kuratowski subgraph that proves that G is not planar.
+
+    """
+    # copy graph
+    G = nx.Graph(G)
+
+    if check_planarity(G)[0]:
+        raise nx.NetworkXException("G is planar - no counter example.")
+
+    # find Kuratowski subgraph
+    subgraph = nx.Graph()
+    for u in G:
+        nbrs = list(G[u])
+        for v in nbrs:
+            G.remove_edge(u, v)
+            if check_planarity(G)[0]:
+                G.add_edge(u, v)
+                subgraph.add_edge(u, v)
+
+    return subgraph
+
+
+def get_counterexample_recursive(G):
+    """Recursive version of :meth:`get_counterexample`."""
+
+    # copy graph
+    G = nx.Graph(G)
+
+    if check_planarity_recursive(G)[0]:
+        raise nx.NetworkXException("G is planar - no counter example.")
+
+    # find Kuratowski subgraph
+    subgraph = nx.Graph()
+    for u in G:
+        nbrs = list(G[u])
+        for v in nbrs:
+            G.remove_edge(u, v)
+            if check_planarity_recursive(G)[0]:
+                G.add_edge(u, v)
+                subgraph.add_edge(u, v)
+
+    return subgraph
+
+
+class Interval:
+    """Represents a set of return edges.
+
+    All return edges in an interval induce a same constraint on the contained
+    edges, which means that all edges must either have a left orientation or
+    all edges must have a right orientation.
+    """
+
+    def __init__(self, low=None, high=None):
+        self.low = low
+        self.high = high
+
+    def empty(self):
+        """Check if the interval is empty"""
+        return self.low is None and self.high is None
+
+    def copy(self):
+        """Returns a copy of this interval"""
+        return Interval(self.low, self.high)
+
+    def conflicting(self, b, planarity_state):
+        """Returns True if interval I conflicts with edge b"""
+        return (
+            not self.empty()
+            and planarity_state.lowpt[self.high] > planarity_state.lowpt[b]
+        )
+
+
+class ConflictPair:
+    """Represents a different constraint between two intervals.
+
+    The edges in the left interval must have a different orientation than
+    the one in the right interval.
+    """
+
+    def __init__(self, left=Interval(), right=Interval()):
+        self.left = left
+        self.right = right
+
+    def swap(self):
+        """Swap left and right intervals"""
+        temp = self.left
+        self.left = self.right
+        self.right = temp
+
+    def lowest(self, planarity_state):
+        """Returns the lowest lowpoint of a conflict pair"""
+        if self.left.empty():
+            return planarity_state.lowpt[self.right.low]
+        if self.right.empty():
+            return planarity_state.lowpt[self.left.low]
+        return min(
+            planarity_state.lowpt[self.left.low], planarity_state.lowpt[self.right.low]
+        )
+
+
+def top_of_stack(l):
+    """Returns the element on top of the stack."""
+    if not l:
+        return None
+    return l[-1]
+
+
+class LRPlanarity:
+    """A class to maintain the state during planarity check."""
+
+    __slots__ = [
+        "G",
+        "roots",
+        "height",
+        "lowpt",
+        "lowpt2",
+        "nesting_depth",
+        "parent_edge",
+        "DG",
+        "adjs",
+        "ordered_adjs",
+        "ref",
+        "side",
+        "S",
+        "stack_bottom",
+        "lowpt_edge",
+        "left_ref",
+        "right_ref",
+        "embedding",
+    ]
+
+    def __init__(self, G):
+        # copy G without adding self-loops
+        self.G = nx.Graph()
+        self.G.add_nodes_from(G.nodes)
+        for e in G.edges:
+            if e[0] != e[1]:
+                self.G.add_edge(e[0], e[1])
+
+        self.roots = []
+
+        # distance from tree root
+        self.height = defaultdict(lambda: None)
+
+        self.lowpt = {}  # height of lowest return point of an edge
+        self.lowpt2 = {}  # height of second lowest return point
+        self.nesting_depth = {}  # for nesting order
+
+        # None -> missing edge
+        self.parent_edge = defaultdict(lambda: None)
+
+        # oriented DFS graph
+        self.DG = nx.DiGraph()
+        self.DG.add_nodes_from(G.nodes)
+
+        self.adjs = {}
+        self.ordered_adjs = {}
+
+        self.ref = defaultdict(lambda: None)
+        self.side = defaultdict(lambda: 1)
+
+        # stack of conflict pairs
+        self.S = []
+        self.stack_bottom = {}
+        self.lowpt_edge = {}
+
+        self.left_ref = {}
+        self.right_ref = {}
+
+        self.embedding = PlanarEmbedding()
+
+    def lr_planarity(self):
+        """Execute the LR planarity test.
+
+        Returns
+        -------
+        embedding : dict
+            If the graph is planar an embedding is returned. Otherwise None.
+        """
+        if self.G.order() > 2 and self.G.size() > 3 * self.G.order() - 6:
+            # graph is not planar
+            return None
+
+        # make adjacency lists for dfs
+        for v in self.G:
+            self.adjs[v] = list(self.G[v])
+
+        # orientation of the graph by depth first search traversal
+        for v in self.G:
+            if self.height[v] is None:
+                self.height[v] = 0
+                self.roots.append(v)
+                self.dfs_orientation(v)
+
+        # Free no longer used variables
+        self.G = None
+        self.lowpt2 = None
+        self.adjs = None
+
+        # testing
+        for v in self.DG:  # sort the adjacency lists by nesting depth
+            # note: this sorting leads to non linear time
+            self.ordered_adjs[v] = sorted(
+                self.DG[v], key=lambda x: self.nesting_depth[(v, x)]
+            )
+        for v in self.roots:
+            if not self.dfs_testing(v):
+                return None
+
+        # Free no longer used variables
+        self.height = None
+        self.lowpt = None
+        self.S = None
+        self.stack_bottom = None
+        self.lowpt_edge = None
+
+        for e in self.DG.edges:
+            self.nesting_depth[e] = self.sign(e) * self.nesting_depth[e]
+
+        self.embedding.add_nodes_from(self.DG.nodes)
+        for v in self.DG:
+            # sort the adjacency lists again
+            self.ordered_adjs[v] = sorted(
+                self.DG[v], key=lambda x: self.nesting_depth[(v, x)]
+            )
+            # initialize the embedding
+            previous_node = None
+            for w in self.ordered_adjs[v]:
+                self.embedding.add_half_edge_cw(v, w, previous_node)
+                previous_node = w
+
+        # Free no longer used variables
+        self.DG = None
+        self.nesting_depth = None
+        self.ref = None
+
+        # compute the complete embedding
+        for v in self.roots:
+            self.dfs_embedding(v)
+
+        # Free no longer used variables
+        self.roots = None
+        self.parent_edge = None
+        self.ordered_adjs = None
+        self.left_ref = None
+        self.right_ref = None
+        self.side = None
+
+        return self.embedding
+
+    def lr_planarity_recursive(self):
+        """Recursive version of :meth:`lr_planarity`."""
+        if self.G.order() > 2 and self.G.size() > 3 * self.G.order() - 6:
+            # graph is not planar
+            return None
+
+        # orientation of the graph by depth first search traversal
+        for v in self.G:
+            if self.height[v] is None:
+                self.height[v] = 0
+                self.roots.append(v)
+                self.dfs_orientation_recursive(v)
+
+        # Free no longer used variable
+        self.G = None
+
+        # testing
+        for v in self.DG:  # sort the adjacency lists by nesting depth
+            # note: this sorting leads to non linear time
+            self.ordered_adjs[v] = sorted(
+                self.DG[v], key=lambda x: self.nesting_depth[(v, x)]
+            )
+        for v in self.roots:
+            if not self.dfs_testing_recursive(v):
+                return None
+
+        for e in self.DG.edges:
+            self.nesting_depth[e] = self.sign_recursive(e) * self.nesting_depth[e]
+
+        self.embedding.add_nodes_from(self.DG.nodes)
+        for v in self.DG:
+            # sort the adjacency lists again
+            self.ordered_adjs[v] = sorted(
+                self.DG[v], key=lambda x: self.nesting_depth[(v, x)]
+            )
+            # initialize the embedding
+            previous_node = None
+            for w in self.ordered_adjs[v]:
+                self.embedding.add_half_edge_cw(v, w, previous_node)
+                previous_node = w
+
+        # compute the complete embedding
+        for v in self.roots:
+            self.dfs_embedding_recursive(v)
+
+        return self.embedding
+
+    def dfs_orientation(self, v):
+        """Orient the graph by DFS, compute lowpoints and nesting order."""
+        # the recursion stack
+        dfs_stack = [v]
+        # index of next edge to handle in adjacency list of each node
+        ind = defaultdict(lambda: 0)
+        # boolean to indicate whether to skip the initial work for an edge
+        skip_init = defaultdict(lambda: False)
+
+        while dfs_stack:
+            v = dfs_stack.pop()
+            e = self.parent_edge[v]
+
+            for w in self.adjs[v][ind[v] :]:
+                vw = (v, w)
+
+                if not skip_init[vw]:
+                    if (v, w) in self.DG.edges or (w, v) in self.DG.edges:
+                        ind[v] += 1
+                        continue  # the edge was already oriented
+
+                    self.DG.add_edge(v, w)  # orient the edge
+
+                    self.lowpt[vw] = self.height[v]
+                    self.lowpt2[vw] = self.height[v]
+                    if self.height[w] is None:  # (v, w) is a tree edge
+                        self.parent_edge[w] = vw
+                        self.height[w] = self.height[v] + 1
+
+                        dfs_stack.append(v)  # revisit v after finishing w
+                        dfs_stack.append(w)  # visit w next
+                        skip_init[vw] = True  # don't redo this block
+                        break  # handle next node in dfs_stack (i.e. w)
+                    else:  # (v, w) is a back edge
+                        self.lowpt[vw] = self.height[w]
+
+                # determine nesting graph
+                self.nesting_depth[vw] = 2 * self.lowpt[vw]
+                if self.lowpt2[vw] < self.height[v]:  # chordal
+                    self.nesting_depth[vw] += 1
+
+                # update lowpoints of parent edge e
+                if e is not None:
+                    if self.lowpt[vw] < self.lowpt[e]:
+                        self.lowpt2[e] = min(self.lowpt[e], self.lowpt2[vw])
+                        self.lowpt[e] = self.lowpt[vw]
+                    elif self.lowpt[vw] > self.lowpt[e]:
+                        self.lowpt2[e] = min(self.lowpt2[e], self.lowpt[vw])
+                    else:
+                        self.lowpt2[e] = min(self.lowpt2[e], self.lowpt2[vw])
+
+                ind[v] += 1
+
+    def dfs_orientation_recursive(self, v):
+        """Recursive version of :meth:`dfs_orientation`."""
+        e = self.parent_edge[v]
+        for w in self.G[v]:
+            if (v, w) in self.DG.edges or (w, v) in self.DG.edges:
+                continue  # the edge was already oriented
+            vw = (v, w)
+            self.DG.add_edge(v, w)  # orient the edge
+
+            self.lowpt[vw] = self.height[v]
+            self.lowpt2[vw] = self.height[v]
+            if self.height[w] is None:  # (v, w) is a tree edge
+                self.parent_edge[w] = vw
+                self.height[w] = self.height[v] + 1
+                self.dfs_orientation_recursive(w)
+            else:  # (v, w) is a back edge
+                self.lowpt[vw] = self.height[w]
+
+            # determine nesting graph
+            self.nesting_depth[vw] = 2 * self.lowpt[vw]
+            if self.lowpt2[vw] < self.height[v]:  # chordal
+                self.nesting_depth[vw] += 1
+
+            # update lowpoints of parent edge e
+            if e is not None:
+                if self.lowpt[vw] < self.lowpt[e]:
+                    self.lowpt2[e] = min(self.lowpt[e], self.lowpt2[vw])
+                    self.lowpt[e] = self.lowpt[vw]
+                elif self.lowpt[vw] > self.lowpt[e]:
+                    self.lowpt2[e] = min(self.lowpt2[e], self.lowpt[vw])
+                else:
+                    self.lowpt2[e] = min(self.lowpt2[e], self.lowpt2[vw])
+
+    def dfs_testing(self, v):
+        """Test for LR partition."""
+        # the recursion stack
+        dfs_stack = [v]
+        # index of next edge to handle in adjacency list of each node
+        ind = defaultdict(lambda: 0)
+        # boolean to indicate whether to skip the initial work for an edge
+        skip_init = defaultdict(lambda: False)
+
+        while dfs_stack:
+            v = dfs_stack.pop()
+            e = self.parent_edge[v]
+            # to indicate whether to skip the final block after the for loop
+            skip_final = False
+
+            for w in self.ordered_adjs[v][ind[v] :]:
+                ei = (v, w)
+
+                if not skip_init[ei]:
+                    self.stack_bottom[ei] = top_of_stack(self.S)
+
+                    if ei == self.parent_edge[w]:  # tree edge
+                        dfs_stack.append(v)  # revisit v after finishing w
+                        dfs_stack.append(w)  # visit w next
+                        skip_init[ei] = True  # don't redo this block
+                        skip_final = True  # skip final work after breaking
+                        break  # handle next node in dfs_stack (i.e. w)
+                    else:  # back edge
+                        self.lowpt_edge[ei] = ei
+                        self.S.append(ConflictPair(right=Interval(ei, ei)))
+
+                # integrate new return edges
+                if self.lowpt[ei] < self.height[v]:
+                    if w == self.ordered_adjs[v][0]:  # e_i has return edge
+                        self.lowpt_edge[e] = self.lowpt_edge[ei]
+                    else:  # add constraints of e_i
+                        if not self.add_constraints(ei, e):
+                            # graph is not planar
+                            return False
+
+                ind[v] += 1
+
+            if not skip_final:
+                # remove back edges returning to parent
+                if e is not None:  # v isn't root
+                    self.remove_back_edges(e)
+
+        return True
+
+    def dfs_testing_recursive(self, v):
+        """Recursive version of :meth:`dfs_testing`."""
+        e = self.parent_edge[v]
+        for w in self.ordered_adjs[v]:
+            ei = (v, w)
+            self.stack_bottom[ei] = top_of_stack(self.S)
+            if ei == self.parent_edge[w]:  # tree edge
+                if not self.dfs_testing_recursive(w):
+                    return False
+            else:  # back edge
+                self.lowpt_edge[ei] = ei
+                self.S.append(ConflictPair(right=Interval(ei, ei)))
+
+            # integrate new return edges
+            if self.lowpt[ei] < self.height[v]:
+                if w == self.ordered_adjs[v][0]:  # e_i has return edge
+                    self.lowpt_edge[e] = self.lowpt_edge[ei]
+                else:  # add constraints of e_i
+                    if not self.add_constraints(ei, e):
+                        # graph is not planar
+                        return False
+
+        # remove back edges returning to parent
+        if e is not None:  # v isn't root
+            self.remove_back_edges(e)
+        return True
+
+    def add_constraints(self, ei, e):
+        P = ConflictPair()
+        # merge return edges of e_i into P.right
+        while True:
+            Q = self.S.pop()
+            if not Q.left.empty():
+                Q.swap()
+            if not Q.left.empty():  # not planar
+                return False
+            if self.lowpt[Q.right.low] > self.lowpt[e]:
+                # merge intervals
+                if P.right.empty():  # topmost interval
+                    P.right = Q.right.copy()
+                else:
+                    self.ref[P.right.low] = Q.right.high
+                P.right.low = Q.right.low
+            else:  # align
+                self.ref[Q.right.low] = self.lowpt_edge[e]
+            if top_of_stack(self.S) == self.stack_bottom[ei]:
+                break
+        # merge conflicting return edges of e_1,...,e_i-1 into P.L
+        while top_of_stack(self.S).left.conflicting(ei, self) or top_of_stack(
+            self.S
+        ).right.conflicting(ei, self):
+            Q = self.S.pop()
+            if Q.right.conflicting(ei, self):
+                Q.swap()
+            if Q.right.conflicting(ei, self):  # not planar
+                return False
+            # merge interval below lowpt(e_i) into P.R
+            self.ref[P.right.low] = Q.right.high
+            if Q.right.low is not None:
+                P.right.low = Q.right.low
+
+            if P.left.empty():  # topmost interval
+                P.left = Q.left.copy()
+            else:
+                self.ref[P.left.low] = Q.left.high
+            P.left.low = Q.left.low
+
+        if not (P.left.empty() and P.right.empty()):
+            self.S.append(P)
+        return True
+
+    def remove_back_edges(self, e):
+        u = e[0]
+        # trim back edges ending at parent u
+        # drop entire conflict pairs
+        while self.S and top_of_stack(self.S).lowest(self) == self.height[u]:
+            P = self.S.pop()
+            if P.left.low is not None:
+                self.side[P.left.low] = -1
+
+        if self.S:  # one more conflict pair to consider
+            P = self.S.pop()
+            # trim left interval
+            while P.left.high is not None and P.left.high[1] == u:
+                P.left.high = self.ref[P.left.high]
+            if P.left.high is None and P.left.low is not None:
+                # just emptied
+                self.ref[P.left.low] = P.right.low
+                self.side[P.left.low] = -1
+                P.left.low = None
+            # trim right interval
+            while P.right.high is not None and P.right.high[1] == u:
+                P.right.high = self.ref[P.right.high]
+            if P.right.high is None and P.right.low is not None:
+                # just emptied
+                self.ref[P.right.low] = P.left.low
+                self.side[P.right.low] = -1
+                P.right.low = None
+            self.S.append(P)
+
+        # side of e is side of a highest return edge
+        if self.lowpt[e] < self.height[u]:  # e has return edge
+            hl = top_of_stack(self.S).left.high
+            hr = top_of_stack(self.S).right.high
+
+            if hl is not None and (hr is None or self.lowpt[hl] > self.lowpt[hr]):
+                self.ref[e] = hl
+            else:
+                self.ref[e] = hr
+
+    def dfs_embedding(self, v):
+        """Completes the embedding."""
+        # the recursion stack
+        dfs_stack = [v]
+        # index of next edge to handle in adjacency list of each node
+        ind = defaultdict(lambda: 0)
+
+        while dfs_stack:
+            v = dfs_stack.pop()
+
+            for w in self.ordered_adjs[v][ind[v] :]:
+                ind[v] += 1
+                ei = (v, w)
+
+                if ei == self.parent_edge[w]:  # tree edge
+                    self.embedding.add_half_edge_first(w, v)
+                    self.left_ref[v] = w
+                    self.right_ref[v] = w
+
+                    dfs_stack.append(v)  # revisit v after finishing w
+                    dfs_stack.append(w)  # visit w next
+                    break  # handle next node in dfs_stack (i.e. w)
+                else:  # back edge
+                    if self.side[ei] == 1:
+                        self.embedding.add_half_edge_cw(w, v, self.right_ref[w])
+                    else:
+                        self.embedding.add_half_edge_ccw(w, v, self.left_ref[w])
+                        self.left_ref[w] = v
+
+    def dfs_embedding_recursive(self, v):
+        """Recursive version of :meth:`dfs_embedding`."""
+        for w in self.ordered_adjs[v]:
+            ei = (v, w)
+            if ei == self.parent_edge[w]:  # tree edge
+                self.embedding.add_half_edge_first(w, v)
+                self.left_ref[v] = w
+                self.right_ref[v] = w
+                self.dfs_embedding_recursive(w)
+            else:  # back edge
+                if self.side[ei] == 1:
+                    # place v directly after right_ref[w] in embed. list of w
+                    self.embedding.add_half_edge_cw(w, v, self.right_ref[w])
+                else:
+                    # place v directly before left_ref[w] in embed. list of w
+                    self.embedding.add_half_edge_ccw(w, v, self.left_ref[w])
+                    self.left_ref[w] = v
+
+    def sign(self, e):
+        """Resolve the relative side of an edge to the absolute side."""
+        # the recursion stack
+        dfs_stack = [e]
+        # dict to remember reference edges
+        old_ref = defaultdict(lambda: None)
+
+        while dfs_stack:
+            e = dfs_stack.pop()
+
+            if self.ref[e] is not None:
+                dfs_stack.append(e)  # revisit e after finishing self.ref[e]
+                dfs_stack.append(self.ref[e])  # visit self.ref[e] next
+                old_ref[e] = self.ref[e]  # remember value of self.ref[e]
+                self.ref[e] = None
+            else:
+                self.side[e] *= self.side[old_ref[e]]
+
+        return self.side[e]
+
+    def sign_recursive(self, e):
+        """Recursive version of :meth:`sign`."""
+        if self.ref[e] is not None:
+            self.side[e] = self.side[e] * self.sign_recursive(self.ref[e])
+            self.ref[e] = None
+        return self.side[e]
+
+
+class PlanarEmbedding(nx.DiGraph):
+    """Represents a planar graph with its planar embedding.
+
+    The planar embedding is given by a `combinatorial embedding
+    <https://en.wikipedia.org/wiki/Graph_embedding#Combinatorial_embedding>`_.
+
+    .. note:: `check_planarity` is the preferred way to check if a graph is planar.
+
+    **Neighbor ordering:**
+
+    In comparison to a usual graph structure, the embedding also stores the
+    order of all neighbors for every vertex.
+    The order of the neighbors can be given in clockwise (cw) direction or
+    counterclockwise (ccw) direction. This order is stored as edge attributes
+    in the underlying directed graph. For the edge (u, v) the edge attribute
+    'cw' is set to the neighbor of u that follows immediately after v in
+    clockwise direction.
+
+    In order for a PlanarEmbedding to be valid it must fulfill multiple
+    conditions. It is possible to check if these conditions are fulfilled with
+    the method :meth:`check_structure`.
+    The conditions are:
+
+    * Edges must go in both directions (because the edge attributes differ)
+    * Every edge must have a 'cw' and 'ccw' attribute which corresponds to a
+      correct planar embedding.
+    * A node with non zero degree must have a node attribute 'first_nbr'.
+
+    As long as a PlanarEmbedding is invalid only the following methods should
+    be called:
+
+    * :meth:`add_half_edge_ccw`
+    * :meth:`add_half_edge_cw`
+    * :meth:`connect_components`
+    * :meth:`add_half_edge_first`
+
+    Even though the graph is a subclass of nx.DiGraph, it can still be used
+    for algorithms that require undirected graphs, because the method
+    :meth:`is_directed` is overridden. This is possible, because a valid
+    PlanarGraph must have edges in both directions.
+
+    **Half edges:**
+
+    In methods like `add_half_edge_ccw` the term "half-edge" is used, which is
+    a term that is used in `doubly connected edge lists
+    <https://en.wikipedia.org/wiki/Doubly_connected_edge_list>`_. It is used
+    to emphasize that the edge is only in one direction and there exists
+    another half-edge in the opposite direction.
+    While conventional edges always have two faces (including outer face) next
+    to them, it is possible to assign each half-edge *exactly one* face.
+    For a half-edge (u, v) that is orientated such that u is below v then the
+    face that belongs to (u, v) is to the right of this half-edge.
+
+    See Also
+    --------
+    is_planar :
+        Preferred way to check if an existing graph is planar.
+
+    check_planarity :
+        A convenient way to create a `PlanarEmbedding`. If not planar,
+        it returns a subgraph that shows this.
+
+    Examples
+    --------
+
+    Create an embedding of a star graph (compare `nx.star_graph(3)`):
+
+    >>> G = nx.PlanarEmbedding()
+    >>> G.add_half_edge_cw(0, 1, None)
+    >>> G.add_half_edge_cw(0, 2, 1)
+    >>> G.add_half_edge_cw(0, 3, 2)
+    >>> G.add_half_edge_cw(1, 0, None)
+    >>> G.add_half_edge_cw(2, 0, None)
+    >>> G.add_half_edge_cw(3, 0, None)
+
+    Alternatively the same embedding can also be defined in counterclockwise
+    orientation. The following results in exactly the same PlanarEmbedding:
+
+    >>> G = nx.PlanarEmbedding()
+    >>> G.add_half_edge_ccw(0, 1, None)
+    >>> G.add_half_edge_ccw(0, 3, 1)
+    >>> G.add_half_edge_ccw(0, 2, 3)
+    >>> G.add_half_edge_ccw(1, 0, None)
+    >>> G.add_half_edge_ccw(2, 0, None)
+    >>> G.add_half_edge_ccw(3, 0, None)
+
+    After creating a graph, it is possible to validate that the PlanarEmbedding
+    object is correct:
+
+    >>> G.check_structure()
+
+    """
+
+    def get_data(self):
+        """Converts the adjacency structure into a better readable structure.
+
+        Returns
+        -------
+        embedding : dict
+            A dict mapping all nodes to a list of neighbors sorted in
+            clockwise order.
+
+        See Also
+        --------
+        set_data
+
+        """
+        embedding = dict()
+        for v in self:
+            embedding[v] = list(self.neighbors_cw_order(v))
+        return embedding
+
+    def set_data(self, data):
+        """Inserts edges according to given sorted neighbor list.
+
+        The input format is the same as the output format of get_data().
+
+        Parameters
+        ----------
+        data : dict
+            A dict mapping all nodes to a list of neighbors sorted in
+            clockwise order.
+
+        See Also
+        --------
+        get_data
+
+        """
+        for v in data:
+            for w in reversed(data[v]):
+                self.add_half_edge_first(v, w)
+
+    def neighbors_cw_order(self, v):
+        """Generator for the neighbors of v in clockwise order.
+
+        Parameters
+        ----------
+        v : node
+
+        Yields
+        ------
+        node
+
+        """
+        if len(self[v]) == 0:
+            # v has no neighbors
+            return
+        start_node = self.nodes[v]["first_nbr"]
+        yield start_node
+        current_node = self[v][start_node]["cw"]
+        while start_node != current_node:
+            yield current_node
+            current_node = self[v][current_node]["cw"]
+
+    def check_structure(self):
+        """Runs without exceptions if this object is valid.
+
+        Checks that the following properties are fulfilled:
+
+        * Edges go in both directions (because the edge attributes differ).
+        * Every edge has a 'cw' and 'ccw' attribute which corresponds to a
+          correct planar embedding.
+        * A node with a degree larger than 0 has a node attribute 'first_nbr'.
+
+        Running this method verifies that the underlying Graph must be planar.
+
+        Raises
+        ------
+        NetworkXException
+            This exception is raised with a short explanation if the
+            PlanarEmbedding is invalid.
+        """
+        # Check fundamental structure
+        for v in self:
+            try:
+                sorted_nbrs = set(self.neighbors_cw_order(v))
+            except KeyError as err:
+                msg = f"Bad embedding. Missing orientation for a neighbor of {v}"
+                raise nx.NetworkXException(msg) from err
+
+            unsorted_nbrs = set(self[v])
+            if sorted_nbrs != unsorted_nbrs:
+                msg = "Bad embedding. Edge orientations not set correctly."
+                raise nx.NetworkXException(msg)
+            for w in self[v]:
+                # Check if opposite half-edge exists
+                if not self.has_edge(w, v):
+                    msg = "Bad embedding. Opposite half-edge is missing."
+                    raise nx.NetworkXException(msg)
+
+        # Check planarity
+        counted_half_edges = set()
+        for component in nx.connected_components(self):
+            if len(component) == 1:
+                # Don't need to check single node component
+                continue
+            num_nodes = len(component)
+            num_half_edges = 0
+            num_faces = 0
+            for v in component:
+                for w in self.neighbors_cw_order(v):
+                    num_half_edges += 1
+                    if (v, w) not in counted_half_edges:
+                        # We encountered a new face
+                        num_faces += 1
+                        # Mark all half-edges belonging to this face
+                        self.traverse_face(v, w, counted_half_edges)
+            num_edges = num_half_edges // 2  # num_half_edges is even
+            if num_nodes - num_edges + num_faces != 2:
+                # The result does not match Euler's formula
+                msg = "Bad embedding. The graph does not match Euler's formula"
+                raise nx.NetworkXException(msg)
+
+    def add_half_edge_ccw(self, start_node, end_node, reference_neighbor):
+        """Adds a half-edge from start_node to end_node.
+
+        The half-edge is added counter clockwise next to the existing half-edge
+        (start_node, reference_neighbor).
+
+        Parameters
+        ----------
+        start_node : node
+            Start node of inserted edge.
+        end_node : node
+            End node of inserted edge.
+        reference_neighbor: node
+            End node of reference edge.
+
+        Raises
+        ------
+        NetworkXException
+            If the reference_neighbor does not exist.
+
+        See Also
+        --------
+        add_half_edge_cw
+        connect_components
+        add_half_edge_first
+
+        """
+        if reference_neighbor is None:
+            # The start node has no neighbors
+            self.add_edge(start_node, end_node)  # Add edge to graph
+            self[start_node][end_node]["cw"] = end_node
+            self[start_node][end_node]["ccw"] = end_node
+            self.nodes[start_node]["first_nbr"] = end_node
+        else:
+            ccw_reference = self[start_node][reference_neighbor]["ccw"]
+            self.add_half_edge_cw(start_node, end_node, ccw_reference)
+
+            if reference_neighbor == self.nodes[start_node].get("first_nbr", None):
+                # Update first neighbor
+                self.nodes[start_node]["first_nbr"] = end_node
+
+    def add_half_edge_cw(self, start_node, end_node, reference_neighbor):
+        """Adds a half-edge from start_node to end_node.
+
+        The half-edge is added clockwise next to the existing half-edge
+        (start_node, reference_neighbor).
+
+        Parameters
+        ----------
+        start_node : node
+            Start node of inserted edge.
+        end_node : node
+            End node of inserted edge.
+        reference_neighbor: node
+            End node of reference edge.
+
+        Raises
+        ------
+        NetworkXException
+            If the reference_neighbor does not exist.
+
+        See Also
+        --------
+        add_half_edge_ccw
+        connect_components
+        add_half_edge_first
+        """
+        self.add_edge(start_node, end_node)  # Add edge to graph
+
+        if reference_neighbor is None:
+            # The start node has no neighbors
+            self[start_node][end_node]["cw"] = end_node
+            self[start_node][end_node]["ccw"] = end_node
+            self.nodes[start_node]["first_nbr"] = end_node
+            return
+
+        if reference_neighbor not in self[start_node]:
+            raise nx.NetworkXException(
+                "Cannot add edge. Reference neighbor does not exist"
+            )
+
+        # Get half-edge at the other side
+        cw_reference = self[start_node][reference_neighbor]["cw"]
+        # Alter half-edge data structures
+        self[start_node][reference_neighbor]["cw"] = end_node
+        self[start_node][end_node]["cw"] = cw_reference
+        self[start_node][cw_reference]["ccw"] = end_node
+        self[start_node][end_node]["ccw"] = reference_neighbor
+
+    def connect_components(self, v, w):
+        """Adds half-edges for (v, w) and (w, v) at some position.
+
+        This method should only be called if v and w are in different
+        components, or it might break the embedding.
+        This especially means that if `connect_components(v, w)`
+        is called it is not allowed to call `connect_components(w, v)`
+        afterwards. The neighbor orientations in both directions are
+        all set correctly after the first call.
+
+        Parameters
+        ----------
+        v : node
+        w : node
+
+        See Also
+        --------
+        add_half_edge_ccw
+        add_half_edge_cw
+        add_half_edge_first
+        """
+        self.add_half_edge_first(v, w)
+        self.add_half_edge_first(w, v)
+
+    def add_half_edge_first(self, start_node, end_node):
+        """The added half-edge is inserted at the first position in the order.
+
+        Parameters
+        ----------
+        start_node : node
+        end_node : node
+
+        See Also
+        --------
+        add_half_edge_ccw
+        add_half_edge_cw
+        connect_components
+        """
+        if start_node in self and "first_nbr" in self.nodes[start_node]:
+            reference = self.nodes[start_node]["first_nbr"]
+        else:
+            reference = None
+        self.add_half_edge_ccw(start_node, end_node, reference)
+
+    def next_face_half_edge(self, v, w):
+        """Returns the following half-edge left of a face.
+
+        Parameters
+        ----------
+        v : node
+        w : node
+
+        Returns
+        -------
+        half-edge : tuple
+        """
+        new_node = self[w][v]["ccw"]
+        return w, new_node
+
+    def traverse_face(self, v, w, mark_half_edges=None):
+        """Returns nodes on the face that belong to the half-edge (v, w).
+
+        The face that is traversed lies to the right of the half-edge (in an
+        orientation where v is below w).
+
+        Optionally it is possible to pass a set to which all encountered half
+        edges are added. Before calling this method, this set must not include
+        any half-edges that belong to the face.
+
+        Parameters
+        ----------
+        v : node
+            Start node of half-edge.
+        w : node
+            End node of half-edge.
+        mark_half_edges: set, optional
+            Set to which all encountered half-edges are added.
+
+        Returns
+        -------
+        face : list
+            A list of nodes that lie on this face.
+        """
+        if mark_half_edges is None:
+            mark_half_edges = set()
+
+        face_nodes = [v]
+        mark_half_edges.add((v, w))
+        prev_node = v
+        cur_node = w
+        # Last half-edge is (incoming_node, v)
+        incoming_node = self[v][w]["cw"]
+
+        while cur_node != v or prev_node != incoming_node:
+            face_nodes.append(cur_node)
+            prev_node, cur_node = self.next_face_half_edge(prev_node, cur_node)
+            if (prev_node, cur_node) in mark_half_edges:
+                raise nx.NetworkXException("Bad planar embedding. Impossible face.")
+            mark_half_edges.add((prev_node, cur_node))
+
+        return face_nodes
+
+    def is_directed(self):
+        """A valid PlanarEmbedding is undirected.
+
+        All reverse edges are contained, i.e. for every existing
+        half-edge (v, w) the half-edge in the opposite direction (w, v) is also
+        contained.
+        """
+        return False
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/polynomials.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/polynomials.py
new file mode 100644
index 0000000..35c0166
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/polynomials.py
@@ -0,0 +1,290 @@
+"""Provides algorithms supporting the computation of graph polynomials.
+
+Graph polynomials are polynomial-valued graph invariants that encode a wide
+variety of structural information. Examples include the Tutte polynomial,
+chromatic polynomial, characteristic polynomial, and matching polynomial. An
+extensive treatment is provided in [1]_.
+
+.. [1] Y. Shi, M. Dehmer, X. Li, I. Gutman,
+   "Graph Polynomials"
+"""
+from collections import deque
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["tutte_polynomial", "chromatic_polynomial"]
+
+
+@not_implemented_for("directed")
+def tutte_polynomial(G):
+    r"""Returns the Tutte polynomial of `G`
+
+    This function computes the Tutte polynomial via an iterative version of
+    the deletion-contraction algorithm.
+
+    The Tutte polynomial `T_G(x, y)` is a fundamental graph polynomial invariant in
+    two variables. It encodes a wide array of information related to the
+    edge-connectivity of a graph; "Many problems about graphs can be reduced to
+    problems of finding and evaluating the Tutte polynomial at certain values" [1]_.
+    In fact, every deletion-contraction-expressible feature of a graph is a
+    specialization of the Tutte polynomial [2]_ (see Notes for examples).
+
+    There are several equivalent definitions; here are three:
+
+    Def 1 (rank-nullity expansion): For `G` an undirected graph, `n(G)` the
+    number of vertices of `G`, `E` the edge set of `G`, `V` the vertex set of
+    `G`, and `c(A)` the number of connected components of the graph with vertex
+    set `V` and edge set `A` [3]_:
+
+    .. math::
+
+        T_G(x, y) = \sum_{A \in E} (x-1)^{c(A) - c(E)} (y-1)^{c(A) + |A| - n(G)}
+
+    Def 2 (spanning tree expansion): Let `G` be an undirected graph, `T` a spanning
+    tree of `G`, and `E` the edge set of `G`. Let `E` have an arbitrary strict
+    linear order `L`. Let `B_e` be the unique minimal nonempty edge cut of
+    $E \setminus T \cup {e}$. An edge `e` is internally active with respect to
+    `T` and `L` if `e` is the least edge in `B_e` according to the linear order
+    `L`. The internal activity of `T` (denoted `i(T)`) is the number of edges
+    in $E \setminus T$ that are internally active with respect to `T` and `L`.
+    Let `P_e` be the unique path in $T \cup {e}$ whose source and target vertex
+    are the same. An edge `e` is externally active with respect to `T` and `L`
+    if `e` is the least edge in `P_e` according to the linear order `L`. The
+    external activity of `T` (denoted `e(T)`) is the number of edges in
+    $E \setminus T$ that are externally active with respect to `T` and `L`.
+    Then [4]_ [5]_:
+
+    .. math::
+
+        T_G(x, y) = \sum_{T \text{ a spanning tree of } G} x^{i(T)} y^{e(T)}
+
+    Def 3 (deletion-contraction recurrence): For `G` an undirected graph, `G-e`
+    the graph obtained from `G` by deleting edge `e`, `G/e` the graph obtained
+    from `G` by contracting edge `e`, `k(G)` the number of cut-edges of `G`,
+    and `l(G)` the number of self-loops of `G`:
+
+    .. math::
+        T_G(x, y) = \begin{cases}
+    	   x^{k(G)} y^{l(G)}, & \text{if all edges are cut-edges or self-loops} \\
+           T_{G-e}(x, y) + T_{G/e}(x, y), & \text{otherwise, for an arbitrary edge $e$ not a cut-edge or loop}
+        \end{cases}
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    instance of `sympy.core.add.Add`
+        A Sympy expression representing the Tutte polynomial for `G`.
+
+    Examples
+    --------
+    >>> C = nx.cycle_graph(5)
+    >>> nx.tutte_polynomial(C)
+    x**4 + x**3 + x**2 + x + y
+
+    >>> D = nx.diamond_graph()
+    >>> nx.tutte_polynomial(D)
+    x**3 + 2*x**2 + 2*x*y + x + y**2 + y
+
+    Notes
+    -----
+    Some specializations of the Tutte polynomial:
+
+    - `T_G(1, 1)` counts the number of spanning trees of `G`
+    - `T_G(1, 2)` counts the number of connected spanning subgraphs of `G`
+    - `T_G(2, 1)` counts the number of spanning forests in `G`
+    - `T_G(0, 2)` counts the number of strong orientations of `G`
+    - `T_G(2, 0)` counts the number of acyclic orientations of `G`
+
+    Edge contraction is defined and deletion-contraction is introduced in [6]_.
+    Combinatorial meaning of the coefficients is introduced in [7]_.
+    Universality, properties, and applications are discussed in [8]_.
+
+    Practically, up-front computation of the Tutte polynomial may be useful when
+    users wish to repeatedly calculate edge-connectivity-related information
+    about one or more graphs.
+
+    References
+    ----------
+    .. [1] M. Brandt,
+       "The Tutte Polynomial."
+       Talking About Combinatorial Objects Seminar, 2015
+       https://math.berkeley.edu/~brandtm/talks/tutte.pdf
+    .. [2] A. Björklund, T. Husfeldt, P. Kaski, M. Koivisto,
+       "Computing the Tutte polynomial in vertex-exponential time"
+       49th Annual IEEE Symposium on Foundations of Computer Science, 2008
+       https://ieeexplore.ieee.org/abstract/document/4691000
+    .. [3] Y. Shi, M. Dehmer, X. Li, I. Gutman,
+       "Graph Polynomials," p. 14
+    .. [4] Y. Shi, M. Dehmer, X. Li, I. Gutman,
+       "Graph Polynomials," p. 46
+    .. [5] A. Nešetril, J. Goodall,
+       "Graph invariants, homomorphisms, and the Tutte polynomial"
+       https://iuuk.mff.cuni.cz/~andrew/Tutte.pdf
+    .. [6] D. B. West,
+       "Introduction to Graph Theory," p. 84
+    .. [7] G. Coutinho,
+       "A brief introduction to the Tutte polynomial"
+       Structural Analysis of Complex Networks, 2011
+       https://homepages.dcc.ufmg.br/~gabriel/seminars/coutinho_tuttepolynomial_seminar.pdf
+    .. [8] J. A. Ellis-Monaghan, C. Merino,
+       "Graph polynomials and their applications I: The Tutte polynomial"
+       Structural Analysis of Complex Networks, 2011
+       https://arxiv.org/pdf/0803.3079.pdf
+    """
+    import sympy
+
+    x = sympy.Symbol("x")
+    y = sympy.Symbol("y")
+    stack = deque()
+    stack.append(nx.MultiGraph(G))
+
+    polynomial = 0
+    while stack:
+        G = stack.pop()
+        bridges = set(nx.bridges(G))
+
+        e = None
+        for i in G.edges:
+            if (i[0], i[1]) not in bridges and i[0] != i[1]:
+                e = i
+                break
+        if not e:
+            loops = list(nx.selfloop_edges(G, keys=True))
+            polynomial += x ** len(bridges) * y ** len(loops)
+        else:
+            # deletion-contraction
+            C = nx.contracted_edge(G, e, self_loops=True)
+            C.remove_edge(e[0], e[0])
+            G.remove_edge(*e)
+            stack.append(G)
+            stack.append(C)
+    return sympy.simplify(polynomial)
+
+
+@not_implemented_for("directed")
+def chromatic_polynomial(G):
+    r"""Returns the chromatic polynomial of `G`
+
+    This function computes the chromatic polynomial via an iterative version of
+    the deletion-contraction algorithm.
+
+    The chromatic polynomial `X_G(x)` is a fundamental graph polynomial
+    invariant in one variable. Evaluating `X_G(k)` for an natural number `k`
+    enumerates the proper k-colorings of `G`.
+
+    There are several equivalent definitions; here are three:
+
+    Def 1 (explicit formula):
+    For `G` an undirected graph, `c(G)` the number of connected components of
+    `G`, `E` the edge set of `G`, and `G(S)` the spanning subgraph of `G` with
+    edge set `S` [1]_:
+
+    .. math::
+
+        X_G(x) = \sum_{S \subseteq E} (-1)^{|S|} x^{c(G(S))}
+
+
+    Def 2 (interpolating polynomial):
+    For `G` an undirected graph, `n(G)` the number of vertices of `G`, `k_0 = 0`,
+    and `k_i` the number of distinct ways to color the vertices of `G` with `i`
+    unique colors (for `i` a natural number at most `n(G)`), `X_G(x)` is the
+    unique Lagrange interpolating polynomial of degree `n(G)` through the points
+    `(0, k_0), (1, k_1), \dots, (n(G), k_{n(G)})` [2]_.
+
+
+    Def 3 (chromatic recurrence):
+    For `G` an undirected graph, `G-e` the graph obtained from `G` by deleting
+    edge `e`, `G/e` the graph obtained from `G` by contracting edge `e`, `n(G)`
+    the number of vertices of `G`, and `e(G)` the number of edges of `G` [3]_:
+
+    .. math::
+        X_G(x) = \begin{cases}
+    	   x^{n(G)}, & \text{if $e(G)=0$} \\
+           X_{G-e}(x) - X_{G/e}(x), & \text{otherwise, for an arbitrary edge $e$}
+        \end{cases}
+
+    This formulation is also known as the Fundamental Reduction Theorem [4]_.
+
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    instance of `sympy.core.add.Add`
+        A Sympy expression representing the chromatic polynomial for `G`.
+
+    Examples
+    --------
+    >>> C = nx.cycle_graph(5)
+    >>> nx.chromatic_polynomial(C)
+    x**5 - 5*x**4 + 10*x**3 - 10*x**2 + 4*x
+
+    >>> G = nx.complete_graph(4)
+    >>> nx.chromatic_polynomial(G)
+    x**4 - 6*x**3 + 11*x**2 - 6*x
+
+    Notes
+    -----
+    Interpretation of the coefficients is discussed in [5]_. Several special
+    cases are listed in [2]_.
+
+    The chromatic polynomial is a specialization of the Tutte polynomial; in
+    particular, `X_G(x) = `T_G(x, 0)` [6]_.
+
+    The chromatic polynomial may take negative arguments, though evaluations
+    may not have chromatic interpretations. For instance, `X_G(-1)` enumerates
+    the acyclic orientations of `G` [7]_.
+
+    References
+    ----------
+    .. [1] D. B. West,
+       "Introduction to Graph Theory," p. 222
+    .. [2] E. W. Weisstein
+       "Chromatic Polynomial"
+       MathWorld--A Wolfram Web Resource
+       https://mathworld.wolfram.com/ChromaticPolynomial.html
+    .. [3] D. B. West,
+       "Introduction to Graph Theory," p. 221
+    .. [4] J. Zhang, J. Goodall,
+       "An Introduction to Chromatic Polynomials"
+       https://math.mit.edu/~apost/courses/18.204_2018/Julie_Zhang_paper.pdf
+    .. [5] R. C. Read,
+       "An Introduction to Chromatic Polynomials"
+       Journal of Combinatorial Theory, 1968
+       https://math.berkeley.edu/~mrklug/ReadChromatic.pdf
+    .. [6] W. T. Tutte,
+       "Graph-polynomials"
+       Advances in Applied Mathematics, 2004
+       https://www.sciencedirect.com/science/article/pii/S0196885803000411
+    .. [7] R. P. Stanley,
+       "Acyclic orientations of graphs"
+       Discrete Mathematics, 2006
+       https://math.mit.edu/~rstan/pubs/pubfiles/18.pdf
+    """
+    import sympy
+
+    x = sympy.Symbol("x")
+    stack = deque()
+    stack.append(nx.MultiGraph(G, contraction_idx=0))
+
+    polynomial = 0
+    while stack:
+        G = stack.pop()
+        edges = list(G.edges)
+        if not edges:
+            polynomial += (-1) ** G.graph["contraction_idx"] * x ** len(G)
+        else:
+            e = edges[0]
+            C = nx.contracted_edge(G, e, self_loops=True)
+            C.graph["contraction_idx"] = G.graph["contraction_idx"] + 1
+            C.remove_edge(e[0], e[0])
+            G.remove_edge(*e)
+            stack.append(G)
+            stack.append(C)
+    return polynomial
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/reciprocity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/reciprocity.py
new file mode 100644
index 0000000..1b7761b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/reciprocity.py
@@ -0,0 +1,94 @@
+"""Algorithms to calculate reciprocity in a directed graph."""
+from networkx import NetworkXError
+
+from ..utils import not_implemented_for
+
+__all__ = ["reciprocity", "overall_reciprocity"]
+
+
+@not_implemented_for("undirected", "multigraph")
+def reciprocity(G, nodes=None):
+    r"""Compute the reciprocity in a directed graph.
+
+    The reciprocity of a directed graph is defined as the ratio
+    of the number of edges pointing in both directions to the total
+    number of edges in the graph.
+    Formally, $r = |{(u,v) \in G|(v,u) \in G}| / |{(u,v) \in G}|$.
+
+    The reciprocity of a single node u is defined similarly,
+    it is the ratio of the number of edges in both directions to
+    the total number of edges attached to node u.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx directed graph
+    nodes : container of nodes, optional (default=whole graph)
+       Compute reciprocity for nodes in this container.
+
+    Returns
+    -------
+    out : dictionary
+       Reciprocity keyed by node label.
+
+    Notes
+    -----
+    The reciprocity is not defined for isolated nodes.
+    In such cases this function will return None.
+
+    """
+    # If `nodes` is not specified, calculate the reciprocity of the graph.
+    if nodes is None:
+        return overall_reciprocity(G)
+
+    # If `nodes` represents a single node in the graph, return only its
+    # reciprocity.
+    if nodes in G:
+        reciprocity = next(_reciprocity_iter(G, nodes))[1]
+        if reciprocity is None:
+            raise NetworkXError("Not defined for isolated nodes.")
+        else:
+            return reciprocity
+
+    # Otherwise, `nodes` represents an iterable of nodes, so return a
+    # dictionary mapping node to its reciprocity.
+    return dict(_reciprocity_iter(G, nodes))
+
+
+def _reciprocity_iter(G, nodes):
+    """Return an iterator of (node, reciprocity)."""
+    n = G.nbunch_iter(nodes)
+    for node in n:
+        pred = set(G.predecessors(node))
+        succ = set(G.successors(node))
+        overlap = pred & succ
+        n_total = len(pred) + len(succ)
+
+        # Reciprocity is not defined for isolated nodes.
+        # Return None.
+        if n_total == 0:
+            yield (node, None)
+        else:
+            reciprocity = 2 * len(overlap) / n_total
+            yield (node, reciprocity)
+
+
+@not_implemented_for("undirected", "multigraph")
+def overall_reciprocity(G):
+    """Compute the reciprocity for the whole graph.
+
+    See the doc of reciprocity for the definition.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+
+    """
+    n_all_edge = G.number_of_edges()
+    n_overlap_edge = (n_all_edge - G.to_undirected().number_of_edges()) * 2
+
+    if n_all_edge == 0:
+        raise NetworkXError("Not defined for empty graphs")
+
+    return n_overlap_edge / n_all_edge
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/regular.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/regular.py
new file mode 100644
index 0000000..3f76d40
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/regular.py
@@ -0,0 +1,190 @@
+"""Functions for computing and verifying regular graphs."""
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["is_regular", "is_k_regular", "k_factor"]
+
+
+def is_regular(G):
+    """Determines whether the graph ``G`` is a regular graph.
+
+    A regular graph is a graph where each vertex has the same degree. A
+    regular digraph is a graph where the indegree and outdegree of each
+    vertex are equal.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    bool
+        Whether the given graph or digraph is regular.
+
+    """
+    n1 = nx.utils.arbitrary_element(G)
+    if not G.is_directed():
+        d1 = G.degree(n1)
+        return all(d1 == d for _, d in G.degree)
+    else:
+        d_in = G.in_degree(n1)
+        in_regular = all(d_in == d for _, d in G.in_degree)
+        d_out = G.out_degree(n1)
+        out_regular = all(d_out == d for _, d in G.out_degree)
+        return in_regular and out_regular
+
+
+@not_implemented_for("directed")
+def is_k_regular(G, k):
+    """Determines whether the graph ``G`` is a k-regular graph.
+
+    A k-regular graph is a graph where each vertex has degree k.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    Returns
+    -------
+    bool
+        Whether the given graph is k-regular.
+
+    """
+    return all(d == k for n, d in G.degree)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def k_factor(G, k, matching_weight="weight"):
+    """Compute a k-factor of G
+
+    A k-factor of a graph is a spanning k-regular subgraph.
+    A spanning k-regular subgraph of G is a subgraph that contains
+    each vertex of G and a subset of the edges of G such that each
+    vertex has degree k.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+      Undirected graph
+
+    matching_weight: string, optional (default='weight')
+       Edge data key corresponding to the edge weight.
+       Used for finding the max-weighted perfect matching.
+       If key not found, uses 1 as weight.
+
+    Returns
+    -------
+    G2 : NetworkX graph
+        A k-factor of G
+
+    References
+    ----------
+    .. [1] "An algorithm for computing simple k-factors.",
+       Meijer, Henk, Yurai Núñez-Rodríguez, and David Rappaport,
+       Information processing letters, 2009.
+    """
+
+    from networkx.algorithms.matching import is_perfect_matching, max_weight_matching
+
+    class LargeKGadget:
+        def __init__(self, k, degree, node, g):
+            self.original = node
+            self.g = g
+            self.k = k
+            self.degree = degree
+
+            self.outer_vertices = [(node, x) for x in range(degree)]
+            self.core_vertices = [(node, x + degree) for x in range(degree - k)]
+
+        def replace_node(self):
+            adj_view = self.g[self.original]
+            neighbors = list(adj_view.keys())
+            edge_attrs = list(adj_view.values())
+            for (outer, neighbor, edge_attrs) in zip(
+                self.outer_vertices, neighbors, edge_attrs
+            ):
+                self.g.add_edge(outer, neighbor, **edge_attrs)
+            for core in self.core_vertices:
+                for outer in self.outer_vertices:
+                    self.g.add_edge(core, outer)
+            self.g.remove_node(self.original)
+
+        def restore_node(self):
+            self.g.add_node(self.original)
+            for outer in self.outer_vertices:
+                adj_view = self.g[outer]
+                for neighbor, edge_attrs in list(adj_view.items()):
+                    if neighbor not in self.core_vertices:
+                        self.g.add_edge(self.original, neighbor, **edge_attrs)
+                        break
+            g.remove_nodes_from(self.outer_vertices)
+            g.remove_nodes_from(self.core_vertices)
+
+    class SmallKGadget:
+        def __init__(self, k, degree, node, g):
+            self.original = node
+            self.k = k
+            self.degree = degree
+            self.g = g
+
+            self.outer_vertices = [(node, x) for x in range(degree)]
+            self.inner_vertices = [(node, x + degree) for x in range(degree)]
+            self.core_vertices = [(node, x + 2 * degree) for x in range(k)]
+
+        def replace_node(self):
+            adj_view = self.g[self.original]
+            for (outer, inner, (neighbor, edge_attrs)) in zip(
+                self.outer_vertices, self.inner_vertices, list(adj_view.items())
+            ):
+                self.g.add_edge(outer, inner)
+                self.g.add_edge(outer, neighbor, **edge_attrs)
+            for core in self.core_vertices:
+                for inner in self.inner_vertices:
+                    self.g.add_edge(core, inner)
+            self.g.remove_node(self.original)
+
+        def restore_node(self):
+            self.g.add_node(self.original)
+            for outer in self.outer_vertices:
+                adj_view = self.g[outer]
+                for neighbor, edge_attrs in adj_view.items():
+                    if neighbor not in self.core_vertices:
+                        self.g.add_edge(self.original, neighbor, **edge_attrs)
+                        break
+            self.g.remove_nodes_from(self.outer_vertices)
+            self.g.remove_nodes_from(self.inner_vertices)
+            self.g.remove_nodes_from(self.core_vertices)
+
+    # Step 1
+    if any(d < k for _, d in G.degree):
+        raise nx.NetworkXUnfeasible("Graph contains a vertex with degree less than k")
+    g = G.copy()
+
+    # Step 2
+    gadgets = []
+    for node, degree in list(g.degree):
+        if k < degree / 2.0:
+            gadget = SmallKGadget(k, degree, node, g)
+        else:
+            gadget = LargeKGadget(k, degree, node, g)
+        gadget.replace_node()
+        gadgets.append(gadget)
+
+    # Step 3
+    matching = max_weight_matching(g, maxcardinality=True, weight=matching_weight)
+
+    # Step 4
+    if not is_perfect_matching(g, matching):
+        raise nx.NetworkXUnfeasible(
+            "Cannot find k-factor because no perfect matching exists"
+        )
+
+    for edge in g.edges():
+        if edge not in matching and (edge[1], edge[0]) not in matching:
+            g.remove_edge(edge[0], edge[1])
+
+    for gadget in gadgets:
+        gadget.restore_node()
+
+    return g
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/richclub.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/richclub.py
new file mode 100644
index 0000000..599d899
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/richclub.py
@@ -0,0 +1,120 @@
+"""Functions for computing rich-club coefficients."""
+
+from itertools import accumulate
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["rich_club_coefficient"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def rich_club_coefficient(G, normalized=True, Q=100, seed=None):
+    r"""Returns the rich-club coefficient of the graph `G`.
+
+    For each degree *k*, the *rich-club coefficient* is the ratio of the
+    number of actual to the number of potential edges for nodes with
+    degree greater than *k*:
+
+    .. math::
+
+        \phi(k) = \frac{2 E_k}{N_k (N_k - 1)}
+
+    where `N_k` is the number of nodes with degree larger than *k*, and
+    `E_k` is the number of edges among those nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph with neither parallel edges nor self-loops.
+    normalized : bool (optional)
+        Normalize using randomized network as in [1]_
+    Q : float (optional, default=100)
+        If `normalized` is True, perform `Q * m` double-edge
+        swaps, where `m` is the number of edges in `G`, to use as a
+        null-model for normalization.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    rc : dictionary
+       A dictionary, keyed by degree, with rich-club coefficient values.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (4, 5)])
+    >>> rc = nx.rich_club_coefficient(G, normalized=False, seed=42)
+    >>> rc[0]
+    0.4
+
+    Notes
+    -----
+    The rich club definition and algorithm are found in [1]_.  This
+    algorithm ignores any edge weights and is not defined for directed
+    graphs or graphs with parallel edges or self loops.
+
+    Estimates for appropriate values of `Q` are found in [2]_.
+
+    References
+    ----------
+    .. [1] Julian J. McAuley, Luciano da Fontoura Costa,
+       and Tibério S. Caetano,
+       "The rich-club phenomenon across complex network hierarchies",
+       Applied Physics Letters Vol 91 Issue 8, August 2007.
+       https://arxiv.org/abs/physics/0701290
+    .. [2] R. Milo, N. Kashtan, S. Itzkovitz, M. E. J. Newman, U. Alon,
+       "Uniform generation of random graphs with arbitrary degree
+       sequences", 2006. https://arxiv.org/abs/cond-mat/0312028
+    """
+    if nx.number_of_selfloops(G) > 0:
+        raise Exception(
+            "rich_club_coefficient is not implemented for " "graphs with self loops."
+        )
+    rc = _compute_rc(G)
+    if normalized:
+        # make R a copy of G, randomize with Q*|E| double edge swaps
+        # and use rich_club coefficient of R to normalize
+        R = G.copy()
+        E = R.number_of_edges()
+        nx.double_edge_swap(R, Q * E, max_tries=Q * E * 10, seed=seed)
+        rcran = _compute_rc(R)
+        rc = {k: v / rcran[k] for k, v in rc.items()}
+    return rc
+
+
+def _compute_rc(G):
+    """Returns the rich-club coefficient for each degree in the graph
+    `G`.
+
+    `G` is an undirected graph without multiedges.
+
+    Returns a dictionary mapping degree to rich-club coefficient for
+    that degree.
+
+    """
+    deghist = nx.degree_histogram(G)
+    total = sum(deghist)
+    # Compute the number of nodes with degree greater than `k`, for each
+    # degree `k` (omitting the last entry, which is zero).
+    nks = (total - cs for cs in accumulate(deghist) if total - cs > 1)
+    # Create a sorted list of pairs of edge endpoint degrees.
+    #
+    # The list is sorted in reverse order so that we can pop from the
+    # right side of the list later, instead of popping from the left
+    # side of the list, which would have a linear time cost.
+    edge_degrees = sorted((sorted(map(G.degree, e)) for e in G.edges()), reverse=True)
+    ek = G.number_of_edges()
+    k1, k2 = edge_degrees.pop()
+    rc = {}
+    for d, nk in enumerate(nks):
+        while k1 <= d:
+            if len(edge_degrees) == 0:
+                ek = 0
+                break
+            k1, k2 = edge_degrees.pop()
+            ek -= 1
+        rc[d] = 2 * ek / (nk * (nk - 1))
+    return rc
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/__init__.py
new file mode 100644
index 0000000..eb0d91c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/__init__.py
@@ -0,0 +1,5 @@
+from networkx.algorithms.shortest_paths.generic import *
+from networkx.algorithms.shortest_paths.unweighted import *
+from networkx.algorithms.shortest_paths.weighted import *
+from networkx.algorithms.shortest_paths.astar import *
+from networkx.algorithms.shortest_paths.dense import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/astar.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/astar.py
new file mode 100644
index 0000000..5d5a847
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/astar.py
@@ -0,0 +1,199 @@
+"""Shortest paths and path lengths using the A* ("A star") algorithm.
+"""
+from heapq import heappop, heappush
+from itertools import count
+
+import networkx as nx
+from networkx.algorithms.shortest_paths.weighted import _weight_function
+
+__all__ = ["astar_path", "astar_path_length"]
+
+
+def astar_path(G, source, target, heuristic=None, weight="weight"):
+    """Returns a list of nodes in a shortest path between source and target
+    using the A* ("A-star") algorithm.
+
+    There may be more than one shortest path.  This returns only one.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Starting node for path
+
+    target : node
+       Ending node for path
+
+    heuristic : function
+       A function to evaluate the estimate of the distance
+       from the a node to the target.  The function takes
+       two nodes arguments and must return a number.
+       If the heuristic is inadmissible (if it might
+       overestimate the cost of reaching the goal from a node),
+       the result may not be a shortest path.
+       The algorithm does not support updating heuristic
+       values for the same node due to caching the first
+       heuristic calculation per node.
+
+    weight : string or function
+       If this is a string, then edge weights will be accessed via the
+       edge attribute with this key (that is, the weight of the edge
+       joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+       such edge attribute exists, the weight of the edge is assumed to
+       be one.
+       If this is a function, the weight of an edge is the value
+       returned by the function. The function must accept exactly three
+       positional arguments: the two endpoints of an edge and the
+       dictionary of edge attributes for that edge. The function must
+       return a number.
+
+    Raises
+    ------
+    NetworkXNoPath
+        If no path exists between source and target.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> print(nx.astar_path(G, 0, 4))
+    [0, 1, 2, 3, 4]
+    >>> G = nx.grid_graph(dim=[3, 3])  # nodes are two-tuples (x,y)
+    >>> nx.set_edge_attributes(G, {e: e[1][0] * 2 for e in G.edges()}, "cost")
+    >>> def dist(a, b):
+    ...     (x1, y1) = a
+    ...     (x2, y2) = b
+    ...     return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
+    >>> print(nx.astar_path(G, (0, 0), (2, 2), heuristic=dist, weight="cost"))
+    [(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)]
+
+
+    See Also
+    --------
+    shortest_path, dijkstra_path
+
+    """
+    if source not in G or target not in G:
+        msg = f"Either source {source} or target {target} is not in G"
+        raise nx.NodeNotFound(msg)
+
+    if heuristic is None:
+        # The default heuristic is h=0 - same as Dijkstra's algorithm
+        def heuristic(u, v):
+            return 0
+
+    push = heappush
+    pop = heappop
+    weight = _weight_function(G, weight)
+
+    # The queue stores priority, node, cost to reach, and parent.
+    # Uses Python heapq to keep in priority order.
+    # Add a counter to the queue to prevent the underlying heap from
+    # attempting to compare the nodes themselves. The hash breaks ties in the
+    # priority and is guaranteed unique for all nodes in the graph.
+    c = count()
+    queue = [(0, next(c), source, 0, None)]
+
+    # Maps enqueued nodes to distance of discovered paths and the
+    # computed heuristics to target. We avoid computing the heuristics
+    # more than once and inserting the node into the queue too many times.
+    enqueued = {}
+    # Maps explored nodes to parent closest to the source.
+    explored = {}
+
+    while queue:
+        # Pop the smallest item from queue.
+        _, __, curnode, dist, parent = pop(queue)
+
+        if curnode == target:
+            path = [curnode]
+            node = parent
+            while node is not None:
+                path.append(node)
+                node = explored[node]
+            path.reverse()
+            return path
+
+        if curnode in explored:
+            # Do not override the parent of starting node
+            if explored[curnode] is None:
+                continue
+
+            # Skip bad paths that were enqueued before finding a better one
+            qcost, h = enqueued[curnode]
+            if qcost < dist:
+                continue
+
+        explored[curnode] = parent
+
+        for neighbor, w in G[curnode].items():
+            ncost = dist + weight(curnode, neighbor, w)
+            if neighbor in enqueued:
+                qcost, h = enqueued[neighbor]
+                # if qcost <= ncost, a less costly path from the
+                # neighbor to the source was already determined.
+                # Therefore, we won't attempt to push this neighbor
+                # to the queue
+                if qcost <= ncost:
+                    continue
+            else:
+                h = heuristic(neighbor, target)
+            enqueued[neighbor] = ncost, h
+            push(queue, (ncost + h, next(c), neighbor, ncost, curnode))
+
+    raise nx.NetworkXNoPath(f"Node {target} not reachable from {source}")
+
+
+def astar_path_length(G, source, target, heuristic=None, weight="weight"):
+    """Returns the length of the shortest path between source and target using
+    the A* ("A-star") algorithm.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Starting node for path
+
+    target : node
+       Ending node for path
+
+    heuristic : function
+       A function to evaluate the estimate of the distance
+       from the a node to the target.  The function takes
+       two nodes arguments and must return a number.
+       If the heuristic is inadmissible (if it might
+       overestimate the cost of reaching the goal from a node),
+       the result may not be a shortest path.
+       The algorithm does not support updating heuristic
+       values for the same node due to caching the first
+       heuristic calculation per node.
+
+    weight : string or function
+       If this is a string, then edge weights will be accessed via the
+       edge attribute with this key (that is, the weight of the edge
+       joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+       such edge attribute exists, the weight of the edge is assumed to
+       be one.
+       If this is a function, the weight of an edge is the value
+       returned by the function. The function must accept exactly three
+       positional arguments: the two endpoints of an edge and the
+       dictionary of edge attributes for that edge. The function must
+       return a number.
+    Raises
+    ------
+    NetworkXNoPath
+        If no path exists between source and target.
+
+    See Also
+    --------
+    astar_path
+
+    """
+    if source not in G or target not in G:
+        msg = f"Either source {source} or target {target} is not in G"
+        raise nx.NodeNotFound(msg)
+
+    weight = _weight_function(G, weight)
+    path = astar_path(G, source, target, heuristic, weight)
+    return sum(weight(u, v, G[u][v]) for u, v in zip(path[:-1], path[1:]))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/dense.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/dense.py
new file mode 100644
index 0000000..8965171
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/dense.py
@@ -0,0 +1,233 @@
+"""Floyd-Warshall algorithm for shortest paths.
+"""
+import networkx as nx
+
+__all__ = [
+    "floyd_warshall",
+    "floyd_warshall_predecessor_and_distance",
+    "reconstruct_path",
+    "floyd_warshall_numpy",
+]
+
+
+def floyd_warshall_numpy(G, nodelist=None, weight="weight"):
+    """Find all-pairs shortest path lengths using Floyd's algorithm.
+
+    This algorithm for finding shortest paths takes advantage of
+    matrix representations of a graph and works well for dense
+    graphs where all-pairs shortest path lengths are desired.
+    The results are returned as a NumPy array, distance[i, j],
+    where i and j are the indexes of two nodes in nodelist.
+    The entry distance[i, j] is the distance along a shortest
+    path from i to j. If no path exists the distance is Inf.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    nodelist : list, optional (default=G.nodes)
+       The rows and columns are ordered by the nodes in nodelist.
+       If nodelist is None then the ordering is produced by G.nodes.
+       Nodelist should include all nodes in G.
+
+    weight: string, optional (default='weight')
+       Edge data key corresponding to the edge weight.
+
+    Returns
+    -------
+    distance : 2D numpy.ndarray
+        A numpy array of shortest path distances between nodes.
+        If there is no path between two nodes the value is Inf.
+
+    Notes
+    -----
+    Floyd's algorithm is appropriate for finding shortest paths in
+    dense graphs or graphs with negative weights when Dijkstra's
+    algorithm fails. This algorithm can still fail if there are negative
+    cycles. It has running time $O(n^3)$ with running space of $O(n^2)$.
+
+    Raises
+    ------
+    NetworkXError
+        If nodelist is not a list of the nodes in G.
+    """
+    import numpy as np
+
+    if nodelist is not None:
+        if not (len(nodelist) == len(G) == len(set(nodelist))):
+            raise nx.NetworkXError(
+                "nodelist must contain every node in G with no repeats."
+                "If you wanted a subgraph of G use G.subgraph(nodelist)"
+            )
+
+    # To handle cases when an edge has weight=0, we must make sure that
+    # nonedges are not given the value 0 as well.
+    A = nx.to_numpy_array(
+        G, nodelist, multigraph_weight=min, weight=weight, nonedge=np.inf
+    )
+    n, m = A.shape
+    np.fill_diagonal(A, 0)  # diagonal elements should be zero
+    for i in range(n):
+        # The second term has the same shape as A due to broadcasting
+        A = np.minimum(A, A[i, :][np.newaxis, :] + A[:, i][:, np.newaxis])
+    return A
+
+
+def floyd_warshall_predecessor_and_distance(G, weight="weight"):
+    """Find all-pairs shortest path lengths using Floyd's algorithm.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight: string, optional (default= 'weight')
+       Edge data key corresponding to the edge weight.
+
+    Returns
+    -------
+    predecessor,distance : dictionaries
+       Dictionaries, keyed by source and target, of predecessors and distances
+       in the shortest path.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_weighted_edges_from(
+    ...     [
+    ...         ("s", "u", 10),
+    ...         ("s", "x", 5),
+    ...         ("u", "v", 1),
+    ...         ("u", "x", 2),
+    ...         ("v", "y", 1),
+    ...         ("x", "u", 3),
+    ...         ("x", "v", 5),
+    ...         ("x", "y", 2),
+    ...         ("y", "s", 7),
+    ...         ("y", "v", 6),
+    ...     ]
+    ... )
+    >>> predecessors, _ = nx.floyd_warshall_predecessor_and_distance(G)
+    >>> print(nx.reconstruct_path("s", "v", predecessors))
+    ['s', 'x', 'u', 'v']
+
+    Notes
+    -----
+    Floyd's algorithm is appropriate for finding shortest paths
+    in dense graphs or graphs with negative weights when Dijkstra's algorithm
+    fails.  This algorithm can still fail if there are negative cycles.
+    It has running time $O(n^3)$ with running space of $O(n^2)$.
+
+    See Also
+    --------
+    floyd_warshall
+    floyd_warshall_numpy
+    all_pairs_shortest_path
+    all_pairs_shortest_path_length
+    """
+    from collections import defaultdict
+
+    # dictionary-of-dictionaries representation for dist and pred
+    # use some defaultdict magick here
+    # for dist the default is the floating point inf value
+    dist = defaultdict(lambda: defaultdict(lambda: float("inf")))
+    for u in G:
+        dist[u][u] = 0
+    pred = defaultdict(dict)
+    # initialize path distance dictionary to be the adjacency matrix
+    # also set the distance to self to 0 (zero diagonal)
+    undirected = not G.is_directed()
+    for u, v, d in G.edges(data=True):
+        e_weight = d.get(weight, 1.0)
+        dist[u][v] = min(e_weight, dist[u][v])
+        pred[u][v] = u
+        if undirected:
+            dist[v][u] = min(e_weight, dist[v][u])
+            pred[v][u] = v
+    for w in G:
+        dist_w = dist[w]  # save recomputation
+        for u in G:
+            dist_u = dist[u]  # save recomputation
+            for v in G:
+                d = dist_u[w] + dist_w[v]
+                if dist_u[v] > d:
+                    dist_u[v] = d
+                    pred[u][v] = pred[w][v]
+    return dict(pred), dict(dist)
+
+
+def reconstruct_path(source, target, predecessors):
+    """Reconstruct a path from source to target using the predecessors
+    dict as returned by floyd_warshall_predecessor_and_distance
+
+    Parameters
+    ----------
+    source : node
+       Starting node for path
+
+    target : node
+       Ending node for path
+
+    predecessors: dictionary
+       Dictionary, keyed by source and target, of predecessors in the
+       shortest path, as returned by floyd_warshall_predecessor_and_distance
+
+    Returns
+    -------
+    path : list
+       A list of nodes containing the shortest path from source to target
+
+       If source and target are the same, an empty list is returned
+
+    Notes
+    -----
+    This function is meant to give more applicability to the
+    floyd_warshall_predecessor_and_distance function
+
+    See Also
+    --------
+    floyd_warshall_predecessor_and_distance
+    """
+    if source == target:
+        return []
+    prev = predecessors[source]
+    curr = prev[target]
+    path = [target, curr]
+    while curr != source:
+        curr = prev[curr]
+        path.append(curr)
+    return list(reversed(path))
+
+
+def floyd_warshall(G, weight="weight"):
+    """Find all-pairs shortest path lengths using Floyd's algorithm.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight: string, optional (default= 'weight')
+       Edge data key corresponding to the edge weight.
+
+
+    Returns
+    -------
+    distance : dict
+       A dictionary,  keyed by source and target, of shortest paths distances
+       between nodes.
+
+    Notes
+    -----
+    Floyd's algorithm is appropriate for finding shortest paths
+    in dense graphs or graphs with negative weights when Dijkstra's algorithm
+    fails.  This algorithm can still fail if there are negative cycles.
+    It has running time $O(n^3)$ with running space of $O(n^2)$.
+
+    See Also
+    --------
+    floyd_warshall_predecessor_and_distance
+    floyd_warshall_numpy
+    all_pairs_shortest_path
+    all_pairs_shortest_path_length
+    """
+    # could make this its own function to reduce memory costs
+    return floyd_warshall_predecessor_and_distance(G, weight=weight)[1]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/generic.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/generic.py
new file mode 100644
index 0000000..129f741
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/generic.py
@@ -0,0 +1,568 @@
+"""
+Compute the shortest paths and path lengths between nodes in the graph.
+
+These algorithms work with undirected and directed graphs.
+
+"""
+
+import networkx as nx
+
+__all__ = [
+    "shortest_path",
+    "all_shortest_paths",
+    "shortest_path_length",
+    "average_shortest_path_length",
+    "has_path",
+]
+
+
+def has_path(G, source, target):
+    """Returns *True* if *G* has a path from *source* to *target*.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Starting node for path
+
+    target : node
+       Ending node for path
+    """
+    try:
+        nx.shortest_path(G, source, target)
+    except nx.NetworkXNoPath:
+        return False
+    return True
+
+
+def shortest_path(G, source=None, target=None, weight=None, method="dijkstra"):
+    """Compute shortest paths in the graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node, optional
+        Starting node for path. If not specified, compute shortest
+        paths for each possible starting node.
+
+    target : node, optional
+        Ending node for path. If not specified, compute shortest
+        paths to all possible nodes.
+
+    weight : None, string or function, optional (default = None)
+        If None, every edge has weight/distance/cost 1.
+        If a string, use this edge attribute as the edge weight.
+        Any edge attribute not present defaults to 1.
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly
+        three positional arguments: the two endpoints of an edge and
+        the dictionary of edge attributes for that edge.
+        The function must return a number.
+
+    method : string, optional (default = 'dijkstra')
+        The algorithm to use to compute the path.
+        Supported options: 'dijkstra', 'bellman-ford'.
+        Other inputs produce a ValueError.
+        If `weight` is None, unweighted graph methods are used, and this
+        suggestion is ignored.
+
+    Returns
+    -------
+    path: list or dictionary
+        All returned paths include both the source and target in the path.
+
+        If the source and target are both specified, return a single list
+        of nodes in a shortest path from the source to the target.
+
+        If only the source is specified, return a dictionary keyed by
+        targets with a list of nodes in a shortest path from the source
+        to one of the targets.
+
+        If only the target is specified, return a dictionary keyed by
+        sources with a list of nodes in a shortest path from one of the
+        sources to the target.
+
+        If neither the source nor target are specified return a dictionary
+        of dictionaries with path[source][target]=[list of nodes in path].
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    ValueError
+        If `method` is not among the supported options.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> print(nx.shortest_path(G, source=0, target=4))
+    [0, 1, 2, 3, 4]
+    >>> p = nx.shortest_path(G, source=0)  # target not specified
+    >>> p[3] # shortest path from source=0 to target=3
+    [0, 1, 2, 3]
+    >>> p = nx.shortest_path(G, target=4)  # source not specified
+    >>> p[1] # shortest path from source=1 to target=4
+    [1, 2, 3, 4]
+    >>> p = nx.shortest_path(G)  # source, target not specified
+    >>> p[2][4] # shortest path from source=2 to target=4
+    [2, 3, 4]
+
+    Notes
+    -----
+    There may be more than one shortest path between a source and target.
+    This returns only one of them.
+
+    See Also
+    --------
+    all_pairs_shortest_path
+    all_pairs_dijkstra_path
+    all_pairs_bellman_ford_path
+    single_source_shortest_path
+    single_source_dijkstra_path
+    single_source_bellman_ford_path
+    """
+    if method not in ("dijkstra", "bellman-ford"):
+        # so we don't need to check in each branch later
+        raise ValueError(f"method not supported: {method}")
+    method = "unweighted" if weight is None else method
+    if source is None:
+        if target is None:
+            # Find paths between all pairs.
+            if method == "unweighted":
+                paths = dict(nx.all_pairs_shortest_path(G))
+            elif method == "dijkstra":
+                paths = dict(nx.all_pairs_dijkstra_path(G, weight=weight))
+            else:  # method == 'bellman-ford':
+                paths = dict(nx.all_pairs_bellman_ford_path(G, weight=weight))
+        else:
+            # Find paths from all nodes co-accessible to the target.
+            if G.is_directed():
+                G = G.reverse(copy=False)
+            if method == "unweighted":
+                paths = nx.single_source_shortest_path(G, target)
+            elif method == "dijkstra":
+                paths = nx.single_source_dijkstra_path(G, target, weight=weight)
+            else:  # method == 'bellman-ford':
+                paths = nx.single_source_bellman_ford_path(G, target, weight=weight)
+            # Now flip the paths so they go from a source to the target.
+            for target in paths:
+                paths[target] = list(reversed(paths[target]))
+    else:
+        if target is None:
+            # Find paths to all nodes accessible from the source.
+            if method == "unweighted":
+                paths = nx.single_source_shortest_path(G, source)
+            elif method == "dijkstra":
+                paths = nx.single_source_dijkstra_path(G, source, weight=weight)
+            else:  # method == 'bellman-ford':
+                paths = nx.single_source_bellman_ford_path(G, source, weight=weight)
+        else:
+            # Find shortest source-target path.
+            if method == "unweighted":
+                paths = nx.bidirectional_shortest_path(G, source, target)
+            elif method == "dijkstra":
+                _, paths = nx.bidirectional_dijkstra(G, source, target, weight)
+            else:  # method == 'bellman-ford':
+                paths = nx.bellman_ford_path(G, source, target, weight)
+    return paths
+
+
+def shortest_path_length(G, source=None, target=None, weight=None, method="dijkstra"):
+    """Compute shortest path lengths in the graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node, optional
+        Starting node for path.
+        If not specified, compute shortest path lengths using all nodes as
+        source nodes.
+
+    target : node, optional
+        Ending node for path.
+        If not specified, compute shortest path lengths using all nodes as
+        target nodes.
+
+    weight : None, string or function, optional (default = None)
+        If None, every edge has weight/distance/cost 1.
+        If a string, use this edge attribute as the edge weight.
+        Any edge attribute not present defaults to 1.
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly
+        three positional arguments: the two endpoints of an edge and
+        the dictionary of edge attributes for that edge.
+        The function must return a number.
+
+    method : string, optional (default = 'dijkstra')
+        The algorithm to use to compute the path length.
+        Supported options: 'dijkstra', 'bellman-ford'.
+        Other inputs produce a ValueError.
+        If `weight` is None, unweighted graph methods are used, and this
+        suggestion is ignored.
+
+    Returns
+    -------
+    length: int or iterator
+        If the source and target are both specified, return the length of
+        the shortest path from the source to the target.
+
+        If only the source is specified, return a dict keyed by target
+        to the shortest path length from the source to that target.
+
+        If only the target is specified, return a dict keyed by source
+        to the shortest path length from that source to the target.
+
+        If neither the source nor target are specified, return an iterator
+        over (source, dictionary) where dictionary is keyed by target to
+        shortest path length from source to that target.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    NetworkXNoPath
+        If no path exists between source and target.
+
+    ValueError
+        If `method` is not among the supported options.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> nx.shortest_path_length(G, source=0, target=4)
+    4
+    >>> p = nx.shortest_path_length(G, source=0)  # target not specified
+    >>> p[4]
+    4
+    >>> p = nx.shortest_path_length(G, target=4)  # source not specified
+    >>> p[0]
+    4
+    >>> p = dict(nx.shortest_path_length(G))  # source,target not specified
+    >>> p[0][4]
+    4
+
+    Notes
+    -----
+    The length of the path is always 1 less than the number of nodes involved
+    in the path since the length measures the number of edges followed.
+
+    For digraphs this returns the shortest directed path length. To find path
+    lengths in the reverse direction use G.reverse(copy=False) first to flip
+    the edge orientation.
+
+    See Also
+    --------
+    all_pairs_shortest_path_length
+    all_pairs_dijkstra_path_length
+    all_pairs_bellman_ford_path_length
+    single_source_shortest_path_length
+    single_source_dijkstra_path_length
+    single_source_bellman_ford_path_length
+    """
+    if method not in ("dijkstra", "bellman-ford"):
+        # so we don't need to check in each branch later
+        raise ValueError(f"method not supported: {method}")
+    method = "unweighted" if weight is None else method
+    if source is None:
+        if target is None:
+            # Find paths between all pairs.
+            if method == "unweighted":
+                paths = nx.all_pairs_shortest_path_length(G)
+            elif method == "dijkstra":
+                paths = nx.all_pairs_dijkstra_path_length(G, weight=weight)
+            else:  # method == 'bellman-ford':
+                paths = nx.all_pairs_bellman_ford_path_length(G, weight=weight)
+        else:
+            # Find paths from all nodes co-accessible to the target.
+            if G.is_directed():
+                G = G.reverse(copy=False)
+            if method == "unweighted":
+                path_length = nx.single_source_shortest_path_length
+                paths = path_length(G, target)
+            elif method == "dijkstra":
+                path_length = nx.single_source_dijkstra_path_length
+                paths = path_length(G, target, weight=weight)
+            else:  # method == 'bellman-ford':
+                path_length = nx.single_source_bellman_ford_path_length
+                paths = path_length(G, target, weight=weight)
+    else:
+        if target is None:
+            # Find paths to all nodes accessible from the source.
+            if method == "unweighted":
+                paths = nx.single_source_shortest_path_length(G, source)
+            elif method == "dijkstra":
+                path_length = nx.single_source_dijkstra_path_length
+                paths = path_length(G, source, weight=weight)
+            else:  # method == 'bellman-ford':
+                path_length = nx.single_source_bellman_ford_path_length
+                paths = path_length(G, source, weight=weight)
+        else:
+            # Find shortest source-target path.
+            if method == "unweighted":
+                p = nx.bidirectional_shortest_path(G, source, target)
+                paths = len(p) - 1
+            elif method == "dijkstra":
+                paths = nx.dijkstra_path_length(G, source, target, weight)
+            else:  # method == 'bellman-ford':
+                paths = nx.bellman_ford_path_length(G, source, target, weight)
+    return paths
+
+
+def average_shortest_path_length(G, weight=None, method=None):
+    r"""Returns the average shortest path length.
+
+    The average shortest path length is
+
+    .. math::
+
+       a =\sum_{s,t \in V} \frac{d(s, t)}{n(n-1)}
+
+    where `V` is the set of nodes in `G`,
+    `d(s, t)` is the shortest path from `s` to `t`,
+    and `n` is the number of nodes in `G`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight : None, string or function, optional (default = None)
+        If None, every edge has weight/distance/cost 1.
+        If a string, use this edge attribute as the edge weight.
+        Any edge attribute not present defaults to 1.
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly
+        three positional arguments: the two endpoints of an edge and
+        the dictionary of edge attributes for that edge.
+        The function must return a number.
+
+    method : string, optional (default = 'unweighted' or 'djikstra')
+        The algorithm to use to compute the path lengths.
+        Supported options are 'unweighted', 'dijkstra', 'bellman-ford',
+        'floyd-warshall' and 'floyd-warshall-numpy'.
+        Other method values produce a ValueError.
+        The default method is 'unweighted' if `weight` is None,
+        otherwise the default method is 'dijkstra'.
+
+    Raises
+    ------
+    NetworkXPointlessConcept
+        If `G` is the null graph (that is, the graph on zero nodes).
+
+    NetworkXError
+        If `G` is not connected (or not weakly connected, in the case
+        of a directed graph).
+
+    ValueError
+        If `method` is not among the supported options.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> nx.average_shortest_path_length(G)
+    2.0
+
+    For disconnected graphs, you can compute the average shortest path
+    length for each component
+
+    >>> G = nx.Graph([(1, 2), (3, 4)])
+    >>> for C in (G.subgraph(c).copy() for c in nx.connected_components(G)):
+    ...     print(nx.average_shortest_path_length(C))
+    1.0
+    1.0
+
+    """
+    single_source_methods = ["unweighted", "dijkstra", "bellman-ford"]
+    all_pairs_methods = ["floyd-warshall", "floyd-warshall-numpy"]
+    supported_methods = single_source_methods + all_pairs_methods
+
+    if method is None:
+        method = "unweighted" if weight is None else "dijkstra"
+    if method not in supported_methods:
+        raise ValueError(f"method not supported: {method}")
+
+    n = len(G)
+    # For the special case of the null graph, raise an exception, since
+    # there are no paths in the null graph.
+    if n == 0:
+        msg = (
+            "the null graph has no paths, thus there is no average"
+            "shortest path length"
+        )
+        raise nx.NetworkXPointlessConcept(msg)
+    # For the special case of the trivial graph, return zero immediately.
+    if n == 1:
+        return 0
+    # Shortest path length is undefined if the graph is disconnected.
+    if G.is_directed() and not nx.is_weakly_connected(G):
+        raise nx.NetworkXError("Graph is not weakly connected.")
+    if not G.is_directed() and not nx.is_connected(G):
+        raise nx.NetworkXError("Graph is not connected.")
+
+    # Compute all-pairs shortest paths.
+    def path_length(v):
+        if method == "unweighted":
+            return nx.single_source_shortest_path_length(G, v)
+        elif method == "dijkstra":
+            return nx.single_source_dijkstra_path_length(G, v, weight=weight)
+        elif method == "bellman-ford":
+            return nx.single_source_bellman_ford_path_length(G, v, weight=weight)
+
+    if method in single_source_methods:
+        # Sum the distances for each (ordered) pair of source and target node.
+        s = sum(l for u in G for l in path_length(u).values())
+    else:
+        if method == "floyd-warshall":
+            all_pairs = nx.floyd_warshall(G, weight=weight)
+            s = sum(sum(t.values()) for t in all_pairs.values())
+        elif method == "floyd-warshall-numpy":
+            s = nx.floyd_warshall_numpy(G, weight=weight).sum()
+    return s / (n * (n - 1))
+
+
+def all_shortest_paths(G, source, target, weight=None, method="dijkstra"):
+    """Compute all shortest simple paths in the graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Starting node for path.
+
+    target : node
+       Ending node for path.
+
+    weight : None, string or function, optional (default = None)
+        If None, every edge has weight/distance/cost 1.
+        If a string, use this edge attribute as the edge weight.
+        Any edge attribute not present defaults to 1.
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly
+        three positional arguments: the two endpoints of an edge and
+        the dictionary of edge attributes for that edge.
+        The function must return a number.
+
+    method : string, optional (default = 'dijkstra')
+       The algorithm to use to compute the path lengths.
+       Supported options: 'dijkstra', 'bellman-ford'.
+       Other inputs produce a ValueError.
+       If `weight` is None, unweighted graph methods are used, and this
+       suggestion is ignored.
+
+    Returns
+    -------
+    paths : generator of lists
+        A generator of all paths between source and target.
+
+    Raises
+    ------
+    ValueError
+        If `method` is not among the supported options.
+
+    NetworkXNoPath
+        If `target` cannot be reached from `source`.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> nx.add_path(G, [0, 1, 2])
+    >>> nx.add_path(G, [0, 10, 2])
+    >>> print([p for p in nx.all_shortest_paths(G, source=0, target=2)])
+    [[0, 1, 2], [0, 10, 2]]
+
+    Notes
+    -----
+    There may be many shortest paths between the source and target.  If G
+    contains zero-weight cycles, this function will not produce all shortest
+    paths because doing so would produce infinitely many paths of unbounded
+    length -- instead, we only produce the shortest simple paths.
+
+    See Also
+    --------
+    shortest_path
+    single_source_shortest_path
+    all_pairs_shortest_path
+    """
+    method = "unweighted" if weight is None else method
+    if method == "unweighted":
+        pred = nx.predecessor(G, source)
+    elif method == "dijkstra":
+        pred, dist = nx.dijkstra_predecessor_and_distance(G, source, weight=weight)
+    elif method == "bellman-ford":
+        pred, dist = nx.bellman_ford_predecessor_and_distance(G, source, weight=weight)
+    else:
+        raise ValueError(f"method not supported: {method}")
+
+    return _build_paths_from_predecessors({source}, target, pred)
+
+
+def _build_paths_from_predecessors(sources, target, pred):
+    """Compute all simple paths to target, given the predecessors found in
+    pred, terminating when any source in sources is found.
+
+    Parameters
+    ----------
+    sources : set
+       Starting nodes for path.
+
+    target : node
+       Ending node for path.
+
+    pred : dict
+       A dictionary of predecessor lists, keyed by node
+
+    Returns
+    -------
+    paths : generator of lists
+        A generator of all paths between source and target.
+
+    Raises
+    ------
+    NetworkXNoPath
+        If `target` cannot be reached from `source`.
+
+    Notes
+    -----
+    There may be many paths between the sources and target.  If there are
+    cycles among the predecessors, this function will not produce all
+    possible paths because doing so would produce infinitely many paths
+    of unbounded length -- instead, we only produce simple paths.
+
+    See Also
+    --------
+    shortest_path
+    single_source_shortest_path
+    all_pairs_shortest_path
+    all_shortest_paths
+    bellman_ford_path
+    """
+    if target not in pred:
+        raise nx.NetworkXNoPath(f"Target {target} cannot be reached from given sources")
+
+    seen = {target}
+    stack = [[target, 0]]
+    top = 0
+    while top >= 0:
+        node, i = stack[top]
+        if node in sources:
+            yield [p for p, n in reversed(stack[: top + 1])]
+        if len(pred[node]) > i:
+            stack[top][1] = i + 1
+            next = pred[node][i]
+            if next in seen:
+                continue
+            else:
+                seen.add(next)
+            top += 1
+            if top == len(stack):
+                stack.append([next, 0])
+            else:
+                stack[top][:] = [next, 0]
+        else:
+            seen.discard(node)
+            top -= 1
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_astar.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_astar.py
new file mode 100644
index 0000000..e622502
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_astar.py
@@ -0,0 +1,177 @@
+import pytest
+
+import networkx as nx
+from networkx.utils import pairwise
+
+
+class TestAStar:
+    @classmethod
+    def setup_class(cls):
+        edges = [
+            ("s", "u", 10),
+            ("s", "x", 5),
+            ("u", "v", 1),
+            ("u", "x", 2),
+            ("v", "y", 1),
+            ("x", "u", 3),
+            ("x", "v", 5),
+            ("x", "y", 2),
+            ("y", "s", 7),
+            ("y", "v", 6),
+        ]
+        cls.XG = nx.DiGraph()
+        cls.XG.add_weighted_edges_from(edges)
+
+    def test_multiple_optimal_paths(self):
+        """Tests that A* algorithm finds any of multiple optimal paths"""
+        heuristic_values = {"a": 1.35, "b": 1.18, "c": 0.67, "d": 0}
+
+        def h(u, v):
+            return heuristic_values[u]
+
+        graph = nx.Graph()
+        points = ["a", "b", "c", "d"]
+        edges = [("a", "b", 0.18), ("a", "c", 0.68), ("b", "c", 0.50), ("c", "d", 0.67)]
+
+        graph.add_nodes_from(points)
+        graph.add_weighted_edges_from(edges)
+
+        path1 = ["a", "c", "d"]
+        path2 = ["a", "b", "c", "d"]
+        assert nx.astar_path(graph, "a", "d", h) in (path1, path2)
+
+    def test_astar_directed(self):
+        assert nx.astar_path(self.XG, "s", "v") == ["s", "x", "u", "v"]
+        assert nx.astar_path_length(self.XG, "s", "v") == 9
+
+    def test_astar_multigraph(self):
+        G = nx.MultiDiGraph(self.XG)
+        G.add_weighted_edges_from((u, v, 1000) for (u, v) in list(G.edges()))
+        assert nx.astar_path(G, "s", "v") == ["s", "x", "u", "v"]
+        assert nx.astar_path_length(G, "s", "v") == 9
+
+    def test_astar_undirected(self):
+        GG = self.XG.to_undirected()
+        # make sure we get lower weight
+        # to_undirected might choose either edge with weight 2 or weight 3
+        GG["u"]["x"]["weight"] = 2
+        GG["y"]["v"]["weight"] = 2
+        assert nx.astar_path(GG, "s", "v") == ["s", "x", "u", "v"]
+        assert nx.astar_path_length(GG, "s", "v") == 8
+
+    def test_astar_directed2(self):
+        XG2 = nx.DiGraph()
+        edges = [
+            (1, 4, 1),
+            (4, 5, 1),
+            (5, 6, 1),
+            (6, 3, 1),
+            (1, 3, 50),
+            (1, 2, 100),
+            (2, 3, 100),
+        ]
+        XG2.add_weighted_edges_from(edges)
+        assert nx.astar_path(XG2, 1, 3) == [1, 4, 5, 6, 3]
+
+    def test_astar_undirected2(self):
+        XG3 = nx.Graph()
+        edges = [(0, 1, 2), (1, 2, 12), (2, 3, 1), (3, 4, 5), (4, 5, 1), (5, 0, 10)]
+        XG3.add_weighted_edges_from(edges)
+        assert nx.astar_path(XG3, 0, 3) == [0, 1, 2, 3]
+        assert nx.astar_path_length(XG3, 0, 3) == 15
+
+    def test_astar_undirected3(self):
+        XG4 = nx.Graph()
+        edges = [
+            (0, 1, 2),
+            (1, 2, 2),
+            (2, 3, 1),
+            (3, 4, 1),
+            (4, 5, 1),
+            (5, 6, 1),
+            (6, 7, 1),
+            (7, 0, 1),
+        ]
+        XG4.add_weighted_edges_from(edges)
+        assert nx.astar_path(XG4, 0, 2) == [0, 1, 2]
+        assert nx.astar_path_length(XG4, 0, 2) == 4
+
+    """ Tests that A* finds correct path when multiple paths exist
+        and the best one is not expanded first (GH issue #3464)
+    """
+
+    def test_astar_directed3(self):
+        heuristic_values = {"n5": 36, "n2": 4, "n1": 0, "n0": 0}
+
+        def h(u, v):
+            return heuristic_values[u]
+
+        edges = [("n5", "n1", 11), ("n5", "n2", 9), ("n2", "n1", 1), ("n1", "n0", 32)]
+        graph = nx.DiGraph()
+        graph.add_weighted_edges_from(edges)
+        answer = ["n5", "n2", "n1", "n0"]
+        assert nx.astar_path(graph, "n5", "n0", h) == answer
+
+    """ Tests that parent is not wrongly overridden when a node
+        is re-explored multiple times.
+    """
+
+    def test_astar_directed4(self):
+        edges = [
+            ("a", "b", 1),
+            ("a", "c", 1),
+            ("b", "d", 2),
+            ("c", "d", 1),
+            ("d", "e", 1),
+        ]
+        graph = nx.DiGraph()
+        graph.add_weighted_edges_from(edges)
+        assert nx.astar_path(graph, "a", "e") == ["a", "c", "d", "e"]
+
+    # >>> MXG4=NX.MultiGraph(XG4)
+    # >>> MXG4.add_edge(0,1,3)
+    # >>> NX.dijkstra_path(MXG4,0,2)
+    # [0, 1, 2]
+
+    def test_astar_w1(self):
+        G = nx.DiGraph()
+        G.add_edges_from(
+            [
+                ("s", "u"),
+                ("s", "x"),
+                ("u", "v"),
+                ("u", "x"),
+                ("v", "y"),
+                ("x", "u"),
+                ("x", "w"),
+                ("w", "v"),
+                ("x", "y"),
+                ("y", "s"),
+                ("y", "v"),
+            ]
+        )
+        assert nx.astar_path(G, "s", "v") == ["s", "u", "v"]
+        assert nx.astar_path_length(G, "s", "v") == 2
+
+    def test_astar_nopath(self):
+        with pytest.raises(nx.NodeNotFound):
+            nx.astar_path(self.XG, "s", "moon")
+
+    def test_cycle(self):
+        C = nx.cycle_graph(7)
+        assert nx.astar_path(C, 0, 3) == [0, 1, 2, 3]
+        assert nx.dijkstra_path(C, 0, 4) == [0, 6, 5, 4]
+
+    def test_unorderable_nodes(self):
+        """Tests that A* accommodates nodes that are not orderable.
+
+        For more information, see issue #554.
+
+        """
+        # Create the cycle graph on four nodes, with nodes represented
+        # as (unorderable) Python objects.
+        nodes = [object() for n in range(4)]
+        G = nx.Graph()
+        G.add_edges_from(pairwise(nodes, cyclic=True))
+        path = nx.astar_path(G, nodes[0], nodes[2])
+        assert len(path) == 3
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_dense.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_dense.py
new file mode 100644
index 0000000..6923bfe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_dense.py
@@ -0,0 +1,212 @@
+import pytest
+
+import networkx as nx
+
+
+class TestFloyd:
+    @classmethod
+    def setup_class(cls):
+        pass
+
+    def test_floyd_warshall_predecessor_and_distance(self):
+        XG = nx.DiGraph()
+        XG.add_weighted_edges_from(
+            [
+                ("s", "u", 10),
+                ("s", "x", 5),
+                ("u", "v", 1),
+                ("u", "x", 2),
+                ("v", "y", 1),
+                ("x", "u", 3),
+                ("x", "v", 5),
+                ("x", "y", 2),
+                ("y", "s", 7),
+                ("y", "v", 6),
+            ]
+        )
+        path, dist = nx.floyd_warshall_predecessor_and_distance(XG)
+        assert dist["s"]["v"] == 9
+        assert path["s"]["v"] == "u"
+        assert dist == {
+            "y": {"y": 0, "x": 12, "s": 7, "u": 15, "v": 6},
+            "x": {"y": 2, "x": 0, "s": 9, "u": 3, "v": 4},
+            "s": {"y": 7, "x": 5, "s": 0, "u": 8, "v": 9},
+            "u": {"y": 2, "x": 2, "s": 9, "u": 0, "v": 1},
+            "v": {"y": 1, "x": 13, "s": 8, "u": 16, "v": 0},
+        }
+
+        GG = XG.to_undirected()
+        # make sure we get lower weight
+        # to_undirected might choose either edge with weight 2 or weight 3
+        GG["u"]["x"]["weight"] = 2
+        path, dist = nx.floyd_warshall_predecessor_and_distance(GG)
+        assert dist["s"]["v"] == 8
+        # skip this test, could be alternate path s-u-v
+        #        assert_equal(path['s']['v'],'y')
+
+        G = nx.DiGraph()  # no weights
+        G.add_edges_from(
+            [
+                ("s", "u"),
+                ("s", "x"),
+                ("u", "v"),
+                ("u", "x"),
+                ("v", "y"),
+                ("x", "u"),
+                ("x", "v"),
+                ("x", "y"),
+                ("y", "s"),
+                ("y", "v"),
+            ]
+        )
+        path, dist = nx.floyd_warshall_predecessor_and_distance(G)
+        assert dist["s"]["v"] == 2
+        # skip this test, could be alternate path s-u-v
+        # assert_equal(path['s']['v'],'x')
+
+        # alternate interface
+        dist = nx.floyd_warshall(G)
+        assert dist["s"]["v"] == 2
+
+        # floyd_warshall_predecessor_and_distance returns
+        # dicts-of-defautdicts
+        # make sure we don't get empty dictionary
+        XG = nx.DiGraph()
+        XG.add_weighted_edges_from(
+            [("v", "x", 5.0), ("y", "x", 5.0), ("v", "y", 6.0), ("x", "u", 2.0)]
+        )
+        path, dist = nx.floyd_warshall_predecessor_and_distance(XG)
+        inf = float("inf")
+        assert dist == {
+            "v": {"v": 0, "x": 5.0, "y": 6.0, "u": 7.0},
+            "x": {"x": 0, "u": 2.0, "v": inf, "y": inf},
+            "y": {"y": 0, "x": 5.0, "v": inf, "u": 7.0},
+            "u": {"u": 0, "v": inf, "x": inf, "y": inf},
+        }
+        assert path == {
+            "v": {"x": "v", "y": "v", "u": "x"},
+            "x": {"u": "x"},
+            "y": {"x": "y", "u": "x"},
+        }
+
+    def test_reconstruct_path(self):
+        with pytest.raises(KeyError):
+            XG = nx.DiGraph()
+            XG.add_weighted_edges_from(
+                [
+                    ("s", "u", 10),
+                    ("s", "x", 5),
+                    ("u", "v", 1),
+                    ("u", "x", 2),
+                    ("v", "y", 1),
+                    ("x", "u", 3),
+                    ("x", "v", 5),
+                    ("x", "y", 2),
+                    ("y", "s", 7),
+                    ("y", "v", 6),
+                ]
+            )
+            predecessors, _ = nx.floyd_warshall_predecessor_and_distance(XG)
+
+            path = nx.reconstruct_path("s", "v", predecessors)
+            assert path == ["s", "x", "u", "v"]
+
+            path = nx.reconstruct_path("s", "s", predecessors)
+            assert path == []
+
+            # this part raises the keyError
+            nx.reconstruct_path("1", "2", predecessors)
+
+    def test_cycle(self):
+        path, dist = nx.floyd_warshall_predecessor_and_distance(nx.cycle_graph(7))
+        assert dist[0][3] == 3
+        assert path[0][3] == 2
+        assert dist[0][4] == 3
+
+    def test_weighted(self):
+        XG3 = nx.Graph()
+        XG3.add_weighted_edges_from(
+            [[0, 1, 2], [1, 2, 12], [2, 3, 1], [3, 4, 5], [4, 5, 1], [5, 0, 10]]
+        )
+        path, dist = nx.floyd_warshall_predecessor_and_distance(XG3)
+        assert dist[0][3] == 15
+        assert path[0][3] == 2
+
+    def test_weighted2(self):
+        XG4 = nx.Graph()
+        XG4.add_weighted_edges_from(
+            [
+                [0, 1, 2],
+                [1, 2, 2],
+                [2, 3, 1],
+                [3, 4, 1],
+                [4, 5, 1],
+                [5, 6, 1],
+                [6, 7, 1],
+                [7, 0, 1],
+            ]
+        )
+        path, dist = nx.floyd_warshall_predecessor_and_distance(XG4)
+        assert dist[0][2] == 4
+        assert path[0][2] == 1
+
+    def test_weight_parameter(self):
+        XG4 = nx.Graph()
+        XG4.add_edges_from(
+            [
+                (0, 1, {"heavy": 2}),
+                (1, 2, {"heavy": 2}),
+                (2, 3, {"heavy": 1}),
+                (3, 4, {"heavy": 1}),
+                (4, 5, {"heavy": 1}),
+                (5, 6, {"heavy": 1}),
+                (6, 7, {"heavy": 1}),
+                (7, 0, {"heavy": 1}),
+            ]
+        )
+        path, dist = nx.floyd_warshall_predecessor_and_distance(XG4, weight="heavy")
+        assert dist[0][2] == 4
+        assert path[0][2] == 1
+
+    def test_zero_distance(self):
+        XG = nx.DiGraph()
+        XG.add_weighted_edges_from(
+            [
+                ("s", "u", 10),
+                ("s", "x", 5),
+                ("u", "v", 1),
+                ("u", "x", 2),
+                ("v", "y", 1),
+                ("x", "u", 3),
+                ("x", "v", 5),
+                ("x", "y", 2),
+                ("y", "s", 7),
+                ("y", "v", 6),
+            ]
+        )
+        path, dist = nx.floyd_warshall_predecessor_and_distance(XG)
+
+        for u in XG:
+            assert dist[u][u] == 0
+
+        GG = XG.to_undirected()
+        # make sure we get lower weight
+        # to_undirected might choose either edge with weight 2 or weight 3
+        GG["u"]["x"]["weight"] = 2
+        path, dist = nx.floyd_warshall_predecessor_and_distance(GG)
+
+        for u in GG:
+            dist[u][u] = 0
+
+    def test_zero_weight(self):
+        G = nx.DiGraph()
+        edges = [(1, 2, -2), (2, 3, -4), (1, 5, 1), (5, 4, 0), (4, 3, -5), (2, 5, -7)]
+        G.add_weighted_edges_from(edges)
+        dist = nx.floyd_warshall(G)
+        assert dist[1][3] == -14
+
+        G = nx.MultiDiGraph()
+        edges.append((2, 5, -7))
+        G.add_weighted_edges_from(edges)
+        dist = nx.floyd_warshall(G)
+        assert dist[1][3] == -14
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_dense_numpy.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_dense_numpy.py
new file mode 100644
index 0000000..1316e23
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_dense_numpy.py
@@ -0,0 +1,89 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+
+
+import networkx as nx
+
+
+def test_cycle_numpy():
+    dist = nx.floyd_warshall_numpy(nx.cycle_graph(7))
+    assert dist[0, 3] == 3
+    assert dist[0, 4] == 3
+
+
+def test_weighted_numpy_three_edges():
+    XG3 = nx.Graph()
+    XG3.add_weighted_edges_from(
+        [[0, 1, 2], [1, 2, 12], [2, 3, 1], [3, 4, 5], [4, 5, 1], [5, 0, 10]]
+    )
+    dist = nx.floyd_warshall_numpy(XG3)
+    assert dist[0, 3] == 15
+
+
+def test_weighted_numpy_two_edges():
+    XG4 = nx.Graph()
+    XG4.add_weighted_edges_from(
+        [
+            [0, 1, 2],
+            [1, 2, 2],
+            [2, 3, 1],
+            [3, 4, 1],
+            [4, 5, 1],
+            [5, 6, 1],
+            [6, 7, 1],
+            [7, 0, 1],
+        ]
+    )
+    dist = nx.floyd_warshall_numpy(XG4)
+    assert dist[0, 2] == 4
+
+
+def test_weight_parameter_numpy():
+    XG4 = nx.Graph()
+    XG4.add_edges_from(
+        [
+            (0, 1, {"heavy": 2}),
+            (1, 2, {"heavy": 2}),
+            (2, 3, {"heavy": 1}),
+            (3, 4, {"heavy": 1}),
+            (4, 5, {"heavy": 1}),
+            (5, 6, {"heavy": 1}),
+            (6, 7, {"heavy": 1}),
+            (7, 0, {"heavy": 1}),
+        ]
+    )
+    dist = nx.floyd_warshall_numpy(XG4, weight="heavy")
+    assert dist[0, 2] == 4
+
+
+def test_directed_cycle_numpy():
+    G = nx.DiGraph()
+    nx.add_cycle(G, [0, 1, 2, 3])
+    pred, dist = nx.floyd_warshall_predecessor_and_distance(G)
+    D = nx.utils.dict_to_numpy_array(dist)
+    np.testing.assert_equal(nx.floyd_warshall_numpy(G), D)
+
+
+def test_zero_weight():
+    G = nx.DiGraph()
+    edges = [(1, 2, -2), (2, 3, -4), (1, 5, 1), (5, 4, 0), (4, 3, -5), (2, 5, -7)]
+    G.add_weighted_edges_from(edges)
+    dist = nx.floyd_warshall_numpy(G)
+    assert int(np.min(dist)) == -14
+
+    G = nx.MultiDiGraph()
+    edges.append((2, 5, -7))
+    G.add_weighted_edges_from(edges)
+    dist = nx.floyd_warshall_numpy(G)
+    assert int(np.min(dist)) == -14
+
+
+def test_nodelist():
+    G = nx.path_graph(7)
+    dist = nx.floyd_warshall_numpy(G, nodelist=[3, 5, 4, 6, 2, 1, 0])
+    assert dist[0, 3] == 3
+    assert dist[0, 1] == 2
+    assert dist[6, 2] == 4
+    pytest.raises(nx.NetworkXError, nx.floyd_warshall_numpy, G, [1, 3])
+    pytest.raises(nx.NetworkXError, nx.floyd_warshall_numpy, G, list(range(9)))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_generic.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_generic.py
new file mode 100644
index 0000000..093fd9c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_generic.py
@@ -0,0 +1,377 @@
+import pytest
+
+import networkx as nx
+
+
+def validate_grid_path(r, c, s, t, p):
+    assert isinstance(p, list)
+    assert p[0] == s
+    assert p[-1] == t
+    s = ((s - 1) // c, (s - 1) % c)
+    t = ((t - 1) // c, (t - 1) % c)
+    assert len(p) == abs(t[0] - s[0]) + abs(t[1] - s[1]) + 1
+    p = [((u - 1) // c, (u - 1) % c) for u in p]
+    for u in p:
+        assert 0 <= u[0] < r
+        assert 0 <= u[1] < c
+    for u, v in zip(p[:-1], p[1:]):
+        assert (abs(v[0] - u[0]), abs(v[1] - u[1])) in [(0, 1), (1, 0)]
+
+
+class TestGenericPath:
+    @classmethod
+    def setup_class(cls):
+        from networkx import convert_node_labels_to_integers as cnlti
+
+        cls.grid = cnlti(nx.grid_2d_graph(4, 4), first_label=1, ordering="sorted")
+        cls.cycle = nx.cycle_graph(7)
+        cls.directed_cycle = nx.cycle_graph(7, create_using=nx.DiGraph())
+        cls.neg_weights = nx.DiGraph()
+        cls.neg_weights.add_edge(0, 1, weight=1)
+        cls.neg_weights.add_edge(0, 2, weight=3)
+        cls.neg_weights.add_edge(1, 3, weight=1)
+        cls.neg_weights.add_edge(2, 3, weight=-2)
+
+    def test_shortest_path(self):
+        assert nx.shortest_path(self.cycle, 0, 3) == [0, 1, 2, 3]
+        assert nx.shortest_path(self.cycle, 0, 4) == [0, 6, 5, 4]
+        validate_grid_path(4, 4, 1, 12, nx.shortest_path(self.grid, 1, 12))
+        assert nx.shortest_path(self.directed_cycle, 0, 3) == [0, 1, 2, 3]
+        # now with weights
+        assert nx.shortest_path(self.cycle, 0, 3, weight="weight") == [0, 1, 2, 3]
+        assert nx.shortest_path(self.cycle, 0, 4, weight="weight") == [0, 6, 5, 4]
+        validate_grid_path(
+            4, 4, 1, 12, nx.shortest_path(self.grid, 1, 12, weight="weight")
+        )
+        assert nx.shortest_path(self.directed_cycle, 0, 3, weight="weight") == [
+            0,
+            1,
+            2,
+            3,
+        ]
+        # weights and method specified
+        assert nx.shortest_path(
+            self.directed_cycle, 0, 3, weight="weight", method="dijkstra"
+        ) == [0, 1, 2, 3]
+        assert nx.shortest_path(
+            self.directed_cycle, 0, 3, weight="weight", method="bellman-ford"
+        ) == [0, 1, 2, 3]
+        # when Dijkstra's will probably (depending on precise implementation)
+        # incorrectly return [0, 1, 3] instead
+        assert nx.shortest_path(
+            self.neg_weights, 0, 3, weight="weight", method="bellman-ford"
+        ) == [0, 2, 3]
+        # confirm bad method rejection
+        pytest.raises(ValueError, nx.shortest_path, self.cycle, method="SPAM")
+        # confirm absent source rejection
+        pytest.raises(nx.NodeNotFound, nx.shortest_path, self.cycle, 8)
+
+    def test_shortest_path_target(self):
+        answer = {0: [0, 1], 1: [1], 2: [2, 1]}
+        sp = nx.shortest_path(nx.path_graph(3), target=1)
+        assert sp == answer
+        # with weights
+        sp = nx.shortest_path(nx.path_graph(3), target=1, weight="weight")
+        assert sp == answer
+        # weights and method specified
+        sp = nx.shortest_path(
+            nx.path_graph(3), target=1, weight="weight", method="dijkstra"
+        )
+        assert sp == answer
+        sp = nx.shortest_path(
+            nx.path_graph(3), target=1, weight="weight", method="bellman-ford"
+        )
+        assert sp == answer
+
+    def test_shortest_path_length(self):
+        assert nx.shortest_path_length(self.cycle, 0, 3) == 3
+        assert nx.shortest_path_length(self.grid, 1, 12) == 5
+        assert nx.shortest_path_length(self.directed_cycle, 0, 4) == 4
+        # now with weights
+        assert nx.shortest_path_length(self.cycle, 0, 3, weight="weight") == 3
+        assert nx.shortest_path_length(self.grid, 1, 12, weight="weight") == 5
+        assert nx.shortest_path_length(self.directed_cycle, 0, 4, weight="weight") == 4
+        # weights and method specified
+        assert (
+            nx.shortest_path_length(
+                self.cycle, 0, 3, weight="weight", method="dijkstra"
+            )
+            == 3
+        )
+        assert (
+            nx.shortest_path_length(
+                self.cycle, 0, 3, weight="weight", method="bellman-ford"
+            )
+            == 3
+        )
+        # confirm bad method rejection
+        pytest.raises(ValueError, nx.shortest_path_length, self.cycle, method="SPAM")
+        # confirm absent source rejection
+        pytest.raises(nx.NodeNotFound, nx.shortest_path_length, self.cycle, 8)
+
+    def test_shortest_path_length_target(self):
+        answer = {0: 1, 1: 0, 2: 1}
+        sp = dict(nx.shortest_path_length(nx.path_graph(3), target=1))
+        assert sp == answer
+        # with weights
+        sp = nx.shortest_path_length(nx.path_graph(3), target=1, weight="weight")
+        assert sp == answer
+        # weights and method specified
+        sp = nx.shortest_path_length(
+            nx.path_graph(3), target=1, weight="weight", method="dijkstra"
+        )
+        assert sp == answer
+        sp = nx.shortest_path_length(
+            nx.path_graph(3), target=1, weight="weight", method="bellman-ford"
+        )
+        assert sp == answer
+
+    def test_single_source_shortest_path(self):
+        p = nx.shortest_path(self.cycle, 0)
+        assert p[3] == [0, 1, 2, 3]
+        assert p == nx.single_source_shortest_path(self.cycle, 0)
+        p = nx.shortest_path(self.grid, 1)
+        validate_grid_path(4, 4, 1, 12, p[12])
+        # now with weights
+        p = nx.shortest_path(self.cycle, 0, weight="weight")
+        assert p[3] == [0, 1, 2, 3]
+        assert p == nx.single_source_dijkstra_path(self.cycle, 0)
+        p = nx.shortest_path(self.grid, 1, weight="weight")
+        validate_grid_path(4, 4, 1, 12, p[12])
+        # weights and method specified
+        p = nx.shortest_path(self.cycle, 0, method="dijkstra", weight="weight")
+        assert p[3] == [0, 1, 2, 3]
+        assert p == nx.single_source_shortest_path(self.cycle, 0)
+        p = nx.shortest_path(self.cycle, 0, method="bellman-ford", weight="weight")
+        assert p[3] == [0, 1, 2, 3]
+        assert p == nx.single_source_shortest_path(self.cycle, 0)
+
+    def test_single_source_shortest_path_length(self):
+        ans = dict(nx.shortest_path_length(self.cycle, 0))
+        assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        assert ans == dict(nx.single_source_shortest_path_length(self.cycle, 0))
+        ans = dict(nx.shortest_path_length(self.grid, 1))
+        assert ans[16] == 6
+        # now with weights
+        ans = dict(nx.shortest_path_length(self.cycle, 0, weight="weight"))
+        assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        assert ans == dict(nx.single_source_dijkstra_path_length(self.cycle, 0))
+        ans = dict(nx.shortest_path_length(self.grid, 1, weight="weight"))
+        assert ans[16] == 6
+        # weights and method specified
+        ans = dict(
+            nx.shortest_path_length(self.cycle, 0, weight="weight", method="dijkstra")
+        )
+        assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        assert ans == dict(nx.single_source_dijkstra_path_length(self.cycle, 0))
+        ans = dict(
+            nx.shortest_path_length(
+                self.cycle, 0, weight="weight", method="bellman-ford"
+            )
+        )
+        assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        assert ans == dict(nx.single_source_bellman_ford_path_length(self.cycle, 0))
+
+    def test_all_pairs_shortest_path(self):
+        p = nx.shortest_path(self.cycle)
+        assert p[0][3] == [0, 1, 2, 3]
+        assert p == dict(nx.all_pairs_shortest_path(self.cycle))
+        p = nx.shortest_path(self.grid)
+        validate_grid_path(4, 4, 1, 12, p[1][12])
+        # now with weights
+        p = nx.shortest_path(self.cycle, weight="weight")
+        assert p[0][3] == [0, 1, 2, 3]
+        assert p == dict(nx.all_pairs_dijkstra_path(self.cycle))
+        p = nx.shortest_path(self.grid, weight="weight")
+        validate_grid_path(4, 4, 1, 12, p[1][12])
+        # weights and method specified
+        p = nx.shortest_path(self.cycle, weight="weight", method="dijkstra")
+        assert p[0][3] == [0, 1, 2, 3]
+        assert p == dict(nx.all_pairs_dijkstra_path(self.cycle))
+        p = nx.shortest_path(self.cycle, weight="weight", method="bellman-ford")
+        assert p[0][3] == [0, 1, 2, 3]
+        assert p == dict(nx.all_pairs_bellman_ford_path(self.cycle))
+
+    def test_all_pairs_shortest_path_length(self):
+        ans = dict(nx.shortest_path_length(self.cycle))
+        assert ans[0] == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        assert ans == dict(nx.all_pairs_shortest_path_length(self.cycle))
+        ans = dict(nx.shortest_path_length(self.grid))
+        assert ans[1][16] == 6
+        # now with weights
+        ans = dict(nx.shortest_path_length(self.cycle, weight="weight"))
+        assert ans[0] == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        assert ans == dict(nx.all_pairs_dijkstra_path_length(self.cycle))
+        ans = dict(nx.shortest_path_length(self.grid, weight="weight"))
+        assert ans[1][16] == 6
+        # weights and method specified
+        ans = dict(
+            nx.shortest_path_length(self.cycle, weight="weight", method="dijkstra")
+        )
+        assert ans[0] == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        assert ans == dict(nx.all_pairs_dijkstra_path_length(self.cycle))
+        ans = dict(
+            nx.shortest_path_length(self.cycle, weight="weight", method="bellman-ford")
+        )
+        assert ans[0] == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        assert ans == dict(nx.all_pairs_bellman_ford_path_length(self.cycle))
+
+    def test_has_path(self):
+        G = nx.Graph()
+        nx.add_path(G, range(3))
+        nx.add_path(G, range(3, 5))
+        assert nx.has_path(G, 0, 2)
+        assert not nx.has_path(G, 0, 4)
+
+    def test_all_shortest_paths(self):
+        G = nx.Graph()
+        nx.add_path(G, [0, 1, 2, 3])
+        nx.add_path(G, [0, 10, 20, 3])
+        assert [[0, 1, 2, 3], [0, 10, 20, 3]] == sorted(nx.all_shortest_paths(G, 0, 3))
+        # with weights
+        G = nx.Graph()
+        nx.add_path(G, [0, 1, 2, 3])
+        nx.add_path(G, [0, 10, 20, 3])
+        assert [[0, 1, 2, 3], [0, 10, 20, 3]] == sorted(
+            nx.all_shortest_paths(G, 0, 3, weight="weight")
+        )
+        # weights and method specified
+        G = nx.Graph()
+        nx.add_path(G, [0, 1, 2, 3])
+        nx.add_path(G, [0, 10, 20, 3])
+        assert [[0, 1, 2, 3], [0, 10, 20, 3]] == sorted(
+            nx.all_shortest_paths(G, 0, 3, weight="weight", method="dijkstra")
+        )
+        G = nx.Graph()
+        nx.add_path(G, [0, 1, 2, 3])
+        nx.add_path(G, [0, 10, 20, 3])
+        assert [[0, 1, 2, 3], [0, 10, 20, 3]] == sorted(
+            nx.all_shortest_paths(G, 0, 3, weight="weight", method="bellman-ford")
+        )
+
+    def test_all_shortest_paths_raise(self):
+        with pytest.raises(nx.NetworkXNoPath):
+            G = nx.path_graph(4)
+            G.add_node(4)
+            list(nx.all_shortest_paths(G, 0, 4))
+
+    def test_bad_method(self):
+        with pytest.raises(ValueError):
+            G = nx.path_graph(2)
+            list(nx.all_shortest_paths(G, 0, 1, weight="weight", method="SPAM"))
+
+    def test_all_shortest_paths_zero_weight_edge(self):
+        g = nx.Graph()
+        nx.add_path(g, [0, 1, 3])
+        nx.add_path(g, [0, 1, 2, 3])
+        g.edges[1, 2]["weight"] = 0
+        paths30d = list(
+            nx.all_shortest_paths(g, 3, 0, weight="weight", method="dijkstra")
+        )
+        paths03d = list(
+            nx.all_shortest_paths(g, 0, 3, weight="weight", method="dijkstra")
+        )
+        paths30b = list(
+            nx.all_shortest_paths(g, 3, 0, weight="weight", method="bellman-ford")
+        )
+        paths03b = list(
+            nx.all_shortest_paths(g, 0, 3, weight="weight", method="bellman-ford")
+        )
+        assert sorted(paths03d) == sorted(p[::-1] for p in paths30d)
+        assert sorted(paths03d) == sorted(p[::-1] for p in paths30b)
+        assert sorted(paths03b) == sorted(p[::-1] for p in paths30b)
+
+
+class TestAverageShortestPathLength:
+    def test_cycle_graph(self):
+        ans = nx.average_shortest_path_length(nx.cycle_graph(7))
+        assert ans == pytest.approx(2, abs=1e-7)
+
+    def test_path_graph(self):
+        ans = nx.average_shortest_path_length(nx.path_graph(5))
+        assert ans == pytest.approx(2, abs=1e-7)
+
+    def test_weighted(self):
+        G = nx.Graph()
+        nx.add_cycle(G, range(7), weight=2)
+        ans = nx.average_shortest_path_length(G, weight="weight")
+        assert ans == pytest.approx(4, abs=1e-7)
+        G = nx.Graph()
+        nx.add_path(G, range(5), weight=2)
+        ans = nx.average_shortest_path_length(G, weight="weight")
+        assert ans == pytest.approx(4, abs=1e-7)
+
+    def test_specified_methods(self):
+        G = nx.Graph()
+        nx.add_cycle(G, range(7), weight=2)
+        ans = nx.average_shortest_path_length(G, weight="weight", method="dijkstra")
+        assert ans == pytest.approx(4, abs=1e-7)
+        ans = nx.average_shortest_path_length(G, weight="weight", method="bellman-ford")
+        assert ans == pytest.approx(4, abs=1e-7)
+        ans = nx.average_shortest_path_length(
+            G, weight="weight", method="floyd-warshall"
+        )
+        assert ans == pytest.approx(4, abs=1e-7)
+
+        G = nx.Graph()
+        nx.add_path(G, range(5), weight=2)
+        ans = nx.average_shortest_path_length(G, weight="weight", method="dijkstra")
+        assert ans == pytest.approx(4, abs=1e-7)
+        ans = nx.average_shortest_path_length(G, weight="weight", method="bellman-ford")
+        assert ans == pytest.approx(4, abs=1e-7)
+        ans = nx.average_shortest_path_length(
+            G, weight="weight", method="floyd-warshall"
+        )
+        assert ans == pytest.approx(4, abs=1e-7)
+
+    def test_disconnected(self):
+        g = nx.Graph()
+        g.add_nodes_from(range(3))
+        g.add_edge(0, 1)
+        pytest.raises(nx.NetworkXError, nx.average_shortest_path_length, g)
+        g = g.to_directed()
+        pytest.raises(nx.NetworkXError, nx.average_shortest_path_length, g)
+
+    def test_trivial_graph(self):
+        """Tests that the trivial graph has average path length zero,
+        since there is exactly one path of length zero in the trivial
+        graph.
+
+        For more information, see issue #1960.
+
+        """
+        G = nx.trivial_graph()
+        assert nx.average_shortest_path_length(G) == 0
+
+    def test_null_graph(self):
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.average_shortest_path_length(nx.null_graph())
+
+    def test_bad_method(self):
+        with pytest.raises(ValueError):
+            G = nx.path_graph(2)
+            nx.average_shortest_path_length(G, weight="weight", method="SPAM")
+
+
+class TestAverageShortestPathLengthNumpy:
+    @classmethod
+    def setup_class(cls):
+        global np
+        import pytest
+
+        np = pytest.importorskip("numpy")
+
+    def test_specified_methods_numpy(self):
+        G = nx.Graph()
+        nx.add_cycle(G, range(7), weight=2)
+        ans = nx.average_shortest_path_length(
+            G, weight="weight", method="floyd-warshall-numpy"
+        )
+        np.testing.assert_almost_equal(ans, 4)
+
+        G = nx.Graph()
+        nx.add_path(G, range(5), weight=2)
+        ans = nx.average_shortest_path_length(
+            G, weight="weight", method="floyd-warshall-numpy"
+        )
+        np.testing.assert_almost_equal(ans, 4)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_unweighted.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_unweighted.py
new file mode 100644
index 0000000..96708f0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_unweighted.py
@@ -0,0 +1,116 @@
+import networkx as nx
+
+
+def validate_grid_path(r, c, s, t, p):
+    assert isinstance(p, list)
+    assert p[0] == s
+    assert p[-1] == t
+    s = ((s - 1) // c, (s - 1) % c)
+    t = ((t - 1) // c, (t - 1) % c)
+    assert len(p) == abs(t[0] - s[0]) + abs(t[1] - s[1]) + 1
+    p = [((u - 1) // c, (u - 1) % c) for u in p]
+    for u in p:
+        assert 0 <= u[0] < r
+        assert 0 <= u[1] < c
+    for u, v in zip(p[:-1], p[1:]):
+        assert (abs(v[0] - u[0]), abs(v[1] - u[1])) in [(0, 1), (1, 0)]
+
+
+class TestUnweightedPath:
+    @classmethod
+    def setup_class(cls):
+        from networkx import convert_node_labels_to_integers as cnlti
+
+        cls.grid = cnlti(nx.grid_2d_graph(4, 4), first_label=1, ordering="sorted")
+        cls.cycle = nx.cycle_graph(7)
+        cls.directed_cycle = nx.cycle_graph(7, create_using=nx.DiGraph())
+
+    def test_bidirectional_shortest_path(self):
+        assert nx.bidirectional_shortest_path(self.cycle, 0, 3) == [0, 1, 2, 3]
+        assert nx.bidirectional_shortest_path(self.cycle, 0, 4) == [0, 6, 5, 4]
+        validate_grid_path(
+            4, 4, 1, 12, nx.bidirectional_shortest_path(self.grid, 1, 12)
+        )
+        assert nx.bidirectional_shortest_path(self.directed_cycle, 0, 3) == [0, 1, 2, 3]
+
+    def test_shortest_path_length(self):
+        assert nx.shortest_path_length(self.cycle, 0, 3) == 3
+        assert nx.shortest_path_length(self.grid, 1, 12) == 5
+        assert nx.shortest_path_length(self.directed_cycle, 0, 4) == 4
+        # now with weights
+        assert nx.shortest_path_length(self.cycle, 0, 3, weight=True) == 3
+        assert nx.shortest_path_length(self.grid, 1, 12, weight=True) == 5
+        assert nx.shortest_path_length(self.directed_cycle, 0, 4, weight=True) == 4
+
+    def test_single_source_shortest_path(self):
+        p = nx.single_source_shortest_path(self.directed_cycle, 3)
+        assert p[0] == [3, 4, 5, 6, 0]
+        p = nx.single_source_shortest_path(self.cycle, 0)
+        assert p[3] == [0, 1, 2, 3]
+        p = nx.single_source_shortest_path(self.cycle, 0, cutoff=0)
+        assert p == {0: [0]}
+
+    def test_single_source_shortest_path_length(self):
+        pl = nx.single_source_shortest_path_length
+        lengths = {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        assert dict(pl(self.cycle, 0)) == lengths
+        lengths = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6}
+        assert dict(pl(self.directed_cycle, 0)) == lengths
+
+    def test_single_target_shortest_path(self):
+        p = nx.single_target_shortest_path(self.directed_cycle, 0)
+        assert p[3] == [3, 4, 5, 6, 0]
+        p = nx.single_target_shortest_path(self.cycle, 0)
+        assert p[3] == [3, 2, 1, 0]
+        p = nx.single_target_shortest_path(self.cycle, 0, cutoff=0)
+        assert p == {0: [0]}
+
+    def test_single_target_shortest_path_length(self):
+        pl = nx.single_target_shortest_path_length
+        lengths = {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        assert dict(pl(self.cycle, 0)) == lengths
+        lengths = {0: 0, 1: 6, 2: 5, 3: 4, 4: 3, 5: 2, 6: 1}
+        assert dict(pl(self.directed_cycle, 0)) == lengths
+
+    def test_all_pairs_shortest_path(self):
+        p = dict(nx.all_pairs_shortest_path(self.cycle))
+        assert p[0][3] == [0, 1, 2, 3]
+        p = dict(nx.all_pairs_shortest_path(self.grid))
+        validate_grid_path(4, 4, 1, 12, p[1][12])
+
+    def test_all_pairs_shortest_path_length(self):
+        l = dict(nx.all_pairs_shortest_path_length(self.cycle))
+        assert l[0] == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        l = dict(nx.all_pairs_shortest_path_length(self.grid))
+        assert l[1][16] == 6
+
+    def test_predecessor_path(self):
+        G = nx.path_graph(4)
+        assert nx.predecessor(G, 0) == {0: [], 1: [0], 2: [1], 3: [2]}
+        assert nx.predecessor(G, 0, 3) == [2]
+
+    def test_predecessor_cycle(self):
+        G = nx.cycle_graph(4)
+        pred = nx.predecessor(G, 0)
+        assert pred[0] == []
+        assert pred[1] == [0]
+        assert pred[2] in [[1, 3], [3, 1]]
+        assert pred[3] == [0]
+
+    def test_predecessor_cutoff(self):
+        G = nx.path_graph(4)
+        p = nx.predecessor(G, 0, 3)
+        assert 4 not in p
+
+    def test_predecessor_target(self):
+        G = nx.path_graph(4)
+        p = nx.predecessor(G, 0, 3)
+        assert p == [2]
+        p = nx.predecessor(G, 0, 3, cutoff=2)
+        assert p == []
+        p, s = nx.predecessor(G, 0, 3, return_seen=True)
+        assert p == [2]
+        assert s == 3
+        p, s = nx.predecessor(G, 0, 3, cutoff=2, return_seen=True)
+        assert p == []
+        assert s == -1
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_weighted.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_weighted.py
new file mode 100644
index 0000000..2b18696
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/tests/test_weighted.py
@@ -0,0 +1,924 @@
+import pytest
+
+import networkx as nx
+from networkx.utils import pairwise
+
+
+def validate_path(G, s, t, soln_len, path, weight="weight"):
+    assert path[0] == s
+    assert path[-1] == t
+
+    if callable(weight):
+        weight_f = weight
+    else:
+        if G.is_multigraph():
+
+            def weight_f(u, v, d):
+                return min(e.get(weight, 1) for e in d.values())
+
+        else:
+
+            def weight_f(u, v, d):
+                return d.get(weight, 1)
+
+    computed = sum(weight_f(u, v, G[u][v]) for u, v in pairwise(path))
+    assert soln_len == computed
+
+
+def validate_length_path(G, s, t, soln_len, length, path, weight="weight"):
+    assert soln_len == length
+    validate_path(G, s, t, length, path, weight=weight)
+
+
+class WeightedTestBase:
+    """Base class for test classes that test functions for computing
+    shortest paths in weighted graphs.
+
+    """
+
+    def setup(self):
+        """Creates some graphs for use in the unit tests."""
+        cnlti = nx.convert_node_labels_to_integers
+        self.grid = cnlti(nx.grid_2d_graph(4, 4), first_label=1, ordering="sorted")
+        self.cycle = nx.cycle_graph(7)
+        self.directed_cycle = nx.cycle_graph(7, create_using=nx.DiGraph())
+        self.XG = nx.DiGraph()
+        self.XG.add_weighted_edges_from(
+            [
+                ("s", "u", 10),
+                ("s", "x", 5),
+                ("u", "v", 1),
+                ("u", "x", 2),
+                ("v", "y", 1),
+                ("x", "u", 3),
+                ("x", "v", 5),
+                ("x", "y", 2),
+                ("y", "s", 7),
+                ("y", "v", 6),
+            ]
+        )
+        self.MXG = nx.MultiDiGraph(self.XG)
+        self.MXG.add_edge("s", "u", weight=15)
+        self.XG2 = nx.DiGraph()
+        self.XG2.add_weighted_edges_from(
+            [
+                [1, 4, 1],
+                [4, 5, 1],
+                [5, 6, 1],
+                [6, 3, 1],
+                [1, 3, 50],
+                [1, 2, 100],
+                [2, 3, 100],
+            ]
+        )
+
+        self.XG3 = nx.Graph()
+        self.XG3.add_weighted_edges_from(
+            [[0, 1, 2], [1, 2, 12], [2, 3, 1], [3, 4, 5], [4, 5, 1], [5, 0, 10]]
+        )
+
+        self.XG4 = nx.Graph()
+        self.XG4.add_weighted_edges_from(
+            [
+                [0, 1, 2],
+                [1, 2, 2],
+                [2, 3, 1],
+                [3, 4, 1],
+                [4, 5, 1],
+                [5, 6, 1],
+                [6, 7, 1],
+                [7, 0, 1],
+            ]
+        )
+        self.MXG4 = nx.MultiGraph(self.XG4)
+        self.MXG4.add_edge(0, 1, weight=3)
+        self.G = nx.DiGraph()  # no weights
+        self.G.add_edges_from(
+            [
+                ("s", "u"),
+                ("s", "x"),
+                ("u", "v"),
+                ("u", "x"),
+                ("v", "y"),
+                ("x", "u"),
+                ("x", "v"),
+                ("x", "y"),
+                ("y", "s"),
+                ("y", "v"),
+            ]
+        )
+
+
+class TestWeightedPath(WeightedTestBase):
+    def test_dijkstra(self):
+        (D, P) = nx.single_source_dijkstra(self.XG, "s")
+        validate_path(self.XG, "s", "v", 9, P["v"])
+        assert D["v"] == 9
+
+        validate_path(
+            self.XG, "s", "v", 9, nx.single_source_dijkstra_path(self.XG, "s")["v"]
+        )
+        assert dict(nx.single_source_dijkstra_path_length(self.XG, "s"))["v"] == 9
+
+        validate_path(
+            self.XG, "s", "v", 9, nx.single_source_dijkstra(self.XG, "s")[1]["v"]
+        )
+        validate_path(
+            self.MXG, "s", "v", 9, nx.single_source_dijkstra_path(self.MXG, "s")["v"]
+        )
+
+        GG = self.XG.to_undirected()
+        # make sure we get lower weight
+        # to_undirected might choose either edge with weight 2 or weight 3
+        GG["u"]["x"]["weight"] = 2
+        (D, P) = nx.single_source_dijkstra(GG, "s")
+        validate_path(GG, "s", "v", 8, P["v"])
+        assert D["v"] == 8  # uses lower weight of 2 on u<->x edge
+        validate_path(GG, "s", "v", 8, nx.dijkstra_path(GG, "s", "v"))
+        assert nx.dijkstra_path_length(GG, "s", "v") == 8
+
+        validate_path(self.XG2, 1, 3, 4, nx.dijkstra_path(self.XG2, 1, 3))
+        validate_path(self.XG3, 0, 3, 15, nx.dijkstra_path(self.XG3, 0, 3))
+        assert nx.dijkstra_path_length(self.XG3, 0, 3) == 15
+        validate_path(self.XG4, 0, 2, 4, nx.dijkstra_path(self.XG4, 0, 2))
+        assert nx.dijkstra_path_length(self.XG4, 0, 2) == 4
+        validate_path(self.MXG4, 0, 2, 4, nx.dijkstra_path(self.MXG4, 0, 2))
+        validate_path(
+            self.G, "s", "v", 2, nx.single_source_dijkstra(self.G, "s", "v")[1]
+        )
+        validate_path(
+            self.G, "s", "v", 2, nx.single_source_dijkstra(self.G, "s")[1]["v"]
+        )
+
+        validate_path(self.G, "s", "v", 2, nx.dijkstra_path(self.G, "s", "v"))
+        assert nx.dijkstra_path_length(self.G, "s", "v") == 2
+
+        # NetworkXError: node s not reachable from moon
+        pytest.raises(nx.NetworkXNoPath, nx.dijkstra_path, self.G, "s", "moon")
+        pytest.raises(nx.NetworkXNoPath, nx.dijkstra_path_length, self.G, "s", "moon")
+
+        validate_path(self.cycle, 0, 3, 3, nx.dijkstra_path(self.cycle, 0, 3))
+        validate_path(self.cycle, 0, 4, 3, nx.dijkstra_path(self.cycle, 0, 4))
+
+        assert nx.single_source_dijkstra(self.cycle, 0, 0) == (0, [0])
+
+    def test_bidirectional_dijkstra(self):
+        validate_length_path(
+            self.XG, "s", "v", 9, *nx.bidirectional_dijkstra(self.XG, "s", "v")
+        )
+        validate_length_path(
+            self.G, "s", "v", 2, *nx.bidirectional_dijkstra(self.G, "s", "v")
+        )
+        validate_length_path(
+            self.cycle, 0, 3, 3, *nx.bidirectional_dijkstra(self.cycle, 0, 3)
+        )
+        validate_length_path(
+            self.cycle, 0, 4, 3, *nx.bidirectional_dijkstra(self.cycle, 0, 4)
+        )
+        validate_length_path(
+            self.XG3, 0, 3, 15, *nx.bidirectional_dijkstra(self.XG3, 0, 3)
+        )
+        validate_length_path(
+            self.XG4, 0, 2, 4, *nx.bidirectional_dijkstra(self.XG4, 0, 2)
+        )
+
+        # need more tests here
+        P = nx.single_source_dijkstra_path(self.XG, "s")["v"]
+        validate_path(
+            self.XG,
+            "s",
+            "v",
+            sum(self.XG[u][v]["weight"] for u, v in zip(P[:-1], P[1:])),
+            nx.dijkstra_path(self.XG, "s", "v"),
+        )
+
+        # check absent source
+        G = nx.path_graph(2)
+        pytest.raises(nx.NodeNotFound, nx.bidirectional_dijkstra, G, 3, 0)
+
+    def test_weight_functions(self):
+        def heuristic(*z):
+            return sum(val**2 for val in z)
+
+        def getpath(pred, v, s):
+            return [v] if v == s else getpath(pred, pred[v], s) + [v]
+
+        def goldberg_radzik(g, s, t, weight="weight"):
+            pred, dist = nx.goldberg_radzik(g, s, weight=weight)
+            dist = dist[t]
+            return dist, getpath(pred, t, s)
+
+        def astar(g, s, t, weight="weight"):
+            path = nx.astar_path(g, s, t, heuristic, weight=weight)
+            dist = nx.astar_path_length(g, s, t, heuristic, weight=weight)
+            return dist, path
+
+        def vlp(G, s, t, l, F, w):
+            res = F(G, s, t, weight=w)
+            validate_length_path(G, s, t, l, *res, weight=w)
+
+        G = self.cycle
+        s = 6
+        t = 4
+        path = [6] + list(range(t + 1))
+
+        def weight(u, v, _):
+            return 1 + v**2
+
+        length = sum(weight(u, v, None) for u, v in pairwise(path))
+        vlp(G, s, t, length, nx.bidirectional_dijkstra, weight)
+        vlp(G, s, t, length, nx.single_source_dijkstra, weight)
+        vlp(G, s, t, length, nx.single_source_bellman_ford, weight)
+        vlp(G, s, t, length, goldberg_radzik, weight)
+        vlp(G, s, t, length, astar, weight)
+
+        def weight(u, v, _):
+            return 2 ** (u * v)
+
+        length = sum(weight(u, v, None) for u, v in pairwise(path))
+        vlp(G, s, t, length, nx.bidirectional_dijkstra, weight)
+        vlp(G, s, t, length, nx.single_source_dijkstra, weight)
+        vlp(G, s, t, length, nx.single_source_bellman_ford, weight)
+        vlp(G, s, t, length, goldberg_radzik, weight)
+        vlp(G, s, t, length, astar, weight)
+
+    def test_bidirectional_dijkstra_no_path(self):
+        with pytest.raises(nx.NetworkXNoPath):
+            G = nx.Graph()
+            nx.add_path(G, [1, 2, 3])
+            nx.add_path(G, [4, 5, 6])
+            path = nx.bidirectional_dijkstra(G, 1, 6)
+
+    @pytest.mark.parametrize(
+        "fn",
+        (
+            nx.dijkstra_path,
+            nx.dijkstra_path_length,
+            nx.single_source_dijkstra_path,
+            nx.single_source_dijkstra_path_length,
+            nx.single_source_dijkstra,
+            nx.dijkstra_predecessor_and_distance,
+        ),
+    )
+    def test_absent_source(self, fn):
+        G = nx.path_graph(2)
+        with pytest.raises(nx.NodeNotFound):
+            fn(G, 3, 0)
+        # Test when source == target, which is handled specially by some functions
+        with pytest.raises(nx.NodeNotFound):
+            fn(G, 3, 3)
+
+    def test_dijkstra_predecessor1(self):
+        G = nx.path_graph(4)
+        assert nx.dijkstra_predecessor_and_distance(G, 0) == (
+            {0: [], 1: [0], 2: [1], 3: [2]},
+            {0: 0, 1: 1, 2: 2, 3: 3},
+        )
+
+    def test_dijkstra_predecessor2(self):
+        # 4-cycle
+        G = nx.Graph([(0, 1), (1, 2), (2, 3), (3, 0)])
+        pred, dist = nx.dijkstra_predecessor_and_distance(G, (0))
+        assert pred[0] == []
+        assert pred[1] == [0]
+        assert pred[2] in [[1, 3], [3, 1]]
+        assert pred[3] == [0]
+        assert dist == {0: 0, 1: 1, 2: 2, 3: 1}
+
+    def test_dijkstra_predecessor3(self):
+        XG = nx.DiGraph()
+        XG.add_weighted_edges_from(
+            [
+                ("s", "u", 10),
+                ("s", "x", 5),
+                ("u", "v", 1),
+                ("u", "x", 2),
+                ("v", "y", 1),
+                ("x", "u", 3),
+                ("x", "v", 5),
+                ("x", "y", 2),
+                ("y", "s", 7),
+                ("y", "v", 6),
+            ]
+        )
+        (P, D) = nx.dijkstra_predecessor_and_distance(XG, "s")
+        assert P["v"] == ["u"]
+        assert D["v"] == 9
+        (P, D) = nx.dijkstra_predecessor_and_distance(XG, "s", cutoff=8)
+        assert "v" not in D
+
+    def test_single_source_dijkstra_path_length(self):
+        pl = nx.single_source_dijkstra_path_length
+        assert dict(pl(self.MXG4, 0))[2] == 4
+        spl = pl(self.MXG4, 0, cutoff=2)
+        assert 2 not in spl
+
+    def test_bidirectional_dijkstra_multigraph(self):
+        G = nx.MultiGraph()
+        G.add_edge("a", "b", weight=10)
+        G.add_edge("a", "b", weight=100)
+        dp = nx.bidirectional_dijkstra(G, "a", "b")
+        assert dp == (10, ["a", "b"])
+
+    def test_dijkstra_pred_distance_multigraph(self):
+        G = nx.MultiGraph()
+        G.add_edge("a", "b", key="short", foo=5, weight=100)
+        G.add_edge("a", "b", key="long", bar=1, weight=110)
+        p, d = nx.dijkstra_predecessor_and_distance(G, "a")
+        assert p == {"a": [], "b": ["a"]}
+        assert d == {"a": 0, "b": 100}
+
+    def test_negative_edge_cycle(self):
+        G = nx.cycle_graph(5, create_using=nx.DiGraph())
+        assert not nx.negative_edge_cycle(G)
+        G.add_edge(8, 9, weight=-7)
+        G.add_edge(9, 8, weight=3)
+        graph_size = len(G)
+        assert nx.negative_edge_cycle(G)
+        assert graph_size == len(G)
+        pytest.raises(ValueError, nx.single_source_dijkstra_path_length, G, 8)
+        pytest.raises(ValueError, nx.single_source_dijkstra, G, 8)
+        pytest.raises(ValueError, nx.dijkstra_predecessor_and_distance, G, 8)
+        G.add_edge(9, 10)
+        pytest.raises(ValueError, nx.bidirectional_dijkstra, G, 8, 10)
+
+    def test_negative_edge_cycle_custom_weight_key(self):
+        d = nx.DiGraph()
+        d.add_edge("a", "b", w=-2)
+        d.add_edge("b", "a", w=-1)
+        assert nx.negative_edge_cycle(d, weight="w")
+
+    def test_weight_function(self):
+        """Tests that a callable weight is interpreted as a weight
+        function instead of an edge attribute.
+
+        """
+        # Create a triangle in which the edge from node 0 to node 2 has
+        # a large weight and the other two edges have a small weight.
+        G = nx.complete_graph(3)
+        G.adj[0][2]["weight"] = 10
+        G.adj[0][1]["weight"] = 1
+        G.adj[1][2]["weight"] = 1
+
+        # The weight function will take the multiplicative inverse of
+        # the weights on the edges. This way, weights that were large
+        # before now become small and vice versa.
+
+        def weight(u, v, d):
+            return 1 / d["weight"]
+
+        # The shortest path from 0 to 2 using the actual weights on the
+        # edges should be [0, 1, 2].
+        distance, path = nx.single_source_dijkstra(G, 0, 2)
+        assert distance == 2
+        assert path == [0, 1, 2]
+        # However, with the above weight function, the shortest path
+        # should be [0, 2], since that has a very small weight.
+        distance, path = nx.single_source_dijkstra(G, 0, 2, weight=weight)
+        assert distance == 1 / 10
+        assert path == [0, 2]
+
+    def test_all_pairs_dijkstra_path(self):
+        cycle = nx.cycle_graph(7)
+        p = dict(nx.all_pairs_dijkstra_path(cycle))
+        assert p[0][3] == [0, 1, 2, 3]
+
+        cycle[1][2]["weight"] = 10
+        p = dict(nx.all_pairs_dijkstra_path(cycle))
+        assert p[0][3] == [0, 6, 5, 4, 3]
+
+    def test_all_pairs_dijkstra_path_length(self):
+        cycle = nx.cycle_graph(7)
+        pl = dict(nx.all_pairs_dijkstra_path_length(cycle))
+        assert pl[0] == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+
+        cycle[1][2]["weight"] = 10
+        pl = dict(nx.all_pairs_dijkstra_path_length(cycle))
+        assert pl[0] == {0: 0, 1: 1, 2: 5, 3: 4, 4: 3, 5: 2, 6: 1}
+
+    def test_all_pairs_dijkstra(self):
+        cycle = nx.cycle_graph(7)
+        out = dict(nx.all_pairs_dijkstra(cycle))
+        assert out[0][0] == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
+        assert out[0][1][3] == [0, 1, 2, 3]
+
+        cycle[1][2]["weight"] = 10
+        out = dict(nx.all_pairs_dijkstra(cycle))
+        assert out[0][0] == {0: 0, 1: 1, 2: 5, 3: 4, 4: 3, 5: 2, 6: 1}
+        assert out[0][1][3] == [0, 6, 5, 4, 3]
+
+
+class TestDijkstraPathLength:
+    """Unit tests for the :func:`networkx.dijkstra_path_length`
+    function.
+
+    """
+
+    def test_weight_function(self):
+        """Tests for computing the length of the shortest path using
+        Dijkstra's algorithm with a user-defined weight function.
+
+        """
+        # Create a triangle in which the edge from node 0 to node 2 has
+        # a large weight and the other two edges have a small weight.
+        G = nx.complete_graph(3)
+        G.adj[0][2]["weight"] = 10
+        G.adj[0][1]["weight"] = 1
+        G.adj[1][2]["weight"] = 1
+
+        # The weight function will take the multiplicative inverse of
+        # the weights on the edges. This way, weights that were large
+        # before now become small and vice versa.
+
+        def weight(u, v, d):
+            return 1 / d["weight"]
+
+        # The shortest path from 0 to 2 using the actual weights on the
+        # edges should be [0, 1, 2]. However, with the above weight
+        # function, the shortest path should be [0, 2], since that has a
+        # very small weight.
+        length = nx.dijkstra_path_length(G, 0, 2, weight=weight)
+        assert length == 1 / 10
+
+
+class TestMultiSourceDijkstra:
+    """Unit tests for the multi-source dialect of Dijkstra's shortest
+    path algorithms.
+
+    """
+
+    def test_no_sources(self):
+        with pytest.raises(ValueError):
+            nx.multi_source_dijkstra(nx.Graph(), {})
+
+    def test_path_no_sources(self):
+        with pytest.raises(ValueError):
+            nx.multi_source_dijkstra_path(nx.Graph(), {})
+
+    def test_path_length_no_sources(self):
+        with pytest.raises(ValueError):
+            nx.multi_source_dijkstra_path_length(nx.Graph(), {})
+
+    @pytest.mark.parametrize(
+        "fn",
+        (
+            nx.multi_source_dijkstra_path,
+            nx.multi_source_dijkstra_path_length,
+            nx.multi_source_dijkstra,
+        ),
+    )
+    def test_absent_source(self, fn):
+        G = nx.path_graph(2)
+        with pytest.raises(nx.NodeNotFound):
+            fn(G, [3], 0)
+        with pytest.raises(nx.NodeNotFound):
+            fn(G, [3], 3)
+
+    def test_two_sources(self):
+        edges = [(0, 1, 1), (1, 2, 1), (2, 3, 10), (3, 4, 1)]
+        G = nx.Graph()
+        G.add_weighted_edges_from(edges)
+        sources = {0, 4}
+        distances, paths = nx.multi_source_dijkstra(G, sources)
+        expected_distances = {0: 0, 1: 1, 2: 2, 3: 1, 4: 0}
+        expected_paths = {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [4, 3], 4: [4]}
+        assert distances == expected_distances
+        assert paths == expected_paths
+
+    def test_simple_paths(self):
+        G = nx.path_graph(4)
+        lengths = nx.multi_source_dijkstra_path_length(G, [0])
+        assert lengths == {n: n for n in G}
+        paths = nx.multi_source_dijkstra_path(G, [0])
+        assert paths == {n: list(range(n + 1)) for n in G}
+
+
+class TestBellmanFordAndGoldbergRadzik(WeightedTestBase):
+    def test_single_node_graph(self):
+        G = nx.DiGraph()
+        G.add_node(0)
+        assert nx.single_source_bellman_ford_path(G, 0) == {0: [0]}
+        assert nx.single_source_bellman_ford_path_length(G, 0) == {0: 0}
+        assert nx.single_source_bellman_ford(G, 0) == ({0: 0}, {0: [0]})
+        assert nx.bellman_ford_predecessor_and_distance(G, 0) == ({0: []}, {0: 0})
+        assert nx.goldberg_radzik(G, 0) == ({0: None}, {0: 0})
+
+    def test_absent_source_bellman_ford(self):
+        # the check is in _bellman_ford; this provides regression testing
+        # against later changes to "client" Bellman-Ford functions
+        G = nx.path_graph(2)
+        for fn in (
+            nx.bellman_ford_predecessor_and_distance,
+            nx.bellman_ford_path,
+            nx.bellman_ford_path_length,
+            nx.single_source_bellman_ford_path,
+            nx.single_source_bellman_ford_path_length,
+            nx.single_source_bellman_ford,
+        ):
+            pytest.raises(nx.NodeNotFound, fn, G, 3, 0)
+            pytest.raises(nx.NodeNotFound, fn, G, 3, 3)
+
+    def test_absent_source_goldberg_radzik(self):
+        with pytest.raises(nx.NodeNotFound):
+            G = nx.path_graph(2)
+            nx.goldberg_radzik(G, 3, 0)
+
+    def test_negative_cycle_heuristic(self):
+        G = nx.DiGraph()
+        G.add_edge(0, 1, weight=-1)
+        G.add_edge(1, 2, weight=-1)
+        G.add_edge(2, 3, weight=-1)
+        G.add_edge(3, 0, weight=3)
+        assert not nx.negative_edge_cycle(G, heuristic=True)
+        G.add_edge(2, 0, weight=1.999)
+        assert nx.negative_edge_cycle(G, heuristic=True)
+        G.edges[2, 0]["weight"] = 2
+        assert not nx.negative_edge_cycle(G, heuristic=True)
+
+    def test_negative_cycle_consistency(self):
+        import random
+
+        unif = random.uniform
+        for random_seed in range(2):  # range(20):
+            random.seed(random_seed)
+            for density in [0.1, 0.9]:  # .3, .7, .9]:
+                for N in [1, 10, 20]:  # range(1, 60 - int(30 * density)):
+                    for max_cost in [1, 90]:  # [1, 10, 40, 90]:
+                        G = nx.binomial_graph(N, density, seed=4, directed=True)
+                        edges = ((u, v, unif(-1, max_cost)) for u, v in G.edges)
+                        G.add_weighted_edges_from(edges)
+
+                        no_heuristic = nx.negative_edge_cycle(G, heuristic=False)
+                        with_heuristic = nx.negative_edge_cycle(G, heuristic=True)
+                        assert no_heuristic == with_heuristic
+
+    def test_negative_cycle(self):
+        G = nx.cycle_graph(5, create_using=nx.DiGraph())
+        G.add_edge(1, 2, weight=-7)
+        for i in range(5):
+            pytest.raises(
+                nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, i
+            )
+            pytest.raises(
+                nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, i
+            )
+            pytest.raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, i)
+            pytest.raises(
+                nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, i
+            )
+            pytest.raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, i)
+        G = nx.cycle_graph(5)  # undirected Graph
+        G.add_edge(1, 2, weight=-3)
+        for i in range(5):
+            pytest.raises(
+                nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, i
+            )
+            pytest.raises(
+                nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, i
+            )
+            pytest.raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, i)
+            pytest.raises(
+                nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, i
+            )
+            pytest.raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, i)
+        G = nx.DiGraph([(1, 1, {"weight": -1})])
+        pytest.raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, 1)
+        pytest.raises(
+            nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, 1
+        )
+        pytest.raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, 1)
+        pytest.raises(
+            nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, 1
+        )
+        pytest.raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, 1)
+
+    def test_find_negative_cycle_longer_cycle(self):
+        G = nx.cycle_graph(5, create_using=nx.DiGraph())
+        nx.add_cycle(G, [3, 5, 6, 7, 8, 9])
+        G.add_edge(1, 2, weight=-30)
+        assert nx.find_negative_cycle(G, 1) == [0, 1, 2, 3, 4, 0]
+        assert nx.find_negative_cycle(G, 7) == [2, 3, 4, 0, 1, 2]
+
+    def test_find_negative_cycle_no_cycle(self):
+        G = nx.path_graph(5, create_using=nx.DiGraph())
+        pytest.raises(nx.NetworkXError, nx.find_negative_cycle, G, 3)
+
+    def test_find_negative_cycle_single_edge(self):
+        G = nx.Graph()
+        G.add_edge(0, 1, weight=-1)
+        assert nx.find_negative_cycle(G, 1) == [1, 0, 1]
+
+    def test_negative_weight(self):
+        G = nx.cycle_graph(5, create_using=nx.DiGraph())
+        G.add_edge(1, 2, weight=-3)
+        assert nx.single_source_bellman_ford_path(G, 0) == {
+            0: [0],
+            1: [0, 1],
+            2: [0, 1, 2],
+            3: [0, 1, 2, 3],
+            4: [0, 1, 2, 3, 4],
+        }
+        assert nx.single_source_bellman_ford_path_length(G, 0) == {
+            0: 0,
+            1: 1,
+            2: -2,
+            3: -1,
+            4: 0,
+        }
+        assert nx.single_source_bellman_ford(G, 0) == (
+            {0: 0, 1: 1, 2: -2, 3: -1, 4: 0},
+            {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3], 4: [0, 1, 2, 3, 4]},
+        )
+        assert nx.bellman_ford_predecessor_and_distance(G, 0) == (
+            {0: [], 1: [0], 2: [1], 3: [2], 4: [3]},
+            {0: 0, 1: 1, 2: -2, 3: -1, 4: 0},
+        )
+        assert nx.goldberg_radzik(G, 0) == (
+            {0: None, 1: 0, 2: 1, 3: 2, 4: 3},
+            {0: 0, 1: 1, 2: -2, 3: -1, 4: 0},
+        )
+
+    def test_not_connected(self):
+        G = nx.complete_graph(6)
+        G.add_edge(10, 11)
+        G.add_edge(10, 12)
+        assert nx.single_source_bellman_ford_path(G, 0) == {
+            0: [0],
+            1: [0, 1],
+            2: [0, 2],
+            3: [0, 3],
+            4: [0, 4],
+            5: [0, 5],
+        }
+        assert nx.single_source_bellman_ford_path_length(G, 0) == {
+            0: 0,
+            1: 1,
+            2: 1,
+            3: 1,
+            4: 1,
+            5: 1,
+        }
+        assert nx.single_source_bellman_ford(G, 0) == (
+            {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
+            {0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]},
+        )
+        assert nx.bellman_ford_predecessor_and_distance(G, 0) == (
+            {0: [], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]},
+            {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
+        )
+        assert nx.goldberg_radzik(G, 0) == (
+            {0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0},
+            {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
+        )
+
+        # not connected, with a component not containing the source that
+        # contains a negative cycle.
+        G = nx.complete_graph(6)
+        G.add_edges_from(
+            [
+                ("A", "B", {"load": 3}),
+                ("B", "C", {"load": -10}),
+                ("C", "A", {"load": 2}),
+            ]
+        )
+        assert nx.single_source_bellman_ford_path(G, 0, weight="load") == {
+            0: [0],
+            1: [0, 1],
+            2: [0, 2],
+            3: [0, 3],
+            4: [0, 4],
+            5: [0, 5],
+        }
+        assert nx.single_source_bellman_ford_path_length(G, 0, weight="load") == {
+            0: 0,
+            1: 1,
+            2: 1,
+            3: 1,
+            4: 1,
+            5: 1,
+        }
+        assert nx.single_source_bellman_ford(G, 0, weight="load") == (
+            {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
+            {0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]},
+        )
+        assert nx.bellman_ford_predecessor_and_distance(G, 0, weight="load") == (
+            {0: [], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]},
+            {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
+        )
+        assert nx.goldberg_radzik(G, 0, weight="load") == (
+            {0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0},
+            {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
+        )
+
+    def test_multigraph(self):
+        assert nx.bellman_ford_path(self.MXG, "s", "v") == ["s", "x", "u", "v"]
+        assert nx.bellman_ford_path_length(self.MXG, "s", "v") == 9
+        assert nx.single_source_bellman_ford_path(self.MXG, "s")["v"] == [
+            "s",
+            "x",
+            "u",
+            "v",
+        ]
+        assert nx.single_source_bellman_ford_path_length(self.MXG, "s")["v"] == 9
+        D, P = nx.single_source_bellman_ford(self.MXG, "s", target="v")
+        assert D == 9
+        assert P == ["s", "x", "u", "v"]
+        P, D = nx.bellman_ford_predecessor_and_distance(self.MXG, "s")
+        assert P["v"] == ["u"]
+        assert D["v"] == 9
+        P, D = nx.goldberg_radzik(self.MXG, "s")
+        assert P["v"] == "u"
+        assert D["v"] == 9
+        assert nx.bellman_ford_path(self.MXG4, 0, 2) == [0, 1, 2]
+        assert nx.bellman_ford_path_length(self.MXG4, 0, 2) == 4
+        assert nx.single_source_bellman_ford_path(self.MXG4, 0)[2] == [0, 1, 2]
+        assert nx.single_source_bellman_ford_path_length(self.MXG4, 0)[2] == 4
+        D, P = nx.single_source_bellman_ford(self.MXG4, 0, target=2)
+        assert D == 4
+        assert P == [0, 1, 2]
+        P, D = nx.bellman_ford_predecessor_and_distance(self.MXG4, 0)
+        assert P[2] == [1]
+        assert D[2] == 4
+        P, D = nx.goldberg_radzik(self.MXG4, 0)
+        assert P[2] == 1
+        assert D[2] == 4
+
+    def test_others(self):
+        assert nx.bellman_ford_path(self.XG, "s", "v") == ["s", "x", "u", "v"]
+        assert nx.bellman_ford_path_length(self.XG, "s", "v") == 9
+        assert nx.single_source_bellman_ford_path(self.XG, "s")["v"] == [
+            "s",
+            "x",
+            "u",
+            "v",
+        ]
+        assert nx.single_source_bellman_ford_path_length(self.XG, "s")["v"] == 9
+        D, P = nx.single_source_bellman_ford(self.XG, "s", target="v")
+        assert D == 9
+        assert P == ["s", "x", "u", "v"]
+        (P, D) = nx.bellman_ford_predecessor_and_distance(self.XG, "s")
+        assert P["v"] == ["u"]
+        assert D["v"] == 9
+        (P, D) = nx.goldberg_radzik(self.XG, "s")
+        assert P["v"] == "u"
+        assert D["v"] == 9
+
+    def test_path_graph(self):
+        G = nx.path_graph(4)
+        assert nx.single_source_bellman_ford_path(G, 0) == {
+            0: [0],
+            1: [0, 1],
+            2: [0, 1, 2],
+            3: [0, 1, 2, 3],
+        }
+        assert nx.single_source_bellman_ford_path_length(G, 0) == {
+            0: 0,
+            1: 1,
+            2: 2,
+            3: 3,
+        }
+        assert nx.single_source_bellman_ford(G, 0) == (
+            {0: 0, 1: 1, 2: 2, 3: 3},
+            {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3]},
+        )
+        assert nx.bellman_ford_predecessor_and_distance(G, 0) == (
+            {0: [], 1: [0], 2: [1], 3: [2]},
+            {0: 0, 1: 1, 2: 2, 3: 3},
+        )
+        assert nx.goldberg_radzik(G, 0) == (
+            {0: None, 1: 0, 2: 1, 3: 2},
+            {0: 0, 1: 1, 2: 2, 3: 3},
+        )
+        assert nx.single_source_bellman_ford_path(G, 3) == {
+            0: [3, 2, 1, 0],
+            1: [3, 2, 1],
+            2: [3, 2],
+            3: [3],
+        }
+        assert nx.single_source_bellman_ford_path_length(G, 3) == {
+            0: 3,
+            1: 2,
+            2: 1,
+            3: 0,
+        }
+        assert nx.single_source_bellman_ford(G, 3) == (
+            {0: 3, 1: 2, 2: 1, 3: 0},
+            {0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3]},
+        )
+        assert nx.bellman_ford_predecessor_and_distance(G, 3) == (
+            {0: [1], 1: [2], 2: [3], 3: []},
+            {0: 3, 1: 2, 2: 1, 3: 0},
+        )
+        assert nx.goldberg_radzik(G, 3) == (
+            {0: 1, 1: 2, 2: 3, 3: None},
+            {0: 3, 1: 2, 2: 1, 3: 0},
+        )
+
+    def test_4_cycle(self):
+        # 4-cycle
+        G = nx.Graph([(0, 1), (1, 2), (2, 3), (3, 0)])
+        dist, path = nx.single_source_bellman_ford(G, 0)
+        assert dist == {0: 0, 1: 1, 2: 2, 3: 1}
+        assert path[0] == [0]
+        assert path[1] == [0, 1]
+        assert path[2] in [[0, 1, 2], [0, 3, 2]]
+        assert path[3] == [0, 3]
+
+        pred, dist = nx.bellman_ford_predecessor_and_distance(G, 0)
+        assert pred[0] == []
+        assert pred[1] == [0]
+        assert pred[2] in [[1, 3], [3, 1]]
+        assert pred[3] == [0]
+        assert dist == {0: 0, 1: 1, 2: 2, 3: 1}
+
+        pred, dist = nx.goldberg_radzik(G, 0)
+        assert pred[0] is None
+        assert pred[1] == 0
+        assert pred[2] in [1, 3]
+        assert pred[3] == 0
+        assert dist == {0: 0, 1: 1, 2: 2, 3: 1}
+
+    def test_negative_weight_bf_path(self):
+        G = nx.DiGraph()
+        G.add_nodes_from("abcd")
+        G.add_edge("a", "d", weight=0)
+        G.add_edge("a", "b", weight=1)
+        G.add_edge("b", "c", weight=-3)
+        G.add_edge("c", "d", weight=1)
+
+        assert nx.bellman_ford_path(G, "a", "d") == ["a", "b", "c", "d"]
+        assert nx.bellman_ford_path_length(G, "a", "d") == -1
+
+    def test_zero_cycle_smoke(self):
+        D = nx.DiGraph()
+        D.add_weighted_edges_from([(0, 1, 1), (1, 2, 1), (2, 3, 1), (3, 1, -2)])
+
+        nx.bellman_ford_path(D, 1, 3)
+        nx.dijkstra_path(D, 1, 3)
+        nx.bidirectional_dijkstra(D, 1, 3)
+        # FIXME nx.goldberg_radzik(D, 1)
+
+
+class TestJohnsonAlgorithm(WeightedTestBase):
+    def test_single_node_graph(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.DiGraph()
+            G.add_node(0)
+            nx.johnson(G)
+
+    def test_negative_cycle(self):
+        G = nx.DiGraph()
+        G.add_weighted_edges_from(
+            [
+                ("0", "3", 3),
+                ("0", "1", -5),
+                ("1", "0", -5),
+                ("0", "2", 2),
+                ("1", "2", 4),
+                ("2", "3", 1),
+            ]
+        )
+        pytest.raises(nx.NetworkXUnbounded, nx.johnson, G)
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [
+                ("0", "3", 3),
+                ("0", "1", -5),
+                ("1", "0", -5),
+                ("0", "2", 2),
+                ("1", "2", 4),
+                ("2", "3", 1),
+            ]
+        )
+        pytest.raises(nx.NetworkXUnbounded, nx.johnson, G)
+
+    def test_negative_weights(self):
+        G = nx.DiGraph()
+        G.add_weighted_edges_from(
+            [("0", "3", 3), ("0", "1", -5), ("0", "2", 2), ("1", "2", 4), ("2", "3", 1)]
+        )
+        paths = nx.johnson(G)
+        assert paths == {
+            "1": {"1": ["1"], "3": ["1", "2", "3"], "2": ["1", "2"]},
+            "0": {
+                "1": ["0", "1"],
+                "0": ["0"],
+                "3": ["0", "1", "2", "3"],
+                "2": ["0", "1", "2"],
+            },
+            "3": {"3": ["3"]},
+            "2": {"3": ["2", "3"], "2": ["2"]},
+        }
+
+    def test_unweighted_graph(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.path_graph(5)
+            nx.johnson(G)
+
+    def test_graphs(self):
+        validate_path(self.XG, "s", "v", 9, nx.johnson(self.XG)["s"]["v"])
+        validate_path(self.MXG, "s", "v", 9, nx.johnson(self.MXG)["s"]["v"])
+        validate_path(self.XG2, 1, 3, 4, nx.johnson(self.XG2)[1][3])
+        validate_path(self.XG3, 0, 3, 15, nx.johnson(self.XG3)[0][3])
+        validate_path(self.XG4, 0, 2, 4, nx.johnson(self.XG4)[0][2])
+        validate_path(self.MXG4, 0, 2, 4, nx.johnson(self.MXG4)[0][2])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/unweighted.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/unweighted.py
new file mode 100644
index 0000000..5363b24
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/unweighted.py
@@ -0,0 +1,530 @@
+"""
+Shortest path algorithms for unweighted graphs.
+"""
+import networkx as nx
+
+__all__ = [
+    "bidirectional_shortest_path",
+    "single_source_shortest_path",
+    "single_source_shortest_path_length",
+    "single_target_shortest_path",
+    "single_target_shortest_path_length",
+    "all_pairs_shortest_path",
+    "all_pairs_shortest_path_length",
+    "predecessor",
+]
+
+
+def single_source_shortest_path_length(G, source, cutoff=None):
+    """Compute the shortest path lengths from source to all reachable nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Starting node for path
+
+    cutoff : integer, optional
+        Depth to stop the search. Only paths of length <= cutoff are returned.
+
+    Returns
+    -------
+    lengths : dict
+        Dict keyed by node to shortest path length to source.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> length = nx.single_source_shortest_path_length(G, 0)
+    >>> length[4]
+    4
+    >>> for node in length:
+    ...     print(f"{node}: {length[node]}")
+    0: 0
+    1: 1
+    2: 2
+    3: 3
+    4: 4
+
+    See Also
+    --------
+    shortest_path_length
+    """
+    if source not in G:
+        raise nx.NodeNotFound(f"Source {source} is not in G")
+    if cutoff is None:
+        cutoff = float("inf")
+    nextlevel = {source: 1}
+    return dict(_single_shortest_path_length(G.adj, nextlevel, cutoff))
+
+
+def _single_shortest_path_length(adj, firstlevel, cutoff):
+    """Yields (node, level) in a breadth first search
+
+    Shortest Path Length helper function
+    Parameters
+    ----------
+        adj : dict
+            Adjacency dict or view
+        firstlevel : dict
+            starting nodes, e.g. {source: 1} or {target: 1}
+        cutoff : int or float
+            level at which we stop the process
+    """
+    seen = {}  # level (number of hops) when seen in BFS
+    level = 0  # the current level
+    nextlevel = set(firstlevel)  # set of nodes to check at next level
+    n = len(adj)
+    while nextlevel and cutoff >= level:
+        thislevel = nextlevel  # advance to next level
+        nextlevel = set()  # and start a new set (fringe)
+        found = []
+        for v in thislevel:
+            if v not in seen:
+                seen[v] = level  # set the level of vertex v
+                found.append(v)
+                yield (v, level)
+        if len(seen) == n:
+            return
+        for v in found:
+            nextlevel.update(adj[v])
+        level += 1
+    del seen
+
+
+def single_target_shortest_path_length(G, target, cutoff=None):
+    """Compute the shortest path lengths to target from all reachable nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    target : node
+       Target node for path
+
+    cutoff : integer, optional
+        Depth to stop the search. Only paths of length <= cutoff are returned.
+
+    Returns
+    -------
+    lengths : iterator
+        (source, shortest path length) iterator
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5, create_using=nx.DiGraph())
+    >>> length = dict(nx.single_target_shortest_path_length(G, 4))
+    >>> length[0]
+    4
+    >>> for node in range(5):
+    ...     print(f"{node}: {length[node]}")
+    0: 4
+    1: 3
+    2: 2
+    3: 1
+    4: 0
+
+    See Also
+    --------
+    single_source_shortest_path_length, shortest_path_length
+    """
+    if target not in G:
+        raise nx.NodeNotFound(f"Target {target} is not in G")
+
+    if cutoff is None:
+        cutoff = float("inf")
+    # handle either directed or undirected
+    adj = G.pred if G.is_directed() else G.adj
+    nextlevel = {target: 1}
+    return _single_shortest_path_length(adj, nextlevel, cutoff)
+
+
+def all_pairs_shortest_path_length(G, cutoff=None):
+    """Computes the shortest path lengths between all nodes in `G`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    cutoff : integer, optional
+        Depth at which to stop the search. Only paths of length at most
+        `cutoff` are returned.
+
+    Returns
+    -------
+    lengths : iterator
+        (source, dictionary) iterator with dictionary keyed by target and
+        shortest path length as the key value.
+
+    Notes
+    -----
+    The iterator returned only has reachable node pairs.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> length = dict(nx.all_pairs_shortest_path_length(G))
+    >>> for node in [0, 1, 2, 3, 4]:
+    ...     print(f"1 - {node}: {length[1][node]}")
+    1 - 0: 1
+    1 - 1: 0
+    1 - 2: 1
+    1 - 3: 2
+    1 - 4: 3
+    >>> length[3][2]
+    1
+    >>> length[2][2]
+    0
+
+    """
+    length = single_source_shortest_path_length
+    # TODO This can be trivially parallelized.
+    for n in G:
+        yield (n, length(G, n, cutoff=cutoff))
+
+
+def bidirectional_shortest_path(G, source, target):
+    """Returns a list of nodes in a shortest path between source and target.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node label
+       starting node for path
+
+    target : node label
+       ending node for path
+
+    Returns
+    -------
+    path: list
+       List of nodes in a path from source to target.
+
+    Raises
+    ------
+    NetworkXNoPath
+       If no path exists between source and target.
+
+    See Also
+    --------
+    shortest_path
+
+    Notes
+    -----
+    This algorithm is used by shortest_path(G, source, target).
+    """
+
+    if source not in G or target not in G:
+        msg = f"Either source {source} or target {target} is not in G"
+        raise nx.NodeNotFound(msg)
+
+    # call helper to do the real work
+    results = _bidirectional_pred_succ(G, source, target)
+    pred, succ, w = results
+
+    # build path from pred+w+succ
+    path = []
+    # from source to w
+    while w is not None:
+        path.append(w)
+        w = pred[w]
+    path.reverse()
+    # from w to target
+    w = succ[path[-1]]
+    while w is not None:
+        path.append(w)
+        w = succ[w]
+
+    return path
+
+
+def _bidirectional_pred_succ(G, source, target):
+    """Bidirectional shortest path helper.
+
+    Returns (pred, succ, w) where
+    pred is a dictionary of predecessors from w to the source, and
+    succ is a dictionary of successors from w to the target.
+    """
+    # does BFS from both source and target and meets in the middle
+    if target == source:
+        return ({target: None}, {source: None}, source)
+
+    # handle either directed or undirected
+    if G.is_directed():
+        Gpred = G.pred
+        Gsucc = G.succ
+    else:
+        Gpred = G.adj
+        Gsucc = G.adj
+
+    # predecesssor and successors in search
+    pred = {source: None}
+    succ = {target: None}
+
+    # initialize fringes, start with forward
+    forward_fringe = [source]
+    reverse_fringe = [target]
+
+    while forward_fringe and reverse_fringe:
+        if len(forward_fringe) <= len(reverse_fringe):
+            this_level = forward_fringe
+            forward_fringe = []
+            for v in this_level:
+                for w in Gsucc[v]:
+                    if w not in pred:
+                        forward_fringe.append(w)
+                        pred[w] = v
+                    if w in succ:  # path found
+                        return pred, succ, w
+        else:
+            this_level = reverse_fringe
+            reverse_fringe = []
+            for v in this_level:
+                for w in Gpred[v]:
+                    if w not in succ:
+                        succ[w] = v
+                        reverse_fringe.append(w)
+                    if w in pred:  # found path
+                        return pred, succ, w
+
+    raise nx.NetworkXNoPath(f"No path between {source} and {target}.")
+
+
+def single_source_shortest_path(G, source, cutoff=None):
+    """Compute shortest path between source
+    and all other nodes reachable from source.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node label
+       Starting node for path
+
+    cutoff : integer, optional
+        Depth to stop the search. Only paths of length <= cutoff are returned.
+
+    Returns
+    -------
+    lengths : dictionary
+        Dictionary, keyed by target, of shortest paths.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> path = nx.single_source_shortest_path(G, 0)
+    >>> path[4]
+    [0, 1, 2, 3, 4]
+
+    Notes
+    -----
+    The shortest path is not necessarily unique. So there can be multiple
+    paths between the source and each target node, all of which have the
+    same 'shortest' length. For each target node, this function returns
+    only one of those paths.
+
+    See Also
+    --------
+    shortest_path
+    """
+    if source not in G:
+        raise nx.NodeNotFound(f"Source {source} not in G")
+
+    def join(p1, p2):
+        return p1 + p2
+
+    if cutoff is None:
+        cutoff = float("inf")
+    nextlevel = {source: 1}  # list of nodes to check at next level
+    paths = {source: [source]}  # paths dictionary  (paths to key from source)
+    return dict(_single_shortest_path(G.adj, nextlevel, paths, cutoff, join))
+
+
+def _single_shortest_path(adj, firstlevel, paths, cutoff, join):
+    """Returns shortest paths
+
+    Shortest Path helper function
+    Parameters
+    ----------
+        adj : dict
+            Adjacency dict or view
+        firstlevel : dict
+            starting nodes, e.g. {source: 1} or {target: 1}
+        paths : dict
+            paths for starting nodes, e.g. {source: [source]}
+        cutoff : int or float
+            level at which we stop the process
+        join : function
+            function to construct a path from two partial paths. Requires two
+            list inputs `p1` and `p2`, and returns a list. Usually returns
+            `p1 + p2` (forward from source) or `p2 + p1` (backward from target)
+    """
+    level = 0  # the current level
+    nextlevel = firstlevel
+    while nextlevel and cutoff > level:
+        thislevel = nextlevel
+        nextlevel = {}
+        for v in thislevel:
+            for w in adj[v]:
+                if w not in paths:
+                    paths[w] = join(paths[v], [w])
+                    nextlevel[w] = 1
+        level += 1
+    return paths
+
+
+def single_target_shortest_path(G, target, cutoff=None):
+    """Compute shortest path to target from all nodes that reach target.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    target : node label
+       Target node for path
+
+    cutoff : integer, optional
+        Depth to stop the search. Only paths of length <= cutoff are returned.
+
+    Returns
+    -------
+    lengths : dictionary
+        Dictionary, keyed by target, of shortest paths.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5, create_using=nx.DiGraph())
+    >>> path = nx.single_target_shortest_path(G, 4)
+    >>> path[0]
+    [0, 1, 2, 3, 4]
+
+    Notes
+    -----
+    The shortest path is not necessarily unique. So there can be multiple
+    paths between the source and each target node, all of which have the
+    same 'shortest' length. For each target node, this function returns
+    only one of those paths.
+
+    See Also
+    --------
+    shortest_path, single_source_shortest_path
+    """
+    if target not in G:
+        raise nx.NodeNotFound(f"Target {target} not in G")
+
+    def join(p1, p2):
+        return p2 + p1
+
+    # handle undirected graphs
+    adj = G.pred if G.is_directed() else G.adj
+    if cutoff is None:
+        cutoff = float("inf")
+    nextlevel = {target: 1}  # list of nodes to check at next level
+    paths = {target: [target]}  # paths dictionary  (paths to key from source)
+    return dict(_single_shortest_path(adj, nextlevel, paths, cutoff, join))
+
+
+def all_pairs_shortest_path(G, cutoff=None):
+    """Compute shortest paths between all nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    cutoff : integer, optional
+        Depth at which to stop the search. Only paths of length at most
+        `cutoff` are returned.
+
+    Returns
+    -------
+    lengths : dictionary
+        Dictionary, keyed by source and target, of shortest paths.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> path = dict(nx.all_pairs_shortest_path(G))
+    >>> print(path[0][4])
+    [0, 1, 2, 3, 4]
+
+    See Also
+    --------
+    floyd_warshall
+
+    """
+    # TODO This can be trivially parallelized.
+    for n in G:
+        yield (n, single_source_shortest_path(G, n, cutoff=cutoff))
+
+
+def predecessor(G, source, target=None, cutoff=None, return_seen=None):
+    """Returns dict of predecessors for the path from source to all nodes in G
+
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node label
+       Starting node for path
+
+    target : node label, optional
+       Ending node for path. If provided only predecessors between
+       source and target are returned
+
+    cutoff : integer, optional
+        Depth to stop the search. Only paths of length <= cutoff are returned.
+
+
+    Returns
+    -------
+    pred : dictionary
+        Dictionary, keyed by node, of predecessors in the shortest path.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> list(G)
+    [0, 1, 2, 3]
+    >>> nx.predecessor(G, 0)
+    {0: [], 1: [0], 2: [1], 3: [2]}
+
+    """
+    if source not in G:
+        raise nx.NodeNotFound(f"Source {source} not in G")
+
+    level = 0  # the current level
+    nextlevel = [source]  # list of nodes to check at next level
+    seen = {source: level}  # level (number of hops) when seen in BFS
+    pred = {source: []}  # predecessor dictionary
+    while nextlevel:
+        level = level + 1
+        thislevel = nextlevel
+        nextlevel = []
+        for v in thislevel:
+            for w in G[v]:
+                if w not in seen:
+                    pred[w] = [v]
+                    seen[w] = level
+                    nextlevel.append(w)
+                elif seen[w] == level:  # add v to predecessor list if it
+                    pred[w].append(v)  # is at the correct level
+        if cutoff and cutoff <= level:
+            break
+
+    if target is not None:
+        if return_seen:
+            if target not in pred:
+                return ([], -1)  # No predecessor
+            return (pred[target], seen[target])
+        else:
+            if target not in pred:
+                return []  # No predecessor
+            return pred[target]
+    else:
+        if return_seen:
+            return (pred, seen)
+        else:
+            return pred
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/weighted.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/weighted.py
new file mode 100644
index 0000000..ef0ee63
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/shortest_paths/weighted.py
@@ -0,0 +1,2464 @@
+"""
+Shortest path algorithms for weighted graphs.
+"""
+
+from collections import deque
+from heapq import heappop, heappush
+from itertools import count
+
+import networkx as nx
+from networkx.algorithms.shortest_paths.generic import _build_paths_from_predecessors
+
+__all__ = [
+    "dijkstra_path",
+    "dijkstra_path_length",
+    "bidirectional_dijkstra",
+    "single_source_dijkstra",
+    "single_source_dijkstra_path",
+    "single_source_dijkstra_path_length",
+    "multi_source_dijkstra",
+    "multi_source_dijkstra_path",
+    "multi_source_dijkstra_path_length",
+    "all_pairs_dijkstra",
+    "all_pairs_dijkstra_path",
+    "all_pairs_dijkstra_path_length",
+    "dijkstra_predecessor_and_distance",
+    "bellman_ford_path",
+    "bellman_ford_path_length",
+    "single_source_bellman_ford",
+    "single_source_bellman_ford_path",
+    "single_source_bellman_ford_path_length",
+    "all_pairs_bellman_ford_path",
+    "all_pairs_bellman_ford_path_length",
+    "bellman_ford_predecessor_and_distance",
+    "negative_edge_cycle",
+    "find_negative_cycle",
+    "goldberg_radzik",
+    "johnson",
+]
+
+
+def _weight_function(G, weight):
+    """Returns a function that returns the weight of an edge.
+
+    The returned function is specifically suitable for input to
+    functions :func:`_dijkstra` and :func:`_bellman_ford_relaxation`.
+
+    Parameters
+    ----------
+    G : NetworkX graph.
+
+    weight : string or function
+        If it is callable, `weight` itself is returned. If it is a string,
+        it is assumed to be the name of the edge attribute that represents
+        the weight of an edge. In that case, a function is returned that
+        gets the edge weight according to the specified edge attribute.
+
+    Returns
+    -------
+    function
+        This function returns a callable that accepts exactly three inputs:
+        a node, an node adjacent to the first one, and the edge attribute
+        dictionary for the eedge joining those nodes. That function returns
+        a number representing the weight of an edge.
+
+    If `G` is a multigraph, and `weight` is not callable, the
+    minimum edge weight over all parallel edges is returned. If any edge
+    does not have an attribute with key `weight`, it is assumed to
+    have weight one.
+
+    """
+    if callable(weight):
+        return weight
+    # If the weight keyword argument is not callable, we assume it is a
+    # string representing the edge attribute containing the weight of
+    # the edge.
+    if G.is_multigraph():
+        return lambda u, v, d: min(attr.get(weight, 1) for attr in d.values())
+    return lambda u, v, data: data.get(weight, 1)
+
+
+def dijkstra_path(G, source, target, weight="weight"):
+    """Returns the shortest weighted path from source to target in G.
+
+    Uses Dijkstra's Method to compute the shortest weighted path
+    between two nodes in a graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+        Starting node
+
+    target : node
+        Ending node
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    path : list
+        List of nodes in a shortest path.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    NetworkXNoPath
+        If no path exists between source and target.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> print(nx.dijkstra_path(G, 0, 4))
+    [0, 1, 2, 3, 4]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The weight function can be used to hide edges by returning None.
+    So ``weight = lambda u, v, d: 1 if d['color']=="red" else None``
+    will find the shortest red path.
+
+    The weight function can be used to include node weights.
+
+    >>> def func(u, v, d):
+    ...     node_u_wt = G.nodes[u].get("node_weight", 1)
+    ...     node_v_wt = G.nodes[v].get("node_weight", 1)
+    ...     edge_wt = d.get("weight", 1)
+    ...     return node_u_wt / 2 + node_v_wt / 2 + edge_wt
+
+    In this example we take the average of start and end node
+    weights of an edge and add it to the weight of the edge.
+
+    The function :func:`single_source_dijkstra` computes both
+    path and length-of-path if you need both, use that.
+
+    See Also
+    --------
+    bidirectional_dijkstra
+    bellman_ford_path
+    single_source_dijkstra
+    """
+    (length, path) = single_source_dijkstra(G, source, target=target, weight=weight)
+    return path
+
+
+def dijkstra_path_length(G, source, target, weight="weight"):
+    """Returns the shortest weighted path length in G from source to target.
+
+    Uses Dijkstra's Method to compute the shortest weighted path length
+    between two nodes in a graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node label
+        starting node for path
+
+    target : node label
+        ending node for path
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    length : number
+        Shortest path length.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    NetworkXNoPath
+        If no path exists between source and target.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> nx.dijkstra_path_length(G, 0, 4)
+    4
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The weight function can be used to hide edges by returning None.
+    So ``weight = lambda u, v, d: 1 if d['color']=="red" else None``
+    will find the shortest red path.
+
+    The function :func:`single_source_dijkstra` computes both
+    path and length-of-path if you need both, use that.
+
+    See Also
+    --------
+    bidirectional_dijkstra
+    bellman_ford_path_length
+    single_source_dijkstra
+
+    """
+    if source not in G:
+        raise nx.NodeNotFound(f"Node {source} not found in graph")
+    if source == target:
+        return 0
+    weight = _weight_function(G, weight)
+    length = _dijkstra(G, source, weight, target=target)
+    try:
+        return length[target]
+    except KeyError as err:
+        raise nx.NetworkXNoPath(f"Node {target} not reachable from {source}") from err
+
+
+def single_source_dijkstra_path(G, source, cutoff=None, weight="weight"):
+    """Find shortest weighted paths in G from a source node.
+
+    Compute shortest path between source and all other reachable
+    nodes for a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+        Starting node for path.
+
+    cutoff : integer or float, optional
+        Length (sum of edge weights) at which the search is stopped.
+        If cutoff is provided, only return paths with summed weight <= cutoff.
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    paths : dictionary
+        Dictionary of shortest path lengths keyed by target.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> path = nx.single_source_dijkstra_path(G, 0)
+    >>> path[4]
+    [0, 1, 2, 3, 4]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The weight function can be used to hide edges by returning None.
+    So ``weight = lambda u, v, d: 1 if d['color']=="red" else None``
+    will find the shortest red path.
+
+    See Also
+    --------
+    single_source_dijkstra, single_source_bellman_ford
+
+    """
+    return multi_source_dijkstra_path(G, {source}, cutoff=cutoff, weight=weight)
+
+
+def single_source_dijkstra_path_length(G, source, cutoff=None, weight="weight"):
+    """Find shortest weighted path lengths in G from a source node.
+
+    Compute the shortest path length between source and all other
+    reachable nodes for a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node label
+        Starting node for path
+
+    cutoff : integer or float, optional
+        Length (sum of edge weights) at which the search is stopped.
+        If cutoff is provided, only return paths with summed weight <= cutoff.
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    length : dict
+        Dict keyed by node to shortest path length from source.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> length = nx.single_source_dijkstra_path_length(G, 0)
+    >>> length[4]
+    4
+    >>> for node in [0, 1, 2, 3, 4]:
+    ...     print(f"{node}: {length[node]}")
+    0: 0
+    1: 1
+    2: 2
+    3: 3
+    4: 4
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The weight function can be used to hide edges by returning None.
+    So ``weight = lambda u, v, d: 1 if d['color']=="red" else None``
+    will find the shortest red path.
+
+    See Also
+    --------
+    single_source_dijkstra, single_source_bellman_ford_path_length
+
+    """
+    return multi_source_dijkstra_path_length(G, {source}, cutoff=cutoff, weight=weight)
+
+
+def single_source_dijkstra(G, source, target=None, cutoff=None, weight="weight"):
+    """Find shortest weighted paths and lengths from a source node.
+
+    Compute the shortest path length between source and all other
+    reachable nodes for a weighted graph.
+
+    Uses Dijkstra's algorithm to compute shortest paths and lengths
+    between a source and all other reachable nodes in a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node label
+        Starting node for path
+
+    target : node label, optional
+        Ending node for path
+
+    cutoff : integer or float, optional
+        Length (sum of edge weights) at which the search is stopped.
+        If cutoff is provided, only return paths with summed weight <= cutoff.
+
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    distance, path : pair of dictionaries, or numeric and list.
+        If target is None, paths and lengths to all nodes are computed.
+        The return value is a tuple of two dictionaries keyed by target nodes.
+        The first dictionary stores distance to each target node.
+        The second stores the path to each target node.
+        If target is not None, returns a tuple (distance, path), where
+        distance is the distance from source to target and path is a list
+        representing the path from source to target.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> length, path = nx.single_source_dijkstra(G, 0)
+    >>> length[4]
+    4
+    >>> for node in [0, 1, 2, 3, 4]:
+    ...     print(f"{node}: {length[node]}")
+    0: 0
+    1: 1
+    2: 2
+    3: 3
+    4: 4
+    >>> path[4]
+    [0, 1, 2, 3, 4]
+    >>> length, path = nx.single_source_dijkstra(G, 0, 1)
+    >>> length
+    1
+    >>> path
+    [0, 1]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The weight function can be used to hide edges by returning None.
+    So ``weight = lambda u, v, d: 1 if d['color']=="red" else None``
+    will find the shortest red path.
+
+    Based on the Python cookbook recipe (119466) at
+    https://code.activestate.com/recipes/119466/
+
+    This algorithm is not guaranteed to work if edge weights
+    are negative or are floating point numbers
+    (overflows and roundoff errors can cause problems).
+
+    See Also
+    --------
+    single_source_dijkstra_path
+    single_source_dijkstra_path_length
+    single_source_bellman_ford
+    """
+    return multi_source_dijkstra(
+        G, {source}, cutoff=cutoff, target=target, weight=weight
+    )
+
+
+def multi_source_dijkstra_path(G, sources, cutoff=None, weight="weight"):
+    """Find shortest weighted paths in G from a given set of source
+    nodes.
+
+    Compute shortest path between any of the source nodes and all other
+    reachable nodes for a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    sources : non-empty set of nodes
+        Starting nodes for paths. If this is just a set containing a
+        single node, then all paths computed by this function will start
+        from that node. If there are two or more nodes in the set, the
+        computed paths may begin from any one of the start nodes.
+
+    cutoff : integer or float, optional
+        Length (sum of edge weights) at which the search is stopped.
+        If cutoff is provided, only return paths with summed weight <= cutoff.
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    paths : dictionary
+        Dictionary of shortest paths keyed by target.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> path = nx.multi_source_dijkstra_path(G, {0, 4})
+    >>> path[1]
+    [0, 1]
+    >>> path[3]
+    [4, 3]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The weight function can be used to hide edges by returning None.
+    So ``weight = lambda u, v, d: 1 if d['color']=="red" else None``
+    will find the shortest red path.
+
+    Raises
+    ------
+    ValueError
+        If `sources` is empty.
+    NodeNotFound
+        If any of `sources` is not in `G`.
+
+    See Also
+    --------
+    multi_source_dijkstra, multi_source_bellman_ford
+
+    """
+    length, path = multi_source_dijkstra(G, sources, cutoff=cutoff, weight=weight)
+    return path
+
+
+def multi_source_dijkstra_path_length(G, sources, cutoff=None, weight="weight"):
+    """Find shortest weighted path lengths in G from a given set of
+    source nodes.
+
+    Compute the shortest path length between any of the source nodes and
+    all other reachable nodes for a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    sources : non-empty set of nodes
+        Starting nodes for paths. If this is just a set containing a
+        single node, then all paths computed by this function will start
+        from that node. If there are two or more nodes in the set, the
+        computed paths may begin from any one of the start nodes.
+
+    cutoff : integer or float, optional
+        Length (sum of edge weights) at which the search is stopped.
+        If cutoff is provided, only return paths with summed weight <= cutoff.
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    length : dict
+        Dict keyed by node to shortest path length to nearest source.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> length = nx.multi_source_dijkstra_path_length(G, {0, 4})
+    >>> for node in [0, 1, 2, 3, 4]:
+    ...     print(f"{node}: {length[node]}")
+    0: 0
+    1: 1
+    2: 2
+    3: 1
+    4: 0
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The weight function can be used to hide edges by returning None.
+    So ``weight = lambda u, v, d: 1 if d['color']=="red" else None``
+    will find the shortest red path.
+
+    Raises
+    ------
+    ValueError
+        If `sources` is empty.
+    NodeNotFound
+        If any of `sources` is not in `G`.
+
+    See Also
+    --------
+    multi_source_dijkstra
+
+    """
+    if not sources:
+        raise ValueError("sources must not be empty")
+    for s in sources:
+        if s not in G:
+            raise nx.NodeNotFound(f"Node {s} not found in graph")
+    weight = _weight_function(G, weight)
+    return _dijkstra_multisource(G, sources, weight, cutoff=cutoff)
+
+
+def multi_source_dijkstra(G, sources, target=None, cutoff=None, weight="weight"):
+    """Find shortest weighted paths and lengths from a given set of
+    source nodes.
+
+    Uses Dijkstra's algorithm to compute the shortest paths and lengths
+    between one of the source nodes and the given `target`, or all other
+    reachable nodes if not specified, for a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    sources : non-empty set of nodes
+        Starting nodes for paths. If this is just a set containing a
+        single node, then all paths computed by this function will start
+        from that node. If there are two or more nodes in the set, the
+        computed paths may begin from any one of the start nodes.
+
+    target : node label, optional
+        Ending node for path
+
+    cutoff : integer or float, optional
+        Length (sum of edge weights) at which the search is stopped.
+        If cutoff is provided, only return paths with summed weight <= cutoff.
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    distance, path : pair of dictionaries, or numeric and list
+        If target is None, returns a tuple of two dictionaries keyed by node.
+        The first dictionary stores distance from one of the source nodes.
+        The second stores the path from one of the sources to that node.
+        If target is not None, returns a tuple of (distance, path) where
+        distance is the distance from source to target and path is a list
+        representing the path from source to target.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> length, path = nx.multi_source_dijkstra(G, {0, 4})
+    >>> for node in [0, 1, 2, 3, 4]:
+    ...     print(f"{node}: {length[node]}")
+    0: 0
+    1: 1
+    2: 2
+    3: 1
+    4: 0
+    >>> path[1]
+    [0, 1]
+    >>> path[3]
+    [4, 3]
+
+    >>> length, path = nx.multi_source_dijkstra(G, {0, 4}, 1)
+    >>> length
+    1
+    >>> path
+    [0, 1]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The weight function can be used to hide edges by returning None.
+    So ``weight = lambda u, v, d: 1 if d['color']=="red" else None``
+    will find the shortest red path.
+
+    Based on the Python cookbook recipe (119466) at
+    https://code.activestate.com/recipes/119466/
+
+    This algorithm is not guaranteed to work if edge weights
+    are negative or are floating point numbers
+    (overflows and roundoff errors can cause problems).
+
+    Raises
+    ------
+    ValueError
+        If `sources` is empty.
+    NodeNotFound
+        If any of `sources` is not in `G`.
+
+    See Also
+    --------
+    multi_source_dijkstra_path
+    multi_source_dijkstra_path_length
+
+    """
+    if not sources:
+        raise ValueError("sources must not be empty")
+    for s in sources:
+        if s not in G:
+            raise nx.NodeNotFound(f"Node {s} not found in graph")
+    if target in sources:
+        return (0, [target])
+    weight = _weight_function(G, weight)
+    paths = {source: [source] for source in sources}  # dictionary of paths
+    dist = _dijkstra_multisource(
+        G, sources, weight, paths=paths, cutoff=cutoff, target=target
+    )
+    if target is None:
+        return (dist, paths)
+    try:
+        return (dist[target], paths[target])
+    except KeyError as err:
+        raise nx.NetworkXNoPath(f"No path to {target}.") from err
+
+
+def _dijkstra(G, source, weight, pred=None, paths=None, cutoff=None, target=None):
+    """Uses Dijkstra's algorithm to find shortest weighted paths from a
+    single source.
+
+    This is a convenience function for :func:`_dijkstra_multisource`
+    with all the arguments the same, except the keyword argument
+    `sources` set to ``[source]``.
+
+    """
+    return _dijkstra_multisource(
+        G, [source], weight, pred=pred, paths=paths, cutoff=cutoff, target=target
+    )
+
+
+def _dijkstra_multisource(
+    G, sources, weight, pred=None, paths=None, cutoff=None, target=None
+):
+    """Uses Dijkstra's algorithm to find shortest weighted paths
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    sources : non-empty iterable of nodes
+        Starting nodes for paths. If this is just an iterable containing
+        a single node, then all paths computed by this function will
+        start from that node. If there are two or more nodes in this
+        iterable, the computed paths may begin from any one of the start
+        nodes.
+
+    weight: function
+        Function with (u, v, data) input that returns that edges weight
+
+    pred: dict of lists, optional(default=None)
+        dict to store a list of predecessors keyed by that node
+        If None, predecessors are not stored.
+
+    paths: dict, optional (default=None)
+        dict to store the path list from source to each node, keyed by node.
+        If None, paths are not stored.
+
+    target : node label, optional
+        Ending node for path. Search is halted when target is found.
+
+    cutoff : integer or float, optional
+        Length (sum of edge weights) at which the search is stopped.
+        If cutoff is provided, only return paths with summed weight <= cutoff.
+
+    Returns
+    -------
+    distance : dictionary
+        A mapping from node to shortest distance to that node from one
+        of the source nodes.
+
+    Raises
+    ------
+    NodeNotFound
+        If any of `sources` is not in `G`.
+
+    Notes
+    -----
+    The optional predecessor and path dictionaries can be accessed by
+    the caller through the original pred and paths objects passed
+    as arguments. No need to explicitly return pred or paths.
+
+    """
+    G_succ = G._adj  # For speed-up (and works for both directed and undirected graphs)
+
+    push = heappush
+    pop = heappop
+    dist = {}  # dictionary of final distances
+    seen = {}
+    # fringe is heapq with 3-tuples (distance,c,node)
+    # use the count c to avoid comparing nodes (may not be able to)
+    c = count()
+    fringe = []
+    for source in sources:
+        seen[source] = 0
+        push(fringe, (0, next(c), source))
+    while fringe:
+        (d, _, v) = pop(fringe)
+        if v in dist:
+            continue  # already searched this node.
+        dist[v] = d
+        if v == target:
+            break
+        for u, e in G_succ[v].items():
+            cost = weight(v, u, e)
+            if cost is None:
+                continue
+            vu_dist = dist[v] + cost
+            if cutoff is not None:
+                if vu_dist > cutoff:
+                    continue
+            if u in dist:
+                u_dist = dist[u]
+                if vu_dist < u_dist:
+                    raise ValueError("Contradictory paths found:", "negative weights?")
+                elif pred is not None and vu_dist == u_dist:
+                    pred[u].append(v)
+            elif u not in seen or vu_dist < seen[u]:
+                seen[u] = vu_dist
+                push(fringe, (vu_dist, next(c), u))
+                if paths is not None:
+                    paths[u] = paths[v] + [u]
+                if pred is not None:
+                    pred[u] = [v]
+            elif vu_dist == seen[u]:
+                if pred is not None:
+                    pred[u].append(v)
+
+    # The optional predecessor and path dictionaries can be accessed
+    # by the caller via the pred and paths objects passed as arguments.
+    return dist
+
+
+def dijkstra_predecessor_and_distance(G, source, cutoff=None, weight="weight"):
+    """Compute weighted shortest path length and predecessors.
+
+    Uses Dijkstra's Method to obtain the shortest weighted paths
+    and return dictionaries of predecessors for each node and
+    distance for each node from the `source`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node label
+        Starting node for path
+
+    cutoff : integer or float, optional
+        Length (sum of edge weights) at which the search is stopped.
+        If cutoff is provided, only return paths with summed weight <= cutoff.
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    pred, distance : dictionaries
+        Returns two dictionaries representing a list of predecessors
+        of a node and the distance to each node.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The list of predecessors contains more than one element only when
+    there are more than one shortest paths to the key node.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5, create_using=nx.DiGraph())
+    >>> pred, dist = nx.dijkstra_predecessor_and_distance(G, 0)
+    >>> sorted(pred.items())
+    [(0, []), (1, [0]), (2, [1]), (3, [2]), (4, [3])]
+    >>> sorted(dist.items())
+    [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
+
+    >>> pred, dist = nx.dijkstra_predecessor_and_distance(G, 0, 1)
+    >>> sorted(pred.items())
+    [(0, []), (1, [0])]
+    >>> sorted(dist.items())
+    [(0, 0), (1, 1)]
+    """
+    if source not in G:
+        raise nx.NodeNotFound(f"Node {source} is not found in the graph")
+    weight = _weight_function(G, weight)
+    pred = {source: []}  # dictionary of predecessors
+    return (pred, _dijkstra(G, source, weight, pred=pred, cutoff=cutoff))
+
+
+def all_pairs_dijkstra(G, cutoff=None, weight="weight"):
+    """Find shortest weighted paths and lengths between all nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    cutoff : integer or float, optional
+        Length (sum of edge weights) at which the search is stopped.
+        If cutoff is provided, only return paths with summed weight <= cutoff.
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edge[u][v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Yields
+    ------
+    (node, (distance, path)) : (node obj, (dict, dict))
+        Each source node has two associated dicts. The first holds distance
+        keyed by target and the second holds paths keyed by target.
+        (See single_source_dijkstra for the source/target node terminology.)
+        If desired you can apply `dict()` to this function to create a dict
+        keyed by source node to the two dicts.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> len_path = dict(nx.all_pairs_dijkstra(G))
+    >>> len_path[3][0][1]
+    2
+    >>> for node in [0, 1, 2, 3, 4]:
+    ...     print(f"3 - {node}: {len_path[3][0][node]}")
+    3 - 0: 3
+    3 - 1: 2
+    3 - 2: 1
+    3 - 3: 0
+    3 - 4: 1
+    >>> len_path[3][1][1]
+    [3, 2, 1]
+    >>> for n, (dist, path) in nx.all_pairs_dijkstra(G):
+    ...     print(path[1])
+    [0, 1]
+    [1]
+    [2, 1]
+    [3, 2, 1]
+    [4, 3, 2, 1]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The yielded dicts only have keys for reachable nodes.
+    """
+    for n in G:
+        dist, path = single_source_dijkstra(G, n, cutoff=cutoff, weight=weight)
+        yield (n, (dist, path))
+
+
+def all_pairs_dijkstra_path_length(G, cutoff=None, weight="weight"):
+    """Compute shortest path lengths between all nodes in a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    cutoff : integer or float, optional
+        Length (sum of edge weights) at which the search is stopped.
+        If cutoff is provided, only return paths with summed weight <= cutoff.
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    distance : iterator
+        (source, dictionary) iterator with dictionary keyed by target and
+        shortest path length as the key value.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> length = dict(nx.all_pairs_dijkstra_path_length(G))
+    >>> for node in [0, 1, 2, 3, 4]:
+    ...     print(f"1 - {node}: {length[1][node]}")
+    1 - 0: 1
+    1 - 1: 0
+    1 - 2: 1
+    1 - 3: 2
+    1 - 4: 3
+    >>> length[3][2]
+    1
+    >>> length[2][2]
+    0
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The dictionary returned only has keys for reachable node pairs.
+    """
+    length = single_source_dijkstra_path_length
+    for n in G:
+        yield (n, length(G, n, cutoff=cutoff, weight=weight))
+
+
+def all_pairs_dijkstra_path(G, cutoff=None, weight="weight"):
+    """Compute shortest paths between all nodes in a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    cutoff : integer or float, optional
+        Length (sum of edge weights) at which the search is stopped.
+        If cutoff is provided, only return paths with summed weight <= cutoff.
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    distance : dictionary
+        Dictionary, keyed by source and target, of shortest paths.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> path = dict(nx.all_pairs_dijkstra_path(G))
+    >>> path[0][4]
+    [0, 1, 2, 3, 4]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    See Also
+    --------
+    floyd_warshall, all_pairs_bellman_ford_path
+
+    """
+    path = single_source_dijkstra_path
+    # TODO This can be trivially parallelized.
+    for n in G:
+        yield (n, path(G, n, cutoff=cutoff, weight=weight))
+
+
+def bellman_ford_predecessor_and_distance(
+    G, source, target=None, weight="weight", heuristic=False
+):
+    """Compute shortest path lengths and predecessors on shortest paths
+    in weighted graphs.
+
+    The algorithm has a running time of $O(mn)$ where $n$ is the number of
+    nodes and $m$ is the number of edges.  It is slower than Dijkstra but
+    can handle negative edge weights.
+
+    If a negative cycle is detected, you can use :func:`find_negative_cycle`
+    to return the cycle and examine it. Shortest paths are not defined when
+    a negative cycle exists because once reached, the path can cycle forever
+    to build up arbitrarily low weights.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The algorithm works for all types of graphs, including directed
+        graphs and multigraphs.
+
+    source: node label
+        Starting node for path
+
+    target : node label, optional
+        Ending node for path
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    heuristic : bool
+        Determines whether to use a heuristic to early detect negative
+        cycles at a hopefully negligible cost.
+
+    Returns
+    -------
+    pred, dist : dictionaries
+        Returns two dictionaries keyed by node to predecessor in the
+        path and to the distance from the source respectively.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    NetworkXUnbounded
+        If the (di)graph contains a negative (di)cycle, the
+        algorithm raises an exception to indicate the presence of the
+        negative (di)cycle.  Note: any negative weight edge in an
+        undirected graph is a negative cycle.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5, create_using=nx.DiGraph())
+    >>> pred, dist = nx.bellman_ford_predecessor_and_distance(G, 0)
+    >>> sorted(pred.items())
+    [(0, []), (1, [0]), (2, [1]), (3, [2]), (4, [3])]
+    >>> sorted(dist.items())
+    [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
+
+    >>> pred, dist = nx.bellman_ford_predecessor_and_distance(G, 0, 1)
+    >>> sorted(pred.items())
+    [(0, []), (1, [0]), (2, [1]), (3, [2]), (4, [3])]
+    >>> sorted(dist.items())
+    [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
+
+    >>> G = nx.cycle_graph(5, create_using=nx.DiGraph())
+    >>> G[1][2]["weight"] = -7
+    >>> nx.bellman_ford_predecessor_and_distance(G, 0)
+    Traceback (most recent call last):
+        ...
+    networkx.exception.NetworkXUnbounded: Negative cycle detected.
+
+    See Also
+    --------
+    find_negative_cycle
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The dictionaries returned only have keys for nodes reachable from
+    the source.
+
+    In the case where the (di)graph is not connected, if a component
+    not containing the source contains a negative (di)cycle, it
+    will not be detected.
+
+    In NetworkX v2.1 and prior, the source node had predecessor `[None]`.
+    In NetworkX v2.2 this changed to the source node having predecessor `[]`
+    """
+    if source not in G:
+        raise nx.NodeNotFound(f"Node {source} is not found in the graph")
+    weight = _weight_function(G, weight)
+    if any(weight(u, v, d) < 0 for u, v, d in nx.selfloop_edges(G, data=True)):
+        raise nx.NetworkXUnbounded("Negative cycle detected.")
+
+    dist = {source: 0}
+    pred = {source: []}
+
+    if len(G) == 1:
+        return pred, dist
+
+    weight = _weight_function(G, weight)
+
+    dist = _bellman_ford(
+        G, [source], weight, pred=pred, dist=dist, target=target, heuristic=heuristic
+    )
+    return (pred, dist)
+
+
+def _bellman_ford(
+    G,
+    source,
+    weight,
+    pred=None,
+    paths=None,
+    dist=None,
+    target=None,
+    heuristic=True,
+):
+    """Calls relaxation loop for Bellman–Ford algorithm and builds paths
+
+    This is an implementation of the SPFA variant.
+    See https://en.wikipedia.org/wiki/Shortest_Path_Faster_Algorithm
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source: list
+        List of source nodes. The shortest path from any of the source
+        nodes will be found if multiple sources are provided.
+
+    weight : function
+        The weight of an edge is the value returned by the function. The
+        function must accept exactly three positional arguments: the two
+        endpoints of an edge and the dictionary of edge attributes for
+        that edge. The function must return a number.
+
+    pred: dict of lists, optional (default=None)
+        dict to store a list of predecessors keyed by that node
+        If None, predecessors are not stored
+
+    paths: dict, optional (default=None)
+        dict to store the path list from source to each node, keyed by node
+        If None, paths are not stored
+
+    dist: dict, optional (default=None)
+        dict to store distance from source to the keyed node
+        If None, returned dist dict contents default to 0 for every node in the
+        source list
+
+    target: node label, optional
+        Ending node for path. Path lengths to other destinations may (and
+        probably will) be incorrect.
+
+    heuristic : bool
+        Determines whether to use a heuristic to early detect negative
+        cycles at a hopefully negligible cost.
+
+    Returns
+    -------
+    dist : dict
+        Returns a dict keyed by node to the distance from the source.
+        Dicts for paths and pred are in the mutated input dicts by those names.
+
+    Raises
+    ------
+    NodeNotFound
+        If any of `source` is not in `G`.
+
+    NetworkXUnbounded
+        If the (di)graph contains a negative (di)cycle, the
+        algorithm raises an exception to indicate the presence of the
+        negative (di)cycle.  Note: any negative weight edge in an
+        undirected graph is a negative cycle
+    """
+    if pred is None:
+        pred = {v: [] for v in source}
+
+    if dist is None:
+        dist = {v: 0 for v in source}
+
+    negative_cycle_found = _inner_bellman_ford(
+        G,
+        source,
+        weight,
+        pred,
+        dist,
+        heuristic,
+    )
+    if negative_cycle_found is not None:
+        raise nx.NetworkXUnbounded("Negative cycle detected.")
+
+    if paths is not None:
+        sources = set(source)
+        dsts = [target] if target is not None else pred
+        for dst in dsts:
+            gen = _build_paths_from_predecessors(sources, dst, pred)
+            paths[dst] = next(gen)
+
+    return dist
+
+
+def _inner_bellman_ford(
+    G,
+    sources,
+    weight,
+    pred,
+    dist=None,
+    heuristic=True,
+):
+    """Inner Relaxation loop for Bellman–Ford algorithm.
+
+    This is an implementation of the SPFA variant.
+    See https://en.wikipedia.org/wiki/Shortest_Path_Faster_Algorithm
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source: list
+        List of source nodes. The shortest path from any of the source
+        nodes will be found if multiple sources are provided.
+
+    weight : function
+        The weight of an edge is the value returned by the function. The
+        function must accept exactly three positional arguments: the two
+        endpoints of an edge and the dictionary of edge attributes for
+        that edge. The function must return a number.
+
+    pred: dict of lists
+        dict to store a list of predecessors keyed by that node
+
+    dist: dict, optional (default=None)
+        dict to store distance from source to the keyed node
+        If None, returned dist dict contents default to 0 for every node in the
+        source list
+
+    heuristic : bool
+        Determines whether to use a heuristic to early detect negative
+        cycles at a hopefully negligible cost.
+
+    Returns
+    -------
+    node or None
+        Return a node `v` where processing discovered a negative cycle.
+        If no negative cycle found, return None.
+
+    Raises
+    ------
+    NodeNotFound
+        If any of `source` is not in `G`.
+    """
+    for s in sources:
+        if s not in G:
+            raise nx.NodeNotFound(f"Source {s} not in G")
+
+    if pred is None:
+        pred = {v: [] for v in sources}
+
+    if dist is None:
+        dist = {v: 0 for v in sources}
+
+    # Heuristic Storage setup. Note: use None because nodes cannot be None
+    nonexistent_edge = (None, None)
+    pred_edge = {v: None for v in sources}
+    recent_update = {v: nonexistent_edge for v in sources}
+
+    G_succ = G._adj  # For speed-up (and works for both directed and undirected graphs)
+    inf = float("inf")
+    n = len(G)
+
+    count = {}
+    q = deque(sources)
+    in_q = set(sources)
+    while q:
+        u = q.popleft()
+        in_q.remove(u)
+
+        # Skip relaxations if any of the predecessors of u is in the queue.
+        if all(pred_u not in in_q for pred_u in pred[u]):
+            dist_u = dist[u]
+            for v, e in G_succ[u].items():
+                dist_v = dist_u + weight(u, v, e)
+
+                if dist_v < dist.get(v, inf):
+                    # In this conditional branch we are updating the path with v.
+                    # If it happens that some earlier update also added node v
+                    # that implies the existence of a negative cycle since
+                    # after the update node v would lie on the update path twice.
+                    # The update path is stored up to one of the source nodes,
+                    # therefore u is always in the dict recent_update
+                    if heuristic:
+                        if v in recent_update[u]:
+                            # Negative cycle found!
+                            pred[v].append(u)
+                            return v
+
+                        # Transfer the recent update info from u to v if the
+                        # same source node is the head of the update path.
+                        # If the source node is responsible for the cost update,
+                        # then clear the history and use it instead.
+                        if v in pred_edge and pred_edge[v] == u:
+                            recent_update[v] = recent_update[u]
+                        else:
+                            recent_update[v] = (u, v)
+
+                    if v not in in_q:
+                        q.append(v)
+                        in_q.add(v)
+                        count_v = count.get(v, 0) + 1
+                        if count_v == n:
+                            # Negative cycle found!
+                            return v
+
+                        count[v] = count_v
+                    dist[v] = dist_v
+                    pred[v] = [u]
+                    pred_edge[v] = u
+
+                elif dist.get(v) is not None and dist_v == dist.get(v):
+                    pred[v].append(u)
+
+    # successfully found shortest_path. No negative cycles found.
+    return None
+
+
+def bellman_ford_path(G, source, target, weight="weight"):
+    """Returns the shortest path from source to target in a weighted graph G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+        Starting node
+
+    target : node
+        Ending node
+
+    weight : string or function (default="weight")
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    path : list
+        List of nodes in a shortest path.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    NetworkXNoPath
+        If no path exists between source and target.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> nx.bellman_ford_path(G, 0, 4)
+    [0, 1, 2, 3, 4]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    See Also
+    --------
+    dijkstra_path, bellman_ford_path_length
+    """
+    length, path = single_source_bellman_ford(G, source, target=target, weight=weight)
+    return path
+
+
+def bellman_ford_path_length(G, source, target, weight="weight"):
+    """Returns the shortest path length from source to target
+    in a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node label
+        starting node for path
+
+    target : node label
+        ending node for path
+
+    weight : string or function (default="weight")
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    length : number
+        Shortest path length.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    NetworkXNoPath
+        If no path exists between source and target.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> nx.bellman_ford_path_length(G, 0, 4)
+    4
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    See Also
+    --------
+    dijkstra_path_length, bellman_ford_path
+    """
+    if source == target:
+        if source not in G:
+            raise nx.NodeNotFound(f"Node {source} not found in graph")
+        return 0
+
+    weight = _weight_function(G, weight)
+
+    length = _bellman_ford(G, [source], weight, target=target)
+
+    try:
+        return length[target]
+    except KeyError as err:
+        raise nx.NetworkXNoPath(f"node {target} not reachable from {source}") from err
+
+
+def single_source_bellman_ford_path(G, source, weight="weight"):
+    """Compute shortest path between source and all other reachable
+    nodes for a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+        Starting node for path.
+
+    weight : string or function (default="weight")
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    paths : dictionary
+        Dictionary of shortest path lengths keyed by target.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> path = nx.single_source_bellman_ford_path(G, 0)
+    >>> path[4]
+    [0, 1, 2, 3, 4]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    See Also
+    --------
+    single_source_dijkstra, single_source_bellman_ford
+
+    """
+    (length, path) = single_source_bellman_ford(G, source, weight=weight)
+    return path
+
+
+def single_source_bellman_ford_path_length(G, source, weight="weight"):
+    """Compute the shortest path length between source and all other
+    reachable nodes for a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node label
+        Starting node for path
+
+    weight : string or function (default="weight")
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    length : iterator
+        (target, shortest path length) iterator
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> length = dict(nx.single_source_bellman_ford_path_length(G, 0))
+    >>> length[4]
+    4
+    >>> for node in [0, 1, 2, 3, 4]:
+    ...     print(f"{node}: {length[node]}")
+    0: 0
+    1: 1
+    2: 2
+    3: 3
+    4: 4
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    See Also
+    --------
+    single_source_dijkstra, single_source_bellman_ford
+
+    """
+    weight = _weight_function(G, weight)
+    return _bellman_ford(G, [source], weight)
+
+
+def single_source_bellman_ford(G, source, target=None, weight="weight"):
+    """Compute shortest paths and lengths in a weighted graph G.
+
+    Uses Bellman-Ford algorithm for shortest paths.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node label
+        Starting node for path
+
+    target : node label, optional
+        Ending node for path
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    distance, path : pair of dictionaries, or numeric and list
+        If target is None, returns a tuple of two dictionaries keyed by node.
+        The first dictionary stores distance from one of the source nodes.
+        The second stores the path from one of the sources to that node.
+        If target is not None, returns a tuple of (distance, path) where
+        distance is the distance from source to target and path is a list
+        representing the path from source to target.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> length, path = nx.single_source_bellman_ford(G, 0)
+    >>> length[4]
+    4
+    >>> for node in [0, 1, 2, 3, 4]:
+    ...     print(f"{node}: {length[node]}")
+    0: 0
+    1: 1
+    2: 2
+    3: 3
+    4: 4
+    >>> path[4]
+    [0, 1, 2, 3, 4]
+    >>> length, path = nx.single_source_bellman_ford(G, 0, 1)
+    >>> length
+    1
+    >>> path
+    [0, 1]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    See Also
+    --------
+    single_source_dijkstra
+    single_source_bellman_ford_path
+    single_source_bellman_ford_path_length
+    """
+    if source == target:
+        if source not in G:
+            raise nx.NodeNotFound(f"Node {source} is not found in the graph")
+        return (0, [source])
+
+    weight = _weight_function(G, weight)
+
+    paths = {source: [source]}  # dictionary of paths
+    dist = _bellman_ford(G, [source], weight, paths=paths, target=target)
+    if target is None:
+        return (dist, paths)
+    try:
+        return (dist[target], paths[target])
+    except KeyError as err:
+        msg = f"Node {target} not reachable from {source}"
+        raise nx.NetworkXNoPath(msg) from err
+
+
+def all_pairs_bellman_ford_path_length(G, weight="weight"):
+    """Compute shortest path lengths between all nodes in a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight : string or function (default="weight")
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    distance : iterator
+        (source, dictionary) iterator with dictionary keyed by target and
+        shortest path length as the key value.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> length = dict(nx.all_pairs_bellman_ford_path_length(G))
+    >>> for node in [0, 1, 2, 3, 4]:
+    ...     print(f"1 - {node}: {length[1][node]}")
+    1 - 0: 1
+    1 - 1: 0
+    1 - 2: 1
+    1 - 3: 2
+    1 - 4: 3
+    >>> length[3][2]
+    1
+    >>> length[2][2]
+    0
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The dictionary returned only has keys for reachable node pairs.
+    """
+    length = single_source_bellman_ford_path_length
+    for n in G:
+        yield (n, dict(length(G, n, weight=weight)))
+
+
+def all_pairs_bellman_ford_path(G, weight="weight"):
+    """Compute shortest paths between all nodes in a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight : string or function (default="weight")
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    distance : dictionary
+        Dictionary, keyed by source and target, of shortest paths.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> path = dict(nx.all_pairs_bellman_ford_path(G))
+    >>> path[0][4]
+    [0, 1, 2, 3, 4]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    See Also
+    --------
+    floyd_warshall, all_pairs_dijkstra_path
+
+    """
+    path = single_source_bellman_ford_path
+    # TODO This can be trivially parallelized.
+    for n in G:
+        yield (n, path(G, n, weight=weight))
+
+
+def goldberg_radzik(G, source, weight="weight"):
+    """Compute shortest path lengths and predecessors on shortest paths
+    in weighted graphs.
+
+    The algorithm has a running time of $O(mn)$ where $n$ is the number of
+    nodes and $m$ is the number of edges.  It is slower than Dijkstra but
+    can handle negative edge weights.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The algorithm works for all types of graphs, including directed
+        graphs and multigraphs.
+
+    source: node label
+        Starting node for path
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    pred, dist : dictionaries
+        Returns two dictionaries keyed by node to predecessor in the
+        path and to the distance from the source respectively.
+
+    Raises
+    ------
+    NodeNotFound
+        If `source` is not in `G`.
+
+    NetworkXUnbounded
+        If the (di)graph contains a negative (di)cycle, the
+        algorithm raises an exception to indicate the presence of the
+        negative (di)cycle.  Note: any negative weight edge in an
+        undirected graph is a negative cycle.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5, create_using=nx.DiGraph())
+    >>> pred, dist = nx.goldberg_radzik(G, 0)
+    >>> sorted(pred.items())
+    [(0, None), (1, 0), (2, 1), (3, 2), (4, 3)]
+    >>> sorted(dist.items())
+    [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
+
+    >>> G = nx.cycle_graph(5, create_using=nx.DiGraph())
+    >>> G[1][2]["weight"] = -7
+    >>> nx.goldberg_radzik(G, 0)
+    Traceback (most recent call last):
+        ...
+    networkx.exception.NetworkXUnbounded: Negative cycle detected.
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The dictionaries returned only have keys for nodes reachable from
+    the source.
+
+    In the case where the (di)graph is not connected, if a component
+    not containing the source contains a negative (di)cycle, it
+    will not be detected.
+
+    """
+    if source not in G:
+        raise nx.NodeNotFound(f"Node {source} is not found in the graph")
+    weight = _weight_function(G, weight)
+    if any(weight(u, v, d) < 0 for u, v, d in nx.selfloop_edges(G, data=True)):
+        raise nx.NetworkXUnbounded("Negative cycle detected.")
+
+    if len(G) == 1:
+        return {source: None}, {source: 0}
+
+    G_succ = G._adj  # For speed-up (and works for both directed and undirected graphs)
+
+    inf = float("inf")
+    d = {u: inf for u in G}
+    d[source] = 0
+    pred = {source: None}
+
+    def topo_sort(relabeled):
+        """Topologically sort nodes relabeled in the previous round and detect
+        negative cycles.
+        """
+        # List of nodes to scan in this round. Denoted by A in Goldberg and
+        # Radzik's paper.
+        to_scan = []
+        # In the DFS in the loop below, neg_count records for each node the
+        # number of edges of negative reduced costs on the path from a DFS root
+        # to the node in the DFS forest. The reduced cost of an edge (u, v) is
+        # defined as d[u] + weight[u][v] - d[v].
+        #
+        # neg_count also doubles as the DFS visit marker array.
+        neg_count = {}
+        for u in relabeled:
+            # Skip visited nodes.
+            if u in neg_count:
+                continue
+            d_u = d[u]
+            # Skip nodes without out-edges of negative reduced costs.
+            if all(d_u + weight(u, v, e) >= d[v] for v, e in G_succ[u].items()):
+                continue
+            # Nonrecursive DFS that inserts nodes reachable from u via edges of
+            # nonpositive reduced costs into to_scan in (reverse) topological
+            # order.
+            stack = [(u, iter(G_succ[u].items()))]
+            in_stack = {u}
+            neg_count[u] = 0
+            while stack:
+                u, it = stack[-1]
+                try:
+                    v, e = next(it)
+                except StopIteration:
+                    to_scan.append(u)
+                    stack.pop()
+                    in_stack.remove(u)
+                    continue
+                t = d[u] + weight(u, v, e)
+                d_v = d[v]
+                if t <= d_v:
+                    is_neg = t < d_v
+                    d[v] = t
+                    pred[v] = u
+                    if v not in neg_count:
+                        neg_count[v] = neg_count[u] + int(is_neg)
+                        stack.append((v, iter(G_succ[v].items())))
+                        in_stack.add(v)
+                    elif v in in_stack and neg_count[u] + int(is_neg) > neg_count[v]:
+                        # (u, v) is a back edge, and the cycle formed by the
+                        # path v to u and (u, v) contains at least one edge of
+                        # negative reduced cost. The cycle must be of negative
+                        # cost.
+                        raise nx.NetworkXUnbounded("Negative cycle detected.")
+        to_scan.reverse()
+        return to_scan
+
+    def relax(to_scan):
+        """Relax out-edges of relabeled nodes."""
+        relabeled = set()
+        # Scan nodes in to_scan in topological order and relax incident
+        # out-edges. Add the relabled nodes to labeled.
+        for u in to_scan:
+            d_u = d[u]
+            for v, e in G_succ[u].items():
+                w_e = weight(u, v, e)
+                if d_u + w_e < d[v]:
+                    d[v] = d_u + w_e
+                    pred[v] = u
+                    relabeled.add(v)
+        return relabeled
+
+    # Set of nodes relabled in the last round of scan operations. Denoted by B
+    # in Goldberg and Radzik's paper.
+    relabeled = {source}
+
+    while relabeled:
+        to_scan = topo_sort(relabeled)
+        relabeled = relax(to_scan)
+
+    d = {u: d[u] for u in pred}
+    return pred, d
+
+
+def negative_edge_cycle(G, weight="weight", heuristic=True):
+    """Returns True if there exists a negative edge cycle anywhere in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    heuristic : bool
+        Determines whether to use a heuristic to early detect negative
+        cycles at a negligible cost. In case of graphs with a negative cycle,
+        the performance of detection increases by at least an order of magnitude.
+
+    Returns
+    -------
+    negative_cycle : bool
+        True if a negative edge cycle exists, otherwise False.
+
+    Examples
+    --------
+    >>> G = nx.cycle_graph(5, create_using=nx.DiGraph())
+    >>> print(nx.negative_edge_cycle(G))
+    False
+    >>> G[1][2]["weight"] = -7
+    >>> print(nx.negative_edge_cycle(G))
+    True
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    This algorithm uses bellman_ford_predecessor_and_distance() but finds
+    negative cycles on any component by first adding a new node connected to
+    every node, and starting bellman_ford_predecessor_and_distance on that
+    node.  It then removes that extra node.
+    """
+    # find unused node to use temporarily
+    newnode = -1
+    while newnode in G:
+        newnode -= 1
+    # connect it to all nodes
+    G.add_edges_from([(newnode, n) for n in G])
+
+    try:
+        bellman_ford_predecessor_and_distance(
+            G, newnode, weight=weight, heuristic=heuristic
+        )
+    except nx.NetworkXUnbounded:
+        return True
+    finally:
+        G.remove_node(newnode)
+    return False
+
+
+def find_negative_cycle(G, source, weight="weight"):
+    """Returns a cycle with negative total weight if it exists.
+
+    Bellman-Ford is used to find shortest_paths. That algorithm
+    stops if there exists a negative cycle. This algorithm
+    picks up from there and returns the found negative cycle.
+
+    The cycle consists of a list of nodes in the cycle order. The last
+    node equals the first to make it a cycle.
+    You can look up the edge weights in the original graph. In the case
+    of multigraphs the relevant edge is the minimal weight edge between
+    the nodes in the 2-tuple.
+
+    If the graph has no negative cycle, a NetworkXError is raised.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source: node label
+        The search for the negative cycle will start from this node.
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_weighted_edges_from([(0, 1, 2), (1, 2, 2), (2, 0, 1), (1, 4, 2), (4, 0, -5)])
+    >>> nx.find_negative_cycle(G, 0)
+    [4, 0, 1, 4]
+
+    Returns
+    -------
+    cycle : list
+        A list of nodes in the order of the cycle found. The last node
+        equals the first to indicate a cycle.
+
+    Raises
+    ------
+    NetworkXError
+        If no negative cycle is found.
+    """
+    weight = _weight_function(G, weight)
+    pred = {source: []}
+
+    v = _inner_bellman_ford(G, [source], weight, pred=pred)
+    if v is None:
+        raise nx.NetworkXError("No negative cycles detected.")
+
+    # negative cycle detected... find it
+    neg_cycle = []
+    stack = [(v, list(pred[v]))]
+    seen = {v}
+    while stack:
+        node, preds = stack[-1]
+        if v in preds:
+            # found the cycle
+            neg_cycle.extend([node, v])
+            neg_cycle = list(reversed(neg_cycle))
+            return neg_cycle
+
+        if preds:
+            nbr = preds.pop()
+            if nbr not in seen:
+                stack.append((nbr, list(pred[nbr])))
+                neg_cycle.append(node)
+                seen.add(nbr)
+        else:
+            stack.pop()
+            if neg_cycle:
+                neg_cycle.pop()
+            else:
+                if v in G[v] and weight(G, v, v) < 0:
+                    return [v, v]
+                # should not reach here
+                raise nx.NetworkXError("Negative cycle is detected but not found")
+    # should not get here...
+    msg = "negative cycle detected but not identified"
+    raise nx.NetworkXUnbounded(msg)
+
+
+def bidirectional_dijkstra(G, source, target, weight="weight"):
+    r"""Dijkstra's algorithm for shortest paths using bidirectional search.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+        Starting node.
+
+    target : node
+        Ending node.
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    length, path : number and list
+        length is the distance from source to target.
+        path is a list of nodes on a path from source to target.
+
+    Raises
+    ------
+    NodeNotFound
+        If either `source` or `target` is not in `G`.
+
+    NetworkXNoPath
+        If no path exists between source and target.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> length, path = nx.bidirectional_dijkstra(G, 0, 4)
+    >>> print(length)
+    4
+    >>> print(path)
+    [0, 1, 2, 3, 4]
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    The weight function can be used to hide edges by returning None.
+    So ``weight = lambda u, v, d: 1 if d['color']=="red" else None``
+    will find the shortest red path.
+
+    In practice  bidirectional Dijkstra is much more than twice as fast as
+    ordinary Dijkstra.
+
+    Ordinary Dijkstra expands nodes in a sphere-like manner from the
+    source. The radius of this sphere will eventually be the length
+    of the shortest path. Bidirectional Dijkstra will expand nodes
+    from both the source and the target, making two spheres of half
+    this radius. Volume of the first sphere is `\pi*r*r` while the
+    others are `2*\pi*r/2*r/2`, making up half the volume.
+
+    This algorithm is not guaranteed to work if edge weights
+    are negative or are floating point numbers
+    (overflows and roundoff errors can cause problems).
+
+    See Also
+    --------
+    shortest_path
+    shortest_path_length
+    """
+    if source not in G or target not in G:
+        msg = f"Either source {source} or target {target} is not in G"
+        raise nx.NodeNotFound(msg)
+
+    if source == target:
+        return (0, [source])
+
+    weight = _weight_function(G, weight)
+    push = heappush
+    pop = heappop
+    # Init:  [Forward, Backward]
+    dists = [{}, {}]  # dictionary of final distances
+    paths = [{source: [source]}, {target: [target]}]  # dictionary of paths
+    fringe = [[], []]  # heap of (distance, node) for choosing node to expand
+    seen = [{source: 0}, {target: 0}]  # dict of distances to seen nodes
+    c = count()
+    # initialize fringe heap
+    push(fringe[0], (0, next(c), source))
+    push(fringe[1], (0, next(c), target))
+    # neighs for extracting correct neighbor information
+    if G.is_directed():
+        neighs = [G._succ, G._pred]
+    else:
+        neighs = [G._adj, G._adj]
+    # variables to hold shortest discovered path
+    # finaldist = 1e30000
+    finalpath = []
+    dir = 1
+    while fringe[0] and fringe[1]:
+        # choose direction
+        # dir == 0 is forward direction and dir == 1 is back
+        dir = 1 - dir
+        # extract closest to expand
+        (dist, _, v) = pop(fringe[dir])
+        if v in dists[dir]:
+            # Shortest path to v has already been found
+            continue
+        # update distance
+        dists[dir][v] = dist  # equal to seen[dir][v]
+        if v in dists[1 - dir]:
+            # if we have scanned v in both directions we are done
+            # we have now discovered the shortest path
+            return (finaldist, finalpath)
+
+        for w, d in neighs[dir][v].items():
+            # weight(v, w, d) for forward and weight(w, v, d) for back direction
+            cost = weight(v, w, d) if dir == 0 else weight(w, v, d)
+            if cost is None:
+                continue
+            vwLength = dists[dir][v] + cost
+            if w in dists[dir]:
+                if vwLength < dists[dir][w]:
+                    raise ValueError("Contradictory paths found: negative weights?")
+            elif w not in seen[dir] or vwLength < seen[dir][w]:
+                # relaxing
+                seen[dir][w] = vwLength
+                push(fringe[dir], (vwLength, next(c), w))
+                paths[dir][w] = paths[dir][v] + [w]
+                if w in seen[0] and w in seen[1]:
+                    # see if this path is better than the already
+                    # discovered shortest path
+                    totaldist = seen[0][w] + seen[1][w]
+                    if finalpath == [] or finaldist > totaldist:
+                        finaldist = totaldist
+                        revpath = paths[1][w][:]
+                        revpath.reverse()
+                        finalpath = paths[0][w] + revpath[1:]
+    raise nx.NetworkXNoPath(f"No path between {source} and {target}.")
+
+
+def johnson(G, weight="weight"):
+    r"""Uses Johnson's Algorithm to compute shortest paths.
+
+    Johnson's Algorithm finds a shortest path between each pair of
+    nodes in a weighted graph even if negative weights are present.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight : string or function
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    distance : dictionary
+        Dictionary, keyed by source and target, of shortest paths.
+
+    Raises
+    ------
+    NetworkXError
+        If given graph is not weighted.
+
+    Examples
+    --------
+    >>> graph = nx.DiGraph()
+    >>> graph.add_weighted_edges_from(
+    ...     [("0", "3", 3), ("0", "1", -5), ("0", "2", 2), ("1", "2", 4), ("2", "3", 1)]
+    ... )
+    >>> paths = nx.johnson(graph, weight="weight")
+    >>> paths["0"]["2"]
+    ['0', '1', '2']
+
+    Notes
+    -----
+    Johnson's algorithm is suitable even for graphs with negative weights. It
+    works by using the Bellman–Ford algorithm to compute a transformation of
+    the input graph that removes all negative weights, allowing Dijkstra's
+    algorithm to be used on the transformed graph.
+
+    The time complexity of this algorithm is $O(n^2 \log n + n m)$,
+    where $n$ is the number of nodes and $m$ the number of edges in the
+    graph. For dense graphs, this may be faster than the Floyd–Warshall
+    algorithm.
+
+    See Also
+    --------
+    floyd_warshall_predecessor_and_distance
+    floyd_warshall_numpy
+    all_pairs_shortest_path
+    all_pairs_shortest_path_length
+    all_pairs_dijkstra_path
+    bellman_ford_predecessor_and_distance
+    all_pairs_bellman_ford_path
+    all_pairs_bellman_ford_path_length
+
+    """
+    if not nx.is_weighted(G, weight=weight):
+        raise nx.NetworkXError("Graph is not weighted.")
+
+    dist = {v: 0 for v in G}
+    pred = {v: [] for v in G}
+    weight = _weight_function(G, weight)
+
+    # Calculate distance of shortest paths
+    dist_bellman = _bellman_ford(G, list(G), weight, pred=pred, dist=dist)
+
+    # Update the weight function to take into account the Bellman--Ford
+    # relaxation distances.
+    def new_weight(u, v, d):
+        return weight(u, v, d) + dist_bellman[u] - dist_bellman[v]
+
+    def dist_path(v):
+        paths = {v: [v]}
+        _dijkstra(G, v, new_weight, paths=paths)
+        return paths
+
+    return {v: dist_path(v) for v in G}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/similarity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/similarity.py
new file mode 100644
index 0000000..fe6e0f2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/similarity.py
@@ -0,0 +1,1731 @@
+""" Functions measuring similarity using graph edit distance.
+
+The graph edit distance is the number of edge/node changes needed
+to make two graphs isomorphic.
+
+The default algorithm/implementation is sub-optimal for some graphs.
+The problem of finding the exact Graph Edit Distance (GED) is NP-hard
+so it is often slow. If the simple interface `graph_edit_distance`
+takes too long for your graph, try `optimize_graph_edit_distance`
+and/or `optimize_edit_paths`.
+
+At the same time, I encourage capable people to investigate
+alternative GED algorithms, in order to improve the choices available.
+"""
+
+import math
+import time
+import warnings
+from functools import reduce
+from itertools import product
+from operator import mul
+
+import networkx as nx
+
+__all__ = [
+    "graph_edit_distance",
+    "optimal_edit_paths",
+    "optimize_graph_edit_distance",
+    "optimize_edit_paths",
+    "simrank_similarity",
+    "simrank_similarity_numpy",
+    "panther_similarity",
+    "generate_random_paths",
+]
+
+
+def debug_print(*args, **kwargs):
+    print(*args, **kwargs)
+
+
+def graph_edit_distance(
+    G1,
+    G2,
+    node_match=None,
+    edge_match=None,
+    node_subst_cost=None,
+    node_del_cost=None,
+    node_ins_cost=None,
+    edge_subst_cost=None,
+    edge_del_cost=None,
+    edge_ins_cost=None,
+    roots=None,
+    upper_bound=None,
+    timeout=None,
+):
+    """Returns GED (graph edit distance) between graphs G1 and G2.
+
+    Graph edit distance is a graph similarity measure analogous to
+    Levenshtein distance for strings.  It is defined as minimum cost
+    of edit path (sequence of node and edge edit operations)
+    transforming graph G1 to graph isomorphic to G2.
+
+    Parameters
+    ----------
+    G1, G2: graphs
+        The two graphs G1 and G2 must be of the same type.
+
+    node_match : callable
+        A function that returns True if node n1 in G1 and n2 in G2
+        should be considered equal during matching.
+
+        The function will be called like
+
+           node_match(G1.nodes[n1], G2.nodes[n2]).
+
+        That is, the function will receive the node attribute
+        dictionaries for n1 and n2 as inputs.
+
+        Ignored if node_subst_cost is specified.  If neither
+        node_match nor node_subst_cost are specified then node
+        attributes are not considered.
+
+    edge_match : callable
+        A function that returns True if the edge attribute dictionaries
+        for the pair of nodes (u1, v1) in G1 and (u2, v2) in G2 should
+        be considered equal during matching.
+
+        The function will be called like
+
+           edge_match(G1[u1][v1], G2[u2][v2]).
+
+        That is, the function will receive the edge attribute
+        dictionaries of the edges under consideration.
+
+        Ignored if edge_subst_cost is specified.  If neither
+        edge_match nor edge_subst_cost are specified then edge
+        attributes are not considered.
+
+    node_subst_cost, node_del_cost, node_ins_cost : callable
+        Functions that return the costs of node substitution, node
+        deletion, and node insertion, respectively.
+
+        The functions will be called like
+
+           node_subst_cost(G1.nodes[n1], G2.nodes[n2]),
+           node_del_cost(G1.nodes[n1]),
+           node_ins_cost(G2.nodes[n2]).
+
+        That is, the functions will receive the node attribute
+        dictionaries as inputs.  The functions are expected to return
+        positive numeric values.
+
+        Function node_subst_cost overrides node_match if specified.
+        If neither node_match nor node_subst_cost are specified then
+        default node substitution cost of 0 is used (node attributes
+        are not considered during matching).
+
+        If node_del_cost is not specified then default node deletion
+        cost of 1 is used.  If node_ins_cost is not specified then
+        default node insertion cost of 1 is used.
+
+    edge_subst_cost, edge_del_cost, edge_ins_cost : callable
+        Functions that return the costs of edge substitution, edge
+        deletion, and edge insertion, respectively.
+
+        The functions will be called like
+
+           edge_subst_cost(G1[u1][v1], G2[u2][v2]),
+           edge_del_cost(G1[u1][v1]),
+           edge_ins_cost(G2[u2][v2]).
+
+        That is, the functions will receive the edge attribute
+        dictionaries as inputs.  The functions are expected to return
+        positive numeric values.
+
+        Function edge_subst_cost overrides edge_match if specified.
+        If neither edge_match nor edge_subst_cost are specified then
+        default edge substitution cost of 0 is used (edge attributes
+        are not considered during matching).
+
+        If edge_del_cost is not specified then default edge deletion
+        cost of 1 is used.  If edge_ins_cost is not specified then
+        default edge insertion cost of 1 is used.
+
+    roots : 2-tuple
+        Tuple where first element is a node in G1 and the second
+        is a node in G2.
+        These nodes are forced to be matched in the comparison to
+        allow comparison between rooted graphs.
+
+    upper_bound : numeric
+        Maximum edit distance to consider.  Return None if no edit
+        distance under or equal to upper_bound exists.
+
+    timeout : numeric
+        Maximum number of seconds to execute.
+        After timeout is met, the current best GED is returned.
+
+    Examples
+    --------
+    >>> G1 = nx.cycle_graph(6)
+    >>> G2 = nx.wheel_graph(7)
+    >>> nx.graph_edit_distance(G1, G2)
+    7.0
+
+    >>> G1 = nx.star_graph(5)
+    >>> G2 = nx.star_graph(5)
+    >>> nx.graph_edit_distance(G1, G2, roots=(0, 0))
+    0.0
+    >>> nx.graph_edit_distance(G1, G2, roots=(1, 0))
+    8.0
+
+    See Also
+    --------
+    optimal_edit_paths, optimize_graph_edit_distance,
+
+    is_isomorphic: test for graph edit distance of 0
+
+    References
+    ----------
+    .. [1] Zeina Abu-Aisheh, Romain Raveaux, Jean-Yves Ramel, Patrick
+       Martineau. An Exact Graph Edit Distance Algorithm for Solving
+       Pattern Recognition Problems. 4th International Conference on
+       Pattern Recognition Applications and Methods 2015, Jan 2015,
+       Lisbon, Portugal. 2015,
+       <10.5220/0005209202710278>. <hal-01168816>
+       https://hal.archives-ouvertes.fr/hal-01168816
+
+    """
+    bestcost = None
+    for vertex_path, edge_path, cost in optimize_edit_paths(
+        G1,
+        G2,
+        node_match,
+        edge_match,
+        node_subst_cost,
+        node_del_cost,
+        node_ins_cost,
+        edge_subst_cost,
+        edge_del_cost,
+        edge_ins_cost,
+        upper_bound,
+        True,
+        roots,
+        timeout,
+    ):
+        # assert bestcost is None or cost < bestcost
+        bestcost = cost
+    return bestcost
+
+
+def optimal_edit_paths(
+    G1,
+    G2,
+    node_match=None,
+    edge_match=None,
+    node_subst_cost=None,
+    node_del_cost=None,
+    node_ins_cost=None,
+    edge_subst_cost=None,
+    edge_del_cost=None,
+    edge_ins_cost=None,
+    upper_bound=None,
+):
+    """Returns all minimum-cost edit paths transforming G1 to G2.
+
+    Graph edit path is a sequence of node and edge edit operations
+    transforming graph G1 to graph isomorphic to G2.  Edit operations
+    include substitutions, deletions, and insertions.
+
+    Parameters
+    ----------
+    G1, G2: graphs
+        The two graphs G1 and G2 must be of the same type.
+
+    node_match : callable
+        A function that returns True if node n1 in G1 and n2 in G2
+        should be considered equal during matching.
+
+        The function will be called like
+
+           node_match(G1.nodes[n1], G2.nodes[n2]).
+
+        That is, the function will receive the node attribute
+        dictionaries for n1 and n2 as inputs.
+
+        Ignored if node_subst_cost is specified.  If neither
+        node_match nor node_subst_cost are specified then node
+        attributes are not considered.
+
+    edge_match : callable
+        A function that returns True if the edge attribute dictionaries
+        for the pair of nodes (u1, v1) in G1 and (u2, v2) in G2 should
+        be considered equal during matching.
+
+        The function will be called like
+
+           edge_match(G1[u1][v1], G2[u2][v2]).
+
+        That is, the function will receive the edge attribute
+        dictionaries of the edges under consideration.
+
+        Ignored if edge_subst_cost is specified.  If neither
+        edge_match nor edge_subst_cost are specified then edge
+        attributes are not considered.
+
+    node_subst_cost, node_del_cost, node_ins_cost : callable
+        Functions that return the costs of node substitution, node
+        deletion, and node insertion, respectively.
+
+        The functions will be called like
+
+           node_subst_cost(G1.nodes[n1], G2.nodes[n2]),
+           node_del_cost(G1.nodes[n1]),
+           node_ins_cost(G2.nodes[n2]).
+
+        That is, the functions will receive the node attribute
+        dictionaries as inputs.  The functions are expected to return
+        positive numeric values.
+
+        Function node_subst_cost overrides node_match if specified.
+        If neither node_match nor node_subst_cost are specified then
+        default node substitution cost of 0 is used (node attributes
+        are not considered during matching).
+
+        If node_del_cost is not specified then default node deletion
+        cost of 1 is used.  If node_ins_cost is not specified then
+        default node insertion cost of 1 is used.
+
+    edge_subst_cost, edge_del_cost, edge_ins_cost : callable
+        Functions that return the costs of edge substitution, edge
+        deletion, and edge insertion, respectively.
+
+        The functions will be called like
+
+           edge_subst_cost(G1[u1][v1], G2[u2][v2]),
+           edge_del_cost(G1[u1][v1]),
+           edge_ins_cost(G2[u2][v2]).
+
+        That is, the functions will receive the edge attribute
+        dictionaries as inputs.  The functions are expected to return
+        positive numeric values.
+
+        Function edge_subst_cost overrides edge_match if specified.
+        If neither edge_match nor edge_subst_cost are specified then
+        default edge substitution cost of 0 is used (edge attributes
+        are not considered during matching).
+
+        If edge_del_cost is not specified then default edge deletion
+        cost of 1 is used.  If edge_ins_cost is not specified then
+        default edge insertion cost of 1 is used.
+
+    upper_bound : numeric
+        Maximum edit distance to consider.
+
+    Returns
+    -------
+    edit_paths : list of tuples (node_edit_path, edge_edit_path)
+        node_edit_path : list of tuples (u, v)
+        edge_edit_path : list of tuples ((u1, v1), (u2, v2))
+
+    cost : numeric
+        Optimal edit path cost (graph edit distance).
+
+    Examples
+    --------
+    >>> G1 = nx.cycle_graph(4)
+    >>> G2 = nx.wheel_graph(5)
+    >>> paths, cost = nx.optimal_edit_paths(G1, G2)
+    >>> len(paths)
+    40
+    >>> cost
+    5.0
+
+    See Also
+    --------
+    graph_edit_distance, optimize_edit_paths
+
+    References
+    ----------
+    .. [1] Zeina Abu-Aisheh, Romain Raveaux, Jean-Yves Ramel, Patrick
+       Martineau. An Exact Graph Edit Distance Algorithm for Solving
+       Pattern Recognition Problems. 4th International Conference on
+       Pattern Recognition Applications and Methods 2015, Jan 2015,
+       Lisbon, Portugal. 2015,
+       <10.5220/0005209202710278>. <hal-01168816>
+       https://hal.archives-ouvertes.fr/hal-01168816
+
+    """
+    paths = list()
+    bestcost = None
+    for vertex_path, edge_path, cost in optimize_edit_paths(
+        G1,
+        G2,
+        node_match,
+        edge_match,
+        node_subst_cost,
+        node_del_cost,
+        node_ins_cost,
+        edge_subst_cost,
+        edge_del_cost,
+        edge_ins_cost,
+        upper_bound,
+        False,
+    ):
+        # assert bestcost is None or cost <= bestcost
+        if bestcost is not None and cost < bestcost:
+            paths = list()
+        paths.append((vertex_path, edge_path))
+        bestcost = cost
+    return paths, bestcost
+
+
+def optimize_graph_edit_distance(
+    G1,
+    G2,
+    node_match=None,
+    edge_match=None,
+    node_subst_cost=None,
+    node_del_cost=None,
+    node_ins_cost=None,
+    edge_subst_cost=None,
+    edge_del_cost=None,
+    edge_ins_cost=None,
+    upper_bound=None,
+):
+    """Returns consecutive approximations of GED (graph edit distance)
+    between graphs G1 and G2.
+
+    Graph edit distance is a graph similarity measure analogous to
+    Levenshtein distance for strings.  It is defined as minimum cost
+    of edit path (sequence of node and edge edit operations)
+    transforming graph G1 to graph isomorphic to G2.
+
+    Parameters
+    ----------
+    G1, G2: graphs
+        The two graphs G1 and G2 must be of the same type.
+
+    node_match : callable
+        A function that returns True if node n1 in G1 and n2 in G2
+        should be considered equal during matching.
+
+        The function will be called like
+
+           node_match(G1.nodes[n1], G2.nodes[n2]).
+
+        That is, the function will receive the node attribute
+        dictionaries for n1 and n2 as inputs.
+
+        Ignored if node_subst_cost is specified.  If neither
+        node_match nor node_subst_cost are specified then node
+        attributes are not considered.
+
+    edge_match : callable
+        A function that returns True if the edge attribute dictionaries
+        for the pair of nodes (u1, v1) in G1 and (u2, v2) in G2 should
+        be considered equal during matching.
+
+        The function will be called like
+
+           edge_match(G1[u1][v1], G2[u2][v2]).
+
+        That is, the function will receive the edge attribute
+        dictionaries of the edges under consideration.
+
+        Ignored if edge_subst_cost is specified.  If neither
+        edge_match nor edge_subst_cost are specified then edge
+        attributes are not considered.
+
+    node_subst_cost, node_del_cost, node_ins_cost : callable
+        Functions that return the costs of node substitution, node
+        deletion, and node insertion, respectively.
+
+        The functions will be called like
+
+           node_subst_cost(G1.nodes[n1], G2.nodes[n2]),
+           node_del_cost(G1.nodes[n1]),
+           node_ins_cost(G2.nodes[n2]).
+
+        That is, the functions will receive the node attribute
+        dictionaries as inputs.  The functions are expected to return
+        positive numeric values.
+
+        Function node_subst_cost overrides node_match if specified.
+        If neither node_match nor node_subst_cost are specified then
+        default node substitution cost of 0 is used (node attributes
+        are not considered during matching).
+
+        If node_del_cost is not specified then default node deletion
+        cost of 1 is used.  If node_ins_cost is not specified then
+        default node insertion cost of 1 is used.
+
+    edge_subst_cost, edge_del_cost, edge_ins_cost : callable
+        Functions that return the costs of edge substitution, edge
+        deletion, and edge insertion, respectively.
+
+        The functions will be called like
+
+           edge_subst_cost(G1[u1][v1], G2[u2][v2]),
+           edge_del_cost(G1[u1][v1]),
+           edge_ins_cost(G2[u2][v2]).
+
+        That is, the functions will receive the edge attribute
+        dictionaries as inputs.  The functions are expected to return
+        positive numeric values.
+
+        Function edge_subst_cost overrides edge_match if specified.
+        If neither edge_match nor edge_subst_cost are specified then
+        default edge substitution cost of 0 is used (edge attributes
+        are not considered during matching).
+
+        If edge_del_cost is not specified then default edge deletion
+        cost of 1 is used.  If edge_ins_cost is not specified then
+        default edge insertion cost of 1 is used.
+
+    upper_bound : numeric
+        Maximum edit distance to consider.
+
+    Returns
+    -------
+    Generator of consecutive approximations of graph edit distance.
+
+    Examples
+    --------
+    >>> G1 = nx.cycle_graph(6)
+    >>> G2 = nx.wheel_graph(7)
+    >>> for v in nx.optimize_graph_edit_distance(G1, G2):
+    ...     minv = v
+    >>> minv
+    7.0
+
+    See Also
+    --------
+    graph_edit_distance, optimize_edit_paths
+
+    References
+    ----------
+    .. [1] Zeina Abu-Aisheh, Romain Raveaux, Jean-Yves Ramel, Patrick
+       Martineau. An Exact Graph Edit Distance Algorithm for Solving
+       Pattern Recognition Problems. 4th International Conference on
+       Pattern Recognition Applications and Methods 2015, Jan 2015,
+       Lisbon, Portugal. 2015,
+       <10.5220/0005209202710278>. <hal-01168816>
+       https://hal.archives-ouvertes.fr/hal-01168816
+    """
+    for vertex_path, edge_path, cost in optimize_edit_paths(
+        G1,
+        G2,
+        node_match,
+        edge_match,
+        node_subst_cost,
+        node_del_cost,
+        node_ins_cost,
+        edge_subst_cost,
+        edge_del_cost,
+        edge_ins_cost,
+        upper_bound,
+        True,
+    ):
+        yield cost
+
+
+def optimize_edit_paths(
+    G1,
+    G2,
+    node_match=None,
+    edge_match=None,
+    node_subst_cost=None,
+    node_del_cost=None,
+    node_ins_cost=None,
+    edge_subst_cost=None,
+    edge_del_cost=None,
+    edge_ins_cost=None,
+    upper_bound=None,
+    strictly_decreasing=True,
+    roots=None,
+    timeout=None,
+):
+    """GED (graph edit distance) calculation: advanced interface.
+
+    Graph edit path is a sequence of node and edge edit operations
+    transforming graph G1 to graph isomorphic to G2.  Edit operations
+    include substitutions, deletions, and insertions.
+
+    Graph edit distance is defined as minimum cost of edit path.
+
+    Parameters
+    ----------
+    G1, G2: graphs
+        The two graphs G1 and G2 must be of the same type.
+
+    node_match : callable
+        A function that returns True if node n1 in G1 and n2 in G2
+        should be considered equal during matching.
+
+        The function will be called like
+
+           node_match(G1.nodes[n1], G2.nodes[n2]).
+
+        That is, the function will receive the node attribute
+        dictionaries for n1 and n2 as inputs.
+
+        Ignored if node_subst_cost is specified.  If neither
+        node_match nor node_subst_cost are specified then node
+        attributes are not considered.
+
+    edge_match : callable
+        A function that returns True if the edge attribute dictionaries
+        for the pair of nodes (u1, v1) in G1 and (u2, v2) in G2 should
+        be considered equal during matching.
+
+        The function will be called like
+
+           edge_match(G1[u1][v1], G2[u2][v2]).
+
+        That is, the function will receive the edge attribute
+        dictionaries of the edges under consideration.
+
+        Ignored if edge_subst_cost is specified.  If neither
+        edge_match nor edge_subst_cost are specified then edge
+        attributes are not considered.
+
+    node_subst_cost, node_del_cost, node_ins_cost : callable
+        Functions that return the costs of node substitution, node
+        deletion, and node insertion, respectively.
+
+        The functions will be called like
+
+           node_subst_cost(G1.nodes[n1], G2.nodes[n2]),
+           node_del_cost(G1.nodes[n1]),
+           node_ins_cost(G2.nodes[n2]).
+
+        That is, the functions will receive the node attribute
+        dictionaries as inputs.  The functions are expected to return
+        positive numeric values.
+
+        Function node_subst_cost overrides node_match if specified.
+        If neither node_match nor node_subst_cost are specified then
+        default node substitution cost of 0 is used (node attributes
+        are not considered during matching).
+
+        If node_del_cost is not specified then default node deletion
+        cost of 1 is used.  If node_ins_cost is not specified then
+        default node insertion cost of 1 is used.
+
+    edge_subst_cost, edge_del_cost, edge_ins_cost : callable
+        Functions that return the costs of edge substitution, edge
+        deletion, and edge insertion, respectively.
+
+        The functions will be called like
+
+           edge_subst_cost(G1[u1][v1], G2[u2][v2]),
+           edge_del_cost(G1[u1][v1]),
+           edge_ins_cost(G2[u2][v2]).
+
+        That is, the functions will receive the edge attribute
+        dictionaries as inputs.  The functions are expected to return
+        positive numeric values.
+
+        Function edge_subst_cost overrides edge_match if specified.
+        If neither edge_match nor edge_subst_cost are specified then
+        default edge substitution cost of 0 is used (edge attributes
+        are not considered during matching).
+
+        If edge_del_cost is not specified then default edge deletion
+        cost of 1 is used.  If edge_ins_cost is not specified then
+        default edge insertion cost of 1 is used.
+
+    upper_bound : numeric
+        Maximum edit distance to consider.
+
+    strictly_decreasing : bool
+        If True, return consecutive approximations of strictly
+        decreasing cost.  Otherwise, return all edit paths of cost
+        less than or equal to the previous minimum cost.
+
+    roots : 2-tuple
+        Tuple where first element is a node in G1 and the second
+        is a node in G2.
+        These nodes are forced to be matched in the comparison to
+        allow comparison between rooted graphs.
+
+    timeout : numeric
+        Maximum number of seconds to execute.
+        After timeout is met, the current best GED is returned.
+
+    Returns
+    -------
+    Generator of tuples (node_edit_path, edge_edit_path, cost)
+        node_edit_path : list of tuples (u, v)
+        edge_edit_path : list of tuples ((u1, v1), (u2, v2))
+        cost : numeric
+
+    See Also
+    --------
+    graph_edit_distance, optimize_graph_edit_distance, optimal_edit_paths
+
+    References
+    ----------
+    .. [1] Zeina Abu-Aisheh, Romain Raveaux, Jean-Yves Ramel, Patrick
+       Martineau. An Exact Graph Edit Distance Algorithm for Solving
+       Pattern Recognition Problems. 4th International Conference on
+       Pattern Recognition Applications and Methods 2015, Jan 2015,
+       Lisbon, Portugal. 2015,
+       <10.5220/0005209202710278>. <hal-01168816>
+       https://hal.archives-ouvertes.fr/hal-01168816
+
+    """
+    # TODO: support DiGraph
+
+    import numpy as np
+    import scipy as sp
+    import scipy.optimize  # call as sp.optimize
+
+    class CostMatrix:
+        def __init__(self, C, lsa_row_ind, lsa_col_ind, ls):
+            # assert C.shape[0] == len(lsa_row_ind)
+            # assert C.shape[1] == len(lsa_col_ind)
+            # assert len(lsa_row_ind) == len(lsa_col_ind)
+            # assert set(lsa_row_ind) == set(range(len(lsa_row_ind)))
+            # assert set(lsa_col_ind) == set(range(len(lsa_col_ind)))
+            # assert ls == C[lsa_row_ind, lsa_col_ind].sum()
+            self.C = C
+            self.lsa_row_ind = lsa_row_ind
+            self.lsa_col_ind = lsa_col_ind
+            self.ls = ls
+
+    def make_CostMatrix(C, m, n):
+        # assert(C.shape == (m + n, m + n))
+        lsa_row_ind, lsa_col_ind = sp.optimize.linear_sum_assignment(C)
+
+        # Fixup dummy assignments:
+        # each substitution i<->j should have dummy assignment m+j<->n+i
+        # NOTE: fast reduce of Cv relies on it
+        # assert len(lsa_row_ind) == len(lsa_col_ind)
+        indexes = zip(range(len(lsa_row_ind)), lsa_row_ind, lsa_col_ind)
+        subst_ind = list(k for k, i, j in indexes if i < m and j < n)
+        indexes = zip(range(len(lsa_row_ind)), lsa_row_ind, lsa_col_ind)
+        dummy_ind = list(k for k, i, j in indexes if i >= m and j >= n)
+        # assert len(subst_ind) == len(dummy_ind)
+        lsa_row_ind[dummy_ind] = lsa_col_ind[subst_ind] + m
+        lsa_col_ind[dummy_ind] = lsa_row_ind[subst_ind] + n
+
+        return CostMatrix(
+            C, lsa_row_ind, lsa_col_ind, C[lsa_row_ind, lsa_col_ind].sum()
+        )
+
+    def extract_C(C, i, j, m, n):
+        # assert(C.shape == (m + n, m + n))
+        row_ind = [k in i or k - m in j for k in range(m + n)]
+        col_ind = [k in j or k - n in i for k in range(m + n)]
+        return C[row_ind, :][:, col_ind]
+
+    def reduce_C(C, i, j, m, n):
+        # assert(C.shape == (m + n, m + n))
+        row_ind = [k not in i and k - m not in j for k in range(m + n)]
+        col_ind = [k not in j and k - n not in i for k in range(m + n)]
+        return C[row_ind, :][:, col_ind]
+
+    def reduce_ind(ind, i):
+        # assert set(ind) == set(range(len(ind)))
+        rind = ind[[k not in i for k in ind]]
+        for k in set(i):
+            rind[rind >= k] -= 1
+        return rind
+
+    def match_edges(u, v, pending_g, pending_h, Ce, matched_uv=[]):
+        """
+        Parameters:
+            u, v: matched vertices, u=None or v=None for
+               deletion/insertion
+            pending_g, pending_h: lists of edges not yet mapped
+            Ce: CostMatrix of pending edge mappings
+            matched_uv: partial vertex edit path
+                list of tuples (u, v) of previously matched vertex
+                    mappings u<->v, u=None or v=None for
+                    deletion/insertion
+
+        Returns:
+            list of (i, j): indices of edge mappings g<->h
+            localCe: local CostMatrix of edge mappings
+                (basically submatrix of Ce at cross of rows i, cols j)
+        """
+        M = len(pending_g)
+        N = len(pending_h)
+        # assert Ce.C.shape == (M + N, M + N)
+
+        # only attempt to match edges after one node match has been made
+        # this will stop self-edges on the first node being automatically deleted
+        # even when a substitution is the better option
+        if matched_uv:
+            g_ind = [
+                i
+                for i in range(M)
+                if pending_g[i][:2] == (u, u)
+                or any(
+                    pending_g[i][:2] in ((p, u), (u, p), (p, p)) for p, q in matched_uv
+                )
+            ]
+            h_ind = [
+                j
+                for j in range(N)
+                if pending_h[j][:2] == (v, v)
+                or any(
+                    pending_h[j][:2] in ((q, v), (v, q), (q, q)) for p, q in matched_uv
+                )
+            ]
+        else:
+            g_ind = []
+            h_ind = []
+
+        m = len(g_ind)
+        n = len(h_ind)
+
+        if m or n:
+            C = extract_C(Ce.C, g_ind, h_ind, M, N)
+            # assert C.shape == (m + n, m + n)
+
+            # Forbid structurally invalid matches
+            # NOTE: inf remembered from Ce construction
+            for k, i in zip(range(m), g_ind):
+                g = pending_g[i][:2]
+                for l, j in zip(range(n), h_ind):
+                    h = pending_h[j][:2]
+                    if nx.is_directed(G1) or nx.is_directed(G2):
+                        if any(
+                            g == (p, u) and h == (q, v) or g == (u, p) and h == (v, q)
+                            for p, q in matched_uv
+                        ):
+                            continue
+                    else:
+                        if any(
+                            g in ((p, u), (u, p)) and h in ((q, v), (v, q))
+                            for p, q in matched_uv
+                        ):
+                            continue
+                    if g == (u, u) or any(g == (p, p) for p, q in matched_uv):
+                        continue
+                    if h == (v, v) or any(h == (q, q) for p, q in matched_uv):
+                        continue
+                    C[k, l] = inf
+
+            localCe = make_CostMatrix(C, m, n)
+            ij = list(
+                (
+                    g_ind[k] if k < m else M + h_ind[l],
+                    h_ind[l] if l < n else N + g_ind[k],
+                )
+                for k, l in zip(localCe.lsa_row_ind, localCe.lsa_col_ind)
+                if k < m or l < n
+            )
+
+        else:
+            ij = []
+            localCe = CostMatrix(np.empty((0, 0)), [], [], 0)
+
+        return ij, localCe
+
+    def reduce_Ce(Ce, ij, m, n):
+        if len(ij):
+            i, j = zip(*ij)
+            m_i = m - sum(1 for t in i if t < m)
+            n_j = n - sum(1 for t in j if t < n)
+            return make_CostMatrix(reduce_C(Ce.C, i, j, m, n), m_i, n_j)
+        else:
+            return Ce
+
+    def get_edit_ops(
+        matched_uv, pending_u, pending_v, Cv, pending_g, pending_h, Ce, matched_cost
+    ):
+        """
+        Parameters:
+            matched_uv: partial vertex edit path
+                list of tuples (u, v) of vertex mappings u<->v,
+                u=None or v=None for deletion/insertion
+            pending_u, pending_v: lists of vertices not yet mapped
+            Cv: CostMatrix of pending vertex mappings
+            pending_g, pending_h: lists of edges not yet mapped
+            Ce: CostMatrix of pending edge mappings
+            matched_cost: cost of partial edit path
+
+        Returns:
+            sequence of
+                (i, j): indices of vertex mapping u<->v
+                Cv_ij: reduced CostMatrix of pending vertex mappings
+                    (basically Cv with row i, col j removed)
+                list of (x, y): indices of edge mappings g<->h
+                Ce_xy: reduced CostMatrix of pending edge mappings
+                    (basically Ce with rows x, cols y removed)
+                cost: total cost of edit operation
+            NOTE: most promising ops first
+        """
+        m = len(pending_u)
+        n = len(pending_v)
+        # assert Cv.C.shape == (m + n, m + n)
+
+        # 1) a vertex mapping from optimal linear sum assignment
+        i, j = min(
+            (k, l) for k, l in zip(Cv.lsa_row_ind, Cv.lsa_col_ind) if k < m or l < n
+        )
+        xy, localCe = match_edges(
+            pending_u[i] if i < m else None,
+            pending_v[j] if j < n else None,
+            pending_g,
+            pending_h,
+            Ce,
+            matched_uv,
+        )
+        Ce_xy = reduce_Ce(Ce, xy, len(pending_g), len(pending_h))
+        # assert Ce.ls <= localCe.ls + Ce_xy.ls
+        if prune(matched_cost + Cv.ls + localCe.ls + Ce_xy.ls):
+            pass
+        else:
+            # get reduced Cv efficiently
+            Cv_ij = CostMatrix(
+                reduce_C(Cv.C, (i,), (j,), m, n),
+                reduce_ind(Cv.lsa_row_ind, (i, m + j)),
+                reduce_ind(Cv.lsa_col_ind, (j, n + i)),
+                Cv.ls - Cv.C[i, j],
+            )
+            yield (i, j), Cv_ij, xy, Ce_xy, Cv.C[i, j] + localCe.ls
+
+        # 2) other candidates, sorted by lower-bound cost estimate
+        other = list()
+        fixed_i, fixed_j = i, j
+        if m <= n:
+            candidates = (
+                (t, fixed_j)
+                for t in range(m + n)
+                if t != fixed_i and (t < m or t == m + fixed_j)
+            )
+        else:
+            candidates = (
+                (fixed_i, t)
+                for t in range(m + n)
+                if t != fixed_j and (t < n or t == n + fixed_i)
+            )
+        for i, j in candidates:
+            if prune(matched_cost + Cv.C[i, j] + Ce.ls):
+                continue
+            Cv_ij = make_CostMatrix(
+                reduce_C(Cv.C, (i,), (j,), m, n),
+                m - 1 if i < m else m,
+                n - 1 if j < n else n,
+            )
+            # assert Cv.ls <= Cv.C[i, j] + Cv_ij.ls
+            if prune(matched_cost + Cv.C[i, j] + Cv_ij.ls + Ce.ls):
+                continue
+            xy, localCe = match_edges(
+                pending_u[i] if i < m else None,
+                pending_v[j] if j < n else None,
+                pending_g,
+                pending_h,
+                Ce,
+                matched_uv,
+            )
+            if prune(matched_cost + Cv.C[i, j] + Cv_ij.ls + localCe.ls):
+                continue
+            Ce_xy = reduce_Ce(Ce, xy, len(pending_g), len(pending_h))
+            # assert Ce.ls <= localCe.ls + Ce_xy.ls
+            if prune(matched_cost + Cv.C[i, j] + Cv_ij.ls + localCe.ls + Ce_xy.ls):
+                continue
+            other.append(((i, j), Cv_ij, xy, Ce_xy, Cv.C[i, j] + localCe.ls))
+
+        yield from sorted(other, key=lambda t: t[4] + t[1].ls + t[3].ls)
+
+    def get_edit_paths(
+        matched_uv,
+        pending_u,
+        pending_v,
+        Cv,
+        matched_gh,
+        pending_g,
+        pending_h,
+        Ce,
+        matched_cost,
+    ):
+        """
+        Parameters:
+            matched_uv: partial vertex edit path
+                list of tuples (u, v) of vertex mappings u<->v,
+                u=None or v=None for deletion/insertion
+            pending_u, pending_v: lists of vertices not yet mapped
+            Cv: CostMatrix of pending vertex mappings
+            matched_gh: partial edge edit path
+                list of tuples (g, h) of edge mappings g<->h,
+                g=None or h=None for deletion/insertion
+            pending_g, pending_h: lists of edges not yet mapped
+            Ce: CostMatrix of pending edge mappings
+            matched_cost: cost of partial edit path
+
+        Returns:
+            sequence of (vertex_path, edge_path, cost)
+                vertex_path: complete vertex edit path
+                    list of tuples (u, v) of vertex mappings u<->v,
+                    u=None or v=None for deletion/insertion
+                edge_path: complete edge edit path
+                    list of tuples (g, h) of edge mappings g<->h,
+                    g=None or h=None for deletion/insertion
+                cost: total cost of edit path
+            NOTE: path costs are non-increasing
+        """
+        # debug_print('matched-uv:', matched_uv)
+        # debug_print('matched-gh:', matched_gh)
+        # debug_print('matched-cost:', matched_cost)
+        # debug_print('pending-u:', pending_u)
+        # debug_print('pending-v:', pending_v)
+        # debug_print(Cv.C)
+        # assert list(sorted(G1.nodes)) == list(sorted(list(u for u, v in matched_uv if u is not None) + pending_u))
+        # assert list(sorted(G2.nodes)) == list(sorted(list(v for u, v in matched_uv if v is not None) + pending_v))
+        # debug_print('pending-g:', pending_g)
+        # debug_print('pending-h:', pending_h)
+        # debug_print(Ce.C)
+        # assert list(sorted(G1.edges)) == list(sorted(list(g for g, h in matched_gh if g is not None) + pending_g))
+        # assert list(sorted(G2.edges)) == list(sorted(list(h for g, h in matched_gh if h is not None) + pending_h))
+        # debug_print()
+
+        if prune(matched_cost + Cv.ls + Ce.ls):
+            return
+
+        if not max(len(pending_u), len(pending_v)):
+            # assert not len(pending_g)
+            # assert not len(pending_h)
+            # path completed!
+            # assert matched_cost <= maxcost.value
+            maxcost.value = min(maxcost.value, matched_cost)
+            yield matched_uv, matched_gh, matched_cost
+
+        else:
+            edit_ops = get_edit_ops(
+                matched_uv,
+                pending_u,
+                pending_v,
+                Cv,
+                pending_g,
+                pending_h,
+                Ce,
+                matched_cost,
+            )
+            for ij, Cv_ij, xy, Ce_xy, edit_cost in edit_ops:
+                i, j = ij
+                # assert Cv.C[i, j] + sum(Ce.C[t] for t in xy) == edit_cost
+                if prune(matched_cost + edit_cost + Cv_ij.ls + Ce_xy.ls):
+                    continue
+
+                # dive deeper
+                u = pending_u.pop(i) if i < len(pending_u) else None
+                v = pending_v.pop(j) if j < len(pending_v) else None
+                matched_uv.append((u, v))
+                for x, y in xy:
+                    len_g = len(pending_g)
+                    len_h = len(pending_h)
+                    matched_gh.append(
+                        (
+                            pending_g[x] if x < len_g else None,
+                            pending_h[y] if y < len_h else None,
+                        )
+                    )
+                sortedx = list(sorted(x for x, y in xy))
+                sortedy = list(sorted(y for x, y in xy))
+                G = list(
+                    (pending_g.pop(x) if x < len(pending_g) else None)
+                    for x in reversed(sortedx)
+                )
+                H = list(
+                    (pending_h.pop(y) if y < len(pending_h) else None)
+                    for y in reversed(sortedy)
+                )
+
+                yield from get_edit_paths(
+                    matched_uv,
+                    pending_u,
+                    pending_v,
+                    Cv_ij,
+                    matched_gh,
+                    pending_g,
+                    pending_h,
+                    Ce_xy,
+                    matched_cost + edit_cost,
+                )
+
+                # backtrack
+                if u is not None:
+                    pending_u.insert(i, u)
+                if v is not None:
+                    pending_v.insert(j, v)
+                matched_uv.pop()
+                for x, g in zip(sortedx, reversed(G)):
+                    if g is not None:
+                        pending_g.insert(x, g)
+                for y, h in zip(sortedy, reversed(H)):
+                    if h is not None:
+                        pending_h.insert(y, h)
+                for t in xy:
+                    matched_gh.pop()
+
+    # Initialization
+
+    pending_u = list(G1.nodes)
+    pending_v = list(G2.nodes)
+
+    initial_cost = 0
+    if roots:
+        root_u, root_v = roots
+        if root_u not in pending_u or root_v not in pending_v:
+            raise nx.NodeNotFound("Root node not in graph.")
+
+        # remove roots from pending
+        pending_u.remove(root_u)
+        pending_v.remove(root_v)
+
+    # cost matrix of vertex mappings
+    m = len(pending_u)
+    n = len(pending_v)
+    C = np.zeros((m + n, m + n))
+    if node_subst_cost:
+        C[0:m, 0:n] = np.array(
+            [
+                node_subst_cost(G1.nodes[u], G2.nodes[v])
+                for u in pending_u
+                for v in pending_v
+            ]
+        ).reshape(m, n)
+        if roots:
+            initial_cost = node_subst_cost(G1.nodes[root_u], G2.nodes[root_v])
+    elif node_match:
+        C[0:m, 0:n] = np.array(
+            [
+                1 - int(node_match(G1.nodes[u], G2.nodes[v]))
+                for u in pending_u
+                for v in pending_v
+            ]
+        ).reshape(m, n)
+        if roots:
+            initial_cost = 1 - node_match(G1.nodes[root_u], G2.nodes[root_v])
+    else:
+        # all zeroes
+        pass
+    # assert not min(m, n) or C[0:m, 0:n].min() >= 0
+    if node_del_cost:
+        del_costs = [node_del_cost(G1.nodes[u]) for u in pending_u]
+    else:
+        del_costs = [1] * len(pending_u)
+    # assert not m or min(del_costs) >= 0
+    if node_ins_cost:
+        ins_costs = [node_ins_cost(G2.nodes[v]) for v in pending_v]
+    else:
+        ins_costs = [1] * len(pending_v)
+    # assert not n or min(ins_costs) >= 0
+    inf = C[0:m, 0:n].sum() + sum(del_costs) + sum(ins_costs) + 1
+    C[0:m, n : n + m] = np.array(
+        [del_costs[i] if i == j else inf for i in range(m) for j in range(m)]
+    ).reshape(m, m)
+    C[m : m + n, 0:n] = np.array(
+        [ins_costs[i] if i == j else inf for i in range(n) for j in range(n)]
+    ).reshape(n, n)
+    Cv = make_CostMatrix(C, m, n)
+    # debug_print(f"Cv: {m} x {n}")
+    # debug_print(Cv.C)
+
+    pending_g = list(G1.edges)
+    pending_h = list(G2.edges)
+
+    # cost matrix of edge mappings
+    m = len(pending_g)
+    n = len(pending_h)
+    C = np.zeros((m + n, m + n))
+    if edge_subst_cost:
+        C[0:m, 0:n] = np.array(
+            [
+                edge_subst_cost(G1.edges[g], G2.edges[h])
+                for g in pending_g
+                for h in pending_h
+            ]
+        ).reshape(m, n)
+    elif edge_match:
+        C[0:m, 0:n] = np.array(
+            [
+                1 - int(edge_match(G1.edges[g], G2.edges[h]))
+                for g in pending_g
+                for h in pending_h
+            ]
+        ).reshape(m, n)
+    else:
+        # all zeroes
+        pass
+    # assert not min(m, n) or C[0:m, 0:n].min() >= 0
+    if edge_del_cost:
+        del_costs = [edge_del_cost(G1.edges[g]) for g in pending_g]
+    else:
+        del_costs = [1] * len(pending_g)
+    # assert not m or min(del_costs) >= 0
+    if edge_ins_cost:
+        ins_costs = [edge_ins_cost(G2.edges[h]) for h in pending_h]
+    else:
+        ins_costs = [1] * len(pending_h)
+    # assert not n or min(ins_costs) >= 0
+    inf = C[0:m, 0:n].sum() + sum(del_costs) + sum(ins_costs) + 1
+    C[0:m, n : n + m] = np.array(
+        [del_costs[i] if i == j else inf for i in range(m) for j in range(m)]
+    ).reshape(m, m)
+    C[m : m + n, 0:n] = np.array(
+        [ins_costs[i] if i == j else inf for i in range(n) for j in range(n)]
+    ).reshape(n, n)
+    Ce = make_CostMatrix(C, m, n)
+    # debug_print(f'Ce: {m} x {n}')
+    # debug_print(Ce.C)
+    # debug_print()
+
+    class MaxCost:
+        def __init__(self):
+            # initial upper-bound estimate
+            # NOTE: should work for empty graph
+            self.value = Cv.C.sum() + Ce.C.sum() + 1
+
+    maxcost = MaxCost()
+
+    if timeout is not None:
+        if timeout <= 0:
+            raise nx.NetworkXError("Timeout value must be greater than 0")
+        start = time.perf_counter()
+
+    def prune(cost):
+        if timeout is not None:
+            if time.perf_counter() - start > timeout:
+                return True
+        if upper_bound is not None:
+            if cost > upper_bound:
+                return True
+        if cost > maxcost.value:
+            return True
+        elif strictly_decreasing and cost >= maxcost.value:
+            return True
+
+    # Now go!
+
+    done_uv = [] if roots is None else [roots]
+
+    for vertex_path, edge_path, cost in get_edit_paths(
+        done_uv, pending_u, pending_v, Cv, [], pending_g, pending_h, Ce, initial_cost
+    ):
+        # assert sorted(G1.nodes) == sorted(u for u, v in vertex_path if u is not None)
+        # assert sorted(G2.nodes) == sorted(v for u, v in vertex_path if v is not None)
+        # assert sorted(G1.edges) == sorted(g for g, h in edge_path if g is not None)
+        # assert sorted(G2.edges) == sorted(h for g, h in edge_path if h is not None)
+        # print(vertex_path, edge_path, cost, file = sys.stderr)
+        # assert cost == maxcost.value
+        yield list(vertex_path), list(edge_path), cost
+
+
+def simrank_similarity(
+    G,
+    source=None,
+    target=None,
+    importance_factor=0.9,
+    max_iterations=1000,
+    tolerance=1e-4,
+):
+    """Returns the SimRank similarity of nodes in the graph ``G``.
+
+    SimRank is a similarity metric that says "two objects are considered
+    to be similar if they are referenced by similar objects." [1]_.
+
+    The pseudo-code definition from the paper is::
+
+        def simrank(G, u, v):
+            in_neighbors_u = G.predecessors(u)
+            in_neighbors_v = G.predecessors(v)
+            scale = C / (len(in_neighbors_u) * len(in_neighbors_v))
+            return scale * sum(simrank(G, w, x)
+                               for w, x in product(in_neighbors_u,
+                                                   in_neighbors_v))
+
+    where ``G`` is the graph, ``u`` is the source, ``v`` is the target,
+    and ``C`` is a float decay or importance factor between 0 and 1.
+
+    The SimRank algorithm for determining node similarity is defined in
+    [2]_.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A NetworkX graph
+
+    source : node
+        If this is specified, the returned dictionary maps each node
+        ``v`` in the graph to the similarity between ``source`` and
+        ``v``.
+
+    target : node
+        If both ``source`` and ``target`` are specified, the similarity
+        value between ``source`` and ``target`` is returned. If
+        ``target`` is specified but ``source`` is not, this argument is
+        ignored.
+
+    importance_factor : float
+        The relative importance of indirect neighbors with respect to
+        direct neighbors.
+
+    max_iterations : integer
+        Maximum number of iterations.
+
+    tolerance : float
+        Error tolerance used to check convergence. When an iteration of
+        the algorithm finds that no similarity value changes more than
+        this amount, the algorithm halts.
+
+    Returns
+    -------
+    similarity : dictionary or float
+        If ``source`` and ``target`` are both ``None``, this returns a
+        dictionary of dictionaries, where keys are node pairs and value
+        are similarity of the pair of nodes.
+
+        If ``source`` is not ``None`` but ``target`` is, this returns a
+        dictionary mapping node to the similarity of ``source`` and that
+        node.
+
+        If neither ``source`` nor ``target`` is ``None``, this returns
+        the similarity value for the given pair of nodes.
+
+    Examples
+    --------
+    >>> G = nx.cycle_graph(2)
+    >>> nx.simrank_similarity(G)
+    {0: {0: 1.0, 1: 0.0}, 1: {0: 0.0, 1: 1.0}}
+    >>> nx.simrank_similarity(G, source=0)
+    {0: 1.0, 1: 0.0}
+    >>> nx.simrank_similarity(G, source=0, target=0)
+    1.0
+
+    The result of this function can be converted to a numpy array
+    representing the SimRank matrix by using the node order of the
+    graph to determine which row and column represent each node.
+    Other ordering of nodes is also possible.
+
+    >>> import numpy as np
+    >>> sim = nx.simrank_similarity(G)
+    >>> np.array([[sim[u][v] for v in G] for u in G])
+    array([[1., 0.],
+           [0., 1.]])
+    >>> sim_1d = nx.simrank_similarity(G, source=0)
+    >>> np.array([sim[0][v] for v in G])
+    array([1., 0.])
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/SimRank
+    .. [2] G. Jeh and J. Widom.
+           "SimRank: a measure of structural-context similarity",
+           In KDD'02: Proceedings of the Eighth ACM SIGKDD
+           International Conference on Knowledge Discovery and Data Mining,
+           pp. 538--543. ACM Press, 2002.
+    """
+    import numpy as np
+
+    nodelist = list(G)
+    s_indx = None if source is None else nodelist.index(source)
+    t_indx = None if target is None else nodelist.index(target)
+
+    x = _simrank_similarity_numpy(
+        G, s_indx, t_indx, importance_factor, max_iterations, tolerance
+    )
+
+    if isinstance(x, np.ndarray):
+        if x.ndim == 1:
+            return {node: val for node, val in zip(G, x)}
+        else:  # x.ndim == 2:
+            return {u: dict(zip(G, row)) for u, row in zip(G, x)}
+    return x
+
+
+def _simrank_similarity_python(
+    G,
+    source=None,
+    target=None,
+    importance_factor=0.9,
+    max_iterations=1000,
+    tolerance=1e-4,
+):
+    """Returns the SimRank similarity of nodes in the graph ``G``.
+
+    This pure Python version is provided for pedagogical purposes.
+
+    Examples
+    --------
+    >>> G = nx.cycle_graph(2)
+    >>> nx.similarity._simrank_similarity_python(G)
+    {0: {0: 1, 1: 0.0}, 1: {0: 0.0, 1: 1}}
+    >>> nx.similarity._simrank_similarity_python(G, source=0)
+    {0: 1, 1: 0.0}
+    >>> nx.similarity._simrank_similarity_python(G, source=0, target=0)
+    1
+    """
+    # build up our similarity adjacency dictionary output
+    newsim = {u: {v: 1 if u == v else 0 for v in G} for u in G}
+
+    # These functions compute the update to the similarity value of the nodes
+    # `u` and `v` with respect to the previous similarity values.
+    def avg_sim(s):
+        return sum(newsim[w][x] for (w, x) in s) / len(s) if s else 0.0
+
+    Gadj = G.pred if G.is_directed() else G.adj
+
+    def sim(u, v):
+        return importance_factor * avg_sim(list(product(Gadj[u], Gadj[v])))
+
+    for its in range(max_iterations):
+        oldsim = newsim
+        newsim = {u: {v: sim(u, v) if u is not v else 1 for v in G} for u in G}
+        is_close = all(
+            all(
+                abs(newsim[u][v] - old) <= tolerance * (1 + abs(old))
+                for v, old in nbrs.items()
+            )
+            for u, nbrs in oldsim.items()
+        )
+        if is_close:
+            break
+
+    if its + 1 == max_iterations:
+        raise nx.ExceededMaxIterations(
+            f"simrank did not converge after {max_iterations} iterations."
+        )
+
+    if source is not None and target is not None:
+        return newsim[source][target]
+    if source is not None:
+        return newsim[source]
+    return newsim
+
+
+def _simrank_similarity_numpy(
+    G,
+    source=None,
+    target=None,
+    importance_factor=0.9,
+    max_iterations=1000,
+    tolerance=1e-4,
+):
+    """Calculate SimRank of nodes in ``G`` using matrices with ``numpy``.
+
+    The SimRank algorithm for determining node similarity is defined in
+    [1]_.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A NetworkX graph
+
+    source : node
+        If this is specified, the returned dictionary maps each node
+        ``v`` in the graph to the similarity between ``source`` and
+        ``v``.
+
+    target : node
+        If both ``source`` and ``target`` are specified, the similarity
+        value between ``source`` and ``target`` is returned. If
+        ``target`` is specified but ``source`` is not, this argument is
+        ignored.
+
+    importance_factor : float
+        The relative importance of indirect neighbors with respect to
+        direct neighbors.
+
+    max_iterations : integer
+        Maximum number of iterations.
+
+    tolerance : float
+        Error tolerance used to check convergence. When an iteration of
+        the algorithm finds that no similarity value changes more than
+        this amount, the algorithm halts.
+
+    Returns
+    -------
+    similarity : numpy array or float
+        If ``source`` and ``target`` are both ``None``, this returns a
+        2D array containing SimRank scores of the nodes.
+
+        If ``source`` is not ``None`` but ``target`` is, this returns an
+        1D array containing SimRank scores of ``source`` and that
+        node.
+
+        If neither ``source`` nor ``target`` is ``None``, this returns
+        the similarity value for the given pair of nodes.
+
+    Examples
+    --------
+    >>> G = nx.cycle_graph(2)
+    >>> nx.similarity._simrank_similarity_numpy(G)
+    array([[1., 0.],
+           [0., 1.]])
+    >>> nx.similarity._simrank_similarity_numpy(G, source=0)
+    array([1., 0.])
+    >>> nx.similarity._simrank_similarity_numpy(G, source=0, target=0)
+    1.0
+
+    References
+    ----------
+    .. [1] G. Jeh and J. Widom.
+           "SimRank: a measure of structural-context similarity",
+           In KDD'02: Proceedings of the Eighth ACM SIGKDD
+           International Conference on Knowledge Discovery and Data Mining,
+           pp. 538--543. ACM Press, 2002.
+    """
+    # This algorithm follows roughly
+    #
+    #     S = max{C * (A.T * S * A), I}
+    #
+    # where C is the importance factor, A is the column normalized
+    # adjacency matrix, and I is the identity matrix.
+    import numpy as np
+
+    adjacency_matrix = nx.to_numpy_array(G)
+
+    # column-normalize the ``adjacency_matrix``
+    s = np.array(adjacency_matrix.sum(axis=0))
+    s[s == 0] = 1
+    adjacency_matrix /= s  # adjacency_matrix.sum(axis=0)
+
+    newsim = np.eye(len(G), dtype=np.float64)
+    for its in range(max_iterations):
+        prevsim = newsim.copy()
+        newsim = importance_factor * ((adjacency_matrix.T @ prevsim) @ adjacency_matrix)
+        np.fill_diagonal(newsim, 1.0)
+
+        if np.allclose(prevsim, newsim, atol=tolerance):
+            break
+
+    if its + 1 == max_iterations:
+        raise nx.ExceededMaxIterations(
+            f"simrank did not converge after {max_iterations} iterations."
+        )
+
+    if source is not None and target is not None:
+        return newsim[source, target]
+    if source is not None:
+        return newsim[source]
+    return newsim
+
+
+def simrank_similarity_numpy(
+    G,
+    source=None,
+    target=None,
+    importance_factor=0.9,
+    max_iterations=100,
+    tolerance=1e-4,
+):
+    """Calculate SimRank of nodes in ``G`` using matrices with ``numpy``.
+
+    .. deprecated:: 2.6
+        simrank_similarity_numpy is deprecated and will be removed in networkx 3.0.
+        Use simrank_similarity
+
+    """
+    warnings.warn(
+        (
+            "networkx.simrank_similarity_numpy is deprecated and will be removed"
+            "in NetworkX 3.0, use networkx.simrank_similarity instead."
+        ),
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return _simrank_similarity_numpy(
+        G, source, target, importance_factor, max_iterations, tolerance
+    )
+
+
+def panther_similarity(G, source, k=5, path_length=5, c=0.5, delta=0.1, eps=None):
+    r"""Returns the Panther similarity of nodes in the graph `G` to node ``v``.
+
+    Panther is a similarity metric that says "two objects are considered
+    to be similar if they frequently appear on the same paths." [1]_.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A NetworkX graph
+    source : node
+        Source node for which to find the top `k` similar other nodes
+    k : int (default = 5)
+        The number of most similar nodes to return
+    path_length : int (default = 5)
+        How long the randomly generated paths should be (``T`` in [1]_)
+    c : float (default = 0.5)
+        A universal positive constant used to scale the number
+        of sample random paths to generate.
+    delta : float (default = 0.1)
+        The probability that the similarity $S$ is not an epsilon-approximation to (R, phi),
+        where $R$ is the number of random paths and $\phi$ is the probability
+        that an element sampled from a set $A \subseteq D$, where $D$ is the domain.
+    eps : float or None (default = None)
+        The error bound. Per [1]_, a good value is ``sqrt(1/|E|)``. Therefore,
+        if no value is provided, the recommended computed value will be used.
+
+    Returns
+    -------
+    similarity : dictionary
+        Dictionary of nodes to similarity scores (as floats). Note:
+        the self-similarity (i.e., ``v``) will not be included in
+        the returned dictionary.
+
+    Examples
+    --------
+    >>> G = nx.star_graph(10)
+    >>> sim = nx.panther_similarity(G, 0)
+
+    References
+    ----------
+    .. [1] Zhang, J., Tang, J., Ma, C., Tong, H., Jing, Y., & Li, J.
+           Panther: Fast top-k similarity search on large networks.
+           In Proceedings of the ACM SIGKDD International Conference
+           on Knowledge Discovery and Data Mining (Vol. 2015-August, pp. 1445–1454).
+           Association for Computing Machinery. https://doi.org/10.1145/2783258.2783267.
+    """
+    import numpy as np
+
+    num_nodes = G.number_of_nodes()
+    if num_nodes < k:
+        warnings.warn(
+            f"Number of nodes is {num_nodes}, but requested k is {k}. "
+            "Setting k to number of nodes."
+        )
+        k = num_nodes
+    # According to [1], they empirically determined
+    # a good value for ``eps`` to be sqrt( 1 / |E| )
+    if eps is None:
+        eps = np.sqrt(1.0 / G.number_of_edges())
+
+    inv_node_map = {name: index for index, name in enumerate(G.nodes)}
+    node_map = np.array(G)
+
+    # Calculate the sample size ``R`` for how many paths
+    # to randomly generate
+    t_choose_2 = math.comb(path_length, 2)
+    sample_size = int((c / eps**2) * (np.log2(t_choose_2) + 1 + np.log(1 / delta)))
+    index_map = {}
+    _ = list(
+        generate_random_paths(
+            G, sample_size, path_length=path_length, index_map=index_map
+        )
+    )
+    S = np.zeros(num_nodes)
+
+    inv_sample_size = 1 / sample_size
+
+    source_paths = set(index_map[source])
+
+    # Calculate the path similarities
+    # between ``source`` (v) and ``node`` (v_j)
+    # using our inverted index mapping of
+    # vertices to paths
+    for node, paths in index_map.items():
+        # Only consider paths where both
+        # ``node`` and ``source`` are present
+        common_paths = source_paths.intersection(paths)
+        S[inv_node_map[node]] = len(common_paths) * inv_sample_size
+
+    # Retrieve top ``k`` similar
+    # Note: the below performed anywhere from 4-10x faster
+    # (depending on input sizes) vs the equivalent ``np.argsort(S)[::-1]``
+    top_k_unsorted = np.argpartition(S, -k)[-k:]
+    top_k_sorted = top_k_unsorted[np.argsort(S[top_k_unsorted])][::-1]
+
+    # Add back the similarity scores
+    top_k_sorted_names = map(lambda n: node_map[n], top_k_sorted)
+    top_k_with_val = dict(zip(top_k_sorted_names, S[top_k_sorted]))
+
+    # Remove the self-similarity
+    top_k_with_val.pop(source, None)
+    return top_k_with_val
+
+
+def generate_random_paths(G, sample_size, path_length=5, index_map=None):
+    """Randomly generate `sample_size` paths of length `path_length`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A NetworkX graph
+    sample_size : integer
+        The number of paths to generate. This is ``R`` in [1]_.
+    path_length : integer (default = 5)
+        The maximum size of the path to randomly generate.
+        This is ``T`` in [1]_. According to the paper, ``T >= 5`` is
+        recommended.
+    index_map : dictionary, optional
+        If provided, this will be populated with the inverted
+        index of nodes mapped to the set of generated random path
+        indices within ``paths``.
+
+    Returns
+    -------
+    paths : generator of lists
+        Generator of `sample_size` paths each with length `path_length`.
+
+    Examples
+    --------
+    Note that the return value is the list of paths:
+
+    >>> G = nx.star_graph(3)
+    >>> random_path = nx.generate_random_paths(G, 2)
+
+    By passing a dictionary into `index_map`, it will build an
+    inverted index mapping of nodes to the paths in which that node is present:
+
+    >>> G = nx.star_graph(3)
+    >>> index_map = {}
+    >>> random_path = nx.generate_random_paths(G, 3, index_map=index_map)
+    >>> paths_containing_node_0 = [random_path[path_idx] for path_idx in index_map.get(0, [])]
+
+    References
+    ----------
+    .. [1] Zhang, J., Tang, J., Ma, C., Tong, H., Jing, Y., & Li, J.
+           Panther: Fast top-k similarity search on large networks.
+           In Proceedings of the ACM SIGKDD International Conference
+           on Knowledge Discovery and Data Mining (Vol. 2015-August, pp. 1445–1454).
+           Association for Computing Machinery. https://doi.org/10.1145/2783258.2783267.
+    """
+    import numpy as np
+
+    # Calculate transition probabilities between
+    # every pair of vertices according to Eq. (3)
+    adj_mat = nx.to_numpy_array(G)
+    inv_row_sums = np.reciprocal(adj_mat.sum(axis=1)).reshape(-1, 1)
+    transition_probabilities = adj_mat * inv_row_sums
+
+    node_map = np.array(G)
+    num_nodes = G.number_of_nodes()
+
+    for path_index in range(sample_size):
+        # Sample current vertex v = v_i uniformly at random
+        node_index = np.random.randint(0, high=num_nodes)
+        node = node_map[node_index]
+
+        # Add v into p_r and add p_r into the path set
+        # of v, i.e., P_v
+        path = [node]
+
+        # Build the inverted index (P_v) of vertices to paths
+        if index_map is not None:
+            if node in index_map:
+                index_map[node].add(path_index)
+            else:
+                index_map[node] = {path_index}
+
+        starting_index = node_index
+        for _ in range(path_length):
+            # Randomly sample a neighbor (v_j) according
+            # to transition probabilities from ``node`` (v) to its neighbors
+            neighbor_index = np.random.choice(
+                num_nodes, p=transition_probabilities[starting_index]
+            )
+
+            # Set current vertex (v = v_j)
+            starting_index = neighbor_index
+
+            # Add v into p_r
+            neighbor_node = node_map[neighbor_index]
+            path.append(neighbor_node)
+
+            # Add p_r into P_v
+            if index_map is not None:
+                if neighbor_node in index_map:
+                    index_map[neighbor_node].add(path_index)
+                else:
+                    index_map[neighbor_node] = {path_index}
+
+        yield path
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/simple_paths.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/simple_paths.py
new file mode 100644
index 0000000..0ce2721
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/simple_paths.py
@@ -0,0 +1,955 @@
+from heapq import heappop, heappush
+from itertools import count
+
+import networkx as nx
+from networkx.algorithms.shortest_paths.weighted import _weight_function
+from networkx.utils import not_implemented_for, pairwise
+
+__all__ = [
+    "all_simple_paths",
+    "is_simple_path",
+    "shortest_simple_paths",
+    "all_simple_edge_paths",
+]
+
+
+def is_simple_path(G, nodes):
+    """Returns True if and only if `nodes` form a simple path in `G`.
+
+    A *simple path* in a graph is a nonempty sequence of nodes in which
+    no node appears more than once in the sequence, and each adjacent
+    pair of nodes in the sequence is adjacent in the graph.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph.
+    nodes : list
+        A list of one or more nodes in the graph `G`.
+
+    Returns
+    -------
+    bool
+        Whether the given list of nodes represents a simple path in `G`.
+
+    Notes
+    -----
+    An empty list of nodes is not a path but a list of one node is a
+    path. Here's an explanation why.
+
+    This function operates on *node paths*. One could also consider
+    *edge paths*. There is a bijection between node paths and edge
+    paths.
+
+    The *length of a path* is the number of edges in the path, so a list
+    of nodes of length *n* corresponds to a path of length *n* - 1.
+    Thus the smallest edge path would be a list of zero edges, the empty
+    path. This corresponds to a list of one node.
+
+    To convert between a node path and an edge path, you can use code
+    like the following::
+
+        >>> from networkx.utils import pairwise
+        >>> nodes = [0, 1, 2, 3]
+        >>> edges = list(pairwise(nodes))
+        >>> edges
+        [(0, 1), (1, 2), (2, 3)]
+        >>> nodes = [edges[0][0]] + [v for u, v in edges]
+        >>> nodes
+        [0, 1, 2, 3]
+
+    Examples
+    --------
+    >>> G = nx.cycle_graph(4)
+    >>> nx.is_simple_path(G, [2, 3, 0])
+    True
+    >>> nx.is_simple_path(G, [0, 2])
+    False
+
+    """
+    # The empty list is not a valid path. Could also return
+    # NetworkXPointlessConcept here.
+    if len(nodes) == 0:
+        return False
+    # If the list is a single node, just check that the node is actually
+    # in the graph.
+    if len(nodes) == 1:
+        return nodes[0] in G
+    # Test that no node appears more than once, and that each
+    # adjacent pair of nodes is adjacent.
+    return len(set(nodes)) == len(nodes) and all(v in G[u] for u, v in pairwise(nodes))
+
+
+def all_simple_paths(G, source, target, cutoff=None):
+    """Generate all simple paths in the graph G from source to target.
+
+    A simple path is a path with no repeated nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Starting node for path
+
+    target : nodes
+       Single node or iterable of nodes at which to end path
+
+    cutoff : integer, optional
+        Depth to stop the search. Only paths of length <= cutoff are returned.
+
+    Returns
+    -------
+    path_generator: generator
+       A generator that produces lists of simple paths.  If there are no paths
+       between the source and target within the given cutoff the generator
+       produces no output.
+
+    Examples
+    --------
+    This iterator generates lists of nodes::
+
+        >>> G = nx.complete_graph(4)
+        >>> for path in nx.all_simple_paths(G, source=0, target=3):
+        ...     print(path)
+        ...
+        [0, 1, 2, 3]
+        [0, 1, 3]
+        [0, 2, 1, 3]
+        [0, 2, 3]
+        [0, 3]
+
+    You can generate only those paths that are shorter than a certain
+    length by using the `cutoff` keyword argument::
+
+        >>> paths = nx.all_simple_paths(G, source=0, target=3, cutoff=2)
+        >>> print(list(paths))
+        [[0, 1, 3], [0, 2, 3], [0, 3]]
+
+    To get each path as the corresponding list of edges, you can use the
+    :func:`networkx.utils.pairwise` helper function::
+
+        >>> paths = nx.all_simple_paths(G, source=0, target=3)
+        >>> for path in map(nx.utils.pairwise, paths):
+        ...     print(list(path))
+        [(0, 1), (1, 2), (2, 3)]
+        [(0, 1), (1, 3)]
+        [(0, 2), (2, 1), (1, 3)]
+        [(0, 2), (2, 3)]
+        [(0, 3)]
+
+    Pass an iterable of nodes as target to generate all paths ending in any of several nodes::
+
+        >>> G = nx.complete_graph(4)
+        >>> for path in nx.all_simple_paths(G, source=0, target=[3, 2]):
+        ...     print(path)
+        ...
+        [0, 1, 2]
+        [0, 1, 2, 3]
+        [0, 1, 3]
+        [0, 1, 3, 2]
+        [0, 2]
+        [0, 2, 1, 3]
+        [0, 2, 3]
+        [0, 3]
+        [0, 3, 1, 2]
+        [0, 3, 2]
+
+    Iterate over each path from the root nodes to the leaf nodes in a
+    directed acyclic graph using a functional programming approach::
+
+        >>> from itertools import chain
+        >>> from itertools import product
+        >>> from itertools import starmap
+        >>> from functools import partial
+        >>>
+        >>> chaini = chain.from_iterable
+        >>>
+        >>> G = nx.DiGraph([(0, 1), (1, 2), (0, 3), (3, 2)])
+        >>> roots = (v for v, d in G.in_degree() if d == 0)
+        >>> leaves = (v for v, d in G.out_degree() if d == 0)
+        >>> all_paths = partial(nx.all_simple_paths, G)
+        >>> list(chaini(starmap(all_paths, product(roots, leaves))))
+        [[0, 1, 2], [0, 3, 2]]
+
+    The same list computed using an iterative approach::
+
+        >>> G = nx.DiGraph([(0, 1), (1, 2), (0, 3), (3, 2)])
+        >>> roots = (v for v, d in G.in_degree() if d == 0)
+        >>> leaves = (v for v, d in G.out_degree() if d == 0)
+        >>> all_paths = []
+        >>> for root in roots:
+        ...     for leaf in leaves:
+        ...         paths = nx.all_simple_paths(G, root, leaf)
+        ...         all_paths.extend(paths)
+        >>> all_paths
+        [[0, 1, 2], [0, 3, 2]]
+
+    Iterate over each path from the root nodes to the leaf nodes in a
+    directed acyclic graph passing all leaves together to avoid unnecessary
+    compute::
+
+        >>> G = nx.DiGraph([(0, 1), (2, 1), (1, 3), (1, 4)])
+        >>> roots = (v for v, d in G.in_degree() if d == 0)
+        >>> leaves = [v for v, d in G.out_degree() if d == 0]
+        >>> all_paths = []
+        >>> for root in roots:
+        ...     paths = nx.all_simple_paths(G, root, leaves)
+        ...     all_paths.extend(paths)
+        >>> all_paths
+        [[0, 1, 3], [0, 1, 4], [2, 1, 3], [2, 1, 4]]
+
+    Notes
+    -----
+    This algorithm uses a modified depth-first search to generate the
+    paths [1]_.  A single path can be found in $O(V+E)$ time but the
+    number of simple paths in a graph can be very large, e.g. $O(n!)$ in
+    the complete graph of order $n$.
+
+    This function does not check that a path exists between `source` and
+    `target`. For large graphs, this may result in very long runtimes.
+    Consider using `has_path` to check that a path exists between `source` and
+    `target` before calling this function on large graphs.
+
+    References
+    ----------
+    .. [1] R. Sedgewick, "Algorithms in C, Part 5: Graph Algorithms",
+       Addison Wesley Professional, 3rd ed., 2001.
+
+    See Also
+    --------
+    all_shortest_paths, shortest_path, has_path
+
+    """
+    if source not in G:
+        raise nx.NodeNotFound(f"source node {source} not in graph")
+    if target in G:
+        targets = {target}
+    else:
+        try:
+            targets = set(target)
+        except TypeError as err:
+            raise nx.NodeNotFound(f"target node {target} not in graph") from err
+    if source in targets:
+        return _empty_generator()
+    if cutoff is None:
+        cutoff = len(G) - 1
+    if cutoff < 1:
+        return _empty_generator()
+    if G.is_multigraph():
+        return _all_simple_paths_multigraph(G, source, targets, cutoff)
+    else:
+        return _all_simple_paths_graph(G, source, targets, cutoff)
+
+
+def _empty_generator():
+    yield from ()
+
+
+def _all_simple_paths_graph(G, source, targets, cutoff):
+    visited = dict.fromkeys([source])
+    stack = [iter(G[source])]
+    while stack:
+        children = stack[-1]
+        child = next(children, None)
+        if child is None:
+            stack.pop()
+            visited.popitem()
+        elif len(visited) < cutoff:
+            if child in visited:
+                continue
+            if child in targets:
+                yield list(visited) + [child]
+            visited[child] = None
+            if targets - set(visited.keys()):  # expand stack until find all targets
+                stack.append(iter(G[child]))
+            else:
+                visited.popitem()  # maybe other ways to child
+        else:  # len(visited) == cutoff:
+            for target in (targets & (set(children) | {child})) - set(visited.keys()):
+                yield list(visited) + [target]
+            stack.pop()
+            visited.popitem()
+
+
+def _all_simple_paths_multigraph(G, source, targets, cutoff):
+    visited = dict.fromkeys([source])
+    stack = [(v for u, v in G.edges(source))]
+    while stack:
+        children = stack[-1]
+        child = next(children, None)
+        if child is None:
+            stack.pop()
+            visited.popitem()
+        elif len(visited) < cutoff:
+            if child in visited:
+                continue
+            if child in targets:
+                yield list(visited) + [child]
+            visited[child] = None
+            if targets - set(visited.keys()):
+                stack.append((v for u, v in G.edges(child)))
+            else:
+                visited.popitem()
+        else:  # len(visited) == cutoff:
+            for target in targets - set(visited.keys()):
+                count = ([child] + list(children)).count(target)
+                for i in range(count):
+                    yield list(visited) + [target]
+            stack.pop()
+            visited.popitem()
+
+
+def all_simple_edge_paths(G, source, target, cutoff=None):
+    """Generate lists of edges for all simple paths in G from source to target.
+
+    A simple path is a path with no repeated nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Starting node for path
+
+    target : nodes
+       Single node or iterable of nodes at which to end path
+
+    cutoff : integer, optional
+        Depth to stop the search. Only paths of length <= cutoff are returned.
+
+    Returns
+    -------
+    path_generator: generator
+       A generator that produces lists of simple paths.  If there are no paths
+       between the source and target within the given cutoff the generator
+       produces no output.
+       For multigraphs, the list of edges have elements of the form `(u,v,k)`.
+       Where `k` corresponds to the edge key.
+
+    Examples
+    --------
+
+    Print the simple path edges of a Graph::
+
+        >>> g = nx.Graph([(1, 2), (2, 4), (1, 3), (3, 4)])
+        >>> for path in sorted(nx.all_simple_edge_paths(g, 1, 4)):
+        ...     print(path)
+        [(1, 2), (2, 4)]
+        [(1, 3), (3, 4)]
+
+    Print the simple path edges of a MultiGraph. Returned edges come with
+    their associated keys::
+
+        >>> mg = nx.MultiGraph()
+        >>> mg.add_edge(1, 2, key="k0")
+        'k0'
+        >>> mg.add_edge(1, 2, key="k1")
+        'k1'
+        >>> mg.add_edge(2, 3, key="k0")
+        'k0'
+        >>> for path in sorted(nx.all_simple_edge_paths(mg, 1, 3)):
+        ...     print(path)
+        [(1, 2, 'k0'), (2, 3, 'k0')]
+        [(1, 2, 'k1'), (2, 3, 'k0')]
+
+
+    Notes
+    -----
+    This algorithm uses a modified depth-first search to generate the
+    paths [1]_.  A single path can be found in $O(V+E)$ time but the
+    number of simple paths in a graph can be very large, e.g. $O(n!)$ in
+    the complete graph of order $n$.
+
+    References
+    ----------
+    .. [1] R. Sedgewick, "Algorithms in C, Part 5: Graph Algorithms",
+       Addison Wesley Professional, 3rd ed., 2001.
+
+    See Also
+    --------
+    all_shortest_paths, shortest_path, all_simple_paths
+
+    """
+    if source not in G:
+        raise nx.NodeNotFound("source node %s not in graph" % source)
+    if target in G:
+        targets = {target}
+    else:
+        try:
+            targets = set(target)
+        except TypeError:
+            raise nx.NodeNotFound("target node %s not in graph" % target)
+    if source in targets:
+        return []
+    if cutoff is None:
+        cutoff = len(G) - 1
+    if cutoff < 1:
+        return []
+    if G.is_multigraph():
+        for simp_path in _all_simple_edge_paths_multigraph(G, source, targets, cutoff):
+            yield simp_path
+    else:
+        for simp_path in _all_simple_paths_graph(G, source, targets, cutoff):
+            yield list(zip(simp_path[:-1], simp_path[1:]))
+
+
+def _all_simple_edge_paths_multigraph(G, source, targets, cutoff):
+    if not cutoff or cutoff < 1:
+        return []
+    visited = [source]
+    stack = [iter(G.edges(source, keys=True))]
+
+    while stack:
+        children = stack[-1]
+        child = next(children, None)
+        if child is None:
+            stack.pop()
+            visited.pop()
+        elif len(visited) < cutoff:
+            if child[1] in targets:
+                yield visited[1:] + [child]
+            elif child[1] not in [v[0] for v in visited[1:]]:
+                visited.append(child)
+                stack.append(iter(G.edges(child[1], keys=True)))
+        else:  # len(visited) == cutoff:
+            for (u, v, k) in [child] + list(children):
+                if v in targets:
+                    yield visited[1:] + [(u, v, k)]
+            stack.pop()
+            visited.pop()
+
+
+@not_implemented_for("multigraph")
+def shortest_simple_paths(G, source, target, weight=None):
+    """Generate all simple paths in the graph G from source to target,
+       starting from shortest ones.
+
+    A simple path is a path with no repeated nodes.
+
+    If a weighted shortest path search is to be used, no negative weights
+    are allowed.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Starting node for path
+
+    target : node
+       Ending node for path
+
+    weight : string or function
+        If it is a string, it is the name of the edge attribute to be
+        used as a weight.
+
+        If it is a function, the weight of an edge is the value returned
+        by the function. The function must accept exactly three positional
+        arguments: the two endpoints of an edge and the dictionary of edge
+        attributes for that edge. The function must return a number.
+
+        If None all edges are considered to have unit weight. Default
+        value None.
+
+    Returns
+    -------
+    path_generator: generator
+       A generator that produces lists of simple paths, in order from
+       shortest to longest.
+
+    Raises
+    ------
+    NetworkXNoPath
+       If no path exists between source and target.
+
+    NetworkXError
+       If source or target nodes are not in the input graph.
+
+    NetworkXNotImplemented
+       If the input graph is a Multi[Di]Graph.
+
+    Examples
+    --------
+
+    >>> G = nx.cycle_graph(7)
+    >>> paths = list(nx.shortest_simple_paths(G, 0, 3))
+    >>> print(paths)
+    [[0, 1, 2, 3], [0, 6, 5, 4, 3]]
+
+    You can use this function to efficiently compute the k shortest/best
+    paths between two nodes.
+
+    >>> from itertools import islice
+    >>> def k_shortest_paths(G, source, target, k, weight=None):
+    ...     return list(
+    ...         islice(nx.shortest_simple_paths(G, source, target, weight=weight), k)
+    ...     )
+    >>> for path in k_shortest_paths(G, 0, 3, 2):
+    ...     print(path)
+    [0, 1, 2, 3]
+    [0, 6, 5, 4, 3]
+
+    Notes
+    -----
+    This procedure is based on algorithm by Jin Y. Yen [1]_.  Finding
+    the first $K$ paths requires $O(KN^3)$ operations.
+
+    See Also
+    --------
+    all_shortest_paths
+    shortest_path
+    all_simple_paths
+
+    References
+    ----------
+    .. [1] Jin Y. Yen, "Finding the K Shortest Loopless Paths in a
+       Network", Management Science, Vol. 17, No. 11, Theory Series
+       (Jul., 1971), pp. 712-716.
+
+    """
+    if source not in G:
+        raise nx.NodeNotFound(f"source node {source} not in graph")
+
+    if target not in G:
+        raise nx.NodeNotFound(f"target node {target} not in graph")
+
+    if weight is None:
+        length_func = len
+        shortest_path_func = _bidirectional_shortest_path
+    else:
+        wt = _weight_function(G, weight)
+
+        def length_func(path):
+            return sum(
+                wt(u, v, G.get_edge_data(u, v)) for (u, v) in zip(path, path[1:])
+            )
+
+        shortest_path_func = _bidirectional_dijkstra
+
+    listA = list()
+    listB = PathBuffer()
+    prev_path = None
+    while True:
+        if not prev_path:
+            length, path = shortest_path_func(G, source, target, weight=weight)
+            listB.push(length, path)
+        else:
+            ignore_nodes = set()
+            ignore_edges = set()
+            for i in range(1, len(prev_path)):
+                root = prev_path[:i]
+                root_length = length_func(root)
+                for path in listA:
+                    if path[:i] == root:
+                        ignore_edges.add((path[i - 1], path[i]))
+                try:
+                    length, spur = shortest_path_func(
+                        G,
+                        root[-1],
+                        target,
+                        ignore_nodes=ignore_nodes,
+                        ignore_edges=ignore_edges,
+                        weight=weight,
+                    )
+                    path = root[:-1] + spur
+                    listB.push(root_length + length, path)
+                except nx.NetworkXNoPath:
+                    pass
+                ignore_nodes.add(root[-1])
+
+        if listB:
+            path = listB.pop()
+            yield path
+            listA.append(path)
+            prev_path = path
+        else:
+            break
+
+
+class PathBuffer:
+    def __init__(self):
+        self.paths = set()
+        self.sortedpaths = list()
+        self.counter = count()
+
+    def __len__(self):
+        return len(self.sortedpaths)
+
+    def push(self, cost, path):
+        hashable_path = tuple(path)
+        if hashable_path not in self.paths:
+            heappush(self.sortedpaths, (cost, next(self.counter), path))
+            self.paths.add(hashable_path)
+
+    def pop(self):
+        (cost, num, path) = heappop(self.sortedpaths)
+        hashable_path = tuple(path)
+        self.paths.remove(hashable_path)
+        return path
+
+
+def _bidirectional_shortest_path(
+    G, source, target, ignore_nodes=None, ignore_edges=None, weight=None
+):
+    """Returns the shortest path between source and target ignoring
+       nodes and edges in the containers ignore_nodes and ignore_edges.
+
+    This is a custom modification of the standard bidirectional shortest
+    path implementation at networkx.algorithms.unweighted
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       starting node for path
+
+    target : node
+       ending node for path
+
+    ignore_nodes : container of nodes
+       nodes to ignore, optional
+
+    ignore_edges : container of edges
+       edges to ignore, optional
+
+    weight : None
+       This function accepts a weight argument for convenience of
+       shortest_simple_paths function. It will be ignored.
+
+    Returns
+    -------
+    path: list
+       List of nodes in a path from source to target.
+
+    Raises
+    ------
+    NetworkXNoPath
+       If no path exists between source and target.
+
+    See Also
+    --------
+    shortest_path
+
+    """
+    # call helper to do the real work
+    results = _bidirectional_pred_succ(G, source, target, ignore_nodes, ignore_edges)
+    pred, succ, w = results
+
+    # build path from pred+w+succ
+    path = []
+    # from w to target
+    while w is not None:
+        path.append(w)
+        w = succ[w]
+    # from source to w
+    w = pred[path[0]]
+    while w is not None:
+        path.insert(0, w)
+        w = pred[w]
+
+    return len(path), path
+
+
+def _bidirectional_pred_succ(G, source, target, ignore_nodes=None, ignore_edges=None):
+    """Bidirectional shortest path helper.
+    Returns (pred,succ,w) where
+    pred is a dictionary of predecessors from w to the source, and
+    succ is a dictionary of successors from w to the target.
+    """
+    # does BFS from both source and target and meets in the middle
+    if ignore_nodes and (source in ignore_nodes or target in ignore_nodes):
+        raise nx.NetworkXNoPath(f"No path between {source} and {target}.")
+    if target == source:
+        return ({target: None}, {source: None}, source)
+
+    # handle either directed or undirected
+    if G.is_directed():
+        Gpred = G.predecessors
+        Gsucc = G.successors
+    else:
+        Gpred = G.neighbors
+        Gsucc = G.neighbors
+
+    # support optional nodes filter
+    if ignore_nodes:
+
+        def filter_iter(nodes):
+            def iterate(v):
+                for w in nodes(v):
+                    if w not in ignore_nodes:
+                        yield w
+
+            return iterate
+
+        Gpred = filter_iter(Gpred)
+        Gsucc = filter_iter(Gsucc)
+
+    # support optional edges filter
+    if ignore_edges:
+        if G.is_directed():
+
+            def filter_pred_iter(pred_iter):
+                def iterate(v):
+                    for w in pred_iter(v):
+                        if (w, v) not in ignore_edges:
+                            yield w
+
+                return iterate
+
+            def filter_succ_iter(succ_iter):
+                def iterate(v):
+                    for w in succ_iter(v):
+                        if (v, w) not in ignore_edges:
+                            yield w
+
+                return iterate
+
+            Gpred = filter_pred_iter(Gpred)
+            Gsucc = filter_succ_iter(Gsucc)
+
+        else:
+
+            def filter_iter(nodes):
+                def iterate(v):
+                    for w in nodes(v):
+                        if (v, w) not in ignore_edges and (w, v) not in ignore_edges:
+                            yield w
+
+                return iterate
+
+            Gpred = filter_iter(Gpred)
+            Gsucc = filter_iter(Gsucc)
+
+    # predecesssor and successors in search
+    pred = {source: None}
+    succ = {target: None}
+
+    # initialize fringes, start with forward
+    forward_fringe = [source]
+    reverse_fringe = [target]
+
+    while forward_fringe and reverse_fringe:
+        if len(forward_fringe) <= len(reverse_fringe):
+            this_level = forward_fringe
+            forward_fringe = []
+            for v in this_level:
+                for w in Gsucc(v):
+                    if w not in pred:
+                        forward_fringe.append(w)
+                        pred[w] = v
+                    if w in succ:
+                        # found path
+                        return pred, succ, w
+        else:
+            this_level = reverse_fringe
+            reverse_fringe = []
+            for v in this_level:
+                for w in Gpred(v):
+                    if w not in succ:
+                        succ[w] = v
+                        reverse_fringe.append(w)
+                    if w in pred:
+                        # found path
+                        return pred, succ, w
+
+    raise nx.NetworkXNoPath(f"No path between {source} and {target}.")
+
+
+def _bidirectional_dijkstra(
+    G, source, target, weight="weight", ignore_nodes=None, ignore_edges=None
+):
+    """Dijkstra's algorithm for shortest paths using bidirectional search.
+
+    This function returns the shortest path between source and target
+    ignoring nodes and edges in the containers ignore_nodes and
+    ignore_edges.
+
+    This is a custom modification of the standard Dijkstra bidirectional
+    shortest path implementation at networkx.algorithms.weighted
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Starting node.
+
+    target : node
+       Ending node.
+
+    weight: string, function, optional (default='weight')
+       Edge data key or weight function corresponding to the edge weight
+
+    ignore_nodes : container of nodes
+       nodes to ignore, optional
+
+    ignore_edges : container of edges
+       edges to ignore, optional
+
+    Returns
+    -------
+    length : number
+        Shortest path length.
+
+    Returns a tuple of two dictionaries keyed by node.
+    The first dictionary stores distance from the source.
+    The second stores the path from the source to that node.
+
+    Raises
+    ------
+    NetworkXNoPath
+        If no path exists between source and target.
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    In practice  bidirectional Dijkstra is much more than twice as fast as
+    ordinary Dijkstra.
+
+    Ordinary Dijkstra expands nodes in a sphere-like manner from the
+    source. The radius of this sphere will eventually be the length
+    of the shortest path. Bidirectional Dijkstra will expand nodes
+    from both the source and the target, making two spheres of half
+    this radius. Volume of the first sphere is pi*r*r while the
+    others are 2*pi*r/2*r/2, making up half the volume.
+
+    This algorithm is not guaranteed to work if edge weights
+    are negative or are floating point numbers
+    (overflows and roundoff errors can cause problems).
+
+    See Also
+    --------
+    shortest_path
+    shortest_path_length
+    """
+    if ignore_nodes and (source in ignore_nodes or target in ignore_nodes):
+        raise nx.NetworkXNoPath(f"No path between {source} and {target}.")
+    if source == target:
+        if source not in G:
+            raise nx.NodeNotFound(f"Node {source} not in graph")
+        return (0, [source])
+
+    # handle either directed or undirected
+    if G.is_directed():
+        Gpred = G.predecessors
+        Gsucc = G.successors
+    else:
+        Gpred = G.neighbors
+        Gsucc = G.neighbors
+
+    # support optional nodes filter
+    if ignore_nodes:
+
+        def filter_iter(nodes):
+            def iterate(v):
+                for w in nodes(v):
+                    if w not in ignore_nodes:
+                        yield w
+
+            return iterate
+
+        Gpred = filter_iter(Gpred)
+        Gsucc = filter_iter(Gsucc)
+
+    # support optional edges filter
+    if ignore_edges:
+        if G.is_directed():
+
+            def filter_pred_iter(pred_iter):
+                def iterate(v):
+                    for w in pred_iter(v):
+                        if (w, v) not in ignore_edges:
+                            yield w
+
+                return iterate
+
+            def filter_succ_iter(succ_iter):
+                def iterate(v):
+                    for w in succ_iter(v):
+                        if (v, w) not in ignore_edges:
+                            yield w
+
+                return iterate
+
+            Gpred = filter_pred_iter(Gpred)
+            Gsucc = filter_succ_iter(Gsucc)
+
+        else:
+
+            def filter_iter(nodes):
+                def iterate(v):
+                    for w in nodes(v):
+                        if (v, w) not in ignore_edges and (w, v) not in ignore_edges:
+                            yield w
+
+                return iterate
+
+            Gpred = filter_iter(Gpred)
+            Gsucc = filter_iter(Gsucc)
+
+    push = heappush
+    pop = heappop
+    # Init:   Forward             Backward
+    dists = [{}, {}]  # dictionary of final distances
+    paths = [{source: [source]}, {target: [target]}]  # dictionary of paths
+    fringe = [[], []]  # heap of (distance, node) tuples for
+    # extracting next node to expand
+    seen = [{source: 0}, {target: 0}]  # dictionary of distances to
+    # nodes seen
+    c = count()
+    # initialize fringe heap
+    push(fringe[0], (0, next(c), source))
+    push(fringe[1], (0, next(c), target))
+    # neighs for extracting correct neighbor information
+    neighs = [Gsucc, Gpred]
+    # variables to hold shortest discovered path
+    # finaldist = 1e30000
+    finalpath = []
+    dir = 1
+    while fringe[0] and fringe[1]:
+        # choose direction
+        # dir == 0 is forward direction and dir == 1 is back
+        dir = 1 - dir
+        # extract closest to expand
+        (dist, _, v) = pop(fringe[dir])
+        if v in dists[dir]:
+            # Shortest path to v has already been found
+            continue
+        # update distance
+        dists[dir][v] = dist  # equal to seen[dir][v]
+        if v in dists[1 - dir]:
+            # if we have scanned v in both directions we are done
+            # we have now discovered the shortest path
+            return (finaldist, finalpath)
+
+        wt = _weight_function(G, weight)
+        for w in neighs[dir](v):
+            if dir == 0:  # forward
+                minweight = wt(v, w, G.get_edge_data(v, w))
+                vwLength = dists[dir][v] + minweight
+            else:  # back, must remember to change v,w->w,v
+                minweight = wt(w, v, G.get_edge_data(w, v))
+                vwLength = dists[dir][v] + minweight
+
+            if w in dists[dir]:
+                if vwLength < dists[dir][w]:
+                    raise ValueError("Contradictory paths found: negative weights?")
+            elif w not in seen[dir] or vwLength < seen[dir][w]:
+                # relaxing
+                seen[dir][w] = vwLength
+                push(fringe[dir], (vwLength, next(c), w))
+                paths[dir][w] = paths[dir][v] + [w]
+                if w in seen[0] and w in seen[1]:
+                    # see if this path is better than the already
+                    # discovered shortest path
+                    totaldist = seen[0][w] + seen[1][w]
+                    if finalpath == [] or finaldist > totaldist:
+                        finaldist = totaldist
+                        revpath = paths[1][w][:]
+                        revpath.reverse()
+                        finalpath = paths[0][w] + revpath[1:]
+    raise nx.NetworkXNoPath(f"No path between {source} and {target}.")
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/smallworld.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/smallworld.py
new file mode 100644
index 0000000..fc64d13
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/smallworld.py
@@ -0,0 +1,385 @@
+"""Functions for estimating the small-world-ness of graphs.
+
+A small world network is characterized by a small average shortest path length,
+and a large clustering coefficient.
+
+Small-worldness is commonly measured with the coefficient sigma or omega.
+
+Both coefficients compare the average clustering coefficient and shortest path
+length of a given graph against the same quantities for an equivalent random
+or lattice graph.
+
+For more information, see the Wikipedia article on small-world network [1]_.
+
+.. [1] Small-world network:: https://en.wikipedia.org/wiki/Small-world_network
+
+"""
+import networkx as nx
+from networkx.utils import not_implemented_for, py_random_state
+
+__all__ = ["random_reference", "lattice_reference", "sigma", "omega"]
+
+
+@py_random_state(3)
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def random_reference(G, niter=1, connectivity=True, seed=None):
+    """Compute a random graph by swapping edges of a given graph.
+
+    Parameters
+    ----------
+    G : graph
+        An undirected graph with 4 or more nodes.
+
+    niter : integer (optional, default=1)
+        An edge is rewired approximately `niter` times.
+
+    connectivity : boolean (optional, default=True)
+        When True, ensure connectivity for the randomized graph.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : graph
+        The randomized graph.
+
+    Notes
+    -----
+    The implementation is adapted from the algorithm by Maslov and Sneppen
+    (2002) [1]_.
+
+    References
+    ----------
+    .. [1] Maslov, Sergei, and Kim Sneppen.
+           "Specificity and stability in topology of protein networks."
+           Science 296.5569 (2002): 910-913.
+    """
+    if len(G) < 4:
+        raise nx.NetworkXError("Graph has less than four nodes.")
+
+    from networkx.utils import cumulative_distribution, discrete_sequence
+
+    local_conn = nx.connectivity.local_edge_connectivity
+
+    G = G.copy()
+    keys, degrees = zip(*G.degree())  # keys, degree
+    cdf = cumulative_distribution(degrees)  # cdf of degree
+    nnodes = len(G)
+    nedges = nx.number_of_edges(G)
+    niter = niter * nedges
+    ntries = int(nnodes * nedges / (nnodes * (nnodes - 1) / 2))
+    swapcount = 0
+
+    for i in range(niter):
+        n = 0
+        while n < ntries:
+            # pick two random edges without creating edge list
+            # choose source node indices from discrete distribution
+            (ai, ci) = discrete_sequence(2, cdistribution=cdf, seed=seed)
+            if ai == ci:
+                continue  # same source, skip
+            a = keys[ai]  # convert index to label
+            c = keys[ci]
+            # choose target uniformly from neighbors
+            b = seed.choice(list(G.neighbors(a)))
+            d = seed.choice(list(G.neighbors(c)))
+            if b in [a, c, d] or d in [a, b, c]:
+                continue  # all vertices should be different
+
+            # don't create parallel edges
+            if (d not in G[a]) and (b not in G[c]):
+                G.add_edge(a, d)
+                G.add_edge(c, b)
+                G.remove_edge(a, b)
+                G.remove_edge(c, d)
+
+                # Check if the graph is still connected
+                if connectivity and local_conn(G, a, b) == 0:
+                    # Not connected, revert the swap
+                    G.remove_edge(a, d)
+                    G.remove_edge(c, b)
+                    G.add_edge(a, b)
+                    G.add_edge(c, d)
+                else:
+                    swapcount += 1
+                    break
+            n += 1
+    return G
+
+
+@py_random_state(4)
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def lattice_reference(G, niter=5, D=None, connectivity=True, seed=None):
+    """Latticize the given graph by swapping edges.
+
+    Parameters
+    ----------
+    G : graph
+        An undirected graph with 4 or more nodes.
+
+    niter : integer (optional, default=1)
+        An edge is rewired approximatively niter times.
+
+    D : numpy.array (optional, default=None)
+        Distance to the diagonal matrix.
+
+    connectivity : boolean (optional, default=True)
+        Ensure connectivity for the latticized graph when set to True.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : graph
+        The latticized graph.
+
+    Notes
+    -----
+    The implementation is adapted from the algorithm by Sporns et al. [1]_.
+    which is inspired from the original work by Maslov and Sneppen(2002) [2]_.
+
+    References
+    ----------
+    .. [1] Sporns, Olaf, and Jonathan D. Zwi.
+       "The small world of the cerebral cortex."
+       Neuroinformatics 2.2 (2004): 145-162.
+    .. [2] Maslov, Sergei, and Kim Sneppen.
+       "Specificity and stability in topology of protein networks."
+       Science 296.5569 (2002): 910-913.
+    """
+    import numpy as np
+
+    from networkx.utils import cumulative_distribution, discrete_sequence
+
+    local_conn = nx.connectivity.local_edge_connectivity
+
+    if len(G) < 4:
+        raise nx.NetworkXError("Graph has less than four nodes.")
+    # Instead of choosing uniformly at random from a generated edge list,
+    # this algorithm chooses nonuniformly from the set of nodes with
+    # probability weighted by degree.
+    G = G.copy()
+    keys, degrees = zip(*G.degree())  # keys, degree
+    cdf = cumulative_distribution(degrees)  # cdf of degree
+
+    nnodes = len(G)
+    nedges = nx.number_of_edges(G)
+    if D is None:
+        D = np.zeros((nnodes, nnodes))
+        un = np.arange(1, nnodes)
+        um = np.arange(nnodes - 1, 0, -1)
+        u = np.append((0,), np.where(un < um, un, um))
+
+        for v in range(int(np.ceil(nnodes / 2))):
+            D[nnodes - v - 1, :] = np.append(u[v + 1 :], u[: v + 1])
+            D[v, :] = D[nnodes - v - 1, :][::-1]
+
+    niter = niter * nedges
+    # maximal number of rewiring attempts per 'niter'
+    max_attempts = int(nnodes * nedges / (nnodes * (nnodes - 1) / 2))
+
+    for _ in range(niter):
+        n = 0
+        while n < max_attempts:
+            # pick two random edges without creating edge list
+            # choose source node indices from discrete distribution
+            (ai, ci) = discrete_sequence(2, cdistribution=cdf, seed=seed)
+            if ai == ci:
+                continue  # same source, skip
+            a = keys[ai]  # convert index to label
+            c = keys[ci]
+            # choose target uniformly from neighbors
+            b = seed.choice(list(G.neighbors(a)))
+            d = seed.choice(list(G.neighbors(c)))
+            bi = keys.index(b)
+            di = keys.index(d)
+
+            if b in [a, c, d] or d in [a, b, c]:
+                continue  # all vertices should be different
+
+            # don't create parallel edges
+            if (d not in G[a]) and (b not in G[c]):
+                if D[ai, bi] + D[ci, di] >= D[ai, ci] + D[bi, di]:
+                    # only swap if we get closer to the diagonal
+                    G.add_edge(a, d)
+                    G.add_edge(c, b)
+                    G.remove_edge(a, b)
+                    G.remove_edge(c, d)
+
+                    # Check if the graph is still connected
+                    if connectivity and local_conn(G, a, b) == 0:
+                        # Not connected, revert the swap
+                        G.remove_edge(a, d)
+                        G.remove_edge(c, b)
+                        G.add_edge(a, b)
+                        G.add_edge(c, d)
+                    else:
+                        break
+            n += 1
+
+    return G
+
+
+@py_random_state(3)
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def sigma(G, niter=100, nrand=10, seed=None):
+    """Returns the small-world coefficient (sigma) of the given graph.
+
+    The small-world coefficient is defined as:
+    sigma = C/Cr / L/Lr
+    where C and L are respectively the average clustering coefficient and
+    average shortest path length of G. Cr and Lr are respectively the average
+    clustering coefficient and average shortest path length of an equivalent
+    random graph.
+
+    A graph is commonly classified as small-world if sigma>1.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+    niter : integer (optional, default=100)
+        Approximate number of rewiring per edge to compute the equivalent
+        random graph.
+    nrand : integer (optional, default=10)
+        Number of random graphs generated to compute the average clustering
+        coefficient (Cr) and average shortest path length (Lr).
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    sigma : float
+        The small-world coefficient of G.
+
+    Notes
+    -----
+    The implementation is adapted from Humphries et al. [1]_ [2]_.
+
+    References
+    ----------
+    .. [1] The brainstem reticular formation is a small-world, not scale-free,
+           network M. D. Humphries, K. Gurney and T. J. Prescott,
+           Proc. Roy. Soc. B 2006 273, 503-511, doi:10.1098/rspb.2005.3354.
+    .. [2] Humphries and Gurney (2008).
+           "Network 'Small-World-Ness': A Quantitative Method for Determining
+           Canonical Network Equivalence".
+           PLoS One. 3 (4). PMID 18446219. doi:10.1371/journal.pone.0002051.
+    """
+    import numpy as np
+
+    # Compute the mean clustering coefficient and average shortest path length
+    # for an equivalent random graph
+    randMetrics = {"C": [], "L": []}
+    for i in range(nrand):
+        Gr = random_reference(G, niter=niter, seed=seed)
+        randMetrics["C"].append(nx.transitivity(Gr))
+        randMetrics["L"].append(nx.average_shortest_path_length(Gr))
+
+    C = nx.transitivity(G)
+    L = nx.average_shortest_path_length(G)
+    Cr = np.mean(randMetrics["C"])
+    Lr = np.mean(randMetrics["L"])
+
+    sigma = (C / Cr) / (L / Lr)
+
+    return sigma
+
+
+@py_random_state(3)
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def omega(G, niter=5, nrand=10, seed=None):
+    """Returns the small-world coefficient (omega) of a graph
+
+    The small-world coefficient of a graph G is:
+
+    omega = Lr/L - C/Cl
+
+    where C and L are respectively the average clustering coefficient and
+    average shortest path length of G. Lr is the average shortest path length
+    of an equivalent random graph and Cl is the average clustering coefficient
+    of an equivalent lattice graph.
+
+    The small-world coefficient (omega) measures how much G is like a lattice
+    or a random graph. Negative values mean G is similar to a lattice whereas
+    positive values mean G is a random graph.
+    Values close to 0 mean that G has small-world characteristics.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+
+    niter: integer (optional, default=5)
+        Approximate number of rewiring per edge to compute the equivalent
+        random graph.
+
+    nrand: integer (optional, default=10)
+        Number of random graphs generated to compute the maximal clustering
+        coefficient (Cr) and average shortest path length (Lr).
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+
+    Returns
+    -------
+    omega : float
+        The small-world coefficient (omega)
+
+    Notes
+    -----
+    The implementation is adapted from the algorithm by Telesford et al. [1]_.
+
+    References
+    ----------
+    .. [1] Telesford, Joyce, Hayasaka, Burdette, and Laurienti (2011).
+           "The Ubiquity of Small-World Networks".
+           Brain Connectivity. 1 (0038): 367-75.  PMC 3604768. PMID 22432451.
+           doi:10.1089/brain.2011.0038.
+    """
+    import numpy as np
+
+    # Compute the mean clustering coefficient and average shortest path length
+    # for an equivalent random graph
+    randMetrics = {"C": [], "L": []}
+
+    # Calculate initial average clustering coefficient which potentially will
+    # get replaced by higher clustering coefficients from generated lattice
+    # reference graphs
+    Cl = nx.average_clustering(G)
+
+    niter_lattice_reference = niter
+    niter_random_reference = niter * 2
+
+    for _ in range(nrand):
+        # Generate random graph
+        Gr = random_reference(G, niter=niter_random_reference, seed=seed)
+        randMetrics["L"].append(nx.average_shortest_path_length(Gr))
+
+        # Generate lattice graph
+        Gl = lattice_reference(G, niter=niter_lattice_reference, seed=seed)
+
+        # Replace old clustering coefficient, if clustering is higher in
+        # generated lattice reference
+        Cl_temp = nx.average_clustering(Gl)
+        if Cl_temp > Cl:
+            Cl = Cl_temp
+
+    C = nx.average_clustering(G)
+    L = nx.average_shortest_path_length(G)
+    Lr = np.mean(randMetrics["L"])
+
+    omega = (Lr / L) - (C / Cl)
+
+    return omega
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/smetric.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/smetric.py
new file mode 100644
index 0000000..b851e1e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/smetric.py
@@ -0,0 +1,38 @@
+import networkx as nx
+
+__all__ = ["s_metric"]
+
+
+def s_metric(G, normalized=True):
+    """Returns the s-metric of graph.
+
+    The s-metric is defined as the sum of the products deg(u)*deg(v)
+    for every edge (u,v) in G. If norm is provided construct the
+    s-max graph and compute it's s_metric, and return the normalized
+    s value
+
+    Parameters
+    ----------
+    G    : graph
+           The graph used to compute the s-metric.
+    normalized : bool (optional)
+           Normalize the value.
+
+    Returns
+    -------
+    s : float
+        The s-metric of the graph.
+
+    References
+    ----------
+    .. [1] Lun Li, David Alderson, John C. Doyle, and Walter Willinger,
+           Towards a Theory of Scale-Free Graphs:
+           Definition, Properties, and  Implications (Extended Version), 2005.
+           https://arxiv.org/abs/cond-mat/0501169
+    """
+    if normalized:
+        raise nx.NetworkXError("Normalization not implemented")
+    #        Gmax = li_smax_graph(list(G.degree().values()))
+    #        return s_metric(G,normalized=False)/s_metric(Gmax,normalized=False)
+    #    else:
+    return float(sum(G.degree(u) * G.degree(v) for (u, v) in G.edges()))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/sparsifiers.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/sparsifiers.py
new file mode 100644
index 0000000..2c425d1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/sparsifiers.py
@@ -0,0 +1,294 @@
+"""Functions for computing sparsifiers of graphs."""
+import math
+
+import networkx as nx
+from networkx.utils import not_implemented_for, py_random_state
+
+__all__ = ["spanner"]
+
+
+@py_random_state(3)
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def spanner(G, stretch, weight=None, seed=None):
+    """Returns a spanner of the given graph with the given stretch.
+
+    A spanner of a graph G = (V, E) with stretch t is a subgraph
+    H = (V, E_S) such that E_S is a subset of E and the distance between
+    any pair of nodes in H is at most t times the distance between the
+    nodes in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected simple graph.
+
+    stretch : float
+        The stretch of the spanner.
+
+    weight : object
+        The edge attribute to use as distance.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    NetworkX graph
+        A spanner of the given graph with the given stretch.
+
+    Raises
+    ------
+    ValueError
+        If a stretch less than 1 is given.
+
+    Notes
+    -----
+    This function implements the spanner algorithm by Baswana and Sen,
+    see [1].
+
+    This algorithm is a randomized las vegas algorithm: The expected
+    running time is O(km) where k = (stretch + 1) // 2 and m is the
+    number of edges in G. The returned graph is always a spanner of the
+    given graph with the specified stretch. For weighted graphs the
+    number of edges in the spanner is O(k * n^(1 + 1 / k)) where k is
+    defined as above and n is the number of nodes in G. For unweighted
+    graphs the number of edges is O(n^(1 + 1 / k) + kn).
+
+    References
+    ----------
+    [1] S. Baswana, S. Sen. A Simple and Linear Time Randomized
+    Algorithm for Computing Sparse Spanners in Weighted Graphs.
+    Random Struct. Algorithms 30(4): 532-563 (2007).
+    """
+    if stretch < 1:
+        raise ValueError("stretch must be at least 1")
+
+    k = (stretch + 1) // 2
+
+    # initialize spanner H with empty edge set
+    H = nx.empty_graph()
+    H.add_nodes_from(G.nodes)
+
+    # phase 1: forming the clusters
+    # the residual graph has V' from the paper as its node set
+    # and E' from the paper as its edge set
+    residual_graph = _setup_residual_graph(G, weight)
+    # clustering is a dictionary that maps nodes in a cluster to the
+    # cluster center
+    clustering = {v: v for v in G.nodes}
+    sample_prob = math.pow(G.number_of_nodes(), -1 / k)
+    size_limit = 2 * math.pow(G.number_of_nodes(), 1 + 1 / k)
+
+    i = 0
+    while i < k - 1:
+        # step 1: sample centers
+        sampled_centers = set()
+        for center in set(clustering.values()):
+            if seed.random() < sample_prob:
+                sampled_centers.add(center)
+
+        # combined loop for steps 2 and 3
+        edges_to_add = set()
+        edges_to_remove = set()
+        new_clustering = {}
+        for v in residual_graph.nodes:
+            if clustering[v] in sampled_centers:
+                continue
+
+            # step 2: find neighboring (sampled) clusters and
+            # lightest edges to them
+            lightest_edge_neighbor, lightest_edge_weight = _lightest_edge_dicts(
+                residual_graph, clustering, v
+            )
+            neighboring_sampled_centers = (
+                set(lightest_edge_weight.keys()) & sampled_centers
+            )
+
+            # step 3: add edges to spanner
+            if not neighboring_sampled_centers:
+                # connect to each neighboring center via lightest edge
+                for neighbor in lightest_edge_neighbor.values():
+                    edges_to_add.add((v, neighbor))
+                # remove all incident edges
+                for neighbor in residual_graph.adj[v]:
+                    edges_to_remove.add((v, neighbor))
+
+            else:  # there is a neighboring sampled center
+                closest_center = min(
+                    neighboring_sampled_centers, key=lightest_edge_weight.get
+                )
+                closest_center_weight = lightest_edge_weight[closest_center]
+                closest_center_neighbor = lightest_edge_neighbor[closest_center]
+
+                edges_to_add.add((v, closest_center_neighbor))
+                new_clustering[v] = closest_center
+
+                # connect to centers with edge weight less than
+                # closest_center_weight
+                for center, edge_weight in lightest_edge_weight.items():
+                    if edge_weight < closest_center_weight:
+                        neighbor = lightest_edge_neighbor[center]
+                        edges_to_add.add((v, neighbor))
+
+                # remove edges to centers with edge weight less than
+                # closest_center_weight
+                for neighbor in residual_graph.adj[v]:
+                    neighbor_cluster = clustering[neighbor]
+                    neighbor_weight = lightest_edge_weight[neighbor_cluster]
+                    if (
+                        neighbor_cluster == closest_center
+                        or neighbor_weight < closest_center_weight
+                    ):
+                        edges_to_remove.add((v, neighbor))
+
+        # check whether iteration added too many edges to spanner,
+        # if so repeat
+        if len(edges_to_add) > size_limit:
+            # an iteration is repeated O(1) times on expectation
+            continue
+
+        # iteration succeeded
+        i = i + 1
+
+        # actually add edges to spanner
+        for u, v in edges_to_add:
+            _add_edge_to_spanner(H, residual_graph, u, v, weight)
+
+        # actually delete edges from residual graph
+        residual_graph.remove_edges_from(edges_to_remove)
+
+        # copy old clustering data to new_clustering
+        for node, center in clustering.items():
+            if center in sampled_centers:
+                new_clustering[node] = center
+        clustering = new_clustering
+
+        # step 4: remove intra-cluster edges
+        for u in residual_graph.nodes:
+            for v in list(residual_graph.adj[u]):
+                if clustering[u] == clustering[v]:
+                    residual_graph.remove_edge(u, v)
+
+        # update residual graph node set
+        for v in list(residual_graph.nodes):
+            if v not in clustering:
+                residual_graph.remove_node(v)
+
+    # phase 2: vertex-cluster joining
+    for v in residual_graph.nodes:
+        lightest_edge_neighbor, _ = _lightest_edge_dicts(residual_graph, clustering, v)
+        for neighbor in lightest_edge_neighbor.values():
+            _add_edge_to_spanner(H, residual_graph, v, neighbor, weight)
+
+    return H
+
+
+def _setup_residual_graph(G, weight):
+    """Setup residual graph as a copy of G with unique edges weights.
+
+    The node set of the residual graph corresponds to the set V' from
+    the Baswana-Sen paper and the edge set corresponds to the set E'
+    from the paper.
+
+    This function associates distinct weights to the edges of the
+    residual graph (even for unweighted input graphs), as required by
+    the algorithm.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected simple graph.
+
+    weight : object
+        The edge attribute to use as distance.
+
+    Returns
+    -------
+    NetworkX graph
+        The residual graph used for the Baswana-Sen algorithm.
+    """
+    residual_graph = G.copy()
+
+    # establish unique edge weights, even for unweighted graphs
+    for u, v in G.edges():
+        if not weight:
+            residual_graph[u][v]["weight"] = (id(u), id(v))
+        else:
+            residual_graph[u][v]["weight"] = (G[u][v][weight], id(u), id(v))
+
+    return residual_graph
+
+
+def _lightest_edge_dicts(residual_graph, clustering, node):
+    """Find the lightest edge to each cluster.
+
+    Searches for the minimum-weight edge to each cluster adjacent to
+    the given node.
+
+    Parameters
+    ----------
+    residual_graph : NetworkX graph
+        The residual graph used by the Baswana-Sen algorithm.
+
+    clustering : dictionary
+        The current clustering of the nodes.
+
+    node : node
+        The node from which the search originates.
+
+    Returns
+    -------
+    lightest_edge_neighbor, lightest_edge_weight : dictionary, dictionary
+        lightest_edge_neighbor is a dictionary that maps a center C to
+        a node v in the corresponding cluster such that the edge from
+        the given node to v is the lightest edge from the given node to
+        any node in cluster. lightest_edge_weight maps a center C to the
+        weight of the aforementioned edge.
+
+    Notes
+    -----
+    If a cluster has no node that is adjacent to the given node in the
+    residual graph then the center of the cluster is not a key in the
+    returned dictionaries.
+    """
+    lightest_edge_neighbor = {}
+    lightest_edge_weight = {}
+    for neighbor in residual_graph.adj[node]:
+        neighbor_center = clustering[neighbor]
+        weight = residual_graph[node][neighbor]["weight"]
+        if (
+            neighbor_center not in lightest_edge_weight
+            or weight < lightest_edge_weight[neighbor_center]
+        ):
+            lightest_edge_neighbor[neighbor_center] = neighbor
+            lightest_edge_weight[neighbor_center] = weight
+    return lightest_edge_neighbor, lightest_edge_weight
+
+
+def _add_edge_to_spanner(H, residual_graph, u, v, weight):
+    """Add the edge {u, v} to the spanner H and take weight from
+    the residual graph.
+
+    Parameters
+    ----------
+    H : NetworkX graph
+        The spanner under construction.
+
+    residual_graph : NetworkX graph
+        The residual graph used by the Baswana-Sen algorithm. The weight
+        for the edge is taken from this graph.
+
+    u : node
+        One endpoint of the edge.
+
+    v : node
+        The other endpoint of the edge.
+
+    weight : object
+        The edge attribute to use as distance.
+    """
+    H.add_edge(u, v)
+    if weight:
+        H[u][v][weight] = residual_graph[u][v]["weight"][0]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/structuralholes.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/structuralholes.py
new file mode 100644
index 0000000..55cdfe4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/structuralholes.py
@@ -0,0 +1,278 @@
+"""Functions for computing measures of structural holes."""
+
+import networkx as nx
+
+__all__ = ["constraint", "local_constraint", "effective_size"]
+
+
+def mutual_weight(G, u, v, weight=None):
+    """Returns the sum of the weights of the edge from `u` to `v` and
+    the edge from `v` to `u` in `G`.
+
+    `weight` is the edge data key that represents the edge weight. If
+    the specified key is `None` or is not in the edge data for an edge,
+    that edge is assumed to have weight 1.
+
+    Pre-conditions: `u` and `v` must both be in `G`.
+
+    """
+    try:
+        a_uv = G[u][v].get(weight, 1)
+    except KeyError:
+        a_uv = 0
+    try:
+        a_vu = G[v][u].get(weight, 1)
+    except KeyError:
+        a_vu = 0
+    return a_uv + a_vu
+
+
+def normalized_mutual_weight(G, u, v, norm=sum, weight=None):
+    """Returns normalized mutual weight of the edges from `u` to `v`
+    with respect to the mutual weights of the neighbors of `u` in `G`.
+
+    `norm` specifies how the normalization factor is computed. It must
+    be a function that takes a single argument and returns a number.
+    The argument will be an iterable of mutual weights
+    of pairs ``(u, w)``, where ``w`` ranges over each (in- and
+    out-)neighbor of ``u``. Commons values for `normalization` are
+    ``sum`` and ``max``.
+
+    `weight` can be ``None`` or a string, if None, all edge weights
+    are considered equal. Otherwise holds the name of the edge
+    attribute used as weight.
+
+    """
+    scale = norm(mutual_weight(G, u, w, weight) for w in set(nx.all_neighbors(G, u)))
+    return 0 if scale == 0 else mutual_weight(G, u, v, weight) / scale
+
+
+def effective_size(G, nodes=None, weight=None):
+    r"""Returns the effective size of all nodes in the graph ``G``.
+
+    The *effective size* of a node's ego network is based on the concept
+    of redundancy. A person's ego network has redundancy to the extent
+    that her contacts are connected to each other as well. The
+    nonredundant part of a person's relationships it's the effective
+    size of her ego network [1]_.  Formally, the effective size of a
+    node $u$, denoted $e(u)$, is defined by
+
+    .. math::
+
+       e(u) = \sum_{v \in N(u) \setminus \{u\}}
+       \left(1 - \sum_{w \in N(v)} p_{uw} m_{vw}\right)
+
+    where $N(u)$ is the set of neighbors of $u$ and $p_{uw}$ is the
+    normalized mutual weight of the (directed or undirected) edges
+    joining $u$ and $v$, for each vertex $u$ and $v$ [1]_. And $m_{vw}$
+    is the mutual weight of $v$ and $w$ divided by $v$ highest mutual
+    weight with any of its neighbors. The *mutual weight* of $u$ and $v$
+    is the sum of the weights of edges joining them (edge weights are
+    assumed to be one if the graph is unweighted).
+
+    For the case of unweighted and undirected graphs, Borgatti proposed
+    a simplified formula to compute effective size [2]_
+
+    .. math::
+
+       e(u) = n - \frac{2t}{n}
+
+    where `t` is the number of ties in the ego network (not including
+    ties to ego) and `n` is the number of nodes (excluding ego).
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The graph containing ``v``. Directed graphs are treated like
+        undirected graphs when computing neighbors of ``v``.
+
+    nodes : container, optional
+        Container of nodes in the graph ``G`` to compute the effective size.
+        If None, the effective size of every node is computed.
+
+    weight : None or string, optional
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+
+    Returns
+    -------
+    dict
+        Dictionary with nodes as keys and the effective size of the node as values.
+
+    Notes
+    -----
+    Burt also defined the related concept of *efficiency* of a node's ego
+    network, which is its effective size divided by the degree of that
+    node [1]_. So you can easily compute efficiency:
+
+    >>> G = nx.DiGraph()
+    >>> G.add_edges_from([(0, 1), (0, 2), (1, 0), (2, 1)])
+    >>> esize = nx.effective_size(G)
+    >>> efficiency = {n: v / G.degree(n) for n, v in esize.items()}
+
+    See also
+    --------
+    constraint
+
+    References
+    ----------
+    .. [1] Burt, Ronald S.
+           *Structural Holes: The Social Structure of Competition.*
+           Cambridge: Harvard University Press, 1995.
+
+    .. [2] Borgatti, S.
+           "Structural Holes: Unpacking Burt's Redundancy Measures"
+           CONNECTIONS 20(1):35-38.
+           http://www.analytictech.com/connections/v20(1)/holes.htm
+
+    """
+
+    def redundancy(G, u, v, weight=None):
+        nmw = normalized_mutual_weight
+        r = sum(
+            nmw(G, u, w, weight=weight) * nmw(G, v, w, norm=max, weight=weight)
+            for w in set(nx.all_neighbors(G, u))
+        )
+        return 1 - r
+
+    effective_size = {}
+    if nodes is None:
+        nodes = G
+    # Use Borgatti's simplified formula for unweighted and undirected graphs
+    if not G.is_directed() and weight is None:
+        for v in nodes:
+            # Effective size is not defined for isolated nodes
+            if len(G[v]) == 0:
+                effective_size[v] = float("nan")
+                continue
+            E = nx.ego_graph(G, v, center=False, undirected=True)
+            effective_size[v] = len(E) - (2 * E.size()) / len(E)
+    else:
+        for v in nodes:
+            # Effective size is not defined for isolated nodes
+            if len(G[v]) == 0:
+                effective_size[v] = float("nan")
+                continue
+            effective_size[v] = sum(
+                redundancy(G, v, u, weight) for u in set(nx.all_neighbors(G, v))
+            )
+    return effective_size
+
+
+def constraint(G, nodes=None, weight=None):
+    r"""Returns the constraint on all nodes in the graph ``G``.
+
+    The *constraint* is a measure of the extent to which a node *v* is
+    invested in those nodes that are themselves invested in the
+    neighbors of *v*. Formally, the *constraint on v*, denoted `c(v)`,
+    is defined by
+
+    .. math::
+
+       c(v) = \sum_{w \in N(v) \setminus \{v\}} \ell(v, w)
+
+    where $N(v)$ is the subset of the neighbors of `v` that are either
+    predecessors or successors of `v` and $\ell(v, w)$ is the local
+    constraint on `v` with respect to `w` [1]_. For the definition of local
+    constraint, see :func:`local_constraint`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The graph containing ``v``. This can be either directed or undirected.
+
+    nodes : container, optional
+        Container of nodes in the graph ``G`` to compute the constraint. If
+        None, the constraint of every node is computed.
+
+    weight : None or string, optional
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+
+    Returns
+    -------
+    dict
+        Dictionary with nodes as keys and the constraint on the node as values.
+
+    See also
+    --------
+    local_constraint
+
+    References
+    ----------
+    .. [1] Burt, Ronald S.
+           "Structural holes and good ideas".
+           American Journal of Sociology (110): 349–399.
+
+    """
+    if nodes is None:
+        nodes = G
+    constraint = {}
+    for v in nodes:
+        # Constraint is not defined for isolated nodes
+        if len(G[v]) == 0:
+            constraint[v] = float("nan")
+            continue
+        constraint[v] = sum(
+            local_constraint(G, v, n, weight) for n in set(nx.all_neighbors(G, v))
+        )
+    return constraint
+
+
+def local_constraint(G, u, v, weight=None):
+    r"""Returns the local constraint on the node ``u`` with respect to
+    the node ``v`` in the graph ``G``.
+
+    Formally, the *local constraint on u with respect to v*, denoted
+    $\ell(v)$, is defined by
+
+    .. math::
+
+       \ell(u, v) = \left(p_{uv} + \sum_{w \in N(v)} p_{uw} p_{wv}\right)^2,
+
+    where $N(v)$ is the set of neighbors of $v$ and $p_{uv}$ is the
+    normalized mutual weight of the (directed or undirected) edges
+    joining $u$ and $v$, for each vertex $u$ and $v$ [1]_. The *mutual
+    weight* of $u$ and $v$ is the sum of the weights of edges joining
+    them (edge weights are assumed to be one if the graph is
+    unweighted).
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The graph containing ``u`` and ``v``. This can be either
+        directed or undirected.
+
+    u : node
+        A node in the graph ``G``.
+
+    v : node
+        A node in the graph ``G``.
+
+    weight : None or string, optional
+      If None, all edge weights are considered equal.
+      Otherwise holds the name of the edge attribute used as weight.
+
+    Returns
+    -------
+    float
+        The constraint of the node ``v`` in the graph ``G``.
+
+    See also
+    --------
+    constraint
+
+    References
+    ----------
+    .. [1] Burt, Ronald S.
+           "Structural holes and good ideas".
+           American Journal of Sociology (110): 349–399.
+
+    """
+    nmw = normalized_mutual_weight
+    direct = nmw(G, u, v, weight=weight)
+    indirect = sum(
+        nmw(G, u, w, weight=weight) * nmw(G, w, v, weight=weight)
+        for w in set(nx.all_neighbors(G, u))
+    )
+    return (direct + indirect) ** 2
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/summarization.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/summarization.py
new file mode 100644
index 0000000..16c7e62
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/summarization.py
@@ -0,0 +1,556 @@
+"""
+Graph summarization finds smaller representations of graphs resulting in faster
+runtime of algorithms, reduced storage needs, and noise reduction.
+Summarization has applications in areas such as visualization, pattern mining,
+clustering and community detection, and more.  Core graph summarization
+techniques are grouping/aggregation, bit-compression,
+simplification/sparsification, and influence based. Graph summarization
+algorithms often produce either summary graphs in the form of supergraphs or
+sparsified graphs, or a list of independent structures. Supergraphs are the
+most common product, which consist of supernodes and original nodes and are
+connected by edges and superedges, which represent aggregate edges between
+nodes and supernodes.
+
+Grouping/aggregation based techniques compress graphs by representing
+close/connected nodes and edges in a graph by a single node/edge in a
+supergraph. Nodes can be grouped together into supernodes based on their
+structural similarities or proximity within a graph to reduce the total number
+of nodes in a graph. Edge-grouping techniques group edges into lossy/lossless
+nodes called compressor or virtual nodes to reduce the total number of edges in
+a graph. Edge-grouping techniques can be lossless, meaning that they can be
+used to re-create the original graph, or techniques can be lossy, requiring
+less space to store the summary graph, but at the expense of lower
+recontruction accuracy of the original graph.
+
+Bit-compression techniques minimize the amount of information needed to
+describe the original graph, while revealing structural patterns in the
+original graph.  The two-part minimum description length (MDL) is often used to
+represent the model and the original graph in terms of the model.  A key
+difference between graph compression and graph summarization is that graph
+summarization focuses on finding structural patterns within the original graph,
+whereas graph compression focuses on compressions the original graph to be as
+small as possible.  **NOTE**: Some bit-compression methods exist solely to
+compress a graph without creating a summary graph or finding comprehensible
+structural patterns.
+
+Simplification/Sparsification techniques attempt to create a sparse
+representation of a graph by removing unimportant nodes and edges from the
+graph.  Sparsified graphs differ from supergraphs created by
+grouping/aggregation by only containing a subset of the original nodes and
+edges of the original graph.
+
+Influence based techniques aim to find a high-level description of influence
+propagation in a large graph.  These methods are scarce and have been mostly
+applied to social graphs.
+
+*dedensification* is a grouping/aggregation based technique to compress the
+neighborhoods around high-degree nodes in unweighted graphs by adding
+compressor nodes that summarize multiple edges of the same type to
+high-degree nodes (nodes with a degree greater than a given threshold).
+Dedensification was developed for the purpose of increasing performance of
+query processing around high-degree nodes in graph databases and enables direct
+operations on the compressed graph.  The structural patterns surrounding
+high-degree nodes in the original is preserved while using fewer edges and
+adding a small number of compressor nodes.  The degree of nodes present in the
+original graph is also preserved. The current implementation of dedensification
+supports graphs with one edge type.
+
+For more information on graph summarization, see `Graph Summarization Methods
+and Applications: A Survey <https://dl.acm.org/doi/abs/10.1145/3186727>`_
+"""
+from collections import Counter, defaultdict
+
+import networkx as nx
+
+__all__ = ["dedensify", "snap_aggregation"]
+
+
+def dedensify(G, threshold, prefix=None, copy=True):
+    """Compresses neighborhoods around high-degree nodes
+
+    Reduces the number of edges to high-degree nodes by adding compressor nodes
+    that summarize multiple edges of the same type to high-degree nodes (nodes
+    with a degree greater than a given threshold).  Dedensification also has
+    the added benefit of reducing the number of edges around high-degree nodes.
+    The implementation currently supports graphs with a single edge type.
+
+    Parameters
+    ----------
+    G: graph
+       A networkx graph
+    threshold: int
+       Minimum degree threshold of a node to be considered a high degree node.
+       The threshold must be greater than or equal to 2.
+    prefix: str or None, optional (default: None)
+       An optional prefix for denoting compressor nodes
+    copy: bool, optional (default: True)
+       Indicates if dedensification should be done inplace
+
+    Returns
+    -------
+    dedensified networkx graph : (graph, set)
+        2-tuple of the dedensified graph and set of compressor nodes
+
+    Notes
+    -----
+    According to the algorithm in [1]_, removes edges in a graph by
+    compressing/decompressing the neighborhoods around high degree nodes by
+    adding compressor nodes that summarize multiple edges of the same type
+    to high-degree nodes.  Dedensification will only add a compressor node when
+    doing so will reduce the total number of edges in the given graph. This
+    implementation currently supports graphs with a single edge type.
+
+    Examples
+    --------
+    Dedensification will only add compressor nodes when doing so would result
+    in fewer edges::
+
+        >>> original_graph = nx.DiGraph()
+        >>> original_graph.add_nodes_from(
+        ...     ["1", "2", "3", "4", "5", "6", "A", "B", "C"]
+        ... )
+        >>> original_graph.add_edges_from(
+        ...     [
+        ...         ("1", "C"), ("1", "B"),
+        ...         ("2", "C"), ("2", "B"), ("2", "A"),
+        ...         ("3", "B"), ("3", "A"), ("3", "6"),
+        ...         ("4", "C"), ("4", "B"), ("4", "A"),
+        ...         ("5", "B"), ("5", "A"),
+        ...         ("6", "5"),
+        ...         ("A", "6")
+        ...     ]
+        ... )
+        >>> c_graph, c_nodes = nx.dedensify(original_graph, threshold=2)
+        >>> original_graph.number_of_edges()
+        15
+        >>> c_graph.number_of_edges()
+        14
+
+    A dedensified, directed graph can be "densified" to reconstruct the
+    original graph::
+
+        >>> original_graph = nx.DiGraph()
+        >>> original_graph.add_nodes_from(
+        ...     ["1", "2", "3", "4", "5", "6", "A", "B", "C"]
+        ... )
+        >>> original_graph.add_edges_from(
+        ...     [
+        ...         ("1", "C"), ("1", "B"),
+        ...         ("2", "C"), ("2", "B"), ("2", "A"),
+        ...         ("3", "B"), ("3", "A"), ("3", "6"),
+        ...         ("4", "C"), ("4", "B"), ("4", "A"),
+        ...         ("5", "B"), ("5", "A"),
+        ...         ("6", "5"),
+        ...         ("A", "6")
+        ...     ]
+        ... )
+        >>> c_graph, c_nodes = nx.dedensify(original_graph, threshold=2)
+        >>> # re-densifies the compressed graph into the original graph
+        >>> for c_node in c_nodes:
+        ...     all_neighbors = set(nx.all_neighbors(c_graph, c_node))
+        ...     out_neighbors = set(c_graph.neighbors(c_node))
+        ...     for out_neighbor in out_neighbors:
+        ...         c_graph.remove_edge(c_node, out_neighbor)
+        ...     in_neighbors = all_neighbors - out_neighbors
+        ...     for in_neighbor in in_neighbors:
+        ...         c_graph.remove_edge(in_neighbor, c_node)
+        ...         for out_neighbor in out_neighbors:
+        ...             c_graph.add_edge(in_neighbor, out_neighbor)
+        ...     c_graph.remove_node(c_node)
+        ...
+        >>> nx.is_isomorphic(original_graph, c_graph)
+        True
+
+    References
+    ----------
+    .. [1] Maccioni, A., & Abadi, D. J. (2016, August).
+       Scalable pattern matching over compressed graphs via dedensification.
+       In Proceedings of the 22nd ACM SIGKDD International Conference on
+       Knowledge Discovery and Data Mining (pp. 1755-1764).
+       http://www.cs.umd.edu/~abadi/papers/graph-dedense.pdf
+    """
+    if threshold < 2:
+        raise nx.NetworkXError("The degree threshold must be >= 2")
+
+    degrees = G.in_degree if G.is_directed() else G.degree
+    # Group nodes based on degree threshold
+    high_degree_nodes = {n for n, d in degrees if d > threshold}
+    low_degree_nodes = G.nodes() - high_degree_nodes
+
+    auxillary = {}
+    for node in G:
+        high_degree_neighbors = frozenset(high_degree_nodes & set(G[node]))
+        if high_degree_neighbors:
+            if high_degree_neighbors in auxillary:
+                auxillary[high_degree_neighbors].add(node)
+            else:
+                auxillary[high_degree_neighbors] = {node}
+
+    if copy:
+        G = G.copy()
+
+    compressor_nodes = set()
+    for index, (high_degree_nodes, low_degree_nodes) in enumerate(auxillary.items()):
+        low_degree_node_count = len(low_degree_nodes)
+        high_degree_node_count = len(high_degree_nodes)
+        old_edges = high_degree_node_count * low_degree_node_count
+        new_edges = high_degree_node_count + low_degree_node_count
+        if old_edges <= new_edges:
+            continue
+        compression_node = "".join(str(node) for node in high_degree_nodes)
+        if prefix:
+            compression_node = str(prefix) + compression_node
+        for node in low_degree_nodes:
+            for high_node in high_degree_nodes:
+                if G.has_edge(node, high_node):
+                    G.remove_edge(node, high_node)
+
+            G.add_edge(node, compression_node)
+        for node in high_degree_nodes:
+            G.add_edge(compression_node, node)
+        compressor_nodes.add(compression_node)
+    return G, compressor_nodes
+
+
+def _snap_build_graph(
+    G,
+    groups,
+    node_attributes,
+    edge_attributes,
+    neighbor_info,
+    edge_types,
+    prefix,
+    supernode_attribute,
+    superedge_attribute,
+):
+    """
+    Build the summary graph from the data structures produced in the SNAP aggregation algorithm
+
+    Used in the SNAP aggregation algorithm to build the output summary graph and supernode
+    lookup dictionary.  This process uses the original graph and the data structures to
+    create the supernodes with the correct node attributes, and the superedges with the correct
+    edge attributes
+
+    Parameters
+    ----------
+    G: networkx.Graph
+        the original graph to be summarized
+    groups: dict
+        A dictionary of unique group IDs and their corresponding node groups
+    node_attributes: iterable
+        An iterable of the node attributes considered in the summarization process
+    edge_attributes: iterable
+        An iterable of the edge attributes considered in the summarization process
+    neighbor_info: dict
+        A data structure indicating the number of edges a node has with the
+        groups in the current summarization of each edge type
+    edge_types: dict
+        dictionary of edges in the graph and their corresponding attributes recognized
+        in the summarization
+    prefix: string
+        The prefix to be added to all supernodes
+    supernode_attribute: str
+        The node attribute for recording the supernode groupings of nodes
+    superedge_attribute: str
+        The edge attribute for recording the edge types represented by superedges
+
+    Returns
+    -------
+    summary graph: Networkx graph
+    """
+    output = G.__class__()
+    node_label_lookup = dict()
+    for index, group_id in enumerate(groups):
+        group_set = groups[group_id]
+        supernode = f"{prefix}{index}"
+        node_label_lookup[group_id] = supernode
+        supernode_attributes = {
+            attr: G.nodes[next(iter(group_set))][attr] for attr in node_attributes
+        }
+        supernode_attributes[supernode_attribute] = group_set
+        output.add_node(supernode, **supernode_attributes)
+
+    for group_id in groups:
+        group_set = groups[group_id]
+        source_supernode = node_label_lookup[group_id]
+        for other_group, group_edge_types in neighbor_info[
+            next(iter(group_set))
+        ].items():
+            if group_edge_types:
+                target_supernode = node_label_lookup[other_group]
+                summary_graph_edge = (source_supernode, target_supernode)
+
+                edge_types = [
+                    dict(zip(edge_attributes, edge_type))
+                    for edge_type in group_edge_types
+                ]
+
+                has_edge = output.has_edge(*summary_graph_edge)
+                if output.is_multigraph():
+                    if not has_edge:
+                        for edge_type in edge_types:
+                            output.add_edge(*summary_graph_edge, **edge_type)
+                    elif not output.is_directed():
+                        existing_edge_data = output.get_edge_data(*summary_graph_edge)
+                        for edge_type in edge_types:
+                            if edge_type not in existing_edge_data.values():
+                                output.add_edge(*summary_graph_edge, **edge_type)
+                else:
+                    superedge_attributes = {superedge_attribute: edge_types}
+                    output.add_edge(*summary_graph_edge, **superedge_attributes)
+
+    return output
+
+
+def _snap_eligible_group(G, groups, group_lookup, edge_types):
+    """
+    Determines if a group is eligible to be split.
+
+    A group is eligible to be split if all nodes in the group have edges of the same type(s)
+    with the same other groups.
+
+    Parameters
+    ----------
+    G: graph
+        graph to be summarized
+    groups: dict
+        A dictionary of unique group IDs and their corresponding node groups
+    group_lookup: dict
+        dictionary of nodes and their current corresponding group ID
+    edge_types: dict
+        dictionary of edges in the graph and their corresponding attributes recognized
+        in the summarization
+
+    Returns
+    -------
+    tuple: group ID to split, and neighbor-groups participation_counts data structure
+    """
+    neighbor_info = {node: {gid: Counter() for gid in groups} for node in group_lookup}
+    for group_id in groups:
+        current_group = groups[group_id]
+
+        # build neighbor_info for nodes in group
+        for node in current_group:
+            neighbor_info[node] = {group_id: Counter() for group_id in groups}
+            edges = G.edges(node, keys=True) if G.is_multigraph() else G.edges(node)
+            for edge in edges:
+                neighbor = edge[1]
+                edge_type = edge_types[edge]
+                neighbor_group_id = group_lookup[neighbor]
+                neighbor_info[node][neighbor_group_id][edge_type] += 1
+
+        # check if group_id is eligible to be split
+        group_size = len(current_group)
+        for other_group_id in groups:
+            edge_counts = Counter()
+            for node in current_group:
+                edge_counts.update(neighbor_info[node][other_group_id].keys())
+
+            if not all(count == group_size for count in edge_counts.values()):
+                # only the neighbor_info of the returned group_id is required for handling group splits
+                return group_id, neighbor_info
+
+    # if no eligible groups, complete neighbor_info is calculated
+    return None, neighbor_info
+
+
+def _snap_split(groups, neighbor_info, group_lookup, group_id):
+    """
+    Splits a group based on edge types and updates the groups accordingly
+
+    Splits the group with the given group_id based on the edge types
+    of the nodes so that each new grouping will all have the same
+    edges with other nodes.
+
+    Parameters
+    ----------
+    groups: dict
+        A dictionary of unique group IDs and their corresponding node groups
+    neighbor_info: dict
+        A data structure indicating the number of edges a node has with the
+        groups in the current summarization of each edge type
+    edge_types: dict
+        dictionary of edges in the graph and their corresponding attributes recognized
+        in the summarization
+    group_lookup: dict
+        dictionary of nodes and their current corresponding group ID
+    group_id: object
+        ID of group to be split
+
+    Returns
+    -------
+    dict
+        The updated groups based on the split
+    """
+    new_group_mappings = defaultdict(set)
+    for node in groups[group_id]:
+        signature = tuple(
+            frozenset(edge_types) for edge_types in neighbor_info[node].values()
+        )
+        new_group_mappings[signature].add(node)
+
+    # leave the biggest new_group as the original group
+    new_groups = sorted(new_group_mappings.values(), key=len)
+    for new_group in new_groups[:-1]:
+        # Assign unused integer as the new_group_id
+        # ids are tuples, so will not interact with the original group_ids
+        new_group_id = len(groups)
+        groups[new_group_id] = new_group
+        groups[group_id] -= new_group
+        for node in new_group:
+            group_lookup[node] = new_group_id
+
+    return groups
+
+
+def snap_aggregation(
+    G,
+    node_attributes,
+    edge_attributes=(),
+    prefix="Supernode-",
+    supernode_attribute="group",
+    superedge_attribute="types",
+):
+    """Creates a summary graph based on attributes and connectivity.
+
+    This function uses the Summarization by Grouping Nodes on Attributes
+    and Pairwise edges (SNAP) algorithm for summarizing a given
+    graph by grouping nodes by node attributes and their edge attributes
+    into supernodes in a summary graph.  This name SNAP should not be
+    confused with the Stanford Network Analysis Project (SNAP).
+
+    Here is a high-level view of how this algorithm works:
+
+    1) Group nodes by node attribute values.
+
+    2) Iteratively split groups until all nodes in each group have edges
+    to nodes in the same groups. That is, until all the groups are homogeneous
+    in their member nodes' edges to other groups.  For example,
+    if all the nodes in group A only have edge to nodes in group B, then the
+    group is homogeneous and does not need to be split. If all nodes in group B
+    have edges with nodes in groups {A, C}, but some also have edges with other
+    nodes in B, then group B is not homogeneous and needs to be split into
+    groups have edges with {A, C} and a group of nodes having
+    edges with {A, B, C}.  This way, viewers of the summary graph can
+    assume that all nodes in the group have the exact same node attributes and
+    the exact same edges.
+
+    3) Build the output summary graph, where the groups are represented by
+    super-nodes. Edges represent the edges shared between all the nodes in each
+    respective groups.
+
+    A SNAP summary graph can be used to visualize graphs that are too large to display
+    or visually analyze, or to efficiently identify sets of similar nodes with similar connectivity
+    patterns to other sets of similar nodes based on specified node and/or edge attributes in a graph.
+
+    Parameters
+    ----------
+    G: graph
+        Networkx Graph to be summarized
+    edge_attributes: iterable, optional
+        An iterable of the edge attributes considered in the summarization process.  If provided, unique
+        combinations of the attribute values found in the graph are used to
+        determine the edge types in the graph.  If not provided, all edges
+        are considered to be of the same type.
+    prefix: str
+        The prefix used to denote supernodes in the summary graph. Defaults to 'Supernode-'.
+    supernode_attribute: str
+        The node attribute for recording the supernode groupings of nodes. Defaults to 'group'.
+    superedge_attribute: str
+        The edge attribute for recording the edge types of multiple edges. Defaults to 'types'.
+
+    Returns
+    -------
+    networkx.Graph: summary graph
+
+    Examples
+    --------
+    SNAP aggregation takes a graph and summarizes it in the context of user-provided
+    node and edge attributes such that a viewer can more easily extract and
+    analyze the information represented by the graph
+
+    >>> nodes = {
+    ...     "A": dict(color="Red"),
+    ...     "B": dict(color="Red"),
+    ...     "C": dict(color="Red"),
+    ...     "D": dict(color="Red"),
+    ...     "E": dict(color="Blue"),
+    ...     "F": dict(color="Blue"),
+    ... }
+    >>> edges = [
+    ...     ("A", "E", "Strong"),
+    ...     ("B", "F", "Strong"),
+    ...     ("C", "E", "Weak"),
+    ...     ("D", "F", "Weak"),
+    ... ]
+    >>> G = nx.Graph()
+    >>> for node in nodes:
+    ...     attributes = nodes[node]
+    ...     G.add_node(node, **attributes)
+    ...
+    >>> for source, target, type in edges:
+    ...     G.add_edge(source, target, type=type)
+    ...
+    >>> node_attributes = ('color', )
+    >>> edge_attributes = ('type', )
+    >>> summary_graph = nx.snap_aggregation(G, node_attributes=node_attributes, edge_attributes=edge_attributes)
+
+    Notes
+    -----
+    The summary graph produced is called a maximum Attribute-edge
+    compatible (AR-compatible) grouping.  According to [1]_, an
+    AR-compatible grouping means that all nodes in each group have the same
+    exact node attribute values and the same exact edges and
+    edge types to one or more nodes in the same groups.  The maximal
+    AR-compatible grouping is the grouping with the minimal cardinality.
+
+    The AR-compatible grouping is the most detailed grouping provided by
+    any of the SNAP algorithms.
+
+    References
+    ----------
+    .. [1] Y. Tian, R. A. Hankins, and J. M. Patel. Efficient aggregation
+       for graph summarization. In Proc. 2008 ACM-SIGMOD Int. Conf.
+       Management of Data (SIGMOD’08), pages 567–580, Vancouver, Canada,
+       June 2008.
+    """
+    edge_types = {
+        edge: tuple(attrs.get(attr) for attr in edge_attributes)
+        for edge, attrs in G.edges.items()
+    }
+    if not G.is_directed():
+        if G.is_multigraph():
+            # list is needed to avoid mutating while iterating
+            edges = [((v, u, k), etype) for (u, v, k), etype in edge_types.items()]
+        else:
+            # list is needed to avoid mutating while iterating
+            edges = [((v, u), etype) for (u, v), etype in edge_types.items()]
+        edge_types.update(edges)
+
+    group_lookup = {
+        node: tuple(attrs[attr] for attr in node_attributes)
+        for node, attrs in G.nodes.items()
+    }
+    groups = defaultdict(set)
+    for node, node_type in group_lookup.items():
+        groups[node_type].add(node)
+
+    eligible_group_id, neighbor_info = _snap_eligible_group(
+        G, groups, group_lookup, edge_types
+    )
+    while eligible_group_id:
+        groups = _snap_split(groups, neighbor_info, group_lookup, eligible_group_id)
+        eligible_group_id, neighbor_info = _snap_eligible_group(
+            G, groups, group_lookup, edge_types
+        )
+    return _snap_build_graph(
+        G,
+        groups,
+        node_attributes,
+        edge_attributes,
+        neighbor_info,
+        edge_types,
+        prefix,
+        supernode_attribute,
+        superedge_attribute,
+    )
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/swap.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/swap.py
new file mode 100644
index 0000000..26a1f31
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/swap.py
@@ -0,0 +1,269 @@
+"""Swap edges in a graph.
+"""
+
+import math
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = ["double_edge_swap", "connected_double_edge_swap"]
+
+
+@py_random_state(3)
+def double_edge_swap(G, nswap=1, max_tries=100, seed=None):
+    """Swap two edges in the graph while keeping the node degrees fixed.
+
+    A double-edge swap removes two randomly chosen edges u-v and x-y
+    and creates the new edges u-x and v-y::
+
+     u--v            u  v
+            becomes  |  |
+     x--y            x  y
+
+    If either the edge u-x or v-y already exist no swap is performed
+    and another attempt is made to find a suitable edge pair.
+
+    Parameters
+    ----------
+    G : graph
+       An undirected graph
+
+    nswap : integer (optional, default=1)
+       Number of double-edge swaps to perform
+
+    max_tries : integer (optional)
+       Maximum number of attempts to swap edges
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : graph
+       The graph after double edge swaps.
+
+    Notes
+    -----
+    Does not enforce any connectivity constraints.
+
+    The graph G is modified in place.
+    """
+    if G.is_directed():
+        raise nx.NetworkXError("double_edge_swap() not defined for directed graphs.")
+    if nswap > max_tries:
+        raise nx.NetworkXError("Number of swaps > number of tries allowed.")
+    if len(G) < 4:
+        raise nx.NetworkXError("Graph has less than four nodes.")
+    # Instead of choosing uniformly at random from a generated edge list,
+    # this algorithm chooses nonuniformly from the set of nodes with
+    # probability weighted by degree.
+    n = 0
+    swapcount = 0
+    keys, degrees = zip(*G.degree())  # keys, degree
+    cdf = nx.utils.cumulative_distribution(degrees)  # cdf of degree
+    discrete_sequence = nx.utils.discrete_sequence
+    while swapcount < nswap:
+        #        if random.random() < 0.5: continue # trick to avoid periodicities?
+        # pick two random edges without creating edge list
+        # choose source node indices from discrete distribution
+        (ui, xi) = discrete_sequence(2, cdistribution=cdf, seed=seed)
+        if ui == xi:
+            continue  # same source, skip
+        u = keys[ui]  # convert index to label
+        x = keys[xi]
+        # choose target uniformly from neighbors
+        v = seed.choice(list(G[u]))
+        y = seed.choice(list(G[x]))
+        if v == y:
+            continue  # same target, skip
+        if (x not in G[u]) and (y not in G[v]):  # don't create parallel edges
+            G.add_edge(u, x)
+            G.add_edge(v, y)
+            G.remove_edge(u, v)
+            G.remove_edge(x, y)
+            swapcount += 1
+        if n >= max_tries:
+            e = (
+                f"Maximum number of swap attempts ({n}) exceeded "
+                f"before desired swaps achieved ({nswap})."
+            )
+            raise nx.NetworkXAlgorithmError(e)
+        n += 1
+    return G
+
+
+@py_random_state(3)
+def connected_double_edge_swap(G, nswap=1, _window_threshold=3, seed=None):
+    """Attempts the specified number of double-edge swaps in the graph `G`.
+
+    A double-edge swap removes two randomly chosen edges `(u, v)` and `(x,
+    y)` and creates the new edges `(u, x)` and `(v, y)`::
+
+     u--v            u  v
+            becomes  |  |
+     x--y            x  y
+
+    If either `(u, x)` or `(v, y)` already exist, then no swap is performed
+    so the actual number of swapped edges is always *at most* `nswap`.
+
+    Parameters
+    ----------
+    G : graph
+       An undirected graph
+
+    nswap : integer (optional, default=1)
+       Number of double-edge swaps to perform
+
+    _window_threshold : integer
+
+       The window size below which connectedness of the graph will be checked
+       after each swap.
+
+       The "window" in this function is a dynamically updated integer that
+       represents the number of swap attempts to make before checking if the
+       graph remains connected. It is an optimization used to decrease the
+       running time of the algorithm in exchange for increased complexity of
+       implementation.
+
+       If the window size is below this threshold, then the algorithm checks
+       after each swap if the graph remains connected by checking if there is a
+       path joining the two nodes whose edge was just removed. If the window
+       size is above this threshold, then the algorithm performs do all the
+       swaps in the window and only then check if the graph is still connected.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    int
+       The number of successful swaps
+
+    Raises
+    ------
+
+    NetworkXError
+
+       If the input graph is not connected, or if the graph has fewer than four
+       nodes.
+
+    Notes
+    -----
+
+    The initial graph `G` must be connected, and the resulting graph is
+    connected. The graph `G` is modified in place.
+
+    References
+    ----------
+    .. [1] C. Gkantsidis and M. Mihail and E. Zegura,
+           The Markov chain simulation method for generating connected
+           power law random graphs, 2003.
+           http://citeseer.ist.psu.edu/gkantsidis03markov.html
+    """
+    if not nx.is_connected(G):
+        raise nx.NetworkXError("Graph not connected")
+    if len(G) < 4:
+        raise nx.NetworkXError("Graph has less than four nodes.")
+    n = 0
+    swapcount = 0
+    deg = G.degree()
+    # Label key for nodes
+    dk = list(n for n, d in G.degree())
+    cdf = nx.utils.cumulative_distribution(list(d for n, d in G.degree()))
+    discrete_sequence = nx.utils.discrete_sequence
+    window = 1
+    while n < nswap:
+        wcount = 0
+        swapped = []
+        # If the window is small, we just check each time whether the graph is
+        # connected by checking if the nodes that were just separated are still
+        # connected.
+        if window < _window_threshold:
+            # This Boolean keeps track of whether there was a failure or not.
+            fail = False
+            while wcount < window and n < nswap:
+                # Pick two random edges without creating the edge list. Choose
+                # source nodes from the discrete degree distribution.
+                (ui, xi) = discrete_sequence(2, cdistribution=cdf, seed=seed)
+                # If the source nodes are the same, skip this pair.
+                if ui == xi:
+                    continue
+                # Convert an index to a node label.
+                u = dk[ui]
+                x = dk[xi]
+                # Choose targets uniformly from neighbors.
+                v = seed.choice(list(G.neighbors(u)))
+                y = seed.choice(list(G.neighbors(x)))
+                # If the target nodes are the same, skip this pair.
+                if v == y:
+                    continue
+                if x not in G[u] and y not in G[v]:
+                    G.remove_edge(u, v)
+                    G.remove_edge(x, y)
+                    G.add_edge(u, x)
+                    G.add_edge(v, y)
+                    swapped.append((u, v, x, y))
+                    swapcount += 1
+                n += 1
+                # If G remains connected...
+                if nx.has_path(G, u, v):
+                    wcount += 1
+                # Otherwise, undo the changes.
+                else:
+                    G.add_edge(u, v)
+                    G.add_edge(x, y)
+                    G.remove_edge(u, x)
+                    G.remove_edge(v, y)
+                    swapcount -= 1
+                    fail = True
+            # If one of the swaps failed, reduce the window size.
+            if fail:
+                window = math.ceil(window / 2)
+            else:
+                window += 1
+        # If the window is large, then there is a good chance that a bunch of
+        # swaps will work. It's quicker to do all those swaps first and then
+        # check if the graph remains connected.
+        else:
+            while wcount < window and n < nswap:
+                # Pick two random edges without creating the edge list. Choose
+                # source nodes from the discrete degree distribution.
+                (ui, xi) = nx.utils.discrete_sequence(2, cdistribution=cdf)
+                # If the source nodes are the same, skip this pair.
+                if ui == xi:
+                    continue
+                # Convert an index to a node label.
+                u = dk[ui]
+                x = dk[xi]
+                # Choose targets uniformly from neighbors.
+                v = seed.choice(list(G.neighbors(u)))
+                y = seed.choice(list(G.neighbors(x)))
+                # If the target nodes are the same, skip this pair.
+                if v == y:
+                    continue
+                if x not in G[u] and y not in G[v]:
+                    G.remove_edge(u, v)
+                    G.remove_edge(x, y)
+                    G.add_edge(u, x)
+                    G.add_edge(v, y)
+                    swapped.append((u, v, x, y))
+                    swapcount += 1
+                n += 1
+                wcount += 1
+            # If the graph remains connected, increase the window size.
+            if nx.is_connected(G):
+                window += 1
+            # Otherwise, undo the changes from the previous window and decrease
+            # the window size.
+            else:
+                while swapped:
+                    (u, v, x, y) = swapped.pop()
+                    G.add_edge(u, v)
+                    G.add_edge(x, y)
+                    G.remove_edge(u, x)
+                    G.remove_edge(v, y)
+                    swapcount -= 1
+                window = math.ceil(window / 2)
+    return swapcount
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_asteroidal.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_asteroidal.py
new file mode 100644
index 0000000..b0487af
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_asteroidal.py
@@ -0,0 +1,24 @@
+import networkx as nx
+
+
+def test_is_at_free():
+
+    is_at_free = nx.asteroidal.is_at_free
+
+    cycle = nx.cycle_graph(6)
+    assert not is_at_free(cycle)
+
+    path = nx.path_graph(6)
+    assert is_at_free(path)
+
+    small_graph = nx.complete_graph(2)
+    assert is_at_free(small_graph)
+
+    petersen = nx.petersen_graph()
+    assert not is_at_free(petersen)
+
+    clique = nx.complete_graph(6)
+    assert is_at_free(clique)
+
+    line_clique = nx.line_graph(clique)
+    assert not is_at_free(line_clique)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_boundary.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_boundary.py
new file mode 100644
index 0000000..23837f0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_boundary.py
@@ -0,0 +1,154 @@
+"""Unit tests for the :mod:`networkx.algorithms.boundary` module."""
+
+from itertools import combinations
+
+import pytest
+
+import networkx as nx
+from networkx import convert_node_labels_to_integers as cnlti
+from networkx.utils import edges_equal
+
+
+class TestNodeBoundary:
+    """Unit tests for the :func:`~networkx.node_boundary` function."""
+
+    def test_null_graph(self):
+        """Tests that the null graph has empty node boundaries."""
+        null = nx.null_graph()
+        assert nx.node_boundary(null, []) == set()
+        assert nx.node_boundary(null, [], []) == set()
+        assert nx.node_boundary(null, [1, 2, 3]) == set()
+        assert nx.node_boundary(null, [1, 2, 3], [4, 5, 6]) == set()
+        assert nx.node_boundary(null, [1, 2, 3], [3, 4, 5]) == set()
+
+    def test_path_graph(self):
+        P10 = cnlti(nx.path_graph(10), first_label=1)
+        assert nx.node_boundary(P10, []) == set()
+        assert nx.node_boundary(P10, [], []) == set()
+        assert nx.node_boundary(P10, [1, 2, 3]) == {4}
+        assert nx.node_boundary(P10, [4, 5, 6]) == {3, 7}
+        assert nx.node_boundary(P10, [3, 4, 5, 6, 7]) == {2, 8}
+        assert nx.node_boundary(P10, [8, 9, 10]) == {7}
+        assert nx.node_boundary(P10, [4, 5, 6], [9, 10]) == set()
+
+    def test_complete_graph(self):
+        K10 = cnlti(nx.complete_graph(10), first_label=1)
+        assert nx.node_boundary(K10, []) == set()
+        assert nx.node_boundary(K10, [], []) == set()
+        assert nx.node_boundary(K10, [1, 2, 3]) == {4, 5, 6, 7, 8, 9, 10}
+        assert nx.node_boundary(K10, [4, 5, 6]) == {1, 2, 3, 7, 8, 9, 10}
+        assert nx.node_boundary(K10, [3, 4, 5, 6, 7]) == {1, 2, 8, 9, 10}
+        assert nx.node_boundary(K10, [4, 5, 6], []) == set()
+        assert nx.node_boundary(K10, K10) == set()
+        assert nx.node_boundary(K10, [1, 2, 3], [3, 4, 5]) == {4, 5}
+
+    def test_petersen(self):
+        """Check boundaries in the petersen graph
+
+        cheeger(G,k)=min(|bdy(S)|/|S| for |S|=k, 0<k<=|V(G)|/2)
+
+        """
+
+        def cheeger(G, k):
+            return min(len(nx.node_boundary(G, nn)) / k for nn in combinations(G, k))
+
+        P = nx.petersen_graph()
+        assert cheeger(P, 1) == pytest.approx(3.00, abs=1e-2)
+        assert cheeger(P, 2) == pytest.approx(2.00, abs=1e-2)
+        assert cheeger(P, 3) == pytest.approx(1.67, abs=1e-2)
+        assert cheeger(P, 4) == pytest.approx(1.00, abs=1e-2)
+        assert cheeger(P, 5) == pytest.approx(0.80, abs=1e-2)
+
+    def test_directed(self):
+        """Tests the node boundary of a directed graph."""
+        G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)])
+        S = {0, 1}
+        boundary = nx.node_boundary(G, S)
+        expected = {2}
+        assert boundary == expected
+
+    def test_multigraph(self):
+        """Tests the node boundary of a multigraph."""
+        G = nx.MultiGraph(list(nx.cycle_graph(5).edges()) * 2)
+        S = {0, 1}
+        boundary = nx.node_boundary(G, S)
+        expected = {2, 4}
+        assert boundary == expected
+
+    def test_multidigraph(self):
+        """Tests the edge boundary of a multdiigraph."""
+        edges = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]
+        G = nx.MultiDiGraph(edges * 2)
+        S = {0, 1}
+        boundary = nx.node_boundary(G, S)
+        expected = {2}
+        assert boundary == expected
+
+
+class TestEdgeBoundary:
+    """Unit tests for the :func:`~networkx.edge_boundary` function."""
+
+    def test_null_graph(self):
+        null = nx.null_graph()
+        assert list(nx.edge_boundary(null, [])) == []
+        assert list(nx.edge_boundary(null, [], [])) == []
+        assert list(nx.edge_boundary(null, [1, 2, 3])) == []
+        assert list(nx.edge_boundary(null, [1, 2, 3], [4, 5, 6])) == []
+        assert list(nx.edge_boundary(null, [1, 2, 3], [3, 4, 5])) == []
+
+    def test_path_graph(self):
+        P10 = cnlti(nx.path_graph(10), first_label=1)
+        assert list(nx.edge_boundary(P10, [])) == []
+        assert list(nx.edge_boundary(P10, [], [])) == []
+        assert list(nx.edge_boundary(P10, [1, 2, 3])) == [(3, 4)]
+        assert sorted(nx.edge_boundary(P10, [4, 5, 6])) == [(4, 3), (6, 7)]
+        assert sorted(nx.edge_boundary(P10, [3, 4, 5, 6, 7])) == [(3, 2), (7, 8)]
+        assert list(nx.edge_boundary(P10, [8, 9, 10])) == [(8, 7)]
+        assert sorted(nx.edge_boundary(P10, [4, 5, 6], [9, 10])) == []
+        assert list(nx.edge_boundary(P10, [1, 2, 3], [3, 4, 5])) == [(2, 3), (3, 4)]
+
+    def test_complete_graph(self):
+        K10 = cnlti(nx.complete_graph(10), first_label=1)
+
+        def ilen(iterable):
+            return sum(1 for i in iterable)
+
+        assert list(nx.edge_boundary(K10, [])) == []
+        assert list(nx.edge_boundary(K10, [], [])) == []
+        assert ilen(nx.edge_boundary(K10, [1, 2, 3])) == 21
+        assert ilen(nx.edge_boundary(K10, [4, 5, 6, 7])) == 24
+        assert ilen(nx.edge_boundary(K10, [3, 4, 5, 6, 7])) == 25
+        assert ilen(nx.edge_boundary(K10, [8, 9, 10])) == 21
+        assert edges_equal(
+            nx.edge_boundary(K10, [4, 5, 6], [9, 10]),
+            [(4, 9), (4, 10), (5, 9), (5, 10), (6, 9), (6, 10)],
+        )
+        assert edges_equal(
+            nx.edge_boundary(K10, [1, 2, 3], [3, 4, 5]),
+            [(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5)],
+        )
+
+    def test_directed(self):
+        """Tests the edge boundary of a directed graph."""
+        G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)])
+        S = {0, 1}
+        boundary = list(nx.edge_boundary(G, S))
+        expected = [(1, 2)]
+        assert boundary == expected
+
+    def test_multigraph(self):
+        """Tests the edge boundary of a multigraph."""
+        G = nx.MultiGraph(list(nx.cycle_graph(5).edges()) * 2)
+        S = {0, 1}
+        boundary = list(nx.edge_boundary(G, S))
+        expected = [(0, 4), (0, 4), (1, 2), (1, 2)]
+        assert boundary == expected
+
+    def test_multidigraph(self):
+        """Tests the edge boundary of a multdiigraph."""
+        edges = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]
+        G = nx.MultiDiGraph(edges * 2)
+        S = {0, 1}
+        boundary = list(nx.edge_boundary(G, S))
+        expected = [(1, 2), (1, 2)]
+        assert boundary == expected
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_bridges.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_bridges.py
new file mode 100644
index 0000000..059cf3d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_bridges.py
@@ -0,0 +1,87 @@
+"""Unit tests for bridge-finding algorithms."""
+
+import networkx as nx
+
+
+class TestBridges:
+    """Unit tests for the bridge-finding function."""
+
+    def test_single_bridge(self):
+        edges = [
+            # DFS tree edges.
+            (1, 2),
+            (2, 3),
+            (3, 4),
+            (3, 5),
+            (5, 6),
+            (6, 7),
+            (7, 8),
+            (5, 9),
+            (9, 10),
+            # Nontree edges.
+            (1, 3),
+            (1, 4),
+            (2, 5),
+            (5, 10),
+            (6, 8),
+        ]
+        G = nx.Graph(edges)
+        source = 1
+        bridges = list(nx.bridges(G, source))
+        assert bridges == [(5, 6)]
+
+    def test_barbell_graph(self):
+        # The (3, 0) barbell graph has two triangles joined by a single edge.
+        G = nx.barbell_graph(3, 0)
+        source = 0
+        bridges = list(nx.bridges(G, source))
+        assert bridges == [(2, 3)]
+
+    def test_multiedge_bridge(self):
+        edges = [
+            (0, 1),
+            (0, 2),
+            (1, 2),
+            (1, 2),
+            (2, 3),
+            (3, 4),
+            (3, 4),
+        ]
+        G = nx.MultiGraph(edges)
+        assert list(nx.bridges(G)) == [(2, 3)]
+
+
+class TestLocalBridges:
+    """Unit tests for the local_bridge function."""
+
+    @classmethod
+    def setup_class(cls):
+        cls.BB = nx.barbell_graph(4, 0)
+        cls.square = nx.cycle_graph(4)
+        cls.tri = nx.cycle_graph(3)
+
+    def test_nospan(self):
+        expected = {(3, 4), (4, 3)}
+        assert next(nx.local_bridges(self.BB, with_span=False)) in expected
+        assert set(nx.local_bridges(self.square, with_span=False)) == self.square.edges
+        assert list(nx.local_bridges(self.tri, with_span=False)) == []
+
+    def test_no_weight(self):
+        inf = float("inf")
+        expected = {(3, 4, inf), (4, 3, inf)}
+        assert next(nx.local_bridges(self.BB)) in expected
+        expected = {(u, v, 3) for u, v, in self.square.edges}
+        assert set(nx.local_bridges(self.square)) == expected
+        assert list(nx.local_bridges(self.tri)) == []
+
+    def test_weight(self):
+        inf = float("inf")
+        G = self.square.copy()
+
+        G.edges[1, 2]["weight"] = 2
+        expected = {(u, v, 5 - wt) for u, v, wt in G.edges(data="weight", default=1)}
+        assert set(nx.local_bridges(G, weight="weight")) == expected
+
+        expected = {(u, v, 6) for u, v in G.edges}
+        lb = nx.local_bridges(G, weight=lambda u, v, d: 2)
+        assert set(lb) == expected
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_chains.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_chains.py
new file mode 100644
index 0000000..f8886c9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_chains.py
@@ -0,0 +1,131 @@
+"""Unit tests for the chain decomposition functions."""
+from itertools import cycle, islice
+
+import networkx as nx
+
+
+def cycles(seq):
+    """Yields cyclic permutations of the given sequence.
+
+    For example::
+
+        >>> list(cycles("abc"))
+        [('a', 'b', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b')]
+
+    """
+    n = len(seq)
+    cycled_seq = cycle(seq)
+    for x in seq:
+        yield tuple(islice(cycled_seq, n))
+        next(cycled_seq)
+
+
+def cyclic_equals(seq1, seq2):
+    """Decide whether two sequences are equal up to cyclic permutations.
+
+    For example::
+
+        >>> cyclic_equals("xyz", "zxy")
+        True
+        >>> cyclic_equals("xyz", "zyx")
+        False
+
+    """
+    # Cast seq2 to a tuple since `cycles()` yields tuples.
+    seq2 = tuple(seq2)
+    return any(x == tuple(seq2) for x in cycles(seq1))
+
+
+class TestChainDecomposition:
+    """Unit tests for the chain decomposition function."""
+
+    def assertContainsChain(self, chain, expected):
+        # A cycle could be expressed in two different orientations, one
+        # forward and one backward, so we need to check for cyclic
+        # equality in both orientations.
+        reversed_chain = list(reversed([tuple(reversed(e)) for e in chain]))
+        for candidate in expected:
+            if cyclic_equals(chain, candidate):
+                break
+            if cyclic_equals(reversed_chain, candidate):
+                break
+        else:
+            self.fail("chain not found")
+
+    def test_decomposition(self):
+        edges = [
+            # DFS tree edges.
+            (1, 2),
+            (2, 3),
+            (3, 4),
+            (3, 5),
+            (5, 6),
+            (6, 7),
+            (7, 8),
+            (5, 9),
+            (9, 10),
+            # Nontree edges.
+            (1, 3),
+            (1, 4),
+            (2, 5),
+            (5, 10),
+            (6, 8),
+        ]
+        G = nx.Graph(edges)
+        expected = [
+            [(1, 3), (3, 2), (2, 1)],
+            [(1, 4), (4, 3)],
+            [(2, 5), (5, 3)],
+            [(5, 10), (10, 9), (9, 5)],
+            [(6, 8), (8, 7), (7, 6)],
+        ]
+        chains = list(nx.chain_decomposition(G, root=1))
+        assert len(chains) == len(expected)
+
+    # This chain decomposition isn't unique
+    #        for chain in chains:
+    #            print(chain)
+    #            self.assertContainsChain(chain, expected)
+
+    def test_barbell_graph(self):
+        # The (3, 0) barbell graph has two triangles joined by a single edge.
+        G = nx.barbell_graph(3, 0)
+        chains = list(nx.chain_decomposition(G, root=0))
+        expected = [[(0, 1), (1, 2), (2, 0)], [(3, 4), (4, 5), (5, 3)]]
+        assert len(chains) == len(expected)
+        for chain in chains:
+            self.assertContainsChain(chain, expected)
+
+    def test_disconnected_graph(self):
+        """Test for a graph with multiple connected components."""
+        G = nx.barbell_graph(3, 0)
+        H = nx.barbell_graph(3, 0)
+        mapping = dict(zip(range(6), "abcdef"))
+        nx.relabel_nodes(H, mapping, copy=False)
+        G = nx.union(G, H)
+        chains = list(nx.chain_decomposition(G))
+        expected = [
+            [(0, 1), (1, 2), (2, 0)],
+            [(3, 4), (4, 5), (5, 3)],
+            [("a", "b"), ("b", "c"), ("c", "a")],
+            [("d", "e"), ("e", "f"), ("f", "d")],
+        ]
+        assert len(chains) == len(expected)
+        for chain in chains:
+            self.assertContainsChain(chain, expected)
+
+    def test_disconnected_graph_root_node(self):
+        """Test for a single component of a disconnected graph."""
+        G = nx.barbell_graph(3, 0)
+        H = nx.barbell_graph(3, 0)
+        mapping = dict(zip(range(6), "abcdef"))
+        nx.relabel_nodes(H, mapping, copy=False)
+        G = nx.union(G, H)
+        chains = list(nx.chain_decomposition(G, root="a"))
+        expected = [
+            [("a", "b"), ("b", "c"), ("c", "a")],
+            [("d", "e"), ("e", "f"), ("f", "d")],
+        ]
+        assert len(chains) == len(expected)
+        for chain in chains:
+            self.assertContainsChain(chain, expected)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_chordal.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_chordal.py
new file mode 100644
index 0000000..c72699c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_chordal.py
@@ -0,0 +1,129 @@
+import pytest
+
+import networkx as nx
+
+
+class TestMCS:
+    @classmethod
+    def setup_class(cls):
+        # simple graph
+        connected_chordal_G = nx.Graph()
+        connected_chordal_G.add_edges_from(
+            [
+                (1, 2),
+                (1, 3),
+                (2, 3),
+                (2, 4),
+                (3, 4),
+                (3, 5),
+                (3, 6),
+                (4, 5),
+                (4, 6),
+                (5, 6),
+            ]
+        )
+        cls.connected_chordal_G = connected_chordal_G
+
+        chordal_G = nx.Graph()
+        chordal_G.add_edges_from(
+            [
+                (1, 2),
+                (1, 3),
+                (2, 3),
+                (2, 4),
+                (3, 4),
+                (3, 5),
+                (3, 6),
+                (4, 5),
+                (4, 6),
+                (5, 6),
+                (7, 8),
+            ]
+        )
+        chordal_G.add_node(9)
+        cls.chordal_G = chordal_G
+
+        non_chordal_G = nx.Graph()
+        non_chordal_G.add_edges_from([(1, 2), (1, 3), (2, 4), (2, 5), (3, 4), (3, 5)])
+        cls.non_chordal_G = non_chordal_G
+
+        self_loop_G = nx.Graph()
+        self_loop_G.add_edges_from([(1, 1)])
+        cls.self_loop_G = self_loop_G
+
+    @pytest.mark.parametrize("G", (nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()))
+    def test_is_chordal_not_implemented(self, G):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            nx.is_chordal(G)
+
+    def test_is_chordal(self):
+        assert not nx.is_chordal(self.non_chordal_G)
+        assert nx.is_chordal(self.chordal_G)
+        assert nx.is_chordal(self.connected_chordal_G)
+        assert nx.is_chordal(nx.complete_graph(3))
+        assert nx.is_chordal(nx.cycle_graph(3))
+        assert not nx.is_chordal(nx.cycle_graph(5))
+        with pytest.raises(nx.NetworkXError, match="Input graph is not chordal"):
+            nx.is_chordal(self.self_loop_G)
+
+    def test_induced_nodes(self):
+        G = nx.generators.classic.path_graph(10)
+        Induced_nodes = nx.find_induced_nodes(G, 1, 9, 2)
+        assert Induced_nodes == {1, 2, 3, 4, 5, 6, 7, 8, 9}
+        pytest.raises(
+            nx.NetworkXTreewidthBoundExceeded, nx.find_induced_nodes, G, 1, 9, 1
+        )
+        Induced_nodes = nx.find_induced_nodes(self.chordal_G, 1, 6)
+        assert Induced_nodes == {1, 2, 4, 6}
+        pytest.raises(nx.NetworkXError, nx.find_induced_nodes, self.non_chordal_G, 1, 5)
+
+    def test_graph_treewidth(self):
+        with pytest.raises(nx.NetworkXError, match="Input graph is not chordal"):
+            nx.chordal_graph_treewidth(self.non_chordal_G)
+
+    def test_chordal_find_cliques(self):
+        cliques = {
+            frozenset([9]),
+            frozenset([7, 8]),
+            frozenset([1, 2, 3]),
+            frozenset([2, 3, 4]),
+            frozenset([3, 4, 5, 6]),
+        }
+        assert nx.chordal_graph_cliques(self.chordal_G) == cliques
+        with pytest.raises(nx.NetworkXError, match="Input graph is not chordal"):
+            nx.chordal_graph_cliques(self.non_chordal_G)
+        with pytest.raises(nx.NetworkXError, match="Input graph is not chordal"):
+            nx.chordal_graph_cliques(self.self_loop_G)
+
+    def test_chordal_find_cliques_path(self):
+        G = nx.path_graph(10)
+        cliqueset = nx.chordal_graph_cliques(G)
+        for (u, v) in G.edges():
+            assert frozenset([u, v]) in cliqueset or frozenset([v, u]) in cliqueset
+
+    def test_chordal_find_cliquesCC(self):
+        cliques = {frozenset([1, 2, 3]), frozenset([2, 3, 4]), frozenset([3, 4, 5, 6])}
+        cgc = nx.chordal_graph_cliques
+        assert cgc(self.connected_chordal_G) == cliques
+
+    def test_complete_to_chordal_graph(self):
+        fgrg = nx.fast_gnp_random_graph
+        test_graphs = [
+            nx.barbell_graph(6, 2),
+            nx.cycle_graph(15),
+            nx.wheel_graph(20),
+            nx.grid_graph([10, 4]),
+            nx.ladder_graph(15),
+            nx.star_graph(5),
+            nx.bull_graph(),
+            fgrg(20, 0.3, seed=1),
+        ]
+        for G in test_graphs:
+            H, a = nx.complete_to_chordal_graph(G)
+            assert nx.is_chordal(H)
+            assert len(a) == H.number_of_nodes()
+            if nx.is_chordal(G):
+                assert G.number_of_edges() == H.number_of_edges()
+                assert set(a.values()) == {0}
+            else:
+                assert len(set(a.values())) == H.number_of_nodes()
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_clique.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_clique.py
new file mode 100644
index 0000000..f6d5335
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_clique.py
@@ -0,0 +1,316 @@
+import pytest
+
+import networkx as nx
+from networkx import convert_node_labels_to_integers as cnlti
+
+
+class TestCliques:
+    def setup_method(self):
+        z = [3, 4, 3, 4, 2, 4, 2, 1, 1, 1, 1]
+        self.G = cnlti(nx.generators.havel_hakimi_graph(z), first_label=1)
+        self.cl = list(nx.find_cliques(self.G))
+        H = nx.complete_graph(6)
+        H = nx.relabel_nodes(H, {i: i + 1 for i in range(6)})
+        H.remove_edges_from([(2, 6), (2, 5), (2, 4), (1, 3), (5, 3)])
+        self.H = H
+
+    def test_find_cliques1(self):
+        cl = list(nx.find_cliques(self.G))
+        rcl = nx.find_cliques_recursive(self.G)
+        expected = [[2, 6, 1, 3], [2, 6, 4], [5, 4, 7], [8, 9], [10, 11]]
+        assert sorted(map(sorted, cl)) == sorted(map(sorted, rcl))
+        assert sorted(map(sorted, cl)) == sorted(map(sorted, expected))
+
+    def test_selfloops(self):
+        self.G.add_edge(1, 1)
+        cl = list(nx.find_cliques(self.G))
+        rcl = list(nx.find_cliques_recursive(self.G))
+        assert set(map(frozenset, cl)) == set(map(frozenset, rcl))
+        answer = [{2, 6, 1, 3}, {2, 6, 4}, {5, 4, 7}, {8, 9}, {10, 11}]
+        assert len(answer) == len(cl)
+        assert all(set(c) in answer for c in cl)
+
+    def test_find_cliques2(self):
+        hcl = list(nx.find_cliques(self.H))
+        assert sorted(map(sorted, hcl)) == [[1, 2], [1, 4, 5, 6], [2, 3], [3, 4, 6]]
+
+    def test_find_cliques3(self):
+        # all cliques are [[2, 6, 1, 3], [2, 6, 4], [5, 4, 7], [8, 9], [10, 11]]
+
+        cl = list(nx.find_cliques(self.G, [2]))
+        rcl = nx.find_cliques_recursive(self.G, [2])
+        expected = [[2, 6, 1, 3], [2, 6, 4]]
+        assert sorted(map(sorted, rcl)) == sorted(map(sorted, expected))
+        assert sorted(map(sorted, cl)) == sorted(map(sorted, expected))
+
+        cl = list(nx.find_cliques(self.G, [2, 3]))
+        rcl = nx.find_cliques_recursive(self.G, [2, 3])
+        expected = [[2, 6, 1, 3]]
+        assert sorted(map(sorted, rcl)) == sorted(map(sorted, expected))
+        assert sorted(map(sorted, cl)) == sorted(map(sorted, expected))
+
+        cl = list(nx.find_cliques(self.G, [2, 6, 4]))
+        rcl = nx.find_cliques_recursive(self.G, [2, 6, 4])
+        expected = [[2, 6, 4]]
+        assert sorted(map(sorted, rcl)) == sorted(map(sorted, expected))
+        assert sorted(map(sorted, cl)) == sorted(map(sorted, expected))
+
+        cl = list(nx.find_cliques(self.G, [2, 6, 4]))
+        rcl = nx.find_cliques_recursive(self.G, [2, 6, 4])
+        expected = [[2, 6, 4]]
+        assert sorted(map(sorted, rcl)) == sorted(map(sorted, expected))
+        assert sorted(map(sorted, cl)) == sorted(map(sorted, expected))
+
+        with pytest.raises(ValueError):
+            list(nx.find_cliques(self.G, [2, 6, 4, 1]))
+
+        with pytest.raises(ValueError):
+            list(nx.find_cliques_recursive(self.G, [2, 6, 4, 1]))
+
+    def test_clique_number(self):
+        G = self.G
+        assert nx.graph_clique_number(G) == 4
+        assert nx.graph_clique_number(G, cliques=self.cl) == 4
+
+    def test_clique_number2(self):
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3])
+        assert nx.graph_clique_number(G) == 1
+
+    def test_clique_number3(self):
+        G = nx.Graph()
+        assert nx.graph_clique_number(G) == 0
+
+    def test_number_of_cliques(self):
+        G = self.G
+        assert nx.graph_number_of_cliques(G) == 5
+        assert nx.graph_number_of_cliques(G, cliques=self.cl) == 5
+        assert nx.number_of_cliques(G, 1) == 1
+        assert list(nx.number_of_cliques(G, [1]).values()) == [1]
+        assert list(nx.number_of_cliques(G, [1, 2]).values()) == [1, 2]
+        assert nx.number_of_cliques(G, [1, 2]) == {1: 1, 2: 2}
+        assert nx.number_of_cliques(G, 2) == 2
+        assert nx.number_of_cliques(G) == {
+            1: 1,
+            2: 2,
+            3: 1,
+            4: 2,
+            5: 1,
+            6: 2,
+            7: 1,
+            8: 1,
+            9: 1,
+            10: 1,
+            11: 1,
+        }
+        assert nx.number_of_cliques(G, nodes=list(G)) == {
+            1: 1,
+            2: 2,
+            3: 1,
+            4: 2,
+            5: 1,
+            6: 2,
+            7: 1,
+            8: 1,
+            9: 1,
+            10: 1,
+            11: 1,
+        }
+        assert nx.number_of_cliques(G, nodes=[2, 3, 4]) == {2: 2, 3: 1, 4: 2}
+        assert nx.number_of_cliques(G, cliques=self.cl) == {
+            1: 1,
+            2: 2,
+            3: 1,
+            4: 2,
+            5: 1,
+            6: 2,
+            7: 1,
+            8: 1,
+            9: 1,
+            10: 1,
+            11: 1,
+        }
+        assert nx.number_of_cliques(G, list(G), cliques=self.cl) == {
+            1: 1,
+            2: 2,
+            3: 1,
+            4: 2,
+            5: 1,
+            6: 2,
+            7: 1,
+            8: 1,
+            9: 1,
+            10: 1,
+            11: 1,
+        }
+
+    def test_node_clique_number(self):
+        G = self.G
+        assert nx.node_clique_number(G, 1) == 4
+        assert list(nx.node_clique_number(G, [1]).values()) == [4]
+        assert list(nx.node_clique_number(G, [1, 2]).values()) == [4, 4]
+        assert nx.node_clique_number(G, [1, 2]) == {1: 4, 2: 4}
+        assert nx.node_clique_number(G, 1) == 4
+        assert nx.node_clique_number(G) == {
+            1: 4,
+            2: 4,
+            3: 4,
+            4: 3,
+            5: 3,
+            6: 4,
+            7: 3,
+            8: 2,
+            9: 2,
+            10: 2,
+            11: 2,
+        }
+        assert nx.node_clique_number(G, cliques=self.cl) == {
+            1: 4,
+            2: 4,
+            3: 4,
+            4: 3,
+            5: 3,
+            6: 4,
+            7: 3,
+            8: 2,
+            9: 2,
+            10: 2,
+            11: 2,
+        }
+        assert nx.node_clique_number(G, [1, 2], cliques=self.cl) == {1: 4, 2: 4}
+        assert nx.node_clique_number(G, 1, cliques=self.cl) == 4
+
+    def test_cliques_containing_node(self):
+        G = self.G
+        assert nx.cliques_containing_node(G, 1) == [[2, 6, 1, 3]]
+        assert list(nx.cliques_containing_node(G, [1]).values()) == [[[2, 6, 1, 3]]]
+        assert [
+            sorted(c) for c in list(nx.cliques_containing_node(G, [1, 2]).values())
+        ] == [[[2, 6, 1, 3]], [[2, 6, 1, 3], [2, 6, 4]]]
+        result = nx.cliques_containing_node(G, [1, 2])
+        for k, v in result.items():
+            result[k] = sorted(v)
+        assert result == {1: [[2, 6, 1, 3]], 2: [[2, 6, 1, 3], [2, 6, 4]]}
+        assert nx.cliques_containing_node(G, 1) == [[2, 6, 1, 3]]
+        expected = [{2, 6, 1, 3}, {2, 6, 4}]
+        answer = [set(c) for c in nx.cliques_containing_node(G, 2)]
+        assert answer in (expected, list(reversed(expected)))
+
+        answer = [set(c) for c in nx.cliques_containing_node(G, 2, cliques=self.cl)]
+        assert answer in (expected, list(reversed(expected)))
+        assert len(nx.cliques_containing_node(G)) == 11
+
+    def test_make_clique_bipartite(self):
+        G = self.G
+        B = nx.make_clique_bipartite(G)
+        assert sorted(B) == [-5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+        # Project onto the nodes of the original graph.
+        H = nx.projected_graph(B, range(1, 12))
+        assert H.adj == G.adj
+        # Project onto the nodes representing the cliques.
+        H1 = nx.projected_graph(B, range(-5, 0))
+        # Relabel the negative numbers as positive ones.
+        H1 = nx.relabel_nodes(H1, {-v: v for v in range(1, 6)})
+        assert sorted(H1) == [1, 2, 3, 4, 5]
+
+    def test_make_max_clique_graph(self):
+        """Tests that the maximal clique graph is the same as the bipartite
+        clique graph after being projected onto the nodes representing the
+        cliques.
+
+        """
+        G = self.G
+        B = nx.make_clique_bipartite(G)
+        # Project onto the nodes representing the cliques.
+        H1 = nx.projected_graph(B, range(-5, 0))
+        # Relabel the negative numbers as nonnegative ones, starting at
+        # 0.
+        H1 = nx.relabel_nodes(H1, {-v: v - 1 for v in range(1, 6)})
+        H2 = nx.make_max_clique_graph(G)
+        assert H1.adj == H2.adj
+
+    def test_directed(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            next(nx.find_cliques(nx.DiGraph()))
+
+
+class TestEnumerateAllCliques:
+    def test_paper_figure_4(self):
+        # Same graph as given in Fig. 4 of paper enumerate_all_cliques is
+        # based on.
+        # http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=1559964&isnumber=33129
+        G = nx.Graph()
+        edges_fig_4 = [
+            ("a", "b"),
+            ("a", "c"),
+            ("a", "d"),
+            ("a", "e"),
+            ("b", "c"),
+            ("b", "d"),
+            ("b", "e"),
+            ("c", "d"),
+            ("c", "e"),
+            ("d", "e"),
+            ("f", "b"),
+            ("f", "c"),
+            ("f", "g"),
+            ("g", "f"),
+            ("g", "c"),
+            ("g", "d"),
+            ("g", "e"),
+        ]
+        G.add_edges_from(edges_fig_4)
+
+        cliques = list(nx.enumerate_all_cliques(G))
+        clique_sizes = list(map(len, cliques))
+        assert sorted(clique_sizes) == clique_sizes
+
+        expected_cliques = [
+            ["a"],
+            ["b"],
+            ["c"],
+            ["d"],
+            ["e"],
+            ["f"],
+            ["g"],
+            ["a", "b"],
+            ["a", "b", "d"],
+            ["a", "b", "d", "e"],
+            ["a", "b", "e"],
+            ["a", "c"],
+            ["a", "c", "d"],
+            ["a", "c", "d", "e"],
+            ["a", "c", "e"],
+            ["a", "d"],
+            ["a", "d", "e"],
+            ["a", "e"],
+            ["b", "c"],
+            ["b", "c", "d"],
+            ["b", "c", "d", "e"],
+            ["b", "c", "e"],
+            ["b", "c", "f"],
+            ["b", "d"],
+            ["b", "d", "e"],
+            ["b", "e"],
+            ["b", "f"],
+            ["c", "d"],
+            ["c", "d", "e"],
+            ["c", "d", "e", "g"],
+            ["c", "d", "g"],
+            ["c", "e"],
+            ["c", "e", "g"],
+            ["c", "f"],
+            ["c", "f", "g"],
+            ["c", "g"],
+            ["d", "e"],
+            ["d", "e", "g"],
+            ["d", "g"],
+            ["e", "g"],
+            ["f", "g"],
+            ["a", "b", "c"],
+            ["a", "b", "c", "d"],
+            ["a", "b", "c", "d", "e"],
+            ["a", "b", "c", "e"],
+        ]
+
+        assert sorted(map(sorted, cliques)) == sorted(map(sorted, expected_cliques))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_cluster.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_cluster.py
new file mode 100644
index 0000000..d69f036
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_cluster.py
@@ -0,0 +1,543 @@
+import pytest
+
+import networkx as nx
+
+
+class TestTriangles:
+    def test_empty(self):
+        G = nx.Graph()
+        assert list(nx.triangles(G).values()) == []
+
+    def test_path(self):
+        G = nx.path_graph(10)
+        assert list(nx.triangles(G).values()) == [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        assert nx.triangles(G) == {
+            0: 0,
+            1: 0,
+            2: 0,
+            3: 0,
+            4: 0,
+            5: 0,
+            6: 0,
+            7: 0,
+            8: 0,
+            9: 0,
+        }
+
+    def test_cubical(self):
+        G = nx.cubical_graph()
+        assert list(nx.triangles(G).values()) == [0, 0, 0, 0, 0, 0, 0, 0]
+        assert nx.triangles(G, 1) == 0
+        assert list(nx.triangles(G, [1, 2]).values()) == [0, 0]
+        assert nx.triangles(G, 1) == 0
+        assert nx.triangles(G, [1, 2]) == {1: 0, 2: 0}
+
+    def test_k5(self):
+        G = nx.complete_graph(5)
+        assert list(nx.triangles(G).values()) == [6, 6, 6, 6, 6]
+        assert sum(nx.triangles(G).values()) / 3 == 10
+        assert nx.triangles(G, 1) == 6
+        G.remove_edge(1, 2)
+        assert list(nx.triangles(G).values()) == [5, 3, 3, 5, 5]
+        assert nx.triangles(G, 1) == 3
+        G.add_edge(3, 3)  # ignore self-edges
+        assert list(nx.triangles(G).values()) == [5, 3, 3, 5, 5]
+        assert nx.triangles(G, 3) == 5
+
+
+class TestDirectedClustering:
+    def test_clustering(self):
+        G = nx.DiGraph()
+        assert list(nx.clustering(G).values()) == []
+        assert nx.clustering(G) == {}
+
+    def test_path(self):
+        G = nx.path_graph(10, create_using=nx.DiGraph())
+        assert list(nx.clustering(G).values()) == [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+        ]
+        assert nx.clustering(G) == {
+            0: 0,
+            1: 0,
+            2: 0,
+            3: 0,
+            4: 0,
+            5: 0,
+            6: 0,
+            7: 0,
+            8: 0,
+            9: 0,
+        }
+        assert nx.clustering(G, 0) == 0
+
+    def test_k5(self):
+        G = nx.complete_graph(5, create_using=nx.DiGraph())
+        assert list(nx.clustering(G).values()) == [1, 1, 1, 1, 1]
+        assert nx.average_clustering(G) == 1
+        G.remove_edge(1, 2)
+        assert list(nx.clustering(G).values()) == [
+            11 / 12,
+            1,
+            1,
+            11 / 12,
+            11 / 12,
+        ]
+        assert nx.clustering(G, [1, 4]) == {1: 1, 4: 11 / 12}
+        G.remove_edge(2, 1)
+        assert list(nx.clustering(G).values()) == [
+            5 / 6,
+            1,
+            1,
+            5 / 6,
+            5 / 6,
+        ]
+        assert nx.clustering(G, [1, 4]) == {1: 1, 4: 0.83333333333333337}
+        assert nx.clustering(G, 4) == 5 / 6
+
+    def test_triangle_and_edge(self):
+        G = nx.cycle_graph(3, create_using=nx.DiGraph())
+        G.add_edge(0, 4)
+        assert nx.clustering(G)[0] == 1 / 6
+
+
+class TestDirectedWeightedClustering:
+    @classmethod
+    def setup_class(cls):
+        global np
+        np = pytest.importorskip("numpy")
+
+    def test_clustering(self):
+        G = nx.DiGraph()
+        assert list(nx.clustering(G, weight="weight").values()) == []
+        assert nx.clustering(G) == {}
+
+    def test_path(self):
+        G = nx.path_graph(10, create_using=nx.DiGraph())
+        assert list(nx.clustering(G, weight="weight").values()) == [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+        ]
+        assert nx.clustering(G, weight="weight") == {
+            0: 0,
+            1: 0,
+            2: 0,
+            3: 0,
+            4: 0,
+            5: 0,
+            6: 0,
+            7: 0,
+            8: 0,
+            9: 0,
+        }
+
+    def test_k5(self):
+        G = nx.complete_graph(5, create_using=nx.DiGraph())
+        assert list(nx.clustering(G, weight="weight").values()) == [1, 1, 1, 1, 1]
+        assert nx.average_clustering(G, weight="weight") == 1
+        G.remove_edge(1, 2)
+        assert list(nx.clustering(G, weight="weight").values()) == [
+            11 / 12,
+            1,
+            1,
+            11 / 12,
+            11 / 12,
+        ]
+        assert nx.clustering(G, [1, 4], weight="weight") == {1: 1, 4: 11 / 12}
+        G.remove_edge(2, 1)
+        assert list(nx.clustering(G, weight="weight").values()) == [
+            5 / 6,
+            1,
+            1,
+            5 / 6,
+            5 / 6,
+        ]
+        assert nx.clustering(G, [1, 4], weight="weight") == {
+            1: 1,
+            4: 0.83333333333333337,
+        }
+
+    def test_triangle_and_edge(self):
+        G = nx.cycle_graph(3, create_using=nx.DiGraph())
+        G.add_edge(0, 4, weight=2)
+        assert nx.clustering(G)[0] == 1 / 6
+        # Relaxed comparisons to allow graphblas-algorithms to pass tests
+        np.testing.assert_allclose(nx.clustering(G, weight="weight")[0], 1 / 12)
+        np.testing.assert_allclose(nx.clustering(G, 0, weight="weight"), 1 / 12)
+
+
+class TestWeightedClustering:
+    @classmethod
+    def setup_class(cls):
+        global np
+        np = pytest.importorskip("numpy")
+
+    def test_clustering(self):
+        G = nx.Graph()
+        assert list(nx.clustering(G, weight="weight").values()) == []
+        assert nx.clustering(G) == {}
+
+    def test_path(self):
+        G = nx.path_graph(10)
+        assert list(nx.clustering(G, weight="weight").values()) == [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+        ]
+        assert nx.clustering(G, weight="weight") == {
+            0: 0,
+            1: 0,
+            2: 0,
+            3: 0,
+            4: 0,
+            5: 0,
+            6: 0,
+            7: 0,
+            8: 0,
+            9: 0,
+        }
+
+    def test_cubical(self):
+        G = nx.cubical_graph()
+        assert list(nx.clustering(G, weight="weight").values()) == [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+        ]
+        assert nx.clustering(G, 1) == 0
+        assert list(nx.clustering(G, [1, 2], weight="weight").values()) == [0, 0]
+        assert nx.clustering(G, 1, weight="weight") == 0
+        assert nx.clustering(G, [1, 2], weight="weight") == {1: 0, 2: 0}
+
+    def test_k5(self):
+        G = nx.complete_graph(5)
+        assert list(nx.clustering(G, weight="weight").values()) == [1, 1, 1, 1, 1]
+        assert nx.average_clustering(G, weight="weight") == 1
+        G.remove_edge(1, 2)
+        assert list(nx.clustering(G, weight="weight").values()) == [
+            5 / 6,
+            1,
+            1,
+            5 / 6,
+            5 / 6,
+        ]
+        assert nx.clustering(G, [1, 4], weight="weight") == {
+            1: 1,
+            4: 0.83333333333333337,
+        }
+
+    def test_triangle_and_edge(self):
+        G = nx.cycle_graph(3)
+        G.add_edge(0, 4, weight=2)
+        assert nx.clustering(G)[0] == 1 / 3
+        np.testing.assert_allclose(nx.clustering(G, weight="weight")[0], 1 / 6)
+        np.testing.assert_allclose(nx.clustering(G, 0, weight="weight"), 1 / 6)
+
+    def test_triangle_and_signed_edge(self):
+        G = nx.cycle_graph(3)
+        G.add_edge(0, 1, weight=-1)
+        G.add_edge(3, 0, weight=0)
+        assert nx.clustering(G)[0] == 1 / 3
+        assert nx.clustering(G, weight="weight")[0] == -1 / 3
+
+
+class TestClustering:
+    @classmethod
+    def setup_class(cls):
+        pytest.importorskip("numpy")
+
+    def test_clustering(self):
+        G = nx.Graph()
+        assert list(nx.clustering(G).values()) == []
+        assert nx.clustering(G) == {}
+
+    def test_path(self):
+        G = nx.path_graph(10)
+        assert list(nx.clustering(G).values()) == [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+        ]
+        assert nx.clustering(G) == {
+            0: 0,
+            1: 0,
+            2: 0,
+            3: 0,
+            4: 0,
+            5: 0,
+            6: 0,
+            7: 0,
+            8: 0,
+            9: 0,
+        }
+
+    def test_cubical(self):
+        G = nx.cubical_graph()
+        assert list(nx.clustering(G).values()) == [0, 0, 0, 0, 0, 0, 0, 0]
+        assert nx.clustering(G, 1) == 0
+        assert list(nx.clustering(G, [1, 2]).values()) == [0, 0]
+        assert nx.clustering(G, 1) == 0
+        assert nx.clustering(G, [1, 2]) == {1: 0, 2: 0}
+
+    def test_k5(self):
+        G = nx.complete_graph(5)
+        assert list(nx.clustering(G).values()) == [1, 1, 1, 1, 1]
+        assert nx.average_clustering(G) == 1
+        G.remove_edge(1, 2)
+        assert list(nx.clustering(G).values()) == [
+            5 / 6,
+            1,
+            1,
+            5 / 6,
+            5 / 6,
+        ]
+        assert nx.clustering(G, [1, 4]) == {1: 1, 4: 0.83333333333333337}
+
+    def test_k5_signed(self):
+        G = nx.complete_graph(5)
+        assert list(nx.clustering(G).values()) == [1, 1, 1, 1, 1]
+        assert nx.average_clustering(G) == 1
+        G.remove_edge(1, 2)
+        G.add_edge(0, 1, weight=-1)
+        assert list(nx.clustering(G, weight="weight").values()) == [
+            1 / 6,
+            -1 / 3,
+            1,
+            3 / 6,
+            3 / 6,
+        ]
+
+
+class TestTransitivity:
+    def test_transitivity(self):
+        G = nx.Graph()
+        assert nx.transitivity(G) == 0
+
+    def test_path(self):
+        G = nx.path_graph(10)
+        assert nx.transitivity(G) == 0
+
+    def test_cubical(self):
+        G = nx.cubical_graph()
+        assert nx.transitivity(G) == 0
+
+    def test_k5(self):
+        G = nx.complete_graph(5)
+        assert nx.transitivity(G) == 1
+        G.remove_edge(1, 2)
+        assert nx.transitivity(G) == 0.875
+
+
+class TestSquareClustering:
+    def test_clustering(self):
+        G = nx.Graph()
+        assert list(nx.square_clustering(G).values()) == []
+        assert nx.square_clustering(G) == {}
+
+    def test_path(self):
+        G = nx.path_graph(10)
+        assert list(nx.square_clustering(G).values()) == [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+        ]
+        assert nx.square_clustering(G) == {
+            0: 0,
+            1: 0,
+            2: 0,
+            3: 0,
+            4: 0,
+            5: 0,
+            6: 0,
+            7: 0,
+            8: 0,
+            9: 0,
+        }
+
+    def test_cubical(self):
+        G = nx.cubical_graph()
+        assert list(nx.square_clustering(G).values()) == [
+            1 / 3,
+            1 / 3,
+            1 / 3,
+            1 / 3,
+            1 / 3,
+            1 / 3,
+            1 / 3,
+            1 / 3,
+        ]
+        assert list(nx.square_clustering(G, [1, 2]).values()) == [1 / 3, 1 / 3]
+        assert nx.square_clustering(G, [1])[1] == 1 / 3
+        assert nx.square_clustering(G, 1) == 1 / 3
+        assert nx.square_clustering(G, [1, 2]) == {1: 1 / 3, 2: 1 / 3}
+
+    def test_k5(self):
+        G = nx.complete_graph(5)
+        assert list(nx.square_clustering(G).values()) == [1, 1, 1, 1, 1]
+
+    def test_bipartite_k5(self):
+        G = nx.complete_bipartite_graph(5, 5)
+        assert list(nx.square_clustering(G).values()) == [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+
+    def test_lind_square_clustering(self):
+        """Test C4 for figure 1 Lind et al (2005)"""
+        G = nx.Graph(
+            [
+                (1, 2),
+                (1, 3),
+                (1, 6),
+                (1, 7),
+                (2, 4),
+                (2, 5),
+                (3, 4),
+                (3, 5),
+                (6, 7),
+                (7, 8),
+                (6, 8),
+                (7, 9),
+                (7, 10),
+                (6, 11),
+                (6, 12),
+                (2, 13),
+                (2, 14),
+                (3, 15),
+                (3, 16),
+            ]
+        )
+        G1 = G.subgraph([1, 2, 3, 4, 5, 13, 14, 15, 16])
+        G2 = G.subgraph([1, 6, 7, 8, 9, 10, 11, 12])
+        assert nx.square_clustering(G, [1])[1] == 3 / 43
+        assert nx.square_clustering(G1, [1])[1] == 2 / 6
+        assert nx.square_clustering(G2, [1])[1] == 1 / 5
+
+    def test_peng_square_clustering(self):
+        """Test eq2 for figure 1 Peng et al (2008)"""
+        G = nx.Graph([(1, 2), (1, 3), (2, 4), (3, 4), (3, 5), (3, 6)])
+        assert nx.square_clustering(G, [1])[1] == 1 / 3
+
+
+class TestAverageClustering:
+    @classmethod
+    def setup_class(cls):
+        pytest.importorskip("numpy")
+
+    def test_empty(self):
+        G = nx.Graph()
+        with pytest.raises(ZeroDivisionError):
+            nx.average_clustering(G)
+
+    def test_average_clustering(self):
+        G = nx.cycle_graph(3)
+        G.add_edge(2, 3)
+        assert nx.average_clustering(G) == (1 + 1 + 1 / 3) / 4
+        assert nx.average_clustering(G, count_zeros=True) == (1 + 1 + 1 / 3) / 4
+        assert nx.average_clustering(G, count_zeros=False) == (1 + 1 + 1 / 3) / 3
+        assert nx.average_clustering(G, [1, 2, 3]) == (1 + 1 / 3) / 3
+        assert nx.average_clustering(G, [1, 2, 3], count_zeros=True) == (1 + 1 / 3) / 3
+        assert nx.average_clustering(G, [1, 2, 3], count_zeros=False) == (1 + 1 / 3) / 2
+
+    def test_average_clustering_signed(self):
+        G = nx.cycle_graph(3)
+        G.add_edge(2, 3)
+        G.add_edge(0, 1, weight=-1)
+        assert nx.average_clustering(G, weight="weight") == (-1 - 1 - 1 / 3) / 4
+        assert (
+            nx.average_clustering(G, weight="weight", count_zeros=True)
+            == (-1 - 1 - 1 / 3) / 4
+        )
+        assert (
+            nx.average_clustering(G, weight="weight", count_zeros=False)
+            == (-1 - 1 - 1 / 3) / 3
+        )
+
+
+class TestDirectedAverageClustering:
+    @classmethod
+    def setup_class(cls):
+        pytest.importorskip("numpy")
+
+    def test_empty(self):
+        G = nx.DiGraph()
+        with pytest.raises(ZeroDivisionError):
+            nx.average_clustering(G)
+
+    def test_average_clustering(self):
+        G = nx.cycle_graph(3, create_using=nx.DiGraph())
+        G.add_edge(2, 3)
+        assert nx.average_clustering(G) == (1 + 1 + 1 / 3) / 8
+        assert nx.average_clustering(G, count_zeros=True) == (1 + 1 + 1 / 3) / 8
+        assert nx.average_clustering(G, count_zeros=False) == (1 + 1 + 1 / 3) / 6
+        assert nx.average_clustering(G, [1, 2, 3]) == (1 + 1 / 3) / 6
+        assert nx.average_clustering(G, [1, 2, 3], count_zeros=True) == (1 + 1 / 3) / 6
+        assert nx.average_clustering(G, [1, 2, 3], count_zeros=False) == (1 + 1 / 3) / 4
+
+
+class TestGeneralizedDegree:
+    def test_generalized_degree(self):
+        G = nx.Graph()
+        assert nx.generalized_degree(G) == {}
+
+    def test_path(self):
+        G = nx.path_graph(5)
+        assert nx.generalized_degree(G, 0) == {0: 1}
+        assert nx.generalized_degree(G, 1) == {0: 2}
+
+    def test_cubical(self):
+        G = nx.cubical_graph()
+        assert nx.generalized_degree(G, 0) == {0: 3}
+
+    def test_k5(self):
+        G = nx.complete_graph(5)
+        assert nx.generalized_degree(G, 0) == {3: 4}
+        G.remove_edge(0, 1)
+        assert nx.generalized_degree(G, 0) == {2: 3}
+        assert nx.generalized_degree(G, [1, 2]) == {1: {2: 3}, 2: {2: 2, 3: 2}}
+        assert nx.generalized_degree(G) == {
+            0: {2: 3},
+            1: {2: 3},
+            2: {2: 2, 3: 2},
+            3: {2: 2, 3: 2},
+            4: {2: 2, 3: 2},
+        }
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_communicability.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_communicability.py
new file mode 100644
index 0000000..bf21988
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_communicability.py
@@ -0,0 +1,81 @@
+from collections import defaultdict
+
+import pytest
+
+pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+from networkx.algorithms.communicability_alg import communicability, communicability_exp
+
+
+class TestCommunicability:
+    def test_communicability(self):
+        answer = {
+            0: {0: 1.5430806348152435, 1: 1.1752011936438012},
+            1: {0: 1.1752011936438012, 1: 1.5430806348152435},
+        }
+        #        answer={(0, 0): 1.5430806348152435,
+        #                (0, 1): 1.1752011936438012,
+        #                (1, 0): 1.1752011936438012,
+        #                (1, 1): 1.5430806348152435}
+
+        result = communicability(nx.path_graph(2))
+        for k1, val in result.items():
+            for k2 in val:
+                assert answer[k1][k2] == pytest.approx(result[k1][k2], abs=1e-7)
+
+    def test_communicability2(self):
+
+        answer_orig = {
+            ("1", "1"): 1.6445956054135658,
+            ("1", "Albert"): 0.7430186221096251,
+            ("1", "Aric"): 0.7430186221096251,
+            ("1", "Dan"): 1.6208126320442937,
+            ("1", "Franck"): 0.42639707170035257,
+            ("Albert", "1"): 0.7430186221096251,
+            ("Albert", "Albert"): 2.4368257358712189,
+            ("Albert", "Aric"): 1.4368257358712191,
+            ("Albert", "Dan"): 2.0472097037446453,
+            ("Albert", "Franck"): 1.8340111678944691,
+            ("Aric", "1"): 0.7430186221096251,
+            ("Aric", "Albert"): 1.4368257358712191,
+            ("Aric", "Aric"): 2.4368257358712193,
+            ("Aric", "Dan"): 2.0472097037446457,
+            ("Aric", "Franck"): 1.8340111678944691,
+            ("Dan", "1"): 1.6208126320442937,
+            ("Dan", "Albert"): 2.0472097037446453,
+            ("Dan", "Aric"): 2.0472097037446457,
+            ("Dan", "Dan"): 3.1306328496328168,
+            ("Dan", "Franck"): 1.4860372442192515,
+            ("Franck", "1"): 0.42639707170035257,
+            ("Franck", "Albert"): 1.8340111678944691,
+            ("Franck", "Aric"): 1.8340111678944691,
+            ("Franck", "Dan"): 1.4860372442192515,
+            ("Franck", "Franck"): 2.3876142275231915,
+        }
+
+        answer = defaultdict(dict)
+        for (k1, k2), v in answer_orig.items():
+            answer[k1][k2] = v
+
+        G1 = nx.Graph(
+            [
+                ("Franck", "Aric"),
+                ("Aric", "Dan"),
+                ("Dan", "Albert"),
+                ("Albert", "Franck"),
+                ("Dan", "1"),
+                ("Franck", "Albert"),
+            ]
+        )
+
+        result = communicability(G1)
+        for k1, val in result.items():
+            for k2 in val:
+                assert answer[k1][k2] == pytest.approx(result[k1][k2], abs=1e-7)
+
+        result = communicability_exp(G1)
+        for k1, val in result.items():
+            for k2 in val:
+                assert answer[k1][k2] == pytest.approx(result[k1][k2], abs=1e-7)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_core.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_core.py
new file mode 100644
index 0000000..db2d277
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_core.py
@@ -0,0 +1,171 @@
+import networkx as nx
+from networkx.utils import nodes_equal
+
+
+class TestCore:
+    @classmethod
+    def setup_class(cls):
+        # G is the example graph in Figure 1 from Batagelj and
+        # Zaversnik's paper titled An O(m) Algorithm for Cores
+        # Decomposition of Networks, 2003,
+        # http://arXiv.org/abs/cs/0310049.  With nodes labeled as
+        # shown, the 3-core is given by nodes 1-8, the 2-core by nodes
+        # 9-16, the 1-core by nodes 17-20 and node 21 is in the
+        # 0-core.
+        t1 = nx.convert_node_labels_to_integers(nx.tetrahedral_graph(), 1)
+        t2 = nx.convert_node_labels_to_integers(t1, 5)
+        G = nx.union(t1, t2)
+        G.add_edges_from(
+            [
+                (3, 7),
+                (2, 11),
+                (11, 5),
+                (11, 12),
+                (5, 12),
+                (12, 19),
+                (12, 18),
+                (3, 9),
+                (7, 9),
+                (7, 10),
+                (9, 10),
+                (9, 20),
+                (17, 13),
+                (13, 14),
+                (14, 15),
+                (15, 16),
+                (16, 13),
+            ]
+        )
+        G.add_node(21)
+        cls.G = G
+
+        # Create the graph H resulting from the degree sequence
+        # [0, 1, 2, 2, 2, 2, 3] when using the Havel-Hakimi algorithm.
+
+        degseq = [0, 1, 2, 2, 2, 2, 3]
+        H = nx.havel_hakimi_graph(degseq)
+        mapping = {6: 0, 0: 1, 4: 3, 5: 6, 3: 4, 1: 2, 2: 5}
+        cls.H = nx.relabel_nodes(H, mapping)
+
+    def test_trivial(self):
+        """Empty graph"""
+        G = nx.Graph()
+        assert nx.core_number(G) == {}
+
+    def test_core_number(self):
+        core = nx.core_number(self.G)
+        nodes_by_core = [sorted(n for n in core if core[n] == val) for val in range(4)]
+        assert nodes_equal(nodes_by_core[0], [21])
+        assert nodes_equal(nodes_by_core[1], [17, 18, 19, 20])
+        assert nodes_equal(nodes_by_core[2], [9, 10, 11, 12, 13, 14, 15, 16])
+        assert nodes_equal(nodes_by_core[3], [1, 2, 3, 4, 5, 6, 7, 8])
+
+    def test_core_number2(self):
+        core = nx.core_number(self.H)
+        nodes_by_core = [sorted(n for n in core if core[n] == val) for val in range(3)]
+        assert nodes_equal(nodes_by_core[0], [0])
+        assert nodes_equal(nodes_by_core[1], [1, 3])
+        assert nodes_equal(nodes_by_core[2], [2, 4, 5, 6])
+
+    def test_directed_core_number(self):
+        """core number had a bug for directed graphs found in issue #1959"""
+        # small example where too timid edge removal can make cn[2] = 3
+        G = nx.DiGraph()
+        edges = [(1, 2), (2, 1), (2, 3), (2, 4), (3, 4), (4, 3)]
+        G.add_edges_from(edges)
+        assert nx.core_number(G) == {1: 2, 2: 2, 3: 2, 4: 2}
+        # small example where too aggressive edge removal can make cn[2] = 2
+        more_edges = [(1, 5), (3, 5), (4, 5), (3, 6), (4, 6), (5, 6)]
+        G.add_edges_from(more_edges)
+        assert nx.core_number(G) == {1: 3, 2: 3, 3: 3, 4: 3, 5: 3, 6: 3}
+
+    def test_main_core(self):
+        main_core_subgraph = nx.k_core(self.H)
+        assert sorted(main_core_subgraph.nodes()) == [2, 4, 5, 6]
+
+    def test_k_core(self):
+        # k=0
+        k_core_subgraph = nx.k_core(self.H, k=0)
+        assert sorted(k_core_subgraph.nodes()) == sorted(self.H.nodes())
+        # k=1
+        k_core_subgraph = nx.k_core(self.H, k=1)
+        assert sorted(k_core_subgraph.nodes()) == [1, 2, 3, 4, 5, 6]
+        # k = 2
+        k_core_subgraph = nx.k_core(self.H, k=2)
+        assert sorted(k_core_subgraph.nodes()) == [2, 4, 5, 6]
+
+    def test_main_crust(self):
+        main_crust_subgraph = nx.k_crust(self.H)
+        assert sorted(main_crust_subgraph.nodes()) == [0, 1, 3]
+
+    def test_k_crust(self):
+        # k = 0
+        k_crust_subgraph = nx.k_crust(self.H, k=2)
+        assert sorted(k_crust_subgraph.nodes()) == sorted(self.H.nodes())
+        # k=1
+        k_crust_subgraph = nx.k_crust(self.H, k=1)
+        assert sorted(k_crust_subgraph.nodes()) == [0, 1, 3]
+        # k=2
+        k_crust_subgraph = nx.k_crust(self.H, k=0)
+        assert sorted(k_crust_subgraph.nodes()) == [0]
+
+    def test_main_shell(self):
+        main_shell_subgraph = nx.k_shell(self.H)
+        assert sorted(main_shell_subgraph.nodes()) == [2, 4, 5, 6]
+
+    def test_k_shell(self):
+        # k=0
+        k_shell_subgraph = nx.k_shell(self.H, k=2)
+        assert sorted(k_shell_subgraph.nodes()) == [2, 4, 5, 6]
+        # k=1
+        k_shell_subgraph = nx.k_shell(self.H, k=1)
+        assert sorted(k_shell_subgraph.nodes()) == [1, 3]
+        # k=2
+        k_shell_subgraph = nx.k_shell(self.H, k=0)
+        assert sorted(k_shell_subgraph.nodes()) == [0]
+
+    def test_k_corona(self):
+        # k=0
+        k_corona_subgraph = nx.k_corona(self.H, k=2)
+        assert sorted(k_corona_subgraph.nodes()) == [2, 4, 5, 6]
+        # k=1
+        k_corona_subgraph = nx.k_corona(self.H, k=1)
+        assert sorted(k_corona_subgraph.nodes()) == [1]
+        # k=2
+        k_corona_subgraph = nx.k_corona(self.H, k=0)
+        assert sorted(k_corona_subgraph.nodes()) == [0]
+
+    def test_k_truss(self):
+        # k=-1
+        k_truss_subgraph = nx.k_truss(self.G, -1)
+        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 21))
+        # k=0
+        k_truss_subgraph = nx.k_truss(self.G, 0)
+        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 21))
+        # k=1
+        k_truss_subgraph = nx.k_truss(self.G, 1)
+        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 21))
+        # k=2
+        k_truss_subgraph = nx.k_truss(self.G, 2)
+        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 21))
+        # k=3
+        k_truss_subgraph = nx.k_truss(self.G, 3)
+        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 13))
+
+        k_truss_subgraph = nx.k_truss(self.G, 4)
+        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 9))
+
+        k_truss_subgraph = nx.k_truss(self.G, 5)
+        assert sorted(k_truss_subgraph.nodes()) == []
+
+    def test_onion_layers(self):
+        layers = nx.onion_layers(self.G)
+        nodes_by_layer = [
+            sorted(n for n in layers if layers[n] == val) for val in range(1, 7)
+        ]
+        assert nodes_equal(nodes_by_layer[0], [21])
+        assert nodes_equal(nodes_by_layer[1], [17, 18, 19, 20])
+        assert nodes_equal(nodes_by_layer[2], [10, 12, 13, 14, 15, 16])
+        assert nodes_equal(nodes_by_layer[3], [9, 11])
+        assert nodes_equal(nodes_by_layer[4], [1, 2, 4, 5, 6, 8])
+        assert nodes_equal(nodes_by_layer[5], [3, 7])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_covering.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_covering.py
new file mode 100644
index 0000000..4097196
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_covering.py
@@ -0,0 +1,74 @@
+import networkx as nx
+
+
+class TestMinEdgeCover:
+    """Tests for :func:`networkx.algorithms.min_edge_cover`"""
+
+    def test_empty_graph(self):
+        G = nx.Graph()
+        assert nx.min_edge_cover(G) == set()
+
+    def test_graph_with_loop(self):
+        G = nx.Graph()
+        G.add_edge(0, 0)
+        assert nx.min_edge_cover(G) == {(0, 0)}
+
+    def test_graph_single_edge(self):
+        G = nx.Graph([(0, 1)])
+        assert nx.min_edge_cover(G) in ({(0, 1)}, {(1, 0)})
+
+    def test_graph_two_edge_path(self):
+        G = nx.path_graph(3)
+        min_cover = nx.min_edge_cover(G)
+        assert len(min_cover) == 2
+        for u, v in G.edges:
+            assert (u, v) in min_cover or (v, u) in min_cover
+
+    def test_bipartite_explicit(self):
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3, 4], bipartite=0)
+        G.add_nodes_from(["a", "b", "c"], bipartite=1)
+        G.add_edges_from([(1, "a"), (1, "b"), (2, "b"), (2, "c"), (3, "c"), (4, "a")])
+        # Use bipartite method by prescribing the algorithm
+        min_cover = nx.min_edge_cover(
+            G, nx.algorithms.bipartite.matching.eppstein_matching
+        )
+        assert nx.is_edge_cover(G, min_cover)
+        assert len(min_cover) == 8
+        # Use the default method which is not specialized for bipartite
+        min_cover2 = nx.min_edge_cover(G)
+        assert nx.is_edge_cover(G, min_cover2)
+        assert len(min_cover2) == 4
+
+    def test_complete_graph_even(self):
+        G = nx.complete_graph(10)
+        min_cover = nx.min_edge_cover(G)
+        assert nx.is_edge_cover(G, min_cover)
+        assert len(min_cover) == 5
+
+    def test_complete_graph_odd(self):
+        G = nx.complete_graph(11)
+        min_cover = nx.min_edge_cover(G)
+        assert nx.is_edge_cover(G, min_cover)
+        assert len(min_cover) == 6
+
+
+class TestIsEdgeCover:
+    """Tests for :func:`networkx.algorithms.is_edge_cover`"""
+
+    def test_empty_graph(self):
+        G = nx.Graph()
+        assert nx.is_edge_cover(G, set())
+
+    def test_graph_with_loop(self):
+        G = nx.Graph()
+        G.add_edge(1, 1)
+        assert nx.is_edge_cover(G, {(1, 1)})
+
+    def test_graph_single_edge(self):
+        G = nx.Graph()
+        G.add_edge(0, 1)
+        assert nx.is_edge_cover(G, {(0, 0), (1, 1)})
+        assert nx.is_edge_cover(G, {(0, 1), (1, 0)})
+        assert nx.is_edge_cover(G, {(0, 1)})
+        assert not nx.is_edge_cover(G, {(0, 0)})
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_cuts.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_cuts.py
new file mode 100644
index 0000000..6d8656e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_cuts.py
@@ -0,0 +1,172 @@
+"""Unit tests for the :mod:`networkx.algorithms.cuts` module."""
+
+
+import networkx as nx
+
+
+class TestCutSize:
+    """Unit tests for the :func:`~networkx.cut_size` function."""
+
+    def test_symmetric(self):
+        """Tests that the cut size is symmetric."""
+        G = nx.barbell_graph(3, 0)
+        S = {0, 1, 4}
+        T = {2, 3, 5}
+        assert nx.cut_size(G, S, T) == 4
+        assert nx.cut_size(G, T, S) == 4
+
+    def test_single_edge(self):
+        """Tests for a cut of a single edge."""
+        G = nx.barbell_graph(3, 0)
+        S = {0, 1, 2}
+        T = {3, 4, 5}
+        assert nx.cut_size(G, S, T) == 1
+        assert nx.cut_size(G, T, S) == 1
+
+    def test_directed(self):
+        """Tests that each directed edge is counted once in the cut."""
+        G = nx.barbell_graph(3, 0).to_directed()
+        S = {0, 1, 2}
+        T = {3, 4, 5}
+        assert nx.cut_size(G, S, T) == 2
+        assert nx.cut_size(G, T, S) == 2
+
+    def test_directed_symmetric(self):
+        """Tests that a cut in a directed graph is symmetric."""
+        G = nx.barbell_graph(3, 0).to_directed()
+        S = {0, 1, 4}
+        T = {2, 3, 5}
+        assert nx.cut_size(G, S, T) == 8
+        assert nx.cut_size(G, T, S) == 8
+
+    def test_multigraph(self):
+        """Tests that parallel edges are each counted for a cut."""
+        G = nx.MultiGraph(["ab", "ab"])
+        assert nx.cut_size(G, {"a"}, {"b"}) == 2
+
+
+class TestVolume:
+    """Unit tests for the :func:`~networkx.volume` function."""
+
+    def test_graph(self):
+        G = nx.cycle_graph(4)
+        assert nx.volume(G, {0, 1}) == 4
+
+    def test_digraph(self):
+        G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 0)])
+        assert nx.volume(G, {0, 1}) == 2
+
+    def test_multigraph(self):
+        edges = list(nx.cycle_graph(4).edges())
+        G = nx.MultiGraph(edges * 2)
+        assert nx.volume(G, {0, 1}) == 8
+
+    def test_multidigraph(self):
+        edges = [(0, 1), (1, 2), (2, 3), (3, 0)]
+        G = nx.MultiDiGraph(edges * 2)
+        assert nx.volume(G, {0, 1}) == 4
+
+    def test_barbell(self):
+        G = nx.barbell_graph(3, 0)
+        assert nx.volume(G, {0, 1, 2}) == 7
+        assert nx.volume(G, {3, 4, 5}) == 7
+
+
+class TestNormalizedCutSize:
+    """Unit tests for the :func:`~networkx.normalized_cut_size` function."""
+
+    def test_graph(self):
+        G = nx.path_graph(4)
+        S = {1, 2}
+        T = set(G) - S
+        size = nx.normalized_cut_size(G, S, T)
+        # The cut looks like this: o-{-o--o-}-o
+        expected = 2 * ((1 / 4) + (1 / 2))
+        assert expected == size
+        # Test with no input T
+        assert expected == nx.normalized_cut_size(G, S)
+
+    def test_directed(self):
+        G = nx.DiGraph([(0, 1), (1, 2), (2, 3)])
+        S = {1, 2}
+        T = set(G) - S
+        size = nx.normalized_cut_size(G, S, T)
+        # The cut looks like this: o-{->o-->o-}->o
+        expected = 2 * ((1 / 2) + (1 / 1))
+        assert expected == size
+        # Test with no input T
+        assert expected == nx.normalized_cut_size(G, S)
+
+
+class TestConductance:
+    """Unit tests for the :func:`~networkx.conductance` function."""
+
+    def test_graph(self):
+        G = nx.barbell_graph(5, 0)
+        # Consider the singleton sets containing the "bridge" nodes.
+        # There is only one cut edge, and each set has volume five.
+        S = {4}
+        T = {5}
+        conductance = nx.conductance(G, S, T)
+        expected = 1 / 5
+        assert expected == conductance
+        # Test with no input T
+        G2 = nx.barbell_graph(3, 0)
+        # There is only one cut edge, and each set has volume seven.
+        S2 = {0, 1, 2}
+        assert nx.conductance(G2, S2) == 1 / 7
+
+
+class TestEdgeExpansion:
+    """Unit tests for the :func:`~networkx.edge_expansion` function."""
+
+    def test_graph(self):
+        G = nx.barbell_graph(5, 0)
+        S = set(range(5))
+        T = set(G) - S
+        expansion = nx.edge_expansion(G, S, T)
+        expected = 1 / 5
+        assert expected == expansion
+        # Test with no input T
+        assert expected == nx.edge_expansion(G, S)
+
+
+class TestNodeExpansion:
+    """Unit tests for the :func:`~networkx.node_expansion` function."""
+
+    def test_graph(self):
+        G = nx.path_graph(8)
+        S = {3, 4, 5}
+        expansion = nx.node_expansion(G, S)
+        # The neighborhood of S has cardinality five, and S has
+        # cardinality three.
+        expected = 5 / 3
+        assert expected == expansion
+
+
+class TestBoundaryExpansion:
+    """Unit tests for the :func:`~networkx.boundary_expansion` function."""
+
+    def test_graph(self):
+        G = nx.complete_graph(10)
+        S = set(range(4))
+        expansion = nx.boundary_expansion(G, S)
+        # The node boundary of S has cardinality six, and S has
+        # cardinality three.
+        expected = 6 / 4
+        assert expected == expansion
+
+
+class TestMixingExpansion:
+    """Unit tests for the :func:`~networkx.mixing_expansion` function."""
+
+    def test_graph(self):
+        G = nx.barbell_graph(5, 0)
+        S = set(range(5))
+        T = set(G) - S
+        expansion = nx.mixing_expansion(G, S, T)
+        # There is one cut edge, and the total number of edges in the
+        # graph is twice the total number of edges in a clique of size
+        # five, plus one more for the bridge.
+        expected = 1 / (2 * (5 * 4 + 1))
+        assert expected == expansion
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_cycles.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_cycles.py
new file mode 100644
index 0000000..42a2f01
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_cycles.py
@@ -0,0 +1,347 @@
+import pytest
+
+import networkx
+import networkx as nx
+from networkx.algorithms import find_cycle, minimum_cycle_basis
+from networkx.algorithms.traversal.edgedfs import FORWARD, REVERSE
+
+
+class TestCycles:
+    @classmethod
+    def setup_class(cls):
+        G = networkx.Graph()
+        nx.add_cycle(G, [0, 1, 2, 3])
+        nx.add_cycle(G, [0, 3, 4, 5])
+        nx.add_cycle(G, [0, 1, 6, 7, 8])
+        G.add_edge(8, 9)
+        cls.G = G
+
+    def is_cyclic_permutation(self, a, b):
+        n = len(a)
+        if len(b) != n:
+            return False
+        l = a + a
+        return any(l[i : i + n] == b for i in range(n))
+
+    def test_cycle_basis(self):
+        G = self.G
+        cy = networkx.cycle_basis(G, 0)
+        sort_cy = sorted(sorted(c) for c in cy)
+        assert sort_cy == [[0, 1, 2, 3], [0, 1, 6, 7, 8], [0, 3, 4, 5]]
+        cy = networkx.cycle_basis(G, 1)
+        sort_cy = sorted(sorted(c) for c in cy)
+        assert sort_cy == [[0, 1, 2, 3], [0, 1, 6, 7, 8], [0, 3, 4, 5]]
+        cy = networkx.cycle_basis(G, 9)
+        sort_cy = sorted(sorted(c) for c in cy)
+        assert sort_cy == [[0, 1, 2, 3], [0, 1, 6, 7, 8], [0, 3, 4, 5]]
+        # test disconnected graphs
+        nx.add_cycle(G, "ABC")
+        cy = networkx.cycle_basis(G, 9)
+        sort_cy = sorted(sorted(c) for c in cy[:-1]) + [sorted(cy[-1])]
+        assert sort_cy == [[0, 1, 2, 3], [0, 1, 6, 7, 8], [0, 3, 4, 5], ["A", "B", "C"]]
+
+    def test_cycle_basis2(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            G = nx.DiGraph()
+            cy = networkx.cycle_basis(G, 0)
+
+    def test_cycle_basis3(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            G = nx.MultiGraph()
+            cy = networkx.cycle_basis(G, 0)
+
+    def test_simple_cycles(self):
+        edges = [(0, 0), (0, 1), (0, 2), (1, 2), (2, 0), (2, 1), (2, 2)]
+        G = nx.DiGraph(edges)
+        cc = sorted(nx.simple_cycles(G))
+        ca = [[0], [0, 1, 2], [0, 2], [1, 2], [2]]
+        assert len(cc) == len(ca)
+        for c in cc:
+            assert any(self.is_cyclic_permutation(c, rc) for rc in ca)
+
+    def test_simple_cycles_graph(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            G = nx.Graph()
+            c = sorted(nx.simple_cycles(G))
+
+    def test_unsortable(self):
+        #  TODO What does this test do?  das 6/2013
+        G = nx.DiGraph()
+        nx.add_cycle(G, ["a", 1])
+        c = list(nx.simple_cycles(G))
+
+    def test_simple_cycles_small(self):
+        G = nx.DiGraph()
+        nx.add_cycle(G, [1, 2, 3])
+        c = sorted(nx.simple_cycles(G))
+        assert len(c) == 1
+        assert self.is_cyclic_permutation(c[0], [1, 2, 3])
+        nx.add_cycle(G, [10, 20, 30])
+        cc = sorted(nx.simple_cycles(G))
+        assert len(cc) == 2
+        ca = [[1, 2, 3], [10, 20, 30]]
+        for c in cc:
+            assert any(self.is_cyclic_permutation(c, rc) for rc in ca)
+
+    def test_simple_cycles_empty(self):
+        G = nx.DiGraph()
+        assert list(nx.simple_cycles(G)) == []
+
+    def test_complete_directed_graph(self):
+        # see table 2 in Johnson's paper
+        ncircuits = [1, 5, 20, 84, 409, 2365, 16064]
+        for n, c in zip(range(2, 9), ncircuits):
+            G = nx.DiGraph(nx.complete_graph(n))
+            assert len(list(nx.simple_cycles(G))) == c
+
+    def worst_case_graph(self, k):
+        # see figure 1 in Johnson's paper
+        # this graph has exactly 3k simple cycles
+        G = nx.DiGraph()
+        for n in range(2, k + 2):
+            G.add_edge(1, n)
+            G.add_edge(n, k + 2)
+        G.add_edge(2 * k + 1, 1)
+        for n in range(k + 2, 2 * k + 2):
+            G.add_edge(n, 2 * k + 2)
+            G.add_edge(n, n + 1)
+        G.add_edge(2 * k + 3, k + 2)
+        for n in range(2 * k + 3, 3 * k + 3):
+            G.add_edge(2 * k + 2, n)
+            G.add_edge(n, 3 * k + 3)
+        G.add_edge(3 * k + 3, 2 * k + 2)
+        return G
+
+    def test_worst_case_graph(self):
+        # see figure 1 in Johnson's paper
+        for k in range(3, 10):
+            G = self.worst_case_graph(k)
+            l = len(list(nx.simple_cycles(G)))
+            assert l == 3 * k
+
+    def test_recursive_simple_and_not(self):
+        for k in range(2, 10):
+            G = self.worst_case_graph(k)
+            cc = sorted(nx.simple_cycles(G))
+            rcc = sorted(nx.recursive_simple_cycles(G))
+            assert len(cc) == len(rcc)
+            for c in cc:
+                assert any(self.is_cyclic_permutation(c, r) for r in rcc)
+            for rc in rcc:
+                assert any(self.is_cyclic_permutation(rc, c) for c in cc)
+
+    def test_simple_graph_with_reported_bug(self):
+        G = nx.DiGraph()
+        edges = [
+            (0, 2),
+            (0, 3),
+            (1, 0),
+            (1, 3),
+            (2, 1),
+            (2, 4),
+            (3, 2),
+            (3, 4),
+            (4, 0),
+            (4, 1),
+            (4, 5),
+            (5, 0),
+            (5, 1),
+            (5, 2),
+            (5, 3),
+        ]
+        G.add_edges_from(edges)
+        cc = sorted(nx.simple_cycles(G))
+        assert len(cc) == 26
+        rcc = sorted(nx.recursive_simple_cycles(G))
+        assert len(cc) == len(rcc)
+        for c in cc:
+            assert any(self.is_cyclic_permutation(c, rc) for rc in rcc)
+        for rc in rcc:
+            assert any(self.is_cyclic_permutation(rc, c) for c in cc)
+
+
+# These tests might fail with hash randomization since they depend on
+# edge_dfs. For more information, see the comments in:
+#    networkx/algorithms/traversal/tests/test_edgedfs.py
+
+
+class TestFindCycle:
+    @classmethod
+    def setup_class(cls):
+        cls.nodes = [0, 1, 2, 3]
+        cls.edges = [(-1, 0), (0, 1), (1, 0), (1, 0), (2, 1), (3, 1)]
+
+    def test_graph_nocycle(self):
+        G = nx.Graph(self.edges)
+        pytest.raises(nx.exception.NetworkXNoCycle, find_cycle, G, self.nodes)
+
+    def test_graph_cycle(self):
+        G = nx.Graph(self.edges)
+        G.add_edge(2, 0)
+        x = list(find_cycle(G, self.nodes))
+        x_ = [(0, 1), (1, 2), (2, 0)]
+        assert x == x_
+
+    def test_graph_orientation_none(self):
+        G = nx.Graph(self.edges)
+        G.add_edge(2, 0)
+        x = list(find_cycle(G, self.nodes, orientation=None))
+        x_ = [(0, 1), (1, 2), (2, 0)]
+        assert x == x_
+
+    def test_graph_orientation_original(self):
+        G = nx.Graph(self.edges)
+        G.add_edge(2, 0)
+        x = list(find_cycle(G, self.nodes, orientation="original"))
+        x_ = [(0, 1, FORWARD), (1, 2, FORWARD), (2, 0, FORWARD)]
+        assert x == x_
+
+    def test_digraph(self):
+        G = nx.DiGraph(self.edges)
+        x = list(find_cycle(G, self.nodes))
+        x_ = [(0, 1), (1, 0)]
+        assert x == x_
+
+    def test_digraph_orientation_none(self):
+        G = nx.DiGraph(self.edges)
+        x = list(find_cycle(G, self.nodes, orientation=None))
+        x_ = [(0, 1), (1, 0)]
+        assert x == x_
+
+    def test_digraph_orientation_original(self):
+        G = nx.DiGraph(self.edges)
+        x = list(find_cycle(G, self.nodes, orientation="original"))
+        x_ = [(0, 1, FORWARD), (1, 0, FORWARD)]
+        assert x == x_
+
+    def test_multigraph(self):
+        G = nx.MultiGraph(self.edges)
+        x = list(find_cycle(G, self.nodes))
+        x_ = [(0, 1, 0), (1, 0, 1)]  # or (1, 0, 2)
+        # Hash randomization...could be any edge.
+        assert x[0] == x_[0]
+        assert x[1][:2] == x_[1][:2]
+
+    def test_multidigraph(self):
+        G = nx.MultiDiGraph(self.edges)
+        x = list(find_cycle(G, self.nodes))
+        x_ = [(0, 1, 0), (1, 0, 0)]  # (1, 0, 1)
+        assert x[0] == x_[0]
+        assert x[1][:2] == x_[1][:2]
+
+    def test_digraph_ignore(self):
+        G = nx.DiGraph(self.edges)
+        x = list(find_cycle(G, self.nodes, orientation="ignore"))
+        x_ = [(0, 1, FORWARD), (1, 0, FORWARD)]
+        assert x == x_
+
+    def test_digraph_reverse(self):
+        G = nx.DiGraph(self.edges)
+        x = list(find_cycle(G, self.nodes, orientation="reverse"))
+        x_ = [(1, 0, REVERSE), (0, 1, REVERSE)]
+        assert x == x_
+
+    def test_multidigraph_ignore(self):
+        G = nx.MultiDiGraph(self.edges)
+        x = list(find_cycle(G, self.nodes, orientation="ignore"))
+        x_ = [(0, 1, 0, FORWARD), (1, 0, 0, FORWARD)]  # or (1, 0, 1, 1)
+        assert x[0] == x_[0]
+        assert x[1][:2] == x_[1][:2]
+        assert x[1][3] == x_[1][3]
+
+    def test_multidigraph_ignore2(self):
+        # Loop traversed an edge while ignoring its orientation.
+        G = nx.MultiDiGraph([(0, 1), (1, 2), (1, 2)])
+        x = list(find_cycle(G, [0, 1, 2], orientation="ignore"))
+        x_ = [(1, 2, 0, FORWARD), (1, 2, 1, REVERSE)]
+        assert x == x_
+
+    def test_multidigraph_original(self):
+        # Node 2 doesn't need to be searched again from visited from 4.
+        # The goal here is to cover the case when 2 to be researched from 4,
+        # when 4 is visited from the first time (so we must make sure that 4
+        # is not visited from 2, and hence, we respect the edge orientation).
+        G = nx.MultiDiGraph([(0, 1), (1, 2), (2, 3), (4, 2)])
+        pytest.raises(
+            nx.exception.NetworkXNoCycle,
+            find_cycle,
+            G,
+            [0, 1, 2, 3, 4],
+            orientation="original",
+        )
+
+    def test_dag(self):
+        G = nx.DiGraph([(0, 1), (0, 2), (1, 2)])
+        pytest.raises(
+            nx.exception.NetworkXNoCycle, find_cycle, G, orientation="original"
+        )
+        x = list(find_cycle(G, orientation="ignore"))
+        assert x == [(0, 1, FORWARD), (1, 2, FORWARD), (0, 2, REVERSE)]
+
+    def test_prev_explored(self):
+        # https://github.com/networkx/networkx/issues/2323
+
+        G = nx.DiGraph()
+        G.add_edges_from([(1, 0), (2, 0), (1, 2), (2, 1)])
+        pytest.raises(nx.NetworkXNoCycle, find_cycle, G, source=0)
+        x = list(nx.find_cycle(G, 1))
+        x_ = [(1, 2), (2, 1)]
+        assert x == x_
+
+        x = list(nx.find_cycle(G, 2))
+        x_ = [(2, 1), (1, 2)]
+        assert x == x_
+
+        x = list(nx.find_cycle(G))
+        x_ = [(1, 2), (2, 1)]
+        assert x == x_
+
+    def test_no_cycle(self):
+        # https://github.com/networkx/networkx/issues/2439
+
+        G = nx.DiGraph()
+        G.add_edges_from([(1, 2), (2, 0), (3, 1), (3, 2)])
+        pytest.raises(nx.NetworkXNoCycle, find_cycle, G, source=0)
+        pytest.raises(nx.NetworkXNoCycle, find_cycle, G)
+
+
+def assert_basis_equal(a, b):
+    assert sorted(a) == sorted(b)
+
+
+class TestMinimumCycles:
+    @classmethod
+    def setup_class(cls):
+        T = nx.Graph()
+        nx.add_cycle(T, [1, 2, 3, 4], weight=1)
+        T.add_edge(2, 4, weight=5)
+        cls.diamond_graph = T
+
+    def test_unweighted_diamond(self):
+        mcb = minimum_cycle_basis(self.diamond_graph)
+        assert_basis_equal([sorted(c) for c in mcb], [[1, 2, 4], [2, 3, 4]])
+
+    def test_weighted_diamond(self):
+        mcb = minimum_cycle_basis(self.diamond_graph, weight="weight")
+        assert_basis_equal([sorted(c) for c in mcb], [[1, 2, 4], [1, 2, 3, 4]])
+
+    def test_dimensionality(self):
+        # checks |MCB|=|E|-|V|+|NC|
+        ntrial = 10
+        for _ in range(ntrial):
+            rg = nx.erdos_renyi_graph(10, 0.3)
+            nnodes = rg.number_of_nodes()
+            nedges = rg.number_of_edges()
+            ncomp = nx.number_connected_components(rg)
+
+            dim_mcb = len(minimum_cycle_basis(rg))
+            assert dim_mcb == nedges - nnodes + ncomp
+
+    def test_complete_graph(self):
+        cg = nx.complete_graph(5)
+        mcb = minimum_cycle_basis(cg)
+        assert all([len(cycle) == 3 for cycle in mcb])
+
+    def test_tree_graph(self):
+        tg = nx.balanced_tree(3, 3)
+        assert not minimum_cycle_basis(tg)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_d_separation.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_d_separation.py
new file mode 100644
index 0000000..23367a0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_d_separation.py
@@ -0,0 +1,158 @@
+from itertools import combinations
+
+import pytest
+
+import networkx as nx
+
+
+def path_graph():
+    """Return a path graph of length three."""
+    G = nx.path_graph(3, create_using=nx.DiGraph)
+    G.graph["name"] = "path"
+    nx.freeze(G)
+    return G
+
+
+def fork_graph():
+    """Return a three node fork graph."""
+    G = nx.DiGraph(name="fork")
+    G.add_edges_from([(0, 1), (0, 2)])
+    nx.freeze(G)
+    return G
+
+
+def collider_graph():
+    """Return a collider/v-structure graph with three nodes."""
+    G = nx.DiGraph(name="collider")
+    G.add_edges_from([(0, 2), (1, 2)])
+    nx.freeze(G)
+    return G
+
+
+def naive_bayes_graph():
+    """Return a simply Naive Bayes PGM graph."""
+    G = nx.DiGraph(name="naive_bayes")
+    G.add_edges_from([(0, 1), (0, 2), (0, 3), (0, 4)])
+    nx.freeze(G)
+    return G
+
+
+def asia_graph():
+    """Return the 'Asia' PGM graph."""
+    G = nx.DiGraph(name="asia")
+    G.add_edges_from(
+        [
+            ("asia", "tuberculosis"),
+            ("smoking", "cancer"),
+            ("smoking", "bronchitis"),
+            ("tuberculosis", "either"),
+            ("cancer", "either"),
+            ("either", "xray"),
+            ("either", "dyspnea"),
+            ("bronchitis", "dyspnea"),
+        ]
+    )
+    nx.freeze(G)
+    return G
+
+
+@pytest.fixture(name="path_graph")
+def path_graph_fixture():
+    return path_graph()
+
+
+@pytest.fixture(name="fork_graph")
+def fork_graph_fixture():
+    return fork_graph()
+
+
+@pytest.fixture(name="collider_graph")
+def collider_graph_fixture():
+    return collider_graph()
+
+
+@pytest.fixture(name="naive_bayes_graph")
+def naive_bayes_graph_fixture():
+    return naive_bayes_graph()
+
+
+@pytest.fixture(name="asia_graph")
+def asia_graph_fixture():
+    return asia_graph()
+
+
+@pytest.mark.parametrize(
+    "graph",
+    [path_graph(), fork_graph(), collider_graph(), naive_bayes_graph(), asia_graph()],
+)
+def test_markov_condition(graph):
+    """Test that the Markov condition holds for each PGM graph."""
+    for node in graph.nodes:
+        parents = set(graph.predecessors(node))
+        non_descendants = graph.nodes - nx.descendants(graph, node) - {node} - parents
+        assert nx.d_separated(graph, {node}, non_descendants, parents)
+
+
+def test_path_graph_dsep(path_graph):
+    """Example-based test of d-separation for path_graph."""
+    assert nx.d_separated(path_graph, {0}, {2}, {1})
+    assert not nx.d_separated(path_graph, {0}, {2}, {})
+
+
+def test_fork_graph_dsep(fork_graph):
+    """Example-based test of d-separation for fork_graph."""
+    assert nx.d_separated(fork_graph, {1}, {2}, {0})
+    assert not nx.d_separated(fork_graph, {1}, {2}, {})
+
+
+def test_collider_graph_dsep(collider_graph):
+    """Example-based test of d-separation for collider_graph."""
+    assert nx.d_separated(collider_graph, {0}, {1}, {})
+    assert not nx.d_separated(collider_graph, {0}, {1}, {2})
+
+
+def test_naive_bayes_dsep(naive_bayes_graph):
+    """Example-based test of d-separation for naive_bayes_graph."""
+    for u, v in combinations(range(1, 5), 2):
+        assert nx.d_separated(naive_bayes_graph, {u}, {v}, {0})
+        assert not nx.d_separated(naive_bayes_graph, {u}, {v}, {})
+
+
+def test_asia_graph_dsep(asia_graph):
+    """Example-based test of d-separation for asia_graph."""
+    assert nx.d_separated(
+        asia_graph, {"asia", "smoking"}, {"dyspnea", "xray"}, {"bronchitis", "either"}
+    )
+    assert nx.d_separated(
+        asia_graph, {"tuberculosis", "cancer"}, {"bronchitis"}, {"smoking", "xray"}
+    )
+
+
+def test_undirected_graphs_are_not_supported():
+    """
+    Test that undirected graphs are not supported.
+
+    d-separation does not apply in the case of undirected graphs.
+    """
+    with pytest.raises(nx.NetworkXNotImplemented):
+        g = nx.path_graph(3, nx.Graph)
+        nx.d_separated(g, {0}, {1}, {2})
+
+
+def test_cyclic_graphs_raise_error():
+    """
+    Test that cycle graphs should cause erroring.
+
+    This is because PGMs assume a directed acyclic graph.
+    """
+    with pytest.raises(nx.NetworkXError):
+        g = nx.cycle_graph(3, nx.DiGraph)
+        nx.d_separated(g, {0}, {1}, {2})
+
+
+def test_invalid_nodes_raise_error(asia_graph):
+    """
+    Test that graphs that have invalid nodes passed in raise errors.
+    """
+    with pytest.raises(nx.NodeNotFound):
+        nx.d_separated(asia_graph, {0}, {1}, {2})
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_dag.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_dag.py
new file mode 100644
index 0000000..b39b033
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_dag.py
@@ -0,0 +1,710 @@
+from collections import deque
+from itertools import combinations, permutations
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, pairwise
+
+
+# Recipe from the itertools documentation.
+def _consume(iterator):
+    "Consume the iterator entirely."
+    # Feed the entire iterator into a zero-length deque.
+    deque(iterator, maxlen=0)
+
+
+class TestDagLongestPath:
+    """Unit tests computing the longest path in a directed acyclic graph."""
+
+    def test_empty(self):
+        G = nx.DiGraph()
+        assert nx.dag_longest_path(G) == []
+
+    def test_unweighted1(self):
+        edges = [(1, 2), (2, 3), (2, 4), (3, 5), (5, 6), (3, 7)]
+        G = nx.DiGraph(edges)
+        assert nx.dag_longest_path(G) == [1, 2, 3, 5, 6]
+
+    def test_unweighted2(self):
+        edges = [(1, 2), (2, 3), (3, 4), (4, 5), (1, 3), (1, 5), (3, 5)]
+        G = nx.DiGraph(edges)
+        assert nx.dag_longest_path(G) == [1, 2, 3, 4, 5]
+
+    def test_weighted(self):
+        G = nx.DiGraph()
+        edges = [(1, 2, -5), (2, 3, 1), (3, 4, 1), (4, 5, 0), (3, 5, 4), (1, 6, 2)]
+        G.add_weighted_edges_from(edges)
+        assert nx.dag_longest_path(G) == [2, 3, 5]
+
+    def test_undirected_not_implemented(self):
+        G = nx.Graph()
+        pytest.raises(nx.NetworkXNotImplemented, nx.dag_longest_path, G)
+
+    def test_unorderable_nodes(self):
+        """Tests that computing the longest path does not depend on
+        nodes being orderable.
+
+        For more information, see issue #1989.
+
+        """
+        # Create the directed path graph on four nodes in a diamond shape,
+        # with nodes represented as (unorderable) Python objects.
+        nodes = [object() for n in range(4)]
+        G = nx.DiGraph()
+        G.add_edge(nodes[0], nodes[1])
+        G.add_edge(nodes[0], nodes[2])
+        G.add_edge(nodes[2], nodes[3])
+        G.add_edge(nodes[1], nodes[3])
+
+        # this will raise NotImplementedError when nodes need to be ordered
+        nx.dag_longest_path(G)
+
+
+class TestDagLongestPathLength:
+    """Unit tests for computing the length of a longest path in a
+    directed acyclic graph.
+
+    """
+
+    def test_unweighted(self):
+        edges = [(1, 2), (2, 3), (2, 4), (3, 5), (5, 6), (5, 7)]
+        G = nx.DiGraph(edges)
+        assert nx.dag_longest_path_length(G) == 4
+
+        edges = [(1, 2), (2, 3), (3, 4), (4, 5), (1, 3), (1, 5), (3, 5)]
+        G = nx.DiGraph(edges)
+        assert nx.dag_longest_path_length(G) == 4
+
+        # test degenerate graphs
+        G = nx.DiGraph()
+        G.add_node(1)
+        assert nx.dag_longest_path_length(G) == 0
+
+    def test_undirected_not_implemented(self):
+        G = nx.Graph()
+        pytest.raises(nx.NetworkXNotImplemented, nx.dag_longest_path_length, G)
+
+    def test_weighted(self):
+        edges = [(1, 2, -5), (2, 3, 1), (3, 4, 1), (4, 5, 0), (3, 5, 4), (1, 6, 2)]
+        G = nx.DiGraph()
+        G.add_weighted_edges_from(edges)
+        assert nx.dag_longest_path_length(G) == 5
+
+
+class TestDAG:
+    @classmethod
+    def setup_class(cls):
+        pass
+
+    def test_topological_sort1(self):
+        DG = nx.DiGraph([(1, 2), (1, 3), (2, 3)])
+
+        for algorithm in [nx.topological_sort, nx.lexicographical_topological_sort]:
+            assert tuple(algorithm(DG)) == (1, 2, 3)
+
+        DG.add_edge(3, 2)
+
+        for algorithm in [nx.topological_sort, nx.lexicographical_topological_sort]:
+            pytest.raises(nx.NetworkXUnfeasible, _consume, algorithm(DG))
+
+        DG.remove_edge(2, 3)
+
+        for algorithm in [nx.topological_sort, nx.lexicographical_topological_sort]:
+            assert tuple(algorithm(DG)) == (1, 3, 2)
+
+        DG.remove_edge(3, 2)
+
+        assert tuple(nx.topological_sort(DG)) in {(1, 2, 3), (1, 3, 2)}
+        assert tuple(nx.lexicographical_topological_sort(DG)) == (1, 2, 3)
+
+    def test_is_directed_acyclic_graph(self):
+        G = nx.generators.complete_graph(2)
+        assert not nx.is_directed_acyclic_graph(G)
+        assert not nx.is_directed_acyclic_graph(G.to_directed())
+        assert not nx.is_directed_acyclic_graph(nx.Graph([(3, 4), (4, 5)]))
+        assert nx.is_directed_acyclic_graph(nx.DiGraph([(3, 4), (4, 5)]))
+
+    def test_topological_sort2(self):
+        DG = nx.DiGraph(
+            {
+                1: [2],
+                2: [3],
+                3: [4],
+                4: [5],
+                5: [1],
+                11: [12],
+                12: [13],
+                13: [14],
+                14: [15],
+            }
+        )
+        pytest.raises(nx.NetworkXUnfeasible, _consume, nx.topological_sort(DG))
+
+        assert not nx.is_directed_acyclic_graph(DG)
+
+        DG.remove_edge(1, 2)
+        _consume(nx.topological_sort(DG))
+        assert nx.is_directed_acyclic_graph(DG)
+
+    def test_topological_sort3(self):
+        DG = nx.DiGraph()
+        DG.add_edges_from([(1, i) for i in range(2, 5)])
+        DG.add_edges_from([(2, i) for i in range(5, 9)])
+        DG.add_edges_from([(6, i) for i in range(9, 12)])
+        DG.add_edges_from([(4, i) for i in range(12, 15)])
+
+        def validate(order):
+            assert isinstance(order, list)
+            assert set(order) == set(DG)
+            for u, v in combinations(order, 2):
+                assert not nx.has_path(DG, v, u)
+
+        validate(list(nx.topological_sort(DG)))
+
+        DG.add_edge(14, 1)
+        pytest.raises(nx.NetworkXUnfeasible, _consume, nx.topological_sort(DG))
+
+    def test_topological_sort4(self):
+        G = nx.Graph()
+        G.add_edge(1, 2)
+        # Only directed graphs can be topologically sorted.
+        pytest.raises(nx.NetworkXError, _consume, nx.topological_sort(G))
+
+    def test_topological_sort5(self):
+        G = nx.DiGraph()
+        G.add_edge(0, 1)
+        assert list(nx.topological_sort(G)) == [0, 1]
+
+    def test_topological_sort6(self):
+        for algorithm in [nx.topological_sort, nx.lexicographical_topological_sort]:
+
+            def runtime_error():
+                DG = nx.DiGraph([(1, 2), (2, 3), (3, 4)])
+                first = True
+                for x in algorithm(DG):
+                    if first:
+                        first = False
+                        DG.add_edge(5 - x, 5)
+
+            def unfeasible_error():
+                DG = nx.DiGraph([(1, 2), (2, 3), (3, 4)])
+                first = True
+                for x in algorithm(DG):
+                    if first:
+                        first = False
+                        DG.remove_node(4)
+
+            def runtime_error2():
+                DG = nx.DiGraph([(1, 2), (2, 3), (3, 4)])
+                first = True
+                for x in algorithm(DG):
+                    if first:
+                        first = False
+                        DG.remove_node(2)
+
+            pytest.raises(RuntimeError, runtime_error)
+            pytest.raises(RuntimeError, runtime_error2)
+            pytest.raises(nx.NetworkXUnfeasible, unfeasible_error)
+
+    def test_all_topological_sorts_1(self):
+        DG = nx.DiGraph([(1, 2), (2, 3), (3, 4), (4, 5)])
+        assert list(nx.all_topological_sorts(DG)) == [[1, 2, 3, 4, 5]]
+
+    def test_all_topological_sorts_2(self):
+        DG = nx.DiGraph([(1, 3), (2, 1), (2, 4), (4, 3), (4, 5)])
+        assert sorted(nx.all_topological_sorts(DG)) == [
+            [2, 1, 4, 3, 5],
+            [2, 1, 4, 5, 3],
+            [2, 4, 1, 3, 5],
+            [2, 4, 1, 5, 3],
+            [2, 4, 5, 1, 3],
+        ]
+
+    def test_all_topological_sorts_3(self):
+        def unfeasible():
+            DG = nx.DiGraph([(1, 2), (2, 3), (3, 4), (4, 2), (4, 5)])
+            # convert to list to execute generator
+            list(nx.all_topological_sorts(DG))
+
+        def not_implemented():
+            G = nx.Graph([(1, 2), (2, 3)])
+            # convert to list to execute generator
+            list(nx.all_topological_sorts(G))
+
+        def not_implemted_2():
+            G = nx.MultiGraph([(1, 2), (1, 2), (2, 3)])
+            list(nx.all_topological_sorts(G))
+
+        pytest.raises(nx.NetworkXUnfeasible, unfeasible)
+        pytest.raises(nx.NetworkXNotImplemented, not_implemented)
+        pytest.raises(nx.NetworkXNotImplemented, not_implemted_2)
+
+    def test_all_topological_sorts_4(self):
+        DG = nx.DiGraph()
+        for i in range(7):
+            DG.add_node(i)
+        assert sorted(map(list, permutations(DG.nodes))) == sorted(
+            nx.all_topological_sorts(DG)
+        )
+
+    def test_all_topological_sorts_multigraph_1(self):
+        DG = nx.MultiDiGraph([(1, 2), (1, 2), (2, 3), (3, 4), (3, 5), (3, 5), (3, 5)])
+        assert sorted(nx.all_topological_sorts(DG)) == sorted(
+            [[1, 2, 3, 4, 5], [1, 2, 3, 5, 4]]
+        )
+
+    def test_all_topological_sorts_multigraph_2(self):
+        N = 9
+        edges = []
+        for i in range(1, N):
+            edges.extend([(i, i + 1)] * i)
+        DG = nx.MultiDiGraph(edges)
+        assert list(nx.all_topological_sorts(DG)) == [list(range(1, N + 1))]
+
+    def test_ancestors(self):
+        G = nx.DiGraph()
+        ancestors = nx.algorithms.dag.ancestors
+        G.add_edges_from([(1, 2), (1, 3), (4, 2), (4, 3), (4, 5), (2, 6), (5, 6)])
+        assert ancestors(G, 6) == {1, 2, 4, 5}
+        assert ancestors(G, 3) == {1, 4}
+        assert ancestors(G, 1) == set()
+        pytest.raises(nx.NetworkXError, ancestors, G, 8)
+
+    def test_descendants(self):
+        G = nx.DiGraph()
+        descendants = nx.algorithms.dag.descendants
+        G.add_edges_from([(1, 2), (1, 3), (4, 2), (4, 3), (4, 5), (2, 6), (5, 6)])
+        assert descendants(G, 1) == {2, 3, 6}
+        assert descendants(G, 4) == {2, 3, 5, 6}
+        assert descendants(G, 3) == set()
+        pytest.raises(nx.NetworkXError, descendants, G, 8)
+
+    def test_transitive_closure(self):
+        G = nx.DiGraph([(1, 2), (2, 3), (3, 4)])
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        assert edges_equal(nx.transitive_closure(G).edges(), solution)
+        G = nx.DiGraph([(1, 2), (2, 3), (2, 4)])
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4)]
+        assert edges_equal(nx.transitive_closure(G).edges(), solution)
+        G = nx.DiGraph([(1, 2), (2, 3), (3, 1)])
+        solution = [(1, 2), (2, 1), (2, 3), (3, 2), (1, 3), (3, 1)]
+        soln = sorted(solution + [(n, n) for n in G])
+        assert edges_equal(sorted(nx.transitive_closure(G).edges()), soln)
+
+        G = nx.Graph([(1, 2), (2, 3), (3, 4)])
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        assert edges_equal(sorted(nx.transitive_closure(G).edges()), solution)
+
+        G = nx.MultiGraph([(1, 2), (2, 3), (3, 4)])
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        assert edges_equal(sorted(nx.transitive_closure(G).edges()), solution)
+
+        G = nx.MultiDiGraph([(1, 2), (2, 3), (3, 4)])
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        assert edges_equal(sorted(nx.transitive_closure(G).edges()), solution)
+
+        # test if edge data is copied
+        G = nx.DiGraph([(1, 2, {"a": 3}), (2, 3, {"b": 0}), (3, 4)])
+        H = nx.transitive_closure(G)
+        for u, v in G.edges():
+            assert G.get_edge_data(u, v) == H.get_edge_data(u, v)
+
+        k = 10
+        G = nx.DiGraph((i, i + 1, {"f": "b", "weight": i}) for i in range(k))
+        H = nx.transitive_closure(G)
+        for u, v in G.edges():
+            assert G.get_edge_data(u, v) == H.get_edge_data(u, v)
+
+        G = nx.Graph()
+        with pytest.raises(nx.NetworkXError):
+            nx.transitive_closure(G, reflexive="wrong input")
+
+    def test_reflexive_transitive_closure(self):
+        G = nx.DiGraph([(1, 2), (2, 3), (3, 4)])
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        soln = sorted(solution + [(n, n) for n in G])
+        assert edges_equal(nx.transitive_closure(G).edges(), solution)
+        assert edges_equal(nx.transitive_closure(G, False).edges(), solution)
+        assert edges_equal(nx.transitive_closure(G, True).edges(), soln)
+        assert edges_equal(nx.transitive_closure(G, None).edges(), solution)
+
+        G = nx.DiGraph([(1, 2), (2, 3), (2, 4)])
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4)]
+        soln = sorted(solution + [(n, n) for n in G])
+        assert edges_equal(nx.transitive_closure(G).edges(), solution)
+        assert edges_equal(nx.transitive_closure(G, False).edges(), solution)
+        assert edges_equal(nx.transitive_closure(G, True).edges(), soln)
+        assert edges_equal(nx.transitive_closure(G, None).edges(), solution)
+
+        G = nx.DiGraph([(1, 2), (2, 3), (3, 1)])
+        solution = sorted([(1, 2), (2, 1), (2, 3), (3, 2), (1, 3), (3, 1)])
+        soln = sorted(solution + [(n, n) for n in G])
+        assert edges_equal(sorted(nx.transitive_closure(G).edges()), soln)
+        assert edges_equal(sorted(nx.transitive_closure(G, False).edges()), soln)
+        assert edges_equal(sorted(nx.transitive_closure(G, None).edges()), solution)
+        assert edges_equal(sorted(nx.transitive_closure(G, True).edges()), soln)
+
+        G = nx.Graph([(1, 2), (2, 3), (3, 4)])
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        soln = sorted(solution + [(n, n) for n in G])
+        assert edges_equal(nx.transitive_closure(G).edges(), solution)
+        assert edges_equal(nx.transitive_closure(G, False).edges(), solution)
+        assert edges_equal(nx.transitive_closure(G, True).edges(), soln)
+        assert edges_equal(nx.transitive_closure(G, None).edges(), solution)
+
+        G = nx.MultiGraph([(1, 2), (2, 3), (3, 4)])
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        soln = sorted(solution + [(n, n) for n in G])
+        assert edges_equal(nx.transitive_closure(G).edges(), solution)
+        assert edges_equal(nx.transitive_closure(G, False).edges(), solution)
+        assert edges_equal(nx.transitive_closure(G, True).edges(), soln)
+        assert edges_equal(nx.transitive_closure(G, None).edges(), solution)
+
+        G = nx.MultiDiGraph([(1, 2), (2, 3), (3, 4)])
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        soln = sorted(solution + [(n, n) for n in G])
+        assert edges_equal(nx.transitive_closure(G).edges(), solution)
+        assert edges_equal(nx.transitive_closure(G, False).edges(), solution)
+        assert edges_equal(nx.transitive_closure(G, True).edges(), soln)
+        assert edges_equal(nx.transitive_closure(G, None).edges(), solution)
+
+    def test_transitive_closure_dag(self):
+        G = nx.DiGraph([(1, 2), (2, 3), (3, 4)])
+        transitive_closure = nx.algorithms.dag.transitive_closure_dag
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        assert edges_equal(transitive_closure(G).edges(), solution)
+        G = nx.DiGraph([(1, 2), (2, 3), (2, 4)])
+        solution = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4)]
+        assert edges_equal(transitive_closure(G).edges(), solution)
+        G = nx.Graph([(1, 2), (2, 3), (3, 4)])
+        pytest.raises(nx.NetworkXNotImplemented, transitive_closure, G)
+
+        # test if edge data is copied
+        G = nx.DiGraph([(1, 2, {"a": 3}), (2, 3, {"b": 0}), (3, 4)])
+        H = transitive_closure(G)
+        for u, v in G.edges():
+            assert G.get_edge_data(u, v) == H.get_edge_data(u, v)
+
+        k = 10
+        G = nx.DiGraph((i, i + 1, {"foo": "bar", "weight": i}) for i in range(k))
+        H = transitive_closure(G)
+        for u, v in G.edges():
+            assert G.get_edge_data(u, v) == H.get_edge_data(u, v)
+
+    def test_transitive_reduction(self):
+        G = nx.DiGraph([(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)])
+        transitive_reduction = nx.algorithms.dag.transitive_reduction
+        solution = [(1, 2), (2, 3), (3, 4)]
+        assert edges_equal(transitive_reduction(G).edges(), solution)
+        G = nx.DiGraph([(1, 2), (1, 3), (1, 4), (2, 3), (2, 4)])
+        transitive_reduction = nx.algorithms.dag.transitive_reduction
+        solution = [(1, 2), (2, 3), (2, 4)]
+        assert edges_equal(transitive_reduction(G).edges(), solution)
+        G = nx.Graph([(1, 2), (2, 3), (3, 4)])
+        pytest.raises(nx.NetworkXNotImplemented, transitive_reduction, G)
+
+    def _check_antichains(self, solution, result):
+        sol = [frozenset(a) for a in solution]
+        res = [frozenset(a) for a in result]
+        assert set(sol) == set(res)
+
+    def test_antichains(self):
+        antichains = nx.algorithms.dag.antichains
+        G = nx.DiGraph([(1, 2), (2, 3), (3, 4)])
+        solution = [[], [4], [3], [2], [1]]
+        self._check_antichains(list(antichains(G)), solution)
+        G = nx.DiGraph([(1, 2), (2, 3), (2, 4), (3, 5), (5, 6), (5, 7)])
+        solution = [
+            [],
+            [4],
+            [7],
+            [7, 4],
+            [6],
+            [6, 4],
+            [6, 7],
+            [6, 7, 4],
+            [5],
+            [5, 4],
+            [3],
+            [3, 4],
+            [2],
+            [1],
+        ]
+        self._check_antichains(list(antichains(G)), solution)
+        G = nx.DiGraph([(1, 2), (1, 3), (3, 4), (3, 5), (5, 6)])
+        solution = [
+            [],
+            [6],
+            [5],
+            [4],
+            [4, 6],
+            [4, 5],
+            [3],
+            [2],
+            [2, 6],
+            [2, 5],
+            [2, 4],
+            [2, 4, 6],
+            [2, 4, 5],
+            [2, 3],
+            [1],
+        ]
+        self._check_antichains(list(antichains(G)), solution)
+        G = nx.DiGraph({0: [1, 2], 1: [4], 2: [3], 3: [4]})
+        solution = [[], [4], [3], [2], [1], [1, 3], [1, 2], [0]]
+        self._check_antichains(list(antichains(G)), solution)
+        G = nx.DiGraph()
+        self._check_antichains(list(antichains(G)), [[]])
+        G = nx.DiGraph()
+        G.add_nodes_from([0, 1, 2])
+        solution = [[], [0], [1], [1, 0], [2], [2, 0], [2, 1], [2, 1, 0]]
+        self._check_antichains(list(antichains(G)), solution)
+
+        def f(x):
+            return list(antichains(x))
+
+        G = nx.Graph([(1, 2), (2, 3), (3, 4)])
+        pytest.raises(nx.NetworkXNotImplemented, f, G)
+        G = nx.DiGraph([(1, 2), (2, 3), (3, 1)])
+        pytest.raises(nx.NetworkXUnfeasible, f, G)
+
+    def test_lexicographical_topological_sort(self):
+        G = nx.DiGraph([(1, 2), (2, 3), (1, 4), (1, 5), (2, 6)])
+        assert list(nx.lexicographical_topological_sort(G)) == [1, 2, 3, 4, 5, 6]
+        assert list(nx.lexicographical_topological_sort(G, key=lambda x: x)) == [
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+        ]
+        assert list(nx.lexicographical_topological_sort(G, key=lambda x: -x)) == [
+            1,
+            5,
+            4,
+            2,
+            6,
+            3,
+        ]
+
+    def test_lexicographical_topological_sort2(self):
+        """
+        Check the case of two or more nodes with same key value.
+        Want to avoid exception raised due to comparing nodes directly.
+        See Issue #3493
+        """
+
+        class Test_Node:
+            def __init__(self, n):
+                self.label = n
+                self.priority = 1
+
+            def __repr__(self):
+                return f"Node({self.label})"
+
+        def sorting_key(node):
+            return node.priority
+
+        test_nodes = [Test_Node(n) for n in range(4)]
+        G = nx.DiGraph()
+        edges = [(0, 1), (0, 2), (0, 3), (2, 3)]
+        G.add_edges_from((test_nodes[a], test_nodes[b]) for a, b in edges)
+
+        sorting = list(nx.lexicographical_topological_sort(G, key=sorting_key))
+        assert sorting == test_nodes
+
+
+def test_topological_generations():
+    G = nx.DiGraph(
+        {1: [2, 3], 2: [4, 5], 3: [7], 4: [], 5: [6, 7], 6: [], 7: []}
+    ).reverse()
+    # order within each generation is inconsequential
+    generations = [sorted(gen) for gen in nx.topological_generations(G)]
+    expected = [[4, 6, 7], [3, 5], [2], [1]]
+    assert generations == expected
+
+    MG = nx.MultiDiGraph(G.edges)
+    MG.add_edge(2, 1)
+    generations = [sorted(gen) for gen in nx.topological_generations(MG)]
+    assert generations == expected
+
+
+def test_topological_generations_empty():
+    G = nx.DiGraph()
+    assert list(nx.topological_generations(G)) == []
+
+
+def test_topological_generations_cycle():
+    G = nx.DiGraph([[2, 1], [3, 1], [1, 2]])
+    with pytest.raises(nx.NetworkXUnfeasible):
+        list(nx.topological_generations(G))
+
+
+def test_is_aperiodic_cycle():
+    G = nx.DiGraph()
+    nx.add_cycle(G, [1, 2, 3, 4])
+    assert not nx.is_aperiodic(G)
+
+
+def test_is_aperiodic_cycle2():
+    G = nx.DiGraph()
+    nx.add_cycle(G, [1, 2, 3, 4])
+    nx.add_cycle(G, [3, 4, 5, 6, 7])
+    assert nx.is_aperiodic(G)
+
+
+def test_is_aperiodic_cycle3():
+    G = nx.DiGraph()
+    nx.add_cycle(G, [1, 2, 3, 4])
+    nx.add_cycle(G, [3, 4, 5, 6])
+    assert not nx.is_aperiodic(G)
+
+
+def test_is_aperiodic_cycle4():
+    G = nx.DiGraph()
+    nx.add_cycle(G, [1, 2, 3, 4])
+    G.add_edge(1, 3)
+    assert nx.is_aperiodic(G)
+
+
+def test_is_aperiodic_selfloop():
+    G = nx.DiGraph()
+    nx.add_cycle(G, [1, 2, 3, 4])
+    G.add_edge(1, 1)
+    assert nx.is_aperiodic(G)
+
+
+def test_is_aperiodic_raise():
+    G = nx.Graph()
+    pytest.raises(nx.NetworkXError, nx.is_aperiodic, G)
+
+
+def test_is_aperiodic_bipartite():
+    # Bipartite graph
+    G = nx.DiGraph(nx.davis_southern_women_graph())
+    assert not nx.is_aperiodic(G)
+
+
+def test_is_aperiodic_rary_tree():
+    G = nx.full_rary_tree(3, 27, create_using=nx.DiGraph())
+    assert not nx.is_aperiodic(G)
+
+
+def test_is_aperiodic_disconnected():
+    # disconnected graph
+    G = nx.DiGraph()
+    nx.add_cycle(G, [1, 2, 3, 4])
+    nx.add_cycle(G, [5, 6, 7, 8])
+    assert not nx.is_aperiodic(G)
+    G.add_edge(1, 3)
+    G.add_edge(5, 7)
+    assert nx.is_aperiodic(G)
+
+
+def test_is_aperiodic_disconnected2():
+    G = nx.DiGraph()
+    nx.add_cycle(G, [0, 1, 2])
+    G.add_edge(3, 3)
+    assert not nx.is_aperiodic(G)
+
+
+class TestDagToBranching:
+    """Unit tests for the :func:`networkx.dag_to_branching` function."""
+
+    def test_single_root(self):
+        """Tests that a directed acyclic graph with a single degree
+        zero node produces an arborescence.
+
+        """
+        G = nx.DiGraph([(0, 1), (0, 2), (1, 3), (2, 3)])
+        B = nx.dag_to_branching(G)
+        expected = nx.DiGraph([(0, 1), (1, 3), (0, 2), (2, 4)])
+        assert nx.is_arborescence(B)
+        assert nx.is_isomorphic(B, expected)
+
+    def test_multiple_roots(self):
+        """Tests that a directed acyclic graph with multiple degree zero
+        nodes creates an arborescence with multiple (weakly) connected
+        components.
+
+        """
+        G = nx.DiGraph([(0, 1), (0, 2), (1, 3), (2, 3), (5, 2)])
+        B = nx.dag_to_branching(G)
+        expected = nx.DiGraph([(0, 1), (1, 3), (0, 2), (2, 4), (5, 6), (6, 7)])
+        assert nx.is_branching(B)
+        assert not nx.is_arborescence(B)
+        assert nx.is_isomorphic(B, expected)
+
+    # # Attributes are not copied by this function. If they were, this would
+    # # be a good test to uncomment.
+    # def test_copy_attributes(self):
+    #     """Tests that node attributes are copied in the branching."""
+    #     G = nx.DiGraph([(0, 1), (0, 2), (1, 3), (2, 3)])
+    #     for v in G:
+    #         G.node[v]['label'] = str(v)
+    #     B = nx.dag_to_branching(G)
+    #     # Determine the root node of the branching.
+    #     root = next(v for v, d in B.in_degree() if d == 0)
+    #     assert_equal(B.node[root]['label'], '0')
+    #     children = B[root]
+    #     # Get the left and right children, nodes 1 and 2, respectively.
+    #     left, right = sorted(children, key=lambda v: B.node[v]['label'])
+    #     assert_equal(B.node[left]['label'], '1')
+    #     assert_equal(B.node[right]['label'], '2')
+    #     # Get the left grandchild.
+    #     children = B[left]
+    #     assert_equal(len(children), 1)
+    #     left_grandchild = arbitrary_element(children)
+    #     assert_equal(B.node[left_grandchild]['label'], '3')
+    #     # Get the right grandchild.
+    #     children = B[right]
+    #     assert_equal(len(children), 1)
+    #     right_grandchild = arbitrary_element(children)
+    #     assert_equal(B.node[right_grandchild]['label'], '3')
+
+    def test_already_arborescence(self):
+        """Tests that a directed acyclic graph that is already an
+        arborescence produces an isomorphic arborescence as output.
+
+        """
+        A = nx.balanced_tree(2, 2, create_using=nx.DiGraph())
+        B = nx.dag_to_branching(A)
+        assert nx.is_isomorphic(A, B)
+
+    def test_already_branching(self):
+        """Tests that a directed acyclic graph that is already a
+        branching produces an isomorphic branching as output.
+
+        """
+        T1 = nx.balanced_tree(2, 2, create_using=nx.DiGraph())
+        T2 = nx.balanced_tree(2, 2, create_using=nx.DiGraph())
+        G = nx.disjoint_union(T1, T2)
+        B = nx.dag_to_branching(G)
+        assert nx.is_isomorphic(G, B)
+
+    def test_not_acyclic(self):
+        """Tests that a non-acyclic graph causes an exception."""
+        with pytest.raises(nx.HasACycle):
+            G = nx.DiGraph(pairwise("abc", cyclic=True))
+            nx.dag_to_branching(G)
+
+    def test_undirected(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            nx.dag_to_branching(nx.Graph())
+
+    def test_multigraph(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            nx.dag_to_branching(nx.MultiGraph())
+
+    def test_multidigraph(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            nx.dag_to_branching(nx.MultiDiGraph())
+
+
+def test_ancestors_descendants_undirected():
+    """Regression test to ensure anscestors and descendants work as expected on
+    undirected graphs."""
+    G = nx.path_graph(5)
+    nx.ancestors(G, 2) == nx.descendants(G, 2) == {0, 1, 3, 4}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_distance_measures.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_distance_measures.py
new file mode 100644
index 0000000..d7cec15
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_distance_measures.py
@@ -0,0 +1,261 @@
+from random import Random
+
+import pytest
+
+import networkx as nx
+from networkx import convert_node_labels_to_integers as cnlti
+from networkx.algorithms.distance_measures import _extrema_bounding
+
+
+@pytest.mark.parametrize(
+    "compute", ("diameter", "radius", "periphery", "center", "eccentricities")
+)
+def test_extrema_bounding_deprecated(compute):
+    G = nx.complete_graph(3)
+    with pytest.deprecated_call():
+        nx.extrema_bounding(G, compute=compute)
+
+
+def test__extrema_bounding_invalid_compute_kwarg():
+    G = nx.path_graph(3)
+    with pytest.raises(ValueError, match="compute must be one of"):
+        _extrema_bounding(G, compute="spam")
+
+
+class TestDistance:
+    def setup_method(self):
+        G = cnlti(nx.grid_2d_graph(4, 4), first_label=1, ordering="sorted")
+        self.G = G
+
+    def test_eccentricity(self):
+        assert nx.eccentricity(self.G, 1) == 6
+        e = nx.eccentricity(self.G)
+        assert e[1] == 6
+
+        sp = dict(nx.shortest_path_length(self.G))
+        e = nx.eccentricity(self.G, sp=sp)
+        assert e[1] == 6
+
+        e = nx.eccentricity(self.G, v=1)
+        assert e == 6
+
+        # This behavior changed in version 1.8 (ticket #739)
+        e = nx.eccentricity(self.G, v=[1, 1])
+        assert e[1] == 6
+        e = nx.eccentricity(self.G, v=[1, 2])
+        assert e[1] == 6
+
+        # test against graph with one node
+        G = nx.path_graph(1)
+        e = nx.eccentricity(G)
+        assert e[0] == 0
+        e = nx.eccentricity(G, v=0)
+        assert e == 0
+        pytest.raises(nx.NetworkXError, nx.eccentricity, G, 1)
+
+        # test against empty graph
+        G = nx.empty_graph()
+        e = nx.eccentricity(G)
+        assert e == {}
+
+    def test_diameter(self):
+        assert nx.diameter(self.G) == 6
+
+    def test_radius(self):
+        assert nx.radius(self.G) == 4
+
+    def test_periphery(self):
+        assert set(nx.periphery(self.G)) == {1, 4, 13, 16}
+
+    def test_center(self):
+        assert set(nx.center(self.G)) == {6, 7, 10, 11}
+
+    def test_bound_diameter(self):
+        assert nx.diameter(self.G, usebounds=True) == 6
+
+    def test_bound_radius(self):
+        assert nx.radius(self.G, usebounds=True) == 4
+
+    def test_bound_periphery(self):
+        result = {1, 4, 13, 16}
+        assert set(nx.periphery(self.G, usebounds=True)) == result
+
+    def test_bound_center(self):
+        result = {6, 7, 10, 11}
+        assert set(nx.center(self.G, usebounds=True)) == result
+
+    def test_radius_exception(self):
+        G = nx.Graph()
+        G.add_edge(1, 2)
+        G.add_edge(3, 4)
+        pytest.raises(nx.NetworkXError, nx.diameter, G)
+
+    def test_eccentricity_infinite(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.Graph([(1, 2), (3, 4)])
+            e = nx.eccentricity(G)
+
+    def test_eccentricity_undirected_not_connected(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.Graph([(1, 2), (3, 4)])
+            e = nx.eccentricity(G, sp=1)
+
+    def test_eccentricity_directed_weakly_connected(self):
+        with pytest.raises(nx.NetworkXError):
+            DG = nx.DiGraph([(1, 2), (1, 3)])
+            nx.eccentricity(DG)
+
+
+class TestResistanceDistance:
+    @classmethod
+    def setup_class(cls):
+        global np
+        global sp
+        np = pytest.importorskip("numpy")
+        sp = pytest.importorskip("scipy")
+
+    def setup_method(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=2)
+        G.add_edge(2, 3, weight=4)
+        G.add_edge(3, 4, weight=1)
+        G.add_edge(1, 4, weight=3)
+        self.G = G
+
+    def test_resistance_distance(self):
+        rd = nx.resistance_distance(self.G, 1, 3, "weight", True)
+        test_data = 1 / (1 / (2 + 4) + 1 / (1 + 3))
+        assert round(rd, 5) == round(test_data, 5)
+
+    def test_resistance_distance_noinv(self):
+        rd = nx.resistance_distance(self.G, 1, 3, "weight", False)
+        test_data = 1 / (1 / (1 / 2 + 1 / 4) + 1 / (1 / 1 + 1 / 3))
+        assert round(rd, 5) == round(test_data, 5)
+
+    def test_resistance_distance_no_weight(self):
+        rd = nx.resistance_distance(self.G, 1, 3)
+        assert round(rd, 5) == 1
+
+    def test_resistance_distance_neg_weight(self):
+        self.G[2][3]["weight"] = -4
+        rd = nx.resistance_distance(self.G, 1, 3, "weight", True)
+        test_data = 1 / (1 / (2 + -4) + 1 / (1 + 3))
+        assert round(rd, 5) == round(test_data, 5)
+
+    def test_multigraph(self):
+        G = nx.MultiGraph()
+        G.add_edge(1, 2, weight=2)
+        G.add_edge(2, 3, weight=4)
+        G.add_edge(3, 4, weight=1)
+        G.add_edge(1, 4, weight=3)
+        rd = nx.resistance_distance(G, 1, 3, "weight", True)
+        assert np.isclose(rd, 1 / (1 / (2 + 4) + 1 / (1 + 3)))
+
+    def test_resistance_distance_div0(self):
+        with pytest.raises(ZeroDivisionError):
+            self.G[1][2]["weight"] = 0
+            nx.resistance_distance(self.G, 1, 3, "weight")
+
+    def test_resistance_distance_not_connected(self):
+        with pytest.raises(nx.NetworkXError):
+            self.G.add_node(5)
+            nx.resistance_distance(self.G, 1, 5)
+
+    def test_resistance_distance_same_node(self):
+        with pytest.raises(nx.NetworkXError):
+            nx.resistance_distance(self.G, 1, 1)
+
+    def test_resistance_distance_nodeA_not_in_graph(self):
+        with pytest.raises(nx.NetworkXError):
+            nx.resistance_distance(self.G, 9, 1)
+
+    def test_resistance_distance_nodeB_not_in_graph(self):
+        with pytest.raises(nx.NetworkXError):
+            nx.resistance_distance(self.G, 1, 9)
+
+
+class TestBarycenter:
+    """Test :func:`networkx.algorithms.distance_measures.barycenter`."""
+
+    def barycenter_as_subgraph(self, g, **kwargs):
+        """Return the subgraph induced on the barycenter of g"""
+        b = nx.barycenter(g, **kwargs)
+        assert isinstance(b, list)
+        assert set(b) <= set(g)
+        return g.subgraph(b)
+
+    def test_must_be_connected(self):
+        pytest.raises(nx.NetworkXNoPath, nx.barycenter, nx.empty_graph(5))
+
+    def test_sp_kwarg(self):
+        # Complete graph K_5. Normally it works...
+        K_5 = nx.complete_graph(5)
+        sp = dict(nx.shortest_path_length(K_5))
+        assert nx.barycenter(K_5, sp=sp) == list(K_5)
+
+        # ...but not with the weight argument
+        for u, v, data in K_5.edges.data():
+            data["weight"] = 1
+        pytest.raises(ValueError, nx.barycenter, K_5, sp=sp, weight="weight")
+
+        # ...and a corrupted sp can make it seem like K_5 is disconnected
+        del sp[0][1]
+        pytest.raises(nx.NetworkXNoPath, nx.barycenter, K_5, sp=sp)
+
+    def test_trees(self):
+        """The barycenter of a tree is a single vertex or an edge.
+
+        See [West01]_, p. 78.
+        """
+        prng = Random(0xDEADBEEF)
+        for i in range(50):
+            RT = nx.random_tree(prng.randint(1, 75), prng)
+            b = self.barycenter_as_subgraph(RT)
+            if len(b) == 2:
+                assert b.size() == 1
+            else:
+                assert len(b) == 1
+                assert b.size() == 0
+
+    def test_this_one_specific_tree(self):
+        """Test the tree pictured at the bottom of [West01]_, p. 78."""
+        g = nx.Graph(
+            {
+                "a": ["b"],
+                "b": ["a", "x"],
+                "x": ["b", "y"],
+                "y": ["x", "z"],
+                "z": ["y", 0, 1, 2, 3, 4],
+                0: ["z"],
+                1: ["z"],
+                2: ["z"],
+                3: ["z"],
+                4: ["z"],
+            }
+        )
+        b = self.barycenter_as_subgraph(g, attr="barycentricity")
+        assert list(b) == ["z"]
+        assert not b.edges
+        expected_barycentricity = {
+            0: 23,
+            1: 23,
+            2: 23,
+            3: 23,
+            4: 23,
+            "a": 35,
+            "b": 27,
+            "x": 21,
+            "y": 17,
+            "z": 15,
+        }
+        for node, barycentricity in expected_barycentricity.items():
+            assert g.nodes[node]["barycentricity"] == barycentricity
+
+        # Doubling weights should do nothing but double the barycentricities
+        for edge in g.edges:
+            g.edges[edge]["weight"] = 2
+        b = self.barycenter_as_subgraph(g, weight="weight", attr="barycentricity2")
+        assert list(b) == ["z"]
+        assert not b.edges
+        for node, barycentricity in expected_barycentricity.items():
+            assert g.nodes[node]["barycentricity2"] == barycentricity * 2
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_distance_regular.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_distance_regular.py
new file mode 100644
index 0000000..d336b18
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_distance_regular.py
@@ -0,0 +1,66 @@
+import networkx as nx
+from networkx import is_strongly_regular
+
+
+class TestDistanceRegular:
+    def test_is_distance_regular(self):
+        assert nx.is_distance_regular(nx.icosahedral_graph())
+        assert nx.is_distance_regular(nx.petersen_graph())
+        assert nx.is_distance_regular(nx.cubical_graph())
+        assert nx.is_distance_regular(nx.complete_bipartite_graph(3, 3))
+        assert nx.is_distance_regular(nx.tetrahedral_graph())
+        assert nx.is_distance_regular(nx.dodecahedral_graph())
+        assert nx.is_distance_regular(nx.pappus_graph())
+        assert nx.is_distance_regular(nx.heawood_graph())
+        assert nx.is_distance_regular(nx.cycle_graph(3))
+        # no distance regular
+        assert not nx.is_distance_regular(nx.path_graph(4))
+
+    def test_not_connected(self):
+        G = nx.cycle_graph(4)
+        nx.add_cycle(G, [5, 6, 7])
+        assert not nx.is_distance_regular(G)
+
+    def test_global_parameters(self):
+        b, c = nx.intersection_array(nx.cycle_graph(5))
+        g = nx.global_parameters(b, c)
+        assert list(g) == [(0, 0, 2), (1, 0, 1), (1, 1, 0)]
+        b, c = nx.intersection_array(nx.cycle_graph(3))
+        g = nx.global_parameters(b, c)
+        assert list(g) == [(0, 0, 2), (1, 1, 0)]
+
+    def test_intersection_array(self):
+        b, c = nx.intersection_array(nx.cycle_graph(5))
+        assert b == [2, 1]
+        assert c == [1, 1]
+        b, c = nx.intersection_array(nx.dodecahedral_graph())
+        assert b == [3, 2, 1, 1, 1]
+        assert c == [1, 1, 1, 2, 3]
+        b, c = nx.intersection_array(nx.icosahedral_graph())
+        assert b == [5, 2, 1]
+        assert c == [1, 2, 5]
+
+
+class TestStronglyRegular:
+    """Unit tests for the :func:`~networkx.is_strongly_regular`
+    function.
+
+    """
+
+    def test_cycle_graph(self):
+        """Tests that the cycle graph on five vertices is strongly
+        regular.
+
+        """
+        G = nx.cycle_graph(5)
+        assert is_strongly_regular(G)
+
+    def test_petersen_graph(self):
+        """Tests that the Petersen graph is strongly regular."""
+        G = nx.petersen_graph()
+        assert is_strongly_regular(G)
+
+    def test_path_graph(self):
+        """Tests that the path graph is not strongly regular."""
+        G = nx.path_graph(4)
+        assert not is_strongly_regular(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_dominance.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_dominance.py
new file mode 100644
index 0000000..a8d0882
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_dominance.py
@@ -0,0 +1,285 @@
+import pytest
+
+import networkx as nx
+
+
+class TestImmediateDominators:
+    def test_exceptions(self):
+        G = nx.Graph()
+        G.add_node(0)
+        pytest.raises(nx.NetworkXNotImplemented, nx.immediate_dominators, G, 0)
+        G = nx.MultiGraph(G)
+        pytest.raises(nx.NetworkXNotImplemented, nx.immediate_dominators, G, 0)
+        G = nx.DiGraph([[0, 0]])
+        pytest.raises(nx.NetworkXError, nx.immediate_dominators, G, 1)
+
+    def test_singleton(self):
+        G = nx.DiGraph()
+        G.add_node(0)
+        assert nx.immediate_dominators(G, 0) == {0: 0}
+        G.add_edge(0, 0)
+        assert nx.immediate_dominators(G, 0) == {0: 0}
+
+    def test_path(self):
+        n = 5
+        G = nx.path_graph(n, create_using=nx.DiGraph())
+        assert nx.immediate_dominators(G, 0) == {i: max(i - 1, 0) for i in range(n)}
+
+    def test_cycle(self):
+        n = 5
+        G = nx.cycle_graph(n, create_using=nx.DiGraph())
+        assert nx.immediate_dominators(G, 0) == {i: max(i - 1, 0) for i in range(n)}
+
+    def test_unreachable(self):
+        n = 5
+        assert n > 1
+        G = nx.path_graph(n, create_using=nx.DiGraph())
+        assert nx.immediate_dominators(G, n // 2) == {
+            i: max(i - 1, n // 2) for i in range(n // 2, n)
+        }
+
+    def test_irreducible1(self):
+        # Graph taken from Figure 2 of
+        # K. D. Cooper, T. J. Harvey, and K. Kennedy.
+        # A simple, fast dominance algorithm.
+        # Software Practice & Experience, 4:110, 2001.
+        edges = [(1, 2), (2, 1), (3, 2), (4, 1), (5, 3), (5, 4)]
+        G = nx.DiGraph(edges)
+        assert nx.immediate_dominators(G, 5) == {i: 5 for i in range(1, 6)}
+
+    def test_irreducible2(self):
+        # Graph taken from Figure 4 of
+        # K. D. Cooper, T. J. Harvey, and K. Kennedy.
+        # A simple, fast dominance algorithm.
+        # Software Practice & Experience, 4:110, 2001.
+        edges = [(1, 2), (2, 1), (2, 3), (3, 2), (4, 2), (4, 3), (5, 1), (6, 4), (6, 5)]
+        G = nx.DiGraph(edges)
+        result = nx.immediate_dominators(G, 6)
+        assert result == {i: 6 for i in range(1, 7)}
+
+    def test_domrel_png(self):
+        # Graph taken from https://commons.wikipedia.org/wiki/File:Domrel.png
+        edges = [(1, 2), (2, 3), (2, 4), (2, 6), (3, 5), (4, 5), (5, 2)]
+        G = nx.DiGraph(edges)
+        result = nx.immediate_dominators(G, 1)
+        assert result == {1: 1, 2: 1, 3: 2, 4: 2, 5: 2, 6: 2}
+        # Test postdominance.
+        result = nx.immediate_dominators(G.reverse(copy=False), 6)
+        assert result == {1: 2, 2: 6, 3: 5, 4: 5, 5: 2, 6: 6}
+
+    def test_boost_example(self):
+        # Graph taken from Figure 1 of
+        # http://www.boost.org/doc/libs/1_56_0/libs/graph/doc/lengauer_tarjan_dominator.htm
+        edges = [(0, 1), (1, 2), (1, 3), (2, 7), (3, 4), (4, 5), (4, 6), (5, 7), (6, 4)]
+        G = nx.DiGraph(edges)
+        result = nx.immediate_dominators(G, 0)
+        assert result == {0: 0, 1: 0, 2: 1, 3: 1, 4: 3, 5: 4, 6: 4, 7: 1}
+        # Test postdominance.
+        result = nx.immediate_dominators(G.reverse(copy=False), 7)
+        assert result == {0: 1, 1: 7, 2: 7, 3: 4, 4: 5, 5: 7, 6: 4, 7: 7}
+
+
+class TestDominanceFrontiers:
+    def test_exceptions(self):
+        G = nx.Graph()
+        G.add_node(0)
+        pytest.raises(nx.NetworkXNotImplemented, nx.dominance_frontiers, G, 0)
+        G = nx.MultiGraph(G)
+        pytest.raises(nx.NetworkXNotImplemented, nx.dominance_frontiers, G, 0)
+        G = nx.DiGraph([[0, 0]])
+        pytest.raises(nx.NetworkXError, nx.dominance_frontiers, G, 1)
+
+    def test_singleton(self):
+        G = nx.DiGraph()
+        G.add_node(0)
+        assert nx.dominance_frontiers(G, 0) == {0: set()}
+        G.add_edge(0, 0)
+        assert nx.dominance_frontiers(G, 0) == {0: set()}
+
+    def test_path(self):
+        n = 5
+        G = nx.path_graph(n, create_using=nx.DiGraph())
+        assert nx.dominance_frontiers(G, 0) == {i: set() for i in range(n)}
+
+    def test_cycle(self):
+        n = 5
+        G = nx.cycle_graph(n, create_using=nx.DiGraph())
+        assert nx.dominance_frontiers(G, 0) == {i: set() for i in range(n)}
+
+    def test_unreachable(self):
+        n = 5
+        assert n > 1
+        G = nx.path_graph(n, create_using=nx.DiGraph())
+        assert nx.dominance_frontiers(G, n // 2) == {i: set() for i in range(n // 2, n)}
+
+    def test_irreducible1(self):
+        # Graph taken from Figure 2 of
+        # K. D. Cooper, T. J. Harvey, and K. Kennedy.
+        # A simple, fast dominance algorithm.
+        # Software Practice & Experience, 4:110, 2001.
+        edges = [(1, 2), (2, 1), (3, 2), (4, 1), (5, 3), (5, 4)]
+        G = nx.DiGraph(edges)
+        assert {u: df for u, df in nx.dominance_frontiers(G, 5).items()} == {
+            1: {2},
+            2: {1},
+            3: {2},
+            4: {1},
+            5: set(),
+        }
+
+    def test_irreducible2(self):
+        # Graph taken from Figure 4 of
+        # K. D. Cooper, T. J. Harvey, and K. Kennedy.
+        # A simple, fast dominance algorithm.
+        # Software Practice & Experience, 4:110, 2001.
+        edges = [(1, 2), (2, 1), (2, 3), (3, 2), (4, 2), (4, 3), (5, 1), (6, 4), (6, 5)]
+        G = nx.DiGraph(edges)
+        assert nx.dominance_frontiers(G, 6) == {
+            1: {2},
+            2: {1, 3},
+            3: {2},
+            4: {2, 3},
+            5: {1},
+            6: set(),
+        }
+
+    def test_domrel_png(self):
+        # Graph taken from https://commons.wikipedia.org/wiki/File:Domrel.png
+        edges = [(1, 2), (2, 3), (2, 4), (2, 6), (3, 5), (4, 5), (5, 2)]
+        G = nx.DiGraph(edges)
+        assert nx.dominance_frontiers(G, 1) == {
+            1: set(),
+            2: {2},
+            3: {5},
+            4: {5},
+            5: {2},
+            6: set(),
+        }
+        # Test postdominance.
+        result = nx.dominance_frontiers(G.reverse(copy=False), 6)
+        assert result == {1: set(), 2: {2}, 3: {2}, 4: {2}, 5: {2}, 6: set()}
+
+    def test_boost_example(self):
+        # Graph taken from Figure 1 of
+        # http://www.boost.org/doc/libs/1_56_0/libs/graph/doc/lengauer_tarjan_dominator.htm
+        edges = [(0, 1), (1, 2), (1, 3), (2, 7), (3, 4), (4, 5), (4, 6), (5, 7), (6, 4)]
+        G = nx.DiGraph(edges)
+        assert nx.dominance_frontiers(G, 0) == {
+            0: set(),
+            1: set(),
+            2: {7},
+            3: {7},
+            4: {4, 7},
+            5: {7},
+            6: {4},
+            7: set(),
+        }
+        # Test postdominance.
+        result = nx.dominance_frontiers(G.reverse(copy=False), 7)
+        expected = {
+            0: set(),
+            1: set(),
+            2: {1},
+            3: {1},
+            4: {1, 4},
+            5: {1},
+            6: {4},
+            7: set(),
+        }
+        assert result == expected
+
+    def test_discard_issue(self):
+        # https://github.com/networkx/networkx/issues/2071
+        g = nx.DiGraph()
+        g.add_edges_from(
+            [
+                ("b0", "b1"),
+                ("b1", "b2"),
+                ("b2", "b3"),
+                ("b3", "b1"),
+                ("b1", "b5"),
+                ("b5", "b6"),
+                ("b5", "b8"),
+                ("b6", "b7"),
+                ("b8", "b7"),
+                ("b7", "b3"),
+                ("b3", "b4"),
+            ]
+        )
+        df = nx.dominance_frontiers(g, "b0")
+        assert df == {
+            "b4": set(),
+            "b5": {"b3"},
+            "b6": {"b7"},
+            "b7": {"b3"},
+            "b0": set(),
+            "b1": {"b1"},
+            "b2": {"b3"},
+            "b3": {"b1"},
+            "b8": {"b7"},
+        }
+
+    def test_loop(self):
+        g = nx.DiGraph()
+        g.add_edges_from([("a", "b"), ("b", "c"), ("b", "a")])
+        df = nx.dominance_frontiers(g, "a")
+        assert df == {"a": set(), "b": set(), "c": set()}
+
+    def test_missing_immediate_doms(self):
+        # see https://github.com/networkx/networkx/issues/2070
+        g = nx.DiGraph()
+        edges = [
+            ("entry_1", "b1"),
+            ("b1", "b2"),
+            ("b2", "b3"),
+            ("b3", "exit"),
+            ("entry_2", "b3"),
+        ]
+
+        # entry_1
+        #   |
+        #   b1
+        #   |
+        #   b2  entry_2
+        #    |  /
+        #    b3
+        #    |
+        #   exit
+
+        g.add_edges_from(edges)
+        # formerly raised KeyError on entry_2 when parsing b3
+        # because entry_2 does not have immediate doms (no path)
+        nx.dominance_frontiers(g, "entry_1")
+
+    def test_loops_larger(self):
+        # from
+        # http://ecee.colorado.edu/~waite/Darmstadt/motion.html
+        g = nx.DiGraph()
+        edges = [
+            ("entry", "exit"),
+            ("entry", "1"),
+            ("1", "2"),
+            ("2", "3"),
+            ("3", "4"),
+            ("4", "5"),
+            ("5", "6"),
+            ("6", "exit"),
+            ("6", "2"),
+            ("5", "3"),
+            ("4", "4"),
+        ]
+
+        g.add_edges_from(edges)
+        df = nx.dominance_frontiers(g, "entry")
+        answer = {
+            "entry": set(),
+            "1": {"exit"},
+            "2": {"exit", "2"},
+            "3": {"exit", "3", "2"},
+            "4": {"exit", "4", "3", "2"},
+            "5": {"exit", "3", "2"},
+            "6": {"exit", "2"},
+            "exit": set(),
+        }
+        for n in df:
+            assert set(df[n]) == set(answer[n])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_dominating.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_dominating.py
new file mode 100644
index 0000000..b945c73
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_dominating.py
@@ -0,0 +1,46 @@
+import pytest
+
+import networkx as nx
+
+
+def test_dominating_set():
+    G = nx.gnp_random_graph(100, 0.1)
+    D = nx.dominating_set(G)
+    assert nx.is_dominating_set(G, D)
+    D = nx.dominating_set(G, start_with=0)
+    assert nx.is_dominating_set(G, D)
+
+
+def test_complete():
+    """In complete graphs each node is a dominating set.
+    Thus the dominating set has to be of cardinality 1.
+    """
+    K4 = nx.complete_graph(4)
+    assert len(nx.dominating_set(K4)) == 1
+    K5 = nx.complete_graph(5)
+    assert len(nx.dominating_set(K5)) == 1
+
+
+def test_raise_dominating_set():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.path_graph(4)
+        D = nx.dominating_set(G, start_with=10)
+
+
+def test_is_dominating_set():
+    G = nx.path_graph(4)
+    d = {1, 3}
+    assert nx.is_dominating_set(G, d)
+    d = {0, 2}
+    assert nx.is_dominating_set(G, d)
+    d = {1}
+    assert not nx.is_dominating_set(G, d)
+
+
+def test_wikipedia_is_dominating_set():
+    """Example from https://en.wikipedia.org/wiki/Dominating_set"""
+    G = nx.cycle_graph(4)
+    G.add_edges_from([(0, 4), (1, 4), (2, 5)])
+    assert nx.is_dominating_set(G, {4, 3, 5})
+    assert nx.is_dominating_set(G, {0, 2})
+    assert nx.is_dominating_set(G, {1, 2})
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_efficiency.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_efficiency.py
new file mode 100644
index 0000000..9a2e7d0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_efficiency.py
@@ -0,0 +1,58 @@
+"""Unit tests for the :mod:`networkx.algorithms.efficiency` module."""
+
+import networkx as nx
+
+
+class TestEfficiency:
+    def setup_method(self):
+        # G1 is a disconnected graph
+        self.G1 = nx.Graph()
+        self.G1.add_nodes_from([1, 2, 3])
+        # G2 is a cycle graph
+        self.G2 = nx.cycle_graph(4)
+        # G3 is the triangle graph with one additional edge
+        self.G3 = nx.lollipop_graph(3, 1)
+
+    def test_efficiency_disconnected_nodes(self):
+        """
+        When nodes are disconnected, efficiency is 0
+        """
+        assert nx.efficiency(self.G1, 1, 2) == 0
+
+    def test_local_efficiency_disconnected_graph(self):
+        """
+        In a disconnected graph the efficiency is 0
+        """
+        assert nx.local_efficiency(self.G1) == 0
+
+    def test_efficiency(self):
+        assert nx.efficiency(self.G2, 0, 1) == 1
+        assert nx.efficiency(self.G2, 0, 2) == 1 / 2
+
+    def test_global_efficiency(self):
+        assert nx.global_efficiency(self.G2) == 5 / 6
+
+    def test_global_efficiency_complete_graph(self):
+        """
+        Tests that the average global efficiency of the complete graph is one.
+        """
+        for n in range(2, 10):
+            G = nx.complete_graph(n)
+            assert nx.global_efficiency(G) == 1
+
+    def test_local_efficiency_complete_graph(self):
+        """
+        Test that the local efficiency for a complete graph with at least 3
+        nodes should be one. For a graph with only 2 nodes, the induced
+        subgraph has no edges.
+        """
+        for n in range(3, 10):
+            G = nx.complete_graph(n)
+            assert nx.local_efficiency(G) == 1
+
+    def test_using_ego_graph(self):
+        """
+        Test that the ego graph is used when computing local efficiency.
+        For more information, see GitHub issue #2710.
+        """
+        assert nx.local_efficiency(self.G3) == 7 / 12
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_euler.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_euler.py
new file mode 100644
index 0000000..7dfe2d1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_euler.py
@@ -0,0 +1,275 @@
+import collections
+
+import pytest
+
+import networkx as nx
+
+
+class TestIsEulerian:
+    def test_is_eulerian(self):
+        assert nx.is_eulerian(nx.complete_graph(5))
+        assert nx.is_eulerian(nx.complete_graph(7))
+        assert nx.is_eulerian(nx.hypercube_graph(4))
+        assert nx.is_eulerian(nx.hypercube_graph(6))
+
+        assert not nx.is_eulerian(nx.complete_graph(4))
+        assert not nx.is_eulerian(nx.complete_graph(6))
+        assert not nx.is_eulerian(nx.hypercube_graph(3))
+        assert not nx.is_eulerian(nx.hypercube_graph(5))
+
+        assert not nx.is_eulerian(nx.petersen_graph())
+        assert not nx.is_eulerian(nx.path_graph(4))
+
+    def test_is_eulerian2(self):
+        # not connected
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3])
+        assert not nx.is_eulerian(G)
+        # not strongly connected
+        G = nx.DiGraph()
+        G.add_nodes_from([1, 2, 3])
+        assert not nx.is_eulerian(G)
+        G = nx.MultiDiGraph()
+        G.add_edge(1, 2)
+        G.add_edge(2, 3)
+        G.add_edge(2, 3)
+        G.add_edge(3, 1)
+        assert not nx.is_eulerian(G)
+
+
+class TestEulerianCircuit:
+    def test_eulerian_circuit_cycle(self):
+        G = nx.cycle_graph(4)
+
+        edges = list(nx.eulerian_circuit(G, source=0))
+        nodes = [u for u, v in edges]
+        assert nodes == [0, 3, 2, 1]
+        assert edges == [(0, 3), (3, 2), (2, 1), (1, 0)]
+
+        edges = list(nx.eulerian_circuit(G, source=1))
+        nodes = [u for u, v in edges]
+        assert nodes == [1, 2, 3, 0]
+        assert edges == [(1, 2), (2, 3), (3, 0), (0, 1)]
+
+        G = nx.complete_graph(3)
+
+        edges = list(nx.eulerian_circuit(G, source=0))
+        nodes = [u for u, v in edges]
+        assert nodes == [0, 2, 1]
+        assert edges == [(0, 2), (2, 1), (1, 0)]
+
+        edges = list(nx.eulerian_circuit(G, source=1))
+        nodes = [u for u, v in edges]
+        assert nodes == [1, 2, 0]
+        assert edges == [(1, 2), (2, 0), (0, 1)]
+
+    def test_eulerian_circuit_digraph(self):
+        G = nx.DiGraph()
+        nx.add_cycle(G, [0, 1, 2, 3])
+
+        edges = list(nx.eulerian_circuit(G, source=0))
+        nodes = [u for u, v in edges]
+        assert nodes == [0, 1, 2, 3]
+        assert edges == [(0, 1), (1, 2), (2, 3), (3, 0)]
+
+        edges = list(nx.eulerian_circuit(G, source=1))
+        nodes = [u for u, v in edges]
+        assert nodes == [1, 2, 3, 0]
+        assert edges == [(1, 2), (2, 3), (3, 0), (0, 1)]
+
+    def test_multigraph(self):
+        G = nx.MultiGraph()
+        nx.add_cycle(G, [0, 1, 2, 3])
+        G.add_edge(1, 2)
+        G.add_edge(1, 2)
+        edges = list(nx.eulerian_circuit(G, source=0))
+        nodes = [u for u, v in edges]
+        assert nodes == [0, 3, 2, 1, 2, 1]
+        assert edges == [(0, 3), (3, 2), (2, 1), (1, 2), (2, 1), (1, 0)]
+
+    def test_multigraph_with_keys(self):
+        G = nx.MultiGraph()
+        nx.add_cycle(G, [0, 1, 2, 3])
+        G.add_edge(1, 2)
+        G.add_edge(1, 2)
+        edges = list(nx.eulerian_circuit(G, source=0, keys=True))
+        nodes = [u for u, v, k in edges]
+        assert nodes == [0, 3, 2, 1, 2, 1]
+        assert edges[:2] == [(0, 3, 0), (3, 2, 0)]
+        assert collections.Counter(edges[2:5]) == collections.Counter(
+            [(2, 1, 0), (1, 2, 1), (2, 1, 2)]
+        )
+        assert edges[5:] == [(1, 0, 0)]
+
+    def test_not_eulerian(self):
+        with pytest.raises(nx.NetworkXError):
+            f = list(nx.eulerian_circuit(nx.complete_graph(4)))
+
+
+class TestIsSemiEulerian:
+    def test_is_semieulerian(self):
+        # Test graphs with Eulerian paths but no cycles return True.
+        assert nx.is_semieulerian(nx.path_graph(4))
+        G = nx.path_graph(6, create_using=nx.DiGraph)
+        assert nx.is_semieulerian(G)
+
+        # Test graphs with Eulerian cycles return False.
+        assert not nx.is_semieulerian(nx.complete_graph(5))
+        assert not nx.is_semieulerian(nx.complete_graph(7))
+        assert not nx.is_semieulerian(nx.hypercube_graph(4))
+        assert not nx.is_semieulerian(nx.hypercube_graph(6))
+
+
+class TestHasEulerianPath:
+    def test_has_eulerian_path_cyclic(self):
+        # Test graphs with Eulerian cycles return True.
+        assert nx.has_eulerian_path(nx.complete_graph(5))
+        assert nx.has_eulerian_path(nx.complete_graph(7))
+        assert nx.has_eulerian_path(nx.hypercube_graph(4))
+        assert nx.has_eulerian_path(nx.hypercube_graph(6))
+
+    def test_has_eulerian_path_non_cyclic(self):
+        # Test graphs with Eulerian paths but no cycles return True.
+        assert nx.has_eulerian_path(nx.path_graph(4))
+        G = nx.path_graph(6, create_using=nx.DiGraph)
+        assert nx.has_eulerian_path(G)
+
+    def test_has_eulerian_path_directed_graph(self):
+        # Test directed graphs and returns False
+        G = nx.DiGraph()
+        G.add_edges_from([(0, 1), (1, 2), (0, 2)])
+        assert not nx.has_eulerian_path(G)
+
+        # Test directed graphs without isolated node returns True
+        G = nx.DiGraph()
+        G.add_edges_from([(0, 1), (1, 2), (2, 0)])
+        assert nx.has_eulerian_path(G)
+
+        # Test directed graphs with isolated node returns False
+        G.add_node(3)
+        assert not nx.has_eulerian_path(G)
+
+    @pytest.mark.parametrize("G", (nx.Graph(), nx.DiGraph()))
+    def test_has_eulerian_path_not_weakly_connected(self, G):
+        G.add_edges_from([(0, 1), (2, 3), (3, 2)])
+        assert not nx.has_eulerian_path(G)
+
+    @pytest.mark.parametrize("G", (nx.Graph(), nx.DiGraph()))
+    def test_has_eulerian_path_unbalancedins_more_than_one(self, G):
+        G.add_edges_from([(0, 1), (2, 3)])
+        assert not nx.has_eulerian_path(G)
+
+
+class TestFindPathStart:
+    def testfind_path_start(self):
+        find_path_start = nx.algorithms.euler._find_path_start
+        # Test digraphs return correct starting node.
+        G = nx.path_graph(6, create_using=nx.DiGraph)
+        assert find_path_start(G) == 0
+        edges = [(0, 1), (1, 2), (2, 0), (4, 0)]
+        assert find_path_start(nx.DiGraph(edges)) == 4
+
+        # Test graph with no Eulerian path return None.
+        edges = [(0, 1), (1, 2), (2, 3), (2, 4)]
+        assert find_path_start(nx.DiGraph(edges)) is None
+
+
+class TestEulerianPath:
+    def test_eulerian_path(self):
+        x = [(4, 0), (0, 1), (1, 2), (2, 0)]
+        for e1, e2 in zip(x, nx.eulerian_path(nx.DiGraph(x))):
+            assert e1 == e2
+
+    def test_eulerian_path_straight_link(self):
+        G = nx.DiGraph()
+        result = [(1, 2), (2, 3), (3, 4), (4, 5)]
+        G.add_edges_from(result)
+        assert result == list(nx.eulerian_path(G))
+        assert result == list(nx.eulerian_path(G, source=1))
+        with pytest.raises(nx.NetworkXError):
+            list(nx.eulerian_path(G, source=3))
+        with pytest.raises(nx.NetworkXError):
+            list(nx.eulerian_path(G, source=4))
+        with pytest.raises(nx.NetworkXError):
+            list(nx.eulerian_path(G, source=5))
+
+    def test_eulerian_path_multigraph(self):
+        G = nx.MultiDiGraph()
+        result = [(2, 1), (1, 2), (2, 1), (1, 2), (2, 3), (3, 4), (4, 3)]
+        G.add_edges_from(result)
+        assert result == list(nx.eulerian_path(G))
+        assert result == list(nx.eulerian_path(G, source=2))
+        with pytest.raises(nx.NetworkXError):
+            list(nx.eulerian_path(G, source=3))
+        with pytest.raises(nx.NetworkXError):
+            list(nx.eulerian_path(G, source=4))
+
+    def test_eulerian_path_eulerian_circuit(self):
+        G = nx.DiGraph()
+        result = [(1, 2), (2, 3), (3, 4), (4, 1)]
+        result2 = [(2, 3), (3, 4), (4, 1), (1, 2)]
+        result3 = [(3, 4), (4, 1), (1, 2), (2, 3)]
+        G.add_edges_from(result)
+        assert result == list(nx.eulerian_path(G))
+        assert result == list(nx.eulerian_path(G, source=1))
+        assert result2 == list(nx.eulerian_path(G, source=2))
+        assert result3 == list(nx.eulerian_path(G, source=3))
+
+    def test_eulerian_path_undirected(self):
+        G = nx.Graph()
+        result = [(1, 2), (2, 3), (3, 4), (4, 5)]
+        result2 = [(5, 4), (4, 3), (3, 2), (2, 1)]
+        G.add_edges_from(result)
+        assert list(nx.eulerian_path(G)) in (result, result2)
+        assert result == list(nx.eulerian_path(G, source=1))
+        assert result2 == list(nx.eulerian_path(G, source=5))
+        with pytest.raises(nx.NetworkXError):
+            list(nx.eulerian_path(G, source=3))
+        with pytest.raises(nx.NetworkXError):
+            list(nx.eulerian_path(G, source=2))
+
+    def test_eulerian_path_multigraph_undirected(self):
+        G = nx.MultiGraph()
+        result = [(2, 1), (1, 2), (2, 1), (1, 2), (2, 3), (3, 4)]
+        G.add_edges_from(result)
+        assert result == list(nx.eulerian_path(G))
+        assert result == list(nx.eulerian_path(G, source=2))
+        with pytest.raises(nx.NetworkXError):
+            list(nx.eulerian_path(G, source=3))
+        with pytest.raises(nx.NetworkXError):
+            list(nx.eulerian_path(G, source=1))
+
+
+class TestEulerize:
+    def test_disconnected(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.from_edgelist([(0, 1), (2, 3)])
+            nx.eulerize(G)
+
+    def test_null_graph(self):
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.eulerize(nx.Graph())
+
+    def test_null_multigraph(self):
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.eulerize(nx.MultiGraph())
+
+    def test_on_empty_graph(self):
+        with pytest.raises(nx.NetworkXError):
+            nx.eulerize(nx.empty_graph(3))
+
+    def test_on_eulerian(self):
+        G = nx.cycle_graph(3)
+        H = nx.eulerize(G)
+        assert nx.is_isomorphic(G, H)
+
+    def test_on_eulerian_multigraph(self):
+        G = nx.MultiGraph(nx.cycle_graph(3))
+        G.add_edge(0, 1)
+        H = nx.eulerize(G)
+        assert nx.is_eulerian(H)
+
+    def test_on_complete_graph(self):
+        G = nx.complete_graph(4)
+        assert nx.is_eulerian(nx.eulerize(G))
+        assert nx.is_eulerian(nx.eulerize(nx.MultiGraph(G)))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_graph_hashing.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_graph_hashing.py
new file mode 100644
index 0000000..cffa8bb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_graph_hashing.py
@@ -0,0 +1,657 @@
+import pytest
+
+import networkx as nx
+from networkx.generators import directed
+
+# Unit tests for the :func:`~networkx.weisfeiler_lehman_graph_hash` function
+
+
+def test_empty_graph_hash():
+    """
+    empty graphs should give hashes regardless of other params
+    """
+    G1 = nx.empty_graph()
+    G2 = nx.empty_graph()
+
+    h1 = nx.weisfeiler_lehman_graph_hash(G1)
+    h2 = nx.weisfeiler_lehman_graph_hash(G2)
+    h3 = nx.weisfeiler_lehman_graph_hash(G2, edge_attr="edge_attr1")
+    h4 = nx.weisfeiler_lehman_graph_hash(G2, node_attr="node_attr1")
+    h5 = nx.weisfeiler_lehman_graph_hash(
+        G2, edge_attr="edge_attr1", node_attr="node_attr1"
+    )
+    h6 = nx.weisfeiler_lehman_graph_hash(G2, iterations=10)
+
+    assert h1 == h2
+    assert h1 == h3
+    assert h1 == h4
+    assert h1 == h5
+    assert h1 == h6
+
+
+def test_directed():
+    """
+    A directed graph with no bi-directional edges should yield different a graph hash
+    to the same graph taken as undirected if there are no hash collisions.
+    """
+    r = 10
+    for i in range(r):
+        G_directed = nx.gn_graph(10 + r, seed=100 + i)
+        G_undirected = nx.to_undirected(G_directed)
+
+        h_directed = nx.weisfeiler_lehman_graph_hash(G_directed)
+        h_undirected = nx.weisfeiler_lehman_graph_hash(G_undirected)
+
+        assert h_directed != h_undirected
+
+
+def test_reversed():
+    """
+    A directed graph with no bi-directional edges should yield different a graph hash
+    to the same graph taken with edge directions reversed if there are no hash collisions.
+    Here we test a cycle graph which is the minimal counterexample
+    """
+    G = nx.cycle_graph(5, create_using=nx.DiGraph)
+    nx.set_node_attributes(G, {n: str(n) for n in G.nodes()}, name="label")
+
+    G_reversed = G.reverse()
+
+    h = nx.weisfeiler_lehman_graph_hash(G, node_attr="label")
+    h_reversed = nx.weisfeiler_lehman_graph_hash(G_reversed, node_attr="label")
+
+    assert h != h_reversed
+
+
+def test_isomorphic():
+    """
+    graph hashes should be invariant to node-relabeling (when the output is reindexed
+    by the same mapping)
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G1 = nx.erdos_renyi_graph(n, p * i, seed=200 + i)
+        G2 = nx.relabel_nodes(G1, {u: -1 * u for u in G1.nodes()})
+
+        g1_hash = nx.weisfeiler_lehman_graph_hash(G1)
+        g2_hash = nx.weisfeiler_lehman_graph_hash(G2)
+
+        assert g1_hash == g2_hash
+
+
+def test_isomorphic_edge_attr():
+    """
+    Isomorphic graphs with differing edge attributes should yield different graph
+    hashes if the 'edge_attr' argument is supplied and populated in the graph,
+    and there are no hash collisions.
+    The output should still be invariant to node-relabeling
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G1 = nx.erdos_renyi_graph(n, p * i, seed=300 + i)
+
+        for a, b in G1.edges:
+            G1[a][b]["edge_attr1"] = f"{a}-{b}-1"
+            G1[a][b]["edge_attr2"] = f"{a}-{b}-2"
+
+        g1_hash_with_edge_attr1 = nx.weisfeiler_lehman_graph_hash(
+            G1, edge_attr="edge_attr1"
+        )
+        g1_hash_with_edge_attr2 = nx.weisfeiler_lehman_graph_hash(
+            G1, edge_attr="edge_attr2"
+        )
+        g1_hash_no_edge_attr = nx.weisfeiler_lehman_graph_hash(G1, edge_attr=None)
+
+        assert g1_hash_with_edge_attr1 != g1_hash_no_edge_attr
+        assert g1_hash_with_edge_attr2 != g1_hash_no_edge_attr
+        assert g1_hash_with_edge_attr1 != g1_hash_with_edge_attr2
+
+        G2 = nx.relabel_nodes(G1, {u: -1 * u for u in G1.nodes()})
+
+        g2_hash_with_edge_attr1 = nx.weisfeiler_lehman_graph_hash(
+            G2, edge_attr="edge_attr1"
+        )
+        g2_hash_with_edge_attr2 = nx.weisfeiler_lehman_graph_hash(
+            G2, edge_attr="edge_attr2"
+        )
+
+        assert g1_hash_with_edge_attr1 == g2_hash_with_edge_attr1
+        assert g1_hash_with_edge_attr2 == g2_hash_with_edge_attr2
+
+
+def test_missing_edge_attr():
+    """
+    If the 'edge_attr' argument is supplied but is missing from an edge in the graph,
+    we should raise a KeyError
+    """
+    G = nx.Graph()
+    G.add_edges_from([(1, 2, {"edge_attr1": "a"}), (1, 3, {})])
+    pytest.raises(KeyError, nx.weisfeiler_lehman_graph_hash, G, edge_attr="edge_attr1")
+
+
+def test_isomorphic_node_attr():
+    """
+    Isomorphic graphs with differing node attributes should yield different graph
+    hashes if the 'node_attr' argument is supplied and populated in the graph, and
+    there are no hash collisions.
+    The output should still be invariant to node-relabeling
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G1 = nx.erdos_renyi_graph(n, p * i, seed=400 + i)
+
+        for u in G1.nodes():
+            G1.nodes[u]["node_attr1"] = f"{u}-1"
+            G1.nodes[u]["node_attr2"] = f"{u}-2"
+
+        g1_hash_with_node_attr1 = nx.weisfeiler_lehman_graph_hash(
+            G1, node_attr="node_attr1"
+        )
+        g1_hash_with_node_attr2 = nx.weisfeiler_lehman_graph_hash(
+            G1, node_attr="node_attr2"
+        )
+        g1_hash_no_node_attr = nx.weisfeiler_lehman_graph_hash(G1, node_attr=None)
+
+        assert g1_hash_with_node_attr1 != g1_hash_no_node_attr
+        assert g1_hash_with_node_attr2 != g1_hash_no_node_attr
+        assert g1_hash_with_node_attr1 != g1_hash_with_node_attr2
+
+        G2 = nx.relabel_nodes(G1, {u: -1 * u for u in G1.nodes()})
+
+        g2_hash_with_node_attr1 = nx.weisfeiler_lehman_graph_hash(
+            G2, node_attr="node_attr1"
+        )
+        g2_hash_with_node_attr2 = nx.weisfeiler_lehman_graph_hash(
+            G2, node_attr="node_attr2"
+        )
+
+        assert g1_hash_with_node_attr1 == g2_hash_with_node_attr1
+        assert g1_hash_with_node_attr2 == g2_hash_with_node_attr2
+
+
+def test_missing_node_attr():
+    """
+    If the 'node_attr' argument is supplied but is missing from a node in the graph,
+    we should raise a KeyError
+    """
+    G = nx.Graph()
+    G.add_nodes_from([(1, {"node_attr1": "a"}), (2, {})])
+    G.add_edges_from([(1, 2), (2, 3), (3, 1), (1, 4)])
+    pytest.raises(KeyError, nx.weisfeiler_lehman_graph_hash, G, node_attr="node_attr1")
+
+
+def test_isomorphic_edge_attr_and_node_attr():
+    """
+    Isomorphic graphs with differing node attributes should yield different graph
+    hashes if the 'node_attr' and 'edge_attr' argument is supplied and populated in
+    the graph, and there are no hash collisions.
+    The output should still be invariant to node-relabeling
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G1 = nx.erdos_renyi_graph(n, p * i, seed=500 + i)
+
+        for u in G1.nodes():
+            G1.nodes[u]["node_attr1"] = f"{u}-1"
+            G1.nodes[u]["node_attr2"] = f"{u}-2"
+
+        for a, b in G1.edges:
+            G1[a][b]["edge_attr1"] = f"{a}-{b}-1"
+            G1[a][b]["edge_attr2"] = f"{a}-{b}-2"
+
+        g1_hash_edge1_node1 = nx.weisfeiler_lehman_graph_hash(
+            G1, edge_attr="edge_attr1", node_attr="node_attr1"
+        )
+        g1_hash_edge2_node2 = nx.weisfeiler_lehman_graph_hash(
+            G1, edge_attr="edge_attr2", node_attr="node_attr2"
+        )
+        g1_hash_edge1_node2 = nx.weisfeiler_lehman_graph_hash(
+            G1, edge_attr="edge_attr1", node_attr="node_attr2"
+        )
+        g1_hash_no_attr = nx.weisfeiler_lehman_graph_hash(G1)
+
+        assert g1_hash_edge1_node1 != g1_hash_no_attr
+        assert g1_hash_edge2_node2 != g1_hash_no_attr
+        assert g1_hash_edge1_node1 != g1_hash_edge2_node2
+        assert g1_hash_edge1_node2 != g1_hash_edge2_node2
+        assert g1_hash_edge1_node2 != g1_hash_edge1_node1
+
+        G2 = nx.relabel_nodes(G1, {u: -1 * u for u in G1.nodes()})
+
+        g2_hash_edge1_node1 = nx.weisfeiler_lehman_graph_hash(
+            G2, edge_attr="edge_attr1", node_attr="node_attr1"
+        )
+        g2_hash_edge2_node2 = nx.weisfeiler_lehman_graph_hash(
+            G2, edge_attr="edge_attr2", node_attr="node_attr2"
+        )
+
+        assert g1_hash_edge1_node1 == g2_hash_edge1_node1
+        assert g1_hash_edge2_node2 == g2_hash_edge2_node2
+
+
+def test_digest_size():
+    """
+    The hash string lengths should be as expected for a variety of graphs and
+    digest sizes
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G = nx.erdos_renyi_graph(n, p * i, seed=1000 + i)
+
+        h16 = nx.weisfeiler_lehman_graph_hash(G)
+        h32 = nx.weisfeiler_lehman_graph_hash(G, digest_size=32)
+
+        assert h16 != h32
+        assert len(h16) == 16 * 2
+        assert len(h32) == 32 * 2
+
+
+# Unit tests for the :func:`~networkx.weisfeiler_lehman_hash_subgraphs` function
+
+
+def is_subiteration(a, b):
+    """
+    returns True if that each hash sequence in 'a' is a prefix for
+    the corresponding sequence indexed by the same node in 'b'.
+    """
+    return all(b[node][: len(hashes)] == hashes for node, hashes in a.items())
+
+
+def hexdigest_sizes_correct(a, digest_size):
+    """
+    returns True if all hex digest sizes are the expected length in a node:subgraph-hashes
+    dictionary. Hex digest string length == 2 * bytes digest length since each pair of hex
+    digits encodes 1 byte (https://docs.python.org/3/library/hashlib.html)
+    """
+    hexdigest_size = digest_size * 2
+    list_digest_sizes_correct = lambda l: all(len(x) == hexdigest_size for x in l)
+    return all(list_digest_sizes_correct(hashes) for hashes in a.values())
+
+
+def test_empty_graph_subgraph_hash():
+    """ "
+    empty graphs should give empty dict subgraph hashes regardless of other params
+    """
+    G = nx.empty_graph()
+
+    subgraph_hashes1 = nx.weisfeiler_lehman_subgraph_hashes(G)
+    subgraph_hashes2 = nx.weisfeiler_lehman_subgraph_hashes(G, edge_attr="edge_attr")
+    subgraph_hashes3 = nx.weisfeiler_lehman_subgraph_hashes(G, node_attr="edge_attr")
+    subgraph_hashes4 = nx.weisfeiler_lehman_subgraph_hashes(G, iterations=2)
+    subgraph_hashes5 = nx.weisfeiler_lehman_subgraph_hashes(G, digest_size=64)
+
+    assert subgraph_hashes1 == {}
+    assert subgraph_hashes2 == {}
+    assert subgraph_hashes3 == {}
+    assert subgraph_hashes4 == {}
+    assert subgraph_hashes5 == {}
+
+
+def test_directed_subgraph_hash():
+    """
+    A directed graph with no bi-directional edges should yield different subgraph hashes
+    to the same graph taken as undirected, if all hashes don't collide.
+    """
+    r = 10
+    for i in range(r):
+        G_directed = nx.gn_graph(10 + r, seed=100 + i)
+        G_undirected = nx.to_undirected(G_directed)
+
+        directed_subgraph_hashes = nx.weisfeiler_lehman_subgraph_hashes(G_directed)
+        undirected_subgraph_hashes = nx.weisfeiler_lehman_subgraph_hashes(G_undirected)
+
+        assert directed_subgraph_hashes != undirected_subgraph_hashes
+
+
+def test_reversed_subgraph_hash():
+    """
+    A directed graph with no bi-directional edges should yield different subgraph hashes
+    to the same graph taken with edge directions reversed if there are no hash collisions.
+    Here we test a cycle graph which is the minimal counterexample
+    """
+    G = nx.cycle_graph(5, create_using=nx.DiGraph)
+    nx.set_node_attributes(G, {n: str(n) for n in G.nodes()}, name="label")
+
+    G_reversed = G.reverse()
+
+    h = nx.weisfeiler_lehman_subgraph_hashes(G, node_attr="label")
+    h_reversed = nx.weisfeiler_lehman_subgraph_hashes(G_reversed, node_attr="label")
+
+    assert h != h_reversed
+
+
+def test_isomorphic_subgraph_hash():
+    """
+    the subgraph hashes should be invariant to node-relabeling when the output is reindexed
+    by the same mapping and all hashes don't collide.
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G1 = nx.erdos_renyi_graph(n, p * i, seed=200 + i)
+        G2 = nx.relabel_nodes(G1, {u: -1 * u for u in G1.nodes()})
+
+        g1_subgraph_hashes = nx.weisfeiler_lehman_subgraph_hashes(G1)
+        g2_subgraph_hashes = nx.weisfeiler_lehman_subgraph_hashes(G2)
+
+        assert g1_subgraph_hashes == {-1 * k: v for k, v in g2_subgraph_hashes.items()}
+
+
+def test_isomorphic_edge_attr_subgraph_hash():
+    """
+    Isomorphic graphs with differing edge attributes should yield different subgraph
+    hashes if the 'edge_attr' argument is supplied and populated in the graph, and
+    all hashes don't collide.
+    The output should still be invariant to node-relabeling
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G1 = nx.erdos_renyi_graph(n, p * i, seed=300 + i)
+
+        for a, b in G1.edges:
+            G1[a][b]["edge_attr1"] = f"{a}-{b}-1"
+            G1[a][b]["edge_attr2"] = f"{a}-{b}-2"
+
+        g1_hash_with_edge_attr1 = nx.weisfeiler_lehman_subgraph_hashes(
+            G1, edge_attr="edge_attr1"
+        )
+        g1_hash_with_edge_attr2 = nx.weisfeiler_lehman_subgraph_hashes(
+            G1, edge_attr="edge_attr2"
+        )
+        g1_hash_no_edge_attr = nx.weisfeiler_lehman_subgraph_hashes(G1, edge_attr=None)
+
+        assert g1_hash_with_edge_attr1 != g1_hash_no_edge_attr
+        assert g1_hash_with_edge_attr2 != g1_hash_no_edge_attr
+        assert g1_hash_with_edge_attr1 != g1_hash_with_edge_attr2
+
+        G2 = nx.relabel_nodes(G1, {u: -1 * u for u in G1.nodes()})
+
+        g2_hash_with_edge_attr1 = nx.weisfeiler_lehman_subgraph_hashes(
+            G2, edge_attr="edge_attr1"
+        )
+        g2_hash_with_edge_attr2 = nx.weisfeiler_lehman_subgraph_hashes(
+            G2, edge_attr="edge_attr2"
+        )
+
+        assert g1_hash_with_edge_attr1 == {
+            -1 * k: v for k, v in g2_hash_with_edge_attr1.items()
+        }
+        assert g1_hash_with_edge_attr2 == {
+            -1 * k: v for k, v in g2_hash_with_edge_attr2.items()
+        }
+
+
+def test_missing_edge_attr_subgraph_hash():
+    """
+    If the 'edge_attr' argument is supplied but is missing from an edge in the graph,
+    we should raise a KeyError
+    """
+    G = nx.Graph()
+    G.add_edges_from([(1, 2, {"edge_attr1": "a"}), (1, 3, {})])
+    pytest.raises(
+        KeyError, nx.weisfeiler_lehman_subgraph_hashes, G, edge_attr="edge_attr1"
+    )
+
+
+def test_isomorphic_node_attr_subgraph_hash():
+    """
+    Isomorphic graphs with differing node attributes should yield different subgraph
+    hashes if the 'node_attr' argument is supplied and populated in the graph, and
+    all hashes don't collide.
+    The output should still be invariant to node-relabeling
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G1 = nx.erdos_renyi_graph(n, p * i, seed=400 + i)
+
+        for u in G1.nodes():
+            G1.nodes[u]["node_attr1"] = f"{u}-1"
+            G1.nodes[u]["node_attr2"] = f"{u}-2"
+
+        g1_hash_with_node_attr1 = nx.weisfeiler_lehman_subgraph_hashes(
+            G1, node_attr="node_attr1"
+        )
+        g1_hash_with_node_attr2 = nx.weisfeiler_lehman_subgraph_hashes(
+            G1, node_attr="node_attr2"
+        )
+        g1_hash_no_node_attr = nx.weisfeiler_lehman_subgraph_hashes(G1, node_attr=None)
+
+        assert g1_hash_with_node_attr1 != g1_hash_no_node_attr
+        assert g1_hash_with_node_attr2 != g1_hash_no_node_attr
+        assert g1_hash_with_node_attr1 != g1_hash_with_node_attr2
+
+        G2 = nx.relabel_nodes(G1, {u: -1 * u for u in G1.nodes()})
+
+        g2_hash_with_node_attr1 = nx.weisfeiler_lehman_subgraph_hashes(
+            G2, node_attr="node_attr1"
+        )
+        g2_hash_with_node_attr2 = nx.weisfeiler_lehman_subgraph_hashes(
+            G2, node_attr="node_attr2"
+        )
+
+        assert g1_hash_with_node_attr1 == {
+            -1 * k: v for k, v in g2_hash_with_node_attr1.items()
+        }
+        assert g1_hash_with_node_attr2 == {
+            -1 * k: v for k, v in g2_hash_with_node_attr2.items()
+        }
+
+
+def test_missing_node_attr_subgraph_hash():
+    """
+    If the 'node_attr' argument is supplied but is missing from a node in the graph,
+    we should raise a KeyError
+    """
+    G = nx.Graph()
+    G.add_nodes_from([(1, {"node_attr1": "a"}), (2, {})])
+    G.add_edges_from([(1, 2), (2, 3), (3, 1), (1, 4)])
+    pytest.raises(
+        KeyError, nx.weisfeiler_lehman_subgraph_hashes, G, node_attr="node_attr1"
+    )
+
+
+def test_isomorphic_edge_attr_and_node_attr_subgraph_hash():
+    """
+    Isomorphic graphs with differing node attributes should yield different subgraph
+    hashes if the 'node_attr' and 'edge_attr' argument is supplied and populated in
+    the graph, and all hashes don't collide
+    The output should still be invariant to node-relabeling
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G1 = nx.erdos_renyi_graph(n, p * i, seed=500 + i)
+
+        for u in G1.nodes():
+            G1.nodes[u]["node_attr1"] = f"{u}-1"
+            G1.nodes[u]["node_attr2"] = f"{u}-2"
+
+        for a, b in G1.edges:
+            G1[a][b]["edge_attr1"] = f"{a}-{b}-1"
+            G1[a][b]["edge_attr2"] = f"{a}-{b}-2"
+
+        g1_hash_edge1_node1 = nx.weisfeiler_lehman_subgraph_hashes(
+            G1, edge_attr="edge_attr1", node_attr="node_attr1"
+        )
+        g1_hash_edge2_node2 = nx.weisfeiler_lehman_subgraph_hashes(
+            G1, edge_attr="edge_attr2", node_attr="node_attr2"
+        )
+        g1_hash_edge1_node2 = nx.weisfeiler_lehman_subgraph_hashes(
+            G1, edge_attr="edge_attr1", node_attr="node_attr2"
+        )
+        g1_hash_no_attr = nx.weisfeiler_lehman_subgraph_hashes(G1)
+
+        assert g1_hash_edge1_node1 != g1_hash_no_attr
+        assert g1_hash_edge2_node2 != g1_hash_no_attr
+        assert g1_hash_edge1_node1 != g1_hash_edge2_node2
+        assert g1_hash_edge1_node2 != g1_hash_edge2_node2
+        assert g1_hash_edge1_node2 != g1_hash_edge1_node1
+
+        G2 = nx.relabel_nodes(G1, {u: -1 * u for u in G1.nodes()})
+
+        g2_hash_edge1_node1 = nx.weisfeiler_lehman_subgraph_hashes(
+            G2, edge_attr="edge_attr1", node_attr="node_attr1"
+        )
+        g2_hash_edge2_node2 = nx.weisfeiler_lehman_subgraph_hashes(
+            G2, edge_attr="edge_attr2", node_attr="node_attr2"
+        )
+
+        assert g1_hash_edge1_node1 == {
+            -1 * k: v for k, v in g2_hash_edge1_node1.items()
+        }
+        assert g1_hash_edge2_node2 == {
+            -1 * k: v for k, v in g2_hash_edge2_node2.items()
+        }
+
+
+def test_iteration_depth():
+    """
+    All nodes should have the correct number of subgraph hashes in the output when
+    using degree as initial node labels
+    Subsequent iteration depths for the same graph should be additive for each node
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G = nx.erdos_renyi_graph(n, p * i, seed=600 + i)
+
+        depth3 = nx.weisfeiler_lehman_subgraph_hashes(G, iterations=3)
+        depth4 = nx.weisfeiler_lehman_subgraph_hashes(G, iterations=4)
+        depth5 = nx.weisfeiler_lehman_subgraph_hashes(G, iterations=5)
+
+        assert all(len(hashes) == 3 for hashes in depth3.values())
+        assert all(len(hashes) == 4 for hashes in depth4.values())
+        assert all(len(hashes) == 5 for hashes in depth5.values())
+
+        assert is_subiteration(depth3, depth4)
+        assert is_subiteration(depth4, depth5)
+        assert is_subiteration(depth3, depth5)
+
+
+def test_iteration_depth_edge_attr():
+    """
+    All nodes should have the correct number of subgraph hashes in the output when
+    setting initial node labels empty and using an edge attribute when aggregating
+    neighborhoods.
+    Subsequent iteration depths for the same graph should be additive for each node
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G = nx.erdos_renyi_graph(n, p * i, seed=700 + i)
+
+        for a, b in G.edges:
+            G[a][b]["edge_attr1"] = f"{a}-{b}-1"
+
+        depth3 = nx.weisfeiler_lehman_subgraph_hashes(
+            G, edge_attr="edge_attr1", iterations=3
+        )
+        depth4 = nx.weisfeiler_lehman_subgraph_hashes(
+            G, edge_attr="edge_attr1", iterations=4
+        )
+        depth5 = nx.weisfeiler_lehman_subgraph_hashes(
+            G, edge_attr="edge_attr1", iterations=5
+        )
+
+        assert all(len(hashes) == 3 for hashes in depth3.values())
+        assert all(len(hashes) == 4 for hashes in depth4.values())
+        assert all(len(hashes) == 5 for hashes in depth5.values())
+
+        assert is_subiteration(depth3, depth4)
+        assert is_subiteration(depth4, depth5)
+        assert is_subiteration(depth3, depth5)
+
+
+def test_iteration_depth_node_attr():
+    """
+    All nodes should have the correct number of subgraph hashes in the output when
+    setting initial node labels to an attribute.
+    Subsequent iteration depths for the same graph should be additive for each node
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G = nx.erdos_renyi_graph(n, p * i, seed=800 + i)
+
+        for u in G.nodes():
+            G.nodes[u]["node_attr1"] = f"{u}-1"
+
+        depth3 = nx.weisfeiler_lehman_subgraph_hashes(
+            G, node_attr="node_attr1", iterations=3
+        )
+        depth4 = nx.weisfeiler_lehman_subgraph_hashes(
+            G, node_attr="node_attr1", iterations=4
+        )
+        depth5 = nx.weisfeiler_lehman_subgraph_hashes(
+            G, node_attr="node_attr1", iterations=5
+        )
+
+        assert all(len(hashes) == 3 for hashes in depth3.values())
+        assert all(len(hashes) == 4 for hashes in depth4.values())
+        assert all(len(hashes) == 5 for hashes in depth5.values())
+
+        assert is_subiteration(depth3, depth4)
+        assert is_subiteration(depth4, depth5)
+        assert is_subiteration(depth3, depth5)
+
+
+def test_iteration_depth_node_edge_attr():
+    """
+    All nodes should have the correct number of subgraph hashes in the output when
+    setting initial node labels to an attribute and also using an edge attribute when
+    aggregating neighborhoods.
+    Subsequent iteration depths for the same graph should be additive for each node
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G = nx.erdos_renyi_graph(n, p * i, seed=900 + i)
+
+        for u in G.nodes():
+            G.nodes[u]["node_attr1"] = f"{u}-1"
+
+        for a, b in G.edges:
+            G[a][b]["edge_attr1"] = f"{a}-{b}-1"
+
+        depth3 = nx.weisfeiler_lehman_subgraph_hashes(
+            G, edge_attr="edge_attr1", node_attr="node_attr1", iterations=3
+        )
+        depth4 = nx.weisfeiler_lehman_subgraph_hashes(
+            G, edge_attr="edge_attr1", node_attr="node_attr1", iterations=4
+        )
+        depth5 = nx.weisfeiler_lehman_subgraph_hashes(
+            G, edge_attr="edge_attr1", node_attr="node_attr1", iterations=5
+        )
+
+        assert all(len(hashes) == 3 for hashes in depth3.values())
+        assert all(len(hashes) == 4 for hashes in depth4.values())
+        assert all(len(hashes) == 5 for hashes in depth5.values())
+
+        assert is_subiteration(depth3, depth4)
+        assert is_subiteration(depth4, depth5)
+        assert is_subiteration(depth3, depth5)
+
+
+def test_digest_size_subgraph_hash():
+    """
+    The hash string lengths should be as expected for a variety of graphs and
+    digest sizes
+    """
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(1, r + 1):
+        G = nx.erdos_renyi_graph(n, p * i, seed=1000 + i)
+
+        digest_size16_hashes = nx.weisfeiler_lehman_subgraph_hashes(G)
+        digest_size32_hashes = nx.weisfeiler_lehman_subgraph_hashes(G, digest_size=32)
+
+        assert digest_size16_hashes != digest_size32_hashes
+
+        assert hexdigest_sizes_correct(digest_size16_hashes, 16)
+        assert hexdigest_sizes_correct(digest_size32_hashes, 32)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_graphical.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_graphical.py
new file mode 100644
index 0000000..d55ac8c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_graphical.py
@@ -0,0 +1,163 @@
+import pytest
+
+import networkx as nx
+
+
+def test_valid_degree_sequence1():
+    n = 100
+    p = 0.3
+    for i in range(10):
+        G = nx.erdos_renyi_graph(n, p)
+        deg = (d for n, d in G.degree())
+        assert nx.is_graphical(deg, method="eg")
+        assert nx.is_graphical(deg, method="hh")
+
+
+def test_valid_degree_sequence2():
+    n = 100
+    for i in range(10):
+        G = nx.barabasi_albert_graph(n, 1)
+        deg = (d for n, d in G.degree())
+        assert nx.is_graphical(deg, method="eg")
+        assert nx.is_graphical(deg, method="hh")
+
+
+def test_string_input():
+    pytest.raises(nx.NetworkXException, nx.is_graphical, [], "foo")
+    pytest.raises(nx.NetworkXException, nx.is_graphical, ["red"], "hh")
+    pytest.raises(nx.NetworkXException, nx.is_graphical, ["red"], "eg")
+
+
+def test_non_integer_input():
+    pytest.raises(nx.NetworkXException, nx.is_graphical, [72.5], "eg")
+    pytest.raises(nx.NetworkXException, nx.is_graphical, [72.5], "hh")
+
+
+def test_negative_input():
+    assert not nx.is_graphical([-1], "hh")
+    assert not nx.is_graphical([-1], "eg")
+
+
+class TestAtlas:
+    @classmethod
+    def setup_class(cls):
+        global atlas
+        import networkx.generators.atlas as atlas
+
+        cls.GAG = atlas.graph_atlas_g()
+
+    def test_atlas(self):
+        for graph in self.GAG:
+            deg = (d for n, d in graph.degree())
+            assert nx.is_graphical(deg, method="eg")
+            assert nx.is_graphical(deg, method="hh")
+
+
+def test_small_graph_true():
+    z = [5, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
+    assert nx.is_graphical(z, method="hh")
+    assert nx.is_graphical(z, method="eg")
+    z = [10, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2]
+    assert nx.is_graphical(z, method="hh")
+    assert nx.is_graphical(z, method="eg")
+    z = [1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
+    assert nx.is_graphical(z, method="hh")
+    assert nx.is_graphical(z, method="eg")
+
+
+def test_small_graph_false():
+    z = [1000, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
+    assert not nx.is_graphical(z, method="hh")
+    assert not nx.is_graphical(z, method="eg")
+    z = [6, 5, 4, 4, 2, 1, 1, 1]
+    assert not nx.is_graphical(z, method="hh")
+    assert not nx.is_graphical(z, method="eg")
+    z = [1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
+    assert not nx.is_graphical(z, method="hh")
+    assert not nx.is_graphical(z, method="eg")
+
+
+def test_directed_degree_sequence():
+    # Test a range of valid directed degree sequences
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(r):
+        G = nx.erdos_renyi_graph(n, p * (i + 1), None, True)
+        din = (d for n, d in G.in_degree())
+        dout = (d for n, d in G.out_degree())
+        assert nx.is_digraphical(din, dout)
+
+
+def test_small_directed_sequences():
+    dout = [5, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
+    din = [3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1]
+    assert nx.is_digraphical(din, dout)
+    # Test nongraphical directed sequence
+    dout = [1000, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
+    din = [103, 102, 102, 102, 102, 102, 102, 102, 102, 102]
+    assert not nx.is_digraphical(din, dout)
+    # Test digraphical small sequence
+    dout = [1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
+    din = [2, 2, 2, 2, 2, 2, 2, 2, 1, 1]
+    assert nx.is_digraphical(din, dout)
+    # Test nonmatching sum
+    din = [2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1]
+    assert not nx.is_digraphical(din, dout)
+    # Test for negative integer in sequence
+    din = [2, 2, 2, -2, 2, 2, 2, 2, 1, 1, 4]
+    assert not nx.is_digraphical(din, dout)
+    # Test for noninteger
+    din = dout = [1, 1, 1.1, 1]
+    assert not nx.is_digraphical(din, dout)
+    din = dout = [1, 1, "rer", 1]
+    assert not nx.is_digraphical(din, dout)
+
+
+def test_multi_sequence():
+    # Test nongraphical multi sequence
+    seq = [1000, 3, 3, 3, 3, 2, 2, 2, 1, 1]
+    assert not nx.is_multigraphical(seq)
+    # Test small graphical multi sequence
+    seq = [6, 5, 4, 4, 2, 1, 1, 1]
+    assert nx.is_multigraphical(seq)
+    # Test for negative integer in sequence
+    seq = [6, 5, 4, -4, 2, 1, 1, 1]
+    assert not nx.is_multigraphical(seq)
+    # Test for sequence with odd sum
+    seq = [1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
+    assert not nx.is_multigraphical(seq)
+    # Test for noninteger
+    seq = [1, 1, 1.1, 1]
+    assert not nx.is_multigraphical(seq)
+    seq = [1, 1, "rer", 1]
+    assert not nx.is_multigraphical(seq)
+
+
+def test_pseudo_sequence():
+    # Test small valid pseudo sequence
+    seq = [1000, 3, 3, 3, 3, 2, 2, 2, 1, 1]
+    assert nx.is_pseudographical(seq)
+    # Test for sequence with odd sum
+    seq = [1000, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
+    assert not nx.is_pseudographical(seq)
+    # Test for negative integer in sequence
+    seq = [1000, 3, 3, 3, 3, 2, 2, -2, 1, 1]
+    assert not nx.is_pseudographical(seq)
+    # Test for noninteger
+    seq = [1, 1, 1.1, 1]
+    assert not nx.is_pseudographical(seq)
+    seq = [1, 1, "rer", 1]
+    assert not nx.is_pseudographical(seq)
+
+
+def test_numpy_degree_sequence():
+    np = pytest.importorskip("numpy")
+    ds = np.array([1, 2, 2, 2, 1], dtype=np.int64)
+    assert nx.is_graphical(ds, "eg")
+    assert nx.is_graphical(ds, "hh")
+    ds = np.array([1, 2, 2, 2, 1], dtype=np.float64)
+    assert nx.is_graphical(ds, "eg")
+    assert nx.is_graphical(ds, "hh")
+    ds = np.array([1.1, 2, 2, 2, 1], dtype=np.float64)
+    pytest.raises(nx.NetworkXException, nx.is_graphical, ds, "eg")
+    pytest.raises(nx.NetworkXException, nx.is_graphical, ds, "hh")
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_hierarchy.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_hierarchy.py
new file mode 100644
index 0000000..227c89c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_hierarchy.py
@@ -0,0 +1,39 @@
+import pytest
+
+import networkx as nx
+
+
+def test_hierarchy_exception():
+    G = nx.cycle_graph(5)
+    pytest.raises(nx.NetworkXError, nx.flow_hierarchy, G)
+
+
+def test_hierarchy_cycle():
+    G = nx.cycle_graph(5, create_using=nx.DiGraph())
+    assert nx.flow_hierarchy(G) == 0.0
+
+
+def test_hierarchy_tree():
+    G = nx.full_rary_tree(2, 16, create_using=nx.DiGraph())
+    assert nx.flow_hierarchy(G) == 1.0
+
+
+def test_hierarchy_1():
+    G = nx.DiGraph()
+    G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 1), (3, 4), (0, 4)])
+    assert nx.flow_hierarchy(G) == 0.5
+
+
+def test_hierarchy_weight():
+    G = nx.DiGraph()
+    G.add_edges_from(
+        [
+            (0, 1, {"weight": 0.3}),
+            (1, 2, {"weight": 0.1}),
+            (2, 3, {"weight": 0.1}),
+            (3, 1, {"weight": 0.1}),
+            (3, 4, {"weight": 0.3}),
+            (0, 4, {"weight": 0.3}),
+        ]
+    )
+    assert nx.flow_hierarchy(G, weight="weight") == 0.75
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_hybrid.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_hybrid.py
new file mode 100644
index 0000000..6af0016
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_hybrid.py
@@ -0,0 +1,24 @@
+import networkx as nx
+
+
+def test_2d_grid_graph():
+    # FC article claims 2d grid graph of size n is (3,3)-connected
+    # and (5,9)-connected, but I don't think it is (5,9)-connected
+    G = nx.grid_2d_graph(8, 8, periodic=True)
+    assert nx.is_kl_connected(G, 3, 3)
+    assert not nx.is_kl_connected(G, 5, 9)
+    (H, graphOK) = nx.kl_connected_subgraph(G, 5, 9, same_as_graph=True)
+    assert not graphOK
+
+
+def test_small_graph():
+    G = nx.Graph()
+    G.add_edge(1, 2)
+    G.add_edge(1, 3)
+    G.add_edge(2, 3)
+    assert nx.is_kl_connected(G, 2, 2)
+    H = nx.kl_connected_subgraph(G, 2, 2)
+    (H, graphOK) = nx.kl_connected_subgraph(
+        G, 2, 2, low_memory=True, same_as_graph=True
+    )
+    assert graphOK
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_isolate.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_isolate.py
new file mode 100644
index 0000000..d29b306
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_isolate.py
@@ -0,0 +1,26 @@
+"""Unit tests for the :mod:`networkx.algorithms.isolates` module."""
+
+import networkx as nx
+
+
+def test_is_isolate():
+    G = nx.Graph()
+    G.add_edge(0, 1)
+    G.add_node(2)
+    assert not nx.is_isolate(G, 0)
+    assert not nx.is_isolate(G, 1)
+    assert nx.is_isolate(G, 2)
+
+
+def test_isolates():
+    G = nx.Graph()
+    G.add_edge(0, 1)
+    G.add_nodes_from([2, 3])
+    assert sorted(nx.isolates(G)) == [2, 3]
+
+
+def test_number_of_isolates():
+    G = nx.Graph()
+    G.add_edge(0, 1)
+    G.add_nodes_from([2, 3])
+    assert nx.number_of_isolates(G) == 2
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_link_prediction.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_link_prediction.py
new file mode 100644
index 0000000..7fc04d2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_link_prediction.py
@@ -0,0 +1,582 @@
+import math
+from functools import partial
+
+import pytest
+
+import networkx as nx
+
+
+def _test_func(G, ebunch, expected, predict_func, **kwargs):
+    result = predict_func(G, ebunch, **kwargs)
+    exp_dict = {tuple(sorted([u, v])): score for u, v, score in expected}
+    res_dict = {tuple(sorted([u, v])): score for u, v, score in result}
+
+    assert len(exp_dict) == len(res_dict)
+    for p in exp_dict:
+        assert exp_dict[p] == pytest.approx(res_dict[p], abs=1e-7)
+
+
+class TestResourceAllocationIndex:
+    @classmethod
+    def setup_class(cls):
+        cls.func = staticmethod(nx.resource_allocation_index)
+        cls.test = partial(_test_func, predict_func=cls.func)
+
+    def test_K5(self):
+        G = nx.complete_graph(5)
+        self.test(G, [(0, 1)], [(0, 1, 0.75)])
+
+    def test_P3(self):
+        G = nx.path_graph(3)
+        self.test(G, [(0, 2)], [(0, 2, 0.5)])
+
+    def test_S4(self):
+        G = nx.star_graph(4)
+        self.test(G, [(1, 2)], [(1, 2, 0.25)])
+
+    def test_notimplemented(self):
+        assert pytest.raises(
+            nx.NetworkXNotImplemented, self.func, nx.DiGraph([(0, 1), (1, 2)]), [(0, 2)]
+        )
+        assert pytest.raises(
+            nx.NetworkXNotImplemented,
+            self.func,
+            nx.MultiGraph([(0, 1), (1, 2)]),
+            [(0, 2)],
+        )
+        assert pytest.raises(
+            nx.NetworkXNotImplemented,
+            self.func,
+            nx.MultiDiGraph([(0, 1), (1, 2)]),
+            [(0, 2)],
+        )
+
+    def test_no_common_neighbor(self):
+        G = nx.Graph()
+        G.add_nodes_from([0, 1])
+        self.test(G, [(0, 1)], [(0, 1, 0)])
+
+    def test_equal_nodes(self):
+        G = nx.complete_graph(4)
+        self.test(G, [(0, 0)], [(0, 0, 1)])
+
+    def test_all_nonexistent_edges(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        self.test(G, None, [(0, 3, 0.5), (1, 2, 0.5), (1, 3, 0)])
+
+
+class TestJaccardCoefficient:
+    @classmethod
+    def setup_class(cls):
+        cls.func = staticmethod(nx.jaccard_coefficient)
+        cls.test = partial(_test_func, predict_func=cls.func)
+
+    def test_K5(self):
+        G = nx.complete_graph(5)
+        self.test(G, [(0, 1)], [(0, 1, 0.6)])
+
+    def test_P4(self):
+        G = nx.path_graph(4)
+        self.test(G, [(0, 2)], [(0, 2, 0.5)])
+
+    def test_notimplemented(self):
+        assert pytest.raises(
+            nx.NetworkXNotImplemented, self.func, nx.DiGraph([(0, 1), (1, 2)]), [(0, 2)]
+        )
+        assert pytest.raises(
+            nx.NetworkXNotImplemented,
+            self.func,
+            nx.MultiGraph([(0, 1), (1, 2)]),
+            [(0, 2)],
+        )
+        assert pytest.raises(
+            nx.NetworkXNotImplemented,
+            self.func,
+            nx.MultiDiGraph([(0, 1), (1, 2)]),
+            [(0, 2)],
+        )
+
+    def test_no_common_neighbor(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (2, 3)])
+        self.test(G, [(0, 2)], [(0, 2, 0)])
+
+    def test_isolated_nodes(self):
+        G = nx.Graph()
+        G.add_nodes_from([0, 1])
+        self.test(G, [(0, 1)], [(0, 1, 0)])
+
+    def test_all_nonexistent_edges(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        self.test(G, None, [(0, 3, 0.5), (1, 2, 0.5), (1, 3, 0)])
+
+
+class TestAdamicAdarIndex:
+    @classmethod
+    def setup_class(cls):
+        cls.func = staticmethod(nx.adamic_adar_index)
+        cls.test = partial(_test_func, predict_func=cls.func)
+
+    def test_K5(self):
+        G = nx.complete_graph(5)
+        self.test(G, [(0, 1)], [(0, 1, 3 / math.log(4))])
+
+    def test_P3(self):
+        G = nx.path_graph(3)
+        self.test(G, [(0, 2)], [(0, 2, 1 / math.log(2))])
+
+    def test_S4(self):
+        G = nx.star_graph(4)
+        self.test(G, [(1, 2)], [(1, 2, 1 / math.log(4))])
+
+    def test_notimplemented(self):
+        assert pytest.raises(
+            nx.NetworkXNotImplemented, self.func, nx.DiGraph([(0, 1), (1, 2)]), [(0, 2)]
+        )
+        assert pytest.raises(
+            nx.NetworkXNotImplemented,
+            self.func,
+            nx.MultiGraph([(0, 1), (1, 2)]),
+            [(0, 2)],
+        )
+        assert pytest.raises(
+            nx.NetworkXNotImplemented,
+            self.func,
+            nx.MultiDiGraph([(0, 1), (1, 2)]),
+            [(0, 2)],
+        )
+
+    def test_no_common_neighbor(self):
+        G = nx.Graph()
+        G.add_nodes_from([0, 1])
+        self.test(G, [(0, 1)], [(0, 1, 0)])
+
+    def test_equal_nodes(self):
+        G = nx.complete_graph(4)
+        self.test(G, [(0, 0)], [(0, 0, 3 / math.log(3))])
+
+    def test_all_nonexistent_edges(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        self.test(
+            G, None, [(0, 3, 1 / math.log(2)), (1, 2, 1 / math.log(2)), (1, 3, 0)]
+        )
+
+
+class TestCommonNeighborCentrality:
+    @classmethod
+    def setup_class(cls):
+        cls.func = staticmethod(nx.common_neighbor_centrality)
+        cls.test = partial(_test_func, predict_func=cls.func)
+
+    def test_K5(self):
+        G = nx.complete_graph(5)
+        self.test(G, [(0, 1)], [(0, 1, 3.0)], alpha=1)
+        self.test(G, [(0, 1)], [(0, 1, 5.0)], alpha=0)
+
+    def test_P3(self):
+        G = nx.path_graph(3)
+        self.test(G, [(0, 2)], [(0, 2, 1.25)], alpha=0.5)
+
+    def test_S4(self):
+        G = nx.star_graph(4)
+        self.test(G, [(1, 2)], [(1, 2, 1.75)], alpha=0.5)
+
+    @pytest.mark.parametrize("graph_type", (nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph))
+    def test_notimplemented(self, graph_type):
+        assert pytest.raises(
+            nx.NetworkXNotImplemented, self.func, graph_type([(0, 1), (1, 2)]), [(0, 2)]
+        )
+
+    def test_no_common_neighbor(self):
+        G = nx.Graph()
+        G.add_nodes_from([0, 1])
+        self.test(G, [(0, 1)], [(0, 1, 0)])
+
+    def test_equal_nodes(self):
+        G = nx.complete_graph(4)
+        assert pytest.raises(nx.NetworkXAlgorithmError, self.test, G, [(0, 0)], [])
+
+    def test_all_nonexistent_edges(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        self.test(G, None, [(0, 3, 1.5), (1, 2, 1.5), (1, 3, 2 / 3)], alpha=0.5)
+
+
+class TestPreferentialAttachment:
+    @classmethod
+    def setup_class(cls):
+        cls.func = staticmethod(nx.preferential_attachment)
+        cls.test = partial(_test_func, predict_func=cls.func)
+
+    def test_K5(self):
+        G = nx.complete_graph(5)
+        self.test(G, [(0, 1)], [(0, 1, 16)])
+
+    def test_P3(self):
+        G = nx.path_graph(3)
+        self.test(G, [(0, 1)], [(0, 1, 2)])
+
+    def test_S4(self):
+        G = nx.star_graph(4)
+        self.test(G, [(0, 2)], [(0, 2, 4)])
+
+    def test_notimplemented(self):
+        assert pytest.raises(
+            nx.NetworkXNotImplemented, self.func, nx.DiGraph([(0, 1), (1, 2)]), [(0, 2)]
+        )
+        assert pytest.raises(
+            nx.NetworkXNotImplemented,
+            self.func,
+            nx.MultiGraph([(0, 1), (1, 2)]),
+            [(0, 2)],
+        )
+        assert pytest.raises(
+            nx.NetworkXNotImplemented,
+            self.func,
+            nx.MultiDiGraph([(0, 1), (1, 2)]),
+            [(0, 2)],
+        )
+
+    def test_zero_degrees(self):
+        G = nx.Graph()
+        G.add_nodes_from([0, 1])
+        self.test(G, [(0, 1)], [(0, 1, 0)])
+
+    def test_all_nonexistent_edges(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        self.test(G, None, [(0, 3, 2), (1, 2, 2), (1, 3, 1)])
+
+
+class TestCNSoundarajanHopcroft:
+    @classmethod
+    def setup_class(cls):
+        cls.func = staticmethod(nx.cn_soundarajan_hopcroft)
+        cls.test = partial(_test_func, predict_func=cls.func, community="community")
+
+    def test_K5(self):
+        G = nx.complete_graph(5)
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        G.nodes[4]["community"] = 1
+        self.test(G, [(0, 1)], [(0, 1, 5)])
+
+    def test_P3(self):
+        G = nx.path_graph(3)
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 0
+        self.test(G, [(0, 2)], [(0, 2, 1)])
+
+    def test_S4(self):
+        G = nx.star_graph(4)
+        G.nodes[0]["community"] = 1
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 1
+        G.nodes[3]["community"] = 0
+        G.nodes[4]["community"] = 0
+        self.test(G, [(1, 2)], [(1, 2, 2)])
+
+    def test_notimplemented(self):
+        G = nx.DiGraph([(0, 1), (1, 2)])
+        G.add_nodes_from([0, 1, 2], community=0)
+        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
+        G = nx.MultiGraph([(0, 1), (1, 2)])
+        G.add_nodes_from([0, 1, 2], community=0)
+        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
+        G = nx.MultiDiGraph([(0, 1), (1, 2)])
+        G.add_nodes_from([0, 1, 2], community=0)
+        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
+
+    def test_no_common_neighbor(self):
+        G = nx.Graph()
+        G.add_nodes_from([0, 1])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        self.test(G, [(0, 1)], [(0, 1, 0)])
+
+    def test_equal_nodes(self):
+        G = nx.complete_graph(3)
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        self.test(G, [(0, 0)], [(0, 0, 4)])
+
+    def test_different_community(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 1
+        self.test(G, [(0, 3)], [(0, 3, 2)])
+
+    def test_no_community_information(self):
+        G = nx.complete_graph(5)
+        assert pytest.raises(nx.NetworkXAlgorithmError, list, self.func(G, [(0, 1)]))
+
+    def test_insufficient_community_information(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[3]["community"] = 0
+        assert pytest.raises(nx.NetworkXAlgorithmError, list, self.func(G, [(0, 3)]))
+
+    def test_sufficient_community_information(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (1, 2), (1, 3), (2, 4), (3, 4), (4, 5)])
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        G.nodes[4]["community"] = 0
+        self.test(G, [(1, 4)], [(1, 4, 4)])
+
+    def test_custom_community_attribute_name(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
+        G.nodes[0]["cmty"] = 0
+        G.nodes[1]["cmty"] = 0
+        G.nodes[2]["cmty"] = 0
+        G.nodes[3]["cmty"] = 1
+        self.test(G, [(0, 3)], [(0, 3, 2)], community="cmty")
+
+    def test_all_nonexistent_edges(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        self.test(G, None, [(0, 3, 2), (1, 2, 1), (1, 3, 0)])
+
+
+class TestRAIndexSoundarajanHopcroft:
+    @classmethod
+    def setup_class(cls):
+        cls.func = staticmethod(nx.ra_index_soundarajan_hopcroft)
+        cls.test = partial(_test_func, predict_func=cls.func, community="community")
+
+    def test_K5(self):
+        G = nx.complete_graph(5)
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        G.nodes[4]["community"] = 1
+        self.test(G, [(0, 1)], [(0, 1, 0.5)])
+
+    def test_P3(self):
+        G = nx.path_graph(3)
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 0
+        self.test(G, [(0, 2)], [(0, 2, 0)])
+
+    def test_S4(self):
+        G = nx.star_graph(4)
+        G.nodes[0]["community"] = 1
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 1
+        G.nodes[3]["community"] = 0
+        G.nodes[4]["community"] = 0
+        self.test(G, [(1, 2)], [(1, 2, 0.25)])
+
+    def test_notimplemented(self):
+        G = nx.DiGraph([(0, 1), (1, 2)])
+        G.add_nodes_from([0, 1, 2], community=0)
+        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
+        G = nx.MultiGraph([(0, 1), (1, 2)])
+        G.add_nodes_from([0, 1, 2], community=0)
+        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
+        G = nx.MultiDiGraph([(0, 1), (1, 2)])
+        G.add_nodes_from([0, 1, 2], community=0)
+        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
+
+    def test_no_common_neighbor(self):
+        G = nx.Graph()
+        G.add_nodes_from([0, 1])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        self.test(G, [(0, 1)], [(0, 1, 0)])
+
+    def test_equal_nodes(self):
+        G = nx.complete_graph(3)
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        self.test(G, [(0, 0)], [(0, 0, 1)])
+
+    def test_different_community(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 1
+        self.test(G, [(0, 3)], [(0, 3, 0)])
+
+    def test_no_community_information(self):
+        G = nx.complete_graph(5)
+        assert pytest.raises(nx.NetworkXAlgorithmError, list, self.func(G, [(0, 1)]))
+
+    def test_insufficient_community_information(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[3]["community"] = 0
+        assert pytest.raises(nx.NetworkXAlgorithmError, list, self.func(G, [(0, 3)]))
+
+    def test_sufficient_community_information(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (1, 2), (1, 3), (2, 4), (3, 4), (4, 5)])
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        G.nodes[4]["community"] = 0
+        self.test(G, [(1, 4)], [(1, 4, 1)])
+
+    def test_custom_community_attribute_name(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
+        G.nodes[0]["cmty"] = 0
+        G.nodes[1]["cmty"] = 0
+        G.nodes[2]["cmty"] = 0
+        G.nodes[3]["cmty"] = 1
+        self.test(G, [(0, 3)], [(0, 3, 0)], community="cmty")
+
+    def test_all_nonexistent_edges(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        self.test(G, None, [(0, 3, 0.5), (1, 2, 0), (1, 3, 0)])
+
+
+class TestWithinInterCluster:
+    @classmethod
+    def setup_class(cls):
+        cls.delta = 0.001
+        cls.func = staticmethod(nx.within_inter_cluster)
+        cls.test = partial(
+            _test_func, predict_func=cls.func, delta=cls.delta, community="community"
+        )
+
+    def test_K5(self):
+        G = nx.complete_graph(5)
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        G.nodes[4]["community"] = 1
+        self.test(G, [(0, 1)], [(0, 1, 2 / (1 + self.delta))])
+
+    def test_P3(self):
+        G = nx.path_graph(3)
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 0
+        self.test(G, [(0, 2)], [(0, 2, 0)])
+
+    def test_S4(self):
+        G = nx.star_graph(4)
+        G.nodes[0]["community"] = 1
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 1
+        G.nodes[3]["community"] = 0
+        G.nodes[4]["community"] = 0
+        self.test(G, [(1, 2)], [(1, 2, 1 / self.delta)])
+
+    def test_notimplemented(self):
+        G = nx.DiGraph([(0, 1), (1, 2)])
+        G.add_nodes_from([0, 1, 2], community=0)
+        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
+        G = nx.MultiGraph([(0, 1), (1, 2)])
+        G.add_nodes_from([0, 1, 2], community=0)
+        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
+        G = nx.MultiDiGraph([(0, 1), (1, 2)])
+        G.add_nodes_from([0, 1, 2], community=0)
+        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
+
+    def test_no_common_neighbor(self):
+        G = nx.Graph()
+        G.add_nodes_from([0, 1])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        self.test(G, [(0, 1)], [(0, 1, 0)])
+
+    def test_equal_nodes(self):
+        G = nx.complete_graph(3)
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        self.test(G, [(0, 0)], [(0, 0, 2 / self.delta)])
+
+    def test_different_community(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 1
+        self.test(G, [(0, 3)], [(0, 3, 0)])
+
+    def test_no_inter_cluster_common_neighbor(self):
+        G = nx.complete_graph(4)
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        self.test(G, [(0, 3)], [(0, 3, 2 / self.delta)])
+
+    def test_no_community_information(self):
+        G = nx.complete_graph(5)
+        assert pytest.raises(nx.NetworkXAlgorithmError, list, self.func(G, [(0, 1)]))
+
+    def test_insufficient_community_information(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 0
+        G.nodes[3]["community"] = 0
+        assert pytest.raises(nx.NetworkXAlgorithmError, list, self.func(G, [(0, 3)]))
+
+    def test_sufficient_community_information(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (1, 2), (1, 3), (2, 4), (3, 4), (4, 5)])
+        G.nodes[1]["community"] = 0
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        G.nodes[4]["community"] = 0
+        self.test(G, [(1, 4)], [(1, 4, 2 / self.delta)])
+
+    def test_invalid_delta(self):
+        G = nx.complete_graph(3)
+        G.add_nodes_from([0, 1, 2], community=0)
+        assert pytest.raises(nx.NetworkXAlgorithmError, self.func, G, [(0, 1)], 0)
+        assert pytest.raises(nx.NetworkXAlgorithmError, self.func, G, [(0, 1)], -0.5)
+
+    def test_custom_community_attribute_name(self):
+        G = nx.complete_graph(4)
+        G.nodes[0]["cmty"] = 0
+        G.nodes[1]["cmty"] = 0
+        G.nodes[2]["cmty"] = 0
+        G.nodes[3]["cmty"] = 0
+        self.test(G, [(0, 3)], [(0, 3, 2 / self.delta)], community="cmty")
+
+    def test_all_nonexistent_edges(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        self.test(G, None, [(0, 3, 1 / self.delta), (1, 2, 0), (1, 3, 0)])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_lowest_common_ancestors.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_lowest_common_ancestors.py
new file mode 100644
index 0000000..acb2336
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_lowest_common_ancestors.py
@@ -0,0 +1,313 @@
+from itertools import chain, combinations, product
+
+import pytest
+
+import networkx as nx
+
+tree_all_pairs_lca = nx.tree_all_pairs_lowest_common_ancestor
+all_pairs_lca = nx.all_pairs_lowest_common_ancestor
+
+
+def get_pair(dictionary, n1, n2):
+    if (n1, n2) in dictionary:
+        return dictionary[n1, n2]
+    else:
+        return dictionary[n2, n1]
+
+
+class TestTreeLCA:
+    @classmethod
+    def setup_class(cls):
+        cls.DG = nx.DiGraph()
+        edges = [(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6)]
+        cls.DG.add_edges_from(edges)
+        cls.ans = dict(tree_all_pairs_lca(cls.DG, 0))
+        gold = {(n, n): n for n in cls.DG}
+        gold.update({(0, i): 0 for i in range(1, 7)})
+        gold.update(
+            {
+                (1, 2): 0,
+                (1, 3): 1,
+                (1, 4): 1,
+                (1, 5): 0,
+                (1, 6): 0,
+                (2, 3): 0,
+                (2, 4): 0,
+                (2, 5): 2,
+                (2, 6): 2,
+                (3, 4): 1,
+                (3, 5): 0,
+                (3, 6): 0,
+                (4, 5): 0,
+                (4, 6): 0,
+                (5, 6): 2,
+            }
+        )
+
+        cls.gold = gold
+
+    @staticmethod
+    def assert_has_same_pairs(d1, d2):
+        for (a, b) in ((min(pair), max(pair)) for pair in chain(d1, d2)):
+            assert get_pair(d1, a, b) == get_pair(d2, a, b)
+
+    def test_tree_all_pairs_lowest_common_ancestor1(self):
+        """Specifying the root is optional."""
+        assert dict(tree_all_pairs_lca(self.DG)) == self.ans
+
+    def test_tree_all_pairs_lowest_common_ancestor2(self):
+        """Specifying only some pairs gives only those pairs."""
+        test_pairs = [(0, 1), (0, 1), (1, 0)]
+        ans = dict(tree_all_pairs_lca(self.DG, 0, test_pairs))
+        assert (0, 1) in ans and (1, 0) in ans
+        assert len(ans) == 2
+
+    def test_tree_all_pairs_lowest_common_ancestor3(self):
+        """Specifying no pairs same as specifying all."""
+        all_pairs = chain(combinations(self.DG, 2), ((node, node) for node in self.DG))
+
+        ans = dict(tree_all_pairs_lca(self.DG, 0, all_pairs))
+        self.assert_has_same_pairs(ans, self.ans)
+
+    def test_tree_all_pairs_lowest_common_ancestor4(self):
+        """Gives the right answer."""
+        ans = dict(tree_all_pairs_lca(self.DG))
+        self.assert_has_same_pairs(self.gold, ans)
+
+    def test_tree_all_pairs_lowest_common_ancestor5(self):
+        """Handles invalid input correctly."""
+        empty_digraph = tree_all_pairs_lca(nx.DiGraph())
+        pytest.raises(nx.NetworkXPointlessConcept, list, empty_digraph)
+
+        bad_pairs_digraph = tree_all_pairs_lca(self.DG, pairs=[(-1, -2)])
+        pytest.raises(nx.NodeNotFound, list, bad_pairs_digraph)
+
+    def test_tree_all_pairs_lowest_common_ancestor6(self):
+        """Works on subtrees."""
+        ans = dict(tree_all_pairs_lca(self.DG, 1))
+        gold = {
+            pair: lca
+            for (pair, lca) in self.gold.items()
+            if all(n in (1, 3, 4) for n in pair)
+        }
+        self.assert_has_same_pairs(gold, ans)
+
+    def test_tree_all_pairs_lowest_common_ancestor7(self):
+        """Works on disconnected nodes."""
+        G = nx.DiGraph()
+        G.add_node(1)
+        assert {(1, 1): 1} == dict(tree_all_pairs_lca(G))
+
+        G.add_node(0)
+        assert {(1, 1): 1} == dict(tree_all_pairs_lca(G, 1))
+        assert {(0, 0): 0} == dict(tree_all_pairs_lca(G, 0))
+
+        pytest.raises(nx.NetworkXError, list, tree_all_pairs_lca(G))
+
+    def test_tree_all_pairs_lowest_common_ancestor8(self):
+        """Raises right errors if not a tree."""
+        # Cycle
+        G = nx.DiGraph([(1, 2), (2, 1)])
+        pytest.raises(nx.NetworkXError, list, tree_all_pairs_lca(G))
+        # DAG
+        G = nx.DiGraph([(0, 2), (1, 2)])
+        pytest.raises(nx.NetworkXError, list, tree_all_pairs_lca(G))
+
+    def test_tree_all_pairs_lowest_common_ancestor9(self):
+        """Test that pairs works correctly as a generator."""
+        pairs = iter([(0, 1), (0, 1), (1, 0)])
+        some_pairs = dict(tree_all_pairs_lca(self.DG, 0, pairs))
+        assert (0, 1) in some_pairs and (1, 0) in some_pairs
+        assert len(some_pairs) == 2
+
+    def test_tree_all_pairs_lowest_common_ancestor10(self):
+        """Test that pairs not in the graph raises error."""
+        lca = tree_all_pairs_lca(self.DG, 0, [(-1, -1)])
+        pytest.raises(nx.NodeNotFound, list, lca)
+        # check if node is None
+        lca = tree_all_pairs_lca(self.DG, None, [(-1, -1)])
+        pytest.raises(nx.NodeNotFound, list, lca)
+
+    def test_tree_all_pairs_lowest_common_ancestor12(self):
+        """Test that tree routine bails on DAGs."""
+        G = nx.DiGraph([(3, 4), (5, 4)])
+        pytest.raises(nx.NetworkXError, list, tree_all_pairs_lca(G))
+
+    def test_not_implemented_for(self):
+        NNI = nx.NetworkXNotImplemented
+        G = nx.Graph([(0, 1)])
+        with pytest.raises(NNI):
+            next(tree_all_pairs_lca(G))
+        with pytest.raises(NNI):
+            next(all_pairs_lca(G))
+        pytest.raises(NNI, nx.lowest_common_ancestor, G, 0, 1)
+        G = nx.MultiGraph([(0, 1)])
+        with pytest.raises(NNI):
+            next(tree_all_pairs_lca(G))
+        with pytest.raises(NNI):
+            next(all_pairs_lca(G))
+        pytest.raises(NNI, nx.lowest_common_ancestor, G, 0, 1)
+        G = nx.MultiDiGraph([(0, 1)])
+        with pytest.raises(NNI):
+            next(tree_all_pairs_lca(G))
+        with pytest.raises(NNI):
+            next(all_pairs_lca(G))
+        pytest.raises(NNI, nx.lowest_common_ancestor, G, 0, 1)
+
+    def test_tree_all_pairs_lowest_common_ancestor13(self):
+        """Test that it works on non-empty trees with no LCAs."""
+        G = nx.DiGraph()
+        G.add_node(3)
+        ans = list(tree_all_pairs_lca(G))
+        assert ans == [((3, 3), 3)]
+
+
+class TestDAGLCA:
+    @classmethod
+    def setup_class(cls):
+        cls.DG = nx.DiGraph()
+        nx.add_path(cls.DG, (0, 1, 2, 3))
+        nx.add_path(cls.DG, (0, 4, 3))
+        nx.add_path(cls.DG, (0, 5, 6, 8, 3))
+        nx.add_path(cls.DG, (5, 7, 8))
+        cls.DG.add_edge(6, 2)
+        cls.DG.add_edge(7, 2)
+
+        cls.root_distance = nx.shortest_path_length(cls.DG, source=0)
+
+        cls.gold = {
+            (1, 1): 1,
+            (1, 2): 1,
+            (1, 3): 1,
+            (1, 4): 0,
+            (1, 5): 0,
+            (1, 6): 0,
+            (1, 7): 0,
+            (1, 8): 0,
+            (2, 2): 2,
+            (2, 3): 2,
+            (2, 4): 0,
+            (2, 5): 5,
+            (2, 6): 6,
+            (2, 7): 7,
+            (2, 8): 7,
+            (3, 3): 8,
+            (3, 4): 4,
+            (3, 5): 5,
+            (3, 6): 6,
+            (3, 7): 7,
+            (3, 8): 8,
+            (4, 4): 4,
+            (4, 5): 0,
+            (4, 6): 0,
+            (4, 7): 0,
+            (4, 8): 0,
+            (5, 5): 5,
+            (5, 6): 5,
+            (5, 7): 5,
+            (5, 8): 5,
+            (6, 6): 6,
+            (6, 7): 5,
+            (6, 8): 6,
+            (7, 7): 7,
+            (7, 8): 7,
+            (8, 8): 8,
+        }
+        cls.gold.update(((0, n), 0) for n in cls.DG)
+
+    def assert_lca_dicts_same(self, d1, d2, G=None):
+        """Checks if d1 and d2 contain the same pairs and
+        have a node at the same distance from root for each.
+        If G is None use self.DG."""
+        if G is None:
+            G = self.DG
+            root_distance = self.root_distance
+        else:
+            roots = [n for n, deg in G.in_degree if deg == 0]
+            assert len(roots) == 1
+            root_distance = nx.shortest_path_length(G, source=roots[0])
+
+        for a, b in ((min(pair), max(pair)) for pair in chain(d1, d2)):
+            assert (
+                root_distance[get_pair(d1, a, b)] == root_distance[get_pair(d2, a, b)]
+            )
+
+    def test_all_pairs_lowest_common_ancestor1(self):
+        """Produces the correct results."""
+        self.assert_lca_dicts_same(dict(all_pairs_lca(self.DG)), self.gold)
+
+    def test_all_pairs_lowest_common_ancestor2(self):
+        """Produces the correct results when all pairs given."""
+        all_pairs = list(product(self.DG.nodes(), self.DG.nodes()))
+        ans = all_pairs_lca(self.DG, pairs=all_pairs)
+        self.assert_lca_dicts_same(dict(ans), self.gold)
+
+    def test_all_pairs_lowest_common_ancestor3(self):
+        """Produces the correct results when all pairs given as a generator."""
+        all_pairs = product(self.DG.nodes(), self.DG.nodes())
+        ans = all_pairs_lca(self.DG, pairs=all_pairs)
+        self.assert_lca_dicts_same(dict(ans), self.gold)
+
+    def test_all_pairs_lowest_common_ancestor4(self):
+        """Graph with two roots."""
+        G = self.DG.copy()
+        G.add_edge(9, 10)
+        G.add_edge(9, 4)
+        gold = self.gold.copy()
+        gold[9, 9] = 9
+        gold[9, 10] = 9
+        gold[9, 4] = 9
+        gold[9, 3] = 9
+        gold[10, 4] = 9
+        gold[10, 3] = 9
+        gold[10, 10] = 10
+
+        testing = dict(all_pairs_lca(G))
+
+        G.add_edge(-1, 9)
+        G.add_edge(-1, 0)
+        self.assert_lca_dicts_same(testing, gold, G)
+
+    def test_all_pairs_lowest_common_ancestor5(self):
+        """Test that pairs not in the graph raises error."""
+        pytest.raises(nx.NodeNotFound, all_pairs_lca, self.DG, [(-1, -1)])
+
+    def test_all_pairs_lowest_common_ancestor6(self):
+        """Test that pairs with no LCA specified emits nothing."""
+        G = self.DG.copy()
+        G.add_node(-1)
+        gen = all_pairs_lca(G, [(-1, -1), (-1, 0)])
+        assert dict(gen) == {(-1, -1): -1}
+
+    def test_all_pairs_lowest_common_ancestor7(self):
+        """Test that LCA on null graph bails."""
+        pytest.raises(nx.NetworkXPointlessConcept, all_pairs_lca, nx.DiGraph())
+
+    def test_all_pairs_lowest_common_ancestor8(self):
+        """Test that LCA on non-dags bails."""
+        pytest.raises(nx.NetworkXError, all_pairs_lca, nx.DiGraph([(3, 4), (4, 3)]))
+
+    def test_all_pairs_lowest_common_ancestor9(self):
+        """Test that it works on non-empty graphs with no LCAs."""
+        G = nx.DiGraph()
+        G.add_node(3)
+        ans = list(all_pairs_lca(G))
+        assert ans == [((3, 3), 3)]
+
+    def test_all_pairs_lowest_common_ancestor10(self):
+        """Test that it works on a small graph that previously revealed a bug gh-4942"""
+        G = nx.DiGraph([(0, 2), (1, 2), (2, 3)])
+        ans = list(all_pairs_lca(G))
+        assert len(ans) == 9
+
+    def test_lowest_common_ancestor1(self):
+        """Test that the one-pair function works on default."""
+        G = nx.DiGraph([(0, 1), (2, 1)])
+        sentinel = object()
+        assert nx.lowest_common_ancestor(G, 0, 2, default=sentinel) is sentinel
+
+    def test_lowest_common_ancestor2(self):
+        """Test that the one-pair function works on identity."""
+        G = nx.DiGraph()
+        G.add_node(3)
+        assert nx.lowest_common_ancestor(G, 3, 3) == 3
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_matching.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_matching.py
new file mode 100644
index 0000000..b5a466d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_matching.py
@@ -0,0 +1,572 @@
+import math
+from itertools import permutations
+
+from pytest import raises
+
+import networkx as nx
+from networkx.algorithms.matching import matching_dict_to_set
+from networkx.utils import edges_equal
+
+
+class TestMaxWeightMatching:
+    """Unit tests for the
+    :func:`~networkx.algorithms.matching.max_weight_matching` function.
+
+    """
+
+    def test_trivial1(self):
+        """Empty graph"""
+        G = nx.Graph()
+        assert nx.max_weight_matching(G) == set()
+        assert nx.min_weight_matching(G) == set()
+
+    def test_selfloop(self):
+        G = nx.Graph()
+        G.add_edge(0, 0, weight=100)
+        assert nx.max_weight_matching(G) == set()
+        assert nx.min_weight_matching(G) == set()
+
+    def test_single_edge(self):
+        G = nx.Graph()
+        G.add_edge(0, 1)
+        assert edges_equal(
+            nx.max_weight_matching(G), matching_dict_to_set({0: 1, 1: 0})
+        )
+        assert edges_equal(
+            nx.min_weight_matching(G), matching_dict_to_set({0: 1, 1: 0})
+        )
+
+    def test_two_path(self):
+        G = nx.Graph()
+        G.add_edge("one", "two", weight=10)
+        G.add_edge("two", "three", weight=11)
+        assert edges_equal(
+            nx.max_weight_matching(G),
+            matching_dict_to_set({"three": "two", "two": "three"}),
+        )
+        assert edges_equal(
+            nx.min_weight_matching(G),
+            matching_dict_to_set({"one": "two", "two": "one"}),
+        )
+
+    def test_path(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=5)
+        G.add_edge(2, 3, weight=11)
+        G.add_edge(3, 4, weight=5)
+        assert edges_equal(
+            nx.max_weight_matching(G), matching_dict_to_set({2: 3, 3: 2})
+        )
+        assert edges_equal(
+            nx.max_weight_matching(G, 1), matching_dict_to_set({1: 2, 2: 1, 3: 4, 4: 3})
+        )
+        assert edges_equal(
+            nx.min_weight_matching(G), matching_dict_to_set({1: 2, 3: 4})
+        )
+        assert edges_equal(
+            nx.min_weight_matching(G, 1), matching_dict_to_set({1: 2, 3: 4})
+        )
+
+    def test_square(self):
+        G = nx.Graph()
+        G.add_edge(1, 4, weight=2)
+        G.add_edge(2, 3, weight=2)
+        G.add_edge(1, 2, weight=1)
+        G.add_edge(3, 4, weight=4)
+        assert edges_equal(
+            nx.max_weight_matching(G), matching_dict_to_set({1: 2, 3: 4})
+        )
+        assert edges_equal(
+            nx.min_weight_matching(G), matching_dict_to_set({1: 4, 2: 3})
+        )
+
+    def test_edge_attribute_name(self):
+        G = nx.Graph()
+        G.add_edge("one", "two", weight=10, abcd=11)
+        G.add_edge("two", "three", weight=11, abcd=10)
+        assert edges_equal(
+            nx.max_weight_matching(G, weight="abcd"),
+            matching_dict_to_set({"one": "two", "two": "one"}),
+        )
+        assert edges_equal(
+            nx.min_weight_matching(G, weight="abcd"),
+            matching_dict_to_set({"three": "two"}),
+        )
+
+    def test_floating_point_weights(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=math.pi)
+        G.add_edge(2, 3, weight=math.exp(1))
+        G.add_edge(1, 3, weight=3.0)
+        G.add_edge(1, 4, weight=math.sqrt(2.0))
+        assert edges_equal(
+            nx.max_weight_matching(G), matching_dict_to_set({1: 4, 2: 3, 3: 2, 4: 1})
+        )
+        assert edges_equal(
+            nx.min_weight_matching(G), matching_dict_to_set({1: 4, 2: 3, 3: 2, 4: 1})
+        )
+
+    def test_negative_weights(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=2)
+        G.add_edge(1, 3, weight=-2)
+        G.add_edge(2, 3, weight=1)
+        G.add_edge(2, 4, weight=-1)
+        G.add_edge(3, 4, weight=-6)
+        assert edges_equal(
+            nx.max_weight_matching(G), matching_dict_to_set({1: 2, 2: 1})
+        )
+        assert edges_equal(
+            nx.max_weight_matching(G, 1), matching_dict_to_set({1: 3, 2: 4, 3: 1, 4: 2})
+        )
+        assert edges_equal(
+            nx.min_weight_matching(G), matching_dict_to_set({1: 2, 3: 4})
+        )
+        assert edges_equal(
+            nx.min_weight_matching(G, 1), matching_dict_to_set({1: 2, 3: 4})
+        )
+
+    def test_s_blossom(self):
+        """Create S-blossom and use it for augmentation:"""
+        G = nx.Graph()
+        G.add_weighted_edges_from([(1, 2, 8), (1, 3, 9), (2, 3, 10), (3, 4, 7)])
+        answer = matching_dict_to_set({1: 2, 2: 1, 3: 4, 4: 3})
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+        G.add_weighted_edges_from([(1, 6, 5), (4, 5, 6)])
+        answer = matching_dict_to_set({1: 6, 2: 3, 3: 2, 4: 5, 5: 4, 6: 1})
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+    def test_s_t_blossom(self):
+        """Create S-blossom, relabel as T-blossom, use for augmentation:"""
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [(1, 2, 9), (1, 3, 8), (2, 3, 10), (1, 4, 5), (4, 5, 4), (1, 6, 3)]
+        )
+        answer = matching_dict_to_set({1: 6, 2: 3, 3: 2, 4: 5, 5: 4, 6: 1})
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+        G.add_edge(4, 5, weight=3)
+        G.add_edge(1, 6, weight=4)
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+        G.remove_edge(1, 6)
+        G.add_edge(3, 6, weight=4)
+        answer = matching_dict_to_set({1: 2, 2: 1, 3: 6, 4: 5, 5: 4, 6: 3})
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+    def test_nested_s_blossom(self):
+        """Create nested S-blossom, use for augmentation:"""
+
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [
+                (1, 2, 9),
+                (1, 3, 9),
+                (2, 3, 10),
+                (2, 4, 8),
+                (3, 5, 8),
+                (4, 5, 10),
+                (5, 6, 6),
+            ]
+        )
+        dict_format = {1: 3, 2: 4, 3: 1, 4: 2, 5: 6, 6: 5}
+        expected = {frozenset(e) for e in matching_dict_to_set(dict_format)}
+        answer = {frozenset(e) for e in nx.max_weight_matching(G)}
+        assert answer == expected
+        answer = {frozenset(e) for e in nx.min_weight_matching(G)}
+        assert answer == expected
+
+    def test_nested_s_blossom_relabel(self):
+        """Create S-blossom, relabel as S, include in nested S-blossom:"""
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [
+                (1, 2, 10),
+                (1, 7, 10),
+                (2, 3, 12),
+                (3, 4, 20),
+                (3, 5, 20),
+                (4, 5, 25),
+                (5, 6, 10),
+                (6, 7, 10),
+                (7, 8, 8),
+            ]
+        )
+        answer = matching_dict_to_set({1: 2, 2: 1, 3: 4, 4: 3, 5: 6, 6: 5, 7: 8, 8: 7})
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+    def test_nested_s_blossom_expand(self):
+        """Create nested S-blossom, augment, expand recursively:"""
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [
+                (1, 2, 8),
+                (1, 3, 8),
+                (2, 3, 10),
+                (2, 4, 12),
+                (3, 5, 12),
+                (4, 5, 14),
+                (4, 6, 12),
+                (5, 7, 12),
+                (6, 7, 14),
+                (7, 8, 12),
+            ]
+        )
+        answer = matching_dict_to_set({1: 2, 2: 1, 3: 5, 4: 6, 5: 3, 6: 4, 7: 8, 8: 7})
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+    def test_s_blossom_relabel_expand(self):
+        """Create S-blossom, relabel as T, expand:"""
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [
+                (1, 2, 23),
+                (1, 5, 22),
+                (1, 6, 15),
+                (2, 3, 25),
+                (3, 4, 22),
+                (4, 5, 25),
+                (4, 8, 14),
+                (5, 7, 13),
+            ]
+        )
+        answer = matching_dict_to_set({1: 6, 2: 3, 3: 2, 4: 8, 5: 7, 6: 1, 7: 5, 8: 4})
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+    def test_nested_s_blossom_relabel_expand(self):
+        """Create nested S-blossom, relabel as T, expand:"""
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [
+                (1, 2, 19),
+                (1, 3, 20),
+                (1, 8, 8),
+                (2, 3, 25),
+                (2, 4, 18),
+                (3, 5, 18),
+                (4, 5, 13),
+                (4, 7, 7),
+                (5, 6, 7),
+            ]
+        )
+        answer = matching_dict_to_set({1: 8, 2: 3, 3: 2, 4: 7, 5: 6, 6: 5, 7: 4, 8: 1})
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+    def test_nasty_blossom1(self):
+        """Create blossom, relabel as T in more than one way, expand,
+        augment:
+        """
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [
+                (1, 2, 45),
+                (1, 5, 45),
+                (2, 3, 50),
+                (3, 4, 45),
+                (4, 5, 50),
+                (1, 6, 30),
+                (3, 9, 35),
+                (4, 8, 35),
+                (5, 7, 26),
+                (9, 10, 5),
+            ]
+        )
+        ansdict = {1: 6, 2: 3, 3: 2, 4: 8, 5: 7, 6: 1, 7: 5, 8: 4, 9: 10, 10: 9}
+        answer = matching_dict_to_set(ansdict)
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+    def test_nasty_blossom2(self):
+        """Again but slightly different:"""
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [
+                (1, 2, 45),
+                (1, 5, 45),
+                (2, 3, 50),
+                (3, 4, 45),
+                (4, 5, 50),
+                (1, 6, 30),
+                (3, 9, 35),
+                (4, 8, 26),
+                (5, 7, 40),
+                (9, 10, 5),
+            ]
+        )
+        ans = {1: 6, 2: 3, 3: 2, 4: 8, 5: 7, 6: 1, 7: 5, 8: 4, 9: 10, 10: 9}
+        answer = matching_dict_to_set(ans)
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+    def test_nasty_blossom_least_slack(self):
+        """Create blossom, relabel as T, expand such that a new
+        least-slack S-to-free dge is produced, augment:
+        """
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [
+                (1, 2, 45),
+                (1, 5, 45),
+                (2, 3, 50),
+                (3, 4, 45),
+                (4, 5, 50),
+                (1, 6, 30),
+                (3, 9, 35),
+                (4, 8, 28),
+                (5, 7, 26),
+                (9, 10, 5),
+            ]
+        )
+        ans = {1: 6, 2: 3, 3: 2, 4: 8, 5: 7, 6: 1, 7: 5, 8: 4, 9: 10, 10: 9}
+        answer = matching_dict_to_set(ans)
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+    def test_nasty_blossom_augmenting(self):
+        """Create nested blossom, relabel as T in more than one way"""
+        # expand outer blossom such that inner blossom ends up on an
+        # augmenting path:
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [
+                (1, 2, 45),
+                (1, 7, 45),
+                (2, 3, 50),
+                (3, 4, 45),
+                (4, 5, 95),
+                (4, 6, 94),
+                (5, 6, 94),
+                (6, 7, 50),
+                (1, 8, 30),
+                (3, 11, 35),
+                (5, 9, 36),
+                (7, 10, 26),
+                (11, 12, 5),
+            ]
+        )
+        ans = {
+            1: 8,
+            2: 3,
+            3: 2,
+            4: 6,
+            5: 9,
+            6: 4,
+            7: 10,
+            8: 1,
+            9: 5,
+            10: 7,
+            11: 12,
+            12: 11,
+        }
+        answer = matching_dict_to_set(ans)
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+    def test_nasty_blossom_expand_recursively(self):
+        """Create nested S-blossom, relabel as S, expand recursively:"""
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [
+                (1, 2, 40),
+                (1, 3, 40),
+                (2, 3, 60),
+                (2, 4, 55),
+                (3, 5, 55),
+                (4, 5, 50),
+                (1, 8, 15),
+                (5, 7, 30),
+                (7, 6, 10),
+                (8, 10, 10),
+                (4, 9, 30),
+            ]
+        )
+        ans = {1: 2, 2: 1, 3: 5, 4: 9, 5: 3, 6: 7, 7: 6, 8: 10, 9: 4, 10: 8}
+        answer = matching_dict_to_set(ans)
+        assert edges_equal(nx.max_weight_matching(G), answer)
+        assert edges_equal(nx.min_weight_matching(G), answer)
+
+    def test_wrong_graph_type(self):
+        error = nx.NetworkXNotImplemented
+        raises(error, nx.max_weight_matching, nx.MultiGraph())
+        raises(error, nx.max_weight_matching, nx.MultiDiGraph())
+        raises(error, nx.max_weight_matching, nx.DiGraph())
+        raises(error, nx.min_weight_matching, nx.DiGraph())
+
+
+class TestIsMatching:
+    """Unit tests for the
+    :func:`~networkx.algorithms.matching.is_matching` function.
+
+    """
+
+    def test_dict(self):
+        G = nx.path_graph(4)
+        assert nx.is_matching(G, {0: 1, 1: 0, 2: 3, 3: 2})
+
+    def test_empty_matching(self):
+        G = nx.path_graph(4)
+        assert nx.is_matching(G, set())
+
+    def test_single_edge(self):
+        G = nx.path_graph(4)
+        assert nx.is_matching(G, {(1, 2)})
+
+    def test_edge_order(self):
+        G = nx.path_graph(4)
+        assert nx.is_matching(G, {(0, 1), (2, 3)})
+        assert nx.is_matching(G, {(1, 0), (2, 3)})
+        assert nx.is_matching(G, {(0, 1), (3, 2)})
+        assert nx.is_matching(G, {(1, 0), (3, 2)})
+
+    def test_valid_matching(self):
+        G = nx.path_graph(4)
+        assert nx.is_matching(G, {(0, 1), (2, 3)})
+
+    def test_invalid_input(self):
+        error = nx.NetworkXError
+        G = nx.path_graph(4)
+        # edge to node not in G
+        raises(error, nx.is_matching, G, {(0, 5), (2, 3)})
+        # edge not a 2-tuple
+        raises(error, nx.is_matching, G, {(0, 1, 2), (2, 3)})
+        raises(error, nx.is_matching, G, {(0,), (2, 3)})
+
+    def test_selfloops(self):
+        error = nx.NetworkXError
+        G = nx.path_graph(4)
+        # selfloop for node not in G
+        raises(error, nx.is_matching, G, {(5, 5), (2, 3)})
+        # selfloop edge not in G
+        assert not nx.is_matching(G, {(0, 0), (1, 2), (2, 3)})
+        # selfloop edge in G
+        G.add_edge(0, 0)
+        assert not nx.is_matching(G, {(0, 0), (1, 2), (2, 3)})
+
+    def test_invalid_matching(self):
+        G = nx.path_graph(4)
+        assert not nx.is_matching(G, {(0, 1), (1, 2), (2, 3)})
+
+    def test_invalid_edge(self):
+        G = nx.path_graph(4)
+        assert not nx.is_matching(G, {(0, 3), (1, 2)})
+        raises(nx.NetworkXError, nx.is_matching, G, {(0, 55)})
+
+        G = nx.DiGraph(G.edges)
+        assert nx.is_matching(G, {(0, 1)})
+        assert not nx.is_matching(G, {(1, 0)})
+
+
+class TestIsMaximalMatching:
+    """Unit tests for the
+    :func:`~networkx.algorithms.matching.is_maximal_matching` function.
+
+    """
+
+    def test_dict(self):
+        G = nx.path_graph(4)
+        assert nx.is_maximal_matching(G, {0: 1, 1: 0, 2: 3, 3: 2})
+
+    def test_valid(self):
+        G = nx.path_graph(4)
+        assert nx.is_maximal_matching(G, {(0, 1), (2, 3)})
+
+    def test_not_matching(self):
+        G = nx.path_graph(4)
+        assert not nx.is_maximal_matching(G, {(0, 1), (1, 2), (2, 3)})
+
+    def test_not_maximal(self):
+        G = nx.path_graph(4)
+        assert not nx.is_maximal_matching(G, {(0, 1)})
+
+
+class TestIsPerfectMatching:
+    """Unit tests for the
+    :func:`~networkx.algorithms.matching.is_perfect_matching` function.
+
+    """
+
+    def test_dict(self):
+        G = nx.path_graph(4)
+        assert nx.is_perfect_matching(G, {0: 1, 1: 0, 2: 3, 3: 2})
+
+    def test_valid(self):
+        G = nx.path_graph(4)
+        assert nx.is_perfect_matching(G, {(0, 1), (2, 3)})
+
+    def test_valid_not_path(self):
+        G = nx.cycle_graph(4)
+        G.add_edge(0, 4)
+        G.add_edge(1, 4)
+        G.add_edge(5, 2)
+
+        assert nx.is_perfect_matching(G, {(1, 4), (0, 3), (5, 2)})
+
+    def test_not_matching(self):
+        G = nx.path_graph(4)
+        assert not nx.is_perfect_matching(G, {(0, 1), (1, 2), (2, 3)})
+
+    def test_maximal_but_not_perfect(self):
+        G = nx.cycle_graph(4)
+        G.add_edge(0, 4)
+        G.add_edge(1, 4)
+
+        assert not nx.is_perfect_matching(G, {(1, 4), (0, 3)})
+
+
+class TestMaximalMatching:
+    """Unit tests for the
+    :func:`~networkx.algorithms.matching.maximal_matching`.
+
+    """
+
+    def test_valid_matching(self):
+        edges = [(1, 2), (1, 5), (2, 3), (2, 5), (3, 4), (3, 6), (5, 6)]
+        G = nx.Graph(edges)
+        matching = nx.maximal_matching(G)
+        assert nx.is_maximal_matching(G, matching)
+
+    def test_single_edge_matching(self):
+        # In the star graph, any maximal matching has just one edge.
+        G = nx.star_graph(5)
+        matching = nx.maximal_matching(G)
+        assert 1 == len(matching)
+        assert nx.is_maximal_matching(G, matching)
+
+    def test_self_loops(self):
+        # Create the path graph with two self-loops.
+        G = nx.path_graph(3)
+        G.add_edges_from([(0, 0), (1, 1)])
+        matching = nx.maximal_matching(G)
+        assert len(matching) == 1
+        # The matching should never include self-loops.
+        assert not any(u == v for u, v in matching)
+        assert nx.is_maximal_matching(G, matching)
+
+    def test_ordering(self):
+        """Tests that a maximal matching is computed correctly
+        regardless of the order in which nodes are added to the graph.
+
+        """
+        for nodes in permutations(range(3)):
+            G = nx.Graph()
+            G.add_nodes_from(nodes)
+            G.add_edges_from([(0, 1), (0, 2)])
+            matching = nx.maximal_matching(G)
+            assert len(matching) == 1
+            assert nx.is_maximal_matching(G, matching)
+
+    def test_wrong_graph_type(self):
+        error = nx.NetworkXNotImplemented
+        raises(error, nx.maximal_matching, nx.MultiGraph())
+        raises(error, nx.maximal_matching, nx.MultiDiGraph())
+        raises(error, nx.maximal_matching, nx.DiGraph())
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_max_weight_clique.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_max_weight_clique.py
new file mode 100644
index 0000000..cebe37f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_max_weight_clique.py
@@ -0,0 +1,181 @@
+"""Maximum weight clique test suite.
+
+"""
+
+import pytest
+
+import networkx as nx
+
+
+class TestMaximumWeightClique:
+    def test_basic_cases(self):
+        def check_basic_case(graph_func, expected_weight, weight_accessor):
+            graph = graph_func()
+            clique, weight = nx.algorithms.max_weight_clique(graph, weight_accessor)
+            assert verify_clique(
+                graph, clique, weight, expected_weight, weight_accessor
+            )
+
+        for graph_func, (expected_weight, expected_size) in TEST_CASES.items():
+            check_basic_case(graph_func, expected_weight, "weight")
+            check_basic_case(graph_func, expected_size, None)
+
+    def test_key_error(self):
+        graph = two_node_graph()
+        with pytest.raises(KeyError):
+            nx.algorithms.max_weight_clique(graph, "non-existent-key")
+
+    def test_error_on_non_integer_weight(self):
+        graph = two_node_graph()
+        graph.nodes[2]["weight"] = 1.5
+        with pytest.raises(ValueError):
+            nx.algorithms.max_weight_clique(graph)
+
+    def test_unaffected_by_self_loops(self):
+        graph = two_node_graph()
+        graph.add_edge(1, 1)
+        graph.add_edge(2, 2)
+        clique, weight = nx.algorithms.max_weight_clique(graph, "weight")
+        assert verify_clique(graph, clique, weight, 30, "weight")
+        graph = three_node_independent_set()
+        graph.add_edge(1, 1)
+        clique, weight = nx.algorithms.max_weight_clique(graph, "weight")
+        assert verify_clique(graph, clique, weight, 20, "weight")
+
+    def test_30_node_prob(self):
+        G = nx.Graph()
+        G.add_nodes_from(range(1, 31))
+        for i in range(1, 31):
+            G.nodes[i]["weight"] = i + 1
+        # fmt: off
+        G.add_edges_from(
+            [
+                (1, 12), (1, 13), (1, 15), (1, 16), (1, 18), (1, 19), (1, 20),
+                (1, 23), (1, 26), (1, 28), (1, 29), (1, 30), (2, 3), (2, 4),
+                (2, 5), (2, 8), (2, 9), (2, 10), (2, 14), (2, 17), (2, 18),
+                (2, 21), (2, 22), (2, 23), (2, 27), (3, 9), (3, 15), (3, 21),
+                (3, 22), (3, 23), (3, 24), (3, 27), (3, 28), (3, 29), (4, 5),
+                (4, 6), (4, 8), (4, 21), (4, 22), (4, 23), (4, 26), (4, 28),
+                (4, 30), (5, 6), (5, 8), (5, 9), (5, 13), (5, 14), (5, 15),
+                (5, 16), (5, 20), (5, 21), (5, 22), (5, 25), (5, 28), (5, 29),
+                (6, 7), (6, 8), (6, 13), (6, 17), (6, 18), (6, 19), (6, 24),
+                (6, 26), (6, 27), (6, 28), (6, 29), (7, 12), (7, 14), (7, 15),
+                (7, 16), (7, 17), (7, 20), (7, 25), (7, 27), (7, 29), (7, 30),
+                (8, 10), (8, 15), (8, 16), (8, 18), (8, 20), (8, 22), (8, 24),
+                (8, 26), (8, 27), (8, 28), (8, 30), (9, 11), (9, 12), (9, 13),
+                (9, 14), (9, 15), (9, 16), (9, 19), (9, 20), (9, 21), (9, 24),
+                (9, 30), (10, 12), (10, 15), (10, 18), (10, 19), (10, 20),
+                (10, 22), (10, 23), (10, 24), (10, 26), (10, 27), (10, 29),
+                (10, 30), (11, 13), (11, 15), (11, 16), (11, 17), (11, 18),
+                (11, 19), (11, 20), (11, 22), (11, 29), (11, 30), (12, 14),
+                (12, 17), (12, 18), (12, 19), (12, 20), (12, 21), (12, 23),
+                (12, 25), (12, 26), (12, 30), (13, 20), (13, 22), (13, 23),
+                (13, 24), (13, 30), (14, 16), (14, 20), (14, 21), (14, 22),
+                (14, 23), (14, 25), (14, 26), (14, 27), (14, 29), (14, 30),
+                (15, 17), (15, 18), (15, 20), (15, 21), (15, 26), (15, 27),
+                (15, 28), (16, 17), (16, 18), (16, 19), (16, 20), (16, 21),
+                (16, 29), (16, 30), (17, 18), (17, 21), (17, 22), (17, 25),
+                (17, 27), (17, 28), (17, 30), (18, 19), (18, 20), (18, 21),
+                (18, 22), (18, 23), (18, 24), (19, 20), (19, 22), (19, 23),
+                (19, 24), (19, 25), (19, 27), (19, 30), (20, 21), (20, 23),
+                (20, 24), (20, 26), (20, 28), (20, 29), (21, 23), (21, 26),
+                (21, 27), (21, 29), (22, 24), (22, 25), (22, 26), (22, 29),
+                (23, 25), (23, 30), (24, 25), (24, 26), (25, 27), (25, 29),
+                (26, 27), (26, 28), (26, 30), (28, 29), (29, 30),
+            ]
+        )
+        # fmt: on
+        clique, weight = nx.algorithms.max_weight_clique(G)
+        assert verify_clique(G, clique, weight, 111, "weight")
+
+
+#  ############################  Utility functions ############################
+def verify_clique(
+    graph, clique, reported_clique_weight, expected_clique_weight, weight_accessor
+):
+    for node1 in clique:
+        for node2 in clique:
+            if node1 == node2:
+                continue
+            if not graph.has_edge(node1, node2):
+                return False
+
+    if weight_accessor is None:
+        clique_weight = len(clique)
+    else:
+        clique_weight = sum(graph.nodes[v]["weight"] for v in clique)
+
+    if clique_weight != expected_clique_weight:
+        return False
+    if clique_weight != reported_clique_weight:
+        return False
+
+    return True
+
+
+#  ############################  Graph Generation ############################
+
+
+def empty_graph():
+    return nx.Graph()
+
+
+def one_node_graph():
+    graph = nx.Graph()
+    graph.add_nodes_from([1])
+    graph.nodes[1]["weight"] = 10
+    return graph
+
+
+def two_node_graph():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2])
+    graph.add_edges_from([(1, 2)])
+    graph.nodes[1]["weight"] = 10
+    graph.nodes[2]["weight"] = 20
+    return graph
+
+
+def three_node_clique():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3])
+    graph.add_edges_from([(1, 2), (1, 3), (2, 3)])
+    graph.nodes[1]["weight"] = 10
+    graph.nodes[2]["weight"] = 20
+    graph.nodes[3]["weight"] = 5
+    return graph
+
+
+def three_node_independent_set():
+    graph = nx.Graph()
+    graph.add_nodes_from([1, 2, 3])
+    graph.nodes[1]["weight"] = 10
+    graph.nodes[2]["weight"] = 20
+    graph.nodes[3]["weight"] = 5
+    return graph
+
+
+def disconnected():
+    graph = nx.Graph()
+    graph.add_edges_from([(1, 2), (2, 3), (4, 5), (5, 6)])
+    graph.nodes[1]["weight"] = 10
+    graph.nodes[2]["weight"] = 20
+    graph.nodes[3]["weight"] = 5
+    graph.nodes[4]["weight"] = 100
+    graph.nodes[5]["weight"] = 200
+    graph.nodes[6]["weight"] = 50
+    return graph
+
+
+# --------------------------------------------------------------------------
+# Basic tests for all strategies
+# For each basic graph function, specify expected weight of max weight clique
+# and expected size of maximum clique
+TEST_CASES = {
+    empty_graph: (0, 0),
+    one_node_graph: (10, 1),
+    two_node_graph: (30, 2),
+    three_node_clique: (35, 3),
+    three_node_independent_set: (20, 1),
+    disconnected: (300, 2),
+}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_mis.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_mis.py
new file mode 100644
index 0000000..c2f1eb1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_mis.py
@@ -0,0 +1,62 @@
+"""
+Tests for maximal (not maximum) independent sets.
+
+"""
+
+import random
+
+import pytest
+
+import networkx as nx
+
+
+def test_random_seed():
+    G = nx.empty_graph(5)
+    assert nx.maximal_independent_set(G, seed=1) == [1, 0, 3, 2, 4]
+
+
+@pytest.mark.parametrize("graph", [nx.complete_graph(5), nx.complete_graph(55)])
+def test_K5(graph):
+    """Maximal independent set for complete graphs"""
+    assert all(nx.maximal_independent_set(graph, [n]) == [n] for n in graph)
+
+
+def test_exceptions():
+    """Bad input should raise exception."""
+    G = nx.florentine_families_graph()
+    pytest.raises(nx.NetworkXUnfeasible, nx.maximal_independent_set, G, ["Smith"])
+    pytest.raises(
+        nx.NetworkXUnfeasible, nx.maximal_independent_set, G, ["Salviati", "Pazzi"]
+    )
+    # MaximalIndependantSet is not implemented for directed graphs
+    pytest.raises(nx.NetworkXNotImplemented, nx.maximal_independent_set, nx.DiGraph(G))
+
+
+def test_florentine_family():
+    G = nx.florentine_families_graph()
+    indep = nx.maximal_independent_set(G, ["Medici", "Bischeri"])
+    assert set(indep) == {
+        "Medici",
+        "Bischeri",
+        "Castellani",
+        "Pazzi",
+        "Ginori",
+        "Lamberteschi",
+    }
+
+
+def test_bipartite():
+    G = nx.complete_bipartite_graph(12, 34)
+    indep = nx.maximal_independent_set(G, [4, 5, 9, 10])
+    assert sorted(indep) == list(range(12))
+
+
+def test_random_graphs():
+    """Generate 5 random graphs of different types and sizes and
+    make sure that all sets are independent and maximal."""
+    for i in range(0, 50, 10):
+        G = nx.erdos_renyi_graph(i * 10 + 1, random.random())
+        IS = nx.maximal_independent_set(G)
+        assert G.subgraph(IS).number_of_edges() == 0
+        neighbors_of_MIS = set.union(*(set(G.neighbors(v)) for v in IS))
+        assert all(v in neighbors_of_MIS for v in set(G.nodes()).difference(IS))
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_moral.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_moral.py
new file mode 100644
index 0000000..fc98c97
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_moral.py
@@ -0,0 +1,15 @@
+import networkx as nx
+from networkx.algorithms.moral import moral_graph
+
+
+def test_get_moral_graph():
+    graph = nx.DiGraph()
+    graph.add_nodes_from([1, 2, 3, 4, 5, 6, 7])
+    graph.add_edges_from([(1, 2), (3, 2), (4, 1), (4, 5), (6, 5), (7, 5)])
+    H = moral_graph(graph)
+    assert not H.is_directed()
+    assert H.has_edge(1, 3)
+    assert H.has_edge(4, 6)
+    assert H.has_edge(6, 7)
+    assert H.has_edge(4, 7)
+    assert not H.has_edge(1, 5)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_node_classification.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_node_classification.py
new file mode 100644
index 0000000..ff99841
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_node_classification.py
@@ -0,0 +1,140 @@
+import pytest
+
+pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+from networkx.algorithms import node_classification
+
+
+class TestHarmonicFunction:
+    def test_path_graph(self):
+        G = nx.path_graph(4)
+        label_name = "label"
+        G.nodes[0][label_name] = "A"
+        G.nodes[3][label_name] = "B"
+        predicted = node_classification.harmonic_function(G, label_name=label_name)
+        assert predicted[0] == "A"
+        assert predicted[1] == "A"
+        assert predicted[2] == "B"
+        assert predicted[3] == "B"
+
+    def test_no_labels(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.path_graph(4)
+            node_classification.harmonic_function(G)
+
+    def test_no_nodes(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.Graph()
+            node_classification.harmonic_function(G)
+
+    def test_no_edges(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.Graph()
+            G.add_node(1)
+            G.add_node(2)
+            node_classification.harmonic_function(G)
+
+    def test_digraph(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            G = nx.DiGraph()
+            G.add_edge(0, 1)
+            G.add_edge(1, 2)
+            G.add_edge(2, 3)
+            label_name = "label"
+            G.nodes[0][label_name] = "A"
+            G.nodes[3][label_name] = "B"
+            node_classification.harmonic_function(G)
+
+    def test_one_labeled_node(self):
+        G = nx.path_graph(4)
+        label_name = "label"
+        G.nodes[0][label_name] = "A"
+        predicted = node_classification.harmonic_function(G, label_name=label_name)
+        assert predicted[0] == "A"
+        assert predicted[1] == "A"
+        assert predicted[2] == "A"
+        assert predicted[3] == "A"
+
+    def test_nodes_all_labeled(self):
+        G = nx.karate_club_graph()
+        label_name = "club"
+        predicted = node_classification.harmonic_function(G, label_name=label_name)
+        for i in range(len(G)):
+            assert predicted[i] == G.nodes[i][label_name]
+
+    def test_labeled_nodes_are_not_changed(self):
+        G = nx.karate_club_graph()
+        label_name = "club"
+        label_removed = {0, 1, 2, 3, 4, 5, 6, 7}
+        for i in label_removed:
+            del G.nodes[i][label_name]
+        predicted = node_classification.harmonic_function(G, label_name=label_name)
+        label_not_removed = set(list(range(len(G)))) - label_removed
+        for i in label_not_removed:
+            assert predicted[i] == G.nodes[i][label_name]
+
+
+class TestLocalAndGlobalConsistency:
+    def test_path_graph(self):
+        G = nx.path_graph(4)
+        label_name = "label"
+        G.nodes[0][label_name] = "A"
+        G.nodes[3][label_name] = "B"
+        predicted = node_classification.local_and_global_consistency(
+            G, label_name=label_name
+        )
+        assert predicted[0] == "A"
+        assert predicted[1] == "A"
+        assert predicted[2] == "B"
+        assert predicted[3] == "B"
+
+    def test_no_labels(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.path_graph(4)
+            node_classification.local_and_global_consistency(G)
+
+    def test_no_nodes(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.Graph()
+            node_classification.local_and_global_consistency(G)
+
+    def test_no_edges(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.Graph()
+            G.add_node(1)
+            G.add_node(2)
+            node_classification.local_and_global_consistency(G)
+
+    def test_digraph(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            G = nx.DiGraph()
+            G.add_edge(0, 1)
+            G.add_edge(1, 2)
+            G.add_edge(2, 3)
+            label_name = "label"
+            G.nodes[0][label_name] = "A"
+            G.nodes[3][label_name] = "B"
+            node_classification.harmonic_function(G)
+
+    def test_one_labeled_node(self):
+        G = nx.path_graph(4)
+        label_name = "label"
+        G.nodes[0][label_name] = "A"
+        predicted = node_classification.local_and_global_consistency(
+            G, label_name=label_name
+        )
+        assert predicted[0] == "A"
+        assert predicted[1] == "A"
+        assert predicted[2] == "A"
+        assert predicted[3] == "A"
+
+    def test_nodes_all_labeled(self):
+        G = nx.karate_club_graph()
+        label_name = "club"
+        predicted = node_classification.local_and_global_consistency(
+            G, alpha=0, label_name=label_name
+        )
+        for i in range(len(G)):
+            assert predicted[i] == G.nodes[i][label_name]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_node_classification_deprecations.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_node_classification_deprecations.py
new file mode 100644
index 0000000..2d12561
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_node_classification_deprecations.py
@@ -0,0 +1,41 @@
+"""TODO: Remove this test module for version 3.0."""
+
+
+import sys
+
+import pytest
+
+# NOTE: It is necessary to prevent previous imports in the test suite from
+# "contaminating" the tests for the deprecation warnings by removing
+# node_classification from sys.modules.
+
+
+def test_hmn_deprecation_warning():
+    sys.modules.pop("networkx.algorithms.node_classification", None)
+    with pytest.warns(DeprecationWarning):
+        from networkx.algorithms.node_classification import hmn
+
+
+def test_lgc_deprecation_warning():
+    sys.modules.pop("networkx.algorithms.node_classification", None)
+    with pytest.warns(DeprecationWarning):
+        from networkx.algorithms.node_classification import lgc
+
+
+def test_no_warn_on_function_import(recwarn):
+    # Accessing the functions shouldn't raise any warning
+    sys.modules.pop("networkx.algorithms.node_classification", None)
+    from networkx.algorithms.node_classification import (
+        harmonic_function,
+        local_and_global_consistency,
+    )
+
+    assert len(recwarn) == 0
+
+
+def test_no_warn_on_package_import(recwarn):
+    # Accessing the package shouldn't raise any warning
+    sys.modules.pop("networkx.algorithms.node_classification", None)
+    from networkx.algorithms import node_classification
+
+    assert len(recwarn) == 0
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_non_randomness.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_non_randomness.py
new file mode 100644
index 0000000..1f6de59
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_non_randomness.py
@@ -0,0 +1,37 @@
+import pytest
+
+import networkx as nx
+
+np = pytest.importorskip("numpy")
+
+
+@pytest.mark.parametrize(
+    "k, weight, expected",
+    [
+        (None, None, 7.21),  # infers 3 communities
+        (2, None, 11.7),
+        (None, "weight", 25.45),
+        (2, "weight", 38.8),
+    ],
+)
+def test_non_randomness(k, weight, expected):
+    G = nx.karate_club_graph()
+    np.testing.assert_almost_equal(
+        nx.non_randomness(G, k, weight)[0], expected, decimal=2
+    )
+
+
+def test_non_connected():
+    G = nx.Graph()
+    G.add_edge(1, 2)
+    G.add_node(3)
+    with pytest.raises(nx.NetworkXException):
+        nx.non_randomness(G)
+
+
+def test_self_loops():
+    G = nx.Graph()
+    G.add_edge(1, 2)
+    G.add_edge(1, 1)
+    with pytest.raises(nx.NetworkXError):
+        nx.non_randomness(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_planar_drawing.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_planar_drawing.py
new file mode 100644
index 0000000..2a12c06
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_planar_drawing.py
@@ -0,0 +1,274 @@
+import math
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.planar_drawing import triangulate_embedding
+
+
+def test_graph1():
+    embedding_data = {0: [1, 2, 3], 1: [2, 0], 2: [3, 0, 1], 3: [2, 0]}
+    check_embedding_data(embedding_data)
+
+
+def test_graph2():
+    embedding_data = {
+        0: [8, 6],
+        1: [2, 6, 9],
+        2: [8, 1, 7, 9, 6, 4],
+        3: [9],
+        4: [2],
+        5: [6, 8],
+        6: [9, 1, 0, 5, 2],
+        7: [9, 2],
+        8: [0, 2, 5],
+        9: [1, 6, 2, 7, 3],
+    }
+    check_embedding_data(embedding_data)
+
+
+def test_circle_graph():
+    embedding_data = {
+        0: [1, 9],
+        1: [0, 2],
+        2: [1, 3],
+        3: [2, 4],
+        4: [3, 5],
+        5: [4, 6],
+        6: [5, 7],
+        7: [6, 8],
+        8: [7, 9],
+        9: [8, 0],
+    }
+    check_embedding_data(embedding_data)
+
+
+def test_grid_graph():
+    embedding_data = {
+        (0, 1): [(0, 0), (1, 1), (0, 2)],
+        (1, 2): [(1, 1), (2, 2), (0, 2)],
+        (0, 0): [(0, 1), (1, 0)],
+        (2, 1): [(2, 0), (2, 2), (1, 1)],
+        (1, 1): [(2, 1), (1, 2), (0, 1), (1, 0)],
+        (2, 0): [(1, 0), (2, 1)],
+        (2, 2): [(1, 2), (2, 1)],
+        (1, 0): [(0, 0), (2, 0), (1, 1)],
+        (0, 2): [(1, 2), (0, 1)],
+    }
+    check_embedding_data(embedding_data)
+
+
+def test_one_node_graph():
+    embedding_data = {0: []}
+    check_embedding_data(embedding_data)
+
+
+def test_two_node_graph():
+    embedding_data = {0: [1], 1: [0]}
+    check_embedding_data(embedding_data)
+
+
+def test_three_node_graph():
+    embedding_data = {0: [1, 2], 1: [0, 2], 2: [0, 1]}
+    check_embedding_data(embedding_data)
+
+
+def test_multiple_component_graph1():
+    embedding_data = {0: [], 1: []}
+    check_embedding_data(embedding_data)
+
+
+def test_multiple_component_graph2():
+    embedding_data = {0: [1, 2], 1: [0, 2], 2: [0, 1], 3: [4, 5], 4: [3, 5], 5: [3, 4]}
+    check_embedding_data(embedding_data)
+
+
+def test_invalid_half_edge():
+    with pytest.raises(nx.NetworkXException):
+        embedding_data = {1: [2, 3, 4], 2: [1, 3, 4], 3: [1, 2, 4], 4: [1, 2, 3]}
+        embedding = nx.PlanarEmbedding()
+        embedding.set_data(embedding_data)
+        nx.combinatorial_embedding_to_pos(embedding)
+
+
+def test_triangulate_embedding1():
+    embedding = nx.PlanarEmbedding()
+    embedding.add_node(1)
+    expected_embedding = {1: []}
+    check_triangulation(embedding, expected_embedding)
+
+
+def test_triangulate_embedding2():
+    embedding = nx.PlanarEmbedding()
+    embedding.connect_components(1, 2)
+    expected_embedding = {1: [2], 2: [1]}
+    check_triangulation(embedding, expected_embedding)
+
+
+def check_triangulation(embedding, expected_embedding):
+    res_embedding, _ = triangulate_embedding(embedding, True)
+    assert (
+        res_embedding.get_data() == expected_embedding
+    ), "Expected embedding incorrect"
+    res_embedding, _ = triangulate_embedding(embedding, False)
+    assert (
+        res_embedding.get_data() == expected_embedding
+    ), "Expected embedding incorrect"
+
+
+def check_embedding_data(embedding_data):
+    """Checks that the planar embedding of the input is correct"""
+    embedding = nx.PlanarEmbedding()
+    embedding.set_data(embedding_data)
+    pos_fully = nx.combinatorial_embedding_to_pos(embedding, False)
+    msg = "Planar drawing does not conform to the embedding (fully " "triangulation)"
+    assert planar_drawing_conforms_to_embedding(embedding, pos_fully), msg
+    check_edge_intersections(embedding, pos_fully)
+    pos_internally = nx.combinatorial_embedding_to_pos(embedding, True)
+    msg = "Planar drawing does not conform to the embedding (internal " "triangulation)"
+    assert planar_drawing_conforms_to_embedding(embedding, pos_internally), msg
+    check_edge_intersections(embedding, pos_internally)
+
+
+def is_close(a, b, rel_tol=1e-09, abs_tol=0.0):
+    # Check if float numbers are basically equal, for python >=3.5 there is
+    # function for that in the standard library
+    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
+
+
+def point_in_between(a, b, p):
+    # checks if p is on the line between a and b
+    x1, y1 = a
+    x2, y2 = b
+    px, py = p
+    dist_1_2 = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
+    dist_1_p = math.sqrt((x1 - px) ** 2 + (y1 - py) ** 2)
+    dist_2_p = math.sqrt((x2 - px) ** 2 + (y2 - py) ** 2)
+    return is_close(dist_1_p + dist_2_p, dist_1_2)
+
+
+def check_edge_intersections(G, pos):
+    """Check all edges in G for intersections.
+
+    Raises an exception if an intersection is found.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+    pos : dict
+        Maps every node to a tuple (x, y) representing its position
+
+    """
+    for a, b in G.edges():
+        for c, d in G.edges():
+            # Check if end points are different
+            if a != c and b != d and b != c and a != d:
+                x1, y1 = pos[a]
+                x2, y2 = pos[b]
+                x3, y3 = pos[c]
+                x4, y4 = pos[d]
+                determinant = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)
+                if determinant != 0:  # the lines are not parallel
+                    # calculate intersection point, see:
+                    # https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
+                    px = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (
+                        x3 * y4 - y3 * x4
+                    ) / determinant
+                    py = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (
+                        x3 * y4 - y3 * x4
+                    ) / determinant
+
+                    # Check if intersection lies between the points
+                    if point_in_between(pos[a], pos[b], (px, py)) and point_in_between(
+                        pos[c], pos[d], (px, py)
+                    ):
+                        msg = f"There is an intersection at {px},{py}"
+                        raise nx.NetworkXException(msg)
+
+                #  Check overlap
+                msg = "A node lies on a edge connecting two other nodes"
+                if (
+                    point_in_between(pos[a], pos[b], pos[c])
+                    or point_in_between(pos[a], pos[b], pos[d])
+                    or point_in_between(pos[c], pos[d], pos[a])
+                    or point_in_between(pos[c], pos[d], pos[b])
+                ):
+                    raise nx.NetworkXException(msg)
+    # No edge intersection found
+
+
+class Vector:
+    """Compare vectors by their angle without loss of precision
+
+    All vectors in direction [0, 1] are the smallest.
+    The vectors grow in clockwise direction.
+    """
+
+    __slots__ = ["x", "y", "node", "quadrant"]
+
+    def __init__(self, x, y, node):
+        self.x = x
+        self.y = y
+        self.node = node
+        if self.x >= 0 and self.y > 0:
+            self.quadrant = 1
+        elif self.x > 0 and self.y <= 0:
+            self.quadrant = 2
+        elif self.x <= 0 and self.y < 0:
+            self.quadrant = 3
+        else:
+            self.quadrant = 4
+
+    def __eq__(self, other):
+        return self.quadrant == other.quadrant and self.x * other.y == self.y * other.x
+
+    def __lt__(self, other):
+        if self.quadrant < other.quadrant:
+            return True
+        elif self.quadrant > other.quadrant:
+            return False
+        else:
+            return self.x * other.y < self.y * other.x
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __le__(self, other):
+        return not other < self
+
+    def __gt__(self, other):
+        return other < self
+
+    def __ge__(self, other):
+        return not self < other
+
+
+def planar_drawing_conforms_to_embedding(embedding, pos):
+    """Checks if pos conforms to the planar embedding
+
+    Returns true iff the neighbors are actually oriented in the orientation
+    specified of the embedding
+    """
+    for v in embedding:
+        nbr_vectors = []
+        v_pos = pos[v]
+        for nbr in embedding[v]:
+            new_vector = Vector(pos[nbr][0] - v_pos[0], pos[nbr][1] - v_pos[1], nbr)
+            nbr_vectors.append(new_vector)
+        # Sort neighbors according to their phi angle
+        nbr_vectors.sort()
+        for idx, nbr_vector in enumerate(nbr_vectors):
+            cw_vector = nbr_vectors[(idx + 1) % len(nbr_vectors)]
+            ccw_vector = nbr_vectors[idx - 1]
+            if (
+                embedding[v][nbr_vector.node]["cw"] != cw_vector.node
+                or embedding[v][nbr_vector.node]["ccw"] != ccw_vector.node
+            ):
+                return False
+            if cw_vector.node != nbr_vector.node and cw_vector == nbr_vector:
+                # Lines overlap
+                return False
+            if ccw_vector.node != nbr_vector.node and ccw_vector == nbr_vector:
+                # Lines overlap
+                return False
+    return True
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_planarity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_planarity.py
new file mode 100644
index 0000000..675a5d9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_planarity.py
@@ -0,0 +1,442 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms.planarity import (
+    check_planarity_recursive,
+    get_counterexample,
+    get_counterexample_recursive,
+)
+
+
+class TestLRPlanarity:
+    """Nose Unit tests for the :mod:`networkx.algorithms.planarity` module.
+
+    Tests three things:
+    1. Check that the result is correct
+        (returns planar if and only if the graph is actually planar)
+    2. In case a counter example is returned: Check if it is correct
+    3. In case an embedding is returned: Check if its actually an embedding
+    """
+
+    @staticmethod
+    def check_graph(G, is_planar=None):
+        """Raises an exception if the lr_planarity check returns a wrong result
+
+        Parameters
+        ----------
+        G : NetworkX graph
+        is_planar : bool
+            The expected result of the planarity check.
+            If set to None only counter example or embedding are verified.
+
+        """
+
+        # obtain results of planarity check
+        is_planar_lr, result = nx.check_planarity(G, True)
+        is_planar_lr_rec, result_rec = check_planarity_recursive(G, True)
+
+        if is_planar is not None:
+            # set a message for the assert
+            if is_planar:
+                msg = "Wrong planarity check result. Should be planar."
+            else:
+                msg = "Wrong planarity check result. Should be non-planar."
+
+            # check if the result is as expected
+            assert is_planar == is_planar_lr, msg
+            assert is_planar == is_planar_lr_rec, msg
+
+        if is_planar_lr:
+            # check embedding
+            check_embedding(G, result)
+            check_embedding(G, result_rec)
+        else:
+            # check counter example
+            check_counterexample(G, result)
+            check_counterexample(G, result_rec)
+
+    def test_simple_planar_graph(self):
+        e = [
+            (1, 2),
+            (2, 3),
+            (3, 4),
+            (4, 6),
+            (6, 7),
+            (7, 1),
+            (1, 5),
+            (5, 2),
+            (2, 4),
+            (4, 5),
+            (5, 7),
+        ]
+        self.check_graph(nx.Graph(e), is_planar=True)
+
+    def test_planar_with_selfloop(self):
+        e = [
+            (1, 1),
+            (2, 2),
+            (3, 3),
+            (4, 4),
+            (5, 5),
+            (1, 2),
+            (1, 3),
+            (1, 5),
+            (2, 5),
+            (2, 4),
+            (3, 4),
+            (3, 5),
+            (4, 5),
+        ]
+        self.check_graph(nx.Graph(e), is_planar=True)
+
+    def test_k3_3(self):
+        self.check_graph(nx.complete_bipartite_graph(3, 3), is_planar=False)
+
+    def test_k5(self):
+        self.check_graph(nx.complete_graph(5), is_planar=False)
+
+    def test_multiple_components_planar(self):
+        e = [(1, 2), (2, 3), (3, 1), (4, 5), (5, 6), (6, 4)]
+        self.check_graph(nx.Graph(e), is_planar=True)
+
+    def test_multiple_components_non_planar(self):
+        G = nx.complete_graph(5)
+        # add another planar component to the non planar component
+        # G stays non planar
+        G.add_edges_from([(6, 7), (7, 8), (8, 6)])
+        self.check_graph(G, is_planar=False)
+
+    def test_non_planar_with_selfloop(self):
+        G = nx.complete_graph(5)
+        # add self loops
+        for i in range(5):
+            G.add_edge(i, i)
+        self.check_graph(G, is_planar=False)
+
+    def test_non_planar1(self):
+        # tests a graph that has no subgraph directly isomorph to K5 or K3_3
+        e = [
+            (1, 5),
+            (1, 6),
+            (1, 7),
+            (2, 6),
+            (2, 3),
+            (3, 5),
+            (3, 7),
+            (4, 5),
+            (4, 6),
+            (4, 7),
+        ]
+        self.check_graph(nx.Graph(e), is_planar=False)
+
+    def test_loop(self):
+        # test a graph with a selfloop
+        e = [(1, 2), (2, 2)]
+        G = nx.Graph(e)
+        self.check_graph(G, is_planar=True)
+
+    def test_comp(self):
+        # test multiple component graph
+        e = [(1, 2), (3, 4)]
+        G = nx.Graph(e)
+        G.remove_edge(1, 2)
+        self.check_graph(G, is_planar=True)
+
+    def test_goldner_harary(self):
+        # test goldner-harary graph (a maximal planar graph)
+        e = [
+            (1, 2),
+            (1, 3),
+            (1, 4),
+            (1, 5),
+            (1, 7),
+            (1, 8),
+            (1, 10),
+            (1, 11),
+            (2, 3),
+            (2, 4),
+            (2, 6),
+            (2, 7),
+            (2, 9),
+            (2, 10),
+            (2, 11),
+            (3, 4),
+            (4, 5),
+            (4, 6),
+            (4, 7),
+            (5, 7),
+            (6, 7),
+            (7, 8),
+            (7, 9),
+            (7, 10),
+            (8, 10),
+            (9, 10),
+            (10, 11),
+        ]
+        G = nx.Graph(e)
+        self.check_graph(G, is_planar=True)
+
+    def test_planar_multigraph(self):
+        G = nx.MultiGraph([(1, 2), (1, 2), (1, 2), (1, 2), (2, 3), (3, 1)])
+        self.check_graph(G, is_planar=True)
+
+    def test_non_planar_multigraph(self):
+        G = nx.MultiGraph(nx.complete_graph(5))
+        G.add_edges_from([(1, 2)] * 5)
+        self.check_graph(G, is_planar=False)
+
+    def test_planar_digraph(self):
+        G = nx.DiGraph([(1, 2), (2, 3), (2, 4), (4, 1), (4, 2), (1, 4), (3, 2)])
+        self.check_graph(G, is_planar=True)
+
+    def test_non_planar_digraph(self):
+        G = nx.DiGraph(nx.complete_graph(5))
+        G.remove_edge(1, 2)
+        G.remove_edge(4, 1)
+        self.check_graph(G, is_planar=False)
+
+    def test_single_component(self):
+        # Test a graph with only a single node
+        G = nx.Graph()
+        G.add_node(1)
+        self.check_graph(G, is_planar=True)
+
+    def test_graph1(self):
+        G = nx.OrderedGraph(
+            [
+                (3, 10),
+                (2, 13),
+                (1, 13),
+                (7, 11),
+                (0, 8),
+                (8, 13),
+                (0, 2),
+                (0, 7),
+                (0, 10),
+                (1, 7),
+            ]
+        )
+        self.check_graph(G, is_planar=True)
+
+    def test_graph2(self):
+        G = nx.OrderedGraph(
+            [
+                (1, 2),
+                (4, 13),
+                (0, 13),
+                (4, 5),
+                (7, 10),
+                (1, 7),
+                (0, 3),
+                (2, 6),
+                (5, 6),
+                (7, 13),
+                (4, 8),
+                (0, 8),
+                (0, 9),
+                (2, 13),
+                (6, 7),
+                (3, 6),
+                (2, 8),
+            ]
+        )
+        self.check_graph(G, is_planar=False)
+
+    def test_graph3(self):
+        G = nx.OrderedGraph(
+            [
+                (0, 7),
+                (3, 11),
+                (3, 4),
+                (8, 9),
+                (4, 11),
+                (1, 7),
+                (1, 13),
+                (1, 11),
+                (3, 5),
+                (5, 7),
+                (1, 3),
+                (0, 4),
+                (5, 11),
+                (5, 13),
+            ]
+        )
+        self.check_graph(G, is_planar=False)
+
+    def test_counterexample_planar(self):
+        with pytest.raises(nx.NetworkXException):
+            # Try to get a counterexample of a planar graph
+            G = nx.Graph()
+            G.add_node(1)
+            get_counterexample(G)
+
+    def test_counterexample_planar_recursive(self):
+        with pytest.raises(nx.NetworkXException):
+            # Try to get a counterexample of a planar graph
+            G = nx.Graph()
+            G.add_node(1)
+            get_counterexample_recursive(G)
+
+
+def check_embedding(G, embedding):
+    """Raises an exception if the combinatorial embedding is not correct
+
+    Parameters
+    ----------
+    G : NetworkX graph
+    embedding : a dict mapping nodes to a list of edges
+        This specifies the ordering of the outgoing edges from a node for
+        a combinatorial embedding
+
+    Notes
+    -----
+    Checks the following things:
+        - The type of the embedding is correct
+        - The nodes and edges match the original graph
+        - Every half edge has its matching opposite half edge
+        - No intersections of edges (checked by Euler's formula)
+    """
+
+    if not isinstance(embedding, nx.PlanarEmbedding):
+        raise nx.NetworkXException("Bad embedding. Not of type nx.PlanarEmbedding")
+
+    # Check structure
+    embedding.check_structure()
+
+    # Check that graphs are equivalent
+
+    assert set(G.nodes) == set(
+        embedding.nodes
+    ), "Bad embedding. Nodes don't match the original graph."
+
+    # Check that the edges are equal
+    g_edges = set()
+    for edge in G.edges:
+        if edge[0] != edge[1]:
+            g_edges.add((edge[0], edge[1]))
+            g_edges.add((edge[1], edge[0]))
+    assert g_edges == set(
+        embedding.edges
+    ), "Bad embedding. Edges don't match the original graph."
+
+
+def check_counterexample(G, sub_graph):
+    """Raises an exception if the counterexample is wrong.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+    subdivision_nodes : set
+        A set of nodes inducing a subgraph as a counterexample
+    """
+    # 1. Create the sub graph
+    sub_graph = nx.Graph(sub_graph)
+
+    # 2. Remove self loops
+    for u in sub_graph:
+        if sub_graph.has_edge(u, u):
+            sub_graph.remove_edge(u, u)
+
+    # keep track of nodes we might need to contract
+    contract = list(sub_graph)
+
+    # 3. Contract Edges
+    while len(contract) > 0:
+        contract_node = contract.pop()
+        if contract_node not in sub_graph:
+            # Node was already contracted
+            continue
+        degree = sub_graph.degree[contract_node]
+        # Check if we can remove the node
+        if degree == 2:
+            # Get the two neighbors
+            neighbors = iter(sub_graph[contract_node])
+            u = next(neighbors)
+            v = next(neighbors)
+            # Save nodes for later
+            contract.append(u)
+            contract.append(v)
+            # Contract edge
+            sub_graph.remove_node(contract_node)
+            sub_graph.add_edge(u, v)
+
+    # 4. Check for isomorphism with K5 or K3_3 graphs
+    if len(sub_graph) == 5:
+        if not nx.is_isomorphic(nx.complete_graph(5), sub_graph):
+            raise nx.NetworkXException("Bad counter example.")
+    elif len(sub_graph) == 6:
+        if not nx.is_isomorphic(nx.complete_bipartite_graph(3, 3), sub_graph):
+            raise nx.NetworkXException("Bad counter example.")
+    else:
+        raise nx.NetworkXException("Bad counter example.")
+
+
+class TestPlanarEmbeddingClass:
+    def test_get_data(self):
+        embedding = self.get_star_embedding(3)
+        data = embedding.get_data()
+        data_cmp = {0: [2, 1], 1: [0], 2: [0]}
+        assert data == data_cmp
+
+    def test_missing_edge_orientation(self):
+        with pytest.raises(nx.NetworkXException):
+            embedding = nx.PlanarEmbedding()
+            embedding.add_edge(1, 2)
+            embedding.add_edge(2, 1)
+            # Invalid structure because the orientation of the edge was not set
+            embedding.check_structure()
+
+    def test_invalid_edge_orientation(self):
+        with pytest.raises(nx.NetworkXException):
+            embedding = nx.PlanarEmbedding()
+            embedding.add_half_edge_first(1, 2)
+            embedding.add_half_edge_first(2, 1)
+            embedding.add_edge(1, 3)
+            embedding.check_structure()
+
+    def test_missing_half_edge(self):
+        with pytest.raises(nx.NetworkXException):
+            embedding = nx.PlanarEmbedding()
+            embedding.add_half_edge_first(1, 2)
+            # Invalid structure because other half edge is missing
+            embedding.check_structure()
+
+    def test_not_fulfilling_euler_formula(self):
+        with pytest.raises(nx.NetworkXException):
+            embedding = nx.PlanarEmbedding()
+            for i in range(5):
+                for j in range(5):
+                    if i != j:
+                        embedding.add_half_edge_first(i, j)
+            embedding.check_structure()
+
+    def test_missing_reference(self):
+        with pytest.raises(nx.NetworkXException):
+            embedding = nx.PlanarEmbedding()
+            embedding.add_half_edge_cw(1, 2, 3)
+
+    def test_connect_components(self):
+        embedding = nx.PlanarEmbedding()
+        embedding.connect_components(1, 2)
+
+    def test_successful_face_traversal(self):
+        embedding = nx.PlanarEmbedding()
+        embedding.add_half_edge_first(1, 2)
+        embedding.add_half_edge_first(2, 1)
+        face = embedding.traverse_face(1, 2)
+        assert face == [1, 2]
+
+    def test_unsuccessful_face_traversal(self):
+        with pytest.raises(nx.NetworkXException):
+            embedding = nx.PlanarEmbedding()
+            embedding.add_edge(1, 2, ccw=2, cw=3)
+            embedding.add_edge(2, 1, ccw=1, cw=3)
+            embedding.traverse_face(1, 2)
+
+    @staticmethod
+    def get_star_embedding(n):
+        embedding = nx.PlanarEmbedding()
+        for i in range(1, n):
+            embedding.add_half_edge_first(0, i)
+            embedding.add_half_edge_first(i, 0)
+        return embedding
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_polynomials.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_polynomials.py
new file mode 100644
index 0000000..a81d6a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_polynomials.py
@@ -0,0 +1,57 @@
+"""Unit tests for the :mod:`networkx.algorithms.polynomials` module."""
+
+import pytest
+
+import networkx as nx
+
+sympy = pytest.importorskip("sympy")
+
+
+# Mapping of input graphs to a string representation of their tutte polynomials
+_test_tutte_graphs = {
+    nx.complete_graph(1): "1",
+    nx.complete_graph(4): "x**3 + 3*x**2 + 4*x*y + 2*x + y**3 + 3*y**2 + 2*y",
+    nx.cycle_graph(5): "x**4 + x**3 + x**2 + x + y",
+    nx.diamond_graph(): "x**3 + 2*x**2 + 2*x*y + x + y**2 + y",
+}
+
+_test_chromatic_graphs = {
+    nx.complete_graph(1): "x",
+    nx.complete_graph(4): "x**4 - 6*x**3 + 11*x**2 - 6*x",
+    nx.cycle_graph(5): "x**5 - 5*x**4 + 10*x**3 - 10*x**2 + 4*x",
+    nx.diamond_graph(): "x**4 - 5*x**3 + 8*x**2 - 4*x",
+    nx.path_graph(5): "x**5 - 4*x**4 + 6*x**3 - 4*x**2 + x",
+}
+
+
+@pytest.mark.parametrize(("G", "expected"), _test_tutte_graphs.items())
+def test_tutte_polynomial(G, expected):
+    assert nx.tutte_polynomial(G).equals(expected)
+
+
+@pytest.mark.parametrize("G", _test_tutte_graphs.keys())
+def test_tutte_polynomial_disjoint(G):
+    """Tutte polynomial factors into the Tutte polynomials of its components.
+    Verify this property with the disjoint union of two copies of the input graph.
+    """
+    t_g = nx.tutte_polynomial(G)
+    H = nx.disjoint_union(G, G)
+    t_h = nx.tutte_polynomial(H)
+    assert sympy.simplify(t_g * t_g).equals(t_h)
+
+
+@pytest.mark.parametrize(("G", "expected"), _test_chromatic_graphs.items())
+def test_chromatic_polynomial(G, expected):
+    assert nx.chromatic_polynomial(G).equals(expected)
+
+
+@pytest.mark.parametrize("G", _test_chromatic_graphs.keys())
+def test_chromatic_polynomial_disjoint(G):
+    """Chromatic polynomial factors into the Chromatic polynomials of its
+    components. Verify this property with the disjoint union of two copies of
+    the input graph.
+    """
+    x_g = nx.chromatic_polynomial(G)
+    H = nx.disjoint_union(G, G)
+    x_h = nx.chromatic_polynomial(H)
+    assert sympy.simplify(x_g * x_g).equals(x_h)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_reciprocity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_reciprocity.py
new file mode 100644
index 0000000..2c5fc04
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_reciprocity.py
@@ -0,0 +1,38 @@
+import pytest
+
+import networkx as nx
+
+
+class TestReciprocity:
+
+    # test overall reicprocity by passing whole graph
+    def test_reciprocity_digraph(self):
+        DG = nx.DiGraph([(1, 2), (2, 1)])
+        reciprocity = nx.reciprocity(DG)
+        assert reciprocity == 1.0
+
+    # test empty graph's overall reciprocity which will throw an error
+    def test_overall_reciprocity_empty_graph(self):
+        with pytest.raises(nx.NetworkXError):
+            DG = nx.DiGraph()
+            nx.overall_reciprocity(DG)
+
+    # test for reciprocity for a list of nodes
+    def test_reciprocity_graph_nodes(self):
+        DG = nx.DiGraph([(1, 2), (2, 3), (3, 2)])
+        reciprocity = nx.reciprocity(DG, [1, 2])
+        expected_reciprocity = {1: 0.0, 2: 0.6666666666666666}
+        assert reciprocity == expected_reciprocity
+
+    # test for reciprocity for a single node
+    def test_reciprocity_graph_node(self):
+        DG = nx.DiGraph([(1, 2), (2, 3), (3, 2)])
+        reciprocity = nx.reciprocity(DG, 2)
+        assert reciprocity == 0.6666666666666666
+
+    # test for reciprocity for an isolated node
+    def test_reciprocity_graph_isolated_nodes(self):
+        with pytest.raises(nx.NetworkXError):
+            DG = nx.DiGraph([(1, 2)])
+            DG.add_node(4)
+            nx.reciprocity(DG, 4)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_regular.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_regular.py
new file mode 100644
index 0000000..0c8e4e4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_regular.py
@@ -0,0 +1,86 @@
+import pytest
+
+import networkx
+import networkx as nx
+import networkx.algorithms.regular as reg
+import networkx.generators as gen
+
+
+class TestKFactor:
+    def test_k_factor_trivial(self):
+        g = gen.cycle_graph(4)
+        f = reg.k_factor(g, 2)
+        assert g.edges == f.edges
+
+    def test_k_factor1(self):
+        g = gen.grid_2d_graph(4, 4)
+        g_kf = reg.k_factor(g, 2)
+        for edge in g_kf.edges():
+            assert g.has_edge(edge[0], edge[1])
+        for _, degree in g_kf.degree():
+            assert degree == 2
+
+    def test_k_factor2(self):
+        g = gen.complete_graph(6)
+        g_kf = reg.k_factor(g, 3)
+        for edge in g_kf.edges():
+            assert g.has_edge(edge[0], edge[1])
+        for _, degree in g_kf.degree():
+            assert degree == 3
+
+    def test_k_factor3(self):
+        g = gen.grid_2d_graph(4, 4)
+        with pytest.raises(nx.NetworkXUnfeasible):
+            reg.k_factor(g, 3)
+
+    def test_k_factor4(self):
+        g = gen.lattice.hexagonal_lattice_graph(4, 4)
+        # Perfect matching doesn't exist for 4,4 hexagonal lattice graph
+        with pytest.raises(nx.NetworkXUnfeasible):
+            reg.k_factor(g, 2)
+
+    def test_k_factor5(self):
+        g = gen.complete_graph(6)
+        # small k to exercise SmallKGadget
+        g_kf = reg.k_factor(g, 2)
+        for edge in g_kf.edges():
+            assert g.has_edge(edge[0], edge[1])
+        for _, degree in g_kf.degree():
+            assert degree == 2
+
+
+class TestIsRegular:
+    def test_is_regular1(self):
+        g = gen.cycle_graph(4)
+        assert reg.is_regular(g)
+
+    def test_is_regular2(self):
+        g = gen.complete_graph(5)
+        assert reg.is_regular(g)
+
+    def test_is_regular3(self):
+        g = gen.lollipop_graph(5, 5)
+        assert not reg.is_regular(g)
+
+    def test_is_regular4(self):
+        g = nx.DiGraph()
+        g.add_edges_from([(0, 1), (1, 2), (2, 0)])
+        assert reg.is_regular(g)
+
+
+class TestIsKRegular:
+    def test_is_k_regular1(self):
+        g = gen.cycle_graph(4)
+        assert reg.is_k_regular(g, 2)
+        assert not reg.is_k_regular(g, 3)
+
+    def test_is_k_regular2(self):
+        g = gen.complete_graph(5)
+        assert reg.is_k_regular(g, 4)
+        assert not reg.is_k_regular(g, 3)
+        assert not reg.is_k_regular(g, 6)
+
+    def test_is_k_regular3(self):
+        g = gen.lollipop_graph(5, 5)
+        assert not reg.is_k_regular(g, 5)
+        assert not reg.is_k_regular(g, 6)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_richclub.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_richclub.py
new file mode 100644
index 0000000..1ed42d4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_richclub.py
@@ -0,0 +1,86 @@
+import pytest
+
+import networkx as nx
+
+
+def test_richclub():
+    G = nx.Graph([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (4, 5)])
+    rc = nx.richclub.rich_club_coefficient(G, normalized=False)
+    assert rc == {0: 12.0 / 30, 1: 8.0 / 12}
+
+    # test single value
+    rc0 = nx.richclub.rich_club_coefficient(G, normalized=False)[0]
+    assert rc0 == 12.0 / 30.0
+
+
+def test_richclub_seed():
+    G = nx.Graph([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (4, 5)])
+    rcNorm = nx.richclub.rich_club_coefficient(G, Q=2, seed=1)
+    assert rcNorm == {0: 1.0, 1: 1.0}
+
+
+def test_richclub_normalized():
+    G = nx.Graph([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (4, 5)])
+    rcNorm = nx.richclub.rich_club_coefficient(G, Q=2)
+    assert rcNorm == {0: 1.0, 1: 1.0}
+
+
+def test_richclub2():
+    T = nx.balanced_tree(2, 10)
+    rc = nx.richclub.rich_club_coefficient(T, normalized=False)
+    assert rc == {
+        0: 4092 / (2047 * 2046.0),
+        1: (2044.0 / (1023 * 1022)),
+        2: (2040.0 / (1022 * 1021)),
+    }
+
+
+def test_richclub3():
+    # tests edgecase
+    G = nx.karate_club_graph()
+    rc = nx.rich_club_coefficient(G, normalized=False)
+    assert rc == {
+        0: 156.0 / 1122,
+        1: 154.0 / 1056,
+        2: 110.0 / 462,
+        3: 78.0 / 240,
+        4: 44.0 / 90,
+        5: 22.0 / 42,
+        6: 10.0 / 20,
+        7: 10.0 / 20,
+        8: 10.0 / 20,
+        9: 6.0 / 12,
+        10: 2.0 / 6,
+        11: 2.0 / 6,
+        12: 0.0,
+        13: 0.0,
+        14: 0.0,
+        15: 0.0,
+    }
+
+
+def test_richclub4():
+    G = nx.Graph()
+    G.add_edges_from(
+        [(0, 1), (0, 2), (0, 3), (0, 4), (4, 5), (5, 9), (6, 9), (7, 9), (8, 9)]
+    )
+    rc = nx.rich_club_coefficient(G, normalized=False)
+    assert rc == {0: 18 / 90.0, 1: 6 / 12.0, 2: 0.0, 3: 0.0}
+
+
+def test_richclub_exception():
+    with pytest.raises(nx.NetworkXNotImplemented):
+        G = nx.DiGraph()
+        nx.rich_club_coefficient(G)
+
+
+def test_rich_club_exception2():
+    with pytest.raises(nx.NetworkXNotImplemented):
+        G = nx.MultiGraph()
+        nx.rich_club_coefficient(G)
+
+
+# def test_richclub2_normalized():
+#    T = nx.balanced_tree(2,10)
+#    rcNorm = nx.richclub.rich_club_coefficient(T,Q=2)
+#    assert_true(rcNorm[0] ==1.0 and rcNorm[1] < 0.9 and rcNorm[2] < 0.9)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_similarity.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_similarity.py
new file mode 100644
index 0000000..9b620de
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_similarity.py
@@ -0,0 +1,920 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms.similarity import (
+    graph_edit_distance,
+    optimal_edit_paths,
+    optimize_graph_edit_distance,
+)
+from networkx.generators.classic import (
+    circular_ladder_graph,
+    cycle_graph,
+    path_graph,
+    wheel_graph,
+)
+
+
+def nmatch(n1, n2):
+    return n1 == n2
+
+
+def ematch(e1, e2):
+    return e1 == e2
+
+
+def getCanonical():
+    G = nx.Graph()
+    G.add_node("A", label="A")
+    G.add_node("B", label="B")
+    G.add_node("C", label="C")
+    G.add_node("D", label="D")
+    G.add_edge("A", "B", label="a-b")
+    G.add_edge("B", "C", label="b-c")
+    G.add_edge("B", "D", label="b-d")
+    return G
+
+
+class TestSimilarity:
+    @classmethod
+    def setup_class(cls):
+        global np
+        np = pytest.importorskip("numpy")
+        pytest.importorskip("scipy")
+
+    def test_graph_edit_distance_roots_and_timeout(self):
+        G0 = nx.star_graph(5)
+        G1 = G0.copy()
+        pytest.raises(ValueError, graph_edit_distance, G0, G1, roots=[2])
+        pytest.raises(ValueError, graph_edit_distance, G0, G1, roots=[2, 3, 4])
+        pytest.raises(nx.NodeNotFound, graph_edit_distance, G0, G1, roots=(9, 3))
+        pytest.raises(nx.NodeNotFound, graph_edit_distance, G0, G1, roots=(3, 9))
+        pytest.raises(nx.NodeNotFound, graph_edit_distance, G0, G1, roots=(9, 9))
+        assert graph_edit_distance(G0, G1, roots=(1, 2)) == 0
+        assert graph_edit_distance(G0, G1, roots=(0, 1)) == 8
+        assert graph_edit_distance(G0, G1, roots=(1, 2), timeout=5) == 0
+        assert graph_edit_distance(G0, G1, roots=(0, 1), timeout=5) == 8
+        assert graph_edit_distance(G0, G1, roots=(0, 1), timeout=0.0001) is None
+        # test raise on 0 timeout
+        pytest.raises(nx.NetworkXError, graph_edit_distance, G0, G1, timeout=0)
+
+    def test_graph_edit_distance(self):
+        G0 = nx.Graph()
+        G1 = path_graph(6)
+        G2 = cycle_graph(6)
+        G3 = wheel_graph(7)
+
+        assert graph_edit_distance(G0, G0) == 0
+        assert graph_edit_distance(G0, G1) == 11
+        assert graph_edit_distance(G1, G0) == 11
+        assert graph_edit_distance(G0, G2) == 12
+        assert graph_edit_distance(G2, G0) == 12
+        assert graph_edit_distance(G0, G3) == 19
+        assert graph_edit_distance(G3, G0) == 19
+
+        assert graph_edit_distance(G1, G1) == 0
+        assert graph_edit_distance(G1, G2) == 1
+        assert graph_edit_distance(G2, G1) == 1
+        assert graph_edit_distance(G1, G3) == 8
+        assert graph_edit_distance(G3, G1) == 8
+
+        assert graph_edit_distance(G2, G2) == 0
+        assert graph_edit_distance(G2, G3) == 7
+        assert graph_edit_distance(G3, G2) == 7
+
+        assert graph_edit_distance(G3, G3) == 0
+
+    def test_graph_edit_distance_node_match(self):
+        G1 = cycle_graph(5)
+        G2 = cycle_graph(5)
+        for n, attr in G1.nodes.items():
+            attr["color"] = "red" if n % 2 == 0 else "blue"
+        for n, attr in G2.nodes.items():
+            attr["color"] = "red" if n % 2 == 1 else "blue"
+        assert graph_edit_distance(G1, G2) == 0
+        assert (
+            graph_edit_distance(
+                G1, G2, node_match=lambda n1, n2: n1["color"] == n2["color"]
+            )
+            == 1
+        )
+
+    def test_graph_edit_distance_edge_match(self):
+        G1 = path_graph(6)
+        G2 = path_graph(6)
+        for e, attr in G1.edges.items():
+            attr["color"] = "red" if min(e) % 2 == 0 else "blue"
+        for e, attr in G2.edges.items():
+            attr["color"] = "red" if min(e) // 3 == 0 else "blue"
+        assert graph_edit_distance(G1, G2) == 0
+        assert (
+            graph_edit_distance(
+                G1, G2, edge_match=lambda e1, e2: e1["color"] == e2["color"]
+            )
+            == 2
+        )
+
+    def test_graph_edit_distance_node_cost(self):
+        G1 = path_graph(6)
+        G2 = path_graph(6)
+        for n, attr in G1.nodes.items():
+            attr["color"] = "red" if n % 2 == 0 else "blue"
+        for n, attr in G2.nodes.items():
+            attr["color"] = "red" if n % 2 == 1 else "blue"
+
+        def node_subst_cost(uattr, vattr):
+            if uattr["color"] == vattr["color"]:
+                return 1
+            else:
+                return 10
+
+        def node_del_cost(attr):
+            if attr["color"] == "blue":
+                return 20
+            else:
+                return 50
+
+        def node_ins_cost(attr):
+            if attr["color"] == "blue":
+                return 40
+            else:
+                return 100
+
+        assert (
+            graph_edit_distance(
+                G1,
+                G2,
+                node_subst_cost=node_subst_cost,
+                node_del_cost=node_del_cost,
+                node_ins_cost=node_ins_cost,
+            )
+            == 6
+        )
+
+    def test_graph_edit_distance_edge_cost(self):
+        G1 = path_graph(6)
+        G2 = path_graph(6)
+        for e, attr in G1.edges.items():
+            attr["color"] = "red" if min(e) % 2 == 0 else "blue"
+        for e, attr in G2.edges.items():
+            attr["color"] = "red" if min(e) // 3 == 0 else "blue"
+
+        def edge_subst_cost(gattr, hattr):
+            if gattr["color"] == hattr["color"]:
+                return 0.01
+            else:
+                return 0.1
+
+        def edge_del_cost(attr):
+            if attr["color"] == "blue":
+                return 0.2
+            else:
+                return 0.5
+
+        def edge_ins_cost(attr):
+            if attr["color"] == "blue":
+                return 0.4
+            else:
+                return 1.0
+
+        assert (
+            graph_edit_distance(
+                G1,
+                G2,
+                edge_subst_cost=edge_subst_cost,
+                edge_del_cost=edge_del_cost,
+                edge_ins_cost=edge_ins_cost,
+            )
+            == 0.23
+        )
+
+    def test_graph_edit_distance_upper_bound(self):
+        G1 = circular_ladder_graph(2)
+        G2 = circular_ladder_graph(6)
+        assert graph_edit_distance(G1, G2, upper_bound=5) is None
+        assert graph_edit_distance(G1, G2, upper_bound=24) == 22
+        assert graph_edit_distance(G1, G2) == 22
+
+    def test_optimal_edit_paths(self):
+        G1 = path_graph(3)
+        G2 = cycle_graph(3)
+        paths, cost = optimal_edit_paths(G1, G2)
+        assert cost == 1
+        assert len(paths) == 6
+
+        def canonical(vertex_path, edge_path):
+            return (
+                tuple(sorted(vertex_path)),
+                tuple(sorted(edge_path, key=lambda x: (None in x, x))),
+            )
+
+        expected_paths = [
+            (
+                [(0, 0), (1, 1), (2, 2)],
+                [((0, 1), (0, 1)), ((1, 2), (1, 2)), (None, (0, 2))],
+            ),
+            (
+                [(0, 0), (1, 2), (2, 1)],
+                [((0, 1), (0, 2)), ((1, 2), (1, 2)), (None, (0, 1))],
+            ),
+            (
+                [(0, 1), (1, 0), (2, 2)],
+                [((0, 1), (0, 1)), ((1, 2), (0, 2)), (None, (1, 2))],
+            ),
+            (
+                [(0, 1), (1, 2), (2, 0)],
+                [((0, 1), (1, 2)), ((1, 2), (0, 2)), (None, (0, 1))],
+            ),
+            (
+                [(0, 2), (1, 0), (2, 1)],
+                [((0, 1), (0, 2)), ((1, 2), (0, 1)), (None, (1, 2))],
+            ),
+            (
+                [(0, 2), (1, 1), (2, 0)],
+                [((0, 1), (1, 2)), ((1, 2), (0, 1)), (None, (0, 2))],
+            ),
+        ]
+        assert {canonical(*p) for p in paths} == {canonical(*p) for p in expected_paths}
+
+    def test_optimize_graph_edit_distance(self):
+        G1 = circular_ladder_graph(2)
+        G2 = circular_ladder_graph(6)
+        bestcost = 1000
+        for cost in optimize_graph_edit_distance(G1, G2):
+            assert cost < bestcost
+            bestcost = cost
+        assert bestcost == 22
+
+    # def test_graph_edit_distance_bigger(self):
+    #     G1 = circular_ladder_graph(12)
+    #     G2 = circular_ladder_graph(16)
+    #     assert_equal(graph_edit_distance(G1, G2), 22)
+
+    def test_selfloops(self):
+        G0 = nx.Graph()
+        G1 = nx.Graph()
+        G1.add_edges_from((("A", "A"), ("A", "B")))
+        G2 = nx.Graph()
+        G2.add_edges_from((("A", "B"), ("B", "B")))
+        G3 = nx.Graph()
+        G3.add_edges_from((("A", "A"), ("A", "B"), ("B", "B")))
+
+        assert graph_edit_distance(G0, G0) == 0
+        assert graph_edit_distance(G0, G1) == 4
+        assert graph_edit_distance(G1, G0) == 4
+        assert graph_edit_distance(G0, G2) == 4
+        assert graph_edit_distance(G2, G0) == 4
+        assert graph_edit_distance(G0, G3) == 5
+        assert graph_edit_distance(G3, G0) == 5
+
+        assert graph_edit_distance(G1, G1) == 0
+        assert graph_edit_distance(G1, G2) == 0
+        assert graph_edit_distance(G2, G1) == 0
+        assert graph_edit_distance(G1, G3) == 1
+        assert graph_edit_distance(G3, G1) == 1
+
+        assert graph_edit_distance(G2, G2) == 0
+        assert graph_edit_distance(G2, G3) == 1
+        assert graph_edit_distance(G3, G2) == 1
+
+        assert graph_edit_distance(G3, G3) == 0
+
+    def test_digraph(self):
+        G0 = nx.DiGraph()
+        G1 = nx.DiGraph()
+        G1.add_edges_from((("A", "B"), ("B", "C"), ("C", "D"), ("D", "A")))
+        G2 = nx.DiGraph()
+        G2.add_edges_from((("A", "B"), ("B", "C"), ("C", "D"), ("A", "D")))
+        G3 = nx.DiGraph()
+        G3.add_edges_from((("A", "B"), ("A", "C"), ("B", "D"), ("C", "D")))
+
+        assert graph_edit_distance(G0, G0) == 0
+        assert graph_edit_distance(G0, G1) == 8
+        assert graph_edit_distance(G1, G0) == 8
+        assert graph_edit_distance(G0, G2) == 8
+        assert graph_edit_distance(G2, G0) == 8
+        assert graph_edit_distance(G0, G3) == 8
+        assert graph_edit_distance(G3, G0) == 8
+
+        assert graph_edit_distance(G1, G1) == 0
+        assert graph_edit_distance(G1, G2) == 2
+        assert graph_edit_distance(G2, G1) == 2
+        assert graph_edit_distance(G1, G3) == 4
+        assert graph_edit_distance(G3, G1) == 4
+
+        assert graph_edit_distance(G2, G2) == 0
+        assert graph_edit_distance(G2, G3) == 2
+        assert graph_edit_distance(G3, G2) == 2
+
+        assert graph_edit_distance(G3, G3) == 0
+
+    def test_multigraph(self):
+        G0 = nx.MultiGraph()
+        G1 = nx.MultiGraph()
+        G1.add_edges_from((("A", "B"), ("B", "C"), ("A", "C")))
+        G2 = nx.MultiGraph()
+        G2.add_edges_from((("A", "B"), ("B", "C"), ("B", "C"), ("A", "C")))
+        G3 = nx.MultiGraph()
+        G3.add_edges_from((("A", "B"), ("B", "C"), ("A", "C"), ("A", "C"), ("A", "C")))
+
+        assert graph_edit_distance(G0, G0) == 0
+        assert graph_edit_distance(G0, G1) == 6
+        assert graph_edit_distance(G1, G0) == 6
+        assert graph_edit_distance(G0, G2) == 7
+        assert graph_edit_distance(G2, G0) == 7
+        assert graph_edit_distance(G0, G3) == 8
+        assert graph_edit_distance(G3, G0) == 8
+
+        assert graph_edit_distance(G1, G1) == 0
+        assert graph_edit_distance(G1, G2) == 1
+        assert graph_edit_distance(G2, G1) == 1
+        assert graph_edit_distance(G1, G3) == 2
+        assert graph_edit_distance(G3, G1) == 2
+
+        assert graph_edit_distance(G2, G2) == 0
+        assert graph_edit_distance(G2, G3) == 1
+        assert graph_edit_distance(G3, G2) == 1
+
+        assert graph_edit_distance(G3, G3) == 0
+
+    def test_multidigraph(self):
+        G1 = nx.MultiDiGraph()
+        G1.add_edges_from(
+            (
+                ("hardware", "kernel"),
+                ("kernel", "hardware"),
+                ("kernel", "userspace"),
+                ("userspace", "kernel"),
+            )
+        )
+        G2 = nx.MultiDiGraph()
+        G2.add_edges_from(
+            (
+                ("winter", "spring"),
+                ("spring", "summer"),
+                ("summer", "autumn"),
+                ("autumn", "winter"),
+            )
+        )
+
+        assert graph_edit_distance(G1, G2) == 5
+        assert graph_edit_distance(G2, G1) == 5
+
+    # by https://github.com/jfbeaumont
+    def testCopy(self):
+        G = nx.Graph()
+        G.add_node("A", label="A")
+        G.add_node("B", label="B")
+        G.add_edge("A", "B", label="a-b")
+        assert (
+            graph_edit_distance(G, G.copy(), node_match=nmatch, edge_match=ematch) == 0
+        )
+
+    def testSame(self):
+        G1 = nx.Graph()
+        G1.add_node("A", label="A")
+        G1.add_node("B", label="B")
+        G1.add_edge("A", "B", label="a-b")
+        G2 = nx.Graph()
+        G2.add_node("A", label="A")
+        G2.add_node("B", label="B")
+        G2.add_edge("A", "B", label="a-b")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 0
+
+    def testOneEdgeLabelDiff(self):
+        G1 = nx.Graph()
+        G1.add_node("A", label="A")
+        G1.add_node("B", label="B")
+        G1.add_edge("A", "B", label="a-b")
+        G2 = nx.Graph()
+        G2.add_node("A", label="A")
+        G2.add_node("B", label="B")
+        G2.add_edge("A", "B", label="bad")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 1
+
+    def testOneNodeLabelDiff(self):
+        G1 = nx.Graph()
+        G1.add_node("A", label="A")
+        G1.add_node("B", label="B")
+        G1.add_edge("A", "B", label="a-b")
+        G2 = nx.Graph()
+        G2.add_node("A", label="Z")
+        G2.add_node("B", label="B")
+        G2.add_edge("A", "B", label="a-b")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 1
+
+    def testOneExtraNode(self):
+        G1 = nx.Graph()
+        G1.add_node("A", label="A")
+        G1.add_node("B", label="B")
+        G1.add_edge("A", "B", label="a-b")
+        G2 = nx.Graph()
+        G2.add_node("A", label="A")
+        G2.add_node("B", label="B")
+        G2.add_edge("A", "B", label="a-b")
+        G2.add_node("C", label="C")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 1
+
+    def testOneExtraEdge(self):
+        G1 = nx.Graph()
+        G1.add_node("A", label="A")
+        G1.add_node("B", label="B")
+        G1.add_node("C", label="C")
+        G1.add_node("C", label="C")
+        G1.add_edge("A", "B", label="a-b")
+        G2 = nx.Graph()
+        G2.add_node("A", label="A")
+        G2.add_node("B", label="B")
+        G2.add_node("C", label="C")
+        G2.add_edge("A", "B", label="a-b")
+        G2.add_edge("A", "C", label="a-c")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 1
+
+    def testOneExtraNodeAndEdge(self):
+        G1 = nx.Graph()
+        G1.add_node("A", label="A")
+        G1.add_node("B", label="B")
+        G1.add_edge("A", "B", label="a-b")
+        G2 = nx.Graph()
+        G2.add_node("A", label="A")
+        G2.add_node("B", label="B")
+        G2.add_node("C", label="C")
+        G2.add_edge("A", "B", label="a-b")
+        G2.add_edge("A", "C", label="a-c")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 2
+
+    def testGraph1(self):
+        G1 = getCanonical()
+        G2 = nx.Graph()
+        G2.add_node("A", label="A")
+        G2.add_node("B", label="B")
+        G2.add_node("D", label="D")
+        G2.add_node("E", label="E")
+        G2.add_edge("A", "B", label="a-b")
+        G2.add_edge("B", "D", label="b-d")
+        G2.add_edge("D", "E", label="d-e")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 3
+
+    def testGraph2(self):
+        G1 = getCanonical()
+        G2 = nx.Graph()
+        G2.add_node("A", label="A")
+        G2.add_node("B", label="B")
+        G2.add_node("C", label="C")
+        G2.add_node("D", label="D")
+        G2.add_node("E", label="E")
+        G2.add_edge("A", "B", label="a-b")
+        G2.add_edge("B", "C", label="b-c")
+        G2.add_edge("C", "D", label="c-d")
+        G2.add_edge("C", "E", label="c-e")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 4
+
+    def testGraph3(self):
+        G1 = getCanonical()
+        G2 = nx.Graph()
+        G2.add_node("A", label="A")
+        G2.add_node("B", label="B")
+        G2.add_node("C", label="C")
+        G2.add_node("D", label="D")
+        G2.add_node("E", label="E")
+        G2.add_node("F", label="F")
+        G2.add_node("G", label="G")
+        G2.add_edge("A", "C", label="a-c")
+        G2.add_edge("A", "D", label="a-d")
+        G2.add_edge("D", "E", label="d-e")
+        G2.add_edge("D", "F", label="d-f")
+        G2.add_edge("D", "G", label="d-g")
+        G2.add_edge("E", "B", label="e-b")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 12
+
+    def testGraph4(self):
+        G1 = getCanonical()
+        G2 = nx.Graph()
+        G2.add_node("A", label="A")
+        G2.add_node("B", label="B")
+        G2.add_node("C", label="C")
+        G2.add_node("D", label="D")
+        G2.add_edge("A", "B", label="a-b")
+        G2.add_edge("B", "C", label="b-c")
+        G2.add_edge("C", "D", label="c-d")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 2
+
+    def testGraph4_a(self):
+        G1 = getCanonical()
+        G2 = nx.Graph()
+        G2.add_node("A", label="A")
+        G2.add_node("B", label="B")
+        G2.add_node("C", label="C")
+        G2.add_node("D", label="D")
+        G2.add_edge("A", "B", label="a-b")
+        G2.add_edge("B", "C", label="b-c")
+        G2.add_edge("A", "D", label="a-d")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 2
+
+    def testGraph4_b(self):
+        G1 = getCanonical()
+        G2 = nx.Graph()
+        G2.add_node("A", label="A")
+        G2.add_node("B", label="B")
+        G2.add_node("C", label="C")
+        G2.add_node("D", label="D")
+        G2.add_edge("A", "B", label="a-b")
+        G2.add_edge("B", "C", label="b-c")
+        G2.add_edge("B", "D", label="bad")
+        assert graph_edit_distance(G1, G2, node_match=nmatch, edge_match=ematch) == 1
+
+    # note: nx.simrank_similarity_numpy not included because returns np.array
+    simrank_algs = [nx.simrank_similarity, nx.similarity._simrank_similarity_python]
+
+    @pytest.mark.parametrize("simrank_similarity", simrank_algs)
+    def test_simrank_no_source_no_target(self, simrank_similarity):
+        G = nx.cycle_graph(5)
+        expected = {
+            0: {
+                0: 1,
+                1: 0.3951219505902448,
+                2: 0.5707317069281646,
+                3: 0.5707317069281646,
+                4: 0.3951219505902449,
+            },
+            1: {
+                0: 0.3951219505902448,
+                1: 1,
+                2: 0.3951219505902449,
+                3: 0.5707317069281646,
+                4: 0.5707317069281646,
+            },
+            2: {
+                0: 0.5707317069281646,
+                1: 0.3951219505902449,
+                2: 1,
+                3: 0.3951219505902449,
+                4: 0.5707317069281646,
+            },
+            3: {
+                0: 0.5707317069281646,
+                1: 0.5707317069281646,
+                2: 0.3951219505902449,
+                3: 1,
+                4: 0.3951219505902449,
+            },
+            4: {
+                0: 0.3951219505902449,
+                1: 0.5707317069281646,
+                2: 0.5707317069281646,
+                3: 0.3951219505902449,
+                4: 1,
+            },
+        }
+        actual = simrank_similarity(G)
+        for k, v in expected.items():
+            assert v == pytest.approx(actual[k], abs=1e-2)
+
+        # For a DiGraph test, use the first graph from the paper cited in
+        # the docs: https://dl.acm.org/doi/pdf/10.1145/775047.775126
+        G = nx.DiGraph()
+        G.add_node(0, label="Univ")
+        G.add_node(1, label="ProfA")
+        G.add_node(2, label="ProfB")
+        G.add_node(3, label="StudentA")
+        G.add_node(4, label="StudentB")
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 4), (4, 2), (3, 0)])
+
+        expected = {
+            0: {0: 1, 1: 0.0, 2: 0.1323363991265798, 3: 0.0, 4: 0.03387811817640443},
+            1: {0: 0.0, 1: 1, 2: 0.4135512472705618, 3: 0.0, 4: 0.10586911930126384},
+            2: {
+                0: 0.1323363991265798,
+                1: 0.4135512472705618,
+                2: 1,
+                3: 0.04234764772050554,
+                4: 0.08822426608438655,
+            },
+            3: {0: 0.0, 1: 0.0, 2: 0.04234764772050554, 3: 1, 4: 0.3308409978164495},
+            4: {
+                0: 0.03387811817640443,
+                1: 0.10586911930126384,
+                2: 0.08822426608438655,
+                3: 0.3308409978164495,
+                4: 1,
+            },
+        }
+        # Use the importance_factor from the paper to get the same numbers.
+        actual = simrank_similarity(G, importance_factor=0.8)
+        for k, v in expected.items():
+            assert v == pytest.approx(actual[k], abs=1e-2)
+
+    @pytest.mark.parametrize("simrank_similarity", simrank_algs)
+    def test_simrank_source_no_target(self, simrank_similarity):
+        G = nx.cycle_graph(5)
+        expected = {
+            0: 1,
+            1: 0.3951219505902448,
+            2: 0.5707317069281646,
+            3: 0.5707317069281646,
+            4: 0.3951219505902449,
+        }
+        actual = simrank_similarity(G, source=0)
+        assert expected == pytest.approx(actual, abs=1e-2)
+
+        # For a DiGraph test, use the first graph from the paper cited in
+        # the docs: https://dl.acm.org/doi/pdf/10.1145/775047.775126
+        G = nx.DiGraph()
+        G.add_node(0, label="Univ")
+        G.add_node(1, label="ProfA")
+        G.add_node(2, label="ProfB")
+        G.add_node(3, label="StudentA")
+        G.add_node(4, label="StudentB")
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 4), (4, 2), (3, 0)])
+
+        expected = {0: 1, 1: 0.0, 2: 0.1323363991265798, 3: 0.0, 4: 0.03387811817640443}
+        # Use the importance_factor from the paper to get the same numbers.
+        actual = simrank_similarity(G, importance_factor=0.8, source=0)
+        assert expected == pytest.approx(actual, abs=1e-2)
+
+    @pytest.mark.parametrize("simrank_similarity", simrank_algs)
+    def test_simrank_noninteger_nodes(self, simrank_similarity):
+        G = nx.cycle_graph(5)
+        G = nx.relabel_nodes(G, dict(enumerate("abcde")))
+        expected = {
+            "a": 1,
+            "b": 0.3951219505902448,
+            "c": 0.5707317069281646,
+            "d": 0.5707317069281646,
+            "e": 0.3951219505902449,
+        }
+        actual = simrank_similarity(G, source="a")
+        assert expected == pytest.approx(actual, abs=1e-2)
+
+        # For a DiGraph test, use the first graph from the paper cited in
+        # the docs: https://dl.acm.org/doi/pdf/10.1145/775047.775126
+        G = nx.DiGraph()
+        G.add_node(0, label="Univ")
+        G.add_node(1, label="ProfA")
+        G.add_node(2, label="ProfB")
+        G.add_node(3, label="StudentA")
+        G.add_node(4, label="StudentB")
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 4), (4, 2), (3, 0)])
+        node_labels = dict(enumerate(nx.get_node_attributes(G, "label").values()))
+        G = nx.relabel_nodes(G, node_labels)
+
+        expected = {
+            "Univ": 1,
+            "ProfA": 0.0,
+            "ProfB": 0.1323363991265798,
+            "StudentA": 0.0,
+            "StudentB": 0.03387811817640443,
+        }
+        # Use the importance_factor from the paper to get the same numbers.
+        actual = simrank_similarity(G, importance_factor=0.8, source="Univ")
+        assert expected == pytest.approx(actual, abs=1e-2)
+
+    @pytest.mark.parametrize("simrank_similarity", simrank_algs)
+    def test_simrank_source_and_target(self, simrank_similarity):
+        G = nx.cycle_graph(5)
+        expected = 1
+        actual = simrank_similarity(G, source=0, target=0)
+        assert expected == pytest.approx(actual, abs=1e-2)
+
+        # For a DiGraph test, use the first graph from the paper cited in
+        # the docs: https://dl.acm.org/doi/pdf/10.1145/775047.775126
+        G = nx.DiGraph()
+        G.add_node(0, label="Univ")
+        G.add_node(1, label="ProfA")
+        G.add_node(2, label="ProfB")
+        G.add_node(3, label="StudentA")
+        G.add_node(4, label="StudentB")
+        G.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 4), (4, 2), (3, 0)])
+
+        expected = 0.1323363991265798
+        # Use the importance_factor from the paper to get the same numbers.
+        # Use the pair (0,2) because (0,0) and (0,1) have trivial results.
+        actual = simrank_similarity(G, importance_factor=0.8, source=0, target=2)
+        assert expected == pytest.approx(actual, abs=1e-5)
+
+    @pytest.mark.parametrize("alg", simrank_algs)
+    def test_simrank_max_iterations(self, alg):
+        G = nx.cycle_graph(5)
+        pytest.raises(nx.ExceededMaxIterations, alg, G, max_iterations=10)
+
+    def test_simrank_between_versions(self):
+        G = nx.cycle_graph(5)
+        # _python tolerance 1e-4
+        expected_python_tol4 = {
+            0: 1,
+            1: 0.394512499239852,
+            2: 0.5703550452791322,
+            3: 0.5703550452791323,
+            4: 0.394512499239852,
+        }
+        # _numpy tolerance 1e-4
+        expected_numpy_tol4 = {
+            0: 1.0,
+            1: 0.3947180735764555,
+            2: 0.570482097206368,
+            3: 0.570482097206368,
+            4: 0.3947180735764555,
+        }
+        actual = nx.simrank_similarity(G, source=0)
+        assert expected_numpy_tol4 == pytest.approx(actual, abs=1e-7)
+        # versions differ at 1e-4 level but equal at 1e-3
+        assert expected_python_tol4 != pytest.approx(actual, abs=1e-4)
+        assert expected_python_tol4 == pytest.approx(actual, abs=1e-3)
+
+        actual = nx.similarity._simrank_similarity_python(G, source=0)
+        assert expected_python_tol4 == pytest.approx(actual, abs=1e-7)
+        # versions differ at 1e-4 level but equal at 1e-3
+        assert expected_numpy_tol4 != pytest.approx(actual, abs=1e-4)
+        assert expected_numpy_tol4 == pytest.approx(actual, abs=1e-3)
+
+    def test_simrank_numpy_no_source_no_target(self):
+        G = nx.cycle_graph(5)
+        expected = np.array(
+            [
+                [
+                    1.0,
+                    0.3947180735764555,
+                    0.570482097206368,
+                    0.570482097206368,
+                    0.3947180735764555,
+                ],
+                [
+                    0.3947180735764555,
+                    1.0,
+                    0.3947180735764555,
+                    0.570482097206368,
+                    0.570482097206368,
+                ],
+                [
+                    0.570482097206368,
+                    0.3947180735764555,
+                    1.0,
+                    0.3947180735764555,
+                    0.570482097206368,
+                ],
+                [
+                    0.570482097206368,
+                    0.570482097206368,
+                    0.3947180735764555,
+                    1.0,
+                    0.3947180735764555,
+                ],
+                [
+                    0.3947180735764555,
+                    0.570482097206368,
+                    0.570482097206368,
+                    0.3947180735764555,
+                    1.0,
+                ],
+            ]
+        )
+        actual = nx.similarity._simrank_similarity_numpy(G)
+        np.testing.assert_allclose(expected, actual, atol=1e-7)
+
+    def test_simrank_numpy_source_no_target(self):
+        G = nx.cycle_graph(5)
+        expected = np.array(
+            [
+                1.0,
+                0.3947180735764555,
+                0.570482097206368,
+                0.570482097206368,
+                0.3947180735764555,
+            ]
+        )
+        actual = nx.similarity._simrank_similarity_numpy(G, source=0)
+        np.testing.assert_allclose(expected, actual, atol=1e-7)
+
+    def test_simrank_numpy_source_and_target(self):
+        G = nx.cycle_graph(5)
+        expected = 1.0
+        actual = nx.similarity._simrank_similarity_numpy(G, source=0, target=0)
+        np.testing.assert_allclose(expected, actual, atol=1e-7)
+
+    def test_panther_similarity_unweighted(self):
+        np.random.seed(42)
+
+        G = nx.Graph()
+        G.add_edge(0, 1)
+        G.add_edge(0, 2)
+        G.add_edge(0, 3)
+        G.add_edge(1, 2)
+        G.add_edge(2, 4)
+        expected = {3: 0.5, 2: 0.5, 1: 0.5, 4: 0.125}
+        sim = nx.panther_similarity(G, 0, path_length=2)
+        assert sim == expected
+
+    def test_panther_similarity_weighted(self):
+        np.random.seed(42)
+
+        G = nx.Graph()
+        G.add_edge("v1", "v2", weight=5)
+        G.add_edge("v1", "v3", weight=1)
+        G.add_edge("v1", "v4", weight=2)
+        G.add_edge("v2", "v3", weight=0.1)
+        G.add_edge("v3", "v5", weight=1)
+        expected = {"v3": 0.75, "v4": 0.5, "v2": 0.5, "v5": 0.25}
+        sim = nx.panther_similarity(G, "v1", path_length=2)
+        assert sim == expected
+
+    def test_generate_random_paths_unweighted(self):
+        np.random.seed(42)
+
+        index_map = {}
+        num_paths = 10
+        path_length = 2
+        G = nx.Graph()
+        G.add_edge(0, 1)
+        G.add_edge(0, 2)
+        G.add_edge(0, 3)
+        G.add_edge(1, 2)
+        G.add_edge(2, 4)
+        paths = nx.generate_random_paths(
+            G, num_paths, path_length=path_length, index_map=index_map
+        )
+        expected_paths = [
+            [3, 0, 3],
+            [4, 2, 1],
+            [2, 1, 0],
+            [2, 0, 3],
+            [3, 0, 1],
+            [3, 0, 1],
+            [4, 2, 0],
+            [2, 1, 0],
+            [3, 0, 2],
+            [2, 1, 2],
+        ]
+        expected_map = {
+            0: {0, 2, 3, 4, 5, 6, 7, 8},
+            1: {1, 2, 4, 5, 7, 9},
+            2: {1, 2, 3, 6, 7, 8, 9},
+            3: {0, 3, 4, 5, 8},
+            4: {1, 6},
+        }
+
+        assert expected_paths == list(paths)
+        assert expected_map == index_map
+
+    def test_generate_random_paths_weighted(self):
+        np.random.seed(42)
+
+        index_map = {}
+        num_paths = 10
+        path_length = 6
+        G = nx.Graph()
+        G.add_edge("a", "b", weight=0.6)
+        G.add_edge("a", "c", weight=0.2)
+        G.add_edge("c", "d", weight=0.1)
+        G.add_edge("c", "e", weight=0.7)
+        G.add_edge("c", "f", weight=0.9)
+        G.add_edge("a", "d", weight=0.3)
+        paths = nx.generate_random_paths(
+            G, num_paths, path_length=path_length, index_map=index_map
+        )
+
+        expected_paths = [
+            ["d", "c", "f", "c", "d", "a", "b"],
+            ["e", "c", "f", "c", "f", "c", "e"],
+            ["d", "a", "b", "a", "b", "a", "c"],
+            ["b", "a", "d", "a", "b", "a", "b"],
+            ["d", "a", "b", "a", "b", "a", "d"],
+            ["d", "a", "b", "a", "b", "a", "c"],
+            ["d", "a", "b", "a", "b", "a", "b"],
+            ["f", "c", "f", "c", "f", "c", "e"],
+            ["d", "a", "d", "a", "b", "a", "b"],
+            ["e", "c", "f", "c", "e", "c", "d"],
+        ]
+        expected_map = {
+            "d": {0, 2, 3, 4, 5, 6, 8, 9},
+            "c": {0, 1, 2, 5, 7, 9},
+            "f": {0, 1, 9, 7},
+            "a": {0, 2, 3, 4, 5, 6, 8},
+            "b": {0, 2, 3, 4, 5, 6, 8},
+            "e": {1, 9, 7},
+        }
+
+        assert expected_paths == list(paths)
+        assert expected_map == index_map
+
+    def test_symmetry_with_custom_matching(self):
+        print("G2 is edge (a,b) and G3 is edge (a,a)")
+        print("but node order for G2 is (a,b) while for G3 it is (b,a)")
+
+        a, b = "A", "B"
+        G2 = nx.Graph()
+        G2.add_nodes_from((a, b))
+        G2.add_edges_from([(a, b)])
+        G3 = nx.Graph()
+        G3.add_nodes_from((b, a))
+        G3.add_edges_from([(a, a)])
+        for G in (G2, G3):
+            for n in G:
+                G.nodes[n]["attr"] = n
+            for e in G.edges:
+                G.edges[e]["attr"] = e
+        match = lambda x, y: x == y
+
+        print("Starting G2 to G3 GED calculation")
+        assert nx.graph_edit_distance(G2, G3, node_match=match, edge_match=match) == 1
+
+        print("Starting G3 to G2 GED calculation")
+        assert nx.graph_edit_distance(G3, G2, node_match=match, edge_match=match) == 1
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_simple_paths.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_simple_paths.py
new file mode 100644
index 0000000..08348b9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_simple_paths.py
@@ -0,0 +1,765 @@
+import random
+
+import pytest
+
+import networkx as nx
+from networkx import convert_node_labels_to_integers as cnlti
+from networkx.algorithms.simple_paths import (
+    _bidirectional_dijkstra,
+    _bidirectional_shortest_path,
+)
+from networkx.utils import arbitrary_element, pairwise
+
+
+class TestIsSimplePath:
+    """Unit tests for the
+    :func:`networkx.algorithms.simple_paths.is_simple_path` function.
+
+    """
+
+    def test_empty_list(self):
+        """Tests that the empty list is not a valid path, since there
+        should be a one-to-one correspondence between paths as lists of
+        nodes and paths as lists of edges.
+
+        """
+        G = nx.trivial_graph()
+        assert not nx.is_simple_path(G, [])
+
+    def test_trivial_path(self):
+        """Tests that the trivial path, a path of length one, is
+        considered a simple path in a graph.
+
+        """
+        G = nx.trivial_graph()
+        assert nx.is_simple_path(G, [0])
+
+    def test_trivial_nonpath(self):
+        """Tests that a list whose sole element is an object not in the
+        graph is not considered a simple path.
+
+        """
+        G = nx.trivial_graph()
+        assert not nx.is_simple_path(G, ["not a node"])
+
+    def test_simple_path(self):
+        G = nx.path_graph(2)
+        assert nx.is_simple_path(G, [0, 1])
+
+    def test_non_simple_path(self):
+        G = nx.path_graph(2)
+        assert not nx.is_simple_path(G, [0, 1, 0])
+
+    def test_cycle(self):
+        G = nx.cycle_graph(3)
+        assert not nx.is_simple_path(G, [0, 1, 2, 0])
+
+    def test_missing_node(self):
+        G = nx.path_graph(2)
+        assert not nx.is_simple_path(G, [0, 2])
+
+    def test_directed_path(self):
+        G = nx.DiGraph([(0, 1), (1, 2)])
+        assert nx.is_simple_path(G, [0, 1, 2])
+
+    def test_directed_non_path(self):
+        G = nx.DiGraph([(0, 1), (1, 2)])
+        assert not nx.is_simple_path(G, [2, 1, 0])
+
+    def test_directed_cycle(self):
+        G = nx.DiGraph([(0, 1), (1, 2), (2, 0)])
+        assert not nx.is_simple_path(G, [0, 1, 2, 0])
+
+    def test_multigraph(self):
+        G = nx.MultiGraph([(0, 1), (0, 1)])
+        assert nx.is_simple_path(G, [0, 1])
+
+    def test_multidigraph(self):
+        G = nx.MultiDiGraph([(0, 1), (0, 1), (1, 0), (1, 0)])
+        assert nx.is_simple_path(G, [0, 1])
+
+
+# Tests for all_simple_paths
+def test_all_simple_paths():
+    G = nx.path_graph(4)
+    paths = nx.all_simple_paths(G, 0, 3)
+    assert {tuple(p) for p in paths} == {(0, 1, 2, 3)}
+
+
+def test_all_simple_paths_with_two_targets_emits_two_paths():
+    G = nx.path_graph(4)
+    G.add_edge(2, 4)
+    paths = nx.all_simple_paths(G, 0, [3, 4])
+    assert {tuple(p) for p in paths} == {(0, 1, 2, 3), (0, 1, 2, 4)}
+
+
+def test_digraph_all_simple_paths_with_two_targets_emits_two_paths():
+    G = nx.path_graph(4, create_using=nx.DiGraph())
+    G.add_edge(2, 4)
+    paths = nx.all_simple_paths(G, 0, [3, 4])
+    assert {tuple(p) for p in paths} == {(0, 1, 2, 3), (0, 1, 2, 4)}
+
+
+def test_all_simple_paths_with_two_targets_cutoff():
+    G = nx.path_graph(4)
+    G.add_edge(2, 4)
+    paths = nx.all_simple_paths(G, 0, [3, 4], cutoff=3)
+    assert {tuple(p) for p in paths} == {(0, 1, 2, 3), (0, 1, 2, 4)}
+
+
+def test_digraph_all_simple_paths_with_two_targets_cutoff():
+    G = nx.path_graph(4, create_using=nx.DiGraph())
+    G.add_edge(2, 4)
+    paths = nx.all_simple_paths(G, 0, [3, 4], cutoff=3)
+    assert {tuple(p) for p in paths} == {(0, 1, 2, 3), (0, 1, 2, 4)}
+
+
+def test_all_simple_paths_with_two_targets_in_line_emits_two_paths():
+    G = nx.path_graph(4)
+    paths = nx.all_simple_paths(G, 0, [2, 3])
+    assert {tuple(p) for p in paths} == {(0, 1, 2), (0, 1, 2, 3)}
+
+
+def test_all_simple_paths_ignores_cycle():
+    G = nx.cycle_graph(3, create_using=nx.DiGraph())
+    G.add_edge(1, 3)
+    paths = nx.all_simple_paths(G, 0, 3)
+    assert {tuple(p) for p in paths} == {(0, 1, 3)}
+
+
+def test_all_simple_paths_with_two_targets_inside_cycle_emits_two_paths():
+    G = nx.cycle_graph(3, create_using=nx.DiGraph())
+    G.add_edge(1, 3)
+    paths = nx.all_simple_paths(G, 0, [2, 3])
+    assert {tuple(p) for p in paths} == {(0, 1, 2), (0, 1, 3)}
+
+
+def test_all_simple_paths_source_target():
+    G = nx.path_graph(4)
+    paths = nx.all_simple_paths(G, 1, 1)
+    assert list(paths) == []
+
+
+def test_all_simple_paths_cutoff():
+    G = nx.complete_graph(4)
+    paths = nx.all_simple_paths(G, 0, 1, cutoff=1)
+    assert {tuple(p) for p in paths} == {(0, 1)}
+    paths = nx.all_simple_paths(G, 0, 1, cutoff=2)
+    assert {tuple(p) for p in paths} == {(0, 1), (0, 2, 1), (0, 3, 1)}
+
+
+def test_all_simple_paths_on_non_trivial_graph():
+    """you may need to draw this graph to make sure it is reasonable"""
+    G = nx.path_graph(5, create_using=nx.DiGraph())
+    G.add_edges_from([(0, 5), (1, 5), (1, 3), (5, 4), (4, 2), (4, 3)])
+    paths = nx.all_simple_paths(G, 1, [2, 3])
+    assert {tuple(p) for p in paths} == {
+        (1, 2),
+        (1, 3, 4, 2),
+        (1, 5, 4, 2),
+        (1, 3),
+        (1, 2, 3),
+        (1, 5, 4, 3),
+        (1, 5, 4, 2, 3),
+    }
+    paths = nx.all_simple_paths(G, 1, [2, 3], cutoff=3)
+    assert {tuple(p) for p in paths} == {
+        (1, 2),
+        (1, 3, 4, 2),
+        (1, 5, 4, 2),
+        (1, 3),
+        (1, 2, 3),
+        (1, 5, 4, 3),
+    }
+    paths = nx.all_simple_paths(G, 1, [2, 3], cutoff=2)
+    assert {tuple(p) for p in paths} == {(1, 2), (1, 3), (1, 2, 3)}
+
+
+def test_all_simple_paths_multigraph():
+    G = nx.MultiGraph([(1, 2), (1, 2)])
+    paths = nx.all_simple_paths(G, 1, 1)
+    assert list(paths) == []
+    nx.add_path(G, [3, 1, 10, 2])
+    paths = list(nx.all_simple_paths(G, 1, 2))
+    assert len(paths) == 3
+    assert {tuple(p) for p in paths} == {(1, 2), (1, 2), (1, 10, 2)}
+
+
+def test_all_simple_paths_multigraph_with_cutoff():
+    G = nx.MultiGraph([(1, 2), (1, 2), (1, 10), (10, 2)])
+    paths = list(nx.all_simple_paths(G, 1, 2, cutoff=1))
+    assert len(paths) == 2
+    assert {tuple(p) for p in paths} == {(1, 2), (1, 2)}
+
+
+def test_all_simple_paths_directed():
+    G = nx.DiGraph()
+    nx.add_path(G, [1, 2, 3])
+    nx.add_path(G, [3, 2, 1])
+    paths = nx.all_simple_paths(G, 1, 3)
+    assert {tuple(p) for p in paths} == {(1, 2, 3)}
+
+
+def test_all_simple_paths_empty():
+    G = nx.path_graph(4)
+    paths = nx.all_simple_paths(G, 0, 3, cutoff=2)
+    assert list(paths) == []
+
+
+def test_all_simple_paths_corner_cases():
+    assert list(nx.all_simple_paths(nx.empty_graph(2), 0, 0)) == []
+    assert list(nx.all_simple_paths(nx.empty_graph(2), 0, 1)) == []
+    assert list(nx.all_simple_paths(nx.path_graph(9), 0, 8, 0)) == []
+
+
+def hamiltonian_path(G, source):
+    source = arbitrary_element(G)
+    neighbors = set(G[source]) - {source}
+    n = len(G)
+    for target in neighbors:
+        for path in nx.all_simple_paths(G, source, target):
+            if len(path) == n:
+                yield path
+
+
+def test_hamiltonian_path():
+    from itertools import permutations
+
+    G = nx.complete_graph(4)
+    paths = [list(p) for p in hamiltonian_path(G, 0)]
+    exact = [[0] + list(p) for p in permutations([1, 2, 3], 3)]
+    assert sorted(paths) == sorted(exact)
+
+
+def test_cutoff_zero():
+    G = nx.complete_graph(4)
+    paths = nx.all_simple_paths(G, 0, 3, cutoff=0)
+    assert list(list(p) for p in paths) == []
+    paths = nx.all_simple_paths(nx.MultiGraph(G), 0, 3, cutoff=0)
+    assert list(list(p) for p in paths) == []
+
+
+def test_source_missing():
+    with pytest.raises(nx.NodeNotFound):
+        G = nx.Graph()
+        nx.add_path(G, [1, 2, 3])
+        list(nx.all_simple_paths(nx.MultiGraph(G), 0, 3))
+
+
+def test_target_missing():
+    with pytest.raises(nx.NodeNotFound):
+        G = nx.Graph()
+        nx.add_path(G, [1, 2, 3])
+        list(nx.all_simple_paths(nx.MultiGraph(G), 1, 4))
+
+
+# Tests for all_simple_edge_paths
+def test_all_simple_edge_paths():
+    G = nx.path_graph(4)
+    paths = nx.all_simple_edge_paths(G, 0, 3)
+    assert {tuple(p) for p in paths} == {((0, 1), (1, 2), (2, 3))}
+
+
+def test_all_simple_edge_paths_with_two_targets_emits_two_paths():
+    G = nx.path_graph(4)
+    G.add_edge(2, 4)
+    paths = nx.all_simple_edge_paths(G, 0, [3, 4])
+    assert {tuple(p) for p in paths} == {
+        ((0, 1), (1, 2), (2, 3)),
+        ((0, 1), (1, 2), (2, 4)),
+    }
+
+
+def test_digraph_all_simple_edge_paths_with_two_targets_emits_two_paths():
+    G = nx.path_graph(4, create_using=nx.DiGraph())
+    G.add_edge(2, 4)
+    paths = nx.all_simple_edge_paths(G, 0, [3, 4])
+    assert {tuple(p) for p in paths} == {
+        ((0, 1), (1, 2), (2, 3)),
+        ((0, 1), (1, 2), (2, 4)),
+    }
+
+
+def test_all_simple_edge_paths_with_two_targets_cutoff():
+    G = nx.path_graph(4)
+    G.add_edge(2, 4)
+    paths = nx.all_simple_edge_paths(G, 0, [3, 4], cutoff=3)
+    assert {tuple(p) for p in paths} == {
+        ((0, 1), (1, 2), (2, 3)),
+        ((0, 1), (1, 2), (2, 4)),
+    }
+
+
+def test_digraph_all_simple_edge_paths_with_two_targets_cutoff():
+    G = nx.path_graph(4, create_using=nx.DiGraph())
+    G.add_edge(2, 4)
+    paths = nx.all_simple_edge_paths(G, 0, [3, 4], cutoff=3)
+    assert {tuple(p) for p in paths} == {
+        ((0, 1), (1, 2), (2, 3)),
+        ((0, 1), (1, 2), (2, 4)),
+    }
+
+
+def test_all_simple_edge_paths_with_two_targets_in_line_emits_two_paths():
+    G = nx.path_graph(4)
+    paths = nx.all_simple_edge_paths(G, 0, [2, 3])
+    assert {tuple(p) for p in paths} == {((0, 1), (1, 2)), ((0, 1), (1, 2), (2, 3))}
+
+
+def test_all_simple_edge_paths_ignores_cycle():
+    G = nx.cycle_graph(3, create_using=nx.DiGraph())
+    G.add_edge(1, 3)
+    paths = nx.all_simple_edge_paths(G, 0, 3)
+    assert {tuple(p) for p in paths} == {((0, 1), (1, 3))}
+
+
+def test_all_simple_edge_paths_with_two_targets_inside_cycle_emits_two_paths():
+    G = nx.cycle_graph(3, create_using=nx.DiGraph())
+    G.add_edge(1, 3)
+    paths = nx.all_simple_edge_paths(G, 0, [2, 3])
+    assert {tuple(p) for p in paths} == {((0, 1), (1, 2)), ((0, 1), (1, 3))}
+
+
+def test_all_simple_edge_paths_source_target():
+    G = nx.path_graph(4)
+    paths = nx.all_simple_edge_paths(G, 1, 1)
+    assert list(paths) == []
+
+
+def test_all_simple_edge_paths_cutoff():
+    G = nx.complete_graph(4)
+    paths = nx.all_simple_edge_paths(G, 0, 1, cutoff=1)
+    assert {tuple(p) for p in paths} == {((0, 1),)}
+    paths = nx.all_simple_edge_paths(G, 0, 1, cutoff=2)
+    assert {tuple(p) for p in paths} == {((0, 1),), ((0, 2), (2, 1)), ((0, 3), (3, 1))}
+
+
+def test_all_simple_edge_paths_on_non_trivial_graph():
+    """you may need to draw this graph to make sure it is reasonable"""
+    G = nx.path_graph(5, create_using=nx.DiGraph())
+    G.add_edges_from([(0, 5), (1, 5), (1, 3), (5, 4), (4, 2), (4, 3)])
+    paths = nx.all_simple_edge_paths(G, 1, [2, 3])
+    assert {tuple(p) for p in paths} == {
+        ((1, 2),),
+        ((1, 3), (3, 4), (4, 2)),
+        ((1, 5), (5, 4), (4, 2)),
+        ((1, 3),),
+        ((1, 2), (2, 3)),
+        ((1, 5), (5, 4), (4, 3)),
+        ((1, 5), (5, 4), (4, 2), (2, 3)),
+    }
+    paths = nx.all_simple_edge_paths(G, 1, [2, 3], cutoff=3)
+    assert {tuple(p) for p in paths} == {
+        ((1, 2),),
+        ((1, 3), (3, 4), (4, 2)),
+        ((1, 5), (5, 4), (4, 2)),
+        ((1, 3),),
+        ((1, 2), (2, 3)),
+        ((1, 5), (5, 4), (4, 3)),
+    }
+    paths = nx.all_simple_edge_paths(G, 1, [2, 3], cutoff=2)
+    assert {tuple(p) for p in paths} == {((1, 2),), ((1, 3),), ((1, 2), (2, 3))}
+
+
+def test_all_simple_edge_paths_multigraph():
+    G = nx.MultiGraph([(1, 2), (1, 2)])
+    paths = nx.all_simple_edge_paths(G, 1, 1)
+    assert list(paths) == []
+    nx.add_path(G, [3, 1, 10, 2])
+    paths = list(nx.all_simple_edge_paths(G, 1, 2))
+    assert len(paths) == 3
+    assert {tuple(p) for p in paths} == {
+        ((1, 2, 0),),
+        ((1, 2, 1),),
+        ((1, 10, 0), (10, 2, 0)),
+    }
+
+
+def test_all_simple_edge_paths_multigraph_with_cutoff():
+    G = nx.MultiGraph([(1, 2), (1, 2), (1, 10), (10, 2)])
+    paths = list(nx.all_simple_edge_paths(G, 1, 2, cutoff=1))
+    assert len(paths) == 2
+    assert {tuple(p) for p in paths} == {((1, 2, 0),), ((1, 2, 1),)}
+
+
+def test_all_simple_edge_paths_directed():
+    G = nx.DiGraph()
+    nx.add_path(G, [1, 2, 3])
+    nx.add_path(G, [3, 2, 1])
+    paths = nx.all_simple_edge_paths(G, 1, 3)
+    assert {tuple(p) for p in paths} == {((1, 2), (2, 3))}
+
+
+def test_all_simple_edge_paths_empty():
+    G = nx.path_graph(4)
+    paths = nx.all_simple_edge_paths(G, 0, 3, cutoff=2)
+    assert list(paths) == []
+
+
+def test_all_simple_edge_paths_corner_cases():
+    assert list(nx.all_simple_edge_paths(nx.empty_graph(2), 0, 0)) == []
+    assert list(nx.all_simple_edge_paths(nx.empty_graph(2), 0, 1)) == []
+    assert list(nx.all_simple_edge_paths(nx.path_graph(9), 0, 8, 0)) == []
+
+
+def hamiltonian_edge_path(G, source):
+    source = arbitrary_element(G)
+    neighbors = set(G[source]) - {source}
+    n = len(G)
+    for target in neighbors:
+        for path in nx.all_simple_edge_paths(G, source, target):
+            if len(path) == n - 1:
+                yield path
+
+
+def test_hamiltonian__edge_path():
+    from itertools import permutations
+
+    G = nx.complete_graph(4)
+    paths = hamiltonian_edge_path(G, 0)
+    exact = [list(pairwise([0] + list(p))) for p in permutations([1, 2, 3], 3)]
+    assert sorted(exact) == [p for p in sorted(paths)]
+
+
+def test_edge_cutoff_zero():
+    G = nx.complete_graph(4)
+    paths = nx.all_simple_edge_paths(G, 0, 3, cutoff=0)
+    assert list(list(p) for p in paths) == []
+    paths = nx.all_simple_edge_paths(nx.MultiGraph(G), 0, 3, cutoff=0)
+    assert list(list(p) for p in paths) == []
+
+
+def test_edge_source_missing():
+    with pytest.raises(nx.NodeNotFound):
+        G = nx.Graph()
+        nx.add_path(G, [1, 2, 3])
+        list(nx.all_simple_edge_paths(nx.MultiGraph(G), 0, 3))
+
+
+def test_edge_target_missing():
+    with pytest.raises(nx.NodeNotFound):
+        G = nx.Graph()
+        nx.add_path(G, [1, 2, 3])
+        list(nx.all_simple_edge_paths(nx.MultiGraph(G), 1, 4))
+
+
+# Tests for shortest_simple_paths
+def test_shortest_simple_paths():
+    G = cnlti(nx.grid_2d_graph(4, 4), first_label=1, ordering="sorted")
+    paths = nx.shortest_simple_paths(G, 1, 12)
+    assert next(paths) == [1, 2, 3, 4, 8, 12]
+    assert next(paths) == [1, 5, 6, 7, 8, 12]
+    assert [len(path) for path in nx.shortest_simple_paths(G, 1, 12)] == sorted(
+        len(path) for path in nx.all_simple_paths(G, 1, 12)
+    )
+
+
+def test_shortest_simple_paths_directed():
+    G = nx.cycle_graph(7, create_using=nx.DiGraph())
+    paths = nx.shortest_simple_paths(G, 0, 3)
+    assert [path for path in paths] == [[0, 1, 2, 3]]
+
+
+def test_shortest_simple_paths_directed_with_weight_fucntion():
+    def cost(u, v, x):
+        return 1
+
+    G = cnlti(nx.grid_2d_graph(4, 4), first_label=1, ordering="sorted")
+    paths = nx.shortest_simple_paths(G, 1, 12)
+    assert next(paths) == [1, 2, 3, 4, 8, 12]
+    assert next(paths) == [1, 5, 6, 7, 8, 12]
+    assert [
+        len(path) for path in nx.shortest_simple_paths(G, 1, 12, weight=cost)
+    ] == sorted(len(path) for path in nx.all_simple_paths(G, 1, 12))
+
+
+def test_shortest_simple_paths_with_weight_fucntion():
+    def cost(u, v, x):
+        return 1
+
+    G = nx.cycle_graph(7, create_using=nx.DiGraph())
+    paths = nx.shortest_simple_paths(G, 0, 3, weight=cost)
+    assert [path for path in paths] == [[0, 1, 2, 3]]
+
+
+def test_Greg_Bernstein():
+    g1 = nx.Graph()
+    g1.add_nodes_from(["N0", "N1", "N2", "N3", "N4"])
+    g1.add_edge("N4", "N1", weight=10.0, capacity=50, name="L5")
+    g1.add_edge("N4", "N0", weight=7.0, capacity=40, name="L4")
+    g1.add_edge("N0", "N1", weight=10.0, capacity=45, name="L1")
+    g1.add_edge("N3", "N0", weight=10.0, capacity=50, name="L0")
+    g1.add_edge("N2", "N3", weight=12.0, capacity=30, name="L2")
+    g1.add_edge("N1", "N2", weight=15.0, capacity=42, name="L3")
+    solution = [["N1", "N0", "N3"], ["N1", "N2", "N3"], ["N1", "N4", "N0", "N3"]]
+    result = list(nx.shortest_simple_paths(g1, "N1", "N3", weight="weight"))
+    assert result == solution
+
+
+def test_weighted_shortest_simple_path():
+    def cost_func(path):
+        return sum(G.adj[u][v]["weight"] for (u, v) in zip(path, path[1:]))
+
+    G = nx.complete_graph(5)
+    weight = {(u, v): random.randint(1, 100) for (u, v) in G.edges()}
+    nx.set_edge_attributes(G, weight, "weight")
+    cost = 0
+    for path in nx.shortest_simple_paths(G, 0, 3, weight="weight"):
+        this_cost = cost_func(path)
+        assert cost <= this_cost
+        cost = this_cost
+
+
+def test_directed_weighted_shortest_simple_path():
+    def cost_func(path):
+        return sum(G.adj[u][v]["weight"] for (u, v) in zip(path, path[1:]))
+
+    G = nx.complete_graph(5)
+    G = G.to_directed()
+    weight = {(u, v): random.randint(1, 100) for (u, v) in G.edges()}
+    nx.set_edge_attributes(G, weight, "weight")
+    cost = 0
+    for path in nx.shortest_simple_paths(G, 0, 3, weight="weight"):
+        this_cost = cost_func(path)
+        assert cost <= this_cost
+        cost = this_cost
+
+
+def test_weighted_shortest_simple_path_issue2427():
+    G = nx.Graph()
+    G.add_edge("IN", "OUT", weight=2)
+    G.add_edge("IN", "A", weight=1)
+    G.add_edge("IN", "B", weight=2)
+    G.add_edge("B", "OUT", weight=2)
+    assert list(nx.shortest_simple_paths(G, "IN", "OUT", weight="weight")) == [
+        ["IN", "OUT"],
+        ["IN", "B", "OUT"],
+    ]
+    G = nx.Graph()
+    G.add_edge("IN", "OUT", weight=10)
+    G.add_edge("IN", "A", weight=1)
+    G.add_edge("IN", "B", weight=1)
+    G.add_edge("B", "OUT", weight=1)
+    assert list(nx.shortest_simple_paths(G, "IN", "OUT", weight="weight")) == [
+        ["IN", "B", "OUT"],
+        ["IN", "OUT"],
+    ]
+
+
+def test_directed_weighted_shortest_simple_path_issue2427():
+    G = nx.DiGraph()
+    G.add_edge("IN", "OUT", weight=2)
+    G.add_edge("IN", "A", weight=1)
+    G.add_edge("IN", "B", weight=2)
+    G.add_edge("B", "OUT", weight=2)
+    assert list(nx.shortest_simple_paths(G, "IN", "OUT", weight="weight")) == [
+        ["IN", "OUT"],
+        ["IN", "B", "OUT"],
+    ]
+    G = nx.DiGraph()
+    G.add_edge("IN", "OUT", weight=10)
+    G.add_edge("IN", "A", weight=1)
+    G.add_edge("IN", "B", weight=1)
+    G.add_edge("B", "OUT", weight=1)
+    assert list(nx.shortest_simple_paths(G, "IN", "OUT", weight="weight")) == [
+        ["IN", "B", "OUT"],
+        ["IN", "OUT"],
+    ]
+
+
+def test_weight_name():
+    G = nx.cycle_graph(7)
+    nx.set_edge_attributes(G, 1, "weight")
+    nx.set_edge_attributes(G, 1, "foo")
+    G.adj[1][2]["foo"] = 7
+    paths = list(nx.shortest_simple_paths(G, 0, 3, weight="foo"))
+    solution = [[0, 6, 5, 4, 3], [0, 1, 2, 3]]
+    assert paths == solution
+
+
+def test_ssp_source_missing():
+    with pytest.raises(nx.NodeNotFound):
+        G = nx.Graph()
+        nx.add_path(G, [1, 2, 3])
+        list(nx.shortest_simple_paths(G, 0, 3))
+
+
+def test_ssp_target_missing():
+    with pytest.raises(nx.NodeNotFound):
+        G = nx.Graph()
+        nx.add_path(G, [1, 2, 3])
+        list(nx.shortest_simple_paths(G, 1, 4))
+
+
+def test_ssp_multigraph():
+    with pytest.raises(nx.NetworkXNotImplemented):
+        G = nx.MultiGraph()
+        nx.add_path(G, [1, 2, 3])
+        list(nx.shortest_simple_paths(G, 1, 4))
+
+
+def test_ssp_source_missing2():
+    with pytest.raises(nx.NetworkXNoPath):
+        G = nx.Graph()
+        nx.add_path(G, [0, 1, 2])
+        nx.add_path(G, [3, 4, 5])
+        list(nx.shortest_simple_paths(G, 0, 3))
+
+
+def test_bidirectional_shortest_path_restricted_cycle():
+    cycle = nx.cycle_graph(7)
+    length, path = _bidirectional_shortest_path(cycle, 0, 3)
+    assert path == [0, 1, 2, 3]
+    length, path = _bidirectional_shortest_path(cycle, 0, 3, ignore_nodes=[1])
+    assert path == [0, 6, 5, 4, 3]
+
+
+def test_bidirectional_shortest_path_restricted_wheel():
+    wheel = nx.wheel_graph(6)
+    length, path = _bidirectional_shortest_path(wheel, 1, 3)
+    assert path in [[1, 0, 3], [1, 2, 3]]
+    length, path = _bidirectional_shortest_path(wheel, 1, 3, ignore_nodes=[0])
+    assert path == [1, 2, 3]
+    length, path = _bidirectional_shortest_path(wheel, 1, 3, ignore_nodes=[0, 2])
+    assert path == [1, 5, 4, 3]
+    length, path = _bidirectional_shortest_path(
+        wheel, 1, 3, ignore_edges=[(1, 0), (5, 0), (2, 3)]
+    )
+    assert path in [[1, 2, 0, 3], [1, 5, 4, 3]]
+
+
+def test_bidirectional_shortest_path_restricted_directed_cycle():
+    directed_cycle = nx.cycle_graph(7, create_using=nx.DiGraph())
+    length, path = _bidirectional_shortest_path(directed_cycle, 0, 3)
+    assert path == [0, 1, 2, 3]
+    pytest.raises(
+        nx.NetworkXNoPath,
+        _bidirectional_shortest_path,
+        directed_cycle,
+        0,
+        3,
+        ignore_nodes=[1],
+    )
+    length, path = _bidirectional_shortest_path(
+        directed_cycle, 0, 3, ignore_edges=[(2, 1)]
+    )
+    assert path == [0, 1, 2, 3]
+    pytest.raises(
+        nx.NetworkXNoPath,
+        _bidirectional_shortest_path,
+        directed_cycle,
+        0,
+        3,
+        ignore_edges=[(1, 2)],
+    )
+
+
+def test_bidirectional_shortest_path_ignore():
+    G = nx.Graph()
+    nx.add_path(G, [1, 2])
+    nx.add_path(G, [1, 3])
+    nx.add_path(G, [1, 4])
+    pytest.raises(
+        nx.NetworkXNoPath, _bidirectional_shortest_path, G, 1, 2, ignore_nodes=[1]
+    )
+    pytest.raises(
+        nx.NetworkXNoPath, _bidirectional_shortest_path, G, 1, 2, ignore_nodes=[2]
+    )
+    G = nx.Graph()
+    nx.add_path(G, [1, 3])
+    nx.add_path(G, [1, 4])
+    nx.add_path(G, [3, 2])
+    pytest.raises(
+        nx.NetworkXNoPath, _bidirectional_shortest_path, G, 1, 2, ignore_nodes=[1, 2]
+    )
+
+
+def validate_path(G, s, t, soln_len, path):
+    assert path[0] == s
+    assert path[-1] == t
+    assert soln_len == sum(
+        G[u][v].get("weight", 1) for u, v in zip(path[:-1], path[1:])
+    )
+
+
+def validate_length_path(G, s, t, soln_len, length, path):
+    assert soln_len == length
+    validate_path(G, s, t, length, path)
+
+
+def test_bidirectional_dijksta_restricted():
+    XG = nx.DiGraph()
+    XG.add_weighted_edges_from(
+        [
+            ("s", "u", 10),
+            ("s", "x", 5),
+            ("u", "v", 1),
+            ("u", "x", 2),
+            ("v", "y", 1),
+            ("x", "u", 3),
+            ("x", "v", 5),
+            ("x", "y", 2),
+            ("y", "s", 7),
+            ("y", "v", 6),
+        ]
+    )
+
+    XG3 = nx.Graph()
+    XG3.add_weighted_edges_from(
+        [[0, 1, 2], [1, 2, 12], [2, 3, 1], [3, 4, 5], [4, 5, 1], [5, 0, 10]]
+    )
+    validate_length_path(XG, "s", "v", 9, *_bidirectional_dijkstra(XG, "s", "v"))
+    validate_length_path(
+        XG, "s", "v", 10, *_bidirectional_dijkstra(XG, "s", "v", ignore_nodes=["u"])
+    )
+    validate_length_path(
+        XG,
+        "s",
+        "v",
+        11,
+        *_bidirectional_dijkstra(XG, "s", "v", ignore_edges=[("s", "x")])
+    )
+    pytest.raises(
+        nx.NetworkXNoPath,
+        _bidirectional_dijkstra,
+        XG,
+        "s",
+        "v",
+        ignore_nodes=["u"],
+        ignore_edges=[("s", "x")],
+    )
+    validate_length_path(XG3, 0, 3, 15, *_bidirectional_dijkstra(XG3, 0, 3))
+    validate_length_path(
+        XG3, 0, 3, 16, *_bidirectional_dijkstra(XG3, 0, 3, ignore_nodes=[1])
+    )
+    validate_length_path(
+        XG3, 0, 3, 16, *_bidirectional_dijkstra(XG3, 0, 3, ignore_edges=[(2, 3)])
+    )
+    pytest.raises(
+        nx.NetworkXNoPath,
+        _bidirectional_dijkstra,
+        XG3,
+        0,
+        3,
+        ignore_nodes=[1],
+        ignore_edges=[(5, 4)],
+    )
+
+
+def test_bidirectional_dijkstra_no_path():
+    with pytest.raises(nx.NetworkXNoPath):
+        G = nx.Graph()
+        nx.add_path(G, [1, 2, 3])
+        nx.add_path(G, [4, 5, 6])
+        _bidirectional_dijkstra(G, 1, 6)
+
+
+def test_bidirectional_dijkstra_ignore():
+    G = nx.Graph()
+    nx.add_path(G, [1, 2, 10])
+    nx.add_path(G, [1, 3, 10])
+    pytest.raises(nx.NetworkXNoPath, _bidirectional_dijkstra, G, 1, 2, ignore_nodes=[1])
+    pytest.raises(nx.NetworkXNoPath, _bidirectional_dijkstra, G, 1, 2, ignore_nodes=[2])
+    pytest.raises(
+        nx.NetworkXNoPath, _bidirectional_dijkstra, G, 1, 2, ignore_nodes=[1, 2]
+    )
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_smallworld.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_smallworld.py
new file mode 100644
index 0000000..42ede0e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_smallworld.py
@@ -0,0 +1,70 @@
+import pytest
+
+pytest.importorskip("numpy")
+
+import random
+
+import networkx as nx
+from networkx import lattice_reference, omega, random_reference, sigma
+
+rng = 42
+
+
+def test_random_reference():
+    G = nx.connected_watts_strogatz_graph(50, 6, 0.1, seed=rng)
+    Gr = random_reference(G, niter=1, seed=rng)
+    C = nx.average_clustering(G)
+    Cr = nx.average_clustering(Gr)
+    assert C > Cr
+
+    with pytest.raises(nx.NetworkXError):
+        next(random_reference(nx.Graph()))
+    with pytest.raises(nx.NetworkXNotImplemented):
+        next(random_reference(nx.DiGraph()))
+
+    H = nx.Graph(((0, 1), (2, 3)))
+    Hl = random_reference(H, niter=1, seed=rng)
+
+
+def test_lattice_reference():
+    G = nx.connected_watts_strogatz_graph(50, 6, 1, seed=rng)
+    Gl = lattice_reference(G, niter=1, seed=rng)
+    L = nx.average_shortest_path_length(G)
+    Ll = nx.average_shortest_path_length(Gl)
+    assert Ll > L
+
+    pytest.raises(nx.NetworkXError, lattice_reference, nx.Graph())
+    pytest.raises(nx.NetworkXNotImplemented, lattice_reference, nx.DiGraph())
+
+    H = nx.Graph(((0, 1), (2, 3)))
+    Hl = lattice_reference(H, niter=1)
+
+
+def test_sigma():
+    Gs = nx.connected_watts_strogatz_graph(50, 6, 0.1, seed=rng)
+    Gr = nx.connected_watts_strogatz_graph(50, 6, 1, seed=rng)
+    sigmas = sigma(Gs, niter=1, nrand=2, seed=rng)
+    sigmar = sigma(Gr, niter=1, nrand=2, seed=rng)
+    assert sigmar < sigmas
+
+
+def test_omega():
+    Gl = nx.connected_watts_strogatz_graph(50, 6, 0, seed=rng)
+    Gr = nx.connected_watts_strogatz_graph(50, 6, 1, seed=rng)
+    Gs = nx.connected_watts_strogatz_graph(50, 6, 0.1, seed=rng)
+    omegal = omega(Gl, niter=1, nrand=1, seed=rng)
+    omegar = omega(Gr, niter=1, nrand=1, seed=rng)
+    omegas = omega(Gs, niter=1, nrand=1, seed=rng)
+    assert omegal < omegas and omegas < omegar
+
+    # Test that omega lies within the [-1, 1] bounds
+    G_barbell = nx.barbell_graph(5, 1)
+    G_karate = nx.karate_club_graph()
+
+    omega_barbell = nx.omega(G_barbell)
+    omega_karate = nx.omega(G_karate, nrand=2)
+
+    omegas = (omegal, omegar, omegas, omega_barbell, omega_karate)
+
+    for o in omegas:
+        assert -1 <= o <= 1
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_smetric.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_smetric.py
new file mode 100644
index 0000000..b6c4570
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_smetric.py
@@ -0,0 +1,22 @@
+import pytest
+
+import networkx as nx
+
+
+def test_smetric():
+    g = nx.Graph()
+    g.add_edge(1, 2)
+    g.add_edge(2, 3)
+    g.add_edge(2, 4)
+    g.add_edge(1, 4)
+    sm = nx.s_metric(g, normalized=False)
+    assert sm == 19.0
+
+
+#    smNorm = nx.s_metric(g,normalized=True)
+#    assert_equal(smNorm, 0.95)
+
+
+def test_normalized():
+    with pytest.raises(nx.NetworkXError):
+        sm = nx.s_metric(nx.Graph(), normalized=True)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_sparsifiers.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_sparsifiers.py
new file mode 100644
index 0000000..78cabce
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_sparsifiers.py
@@ -0,0 +1,137 @@
+"""Unit tests for the sparsifier computation functions."""
+import pytest
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+_seed = 2
+
+
+def _test_spanner(G, spanner, stretch, weight=None):
+    """Test whether a spanner is valid.
+
+    This function tests whether the given spanner is a subgraph of the
+    given graph G with the same node set. It also tests for all shortest
+    paths whether they adhere to the given stretch.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The original graph for which the spanner was constructed.
+
+    spanner : NetworkX graph
+        The spanner to be tested.
+
+    stretch : float
+        The proclaimed stretch of the spanner.
+
+    weight : object
+        The edge attribute to use as distance.
+    """
+    # check node set
+    assert set(G.nodes()) == set(spanner.nodes())
+
+    # check edge set and weights
+    for u, v in spanner.edges():
+        assert G.has_edge(u, v)
+        if weight:
+            assert spanner[u][v][weight] == G[u][v][weight]
+
+    # check connectivity and stretch
+    original_length = dict(nx.shortest_path_length(G, weight=weight))
+    spanner_length = dict(nx.shortest_path_length(spanner, weight=weight))
+    for u in G.nodes():
+        for v in G.nodes():
+            if u in original_length and v in original_length[u]:
+                assert spanner_length[u][v] <= stretch * original_length[u][v]
+
+
+@py_random_state(1)
+def _assign_random_weights(G, seed=None):
+    """Assigns random weights to the edges of a graph.
+
+    Parameters
+    ----------
+
+    G : NetworkX graph
+        The original graph for which the spanner was constructed.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    """
+    for u, v in G.edges():
+        G[u][v]["weight"] = seed.random()
+
+
+def test_spanner_trivial():
+    """Test a trivial spanner with stretch 1."""
+    G = nx.complete_graph(20)
+    spanner = nx.spanner(G, 1, seed=_seed)
+
+    for u, v in G.edges:
+        assert spanner.has_edge(u, v)
+
+
+def test_spanner_unweighted_complete_graph():
+    """Test spanner construction on a complete unweighted graph."""
+    G = nx.complete_graph(20)
+
+    spanner = nx.spanner(G, 4, seed=_seed)
+    _test_spanner(G, spanner, 4)
+
+    spanner = nx.spanner(G, 10, seed=_seed)
+    _test_spanner(G, spanner, 10)
+
+
+def test_spanner_weighted_complete_graph():
+    """Test spanner construction on a complete weighted graph."""
+    G = nx.complete_graph(20)
+    _assign_random_weights(G, seed=_seed)
+
+    spanner = nx.spanner(G, 4, weight="weight", seed=_seed)
+    _test_spanner(G, spanner, 4, weight="weight")
+
+    spanner = nx.spanner(G, 10, weight="weight", seed=_seed)
+    _test_spanner(G, spanner, 10, weight="weight")
+
+
+def test_spanner_unweighted_gnp_graph():
+    """Test spanner construction on an unweighted gnp graph."""
+    G = nx.gnp_random_graph(20, 0.4, seed=_seed)
+
+    spanner = nx.spanner(G, 4, seed=_seed)
+    _test_spanner(G, spanner, 4)
+
+    spanner = nx.spanner(G, 10, seed=_seed)
+    _test_spanner(G, spanner, 10)
+
+
+def test_spanner_weighted_gnp_graph():
+    """Test spanner construction on an weighted gnp graph."""
+    G = nx.gnp_random_graph(20, 0.4, seed=_seed)
+    _assign_random_weights(G, seed=_seed)
+
+    spanner = nx.spanner(G, 4, weight="weight", seed=_seed)
+    _test_spanner(G, spanner, 4, weight="weight")
+
+    spanner = nx.spanner(G, 10, weight="weight", seed=_seed)
+    _test_spanner(G, spanner, 10, weight="weight")
+
+
+def test_spanner_unweighted_disconnected_graph():
+    """Test spanner construction on a disconnected graph."""
+    G = nx.disjoint_union(nx.complete_graph(10), nx.complete_graph(10))
+
+    spanner = nx.spanner(G, 4, seed=_seed)
+    _test_spanner(G, spanner, 4)
+
+    spanner = nx.spanner(G, 10, seed=_seed)
+    _test_spanner(G, spanner, 10)
+
+
+def test_spanner_invalid_stretch():
+    """Check whether an invalid stretch is caught."""
+    with pytest.raises(ValueError):
+        G = nx.empty_graph()
+        nx.spanner(G, 0)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_structuralholes.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_structuralholes.py
new file mode 100644
index 0000000..53a4e88
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_structuralholes.py
@@ -0,0 +1,135 @@
+"""Unit tests for the :mod:`networkx.algorithms.structuralholes` module."""
+import math
+
+import pytest
+
+import networkx as nx
+
+
+class TestStructuralHoles:
+    """Unit tests for computing measures of structural holes.
+
+    The expected values for these functions were originally computed using the
+    proprietary software `UCINET`_ and the free software `IGraph`_ , and then
+    computed by hand to make sure that the results are correct.
+
+    .. _UCINET: https://sites.google.com/site/ucinetsoftware/home
+    .. _IGraph: http://igraph.org/
+
+    """
+
+    def setup(self):
+        self.D = nx.DiGraph()
+        self.D.add_edges_from([(0, 1), (0, 2), (1, 0), (2, 1)])
+        self.D_weights = {(0, 1): 2, (0, 2): 2, (1, 0): 1, (2, 1): 1}
+        # Example from http://www.analytictech.com/connections/v20(1)/holes.htm
+        self.G = nx.Graph()
+        self.G.add_edges_from(
+            [
+                ("A", "B"),
+                ("A", "F"),
+                ("A", "G"),
+                ("A", "E"),
+                ("E", "G"),
+                ("F", "G"),
+                ("B", "G"),
+                ("B", "D"),
+                ("D", "G"),
+                ("G", "C"),
+            ]
+        )
+        self.G_weights = {
+            ("A", "B"): 2,
+            ("A", "F"): 3,
+            ("A", "G"): 5,
+            ("A", "E"): 2,
+            ("E", "G"): 8,
+            ("F", "G"): 3,
+            ("B", "G"): 4,
+            ("B", "D"): 1,
+            ("D", "G"): 3,
+            ("G", "C"): 10,
+        }
+
+    def test_constraint_directed(self):
+        constraint = nx.constraint(self.D)
+        assert constraint[0] == pytest.approx(1.003, abs=1e-3)
+        assert constraint[1] == pytest.approx(1.003, abs=1e-3)
+        assert constraint[2] == pytest.approx(1.389, abs=1e-3)
+
+    def test_effective_size_directed(self):
+        effective_size = nx.effective_size(self.D)
+        assert effective_size[0] == pytest.approx(1.167, abs=1e-3)
+        assert effective_size[1] == pytest.approx(1.167, abs=1e-3)
+        assert effective_size[2] == pytest.approx(1, abs=1e-3)
+
+    def test_constraint_weighted_directed(self):
+        D = self.D.copy()
+        nx.set_edge_attributes(D, self.D_weights, "weight")
+        constraint = nx.constraint(D, weight="weight")
+        assert constraint[0] == pytest.approx(0.840, abs=1e-3)
+        assert constraint[1] == pytest.approx(1.143, abs=1e-3)
+        assert constraint[2] == pytest.approx(1.378, abs=1e-3)
+
+    def test_effective_size_weighted_directed(self):
+        D = self.D.copy()
+        nx.set_edge_attributes(D, self.D_weights, "weight")
+        effective_size = nx.effective_size(D, weight="weight")
+        assert effective_size[0] == pytest.approx(1.567, abs=1e-3)
+        assert effective_size[1] == pytest.approx(1.083, abs=1e-3)
+        assert effective_size[2] == pytest.approx(1, abs=1e-3)
+
+    def test_constraint_undirected(self):
+        constraint = nx.constraint(self.G)
+        assert constraint["G"] == pytest.approx(0.400, abs=1e-3)
+        assert constraint["A"] == pytest.approx(0.595, abs=1e-3)
+        assert constraint["C"] == pytest.approx(1, abs=1e-3)
+
+    def test_effective_size_undirected_borgatti(self):
+        effective_size = nx.effective_size(self.G)
+        assert effective_size["G"] == pytest.approx(4.67, abs=1e-2)
+        assert effective_size["A"] == pytest.approx(2.50, abs=1e-2)
+        assert effective_size["C"] == pytest.approx(1, abs=1e-2)
+
+    def test_effective_size_undirected(self):
+        G = self.G.copy()
+        nx.set_edge_attributes(G, 1, "weight")
+        effective_size = nx.effective_size(G, weight="weight")
+        assert effective_size["G"] == pytest.approx(4.67, abs=1e-2)
+        assert effective_size["A"] == pytest.approx(2.50, abs=1e-2)
+        assert effective_size["C"] == pytest.approx(1, abs=1e-2)
+
+    def test_constraint_weighted_undirected(self):
+        G = self.G.copy()
+        nx.set_edge_attributes(G, self.G_weights, "weight")
+        constraint = nx.constraint(G, weight="weight")
+        assert constraint["G"] == pytest.approx(0.299, abs=1e-3)
+        assert constraint["A"] == pytest.approx(0.795, abs=1e-3)
+        assert constraint["C"] == pytest.approx(1, abs=1e-3)
+
+    def test_effective_size_weighted_undirected(self):
+        G = self.G.copy()
+        nx.set_edge_attributes(G, self.G_weights, "weight")
+        effective_size = nx.effective_size(G, weight="weight")
+        assert effective_size["G"] == pytest.approx(5.47, abs=1e-2)
+        assert effective_size["A"] == pytest.approx(2.47, abs=1e-2)
+        assert effective_size["C"] == pytest.approx(1, abs=1e-2)
+
+    def test_constraint_isolated(self):
+        G = self.G.copy()
+        G.add_node(1)
+        constraint = nx.constraint(G)
+        assert math.isnan(constraint[1])
+
+    def test_effective_size_isolated(self):
+        G = self.G.copy()
+        G.add_node(1)
+        nx.set_edge_attributes(G, self.G_weights, "weight")
+        effective_size = nx.effective_size(G, weight="weight")
+        assert math.isnan(effective_size[1])
+
+    def test_effective_size_borgatti_isolated(self):
+        G = self.G.copy()
+        G.add_node(1)
+        effective_size = nx.effective_size(G)
+        assert math.isnan(effective_size[1])
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_summarization.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_summarization.py
new file mode 100644
index 0000000..c951b86
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_summarization.py
@@ -0,0 +1,641 @@
+"""
+Unit tests for dedensification and graph summarization
+"""
+import pytest
+
+import networkx as nx
+
+
+class TestDirectedDedensification:
+    def build_original_graph(self):
+        original_matrix = [
+            ("1", "BC"),
+            ("2", "ABC"),
+            ("3", ["A", "B", "6"]),
+            ("4", "ABC"),
+            ("5", "AB"),
+            ("6", ["5"]),
+            ("A", ["6"]),
+        ]
+        graph = nx.DiGraph()
+        for source, targets in original_matrix:
+            for target in targets:
+                graph.add_edge(source, target)
+        return graph
+
+    def build_compressed_graph(self):
+        compressed_matrix = [
+            ("1", "BC"),
+            ("2", ["ABC"]),
+            ("3", ["A", "B", "6"]),
+            ("4", ["ABC"]),
+            ("5", "AB"),
+            ("6", ["5"]),
+            ("A", ["6"]),
+            ("ABC", "ABC"),
+        ]
+        compressed_graph = nx.DiGraph()
+        for source, targets in compressed_matrix:
+            for target in targets:
+                compressed_graph.add_edge(source, target)
+        return compressed_graph
+
+    def test_empty(self):
+        """
+        Verify that an empty directed graph results in no compressor nodes
+        """
+        G = nx.DiGraph()
+        compressed_graph, c_nodes = nx.dedensify(G, threshold=2)
+        assert c_nodes == set()
+
+    @staticmethod
+    def densify(G, compressor_nodes, copy=True):
+        """
+        Reconstructs the original graph from a dedensified, directed graph
+
+        Parameters
+        ----------
+        G: dedensified graph
+           A networkx graph
+        compressor_nodes: iterable
+           Iterable of compressor nodes in the dedensified graph
+        inplace: bool, optional (default: False)
+           Indicates if densification should be done inplace
+
+        Returns
+        -------
+        G: graph
+           A densified networkx graph
+        """
+        if copy:
+            G = G.copy()
+        for compressor_node in compressor_nodes:
+            all_neighbors = set(nx.all_neighbors(G, compressor_node))
+            out_neighbors = set(G.neighbors(compressor_node))
+            for out_neighbor in out_neighbors:
+                G.remove_edge(compressor_node, out_neighbor)
+            in_neighbors = all_neighbors - out_neighbors
+            for in_neighbor in in_neighbors:
+                G.remove_edge(in_neighbor, compressor_node)
+                for out_neighbor in out_neighbors:
+                    G.add_edge(in_neighbor, out_neighbor)
+            G.remove_node(compressor_node)
+        return G
+
+    def setup_method(self):
+        self.c_nodes = ("ABC",)
+
+    def test_dedensify_edges(self):
+        """
+        Verifies that dedensify produced the correct edges to/from compressor
+        nodes in a directed graph
+        """
+        G = self.build_original_graph()
+        compressed_G = self.build_compressed_graph()
+        compressed_graph, c_nodes = nx.dedensify(G, threshold=2)
+        for s, t in compressed_graph.edges():
+            o_s = "".join(sorted(s))
+            o_t = "".join(sorted(t))
+            compressed_graph_exists = compressed_graph.has_edge(s, t)
+            verified_compressed_exists = compressed_G.has_edge(o_s, o_t)
+            assert compressed_graph_exists == verified_compressed_exists
+        assert len(c_nodes) == len(self.c_nodes)
+
+    def test_dedensify_edge_count(self):
+        """
+        Verifies that dedensify produced the correct number of comrpessor nodes
+        in a directed graph
+        """
+        G = self.build_original_graph()
+        original_edge_count = len(G.edges())
+        c_G, c_nodes = nx.dedensify(G, threshold=2)
+        compressed_edge_count = len(c_G.edges())
+        assert compressed_edge_count <= original_edge_count
+        compressed_G = self.build_compressed_graph()
+        assert compressed_edge_count == len(compressed_G.edges())
+
+    def test_densify_edges(self):
+        """
+        Verifies that densification produces the correct edges from the
+        original directed graph
+        """
+        compressed_G = self.build_compressed_graph()
+        original_graph = self.densify(compressed_G, self.c_nodes, copy=True)
+        G = self.build_original_graph()
+        for s, t in G.edges():
+            assert G.has_edge(s, t) == original_graph.has_edge(s, t)
+
+    def test_densify_edge_count(self):
+        """
+        Verifies that densification produces the correct number of edges in the
+        original directed graph
+        """
+        compressed_G = self.build_compressed_graph()
+        compressed_edge_count = len(compressed_G.edges())
+        original_graph = self.densify(compressed_G, self.c_nodes)
+        original_edge_count = len(original_graph.edges())
+        assert compressed_edge_count <= original_edge_count
+        G = self.build_original_graph()
+        assert original_edge_count == len(G.edges())
+
+
+class TestUnDirectedDedensification:
+    def build_original_graph(self):
+        """
+        Builds graph shown in the original research paper
+        """
+        original_matrix = [
+            ("1", "CB"),
+            ("2", "ABC"),
+            ("3", ["A", "B", "6"]),
+            ("4", "ABC"),
+            ("5", "AB"),
+            ("6", ["5"]),
+            ("A", ["6"]),
+        ]
+        graph = nx.Graph()
+        for source, targets in original_matrix:
+            for target in targets:
+                graph.add_edge(source, target)
+        return graph
+
+    def test_empty(self):
+        """
+        Verify that an empty undirected graph results in no compressor nodes
+        """
+        G = nx.Graph()
+        compressed_G, c_nodes = nx.dedensify(G, threshold=2)
+        assert c_nodes == set()
+
+    def setup_method(self):
+        self.c_nodes = ("6AB", "ABC")
+
+    def build_compressed_graph(self):
+        compressed_matrix = [
+            ("1", ["B", "C"]),
+            ("2", ["ABC"]),
+            ("3", ["6AB"]),
+            ("4", ["ABC"]),
+            ("5", ["6AB"]),
+            ("6", ["6AB", "A"]),
+            ("A", ["6AB", "ABC"]),
+            ("B", ["ABC", "6AB"]),
+            ("C", ["ABC"]),
+        ]
+        compressed_graph = nx.Graph()
+        for source, targets in compressed_matrix:
+            for target in targets:
+                compressed_graph.add_edge(source, target)
+        return compressed_graph
+
+    def test_dedensify_edges(self):
+        """
+        Verifies that dedensify produced correct compressor nodes and the
+        correct edges to/from the compressor nodes in an undirected graph
+        """
+        G = self.build_original_graph()
+        c_G, c_nodes = nx.dedensify(G, threshold=2)
+        v_compressed_G = self.build_compressed_graph()
+        for s, t in c_G.edges():
+            o_s = "".join(sorted(s))
+            o_t = "".join(sorted(t))
+            has_compressed_edge = c_G.has_edge(s, t)
+            verified_has_compressed_edge = v_compressed_G.has_edge(o_s, o_t)
+            assert has_compressed_edge == verified_has_compressed_edge
+        assert len(c_nodes) == len(self.c_nodes)
+
+    def test_dedensify_edge_count(self):
+        """
+        Verifies that dedensify produced the correct number of edges in an
+        undirected graph
+        """
+        G = self.build_original_graph()
+        c_G, c_nodes = nx.dedensify(G, threshold=2, copy=True)
+        compressed_edge_count = len(c_G.edges())
+        verified_original_edge_count = len(G.edges())
+        assert compressed_edge_count <= verified_original_edge_count
+        verified_compressed_G = self.build_compressed_graph()
+        verified_compressed_edge_count = len(verified_compressed_G.edges())
+        assert compressed_edge_count == verified_compressed_edge_count
+
+
+@pytest.mark.parametrize(
+    "graph_type", [nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph]
+)
+def test_summarization_empty(graph_type):
+    G = graph_type()
+    summary_graph = nx.snap_aggregation(G, node_attributes=("color",))
+    assert nx.is_isomorphic(summary_graph, G)
+
+
+class AbstractSNAP:
+    node_attributes = ("color",)
+
+    def build_original_graph(self):
+        pass
+
+    def build_summary_graph(self):
+        pass
+
+    def test_summary_graph(self):
+        original_graph = self.build_original_graph()
+        summary_graph = self.build_summary_graph()
+
+        relationship_attributes = ("type",)
+        generated_summary_graph = nx.snap_aggregation(
+            original_graph, self.node_attributes, relationship_attributes
+        )
+        relabeled_summary_graph = self.deterministic_labels(generated_summary_graph)
+        assert nx.is_isomorphic(summary_graph, relabeled_summary_graph)
+
+    def deterministic_labels(self, G):
+        node_labels = list(G.nodes)
+        node_labels = sorted(node_labels, key=lambda n: sorted(G.nodes[n]["group"])[0])
+        node_labels.sort()
+
+        label_mapping = dict()
+        for index, node in enumerate(node_labels):
+            label = "Supernode-%s" % index
+            label_mapping[node] = label
+
+        return nx.relabel_nodes(G, label_mapping)
+
+
+class TestSNAPNoEdgeTypes(AbstractSNAP):
+    relationship_attributes = ()
+
+    def test_summary_graph(self):
+        original_graph = self.build_original_graph()
+        summary_graph = self.build_summary_graph()
+
+        relationship_attributes = ("type",)
+        generated_summary_graph = nx.snap_aggregation(
+            original_graph, self.node_attributes
+        )
+        relabeled_summary_graph = self.deterministic_labels(generated_summary_graph)
+        assert nx.is_isomorphic(summary_graph, relabeled_summary_graph)
+
+    def build_original_graph(self):
+        nodes = {
+            "A": dict(color="Red"),
+            "B": dict(color="Red"),
+            "C": dict(color="Red"),
+            "D": dict(color="Red"),
+            "E": dict(color="Blue"),
+            "F": dict(color="Blue"),
+            "G": dict(color="Blue"),
+            "H": dict(color="Blue"),
+            "I": dict(color="Yellow"),
+            "J": dict(color="Yellow"),
+            "K": dict(color="Yellow"),
+            "L": dict(color="Yellow"),
+        }
+        edges = [
+            ("A", "B"),
+            ("A", "C"),
+            ("A", "E"),
+            ("A", "I"),
+            ("B", "D"),
+            ("B", "J"),
+            ("B", "F"),
+            ("C", "G"),
+            ("D", "H"),
+            ("I", "J"),
+            ("J", "K"),
+            ("I", "L"),
+        ]
+        G = nx.Graph()
+        for node in nodes:
+            attributes = nodes[node]
+            G.add_node(node, **attributes)
+
+        for source, target in edges:
+            G.add_edge(source, target)
+
+        return G
+
+    def build_summary_graph(self):
+        nodes = {
+            "Supernode-0": dict(color="Red"),
+            "Supernode-1": dict(color="Red"),
+            "Supernode-2": dict(color="Blue"),
+            "Supernode-3": dict(color="Blue"),
+            "Supernode-4": dict(color="Yellow"),
+            "Supernode-5": dict(color="Yellow"),
+        }
+        edges = [
+            ("Supernode-0", "Supernode-0"),
+            ("Supernode-0", "Supernode-1"),
+            ("Supernode-0", "Supernode-2"),
+            ("Supernode-0", "Supernode-4"),
+            ("Supernode-1", "Supernode-3"),
+            ("Supernode-4", "Supernode-4"),
+            ("Supernode-4", "Supernode-5"),
+        ]
+        G = nx.Graph()
+        for node in nodes:
+            attributes = nodes[node]
+            G.add_node(node, **attributes)
+
+        for source, target in edges:
+            G.add_edge(source, target)
+
+        supernodes = {
+            "Supernode-0": {"A", "B"},
+            "Supernode-1": {"C", "D"},
+            "Supernode-2": {"E", "F"},
+            "Supernode-3": {"G", "H"},
+            "Supernode-4": {"I", "J"},
+            "Supernode-5": {"K", "L"},
+        }
+        nx.set_node_attributes(G, supernodes, "group")
+        return G
+
+
+class TestSNAPUndirected(AbstractSNAP):
+    def build_original_graph(self):
+        nodes = {
+            "A": dict(color="Red"),
+            "B": dict(color="Red"),
+            "C": dict(color="Red"),
+            "D": dict(color="Red"),
+            "E": dict(color="Blue"),
+            "F": dict(color="Blue"),
+            "G": dict(color="Blue"),
+            "H": dict(color="Blue"),
+            "I": dict(color="Yellow"),
+            "J": dict(color="Yellow"),
+            "K": dict(color="Yellow"),
+            "L": dict(color="Yellow"),
+        }
+        edges = [
+            ("A", "B", "Strong"),
+            ("A", "C", "Weak"),
+            ("A", "E", "Strong"),
+            ("A", "I", "Weak"),
+            ("B", "D", "Weak"),
+            ("B", "J", "Weak"),
+            ("B", "F", "Strong"),
+            ("C", "G", "Weak"),
+            ("D", "H", "Weak"),
+            ("I", "J", "Strong"),
+            ("J", "K", "Strong"),
+            ("I", "L", "Strong"),
+        ]
+        G = nx.Graph()
+        for node in nodes:
+            attributes = nodes[node]
+            G.add_node(node, **attributes)
+
+        for source, target, type in edges:
+            G.add_edge(source, target, type=type)
+
+        return G
+
+    def build_summary_graph(self):
+        nodes = {
+            "Supernode-0": dict(color="Red"),
+            "Supernode-1": dict(color="Red"),
+            "Supernode-2": dict(color="Blue"),
+            "Supernode-3": dict(color="Blue"),
+            "Supernode-4": dict(color="Yellow"),
+            "Supernode-5": dict(color="Yellow"),
+        }
+        edges = [
+            ("Supernode-0", "Supernode-0", "Strong"),
+            ("Supernode-0", "Supernode-1", "Weak"),
+            ("Supernode-0", "Supernode-2", "Strong"),
+            ("Supernode-0", "Supernode-4", "Weak"),
+            ("Supernode-1", "Supernode-3", "Weak"),
+            ("Supernode-4", "Supernode-4", "Strong"),
+            ("Supernode-4", "Supernode-5", "Strong"),
+        ]
+        G = nx.Graph()
+        for node in nodes:
+            attributes = nodes[node]
+            G.add_node(node, **attributes)
+
+        for source, target, type in edges:
+            G.add_edge(source, target, types=[dict(type=type)])
+
+        supernodes = {
+            "Supernode-0": {"A", "B"},
+            "Supernode-1": {"C", "D"},
+            "Supernode-2": {"E", "F"},
+            "Supernode-3": {"G", "H"},
+            "Supernode-4": {"I", "J"},
+            "Supernode-5": {"K", "L"},
+        }
+        nx.set_node_attributes(G, supernodes, "group")
+        return G
+
+
+class TestSNAPDirected(AbstractSNAP):
+    def build_original_graph(self):
+        nodes = {
+            "A": dict(color="Red"),
+            "B": dict(color="Red"),
+            "C": dict(color="Green"),
+            "D": dict(color="Green"),
+            "E": dict(color="Blue"),
+            "F": dict(color="Blue"),
+            "G": dict(color="Yellow"),
+            "H": dict(color="Yellow"),
+        }
+        edges = [
+            ("A", "C", "Strong"),
+            ("A", "E", "Strong"),
+            ("A", "F", "Weak"),
+            ("B", "D", "Strong"),
+            ("B", "E", "Weak"),
+            ("B", "F", "Strong"),
+            ("C", "G", "Strong"),
+            ("C", "F", "Strong"),
+            ("D", "E", "Strong"),
+            ("D", "H", "Strong"),
+            ("G", "E", "Strong"),
+            ("H", "F", "Strong"),
+        ]
+        G = nx.DiGraph()
+        for node in nodes:
+            attributes = nodes[node]
+            G.add_node(node, **attributes)
+
+        for source, target, type in edges:
+            G.add_edge(source, target, type=type)
+
+        return G
+
+    def build_summary_graph(self):
+        nodes = {
+            "Supernode-0": dict(color="Red"),
+            "Supernode-1": dict(color="Green"),
+            "Supernode-2": dict(color="Blue"),
+            "Supernode-3": dict(color="Yellow"),
+        }
+        edges = [
+            ("Supernode-0", "Supernode-1", [{"type": "Strong"}]),
+            ("Supernode-0", "Supernode-2", [{"type": "Weak"}, {"type": "Strong"}]),
+            ("Supernode-1", "Supernode-2", [{"type": "Strong"}]),
+            ("Supernode-1", "Supernode-3", [{"type": "Strong"}]),
+            ("Supernode-3", "Supernode-2", [{"type": "Strong"}]),
+        ]
+        G = nx.DiGraph()
+        for node in nodes:
+            attributes = nodes[node]
+            G.add_node(node, **attributes)
+
+        for source, target, types in edges:
+            G.add_edge(source, target, types=types)
+
+        supernodes = {
+            "Supernode-0": {"A", "B"},
+            "Supernode-1": {"C", "D"},
+            "Supernode-2": {"E", "F"},
+            "Supernode-3": {"G", "H"},
+            "Supernode-4": {"I", "J"},
+            "Supernode-5": {"K", "L"},
+        }
+        nx.set_node_attributes(G, supernodes, "group")
+        return G
+
+
+class TestSNAPUndirectedMulti(AbstractSNAP):
+    def build_original_graph(self):
+        nodes = {
+            "A": dict(color="Red"),
+            "B": dict(color="Red"),
+            "C": dict(color="Red"),
+            "D": dict(color="Blue"),
+            "E": dict(color="Blue"),
+            "F": dict(color="Blue"),
+            "G": dict(color="Yellow"),
+            "H": dict(color="Yellow"),
+            "I": dict(color="Yellow"),
+        }
+        edges = [
+            ("A", "D", ["Weak", "Strong"]),
+            ("B", "E", ["Weak", "Strong"]),
+            ("D", "I", ["Strong"]),
+            ("E", "H", ["Strong"]),
+            ("F", "G", ["Weak"]),
+            ("I", "G", ["Weak", "Strong"]),
+            ("I", "H", ["Weak", "Strong"]),
+            ("G", "H", ["Weak", "Strong"]),
+        ]
+        G = nx.MultiGraph()
+        for node in nodes:
+            attributes = nodes[node]
+            G.add_node(node, **attributes)
+
+        for source, target, types in edges:
+            for type in types:
+                G.add_edge(source, target, type=type)
+
+        return G
+
+    def build_summary_graph(self):
+        nodes = {
+            "Supernode-0": dict(color="Red"),
+            "Supernode-1": dict(color="Blue"),
+            "Supernode-2": dict(color="Yellow"),
+            "Supernode-3": dict(color="Blue"),
+            "Supernode-4": dict(color="Yellow"),
+            "Supernode-5": dict(color="Red"),
+        }
+        edges = [
+            ("Supernode-1", "Supernode-2", [{"type": "Weak"}]),
+            ("Supernode-2", "Supernode-4", [{"type": "Weak"}, {"type": "Strong"}]),
+            ("Supernode-3", "Supernode-4", [{"type": "Strong"}]),
+            ("Supernode-3", "Supernode-5", [{"type": "Weak"}, {"type": "Strong"}]),
+            ("Supernode-4", "Supernode-4", [{"type": "Weak"}, {"type": "Strong"}]),
+        ]
+        G = nx.MultiGraph()
+        for node in nodes:
+            attributes = nodes[node]
+            G.add_node(node, **attributes)
+
+        for source, target, types in edges:
+            for type in types:
+                G.add_edge(source, target, type=type)
+
+        supernodes = {
+            "Supernode-0": {"A", "B"},
+            "Supernode-1": {"C", "D"},
+            "Supernode-2": {"E", "F"},
+            "Supernode-3": {"G", "H"},
+            "Supernode-4": {"I", "J"},
+            "Supernode-5": {"K", "L"},
+        }
+        nx.set_node_attributes(G, supernodes, "group")
+        return G
+
+
+class TestSNAPDirectedMulti(AbstractSNAP):
+    def build_original_graph(self):
+        nodes = {
+            "A": dict(color="Red"),
+            "B": dict(color="Red"),
+            "C": dict(color="Green"),
+            "D": dict(color="Green"),
+            "E": dict(color="Blue"),
+            "F": dict(color="Blue"),
+            "G": dict(color="Yellow"),
+            "H": dict(color="Yellow"),
+        }
+        edges = [
+            ("A", "C", ["Weak", "Strong"]),
+            ("A", "E", ["Strong"]),
+            ("A", "F", ["Weak"]),
+            ("B", "D", ["Weak", "Strong"]),
+            ("B", "E", ["Weak"]),
+            ("B", "F", ["Strong"]),
+            ("C", "G", ["Weak", "Strong"]),
+            ("C", "F", ["Strong"]),
+            ("D", "E", ["Strong"]),
+            ("D", "H", ["Weak", "Strong"]),
+            ("G", "E", ["Strong"]),
+            ("H", "F", ["Strong"]),
+        ]
+        G = nx.MultiDiGraph()
+        for node in nodes:
+            attributes = nodes[node]
+            G.add_node(node, **attributes)
+
+        for source, target, types in edges:
+            for type in types:
+                G.add_edge(source, target, type=type)
+
+        return G
+
+    def build_summary_graph(self):
+        nodes = {
+            "Supernode-0": dict(color="Red"),
+            "Supernode-1": dict(color="Blue"),
+            "Supernode-2": dict(color="Yellow"),
+            "Supernode-3": dict(color="Blue"),
+        }
+        edges = [
+            ("Supernode-0", "Supernode-1", ["Weak", "Strong"]),
+            ("Supernode-0", "Supernode-2", ["Weak", "Strong"]),
+            ("Supernode-1", "Supernode-2", ["Strong"]),
+            ("Supernode-1", "Supernode-3", ["Weak", "Strong"]),
+            ("Supernode-3", "Supernode-2", ["Strong"]),
+        ]
+        G = nx.MultiDiGraph()
+        for node in nodes:
+            attributes = nodes[node]
+            G.add_node(node, **attributes)
+
+        for source, target, types in edges:
+            for type in types:
+                G.add_edge(source, target, type=type)
+
+        supernodes = {
+            "Supernode-0": {"A", "B"},
+            "Supernode-1": {"C", "D"},
+            "Supernode-2": {"E", "F"},
+            "Supernode-3": {"G", "H"},
+        }
+        nx.set_node_attributes(G, supernodes, "group")
+        return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_swap.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_swap.py
new file mode 100644
index 0000000..9982b95
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_swap.py
@@ -0,0 +1,94 @@
+import pytest
+
+import networkx as nx
+
+# import random
+# random.seed(0)
+
+
+def test_double_edge_swap():
+    graph = nx.barabasi_albert_graph(200, 1)
+    degrees = sorted(d for n, d in graph.degree())
+    G = nx.double_edge_swap(graph, 40)
+    assert degrees == sorted(d for n, d in graph.degree())
+
+
+def test_double_edge_swap_seed():
+    graph = nx.barabasi_albert_graph(200, 1)
+    degrees = sorted(d for n, d in graph.degree())
+    G = nx.double_edge_swap(graph, 40, seed=1)
+    assert degrees == sorted(d for n, d in graph.degree())
+
+
+def test_connected_double_edge_swap():
+    graph = nx.barabasi_albert_graph(200, 1)
+    degrees = sorted(d for n, d in graph.degree())
+    G = nx.connected_double_edge_swap(graph, 40, seed=1)
+    assert nx.is_connected(graph)
+    assert degrees == sorted(d for n, d in graph.degree())
+
+
+def test_connected_double_edge_swap_low_window_threshold():
+    graph = nx.barabasi_albert_graph(200, 1)
+    degrees = sorted(d for n, d in graph.degree())
+    G = nx.connected_double_edge_swap(graph, 40, _window_threshold=0, seed=1)
+    assert nx.is_connected(graph)
+    assert degrees == sorted(d for n, d in graph.degree())
+
+
+def test_connected_double_edge_swap_star():
+    # Testing ui==xi in connected_double_edge_swap
+    graph = nx.star_graph(40)
+    degrees = sorted(d for n, d in graph.degree())
+    G = nx.connected_double_edge_swap(graph, 1, seed=4)
+    assert nx.is_connected(graph)
+    assert degrees == sorted(d for n, d in graph.degree())
+
+
+def test_connected_double_edge_swap_star_low_window_threshold():
+    # Testing ui==xi in connected_double_edge_swap with low window threshold
+    graph = nx.star_graph(40)
+    degrees = sorted(d for n, d in graph.degree())
+    G = nx.connected_double_edge_swap(graph, 1, _window_threshold=0, seed=4)
+    assert nx.is_connected(graph)
+    assert degrees == sorted(d for n, d in graph.degree())
+
+
+def test_double_edge_swap_small():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.double_edge_swap(nx.path_graph(3))
+
+
+def test_double_edge_swap_tries():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.double_edge_swap(nx.path_graph(10), nswap=1, max_tries=0)
+
+
+def test_double_edge_directed():
+    graph = nx.DiGraph([(0, 1), (2, 3)])
+    with pytest.raises(nx.NetworkXError, match="not defined for directed graphs."):
+        G = nx.double_edge_swap(graph)
+
+
+def test_double_edge_max_tries():
+    with pytest.raises(nx.NetworkXAlgorithmError):
+        G = nx.double_edge_swap(nx.complete_graph(4), nswap=1, max_tries=5)
+
+
+def test_connected_double_edge_swap_small():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.connected_double_edge_swap(nx.path_graph(3))
+
+
+def test_connected_double_edge_swap_not_connected():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.path_graph(3)
+        nx.add_path(G, [10, 11, 12])
+        G = nx.connected_double_edge_swap(G)
+
+
+def test_degree_seq_c4():
+    G = nx.cycle_graph(4)
+    degrees = sorted(d for n, d in G.degree())
+    G = nx.double_edge_swap(G, 1, 100)
+    assert degrees == sorted(d for n, d in G.degree())
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_threshold.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_threshold.py
new file mode 100644
index 0000000..c06784a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_threshold.py
@@ -0,0 +1,269 @@
+"""
+Threshold Graphs
+================
+"""
+
+import pytest
+
+import networkx as nx
+import networkx.algorithms.threshold as nxt
+from networkx.algorithms.isomorphism.isomorph import graph_could_be_isomorphic
+
+cnlti = nx.convert_node_labels_to_integers
+
+
+class TestGeneratorThreshold:
+    def test_threshold_sequence_graph_test(self):
+        G = nx.star_graph(10)
+        assert nxt.is_threshold_graph(G)
+        assert nxt.is_threshold_sequence(list(d for n, d in G.degree()))
+
+        G = nx.complete_graph(10)
+        assert nxt.is_threshold_graph(G)
+        assert nxt.is_threshold_sequence(list(d for n, d in G.degree()))
+
+        deg = [3, 2, 2, 1, 1, 1]
+        assert not nxt.is_threshold_sequence(deg)
+
+        deg = [3, 2, 2, 1]
+        assert nxt.is_threshold_sequence(deg)
+
+        G = nx.generators.havel_hakimi_graph(deg)
+        assert nxt.is_threshold_graph(G)
+
+    def test_creation_sequences(self):
+        deg = [3, 2, 2, 1]
+        G = nx.generators.havel_hakimi_graph(deg)
+
+        with pytest.raises(ValueError):
+            nxt.creation_sequence(deg, with_labels=True, compact=True)
+
+        cs0 = nxt.creation_sequence(deg)
+        H0 = nxt.threshold_graph(cs0)
+        assert "".join(cs0) == "ddid"
+
+        cs1 = nxt.creation_sequence(deg, with_labels=True)
+        H1 = nxt.threshold_graph(cs1)
+        assert cs1 == [(1, "d"), (2, "d"), (3, "i"), (0, "d")]
+
+        cs2 = nxt.creation_sequence(deg, compact=True)
+        H2 = nxt.threshold_graph(cs2)
+        assert cs2 == [2, 1, 1]
+        assert "".join(nxt.uncompact(cs2)) == "ddid"
+        assert graph_could_be_isomorphic(H0, G)
+        assert graph_could_be_isomorphic(H0, H1)
+        assert graph_could_be_isomorphic(H0, H2)
+
+    def test_make_compact(self):
+        assert nxt.make_compact(["d", "d", "d", "i", "d", "d"]) == [3, 1, 2]
+        assert nxt.make_compact([3, 1, 2]) == [3, 1, 2]
+        assert pytest.raises(TypeError, nxt.make_compact, [3.0, 1.0, 2.0])
+
+    def test_uncompact(self):
+        assert nxt.uncompact([3, 1, 2]) == ["d", "d", "d", "i", "d", "d"]
+        assert nxt.uncompact(["d", "d", "i", "d"]) == ["d", "d", "i", "d"]
+        assert nxt.uncompact(
+            nxt.uncompact([(1, "d"), (2, "d"), (3, "i"), (0, "d")])
+        ) == nxt.uncompact([(1, "d"), (2, "d"), (3, "i"), (0, "d")])
+        assert pytest.raises(TypeError, nxt.uncompact, [3.0, 1.0, 2.0])
+
+    def test_creation_sequence_to_weights(self):
+        assert nxt.creation_sequence_to_weights([3, 1, 2]) == [
+            0.5,
+            0.5,
+            0.5,
+            0.25,
+            0.75,
+            0.75,
+        ]
+        assert pytest.raises(
+            TypeError, nxt.creation_sequence_to_weights, [3.0, 1.0, 2.0]
+        )
+
+    def test_weights_to_creation_sequence(self):
+        deg = [3, 2, 2, 1]
+        with pytest.raises(ValueError):
+            nxt.weights_to_creation_sequence(deg, with_labels=True, compact=True)
+        assert nxt.weights_to_creation_sequence(deg, with_labels=True) == [
+            (3, "d"),
+            (1, "d"),
+            (2, "d"),
+            (0, "d"),
+        ]
+        assert nxt.weights_to_creation_sequence(deg, compact=True) == [4]
+
+    def test_find_alternating_4_cycle(self):
+        G = nx.Graph()
+        G.add_edge(1, 2)
+        assert not nxt.find_alternating_4_cycle(G)
+
+    def test_shortest_path(self):
+        deg = [3, 2, 2, 1]
+        G = nx.generators.havel_hakimi_graph(deg)
+        cs1 = nxt.creation_sequence(deg, with_labels=True)
+        for n, m in [(3, 0), (0, 3), (0, 2), (0, 1), (1, 3), (3, 1), (1, 2), (2, 3)]:
+            assert nxt.shortest_path(cs1, n, m) == nx.shortest_path(G, n, m)
+
+        spl = nxt.shortest_path_length(cs1, 3)
+        spl2 = nxt.shortest_path_length([t for v, t in cs1], 2)
+        assert spl == spl2
+
+        spld = {}
+        for j, pl in enumerate(spl):
+            n = cs1[j][0]
+            spld[n] = pl
+        assert spld == nx.single_source_shortest_path_length(G, 3)
+
+        assert nxt.shortest_path(["d", "d", "d", "i", "d", "d"], 1, 2) == [1, 2]
+        assert nxt.shortest_path([3, 1, 2], 1, 2) == [1, 2]
+        assert pytest.raises(TypeError, nxt.shortest_path, [3.0, 1.0, 2.0], 1, 2)
+        assert pytest.raises(ValueError, nxt.shortest_path, [3, 1, 2], "a", 2)
+        assert pytest.raises(ValueError, nxt.shortest_path, [3, 1, 2], 1, "b")
+        assert nxt.shortest_path([3, 1, 2], 1, 1) == [1]
+
+    def test_shortest_path_length(self):
+        assert nxt.shortest_path_length([3, 1, 2], 1) == [1, 0, 1, 2, 1, 1]
+        assert nxt.shortest_path_length(["d", "d", "d", "i", "d", "d"], 1) == [
+            1,
+            0,
+            1,
+            2,
+            1,
+            1,
+        ]
+        assert nxt.shortest_path_length(("d", "d", "d", "i", "d", "d"), 1) == [
+            1,
+            0,
+            1,
+            2,
+            1,
+            1,
+        ]
+        assert pytest.raises(TypeError, nxt.shortest_path, [3.0, 1.0, 2.0], 1)
+
+    def test_random_threshold_sequence(self):
+        assert len(nxt.random_threshold_sequence(10, 0.5)) == 10
+        assert nxt.random_threshold_sequence(10, 0.5, seed=42) == [
+            "d",
+            "i",
+            "d",
+            "d",
+            "d",
+            "i",
+            "i",
+            "i",
+            "d",
+            "d",
+        ]
+        assert pytest.raises(ValueError, nxt.random_threshold_sequence, 10, 1.5)
+
+    def test_right_d_threshold_sequence(self):
+        assert nxt.right_d_threshold_sequence(3, 2) == ["d", "i", "d"]
+        assert pytest.raises(ValueError, nxt.right_d_threshold_sequence, 2, 3)
+
+    def test_left_d_threshold_sequence(self):
+        assert nxt.left_d_threshold_sequence(3, 2) == ["d", "i", "d"]
+        assert pytest.raises(ValueError, nxt.left_d_threshold_sequence, 2, 3)
+
+    def test_weights_thresholds(self):
+        wseq = [3, 4, 3, 3, 5, 6, 5, 4, 5, 6]
+        cs = nxt.weights_to_creation_sequence(wseq, threshold=10)
+        wseq = nxt.creation_sequence_to_weights(cs)
+        cs2 = nxt.weights_to_creation_sequence(wseq)
+        assert cs == cs2
+
+        wseq = nxt.creation_sequence_to_weights(nxt.uncompact([3, 1, 2, 3, 3, 2, 3]))
+        assert wseq == [
+            s * 0.125 for s in [4, 4, 4, 3, 5, 5, 2, 2, 2, 6, 6, 6, 1, 1, 7, 7, 7]
+        ]
+
+        wseq = nxt.creation_sequence_to_weights([3, 1, 2, 3, 3, 2, 3])
+        assert wseq == [
+            s * 0.125 for s in [4, 4, 4, 3, 5, 5, 2, 2, 2, 6, 6, 6, 1, 1, 7, 7, 7]
+        ]
+
+        wseq = nxt.creation_sequence_to_weights(list(enumerate("ddidiiidididi")))
+        assert wseq == [s * 0.1 for s in [5, 5, 4, 6, 3, 3, 3, 7, 2, 8, 1, 9, 0]]
+
+        wseq = nxt.creation_sequence_to_weights("ddidiiidididi")
+        assert wseq == [s * 0.1 for s in [5, 5, 4, 6, 3, 3, 3, 7, 2, 8, 1, 9, 0]]
+
+        wseq = nxt.creation_sequence_to_weights("ddidiiidididid")
+        ws = [s / 12 for s in [6, 6, 5, 7, 4, 4, 4, 8, 3, 9, 2, 10, 1, 11]]
+        assert sum(abs(c - d) for c, d in zip(wseq, ws)) < 1e-14
+
+    def test_finding_routines(self):
+        G = nx.Graph({1: [2], 2: [3], 3: [4], 4: [5], 5: [6]})
+        G.add_edge(2, 4)
+        G.add_edge(2, 5)
+        G.add_edge(2, 7)
+        G.add_edge(3, 6)
+        G.add_edge(4, 6)
+
+        # Alternating 4 cycle
+        assert nxt.find_alternating_4_cycle(G) == [1, 2, 3, 6]
+
+        # Threshold graph
+        TG = nxt.find_threshold_graph(G)
+        assert nxt.is_threshold_graph(TG)
+        assert sorted(TG.nodes()) == [1, 2, 3, 4, 5, 7]
+
+        cs = nxt.creation_sequence(dict(TG.degree()), with_labels=True)
+        assert nxt.find_creation_sequence(G) == cs
+
+    def test_fast_versions_properties_threshold_graphs(self):
+        cs = "ddiiddid"
+        G = nxt.threshold_graph(cs)
+        assert nxt.density("ddiiddid") == nx.density(G)
+        assert sorted(nxt.degree_sequence(cs)) == sorted(d for n, d in G.degree())
+
+        ts = nxt.triangle_sequence(cs)
+        assert ts == list(nx.triangles(G).values())
+        assert sum(ts) // 3 == nxt.triangles(cs)
+
+        c1 = nxt.cluster_sequence(cs)
+        c2 = list(nx.clustering(G).values())
+        assert sum(abs(c - d) for c, d in zip(c1, c2)) == pytest.approx(0, abs=1e-7)
+
+        b1 = nx.betweenness_centrality(G).values()
+        b2 = nxt.betweenness_sequence(cs)
+        assert sum(abs(c - d) for c, d in zip(b1, b2)) < 1e-14
+
+        assert nxt.eigenvalues(cs) == [0, 1, 3, 3, 5, 7, 7, 8]
+
+        # Degree Correlation
+        assert abs(nxt.degree_correlation(cs) + 0.593038821954) < 1e-12
+        assert nxt.degree_correlation("diiiddi") == -0.8
+        assert nxt.degree_correlation("did") == -1.0
+        assert nxt.degree_correlation("ddd") == 1.0
+        assert nxt.eigenvalues("dddiii") == [0, 0, 0, 0, 3, 3]
+        assert nxt.eigenvalues("dddiiid") == [0, 1, 1, 1, 4, 4, 7]
+
+    def test_tg_creation_routines(self):
+        s = nxt.left_d_threshold_sequence(5, 7)
+        s = nxt.right_d_threshold_sequence(5, 7)
+        s1 = nxt.swap_d(s, 1.0, 1.0)
+        s1 = nxt.swap_d(s, 1.0, 1.0, seed=1)
+
+    def test_eigenvectors(self):
+        np = pytest.importorskip("numpy")
+        eigenval = np.linalg.eigvals
+        pytest.importorskip("scipy")
+
+        cs = "ddiiddid"
+        G = nxt.threshold_graph(cs)
+        (tgeval, tgevec) = nxt.eigenvectors(cs)
+        np.testing.assert_allclose([np.dot(lv, lv) for lv in tgevec], 1.0, rtol=1e-9)
+        lapl = nx.laplacian_matrix(G)
+
+    def test_create_using(self):
+        cs = "ddiiddid"
+        G = nxt.threshold_graph(cs)
+        assert pytest.raises(
+            nx.exception.NetworkXError,
+            nxt.threshold_graph,
+            cs,
+            create_using=nx.DiGraph(),
+        )
+        MG = nxt.threshold_graph(cs, create_using=nx.MultiGraph())
+        assert sorted(MG.edges()) == sorted(G.edges())
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_tournament.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_tournament.py
new file mode 100644
index 0000000..0a88b42
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_tournament.py
@@ -0,0 +1,162 @@
+"""Unit tests for the :mod:`networkx.algorithms.tournament` module."""
+from itertools import combinations
+
+import pytest
+
+from networkx import DiGraph
+from networkx.algorithms.tournament import (
+    hamiltonian_path,
+    index_satisfying,
+    is_reachable,
+    is_strongly_connected,
+    is_tournament,
+    random_tournament,
+    score_sequence,
+    tournament_matrix,
+)
+
+
+def test_condition_not_satisfied():
+    condition = lambda x: x > 0
+    iter_in = [0]
+    assert index_satisfying(iter_in, condition) == 1
+
+
+def test_empty_iterable():
+    condition = lambda x: x > 0
+    with pytest.raises(ValueError):
+        index_satisfying([], condition)
+
+
+def test_is_tournament():
+    G = DiGraph()
+    G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0), (1, 3), (0, 2)])
+    assert is_tournament(G)
+
+
+def test_self_loops():
+    """A tournament must have no self-loops."""
+    G = DiGraph()
+    G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0), (1, 3), (0, 2)])
+    G.add_edge(0, 0)
+    assert not is_tournament(G)
+
+
+def test_missing_edges():
+    """A tournament must not have any pair of nodes without at least
+    one edge joining the pair.
+
+    """
+    G = DiGraph()
+    G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0), (1, 3)])
+    assert not is_tournament(G)
+
+
+def test_bidirectional_edges():
+    """A tournament must not have any pair of nodes with greater
+    than one edge joining the pair.
+
+    """
+    G = DiGraph()
+    G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0), (1, 3), (0, 2)])
+    G.add_edge(1, 0)
+    assert not is_tournament(G)
+
+
+def test_graph_is_tournament():
+    for _ in range(10):
+        G = random_tournament(5)
+        assert is_tournament(G)
+
+
+def test_graph_is_tournament_seed():
+    for _ in range(10):
+        G = random_tournament(5, seed=1)
+        assert is_tournament(G)
+
+
+def test_graph_is_tournament_one_node():
+    G = random_tournament(1)
+    assert is_tournament(G)
+
+
+def test_graph_is_tournament_zero_node():
+    G = random_tournament(0)
+    assert is_tournament(G)
+
+
+def test_hamiltonian_empty_graph():
+    path = hamiltonian_path(DiGraph())
+    assert len(path) == 0
+
+
+def test_path_is_hamiltonian():
+    G = DiGraph()
+    G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0), (1, 3), (0, 2)])
+    path = hamiltonian_path(G)
+    assert len(path) == 4
+    assert all(v in G[u] for u, v in zip(path, path[1:]))
+
+
+def test_hamiltonian_cycle():
+    """Tests that :func:`networkx.tournament.hamiltonian_path`
+    returns a Hamiltonian cycle when provided a strongly connected
+    tournament.
+
+    """
+    G = DiGraph()
+    G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0), (1, 3), (0, 2)])
+    path = hamiltonian_path(G)
+    assert len(path) == 4
+    assert all(v in G[u] for u, v in zip(path, path[1:]))
+    assert path[0] in G[path[-1]]
+
+
+def test_score_sequence_edge():
+    G = DiGraph([(0, 1)])
+    assert score_sequence(G) == [0, 1]
+
+
+def test_score_sequence_triangle():
+    G = DiGraph([(0, 1), (1, 2), (2, 0)])
+    assert score_sequence(G) == [1, 1, 1]
+
+
+def test_tournament_matrix():
+    np = pytest.importorskip("numpy")
+    pytest.importorskip("scipy")
+    npt = np.testing
+    G = DiGraph([(0, 1)])
+    m = tournament_matrix(G)
+    npt.assert_array_equal(m.todense(), np.array([[0, 1], [-1, 0]]))
+
+
+def test_reachable_pair():
+    """Tests for a reachable pair of nodes."""
+    G = DiGraph([(0, 1), (1, 2), (2, 0)])
+    assert is_reachable(G, 0, 2)
+
+
+def test_same_node_is_reachable():
+    """Tests that a node is always reachable from it."""
+    # G is an arbitrary tournament on ten nodes.
+    G = DiGraph(sorted(p) for p in combinations(range(10), 2))
+    assert all(is_reachable(G, v, v) for v in G)
+
+
+def test_unreachable_pair():
+    """Tests for an unreachable pair of nodes."""
+    G = DiGraph([(0, 1), (0, 2), (1, 2)])
+    assert not is_reachable(G, 1, 0)
+
+
+def test_is_strongly_connected():
+    """Tests for a strongly connected tournament."""
+    G = DiGraph([(0, 1), (1, 2), (2, 0)])
+    assert is_strongly_connected(G)
+
+
+def test_not_strongly_connected():
+    """Tests for a tournament that is not strongly connected."""
+    G = DiGraph([(0, 1), (0, 2), (1, 2)])
+    assert not is_strongly_connected(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_triads.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_triads.py
new file mode 100644
index 0000000..446c2db
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_triads.py
@@ -0,0 +1,272 @@
+"""Tests for the :mod:`networkx.algorithms.triads` module."""
+
+import itertools
+from collections import defaultdict
+from random import sample
+
+import pytest
+
+import networkx as nx
+
+
+def test_triadic_census():
+    """Tests the triadic_census function."""
+    G = nx.DiGraph()
+    G.add_edges_from(["01", "02", "03", "04", "05", "12", "16", "51", "56", "65"])
+    expected = {
+        "030T": 2,
+        "120C": 1,
+        "210": 0,
+        "120U": 0,
+        "012": 9,
+        "102": 3,
+        "021U": 0,
+        "111U": 0,
+        "003": 8,
+        "030C": 0,
+        "021D": 9,
+        "201": 0,
+        "111D": 1,
+        "300": 0,
+        "120D": 0,
+        "021C": 2,
+    }
+    actual = nx.triadic_census(G)
+    assert expected == actual
+
+
+def test_is_triad():
+    """Tests the is_triad function"""
+    G = nx.karate_club_graph()
+    G = G.to_directed()
+    for i in range(100):
+        nodes = sample(sorted(G.nodes()), 3)
+        G2 = G.subgraph(nodes)
+        assert nx.is_triad(G2)
+
+
+def test_all_triplets():
+    """Tests the all_triplets function."""
+    G = nx.DiGraph()
+    G.add_edges_from(["01", "02", "03", "04", "05", "12", "16", "51", "56", "65"])
+    expected = [
+        f"{i},{j},{k}"
+        for i in range(7)
+        for j in range(i + 1, 7)
+        for k in range(j + 1, 7)
+    ]
+    expected = [set(x.split(",")) for x in expected]
+    actual = list(set(x) for x in nx.all_triplets(G))
+    assert all([any([s1 == s2 for s1 in expected]) for s2 in actual])
+
+
+def test_all_triads():
+    """Tests the all_triplets function."""
+    G = nx.DiGraph()
+    G.add_edges_from(["01", "02", "03", "04", "05", "12", "16", "51", "56", "65"])
+    expected = [
+        f"{i},{j},{k}"
+        for i in range(7)
+        for j in range(i + 1, 7)
+        for k in range(j + 1, 7)
+    ]
+    expected = [G.subgraph(x.split(",")) for x in expected]
+    actual = list(nx.all_triads(G))
+    assert all(any([nx.is_isomorphic(G1, G2) for G1 in expected]) for G2 in actual)
+
+
+def test_triad_type():
+    """Tests the triad_type function."""
+    # 0 edges (1 type)
+    G = nx.DiGraph({0: [], 1: [], 2: []})
+    assert nx.triad_type(G) == "003"
+    # 1 edge (1 type)
+    G = nx.DiGraph({0: [1], 1: [], 2: []})
+    assert nx.triad_type(G) == "012"
+    # 2 edges (4 types)
+    G = nx.DiGraph([(0, 1), (0, 2)])
+    assert nx.triad_type(G) == "021D"
+    G = nx.DiGraph({0: [1], 1: [0], 2: []})
+    assert nx.triad_type(G) == "102"
+    G = nx.DiGraph([(0, 1), (2, 1)])
+    assert nx.triad_type(G) == "021U"
+    G = nx.DiGraph([(0, 1), (1, 2)])
+    assert nx.triad_type(G) == "021C"
+    # 3 edges (4 types)
+    G = nx.DiGraph([(0, 1), (1, 0), (2, 1)])
+    assert nx.triad_type(G) == "111D"
+    G = nx.DiGraph([(0, 1), (1, 0), (1, 2)])
+    assert nx.triad_type(G) == "111U"
+    G = nx.DiGraph([(0, 1), (1, 2), (0, 2)])
+    assert nx.triad_type(G) == "030T"
+    G = nx.DiGraph([(0, 1), (1, 2), (2, 0)])
+    assert nx.triad_type(G) == "030C"
+    # 4 edges (4 types)
+    G = nx.DiGraph([(0, 1), (1, 0), (2, 0), (0, 2)])
+    assert nx.triad_type(G) == "201"
+    G = nx.DiGraph([(0, 1), (1, 0), (2, 0), (2, 1)])
+    assert nx.triad_type(G) == "120D"
+    G = nx.DiGraph([(0, 1), (1, 0), (0, 2), (1, 2)])
+    assert nx.triad_type(G) == "120U"
+    G = nx.DiGraph([(0, 1), (1, 0), (0, 2), (2, 1)])
+    assert nx.triad_type(G) == "120C"
+    # 5 edges (1 type)
+    G = nx.DiGraph([(0, 1), (1, 0), (2, 1), (1, 2), (0, 2)])
+    assert nx.triad_type(G) == "210"
+    # 6 edges (1 type)
+    G = nx.DiGraph([(0, 1), (1, 0), (1, 2), (2, 1), (0, 2), (2, 0)])
+    assert nx.triad_type(G) == "300"
+
+
+def test_triads_by_type():
+    """Tests the all_triplets function."""
+    G = nx.DiGraph()
+    G.add_edges_from(["01", "02", "03", "04", "05", "12", "16", "51", "56", "65"])
+    all_triads = nx.all_triads(G)
+    expected = defaultdict(list)
+    for triad in all_triads:
+        name = nx.triad_type(triad)
+        expected[name].append(triad)
+    actual = nx.triads_by_type(G)
+    assert set(actual.keys()) == set(expected.keys())
+    for tri_type, actual_Gs in actual.items():
+        expected_Gs = expected[tri_type]
+        for a in actual_Gs:
+            assert any(nx.is_isomorphic(a, e) for e in expected_Gs)
+
+
+def test_random_triad():
+    """Tests the random_triad function"""
+    G = nx.karate_club_graph()
+    G = G.to_directed()
+    for i in range(100):
+        assert nx.is_triad(nx.random_triad(G))
+
+
+def test_triadic_census_short_path_nodelist():
+    G = nx.path_graph("abc", create_using=nx.DiGraph)
+    expected = {"021C": 1}
+    for nl in ["a", "b", "c", "ab", "ac", "bc", "abc"]:
+        triad_census = nx.triadic_census(G, nodelist=nl)
+        assert expected == {typ: cnt for typ, cnt in triad_census.items() if cnt > 0}
+
+
+def test_triadic_census_correct_nodelist_values():
+    G = nx.path_graph(5, create_using=nx.DiGraph)
+    msg = r"nodelist includes duplicate nodes or nodes not in G"
+    with pytest.raises(ValueError, match=msg):
+        nx.triadic_census(G, [1, 2, 2, 3])
+    with pytest.raises(ValueError, match=msg):
+        nx.triadic_census(G, [1, 2, "a", 3])
+
+
+def test_triadic_census_tiny_graphs():
+    tc = nx.triadic_census(nx.empty_graph(0, create_using=nx.DiGraph))
+    assert {} == {typ: cnt for typ, cnt in tc.items() if cnt > 0}
+    tc = nx.triadic_census(nx.empty_graph(1, create_using=nx.DiGraph))
+    assert {} == {typ: cnt for typ, cnt in tc.items() if cnt > 0}
+    tc = nx.triadic_census(nx.empty_graph(2, create_using=nx.DiGraph))
+    assert {} == {typ: cnt for typ, cnt in tc.items() if cnt > 0}
+    tc = nx.triadic_census(nx.DiGraph([(1, 2)]))
+    assert {} == {typ: cnt for typ, cnt in tc.items() if cnt > 0}
+
+
+def test_triadic_census_selfloops():
+    GG = nx.path_graph("abc", create_using=nx.DiGraph)
+    expected = {"021C": 1}
+    for n in GG:
+        G = GG.copy()
+        G.add_edge(n, n)
+        tc = nx.triadic_census(G)
+        assert expected == {typ: cnt for typ, cnt in tc.items() if cnt > 0}
+
+    GG = nx.path_graph("abcde", create_using=nx.DiGraph)
+    tbt = nx.triads_by_type(GG)
+    for n in GG:
+        GG.add_edge(n, n)
+    tc = nx.triadic_census(GG)
+    assert tc == {tt: len(tbt[tt]) for tt in tc}
+
+
+def test_triadic_census_four_path():
+    G = nx.path_graph("abcd", create_using=nx.DiGraph)
+    expected = {"012": 2, "021C": 2}
+    triad_census = nx.triadic_census(G)
+    assert expected == {typ: cnt for typ, cnt in triad_census.items() if cnt > 0}
+
+
+def test_triadic_census_four_path_nodelist():
+    G = nx.path_graph("abcd", create_using=nx.DiGraph)
+    expected_end = {"012": 2, "021C": 1}
+    expected_mid = {"012": 1, "021C": 2}
+    a_triad_census = nx.triadic_census(G, nodelist=["a"])
+    assert expected_end == {typ: cnt for typ, cnt in a_triad_census.items() if cnt > 0}
+    b_triad_census = nx.triadic_census(G, nodelist=["b"])
+    assert expected_mid == {typ: cnt for typ, cnt in b_triad_census.items() if cnt > 0}
+    c_triad_census = nx.triadic_census(G, nodelist=["c"])
+    assert expected_mid == {typ: cnt for typ, cnt in c_triad_census.items() if cnt > 0}
+    d_triad_census = nx.triadic_census(G, nodelist=["d"])
+    assert expected_end == {typ: cnt for typ, cnt in d_triad_census.items() if cnt > 0}
+
+
+def test_triadic_census_nodelist():
+    """Tests the triadic_census function."""
+    G = nx.DiGraph()
+    G.add_edges_from(["01", "02", "03", "04", "05", "12", "16", "51", "56", "65"])
+    expected = {
+        "030T": 2,
+        "120C": 1,
+        "210": 0,
+        "120U": 0,
+        "012": 9,
+        "102": 3,
+        "021U": 0,
+        "111U": 0,
+        "003": 8,
+        "030C": 0,
+        "021D": 9,
+        "201": 0,
+        "111D": 1,
+        "300": 0,
+        "120D": 0,
+        "021C": 2,
+    }
+    actual = {k: 0 for k in expected}
+    for node in G.nodes():
+        node_triad_census = nx.triadic_census(G, nodelist=[node])
+        for triad_key in expected:
+            actual[triad_key] += node_triad_census[triad_key]
+    # Divide all counts by 3
+    for k, v in actual.items():
+        actual[k] //= 3
+    assert expected == actual
+
+
+@pytest.mark.parametrize("N", [5, 10])
+def test_triandic_census_on_random_graph(N):
+    G = nx.binomial_graph(N, 0.3, directed=True, seed=42)
+    tc1 = nx.triadic_census(G)
+    tbt = nx.triads_by_type(G)
+    tc2 = {tt: len(tbt[tt]) for tt in tc1}
+    assert tc1 == tc2
+
+    for n in G:
+        tc1 = nx.triadic_census(G, nodelist={n})
+        tc2 = {tt: sum(1 for t in tbt.get(tt, []) if n in t) for tt in tc1}
+        assert tc1 == tc2
+
+    for ns in itertools.combinations(G, 2):
+        ns = set(ns)
+        tc1 = nx.triadic_census(G, nodelist=ns)
+        tc2 = {
+            tt: sum(1 for t in tbt.get(tt, []) if any(n in ns for n in t)) for tt in tc1
+        }
+        assert tc1 == tc2
+
+    for ns in itertools.combinations(G, 3):
+        ns = set(ns)
+        tc1 = nx.triadic_census(G, nodelist=ns)
+        tc2 = {
+            tt: sum(1 for t in tbt.get(tt, []) if any(n in ns for n in t)) for tt in tc1
+        }
+        assert tc1 == tc2
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_vitality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_vitality.py
new file mode 100644
index 0000000..248206e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_vitality.py
@@ -0,0 +1,41 @@
+import networkx as nx
+
+
+class TestClosenessVitality:
+    def test_unweighted(self):
+        G = nx.cycle_graph(3)
+        vitality = nx.closeness_vitality(G)
+        assert vitality == {0: 2, 1: 2, 2: 2}
+
+    def test_weighted(self):
+        G = nx.Graph()
+        nx.add_cycle(G, [0, 1, 2], weight=2)
+        vitality = nx.closeness_vitality(G, weight="weight")
+        assert vitality == {0: 4, 1: 4, 2: 4}
+
+    def test_unweighted_digraph(self):
+        G = nx.DiGraph(nx.cycle_graph(3))
+        vitality = nx.closeness_vitality(G)
+        assert vitality == {0: 4, 1: 4, 2: 4}
+
+    def test_weighted_digraph(self):
+        G = nx.DiGraph()
+        nx.add_cycle(G, [0, 1, 2], weight=2)
+        nx.add_cycle(G, [2, 1, 0], weight=2)
+        vitality = nx.closeness_vitality(G, weight="weight")
+        assert vitality == {0: 8, 1: 8, 2: 8}
+
+    def test_weighted_multidigraph(self):
+        G = nx.MultiDiGraph()
+        nx.add_cycle(G, [0, 1, 2], weight=2)
+        nx.add_cycle(G, [2, 1, 0], weight=2)
+        vitality = nx.closeness_vitality(G, weight="weight")
+        assert vitality == {0: 8, 1: 8, 2: 8}
+
+    def test_disconnecting_graph(self):
+        """Tests that the closeness vitality of a node whose removal
+        disconnects the graph is negative infinity.
+
+        """
+        G = nx.path_graph(3)
+        assert nx.closeness_vitality(G, node=1) == -float("inf")
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_voronoi.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_voronoi.py
new file mode 100644
index 0000000..3269ae6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_voronoi.py
@@ -0,0 +1,103 @@
+import networkx as nx
+from networkx.utils import pairwise
+
+
+class TestVoronoiCells:
+    """Unit tests for the Voronoi cells function."""
+
+    def test_isolates(self):
+        """Tests that a graph with isolated nodes has all isolates in
+        one block of the partition.
+
+        """
+        G = nx.empty_graph(5)
+        cells = nx.voronoi_cells(G, {0, 2, 4})
+        expected = {0: {0}, 2: {2}, 4: {4}, "unreachable": {1, 3}}
+        assert expected == cells
+
+    def test_undirected_unweighted(self):
+        G = nx.cycle_graph(6)
+        cells = nx.voronoi_cells(G, {0, 3})
+        expected = {0: {0, 1, 5}, 3: {2, 3, 4}}
+        assert expected == cells
+
+    def test_directed_unweighted(self):
+        # This is the singly-linked directed cycle graph on six nodes.
+        G = nx.DiGraph(pairwise(range(6), cyclic=True))
+        cells = nx.voronoi_cells(G, {0, 3})
+        expected = {0: {0, 1, 2}, 3: {3, 4, 5}}
+        assert expected == cells
+
+    def test_directed_inward(self):
+        """Tests that reversing the graph gives the "inward" Voronoi
+        partition.
+
+        """
+        # This is the singly-linked reverse directed cycle graph on six nodes.
+        G = nx.DiGraph(pairwise(range(6), cyclic=True))
+        G = G.reverse(copy=False)
+        cells = nx.voronoi_cells(G, {0, 3})
+        expected = {0: {0, 4, 5}, 3: {1, 2, 3}}
+        assert expected == cells
+
+    def test_undirected_weighted(self):
+        edges = [(0, 1, 10), (1, 2, 1), (2, 3, 1)]
+        G = nx.Graph()
+        G.add_weighted_edges_from(edges)
+        cells = nx.voronoi_cells(G, {0, 3})
+        expected = {0: {0}, 3: {1, 2, 3}}
+        assert expected == cells
+
+    def test_directed_weighted(self):
+        edges = [(0, 1, 10), (1, 2, 1), (2, 3, 1), (3, 2, 1), (2, 1, 1)]
+        G = nx.DiGraph()
+        G.add_weighted_edges_from(edges)
+        cells = nx.voronoi_cells(G, {0, 3})
+        expected = {0: {0}, 3: {1, 2, 3}}
+        assert expected == cells
+
+    def test_multigraph_unweighted(self):
+        """Tests that the Voronoi cells for a multigraph are the same as
+        for a simple graph.
+
+        """
+        edges = [(0, 1), (1, 2), (2, 3)]
+        G = nx.MultiGraph(2 * edges)
+        H = nx.Graph(G)
+        G_cells = nx.voronoi_cells(G, {0, 3})
+        H_cells = nx.voronoi_cells(H, {0, 3})
+        assert G_cells == H_cells
+
+    def test_multidigraph_unweighted(self):
+        # This is the twice-singly-linked directed cycle graph on six nodes.
+        edges = list(pairwise(range(6), cyclic=True))
+        G = nx.MultiDiGraph(2 * edges)
+        H = nx.DiGraph(G)
+        G_cells = nx.voronoi_cells(G, {0, 3})
+        H_cells = nx.voronoi_cells(H, {0, 3})
+        assert G_cells == H_cells
+
+    def test_multigraph_weighted(self):
+        edges = [(0, 1, 10), (0, 1, 10), (1, 2, 1), (1, 2, 100), (2, 3, 1), (2, 3, 100)]
+        G = nx.MultiGraph()
+        G.add_weighted_edges_from(edges)
+        cells = nx.voronoi_cells(G, {0, 3})
+        expected = {0: {0}, 3: {1, 2, 3}}
+        assert expected == cells
+
+    def test_multidigraph_weighted(self):
+        edges = [
+            (0, 1, 10),
+            (0, 1, 10),
+            (1, 2, 1),
+            (2, 3, 1),
+            (3, 2, 10),
+            (3, 2, 1),
+            (2, 1, 10),
+            (2, 1, 1),
+        ]
+        G = nx.MultiDiGraph()
+        G.add_weighted_edges_from(edges)
+        cells = nx.voronoi_cells(G, {0, 3})
+        expected = {0: {0}, 3: {1, 2, 3}}
+        assert expected == cells
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_wiener.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_wiener.py
new file mode 100644
index 0000000..1cb4040
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tests/test_wiener.py
@@ -0,0 +1,66 @@
+"""Unit tests for the :mod:`networkx.algorithms.wiener` module."""
+
+
+from networkx import DiGraph, complete_graph, empty_graph, path_graph, wiener_index
+
+
+class TestWienerIndex:
+    """Unit tests for computing the Wiener index of a graph."""
+
+    def test_disconnected_graph(self):
+        """Tests that the Wiener index of a disconnected graph is
+        positive infinity.
+
+        """
+        assert wiener_index(empty_graph(2)) == float("inf")
+
+    def test_directed(self):
+        """Tests that each pair of nodes in the directed graph is
+        counted once when computing the Wiener index.
+
+        """
+        G = complete_graph(3)
+        H = DiGraph(G)
+        assert (2 * wiener_index(G)) == wiener_index(H)
+
+    def test_complete_graph(self):
+        """Tests that the Wiener index of the complete graph is simply
+        the number of edges.
+
+        """
+        n = 10
+        G = complete_graph(n)
+        assert wiener_index(G) == (n * (n - 1) / 2)
+
+    def test_path_graph(self):
+        """Tests that the Wiener index of the path graph is correctly
+        computed.
+
+        """
+        # In P_n, there are n - 1 pairs of vertices at distance one, n -
+        # 2 pairs at distance two, n - 3 at distance three, ..., 1 at
+        # distance n - 1, so the Wiener index should be
+        #
+        #     1 * (n - 1) + 2 * (n - 2) + ... + (n - 2) * 2 + (n - 1) * 1
+        #
+        # For example, in P_5,
+        #
+        #     1 * 4 + 2 * 3 + 3 * 2 + 4 * 1 = 2 (1 * 4 + 2 * 3)
+        #
+        # and in P_6,
+        #
+        #     1 * 5 + 2 * 4 + 3 * 3 + 4 * 2 + 5 * 1 = 2 (1 * 5 + 2 * 4) + 3 * 3
+        #
+        # assuming n is *odd*, this gives the formula
+        #
+        #     2 \sum_{i = 1}^{(n - 1) / 2} [i * (n - i)]
+        #
+        # assuming n is *even*, this gives the formula
+        #
+        #     2 \sum_{i = 1}^{n / 2} [i * (n - i)] - (n / 2) ** 2
+        #
+        n = 9
+        G = path_graph(n)
+        expected = 2 * sum(i * (n - i) for i in range(1, (n // 2) + 1))
+        actual = wiener_index(G)
+        assert expected == actual
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/threshold.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/threshold.py
new file mode 100644
index 0000000..5c50394
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/threshold.py
@@ -0,0 +1,974 @@
+"""
+Threshold Graphs - Creation, manipulation and identification.
+"""
+from math import sqrt
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = ["is_threshold_graph", "find_threshold_graph"]
+
+
+def is_threshold_graph(G):
+    """
+    Returns `True` if `G` is a threshold graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph instance
+        An instance of `Graph`, `DiGraph`, `MultiGraph` or `MultiDiGraph`
+
+    Returns
+    -------
+    bool
+        `True` if `G` is a threshold graph, `False` otherwise.
+
+    Examples
+    --------
+    >>> from networkx.algorithms.threshold import is_threshold_graph
+    >>> G = nx.path_graph(3)
+    >>> is_threshold_graph(G)
+    True
+    >>> G = nx.barbell_graph(3, 3)
+    >>> is_threshold_graph(G)
+    False
+
+    References
+    ----------
+    .. [1] Threshold graphs: https://en.wikipedia.org/wiki/Threshold_graph
+    """
+    return is_threshold_sequence(list(d for n, d in G.degree()))
+
+
+def is_threshold_sequence(degree_sequence):
+    """
+    Returns True if the sequence is a threshold degree seqeunce.
+
+    Uses the property that a threshold graph must be constructed by
+    adding either dominating or isolated nodes. Thus, it can be
+    deconstructed iteratively by removing a node of degree zero or a
+    node that connects to the remaining nodes.  If this deconstruction
+    failes then the sequence is not a threshold sequence.
+    """
+    ds = degree_sequence[:]  # get a copy so we don't destroy original
+    ds.sort()
+    while ds:
+        if ds[0] == 0:  # if isolated node
+            ds.pop(0)  # remove it
+            continue
+        if ds[-1] != len(ds) - 1:  # is the largest degree node dominating?
+            return False  # no, not a threshold degree sequence
+        ds.pop()  # yes, largest is the dominating node
+        ds = [d - 1 for d in ds]  # remove it and decrement all degrees
+    return True
+
+
+def creation_sequence(degree_sequence, with_labels=False, compact=False):
+    """
+    Determines the creation sequence for the given threshold degree sequence.
+
+    The creation sequence is a list of single characters 'd'
+    or 'i': 'd' for dominating or 'i' for isolated vertices.
+    Dominating vertices are connected to all vertices present when it
+    is added.  The first node added is by convention 'd'.
+    This list can be converted to a string if desired using "".join(cs)
+
+    If with_labels==True:
+    Returns a list of 2-tuples containing the vertex number
+    and a character 'd' or 'i' which describes the type of vertex.
+
+    If compact==True:
+    Returns the creation sequence in a compact form that is the number
+    of 'i's and 'd's alternating.
+    Examples:
+    [1,2,2,3] represents d,i,i,d,d,i,i,i
+    [3,1,2] represents d,d,d,i,d,d
+
+    Notice that the first number is the first vertex to be used for
+    construction and so is always 'd'.
+
+    with_labels and compact cannot both be True.
+
+    Returns None if the sequence is not a threshold sequence
+    """
+    if with_labels and compact:
+        raise ValueError("compact sequences cannot be labeled")
+
+    # make an indexed copy
+    if isinstance(degree_sequence, dict):  # labeled degree seqeunce
+        ds = [[degree, label] for (label, degree) in degree_sequence.items()]
+    else:
+        ds = [[d, i] for i, d in enumerate(degree_sequence)]
+    ds.sort()
+    cs = []  # creation sequence
+    while ds:
+        if ds[0][0] == 0:  # isolated node
+            (d, v) = ds.pop(0)
+            if len(ds) > 0:  # make sure we start with a d
+                cs.insert(0, (v, "i"))
+            else:
+                cs.insert(0, (v, "d"))
+            continue
+        if ds[-1][0] != len(ds) - 1:  # Not dominating node
+            return None  # not a threshold degree sequence
+        (d, v) = ds.pop()
+        cs.insert(0, (v, "d"))
+        ds = [[d[0] - 1, d[1]] for d in ds]  # decrement due to removing node
+
+    if with_labels:
+        return cs
+    if compact:
+        return make_compact(cs)
+    return [v[1] for v in cs]  # not labeled
+
+
+def make_compact(creation_sequence):
+    """
+    Returns the creation sequence in a compact form
+    that is the number of 'i's and 'd's alternating.
+
+    Examples
+    --------
+    >>> from networkx.algorithms.threshold import make_compact
+    >>> make_compact(["d", "i", "i", "d", "d", "i", "i", "i"])
+    [1, 2, 2, 3]
+    >>> make_compact(["d", "d", "d", "i", "d", "d"])
+    [3, 1, 2]
+
+    Notice that the first number is the first vertex
+    to be used for construction and so is always 'd'.
+
+    Labeled creation sequences lose their labels in the
+    compact representation.
+
+    >>> make_compact([3, 1, 2])
+    [3, 1, 2]
+    """
+    first = creation_sequence[0]
+    if isinstance(first, str):  # creation sequence
+        cs = creation_sequence[:]
+    elif isinstance(first, tuple):  # labeled creation sequence
+        cs = [s[1] for s in creation_sequence]
+    elif isinstance(first, int):  # compact creation sequence
+        return creation_sequence
+    else:
+        raise TypeError("Not a valid creation sequence type")
+
+    ccs = []
+    count = 1  # count the run lengths of d's or i's.
+    for i in range(1, len(cs)):
+        if cs[i] == cs[i - 1]:
+            count += 1
+        else:
+            ccs.append(count)
+            count = 1
+    ccs.append(count)  # don't forget the last one
+    return ccs
+
+
+def uncompact(creation_sequence):
+    """
+    Converts a compact creation sequence for a threshold
+    graph to a standard creation sequence (unlabeled).
+    If the creation_sequence is already standard, return it.
+    See creation_sequence.
+    """
+    first = creation_sequence[0]
+    if isinstance(first, str):  # creation sequence
+        return creation_sequence
+    elif isinstance(first, tuple):  # labeled creation sequence
+        return creation_sequence
+    elif isinstance(first, int):  # compact creation sequence
+        ccscopy = creation_sequence[:]
+    else:
+        raise TypeError("Not a valid creation sequence type")
+    cs = []
+    while ccscopy:
+        cs.extend(ccscopy.pop(0) * ["d"])
+        if ccscopy:
+            cs.extend(ccscopy.pop(0) * ["i"])
+    return cs
+
+
+def creation_sequence_to_weights(creation_sequence):
+    """
+    Returns a list of node weights which create the threshold
+    graph designated by the creation sequence.  The weights
+    are scaled so that the threshold is 1.0.  The order of the
+    nodes is the same as that in the creation sequence.
+    """
+    # Turn input sequence into a labeled creation sequence
+    first = creation_sequence[0]
+    if isinstance(first, str):  # creation sequence
+        if isinstance(creation_sequence, list):
+            wseq = creation_sequence[:]
+        else:
+            wseq = list(creation_sequence)  # string like 'ddidid'
+    elif isinstance(first, tuple):  # labeled creation sequence
+        wseq = [v[1] for v in creation_sequence]
+    elif isinstance(first, int):  # compact creation sequence
+        wseq = uncompact(creation_sequence)
+    else:
+        raise TypeError("Not a valid creation sequence type")
+    # pass through twice--first backwards
+    wseq.reverse()
+    w = 0
+    prev = "i"
+    for j, s in enumerate(wseq):
+        if s == "i":
+            wseq[j] = w
+            prev = s
+        elif prev == "i":
+            prev = s
+            w += 1
+    wseq.reverse()  # now pass through forwards
+    for j, s in enumerate(wseq):
+        if s == "d":
+            wseq[j] = w
+            prev = s
+        elif prev == "d":
+            prev = s
+            w += 1
+    # Now scale weights
+    if prev == "d":
+        w += 1
+    wscale = 1 / w
+    return [ww * wscale for ww in wseq]
+    # return wseq
+
+
+def weights_to_creation_sequence(
+    weights, threshold=1, with_labels=False, compact=False
+):
+    """
+    Returns a creation sequence for a threshold graph
+    determined by the weights and threshold given as input.
+    If the sum of two node weights is greater than the
+    threshold value, an edge is created between these nodes.
+
+    The creation sequence is a list of single characters 'd'
+    or 'i': 'd' for dominating or 'i' for isolated vertices.
+    Dominating vertices are connected to all vertices present
+    when it is added.  The first node added is by convention 'd'.
+
+    If with_labels==True:
+    Returns a list of 2-tuples containing the vertex number
+    and a character 'd' or 'i' which describes the type of vertex.
+
+    If compact==True:
+    Returns the creation sequence in a compact form that is the number
+    of 'i's and 'd's alternating.
+    Examples:
+    [1,2,2,3] represents d,i,i,d,d,i,i,i
+    [3,1,2] represents d,d,d,i,d,d
+
+    Notice that the first number is the first vertex to be used for
+    construction and so is always 'd'.
+
+    with_labels and compact cannot both be True.
+    """
+    if with_labels and compact:
+        raise ValueError("compact sequences cannot be labeled")
+
+    # make an indexed copy
+    if isinstance(weights, dict):  # labeled weights
+        wseq = [[w, label] for (label, w) in weights.items()]
+    else:
+        wseq = [[w, i] for i, w in enumerate(weights)]
+    wseq.sort()
+    cs = []  # creation sequence
+    cutoff = threshold - wseq[-1][0]
+    while wseq:
+        if wseq[0][0] < cutoff:  # isolated node
+            (w, label) = wseq.pop(0)
+            cs.append((label, "i"))
+        else:
+            (w, label) = wseq.pop()
+            cs.append((label, "d"))
+            cutoff = threshold - wseq[-1][0]
+        if len(wseq) == 1:  # make sure we start with a d
+            (w, label) = wseq.pop()
+            cs.append((label, "d"))
+    # put in correct order
+    cs.reverse()
+
+    if with_labels:
+        return cs
+    if compact:
+        return make_compact(cs)
+    return [v[1] for v in cs]  # not labeled
+
+
+# Manipulating NetworkX.Graphs in context of threshold graphs
+def threshold_graph(creation_sequence, create_using=None):
+    """
+    Create a threshold graph from the creation sequence or compact
+    creation_sequence.
+
+    The input sequence can be a
+
+    creation sequence (e.g. ['d','i','d','d','d','i'])
+    labeled creation sequence (e.g. [(0,'d'),(2,'d'),(1,'i')])
+    compact creation sequence (e.g. [2,1,1,2,0])
+
+    Use cs=creation_sequence(degree_sequence,labeled=True)
+    to convert a degree sequence to a creation sequence.
+
+    Returns None if the sequence is not valid
+    """
+    # Turn input sequence into a labeled creation sequence
+    first = creation_sequence[0]
+    if isinstance(first, str):  # creation sequence
+        ci = list(enumerate(creation_sequence))
+    elif isinstance(first, tuple):  # labeled creation sequence
+        ci = creation_sequence[:]
+    elif isinstance(first, int):  # compact creation sequence
+        cs = uncompact(creation_sequence)
+        ci = list(enumerate(cs))
+    else:
+        print("not a valid creation sequence type")
+        return None
+
+    G = nx.empty_graph(0, create_using)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    G.name = "Threshold Graph"
+
+    # add nodes and edges
+    # if type is 'i' just add nodea
+    # if type is a d connect to everything previous
+    while ci:
+        (v, node_type) = ci.pop(0)
+        if node_type == "d":  # dominating type, connect to all existing nodes
+            # We use `for u in list(G):` instead of
+            # `for u in G:` because we edit the graph `G` in
+            # the loop. Hence using an iterator will result in
+            # `RuntimeError: dictionary changed size during iteration`
+            for u in list(G):
+                G.add_edge(v, u)
+        G.add_node(v)
+    return G
+
+
+def find_alternating_4_cycle(G):
+    """
+    Returns False if there aren't any alternating 4 cycles.
+    Otherwise returns the cycle as [a,b,c,d] where (a,b)
+    and (c,d) are edges and (a,c) and (b,d) are not.
+    """
+    for (u, v) in G.edges():
+        for w in G.nodes():
+            if not G.has_edge(u, w) and u != w:
+                for x in G.neighbors(w):
+                    if not G.has_edge(v, x) and v != x:
+                        return [u, v, w, x]
+    return False
+
+
+def find_threshold_graph(G, create_using=None):
+    """
+    Returns a threshold subgraph that is close to largest in `G`.
+
+    The threshold graph will contain the largest degree node in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph instance
+        An instance of `Graph`, or `MultiDiGraph`
+    create_using : NetworkX graph class or `None` (default), optional
+        Type of graph to use when constructing the threshold graph.
+        If `None`, infer the appropriate graph type from the input.
+
+    Returns
+    -------
+    graph :
+        A graph instance representing the threshold graph
+
+    Examples
+    --------
+    >>> from networkx.algorithms.threshold import find_threshold_graph
+    >>> G = nx.barbell_graph(3, 3)
+    >>> T = find_threshold_graph(G)
+    >>> T.nodes # may vary
+    NodeView((7, 8, 5, 6))
+
+    References
+    ----------
+    .. [1] Threshold graphs: https://en.wikipedia.org/wiki/Threshold_graph
+    """
+    return threshold_graph(find_creation_sequence(G), create_using)
+
+
+def find_creation_sequence(G):
+    """
+    Find a threshold subgraph that is close to largest in G.
+    Returns the labeled creation sequence of that threshold graph.
+    """
+    cs = []
+    # get a local pointer to the working part of the graph
+    H = G
+    while H.order() > 0:
+        # get new degree sequence on subgraph
+        dsdict = dict(H.degree())
+        ds = [(d, v) for v, d in dsdict.items()]
+        ds.sort()
+        # Update threshold graph nodes
+        if ds[-1][0] == 0:  # all are isolated
+            cs.extend(zip(dsdict, ["i"] * (len(ds) - 1) + ["d"]))
+            break  # Done!
+        # pull off isolated nodes
+        while ds[0][0] == 0:
+            (d, iso) = ds.pop(0)
+            cs.append((iso, "i"))
+        # find new biggest node
+        (d, bigv) = ds.pop()
+        # add edges of star to t_g
+        cs.append((bigv, "d"))
+        # form subgraph of neighbors of big node
+        H = H.subgraph(H.neighbors(bigv))
+    cs.reverse()
+    return cs
+
+
+# Properties of Threshold Graphs
+def triangles(creation_sequence):
+    """
+    Compute number of triangles in the threshold graph with the
+    given creation sequence.
+    """
+    # shortcut algorithm that doesn't require computing number
+    # of triangles at each node.
+    cs = creation_sequence  # alias
+    dr = cs.count("d")  # number of d's in sequence
+    ntri = dr * (dr - 1) * (dr - 2) / 6  # number of triangles in clique of nd d's
+    # now add dr choose 2 triangles for every 'i' in sequence where
+    # dr is the number of d's to the right of the current i
+    for i, typ in enumerate(cs):
+        if typ == "i":
+            ntri += dr * (dr - 1) / 2
+        else:
+            dr -= 1
+    return ntri
+
+
+def triangle_sequence(creation_sequence):
+    """
+    Return triangle sequence for the given threshold graph creation sequence.
+
+    """
+    cs = creation_sequence
+    seq = []
+    dr = cs.count("d")  # number of d's to the right of the current pos
+    dcur = (dr - 1) * (dr - 2) // 2  # number of triangles through a node of clique dr
+    irun = 0  # number of i's in the last run
+    drun = 0  # number of d's in the last run
+    for i, sym in enumerate(cs):
+        if sym == "d":
+            drun += 1
+            tri = dcur + (dr - 1) * irun  # new triangles at this d
+        else:  # cs[i]="i":
+            if prevsym == "d":  # new string of i's
+                dcur += (dr - 1) * irun  # accumulate shared shortest paths
+                irun = 0  # reset i run counter
+                dr -= drun  # reduce number of d's to right
+                drun = 0  # reset d run counter
+            irun += 1
+            tri = dr * (dr - 1) // 2  # new triangles at this i
+        seq.append(tri)
+        prevsym = sym
+    return seq
+
+
+def cluster_sequence(creation_sequence):
+    """
+    Return cluster sequence for the given threshold graph creation sequence.
+    """
+    triseq = triangle_sequence(creation_sequence)
+    degseq = degree_sequence(creation_sequence)
+    cseq = []
+    for i, deg in enumerate(degseq):
+        tri = triseq[i]
+        if deg <= 1:  # isolated vertex or single pair gets cc 0
+            cseq.append(0)
+            continue
+        max_size = (deg * (deg - 1)) // 2
+        cseq.append(tri / max_size)
+    return cseq
+
+
+def degree_sequence(creation_sequence):
+    """
+    Return degree sequence for the threshold graph with the given
+    creation sequence
+    """
+    cs = creation_sequence  # alias
+    seq = []
+    rd = cs.count("d")  # number of d to the right
+    for i, sym in enumerate(cs):
+        if sym == "d":
+            rd -= 1
+            seq.append(rd + i)
+        else:
+            seq.append(rd)
+    return seq
+
+
+def density(creation_sequence):
+    """
+    Return the density of the graph with this creation_sequence.
+    The density is the fraction of possible edges present.
+    """
+    N = len(creation_sequence)
+    two_size = sum(degree_sequence(creation_sequence))
+    two_possible = N * (N - 1)
+    den = two_size / two_possible
+    return den
+
+
+def degree_correlation(creation_sequence):
+    """
+    Return the degree-degree correlation over all edges.
+    """
+    cs = creation_sequence
+    s1 = 0  # deg_i*deg_j
+    s2 = 0  # deg_i^2+deg_j^2
+    s3 = 0  # deg_i+deg_j
+    m = 0  # number of edges
+    rd = cs.count("d")  # number of d nodes to the right
+    rdi = [i for i, sym in enumerate(cs) if sym == "d"]  # index of "d"s
+    ds = degree_sequence(cs)
+    for i, sym in enumerate(cs):
+        if sym == "d":
+            if i != rdi[0]:
+                print("Logic error in degree_correlation", i, rdi)
+                raise ValueError
+            rdi.pop(0)
+        degi = ds[i]
+        for dj in rdi:
+            degj = ds[dj]
+            s1 += degj * degi
+            s2 += degi**2 + degj**2
+            s3 += degi + degj
+            m += 1
+    denom = 2 * m * s2 - s3 * s3
+    numer = 4 * m * s1 - s3 * s3
+    if denom == 0:
+        if numer == 0:
+            return 1
+        raise ValueError(f"Zero Denominator but Numerator is {numer}")
+    return numer / denom
+
+
+def shortest_path(creation_sequence, u, v):
+    """
+    Find the shortest path between u and v in a
+    threshold graph G with the given creation_sequence.
+
+    For an unlabeled creation_sequence, the vertices
+    u and v must be integers in (0,len(sequence)) referring
+    to the position of the desired vertices in the sequence.
+
+    For a labeled creation_sequence, u and v are labels of veritices.
+
+    Use cs=creation_sequence(degree_sequence,with_labels=True)
+    to convert a degree sequence to a creation sequence.
+
+    Returns a list of vertices from u to v.
+    Example: if they are neighbors, it returns [u,v]
+    """
+    # Turn input sequence into a labeled creation sequence
+    first = creation_sequence[0]
+    if isinstance(first, str):  # creation sequence
+        cs = [(i, creation_sequence[i]) for i in range(len(creation_sequence))]
+    elif isinstance(first, tuple):  # labeled creation sequence
+        cs = creation_sequence[:]
+    elif isinstance(first, int):  # compact creation sequence
+        ci = uncompact(creation_sequence)
+        cs = [(i, ci[i]) for i in range(len(ci))]
+    else:
+        raise TypeError("Not a valid creation sequence type")
+
+    verts = [s[0] for s in cs]
+    if v not in verts:
+        raise ValueError(f"Vertex {v} not in graph from creation_sequence")
+    if u not in verts:
+        raise ValueError(f"Vertex {u} not in graph from creation_sequence")
+    # Done checking
+    if u == v:
+        return [u]
+
+    uindex = verts.index(u)
+    vindex = verts.index(v)
+    bigind = max(uindex, vindex)
+    if cs[bigind][1] == "d":
+        return [u, v]
+    # must be that cs[bigind][1]=='i'
+    cs = cs[bigind:]
+    while cs:
+        vert = cs.pop()
+        if vert[1] == "d":
+            return [u, vert[0], v]
+    # All after u are type 'i' so no connection
+    return -1
+
+
+def shortest_path_length(creation_sequence, i):
+    """
+    Return the shortest path length from indicated node to
+    every other node for the threshold graph with the given
+    creation sequence.
+    Node is indicated by index i in creation_sequence unless
+    creation_sequence is labeled in which case, i is taken to
+    be the label of the node.
+
+    Paths lengths in threshold graphs are at most 2.
+    Length to unreachable nodes is set to -1.
+    """
+    # Turn input sequence into a labeled creation sequence
+    first = creation_sequence[0]
+    if isinstance(first, str):  # creation sequence
+        if isinstance(creation_sequence, list):
+            cs = creation_sequence[:]
+        else:
+            cs = list(creation_sequence)
+    elif isinstance(first, tuple):  # labeled creation sequence
+        cs = [v[1] for v in creation_sequence]
+        i = [v[0] for v in creation_sequence].index(i)
+    elif isinstance(first, int):  # compact creation sequence
+        cs = uncompact(creation_sequence)
+    else:
+        raise TypeError("Not a valid creation sequence type")
+
+    # Compute
+    N = len(cs)
+    spl = [2] * N  # length 2 to every node
+    spl[i] = 0  # except self which is 0
+    # 1 for all d's to the right
+    for j in range(i + 1, N):
+        if cs[j] == "d":
+            spl[j] = 1
+    if cs[i] == "d":  # 1 for all nodes to the left
+        for j in range(i):
+            spl[j] = 1
+    # and -1 for any trailing i to indicate unreachable
+    for j in range(N - 1, 0, -1):
+        if cs[j] == "d":
+            break
+        spl[j] = -1
+    return spl
+
+
+def betweenness_sequence(creation_sequence, normalized=True):
+    """
+    Return betweenness for the threshold graph with the given creation
+    sequence.  The result is unscaled.  To scale the values
+    to the iterval [0,1] divide by (n-1)*(n-2).
+    """
+    cs = creation_sequence
+    seq = []  # betweenness
+    lastchar = "d"  # first node is always a 'd'
+    dr = float(cs.count("d"))  # number of d's to the right of curren pos
+    irun = 0  # number of i's in the last run
+    drun = 0  # number of d's in the last run
+    dlast = 0.0  # betweenness of last d
+    for i, c in enumerate(cs):
+        if c == "d":  # cs[i]=="d":
+            # betweennees = amt shared with eariler d's and i's
+            #             + new isolated nodes covered
+            #             + new paths to all previous nodes
+            b = dlast + (irun - 1) * irun / dr + 2 * irun * (i - drun - irun) / dr
+            drun += 1  # update counter
+        else:  # cs[i]="i":
+            if lastchar == "d":  # if this is a new run of i's
+                dlast = b  # accumulate betweenness
+                dr -= drun  # update number of d's to the right
+                drun = 0  # reset d counter
+                irun = 0  # reset i counter
+            b = 0  # isolated nodes have zero betweenness
+            irun += 1  # add another i to the run
+        seq.append(float(b))
+        lastchar = c
+
+    # normalize by the number of possible shortest paths
+    if normalized:
+        order = len(cs)
+        scale = 1.0 / ((order - 1) * (order - 2))
+        seq = [s * scale for s in seq]
+
+    return seq
+
+
+def eigenvectors(creation_sequence):
+    """
+    Return a 2-tuple of Laplacian eigenvalues and eigenvectors
+    for the threshold network with creation_sequence.
+    The first value is a list of eigenvalues.
+    The second value is a list of eigenvectors.
+    The lists are in the same order so corresponding eigenvectors
+    and eigenvalues are in the same position in the two lists.
+
+    Notice that the order of the eigenvalues returned by eigenvalues(cs)
+    may not correspond to the order of these eigenvectors.
+    """
+    ccs = make_compact(creation_sequence)
+    N = sum(ccs)
+    vec = [0] * N
+    val = vec[:]
+    # get number of type d nodes to the right (all for first node)
+    dr = sum(ccs[::2])
+
+    nn = ccs[0]
+    vec[0] = [1.0 / sqrt(N)] * N
+    val[0] = 0
+    e = dr
+    dr -= nn
+    type_d = True
+    i = 1
+    dd = 1
+    while dd < nn:
+        scale = 1.0 / sqrt(dd * dd + i)
+        vec[i] = i * [-scale] + [dd * scale] + [0] * (N - i - 1)
+        val[i] = e
+        i += 1
+        dd += 1
+    if len(ccs) == 1:
+        return (val, vec)
+    for nn in ccs[1:]:
+        scale = 1.0 / sqrt(nn * i * (i + nn))
+        vec[i] = i * [-nn * scale] + nn * [i * scale] + [0] * (N - i - nn)
+        # find eigenvalue
+        type_d = not type_d
+        if type_d:
+            e = i + dr
+            dr -= nn
+        else:
+            e = dr
+        val[i] = e
+        st = i
+        i += 1
+        dd = 1
+        while dd < nn:
+            scale = 1.0 / sqrt(i - st + dd * dd)
+            vec[i] = [0] * st + (i - st) * [-scale] + [dd * scale] + [0] * (N - i - 1)
+            val[i] = e
+            i += 1
+            dd += 1
+    return (val, vec)
+
+
+def spectral_projection(u, eigenpairs):
+    """
+    Returns the coefficients of each eigenvector
+    in a projection of the vector u onto the normalized
+    eigenvectors which are contained in eigenpairs.
+
+    eigenpairs should be a list of two objects.  The
+    first is a list of eigenvalues and the second a list
+    of eigenvectors.  The eigenvectors should be lists.
+
+    There's not a lot of error checking on lengths of
+    arrays, etc. so be careful.
+    """
+    coeff = []
+    evect = eigenpairs[1]
+    for ev in evect:
+        c = sum(evv * uv for (evv, uv) in zip(ev, u))
+        coeff.append(c)
+    return coeff
+
+
+def eigenvalues(creation_sequence):
+    """
+    Return sequence of eigenvalues of the Laplacian of the threshold
+    graph for the given creation_sequence.
+
+    Based on the Ferrer's diagram method.  The spectrum is integral
+    and is the conjugate of the degree sequence.
+
+    See::
+
+      @Article{degree-merris-1994,
+       author = {Russel Merris},
+       title = {Degree maximal graphs are Laplacian integral},
+       journal = {Linear Algebra Appl.},
+       year = {1994},
+       volume = {199},
+       pages = {381--389},
+      }
+
+    """
+    degseq = degree_sequence(creation_sequence)
+    degseq.sort()
+    eiglist = []  # zero is always one eigenvalue
+    eig = 0
+    row = len(degseq)
+    bigdeg = degseq.pop()
+    while row:
+        if bigdeg < row:
+            eiglist.append(eig)
+            row -= 1
+        else:
+            eig += 1
+            if degseq:
+                bigdeg = degseq.pop()
+            else:
+                bigdeg = 0
+    return eiglist
+
+
+# Threshold graph creation routines
+
+
+@py_random_state(2)
+def random_threshold_sequence(n, p, seed=None):
+    """
+    Create a random threshold sequence of size n.
+    A creation sequence is built by randomly choosing d's with
+    probabiliy p and i's with probability 1-p.
+
+    s=nx.random_threshold_sequence(10,0.5)
+
+    returns a threshold sequence of length 10 with equal
+    probably of an i or a d at each position.
+
+    A "random" threshold graph can be built with
+
+    G=nx.threshold_graph(s)
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    """
+    if not (0 <= p <= 1):
+        raise ValueError("p must be in [0,1]")
+
+    cs = ["d"]  # threshold sequences always start with a d
+    for i in range(1, n):
+        if seed.random() < p:
+            cs.append("d")
+        else:
+            cs.append("i")
+    return cs
+
+
+# maybe *_d_threshold_sequence routines should
+# be (or be called from) a single routine with a more descriptive name
+# and a keyword parameter?
+def right_d_threshold_sequence(n, m):
+    """
+    Create a skewed threshold graph with a given number
+    of vertices (n) and a given number of edges (m).
+
+    The routine returns an unlabeled creation sequence
+    for the threshold graph.
+
+    FIXME: describe algorithm
+
+    """
+    cs = ["d"] + ["i"] * (n - 1)  # create sequence with n insolated nodes
+
+    #  m <n : not enough edges, make disconnected
+    if m < n:
+        cs[m] = "d"
+        return cs
+
+    # too many edges
+    if m > n * (n - 1) / 2:
+        raise ValueError("Too many edges for this many nodes.")
+
+    # connected case m >n-1
+    ind = n - 1
+    sum = n - 1
+    while sum < m:
+        cs[ind] = "d"
+        ind -= 1
+        sum += ind
+    ind = m - (sum - ind)
+    cs[ind] = "d"
+    return cs
+
+
+def left_d_threshold_sequence(n, m):
+    """
+    Create a skewed threshold graph with a given number
+    of vertices (n) and a given number of edges (m).
+
+    The routine returns an unlabeled creation sequence
+    for the threshold graph.
+
+    FIXME: describe algorithm
+
+    """
+    cs = ["d"] + ["i"] * (n - 1)  # create sequence with n insolated nodes
+
+    #  m <n : not enough edges, make disconnected
+    if m < n:
+        cs[m] = "d"
+        return cs
+
+    # too many edges
+    if m > n * (n - 1) / 2:
+        raise ValueError("Too many edges for this many nodes.")
+
+    # Connected case when M>N-1
+    cs[n - 1] = "d"
+    sum = n - 1
+    ind = 1
+    while sum < m:
+        cs[ind] = "d"
+        sum += ind
+        ind += 1
+    if sum > m:  # be sure not to change the first vertex
+        cs[sum - m] = "i"
+    return cs
+
+
+@py_random_state(3)
+def swap_d(cs, p_split=1.0, p_combine=1.0, seed=None):
+    """
+    Perform a "swap" operation on a threshold sequence.
+
+    The swap preserves the number of nodes and edges
+    in the graph for the given sequence.
+    The resulting sequence is still a threshold sequence.
+
+    Perform one split and one combine operation on the
+    'd's of a creation sequence for a threshold graph.
+    This operation maintains the number of nodes and edges
+    in the graph, but shifts the edges from node to node
+    maintaining the threshold quality of the graph.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    """
+    # preprocess the creation sequence
+    dlist = [i for (i, node_type) in enumerate(cs[1:-1]) if node_type == "d"]
+    # split
+    if seed.random() < p_split:
+        choice = seed.choice(dlist)
+        split_to = seed.choice(range(choice))
+        flip_side = choice - split_to
+        if split_to != flip_side and cs[split_to] == "i" and cs[flip_side] == "i":
+            cs[choice] = "i"
+            cs[split_to] = "d"
+            cs[flip_side] = "d"
+            dlist.remove(choice)
+            # don't add or combine may reverse this action
+            # dlist.extend([split_to,flip_side])
+    #            print >>sys.stderr,"split at %s to %s and %s"%(choice,split_to,flip_side)
+    # combine
+    if seed.random() < p_combine and dlist:
+        first_choice = seed.choice(dlist)
+        second_choice = seed.choice(dlist)
+        target = first_choice + second_choice
+        if target >= len(cs) or cs[target] == "d" or first_choice == second_choice:
+            return cs
+        # OK to combine
+        cs[first_choice] = "i"
+        cs[second_choice] = "i"
+        cs[target] = "d"
+    #        print >>sys.stderr,"combine %s and %s to make %s."%(first_choice,second_choice,target)
+
+    return cs
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tournament.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tournament.py
new file mode 100644
index 0000000..278a1c4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tournament.py
@@ -0,0 +1,391 @@
+"""Functions concerning tournament graphs.
+
+A `tournament graph`_ is a complete oriented graph. In other words, it
+is a directed graph in which there is exactly one directed edge joining
+each pair of distinct nodes. For each function in this module that
+accepts a graph as input, you must provide a tournament graph. The
+responsibility is on the caller to ensure that the graph is a tournament
+graph.
+
+To access the functions in this module, you must access them through the
+:mod:`networkx.algorithms.tournament` module::
+
+    >>> from networkx.algorithms import tournament
+    >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 0)])
+    >>> tournament.is_tournament(G)
+    True
+
+.. _tournament graph: https://en.wikipedia.org/wiki/Tournament_%28graph_theory%29
+
+"""
+from itertools import combinations
+
+import networkx as nx
+from networkx.algorithms.simple_paths import is_simple_path as is_path
+from networkx.utils import arbitrary_element, not_implemented_for, py_random_state
+
+__all__ = [
+    "hamiltonian_path",
+    "is_reachable",
+    "is_strongly_connected",
+    "is_tournament",
+    "random_tournament",
+    "score_sequence",
+]
+
+
+def index_satisfying(iterable, condition):
+    """Returns the index of the first element in `iterable` that
+    satisfies the given condition.
+
+    If no such element is found (that is, when the iterable is
+    exhausted), this returns the length of the iterable (that is, one
+    greater than the last index of the iterable).
+
+    `iterable` must not be empty. If `iterable` is empty, this
+    function raises :exc:`ValueError`.
+
+    """
+    # Pre-condition: iterable must not be empty.
+    for i, x in enumerate(iterable):
+        if condition(x):
+            return i
+    # If we reach the end of the iterable without finding an element
+    # that satisfies the condition, return the length of the iterable,
+    # which is one greater than the index of its last element. If the
+    # iterable was empty, `i` will not be defined, so we raise an
+    # exception.
+    try:
+        return i + 1
+    except NameError as err:
+        raise ValueError("iterable must be non-empty") from err
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def is_tournament(G):
+    """Returns True if and only if `G` is a tournament.
+
+    A tournament is a directed graph, with neither self-loops nor
+    multi-edges, in which there is exactly one directed edge joining
+    each pair of distinct nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A directed graph representing a tournament.
+
+    Returns
+    -------
+    bool
+        Whether the given graph is a tournament graph.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import tournament
+    >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 0)])
+    >>> tournament.is_tournament(G)
+    True
+
+    Notes
+    -----
+    Some definitions require a self-loop on each node, but that is not
+    the convention used here.
+
+    """
+    # In a tournament, there is exactly one directed edge joining each pair.
+    return (
+        all((v in G[u]) ^ (u in G[v]) for u, v in combinations(G, 2))
+        and nx.number_of_selfloops(G) == 0
+    )
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def hamiltonian_path(G):
+    """Returns a Hamiltonian path in the given tournament graph.
+
+    Each tournament has a Hamiltonian path. If furthermore, the
+    tournament is strongly connected, then the returned Hamiltonian path
+    is a Hamiltonian cycle (by joining the endpoints of the path).
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A directed graph representing a tournament.
+
+    Returns
+    -------
+    path : list
+        A list of nodes which form a Hamiltonian path in `G`.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import tournament
+    >>> G = nx.DiGraph([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)])
+    >>> tournament.hamiltonian_path(G)
+    [0, 1, 2, 3]
+
+    Notes
+    -----
+    This is a recursive implementation with an asymptotic running time
+    of $O(n^2)$, ignoring multiplicative polylogarithmic factors, where
+    $n$ is the number of nodes in the graph.
+
+    """
+    if len(G) == 0:
+        return []
+    if len(G) == 1:
+        return [arbitrary_element(G)]
+    v = arbitrary_element(G)
+    hampath = hamiltonian_path(G.subgraph(set(G) - {v}))
+    # Get the index of the first node in the path that does *not* have
+    # an edge to `v`, then insert `v` before that node.
+    index = index_satisfying(hampath, lambda u: v not in G[u])
+    hampath.insert(index, v)
+    return hampath
+
+
+@py_random_state(1)
+def random_tournament(n, seed=None):
+    r"""Returns a random tournament graph on `n` nodes.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes in the returned graph.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : DiGraph
+        A tournament on `n` nodes, with exactly one directed edge joining
+        each pair of distinct nodes.
+
+    Notes
+    -----
+    This algorithm adds, for each pair of distinct nodes, an edge with
+    uniformly random orientation. In other words, `\binom{n}{2}` flips
+    of an unbiased coin decide the orientations of the edges in the
+    graph.
+
+    """
+    # Flip an unbiased coin for each pair of distinct nodes.
+    coins = (seed.random() for i in range((n * (n - 1)) // 2))
+    pairs = combinations(range(n), 2)
+    edges = ((u, v) if r < 0.5 else (v, u) for (u, v), r in zip(pairs, coins))
+    return nx.DiGraph(edges)
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def score_sequence(G):
+    """Returns the score sequence for the given tournament graph.
+
+    The score sequence is the sorted list of the out-degrees of the
+    nodes of the graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A directed graph representing a tournament.
+
+    Returns
+    -------
+    list
+        A sorted list of the out-degrees of the nodes of `G`.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import tournament
+    >>> G = nx.DiGraph([(1, 0), (1, 3), (0, 2), (0, 3), (2, 1), (3, 2)])
+    >>> tournament.score_sequence(G)
+    [1, 1, 2, 2]
+
+    """
+    return sorted(d for v, d in G.out_degree())
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def tournament_matrix(G):
+    r"""Returns the tournament matrix for the given tournament graph.
+
+    This function requires SciPy.
+
+    The *tournament matrix* of a tournament graph with edge set *E* is
+    the matrix *T* defined by
+
+    .. math::
+
+       T_{i j} =
+       \begin{cases}
+       +1 & \text{if } (i, j) \in E \\
+       -1 & \text{if } (j, i) \in E \\
+       0 & \text{if } i == j.
+       \end{cases}
+
+    An equivalent definition is `T = A - A^T`, where *A* is the
+    adjacency matrix of the graph `G`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A directed graph representing a tournament.
+
+    Returns
+    -------
+    SciPy sparse matrix
+        The tournament matrix of the tournament graph `G`.
+
+    Raises
+    ------
+    ImportError
+        If SciPy is not available.
+
+    """
+    A = nx.adjacency_matrix(G)
+    return A - A.T
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def is_reachable(G, s, t):
+    """Decides whether there is a path from `s` to `t` in the
+    tournament.
+
+    This function is more theoretically efficient than the reachability
+    checks than the shortest path algorithms in
+    :mod:`networkx.algorithms.shortest_paths`.
+
+    The given graph **must** be a tournament, otherwise this function's
+    behavior is undefined.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A directed graph representing a tournament.
+
+    s : node
+        A node in the graph.
+
+    t : node
+        A node in the graph.
+
+    Returns
+    -------
+    bool
+        Whether there is a path from `s` to `t` in `G`.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import tournament
+    >>> G = nx.DiGraph([(1, 0), (1, 3), (1, 2), (2, 3), (2, 0), (3, 0)])
+    >>> tournament.is_reachable(G, 1, 3)
+    True
+    >>> tournament.is_reachable(G, 3, 2)
+    False
+
+    Notes
+    -----
+    Although this function is more theoretically efficient than the
+    generic shortest path functions, a speedup requires the use of
+    parallelism. Though it may in the future, the current implementation
+    does not use parallelism, thus you may not see much of a speedup.
+
+    This algorithm comes from [1].
+
+    References
+    ----------
+    .. [1] Tantau, Till.
+           "A note on the complexity of the reachability problem for
+           tournaments."
+           *Electronic Colloquium on Computational Complexity*. 2001.
+           <http://eccc.hpi-web.de/report/2001/092/>
+    """
+
+    def two_neighborhood(G, v):
+        """Returns the set of nodes at distance at most two from `v`.
+
+        `G` must be a graph and `v` a node in that graph.
+
+        The returned set includes the nodes at distance zero (that is,
+        the node `v` itself), the nodes at distance one (that is, the
+        out-neighbors of `v`), and the nodes at distance two.
+
+        """
+        # TODO This is trivially parallelizable.
+        return {
+            x for x in G if x == v or x in G[v] or any(is_path(G, [v, z, x]) for z in G)
+        }
+
+    def is_closed(G, nodes):
+        """Decides whether the given set of nodes is closed.
+
+        A set *S* of nodes is *closed* if for each node *u* in the graph
+        not in *S* and for each node *v* in *S*, there is an edge from
+        *u* to *v*.
+
+        """
+        # TODO This is trivially parallelizable.
+        return all(v in G[u] for u in set(G) - nodes for v in nodes)
+
+    # TODO This is trivially parallelizable.
+    neighborhoods = [two_neighborhood(G, v) for v in G]
+    return all(not (is_closed(G, S) and s in S and t not in S) for S in neighborhoods)
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def is_strongly_connected(G):
+    """Decides whether the given tournament is strongly connected.
+
+    This function is more theoretically efficient than the
+    :func:`~networkx.algorithms.components.is_strongly_connected`
+    function.
+
+    The given graph **must** be a tournament, otherwise this function's
+    behavior is undefined.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A directed graph representing a tournament.
+
+    Returns
+    -------
+    bool
+        Whether the tournament is strongly connected.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import tournament
+    >>> G = nx.DiGraph([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3), (3, 0)])
+    >>> tournament.is_strongly_connected(G)
+    True
+    >>> G.remove_edge(1, 3)
+    >>> tournament.is_strongly_connected(G)
+    False
+
+    Notes
+    -----
+    Although this function is more theoretically efficient than the
+    generic strong connectivity function, a speedup requires the use of
+    parallelism. Though it may in the future, the current implementation
+    does not use parallelism, thus you may not see much of a speedup.
+
+    This algorithm comes from [1].
+
+    References
+    ----------
+    .. [1] Tantau, Till.
+           "A note on the complexity of the reachability problem for
+           tournaments."
+           *Electronic Colloquium on Computational Complexity*. 2001.
+           <http://eccc.hpi-web.de/report/2001/092/>
+
+    """
+    # TODO This is trivially parallelizable.
+    return all(is_reachable(G, u, v) for u in G for v in G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/__init__.py
new file mode 100644
index 0000000..93e6cdd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/__init__.py
@@ -0,0 +1,5 @@
+from .beamsearch import *
+from .breadth_first_search import *
+from .depth_first_search import *
+from .edgedfs import *
+from .edgebfs import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/beamsearch.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/beamsearch.py
new file mode 100644
index 0000000..8a112c2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/beamsearch.py
@@ -0,0 +1,104 @@
+"""Basic algorithms for breadth-first searching the nodes of a graph."""
+
+from .breadth_first_search import generic_bfs_edges
+
+__all__ = ["bfs_beam_edges"]
+
+
+def bfs_beam_edges(G, source, value, width=None):
+    """Iterates over edges in a beam search.
+
+    The beam search is a generalized breadth-first search in which only
+    the "best" *w* neighbors of the current node are enqueued, where *w*
+    is the beam width and "best" is an application-specific
+    heuristic. In general, a beam search with a small beam width might
+    not visit each node in the graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+        Starting node for the breadth-first search; this function
+        iterates over only those edges in the component reachable from
+        this node.
+
+    value : function
+        A function that takes a node of the graph as input and returns a
+        real number indicating how "good" it is. A higher value means it
+        is more likely to be visited sooner during the search. When
+        visiting a new node, only the `width` neighbors with the highest
+        `value` are enqueued (in decreasing order of `value`).
+
+    width : int (default = None)
+        The beam width for the search. This is the number of neighbors
+        (ordered by `value`) to enqueue when visiting each new node.
+
+    Yields
+    ------
+    edge
+        Edges in the beam search starting from `source`, given as a pair
+        of nodes.
+
+    Examples
+    --------
+    To give nodes with, for example, a higher centrality precedence
+    during the search, set the `value` function to return the centrality
+    value of the node:
+
+    >>> G = nx.karate_club_graph()
+    >>> centrality = nx.eigenvector_centrality(G)
+    >>> source = 0
+    >>> width = 5
+    >>> for u, v in nx.bfs_beam_edges(G, source, centrality.get, width):
+    ...     print((u, v))
+    ...
+    (0, 2)
+    (0, 1)
+    (0, 8)
+    (0, 13)
+    (0, 3)
+    (2, 32)
+    (1, 30)
+    (8, 33)
+    (3, 7)
+    (32, 31)
+    (31, 28)
+    (31, 25)
+    (25, 23)
+    (25, 24)
+    (23, 29)
+    (23, 27)
+    (29, 26)
+    """
+
+    if width is None:
+        width = len(G)
+
+    def successors(v):
+        """Returns a list of the best neighbors of a node.
+
+        `v` is a node in the graph `G`.
+
+        The "best" neighbors are chosen according to the `value`
+        function (higher is better). Only the `width` best neighbors of
+        `v` are returned.
+
+        The list returned by this function is in decreasing value as
+        measured by the `value` function.
+
+        """
+        # TODO The Python documentation states that for small values, it
+        # is better to use `heapq.nlargest`. We should determine the
+        # threshold at which its better to use `heapq.nlargest()`
+        # instead of `sorted()[:]` and apply that optimization here.
+        #
+        # If `width` is greater than the number of neighbors of `v`, all
+        # neighbors are returned by the semantics of slicing in
+        # Python. This occurs in the special case that the user did not
+        # specify a `width`: in this case all neighbors are always
+        # returned, so this is just a (slower) implementation of
+        # `bfs_edges(G, source)` but with a sorted enqueue step.
+        return iter(sorted(G.neighbors(v), key=value, reverse=True)[:width])
+
+    yield from generic_bfs_edges(G, source, successors)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/breadth_first_search.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/breadth_first_search.py
new file mode 100644
index 0000000..a68dbfe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/breadth_first_search.py
@@ -0,0 +1,420 @@
+"""Basic algorithms for breadth-first searching the nodes of a graph."""
+from collections import deque
+
+import networkx as nx
+
+__all__ = [
+    "bfs_edges",
+    "bfs_tree",
+    "bfs_predecessors",
+    "bfs_successors",
+    "descendants_at_distance",
+]
+
+
+def generic_bfs_edges(G, source, neighbors=None, depth_limit=None, sort_neighbors=None):
+    """Iterate over edges in a breadth-first search.
+
+    The breadth-first search begins at `source` and enqueues the
+    neighbors of newly visited nodes specified by the `neighbors`
+    function.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+        Starting node for the breadth-first search; this function
+        iterates over only those edges in the component reachable from
+        this node.
+
+    neighbors : function
+        A function that takes a newly visited node of the graph as input
+        and returns an *iterator* (not just a list) of nodes that are
+        neighbors of that node. If not specified, this is just the
+        ``G.neighbors`` method, but in general it can be any function
+        that returns an iterator over some or all of the neighbors of a
+        given node, in any order.
+
+    depth_limit : int, optional(default=len(G))
+        Specify the maximum search depth
+
+    sort_neighbors : function
+        A function that takes the list of neighbors of given node as input, and
+        returns an *iterator* over these neighbors but with custom ordering.
+
+    Yields
+    ------
+    edge
+        Edges in the breadth-first search starting from `source`.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(3)
+    >>> print(list(nx.bfs_edges(G, 0)))
+    [(0, 1), (1, 2)]
+    >>> print(list(nx.bfs_edges(G, source=0, depth_limit=1)))
+    [(0, 1)]
+
+    Notes
+    -----
+    This implementation is from `PADS`_, which was in the public domain
+    when it was first accessed in July, 2004.  The modifications
+    to allow depth limits are based on the Wikipedia article
+    "`Depth-limited-search`_".
+
+    .. _PADS: http://www.ics.uci.edu/~eppstein/PADS/BFS.py
+    .. _Depth-limited-search: https://en.wikipedia.org/wiki/Depth-limited_search
+    """
+    if callable(sort_neighbors):
+        _neighbors = neighbors
+        neighbors = lambda node: iter(sort_neighbors(_neighbors(node)))
+
+    visited = {source}
+    if depth_limit is None:
+        depth_limit = len(G)
+    queue = deque([(source, depth_limit, neighbors(source))])
+    while queue:
+        parent, depth_now, children = queue[0]
+        try:
+            child = next(children)
+            if child not in visited:
+                yield parent, child
+                visited.add(child)
+                if depth_now > 1:
+                    queue.append((child, depth_now - 1, neighbors(child)))
+        except StopIteration:
+            queue.popleft()
+
+
+def bfs_edges(G, source, reverse=False, depth_limit=None, sort_neighbors=None):
+    """Iterate over edges in a breadth-first-search starting at source.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Specify starting node for breadth-first search; this function
+       iterates over only those edges in the component reachable from
+       this node.
+
+    reverse : bool, optional
+       If True traverse a directed graph in the reverse direction
+
+    depth_limit : int, optional(default=len(G))
+        Specify the maximum search depth
+
+    sort_neighbors : function
+        A function that takes the list of neighbors of given node as input, and
+        returns an *iterator* over these neighbors but with custom ordering.
+
+    Yields
+    ------
+    edge: 2-tuple of nodes
+       Yields edges resulting from the breadth-first search.
+
+    Examples
+    --------
+    To get the edges in a breadth-first search::
+
+        >>> G = nx.path_graph(3)
+        >>> list(nx.bfs_edges(G, 0))
+        [(0, 1), (1, 2)]
+        >>> list(nx.bfs_edges(G, source=0, depth_limit=1))
+        [(0, 1)]
+
+    To get the nodes in a breadth-first search order::
+
+        >>> G = nx.path_graph(3)
+        >>> root = 2
+        >>> edges = nx.bfs_edges(G, root)
+        >>> nodes = [root] + [v for u, v in edges]
+        >>> nodes
+        [2, 1, 0]
+
+    Notes
+    -----
+    The naming of this function is very similar to
+    :func:`~networkx.algorithms.traversal.edgebfs.edge_bfs`. The difference
+    is that ``edge_bfs`` yields edges even if they extend back to an already
+    explored node while this generator yields the edges of the tree that results
+    from a breadth-first-search (BFS) so no edges are reported if they extend
+    to already explored nodes. That means ``edge_bfs`` reports all edges while
+    ``bfs_edges`` only reports those traversed by a node-based BFS. Yet another
+    description is that ``bfs_edges`` reports the edges traversed during BFS
+    while ``edge_bfs`` reports all edges in the order they are explored.
+
+    Based on the breadth-first search implementation in PADS [1]_
+    by D. Eppstein, July 2004; with modifications to allow depth limits
+    as described in [2]_.
+
+    References
+    ----------
+    .. [1] http://www.ics.uci.edu/~eppstein/PADS/BFS.py.
+    .. [2] https://en.wikipedia.org/wiki/Depth-limited_search
+
+    See Also
+    --------
+    bfs_tree
+    :func:`~networkx.algorithms.traversal.depth_first_search.dfs_edges`
+    :func:`~networkx.algorithms.traversal.edgebfs.edge_bfs`
+
+    """
+    if reverse and G.is_directed():
+        successors = G.predecessors
+    else:
+        successors = G.neighbors
+    yield from generic_bfs_edges(G, source, successors, depth_limit, sort_neighbors)
+
+
+def bfs_tree(G, source, reverse=False, depth_limit=None, sort_neighbors=None):
+    """Returns an oriented tree constructed from of a breadth-first-search
+    starting at source.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Specify starting node for breadth-first search
+
+    reverse : bool, optional
+       If True traverse a directed graph in the reverse direction
+
+    depth_limit : int, optional(default=len(G))
+        Specify the maximum search depth
+
+    sort_neighbors : function
+        A function that takes the list of neighbors of given node as input, and
+        returns an *iterator* over these neighbors but with custom ordering.
+
+    Returns
+    -------
+    T: NetworkX DiGraph
+       An oriented tree
+
+    Examples
+    --------
+    >>> G = nx.path_graph(3)
+    >>> print(list(nx.bfs_tree(G, 1).edges()))
+    [(1, 0), (1, 2)]
+    >>> H = nx.Graph()
+    >>> nx.add_path(H, [0, 1, 2, 3, 4, 5, 6])
+    >>> nx.add_path(H, [2, 7, 8, 9, 10])
+    >>> print(sorted(list(nx.bfs_tree(H, source=3, depth_limit=3).edges())))
+    [(1, 0), (2, 1), (2, 7), (3, 2), (3, 4), (4, 5), (5, 6), (7, 8)]
+
+
+    Notes
+    -----
+    Based on http://www.ics.uci.edu/~eppstein/PADS/BFS.py
+    by D. Eppstein, July 2004. The modifications
+    to allow depth limits based on the Wikipedia article
+    "`Depth-limited-search`_".
+
+    .. _Depth-limited-search: https://en.wikipedia.org/wiki/Depth-limited_search
+
+    See Also
+    --------
+    dfs_tree
+    bfs_edges
+    edge_bfs
+    """
+    T = nx.DiGraph()
+    T.add_node(source)
+    edges_gen = bfs_edges(
+        G,
+        source,
+        reverse=reverse,
+        depth_limit=depth_limit,
+        sort_neighbors=sort_neighbors,
+    )
+    T.add_edges_from(edges_gen)
+    return T
+
+
+def bfs_predecessors(G, source, depth_limit=None, sort_neighbors=None):
+    """Returns an iterator of predecessors in breadth-first-search from source.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Specify starting node for breadth-first search
+
+    depth_limit : int, optional(default=len(G))
+        Specify the maximum search depth
+
+    sort_neighbors : function
+        A function that takes the list of neighbors of given node as input, and
+        returns an *iterator* over these neighbors but with custom ordering.
+
+    Returns
+    -------
+    pred: iterator
+        (node, predecessor) iterator where `predecessor` is the predecessor of
+        `node` in a breadth first search starting from `source`.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(3)
+    >>> print(dict(nx.bfs_predecessors(G, 0)))
+    {1: 0, 2: 1}
+    >>> H = nx.Graph()
+    >>> H.add_edges_from([(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6)])
+    >>> print(dict(nx.bfs_predecessors(H, 0)))
+    {1: 0, 2: 0, 3: 1, 4: 1, 5: 2, 6: 2}
+    >>> M = nx.Graph()
+    >>> nx.add_path(M, [0, 1, 2, 3, 4, 5, 6])
+    >>> nx.add_path(M, [2, 7, 8, 9, 10])
+    >>> print(sorted(nx.bfs_predecessors(M, source=1, depth_limit=3)))
+    [(0, 1), (2, 1), (3, 2), (4, 3), (7, 2), (8, 7)]
+    >>> N = nx.DiGraph()
+    >>> nx.add_path(N, [0, 1, 2, 3, 4, 7])
+    >>> nx.add_path(N, [3, 5, 6, 7])
+    >>> print(sorted(nx.bfs_predecessors(N, source=2)))
+    [(3, 2), (4, 3), (5, 3), (6, 5), (7, 4)]
+
+    Notes
+    -----
+    Based on http://www.ics.uci.edu/~eppstein/PADS/BFS.py
+    by D. Eppstein, July 2004. The modifications
+    to allow depth limits based on the Wikipedia article
+    "`Depth-limited-search`_".
+
+    .. _Depth-limited-search: https://en.wikipedia.org/wiki/Depth-limited_search
+
+    See Also
+    --------
+    bfs_tree
+    bfs_edges
+    edge_bfs
+    """
+    for s, t in bfs_edges(
+        G, source, depth_limit=depth_limit, sort_neighbors=sort_neighbors
+    ):
+        yield (t, s)
+
+
+def bfs_successors(G, source, depth_limit=None, sort_neighbors=None):
+    """Returns an iterator of successors in breadth-first-search from source.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node
+       Specify starting node for breadth-first search
+
+    depth_limit : int, optional(default=len(G))
+        Specify the maximum search depth
+
+    sort_neighbors : function
+        A function that takes the list of neighbors of given node as input, and
+        returns an *iterator* over these neighbors but with custom ordering.
+
+    Returns
+    -------
+    succ: iterator
+       (node, successors) iterator where `successors` is the non-empty list of
+       successors of `node` in a breadth first search from `source`.
+       To appear in the iterator, `node` must have successors.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(3)
+    >>> print(dict(nx.bfs_successors(G, 0)))
+    {0: [1], 1: [2]}
+    >>> H = nx.Graph()
+    >>> H.add_edges_from([(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6)])
+    >>> print(dict(nx.bfs_successors(H, 0)))
+    {0: [1, 2], 1: [3, 4], 2: [5, 6]}
+    >>> G = nx.Graph()
+    >>> nx.add_path(G, [0, 1, 2, 3, 4, 5, 6])
+    >>> nx.add_path(G, [2, 7, 8, 9, 10])
+    >>> print(dict(nx.bfs_successors(G, source=1, depth_limit=3)))
+    {1: [0, 2], 2: [3, 7], 3: [4], 7: [8]}
+    >>> G = nx.DiGraph()
+    >>> nx.add_path(G, [0, 1, 2, 3, 4, 5])
+    >>> print(dict(nx.bfs_successors(G, source=3)))
+    {3: [4], 4: [5]}
+
+    Notes
+    -----
+    Based on http://www.ics.uci.edu/~eppstein/PADS/BFS.py
+    by D. Eppstein, July 2004.The modifications
+    to allow depth limits based on the Wikipedia article
+    "`Depth-limited-search`_".
+
+    .. _Depth-limited-search: https://en.wikipedia.org/wiki/Depth-limited_search
+
+    See Also
+    --------
+    bfs_tree
+    bfs_edges
+    edge_bfs
+    """
+    parent = source
+    children = []
+    for p, c in bfs_edges(
+        G, source, depth_limit=depth_limit, sort_neighbors=sort_neighbors
+    ):
+        if p == parent:
+            children.append(c)
+            continue
+        yield (parent, children)
+        children = [c]
+        parent = p
+    yield (parent, children)
+
+
+def descendants_at_distance(G, source, distance):
+    """Returns all nodes at a fixed `distance` from `source` in `G`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A graph
+    source : node in `G`
+    distance : the distance of the wanted nodes from `source`
+
+    Returns
+    -------
+    set()
+        The descendants of `source` in `G` at the given `distance` from `source`
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> nx.descendants_at_distance(G, 2, 2)
+    {0, 4}
+    >>> H = nx.DiGraph()
+    >>> H.add_edges_from([(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6)])
+    >>> nx.descendants_at_distance(H, 0, 2)
+    {3, 4, 5, 6}
+    >>> nx.descendants_at_distance(H, 5, 0)
+    {5}
+    >>> nx.descendants_at_distance(H, 5, 1)
+    set()
+    """
+    if not G.has_node(source):
+        raise nx.NetworkXError(f"The node {source} is not in the graph.")
+    current_distance = 0
+    current_layer = {source}
+    visited = {source}
+
+    # this is basically BFS, except that the current layer only stores the nodes at
+    # current_distance from source at each iteration
+    while current_distance < distance:
+        next_layer = set()
+        for node in current_layer:
+            for child in G[node]:
+                if child not in visited:
+                    visited.add(child)
+                    next_layer.add(child)
+        current_layer = next_layer
+        current_distance += 1
+
+    return current_layer
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/depth_first_search.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/depth_first_search.py
new file mode 100644
index 0000000..0ccca4f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/depth_first_search.py
@@ -0,0 +1,443 @@
+"""Basic algorithms for depth-first searching the nodes of a graph."""
+from collections import defaultdict
+
+import networkx as nx
+
+__all__ = [
+    "dfs_edges",
+    "dfs_tree",
+    "dfs_predecessors",
+    "dfs_successors",
+    "dfs_preorder_nodes",
+    "dfs_postorder_nodes",
+    "dfs_labeled_edges",
+]
+
+
+def dfs_edges(G, source=None, depth_limit=None):
+    """Iterate over edges in a depth-first-search (DFS).
+
+    Perform a depth-first-search over the nodes of `G` and yield
+    the edges in order. This may not generate all edges in `G`
+    (see `~networkx.algorithms.traversal.edgedfs.edge_dfs`).
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node, optional
+       Specify starting node for depth-first search and yield edges in
+       the component reachable from source.
+
+    depth_limit : int, optional (default=len(G))
+       Specify the maximum search depth.
+
+    Yields
+    ------
+    edge: 2-tuple of nodes
+       Yields edges resulting from the depth-first-search.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> list(nx.dfs_edges(G, source=0))
+    [(0, 1), (1, 2), (2, 3), (3, 4)]
+    >>> list(nx.dfs_edges(G, source=0, depth_limit=2))
+    [(0, 1), (1, 2)]
+
+    Notes
+    -----
+    If a source is not specified then a source is chosen arbitrarily and
+    repeatedly until all components in the graph are searched.
+
+    The implementation of this function is adapted from David Eppstein's
+    depth-first search function in PADS [1]_, with modifications
+    to allow depth limits based on the Wikipedia article
+    "Depth-limited search" [2]_.
+
+    See Also
+    --------
+    dfs_preorder_nodes
+    dfs_postorder_nodes
+    dfs_labeled_edges
+    :func:`~networkx.algorithms.traversal.edgedfs.edge_dfs`
+    :func:`~networkx.algorithms.traversal.breadth_first_search.bfs_edges`
+
+    References
+    ----------
+    .. [1] http://www.ics.uci.edu/~eppstein/PADS
+    .. [2] https://en.wikipedia.org/wiki/Depth-limited_search
+    """
+    if source is None:
+        # edges for all components
+        nodes = G
+    else:
+        # edges for components with source
+        nodes = [source]
+    visited = set()
+    if depth_limit is None:
+        depth_limit = len(G)
+    for start in nodes:
+        if start in visited:
+            continue
+        visited.add(start)
+        stack = [(start, depth_limit, iter(G[start]))]
+        while stack:
+            parent, depth_now, children = stack[-1]
+            try:
+                child = next(children)
+                if child not in visited:
+                    yield parent, child
+                    visited.add(child)
+                    if depth_now > 1:
+                        stack.append((child, depth_now - 1, iter(G[child])))
+            except StopIteration:
+                stack.pop()
+
+
+def dfs_tree(G, source=None, depth_limit=None):
+    """Returns oriented tree constructed from a depth-first-search from source.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node, optional
+       Specify starting node for depth-first search.
+
+    depth_limit : int, optional (default=len(G))
+       Specify the maximum search depth.
+
+    Returns
+    -------
+    T : NetworkX DiGraph
+       An oriented tree
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> T = nx.dfs_tree(G, source=0, depth_limit=2)
+    >>> list(T.edges())
+    [(0, 1), (1, 2)]
+    >>> T = nx.dfs_tree(G, source=0)
+    >>> list(T.edges())
+    [(0, 1), (1, 2), (2, 3), (3, 4)]
+
+    See Also
+    --------
+    dfs_preorder_nodes
+    dfs_postorder_nodes
+    dfs_labeled_edges
+    edge_dfs
+    bfs_tree
+    """
+    T = nx.DiGraph()
+    if source is None:
+        T.add_nodes_from(G)
+    else:
+        T.add_node(source)
+    T.add_edges_from(dfs_edges(G, source, depth_limit))
+    return T
+
+
+def dfs_predecessors(G, source=None, depth_limit=None):
+    """Returns dictionary of predecessors in depth-first-search from source.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node, optional
+       Specify starting node for depth-first search.
+
+    depth_limit : int, optional (default=len(G))
+       Specify the maximum search depth.
+
+    Returns
+    -------
+    pred: dict
+       A dictionary with nodes as keys and predecessor nodes as values.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.dfs_predecessors(G, source=0)
+    {1: 0, 2: 1, 3: 2}
+    >>> nx.dfs_predecessors(G, source=0, depth_limit=2)
+    {1: 0, 2: 1}
+
+    Notes
+    -----
+    If a source is not specified then a source is chosen arbitrarily and
+    repeatedly until all components in the graph are searched.
+
+    The implementation of this function is adapted from David Eppstein's
+    depth-first search function in `PADS`_, with modifications
+    to allow depth limits based on the Wikipedia article
+    "`Depth-limited search`_".
+
+    .. _PADS: http://www.ics.uci.edu/~eppstein/PADS
+    .. _Depth-limited search: https://en.wikipedia.org/wiki/Depth-limited_search
+
+    See Also
+    --------
+    dfs_preorder_nodes
+    dfs_postorder_nodes
+    dfs_labeled_edges
+    edge_dfs
+    bfs_tree
+    """
+    return {t: s for s, t in dfs_edges(G, source, depth_limit)}
+
+
+def dfs_successors(G, source=None, depth_limit=None):
+    """Returns dictionary of successors in depth-first-search from source.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node, optional
+       Specify starting node for depth-first search.
+
+    depth_limit : int, optional (default=len(G))
+       Specify the maximum search depth.
+
+    Returns
+    -------
+    succ: dict
+       A dictionary with nodes as keys and list of successor nodes as values.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> nx.dfs_successors(G, source=0)
+    {0: [1], 1: [2], 2: [3], 3: [4]}
+    >>> nx.dfs_successors(G, source=0, depth_limit=2)
+    {0: [1], 1: [2]}
+
+    Notes
+    -----
+    If a source is not specified then a source is chosen arbitrarily and
+    repeatedly until all components in the graph are searched.
+
+    The implementation of this function is adapted from David Eppstein's
+    depth-first search function in `PADS`_, with modifications
+    to allow depth limits based on the Wikipedia article
+    "`Depth-limited search`_".
+
+    .. _PADS: http://www.ics.uci.edu/~eppstein/PADS
+    .. _Depth-limited search: https://en.wikipedia.org/wiki/Depth-limited_search
+
+    See Also
+    --------
+    dfs_preorder_nodes
+    dfs_postorder_nodes
+    dfs_labeled_edges
+    edge_dfs
+    bfs_tree
+    """
+    d = defaultdict(list)
+    for s, t in dfs_edges(G, source=source, depth_limit=depth_limit):
+        d[s].append(t)
+    return dict(d)
+
+
+def dfs_postorder_nodes(G, source=None, depth_limit=None):
+    """Generate nodes in a depth-first-search post-ordering starting at source.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node, optional
+       Specify starting node for depth-first search.
+
+    depth_limit : int, optional (default=len(G))
+       Specify the maximum search depth.
+
+    Returns
+    -------
+    nodes: generator
+       A generator of nodes in a depth-first-search post-ordering.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> list(nx.dfs_postorder_nodes(G, source=0))
+    [4, 3, 2, 1, 0]
+    >>> list(nx.dfs_postorder_nodes(G, source=0, depth_limit=2))
+    [1, 0]
+
+    Notes
+    -----
+    If a source is not specified then a source is chosen arbitrarily and
+    repeatedly until all components in the graph are searched.
+
+    The implementation of this function is adapted from David Eppstein's
+    depth-first search function in `PADS`_, with modifications
+    to allow depth limits based on the Wikipedia article
+    "`Depth-limited search`_".
+
+    .. _PADS: http://www.ics.uci.edu/~eppstein/PADS
+    .. _Depth-limited search: https://en.wikipedia.org/wiki/Depth-limited_search
+
+    See Also
+    --------
+    dfs_edges
+    dfs_preorder_nodes
+    dfs_labeled_edges
+    edge_dfs
+    bfs_tree
+    """
+    edges = nx.dfs_labeled_edges(G, source=source, depth_limit=depth_limit)
+    return (v for u, v, d in edges if d == "reverse")
+
+
+def dfs_preorder_nodes(G, source=None, depth_limit=None):
+    """Generate nodes in a depth-first-search pre-ordering starting at source.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node, optional
+       Specify starting node for depth-first search and return nodes in
+       the component reachable from source.
+
+    depth_limit : int, optional (default=len(G))
+       Specify the maximum search depth.
+
+    Returns
+    -------
+    nodes: generator
+       A generator of nodes in a depth-first-search pre-ordering.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> list(nx.dfs_preorder_nodes(G, source=0))
+    [0, 1, 2, 3, 4]
+    >>> list(nx.dfs_preorder_nodes(G, source=0, depth_limit=2))
+    [0, 1, 2]
+
+    Notes
+    -----
+    If a source is not specified then a source is chosen arbitrarily and
+    repeatedly until all components in the graph are searched.
+
+    The implementation of this function is adapted from David Eppstein's
+    depth-first search function in `PADS`_, with modifications
+    to allow depth limits based on the Wikipedia article
+    "`Depth-limited search`_".
+
+    .. _PADS: http://www.ics.uci.edu/~eppstein/PADS
+    .. _Depth-limited search: https://en.wikipedia.org/wiki/Depth-limited_search
+
+    See Also
+    --------
+    dfs_edges
+    dfs_postorder_nodes
+    dfs_labeled_edges
+    bfs_edges
+    """
+    edges = nx.dfs_labeled_edges(G, source=source, depth_limit=depth_limit)
+    return (v for u, v, d in edges if d == "forward")
+
+
+def dfs_labeled_edges(G, source=None, depth_limit=None):
+    """Iterate over edges in a depth-first-search (DFS) labeled by type.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    source : node, optional
+       Specify starting node for depth-first search and return edges in
+       the component reachable from source.
+
+    depth_limit : int, optional (default=len(G))
+       Specify the maximum search depth.
+
+    Returns
+    -------
+    edges: generator
+       A generator of triples of the form (*u*, *v*, *d*), where (*u*,
+       *v*) is the edge being explored in the depth-first search and *d*
+       is one of the strings 'forward', 'nontree', or 'reverse'. A
+       'forward' edge is one in which *u* has been visited but *v* has
+       not. A 'nontree' edge is one in which both *u* and *v* have been
+       visited but the edge is not in the DFS tree. A 'reverse' edge is
+       on in which both *u* and *v* have been visited and the edge is in
+       the DFS tree.
+
+    Examples
+    --------
+
+    The labels reveal the complete transcript of the depth-first search
+    algorithm in more detail than, for example, :func:`dfs_edges`::
+
+        >>> from pprint import pprint
+        >>>
+        >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 1)])
+        >>> pprint(list(nx.dfs_labeled_edges(G, source=0)))
+        [(0, 0, 'forward'),
+         (0, 1, 'forward'),
+         (1, 2, 'forward'),
+         (2, 1, 'nontree'),
+         (1, 2, 'reverse'),
+         (0, 1, 'reverse'),
+         (0, 0, 'reverse')]
+
+    Notes
+    -----
+    If a source is not specified then a source is chosen arbitrarily and
+    repeatedly until all components in the graph are searched.
+
+    The implementation of this function is adapted from David Eppstein's
+    depth-first search function in `PADS`_, with modifications
+    to allow depth limits based on the Wikipedia article
+    "`Depth-limited search`_".
+
+    .. _PADS: http://www.ics.uci.edu/~eppstein/PADS
+    .. _Depth-limited search: https://en.wikipedia.org/wiki/Depth-limited_search
+
+    See Also
+    --------
+    dfs_edges
+    dfs_preorder_nodes
+    dfs_postorder_nodes
+    """
+    # Based on http://www.ics.uci.edu/~eppstein/PADS/DFS.py
+    # by D. Eppstein, July 2004.
+    if source is None:
+        # edges for all components
+        nodes = G
+    else:
+        # edges for components with source
+        nodes = [source]
+    visited = set()
+    if depth_limit is None:
+        depth_limit = len(G)
+    for start in nodes:
+        if start in visited:
+            continue
+        yield start, start, "forward"
+        visited.add(start)
+        stack = [(start, depth_limit, iter(G[start]))]
+        while stack:
+            parent, depth_now, children = stack[-1]
+            try:
+                child = next(children)
+                if child in visited:
+                    yield parent, child, "nontree"
+                else:
+                    yield parent, child, "forward"
+                    visited.add(child)
+                    if depth_now > 1:
+                        stack.append((child, depth_now - 1, iter(G[child])))
+            except StopIteration:
+                stack.pop()
+                if stack:
+                    yield stack[-1][0], parent, "reverse"
+        yield start, start, "reverse"
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/edgebfs.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/edgebfs.py
new file mode 100644
index 0000000..4e1c541
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/edgebfs.py
@@ -0,0 +1,176 @@
+"""
+=============================
+Breadth First Search on Edges
+=============================
+
+Algorithms for a breadth-first traversal of edges in a graph.
+
+"""
+from collections import deque
+
+import networkx as nx
+
+FORWARD = "forward"
+REVERSE = "reverse"
+
+__all__ = ["edge_bfs"]
+
+
+def edge_bfs(G, source=None, orientation=None):
+    """A directed, breadth-first-search of edges in `G`, beginning at `source`.
+
+    Yield the edges of G in a breadth-first-search order continuing until
+    all edges are generated.
+
+    Parameters
+    ----------
+    G : graph
+        A directed/undirected graph/multigraph.
+
+    source : node, list of nodes
+        The node from which the traversal begins. If None, then a source
+        is chosen arbitrarily and repeatedly until all edges from each node in
+        the graph are searched.
+
+    orientation : None | 'original' | 'reverse' | 'ignore' (default: None)
+        For directed graphs and directed multigraphs, edge traversals need not
+        respect the original orientation of the edges.
+        When set to 'reverse' every edge is traversed in the reverse direction.
+        When set to 'ignore', every edge is treated as undirected.
+        When set to 'original', every edge is treated as directed.
+        In all three cases, the yielded edge tuples add a last entry to
+        indicate the direction in which that edge was traversed.
+        If orientation is None, the yielded edge has no direction indicated.
+        The direction is respected, but not reported.
+
+    Yields
+    ------
+    edge : directed edge
+        A directed edge indicating the path taken by the breadth-first-search.
+        For graphs, `edge` is of the form `(u, v)` where `u` and `v`
+        are the tail and head of the edge as determined by the traversal.
+        For multigraphs, `edge` is of the form `(u, v, key)`, where `key` is
+        the key of the edge. When the graph is directed, then `u` and `v`
+        are always in the order of the actual directed edge.
+        If orientation is not None then the edge tuple is extended to include
+        the direction of traversal ('forward' or 'reverse') on that edge.
+
+    Examples
+    --------
+    >>> nodes = [0, 1, 2, 3]
+    >>> edges = [(0, 1), (1, 0), (1, 0), (2, 0), (2, 1), (3, 1)]
+
+    >>> list(nx.edge_bfs(nx.Graph(edges), nodes))
+    [(0, 1), (0, 2), (1, 2), (1, 3)]
+
+    >>> list(nx.edge_bfs(nx.DiGraph(edges), nodes))
+    [(0, 1), (1, 0), (2, 0), (2, 1), (3, 1)]
+
+    >>> list(nx.edge_bfs(nx.MultiGraph(edges), nodes))
+    [(0, 1, 0), (0, 1, 1), (0, 1, 2), (0, 2, 0), (1, 2, 0), (1, 3, 0)]
+
+    >>> list(nx.edge_bfs(nx.MultiDiGraph(edges), nodes))
+    [(0, 1, 0), (1, 0, 0), (1, 0, 1), (2, 0, 0), (2, 1, 0), (3, 1, 0)]
+
+    >>> list(nx.edge_bfs(nx.DiGraph(edges), nodes, orientation="ignore"))
+    [(0, 1, 'forward'), (1, 0, 'reverse'), (2, 0, 'reverse'), (2, 1, 'reverse'), (3, 1, 'reverse')]
+
+    >>> list(nx.edge_bfs(nx.MultiDiGraph(edges), nodes, orientation="ignore"))
+    [(0, 1, 0, 'forward'), (1, 0, 0, 'reverse'), (1, 0, 1, 'reverse'), (2, 0, 0, 'reverse'), (2, 1, 0, 'reverse'), (3, 1, 0, 'reverse')]
+
+    Notes
+    -----
+    The goal of this function is to visit edges. It differs from the more
+    familiar breadth-first-search of nodes, as provided by
+    :func:`networkx.algorithms.traversal.breadth_first_search.bfs_edges`, in
+    that it does not stop once every node has been visited. In a directed graph
+    with edges [(0, 1), (1, 2), (2, 1)], the edge (2, 1) would not be visited
+    if not for the functionality provided by this function.
+
+    The naming of this function is very similar to bfs_edges. The difference
+    is that 'edge_bfs' yields edges even if they extend back to an already
+    explored node while 'bfs_edges' yields the edges of the tree that results
+    from a breadth-first-search (BFS) so no edges are reported if they extend
+    to already explored nodes. That means 'edge_bfs' reports all edges while
+    'bfs_edges' only report those traversed by a node-based BFS. Yet another
+    description is that 'bfs_edges' reports the edges traversed during BFS
+    while 'edge_bfs' reports all edges in the order they are explored.
+
+    See Also
+    --------
+    bfs_edges
+    bfs_tree
+    edge_dfs
+
+    """
+    nodes = list(G.nbunch_iter(source))
+    if not nodes:
+        return
+
+    directed = G.is_directed()
+    kwds = {"data": False}
+    if G.is_multigraph() is True:
+        kwds["keys"] = True
+
+    # set up edge lookup
+    if orientation is None:
+
+        def edges_from(node):
+            return iter(G.edges(node, **kwds))
+
+    elif not directed or orientation == "original":
+
+        def edges_from(node):
+            for e in G.edges(node, **kwds):
+                yield e + (FORWARD,)
+
+    elif orientation == "reverse":
+
+        def edges_from(node):
+            for e in G.in_edges(node, **kwds):
+                yield e + (REVERSE,)
+
+    elif orientation == "ignore":
+
+        def edges_from(node):
+            for e in G.edges(node, **kwds):
+                yield e + (FORWARD,)
+            for e in G.in_edges(node, **kwds):
+                yield e + (REVERSE,)
+
+    else:
+        raise nx.NetworkXError("invalid orientation argument.")
+
+    if directed:
+        neighbors = G.successors
+
+        def edge_id(edge):
+            # remove direction indicator
+            return edge[:-1] if orientation is not None else edge
+
+    else:
+        neighbors = G.neighbors
+
+        def edge_id(edge):
+            return (frozenset(edge[:2]),) + edge[2:]
+
+    check_reverse = directed and orientation in ("reverse", "ignore")
+
+    # start BFS
+    visited_nodes = {n for n in nodes}
+    visited_edges = set()
+    queue = deque([(n, edges_from(n)) for n in nodes])
+    while queue:
+        parent, children_edges = queue.popleft()
+        for edge in children_edges:
+            if check_reverse and edge[-1] == REVERSE:
+                child = edge[0]
+            else:
+                child = edge[1]
+            if child not in visited_nodes:
+                visited_nodes.add(child)
+                queue.append((child, edges_from(child)))
+            edgeid = edge_id(edge)
+            if edgeid not in visited_edges:
+                visited_edges.add(edgeid)
+                yield edge
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/edgedfs.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/edgedfs.py
new file mode 100644
index 0000000..8a4ba83
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/edgedfs.py
@@ -0,0 +1,174 @@
+"""
+===========================
+Depth First Search on Edges
+===========================
+
+Algorithms for a depth-first traversal of edges in a graph.
+
+"""
+import networkx as nx
+
+FORWARD = "forward"
+REVERSE = "reverse"
+
+__all__ = ["edge_dfs"]
+
+
+def edge_dfs(G, source=None, orientation=None):
+    """A directed, depth-first-search of edges in `G`, beginning at `source`.
+
+    Yield the edges of G in a depth-first-search order continuing until
+    all edges are generated.
+
+    Parameters
+    ----------
+    G : graph
+        A directed/undirected graph/multigraph.
+
+    source : node, list of nodes
+        The node from which the traversal begins. If None, then a source
+        is chosen arbitrarily and repeatedly until all edges from each node in
+        the graph are searched.
+
+    orientation : None | 'original' | 'reverse' | 'ignore' (default: None)
+        For directed graphs and directed multigraphs, edge traversals need not
+        respect the original orientation of the edges.
+        When set to 'reverse' every edge is traversed in the reverse direction.
+        When set to 'ignore', every edge is treated as undirected.
+        When set to 'original', every edge is treated as directed.
+        In all three cases, the yielded edge tuples add a last entry to
+        indicate the direction in which that edge was traversed.
+        If orientation is None, the yielded edge has no direction indicated.
+        The direction is respected, but not reported.
+
+    Yields
+    ------
+    edge : directed edge
+        A directed edge indicating the path taken by the depth-first traversal.
+        For graphs, `edge` is of the form `(u, v)` where `u` and `v`
+        are the tail and head of the edge as determined by the traversal.
+        For multigraphs, `edge` is of the form `(u, v, key)`, where `key` is
+        the key of the edge. When the graph is directed, then `u` and `v`
+        are always in the order of the actual directed edge.
+        If orientation is not None then the edge tuple is extended to include
+        the direction of traversal ('forward' or 'reverse') on that edge.
+
+    Examples
+    --------
+    >>> nodes = [0, 1, 2, 3]
+    >>> edges = [(0, 1), (1, 0), (1, 0), (2, 1), (3, 1)]
+
+    >>> list(nx.edge_dfs(nx.Graph(edges), nodes))
+    [(0, 1), (1, 2), (1, 3)]
+
+    >>> list(nx.edge_dfs(nx.DiGraph(edges), nodes))
+    [(0, 1), (1, 0), (2, 1), (3, 1)]
+
+    >>> list(nx.edge_dfs(nx.MultiGraph(edges), nodes))
+    [(0, 1, 0), (1, 0, 1), (0, 1, 2), (1, 2, 0), (1, 3, 0)]
+
+    >>> list(nx.edge_dfs(nx.MultiDiGraph(edges), nodes))
+    [(0, 1, 0), (1, 0, 0), (1, 0, 1), (2, 1, 0), (3, 1, 0)]
+
+    >>> list(nx.edge_dfs(nx.DiGraph(edges), nodes, orientation="ignore"))
+    [(0, 1, 'forward'), (1, 0, 'forward'), (2, 1, 'reverse'), (3, 1, 'reverse')]
+
+    >>> list(nx.edge_dfs(nx.MultiDiGraph(edges), nodes, orientation="ignore"))
+    [(0, 1, 0, 'forward'), (1, 0, 0, 'forward'), (1, 0, 1, 'reverse'), (2, 1, 0, 'reverse'), (3, 1, 0, 'reverse')]
+
+    Notes
+    -----
+    The goal of this function is to visit edges. It differs from the more
+    familiar depth-first traversal of nodes, as provided by
+    :func:`~networkx.algorithms.traversal.depth_first_search.dfs_edges`, in
+    that it does not stop once every node has been visited. In a directed graph
+    with edges [(0, 1), (1, 2), (2, 1)], the edge (2, 1) would not be visited
+    if not for the functionality provided by this function.
+
+    See Also
+    --------
+    :func:`~networkx.algorithms.traversal.depth_first_search.dfs_edges`
+
+    """
+    nodes = list(G.nbunch_iter(source))
+    if not nodes:
+        return
+
+    directed = G.is_directed()
+    kwds = {"data": False}
+    if G.is_multigraph() is True:
+        kwds["keys"] = True
+
+    # set up edge lookup
+    if orientation is None:
+
+        def edges_from(node):
+            return iter(G.edges(node, **kwds))
+
+    elif not directed or orientation == "original":
+
+        def edges_from(node):
+            for e in G.edges(node, **kwds):
+                yield e + (FORWARD,)
+
+    elif orientation == "reverse":
+
+        def edges_from(node):
+            for e in G.in_edges(node, **kwds):
+                yield e + (REVERSE,)
+
+    elif orientation == "ignore":
+
+        def edges_from(node):
+            for e in G.edges(node, **kwds):
+                yield e + (FORWARD,)
+            for e in G.in_edges(node, **kwds):
+                yield e + (REVERSE,)
+
+    else:
+        raise nx.NetworkXError("invalid orientation argument.")
+
+    # set up formation of edge_id to easily look up if edge already returned
+    if directed:
+
+        def edge_id(edge):
+            # remove direction indicator
+            return edge[:-1] if orientation is not None else edge
+
+    else:
+
+        def edge_id(edge):
+            # single id for undirected requires frozenset on nodes
+            return (frozenset(edge[:2]),) + edge[2:]
+
+    # Basic setup
+    check_reverse = directed and orientation in ("reverse", "ignore")
+
+    visited_edges = set()
+    visited_nodes = set()
+    edges = {}
+
+    # start DFS
+    for start_node in nodes:
+        stack = [start_node]
+        while stack:
+            current_node = stack[-1]
+            if current_node not in visited_nodes:
+                edges[current_node] = edges_from(current_node)
+                visited_nodes.add(current_node)
+
+            try:
+                edge = next(edges[current_node])
+            except StopIteration:
+                # No more edges from the current node.
+                stack.pop()
+            else:
+                edgeid = edge_id(edge)
+                if edgeid not in visited_edges:
+                    visited_edges.add(edgeid)
+                    # Mark the traversed "to" node as to-be-explored.
+                    if check_reverse and edge[-1] == REVERSE:
+                        stack.append(edge[0])
+                    else:
+                        stack.append(edge[1])
+                    yield edge
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_beamsearch.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_beamsearch.py
new file mode 100644
index 0000000..249cc2f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_beamsearch.py
@@ -0,0 +1,27 @@
+"""Unit tests for the beam search functions."""
+
+import networkx as nx
+
+
+def identity(x):
+    return x
+
+
+class TestBeamSearch:
+    """Unit tests for the beam search function."""
+
+    def test_narrow(self):
+        """Tests that a narrow beam width may cause an incomplete search."""
+        # In this search, we enqueue only the neighbor 3 at the first
+        # step, then only the neighbor 2 at the second step. Once at
+        # node 2, the search chooses node 3, since it has a higher value
+        # that node 1, but node 3 has already been visited, so the
+        # search terminates.
+        G = nx.cycle_graph(4)
+        edges = nx.bfs_beam_edges(G, 0, identity, width=1)
+        assert list(edges) == [(0, 3), (3, 2)]
+
+    def test_wide(self):
+        G = nx.cycle_graph(4)
+        edges = nx.bfs_beam_edges(G, 0, identity, width=2)
+        assert list(edges) == [(0, 3), (0, 1), (3, 2)]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_bfs.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_bfs.py
new file mode 100644
index 0000000..2ae42b9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_bfs.py
@@ -0,0 +1,119 @@
+from functools import partial
+
+import pytest
+
+import networkx as nx
+
+
+class TestBFS:
+    @classmethod
+    def setup_class(cls):
+        # simple graph
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (1, 2), (1, 3), (2, 4), (3, 4)])
+        cls.G = G
+
+    def test_successor(self):
+        assert dict(nx.bfs_successors(self.G, source=0)) == {0: [1], 1: [2, 3], 2: [4]}
+
+    def test_predecessor(self):
+        assert dict(nx.bfs_predecessors(self.G, source=0)) == {1: 0, 2: 1, 3: 1, 4: 2}
+
+    def test_bfs_tree(self):
+        T = nx.bfs_tree(self.G, source=0)
+        assert sorted(T.nodes()) == sorted(self.G.nodes())
+        assert sorted(T.edges()) == [(0, 1), (1, 2), (1, 3), (2, 4)]
+
+    def test_bfs_edges(self):
+        edges = nx.bfs_edges(self.G, source=0)
+        assert list(edges) == [(0, 1), (1, 2), (1, 3), (2, 4)]
+
+    def test_bfs_edges_reverse(self):
+        D = nx.DiGraph()
+        D.add_edges_from([(0, 1), (1, 2), (1, 3), (2, 4), (3, 4)])
+        edges = nx.bfs_edges(D, source=4, reverse=True)
+        assert list(edges) == [(4, 2), (4, 3), (2, 1), (1, 0)]
+
+    def test_bfs_edges_sorting(self):
+        D = nx.DiGraph()
+        D.add_edges_from([(0, 1), (0, 2), (1, 4), (1, 3), (2, 5)])
+        sort_desc = partial(sorted, reverse=True)
+        edges_asc = nx.bfs_edges(D, source=0, sort_neighbors=sorted)
+        edges_desc = nx.bfs_edges(D, source=0, sort_neighbors=sort_desc)
+        assert list(edges_asc) == [(0, 1), (0, 2), (1, 3), (1, 4), (2, 5)]
+        assert list(edges_desc) == [(0, 2), (0, 1), (2, 5), (1, 4), (1, 3)]
+
+    def test_bfs_tree_isolates(self):
+        G = nx.Graph()
+        G.add_node(1)
+        G.add_node(2)
+        T = nx.bfs_tree(G, source=1)
+        assert sorted(T.nodes()) == [1]
+        assert sorted(T.edges()) == []
+
+    def test_descendants_at_distance(self):
+        for distance, descendants in enumerate([{0}, {1}, {2, 3}, {4}]):
+            assert nx.descendants_at_distance(self.G, 0, distance) == descendants
+
+    def test_descendants_at_distance_missing_source(self):
+        with pytest.raises(nx.NetworkXError):
+            nx.descendants_at_distance(self.G, "abc", 0)
+
+
+class TestBreadthLimitedSearch:
+    @classmethod
+    def setup_class(cls):
+        # a tree
+        G = nx.Graph()
+        nx.add_path(G, [0, 1, 2, 3, 4, 5, 6])
+        nx.add_path(G, [2, 7, 8, 9, 10])
+        cls.G = G
+        # a disconnected graph
+        D = nx.Graph()
+        D.add_edges_from([(0, 1), (2, 3)])
+        nx.add_path(D, [2, 7, 8, 9, 10])
+        cls.D = D
+
+    def test_limited_bfs_successor(self):
+        assert dict(nx.bfs_successors(self.G, source=1, depth_limit=3)) == {
+            1: [0, 2],
+            2: [3, 7],
+            3: [4],
+            7: [8],
+        }
+        result = {
+            n: sorted(s) for n, s in nx.bfs_successors(self.D, source=7, depth_limit=2)
+        }
+        assert result == {8: [9], 2: [3], 7: [2, 8]}
+
+    def test_limited_bfs_predecessor(self):
+        assert dict(nx.bfs_predecessors(self.G, source=1, depth_limit=3)) == {
+            0: 1,
+            2: 1,
+            3: 2,
+            4: 3,
+            7: 2,
+            8: 7,
+        }
+        assert dict(nx.bfs_predecessors(self.D, source=7, depth_limit=2)) == {
+            2: 7,
+            3: 2,
+            8: 7,
+            9: 8,
+        }
+
+    def test_limited_bfs_tree(self):
+        T = nx.bfs_tree(self.G, source=3, depth_limit=1)
+        assert sorted(T.edges()) == [(3, 2), (3, 4)]
+
+    def test_limited_bfs_edges(self):
+        edges = nx.bfs_edges(self.G, source=9, depth_limit=4)
+        assert list(edges) == [(9, 8), (9, 10), (8, 7), (7, 2), (2, 1), (2, 3)]
+
+    def test_limited_descendants_at_distance(self):
+        for distance, descendants in enumerate(
+            [{0}, {1}, {2}, {3, 7}, {4, 8}, {5, 9}, {6, 10}]
+        ):
+            assert nx.descendants_at_distance(self.G, 0, distance) == descendants
+        for distance, descendants in enumerate([{2}, {3, 7}, {8}, {9}, {10}]):
+            assert nx.descendants_at_distance(self.D, 2, distance) == descendants
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_dfs.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_dfs.py
new file mode 100644
index 0000000..7652809
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_dfs.py
@@ -0,0 +1,152 @@
+import networkx as nx
+
+
+class TestDFS:
+    @classmethod
+    def setup_class(cls):
+        # simple graph
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (1, 2), (1, 3), (2, 4), (3, 0), (0, 4)])
+        cls.G = G
+        # simple graph, disconnected
+        D = nx.Graph()
+        D.add_edges_from([(0, 1), (2, 3)])
+        cls.D = D
+
+    def test_preorder_nodes(self):
+        assert list(nx.dfs_preorder_nodes(self.G, source=0)) == [0, 1, 2, 4, 3]
+        assert list(nx.dfs_preorder_nodes(self.D)) == [0, 1, 2, 3]
+        assert list(nx.dfs_preorder_nodes(self.D, source=2)) == [2, 3]
+
+    def test_postorder_nodes(self):
+        assert list(nx.dfs_postorder_nodes(self.G, source=0)) == [4, 2, 3, 1, 0]
+        assert list(nx.dfs_postorder_nodes(self.D)) == [1, 0, 3, 2]
+        assert list(nx.dfs_postorder_nodes(self.D, source=0)) == [1, 0]
+
+    def test_successor(self):
+        assert nx.dfs_successors(self.G, source=0) == {0: [1], 1: [2, 3], 2: [4]}
+        assert nx.dfs_successors(self.G, source=1) == {0: [3, 4], 1: [0], 4: [2]}
+        assert nx.dfs_successors(self.D) == {0: [1], 2: [3]}
+        assert nx.dfs_successors(self.D, source=1) == {1: [0]}
+
+    def test_predecessor(self):
+        assert nx.dfs_predecessors(self.G, source=0) == {1: 0, 2: 1, 3: 1, 4: 2}
+        assert nx.dfs_predecessors(self.D) == {1: 0, 3: 2}
+
+    def test_dfs_tree(self):
+        exp_nodes = sorted(self.G.nodes())
+        exp_edges = [(0, 1), (1, 2), (1, 3), (2, 4)]
+        # Search from first node
+        T = nx.dfs_tree(self.G, source=0)
+        assert sorted(T.nodes()) == exp_nodes
+        assert sorted(T.edges()) == exp_edges
+        # Check source=None
+        T = nx.dfs_tree(self.G, source=None)
+        assert sorted(T.nodes()) == exp_nodes
+        assert sorted(T.edges()) == exp_edges
+        # Check source=None is the default
+        T = nx.dfs_tree(self.G)
+        assert sorted(T.nodes()) == exp_nodes
+        assert sorted(T.edges()) == exp_edges
+
+    def test_dfs_edges(self):
+        edges = nx.dfs_edges(self.G, source=0)
+        assert list(edges) == [(0, 1), (1, 2), (2, 4), (1, 3)]
+        edges = nx.dfs_edges(self.D)
+        assert list(edges) == [(0, 1), (2, 3)]
+
+    def test_dfs_labeled_edges(self):
+        edges = list(nx.dfs_labeled_edges(self.G, source=0))
+        forward = [(u, v) for (u, v, d) in edges if d == "forward"]
+        assert forward == [(0, 0), (0, 1), (1, 2), (2, 4), (1, 3)]
+
+    def test_dfs_labeled_disconnected_edges(self):
+        edges = list(nx.dfs_labeled_edges(self.D))
+        forward = [(u, v) for (u, v, d) in edges if d == "forward"]
+        assert forward == [(0, 0), (0, 1), (2, 2), (2, 3)]
+
+    def test_dfs_tree_isolates(self):
+        G = nx.Graph()
+        G.add_node(1)
+        G.add_node(2)
+        T = nx.dfs_tree(G, source=1)
+        assert sorted(T.nodes()) == [1]
+        assert sorted(T.edges()) == []
+        T = nx.dfs_tree(G, source=None)
+        assert sorted(T.nodes()) == [1, 2]
+        assert sorted(T.edges()) == []
+
+
+class TestDepthLimitedSearch:
+    @classmethod
+    def setup_class(cls):
+        # a tree
+        G = nx.Graph()
+        nx.add_path(G, [0, 1, 2, 3, 4, 5, 6])
+        nx.add_path(G, [2, 7, 8, 9, 10])
+        cls.G = G
+        # a disconnected graph
+        D = nx.Graph()
+        D.add_edges_from([(0, 1), (2, 3)])
+        nx.add_path(D, [2, 7, 8, 9, 10])
+        cls.D = D
+
+    def test_dls_preorder_nodes(self):
+        assert list(nx.dfs_preorder_nodes(self.G, source=0, depth_limit=2)) == [0, 1, 2]
+        assert list(nx.dfs_preorder_nodes(self.D, source=1, depth_limit=2)) == ([1, 0])
+
+    def test_dls_postorder_nodes(self):
+        assert list(nx.dfs_postorder_nodes(self.G, source=3, depth_limit=3)) == [
+            1,
+            7,
+            2,
+            5,
+            4,
+            3,
+        ]
+        assert list(nx.dfs_postorder_nodes(self.D, source=2, depth_limit=2)) == (
+            [3, 7, 2]
+        )
+
+    def test_dls_successor(self):
+        result = nx.dfs_successors(self.G, source=4, depth_limit=3)
+        assert {n: set(v) for n, v in result.items()} == {
+            2: {1, 7},
+            3: {2},
+            4: {3, 5},
+            5: {6},
+        }
+        result = nx.dfs_successors(self.D, source=7, depth_limit=2)
+        assert {n: set(v) for n, v in result.items()} == {8: {9}, 2: {3}, 7: {8, 2}}
+
+    def test_dls_predecessor(self):
+        assert nx.dfs_predecessors(self.G, source=0, depth_limit=3) == {
+            1: 0,
+            2: 1,
+            3: 2,
+            7: 2,
+        }
+        assert nx.dfs_predecessors(self.D, source=2, depth_limit=3) == {
+            8: 7,
+            9: 8,
+            3: 2,
+            7: 2,
+        }
+
+    def test_dls_tree(self):
+        T = nx.dfs_tree(self.G, source=3, depth_limit=1)
+        assert sorted(T.edges()) == [(3, 2), (3, 4)]
+
+    def test_dls_edges(self):
+        edges = nx.dfs_edges(self.G, source=9, depth_limit=4)
+        assert list(edges) == [(9, 8), (8, 7), (7, 2), (2, 1), (2, 3), (9, 10)]
+
+    def test_dls_labeled_edges(self):
+        edges = list(nx.dfs_labeled_edges(self.G, source=5, depth_limit=1))
+        forward = [(u, v) for (u, v, d) in edges if d == "forward"]
+        assert forward == [(5, 5), (5, 4), (5, 6)]
+
+    def test_dls_labeled_disconnected_edges(self):
+        edges = list(nx.dfs_labeled_edges(self.G, source=6, depth_limit=2))
+        forward = [(u, v) for (u, v, d) in edges if d == "forward"]
+        assert forward == [(6, 6), (6, 5), (5, 4)]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_edgebfs.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_edgebfs.py
new file mode 100644
index 0000000..1bf3fae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_edgebfs.py
@@ -0,0 +1,147 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms.traversal.edgedfs import FORWARD, REVERSE
+
+
+class TestEdgeBFS:
+    @classmethod
+    def setup_class(cls):
+        cls.nodes = [0, 1, 2, 3]
+        cls.edges = [(0, 1), (1, 0), (1, 0), (2, 0), (2, 1), (3, 1)]
+
+    def test_empty(self):
+        G = nx.Graph()
+        edges = list(nx.edge_bfs(G))
+        assert edges == []
+
+    def test_graph_single_source(self):
+        G = nx.Graph(self.edges)
+        G.add_edge(4, 5)
+        x = list(nx.edge_bfs(G, [0]))
+        x_ = [(0, 1), (0, 2), (1, 2), (1, 3)]
+        assert x == x_
+
+    def test_graph(self):
+        G = nx.Graph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes))
+        x_ = [(0, 1), (0, 2), (1, 2), (1, 3)]
+        assert x == x_
+
+    def test_digraph(self):
+        G = nx.DiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes))
+        x_ = [(0, 1), (1, 0), (2, 0), (2, 1), (3, 1)]
+        assert x == x_
+
+    def test_digraph_orientation_invalid(self):
+        G = nx.DiGraph(self.edges)
+        edge_iterator = nx.edge_bfs(G, self.nodes, orientation="hello")
+        pytest.raises(nx.NetworkXError, list, edge_iterator)
+
+    def test_digraph_orientation_none(self):
+        G = nx.DiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation=None))
+        x_ = [(0, 1), (1, 0), (2, 0), (2, 1), (3, 1)]
+        assert x == x_
+
+    def test_digraph_orientation_original(self):
+        G = nx.DiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation="original"))
+        x_ = [
+            (0, 1, FORWARD),
+            (1, 0, FORWARD),
+            (2, 0, FORWARD),
+            (2, 1, FORWARD),
+            (3, 1, FORWARD),
+        ]
+        assert x == x_
+
+    def test_digraph2(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(4))
+        x = list(nx.edge_bfs(G, [0]))
+        x_ = [(0, 1), (1, 2), (2, 3)]
+        assert x == x_
+
+    def test_digraph_rev(self):
+        G = nx.DiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation="reverse"))
+        x_ = [
+            (1, 0, REVERSE),
+            (2, 0, REVERSE),
+            (0, 1, REVERSE),
+            (2, 1, REVERSE),
+            (3, 1, REVERSE),
+        ]
+        assert x == x_
+
+    def test_digraph_rev2(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(4))
+        x = list(nx.edge_bfs(G, [3], orientation="reverse"))
+        x_ = [(2, 3, REVERSE), (1, 2, REVERSE), (0, 1, REVERSE)]
+        assert x == x_
+
+    def test_multigraph(self):
+        G = nx.MultiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes))
+        x_ = [(0, 1, 0), (0, 1, 1), (0, 1, 2), (0, 2, 0), (1, 2, 0), (1, 3, 0)]
+        # This is an example of where hash randomization can break.
+        # There are 3! * 2 alternative outputs, such as:
+        #    [(0, 1, 1), (1, 0, 0), (0, 1, 2), (1, 3, 0), (1, 2, 0)]
+        # But note, the edges (1,2,0) and (1,3,0) always follow the (0,1,k)
+        # edges. So the algorithm only guarantees a partial order. A total
+        # order is guaranteed only if the graph data structures are ordered.
+        assert x == x_
+
+    def test_multidigraph(self):
+        G = nx.MultiDiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes))
+        x_ = [(0, 1, 0), (1, 0, 0), (1, 0, 1), (2, 0, 0), (2, 1, 0), (3, 1, 0)]
+        assert x == x_
+
+    def test_multidigraph_rev(self):
+        G = nx.MultiDiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation="reverse"))
+        x_ = [
+            (1, 0, 0, REVERSE),
+            (1, 0, 1, REVERSE),
+            (2, 0, 0, REVERSE),
+            (0, 1, 0, REVERSE),
+            (2, 1, 0, REVERSE),
+            (3, 1, 0, REVERSE),
+        ]
+        assert x == x_
+
+    def test_digraph_ignore(self):
+        G = nx.DiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation="ignore"))
+        x_ = [
+            (0, 1, FORWARD),
+            (1, 0, REVERSE),
+            (2, 0, REVERSE),
+            (2, 1, REVERSE),
+            (3, 1, REVERSE),
+        ]
+        assert x == x_
+
+    def test_digraph_ignore2(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(4))
+        x = list(nx.edge_bfs(G, [0], orientation="ignore"))
+        x_ = [(0, 1, FORWARD), (1, 2, FORWARD), (2, 3, FORWARD)]
+        assert x == x_
+
+    def test_multidigraph_ignore(self):
+        G = nx.MultiDiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation="ignore"))
+        x_ = [
+            (0, 1, 0, FORWARD),
+            (1, 0, 0, REVERSE),
+            (1, 0, 1, REVERSE),
+            (2, 0, 0, REVERSE),
+            (2, 1, 0, REVERSE),
+            (3, 1, 0, REVERSE),
+        ]
+        assert x == x_
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_edgedfs.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_edgedfs.py
new file mode 100644
index 0000000..7c1967c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/traversal/tests/test_edgedfs.py
@@ -0,0 +1,131 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms import edge_dfs
+from networkx.algorithms.traversal.edgedfs import FORWARD, REVERSE
+
+# These tests can fail with hash randomization. The easiest and clearest way
+# to write these unit tests is for the edges to be output in an expected total
+# order, but we cannot guarantee the order amongst outgoing edges from a node,
+# unless each class uses an ordered data structure for neighbors. This is
+# painful to do with the current API. The alternative is that the tests are
+# written (IMO confusingly) so that there is not a total order over the edges,
+# but only a partial order. Due to the small size of the graphs, hopefully
+# failures due to hash randomization will not occur. For an example of how
+# this can fail, see TestEdgeDFS.test_multigraph.
+
+
+class TestEdgeDFS:
+    @classmethod
+    def setup_class(cls):
+        cls.nodes = [0, 1, 2, 3]
+        cls.edges = [(0, 1), (1, 0), (1, 0), (2, 1), (3, 1)]
+
+    def test_empty(self):
+        G = nx.Graph()
+        edges = list(edge_dfs(G))
+        assert edges == []
+
+    def test_graph(self):
+        G = nx.Graph(self.edges)
+        x = list(edge_dfs(G, self.nodes))
+        x_ = [(0, 1), (1, 2), (1, 3)]
+        assert x == x_
+
+    def test_digraph(self):
+        G = nx.DiGraph(self.edges)
+        x = list(edge_dfs(G, self.nodes))
+        x_ = [(0, 1), (1, 0), (2, 1), (3, 1)]
+        assert x == x_
+
+    def test_digraph_orientation_invalid(self):
+        G = nx.DiGraph(self.edges)
+        edge_iterator = edge_dfs(G, self.nodes, orientation="hello")
+        pytest.raises(nx.NetworkXError, list, edge_iterator)
+
+    def test_digraph_orientation_none(self):
+        G = nx.DiGraph(self.edges)
+        x = list(edge_dfs(G, self.nodes, orientation=None))
+        x_ = [(0, 1), (1, 0), (2, 1), (3, 1)]
+        assert x == x_
+
+    def test_digraph_orientation_original(self):
+        G = nx.DiGraph(self.edges)
+        x = list(edge_dfs(G, self.nodes, orientation="original"))
+        x_ = [(0, 1, FORWARD), (1, 0, FORWARD), (2, 1, FORWARD), (3, 1, FORWARD)]
+        assert x == x_
+
+    def test_digraph2(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(4))
+        x = list(edge_dfs(G, [0]))
+        x_ = [(0, 1), (1, 2), (2, 3)]
+        assert x == x_
+
+    def test_digraph_rev(self):
+        G = nx.DiGraph(self.edges)
+        x = list(edge_dfs(G, self.nodes, orientation="reverse"))
+        x_ = [(1, 0, REVERSE), (0, 1, REVERSE), (2, 1, REVERSE), (3, 1, REVERSE)]
+        assert x == x_
+
+    def test_digraph_rev2(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(4))
+        x = list(edge_dfs(G, [3], orientation="reverse"))
+        x_ = [(2, 3, REVERSE), (1, 2, REVERSE), (0, 1, REVERSE)]
+        assert x == x_
+
+    def test_multigraph(self):
+        G = nx.MultiGraph(self.edges)
+        x = list(edge_dfs(G, self.nodes))
+        x_ = [(0, 1, 0), (1, 0, 1), (0, 1, 2), (1, 2, 0), (1, 3, 0)]
+        # This is an example of where hash randomization can break.
+        # There are 3! * 2 alternative outputs, such as:
+        #    [(0, 1, 1), (1, 0, 0), (0, 1, 2), (1, 3, 0), (1, 2, 0)]
+        # But note, the edges (1,2,0) and (1,3,0) always follow the (0,1,k)
+        # edges. So the algorithm only guarantees a partial order. A total
+        # order is guaranteed only if the graph data structures are ordered.
+        assert x == x_
+
+    def test_multidigraph(self):
+        G = nx.MultiDiGraph(self.edges)
+        x = list(edge_dfs(G, self.nodes))
+        x_ = [(0, 1, 0), (1, 0, 0), (1, 0, 1), (2, 1, 0), (3, 1, 0)]
+        assert x == x_
+
+    def test_multidigraph_rev(self):
+        G = nx.MultiDiGraph(self.edges)
+        x = list(edge_dfs(G, self.nodes, orientation="reverse"))
+        x_ = [
+            (1, 0, 0, REVERSE),
+            (0, 1, 0, REVERSE),
+            (1, 0, 1, REVERSE),
+            (2, 1, 0, REVERSE),
+            (3, 1, 0, REVERSE),
+        ]
+        assert x == x_
+
+    def test_digraph_ignore(self):
+        G = nx.DiGraph(self.edges)
+        x = list(edge_dfs(G, self.nodes, orientation="ignore"))
+        x_ = [(0, 1, FORWARD), (1, 0, FORWARD), (2, 1, REVERSE), (3, 1, REVERSE)]
+        assert x == x_
+
+    def test_digraph_ignore2(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(4))
+        x = list(edge_dfs(G, [0], orientation="ignore"))
+        x_ = [(0, 1, FORWARD), (1, 2, FORWARD), (2, 3, FORWARD)]
+        assert x == x_
+
+    def test_multidigraph_ignore(self):
+        G = nx.MultiDiGraph(self.edges)
+        x = list(edge_dfs(G, self.nodes, orientation="ignore"))
+        x_ = [
+            (0, 1, 0, FORWARD),
+            (1, 0, 0, FORWARD),
+            (1, 0, 1, REVERSE),
+            (2, 1, 0, REVERSE),
+            (3, 1, 0, REVERSE),
+        ]
+        assert x == x_
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/__init__.py
new file mode 100644
index 0000000..7120d4b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/__init__.py
@@ -0,0 +1,6 @@
+from .branchings import *
+from .coding import *
+from .mst import *
+from .recognition import *
+from .operations import *
+from .decomposition import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/branchings.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/branchings.py
new file mode 100644
index 0000000..8f8602b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/branchings.py
@@ -0,0 +1,1048 @@
+"""
+Algorithms for finding optimum branchings and spanning arborescences.
+
+This implementation is based on:
+
+    J. Edmonds, Optimum branchings, J. Res. Natl. Bur. Standards 71B (1967),
+    233–240. URL: http://archive.org/details/jresv71Bn4p233
+
+"""
+# TODO: Implement method from Gabow, Galil, Spence and Tarjan:
+#
+# @article{
+#    year={1986},
+#    issn={0209-9683},
+#    journal={Combinatorica},
+#    volume={6},
+#    number={2},
+#    doi={10.1007/BF02579168},
+#    title={Efficient algorithms for finding minimum spanning trees in
+#        undirected and directed graphs},
+#    url={https://doi.org/10.1007/BF02579168},
+#    publisher={Springer-Verlag},
+#    keywords={68 B 15; 68 C 05},
+#    author={Gabow, Harold N. and Galil, Zvi and Spencer, Thomas and Tarjan,
+#        Robert E.},
+#    pages={109-122},
+#    language={English}
+# }
+import string
+from dataclasses import dataclass, field
+from enum import Enum
+from operator import itemgetter
+from queue import PriorityQueue
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+from .recognition import is_arborescence, is_branching
+
+__all__ = [
+    "branching_weight",
+    "greedy_branching",
+    "maximum_branching",
+    "minimum_branching",
+    "maximum_spanning_arborescence",
+    "minimum_spanning_arborescence",
+    "ArborescenceIterator",
+    "Edmonds",
+]
+
+KINDS = {"max", "min"}
+
+STYLES = {
+    "branching": "branching",
+    "arborescence": "arborescence",
+    "spanning arborescence": "arborescence",
+}
+
+INF = float("inf")
+
+
+@py_random_state(1)
+def random_string(L=15, seed=None):
+    return "".join([seed.choice(string.ascii_letters) for n in range(L)])
+
+
+def _min_weight(weight):
+    return -weight
+
+
+def _max_weight(weight):
+    return weight
+
+
+def branching_weight(G, attr="weight", default=1):
+    """
+    Returns the total weight of a branching.
+
+    You must access this function through the networkx.algorithms.tree module.
+
+    Parameters
+    ----------
+    G : DiGraph
+        The directed graph.
+    attr : str
+        The attribute to use as weights. If None, then each edge will be
+        treated equally with a weight of 1.
+    default : float
+        When `attr` is not None, then if an edge does not have that attribute,
+        `default` specifies what value it should take.
+
+    Returns
+    -------
+    weight: int or float
+        The total weight of the branching.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_weighted_edges_from([(0, 1, 2), (1, 2, 4), (2, 3, 3), (3, 4, 2)])
+    >>> nx.tree.branching_weight(G)
+    11
+
+    """
+    return sum(edge[2].get(attr, default) for edge in G.edges(data=True))
+
+
+@py_random_state(4)
+def greedy_branching(G, attr="weight", default=1, kind="max", seed=None):
+    """
+    Returns a branching obtained through a greedy algorithm.
+
+    This algorithm is wrong, and cannot give a proper optimal branching.
+    However, we include it for pedagogical reasons, as it can be helpful to
+    see what its outputs are.
+
+    The output is a branching, and possibly, a spanning arborescence. However,
+    it is not guaranteed to be optimal in either case.
+
+    Parameters
+    ----------
+    G : DiGraph
+        The directed graph to scan.
+    attr : str
+        The attribute to use as weights. If None, then each edge will be
+        treated equally with a weight of 1.
+    default : float
+        When `attr` is not None, then if an edge does not have that attribute,
+        `default` specifies what value it should take.
+    kind : str
+        The type of optimum to search for: 'min' or 'max' greedy branching.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    B : directed graph
+        The greedily obtained branching.
+
+    """
+    if kind not in KINDS:
+        raise nx.NetworkXException("Unknown value for `kind`.")
+
+    if kind == "min":
+        reverse = False
+    else:
+        reverse = True
+
+    if attr is None:
+        # Generate a random string the graph probably won't have.
+        attr = random_string(seed=seed)
+
+    edges = [(u, v, data.get(attr, default)) for (u, v, data) in G.edges(data=True)]
+
+    # We sort by weight, but also by nodes to normalize behavior across runs.
+    try:
+        edges.sort(key=itemgetter(2, 0, 1), reverse=reverse)
+    except TypeError:
+        # This will fail in Python 3.x if the nodes are of varying types.
+        # In that case, we use the arbitrary order.
+        edges.sort(key=itemgetter(2), reverse=reverse)
+
+    # The branching begins with a forest of no edges.
+    B = nx.DiGraph()
+    B.add_nodes_from(G)
+
+    # Now we add edges greedily so long we maintain the branching.
+    uf = nx.utils.UnionFind()
+    for i, (u, v, w) in enumerate(edges):
+        if uf[u] == uf[v]:
+            # Adding this edge would form a directed cycle.
+            continue
+        elif B.in_degree(v) == 1:
+            # The edge would increase the degree to be greater than one.
+            continue
+        else:
+            # If attr was None, then don't insert weights...
+            data = {}
+            if attr is not None:
+                data[attr] = w
+            B.add_edge(u, v, **data)
+            uf.union(u, v)
+
+    return B
+
+
+class MultiDiGraph_EdgeKey(nx.MultiDiGraph):
+    """
+    MultiDiGraph which assigns unique keys to every edge.
+
+    Adds a dictionary edge_index which maps edge keys to (u, v, data) tuples.
+
+    This is not a complete implementation. For Edmonds algorithm, we only use
+    add_node and add_edge, so that is all that is implemented here. During
+    additions, any specified keys are ignored---this means that you also
+    cannot update edge attributes through add_node and add_edge.
+
+    Why do we need this? Edmonds algorithm requires that we track edges, even
+    as we change the head and tail of an edge, and even changing the weight
+    of edges. We must reliably track edges across graph mutations.
+
+    """
+
+    def __init__(self, incoming_graph_data=None, **attr):
+        cls = super()
+        cls.__init__(incoming_graph_data=incoming_graph_data, **attr)
+
+        self._cls = cls
+        self.edge_index = {}
+
+    def remove_node(self, n):
+        keys = set()
+        for keydict in self.pred[n].values():
+            keys.update(keydict)
+        for keydict in self.succ[n].values():
+            keys.update(keydict)
+
+        for key in keys:
+            del self.edge_index[key]
+
+        self._cls.remove_node(n)
+
+    def remove_nodes_from(self, nbunch):
+        for n in nbunch:
+            self.remove_node(n)
+
+    def add_edge(self, u_for_edge, v_for_edge, key_for_edge, **attr):
+        """
+        Key is now required.
+
+        """
+        u, v, key = u_for_edge, v_for_edge, key_for_edge
+        if key in self.edge_index:
+            uu, vv, _ = self.edge_index[key]
+            if (u != uu) or (v != vv):
+                raise Exception(f"Key {key!r} is already in use.")
+
+        self._cls.add_edge(u, v, key, **attr)
+        self.edge_index[key] = (u, v, self.succ[u][v][key])
+
+    def add_edges_from(self, ebunch_to_add, **attr):
+        for u, v, k, d in ebunch_to_add:
+            self.add_edge(u, v, k, **d)
+
+    def remove_edge_with_key(self, key):
+        try:
+            u, v, _ = self.edge_index[key]
+        except KeyError as err:
+            raise KeyError(f"Invalid edge key {key!r}") from err
+        else:
+            del self.edge_index[key]
+            self._cls.remove_edge(u, v, key)
+
+    def remove_edges_from(self, ebunch):
+        raise NotImplementedError
+
+
+def get_path(G, u, v):
+    """
+    Returns the edge keys of the unique path between u and v.
+
+    This is not a generic function. G must be a branching and an instance of
+    MultiDiGraph_EdgeKey.
+
+    """
+    nodes = nx.shortest_path(G, u, v)
+
+    # We are guaranteed that there is only one edge connected every node
+    # in the shortest path.
+
+    def first_key(i, vv):
+        # Needed for 2.x/3.x compatibilitity
+        keys = G[nodes[i]][vv].keys()
+        # Normalize behavior
+        keys = list(keys)
+        return keys[0]
+
+    edges = [first_key(i, vv) for i, vv in enumerate(nodes[1:])]
+    return nodes, edges
+
+
+class Edmonds:
+    """
+    Edmonds algorithm [1]_ for finding optimal branchings and spanning
+    arborescences.
+
+    This algorithm can find both minimum and maximum spanning arborescences and
+    branchings.
+
+    Notes
+    -----
+    While this algorithm can find a minimum branching, since it isn't required
+    to be spanning, the minimum branching is always from the set of negative
+    weight edges which is most likely the empty set for most graphs.
+
+    References
+    ----------
+    .. [1] J. Edmonds, Optimum Branchings, Journal of Research of the National
+           Bureau of Standards, 1967, Vol. 71B, p.233-240,
+           https://archive.org/details/jresv71Bn4p233
+
+    """
+
+    def __init__(self, G, seed=None):
+        self.G_original = G
+
+        # Need to fix this. We need the whole tree.
+        self.store = True
+
+        # The final answer.
+        self.edges = []
+
+        # Since we will be creating graphs with new nodes, we need to make
+        # sure that our node names do not conflict with the real node names.
+        self.template = random_string(seed=seed) + "_{0}"
+
+    def _init(self, attr, default, kind, style, preserve_attrs, seed, partition):
+        if kind not in KINDS:
+            raise nx.NetworkXException("Unknown value for `kind`.")
+
+        # Store inputs.
+        self.attr = attr
+        self.default = default
+        self.kind = kind
+        self.style = style
+
+        # Determine how we are going to transform the weights.
+        if kind == "min":
+            self.trans = trans = _min_weight
+        else:
+            self.trans = trans = _max_weight
+
+        if attr is None:
+            # Generate a random attr the graph probably won't have.
+            attr = random_string(seed=seed)
+
+        # This is the actual attribute used by the algorithm.
+        self._attr = attr
+
+        # This attribute is used to store whether a particular edge is still
+        # a candidate. We generate a random attr to remove clashes with
+        # preserved edges
+        self.candidate_attr = "candidate_" + random_string(seed=seed)
+
+        # The object we manipulate at each step is a multidigraph.
+        self.G = G = MultiDiGraph_EdgeKey()
+        for key, (u, v, data) in enumerate(self.G_original.edges(data=True)):
+            d = {attr: trans(data.get(attr, default))}
+
+            if data.get(partition) is not None:
+                d[partition] = data.get(partition)
+
+            if preserve_attrs:
+                for (d_k, d_v) in data.items():
+                    if d_k != attr:
+                        d[d_k] = d_v
+
+            G.add_edge(u, v, key, **d)
+
+        self.level = 0
+
+        # These are the "buckets" from the paper.
+        #
+        # As in the paper, G^i are modified versions of the original graph.
+        # D^i and E^i are nodes and edges of the maximal edges that are
+        # consistent with G^i. These are dashed edges in figures A-F of the
+        # paper. In this implementation, we store D^i and E^i together as a
+        # graph B^i. So we will have strictly more B^i than the paper does.
+        self.B = MultiDiGraph_EdgeKey()
+        self.B.edge_index = {}
+        self.graphs = []  # G^i
+        self.branchings = []  # B^i
+        self.uf = nx.utils.UnionFind()
+
+        # A list of lists of edge indexes. Each list is a circuit for graph G^i.
+        # Note the edge list will not, in general, be a circuit in graph G^0.
+        self.circuits = []
+        # Stores the index of the minimum edge in the circuit found in G^i
+        # and B^i. The ordering of the edges seems to preserve the weight
+        # ordering from G^0. So even if the circuit does not form a circuit
+        # in G^0, it is still true that the minimum edge of the circuit in
+        # G^i is still the minimum edge in circuit G^0 (despite their weights
+        # being different).
+        self.minedge_circuit = []
+
+    def find_optimum(
+        self,
+        attr="weight",
+        default=1,
+        kind="max",
+        style="branching",
+        preserve_attrs=False,
+        partition=None,
+        seed=None,
+    ):
+        """
+        Returns a branching from G.
+
+        Parameters
+        ----------
+        attr : str
+            The edge attribute used to in determining optimality.
+        default : float
+            The value of the edge attribute used if an edge does not have
+            the attribute `attr`.
+        kind : {'min', 'max'}
+            The type of optimum to search for, either 'min' or 'max'.
+        style : {'branching', 'arborescence'}
+            If 'branching', then an optimal branching is found. If `style` is
+            'arborescence', then a branching is found, such that if the
+            branching is also an arborescence, then the branching is an
+            optimal spanning arborescences. A given graph G need not have
+            an optimal spanning arborescence.
+        preserve_attrs : bool
+            If True, preserve the other edge attributes of the original
+            graph (that are not the one passed to `attr`)
+        partition : str
+            The edge attribute holding edge partition data. Used in the
+            spanning arborescence iterator.
+        seed : integer, random_state, or None (default)
+            Indicator of random number generation state.
+            See :ref:`Randomness<randomness>`.
+
+        Returns
+        -------
+        H : (multi)digraph
+            The branching.
+
+        """
+        self._init(attr, default, kind, style, preserve_attrs, seed, partition)
+        uf = self.uf
+
+        # This enormous while loop could use some refactoring...
+
+        G, B = self.G, self.B
+        D = set()
+        nodes = iter(list(G.nodes()))
+        attr = self._attr
+        G_pred = G.pred
+
+        def desired_edge(v):
+            """
+            Find the edge directed toward v with maximal weight.
+
+            If an edge partition exists in this graph, return the included edge
+            if it exists and no not return any excluded edges. There can only
+            be one included edge for each vertex otherwise the edge partition is
+            empty.
+            """
+            edge = None
+            weight = -INF
+            for u, _, key, data in G.in_edges(v, data=True, keys=True):
+                # Skip excluded edges
+                if data.get(partition) == nx.EdgePartition.EXCLUDED:
+                    continue
+                new_weight = data[attr]
+                # Return the included edge
+                if data.get(partition) == nx.EdgePartition.INCLUDED:
+                    weight = new_weight
+                    edge = (u, v, key, new_weight, data)
+                    return edge, weight
+                # Find the best open edge
+                if new_weight > weight:
+                    weight = new_weight
+                    edge = (u, v, key, new_weight, data)
+
+            return edge, weight
+
+        while True:
+            # (I1): Choose a node v in G^i not in D^i.
+            try:
+                v = next(nodes)
+            except StopIteration:
+                # If there are no more new nodes to consider, then we *should*
+                # meet the break condition (b) from the paper:
+                #   (b) every node of G^i is in D^i and E^i is a branching
+                # Construction guarantees that it's a branching.
+                assert len(G) == len(B)
+                if len(B):
+                    assert is_branching(B)
+
+                if self.store:
+                    self.graphs.append(G.copy())
+                    self.branchings.append(B.copy())
+
+                    # Add these to keep the lengths equal. Element i is the
+                    # circuit at level i that was merged to form branching i+1.
+                    # There is no circuit for the last level.
+                    self.circuits.append([])
+                    self.minedge_circuit.append(None)
+                break
+            else:
+                if v in D:
+                    # print("v in D", v)
+                    continue
+
+            # Put v into bucket D^i.
+            # print(f"Adding node {v}")
+            D.add(v)
+            B.add_node(v)
+
+            edge, weight = desired_edge(v)
+            # print(f"Max edge is {edge!r}")
+            if edge is None:
+                # If there is no edge, continue with a new node at (I1).
+                continue
+            else:
+                # Determine if adding the edge to E^i would mean its no longer
+                # a branching. Presently, v has indegree 0 in B---it is a root.
+                u = edge[0]
+
+                if uf[u] == uf[v]:
+                    # Then adding the edge will create a circuit. Then B
+                    # contains a unique path P from v to u. So condition (a)
+                    # from the paper does hold. We need to store the circuit
+                    # for future reference.
+                    Q_nodes, Q_edges = get_path(B, v, u)
+                    Q_edges.append(edge[2])  # Edge key
+                else:
+                    # Then B with the edge is still a branching and condition
+                    # (a) from the paper does not hold.
+                    Q_nodes, Q_edges = None, None
+
+                # Conditions for adding the edge.
+                # If weight < 0, then it cannot help in finding a maximum branching.
+                if self.style == "branching" and weight <= 0:
+                    acceptable = False
+                else:
+                    acceptable = True
+
+                # print(f"Edge is acceptable: {acceptable}")
+                if acceptable:
+                    dd = {attr: weight}
+                    if edge[4].get(partition) is not None:
+                        dd[partition] = edge[4].get(partition)
+                    B.add_edge(u, v, edge[2], **dd)
+                    G[u][v][edge[2]][self.candidate_attr] = True
+                    uf.union(u, v)
+                    if Q_edges is not None:
+                        # print("Edge introduced a simple cycle:")
+                        # print(Q_nodes, Q_edges)
+
+                        # Move to method
+                        # Previous meaning of u and v is no longer important.
+
+                        # Apply (I2).
+                        # Get the edge in the cycle with the minimum weight.
+                        # Also, save the incoming weights for each node.
+                        minweight = INF
+                        minedge = None
+                        Q_incoming_weight = {}
+                        for edge_key in Q_edges:
+                            u, v, data = B.edge_index[edge_key]
+                            # We cannot remove an included edges, even if it is
+                            # the minimum edge in the circuit
+                            w = data[attr]
+                            Q_incoming_weight[v] = w
+                            if data.get(partition) == nx.EdgePartition.INCLUDED:
+                                continue
+                            if w < minweight:
+                                minweight = w
+                                minedge = edge_key
+
+                        self.circuits.append(Q_edges)
+                        self.minedge_circuit.append(minedge)
+
+                        if self.store:
+                            self.graphs.append(G.copy())
+                        # Always need the branching with circuits.
+                        self.branchings.append(B.copy())
+
+                        # Now we mutate it.
+                        new_node = self.template.format(self.level)
+
+                        # print(minweight, minedge, Q_incoming_weight)
+
+                        G.add_node(new_node)
+                        new_edges = []
+                        for u, v, key, data in G.edges(data=True, keys=True):
+                            if u in Q_incoming_weight:
+                                if v in Q_incoming_weight:
+                                    # Circuit edge, do nothing for now.
+                                    # Eventually delete it.
+                                    continue
+                                else:
+                                    # Outgoing edge. Make it from new node
+                                    dd = data.copy()
+                                    new_edges.append((new_node, v, key, dd))
+                            else:
+                                if v in Q_incoming_weight:
+                                    # Incoming edge. Change its weight
+                                    w = data[attr]
+                                    w += minweight - Q_incoming_weight[v]
+                                    dd = data.copy()
+                                    dd[attr] = w
+                                    new_edges.append((u, new_node, key, dd))
+                                else:
+                                    # Outside edge. No modification necessary.
+                                    continue
+
+                        G.remove_nodes_from(Q_nodes)
+                        B.remove_nodes_from(Q_nodes)
+                        D.difference_update(set(Q_nodes))
+
+                        for u, v, key, data in new_edges:
+                            G.add_edge(u, v, key, **data)
+                            if self.candidate_attr in data:
+                                del data[self.candidate_attr]
+                                B.add_edge(u, v, key, **data)
+                                uf.union(u, v)
+
+                        nodes = iter(list(G.nodes()))
+                        self.level += 1
+
+        # (I3) Branch construction.
+        # print(self.level)
+        H = self.G_original.__class__()
+
+        def is_root(G, u, edgekeys):
+            """
+            Returns True if `u` is a root node in G.
+
+            Node `u` will be a root node if its in-degree, restricted to the
+            specified edges, is equal to 0.
+
+            """
+            if u not in G:
+                # print(G.nodes(), u)
+                raise Exception(f"{u!r} not in G")
+            for v in G.pred[u]:
+                for edgekey in G.pred[u][v]:
+                    if edgekey in edgekeys:
+                        return False, edgekey
+            else:
+                return True, None
+
+        # Start with the branching edges in the last level.
+        edges = set(self.branchings[self.level].edge_index)
+        while self.level > 0:
+            self.level -= 1
+
+            # The current level is i, and we start counting from 0.
+
+            # We need the node at level i+1 that results from merging a circuit
+            # at level i. randomname_0 is the first merged node and this
+            # happens at level 1. That is, randomname_0 is a node at level 1
+            # that results from merging a circuit at level 0.
+            merged_node = self.template.format(self.level)
+
+            # The circuit at level i that was merged as a node the graph
+            # at level i+1.
+            circuit = self.circuits[self.level]
+            # print
+            # print(merged_node, self.level, circuit)
+            # print("before", edges)
+            # Note, we ask if it is a root in the full graph, not the branching.
+            # The branching alone doesn't have all the edges.
+
+            isroot, edgekey = is_root(self.graphs[self.level + 1], merged_node, edges)
+            edges.update(circuit)
+            if isroot:
+                minedge = self.minedge_circuit[self.level]
+                if minedge is None:
+                    raise Exception
+
+                # Remove the edge in the cycle with minimum weight.
+                edges.remove(minedge)
+            else:
+                # We have identified an edge at next higher level that
+                # transitions into the merged node at the level. That edge
+                # transitions to some corresponding node at the current level.
+                # We want to remove an edge from the cycle that transitions
+                # into the corresponding node.
+                # print("edgekey is: ", edgekey)
+                # print("circuit is: ", circuit)
+                # The branching at level i
+                G = self.graphs[self.level]
+                # print(G.edge_index)
+                target = G.edge_index[edgekey][1]
+                for edgekey in circuit:
+                    u, v, data = G.edge_index[edgekey]
+                    if v == target:
+                        break
+                else:
+                    raise Exception("Couldn't find edge incoming to merged node.")
+                # print(f"not a root. removing {edgekey}")
+
+                edges.remove(edgekey)
+
+        self.edges = edges
+
+        H.add_nodes_from(self.G_original)
+        for edgekey in edges:
+            u, v, d = self.graphs[0].edge_index[edgekey]
+            dd = {self.attr: self.trans(d[self.attr])}
+
+            # Optionally, preserve the other edge attributes of the original
+            # graph
+            if preserve_attrs:
+                for (key, value) in d.items():
+                    if key not in [self.attr, self.candidate_attr]:
+                        dd[key] = value
+
+            # TODO: make this preserve the key.
+            H.add_edge(u, v, **dd)
+
+        return H
+
+
+def maximum_branching(
+    G, attr="weight", default=1, preserve_attrs=False, partition=None
+):
+    ed = Edmonds(G)
+    B = ed.find_optimum(
+        attr,
+        default,
+        kind="max",
+        style="branching",
+        preserve_attrs=preserve_attrs,
+        partition=partition,
+    )
+    return B
+
+
+def minimum_branching(
+    G, attr="weight", default=1, preserve_attrs=False, partition=None
+):
+    ed = Edmonds(G)
+    B = ed.find_optimum(
+        attr,
+        default,
+        kind="min",
+        style="branching",
+        preserve_attrs=preserve_attrs,
+        partition=partition,
+    )
+    return B
+
+
+def maximum_spanning_arborescence(
+    G, attr="weight", default=1, preserve_attrs=False, partition=None
+):
+    ed = Edmonds(G)
+    B = ed.find_optimum(
+        attr,
+        default,
+        kind="max",
+        style="arborescence",
+        preserve_attrs=preserve_attrs,
+        partition=partition,
+    )
+    if not is_arborescence(B):
+        msg = "No maximum spanning arborescence in G."
+        raise nx.exception.NetworkXException(msg)
+    return B
+
+
+def minimum_spanning_arborescence(
+    G, attr="weight", default=1, preserve_attrs=False, partition=None
+):
+    ed = Edmonds(G)
+    B = ed.find_optimum(
+        attr,
+        default,
+        kind="min",
+        style="arborescence",
+        preserve_attrs=preserve_attrs,
+        partition=partition,
+    )
+    if not is_arborescence(B):
+        msg = "No minimum spanning arborescence in G."
+        raise nx.exception.NetworkXException(msg)
+    return B
+
+
+docstring_branching = """
+Returns a {kind} {style} from G.
+
+Parameters
+----------
+G : (multi)digraph-like
+    The graph to be searched.
+attr : str
+    The edge attribute used to in determining optimality.
+default : float
+    The value of the edge attribute used if an edge does not have
+    the attribute `attr`.
+preserve_attrs : bool
+    If True, preserve the other attributes of the original graph (that are not
+    passed to `attr`)
+partition : str
+    The key for the edge attribute containing the partition
+    data on the graph. Edges can be included, excluded or open using the
+    `EdgePartition` enum.
+
+Returns
+-------
+B : (multi)digraph-like
+    A {kind} {style}.
+"""
+
+docstring_arborescence = (
+    docstring_branching
+    + """
+Raises
+------
+NetworkXException
+    If the graph does not contain a {kind} {style}.
+
+"""
+)
+
+maximum_branching.__doc__ = docstring_branching.format(
+    kind="maximum", style="branching"
+)
+
+minimum_branching.__doc__ = docstring_branching.format(
+    kind="minimum", style="branching"
+)
+
+maximum_spanning_arborescence.__doc__ = docstring_arborescence.format(
+    kind="maximum", style="spanning arborescence"
+)
+
+minimum_spanning_arborescence.__doc__ = docstring_arborescence.format(
+    kind="minimum", style="spanning arborescence"
+)
+
+
+class ArborescenceIterator:
+    """
+    Iterate over all spanning arborescences of a graph in either increasing or
+    decreasing cost.
+
+    Notes
+    -----
+    This iterator uses the partition scheme from [1]_ (included edges,
+    excluded edges and open edges). It generates minimum spanning
+    arborescences using a modified Edmonds' Algorithm which respects the
+    partition of edges. For arborescences with the same weight, ties are
+    broken arbitrarily.
+
+    References
+    ----------
+    .. [1] G.K. Janssens, K. Sörensen, An algorithm to generate all spanning
+           trees in order of increasing cost, Pesquisa Operacional, 2005-08,
+           Vol. 25 (2), p. 219-229,
+           https://www.scielo.br/j/pope/a/XHswBwRwJyrfL88dmMwYNWp/?lang=en
+    """
+
+    @dataclass(order=True)
+    class Partition:
+        """
+        This dataclass represents a partition and stores a dict with the edge
+        data and the weight of the minimum spanning arborescence of the
+        partition dict.
+        """
+
+        mst_weight: float
+        partition_dict: dict = field(compare=False)
+
+        def __copy__(self):
+            return ArborescenceIterator.Partition(
+                self.mst_weight, self.partition_dict.copy()
+            )
+
+    def __init__(self, G, weight="weight", minimum=True, init_partition=None):
+        """
+        Initialize the iterator
+
+        Parameters
+        ----------
+        G : nx.DiGraph
+            The directed graph which we need to iterate trees over
+
+        weight : String, default = "weight"
+            The edge attribute used to store the weight of the edge
+
+        minimum : bool, default = True
+            Return the trees in increasing order while true and decreasing order
+            while false.
+
+        init_partition : tuple, default = None
+            In the case that certain edges have to be included or excluded from
+            the arborescences, `init_partition` should be in the form
+            `(included_edges, excluded_edges)` where each edges is a
+            `(u, v)`-tuple inside an iterable such as a list or set.
+
+        """
+        self.G = G.copy()
+        self.weight = weight
+        self.minimum = minimum
+        self.method = (
+            minimum_spanning_arborescence if minimum else maximum_spanning_arborescence
+        )
+        # Randomly create a key for an edge attribute to hold the partition data
+        self.partition_key = (
+            "ArborescenceIterators super secret partition attribute name"
+        )
+        if init_partition is not None:
+            partition_dict = {}
+            for e in init_partition[0]:
+                partition_dict[e] = nx.EdgePartition.INCLUDED
+            for e in init_partition[1]:
+                partition_dict[e] = nx.EdgePartition.EXCLUDED
+            self.init_partition = ArborescenceIterator.Partition(0, partition_dict)
+        else:
+            self.init_partition = None
+
+    def __iter__(self):
+        """
+        Returns
+        -------
+        ArborescenceIterator
+            The iterator object for this graph
+        """
+        self.partition_queue = PriorityQueue()
+        self._clear_partition(self.G)
+
+        # Write the initial partition if it exists.
+        if self.init_partition is not None:
+            self._write_partition(self.init_partition)
+
+        mst_weight = self.method(
+            self.G,
+            self.weight,
+            partition=self.partition_key,
+            preserve_attrs=True,
+        ).size(weight=self.weight)
+
+        self.partition_queue.put(
+            self.Partition(
+                mst_weight if self.minimum else -mst_weight,
+                dict()
+                if self.init_partition is None
+                else self.init_partition.partition_dict,
+            )
+        )
+
+        return self
+
+    def __next__(self):
+        """
+        Returns
+        -------
+        (multi)Graph
+            The spanning tree of next greatest weight, which ties broken
+            arbitrarily.
+        """
+        if self.partition_queue.empty():
+            del self.G, self.partition_queue
+            raise StopIteration
+
+        partition = self.partition_queue.get()
+        self._write_partition(partition)
+        next_arborescence = self.method(
+            self.G,
+            self.weight,
+            partition=self.partition_key,
+            preserve_attrs=True,
+        )
+        self._partition(partition, next_arborescence)
+
+        self._clear_partition(next_arborescence)
+        return next_arborescence
+
+    def _partition(self, partition, partition_arborescence):
+        """
+        Create new partitions based of the minimum spanning tree of the
+        current minimum partition.
+
+        Parameters
+        ----------
+        partition : Partition
+            The Partition instance used to generate the current minimum spanning
+            tree.
+        partition_arborescence : nx.Graph
+            The minimum spanning arborescence of the input partition.
+        """
+        # create two new partitions with the data from the input partition dict
+        p1 = self.Partition(0, partition.partition_dict.copy())
+        p2 = self.Partition(0, partition.partition_dict.copy())
+        for e in partition_arborescence.edges:
+            # determine if the edge was open or included
+            if e not in partition.partition_dict:
+                # This is an open edge
+                p1.partition_dict[e] = nx.EdgePartition.EXCLUDED
+                p2.partition_dict[e] = nx.EdgePartition.INCLUDED
+
+                self._write_partition(p1)
+                try:
+                    p1_mst = self.method(
+                        self.G,
+                        self.weight,
+                        partition=self.partition_key,
+                        preserve_attrs=True,
+                    )
+
+                    p1_mst_weight = p1_mst.size(weight=self.weight)
+                    p1.mst_weight = p1_mst_weight if self.minimum else -p1_mst_weight
+                    self.partition_queue.put(p1.__copy__())
+                except nx.NetworkXException:
+                    pass
+
+                p1.partition_dict = p2.partition_dict.copy()
+
+    def _write_partition(self, partition):
+        """
+        Writes the desired partition into the graph to calculate the minimum
+        spanning tree. Also, if one incoming edge is included, mark all others
+        as excluded so that if that vertex is merged during Edmonds' algorithm
+        we cannot still pick another of that vertex's included edges.
+
+        Parameters
+        ----------
+        partition : Partition
+            A Partition dataclass describing a partition on the edges of the
+            graph.
+        """
+        for u, v, d in self.G.edges(data=True):
+            if (u, v) in partition.partition_dict:
+                d[self.partition_key] = partition.partition_dict[(u, v)]
+            else:
+                d[self.partition_key] = nx.EdgePartition.OPEN
+
+        for n in self.G:
+            included_count = 0
+            excluded_count = 0
+            for u, v, d in self.G.in_edges(nbunch=n, data=True):
+                if d.get(self.partition_key) == nx.EdgePartition.INCLUDED:
+                    included_count += 1
+                elif d.get(self.partition_key) == nx.EdgePartition.EXCLUDED:
+                    excluded_count += 1
+            # Check that if there is an included edges, all other incoming ones
+            # are excluded. If not fix it!
+            if included_count == 1 and excluded_count != self.G.in_degree(n) - 1:
+                for u, v, d in self.G.in_edges(nbunch=n, data=True):
+                    if d.get(self.partition_key) != nx.EdgePartition.INCLUDED:
+                        d[self.partition_key] = nx.EdgePartition.EXCLUDED
+
+    def _clear_partition(self, G):
+        """
+        Removes partition data from the graph
+        """
+        for u, v, d in G.edges(data=True):
+            if self.partition_key in d:
+                del d[self.partition_key]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/coding.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/coding.py
new file mode 100644
index 0000000..0147e7e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/coding.py
@@ -0,0 +1,398 @@
+"""Functions for encoding and decoding trees.
+
+Since a tree is a highly restricted form of graph, it can be represented
+concisely in several ways. This module includes functions for encoding
+and decoding trees in the form of nested tuples and Prüfer
+sequences. The former requires a rooted tree, whereas the latter can be
+applied to unrooted trees. Furthermore, there is a bijection from Prüfer
+sequences to labeled trees.
+
+"""
+from collections import Counter
+from itertools import chain
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "from_nested_tuple",
+    "from_prufer_sequence",
+    "NotATree",
+    "to_nested_tuple",
+    "to_prufer_sequence",
+]
+
+
+class NotATree(nx.NetworkXException):
+    """Raised when a function expects a tree (that is, a connected
+    undirected graph with no cycles) but gets a non-tree graph as input
+    instead.
+
+    """
+
+
+@not_implemented_for("directed")
+def to_nested_tuple(T, root, canonical_form=False):
+    """Returns a nested tuple representation of the given tree.
+
+    The nested tuple representation of a tree is defined
+    recursively. The tree with one node and no edges is represented by
+    the empty tuple, ``()``. A tree with ``k`` subtrees is represented
+    by a tuple of length ``k`` in which each element is the nested tuple
+    representation of a subtree.
+
+    Parameters
+    ----------
+    T : NetworkX graph
+        An undirected graph object representing a tree.
+
+    root : node
+        The node in ``T`` to interpret as the root of the tree.
+
+    canonical_form : bool
+        If ``True``, each tuple is sorted so that the function returns
+        a canonical form for rooted trees. This means "lighter" subtrees
+        will appear as nested tuples before "heavier" subtrees. In this
+        way, each isomorphic rooted tree has the same nested tuple
+        representation.
+
+    Returns
+    -------
+    tuple
+        A nested tuple representation of the tree.
+
+    Notes
+    -----
+    This function is *not* the inverse of :func:`from_nested_tuple`; the
+    only guarantee is that the rooted trees are isomorphic.
+
+    See also
+    --------
+    from_nested_tuple
+    to_prufer_sequence
+
+    Examples
+    --------
+    The tree need not be a balanced binary tree::
+
+        >>> T = nx.Graph()
+        >>> T.add_edges_from([(0, 1), (0, 2), (0, 3)])
+        >>> T.add_edges_from([(1, 4), (1, 5)])
+        >>> T.add_edges_from([(3, 6), (3, 7)])
+        >>> root = 0
+        >>> nx.to_nested_tuple(T, root)
+        (((), ()), (), ((), ()))
+
+    Continuing the above example, if ``canonical_form`` is ``True``, the
+    nested tuples will be sorted::
+
+        >>> nx.to_nested_tuple(T, root, canonical_form=True)
+        ((), ((), ()), ((), ()))
+
+    Even the path graph can be interpreted as a tree::
+
+        >>> T = nx.path_graph(4)
+        >>> root = 0
+        >>> nx.to_nested_tuple(T, root)
+        ((((),),),)
+
+    """
+
+    def _make_tuple(T, root, _parent):
+        """Recursively compute the nested tuple representation of the
+        given rooted tree.
+
+        ``_parent`` is the parent node of ``root`` in the supertree in
+        which ``T`` is a subtree, or ``None`` if ``root`` is the root of
+        the supertree. This argument is used to determine which
+        neighbors of ``root`` are children and which is the parent.
+
+        """
+        # Get the neighbors of `root` that are not the parent node. We
+        # are guaranteed that `root` is always in `T` by construction.
+        children = set(T[root]) - {_parent}
+        if len(children) == 0:
+            return ()
+        nested = (_make_tuple(T, v, root) for v in children)
+        if canonical_form:
+            nested = sorted(nested)
+        return tuple(nested)
+
+    # Do some sanity checks on the input.
+    if not nx.is_tree(T):
+        raise nx.NotATree("provided graph is not a tree")
+    if root not in T:
+        raise nx.NodeNotFound(f"Graph {T} contains no node {root}")
+
+    return _make_tuple(T, root, None)
+
+
+def from_nested_tuple(sequence, sensible_relabeling=False):
+    """Returns the rooted tree corresponding to the given nested tuple.
+
+    The nested tuple representation of a tree is defined
+    recursively. The tree with one node and no edges is represented by
+    the empty tuple, ``()``. A tree with ``k`` subtrees is represented
+    by a tuple of length ``k`` in which each element is the nested tuple
+    representation of a subtree.
+
+    Parameters
+    ----------
+    sequence : tuple
+        A nested tuple representing a rooted tree.
+
+    sensible_relabeling : bool
+        Whether to relabel the nodes of the tree so that nodes are
+        labeled in increasing order according to their breadth-first
+        search order from the root node.
+
+    Returns
+    -------
+    NetworkX graph
+        The tree corresponding to the given nested tuple, whose root
+        node is node 0. If ``sensible_labeling`` is ``True``, nodes will
+        be labeled in breadth-first search order starting from the root
+        node.
+
+    Notes
+    -----
+    This function is *not* the inverse of :func:`to_nested_tuple`; the
+    only guarantee is that the rooted trees are isomorphic.
+
+    See also
+    --------
+    to_nested_tuple
+    from_prufer_sequence
+
+    Examples
+    --------
+    Sensible relabeling ensures that the nodes are labeled from the root
+    starting at 0::
+
+        >>> balanced = (((), ()), ((), ()))
+        >>> T = nx.from_nested_tuple(balanced, sensible_relabeling=True)
+        >>> edges = [(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6)]
+        >>> all((u, v) in T.edges() or (v, u) in T.edges() for (u, v) in edges)
+        True
+
+    """
+
+    def _make_tree(sequence):
+        """Recursively creates a tree from the given sequence of nested
+        tuples.
+
+        This function employs the :func:`~networkx.tree.join` function
+        to recursively join subtrees into a larger tree.
+
+        """
+        # The empty sequence represents the empty tree, which is the
+        # (unique) graph with a single node. We mark the single node
+        # with an attribute that indicates that it is the root of the
+        # graph.
+        if len(sequence) == 0:
+            return nx.empty_graph(1)
+        # For a nonempty sequence, get the subtrees for each child
+        # sequence and join all the subtrees at their roots. After
+        # joining the subtrees, the root is node 0.
+        return nx.tree.join([(_make_tree(child), 0) for child in sequence])
+
+    # Make the tree and remove the `is_root` node attribute added by the
+    # helper function.
+    T = _make_tree(sequence)
+    if sensible_relabeling:
+        # Relabel the nodes according to their breadth-first search
+        # order, starting from the root node (that is, the node 0).
+        bfs_nodes = chain([0], (v for u, v in nx.bfs_edges(T, 0)))
+        labels = {v: i for i, v in enumerate(bfs_nodes)}
+        # We would like to use `copy=False`, but `relabel_nodes` doesn't
+        # allow a relabel mapping that can't be topologically sorted.
+        T = nx.relabel_nodes(T, labels)
+    return T
+
+
+@not_implemented_for("directed")
+def to_prufer_sequence(T):
+    r"""Returns the Prüfer sequence of the given tree.
+
+    A *Prüfer sequence* is a list of *n* - 2 numbers between 0 and
+    *n* - 1, inclusive. The tree corresponding to a given Prüfer
+    sequence can be recovered by repeatedly joining a node in the
+    sequence with a node with the smallest potential degree according to
+    the sequence.
+
+    Parameters
+    ----------
+    T : NetworkX graph
+        An undirected graph object representing a tree.
+
+    Returns
+    -------
+    list
+        The Prüfer sequence of the given tree.
+
+    Raises
+    ------
+    NetworkXPointlessConcept
+        If the number of nodes in `T` is less than two.
+
+    NotATree
+        If `T` is not a tree.
+
+    KeyError
+        If the set of nodes in `T` is not {0, …, *n* - 1}.
+
+    Notes
+    -----
+    There is a bijection from labeled trees to Prüfer sequences. This
+    function is the inverse of the :func:`from_prufer_sequence`
+    function.
+
+    Sometimes Prüfer sequences use nodes labeled from 1 to *n* instead
+    of from 0 to *n* - 1. This function requires nodes to be labeled in
+    the latter form. You can use :func:`~networkx.relabel_nodes` to
+    relabel the nodes of your tree to the appropriate format.
+
+    This implementation is from [1]_ and has a running time of
+    $O(n)$.
+
+    See also
+    --------
+    to_nested_tuple
+    from_prufer_sequence
+
+    References
+    ----------
+    .. [1] Wang, Xiaodong, Lei Wang, and Yingjie Wu.
+           "An optimal algorithm for Prufer codes."
+           *Journal of Software Engineering and Applications* 2.02 (2009): 111.
+           <https://doi.org/10.4236/jsea.2009.22016>
+
+    Examples
+    --------
+    There is a bijection between Prüfer sequences and labeled trees, so
+    this function is the inverse of the :func:`from_prufer_sequence`
+    function:
+
+    >>> edges = [(0, 3), (1, 3), (2, 3), (3, 4), (4, 5)]
+    >>> tree = nx.Graph(edges)
+    >>> sequence = nx.to_prufer_sequence(tree)
+    >>> sequence
+    [3, 3, 3, 4]
+    >>> tree2 = nx.from_prufer_sequence(sequence)
+    >>> list(tree2.edges()) == edges
+    True
+
+    """
+    # Perform some sanity checks on the input.
+    n = len(T)
+    if n < 2:
+        msg = "Prüfer sequence undefined for trees with fewer than two nodes"
+        raise nx.NetworkXPointlessConcept(msg)
+    if not nx.is_tree(T):
+        raise nx.NotATree("provided graph is not a tree")
+    if set(T) != set(range(n)):
+        raise KeyError("tree must have node labels {0, ..., n - 1}")
+
+    degree = dict(T.degree())
+
+    def parents(u):
+        return next(v for v in T[u] if degree[v] > 1)
+
+    index = u = next(k for k in range(n) if degree[k] == 1)
+    result = []
+    for i in range(n - 2):
+        v = parents(u)
+        result.append(v)
+        degree[v] -= 1
+        if v < index and degree[v] == 1:
+            u = v
+        else:
+            index = u = next(k for k in range(index + 1, n) if degree[k] == 1)
+    return result
+
+
+def from_prufer_sequence(sequence):
+    r"""Returns the tree corresponding to the given Prüfer sequence.
+
+    A *Prüfer sequence* is a list of *n* - 2 numbers between 0 and
+    *n* - 1, inclusive. The tree corresponding to a given Prüfer
+    sequence can be recovered by repeatedly joining a node in the
+    sequence with a node with the smallest potential degree according to
+    the sequence.
+
+    Parameters
+    ----------
+    sequence : list
+        A Prüfer sequence, which is a list of *n* - 2 integers between
+        zero and *n* - 1, inclusive.
+
+    Returns
+    -------
+    NetworkX graph
+        The tree corresponding to the given Prüfer sequence.
+
+    Notes
+    -----
+    There is a bijection from labeled trees to Prüfer sequences. This
+    function is the inverse of the :func:`from_prufer_sequence` function.
+
+    Sometimes Prüfer sequences use nodes labeled from 1 to *n* instead
+    of from 0 to *n* - 1. This function requires nodes to be labeled in
+    the latter form. You can use :func:`networkx.relabel_nodes` to
+    relabel the nodes of your tree to the appropriate format.
+
+    This implementation is from [1]_ and has a running time of
+    $O(n)$.
+
+    References
+    ----------
+    .. [1] Wang, Xiaodong, Lei Wang, and Yingjie Wu.
+           "An optimal algorithm for Prufer codes."
+           *Journal of Software Engineering and Applications* 2.02 (2009): 111.
+           <https://doi.org/10.4236/jsea.2009.22016>
+
+    See also
+    --------
+    from_nested_tuple
+    to_prufer_sequence
+
+    Examples
+    --------
+    There is a bijection between Prüfer sequences and labeled trees, so
+    this function is the inverse of the :func:`to_prufer_sequence`
+    function:
+
+    >>> edges = [(0, 3), (1, 3), (2, 3), (3, 4), (4, 5)]
+    >>> tree = nx.Graph(edges)
+    >>> sequence = nx.to_prufer_sequence(tree)
+    >>> sequence
+    [3, 3, 3, 4]
+    >>> tree2 = nx.from_prufer_sequence(sequence)
+    >>> list(tree2.edges()) == edges
+    True
+
+    """
+    n = len(sequence) + 2
+    # `degree` stores the remaining degree (plus one) for each node. The
+    # degree of a node in the decoded tree is one more than the number
+    # of times it appears in the code.
+    degree = Counter(chain(sequence, range(n)))
+    T = nx.empty_graph(n)
+    # `not_orphaned` is the set of nodes that have a parent in the
+    # tree. After the loop, there should be exactly two nodes that are
+    # not in this set.
+    not_orphaned = set()
+    index = u = next(k for k in range(n) if degree[k] == 1)
+    for v in sequence:
+        T.add_edge(u, v)
+        not_orphaned.add(u)
+        degree[v] -= 1
+        if v < index and degree[v] == 1:
+            u = v
+        else:
+            index = u = next(k for k in range(index + 1, n) if degree[k] == 1)
+    # At this point, there must be exactly two orphaned nodes; join them.
+    orphans = set(T) - not_orphaned
+    u, v = orphans
+    T.add_edge(u, v)
+    return T
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/decomposition.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/decomposition.py
new file mode 100644
index 0000000..54a2118
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/decomposition.py
@@ -0,0 +1,87 @@
+r"""Function for computing a junction tree of a graph."""
+
+from itertools import combinations
+
+import networkx as nx
+from networkx.algorithms import chordal_graph_cliques, complete_to_chordal_graph, moral
+from networkx.utils import not_implemented_for
+
+__all__ = ["junction_tree"]
+
+
+@not_implemented_for("multigraph")
+def junction_tree(G):
+    r"""Returns a junction tree of a given graph.
+
+    A junction tree (or clique tree) is constructed from a (un)directed graph G.
+    The tree is constructed based on a moralized and triangulated version of G.
+    The tree's nodes consist of maximal cliques and sepsets of the revised graph.
+    The sepset of two cliques is the intersection of the nodes of these cliques,
+    e.g. the sepset of (A,B,C) and (A,C,E,F) is (A,C). These nodes are often called
+    "variables" in this literature. The tree is bipartitie with each sepset
+    connected to its two cliques.
+
+    Junction Trees are not unique as the order of clique consideration determines
+    which sepsets are included.
+
+    The junction tree algorithm consists of five steps [1]_:
+
+    1. Moralize the graph
+    2. Triangulate the graph
+    3. Find maximal cliques
+    4. Build the tree from cliques, connecting cliques with shared
+       nodes, set edge-weight to number of shared variables
+    5. Find maximum spanning tree
+
+
+    Parameters
+    ----------
+    G : networkx.Graph
+        Directed or undirected graph.
+
+    Returns
+    -------
+    junction_tree : networkx.Graph
+        The corresponding junction tree of `G`.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        Raised if `G` is an instance of `MultiGraph` or `MultiDiGraph`.
+
+    References
+    ----------
+    .. [1] Junction tree algorithm:
+       https://en.wikipedia.org/wiki/Junction_tree_algorithm
+
+    .. [2] Finn V. Jensen and Frank Jensen. 1994. Optimal
+       junction trees. In Proceedings of the Tenth international
+       conference on Uncertainty in artificial intelligence (UAI’94).
+       Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 360–366.
+    """
+
+    clique_graph = nx.Graph()
+
+    if G.is_directed():
+        G = moral.moral_graph(G)
+    chordal_graph, _ = complete_to_chordal_graph(G)
+
+    cliques = [tuple(sorted(i)) for i in chordal_graph_cliques(chordal_graph)]
+    clique_graph.add_nodes_from(cliques, type="clique")
+
+    for edge in combinations(cliques, 2):
+        set_edge_0 = set(edge[0])
+        set_edge_1 = set(edge[1])
+        if not set_edge_0.isdisjoint(set_edge_1):
+            sepset = tuple(sorted(set_edge_0.intersection(set_edge_1)))
+            clique_graph.add_edge(edge[0], edge[1], weight=len(sepset), sepset=sepset)
+
+    junction_tree = nx.maximum_spanning_tree(clique_graph)
+
+    for edge in list(junction_tree.edges(data=True)):
+        junction_tree.add_node(edge[2]["sepset"], type="sepset")
+        junction_tree.add_edge(edge[0], edge[2]["sepset"])
+        junction_tree.add_edge(edge[1], edge[2]["sepset"])
+        junction_tree.remove_edge(edge[0], edge[1])
+
+    return junction_tree
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/mst.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/mst.py
new file mode 100644
index 0000000..e2ff7c6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/mst.py
@@ -0,0 +1,1112 @@
+"""
+Algorithms for calculating min/max spanning trees/forests.
+
+"""
+from dataclasses import dataclass, field
+from enum import Enum
+from heapq import heappop, heappush
+from itertools import count
+from math import isnan
+from operator import itemgetter
+from queue import PriorityQueue
+
+import networkx as nx
+from networkx.utils import UnionFind, not_implemented_for, py_random_state
+
+__all__ = [
+    "minimum_spanning_edges",
+    "maximum_spanning_edges",
+    "minimum_spanning_tree",
+    "maximum_spanning_tree",
+    "random_spanning_tree",
+    "partition_spanning_tree",
+    "EdgePartition",
+    "SpanningTreeIterator",
+]
+
+
+class EdgePartition(Enum):
+    """
+    An enum to store the state of an edge partition. The enum is written to the
+    edges of a graph before being pasted to `kruskal_mst_edges`. Options are:
+
+    - EdgePartition.OPEN
+    - EdgePartition.INCLUDED
+    - EdgePartition.EXCLUDED
+    """
+
+    OPEN = 0
+    INCLUDED = 1
+    EXCLUDED = 2
+
+
+@not_implemented_for("multigraph")
+def boruvka_mst_edges(
+    G, minimum=True, weight="weight", keys=False, data=True, ignore_nan=False
+):
+    """Iterate over edges of a Borůvka's algorithm min/max spanning tree.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        The edges of `G` must have distinct weights,
+        otherwise the edges may not form a tree.
+
+    minimum : bool (default: True)
+        Find the minimum (True) or maximum (False) spanning tree.
+
+    weight : string (default: 'weight')
+        The name of the edge attribute holding the edge weights.
+
+    keys : bool (default: True)
+        This argument is ignored since this function is not
+        implemented for multigraphs; it exists only for consistency
+        with the other minimum spanning tree functions.
+
+    data : bool (default: True)
+        Flag for whether to yield edge attribute dicts.
+        If True, yield edges `(u, v, d)`, where `d` is the attribute dict.
+        If False, yield edges `(u, v)`.
+
+    ignore_nan : bool (default: False)
+        If a NaN is found as an edge weight normally an exception is raised.
+        If `ignore_nan is True` then that edge is ignored instead.
+
+    """
+    # Initialize a forest, assuming initially that it is the discrete
+    # partition of the nodes of the graph.
+    forest = UnionFind(G)
+
+    def best_edge(component):
+        """Returns the optimum (minimum or maximum) edge on the edge
+        boundary of the given set of nodes.
+
+        A return value of ``None`` indicates an empty boundary.
+
+        """
+        sign = 1 if minimum else -1
+        minwt = float("inf")
+        boundary = None
+        for e in nx.edge_boundary(G, component, data=True):
+            wt = e[-1].get(weight, 1) * sign
+            if isnan(wt):
+                if ignore_nan:
+                    continue
+                msg = f"NaN found as an edge weight. Edge {e}"
+                raise ValueError(msg)
+            if wt < minwt:
+                minwt = wt
+                boundary = e
+        return boundary
+
+    # Determine the optimum edge in the edge boundary of each component
+    # in the forest.
+    best_edges = (best_edge(component) for component in forest.to_sets())
+    best_edges = [edge for edge in best_edges if edge is not None]
+    # If each entry was ``None``, that means the graph was disconnected,
+    # so we are done generating the forest.
+    while best_edges:
+        # Determine the optimum edge in the edge boundary of each
+        # component in the forest.
+        #
+        # This must be a sequence, not an iterator. In this list, the
+        # same edge may appear twice, in different orientations (but
+        # that's okay, since a union operation will be called on the
+        # endpoints the first time it is seen, but not the second time).
+        #
+        # Any ``None`` indicates that the edge boundary for that
+        # component was empty, so that part of the forest has been
+        # completed.
+        #
+        # TODO This can be parallelized, both in the outer loop over
+        # each component in the forest and in the computation of the
+        # minimum. (Same goes for the identical lines outside the loop.)
+        best_edges = (best_edge(component) for component in forest.to_sets())
+        best_edges = [edge for edge in best_edges if edge is not None]
+        # Join trees in the forest using the best edges, and yield that
+        # edge, since it is part of the spanning tree.
+        #
+        # TODO This loop can be parallelized, to an extent (the union
+        # operation must be atomic).
+        for u, v, d in best_edges:
+            if forest[u] != forest[v]:
+                if data:
+                    yield u, v, d
+                else:
+                    yield u, v
+                forest.union(u, v)
+
+
+def kruskal_mst_edges(
+    G, minimum, weight="weight", keys=True, data=True, ignore_nan=False, partition=None
+):
+    """
+    Iterate over edge of a Kruskal's algorithm min/max spanning tree.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        The graph holding the tree of interest.
+
+    minimum : bool (default: True)
+        Find the minimum (True) or maximum (False) spanning tree.
+
+    weight : string (default: 'weight')
+        The name of the edge attribute holding the edge weights.
+
+    keys : bool (default: True)
+        If `G` is a multigraph, `keys` controls whether edge keys ar yielded.
+        Otherwise `keys` is ignored.
+
+    data : bool (default: True)
+        Flag for whether to yield edge attribute dicts.
+        If True, yield edges `(u, v, d)`, where `d` is the attribute dict.
+        If False, yield edges `(u, v)`.
+
+    ignore_nan : bool (default: False)
+        If a NaN is found as an edge weight normally an exception is raised.
+        If `ignore_nan is True` then that edge is ignored instead.
+
+    partition : string (default: None)
+        The name of the edge attribute holding the partition data, if it exists.
+        Partition data is written to the edges using the `EdgePartition` enum.
+        If a partition exists, all included edges and none of the excluded edges
+        will appear in the final tree. Open edges may or may not be used.
+
+    Yields
+    ------
+    edge tuple
+        The edges as discovered by Kruskal's method. Each edge can
+        take the following forms: `(u, v)`, `(u, v, d)` or `(u, v, k, d)`
+        depending on the `key` and `data` parameters
+    """
+    subtrees = UnionFind()
+    if G.is_multigraph():
+        edges = G.edges(keys=True, data=True)
+    else:
+        edges = G.edges(data=True)
+
+    """
+    Sort the edges of the graph with respect to the partition data. 
+    Edges are returned in the following order:
+
+    * Included edges
+    * Open edges from smallest to largest weight
+    * Excluded edges
+    """
+    included_edges = []
+    open_edges = []
+    for e in edges:
+        d = e[-1]
+        wt = d.get(weight, 1)
+        if isnan(wt):
+            if ignore_nan:
+                continue
+            raise ValueError(f"NaN found as an edge weight. Edge {e}")
+
+        edge = (wt,) + e
+        if d.get(partition) == EdgePartition.INCLUDED:
+            included_edges.append(edge)
+        elif d.get(partition) == EdgePartition.EXCLUDED:
+            continue
+        else:
+            open_edges.append(edge)
+
+    if minimum:
+        sorted_open_edges = sorted(open_edges, key=itemgetter(0))
+    else:
+        sorted_open_edges = sorted(open_edges, key=itemgetter(0), reverse=True)
+
+    # Condense the lists into one
+    included_edges.extend(sorted_open_edges)
+    sorted_edges = included_edges
+    del open_edges, sorted_open_edges, included_edges
+
+    # Multigraphs need to handle edge keys in addition to edge data.
+    if G.is_multigraph():
+        for wt, u, v, k, d in sorted_edges:
+            if subtrees[u] != subtrees[v]:
+                if keys:
+                    if data:
+                        yield u, v, k, d
+                    else:
+                        yield u, v, k
+                else:
+                    if data:
+                        yield u, v, d
+                    else:
+                        yield u, v
+                subtrees.union(u, v)
+    else:
+        for wt, u, v, d in sorted_edges:
+            if subtrees[u] != subtrees[v]:
+                if data:
+                    yield u, v, d
+                else:
+                    yield u, v
+                subtrees.union(u, v)
+
+
+def prim_mst_edges(G, minimum, weight="weight", keys=True, data=True, ignore_nan=False):
+    """Iterate over edges of Prim's algorithm min/max spanning tree.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        The graph holding the tree of interest.
+
+    minimum : bool (default: True)
+        Find the minimum (True) or maximum (False) spanning tree.
+
+    weight : string (default: 'weight')
+        The name of the edge attribute holding the edge weights.
+
+    keys : bool (default: True)
+        If `G` is a multigraph, `keys` controls whether edge keys ar yielded.
+        Otherwise `keys` is ignored.
+
+    data : bool (default: True)
+        Flag for whether to yield edge attribute dicts.
+        If True, yield edges `(u, v, d)`, where `d` is the attribute dict.
+        If False, yield edges `(u, v)`.
+
+    ignore_nan : bool (default: False)
+        If a NaN is found as an edge weight normally an exception is raised.
+        If `ignore_nan is True` then that edge is ignored instead.
+
+    """
+    is_multigraph = G.is_multigraph()
+    push = heappush
+    pop = heappop
+
+    nodes = set(G)
+    c = count()
+
+    sign = 1 if minimum else -1
+
+    while nodes:
+        u = nodes.pop()
+        frontier = []
+        visited = {u}
+        if is_multigraph:
+            for v, keydict in G.adj[u].items():
+                for k, d in keydict.items():
+                    wt = d.get(weight, 1) * sign
+                    if isnan(wt):
+                        if ignore_nan:
+                            continue
+                        msg = f"NaN found as an edge weight. Edge {(u, v, k, d)}"
+                        raise ValueError(msg)
+                    push(frontier, (wt, next(c), u, v, k, d))
+        else:
+            for v, d in G.adj[u].items():
+                wt = d.get(weight, 1) * sign
+                if isnan(wt):
+                    if ignore_nan:
+                        continue
+                    msg = f"NaN found as an edge weight. Edge {(u, v, d)}"
+                    raise ValueError(msg)
+                push(frontier, (wt, next(c), u, v, d))
+        while nodes and frontier:
+            if is_multigraph:
+                W, _, u, v, k, d = pop(frontier)
+            else:
+                W, _, u, v, d = pop(frontier)
+            if v in visited or v not in nodes:
+                continue
+            # Multigraphs need to handle edge keys in addition to edge data.
+            if is_multigraph and keys:
+                if data:
+                    yield u, v, k, d
+                else:
+                    yield u, v, k
+            else:
+                if data:
+                    yield u, v, d
+                else:
+                    yield u, v
+            # update frontier
+            visited.add(v)
+            nodes.discard(v)
+            if is_multigraph:
+                for w, keydict in G.adj[v].items():
+                    if w in visited:
+                        continue
+                    for k2, d2 in keydict.items():
+                        new_weight = d2.get(weight, 1) * sign
+                        push(frontier, (new_weight, next(c), v, w, k2, d2))
+            else:
+                for w, d2 in G.adj[v].items():
+                    if w in visited:
+                        continue
+                    new_weight = d2.get(weight, 1) * sign
+                    push(frontier, (new_weight, next(c), v, w, d2))
+
+
+ALGORITHMS = {
+    "boruvka": boruvka_mst_edges,
+    "borůvka": boruvka_mst_edges,
+    "kruskal": kruskal_mst_edges,
+    "prim": prim_mst_edges,
+}
+
+
+@not_implemented_for("directed")
+def minimum_spanning_edges(
+    G, algorithm="kruskal", weight="weight", keys=True, data=True, ignore_nan=False
+):
+    """Generate edges in a minimum spanning forest of an undirected
+    weighted graph.
+
+    A minimum spanning tree is a subgraph of the graph (a tree)
+    with the minimum sum of edge weights.  A spanning forest is a
+    union of the spanning trees for each connected component of the graph.
+
+    Parameters
+    ----------
+    G : undirected Graph
+       An undirected graph. If `G` is connected, then the algorithm finds a
+       spanning tree. Otherwise, a spanning forest is found.
+
+    algorithm : string
+       The algorithm to use when finding a minimum spanning tree. Valid
+       choices are 'kruskal', 'prim', or 'boruvka'. The default is 'kruskal'.
+
+    weight : string
+       Edge data key to use for weight (default 'weight').
+
+    keys : bool
+       Whether to yield edge key in multigraphs in addition to the edge.
+       If `G` is not a multigraph, this is ignored.
+
+    data : bool, optional
+       If True yield the edge data along with the edge.
+
+    ignore_nan : bool (default: False)
+        If a NaN is found as an edge weight normally an exception is raised.
+        If `ignore_nan is True` then that edge is ignored instead.
+
+    Returns
+    -------
+    edges : iterator
+       An iterator over edges in a maximum spanning tree of `G`.
+       Edges connecting nodes `u` and `v` are represented as tuples:
+       `(u, v, k, d)` or `(u, v, k)` or `(u, v, d)` or `(u, v)`
+
+       If `G` is a multigraph, `keys` indicates whether the edge key `k` will
+       be reported in the third position in the edge tuple. `data` indicates
+       whether the edge datadict `d` will appear at the end of the edge tuple.
+
+       If `G` is not a multigraph, the tuples are `(u, v, d)` if `data` is True
+       or `(u, v)` if `data` is False.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import tree
+
+    Find minimum spanning edges by Kruskal's algorithm
+
+    >>> G = nx.cycle_graph(4)
+    >>> G.add_edge(0, 3, weight=2)
+    >>> mst = tree.minimum_spanning_edges(G, algorithm="kruskal", data=False)
+    >>> edgelist = list(mst)
+    >>> sorted(sorted(e) for e in edgelist)
+    [[0, 1], [1, 2], [2, 3]]
+
+    Find minimum spanning edges by Prim's algorithm
+
+    >>> G = nx.cycle_graph(4)
+    >>> G.add_edge(0, 3, weight=2)
+    >>> mst = tree.minimum_spanning_edges(G, algorithm="prim", data=False)
+    >>> edgelist = list(mst)
+    >>> sorted(sorted(e) for e in edgelist)
+    [[0, 1], [1, 2], [2, 3]]
+
+    Notes
+    -----
+    For Borůvka's algorithm, each edge must have a weight attribute, and
+    each edge weight must be distinct.
+
+    For the other algorithms, if the graph edges do not have a weight
+    attribute a default weight of 1 will be used.
+
+    Modified code from David Eppstein, April 2006
+    http://www.ics.uci.edu/~eppstein/PADS/
+
+    """
+    try:
+        algo = ALGORITHMS[algorithm]
+    except KeyError as err:
+        msg = f"{algorithm} is not a valid choice for an algorithm."
+        raise ValueError(msg) from err
+
+    return algo(
+        G, minimum=True, weight=weight, keys=keys, data=data, ignore_nan=ignore_nan
+    )
+
+
+@not_implemented_for("directed")
+def maximum_spanning_edges(
+    G, algorithm="kruskal", weight="weight", keys=True, data=True, ignore_nan=False
+):
+    """Generate edges in a maximum spanning forest of an undirected
+    weighted graph.
+
+    A maximum spanning tree is a subgraph of the graph (a tree)
+    with the maximum possible sum of edge weights.  A spanning forest is a
+    union of the spanning trees for each connected component of the graph.
+
+    Parameters
+    ----------
+    G : undirected Graph
+       An undirected graph. If `G` is connected, then the algorithm finds a
+       spanning tree. Otherwise, a spanning forest is found.
+
+    algorithm : string
+       The algorithm to use when finding a maximum spanning tree. Valid
+       choices are 'kruskal', 'prim', or 'boruvka'. The default is 'kruskal'.
+
+    weight : string
+       Edge data key to use for weight (default 'weight').
+
+    keys : bool
+       Whether to yield edge key in multigraphs in addition to the edge.
+       If `G` is not a multigraph, this is ignored.
+
+    data : bool, optional
+       If True yield the edge data along with the edge.
+
+    ignore_nan : bool (default: False)
+        If a NaN is found as an edge weight normally an exception is raised.
+        If `ignore_nan is True` then that edge is ignored instead.
+
+    Returns
+    -------
+    edges : iterator
+       An iterator over edges in a maximum spanning tree of `G`.
+       Edges connecting nodes `u` and `v` are represented as tuples:
+       `(u, v, k, d)` or `(u, v, k)` or `(u, v, d)` or `(u, v)`
+
+       If `G` is a multigraph, `keys` indicates whether the edge key `k` will
+       be reported in the third position in the edge tuple. `data` indicates
+       whether the edge datadict `d` will appear at the end of the edge tuple.
+
+       If `G` is not a multigraph, the tuples are `(u, v, d)` if `data` is True
+       or `(u, v)` if `data` is False.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import tree
+
+    Find maximum spanning edges by Kruskal's algorithm
+
+    >>> G = nx.cycle_graph(4)
+    >>> G.add_edge(0, 3, weight=2)
+    >>> mst = tree.maximum_spanning_edges(G, algorithm="kruskal", data=False)
+    >>> edgelist = list(mst)
+    >>> sorted(sorted(e) for e in edgelist)
+    [[0, 1], [0, 3], [1, 2]]
+
+    Find maximum spanning edges by Prim's algorithm
+
+    >>> G = nx.cycle_graph(4)
+    >>> G.add_edge(0, 3, weight=2)  # assign weight 2 to edge 0-3
+    >>> mst = tree.maximum_spanning_edges(G, algorithm="prim", data=False)
+    >>> edgelist = list(mst)
+    >>> sorted(sorted(e) for e in edgelist)
+    [[0, 1], [0, 3], [2, 3]]
+
+    Notes
+    -----
+    For Borůvka's algorithm, each edge must have a weight attribute, and
+    each edge weight must be distinct.
+
+    For the other algorithms, if the graph edges do not have a weight
+    attribute a default weight of 1 will be used.
+
+    Modified code from David Eppstein, April 2006
+    http://www.ics.uci.edu/~eppstein/PADS/
+    """
+    try:
+        algo = ALGORITHMS[algorithm]
+    except KeyError as err:
+        msg = f"{algorithm} is not a valid choice for an algorithm."
+        raise ValueError(msg) from err
+
+    return algo(
+        G, minimum=False, weight=weight, keys=keys, data=data, ignore_nan=ignore_nan
+    )
+
+
+def minimum_spanning_tree(G, weight="weight", algorithm="kruskal", ignore_nan=False):
+    """Returns a minimum spanning tree or forest on an undirected graph `G`.
+
+    Parameters
+    ----------
+    G : undirected graph
+        An undirected graph. If `G` is connected, then the algorithm finds a
+        spanning tree. Otherwise, a spanning forest is found.
+
+    weight : str
+       Data key to use for edge weights.
+
+    algorithm : string
+       The algorithm to use when finding a minimum spanning tree. Valid
+       choices are 'kruskal', 'prim', or 'boruvka'. The default is
+       'kruskal'.
+
+    ignore_nan : bool (default: False)
+        If a NaN is found as an edge weight normally an exception is raised.
+        If `ignore_nan is True` then that edge is ignored instead.
+
+    Returns
+    -------
+    G : NetworkX Graph
+       A minimum spanning tree or forest.
+
+    Examples
+    --------
+    >>> G = nx.cycle_graph(4)
+    >>> G.add_edge(0, 3, weight=2)
+    >>> T = nx.minimum_spanning_tree(G)
+    >>> sorted(T.edges(data=True))
+    [(0, 1, {}), (1, 2, {}), (2, 3, {})]
+
+
+    Notes
+    -----
+    For Borůvka's algorithm, each edge must have a weight attribute, and
+    each edge weight must be distinct.
+
+    For the other algorithms, if the graph edges do not have a weight
+    attribute a default weight of 1 will be used.
+
+    There may be more than one tree with the same minimum or maximum weight.
+    See :mod:`networkx.tree.recognition` for more detailed definitions.
+
+    Isolated nodes with self-loops are in the tree as edgeless isolated nodes.
+
+    """
+    edges = minimum_spanning_edges(
+        G, algorithm, weight, keys=True, data=True, ignore_nan=ignore_nan
+    )
+    T = G.__class__()  # Same graph class as G
+    T.graph.update(G.graph)
+    T.add_nodes_from(G.nodes.items())
+    T.add_edges_from(edges)
+    return T
+
+
+def partition_spanning_tree(
+    G, minimum=True, weight="weight", partition="partition", ignore_nan=False
+):
+    """
+    Find a spanning tree while respecting a partition of edges.
+
+    Edges can be flagged as either `INLCUDED` which are required to be in the
+    returned tree, `EXCLUDED`, which cannot be in the returned tree and `OPEN`.
+
+    This is used in the SpanningTreeIterator to create new partitions following
+    the algorithm of Sörensen and Janssens [1]_.
+
+    Parameters
+    ----------
+    G : undirected graph
+        An undirected graph.
+
+    minimum : bool (default: True)
+        Determines whether the returned tree is the minimum spanning tree of
+        the partition of the maximum one.
+
+    weight : str
+        Data key to use for edge weights.
+
+    partition : str
+        The key for the edge attribute containing the partition
+        data on the graph. Edges can be included, excluded or open using the
+        `EdgePartition` enum.
+
+    ignore_nan : bool (default: False)
+        If a NaN is found as an edge weight normally an exception is raised.
+        If `ignore_nan is True` then that edge is ignored instead.
+
+
+    Returns
+    -------
+    G : NetworkX Graph
+        A minimum spanning tree using all of the included edges in the graph and
+        none of the excluded edges.
+
+    References
+    ----------
+    .. [1] G.K. Janssens, K. Sörensen, An algorithm to generate all spanning
+           trees in order of increasing cost, Pesquisa Operacional, 2005-08,
+           Vol. 25 (2), p. 219-229,
+           https://www.scielo.br/j/pope/a/XHswBwRwJyrfL88dmMwYNWp/?lang=en
+    """
+    edges = kruskal_mst_edges(
+        G,
+        minimum,
+        weight,
+        keys=True,
+        data=True,
+        ignore_nan=ignore_nan,
+        partition=partition,
+    )
+    T = G.__class__()  # Same graph class as G
+    T.graph.update(G.graph)
+    T.add_nodes_from(G.nodes.items())
+    T.add_edges_from(edges)
+    return T
+
+
+def maximum_spanning_tree(G, weight="weight", algorithm="kruskal", ignore_nan=False):
+    """Returns a maximum spanning tree or forest on an undirected graph `G`.
+
+    Parameters
+    ----------
+    G : undirected graph
+        An undirected graph. If `G` is connected, then the algorithm finds a
+        spanning tree. Otherwise, a spanning forest is found.
+
+    weight : str
+       Data key to use for edge weights.
+
+    algorithm : string
+       The algorithm to use when finding a maximum spanning tree. Valid
+       choices are 'kruskal', 'prim', or 'boruvka'. The default is
+       'kruskal'.
+
+    ignore_nan : bool (default: False)
+        If a NaN is found as an edge weight normally an exception is raised.
+        If `ignore_nan is True` then that edge is ignored instead.
+
+
+    Returns
+    -------
+    G : NetworkX Graph
+       A maximum spanning tree or forest.
+
+
+    Examples
+    --------
+    >>> G = nx.cycle_graph(4)
+    >>> G.add_edge(0, 3, weight=2)
+    >>> T = nx.maximum_spanning_tree(G)
+    >>> sorted(T.edges(data=True))
+    [(0, 1, {}), (0, 3, {'weight': 2}), (1, 2, {})]
+
+
+    Notes
+    -----
+    For Borůvka's algorithm, each edge must have a weight attribute, and
+    each edge weight must be distinct.
+
+    For the other algorithms, if the graph edges do not have a weight
+    attribute a default weight of 1 will be used.
+
+    There may be more than one tree with the same minimum or maximum weight.
+    See :mod:`networkx.tree.recognition` for more detailed definitions.
+
+    Isolated nodes with self-loops are in the tree as edgeless isolated nodes.
+
+    """
+    edges = maximum_spanning_edges(
+        G, algorithm, weight, keys=True, data=True, ignore_nan=ignore_nan
+    )
+    edges = list(edges)
+    T = G.__class__()  # Same graph class as G
+    T.graph.update(G.graph)
+    T.add_nodes_from(G.nodes.items())
+    T.add_edges_from(edges)
+    return T
+
+
+@py_random_state(3)
+def random_spanning_tree(G, weight=None, *, multiplicative=True, seed=None):
+    """
+    Sample a random spanning tree using the edges weights of `G`.
+
+    This function supports two different methods for determining the
+    probability of the graph. If ``multiplicative=True``, the probability
+    is based on the product of edge weights, and if ``multiplicative=False``
+    it is based on the sum of the edge weight. However, since it is
+    easier to determine the total weight of all spanning trees for the
+    multiplicative verison, that is significantly faster and should be used if
+    possible. Additionally, setting `weight` to `None` will cause a spanning tree
+    to be selected with uniform probability.
+
+    The function uses algorithm A8 in [1]_ .
+
+    Parameters
+    ----------
+    G : nx.Graph
+        An undirected version of the original graph.
+
+    weight : string
+        The edge key for the edge attribute holding edge weight.
+
+    multiplicative : bool, default=True
+        If `True`, the probability of each tree is the product of its edge weight
+        over the sum of the product of all the spanning trees in the graph. If
+        `False`, the probability is the sum of its edge weight over the sum of
+        the sum of weights for all spanning trees in the graph.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    nx.Graph
+        A spanning tree using the distribution defined by the weight of the tree.
+
+    References
+    ----------
+    .. [1] V. Kulkarni, Generating random combinatorial objects, Journal of
+       Algorithms, 11 (1990), pp. 185–207
+    """
+
+    def find_node(merged_nodes, node):
+        """
+        We can think of clusters of contracted nodes as having one
+        representative in the graph. Each node which is not in merged_nodes
+        is still its own representative. Since a representative can be later
+        contracted, we need to recursively search though the dict to find
+        the final representative, but once we know it we can use path
+        compression to speed up the access of the representative for next time.
+
+        This cannot be replaced by the standard NetworkX union_find since that
+        data structure will merge nodes with less representing nodes into the
+        one with more representing nodes but this function requires we merge
+        them using the order that contract_edges contracts using.
+
+        Parameters
+        ----------
+        merged_nodes : dict
+            The dict storing the mapping from node to representative
+        node
+            The node whose representative we seek
+
+        Returns
+        -------
+        The representative of the `node`
+        """
+        if node not in merged_nodes:
+            return node
+        else:
+            rep = find_node(merged_nodes, merged_nodes[node])
+            merged_nodes[node] = rep
+            return rep
+
+    def prepare_graph():
+        """
+        For the graph `G`, remove all edges not in the set `V` and then
+        contract all edges in the set `U`.
+
+        Returns
+        -------
+        A copy of `G` which has had all edges not in `V` removed and all edges
+        in `U` contracted.
+        """
+
+        # The result is a MultiGraph version of G so that parallel edges are
+        # allowed during edge contraction
+        result = nx.MultiGraph(incoming_graph_data=G)
+
+        # Remove all edges not in V
+        edges_to_remove = set(result.edges()).difference(V)
+        result.remove_edges_from(edges_to_remove)
+
+        # Contract all edges in U
+        #
+        # Imagine that you have two edges to contract and they share an
+        # endpoint like this:
+        #                        [0] ----- [1] ----- [2]
+        # If we contract (0, 1) first, the contraction function will always
+        # delete the second node it is passed so the resulting graph would be
+        #                             [0] ----- [2]
+        # and edge (1, 2) no longer exists but (0, 2) would need to be contracted
+        # in its place now. That is why I use the below dict as a merge-find
+        # data structure with path compression to track how the nodes are merged.
+        merged_nodes = {}
+
+        for u, v in U:
+            u_rep = find_node(merged_nodes, u)
+            v_rep = find_node(merged_nodes, v)
+            # We cannot contract a node with itself
+            if u_rep == v_rep:
+                continue
+            nx.contracted_nodes(result, u_rep, v_rep, self_loops=False, copy=False)
+            merged_nodes[v_rep] = u_rep
+
+        return merged_nodes, result
+
+    def spanning_tree_total_weight(G, weight):
+        """
+        Find the sum of weights of the spanning trees of `G` using the
+        approioate `method`.
+
+        This is easy if the choosen method is 'multiplicative', since we can
+        use Kirchhoff's Tree Matrix Theorem directly. However, with the
+        'additive' method, this process is slightly more complex and less
+        computatiionally efficent as we have to find the number of spanning
+        trees which contain each possible edge in the graph.
+
+        Parameters
+        ----------
+        G : NetworkX Graph
+            The graph to find the total weight of all spanning trees on.
+
+        weight : string
+            The key for the weight edge attribute of the graph.
+
+        Returns
+        -------
+        float
+            The sum of either the multiplicative or additive weight for all
+            spanning trees in the graph.
+        """
+        if multiplicative:
+            return nx.total_spanning_tree_weight(G, weight)
+        else:
+            # There are two cases for the total spanning tree additive weight.
+            # 1. There is one edge in the graph. Then the only spanning tree is
+            #    that edge itself, which will have a total weight of that edge
+            #    itself.
+            if G.number_of_edges() == 1:
+                return G.edges(data=weight).__iter__().__next__()[2]
+            # 2. There are more than two edges in the graph. Then, we can find the
+            #    total weight of the spanning trees using the formula in the
+            #    reference paper: take the weight of that edge and multiple it by
+            #    the number of spanning trees which have to include that edge. This
+            #    can be accomplished by contracting the edge and finding the
+            #    multiplicative total spanning tree weight if the weight of each edge
+            #    is assumed to be 1, which is conviently built into networkx already,
+            #    by calling total_spanning_tree_weight with weight=None
+            else:
+                total = 0
+                for u, v, w in G.edges(data=weight):
+                    total += w * nx.total_spanning_tree_weight(
+                        nx.contracted_edge(G, edge=(u, v), self_loops=False), None
+                    )
+                return total
+
+    U = set()
+    st_cached_value = 0
+    V = set(G.edges())
+    shuffled_edges = list(G.edges())
+    seed.shuffle(shuffled_edges)
+
+    for u, v in shuffled_edges:
+        e_weight = G[u][v][weight] if weight is not None else 1
+        node_map, prepared_G = prepare_graph()
+        G_total_tree_weight = spanning_tree_total_weight(prepared_G, weight)
+        # Add the edge to U so that we can compute the total tree weight
+        # assuming we include that edge
+        # Now, if (u, v) cannot exist in G because it is fully contracted out
+        # of existence, then it by definition cannot influence G_e's Kirchhoff
+        # value. But, we also cannot pick it.
+        rep_edge = (find_node(node_map, u), find_node(node_map, v))
+        # Check to see if the 'representative edge' for the current edge is
+        # in prepared_G. If so, then we can pick it.
+        if rep_edge in prepared_G.edges:
+            prepared_G_e = nx.contracted_edge(
+                prepared_G, edge=rep_edge, self_loops=False
+            )
+            G_e_total_tree_weight = spanning_tree_total_weight(prepared_G_e, weight)
+            if multiplicative:
+                threshold = e_weight * G_e_total_tree_weight / G_total_tree_weight
+            else:
+                numerator = (
+                    st_cached_value + e_weight
+                ) * nx.total_spanning_tree_weight(prepared_G_e) + G_e_total_tree_weight
+                denominator = (
+                    st_cached_value * nx.total_spanning_tree_weight(prepared_G)
+                    + G_total_tree_weight
+                )
+                threshold = numerator / denominator
+        else:
+            threshold = 0.0
+        z = seed.uniform(0.0, 1.0)
+        if z > threshold:
+            # Remove the edge from V since we did not pick it.
+            V.remove((u, v))
+        else:
+            # Add the edge to U since we picked it.
+            st_cached_value += e_weight
+            U.add((u, v))
+        # If we decide to keep an edge, it may complete the spanning tree.
+        if len(U) == G.number_of_nodes() - 1:
+            spanning_tree = nx.Graph()
+            spanning_tree.add_edges_from(U)
+            return spanning_tree
+    raise Exception(f"Something went wrong! Only {len(U)} edges in the spanning tree!")
+
+
+class SpanningTreeIterator:
+    """
+    Iterate over all spanning trees of a graph in either increasing or
+    decreasing cost.
+
+    Notes
+    -----
+    This iterator uses the partition scheme from [1]_ (included edges,
+    excluded edges and open edges) as well as a modified Kruskal's Algorithm
+    to generate minimum spanning trees which respect the partition of edges.
+    For spanning trees with the same weight, ties are broken arbitrarily.
+
+    References
+    ----------
+    .. [1] G.K. Janssens, K. Sörensen, An algorithm to generate all spanning
+           trees in order of increasing cost, Pesquisa Operacional, 2005-08,
+           Vol. 25 (2), p. 219-229,
+           https://www.scielo.br/j/pope/a/XHswBwRwJyrfL88dmMwYNWp/?lang=en
+    """
+
+    @dataclass(order=True)
+    class Partition:
+        """
+        This dataclass represents a partition and stores a dict with the edge
+        data and the weight of the minimum spanning tree of the partition dict.
+        """
+
+        mst_weight: float
+        partition_dict: dict = field(compare=False)
+
+        def __copy__(self):
+            return SpanningTreeIterator.Partition(
+                self.mst_weight, self.partition_dict.copy()
+            )
+
+    def __init__(self, G, weight="weight", minimum=True, ignore_nan=False):
+        """
+        Initialize the iterator
+
+        Parameters
+        ----------
+        G : nx.Graph
+            The directed graph which we need to iterate trees over
+
+        weight : String, default = "weight"
+            The edge attribute used to store the weight of the edge
+
+        minimum : bool, default = True
+            Return the trees in increasing order while true and decreasing order
+            while false.
+
+        ignore_nan : bool, default = False
+            If a NaN is found as an edge weight normally an exception is raised.
+            If `ignore_nan is True` then that edge is ignored instead.
+        """
+        self.G = G.copy()
+        self.weight = weight
+        self.minimum = minimum
+        self.ignore_nan = ignore_nan
+        # Randomly create a key for an edge attribute to hold the partition data
+        self.partition_key = (
+            "SpanningTreeIterators super secret partition attribute name"
+        )
+
+    def __iter__(self):
+        """
+        Returns
+        -------
+        SpanningTreeIterator
+            The iterator object for this graph
+        """
+        self.partition_queue = PriorityQueue()
+        self._clear_partition(self.G)
+        mst_weight = partition_spanning_tree(
+            self.G, self.minimum, self.weight, self.partition_key, self.ignore_nan
+        ).size(weight=self.weight)
+
+        self.partition_queue.put(
+            self.Partition(mst_weight if self.minimum else -mst_weight, dict())
+        )
+
+        return self
+
+    def __next__(self):
+        """
+        Returns
+        -------
+        (multi)Graph
+            The spanning tree of next greatest weight, which ties broken
+            arbitrarily.
+        """
+        if self.partition_queue.empty():
+            del self.G, self.partition_queue
+            raise StopIteration
+
+        partition = self.partition_queue.get()
+        self._write_partition(partition)
+        next_tree = partition_spanning_tree(
+            self.G, self.minimum, self.weight, self.partition_key, self.ignore_nan
+        )
+        self._partition(partition, next_tree)
+
+        self._clear_partition(next_tree)
+        return next_tree
+
+    def _partition(self, partition, partition_tree):
+        """
+        Create new partitions based of the minimum spanning tree of the
+        current minimum partition.
+
+        Parameters
+        ----------
+        partition : Partition
+            The Partition instance used to generate the current minimum spanning
+            tree.
+        partition_tree : nx.Graph
+            The minimum spanning tree of the input partition.
+        """
+        # create two new partitions with the data from the input partition dict
+        p1 = self.Partition(0, partition.partition_dict.copy())
+        p2 = self.Partition(0, partition.partition_dict.copy())
+        for e in partition_tree.edges:
+            # determine if the edge was open or included
+            if e not in partition.partition_dict:
+                # This is an open edge
+                p1.partition_dict[e] = EdgePartition.EXCLUDED
+                p2.partition_dict[e] = EdgePartition.INCLUDED
+
+                self._write_partition(p1)
+                p1_mst = partition_spanning_tree(
+                    self.G,
+                    self.minimum,
+                    self.weight,
+                    self.partition_key,
+                    self.ignore_nan,
+                )
+                p1_mst_weight = p1_mst.size(weight=self.weight)
+                if nx.is_connected(p1_mst):
+                    p1.mst_weight = p1_mst_weight if self.minimum else -p1_mst_weight
+                    self.partition_queue.put(p1.__copy__())
+                p1.partition_dict = p2.partition_dict.copy()
+
+    def _write_partition(self, partition):
+        """
+        Writes the desired partition into the graph to calculate the minimum
+        spanning tree.
+
+        Parameters
+        ----------
+        partition : Partition
+            A Partition dataclass describing a partition on the edges of the
+            graph.
+        """
+        for u, v, d in self.G.edges(data=True):
+            if (u, v) in partition.partition_dict:
+                d[self.partition_key] = partition.partition_dict[(u, v)]
+            else:
+                d[self.partition_key] = EdgePartition.OPEN
+
+    def _clear_partition(self, G):
+        """
+        Removes partition data from the graph
+        """
+        for u, v, d in G.edges(data=True):
+            if self.partition_key in d:
+                del d[self.partition_key]
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/operations.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/operations.py
new file mode 100644
index 0000000..da3adda
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/operations.py
@@ -0,0 +1,106 @@
+"""Operations on trees."""
+from functools import partial
+from itertools import accumulate, chain
+
+import networkx as nx
+
+__all__ = ["join"]
+
+
+def join(rooted_trees, label_attribute=None):
+    """Returns a new rooted tree with a root node joined with the roots
+    of each of the given rooted trees.
+
+    Parameters
+    ----------
+    rooted_trees : list
+        A list of pairs in which each left element is a NetworkX graph
+        object representing a tree and each right element is the root
+        node of that tree. The nodes of these trees will be relabeled to
+        integers.
+
+    label_attribute : str
+        If provided, the old node labels will be stored in the new tree
+        under this node attribute. If not provided, the node attribute
+        ``'_old'`` will store the original label of the node in the
+        rooted trees given in the input.
+
+    Returns
+    -------
+    NetworkX graph
+        The rooted tree whose subtrees are the given rooted trees. The
+        new root node is labeled 0. Each non-root node has an attribute,
+        as described under the keyword argument ``label_attribute``,
+        that indicates the label of the original node in the input tree.
+
+    Notes
+    -----
+    Graph, edge, and node attributes are propagated from the given
+    rooted trees to the created tree. If there are any overlapping graph
+    attributes, those from later trees will overwrite those from earlier
+    trees in the tuple of positional arguments.
+
+    Examples
+    --------
+    Join two full balanced binary trees of height *h* to get a full
+    balanced binary tree of depth *h* + 1::
+
+        >>> h = 4
+        >>> left = nx.balanced_tree(2, h)
+        >>> right = nx.balanced_tree(2, h)
+        >>> joined_tree = nx.join([(left, 0), (right, 0)])
+        >>> nx.is_isomorphic(joined_tree, nx.balanced_tree(2, h + 1))
+        True
+
+    """
+    if len(rooted_trees) == 0:
+        return nx.empty_graph(1)
+
+    # Unzip the zipped list of (tree, root) pairs.
+    trees, roots = zip(*rooted_trees)
+
+    # The join of the trees has the same type as the type of the first
+    # tree.
+    R = type(trees[0])()
+
+    # Relabel the nodes so that their union is the integers starting at 1.
+    if label_attribute is None:
+        label_attribute = "_old"
+    relabel = partial(
+        nx.convert_node_labels_to_integers, label_attribute=label_attribute
+    )
+    lengths = (len(tree) for tree in trees[:-1])
+    first_labels = chain([0], accumulate(lengths))
+    trees = [
+        relabel(tree, first_label=first_label + 1)
+        for tree, first_label in zip(trees, first_labels)
+    ]
+
+    # Get the relabeled roots.
+    roots = [
+        next(v for v, d in tree.nodes(data=True) if d.get("_old") == root)
+        for tree, root in zip(trees, roots)
+    ]
+
+    # Remove the old node labels.
+    for tree in trees:
+        for v in tree:
+            tree.nodes[v].pop("_old")
+
+    # Add all sets of nodes and edges, with data.
+    nodes = (tree.nodes(data=True) for tree in trees)
+    edges = (tree.edges(data=True) for tree in trees)
+    R.add_nodes_from(chain.from_iterable(nodes))
+    R.add_edges_from(chain.from_iterable(edges))
+
+    # Add graph attributes; later attributes take precedent over earlier
+    # attributes.
+    for tree in trees:
+        R.graph.update(tree.graph)
+
+    # Finally, join the subtrees at the root. We know 0 is unused by the
+    # way we relabeled the subtrees.
+    R.add_node(0)
+    R.add_edges_from((0, root) for root in roots)
+
+    return R
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/recognition.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/recognition.py
new file mode 100644
index 0000000..8fdeb76
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/recognition.py
@@ -0,0 +1,269 @@
+"""
+Recognition Tests
+=================
+
+A *forest* is an acyclic, undirected graph, and a *tree* is a connected forest.
+Depending on the subfield, there are various conventions for generalizing these
+definitions to directed graphs.
+
+In one convention, directed variants of forest and tree are defined in an
+identical manner, except that the direction of the edges is ignored. In effect,
+each directed edge is treated as a single undirected edge. Then, additional
+restrictions are imposed to define *branchings* and *arborescences*.
+
+In another convention, directed variants of forest and tree correspond to
+the previous convention's branchings and arborescences, respectively. Then two
+new terms, *polyforest* and *polytree*, are defined to correspond to the other
+convention's forest and tree.
+
+Summarizing::
+
+   +-----------------------------+
+   | Convention A | Convention B |
+   +=============================+
+   | forest       | polyforest   |
+   | tree         | polytree     |
+   | branching    | forest       |
+   | arborescence | tree         |
+   +-----------------------------+
+
+Each convention has its reasons. The first convention emphasizes definitional
+similarity in that directed forests and trees are only concerned with
+acyclicity and do not have an in-degree constraint, just as their undirected
+counterparts do not. The second convention emphasizes functional similarity
+in the sense that the directed analog of a spanning tree is a spanning
+arborescence. That is, take any spanning tree and choose one node as the root.
+Then every edge is assigned a direction such there is a directed path from the
+root to every other node. The result is a spanning arborescence.
+
+NetworkX follows convention "A". Explicitly, these are:
+
+undirected forest
+   An undirected graph with no undirected cycles.
+
+undirected tree
+   A connected, undirected forest.
+
+directed forest
+   A directed graph with no undirected cycles. Equivalently, the underlying
+   graph structure (which ignores edge orientations) is an undirected forest.
+   In convention B, this is known as a polyforest.
+
+directed tree
+   A weakly connected, directed forest. Equivalently, the underlying graph
+   structure (which ignores edge orientations) is an undirected tree. In
+   convention B, this is known as a polytree.
+
+branching
+   A directed forest with each node having, at most, one parent. So the maximum
+   in-degree is equal to 1. In convention B, this is known as a forest.
+
+arborescence
+   A directed tree with each node having, at most, one parent. So the maximum
+   in-degree is equal to 1. In convention B, this is known as a tree.
+
+For trees and arborescences, the adjective "spanning" may be added to designate
+that the graph, when considered as a forest/branching, consists of a single
+tree/arborescence that includes all nodes in the graph. It is true, by
+definition, that every tree/arborescence is spanning with respect to the nodes
+that define the tree/arborescence and so, it might seem redundant to introduce
+the notion of "spanning". However, the nodes may represent a subset of
+nodes from a larger graph, and it is in this context that the term "spanning"
+becomes a useful notion.
+
+"""
+
+import networkx as nx
+
+__all__ = ["is_arborescence", "is_branching", "is_forest", "is_tree"]
+
+
+@nx.utils.not_implemented_for("undirected")
+def is_arborescence(G):
+    """
+    Returns True if `G` is an arborescence.
+
+    An arborescence is a directed tree with maximum in-degree equal to 1.
+
+    Parameters
+    ----------
+    G : graph
+        The graph to test.
+
+    Returns
+    -------
+    b : bool
+        A boolean that is True if `G` is an arborescence.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph([(0, 1), (0, 2), (2, 3), (3, 4)])
+    >>> nx.is_arborescence(G)
+    True
+    >>> G.remove_edge(0, 1)
+    >>> G.add_edge(1, 2)  # maximum in-degree is 2
+    >>> nx.is_arborescence(G)
+    False
+
+    Notes
+    -----
+    In another convention, an arborescence is known as a *tree*.
+
+    See Also
+    --------
+    is_tree
+
+    """
+    return is_tree(G) and max(d for n, d in G.in_degree()) <= 1
+
+
+@nx.utils.not_implemented_for("undirected")
+def is_branching(G):
+    """
+    Returns True if `G` is a branching.
+
+    A branching is a directed forest with maximum in-degree equal to 1.
+
+    Parameters
+    ----------
+    G : directed graph
+        The directed graph to test.
+
+    Returns
+    -------
+    b : bool
+        A boolean that is True if `G` is a branching.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 4)])
+    >>> nx.is_branching(G)
+    True
+    >>> G.remove_edge(2, 3)
+    >>> G.add_edge(3, 1)  # maximum in-degree is 2
+    >>> nx.is_branching(G)
+    False
+
+    Notes
+    -----
+    In another convention, a branching is also known as a *forest*.
+
+    See Also
+    --------
+    is_forest
+
+    """
+    return is_forest(G) and max(d for n, d in G.in_degree()) <= 1
+
+
+def is_forest(G):
+    """
+    Returns True if `G` is a forest.
+
+    A forest is a graph with no undirected cycles.
+
+    For directed graphs, `G` is a forest if the underlying graph is a forest.
+    The underlying graph is obtained by treating each directed edge as a single
+    undirected edge in a multigraph.
+
+    Parameters
+    ----------
+    G : graph
+        The graph to test.
+
+    Returns
+    -------
+    b : bool
+        A boolean that is True if `G` is a forest.
+
+    Raises
+    ------
+    NetworkXPointlessConcept
+        If `G` is empty.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_edges_from([(1, 2), (1, 3), (2, 4), (2, 5)])
+    >>> nx.is_forest(G)
+    True
+    >>> G.add_edge(4, 1)
+    >>> nx.is_forest(G)
+    False
+
+    Notes
+    -----
+    In another convention, a directed forest is known as a *polyforest* and
+    then *forest* corresponds to a *branching*.
+
+    See Also
+    --------
+    is_branching
+
+    """
+    if len(G) == 0:
+        raise nx.exception.NetworkXPointlessConcept("G has no nodes.")
+
+    if G.is_directed():
+        components = (G.subgraph(c) for c in nx.weakly_connected_components(G))
+    else:
+        components = (G.subgraph(c) for c in nx.connected_components(G))
+
+    return all(len(c) - 1 == c.number_of_edges() for c in components)
+
+
+def is_tree(G):
+    """
+    Returns True if `G` is a tree.
+
+    A tree is a connected graph with no undirected cycles.
+
+    For directed graphs, `G` is a tree if the underlying graph is a tree. The
+    underlying graph is obtained by treating each directed edge as a single
+    undirected edge in a multigraph.
+
+    Parameters
+    ----------
+    G : graph
+        The graph to test.
+
+    Returns
+    -------
+    b : bool
+        A boolean that is True if `G` is a tree.
+
+    Raises
+    ------
+    NetworkXPointlessConcept
+        If `G` is empty.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_edges_from([(1, 2), (1, 3), (2, 4), (2, 5)])
+    >>> nx.is_tree(G)  # n-1 edges
+    True
+    >>> G.add_edge(3, 4)
+    >>> nx.is_tree(G)  # n edges
+    False
+
+    Notes
+    -----
+    In another convention, a directed tree is known as a *polytree* and then
+    *tree* corresponds to an *arborescence*.
+
+    See Also
+    --------
+    is_arborescence
+
+    """
+    if len(G) == 0:
+        raise nx.exception.NetworkXPointlessConcept("G has no nodes.")
+
+    if G.is_directed():
+        is_connected = nx.is_weakly_connected
+    else:
+        is_connected = nx.is_connected
+
+    # A connected graph with no cycles has n-1 edges.
+    return len(G) - 1 == G.number_of_edges() and is_connected(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_branchings.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_branchings.py
new file mode 100644
index 0000000..3417446
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_branchings.py
@@ -0,0 +1,556 @@
+import math
+
+import pytest
+
+np = pytest.importorskip("numpy")
+
+import networkx as nx
+from networkx.algorithms.tree import branchings, recognition
+
+#
+# Explicitly discussed examples from Edmonds paper.
+#
+
+# Used in Figures A-F.
+#
+# fmt: off
+G_array = np.array([
+    # 0   1   2   3   4   5   6   7   8
+    [0, 0, 12, 0, 12, 0, 0, 0, 0],  # 0
+    [4, 0, 0, 0, 0, 13, 0, 0, 0],  # 1
+    [0, 17, 0, 21, 0, 12, 0, 0, 0],  # 2
+    [5, 0, 0, 0, 17, 0, 18, 0, 0],  # 3
+    [0, 0, 0, 0, 0, 0, 0, 12, 0],  # 4
+    [0, 0, 0, 0, 0, 0, 14, 0, 12],  # 5
+    [0, 0, 21, 0, 0, 0, 0, 0, 15],  # 6
+    [0, 0, 0, 19, 0, 0, 15, 0, 0],  # 7
+    [0, 0, 0, 0, 0, 0, 0, 18, 0],  # 8
+], dtype=int)
+
+
+# fmt: on
+
+
+def G1():
+    G = nx.from_numpy_array(G_array, create_using=nx.MultiDiGraph)
+    return G
+
+
+def G2():
+    # Now we shift all the weights by -10.
+    # Should not affect optimal arborescence, but does affect optimal branching.
+    Garr = G_array.copy()
+    Garr[np.nonzero(Garr)] -= 10
+    G = nx.from_numpy_array(Garr, create_using=nx.MultiDiGraph)
+    return G
+
+
+# An optimal branching for G1 that is also a spanning arborescence. So it is
+# also an optimal spanning arborescence.
+#
+optimal_arborescence_1 = [
+    (0, 2, 12),
+    (2, 1, 17),
+    (2, 3, 21),
+    (1, 5, 13),
+    (3, 4, 17),
+    (3, 6, 18),
+    (6, 8, 15),
+    (8, 7, 18),
+]
+
+# For G2, the optimal branching of G1 (with shifted weights) is no longer
+# an optimal branching, but it is still an optimal spanning arborescence
+# (just with shifted weights). An optimal branching for G2 is similar to what
+# appears in figure G (this is greedy_subopt_branching_1a below), but with the
+# edge (3, 0, 5), which is now (3, 0, -5), removed. Thus, the optimal branching
+# is not a spanning arborescence. The code finds optimal_branching_2a.
+# An alternative and equivalent branching is optimal_branching_2b. We would
+# need to modify the code to iterate through all equivalent optimal branchings.
+#
+# These are maximal branchings or arborescences.
+optimal_branching_2a = [
+    (5, 6, 4),
+    (6, 2, 11),
+    (6, 8, 5),
+    (8, 7, 8),
+    (2, 1, 7),
+    (2, 3, 11),
+    (3, 4, 7),
+]
+optimal_branching_2b = [
+    (8, 7, 8),
+    (7, 3, 9),
+    (3, 4, 7),
+    (3, 6, 8),
+    (6, 2, 11),
+    (2, 1, 7),
+    (1, 5, 3),
+]
+optimal_arborescence_2 = [
+    (0, 2, 2),
+    (2, 1, 7),
+    (2, 3, 11),
+    (1, 5, 3),
+    (3, 4, 7),
+    (3, 6, 8),
+    (6, 8, 5),
+    (8, 7, 8),
+]
+
+# Two suboptimal maximal branchings on G1 obtained from a greedy algorithm.
+# 1a matches what is shown in Figure G in Edmonds's paper.
+greedy_subopt_branching_1a = [
+    (5, 6, 14),
+    (6, 2, 21),
+    (6, 8, 15),
+    (8, 7, 18),
+    (2, 1, 17),
+    (2, 3, 21),
+    (3, 0, 5),
+    (3, 4, 17),
+]
+greedy_subopt_branching_1b = [
+    (8, 7, 18),
+    (7, 6, 15),
+    (6, 2, 21),
+    (2, 1, 17),
+    (2, 3, 21),
+    (1, 5, 13),
+    (3, 0, 5),
+    (3, 4, 17),
+]
+
+
+def build_branching(edges):
+    G = nx.DiGraph()
+    for u, v, weight in edges:
+        G.add_edge(u, v, weight=weight)
+    return G
+
+
+def sorted_edges(G, attr="weight", default=1):
+    edges = [(u, v, data.get(attr, default)) for (u, v, data) in G.edges(data=True)]
+    edges = sorted(edges, key=lambda x: (x[2], x[1], x[0]))
+    return edges
+
+
+def assert_equal_branchings(G1, G2, attr="weight", default=1):
+    edges1 = list(G1.edges(data=True))
+    edges2 = list(G2.edges(data=True))
+    assert len(edges1) == len(edges2)
+
+    # Grab the weights only.
+    e1 = sorted_edges(G1, attr, default)
+    e2 = sorted_edges(G2, attr, default)
+
+    for a, b in zip(e1, e2):
+        assert a[:2] == b[:2]
+        np.testing.assert_almost_equal(a[2], b[2])
+
+
+################
+
+
+def test_optimal_branching1():
+    G = build_branching(optimal_arborescence_1)
+    assert recognition.is_arborescence(G), True
+    assert branchings.branching_weight(G) == 131
+
+
+def test_optimal_branching2a():
+    G = build_branching(optimal_branching_2a)
+    assert recognition.is_arborescence(G), True
+    assert branchings.branching_weight(G) == 53
+
+
+def test_optimal_branching2b():
+    G = build_branching(optimal_branching_2b)
+    assert recognition.is_arborescence(G), True
+    assert branchings.branching_weight(G) == 53
+
+
+def test_optimal_arborescence2():
+    G = build_branching(optimal_arborescence_2)
+    assert recognition.is_arborescence(G), True
+    assert branchings.branching_weight(G) == 51
+
+
+def test_greedy_suboptimal_branching1a():
+    G = build_branching(greedy_subopt_branching_1a)
+    assert recognition.is_arborescence(G), True
+    assert branchings.branching_weight(G) == 128
+
+
+def test_greedy_suboptimal_branching1b():
+    G = build_branching(greedy_subopt_branching_1b)
+    assert recognition.is_arborescence(G), True
+    assert branchings.branching_weight(G) == 127
+
+
+def test_greedy_max1():
+    # Standard test.
+    #
+    G = G1()
+    B = branchings.greedy_branching(G)
+    # There are only two possible greedy branchings. The sorting is such
+    # that it should equal the second suboptimal branching: 1b.
+    B_ = build_branching(greedy_subopt_branching_1b)
+    assert_equal_branchings(B, B_)
+
+
+def test_greedy_max2():
+    # Different default weight.
+    #
+    G = G1()
+    del G[1][0][0]["weight"]
+    B = branchings.greedy_branching(G, default=6)
+    # Chosen so that edge (3,0,5) is not selected and (1,0,6) is instead.
+
+    edges = [
+        (1, 0, 6),
+        (1, 5, 13),
+        (7, 6, 15),
+        (2, 1, 17),
+        (3, 4, 17),
+        (8, 7, 18),
+        (2, 3, 21),
+        (6, 2, 21),
+    ]
+    B_ = build_branching(edges)
+    assert_equal_branchings(B, B_)
+
+
+def test_greedy_max3():
+    # All equal weights.
+    #
+    G = G1()
+    B = branchings.greedy_branching(G, attr=None)
+
+    # This is mostly arbitrary...the output was generated by running the algo.
+    edges = [
+        (2, 1, 1),
+        (3, 0, 1),
+        (3, 4, 1),
+        (5, 8, 1),
+        (6, 2, 1),
+        (7, 3, 1),
+        (7, 6, 1),
+        (8, 7, 1),
+    ]
+    B_ = build_branching(edges)
+    assert_equal_branchings(B, B_, default=1)
+
+
+def test_greedy_min():
+    G = G1()
+    B = branchings.greedy_branching(G, kind="min")
+
+    edges = [
+        (1, 0, 4),
+        (0, 2, 12),
+        (0, 4, 12),
+        (2, 5, 12),
+        (4, 7, 12),
+        (5, 8, 12),
+        (5, 6, 14),
+        (7, 3, 19),
+    ]
+    B_ = build_branching(edges)
+    assert_equal_branchings(B, B_)
+
+
+def test_edmonds1_maxbranch():
+    G = G1()
+    x = branchings.maximum_branching(G)
+    x_ = build_branching(optimal_arborescence_1)
+    assert_equal_branchings(x, x_)
+
+
+def test_edmonds1_maxarbor():
+    G = G1()
+    x = branchings.maximum_spanning_arborescence(G)
+    x_ = build_branching(optimal_arborescence_1)
+    assert_equal_branchings(x, x_)
+
+
+def test_edmonds2_maxbranch():
+    G = G2()
+    x = branchings.maximum_branching(G)
+    x_ = build_branching(optimal_branching_2a)
+    assert_equal_branchings(x, x_)
+
+
+def test_edmonds2_maxarbor():
+    G = G2()
+    x = branchings.maximum_spanning_arborescence(G)
+    x_ = build_branching(optimal_arborescence_2)
+    assert_equal_branchings(x, x_)
+
+
+def test_edmonds2_minarbor():
+    G = G1()
+    x = branchings.minimum_spanning_arborescence(G)
+    # This was obtained from algorithm. Need to verify it independently.
+    # Branch weight is: 96
+    edges = [
+        (3, 0, 5),
+        (0, 2, 12),
+        (0, 4, 12),
+        (2, 5, 12),
+        (4, 7, 12),
+        (5, 8, 12),
+        (5, 6, 14),
+        (2, 1, 17),
+    ]
+    x_ = build_branching(edges)
+    assert_equal_branchings(x, x_)
+
+
+def test_edmonds3_minbranch1():
+    G = G1()
+    x = branchings.minimum_branching(G)
+    edges = []
+    x_ = build_branching(edges)
+    assert_equal_branchings(x, x_)
+
+
+def test_edmonds3_minbranch2():
+    G = G1()
+    G.add_edge(8, 9, weight=-10)
+    x = branchings.minimum_branching(G)
+    edges = [(8, 9, -10)]
+    x_ = build_branching(edges)
+    assert_equal_branchings(x, x_)
+
+
+# Need more tests
+
+
+def test_mst():
+    # Make sure we get the same results for undirected graphs.
+    # Example from: https://en.wikipedia.org/wiki/Kruskal's_algorithm
+    G = nx.Graph()
+    edgelist = [
+        (0, 3, [("weight", 5)]),
+        (0, 1, [("weight", 7)]),
+        (1, 3, [("weight", 9)]),
+        (1, 2, [("weight", 8)]),
+        (1, 4, [("weight", 7)]),
+        (3, 4, [("weight", 15)]),
+        (3, 5, [("weight", 6)]),
+        (2, 4, [("weight", 5)]),
+        (4, 5, [("weight", 8)]),
+        (4, 6, [("weight", 9)]),
+        (5, 6, [("weight", 11)]),
+    ]
+    G.add_edges_from(edgelist)
+    G = G.to_directed()
+    x = branchings.minimum_spanning_arborescence(G)
+
+    edges = [
+        ({0, 1}, 7),
+        ({0, 3}, 5),
+        ({3, 5}, 6),
+        ({1, 4}, 7),
+        ({4, 2}, 5),
+        ({4, 6}, 9),
+    ]
+
+    assert x.number_of_edges() == len(edges)
+    for u, v, d in x.edges(data=True):
+        assert ({u, v}, d["weight"]) in edges
+
+
+def test_mixed_nodetypes():
+    # Smoke test to make sure no TypeError is raised for mixed node types.
+    G = nx.Graph()
+    edgelist = [(0, 3, [("weight", 5)]), (0, "1", [("weight", 5)])]
+    G.add_edges_from(edgelist)
+    G = G.to_directed()
+    x = branchings.minimum_spanning_arborescence(G)
+
+
+def test_edmonds1_minbranch():
+    # Using -G_array and min should give the same as optimal_arborescence_1,
+    # but with all edges negative.
+    edges = [(u, v, -w) for (u, v, w) in optimal_arborescence_1]
+
+    G = nx.from_numpy_array(-G_array, create_using=nx.DiGraph)
+
+    # Quickly make sure max branching is empty.
+    x = branchings.maximum_branching(G)
+    x_ = build_branching([])
+    assert_equal_branchings(x, x_)
+
+    # Now test the min branching.
+    x = branchings.minimum_branching(G)
+    x_ = build_branching(edges)
+    assert_equal_branchings(x, x_)
+
+
+def test_edge_attribute_preservation_normal_graph():
+    # Test that edge attributes are preserved when finding an optimum graph
+    # using the Edmonds class for normal graphs.
+    G = nx.Graph()
+
+    edgelist = [
+        (0, 1, [("weight", 5), ("otherattr", 1), ("otherattr2", 3)]),
+        (0, 2, [("weight", 5), ("otherattr", 2), ("otherattr2", 2)]),
+        (1, 2, [("weight", 6), ("otherattr", 3), ("otherattr2", 1)]),
+    ]
+    G.add_edges_from(edgelist)
+
+    ed = branchings.Edmonds(G)
+    B = ed.find_optimum("weight", preserve_attrs=True, seed=1)
+
+    assert B[0][1]["otherattr"] == 1
+    assert B[0][1]["otherattr2"] == 3
+
+
+def test_edge_attribute_preservation_multigraph():
+    # Test that edge attributes are preserved when finding an optimum graph
+    # using the Edmonds class for multigraphs.
+    G = nx.MultiGraph()
+
+    edgelist = [
+        (0, 1, [("weight", 5), ("otherattr", 1), ("otherattr2", 3)]),
+        (0, 2, [("weight", 5), ("otherattr", 2), ("otherattr2", 2)]),
+        (1, 2, [("weight", 6), ("otherattr", 3), ("otherattr2", 1)]),
+    ]
+    G.add_edges_from(edgelist * 2)  # Make sure we have duplicate edge paths
+
+    ed = branchings.Edmonds(G)
+    B = ed.find_optimum("weight", preserve_attrs=True)
+
+    assert B[0][1][0]["otherattr"] == 1
+    assert B[0][1][0]["otherattr2"] == 3
+
+
+def test_edge_attribute_discard():
+    # Test that edge attributes are discarded if we do not specify to keep them
+    G = nx.Graph()
+
+    edgelist = [
+        (0, 1, [("weight", 5), ("otherattr", 1), ("otherattr2", 3)]),
+        (0, 2, [("weight", 5), ("otherattr", 2), ("otherattr2", 2)]),
+        (1, 2, [("weight", 6), ("otherattr", 3), ("otherattr2", 1)]),
+    ]
+    G.add_edges_from(edgelist)
+
+    ed = branchings.Edmonds(G)
+    B = ed.find_optimum("weight", preserve_attrs=False)
+
+    edge_dict = B[0][1]
+    with pytest.raises(KeyError):
+        _ = edge_dict["otherattr"]
+
+
+def test_partition_spanning_arborescence():
+    """
+    Test that we can generate minimum spanning arborescences which respect the
+    given partition.
+    """
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+    G[3][0]["partition"] = nx.EdgePartition.EXCLUDED
+    G[2][3]["partition"] = nx.EdgePartition.INCLUDED
+    G[7][3]["partition"] = nx.EdgePartition.EXCLUDED
+    G[0][2]["partition"] = nx.EdgePartition.EXCLUDED
+    G[6][2]["partition"] = nx.EdgePartition.INCLUDED
+
+    actual_edges = [
+        (0, 4, 12),
+        (1, 0, 4),
+        (1, 5, 13),
+        (2, 3, 21),
+        (4, 7, 12),
+        (5, 6, 14),
+        (5, 8, 12),
+        (6, 2, 21),
+    ]
+
+    B = branchings.minimum_spanning_arborescence(G, partition="partition")
+    assert_equal_branchings(build_branching(actual_edges), B)
+
+
+def test_arborescence_iterator_min():
+    """
+    Tests the arborescence iterator.
+
+    A brute force method found 680 arboresecences in this graph.
+    This test will not verify all of them individually, but will check two
+    things
+
+    * The iterator returns 680 arboresecences
+    * The weight of the arborescences is non-strictly increasing
+
+    for more information please visit
+    https://mjschwenne.github.io/2021/06/10/implementing-the-iterators.html
+    """
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+
+    arborescence_count = 0
+    arborescence_weight = -math.inf
+    for B in branchings.ArborescenceIterator(G):
+        arborescence_count += 1
+        new_arborescence_weight = B.size(weight="weight")
+        assert new_arborescence_weight >= arborescence_weight
+        arborescence_weight = new_arborescence_weight
+
+    assert arborescence_count == 680
+
+
+def test_arborescence_iterator_max():
+    """
+    Tests the arborescence iterator.
+
+    A brute force method found 680 arboresecences in this graph.
+    This test will not verify all of them individually, but will check two
+    things
+
+    * The iterator returns 680 arboresecences
+    * The weight of the arborescences is non-strictly decreasing
+
+    for more information please visit
+    https://mjschwenne.github.io/2021/06/10/implementing-the-iterators.html
+    """
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+
+    arborescence_count = 0
+    arborescence_weight = math.inf
+    for B in branchings.ArborescenceIterator(G, minimum=False):
+        arborescence_count += 1
+        new_arborescence_weight = B.size(weight="weight")
+        assert new_arborescence_weight <= arborescence_weight
+        arborescence_weight = new_arborescence_weight
+
+    assert arborescence_count == 680
+
+
+def test_arborescence_iterator_initial_partition():
+    """
+    Tests the arborescence iterator with three included edges and three excluded
+    in the initial partition.
+
+    A brute force method similar to the one used in the above tests found that
+    there are 16 arborescences which contain the included edges and not the
+    excluded edges.
+    """
+    G = nx.from_numpy_array(G_array, create_using=nx.DiGraph)
+    included_edges = [(1, 0), (5, 6), (8, 7)]
+    excluded_edges = [(0, 2), (3, 6), (1, 5)]
+
+    arborescence_count = 0
+    arborescence_weight = -math.inf
+    for B in branchings.ArborescenceIterator(
+        G, init_partition=(included_edges, excluded_edges)
+    ):
+        arborescence_count += 1
+        new_arborescence_weight = B.size(weight="weight")
+        assert new_arborescence_weight >= arborescence_weight
+        arborescence_weight = new_arborescence_weight
+        for e in included_edges:
+            assert e in B.edges
+        for e in excluded_edges:
+            assert e not in B.edges
+    assert arborescence_count == 16
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_coding.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_coding.py
new file mode 100644
index 0000000..c695fea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_coding.py
@@ -0,0 +1,113 @@
+"""Unit tests for the :mod:`~networkx.algorithms.tree.coding` module."""
+from itertools import product
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, nodes_equal
+
+
+class TestPruferSequence:
+    """Unit tests for the Prüfer sequence encoding and decoding
+    functions.
+
+    """
+
+    def test_nontree(self):
+        with pytest.raises(nx.NotATree):
+            G = nx.cycle_graph(3)
+            nx.to_prufer_sequence(G)
+
+    def test_null_graph(self):
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.to_prufer_sequence(nx.null_graph())
+
+    def test_trivial_graph(self):
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.to_prufer_sequence(nx.trivial_graph())
+
+    def test_bad_integer_labels(self):
+        with pytest.raises(KeyError):
+            T = nx.Graph(nx.utils.pairwise("abc"))
+            nx.to_prufer_sequence(T)
+
+    def test_encoding(self):
+        """Tests for encoding a tree as a Prüfer sequence using the
+        iterative strategy.
+
+        """
+        # Example from Wikipedia.
+        tree = nx.Graph([(0, 3), (1, 3), (2, 3), (3, 4), (4, 5)])
+        sequence = nx.to_prufer_sequence(tree)
+        assert sequence == [3, 3, 3, 4]
+
+    def test_decoding(self):
+        """Tests for decoding a tree from a Prüfer sequence."""
+        # Example from Wikipedia.
+        sequence = [3, 3, 3, 4]
+        tree = nx.from_prufer_sequence(sequence)
+        assert nodes_equal(list(tree), list(range(6)))
+        edges = [(0, 3), (1, 3), (2, 3), (3, 4), (4, 5)]
+        assert edges_equal(list(tree.edges()), edges)
+
+    def test_decoding2(self):
+        # Example from "An Optimal Algorithm for Prufer Codes".
+        sequence = [2, 4, 0, 1, 3, 3]
+        tree = nx.from_prufer_sequence(sequence)
+        assert nodes_equal(list(tree), list(range(8)))
+        edges = [(0, 1), (0, 4), (1, 3), (2, 4), (2, 5), (3, 6), (3, 7)]
+        assert edges_equal(list(tree.edges()), edges)
+
+    def test_inverse(self):
+        """Tests that the encoding and decoding functions are inverses."""
+        for T in nx.nonisomorphic_trees(4):
+            T2 = nx.from_prufer_sequence(nx.to_prufer_sequence(T))
+            assert nodes_equal(list(T), list(T2))
+            assert edges_equal(list(T.edges()), list(T2.edges()))
+
+        for seq in product(range(4), repeat=2):
+            seq2 = nx.to_prufer_sequence(nx.from_prufer_sequence(seq))
+            assert list(seq) == seq2
+
+
+class TestNestedTuple:
+    """Unit tests for the nested tuple encoding and decoding functions."""
+
+    def test_nontree(self):
+        with pytest.raises(nx.NotATree):
+            G = nx.cycle_graph(3)
+            nx.to_nested_tuple(G, 0)
+
+    def test_unknown_root(self):
+        with pytest.raises(nx.NodeNotFound):
+            G = nx.path_graph(2)
+            nx.to_nested_tuple(G, "bogus")
+
+    def test_encoding(self):
+        T = nx.full_rary_tree(2, 2**3 - 1)
+        expected = (((), ()), ((), ()))
+        actual = nx.to_nested_tuple(T, 0)
+        assert nodes_equal(expected, actual)
+
+    def test_canonical_form(self):
+        T = nx.Graph()
+        T.add_edges_from([(0, 1), (0, 2), (0, 3)])
+        T.add_edges_from([(1, 4), (1, 5)])
+        T.add_edges_from([(3, 6), (3, 7)])
+        root = 0
+        actual = nx.to_nested_tuple(T, root, canonical_form=True)
+        expected = ((), ((), ()), ((), ()))
+        assert actual == expected
+
+    def test_decoding(self):
+        balanced = (((), ()), ((), ()))
+        expected = nx.full_rary_tree(2, 2**3 - 1)
+        actual = nx.from_nested_tuple(balanced)
+        assert nx.is_isomorphic(expected, actual)
+
+    def test_sensible_relabeling(self):
+        balanced = (((), ()), ((), ()))
+        T = nx.from_nested_tuple(balanced, sensible_relabeling=True)
+        edges = [(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6)]
+        assert nodes_equal(list(T), list(range(2**3 - 1)))
+        assert edges_equal(list(T.edges()), edges)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_decomposition.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_decomposition.py
new file mode 100644
index 0000000..8c37605
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_decomposition.py
@@ -0,0 +1,79 @@
+import networkx as nx
+from networkx.algorithms.tree.decomposition import junction_tree
+
+
+def test_junction_tree_directed_confounders():
+    B = nx.DiGraph()
+    B.add_edges_from([("A", "C"), ("B", "C"), ("C", "D"), ("C", "E")])
+
+    G = junction_tree(B)
+    J = nx.Graph()
+    J.add_edges_from(
+        [
+            (("C", "E"), ("C",)),
+            (("C",), ("A", "B", "C")),
+            (("A", "B", "C"), ("C",)),
+            (("C",), ("C", "D")),
+        ]
+    )
+
+    assert nx.is_isomorphic(G, J)
+
+
+def test_junction_tree_directed_unconnected_nodes():
+    B = nx.DiGraph()
+    B.add_nodes_from([("A", "B", "C", "D")])
+    G = junction_tree(B)
+
+    J = nx.Graph()
+    J.add_nodes_from([("A", "B", "C", "D")])
+
+    assert nx.is_isomorphic(G, J)
+
+
+def test_junction_tree_directed_cascade():
+    B = nx.DiGraph()
+    B.add_edges_from([("A", "B"), ("B", "C"), ("C", "D")])
+    G = junction_tree(B)
+
+    J = nx.Graph()
+    J.add_edges_from(
+        [
+            (("A", "B"), ("B",)),
+            (("B",), ("B", "C")),
+            (("B", "C"), ("C",)),
+            (("C",), ("C", "D")),
+        ]
+    )
+    assert nx.is_isomorphic(G, J)
+
+
+def test_junction_tree_directed_unconnected_edges():
+    B = nx.DiGraph()
+    B.add_edges_from([("A", "B"), ("C", "D"), ("E", "F")])
+    G = junction_tree(B)
+
+    J = nx.Graph()
+    J.add_nodes_from([("A", "B"), ("C", "D"), ("E", "F")])
+
+    assert nx.is_isomorphic(G, J)
+
+
+def test_junction_tree_undirected():
+    B = nx.Graph()
+    B.add_edges_from([("A", "C"), ("A", "D"), ("B", "C"), ("C", "E")])
+    G = junction_tree(B)
+
+    J = nx.Graph()
+    J.add_edges_from(
+        [
+            (("A", "D"), ("A",)),
+            (("A",), ("A", "C")),
+            (("A", "C"), ("C",)),
+            (("C",), ("B", "C")),
+            (("B", "C"), ("C",)),
+            (("C",), ("C", "E")),
+        ]
+    )
+
+    assert nx.is_isomorphic(G, J)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_mst.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_mst.py
new file mode 100644
index 0000000..7daf0fc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_mst.py
@@ -0,0 +1,622 @@
+"""Unit tests for the :mod:`networkx.algorithms.tree.mst` module."""
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, nodes_equal
+
+
+def test_unknown_algorithm():
+    with pytest.raises(ValueError):
+        nx.minimum_spanning_tree(nx.Graph(), algorithm="random")
+
+
+class MinimumSpanningTreeTestBase:
+    """Base class for test classes for minimum spanning tree algorithms.
+    This class contains some common tests that will be inherited by
+    subclasses. Each subclass must have a class attribute
+    :data:`algorithm` that is a string representing the algorithm to
+    run, as described under the ``algorithm`` keyword argument for the
+    :func:`networkx.minimum_spanning_edges` function.  Subclasses can
+    then implement any algorithm-specific tests.
+    """
+
+    def setup_method(self, method):
+        """Creates an example graph and stores the expected minimum and
+        maximum spanning tree edges.
+        """
+        # This stores the class attribute `algorithm` in an instance attribute.
+        self.algo = self.algorithm
+        # This example graph comes from Wikipedia:
+        # https://en.wikipedia.org/wiki/Kruskal's_algorithm
+        edges = [
+            (0, 1, 7),
+            (0, 3, 5),
+            (1, 2, 8),
+            (1, 3, 9),
+            (1, 4, 7),
+            (2, 4, 5),
+            (3, 4, 15),
+            (3, 5, 6),
+            (4, 5, 8),
+            (4, 6, 9),
+            (5, 6, 11),
+        ]
+        self.G = nx.Graph()
+        self.G.add_weighted_edges_from(edges)
+        self.minimum_spanning_edgelist = [
+            (0, 1, {"weight": 7}),
+            (0, 3, {"weight": 5}),
+            (1, 4, {"weight": 7}),
+            (2, 4, {"weight": 5}),
+            (3, 5, {"weight": 6}),
+            (4, 6, {"weight": 9}),
+        ]
+        self.maximum_spanning_edgelist = [
+            (0, 1, {"weight": 7}),
+            (1, 2, {"weight": 8}),
+            (1, 3, {"weight": 9}),
+            (3, 4, {"weight": 15}),
+            (4, 6, {"weight": 9}),
+            (5, 6, {"weight": 11}),
+        ]
+
+    def test_minimum_edges(self):
+        edges = nx.minimum_spanning_edges(self.G, algorithm=self.algo)
+        # Edges from the spanning edges functions don't come in sorted
+        # orientation, so we need to sort each edge individually.
+        actual = sorted((min(u, v), max(u, v), d) for u, v, d in edges)
+        assert edges_equal(actual, self.minimum_spanning_edgelist)
+
+    def test_maximum_edges(self):
+        edges = nx.maximum_spanning_edges(self.G, algorithm=self.algo)
+        # Edges from the spanning edges functions don't come in sorted
+        # orientation, so we need to sort each edge individually.
+        actual = sorted((min(u, v), max(u, v), d) for u, v, d in edges)
+        assert edges_equal(actual, self.maximum_spanning_edgelist)
+
+    def test_without_data(self):
+        edges = nx.minimum_spanning_edges(self.G, algorithm=self.algo, data=False)
+        # Edges from the spanning edges functions don't come in sorted
+        # orientation, so we need to sort each edge individually.
+        actual = sorted((min(u, v), max(u, v)) for u, v in edges)
+        expected = [(u, v) for u, v, d in self.minimum_spanning_edgelist]
+        assert edges_equal(actual, expected)
+
+    def test_nan_weights(self):
+        # Edge weights NaN never appear in the spanning tree. see #2164
+        G = self.G
+        G.add_edge(0, 12, weight=float("nan"))
+        edges = nx.minimum_spanning_edges(
+            G, algorithm=self.algo, data=False, ignore_nan=True
+        )
+        actual = sorted((min(u, v), max(u, v)) for u, v in edges)
+        expected = [(u, v) for u, v, d in self.minimum_spanning_edgelist]
+        assert edges_equal(actual, expected)
+        # Now test for raising exception
+        edges = nx.minimum_spanning_edges(
+            G, algorithm=self.algo, data=False, ignore_nan=False
+        )
+        with pytest.raises(ValueError):
+            list(edges)
+        # test default for ignore_nan as False
+        edges = nx.minimum_spanning_edges(G, algorithm=self.algo, data=False)
+        with pytest.raises(ValueError):
+            list(edges)
+
+    def test_nan_weights_order(self):
+        # now try again with a nan edge at the beginning of G.nodes
+        edges = [
+            (0, 1, 7),
+            (0, 3, 5),
+            (1, 2, 8),
+            (1, 3, 9),
+            (1, 4, 7),
+            (2, 4, 5),
+            (3, 4, 15),
+            (3, 5, 6),
+            (4, 5, 8),
+            (4, 6, 9),
+            (5, 6, 11),
+        ]
+        G = nx.Graph()
+        G.add_weighted_edges_from([(u + 1, v + 1, wt) for u, v, wt in edges])
+        G.add_edge(0, 7, weight=float("nan"))
+        edges = nx.minimum_spanning_edges(
+            G, algorithm=self.algo, data=False, ignore_nan=True
+        )
+        actual = sorted((min(u, v), max(u, v)) for u, v in edges)
+        shift = [(u + 1, v + 1) for u, v, d in self.minimum_spanning_edgelist]
+        assert edges_equal(actual, shift)
+
+    def test_isolated_node(self):
+        # now try again with an isolated node
+        edges = [
+            (0, 1, 7),
+            (0, 3, 5),
+            (1, 2, 8),
+            (1, 3, 9),
+            (1, 4, 7),
+            (2, 4, 5),
+            (3, 4, 15),
+            (3, 5, 6),
+            (4, 5, 8),
+            (4, 6, 9),
+            (5, 6, 11),
+        ]
+        G = nx.Graph()
+        G.add_weighted_edges_from([(u + 1, v + 1, wt) for u, v, wt in edges])
+        G.add_node(0)
+        edges = nx.minimum_spanning_edges(
+            G, algorithm=self.algo, data=False, ignore_nan=True
+        )
+        actual = sorted((min(u, v), max(u, v)) for u, v in edges)
+        shift = [(u + 1, v + 1) for u, v, d in self.minimum_spanning_edgelist]
+        assert edges_equal(actual, shift)
+
+    def test_minimum_tree(self):
+        T = nx.minimum_spanning_tree(self.G, algorithm=self.algo)
+        actual = sorted(T.edges(data=True))
+        assert edges_equal(actual, self.minimum_spanning_edgelist)
+
+    def test_maximum_tree(self):
+        T = nx.maximum_spanning_tree(self.G, algorithm=self.algo)
+        actual = sorted(T.edges(data=True))
+        assert edges_equal(actual, self.maximum_spanning_edgelist)
+
+    def test_disconnected(self):
+        G = nx.Graph([(0, 1, dict(weight=1)), (2, 3, dict(weight=2))])
+        T = nx.minimum_spanning_tree(G, algorithm=self.algo)
+        assert nodes_equal(list(T), list(range(4)))
+        assert edges_equal(list(T.edges()), [(0, 1), (2, 3)])
+
+    def test_empty_graph(self):
+        G = nx.empty_graph(3)
+        T = nx.minimum_spanning_tree(G, algorithm=self.algo)
+        assert nodes_equal(sorted(T), list(range(3)))
+        assert T.number_of_edges() == 0
+
+    def test_attributes(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=1, color="red", distance=7)
+        G.add_edge(2, 3, weight=1, color="green", distance=2)
+        G.add_edge(1, 3, weight=10, color="blue", distance=1)
+        G.graph["foo"] = "bar"
+        T = nx.minimum_spanning_tree(G, algorithm=self.algo)
+        assert T.graph == G.graph
+        assert nodes_equal(T, G)
+        for u, v in T.edges():
+            assert T.adj[u][v] == G.adj[u][v]
+
+    def test_weight_attribute(self):
+        G = nx.Graph()
+        G.add_edge(0, 1, weight=1, distance=7)
+        G.add_edge(0, 2, weight=30, distance=1)
+        G.add_edge(1, 2, weight=1, distance=1)
+        G.add_node(3)
+        T = nx.minimum_spanning_tree(G, algorithm=self.algo, weight="distance")
+        assert nodes_equal(sorted(T), list(range(4)))
+        assert edges_equal(sorted(T.edges()), [(0, 2), (1, 2)])
+        T = nx.maximum_spanning_tree(G, algorithm=self.algo, weight="distance")
+        assert nodes_equal(sorted(T), list(range(4)))
+        assert edges_equal(sorted(T.edges()), [(0, 1), (0, 2)])
+
+
+class TestBoruvka(MinimumSpanningTreeTestBase):
+    """Unit tests for computing a minimum (or maximum) spanning tree
+    using Borůvka's algorithm.
+    """
+
+    algorithm = "boruvka"
+
+    def test_unicode_name(self):
+        """Tests that using a Unicode string can correctly indicate
+        Borůvka's algorithm.
+        """
+        edges = nx.minimum_spanning_edges(self.G, algorithm="borůvka")
+        # Edges from the spanning edges functions don't come in sorted
+        # orientation, so we need to sort each edge individually.
+        actual = sorted((min(u, v), max(u, v), d) for u, v, d in edges)
+        assert edges_equal(actual, self.minimum_spanning_edgelist)
+
+
+class MultigraphMSTTestBase(MinimumSpanningTreeTestBase):
+    # Abstract class
+
+    def test_multigraph_keys_min(self):
+        """Tests that the minimum spanning edges of a multigraph
+        preserves edge keys.
+        """
+        G = nx.MultiGraph()
+        G.add_edge(0, 1, key="a", weight=2)
+        G.add_edge(0, 1, key="b", weight=1)
+        min_edges = nx.minimum_spanning_edges
+        mst_edges = min_edges(G, algorithm=self.algo, data=False)
+        assert edges_equal([(0, 1, "b")], list(mst_edges))
+
+    def test_multigraph_keys_max(self):
+        """Tests that the maximum spanning edges of a multigraph
+        preserves edge keys.
+        """
+        G = nx.MultiGraph()
+        G.add_edge(0, 1, key="a", weight=2)
+        G.add_edge(0, 1, key="b", weight=1)
+        max_edges = nx.maximum_spanning_edges
+        mst_edges = max_edges(G, algorithm=self.algo, data=False)
+        assert edges_equal([(0, 1, "a")], list(mst_edges))
+
+
+class TestKruskal(MultigraphMSTTestBase):
+    """Unit tests for computing a minimum (or maximum) spanning tree
+    using Kruskal's algorithm.
+    """
+
+    algorithm = "kruskal"
+
+
+class TestPrim(MultigraphMSTTestBase):
+    """Unit tests for computing a minimum (or maximum) spanning tree
+    using Prim's algorithm.
+    """
+
+    algorithm = "prim"
+
+    def test_multigraph_keys_tree(self):
+        G = nx.MultiGraph()
+        G.add_edge(0, 1, key="a", weight=2)
+        G.add_edge(0, 1, key="b", weight=1)
+        T = nx.minimum_spanning_tree(G, algorithm=self.algo)
+        assert edges_equal([(0, 1, 1)], list(T.edges(data="weight")))
+
+    def test_multigraph_keys_tree_max(self):
+        G = nx.MultiGraph()
+        G.add_edge(0, 1, key="a", weight=2)
+        G.add_edge(0, 1, key="b", weight=1)
+        T = nx.maximum_spanning_tree(G, algorithm=self.algo)
+        assert edges_equal([(0, 1, 2)], list(T.edges(data="weight")))
+
+
+class TestSpanningTreeIterator:
+    """
+    Tests the spanning tree iterator on the example graph in the 2005 Sörensen
+    and Janssens paper An Algorithm to Generate all Spanning Trees of a Graph in
+    Order of Increasing Cost
+    """
+
+    def setup(self):
+        # Original Graph
+        edges = [(0, 1, 5), (1, 2, 4), (1, 4, 6), (2, 3, 5), (2, 4, 7), (3, 4, 3)]
+        self.G = nx.Graph()
+        self.G.add_weighted_edges_from(edges)
+        # List of lists of spanning trees in increasing order
+        self.spanning_trees = [
+            # 1, MST, cost = 17
+            [
+                (0, 1, {"weight": 5}),
+                (1, 2, {"weight": 4}),
+                (2, 3, {"weight": 5}),
+                (3, 4, {"weight": 3}),
+            ],
+            # 2, cost = 18
+            [
+                (0, 1, {"weight": 5}),
+                (1, 2, {"weight": 4}),
+                (1, 4, {"weight": 6}),
+                (3, 4, {"weight": 3}),
+            ],
+            # 3, cost = 19
+            [
+                (0, 1, {"weight": 5}),
+                (1, 4, {"weight": 6}),
+                (2, 3, {"weight": 5}),
+                (3, 4, {"weight": 3}),
+            ],
+            # 4, cost = 19
+            [
+                (0, 1, {"weight": 5}),
+                (1, 2, {"weight": 4}),
+                (2, 4, {"weight": 7}),
+                (3, 4, {"weight": 3}),
+            ],
+            # 5, cost = 20
+            [
+                (0, 1, {"weight": 5}),
+                (1, 2, {"weight": 4}),
+                (1, 4, {"weight": 6}),
+                (2, 3, {"weight": 5}),
+            ],
+            # 6, cost = 21
+            [
+                (0, 1, {"weight": 5}),
+                (1, 4, {"weight": 6}),
+                (2, 4, {"weight": 7}),
+                (3, 4, {"weight": 3}),
+            ],
+            # 7, cost = 21
+            [
+                (0, 1, {"weight": 5}),
+                (1, 2, {"weight": 4}),
+                (2, 3, {"weight": 5}),
+                (2, 4, {"weight": 7}),
+            ],
+            # 8, cost = 23
+            [
+                (0, 1, {"weight": 5}),
+                (1, 4, {"weight": 6}),
+                (2, 3, {"weight": 5}),
+                (2, 4, {"weight": 7}),
+            ],
+        ]
+
+    def test_minimum_spanning_tree_iterator(self):
+        """
+        Tests that the spanning trees are correctly returned in increasing order
+        """
+        tree_index = 0
+        for tree in nx.SpanningTreeIterator(self.G):
+            actual = sorted(tree.edges(data=True))
+            assert edges_equal(actual, self.spanning_trees[tree_index])
+            tree_index += 1
+
+    def test_maximum_spanning_tree_iterator(self):
+        """
+        Tests that the spanning trees are correctly returned in decreasing order
+        """
+        tree_index = 7
+        for tree in nx.SpanningTreeIterator(self.G, minimum=False):
+            actual = sorted(tree.edges(data=True))
+            assert edges_equal(actual, self.spanning_trees[tree_index])
+            tree_index -= 1
+
+
+def test_random_spanning_tree_multiplicative_small():
+    """
+    Using a fixed seed, sample one tree for repeatability.
+    """
+    from math import exp
+
+    pytest.importorskip("scipy")
+
+    gamma = {
+        (0, 1): -0.6383,
+        (0, 2): -0.6827,
+        (0, 5): 0,
+        (1, 2): -1.0781,
+        (1, 4): 0,
+        (2, 3): 0,
+        (5, 3): -0.2820,
+        (5, 4): -0.3327,
+        (4, 3): -0.9927,
+    }
+
+    # The undirected support of gamma
+    G = nx.Graph()
+    for u, v in gamma:
+        G.add_edge(u, v, lambda_key=exp(gamma[(u, v)]))
+
+    solution_edges = [(2, 3), (3, 4), (0, 5), (5, 4), (4, 1)]
+    solution = nx.Graph()
+    solution.add_edges_from(solution_edges)
+
+    sampled_tree = nx.random_spanning_tree(G, "lambda_key", seed=42)
+
+    assert nx.utils.edges_equal(solution.edges, sampled_tree.edges)
+
+
+@pytest.mark.slow
+def test_random_spanning_tree_multiplicative_large():
+    """
+    Sample many trees from the distribution created in the last test
+    """
+    from math import exp
+    from random import Random
+
+    pytest.importorskip("numpy")
+    stats = pytest.importorskip("scipy.stats")
+
+    gamma = {
+        (0, 1): -0.6383,
+        (0, 2): -0.6827,
+        (0, 5): 0,
+        (1, 2): -1.0781,
+        (1, 4): 0,
+        (2, 3): 0,
+        (5, 3): -0.2820,
+        (5, 4): -0.3327,
+        (4, 3): -0.9927,
+    }
+
+    # The undirected support of gamma
+    G = nx.Graph()
+    for u, v in gamma:
+        G.add_edge(u, v, lambda_key=exp(gamma[(u, v)]))
+
+    # Find the multiplicative weight for each tree.
+    total_weight = 0
+    tree_expected = {}
+    for t in nx.SpanningTreeIterator(G):
+        # Find the multiplicative weight of the spanning tree
+        weight = 1
+        for u, v, d in t.edges(data="lambda_key"):
+            weight *= d
+        tree_expected[t] = weight
+        total_weight += weight
+
+    # Assert that every tree has an entry in the expected distribution
+    assert len(tree_expected) == 75
+
+    # Set the sample size and then calculate the expected number of times we
+    # expect to see each tree. This test uses a near minimum sample size where
+    # the most unlikely tree has an expected frequency of 5.15.
+    # (Minimum required is 5)
+    #
+    # Here we also initialize the tree_actual dict so that we know the keys
+    # match between the two. We will later take advantage of the fact that since
+    # python 3.7 dict order is guaranteed so the expected and actual data will
+    # have the same order.
+    sample_size = 1200
+    tree_actual = {}
+    for t in tree_expected:
+        tree_expected[t] = (tree_expected[t] / total_weight) * sample_size
+        tree_actual[t] = 0
+
+    # Sample the spanning trees
+    #
+    # Assert that they are actually trees and record which of the 75 trees we
+    # have sampled.
+    #
+    # For repeatability, we want to take advantage of the decorators in NetworkX
+    # to randomly sample the same sample each time. However, if we pass in a
+    # constant seed to sample_spanning_tree we will get the same tree each time.
+    # Instead, we can create our own random number generator with a fixed seed
+    # and pass those into sample_spanning_tree.
+    rng = Random(37)
+    for _ in range(sample_size):
+        sampled_tree = nx.random_spanning_tree(G, "lambda_key", seed=rng)
+        assert nx.is_tree(sampled_tree)
+
+        for t in tree_expected:
+            if nx.utils.edges_equal(t.edges, sampled_tree.edges):
+                tree_actual[t] += 1
+                break
+
+    # Conduct a Chi squared test to see if the actual distribution matches the
+    # expected one at an alpha = 0.05 significance level.
+    #
+    # H_0: The distribution of trees in tree_actual matches the normalized product
+    # of the edge weights in the tree.
+    #
+    # H_a: The distribution of trees in tree_actual follows some other
+    # distribution of spanning trees.
+    _, p = stats.chisquare(list(tree_actual.values()), list(tree_expected.values()))
+
+    # Assert that p is greater than the significance level so that we do not
+    # reject the null hypothesis
+    assert not p < 0.05
+
+
+def test_random_spanning_tree_additive_small():
+    """
+    Sample a single spanning tree from the additive method.
+    """
+    pytest.importorskip("scipy")
+
+    edges = {
+        (0, 1): 1,
+        (0, 2): 1,
+        (0, 5): 3,
+        (1, 2): 2,
+        (1, 4): 3,
+        (2, 3): 3,
+        (5, 3): 4,
+        (5, 4): 5,
+        (4, 3): 4,
+    }
+
+    # Build the graph
+    G = nx.Graph()
+    for u, v in edges:
+        G.add_edge(u, v, weight=edges[(u, v)])
+
+    solution_edges = [(0, 2), (1, 2), (2, 3), (3, 4), (3, 5)]
+    solution = nx.Graph()
+    solution.add_edges_from(solution_edges)
+
+    sampled_tree = nx.random_spanning_tree(
+        G, weight="weight", multiplicative=False, seed=37
+    )
+
+    assert nx.utils.edges_equal(solution.edges, sampled_tree.edges)
+
+
+@pytest.mark.slow
+def test_random_spanning_tree_additive_large():
+    """
+    Sample many spanning trees from the additive method.
+    """
+    from random import Random
+
+    pytest.importorskip("numpy")
+    stats = pytest.importorskip("scipy.stats")
+
+    edges = {
+        (0, 1): 1,
+        (0, 2): 1,
+        (0, 5): 3,
+        (1, 2): 2,
+        (1, 4): 3,
+        (2, 3): 3,
+        (5, 3): 4,
+        (5, 4): 5,
+        (4, 3): 4,
+    }
+
+    # Build the graph
+    G = nx.Graph()
+    for u, v in edges:
+        G.add_edge(u, v, weight=edges[(u, v)])
+
+    # Find the additive weight for each tree.
+    total_weight = 0
+    tree_expected = {}
+    for t in nx.SpanningTreeIterator(G):
+        # Find the multiplicative weight of the spanning tree
+        weight = 0
+        for u, v, d in t.edges(data="weight"):
+            weight += d
+        tree_expected[t] = weight
+        total_weight += weight
+
+    # Assert that every tree has an entry in the expected distribution
+    assert len(tree_expected) == 75
+
+    # Set the sample size and then calculate the expected number of times we
+    # expect to see each tree. This test uses a near minimum sample size where
+    # the most unlikely tree has an expected frequency of 5.07.
+    # (Minimum required is 5)
+    #
+    # Here we also initialize the tree_actual dict so that we know the keys
+    # match between the two. We will later take advantage of the fact that since
+    # python 3.7 dict order is guaranteed so the expected and actual data will
+    # have the same order.
+    sample_size = 500
+    tree_actual = {}
+    for t in tree_expected:
+        tree_expected[t] = (tree_expected[t] / total_weight) * sample_size
+        tree_actual[t] = 0
+
+    # Sample the spanning trees
+    #
+    # Assert that they are actually trees and record which of the 75 trees we
+    # have sampled.
+    #
+    # For repeatability, we want to take advantage of the decorators in NetworkX
+    # to randomly sample the same sample each time. However, if we pass in a
+    # constant seed to sample_spanning_tree we will get the same tree each time.
+    # Instead, we can create our own random number generator with a fixed seed
+    # and pass those into sample_spanning_tree.
+    rng = Random(37)
+    for _ in range(sample_size):
+        sampled_tree = nx.random_spanning_tree(
+            G, "weight", multiplicative=False, seed=rng
+        )
+        assert nx.is_tree(sampled_tree)
+
+        for t in tree_expected:
+            if nx.utils.edges_equal(t.edges, sampled_tree.edges):
+                tree_actual[t] += 1
+                break
+
+    # Conduct a Chi squared test to see if the actual distribution matches the
+    # expected one at an alpha = 0.05 significance level.
+    #
+    # H_0: The distribution of trees in tree_actual matches the normalized product
+    # of the edge weights in the tree.
+    #
+    # H_a: The distribution of trees in tree_actual follows some other
+    # distribution of spanning trees.
+    _, p = stats.chisquare(list(tree_actual.values()), list(tree_expected.values()))
+
+    # Assert that p is greater than the significance level so that we do not
+    # reject the null hypothesis
+    assert not p < 0.05
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_operations.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_operations.py
new file mode 100644
index 0000000..a2c5827
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_operations.py
@@ -0,0 +1,37 @@
+"""Unit tests for the :mod:`networkx.algorithms.tree.operations` module.
+
+"""
+
+import networkx as nx
+from networkx.utils import edges_equal, nodes_equal
+
+
+class TestJoin:
+    """Unit tests for the :func:`networkx.tree.join` function."""
+
+    def test_empty_sequence(self):
+        """Tests that joining the empty sequence results in the tree
+        with one node.
+
+        """
+        T = nx.join([])
+        assert len(T) == 1
+        assert T.number_of_edges() == 0
+
+    def test_single(self):
+        """Tests that joining just one tree yields a tree with one more
+        node.
+
+        """
+        T = nx.empty_graph(1)
+        actual = nx.join([(T, 0)])
+        expected = nx.path_graph(2)
+        assert nodes_equal(list(expected), list(actual))
+        assert edges_equal(list(expected.edges()), list(actual.edges()))
+
+    def test_basic(self):
+        """Tests for joining multiple subtrees at a root node."""
+        trees = [(nx.full_rary_tree(2, 2**2 - 1), 0) for i in range(2)]
+        actual = nx.join(trees)
+        expected = nx.full_rary_tree(2, 2**3 - 1)
+        assert nx.is_isomorphic(actual, expected)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_recognition.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_recognition.py
new file mode 100644
index 0000000..d9c4943
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/tree/tests/test_recognition.py
@@ -0,0 +1,164 @@
+import pytest
+
+import networkx as nx
+
+
+class TestTreeRecognition:
+
+    graph = nx.Graph
+    multigraph = nx.MultiGraph
+
+    @classmethod
+    def setup_class(cls):
+
+        cls.T1 = cls.graph()
+
+        cls.T2 = cls.graph()
+        cls.T2.add_node(1)
+
+        cls.T3 = cls.graph()
+        cls.T3.add_nodes_from(range(5))
+        edges = [(i, i + 1) for i in range(4)]
+        cls.T3.add_edges_from(edges)
+
+        cls.T5 = cls.multigraph()
+        cls.T5.add_nodes_from(range(5))
+        edges = [(i, i + 1) for i in range(4)]
+        cls.T5.add_edges_from(edges)
+
+        cls.T6 = cls.graph()
+        cls.T6.add_nodes_from([6, 7])
+        cls.T6.add_edge(6, 7)
+
+        cls.F1 = nx.compose(cls.T6, cls.T3)
+
+        cls.N4 = cls.graph()
+        cls.N4.add_node(1)
+        cls.N4.add_edge(1, 1)
+
+        cls.N5 = cls.graph()
+        cls.N5.add_nodes_from(range(5))
+
+        cls.N6 = cls.graph()
+        cls.N6.add_nodes_from(range(3))
+        cls.N6.add_edges_from([(0, 1), (1, 2), (2, 0)])
+
+        cls.NF1 = nx.compose(cls.T6, cls.N6)
+
+    def test_null_tree(self):
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.is_tree(self.graph())
+
+    def test_null_tree2(self):
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.is_tree(self.multigraph())
+
+    def test_null_forest(self):
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.is_forest(self.graph())
+
+    def test_null_forest2(self):
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.is_forest(self.multigraph())
+
+    def test_is_tree(self):
+        assert nx.is_tree(self.T2)
+        assert nx.is_tree(self.T3)
+        assert nx.is_tree(self.T5)
+
+    def test_is_not_tree(self):
+        assert not nx.is_tree(self.N4)
+        assert not nx.is_tree(self.N5)
+        assert not nx.is_tree(self.N6)
+
+    def test_is_forest(self):
+        assert nx.is_forest(self.T2)
+        assert nx.is_forest(self.T3)
+        assert nx.is_forest(self.T5)
+        assert nx.is_forest(self.F1)
+        assert nx.is_forest(self.N5)
+
+    def test_is_not_forest(self):
+        assert not nx.is_forest(self.N4)
+        assert not nx.is_forest(self.N6)
+        assert not nx.is_forest(self.NF1)
+
+
+class TestDirectedTreeRecognition(TestTreeRecognition):
+    graph = nx.DiGraph
+    multigraph = nx.MultiDiGraph
+
+
+def test_disconnected_graph():
+    # https://github.com/networkx/networkx/issues/1144
+    G = nx.Graph()
+    G.add_edges_from([(0, 1), (1, 2), (2, 0), (3, 4)])
+    assert not nx.is_tree(G)
+
+    G = nx.DiGraph()
+    G.add_edges_from([(0, 1), (1, 2), (2, 0), (3, 4)])
+    assert not nx.is_tree(G)
+
+
+def test_dag_nontree():
+    G = nx.DiGraph()
+    G.add_edges_from([(0, 1), (0, 2), (1, 2)])
+    assert not nx.is_tree(G)
+    assert nx.is_directed_acyclic_graph(G)
+
+
+def test_multicycle():
+    G = nx.MultiDiGraph()
+    G.add_edges_from([(0, 1), (0, 1)])
+    assert not nx.is_tree(G)
+    assert nx.is_directed_acyclic_graph(G)
+
+
+def test_emptybranch():
+    G = nx.DiGraph()
+    G.add_nodes_from(range(10))
+    assert nx.is_branching(G)
+    assert not nx.is_arborescence(G)
+
+
+def test_path():
+    G = nx.DiGraph()
+    nx.add_path(G, range(5))
+    assert nx.is_branching(G)
+    assert nx.is_arborescence(G)
+
+
+def test_notbranching1():
+    # Acyclic violation.
+    G = nx.MultiDiGraph()
+    G.add_nodes_from(range(10))
+    G.add_edges_from([(0, 1), (1, 0)])
+    assert not nx.is_branching(G)
+    assert not nx.is_arborescence(G)
+
+
+def test_notbranching2():
+    # In-degree violation.
+    G = nx.MultiDiGraph()
+    G.add_nodes_from(range(10))
+    G.add_edges_from([(0, 1), (0, 2), (3, 2)])
+    assert not nx.is_branching(G)
+    assert not nx.is_arborescence(G)
+
+
+def test_notarborescence1():
+    # Not an arborescence due to not spanning.
+    G = nx.MultiDiGraph()
+    G.add_nodes_from(range(10))
+    G.add_edges_from([(0, 1), (0, 2), (1, 3), (5, 6)])
+    assert nx.is_branching(G)
+    assert not nx.is_arborescence(G)
+
+
+def test_notarborescence2():
+    # Not an arborescence due to in-degree violation.
+    G = nx.MultiDiGraph()
+    nx.add_path(G, range(5))
+    G.add_edge(6, 4)
+    assert not nx.is_branching(G)
+    assert not nx.is_arborescence(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/triads.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/triads.py
new file mode 100644
index 0000000..1c107a1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/triads.py
@@ -0,0 +1,498 @@
+# See https://github.com/networkx/networkx/pull/1474
+# Copyright 2011 Reya Group <http://www.reyagroup.com>
+# Copyright 2011 Alex Levenson <alex@isnotinvain.com>
+# Copyright 2011 Diederik van Liere <diederik.vanliere@rotman.utoronto.ca>
+"""Functions for analyzing triads of a graph."""
+
+from collections import defaultdict
+from itertools import combinations, permutations
+from random import sample
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "triadic_census",
+    "is_triad",
+    "all_triplets",
+    "all_triads",
+    "triads_by_type",
+    "triad_type",
+    "random_triad",
+]
+
+#: The integer codes representing each type of triad.
+#:
+#: Triads that are the same up to symmetry have the same code.
+TRICODES = (
+    1,
+    2,
+    2,
+    3,
+    2,
+    4,
+    6,
+    8,
+    2,
+    6,
+    5,
+    7,
+    3,
+    8,
+    7,
+    11,
+    2,
+    6,
+    4,
+    8,
+    5,
+    9,
+    9,
+    13,
+    6,
+    10,
+    9,
+    14,
+    7,
+    14,
+    12,
+    15,
+    2,
+    5,
+    6,
+    7,
+    6,
+    9,
+    10,
+    14,
+    4,
+    9,
+    9,
+    12,
+    8,
+    13,
+    14,
+    15,
+    3,
+    7,
+    8,
+    11,
+    7,
+    12,
+    14,
+    15,
+    8,
+    14,
+    13,
+    15,
+    11,
+    15,
+    15,
+    16,
+)
+
+#: The names of each type of triad. The order of the elements is
+#: important: it corresponds to the tricodes given in :data:`TRICODES`.
+TRIAD_NAMES = (
+    "003",
+    "012",
+    "102",
+    "021D",
+    "021U",
+    "021C",
+    "111D",
+    "111U",
+    "030T",
+    "030C",
+    "201",
+    "120D",
+    "120U",
+    "120C",
+    "210",
+    "300",
+)
+
+
+#: A dictionary mapping triad code to triad name.
+TRICODE_TO_NAME = {i: TRIAD_NAMES[code - 1] for i, code in enumerate(TRICODES)}
+
+
+def _tricode(G, v, u, w):
+    """Returns the integer code of the given triad.
+
+    This is some fancy magic that comes from Batagelj and Mrvar's paper. It
+    treats each edge joining a pair of `v`, `u`, and `w` as a bit in
+    the binary representation of an integer.
+
+    """
+    combos = ((v, u, 1), (u, v, 2), (v, w, 4), (w, v, 8), (u, w, 16), (w, u, 32))
+    return sum(x for u, v, x in combos if v in G[u])
+
+
+@not_implemented_for("undirected")
+def triadic_census(G, nodelist=None):
+    """Determines the triadic census of a directed graph.
+
+    The triadic census is a count of how many of the 16 possible types of
+    triads are present in a directed graph. If a list of nodes is passed, then
+    only those triads are taken into account which have elements of nodelist in them.
+
+    Parameters
+    ----------
+    G : digraph
+       A NetworkX DiGraph
+    nodelist : list
+        List of nodes for which you want to calculate triadic census
+
+    Returns
+    -------
+    census : dict
+       Dictionary with triad type as keys and number of occurrences as values.
+
+    Notes
+    -----
+    This algorithm has complexity $O(m)$ where $m$ is the number of edges in
+    the graph.
+
+    Raises
+    ------
+    ValueError
+        If `nodelist` contains duplicate nodes or nodes not in `G`.
+        If you want to ignore this you can preprocess with `set(nodelist) & G.nodes`
+
+    See also
+    --------
+    triad_graph
+
+    References
+    ----------
+    .. [1] Vladimir Batagelj and Andrej Mrvar, A subquadratic triad census
+        algorithm for large sparse networks with small maximum degree,
+        University of Ljubljana,
+        http://vlado.fmf.uni-lj.si/pub/networks/doc/triads/triads.pdf
+
+    """
+    nodeset = set(G.nbunch_iter(nodelist))
+    if nodelist is not None and len(nodelist) != len(nodeset):
+        raise ValueError("nodelist includes duplicate nodes or nodes not in G")
+
+    N = len(G)
+    Nnot = N - len(nodeset)  # can signal special counting for subset of nodes
+
+    # create an ordering of nodes with nodeset nodes first
+    m = {n: i for i, n in enumerate(nodeset)}
+    if Nnot:
+        # add non-nodeset nodes later in the ordering
+        not_nodeset = G.nodes - nodeset
+        m.update((n, i + N) for i, n in enumerate(not_nodeset))
+
+    # build all_neighbor dicts for easy counting
+    # After Python 3.8 can leave off these keys(). Speedup also using G._pred
+    # nbrs = {n: G._pred[n].keys() | G._succ[n].keys() for n in G}
+    nbrs = {n: G.pred[n].keys() | G.succ[n].keys() for n in G}
+    dbl_nbrs = {n: G.pred[n].keys() & G.succ[n].keys() for n in G}
+
+    if Nnot:
+        sgl_nbrs = {n: G.pred[n].keys() ^ G.succ[n].keys() for n in not_nodeset}
+        # find number of edges not incident to nodes in nodeset
+        sgl = sum(1 for n in not_nodeset for nbr in sgl_nbrs[n] if nbr not in nodeset)
+        sgl_edges_outside = sgl // 2
+        dbl = sum(1 for n in not_nodeset for nbr in dbl_nbrs[n] if nbr not in nodeset)
+        dbl_edges_outside = dbl // 2
+
+    # Initialize the count for each triad to be zero.
+    census = {name: 0 for name in TRIAD_NAMES}
+    # Main loop over nodes
+    for v in nodeset:
+        vnbrs = nbrs[v]
+        dbl_vnbrs = dbl_nbrs[v]
+        if Nnot:
+            # set up counts of edges attached to v.
+            sgl_unbrs_bdy = sgl_unbrs_out = dbl_unbrs_bdy = dbl_unbrs_out = 0
+        for u in vnbrs:
+            if m[u] <= m[v]:
+                continue
+            unbrs = nbrs[u]
+            neighbors = (vnbrs | unbrs) - {u, v}
+            # Count connected triads.
+            for w in neighbors:
+                if m[u] < m[w] or (m[v] < m[w] < m[u] and v not in nbrs[w]):
+                    code = _tricode(G, v, u, w)
+                    census[TRICODE_TO_NAME[code]] += 1
+
+            # Use a formula for dyadic triads with edge incident to v
+            if u in dbl_vnbrs:
+                census["102"] += N - len(neighbors) - 2
+            else:
+                census["012"] += N - len(neighbors) - 2
+
+            # Count edges attached to v. Subtract later to get triads with v isolated
+            # _out are (u,unbr) for unbrs outside boundary of nodeset
+            # _bdy are (u,unbr) for unbrs on boundary of nodeset (get double counted)
+            if Nnot and u not in nodeset:
+                sgl_unbrs = sgl_nbrs[u]
+                sgl_unbrs_bdy += len(sgl_unbrs & vnbrs - nodeset)
+                sgl_unbrs_out += len(sgl_unbrs - vnbrs - nodeset)
+                dbl_unbrs = dbl_nbrs[u]
+                dbl_unbrs_bdy += len(dbl_unbrs & vnbrs - nodeset)
+                dbl_unbrs_out += len(dbl_unbrs - vnbrs - nodeset)
+        # if nodeset == G.nodes, skip this b/c we will find the edge later.
+        if Nnot:
+            # Count edges outside nodeset not connected with v (v isolated triads)
+            census["012"] += sgl_edges_outside - (sgl_unbrs_out + sgl_unbrs_bdy // 2)
+            census["102"] += dbl_edges_outside - (dbl_unbrs_out + dbl_unbrs_bdy // 2)
+
+    # calculate null triads: "003"
+    # null triads = total number of possible triads - all found triads
+    total_triangles = (N * (N - 1) * (N - 2)) // 6
+    triangles_without_nodeset = (Nnot * (Nnot - 1) * (Nnot - 2)) // 6
+    total_census = total_triangles - triangles_without_nodeset
+    census["003"] = total_census - sum(census.values())
+
+    return census
+
+
+def is_triad(G):
+    """Returns True if the graph G is a triad, else False.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX Graph
+
+    Returns
+    -------
+    istriad : boolean
+       Whether G is a valid triad
+    """
+    if isinstance(G, nx.Graph):
+        if G.order() == 3 and nx.is_directed(G):
+            if not any((n, n) in G.edges() for n in G.nodes()):
+                return True
+    return False
+
+
+@not_implemented_for("undirected")
+def all_triplets(G):
+    """Returns a generator of all possible sets of 3 nodes in a DiGraph.
+
+    Parameters
+    ----------
+    G : digraph
+       A NetworkX DiGraph
+
+    Returns
+    -------
+    triplets : generator of 3-tuples
+       Generator of tuples of 3 nodes
+    """
+    triplets = combinations(G.nodes(), 3)
+    return triplets
+
+
+@not_implemented_for("undirected")
+def all_triads(G):
+    """A generator of all possible triads in G.
+
+    Parameters
+    ----------
+    G : digraph
+       A NetworkX DiGraph
+
+    Returns
+    -------
+    all_triads : generator of DiGraphs
+       Generator of triads (order-3 DiGraphs)
+    """
+    triplets = combinations(G.nodes(), 3)
+    for triplet in triplets:
+        yield G.subgraph(triplet).copy()
+
+
+@not_implemented_for("undirected")
+def triads_by_type(G):
+    """Returns a list of all triads for each triad type in a directed graph.
+
+    Parameters
+    ----------
+    G : digraph
+       A NetworkX DiGraph
+
+    Returns
+    -------
+    tri_by_type : dict
+       Dictionary with triad types as keys and lists of triads as values.
+    """
+    # num_triads = o * (o - 1) * (o - 2) // 6
+    # if num_triads > TRIAD_LIMIT: print(WARNING)
+    all_tri = all_triads(G)
+    tri_by_type = defaultdict(list)
+    for triad in all_tri:
+        name = triad_type(triad)
+        tri_by_type[name].append(triad)
+    return tri_by_type
+
+
+@not_implemented_for("undirected")
+def triad_type(G):
+    """Returns the sociological triad type for a triad.
+
+    Parameters
+    ----------
+    G : digraph
+       A NetworkX DiGraph with 3 nodes
+
+    Returns
+    -------
+    triad_type : str
+       A string identifying the triad type
+
+    Notes
+    -----
+    There can be 6 unique edges in a triad (order-3 DiGraph) (so 2^^6=64 unique
+    triads given 3 nodes). These 64 triads each display exactly 1 of 16
+    topologies of triads (topologies can be permuted). These topologies are
+    identified by the following notation:
+
+    {m}{a}{n}{type} (for example: 111D, 210, 102)
+
+    Here:
+
+    {m}     = number of mutual ties (takes 0, 1, 2, 3); a mutual tie is (0,1)
+              AND (1,0)
+    {a}     = number of assymmetric ties (takes 0, 1, 2, 3); an assymmetric tie
+              is (0,1) BUT NOT (1,0) or vice versa
+    {n}     = number of null ties (takes 0, 1, 2, 3); a null tie is NEITHER
+              (0,1) NOR (1,0)
+    {type}  = a letter (takes U, D, C, T) corresponding to up, down, cyclical
+              and transitive. This is only used for topologies that can have
+              more than one form (eg: 021D and 021U).
+
+    References
+    ----------
+    .. [1] Snijders, T. (2012). "Transitivity and triads." University of
+        Oxford.
+        https://web.archive.org/web/20170830032057/http://www.stats.ox.ac.uk/~snijders/Trans_Triads_ha.pdf
+    """
+    if not is_triad(G):
+        raise nx.NetworkXAlgorithmError("G is not a triad (order-3 DiGraph)")
+    num_edges = len(G.edges())
+    if num_edges == 0:
+        return "003"
+    elif num_edges == 1:
+        return "012"
+    elif num_edges == 2:
+        e1, e2 = G.edges()
+        if set(e1) == set(e2):
+            return "102"
+        elif e1[0] == e2[0]:
+            return "021D"
+        elif e1[1] == e2[1]:
+            return "021U"
+        elif e1[1] == e2[0] or e2[1] == e1[0]:
+            return "021C"
+    elif num_edges == 3:
+        for (e1, e2, e3) in permutations(G.edges(), 3):
+            if set(e1) == set(e2):
+                if e3[0] in e1:
+                    return "111U"
+                # e3[1] in e1:
+                return "111D"
+            elif set(e1).symmetric_difference(set(e2)) == set(e3):
+                if {e1[0], e2[0], e3[0]} == {e1[0], e2[0], e3[0]} == set(G.nodes()):
+                    return "030C"
+                # e3 == (e1[0], e2[1]) and e2 == (e1[1], e3[1]):
+                return "030T"
+    elif num_edges == 4:
+        for (e1, e2, e3, e4) in permutations(G.edges(), 4):
+            if set(e1) == set(e2):
+                # identify pair of symmetric edges (which necessarily exists)
+                if set(e3) == set(e4):
+                    return "201"
+                if {e3[0]} == {e4[0]} == set(e3).intersection(set(e4)):
+                    return "120D"
+                if {e3[1]} == {e4[1]} == set(e3).intersection(set(e4)):
+                    return "120U"
+                if e3[1] == e4[0]:
+                    return "120C"
+    elif num_edges == 5:
+        return "210"
+    elif num_edges == 6:
+        return "300"
+
+
+@not_implemented_for("undirected")
+def random_triad(G):
+    """Returns a random triad from a directed graph.
+
+    Parameters
+    ----------
+    G : digraph
+       A NetworkX DiGraph
+
+    Returns
+    -------
+    G2 : subgraph
+       A randomly selected triad (order-3 NetworkX DiGraph)
+    """
+    nodes = sample(list(G.nodes()), 3)
+    G2 = G.subgraph(nodes)
+    return G2
+
+
+"""
+@not_implemented_for('undirected')
+def triadic_closures(G):
+    '''Returns a list of order-3 subgraphs of G that are triadic closures.
+
+    Parameters
+    ----------
+    G : digraph
+       A NetworkX DiGraph
+
+    Returns
+    -------
+    closures : list
+       List of triads of G that are triadic closures
+    '''
+    pass
+
+
+@not_implemented_for('undirected')
+def focal_closures(G, attr_name):
+    '''Returns a list of order-3 subgraphs of G that are focally closed.
+
+    Parameters
+    ----------
+    G : digraph
+       A NetworkX DiGraph
+    attr_name : str
+        An attribute name
+
+
+    Returns
+    -------
+    closures : list
+       List of triads of G that are focally closed on attr_name
+    '''
+    pass
+
+
+@not_implemented_for('undirected')
+def balanced_triads(G, crit_func):
+    '''Returns a list of order-3 subgraphs of G that are stable.
+
+    Parameters
+    ----------
+    G : digraph
+       A NetworkX DiGraph
+    crit_func : function
+       A function that determines if a triad (order-3 digraph) is stable
+
+    Returns
+    -------
+    triads : list
+       List of triads in G that are stable
+    '''
+    pass
+"""
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/vitality.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/vitality.py
new file mode 100644
index 0000000..88e174d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/vitality.py
@@ -0,0 +1,75 @@
+"""
+Vitality measures.
+"""
+from functools import partial
+
+import networkx as nx
+
+__all__ = ["closeness_vitality"]
+
+
+def closeness_vitality(G, node=None, weight=None, wiener_index=None):
+    """Returns the closeness vitality for nodes in the graph.
+
+    The *closeness vitality* of a node, defined in Section 3.6.2 of [1],
+    is the change in the sum of distances between all node pairs when
+    excluding that node.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A strongly-connected graph.
+
+    weight : string
+        The name of the edge attribute used as weight. This is passed
+        directly to the :func:`~networkx.wiener_index` function.
+
+    node : object
+        If specified, only the closeness vitality for this node will be
+        returned. Otherwise, a dictionary mapping each node to its
+        closeness vitality will be returned.
+
+    Other parameters
+    ----------------
+    wiener_index : number
+        If you have already computed the Wiener index of the graph
+        `G`, you can provide that value here. Otherwise, it will be
+        computed for you.
+
+    Returns
+    -------
+    dictionary or float
+        If `node` is None, this function returns a dictionary
+        with nodes as keys and closeness vitality as the
+        value. Otherwise, it returns only the closeness vitality for the
+        specified `node`.
+
+        The closeness vitality of a node may be negative infinity if
+        removing that node would disconnect the graph.
+
+    Examples
+    --------
+    >>> G = nx.cycle_graph(3)
+    >>> nx.closeness_vitality(G)
+    {0: 2.0, 1: 2.0, 2: 2.0}
+
+    See Also
+    --------
+    closeness_centrality
+
+    References
+    ----------
+    .. [1] Ulrik Brandes, Thomas Erlebach (eds.).
+           *Network Analysis: Methodological Foundations*.
+           Springer, 2005.
+           <http://books.google.com/books?id=TTNhSm7HYrIC>
+
+    """
+    if wiener_index is None:
+        wiener_index = nx.wiener_index(G, weight=weight)
+    if node is not None:
+        after = nx.wiener_index(G.subgraph(set(G) - {node}), weight=weight)
+        return wiener_index - after
+    vitality = partial(closeness_vitality, G, weight=weight, wiener_index=wiener_index)
+    # TODO This can be trivially parallelized.
+    return {v: vitality(node=v) for v in G}
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/voronoi.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/voronoi.py
new file mode 100644
index 0000000..184afa2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/voronoi.py
@@ -0,0 +1,85 @@
+"""Functions for computing the Voronoi cells of a graph."""
+import networkx as nx
+from networkx.utils import groups
+
+__all__ = ["voronoi_cells"]
+
+
+def voronoi_cells(G, center_nodes, weight="weight"):
+    """Returns the Voronoi cells centered at `center_nodes` with respect
+    to the shortest-path distance metric.
+
+    If *C* is a set of nodes in the graph and *c* is an element of *C*,
+    the *Voronoi cell* centered at a node *c* is the set of all nodes
+    *v* that are closer to *c* than to any other center node in *C* with
+    respect to the shortest-path distance metric. [1]_
+
+    For directed graphs, this will compute the "outward" Voronoi cells,
+    as defined in [1]_, in which distance is measured from the center
+    nodes to the target node. For the "inward" Voronoi cells, use the
+    :meth:`DiGraph.reverse` method to reverse the orientation of the
+    edges before invoking this function on the directed graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    center_nodes : set
+        A nonempty set of nodes in the graph `G` that represent the
+        center of the Voronoi cells.
+
+    weight : string or function
+        The edge attribute (or an arbitrary function) representing the
+        weight of an edge. This keyword argument is as described in the
+        documentation for :func:`~networkx.multi_source_dijkstra_path`,
+        for example.
+
+    Returns
+    -------
+    dictionary
+        A mapping from center node to set of all nodes in the graph
+        closer to that center node than to any other center node. The
+        keys of the dictionary are the element of `center_nodes`, and
+        the values of the dictionary form a partition of the nodes of
+        `G`.
+
+    Examples
+    --------
+    To get only the partition of the graph induced by the Voronoi cells,
+    take the collection of all values in the returned dictionary::
+
+        >>> G = nx.path_graph(6)
+        >>> center_nodes = {0, 3}
+        >>> cells = nx.voronoi_cells(G, center_nodes)
+        >>> partition = set(map(frozenset, cells.values()))
+        >>> sorted(map(sorted, partition))
+        [[0, 1], [2, 3, 4, 5]]
+
+    Raises
+    ------
+    ValueError
+        If `center_nodes` is empty.
+
+    References
+    ----------
+    .. [1] Erwig, Martin. (2000),
+           "The graph Voronoi diagram with applications."
+           *Networks*, 36: 156--163.
+           <dx.doi.org/10.1002/1097-0037(200010)36:3<156::AID-NET2>3.0.CO;2-L>
+
+    """
+    # Determine the shortest paths from any one of the center nodes to
+    # every node in the graph.
+    #
+    # This raises `ValueError` if `center_nodes` is an empty set.
+    paths = nx.multi_source_dijkstra_path(G, center_nodes, weight=weight)
+    # Determine the center node from which the shortest path originates.
+    nearest = {v: p[0] for v, p in paths.items()}
+    # Get the mapping from center node to all nodes closer to it than to
+    # any other center node.
+    cells = groups(nearest)
+    # We collect all unreachable nodes under a special key, if there are any.
+    unreachable = set(G) - set(nearest)
+    if unreachable:
+        cells["unreachable"] = unreachable
+    return cells
diff --git a/myenv/lib/python3.9/site-packages/networkx/algorithms/wiener.py b/myenv/lib/python3.9/site-packages/networkx/algorithms/wiener.py
new file mode 100644
index 0000000..e60fb9e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/algorithms/wiener.py
@@ -0,0 +1,76 @@
+"""Functions related to the Wiener index of a graph."""
+
+from itertools import chain
+
+from .components import is_connected, is_strongly_connected
+from .shortest_paths import shortest_path_length as spl
+
+__all__ = ["wiener_index"]
+
+#: Rename the :func:`chain.from_iterable` function for the sake of
+#: brevity.
+chaini = chain.from_iterable
+
+
+def wiener_index(G, weight=None):
+    """Returns the Wiener index of the given graph.
+
+    The *Wiener index* of a graph is the sum of the shortest-path
+    distances between each pair of reachable nodes. For pairs of nodes
+    in undirected graphs, only one orientation of the pair is counted.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight : object
+        The edge attribute to use as distance when computing
+        shortest-path distances. This is passed directly to the
+        :func:`networkx.shortest_path_length` function.
+
+    Returns
+    -------
+    float
+        The Wiener index of the graph `G`.
+
+    Raises
+    ------
+    NetworkXError
+        If the graph `G` is not connected.
+
+    Notes
+    -----
+    If a pair of nodes is not reachable, the distance is assumed to be
+    infinity. This means that for graphs that are not
+    strongly-connected, this function returns ``inf``.
+
+    The Wiener index is not usually defined for directed graphs, however
+    this function uses the natural generalization of the Wiener index to
+    directed graphs.
+
+    Examples
+    --------
+    The Wiener index of the (unweighted) complete graph on *n* nodes
+    equals the number of pairs of the *n* nodes, since each pair of
+    nodes is at distance one::
+
+        >>> n = 10
+        >>> G = nx.complete_graph(n)
+        >>> nx.wiener_index(G) == n * (n - 1) / 2
+        True
+
+    Graphs that are not strongly-connected have infinite Wiener index::
+
+        >>> G = nx.empty_graph(2)
+        >>> nx.wiener_index(G)
+        inf
+
+    """
+    is_directed = G.is_directed()
+    if (is_directed and not is_strongly_connected(G)) or (
+        not is_directed and not is_connected(G)
+    ):
+        return float("inf")
+    total = sum(chaini(p.values() for v, p in spl(G, weight=weight)))
+    # Need to account for double counting pairs of nodes in undirected graphs.
+    return total if is_directed else total / 2
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/__init__.py b/myenv/lib/python3.9/site-packages/networkx/classes/__init__.py
new file mode 100644
index 0000000..d5bb1d7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/__init__.py
@@ -0,0 +1,13 @@
+from .graph import Graph
+from .digraph import DiGraph
+from .multigraph import MultiGraph
+from .multidigraph import MultiDiGraph
+from .ordered import *
+
+from .function import *
+
+from networkx.classes import filters
+
+from networkx.classes import coreviews
+from networkx.classes import graphviews
+from networkx.classes import reportviews
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/coreviews.py b/myenv/lib/python3.9/site-packages/networkx/classes/coreviews.py
new file mode 100644
index 0000000..6c5b8a4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/coreviews.py
@@ -0,0 +1,482 @@
+"""Views of core data structures such as nested Mappings (e.g. dict-of-dicts).
+These ``Views`` often restrict element access, with either the entire view or
+layers of nested mappings being read-only.
+"""
+import warnings
+from collections.abc import Mapping
+
+__all__ = [
+    "AtlasView",
+    "AdjacencyView",
+    "MultiAdjacencyView",
+    "UnionAtlas",
+    "UnionAdjacency",
+    "UnionMultiInner",
+    "UnionMultiAdjacency",
+    "FilterAtlas",
+    "FilterAdjacency",
+    "FilterMultiInner",
+    "FilterMultiAdjacency",
+]
+
+
+class AtlasView(Mapping):
+    """An AtlasView is a Read-only Mapping of Mappings.
+
+    It is a View into a dict-of-dict data structure.
+    The inner level of dict is read-write. But the
+    outer level is read-only.
+
+    See Also
+    ========
+    AdjacencyView: View into dict-of-dict-of-dict
+    MultiAdjacencyView: View into dict-of-dict-of-dict-of-dict
+    """
+
+    __slots__ = ("_atlas",)
+
+    def __getstate__(self):
+        return {"_atlas": self._atlas}
+
+    def __setstate__(self, state):
+        self._atlas = state["_atlas"]
+
+    def __init__(self, d):
+        self._atlas = d
+
+    def __len__(self):
+        return len(self._atlas)
+
+    def __iter__(self):
+        return iter(self._atlas)
+
+    def __getitem__(self, key):
+        return self._atlas[key]
+
+    def copy(self):
+        return {n: self[n].copy() for n in self._atlas}
+
+    def __str__(self):
+        return str(self._atlas)  # {nbr: self[nbr] for nbr in self})
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self._atlas!r})"
+
+
+class AdjacencyView(AtlasView):
+    """An AdjacencyView is a Read-only Map of Maps of Maps.
+
+    It is a View into a dict-of-dict-of-dict data structure.
+    The inner level of dict is read-write. But the
+    outer levels are read-only.
+
+    See Also
+    ========
+    AtlasView: View into dict-of-dict
+    MultiAdjacencyView: View into dict-of-dict-of-dict-of-dict
+    """
+
+    __slots__ = ()  # Still uses AtlasView slots names _atlas
+
+    def __getitem__(self, name):
+        return AtlasView(self._atlas[name])
+
+    def copy(self):
+        return {n: self[n].copy() for n in self._atlas}
+
+
+class MultiAdjacencyView(AdjacencyView):
+    """An MultiAdjacencyView is a Read-only Map of Maps of Maps of Maps.
+
+    It is a View into a dict-of-dict-of-dict-of-dict data structure.
+    The inner level of dict is read-write. But the
+    outer levels are read-only.
+
+    See Also
+    ========
+    AtlasView: View into dict-of-dict
+    AdjacencyView: View into dict-of-dict-of-dict
+    """
+
+    __slots__ = ()  # Still uses AtlasView slots names _atlas
+
+    def __getitem__(self, name):
+        return AdjacencyView(self._atlas[name])
+
+    def copy(self):
+        return {n: self[n].copy() for n in self._atlas}
+
+
+class UnionAtlas(Mapping):
+    """A read-only union of two atlases (dict-of-dict).
+
+    The two dict-of-dicts represent the inner dict of
+    an Adjacency:  `G.succ[node]` and `G.pred[node]`.
+    The inner level of dict of both hold attribute key:value
+    pairs and is read-write. But the outer level is read-only.
+
+    See Also
+    ========
+    UnionAdjacency: View into dict-of-dict-of-dict
+    UnionMultiAdjacency: View into dict-of-dict-of-dict-of-dict
+    """
+
+    __slots__ = ("_succ", "_pred")
+
+    def __getstate__(self):
+        return {"_succ": self._succ, "_pred": self._pred}
+
+    def __setstate__(self, state):
+        self._succ = state["_succ"]
+        self._pred = state["_pred"]
+
+    def __init__(self, succ, pred):
+        self._succ = succ
+        self._pred = pred
+
+    def __len__(self):
+        return len(self._succ) + len(self._pred)
+
+    def __iter__(self):
+        return iter(set(self._succ.keys()) | set(self._pred.keys()))
+
+    def __getitem__(self, key):
+        try:
+            return self._succ[key]
+        except KeyError:
+            return self._pred[key]
+
+    def copy(self):
+        result = {nbr: dd.copy() for nbr, dd in self._succ.items()}
+        for nbr, dd in self._pred.items():
+            if nbr in result:
+                result[nbr].update(dd)
+            else:
+                result[nbr] = dd.copy()
+        return result
+
+    def __str__(self):
+        return str({nbr: self[nbr] for nbr in self})
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self._succ!r}, {self._pred!r})"
+
+
+class UnionAdjacency(Mapping):
+    """A read-only union of dict Adjacencies as a Map of Maps of Maps.
+
+    The two input dict-of-dict-of-dicts represent the union of
+    `G.succ` and `G.pred`. Return values are UnionAtlas
+    The inner level of dict is read-write. But the
+    middle and outer levels are read-only.
+
+    succ : a dict-of-dict-of-dict {node: nbrdict}
+    pred : a dict-of-dict-of-dict {node: nbrdict}
+    The keys for the two dicts should be the same
+
+    See Also
+    ========
+    UnionAtlas: View into dict-of-dict
+    UnionMultiAdjacency: View into dict-of-dict-of-dict-of-dict
+    """
+
+    __slots__ = ("_succ", "_pred")
+
+    def __getstate__(self):
+        return {"_succ": self._succ, "_pred": self._pred}
+
+    def __setstate__(self, state):
+        self._succ = state["_succ"]
+        self._pred = state["_pred"]
+
+    def __init__(self, succ, pred):
+        # keys must be the same for two input dicts
+        assert len(set(succ.keys()) ^ set(pred.keys())) == 0
+        self._succ = succ
+        self._pred = pred
+
+    def __len__(self):
+        return len(self._succ)  # length of each dict should be the same
+
+    def __iter__(self):
+        return iter(self._succ)
+
+    def __getitem__(self, nbr):
+        return UnionAtlas(self._succ[nbr], self._pred[nbr])
+
+    def copy(self):
+        return {n: self[n].copy() for n in self._succ}
+
+    def __str__(self):
+        return str({nbr: self[nbr] for nbr in self})
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self._succ!r}, {self._pred!r})"
+
+
+class UnionMultiInner(UnionAtlas):
+    """A read-only union of two inner dicts of MultiAdjacencies.
+
+    The two input dict-of-dict-of-dicts represent the union of
+    `G.succ[node]` and `G.pred[node]` for MultiDiGraphs.
+    Return values are UnionAtlas.
+    The inner level of dict is read-write. But the outer levels are read-only.
+
+    See Also
+    ========
+    UnionAtlas: View into dict-of-dict
+    UnionAdjacency:  View into dict-of-dict-of-dict
+    UnionMultiAdjacency:  View into dict-of-dict-of-dict-of-dict
+    """
+
+    __slots__ = ()  # Still uses UnionAtlas slots names _succ, _pred
+
+    def __getitem__(self, node):
+        in_succ = node in self._succ
+        in_pred = node in self._pred
+        if in_succ:
+            if in_pred:
+                return UnionAtlas(self._succ[node], self._pred[node])
+            return UnionAtlas(self._succ[node], {})
+        return UnionAtlas({}, self._pred[node])
+
+    def copy(self):
+        nodes = set(self._succ.keys()) | set(self._pred.keys())
+        return {n: self[n].copy() for n in nodes}
+
+
+class UnionMultiAdjacency(UnionAdjacency):
+    """A read-only union of two dict MultiAdjacencies.
+
+    The two input dict-of-dict-of-dict-of-dicts represent the union of
+    `G.succ` and `G.pred` for MultiDiGraphs. Return values are UnionAdjacency.
+    The inner level of dict is read-write. But the outer levels are read-only.
+
+    See Also
+    ========
+    UnionAtlas:  View into dict-of-dict
+    UnionMultiInner:  View into dict-of-dict-of-dict
+    """
+
+    __slots__ = ()  # Still uses UnionAdjacency slots names _succ, _pred
+
+    def __getitem__(self, node):
+        return UnionMultiInner(self._succ[node], self._pred[node])
+
+
+class FilterAtlas(Mapping):  # nodedict, nbrdict, keydict
+    def __init__(self, d, NODE_OK):
+        self._atlas = d
+        self.NODE_OK = NODE_OK
+
+    def __len__(self):
+        return sum(1 for n in self)
+
+    def __iter__(self):
+        try:  # check that NODE_OK has attr 'nodes'
+            node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas)
+        except AttributeError:
+            node_ok_shorter = False
+        if node_ok_shorter:
+            return (n for n in self.NODE_OK.nodes if n in self._atlas)
+        return (n for n in self._atlas if self.NODE_OK(n))
+
+    def __getitem__(self, key):
+        if key in self._atlas and self.NODE_OK(key):
+            return self._atlas[key]
+        raise KeyError(f"Key {key} not found")
+
+    # FIXME should this just be removed? we don't use it, but someone might
+    def copy(self):
+        warnings.warn(
+            (
+                "FilterAtlas.copy is deprecated.\n"
+                "It will be removed in NetworkX 3.0.\n"
+                "Please open an Issue on https://github.com/networkx/networkx/issues\n"
+                "if you use this feature. We think that no one does use it."
+            ),
+            DeprecationWarning,
+        )
+        try:  # check that NODE_OK has attr 'nodes'
+            node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas)
+        except AttributeError:
+            node_ok_shorter = False
+        if node_ok_shorter:
+            return {u: self._atlas[u] for u in self.NODE_OK.nodes if u in self._atlas}
+        return {u: d for u, d in self._atlas.items() if self.NODE_OK(u)}
+
+    def __str__(self):
+        return str({nbr: self[nbr] for nbr in self})
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self._atlas!r}, {self.NODE_OK!r})"
+
+
+class FilterAdjacency(Mapping):  # edgedict
+    def __init__(self, d, NODE_OK, EDGE_OK):
+        self._atlas = d
+        self.NODE_OK = NODE_OK
+        self.EDGE_OK = EDGE_OK
+
+    def __len__(self):
+        return sum(1 for n in self)
+
+    def __iter__(self):
+        try:  # check that NODE_OK has attr 'nodes'
+            node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas)
+        except AttributeError:
+            node_ok_shorter = False
+        if node_ok_shorter:
+            return (n for n in self.NODE_OK.nodes if n in self._atlas)
+        return (n for n in self._atlas if self.NODE_OK(n))
+
+    def __getitem__(self, node):
+        if node in self._atlas and self.NODE_OK(node):
+
+            def new_node_ok(nbr):
+                return self.NODE_OK(nbr) and self.EDGE_OK(node, nbr)
+
+            return FilterAtlas(self._atlas[node], new_node_ok)
+        raise KeyError(f"Key {node} not found")
+
+    # FIXME should this just be removed? we don't use it, but someone might
+    def copy(self):
+        warnings.warn(
+            (
+                "FilterAdjacency.copy is deprecated.\n"
+                "It will be removed in NetworkX 3.0.\n"
+                "Please open an Issue on https://github.com/networkx/networkx/issues\n"
+                "if you use this feature. We think that no one does use it."
+            ),
+            DeprecationWarning,
+        )
+        try:  # check that NODE_OK has attr 'nodes'
+            node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas)
+        except AttributeError:
+            node_ok_shorter = False
+        if node_ok_shorter:
+            return {
+                u: {
+                    v: d
+                    for v, d in self._atlas[u].items()
+                    if self.NODE_OK(v)
+                    if self.EDGE_OK(u, v)
+                }
+                for u in self.NODE_OK.nodes
+                if u in self._atlas
+            }
+        return {
+            u: {v: d for v, d in nbrs.items() if self.NODE_OK(v) if self.EDGE_OK(u, v)}
+            for u, nbrs in self._atlas.items()
+            if self.NODE_OK(u)
+        }
+
+    def __str__(self):
+        return str({nbr: self[nbr] for nbr in self})
+
+    def __repr__(self):
+        name = self.__class__.__name__
+        return f"{name}({self._atlas!r}, {self.NODE_OK!r}, {self.EDGE_OK!r})"
+
+
+class FilterMultiInner(FilterAdjacency):  # muliedge_seconddict
+    def __iter__(self):
+        try:  # check that NODE_OK has attr 'nodes'
+            node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas)
+        except AttributeError:
+            node_ok_shorter = False
+        if node_ok_shorter:
+            my_nodes = (n for n in self.NODE_OK.nodes if n in self._atlas)
+        else:
+            my_nodes = (n for n in self._atlas if self.NODE_OK(n))
+        for n in my_nodes:
+            some_keys_ok = False
+            for key in self._atlas[n]:
+                if self.EDGE_OK(n, key):
+                    some_keys_ok = True
+                    break
+            if some_keys_ok is True:
+                yield n
+
+    def __getitem__(self, nbr):
+        if nbr in self._atlas and self.NODE_OK(nbr):
+
+            def new_node_ok(key):
+                return self.EDGE_OK(nbr, key)
+
+            return FilterAtlas(self._atlas[nbr], new_node_ok)
+        raise KeyError(f"Key {nbr} not found")
+
+    # FIXME should this just be removed? we don't use it, but someone might
+    def copy(self):
+        warnings.warn(
+            (
+                "FilterMultiInner.copy is deprecated.\n"
+                "It will be removed in NetworkX 3.0.\n"
+                "Please open an Issue on https://github.com/networkx/networkx/issues\n"
+                "if you use this feature. We think that no one does use it."
+            ),
+            DeprecationWarning,
+        )
+        try:  # check that NODE_OK has attr 'nodes'
+            node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas)
+        except AttributeError:
+            node_ok_shorter = False
+        if node_ok_shorter:
+            return {
+                v: {k: d for k, d in self._atlas[v].items() if self.EDGE_OK(v, k)}
+                for v in self.NODE_OK.nodes
+                if v in self._atlas
+            }
+        return {
+            v: {k: d for k, d in nbrs.items() if self.EDGE_OK(v, k)}
+            for v, nbrs in self._atlas.items()
+            if self.NODE_OK(v)
+        }
+
+
+class FilterMultiAdjacency(FilterAdjacency):  # multiedgedict
+    def __getitem__(self, node):
+        if node in self._atlas and self.NODE_OK(node):
+
+            def edge_ok(nbr, key):
+                return self.NODE_OK(nbr) and self.EDGE_OK(node, nbr, key)
+
+            return FilterMultiInner(self._atlas[node], self.NODE_OK, edge_ok)
+        raise KeyError(f"Key {node} not found")
+
+    # FIXME should this just be removed? we don't use it, but someone might
+    def copy(self):
+        warnings.warn(
+            (
+                "FilterMultiAdjacency.copy is deprecated.\n"
+                "It will be removed in NetworkX 3.0.\n"
+                "Please open an Issue on https://github.com/networkx/networkx/issues\n"
+                "if you use this feature. We think that no one does use it."
+            ),
+            DeprecationWarning,
+        )
+        try:  # check that NODE_OK has attr 'nodes'
+            node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas)
+        except AttributeError:
+            node_ok_shorter = False
+        if node_ok_shorter:
+            my_nodes = self.NODE_OK.nodes
+            return {
+                u: {
+                    v: {k: d for k, d in kd.items() if self.EDGE_OK(u, v, k)}
+                    for v, kd in self._atlas[u].items()
+                    if v in my_nodes
+                }
+                for u in my_nodes
+                if u in self._atlas
+            }
+        return {
+            u: {
+                v: {k: d for k, d in kd.items() if self.EDGE_OK(u, v, k)}
+                for v, kd in nbrs.items()
+                if self.NODE_OK(v)
+            }
+            for u, nbrs in self._atlas.items()
+            if self.NODE_OK(u)
+        }
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/digraph.py b/myenv/lib/python3.9/site-packages/networkx/classes/digraph.py
new file mode 100644
index 0000000..9528a15
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/digraph.py
@@ -0,0 +1,1269 @@
+"""Base class for directed graphs."""
+from copy import deepcopy
+from functools import cached_property
+
+import networkx as nx
+import networkx.convert as convert
+from networkx.classes.coreviews import AdjacencyView
+from networkx.classes.graph import Graph
+from networkx.classes.reportviews import (
+    DiDegreeView,
+    InDegreeView,
+    InEdgeView,
+    OutDegreeView,
+    OutEdgeView,
+)
+from networkx.exception import NetworkXError
+
+__all__ = ["DiGraph"]
+
+
+class _CachedPropertyResetterAdjAndSucc:
+    """Data Descriptor class that syncs and resets cached properties adj and succ
+
+    The cached properties `adj` and `succ` are reset whenever `_adj` or `_succ`
+    are set to new objects. In addition, the attributes `_succ` and `_adj`
+    are synced so these two names point to the same object.
+
+    This object sits on a class and ensures that any instance of that
+    class clears its cached properties "succ" and "adj" whenever the
+    underlying instance attributes "_succ" or "_adj" are set to a new object.
+    It only affects the set process of the obj._adj and obj._succ attribute.
+    All get/del operations act as they normally would.
+
+    For info on Data Descriptors see: https://docs.python.org/3/howto/descriptor.html
+    """
+
+    def __set__(self, obj, value):
+        od = obj.__dict__
+        od["_adj"] = value
+        od["_succ"] = value
+        # reset cached properties
+        if "adj" in od:
+            del od["adj"]
+        if "succ" in od:
+            del od["succ"]
+
+
+class _CachedPropertyResetterPred:
+    """Data Descriptor class for _pred that resets ``pred`` cached_property when needed
+
+    This assumes that the ``cached_property`` ``G.pred`` should be reset whenever
+    ``G._pred`` is set to a new value.
+
+    This object sits on a class and ensures that any instance of that
+    class clears its cached property "pred" whenever the underlying
+    instance attribute "_pred" is set to a new object. It only affects
+    the set process of the obj._pred attribute. All get/del operations
+    act as they normally would.
+
+    For info on Data Descriptors see: https://docs.python.org/3/howto/descriptor.html
+    """
+
+    def __set__(self, obj, value):
+        od = obj.__dict__
+        od["_pred"] = value
+        if "pred" in od:
+            del od["pred"]
+
+
+class DiGraph(Graph):
+    """
+    Base class for directed graphs.
+
+    A DiGraph stores nodes and edges with optional data, or attributes.
+
+    DiGraphs hold directed edges.  Self loops are allowed but multiple
+    (parallel) edges are not.
+
+    Nodes can be arbitrary (hashable) Python objects with optional
+    key/value attributes. By convention `None` is not used as a node.
+
+    Edges are represented as links between nodes with optional
+    key/value attributes.
+
+    Parameters
+    ----------
+    incoming_graph_data : input graph (optional, default: None)
+        Data to initialize graph. If None (default) an empty
+        graph is created.  The data can be any format that is supported
+        by the to_networkx_graph() function, currently including edge list,
+        dict of dicts, dict of lists, NetworkX graph, 2D NumPy array, SciPy
+        sparse matrix, or PyGraphviz graph.
+
+    attr : keyword arguments, optional (default= no attributes)
+        Attributes to add to graph as key=value pairs.
+
+    See Also
+    --------
+    Graph
+    MultiGraph
+    MultiDiGraph
+    OrderedDiGraph
+
+    Examples
+    --------
+    Create an empty graph structure (a "null graph") with no nodes and
+    no edges.
+
+    >>> G = nx.DiGraph()
+
+    G can be grown in several ways.
+
+    **Nodes:**
+
+    Add one node at a time:
+
+    >>> G.add_node(1)
+
+    Add the nodes from any container (a list, dict, set or
+    even the lines from a file or the nodes from another graph).
+
+    >>> G.add_nodes_from([2, 3])
+    >>> G.add_nodes_from(range(100, 110))
+    >>> H = nx.path_graph(10)
+    >>> G.add_nodes_from(H)
+
+    In addition to strings and integers any hashable Python object
+    (except None) can represent a node, e.g. a customized node object,
+    or even another Graph.
+
+    >>> G.add_node(H)
+
+    **Edges:**
+
+    G can also be grown by adding edges.
+
+    Add one edge,
+
+    >>> G.add_edge(1, 2)
+
+    a list of edges,
+
+    >>> G.add_edges_from([(1, 2), (1, 3)])
+
+    or a collection of edges,
+
+    >>> G.add_edges_from(H.edges)
+
+    If some edges connect nodes not yet in the graph, the nodes
+    are added automatically.  There are no errors when adding
+    nodes or edges that already exist.
+
+    **Attributes:**
+
+    Each graph, node, and edge can hold key/value attribute pairs
+    in an associated attribute dictionary (the keys must be hashable).
+    By default these are empty, but can be added or changed using
+    add_edge, add_node or direct manipulation of the attribute
+    dictionaries named graph, node and edge respectively.
+
+    >>> G = nx.DiGraph(day="Friday")
+    >>> G.graph
+    {'day': 'Friday'}
+
+    Add node attributes using add_node(), add_nodes_from() or G.nodes
+
+    >>> G.add_node(1, time="5pm")
+    >>> G.add_nodes_from([3], time="2pm")
+    >>> G.nodes[1]
+    {'time': '5pm'}
+    >>> G.nodes[1]["room"] = 714
+    >>> del G.nodes[1]["room"]  # remove attribute
+    >>> list(G.nodes(data=True))
+    [(1, {'time': '5pm'}), (3, {'time': '2pm'})]
+
+    Add edge attributes using add_edge(), add_edges_from(), subscript
+    notation, or G.edges.
+
+    >>> G.add_edge(1, 2, weight=4.7)
+    >>> G.add_edges_from([(3, 4), (4, 5)], color="red")
+    >>> G.add_edges_from([(1, 2, {"color": "blue"}), (2, 3, {"weight": 8})])
+    >>> G[1][2]["weight"] = 4.7
+    >>> G.edges[1, 2]["weight"] = 4
+
+    Warning: we protect the graph data structure by making `G.edges[1, 2]` a
+    read-only dict-like structure. However, you can assign to attributes
+    in e.g. `G.edges[1, 2]`. Thus, use 2 sets of brackets to add/change
+    data attributes: `G.edges[1, 2]['weight'] = 4`
+    (For multigraphs: `MG.edges[u, v, key][name] = value`).
+
+    **Shortcuts:**
+
+    Many common graph features allow python syntax to speed reporting.
+
+    >>> 1 in G  # check if node in graph
+    True
+    >>> [n for n in G if n < 3]  # iterate through nodes
+    [1, 2]
+    >>> len(G)  # number of nodes in graph
+    5
+
+    Often the best way to traverse all edges of a graph is via the neighbors.
+    The neighbors are reported as an adjacency-dict `G.adj` or `G.adjacency()`
+
+    >>> for n, nbrsdict in G.adjacency():
+    ...     for nbr, eattr in nbrsdict.items():
+    ...         if "weight" in eattr:
+    ...             # Do something useful with the edges
+    ...             pass
+
+    But the edges reporting object is often more convenient:
+
+    >>> for u, v, weight in G.edges(data="weight"):
+    ...     if weight is not None:
+    ...         # Do something useful with the edges
+    ...         pass
+
+    **Reporting:**
+
+    Simple graph information is obtained using object-attributes and methods.
+    Reporting usually provides views instead of containers to reduce memory
+    usage. The views update as the graph is updated similarly to dict-views.
+    The objects `nodes`, `edges` and `adj` provide access to data attributes
+    via lookup (e.g. `nodes[n]`, `edges[u, v]`, `adj[u][v]`) and iteration
+    (e.g. `nodes.items()`, `nodes.data('color')`,
+    `nodes.data('color', default='blue')` and similarly for `edges`)
+    Views exist for `nodes`, `edges`, `neighbors()`/`adj` and `degree`.
+
+    For details on these and other miscellaneous methods, see below.
+
+    **Subclasses (Advanced):**
+
+    The Graph class uses a dict-of-dict-of-dict data structure.
+    The outer dict (node_dict) holds adjacency information keyed by node.
+    The next dict (adjlist_dict) represents the adjacency information and holds
+    edge data keyed by neighbor.  The inner dict (edge_attr_dict) represents
+    the edge data and holds edge attribute values keyed by attribute names.
+
+    Each of these three dicts can be replaced in a subclass by a user defined
+    dict-like object. In general, the dict-like features should be
+    maintained but extra features can be added. To replace one of the
+    dicts create a new graph class by changing the class(!) variable
+    holding the factory for that dict-like structure. The variable names are
+    node_dict_factory, node_attr_dict_factory, adjlist_inner_dict_factory,
+    adjlist_outer_dict_factory, edge_attr_dict_factory and graph_attr_dict_factory.
+
+    node_dict_factory : function, (default: dict)
+        Factory function to be used to create the dict containing node
+        attributes, keyed by node id.
+        It should require no arguments and return a dict-like object
+
+    node_attr_dict_factory: function, (default: dict)
+        Factory function to be used to create the node attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object
+
+    adjlist_outer_dict_factory : function, (default: dict)
+        Factory function to be used to create the outer-most dict
+        in the data structure that holds adjacency info keyed by node.
+        It should require no arguments and return a dict-like object.
+
+    adjlist_inner_dict_factory : function, optional (default: dict)
+        Factory function to be used to create the adjacency list
+        dict which holds edge data keyed by neighbor.
+        It should require no arguments and return a dict-like object
+
+    edge_attr_dict_factory : function, optional (default: dict)
+        Factory function to be used to create the edge attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object.
+
+    graph_attr_dict_factory : function, (default: dict)
+        Factory function to be used to create the graph attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object.
+
+    Typically, if your extension doesn't impact the data structure all
+    methods will inherited without issue except: `to_directed/to_undirected`.
+    By default these methods create a DiGraph/Graph class and you probably
+    want them to create your extension of a DiGraph/Graph. To facilitate
+    this we define two class variables that you can set in your subclass.
+
+    to_directed_class : callable, (default: DiGraph or MultiDiGraph)
+        Class to create a new graph structure in the `to_directed` method.
+        If `None`, a NetworkX class (DiGraph or MultiDiGraph) is used.
+
+    to_undirected_class : callable, (default: Graph or MultiGraph)
+        Class to create a new graph structure in the `to_undirected` method.
+        If `None`, a NetworkX class (Graph or MultiGraph) is used.
+
+    **Subclassing Example**
+
+    Create a low memory graph class that effectively disallows edge
+    attributes by using a single attribute dict for all edges.
+    This reduces the memory used, but you lose edge attributes.
+
+    >>> class ThinGraph(nx.Graph):
+    ...     all_edge_dict = {"weight": 1}
+    ...
+    ...     def single_edge_dict(self):
+    ...         return self.all_edge_dict
+    ...
+    ...     edge_attr_dict_factory = single_edge_dict
+    >>> G = ThinGraph()
+    >>> G.add_edge(2, 1)
+    >>> G[2][1]
+    {'weight': 1}
+    >>> G.add_edge(2, 2)
+    >>> G[2][1] is G[2][2]
+    True
+
+
+    Please see :mod:`~networkx.classes.ordered` for more examples of
+    creating graph subclasses by overwriting the base class `dict` with
+    a dictionary-like object.
+    """
+
+    _adj = _CachedPropertyResetterAdjAndSucc()  # type: ignore
+    _succ = _adj  # type: ignore
+    _pred = _CachedPropertyResetterPred()
+
+    def __init__(self, incoming_graph_data=None, **attr):
+        """Initialize a graph with edges, name, or graph attributes.
+
+        Parameters
+        ----------
+        incoming_graph_data : input graph (optional, default: None)
+            Data to initialize graph.  If None (default) an empty
+            graph is created.  The data can be an edge list, or any
+            NetworkX graph object.  If the corresponding optional Python
+            packages are installed the data can also be a 2D NumPy array, a
+            SciPy sparse matrix, or a PyGraphviz graph.
+
+        attr : keyword arguments, optional (default= no attributes)
+            Attributes to add to graph as key=value pairs.
+
+        See Also
+        --------
+        convert
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G = nx.Graph(name="my graph")
+        >>> e = [(1, 2), (2, 3), (3, 4)]  # list of edges
+        >>> G = nx.Graph(e)
+
+        Arbitrary graph attribute pairs (key=value) may be assigned
+
+        >>> G = nx.Graph(e, day="Friday")
+        >>> G.graph
+        {'day': 'Friday'}
+
+        """
+        self.graph = self.graph_attr_dict_factory()  # dictionary for graph attributes
+        self._node = self.node_dict_factory()  # dictionary for node attr
+        # We store two adjacency lists:
+        # the predecessors of node n are stored in the dict self._pred
+        # the successors of node n are stored in the dict self._succ=self._adj
+        self._adj = self.adjlist_outer_dict_factory()  # empty adjacency dict successor
+        self._pred = self.adjlist_outer_dict_factory()  # predecessor
+        # Note: self._succ = self._adj  # successor
+
+        # attempt to load graph with data
+        if incoming_graph_data is not None:
+            convert.to_networkx_graph(incoming_graph_data, create_using=self)
+        # load graph attributes (must be after convert)
+        self.graph.update(attr)
+
+    @cached_property
+    def adj(self):
+        """Graph adjacency object holding the neighbors of each node.
+
+        This object is a read-only dict-like structure with node keys
+        and neighbor-dict values.  The neighbor-dict is keyed by neighbor
+        to the edge-data-dict.  So `G.adj[3][2]['color'] = 'blue'` sets
+        the color of the edge `(3, 2)` to `"blue"`.
+
+        Iterating over G.adj behaves like a dict. Useful idioms include
+        `for nbr, datadict in G.adj[n].items():`.
+
+        The neighbor information is also provided by subscripting the graph.
+        So `for nbr, foovalue in G[node].data('foo', default=1):` works.
+
+        For directed graphs, `G.adj` holds outgoing (successor) info.
+        """
+        return AdjacencyView(self._succ)
+
+    @cached_property
+    def succ(self):
+        """Graph adjacency object holding the successors of each node.
+
+        This object is a read-only dict-like structure with node keys
+        and neighbor-dict values.  The neighbor-dict is keyed by neighbor
+        to the edge-data-dict.  So `G.succ[3][2]['color'] = 'blue'` sets
+        the color of the edge `(3, 2)` to `"blue"`.
+
+        Iterating over G.succ behaves like a dict. Useful idioms include
+        `for nbr, datadict in G.succ[n].items():`.  A data-view not provided
+        by dicts also exists: `for nbr, foovalue in G.succ[node].data('foo'):`
+        and a default can be set via a `default` argument to the `data` method.
+
+        The neighbor information is also provided by subscripting the graph.
+        So `for nbr, foovalue in G[node].data('foo', default=1):` works.
+
+        For directed graphs, `G.adj` is identical to `G.succ`.
+        """
+        return AdjacencyView(self._succ)
+
+    @cached_property
+    def pred(self):
+        """Graph adjacency object holding the predecessors of each node.
+
+        This object is a read-only dict-like structure with node keys
+        and neighbor-dict values.  The neighbor-dict is keyed by neighbor
+        to the edge-data-dict.  So `G.pred[2][3]['color'] = 'blue'` sets
+        the color of the edge `(3, 2)` to `"blue"`.
+
+        Iterating over G.pred behaves like a dict. Useful idioms include
+        `for nbr, datadict in G.pred[n].items():`.  A data-view not provided
+        by dicts also exists: `for nbr, foovalue in G.pred[node].data('foo'):`
+        A default can be set via a `default` argument to the `data` method.
+        """
+        return AdjacencyView(self._pred)
+
+    def add_node(self, node_for_adding, **attr):
+        """Add a single node `node_for_adding` and update node attributes.
+
+        Parameters
+        ----------
+        node_for_adding : node
+            A node can be any hashable Python object except None.
+        attr : keyword arguments, optional
+            Set or change node attributes using key=value.
+
+        See Also
+        --------
+        add_nodes_from
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.add_node(1)
+        >>> G.add_node("Hello")
+        >>> K3 = nx.Graph([(0, 1), (1, 2), (2, 0)])
+        >>> G.add_node(K3)
+        >>> G.number_of_nodes()
+        3
+
+        Use keywords set/change node attributes:
+
+        >>> G.add_node(1, size=10)
+        >>> G.add_node(3, weight=0.4, UTM=("13S", 382871, 3972649))
+
+        Notes
+        -----
+        A hashable object is one that can be used as a key in a Python
+        dictionary. This includes strings, numbers, tuples of strings
+        and numbers, etc.
+
+        On many platforms hashable items also include mutables such as
+        NetworkX Graphs, though one should be careful that the hash
+        doesn't change on mutables.
+        """
+        if node_for_adding not in self._succ:
+            if node_for_adding is None:
+                raise ValueError("None cannot be a node")
+            self._succ[node_for_adding] = self.adjlist_inner_dict_factory()
+            self._pred[node_for_adding] = self.adjlist_inner_dict_factory()
+            attr_dict = self._node[node_for_adding] = self.node_attr_dict_factory()
+            attr_dict.update(attr)
+        else:  # update attr even if node already exists
+            self._node[node_for_adding].update(attr)
+
+    def add_nodes_from(self, nodes_for_adding, **attr):
+        """Add multiple nodes.
+
+        Parameters
+        ----------
+        nodes_for_adding : iterable container
+            A container of nodes (list, dict, set, etc.).
+            OR
+            A container of (node, attribute dict) tuples.
+            Node attributes are updated using the attribute dict.
+        attr : keyword arguments, optional (default= no attributes)
+            Update attributes for all nodes in nodes.
+            Node attributes specified in nodes as a tuple take
+            precedence over attributes specified via keyword arguments.
+
+        See Also
+        --------
+        add_node
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.add_nodes_from("Hello")
+        >>> K3 = nx.Graph([(0, 1), (1, 2), (2, 0)])
+        >>> G.add_nodes_from(K3)
+        >>> sorted(G.nodes(), key=str)
+        [0, 1, 2, 'H', 'e', 'l', 'o']
+
+        Use keywords to update specific node attributes for every node.
+
+        >>> G.add_nodes_from([1, 2], size=10)
+        >>> G.add_nodes_from([3, 4], weight=0.4)
+
+        Use (node, attrdict) tuples to update attributes for specific nodes.
+
+        >>> G.add_nodes_from([(1, dict(size=11)), (2, {"color": "blue"})])
+        >>> G.nodes[1]["size"]
+        11
+        >>> H = nx.Graph()
+        >>> H.add_nodes_from(G.nodes(data=True))
+        >>> H.nodes[1]["size"]
+        11
+
+        """
+        for n in nodes_for_adding:
+            try:
+                newnode = n not in self._node
+                newdict = attr
+            except TypeError:
+                n, ndict = n
+                newnode = n not in self._node
+                newdict = attr.copy()
+                newdict.update(ndict)
+            if newnode:
+                if n is None:
+                    raise ValueError("None cannot be a node")
+                self._succ[n] = self.adjlist_inner_dict_factory()
+                self._pred[n] = self.adjlist_inner_dict_factory()
+                self._node[n] = self.node_attr_dict_factory()
+            self._node[n].update(newdict)
+
+    def remove_node(self, n):
+        """Remove node n.
+
+        Removes the node n and all adjacent edges.
+        Attempting to remove a non-existent node will raise an exception.
+
+        Parameters
+        ----------
+        n : node
+           A node in the graph
+
+        Raises
+        ------
+        NetworkXError
+           If n is not in the graph.
+
+        See Also
+        --------
+        remove_nodes_from
+
+        Examples
+        --------
+        >>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> list(G.edges)
+        [(0, 1), (1, 2)]
+        >>> G.remove_node(1)
+        >>> list(G.edges)
+        []
+
+        """
+        try:
+            nbrs = self._succ[n]
+            del self._node[n]
+        except KeyError as err:  # NetworkXError if n not in self
+            raise NetworkXError(f"The node {n} is not in the digraph.") from err
+        for u in nbrs:
+            del self._pred[u][n]  # remove all edges n-u in digraph
+        del self._succ[n]  # remove node from succ
+        for u in self._pred[n]:
+            del self._succ[u][n]  # remove all edges n-u in digraph
+        del self._pred[n]  # remove node from pred
+
+    def remove_nodes_from(self, nodes):
+        """Remove multiple nodes.
+
+        Parameters
+        ----------
+        nodes : iterable container
+            A container of nodes (list, dict, set, etc.).  If a node
+            in the container is not in the graph it is silently ignored.
+
+        See Also
+        --------
+        remove_node
+
+        Examples
+        --------
+        >>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> e = list(G.nodes)
+        >>> e
+        [0, 1, 2]
+        >>> G.remove_nodes_from(e)
+        >>> list(G.nodes)
+        []
+
+        """
+        for n in nodes:
+            try:
+                succs = self._succ[n]
+                del self._node[n]
+                for u in succs:
+                    del self._pred[u][n]  # remove all edges n-u in digraph
+                del self._succ[n]  # now remove node
+                for u in self._pred[n]:
+                    del self._succ[u][n]  # remove all edges n-u in digraph
+                del self._pred[n]  # now remove node
+            except KeyError:
+                pass  # silent failure on remove
+
+    def add_edge(self, u_of_edge, v_of_edge, **attr):
+        """Add an edge between u and v.
+
+        The nodes u and v will be automatically added if they are
+        not already in the graph.
+
+        Edge attributes can be specified with keywords or by directly
+        accessing the edge's attribute dictionary. See examples below.
+
+        Parameters
+        ----------
+        u_of_edge, v_of_edge : nodes
+            Nodes can be, for example, strings or numbers.
+            Nodes must be hashable (and not None) Python objects.
+        attr : keyword arguments, optional
+            Edge data (or labels or objects) can be assigned using
+            keyword arguments.
+
+        See Also
+        --------
+        add_edges_from : add a collection of edges
+
+        Notes
+        -----
+        Adding an edge that already exists updates the edge data.
+
+        Many NetworkX algorithms designed for weighted graphs use
+        an edge attribute (by default `weight`) to hold a numerical value.
+
+        Examples
+        --------
+        The following all add the edge e=(1, 2) to graph G:
+
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> e = (1, 2)
+        >>> G.add_edge(1, 2)  # explicit two-node form
+        >>> G.add_edge(*e)  # single edge as tuple of two nodes
+        >>> G.add_edges_from([(1, 2)])  # add edges from iterable container
+
+        Associate data to edges using keywords:
+
+        >>> G.add_edge(1, 2, weight=3)
+        >>> G.add_edge(1, 3, weight=7, capacity=15, length=342.7)
+
+        For non-string attribute keys, use subscript notation.
+
+        >>> G.add_edge(1, 2)
+        >>> G[1][2].update({0: 5})
+        >>> G.edges[1, 2].update({0: 5})
+        """
+        u, v = u_of_edge, v_of_edge
+        # add nodes
+        if u not in self._succ:
+            if u is None:
+                raise ValueError("None cannot be a node")
+            self._succ[u] = self.adjlist_inner_dict_factory()
+            self._pred[u] = self.adjlist_inner_dict_factory()
+            self._node[u] = self.node_attr_dict_factory()
+        if v not in self._succ:
+            if v is None:
+                raise ValueError("None cannot be a node")
+            self._succ[v] = self.adjlist_inner_dict_factory()
+            self._pred[v] = self.adjlist_inner_dict_factory()
+            self._node[v] = self.node_attr_dict_factory()
+        # add the edge
+        datadict = self._adj[u].get(v, self.edge_attr_dict_factory())
+        datadict.update(attr)
+        self._succ[u][v] = datadict
+        self._pred[v][u] = datadict
+
+    def add_edges_from(self, ebunch_to_add, **attr):
+        """Add all the edges in ebunch_to_add.
+
+        Parameters
+        ----------
+        ebunch_to_add : container of edges
+            Each edge given in the container will be added to the
+            graph. The edges must be given as 2-tuples (u, v) or
+            3-tuples (u, v, d) where d is a dictionary containing edge data.
+        attr : keyword arguments, optional
+            Edge data (or labels or objects) can be assigned using
+            keyword arguments.
+
+        See Also
+        --------
+        add_edge : add a single edge
+        add_weighted_edges_from : convenient way to add weighted edges
+
+        Notes
+        -----
+        Adding the same edge twice has no effect but any edge data
+        will be updated when each duplicate edge is added.
+
+        Edge attributes specified in an ebunch take precedence over
+        attributes specified via keyword arguments.
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.add_edges_from([(0, 1), (1, 2)])  # using a list of edge tuples
+        >>> e = zip(range(0, 3), range(1, 4))
+        >>> G.add_edges_from(e)  # Add the path graph 0-1-2-3
+
+        Associate data to edges
+
+        >>> G.add_edges_from([(1, 2), (2, 3)], weight=3)
+        >>> G.add_edges_from([(3, 4), (1, 4)], label="WN2898")
+        """
+        for e in ebunch_to_add:
+            ne = len(e)
+            if ne == 3:
+                u, v, dd = e
+            elif ne == 2:
+                u, v = e
+                dd = {}
+            else:
+                raise NetworkXError(f"Edge tuple {e} must be a 2-tuple or 3-tuple.")
+            if u not in self._succ:
+                if u is None:
+                    raise ValueError("None cannot be a node")
+                self._succ[u] = self.adjlist_inner_dict_factory()
+                self._pred[u] = self.adjlist_inner_dict_factory()
+                self._node[u] = self.node_attr_dict_factory()
+            if v not in self._succ:
+                if v is None:
+                    raise ValueError("None cannot be a node")
+                self._succ[v] = self.adjlist_inner_dict_factory()
+                self._pred[v] = self.adjlist_inner_dict_factory()
+                self._node[v] = self.node_attr_dict_factory()
+            datadict = self._adj[u].get(v, self.edge_attr_dict_factory())
+            datadict.update(attr)
+            datadict.update(dd)
+            self._succ[u][v] = datadict
+            self._pred[v][u] = datadict
+
+    def remove_edge(self, u, v):
+        """Remove the edge between u and v.
+
+        Parameters
+        ----------
+        u, v : nodes
+            Remove the edge between nodes u and v.
+
+        Raises
+        ------
+        NetworkXError
+            If there is not an edge between u and v.
+
+        See Also
+        --------
+        remove_edges_from : remove a collection of edges
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, etc
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.remove_edge(0, 1)
+        >>> e = (1, 2)
+        >>> G.remove_edge(*e)  # unpacks e from an edge tuple
+        >>> e = (2, 3, {"weight": 7})  # an edge with attribute data
+        >>> G.remove_edge(*e[:2])  # select first part of edge tuple
+        """
+        try:
+            del self._succ[u][v]
+            del self._pred[v][u]
+        except KeyError as err:
+            raise NetworkXError(f"The edge {u}-{v} not in graph.") from err
+
+    def remove_edges_from(self, ebunch):
+        """Remove all edges specified in ebunch.
+
+        Parameters
+        ----------
+        ebunch: list or container of edge tuples
+            Each edge given in the list or container will be removed
+            from the graph. The edges can be:
+
+                - 2-tuples (u, v) edge between u and v.
+                - 3-tuples (u, v, k) where k is ignored.
+
+        See Also
+        --------
+        remove_edge : remove a single edge
+
+        Notes
+        -----
+        Will fail silently if an edge in ebunch is not in the graph.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> ebunch = [(1, 2), (2, 3)]
+        >>> G.remove_edges_from(ebunch)
+        """
+        for e in ebunch:
+            u, v = e[:2]  # ignore edge data
+            if u in self._succ and v in self._succ[u]:
+                del self._succ[u][v]
+                del self._pred[v][u]
+
+    def has_successor(self, u, v):
+        """Returns True if node u has successor v.
+
+        This is true if graph has the edge u->v.
+        """
+        return u in self._succ and v in self._succ[u]
+
+    def has_predecessor(self, u, v):
+        """Returns True if node u has predecessor v.
+
+        This is true if graph has the edge u<-v.
+        """
+        return u in self._pred and v in self._pred[u]
+
+    def successors(self, n):
+        """Returns an iterator over successor nodes of n.
+
+        A successor of n is a node m such that there exists a directed
+        edge from n to m.
+
+        Parameters
+        ----------
+        n : node
+           A node in the graph
+
+        Raises
+        ------
+        NetworkXError
+           If n is not in the graph.
+
+        See Also
+        --------
+        predecessors
+
+        Notes
+        -----
+        neighbors() and successors() are the same.
+        """
+        try:
+            return iter(self._succ[n])
+        except KeyError as err:
+            raise NetworkXError(f"The node {n} is not in the digraph.") from err
+
+    # digraph definitions
+    neighbors = successors
+
+    def predecessors(self, n):
+        """Returns an iterator over predecessor nodes of n.
+
+        A predecessor of n is a node m such that there exists a directed
+        edge from m to n.
+
+        Parameters
+        ----------
+        n : node
+           A node in the graph
+
+        Raises
+        ------
+        NetworkXError
+           If n is not in the graph.
+
+        See Also
+        --------
+        successors
+        """
+        try:
+            return iter(self._pred[n])
+        except KeyError as err:
+            raise NetworkXError(f"The node {n} is not in the digraph.") from err
+
+    @cached_property
+    def edges(self):
+        """An OutEdgeView of the DiGraph as G.edges or G.edges().
+
+        edges(self, nbunch=None, data=False, default=None)
+
+        The OutEdgeView provides set-like operations on the edge-tuples
+        as well as edge attribute lookup. When called, it also provides
+        an EdgeDataView object which allows control of access to edge
+        attributes (but does not provide set-like operations).
+        Hence, `G.edges[u, v]['color']` provides the value of the color
+        attribute for edge `(u, v)` while
+        `for (u, v, c) in G.edges.data('color', default='red'):`
+        iterates through all the edges yielding the color attribute
+        with default `'red'` if no color attribute exists.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges from these nodes.
+        data : string or bool, optional (default=False)
+            The edge attribute returned in 3-tuple (u, v, ddict[data]).
+            If True, return edge attribute dict in 3-tuple (u, v, ddict).
+            If False, return 2-tuple (u, v).
+        default : value, optional (default=None)
+            Value used for edges that don't have the requested attribute.
+            Only relevant if data is not True or False.
+
+        Returns
+        -------
+        edges : OutEdgeView
+            A view of edge attributes, usually it iterates over (u, v)
+            or (u, v, d) tuples of edges, but can also be used for
+            attribute lookup as `edges[u, v]['foo']`.
+
+        See Also
+        --------
+        in_edges, out_edges
+
+        Notes
+        -----
+        Nodes in nbunch that are not in the graph will be (quietly) ignored.
+        For directed graphs this returns the out-edges.
+
+        Examples
+        --------
+        >>> G = nx.DiGraph()  # or MultiDiGraph, etc
+        >>> nx.add_path(G, [0, 1, 2])
+        >>> G.add_edge(2, 3, weight=5)
+        >>> [e for e in G.edges]
+        [(0, 1), (1, 2), (2, 3)]
+        >>> G.edges.data()  # default data is {} (empty dict)
+        OutEdgeDataView([(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})])
+        >>> G.edges.data("weight", default=1)
+        OutEdgeDataView([(0, 1, 1), (1, 2, 1), (2, 3, 5)])
+        >>> G.edges([0, 2])  # only edges originating from these nodes
+        OutEdgeDataView([(0, 1), (2, 3)])
+        >>> G.edges(0)  # only edges from node 0
+        OutEdgeDataView([(0, 1)])
+
+        """
+        return OutEdgeView(self)
+
+    # alias out_edges to edges
+    @cached_property
+    def out_edges(self):
+        return OutEdgeView(self)
+
+    out_edges.__doc__ = edges.__doc__
+
+    @cached_property
+    def in_edges(self):
+        """An InEdgeView of the Graph as G.in_edges or G.in_edges().
+
+        in_edges(self, nbunch=None, data=False, default=None):
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges incident to these nodes.
+        data : string or bool, optional (default=False)
+            The edge attribute returned in 3-tuple (u, v, ddict[data]).
+            If True, return edge attribute dict in 3-tuple (u, v, ddict).
+            If False, return 2-tuple (u, v).
+        default : value, optional (default=None)
+            Value used for edges that don't have the requested attribute.
+            Only relevant if data is not True or False.
+
+        Returns
+        -------
+        in_edges : InEdgeView
+            A view of edge attributes, usually it iterates over (u, v)
+            or (u, v, d) tuples of edges, but can also be used for
+            attribute lookup as `edges[u, v]['foo']`.
+
+        See Also
+        --------
+        edges
+        """
+        return InEdgeView(self)
+
+    @cached_property
+    def degree(self):
+        """A DegreeView for the Graph as G.degree or G.degree().
+
+        The node degree is the number of edges adjacent to the node.
+        The weighted node degree is the sum of the edge weights for
+        edges incident to that node.
+
+        This object provides an iterator for (node, degree) as well as
+        lookup for the degree for a single node.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges incident to these nodes.
+
+        weight : string or None, optional (default=None)
+           The name of an edge attribute that holds the numerical value used
+           as a weight.  If None, then each edge has weight 1.
+           The degree is the sum of the edge weights adjacent to the node.
+
+        Returns
+        -------
+        DiDegreeView or int
+            If multiple nodes are requested (the default), returns a `DiDegreeView`
+            mapping nodes to their degree.
+            If a single node is requested, returns the degree of the node as an integer.
+
+        See Also
+        --------
+        in_degree, out_degree
+
+        Examples
+        --------
+        >>> G = nx.DiGraph()  # or MultiDiGraph
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.degree(0)  # node 0 with degree 1
+        1
+        >>> list(G.degree([0, 1, 2]))
+        [(0, 1), (1, 2), (2, 2)]
+
+        """
+        return DiDegreeView(self)
+
+    @cached_property
+    def in_degree(self):
+        """An InDegreeView for (node, in_degree) or in_degree for single node.
+
+        The node in_degree is the number of edges pointing to the node.
+        The weighted node degree is the sum of the edge weights for
+        edges incident to that node.
+
+        This object provides an iteration over (node, in_degree) as well as
+        lookup for the degree for a single node.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges incident to these nodes.
+
+        weight : string or None, optional (default=None)
+           The name of an edge attribute that holds the numerical value used
+           as a weight.  If None, then each edge has weight 1.
+           The degree is the sum of the edge weights adjacent to the node.
+
+        Returns
+        -------
+        If a single node is requested
+        deg : int
+            In-degree of the node
+
+        OR if multiple nodes are requested
+        nd_iter : iterator
+            The iterator returns two-tuples of (node, in-degree).
+
+        See Also
+        --------
+        degree, out_degree
+
+        Examples
+        --------
+        >>> G = nx.DiGraph()
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.in_degree(0)  # node 0 with degree 0
+        0
+        >>> list(G.in_degree([0, 1, 2]))
+        [(0, 0), (1, 1), (2, 1)]
+
+        """
+        return InDegreeView(self)
+
+    @cached_property
+    def out_degree(self):
+        """An OutDegreeView for (node, out_degree)
+
+        The node out_degree is the number of edges pointing out of the node.
+        The weighted node degree is the sum of the edge weights for
+        edges incident to that node.
+
+        This object provides an iterator over (node, out_degree) as well as
+        lookup for the degree for a single node.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges incident to these nodes.
+
+        weight : string or None, optional (default=None)
+           The name of an edge attribute that holds the numerical value used
+           as a weight.  If None, then each edge has weight 1.
+           The degree is the sum of the edge weights adjacent to the node.
+
+        Returns
+        -------
+        If a single node is requested
+        deg : int
+            Out-degree of the node
+
+        OR if multiple nodes are requested
+        nd_iter : iterator
+            The iterator returns two-tuples of (node, out-degree).
+
+        See Also
+        --------
+        degree, in_degree
+
+        Examples
+        --------
+        >>> G = nx.DiGraph()
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.out_degree(0)  # node 0 with degree 1
+        1
+        >>> list(G.out_degree([0, 1, 2]))
+        [(0, 1), (1, 1), (2, 1)]
+
+        """
+        return OutDegreeView(self)
+
+    def clear(self):
+        """Remove all nodes and edges from the graph.
+
+        This also removes the name, and all graph, node, and edge attributes.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.clear()
+        >>> list(G.nodes)
+        []
+        >>> list(G.edges)
+        []
+
+        """
+        self._succ.clear()
+        self._pred.clear()
+        self._node.clear()
+        self.graph.clear()
+
+    def clear_edges(self):
+        """Remove all edges from the graph without altering nodes.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.clear_edges()
+        >>> list(G.nodes)
+        [0, 1, 2, 3]
+        >>> list(G.edges)
+        []
+
+        """
+        for predecessor_dict in self._pred.values():
+            predecessor_dict.clear()
+        for successor_dict in self._succ.values():
+            successor_dict.clear()
+
+    def is_multigraph(self):
+        """Returns True if graph is a multigraph, False otherwise."""
+        return False
+
+    def is_directed(self):
+        """Returns True if graph is directed, False otherwise."""
+        return True
+
+    def to_undirected(self, reciprocal=False, as_view=False):
+        """Returns an undirected representation of the digraph.
+
+        Parameters
+        ----------
+        reciprocal : bool (optional)
+          If True only keep edges that appear in both directions
+          in the original digraph.
+        as_view : bool (optional, default=False)
+          If True return an undirected view of the original directed graph.
+
+        Returns
+        -------
+        G : Graph
+            An undirected graph with the same name and nodes and
+            with edge (u, v, data) if either (u, v, data) or (v, u, data)
+            is in the digraph.  If both edges exist in digraph and
+            their edge data is different, only one edge is created
+            with an arbitrary choice of which edge data to use.
+            You must check and correct for this manually if desired.
+
+        See Also
+        --------
+        Graph, copy, add_edge, add_edges_from
+
+        Notes
+        -----
+        If edges in both directions (u, v) and (v, u) exist in the
+        graph, attributes for the new undirected edge will be a combination of
+        the attributes of the directed edges.  The edge data is updated
+        in the (arbitrary) order that the edges are encountered.  For
+        more customized control of the edge attributes use add_edge().
+
+        This returns a "deepcopy" of the edge, node, and
+        graph attributes which attempts to completely copy
+        all of the data and references.
+
+        This is in contrast to the similar G=DiGraph(D) which returns a
+        shallow copy of the data.
+
+        See the Python copy module for more information on shallow
+        and deep copies, https://docs.python.org/3/library/copy.html.
+
+        Warning: If you have subclassed DiGraph to use dict-like objects
+        in the data structure, those changes do not transfer to the
+        Graph created by this method.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(2)  # or MultiGraph, etc
+        >>> H = G.to_directed()
+        >>> list(H.edges)
+        [(0, 1), (1, 0)]
+        >>> G2 = H.to_undirected()
+        >>> list(G2.edges)
+        [(0, 1)]
+        """
+        graph_class = self.to_undirected_class()
+        if as_view is True:
+            return nx.graphviews.generic_graph_view(self, graph_class)
+        # deepcopy when not a view
+        G = graph_class()
+        G.graph.update(deepcopy(self.graph))
+        G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
+        if reciprocal is True:
+            G.add_edges_from(
+                (u, v, deepcopy(d))
+                for u, nbrs in self._adj.items()
+                for v, d in nbrs.items()
+                if v in self._pred[u]
+            )
+        else:
+            G.add_edges_from(
+                (u, v, deepcopy(d))
+                for u, nbrs in self._adj.items()
+                for v, d in nbrs.items()
+            )
+        return G
+
+    def reverse(self, copy=True):
+        """Returns the reverse of the graph.
+
+        The reverse is a graph with the same nodes and edges
+        but with the directions of the edges reversed.
+
+        Parameters
+        ----------
+        copy : bool optional (default=True)
+            If True, return a new DiGraph holding the reversed edges.
+            If False, the reverse graph is created using a view of
+            the original graph.
+        """
+        if copy:
+            H = self.__class__()
+            H.graph.update(deepcopy(self.graph))
+            H.add_nodes_from((n, deepcopy(d)) for n, d in self.nodes.items())
+            H.add_edges_from((v, u, deepcopy(d)) for u, v, d in self.edges(data=True))
+            return H
+        return nx.graphviews.reverse_view(self)
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/filters.py b/myenv/lib/python3.9/site-packages/networkx/classes/filters.py
new file mode 100644
index 0000000..aefcbdf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/filters.py
@@ -0,0 +1,75 @@
+"""Filter factories to hide or show sets of nodes and edges.
+
+These filters return the function used when creating `SubGraph`.
+"""
+__all__ = [
+    "no_filter",
+    "hide_nodes",
+    "hide_edges",
+    "hide_multiedges",
+    "hide_diedges",
+    "hide_multidiedges",
+    "show_nodes",
+    "show_edges",
+    "show_multiedges",
+    "show_diedges",
+    "show_multidiedges",
+]
+
+
+def no_filter(*items):
+    return True
+
+
+def hide_nodes(nodes):
+    nodes = set(nodes)
+    return lambda node: node not in nodes
+
+
+def hide_diedges(edges):
+    edges = {(u, v) for u, v in edges}
+    return lambda u, v: (u, v) not in edges
+
+
+def hide_edges(edges):
+    alledges = set(edges) | {(v, u) for (u, v) in edges}
+    return lambda u, v: (u, v) not in alledges
+
+
+def hide_multidiedges(edges):
+    edges = {(u, v, k) for u, v, k in edges}
+    return lambda u, v, k: (u, v, k) not in edges
+
+
+def hide_multiedges(edges):
+    alledges = set(edges) | {(v, u, k) for (u, v, k) in edges}
+    return lambda u, v, k: (u, v, k) not in alledges
+
+
+# write show_nodes as a class to make SubGraph pickleable
+class show_nodes:
+    def __init__(self, nodes):
+        self.nodes = set(nodes)
+
+    def __call__(self, node):
+        return node in self.nodes
+
+
+def show_diedges(edges):
+    edges = {(u, v) for u, v in edges}
+    return lambda u, v: (u, v) in edges
+
+
+def show_edges(edges):
+    alledges = set(edges) | {(v, u) for (u, v) in edges}
+    return lambda u, v: (u, v) in alledges
+
+
+def show_multidiedges(edges):
+    edges = {(u, v, k) for u, v, k in edges}
+    return lambda u, v, k: (u, v, k) in edges
+
+
+def show_multiedges(edges):
+    alledges = set(edges) | {(v, u, k) for (u, v, k) in edges}
+    return lambda u, v, k: (u, v, k) in alledges
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/function.py b/myenv/lib/python3.9/site-packages/networkx/classes/function.py
new file mode 100644
index 0000000..7707ec4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/function.py
@@ -0,0 +1,1311 @@
+"""Functional interface to graph methods and assorted utilities.
+"""
+
+from collections import Counter
+from itertools import chain
+
+import networkx as nx
+from networkx.classes.graphviews import reverse_view, subgraph_view
+from networkx.utils import not_implemented_for, pairwise
+
+__all__ = [
+    "nodes",
+    "edges",
+    "degree",
+    "degree_histogram",
+    "neighbors",
+    "number_of_nodes",
+    "number_of_edges",
+    "density",
+    "is_directed",
+    "info",
+    "freeze",
+    "is_frozen",
+    "subgraph",
+    "subgraph_view",
+    "induced_subgraph",
+    "reverse_view",
+    "edge_subgraph",
+    "restricted_view",
+    "to_directed",
+    "to_undirected",
+    "add_star",
+    "add_path",
+    "add_cycle",
+    "create_empty_copy",
+    "set_node_attributes",
+    "get_node_attributes",
+    "set_edge_attributes",
+    "get_edge_attributes",
+    "all_neighbors",
+    "non_neighbors",
+    "non_edges",
+    "common_neighbors",
+    "is_weighted",
+    "is_negatively_weighted",
+    "is_empty",
+    "selfloop_edges",
+    "nodes_with_selfloops",
+    "number_of_selfloops",
+    "path_weight",
+    "is_path",
+]
+
+
+def nodes(G):
+    """Returns an iterator over the graph nodes."""
+    return G.nodes()
+
+
+def edges(G, nbunch=None):
+    """Returns an edge view of edges incident to nodes in nbunch.
+
+    Return all edges if nbunch is unspecified or nbunch=None.
+
+    For digraphs, edges=out_edges
+    """
+    return G.edges(nbunch)
+
+
+def degree(G, nbunch=None, weight=None):
+    """Returns a degree view of single node or of nbunch of nodes.
+    If nbunch is omitted, then return degrees of *all* nodes.
+    """
+    return G.degree(nbunch, weight)
+
+
+def neighbors(G, n):
+    """Returns a list of nodes connected to node n."""
+    return G.neighbors(n)
+
+
+def number_of_nodes(G):
+    """Returns the number of nodes in the graph."""
+    return G.number_of_nodes()
+
+
+def number_of_edges(G):
+    """Returns the number of edges in the graph."""
+    return G.number_of_edges()
+
+
+def density(G):
+    r"""Returns the density of a graph.
+
+    The density for undirected graphs is
+
+    .. math::
+
+       d = \frac{2m}{n(n-1)},
+
+    and for directed graphs is
+
+    .. math::
+
+       d = \frac{m}{n(n-1)},
+
+    where `n` is the number of nodes and `m`  is the number of edges in `G`.
+
+    Notes
+    -----
+    The density is 0 for a graph without edges and 1 for a complete graph.
+    The density of multigraphs can be higher than 1.
+
+    Self loops are counted in the total number of edges so graphs with self
+    loops can have density higher than 1.
+    """
+    n = number_of_nodes(G)
+    m = number_of_edges(G)
+    if m == 0 or n <= 1:
+        return 0
+    d = m / (n * (n - 1))
+    if not G.is_directed():
+        d *= 2
+    return d
+
+
+def degree_histogram(G):
+    """Returns a list of the frequency of each degree value.
+
+    Parameters
+    ----------
+    G : Networkx graph
+       A graph
+
+    Returns
+    -------
+    hist : list
+       A list of frequencies of degrees.
+       The degree values are the index in the list.
+
+    Notes
+    -----
+    Note: the bins are width one, hence len(list) can be large
+    (Order(number_of_edges))
+    """
+    counts = Counter(d for n, d in G.degree())
+    return [counts.get(i, 0) for i in range(max(counts) + 1)]
+
+
+def is_directed(G):
+    """Return True if graph is directed."""
+    return G.is_directed()
+
+
+def frozen(*args, **kwargs):
+    """Dummy method for raising errors when trying to modify frozen graphs"""
+    raise nx.NetworkXError("Frozen graph can't be modified")
+
+
+def freeze(G):
+    """Modify graph to prevent further change by adding or removing
+    nodes or edges.
+
+    Node and edge data can still be modified.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> G = nx.freeze(G)
+    >>> try:
+    ...     G.add_edge(4, 5)
+    ... except nx.NetworkXError as err:
+    ...     print(str(err))
+    Frozen graph can't be modified
+
+    Notes
+    -----
+    To "unfreeze" a graph you must make a copy by creating a new graph object:
+
+    >>> graph = nx.path_graph(4)
+    >>> frozen_graph = nx.freeze(graph)
+    >>> unfrozen_graph = nx.Graph(frozen_graph)
+    >>> nx.is_frozen(unfrozen_graph)
+    False
+
+    See Also
+    --------
+    is_frozen
+    """
+    G.add_node = frozen
+    G.add_nodes_from = frozen
+    G.remove_node = frozen
+    G.remove_nodes_from = frozen
+    G.add_edge = frozen
+    G.add_edges_from = frozen
+    G.add_weighted_edges_from = frozen
+    G.remove_edge = frozen
+    G.remove_edges_from = frozen
+    G.clear = frozen
+    G.frozen = True
+    return G
+
+
+def is_frozen(G):
+    """Returns True if graph is frozen.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    See Also
+    --------
+    freeze
+    """
+    try:
+        return G.frozen
+    except AttributeError:
+        return False
+
+
+def add_star(G_to_add_to, nodes_for_star, **attr):
+    """Add a star to Graph G_to_add_to.
+
+    The first node in `nodes_for_star` is the middle of the star.
+    It is connected to all other nodes.
+
+    Parameters
+    ----------
+    G_to_add_to : graph
+        A NetworkX graph
+    nodes_for_star : iterable container
+        A container of nodes.
+    attr : keyword arguments, optional (default= no attributes)
+        Attributes to add to every edge in star.
+
+    See Also
+    --------
+    add_path, add_cycle
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> nx.add_star(G, [0, 1, 2, 3])
+    >>> nx.add_star(G, [10, 11, 12], weight=2)
+    """
+    nlist = iter(nodes_for_star)
+    try:
+        v = next(nlist)
+    except StopIteration:
+        return
+    G_to_add_to.add_node(v)
+    edges = ((v, n) for n in nlist)
+    G_to_add_to.add_edges_from(edges, **attr)
+
+
+def add_path(G_to_add_to, nodes_for_path, **attr):
+    """Add a path to the Graph G_to_add_to.
+
+    Parameters
+    ----------
+    G_to_add_to : graph
+        A NetworkX graph
+    nodes_for_path : iterable container
+        A container of nodes.  A path will be constructed from
+        the nodes (in order) and added to the graph.
+    attr : keyword arguments, optional (default= no attributes)
+        Attributes to add to every edge in path.
+
+    See Also
+    --------
+    add_star, add_cycle
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> nx.add_path(G, [0, 1, 2, 3])
+    >>> nx.add_path(G, [10, 11, 12], weight=7)
+    """
+    nlist = iter(nodes_for_path)
+    try:
+        first_node = next(nlist)
+    except StopIteration:
+        return
+    G_to_add_to.add_node(first_node)
+    G_to_add_to.add_edges_from(pairwise(chain((first_node,), nlist)), **attr)
+
+
+def add_cycle(G_to_add_to, nodes_for_cycle, **attr):
+    """Add a cycle to the Graph G_to_add_to.
+
+    Parameters
+    ----------
+    G_to_add_to : graph
+        A NetworkX graph
+    nodes_for_cycle: iterable container
+        A container of nodes.  A cycle will be constructed from
+        the nodes (in order) and added to the graph.
+    attr : keyword arguments, optional (default= no attributes)
+        Attributes to add to every edge in cycle.
+
+    See Also
+    --------
+    add_path, add_star
+
+    Examples
+    --------
+    >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+    >>> nx.add_cycle(G, [0, 1, 2, 3])
+    >>> nx.add_cycle(G, [10, 11, 12], weight=7)
+    """
+    nlist = iter(nodes_for_cycle)
+    try:
+        first_node = next(nlist)
+    except StopIteration:
+        return
+    G_to_add_to.add_node(first_node)
+    G_to_add_to.add_edges_from(
+        pairwise(chain((first_node,), nlist), cyclic=True), **attr
+    )
+
+
+def subgraph(G, nbunch):
+    """Returns the subgraph induced on nodes in nbunch.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    nbunch : list, iterable
+       A container of nodes that will be iterated through once (thus
+       it should be an iterator or be iterable).  Each element of the
+       container should be a valid node type: any hashable type except
+       None.  If nbunch is None, return all edges data in the graph.
+       Nodes in nbunch that are not in the graph will be (quietly)
+       ignored.
+
+    Notes
+    -----
+    subgraph(G) calls G.subgraph()
+    """
+    return G.subgraph(nbunch)
+
+
+def induced_subgraph(G, nbunch):
+    """Returns a SubGraph view of `G` showing only nodes in nbunch.
+
+    The induced subgraph of a graph on a set of nodes N is the
+    graph with nodes N and edges from G which have both ends in N.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    nbunch : node, container of nodes or None (for all nodes)
+
+    Returns
+    -------
+    subgraph : SubGraph View
+        A read-only view of the subgraph in `G` induced by the nodes.
+        Changes to the graph `G` will be reflected in the view.
+
+    Notes
+    -----
+    To create a mutable subgraph with its own copies of nodes
+    edges and attributes use `subgraph.copy()` or `Graph(subgraph)`
+
+    For an inplace reduction of a graph to a subgraph you can remove nodes:
+    `G.remove_nodes_from(n in G if n not in set(nbunch))`
+
+    If you are going to compute subgraphs of your subgraphs you could
+    end up with a chain of views that can be very slow once the chain
+    has about 15 views in it. If they are all induced subgraphs, you
+    can short-cut the chain by making them all subgraphs of the original
+    graph. The graph class method `G.subgraph` does this when `G` is
+    a subgraph. In contrast, this function allows you to choose to build
+    chains or not, as you wish. The returned subgraph is a view on `G`.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+    >>> H = nx.induced_subgraph(G, [0, 1, 3])
+    >>> list(H.edges)
+    [(0, 1)]
+    >>> list(H.nodes)
+    [0, 1, 3]
+    """
+    induced_nodes = nx.filters.show_nodes(G.nbunch_iter(nbunch))
+    return nx.graphviews.subgraph_view(G, induced_nodes)
+
+
+def edge_subgraph(G, edges):
+    """Returns a view of the subgraph induced by the specified edges.
+
+    The induced subgraph contains each edge in `edges` and each
+    node incident to any of those edges.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    edges : iterable
+        An iterable of edges. Edges not present in `G` are ignored.
+
+    Returns
+    -------
+    subgraph : SubGraph View
+        A read-only edge-induced subgraph of `G`.
+        Changes to `G` are reflected in the view.
+
+    Notes
+    -----
+    To create a mutable subgraph with its own copies of nodes
+    edges and attributes use `subgraph.copy()` or `Graph(subgraph)`
+
+    If you create a subgraph of a subgraph recursively you can end up
+    with a chain of subgraphs that becomes very slow with about 15
+    nested subgraph views. Luckily the edge_subgraph filter nests
+    nicely so you can use the original graph as G in this function
+    to avoid chains. We do not rule out chains programmatically so
+    that odd cases like an `edge_subgraph` of a `restricted_view`
+    can be created.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> H = G.edge_subgraph([(0, 1), (3, 4)])
+    >>> list(H.nodes)
+    [0, 1, 3, 4]
+    >>> list(H.edges)
+    [(0, 1), (3, 4)]
+    """
+    nxf = nx.filters
+    edges = set(edges)
+    nodes = set()
+    for e in edges:
+        nodes.update(e[:2])
+    induced_nodes = nxf.show_nodes(nodes)
+    if G.is_multigraph():
+        if G.is_directed():
+            induced_edges = nxf.show_multidiedges(edges)
+        else:
+            induced_edges = nxf.show_multiedges(edges)
+    else:
+        if G.is_directed():
+            induced_edges = nxf.show_diedges(edges)
+        else:
+            induced_edges = nxf.show_edges(edges)
+    return nx.graphviews.subgraph_view(G, induced_nodes, induced_edges)
+
+
+def restricted_view(G, nodes, edges):
+    """Returns a view of `G` with hidden nodes and edges.
+
+    The resulting subgraph filters out node `nodes` and edges `edges`.
+    Filtered out nodes also filter out any of their edges.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    nodes : iterable
+        An iterable of nodes. Nodes not present in `G` are ignored.
+    edges : iterable
+        An iterable of edges. Edges not present in `G` are ignored.
+
+    Returns
+    -------
+    subgraph : SubGraph View
+        A read-only restricted view of `G` filtering out nodes and edges.
+        Changes to `G` are reflected in the view.
+
+    Notes
+    -----
+    To create a mutable subgraph with its own copies of nodes
+    edges and attributes use `subgraph.copy()` or `Graph(subgraph)`
+
+    If you create a subgraph of a subgraph recursively you may end up
+    with a chain of subgraph views. Such chains can get quite slow
+    for lengths near 15. To avoid long chains, try to make your subgraph
+    based on the original graph.  We do not rule out chains programmatically
+    so that odd cases like an `edge_subgraph` of a `restricted_view`
+    can be created.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(5)
+    >>> H = nx.restricted_view(G, [0], [(1, 2), (3, 4)])
+    >>> list(H.nodes)
+    [1, 2, 3, 4]
+    >>> list(H.edges)
+    [(2, 3)]
+    """
+    nxf = nx.filters
+    hide_nodes = nxf.hide_nodes(nodes)
+    if G.is_multigraph():
+        if G.is_directed():
+            hide_edges = nxf.hide_multidiedges(edges)
+        else:
+            hide_edges = nxf.hide_multiedges(edges)
+    else:
+        if G.is_directed():
+            hide_edges = nxf.hide_diedges(edges)
+        else:
+            hide_edges = nxf.hide_edges(edges)
+    return nx.graphviews.subgraph_view(G, hide_nodes, hide_edges)
+
+
+def to_directed(graph):
+    """Returns a directed view of the graph `graph`.
+
+    Identical to graph.to_directed(as_view=True)
+    Note that graph.to_directed defaults to `as_view=False`
+    while this function always provides a view.
+    """
+    return graph.to_directed(as_view=True)
+
+
+def to_undirected(graph):
+    """Returns an undirected view of the graph `graph`.
+
+    Identical to graph.to_undirected(as_view=True)
+    Note that graph.to_undirected defaults to `as_view=False`
+    while this function always provides a view.
+    """
+    return graph.to_undirected(as_view=True)
+
+
+def create_empty_copy(G, with_data=True):
+    """Returns a copy of the graph G with all of the edges removed.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    with_data :  bool (default=True)
+       Propagate Graph and Nodes data to the new graph.
+
+    See Also
+    --------
+    empty_graph
+
+    """
+    H = G.__class__()
+    H.add_nodes_from(G.nodes(data=with_data))
+    if with_data:
+        H.graph.update(G.graph)
+    return H
+
+
+def info(G, n=None):
+    """Return a summary of information for the graph G or a single node n.
+
+    The summary includes the number of nodes and edges, or neighbours for a single
+    node.
+
+    Parameters
+    ----------
+    G : Networkx graph
+       A graph
+    n : node (any hashable)
+       A node in the graph G
+
+    Returns
+    -------
+    info : str
+        A string containing the short summary
+
+    Raises
+    ------
+    NetworkXError
+        If n is not in the graph G
+
+    .. deprecated:: 2.7
+       ``info`` is deprecated and will be removed in NetworkX 3.0.
+    """
+    import warnings
+
+    warnings.warn(
+        ("info is deprecated and will be removed in version 3.0.\n"),
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    if n is None:
+        return str(G)
+    if n not in G:
+        raise nx.NetworkXError(f"node {n} not in graph")
+    info = ""  # append this all to a string
+    info += f"Node {n} has the following properties:\n"
+    info += f"Degree: {G.degree(n)}\n"
+    info += "Neighbors: "
+    info += " ".join(str(nbr) for nbr in G.neighbors(n))
+    return info
+
+
+def set_node_attributes(G, values, name=None):
+    """Sets node attributes from a given value or dictionary of values.
+
+    .. Warning:: The call order of arguments `values` and `name`
+        switched between v1.x & v2.x.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+
+    values : scalar value, dict-like
+        What the node attribute should be set to.  If `values` is
+        not a dictionary, then it is treated as a single attribute value
+        that is then applied to every node in `G`.  This means that if
+        you provide a mutable object, like a list, updates to that object
+        will be reflected in the node attribute for every node.
+        The attribute name will be `name`.
+
+        If `values` is a dict or a dict of dict, it should be keyed
+        by node to either an attribute value or a dict of attribute key/value
+        pairs used to update the node's attributes.
+
+    name : string (optional, default=None)
+        Name of the node attribute to set if values is a scalar.
+
+    Examples
+    --------
+    After computing some property of the nodes of a graph, you may want
+    to assign a node attribute to store the value of that property for
+    each node::
+
+        >>> G = nx.path_graph(3)
+        >>> bb = nx.betweenness_centrality(G)
+        >>> isinstance(bb, dict)
+        True
+        >>> nx.set_node_attributes(G, bb, "betweenness")
+        >>> G.nodes[1]["betweenness"]
+        1.0
+
+    If you provide a list as the second argument, updates to the list
+    will be reflected in the node attribute for each node::
+
+        >>> G = nx.path_graph(3)
+        >>> labels = []
+        >>> nx.set_node_attributes(G, labels, "labels")
+        >>> labels.append("foo")
+        >>> G.nodes[0]["labels"]
+        ['foo']
+        >>> G.nodes[1]["labels"]
+        ['foo']
+        >>> G.nodes[2]["labels"]
+        ['foo']
+
+    If you provide a dictionary of dictionaries as the second argument,
+    the outer dictionary is assumed to be keyed by node to an inner
+    dictionary of node attributes for that node::
+
+        >>> G = nx.path_graph(3)
+        >>> attrs = {0: {"attr1": 20, "attr2": "nothing"}, 1: {"attr2": 3}}
+        >>> nx.set_node_attributes(G, attrs)
+        >>> G.nodes[0]["attr1"]
+        20
+        >>> G.nodes[0]["attr2"]
+        'nothing'
+        >>> G.nodes[1]["attr2"]
+        3
+        >>> G.nodes[2]
+        {}
+
+    Note that if the dictionary contains nodes that are not in `G`, the
+    values are silently ignored::
+
+        >>> G = nx.Graph()
+        >>> G.add_node(0)
+        >>> nx.set_node_attributes(G, {0: "red", 1: "blue"}, name="color")
+        >>> G.nodes[0]["color"]
+        'red'
+        >>> 1 in G.nodes
+        False
+
+    """
+    # Set node attributes based on type of `values`
+    if name is not None:  # `values` must not be a dict of dict
+        try:  # `values` is a dict
+            for n, v in values.items():
+                try:
+                    G.nodes[n][name] = values[n]
+                except KeyError:
+                    pass
+        except AttributeError:  # `values` is a constant
+            for n in G:
+                G.nodes[n][name] = values
+    else:  # `values` must be dict of dict
+        for n, d in values.items():
+            try:
+                G.nodes[n].update(d)
+            except KeyError:
+                pass
+
+
+def get_node_attributes(G, name):
+    """Get node attributes from graph
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+
+    name : string
+       Attribute name
+
+    Returns
+    -------
+    Dictionary of attributes keyed by node.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_nodes_from([1, 2, 3], color="red")
+    >>> color = nx.get_node_attributes(G, "color")
+    >>> color[1]
+    'red'
+    """
+    return {n: d[name] for n, d in G.nodes.items() if name in d}
+
+
+def set_edge_attributes(G, values, name=None):
+    """Sets edge attributes from a given value or dictionary of values.
+
+    .. Warning:: The call order of arguments `values` and `name`
+        switched between v1.x & v2.x.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+
+    values : scalar value, dict-like
+        What the edge attribute should be set to.  If `values` is
+        not a dictionary, then it is treated as a single attribute value
+        that is then applied to every edge in `G`.  This means that if
+        you provide a mutable object, like a list, updates to that object
+        will be reflected in the edge attribute for each edge.  The attribute
+        name will be `name`.
+
+        If `values` is a dict or a dict of dict, it should be keyed
+        by edge tuple to either an attribute value or a dict of attribute
+        key/value pairs used to update the edge's attributes.
+        For multigraphs, the edge tuples must be of the form ``(u, v, key)``,
+        where `u` and `v` are nodes and `key` is the edge key.
+        For non-multigraphs, the keys must be tuples of the form ``(u, v)``.
+
+    name : string (optional, default=None)
+        Name of the edge attribute to set if values is a scalar.
+
+    Examples
+    --------
+    After computing some property of the edges of a graph, you may want
+    to assign a edge attribute to store the value of that property for
+    each edge::
+
+        >>> G = nx.path_graph(3)
+        >>> bb = nx.edge_betweenness_centrality(G, normalized=False)
+        >>> nx.set_edge_attributes(G, bb, "betweenness")
+        >>> G.edges[1, 2]["betweenness"]
+        2.0
+
+    If you provide a list as the second argument, updates to the list
+    will be reflected in the edge attribute for each edge::
+
+        >>> labels = []
+        >>> nx.set_edge_attributes(G, labels, "labels")
+        >>> labels.append("foo")
+        >>> G.edges[0, 1]["labels"]
+        ['foo']
+        >>> G.edges[1, 2]["labels"]
+        ['foo']
+
+    If you provide a dictionary of dictionaries as the second argument,
+    the entire dictionary will be used to update edge attributes::
+
+        >>> G = nx.path_graph(3)
+        >>> attrs = {(0, 1): {"attr1": 20, "attr2": "nothing"}, (1, 2): {"attr2": 3}}
+        >>> nx.set_edge_attributes(G, attrs)
+        >>> G[0][1]["attr1"]
+        20
+        >>> G[0][1]["attr2"]
+        'nothing'
+        >>> G[1][2]["attr2"]
+        3
+
+    Note that if the dict contains edges that are not in `G`, they are
+    silently ignored::
+
+        >>> G = nx.Graph([(0, 1)])
+        >>> nx.set_edge_attributes(G, {(1, 2): {"weight": 2.0}})
+        >>> (1, 2) in G.edges()
+        False
+
+    """
+    if name is not None:
+        # `values` does not contain attribute names
+        try:
+            # if `values` is a dict using `.items()` => {edge: value}
+            if G.is_multigraph():
+                for (u, v, key), value in values.items():
+                    try:
+                        G[u][v][key][name] = value
+                    except KeyError:
+                        pass
+            else:
+                for (u, v), value in values.items():
+                    try:
+                        G[u][v][name] = value
+                    except KeyError:
+                        pass
+        except AttributeError:
+            # treat `values` as a constant
+            for u, v, data in G.edges(data=True):
+                data[name] = values
+    else:
+        # `values` consists of doct-of-dict {edge: {attr: value}} shape
+        if G.is_multigraph():
+            for (u, v, key), d in values.items():
+                try:
+                    G[u][v][key].update(d)
+                except KeyError:
+                    pass
+        else:
+            for (u, v), d in values.items():
+                try:
+                    G[u][v].update(d)
+                except KeyError:
+                    pass
+
+
+def get_edge_attributes(G, name):
+    """Get edge attributes from graph
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+
+    name : string
+       Attribute name
+
+    Returns
+    -------
+    Dictionary of attributes keyed by edge. For (di)graphs, the keys are
+    2-tuples of the form: (u, v). For multi(di)graphs, the keys are 3-tuples of
+    the form: (u, v, key).
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> nx.add_path(G, [1, 2, 3], color="red")
+    >>> color = nx.get_edge_attributes(G, "color")
+    >>> color[(1, 2)]
+    'red'
+    """
+    if G.is_multigraph():
+        edges = G.edges(keys=True, data=True)
+    else:
+        edges = G.edges(data=True)
+    return {x[:-1]: x[-1][name] for x in edges if name in x[-1]}
+
+
+def all_neighbors(graph, node):
+    """Returns all of the neighbors of a node in the graph.
+
+    If the graph is directed returns predecessors as well as successors.
+
+    Parameters
+    ----------
+    graph : NetworkX graph
+        Graph to find neighbors.
+
+    node : node
+        The node whose neighbors will be returned.
+
+    Returns
+    -------
+    neighbors : iterator
+        Iterator of neighbors
+    """
+    if graph.is_directed():
+        values = chain(graph.predecessors(node), graph.successors(node))
+    else:
+        values = graph.neighbors(node)
+    return values
+
+
+def non_neighbors(graph, node):
+    """Returns the non-neighbors of the node in the graph.
+
+    Parameters
+    ----------
+    graph : NetworkX graph
+        Graph to find neighbors.
+
+    node : node
+        The node whose neighbors will be returned.
+
+    Returns
+    -------
+    non_neighbors : iterator
+        Iterator of nodes in the graph that are not neighbors of the node.
+    """
+    nbors = set(neighbors(graph, node)) | {node}
+    return (nnode for nnode in graph if nnode not in nbors)
+
+
+def non_edges(graph):
+    """Returns the non-existent edges in the graph.
+
+    Parameters
+    ----------
+    graph : NetworkX graph.
+        Graph to find non-existent edges.
+
+    Returns
+    -------
+    non_edges : iterator
+        Iterator of edges that are not in the graph.
+    """
+    if graph.is_directed():
+        for u in graph:
+            for v in non_neighbors(graph, u):
+                yield (u, v)
+    else:
+        nodes = set(graph)
+        while nodes:
+            u = nodes.pop()
+            for v in nodes - set(graph[u]):
+                yield (u, v)
+
+
+@not_implemented_for("directed")
+def common_neighbors(G, u, v):
+    """Returns the common neighbors of two nodes in a graph.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX undirected graph.
+
+    u, v : nodes
+        Nodes in the graph.
+
+    Returns
+    -------
+    cnbors : iterator
+        Iterator of common neighbors of u and v in the graph.
+
+    Raises
+    ------
+    NetworkXError
+        If u or v is not a node in the graph.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> sorted(nx.common_neighbors(G, 0, 1))
+    [2, 3, 4]
+    """
+    if u not in G:
+        raise nx.NetworkXError("u is not in the graph.")
+    if v not in G:
+        raise nx.NetworkXError("v is not in the graph.")
+
+    # Return a generator explicitly instead of yielding so that the above
+    # checks are executed eagerly.
+    return (w for w in G[u] if w in G[v] and w not in (u, v))
+
+
+def is_weighted(G, edge=None, weight="weight"):
+    """Returns True if `G` has weighted edges.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph.
+
+    edge : tuple, optional
+        A 2-tuple specifying the only edge in `G` that will be tested. If
+        None, then every edge in `G` is tested.
+
+    weight: string, optional
+        The attribute name used to query for edge weights.
+
+    Returns
+    -------
+    bool
+        A boolean signifying if `G`, or the specified edge, is weighted.
+
+    Raises
+    ------
+    NetworkXError
+        If the specified edge does not exist.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.is_weighted(G)
+    False
+    >>> nx.is_weighted(G, (2, 3))
+    False
+
+    >>> G = nx.DiGraph()
+    >>> G.add_edge(1, 2, weight=1)
+    >>> nx.is_weighted(G)
+    True
+
+    """
+    if edge is not None:
+        data = G.get_edge_data(*edge)
+        if data is None:
+            msg = f"Edge {edge!r} does not exist."
+            raise nx.NetworkXError(msg)
+        return weight in data
+
+    if is_empty(G):
+        # Special handling required since: all([]) == True
+        return False
+
+    return all(weight in data for u, v, data in G.edges(data=True))
+
+
+def is_negatively_weighted(G, edge=None, weight="weight"):
+    """Returns True if `G` has negatively weighted edges.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph.
+
+    edge : tuple, optional
+        A 2-tuple specifying the only edge in `G` that will be tested. If
+        None, then every edge in `G` is tested.
+
+    weight: string, optional
+        The attribute name used to query for edge weights.
+
+    Returns
+    -------
+    bool
+        A boolean signifying if `G`, or the specified edge, is negatively
+        weighted.
+
+    Raises
+    ------
+    NetworkXError
+        If the specified edge does not exist.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_edges_from([(1, 3), (2, 4), (2, 6)])
+    >>> G.add_edge(1, 2, weight=4)
+    >>> nx.is_negatively_weighted(G, (1, 2))
+    False
+    >>> G[2][4]["weight"] = -2
+    >>> nx.is_negatively_weighted(G)
+    True
+    >>> G = nx.DiGraph()
+    >>> edges = [("0", "3", 3), ("0", "1", -5), ("1", "0", -2)]
+    >>> G.add_weighted_edges_from(edges)
+    >>> nx.is_negatively_weighted(G)
+    True
+
+    """
+    if edge is not None:
+        data = G.get_edge_data(*edge)
+        if data is None:
+            msg = f"Edge {edge!r} does not exist."
+            raise nx.NetworkXError(msg)
+        return weight in data and data[weight] < 0
+
+    return any(weight in data and data[weight] < 0 for u, v, data in G.edges(data=True))
+
+
+def is_empty(G):
+    """Returns True if `G` has no edges.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph.
+
+    Returns
+    -------
+    bool
+        True if `G` has no edges, and False otherwise.
+
+    Notes
+    -----
+    An empty graph can have nodes but not edges. The empty graph with zero
+    nodes is known as the null graph. This is an $O(n)$ operation where n
+    is the number of nodes in the graph.
+
+    """
+    return not any(G.adj.values())
+
+
+def nodes_with_selfloops(G):
+    """Returns an iterator over nodes with self loops.
+
+    A node with a self loop has an edge with both ends adjacent
+    to that node.
+
+    Returns
+    -------
+    nodelist : iterator
+        A iterator over nodes with self loops.
+
+    See Also
+    --------
+    selfloop_edges, number_of_selfloops
+
+    Examples
+    --------
+    >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+    >>> G.add_edge(1, 1)
+    >>> G.add_edge(1, 2)
+    >>> list(nx.nodes_with_selfloops(G))
+    [1]
+
+    """
+    return (n for n, nbrs in G.adj.items() if n in nbrs)
+
+
+def selfloop_edges(G, data=False, keys=False, default=None):
+    """Returns an iterator over selfloop edges.
+
+    A selfloop edge has the same node at both ends.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph.
+    data : string or bool, optional (default=False)
+        Return selfloop edges as two tuples (u, v) (data=False)
+        or three-tuples (u, v, datadict) (data=True)
+        or three-tuples (u, v, datavalue) (data='attrname')
+    keys : bool, optional (default=False)
+        If True, return edge keys with each edge.
+    default : value, optional (default=None)
+        Value used for edges that don't have the requested attribute.
+        Only relevant if data is not True or False.
+
+    Returns
+    -------
+    edgeiter : iterator over edge tuples
+        An iterator over all selfloop edges.
+
+    See Also
+    --------
+    nodes_with_selfloops, number_of_selfloops
+
+    Examples
+    --------
+    >>> G = nx.MultiGraph()  # or Graph, DiGraph, MultiDiGraph, etc
+    >>> ekey = G.add_edge(1, 1)
+    >>> ekey = G.add_edge(1, 2)
+    >>> list(nx.selfloop_edges(G))
+    [(1, 1)]
+    >>> list(nx.selfloop_edges(G, data=True))
+    [(1, 1, {})]
+    >>> list(nx.selfloop_edges(G, keys=True))
+    [(1, 1, 0)]
+    >>> list(nx.selfloop_edges(G, keys=True, data=True))
+    [(1, 1, 0, {})]
+    """
+    if data is True:
+        if G.is_multigraph():
+            if keys is True:
+                return (
+                    (n, n, k, d)
+                    for n, nbrs in G.adj.items()
+                    if n in nbrs
+                    for k, d in nbrs[n].items()
+                )
+            else:
+                return (
+                    (n, n, d)
+                    for n, nbrs in G.adj.items()
+                    if n in nbrs
+                    for d in nbrs[n].values()
+                )
+        else:
+            return ((n, n, nbrs[n]) for n, nbrs in G.adj.items() if n in nbrs)
+    elif data is not False:
+        if G.is_multigraph():
+            if keys is True:
+                return (
+                    (n, n, k, d.get(data, default))
+                    for n, nbrs in G.adj.items()
+                    if n in nbrs
+                    for k, d in nbrs[n].items()
+                )
+            else:
+                return (
+                    (n, n, d.get(data, default))
+                    for n, nbrs in G.adj.items()
+                    if n in nbrs
+                    for d in nbrs[n].values()
+                )
+        else:
+            return (
+                (n, n, nbrs[n].get(data, default))
+                for n, nbrs in G.adj.items()
+                if n in nbrs
+            )
+    else:
+        if G.is_multigraph():
+            if keys is True:
+                return (
+                    (n, n, k) for n, nbrs in G.adj.items() if n in nbrs for k in nbrs[n]
+                )
+            else:
+                return (
+                    (n, n)
+                    for n, nbrs in G.adj.items()
+                    if n in nbrs
+                    for i in range(len(nbrs[n]))  # for easy edge removal (#4068)
+                )
+        else:
+            return ((n, n) for n, nbrs in G.adj.items() if n in nbrs)
+
+
+def number_of_selfloops(G):
+    """Returns the number of selfloop edges.
+
+    A selfloop edge has the same node at both ends.
+
+    Returns
+    -------
+    nloops : int
+        The number of selfloops.
+
+    See Also
+    --------
+    nodes_with_selfloops, selfloop_edges
+
+    Examples
+    --------
+    >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+    >>> G.add_edge(1, 1)
+    >>> G.add_edge(1, 2)
+    >>> nx.number_of_selfloops(G)
+    1
+    """
+    return sum(1 for _ in nx.selfloop_edges(G))
+
+
+def is_path(G, path):
+    """Returns whether or not the specified path exists
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph.
+
+    path: list
+        A list of node labels which defines the path to traverse
+
+    Returns
+    -------
+    isPath: bool
+        A boolean representing whether or not the path exists
+
+    """
+    for node, nbr in nx.utils.pairwise(path):
+        if nbr not in G[node]:
+            return False
+    return True
+
+
+def path_weight(G, path, weight):
+    """Returns total cost associated with specified path and weight
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph.
+
+    path: list
+        A list of node labels which defines the path to traverse
+
+    weight: string
+        A string indicating which edge attribute to use for path cost
+
+    Returns
+    -------
+    cost: int or float
+        An integer or a float representing the total cost with respect to the
+        specified weight of the specified path
+
+    Raises
+    ------
+    NetworkXNoPath
+        If the specified edge does not exist.
+    """
+    multigraph = G.is_multigraph()
+    cost = 0
+
+    if not nx.is_path(G, path):
+        raise nx.NetworkXNoPath("path does not exist")
+    for node, nbr in nx.utils.pairwise(path):
+        if multigraph:
+            cost += min(v[weight] for v in G[node][nbr].values())
+        else:
+            cost += G[node][nbr][weight]
+    return cost
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/graph.py b/myenv/lib/python3.9/site-packages/networkx/classes/graph.py
new file mode 100644
index 0000000..b5c3b79
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/graph.py
@@ -0,0 +1,1940 @@
+"""Base class for undirected graphs.
+
+The Graph class allows any hashable object as a node
+and can associate key/value attribute pairs with each undirected edge.
+
+Self-loops are allowed but multiple edges are not (see MultiGraph).
+
+For directed graphs see DiGraph and MultiDiGraph.
+"""
+from copy import deepcopy
+from functools import cached_property
+
+import networkx as nx
+import networkx.convert as convert
+from networkx.classes.coreviews import AdjacencyView
+from networkx.classes.reportviews import DegreeView, EdgeView, NodeView
+from networkx.exception import NetworkXError
+
+__all__ = ["Graph"]
+
+
+class _CachedPropertyResetterAdj:
+    """Data Descriptor class for _adj that resets ``adj`` cached_property when needed
+
+    This assumes that the ``cached_property`` ``G.adj`` should be reset whenever
+    ``G._adj`` is set to a new value.
+
+    This object sits on a class and ensures that any instance of that
+    class clears its cached property "adj" whenever the underlying
+    instance attribute "_adj" is set to a new object. It only affects
+    the set process of the obj._adj attribute. All get/del operations
+    act as they normally would.
+
+    For info on Data Descriptors see: https://docs.python.org/3/howto/descriptor.html
+    """
+
+    def __set__(self, obj, value):
+        od = obj.__dict__
+        od["_adj"] = value
+        if "adj" in od:
+            del od["adj"]
+
+
+class Graph:
+    """
+    Base class for undirected graphs.
+
+    A Graph stores nodes and edges with optional data, or attributes.
+
+    Graphs hold undirected edges.  Self loops are allowed but multiple
+    (parallel) edges are not.
+
+    Nodes can be arbitrary (hashable) Python objects with optional
+    key/value attributes, except that `None` is not allowed as a node.
+
+    Edges are represented as links between nodes with optional
+    key/value attributes.
+
+    Parameters
+    ----------
+    incoming_graph_data : input graph (optional, default: None)
+        Data to initialize graph. If None (default) an empty
+        graph is created.  The data can be any format that is supported
+        by the to_networkx_graph() function, currently including edge list,
+        dict of dicts, dict of lists, NetworkX graph, 2D NumPy array, SciPy
+        sparse matrix, or PyGraphviz graph.
+
+    attr : keyword arguments, optional (default= no attributes)
+        Attributes to add to graph as key=value pairs.
+
+    See Also
+    --------
+    DiGraph
+    MultiGraph
+    MultiDiGraph
+    OrderedGraph
+
+    Examples
+    --------
+    Create an empty graph structure (a "null graph") with no nodes and
+    no edges.
+
+    >>> G = nx.Graph()
+
+    G can be grown in several ways.
+
+    **Nodes:**
+
+    Add one node at a time:
+
+    >>> G.add_node(1)
+
+    Add the nodes from any container (a list, dict, set or
+    even the lines from a file or the nodes from another graph).
+
+    >>> G.add_nodes_from([2, 3])
+    >>> G.add_nodes_from(range(100, 110))
+    >>> H = nx.path_graph(10)
+    >>> G.add_nodes_from(H)
+
+    In addition to strings and integers any hashable Python object
+    (except None) can represent a node, e.g. a customized node object,
+    or even another Graph.
+
+    >>> G.add_node(H)
+
+    **Edges:**
+
+    G can also be grown by adding edges.
+
+    Add one edge,
+
+    >>> G.add_edge(1, 2)
+
+    a list of edges,
+
+    >>> G.add_edges_from([(1, 2), (1, 3)])
+
+    or a collection of edges,
+
+    >>> G.add_edges_from(H.edges)
+
+    If some edges connect nodes not yet in the graph, the nodes
+    are added automatically.  There are no errors when adding
+    nodes or edges that already exist.
+
+    **Attributes:**
+
+    Each graph, node, and edge can hold key/value attribute pairs
+    in an associated attribute dictionary (the keys must be hashable).
+    By default these are empty, but can be added or changed using
+    add_edge, add_node or direct manipulation of the attribute
+    dictionaries named graph, node and edge respectively.
+
+    >>> G = nx.Graph(day="Friday")
+    >>> G.graph
+    {'day': 'Friday'}
+
+    Add node attributes using add_node(), add_nodes_from() or G.nodes
+
+    >>> G.add_node(1, time="5pm")
+    >>> G.add_nodes_from([3], time="2pm")
+    >>> G.nodes[1]
+    {'time': '5pm'}
+    >>> G.nodes[1]["room"] = 714  # node must exist already to use G.nodes
+    >>> del G.nodes[1]["room"]  # remove attribute
+    >>> list(G.nodes(data=True))
+    [(1, {'time': '5pm'}), (3, {'time': '2pm'})]
+
+    Add edge attributes using add_edge(), add_edges_from(), subscript
+    notation, or G.edges.
+
+    >>> G.add_edge(1, 2, weight=4.7)
+    >>> G.add_edges_from([(3, 4), (4, 5)], color="red")
+    >>> G.add_edges_from([(1, 2, {"color": "blue"}), (2, 3, {"weight": 8})])
+    >>> G[1][2]["weight"] = 4.7
+    >>> G.edges[1, 2]["weight"] = 4
+
+    Warning: we protect the graph data structure by making `G.edges` a
+    read-only dict-like structure. However, you can assign to attributes
+    in e.g. `G.edges[1, 2]`. Thus, use 2 sets of brackets to add/change
+    data attributes: `G.edges[1, 2]['weight'] = 4`
+    (For multigraphs: `MG.edges[u, v, key][name] = value`).
+
+    **Shortcuts:**
+
+    Many common graph features allow python syntax to speed reporting.
+
+    >>> 1 in G  # check if node in graph
+    True
+    >>> [n for n in G if n < 3]  # iterate through nodes
+    [1, 2]
+    >>> len(G)  # number of nodes in graph
+    5
+
+    Often the best way to traverse all edges of a graph is via the neighbors.
+    The neighbors are reported as an adjacency-dict `G.adj` or `G.adjacency()`
+
+    >>> for n, nbrsdict in G.adjacency():
+    ...     for nbr, eattr in nbrsdict.items():
+    ...         if "weight" in eattr:
+    ...             # Do something useful with the edges
+    ...             pass
+
+    But the edges() method is often more convenient:
+
+    >>> for u, v, weight in G.edges.data("weight"):
+    ...     if weight is not None:
+    ...         # Do something useful with the edges
+    ...         pass
+
+    **Reporting:**
+
+    Simple graph information is obtained using object-attributes and methods.
+    Reporting typically provides views instead of containers to reduce memory
+    usage. The views update as the graph is updated similarly to dict-views.
+    The objects `nodes`, `edges` and `adj` provide access to data attributes
+    via lookup (e.g. `nodes[n]`, `edges[u, v]`, `adj[u][v]`) and iteration
+    (e.g. `nodes.items()`, `nodes.data('color')`,
+    `nodes.data('color', default='blue')` and similarly for `edges`)
+    Views exist for `nodes`, `edges`, `neighbors()`/`adj` and `degree`.
+
+    For details on these and other miscellaneous methods, see below.
+
+    **Subclasses (Advanced):**
+
+    The Graph class uses a dict-of-dict-of-dict data structure.
+    The outer dict (node_dict) holds adjacency information keyed by node.
+    The next dict (adjlist_dict) represents the adjacency information and holds
+    edge data keyed by neighbor.  The inner dict (edge_attr_dict) represents
+    the edge data and holds edge attribute values keyed by attribute names.
+
+    Each of these three dicts can be replaced in a subclass by a user defined
+    dict-like object. In general, the dict-like features should be
+    maintained but extra features can be added. To replace one of the
+    dicts create a new graph class by changing the class(!) variable
+    holding the factory for that dict-like structure.
+
+    node_dict_factory : function, (default: dict)
+        Factory function to be used to create the dict containing node
+        attributes, keyed by node id.
+        It should require no arguments and return a dict-like object
+
+    node_attr_dict_factory: function, (default: dict)
+        Factory function to be used to create the node attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object
+
+    adjlist_outer_dict_factory : function, (default: dict)
+        Factory function to be used to create the outer-most dict
+        in the data structure that holds adjacency info keyed by node.
+        It should require no arguments and return a dict-like object.
+
+    adjlist_inner_dict_factory : function, (default: dict)
+        Factory function to be used to create the adjacency list
+        dict which holds edge data keyed by neighbor.
+        It should require no arguments and return a dict-like object
+
+    edge_attr_dict_factory : function, (default: dict)
+        Factory function to be used to create the edge attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object.
+
+    graph_attr_dict_factory : function, (default: dict)
+        Factory function to be used to create the graph attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object.
+
+    Typically, if your extension doesn't impact the data structure all
+    methods will inherit without issue except: `to_directed/to_undirected`.
+    By default these methods create a DiGraph/Graph class and you probably
+    want them to create your extension of a DiGraph/Graph. To facilitate
+    this we define two class variables that you can set in your subclass.
+
+    to_directed_class : callable, (default: DiGraph or MultiDiGraph)
+        Class to create a new graph structure in the `to_directed` method.
+        If `None`, a NetworkX class (DiGraph or MultiDiGraph) is used.
+
+    to_undirected_class : callable, (default: Graph or MultiGraph)
+        Class to create a new graph structure in the `to_undirected` method.
+        If `None`, a NetworkX class (Graph or MultiGraph) is used.
+
+    **Subclassing Example**
+
+    Create a low memory graph class that effectively disallows edge
+    attributes by using a single attribute dict for all edges.
+    This reduces the memory used, but you lose edge attributes.
+
+    >>> class ThinGraph(nx.Graph):
+    ...     all_edge_dict = {"weight": 1}
+    ...
+    ...     def single_edge_dict(self):
+    ...         return self.all_edge_dict
+    ...
+    ...     edge_attr_dict_factory = single_edge_dict
+    >>> G = ThinGraph()
+    >>> G.add_edge(2, 1)
+    >>> G[2][1]
+    {'weight': 1}
+    >>> G.add_edge(2, 2)
+    >>> G[2][1] is G[2][2]
+    True
+
+    Please see :mod:`~networkx.classes.ordered` for more examples of
+    creating graph subclasses by overwriting the base class `dict` with
+    a dictionary-like object.
+    """
+
+    _adj = _CachedPropertyResetterAdj()
+
+    node_dict_factory = dict
+    node_attr_dict_factory = dict
+    adjlist_outer_dict_factory = dict
+    adjlist_inner_dict_factory = dict
+    edge_attr_dict_factory = dict
+    graph_attr_dict_factory = dict
+
+    def to_directed_class(self):
+        """Returns the class to use for empty directed copies.
+
+        If you subclass the base classes, use this to designate
+        what directed class to use for `to_directed()` copies.
+        """
+        return nx.DiGraph
+
+    def to_undirected_class(self):
+        """Returns the class to use for empty undirected copies.
+
+        If you subclass the base classes, use this to designate
+        what directed class to use for `to_directed()` copies.
+        """
+        return Graph
+
+    def __init__(self, incoming_graph_data=None, **attr):
+        """Initialize a graph with edges, name, or graph attributes.
+
+        Parameters
+        ----------
+        incoming_graph_data : input graph (optional, default: None)
+            Data to initialize graph. If None (default) an empty
+            graph is created.  The data can be an edge list, or any
+            NetworkX graph object.  If the corresponding optional Python
+            packages are installed the data can also be a 2D NumPy array, a
+            SciPy sparse matrix, or a PyGraphviz graph.
+
+        attr : keyword arguments, optional (default= no attributes)
+            Attributes to add to graph as key=value pairs.
+
+        See Also
+        --------
+        convert
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G = nx.Graph(name="my graph")
+        >>> e = [(1, 2), (2, 3), (3, 4)]  # list of edges
+        >>> G = nx.Graph(e)
+
+        Arbitrary graph attribute pairs (key=value) may be assigned
+
+        >>> G = nx.Graph(e, day="Friday")
+        >>> G.graph
+        {'day': 'Friday'}
+
+        """
+        self.graph = self.graph_attr_dict_factory()  # dictionary for graph attributes
+        self._node = self.node_dict_factory()  # empty node attribute dict
+        self._adj = self.adjlist_outer_dict_factory()  # empty adjacency dict
+        # attempt to load graph with data
+        if incoming_graph_data is not None:
+            convert.to_networkx_graph(incoming_graph_data, create_using=self)
+        # load graph attributes (must be after convert)
+        self.graph.update(attr)
+
+    @cached_property
+    def adj(self):
+        """Graph adjacency object holding the neighbors of each node.
+
+        This object is a read-only dict-like structure with node keys
+        and neighbor-dict values.  The neighbor-dict is keyed by neighbor
+        to the edge-data-dict.  So `G.adj[3][2]['color'] = 'blue'` sets
+        the color of the edge `(3, 2)` to `"blue"`.
+
+        Iterating over G.adj behaves like a dict. Useful idioms include
+        `for nbr, datadict in G.adj[n].items():`.
+
+        The neighbor information is also provided by subscripting the graph.
+        So `for nbr, foovalue in G[node].data('foo', default=1):` works.
+
+        For directed graphs, `G.adj` holds outgoing (successor) info.
+        """
+        return AdjacencyView(self._adj)
+
+    @property
+    def name(self):
+        """String identifier of the graph.
+
+        This graph attribute appears in the attribute dict G.graph
+        keyed by the string `"name"`. as well as an attribute (technically
+        a property) `G.name`. This is entirely user controlled.
+        """
+        return self.graph.get("name", "")
+
+    @name.setter
+    def name(self, s):
+        self.graph["name"] = s
+
+    def __str__(self):
+        """Returns a short summary of the graph.
+
+        Returns
+        -------
+        info : string
+            Graph information as provided by `nx.info`
+
+        Examples
+        --------
+        >>> G = nx.Graph(name="foo")
+        >>> str(G)
+        "Graph named 'foo' with 0 nodes and 0 edges"
+
+        >>> G = nx.path_graph(3)
+        >>> str(G)
+        'Graph with 3 nodes and 2 edges'
+
+        """
+        return "".join(
+            [
+                type(self).__name__,
+                f" named {self.name!r}" if self.name else "",
+                f" with {self.number_of_nodes()} nodes and {self.number_of_edges()} edges",
+            ]
+        )
+
+    def __iter__(self):
+        """Iterate over the nodes. Use: 'for n in G'.
+
+        Returns
+        -------
+        niter : iterator
+            An iterator over all nodes in the graph.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> [n for n in G]
+        [0, 1, 2, 3]
+        >>> list(G)
+        [0, 1, 2, 3]
+        """
+        return iter(self._node)
+
+    def __contains__(self, n):
+        """Returns True if n is a node, False otherwise. Use: 'n in G'.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> 1 in G
+        True
+        """
+        try:
+            return n in self._node
+        except TypeError:
+            return False
+
+    def __len__(self):
+        """Returns the number of nodes in the graph. Use: 'len(G)'.
+
+        Returns
+        -------
+        nnodes : int
+            The number of nodes in the graph.
+
+        See Also
+        --------
+        number_of_nodes: identical method
+        order: identical method
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> len(G)
+        4
+
+        """
+        return len(self._node)
+
+    def __getitem__(self, n):
+        """Returns a dict of neighbors of node n.  Use: 'G[n]'.
+
+        Parameters
+        ----------
+        n : node
+           A node in the graph.
+
+        Returns
+        -------
+        adj_dict : dictionary
+           The adjacency dictionary for nodes connected to n.
+
+        Notes
+        -----
+        G[n] is the same as G.adj[n] and similar to G.neighbors(n)
+        (which is an iterator over G.adj[n])
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G[0]
+        AtlasView({1: {}})
+        """
+        return self.adj[n]
+
+    def add_node(self, node_for_adding, **attr):
+        """Add a single node `node_for_adding` and update node attributes.
+
+        Parameters
+        ----------
+        node_for_adding : node
+            A node can be any hashable Python object except None.
+        attr : keyword arguments, optional
+            Set or change node attributes using key=value.
+
+        See Also
+        --------
+        add_nodes_from
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.add_node(1)
+        >>> G.add_node("Hello")
+        >>> K3 = nx.Graph([(0, 1), (1, 2), (2, 0)])
+        >>> G.add_node(K3)
+        >>> G.number_of_nodes()
+        3
+
+        Use keywords set/change node attributes:
+
+        >>> G.add_node(1, size=10)
+        >>> G.add_node(3, weight=0.4, UTM=("13S", 382871, 3972649))
+
+        Notes
+        -----
+        A hashable object is one that can be used as a key in a Python
+        dictionary. This includes strings, numbers, tuples of strings
+        and numbers, etc.
+
+        On many platforms hashable items also include mutables such as
+        NetworkX Graphs, though one should be careful that the hash
+        doesn't change on mutables.
+        """
+        if node_for_adding not in self._node:
+            if node_for_adding is None:
+                raise ValueError("None cannot be a node")
+            self._adj[node_for_adding] = self.adjlist_inner_dict_factory()
+            attr_dict = self._node[node_for_adding] = self.node_attr_dict_factory()
+            attr_dict.update(attr)
+        else:  # update attr even if node already exists
+            self._node[node_for_adding].update(attr)
+
+    def add_nodes_from(self, nodes_for_adding, **attr):
+        """Add multiple nodes.
+
+        Parameters
+        ----------
+        nodes_for_adding : iterable container
+            A container of nodes (list, dict, set, etc.).
+            OR
+            A container of (node, attribute dict) tuples.
+            Node attributes are updated using the attribute dict.
+        attr : keyword arguments, optional (default= no attributes)
+            Update attributes for all nodes in nodes.
+            Node attributes specified in nodes as a tuple take
+            precedence over attributes specified via keyword arguments.
+
+        See Also
+        --------
+        add_node
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.add_nodes_from("Hello")
+        >>> K3 = nx.Graph([(0, 1), (1, 2), (2, 0)])
+        >>> G.add_nodes_from(K3)
+        >>> sorted(G.nodes(), key=str)
+        [0, 1, 2, 'H', 'e', 'l', 'o']
+
+        Use keywords to update specific node attributes for every node.
+
+        >>> G.add_nodes_from([1, 2], size=10)
+        >>> G.add_nodes_from([3, 4], weight=0.4)
+
+        Use (node, attrdict) tuples to update attributes for specific nodes.
+
+        >>> G.add_nodes_from([(1, dict(size=11)), (2, {"color": "blue"})])
+        >>> G.nodes[1]["size"]
+        11
+        >>> H = nx.Graph()
+        >>> H.add_nodes_from(G.nodes(data=True))
+        >>> H.nodes[1]["size"]
+        11
+
+        """
+        for n in nodes_for_adding:
+            try:
+                newnode = n not in self._node
+                newdict = attr
+            except TypeError:
+                n, ndict = n
+                newnode = n not in self._node
+                newdict = attr.copy()
+                newdict.update(ndict)
+            if newnode:
+                if n is None:
+                    raise ValueError("None cannot be a node")
+                self._adj[n] = self.adjlist_inner_dict_factory()
+                self._node[n] = self.node_attr_dict_factory()
+            self._node[n].update(newdict)
+
+    def remove_node(self, n):
+        """Remove node n.
+
+        Removes the node n and all adjacent edges.
+        Attempting to remove a non-existent node will raise an exception.
+
+        Parameters
+        ----------
+        n : node
+           A node in the graph
+
+        Raises
+        ------
+        NetworkXError
+           If n is not in the graph.
+
+        See Also
+        --------
+        remove_nodes_from
+
+        Examples
+        --------
+        >>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> list(G.edges)
+        [(0, 1), (1, 2)]
+        >>> G.remove_node(1)
+        >>> list(G.edges)
+        []
+
+        """
+        adj = self._adj
+        try:
+            nbrs = list(adj[n])  # list handles self-loops (allows mutation)
+            del self._node[n]
+        except KeyError as err:  # NetworkXError if n not in self
+            raise NetworkXError(f"The node {n} is not in the graph.") from err
+        for u in nbrs:
+            del adj[u][n]  # remove all edges n-u in graph
+        del adj[n]  # now remove node
+
+    def remove_nodes_from(self, nodes):
+        """Remove multiple nodes.
+
+        Parameters
+        ----------
+        nodes : iterable container
+            A container of nodes (list, dict, set, etc.).  If a node
+            in the container is not in the graph it is silently
+            ignored.
+
+        See Also
+        --------
+        remove_node
+
+        Examples
+        --------
+        >>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> e = list(G.nodes)
+        >>> e
+        [0, 1, 2]
+        >>> G.remove_nodes_from(e)
+        >>> list(G.nodes)
+        []
+
+        """
+        adj = self._adj
+        for n in nodes:
+            try:
+                del self._node[n]
+                for u in list(adj[n]):  # list handles self-loops
+                    del adj[u][n]  # (allows mutation of dict in loop)
+                del adj[n]
+            except KeyError:
+                pass
+
+    @cached_property
+    def nodes(self):
+        """A NodeView of the Graph as G.nodes or G.nodes().
+
+        Can be used as `G.nodes` for data lookup and for set-like operations.
+        Can also be used as `G.nodes(data='color', default=None)` to return a
+        NodeDataView which reports specific node data but no set operations.
+        It presents a dict-like interface as well with `G.nodes.items()`
+        iterating over `(node, nodedata)` 2-tuples and `G.nodes[3]['foo']`
+        providing the value of the `foo` attribute for node `3`. In addition,
+        a view `G.nodes.data('foo')` provides a dict-like interface to the
+        `foo` attribute of each node. `G.nodes.data('foo', default=1)`
+        provides a default for nodes that do not have attribute `foo`.
+
+        Parameters
+        ----------
+        data : string or bool, optional (default=False)
+            The node attribute returned in 2-tuple (n, ddict[data]).
+            If True, return entire node attribute dict as (n, ddict).
+            If False, return just the nodes n.
+
+        default : value, optional (default=None)
+            Value used for nodes that don't have the requested attribute.
+            Only relevant if data is not True or False.
+
+        Returns
+        -------
+        NodeView
+            Allows set-like operations over the nodes as well as node
+            attribute dict lookup and calling to get a NodeDataView.
+            A NodeDataView iterates over `(n, data)` and has no set operations.
+            A NodeView iterates over `n` and includes set operations.
+
+            When called, if data is False, an iterator over nodes.
+            Otherwise an iterator of 2-tuples (node, attribute value)
+            where the attribute is specified in `data`.
+            If data is True then the attribute becomes the
+            entire data dictionary.
+
+        Notes
+        -----
+        If your node data is not needed, it is simpler and equivalent
+        to use the expression ``for n in G``, or ``list(G)``.
+
+        Examples
+        --------
+        There are two simple ways of getting a list of all nodes in the graph:
+
+        >>> G = nx.path_graph(3)
+        >>> list(G.nodes)
+        [0, 1, 2]
+        >>> list(G)
+        [0, 1, 2]
+
+        To get the node data along with the nodes:
+
+        >>> G.add_node(1, time="5pm")
+        >>> G.nodes[0]["foo"] = "bar"
+        >>> list(G.nodes(data=True))
+        [(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})]
+        >>> list(G.nodes.data())
+        [(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})]
+
+        >>> list(G.nodes(data="foo"))
+        [(0, 'bar'), (1, None), (2, None)]
+        >>> list(G.nodes.data("foo"))
+        [(0, 'bar'), (1, None), (2, None)]
+
+        >>> list(G.nodes(data="time"))
+        [(0, None), (1, '5pm'), (2, None)]
+        >>> list(G.nodes.data("time"))
+        [(0, None), (1, '5pm'), (2, None)]
+
+        >>> list(G.nodes(data="time", default="Not Available"))
+        [(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')]
+        >>> list(G.nodes.data("time", default="Not Available"))
+        [(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')]
+
+        If some of your nodes have an attribute and the rest are assumed
+        to have a default attribute value you can create a dictionary
+        from node/attribute pairs using the `default` keyword argument
+        to guarantee the value is never None::
+
+            >>> G = nx.Graph()
+            >>> G.add_node(0)
+            >>> G.add_node(1, weight=2)
+            >>> G.add_node(2, weight=3)
+            >>> dict(G.nodes(data="weight", default=1))
+            {0: 1, 1: 2, 2: 3}
+
+        """
+        return NodeView(self)
+
+    def number_of_nodes(self):
+        """Returns the number of nodes in the graph.
+
+        Returns
+        -------
+        nnodes : int
+            The number of nodes in the graph.
+
+        See Also
+        --------
+        order: identical method
+        __len__: identical method
+
+        Examples
+        --------
+        >>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.number_of_nodes()
+        3
+        """
+        return len(self._node)
+
+    def order(self):
+        """Returns the number of nodes in the graph.
+
+        Returns
+        -------
+        nnodes : int
+            The number of nodes in the graph.
+
+        See Also
+        --------
+        number_of_nodes: identical method
+        __len__: identical method
+
+        Examples
+        --------
+        >>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.order()
+        3
+        """
+        return len(self._node)
+
+    def has_node(self, n):
+        """Returns True if the graph contains the node n.
+
+        Identical to `n in G`
+
+        Parameters
+        ----------
+        n : node
+
+        Examples
+        --------
+        >>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.has_node(0)
+        True
+
+        It is more readable and simpler to use
+
+        >>> 0 in G
+        True
+
+        """
+        try:
+            return n in self._node
+        except TypeError:
+            return False
+
+    def add_edge(self, u_of_edge, v_of_edge, **attr):
+        """Add an edge between u and v.
+
+        The nodes u and v will be automatically added if they are
+        not already in the graph.
+
+        Edge attributes can be specified with keywords or by directly
+        accessing the edge's attribute dictionary. See examples below.
+
+        Parameters
+        ----------
+        u_of_edge, v_of_edge : nodes
+            Nodes can be, for example, strings or numbers.
+            Nodes must be hashable (and not None) Python objects.
+        attr : keyword arguments, optional
+            Edge data (or labels or objects) can be assigned using
+            keyword arguments.
+
+        See Also
+        --------
+        add_edges_from : add a collection of edges
+
+        Notes
+        -----
+        Adding an edge that already exists updates the edge data.
+
+        Many NetworkX algorithms designed for weighted graphs use
+        an edge attribute (by default `weight`) to hold a numerical value.
+
+        Examples
+        --------
+        The following all add the edge e=(1, 2) to graph G:
+
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> e = (1, 2)
+        >>> G.add_edge(1, 2)  # explicit two-node form
+        >>> G.add_edge(*e)  # single edge as tuple of two nodes
+        >>> G.add_edges_from([(1, 2)])  # add edges from iterable container
+
+        Associate data to edges using keywords:
+
+        >>> G.add_edge(1, 2, weight=3)
+        >>> G.add_edge(1, 3, weight=7, capacity=15, length=342.7)
+
+        For non-string attribute keys, use subscript notation.
+
+        >>> G.add_edge(1, 2)
+        >>> G[1][2].update({0: 5})
+        >>> G.edges[1, 2].update({0: 5})
+        """
+        u, v = u_of_edge, v_of_edge
+        # add nodes
+        if u not in self._node:
+            if u is None:
+                raise ValueError("None cannot be a node")
+            self._adj[u] = self.adjlist_inner_dict_factory()
+            self._node[u] = self.node_attr_dict_factory()
+        if v not in self._node:
+            if v is None:
+                raise ValueError("None cannot be a node")
+            self._adj[v] = self.adjlist_inner_dict_factory()
+            self._node[v] = self.node_attr_dict_factory()
+        # add the edge
+        datadict = self._adj[u].get(v, self.edge_attr_dict_factory())
+        datadict.update(attr)
+        self._adj[u][v] = datadict
+        self._adj[v][u] = datadict
+
+    def add_edges_from(self, ebunch_to_add, **attr):
+        """Add all the edges in ebunch_to_add.
+
+        Parameters
+        ----------
+        ebunch_to_add : container of edges
+            Each edge given in the container will be added to the
+            graph. The edges must be given as 2-tuples (u, v) or
+            3-tuples (u, v, d) where d is a dictionary containing edge data.
+        attr : keyword arguments, optional
+            Edge data (or labels or objects) can be assigned using
+            keyword arguments.
+
+        See Also
+        --------
+        add_edge : add a single edge
+        add_weighted_edges_from : convenient way to add weighted edges
+
+        Notes
+        -----
+        Adding the same edge twice has no effect but any edge data
+        will be updated when each duplicate edge is added.
+
+        Edge attributes specified in an ebunch take precedence over
+        attributes specified via keyword arguments.
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.add_edges_from([(0, 1), (1, 2)])  # using a list of edge tuples
+        >>> e = zip(range(0, 3), range(1, 4))
+        >>> G.add_edges_from(e)  # Add the path graph 0-1-2-3
+
+        Associate data to edges
+
+        >>> G.add_edges_from([(1, 2), (2, 3)], weight=3)
+        >>> G.add_edges_from([(3, 4), (1, 4)], label="WN2898")
+        """
+        for e in ebunch_to_add:
+            ne = len(e)
+            if ne == 3:
+                u, v, dd = e
+            elif ne == 2:
+                u, v = e
+                dd = {}  # doesn't need edge_attr_dict_factory
+            else:
+                raise NetworkXError(f"Edge tuple {e} must be a 2-tuple or 3-tuple.")
+            if u not in self._node:
+                if u is None:
+                    raise ValueError("None cannot be a node")
+                self._adj[u] = self.adjlist_inner_dict_factory()
+                self._node[u] = self.node_attr_dict_factory()
+            if v not in self._node:
+                if v is None:
+                    raise ValueError("None cannot be a node")
+                self._adj[v] = self.adjlist_inner_dict_factory()
+                self._node[v] = self.node_attr_dict_factory()
+            datadict = self._adj[u].get(v, self.edge_attr_dict_factory())
+            datadict.update(attr)
+            datadict.update(dd)
+            self._adj[u][v] = datadict
+            self._adj[v][u] = datadict
+
+    def add_weighted_edges_from(self, ebunch_to_add, weight="weight", **attr):
+        """Add weighted edges in `ebunch_to_add` with specified weight attr
+
+        Parameters
+        ----------
+        ebunch_to_add : container of edges
+            Each edge given in the list or container will be added
+            to the graph. The edges must be given as 3-tuples (u, v, w)
+            where w is a number.
+        weight : string, optional (default= 'weight')
+            The attribute name for the edge weights to be added.
+        attr : keyword arguments, optional (default= no attributes)
+            Edge attributes to add/update for all edges.
+
+        See Also
+        --------
+        add_edge : add a single edge
+        add_edges_from : add multiple edges
+
+        Notes
+        -----
+        Adding the same edge twice for Graph/DiGraph simply updates
+        the edge data. For MultiGraph/MultiDiGraph, duplicate edges
+        are stored.
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.add_weighted_edges_from([(0, 1, 3.0), (1, 2, 7.5)])
+        """
+        self.add_edges_from(((u, v, {weight: d}) for u, v, d in ebunch_to_add), **attr)
+
+    def remove_edge(self, u, v):
+        """Remove the edge between u and v.
+
+        Parameters
+        ----------
+        u, v : nodes
+            Remove the edge between nodes u and v.
+
+        Raises
+        ------
+        NetworkXError
+            If there is not an edge between u and v.
+
+        See Also
+        --------
+        remove_edges_from : remove a collection of edges
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, etc
+        >>> G.remove_edge(0, 1)
+        >>> e = (1, 2)
+        >>> G.remove_edge(*e)  # unpacks e from an edge tuple
+        >>> e = (2, 3, {"weight": 7})  # an edge with attribute data
+        >>> G.remove_edge(*e[:2])  # select first part of edge tuple
+        """
+        try:
+            del self._adj[u][v]
+            if u != v:  # self-loop needs only one entry removed
+                del self._adj[v][u]
+        except KeyError as err:
+            raise NetworkXError(f"The edge {u}-{v} is not in the graph") from err
+
+    def remove_edges_from(self, ebunch):
+        """Remove all edges specified in ebunch.
+
+        Parameters
+        ----------
+        ebunch: list or container of edge tuples
+            Each edge given in the list or container will be removed
+            from the graph. The edges can be:
+
+                - 2-tuples (u, v) edge between u and v.
+                - 3-tuples (u, v, k) where k is ignored.
+
+        See Also
+        --------
+        remove_edge : remove a single edge
+
+        Notes
+        -----
+        Will fail silently if an edge in ebunch is not in the graph.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> ebunch = [(1, 2), (2, 3)]
+        >>> G.remove_edges_from(ebunch)
+        """
+        adj = self._adj
+        for e in ebunch:
+            u, v = e[:2]  # ignore edge data if present
+            if u in adj and v in adj[u]:
+                del adj[u][v]
+                if u != v:  # self loop needs only one entry removed
+                    del adj[v][u]
+
+    def update(self, edges=None, nodes=None):
+        """Update the graph using nodes/edges/graphs as input.
+
+        Like dict.update, this method takes a graph as input, adding the
+        graph's nodes and edges to this graph. It can also take two inputs:
+        edges and nodes. Finally it can take either edges or nodes.
+        To specify only nodes the keyword `nodes` must be used.
+
+        The collections of edges and nodes are treated similarly to
+        the add_edges_from/add_nodes_from methods. When iterated, they
+        should yield 2-tuples (u, v) or 3-tuples (u, v, datadict).
+
+        Parameters
+        ----------
+        edges : Graph object, collection of edges, or None
+            The first parameter can be a graph or some edges. If it has
+            attributes `nodes` and `edges`, then it is taken to be a
+            Graph-like object and those attributes are used as collections
+            of nodes and edges to be added to the graph.
+            If the first parameter does not have those attributes, it is
+            treated as a collection of edges and added to the graph.
+            If the first argument is None, no edges are added.
+        nodes : collection of nodes, or None
+            The second parameter is treated as a collection of nodes
+            to be added to the graph unless it is None.
+            If `edges is None` and `nodes is None` an exception is raised.
+            If the first parameter is a Graph, then `nodes` is ignored.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(5)
+        >>> G.update(nx.complete_graph(range(4, 10)))
+        >>> from itertools import combinations
+        >>> edges = (
+        ...     (u, v, {"power": u * v})
+        ...     for u, v in combinations(range(10, 20), 2)
+        ...     if u * v < 225
+        ... )
+        >>> nodes = [1000]  # for singleton, use a container
+        >>> G.update(edges, nodes)
+
+        Notes
+        -----
+        It you want to update the graph using an adjacency structure
+        it is straightforward to obtain the edges/nodes from adjacency.
+        The following examples provide common cases, your adjacency may
+        be slightly different and require tweaks of these examples::
+
+        >>> # dict-of-set/list/tuple
+        >>> adj = {1: {2, 3}, 2: {1, 3}, 3: {1, 2}}
+        >>> e = [(u, v) for u, nbrs in adj.items() for v in nbrs]
+        >>> G.update(edges=e, nodes=adj)
+
+        >>> DG = nx.DiGraph()
+        >>> # dict-of-dict-of-attribute
+        >>> adj = {1: {2: 1.3, 3: 0.7}, 2: {1: 1.4}, 3: {1: 0.7}}
+        >>> e = [
+        ...     (u, v, {"weight": d})
+        ...     for u, nbrs in adj.items()
+        ...     for v, d in nbrs.items()
+        ... ]
+        >>> DG.update(edges=e, nodes=adj)
+
+        >>> # dict-of-dict-of-dict
+        >>> adj = {1: {2: {"weight": 1.3}, 3: {"color": 0.7, "weight": 1.2}}}
+        >>> e = [
+        ...     (u, v, {"weight": d})
+        ...     for u, nbrs in adj.items()
+        ...     for v, d in nbrs.items()
+        ... ]
+        >>> DG.update(edges=e, nodes=adj)
+
+        >>> # predecessor adjacency (dict-of-set)
+        >>> pred = {1: {2, 3}, 2: {3}, 3: {3}}
+        >>> e = [(v, u) for u, nbrs in pred.items() for v in nbrs]
+
+        >>> # MultiGraph dict-of-dict-of-dict-of-attribute
+        >>> MDG = nx.MultiDiGraph()
+        >>> adj = {
+        ...     1: {2: {0: {"weight": 1.3}, 1: {"weight": 1.2}}},
+        ...     3: {2: {0: {"weight": 0.7}}},
+        ... }
+        >>> e = [
+        ...     (u, v, ekey, d)
+        ...     for u, nbrs in adj.items()
+        ...     for v, keydict in nbrs.items()
+        ...     for ekey, d in keydict.items()
+        ... ]
+        >>> MDG.update(edges=e)
+
+        See Also
+        --------
+        add_edges_from: add multiple edges to a graph
+        add_nodes_from: add multiple nodes to a graph
+        """
+        if edges is not None:
+            if nodes is not None:
+                self.add_nodes_from(nodes)
+                self.add_edges_from(edges)
+            else:
+                # check if edges is a Graph object
+                try:
+                    graph_nodes = edges.nodes
+                    graph_edges = edges.edges
+                except AttributeError:
+                    # edge not Graph-like
+                    self.add_edges_from(edges)
+                else:  # edges is Graph-like
+                    self.add_nodes_from(graph_nodes.data())
+                    self.add_edges_from(graph_edges.data())
+                    self.graph.update(edges.graph)
+        elif nodes is not None:
+            self.add_nodes_from(nodes)
+        else:
+            raise NetworkXError("update needs nodes or edges input")
+
+    def has_edge(self, u, v):
+        """Returns True if the edge (u, v) is in the graph.
+
+        This is the same as `v in G[u]` without KeyError exceptions.
+
+        Parameters
+        ----------
+        u, v : nodes
+            Nodes can be, for example, strings or numbers.
+            Nodes must be hashable (and not None) Python objects.
+
+        Returns
+        -------
+        edge_ind : bool
+            True if edge is in the graph, False otherwise.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.has_edge(0, 1)  # using two nodes
+        True
+        >>> e = (0, 1)
+        >>> G.has_edge(*e)  #  e is a 2-tuple (u, v)
+        True
+        >>> e = (0, 1, {"weight": 7})
+        >>> G.has_edge(*e[:2])  # e is a 3-tuple (u, v, data_dictionary)
+        True
+
+        The following syntax are equivalent:
+
+        >>> G.has_edge(0, 1)
+        True
+        >>> 1 in G[0]  # though this gives KeyError if 0 not in G
+        True
+
+        """
+        try:
+            return v in self._adj[u]
+        except KeyError:
+            return False
+
+    def neighbors(self, n):
+        """Returns an iterator over all neighbors of node n.
+
+        This is identical to `iter(G[n])`
+
+        Parameters
+        ----------
+        n : node
+           A node in the graph
+
+        Returns
+        -------
+        neighbors : iterator
+            An iterator over all neighbors of node n
+
+        Raises
+        ------
+        NetworkXError
+            If the node n is not in the graph.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> [n for n in G.neighbors(0)]
+        [1]
+
+        Notes
+        -----
+        Alternate ways to access the neighbors are ``G.adj[n]`` or ``G[n]``:
+
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.add_edge("a", "b", weight=7)
+        >>> G["a"]
+        AtlasView({'b': {'weight': 7}})
+        >>> G = nx.path_graph(4)
+        >>> [n for n in G[0]]
+        [1]
+        """
+        try:
+            return iter(self._adj[n])
+        except KeyError as err:
+            raise NetworkXError(f"The node {n} is not in the graph.") from err
+
+    @cached_property
+    def edges(self):
+        """An EdgeView of the Graph as G.edges or G.edges().
+
+        edges(self, nbunch=None, data=False, default=None)
+
+        The EdgeView provides set-like operations on the edge-tuples
+        as well as edge attribute lookup. When called, it also provides
+        an EdgeDataView object which allows control of access to edge
+        attributes (but does not provide set-like operations).
+        Hence, `G.edges[u, v]['color']` provides the value of the color
+        attribute for edge `(u, v)` while
+        `for (u, v, c) in G.edges.data('color', default='red'):`
+        iterates through all the edges yielding the color attribute
+        with default `'red'` if no color attribute exists.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges from these nodes.
+        data : string or bool, optional (default=False)
+            The edge attribute returned in 3-tuple (u, v, ddict[data]).
+            If True, return edge attribute dict in 3-tuple (u, v, ddict).
+            If False, return 2-tuple (u, v).
+        default : value, optional (default=None)
+            Value used for edges that don't have the requested attribute.
+            Only relevant if data is not True or False.
+
+        Returns
+        -------
+        edges : EdgeView
+            A view of edge attributes, usually it iterates over (u, v)
+            or (u, v, d) tuples of edges, but can also be used for
+            attribute lookup as `edges[u, v]['foo']`.
+
+        Notes
+        -----
+        Nodes in nbunch that are not in the graph will be (quietly) ignored.
+        For directed graphs this returns the out-edges.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(3)  # or MultiGraph, etc
+        >>> G.add_edge(2, 3, weight=5)
+        >>> [e for e in G.edges]
+        [(0, 1), (1, 2), (2, 3)]
+        >>> G.edges.data()  # default data is {} (empty dict)
+        EdgeDataView([(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})])
+        >>> G.edges.data("weight", default=1)
+        EdgeDataView([(0, 1, 1), (1, 2, 1), (2, 3, 5)])
+        >>> G.edges([0, 3])  # only edges from these nodes
+        EdgeDataView([(0, 1), (3, 2)])
+        >>> G.edges(0)  # only edges from node 0
+        EdgeDataView([(0, 1)])
+        """
+        return EdgeView(self)
+
+    def get_edge_data(self, u, v, default=None):
+        """Returns the attribute dictionary associated with edge (u, v).
+
+        This is identical to `G[u][v]` except the default is returned
+        instead of an exception if the edge doesn't exist.
+
+        Parameters
+        ----------
+        u, v : nodes
+        default:  any Python object (default=None)
+            Value to return if the edge (u, v) is not found.
+
+        Returns
+        -------
+        edge_dict : dictionary
+            The edge attribute dictionary.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G[0][1]
+        {}
+
+        Warning: Assigning to `G[u][v]` is not permitted.
+        But it is safe to assign attributes `G[u][v]['foo']`
+
+        >>> G[0][1]["weight"] = 7
+        >>> G[0][1]["weight"]
+        7
+        >>> G[1][0]["weight"]
+        7
+
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.get_edge_data(0, 1)  # default edge data is {}
+        {}
+        >>> e = (0, 1)
+        >>> G.get_edge_data(*e)  # tuple form
+        {}
+        >>> G.get_edge_data("a", "b", default=0)  # edge not in graph, return 0
+        0
+        """
+        try:
+            return self._adj[u][v]
+        except KeyError:
+            return default
+
+    def adjacency(self):
+        """Returns an iterator over (node, adjacency dict) tuples for all nodes.
+
+        For directed graphs, only outgoing neighbors/adjacencies are included.
+
+        Returns
+        -------
+        adj_iter : iterator
+           An iterator over (node, adjacency dictionary) for all nodes in
+           the graph.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> [(n, nbrdict) for n, nbrdict in G.adjacency()]
+        [(0, {1: {}}), (1, {0: {}, 2: {}}), (2, {1: {}, 3: {}}), (3, {2: {}})]
+
+        """
+        return iter(self._adj.items())
+
+    @cached_property
+    def degree(self):
+        """A DegreeView for the Graph as G.degree or G.degree().
+
+        The node degree is the number of edges adjacent to the node.
+        The weighted node degree is the sum of the edge weights for
+        edges incident to that node.
+
+        This object provides an iterator for (node, degree) as well as
+        lookup for the degree for a single node.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges incident to these nodes.
+
+        weight : string or None, optional (default=None)
+           The name of an edge attribute that holds the numerical value used
+           as a weight.  If None, then each edge has weight 1.
+           The degree is the sum of the edge weights adjacent to the node.
+
+        Returns
+        -------
+        DegreeView or int
+            If multiple nodes are requested (the default), returns a `DegreeView`
+            mapping nodes to their degree.
+            If a single node is requested, returns the degree of the node as an integer.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.degree[0]  # node 0 has degree 1
+        1
+        >>> list(G.degree([0, 1, 2]))
+        [(0, 1), (1, 2), (2, 2)]
+        """
+        return DegreeView(self)
+
+    def clear(self):
+        """Remove all nodes and edges from the graph.
+
+        This also removes the name, and all graph, node, and edge attributes.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.clear()
+        >>> list(G.nodes)
+        []
+        >>> list(G.edges)
+        []
+
+        """
+        self._adj.clear()
+        self._node.clear()
+        self.graph.clear()
+
+    def clear_edges(self):
+        """Remove all edges from the graph without altering nodes.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.clear_edges()
+        >>> list(G.nodes)
+        [0, 1, 2, 3]
+        >>> list(G.edges)
+        []
+        """
+        for neighbours_dict in self._adj.values():
+            neighbours_dict.clear()
+
+    def is_multigraph(self):
+        """Returns True if graph is a multigraph, False otherwise."""
+        return False
+
+    def is_directed(self):
+        """Returns True if graph is directed, False otherwise."""
+        return False
+
+    def copy(self, as_view=False):
+        """Returns a copy of the graph.
+
+        The copy method by default returns an independent shallow copy
+        of the graph and attributes. That is, if an attribute is a
+        container, that container is shared by the original an the copy.
+        Use Python's `copy.deepcopy` for new containers.
+
+        If `as_view` is True then a view is returned instead of a copy.
+
+        Notes
+        -----
+        All copies reproduce the graph structure, but data attributes
+        may be handled in different ways. There are four types of copies
+        of a graph that people might want.
+
+        Deepcopy -- A "deepcopy" copies the graph structure as well as
+        all data attributes and any objects they might contain.
+        The entire graph object is new so that changes in the copy
+        do not affect the original object. (see Python's copy.deepcopy)
+
+        Data Reference (Shallow) -- For a shallow copy the graph structure
+        is copied but the edge, node and graph attribute dicts are
+        references to those in the original graph. This saves
+        time and memory but could cause confusion if you change an attribute
+        in one graph and it changes the attribute in the other.
+        NetworkX does not provide this level of shallow copy.
+
+        Independent Shallow -- This copy creates new independent attribute
+        dicts and then does a shallow copy of the attributes. That is, any
+        attributes that are containers are shared between the new graph
+        and the original. This is exactly what `dict.copy()` provides.
+        You can obtain this style copy using:
+
+            >>> G = nx.path_graph(5)
+            >>> H = G.copy()
+            >>> H = G.copy(as_view=False)
+            >>> H = nx.Graph(G)
+            >>> H = G.__class__(G)
+
+        Fresh Data -- For fresh data, the graph structure is copied while
+        new empty data attribute dicts are created. The resulting graph
+        is independent of the original and it has no edge, node or graph
+        attributes. Fresh copies are not enabled. Instead use:
+
+            >>> H = G.__class__()
+            >>> H.add_nodes_from(G)
+            >>> H.add_edges_from(G.edges)
+
+        View -- Inspired by dict-views, graph-views act like read-only
+        versions of the original graph, providing a copy of the original
+        structure without requiring any memory for copying the information.
+
+        See the Python copy module for more information on shallow
+        and deep copies, https://docs.python.org/3/library/copy.html.
+
+        Parameters
+        ----------
+        as_view : bool, optional (default=False)
+            If True, the returned graph-view provides a read-only view
+            of the original graph without actually copying any data.
+
+        Returns
+        -------
+        G : Graph
+            A copy of the graph.
+
+        See Also
+        --------
+        to_directed: return a directed copy of the graph.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> H = G.copy()
+
+        """
+        if as_view is True:
+            return nx.graphviews.generic_graph_view(self)
+        G = self.__class__()
+        G.graph.update(self.graph)
+        G.add_nodes_from((n, d.copy()) for n, d in self._node.items())
+        G.add_edges_from(
+            (u, v, datadict.copy())
+            for u, nbrs in self._adj.items()
+            for v, datadict in nbrs.items()
+        )
+        return G
+
+    def to_directed(self, as_view=False):
+        """Returns a directed representation of the graph.
+
+        Returns
+        -------
+        G : DiGraph
+            A directed graph with the same name, same nodes, and with
+            each edge (u, v, data) replaced by two directed edges
+            (u, v, data) and (v, u, data).
+
+        Notes
+        -----
+        This returns a "deepcopy" of the edge, node, and
+        graph attributes which attempts to completely copy
+        all of the data and references.
+
+        This is in contrast to the similar D=DiGraph(G) which returns a
+        shallow copy of the data.
+
+        See the Python copy module for more information on shallow
+        and deep copies, https://docs.python.org/3/library/copy.html.
+
+        Warning: If you have subclassed Graph to use dict-like objects
+        in the data structure, those changes do not transfer to the
+        DiGraph created by this method.
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or MultiGraph, etc
+        >>> G.add_edge(0, 1)
+        >>> H = G.to_directed()
+        >>> list(H.edges)
+        [(0, 1), (1, 0)]
+
+        If already directed, return a (deep) copy
+
+        >>> G = nx.DiGraph()  # or MultiDiGraph, etc
+        >>> G.add_edge(0, 1)
+        >>> H = G.to_directed()
+        >>> list(H.edges)
+        [(0, 1)]
+        """
+        graph_class = self.to_directed_class()
+        if as_view is True:
+            return nx.graphviews.generic_graph_view(self, graph_class)
+        # deepcopy when not a view
+        G = graph_class()
+        G.graph.update(deepcopy(self.graph))
+        G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
+        G.add_edges_from(
+            (u, v, deepcopy(data))
+            for u, nbrs in self._adj.items()
+            for v, data in nbrs.items()
+        )
+        return G
+
+    def to_undirected(self, as_view=False):
+        """Returns an undirected copy of the graph.
+
+        Parameters
+        ----------
+        as_view : bool (optional, default=False)
+          If True return a view of the original undirected graph.
+
+        Returns
+        -------
+        G : Graph/MultiGraph
+            A deepcopy of the graph.
+
+        See Also
+        --------
+        Graph, copy, add_edge, add_edges_from
+
+        Notes
+        -----
+        This returns a "deepcopy" of the edge, node, and
+        graph attributes which attempts to completely copy
+        all of the data and references.
+
+        This is in contrast to the similar `G = nx.DiGraph(D)` which returns a
+        shallow copy of the data.
+
+        See the Python copy module for more information on shallow
+        and deep copies, https://docs.python.org/3/library/copy.html.
+
+        Warning: If you have subclassed DiGraph to use dict-like objects
+        in the data structure, those changes do not transfer to the
+        Graph created by this method.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(2)  # or MultiGraph, etc
+        >>> H = G.to_directed()
+        >>> list(H.edges)
+        [(0, 1), (1, 0)]
+        >>> G2 = H.to_undirected()
+        >>> list(G2.edges)
+        [(0, 1)]
+        """
+        graph_class = self.to_undirected_class()
+        if as_view is True:
+            return nx.graphviews.generic_graph_view(self, graph_class)
+        # deepcopy when not a view
+        G = graph_class()
+        G.graph.update(deepcopy(self.graph))
+        G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
+        G.add_edges_from(
+            (u, v, deepcopy(d))
+            for u, nbrs in self._adj.items()
+            for v, d in nbrs.items()
+        )
+        return G
+
+    def subgraph(self, nodes):
+        """Returns a SubGraph view of the subgraph induced on `nodes`.
+
+        The induced subgraph of the graph contains the nodes in `nodes`
+        and the edges between those nodes.
+
+        Parameters
+        ----------
+        nodes : list, iterable
+            A container of nodes which will be iterated through once.
+
+        Returns
+        -------
+        G : SubGraph View
+            A subgraph view of the graph. The graph structure cannot be
+            changed but node/edge attributes can and are shared with the
+            original graph.
+
+        Notes
+        -----
+        The graph, edge and node attributes are shared with the original graph.
+        Changes to the graph structure is ruled out by the view, but changes
+        to attributes are reflected in the original graph.
+
+        To create a subgraph with its own copy of the edge/node attributes use:
+        G.subgraph(nodes).copy()
+
+        For an inplace reduction of a graph to a subgraph you can remove nodes:
+        G.remove_nodes_from([n for n in G if n not in set(nodes)])
+
+        Subgraph views are sometimes NOT what you want. In most cases where
+        you want to do more than simply look at the induced edges, it makes
+        more sense to just create the subgraph as its own graph with code like:
+
+        ::
+
+            # Create a subgraph SG based on a (possibly multigraph) G
+            SG = G.__class__()
+            SG.add_nodes_from((n, G.nodes[n]) for n in largest_wcc)
+            if SG.is_multigraph():
+                SG.add_edges_from((n, nbr, key, d)
+                    for n, nbrs in G.adj.items() if n in largest_wcc
+                    for nbr, keydict in nbrs.items() if nbr in largest_wcc
+                    for key, d in keydict.items())
+            else:
+                SG.add_edges_from((n, nbr, d)
+                    for n, nbrs in G.adj.items() if n in largest_wcc
+                    for nbr, d in nbrs.items() if nbr in largest_wcc)
+            SG.graph.update(G.graph)
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> H = G.subgraph([0, 1, 2])
+        >>> list(H.edges)
+        [(0, 1), (1, 2)]
+        """
+        induced_nodes = nx.filters.show_nodes(self.nbunch_iter(nodes))
+        # if already a subgraph, don't make a chain
+        subgraph = nx.graphviews.subgraph_view
+        if hasattr(self, "_NODE_OK"):
+            return subgraph(self._graph, induced_nodes, self._EDGE_OK)
+        return subgraph(self, induced_nodes)
+
+    def edge_subgraph(self, edges):
+        """Returns the subgraph induced by the specified edges.
+
+        The induced subgraph contains each edge in `edges` and each
+        node incident to any one of those edges.
+
+        Parameters
+        ----------
+        edges : iterable
+            An iterable of edges in this graph.
+
+        Returns
+        -------
+        G : Graph
+            An edge-induced subgraph of this graph with the same edge
+            attributes.
+
+        Notes
+        -----
+        The graph, edge, and node attributes in the returned subgraph
+        view are references to the corresponding attributes in the original
+        graph. The view is read-only.
+
+        To create a full graph version of the subgraph with its own copy
+        of the edge or node attributes, use::
+
+            G.edge_subgraph(edges).copy()
+
+        Examples
+        --------
+        >>> G = nx.path_graph(5)
+        >>> H = G.edge_subgraph([(0, 1), (3, 4)])
+        >>> list(H.nodes)
+        [0, 1, 3, 4]
+        >>> list(H.edges)
+        [(0, 1), (3, 4)]
+
+        """
+        return nx.edge_subgraph(self, edges)
+
+    def size(self, weight=None):
+        """Returns the number of edges or total of all edge weights.
+
+        Parameters
+        ----------
+        weight : string or None, optional (default=None)
+            The edge attribute that holds the numerical value used
+            as a weight. If None, then each edge has weight 1.
+
+        Returns
+        -------
+        size : numeric
+            The number of edges or
+            (if weight keyword is provided) the total weight sum.
+
+            If weight is None, returns an int. Otherwise a float
+            (or more general numeric if the weights are more general).
+
+        See Also
+        --------
+        number_of_edges
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.size()
+        3
+
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.add_edge("a", "b", weight=2)
+        >>> G.add_edge("b", "c", weight=4)
+        >>> G.size()
+        2
+        >>> G.size(weight="weight")
+        6.0
+        """
+        s = sum(d for v, d in self.degree(weight=weight))
+        # If `weight` is None, the sum of the degrees is guaranteed to be
+        # even, so we can perform integer division and hence return an
+        # integer. Otherwise, the sum of the weighted degrees is not
+        # guaranteed to be an integer, so we perform "real" division.
+        return s // 2 if weight is None else s / 2
+
+    def number_of_edges(self, u=None, v=None):
+        """Returns the number of edges between two nodes.
+
+        Parameters
+        ----------
+        u, v : nodes, optional (default=all edges)
+            If u and v are specified, return the number of edges between
+            u and v. Otherwise return the total number of all edges.
+
+        Returns
+        -------
+        nedges : int
+            The number of edges in the graph.  If nodes `u` and `v` are
+            specified return the number of edges between those nodes. If
+            the graph is directed, this only returns the number of edges
+            from `u` to `v`.
+
+        See Also
+        --------
+        size
+
+        Examples
+        --------
+        For undirected graphs, this method counts the total number of
+        edges in the graph:
+
+        >>> G = nx.path_graph(4)
+        >>> G.number_of_edges()
+        3
+
+        If you specify two nodes, this counts the total number of edges
+        joining the two nodes:
+
+        >>> G.number_of_edges(0, 1)
+        1
+
+        For directed graphs, this method can count the total number of
+        directed edges from `u` to `v`:
+
+        >>> G = nx.DiGraph()
+        >>> G.add_edge(0, 1)
+        >>> G.add_edge(1, 0)
+        >>> G.number_of_edges(0, 1)
+        1
+
+        """
+        if u is None:
+            return int(self.size())
+        if v in self._adj[u]:
+            return 1
+        return 0
+
+    def nbunch_iter(self, nbunch=None):
+        """Returns an iterator over nodes contained in nbunch that are
+        also in the graph.
+
+        The nodes in nbunch are checked for membership in the graph
+        and if not are silently ignored.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges incident to these nodes.
+
+        Returns
+        -------
+        niter : iterator
+            An iterator over nodes in nbunch that are also in the graph.
+            If nbunch is None, iterate over all nodes in the graph.
+
+        Raises
+        ------
+        NetworkXError
+            If nbunch is not a node or sequence of nodes.
+            If a node in nbunch is not hashable.
+
+        See Also
+        --------
+        Graph.__iter__
+
+        Notes
+        -----
+        When nbunch is an iterator, the returned iterator yields values
+        directly from nbunch, becoming exhausted when nbunch is exhausted.
+
+        To test whether nbunch is a single node, one can use
+        "if nbunch in self:", even after processing with this routine.
+
+        If nbunch is not a node or a (possibly empty) sequence/iterator
+        or None, a :exc:`NetworkXError` is raised.  Also, if any object in
+        nbunch is not hashable, a :exc:`NetworkXError` is raised.
+        """
+        if nbunch is None:  # include all nodes via iterator
+            bunch = iter(self._adj)
+        elif nbunch in self:  # if nbunch is a single node
+            bunch = iter([nbunch])
+        else:  # if nbunch is a sequence of nodes
+
+            def bunch_iter(nlist, adj):
+                try:
+                    for n in nlist:
+                        if n in adj:
+                            yield n
+                except TypeError as err:
+                    exc, message = err, err.args[0]
+                    # capture error for non-sequence/iterator nbunch.
+                    if "iter" in message:
+                        exc = NetworkXError(
+                            "nbunch is not a node or a sequence of nodes."
+                        )
+                    # capture error for unhashable node.
+                    if "hashable" in message:
+                        exc = NetworkXError(
+                            f"Node {n} in sequence nbunch is not a valid node."
+                        )
+                    raise exc
+
+            bunch = bunch_iter(nbunch, self._adj)
+        return bunch
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/graphviews.py b/myenv/lib/python3.9/site-packages/networkx/classes/graphviews.py
new file mode 100644
index 0000000..dcb7836
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/graphviews.py
@@ -0,0 +1,205 @@
+"""View of Graphs as SubGraph, Reverse, Directed, Undirected.
+
+In some algorithms it is convenient to temporarily morph
+a graph to exclude some nodes or edges. It should be better
+to do that via a view than to remove and then re-add.
+In other algorithms it is convenient to temporarily morph
+a graph to reverse directed edges, or treat a directed graph
+as undirected, etc. This module provides those graph views.
+
+The resulting views are essentially read-only graphs that
+report data from the orignal graph object. We provide an
+attribute G._graph which points to the underlying graph object.
+
+Note: Since graphviews look like graphs, one can end up with
+view-of-view-of-view chains. Be careful with chains because
+they become very slow with about 15 nested views.
+For the common simple case of node induced subgraphs created
+from the graph class, we short-cut the chain by returning a
+subgraph of the original graph directly rather than a subgraph
+of a subgraph. We are careful not to disrupt any edge filter in
+the middle subgraph. In general, determining how to short-cut
+the chain is tricky and much harder with restricted_views than
+with induced subgraphs.
+Often it is easiest to use .copy() to avoid chains.
+"""
+import networkx as nx
+from networkx.classes.coreviews import (
+    FilterAdjacency,
+    FilterAtlas,
+    FilterMultiAdjacency,
+    UnionAdjacency,
+    UnionMultiAdjacency,
+)
+from networkx.classes.filters import no_filter
+from networkx.exception import NetworkXError
+from networkx.utils import not_implemented_for
+
+__all__ = ["generic_graph_view", "subgraph_view", "reverse_view"]
+
+
+def generic_graph_view(G, create_using=None):
+    if create_using is None:
+        newG = G.__class__()
+    else:
+        newG = nx.empty_graph(0, create_using)
+    if G.is_multigraph() != newG.is_multigraph():
+        raise NetworkXError("Multigraph for G must agree with create_using")
+    newG = nx.freeze(newG)
+
+    # create view by assigning attributes from G
+    newG._graph = G
+    newG.graph = G.graph
+
+    newG._node = G._node
+    if newG.is_directed():
+        if G.is_directed():
+            newG._succ = G._succ
+            newG._pred = G._pred
+            # newG._adj is synced with _succ
+        else:
+            newG._succ = G._adj
+            newG._pred = G._adj
+            # newG._adj is synced with _succ
+    elif G.is_directed():
+        if G.is_multigraph():
+            newG._adj = UnionMultiAdjacency(G._succ, G._pred)
+        else:
+            newG._adj = UnionAdjacency(G._succ, G._pred)
+    else:
+        newG._adj = G._adj
+    return newG
+
+
+def subgraph_view(G, filter_node=no_filter, filter_edge=no_filter):
+    """View of `G` applying a filter on nodes and edges.
+
+    `subgraph_view` provides a read-only view of the input graph that excludes
+    nodes and edges based on the outcome of two filter functions `filter_node`
+    and `filter_edge`.
+
+    The `filter_node` function takes one argument --- the node --- and returns
+    `True` if the node should be included in the subgraph, and `False` if it
+    should not be included.
+
+    The `filter_edge` function takes two (or three arguments if `G` is a
+    multi-graph) --- the nodes describing an edge, plus the edge-key if
+    parallel edges are possible --- and returns `True` if the edge should be
+    included in the subgraph, and `False` if it should not be included.
+
+    Both node and edge filter functions are called on graph elements as they
+    are queried, meaning there is no up-front cost to creating the view.
+
+    Parameters
+    ----------
+    G : networkx.Graph
+        A directed/undirected graph/multigraph
+
+    filter_node : callable, optional
+        A function taking a node as input, which returns `True` if the node
+        should appear in the view.
+
+    filter_edge : callable, optional
+        A function taking as input the two nodes describing an edge (plus the
+        edge-key if `G` is a multi-graph), which returns `True` if the edge
+        should appear in the view.
+
+    Returns
+    -------
+    graph : networkx.Graph
+        A read-only graph view of the input graph.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(6)
+
+    Filter functions operate on the node, and return `True` if the node should
+    appear in the view:
+
+    >>> def filter_node(n1):
+    ...     return n1 != 5
+    ...
+    >>> view = nx.subgraph_view(G, filter_node=filter_node)
+    >>> view.nodes()
+    NodeView((0, 1, 2, 3, 4))
+
+    We can use a closure pattern to filter graph elements based on additional
+    data --- for example, filtering on edge data attached to the graph:
+
+    >>> G[3][4]["cross_me"] = False
+    >>> def filter_edge(n1, n2):
+    ...     return G[n1][n2].get("cross_me", True)
+    ...
+    >>> view = nx.subgraph_view(G, filter_edge=filter_edge)
+    >>> view.edges()
+    EdgeView([(0, 1), (1, 2), (2, 3), (4, 5)])
+
+    >>> view = nx.subgraph_view(G, filter_node=filter_node, filter_edge=filter_edge,)
+    >>> view.nodes()
+    NodeView((0, 1, 2, 3, 4))
+    >>> view.edges()
+    EdgeView([(0, 1), (1, 2), (2, 3)])
+    """
+    newG = nx.freeze(G.__class__())
+    newG._NODE_OK = filter_node
+    newG._EDGE_OK = filter_edge
+
+    # create view by assigning attributes from G
+    newG._graph = G
+    newG.graph = G.graph
+
+    newG._node = FilterAtlas(G._node, filter_node)
+    if G.is_multigraph():
+        Adj = FilterMultiAdjacency
+
+        def reverse_edge(u, v, k=None):
+            return filter_edge(v, u, k)
+
+    else:
+        Adj = FilterAdjacency
+
+        def reverse_edge(u, v, k=None):
+            return filter_edge(v, u)
+
+    if G.is_directed():
+        newG._succ = Adj(G._succ, filter_node, filter_edge)
+        newG._pred = Adj(G._pred, filter_node, reverse_edge)
+        # newG._adj is synced with _succ
+    else:
+        newG._adj = Adj(G._adj, filter_node, filter_edge)
+    return newG
+
+
+@not_implemented_for("undirected")
+def reverse_view(G):
+    """View of `G` with edge directions reversed
+
+    `reverse_view` returns a read-only view of the input graph where
+    edge directions are reversed.
+
+    Identical to digraph.reverse(copy=False)
+
+    Parameters
+    ----------
+    G : networkx.DiGraph
+
+    Returns
+    -------
+    graph : networkx.DiGraph
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_edge(1, 2)
+    >>> G.add_edge(2, 3)
+    >>> G.edges()
+    OutEdgeView([(1, 2), (2, 3)])
+
+    >>> view = nx.reverse_view(G)
+    >>> view.edges()
+    OutEdgeView([(2, 1), (3, 2)])
+    """
+    newG = generic_graph_view(G)
+    newG._succ, newG._pred = G._pred, G._succ
+    # newG._adj is synced with _succ
+    return newG
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/multidigraph.py b/myenv/lib/python3.9/site-packages/networkx/classes/multidigraph.py
new file mode 100644
index 0000000..e118dc2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/multidigraph.py
@@ -0,0 +1,947 @@
+"""Base class for MultiDiGraph."""
+from copy import deepcopy
+from functools import cached_property
+
+import networkx as nx
+import networkx.convert as convert
+from networkx.classes.coreviews import MultiAdjacencyView
+from networkx.classes.digraph import DiGraph
+from networkx.classes.multigraph import MultiGraph
+from networkx.classes.reportviews import (
+    DiMultiDegreeView,
+    InMultiDegreeView,
+    InMultiEdgeView,
+    OutMultiDegreeView,
+    OutMultiEdgeView,
+)
+from networkx.exception import NetworkXError
+
+__all__ = ["MultiDiGraph"]
+
+
+class MultiDiGraph(MultiGraph, DiGraph):
+    """A directed graph class that can store multiedges.
+
+    Multiedges are multiple edges between two nodes.  Each edge
+    can hold optional data or attributes.
+
+    A MultiDiGraph holds directed edges.  Self loops are allowed.
+
+    Nodes can be arbitrary (hashable) Python objects with optional
+    key/value attributes. By convention `None` is not used as a node.
+
+    Edges are represented as links between nodes with optional
+    key/value attributes.
+
+    Parameters
+    ----------
+    incoming_graph_data : input graph (optional, default: None)
+        Data to initialize graph. If None (default) an empty
+        graph is created.  The data can be any format that is supported
+        by the to_networkx_graph() function, currently including edge list,
+        dict of dicts, dict of lists, NetworkX graph, 2D NumPy array, SciPy
+        sparse matrix, or PyGraphviz graph.
+
+    multigraph_input : bool or None (default None)
+        Note: Only used when `incoming_graph_data` is a dict.
+        If True, `incoming_graph_data` is assumed to be a
+        dict-of-dict-of-dict-of-dict structure keyed by
+        node to neighbor to edge keys to edge data for multi-edges.
+        A NetworkXError is raised if this is not the case.
+        If False, :func:`to_networkx_graph` is used to try to determine
+        the dict's graph data structure as either a dict-of-dict-of-dict
+        keyed by node to neighbor to edge data, or a dict-of-iterable
+        keyed by node to neighbors.
+        If None, the treatment for True is tried, but if it fails,
+        the treatment for False is tried.
+
+    attr : keyword arguments, optional (default= no attributes)
+        Attributes to add to graph as key=value pairs.
+
+    See Also
+    --------
+    Graph
+    DiGraph
+    MultiGraph
+    OrderedMultiDiGraph
+
+    Examples
+    --------
+    Create an empty graph structure (a "null graph") with no nodes and
+    no edges.
+
+    >>> G = nx.MultiDiGraph()
+
+    G can be grown in several ways.
+
+    **Nodes:**
+
+    Add one node at a time:
+
+    >>> G.add_node(1)
+
+    Add the nodes from any container (a list, dict, set or
+    even the lines from a file or the nodes from another graph).
+
+    >>> G.add_nodes_from([2, 3])
+    >>> G.add_nodes_from(range(100, 110))
+    >>> H = nx.path_graph(10)
+    >>> G.add_nodes_from(H)
+
+    In addition to strings and integers any hashable Python object
+    (except None) can represent a node, e.g. a customized node object,
+    or even another Graph.
+
+    >>> G.add_node(H)
+
+    **Edges:**
+
+    G can also be grown by adding edges.
+
+    Add one edge,
+
+    >>> key = G.add_edge(1, 2)
+
+    a list of edges,
+
+    >>> keys = G.add_edges_from([(1, 2), (1, 3)])
+
+    or a collection of edges,
+
+    >>> keys = G.add_edges_from(H.edges)
+
+    If some edges connect nodes not yet in the graph, the nodes
+    are added automatically.  If an edge already exists, an additional
+    edge is created and stored using a key to identify the edge.
+    By default the key is the lowest unused integer.
+
+    >>> keys = G.add_edges_from([(4, 5, dict(route=282)), (4, 5, dict(route=37))])
+    >>> G[4]
+    AdjacencyView({5: {0: {}, 1: {'route': 282}, 2: {'route': 37}}})
+
+    **Attributes:**
+
+    Each graph, node, and edge can hold key/value attribute pairs
+    in an associated attribute dictionary (the keys must be hashable).
+    By default these are empty, but can be added or changed using
+    add_edge, add_node or direct manipulation of the attribute
+    dictionaries named graph, node and edge respectively.
+
+    >>> G = nx.MultiDiGraph(day="Friday")
+    >>> G.graph
+    {'day': 'Friday'}
+
+    Add node attributes using add_node(), add_nodes_from() or G.nodes
+
+    >>> G.add_node(1, time="5pm")
+    >>> G.add_nodes_from([3], time="2pm")
+    >>> G.nodes[1]
+    {'time': '5pm'}
+    >>> G.nodes[1]["room"] = 714
+    >>> del G.nodes[1]["room"]  # remove attribute
+    >>> list(G.nodes(data=True))
+    [(1, {'time': '5pm'}), (3, {'time': '2pm'})]
+
+    Add edge attributes using add_edge(), add_edges_from(), subscript
+    notation, or G.edges.
+
+    >>> key = G.add_edge(1, 2, weight=4.7)
+    >>> keys = G.add_edges_from([(3, 4), (4, 5)], color="red")
+    >>> keys = G.add_edges_from([(1, 2, {"color": "blue"}), (2, 3, {"weight": 8})])
+    >>> G[1][2][0]["weight"] = 4.7
+    >>> G.edges[1, 2, 0]["weight"] = 4
+
+    Warning: we protect the graph data structure by making `G.edges[1,
+    2, 0]` a read-only dict-like structure. However, you can assign to
+    attributes in e.g. `G.edges[1, 2, 0]`. Thus, use 2 sets of brackets
+    to add/change data attributes: `G.edges[1, 2, 0]['weight'] = 4`
+    (for multigraphs the edge key is required: `MG.edges[u, v,
+    key][name] = value`).
+
+    **Shortcuts:**
+
+    Many common graph features allow python syntax to speed reporting.
+
+    >>> 1 in G  # check if node in graph
+    True
+    >>> [n for n in G if n < 3]  # iterate through nodes
+    [1, 2]
+    >>> len(G)  # number of nodes in graph
+    5
+    >>> G[1]  # adjacency dict-like view mapping neighbor -> edge key -> edge attributes
+    AdjacencyView({2: {0: {'weight': 4}, 1: {'color': 'blue'}}})
+
+    Often the best way to traverse all edges of a graph is via the neighbors.
+    The neighbors are available as an adjacency-view `G.adj` object or via
+    the method `G.adjacency()`.
+
+    >>> for n, nbrsdict in G.adjacency():
+    ...     for nbr, keydict in nbrsdict.items():
+    ...         for key, eattr in keydict.items():
+    ...             if "weight" in eattr:
+    ...                 # Do something useful with the edges
+    ...                 pass
+
+    But the edges() method is often more convenient:
+
+    >>> for u, v, keys, weight in G.edges(data="weight", keys=True):
+    ...     if weight is not None:
+    ...         # Do something useful with the edges
+    ...         pass
+
+    **Reporting:**
+
+    Simple graph information is obtained using methods and object-attributes.
+    Reporting usually provides views instead of containers to reduce memory
+    usage. The views update as the graph is updated similarly to dict-views.
+    The objects `nodes`, `edges` and `adj` provide access to data attributes
+    via lookup (e.g. `nodes[n]`, `edges[u, v, k]`, `adj[u][v]`) and iteration
+    (e.g. `nodes.items()`, `nodes.data('color')`,
+    `nodes.data('color', default='blue')` and similarly for `edges`)
+    Views exist for `nodes`, `edges`, `neighbors()`/`adj` and `degree`.
+
+    For details on these and other miscellaneous methods, see below.
+
+    **Subclasses (Advanced):**
+
+    The MultiDiGraph class uses a dict-of-dict-of-dict-of-dict structure.
+    The outer dict (node_dict) holds adjacency information keyed by node.
+    The next dict (adjlist_dict) represents the adjacency information
+    and holds edge_key dicts keyed by neighbor. The edge_key dict holds
+    each edge_attr dict keyed by edge key. The inner dict
+    (edge_attr_dict) represents the edge data and holds edge attribute
+    values keyed by attribute names.
+
+    Each of these four dicts in the dict-of-dict-of-dict-of-dict
+    structure can be replaced by a user defined dict-like object.
+    In general, the dict-like features should be maintained but
+    extra features can be added. To replace one of the dicts create
+    a new graph class by changing the class(!) variable holding the
+    factory for that dict-like structure. The variable names are
+    node_dict_factory, node_attr_dict_factory, adjlist_inner_dict_factory,
+    adjlist_outer_dict_factory, edge_key_dict_factory, edge_attr_dict_factory
+    and graph_attr_dict_factory.
+
+    node_dict_factory : function, (default: dict)
+        Factory function to be used to create the dict containing node
+        attributes, keyed by node id.
+        It should require no arguments and return a dict-like object
+
+    node_attr_dict_factory: function, (default: dict)
+        Factory function to be used to create the node attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object
+
+    adjlist_outer_dict_factory : function, (default: dict)
+        Factory function to be used to create the outer-most dict
+        in the data structure that holds adjacency info keyed by node.
+        It should require no arguments and return a dict-like object.
+
+    adjlist_inner_dict_factory : function, (default: dict)
+        Factory function to be used to create the adjacency list
+        dict which holds multiedge key dicts keyed by neighbor.
+        It should require no arguments and return a dict-like object.
+
+    edge_key_dict_factory : function, (default: dict)
+        Factory function to be used to create the edge key dict
+        which holds edge data keyed by edge key.
+        It should require no arguments and return a dict-like object.
+
+    edge_attr_dict_factory : function, (default: dict)
+        Factory function to be used to create the edge attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object.
+
+    graph_attr_dict_factory : function, (default: dict)
+        Factory function to be used to create the graph attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object.
+
+    Typically, if your extension doesn't impact the data structure all
+    methods will inherited without issue except: `to_directed/to_undirected`.
+    By default these methods create a DiGraph/Graph class and you probably
+    want them to create your extension of a DiGraph/Graph. To facilitate
+    this we define two class variables that you can set in your subclass.
+
+    to_directed_class : callable, (default: DiGraph or MultiDiGraph)
+        Class to create a new graph structure in the `to_directed` method.
+        If `None`, a NetworkX class (DiGraph or MultiDiGraph) is used.
+
+    to_undirected_class : callable, (default: Graph or MultiGraph)
+        Class to create a new graph structure in the `to_undirected` method.
+        If `None`, a NetworkX class (Graph or MultiGraph) is used.
+
+    Please see :mod:`~networkx.classes.ordered` for examples of
+    creating graph subclasses by overwriting the base class `dict` with
+    a dictionary-like object.
+    """
+
+    # node_dict_factory = dict    # already assigned in Graph
+    # adjlist_outer_dict_factory = dict
+    # adjlist_inner_dict_factory = dict
+    edge_key_dict_factory = dict
+    # edge_attr_dict_factory = dict
+
+    def __init__(self, incoming_graph_data=None, multigraph_input=None, **attr):
+        """Initialize a graph with edges, name, or graph attributes.
+
+        Parameters
+        ----------
+        incoming_graph_data : input graph
+            Data to initialize graph.  If incoming_graph_data=None (default)
+            an empty graph is created.  The data can be an edge list, or any
+            NetworkX graph object.  If the corresponding optional Python
+            packages are installed the data can also be a 2D NumPy array, a
+            SciPy sparse matrix, or a PyGraphviz graph.
+
+        multigraph_input : bool or None (default None)
+            Note: Only used when `incoming_graph_data` is a dict.
+            If True, `incoming_graph_data` is assumed to be a
+            dict-of-dict-of-dict-of-dict structure keyed by
+            node to neighbor to edge keys to edge data for multi-edges.
+            A NetworkXError is raised if this is not the case.
+            If False, :func:`to_networkx_graph` is used to try to determine
+            the dict's graph data structure as either a dict-of-dict-of-dict
+            keyed by node to neighbor to edge data, or a dict-of-iterable
+            keyed by node to neighbors.
+            If None, the treatment for True is tried, but if it fails,
+            the treatment for False is tried.
+
+        attr : keyword arguments, optional (default= no attributes)
+            Attributes to add to graph as key=value pairs.
+
+        See Also
+        --------
+        convert
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G = nx.Graph(name="my graph")
+        >>> e = [(1, 2), (2, 3), (3, 4)]  # list of edges
+        >>> G = nx.Graph(e)
+
+        Arbitrary graph attribute pairs (key=value) may be assigned
+
+        >>> G = nx.Graph(e, day="Friday")
+        >>> G.graph
+        {'day': 'Friday'}
+
+        """
+        # multigraph_input can be None/True/False. So check "is not False"
+        if isinstance(incoming_graph_data, dict) and multigraph_input is not False:
+            DiGraph.__init__(self)
+            try:
+                convert.from_dict_of_dicts(
+                    incoming_graph_data, create_using=self, multigraph_input=True
+                )
+                self.graph.update(attr)
+            except Exception as err:
+                if multigraph_input is True:
+                    raise nx.NetworkXError(
+                        f"converting multigraph_input raised:\n{type(err)}: {err}"
+                    )
+                DiGraph.__init__(self, incoming_graph_data, **attr)
+        else:
+            DiGraph.__init__(self, incoming_graph_data, **attr)
+
+    @cached_property
+    def adj(self):
+        """Graph adjacency object holding the neighbors of each node.
+
+        This object is a read-only dict-like structure with node keys
+        and neighbor-dict values.  The neighbor-dict is keyed by neighbor
+        to the edgekey-dict.  So `G.adj[3][2][0]['color'] = 'blue'` sets
+        the color of the edge `(3, 2, 0)` to `"blue"`.
+
+        Iterating over G.adj behaves like a dict. Useful idioms include
+        `for nbr, datadict in G.adj[n].items():`.
+
+        The neighbor information is also provided by subscripting the graph.
+        So `for nbr, foovalue in G[node].data('foo', default=1):` works.
+
+        For directed graphs, `G.adj` holds outgoing (successor) info.
+        """
+        return MultiAdjacencyView(self._succ)
+
+    @cached_property
+    def succ(self):
+        """Graph adjacency object holding the successors of each node.
+
+        This object is a read-only dict-like structure with node keys
+        and neighbor-dict values.  The neighbor-dict is keyed by neighbor
+        to the edgekey-dict.  So `G.adj[3][2][0]['color'] = 'blue'` sets
+        the color of the edge `(3, 2, 0)` to `"blue"`.
+
+        Iterating over G.adj behaves like a dict. Useful idioms include
+        `for nbr, datadict in G.adj[n].items():`.
+
+        The neighbor information is also provided by subscripting the graph.
+        So `for nbr, foovalue in G[node].data('foo', default=1):` works.
+
+        For directed graphs, `G.succ` is identical to `G.adj`.
+        """
+        return MultiAdjacencyView(self._succ)
+
+    @cached_property
+    def pred(self):
+        """Graph adjacency object holding the predecessors of each node.
+
+        This object is a read-only dict-like structure with node keys
+        and neighbor-dict values.  The neighbor-dict is keyed by neighbor
+        to the edgekey-dict.  So `G.adj[3][2][0]['color'] = 'blue'` sets
+        the color of the edge `(3, 2, 0)` to `"blue"`.
+
+        Iterating over G.adj behaves like a dict. Useful idioms include
+        `for nbr, datadict in G.adj[n].items():`.
+        """
+        return MultiAdjacencyView(self._pred)
+
+    def add_edge(self, u_for_edge, v_for_edge, key=None, **attr):
+        """Add an edge between u and v.
+
+        The nodes u and v will be automatically added if they are
+        not already in the graph.
+
+        Edge attributes can be specified with keywords or by directly
+        accessing the edge's attribute dictionary. See examples below.
+
+        Parameters
+        ----------
+        u_for_edge, v_for_edge : nodes
+            Nodes can be, for example, strings or numbers.
+            Nodes must be hashable (and not None) Python objects.
+        key : hashable identifier, optional (default=lowest unused integer)
+            Used to distinguish multiedges between a pair of nodes.
+        attr : keyword arguments, optional
+            Edge data (or labels or objects) can be assigned using
+            keyword arguments.
+
+        Returns
+        -------
+        The edge key assigned to the edge.
+
+        See Also
+        --------
+        add_edges_from : add a collection of edges
+
+        Notes
+        -----
+        To replace/update edge data, use the optional key argument
+        to identify a unique edge.  Otherwise a new edge will be created.
+
+        NetworkX algorithms designed for weighted graphs cannot use
+        multigraphs directly because it is not clear how to handle
+        multiedge weights.  Convert to Graph using edge attribute
+        'weight' to enable weighted graph algorithms.
+
+        Default keys are generated using the method `new_edge_key()`.
+        This method can be overridden by subclassing the base class and
+        providing a custom `new_edge_key()` method.
+
+        Examples
+        --------
+        The following all add the edge e=(1, 2) to graph G:
+
+        >>> G = nx.MultiDiGraph()
+        >>> e = (1, 2)
+        >>> key = G.add_edge(1, 2)  # explicit two-node form
+        >>> G.add_edge(*e)  # single edge as tuple of two nodes
+        1
+        >>> G.add_edges_from([(1, 2)])  # add edges from iterable container
+        [2]
+
+        Associate data to edges using keywords:
+
+        >>> key = G.add_edge(1, 2, weight=3)
+        >>> key = G.add_edge(1, 2, key=0, weight=4)  # update data for key=0
+        >>> key = G.add_edge(1, 3, weight=7, capacity=15, length=342.7)
+
+        For non-string attribute keys, use subscript notation.
+
+        >>> ekey = G.add_edge(1, 2)
+        >>> G[1][2][0].update({0: 5})
+        >>> G.edges[1, 2, 0].update({0: 5})
+        """
+        u, v = u_for_edge, v_for_edge
+        # add nodes
+        if u not in self._succ:
+            if u is None:
+                raise ValueError("None cannot be a node")
+            self._succ[u] = self.adjlist_inner_dict_factory()
+            self._pred[u] = self.adjlist_inner_dict_factory()
+            self._node[u] = self.node_attr_dict_factory()
+        if v not in self._succ:
+            if v is None:
+                raise ValueError("None cannot be a node")
+            self._succ[v] = self.adjlist_inner_dict_factory()
+            self._pred[v] = self.adjlist_inner_dict_factory()
+            self._node[v] = self.node_attr_dict_factory()
+        if key is None:
+            key = self.new_edge_key(u, v)
+        if v in self._succ[u]:
+            keydict = self._adj[u][v]
+            datadict = keydict.get(key, self.edge_attr_dict_factory())
+            datadict.update(attr)
+            keydict[key] = datadict
+        else:
+            # selfloops work this way without special treatment
+            datadict = self.edge_attr_dict_factory()
+            datadict.update(attr)
+            keydict = self.edge_key_dict_factory()
+            keydict[key] = datadict
+            self._succ[u][v] = keydict
+            self._pred[v][u] = keydict
+        return key
+
+    def remove_edge(self, u, v, key=None):
+        """Remove an edge between u and v.
+
+        Parameters
+        ----------
+        u, v : nodes
+            Remove an edge between nodes u and v.
+        key : hashable identifier, optional (default=None)
+            Used to distinguish multiple edges between a pair of nodes.
+            If None, remove a single edge between u and v. If there are
+            multiple edges, removes the last edge added in terms of
+            insertion order.
+
+        Raises
+        ------
+        NetworkXError
+            If there is not an edge between u and v, or
+            if there is no edge with the specified key.
+
+        See Also
+        --------
+        remove_edges_from : remove a collection of edges
+
+        Examples
+        --------
+        >>> G = nx.MultiDiGraph()
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.remove_edge(0, 1)
+        >>> e = (1, 2)
+        >>> G.remove_edge(*e)  # unpacks e from an edge tuple
+
+        For multiple edges
+
+        >>> G = nx.MultiDiGraph()
+        >>> G.add_edges_from([(1, 2), (1, 2), (1, 2)])  # key_list returned
+        [0, 1, 2]
+
+        When ``key=None`` (the default), edges are removed in the opposite
+        order that they were added:
+
+        >>> G.remove_edge(1, 2)
+        >>> G.edges(keys=True)
+        OutMultiEdgeView([(1, 2, 0), (1, 2, 1)])
+
+        For edges with keys
+
+        >>> G = nx.MultiDiGraph()
+        >>> G.add_edge(1, 2, key="first")
+        'first'
+        >>> G.add_edge(1, 2, key="second")
+        'second'
+        >>> G.remove_edge(1, 2, key="first")
+        >>> G.edges(keys=True)
+        OutMultiEdgeView([(1, 2, 'second')])
+
+        """
+        try:
+            d = self._adj[u][v]
+        except KeyError as err:
+            raise NetworkXError(f"The edge {u}-{v} is not in the graph.") from err
+        # remove the edge with specified data
+        if key is None:
+            d.popitem()
+        else:
+            try:
+                del d[key]
+            except KeyError as err:
+                msg = f"The edge {u}-{v} with key {key} is not in the graph."
+                raise NetworkXError(msg) from err
+        if len(d) == 0:
+            # remove the key entries if last edge
+            del self._succ[u][v]
+            del self._pred[v][u]
+
+    @cached_property
+    def edges(self):
+        """An OutMultiEdgeView of the Graph as G.edges or G.edges().
+
+        edges(self, nbunch=None, data=False, keys=False, default=None)
+
+        The OutMultiEdgeView provides set-like operations on the edge-tuples
+        as well as edge attribute lookup. When called, it also provides
+        an EdgeDataView object which allows control of access to edge
+        attributes (but does not provide set-like operations).
+        Hence, ``G.edges[u, v, k]['color']`` provides the value of the color
+        attribute for the edge from ``u`` to ``v`` with key ``k`` while
+        ``for (u, v, k, c) in G.edges(data='color', default='red', keys=True):``
+        iterates through all the edges yielding the color attribute with
+        default `'red'` if no color attribute exists.
+
+        Edges are returned as tuples with optional data and keys
+        in the order (node, neighbor, key, data). If ``keys=True`` is not
+        provided, the tuples will just be (node, neighbor, data), but
+        multiple tuples with the same node and neighbor will be
+        generated when multiple edges between two nodes exist.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges from these nodes.
+        data : string or bool, optional (default=False)
+            The edge attribute returned in 3-tuple (u, v, ddict[data]).
+            If True, return edge attribute dict in 3-tuple (u, v, ddict).
+            If False, return 2-tuple (u, v).
+        keys : bool, optional (default=False)
+            If True, return edge keys with each edge, creating (u, v, k,
+            d) tuples when data is also requested (the default) and (u,
+            v, k) tuples when data is not requested.
+        default : value, optional (default=None)
+            Value used for edges that don't have the requested attribute.
+            Only relevant if data is not True or False.
+
+        Returns
+        -------
+        edges : OutMultiEdgeView
+            A view of edge attributes, usually it iterates over (u, v)
+            (u, v, k) or (u, v, k, d) tuples of edges, but can also be
+            used for attribute lookup as ``edges[u, v, k]['foo']``.
+
+        Notes
+        -----
+        Nodes in nbunch that are not in the graph will be (quietly) ignored.
+        For directed graphs this returns the out-edges.
+
+        Examples
+        --------
+        >>> G = nx.MultiDiGraph()
+        >>> nx.add_path(G, [0, 1, 2])
+        >>> key = G.add_edge(2, 3, weight=5)
+        >>> key2 = G.add_edge(1, 2) # second edge between these nodes
+        >>> [e for e in G.edges()]
+        [(0, 1), (1, 2), (1, 2), (2, 3)]
+        >>> list(G.edges(data=True))  # default data is {} (empty dict)
+        [(0, 1, {}), (1, 2, {}), (1, 2, {}), (2, 3, {'weight': 5})]
+        >>> list(G.edges(data="weight", default=1))
+        [(0, 1, 1), (1, 2, 1), (1, 2, 1), (2, 3, 5)]
+        >>> list(G.edges(keys=True))  # default keys are integers
+        [(0, 1, 0), (1, 2, 0), (1, 2, 1), (2, 3, 0)]
+        >>> list(G.edges(data=True, keys=True))
+        [(0, 1, 0, {}), (1, 2, 0, {}), (1, 2, 1, {}), (2, 3, 0, {'weight': 5})]
+        >>> list(G.edges(data="weight", default=1, keys=True))
+        [(0, 1, 0, 1), (1, 2, 0, 1), (1, 2, 1, 1), (2, 3, 0, 5)]
+        >>> list(G.edges([0, 2]))
+        [(0, 1), (2, 3)]
+        >>> list(G.edges(0))
+        [(0, 1)]
+        >>> list(G.edges(1))
+        [(1, 2), (1, 2)]
+
+        See Also
+        --------
+        in_edges, out_edges
+        """
+        return OutMultiEdgeView(self)
+
+    # alias out_edges to edges
+    @cached_property
+    def out_edges(self):
+        return OutMultiEdgeView(self)
+
+    out_edges.__doc__ = edges.__doc__
+
+    @cached_property
+    def in_edges(self):
+        """An InMultiEdgeView of the Graph as G.in_edges or G.in_edges().
+
+        in_edges(self, nbunch=None, data=False, keys=False, default=None)
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges incident to these nodes.
+        data : string or bool, optional (default=False)
+            The edge attribute returned in 3-tuple (u, v, ddict[data]).
+            If True, return edge attribute dict in 3-tuple (u, v, ddict).
+            If False, return 2-tuple (u, v).
+        keys : bool, optional (default=False)
+            If True, return edge keys with each edge, creating 3-tuples
+            (u, v, k) or with data, 4-tuples (u, v, k, d).
+        default : value, optional (default=None)
+            Value used for edges that don't have the requested attribute.
+            Only relevant if data is not True or False.
+
+        Returns
+        -------
+        in_edges : InMultiEdgeView
+            A view of edge attributes, usually it iterates over (u, v)
+            or (u, v, k) or (u, v, k, d) tuples of edges, but can also be
+            used for attribute lookup as `edges[u, v, k]['foo']`.
+
+        See Also
+        --------
+        edges
+        """
+        return InMultiEdgeView(self)
+
+    @cached_property
+    def degree(self):
+        """A DegreeView for the Graph as G.degree or G.degree().
+
+        The node degree is the number of edges adjacent to the node.
+        The weighted node degree is the sum of the edge weights for
+        edges incident to that node.
+
+        This object provides an iterator for (node, degree) as well as
+        lookup for the degree for a single node.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges incident to these nodes.
+
+        weight : string or None, optional (default=None)
+           The name of an edge attribute that holds the numerical value used
+           as a weight.  If None, then each edge has weight 1.
+           The degree is the sum of the edge weights adjacent to the node.
+
+        Returns
+        -------
+        DiMultiDegreeView or int
+            If multiple nodes are requested (the default), returns a `DiMultiDegreeView`
+            mapping nodes to their degree.
+            If a single node is requested, returns the degree of the node as an integer.
+
+        See Also
+        --------
+        out_degree, in_degree
+
+        Examples
+        --------
+        >>> G = nx.MultiDiGraph()
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.degree(0)  # node 0 with degree 1
+        1
+        >>> list(G.degree([0, 1, 2]))
+        [(0, 1), (1, 2), (2, 2)]
+        >>> G.add_edge(0, 1) # parallel edge
+        1
+        >>> list(G.degree([0, 1, 2])) # parallel edges are counted
+        [(0, 2), (1, 3), (2, 2)]
+
+        """
+        return DiMultiDegreeView(self)
+
+    @cached_property
+    def in_degree(self):
+        """A DegreeView for (node, in_degree) or in_degree for single node.
+
+        The node in-degree is the number of edges pointing in to the node.
+        The weighted node degree is the sum of the edge weights for
+        edges incident to that node.
+
+        This object provides an iterator for (node, degree) as well as
+        lookup for the degree for a single node.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges incident to these nodes.
+
+        weight : string or None, optional (default=None)
+           The edge attribute that holds the numerical value used
+           as a weight.  If None, then each edge has weight 1.
+           The degree is the sum of the edge weights adjacent to the node.
+
+        Returns
+        -------
+        If a single node is requested
+        deg : int
+            Degree of the node
+
+        OR if multiple nodes are requested
+        nd_iter : iterator
+            The iterator returns two-tuples of (node, in-degree).
+
+        See Also
+        --------
+        degree, out_degree
+
+        Examples
+        --------
+        >>> G = nx.MultiDiGraph()
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.in_degree(0)  # node 0 with degree 0
+        0
+        >>> list(G.in_degree([0, 1, 2]))
+        [(0, 0), (1, 1), (2, 1)]
+        >>> G.add_edge(0, 1) # parallel edge
+        1
+        >>> list(G.in_degree([0, 1, 2])) # parallel edges counted
+        [(0, 0), (1, 2), (2, 1)]
+
+        """
+        return InMultiDegreeView(self)
+
+    @cached_property
+    def out_degree(self):
+        """Returns an iterator for (node, out-degree) or out-degree for single node.
+
+        out_degree(self, nbunch=None, weight=None)
+
+        The node out-degree is the number of edges pointing out of the node.
+        This function returns the out-degree for a single node or an iterator
+        for a bunch of nodes or if nothing is passed as argument.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges incident to these nodes.
+
+        weight : string or None, optional (default=None)
+           The edge attribute that holds the numerical value used
+           as a weight.  If None, then each edge has weight 1.
+           The degree is the sum of the edge weights.
+
+        Returns
+        -------
+        If a single node is requested
+        deg : int
+            Degree of the node
+
+        OR if multiple nodes are requested
+        nd_iter : iterator
+            The iterator returns two-tuples of (node, out-degree).
+
+        See Also
+        --------
+        degree, in_degree
+
+        Examples
+        --------
+        >>> G = nx.MultiDiGraph()
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.out_degree(0)  # node 0 with degree 1
+        1
+        >>> list(G.out_degree([0, 1, 2]))
+        [(0, 1), (1, 1), (2, 1)]
+        >>> G.add_edge(0, 1) # parallel edge
+        1
+        >>> list(G.out_degree([0, 1, 2])) # counts parallel edges
+        [(0, 2), (1, 1), (2, 1)]
+
+        """
+        return OutMultiDegreeView(self)
+
+    def is_multigraph(self):
+        """Returns True if graph is a multigraph, False otherwise."""
+        return True
+
+    def is_directed(self):
+        """Returns True if graph is directed, False otherwise."""
+        return True
+
+    def to_undirected(self, reciprocal=False, as_view=False):
+        """Returns an undirected representation of the digraph.
+
+        Parameters
+        ----------
+        reciprocal : bool (optional)
+          If True only keep edges that appear in both directions
+          in the original digraph.
+        as_view : bool (optional, default=False)
+          If True return an undirected view of the original directed graph.
+
+        Returns
+        -------
+        G : MultiGraph
+            An undirected graph with the same name and nodes and
+            with edge (u, v, data) if either (u, v, data) or (v, u, data)
+            is in the digraph.  If both edges exist in digraph and
+            their edge data is different, only one edge is created
+            with an arbitrary choice of which edge data to use.
+            You must check and correct for this manually if desired.
+
+        See Also
+        --------
+        MultiGraph, copy, add_edge, add_edges_from
+
+        Notes
+        -----
+        This returns a "deepcopy" of the edge, node, and
+        graph attributes which attempts to completely copy
+        all of the data and references.
+
+        This is in contrast to the similar D=MultiDiGraph(G) which
+        returns a shallow copy of the data.
+
+        See the Python copy module for more information on shallow
+        and deep copies, https://docs.python.org/3/library/copy.html.
+
+        Warning: If you have subclassed MultiDiGraph to use dict-like
+        objects in the data structure, those changes do not transfer
+        to the MultiGraph created by this method.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(2)  # or MultiGraph, etc
+        >>> H = G.to_directed()
+        >>> list(H.edges)
+        [(0, 1), (1, 0)]
+        >>> G2 = H.to_undirected()
+        >>> list(G2.edges)
+        [(0, 1)]
+        """
+        graph_class = self.to_undirected_class()
+        if as_view is True:
+            return nx.graphviews.generic_graph_view(self, graph_class)
+        # deepcopy when not a view
+        G = graph_class()
+        G.graph.update(deepcopy(self.graph))
+        G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
+        if reciprocal is True:
+            G.add_edges_from(
+                (u, v, key, deepcopy(data))
+                for u, nbrs in self._adj.items()
+                for v, keydict in nbrs.items()
+                for key, data in keydict.items()
+                if v in self._pred[u] and key in self._pred[u][v]
+            )
+        else:
+            G.add_edges_from(
+                (u, v, key, deepcopy(data))
+                for u, nbrs in self._adj.items()
+                for v, keydict in nbrs.items()
+                for key, data in keydict.items()
+            )
+        return G
+
+    def reverse(self, copy=True):
+        """Returns the reverse of the graph.
+
+        The reverse is a graph with the same nodes and edges
+        but with the directions of the edges reversed.
+
+        Parameters
+        ----------
+        copy : bool optional (default=True)
+            If True, return a new DiGraph holding the reversed edges.
+            If False, the reverse graph is created using a view of
+            the original graph.
+        """
+        if copy:
+            H = self.__class__()
+            H.graph.update(deepcopy(self.graph))
+            H.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
+            H.add_edges_from(
+                (v, u, k, deepcopy(d))
+                for u, v, k, d in self.edges(keys=True, data=True)
+            )
+            return H
+        return nx.graphviews.reverse_view(self)
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/multigraph.py b/myenv/lib/python3.9/site-packages/networkx/classes/multigraph.py
new file mode 100644
index 0000000..3332201
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/multigraph.py
@@ -0,0 +1,1246 @@
+"""Base class for MultiGraph."""
+from copy import deepcopy
+from functools import cached_property
+
+import networkx as nx
+import networkx.convert as convert
+from networkx import NetworkXError
+from networkx.classes.coreviews import MultiAdjacencyView
+from networkx.classes.graph import Graph
+from networkx.classes.reportviews import MultiDegreeView, MultiEdgeView
+
+__all__ = ["MultiGraph"]
+
+
+class MultiGraph(Graph):
+    """
+    An undirected graph class that can store multiedges.
+
+    Multiedges are multiple edges between two nodes.  Each edge
+    can hold optional data or attributes.
+
+    A MultiGraph holds undirected edges.  Self loops are allowed.
+
+    Nodes can be arbitrary (hashable) Python objects with optional
+    key/value attributes. By convention `None` is not used as a node.
+
+    Edges are represented as links between nodes with optional
+    key/value attributes, in a MultiGraph each edge has a key to
+    distinguish between multiple edges that have the same source and
+    destination nodes.
+
+    Parameters
+    ----------
+    incoming_graph_data : input graph (optional, default: None)
+        Data to initialize graph. If None (default) an empty
+        graph is created.  The data can be any format that is supported
+        by the to_networkx_graph() function, currently including edge list,
+        dict of dicts, dict of lists, NetworkX graph, 2D NumPy array,
+        SciPy sparse matrix, or PyGraphviz graph.
+
+    multigraph_input : bool or None (default None)
+        Note: Only used when `incoming_graph_data` is a dict.
+        If True, `incoming_graph_data` is assumed to be a
+        dict-of-dict-of-dict-of-dict structure keyed by
+        node to neighbor to edge keys to edge data for multi-edges.
+        A NetworkXError is raised if this is not the case.
+        If False, :func:`to_networkx_graph` is used to try to determine
+        the dict's graph data structure as either a dict-of-dict-of-dict
+        keyed by node to neighbor to edge data, or a dict-of-iterable
+        keyed by node to neighbors.
+        If None, the treatment for True is tried, but if it fails,
+        the treatment for False is tried.
+
+    attr : keyword arguments, optional (default= no attributes)
+        Attributes to add to graph as key=value pairs.
+
+    See Also
+    --------
+    Graph
+    DiGraph
+    MultiDiGraph
+    OrderedMultiGraph
+
+    Examples
+    --------
+    Create an empty graph structure (a "null graph") with no nodes and
+    no edges.
+
+    >>> G = nx.MultiGraph()
+
+    G can be grown in several ways.
+
+    **Nodes:**
+
+    Add one node at a time:
+
+    >>> G.add_node(1)
+
+    Add the nodes from any container (a list, dict, set or
+    even the lines from a file or the nodes from another graph).
+
+    >>> G.add_nodes_from([2, 3])
+    >>> G.add_nodes_from(range(100, 110))
+    >>> H = nx.path_graph(10)
+    >>> G.add_nodes_from(H)
+
+    In addition to strings and integers any hashable Python object
+    (except None) can represent a node, e.g. a customized node object,
+    or even another Graph.
+
+    >>> G.add_node(H)
+
+    **Edges:**
+
+    G can also be grown by adding edges.
+
+    Add one edge,
+
+    >>> key = G.add_edge(1, 2)
+
+    a list of edges,
+
+    >>> keys = G.add_edges_from([(1, 2), (1, 3)])
+
+    or a collection of edges,
+
+    >>> keys = G.add_edges_from(H.edges)
+
+    If some edges connect nodes not yet in the graph, the nodes
+    are added automatically.  If an edge already exists, an additional
+    edge is created and stored using a key to identify the edge.
+    By default the key is the lowest unused integer.
+
+    >>> keys = G.add_edges_from([(4, 5, {"route": 28}), (4, 5, {"route": 37})])
+    >>> G[4]
+    AdjacencyView({3: {0: {}}, 5: {0: {}, 1: {'route': 28}, 2: {'route': 37}}})
+
+    **Attributes:**
+
+    Each graph, node, and edge can hold key/value attribute pairs
+    in an associated attribute dictionary (the keys must be hashable).
+    By default these are empty, but can be added or changed using
+    add_edge, add_node or direct manipulation of the attribute
+    dictionaries named graph, node and edge respectively.
+
+    >>> G = nx.MultiGraph(day="Friday")
+    >>> G.graph
+    {'day': 'Friday'}
+
+    Add node attributes using add_node(), add_nodes_from() or G.nodes
+
+    >>> G.add_node(1, time="5pm")
+    >>> G.add_nodes_from([3], time="2pm")
+    >>> G.nodes[1]
+    {'time': '5pm'}
+    >>> G.nodes[1]["room"] = 714
+    >>> del G.nodes[1]["room"]  # remove attribute
+    >>> list(G.nodes(data=True))
+    [(1, {'time': '5pm'}), (3, {'time': '2pm'})]
+
+    Add edge attributes using add_edge(), add_edges_from(), subscript
+    notation, or G.edges.
+
+    >>> key = G.add_edge(1, 2, weight=4.7)
+    >>> keys = G.add_edges_from([(3, 4), (4, 5)], color="red")
+    >>> keys = G.add_edges_from([(1, 2, {"color": "blue"}), (2, 3, {"weight": 8})])
+    >>> G[1][2][0]["weight"] = 4.7
+    >>> G.edges[1, 2, 0]["weight"] = 4
+
+    Warning: we protect the graph data structure by making `G.edges[1,
+    2, 0]` a read-only dict-like structure. However, you can assign to
+    attributes in e.g. `G.edges[1, 2, 0]`. Thus, use 2 sets of brackets
+    to add/change data attributes: `G.edges[1, 2, 0]['weight'] = 4`.
+
+    **Shortcuts:**
+
+    Many common graph features allow python syntax to speed reporting.
+
+    >>> 1 in G  # check if node in graph
+    True
+    >>> [n for n in G if n < 3]  # iterate through nodes
+    [1, 2]
+    >>> len(G)  # number of nodes in graph
+    5
+    >>> G[1]  # adjacency dict-like view mapping neighbor -> edge key -> edge attributes
+    AdjacencyView({2: {0: {'weight': 4}, 1: {'color': 'blue'}}})
+
+    Often the best way to traverse all edges of a graph is via the neighbors.
+    The neighbors are reported as an adjacency-dict `G.adj` or `G.adjacency()`.
+
+    >>> for n, nbrsdict in G.adjacency():
+    ...     for nbr, keydict in nbrsdict.items():
+    ...         for key, eattr in keydict.items():
+    ...             if "weight" in eattr:
+    ...                 # Do something useful with the edges
+    ...                 pass
+
+    But the edges() method is often more convenient:
+
+    >>> for u, v, keys, weight in G.edges(data="weight", keys=True):
+    ...     if weight is not None:
+    ...         # Do something useful with the edges
+    ...         pass
+
+    **Reporting:**
+
+    Simple graph information is obtained using methods and object-attributes.
+    Reporting usually provides views instead of containers to reduce memory
+    usage. The views update as the graph is updated similarly to dict-views.
+    The objects `nodes`, `edges` and `adj` provide access to data attributes
+    via lookup (e.g. `nodes[n]`, `edges[u, v, k]`, `adj[u][v]`) and iteration
+    (e.g. `nodes.items()`, `nodes.data('color')`,
+    `nodes.data('color', default='blue')` and similarly for `edges`)
+    Views exist for `nodes`, `edges`, `neighbors()`/`adj` and `degree`.
+
+    For details on these and other miscellaneous methods, see below.
+
+    **Subclasses (Advanced):**
+
+    The MultiGraph class uses a dict-of-dict-of-dict-of-dict data structure.
+    The outer dict (node_dict) holds adjacency information keyed by node.
+    The next dict (adjlist_dict) represents the adjacency information
+    and holds edge_key dicts keyed by neighbor. The edge_key dict holds
+    each edge_attr dict keyed by edge key. The inner dict
+    (edge_attr_dict) represents the edge data and holds edge attribute
+    values keyed by attribute names.
+
+    Each of these four dicts in the dict-of-dict-of-dict-of-dict
+    structure can be replaced by a user defined dict-like object.
+    In general, the dict-like features should be maintained but
+    extra features can be added. To replace one of the dicts create
+    a new graph class by changing the class(!) variable holding the
+    factory for that dict-like structure. The variable names are
+    node_dict_factory, node_attr_dict_factory, adjlist_inner_dict_factory,
+    adjlist_outer_dict_factory, edge_key_dict_factory, edge_attr_dict_factory
+    and graph_attr_dict_factory.
+
+    node_dict_factory : function, (default: dict)
+        Factory function to be used to create the dict containing node
+        attributes, keyed by node id.
+        It should require no arguments and return a dict-like object
+
+    node_attr_dict_factory: function, (default: dict)
+        Factory function to be used to create the node attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object
+
+    adjlist_outer_dict_factory : function, (default: dict)
+        Factory function to be used to create the outer-most dict
+        in the data structure that holds adjacency info keyed by node.
+        It should require no arguments and return a dict-like object.
+
+    adjlist_inner_dict_factory : function, (default: dict)
+        Factory function to be used to create the adjacency list
+        dict which holds multiedge key dicts keyed by neighbor.
+        It should require no arguments and return a dict-like object.
+
+    edge_key_dict_factory : function, (default: dict)
+        Factory function to be used to create the edge key dict
+        which holds edge data keyed by edge key.
+        It should require no arguments and return a dict-like object.
+
+    edge_attr_dict_factory : function, (default: dict)
+        Factory function to be used to create the edge attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object.
+
+    graph_attr_dict_factory : function, (default: dict)
+        Factory function to be used to create the graph attribute
+        dict which holds attribute values keyed by attribute name.
+        It should require no arguments and return a dict-like object.
+
+    Typically, if your extension doesn't impact the data structure all
+    methods will inherited without issue except: `to_directed/to_undirected`.
+    By default these methods create a DiGraph/Graph class and you probably
+    want them to create your extension of a DiGraph/Graph. To facilitate
+    this we define two class variables that you can set in your subclass.
+
+    to_directed_class : callable, (default: DiGraph or MultiDiGraph)
+        Class to create a new graph structure in the `to_directed` method.
+        If `None`, a NetworkX class (DiGraph or MultiDiGraph) is used.
+
+    to_undirected_class : callable, (default: Graph or MultiGraph)
+        Class to create a new graph structure in the `to_undirected` method.
+        If `None`, a NetworkX class (Graph or MultiGraph) is used.
+
+    Please see :mod:`~networkx.classes.ordered` for examples of
+    creating graph subclasses by overwriting the base class `dict` with
+    a dictionary-like object.
+    """
+
+    # node_dict_factory = dict    # already assigned in Graph
+    # adjlist_outer_dict_factory = dict
+    # adjlist_inner_dict_factory = dict
+    edge_key_dict_factory = dict
+    # edge_attr_dict_factory = dict
+
+    def to_directed_class(self):
+        """Returns the class to use for empty directed copies.
+
+        If you subclass the base classes, use this to designate
+        what directed class to use for `to_directed()` copies.
+        """
+        return nx.MultiDiGraph
+
+    def to_undirected_class(self):
+        """Returns the class to use for empty undirected copies.
+
+        If you subclass the base classes, use this to designate
+        what directed class to use for `to_directed()` copies.
+        """
+        return MultiGraph
+
+    def __init__(self, incoming_graph_data=None, multigraph_input=None, **attr):
+        """Initialize a graph with edges, name, or graph attributes.
+
+        Parameters
+        ----------
+        incoming_graph_data : input graph
+            Data to initialize graph.  If incoming_graph_data=None (default)
+            an empty graph is created.  The data can be an edge list, or any
+            NetworkX graph object.  If the corresponding optional Python
+            packages are installed the data can also be a 2D NumPy array, a
+            SciPy sparse matrix, or a PyGraphviz graph.
+
+        multigraph_input : bool or None (default None)
+            Note: Only used when `incoming_graph_data` is a dict.
+            If True, `incoming_graph_data` is assumed to be a
+            dict-of-dict-of-dict-of-dict structure keyed by
+            node to neighbor to edge keys to edge data for multi-edges.
+            A NetworkXError is raised if this is not the case.
+            If False, :func:`to_networkx_graph` is used to try to determine
+            the dict's graph data structure as either a dict-of-dict-of-dict
+            keyed by node to neighbor to edge data, or a dict-of-iterable
+            keyed by node to neighbors.
+            If None, the treatment for True is tried, but if it fails,
+            the treatment for False is tried.
+
+        attr : keyword arguments, optional (default= no attributes)
+            Attributes to add to graph as key=value pairs.
+
+        See Also
+        --------
+        convert
+
+        Examples
+        --------
+        >>> G = nx.MultiGraph()
+        >>> G = nx.MultiGraph(name="my graph")
+        >>> e = [(1, 2), (1, 2), (2, 3), (3, 4)]  # list of edges
+        >>> G = nx.MultiGraph(e)
+
+        Arbitrary graph attribute pairs (key=value) may be assigned
+
+        >>> G = nx.MultiGraph(e, day="Friday")
+        >>> G.graph
+        {'day': 'Friday'}
+
+        """
+        # multigraph_input can be None/True/False. So check "is not False"
+        if isinstance(incoming_graph_data, dict) and multigraph_input is not False:
+            Graph.__init__(self)
+            try:
+                convert.from_dict_of_dicts(
+                    incoming_graph_data, create_using=self, multigraph_input=True
+                )
+                self.graph.update(attr)
+            except Exception as err:
+                if multigraph_input is True:
+                    raise nx.NetworkXError(
+                        f"converting multigraph_input raised:\n{type(err)}: {err}"
+                    )
+                Graph.__init__(self, incoming_graph_data, **attr)
+        else:
+            Graph.__init__(self, incoming_graph_data, **attr)
+
+    @cached_property
+    def adj(self):
+        """Graph adjacency object holding the neighbors of each node.
+
+        This object is a read-only dict-like structure with node keys
+        and neighbor-dict values.  The neighbor-dict is keyed by neighbor
+        to the edgekey-data-dict.  So `G.adj[3][2][0]['color'] = 'blue'` sets
+        the color of the edge `(3, 2, 0)` to `"blue"`.
+
+        Iterating over G.adj behaves like a dict. Useful idioms include
+        `for nbr, edgesdict in G.adj[n].items():`.
+
+        The neighbor information is also provided by subscripting the graph.
+
+        Examples
+        --------
+        >>> e = [(1, 2), (1, 2), (1, 3), (3, 4)]  # list of edges
+        >>> G = nx.MultiGraph(e)
+        >>> G.edges[1, 2, 0]["weight"] = 3
+        >>> result = set()
+        >>> for edgekey, data in G[1][2].items():
+        ...     result.add(data.get('weight', 1))
+        >>> result
+        {1, 3}
+
+        For directed graphs, `G.adj` holds outgoing (successor) info.
+        """
+        return MultiAdjacencyView(self._adj)
+
+    def new_edge_key(self, u, v):
+        """Returns an unused key for edges between nodes `u` and `v`.
+
+        The nodes `u` and `v` do not need to be already in the graph.
+
+        Notes
+        -----
+        In the standard MultiGraph class the new key is the number of existing
+        edges between `u` and `v` (increased if necessary to ensure unused).
+        The first edge will have key 0, then 1, etc. If an edge is removed
+        further new_edge_keys may not be in this order.
+
+        Parameters
+        ----------
+        u, v : nodes
+
+        Returns
+        -------
+        key : int
+        """
+        try:
+            keydict = self._adj[u][v]
+        except KeyError:
+            return 0
+        key = len(keydict)
+        while key in keydict:
+            key += 1
+        return key
+
+    def add_edge(self, u_for_edge, v_for_edge, key=None, **attr):
+        """Add an edge between u and v.
+
+        The nodes u and v will be automatically added if they are
+        not already in the graph.
+
+        Edge attributes can be specified with keywords or by directly
+        accessing the edge's attribute dictionary. See examples below.
+
+        Parameters
+        ----------
+        u_for_edge, v_for_edge : nodes
+            Nodes can be, for example, strings or numbers.
+            Nodes must be hashable (and not None) Python objects.
+        key : hashable identifier, optional (default=lowest unused integer)
+            Used to distinguish multiedges between a pair of nodes.
+        attr : keyword arguments, optional
+            Edge data (or labels or objects) can be assigned using
+            keyword arguments.
+
+        Returns
+        -------
+        The edge key assigned to the edge.
+
+        See Also
+        --------
+        add_edges_from : add a collection of edges
+
+        Notes
+        -----
+        To replace/update edge data, use the optional key argument
+        to identify a unique edge.  Otherwise a new edge will be created.
+
+        NetworkX algorithms designed for weighted graphs cannot use
+        multigraphs directly because it is not clear how to handle
+        multiedge weights.  Convert to Graph using edge attribute
+        'weight' to enable weighted graph algorithms.
+
+        Default keys are generated using the method `new_edge_key()`.
+        This method can be overridden by subclassing the base class and
+        providing a custom `new_edge_key()` method.
+
+        Examples
+        --------
+        The following each add an additional edge e=(1, 2) to graph G:
+
+        >>> G = nx.MultiGraph()
+        >>> e = (1, 2)
+        >>> ekey = G.add_edge(1, 2)  # explicit two-node form
+        >>> G.add_edge(*e)  # single edge as tuple of two nodes
+        1
+        >>> G.add_edges_from([(1, 2)])  # add edges from iterable container
+        [2]
+
+        Associate data to edges using keywords:
+
+        >>> ekey = G.add_edge(1, 2, weight=3)
+        >>> ekey = G.add_edge(1, 2, key=0, weight=4)  # update data for key=0
+        >>> ekey = G.add_edge(1, 3, weight=7, capacity=15, length=342.7)
+
+        For non-string attribute keys, use subscript notation.
+
+        >>> ekey = G.add_edge(1, 2)
+        >>> G[1][2][0].update({0: 5})
+        >>> G.edges[1, 2, 0].update({0: 5})
+        """
+        u, v = u_for_edge, v_for_edge
+        # add nodes
+        if u not in self._adj:
+            if u is None:
+                raise ValueError("None cannot be a node")
+            self._adj[u] = self.adjlist_inner_dict_factory()
+            self._node[u] = self.node_attr_dict_factory()
+        if v not in self._adj:
+            if v is None:
+                raise ValueError("None cannot be a node")
+            self._adj[v] = self.adjlist_inner_dict_factory()
+            self._node[v] = self.node_attr_dict_factory()
+        if key is None:
+            key = self.new_edge_key(u, v)
+        if v in self._adj[u]:
+            keydict = self._adj[u][v]
+            datadict = keydict.get(key, self.edge_attr_dict_factory())
+            datadict.update(attr)
+            keydict[key] = datadict
+        else:
+            # selfloops work this way without special treatment
+            datadict = self.edge_attr_dict_factory()
+            datadict.update(attr)
+            keydict = self.edge_key_dict_factory()
+            keydict[key] = datadict
+            self._adj[u][v] = keydict
+            self._adj[v][u] = keydict
+        return key
+
+    def add_edges_from(self, ebunch_to_add, **attr):
+        """Add all the edges in ebunch_to_add.
+
+        Parameters
+        ----------
+        ebunch_to_add : container of edges
+            Each edge given in the container will be added to the
+            graph. The edges can be:
+
+                - 2-tuples (u, v) or
+                - 3-tuples (u, v, d) for an edge data dict d, or
+                - 3-tuples (u, v, k) for not iterable key k, or
+                - 4-tuples (u, v, k, d) for an edge with data and key k
+
+        attr : keyword arguments, optional
+            Edge data (or labels or objects) can be assigned using
+            keyword arguments.
+
+        Returns
+        -------
+        A list of edge keys assigned to the edges in `ebunch`.
+
+        See Also
+        --------
+        add_edge : add a single edge
+        add_weighted_edges_from : convenient way to add weighted edges
+
+        Notes
+        -----
+        Adding the same edge twice has no effect but any edge data
+        will be updated when each duplicate edge is added.
+
+        Edge attributes specified in an ebunch take precedence over
+        attributes specified via keyword arguments.
+
+        Default keys are generated using the method ``new_edge_key()``.
+        This method can be overridden by subclassing the base class and
+        providing a custom ``new_edge_key()`` method.
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.add_edges_from([(0, 1), (1, 2)])  # using a list of edge tuples
+        >>> e = zip(range(0, 3), range(1, 4))
+        >>> G.add_edges_from(e)  # Add the path graph 0-1-2-3
+
+        Associate data to edges
+
+        >>> G.add_edges_from([(1, 2), (2, 3)], weight=3)
+        >>> G.add_edges_from([(3, 4), (1, 4)], label="WN2898")
+        """
+        keylist = []
+        for e in ebunch_to_add:
+            ne = len(e)
+            if ne == 4:
+                u, v, key, dd = e
+            elif ne == 3:
+                u, v, dd = e
+                key = None
+            elif ne == 2:
+                u, v = e
+                dd = {}
+                key = None
+            else:
+                msg = f"Edge tuple {e} must be a 2-tuple, 3-tuple or 4-tuple."
+                raise NetworkXError(msg)
+            ddd = {}
+            ddd.update(attr)
+            try:
+                ddd.update(dd)
+            except (TypeError, ValueError):
+                if ne != 3:
+                    raise
+                key = dd  # ne == 3 with 3rd value not dict, must be a key
+            key = self.add_edge(u, v, key)
+            self[u][v][key].update(ddd)
+            keylist.append(key)
+        return keylist
+
+    def remove_edge(self, u, v, key=None):
+        """Remove an edge between u and v.
+
+        Parameters
+        ----------
+        u, v : nodes
+            Remove an edge between nodes u and v.
+        key : hashable identifier, optional (default=None)
+            Used to distinguish multiple edges between a pair of nodes.
+            If None, remove a single edge between u and v. If there are
+            multiple edges, removes the last edge added in terms of
+            insertion order.
+
+        Raises
+        ------
+        NetworkXError
+            If there is not an edge between u and v, or
+            if there is no edge with the specified key.
+
+        See Also
+        --------
+        remove_edges_from : remove a collection of edges
+
+        Examples
+        --------
+        >>> G = nx.MultiGraph()
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.remove_edge(0, 1)
+        >>> e = (1, 2)
+        >>> G.remove_edge(*e)  # unpacks e from an edge tuple
+
+        For multiple edges
+
+        >>> G = nx.MultiGraph()  # or MultiDiGraph, etc
+        >>> G.add_edges_from([(1, 2), (1, 2), (1, 2)])  # key_list returned
+        [0, 1, 2]
+
+        When ``key=None`` (the default), edges are removed in the opposite
+        order that they were added:
+
+        >>> G.remove_edge(1, 2)
+        >>> G.edges(keys=True)
+        MultiEdgeView([(1, 2, 0), (1, 2, 1)])
+        >>> G.remove_edge(2, 1)  # edges are not directed
+        >>> G.edges(keys=True)
+        MultiEdgeView([(1, 2, 0)])
+
+        For edges with keys
+
+        >>> G = nx.MultiGraph()
+        >>> G.add_edge(1, 2, key="first")
+        'first'
+        >>> G.add_edge(1, 2, key="second")
+        'second'
+        >>> G.remove_edge(1, 2, key="first")
+        >>> G.edges(keys=True)
+        MultiEdgeView([(1, 2, 'second')])
+
+        """
+        try:
+            d = self._adj[u][v]
+        except KeyError as err:
+            raise NetworkXError(f"The edge {u}-{v} is not in the graph.") from err
+        # remove the edge with specified data
+        if key is None:
+            d.popitem()
+        else:
+            try:
+                del d[key]
+            except KeyError as err:
+                msg = f"The edge {u}-{v} with key {key} is not in the graph."
+                raise NetworkXError(msg) from err
+        if len(d) == 0:
+            # remove the key entries if last edge
+            del self._adj[u][v]
+            if u != v:  # check for selfloop
+                del self._adj[v][u]
+
+    def remove_edges_from(self, ebunch):
+        """Remove all edges specified in ebunch.
+
+        Parameters
+        ----------
+        ebunch: list or container of edge tuples
+            Each edge given in the list or container will be removed
+            from the graph. The edges can be:
+
+                - 2-tuples (u, v) A single edge between u and v is removed.
+                - 3-tuples (u, v, key) The edge identified by key is removed.
+                - 4-tuples (u, v, key, data) where data is ignored.
+
+        See Also
+        --------
+        remove_edge : remove a single edge
+
+        Notes
+        -----
+        Will fail silently if an edge in ebunch is not in the graph.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> ebunch = [(1, 2), (2, 3)]
+        >>> G.remove_edges_from(ebunch)
+
+        Removing multiple copies of edges
+
+        >>> G = nx.MultiGraph()
+        >>> keys = G.add_edges_from([(1, 2), (1, 2), (1, 2)])
+        >>> G.remove_edges_from([(1, 2), (2, 1)])  # edges aren't directed
+        >>> list(G.edges())
+        [(1, 2)]
+        >>> G.remove_edges_from([(1, 2), (1, 2)])  # silently ignore extra copy
+        >>> list(G.edges)  # now empty graph
+        []
+
+        When the edge is a 2-tuple ``(u, v)`` but there are multiple edges between
+        u and v in the graph, the most recent edge (in terms of insertion
+        order) is removed.
+
+        >>> G = nx.MultiGraph()
+        >>> for key in ("x", "y", "a"):
+        ...     k = G.add_edge(0, 1, key=key)
+        >>> G.edges(keys=True)
+        MultiEdgeView([(0, 1, 'x'), (0, 1, 'y'), (0, 1, 'a')])
+        >>> G.remove_edges_from([(0, 1)])
+        >>> G.edges(keys=True)
+        MultiEdgeView([(0, 1, 'x'), (0, 1, 'y')])
+
+        """
+        for e in ebunch:
+            try:
+                self.remove_edge(*e[:3])
+            except NetworkXError:
+                pass
+
+    def has_edge(self, u, v, key=None):
+        """Returns True if the graph has an edge between nodes u and v.
+
+        This is the same as `v in G[u] or key in G[u][v]`
+        without KeyError exceptions.
+
+        Parameters
+        ----------
+        u, v : nodes
+            Nodes can be, for example, strings or numbers.
+
+        key : hashable identifier, optional (default=None)
+            If specified return True only if the edge with
+            key is found.
+
+        Returns
+        -------
+        edge_ind : bool
+            True if edge is in the graph, False otherwise.
+
+        Examples
+        --------
+        Can be called either using two nodes u, v, an edge tuple (u, v),
+        or an edge tuple (u, v, key).
+
+        >>> G = nx.MultiGraph()  # or MultiDiGraph
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.has_edge(0, 1)  # using two nodes
+        True
+        >>> e = (0, 1)
+        >>> G.has_edge(*e)  #  e is a 2-tuple (u, v)
+        True
+        >>> G.add_edge(0, 1, key="a")
+        'a'
+        >>> G.has_edge(0, 1, key="a")  # specify key
+        True
+        >>> G.has_edge(1, 0, key="a")  # edges aren't directed
+        True
+        >>> e = (0, 1, "a")
+        >>> G.has_edge(*e)  # e is a 3-tuple (u, v, 'a')
+        True
+
+        The following syntax are equivalent:
+
+        >>> G.has_edge(0, 1)
+        True
+        >>> 1 in G[0]  # though this gives :exc:`KeyError` if 0 not in G
+        True
+        >>> 0 in G[1]  # other order; also gives :exc:`KeyError` if 0 not in G
+        True
+
+        """
+        try:
+            if key is None:
+                return v in self._adj[u]
+            else:
+                return key in self._adj[u][v]
+        except KeyError:
+            return False
+
+    @cached_property
+    def edges(self):
+        """Returns an iterator over the edges.
+
+        edges(self, nbunch=None, data=False, keys=False, default=None)
+
+        The MultiEdgeView provides set-like operations on the edge-tuples
+        as well as edge attribute lookup. When called, it also provides
+        an EdgeDataView object which allows control of access to edge
+        attributes (but does not provide set-like operations).
+        Hence, ``G.edges[u, v, k]['color']`` provides the value of the color
+        attribute for the edge from ``u`` to ``v`` with key ``k`` while
+        ``for (u, v, k, c) in G.edges(data='color', keys=True, default="red"):``
+        iterates through all the edges yielding the color attribute with
+        default `'red'` if no color attribute exists.
+
+        Edges are returned as tuples with optional data and keys
+        in the order (node, neighbor, key, data). If ``keys=True`` is not
+        provided, the tuples will just be (node, neighbor, data), but
+        multiple tuples with the same node and neighbor will be generated
+        when multiple edges exist between two nodes.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges from these nodes.
+        data : string or bool, optional (default=False)
+            The edge attribute returned in 3-tuple (u, v, ddict[data]).
+            If True, return edge attribute dict in 3-tuple (u, v, ddict).
+            If False, return 2-tuple (u, v).
+        keys : bool, optional (default=False)
+            If True, return edge keys with each edge, creating (u, v, k)
+            tuples or (u, v, k, d) tuples if data is also requested.
+        default : value, optional (default=None)
+            Value used for edges that don't have the requested attribute.
+            Only relevant if data is not True or False.
+
+        Returns
+        -------
+        edges : MultiEdgeView
+            A view of edge attributes, usually it iterates over (u, v)
+            (u, v, k) or (u, v, k, d) tuples of edges, but can also be
+            used for attribute lookup as ``edges[u, v, k]['foo']``.
+
+        Notes
+        -----
+        Nodes in nbunch that are not in the graph will be (quietly) ignored.
+        For directed graphs this returns the out-edges.
+
+        Examples
+        --------
+        >>> G = nx.MultiGraph()
+        >>> nx.add_path(G, [0, 1, 2])
+        >>> key = G.add_edge(2, 3, weight=5)
+        >>> key2 = G.add_edge(2, 1, weight=2)  # multi-edge
+        >>> [e for e in G.edges()]
+        [(0, 1), (1, 2), (1, 2), (2, 3)]
+        >>> G.edges.data()  # default data is {} (empty dict)
+        MultiEdgeDataView([(0, 1, {}), (1, 2, {}), (1, 2, {'weight': 2}), (2, 3, {'weight': 5})])
+        >>> G.edges.data("weight", default=1)
+        MultiEdgeDataView([(0, 1, 1), (1, 2, 1), (1, 2, 2), (2, 3, 5)])
+        >>> G.edges(keys=True)  # default keys are integers
+        MultiEdgeView([(0, 1, 0), (1, 2, 0), (1, 2, 1), (2, 3, 0)])
+        >>> G.edges.data(keys=True)
+        MultiEdgeDataView([(0, 1, 0, {}), (1, 2, 0, {}), (1, 2, 1, {'weight': 2}), (2, 3, 0, {'weight': 5})])
+        >>> G.edges.data("weight", default=1, keys=True)
+        MultiEdgeDataView([(0, 1, 0, 1), (1, 2, 0, 1), (1, 2, 1, 2), (2, 3, 0, 5)])
+        >>> G.edges([0, 3])  # Note ordering of tuples from listed sources
+        MultiEdgeDataView([(0, 1), (3, 2)])
+        >>> G.edges([0, 3, 2, 1])  # Note ordering of tuples
+        MultiEdgeDataView([(0, 1), (3, 2), (2, 1), (2, 1)])
+        >>> G.edges(0)
+        MultiEdgeDataView([(0, 1)])
+        """
+        return MultiEdgeView(self)
+
+    def get_edge_data(self, u, v, key=None, default=None):
+        """Returns the attribute dictionary associated with edge (u, v,
+        key).
+
+        If a key is not provided, returns a dictionary mapping edge keys
+        to attribute dictionaries for each edge between u and v.
+
+        This is identical to `G[u][v][key]` except the default is returned
+        instead of an exception is the edge doesn't exist.
+
+        Parameters
+        ----------
+        u, v : nodes
+
+        default :  any Python object (default=None)
+            Value to return if the specific edge (u, v, key) is not
+            found, OR if there are no edges between u and v and no key
+            is specified.
+
+        key : hashable identifier, optional (default=None)
+            Return data only for the edge with specified key, as an
+            attribute dictionary (rather than a dictionary mapping keys
+            to attribute dictionaries).
+
+        Returns
+        -------
+        edge_dict : dictionary
+            The edge attribute dictionary, OR a dictionary mapping edge
+            keys to attribute dictionaries for each of those edges if no
+            specific key is provided (even if there's only one edge
+            between u and v).
+
+        Examples
+        --------
+        >>> G = nx.MultiGraph()  # or MultiDiGraph
+        >>> key = G.add_edge(0, 1, key="a", weight=7)
+        >>> G[0][1]["a"]  # key='a'
+        {'weight': 7}
+        >>> G.edges[0, 1, "a"]  # key='a'
+        {'weight': 7}
+
+        Warning: we protect the graph data structure by making
+        `G.edges` and `G[1][2]` read-only dict-like structures.
+        However, you can assign values to attributes in e.g.
+        `G.edges[1, 2, 'a']` or `G[1][2]['a']` using an additional
+        bracket as shown next. You need to specify all edge info
+        to assign to the edge data associated with an edge.
+
+        >>> G[0][1]["a"]["weight"] = 10
+        >>> G.edges[0, 1, "a"]["weight"] = 10
+        >>> G[0][1]["a"]["weight"]
+        10
+        >>> G.edges[1, 0, "a"]["weight"]
+        10
+
+        >>> G = nx.MultiGraph()  # or MultiDiGraph
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.edges[0, 1, 0]["weight"] = 5
+        >>> G.get_edge_data(0, 1)
+        {0: {'weight': 5}}
+        >>> e = (0, 1)
+        >>> G.get_edge_data(*e)  # tuple form
+        {0: {'weight': 5}}
+        >>> G.get_edge_data(3, 0)  # edge not in graph, returns None
+        >>> G.get_edge_data(3, 0, default=0)  # edge not in graph, return default
+        0
+        >>> G.get_edge_data(1, 0, 0)  # specific key gives back
+        {'weight': 5}
+        """
+        try:
+            if key is None:
+                return self._adj[u][v]
+            else:
+                return self._adj[u][v][key]
+        except KeyError:
+            return default
+
+    @cached_property
+    def degree(self):
+        """A DegreeView for the Graph as G.degree or G.degree().
+
+        The node degree is the number of edges adjacent to the node.
+        The weighted node degree is the sum of the edge weights for
+        edges incident to that node.
+
+        This object provides an iterator for (node, degree) as well as
+        lookup for the degree for a single node.
+
+        Parameters
+        ----------
+        nbunch : single node, container, or all nodes (default= all nodes)
+            The view will only report edges incident to these nodes.
+
+        weight : string or None, optional (default=None)
+           The name of an edge attribute that holds the numerical value used
+           as a weight.  If None, then each edge has weight 1.
+           The degree is the sum of the edge weights adjacent to the node.
+
+        Returns
+        -------
+        MultiDegreeView or int
+            If multiple nodes are requested (the default), returns a `MultiDegreeView`
+            mapping nodes to their degree.
+            If a single node is requested, returns the degree of the node as an integer.
+
+        Examples
+        --------
+        >>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> nx.add_path(G, [0, 1, 2, 3])
+        >>> G.degree(0)  # node 0 with degree 1
+        1
+        >>> list(G.degree([0, 1]))
+        [(0, 1), (1, 2)]
+
+        """
+        return MultiDegreeView(self)
+
+    def is_multigraph(self):
+        """Returns True if graph is a multigraph, False otherwise."""
+        return True
+
+    def is_directed(self):
+        """Returns True if graph is directed, False otherwise."""
+        return False
+
+    def copy(self, as_view=False):
+        """Returns a copy of the graph.
+
+        The copy method by default returns an independent shallow copy
+        of the graph and attributes. That is, if an attribute is a
+        container, that container is shared by the original an the copy.
+        Use Python's `copy.deepcopy` for new containers.
+
+        If `as_view` is True then a view is returned instead of a copy.
+
+        Notes
+        -----
+        All copies reproduce the graph structure, but data attributes
+        may be handled in different ways. There are four types of copies
+        of a graph that people might want.
+
+        Deepcopy -- A "deepcopy" copies the graph structure as well as
+        all data attributes and any objects they might contain.
+        The entire graph object is new so that changes in the copy
+        do not affect the original object. (see Python's copy.deepcopy)
+
+        Data Reference (Shallow) -- For a shallow copy the graph structure
+        is copied but the edge, node and graph attribute dicts are
+        references to those in the original graph. This saves
+        time and memory but could cause confusion if you change an attribute
+        in one graph and it changes the attribute in the other.
+        NetworkX does not provide this level of shallow copy.
+
+        Independent Shallow -- This copy creates new independent attribute
+        dicts and then does a shallow copy of the attributes. That is, any
+        attributes that are containers are shared between the new graph
+        and the original. This is exactly what `dict.copy()` provides.
+        You can obtain this style copy using:
+
+            >>> G = nx.path_graph(5)
+            >>> H = G.copy()
+            >>> H = G.copy(as_view=False)
+            >>> H = nx.Graph(G)
+            >>> H = G.__class__(G)
+
+        Fresh Data -- For fresh data, the graph structure is copied while
+        new empty data attribute dicts are created. The resulting graph
+        is independent of the original and it has no edge, node or graph
+        attributes. Fresh copies are not enabled. Instead use:
+
+            >>> H = G.__class__()
+            >>> H.add_nodes_from(G)
+            >>> H.add_edges_from(G.edges)
+
+        View -- Inspired by dict-views, graph-views act like read-only
+        versions of the original graph, providing a copy of the original
+        structure without requiring any memory for copying the information.
+
+        See the Python copy module for more information on shallow
+        and deep copies, https://docs.python.org/3/library/copy.html.
+
+        Parameters
+        ----------
+        as_view : bool, optional (default=False)
+            If True, the returned graph-view provides a read-only view
+            of the original graph without actually copying any data.
+
+        Returns
+        -------
+        G : Graph
+            A copy of the graph.
+
+        See Also
+        --------
+        to_directed: return a directed copy of the graph.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> H = G.copy()
+
+        """
+        if as_view is True:
+            return nx.graphviews.generic_graph_view(self)
+        G = self.__class__()
+        G.graph.update(self.graph)
+        G.add_nodes_from((n, d.copy()) for n, d in self._node.items())
+        G.add_edges_from(
+            (u, v, key, datadict.copy())
+            for u, nbrs in self._adj.items()
+            for v, keydict in nbrs.items()
+            for key, datadict in keydict.items()
+        )
+        return G
+
+    def to_directed(self, as_view=False):
+        """Returns a directed representation of the graph.
+
+        Returns
+        -------
+        G : MultiDiGraph
+            A directed graph with the same name, same nodes, and with
+            each edge (u, v, k, data) replaced by two directed edges
+            (u, v, k, data) and (v, u, k, data).
+
+        Notes
+        -----
+        This returns a "deepcopy" of the edge, node, and
+        graph attributes which attempts to completely copy
+        all of the data and references.
+
+        This is in contrast to the similar D=MultiDiGraph(G) which
+        returns a shallow copy of the data.
+
+        See the Python copy module for more information on shallow
+        and deep copies, https://docs.python.org/3/library/copy.html.
+
+        Warning: If you have subclassed MultiGraph to use dict-like objects
+        in the data structure, those changes do not transfer to the
+        MultiDiGraph created by this method.
+
+        Examples
+        --------
+        >>> G = nx.MultiGraph()
+        >>> G.add_edge(0, 1)
+        0
+        >>> G.add_edge(0, 1)
+        1
+        >>> H = G.to_directed()
+        >>> list(H.edges)
+        [(0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1)]
+
+        If already directed, return a (deep) copy
+
+        >>> G = nx.MultiDiGraph()
+        >>> G.add_edge(0, 1)
+        0
+        >>> H = G.to_directed()
+        >>> list(H.edges)
+        [(0, 1, 0)]
+        """
+        graph_class = self.to_directed_class()
+        if as_view is True:
+            return nx.graphviews.generic_graph_view(self, graph_class)
+        # deepcopy when not a view
+        G = graph_class()
+        G.graph.update(deepcopy(self.graph))
+        G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
+        G.add_edges_from(
+            (u, v, key, deepcopy(datadict))
+            for u, nbrs in self.adj.items()
+            for v, keydict in nbrs.items()
+            for key, datadict in keydict.items()
+        )
+        return G
+
+    def to_undirected(self, as_view=False):
+        """Returns an undirected copy of the graph.
+
+        Returns
+        -------
+        G : Graph/MultiGraph
+            A deepcopy of the graph.
+
+        See Also
+        --------
+        copy, add_edge, add_edges_from
+
+        Notes
+        -----
+        This returns a "deepcopy" of the edge, node, and
+        graph attributes which attempts to completely copy
+        all of the data and references.
+
+        This is in contrast to the similar `G = nx.MultiGraph(D)`
+        which returns a shallow copy of the data.
+
+        See the Python copy module for more information on shallow
+        and deep copies, https://docs.python.org/3/library/copy.html.
+
+        Warning: If you have subclassed MultiGraph to use dict-like
+        objects in the data structure, those changes do not transfer
+        to the MultiGraph created by this method.
+
+        Examples
+        --------
+        >>> G = nx.MultiGraph([(0, 1), (0, 1), (1, 2)])
+        >>> H = G.to_directed()
+        >>> list(H.edges)
+        [(0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 2, 0), (2, 1, 0)]
+        >>> G2 = H.to_undirected()
+        >>> list(G2.edges)
+        [(0, 1, 0), (0, 1, 1), (1, 2, 0)]
+        """
+        graph_class = self.to_undirected_class()
+        if as_view is True:
+            return nx.graphviews.generic_graph_view(self, graph_class)
+        # deepcopy when not a view
+        G = graph_class()
+        G.graph.update(deepcopy(self.graph))
+        G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
+        G.add_edges_from(
+            (u, v, key, deepcopy(datadict))
+            for u, nbrs in self._adj.items()
+            for v, keydict in nbrs.items()
+            for key, datadict in keydict.items()
+        )
+        return G
+
+    def number_of_edges(self, u=None, v=None):
+        """Returns the number of edges between two nodes.
+
+        Parameters
+        ----------
+        u, v : nodes, optional (Gefault=all edges)
+            If u and v are specified, return the number of edges between
+            u and v. Otherwise return the total number of all edges.
+
+        Returns
+        -------
+        nedges : int
+            The number of edges in the graph.  If nodes `u` and `v` are
+            specified return the number of edges between those nodes. If
+            the graph is directed, this only returns the number of edges
+            from `u` to `v`.
+
+        See Also
+        --------
+        size
+
+        Examples
+        --------
+        For undirected multigraphs, this method counts the total number
+        of edges in the graph::
+
+            >>> G = nx.MultiGraph()
+            >>> G.add_edges_from([(0, 1), (0, 1), (1, 2)])
+            [0, 1, 0]
+            >>> G.number_of_edges()
+            3
+
+        If you specify two nodes, this counts the total number of edges
+        joining the two nodes::
+
+            >>> G.number_of_edges(0, 1)
+            2
+
+        For directed multigraphs, this method can count the total number
+        of directed edges from `u` to `v`::
+
+            >>> G = nx.MultiDiGraph()
+            >>> G.add_edges_from([(0, 1), (0, 1), (1, 0)])
+            [0, 1, 0]
+            >>> G.number_of_edges(0, 1)
+            2
+            >>> G.number_of_edges(1, 0)
+            1
+
+        """
+        if u is None:
+            return self.size()
+        try:
+            edgedata = self._adj[u][v]
+        except KeyError:
+            return 0  # no such edge
+        return len(edgedata)
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/ordered.py b/myenv/lib/python3.9/site-packages/networkx/classes/ordered.py
new file mode 100644
index 0000000..ca82d12
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/ordered.py
@@ -0,0 +1,162 @@
+"""
+
+.. deprecated:: 2.6
+
+   The ordered variants of graph classes in this module are deprecated and
+   will be removed in version 3.0.
+
+Consistently ordered variants of the default base classes.
+Note that if you are using Python 3.6+, you shouldn't need these classes
+because the dicts in Python 3.6+ are ordered.
+Note also that there are many differing expectations for the word "ordered"
+and that these classes may not provide the order you expect.
+The intent here is to give a consistent order not a particular order.
+
+The Ordered (Di/Multi/MultiDi) Graphs give a consistent order for reporting of
+nodes and edges.  The order of node reporting agrees with node adding, but for
+edges, the order is not necessarily the order that the edges were added.
+
+In general, you should use the default (i.e., unordered) graph classes.
+However, there are times (e.g., when testing) when you may need the
+order preserved.
+
+Special care is required when using subgraphs of the Ordered classes.
+The order of nodes in the subclass is not necessarily the same order
+as the original class.  In general it is probably better to avoid using
+subgraphs and replace with code similar to:
+
+.. code-block:: python
+
+    # instead of SG = G.subgraph(ordered_nodes)
+    SG = nx.OrderedGraph()
+    SG.add_nodes_from(ordered_nodes)
+    SG.add_edges_from((u, v) for (u, v) in G.edges() if u in SG if v in SG)
+
+"""
+import warnings
+from collections import OrderedDict
+
+from .digraph import DiGraph
+from .graph import Graph
+from .multidigraph import MultiDiGraph
+from .multigraph import MultiGraph
+
+__all__ = []
+
+__all__.extend(
+    ["OrderedGraph", "OrderedDiGraph", "OrderedMultiGraph", "OrderedMultiDiGraph"]
+)
+
+
+class OrderedGraph(Graph):
+    """Consistently ordered variant of :class:`~networkx.Graph`.
+
+    .. deprecated:: 2.6
+
+       OrderedGraph is deprecated and will be removed in version 3.0.
+       Use `Graph` instead, which guarantees order is preserved for
+       Python >= 3.7
+    """
+
+    node_dict_factory = OrderedDict
+    adjlist_outer_dict_factory = OrderedDict
+    adjlist_inner_dict_factory = OrderedDict
+    edge_attr_dict_factory = OrderedDict
+
+    def __init__(self, incoming_graph_data=None, **attr):
+        warnings.warn(
+            (
+                "OrderedGraph is deprecated and will be removed in version 3.0.\n"
+                "Use `Graph` instead, which guarantees order is preserved for\n"
+                "Python >= 3.7\n"
+            ),
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(incoming_graph_data, **attr)
+
+
+class OrderedDiGraph(DiGraph):
+    """Consistently ordered variant of :class:`~networkx.DiGraph`.
+
+    .. deprecated:: 2.6
+
+       OrderedDiGraph is deprecated and will be removed in version 3.0.
+       Use `DiGraph` instead, which guarantees order is preserved for
+       Python >= 3.7
+    """
+
+    node_dict_factory = OrderedDict
+    adjlist_outer_dict_factory = OrderedDict
+    adjlist_inner_dict_factory = OrderedDict
+    edge_attr_dict_factory = OrderedDict
+
+    def __init__(self, incoming_graph_data=None, **attr):
+        warnings.warn(
+            (
+                "OrderedDiGraph is deprecated and will be removed in version 3.0.\n"
+                "Use `DiGraph` instead, which guarantees order is preserved for\n"
+                "Python >= 3.7\n"
+            ),
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(incoming_graph_data, **attr)
+
+
+class OrderedMultiGraph(MultiGraph):
+    """Consistently ordered variant of :class:`~networkx.MultiGraph`.
+
+    .. deprecated:: 2.6
+
+       OrderedMultiGraph is deprecated and will be removed in version 3.0.
+       Use `MultiGraph` instead, which guarantees order is preserved for
+       Python >= 3.7
+    """
+
+    node_dict_factory = OrderedDict
+    adjlist_outer_dict_factory = OrderedDict
+    adjlist_inner_dict_factory = OrderedDict
+    edge_key_dict_factory = OrderedDict
+    edge_attr_dict_factory = OrderedDict
+
+    def __init__(self, incoming_graph_data=None, **attr):
+        warnings.warn(
+            (
+                "OrderedMultiGraph is deprecated and will be removed in version 3.0.\n"
+                "Use `MultiGraph` instead, which guarantees order is preserved for\n"
+                "Python >= 3.7\n"
+            ),
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(incoming_graph_data, **attr)
+
+
+class OrderedMultiDiGraph(MultiDiGraph):
+    """Consistently ordered variant of :class:`~networkx.MultiDiGraph`.
+
+    .. deprecated:: 2.6
+
+       OrderedMultiDiGraph is deprecated and will be removed in version 3.0.
+       Use `MultiDiGraph` instead, which guarantees order is preserved for
+       Python >= 3.7
+    """
+
+    node_dict_factory = OrderedDict
+    adjlist_outer_dict_factory = OrderedDict
+    adjlist_inner_dict_factory = OrderedDict
+    edge_key_dict_factory = OrderedDict
+    edge_attr_dict_factory = OrderedDict
+
+    def __init__(self, incoming_graph_data=None, **attr):
+        warnings.warn(
+            (
+                "OrderedMultiDiGraph is deprecated and will be removed in version 3.0.\n"
+                "Use `MultiDiGraph` instead, which guarantees order is preserved for\n"
+                "Python >= 3.7\n"
+            ),
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(incoming_graph_data, **attr)
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/reportviews.py b/myenv/lib/python3.9/site-packages/networkx/classes/reportviews.py
new file mode 100644
index 0000000..de5ff04
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/reportviews.py
@@ -0,0 +1,1440 @@
+"""
+View Classes provide node, edge and degree "views" of a graph.
+
+Views for nodes, edges and degree are provided for all base graph classes.
+A view means a read-only object that is quick to create, automatically
+updated when the graph changes, and provides basic access like `n in V`,
+`for n in V`, `V[n]` and sometimes set operations.
+
+The views are read-only iterable containers that are updated as the
+graph is updated. As with dicts, the graph should not be updated
+while iterating through the view. Views can be iterated multiple times.
+
+Edge and Node views also allow data attribute lookup.
+The resulting attribute dict is writable as `G.edges[3, 4]['color']='red'`
+Degree views allow lookup of degree values for single nodes.
+Weighted degree is supported with the `weight` argument.
+
+NodeView
+========
+
+    `V = G.nodes` (or `V = G.nodes()`) allows `len(V)`, `n in V`, set
+    operations e.g. "G.nodes & H.nodes", and `dd = G.nodes[n]`, where
+    `dd` is the node data dict. Iteration is over the nodes by default.
+
+NodeDataView
+============
+
+    To iterate over (node, data) pairs, use arguments to `G.nodes()`
+    to create a DataView e.g. `DV = G.nodes(data='color', default='red')`.
+    The DataView iterates as `for n, color in DV` and allows
+    `(n, 'red') in DV`. Using `DV = G.nodes(data=True)`, the DataViews
+    use the full datadict in writeable form also allowing contain testing as
+    `(n, {'color': 'red'}) in VD`. DataViews allow set operations when
+    data attributes are hashable.
+
+DegreeView
+==========
+
+    `V = G.degree` allows iteration over (node, degree) pairs as well
+    as lookup: `deg=V[n]`. There are many flavors of DegreeView
+    for In/Out/Directed/Multi. For Directed Graphs, `G.degree`
+    counts both in and out going edges. `G.out_degree` and
+    `G.in_degree` count only specific directions.
+    Weighted degree using edge data attributes is provide via
+    `V = G.degree(weight='attr_name')` where any string with the
+    attribute name can be used. `weight=None` is the default.
+    No set operations are implemented for degrees, use NodeView.
+
+    The argument `nbunch` restricts iteration to nodes in nbunch.
+    The DegreeView can still lookup any node even if nbunch is specified.
+
+EdgeView
+========
+
+    `V = G.edges` or `V = G.edges()` allows iteration over edges as well as
+    `e in V`, set operations and edge data lookup `dd = G.edges[2, 3]`.
+    Iteration is over 2-tuples `(u, v)` for Graph/DiGraph. For multigraphs
+    edges 3-tuples `(u, v, key)` are the default but 2-tuples can be obtained
+    via `V = G.edges(keys=False)`.
+
+    Set operations for directed graphs treat the edges as a set of 2-tuples.
+    For undirected graphs, 2-tuples are not a unique representation of edges.
+    So long as the set being compared to contains unique representations
+    of its edges, the set operations will act as expected. If the other
+    set contains both `(0, 1)` and `(1, 0)` however, the result of set
+    operations may contain both representations of the same edge.
+
+EdgeDataView
+============
+
+    Edge data can be reported using an EdgeDataView typically created
+    by calling an EdgeView: `DV = G.edges(data='weight', default=1)`.
+    The EdgeDataView allows iteration over edge tuples, membership checking
+    but no set operations.
+
+    Iteration depends on `data` and `default` and for multigraph `keys`
+    If `data is False` (the default) then iterate over 2-tuples `(u, v)`.
+    If `data is True` iterate over 3-tuples `(u, v, datadict)`.
+    Otherwise iterate over `(u, v, datadict.get(data, default))`.
+    For Multigraphs, if `keys is True`, replace `u, v` with `u, v, key`
+    to create 3-tuples and 4-tuples.
+
+    The argument `nbunch` restricts edges to those incident to nodes in nbunch.
+"""
+from collections.abc import Mapping, Set
+
+import networkx as nx
+
+__all__ = [
+    "NodeView",
+    "NodeDataView",
+    "EdgeView",
+    "OutEdgeView",
+    "InEdgeView",
+    "EdgeDataView",
+    "OutEdgeDataView",
+    "InEdgeDataView",
+    "MultiEdgeView",
+    "OutMultiEdgeView",
+    "InMultiEdgeView",
+    "MultiEdgeDataView",
+    "OutMultiEdgeDataView",
+    "InMultiEdgeDataView",
+    "DegreeView",
+    "DiDegreeView",
+    "InDegreeView",
+    "OutDegreeView",
+    "MultiDegreeView",
+    "DiMultiDegreeView",
+    "InMultiDegreeView",
+    "OutMultiDegreeView",
+]
+
+
+# NodeViews
+class NodeView(Mapping, Set):
+    """A NodeView class to act as G.nodes for a NetworkX Graph
+
+    Set operations act on the nodes without considering data.
+    Iteration is over nodes. Node data can be looked up like a dict.
+    Use NodeDataView to iterate over node data or to specify a data
+    attribute for lookup. NodeDataView is created by calling the NodeView.
+
+    Parameters
+    ----------
+    graph : NetworkX graph-like class
+
+    Examples
+    --------
+    >>> G = nx.path_graph(3)
+    >>> NV = G.nodes()
+    >>> 2 in NV
+    True
+    >>> for n in NV:
+    ...     print(n)
+    0
+    1
+    2
+    >>> assert NV & {1, 2, 3} == {1, 2}
+
+    >>> G.add_node(2, color="blue")
+    >>> NV[2]
+    {'color': 'blue'}
+    >>> G.add_node(8, color="red")
+    >>> NDV = G.nodes(data=True)
+    >>> (2, NV[2]) in NDV
+    True
+    >>> for n, dd in NDV:
+    ...     print((n, dd.get("color", "aqua")))
+    (0, 'aqua')
+    (1, 'aqua')
+    (2, 'blue')
+    (8, 'red')
+    >>> NDV[2] == NV[2]
+    True
+
+    >>> NVdata = G.nodes(data="color", default="aqua")
+    >>> (2, NVdata[2]) in NVdata
+    True
+    >>> for n, dd in NVdata:
+    ...     print((n, dd))
+    (0, 'aqua')
+    (1, 'aqua')
+    (2, 'blue')
+    (8, 'red')
+    >>> NVdata[2] == NV[2]  # NVdata gets 'color', NV gets datadict
+    False
+    """
+
+    __slots__ = ("_nodes",)
+
+    def __getstate__(self):
+        return {"_nodes": self._nodes}
+
+    def __setstate__(self, state):
+        self._nodes = state["_nodes"]
+
+    def __init__(self, graph):
+        self._nodes = graph._node
+
+    # Mapping methods
+    def __len__(self):
+        return len(self._nodes)
+
+    def __iter__(self):
+        return iter(self._nodes)
+
+    def __getitem__(self, n):
+        if isinstance(n, slice):
+            raise nx.NetworkXError(
+                f"{type(self).__name__} does not support slicing, "
+                f"try list(G.nodes)[{n.start}:{n.stop}:{n.step}]"
+            )
+        return self._nodes[n]
+
+    # Set methods
+    def __contains__(self, n):
+        return n in self._nodes
+
+    @classmethod
+    def _from_iterable(cls, it):
+        return set(it)
+
+    # DataView method
+    def __call__(self, data=False, default=None):
+        if data is False:
+            return self
+        return NodeDataView(self._nodes, data, default)
+
+    def data(self, data=True, default=None):
+        """
+        Return a read-only view of node data.
+
+        Parameters
+        ----------
+        data : bool or node data key, default=True
+            If ``data=True`` (the default), return a `NodeDataView` object that
+            maps each node to *all* of its attributes. `data` may also be an
+            arbitrary key, in which case the `NodeDataView` maps each node to
+            the value for the keyed attribute. In this case, if a node does
+            not have the `data` attribute, the `default` value is used.
+        default : object, default=None
+            The value used when a node does not have a specific attribute.
+
+        Returns
+        -------
+        NodeDataView
+            The layout of the returned NodeDataView depends on the value of the
+            `data` parameter.
+
+        Notes
+        -----
+        If ``data=False``, returns a `NodeView` object without data.
+
+        See Also
+        --------
+        NodeDataView
+
+        Examples
+        --------
+        >>> G = nx.Graph()
+        >>> G.add_nodes_from([
+        ...     (0, {"color": "red", "weight": 10}),
+        ...     (1, {"color": "blue"}),
+        ...     (2, {"color": "yellow", "weight": 2})
+        ... ])
+
+        Accessing node data with ``data=True`` (the default) returns a
+        NodeDataView mapping each node to all of its attributes:
+
+        >>> G.nodes.data()
+        NodeDataView({0: {'color': 'red', 'weight': 10}, 1: {'color': 'blue'}, 2: {'color': 'yellow', 'weight': 2}})
+
+        If `data` represents  a key in the node attribute dict, a NodeDataView mapping
+        the nodes to the value for that specific key is returned:
+
+        >>> G.nodes.data("color")
+        NodeDataView({0: 'red', 1: 'blue', 2: 'yellow'}, data='color')
+
+        If a specific key is not found in an attribute dict, the value specified
+        by `default` is returned:
+
+        >>> G.nodes.data("weight", default=-999)
+        NodeDataView({0: 10, 1: -999, 2: 2}, data='weight')
+
+        Note that there is no check that the `data` key is in any of the
+        node attribute dictionaries:
+
+        >>> G.nodes.data("height")
+        NodeDataView({0: None, 1: None, 2: None}, data='height')
+        """
+        if data is False:
+            return self
+        return NodeDataView(self._nodes, data, default)
+
+    def __str__(self):
+        return str(list(self))
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({tuple(self)})"
+
+
+class NodeDataView(Set):
+    """A DataView class for nodes of a NetworkX Graph
+
+    The main use for this class is to iterate through node-data pairs.
+    The data can be the entire data-dictionary for each node, or it
+    can be a specific attribute (with default) for each node.
+    Set operations are enabled with NodeDataView, but don't work in
+    cases where the data is not hashable. Use with caution.
+    Typically, set operations on nodes use NodeView, not NodeDataView.
+    That is, they use `G.nodes` instead of `G.nodes(data='foo')`.
+
+    Parameters
+    ==========
+    graph : NetworkX graph-like class
+    data : bool or string (default=False)
+    default : object (default=None)
+    """
+
+    __slots__ = ("_nodes", "_data", "_default")
+
+    def __getstate__(self):
+        return {"_nodes": self._nodes, "_data": self._data, "_default": self._default}
+
+    def __setstate__(self, state):
+        self._nodes = state["_nodes"]
+        self._data = state["_data"]
+        self._default = state["_default"]
+
+    def __init__(self, nodedict, data=False, default=None):
+        self._nodes = nodedict
+        self._data = data
+        self._default = default
+
+    @classmethod
+    def _from_iterable(cls, it):
+        try:
+            return set(it)
+        except TypeError as err:
+            if "unhashable" in str(err):
+                msg = " : Could be b/c data=True or your values are unhashable"
+                raise TypeError(str(err) + msg) from err
+            raise
+
+    def __len__(self):
+        return len(self._nodes)
+
+    def __iter__(self):
+        data = self._data
+        if data is False:
+            return iter(self._nodes)
+        if data is True:
+            return iter(self._nodes.items())
+        return (
+            (n, dd[data] if data in dd else self._default)
+            for n, dd in self._nodes.items()
+        )
+
+    def __contains__(self, n):
+        try:
+            node_in = n in self._nodes
+        except TypeError:
+            n, d = n
+            return n in self._nodes and self[n] == d
+        if node_in is True:
+            return node_in
+        try:
+            n, d = n
+        except (TypeError, ValueError):
+            return False
+        return n in self._nodes and self[n] == d
+
+    def __getitem__(self, n):
+        if isinstance(n, slice):
+            raise nx.NetworkXError(
+                f"{type(self).__name__} does not support slicing, "
+                f"try list(G.nodes.data())[{n.start}:{n.stop}:{n.step}]"
+            )
+        ddict = self._nodes[n]
+        data = self._data
+        if data is False or data is True:
+            return ddict
+        return ddict[data] if data in ddict else self._default
+
+    def __str__(self):
+        return str(list(self))
+
+    def __repr__(self):
+        name = self.__class__.__name__
+        if self._data is False:
+            return f"{name}({tuple(self)})"
+        if self._data is True:
+            return f"{name}({dict(self)})"
+        return f"{name}({dict(self)}, data={self._data!r})"
+
+
+# DegreeViews
+class DiDegreeView:
+    """A View class for degree of nodes in a NetworkX Graph
+
+    The functionality is like dict.items() with (node, degree) pairs.
+    Additional functionality includes read-only lookup of node degree,
+    and calling with optional features nbunch (for only a subset of nodes)
+    and weight (use edge weights to compute degree).
+
+    Parameters
+    ==========
+    graph : NetworkX graph-like class
+    nbunch : node, container of nodes, or None meaning all nodes (default=None)
+    weight : bool or string (default=None)
+
+    Notes
+    -----
+    DegreeView can still lookup any node even if nbunch is specified.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(3)
+    >>> DV = G.degree()
+    >>> assert DV[2] == 1
+    >>> assert sum(deg for n, deg in DV) == 4
+
+    >>> DVweight = G.degree(weight="span")
+    >>> G.add_edge(1, 2, span=34)
+    >>> DVweight[2]
+    34
+    >>> DVweight[0]  #  default edge weight is 1
+    1
+    >>> sum(span for n, span in DVweight)  # sum weighted degrees
+    70
+
+    >>> DVnbunch = G.degree(nbunch=(1, 2))
+    >>> assert len(list(DVnbunch)) == 2  # iteration over nbunch only
+    """
+
+    def __init__(self, G, nbunch=None, weight=None):
+        self._graph = G
+        self._succ = G._succ if hasattr(G, "_succ") else G._adj
+        self._pred = G._pred if hasattr(G, "_pred") else G._adj
+        self._nodes = self._succ if nbunch is None else list(G.nbunch_iter(nbunch))
+        self._weight = weight
+
+    def __call__(self, nbunch=None, weight=None):
+        if nbunch is None:
+            if weight == self._weight:
+                return self
+            return self.__class__(self._graph, None, weight)
+        try:
+            if nbunch in self._nodes:
+                if weight == self._weight:
+                    return self[nbunch]
+                return self.__class__(self._graph, None, weight)[nbunch]
+        except TypeError:
+            pass
+        return self.__class__(self._graph, nbunch, weight)
+
+    def __getitem__(self, n):
+        weight = self._weight
+        succs = self._succ[n]
+        preds = self._pred[n]
+        if weight is None:
+            return len(succs) + len(preds)
+        return sum(dd.get(weight, 1) for dd in succs.values()) + sum(
+            dd.get(weight, 1) for dd in preds.values()
+        )
+
+    def __iter__(self):
+        weight = self._weight
+        if weight is None:
+            for n in self._nodes:
+                succs = self._succ[n]
+                preds = self._pred[n]
+                yield (n, len(succs) + len(preds))
+        else:
+            for n in self._nodes:
+                succs = self._succ[n]
+                preds = self._pred[n]
+                deg = sum(dd.get(weight, 1) for dd in succs.values()) + sum(
+                    dd.get(weight, 1) for dd in preds.values()
+                )
+                yield (n, deg)
+
+    def __len__(self):
+        return len(self._nodes)
+
+    def __str__(self):
+        return str(list(self))
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({dict(self)})"
+
+
+class DegreeView(DiDegreeView):
+    """A DegreeView class to act as G.degree for a NetworkX Graph
+
+    Typical usage focuses on iteration over `(node, degree)` pairs.
+    The degree is by default the number of edges incident to the node.
+    Optional argument `weight` enables weighted degree using the edge
+    attribute named in the `weight` argument.  Reporting and iteration
+    can also be restricted to a subset of nodes using `nbunch`.
+
+    Additional functionality include node lookup so that `G.degree[n]`
+    reported the (possibly weighted) degree of node `n`. Calling the
+    view creates a view with different arguments `nbunch` or `weight`.
+
+    Parameters
+    ==========
+    graph : NetworkX graph-like class
+    nbunch : node, container of nodes, or None meaning all nodes (default=None)
+    weight : string or None (default=None)
+
+    Notes
+    -----
+    DegreeView can still lookup any node even if nbunch is specified.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(3)
+    >>> DV = G.degree()
+    >>> assert DV[2] == 1
+    >>> assert G.degree[2] == 1
+    >>> assert sum(deg for n, deg in DV) == 4
+
+    >>> DVweight = G.degree(weight="span")
+    >>> G.add_edge(1, 2, span=34)
+    >>> DVweight[2]
+    34
+    >>> DVweight[0]  #  default edge weight is 1
+    1
+    >>> sum(span for n, span in DVweight)  # sum weighted degrees
+    70
+
+    >>> DVnbunch = G.degree(nbunch=(1, 2))
+    >>> assert len(list(DVnbunch)) == 2  # iteration over nbunch only
+    """
+
+    def __getitem__(self, n):
+        weight = self._weight
+        nbrs = self._succ[n]
+        if weight is None:
+            return len(nbrs) + (n in nbrs)
+        return sum(dd.get(weight, 1) for dd in nbrs.values()) + (
+            n in nbrs and nbrs[n].get(weight, 1)
+        )
+
+    def __iter__(self):
+        weight = self._weight
+        if weight is None:
+            for n in self._nodes:
+                nbrs = self._succ[n]
+                yield (n, len(nbrs) + (n in nbrs))
+        else:
+            for n in self._nodes:
+                nbrs = self._succ[n]
+                deg = sum(dd.get(weight, 1) for dd in nbrs.values()) + (
+                    n in nbrs and nbrs[n].get(weight, 1)
+                )
+                yield (n, deg)
+
+
+class OutDegreeView(DiDegreeView):
+    """A DegreeView class to report out_degree for a DiGraph; See DegreeView"""
+
+    def __getitem__(self, n):
+        weight = self._weight
+        nbrs = self._succ[n]
+        if self._weight is None:
+            return len(nbrs)
+        return sum(dd.get(self._weight, 1) for dd in nbrs.values())
+
+    def __iter__(self):
+        weight = self._weight
+        if weight is None:
+            for n in self._nodes:
+                succs = self._succ[n]
+                yield (n, len(succs))
+        else:
+            for n in self._nodes:
+                succs = self._succ[n]
+                deg = sum(dd.get(weight, 1) for dd in succs.values())
+                yield (n, deg)
+
+
+class InDegreeView(DiDegreeView):
+    """A DegreeView class to report in_degree for a DiGraph; See DegreeView"""
+
+    def __getitem__(self, n):
+        weight = self._weight
+        nbrs = self._pred[n]
+        if weight is None:
+            return len(nbrs)
+        return sum(dd.get(weight, 1) for dd in nbrs.values())
+
+    def __iter__(self):
+        weight = self._weight
+        if weight is None:
+            for n in self._nodes:
+                preds = self._pred[n]
+                yield (n, len(preds))
+        else:
+            for n in self._nodes:
+                preds = self._pred[n]
+                deg = sum(dd.get(weight, 1) for dd in preds.values())
+                yield (n, deg)
+
+
+class MultiDegreeView(DiDegreeView):
+    """A DegreeView class for undirected multigraphs; See DegreeView"""
+
+    def __getitem__(self, n):
+        weight = self._weight
+        nbrs = self._succ[n]
+        if weight is None:
+            return sum(len(keys) for keys in nbrs.values()) + (
+                n in nbrs and len(nbrs[n])
+            )
+        # edge weighted graph - degree is sum of nbr edge weights
+        deg = sum(
+            d.get(weight, 1) for key_dict in nbrs.values() for d in key_dict.values()
+        )
+        if n in nbrs:
+            deg += sum(d.get(weight, 1) for d in nbrs[n].values())
+        return deg
+
+    def __iter__(self):
+        weight = self._weight
+        if weight is None:
+            for n in self._nodes:
+                nbrs = self._succ[n]
+                deg = sum(len(keys) for keys in nbrs.values()) + (
+                    n in nbrs and len(nbrs[n])
+                )
+                yield (n, deg)
+        else:
+            for n in self._nodes:
+                nbrs = self._succ[n]
+                deg = sum(
+                    d.get(weight, 1)
+                    for key_dict in nbrs.values()
+                    for d in key_dict.values()
+                )
+                if n in nbrs:
+                    deg += sum(d.get(weight, 1) for d in nbrs[n].values())
+                yield (n, deg)
+
+
+class DiMultiDegreeView(DiDegreeView):
+    """A DegreeView class for MultiDiGraph; See DegreeView"""
+
+    def __getitem__(self, n):
+        weight = self._weight
+        succs = self._succ[n]
+        preds = self._pred[n]
+        if weight is None:
+            return sum(len(keys) for keys in succs.values()) + sum(
+                len(keys) for keys in preds.values()
+            )
+        # edge weighted graph - degree is sum of nbr edge weights
+        deg = sum(
+            d.get(weight, 1) for key_dict in succs.values() for d in key_dict.values()
+        ) + sum(
+            d.get(weight, 1) for key_dict in preds.values() for d in key_dict.values()
+        )
+        return deg
+
+    def __iter__(self):
+        weight = self._weight
+        if weight is None:
+            for n in self._nodes:
+                succs = self._succ[n]
+                preds = self._pred[n]
+                deg = sum(len(keys) for keys in succs.values()) + sum(
+                    len(keys) for keys in preds.values()
+                )
+                yield (n, deg)
+        else:
+            for n in self._nodes:
+                succs = self._succ[n]
+                preds = self._pred[n]
+                deg = sum(
+                    d.get(weight, 1)
+                    for key_dict in succs.values()
+                    for d in key_dict.values()
+                ) + sum(
+                    d.get(weight, 1)
+                    for key_dict in preds.values()
+                    for d in key_dict.values()
+                )
+                yield (n, deg)
+
+
+class InMultiDegreeView(DiDegreeView):
+    """A DegreeView class for inward degree of MultiDiGraph; See DegreeView"""
+
+    def __getitem__(self, n):
+        weight = self._weight
+        nbrs = self._pred[n]
+        if weight is None:
+            return sum(len(data) for data in nbrs.values())
+        # edge weighted graph - degree is sum of nbr edge weights
+        return sum(
+            d.get(weight, 1) for key_dict in nbrs.values() for d in key_dict.values()
+        )
+
+    def __iter__(self):
+        weight = self._weight
+        if weight is None:
+            for n in self._nodes:
+                nbrs = self._pred[n]
+                deg = sum(len(data) for data in nbrs.values())
+                yield (n, deg)
+        else:
+            for n in self._nodes:
+                nbrs = self._pred[n]
+                deg = sum(
+                    d.get(weight, 1)
+                    for key_dict in nbrs.values()
+                    for d in key_dict.values()
+                )
+                yield (n, deg)
+
+
+class OutMultiDegreeView(DiDegreeView):
+    """A DegreeView class for outward degree of MultiDiGraph; See DegreeView"""
+
+    def __getitem__(self, n):
+        weight = self._weight
+        nbrs = self._succ[n]
+        if weight is None:
+            return sum(len(data) for data in nbrs.values())
+        # edge weighted graph - degree is sum of nbr edge weights
+        return sum(
+            d.get(weight, 1) for key_dict in nbrs.values() for d in key_dict.values()
+        )
+
+    def __iter__(self):
+        weight = self._weight
+        if weight is None:
+            for n in self._nodes:
+                nbrs = self._succ[n]
+                deg = sum(len(data) for data in nbrs.values())
+                yield (n, deg)
+        else:
+            for n in self._nodes:
+                nbrs = self._succ[n]
+                deg = sum(
+                    d.get(weight, 1)
+                    for key_dict in nbrs.values()
+                    for d in key_dict.values()
+                )
+                yield (n, deg)
+
+
+# EdgeDataViews
+class OutEdgeDataView:
+    """EdgeDataView for outward edges of DiGraph; See EdgeDataView"""
+
+    __slots__ = (
+        "_viewer",
+        "_nbunch",
+        "_data",
+        "_default",
+        "_adjdict",
+        "_nodes_nbrs",
+        "_report",
+    )
+
+    def __getstate__(self):
+        return {
+            "viewer": self._viewer,
+            "nbunch": self._nbunch,
+            "data": self._data,
+            "default": self._default,
+        }
+
+    def __setstate__(self, state):
+        self.__init__(**state)
+
+    def __init__(self, viewer, nbunch=None, data=False, default=None):
+        self._viewer = viewer
+        adjdict = self._adjdict = viewer._adjdict
+        if nbunch is None:
+            self._nodes_nbrs = adjdict.items
+        else:
+            # dict retains order of nodes but acts like a set
+            nbunch = dict.fromkeys(viewer._graph.nbunch_iter(nbunch))
+            self._nodes_nbrs = lambda: [(n, adjdict[n]) for n in nbunch]
+        self._nbunch = nbunch
+        self._data = data
+        self._default = default
+        # Set _report based on data and default
+        if data is True:
+            self._report = lambda n, nbr, dd: (n, nbr, dd)
+        elif data is False:
+            self._report = lambda n, nbr, dd: (n, nbr)
+        else:  # data is attribute name
+            self._report = (
+                lambda n, nbr, dd: (n, nbr, dd[data])
+                if data in dd
+                else (n, nbr, default)
+            )
+
+    def __len__(self):
+        return sum(len(nbrs) for n, nbrs in self._nodes_nbrs())
+
+    def __iter__(self):
+        return (
+            self._report(n, nbr, dd)
+            for n, nbrs in self._nodes_nbrs()
+            for nbr, dd in nbrs.items()
+        )
+
+    def __contains__(self, e):
+        u, v = e[:2]
+        if self._nbunch is not None and u not in self._nbunch:
+            return False  # this edge doesn't start in nbunch
+        try:
+            ddict = self._adjdict[u][v]
+        except KeyError:
+            return False
+        return e == self._report(u, v, ddict)
+
+    def __str__(self):
+        return str(list(self))
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({list(self)})"
+
+
+class EdgeDataView(OutEdgeDataView):
+    """A EdgeDataView class for edges of Graph
+
+    This view is primarily used to iterate over the edges reporting
+    edges as node-tuples with edge data optionally reported. The
+    argument `nbunch` allows restriction to edges incident to nodes
+    in that container/singleton. The default (nbunch=None)
+    reports all edges. The arguments `data` and `default` control
+    what edge data is reported. The default `data is False` reports
+    only node-tuples for each edge. If `data is True` the entire edge
+    data dict is returned. Otherwise `data` is assumed to hold the name
+    of the edge attribute to report with default `default` if  that
+    edge attribute is not present.
+
+    Parameters
+    ----------
+    nbunch : container of nodes, node or None (default None)
+    data : False, True or string (default False)
+    default : default value (default None)
+
+    Examples
+    --------
+    >>> G = nx.path_graph(3)
+    >>> G.add_edge(1, 2, foo="bar")
+    >>> list(G.edges(data="foo", default="biz"))
+    [(0, 1, 'biz'), (1, 2, 'bar')]
+    >>> assert (0, 1, "biz") in G.edges(data="foo", default="biz")
+    """
+
+    __slots__ = ()
+
+    def __len__(self):
+        return sum(1 for e in self)
+
+    def __iter__(self):
+        seen = {}
+        for n, nbrs in self._nodes_nbrs():
+            for nbr, dd in nbrs.items():
+                if nbr not in seen:
+                    yield self._report(n, nbr, dd)
+            seen[n] = 1
+        del seen
+
+    def __contains__(self, e):
+        u, v = e[:2]
+        if self._nbunch is not None and u not in self._nbunch and v not in self._nbunch:
+            return False  # this edge doesn't start and it doesn't end in nbunch
+        try:
+            ddict = self._adjdict[u][v]
+        except KeyError:
+            return False
+        return e == self._report(u, v, ddict)
+
+
+class InEdgeDataView(OutEdgeDataView):
+    """An EdgeDataView class for outward edges of DiGraph; See EdgeDataView"""
+
+    __slots__ = ()
+
+    def __iter__(self):
+        return (
+            self._report(nbr, n, dd)
+            for n, nbrs in self._nodes_nbrs()
+            for nbr, dd in nbrs.items()
+        )
+
+    def __contains__(self, e):
+        u, v = e[:2]
+        if self._nbunch is not None and v not in self._nbunch:
+            return False  # this edge doesn't end in nbunch
+        try:
+            ddict = self._adjdict[v][u]
+        except KeyError:
+            return False
+        return e == self._report(u, v, ddict)
+
+
+class OutMultiEdgeDataView(OutEdgeDataView):
+    """An EdgeDataView for outward edges of MultiDiGraph; See EdgeDataView"""
+
+    __slots__ = ("keys",)
+
+    def __getstate__(self):
+        return {
+            "viewer": self._viewer,
+            "nbunch": self._nbunch,
+            "keys": self.keys,
+            "data": self._data,
+            "default": self._default,
+        }
+
+    def __setstate__(self, state):
+        self.__init__(**state)
+
+    def __init__(self, viewer, nbunch=None, data=False, keys=False, default=None):
+        self._viewer = viewer
+        adjdict = self._adjdict = viewer._adjdict
+        self.keys = keys
+        if nbunch is None:
+            self._nodes_nbrs = adjdict.items
+        else:
+            # dict retains order of nodes but acts like a set
+            nbunch = dict.fromkeys(viewer._graph.nbunch_iter(nbunch))
+            self._nodes_nbrs = lambda: [(n, adjdict[n]) for n in nbunch]
+        self._nbunch = nbunch
+        self._data = data
+        self._default = default
+        # Set _report based on data and default
+        if data is True:
+            if keys is True:
+                self._report = lambda n, nbr, k, dd: (n, nbr, k, dd)
+            else:
+                self._report = lambda n, nbr, k, dd: (n, nbr, dd)
+        elif data is False:
+            if keys is True:
+                self._report = lambda n, nbr, k, dd: (n, nbr, k)
+            else:
+                self._report = lambda n, nbr, k, dd: (n, nbr)
+        else:  # data is attribute name
+            if keys is True:
+                self._report = (
+                    lambda n, nbr, k, dd: (n, nbr, k, dd[data])
+                    if data in dd
+                    else (n, nbr, k, default)
+                )
+            else:
+                self._report = (
+                    lambda n, nbr, k, dd: (n, nbr, dd[data])
+                    if data in dd
+                    else (n, nbr, default)
+                )
+
+    def __len__(self):
+        return sum(1 for e in self)
+
+    def __iter__(self):
+        return (
+            self._report(n, nbr, k, dd)
+            for n, nbrs in self._nodes_nbrs()
+            for nbr, kd in nbrs.items()
+            for k, dd in kd.items()
+        )
+
+    def __contains__(self, e):
+        u, v = e[:2]
+        if self._nbunch is not None and u not in self._nbunch:
+            return False  # this edge doesn't start in nbunch
+        try:
+            kdict = self._adjdict[u][v]
+        except KeyError:
+            return False
+        if self.keys is True:
+            k = e[2]
+            try:
+                dd = kdict[k]
+            except KeyError:
+                return False
+            return e == self._report(u, v, k, dd)
+        for k, dd in kdict.items():
+            if e == self._report(u, v, k, dd):
+                return True
+        return False
+
+
+class MultiEdgeDataView(OutMultiEdgeDataView):
+    """An EdgeDataView class for edges of MultiGraph; See EdgeDataView"""
+
+    __slots__ = ()
+
+    def __iter__(self):
+        seen = {}
+        for n, nbrs in self._nodes_nbrs():
+            for nbr, kd in nbrs.items():
+                if nbr not in seen:
+                    for k, dd in kd.items():
+                        yield self._report(n, nbr, k, dd)
+            seen[n] = 1
+        del seen
+
+    def __contains__(self, e):
+        u, v = e[:2]
+        if self._nbunch is not None and u not in self._nbunch and v not in self._nbunch:
+            return False  # this edge doesn't start and doesn't end in nbunch
+        try:
+            kdict = self._adjdict[u][v]
+        except KeyError:
+            try:
+                kdict = self._adjdict[v][u]
+            except KeyError:
+                return False
+        if self.keys is True:
+            k = e[2]
+            try:
+                dd = kdict[k]
+            except KeyError:
+                return False
+            return e == self._report(u, v, k, dd)
+        for k, dd in kdict.items():
+            if e == self._report(u, v, k, dd):
+                return True
+        return False
+
+
+class InMultiEdgeDataView(OutMultiEdgeDataView):
+    """An EdgeDataView for inward edges of MultiDiGraph; See EdgeDataView"""
+
+    __slots__ = ()
+
+    def __iter__(self):
+        return (
+            self._report(nbr, n, k, dd)
+            for n, nbrs in self._nodes_nbrs()
+            for nbr, kd in nbrs.items()
+            for k, dd in kd.items()
+        )
+
+    def __contains__(self, e):
+        u, v = e[:2]
+        if self._nbunch is not None and v not in self._nbunch:
+            return False  # this edge doesn't end in nbunch
+        try:
+            kdict = self._adjdict[v][u]
+        except KeyError:
+            return False
+        if self.keys is True:
+            k = e[2]
+            dd = kdict[k]
+            return e == self._report(u, v, k, dd)
+        for k, dd in kdict.items():
+            if e == self._report(u, v, k, dd):
+                return True
+        return False
+
+
+# EdgeViews    have set operations and no data reported
+class OutEdgeView(Set, Mapping):
+    """A EdgeView class for outward edges of a DiGraph"""
+
+    __slots__ = ("_adjdict", "_graph", "_nodes_nbrs")
+
+    def __getstate__(self):
+        return {"_graph": self._graph, "_adjdict": self._adjdict}
+
+    def __setstate__(self, state):
+        self._graph = state["_graph"]
+        self._adjdict = state["_adjdict"]
+        self._nodes_nbrs = self._adjdict.items
+
+    @classmethod
+    def _from_iterable(cls, it):
+        return set(it)
+
+    dataview = OutEdgeDataView
+
+    def __init__(self, G):
+        self._graph = G
+        self._adjdict = G._succ if hasattr(G, "succ") else G._adj
+        self._nodes_nbrs = self._adjdict.items
+
+    # Set methods
+    def __len__(self):
+        return sum(len(nbrs) for n, nbrs in self._nodes_nbrs())
+
+    def __iter__(self):
+        for n, nbrs in self._nodes_nbrs():
+            for nbr in nbrs:
+                yield (n, nbr)
+
+    def __contains__(self, e):
+        try:
+            u, v = e
+            return v in self._adjdict[u]
+        except KeyError:
+            return False
+
+    # Mapping Methods
+    def __getitem__(self, e):
+        if isinstance(e, slice):
+            raise nx.NetworkXError(
+                f"{type(self).__name__} does not support slicing, "
+                f"try list(G.edges)[{e.start}:{e.stop}:{e.step}]"
+            )
+        u, v = e
+        return self._adjdict[u][v]
+
+    # EdgeDataView methods
+    def __call__(self, nbunch=None, data=False, default=None):
+        if nbunch is None and data is False:
+            return self
+        return self.dataview(self, nbunch, data, default)
+
+    def data(self, data=True, default=None, nbunch=None):
+        """
+        Return a read-only view of edge data.
+
+        Parameters
+        ----------
+        data : bool or edge attribute key
+            If ``data=True``, then the data view maps each edge to a dictionary
+            containing all of its attributes. If `data` is a key in the edge
+            dictionary, then the data view maps each edge to its value for
+            the keyed attribute. In this case, if the edge doesn't have the
+            attribute, the `default` value is returned.
+        default : object, default=None
+            The value used when an edge does not have a specific attribute
+        nbunch : container of nodes, optional (default=None)
+            Allows restriction to edges only involving certain nodes. All edges
+            are considered by default.
+
+        Returns
+        -------
+        dataview
+            Returns an `EdgeDataView` for undirected Graphs, `OutEdgeDataView`
+            for DiGraphs, `MultiEdgeDataView` for MultiGraphs and
+            `OutMultiEdgeDataView` for MultiDiGraphs.
+
+        Notes
+        -----
+        If ``data=False``, returns an `EdgeView` without any edge data.
+
+        See Also
+        --------
+        EdgeDataView
+        OutEdgeDataView
+        MultiEdgeDataView
+        OutMultiEdgeDataView
+
+        Examples
+        --------
+        >>> G = nx.Graph()
+        >>> G.add_edges_from([
+        ...     (0, 1, {"dist": 3, "capacity": 20}),
+        ...     (1, 2, {"dist": 4}),
+        ...     (2, 0, {"dist": 5})
+        ... ])
+
+        Accessing edge data with ``data=True`` (the default) returns an
+        edge data view object listing each edge with all of its attributes:
+
+        >>> G.edges.data()
+        EdgeDataView([(0, 1, {'dist': 3, 'capacity': 20}), (0, 2, {'dist': 5}), (1, 2, {'dist': 4})])
+
+        If `data` represents a key in the edge attribute dict, a dataview listing
+        each edge with its value for that specific key is returned:
+
+        >>> G.edges.data("dist")
+        EdgeDataView([(0, 1, 3), (0, 2, 5), (1, 2, 4)])
+
+        `nbunch` can be used to limit the edges:
+
+        >>> G.edges.data("dist", nbunch=[0])
+        EdgeDataView([(0, 1, 3), (0, 2, 5)])
+
+        If a specific key is not found in an edge attribute dict, the value
+        specified by `default` is used:
+
+        >>> G.edges.data("capacity")
+        EdgeDataView([(0, 1, 20), (0, 2, None), (1, 2, None)])
+
+        Note that there is no check that the `data` key is present in any of
+        the edge attribute dictionaries:
+
+        >>> G.edges.data("speed")
+        EdgeDataView([(0, 1, None), (0, 2, None), (1, 2, None)])
+        """
+        if nbunch is None and data is False:
+            return self
+        return self.dataview(self, nbunch, data, default)
+
+    # String Methods
+    def __str__(self):
+        return str(list(self))
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({list(self)})"
+
+
+class EdgeView(OutEdgeView):
+    """A EdgeView class for edges of a Graph
+
+    This densely packed View allows iteration over edges, data lookup
+    like a dict and set operations on edges represented by node-tuples.
+    In addition, edge data can be controlled by calling this object
+    possibly creating an EdgeDataView. Typically edges are iterated over
+    and reported as `(u, v)` node tuples or `(u, v, key)` node/key tuples
+    for multigraphs. Those edge representations can also be using to
+    lookup the data dict for any edge. Set operations also are available
+    where those tuples are the elements of the set.
+    Calling this object with optional arguments `data`, `default` and `keys`
+    controls the form of the tuple (see EdgeDataView). Optional argument
+    `nbunch` allows restriction to edges only involving certain nodes.
+
+    If `data is False` (the default) then iterate over 2-tuples `(u, v)`.
+    If `data is True` iterate over 3-tuples `(u, v, datadict)`.
+    Otherwise iterate over `(u, v, datadict.get(data, default))`.
+    For Multigraphs, if `keys is True`, replace `u, v` with `u, v, key` above.
+
+    Parameters
+    ==========
+    graph : NetworkX graph-like class
+    nbunch : (default= all nodes in graph) only report edges with these nodes
+    keys : (only for MultiGraph. default=False) report edge key in tuple
+    data : bool or string (default=False) see above
+    default : object (default=None)
+
+    Examples
+    ========
+    >>> G = nx.path_graph(4)
+    >>> EV = G.edges()
+    >>> (2, 3) in EV
+    True
+    >>> for u, v in EV:
+    ...     print((u, v))
+    (0, 1)
+    (1, 2)
+    (2, 3)
+    >>> assert EV & {(1, 2), (3, 4)} == {(1, 2)}
+
+    >>> EVdata = G.edges(data="color", default="aqua")
+    >>> G.add_edge(2, 3, color="blue")
+    >>> assert (2, 3, "blue") in EVdata
+    >>> for u, v, c in EVdata:
+    ...     print(f"({u}, {v}) has color: {c}")
+    (0, 1) has color: aqua
+    (1, 2) has color: aqua
+    (2, 3) has color: blue
+
+    >>> EVnbunch = G.edges(nbunch=2)
+    >>> assert (2, 3) in EVnbunch
+    >>> assert (0, 1) not in EVnbunch
+    >>> for u, v in EVnbunch:
+    ...     assert u == 2 or v == 2
+
+    >>> MG = nx.path_graph(4, create_using=nx.MultiGraph)
+    >>> EVmulti = MG.edges(keys=True)
+    >>> (2, 3, 0) in EVmulti
+    True
+    >>> (2, 3) in EVmulti  # 2-tuples work even when keys is True
+    True
+    >>> key = MG.add_edge(2, 3)
+    >>> for u, v, k in EVmulti:
+    ...     print((u, v, k))
+    (0, 1, 0)
+    (1, 2, 0)
+    (2, 3, 0)
+    (2, 3, 1)
+    """
+
+    __slots__ = ()
+
+    dataview = EdgeDataView
+
+    def __len__(self):
+        num_nbrs = (len(nbrs) + (n in nbrs) for n, nbrs in self._nodes_nbrs())
+        return sum(num_nbrs) // 2
+
+    def __iter__(self):
+        seen = {}
+        for n, nbrs in self._nodes_nbrs():
+            for nbr in list(nbrs):
+                if nbr not in seen:
+                    yield (n, nbr)
+            seen[n] = 1
+        del seen
+
+    def __contains__(self, e):
+        try:
+            u, v = e[:2]
+            return v in self._adjdict[u] or u in self._adjdict[v]
+        except (KeyError, ValueError):
+            return False
+
+
+class InEdgeView(OutEdgeView):
+    """A EdgeView class for inward edges of a DiGraph"""
+
+    __slots__ = ()
+
+    def __setstate__(self, state):
+        self._graph = state["_graph"]
+        self._adjdict = state["_adjdict"]
+        self._nodes_nbrs = self._adjdict.items
+
+    dataview = InEdgeDataView
+
+    def __init__(self, G):
+        self._graph = G
+        self._adjdict = G._pred if hasattr(G, "pred") else G._adj
+        self._nodes_nbrs = self._adjdict.items
+
+    def __iter__(self):
+        for n, nbrs in self._nodes_nbrs():
+            for nbr in nbrs:
+                yield (nbr, n)
+
+    def __contains__(self, e):
+        try:
+            u, v = e
+            return u in self._adjdict[v]
+        except KeyError:
+            return False
+
+    def __getitem__(self, e):
+        if isinstance(e, slice):
+            raise nx.NetworkXError(
+                f"{type(self).__name__} does not support slicing, "
+                f"try list(G.in_edges)[{e.start}:{e.stop}:{e.step}]"
+            )
+        u, v = e
+        return self._adjdict[v][u]
+
+
+class OutMultiEdgeView(OutEdgeView):
+    """A EdgeView class for outward edges of a MultiDiGraph"""
+
+    __slots__ = ()
+
+    dataview = OutMultiEdgeDataView
+
+    def __len__(self):
+        return sum(
+            len(kdict) for n, nbrs in self._nodes_nbrs() for nbr, kdict in nbrs.items()
+        )
+
+    def __iter__(self):
+        for n, nbrs in self._nodes_nbrs():
+            for nbr, kdict in nbrs.items():
+                for key in kdict:
+                    yield (n, nbr, key)
+
+    def __contains__(self, e):
+        N = len(e)
+        if N == 3:
+            u, v, k = e
+        elif N == 2:
+            u, v = e
+            k = 0
+        else:
+            raise ValueError("MultiEdge must have length 2 or 3")
+        try:
+            return k in self._adjdict[u][v]
+        except KeyError:
+            return False
+
+    def __getitem__(self, e):
+        if isinstance(e, slice):
+            raise nx.NetworkXError(
+                f"{type(self).__name__} does not support slicing, "
+                f"try list(G.edges)[{e.start}:{e.stop}:{e.step}]"
+            )
+        u, v, k = e
+        return self._adjdict[u][v][k]
+
+    def __call__(self, nbunch=None, data=False, keys=False, default=None):
+        if nbunch is None and data is False and keys is True:
+            return self
+        return self.dataview(self, nbunch, data, keys, default)
+
+    def data(self, data=True, keys=False, default=None, nbunch=None):
+        if nbunch is None and data is False and keys is True:
+            return self
+        return self.dataview(self, nbunch, data, keys, default)
+
+
+class MultiEdgeView(OutMultiEdgeView):
+    """A EdgeView class for edges of a MultiGraph"""
+
+    __slots__ = ()
+
+    dataview = MultiEdgeDataView
+
+    def __len__(self):
+        return sum(1 for e in self)
+
+    def __iter__(self):
+        seen = {}
+        for n, nbrs in self._nodes_nbrs():
+            for nbr, kd in nbrs.items():
+                if nbr not in seen:
+                    for k, dd in kd.items():
+                        yield (n, nbr, k)
+            seen[n] = 1
+        del seen
+
+
+class InMultiEdgeView(OutMultiEdgeView):
+    """A EdgeView class for inward edges of a MultiDiGraph"""
+
+    __slots__ = ()
+
+    def __setstate__(self, state):
+        self._graph = state["_graph"]
+        self._adjdict = state["_adjdict"]
+        self._nodes_nbrs = self._adjdict.items
+
+    dataview = InMultiEdgeDataView
+
+    def __init__(self, G):
+        self._graph = G
+        self._adjdict = G._pred if hasattr(G, "pred") else G._adj
+        self._nodes_nbrs = self._adjdict.items
+
+    def __iter__(self):
+        for n, nbrs in self._nodes_nbrs():
+            for nbr, kdict in nbrs.items():
+                for key in kdict:
+                    yield (nbr, n, key)
+
+    def __contains__(self, e):
+        N = len(e)
+        if N == 3:
+            u, v, k = e
+        elif N == 2:
+            u, v = e
+            k = 0
+        else:
+            raise ValueError("MultiEdge must have length 2 or 3")
+        try:
+            return k in self._adjdict[v][u]
+        except KeyError:
+            return False
+
+    def __getitem__(self, e):
+        if isinstance(e, slice):
+            raise nx.NetworkXError(
+                f"{type(self).__name__} does not support slicing, "
+                f"try list(G.in_edges)[{e.start}:{e.stop}:{e.step}]"
+            )
+        u, v, k = e
+        return self._adjdict[v][u][k]
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/historical_tests.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/historical_tests.py
new file mode 100644
index 0000000..44b72fd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/historical_tests.py
@@ -0,0 +1,474 @@
+"""Original NetworkX graph tests"""
+import pytest
+
+import networkx as nx
+from networkx import convert_node_labels_to_integers as cnlti
+from networkx.utils import edges_equal, nodes_equal
+
+
+class HistoricalTests:
+    @classmethod
+    def setup_class(cls):
+        cls.null = nx.null_graph()
+        cls.P1 = cnlti(nx.path_graph(1), first_label=1)
+        cls.P3 = cnlti(nx.path_graph(3), first_label=1)
+        cls.P10 = cnlti(nx.path_graph(10), first_label=1)
+        cls.K1 = cnlti(nx.complete_graph(1), first_label=1)
+        cls.K3 = cnlti(nx.complete_graph(3), first_label=1)
+        cls.K4 = cnlti(nx.complete_graph(4), first_label=1)
+        cls.K5 = cnlti(nx.complete_graph(5), first_label=1)
+        cls.K10 = cnlti(nx.complete_graph(10), first_label=1)
+        cls.G = nx.Graph
+
+    def test_name(self):
+        G = self.G(name="test")
+        assert G.name == "test"
+        H = self.G()
+        assert H.name == ""
+
+    # Nodes
+
+    def test_add_remove_node(self):
+        G = self.G()
+        G.add_node("A")
+        assert G.has_node("A")
+        G.remove_node("A")
+        assert not G.has_node("A")
+
+    def test_nonhashable_node(self):
+        # Test if a non-hashable object is in the Graph.  A python dict will
+        # raise a TypeError, but for a Graph class a simple  False should be
+        # returned (see Graph __contains__). If it cannot be a node then it is
+        # not a node.
+        G = self.G()
+        assert not G.has_node(["A"])
+        assert not G.has_node({"A": 1})
+
+    def test_add_nodes_from(self):
+        G = self.G()
+        G.add_nodes_from(list("ABCDEFGHIJKL"))
+        assert G.has_node("L")
+        G.remove_nodes_from(["H", "I", "J", "K", "L"])
+        G.add_nodes_from([1, 2, 3, 4])
+        assert sorted(G.nodes(), key=str) == [
+            1,
+            2,
+            3,
+            4,
+            "A",
+            "B",
+            "C",
+            "D",
+            "E",
+            "F",
+            "G",
+        ]
+        # test __iter__
+        assert sorted(G, key=str) == [1, 2, 3, 4, "A", "B", "C", "D", "E", "F", "G"]
+
+    def test_contains(self):
+        G = self.G()
+        G.add_node("A")
+        assert "A" in G
+        assert not [] in G  # never raise a Key or TypeError in this test
+        assert not {1: 1} in G
+
+    def test_add_remove(self):
+        # Test add_node and remove_node acting for various nbunch
+        G = self.G()
+        G.add_node("m")
+        assert G.has_node("m")
+        G.add_node("m")  # no complaints
+        pytest.raises(nx.NetworkXError, G.remove_node, "j")
+        G.remove_node("m")
+        assert list(G) == []
+
+    def test_nbunch_is_list(self):
+        G = self.G()
+        G.add_nodes_from(list("ABCD"))
+        G.add_nodes_from(self.P3)  # add nbunch of nodes (nbunch=Graph)
+        assert sorted(G.nodes(), key=str) == [1, 2, 3, "A", "B", "C", "D"]
+        G.remove_nodes_from(self.P3)  # remove nbunch of nodes (nbunch=Graph)
+        assert sorted(G.nodes(), key=str) == ["A", "B", "C", "D"]
+
+    def test_nbunch_is_set(self):
+        G = self.G()
+        nbunch = set("ABCDEFGHIJKL")
+        G.add_nodes_from(nbunch)
+        assert G.has_node("L")
+
+    def test_nbunch_dict(self):
+        # nbunch is a dict with nodes as keys
+        G = self.G()
+        nbunch = set("ABCDEFGHIJKL")
+        G.add_nodes_from(nbunch)
+        nbunch = {"I": "foo", "J": 2, "K": True, "L": "spam"}
+        G.remove_nodes_from(nbunch)
+        assert sorted(G.nodes(), key=str), ["A", "B", "C", "D", "E", "F", "G", "H"]
+
+    def test_nbunch_iterator(self):
+        G = self.G()
+        G.add_nodes_from(["A", "B", "C", "D", "E", "F", "G", "H"])
+        n_iter = self.P3.nodes()
+        G.add_nodes_from(n_iter)
+        assert sorted(G.nodes(), key=str) == [
+            1,
+            2,
+            3,
+            "A",
+            "B",
+            "C",
+            "D",
+            "E",
+            "F",
+            "G",
+            "H",
+        ]
+        n_iter = self.P3.nodes()  # rebuild same iterator
+        G.remove_nodes_from(n_iter)  # remove nbunch of nodes (nbunch=iterator)
+        assert sorted(G.nodes(), key=str) == ["A", "B", "C", "D", "E", "F", "G", "H"]
+
+    def test_nbunch_graph(self):
+        G = self.G()
+        G.add_nodes_from(["A", "B", "C", "D", "E", "F", "G", "H"])
+        nbunch = self.K3
+        G.add_nodes_from(nbunch)
+        assert sorted(G.nodes(), key=str), [
+            1,
+            2,
+            3,
+            "A",
+            "B",
+            "C",
+            "D",
+            "E",
+            "F",
+            "G",
+            "H",
+        ]
+
+    # Edges
+
+    def test_add_edge(self):
+        G = self.G()
+        pytest.raises(TypeError, G.add_edge, "A")
+
+        G.add_edge("A", "B")  # testing add_edge()
+        G.add_edge("A", "B")  # should fail silently
+        assert G.has_edge("A", "B")
+        assert not G.has_edge("A", "C")
+        assert G.has_edge(*("A", "B"))
+        if G.is_directed():
+            assert not G.has_edge("B", "A")
+        else:
+            # G is undirected, so B->A is an edge
+            assert G.has_edge("B", "A")
+
+        G.add_edge("A", "C")  # test directedness
+        G.add_edge("C", "A")
+        G.remove_edge("C", "A")
+        if G.is_directed():
+            assert G.has_edge("A", "C")
+        else:
+            assert not G.has_edge("A", "C")
+        assert not G.has_edge("C", "A")
+
+    def test_self_loop(self):
+        G = self.G()
+        G.add_edge("A", "A")  # test self loops
+        assert G.has_edge("A", "A")
+        G.remove_edge("A", "A")
+        G.add_edge("X", "X")
+        assert G.has_node("X")
+        G.remove_node("X")
+        G.add_edge("A", "Z")  # should add the node silently
+        assert G.has_node("Z")
+
+    def test_add_edges_from(self):
+        G = self.G()
+        G.add_edges_from([("B", "C")])  # test add_edges_from()
+        assert G.has_edge("B", "C")
+        if G.is_directed():
+            assert not G.has_edge("C", "B")
+        else:
+            assert G.has_edge("C", "B")  # undirected
+
+        G.add_edges_from([("D", "F"), ("B", "D")])
+        assert G.has_edge("D", "F")
+        assert G.has_edge("B", "D")
+
+        if G.is_directed():
+            assert not G.has_edge("D", "B")
+        else:
+            assert G.has_edge("D", "B")  # undirected
+
+    def test_add_edges_from2(self):
+        G = self.G()
+        # after failing silently, should add 2nd edge
+        G.add_edges_from([tuple("IJ"), list("KK"), tuple("JK")])
+        assert G.has_edge(*("I", "J"))
+        assert G.has_edge(*("K", "K"))
+        assert G.has_edge(*("J", "K"))
+        if G.is_directed():
+            assert not G.has_edge(*("K", "J"))
+        else:
+            assert G.has_edge(*("K", "J"))
+
+    def test_add_edges_from3(self):
+        G = self.G()
+        G.add_edges_from(zip(list("ACD"), list("CDE")))
+        assert G.has_edge("D", "E")
+        assert not G.has_edge("E", "C")
+
+    def test_remove_edge(self):
+        G = self.G()
+        G.add_nodes_from([1, 2, 3, "A", "B", "C", "D", "E", "F", "G", "H"])
+
+        G.add_edges_from(zip(list("MNOP"), list("NOPM")))
+        assert G.has_edge("O", "P")
+        assert G.has_edge("P", "M")
+        G.remove_node("P")  # tests remove_node()'s handling of edges.
+        assert not G.has_edge("P", "M")
+        pytest.raises(TypeError, G.remove_edge, "M")
+
+        G.add_edge("N", "M")
+        assert G.has_edge("M", "N")
+        G.remove_edge("M", "N")
+        assert not G.has_edge("M", "N")
+
+        # self loop fails silently
+        G.remove_edges_from([list("HI"), list("DF"), tuple("KK"), tuple("JK")])
+        assert not G.has_edge("H", "I")
+        assert not G.has_edge("J", "K")
+        G.remove_edges_from([list("IJ"), list("KK"), list("JK")])
+        assert not G.has_edge("I", "J")
+        G.remove_nodes_from(set("ZEFHIMNO"))
+        G.add_edge("J", "K")
+
+    def test_edges_nbunch(self):
+        # Test G.edges(nbunch) with various forms of nbunch
+        G = self.G()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
+        # node not in nbunch should be quietly ignored
+        pytest.raises(nx.NetworkXError, G.edges, 6)
+        assert list(G.edges("Z")) == []  # iterable non-node
+        # nbunch can be an empty list
+        assert list(G.edges([])) == []
+        if G.is_directed():
+            elist = [("A", "B"), ("A", "C"), ("B", "D")]
+        else:
+            elist = [("A", "B"), ("A", "C"), ("B", "C"), ("B", "D")]
+        # nbunch can be a list
+        assert edges_equal(list(G.edges(["A", "B"])), elist)
+        # nbunch can be a set
+        assert edges_equal(G.edges({"A", "B"}), elist)
+        # nbunch can be a graph
+        G1 = self.G()
+        G1.add_nodes_from("AB")
+        assert edges_equal(G.edges(G1), elist)
+        # nbunch can be a dict with nodes as keys
+        ndict = {"A": "thing1", "B": "thing2"}
+        assert edges_equal(G.edges(ndict), elist)
+        # nbunch can be a single node
+        assert edges_equal(list(G.edges("A")), [("A", "B"), ("A", "C")])
+        assert nodes_equal(sorted(G), ["A", "B", "C", "D"])
+
+        # nbunch can be nothing (whole graph)
+        assert edges_equal(
+            list(G.edges()),
+            [("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")],
+        )
+
+    def test_degree(self):
+        G = self.G()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
+        assert G.degree("A") == 2
+
+        # degree of single node in iterable container must return dict
+        assert list(G.degree(["A"])) == [("A", 2)]
+        assert sorted(d for n, d in G.degree(["A", "B"])) == [2, 3]
+        assert sorted(d for n, d in G.degree()) == [2, 2, 3, 3]
+
+    def test_degree2(self):
+        H = self.G()
+        H.add_edges_from([(1, 24), (1, 2)])
+        assert sorted(d for n, d in H.degree([1, 24])) == [1, 2]
+
+    def test_degree_graph(self):
+        P3 = nx.path_graph(3)
+        P5 = nx.path_graph(5)
+        # silently ignore nodes not in P3
+        assert dict(d for n, d in P3.degree(["A", "B"])) == {}
+        # nbunch can be a graph
+        assert sorted(d for n, d in P5.degree(P3)) == [1, 2, 2]
+        # nbunch can be a graph that's way too big
+        assert sorted(d for n, d in P3.degree(P5)) == [1, 1, 2]
+        assert list(P5.degree([])) == []
+        assert dict(P5.degree([])) == {}
+
+    def test_null(self):
+        null = nx.null_graph()
+        assert list(null.degree()) == []
+        assert dict(null.degree()) == {}
+
+    def test_order_size(self):
+        G = self.G()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
+        assert G.order() == 4
+        assert G.size() == 5
+        assert G.number_of_edges() == 5
+        assert G.number_of_edges("A", "B") == 1
+        assert G.number_of_edges("A", "D") == 0
+
+    def test_copy(self):
+        G = self.G()
+        H = G.copy()  # copy
+        assert H.adj == G.adj
+        assert H.name == G.name
+        assert H is not G
+
+    def test_subgraph(self):
+        G = self.G()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
+        SG = G.subgraph(["A", "B", "D"])
+        assert nodes_equal(list(SG), ["A", "B", "D"])
+        assert edges_equal(list(SG.edges()), [("A", "B"), ("B", "D")])
+
+    def test_to_directed(self):
+        G = self.G()
+        if not G.is_directed():
+            G.add_edges_from(
+                [("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")]
+            )
+
+            DG = G.to_directed()
+            assert DG is not G  # directed copy or copy
+
+            assert DG.is_directed()
+            assert DG.name == G.name
+            assert DG.adj == G.adj
+            assert sorted(DG.out_edges(list("AB"))) == [
+                ("A", "B"),
+                ("A", "C"),
+                ("B", "A"),
+                ("B", "C"),
+                ("B", "D"),
+            ]
+            DG.remove_edge("A", "B")
+            assert DG.has_edge("B", "A")  # this removes B-A but not  A-B
+            assert not DG.has_edge("A", "B")
+
+    def test_to_undirected(self):
+        G = self.G()
+        if G.is_directed():
+            G.add_edges_from(
+                [("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")]
+            )
+            UG = G.to_undirected()  # to_undirected
+            assert UG is not G
+            assert not UG.is_directed()
+            assert G.is_directed()
+            assert UG.name == G.name
+            assert UG.adj != G.adj
+            assert sorted(UG.edges(list("AB"))) == [
+                ("A", "B"),
+                ("A", "C"),
+                ("B", "C"),
+                ("B", "D"),
+            ]
+            assert sorted(UG.edges(["A", "B"])) == [
+                ("A", "B"),
+                ("A", "C"),
+                ("B", "C"),
+                ("B", "D"),
+            ]
+            UG.remove_edge("A", "B")
+            assert not UG.has_edge("B", "A")
+            assert not UG.has_edge("A", "B")
+
+    def test_neighbors(self):
+        G = self.G()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
+        G.add_nodes_from("GJK")
+        assert sorted(G["A"]) == ["B", "C"]
+        assert sorted(G.neighbors("A")) == ["B", "C"]
+        assert sorted(G.neighbors("A")) == ["B", "C"]
+        assert sorted(G.neighbors("G")) == []
+        pytest.raises(nx.NetworkXError, G.neighbors, "j")
+
+    def test_iterators(self):
+        G = self.G()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
+        G.add_nodes_from("GJK")
+        assert sorted(G.nodes()) == ["A", "B", "C", "D", "G", "J", "K"]
+        assert edges_equal(
+            G.edges(), [("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")]
+        )
+
+        assert sorted(v for k, v in G.degree()) == [0, 0, 0, 2, 2, 3, 3]
+        assert sorted(G.degree(), key=str) == [
+            ("A", 2),
+            ("B", 3),
+            ("C", 3),
+            ("D", 2),
+            ("G", 0),
+            ("J", 0),
+            ("K", 0),
+        ]
+        assert sorted(G.neighbors("A")) == ["B", "C"]
+        pytest.raises(nx.NetworkXError, G.neighbors, "X")
+        G.clear()
+        assert nx.number_of_nodes(G) == 0
+        assert nx.number_of_edges(G) == 0
+
+    def test_null_subgraph(self):
+        # Subgraph of a null graph is a null graph
+        nullgraph = nx.null_graph()
+        G = nx.null_graph()
+        H = G.subgraph([])
+        assert nx.is_isomorphic(H, nullgraph)
+
+    def test_empty_subgraph(self):
+        # Subgraph of an empty graph is an empty graph. test 1
+        nullgraph = nx.null_graph()
+        E5 = nx.empty_graph(5)
+        E10 = nx.empty_graph(10)
+        H = E10.subgraph([])
+        assert nx.is_isomorphic(H, nullgraph)
+        H = E10.subgraph([1, 2, 3, 4, 5])
+        assert nx.is_isomorphic(H, E5)
+
+    def test_complete_subgraph(self):
+        # Subgraph of a complete graph is a complete graph
+        K1 = nx.complete_graph(1)
+        K3 = nx.complete_graph(3)
+        K5 = nx.complete_graph(5)
+        H = K5.subgraph([1, 2, 3])
+        assert nx.is_isomorphic(H, K3)
+
+    def test_subgraph_nbunch(self):
+        nullgraph = nx.null_graph()
+        K1 = nx.complete_graph(1)
+        K3 = nx.complete_graph(3)
+        K5 = nx.complete_graph(5)
+        # Test G.subgraph(nbunch), where nbunch is a single node
+        H = K5.subgraph(1)
+        assert nx.is_isomorphic(H, K1)
+        # Test G.subgraph(nbunch), where nbunch is a set
+        H = K5.subgraph({1})
+        assert nx.is_isomorphic(H, K1)
+        # Test G.subgraph(nbunch), where nbunch is an iterator
+        H = K5.subgraph(iter(K3))
+        assert nx.is_isomorphic(H, K3)
+        # Test G.subgraph(nbunch), where nbunch is another graph
+        H = K5.subgraph(K3)
+        assert nx.is_isomorphic(H, K3)
+        H = K5.subgraph([9])
+        assert nx.is_isomorphic(H, nullgraph)
+
+    def test_node_tuple_issue(self):
+        H = self.G()
+        # Test error handling of tuple as a node
+        pytest.raises(nx.NetworkXError, H.remove_node, (1, 2))
+        H.remove_nodes_from([(1, 2)])  # no error
+        pytest.raises(nx.NetworkXError, H.neighbors, (1, 2))
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_coreviews.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_coreviews.py
new file mode 100644
index 0000000..12572b4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_coreviews.py
@@ -0,0 +1,431 @@
+import pickle
+
+import pytest
+
+import networkx as nx
+
+
+class TestAtlasView:
+    # node->data
+    def setup(self):
+        self.d = {0: {"color": "blue", "weight": 1.2}, 1: {}, 2: {"color": 1}}
+        self.av = nx.classes.coreviews.AtlasView(self.d)
+
+    def test_pickle(self):
+        view = self.av
+        pview = pickle.loads(pickle.dumps(view, -1))
+        assert view == pview
+        assert view.__slots__ == pview.__slots__
+        pview = pickle.loads(pickle.dumps(view))
+        assert view == pview
+        assert view.__slots__ == pview.__slots__
+
+    def test_len(self):
+        assert len(self.av) == len(self.d)
+
+    def test_iter(self):
+        assert list(self.av) == list(self.d)
+
+    def test_getitem(self):
+        assert self.av[1] is self.d[1]
+        assert self.av[2]["color"] == 1
+        pytest.raises(KeyError, self.av.__getitem__, 3)
+
+    def test_copy(self):
+        avcopy = self.av.copy()
+        assert avcopy[0] == self.av[0]
+        assert avcopy == self.av
+        assert avcopy[0] is not self.av[0]
+        assert avcopy is not self.av
+        avcopy[5] = {}
+        assert avcopy != self.av
+
+        avcopy[0]["ht"] = 4
+        assert avcopy[0] != self.av[0]
+        self.av[0]["ht"] = 4
+        assert avcopy[0] == self.av[0]
+        del self.av[0]["ht"]
+
+        assert not hasattr(self.av, "__setitem__")
+
+    def test_items(self):
+        assert sorted(self.av.items()) == sorted(self.d.items())
+
+    def test_str(self):
+        out = str(self.d)
+        assert str(self.av) == out
+
+    def test_repr(self):
+        out = "AtlasView(" + str(self.d) + ")"
+        assert repr(self.av) == out
+
+
+class TestAdjacencyView:
+    # node->nbr->data
+    def setup(self):
+        dd = {"color": "blue", "weight": 1.2}
+        self.nd = {0: dd, 1: {}, 2: {"color": 1}}
+        self.adj = {3: self.nd, 0: {3: dd}, 1: {}, 2: {3: {"color": 1}}}
+        self.adjview = nx.classes.coreviews.AdjacencyView(self.adj)
+
+    def test_pickle(self):
+        view = self.adjview
+        pview = pickle.loads(pickle.dumps(view, -1))
+        assert view == pview
+        assert view.__slots__ == pview.__slots__
+
+    def test_len(self):
+        assert len(self.adjview) == len(self.adj)
+
+    def test_iter(self):
+        assert list(self.adjview) == list(self.adj)
+
+    def test_getitem(self):
+        assert self.adjview[1] is not self.adj[1]
+        assert self.adjview[3][0] is self.adjview[0][3]
+        assert self.adjview[2][3]["color"] == 1
+        pytest.raises(KeyError, self.adjview.__getitem__, 4)
+
+    def test_copy(self):
+        avcopy = self.adjview.copy()
+        assert avcopy[0] == self.adjview[0]
+        assert avcopy[0] is not self.adjview[0]
+
+        avcopy[2][3]["ht"] = 4
+        assert avcopy[2] != self.adjview[2]
+        self.adjview[2][3]["ht"] = 4
+        assert avcopy[2] == self.adjview[2]
+        del self.adjview[2][3]["ht"]
+
+        assert not hasattr(self.adjview, "__setitem__")
+
+    def test_items(self):
+        view_items = sorted((n, dict(d)) for n, d in self.adjview.items())
+        assert view_items == sorted(self.adj.items())
+
+    def test_str(self):
+        out = str(dict(self.adj))
+        assert str(self.adjview) == out
+
+    def test_repr(self):
+        out = self.adjview.__class__.__name__ + "(" + str(self.adj) + ")"
+        assert repr(self.adjview) == out
+
+
+class TestMultiAdjacencyView(TestAdjacencyView):
+    # node->nbr->key->data
+    def setup(self):
+        dd = {"color": "blue", "weight": 1.2}
+        self.kd = {0: dd, 1: {}, 2: {"color": 1}}
+        self.nd = {3: self.kd, 0: {3: dd}, 1: {0: {}}, 2: {3: {"color": 1}}}
+        self.adj = {3: self.nd, 0: {3: {3: dd}}, 1: {}, 2: {3: {8: {}}}}
+        self.adjview = nx.classes.coreviews.MultiAdjacencyView(self.adj)
+
+    def test_getitem(self):
+        assert self.adjview[1] is not self.adj[1]
+        assert self.adjview[3][0][3] is self.adjview[0][3][3]
+        assert self.adjview[3][2][3]["color"] == 1
+        pytest.raises(KeyError, self.adjview.__getitem__, 4)
+
+    def test_copy(self):
+        avcopy = self.adjview.copy()
+        assert avcopy[0] == self.adjview[0]
+        assert avcopy[0] is not self.adjview[0]
+
+        avcopy[2][3][8]["ht"] = 4
+        assert avcopy[2] != self.adjview[2]
+        self.adjview[2][3][8]["ht"] = 4
+        assert avcopy[2] == self.adjview[2]
+        del self.adjview[2][3][8]["ht"]
+
+        assert not hasattr(self.adjview, "__setitem__")
+
+
+class TestUnionAtlas:
+    # node->data
+    def setup(self):
+        self.s = {0: {"color": "blue", "weight": 1.2}, 1: {}, 2: {"color": 1}}
+        self.p = {3: {"color": "blue", "weight": 1.2}, 4: {}, 2: {"watch": 2}}
+        self.av = nx.classes.coreviews.UnionAtlas(self.s, self.p)
+
+    def test_pickle(self):
+        view = self.av
+        pview = pickle.loads(pickle.dumps(view, -1))
+        assert view == pview
+        assert view.__slots__ == pview.__slots__
+
+    def test_len(self):
+        assert len(self.av) == len(self.s) + len(self.p)
+
+    def test_iter(self):
+        assert set(self.av) == set(self.s) | set(self.p)
+
+    def test_getitem(self):
+        assert self.av[0] is self.s[0]
+        assert self.av[4] is self.p[4]
+        assert self.av[2]["color"] == 1
+        pytest.raises(KeyError, self.av[2].__getitem__, "watch")
+        pytest.raises(KeyError, self.av.__getitem__, 8)
+
+    def test_copy(self):
+        avcopy = self.av.copy()
+        assert avcopy[0] == self.av[0]
+        assert avcopy[0] is not self.av[0]
+        assert avcopy is not self.av
+        avcopy[5] = {}
+        assert avcopy != self.av
+
+        avcopy[0]["ht"] = 4
+        assert avcopy[0] != self.av[0]
+        self.av[0]["ht"] = 4
+        assert avcopy[0] == self.av[0]
+        del self.av[0]["ht"]
+
+        assert not hasattr(self.av, "__setitem__")
+
+    def test_items(self):
+        expected = dict(self.p.items())
+        expected.update(self.s)
+        assert sorted(self.av.items()) == sorted(expected.items())
+
+    def test_str(self):
+        out = str(dict(self.av))
+        assert str(self.av) == out
+
+    def test_repr(self):
+        out = f"{self.av.__class__.__name__}({self.s}, {self.p})"
+        assert repr(self.av) == out
+
+
+class TestUnionAdjacency:
+    # node->nbr->data
+    def setup(self):
+        dd = {"color": "blue", "weight": 1.2}
+        self.nd = {0: dd, 1: {}, 2: {"color": 1}}
+        self.s = {3: self.nd, 0: {}, 1: {}, 2: {3: {"color": 1}}}
+        self.p = {3: {}, 0: {3: dd}, 1: {0: {}}, 2: {1: {"color": 1}}}
+        self.adjview = nx.classes.coreviews.UnionAdjacency(self.s, self.p)
+
+    def test_pickle(self):
+        view = self.adjview
+        pview = pickle.loads(pickle.dumps(view, -1))
+        assert view == pview
+        assert view.__slots__ == pview.__slots__
+
+    def test_len(self):
+        assert len(self.adjview) == len(self.s)
+
+    def test_iter(self):
+        assert sorted(self.adjview) == sorted(self.s)
+
+    def test_getitem(self):
+        assert self.adjview[1] is not self.s[1]
+        assert self.adjview[3][0] is self.adjview[0][3]
+        assert self.adjview[2][3]["color"] == 1
+        pytest.raises(KeyError, self.adjview.__getitem__, 4)
+
+    def test_copy(self):
+        avcopy = self.adjview.copy()
+        assert avcopy[0] == self.adjview[0]
+        assert avcopy[0] is not self.adjview[0]
+
+        avcopy[2][3]["ht"] = 4
+        assert avcopy[2] != self.adjview[2]
+        self.adjview[2][3]["ht"] = 4
+        assert avcopy[2] == self.adjview[2]
+        del self.adjview[2][3]["ht"]
+
+        assert not hasattr(self.adjview, "__setitem__")
+
+    def test_str(self):
+        out = str(dict(self.adjview))
+        assert str(self.adjview) == out
+
+    def test_repr(self):
+        clsname = self.adjview.__class__.__name__
+        out = f"{clsname}({self.s}, {self.p})"
+        assert repr(self.adjview) == out
+
+
+class TestUnionMultiInner(TestUnionAdjacency):
+    # nbr->key->data
+    def setup(self):
+        dd = {"color": "blue", "weight": 1.2}
+        self.kd = {7: {}, "ekey": {}, 9: {"color": 1}}
+        self.s = {3: self.kd, 0: {7: dd}, 1: {}, 2: {"key": {"color": 1}}}
+        self.p = {3: {}, 0: {3: dd}, 1: {}, 2: {1: {"span": 2}}}
+        self.adjview = nx.classes.coreviews.UnionMultiInner(self.s, self.p)
+
+    def test_len(self):
+        assert len(self.adjview) == len(self.s) + len(self.p)
+
+    def test_getitem(self):
+        assert self.adjview[1] is not self.s[1]
+        assert self.adjview[0][7] is self.adjview[0][3]
+        assert self.adjview[2]["key"]["color"] == 1
+        assert self.adjview[2][1]["span"] == 2
+        pytest.raises(KeyError, self.adjview.__getitem__, 4)
+        pytest.raises(KeyError, self.adjview[1].__getitem__, "key")
+
+    def test_copy(self):
+        avcopy = self.adjview.copy()
+        assert avcopy[0] == self.adjview[0]
+        assert avcopy[0] is not self.adjview[0]
+
+        avcopy[2][1]["width"] = 8
+        assert avcopy[2] != self.adjview[2]
+        self.adjview[2][1]["width"] = 8
+        assert avcopy[2] == self.adjview[2]
+        del self.adjview[2][1]["width"]
+
+        assert not hasattr(self.adjview, "__setitem__")
+        assert hasattr(avcopy, "__setitem__")
+
+
+class TestUnionMultiAdjacency(TestUnionAdjacency):
+    # node->nbr->key->data
+    def setup(self):
+        dd = {"color": "blue", "weight": 1.2}
+        self.kd = {7: {}, 8: {}, 9: {"color": 1}}
+        self.nd = {3: self.kd, 0: {9: dd}, 1: {8: {}}, 2: {9: {"color": 1}}}
+        self.s = {3: self.nd, 0: {3: {7: dd}}, 1: {}, 2: {3: {8: {}}}}
+        self.p = {3: {}, 0: {3: {9: dd}}, 1: {}, 2: {1: {8: {}}}}
+        self.adjview = nx.classes.coreviews.UnionMultiAdjacency(self.s, self.p)
+
+    def test_getitem(self):
+        assert self.adjview[1] is not self.s[1]
+        assert self.adjview[3][0][9] is self.adjview[0][3][9]
+        assert self.adjview[3][2][9]["color"] == 1
+        pytest.raises(KeyError, self.adjview.__getitem__, 4)
+
+    def test_copy(self):
+        avcopy = self.adjview.copy()
+        assert avcopy[0] == self.adjview[0]
+        assert avcopy[0] is not self.adjview[0]
+
+        avcopy[2][3][8]["ht"] = 4
+        assert avcopy[2] != self.adjview[2]
+        self.adjview[2][3][8]["ht"] = 4
+        assert avcopy[2] == self.adjview[2]
+        del self.adjview[2][3][8]["ht"]
+
+        assert not hasattr(self.adjview, "__setitem__")
+        assert hasattr(avcopy, "__setitem__")
+
+
+class TestFilteredGraphs:
+    def setup(self):
+        self.Graphs = [nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph]
+
+    def test_hide_show_nodes(self):
+        SubGraph = nx.graphviews.subgraph_view
+        for Graph in self.Graphs:
+            G = nx.path_graph(4, Graph)
+            SG = G.subgraph([2, 3])
+            RG = SubGraph(G, nx.filters.hide_nodes([0, 1]))
+            assert SG.nodes == RG.nodes
+            assert SG.edges == RG.edges
+            SGC = SG.copy()
+            RGC = RG.copy()
+            assert SGC.nodes == RGC.nodes
+            assert SGC.edges == RGC.edges
+
+    def test_str_repr(self):
+        SubGraph = nx.graphviews.subgraph_view
+        for Graph in self.Graphs:
+            G = nx.path_graph(4, Graph)
+            SG = G.subgraph([2, 3])
+            RG = SubGraph(G, nx.filters.hide_nodes([0, 1]))
+            str(SG.adj)
+            str(RG.adj)
+            repr(SG.adj)
+            repr(RG.adj)
+            str(SG.adj[2])
+            str(RG.adj[2])
+            repr(SG.adj[2])
+            repr(RG.adj[2])
+
+    def test_copy(self):
+        SubGraph = nx.graphviews.subgraph_view
+        for Graph in self.Graphs:
+            G = nx.path_graph(4, Graph)
+            SG = G.subgraph([2, 3])
+            RG = SubGraph(G, nx.filters.hide_nodes([0, 1]))
+            RsG = SubGraph(G, nx.filters.show_nodes([2, 3]))
+            assert G.adj.copy() == G.adj
+            assert G.adj[2].copy() == G.adj[2]
+            assert SG.adj.copy() == SG.adj
+            assert SG.adj[2].copy() == SG.adj[2]
+            assert RG.adj.copy() == RG.adj
+            assert RG.adj[2].copy() == RG.adj[2]
+            assert RsG.adj.copy() == RsG.adj
+            assert RsG.adj[2].copy() == RsG.adj[2]
+
+    def test_filtered_copy(self):
+        # TODO: This function can be removed when filtered.copy()
+        # deprecation expires
+        SubGraph = nx.graphviews.subgraph_view
+        for Graph in self.Graphs:
+            G = nx.path_graph(4, Graph)
+            SG = G.subgraph([2, 3])
+            RG = SubGraph(G, nx.filters.hide_nodes([0, 1]))
+            RsG = SubGraph(G, nx.filters.show_nodes([2, 3]))
+            # test FilterAtlas & co in these subgraphs
+            assert SG._node.copy() == SG._node
+            assert SG.adj._atlas.copy() == SG.adj._atlas
+            assert SG.adj[2]._atlas.copy() == SG.adj[2]._atlas
+            assert SG.adj[2]._atlas[3].copy() == SG.adj[2]._atlas[3]
+            assert RG.adj._atlas.copy() == RG.adj._atlas
+            assert RG.adj[2]._atlas.copy() == RG.adj[2]._atlas
+            assert RG.adj[2]._atlas[3].copy() == RG.adj[2]._atlas[3]
+            assert RG._node.copy() == RG._node
+            assert RsG.adj._atlas.copy() == RsG.adj._atlas
+            assert RsG.adj[2]._atlas.copy() == RsG.adj[2]._atlas
+            assert RsG.adj[2]._atlas[3].copy() == RsG.adj[2]._atlas[3]
+            assert RsG._node.copy() == RsG._node
+            # test MultiFilterInner
+            if G.is_multigraph():
+                assert SG.adj[2]._atlas[3][0].copy() == SG.adj[2]._atlas[3][0]
+                assert RG.adj[2]._atlas[3][0].copy() == RG.adj[2]._atlas[3][0]
+                assert RsG.adj[2]._atlas[3][0].copy() == RsG.adj[2]._atlas[3][0]
+
+            # test deprecation
+            # FilterAtlas.copy()
+            pytest.deprecated_call(SG._node.copy)
+            # FilterAdjacency.copy()
+            pytest.deprecated_call(SG.adj._atlas.copy)
+            # FilterMultiAdjacency.copy()
+            if G.is_multigraph():
+                pytest.deprecated_call(SG.adj._atlas.copy)
+            # FilterMultiInner.copy()
+            if G.is_multigraph():
+                pytest.deprecated_call(SG.adj[2]._atlas.copy)
+
+            SSG = SG.subgraph([2])
+            assert list(SSG) == [2]
+
+            # check case when node_ok is small
+            G = nx.complete_graph(9, Graph)
+            SG = G.subgraph([2, 3])
+            RG = SubGraph(G, nx.filters.hide_nodes([0, 1]))
+            RsG = SubGraph(G, nx.filters.show_nodes([2, 3, 4, 5, 6, 7, 8]))
+            assert SG.adj._atlas.copy() == SG.adj._atlas
+            assert SG.adj[2]._atlas.copy() == SG.adj[2]._atlas
+            assert SG.adj[2]._atlas[3].copy() == SG.adj[2]._atlas[3]
+            assert SG._node.copy() == SG._node
+            assert RG.adj._atlas.copy() == RG.adj._atlas
+            assert RG.adj[2]._atlas.copy() == RG.adj[2]._atlas
+            assert RG.adj[2]._atlas[3].copy() == RG.adj[2]._atlas[3]
+            assert RG._node.copy() == RG._node
+            assert RsG.adj._atlas.copy() == RsG.adj._atlas
+            assert RsG.adj[2]._atlas.copy() == RsG.adj[2]._atlas
+            assert RsG.adj[2]._atlas[3].copy() == RsG.adj[2]._atlas[3]
+            assert RsG._node.copy() == RsG._node
+            # test MultiFilterInner
+            if G.is_multigraph():
+                assert SG.adj[2][3]._atlas.copy() == SG.adj[2][3]._atlas
+                assert RG.adj[2][3]._atlas.copy() == RG.adj[2][3]._atlas
+                assert RsG.adj[2][3]._atlas.copy() == RsG.adj[2][3]._atlas
+
+            SSG = SG.subgraph([2])
+            assert list(SSG) == [2]
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_digraph.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_digraph.py
new file mode 100644
index 0000000..c8e8655
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_digraph.py
@@ -0,0 +1,327 @@
+import pytest
+
+import networkx as nx
+from networkx.utils import nodes_equal
+
+from .test_graph import BaseAttrGraphTester, BaseGraphTester
+from .test_graph import TestEdgeSubgraph as _TestGraphEdgeSubgraph
+from .test_graph import TestGraph as _TestGraph
+
+
+class BaseDiGraphTester(BaseGraphTester):
+    def test_has_successor(self):
+        G = self.K3
+        assert G.has_successor(0, 1)
+        assert not G.has_successor(0, -1)
+
+    def test_successors(self):
+        G = self.K3
+        assert sorted(G.successors(0)) == [1, 2]
+        with pytest.raises(nx.NetworkXError):
+            G.successors(-1)
+
+    def test_has_predecessor(self):
+        G = self.K3
+        assert G.has_predecessor(0, 1)
+        assert not G.has_predecessor(0, -1)
+
+    def test_predecessors(self):
+        G = self.K3
+        assert sorted(G.predecessors(0)) == [1, 2]
+        with pytest.raises(nx.NetworkXError):
+            G.predecessors(-1)
+
+    def test_edges(self):
+        G = self.K3
+        assert sorted(G.edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
+        assert sorted(G.edges(0)) == [(0, 1), (0, 2)]
+        assert sorted(G.edges([0, 1])) == [(0, 1), (0, 2), (1, 0), (1, 2)]
+        with pytest.raises(nx.NetworkXError):
+            G.edges(-1)
+
+    def test_out_edges(self):
+        G = self.K3
+        assert sorted(G.out_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
+        assert sorted(G.out_edges(0)) == [(0, 1), (0, 2)]
+        with pytest.raises(nx.NetworkXError):
+            G.out_edges(-1)
+
+    def test_out_edges_dir(self):
+        G = self.P3
+        assert sorted(G.out_edges()) == [(0, 1), (1, 2)]
+        assert sorted(G.out_edges(0)) == [(0, 1)]
+        assert sorted(G.out_edges(2)) == []
+
+    def test_out_edges_data(self):
+        G = nx.DiGraph([(0, 1, {"data": 0}), (1, 0, {})])
+        assert sorted(G.out_edges(data=True)) == [(0, 1, {"data": 0}), (1, 0, {})]
+        assert sorted(G.out_edges(0, data=True)) == [(0, 1, {"data": 0})]
+        assert sorted(G.out_edges(data="data")) == [(0, 1, 0), (1, 0, None)]
+        assert sorted(G.out_edges(0, data="data")) == [(0, 1, 0)]
+
+    def test_in_edges_dir(self):
+        G = self.P3
+        assert sorted(G.in_edges()) == [(0, 1), (1, 2)]
+        assert sorted(G.in_edges(0)) == []
+        assert sorted(G.in_edges(2)) == [(1, 2)]
+
+    def test_in_edges_data(self):
+        G = nx.DiGraph([(0, 1, {"data": 0}), (1, 0, {})])
+        assert sorted(G.in_edges(data=True)) == [(0, 1, {"data": 0}), (1, 0, {})]
+        assert sorted(G.in_edges(1, data=True)) == [(0, 1, {"data": 0})]
+        assert sorted(G.in_edges(data="data")) == [(0, 1, 0), (1, 0, None)]
+        assert sorted(G.in_edges(1, data="data")) == [(0, 1, 0)]
+
+    def test_degree(self):
+        G = self.K3
+        assert sorted(G.degree()) == [(0, 4), (1, 4), (2, 4)]
+        assert dict(G.degree()) == {0: 4, 1: 4, 2: 4}
+        assert G.degree(0) == 4
+        assert list(G.degree(iter([0]))) == [(0, 4)]  # run through iterator
+
+    def test_in_degree(self):
+        G = self.K3
+        assert sorted(G.in_degree()) == [(0, 2), (1, 2), (2, 2)]
+        assert dict(G.in_degree()) == {0: 2, 1: 2, 2: 2}
+        assert G.in_degree(0) == 2
+        assert list(G.in_degree(iter([0]))) == [(0, 2)]  # run through iterator
+
+    def test_out_degree(self):
+        G = self.K3
+        assert sorted(G.out_degree()) == [(0, 2), (1, 2), (2, 2)]
+        assert dict(G.out_degree()) == {0: 2, 1: 2, 2: 2}
+        assert G.out_degree(0) == 2
+        assert list(G.out_degree(iter([0]))) == [(0, 2)]
+
+    def test_size(self):
+        G = self.K3
+        assert G.size() == 6
+        assert G.number_of_edges() == 6
+
+    def test_to_undirected_reciprocal(self):
+        G = self.Graph()
+        G.add_edge(1, 2)
+        assert G.to_undirected().has_edge(1, 2)
+        assert not G.to_undirected(reciprocal=True).has_edge(1, 2)
+        G.add_edge(2, 1)
+        assert G.to_undirected(reciprocal=True).has_edge(1, 2)
+
+    def test_reverse_copy(self):
+        G = nx.DiGraph([(0, 1), (1, 2)])
+        R = G.reverse()
+        assert sorted(R.edges()) == [(1, 0), (2, 1)]
+        R.remove_edge(1, 0)
+        assert sorted(R.edges()) == [(2, 1)]
+        assert sorted(G.edges()) == [(0, 1), (1, 2)]
+
+    def test_reverse_nocopy(self):
+        G = nx.DiGraph([(0, 1), (1, 2)])
+        R = G.reverse(copy=False)
+        assert sorted(R.edges()) == [(1, 0), (2, 1)]
+        with pytest.raises(nx.NetworkXError):
+            R.remove_edge(1, 0)
+
+    def test_reverse_hashable(self):
+        class Foo:
+            pass
+
+        x = Foo()
+        y = Foo()
+        G = nx.DiGraph()
+        G.add_edge(x, y)
+        assert nodes_equal(G.nodes(), G.reverse().nodes())
+        assert [(y, x)] == list(G.reverse().edges())
+
+    def test_di_cache_reset(self):
+        G = self.K3.copy()
+        old_succ = G.succ
+        assert id(G.succ) == id(old_succ)
+        old_adj = G.adj
+        assert id(G.adj) == id(old_adj)
+
+        G._succ = {}
+        assert id(G.succ) != id(old_succ)
+        assert id(G.adj) != id(old_adj)
+
+        old_pred = G.pred
+        assert id(G.pred) == id(old_pred)
+        G._pred = {}
+        assert id(G.pred) != id(old_pred)
+
+    def test_di_attributes_cached(self):
+        G = self.K3.copy()
+        assert id(G.in_edges) == id(G.in_edges)
+        assert id(G.out_edges) == id(G.out_edges)
+        assert id(G.in_degree) == id(G.in_degree)
+        assert id(G.out_degree) == id(G.out_degree)
+        assert id(G.succ) == id(G.succ)
+        assert id(G.pred) == id(G.pred)
+
+
+class BaseAttrDiGraphTester(BaseDiGraphTester, BaseAttrGraphTester):
+    def test_edges_data(self):
+        G = self.K3
+        all_edges = [
+            (0, 1, {}),
+            (0, 2, {}),
+            (1, 0, {}),
+            (1, 2, {}),
+            (2, 0, {}),
+            (2, 1, {}),
+        ]
+        assert sorted(G.edges(data=True)) == all_edges
+        assert sorted(G.edges(0, data=True)) == all_edges[:2]
+        assert sorted(G.edges([0, 1], data=True)) == all_edges[:4]
+        with pytest.raises(nx.NetworkXError):
+            G.edges(-1, True)
+
+    def test_in_degree_weighted(self):
+        G = self.K3.copy()
+        G.add_edge(0, 1, weight=0.3, other=1.2)
+        assert sorted(G.in_degree(weight="weight")) == [(0, 2), (1, 1.3), (2, 2)]
+        assert dict(G.in_degree(weight="weight")) == {0: 2, 1: 1.3, 2: 2}
+        assert G.in_degree(1, weight="weight") == 1.3
+        assert sorted(G.in_degree(weight="other")) == [(0, 2), (1, 2.2), (2, 2)]
+        assert dict(G.in_degree(weight="other")) == {0: 2, 1: 2.2, 2: 2}
+        assert G.in_degree(1, weight="other") == 2.2
+        assert list(G.in_degree(iter([1]), weight="other")) == [(1, 2.2)]
+
+    def test_out_degree_weighted(self):
+        G = self.K3.copy()
+        G.add_edge(0, 1, weight=0.3, other=1.2)
+        assert sorted(G.out_degree(weight="weight")) == [(0, 1.3), (1, 2), (2, 2)]
+        assert dict(G.out_degree(weight="weight")) == {0: 1.3, 1: 2, 2: 2}
+        assert G.out_degree(0, weight="weight") == 1.3
+        assert sorted(G.out_degree(weight="other")) == [(0, 2.2), (1, 2), (2, 2)]
+        assert dict(G.out_degree(weight="other")) == {0: 2.2, 1: 2, 2: 2}
+        assert G.out_degree(0, weight="other") == 2.2
+        assert list(G.out_degree(iter([0]), weight="other")) == [(0, 2.2)]
+
+
+class TestDiGraph(BaseAttrDiGraphTester, _TestGraph):
+    """Tests specific to dict-of-dict-of-dict digraph data structure"""
+
+    def setup_method(self):
+        self.Graph = nx.DiGraph
+        # build dict-of-dict-of-dict K3
+        ed1, ed2, ed3, ed4, ed5, ed6 = ({}, {}, {}, {}, {}, {})
+        self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed3, 2: ed4}, 2: {0: ed5, 1: ed6}}
+        self.k3edges = [(0, 1), (0, 2), (1, 2)]
+        self.k3nodes = [0, 1, 2]
+        self.K3 = self.Graph()
+        self.K3._succ = self.k3adj  # K3._adj is synced with K3._succ
+        self.K3._pred = {0: {1: ed3, 2: ed5}, 1: {0: ed1, 2: ed6}, 2: {0: ed2, 1: ed4}}
+        self.K3._node = {}
+        self.K3._node[0] = {}
+        self.K3._node[1] = {}
+        self.K3._node[2] = {}
+
+        ed1, ed2 = ({}, {})
+        self.P3 = self.Graph()
+        self.P3._succ = {0: {1: ed1}, 1: {2: ed2}, 2: {}}
+        self.P3._pred = {0: {}, 1: {0: ed1}, 2: {1: ed2}}
+        # P3._adj is synced with P3._succ
+        self.P3._node = {}
+        self.P3._node[0] = {}
+        self.P3._node[1] = {}
+        self.P3._node[2] = {}
+
+    def test_data_input(self):
+        G = self.Graph({1: [2], 2: [1]}, name="test")
+        assert G.name == "test"
+        assert sorted(G.adj.items()) == [(1, {2: {}}), (2, {1: {}})]
+        assert sorted(G.succ.items()) == [(1, {2: {}}), (2, {1: {}})]
+        assert sorted(G.pred.items()) == [(1, {2: {}}), (2, {1: {}})]
+
+    def test_add_edge(self):
+        G = self.Graph()
+        G.add_edge(0, 1)
+        assert G.adj == {0: {1: {}}, 1: {}}
+        assert G.succ == {0: {1: {}}, 1: {}}
+        assert G.pred == {0: {}, 1: {0: {}}}
+        G = self.Graph()
+        G.add_edge(*(0, 1))
+        assert G.adj == {0: {1: {}}, 1: {}}
+        assert G.succ == {0: {1: {}}, 1: {}}
+        assert G.pred == {0: {}, 1: {0: {}}}
+
+    def test_add_edges_from(self):
+        G = self.Graph()
+        G.add_edges_from([(0, 1), (0, 2, {"data": 3})], data=2)
+        assert G.adj == {0: {1: {"data": 2}, 2: {"data": 3}}, 1: {}, 2: {}}
+        assert G.succ == {0: {1: {"data": 2}, 2: {"data": 3}}, 1: {}, 2: {}}
+        assert G.pred == {0: {}, 1: {0: {"data": 2}}, 2: {0: {"data": 3}}}
+
+        with pytest.raises(nx.NetworkXError):
+            G.add_edges_from([(0,)])  # too few in tuple
+        with pytest.raises(nx.NetworkXError):
+            G.add_edges_from([(0, 1, 2, 3)])  # too many in tuple
+        with pytest.raises(TypeError):
+            G.add_edges_from([0])  # not a tuple
+
+    def test_remove_edge(self):
+        G = self.K3.copy()
+        G.remove_edge(0, 1)
+        assert G.succ == {0: {2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}}
+        assert G.pred == {0: {1: {}, 2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}}
+        with pytest.raises(nx.NetworkXError):
+            G.remove_edge(-1, 0)
+
+    def test_remove_edges_from(self):
+        G = self.K3.copy()
+        G.remove_edges_from([(0, 1)])
+        assert G.succ == {0: {2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}}
+        assert G.pred == {0: {1: {}, 2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}}
+        G.remove_edges_from([(0, 0)])  # silent fail
+
+    def test_clear(self):
+        G = self.K3
+        G.graph["name"] = "K3"
+        G.clear()
+        assert list(G.nodes) == []
+        assert G.succ == {}
+        assert G.pred == {}
+        assert G.graph == {}
+
+    def test_clear_edges(self):
+        G = self.K3
+        G.graph["name"] = "K3"
+        nodes = list(G.nodes)
+        G.clear_edges()
+        assert list(G.nodes) == nodes
+        expected = {0: {}, 1: {}, 2: {}}
+        assert G.succ == expected
+        assert G.pred == expected
+        assert list(G.edges) == []
+        assert G.graph["name"] == "K3"
+
+
+class TestEdgeSubgraph(_TestGraphEdgeSubgraph):
+    """Unit tests for the :meth:`DiGraph.edge_subgraph` method."""
+
+    def setup_method(self):
+        # Create a doubly-linked path graph on five nodes.
+        G = nx.DiGraph(nx.path_graph(5))
+        # Add some node, edge, and graph attributes.
+        for i in range(5):
+            G.nodes[i]["name"] = f"node{i}"
+        G.edges[0, 1]["name"] = "edge01"
+        G.edges[3, 4]["name"] = "edge34"
+        G.graph["name"] = "graph"
+        # Get the subgraph induced by the first and last edges.
+        self.G = G
+        self.H = G.edge_subgraph([(0, 1), (3, 4)])
+
+    def test_pred_succ(self):
+        """Test that nodes are added to predecessors and successors.
+
+        For more information, see GitHub issue #2370.
+
+        """
+        G = nx.DiGraph()
+        G.add_edge(0, 1)
+        H = G.edge_subgraph([(0, 1)])
+        assert list(H.predecessors(0)) == []
+        assert list(H.successors(0)) == [1]
+        assert list(H.predecessors(1)) == [0]
+        assert list(H.successors(1)) == []
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_digraph_historical.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_digraph_historical.py
new file mode 100644
index 0000000..6bcd1e1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_digraph_historical.py
@@ -0,0 +1,110 @@
+"""Original NetworkX graph tests"""
+import pytest
+
+import networkx
+import networkx as nx
+
+from .historical_tests import HistoricalTests
+
+
+class TestDiGraphHistorical(HistoricalTests):
+    @classmethod
+    def setup_class(cls):
+        HistoricalTests.setup_class()
+        cls.G = nx.DiGraph
+
+    def test_in_degree(self):
+        G = self.G()
+        G.add_nodes_from("GJK")
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("B", "C"), ("C", "D")])
+
+        assert sorted(d for n, d in G.in_degree()) == [0, 0, 0, 0, 1, 2, 2]
+        assert dict(G.in_degree()) == {
+            "A": 0,
+            "C": 2,
+            "B": 1,
+            "D": 2,
+            "G": 0,
+            "K": 0,
+            "J": 0,
+        }
+
+    def test_out_degree(self):
+        G = self.G()
+        G.add_nodes_from("GJK")
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("B", "C"), ("C", "D")])
+        assert sorted(v for k, v in G.in_degree()) == [0, 0, 0, 0, 1, 2, 2]
+        assert dict(G.out_degree()) == {
+            "A": 2,
+            "C": 1,
+            "B": 2,
+            "D": 0,
+            "G": 0,
+            "K": 0,
+            "J": 0,
+        }
+
+    def test_degree_digraph(self):
+        H = nx.DiGraph()
+        H.add_edges_from([(1, 24), (1, 2)])
+        assert sorted(d for n, d in H.in_degree([1, 24])) == [0, 1]
+        assert sorted(d for n, d in H.out_degree([1, 24])) == [0, 2]
+        assert sorted(d for n, d in H.degree([1, 24])) == [1, 2]
+
+    def test_neighbors(self):
+        G = self.G()
+        G.add_nodes_from("GJK")
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("B", "C"), ("C", "D")])
+
+        assert sorted(G.neighbors("C")) == ["D"]
+        assert sorted(G["C"]) == ["D"]
+        assert sorted(G.neighbors("A")) == ["B", "C"]
+        pytest.raises(nx.NetworkXError, G.neighbors, "j")
+        pytest.raises(nx.NetworkXError, G.neighbors, "j")
+
+    def test_successors(self):
+        G = self.G()
+        G.add_nodes_from("GJK")
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("B", "C"), ("C", "D")])
+        assert sorted(G.successors("A")) == ["B", "C"]
+        assert sorted(G.successors("A")) == ["B", "C"]
+        assert sorted(G.successors("G")) == []
+        assert sorted(G.successors("D")) == []
+        assert sorted(G.successors("G")) == []
+        pytest.raises(nx.NetworkXError, G.successors, "j")
+        pytest.raises(nx.NetworkXError, G.successors, "j")
+
+    def test_predecessors(self):
+        G = self.G()
+        G.add_nodes_from("GJK")
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("B", "C"), ("C", "D")])
+        assert sorted(G.predecessors("C")) == ["A", "B"]
+        assert sorted(G.predecessors("C")) == ["A", "B"]
+        assert sorted(G.predecessors("G")) == []
+        assert sorted(G.predecessors("A")) == []
+        assert sorted(G.predecessors("G")) == []
+        assert sorted(G.predecessors("A")) == []
+        assert sorted(G.successors("D")) == []
+
+        pytest.raises(nx.NetworkXError, G.predecessors, "j")
+        pytest.raises(nx.NetworkXError, G.predecessors, "j")
+
+    def test_reverse(self):
+        G = nx.complete_graph(10)
+        H = G.to_directed()
+        HR = H.reverse()
+        assert nx.is_isomorphic(H, HR)
+        assert sorted(H.edges()) == sorted(HR.edges())
+
+    def test_reverse2(self):
+        H = nx.DiGraph()
+        foo = [H.add_edge(u, u + 1) for u in range(0, 5)]
+        HR = H.reverse()
+        for u in range(0, 5):
+            assert HR.has_edge(u + 1, u)
+
+    def test_reverse3(self):
+        H = nx.DiGraph()
+        H.add_nodes_from([1, 2, 3, 4])
+        HR = H.reverse()
+        assert sorted(HR.nodes()) == [1, 2, 3, 4]
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_filters.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_filters.py
new file mode 100644
index 0000000..2da5911
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_filters.py
@@ -0,0 +1,177 @@
+import pytest
+
+import networkx as nx
+
+
+class TestFilterFactory:
+    def test_no_filter(self):
+        nf = nx.filters.no_filter
+        assert nf()
+        assert nf(1)
+        assert nf(2, 1)
+
+    def test_hide_nodes(self):
+        f = nx.classes.filters.hide_nodes([1, 2, 3])
+        assert not f(1)
+        assert not f(2)
+        assert not f(3)
+        assert f(4)
+        assert f(0)
+        assert f("a")
+        pytest.raises(TypeError, f, 1, 2)
+        pytest.raises(TypeError, f)
+
+    def test_show_nodes(self):
+        f = nx.classes.filters.show_nodes([1, 2, 3])
+        assert f(1)
+        assert f(2)
+        assert f(3)
+        assert not f(4)
+        assert not f(0)
+        assert not f("a")
+        pytest.raises(TypeError, f, 1, 2)
+        pytest.raises(TypeError, f)
+
+    def test_hide_edges(self):
+        factory = nx.classes.filters.hide_edges
+        f = factory([(1, 2), (3, 4)])
+        assert not f(1, 2)
+        assert not f(3, 4)
+        assert not f(4, 3)
+        assert f(2, 3)
+        assert f(0, -1)
+        assert f("a", "b")
+        pytest.raises(TypeError, f, 1, 2, 3)
+        pytest.raises(TypeError, f, 1)
+        pytest.raises(TypeError, f)
+        pytest.raises(TypeError, factory, [1, 2, 3])
+        pytest.raises(ValueError, factory, [(1, 2, 3)])
+
+    def test_show_edges(self):
+        factory = nx.classes.filters.show_edges
+        f = factory([(1, 2), (3, 4)])
+        assert f(1, 2)
+        assert f(3, 4)
+        assert f(4, 3)
+        assert not f(2, 3)
+        assert not f(0, -1)
+        assert not f("a", "b")
+        pytest.raises(TypeError, f, 1, 2, 3)
+        pytest.raises(TypeError, f, 1)
+        pytest.raises(TypeError, f)
+        pytest.raises(TypeError, factory, [1, 2, 3])
+        pytest.raises(ValueError, factory, [(1, 2, 3)])
+
+    def test_hide_diedges(self):
+        factory = nx.classes.filters.hide_diedges
+        f = factory([(1, 2), (3, 4)])
+        assert not f(1, 2)
+        assert not f(3, 4)
+        assert f(4, 3)
+        assert f(2, 3)
+        assert f(0, -1)
+        assert f("a", "b")
+        pytest.raises(TypeError, f, 1, 2, 3)
+        pytest.raises(TypeError, f, 1)
+        pytest.raises(TypeError, f)
+        pytest.raises(TypeError, factory, [1, 2, 3])
+        pytest.raises(ValueError, factory, [(1, 2, 3)])
+
+    def test_show_diedges(self):
+        factory = nx.classes.filters.show_diedges
+        f = factory([(1, 2), (3, 4)])
+        assert f(1, 2)
+        assert f(3, 4)
+        assert not f(4, 3)
+        assert not f(2, 3)
+        assert not f(0, -1)
+        assert not f("a", "b")
+        pytest.raises(TypeError, f, 1, 2, 3)
+        pytest.raises(TypeError, f, 1)
+        pytest.raises(TypeError, f)
+        pytest.raises(TypeError, factory, [1, 2, 3])
+        pytest.raises(ValueError, factory, [(1, 2, 3)])
+
+    def test_hide_multiedges(self):
+        factory = nx.classes.filters.hide_multiedges
+        f = factory([(1, 2, 0), (3, 4, 1), (1, 2, 1)])
+        assert not f(1, 2, 0)
+        assert not f(1, 2, 1)
+        assert f(1, 2, 2)
+        assert f(3, 4, 0)
+        assert not f(3, 4, 1)
+        assert not f(4, 3, 1)
+        assert f(4, 3, 0)
+        assert f(2, 3, 0)
+        assert f(0, -1, 0)
+        assert f("a", "b", 0)
+        pytest.raises(TypeError, f, 1, 2, 3, 4)
+        pytest.raises(TypeError, f, 1, 2)
+        pytest.raises(TypeError, f, 1)
+        pytest.raises(TypeError, f)
+        pytest.raises(TypeError, factory, [1, 2, 3])
+        pytest.raises(ValueError, factory, [(1, 2)])
+        pytest.raises(ValueError, factory, [(1, 2, 3, 4)])
+
+    def test_show_multiedges(self):
+        factory = nx.classes.filters.show_multiedges
+        f = factory([(1, 2, 0), (3, 4, 1), (1, 2, 1)])
+        assert f(1, 2, 0)
+        assert f(1, 2, 1)
+        assert not f(1, 2, 2)
+        assert not f(3, 4, 0)
+        assert f(3, 4, 1)
+        assert f(4, 3, 1)
+        assert not f(4, 3, 0)
+        assert not f(2, 3, 0)
+        assert not f(0, -1, 0)
+        assert not f("a", "b", 0)
+        pytest.raises(TypeError, f, 1, 2, 3, 4)
+        pytest.raises(TypeError, f, 1, 2)
+        pytest.raises(TypeError, f, 1)
+        pytest.raises(TypeError, f)
+        pytest.raises(TypeError, factory, [1, 2, 3])
+        pytest.raises(ValueError, factory, [(1, 2)])
+        pytest.raises(ValueError, factory, [(1, 2, 3, 4)])
+
+    def test_hide_multidiedges(self):
+        factory = nx.classes.filters.hide_multidiedges
+        f = factory([(1, 2, 0), (3, 4, 1), (1, 2, 1)])
+        assert not f(1, 2, 0)
+        assert not f(1, 2, 1)
+        assert f(1, 2, 2)
+        assert f(3, 4, 0)
+        assert not f(3, 4, 1)
+        assert f(4, 3, 1)
+        assert f(4, 3, 0)
+        assert f(2, 3, 0)
+        assert f(0, -1, 0)
+        assert f("a", "b", 0)
+        pytest.raises(TypeError, f, 1, 2, 3, 4)
+        pytest.raises(TypeError, f, 1, 2)
+        pytest.raises(TypeError, f, 1)
+        pytest.raises(TypeError, f)
+        pytest.raises(TypeError, factory, [1, 2, 3])
+        pytest.raises(ValueError, factory, [(1, 2)])
+        pytest.raises(ValueError, factory, [(1, 2, 3, 4)])
+
+    def test_show_multidiedges(self):
+        factory = nx.classes.filters.show_multidiedges
+        f = factory([(1, 2, 0), (3, 4, 1), (1, 2, 1)])
+        assert f(1, 2, 0)
+        assert f(1, 2, 1)
+        assert not f(1, 2, 2)
+        assert not f(3, 4, 0)
+        assert f(3, 4, 1)
+        assert not f(4, 3, 1)
+        assert not f(4, 3, 0)
+        assert not f(2, 3, 0)
+        assert not f(0, -1, 0)
+        assert not f("a", "b", 0)
+        pytest.raises(TypeError, f, 1, 2, 3, 4)
+        pytest.raises(TypeError, f, 1, 2)
+        pytest.raises(TypeError, f, 1)
+        pytest.raises(TypeError, f)
+        pytest.raises(TypeError, factory, [1, 2, 3])
+        pytest.raises(ValueError, factory, [(1, 2)])
+        pytest.raises(ValueError, factory, [(1, 2, 3, 4)])
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_function.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_function.py
new file mode 100644
index 0000000..051d655
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_function.py
@@ -0,0 +1,799 @@
+import random
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, nodes_equal
+
+
+class TestFunction:
+    def setup_method(self):
+        self.G = nx.Graph({0: [1, 2, 3], 1: [1, 2, 0], 4: []}, name="Test")
+        self.Gdegree = {0: 3, 1: 2, 2: 2, 3: 1, 4: 0}
+        self.Gnodes = list(range(5))
+        self.Gedges = [(0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2)]
+        self.DG = nx.DiGraph({0: [1, 2, 3], 1: [1, 2, 0], 4: []})
+        self.DGin_degree = {0: 1, 1: 2, 2: 2, 3: 1, 4: 0}
+        self.DGout_degree = {0: 3, 1: 3, 2: 0, 3: 0, 4: 0}
+        self.DGnodes = list(range(5))
+        self.DGedges = [(0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2)]
+
+    def test_nodes(self):
+        assert nodes_equal(self.G.nodes(), list(nx.nodes(self.G)))
+        assert nodes_equal(self.DG.nodes(), list(nx.nodes(self.DG)))
+
+    def test_edges(self):
+        assert edges_equal(self.G.edges(), list(nx.edges(self.G)))
+        assert sorted(self.DG.edges()) == sorted(nx.edges(self.DG))
+        assert edges_equal(
+            self.G.edges(nbunch=[0, 1, 3]), list(nx.edges(self.G, nbunch=[0, 1, 3]))
+        )
+        assert sorted(self.DG.edges(nbunch=[0, 1, 3])) == sorted(
+            nx.edges(self.DG, nbunch=[0, 1, 3])
+        )
+
+    def test_degree(self):
+        assert edges_equal(self.G.degree(), list(nx.degree(self.G)))
+        assert sorted(self.DG.degree()) == sorted(nx.degree(self.DG))
+        assert edges_equal(
+            self.G.degree(nbunch=[0, 1]), list(nx.degree(self.G, nbunch=[0, 1]))
+        )
+        assert sorted(self.DG.degree(nbunch=[0, 1])) == sorted(
+            nx.degree(self.DG, nbunch=[0, 1])
+        )
+        assert edges_equal(
+            self.G.degree(weight="weight"), list(nx.degree(self.G, weight="weight"))
+        )
+        assert sorted(self.DG.degree(weight="weight")) == sorted(
+            nx.degree(self.DG, weight="weight")
+        )
+
+    def test_neighbors(self):
+        assert list(self.G.neighbors(1)) == list(nx.neighbors(self.G, 1))
+        assert list(self.DG.neighbors(1)) == list(nx.neighbors(self.DG, 1))
+
+    def test_number_of_nodes(self):
+        assert self.G.number_of_nodes() == nx.number_of_nodes(self.G)
+        assert self.DG.number_of_nodes() == nx.number_of_nodes(self.DG)
+
+    def test_number_of_edges(self):
+        assert self.G.number_of_edges() == nx.number_of_edges(self.G)
+        assert self.DG.number_of_edges() == nx.number_of_edges(self.DG)
+
+    def test_is_directed(self):
+        assert self.G.is_directed() == nx.is_directed(self.G)
+        assert self.DG.is_directed() == nx.is_directed(self.DG)
+
+    def test_add_star(self):
+        G = self.G.copy()
+        nlist = [12, 13, 14, 15]
+        nx.add_star(G, nlist)
+        assert edges_equal(G.edges(nlist), [(12, 13), (12, 14), (12, 15)])
+
+        G = self.G.copy()
+        nx.add_star(G, nlist, weight=2.0)
+        assert edges_equal(
+            G.edges(nlist, data=True),
+            [
+                (12, 13, {"weight": 2.0}),
+                (12, 14, {"weight": 2.0}),
+                (12, 15, {"weight": 2.0}),
+            ],
+        )
+
+        G = self.G.copy()
+        nlist = [12]
+        nx.add_star(G, nlist)
+        assert nodes_equal(G, list(self.G) + nlist)
+
+        G = self.G.copy()
+        nlist = []
+        nx.add_star(G, nlist)
+        assert nodes_equal(G.nodes, self.Gnodes)
+        assert edges_equal(G.edges, self.G.edges)
+
+    def test_add_path(self):
+        G = self.G.copy()
+        nlist = [12, 13, 14, 15]
+        nx.add_path(G, nlist)
+        assert edges_equal(G.edges(nlist), [(12, 13), (13, 14), (14, 15)])
+        G = self.G.copy()
+        nx.add_path(G, nlist, weight=2.0)
+        assert edges_equal(
+            G.edges(nlist, data=True),
+            [
+                (12, 13, {"weight": 2.0}),
+                (13, 14, {"weight": 2.0}),
+                (14, 15, {"weight": 2.0}),
+            ],
+        )
+
+        G = self.G.copy()
+        nlist = ["node"]
+        nx.add_path(G, nlist)
+        assert edges_equal(G.edges(nlist), [])
+        assert nodes_equal(G, list(self.G) + ["node"])
+
+        G = self.G.copy()
+        nlist = iter(["node"])
+        nx.add_path(G, nlist)
+        assert edges_equal(G.edges(["node"]), [])
+        assert nodes_equal(G, list(self.G) + ["node"])
+
+        G = self.G.copy()
+        nlist = [12]
+        nx.add_path(G, nlist)
+        assert edges_equal(G.edges(nlist), [])
+        assert nodes_equal(G, list(self.G) + [12])
+
+        G = self.G.copy()
+        nlist = iter([12])
+        nx.add_path(G, nlist)
+        assert edges_equal(G.edges([12]), [])
+        assert nodes_equal(G, list(self.G) + [12])
+
+        G = self.G.copy()
+        nlist = []
+        nx.add_path(G, nlist)
+        assert edges_equal(G.edges, self.G.edges)
+        assert nodes_equal(G, list(self.G))
+
+        G = self.G.copy()
+        nlist = iter([])
+        nx.add_path(G, nlist)
+        assert edges_equal(G.edges, self.G.edges)
+        assert nodes_equal(G, list(self.G))
+
+    def test_add_cycle(self):
+        G = self.G.copy()
+        nlist = [12, 13, 14, 15]
+        oklists = [
+            [(12, 13), (12, 15), (13, 14), (14, 15)],
+            [(12, 13), (13, 14), (14, 15), (15, 12)],
+        ]
+        nx.add_cycle(G, nlist)
+        assert sorted(G.edges(nlist)) in oklists
+        G = self.G.copy()
+        oklists = [
+            [
+                (12, 13, {"weight": 1.0}),
+                (12, 15, {"weight": 1.0}),
+                (13, 14, {"weight": 1.0}),
+                (14, 15, {"weight": 1.0}),
+            ],
+            [
+                (12, 13, {"weight": 1.0}),
+                (13, 14, {"weight": 1.0}),
+                (14, 15, {"weight": 1.0}),
+                (15, 12, {"weight": 1.0}),
+            ],
+        ]
+        nx.add_cycle(G, nlist, weight=1.0)
+        assert sorted(G.edges(nlist, data=True)) in oklists
+
+        G = self.G.copy()
+        nlist = [12]
+        nx.add_cycle(G, nlist)
+        assert nodes_equal(G, list(self.G) + nlist)
+
+        G = self.G.copy()
+        nlist = []
+        nx.add_cycle(G, nlist)
+        assert nodes_equal(G.nodes, self.Gnodes)
+        assert edges_equal(G.edges, self.G.edges)
+
+    def test_subgraph(self):
+        assert (
+            self.G.subgraph([0, 1, 2, 4]).adj == nx.subgraph(self.G, [0, 1, 2, 4]).adj
+        )
+        assert (
+            self.DG.subgraph([0, 1, 2, 4]).adj == nx.subgraph(self.DG, [0, 1, 2, 4]).adj
+        )
+        assert (
+            self.G.subgraph([0, 1, 2, 4]).adj
+            == nx.induced_subgraph(self.G, [0, 1, 2, 4]).adj
+        )
+        assert (
+            self.DG.subgraph([0, 1, 2, 4]).adj
+            == nx.induced_subgraph(self.DG, [0, 1, 2, 4]).adj
+        )
+        # subgraph-subgraph chain is allowed in function interface
+        H = nx.induced_subgraph(self.G.subgraph([0, 1, 2, 4]), [0, 1, 4])
+        assert H._graph is not self.G
+        assert H.adj == self.G.subgraph([0, 1, 4]).adj
+
+    def test_edge_subgraph(self):
+        assert (
+            self.G.edge_subgraph([(1, 2), (0, 3)]).adj
+            == nx.edge_subgraph(self.G, [(1, 2), (0, 3)]).adj
+        )
+        assert (
+            self.DG.edge_subgraph([(1, 2), (0, 3)]).adj
+            == nx.edge_subgraph(self.DG, [(1, 2), (0, 3)]).adj
+        )
+
+    def test_create_empty_copy(self):
+        G = nx.create_empty_copy(self.G, with_data=False)
+        assert nodes_equal(G, list(self.G))
+        assert G.graph == {}
+        assert G._node == {}.fromkeys(self.G.nodes(), {})
+        assert G._adj == {}.fromkeys(self.G.nodes(), {})
+        G = nx.create_empty_copy(self.G)
+        assert nodes_equal(G, list(self.G))
+        assert G.graph == self.G.graph
+        assert G._node == self.G._node
+        assert G._adj == {}.fromkeys(self.G.nodes(), {})
+
+    def test_degree_histogram(self):
+        assert nx.degree_histogram(self.G) == [1, 1, 1, 1, 1]
+
+    def test_density(self):
+        assert nx.density(self.G) == 0.5
+        assert nx.density(self.DG) == 0.3
+        G = nx.Graph()
+        G.add_node(1)
+        assert nx.density(G) == 0.0
+
+    def test_density_selfloop(self):
+        G = nx.Graph()
+        G.add_edge(1, 1)
+        assert nx.density(G) == 0.0
+        G.add_edge(1, 2)
+        assert nx.density(G) == 2.0
+
+    def test_freeze(self):
+        G = nx.freeze(self.G)
+        assert G.frozen
+        pytest.raises(nx.NetworkXError, G.add_node, 1)
+        pytest.raises(nx.NetworkXError, G.add_nodes_from, [1])
+        pytest.raises(nx.NetworkXError, G.remove_node, 1)
+        pytest.raises(nx.NetworkXError, G.remove_nodes_from, [1])
+        pytest.raises(nx.NetworkXError, G.add_edge, 1, 2)
+        pytest.raises(nx.NetworkXError, G.add_edges_from, [(1, 2)])
+        pytest.raises(nx.NetworkXError, G.remove_edge, 1, 2)
+        pytest.raises(nx.NetworkXError, G.remove_edges_from, [(1, 2)])
+        pytest.raises(nx.NetworkXError, G.clear)
+
+    def test_is_frozen(self):
+        assert not nx.is_frozen(self.G)
+        G = nx.freeze(self.G)
+        assert G.frozen == nx.is_frozen(self.G)
+        assert G.frozen
+
+    def test_info(self):
+        G = nx.path_graph(5)
+        G.name = "path_graph(5)"
+        info = nx.info(G)
+        expected_graph_info = "Graph named 'path_graph(5)' with 5 nodes and 4 edges"
+        assert info == expected_graph_info
+
+        info = nx.info(G, n=1)
+        assert type(info) == str
+        expected_node_info = "\n".join(
+            ["Node 1 has the following properties:", "Degree: 2", "Neighbors: 0 2"]
+        )
+        assert info == expected_node_info
+
+        # must raise an error for a non-existent node
+        pytest.raises(nx.NetworkXError, nx.info, G, 1248)
+
+    def test_info_digraph(self):
+        G = nx.DiGraph(name="path_graph(5)")
+        nx.add_path(G, [0, 1, 2, 3, 4])
+        info = nx.info(G)
+        expected_graph_info = "DiGraph named 'path_graph(5)' with 5 nodes and 4 edges"
+        assert info == expected_graph_info
+
+        info = nx.info(G, n=1)
+        expected_node_info = "\n".join(
+            ["Node 1 has the following properties:", "Degree: 2", "Neighbors: 2"]
+        )
+        assert info == expected_node_info
+
+        pytest.raises(nx.NetworkXError, nx.info, G, n=-1)
+
+    def test_neighbors_complete_graph(self):
+        graph = nx.complete_graph(100)
+        pop = random.sample(list(graph), 1)
+        nbors = list(nx.neighbors(graph, pop[0]))
+        # should be all the other vertices in the graph
+        assert len(nbors) == len(graph) - 1
+
+        graph = nx.path_graph(100)
+        node = random.sample(list(graph), 1)[0]
+        nbors = list(nx.neighbors(graph, node))
+        # should be all the other vertices in the graph
+        if node != 0 and node != 99:
+            assert len(nbors) == 2
+        else:
+            assert len(nbors) == 1
+
+        # create a star graph with 99 outer nodes
+        graph = nx.star_graph(99)
+        nbors = list(nx.neighbors(graph, 0))
+        assert len(nbors) == 99
+
+    def test_non_neighbors(self):
+        graph = nx.complete_graph(100)
+        pop = random.sample(list(graph), 1)
+        nbors = list(nx.non_neighbors(graph, pop[0]))
+        # should be all the other vertices in the graph
+        assert len(nbors) == 0
+
+        graph = nx.path_graph(100)
+        node = random.sample(list(graph), 1)[0]
+        nbors = list(nx.non_neighbors(graph, node))
+        # should be all the other vertices in the graph
+        if node != 0 and node != 99:
+            assert len(nbors) == 97
+        else:
+            assert len(nbors) == 98
+
+        # create a star graph with 99 outer nodes
+        graph = nx.star_graph(99)
+        nbors = list(nx.non_neighbors(graph, 0))
+        assert len(nbors) == 0
+
+        # disconnected graph
+        graph = nx.Graph()
+        graph.add_nodes_from(range(10))
+        nbors = list(nx.non_neighbors(graph, 0))
+        assert len(nbors) == 9
+
+    def test_non_edges(self):
+        # All possible edges exist
+        graph = nx.complete_graph(5)
+        nedges = list(nx.non_edges(graph))
+        assert len(nedges) == 0
+
+        graph = nx.path_graph(4)
+        expected = [(0, 2), (0, 3), (1, 3)]
+        nedges = list(nx.non_edges(graph))
+        for (u, v) in expected:
+            assert (u, v) in nedges or (v, u) in nedges
+
+        graph = nx.star_graph(4)
+        expected = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        nedges = list(nx.non_edges(graph))
+        for (u, v) in expected:
+            assert (u, v) in nedges or (v, u) in nedges
+
+        # Directed graphs
+        graph = nx.DiGraph()
+        graph.add_edges_from([(0, 2), (2, 0), (2, 1)])
+        expected = [(0, 1), (1, 0), (1, 2)]
+        nedges = list(nx.non_edges(graph))
+        for e in expected:
+            assert e in nedges
+
+    def test_is_weighted(self):
+        G = nx.Graph()
+        assert not nx.is_weighted(G)
+
+        G = nx.path_graph(4)
+        assert not nx.is_weighted(G)
+        assert not nx.is_weighted(G, (2, 3))
+
+        G.add_node(4)
+        G.add_edge(3, 4, weight=4)
+        assert not nx.is_weighted(G)
+        assert nx.is_weighted(G, (3, 4))
+
+        G = nx.DiGraph()
+        G.add_weighted_edges_from(
+            [
+                ("0", "3", 3),
+                ("0", "1", -5),
+                ("1", "0", -5),
+                ("0", "2", 2),
+                ("1", "2", 4),
+                ("2", "3", 1),
+            ]
+        )
+        assert nx.is_weighted(G)
+        assert nx.is_weighted(G, ("1", "0"))
+
+        G = G.to_undirected()
+        assert nx.is_weighted(G)
+        assert nx.is_weighted(G, ("1", "0"))
+
+        pytest.raises(nx.NetworkXError, nx.is_weighted, G, (1, 2))
+
+    def test_is_negatively_weighted(self):
+        G = nx.Graph()
+        assert not nx.is_negatively_weighted(G)
+
+        G.add_node(1)
+        G.add_nodes_from([2, 3, 4, 5])
+        assert not nx.is_negatively_weighted(G)
+
+        G.add_edge(1, 2, weight=4)
+        assert not nx.is_negatively_weighted(G, (1, 2))
+
+        G.add_edges_from([(1, 3), (2, 4), (2, 6)])
+        G[1][3]["color"] = "blue"
+        assert not nx.is_negatively_weighted(G)
+        assert not nx.is_negatively_weighted(G, (1, 3))
+
+        G[2][4]["weight"] = -2
+        assert nx.is_negatively_weighted(G, (2, 4))
+        assert nx.is_negatively_weighted(G)
+
+        G = nx.DiGraph()
+        G.add_weighted_edges_from(
+            [
+                ("0", "3", 3),
+                ("0", "1", -5),
+                ("1", "0", -2),
+                ("0", "2", 2),
+                ("1", "2", -3),
+                ("2", "3", 1),
+            ]
+        )
+        assert nx.is_negatively_weighted(G)
+        assert not nx.is_negatively_weighted(G, ("0", "3"))
+        assert nx.is_negatively_weighted(G, ("1", "0"))
+
+        pytest.raises(nx.NetworkXError, nx.is_negatively_weighted, G, (1, 4))
+
+
+class TestCommonNeighbors:
+    @classmethod
+    def setup_class(cls):
+        cls.func = staticmethod(nx.common_neighbors)
+
+        def test_func(G, u, v, expected):
+            result = sorted(cls.func(G, u, v))
+            assert result == expected
+
+        cls.test = staticmethod(test_func)
+
+    def test_K5(self):
+        G = nx.complete_graph(5)
+        self.test(G, 0, 1, [2, 3, 4])
+
+    def test_P3(self):
+        G = nx.path_graph(3)
+        self.test(G, 0, 2, [1])
+
+    def test_S4(self):
+        G = nx.star_graph(4)
+        self.test(G, 1, 2, [0])
+
+    def test_digraph(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            G = nx.DiGraph()
+            G.add_edges_from([(0, 1), (1, 2)])
+            self.func(G, 0, 2)
+
+    def test_nonexistent_nodes(self):
+        G = nx.complete_graph(5)
+        pytest.raises(nx.NetworkXError, nx.common_neighbors, G, 5, 4)
+        pytest.raises(nx.NetworkXError, nx.common_neighbors, G, 4, 5)
+        pytest.raises(nx.NetworkXError, nx.common_neighbors, G, 5, 6)
+
+    def test_custom1(self):
+        """Case of no common neighbors."""
+        G = nx.Graph()
+        G.add_nodes_from([0, 1])
+        self.test(G, 0, 1, [])
+
+    def test_custom2(self):
+        """Case of equal nodes."""
+        G = nx.complete_graph(4)
+        self.test(G, 0, 0, [1, 2, 3])
+
+
+@pytest.mark.parametrize(
+    "graph_type", (nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph)
+)
+def test_set_node_attributes(graph_type):
+    # Test single value
+    G = nx.path_graph(3, create_using=graph_type)
+    vals = 100
+    attr = "hello"
+    nx.set_node_attributes(G, vals, attr)
+    assert G.nodes[0][attr] == vals
+    assert G.nodes[1][attr] == vals
+    assert G.nodes[2][attr] == vals
+
+    # Test dictionary
+    G = nx.path_graph(3, create_using=graph_type)
+    vals = dict(zip(sorted(G.nodes()), range(len(G))))
+    attr = "hi"
+    nx.set_node_attributes(G, vals, attr)
+    assert G.nodes[0][attr] == 0
+    assert G.nodes[1][attr] == 1
+    assert G.nodes[2][attr] == 2
+
+    # Test dictionary of dictionaries
+    G = nx.path_graph(3, create_using=graph_type)
+    d = {"hi": 0, "hello": 200}
+    vals = dict.fromkeys(G.nodes(), d)
+    vals.pop(0)
+    nx.set_node_attributes(G, vals)
+    assert G.nodes[0] == {}
+    assert G.nodes[1]["hi"] == 0
+    assert G.nodes[2]["hello"] == 200
+
+
+@pytest.mark.parametrize(
+    ("values", "name"),
+    (
+        ({0: "red", 1: "blue"}, "color"),  # values dictionary
+        ({0: {"color": "red"}, 1: {"color": "blue"}}, None),  # dict-of-dict
+    ),
+)
+def test_set_node_attributes_ignores_extra_nodes(values, name):
+    """
+    When `values` is a dict or dict-of-dict keyed by nodes, ensure that keys
+    that correspond to nodes not in G are ignored.
+    """
+    G = nx.Graph()
+    G.add_node(0)
+    nx.set_node_attributes(G, values, name)
+    assert G.nodes[0]["color"] == "red"
+    assert 1 not in G.nodes
+
+
+@pytest.mark.parametrize("graph_type", (nx.Graph, nx.DiGraph))
+def test_set_edge_attributes(graph_type):
+    # Test single value
+    G = nx.path_graph(3, create_using=graph_type)
+    attr = "hello"
+    vals = 3
+    nx.set_edge_attributes(G, vals, attr)
+    assert G[0][1][attr] == vals
+    assert G[1][2][attr] == vals
+
+    # Test multiple values
+    G = nx.path_graph(3, create_using=graph_type)
+    attr = "hi"
+    edges = [(0, 1), (1, 2)]
+    vals = dict(zip(edges, range(len(edges))))
+    nx.set_edge_attributes(G, vals, attr)
+    assert G[0][1][attr] == 0
+    assert G[1][2][attr] == 1
+
+    # Test dictionary of dictionaries
+    G = nx.path_graph(3, create_using=graph_type)
+    d = {"hi": 0, "hello": 200}
+    edges = [(0, 1)]
+    vals = dict.fromkeys(edges, d)
+    nx.set_edge_attributes(G, vals)
+    assert G[0][1]["hi"] == 0
+    assert G[0][1]["hello"] == 200
+    assert G[1][2] == {}
+
+
+@pytest.mark.parametrize(
+    ("values", "name"),
+    (
+        ({(0, 1): 1.0, (0, 2): 2.0}, "weight"),  # values dict
+        ({(0, 1): {"weight": 1.0}, (0, 2): {"weight": 2.0}}, None),  # values dod
+    ),
+)
+def test_set_edge_attributes_ignores_extra_edges(values, name):
+    """If `values` is a dict or dict-of-dicts containing edges that are not in
+    G, data associate with these edges should be ignored.
+    """
+    G = nx.Graph([(0, 1)])
+    nx.set_edge_attributes(G, values, name)
+    assert G[0][1]["weight"] == 1.0
+    assert (0, 2) not in G.edges
+
+
+@pytest.mark.parametrize("graph_type", (nx.MultiGraph, nx.MultiDiGraph))
+def test_set_edge_attributes_multi(graph_type):
+    # Test single value
+    G = nx.path_graph(3, create_using=graph_type)
+    attr = "hello"
+    vals = 3
+    nx.set_edge_attributes(G, vals, attr)
+    assert G[0][1][0][attr] == vals
+    assert G[1][2][0][attr] == vals
+
+    # Test multiple values
+    G = nx.path_graph(3, create_using=graph_type)
+    attr = "hi"
+    edges = [(0, 1, 0), (1, 2, 0)]
+    vals = dict(zip(edges, range(len(edges))))
+    nx.set_edge_attributes(G, vals, attr)
+    assert G[0][1][0][attr] == 0
+    assert G[1][2][0][attr] == 1
+
+    # Test dictionary of dictionaries
+    G = nx.path_graph(3, create_using=graph_type)
+    d = {"hi": 0, "hello": 200}
+    edges = [(0, 1, 0)]
+    vals = dict.fromkeys(edges, d)
+    nx.set_edge_attributes(G, vals)
+    assert G[0][1][0]["hi"] == 0
+    assert G[0][1][0]["hello"] == 200
+    assert G[1][2][0] == {}
+
+
+@pytest.mark.parametrize(
+    ("values", "name"),
+    (
+        ({(0, 1, 0): 1.0, (0, 2, 0): 2.0}, "weight"),  # values dict
+        ({(0, 1, 0): {"weight": 1.0}, (0, 2, 0): {"weight": 2.0}}, None),  # values dod
+    ),
+)
+def test_set_edge_attributes_multi_ignores_extra_edges(values, name):
+    """If `values` is a dict or dict-of-dicts containing edges that are not in
+    G, data associate with these edges should be ignored.
+    """
+    G = nx.MultiGraph([(0, 1, 0), (0, 1, 1)])
+    nx.set_edge_attributes(G, values, name)
+    assert G[0][1][0]["weight"] == 1.0
+    assert G[0][1][1] == {}
+    assert (0, 2) not in G.edges()
+
+
+def test_get_node_attributes():
+    graphs = [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]
+    for G in graphs:
+        G = nx.path_graph(3, create_using=G)
+        attr = "hello"
+        vals = 100
+        nx.set_node_attributes(G, vals, attr)
+        attrs = nx.get_node_attributes(G, attr)
+        assert attrs[0] == vals
+        assert attrs[1] == vals
+        assert attrs[2] == vals
+
+
+def test_get_edge_attributes():
+    graphs = [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]
+    for G in graphs:
+        G = nx.path_graph(3, create_using=G)
+        attr = "hello"
+        vals = 100
+        nx.set_edge_attributes(G, vals, attr)
+        attrs = nx.get_edge_attributes(G, attr)
+
+        assert len(attrs) == 2
+        if G.is_multigraph():
+            keys = [(0, 1, 0), (1, 2, 0)]
+            for u, v, k in keys:
+                try:
+                    assert attrs[(u, v, k)] == 100
+                except KeyError:
+                    assert attrs[(v, u, k)] == 100
+        else:
+            keys = [(0, 1), (1, 2)]
+            for u, v in keys:
+                try:
+                    assert attrs[(u, v)] == 100
+                except KeyError:
+                    assert attrs[(v, u)] == 100
+
+
+def test_is_empty():
+    graphs = [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]
+    for G in graphs:
+        assert nx.is_empty(G)
+        G.add_nodes_from(range(5))
+        assert nx.is_empty(G)
+        G.add_edges_from([(1, 2), (3, 4)])
+        assert not nx.is_empty(G)
+
+
+@pytest.mark.parametrize(
+    "graph_type", [nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph]
+)
+def test_selfloops(graph_type):
+    G = nx.complete_graph(3, create_using=graph_type)
+    G.add_edge(0, 0)
+    assert nodes_equal(nx.nodes_with_selfloops(G), [0])
+    assert edges_equal(nx.selfloop_edges(G), [(0, 0)])
+    assert edges_equal(nx.selfloop_edges(G, data=True), [(0, 0, {})])
+    assert nx.number_of_selfloops(G) == 1
+
+
+@pytest.mark.parametrize(
+    "graph_type", [nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph]
+)
+def test_selfloop_edges_attr(graph_type):
+    G = nx.complete_graph(3, create_using=graph_type)
+    G.add_edge(0, 0)
+    G.add_edge(1, 1, weight=2)
+    assert edges_equal(
+        nx.selfloop_edges(G, data=True), [(0, 0, {}), (1, 1, {"weight": 2})]
+    )
+    assert edges_equal(nx.selfloop_edges(G, data="weight"), [(0, 0, None), (1, 1, 2)])
+
+
+def test_selfloop_edges_multi_with_data_and_keys():
+    G = nx.complete_graph(3, create_using=nx.MultiGraph)
+    G.add_edge(0, 0, weight=10)
+    G.add_edge(0, 0, weight=100)
+    assert edges_equal(
+        nx.selfloop_edges(G, data="weight", keys=True), [(0, 0, 0, 10), (0, 0, 1, 100)]
+    )
+
+
+@pytest.mark.parametrize("graph_type", [nx.Graph, nx.DiGraph])
+def test_selfloops_removal(graph_type):
+    G = nx.complete_graph(3, create_using=graph_type)
+    G.add_edge(0, 0)
+    G.remove_edges_from(nx.selfloop_edges(G, keys=True))
+    G.add_edge(0, 0)
+    G.remove_edges_from(nx.selfloop_edges(G, data=True))
+    G.add_edge(0, 0)
+    G.remove_edges_from(nx.selfloop_edges(G, keys=True, data=True))
+
+
+@pytest.mark.parametrize("graph_type", [nx.MultiGraph, nx.MultiDiGraph])
+def test_selfloops_removal_multi(graph_type):
+    """test removing selfloops behavior vis-a-vis altering a dict while iterating.
+    cf. gh-4068"""
+    G = nx.complete_graph(3, create_using=graph_type)
+    # Defaults - see gh-4080
+    G.add_edge(0, 0)
+    G.add_edge(0, 0)
+    G.remove_edges_from(nx.selfloop_edges(G))
+    assert (0, 0) not in G.edges()
+    # With keys
+    G.add_edge(0, 0)
+    G.add_edge(0, 0)
+    with pytest.raises(RuntimeError):
+        G.remove_edges_from(nx.selfloop_edges(G, keys=True))
+    # With data
+    G.add_edge(0, 0)
+    G.add_edge(0, 0)
+    with pytest.raises(TypeError):
+        G.remove_edges_from(nx.selfloop_edges(G, data=True))
+    # With keys and data
+    G.add_edge(0, 0)
+    G.add_edge(0, 0)
+    with pytest.raises(RuntimeError):
+        G.remove_edges_from(nx.selfloop_edges(G, data=True, keys=True))
+
+
+def test_pathweight():
+    valid_path = [1, 2, 3]
+    invalid_path = [1, 3, 2]
+    graphs = [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]
+    edges = [
+        (1, 2, dict(cost=5, dist=6)),
+        (2, 3, dict(cost=3, dist=4)),
+        (1, 2, dict(cost=1, dist=2)),
+    ]
+    for graph in graphs:
+        graph.add_edges_from(edges)
+        assert nx.path_weight(graph, valid_path, "cost") == 4
+        assert nx.path_weight(graph, valid_path, "dist") == 6
+        pytest.raises(nx.NetworkXNoPath, nx.path_weight, graph, invalid_path, "cost")
+
+
+def test_ispath():
+    valid_path = [1, 2, 3, 4]
+    invalid_path = [1, 2, 4, 3]
+    graphs = [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]
+    edges = [(1, 2), (2, 3), (1, 2), (3, 4)]
+    for graph in graphs:
+        graph.add_edges_from(edges)
+        assert nx.is_path(graph, valid_path)
+        assert not nx.is_path(graph, invalid_path)
+
+
+@pytest.mark.parametrize("G", (nx.Graph(), nx.DiGraph()))
+def test_restricted_view(G):
+    G.add_edges_from([(0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2)])
+    G.add_node(4)
+    H = nx.restricted_view(G, [0, 2, 5], [(1, 2), (3, 4)])
+    assert set(H.nodes()) == {1, 3, 4}
+    assert set(H.edges()) == {(1, 1)}
+
+
+@pytest.mark.parametrize("G", (nx.MultiGraph(), nx.MultiDiGraph()))
+def test_restricted_view_multi(G):
+    G.add_edges_from(
+        [(0, 1, 0), (0, 2, 0), (0, 3, 0), (0, 1, 1), (1, 0, 0), (1, 1, 0), (1, 2, 0)]
+    )
+    G.add_node(4)
+    H = nx.restricted_view(G, [0, 2, 5], [(1, 2, 0), (3, 4, 0)])
+    assert set(H.nodes()) == {1, 3, 4}
+    assert set(H.edges()) == {(1, 1)}
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_graph.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_graph.py
new file mode 100644
index 0000000..ebaa04b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_graph.py
@@ -0,0 +1,897 @@
+import gc
+import pickle
+import platform
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, graphs_equal, nodes_equal
+
+
+class BaseGraphTester:
+    """Tests for data-structure independent graph class features."""
+
+    def test_contains(self):
+        G = self.K3
+        assert 1 in G
+        assert 4 not in G
+        assert "b" not in G
+        assert [] not in G  # no exception for nonhashable
+        assert {1: 1} not in G  # no exception for nonhashable
+
+    def test_order(self):
+        G = self.K3
+        assert len(G) == 3
+        assert G.order() == 3
+        assert G.number_of_nodes() == 3
+
+    def test_nodes(self):
+        G = self.K3
+        assert isinstance(G._node, G.node_dict_factory)
+        assert isinstance(G._adj, G.adjlist_outer_dict_factory)
+        assert all(
+            isinstance(adj, G.adjlist_inner_dict_factory) for adj in G._adj.values()
+        )
+        assert sorted(G.nodes()) == self.k3nodes
+        assert sorted(G.nodes(data=True)) == [(0, {}), (1, {}), (2, {})]
+
+    def test_none_node(self):
+        G = self.Graph()
+        with pytest.raises(ValueError):
+            G.add_node(None)
+        with pytest.raises(ValueError):
+            G.add_nodes_from([None])
+        with pytest.raises(ValueError):
+            G.add_edge(0, None)
+        with pytest.raises(ValueError):
+            G.add_edges_from([(0, None)])
+
+    def test_has_node(self):
+        G = self.K3
+        assert G.has_node(1)
+        assert not G.has_node(4)
+        assert not G.has_node([])  # no exception for nonhashable
+        assert not G.has_node({1: 1})  # no exception for nonhashable
+
+    def test_has_edge(self):
+        G = self.K3
+        assert G.has_edge(0, 1)
+        assert not G.has_edge(0, -1)
+
+    def test_neighbors(self):
+        G = self.K3
+        assert sorted(G.neighbors(0)) == [1, 2]
+        with pytest.raises(nx.NetworkXError):
+            G.neighbors(-1)
+
+    @pytest.mark.skipif(
+        platform.python_implementation() == "PyPy", reason="PyPy gc is different"
+    )
+    def test_memory_leak(self):
+        G = self.Graph()
+
+        def count_objects_of_type(_type):
+            return sum(1 for obj in gc.get_objects() if isinstance(obj, _type))
+
+        gc.collect()
+        before = count_objects_of_type(self.Graph)
+        G.copy()
+        gc.collect()
+        after = count_objects_of_type(self.Graph)
+        assert before == after
+
+        # test a subgraph of the base class
+        class MyGraph(self.Graph):
+            pass
+
+        gc.collect()
+        G = MyGraph()
+        before = count_objects_of_type(MyGraph)
+        G.copy()
+        gc.collect()
+        after = count_objects_of_type(MyGraph)
+        assert before == after
+
+    def test_edges(self):
+        G = self.K3
+        assert isinstance(G._adj, G.adjlist_outer_dict_factory)
+        assert edges_equal(G.edges(), [(0, 1), (0, 2), (1, 2)])
+        assert edges_equal(G.edges(0), [(0, 1), (0, 2)])
+        assert edges_equal(G.edges([0, 1]), [(0, 1), (0, 2), (1, 2)])
+        with pytest.raises(nx.NetworkXError):
+            G.edges(-1)
+
+    def test_degree(self):
+        G = self.K3
+        assert sorted(G.degree()) == [(0, 2), (1, 2), (2, 2)]
+        assert dict(G.degree()) == {0: 2, 1: 2, 2: 2}
+        assert G.degree(0) == 2
+        with pytest.raises(nx.NetworkXError):
+            G.degree(-1)  # node not in graph
+
+    def test_size(self):
+        G = self.K3
+        assert G.size() == 3
+        assert G.number_of_edges() == 3
+
+    def test_nbunch_iter(self):
+        G = self.K3
+        assert nodes_equal(G.nbunch_iter(), self.k3nodes)  # all nodes
+        assert nodes_equal(G.nbunch_iter(0), [0])  # single node
+        assert nodes_equal(G.nbunch_iter([0, 1]), [0, 1])  # sequence
+        # sequence with none in graph
+        assert nodes_equal(G.nbunch_iter([-1]), [])
+        # string sequence with none in graph
+        assert nodes_equal(G.nbunch_iter("foo"), [])
+        # node not in graph doesn't get caught upon creation of iterator
+        bunch = G.nbunch_iter(-1)
+        # but gets caught when iterator used
+        with pytest.raises(nx.NetworkXError, match="is not a node or a sequence"):
+            list(bunch)
+        # unhashable doesn't get caught upon creation of iterator
+        bunch = G.nbunch_iter([0, 1, 2, {}])
+        # but gets caught when iterator hits the unhashable
+        with pytest.raises(
+            nx.NetworkXError, match="in sequence nbunch is not a valid node"
+        ):
+            list(bunch)
+
+    def test_nbunch_iter_node_format_raise(self):
+        # Tests that a node that would have failed string formatting
+        # doesn't cause an error when attempting to raise a
+        # :exc:`nx.NetworkXError`.
+
+        # For more information, see pull request #1813.
+        G = self.Graph()
+        nbunch = [("x", set())]
+        with pytest.raises(nx.NetworkXError):
+            list(G.nbunch_iter(nbunch))
+
+    def test_selfloop_degree(self):
+        G = self.Graph()
+        G.add_edge(1, 1)
+        assert sorted(G.degree()) == [(1, 2)]
+        assert dict(G.degree()) == {1: 2}
+        assert G.degree(1) == 2
+        assert sorted(G.degree([1])) == [(1, 2)]
+        assert G.degree(1, weight="weight") == 2
+
+    def test_selfloops(self):
+        G = self.K3.copy()
+        G.add_edge(0, 0)
+        assert nodes_equal(nx.nodes_with_selfloops(G), [0])
+        assert edges_equal(nx.selfloop_edges(G), [(0, 0)])
+        assert nx.number_of_selfloops(G) == 1
+        G.remove_edge(0, 0)
+        G.add_edge(0, 0)
+        G.remove_edges_from([(0, 0)])
+        G.add_edge(1, 1)
+        G.remove_node(1)
+        G.add_edge(0, 0)
+        G.add_edge(1, 1)
+        G.remove_nodes_from([0, 1])
+
+    def test_cache_reset(self):
+        G = self.K3.copy()
+        old_adj = G.adj
+        assert id(G.adj) == id(old_adj)
+        G._adj = {}
+        assert id(G.adj) != id(old_adj)
+
+    def test_attributes_cached(self):
+        G = self.K3.copy()
+        assert id(G.nodes) == id(G.nodes)
+        assert id(G.edges) == id(G.edges)
+        assert id(G.degree) == id(G.degree)
+        assert id(G.adj) == id(G.adj)
+
+
+class BaseAttrGraphTester(BaseGraphTester):
+    """Tests of graph class attribute features."""
+
+    def test_weighted_degree(self):
+        G = self.Graph()
+        G.add_edge(1, 2, weight=2, other=3)
+        G.add_edge(2, 3, weight=3, other=4)
+        assert sorted(d for n, d in G.degree(weight="weight")) == [2, 3, 5]
+        assert dict(G.degree(weight="weight")) == {1: 2, 2: 5, 3: 3}
+        assert G.degree(1, weight="weight") == 2
+        assert nodes_equal((G.degree([1], weight="weight")), [(1, 2)])
+
+        assert nodes_equal((d for n, d in G.degree(weight="other")), [3, 7, 4])
+        assert dict(G.degree(weight="other")) == {1: 3, 2: 7, 3: 4}
+        assert G.degree(1, weight="other") == 3
+        assert edges_equal((G.degree([1], weight="other")), [(1, 3)])
+
+    def add_attributes(self, G):
+        G.graph["foo"] = []
+        G.nodes[0]["foo"] = []
+        G.remove_edge(1, 2)
+        ll = []
+        G.add_edge(1, 2, foo=ll)
+        G.add_edge(2, 1, foo=ll)
+
+    def test_name(self):
+        G = self.Graph(name="")
+        assert G.name == ""
+        G = self.Graph(name="test")
+        assert G.name == "test"
+
+    def test_str_unnamed(self):
+        G = self.Graph()
+        G.add_edges_from([(1, 2), (2, 3)])
+        assert str(G) == f"{type(G).__name__} with 3 nodes and 2 edges"
+
+    def test_str_named(self):
+        G = self.Graph(name="foo")
+        G.add_edges_from([(1, 2), (2, 3)])
+        assert str(G) == f"{type(G).__name__} named 'foo' with 3 nodes and 2 edges"
+
+    def test_graph_chain(self):
+        G = self.Graph([(0, 1), (1, 2)])
+        DG = G.to_directed(as_view=True)
+        SDG = DG.subgraph([0, 1])
+        RSDG = SDG.reverse(copy=False)
+        assert G is DG._graph
+        assert DG is SDG._graph
+        assert SDG is RSDG._graph
+
+    def test_copy(self):
+        G = self.Graph()
+        G.add_node(0)
+        G.add_edge(1, 2)
+        self.add_attributes(G)
+        # copy edge datadict but any container attr are same
+        H = G.copy()
+        self.graphs_equal(H, G)
+        self.different_attrdict(H, G)
+        self.shallow_copy_attrdict(H, G)
+
+    def test_class_copy(self):
+        G = self.Graph()
+        G.add_node(0)
+        G.add_edge(1, 2)
+        self.add_attributes(G)
+        # copy edge datadict but any container attr are same
+        H = G.__class__(G)
+        self.graphs_equal(H, G)
+        self.different_attrdict(H, G)
+        self.shallow_copy_attrdict(H, G)
+
+    def test_fresh_copy(self):
+        G = self.Graph()
+        G.add_node(0)
+        G.add_edge(1, 2)
+        self.add_attributes(G)
+        # copy graph structure but use fresh datadict
+        H = G.__class__()
+        H.add_nodes_from(G)
+        H.add_edges_from(G.edges())
+        assert len(G.nodes[0]) == 1
+        ddict = G.adj[1][2][0] if G.is_multigraph() else G.adj[1][2]
+        assert len(ddict) == 1
+        assert len(H.nodes[0]) == 0
+        ddict = H.adj[1][2][0] if H.is_multigraph() else H.adj[1][2]
+        assert len(ddict) == 0
+
+    def is_deepcopy(self, H, G):
+        self.graphs_equal(H, G)
+        self.different_attrdict(H, G)
+        self.deep_copy_attrdict(H, G)
+
+    def deep_copy_attrdict(self, H, G):
+        self.deepcopy_graph_attr(H, G)
+        self.deepcopy_node_attr(H, G)
+        self.deepcopy_edge_attr(H, G)
+
+    def deepcopy_graph_attr(self, H, G):
+        assert G.graph["foo"] == H.graph["foo"]
+        G.graph["foo"].append(1)
+        assert G.graph["foo"] != H.graph["foo"]
+
+    def deepcopy_node_attr(self, H, G):
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
+        G.nodes[0]["foo"].append(1)
+        assert G.nodes[0]["foo"] != H.nodes[0]["foo"]
+
+    def deepcopy_edge_attr(self, H, G):
+        assert G[1][2]["foo"] == H[1][2]["foo"]
+        G[1][2]["foo"].append(1)
+        assert G[1][2]["foo"] != H[1][2]["foo"]
+
+    def is_shallow_copy(self, H, G):
+        self.graphs_equal(H, G)
+        self.shallow_copy_attrdict(H, G)
+
+    def shallow_copy_attrdict(self, H, G):
+        self.shallow_copy_graph_attr(H, G)
+        self.shallow_copy_node_attr(H, G)
+        self.shallow_copy_edge_attr(H, G)
+
+    def shallow_copy_graph_attr(self, H, G):
+        assert G.graph["foo"] == H.graph["foo"]
+        G.graph["foo"].append(1)
+        assert G.graph["foo"] == H.graph["foo"]
+
+    def shallow_copy_node_attr(self, H, G):
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
+        G.nodes[0]["foo"].append(1)
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
+
+    def shallow_copy_edge_attr(self, H, G):
+        assert G[1][2]["foo"] == H[1][2]["foo"]
+        G[1][2]["foo"].append(1)
+        assert G[1][2]["foo"] == H[1][2]["foo"]
+
+    def same_attrdict(self, H, G):
+        old_foo = H[1][2]["foo"]
+        H.adj[1][2]["foo"] = "baz"
+        assert G.edges == H.edges
+        H.adj[1][2]["foo"] = old_foo
+        assert G.edges == H.edges
+
+        old_foo = H.nodes[0]["foo"]
+        H.nodes[0]["foo"] = "baz"
+        assert G.nodes == H.nodes
+        H.nodes[0]["foo"] = old_foo
+        assert G.nodes == H.nodes
+
+    def different_attrdict(self, H, G):
+        old_foo = H[1][2]["foo"]
+        H.adj[1][2]["foo"] = "baz"
+        assert G._adj != H._adj
+        H.adj[1][2]["foo"] = old_foo
+        assert G._adj == H._adj
+
+        old_foo = H.nodes[0]["foo"]
+        H.nodes[0]["foo"] = "baz"
+        assert G._node != H._node
+        H.nodes[0]["foo"] = old_foo
+        assert G._node == H._node
+
+    def graphs_equal(self, H, G):
+        assert G._adj == H._adj
+        assert G._node == H._node
+        assert G.graph == H.graph
+        assert G.name == H.name
+        if not G.is_directed() and not H.is_directed():
+            assert H._adj[1][2] is H._adj[2][1]
+            assert G._adj[1][2] is G._adj[2][1]
+        else:  # at least one is directed
+            if not G.is_directed():
+                G._pred = G._adj
+                G._succ = G._adj
+            if not H.is_directed():
+                H._pred = H._adj
+                H._succ = H._adj
+            assert G._pred == H._pred
+            assert G._succ == H._succ
+            assert H._succ[1][2] is H._pred[2][1]
+            assert G._succ[1][2] is G._pred[2][1]
+
+    def test_graph_attr(self):
+        G = self.K3.copy()
+        G.graph["foo"] = "bar"
+        assert isinstance(G.graph, G.graph_attr_dict_factory)
+        assert G.graph["foo"] == "bar"
+        del G.graph["foo"]
+        assert G.graph == {}
+        H = self.Graph(foo="bar")
+        assert H.graph["foo"] == "bar"
+
+    def test_node_attr(self):
+        G = self.K3.copy()
+        G.add_node(1, foo="bar")
+        assert all(
+            isinstance(d, G.node_attr_dict_factory) for u, d in G.nodes(data=True)
+        )
+        assert nodes_equal(G.nodes(), [0, 1, 2])
+        assert nodes_equal(G.nodes(data=True), [(0, {}), (1, {"foo": "bar"}), (2, {})])
+        G.nodes[1]["foo"] = "baz"
+        assert nodes_equal(G.nodes(data=True), [(0, {}), (1, {"foo": "baz"}), (2, {})])
+        assert nodes_equal(G.nodes(data="foo"), [(0, None), (1, "baz"), (2, None)])
+        assert nodes_equal(
+            G.nodes(data="foo", default="bar"), [(0, "bar"), (1, "baz"), (2, "bar")]
+        )
+
+    def test_node_attr2(self):
+        G = self.K3.copy()
+        a = {"foo": "bar"}
+        G.add_node(3, **a)
+        assert nodes_equal(G.nodes(), [0, 1, 2, 3])
+        assert nodes_equal(
+            G.nodes(data=True), [(0, {}), (1, {}), (2, {}), (3, {"foo": "bar"})]
+        )
+
+    def test_edge_lookup(self):
+        G = self.Graph()
+        G.add_edge(1, 2, foo="bar")
+        assert edges_equal(G.edges[1, 2], {"foo": "bar"})
+
+    def test_edge_attr(self):
+        G = self.Graph()
+        G.add_edge(1, 2, foo="bar")
+        assert all(
+            isinstance(d, G.edge_attr_dict_factory) for u, v, d in G.edges(data=True)
+        )
+        assert edges_equal(G.edges(data=True), [(1, 2, {"foo": "bar"})])
+        assert edges_equal(G.edges(data="foo"), [(1, 2, "bar")])
+
+    def test_edge_attr2(self):
+        G = self.Graph()
+        G.add_edges_from([(1, 2), (3, 4)], foo="foo")
+        assert edges_equal(
+            G.edges(data=True), [(1, 2, {"foo": "foo"}), (3, 4, {"foo": "foo"})]
+        )
+        assert edges_equal(G.edges(data="foo"), [(1, 2, "foo"), (3, 4, "foo")])
+
+    def test_edge_attr3(self):
+        G = self.Graph()
+        G.add_edges_from([(1, 2, {"weight": 32}), (3, 4, {"weight": 64})], foo="foo")
+        assert edges_equal(
+            G.edges(data=True),
+            [
+                (1, 2, {"foo": "foo", "weight": 32}),
+                (3, 4, {"foo": "foo", "weight": 64}),
+            ],
+        )
+
+        G.remove_edges_from([(1, 2), (3, 4)])
+        G.add_edge(1, 2, data=7, spam="bar", bar="foo")
+        assert edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 7, "spam": "bar", "bar": "foo"})]
+        )
+
+    def test_edge_attr4(self):
+        G = self.Graph()
+        G.add_edge(1, 2, data=7, spam="bar", bar="foo")
+        assert edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 7, "spam": "bar", "bar": "foo"})]
+        )
+        G[1][2]["data"] = 10  # OK to set data like this
+        assert edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 10, "spam": "bar", "bar": "foo"})]
+        )
+
+        G.adj[1][2]["data"] = 20
+        assert edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 20, "spam": "bar", "bar": "foo"})]
+        )
+        G.edges[1, 2]["data"] = 21  # another spelling, "edge"
+        assert edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 21, "spam": "bar", "bar": "foo"})]
+        )
+        G.adj[1][2]["listdata"] = [20, 200]
+        G.adj[1][2]["weight"] = 20
+        dd = {
+            "data": 21,
+            "spam": "bar",
+            "bar": "foo",
+            "listdata": [20, 200],
+            "weight": 20,
+        }
+        assert edges_equal(G.edges(data=True), [(1, 2, dd)])
+
+    def test_to_undirected(self):
+        G = self.K3
+        self.add_attributes(G)
+        H = nx.Graph(G)
+        self.is_shallow_copy(H, G)
+        self.different_attrdict(H, G)
+        H = G.to_undirected()
+        self.is_deepcopy(H, G)
+
+    def test_to_directed_as_view(self):
+        H = nx.path_graph(2, create_using=self.Graph)
+        H2 = H.to_directed(as_view=True)
+        assert H is H2._graph
+        assert H2.has_edge(0, 1)
+        assert H2.has_edge(1, 0) or H.is_directed()
+        pytest.raises(nx.NetworkXError, H2.add_node, -1)
+        pytest.raises(nx.NetworkXError, H2.add_edge, 1, 2)
+        H.add_edge(1, 2)
+        assert H2.has_edge(1, 2)
+        assert H2.has_edge(2, 1) or H.is_directed()
+
+    def test_to_undirected_as_view(self):
+        H = nx.path_graph(2, create_using=self.Graph)
+        H2 = H.to_undirected(as_view=True)
+        assert H is H2._graph
+        assert H2.has_edge(0, 1)
+        assert H2.has_edge(1, 0)
+        pytest.raises(nx.NetworkXError, H2.add_node, -1)
+        pytest.raises(nx.NetworkXError, H2.add_edge, 1, 2)
+        H.add_edge(1, 2)
+        assert H2.has_edge(1, 2)
+        assert H2.has_edge(2, 1)
+
+    def test_directed_class(self):
+        G = self.Graph()
+
+        class newGraph(G.to_undirected_class()):
+            def to_directed_class(self):
+                return newDiGraph
+
+            def to_undirected_class(self):
+                return newGraph
+
+        class newDiGraph(G.to_directed_class()):
+            def to_directed_class(self):
+                return newDiGraph
+
+            def to_undirected_class(self):
+                return newGraph
+
+        G = newDiGraph() if G.is_directed() else newGraph()
+        H = G.to_directed()
+        assert isinstance(H, newDiGraph)
+        H = G.to_undirected()
+        assert isinstance(H, newGraph)
+
+    def test_to_directed(self):
+        G = self.K3
+        self.add_attributes(G)
+        H = nx.DiGraph(G)
+        self.is_shallow_copy(H, G)
+        self.different_attrdict(H, G)
+        H = G.to_directed()
+        self.is_deepcopy(H, G)
+
+    def test_subgraph(self):
+        G = self.K3
+        self.add_attributes(G)
+        H = G.subgraph([0, 1, 2, 5])
+        self.graphs_equal(H, G)
+        self.same_attrdict(H, G)
+        self.shallow_copy_attrdict(H, G)
+
+        H = G.subgraph(0)
+        assert H.adj == {0: {}}
+        H = G.subgraph([])
+        assert H.adj == {}
+        assert G.adj != {}
+
+    def test_selfloops_attr(self):
+        G = self.K3.copy()
+        G.add_edge(0, 0)
+        G.add_edge(1, 1, weight=2)
+        assert edges_equal(
+            nx.selfloop_edges(G, data=True), [(0, 0, {}), (1, 1, {"weight": 2})]
+        )
+        assert edges_equal(
+            nx.selfloop_edges(G, data="weight"), [(0, 0, None), (1, 1, 2)]
+        )
+
+
+class TestGraph(BaseAttrGraphTester):
+    """Tests specific to dict-of-dict-of-dict graph data structure"""
+
+    def setup_method(self):
+        self.Graph = nx.Graph
+        # build dict-of-dict-of-dict K3
+        ed1, ed2, ed3 = ({}, {}, {})
+        self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed1, 2: ed3}, 2: {0: ed2, 1: ed3}}
+        self.k3edges = [(0, 1), (0, 2), (1, 2)]
+        self.k3nodes = [0, 1, 2]
+        self.K3 = self.Graph()
+        self.K3._adj = self.k3adj
+        self.K3._node = {}
+        self.K3._node[0] = {}
+        self.K3._node[1] = {}
+        self.K3._node[2] = {}
+
+    def test_pickle(self):
+        G = self.K3
+        pg = pickle.loads(pickle.dumps(G, -1))
+        self.graphs_equal(pg, G)
+        pg = pickle.loads(pickle.dumps(G))
+        self.graphs_equal(pg, G)
+
+    def test_data_input(self):
+        G = self.Graph({1: [2], 2: [1]}, name="test")
+        assert G.name == "test"
+        assert sorted(G.adj.items()) == [(1, {2: {}}), (2, {1: {}})]
+
+    def test_adjacency(self):
+        G = self.K3
+        assert dict(G.adjacency()) == {
+            0: {1: {}, 2: {}},
+            1: {0: {}, 2: {}},
+            2: {0: {}, 1: {}},
+        }
+
+    def test_getitem(self):
+        G = self.K3
+        assert G.adj[0] == {1: {}, 2: {}}
+        assert G[0] == {1: {}, 2: {}}
+        with pytest.raises(KeyError):
+            G.__getitem__("j")
+        with pytest.raises(TypeError):
+            G.__getitem__(["A"])
+
+    def test_add_node(self):
+        G = self.Graph()
+        G.add_node(0)
+        assert G.adj == {0: {}}
+        # test add attributes
+        G.add_node(1, c="red")
+        G.add_node(2, c="blue")
+        G.add_node(3, c="red")
+        assert G.nodes[1]["c"] == "red"
+        assert G.nodes[2]["c"] == "blue"
+        assert G.nodes[3]["c"] == "red"
+        # test updating attributes
+        G.add_node(1, c="blue")
+        G.add_node(2, c="red")
+        G.add_node(3, c="blue")
+        assert G.nodes[1]["c"] == "blue"
+        assert G.nodes[2]["c"] == "red"
+        assert G.nodes[3]["c"] == "blue"
+
+    def test_add_nodes_from(self):
+        G = self.Graph()
+        G.add_nodes_from([0, 1, 2])
+        assert G.adj == {0: {}, 1: {}, 2: {}}
+        # test add attributes
+        G.add_nodes_from([0, 1, 2], c="red")
+        assert G.nodes[0]["c"] == "red"
+        assert G.nodes[2]["c"] == "red"
+        # test that attribute dicts are not the same
+        assert G.nodes[0] is not G.nodes[1]
+        # test updating attributes
+        G.add_nodes_from([0, 1, 2], c="blue")
+        assert G.nodes[0]["c"] == "blue"
+        assert G.nodes[2]["c"] == "blue"
+        assert G.nodes[0] is not G.nodes[1]
+        # test tuple input
+        H = self.Graph()
+        H.add_nodes_from(G.nodes(data=True))
+        assert H.nodes[0]["c"] == "blue"
+        assert H.nodes[2]["c"] == "blue"
+        assert H.nodes[0] is not H.nodes[1]
+        # specific overrides general
+        H.add_nodes_from([0, (1, {"c": "green"}), (3, {"c": "cyan"})], c="red")
+        assert H.nodes[0]["c"] == "red"
+        assert H.nodes[1]["c"] == "green"
+        assert H.nodes[2]["c"] == "blue"
+        assert H.nodes[3]["c"] == "cyan"
+
+    def test_remove_node(self):
+        G = self.K3.copy()
+        G.remove_node(0)
+        assert G.adj == {1: {2: {}}, 2: {1: {}}}
+        with pytest.raises(nx.NetworkXError):
+            G.remove_node(-1)
+
+        # generator here to implement list,set,string...
+
+    def test_remove_nodes_from(self):
+        G = self.K3.copy()
+        G.remove_nodes_from([0, 1])
+        assert G.adj == {2: {}}
+        G.remove_nodes_from([-1])  # silent fail
+
+    def test_add_edge(self):
+        G = self.Graph()
+        G.add_edge(0, 1)
+        assert G.adj == {0: {1: {}}, 1: {0: {}}}
+        G = self.Graph()
+        G.add_edge(*(0, 1))
+        assert G.adj == {0: {1: {}}, 1: {0: {}}}
+
+    def test_add_edges_from(self):
+        G = self.Graph()
+        G.add_edges_from([(0, 1), (0, 2, {"weight": 3})])
+        assert G.adj == {
+            0: {1: {}, 2: {"weight": 3}},
+            1: {0: {}},
+            2: {0: {"weight": 3}},
+        }
+        G = self.Graph()
+        G.add_edges_from([(0, 1), (0, 2, {"weight": 3}), (1, 2, {"data": 4})], data=2)
+        assert G.adj == {
+            0: {1: {"data": 2}, 2: {"weight": 3, "data": 2}},
+            1: {0: {"data": 2}, 2: {"data": 4}},
+            2: {0: {"weight": 3, "data": 2}, 1: {"data": 4}},
+        }
+
+        with pytest.raises(nx.NetworkXError):
+            G.add_edges_from([(0,)])  # too few in tuple
+        with pytest.raises(nx.NetworkXError):
+            G.add_edges_from([(0, 1, 2, 3)])  # too many in tuple
+        with pytest.raises(TypeError):
+            G.add_edges_from([0])  # not a tuple
+
+    def test_remove_edge(self):
+        G = self.K3.copy()
+        G.remove_edge(0, 1)
+        assert G.adj == {0: {2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}}
+        with pytest.raises(nx.NetworkXError):
+            G.remove_edge(-1, 0)
+
+    def test_remove_edges_from(self):
+        G = self.K3.copy()
+        G.remove_edges_from([(0, 1)])
+        assert G.adj == {0: {2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}}
+        G.remove_edges_from([(0, 0)])  # silent fail
+
+    def test_clear(self):
+        G = self.K3.copy()
+        G.graph["name"] = "K3"
+        G.clear()
+        assert list(G.nodes) == []
+        assert G.adj == {}
+        assert G.graph == {}
+
+    def test_clear_edges(self):
+        G = self.K3.copy()
+        G.graph["name"] = "K3"
+        nodes = list(G.nodes)
+        G.clear_edges()
+        assert list(G.nodes) == nodes
+        assert G.adj == {0: {}, 1: {}, 2: {}}
+        assert list(G.edges) == []
+        assert G.graph["name"] == "K3"
+
+    def test_edges_data(self):
+        G = self.K3
+        all_edges = [(0, 1, {}), (0, 2, {}), (1, 2, {})]
+        assert edges_equal(G.edges(data=True), all_edges)
+        assert edges_equal(G.edges(0, data=True), [(0, 1, {}), (0, 2, {})])
+        assert edges_equal(G.edges([0, 1], data=True), all_edges)
+        with pytest.raises(nx.NetworkXError):
+            G.edges(-1, True)
+
+    def test_get_edge_data(self):
+        G = self.K3.copy()
+        assert G.get_edge_data(0, 1) == {}
+        assert G[0][1] == {}
+        assert G.get_edge_data(10, 20) is None
+        assert G.get_edge_data(-1, 0) is None
+        assert G.get_edge_data(-1, 0, default=1) == 1
+
+    def test_update(self):
+        # specify both edgees and nodes
+        G = self.K3.copy()
+        G.update(nodes=[3, (4, {"size": 2})], edges=[(4, 5), (6, 7, {"weight": 2})])
+        nlist = [
+            (0, {}),
+            (1, {}),
+            (2, {}),
+            (3, {}),
+            (4, {"size": 2}),
+            (5, {}),
+            (6, {}),
+            (7, {}),
+        ]
+        assert sorted(G.nodes.data()) == nlist
+        if G.is_directed():
+            elist = [
+                (0, 1, {}),
+                (0, 2, {}),
+                (1, 0, {}),
+                (1, 2, {}),
+                (2, 0, {}),
+                (2, 1, {}),
+                (4, 5, {}),
+                (6, 7, {"weight": 2}),
+            ]
+        else:
+            elist = [
+                (0, 1, {}),
+                (0, 2, {}),
+                (1, 2, {}),
+                (4, 5, {}),
+                (6, 7, {"weight": 2}),
+            ]
+        assert sorted(G.edges.data()) == elist
+        assert G.graph == {}
+
+        # no keywords -- order is edges, nodes
+        G = self.K3.copy()
+        G.update([(4, 5), (6, 7, {"weight": 2})], [3, (4, {"size": 2})])
+        assert sorted(G.nodes.data()) == nlist
+        assert sorted(G.edges.data()) == elist
+        assert G.graph == {}
+
+        # update using only a graph
+        G = self.Graph()
+        G.graph["foo"] = "bar"
+        G.add_node(2, data=4)
+        G.add_edge(0, 1, weight=0.5)
+        GG = G.copy()
+        H = self.Graph()
+        GG.update(H)
+        assert graphs_equal(G, GG)
+        H.update(G)
+        assert graphs_equal(H, G)
+
+        # update nodes only
+        H = self.Graph()
+        H.update(nodes=[3, 4])
+        assert H.nodes ^ {3, 4} == set()
+        assert H.size() == 0
+
+        # update edges only
+        H = self.Graph()
+        H.update(edges=[(3, 4)])
+        assert sorted(H.edges.data()) == [(3, 4, {})]
+        assert H.size() == 1
+
+        # No inputs -> exception
+        with pytest.raises(nx.NetworkXError):
+            nx.Graph().update()
+
+
+class TestEdgeSubgraph:
+    """Unit tests for the :meth:`Graph.edge_subgraph` method."""
+
+    def setup_method(self):
+        # Create a path graph on five nodes.
+        G = nx.path_graph(5)
+        # Add some node, edge, and graph attributes.
+        for i in range(5):
+            G.nodes[i]["name"] = f"node{i}"
+        G.edges[0, 1]["name"] = "edge01"
+        G.edges[3, 4]["name"] = "edge34"
+        G.graph["name"] = "graph"
+        # Get the subgraph induced by the first and last edges.
+        self.G = G
+        self.H = G.edge_subgraph([(0, 1), (3, 4)])
+
+    def test_correct_nodes(self):
+        """Tests that the subgraph has the correct nodes."""
+        assert [0, 1, 3, 4] == sorted(self.H.nodes())
+
+    def test_correct_edges(self):
+        """Tests that the subgraph has the correct edges."""
+        assert [(0, 1, "edge01"), (3, 4, "edge34")] == sorted(self.H.edges(data="name"))
+
+    def test_add_node(self):
+        """Tests that adding a node to the original graph does not
+        affect the nodes of the subgraph.
+
+        """
+        self.G.add_node(5)
+        assert [0, 1, 3, 4] == sorted(self.H.nodes())
+
+    def test_remove_node(self):
+        """Tests that removing a node in the original graph does
+        affect the nodes of the subgraph.
+
+        """
+        self.G.remove_node(0)
+        assert [1, 3, 4] == sorted(self.H.nodes())
+
+    def test_node_attr_dict(self):
+        """Tests that the node attribute dictionary of the two graphs is
+        the same object.
+
+        """
+        for v in self.H:
+            assert self.G.nodes[v] == self.H.nodes[v]
+        # Making a change to G should make a change in H and vice versa.
+        self.G.nodes[0]["name"] = "foo"
+        assert self.G.nodes[0] == self.H.nodes[0]
+        self.H.nodes[1]["name"] = "bar"
+        assert self.G.nodes[1] == self.H.nodes[1]
+
+    def test_edge_attr_dict(self):
+        """Tests that the edge attribute dictionary of the two graphs is
+        the same object.
+
+        """
+        for u, v in self.H.edges():
+            assert self.G.edges[u, v] == self.H.edges[u, v]
+        # Making a change to G should make a change in H and vice versa.
+        self.G.edges[0, 1]["name"] = "foo"
+        assert self.G.edges[0, 1]["name"] == self.H.edges[0, 1]["name"]
+        self.H.edges[3, 4]["name"] = "bar"
+        assert self.G.edges[3, 4]["name"] == self.H.edges[3, 4]["name"]
+
+    def test_graph_attr_dict(self):
+        """Tests that the graph attribute dictionary of the two graphs
+        is the same object.
+
+        """
+        assert self.G.graph is self.H.graph
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_graph_historical.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_graph_historical.py
new file mode 100644
index 0000000..7af081c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_graph_historical.py
@@ -0,0 +1,12 @@
+"""Original NetworkX graph tests"""
+import networkx
+import networkx as nx
+
+from .historical_tests import HistoricalTests
+
+
+class TestGraphHistorical(HistoricalTests):
+    @classmethod
+    def setup_class(cls):
+        HistoricalTests.setup_class()
+        cls.G = nx.Graph
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_graphviews.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_graphviews.py
new file mode 100644
index 0000000..96a0978
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_graphviews.py
@@ -0,0 +1,352 @@
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, nodes_equal
+
+# Note: SubGraph views are not tested here. They have their own testing file
+
+
+class TestReverseView:
+    def setup(self):
+        self.G = nx.path_graph(9, create_using=nx.DiGraph())
+        self.rv = nx.reverse_view(self.G)
+
+    def test_pickle(self):
+        import pickle
+
+        rv = self.rv
+        prv = pickle.loads(pickle.dumps(rv, -1))
+        assert rv._node == prv._node
+        assert rv._adj == prv._adj
+        assert rv.graph == prv.graph
+
+    def test_contains(self):
+        assert (2, 3) in self.G.edges
+        assert (3, 2) not in self.G.edges
+        assert (2, 3) not in self.rv.edges
+        assert (3, 2) in self.rv.edges
+
+    def test_iter(self):
+        expected = sorted(tuple(reversed(e)) for e in self.G.edges)
+        assert sorted(self.rv.edges) == expected
+
+    def test_exceptions(self):
+        nxg = nx.graphviews
+        G = nx.Graph()
+        pytest.raises(nx.NetworkXNotImplemented, nxg.reverse_view, G)
+
+    def test_subclass(self):
+        class MyGraph(nx.DiGraph):
+            def my_method(self):
+                return "me"
+
+            def to_directed_class(self):
+                return MyGraph()
+
+        M = MyGraph()
+        M.add_edge(1, 2)
+        RM = nx.reverse_view(M)
+        print("RM class", RM.__class__)
+        RMC = RM.copy()
+        print("RMC class", RMC.__class__)
+        print(RMC.edges)
+        assert RMC.has_edge(2, 1)
+        assert RMC.my_method() == "me"
+
+
+class TestMultiReverseView:
+    def setup(self):
+        self.G = nx.path_graph(9, create_using=nx.MultiDiGraph())
+        self.G.add_edge(4, 5)
+        self.rv = nx.reverse_view(self.G)
+
+    def test_pickle(self):
+        import pickle
+
+        rv = self.rv
+        prv = pickle.loads(pickle.dumps(rv, -1))
+        assert rv._node == prv._node
+        assert rv._adj == prv._adj
+        assert rv.graph == prv.graph
+
+    def test_contains(self):
+        assert (2, 3, 0) in self.G.edges
+        assert (3, 2, 0) not in self.G.edges
+        assert (2, 3, 0) not in self.rv.edges
+        assert (3, 2, 0) in self.rv.edges
+        assert (5, 4, 1) in self.rv.edges
+        assert (4, 5, 1) not in self.rv.edges
+
+    def test_iter(self):
+        expected = sorted((v, u, k) for u, v, k in self.G.edges)
+        assert sorted(self.rv.edges) == expected
+
+    def test_exceptions(self):
+        nxg = nx.graphviews
+        MG = nx.MultiGraph(self.G)
+        pytest.raises(nx.NetworkXNotImplemented, nxg.reverse_view, MG)
+
+
+def test_generic_multitype():
+    nxg = nx.graphviews
+    G = nx.DiGraph([(1, 2)])
+    with pytest.raises(nx.NetworkXError):
+        nxg.generic_graph_view(G, create_using=nx.MultiGraph)
+    G = nx.MultiDiGraph([(1, 2)])
+    with pytest.raises(nx.NetworkXError):
+        nxg.generic_graph_view(G, create_using=nx.DiGraph)
+
+
+class TestToDirected:
+    def setup(self):
+        self.G = nx.path_graph(9)
+        self.dv = nx.to_directed(self.G)
+        self.MG = nx.path_graph(9, create_using=nx.MultiGraph())
+        self.Mdv = nx.to_directed(self.MG)
+
+    def test_directed(self):
+        assert not self.G.is_directed()
+        assert self.dv.is_directed()
+
+    def test_already_directed(self):
+        dd = nx.to_directed(self.dv)
+        Mdd = nx.to_directed(self.Mdv)
+        assert edges_equal(dd.edges, self.dv.edges)
+        assert edges_equal(Mdd.edges, self.Mdv.edges)
+
+    def test_pickle(self):
+        import pickle
+
+        dv = self.dv
+        pdv = pickle.loads(pickle.dumps(dv, -1))
+        assert dv._node == pdv._node
+        assert dv._succ == pdv._succ
+        assert dv._pred == pdv._pred
+        assert dv.graph == pdv.graph
+
+    def test_contains(self):
+        assert (2, 3) in self.G.edges
+        assert (3, 2) in self.G.edges
+        assert (2, 3) in self.dv.edges
+        assert (3, 2) in self.dv.edges
+
+    def test_iter(self):
+        revd = [tuple(reversed(e)) for e in self.G.edges]
+        expected = sorted(list(self.G.edges) + revd)
+        assert sorted(self.dv.edges) == expected
+
+
+class TestToUndirected:
+    def setup(self):
+        self.DG = nx.path_graph(9, create_using=nx.DiGraph())
+        self.uv = nx.to_undirected(self.DG)
+        self.MDG = nx.path_graph(9, create_using=nx.MultiDiGraph())
+        self.Muv = nx.to_undirected(self.MDG)
+
+    def test_directed(self):
+        assert self.DG.is_directed()
+        assert not self.uv.is_directed()
+
+    def test_already_directed(self):
+        uu = nx.to_undirected(self.uv)
+        Muu = nx.to_undirected(self.Muv)
+        assert edges_equal(uu.edges, self.uv.edges)
+        assert edges_equal(Muu.edges, self.Muv.edges)
+
+    def test_pickle(self):
+        import pickle
+
+        uv = self.uv
+        puv = pickle.loads(pickle.dumps(uv, -1))
+        assert uv._node == puv._node
+        assert uv._adj == puv._adj
+        assert uv.graph == puv.graph
+        assert hasattr(uv, "_graph")
+
+    def test_contains(self):
+        assert (2, 3) in self.DG.edges
+        assert (3, 2) not in self.DG.edges
+        assert (2, 3) in self.uv.edges
+        assert (3, 2) in self.uv.edges
+
+    def test_iter(self):
+        expected = sorted(self.DG.edges)
+        assert sorted(self.uv.edges) == expected
+
+
+class TestChainsOfViews:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9)
+        cls.DG = nx.path_graph(9, create_using=nx.DiGraph())
+        cls.MG = nx.path_graph(9, create_using=nx.MultiGraph())
+        cls.MDG = nx.path_graph(9, create_using=nx.MultiDiGraph())
+        cls.Gv = nx.to_undirected(cls.DG)
+        cls.DGv = nx.to_directed(cls.G)
+        cls.MGv = nx.to_undirected(cls.MDG)
+        cls.MDGv = nx.to_directed(cls.MG)
+        cls.Rv = cls.DG.reverse()
+        cls.MRv = cls.MDG.reverse()
+        cls.graphs = [
+            cls.G,
+            cls.DG,
+            cls.MG,
+            cls.MDG,
+            cls.Gv,
+            cls.DGv,
+            cls.MGv,
+            cls.MDGv,
+            cls.Rv,
+            cls.MRv,
+        ]
+        for G in cls.graphs:
+            G.edges, G.nodes, G.degree
+
+    def test_pickle(self):
+        import pickle
+
+        for G in self.graphs:
+            H = pickle.loads(pickle.dumps(G, -1))
+            assert edges_equal(H.edges, G.edges)
+            assert nodes_equal(H.nodes, G.nodes)
+
+    def test_subgraph_of_subgraph(self):
+        SGv = nx.subgraph(self.G, range(3, 7))
+        SDGv = nx.subgraph(self.DG, range(3, 7))
+        SMGv = nx.subgraph(self.MG, range(3, 7))
+        SMDGv = nx.subgraph(self.MDG, range(3, 7))
+        for G in self.graphs + [SGv, SDGv, SMGv, SMDGv]:
+            SG = nx.induced_subgraph(G, [4, 5, 6])
+            assert list(SG) == [4, 5, 6]
+            SSG = SG.subgraph([6, 7])
+            assert list(SSG) == [6]
+            # subgraph-subgraph chain is short-cut in base class method
+            assert SSG._graph is G
+
+    def test_restricted_induced_subgraph_chains(self):
+        """Test subgraph chains that both restrict and show nodes/edges.
+
+        A restricted_view subgraph should allow induced subgraphs using
+        G.subgraph that automagically without a chain (meaning the result
+        is a subgraph view of the original graph not a subgraph-of-subgraph.
+        """
+        hide_nodes = [3, 4, 5]
+        hide_edges = [(6, 7)]
+        RG = nx.restricted_view(self.G, hide_nodes, hide_edges)
+        nodes = [4, 5, 6, 7, 8]
+        SG = nx.induced_subgraph(RG, nodes)
+        SSG = RG.subgraph(nodes)
+        assert RG._graph is self.G
+        assert SSG._graph is self.G
+        assert SG._graph is RG
+        assert edges_equal(SG.edges, SSG.edges)
+        # should be same as morphing the graph
+        CG = self.G.copy()
+        CG.remove_nodes_from(hide_nodes)
+        CG.remove_edges_from(hide_edges)
+        assert edges_equal(CG.edges(nodes), SSG.edges)
+        CG.remove_nodes_from([0, 1, 2, 3])
+        assert edges_equal(CG.edges, SSG.edges)
+        # switch order: subgraph first, then restricted view
+        SSSG = self.G.subgraph(nodes)
+        RSG = nx.restricted_view(SSSG, hide_nodes, hide_edges)
+        assert RSG._graph is not self.G
+        assert edges_equal(RSG.edges, CG.edges)
+
+    def test_subgraph_copy(self):
+        for origG in self.graphs:
+            G = nx.OrderedGraph(origG)
+            SG = G.subgraph([4, 5, 6])
+            H = SG.copy()
+            assert type(G) == type(H)
+
+    def test_subgraph_todirected(self):
+        SG = nx.induced_subgraph(self.G, [4, 5, 6])
+        SSG = SG.to_directed()
+        assert sorted(SSG) == [4, 5, 6]
+        assert sorted(SSG.edges) == [(4, 5), (5, 4), (5, 6), (6, 5)]
+
+    def test_subgraph_toundirected(self):
+        SG = nx.induced_subgraph(self.G, [4, 5, 6])
+        SSG = SG.to_undirected()
+        assert list(SSG) == [4, 5, 6]
+        assert sorted(SSG.edges) == [(4, 5), (5, 6)]
+
+    def test_reverse_subgraph_toundirected(self):
+        G = self.DG.reverse(copy=False)
+        SG = G.subgraph([4, 5, 6])
+        SSG = SG.to_undirected()
+        assert list(SSG) == [4, 5, 6]
+        assert sorted(SSG.edges) == [(4, 5), (5, 6)]
+
+    def test_reverse_reverse_copy(self):
+        G = self.DG.reverse(copy=False)
+        H = G.reverse(copy=True)
+        assert H.nodes == self.DG.nodes
+        assert H.edges == self.DG.edges
+        G = self.MDG.reverse(copy=False)
+        H = G.reverse(copy=True)
+        assert H.nodes == self.MDG.nodes
+        assert H.edges == self.MDG.edges
+
+    def test_subgraph_edgesubgraph_toundirected(self):
+        G = self.G.copy()
+        SG = G.subgraph([4, 5, 6])
+        SSG = SG.edge_subgraph([(4, 5), (5, 4)])
+        USSG = SSG.to_undirected()
+        assert list(USSG) == [4, 5]
+        assert sorted(USSG.edges) == [(4, 5)]
+
+    def test_copy_subgraph(self):
+        G = self.G.copy()
+        SG = G.subgraph([4, 5, 6])
+        CSG = SG.copy(as_view=True)
+        DCSG = SG.copy(as_view=False)
+        assert hasattr(CSG, "_graph")  # is a view
+        assert not hasattr(DCSG, "_graph")  # not a view
+
+    def test_copy_disubgraph(self):
+        G = self.DG.copy()
+        SG = G.subgraph([4, 5, 6])
+        CSG = SG.copy(as_view=True)
+        DCSG = SG.copy(as_view=False)
+        assert hasattr(CSG, "_graph")  # is a view
+        assert not hasattr(DCSG, "_graph")  # not a view
+
+    def test_copy_multidisubgraph(self):
+        G = self.MDG.copy()
+        SG = G.subgraph([4, 5, 6])
+        CSG = SG.copy(as_view=True)
+        DCSG = SG.copy(as_view=False)
+        assert hasattr(CSG, "_graph")  # is a view
+        assert not hasattr(DCSG, "_graph")  # not a view
+
+    def test_copy_multisubgraph(self):
+        G = self.MG.copy()
+        SG = G.subgraph([4, 5, 6])
+        CSG = SG.copy(as_view=True)
+        DCSG = SG.copy(as_view=False)
+        assert hasattr(CSG, "_graph")  # is a view
+        assert not hasattr(DCSG, "_graph")  # not a view
+
+    def test_copy_of_view(self):
+        G = nx.OrderedMultiGraph(self.MGv)
+        assert G.__class__.__name__ == "OrderedMultiGraph"
+        G = G.copy(as_view=True)
+        assert G.__class__.__name__ == "OrderedMultiGraph"
+
+    def test_subclass(self):
+        class MyGraph(nx.DiGraph):
+            def my_method(self):
+                return "me"
+
+            def to_directed_class(self):
+                return MyGraph()
+
+        for origG in self.graphs:
+            G = MyGraph(origG)
+            SG = G.subgraph([4, 5, 6])
+            H = SG.copy()
+            assert SG.my_method() == "me"
+            assert H.my_method() == "me"
+            assert not 3 in H or 3 in SG
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_multidigraph.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_multidigraph.py
new file mode 100644
index 0000000..52c8267
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_multidigraph.py
@@ -0,0 +1,455 @@
+from collections import UserDict
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal
+
+from .test_multigraph import BaseMultiGraphTester
+from .test_multigraph import TestEdgeSubgraph as _TestMultiGraphEdgeSubgraph
+from .test_multigraph import TestMultiGraph as _TestMultiGraph
+
+
+class BaseMultiDiGraphTester(BaseMultiGraphTester):
+    def test_edges(self):
+        G = self.K3
+        edges = [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
+        assert sorted(G.edges()) == edges
+        assert sorted(G.edges(0)) == [(0, 1), (0, 2)]
+        pytest.raises((KeyError, nx.NetworkXError), G.edges, -1)
+
+    def test_edges_data(self):
+        G = self.K3
+        edges = [(0, 1, {}), (0, 2, {}), (1, 0, {}), (1, 2, {}), (2, 0, {}), (2, 1, {})]
+        assert sorted(G.edges(data=True)) == edges
+        assert sorted(G.edges(0, data=True)) == [(0, 1, {}), (0, 2, {})]
+        pytest.raises((KeyError, nx.NetworkXError), G.neighbors, -1)
+
+    def test_edges_multi(self):
+        G = self.K3
+        assert sorted(G.edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
+        assert sorted(G.edges(0)) == [(0, 1), (0, 2)]
+        G.add_edge(0, 1)
+        assert sorted(G.edges()) == [
+            (0, 1),
+            (0, 1),
+            (0, 2),
+            (1, 0),
+            (1, 2),
+            (2, 0),
+            (2, 1),
+        ]
+
+    def test_out_edges(self):
+        G = self.K3
+        assert sorted(G.out_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
+        assert sorted(G.out_edges(0)) == [(0, 1), (0, 2)]
+        pytest.raises((KeyError, nx.NetworkXError), G.out_edges, -1)
+        assert sorted(G.out_edges(0, keys=True)) == [(0, 1, 0), (0, 2, 0)]
+
+    def test_out_edges_multi(self):
+        G = self.K3
+        assert sorted(G.out_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
+        assert sorted(G.out_edges(0)) == [(0, 1), (0, 2)]
+        G.add_edge(0, 1, 2)
+        assert sorted(G.out_edges()) == [
+            (0, 1),
+            (0, 1),
+            (0, 2),
+            (1, 0),
+            (1, 2),
+            (2, 0),
+            (2, 1),
+        ]
+
+    def test_out_edges_data(self):
+        G = self.K3
+        assert sorted(G.edges(0, data=True)) == [(0, 1, {}), (0, 2, {})]
+        G.remove_edge(0, 1)
+        G.add_edge(0, 1, data=1)
+        assert sorted(G.edges(0, data=True)) == [(0, 1, {"data": 1}), (0, 2, {})]
+        assert sorted(G.edges(0, data="data")) == [(0, 1, 1), (0, 2, None)]
+        assert sorted(G.edges(0, data="data", default=-1)) == [(0, 1, 1), (0, 2, -1)]
+
+    def test_in_edges(self):
+        G = self.K3
+        assert sorted(G.in_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
+        assert sorted(G.in_edges(0)) == [(1, 0), (2, 0)]
+        pytest.raises((KeyError, nx.NetworkXError), G.in_edges, -1)
+        G.add_edge(0, 1, 2)
+        assert sorted(G.in_edges()) == [
+            (0, 1),
+            (0, 1),
+            (0, 2),
+            (1, 0),
+            (1, 2),
+            (2, 0),
+            (2, 1),
+        ]
+        assert sorted(G.in_edges(0, keys=True)) == [(1, 0, 0), (2, 0, 0)]
+
+    def test_in_edges_no_keys(self):
+        G = self.K3
+        assert sorted(G.in_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
+        assert sorted(G.in_edges(0)) == [(1, 0), (2, 0)]
+        G.add_edge(0, 1, 2)
+        assert sorted(G.in_edges()) == [
+            (0, 1),
+            (0, 1),
+            (0, 2),
+            (1, 0),
+            (1, 2),
+            (2, 0),
+            (2, 1),
+        ]
+
+        assert sorted(G.in_edges(data=True, keys=False)) == [
+            (0, 1, {}),
+            (0, 1, {}),
+            (0, 2, {}),
+            (1, 0, {}),
+            (1, 2, {}),
+            (2, 0, {}),
+            (2, 1, {}),
+        ]
+
+    def test_in_edges_data(self):
+        G = self.K3
+        assert sorted(G.in_edges(0, data=True)) == [(1, 0, {}), (2, 0, {})]
+        G.remove_edge(1, 0)
+        G.add_edge(1, 0, data=1)
+        assert sorted(G.in_edges(0, data=True)) == [(1, 0, {"data": 1}), (2, 0, {})]
+        assert sorted(G.in_edges(0, data="data")) == [(1, 0, 1), (2, 0, None)]
+        assert sorted(G.in_edges(0, data="data", default=-1)) == [(1, 0, 1), (2, 0, -1)]
+
+    def is_shallow(self, H, G):
+        # graph
+        assert G.graph["foo"] == H.graph["foo"]
+        G.graph["foo"].append(1)
+        assert G.graph["foo"] == H.graph["foo"]
+        # node
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
+        G.nodes[0]["foo"].append(1)
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
+        # edge
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
+        G[1][2][0]["foo"].append(1)
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
+
+    def is_deep(self, H, G):
+        # graph
+        assert G.graph["foo"] == H.graph["foo"]
+        G.graph["foo"].append(1)
+        assert G.graph["foo"] != H.graph["foo"]
+        # node
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
+        G.nodes[0]["foo"].append(1)
+        assert G.nodes[0]["foo"] != H.nodes[0]["foo"]
+        # edge
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
+        G[1][2][0]["foo"].append(1)
+        assert G[1][2][0]["foo"] != H[1][2][0]["foo"]
+
+    def test_to_undirected(self):
+        # MultiDiGraph -> MultiGraph changes number of edges so it is
+        # not a copy operation... use is_shallow, not is_shallow_copy
+        G = self.K3
+        self.add_attributes(G)
+        H = nx.MultiGraph(G)
+        # self.is_shallow(H,G)
+        # the result is traversal order dependent so we
+        # can't use the is_shallow() test here.
+        try:
+            assert edges_equal(H.edges(), [(0, 1), (1, 2), (2, 0)])
+        except AssertionError:
+            assert edges_equal(H.edges(), [(0, 1), (1, 2), (1, 2), (2, 0)])
+        H = G.to_undirected()
+        self.is_deep(H, G)
+
+    def test_has_successor(self):
+        G = self.K3
+        assert G.has_successor(0, 1)
+        assert not G.has_successor(0, -1)
+
+    def test_successors(self):
+        G = self.K3
+        assert sorted(G.successors(0)) == [1, 2]
+        pytest.raises((KeyError, nx.NetworkXError), G.successors, -1)
+
+    def test_has_predecessor(self):
+        G = self.K3
+        assert G.has_predecessor(0, 1)
+        assert not G.has_predecessor(0, -1)
+
+    def test_predecessors(self):
+        G = self.K3
+        assert sorted(G.predecessors(0)) == [1, 2]
+        pytest.raises((KeyError, nx.NetworkXError), G.predecessors, -1)
+
+    def test_degree(self):
+        G = self.K3
+        assert sorted(G.degree()) == [(0, 4), (1, 4), (2, 4)]
+        assert dict(G.degree()) == {0: 4, 1: 4, 2: 4}
+        assert G.degree(0) == 4
+        assert list(G.degree(iter([0]))) == [(0, 4)]
+        G.add_edge(0, 1, weight=0.3, other=1.2)
+        assert sorted(G.degree(weight="weight")) == [(0, 4.3), (1, 4.3), (2, 4)]
+        assert sorted(G.degree(weight="other")) == [(0, 5.2), (1, 5.2), (2, 4)]
+
+    def test_in_degree(self):
+        G = self.K3
+        assert sorted(G.in_degree()) == [(0, 2), (1, 2), (2, 2)]
+        assert dict(G.in_degree()) == {0: 2, 1: 2, 2: 2}
+        assert G.in_degree(0) == 2
+        assert list(G.in_degree(iter([0]))) == [(0, 2)]
+        assert G.in_degree(0, weight="weight") == 2
+
+    def test_out_degree(self):
+        G = self.K3
+        assert sorted(G.out_degree()) == [(0, 2), (1, 2), (2, 2)]
+        assert dict(G.out_degree()) == {0: 2, 1: 2, 2: 2}
+        assert G.out_degree(0) == 2
+        assert list(G.out_degree(iter([0]))) == [(0, 2)]
+        assert G.out_degree(0, weight="weight") == 2
+
+    def test_size(self):
+        G = self.K3
+        assert G.size() == 6
+        assert G.number_of_edges() == 6
+        G.add_edge(0, 1, weight=0.3, other=1.2)
+        assert round(G.size(weight="weight"), 2) == 6.3
+        assert round(G.size(weight="other"), 2) == 7.2
+
+    def test_to_undirected_reciprocal(self):
+        G = self.Graph()
+        G.add_edge(1, 2)
+        assert G.to_undirected().has_edge(1, 2)
+        assert not G.to_undirected(reciprocal=True).has_edge(1, 2)
+        G.add_edge(2, 1)
+        assert G.to_undirected(reciprocal=True).has_edge(1, 2)
+
+    def test_reverse_copy(self):
+        G = nx.MultiDiGraph([(0, 1), (0, 1)])
+        R = G.reverse()
+        assert sorted(R.edges()) == [(1, 0), (1, 0)]
+        R.remove_edge(1, 0)
+        assert sorted(R.edges()) == [(1, 0)]
+        assert sorted(G.edges()) == [(0, 1), (0, 1)]
+
+    def test_reverse_nocopy(self):
+        G = nx.MultiDiGraph([(0, 1), (0, 1)])
+        R = G.reverse(copy=False)
+        assert sorted(R.edges()) == [(1, 0), (1, 0)]
+        pytest.raises(nx.NetworkXError, R.remove_edge, 1, 0)
+
+    def test_di_attributes_cached(self):
+        G = self.K3.copy()
+        assert id(G.in_edges) == id(G.in_edges)
+        assert id(G.out_edges) == id(G.out_edges)
+        assert id(G.in_degree) == id(G.in_degree)
+        assert id(G.out_degree) == id(G.out_degree)
+        assert id(G.succ) == id(G.succ)
+        assert id(G.pred) == id(G.pred)
+
+
+class TestMultiDiGraph(BaseMultiDiGraphTester, _TestMultiGraph):
+    def setup_method(self):
+        self.Graph = nx.MultiDiGraph
+        # build K3
+        self.k3edges = [(0, 1), (0, 2), (1, 2)]
+        self.k3nodes = [0, 1, 2]
+        self.K3 = self.Graph()
+        self.K3._succ = {0: {}, 1: {}, 2: {}}
+        # K3._adj is synced with K3._succ
+        self.K3._pred = {0: {}, 1: {}, 2: {}}
+        for u in self.k3nodes:
+            for v in self.k3nodes:
+                if u == v:
+                    continue
+                d = {0: {}}
+                self.K3._succ[u][v] = d
+                self.K3._pred[v][u] = d
+        self.K3._node = {}
+        self.K3._node[0] = {}
+        self.K3._node[1] = {}
+        self.K3._node[2] = {}
+
+    def test_add_edge(self):
+        G = self.Graph()
+        G.add_edge(0, 1)
+        assert G._adj == {0: {1: {0: {}}}, 1: {}}
+        assert G._succ == {0: {1: {0: {}}}, 1: {}}
+        assert G._pred == {0: {}, 1: {0: {0: {}}}}
+        G = self.Graph()
+        G.add_edge(*(0, 1))
+        assert G._adj == {0: {1: {0: {}}}, 1: {}}
+        assert G._succ == {0: {1: {0: {}}}, 1: {}}
+        assert G._pred == {0: {}, 1: {0: {0: {}}}}
+
+    def test_add_edges_from(self):
+        G = self.Graph()
+        G.add_edges_from([(0, 1), (0, 1, {"weight": 3})])
+        assert G._adj == {0: {1: {0: {}, 1: {"weight": 3}}}, 1: {}}
+        assert G._succ == {0: {1: {0: {}, 1: {"weight": 3}}}, 1: {}}
+        assert G._pred == {0: {}, 1: {0: {0: {}, 1: {"weight": 3}}}}
+
+        G.add_edges_from([(0, 1), (0, 1, {"weight": 3})], weight=2)
+        assert G._succ == {
+            0: {1: {0: {}, 1: {"weight": 3}, 2: {"weight": 2}, 3: {"weight": 3}}},
+            1: {},
+        }
+        assert G._pred == {
+            0: {},
+            1: {0: {0: {}, 1: {"weight": 3}, 2: {"weight": 2}, 3: {"weight": 3}}},
+        }
+
+        G = self.Graph()
+        edges = [
+            (0, 1, {"weight": 3}),
+            (0, 1, (("weight", 2),)),
+            (0, 1, 5),
+            (0, 1, "s"),
+        ]
+        G.add_edges_from(edges)
+        keydict = {0: {"weight": 3}, 1: {"weight": 2}, 5: {}, "s": {}}
+        assert G._succ == {0: {1: keydict}, 1: {}}
+        assert G._pred == {1: {0: keydict}, 0: {}}
+
+        # too few in tuple
+        pytest.raises(nx.NetworkXError, G.add_edges_from, [(0,)])
+        # too many in tuple
+        pytest.raises(nx.NetworkXError, G.add_edges_from, [(0, 1, 2, 3, 4)])
+        # not a tuple
+        pytest.raises(TypeError, G.add_edges_from, [0])
+
+    def test_remove_edge(self):
+        G = self.K3
+        G.remove_edge(0, 1)
+        assert G._succ == {
+            0: {2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+        assert G._pred == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+        pytest.raises((KeyError, nx.NetworkXError), G.remove_edge, -1, 0)
+        pytest.raises((KeyError, nx.NetworkXError), G.remove_edge, 0, 2, key=1)
+
+    def test_remove_multiedge(self):
+        G = self.K3
+        G.add_edge(0, 1, key="parallel edge")
+        G.remove_edge(0, 1, key="parallel edge")
+        assert G._adj == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+
+        assert G._succ == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+
+        assert G._pred == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+        G.remove_edge(0, 1)
+        assert G._succ == {
+            0: {2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+        assert G._pred == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+        pytest.raises((KeyError, nx.NetworkXError), G.remove_edge, -1, 0)
+
+    def test_remove_edges_from(self):
+        G = self.K3
+        G.remove_edges_from([(0, 1)])
+        assert G._succ == {
+            0: {2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+        assert G._pred == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+        G.remove_edges_from([(0, 0)])  # silent fail
+
+
+class TestEdgeSubgraph(_TestMultiGraphEdgeSubgraph):
+    """Unit tests for the :meth:`MultiDiGraph.edge_subgraph` method."""
+
+    def setup_method(self):
+        # Create a quadruply-linked path graph on five nodes.
+        G = nx.MultiDiGraph()
+        nx.add_path(G, range(5))
+        nx.add_path(G, range(5))
+        nx.add_path(G, reversed(range(5)))
+        nx.add_path(G, reversed(range(5)))
+        # Add some node, edge, and graph attributes.
+        for i in range(5):
+            G.nodes[i]["name"] = f"node{i}"
+        G.adj[0][1][0]["name"] = "edge010"
+        G.adj[0][1][1]["name"] = "edge011"
+        G.adj[3][4][0]["name"] = "edge340"
+        G.adj[3][4][1]["name"] = "edge341"
+        G.graph["name"] = "graph"
+        # Get the subgraph induced by one of the first edges and one of
+        # the last edges.
+        self.G = G
+        self.H = G.edge_subgraph([(0, 1, 0), (3, 4, 1)])
+
+
+class CustomDictClass(UserDict):
+    pass
+
+
+class MultiDiGraphSubClass(nx.MultiDiGraph):
+    node_dict_factory = CustomDictClass  # type: ignore
+    node_attr_dict_factory = CustomDictClass  # type: ignore
+    adjlist_outer_dict_factory = CustomDictClass  # type: ignore
+    adjlist_inner_dict_factory = CustomDictClass  # type: ignore
+    edge_key_dict_factory = CustomDictClass  # type: ignore
+    edge_attr_dict_factory = CustomDictClass  # type: ignore
+    graph_attr_dict_factory = CustomDictClass  # type: ignore
+
+
+class TestMultiDiGraphSubclass(TestMultiDiGraph):
+    def setup_method(self):
+        self.Graph = MultiDiGraphSubClass
+        # build K3
+        self.k3edges = [(0, 1), (0, 2), (1, 2)]
+        self.k3nodes = [0, 1, 2]
+        self.K3 = self.Graph()
+        self.K3._succ = self.K3.adjlist_outer_dict_factory(
+            {
+                0: self.K3.adjlist_inner_dict_factory(),
+                1: self.K3.adjlist_inner_dict_factory(),
+                2: self.K3.adjlist_inner_dict_factory(),
+            }
+        )
+        # K3._adj is synced with K3._succ
+        self.K3._pred = {0: {}, 1: {}, 2: {}}
+        for u in self.k3nodes:
+            for v in self.k3nodes:
+                if u == v:
+                    continue
+                d = {0: {}}
+                self.K3._succ[u][v] = d
+                self.K3._pred[v][u] = d
+        self.K3._node = self.K3.node_dict_factory()
+        self.K3._node[0] = self.K3.node_attr_dict_factory()
+        self.K3._node[1] = self.K3.node_attr_dict_factory()
+        self.K3._node[2] = self.K3.node_attr_dict_factory()
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_multigraph.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_multigraph.py
new file mode 100644
index 0000000..0584f56
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_multigraph.py
@@ -0,0 +1,525 @@
+from collections import UserDict
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal
+
+from .test_graph import BaseAttrGraphTester
+from .test_graph import TestGraph as _TestGraph
+
+
+class BaseMultiGraphTester(BaseAttrGraphTester):
+    def test_has_edge(self):
+        G = self.K3
+        assert G.has_edge(0, 1)
+        assert not G.has_edge(0, -1)
+        assert G.has_edge(0, 1, 0)
+        assert not G.has_edge(0, 1, 1)
+
+    def test_get_edge_data(self):
+        G = self.K3
+        assert G.get_edge_data(0, 1) == {0: {}}
+        assert G[0][1] == {0: {}}
+        assert G[0][1][0] == {}
+        assert G.get_edge_data(10, 20) is None
+        assert G.get_edge_data(0, 1, 0) == {}
+
+    def test_adjacency(self):
+        G = self.K3
+        assert dict(G.adjacency()) == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+
+    def deepcopy_edge_attr(self, H, G):
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
+        G[1][2][0]["foo"].append(1)
+        assert G[1][2][0]["foo"] != H[1][2][0]["foo"]
+
+    def shallow_copy_edge_attr(self, H, G):
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
+        G[1][2][0]["foo"].append(1)
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
+
+    def graphs_equal(self, H, G):
+        assert G._adj == H._adj
+        assert G._node == H._node
+        assert G.graph == H.graph
+        assert G.name == H.name
+        if not G.is_directed() and not H.is_directed():
+            assert H._adj[1][2][0] is H._adj[2][1][0]
+            assert G._adj[1][2][0] is G._adj[2][1][0]
+        else:  # at least one is directed
+            if not G.is_directed():
+                G._pred = G._adj
+                G._succ = G._adj
+            if not H.is_directed():
+                H._pred = H._adj
+                H._succ = H._adj
+            assert G._pred == H._pred
+            assert G._succ == H._succ
+            assert H._succ[1][2][0] is H._pred[2][1][0]
+            assert G._succ[1][2][0] is G._pred[2][1][0]
+
+    def same_attrdict(self, H, G):
+        # same attrdict in the edgedata
+        old_foo = H[1][2][0]["foo"]
+        H.adj[1][2][0]["foo"] = "baz"
+        assert G._adj == H._adj
+        H.adj[1][2][0]["foo"] = old_foo
+        assert G._adj == H._adj
+
+        old_foo = H.nodes[0]["foo"]
+        H.nodes[0]["foo"] = "baz"
+        assert G._node == H._node
+        H.nodes[0]["foo"] = old_foo
+        assert G._node == H._node
+
+    def different_attrdict(self, H, G):
+        # used by graph_equal_but_different
+        old_foo = H[1][2][0]["foo"]
+        H.adj[1][2][0]["foo"] = "baz"
+        assert G._adj != H._adj
+        H.adj[1][2][0]["foo"] = old_foo
+        assert G._adj == H._adj
+
+        old_foo = H.nodes[0]["foo"]
+        H.nodes[0]["foo"] = "baz"
+        assert G._node != H._node
+        H.nodes[0]["foo"] = old_foo
+        assert G._node == H._node
+
+    def test_to_undirected(self):
+        G = self.K3
+        self.add_attributes(G)
+        H = nx.MultiGraph(G)
+        self.is_shallow_copy(H, G)
+        H = G.to_undirected()
+        self.is_deepcopy(H, G)
+
+    def test_to_directed(self):
+        G = self.K3
+        self.add_attributes(G)
+        H = nx.MultiDiGraph(G)
+        self.is_shallow_copy(H, G)
+        H = G.to_directed()
+        self.is_deepcopy(H, G)
+
+    def test_number_of_edges_selfloops(self):
+        G = self.K3
+        G.add_edge(0, 0)
+        G.add_edge(0, 0)
+        G.add_edge(0, 0, key="parallel edge")
+        G.remove_edge(0, 0, key="parallel edge")
+        assert G.number_of_edges(0, 0) == 2
+        G.remove_edge(0, 0)
+        assert G.number_of_edges(0, 0) == 1
+
+    def test_edge_lookup(self):
+        G = self.Graph()
+        G.add_edge(1, 2, foo="bar")
+        G.add_edge(1, 2, "key", foo="biz")
+        assert edges_equal(G.edges[1, 2, 0], {"foo": "bar"})
+        assert edges_equal(G.edges[1, 2, "key"], {"foo": "biz"})
+
+    def test_edge_attr(self):
+        G = self.Graph()
+        G.add_edge(1, 2, key="k1", foo="bar")
+        G.add_edge(1, 2, key="k2", foo="baz")
+        assert isinstance(G.get_edge_data(1, 2), G.edge_key_dict_factory)
+        assert all(
+            isinstance(d, G.edge_attr_dict_factory) for u, v, d in G.edges(data=True)
+        )
+        assert edges_equal(
+            G.edges(keys=True, data=True),
+            [(1, 2, "k1", {"foo": "bar"}), (1, 2, "k2", {"foo": "baz"})],
+        )
+        assert edges_equal(
+            G.edges(keys=True, data="foo"), [(1, 2, "k1", "bar"), (1, 2, "k2", "baz")]
+        )
+
+    def test_edge_attr4(self):
+        G = self.Graph()
+        G.add_edge(1, 2, key=0, data=7, spam="bar", bar="foo")
+        assert edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 7, "spam": "bar", "bar": "foo"})]
+        )
+        G[1][2][0]["data"] = 10  # OK to set data like this
+        assert edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 10, "spam": "bar", "bar": "foo"})]
+        )
+
+        G.adj[1][2][0]["data"] = 20
+        assert edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 20, "spam": "bar", "bar": "foo"})]
+        )
+        G.edges[1, 2, 0]["data"] = 21  # another spelling, "edge"
+        assert edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 21, "spam": "bar", "bar": "foo"})]
+        )
+        G.adj[1][2][0]["listdata"] = [20, 200]
+        G.adj[1][2][0]["weight"] = 20
+        assert edges_equal(
+            G.edges(data=True),
+            [
+                (
+                    1,
+                    2,
+                    {
+                        "data": 21,
+                        "spam": "bar",
+                        "bar": "foo",
+                        "listdata": [20, 200],
+                        "weight": 20,
+                    },
+                )
+            ],
+        )
+
+
+class TestMultiGraph(BaseMultiGraphTester, _TestGraph):
+    def setup_method(self):
+        self.Graph = nx.MultiGraph
+        # build K3
+        ed1, ed2, ed3 = ({0: {}}, {0: {}}, {0: {}})
+        self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed1, 2: ed3}, 2: {0: ed2, 1: ed3}}
+        self.k3edges = [(0, 1), (0, 2), (1, 2)]
+        self.k3nodes = [0, 1, 2]
+        self.K3 = self.Graph()
+        self.K3._adj = self.k3adj
+        self.K3._node = {}
+        self.K3._node[0] = {}
+        self.K3._node[1] = {}
+        self.K3._node[2] = {}
+
+    def test_data_input(self):
+        G = self.Graph({1: [2], 2: [1]}, name="test")
+        assert G.name == "test"
+        expected = [(1, {2: {0: {}}}), (2, {1: {0: {}}})]
+        assert sorted(G.adj.items()) == expected
+
+    def test_data_multigraph_input(self):
+        # standard case with edge keys and edge data
+        edata0 = dict(w=200, s="foo")
+        edata1 = dict(w=201, s="bar")
+        keydict = {0: edata0, 1: edata1}
+        dododod = {"a": {"b": keydict}}
+
+        multiple_edge = [("a", "b", 0, edata0), ("a", "b", 1, edata1)]
+        single_edge = [("a", "b", 0, keydict)]
+
+        G = self.Graph(dododod, multigraph_input=True)
+        assert list(G.edges(keys=True, data=True)) == multiple_edge
+        G = self.Graph(dododod, multigraph_input=None)
+        assert list(G.edges(keys=True, data=True)) == multiple_edge
+        G = self.Graph(dododod, multigraph_input=False)
+        assert list(G.edges(keys=True, data=True)) == single_edge
+
+        # test round-trip to_dict_of_dict and MultiGraph constructor
+        G = self.Graph(dododod, multigraph_input=True)
+        H = self.Graph(nx.to_dict_of_dicts(G))
+        assert nx.is_isomorphic(G, H) is True  # test that default is True
+        for mgi in [True, False]:
+            H = self.Graph(nx.to_dict_of_dicts(G), multigraph_input=mgi)
+            assert nx.is_isomorphic(G, H) == mgi
+
+    # Set up cases for when incoming_graph_data is not multigraph_input
+    etraits = {"w": 200, "s": "foo"}
+    egraphics = {"color": "blue", "shape": "box"}
+    edata = {"traits": etraits, "graphics": egraphics}
+    dodod1 = {"a": {"b": edata}}
+    dodod2 = {"a": {"b": etraits}}
+    dodod3 = {"a": {"b": {"traits": etraits, "s": "foo"}}}
+    dol = {"a": ["b"]}
+
+    multiple_edge = [("a", "b", "traits", etraits), ("a", "b", "graphics", egraphics)]
+    single_edge = [("a", "b", 0, {})]  # type: ignore
+    single_edge1 = [("a", "b", 0, edata)]
+    single_edge2 = [("a", "b", 0, etraits)]
+    single_edge3 = [("a", "b", 0, {"traits": etraits, "s": "foo"})]
+
+    cases = [  # (dod, mgi, edges)
+        (dodod1, True, multiple_edge),
+        (dodod1, False, single_edge1),
+        (dodod2, False, single_edge2),
+        (dodod3, False, single_edge3),
+        (dol, False, single_edge),
+    ]
+
+    @pytest.mark.parametrize("dod, mgi, edges", cases)
+    def test_non_multigraph_input(self, dod, mgi, edges):
+        G = self.Graph(dod, multigraph_input=mgi)
+        assert list(G.edges(keys=True, data=True)) == edges
+        G = nx.to_networkx_graph(dod, create_using=self.Graph, multigraph_input=mgi)
+        assert list(G.edges(keys=True, data=True)) == edges
+
+    mgi_none_cases = [
+        (dodod1, multiple_edge),
+        (dodod2, single_edge2),
+        (dodod3, single_edge3),
+    ]
+
+    @pytest.mark.parametrize("dod, edges", mgi_none_cases)
+    def test_non_multigraph_input_mgi_none(self, dod, edges):
+        # test constructor without to_networkx_graph for mgi=None
+        G = self.Graph(dod)
+        assert list(G.edges(keys=True, data=True)) == edges
+
+    raise_cases = [dodod2, dodod3, dol]
+
+    @pytest.mark.parametrize("dod", raise_cases)
+    def test_non_multigraph_input_raise(self, dod):
+        # cases where NetworkXError is raised
+        pytest.raises(nx.NetworkXError, self.Graph, dod, multigraph_input=True)
+        pytest.raises(
+            nx.NetworkXError,
+            nx.to_networkx_graph,
+            dod,
+            create_using=self.Graph,
+            multigraph_input=True,
+        )
+
+    def test_getitem(self):
+        G = self.K3
+        assert G[0] == {1: {0: {}}, 2: {0: {}}}
+        with pytest.raises(KeyError):
+            G.__getitem__("j")
+        with pytest.raises(TypeError):
+            G.__getitem__(["A"])
+
+    def test_remove_node(self):
+        G = self.K3
+        G.remove_node(0)
+        assert G.adj == {1: {2: {0: {}}}, 2: {1: {0: {}}}}
+        with pytest.raises(nx.NetworkXError):
+            G.remove_node(-1)
+
+    def test_add_edge(self):
+        G = self.Graph()
+        G.add_edge(0, 1)
+        assert G.adj == {0: {1: {0: {}}}, 1: {0: {0: {}}}}
+        G = self.Graph()
+        G.add_edge(*(0, 1))
+        assert G.adj == {0: {1: {0: {}}}, 1: {0: {0: {}}}}
+
+    def test_add_edge_conflicting_key(self):
+        G = self.Graph()
+        G.add_edge(0, 1, key=1)
+        G.add_edge(0, 1)
+        assert G.number_of_edges() == 2
+        G = self.Graph()
+        G.add_edges_from([(0, 1, 1, {})])
+        G.add_edges_from([(0, 1)])
+        assert G.number_of_edges() == 2
+
+    def test_add_edges_from(self):
+        G = self.Graph()
+        G.add_edges_from([(0, 1), (0, 1, {"weight": 3})])
+        assert G.adj == {
+            0: {1: {0: {}, 1: {"weight": 3}}},
+            1: {0: {0: {}, 1: {"weight": 3}}},
+        }
+        G.add_edges_from([(0, 1), (0, 1, {"weight": 3})], weight=2)
+        assert G.adj == {
+            0: {1: {0: {}, 1: {"weight": 3}, 2: {"weight": 2}, 3: {"weight": 3}}},
+            1: {0: {0: {}, 1: {"weight": 3}, 2: {"weight": 2}, 3: {"weight": 3}}},
+        }
+        G = self.Graph()
+        edges = [
+            (0, 1, {"weight": 3}),
+            (0, 1, (("weight", 2),)),
+            (0, 1, 5),
+            (0, 1, "s"),
+        ]
+        G.add_edges_from(edges)
+        keydict = {0: {"weight": 3}, 1: {"weight": 2}, 5: {}, "s": {}}
+        assert G._adj == {0: {1: keydict}, 1: {0: keydict}}
+
+        # too few in tuple
+        with pytest.raises(nx.NetworkXError):
+            G.add_edges_from([(0,)])
+        # too many in tuple
+        with pytest.raises(nx.NetworkXError):
+            G.add_edges_from([(0, 1, 2, 3, 4)])
+        # not a tuple
+        with pytest.raises(TypeError):
+            G.add_edges_from([0])
+
+    def test_multigraph_add_edges_from_four_tuple_misordered(self):
+        """add_edges_from expects 4-tuples of the format (u, v, key, data_dict).
+
+        Ensure 4-tuples of form (u, v, data_dict, key) raise exception.
+        """
+        G = nx.MultiGraph()
+        with pytest.raises(TypeError):
+            # key/data values flipped in 4-tuple
+            G.add_edges_from([(0, 1, {"color": "red"}, 0)])
+
+    def test_remove_edge(self):
+        G = self.K3
+        G.remove_edge(0, 1)
+        assert G.adj == {0: {2: {0: {}}}, 1: {2: {0: {}}}, 2: {0: {0: {}}, 1: {0: {}}}}
+
+        with pytest.raises(nx.NetworkXError):
+            G.remove_edge(-1, 0)
+        with pytest.raises(nx.NetworkXError):
+            G.remove_edge(0, 2, key=1)
+
+    def test_remove_edges_from(self):
+        G = self.K3.copy()
+        G.remove_edges_from([(0, 1)])
+        kd = {0: {}}
+        assert G.adj == {0: {2: kd}, 1: {2: kd}, 2: {0: kd, 1: kd}}
+        G.remove_edges_from([(0, 0)])  # silent fail
+        self.K3.add_edge(0, 1)
+        G = self.K3.copy()
+        G.remove_edges_from(list(G.edges(data=True, keys=True)))
+        assert G.adj == {0: {}, 1: {}, 2: {}}
+        G = self.K3.copy()
+        G.remove_edges_from(list(G.edges(data=False, keys=True)))
+        assert G.adj == {0: {}, 1: {}, 2: {}}
+        G = self.K3.copy()
+        G.remove_edges_from(list(G.edges(data=False, keys=False)))
+        assert G.adj == {0: {}, 1: {}, 2: {}}
+        G = self.K3.copy()
+        G.remove_edges_from([(0, 1, 0), (0, 2, 0, {}), (1, 2)])
+        assert G.adj == {0: {1: {1: {}}}, 1: {0: {1: {}}}, 2: {}}
+
+    def test_remove_multiedge(self):
+        G = self.K3
+        G.add_edge(0, 1, key="parallel edge")
+        G.remove_edge(0, 1, key="parallel edge")
+        assert G.adj == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+        G.remove_edge(0, 1)
+        kd = {0: {}}
+        assert G.adj == {0: {2: kd}, 1: {2: kd}, 2: {0: kd, 1: kd}}
+        with pytest.raises(nx.NetworkXError):
+            G.remove_edge(-1, 0)
+
+
+class TestEdgeSubgraph:
+    """Unit tests for the :meth:`MultiGraph.edge_subgraph` method."""
+
+    def setup_method(self):
+        # Create a doubly-linked path graph on five nodes.
+        G = nx.MultiGraph()
+        nx.add_path(G, range(5))
+        nx.add_path(G, range(5))
+        # Add some node, edge, and graph attributes.
+        for i in range(5):
+            G.nodes[i]["name"] = f"node{i}"
+        G.adj[0][1][0]["name"] = "edge010"
+        G.adj[0][1][1]["name"] = "edge011"
+        G.adj[3][4][0]["name"] = "edge340"
+        G.adj[3][4][1]["name"] = "edge341"
+        G.graph["name"] = "graph"
+        # Get the subgraph induced by one of the first edges and one of
+        # the last edges.
+        self.G = G
+        self.H = G.edge_subgraph([(0, 1, 0), (3, 4, 1)])
+
+    def test_correct_nodes(self):
+        """Tests that the subgraph has the correct nodes."""
+        assert [0, 1, 3, 4] == sorted(self.H.nodes())
+
+    def test_correct_edges(self):
+        """Tests that the subgraph has the correct edges."""
+        assert [(0, 1, 0, "edge010"), (3, 4, 1, "edge341")] == sorted(
+            self.H.edges(keys=True, data="name")
+        )
+
+    def test_add_node(self):
+        """Tests that adding a node to the original graph does not
+        affect the nodes of the subgraph.
+
+        """
+        self.G.add_node(5)
+        assert [0, 1, 3, 4] == sorted(self.H.nodes())
+
+    def test_remove_node(self):
+        """Tests that removing a node in the original graph does
+        affect the nodes of the subgraph.
+
+        """
+        self.G.remove_node(0)
+        assert [1, 3, 4] == sorted(self.H.nodes())
+
+    def test_node_attr_dict(self):
+        """Tests that the node attribute dictionary of the two graphs is
+        the same object.
+
+        """
+        for v in self.H:
+            assert self.G.nodes[v] == self.H.nodes[v]
+        # Making a change to G should make a change in H and vice versa.
+        self.G.nodes[0]["name"] = "foo"
+        assert self.G.nodes[0] == self.H.nodes[0]
+        self.H.nodes[1]["name"] = "bar"
+        assert self.G.nodes[1] == self.H.nodes[1]
+
+    def test_edge_attr_dict(self):
+        """Tests that the edge attribute dictionary of the two graphs is
+        the same object.
+
+        """
+        for u, v, k in self.H.edges(keys=True):
+            assert self.G._adj[u][v][k] == self.H._adj[u][v][k]
+        # Making a change to G should make a change in H and vice versa.
+        self.G._adj[0][1][0]["name"] = "foo"
+        assert self.G._adj[0][1][0]["name"] == self.H._adj[0][1][0]["name"]
+        self.H._adj[3][4][1]["name"] = "bar"
+        assert self.G._adj[3][4][1]["name"] == self.H._adj[3][4][1]["name"]
+
+    def test_graph_attr_dict(self):
+        """Tests that the graph attribute dictionary of the two graphs
+        is the same object.
+
+        """
+        assert self.G.graph is self.H.graph
+
+
+class CustomDictClass(UserDict):
+    pass
+
+
+class MultiGraphSubClass(nx.MultiGraph):
+    node_dict_factory = CustomDictClass  # type: ignore
+    node_attr_dict_factory = CustomDictClass  # type: ignore
+    adjlist_outer_dict_factory = CustomDictClass  # type: ignore
+    adjlist_inner_dict_factory = CustomDictClass  # type: ignore
+    edge_key_dict_factory = CustomDictClass  # type: ignore
+    edge_attr_dict_factory = CustomDictClass  # type: ignore
+    graph_attr_dict_factory = CustomDictClass  # type: ignore
+
+
+class TestMultiGraphSubclass(TestMultiGraph):
+    def setup_method(self):
+        self.Graph = MultiGraphSubClass
+        # build K3
+        self.k3edges = [(0, 1), (0, 2), (1, 2)]
+        self.k3nodes = [0, 1, 2]
+        self.K3 = self.Graph()
+        self.K3._adj = self.K3.adjlist_outer_dict_factory(
+            {
+                0: self.K3.adjlist_inner_dict_factory(),
+                1: self.K3.adjlist_inner_dict_factory(),
+                2: self.K3.adjlist_inner_dict_factory(),
+            }
+        )
+        self.K3._pred = {0: {}, 1: {}, 2: {}}
+        for u in self.k3nodes:
+            for v in self.k3nodes:
+                if u != v:
+                    d = {0: {}}
+                    self.K3._adj[u][v] = d
+                    self.K3._adj[v][u] = d
+        self.K3._node = self.K3.node_dict_factory()
+        self.K3._node[0] = self.K3.node_attr_dict_factory()
+        self.K3._node[1] = self.K3.node_attr_dict_factory()
+        self.K3._node[2] = self.K3.node_attr_dict_factory()
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_ordered.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_ordered.py
new file mode 100644
index 0000000..f29ecb4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_ordered.py
@@ -0,0 +1,40 @@
+import networkx as nx
+
+
+class TestOrdered:
+    # Just test instantiation.
+    def test_graph(self):
+        G = nx.OrderedGraph()
+
+    def test_digraph(self):
+        G = nx.OrderedDiGraph()
+
+    def test_multigraph(self):
+        G = nx.OrderedMultiGraph()
+
+    def test_multidigraph(self):
+        G = nx.OrderedMultiDiGraph()
+
+
+class TestOrderedFeatures:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.OrderedDiGraph()
+        cls.G.add_nodes_from([1, 2, 3])
+        cls.G.add_edges_from([(2, 3), (1, 3)])
+
+    def test_subgraph_order(self):
+        G = self.G
+        G_sub = G.subgraph([1, 2, 3])
+        assert list(G.nodes) == list(G_sub.nodes)
+        assert list(G.edges) == list(G_sub.edges)
+        assert list(G.pred[3]) == list(G_sub.pred[3])
+        assert [2, 1] == list(G_sub.pred[3])
+        assert [] == list(G_sub.succ[3])
+
+        G_sub = nx.induced_subgraph(G, [1, 2, 3])
+        assert list(G.nodes) == list(G_sub.nodes)
+        assert list(G.edges) == list(G_sub.edges)
+        assert list(G.pred[3]) == list(G_sub.pred[3])
+        assert [2, 1] == list(G_sub.pred[3])
+        assert [] == list(G_sub.succ[3])
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_reportviews.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_reportviews.py
new file mode 100644
index 0000000..7e8dc3d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_reportviews.py
@@ -0,0 +1,1419 @@
+import pickle
+from copy import deepcopy
+
+import pytest
+
+import networkx as nx
+from networkx.classes import reportviews as rv
+from networkx.classes.reportviews import NodeDataView
+
+
+# Nodes
+class TestNodeView:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9)
+        cls.nv = cls.G.nodes  # NodeView(G)
+
+    def test_pickle(self):
+        import pickle
+
+        nv = self.nv
+        pnv = pickle.loads(pickle.dumps(nv, -1))
+        assert nv == pnv
+        assert nv.__slots__ == pnv.__slots__
+
+    def test_str(self):
+        assert str(self.nv) == "[0, 1, 2, 3, 4, 5, 6, 7, 8]"
+
+    def test_repr(self):
+        assert repr(self.nv) == "NodeView((0, 1, 2, 3, 4, 5, 6, 7, 8))"
+
+    def test_contains(self):
+        G = self.G.copy()
+        nv = G.nodes
+        assert 7 in nv
+        assert 9 not in nv
+        G.remove_node(7)
+        G.add_node(9)
+        assert 7 not in nv
+        assert 9 in nv
+
+    def test_getitem(self):
+        G = self.G.copy()
+        nv = G.nodes
+        G.nodes[3]["foo"] = "bar"
+        assert nv[7] == {}
+        assert nv[3] == {"foo": "bar"}
+        # slicing
+        with pytest.raises(nx.NetworkXError):
+            G.nodes[0:5]
+
+    def test_iter(self):
+        nv = self.nv
+        for i, n in enumerate(nv):
+            assert i == n
+        inv = iter(nv)
+        assert next(inv) == 0
+        assert iter(nv) != nv
+        assert iter(inv) == inv
+        inv2 = iter(nv)
+        next(inv2)
+        assert list(inv) == list(inv2)
+        # odd case where NodeView calls NodeDataView with data=False
+        nnv = nv(data=False)
+        for i, n in enumerate(nnv):
+            assert i == n
+
+    def test_call(self):
+        nodes = self.nv
+        assert nodes is nodes()
+        assert nodes is not nodes(data=True)
+        assert nodes is not nodes(data="weight")
+
+
+class TestNodeDataView:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9)
+        cls.nv = NodeDataView(cls.G)
+        cls.ndv = cls.G.nodes.data(True)
+        cls.nwv = cls.G.nodes.data("foo")
+
+    def test_viewtype(self):
+        nv = self.G.nodes
+        ndvfalse = nv.data(False)
+        assert nv is ndvfalse
+        assert nv is not self.ndv
+
+    def test_pickle(self):
+        import pickle
+
+        nv = self.nv
+        pnv = pickle.loads(pickle.dumps(nv, -1))
+        assert nv == pnv
+        assert nv.__slots__ == pnv.__slots__
+
+    def test_str(self):
+        msg = str([(n, {}) for n in range(9)])
+        assert str(self.ndv) == msg
+
+    def test_repr(self):
+        expected = "NodeDataView((0, 1, 2, 3, 4, 5, 6, 7, 8))"
+        assert repr(self.nv) == expected
+        expected = (
+            "NodeDataView({0: {}, 1: {}, 2: {}, 3: {}, "
+            + "4: {}, 5: {}, 6: {}, 7: {}, 8: {}})"
+        )
+        assert repr(self.ndv) == expected
+        expected = (
+            "NodeDataView({0: None, 1: None, 2: None, 3: None, 4: None, "
+            + "5: None, 6: None, 7: None, 8: None}, data='foo')"
+        )
+        assert repr(self.nwv) == expected
+
+    def test_contains(self):
+        G = self.G.copy()
+        nv = G.nodes.data()
+        nwv = G.nodes.data("foo")
+        G.nodes[3]["foo"] = "bar"
+        assert (7, {}) in nv
+        assert (3, {"foo": "bar"}) in nv
+        assert (3, "bar") in nwv
+        assert (7, None) in nwv
+        # default
+        nwv_def = G.nodes(data="foo", default="biz")
+        assert (7, "biz") in nwv_def
+        assert (3, "bar") in nwv_def
+
+    def test_getitem(self):
+        G = self.G.copy()
+        nv = G.nodes
+        G.nodes[3]["foo"] = "bar"
+        assert nv[3] == {"foo": "bar"}
+        # default
+        nwv_def = G.nodes(data="foo", default="biz")
+        assert nwv_def[7], "biz"
+        assert nwv_def[3] == "bar"
+        # slicing
+        with pytest.raises(nx.NetworkXError):
+            G.nodes.data()[0:5]
+
+    def test_iter(self):
+        G = self.G.copy()
+        nv = G.nodes.data()
+        ndv = G.nodes.data(True)
+        nwv = G.nodes.data("foo")
+        for i, (n, d) in enumerate(nv):
+            assert i == n
+            assert d == {}
+        inv = iter(nv)
+        assert next(inv) == (0, {})
+        G.nodes[3]["foo"] = "bar"
+        # default
+        for n, d in nv:
+            if n == 3:
+                assert d == {"foo": "bar"}
+            else:
+                assert d == {}
+        # data=True
+        for n, d in ndv:
+            if n == 3:
+                assert d == {"foo": "bar"}
+            else:
+                assert d == {}
+        # data='foo'
+        for n, d in nwv:
+            if n == 3:
+                assert d == "bar"
+            else:
+                assert d is None
+        # data='foo', default=1
+        for n, d in G.nodes.data("foo", default=1):
+            if n == 3:
+                assert d == "bar"
+            else:
+                assert d == 1
+
+
+def test_nodedataview_unhashable():
+    G = nx.path_graph(9)
+    G.nodes[3]["foo"] = "bar"
+    nvs = [G.nodes.data()]
+    nvs.append(G.nodes.data(True))
+    H = G.copy()
+    H.nodes[4]["foo"] = {1, 2, 3}
+    nvs.append(H.nodes.data(True))
+    # raise unhashable
+    for nv in nvs:
+        pytest.raises(TypeError, set, nv)
+        pytest.raises(TypeError, eval, "nv | nv", locals())
+    # no raise... hashable
+    Gn = G.nodes.data(False)
+    set(Gn)
+    Gn | Gn
+    Gn = G.nodes.data("foo")
+    set(Gn)
+    Gn | Gn
+
+
+class TestNodeViewSetOps:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9)
+        cls.G.nodes[3]["foo"] = "bar"
+        cls.nv = cls.G.nodes
+
+    def n_its(self, nodes):
+        return {node for node in nodes}
+
+    def test_len(self):
+        G = self.G.copy()
+        nv = G.nodes
+        assert len(nv) == 9
+        G.remove_node(7)
+        assert len(nv) == 8
+        G.add_node(9)
+        assert len(nv) == 9
+
+    def test_and(self):
+        # print("G & H nodes:", gnv & hnv)
+        nv = self.nv
+        some_nodes = self.n_its(range(5, 12))
+        assert nv & some_nodes == self.n_its(range(5, 9))
+        assert some_nodes & nv == self.n_its(range(5, 9))
+
+    def test_or(self):
+        # print("G | H nodes:", gnv | hnv)
+        nv = self.nv
+        some_nodes = self.n_its(range(5, 12))
+        assert nv | some_nodes == self.n_its(range(12))
+        assert some_nodes | nv == self.n_its(range(12))
+
+    def test_xor(self):
+        # print("G ^ H nodes:", gnv ^ hnv)
+        nv = self.nv
+        some_nodes = self.n_its(range(5, 12))
+        nodes = {0, 1, 2, 3, 4, 9, 10, 11}
+        assert nv ^ some_nodes == self.n_its(nodes)
+        assert some_nodes ^ nv == self.n_its(nodes)
+
+    def test_sub(self):
+        # print("G - H nodes:", gnv - hnv)
+        nv = self.nv
+        some_nodes = self.n_its(range(5, 12))
+        assert nv - some_nodes == self.n_its(range(5))
+        assert some_nodes - nv == self.n_its(range(9, 12))
+
+
+class TestNodeDataViewSetOps(TestNodeViewSetOps):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9)
+        cls.G.nodes[3]["foo"] = "bar"
+        cls.nv = cls.G.nodes.data("foo")
+
+    def n_its(self, nodes):
+        return {(node, "bar" if node == 3 else None) for node in nodes}
+
+
+class TestNodeDataViewDefaultSetOps(TestNodeDataViewSetOps):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9)
+        cls.G.nodes[3]["foo"] = "bar"
+        cls.nv = cls.G.nodes.data("foo", default=1)
+
+    def n_its(self, nodes):
+        return {(node, "bar" if node == 3 else 1) for node in nodes}
+
+
+# Edges Data View
+class TestEdgeDataView:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9)
+        cls.eview = nx.reportviews.EdgeView
+
+    def test_pickle(self):
+        import pickle
+
+        ev = self.eview(self.G)(data=True)
+        pev = pickle.loads(pickle.dumps(ev, -1))
+        assert list(ev) == list(pev)
+        assert ev.__slots__ == pev.__slots__
+
+    def modify_edge(self, G, e, **kwds):
+        G._adj[e[0]][e[1]].update(kwds)
+
+    def test_str(self):
+        ev = self.eview(self.G)(data=True)
+        rep = str([(n, n + 1, {}) for n in range(8)])
+        assert str(ev) == rep
+
+    def test_repr(self):
+        ev = self.eview(self.G)(data=True)
+        rep = (
+            "EdgeDataView([(0, 1, {}), (1, 2, {}), "
+            + "(2, 3, {}), (3, 4, {}), "
+            + "(4, 5, {}), (5, 6, {}), "
+            + "(6, 7, {}), (7, 8, {})])"
+        )
+        assert repr(ev) == rep
+
+    def test_iterdata(self):
+        G = self.G.copy()
+        evr = self.eview(G)
+        ev = evr(data=True)
+        ev_def = evr(data="foo", default=1)
+
+        for u, v, d in ev:
+            pass
+        assert d == {}
+
+        for u, v, wt in ev_def:
+            pass
+        assert wt == 1
+
+        self.modify_edge(G, (2, 3), foo="bar")
+        for e in ev:
+            assert len(e) == 3
+            if set(e[:2]) == {2, 3}:
+                assert e[2] == {"foo": "bar"}
+                checked = True
+            else:
+                assert e[2] == {}
+        assert checked
+
+        for e in ev_def:
+            assert len(e) == 3
+            if set(e[:2]) == {2, 3}:
+                assert e[2] == "bar"
+                checked_wt = True
+            else:
+                assert e[2] == 1
+        assert checked_wt
+
+    def test_iter(self):
+        evr = self.eview(self.G)
+        ev = evr()
+        for u, v in ev:
+            pass
+        iev = iter(ev)
+        assert next(iev) == (0, 1)
+        assert iter(ev) != ev
+        assert iter(iev) == iev
+
+    def test_contains(self):
+        evr = self.eview(self.G)
+        ev = evr()
+        if self.G.is_directed():
+            assert (1, 2) in ev and (2, 1) not in ev
+        else:
+            assert (1, 2) in ev and (2, 1) in ev
+        assert not (1, 4) in ev
+        assert not (1, 90) in ev
+        assert not (90, 1) in ev
+
+    def test_contains_with_nbunch(self):
+        evr = self.eview(self.G)
+        ev = evr(nbunch=[0, 2])
+        if self.G.is_directed():
+            assert (0, 1) in ev
+            assert not (1, 2) in ev
+            assert (2, 3) in ev
+        else:
+            assert (0, 1) in ev
+            assert (1, 2) in ev
+            assert (2, 3) in ev
+        assert not (3, 4) in ev
+        assert not (4, 5) in ev
+        assert not (5, 6) in ev
+        assert not (7, 8) in ev
+        assert not (8, 9) in ev
+
+    def test_len(self):
+        evr = self.eview(self.G)
+        ev = evr(data="foo")
+        assert len(ev) == 8
+        assert len(evr(1)) == 2
+        assert len(evr([1, 2, 3])) == 4
+
+        assert len(self.G.edges(1)) == 2
+        assert len(self.G.edges()) == 8
+        assert len(self.G.edges) == 8
+
+        H = self.G.copy()
+        H.add_edge(1, 1)
+        assert len(H.edges(1)) == 3
+        assert len(H.edges()) == 9
+        assert len(H.edges) == 9
+
+
+class TestOutEdgeDataView(TestEdgeDataView):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, create_using=nx.DiGraph())
+        cls.eview = nx.reportviews.OutEdgeView
+
+    def test_repr(self):
+        ev = self.eview(self.G)(data=True)
+        rep = (
+            "OutEdgeDataView([(0, 1, {}), (1, 2, {}), "
+            + "(2, 3, {}), (3, 4, {}), "
+            + "(4, 5, {}), (5, 6, {}), "
+            + "(6, 7, {}), (7, 8, {})])"
+        )
+        assert repr(ev) == rep
+
+    def test_len(self):
+        evr = self.eview(self.G)
+        ev = evr(data="foo")
+        assert len(ev) == 8
+        assert len(evr(1)) == 1
+        assert len(evr([1, 2, 3])) == 3
+
+        assert len(self.G.edges(1)) == 1
+        assert len(self.G.edges()) == 8
+        assert len(self.G.edges) == 8
+
+        H = self.G.copy()
+        H.add_edge(1, 1)
+        assert len(H.edges(1)) == 2
+        assert len(H.edges()) == 9
+        assert len(H.edges) == 9
+
+    def test_contains_with_nbunch(self):
+        evr = self.eview(self.G)
+        ev = evr(nbunch=[0, 2])
+        assert (0, 1) in ev
+        assert not (1, 2) in ev
+        assert (2, 3) in ev
+        assert not (3, 4) in ev
+        assert not (4, 5) in ev
+        assert not (5, 6) in ev
+        assert not (7, 8) in ev
+        assert not (8, 9) in ev
+
+
+class TestInEdgeDataView(TestOutEdgeDataView):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, create_using=nx.DiGraph())
+        cls.eview = nx.reportviews.InEdgeView
+
+    def test_repr(self):
+        ev = self.eview(self.G)(data=True)
+        rep = (
+            "InEdgeDataView([(0, 1, {}), (1, 2, {}), "
+            + "(2, 3, {}), (3, 4, {}), "
+            + "(4, 5, {}), (5, 6, {}), "
+            + "(6, 7, {}), (7, 8, {})])"
+        )
+        assert repr(ev) == rep
+
+    def test_contains_with_nbunch(self):
+        evr = self.eview(self.G)
+        ev = evr(nbunch=[0, 2])
+        assert not (0, 1) in ev
+        assert (1, 2) in ev
+        assert not (2, 3) in ev
+        assert not (3, 4) in ev
+        assert not (4, 5) in ev
+        assert not (5, 6) in ev
+        assert not (7, 8) in ev
+        assert not (8, 9) in ev
+
+
+class TestMultiEdgeDataView(TestEdgeDataView):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, create_using=nx.MultiGraph())
+        cls.eview = nx.reportviews.MultiEdgeView
+
+    def modify_edge(self, G, e, **kwds):
+        G._adj[e[0]][e[1]][0].update(kwds)
+
+    def test_repr(self):
+        ev = self.eview(self.G)(data=True)
+        rep = (
+            "MultiEdgeDataView([(0, 1, {}), (1, 2, {}), "
+            + "(2, 3, {}), (3, 4, {}), "
+            + "(4, 5, {}), (5, 6, {}), "
+            + "(6, 7, {}), (7, 8, {})])"
+        )
+        assert repr(ev) == rep
+
+    def test_contains_with_nbunch(self):
+        evr = self.eview(self.G)
+        ev = evr(nbunch=[0, 2])
+        assert (0, 1) in ev
+        assert (1, 2) in ev
+        assert (2, 3) in ev
+        assert not (3, 4) in ev
+        assert not (4, 5) in ev
+        assert not (5, 6) in ev
+        assert not (7, 8) in ev
+        assert not (8, 9) in ev
+
+
+class TestOutMultiEdgeDataView(TestOutEdgeDataView):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, create_using=nx.MultiDiGraph())
+        cls.eview = nx.reportviews.OutMultiEdgeView
+
+    def modify_edge(self, G, e, **kwds):
+        G._adj[e[0]][e[1]][0].update(kwds)
+
+    def test_repr(self):
+        ev = self.eview(self.G)(data=True)
+        rep = (
+            "OutMultiEdgeDataView([(0, 1, {}), (1, 2, {}), "
+            + "(2, 3, {}), (3, 4, {}), "
+            + "(4, 5, {}), (5, 6, {}), "
+            + "(6, 7, {}), (7, 8, {})])"
+        )
+        assert repr(ev) == rep
+
+    def test_contains_with_nbunch(self):
+        evr = self.eview(self.G)
+        ev = evr(nbunch=[0, 2])
+        assert (0, 1) in ev
+        assert not (1, 2) in ev
+        assert (2, 3) in ev
+        assert not (3, 4) in ev
+        assert not (4, 5) in ev
+        assert not (5, 6) in ev
+        assert not (7, 8) in ev
+        assert not (8, 9) in ev
+
+
+class TestInMultiEdgeDataView(TestOutMultiEdgeDataView):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, create_using=nx.MultiDiGraph())
+        cls.eview = nx.reportviews.InMultiEdgeView
+
+    def test_repr(self):
+        ev = self.eview(self.G)(data=True)
+        rep = (
+            "InMultiEdgeDataView([(0, 1, {}), (1, 2, {}), "
+            + "(2, 3, {}), (3, 4, {}), "
+            + "(4, 5, {}), (5, 6, {}), "
+            + "(6, 7, {}), (7, 8, {})])"
+        )
+        assert repr(ev) == rep
+
+    def test_contains_with_nbunch(self):
+        evr = self.eview(self.G)
+        ev = evr(nbunch=[0, 2])
+        assert not (0, 1) in ev
+        assert (1, 2) in ev
+        assert not (2, 3) in ev
+        assert not (3, 4) in ev
+        assert not (4, 5) in ev
+        assert not (5, 6) in ev
+        assert not (7, 8) in ev
+        assert not (8, 9) in ev
+
+
+# Edge Views
+class TestEdgeView:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9)
+        cls.eview = nx.reportviews.EdgeView
+
+    def test_pickle(self):
+        import pickle
+
+        ev = self.eview(self.G)
+        pev = pickle.loads(pickle.dumps(ev, -1))
+        assert ev == pev
+        assert ev.__slots__ == pev.__slots__
+
+    def modify_edge(self, G, e, **kwds):
+        G._adj[e[0]][e[1]].update(kwds)
+
+    def test_str(self):
+        ev = self.eview(self.G)
+        rep = str([(n, n + 1) for n in range(8)])
+        assert str(ev) == rep
+
+    def test_repr(self):
+        ev = self.eview(self.G)
+        rep = (
+            "EdgeView([(0, 1), (1, 2), (2, 3), (3, 4), "
+            + "(4, 5), (5, 6), (6, 7), (7, 8)])"
+        )
+        assert repr(ev) == rep
+
+    def test_getitem(self):
+        G = self.G.copy()
+        ev = G.edges
+        G.edges[0, 1]["foo"] = "bar"
+        assert ev[0, 1] == {"foo": "bar"}
+
+        # slicing
+        with pytest.raises(nx.NetworkXError):
+            G.edges[0:5]
+
+    def test_call(self):
+        ev = self.eview(self.G)
+        assert id(ev) == id(ev())
+        assert id(ev) == id(ev(data=False))
+        assert id(ev) != id(ev(data=True))
+        assert id(ev) != id(ev(nbunch=1))
+
+    def test_data(self):
+        ev = self.eview(self.G)
+        assert id(ev) != id(ev.data())
+        assert id(ev) == id(ev.data(data=False))
+        assert id(ev) != id(ev.data(data=True))
+        assert id(ev) != id(ev.data(nbunch=1))
+
+    def test_iter(self):
+        ev = self.eview(self.G)
+        for u, v in ev:
+            pass
+        iev = iter(ev)
+        assert next(iev) == (0, 1)
+        assert iter(ev) != ev
+        assert iter(iev) == iev
+
+    def test_contains(self):
+        ev = self.eview(self.G)
+        edv = ev()
+        if self.G.is_directed():
+            assert (1, 2) in ev and (2, 1) not in ev
+            assert (1, 2) in edv and (2, 1) not in edv
+        else:
+            assert (1, 2) in ev and (2, 1) in ev
+            assert (1, 2) in edv and (2, 1) in edv
+        assert not (1, 4) in ev
+        assert not (1, 4) in edv
+        # edge not in graph
+        assert not (1, 90) in ev
+        assert not (90, 1) in ev
+        assert not (1, 90) in edv
+        assert not (90, 1) in edv
+
+    def test_contains_with_nbunch(self):
+        ev = self.eview(self.G)
+        evn = ev(nbunch=[0, 2])
+        assert (0, 1) in evn
+        assert (1, 2) in evn
+        assert (2, 3) in evn
+        assert not (3, 4) in evn
+        assert not (4, 5) in evn
+        assert not (5, 6) in evn
+        assert not (7, 8) in evn
+        assert not (8, 9) in evn
+
+    def test_len(self):
+        ev = self.eview(self.G)
+        num_ed = 9 if self.G.is_multigraph() else 8
+        assert len(ev) == num_ed
+
+        H = self.G.copy()
+        H.add_edge(1, 1)
+        assert len(H.edges(1)) == 3 + H.is_multigraph() - H.is_directed()
+        assert len(H.edges()) == num_ed + 1
+        assert len(H.edges) == num_ed + 1
+
+    def test_and(self):
+        # print("G & H edges:", gnv & hnv)
+        ev = self.eview(self.G)
+        some_edges = {(0, 1), (1, 0), (0, 2)}
+        if self.G.is_directed():
+            assert some_edges & ev, {(0, 1)}
+            assert ev & some_edges, {(0, 1)}
+        else:
+            assert ev & some_edges == {(0, 1), (1, 0)}
+            assert some_edges & ev == {(0, 1), (1, 0)}
+        return
+
+    def test_or(self):
+        # print("G | H edges:", gnv | hnv)
+        ev = self.eview(self.G)
+        some_edges = {(0, 1), (1, 0), (0, 2)}
+        result1 = {(n, n + 1) for n in range(8)}
+        result1.update(some_edges)
+        result2 = {(n + 1, n) for n in range(8)}
+        result2.update(some_edges)
+        assert (ev | some_edges) in (result1, result2)
+        assert (some_edges | ev) in (result1, result2)
+
+    def test_xor(self):
+        # print("G ^ H edges:", gnv ^ hnv)
+        ev = self.eview(self.G)
+        some_edges = {(0, 1), (1, 0), (0, 2)}
+        if self.G.is_directed():
+            result = {(n, n + 1) for n in range(1, 8)}
+            result.update({(1, 0), (0, 2)})
+            assert ev ^ some_edges == result
+        else:
+            result = {(n, n + 1) for n in range(1, 8)}
+            result.update({(0, 2)})
+            assert ev ^ some_edges == result
+        return
+
+    def test_sub(self):
+        # print("G - H edges:", gnv - hnv)
+        ev = self.eview(self.G)
+        some_edges = {(0, 1), (1, 0), (0, 2)}
+        result = {(n, n + 1) for n in range(8)}
+        result.remove((0, 1))
+        assert ev - some_edges, result
+
+
+class TestOutEdgeView(TestEdgeView):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, nx.DiGraph())
+        cls.eview = nx.reportviews.OutEdgeView
+
+    def test_repr(self):
+        ev = self.eview(self.G)
+        rep = (
+            "OutEdgeView([(0, 1), (1, 2), (2, 3), (3, 4), "
+            + "(4, 5), (5, 6), (6, 7), (7, 8)])"
+        )
+        assert repr(ev) == rep
+
+    def test_contains_with_nbunch(self):
+        ev = self.eview(self.G)
+        evn = ev(nbunch=[0, 2])
+        assert (0, 1) in evn
+        assert not (1, 2) in evn
+        assert (2, 3) in evn
+        assert not (3, 4) in evn
+        assert not (4, 5) in evn
+        assert not (5, 6) in evn
+        assert not (7, 8) in evn
+        assert not (8, 9) in evn
+
+
+class TestInEdgeView(TestEdgeView):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, nx.DiGraph())
+        cls.eview = nx.reportviews.InEdgeView
+
+    def test_repr(self):
+        ev = self.eview(self.G)
+        rep = (
+            "InEdgeView([(0, 1), (1, 2), (2, 3), (3, 4), "
+            + "(4, 5), (5, 6), (6, 7), (7, 8)])"
+        )
+        assert repr(ev) == rep
+
+    def test_contains_with_nbunch(self):
+        ev = self.eview(self.G)
+        evn = ev(nbunch=[0, 2])
+        assert not (0, 1) in evn
+        assert (1, 2) in evn
+        assert not (2, 3) in evn
+        assert not (3, 4) in evn
+        assert not (4, 5) in evn
+        assert not (5, 6) in evn
+        assert not (7, 8) in evn
+        assert not (8, 9) in evn
+
+
+class TestMultiEdgeView(TestEdgeView):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, nx.MultiGraph())
+        cls.G.add_edge(1, 2, key=3, foo="bar")
+        cls.eview = nx.reportviews.MultiEdgeView
+
+    def modify_edge(self, G, e, **kwds):
+        if len(e) == 2:
+            e = e + (0,)
+        G._adj[e[0]][e[1]][e[2]].update(kwds)
+
+    def test_str(self):
+        ev = self.eview(self.G)
+        replist = [(n, n + 1, 0) for n in range(8)]
+        replist.insert(2, (1, 2, 3))
+        rep = str(replist)
+        assert str(ev) == rep
+
+    def test_getitem(self):
+        G = self.G.copy()
+        ev = G.edges
+        G.edges[0, 1, 0]["foo"] = "bar"
+        assert ev[0, 1, 0] == {"foo": "bar"}
+
+        # slicing
+        with pytest.raises(nx.NetworkXError):
+            G.edges[0:5]
+
+    def test_repr(self):
+        ev = self.eview(self.G)
+        rep = (
+            "MultiEdgeView([(0, 1, 0), (1, 2, 0), (1, 2, 3), (2, 3, 0), "
+            + "(3, 4, 0), (4, 5, 0), (5, 6, 0), (6, 7, 0), (7, 8, 0)])"
+        )
+        assert repr(ev) == rep
+
+    def test_call(self):
+        ev = self.eview(self.G)
+        assert id(ev) == id(ev(keys=True))
+        assert id(ev) == id(ev(data=False, keys=True))
+        assert id(ev) != id(ev(keys=False))
+        assert id(ev) != id(ev(data=True))
+        assert id(ev) != id(ev(nbunch=1))
+
+    def test_data(self):
+        ev = self.eview(self.G)
+        assert id(ev) != id(ev.data())
+        assert id(ev) == id(ev.data(data=False, keys=True))
+        assert id(ev) != id(ev.data(keys=False))
+        assert id(ev) != id(ev.data(data=True))
+        assert id(ev) != id(ev.data(nbunch=1))
+
+    def test_iter(self):
+        ev = self.eview(self.G)
+        for u, v, k in ev:
+            pass
+        iev = iter(ev)
+        assert next(iev) == (0, 1, 0)
+        assert iter(ev) != ev
+        assert iter(iev) == iev
+
+    def test_iterkeys(self):
+        G = self.G
+        evr = self.eview(G)
+        ev = evr(keys=True)
+        for u, v, k in ev:
+            pass
+        assert k == 0
+        ev = evr(keys=True, data="foo", default=1)
+        for u, v, k, wt in ev:
+            pass
+        assert wt == 1
+
+        self.modify_edge(G, (2, 3, 0), foo="bar")
+        ev = evr(keys=True, data=True)
+        for e in ev:
+            assert len(e) == 4
+            print("edge:", e)
+            if set(e[:2]) == {2, 3}:
+                print(self.G._adj[2][3])
+                assert e[2] == 0
+                assert e[3] == {"foo": "bar"}
+                checked = True
+            elif set(e[:3]) == {1, 2, 3}:
+                assert e[2] == 3
+                assert e[3] == {"foo": "bar"}
+                checked_multi = True
+            else:
+                assert e[2] == 0
+                assert e[3] == {}
+        assert checked
+        assert checked_multi
+        ev = evr(keys=True, data="foo", default=1)
+        for e in ev:
+            if set(e[:2]) == {1, 2} and e[2] == 3:
+                assert e[3] == "bar"
+            if set(e[:2]) == {1, 2} and e[2] == 0:
+                assert e[3] == 1
+            if set(e[:2]) == {2, 3}:
+                assert e[2] == 0
+                assert e[3] == "bar"
+                assert len(e) == 4
+                checked_wt = True
+        assert checked_wt
+        ev = evr(keys=True)
+        for e in ev:
+            assert len(e) == 3
+        elist = sorted([(i, i + 1, 0) for i in range(8)] + [(1, 2, 3)])
+        assert sorted(list(ev)) == elist
+        # test order of arguments:graph, nbunch, data, keys, default
+        ev = evr((1, 2), "foo", True, 1)
+        for e in ev:
+            if set(e[:2]) == {1, 2}:
+                assert e[2] in {0, 3}
+                if e[2] == 3:
+                    assert e[3] == "bar"
+                else:  # e[2] == 0
+                    assert e[3] == 1
+        if G.is_directed():
+            assert len(list(ev)) == 3
+        else:
+            assert len(list(ev)) == 4
+
+    def test_or(self):
+        # print("G | H edges:", gnv | hnv)
+        ev = self.eview(self.G)
+        some_edges = {(0, 1, 0), (1, 0, 0), (0, 2, 0)}
+        result = {(n, n + 1, 0) for n in range(8)}
+        result.update(some_edges)
+        result.update({(1, 2, 3)})
+        assert ev | some_edges == result
+        assert some_edges | ev == result
+
+    def test_sub(self):
+        # print("G - H edges:", gnv - hnv)
+        ev = self.eview(self.G)
+        some_edges = {(0, 1, 0), (1, 0, 0), (0, 2, 0)}
+        result = {(n, n + 1, 0) for n in range(8)}
+        result.remove((0, 1, 0))
+        result.update({(1, 2, 3)})
+        assert ev - some_edges, result
+        assert some_edges - ev, result
+
+    def test_xor(self):
+        # print("G ^ H edges:", gnv ^ hnv)
+        ev = self.eview(self.G)
+        some_edges = {(0, 1, 0), (1, 0, 0), (0, 2, 0)}
+        if self.G.is_directed():
+            result = {(n, n + 1, 0) for n in range(1, 8)}
+            result.update({(1, 0, 0), (0, 2, 0), (1, 2, 3)})
+            assert ev ^ some_edges == result
+            assert some_edges ^ ev == result
+        else:
+            result = {(n, n + 1, 0) for n in range(1, 8)}
+            result.update({(0, 2, 0), (1, 2, 3)})
+            assert ev ^ some_edges == result
+            assert some_edges ^ ev == result
+
+    def test_and(self):
+        # print("G & H edges:", gnv & hnv)
+        ev = self.eview(self.G)
+        some_edges = {(0, 1, 0), (1, 0, 0), (0, 2, 0)}
+        if self.G.is_directed():
+            assert ev & some_edges == {(0, 1, 0)}
+            assert some_edges & ev == {(0, 1, 0)}
+        else:
+            assert ev & some_edges == {(0, 1, 0), (1, 0, 0)}
+            assert some_edges & ev == {(0, 1, 0), (1, 0, 0)}
+
+    def test_contains_with_nbunch(self):
+        ev = self.eview(self.G)
+        evn = ev(nbunch=[0, 2])
+        assert (0, 1) in evn
+        assert (1, 2) in evn
+        assert (2, 3) in evn
+        assert not (3, 4) in evn
+        assert not (4, 5) in evn
+        assert not (5, 6) in evn
+        assert not (7, 8) in evn
+        assert not (8, 9) in evn
+
+
+class TestOutMultiEdgeView(TestMultiEdgeView):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, nx.MultiDiGraph())
+        cls.G.add_edge(1, 2, key=3, foo="bar")
+        cls.eview = nx.reportviews.OutMultiEdgeView
+
+    def modify_edge(self, G, e, **kwds):
+        if len(e) == 2:
+            e = e + (0,)
+        G._adj[e[0]][e[1]][e[2]].update(kwds)
+
+    def test_repr(self):
+        ev = self.eview(self.G)
+        rep = (
+            "OutMultiEdgeView([(0, 1, 0), (1, 2, 0), (1, 2, 3), (2, 3, 0),"
+            + " (3, 4, 0), (4, 5, 0), (5, 6, 0), (6, 7, 0), (7, 8, 0)])"
+        )
+        assert repr(ev) == rep
+
+    def test_contains_with_nbunch(self):
+        ev = self.eview(self.G)
+        evn = ev(nbunch=[0, 2])
+        assert (0, 1) in evn
+        assert not (1, 2) in evn
+        assert (2, 3) in evn
+        assert not (3, 4) in evn
+        assert not (4, 5) in evn
+        assert not (5, 6) in evn
+        assert not (7, 8) in evn
+        assert not (8, 9) in evn
+
+
+class TestInMultiEdgeView(TestMultiEdgeView):
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, nx.MultiDiGraph())
+        cls.G.add_edge(1, 2, key=3, foo="bar")
+        cls.eview = nx.reportviews.InMultiEdgeView
+
+    def modify_edge(self, G, e, **kwds):
+        if len(e) == 2:
+            e = e + (0,)
+        G._adj[e[0]][e[1]][e[2]].update(kwds)
+
+    def test_repr(self):
+        ev = self.eview(self.G)
+        rep = (
+            "InMultiEdgeView([(0, 1, 0), (1, 2, 0), (1, 2, 3), (2, 3, 0), "
+            + "(3, 4, 0), (4, 5, 0), (5, 6, 0), (6, 7, 0), (7, 8, 0)])"
+        )
+        assert repr(ev) == rep
+
+    def test_contains_with_nbunch(self):
+        ev = self.eview(self.G)
+        evn = ev(nbunch=[0, 2])
+        assert not (0, 1) in evn
+        assert (1, 2) in evn
+        assert not (2, 3) in evn
+        assert not (3, 4) in evn
+        assert not (4, 5) in evn
+        assert not (5, 6) in evn
+        assert not (7, 8) in evn
+        assert not (8, 9) in evn
+
+
+# Degrees
+class TestDegreeView:
+    GRAPH = nx.Graph
+    dview = nx.reportviews.DegreeView
+
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(6, cls.GRAPH())
+        cls.G.add_edge(1, 3, foo=2)
+        cls.G.add_edge(1, 3, foo=3)
+
+    def test_pickle(self):
+        import pickle
+
+        deg = self.G.degree
+        pdeg = pickle.loads(pickle.dumps(deg, -1))
+        assert dict(deg) == dict(pdeg)
+
+    def test_str(self):
+        dv = self.dview(self.G)
+        rep = str([(0, 1), (1, 3), (2, 2), (3, 3), (4, 2), (5, 1)])
+        assert str(dv) == rep
+        dv = self.G.degree()
+        assert str(dv) == rep
+
+    def test_repr(self):
+        dv = self.dview(self.G)
+        rep = "DegreeView({0: 1, 1: 3, 2: 2, 3: 3, 4: 2, 5: 1})"
+        assert repr(dv) == rep
+
+    def test_iter(self):
+        dv = self.dview(self.G)
+        for n, d in dv:
+            pass
+        idv = iter(dv)
+        assert iter(dv) != dv
+        assert iter(idv) == idv
+        assert next(idv) == (0, dv[0])
+        assert next(idv) == (1, dv[1])
+        # weighted
+        dv = self.dview(self.G, weight="foo")
+        for n, d in dv:
+            pass
+        idv = iter(dv)
+        assert iter(dv) != dv
+        assert iter(idv) == idv
+        assert next(idv) == (0, dv[0])
+        assert next(idv) == (1, dv[1])
+
+    def test_nbunch(self):
+        dv = self.dview(self.G)
+        dvn = dv(0)
+        assert dvn == 1
+        dvn = dv([2, 3])
+        assert sorted(dvn) == [(2, 2), (3, 3)]
+
+    def test_getitem(self):
+        dv = self.dview(self.G)
+        assert dv[0] == 1
+        assert dv[1] == 3
+        assert dv[2] == 2
+        assert dv[3] == 3
+        dv = self.dview(self.G, weight="foo")
+        assert dv[0] == 1
+        assert dv[1] == 5
+        assert dv[2] == 2
+        assert dv[3] == 5
+
+    def test_weight(self):
+        dv = self.dview(self.G)
+        dvw = dv(0, weight="foo")
+        assert dvw == 1
+        dvw = dv(1, weight="foo")
+        assert dvw == 5
+        dvw = dv([2, 3], weight="foo")
+        assert sorted(dvw) == [(2, 2), (3, 5)]
+        dvd = dict(dv(weight="foo"))
+        assert dvd[0] == 1
+        assert dvd[1] == 5
+        assert dvd[2] == 2
+        assert dvd[3] == 5
+
+    def test_len(self):
+        dv = self.dview(self.G)
+        assert len(dv) == 6
+
+
+class TestDiDegreeView(TestDegreeView):
+    GRAPH = nx.DiGraph
+    dview = nx.reportviews.DiDegreeView
+
+    def test_repr(self):
+        dv = self.G.degree()
+        rep = "DiDegreeView({0: 1, 1: 3, 2: 2, 3: 3, 4: 2, 5: 1})"
+        assert repr(dv) == rep
+
+
+class TestOutDegreeView(TestDegreeView):
+    GRAPH = nx.DiGraph
+    dview = nx.reportviews.OutDegreeView
+
+    def test_str(self):
+        dv = self.dview(self.G)
+        rep = str([(0, 1), (1, 2), (2, 1), (3, 1), (4, 1), (5, 0)])
+        assert str(dv) == rep
+        dv = self.G.out_degree()
+        assert str(dv) == rep
+
+    def test_repr(self):
+        dv = self.G.out_degree()
+        rep = "OutDegreeView({0: 1, 1: 2, 2: 1, 3: 1, 4: 1, 5: 0})"
+        assert repr(dv) == rep
+
+    def test_nbunch(self):
+        dv = self.dview(self.G)
+        dvn = dv(0)
+        assert dvn == 1
+        dvn = dv([2, 3])
+        assert sorted(dvn) == [(2, 1), (3, 1)]
+
+    def test_getitem(self):
+        dv = self.dview(self.G)
+        assert dv[0] == 1
+        assert dv[1] == 2
+        assert dv[2] == 1
+        assert dv[3] == 1
+        dv = self.dview(self.G, weight="foo")
+        assert dv[0] == 1
+        assert dv[1] == 4
+        assert dv[2] == 1
+        assert dv[3] == 1
+
+    def test_weight(self):
+        dv = self.dview(self.G)
+        dvw = dv(0, weight="foo")
+        assert dvw == 1
+        dvw = dv(1, weight="foo")
+        assert dvw == 4
+        dvw = dv([2, 3], weight="foo")
+        assert sorted(dvw) == [(2, 1), (3, 1)]
+        dvd = dict(dv(weight="foo"))
+        assert dvd[0] == 1
+        assert dvd[1] == 4
+        assert dvd[2] == 1
+        assert dvd[3] == 1
+
+
+class TestInDegreeView(TestDegreeView):
+    GRAPH = nx.DiGraph
+    dview = nx.reportviews.InDegreeView
+
+    def test_str(self):
+        dv = self.dview(self.G)
+        rep = str([(0, 0), (1, 1), (2, 1), (3, 2), (4, 1), (5, 1)])
+        assert str(dv) == rep
+        dv = self.G.in_degree()
+        assert str(dv) == rep
+
+    def test_repr(self):
+        dv = self.G.in_degree()
+        rep = "InDegreeView({0: 0, 1: 1, 2: 1, 3: 2, 4: 1, 5: 1})"
+        assert repr(dv) == rep
+
+    def test_nbunch(self):
+        dv = self.dview(self.G)
+        dvn = dv(0)
+        assert dvn == 0
+        dvn = dv([2, 3])
+        assert sorted(dvn) == [(2, 1), (3, 2)]
+
+    def test_getitem(self):
+        dv = self.dview(self.G)
+        assert dv[0] == 0
+        assert dv[1] == 1
+        assert dv[2] == 1
+        assert dv[3] == 2
+        dv = self.dview(self.G, weight="foo")
+        assert dv[0] == 0
+        assert dv[1] == 1
+        assert dv[2] == 1
+        assert dv[3] == 4
+
+    def test_weight(self):
+        dv = self.dview(self.G)
+        dvw = dv(0, weight="foo")
+        assert dvw == 0
+        dvw = dv(1, weight="foo")
+        assert dvw == 1
+        dvw = dv([2, 3], weight="foo")
+        assert sorted(dvw) == [(2, 1), (3, 4)]
+        dvd = dict(dv(weight="foo"))
+        assert dvd[0] == 0
+        assert dvd[1] == 1
+        assert dvd[2] == 1
+        assert dvd[3] == 4
+
+
+class TestMultiDegreeView(TestDegreeView):
+    GRAPH = nx.MultiGraph
+    dview = nx.reportviews.MultiDegreeView
+
+    def test_str(self):
+        dv = self.dview(self.G)
+        rep = str([(0, 1), (1, 4), (2, 2), (3, 4), (4, 2), (5, 1)])
+        assert str(dv) == rep
+        dv = self.G.degree()
+        assert str(dv) == rep
+
+    def test_repr(self):
+        dv = self.G.degree()
+        rep = "MultiDegreeView({0: 1, 1: 4, 2: 2, 3: 4, 4: 2, 5: 1})"
+        assert repr(dv) == rep
+
+    def test_nbunch(self):
+        dv = self.dview(self.G)
+        dvn = dv(0)
+        assert dvn == 1
+        dvn = dv([2, 3])
+        assert sorted(dvn) == [(2, 2), (3, 4)]
+
+    def test_getitem(self):
+        dv = self.dview(self.G)
+        assert dv[0] == 1
+        assert dv[1] == 4
+        assert dv[2] == 2
+        assert dv[3] == 4
+        dv = self.dview(self.G, weight="foo")
+        assert dv[0] == 1
+        assert dv[1] == 7
+        assert dv[2] == 2
+        assert dv[3] == 7
+
+    def test_weight(self):
+        dv = self.dview(self.G)
+        dvw = dv(0, weight="foo")
+        assert dvw == 1
+        dvw = dv(1, weight="foo")
+        assert dvw == 7
+        dvw = dv([2, 3], weight="foo")
+        assert sorted(dvw) == [(2, 2), (3, 7)]
+        dvd = dict(dv(weight="foo"))
+        assert dvd[0] == 1
+        assert dvd[1] == 7
+        assert dvd[2] == 2
+        assert dvd[3] == 7
+
+
+class TestDiMultiDegreeView(TestMultiDegreeView):
+    GRAPH = nx.MultiDiGraph
+    dview = nx.reportviews.DiMultiDegreeView
+
+    def test_repr(self):
+        dv = self.G.degree()
+        rep = "DiMultiDegreeView({0: 1, 1: 4, 2: 2, 3: 4, 4: 2, 5: 1})"
+        assert repr(dv) == rep
+
+
+class TestOutMultiDegreeView(TestDegreeView):
+    GRAPH = nx.MultiDiGraph
+    dview = nx.reportviews.OutMultiDegreeView
+
+    def test_str(self):
+        dv = self.dview(self.G)
+        rep = str([(0, 1), (1, 3), (2, 1), (3, 1), (4, 1), (5, 0)])
+        assert str(dv) == rep
+        dv = self.G.out_degree()
+        assert str(dv) == rep
+
+    def test_repr(self):
+        dv = self.G.out_degree()
+        rep = "OutMultiDegreeView({0: 1, 1: 3, 2: 1, 3: 1, 4: 1, 5: 0})"
+        assert repr(dv) == rep
+
+    def test_nbunch(self):
+        dv = self.dview(self.G)
+        dvn = dv(0)
+        assert dvn == 1
+        dvn = dv([2, 3])
+        assert sorted(dvn) == [(2, 1), (3, 1)]
+
+    def test_getitem(self):
+        dv = self.dview(self.G)
+        assert dv[0] == 1
+        assert dv[1] == 3
+        assert dv[2] == 1
+        assert dv[3] == 1
+        dv = self.dview(self.G, weight="foo")
+        assert dv[0] == 1
+        assert dv[1] == 6
+        assert dv[2] == 1
+        assert dv[3] == 1
+
+    def test_weight(self):
+        dv = self.dview(self.G)
+        dvw = dv(0, weight="foo")
+        assert dvw == 1
+        dvw = dv(1, weight="foo")
+        assert dvw == 6
+        dvw = dv([2, 3], weight="foo")
+        assert sorted(dvw) == [(2, 1), (3, 1)]
+        dvd = dict(dv(weight="foo"))
+        assert dvd[0] == 1
+        assert dvd[1] == 6
+        assert dvd[2] == 1
+        assert dvd[3] == 1
+
+
+class TestInMultiDegreeView(TestDegreeView):
+    GRAPH = nx.MultiDiGraph
+    dview = nx.reportviews.InMultiDegreeView
+
+    def test_str(self):
+        dv = self.dview(self.G)
+        rep = str([(0, 0), (1, 1), (2, 1), (3, 3), (4, 1), (5, 1)])
+        assert str(dv) == rep
+        dv = self.G.in_degree()
+        assert str(dv) == rep
+
+    def test_repr(self):
+        dv = self.G.in_degree()
+        rep = "InMultiDegreeView({0: 0, 1: 1, 2: 1, 3: 3, 4: 1, 5: 1})"
+        assert repr(dv) == rep
+
+    def test_nbunch(self):
+        dv = self.dview(self.G)
+        dvn = dv(0)
+        assert dvn == 0
+        dvn = dv([2, 3])
+        assert sorted(dvn) == [(2, 1), (3, 3)]
+
+    def test_getitem(self):
+        dv = self.dview(self.G)
+        assert dv[0] == 0
+        assert dv[1] == 1
+        assert dv[2] == 1
+        assert dv[3] == 3
+        dv = self.dview(self.G, weight="foo")
+        assert dv[0] == 0
+        assert dv[1] == 1
+        assert dv[2] == 1
+        assert dv[3] == 6
+
+    def test_weight(self):
+        dv = self.dview(self.G)
+        dvw = dv(0, weight="foo")
+        assert dvw == 0
+        dvw = dv(1, weight="foo")
+        assert dvw == 1
+        dvw = dv([2, 3], weight="foo")
+        assert sorted(dvw) == [(2, 1), (3, 6)]
+        dvd = dict(dv(weight="foo"))
+        assert dvd[0] == 0
+        assert dvd[1] == 1
+        assert dvd[2] == 1
+        assert dvd[3] == 6
+
+
+@pytest.mark.parametrize(
+    ("reportview", "err_msg_terms"),
+    (
+        (rv.NodeView, "list(G.nodes"),
+        (rv.NodeDataView, "list(G.nodes.data"),
+        (rv.EdgeView, "list(G.edges"),
+        # Directed EdgeViews
+        (rv.InEdgeView, "list(G.in_edges"),
+        (rv.OutEdgeView, "list(G.edges"),
+        # Multi EdgeViews
+        (rv.MultiEdgeView, "list(G.edges"),
+        (rv.InMultiEdgeView, "list(G.in_edges"),
+        (rv.OutMultiEdgeView, "list(G.edges"),
+    ),
+)
+def test_slicing_reportviews(reportview, err_msg_terms):
+    G = nx.complete_graph(3)
+    view = reportview(G)
+    with pytest.raises(nx.NetworkXError) as exc:
+        view[0:2]
+    errmsg = str(exc.value)
+    assert type(view).__name__ in errmsg
+    assert err_msg_terms in errmsg
+
+
+@pytest.mark.parametrize(
+    "graph", [nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph]
+)
+def test_cache_dict_get_set_state(graph):
+    G = nx.path_graph(5, graph())
+    G.nodes, G.edges, G.adj, G.degree
+    if G.is_directed():
+        G.pred, G.succ, G.in_edges, G.out_edges, G.in_degree, G.out_degree
+    cached_dict = G.__dict__
+    assert "nodes" in cached_dict
+    assert "edges" in cached_dict
+    assert "adj" in cached_dict
+    assert "degree" in cached_dict
+    if G.is_directed():
+        assert "pred" in cached_dict
+        assert "succ" in cached_dict
+        assert "in_edges" in cached_dict
+        assert "out_edges" in cached_dict
+        assert "in_degree" in cached_dict
+        assert "out_degree" in cached_dict
+
+    # Raises error if the cached properties and views do not work
+    pickle.loads(pickle.dumps(G, -1))
+    deepcopy(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_special.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_special.py
new file mode 100644
index 0000000..fbeb5f8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_special.py
@@ -0,0 +1,187 @@
+from collections import OrderedDict
+
+import networkx as nx
+
+from .test_digraph import BaseDiGraphTester
+from .test_digraph import TestDiGraph as _TestDiGraph
+from .test_graph import BaseGraphTester
+from .test_graph import TestGraph as _TestGraph
+from .test_multidigraph import TestMultiDiGraph as _TestMultiDiGraph
+from .test_multigraph import TestMultiGraph as _TestMultiGraph
+
+
+def test_factories():
+    class mydict1(dict):
+        pass
+
+    class mydict2(dict):
+        pass
+
+    class mydict3(dict):
+        pass
+
+    class mydict4(dict):
+        pass
+
+    class mydict5(dict):
+        pass
+
+    for Graph in (nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph):
+        # print("testing class: ", Graph.__name__)
+        class MyGraph(Graph):
+            node_dict_factory = mydict1
+            adjlist_outer_dict_factory = mydict2
+            adjlist_inner_dict_factory = mydict3
+            edge_key_dict_factory = mydict4
+            edge_attr_dict_factory = mydict5
+
+        G = MyGraph()
+        assert isinstance(G._node, mydict1)
+        assert isinstance(G._adj, mydict2)
+        G.add_node(1)
+        assert isinstance(G._adj[1], mydict3)
+        if G.is_directed():
+            assert isinstance(G._pred, mydict2)
+            assert isinstance(G._succ, mydict2)
+            assert isinstance(G._pred[1], mydict3)
+        G.add_edge(1, 2)
+        if G.is_multigraph():
+            assert isinstance(G._adj[1][2], mydict4)
+            assert isinstance(G._adj[1][2][0], mydict5)
+        else:
+            assert isinstance(G._adj[1][2], mydict5)
+
+
+class TestSpecialGraph(_TestGraph):
+    def setup_method(self):
+        _TestGraph.setup_method(self)
+        self.Graph = nx.Graph
+
+
+class TestOrderedGraph(_TestGraph):
+    def setup_method(self):
+        _TestGraph.setup_method(self)
+
+        class MyGraph(nx.Graph):
+            node_dict_factory = OrderedDict
+            adjlist_outer_dict_factory = OrderedDict
+            adjlist_inner_dict_factory = OrderedDict
+            edge_attr_dict_factory = OrderedDict
+
+        self.Graph = MyGraph
+
+
+class TestThinGraph(BaseGraphTester):
+    def setup_method(self):
+        all_edge_dict = {"weight": 1}
+
+        class MyGraph(nx.Graph):
+            def edge_attr_dict_factory(self):
+                return all_edge_dict
+
+        self.Graph = MyGraph
+        # build dict-of-dict-of-dict K3
+        ed1, ed2, ed3 = (all_edge_dict, all_edge_dict, all_edge_dict)
+        self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed1, 2: ed3}, 2: {0: ed2, 1: ed3}}
+        self.k3edges = [(0, 1), (0, 2), (1, 2)]
+        self.k3nodes = [0, 1, 2]
+        self.K3 = self.Graph()
+        self.K3._adj = self.k3adj
+        self.K3._node = {}
+        self.K3._node[0] = {}
+        self.K3._node[1] = {}
+        self.K3._node[2] = {}
+
+
+class TestSpecialDiGraph(_TestDiGraph):
+    def setup_method(self):
+        _TestDiGraph.setup_method(self)
+        self.Graph = nx.DiGraph
+
+
+class TestOrderedDiGraph(_TestDiGraph):
+    def setup_method(self):
+        _TestDiGraph.setup_method(self)
+
+        class MyGraph(nx.DiGraph):
+            node_dict_factory = OrderedDict
+            adjlist_outer_dict_factory = OrderedDict
+            adjlist_inner_dict_factory = OrderedDict
+            edge_attr_dict_factory = OrderedDict
+
+        self.Graph = MyGraph
+
+
+class TestThinDiGraph(BaseDiGraphTester):
+    def setup_method(self):
+        all_edge_dict = {"weight": 1}
+
+        class MyGraph(nx.DiGraph):
+            def edge_attr_dict_factory(self):
+                return all_edge_dict
+
+        self.Graph = MyGraph
+        # build dict-of-dict-of-dict K3
+        ed1, ed2, ed3 = (all_edge_dict, all_edge_dict, all_edge_dict)
+        ed4, ed5, ed6 = (all_edge_dict, all_edge_dict, all_edge_dict)
+        self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed3, 2: ed4}, 2: {0: ed5, 1: ed6}}
+        self.k3edges = [(0, 1), (0, 2), (1, 2)]
+        self.k3nodes = [0, 1, 2]
+        self.K3 = self.Graph()
+        self.K3._succ = self.k3adj
+        # K3._adj is synced with K3._succ
+        self.K3._pred = {0: {1: ed3, 2: ed5}, 1: {0: ed1, 2: ed6}, 2: {0: ed2, 1: ed4}}
+        self.K3._node = {}
+        self.K3._node[0] = {}
+        self.K3._node[1] = {}
+        self.K3._node[2] = {}
+
+        ed1, ed2 = (all_edge_dict, all_edge_dict)
+        self.P3 = self.Graph()
+        self.P3._succ = {0: {1: ed1}, 1: {2: ed2}, 2: {}}
+        # P3._adj is synced with P3._succ
+        self.P3._pred = {0: {}, 1: {0: ed1}, 2: {1: ed2}}
+        self.P3._node = {}
+        self.P3._node[0] = {}
+        self.P3._node[1] = {}
+        self.P3._node[2] = {}
+
+
+class TestSpecialMultiGraph(_TestMultiGraph):
+    def setup_method(self):
+        _TestMultiGraph.setup_method(self)
+        self.Graph = nx.MultiGraph
+
+
+class TestOrderedMultiGraph(_TestMultiGraph):
+    def setup_method(self):
+        _TestMultiGraph.setup_method(self)
+
+        class MyGraph(nx.MultiGraph):
+            node_dict_factory = OrderedDict
+            adjlist_outer_dict_factory = OrderedDict
+            adjlist_inner_dict_factory = OrderedDict
+            edge_key_dict_factory = OrderedDict
+            edge_attr_dict_factory = OrderedDict
+
+        self.Graph = MyGraph
+
+
+class TestSpecialMultiDiGraph(_TestMultiDiGraph):
+    def setup_method(self):
+        _TestMultiDiGraph.setup_method(self)
+        self.Graph = nx.MultiDiGraph
+
+
+class TestOrderedMultiDiGraph(_TestMultiDiGraph):
+    def setup_method(self):
+        _TestMultiDiGraph.setup_method(self)
+
+        class MyGraph(nx.MultiDiGraph):
+            node_dict_factory = OrderedDict
+            adjlist_outer_dict_factory = OrderedDict
+            adjlist_inner_dict_factory = OrderedDict
+            edge_key_dict_factory = OrderedDict
+            edge_attr_dict_factory = OrderedDict
+
+        self.Graph = MyGraph
diff --git a/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_subgraphviews.py b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_subgraphviews.py
new file mode 100644
index 0000000..63c5136
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/classes/tests/test_subgraphviews.py
@@ -0,0 +1,363 @@
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal
+
+
+class TestSubGraphView:
+    gview = staticmethod(nx.graphviews.subgraph_view)
+    graph = nx.Graph
+    hide_edges_filter = staticmethod(nx.filters.hide_edges)
+    show_edges_filter = staticmethod(nx.filters.show_edges)
+
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, create_using=cls.graph())
+        cls.hide_edges_w_hide_nodes = {(3, 4), (4, 5), (5, 6)}
+
+    def test_hidden_nodes(self):
+        hide_nodes = [4, 5, 111]
+        nodes_gone = nx.filters.hide_nodes(hide_nodes)
+        gview = self.gview
+        print(gview)
+        G = gview(self.G, filter_node=nodes_gone)
+        assert self.G.nodes - G.nodes == {4, 5}
+        assert self.G.edges - G.edges == self.hide_edges_w_hide_nodes
+        if G.is_directed():
+            assert list(G[3]) == []
+            assert list(G[2]) == [3]
+        else:
+            assert list(G[3]) == [2]
+            assert set(G[2]) == {1, 3}
+        pytest.raises(KeyError, G.__getitem__, 4)
+        pytest.raises(KeyError, G.__getitem__, 112)
+        pytest.raises(KeyError, G.__getitem__, 111)
+        assert G.degree(3) == (3 if G.is_multigraph() else 1)
+        assert G.size() == (7 if G.is_multigraph() else 5)
+
+    def test_hidden_edges(self):
+        hide_edges = [(2, 3), (8, 7), (222, 223)]
+        edges_gone = self.hide_edges_filter(hide_edges)
+        gview = self.gview
+        G = gview(self.G, filter_edge=edges_gone)
+        assert self.G.nodes == G.nodes
+        if G.is_directed():
+            assert self.G.edges - G.edges == {(2, 3)}
+            assert list(G[2]) == []
+            assert list(G.pred[3]) == []
+            assert list(G.pred[2]) == [1]
+            assert G.size() == 7
+        else:
+            assert self.G.edges - G.edges == {(2, 3), (7, 8)}
+            assert list(G[2]) == [1]
+            assert G.size() == 6
+        assert list(G[3]) == [4]
+        pytest.raises(KeyError, G.__getitem__, 221)
+        pytest.raises(KeyError, G.__getitem__, 222)
+        assert G.degree(3) == 1
+
+    def test_shown_node(self):
+        induced_subgraph = nx.filters.show_nodes([2, 3, 111])
+        gview = self.gview
+        G = gview(self.G, filter_node=induced_subgraph)
+        assert set(G.nodes) == {2, 3}
+        if G.is_directed():
+            assert list(G[3]) == []
+        else:
+            assert list(G[3]) == [2]
+        assert list(G[2]) == [3]
+        pytest.raises(KeyError, G.__getitem__, 4)
+        pytest.raises(KeyError, G.__getitem__, 112)
+        pytest.raises(KeyError, G.__getitem__, 111)
+        assert G.degree(3) == (3 if G.is_multigraph() else 1)
+        assert G.size() == (3 if G.is_multigraph() else 1)
+
+    def test_shown_edges(self):
+        show_edges = [(2, 3), (8, 7), (222, 223)]
+        edge_subgraph = self.show_edges_filter(show_edges)
+        G = self.gview(self.G, filter_edge=edge_subgraph)
+        assert self.G.nodes == G.nodes
+        if G.is_directed():
+            assert G.edges == {(2, 3)}
+            assert list(G[3]) == []
+            assert list(G[2]) == [3]
+            assert list(G.pred[3]) == [2]
+            assert list(G.pred[2]) == []
+            assert G.size() == 1
+        else:
+            assert G.edges == {(2, 3), (7, 8)}
+            assert list(G[3]) == [2]
+            assert list(G[2]) == [3]
+            assert G.size() == 2
+        pytest.raises(KeyError, G.__getitem__, 221)
+        pytest.raises(KeyError, G.__getitem__, 222)
+        assert G.degree(3) == 1
+
+
+class TestSubDiGraphView(TestSubGraphView):
+    gview = staticmethod(nx.graphviews.subgraph_view)
+    graph = nx.DiGraph
+    hide_edges_filter = staticmethod(nx.filters.hide_diedges)
+    show_edges_filter = staticmethod(nx.filters.show_diedges)
+    hide_edges = [(2, 3), (8, 7), (222, 223)]
+    excluded = {(2, 3), (3, 4), (4, 5), (5, 6)}
+
+    def test_inoutedges(self):
+        edges_gone = self.hide_edges_filter(self.hide_edges)
+        hide_nodes = [4, 5, 111]
+        nodes_gone = nx.filters.hide_nodes(hide_nodes)
+        G = self.gview(self.G, nodes_gone, edges_gone)
+
+        assert self.G.in_edges - G.in_edges == self.excluded
+        assert self.G.out_edges - G.out_edges == self.excluded
+
+    def test_pred(self):
+        edges_gone = self.hide_edges_filter(self.hide_edges)
+        hide_nodes = [4, 5, 111]
+        nodes_gone = nx.filters.hide_nodes(hide_nodes)
+        G = self.gview(self.G, nodes_gone, edges_gone)
+
+        assert list(G.pred[2]) == [1]
+        assert list(G.pred[6]) == []
+
+    def test_inout_degree(self):
+        edges_gone = self.hide_edges_filter(self.hide_edges)
+        hide_nodes = [4, 5, 111]
+        nodes_gone = nx.filters.hide_nodes(hide_nodes)
+        G = self.gview(self.G, nodes_gone, edges_gone)
+
+        assert G.degree(2) == 1
+        assert G.out_degree(2) == 0
+        assert G.in_degree(2) == 1
+        assert G.size() == 4
+
+
+# multigraph
+class TestMultiGraphView(TestSubGraphView):
+    gview = staticmethod(nx.graphviews.subgraph_view)
+    graph = nx.MultiGraph
+    hide_edges_filter = staticmethod(nx.filters.hide_multiedges)
+    show_edges_filter = staticmethod(nx.filters.show_multiedges)
+
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.path_graph(9, create_using=cls.graph())
+        multiedges = {(2, 3, 4), (2, 3, 5)}
+        cls.G.add_edges_from(multiedges)
+        cls.hide_edges_w_hide_nodes = {(3, 4, 0), (4, 5, 0), (5, 6, 0)}
+
+    def test_hidden_edges(self):
+        hide_edges = [(2, 3, 4), (2, 3, 3), (8, 7, 0), (222, 223, 0)]
+        edges_gone = self.hide_edges_filter(hide_edges)
+        G = self.gview(self.G, filter_edge=edges_gone)
+        assert self.G.nodes == G.nodes
+        if G.is_directed():
+            assert self.G.edges - G.edges == {(2, 3, 4)}
+            assert list(G[3]) == [4]
+            assert list(G[2]) == [3]
+            assert list(G.pred[3]) == [2]  # only one 2 but two edges
+            assert list(G.pred[2]) == [1]
+            assert G.size() == 9
+        else:
+            assert self.G.edges - G.edges == {(2, 3, 4), (7, 8, 0)}
+            assert list(G[3]) == [2, 4]
+            assert list(G[2]) == [1, 3]
+            assert G.size() == 8
+        assert G.degree(3) == 3
+        pytest.raises(KeyError, G.__getitem__, 221)
+        pytest.raises(KeyError, G.__getitem__, 222)
+
+    def test_shown_edges(self):
+        show_edges = [(2, 3, 4), (2, 3, 3), (8, 7, 0), (222, 223, 0)]
+        edge_subgraph = self.show_edges_filter(show_edges)
+        G = self.gview(self.G, filter_edge=edge_subgraph)
+        assert self.G.nodes == G.nodes
+        if G.is_directed():
+            assert G.edges == {(2, 3, 4)}
+            assert list(G[3]) == []
+            assert list(G.pred[3]) == [2]
+            assert list(G.pred[2]) == []
+            assert G.size() == 1
+        else:
+            assert G.edges == {(2, 3, 4), (7, 8, 0)}
+            assert G.size() == 2
+            assert list(G[3]) == [2]
+        assert G.degree(3) == 1
+        assert list(G[2]) == [3]
+        pytest.raises(KeyError, G.__getitem__, 221)
+        pytest.raises(KeyError, G.__getitem__, 222)
+
+
+# multidigraph
+class TestMultiDiGraphView(TestMultiGraphView, TestSubDiGraphView):
+    gview = staticmethod(nx.graphviews.subgraph_view)
+    graph = nx.MultiDiGraph
+    hide_edges_filter = staticmethod(nx.filters.hide_multidiedges)
+    show_edges_filter = staticmethod(nx.filters.show_multidiedges)
+    hide_edges = [(2, 3, 0), (8, 7, 0), (222, 223, 0)]
+    excluded = {(2, 3, 0), (3, 4, 0), (4, 5, 0), (5, 6, 0)}
+
+    def test_inout_degree(self):
+        edges_gone = self.hide_edges_filter(self.hide_edges)
+        hide_nodes = [4, 5, 111]
+        nodes_gone = nx.filters.hide_nodes(hide_nodes)
+        G = self.gview(self.G, nodes_gone, edges_gone)
+
+        assert G.degree(2) == 3
+        assert G.out_degree(2) == 2
+        assert G.in_degree(2) == 1
+        assert G.size() == 6
+
+
+# induced_subgraph
+class TestInducedSubGraph:
+    @classmethod
+    def setup_class(cls):
+        cls.K3 = G = nx.complete_graph(3)
+        G.graph["foo"] = []
+        G.nodes[0]["foo"] = []
+        G.remove_edge(1, 2)
+        ll = []
+        G.add_edge(1, 2, foo=ll)
+        G.add_edge(2, 1, foo=ll)
+
+    def test_full_graph(self):
+        G = self.K3
+        H = nx.induced_subgraph(G, [0, 1, 2, 5])
+        assert H.name == G.name
+        self.graphs_equal(H, G)
+        self.same_attrdict(H, G)
+
+    def test_partial_subgraph(self):
+        G = self.K3
+        H = nx.induced_subgraph(G, 0)
+        assert dict(H.adj) == {0: {}}
+        assert dict(G.adj) != {0: {}}
+
+        H = nx.induced_subgraph(G, [0, 1])
+        assert dict(H.adj) == {0: {1: {}}, 1: {0: {}}}
+
+    def same_attrdict(self, H, G):
+        old_foo = H[1][2]["foo"]
+        H.edges[1, 2]["foo"] = "baz"
+        assert G.edges == H.edges
+        H.edges[1, 2]["foo"] = old_foo
+        assert G.edges == H.edges
+        old_foo = H.nodes[0]["foo"]
+        H.nodes[0]["foo"] = "baz"
+        assert G.nodes == H.nodes
+        H.nodes[0]["foo"] = old_foo
+        assert G.nodes == H.nodes
+
+    def graphs_equal(self, H, G):
+        assert G._adj == H._adj
+        assert G._node == H._node
+        assert G.graph == H.graph
+        assert G.name == H.name
+        if not G.is_directed() and not H.is_directed():
+            assert H._adj[1][2] is H._adj[2][1]
+            assert G._adj[1][2] is G._adj[2][1]
+        else:  # at least one is directed
+            if not G.is_directed():
+                G._pred = G._adj
+                G._succ = G._adj
+            if not H.is_directed():
+                H._pred = H._adj
+                H._succ = H._adj
+            assert G._pred == H._pred
+            assert G._succ == H._succ
+            assert H._succ[1][2] is H._pred[2][1]
+            assert G._succ[1][2] is G._pred[2][1]
+
+
+# edge_subgraph
+class TestEdgeSubGraph:
+    @classmethod
+    def setup_class(cls):
+        # Create a path graph on five nodes.
+        cls.G = G = nx.path_graph(5)
+        # Add some node, edge, and graph attributes.
+        for i in range(5):
+            G.nodes[i]["name"] = f"node{i}"
+        G.edges[0, 1]["name"] = "edge01"
+        G.edges[3, 4]["name"] = "edge34"
+        G.graph["name"] = "graph"
+        # Get the subgraph induced by the first and last edges.
+        cls.H = nx.edge_subgraph(G, [(0, 1), (3, 4)])
+
+    def test_correct_nodes(self):
+        """Tests that the subgraph has the correct nodes."""
+        assert [(0, "node0"), (1, "node1"), (3, "node3"), (4, "node4")] == sorted(
+            self.H.nodes.data("name")
+        )
+
+    def test_correct_edges(self):
+        """Tests that the subgraph has the correct edges."""
+        assert edges_equal(
+            [(0, 1, "edge01"), (3, 4, "edge34")], self.H.edges.data("name")
+        )
+
+    def test_add_node(self):
+        """Tests that adding a node to the original graph does not
+        affect the nodes of the subgraph.
+
+        """
+        self.G.add_node(5)
+        assert [0, 1, 3, 4] == sorted(self.H.nodes)
+        self.G.remove_node(5)
+
+    def test_remove_node(self):
+        """Tests that removing a node in the original graph
+        removes the nodes of the subgraph.
+
+        """
+        self.G.remove_node(0)
+        assert [1, 3, 4] == sorted(self.H.nodes)
+        self.G.add_node(0, name="node0")
+        self.G.add_edge(0, 1, name="edge01")
+
+    def test_node_attr_dict(self):
+        """Tests that the node attribute dictionary of the two graphs is
+        the same object.
+
+        """
+        for v in self.H:
+            assert self.G.nodes[v] == self.H.nodes[v]
+        # Making a change to G should make a change in H and vice versa.
+        self.G.nodes[0]["name"] = "foo"
+        assert self.G.nodes[0] == self.H.nodes[0]
+        self.H.nodes[1]["name"] = "bar"
+        assert self.G.nodes[1] == self.H.nodes[1]
+        # Revert the change, so tests pass with pytest-randomly
+        self.G.nodes[0]["name"] = "node0"
+        self.H.nodes[1]["name"] = "node1"
+
+    def test_edge_attr_dict(self):
+        """Tests that the edge attribute dictionary of the two graphs is
+        the same object.
+
+        """
+        for u, v in self.H.edges():
+            assert self.G.edges[u, v] == self.H.edges[u, v]
+        # Making a change to G should make a change in H and vice versa.
+        self.G.edges[0, 1]["name"] = "foo"
+        assert self.G.edges[0, 1]["name"] == self.H.edges[0, 1]["name"]
+        self.H.edges[3, 4]["name"] = "bar"
+        assert self.G.edges[3, 4]["name"] == self.H.edges[3, 4]["name"]
+        # Revert the change, so tests pass with pytest-randomly
+        self.G.edges[0, 1]["name"] = "edge01"
+        self.H.edges[3, 4]["name"] = "edge34"
+
+    def test_graph_attr_dict(self):
+        """Tests that the graph attribute dictionary of the two graphs
+        is the same object.
+
+        """
+        assert self.G.graph is self.H.graph
+
+    def test_readonly(self):
+        """Tests that the subgraph cannot change the graph structure"""
+        pytest.raises(nx.NetworkXError, self.H.add_node, 5)
+        pytest.raises(nx.NetworkXError, self.H.remove_node, 0)
+        pytest.raises(nx.NetworkXError, self.H.add_edge, 5, 6)
+        pytest.raises(nx.NetworkXError, self.H.remove_edge, 0, 1)
diff --git a/myenv/lib/python3.9/site-packages/networkx/conftest.py b/myenv/lib/python3.9/site-packages/networkx/conftest.py
new file mode 100644
index 0000000..bfed321
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/conftest.py
@@ -0,0 +1,393 @@
+"""
+Testing
+=======
+
+General guidelines for writing good tests:
+
+- doctests always assume ``import networkx as nx`` so don't add that
+- prefer pytest fixtures over classes with setup methods.
+- use the ``@pytest.mark.parametrize``  decorator
+- use ``pytest.importorskip`` for numpy, scipy, pandas, and matplotlib b/c of PyPy.
+  and add the module to the relevant entries below.
+
+"""
+import sys
+import warnings
+
+import pytest
+
+import networkx
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--runslow", action="store_true", default=False, help="run slow tests"
+    )
+
+
+def pytest_configure(config):
+    config.addinivalue_line("markers", "slow: mark test as slow to run")
+
+
+def pytest_collection_modifyitems(config, items):
+    if config.getoption("--runslow"):
+        # --runslow given in cli: do not skip slow tests
+        return
+    skip_slow = pytest.mark.skip(reason="need --runslow option to run")
+    for item in items:
+        if "slow" in item.keywords:
+            item.add_marker(skip_slow)
+
+
+# TODO: The warnings below need to be dealt with, but for now we silence them.
+@pytest.fixture(autouse=True)
+def set_warnings():
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="k_nearest_neighbors"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="numeric_mixing_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message=r"Ordered.* is deprecated"
+    )
+    warnings.filterwarnings(
+        "ignore",
+        category=DeprecationWarning,
+        message="literal_stringizer is deprecated",
+    )
+    warnings.filterwarnings(
+        "ignore",
+        category=DeprecationWarning,
+        message="literal_destringizer is deprecated",
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="is_string_like is deprecated"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="\nauthority_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="\nhub_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="default_opener is deprecated"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="empty_generator is deprecated"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="make_str is deprecated"
+    )
+    warnings.filterwarnings(
+        "ignore",
+        category=DeprecationWarning,
+        message="generate_unique_node is deprecated",
+    )
+    warnings.filterwarnings(
+        "ignore",
+        category=DeprecationWarning,
+        message="context manager reversed is deprecated",
+    )
+    warnings.filterwarnings(
+        "ignore",
+        category=DeprecationWarning,
+        message="This will return a generator in 3.0*",
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="betweenness_centrality_source"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="edge_betweeness"
+    )
+    warnings.filterwarnings(
+        "ignore", category=PendingDeprecationWarning, message="the matrix subclass"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="to_numpy_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="from_numpy_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="networkx.pagerank_numpy"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="networkx.pagerank_scipy"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="write_gpickle"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="read_gpickle"
+    )
+    warnings.filterwarnings("ignore", category=DeprecationWarning, message="write_shp")
+    warnings.filterwarnings("ignore", category=DeprecationWarning, message="read_shp")
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="edges_from_line"
+    )
+    warnings.filterwarnings("ignore", category=DeprecationWarning, message="write_yaml")
+    warnings.filterwarnings("ignore", category=DeprecationWarning, message="read_yaml")
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="FilterAtlas.copy"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="FilterAdjacency.copy"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="FilterMultiAdjacency.copy"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="FilterMultiInner.copy"
+    )
+    warnings.filterwarnings("ignore", category=DeprecationWarning, message="jit_data")
+    warnings.filterwarnings("ignore", category=DeprecationWarning, message="jit_graph")
+    warnings.filterwarnings("ignore", category=DeprecationWarning, message="consume")
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="iterable is deprecated"
+    )
+    warnings.filterwarnings(
+        "ignore",
+        category=FutureWarning,
+        message="\nThe function signature for cytoscape",
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="\nThe `attrs` keyword"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="preserve_random_state"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="`almost_equal`"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="`assert_nodes_equal`"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="`assert_edges_equal`"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="`assert_graphs_equal`"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="networkx.hits_scipy"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="networkx.hits_numpy"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="preserve_random_state"
+    )
+    warnings.filterwarnings(
+        "ignore",
+        category=FutureWarning,
+        message="google_matrix will return an np.ndarray instead of a np.matrix",
+    )
+    ### Future warnings from scipy.sparse array transition
+    warnings.filterwarnings(
+        "ignore", category=FutureWarning, message="biadjacency_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=FutureWarning, message="bethe_hessian_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=FutureWarning, message="incidence_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=FutureWarning, message="laplacian_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=FutureWarning, message="normalized_laplacian_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=FutureWarning, message="directed_laplacian_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore",
+        category=FutureWarning,
+        message="directed_combinatorial_laplacian_matrix",
+    )
+    warnings.filterwarnings(
+        "ignore", category=FutureWarning, message="modularity_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=FutureWarning, message="directed_modularity_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore", category=FutureWarning, message="adjacency_matrix"
+    )
+    warnings.filterwarnings(
+        "ignore",
+        category=DeprecationWarning,
+        message="\n\nThe scipy.sparse array containers",
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="networkx.project"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="\nfind_cores"
+    )
+    warnings.filterwarnings("ignore", category=FutureWarning, message="attr_matrix")
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message=r"\n\nmake_small_.*"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="to_numpy_recarray"
+    )
+    warnings.filterwarnings("ignore", category=DeprecationWarning, message="info")
+    warnings.filterwarnings("ignore", category=DeprecationWarning, message="to_tuple")
+    # create_using for scale_free_graph
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="The create_using argument"
+    )
+    warnings.filterwarnings(
+        "ignore", category=PendingDeprecationWarning, message="nx.nx_pydot"
+    )
+
+
+@pytest.fixture(autouse=True)
+def add_nx(doctest_namespace):
+    doctest_namespace["nx"] = networkx
+
+
+# What dependencies are installed?
+
+try:
+    import numpy
+
+    has_numpy = True
+except ImportError:
+    has_numpy = False
+
+try:
+    import scipy
+
+    has_scipy = True
+except ImportError:
+    has_scipy = False
+
+try:
+    import matplotlib
+
+    has_matplotlib = True
+except ImportError:
+    has_matplotlib = False
+
+try:
+    import pandas
+
+    has_pandas = True
+except ImportError:
+    has_pandas = False
+
+try:
+    import pygraphviz
+
+    has_pygraphviz = True
+except ImportError:
+    has_pygraphviz = False
+
+try:
+    import yaml
+
+    has_yaml = True
+except ImportError:
+    has_yaml = False
+
+try:
+    import pydot
+
+    has_pydot = True
+except ImportError:
+    has_pydot = False
+
+try:
+    import ogr
+
+    has_ogr = True
+except ImportError:
+    has_ogr = False
+
+try:
+    import sympy
+
+    has_sympy = True
+except ImportError:
+    has_sympy = False
+
+
+# List of files that pytest should ignore
+
+collect_ignore = []
+
+needs_numpy = [
+    "algorithms/approximation/traveling_salesman.py",
+    "algorithms/centrality/current_flow_closeness.py",
+    "algorithms/node_classification/__init__.py",
+    "algorithms/non_randomness.py",
+    "algorithms/shortest_paths/dense.py",
+    "linalg/bethehessianmatrix.py",
+    "linalg/laplacianmatrix.py",
+    "utils/misc.py",
+]
+needs_scipy = [
+    "algorithms/approximation/traveling_salesman.py",
+    "algorithms/assortativity/correlation.py",
+    "algorithms/assortativity/mixing.py",
+    "algorithms/assortativity/pairs.py",
+    "algorithms/bipartite/matrix.py",
+    "algorithms/bipartite/spectral.py",
+    "algorithms/centrality/current_flow_betweenness.py",
+    "algorithms/centrality/current_flow_betweenness_subset.py",
+    "algorithms/centrality/eigenvector.py",
+    "algorithms/centrality/katz.py",
+    "algorithms/centrality/second_order.py",
+    "algorithms/centrality/subgraph_alg.py",
+    "algorithms/communicability_alg.py",
+    "algorithms/link_analysis/hits_alg.py",
+    "algorithms/link_analysis/pagerank_alg.py",
+    "algorithms/node_classification/__init__.py",
+    "algorithms/node_classification/hmn.py",
+    "algorithms/node_classification/lgc.py",
+    "algorithms/similarity.py",
+    "convert_matrix.py",
+    "drawing/layout.py",
+    "generators/spectral_graph_forge.py",
+    "linalg/algebraicconnectivity.py",
+    "linalg/attrmatrix.py",
+    "linalg/bethehessianmatrix.py",
+    "linalg/graphmatrix.py",
+    "linalg/modularitymatrix.py",
+    "linalg/spectrum.py",
+    "utils/rcm.py",
+]
+needs_matplotlib = ["drawing/nx_pylab.py"]
+needs_pandas = ["convert_matrix.py"]
+needs_yaml = ["readwrite/nx_yaml.py"]
+needs_pygraphviz = ["drawing/nx_agraph.py"]
+needs_pydot = ["drawing/nx_pydot.py"]
+needs_ogr = ["readwrite/nx_shp.py"]
+needs_sympy = ["algorithms/polynomials.py"]
+
+if not has_numpy:
+    collect_ignore += needs_numpy
+if not has_scipy:
+    collect_ignore += needs_scipy
+if not has_matplotlib:
+    collect_ignore += needs_matplotlib
+if not has_pandas:
+    collect_ignore += needs_pandas
+if not has_yaml:
+    collect_ignore += needs_yaml
+if not has_pygraphviz:
+    collect_ignore += needs_pygraphviz
+if not has_pydot:
+    collect_ignore += needs_pydot
+if not has_ogr:
+    collect_ignore += needs_ogr
+if not has_sympy:
+    collect_ignore += needs_sympy
+
+# FIXME:  This is to avoid errors on AppVeyor
+if sys.platform.startswith("win"):
+    collect_ignore += ["readwrite/graph6.py", "readwrite/sparse6.py"]
diff --git a/myenv/lib/python3.9/site-packages/networkx/convert.py b/myenv/lib/python3.9/site-packages/networkx/convert.py
new file mode 100644
index 0000000..3356dd0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/convert.py
@@ -0,0 +1,491 @@
+"""Functions to convert NetworkX graphs to and from other formats.
+
+The preferred way of converting data to a NetworkX graph is through the
+graph constructor.  The constructor calls the to_networkx_graph() function
+which attempts to guess the input type and convert it automatically.
+
+Examples
+--------
+Create a graph with a single edge from a dictionary of dictionaries
+
+>>> d = {0: {1: 1}}  # dict-of-dicts single edge (0,1)
+>>> G = nx.Graph(d)
+
+See Also
+--------
+nx_agraph, nx_pydot
+"""
+import warnings
+from collections.abc import Collection, Generator, Iterator
+
+import networkx as nx
+
+__all__ = [
+    "to_networkx_graph",
+    "from_dict_of_dicts",
+    "to_dict_of_dicts",
+    "from_dict_of_lists",
+    "to_dict_of_lists",
+    "from_edgelist",
+    "to_edgelist",
+]
+
+
+def to_networkx_graph(data, create_using=None, multigraph_input=False):
+    """Make a NetworkX graph from a known data structure.
+
+    The preferred way to call this is automatically
+    from the class constructor
+
+    >>> d = {0: {1: {"weight": 1}}}  # dict-of-dicts single edge (0,1)
+    >>> G = nx.Graph(d)
+
+    instead of the equivalent
+
+    >>> G = nx.from_dict_of_dicts(d)
+
+    Parameters
+    ----------
+    data : object to be converted
+
+        Current known types are:
+         any NetworkX graph
+         dict-of-dicts
+         dict-of-lists
+         container (e.g. set, list, tuple) of edges
+         iterator (e.g. itertools.chain) that produces edges
+         generator of edges
+         Pandas DataFrame (row per edge)
+         2D numpy array
+         scipy sparse matrix
+         pygraphviz agraph
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+        Graph type to create. If graph instance, then cleared before populated.
+
+    multigraph_input : bool (default False)
+        If True and  data is a dict_of_dicts,
+        try to create a multigraph assuming dict_of_dict_of_lists.
+        If data and create_using are both multigraphs then create
+        a multigraph from a multigraph.
+
+    """
+    # NX graph
+    if hasattr(data, "adj"):
+        try:
+            result = from_dict_of_dicts(
+                data.adj,
+                create_using=create_using,
+                multigraph_input=data.is_multigraph(),
+            )
+            # data.graph should be dict-like
+            result.graph.update(data.graph)
+            # data.nodes should be dict-like
+            # result.add_node_from(data.nodes.items()) possible but
+            # for custom node_attr_dict_factory which may be hashable
+            # will be unexpected behavior
+            for n, dd in data.nodes.items():
+                result._node[n].update(dd)
+            return result
+        except Exception as err:
+            raise nx.NetworkXError("Input is not a correct NetworkX graph.") from err
+
+    # pygraphviz  agraph
+    if hasattr(data, "is_strict"):
+        try:
+            return nx.nx_agraph.from_agraph(data, create_using=create_using)
+        except Exception as err:
+            raise nx.NetworkXError("Input is not a correct pygraphviz graph.") from err
+
+    # dict of dicts/lists
+    if isinstance(data, dict):
+        try:
+            return from_dict_of_dicts(
+                data, create_using=create_using, multigraph_input=multigraph_input
+            )
+        except Exception as err1:
+            if multigraph_input is True:
+                raise nx.NetworkXError(
+                    f"converting multigraph_input raised:\n{type(err1)}: {err1}"
+                )
+            try:
+                return from_dict_of_lists(data, create_using=create_using)
+            except Exception as err2:
+                raise TypeError("Input is not known type.") from err2
+
+    # Pandas DataFrame
+    try:
+        import pandas as pd
+
+        if isinstance(data, pd.DataFrame):
+            if data.shape[0] == data.shape[1]:
+                try:
+                    return nx.from_pandas_adjacency(data, create_using=create_using)
+                except Exception as err:
+                    msg = "Input is not a correct Pandas DataFrame adjacency matrix."
+                    raise nx.NetworkXError(msg) from err
+            else:
+                try:
+                    return nx.from_pandas_edgelist(
+                        data, edge_attr=True, create_using=create_using
+                    )
+                except Exception as err:
+                    msg = "Input is not a correct Pandas DataFrame edge-list."
+                    raise nx.NetworkXError(msg) from err
+    except ImportError:
+        warnings.warn("pandas not found, skipping conversion test.", ImportWarning)
+
+    # numpy matrix or ndarray
+    try:
+        import numpy as np
+
+        if isinstance(data, np.ndarray):
+            try:
+                return nx.from_numpy_array(data, create_using=create_using)
+            except Exception as err:
+                raise nx.NetworkXError(
+                    f"Failed to interpret array as an adjacency matrix."
+                ) from err
+    except ImportError:
+        warnings.warn("numpy not found, skipping conversion test.", ImportWarning)
+
+    # scipy sparse matrix - any format
+    try:
+        import scipy
+
+        if hasattr(data, "format"):
+            try:
+                return nx.from_scipy_sparse_matrix(data, create_using=create_using)
+            except Exception as err:
+                raise nx.NetworkXError(
+                    "Input is not a correct scipy sparse matrix type."
+                ) from err
+    except ImportError:
+        warnings.warn("scipy not found, skipping conversion test.", ImportWarning)
+
+    # Note: most general check - should remain last in order of execution
+    # Includes containers (e.g. list, set, dict, etc.), generators, and
+    # iterators (e.g. itertools.chain) of edges
+
+    if isinstance(data, (Collection, Generator, Iterator)):
+        try:
+            return from_edgelist(data, create_using=create_using)
+        except Exception as err:
+            raise nx.NetworkXError("Input is not a valid edge list") from err
+
+    raise nx.NetworkXError("Input is not a known data type for conversion.")
+
+
+def to_dict_of_lists(G, nodelist=None):
+    """Returns adjacency representation of graph as a dictionary of lists.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    nodelist : list
+       Use only nodes specified in nodelist
+
+    Notes
+    -----
+    Completely ignores edge data for MultiGraph and MultiDiGraph.
+
+    """
+    if nodelist is None:
+        nodelist = G
+
+    d = {}
+    for n in nodelist:
+        d[n] = [nbr for nbr in G.neighbors(n) if nbr in nodelist]
+    return d
+
+
+def from_dict_of_lists(d, create_using=None):
+    """Returns a graph from a dictionary of lists.
+
+    Parameters
+    ----------
+    d : dictionary of lists
+      A dictionary of lists adjacency representation.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+        Graph type to create. If graph instance, then cleared before populated.
+
+    Examples
+    --------
+    >>> dol = {0: [1]}  # single edge (0,1)
+    >>> G = nx.from_dict_of_lists(dol)
+
+    or
+
+    >>> G = nx.Graph(dol)  # use Graph constructor
+
+    """
+    G = nx.empty_graph(0, create_using)
+    G.add_nodes_from(d)
+    if G.is_multigraph() and not G.is_directed():
+        # a dict_of_lists can't show multiedges.  BUT for undirected graphs,
+        # each edge shows up twice in the dict_of_lists.
+        # So we need to treat this case separately.
+        seen = {}
+        for node, nbrlist in d.items():
+            for nbr in nbrlist:
+                if nbr not in seen:
+                    G.add_edge(node, nbr)
+            seen[node] = 1  # don't allow reverse edge to show up
+    else:
+        G.add_edges_from(
+            ((node, nbr) for node, nbrlist in d.items() for nbr in nbrlist)
+        )
+    return G
+
+
+def to_dict_of_dicts(G, nodelist=None, edge_data=None):
+    """Returns adjacency representation of graph as a dictionary of dictionaries.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    nodelist : list
+       Use only nodes specified in nodelist
+
+    edge_data : scalar, optional
+       If provided, the value of the dictionary will be set to `edge_data` for
+       all edges. Usual values could be `1` or `True`. If `edge_data` is
+       `None` (the default), the edgedata in `G` is used, resulting in a
+       dict-of-dict-of-dicts. If `G` is a MultiGraph, the result will be a
+       dict-of-dict-of-dict-of-dicts. See Notes for an approach to customize
+       handling edge data. `edge_data` should *not* be a container.
+
+    Returns
+    -------
+    dod : dict
+       A nested dictionary representation of `G`. Note that the level of
+       nesting depends on the type of `G` and the value of `edge_data`
+       (see Examples).
+
+    See Also
+    --------
+    from_dict_of_dicts, to_dict_of_lists
+
+    Notes
+    -----
+    For a more custom approach to handling edge data, try::
+
+        dod = {
+            n: {
+                nbr: custom(n, nbr, dd) for nbr, dd in nbrdict.items()
+            }
+            for n, nbrdict in G.adj.items()
+        }
+
+    where `custom` returns the desired edge data for each edge between `n` and
+    `nbr`, given existing edge data `dd`.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(3)
+    >>> nx.to_dict_of_dicts(G)
+    {0: {1: {}}, 1: {0: {}, 2: {}}, 2: {1: {}}}
+
+    Edge data is preserved by default (``edge_data=None``), resulting
+    in dict-of-dict-of-dicts where the innermost dictionary contains the
+    edge data:
+
+    >>> G = nx.Graph()
+    >>> G.add_edges_from(
+    ...     [
+    ...         (0, 1, {'weight': 1.0}),
+    ...         (1, 2, {'weight': 2.0}),
+    ...         (2, 0, {'weight': 1.0}),
+    ...     ]
+    ... )
+    >>> d = nx.to_dict_of_dicts(G)
+    >>> d  # doctest: +SKIP
+    {0: {1: {'weight': 1.0}, 2: {'weight': 1.0}},
+     1: {0: {'weight': 1.0}, 2: {'weight': 2.0}},
+     2: {1: {'weight': 2.0}, 0: {'weight': 1.0}}}
+    >>> d[1][2]['weight']
+    2.0
+
+    If `edge_data` is not `None`, edge data in the original graph (if any) is
+    replaced:
+
+    >>> d = nx.to_dict_of_dicts(G, edge_data=1)
+    >>> d
+    {0: {1: 1, 2: 1}, 1: {0: 1, 2: 1}, 2: {1: 1, 0: 1}}
+    >>> d[1][2]
+    1
+
+    This also applies to MultiGraphs: edge data is preserved by default:
+
+    >>> G = nx.MultiGraph()
+    >>> G.add_edge(0, 1, key='a', weight=1.0)
+    'a'
+    >>> G.add_edge(0, 1, key='b', weight=5.0)
+    'b'
+    >>> d = nx.to_dict_of_dicts(G)
+    >>> d  # doctest: +SKIP
+    {0: {1: {'a': {'weight': 1.0}, 'b': {'weight': 5.0}}},
+     1: {0: {'a': {'weight': 1.0}, 'b': {'weight': 5.0}}}}
+    >>> d[0][1]['b']['weight']
+    5.0
+
+    But multi edge data is lost if `edge_data` is not `None`:
+
+    >>> d = nx.to_dict_of_dicts(G, edge_data=10)
+    >>> d
+    {0: {1: 10}, 1: {0: 10}}
+    """
+    dod = {}
+    if nodelist is None:
+        if edge_data is None:
+            for u, nbrdict in G.adjacency():
+                dod[u] = nbrdict.copy()
+        else:  # edge_data is not None
+            for u, nbrdict in G.adjacency():
+                dod[u] = dod.fromkeys(nbrdict, edge_data)
+    else:  # nodelist is not None
+        if edge_data is None:
+            for u in nodelist:
+                dod[u] = {}
+                for v, data in ((v, data) for v, data in G[u].items() if v in nodelist):
+                    dod[u][v] = data
+        else:  # nodelist and edge_data are not None
+            for u in nodelist:
+                dod[u] = {}
+                for v in (v for v in G[u] if v in nodelist):
+                    dod[u][v] = edge_data
+    return dod
+
+
+def from_dict_of_dicts(d, create_using=None, multigraph_input=False):
+    """Returns a graph from a dictionary of dictionaries.
+
+    Parameters
+    ----------
+    d : dictionary of dictionaries
+      A dictionary of dictionaries adjacency representation.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+        Graph type to create. If graph instance, then cleared before populated.
+
+    multigraph_input : bool (default False)
+       When True, the dict `d` is assumed
+       to be a dict-of-dict-of-dict-of-dict structure keyed by
+       node to neighbor to edge keys to edge data for multi-edges.
+       Otherwise this routine assumes dict-of-dict-of-dict keyed by
+       node to neighbor to edge data.
+
+    Examples
+    --------
+    >>> dod = {0: {1: {"weight": 1}}}  # single edge (0,1)
+    >>> G = nx.from_dict_of_dicts(dod)
+
+    or
+
+    >>> G = nx.Graph(dod)  # use Graph constructor
+
+    """
+    G = nx.empty_graph(0, create_using)
+    G.add_nodes_from(d)
+    # does dict d represent a MultiGraph or MultiDiGraph?
+    if multigraph_input:
+        if G.is_directed():
+            if G.is_multigraph():
+                G.add_edges_from(
+                    (u, v, key, data)
+                    for u, nbrs in d.items()
+                    for v, datadict in nbrs.items()
+                    for key, data in datadict.items()
+                )
+            else:
+                G.add_edges_from(
+                    (u, v, data)
+                    for u, nbrs in d.items()
+                    for v, datadict in nbrs.items()
+                    for key, data in datadict.items()
+                )
+        else:  # Undirected
+            if G.is_multigraph():
+                seen = set()  # don't add both directions of undirected graph
+                for u, nbrs in d.items():
+                    for v, datadict in nbrs.items():
+                        if (u, v) not in seen:
+                            G.add_edges_from(
+                                (u, v, key, data) for key, data in datadict.items()
+                            )
+                            seen.add((v, u))
+            else:
+                seen = set()  # don't add both directions of undirected graph
+                for u, nbrs in d.items():
+                    for v, datadict in nbrs.items():
+                        if (u, v) not in seen:
+                            G.add_edges_from(
+                                (u, v, data) for key, data in datadict.items()
+                            )
+                            seen.add((v, u))
+
+    else:  # not a multigraph to multigraph transfer
+        if G.is_multigraph() and not G.is_directed():
+            # d can have both representations u-v, v-u in dict.  Only add one.
+            # We don't need this check for digraphs since we add both directions,
+            # or for Graph() since it is done implicitly (parallel edges not allowed)
+            seen = set()
+            for u, nbrs in d.items():
+                for v, data in nbrs.items():
+                    if (u, v) not in seen:
+                        G.add_edge(u, v, key=0)
+                        G[u][v][0].update(data)
+                    seen.add((v, u))
+        else:
+            G.add_edges_from(
+                ((u, v, data) for u, nbrs in d.items() for v, data in nbrs.items())
+            )
+    return G
+
+
+def to_edgelist(G, nodelist=None):
+    """Returns a list of edges in the graph.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    nodelist : list
+       Use only nodes specified in nodelist
+
+    """
+    if nodelist is None:
+        return G.edges(data=True)
+    return G.edges(nodelist, data=True)
+
+
+def from_edgelist(edgelist, create_using=None):
+    """Returns a graph from a list of edges.
+
+    Parameters
+    ----------
+    edgelist : list or iterator
+      Edge tuples
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+        Graph type to create. If graph instance, then cleared before populated.
+
+    Examples
+    --------
+    >>> edgelist = [(0, 1)]  # single edge (0,1)
+    >>> G = nx.from_edgelist(edgelist)
+
+    or
+
+    >>> G = nx.Graph(edgelist)  # use Graph constructor
+
+    """
+    G = nx.empty_graph(0, create_using)
+    G.add_edges_from(edgelist)
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/convert_matrix.py b/myenv/lib/python3.9/site-packages/networkx/convert_matrix.py
new file mode 100644
index 0000000..fecc8ca
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/convert_matrix.py
@@ -0,0 +1,1673 @@
+"""Functions to convert NetworkX graphs to and from common data containers
+like numpy arrays, scipy sparse arrays, and pandas DataFrames.
+
+The preferred way of converting data to a NetworkX graph is through the
+graph constructor.  The constructor calls the `~networkx.convert.to_networkx_graph`
+function which attempts to guess the input type and convert it automatically.
+
+Examples
+--------
+Create a 10 node random graph from a numpy array
+
+>>> import numpy as np
+>>> rng = np.random.default_rng()
+>>> a = rng.integers(low=0, high=2, size=(10, 10))
+>>> DG = nx.from_numpy_array(a, create_using=nx.DiGraph)
+
+or equivalently:
+
+>>> DG = nx.DiGraph(a)
+
+which calls `from_numpy_array` internally based on the type of ``a``.
+
+See Also
+--------
+nx_agraph, nx_pydot
+"""
+
+import itertools
+import warnings
+from collections import defaultdict
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "from_numpy_matrix",
+    "to_numpy_matrix",
+    "from_pandas_adjacency",
+    "to_pandas_adjacency",
+    "from_pandas_edgelist",
+    "to_pandas_edgelist",
+    "to_numpy_recarray",
+    "from_scipy_sparse_array",
+    "from_scipy_sparse_matrix",
+    "to_scipy_sparse_array",
+    "to_scipy_sparse_matrix",
+    "from_numpy_array",
+    "to_numpy_array",
+]
+
+
+def to_pandas_adjacency(
+    G,
+    nodelist=None,
+    dtype=None,
+    order=None,
+    multigraph_weight=sum,
+    weight="weight",
+    nonedge=0.0,
+):
+    """Returns the graph adjacency matrix as a Pandas DataFrame.
+
+    Parameters
+    ----------
+    G : graph
+        The NetworkX graph used to construct the Pandas DataFrame.
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in `nodelist`.
+       If `nodelist` is None, then the ordering is produced by G.nodes().
+
+    multigraph_weight : {sum, min, max}, optional
+        An operator that determines how weights in multigraphs are handled.
+        The default is to sum the weights of the multiple edges.
+
+    weight : string or None, optional
+        The edge attribute that holds the numerical value used for
+        the edge weight.  If an edge does not have that attribute, then the
+        value 1 is used instead.
+
+    nonedge : float, optional
+        The matrix values corresponding to nonedges are typically set to zero.
+        However, this could be undesirable if there are matrix values
+        corresponding to actual edges that also have the value zero. If so,
+        one might prefer nonedges to have some other value, such as nan.
+
+    Returns
+    -------
+    df : Pandas DataFrame
+       Graph adjacency matrix
+
+    Notes
+    -----
+    For directed graphs, entry i,j corresponds to an edge from i to j.
+
+    The DataFrame entries are assigned to the weight edge attribute. When
+    an edge does not have a weight attribute, the value of the entry is set to
+    the number 1.  For multiple (parallel) edges, the values of the entries
+    are determined by the 'multigraph_weight' parameter.  The default is to
+    sum the weight attributes for each of the parallel edges.
+
+    When `nodelist` does not contain every node in `G`, the matrix is built
+    from the subgraph of `G` that is induced by the nodes in `nodelist`.
+
+    The convention used for self-loop edges in graphs is to assign the
+    diagonal matrix entry value to the weight attribute of the edge
+    (or the number 1 if the edge has no weight attribute).  If the
+    alternate convention of doubling the edge weight is desired the
+    resulting Pandas DataFrame can be modified as follows:
+
+    >>> import pandas as pd
+    >>> pd.options.display.max_columns = 20
+    >>> import numpy as np
+    >>> G = nx.Graph([(1, 1)])
+    >>> df = nx.to_pandas_adjacency(G, dtype=int)
+    >>> df
+       1
+    1  1
+    >>> df.values[np.diag_indices_from(df)] *= 2
+    >>> df
+       1
+    1  2
+
+    Examples
+    --------
+    >>> G = nx.MultiDiGraph()
+    >>> G.add_edge(0, 1, weight=2)
+    0
+    >>> G.add_edge(1, 0)
+    0
+    >>> G.add_edge(2, 2, weight=3)
+    0
+    >>> G.add_edge(2, 2)
+    1
+    >>> nx.to_pandas_adjacency(G, nodelist=[0, 1, 2], dtype=int)
+       0  1  2
+    0  0  2  0
+    1  1  0  0
+    2  0  0  4
+
+    """
+    import pandas as pd
+
+    M = to_numpy_array(
+        G,
+        nodelist=nodelist,
+        dtype=dtype,
+        order=order,
+        multigraph_weight=multigraph_weight,
+        weight=weight,
+        nonedge=nonedge,
+    )
+    if nodelist is None:
+        nodelist = list(G)
+    return pd.DataFrame(data=M, index=nodelist, columns=nodelist)
+
+
+def from_pandas_adjacency(df, create_using=None):
+    r"""Returns a graph from Pandas DataFrame.
+
+    The Pandas DataFrame is interpreted as an adjacency matrix for the graph.
+
+    Parameters
+    ----------
+    df : Pandas DataFrame
+      An adjacency matrix representation of a graph
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Notes
+    -----
+    For directed graphs, explicitly mention create_using=nx.DiGraph,
+    and entry i,j of df corresponds to an edge from i to j.
+
+    If `df` has a single data type for each entry it will be converted to an
+    appropriate Python data type.
+
+    If `df` has a user-specified compound data type the names
+    of the data fields will be used as attribute keys in the resulting
+    NetworkX graph.
+
+    See Also
+    --------
+    to_pandas_adjacency
+
+    Examples
+    --------
+    Simple integer weights on edges:
+
+    >>> import pandas as pd
+    >>> pd.options.display.max_columns = 20
+    >>> df = pd.DataFrame([[1, 1], [2, 1]])
+    >>> df
+       0  1
+    0  1  1
+    1  2  1
+    >>> G = nx.from_pandas_adjacency(df)
+    >>> G.name = "Graph from pandas adjacency matrix"
+    >>> print(nx.info(G))
+    Graph named 'Graph from pandas adjacency matrix' with 2 nodes and 3 edges
+    """
+
+    try:
+        df = df[df.index]
+    except Exception as err:
+        missing = list(set(df.index).difference(set(df.columns)))
+        msg = f"{missing} not in columns"
+        raise nx.NetworkXError("Columns must match Indices.", msg) from err
+
+    A = df.values
+    G = from_numpy_array(A, create_using=create_using)
+
+    nx.relabel.relabel_nodes(G, dict(enumerate(df.columns)), copy=False)
+    return G
+
+
+def to_pandas_edgelist(
+    G,
+    source="source",
+    target="target",
+    nodelist=None,
+    dtype=None,
+    order=None,
+    edge_key=None,
+):
+    """Returns the graph edge list as a Pandas DataFrame.
+
+    Parameters
+    ----------
+    G : graph
+        The NetworkX graph used to construct the Pandas DataFrame.
+
+    source : str or int, optional
+        A valid column name (string or integer) for the source nodes (for the
+        directed case).
+
+    target : str or int, optional
+        A valid column name (string or integer) for the target nodes (for the
+        directed case).
+
+    nodelist : list, optional
+       Use only nodes specified in nodelist
+
+    dtype : dtype, default None
+        Use to create the DataFrame. Data type to force.
+        Only a single dtype is allowed. If None, infer.
+
+    order : None
+        An unused parameter mistakenly included in the function.
+
+        .. deprecated:: 2.6
+            This is deprecated and will be removed in NetworkX v3.0.
+
+    edge_key : str or int or None, optional (default=None)
+        A valid column name (string or integer) for the edge keys (for the
+        multigraph case). If None, edge keys are not stored in the DataFrame.
+
+    Returns
+    -------
+    df : Pandas DataFrame
+       Graph edge list
+
+    Examples
+    --------
+    >>> G = nx.Graph(
+    ...     [
+    ...         ("A", "B", {"cost": 1, "weight": 7}),
+    ...         ("C", "E", {"cost": 9, "weight": 10}),
+    ...     ]
+    ... )
+    >>> df = nx.to_pandas_edgelist(G, nodelist=["A", "C"])
+    >>> df[["source", "target", "cost", "weight"]]
+      source target  cost  weight
+    0      A      B     1       7
+    1      C      E     9      10
+
+    >>> G = nx.MultiGraph([('A', 'B', {'cost': 1}), ('A', 'B', {'cost': 9})])
+    >>> df = nx.to_pandas_edgelist(G, nodelist=['A', 'C'], edge_key='ekey')
+    >>> df[['source', 'target', 'cost', 'ekey']]
+      source target  cost  ekey
+    0      A      B     1     0
+    1      A      B     9     1
+
+    """
+    import pandas as pd
+
+    if nodelist is None:
+        edgelist = G.edges(data=True)
+    else:
+        edgelist = G.edges(nodelist, data=True)
+    source_nodes = [s for s, _, _ in edgelist]
+    target_nodes = [t for _, t, _ in edgelist]
+
+    all_attrs = set().union(*(d.keys() for _, _, d in edgelist))
+    if source in all_attrs:
+        raise nx.NetworkXError(f"Source name {source!r} is an edge attr name")
+    if target in all_attrs:
+        raise nx.NetworkXError(f"Target name {target!r} is an edge attr name")
+
+    nan = float("nan")
+    edge_attr = {k: [d.get(k, nan) for _, _, d in edgelist] for k in all_attrs}
+
+    if G.is_multigraph() and edge_key is not None:
+        if edge_key in all_attrs:
+            raise nx.NetworkXError(f"Edge key name {edge_key!r} is an edge attr name")
+        edge_keys = [k for _, _, k in G.edges(keys=True)]
+        edgelistdict = {source: source_nodes, target: target_nodes, edge_key: edge_keys}
+    else:
+        edgelistdict = {source: source_nodes, target: target_nodes}
+
+    edgelistdict.update(edge_attr)
+    return pd.DataFrame(edgelistdict, dtype=dtype)
+
+
+def from_pandas_edgelist(
+    df,
+    source="source",
+    target="target",
+    edge_attr=None,
+    create_using=None,
+    edge_key=None,
+):
+    """Returns a graph from Pandas DataFrame containing an edge list.
+
+    The Pandas DataFrame should contain at least two columns of node names and
+    zero or more columns of edge attributes. Each row will be processed as one
+    edge instance.
+
+    Note: This function iterates over DataFrame.values, which is not
+    guaranteed to retain the data type across columns in the row. This is only
+    a problem if your row is entirely numeric and a mix of ints and floats. In
+    that case, all values will be returned as floats. See the
+    DataFrame.iterrows documentation for an example.
+
+    Parameters
+    ----------
+    df : Pandas DataFrame
+        An edge list representation of a graph
+
+    source : str or int
+        A valid column name (string or integer) for the source nodes (for the
+        directed case).
+
+    target : str or int
+        A valid column name (string or integer) for the target nodes (for the
+        directed case).
+
+    edge_attr : str or int, iterable, True, or None
+        A valid column name (str or int) or iterable of column names that are
+        used to retrieve items and add them to the graph as edge attributes.
+        If `True`, all of the remaining columns will be added.
+        If `None`, no edge attributes are added to the graph.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+        Graph type to create. If graph instance, then cleared before populated.
+
+    edge_key : str or None, optional (default=None)
+        A valid column name for the edge keys (for a MultiGraph). The values in
+        this column are used for the edge keys when adding edges if create_using
+        is a multigraph.
+
+    See Also
+    --------
+    to_pandas_edgelist
+
+    Examples
+    --------
+    Simple integer weights on edges:
+
+    >>> import pandas as pd
+    >>> pd.options.display.max_columns = 20
+    >>> import numpy as np
+    >>> rng = np.random.RandomState(seed=5)
+    >>> ints = rng.randint(1, 11, size=(3, 2))
+    >>> a = ["A", "B", "C"]
+    >>> b = ["D", "A", "E"]
+    >>> df = pd.DataFrame(ints, columns=["weight", "cost"])
+    >>> df[0] = a
+    >>> df["b"] = b
+    >>> df[["weight", "cost", 0, "b"]]
+       weight  cost  0  b
+    0       4     7  A  D
+    1       7     1  B  A
+    2      10     9  C  E
+    >>> G = nx.from_pandas_edgelist(df, 0, "b", ["weight", "cost"])
+    >>> G["E"]["C"]["weight"]
+    10
+    >>> G["E"]["C"]["cost"]
+    9
+    >>> edges = pd.DataFrame(
+    ...     {
+    ...         "source": [0, 1, 2],
+    ...         "target": [2, 2, 3],
+    ...         "weight": [3, 4, 5],
+    ...         "color": ["red", "blue", "blue"],
+    ...     }
+    ... )
+    >>> G = nx.from_pandas_edgelist(edges, edge_attr=True)
+    >>> G[0][2]["color"]
+    'red'
+
+    Build multigraph with custom keys:
+
+    >>> edges = pd.DataFrame(
+    ...     {
+    ...         "source": [0, 1, 2, 0],
+    ...         "target": [2, 2, 3, 2],
+    ...         "my_edge_key": ["A", "B", "C", "D"],
+    ...         "weight": [3, 4, 5, 6],
+    ...         "color": ["red", "blue", "blue", "blue"],
+    ...     }
+    ... )
+    >>> G = nx.from_pandas_edgelist(
+    ...     edges,
+    ...     edge_key="my_edge_key",
+    ...     edge_attr=["weight", "color"],
+    ...     create_using=nx.MultiGraph(),
+    ... )
+    >>> G[0][2]
+    AtlasView({'A': {'weight': 3, 'color': 'red'}, 'D': {'weight': 6, 'color': 'blue'}})
+
+
+    """
+    g = nx.empty_graph(0, create_using)
+
+    if edge_attr is None:
+        g.add_edges_from(zip(df[source], df[target]))
+        return g
+
+    reserved_columns = [source, target]
+
+    # Additional columns requested
+    attr_col_headings = []
+    attribute_data = []
+    if edge_attr is True:
+        attr_col_headings = [c for c in df.columns if c not in reserved_columns]
+    elif isinstance(edge_attr, (list, tuple)):
+        attr_col_headings = edge_attr
+    else:
+        attr_col_headings = [edge_attr]
+    if len(attr_col_headings) == 0:
+        raise nx.NetworkXError(
+            f"Invalid edge_attr argument: No columns found with name: {attr_col_headings}"
+        )
+
+    try:
+        attribute_data = zip(*[df[col] for col in attr_col_headings])
+    except (KeyError, TypeError) as err:
+        msg = f"Invalid edge_attr argument: {edge_attr}"
+        raise nx.NetworkXError(msg) from err
+
+    if g.is_multigraph():
+        # => append the edge keys from the df to the bundled data
+        if edge_key is not None:
+            try:
+                multigraph_edge_keys = df[edge_key]
+                attribute_data = zip(attribute_data, multigraph_edge_keys)
+            except (KeyError, TypeError) as err:
+                msg = f"Invalid edge_key argument: {edge_key}"
+                raise nx.NetworkXError(msg) from err
+
+        for s, t, attrs in zip(df[source], df[target], attribute_data):
+            if edge_key is not None:
+                attrs, multigraph_edge_key = attrs
+                key = g.add_edge(s, t, key=multigraph_edge_key)
+            else:
+                key = g.add_edge(s, t)
+
+            g[s][t][key].update(zip(attr_col_headings, attrs))
+    else:
+        for s, t, attrs in zip(df[source], df[target], attribute_data):
+            g.add_edge(s, t)
+            g[s][t].update(zip(attr_col_headings, attrs))
+
+    return g
+
+
+def to_numpy_matrix(
+    G,
+    nodelist=None,
+    dtype=None,
+    order=None,
+    multigraph_weight=sum,
+    weight="weight",
+    nonedge=0.0,
+):
+    """Returns the graph adjacency matrix as a NumPy matrix.
+
+    Parameters
+    ----------
+    G : graph
+        The NetworkX graph used to construct the NumPy matrix.
+
+    nodelist : list, optional
+        The rows and columns are ordered according to the nodes in `nodelist`.
+        If `nodelist` is None, then the ordering is produced by G.nodes().
+
+    dtype : NumPy data type, optional
+        A valid single NumPy data type used to initialize the array.
+        This must be a simple type such as int or numpy.float64 and
+        not a compound data type (see to_numpy_recarray)
+        If None, then the NumPy default is used.
+
+    order : {'C', 'F'}, optional
+        Whether to store multidimensional data in C- or Fortran-contiguous
+        (row- or column-wise) order in memory. If None, then the NumPy default
+        is used.
+
+    multigraph_weight : {sum, min, max}, optional
+        An operator that determines how weights in multigraphs are handled.
+        The default is to sum the weights of the multiple edges.
+
+    weight : string or None optional (default = 'weight')
+        The edge attribute that holds the numerical value used for
+        the edge weight. If an edge does not have that attribute, then the
+        value 1 is used instead.
+
+    nonedge : float (default = 0.0)
+        The matrix values corresponding to nonedges are typically set to zero.
+        However, this could be undesirable if there are matrix values
+        corresponding to actual edges that also have the value zero. If so,
+        one might prefer nonedges to have some other value, such as nan.
+
+    Returns
+    -------
+    M : NumPy matrix
+        Graph adjacency matrix
+
+    See Also
+    --------
+    to_numpy_recarray
+
+    Notes
+    -----
+    For directed graphs, entry i,j corresponds to an edge from i to j.
+
+    The matrix entries are assigned to the weight edge attribute. When
+    an edge does not have a weight attribute, the value of the entry is set to
+    the number 1.  For multiple (parallel) edges, the values of the entries
+    are determined by the `multigraph_weight` parameter.  The default is to
+    sum the weight attributes for each of the parallel edges.
+
+    When `nodelist` does not contain every node in `G`, the matrix is built
+    from the subgraph of `G` that is induced by the nodes in `nodelist`.
+
+    The convention used for self-loop edges in graphs is to assign the
+    diagonal matrix entry value to the weight attribute of the edge
+    (or the number 1 if the edge has no weight attribute).  If the
+    alternate convention of doubling the edge weight is desired the
+    resulting Numpy matrix can be modified as follows:
+
+    >>> import numpy as np
+    >>> G = nx.Graph([(1, 1)])
+    >>> A = nx.to_numpy_matrix(G)
+    >>> A
+    matrix([[1.]])
+    >>> A[np.diag_indices_from(A)] *= 2
+    >>> A
+    matrix([[2.]])
+
+    Examples
+    --------
+    >>> G = nx.MultiDiGraph()
+    >>> G.add_edge(0, 1, weight=2)
+    0
+    >>> G.add_edge(1, 0)
+    0
+    >>> G.add_edge(2, 2, weight=3)
+    0
+    >>> G.add_edge(2, 2)
+    1
+    >>> nx.to_numpy_matrix(G, nodelist=[0, 1, 2])
+    matrix([[0., 2., 0.],
+            [1., 0., 0.],
+            [0., 0., 4.]])
+
+    """
+    warnings.warn(
+        (
+            "to_numpy_matrix is deprecated and will be removed in NetworkX 3.0.\n"
+            "Use to_numpy_array instead, e.g. np.asmatrix(to_numpy_array(G, **kwargs))"
+        ),
+        DeprecationWarning,
+    )
+
+    import numpy as np
+
+    A = to_numpy_array(
+        G,
+        nodelist=nodelist,
+        dtype=dtype,
+        order=order,
+        multigraph_weight=multigraph_weight,
+        weight=weight,
+        nonedge=nonedge,
+    )
+    M = np.asmatrix(A, dtype=dtype)
+    return M
+
+
+def from_numpy_matrix(A, parallel_edges=False, create_using=None):
+    """Returns a graph from numpy matrix.
+
+    The numpy matrix is interpreted as an adjacency matrix for the graph.
+
+    Parameters
+    ----------
+    A : numpy matrix
+        An adjacency matrix representation of a graph
+
+    parallel_edges : Boolean
+        If True, `create_using` is a multigraph, and `A` is an
+        integer matrix, then entry *(i, j)* in the matrix is interpreted as the
+        number of parallel edges joining vertices *i* and *j* in the graph.
+        If False, then the entries in the adjacency matrix are interpreted as
+        the weight of a single edge joining the vertices.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Notes
+    -----
+    For directed graphs, explicitly mention create_using=nx.DiGraph,
+    and entry i,j of A corresponds to an edge from i to j.
+
+    If `create_using` is :class:`networkx.MultiGraph` or
+    :class:`networkx.MultiDiGraph`, `parallel_edges` is True, and the
+    entries of `A` are of type :class:`int`, then this function returns a
+    multigraph (constructed from `create_using`) with parallel edges.
+
+    If `create_using` indicates an undirected multigraph, then only the edges
+    indicated by the upper triangle of the matrix `A` will be added to the
+    graph.
+
+    If the numpy matrix has a single data type for each matrix entry it
+    will be converted to an appropriate Python data type.
+
+    If the numpy matrix has a user-specified compound data type the names
+    of the data fields will be used as attribute keys in the resulting
+    NetworkX graph.
+
+    See Also
+    --------
+    to_numpy_recarray
+
+    Examples
+    --------
+    Simple integer weights on edges:
+
+    >>> import numpy as np
+    >>> A = np.array([[1, 1], [2, 1]])
+    >>> G = nx.from_numpy_matrix(A)
+
+    If `create_using` indicates a multigraph and the matrix has only integer
+    entries and `parallel_edges` is False, then the entries will be treated
+    as weights for edges joining the nodes (without creating parallel edges):
+
+    >>> A = np.array([[1, 1], [1, 2]])
+    >>> G = nx.from_numpy_matrix(A, create_using=nx.MultiGraph)
+    >>> G[1][1]
+    AtlasView({0: {'weight': 2}})
+
+    If `create_using` indicates a multigraph and the matrix has only integer
+    entries and `parallel_edges` is True, then the entries will be treated
+    as the number of parallel edges joining those two vertices:
+
+    >>> A = np.array([[1, 1], [1, 2]])
+    >>> temp = nx.MultiGraph()
+    >>> G = nx.from_numpy_matrix(A, parallel_edges=True, create_using=temp)
+    >>> G[1][1]
+    AtlasView({0: {'weight': 1}, 1: {'weight': 1}})
+
+    User defined compound data type on edges:
+
+    >>> dt = [("weight", float), ("cost", int)]
+    >>> A = np.array([[(1.0, 2)]], dtype=dt)
+    >>> G = nx.from_numpy_matrix(A)
+    >>> list(G.edges())
+    [(0, 0)]
+    >>> G[0][0]["cost"]
+    2
+    >>> G[0][0]["weight"]
+    1.0
+
+    """
+    warnings.warn(
+        (
+            "from_numpy_matrix is deprecated and will be removed in NetworkX 3.0.\n"
+            "Use from_numpy_array instead, e.g. from_numpy_array(A, **kwargs)"
+        ),
+        DeprecationWarning,
+    )
+    return from_numpy_array(A, parallel_edges=parallel_edges, create_using=create_using)
+
+
+@not_implemented_for("multigraph")
+def to_numpy_recarray(G, nodelist=None, dtype=None, order=None):
+    """Returns the graph adjacency matrix as a NumPy recarray.
+
+    .. deprecated:: 2.7
+
+       ``to_numpy_recarray`` is deprecated and will be removed in NetworkX 3.0.
+       Use ``nx.to_numpy_array(G, dtype=dtype, weight=None).view(np.recarray)``
+       instead.
+
+    Parameters
+    ----------
+    G : graph
+        The NetworkX graph used to construct the NumPy recarray.
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in `nodelist`.
+       If `nodelist` is None, then the ordering is produced by G.nodes().
+
+    dtype : NumPy data-type, optional
+        A valid NumPy named dtype used to initialize the NumPy recarray.
+        The data type names are assumed to be keys in the graph edge attribute
+        dictionary. The default is ``dtype([("weight", float)])``.
+
+    order : {'C', 'F'}, optional
+        Whether to store multidimensional data in C- or Fortran-contiguous
+        (row- or column-wise) order in memory. If None, then the NumPy default
+        is used.
+
+    Returns
+    -------
+    M : NumPy recarray
+       The graph with specified edge data as a Numpy recarray
+
+    Notes
+    -----
+    When `nodelist` does not contain every node in `G`, the adjacency
+    matrix is built from the subgraph of `G` that is induced by the nodes in
+    `nodelist`.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_edge(1, 2, weight=7.0, cost=5)
+    >>> A = nx.to_numpy_recarray(G, dtype=[("weight", float), ("cost", int)])
+    >>> print(A.weight)
+    [[0. 7.]
+     [7. 0.]]
+    >>> print(A.cost)
+    [[0 5]
+     [5 0]]
+
+    """
+    import warnings
+
+    import numpy as np
+
+    warnings.warn(
+        (
+            "to_numpy_recarray is deprecated and will be removed in version 3.0.\n"
+            "Use to_numpy_array instead::\n\n"
+            "    nx.to_numpy_array(G, dtype=dtype, weight=None).view(np.recarray)"
+        ),
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    if dtype is None:
+        dtype = [("weight", float)]
+
+    if nodelist is None:
+        nodelist = list(G)
+        nodeset = G
+        nlen = len(G)
+    else:
+        nlen = len(nodelist)
+        nodeset = set(G.nbunch_iter(nodelist))
+        if nlen != len(nodeset):
+            for n in nodelist:
+                if n not in G:
+                    raise nx.NetworkXError(f"Node {n} in nodelist is not in G")
+            raise nx.NetworkXError("nodelist contains duplicates.")
+
+    undirected = not G.is_directed()
+    index = dict(zip(nodelist, range(nlen)))
+    M = np.zeros((nlen, nlen), dtype=dtype, order=order)
+
+    names = M.dtype.names
+    for u, v, attrs in G.edges(data=True):
+        if (u in nodeset) and (v in nodeset):
+            i, j = index[u], index[v]
+            values = tuple(attrs[n] for n in names)
+            M[i, j] = values
+            if undirected:
+                M[j, i] = M[i, j]
+
+    return M.view(np.recarray)
+
+
+def to_scipy_sparse_array(G, nodelist=None, dtype=None, weight="weight", format="csr"):
+    """Returns the graph adjacency matrix as a SciPy sparse array.
+
+    Parameters
+    ----------
+    G : graph
+        The NetworkX graph used to construct the sparse matrix.
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in `nodelist`.
+       If `nodelist` is None, then the ordering is produced by G.nodes().
+
+    dtype : NumPy data-type, optional
+        A valid NumPy dtype used to initialize the array. If None, then the
+        NumPy default is used.
+
+    weight : string or None   optional (default='weight')
+        The edge attribute that holds the numerical value used for
+        the edge weight.  If None then all edge weights are 1.
+
+    format : str in {'bsr', 'csr', 'csc', 'coo', 'lil', 'dia', 'dok'}
+        The type of the matrix to be returned (default 'csr').  For
+        some algorithms different implementations of sparse matrices
+        can perform better.  See [1]_ for details.
+
+    Returns
+    -------
+    A : SciPy sparse array
+       Graph adjacency matrix.
+
+    Notes
+    -----
+    For directed graphs, matrix entry i,j corresponds to an edge from i to j.
+
+    The matrix entries are populated using the edge attribute held in
+    parameter weight. When an edge does not have that attribute, the
+    value of the entry is 1.
+
+    For multiple edges the matrix values are the sums of the edge weights.
+
+    When `nodelist` does not contain every node in `G`, the adjacency matrix
+    is built from the subgraph of `G` that is induced by the nodes in
+    `nodelist`.
+
+    The convention used for self-loop edges in graphs is to assign the
+    diagonal matrix entry value to the weight attribute of the edge
+    (or the number 1 if the edge has no weight attribute).  If the
+    alternate convention of doubling the edge weight is desired the
+    resulting Scipy sparse matrix can be modified as follows:
+
+    >>> G = nx.Graph([(1, 1)])
+    >>> A = nx.to_scipy_sparse_array(G)
+    >>> print(A.todense())
+    [[1]]
+    >>> A.setdiag(A.diagonal() * 2)
+    >>> print(A.toarray())
+    [[2]]
+
+    Examples
+    --------
+    >>> G = nx.MultiDiGraph()
+    >>> G.add_edge(0, 1, weight=2)
+    0
+    >>> G.add_edge(1, 0)
+    0
+    >>> G.add_edge(2, 2, weight=3)
+    0
+    >>> G.add_edge(2, 2)
+    1
+    >>> S = nx.to_scipy_sparse_array(G, nodelist=[0, 1, 2])
+    >>> print(S.toarray())
+    [[0 2 0]
+     [1 0 0]
+     [0 0 4]]
+
+    References
+    ----------
+    .. [1] Scipy Dev. References, "Sparse Matrices",
+       https://docs.scipy.org/doc/scipy/reference/sparse.html
+    """
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    if len(G) == 0:
+        raise nx.NetworkXError("Graph has no nodes or edges")
+
+    if nodelist is None:
+        nodelist = list(G)
+        nlen = len(G)
+    else:
+        nlen = len(nodelist)
+        if nlen == 0:
+            raise nx.NetworkXError("nodelist has no nodes")
+        nodeset = set(G.nbunch_iter(nodelist))
+        if nlen != len(nodeset):
+            for n in nodelist:
+                if n not in G:
+                    raise nx.NetworkXError(f"Node {n} in nodelist is not in G")
+            raise nx.NetworkXError("nodelist contains duplicates.")
+        if nlen < len(G):
+            G = G.subgraph(nodelist)
+
+    index = dict(zip(nodelist, range(nlen)))
+    coefficients = zip(
+        *((index[u], index[v], wt) for u, v, wt in G.edges(data=weight, default=1))
+    )
+    try:
+        row, col, data = coefficients
+    except ValueError:
+        # there is no edge in the subgraph
+        row, col, data = [], [], []
+
+    if G.is_directed():
+        A = sp.sparse.coo_array((data, (row, col)), shape=(nlen, nlen), dtype=dtype)
+    else:
+        # symmetrize matrix
+        d = data + data
+        r = row + col
+        c = col + row
+        # selfloop entries get double counted when symmetrizing
+        # so we subtract the data on the diagonal
+        selfloops = list(nx.selfloop_edges(G, data=weight, default=1))
+        if selfloops:
+            diag_index, diag_data = zip(*((index[u], -wt) for u, v, wt in selfloops))
+            d += diag_data
+            r += diag_index
+            c += diag_index
+        A = sp.sparse.coo_array((d, (r, c)), shape=(nlen, nlen), dtype=dtype)
+    try:
+        return A.asformat(format)
+    except ValueError as err:
+        raise nx.NetworkXError(f"Unknown sparse matrix format: {format}") from err
+
+
+def to_scipy_sparse_matrix(G, nodelist=None, dtype=None, weight="weight", format="csr"):
+    """Returns the graph adjacency matrix as a SciPy sparse matrix.
+
+    Parameters
+    ----------
+    G : graph
+        The NetworkX graph used to construct the sparse matrix.
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in `nodelist`.
+       If `nodelist` is None, then the ordering is produced by G.nodes().
+
+    dtype : NumPy data-type, optional
+        A valid NumPy dtype used to initialize the array. If None, then the
+        NumPy default is used.
+
+    weight : string or None   optional (default='weight')
+        The edge attribute that holds the numerical value used for
+        the edge weight.  If None then all edge weights are 1.
+
+    format : str in {'bsr', 'csr', 'csc', 'coo', 'lil', 'dia', 'dok'}
+        The type of the matrix to be returned (default 'csr').  For
+        some algorithms different implementations of sparse matrices
+        can perform better.  See [1]_ for details.
+
+    Returns
+    -------
+    A : SciPy sparse matrix
+       Graph adjacency matrix.
+
+    Notes
+    -----
+    For directed graphs, matrix entry i,j corresponds to an edge from i to j.
+
+    The matrix entries are populated using the edge attribute held in
+    parameter weight. When an edge does not have that attribute, the
+    value of the entry is 1.
+
+    For multiple edges the matrix values are the sums of the edge weights.
+
+    When `nodelist` does not contain every node in `G`, the adjacency matrix
+    is built from the subgraph of `G` that is induced by the nodes in
+    `nodelist`.
+
+    The convention used for self-loop edges in graphs is to assign the
+    diagonal matrix entry value to the weight attribute of the edge
+    (or the number 1 if the edge has no weight attribute).  If the
+    alternate convention of doubling the edge weight is desired the
+    resulting Scipy sparse matrix can be modified as follows:
+
+    >>> G = nx.Graph([(1, 1)])
+    >>> A = nx.to_scipy_sparse_matrix(G)
+    >>> print(A.todense())
+    [[1]]
+    >>> A.setdiag(A.diagonal() * 2)
+    >>> print(A.todense())
+    [[2]]
+
+    Examples
+    --------
+    >>> G = nx.MultiDiGraph()
+    >>> G.add_edge(0, 1, weight=2)
+    0
+    >>> G.add_edge(1, 0)
+    0
+    >>> G.add_edge(2, 2, weight=3)
+    0
+    >>> G.add_edge(2, 2)
+    1
+    >>> S = nx.to_scipy_sparse_matrix(G, nodelist=[0, 1, 2])
+    >>> print(S.todense())
+    [[0 2 0]
+     [1 0 0]
+     [0 0 4]]
+
+    References
+    ----------
+    .. [1] Scipy Dev. References, "Sparse Matrices",
+       https://docs.scipy.org/doc/scipy/reference/sparse.html
+    """
+    import scipy as sp
+    import scipy.sparse
+
+    warnings.warn(
+        (
+            "\n\nThe scipy.sparse array containers will be used instead of matrices\n"
+            "in Networkx 3.0. Use `to_scipy_sparse_array` instead."
+        ),
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    A = to_scipy_sparse_array(
+        G, nodelist=nodelist, dtype=dtype, weight=weight, format=format
+    )
+    return sp.sparse.csr_matrix(A).asformat(format)
+
+
+def from_scipy_sparse_matrix(
+    A, parallel_edges=False, create_using=None, edge_attribute="weight"
+):
+    """Creates a new graph from an adjacency matrix given as a SciPy sparse
+    matrix.
+
+    Parameters
+    ----------
+    A: scipy sparse matrix
+      An adjacency matrix representation of a graph
+
+    parallel_edges : Boolean
+      If this is True, `create_using` is a multigraph, and `A` is an
+      integer matrix, then entry *(i, j)* in the matrix is interpreted as the
+      number of parallel edges joining vertices *i* and *j* in the graph.
+      If it is False, then the entries in the matrix are interpreted as
+      the weight of a single edge joining the vertices.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    edge_attribute: string
+       Name of edge attribute to store matrix numeric value. The data will
+       have the same type as the matrix entry (int, float, (real,imag)).
+
+    Notes
+    -----
+    For directed graphs, explicitly mention create_using=nx.DiGraph,
+    and entry i,j of A corresponds to an edge from i to j.
+
+    If `create_using` is :class:`networkx.MultiGraph` or
+    :class:`networkx.MultiDiGraph`, `parallel_edges` is True, and the
+    entries of `A` are of type :class:`int`, then this function returns a
+    multigraph (constructed from `create_using`) with parallel edges.
+    In this case, `edge_attribute` will be ignored.
+
+    If `create_using` indicates an undirected multigraph, then only the edges
+    indicated by the upper triangle of the matrix `A` will be added to the
+    graph.
+
+    Examples
+    --------
+    >>> import scipy as sp
+    >>> import scipy.sparse  # call as sp.sparse
+    >>> A = sp.sparse.eye(2, 2, 1)
+    >>> G = nx.from_scipy_sparse_matrix(A)
+
+    If `create_using` indicates a multigraph and the matrix has only integer
+    entries and `parallel_edges` is False, then the entries will be treated
+    as weights for edges joining the nodes (without creating parallel edges):
+
+    >>> A = sp.sparse.csr_matrix([[1, 1], [1, 2]])
+    >>> G = nx.from_scipy_sparse_matrix(A, create_using=nx.MultiGraph)
+    >>> G[1][1]
+    AtlasView({0: {'weight': 2}})
+
+    If `create_using` indicates a multigraph and the matrix has only integer
+    entries and `parallel_edges` is True, then the entries will be treated
+    as the number of parallel edges joining those two vertices:
+
+    >>> A = sp.sparse.csr_matrix([[1, 1], [1, 2]])
+    >>> G = nx.from_scipy_sparse_matrix(
+    ...     A, parallel_edges=True, create_using=nx.MultiGraph
+    ... )
+    >>> G[1][1]
+    AtlasView({0: {'weight': 1}, 1: {'weight': 1}})
+
+    """
+    warnings.warn(
+        (
+            "\n\nThe scipy.sparse array containers will be used instead of matrices\n"
+            "in Networkx 3.0. Use `from_scipy_sparse_array` instead."
+        ),
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return from_scipy_sparse_array(
+        A,
+        parallel_edges=parallel_edges,
+        create_using=create_using,
+        edge_attribute=edge_attribute,
+    )
+
+
+def _csr_gen_triples(A):
+    """Converts a SciPy sparse matrix in **Compressed Sparse Row** format to
+    an iterable of weighted edge triples.
+
+    """
+    nrows = A.shape[0]
+    data, indices, indptr = A.data, A.indices, A.indptr
+    for i in range(nrows):
+        for j in range(indptr[i], indptr[i + 1]):
+            yield i, indices[j], data[j]
+
+
+def _csc_gen_triples(A):
+    """Converts a SciPy sparse matrix in **Compressed Sparse Column** format to
+    an iterable of weighted edge triples.
+
+    """
+    ncols = A.shape[1]
+    data, indices, indptr = A.data, A.indices, A.indptr
+    for i in range(ncols):
+        for j in range(indptr[i], indptr[i + 1]):
+            yield indices[j], i, data[j]
+
+
+def _coo_gen_triples(A):
+    """Converts a SciPy sparse matrix in **Coordinate** format to an iterable
+    of weighted edge triples.
+
+    """
+    row, col, data = A.row, A.col, A.data
+    return zip(row, col, data)
+
+
+def _dok_gen_triples(A):
+    """Converts a SciPy sparse matrix in **Dictionary of Keys** format to an
+    iterable of weighted edge triples.
+
+    """
+    for (r, c), v in A.items():
+        yield r, c, v
+
+
+def _generate_weighted_edges(A):
+    """Returns an iterable over (u, v, w) triples, where u and v are adjacent
+    vertices and w is the weight of the edge joining u and v.
+
+    `A` is a SciPy sparse matrix (in any format).
+
+    """
+    if A.format == "csr":
+        return _csr_gen_triples(A)
+    if A.format == "csc":
+        return _csc_gen_triples(A)
+    if A.format == "dok":
+        return _dok_gen_triples(A)
+    # If A is in any other format (including COO), convert it to COO format.
+    return _coo_gen_triples(A.tocoo())
+
+
+def from_scipy_sparse_array(
+    A, parallel_edges=False, create_using=None, edge_attribute="weight"
+):
+    """Creates a new graph from an adjacency matrix given as a SciPy sparse
+    array.
+
+    Parameters
+    ----------
+    A: scipy.sparse array
+      An adjacency matrix representation of a graph
+
+    parallel_edges : Boolean
+      If this is True, `create_using` is a multigraph, and `A` is an
+      integer matrix, then entry *(i, j)* in the matrix is interpreted as the
+      number of parallel edges joining vertices *i* and *j* in the graph.
+      If it is False, then the entries in the matrix are interpreted as
+      the weight of a single edge joining the vertices.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    edge_attribute: string
+       Name of edge attribute to store matrix numeric value. The data will
+       have the same type as the matrix entry (int, float, (real,imag)).
+
+    Notes
+    -----
+    For directed graphs, explicitly mention create_using=nx.DiGraph,
+    and entry i,j of A corresponds to an edge from i to j.
+
+    If `create_using` is :class:`networkx.MultiGraph` or
+    :class:`networkx.MultiDiGraph`, `parallel_edges` is True, and the
+    entries of `A` are of type :class:`int`, then this function returns a
+    multigraph (constructed from `create_using`) with parallel edges.
+    In this case, `edge_attribute` will be ignored.
+
+    If `create_using` indicates an undirected multigraph, then only the edges
+    indicated by the upper triangle of the matrix `A` will be added to the
+    graph.
+
+    Examples
+    --------
+    >>> import scipy as sp
+    >>> import scipy.sparse  # call as sp.sparse
+    >>> A = sp.sparse.eye(2, 2, 1)
+    >>> G = nx.from_scipy_sparse_array(A)
+
+    If `create_using` indicates a multigraph and the matrix has only integer
+    entries and `parallel_edges` is False, then the entries will be treated
+    as weights for edges joining the nodes (without creating parallel edges):
+
+    >>> A = sp.sparse.csr_array([[1, 1], [1, 2]])
+    >>> G = nx.from_scipy_sparse_array(A, create_using=nx.MultiGraph)
+    >>> G[1][1]
+    AtlasView({0: {'weight': 2}})
+
+    If `create_using` indicates a multigraph and the matrix has only integer
+    entries and `parallel_edges` is True, then the entries will be treated
+    as the number of parallel edges joining those two vertices:
+
+    >>> A = sp.sparse.csr_array([[1, 1], [1, 2]])
+    >>> G = nx.from_scipy_sparse_array(
+    ...     A, parallel_edges=True, create_using=nx.MultiGraph
+    ... )
+    >>> G[1][1]
+    AtlasView({0: {'weight': 1}, 1: {'weight': 1}})
+
+    """
+    G = nx.empty_graph(0, create_using)
+    n, m = A.shape
+    if n != m:
+        raise nx.NetworkXError(f"Adjacency matrix not square: nx,ny={A.shape}")
+    # Make sure we get even the isolated nodes of the graph.
+    G.add_nodes_from(range(n))
+    # Create an iterable over (u, v, w) triples and for each triple, add an
+    # edge from u to v with weight w.
+    triples = _generate_weighted_edges(A)
+    # If the entries in the adjacency matrix are integers, the graph is a
+    # multigraph, and parallel_edges is True, then create parallel edges, each
+    # with weight 1, for each entry in the adjacency matrix. Otherwise, create
+    # one edge for each positive entry in the adjacency matrix and set the
+    # weight of that edge to be the entry in the matrix.
+    if A.dtype.kind in ("i", "u") and G.is_multigraph() and parallel_edges:
+        chain = itertools.chain.from_iterable
+        # The following line is equivalent to:
+        #
+        #     for (u, v) in edges:
+        #         for d in range(A[u, v]):
+        #             G.add_edge(u, v, weight=1)
+        #
+        triples = chain(((u, v, 1) for d in range(w)) for (u, v, w) in triples)
+    # If we are creating an undirected multigraph, only add the edges from the
+    # upper triangle of the matrix. Otherwise, add all the edges. This relies
+    # on the fact that the vertices created in the
+    # `_generated_weighted_edges()` function are actually the row/column
+    # indices for the matrix `A`.
+    #
+    # Without this check, we run into a problem where each edge is added twice
+    # when `G.add_weighted_edges_from()` is invoked below.
+    if G.is_multigraph() and not G.is_directed():
+        triples = ((u, v, d) for u, v, d in triples if u <= v)
+    G.add_weighted_edges_from(triples, weight=edge_attribute)
+    return G
+
+
+def to_numpy_array(
+    G,
+    nodelist=None,
+    dtype=None,
+    order=None,
+    multigraph_weight=sum,
+    weight="weight",
+    nonedge=0.0,
+):
+    """Returns the graph adjacency matrix as a NumPy array.
+
+    Parameters
+    ----------
+    G : graph
+        The NetworkX graph used to construct the NumPy array.
+
+    nodelist : list, optional
+        The rows and columns are ordered according to the nodes in `nodelist`.
+        If `nodelist` is ``None``, then the ordering is produced by ``G.nodes()``.
+
+    dtype : NumPy data type, optional
+        A NumPy data type used to initialize the array. If None, then the NumPy
+        default is used. The dtype can be structured if `weight=None`, in which
+        case the dtype field names are used to look up edge attributes. The
+        result is a structured array where each named field in the dtype
+        corresponds to the adjaceny for that edge attribute. See examples for
+        details.
+
+    order : {'C', 'F'}, optional
+        Whether to store multidimensional data in C- or Fortran-contiguous
+        (row- or column-wise) order in memory. If None, then the NumPy default
+        is used.
+
+    multigraph_weight : callable, optional
+        An function that determines how weights in multigraphs are handled.
+        The function should accept a sequence of weights and return a single
+        value. The default is to sum the weights of the multiple edges.
+
+    weight : string or None optional (default = 'weight')
+        The edge attribute that holds the numerical value used for
+        the edge weight. If an edge does not have that attribute, then the
+        value 1 is used instead. `weight` must be ``None`` if a structured
+        dtype is used.
+
+    nonedge : array_like (default = 0.0)
+        The value used to represent non-edges in the adjaceny matrix.
+        The array values corresponding to nonedges are typically set to zero.
+        However, this could be undesirable if there are array values
+        corresponding to actual edges that also have the value zero. If so,
+        one might prefer nonedges to have some other value, such as ``nan``.
+
+    Returns
+    -------
+    A : NumPy ndarray
+        Graph adjacency matrix
+
+    Raises
+    ------
+    NetworkXError
+        If `dtype` is a structured dtype and `G` is a multigraph
+    ValueError
+        If `dtype` is a structured dtype and `weight` is not `None`
+
+    See Also
+    --------
+    from_numpy_array
+
+    Notes
+    -----
+    For directed graphs, entry ``i, j`` corresponds to an edge from ``i`` to ``j``.
+
+    Entries in the adjacency matrix are given by the `weight` edge attribute.
+    When an edge does not have a weight attribute, the value of the entry is
+    set to the number 1.  For multiple (parallel) edges, the values of the
+    entries are determined by the `multigraph_weight` parameter. The default is
+    to sum the weight attributes for each of the parallel edges.
+
+    When `nodelist` does not contain every node in `G`, the adjacency matrix is
+    built from the subgraph of `G` that is induced by the nodes in `nodelist`.
+
+    The convention used for self-loop edges in graphs is to assign the
+    diagonal array entry value to the weight attribute of the edge
+    (or the number 1 if the edge has no weight attribute). If the
+    alternate convention of doubling the edge weight is desired the
+    resulting NumPy array can be modified as follows:
+
+    >>> import numpy as np
+    >>> G = nx.Graph([(1, 1)])
+    >>> A = nx.to_numpy_array(G)
+    >>> A
+    array([[1.]])
+    >>> A[np.diag_indices_from(A)] *= 2
+    >>> A
+    array([[2.]])
+
+    Examples
+    --------
+    >>> G = nx.MultiDiGraph()
+    >>> G.add_edge(0, 1, weight=2)
+    0
+    >>> G.add_edge(1, 0)
+    0
+    >>> G.add_edge(2, 2, weight=3)
+    0
+    >>> G.add_edge(2, 2)
+    1
+    >>> nx.to_numpy_array(G, nodelist=[0, 1, 2])
+    array([[0., 2., 0.],
+           [1., 0., 0.],
+           [0., 0., 4.]])
+
+    When `nodelist` argument is used, nodes of `G` which do not appear in the `nodelist`
+    and their edges are not included in the adjacency matrix. Here is an example:
+
+    >>> G = nx.Graph()
+    >>> G.add_edge(3, 1)
+    >>> G.add_edge(2, 0)
+    >>> G.add_edge(2, 1)
+    >>> G.add_edge(3, 0)
+    >>> nx.to_numpy_array(G, nodelist=[1, 2, 3])
+    array([[0., 1., 1.],
+           [1., 0., 0.],
+           [1., 0., 0.]])
+
+    This function can also be used to create adjacency matrices for multiple
+    edge attributes with structured dtypes:
+
+    >>> G = nx.Graph()
+    >>> G.add_edge(0, 1, weight=10)
+    >>> G.add_edge(1, 2, cost=5)
+    >>> G.add_edge(2, 3, weight=3, cost=-4.0)
+    >>> dtype = np.dtype([("weight", int), ("cost", float)])
+    >>> A = nx.to_numpy_array(G, dtype=dtype, weight=None)
+    >>> A["weight"]
+    array([[ 0, 10,  0,  0],
+           [10,  0,  1,  0],
+           [ 0,  1,  0,  3],
+           [ 0,  0,  3,  0]])
+    >>> A["cost"]
+    array([[ 0.,  1.,  0.,  0.],
+           [ 1.,  0.,  5.,  0.],
+           [ 0.,  5.,  0., -4.],
+           [ 0.,  0., -4.,  0.]])
+
+    As stated above, the argument "nonedge" is useful especially when there are
+    actually edges with weight 0 in the graph. Setting a nonedge value different than 0,
+    makes it much clearer to differentiate such 0-weighted edges and actual nonedge values.
+
+    >>> G = nx.Graph()
+    >>> G.add_edge(3, 1, weight=2)
+    >>> G.add_edge(2, 0, weight=0)
+    >>> G.add_edge(2, 1, weight=0)
+    >>> G.add_edge(3, 0, weight=1)
+    >>> nx.to_numpy_array(G, nonedge=-1.)
+    array([[-1.,  2., -1.,  1.],
+           [ 2., -1.,  0., -1.],
+           [-1.,  0., -1.,  0.],
+           [ 1., -1.,  0., -1.]])
+    """
+    import numpy as np
+
+    if nodelist is None:
+        nodelist = list(G)
+    nlen = len(nodelist)
+
+    # Input validation
+    nodeset = set(nodelist)
+    if nodeset - set(G):
+        raise nx.NetworkXError(f"Nodes {nodeset - set(G)} in nodelist is not in G")
+    if len(nodeset) < nlen:
+        raise nx.NetworkXError("nodelist contains duplicates.")
+
+    A = np.full((nlen, nlen), fill_value=nonedge, dtype=dtype, order=order)
+
+    # Corner cases: empty nodelist or graph without any edges
+    if nlen == 0 or G.number_of_edges() == 0:
+        return A
+
+    # If dtype is structured and weight is None, use dtype field names as
+    # edge attributes
+    edge_attrs = None  # Only single edge attribute by default
+    if A.dtype.names:
+        if weight is None:
+            edge_attrs = dtype.names
+        else:
+            raise ValueError(
+                "Specifying `weight` not supported for structured dtypes\n."
+                "To create adjacency matrices from structured dtypes, use `weight=None`."
+            )
+
+    # Map nodes to row/col in matrix
+    idx = dict(zip(nodelist, range(nlen)))
+    if len(nodelist) < len(G):
+        G = G.subgraph(nodelist).copy()
+
+    # Collect all edge weights and reduce with `multigraph_weights`
+    if G.is_multigraph():
+        if edge_attrs:
+            raise nx.NetworkXError(
+                "Structured arrays are not supported for MultiGraphs"
+            )
+        d = defaultdict(list)
+        for u, v, wt in G.edges(data=weight, default=1.0):
+            d[(idx[u], idx[v])].append(wt)
+        i, j = np.array(list(d.keys())).T  # indices
+        wts = [multigraph_weight(ws) for ws in d.values()]  # reduced weights
+    else:
+        i, j, wts = [], [], []
+
+        # Special branch: multi-attr adjacency from structured dtypes
+        if edge_attrs:
+            # Extract edges with all data
+            for u, v, data in G.edges(data=True):
+                i.append(idx[u])
+                j.append(idx[v])
+                wts.append(data)
+            # Map each attribute to the appropriate named field in the
+            # structured dtype
+            for attr in edge_attrs:
+                attr_data = [wt.get(attr, 1.0) for wt in wts]
+                A[attr][i, j] = attr_data
+                if not G.is_directed():
+                    A[attr][j, i] = attr_data
+            return A
+
+        for u, v, wt in G.edges(data=weight, default=1.0):
+            i.append(idx[u])
+            j.append(idx[v])
+            wts.append(wt)
+
+    # Set array values with advanced indexing
+    A[i, j] = wts
+    if not G.is_directed():
+        A[j, i] = wts
+
+    return A
+
+
+def from_numpy_array(A, parallel_edges=False, create_using=None):
+    """Returns a graph from a 2D NumPy array.
+
+    The 2D NumPy array is interpreted as an adjacency matrix for the graph.
+
+    Parameters
+    ----------
+    A : a 2D numpy.ndarray
+        An adjacency matrix representation of a graph
+
+    parallel_edges : Boolean
+        If this is True, `create_using` is a multigraph, and `A` is an
+        integer array, then entry *(i, j)* in the array is interpreted as the
+        number of parallel edges joining vertices *i* and *j* in the graph.
+        If it is False, then the entries in the array are interpreted as
+        the weight of a single edge joining the vertices.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Notes
+    -----
+    For directed graphs, explicitly mention create_using=nx.DiGraph,
+    and entry i,j of A corresponds to an edge from i to j.
+
+    If `create_using` is :class:`networkx.MultiGraph` or
+    :class:`networkx.MultiDiGraph`, `parallel_edges` is True, and the
+    entries of `A` are of type :class:`int`, then this function returns a
+    multigraph (of the same type as `create_using`) with parallel edges.
+
+    If `create_using` indicates an undirected multigraph, then only the edges
+    indicated by the upper triangle of the array `A` will be added to the
+    graph.
+
+    If the NumPy array has a single data type for each array entry it
+    will be converted to an appropriate Python data type.
+
+    If the NumPy array has a user-specified compound data type the names
+    of the data fields will be used as attribute keys in the resulting
+    NetworkX graph.
+
+    See Also
+    --------
+    to_numpy_array
+
+    Examples
+    --------
+    Simple integer weights on edges:
+
+    >>> import numpy as np
+    >>> A = np.array([[1, 1], [2, 1]])
+    >>> G = nx.from_numpy_array(A)
+    >>> G.edges(data=True)
+    EdgeDataView([(0, 0, {'weight': 1}), (0, 1, {'weight': 2}), (1, 1, {'weight': 1})])
+
+    If `create_using` indicates a multigraph and the array has only integer
+    entries and `parallel_edges` is False, then the entries will be treated
+    as weights for edges joining the nodes (without creating parallel edges):
+
+    >>> A = np.array([[1, 1], [1, 2]])
+    >>> G = nx.from_numpy_array(A, create_using=nx.MultiGraph)
+    >>> G[1][1]
+    AtlasView({0: {'weight': 2}})
+
+    If `create_using` indicates a multigraph and the array has only integer
+    entries and `parallel_edges` is True, then the entries will be treated
+    as the number of parallel edges joining those two vertices:
+
+    >>> A = np.array([[1, 1], [1, 2]])
+    >>> temp = nx.MultiGraph()
+    >>> G = nx.from_numpy_array(A, parallel_edges=True, create_using=temp)
+    >>> G[1][1]
+    AtlasView({0: {'weight': 1}, 1: {'weight': 1}})
+
+    User defined compound data type on edges:
+
+    >>> dt = [("weight", float), ("cost", int)]
+    >>> A = np.array([[(1.0, 2)]], dtype=dt)
+    >>> G = nx.from_numpy_array(A)
+    >>> G.edges()
+    EdgeView([(0, 0)])
+    >>> G[0][0]["cost"]
+    2
+    >>> G[0][0]["weight"]
+    1.0
+
+    """
+    kind_to_python_type = {
+        "f": float,
+        "i": int,
+        "u": int,
+        "b": bool,
+        "c": complex,
+        "S": str,
+        "U": str,
+        "V": "void",
+    }
+    G = nx.empty_graph(0, create_using)
+    if A.ndim != 2:
+        raise nx.NetworkXError(f"Input array must be 2D, not {A.ndim}")
+    n, m = A.shape
+    if n != m:
+        raise nx.NetworkXError(f"Adjacency matrix not square: nx,ny={A.shape}")
+    dt = A.dtype
+    try:
+        python_type = kind_to_python_type[dt.kind]
+    except Exception as err:
+        raise TypeError(f"Unknown numpy data type: {dt}") from err
+
+    # Make sure we get even the isolated nodes of the graph.
+    G.add_nodes_from(range(n))
+    # Get a list of all the entries in the array with nonzero entries. These
+    # coordinates become edges in the graph. (convert to int from np.int64)
+    edges = ((int(e[0]), int(e[1])) for e in zip(*A.nonzero()))
+    # handle numpy constructed data type
+    if python_type == "void":
+        # Sort the fields by their offset, then by dtype, then by name.
+        fields = sorted(
+            (offset, dtype, name) for name, (dtype, offset) in A.dtype.fields.items()
+        )
+        triples = (
+            (
+                u,
+                v,
+                {
+                    name: kind_to_python_type[dtype.kind](val)
+                    for (_, dtype, name), val in zip(fields, A[u, v])
+                },
+            )
+            for u, v in edges
+        )
+    # If the entries in the adjacency matrix are integers, the graph is a
+    # multigraph, and parallel_edges is True, then create parallel edges, each
+    # with weight 1, for each entry in the adjacency matrix. Otherwise, create
+    # one edge for each positive entry in the adjacency matrix and set the
+    # weight of that edge to be the entry in the matrix.
+    elif python_type is int and G.is_multigraph() and parallel_edges:
+        chain = itertools.chain.from_iterable
+        # The following line is equivalent to:
+        #
+        #     for (u, v) in edges:
+        #         for d in range(A[u, v]):
+        #             G.add_edge(u, v, weight=1)
+        #
+        triples = chain(
+            ((u, v, {"weight": 1}) for d in range(A[u, v])) for (u, v) in edges
+        )
+    else:  # basic data type
+        triples = ((u, v, dict(weight=python_type(A[u, v]))) for u, v in edges)
+    # If we are creating an undirected multigraph, only add the edges from the
+    # upper triangle of the matrix. Otherwise, add all the edges. This relies
+    # on the fact that the vertices created in the
+    # `_generated_weighted_edges()` function are actually the row/column
+    # indices for the matrix `A`.
+    #
+    # Without this check, we run into a problem where each edge is added twice
+    # when `G.add_edges_from()` is invoked below.
+    if G.is_multigraph() and not G.is_directed():
+        triples = ((u, v, d) for u, v, d in triples if u <= v)
+    G.add_edges_from(triples)
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/drawing/__init__.py b/myenv/lib/python3.9/site-packages/networkx/drawing/__init__.py
new file mode 100644
index 0000000..1e8542f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/drawing/__init__.py
@@ -0,0 +1,6 @@
+# graph drawing and interface to graphviz
+
+from .layout import *
+from .nx_pylab import *
+from . import nx_agraph
+from . import nx_pydot
diff --git a/myenv/lib/python3.9/site-packages/networkx/drawing/layout.py b/myenv/lib/python3.9/site-packages/networkx/drawing/layout.py
new file mode 100644
index 0000000..b6d2afe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/drawing/layout.py
@@ -0,0 +1,1189 @@
+"""
+******
+Layout
+******
+
+Node positioning algorithms for graph drawing.
+
+For `random_layout()` the possible resulting shape
+is a square of side [0, scale] (default: [0, 1])
+Changing `center` shifts the layout by that amount.
+
+For the other layout routines, the extent is
+[center - scale, center + scale] (default: [-1, 1]).
+
+Warning: Most layout routines have only been tested in 2-dimensions.
+
+"""
+import networkx as nx
+from networkx.utils import np_random_state
+
+__all__ = [
+    "bipartite_layout",
+    "circular_layout",
+    "kamada_kawai_layout",
+    "random_layout",
+    "rescale_layout",
+    "rescale_layout_dict",
+    "shell_layout",
+    "spring_layout",
+    "spectral_layout",
+    "planar_layout",
+    "fruchterman_reingold_layout",
+    "spiral_layout",
+    "multipartite_layout",
+]
+
+
+def _process_params(G, center, dim):
+    # Some boilerplate code.
+    import numpy as np
+
+    if not isinstance(G, nx.Graph):
+        empty_graph = nx.Graph()
+        empty_graph.add_nodes_from(G)
+        G = empty_graph
+
+    if center is None:
+        center = np.zeros(dim)
+    else:
+        center = np.asarray(center)
+
+    if len(center) != dim:
+        msg = "length of center coordinates must match dimension of layout"
+        raise ValueError(msg)
+
+    return G, center
+
+
+@np_random_state(3)
+def random_layout(G, center=None, dim=2, seed=None):
+    """Position nodes uniformly at random in the unit square.
+
+    For every node, a position is generated by choosing each of dim
+    coordinates uniformly at random on the interval [0.0, 1.0).
+
+    NumPy (http://scipy.org) is required for this function.
+
+    Parameters
+    ----------
+    G : NetworkX graph or list of nodes
+        A position will be assigned to every node in G.
+
+    center : array-like or None
+        Coordinate pair around which to center the layout.
+
+    dim : int
+        Dimension of layout.
+
+    seed : int, RandomState instance or None  optional (default=None)
+        Set the random state for deterministic node layouts.
+        If int, `seed` is the seed used by the random number generator,
+        if numpy.random.RandomState instance, `seed` is the random
+        number generator,
+        if None, the random number generator is the RandomState instance used
+        by numpy.random.
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node
+
+    Examples
+    --------
+    >>> G = nx.lollipop_graph(4, 3)
+    >>> pos = nx.random_layout(G)
+
+    """
+    import numpy as np
+
+    G, center = _process_params(G, center, dim)
+    pos = seed.rand(len(G), dim) + center
+    pos = pos.astype(np.float32)
+    pos = dict(zip(G, pos))
+
+    return pos
+
+
+def circular_layout(G, scale=1, center=None, dim=2):
+    # dim=2 only
+    """Position nodes on a circle.
+
+    Parameters
+    ----------
+    G : NetworkX graph or list of nodes
+        A position will be assigned to every node in G.
+
+    scale : number (default: 1)
+        Scale factor for positions.
+
+    center : array-like or None
+        Coordinate pair around which to center the layout.
+
+    dim : int
+        Dimension of layout.
+        If dim>2, the remaining dimensions are set to zero
+        in the returned positions.
+        If dim<2, a ValueError is raised.
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node
+
+    Raises
+    ------
+    ValueError
+        If dim < 2
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> pos = nx.circular_layout(G)
+
+    Notes
+    -----
+    This algorithm currently only works in two dimensions and does not
+    try to minimize edge crossings.
+
+    """
+    import numpy as np
+
+    if dim < 2:
+        raise ValueError("cannot handle dimensions < 2")
+
+    G, center = _process_params(G, center, dim)
+
+    paddims = max(0, (dim - 2))
+
+    if len(G) == 0:
+        pos = {}
+    elif len(G) == 1:
+        pos = {nx.utils.arbitrary_element(G): center}
+    else:
+        # Discard the extra angle since it matches 0 radians.
+        theta = np.linspace(0, 1, len(G) + 1)[:-1] * 2 * np.pi
+        theta = theta.astype(np.float32)
+        pos = np.column_stack(
+            [np.cos(theta), np.sin(theta), np.zeros((len(G), paddims))]
+        )
+        pos = rescale_layout(pos, scale=scale) + center
+        pos = dict(zip(G, pos))
+
+    return pos
+
+
+def shell_layout(G, nlist=None, rotate=None, scale=1, center=None, dim=2):
+    """Position nodes in concentric circles.
+
+    Parameters
+    ----------
+    G : NetworkX graph or list of nodes
+        A position will be assigned to every node in G.
+
+    nlist : list of lists
+       List of node lists for each shell.
+
+    rotate : angle in radians (default=pi/len(nlist))
+       Angle by which to rotate the starting position of each shell
+       relative to the starting position of the previous shell.
+       To recreate behavior before v2.5 use rotate=0.
+
+    scale : number (default: 1)
+        Scale factor for positions.
+
+    center : array-like or None
+        Coordinate pair around which to center the layout.
+
+    dim : int
+        Dimension of layout, currently only dim=2 is supported.
+        Other dimension values result in a ValueError.
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node
+
+    Raises
+    ------
+    ValueError
+        If dim != 2
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> shells = [[0], [1, 2, 3]]
+    >>> pos = nx.shell_layout(G, shells)
+
+    Notes
+    -----
+    This algorithm currently only works in two dimensions and does not
+    try to minimize edge crossings.
+
+    """
+    import numpy as np
+
+    if dim != 2:
+        raise ValueError("can only handle 2 dimensions")
+
+    G, center = _process_params(G, center, dim)
+
+    if len(G) == 0:
+        return {}
+    if len(G) == 1:
+        return {nx.utils.arbitrary_element(G): center}
+
+    if nlist is None:
+        # draw the whole graph in one shell
+        nlist = [list(G)]
+
+    radius_bump = scale / len(nlist)
+
+    if len(nlist[0]) == 1:
+        # single node at center
+        radius = 0.0
+    else:
+        # else start at r=1
+        radius = radius_bump
+
+    if rotate is None:
+        rotate = np.pi / len(nlist)
+    first_theta = rotate
+    npos = {}
+    for nodes in nlist:
+        # Discard the last angle (endpoint=False) since 2*pi matches 0 radians
+        theta = (
+            np.linspace(0, 2 * np.pi, len(nodes), endpoint=False, dtype=np.float32)
+            + first_theta
+        )
+        pos = radius * np.column_stack([np.cos(theta), np.sin(theta)]) + center
+        npos.update(zip(nodes, pos))
+        radius += radius_bump
+        first_theta += rotate
+
+    return npos
+
+
+def bipartite_layout(
+    G, nodes, align="vertical", scale=1, center=None, aspect_ratio=4 / 3
+):
+    """Position nodes in two straight lines.
+
+    Parameters
+    ----------
+    G : NetworkX graph or list of nodes
+        A position will be assigned to every node in G.
+
+    nodes : list or container
+        Nodes in one node set of the bipartite graph.
+        This set will be placed on left or top.
+
+    align : string (default='vertical')
+        The alignment of nodes. Vertical or horizontal.
+
+    scale : number (default: 1)
+        Scale factor for positions.
+
+    center : array-like or None
+        Coordinate pair around which to center the layout.
+
+    aspect_ratio : number (default=4/3):
+        The ratio of the width to the height of the layout.
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node.
+
+    Examples
+    --------
+    >>> G = nx.bipartite.gnmk_random_graph(3, 5, 10, seed=123)
+    >>> top = nx.bipartite.sets(G)[0]
+    >>> pos = nx.bipartite_layout(G, top)
+
+    Notes
+    -----
+    This algorithm currently only works in two dimensions and does not
+    try to minimize edge crossings.
+
+    """
+
+    import numpy as np
+
+    if align not in ("vertical", "horizontal"):
+        msg = "align must be either vertical or horizontal."
+        raise ValueError(msg)
+
+    G, center = _process_params(G, center=center, dim=2)
+    if len(G) == 0:
+        return {}
+
+    height = 1
+    width = aspect_ratio * height
+    offset = (width / 2, height / 2)
+
+    top = set(nodes)
+    bottom = set(G) - top
+    nodes = list(top) + list(bottom)
+
+    left_xs = np.repeat(0, len(top))
+    right_xs = np.repeat(width, len(bottom))
+    left_ys = np.linspace(0, height, len(top))
+    right_ys = np.linspace(0, height, len(bottom))
+
+    top_pos = np.column_stack([left_xs, left_ys]) - offset
+    bottom_pos = np.column_stack([right_xs, right_ys]) - offset
+
+    pos = np.concatenate([top_pos, bottom_pos])
+    pos = rescale_layout(pos, scale=scale) + center
+    if align == "horizontal":
+        pos = pos[:, ::-1]  # swap x and y coords
+    pos = dict(zip(nodes, pos))
+    return pos
+
+
+@np_random_state(10)
+def spring_layout(
+    G,
+    k=None,
+    pos=None,
+    fixed=None,
+    iterations=50,
+    threshold=1e-4,
+    weight="weight",
+    scale=1,
+    center=None,
+    dim=2,
+    seed=None,
+):
+    """Position nodes using Fruchterman-Reingold force-directed algorithm.
+
+    The algorithm simulates a force-directed representation of the network
+    treating edges as springs holding nodes close, while treating nodes
+    as repelling objects, sometimes called an anti-gravity force.
+    Simulation continues until the positions are close to an equilibrium.
+
+    There are some hard-coded values: minimal distance between
+    nodes (0.01) and "temperature" of 0.1 to ensure nodes don't fly away.
+    During the simulation, `k` helps determine the distance between nodes,
+    though `scale` and `center` determine the size and place after
+    rescaling occurs at the end of the simulation.
+
+    Fixing some nodes doesn't allow them to move in the simulation.
+    It also turns off the rescaling feature at the simulation's end.
+    In addition, setting `scale` to `None` turns off rescaling.
+
+    Parameters
+    ----------
+    G : NetworkX graph or list of nodes
+        A position will be assigned to every node in G.
+
+    k : float (default=None)
+        Optimal distance between nodes.  If None the distance is set to
+        1/sqrt(n) where n is the number of nodes.  Increase this value
+        to move nodes farther apart.
+
+    pos : dict or None  optional (default=None)
+        Initial positions for nodes as a dictionary with node as keys
+        and values as a coordinate list or tuple.  If None, then use
+        random initial positions.
+
+    fixed : list or None  optional (default=None)
+        Nodes to keep fixed at initial position.
+        Nodes not in ``G.nodes`` are ignored.
+        ValueError raised if `fixed` specified and `pos` not.
+
+    iterations : int  optional (default=50)
+        Maximum number of iterations taken
+
+    threshold: float optional (default = 1e-4)
+        Threshold for relative error in node position changes.
+        The iteration stops if the error is below this threshold.
+
+    weight : string or None   optional (default='weight')
+        The edge attribute that holds the numerical value used for
+        the edge weight.  Larger means a stronger attractive force.
+        If None, then all edge weights are 1.
+
+    scale : number or None (default: 1)
+        Scale factor for positions. Not used unless `fixed is None`.
+        If scale is None, no rescaling is performed.
+
+    center : array-like or None
+        Coordinate pair around which to center the layout.
+        Not used unless `fixed is None`.
+
+    dim : int
+        Dimension of layout.
+
+    seed : int, RandomState instance or None  optional (default=None)
+        Set the random state for deterministic node layouts.
+        If int, `seed` is the seed used by the random number generator,
+        if numpy.random.RandomState instance, `seed` is the random
+        number generator,
+        if None, the random number generator is the RandomState instance used
+        by numpy.random.
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> pos = nx.spring_layout(G)
+
+    # The same using longer but equivalent function name
+    >>> pos = nx.fruchterman_reingold_layout(G)
+    """
+    import numpy as np
+
+    G, center = _process_params(G, center, dim)
+
+    if fixed is not None:
+        if pos is None:
+            raise ValueError("nodes are fixed without positions given")
+        for node in fixed:
+            if node not in pos:
+                raise ValueError("nodes are fixed without positions given")
+        nfixed = {node: i for i, node in enumerate(G)}
+        fixed = np.asarray([nfixed[node] for node in fixed if node in nfixed])
+
+    if pos is not None:
+        # Determine size of existing domain to adjust initial positions
+        dom_size = max(coord for pos_tup in pos.values() for coord in pos_tup)
+        if dom_size == 0:
+            dom_size = 1
+        pos_arr = seed.rand(len(G), dim) * dom_size + center
+
+        for i, n in enumerate(G):
+            if n in pos:
+                pos_arr[i] = np.asarray(pos[n])
+    else:
+        pos_arr = None
+        dom_size = 1
+
+    if len(G) == 0:
+        return {}
+    if len(G) == 1:
+        return {nx.utils.arbitrary_element(G.nodes()): center}
+
+    try:
+        # Sparse matrix
+        if len(G) < 500:  # sparse solver for large graphs
+            raise ValueError
+        A = nx.to_scipy_sparse_array(G, weight=weight, dtype="f")
+        if k is None and fixed is not None:
+            # We must adjust k by domain size for layouts not near 1x1
+            nnodes, _ = A.shape
+            k = dom_size / np.sqrt(nnodes)
+        pos = _sparse_fruchterman_reingold(
+            A, k, pos_arr, fixed, iterations, threshold, dim, seed
+        )
+    except ValueError:
+        A = nx.to_numpy_array(G, weight=weight)
+        if k is None and fixed is not None:
+            # We must adjust k by domain size for layouts not near 1x1
+            nnodes, _ = A.shape
+            k = dom_size / np.sqrt(nnodes)
+        pos = _fruchterman_reingold(
+            A, k, pos_arr, fixed, iterations, threshold, dim, seed
+        )
+    if fixed is None and scale is not None:
+        pos = rescale_layout(pos, scale=scale) + center
+    pos = dict(zip(G, pos))
+    return pos
+
+
+fruchterman_reingold_layout = spring_layout
+
+
+@np_random_state(7)
+def _fruchterman_reingold(
+    A, k=None, pos=None, fixed=None, iterations=50, threshold=1e-4, dim=2, seed=None
+):
+    # Position nodes in adjacency matrix A using Fruchterman-Reingold
+    # Entry point for NetworkX graph is fruchterman_reingold_layout()
+    import numpy as np
+
+    try:
+        nnodes, _ = A.shape
+    except AttributeError as err:
+        msg = "fruchterman_reingold() takes an adjacency matrix as input"
+        raise nx.NetworkXError(msg) from err
+
+    if pos is None:
+        # random initial positions
+        pos = np.asarray(seed.rand(nnodes, dim), dtype=A.dtype)
+    else:
+        # make sure positions are of same type as matrix
+        pos = pos.astype(A.dtype)
+
+    # optimal distance between nodes
+    if k is None:
+        k = np.sqrt(1.0 / nnodes)
+    # the initial "temperature"  is about .1 of domain area (=1x1)
+    # this is the largest step allowed in the dynamics.
+    # We need to calculate this in case our fixed positions force our domain
+    # to be much bigger than 1x1
+    t = max(max(pos.T[0]) - min(pos.T[0]), max(pos.T[1]) - min(pos.T[1])) * 0.1
+    # simple cooling scheme.
+    # linearly step down by dt on each iteration so last iteration is size dt.
+    dt = t / (iterations + 1)
+    delta = np.zeros((pos.shape[0], pos.shape[0], pos.shape[1]), dtype=A.dtype)
+    # the inscrutable (but fast) version
+    # this is still O(V^2)
+    # could use multilevel methods to speed this up significantly
+    for iteration in range(iterations):
+        # matrix of difference between points
+        delta = pos[:, np.newaxis, :] - pos[np.newaxis, :, :]
+        # distance between points
+        distance = np.linalg.norm(delta, axis=-1)
+        # enforce minimum distance of 0.01
+        np.clip(distance, 0.01, None, out=distance)
+        # displacement "force"
+        displacement = np.einsum(
+            "ijk,ij->ik", delta, (k * k / distance**2 - A * distance / k)
+        )
+        # update positions
+        length = np.linalg.norm(displacement, axis=-1)
+        length = np.where(length < 0.01, 0.1, length)
+        delta_pos = np.einsum("ij,i->ij", displacement, t / length)
+        if fixed is not None:
+            # don't change positions of fixed nodes
+            delta_pos[fixed] = 0.0
+        pos += delta_pos
+        # cool temperature
+        t -= dt
+        if (np.linalg.norm(delta_pos) / nnodes) < threshold:
+            break
+    return pos
+
+
+@np_random_state(7)
+def _sparse_fruchterman_reingold(
+    A, k=None, pos=None, fixed=None, iterations=50, threshold=1e-4, dim=2, seed=None
+):
+    # Position nodes in adjacency matrix A using Fruchterman-Reingold
+    # Entry point for NetworkX graph is fruchterman_reingold_layout()
+    # Sparse version
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    try:
+        nnodes, _ = A.shape
+    except AttributeError as err:
+        msg = "fruchterman_reingold() takes an adjacency matrix as input"
+        raise nx.NetworkXError(msg) from err
+    # make sure we have a LIst of Lists representation
+    try:
+        A = A.tolil()
+    except AttributeError:
+        A = (sp.sparse.coo_array(A)).tolil()
+
+    if pos is None:
+        # random initial positions
+        pos = np.asarray(seed.rand(nnodes, dim), dtype=A.dtype)
+    else:
+        # make sure positions are of same type as matrix
+        pos = pos.astype(A.dtype)
+
+    # no fixed nodes
+    if fixed is None:
+        fixed = []
+
+    # optimal distance between nodes
+    if k is None:
+        k = np.sqrt(1.0 / nnodes)
+    # the initial "temperature"  is about .1 of domain area (=1x1)
+    # this is the largest step allowed in the dynamics.
+    t = max(max(pos.T[0]) - min(pos.T[0]), max(pos.T[1]) - min(pos.T[1])) * 0.1
+    # simple cooling scheme.
+    # linearly step down by dt on each iteration so last iteration is size dt.
+    dt = t / (iterations + 1)
+
+    displacement = np.zeros((dim, nnodes))
+    for iteration in range(iterations):
+        displacement *= 0
+        # loop over rows
+        for i in range(A.shape[0]):
+            if i in fixed:
+                continue
+            # difference between this row's node position and all others
+            delta = (pos[i] - pos).T
+            # distance between points
+            distance = np.sqrt((delta**2).sum(axis=0))
+            # enforce minimum distance of 0.01
+            distance = np.where(distance < 0.01, 0.01, distance)
+            # the adjacency matrix row
+            Ai = A.getrowview(i).toarray()  # TODO: revisit w/ sparse 1D container
+            # displacement "force"
+            displacement[:, i] += (
+                delta * (k * k / distance**2 - Ai * distance / k)
+            ).sum(axis=1)
+        # update positions
+        length = np.sqrt((displacement**2).sum(axis=0))
+        length = np.where(length < 0.01, 0.1, length)
+        delta_pos = (displacement * t / length).T
+        pos += delta_pos
+        # cool temperature
+        t -= dt
+        if (np.linalg.norm(delta_pos) / nnodes) < threshold:
+            break
+    return pos
+
+
+def kamada_kawai_layout(
+    G, dist=None, pos=None, weight="weight", scale=1, center=None, dim=2
+):
+    """Position nodes using Kamada-Kawai path-length cost-function.
+
+    Parameters
+    ----------
+    G : NetworkX graph or list of nodes
+        A position will be assigned to every node in G.
+
+    dist : dict (default=None)
+        A two-level dictionary of optimal distances between nodes,
+        indexed by source and destination node.
+        If None, the distance is computed using shortest_path_length().
+
+    pos : dict or None  optional (default=None)
+        Initial positions for nodes as a dictionary with node as keys
+        and values as a coordinate list or tuple.  If None, then use
+        circular_layout() for dim >= 2 and a linear layout for dim == 1.
+
+    weight : string or None   optional (default='weight')
+        The edge attribute that holds the numerical value used for
+        the edge weight.  If None, then all edge weights are 1.
+
+    scale : number (default: 1)
+        Scale factor for positions.
+
+    center : array-like or None
+        Coordinate pair around which to center the layout.
+
+    dim : int
+        Dimension of layout.
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> pos = nx.kamada_kawai_layout(G)
+    """
+    import numpy as np
+
+    G, center = _process_params(G, center, dim)
+    nNodes = len(G)
+    if nNodes == 0:
+        return {}
+
+    if dist is None:
+        dist = dict(nx.shortest_path_length(G, weight=weight))
+    dist_mtx = 1e6 * np.ones((nNodes, nNodes))
+    for row, nr in enumerate(G):
+        if nr not in dist:
+            continue
+        rdist = dist[nr]
+        for col, nc in enumerate(G):
+            if nc not in rdist:
+                continue
+            dist_mtx[row][col] = rdist[nc]
+
+    if pos is None:
+        if dim >= 3:
+            pos = random_layout(G, dim=dim)
+        elif dim == 2:
+            pos = circular_layout(G, dim=dim)
+        else:
+            pos = {n: pt for n, pt in zip(G, np.linspace(0, 1, len(G)))}
+    pos_arr = np.array([pos[n] for n in G])
+
+    pos = _kamada_kawai_solve(dist_mtx, pos_arr, dim)
+
+    pos = rescale_layout(pos, scale=scale) + center
+    return dict(zip(G, pos))
+
+
+def _kamada_kawai_solve(dist_mtx, pos_arr, dim):
+    # Anneal node locations based on the Kamada-Kawai cost-function,
+    # using the supplied matrix of preferred inter-node distances,
+    # and starting locations.
+
+    import numpy as np
+    import scipy as sp
+    import scipy.optimize  # call as sp.optimize
+
+    meanwt = 1e-3
+    costargs = (np, 1 / (dist_mtx + np.eye(dist_mtx.shape[0]) * 1e-3), meanwt, dim)
+
+    optresult = sp.optimize.minimize(
+        _kamada_kawai_costfn,
+        pos_arr.ravel(),
+        method="L-BFGS-B",
+        args=costargs,
+        jac=True,
+    )
+
+    return optresult.x.reshape((-1, dim))
+
+
+def _kamada_kawai_costfn(pos_vec, np, invdist, meanweight, dim):
+    # Cost-function and gradient for Kamada-Kawai layout algorithm
+    nNodes = invdist.shape[0]
+    pos_arr = pos_vec.reshape((nNodes, dim))
+
+    delta = pos_arr[:, np.newaxis, :] - pos_arr[np.newaxis, :, :]
+    nodesep = np.linalg.norm(delta, axis=-1)
+    direction = np.einsum("ijk,ij->ijk", delta, 1 / (nodesep + np.eye(nNodes) * 1e-3))
+
+    offset = nodesep * invdist - 1.0
+    offset[np.diag_indices(nNodes)] = 0
+
+    cost = 0.5 * np.sum(offset**2)
+    grad = np.einsum("ij,ij,ijk->ik", invdist, offset, direction) - np.einsum(
+        "ij,ij,ijk->jk", invdist, offset, direction
+    )
+
+    # Additional parabolic term to encourage mean position to be near origin:
+    sumpos = np.sum(pos_arr, axis=0)
+    cost += 0.5 * meanweight * np.sum(sumpos**2)
+    grad += meanweight * sumpos
+
+    return (cost, grad.ravel())
+
+
+def spectral_layout(G, weight="weight", scale=1, center=None, dim=2):
+    """Position nodes using the eigenvectors of the graph Laplacian.
+
+    Using the unnormalized Laplacian, the layout shows possible clusters of
+    nodes which are an approximation of the ratio cut. If dim is the number of
+    dimensions then the positions are the entries of the dim eigenvectors
+    corresponding to the ascending eigenvalues starting from the second one.
+
+    Parameters
+    ----------
+    G : NetworkX graph or list of nodes
+        A position will be assigned to every node in G.
+
+    weight : string or None   optional (default='weight')
+        The edge attribute that holds the numerical value used for
+        the edge weight.  If None, then all edge weights are 1.
+
+    scale : number (default: 1)
+        Scale factor for positions.
+
+    center : array-like or None
+        Coordinate pair around which to center the layout.
+
+    dim : int
+        Dimension of layout.
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> pos = nx.spectral_layout(G)
+
+    Notes
+    -----
+    Directed graphs will be considered as undirected graphs when
+    positioning the nodes.
+
+    For larger graphs (>500 nodes) this will use the SciPy sparse
+    eigenvalue solver (ARPACK).
+    """
+    # handle some special cases that break the eigensolvers
+    import numpy as np
+
+    G, center = _process_params(G, center, dim)
+
+    if len(G) <= 2:
+        if len(G) == 0:
+            pos = np.array([])
+        elif len(G) == 1:
+            pos = np.array([center])
+        else:
+            pos = np.array([np.zeros(dim), np.array(center) * 2.0])
+        return dict(zip(G, pos))
+    try:
+        # Sparse matrix
+        if len(G) < 500:  # dense solver is faster for small graphs
+            raise ValueError
+        A = nx.to_scipy_sparse_array(G, weight=weight, dtype="d")
+        # Symmetrize directed graphs
+        if G.is_directed():
+            A = A + np.transpose(A)
+        pos = _sparse_spectral(A, dim)
+    except (ImportError, ValueError):
+        # Dense matrix
+        A = nx.to_numpy_array(G, weight=weight)
+        # Symmetrize directed graphs
+        if G.is_directed():
+            A += A.T
+        pos = _spectral(A, dim)
+
+    pos = rescale_layout(pos, scale=scale) + center
+    pos = dict(zip(G, pos))
+    return pos
+
+
+def _spectral(A, dim=2):
+    # Input adjacency matrix A
+    # Uses dense eigenvalue solver from numpy
+    import numpy as np
+
+    try:
+        nnodes, _ = A.shape
+    except AttributeError as err:
+        msg = "spectral() takes an adjacency matrix as input"
+        raise nx.NetworkXError(msg) from err
+
+    # form Laplacian matrix where D is diagonal of degrees
+    D = np.identity(nnodes, dtype=A.dtype) * np.sum(A, axis=1)
+    L = D - A
+
+    eigenvalues, eigenvectors = np.linalg.eig(L)
+    # sort and keep smallest nonzero
+    index = np.argsort(eigenvalues)[1 : dim + 1]  # 0 index is zero eigenvalue
+    return np.real(eigenvectors[:, index])
+
+
+def _sparse_spectral(A, dim=2):
+    # Input adjacency matrix A
+    # Uses sparse eigenvalue solver from scipy
+    # Could use multilevel methods here, see Koren "On spectral graph drawing"
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+    import scipy.sparse.linalg  # call as sp.sparse.linalg
+
+    try:
+        nnodes, _ = A.shape
+    except AttributeError as err:
+        msg = "sparse_spectral() takes an adjacency matrix as input"
+        raise nx.NetworkXError(msg) from err
+
+    # form Laplacian matrix
+    # TODO: Rm csr_array wrapper in favor of spdiags array constructor when available
+    D = sp.sparse.csr_array(sp.sparse.spdiags(A.sum(axis=1), 0, nnodes, nnodes))
+    L = D - A
+
+    k = dim + 1
+    # number of Lanczos vectors for ARPACK solver.What is the right scaling?
+    ncv = max(2 * k + 1, int(np.sqrt(nnodes)))
+    # return smallest k eigenvalues and eigenvectors
+    eigenvalues, eigenvectors = sp.sparse.linalg.eigsh(L, k, which="SM", ncv=ncv)
+    index = np.argsort(eigenvalues)[1:k]  # 0 index is zero eigenvalue
+    return np.real(eigenvectors[:, index])
+
+
+def planar_layout(G, scale=1, center=None, dim=2):
+    """Position nodes without edge intersections.
+
+    Parameters
+    ----------
+    G : NetworkX graph or list of nodes
+        A position will be assigned to every node in G. If G is of type
+        nx.PlanarEmbedding, the positions are selected accordingly.
+
+    scale : number (default: 1)
+        Scale factor for positions.
+
+    center : array-like or None
+        Coordinate pair around which to center the layout.
+
+    dim : int
+        Dimension of layout.
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node
+
+    Raises
+    ------
+    NetworkXException
+        If G is not planar
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> pos = nx.planar_layout(G)
+    """
+    import numpy as np
+
+    if dim != 2:
+        raise ValueError("can only handle 2 dimensions")
+
+    G, center = _process_params(G, center, dim)
+
+    if len(G) == 0:
+        return {}
+
+    if isinstance(G, nx.PlanarEmbedding):
+        embedding = G
+    else:
+        is_planar, embedding = nx.check_planarity(G)
+        if not is_planar:
+            raise nx.NetworkXException("G is not planar.")
+    pos = nx.combinatorial_embedding_to_pos(embedding)
+    node_list = list(embedding)
+    pos = np.row_stack([pos[x] for x in node_list])
+    pos = pos.astype(np.float64)
+    pos = rescale_layout(pos, scale=scale) + center
+    return dict(zip(node_list, pos))
+
+
+def spiral_layout(G, scale=1, center=None, dim=2, resolution=0.35, equidistant=False):
+    """Position nodes in a spiral layout.
+
+    Parameters
+    ----------
+    G : NetworkX graph or list of nodes
+        A position will be assigned to every node in G.
+    scale : number (default: 1)
+        Scale factor for positions.
+    center : array-like or None
+        Coordinate pair around which to center the layout.
+    dim : int, default=2
+        Dimension of layout, currently only dim=2 is supported.
+        Other dimension values result in a ValueError.
+    resolution : float, default=0.35
+        The compactness of the spiral layout returned.
+        Lower values result in more compressed spiral layouts.
+    equidistant : bool, default=False
+        If True, nodes will be positioned equidistant from each other
+        by decreasing angle further from center.
+        If False, nodes will be positioned at equal angles
+        from each other by increasing separation further from center.
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node
+
+    Raises
+    ------
+    ValueError
+        If dim != 2
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> pos = nx.spiral_layout(G)
+    >>> nx.draw(G, pos=pos)
+
+    Notes
+    -----
+    This algorithm currently only works in two dimensions.
+
+    """
+    import numpy as np
+
+    if dim != 2:
+        raise ValueError("can only handle 2 dimensions")
+
+    G, center = _process_params(G, center, dim)
+
+    if len(G) == 0:
+        return {}
+    if len(G) == 1:
+        return {nx.utils.arbitrary_element(G): center}
+
+    pos = []
+    if equidistant:
+        chord = 1
+        step = 0.5
+        theta = resolution
+        theta += chord / (step * theta)
+        for _ in range(len(G)):
+            r = step * theta
+            theta += chord / r
+            pos.append([np.cos(theta) * r, np.sin(theta) * r])
+
+    else:
+        dist = np.arange(len(G), dtype=float)
+        angle = resolution * dist
+        pos = np.transpose(dist * np.array([np.cos(angle), np.sin(angle)]))
+
+    pos = rescale_layout(np.array(pos), scale=scale) + center
+
+    pos = dict(zip(G, pos))
+
+    return pos
+
+
+def multipartite_layout(G, subset_key="subset", align="vertical", scale=1, center=None):
+    """Position nodes in layers of straight lines.
+
+    Parameters
+    ----------
+    G : NetworkX graph or list of nodes
+        A position will be assigned to every node in G.
+
+    subset_key : string (default='subset')
+        Key of node data to be used as layer subset.
+
+    align : string (default='vertical')
+        The alignment of nodes. Vertical or horizontal.
+
+    scale : number (default: 1)
+        Scale factor for positions.
+
+    center : array-like or None
+        Coordinate pair around which to center the layout.
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node.
+
+    Examples
+    --------
+    >>> G = nx.complete_multipartite_graph(28, 16, 10)
+    >>> pos = nx.multipartite_layout(G)
+
+    Notes
+    -----
+    This algorithm currently only works in two dimensions and does not
+    try to minimize edge crossings.
+
+    Network does not need to be a complete multipartite graph. As long as nodes
+    have subset_key data, they will be placed in the corresponding layers.
+
+    """
+    import numpy as np
+
+    if align not in ("vertical", "horizontal"):
+        msg = "align must be either vertical or horizontal."
+        raise ValueError(msg)
+
+    G, center = _process_params(G, center=center, dim=2)
+    if len(G) == 0:
+        return {}
+
+    layers = {}
+    for v, data in G.nodes(data=True):
+        try:
+            layer = data[subset_key]
+        except KeyError:
+            msg = "all nodes must have subset_key (default='subset') as data"
+            raise ValueError(msg)
+        layers[layer] = [v] + layers.get(layer, [])
+
+    # Sort by layer, if possible
+    try:
+        layers = sorted(layers.items())
+    except TypeError:
+        layers = list(layers.items())
+
+    pos = None
+    nodes = []
+    width = len(layers)
+    for i, (_, layer) in enumerate(layers):
+        height = len(layer)
+        xs = np.repeat(i, height)
+        ys = np.arange(0, height, dtype=float)
+        offset = ((width - 1) / 2, (height - 1) / 2)
+        layer_pos = np.column_stack([xs, ys]) - offset
+        if pos is None:
+            pos = layer_pos
+        else:
+            pos = np.concatenate([pos, layer_pos])
+        nodes.extend(layer)
+    pos = rescale_layout(pos, scale=scale) + center
+    if align == "horizontal":
+        pos = pos[:, ::-1]  # swap x and y coords
+    pos = dict(zip(nodes, pos))
+    return pos
+
+
+def rescale_layout(pos, scale=1):
+    """Returns scaled position array to (-scale, scale) in all axes.
+
+    The function acts on NumPy arrays which hold position information.
+    Each position is one row of the array. The dimension of the space
+    equals the number of columns. Each coordinate in one column.
+
+    To rescale, the mean (center) is subtracted from each axis separately.
+    Then all values are scaled so that the largest magnitude value
+    from all axes equals `scale` (thus, the aspect ratio is preserved).
+    The resulting NumPy Array is returned (order of rows unchanged).
+
+    Parameters
+    ----------
+    pos : numpy array
+        positions to be scaled. Each row is a position.
+
+    scale : number (default: 1)
+        The size of the resulting extent in all directions.
+
+    Returns
+    -------
+    pos : numpy array
+        scaled positions. Each row is a position.
+
+    See Also
+    --------
+    rescale_layout_dict
+    """
+    # Find max length over all dimensions
+    lim = 0  # max coordinate for all axes
+    for i in range(pos.shape[1]):
+        pos[:, i] -= pos[:, i].mean()
+        lim = max(abs(pos[:, i]).max(), lim)
+    # rescale to (-scale, scale) in all directions, preserves aspect
+    if lim > 0:
+        for i in range(pos.shape[1]):
+            pos[:, i] *= scale / lim
+    return pos
+
+
+def rescale_layout_dict(pos, scale=1):
+    """Return a dictionary of scaled positions keyed by node
+
+    Parameters
+    ----------
+    pos : A dictionary of positions keyed by node
+
+    scale : number (default: 1)
+        The size of the resulting extent in all directions.
+
+    Returns
+    -------
+    pos : A dictionary of positions keyed by node
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> pos = {0: np.array((0, 0)), 1: np.array((1, 1)), 2: np.array((0.5, 0.5))}
+    >>> nx.rescale_layout_dict(pos)
+    {0: array([-1., -1.]), 1: array([1., 1.]), 2: array([0., 0.])}
+
+    >>> pos = {0: np.array((0, 0)), 1: np.array((-1, 1)), 2: np.array((-0.5, 0.5))}
+    >>> nx.rescale_layout_dict(pos, scale=2)
+    {0: array([ 2., -2.]), 1: array([-2.,  2.]), 2: array([0., 0.])}
+
+    See Also
+    --------
+    rescale_layout
+    """
+    import numpy as np
+
+    if not pos:  # empty_graph
+        return {}
+    pos_v = np.array(list(pos.values()))
+    pos_v = rescale_layout(pos_v, scale=scale)
+    return dict(zip(pos, pos_v))
diff --git a/myenv/lib/python3.9/site-packages/networkx/drawing/nx_agraph.py b/myenv/lib/python3.9/site-packages/networkx/drawing/nx_agraph.py
new file mode 100644
index 0000000..dc636b4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/drawing/nx_agraph.py
@@ -0,0 +1,495 @@
+"""
+***************
+Graphviz AGraph
+***************
+
+Interface to pygraphviz AGraph class.
+
+Examples
+--------
+>>> G = nx.complete_graph(5)
+>>> A = nx.nx_agraph.to_agraph(G)
+>>> H = nx.nx_agraph.from_agraph(A)
+
+See Also
+--------
+ - Pygraphviz: http://pygraphviz.github.io/
+ - Graphviz:      https://www.graphviz.org
+ - DOT Language:  http://www.graphviz.org/doc/info/lang.html
+"""
+import os
+import tempfile
+
+import networkx as nx
+
+__all__ = [
+    "from_agraph",
+    "to_agraph",
+    "write_dot",
+    "read_dot",
+    "graphviz_layout",
+    "pygraphviz_layout",
+    "view_pygraphviz",
+]
+
+
+def from_agraph(A, create_using=None):
+    """Returns a NetworkX Graph or DiGraph from a PyGraphviz graph.
+
+    Parameters
+    ----------
+    A : PyGraphviz AGraph
+      A graph created with PyGraphviz
+
+    create_using : NetworkX graph constructor, optional (default=None)
+       Graph type to create. If graph instance, then cleared before populated.
+       If `None`, then the appropriate Graph type is inferred from `A`.
+
+    Examples
+    --------
+    >>> K5 = nx.complete_graph(5)
+    >>> A = nx.nx_agraph.to_agraph(K5)
+    >>> G = nx.nx_agraph.from_agraph(A)
+
+    Notes
+    -----
+    The Graph G will have a dictionary G.graph_attr containing
+    the default graphviz attributes for graphs, nodes and edges.
+
+    Default node attributes will be in the dictionary G.node_attr
+    which is keyed by node.
+
+    Edge attributes will be returned as edge data in G.  With
+    edge_attr=False the edge data will be the Graphviz edge weight
+    attribute or the value 1 if no edge weight attribute is found.
+
+    """
+    if create_using is None:
+        if A.is_directed():
+            if A.is_strict():
+                create_using = nx.DiGraph
+            else:
+                create_using = nx.MultiDiGraph
+        else:
+            if A.is_strict():
+                create_using = nx.Graph
+            else:
+                create_using = nx.MultiGraph
+
+    # assign defaults
+    N = nx.empty_graph(0, create_using)
+    if A.name is not None:
+        N.name = A.name
+
+    # add graph attributes
+    N.graph.update(A.graph_attr)
+
+    # add nodes, attributes to N.node_attr
+    for n in A.nodes():
+        str_attr = {str(k): v for k, v in n.attr.items()}
+        N.add_node(str(n), **str_attr)
+
+    # add edges, assign edge data as dictionary of attributes
+    for e in A.edges():
+        u, v = str(e[0]), str(e[1])
+        attr = dict(e.attr)
+        str_attr = {str(k): v for k, v in attr.items()}
+        if not N.is_multigraph():
+            if e.name is not None:
+                str_attr["key"] = e.name
+            N.add_edge(u, v, **str_attr)
+        else:
+            N.add_edge(u, v, key=e.name, **str_attr)
+
+    # add default attributes for graph, nodes, and edges
+    # hang them on N.graph_attr
+    N.graph["graph"] = dict(A.graph_attr)
+    N.graph["node"] = dict(A.node_attr)
+    N.graph["edge"] = dict(A.edge_attr)
+    return N
+
+
+def to_agraph(N):
+    """Returns a pygraphviz graph from a NetworkX graph N.
+
+    Parameters
+    ----------
+    N : NetworkX graph
+      A graph created with NetworkX
+
+    Examples
+    --------
+    >>> K5 = nx.complete_graph(5)
+    >>> A = nx.nx_agraph.to_agraph(K5)
+
+    Notes
+    -----
+    If N has an dict N.graph_attr an attempt will be made first
+    to copy properties attached to the graph (see from_agraph)
+    and then updated with the calling arguments if any.
+
+    """
+    try:
+        import pygraphviz
+    except ImportError as err:
+        raise ImportError(
+            "requires pygraphviz " "http://pygraphviz.github.io/"
+        ) from err
+    directed = N.is_directed()
+    strict = nx.number_of_selfloops(N) == 0 and not N.is_multigraph()
+    A = pygraphviz.AGraph(name=N.name, strict=strict, directed=directed)
+
+    # default graph attributes
+    A.graph_attr.update(N.graph.get("graph", {}))
+    A.node_attr.update(N.graph.get("node", {}))
+    A.edge_attr.update(N.graph.get("edge", {}))
+
+    A.graph_attr.update(
+        (k, v) for k, v in N.graph.items() if k not in ("graph", "node", "edge")
+    )
+
+    # add nodes
+    for n, nodedata in N.nodes(data=True):
+        A.add_node(n)
+        # Add node data
+        a = A.get_node(n)
+        a.attr.update({k: str(v) for k, v in nodedata.items()})
+
+    # loop over edges
+    if N.is_multigraph():
+        for u, v, key, edgedata in N.edges(data=True, keys=True):
+            str_edgedata = {k: str(v) for k, v in edgedata.items() if k != "key"}
+            A.add_edge(u, v, key=str(key))
+            # Add edge data
+            a = A.get_edge(u, v)
+            a.attr.update(str_edgedata)
+
+    else:
+        for u, v, edgedata in N.edges(data=True):
+            str_edgedata = {k: str(v) for k, v in edgedata.items()}
+            A.add_edge(u, v)
+            # Add edge data
+            a = A.get_edge(u, v)
+            a.attr.update(str_edgedata)
+
+    return A
+
+
+def write_dot(G, path):
+    """Write NetworkX graph G to Graphviz dot format on path.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    path : filename
+       Filename or file handle to write
+    """
+    A = to_agraph(G)
+    A.write(path)
+    A.clear()
+    return
+
+
+def read_dot(path):
+    """Returns a NetworkX graph from a dot file on path.
+
+    Parameters
+    ----------
+    path : file or string
+       File name or file handle to read.
+    """
+    try:
+        import pygraphviz
+    except ImportError as err:
+        raise ImportError(
+            "read_dot() requires pygraphviz " "http://pygraphviz.github.io/"
+        ) from err
+    A = pygraphviz.AGraph(file=path)
+    gr = from_agraph(A)
+    A.clear()
+    return gr
+
+
+def graphviz_layout(G, prog="neato", root=None, args=""):
+    """Create node positions for G using Graphviz.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+      A graph created with NetworkX
+    prog : string
+      Name of Graphviz layout program
+    root : string, optional
+      Root node for twopi layout
+    args : string, optional
+      Extra arguments to Graphviz layout program
+
+    Returns
+    -------
+      Dictionary of x, y, positions keyed by node.
+
+    Examples
+    --------
+    >>> G = nx.petersen_graph()
+    >>> pos = nx.nx_agraph.graphviz_layout(G)
+    >>> pos = nx.nx_agraph.graphviz_layout(G, prog="dot")
+
+    Notes
+    -----
+    This is a wrapper for pygraphviz_layout.
+    """
+    return pygraphviz_layout(G, prog=prog, root=root, args=args)
+
+
+def pygraphviz_layout(G, prog="neato", root=None, args=""):
+    """Create node positions for G using Graphviz.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+      A graph created with NetworkX
+    prog : string
+      Name of Graphviz layout program
+    root : string, optional
+      Root node for twopi layout
+    args : string, optional
+      Extra arguments to Graphviz layout program
+
+    Returns
+    -------
+    node_pos : dict
+      Dictionary of x, y, positions keyed by node.
+
+    Examples
+    --------
+    >>> G = nx.petersen_graph()
+    >>> pos = nx.nx_agraph.graphviz_layout(G)
+    >>> pos = nx.nx_agraph.graphviz_layout(G, prog="dot")
+
+    Notes
+    -----
+    If you use complex node objects, they may have the same string
+    representation and GraphViz could treat them as the same node.
+    The layout may assign both nodes a single location. See Issue #1568
+    If this occurs in your case, consider relabeling the nodes just
+    for the layout computation using something similar to::
+
+        >>> H = nx.convert_node_labels_to_integers(G, label_attribute="node_label")
+        >>> H_layout = nx.nx_agraph.pygraphviz_layout(G, prog="dot")
+        >>> G_layout = {H.nodes[n]["node_label"]: p for n, p in H_layout.items()}
+
+    """
+    try:
+        import pygraphviz
+    except ImportError as err:
+        raise ImportError(
+            "requires pygraphviz " "http://pygraphviz.github.io/"
+        ) from err
+    if root is not None:
+        args += f"-Groot={root}"
+    A = to_agraph(G)
+    A.layout(prog=prog, args=args)
+    node_pos = {}
+    for n in G:
+        node = pygraphviz.Node(A, n)
+        try:
+            xs = node.attr["pos"].split(",")
+            node_pos[n] = tuple(float(x) for x in xs)
+        except:
+            print("no position for node", n)
+            node_pos[n] = (0.0, 0.0)
+    return node_pos
+
+
+@nx.utils.open_file(5, "w+b")
+def view_pygraphviz(
+    G, edgelabel=None, prog="dot", args="", suffix="", path=None, show=True
+):
+    """Views the graph G using the specified layout algorithm.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The machine to draw.
+    edgelabel : str, callable, None
+        If a string, then it specifes the edge attribute to be displayed
+        on the edge labels. If a callable, then it is called for each
+        edge and it should return the string to be displayed on the edges.
+        The function signature of `edgelabel` should be edgelabel(data),
+        where `data` is the edge attribute dictionary.
+    prog : string
+        Name of Graphviz layout program.
+    args : str
+        Additional arguments to pass to the Graphviz layout program.
+    suffix : str
+        If `filename` is None, we save to a temporary file.  The value of
+        `suffix` will appear at the tail end of the temporary filename.
+    path : str, None
+        The filename used to save the image.  If None, save to a temporary
+        file.  File formats are the same as those from pygraphviz.agraph.draw.
+    show : bool, default = True
+        Whether to display the graph with :mod:`PIL.Image.show`,
+        default is `True`. If `False`, the rendered graph is still available
+        at `path`.
+
+    Returns
+    -------
+    path : str
+        The filename of the generated image.
+    A : PyGraphviz graph
+        The PyGraphviz graph instance used to generate the image.
+
+    Notes
+    -----
+    If this function is called in succession too quickly, sometimes the
+    image is not displayed. So you might consider time.sleep(.5) between
+    calls if you experience problems.
+
+    """
+    if not len(G):
+        raise nx.NetworkXException("An empty graph cannot be drawn.")
+
+    # If we are providing default values for graphviz, these must be set
+    # before any nodes or edges are added to the PyGraphviz graph object.
+    # The reason for this is that default values only affect incoming objects.
+    # If you change the default values after the objects have been added,
+    # then they inherit no value and are set only if explicitly set.
+
+    # to_agraph() uses these values.
+    attrs = ["edge", "node", "graph"]
+    for attr in attrs:
+        if attr not in G.graph:
+            G.graph[attr] = {}
+
+    # These are the default values.
+    edge_attrs = {"fontsize": "10"}
+    node_attrs = {
+        "style": "filled",
+        "fillcolor": "#0000FF40",
+        "height": "0.75",
+        "width": "0.75",
+        "shape": "circle",
+    }
+    graph_attrs = {}
+
+    def update_attrs(which, attrs):
+        # Update graph attributes. Return list of those which were added.
+        added = []
+        for k, v in attrs.items():
+            if k not in G.graph[which]:
+                G.graph[which][k] = v
+                added.append(k)
+
+    def clean_attrs(which, added):
+        # Remove added attributes
+        for attr in added:
+            del G.graph[which][attr]
+        if not G.graph[which]:
+            del G.graph[which]
+
+    # Update all default values
+    update_attrs("edge", edge_attrs)
+    update_attrs("node", node_attrs)
+    update_attrs("graph", graph_attrs)
+
+    # Convert to agraph, so we inherit default values
+    A = to_agraph(G)
+
+    # Remove the default values we added to the original graph.
+    clean_attrs("edge", edge_attrs)
+    clean_attrs("node", node_attrs)
+    clean_attrs("graph", graph_attrs)
+
+    # If the user passed in an edgelabel, we update the labels for all edges.
+    if edgelabel is not None:
+        if not callable(edgelabel):
+
+            def func(data):
+                return "".join(["  ", str(data[edgelabel]), "  "])
+
+        else:
+            func = edgelabel
+
+        # update all the edge labels
+        if G.is_multigraph():
+            for u, v, key, data in G.edges(keys=True, data=True):
+                # PyGraphviz doesn't convert the key to a string. See #339
+                edge = A.get_edge(u, v, str(key))
+                edge.attr["label"] = str(func(data))
+        else:
+            for u, v, data in G.edges(data=True):
+                edge = A.get_edge(u, v)
+                edge.attr["label"] = str(func(data))
+
+    if path is None:
+        ext = "png"
+        if suffix:
+            suffix = f"_{suffix}.{ext}"
+        else:
+            suffix = f".{ext}"
+        path = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
+    else:
+        # Assume the decorator worked and it is a file-object.
+        pass
+
+    # Write graph to file
+    A.draw(path=path, format=None, prog=prog, args=args)
+    path.close()
+
+    # Show graph in a new window (depends on platform configuration)
+    if show:
+        from PIL import Image
+
+        Image.open(path.name).show()
+
+    return path.name, A
+
+
+def display_pygraphviz(graph, path, format=None, prog=None, args=""):
+    """Internal function to display a graph in OS dependent manner.
+
+    Parameters
+    ----------
+    graph : PyGraphviz graph
+        A PyGraphviz AGraph instance.
+    path :  file object
+        An already opened file object that will be closed.
+    format : str, None
+        An attempt is made to guess the output format based on the extension
+        of the filename. If that fails, the value of `format` is used.
+    prog : string
+        Name of Graphviz layout program.
+    args : str
+        Additional arguments to pass to the Graphviz layout program.
+
+    Notes
+    -----
+    If this function is called in succession too quickly, sometimes the
+    image is not displayed. So you might consider time.sleep(.5) between
+    calls if you experience problems.
+
+    """
+    import warnings
+
+    from PIL import Image
+
+    warnings.warn(
+        "display_pygraphviz is deprecated and will be removed in NetworkX 3.0. "
+        "To view a graph G using pygraphviz, use nx.nx_agraph.view_pygraphviz(G). "
+        "To view a graph from file, consider an image processing libary like "
+        "`Pillow`, e.g. ``PIL.Image.open(path.name).show()``",
+        DeprecationWarning,
+    )
+    if format is None:
+        filename = path.name
+        format = os.path.splitext(filename)[1].lower()[1:]
+    if not format:
+        # Let the draw() function use its default
+        format = None
+
+    # Save to a file and display in the default viewer.
+    # We must close the file before viewing it.
+    graph.draw(path, format, prog, args)
+    path.close()
+    Image.open(filename).show()
diff --git a/myenv/lib/python3.9/site-packages/networkx/drawing/nx_pydot.py b/myenv/lib/python3.9/site-packages/networkx/drawing/nx_pydot.py
new file mode 100644
index 0000000..2055eb3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/drawing/nx_pydot.py
@@ -0,0 +1,452 @@
+"""
+*****
+Pydot
+*****
+
+Import and export NetworkX graphs in Graphviz dot format using pydot.
+
+Either this module or nx_agraph can be used to interface with graphviz.
+
+Examples
+--------
+>>> G = nx.complete_graph(5)
+>>> PG = nx.nx_pydot.to_pydot(G)
+>>> H = nx.nx_pydot.from_pydot(PG)
+
+See Also
+--------
+ - pydot:         https://github.com/erocarrera/pydot
+ - Graphviz:      https://www.graphviz.org
+ - DOT Language:  http://www.graphviz.org/doc/info/lang.html
+"""
+import warnings
+from locale import getpreferredencoding
+
+import networkx as nx
+from networkx.utils import open_file
+
+__all__ = [
+    "write_dot",
+    "read_dot",
+    "graphviz_layout",
+    "pydot_layout",
+    "to_pydot",
+    "from_pydot",
+]
+
+
+@open_file(1, mode="w")
+def write_dot(G, path):
+    """Write NetworkX graph G to Graphviz dot format on path.
+
+    Path can be a string or a file handle.
+    """
+    msg = (
+        "nx.nx_pydot.write_dot depends on the pydot package, which has"
+        "known issues and is not actively maintained. Consider using"
+        "nx.nx_agraph.write_dot instead.\n\n"
+        "See https://github.com/networkx/networkx/issues/5723"
+    )
+    warnings.warn(msg, PendingDeprecationWarning, stacklevel=2)
+    P = to_pydot(G)
+    path.write(P.to_string())
+    return
+
+
+@open_file(0, mode="r")
+def read_dot(path):
+    """Returns a NetworkX :class:`MultiGraph` or :class:`MultiDiGraph` from the
+    dot file with the passed path.
+
+    If this file contains multiple graphs, only the first such graph is
+    returned. All graphs _except_ the first are silently ignored.
+
+    Parameters
+    ----------
+    path : str or file
+        Filename or file handle.
+
+    Returns
+    -------
+    G : MultiGraph or MultiDiGraph
+        A :class:`MultiGraph` or :class:`MultiDiGraph`.
+
+    Notes
+    -----
+    Use `G = nx.Graph(nx.nx_pydot.read_dot(path))` to return a :class:`Graph` instead of a
+    :class:`MultiGraph`.
+    """
+    import pydot
+
+    msg = (
+        "nx.nx_pydot.read_dot depends on the pydot package, which has"
+        "known issues and is not actively maintained. Consider using"
+        "nx.nx_agraph.read_dot instead.\n\n"
+        "See https://github.com/networkx/networkx/issues/5723"
+    )
+    warnings.warn(msg, PendingDeprecationWarning, stacklevel=2)
+
+    data = path.read()
+
+    # List of one or more "pydot.Dot" instances deserialized from this file.
+    P_list = pydot.graph_from_dot_data(data)
+
+    # Convert only the first such instance into a NetworkX graph.
+    return from_pydot(P_list[0])
+
+
+def from_pydot(P):
+    """Returns a NetworkX graph from a Pydot graph.
+
+    Parameters
+    ----------
+    P : Pydot graph
+      A graph created with Pydot
+
+    Returns
+    -------
+    G : NetworkX multigraph
+        A MultiGraph or MultiDiGraph.
+
+    Examples
+    --------
+    >>> K5 = nx.complete_graph(5)
+    >>> A = nx.nx_pydot.to_pydot(K5)
+    >>> G = nx.nx_pydot.from_pydot(A)  # return MultiGraph
+
+    # make a Graph instead of MultiGraph
+    >>> G = nx.Graph(nx.nx_pydot.from_pydot(A))
+
+    """
+    msg = (
+        "nx.nx_pydot.from_pydot depends on the pydot package, which has"
+        "known issues and is not actively maintained.\n\n"
+        "See https://github.com/networkx/networkx/issues/5723"
+    )
+    warnings.warn(msg, PendingDeprecationWarning, stacklevel=2)
+
+    if P.get_strict(None):  # pydot bug: get_strict() shouldn't take argument
+        multiedges = False
+    else:
+        multiedges = True
+
+    if P.get_type() == "graph":  # undirected
+        if multiedges:
+            N = nx.MultiGraph()
+        else:
+            N = nx.Graph()
+    else:
+        if multiedges:
+            N = nx.MultiDiGraph()
+        else:
+            N = nx.DiGraph()
+
+    # assign defaults
+    name = P.get_name().strip('"')
+    if name != "":
+        N.name = name
+
+    # add nodes, attributes to N.node_attr
+    for p in P.get_node_list():
+        n = p.get_name().strip('"')
+        if n in ("node", "graph", "edge"):
+            continue
+        N.add_node(n, **p.get_attributes())
+
+    # add edges
+    for e in P.get_edge_list():
+        u = e.get_source()
+        v = e.get_destination()
+        attr = e.get_attributes()
+        s = []
+        d = []
+
+        if isinstance(u, str):
+            s.append(u.strip('"'))
+        else:
+            for unodes in u["nodes"]:
+                s.append(unodes.strip('"'))
+
+        if isinstance(v, str):
+            d.append(v.strip('"'))
+        else:
+            for vnodes in v["nodes"]:
+                d.append(vnodes.strip('"'))
+
+        for source_node in s:
+            for destination_node in d:
+                N.add_edge(source_node, destination_node, **attr)
+
+    # add default attributes for graph, nodes, edges
+    pattr = P.get_attributes()
+    if pattr:
+        N.graph["graph"] = pattr
+    try:
+        N.graph["node"] = P.get_node_defaults()[0]
+    except (IndexError, TypeError):
+        pass  # N.graph['node']={}
+    try:
+        N.graph["edge"] = P.get_edge_defaults()[0]
+    except (IndexError, TypeError):
+        pass  # N.graph['edge']={}
+    return N
+
+
+def _check_colon_quotes(s):
+    # A quick helper function to check if a string has a colon in it
+    # and if it is quoted properly with double quotes.
+    # refer https://github.com/pydot/pydot/issues/258
+    return ":" in s and (s[0] != '"' or s[-1] != '"')
+
+
+def to_pydot(N):
+    """Returns a pydot graph from a NetworkX graph N.
+
+    Parameters
+    ----------
+    N : NetworkX graph
+      A graph created with NetworkX
+
+    Examples
+    --------
+    >>> K5 = nx.complete_graph(5)
+    >>> P = nx.nx_pydot.to_pydot(K5)
+
+    Notes
+    -----
+
+    """
+    import pydot
+
+    msg = (
+        "nx.nx_pydot.to_pydot depends on the pydot package, which has"
+        "known issues and is not actively maintained.\n\n"
+        "See https://github.com/networkx/networkx/issues/5723"
+    )
+    warnings.warn(msg, PendingDeprecationWarning, stacklevel=2)
+
+    # set Graphviz graph type
+    if N.is_directed():
+        graph_type = "digraph"
+    else:
+        graph_type = "graph"
+    strict = nx.number_of_selfloops(N) == 0 and not N.is_multigraph()
+
+    name = N.name
+    graph_defaults = N.graph.get("graph", {})
+    if name == "":
+        P = pydot.Dot("", graph_type=graph_type, strict=strict, **graph_defaults)
+    else:
+        P = pydot.Dot(
+            f'"{name}"', graph_type=graph_type, strict=strict, **graph_defaults
+        )
+    try:
+        P.set_node_defaults(**N.graph["node"])
+    except KeyError:
+        pass
+    try:
+        P.set_edge_defaults(**N.graph["edge"])
+    except KeyError:
+        pass
+
+    for n, nodedata in N.nodes(data=True):
+        str_nodedata = {str(k): str(v) for k, v in nodedata.items()}
+        # Explicitly catch nodes with ":" in node names or nodedata.
+        n = str(n)
+        raise_error = _check_colon_quotes(n) or (
+            any(
+                (_check_colon_quotes(k) or _check_colon_quotes(v))
+                for k, v in str_nodedata.items()
+            )
+        )
+        if raise_error:
+            raise ValueError(
+                f'Node names and attributes should not contain ":" unless they are quoted with "".\
+                For example the string \'attribute:data1\' should be written as \'"attribute:data1"\'.\
+                Please refer https://github.com/pydot/pydot/issues/258'
+            )
+        p = pydot.Node(n, **str_nodedata)
+        P.add_node(p)
+
+    if N.is_multigraph():
+        for u, v, key, edgedata in N.edges(data=True, keys=True):
+            str_edgedata = {str(k): str(v) for k, v in edgedata.items() if k != "key"}
+            u, v = str(u), str(v)
+            raise_error = (
+                _check_colon_quotes(u)
+                or _check_colon_quotes(v)
+                or (
+                    any(
+                        (_check_colon_quotes(k) or _check_colon_quotes(val))
+                        for k, val in str_edgedata.items()
+                    )
+                )
+            )
+            if raise_error:
+                raise ValueError(
+                    f'Node names and attributes should not contain ":" unless they are quoted with "".\
+                    For example the string \'attribute:data1\' should be written as \'"attribute:data1"\'.\
+                    Please refer https://github.com/pydot/pydot/issues/258'
+                )
+            edge = pydot.Edge(u, v, key=str(key), **str_edgedata)
+            P.add_edge(edge)
+
+    else:
+        for u, v, edgedata in N.edges(data=True):
+            str_edgedata = {str(k): str(v) for k, v in edgedata.items()}
+            u, v = str(u), str(v)
+            raise_error = (
+                _check_colon_quotes(u)
+                or _check_colon_quotes(v)
+                or (
+                    any(
+                        (_check_colon_quotes(k) or _check_colon_quotes(val))
+                        for k, val in str_edgedata.items()
+                    )
+                )
+            )
+            if raise_error:
+                raise ValueError(
+                    f'Node names and attributes should not contain ":" unless they are quoted with "".\
+                    For example the string \'attribute:data1\' should be written as \'"attribute:data1"\'.\
+                    Please refer https://github.com/pydot/pydot/issues/258'
+                )
+            edge = pydot.Edge(u, v, **str_edgedata)
+            P.add_edge(edge)
+    return P
+
+
+def graphviz_layout(G, prog="neato", root=None):
+    """Create node positions using Pydot and Graphviz.
+
+    Returns a dictionary of positions keyed by node.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        The graph for which the layout is computed.
+    prog : string (default: 'neato')
+        The name of the GraphViz program to use for layout.
+        Options depend on GraphViz version but may include:
+        'dot', 'twopi', 'fdp', 'sfdp', 'circo'
+    root : Node from G or None (default: None)
+        The node of G from which to start some layout algorithms.
+
+    Returns
+    -------
+      Dictionary of (x, y) positions keyed by node.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(4)
+    >>> pos = nx.nx_pydot.graphviz_layout(G)
+    >>> pos = nx.nx_pydot.graphviz_layout(G, prog="dot")
+
+    Notes
+    -----
+    This is a wrapper for pydot_layout.
+    """
+    msg = (
+        "nx.nx_pydot.graphviz_layout depends on the pydot package, which has"
+        "known issues and is not actively maintained. Consider using"
+        "nx.nx_agraph.graphviz_layout instead.\n\n"
+        "See https://github.com/networkx/networkx/issues/5723"
+    )
+    warnings.warn(msg, PendingDeprecationWarning, stacklevel=2)
+
+    return pydot_layout(G=G, prog=prog, root=root)
+
+
+def pydot_layout(G, prog="neato", root=None):
+    """Create node positions using :mod:`pydot` and Graphviz.
+
+    Parameters
+    ----------
+    G : Graph
+        NetworkX graph to be laid out.
+    prog : string  (default: 'neato')
+        Name of the GraphViz command to use for layout.
+        Options depend on GraphViz version but may include:
+        'dot', 'twopi', 'fdp', 'sfdp', 'circo'
+    root : Node from G or None (default: None)
+        The node of G from which to start some layout algorithms.
+
+    Returns
+    -------
+    dict
+        Dictionary of positions keyed by node.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(4)
+    >>> pos = nx.nx_pydot.pydot_layout(G)
+    >>> pos = nx.nx_pydot.pydot_layout(G, prog="dot")
+
+    Notes
+    -----
+    If you use complex node objects, they may have the same string
+    representation and GraphViz could treat them as the same node.
+    The layout may assign both nodes a single location. See Issue #1568
+    If this occurs in your case, consider relabeling the nodes just
+    for the layout computation using something similar to::
+
+        H = nx.convert_node_labels_to_integers(G, label_attribute='node_label')
+        H_layout = nx.nx_pydot.pydot_layout(G, prog='dot')
+        G_layout = {H.nodes[n]['node_label']: p for n, p in H_layout.items()}
+
+    """
+    import pydot
+
+    msg = (
+        "nx.nx_pydot.pydot_layout depends on the pydot package, which has"
+        "known issues and is not actively maintained.\n\n"
+        "See https://github.com/networkx/networkx/issues/5723"
+    )
+    warnings.warn(msg, PendingDeprecationWarning, stacklevel=2)
+    P = to_pydot(G)
+    if root is not None:
+        P.set("root", str(root))
+
+    # List of low-level bytes comprising a string in the dot language converted
+    # from the passed graph with the passed external GraphViz command.
+    D_bytes = P.create_dot(prog=prog)
+
+    # Unique string decoded from these bytes with the preferred locale encoding
+    D = str(D_bytes, encoding=getpreferredencoding())
+
+    if D == "":  # no data returned
+        print(f"Graphviz layout with {prog} failed")
+        print()
+        print("To debug what happened try:")
+        print("P = nx.nx_pydot.to_pydot(G)")
+        print('P.write_dot("file.dot")')
+        print(f"And then run {prog} on file.dot")
+        return
+
+    # List of one or more "pydot.Dot" instances deserialized from this string.
+    Q_list = pydot.graph_from_dot_data(D)
+    assert len(Q_list) == 1
+
+    # The first and only such instance, as guaranteed by the above assertion.
+    Q = Q_list[0]
+
+    node_pos = {}
+    for n in G.nodes():
+        str_n = str(n)
+        # Explicitly catch nodes with ":" in node names or nodedata.
+        if _check_colon_quotes(str_n):
+            raise ValueError(
+                f'Node names and node attributes should not contain ":" unless they are quoted with "".\
+                For example the string \'attribute:data1\' should be written as \'"attribute:data1"\'.\
+                Please refer https://github.com/pydot/pydot/issues/258'
+            )
+        pydot_node = pydot.Node(str_n).get_name()
+        node = Q.get_node(pydot_node)
+
+        if isinstance(node, list):
+            node = node[0]
+        pos = node.get_pos()[1:-1]  # strip leading and trailing double quotes
+        if pos is not None:
+            xx, yy = pos.split(",")
+            node_pos[n] = (float(xx), float(yy))
+    return node_pos
diff --git a/myenv/lib/python3.9/site-packages/networkx/drawing/nx_pylab.py b/myenv/lib/python3.9/site-packages/networkx/drawing/nx_pylab.py
new file mode 100644
index 0000000..18ce084
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/drawing/nx_pylab.py
@@ -0,0 +1,1517 @@
+"""
+**********
+Matplotlib
+**********
+
+Draw networks with matplotlib.
+
+Examples
+--------
+>>> G = nx.complete_graph(5)
+>>> nx.draw(G)
+
+See Also
+--------
+ - :doc:`matplotlib <matplotlib:index>`
+ - :func:`matplotlib.pyplot.scatter`
+ - :obj:`matplotlib.patches.FancyArrowPatch`
+"""
+from numbers import Number
+
+import networkx as nx
+from networkx.drawing.layout import (
+    circular_layout,
+    kamada_kawai_layout,
+    planar_layout,
+    random_layout,
+    shell_layout,
+    spectral_layout,
+    spring_layout,
+)
+
+__all__ = [
+    "draw",
+    "draw_networkx",
+    "draw_networkx_nodes",
+    "draw_networkx_edges",
+    "draw_networkx_labels",
+    "draw_networkx_edge_labels",
+    "draw_circular",
+    "draw_kamada_kawai",
+    "draw_random",
+    "draw_spectral",
+    "draw_spring",
+    "draw_planar",
+    "draw_shell",
+]
+
+
+def draw(G, pos=None, ax=None, **kwds):
+    """Draw the graph G with Matplotlib.
+
+    Draw the graph as a simple representation with no node
+    labels or edge labels and using the full Matplotlib figure area
+    and no axis labels by default.  See draw_networkx() for more
+    full-featured drawing that allows title, axis labels etc.
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    pos : dictionary, optional
+        A dictionary with nodes as keys and positions as values.
+        If not specified a spring layout positioning will be computed.
+        See :py:mod:`networkx.drawing.layout` for functions that
+        compute node positions.
+
+    ax : Matplotlib Axes object, optional
+        Draw the graph in specified Matplotlib axes.
+
+    kwds : optional keywords
+        See networkx.draw_networkx() for a description of optional keywords.
+
+    Examples
+    --------
+    >>> G = nx.dodecahedral_graph()
+    >>> nx.draw(G)
+    >>> nx.draw(G, pos=nx.spring_layout(G))  # use spring layout
+
+    See Also
+    --------
+    draw_networkx
+    draw_networkx_nodes
+    draw_networkx_edges
+    draw_networkx_labels
+    draw_networkx_edge_labels
+
+    Notes
+    -----
+    This function has the same name as pylab.draw and pyplot.draw
+    so beware when using `from networkx import *`
+
+    since you might overwrite the pylab.draw function.
+
+    With pyplot use
+
+    >>> import matplotlib.pyplot as plt
+    >>> G = nx.dodecahedral_graph()
+    >>> nx.draw(G)  # networkx draw()
+    >>> plt.draw()  # pyplot draw()
+
+    Also see the NetworkX drawing examples at
+    https://networkx.org/documentation/latest/auto_examples/index.html
+    """
+    import matplotlib.pyplot as plt
+
+    if ax is None:
+        cf = plt.gcf()
+    else:
+        cf = ax.get_figure()
+    cf.set_facecolor("w")
+    if ax is None:
+        if cf._axstack() is None:
+            ax = cf.add_axes((0, 0, 1, 1))
+        else:
+            ax = cf.gca()
+
+    if "with_labels" not in kwds:
+        kwds["with_labels"] = "labels" in kwds
+
+    draw_networkx(G, pos=pos, ax=ax, **kwds)
+    ax.set_axis_off()
+    plt.draw_if_interactive()
+    return
+
+
+def draw_networkx(G, pos=None, arrows=None, with_labels=True, **kwds):
+    r"""Draw the graph G using Matplotlib.
+
+    Draw the graph with Matplotlib with options for node positions,
+    labeling, titles, and many other drawing features.
+    See draw() for simple drawing without labels or axes.
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    pos : dictionary, optional
+        A dictionary with nodes as keys and positions as values.
+        If not specified a spring layout positioning will be computed.
+        See :py:mod:`networkx.drawing.layout` for functions that
+        compute node positions.
+
+    arrows : bool or None, optional (default=None)
+        If `None`, directed graphs draw arrowheads with
+        `~matplotlib.patches.FancyArrowPatch`, while undirected graphs draw edges
+        via `~matplotlib.collections.LineCollection` for speed.
+        If `True`, draw arrowheads with FancyArrowPatches (bendable and stylish).
+        If `False`, draw edges using LineCollection (linear and fast).
+        For directed graphs, if True draw arrowheads.
+        Note: Arrows will be the same color as edges.
+
+    arrowstyle : str (default='-\|>' for directed graphs)
+        For directed graphs, choose the style of the arrowsheads.
+        For undirected graphs default to '-'
+
+        See `matplotlib.patches.ArrowStyle` for more options.
+
+    arrowsize : int or list (default=10)
+        For directed graphs, choose the size of the arrow head's length and
+        width. A list of values can be passed in to assign a different size for arrow head's length and width.
+        See `matplotlib.patches.FancyArrowPatch` for attribute `mutation_scale`
+        for more info.
+
+    with_labels :  bool (default=True)
+        Set to True to draw labels on the nodes.
+
+    ax : Matplotlib Axes object, optional
+        Draw the graph in the specified Matplotlib axes.
+
+    nodelist : list (default=list(G))
+        Draw only specified nodes
+
+    edgelist : list (default=list(G.edges()))
+        Draw only specified edges
+
+    node_size : scalar or array (default=300)
+        Size of nodes.  If an array is specified it must be the
+        same length as nodelist.
+
+    node_color : color or array of colors (default='#1f78b4')
+        Node color. Can be a single color or a sequence of colors with the same
+        length as nodelist. Color can be string or rgb (or rgba) tuple of
+        floats from 0-1. If numeric values are specified they will be
+        mapped to colors using the cmap and vmin,vmax parameters. See
+        matplotlib.scatter for more details.
+
+    node_shape :  string (default='o')
+        The shape of the node.  Specification is as matplotlib.scatter
+        marker, one of 'so^>v<dph8'.
+
+    alpha : float or None (default=None)
+        The node and edge transparency
+
+    cmap : Matplotlib colormap, optional
+        Colormap for mapping intensities of nodes
+
+    vmin,vmax : float, optional
+        Minimum and maximum for node colormap scaling
+
+    linewidths : scalar or sequence (default=1.0)
+        Line width of symbol border
+
+    width : float or array of floats (default=1.0)
+        Line width of edges
+
+    edge_color : color or array of colors (default='k')
+        Edge color. Can be a single color or a sequence of colors with the same
+        length as edgelist. Color can be string or rgb (or rgba) tuple of
+        floats from 0-1. If numeric values are specified they will be
+        mapped to colors using the edge_cmap and edge_vmin,edge_vmax parameters.
+
+    edge_cmap : Matplotlib colormap, optional
+        Colormap for mapping intensities of edges
+
+    edge_vmin,edge_vmax : floats, optional
+        Minimum and maximum for edge colormap scaling
+
+    style : string (default=solid line)
+        Edge line style e.g.: '-', '--', '-.', ':'
+        or words like 'solid' or 'dashed'.
+        (See `matplotlib.patches.FancyArrowPatch`: `linestyle`)
+
+    labels : dictionary (default=None)
+        Node labels in a dictionary of text labels keyed by node
+
+    font_size : int (default=12 for nodes, 10 for edges)
+        Font size for text labels
+
+    font_color : string (default='k' black)
+        Font color string
+
+    font_weight : string (default='normal')
+        Font weight
+
+    font_family : string (default='sans-serif')
+        Font family
+
+    label : string, optional
+        Label for graph legend
+
+    kwds : optional keywords
+        See networkx.draw_networkx_nodes(), networkx.draw_networkx_edges(), and
+        networkx.draw_networkx_labels() for a description of optional keywords.
+
+    Notes
+    -----
+    For directed graphs, arrows  are drawn at the head end.  Arrows can be
+    turned off with keyword arrows=False.
+
+    Examples
+    --------
+    >>> G = nx.dodecahedral_graph()
+    >>> nx.draw(G)
+    >>> nx.draw(G, pos=nx.spring_layout(G))  # use spring layout
+
+    >>> import matplotlib.pyplot as plt
+    >>> limits = plt.axis("off")  # turn off axis
+
+    Also see the NetworkX drawing examples at
+    https://networkx.org/documentation/latest/auto_examples/index.html
+
+    See Also
+    --------
+    draw
+    draw_networkx_nodes
+    draw_networkx_edges
+    draw_networkx_labels
+    draw_networkx_edge_labels
+    """
+    from inspect import signature
+
+    import matplotlib.pyplot as plt
+
+    # Get all valid keywords by inspecting the signatures of draw_networkx_nodes,
+    # draw_networkx_edges, draw_networkx_labels
+
+    valid_node_kwds = signature(draw_networkx_nodes).parameters.keys()
+    valid_edge_kwds = signature(draw_networkx_edges).parameters.keys()
+    valid_label_kwds = signature(draw_networkx_labels).parameters.keys()
+
+    # Create a set with all valid keywords across the three functions and
+    # remove the arguments of this function (draw_networkx)
+    valid_kwds = (valid_node_kwds | valid_edge_kwds | valid_label_kwds) - {
+        "G",
+        "pos",
+        "arrows",
+        "with_labels",
+    }
+
+    if any([k not in valid_kwds for k in kwds]):
+        invalid_args = ", ".join([k for k in kwds if k not in valid_kwds])
+        raise ValueError(f"Received invalid argument(s): {invalid_args}")
+
+    node_kwds = {k: v for k, v in kwds.items() if k in valid_node_kwds}
+    edge_kwds = {k: v for k, v in kwds.items() if k in valid_edge_kwds}
+    label_kwds = {k: v for k, v in kwds.items() if k in valid_label_kwds}
+
+    if pos is None:
+        pos = nx.drawing.spring_layout(G)  # default to spring layout
+
+    draw_networkx_nodes(G, pos, **node_kwds)
+    draw_networkx_edges(G, pos, arrows=arrows, **edge_kwds)
+    if with_labels:
+        draw_networkx_labels(G, pos, **label_kwds)
+    plt.draw_if_interactive()
+
+
+def draw_networkx_nodes(
+    G,
+    pos,
+    nodelist=None,
+    node_size=300,
+    node_color="#1f78b4",
+    node_shape="o",
+    alpha=None,
+    cmap=None,
+    vmin=None,
+    vmax=None,
+    ax=None,
+    linewidths=None,
+    edgecolors=None,
+    label=None,
+    margins=None,
+):
+    """Draw the nodes of the graph G.
+
+    This draws only the nodes of the graph G.
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    pos : dictionary
+        A dictionary with nodes as keys and positions as values.
+        Positions should be sequences of length 2.
+
+    ax : Matplotlib Axes object, optional
+        Draw the graph in the specified Matplotlib axes.
+
+    nodelist : list (default list(G))
+        Draw only specified nodes
+
+    node_size : scalar or array (default=300)
+        Size of nodes.  If an array it must be the same length as nodelist.
+
+    node_color : color or array of colors (default='#1f78b4')
+        Node color. Can be a single color or a sequence of colors with the same
+        length as nodelist. Color can be string or rgb (or rgba) tuple of
+        floats from 0-1. If numeric values are specified they will be
+        mapped to colors using the cmap and vmin,vmax parameters. See
+        matplotlib.scatter for more details.
+
+    node_shape :  string (default='o')
+        The shape of the node.  Specification is as matplotlib.scatter
+        marker, one of 'so^>v<dph8'.
+
+    alpha : float or array of floats (default=None)
+        The node transparency.  This can be a single alpha value,
+        in which case it will be applied to all the nodes of color. Otherwise,
+        if it is an array, the elements of alpha will be applied to the colors
+        in order (cycling through alpha multiple times if necessary).
+
+    cmap : Matplotlib colormap (default=None)
+        Colormap for mapping intensities of nodes
+
+    vmin,vmax : floats or None (default=None)
+        Minimum and maximum for node colormap scaling
+
+    linewidths : [None | scalar | sequence] (default=1.0)
+        Line width of symbol border
+
+    edgecolors : [None | scalar | sequence] (default = node_color)
+        Colors of node borders
+
+    label : [None | string]
+        Label for legend
+
+    margins : float or 2-tuple, optional
+        Sets the padding for axis autoscaling. Increase margin to prevent
+        clipping for nodes that are near the edges of an image. Values should
+        be in the range ``[0, 1]``. See :meth:`matplotlib.axes.Axes.margins`
+        for details. The default is `None`, which uses the Matplotlib default.
+
+    Returns
+    -------
+    matplotlib.collections.PathCollection
+        `PathCollection` of the nodes.
+
+    Examples
+    --------
+    >>> G = nx.dodecahedral_graph()
+    >>> nodes = nx.draw_networkx_nodes(G, pos=nx.spring_layout(G))
+
+    Also see the NetworkX drawing examples at
+    https://networkx.org/documentation/latest/auto_examples/index.html
+
+    See Also
+    --------
+    draw
+    draw_networkx
+    draw_networkx_edges
+    draw_networkx_labels
+    draw_networkx_edge_labels
+    """
+    from collections.abc import Iterable
+
+    import matplotlib as mpl
+    import matplotlib.collections  # call as mpl.collections
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    if ax is None:
+        ax = plt.gca()
+
+    if nodelist is None:
+        nodelist = list(G)
+
+    if len(nodelist) == 0:  # empty nodelist, no drawing
+        return mpl.collections.PathCollection(None)
+
+    try:
+        xy = np.asarray([pos[v] for v in nodelist])
+    except KeyError as err:
+        raise nx.NetworkXError(f"Node {err} has no position.") from err
+
+    if isinstance(alpha, Iterable):
+        node_color = apply_alpha(node_color, alpha, nodelist, cmap, vmin, vmax)
+        alpha = None
+
+    node_collection = ax.scatter(
+        xy[:, 0],
+        xy[:, 1],
+        s=node_size,
+        c=node_color,
+        marker=node_shape,
+        cmap=cmap,
+        vmin=vmin,
+        vmax=vmax,
+        alpha=alpha,
+        linewidths=linewidths,
+        edgecolors=edgecolors,
+        label=label,
+    )
+    ax.tick_params(
+        axis="both",
+        which="both",
+        bottom=False,
+        left=False,
+        labelbottom=False,
+        labelleft=False,
+    )
+
+    if margins is not None:
+        if isinstance(margins, Iterable):
+            ax.margins(*margins)
+        else:
+            ax.margins(margins)
+
+    node_collection.set_zorder(2)
+    return node_collection
+
+
+def draw_networkx_edges(
+    G,
+    pos,
+    edgelist=None,
+    width=1.0,
+    edge_color="k",
+    style="solid",
+    alpha=None,
+    arrowstyle=None,
+    arrowsize=10,
+    edge_cmap=None,
+    edge_vmin=None,
+    edge_vmax=None,
+    ax=None,
+    arrows=None,
+    label=None,
+    node_size=300,
+    nodelist=None,
+    node_shape="o",
+    connectionstyle="arc3",
+    min_source_margin=0,
+    min_target_margin=0,
+):
+    r"""Draw the edges of the graph G.
+
+    This draws only the edges of the graph G.
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    pos : dictionary
+        A dictionary with nodes as keys and positions as values.
+        Positions should be sequences of length 2.
+
+    edgelist : collection of edge tuples (default=G.edges())
+        Draw only specified edges
+
+    width : float or array of floats (default=1.0)
+        Line width of edges
+
+    edge_color : color or array of colors (default='k')
+        Edge color. Can be a single color or a sequence of colors with the same
+        length as edgelist. Color can be string or rgb (or rgba) tuple of
+        floats from 0-1. If numeric values are specified they will be
+        mapped to colors using the edge_cmap and edge_vmin,edge_vmax parameters.
+
+    style : string or array of strings (default='solid')
+        Edge line style e.g.: '-', '--', '-.', ':'
+        or words like 'solid' or 'dashed'.
+        Can be a single style or a sequence of styles with the same
+        length as the edge list.
+        If less styles than edges are given the styles will cycle.
+        If more styles than edges are given the styles will be used sequentially
+        and not be exhausted.
+        Also, `(offset, onoffseq)` tuples can be used as style instead of a strings.
+        (See `matplotlib.patches.FancyArrowPatch`: `linestyle`)
+
+    alpha : float or None (default=None)
+        The edge transparency
+
+    edge_cmap : Matplotlib colormap, optional
+        Colormap for mapping intensities of edges
+
+    edge_vmin,edge_vmax : floats, optional
+        Minimum and maximum for edge colormap scaling
+
+    ax : Matplotlib Axes object, optional
+        Draw the graph in the specified Matplotlib axes.
+
+    arrows : bool or None, optional (default=None)
+        If `None`, directed graphs draw arrowheads with
+        `~matplotlib.patches.FancyArrowPatch`, while undirected graphs draw edges
+        via `~matplotlib.collections.LineCollection` for speed.
+        If `True`, draw arrowheads with FancyArrowPatches (bendable and stylish).
+        If `False`, draw edges using LineCollection (linear and fast).
+
+        Note: Arrowheads will be the same color as edges.
+
+    arrowstyle : str (default='-\|>' for directed graphs)
+        For directed graphs and `arrows==True` defaults to '-\|>',
+        For undirected graphs default to '-'.
+
+        See `matplotlib.patches.ArrowStyle` for more options.
+
+    arrowsize : int (default=10)
+        For directed graphs, choose the size of the arrow head's length and
+        width. See `matplotlib.patches.FancyArrowPatch` for attribute
+        `mutation_scale` for more info.
+
+    connectionstyle : string (default="arc3")
+        Pass the connectionstyle parameter to create curved arc of rounding
+        radius rad. For example, connectionstyle='arc3,rad=0.2'.
+        See `matplotlib.patches.ConnectionStyle` and
+        `matplotlib.patches.FancyArrowPatch` for more info.
+
+    node_size : scalar or array (default=300)
+        Size of nodes. Though the nodes are not drawn with this function, the
+        node size is used in determining edge positioning.
+
+    nodelist : list, optional (default=G.nodes())
+       This provides the node order for the `node_size` array (if it is an array).
+
+    node_shape :  string (default='o')
+        The marker used for nodes, used in determining edge positioning.
+        Specification is as a `matplotlib.markers` marker, e.g. one of 'so^>v<dph8'.
+
+    label : None or string
+        Label for legend
+
+    min_source_margin : int (default=0)
+        The minimum margin (gap) at the begining of the edge at the source.
+
+    min_target_margin : int (default=0)
+        The minimum margin (gap) at the end of the edge at the target.
+
+    Returns
+    -------
+     matplotlib.colections.LineCollection or a list of matplotlib.patches.FancyArrowPatch
+        If ``arrows=True``, a list of FancyArrowPatches is returned.
+        If ``arrows=False``, a LineCollection is returned.
+        If ``arrows=None`` (the default), then a LineCollection is returned if
+        `G` is undirected, otherwise returns a list of FancyArrowPatches.
+
+    Notes
+    -----
+    For directed graphs, arrows are drawn at the head end.  Arrows can be
+    turned off with keyword arrows=False or by passing an arrowstyle without
+    an arrow on the end.
+
+    Be sure to include `node_size` as a keyword argument; arrows are
+    drawn considering the size of nodes.
+
+    Self-loops are always drawn with `~matplotlib.patches.FancyArrowPatch`
+    regardless of the value of `arrows` or whether `G` is directed.
+    When ``arrows=False`` or ``arrows=None`` and `G` is undirected, the
+    FancyArrowPatches corresponding to the self-loops are not explicitly
+    returned. They should instead be accessed via the ``Axes.patches``
+    attribute (see examples).
+
+    Examples
+    --------
+    >>> G = nx.dodecahedral_graph()
+    >>> edges = nx.draw_networkx_edges(G, pos=nx.spring_layout(G))
+
+    >>> G = nx.DiGraph()
+    >>> G.add_edges_from([(1, 2), (1, 3), (2, 3)])
+    >>> arcs = nx.draw_networkx_edges(G, pos=nx.spring_layout(G))
+    >>> alphas = [0.3, 0.4, 0.5]
+    >>> for i, arc in enumerate(arcs):  # change alpha values of arcs
+    ...     arc.set_alpha(alphas[i])
+
+    The FancyArrowPatches corresponding to self-loops are not always
+    returned, but can always be accessed via the ``patches`` attribute of the
+    `matplotlib.Axes` object.
+
+    >>> import matplotlib.pyplot as plt
+    >>> fig, ax = plt.subplots()
+    >>> G = nx.Graph([(0, 1), (0, 0)])  # Self-loop at node 0
+    >>> edge_collection = nx.draw_networkx_edges(G, pos=nx.circular_layout(G), ax=ax)
+    >>> self_loop_fap = ax.patches[0]
+
+    Also see the NetworkX drawing examples at
+    https://networkx.org/documentation/latest/auto_examples/index.html
+
+    See Also
+    --------
+    draw
+    draw_networkx
+    draw_networkx_nodes
+    draw_networkx_labels
+    draw_networkx_edge_labels
+
+    """
+    import matplotlib as mpl
+    import matplotlib.collections  # call as mpl.collections
+    import matplotlib.colors  # call as mpl.colors
+    import matplotlib.patches  # call as mpl.patches
+    import matplotlib.path  # call as mpl.path
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    # The default behavior is to use LineCollection to draw edges for
+    # undirected graphs (for performance reasons) and use FancyArrowPatches
+    # for directed graphs.
+    # The `arrows` keyword can be used to override the default behavior
+
+    if arrowstyle == None:
+        if G.is_directed():
+            arrowstyle = "-|>"
+        else:
+            arrowstyle = "-"
+
+    use_linecollection = not G.is_directed()
+    if arrows in (True, False):
+        use_linecollection = not arrows
+
+    if ax is None:
+        ax = plt.gca()
+
+    if edgelist is None:
+        edgelist = list(G.edges())
+
+    if len(edgelist) == 0:  # no edges!
+        return []
+
+    if nodelist is None:
+        nodelist = list(G.nodes())
+
+    # FancyArrowPatch handles color=None different from LineCollection
+    if edge_color is None:
+        edge_color = "k"
+    edgelist_tuple = list(map(tuple, edgelist))
+
+    # set edge positions
+    edge_pos = np.asarray([(pos[e[0]], pos[e[1]]) for e in edgelist])
+
+    # Check if edge_color is an array of floats and map to edge_cmap.
+    # This is the only case handled differently from matplotlib
+    if (
+        np.iterable(edge_color)
+        and (len(edge_color) == len(edge_pos))
+        and np.alltrue([isinstance(c, Number) for c in edge_color])
+    ):
+        if edge_cmap is not None:
+            assert isinstance(edge_cmap, mpl.colors.Colormap)
+        else:
+            edge_cmap = plt.get_cmap()
+        if edge_vmin is None:
+            edge_vmin = min(edge_color)
+        if edge_vmax is None:
+            edge_vmax = max(edge_color)
+        color_normal = mpl.colors.Normalize(vmin=edge_vmin, vmax=edge_vmax)
+        edge_color = [edge_cmap(color_normal(e)) for e in edge_color]
+
+    def _draw_networkx_edges_line_collection():
+        edge_collection = mpl.collections.LineCollection(
+            edge_pos,
+            colors=edge_color,
+            linewidths=width,
+            antialiaseds=(1,),
+            linestyle=style,
+            alpha=alpha,
+        )
+        edge_collection.set_cmap(edge_cmap)
+        edge_collection.set_clim(edge_vmin, edge_vmax)
+        edge_collection.set_zorder(1)  # edges go behind nodes
+        edge_collection.set_label(label)
+        ax.add_collection(edge_collection)
+
+        return edge_collection
+
+    def _draw_networkx_edges_fancy_arrow_patch():
+        # Note: Waiting for someone to implement arrow to intersection with
+        # marker.  Meanwhile, this works well for polygons with more than 4
+        # sides and circle.
+
+        def to_marker_edge(marker_size, marker):
+            if marker in "s^>v<d":  # `large` markers need extra space
+                return np.sqrt(2 * marker_size) / 2
+            else:
+                return np.sqrt(marker_size) / 2
+
+        # Draw arrows with `matplotlib.patches.FancyarrowPatch`
+        arrow_collection = []
+
+        if isinstance(arrowsize, list):
+            if len(arrowsize) != len(edge_pos):
+                raise ValueError("arrowsize should have the same length as edgelist")
+        else:
+            mutation_scale = arrowsize  # scale factor of arrow head
+
+        base_connection_style = mpl.patches.ConnectionStyle(connectionstyle)
+
+        # Fallback for self-loop scale. Left outside of _connectionstyle so it is
+        # only computed once
+        max_nodesize = np.array(node_size).max()
+
+        def _connectionstyle(posA, posB, *args, **kwargs):
+            # check if we need to do a self-loop
+            if np.all(posA == posB):
+                # Self-loops are scaled by view extent, except in cases the extent
+                # is 0, e.g. for a single node. In this case, fall back to scaling
+                # by the maximum node size
+                selfloop_ht = 0.005 * max_nodesize if h == 0 else h
+                # this is called with _screen space_ values so covert back
+                # to data space
+                data_loc = ax.transData.inverted().transform(posA)
+                v_shift = 0.1 * selfloop_ht
+                h_shift = v_shift * 0.5
+                # put the top of the loop first so arrow is not hidden by node
+                path = [
+                    # 1
+                    data_loc + np.asarray([0, v_shift]),
+                    # 4 4 4
+                    data_loc + np.asarray([h_shift, v_shift]),
+                    data_loc + np.asarray([h_shift, 0]),
+                    data_loc,
+                    # 4 4 4
+                    data_loc + np.asarray([-h_shift, 0]),
+                    data_loc + np.asarray([-h_shift, v_shift]),
+                    data_loc + np.asarray([0, v_shift]),
+                ]
+
+                ret = mpl.path.Path(ax.transData.transform(path), [1, 4, 4, 4, 4, 4, 4])
+            # if not, fall back to the user specified behavior
+            else:
+                ret = base_connection_style(posA, posB, *args, **kwargs)
+
+            return ret
+
+        # FancyArrowPatch doesn't handle color strings
+        arrow_colors = mpl.colors.colorConverter.to_rgba_array(edge_color, alpha)
+        for i, (src, dst) in zip(fancy_edges_indices, edge_pos):
+            x1, y1 = src
+            x2, y2 = dst
+            shrink_source = 0  # space from source to tail
+            shrink_target = 0  # space from  head to target
+
+            if isinstance(arrowsize, list):
+                # Scale each factor of each arrow based on arrowsize list
+                mutation_scale = arrowsize[i]
+
+            if np.iterable(node_size):  # many node sizes
+                source, target = edgelist[i][:2]
+                source_node_size = node_size[nodelist.index(source)]
+                target_node_size = node_size[nodelist.index(target)]
+                shrink_source = to_marker_edge(source_node_size, node_shape)
+                shrink_target = to_marker_edge(target_node_size, node_shape)
+            else:
+                shrink_source = shrink_target = to_marker_edge(node_size, node_shape)
+
+            if shrink_source < min_source_margin:
+                shrink_source = min_source_margin
+
+            if shrink_target < min_target_margin:
+                shrink_target = min_target_margin
+
+            if len(arrow_colors) > i:
+                arrow_color = arrow_colors[i]
+            elif len(arrow_colors) == 1:
+                arrow_color = arrow_colors[0]
+            else:  # Cycle through colors
+                arrow_color = arrow_colors[i % len(arrow_colors)]
+
+            if np.iterable(width):
+                if len(width) > i:
+                    line_width = width[i]
+                else:
+                    line_width = width[i % len(width)]
+            else:
+                line_width = width
+
+            if (
+                np.iterable(style)
+                and not isinstance(style, str)
+                and not isinstance(style, tuple)
+            ):
+                if len(style) > i:
+                    linestyle = style[i]
+                else:  # Cycle through styles
+                    linestyle = style[i % len(style)]
+            else:
+                linestyle = style
+
+            arrow = mpl.patches.FancyArrowPatch(
+                (x1, y1),
+                (x2, y2),
+                arrowstyle=arrowstyle,
+                shrinkA=shrink_source,
+                shrinkB=shrink_target,
+                mutation_scale=mutation_scale,
+                color=arrow_color,
+                linewidth=line_width,
+                connectionstyle=_connectionstyle,
+                linestyle=linestyle,
+                zorder=1,
+            )  # arrows go behind nodes
+
+            arrow_collection.append(arrow)
+            ax.add_patch(arrow)
+
+        return arrow_collection
+
+    # compute initial view
+    minx = np.amin(np.ravel(edge_pos[:, :, 0]))
+    maxx = np.amax(np.ravel(edge_pos[:, :, 0]))
+    miny = np.amin(np.ravel(edge_pos[:, :, 1]))
+    maxy = np.amax(np.ravel(edge_pos[:, :, 1]))
+    w = maxx - minx
+    h = maxy - miny
+
+    # Draw the edges
+    if use_linecollection:
+        edge_viz_obj = _draw_networkx_edges_line_collection()
+        # Make sure selfloop edges are also drawn
+        selfloops_to_draw = [loop for loop in nx.selfloop_edges(G) if loop in edgelist]
+        if selfloops_to_draw:
+            fancy_edges_indices = [
+                edgelist_tuple.index(loop) for loop in selfloops_to_draw
+            ]
+            edge_pos = np.asarray([(pos[e[0]], pos[e[1]]) for e in selfloops_to_draw])
+            arrowstyle = "-"
+            _draw_networkx_edges_fancy_arrow_patch()
+    else:
+        fancy_edges_indices = range(len(edgelist))
+        edge_viz_obj = _draw_networkx_edges_fancy_arrow_patch()
+
+    # update view after drawing
+    padx, pady = 0.05 * w, 0.05 * h
+    corners = (minx - padx, miny - pady), (maxx + padx, maxy + pady)
+    ax.update_datalim(corners)
+    ax.autoscale_view()
+
+    ax.tick_params(
+        axis="both",
+        which="both",
+        bottom=False,
+        left=False,
+        labelbottom=False,
+        labelleft=False,
+    )
+
+    return edge_viz_obj
+
+
+def draw_networkx_labels(
+    G,
+    pos,
+    labels=None,
+    font_size=12,
+    font_color="k",
+    font_family="sans-serif",
+    font_weight="normal",
+    alpha=None,
+    bbox=None,
+    horizontalalignment="center",
+    verticalalignment="center",
+    ax=None,
+    clip_on=True,
+):
+    """Draw node labels on the graph G.
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    pos : dictionary
+        A dictionary with nodes as keys and positions as values.
+        Positions should be sequences of length 2.
+
+    labels : dictionary (default={n: n for n in G})
+        Node labels in a dictionary of text labels keyed by node.
+        Node-keys in labels should appear as keys in `pos`.
+        If needed use: `{n:lab for n,lab in labels.items() if n in pos}`
+
+    font_size : int (default=12)
+        Font size for text labels
+
+    font_color : string (default='k' black)
+        Font color string
+
+    font_weight : string (default='normal')
+        Font weight
+
+    font_family : string (default='sans-serif')
+        Font family
+
+    alpha : float or None (default=None)
+        The text transparency
+
+    bbox : Matplotlib bbox, (default is Matplotlib's ax.text default)
+        Specify text box properties (e.g. shape, color etc.) for node labels.
+
+    horizontalalignment : string (default='center')
+        Horizontal alignment {'center', 'right', 'left'}
+
+    verticalalignment : string (default='center')
+        Vertical alignment {'center', 'top', 'bottom', 'baseline', 'center_baseline'}
+
+    ax : Matplotlib Axes object, optional
+        Draw the graph in the specified Matplotlib axes.
+
+    clip_on : bool (default=True)
+        Turn on clipping of node labels at axis boundaries
+
+    Returns
+    -------
+    dict
+        `dict` of labels keyed on the nodes
+
+    Examples
+    --------
+    >>> G = nx.dodecahedral_graph()
+    >>> labels = nx.draw_networkx_labels(G, pos=nx.spring_layout(G))
+
+    Also see the NetworkX drawing examples at
+    https://networkx.org/documentation/latest/auto_examples/index.html
+
+    See Also
+    --------
+    draw
+    draw_networkx
+    draw_networkx_nodes
+    draw_networkx_edges
+    draw_networkx_edge_labels
+    """
+    import matplotlib.pyplot as plt
+
+    if ax is None:
+        ax = plt.gca()
+
+    if labels is None:
+        labels = {n: n for n in G.nodes()}
+
+    text_items = {}  # there is no text collection so we'll fake one
+    for n, label in labels.items():
+        (x, y) = pos[n]
+        if not isinstance(label, str):
+            label = str(label)  # this makes "1" and 1 labeled the same
+        t = ax.text(
+            x,
+            y,
+            label,
+            size=font_size,
+            color=font_color,
+            family=font_family,
+            weight=font_weight,
+            alpha=alpha,
+            horizontalalignment=horizontalalignment,
+            verticalalignment=verticalalignment,
+            transform=ax.transData,
+            bbox=bbox,
+            clip_on=clip_on,
+        )
+        text_items[n] = t
+
+    ax.tick_params(
+        axis="both",
+        which="both",
+        bottom=False,
+        left=False,
+        labelbottom=False,
+        labelleft=False,
+    )
+
+    return text_items
+
+
+def draw_networkx_edge_labels(
+    G,
+    pos,
+    edge_labels=None,
+    label_pos=0.5,
+    font_size=10,
+    font_color="k",
+    font_family="sans-serif",
+    font_weight="normal",
+    alpha=None,
+    bbox=None,
+    horizontalalignment="center",
+    verticalalignment="center",
+    ax=None,
+    rotate=True,
+    clip_on=True,
+):
+    """Draw edge labels.
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    pos : dictionary
+        A dictionary with nodes as keys and positions as values.
+        Positions should be sequences of length 2.
+
+    edge_labels : dictionary (default=None)
+        Edge labels in a dictionary of labels keyed by edge two-tuple.
+        Only labels for the keys in the dictionary are drawn.
+
+    label_pos : float (default=0.5)
+        Position of edge label along edge (0=head, 0.5=center, 1=tail)
+
+    font_size : int (default=10)
+        Font size for text labels
+
+    font_color : string (default='k' black)
+        Font color string
+
+    font_weight : string (default='normal')
+        Font weight
+
+    font_family : string (default='sans-serif')
+        Font family
+
+    alpha : float or None (default=None)
+        The text transparency
+
+    bbox : Matplotlib bbox, optional
+        Specify text box properties (e.g. shape, color etc.) for edge labels.
+        Default is {boxstyle='round', ec=(1.0, 1.0, 1.0), fc=(1.0, 1.0, 1.0)}.
+
+    horizontalalignment : string (default='center')
+        Horizontal alignment {'center', 'right', 'left'}
+
+    verticalalignment : string (default='center')
+        Vertical alignment {'center', 'top', 'bottom', 'baseline', 'center_baseline'}
+
+    ax : Matplotlib Axes object, optional
+        Draw the graph in the specified Matplotlib axes.
+
+    rotate : bool (deafult=True)
+        Rotate edge labels to lie parallel to edges
+
+    clip_on : bool (default=True)
+        Turn on clipping of edge labels at axis boundaries
+
+    Returns
+    -------
+    dict
+        `dict` of labels keyed by edge
+
+    Examples
+    --------
+    >>> G = nx.dodecahedral_graph()
+    >>> edge_labels = nx.draw_networkx_edge_labels(G, pos=nx.spring_layout(G))
+
+    Also see the NetworkX drawing examples at
+    https://networkx.org/documentation/latest/auto_examples/index.html
+
+    See Also
+    --------
+    draw
+    draw_networkx
+    draw_networkx_nodes
+    draw_networkx_edges
+    draw_networkx_labels
+    """
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    if ax is None:
+        ax = plt.gca()
+    if edge_labels is None:
+        labels = {(u, v): d for u, v, d in G.edges(data=True)}
+    else:
+        labels = edge_labels
+        # Informative exception for multiedges
+        try:
+            (u, v) = next(iter(labels))  # ensures no edge key provided
+        except ValueError as err:
+            raise nx.NetworkXError(
+                "draw_networkx_edge_labels does not support multiedges."
+            ) from err
+        except StopIteration:
+            pass
+
+    text_items = {}
+    for (n1, n2), label in labels.items():
+        (x1, y1) = pos[n1]
+        (x2, y2) = pos[n2]
+        (x, y) = (
+            x1 * label_pos + x2 * (1.0 - label_pos),
+            y1 * label_pos + y2 * (1.0 - label_pos),
+        )
+
+        if rotate:
+            # in degrees
+            angle = np.arctan2(y2 - y1, x2 - x1) / (2.0 * np.pi) * 360
+            # make label orientation "right-side-up"
+            if angle > 90:
+                angle -= 180
+            if angle < -90:
+                angle += 180
+            # transform data coordinate angle to screen coordinate angle
+            xy = np.array((x, y))
+            trans_angle = ax.transData.transform_angles(
+                np.array((angle,)), xy.reshape((1, 2))
+            )[0]
+        else:
+            trans_angle = 0.0
+        # use default box of white with white border
+        if bbox is None:
+            bbox = dict(boxstyle="round", ec=(1.0, 1.0, 1.0), fc=(1.0, 1.0, 1.0))
+        if not isinstance(label, str):
+            label = str(label)  # this makes "1" and 1 labeled the same
+
+        t = ax.text(
+            x,
+            y,
+            label,
+            size=font_size,
+            color=font_color,
+            family=font_family,
+            weight=font_weight,
+            alpha=alpha,
+            horizontalalignment=horizontalalignment,
+            verticalalignment=verticalalignment,
+            rotation=trans_angle,
+            transform=ax.transData,
+            bbox=bbox,
+            zorder=1,
+            clip_on=clip_on,
+        )
+        text_items[(n1, n2)] = t
+
+    ax.tick_params(
+        axis="both",
+        which="both",
+        bottom=False,
+        left=False,
+        labelbottom=False,
+        labelleft=False,
+    )
+
+    return text_items
+
+
+def draw_circular(G, **kwargs):
+    """Draw the graph `G` with a circular layout.
+
+    This is a convenience function equivalent to::
+
+        nx.draw(G, pos=nx.circular_layout(G), **kwargs)
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    kwargs : optional keywords
+        See `draw_networkx` for a description of optional keywords.
+
+    Notes
+    -----
+    The layout is computed each time this function is called. For
+    repeated drawing it is much more efficient to call
+    `~networkx.drawing.layout.circular_layout` directly and reuse the result::
+
+        >>> G = nx.complete_graph(5)
+        >>> pos = nx.circular_layout(G)
+        >>> nx.draw(G, pos=pos)  # Draw the original graph
+        >>> # Draw a subgraph, reusing the same node positions
+        >>> nx.draw(G.subgraph([0, 1, 2]), pos=pos, node_color="red")
+
+    See Also
+    --------
+    :func:`~networkx.drawing.layout.circular_layout`
+    """
+    draw(G, circular_layout(G), **kwargs)
+
+
+def draw_kamada_kawai(G, **kwargs):
+    """Draw the graph `G` with a Kamada-Kawai force-directed layout.
+
+    This is a convenience function equivalent to::
+
+        nx.draw(G, pos=nx.kamada_kawai_layout(G), **kwargs)
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    kwargs : optional keywords
+        See `draw_networkx` for a description of optional keywords.
+
+    Notes
+    -----
+    The layout is computed each time this function is called.
+    For repeated drawing it is much more efficient to call
+    `~networkx.drawing.layout.kamada_kawai_layout` directly and reuse the
+    result::
+
+        >>> G = nx.complete_graph(5)
+        >>> pos = nx.kamada_kawai_layout(G)
+        >>> nx.draw(G, pos=pos)  # Draw the original graph
+        >>> # Draw a subgraph, reusing the same node positions
+        >>> nx.draw(G.subgraph([0, 1, 2]), pos=pos, node_color="red")
+
+    See Also
+    --------
+    :func:`~networkx.drawing.layout.kamada_kawai_layout`
+    """
+    draw(G, kamada_kawai_layout(G), **kwargs)
+
+
+def draw_random(G, **kwargs):
+    """Draw the graph `G` with a random layout.
+
+    This is a convenience function equivalent to::
+
+        nx.draw(G, pos=nx.random_layout(G), **kwargs)
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    kwargs : optional keywords
+        See `draw_networkx` for a description of optional keywords.
+
+    Notes
+    -----
+    The layout is computed each time this function is called.
+    For repeated drawing it is much more efficient to call
+    `~networkx.drawing.layout.random_layout` directly and reuse the result::
+
+        >>> G = nx.complete_graph(5)
+        >>> pos = nx.random_layout(G)
+        >>> nx.draw(G, pos=pos)  # Draw the original graph
+        >>> # Draw a subgraph, reusing the same node positions
+        >>> nx.draw(G.subgraph([0, 1, 2]), pos=pos, node_color="red")
+
+    See Also
+    --------
+    :func:`~networkx.drawing.layout.random_layout`
+    """
+    draw(G, random_layout(G), **kwargs)
+
+
+def draw_spectral(G, **kwargs):
+    """Draw the graph `G` with a spectral 2D layout.
+
+    This is a convenience function equivalent to::
+
+        nx.draw(G, pos=nx.spectral_layout(G), **kwargs)
+
+    For more information about how node positions are determined, see
+    `~networkx.drawing.layout.spectral_layout`.
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    kwargs : optional keywords
+        See `draw_networkx` for a description of optional keywords.
+
+    Notes
+    -----
+    The layout is computed each time this function is called.
+    For repeated drawing it is much more efficient to call
+    `~networkx.drawing.layout.spectral_layout` directly and reuse the result::
+
+        >>> G = nx.complete_graph(5)
+        >>> pos = nx.spectral_layout(G)
+        >>> nx.draw(G, pos=pos)  # Draw the original graph
+        >>> # Draw a subgraph, reusing the same node positions
+        >>> nx.draw(G.subgraph([0, 1, 2]), pos=pos, node_color="red")
+
+    See Also
+    --------
+    :func:`~networkx.drawing.layout.spectral_layout`
+    """
+    draw(G, spectral_layout(G), **kwargs)
+
+
+def draw_spring(G, **kwargs):
+    """Draw the graph `G` with a spring layout.
+
+    This is a convenience function equivalent to::
+
+        nx.draw(G, pos=nx.spring_layout(G), **kwargs)
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    kwargs : optional keywords
+        See `draw_networkx` for a description of optional keywords.
+
+    Notes
+    -----
+    `~networkx.drawing.layout.spring_layout` is also the default layout for
+    `draw`, so this function is equivalent to `draw`.
+
+    The layout is computed each time this function is called.
+    For repeated drawing it is much more efficient to call
+    `~networkx.drawing.layout.spring_layout` directly and reuse the result::
+
+        >>> G = nx.complete_graph(5)
+        >>> pos = nx.spring_layout(G)
+        >>> nx.draw(G, pos=pos)  # Draw the original graph
+        >>> # Draw a subgraph, reusing the same node positions
+        >>> nx.draw(G.subgraph([0, 1, 2]), pos=pos, node_color="red")
+
+    See Also
+    --------
+    draw
+    :func:`~networkx.drawing.layout.spring_layout`
+    """
+    draw(G, spring_layout(G), **kwargs)
+
+
+def draw_shell(G, nlist=None, **kwargs):
+    """Draw networkx graph `G` with shell layout.
+
+    This is a convenience function equivalent to::
+
+        nx.draw(G, pos=nx.shell_layout(G, nlist=nlist), **kwargs)
+
+    Parameters
+    ----------
+    G : graph
+        A networkx graph
+
+    nlist : list of list of nodes, optional
+        A list containing lists of nodes representing the shells.
+        Default is `None`, meaning all nodes are in a single shell.
+        See `~networkx.drawing.layout.shell_layout` for details.
+
+    kwargs : optional keywords
+        See `draw_networkx` for a description of optional keywords.
+
+    Notes
+    -----
+    The layout is computed each time this function is called.
+    For repeated drawing it is much more efficient to call
+    `~networkx.drawing.layout.shell_layout` directly and reuse the result::
+
+        >>> G = nx.complete_graph(5)
+        >>> pos = nx.shell_layout(G)
+        >>> nx.draw(G, pos=pos)  # Draw the original graph
+        >>> # Draw a subgraph, reusing the same node positions
+        >>> nx.draw(G.subgraph([0, 1, 2]), pos=pos, node_color="red")
+
+    See Also
+    --------
+    :func:`~networkx.drawing.layout.shell_layout`
+    """
+    draw(G, shell_layout(G, nlist=nlist), **kwargs)
+
+
+def draw_planar(G, **kwargs):
+    """Draw a planar networkx graph `G` with planar layout.
+
+    This is a convenience function equivalent to::
+
+        nx.draw(G, pos=nx.planar_layout(G), **kwargs)
+
+    Parameters
+    ----------
+    G : graph
+        A planar networkx graph
+
+    kwargs : optional keywords
+        See `draw_networkx` for a description of optional keywords.
+
+    Raises
+    ------
+    NetworkXException
+        When `G` is not planar
+
+    Notes
+    -----
+    The layout is computed each time this function is called.
+    For repeated drawing it is much more efficient to call
+    `~networkx.drawing.layout.planar_layout` directly and reuse the result::
+
+        >>> G = nx.path_graph(5)
+        >>> pos = nx.planar_layout(G)
+        >>> nx.draw(G, pos=pos)  # Draw the original graph
+        >>> # Draw a subgraph, reusing the same node positions
+        >>> nx.draw(G.subgraph([0, 1, 2]), pos=pos, node_color="red")
+
+    See Also
+    --------
+    :func:`~networkx.drawing.layout.planar_layout`
+    """
+    draw(G, planar_layout(G), **kwargs)
+
+
+def apply_alpha(colors, alpha, elem_list, cmap=None, vmin=None, vmax=None):
+    """Apply an alpha (or list of alphas) to the colors provided.
+
+    Parameters
+    ----------
+
+    colors : color string or array of floats (default='r')
+        Color of element. Can be a single color format string,
+        or a sequence of colors with the same length as nodelist.
+        If numeric values are specified they will be mapped to
+        colors using the cmap and vmin,vmax parameters.  See
+        matplotlib.scatter for more details.
+
+    alpha : float or array of floats
+        Alpha values for elements. This can be a single alpha value, in
+        which case it will be applied to all the elements of color. Otherwise,
+        if it is an array, the elements of alpha will be applied to the colors
+        in order (cycling through alpha multiple times if necessary).
+
+    elem_list : array of networkx objects
+        The list of elements which are being colored. These could be nodes,
+        edges or labels.
+
+    cmap : matplotlib colormap
+        Color map for use if colors is a list of floats corresponding to points
+        on a color mapping.
+
+    vmin, vmax : float
+        Minimum and maximum values for normalizing colors if a colormap is used
+
+    Returns
+    -------
+
+    rgba_colors : numpy ndarray
+        Array containing RGBA format values for each of the node colours.
+
+    """
+    from itertools import cycle, islice
+
+    import matplotlib as mpl
+    import matplotlib.cm  # call as mpl.cm
+    import matplotlib.colors  # call as mpl.colors
+    import numpy as np
+
+    # If we have been provided with a list of numbers as long as elem_list,
+    # apply the color mapping.
+    if len(colors) == len(elem_list) and isinstance(colors[0], Number):
+        mapper = mpl.cm.ScalarMappable(cmap=cmap)
+        mapper.set_clim(vmin, vmax)
+        rgba_colors = mapper.to_rgba(colors)
+    # Otherwise, convert colors to matplotlib's RGB using the colorConverter
+    # object.  These are converted to numpy ndarrays to be consistent with the
+    # to_rgba method of ScalarMappable.
+    else:
+        try:
+            rgba_colors = np.array([mpl.colors.colorConverter.to_rgba(colors)])
+        except ValueError:
+            rgba_colors = np.array(
+                [mpl.colors.colorConverter.to_rgba(color) for color in colors]
+            )
+    # Set the final column of the rgba_colors to have the relevant alpha values
+    try:
+        # If alpha is longer than the number of colors, resize to the number of
+        # elements.  Also, if rgba_colors.size (the number of elements of
+        # rgba_colors) is the same as the number of elements, resize the array,
+        # to avoid it being interpreted as a colormap by scatter()
+        if len(alpha) > len(rgba_colors) or rgba_colors.size == len(elem_list):
+            rgba_colors = np.resize(rgba_colors, (len(elem_list), 4))
+            rgba_colors[1:, 0] = rgba_colors[0, 0]
+            rgba_colors[1:, 1] = rgba_colors[0, 1]
+            rgba_colors[1:, 2] = rgba_colors[0, 2]
+        rgba_colors[:, 3] = list(islice(cycle(alpha), len(rgba_colors)))
+    except TypeError:
+        rgba_colors[:, -1] = alpha
+    return rgba_colors
diff --git a/myenv/lib/python3.9/site-packages/networkx/drawing/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/drawing/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/drawing/tests/baseline/test_house_with_colors.png b/myenv/lib/python3.9/site-packages/networkx/drawing/tests/baseline/test_house_with_colors.png
new file mode 100644
index 0000000..31f4962
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/networkx/drawing/tests/baseline/test_house_with_colors.png differ
diff --git a/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_agraph.py b/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_agraph.py
new file mode 100644
index 0000000..c99d29f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_agraph.py
@@ -0,0 +1,242 @@
+"""Unit tests for PyGraphviz interface."""
+import os
+import tempfile
+
+import pytest
+
+pygraphviz = pytest.importorskip("pygraphviz")
+
+
+import networkx as nx
+from networkx.utils import edges_equal, graphs_equal, nodes_equal
+
+
+class TestAGraph:
+    def build_graph(self, G):
+        edges = [("A", "B"), ("A", "C"), ("A", "C"), ("B", "C"), ("A", "D")]
+        G.add_edges_from(edges)
+        G.add_node("E")
+        G.graph["metal"] = "bronze"
+        return G
+
+    def assert_equal(self, G1, G2):
+        assert nodes_equal(G1.nodes(), G2.nodes())
+        assert edges_equal(G1.edges(), G2.edges())
+        assert G1.graph["metal"] == G2.graph["metal"]
+
+    def agraph_checks(self, G):
+        G = self.build_graph(G)
+        A = nx.nx_agraph.to_agraph(G)
+        H = nx.nx_agraph.from_agraph(A)
+        self.assert_equal(G, H)
+
+        fd, fname = tempfile.mkstemp()
+        nx.drawing.nx_agraph.write_dot(H, fname)
+        Hin = nx.nx_agraph.read_dot(fname)
+        self.assert_equal(H, Hin)
+        os.close(fd)
+        os.unlink(fname)
+
+        (fd, fname) = tempfile.mkstemp()
+        with open(fname, "w") as fh:
+            nx.drawing.nx_agraph.write_dot(H, fh)
+
+        with open(fname) as fh:
+            Hin = nx.nx_agraph.read_dot(fh)
+        os.close(fd)
+        os.unlink(fname)
+        self.assert_equal(H, Hin)
+
+    def test_from_agraph_name(self):
+        G = nx.Graph(name="test")
+        A = nx.nx_agraph.to_agraph(G)
+        H = nx.nx_agraph.from_agraph(A)
+        assert G.name == "test"
+
+    @pytest.mark.parametrize(
+        "graph_class", (nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph)
+    )
+    def test_from_agraph_create_using(self, graph_class):
+        G = nx.path_graph(3)
+        A = nx.nx_agraph.to_agraph(G)
+        H = nx.nx_agraph.from_agraph(A, create_using=graph_class)
+        assert isinstance(H, graph_class)
+
+    def test_from_agraph_named_edges(self):
+        # Create an AGraph from an existing (non-multi) Graph
+        G = nx.Graph()
+        G.add_nodes_from([0, 1])
+        A = nx.nx_agraph.to_agraph(G)
+        # Add edge (+ name, given by key) to the AGraph
+        A.add_edge(0, 1, key="foo")
+        # Verify a.name roundtrips out to 'key' in from_agraph
+        H = nx.nx_agraph.from_agraph(A)
+        assert isinstance(H, nx.Graph)
+        assert ("0", "1", {"key": "foo"}) in H.edges(data=True)
+
+    def test_undirected(self):
+        self.agraph_checks(nx.Graph())
+
+    def test_directed(self):
+        self.agraph_checks(nx.DiGraph())
+
+    def test_multi_undirected(self):
+        self.agraph_checks(nx.MultiGraph())
+
+    def test_multi_directed(self):
+        self.agraph_checks(nx.MultiDiGraph())
+
+    def test_to_agraph_with_nodedata(self):
+        G = nx.Graph()
+        G.add_node(1, color="red")
+        A = nx.nx_agraph.to_agraph(G)
+        assert dict(A.nodes()[0].attr) == {"color": "red"}
+
+    @pytest.mark.parametrize("graph_class", (nx.Graph, nx.MultiGraph))
+    def test_to_agraph_with_edgedata(self, graph_class):
+        G = graph_class()
+        G.add_nodes_from([0, 1])
+        G.add_edge(0, 1, color="yellow")
+        A = nx.nx_agraph.to_agraph(G)
+        assert dict(A.edges()[0].attr) == {"color": "yellow"}
+
+    def test_view_pygraphviz_path(self, tmp_path):
+        G = nx.complete_graph(3)
+        input_path = str(tmp_path / "graph.png")
+        out_path, A = nx.nx_agraph.view_pygraphviz(G, path=input_path, show=False)
+        assert out_path == input_path
+        # Ensure file is not empty
+        with open(input_path, "rb") as fh:
+            data = fh.read()
+        assert len(data) > 0
+
+    def test_view_pygraphviz_file_suffix(self, tmp_path):
+        G = nx.complete_graph(3)
+        path, A = nx.nx_agraph.view_pygraphviz(G, suffix=1, show=False)
+        assert path[-6:] == "_1.png"
+
+    def test_view_pygraphviz(self):
+        G = nx.Graph()  # "An empty graph cannot be drawn."
+        pytest.raises(nx.NetworkXException, nx.nx_agraph.view_pygraphviz, G)
+        G = nx.barbell_graph(4, 6)
+        nx.nx_agraph.view_pygraphviz(G, show=False)
+
+    def test_view_pygraphviz_edgelabel(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=7)
+        G.add_edge(2, 3, weight=8)
+        path, A = nx.nx_agraph.view_pygraphviz(G, edgelabel="weight", show=False)
+        for edge in A.edges():
+            assert edge.attr["weight"] in ("7", "8")
+
+    def test_view_pygraphviz_callable_edgelabel(self):
+        G = nx.complete_graph(3)
+
+        def foo_label(data):
+            return "foo"
+
+        path, A = nx.nx_agraph.view_pygraphviz(G, edgelabel=foo_label, show=False)
+        for edge in A.edges():
+            assert edge.attr["label"] == "foo"
+
+    def test_view_pygraphviz_multigraph_edgelabels(self):
+        G = nx.MultiGraph()
+        G.add_edge(0, 1, key=0, name="left_fork")
+        G.add_edge(0, 1, key=1, name="right_fork")
+        path, A = nx.nx_agraph.view_pygraphviz(G, edgelabel="name", show=False)
+        edges = A.edges()
+        assert len(edges) == 2
+        for edge in edges:
+            assert edge.attr["label"].strip() in ("left_fork", "right_fork")
+
+    def test_graph_with_reserved_keywords(self):
+        # test attribute/keyword clash case for #1582
+        # node: n
+        # edges: u,v
+        G = nx.Graph()
+        G = self.build_graph(G)
+        G.nodes["E"]["n"] = "keyword"
+        G.edges[("A", "B")]["u"] = "keyword"
+        G.edges[("A", "B")]["v"] = "keyword"
+        A = nx.nx_agraph.to_agraph(G)
+
+    def test_view_pygraphviz_no_added_attrs_to_input(self):
+        G = nx.complete_graph(2)
+        path, A = nx.nx_agraph.view_pygraphviz(G, show=False)
+        assert G.graph == {}
+
+    @pytest.mark.xfail(reason="known bug in clean_attrs")
+    def test_view_pygraphviz_leaves_input_graph_unmodified(self):
+        G = nx.complete_graph(2)
+        # Add entries to graph dict that to_agraph handles specially
+        G.graph["node"] = {"width": "0.80"}
+        G.graph["edge"] = {"fontsize": "14"}
+        path, A = nx.nx_agraph.view_pygraphviz(G, show=False)
+        assert G.graph == {"node": {"width": "0.80"}, "edge": {"fontsize": "14"}}
+
+    def test_graph_with_AGraph_attrs(self):
+        G = nx.complete_graph(2)
+        # Add entries to graph dict that to_agraph handles specially
+        G.graph["node"] = {"width": "0.80"}
+        G.graph["edge"] = {"fontsize": "14"}
+        path, A = nx.nx_agraph.view_pygraphviz(G, show=False)
+        # Ensure user-specified values are not lost
+        assert dict(A.node_attr)["width"] == "0.80"
+        assert dict(A.edge_attr)["fontsize"] == "14"
+
+    def test_round_trip_empty_graph(self):
+        G = nx.Graph()
+        A = nx.nx_agraph.to_agraph(G)
+        H = nx.nx_agraph.from_agraph(A)
+        # assert graphs_equal(G, H)
+        AA = nx.nx_agraph.to_agraph(H)
+        HH = nx.nx_agraph.from_agraph(AA)
+        assert graphs_equal(H, HH)
+        G.graph["graph"] = {}
+        G.graph["node"] = {}
+        G.graph["edge"] = {}
+        assert graphs_equal(G, HH)
+
+    @pytest.mark.xfail(reason="integer->string node conversion in round trip")
+    def test_round_trip_integer_nodes(self):
+        G = nx.complete_graph(3)
+        A = nx.nx_agraph.to_agraph(G)
+        H = nx.nx_agraph.from_agraph(A)
+        assert graphs_equal(G, H)
+
+    def test_graphviz_alias(self):
+        G = self.build_graph(nx.Graph())
+        pos_graphviz = nx.nx_agraph.graphviz_layout(G)
+        pos_pygraphviz = nx.nx_agraph.pygraphviz_layout(G)
+        assert pos_graphviz == pos_pygraphviz
+
+    @pytest.mark.parametrize("root", range(5))
+    def test_pygraphviz_layout_root(self, root):
+        # NOTE: test depends on layout prog being deterministic
+        G = nx.complete_graph(5)
+        A = nx.nx_agraph.to_agraph(G)
+        # Get layout with root arg is not None
+        pygv_layout = nx.nx_agraph.pygraphviz_layout(G, prog="circo", root=root)
+        # Equivalent layout directly on AGraph
+        A.layout(args=f"-Groot={root}", prog="circo")
+        # Parse AGraph layout
+        a1_pos = tuple(float(v) for v in dict(A.get_node("1").attr)["pos"].split(","))
+        assert pygv_layout[1] == a1_pos
+
+    def test_2d_layout(self):
+        G = nx.Graph()
+        G = self.build_graph(G)
+        G.graph["dimen"] = 2
+        pos = nx.nx_agraph.pygraphviz_layout(G, prog="neato")
+        pos = list(pos.values())
+        assert len(pos) == 5
+        assert len(pos[0]) == 2
+
+    def test_3d_layout(self):
+        G = nx.Graph()
+        G = self.build_graph(G)
+        G.graph["dimen"] = 3
+        pos = nx.nx_agraph.pygraphviz_layout(G, prog="neato")
+        pos = list(pos.values())
+        assert len(pos) == 5
+        assert len(pos[0]) == 3
diff --git a/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_layout.py b/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_layout.py
new file mode 100644
index 0000000..f24d003
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_layout.py
@@ -0,0 +1,445 @@
+"""Unit tests for layout functions."""
+import pytest
+
+import networkx as nx
+
+np = pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+
+class TestLayout:
+    @classmethod
+    def setup_class(cls):
+        cls.Gi = nx.grid_2d_graph(5, 5)
+        cls.Gs = nx.Graph()
+        nx.add_path(cls.Gs, "abcdef")
+        cls.bigG = nx.grid_2d_graph(25, 25)  # > 500 nodes for sparse
+
+    def test_spring_fixed_without_pos(self):
+        G = nx.path_graph(4)
+        pytest.raises(ValueError, nx.spring_layout, G, fixed=[0])
+        pos = {0: (1, 1), 2: (0, 0)}
+        pytest.raises(ValueError, nx.spring_layout, G, fixed=[0, 1], pos=pos)
+        nx.spring_layout(G, fixed=[0, 2], pos=pos)  # No ValueError
+
+    def test_spring_init_pos(self):
+        # Tests GH #2448
+        import math
+
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (1, 2), (2, 0), (2, 3)])
+
+        init_pos = {0: (0.0, 0.0)}
+        fixed_pos = [0]
+        pos = nx.fruchterman_reingold_layout(G, pos=init_pos, fixed=fixed_pos)
+        has_nan = any(math.isnan(c) for coords in pos.values() for c in coords)
+        assert not has_nan, "values should not be nan"
+
+    def test_smoke_empty_graph(self):
+        G = []
+        nx.random_layout(G)
+        nx.circular_layout(G)
+        nx.planar_layout(G)
+        nx.spring_layout(G)
+        nx.fruchterman_reingold_layout(G)
+        nx.spectral_layout(G)
+        nx.shell_layout(G)
+        nx.bipartite_layout(G, G)
+        nx.spiral_layout(G)
+        nx.multipartite_layout(G)
+        nx.kamada_kawai_layout(G)
+
+    def test_smoke_int(self):
+        G = self.Gi
+        nx.random_layout(G)
+        nx.circular_layout(G)
+        nx.planar_layout(G)
+        nx.spring_layout(G)
+        nx.fruchterman_reingold_layout(G)
+        nx.fruchterman_reingold_layout(self.bigG)
+        nx.spectral_layout(G)
+        nx.spectral_layout(G.to_directed())
+        nx.spectral_layout(self.bigG)
+        nx.spectral_layout(self.bigG.to_directed())
+        nx.shell_layout(G)
+        nx.spiral_layout(G)
+        nx.kamada_kawai_layout(G)
+        nx.kamada_kawai_layout(G, dim=1)
+        nx.kamada_kawai_layout(G, dim=3)
+
+    def test_smoke_string(self):
+        G = self.Gs
+        nx.random_layout(G)
+        nx.circular_layout(G)
+        nx.planar_layout(G)
+        nx.spring_layout(G)
+        nx.fruchterman_reingold_layout(G)
+        nx.spectral_layout(G)
+        nx.shell_layout(G)
+        nx.spiral_layout(G)
+        nx.kamada_kawai_layout(G)
+        nx.kamada_kawai_layout(G, dim=1)
+        nx.kamada_kawai_layout(G, dim=3)
+
+    def check_scale_and_center(self, pos, scale, center):
+        center = np.array(center)
+        low = center - scale
+        hi = center + scale
+        vpos = np.array(list(pos.values()))
+        length = vpos.max(0) - vpos.min(0)
+        assert (length <= 2 * scale).all()
+        assert (vpos >= low).all()
+        assert (vpos <= hi).all()
+
+    def test_scale_and_center_arg(self):
+        sc = self.check_scale_and_center
+        c = (4, 5)
+        G = nx.complete_graph(9)
+        G.add_node(9)
+        sc(nx.random_layout(G, center=c), scale=0.5, center=(4.5, 5.5))
+        # rest can have 2*scale length: [-scale, scale]
+        sc(nx.spring_layout(G, scale=2, center=c), scale=2, center=c)
+        sc(nx.spectral_layout(G, scale=2, center=c), scale=2, center=c)
+        sc(nx.circular_layout(G, scale=2, center=c), scale=2, center=c)
+        sc(nx.shell_layout(G, scale=2, center=c), scale=2, center=c)
+        sc(nx.spiral_layout(G, scale=2, center=c), scale=2, center=c)
+        sc(nx.kamada_kawai_layout(G, scale=2, center=c), scale=2, center=c)
+
+        c = (2, 3, 5)
+        sc(nx.kamada_kawai_layout(G, dim=3, scale=2, center=c), scale=2, center=c)
+
+    def test_planar_layout_non_planar_input(self):
+        G = nx.complete_graph(9)
+        pytest.raises(nx.NetworkXException, nx.planar_layout, G)
+
+    def test_smoke_planar_layout_embedding_input(self):
+        embedding = nx.PlanarEmbedding()
+        embedding.set_data({0: [1, 2], 1: [0, 2], 2: [0, 1]})
+        nx.planar_layout(embedding)
+
+    def test_default_scale_and_center(self):
+        sc = self.check_scale_and_center
+        c = (0, 0)
+        G = nx.complete_graph(9)
+        G.add_node(9)
+        sc(nx.random_layout(G), scale=0.5, center=(0.5, 0.5))
+        sc(nx.spring_layout(G), scale=1, center=c)
+        sc(nx.spectral_layout(G), scale=1, center=c)
+        sc(nx.circular_layout(G), scale=1, center=c)
+        sc(nx.shell_layout(G), scale=1, center=c)
+        sc(nx.spiral_layout(G), scale=1, center=c)
+        sc(nx.kamada_kawai_layout(G), scale=1, center=c)
+
+        c = (0, 0, 0)
+        sc(nx.kamada_kawai_layout(G, dim=3), scale=1, center=c)
+
+    def test_circular_planar_and_shell_dim_error(self):
+        G = nx.path_graph(4)
+        pytest.raises(ValueError, nx.circular_layout, G, dim=1)
+        pytest.raises(ValueError, nx.shell_layout, G, dim=1)
+        pytest.raises(ValueError, nx.shell_layout, G, dim=3)
+        pytest.raises(ValueError, nx.planar_layout, G, dim=1)
+        pytest.raises(ValueError, nx.planar_layout, G, dim=3)
+
+    def test_adjacency_interface_numpy(self):
+        A = nx.to_numpy_array(self.Gs)
+        pos = nx.drawing.layout._fruchterman_reingold(A)
+        assert pos.shape == (6, 2)
+        pos = nx.drawing.layout._fruchterman_reingold(A, dim=3)
+        assert pos.shape == (6, 3)
+        pos = nx.drawing.layout._sparse_fruchterman_reingold(A)
+        assert pos.shape == (6, 2)
+
+    def test_adjacency_interface_scipy(self):
+        A = nx.to_scipy_sparse_array(self.Gs, dtype="d")
+        pos = nx.drawing.layout._sparse_fruchterman_reingold(A)
+        assert pos.shape == (6, 2)
+        pos = nx.drawing.layout._sparse_spectral(A)
+        assert pos.shape == (6, 2)
+        pos = nx.drawing.layout._sparse_fruchterman_reingold(A, dim=3)
+        assert pos.shape == (6, 3)
+
+    def test_single_nodes(self):
+        G = nx.path_graph(1)
+        vpos = nx.shell_layout(G)
+        assert not vpos[0].any()
+        G = nx.path_graph(4)
+        vpos = nx.shell_layout(G, [[0], [1, 2], [3]])
+        assert not vpos[0].any()
+        assert vpos[3].any()  # ensure node 3 not at origin (#3188)
+        assert np.linalg.norm(vpos[3]) <= 1  # ensure node 3 fits (#3753)
+        vpos = nx.shell_layout(G, [[0], [1, 2], [3]], rotate=0)
+        assert np.linalg.norm(vpos[3]) <= 1  # ensure node 3 fits (#3753)
+
+    def test_smoke_initial_pos_fruchterman_reingold(self):
+        pos = nx.circular_layout(self.Gi)
+        npos = nx.fruchterman_reingold_layout(self.Gi, pos=pos)
+
+    def test_fixed_node_fruchterman_reingold(self):
+        # Dense version (numpy based)
+        pos = nx.circular_layout(self.Gi)
+        npos = nx.spring_layout(self.Gi, pos=pos, fixed=[(0, 0)])
+        assert tuple(pos[(0, 0)]) == tuple(npos[(0, 0)])
+        # Sparse version (scipy based)
+        pos = nx.circular_layout(self.bigG)
+        npos = nx.spring_layout(self.bigG, pos=pos, fixed=[(0, 0)])
+        for axis in range(2):
+            assert pos[(0, 0)][axis] == pytest.approx(npos[(0, 0)][axis], abs=1e-7)
+
+    def test_center_parameter(self):
+        G = nx.path_graph(1)
+        nx.random_layout(G, center=(1, 1))
+        vpos = nx.circular_layout(G, center=(1, 1))
+        assert tuple(vpos[0]) == (1, 1)
+        vpos = nx.planar_layout(G, center=(1, 1))
+        assert tuple(vpos[0]) == (1, 1)
+        vpos = nx.spring_layout(G, center=(1, 1))
+        assert tuple(vpos[0]) == (1, 1)
+        vpos = nx.fruchterman_reingold_layout(G, center=(1, 1))
+        assert tuple(vpos[0]) == (1, 1)
+        vpos = nx.spectral_layout(G, center=(1, 1))
+        assert tuple(vpos[0]) == (1, 1)
+        vpos = nx.shell_layout(G, center=(1, 1))
+        assert tuple(vpos[0]) == (1, 1)
+        vpos = nx.spiral_layout(G, center=(1, 1))
+        assert tuple(vpos[0]) == (1, 1)
+
+    def test_center_wrong_dimensions(self):
+        G = nx.path_graph(1)
+        assert id(nx.spring_layout) == id(nx.fruchterman_reingold_layout)
+        pytest.raises(ValueError, nx.random_layout, G, center=(1, 1, 1))
+        pytest.raises(ValueError, nx.circular_layout, G, center=(1, 1, 1))
+        pytest.raises(ValueError, nx.planar_layout, G, center=(1, 1, 1))
+        pytest.raises(ValueError, nx.spring_layout, G, center=(1, 1, 1))
+        pytest.raises(ValueError, nx.spring_layout, G, dim=3, center=(1, 1))
+        pytest.raises(ValueError, nx.spectral_layout, G, center=(1, 1, 1))
+        pytest.raises(ValueError, nx.spectral_layout, G, dim=3, center=(1, 1))
+        pytest.raises(ValueError, nx.shell_layout, G, center=(1, 1, 1))
+        pytest.raises(ValueError, nx.spiral_layout, G, center=(1, 1, 1))
+        pytest.raises(ValueError, nx.kamada_kawai_layout, G, center=(1, 1, 1))
+
+    def test_empty_graph(self):
+        G = nx.empty_graph()
+        vpos = nx.random_layout(G, center=(1, 1))
+        assert vpos == {}
+        vpos = nx.circular_layout(G, center=(1, 1))
+        assert vpos == {}
+        vpos = nx.planar_layout(G, center=(1, 1))
+        assert vpos == {}
+        vpos = nx.bipartite_layout(G, G)
+        assert vpos == {}
+        vpos = nx.spring_layout(G, center=(1, 1))
+        assert vpos == {}
+        vpos = nx.fruchterman_reingold_layout(G, center=(1, 1))
+        assert vpos == {}
+        vpos = nx.spectral_layout(G, center=(1, 1))
+        assert vpos == {}
+        vpos = nx.shell_layout(G, center=(1, 1))
+        assert vpos == {}
+        vpos = nx.spiral_layout(G, center=(1, 1))
+        assert vpos == {}
+        vpos = nx.multipartite_layout(G, center=(1, 1))
+        assert vpos == {}
+        vpos = nx.kamada_kawai_layout(G, center=(1, 1))
+        assert vpos == {}
+
+    def test_bipartite_layout(self):
+        G = nx.complete_bipartite_graph(3, 5)
+        top, bottom = nx.bipartite.sets(G)
+
+        vpos = nx.bipartite_layout(G, top)
+        assert len(vpos) == len(G)
+
+        top_x = vpos[list(top)[0]][0]
+        bottom_x = vpos[list(bottom)[0]][0]
+        for node in top:
+            assert vpos[node][0] == top_x
+        for node in bottom:
+            assert vpos[node][0] == bottom_x
+
+        vpos = nx.bipartite_layout(
+            G, top, align="horizontal", center=(2, 2), scale=2, aspect_ratio=1
+        )
+        assert len(vpos) == len(G)
+
+        top_y = vpos[list(top)[0]][1]
+        bottom_y = vpos[list(bottom)[0]][1]
+        for node in top:
+            assert vpos[node][1] == top_y
+        for node in bottom:
+            assert vpos[node][1] == bottom_y
+
+        pytest.raises(ValueError, nx.bipartite_layout, G, top, align="foo")
+
+    def test_multipartite_layout(self):
+        sizes = (0, 5, 7, 2, 8)
+        G = nx.complete_multipartite_graph(*sizes)
+
+        vpos = nx.multipartite_layout(G)
+        assert len(vpos) == len(G)
+
+        start = 0
+        for n in sizes:
+            end = start + n
+            assert all(vpos[start][0] == vpos[i][0] for i in range(start + 1, end))
+            start += n
+
+        vpos = nx.multipartite_layout(G, align="horizontal", scale=2, center=(2, 2))
+        assert len(vpos) == len(G)
+
+        start = 0
+        for n in sizes:
+            end = start + n
+            assert all(vpos[start][1] == vpos[i][1] for i in range(start + 1, end))
+            start += n
+
+        pytest.raises(ValueError, nx.multipartite_layout, G, align="foo")
+
+    def test_kamada_kawai_costfn_1d(self):
+        costfn = nx.drawing.layout._kamada_kawai_costfn
+
+        pos = np.array([4.0, 7.0])
+        invdist = 1 / np.array([[0.1, 2.0], [2.0, 0.3]])
+
+        cost, grad = costfn(pos, np, invdist, meanweight=0, dim=1)
+
+        assert cost == pytest.approx(((3 / 2.0 - 1) ** 2), abs=1e-7)
+        assert grad[0] == pytest.approx((-0.5), abs=1e-7)
+        assert grad[1] == pytest.approx(0.5, abs=1e-7)
+
+    def check_kamada_kawai_costfn(self, pos, invdist, meanwt, dim):
+        costfn = nx.drawing.layout._kamada_kawai_costfn
+
+        cost, grad = costfn(pos.ravel(), np, invdist, meanweight=meanwt, dim=dim)
+
+        expected_cost = 0.5 * meanwt * np.sum(np.sum(pos, axis=0) ** 2)
+        for i in range(pos.shape[0]):
+            for j in range(i + 1, pos.shape[0]):
+                diff = np.linalg.norm(pos[i] - pos[j])
+                expected_cost += (diff * invdist[i][j] - 1.0) ** 2
+
+        assert cost == pytest.approx(expected_cost, abs=1e-7)
+
+        dx = 1e-4
+        for nd in range(pos.shape[0]):
+            for dm in range(pos.shape[1]):
+                idx = nd * pos.shape[1] + dm
+                ps = pos.flatten()
+
+                ps[idx] += dx
+                cplus = costfn(ps, np, invdist, meanweight=meanwt, dim=pos.shape[1])[0]
+
+                ps[idx] -= 2 * dx
+                cminus = costfn(ps, np, invdist, meanweight=meanwt, dim=pos.shape[1])[0]
+
+                assert grad[idx] == pytest.approx((cplus - cminus) / (2 * dx), abs=1e-5)
+
+    def test_kamada_kawai_costfn(self):
+        invdist = 1 / np.array([[0.1, 2.1, 1.7], [2.1, 0.2, 0.6], [1.7, 0.6, 0.3]])
+        meanwt = 0.3
+
+        # 2d
+        pos = np.array([[1.3, -3.2], [2.7, -0.3], [5.1, 2.5]])
+
+        self.check_kamada_kawai_costfn(pos, invdist, meanwt, 2)
+
+        # 3d
+        pos = np.array([[0.9, 8.6, -8.7], [-10, -0.5, -7.1], [9.1, -8.1, 1.6]])
+
+        self.check_kamada_kawai_costfn(pos, invdist, meanwt, 3)
+
+    def test_spiral_layout(self):
+
+        G = self.Gs
+
+        # a lower value of resolution should result in a more compact layout
+        # intuitively, the total distance from the start and end nodes
+        # via each node in between (transiting through each) will be less,
+        # assuming rescaling does not occur on the computed node positions
+        pos_standard = np.array(list(nx.spiral_layout(G, resolution=0.35).values()))
+        pos_tighter = np.array(list(nx.spiral_layout(G, resolution=0.34).values()))
+        distances = np.linalg.norm(pos_standard[:-1] - pos_standard[1:], axis=1)
+        distances_tighter = np.linalg.norm(pos_tighter[:-1] - pos_tighter[1:], axis=1)
+        assert sum(distances) > sum(distances_tighter)
+
+        # return near-equidistant points after the first value if set to true
+        pos_equidistant = np.array(list(nx.spiral_layout(G, equidistant=True).values()))
+        distances_equidistant = np.linalg.norm(
+            pos_equidistant[:-1] - pos_equidistant[1:], axis=1
+        )
+        assert np.allclose(
+            distances_equidistant[1:], distances_equidistant[-1], atol=0.01
+        )
+
+    def test_spiral_layout_equidistant(self):
+        G = nx.path_graph(10)
+        pos = nx.spiral_layout(G, equidistant=True)
+        # Extract individual node positions as an array
+        p = np.array(list(pos.values()))
+        # Elementwise-distance between node positions
+        dist = np.linalg.norm(p[1:] - p[:-1], axis=1)
+        assert np.allclose(np.diff(dist), 0, atol=1e-3)
+
+    def test_rescale_layout_dict(self):
+        G = nx.empty_graph()
+        vpos = nx.random_layout(G, center=(1, 1))
+        assert nx.rescale_layout_dict(vpos) == {}
+
+        G = nx.empty_graph(2)
+        vpos = {0: (0.0, 0.0), 1: (1.0, 1.0)}
+        s_vpos = nx.rescale_layout_dict(vpos)
+        assert np.linalg.norm([sum(x) for x in zip(*s_vpos.values())]) < 1e-6
+
+        G = nx.empty_graph(3)
+        vpos = {0: (0, 0), 1: (1, 1), 2: (0.5, 0.5)}
+        s_vpos = nx.rescale_layout_dict(vpos)
+
+        expectation = {
+            0: np.array((-1, -1)),
+            1: np.array((1, 1)),
+            2: np.array((0, 0)),
+        }
+        for k, v in expectation.items():
+            assert (s_vpos[k] == v).all()
+        s_vpos = nx.rescale_layout_dict(vpos, scale=2)
+
+        expectation = {
+            0: np.array((-2, -2)),
+            1: np.array((2, 2)),
+            2: np.array((0, 0)),
+        }
+        for k, v in expectation.items():
+            assert (s_vpos[k] == v).all()
+
+
+def test_multipartite_layout_nonnumeric_partition_labels():
+    """See gh-5123."""
+    G = nx.Graph()
+    G.add_node(0, subset="s0")
+    G.add_node(1, subset="s0")
+    G.add_node(2, subset="s1")
+    G.add_node(3, subset="s1")
+    G.add_edges_from([(0, 2), (0, 3), (1, 2)])
+    pos = nx.multipartite_layout(G)
+    assert len(pos) == len(G)
+
+
+def test_multipartite_layout_layer_order():
+    """Return the layers in sorted order if the layers of the multipartite
+    graph are sortable. See gh-5691"""
+    G = nx.Graph()
+    for node, layer in zip(("a", "b", "c", "d", "e"), (2, 3, 1, 2, 4)):
+        G.add_node(node, subset=layer)
+
+    # Horizontal alignment, therefore y-coord determines layers
+    pos = nx.multipartite_layout(G, align="horizontal")
+
+    # Nodes "a" and "d" are in the same layer
+    assert pos["a"][-1] == pos["d"][-1]
+    # positions should be sorted according to layer
+    assert pos["c"][-1] < pos["a"][-1] < pos["b"][-1] < pos["e"][-1]
+
+    # Make sure that multipartite_layout still works when layers are not sortable
+    G.nodes["a"]["subset"] = "layer_0"  # Can't sort mixed strs/ints
+    pos_nosort = nx.multipartite_layout(G)  # smoke test: this should not raise
+    assert pos_nosort.keys() == pos.keys()
diff --git a/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_pydot.py b/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_pydot.py
new file mode 100644
index 0000000..90d025e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_pydot.py
@@ -0,0 +1,190 @@
+"""Unit tests for pydot drawing functions."""
+import os
+import tempfile
+from io import StringIO
+
+import pytest
+
+import networkx as nx
+from networkx.utils import graphs_equal
+
+pydot = pytest.importorskip("pydot")
+
+
+@pytest.mark.xfail
+class TestPydot:
+    def pydot_checks(self, G, prog):
+        """
+        Validate :mod:`pydot`-based usage of the passed NetworkX graph with the
+        passed basename of an external GraphViz command (e.g., `dot`, `neato`).
+        """
+
+        # Set the name of this graph to... "G". Failing to do so will
+        # subsequently trip an assertion expecting this name.
+        G.graph["name"] = "G"
+
+        # Add arbitrary nodes and edges to the passed empty graph.
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "C"), ("A", "D")])
+        G.add_node("E")
+
+        # Validate layout of this graph with the passed GraphViz command.
+        graph_layout = nx.nx_pydot.pydot_layout(G, prog=prog)
+        assert isinstance(graph_layout, dict)
+
+        # Convert this graph into a "pydot.Dot" instance.
+        P = nx.nx_pydot.to_pydot(G)
+
+        # Convert this "pydot.Dot" instance back into a graph of the same type.
+        G2 = G.__class__(nx.nx_pydot.from_pydot(P))
+
+        # Validate the original and resulting graphs to be the same.
+        assert graphs_equal(G, G2)
+
+        fd, fname = tempfile.mkstemp()
+
+        # Serialize this "pydot.Dot" instance to a temporary file in dot format
+        P.write_raw(fname)
+
+        # Deserialize a list of new "pydot.Dot" instances back from this file.
+        Pin_list = pydot.graph_from_dot_file(path=fname, encoding="utf-8")
+
+        # Validate this file to contain only one graph.
+        assert len(Pin_list) == 1
+
+        # The single "pydot.Dot" instance deserialized from this file.
+        Pin = Pin_list[0]
+
+        # Sorted list of all nodes in the original "pydot.Dot" instance.
+        n1 = sorted(p.get_name() for p in P.get_node_list())
+
+        # Sorted list of all nodes in the deserialized "pydot.Dot" instance.
+        n2 = sorted(p.get_name() for p in Pin.get_node_list())
+
+        # Validate these instances to contain the same nodes.
+        assert n1 == n2
+
+        # Sorted list of all edges in the original "pydot.Dot" instance.
+        e1 = sorted((e.get_source(), e.get_destination()) for e in P.get_edge_list())
+
+        # Sorted list of all edges in the original "pydot.Dot" instance.
+        e2 = sorted((e.get_source(), e.get_destination()) for e in Pin.get_edge_list())
+
+        # Validate these instances to contain the same edges.
+        assert e1 == e2
+
+        # Deserialize a new graph of the same type back from this file.
+        Hin = nx.nx_pydot.read_dot(fname)
+        Hin = G.__class__(Hin)
+
+        # Validate the original and resulting graphs to be the same.
+        assert graphs_equal(G, Hin)
+
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_undirected(self):
+        self.pydot_checks(nx.Graph(), prog="neato")
+
+    def test_directed(self):
+        self.pydot_checks(nx.DiGraph(), prog="dot")
+
+    def test_read_write(self):
+        G = nx.MultiGraph()
+        G.graph["name"] = "G"
+        G.add_edge("1", "2", key="0")  # read assumes strings
+        fh = StringIO()
+        nx.nx_pydot.write_dot(G, fh)
+        fh.seek(0)
+        H = nx.nx_pydot.read_dot(fh)
+        assert graphs_equal(G, H)
+
+
+def test_pydot_issue_258():
+    G = nx.Graph([("Example:A", 1)])
+    with pytest.raises(ValueError):
+        nx.nx_pydot.to_pydot(G)
+    with pytest.raises(ValueError):
+        nx.nx_pydot.pydot_layout(G)
+
+    G = nx.Graph()
+    G.add_node("1.2", style="filled", fillcolor="red:yellow")
+    with pytest.raises(ValueError):
+        nx.nx_pydot.to_pydot(G)
+    G.remove_node("1.2")
+    G.add_node("1.2", style="filled", fillcolor='"red:yellow"')
+    assert (
+        G.nodes.data() == nx.nx_pydot.from_pydot(nx.nx_pydot.to_pydot(G)).nodes.data()
+    )
+
+    G = nx.DiGraph()
+    G.add_edge("1", "2", foo="bar:1")
+    with pytest.raises(ValueError):
+        nx.nx_pydot.to_pydot(G)
+    G = nx.DiGraph()
+    G.add_edge("1", "2", foo='"bar:1"')
+    assert G["1"]["2"] == nx.nx_pydot.from_pydot(nx.nx_pydot.to_pydot(G))["1"]["2"]
+
+    G = nx.MultiGraph()
+    G.add_edge("1", "2", foo="b:1")
+    G.add_edge("1", "2", bar="foo:foo")
+    with pytest.raises(ValueError):
+        nx.nx_pydot.to_pydot(G)
+    G = nx.MultiGraph()
+    G.add_edge("1", "2", foo='"b:1"')
+    G.add_edge("1", "2", bar='"foo:foo"')
+    # Keys as integers aren't preserved in the conversion. They are read as strings.
+    assert [attr for _, _, attr in G.edges.data()] == [
+        attr
+        for _, _, attr in nx.nx_pydot.from_pydot(nx.nx_pydot.to_pydot(G)).edges.data()
+    ]
+
+    G = nx.Graph()
+    G.add_edge("1", "2")
+    G["1"]["2"]["f:oo"] = "bar"
+    with pytest.raises(ValueError):
+        nx.nx_pydot.to_pydot(G)
+    G = nx.Graph()
+    G.add_edge("1", "2")
+    G["1"]["2"]['"f:oo"'] = "bar"
+    assert G["1"]["2"] == nx.nx_pydot.from_pydot(nx.nx_pydot.to_pydot(G))["1"]["2"]
+
+    G = nx.Graph([('"Example:A"', 1)])
+    layout = nx.nx_pydot.pydot_layout(G)
+    assert isinstance(layout, dict)
+
+
+@pytest.mark.parametrize(
+    "graph_type", [nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph]
+)
+def test_hashable_pydot(graph_type):
+    # gh-5790
+    G = graph_type()
+    G.add_edge("5", frozenset([1]), t='"Example:A"', l=False)
+    G.add_edge("1", 2, w=True, t=("node1",), l=frozenset(["node1"]))
+    G.add_edge("node", (3, 3), w="string")
+
+    assert [
+        {"t": '"Example:A"', "l": "False"},
+        {"w": "True", "t": "('node1',)", "l": "frozenset({'node1'})"},
+        {"w": "string"},
+    ] == [
+        attr
+        for _, _, attr in nx.nx_pydot.from_pydot(nx.nx_pydot.to_pydot(G)).edges.data()
+    ]
+
+    assert {str(i) for i in G.nodes()} == set(
+        nx.nx_pydot.from_pydot(nx.nx_pydot.to_pydot(G)).nodes
+    )
+
+
+def test_pydot_numrical_name():
+    G = nx.Graph()
+    G.add_edges_from([("A", "B"), (0, 1)])
+    graph_layout = nx.nx_pydot.pydot_layout(G, prog="dot")
+    assert isinstance(graph_layout, dict)
+    assert "0" not in graph_layout
+    assert 0 in graph_layout
+    assert "1" not in graph_layout
+    assert 1 in graph_layout
+    assert "A" in graph_layout
+    assert "B" in graph_layout
diff --git a/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_pylab.py b/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_pylab.py
new file mode 100644
index 0000000..33ce4e8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/drawing/tests/test_pylab.py
@@ -0,0 +1,753 @@
+"""Unit tests for matplotlib drawing functions."""
+import itertools
+import os
+
+import pytest
+
+mpl = pytest.importorskip("matplotlib")
+np = pytest.importorskip("numpy")
+mpl.use("PS")
+plt = pytest.importorskip("matplotlib.pyplot")
+plt.rcParams["text.usetex"] = False
+
+
+import networkx as nx
+
+barbell = nx.barbell_graph(4, 6)
+
+
+def test_draw():
+    try:
+        functions = [
+            nx.draw_circular,
+            nx.draw_kamada_kawai,
+            nx.draw_planar,
+            nx.draw_random,
+            nx.draw_spectral,
+            nx.draw_spring,
+            nx.draw_shell,
+        ]
+        options = [{"node_color": "black", "node_size": 100, "width": 3}]
+        for function, option in itertools.product(functions, options):
+            function(barbell, **option)
+            plt.savefig("test.ps")
+
+    finally:
+        try:
+            os.unlink("test.ps")
+        except OSError:
+            pass
+
+
+def test_draw_shell_nlist():
+    try:
+        nlist = [list(range(4)), list(range(4, 10)), list(range(10, 14))]
+        nx.draw_shell(barbell, nlist=nlist)
+        plt.savefig("test.ps")
+    finally:
+        try:
+            os.unlink("test.ps")
+        except OSError:
+            pass
+
+
+def test_edge_colormap():
+    colors = range(barbell.number_of_edges())
+    nx.draw_spring(
+        barbell, edge_color=colors, width=4, edge_cmap=plt.cm.Blues, with_labels=True
+    )
+    # plt.show()
+
+
+def test_arrows():
+    nx.draw_spring(barbell.to_directed())
+    # plt.show()
+
+
+@pytest.mark.parametrize(
+    ("edge_color", "expected"),
+    (
+        (None, "black"),  # Default
+        ("r", "red"),  # Non-default color string
+        (["r"], "red"),  # Single non-default color in a list
+        ((1.0, 1.0, 0.0), "yellow"),  # single color as rgb tuple
+        ([(1.0, 1.0, 0.0)], "yellow"),  # single color as rgb tuple in list
+        ((0, 1, 0, 1), "lime"),  # single color as rgba tuple
+        ([(0, 1, 0, 1)], "lime"),  # single color as rgba tuple in list
+        ("#0000ff", "blue"),  # single color hex code
+        (["#0000ff"], "blue"),  # hex code in list
+    ),
+)
+@pytest.mark.parametrize("edgelist", (None, [(0, 1)]))
+def test_single_edge_color_undirected(edge_color, expected, edgelist):
+    """Tests ways of specifying all edges have a single color for edges
+    drawn with a LineCollection"""
+
+    G = nx.path_graph(3)
+    drawn_edges = nx.draw_networkx_edges(
+        G, pos=nx.random_layout(G), edgelist=edgelist, edge_color=edge_color
+    )
+    assert mpl.colors.same_color(drawn_edges.get_color(), expected)
+
+
+@pytest.mark.parametrize(
+    ("edge_color", "expected"),
+    (
+        (None, "black"),  # Default
+        ("r", "red"),  # Non-default color string
+        (["r"], "red"),  # Single non-default color in a list
+        ((1.0, 1.0, 0.0), "yellow"),  # single color as rgb tuple
+        ([(1.0, 1.0, 0.0)], "yellow"),  # single color as rgb tuple in list
+        ((0, 1, 0, 1), "lime"),  # single color as rgba tuple
+        ([(0, 1, 0, 1)], "lime"),  # single color as rgba tuple in list
+        ("#0000ff", "blue"),  # single color hex code
+        (["#0000ff"], "blue"),  # hex code in list
+    ),
+)
+@pytest.mark.parametrize("edgelist", (None, [(0, 1)]))
+def test_single_edge_color_directed(edge_color, expected, edgelist):
+    """Tests ways of specifying all edges have a single color for edges drawn
+    with FancyArrowPatches"""
+
+    G = nx.path_graph(3, create_using=nx.DiGraph)
+    drawn_edges = nx.draw_networkx_edges(
+        G, pos=nx.random_layout(G), edgelist=edgelist, edge_color=edge_color
+    )
+    for fap in drawn_edges:
+        assert mpl.colors.same_color(fap.get_edgecolor(), expected)
+
+
+def test_edge_color_tuple_interpretation():
+    """If edge_color is a sequence with the same length as edgelist, then each
+    value in edge_color is mapped onto each edge via colormap."""
+    G = nx.path_graph(6, create_using=nx.DiGraph)
+    pos = {n: (n, n) for n in range(len(G))}
+
+    # num edges != 3 or 4 --> edge_color interpreted as rgb(a)
+    for ec in ((0, 0, 1), (0, 0, 1, 1)):
+        # More than 4 edges
+        drawn_edges = nx.draw_networkx_edges(G, pos, edge_color=ec)
+        for fap in drawn_edges:
+            assert mpl.colors.same_color(fap.get_edgecolor(), ec)
+        # Fewer than 3 edges
+        drawn_edges = nx.draw_networkx_edges(
+            G, pos, edgelist=[(0, 1), (1, 2)], edge_color=ec
+        )
+        for fap in drawn_edges:
+            assert mpl.colors.same_color(fap.get_edgecolor(), ec)
+
+    # num edges == 3, len(edge_color) == 4: interpreted as rgba
+    drawn_edges = nx.draw_networkx_edges(
+        G, pos, edgelist=[(0, 1), (1, 2), (2, 3)], edge_color=(0, 0, 1, 1)
+    )
+    for fap in drawn_edges:
+        assert mpl.colors.same_color(fap.get_edgecolor(), "blue")
+
+    # num edges == 4, len(edge_color) == 3: interpreted as rgb
+    drawn_edges = nx.draw_networkx_edges(
+        G, pos, edgelist=[(0, 1), (1, 2), (2, 3), (3, 4)], edge_color=(0, 0, 1)
+    )
+    for fap in drawn_edges:
+        assert mpl.colors.same_color(fap.get_edgecolor(), "blue")
+
+    # num edges == len(edge_color) == 3: interpreted with cmap, *not* as rgb
+    drawn_edges = nx.draw_networkx_edges(
+        G, pos, edgelist=[(0, 1), (1, 2), (2, 3)], edge_color=(0, 0, 1)
+    )
+    assert mpl.colors.same_color(
+        drawn_edges[0].get_edgecolor(), drawn_edges[1].get_edgecolor()
+    )
+    for fap in drawn_edges:
+        assert not mpl.colors.same_color(fap.get_edgecolor(), "blue")
+
+    # num edges == len(edge_color) == 4: interpreted with cmap, *not* as rgba
+    drawn_edges = nx.draw_networkx_edges(
+        G, pos, edgelist=[(0, 1), (1, 2), (2, 3), (3, 4)], edge_color=(0, 0, 1, 1)
+    )
+    assert mpl.colors.same_color(
+        drawn_edges[0].get_edgecolor(), drawn_edges[1].get_edgecolor()
+    )
+    assert mpl.colors.same_color(
+        drawn_edges[2].get_edgecolor(), drawn_edges[3].get_edgecolor()
+    )
+    for fap in drawn_edges:
+        assert not mpl.colors.same_color(fap.get_edgecolor(), "blue")
+
+
+def test_fewer_edge_colors_than_num_edges_directed():
+    """Test that the edge colors are cycled when there are fewer specified
+    colors than edges."""
+    G = barbell.to_directed()
+    pos = nx.random_layout(barbell)
+    edgecolors = ("r", "g", "b")
+    drawn_edges = nx.draw_networkx_edges(G, pos, edge_color=edgecolors)
+    for fap, expected in zip(drawn_edges, itertools.cycle(edgecolors)):
+        assert mpl.colors.same_color(fap.get_edgecolor(), expected)
+
+
+def test_more_edge_colors_than_num_edges_directed():
+    """Test that extra edge colors are ignored when there are more specified
+    colors than edges."""
+    G = nx.path_graph(4, create_using=nx.DiGraph)  # 3 edges
+    pos = nx.random_layout(barbell)
+    edgecolors = ("r", "g", "b", "c")  # 4 edge colors
+    drawn_edges = nx.draw_networkx_edges(G, pos, edge_color=edgecolors)
+    for fap, expected in zip(drawn_edges, edgecolors[:-1]):
+        assert mpl.colors.same_color(fap.get_edgecolor(), expected)
+
+
+def test_edge_color_string_with_gloabl_alpha_undirected():
+    edge_collection = nx.draw_networkx_edges(
+        barbell,
+        pos=nx.random_layout(barbell),
+        edgelist=[(0, 1), (1, 2)],
+        edge_color="purple",
+        alpha=0.2,
+    )
+    ec = edge_collection.get_color().squeeze()  # as rgba tuple
+    assert len(edge_collection.get_paths()) == 2
+    assert mpl.colors.same_color(ec[:-1], "purple")
+    assert ec[-1] == 0.2
+
+
+def test_edge_color_string_with_global_alpha_directed():
+    drawn_edges = nx.draw_networkx_edges(
+        barbell.to_directed(),
+        pos=nx.random_layout(barbell),
+        edgelist=[(0, 1), (1, 2)],
+        edge_color="purple",
+        alpha=0.2,
+    )
+    assert len(drawn_edges) == 2
+    for fap in drawn_edges:
+        ec = fap.get_edgecolor()  # As rgba tuple
+        assert mpl.colors.same_color(ec[:-1], "purple")
+        assert ec[-1] == 0.2
+
+
+@pytest.mark.parametrize("graph_type", (nx.Graph, nx.DiGraph))
+def test_edge_width_default_value(graph_type):
+    """Test the default linewidth for edges drawn either via LineCollection or
+    FancyArrowPatches."""
+    G = nx.path_graph(2, create_using=graph_type)
+    pos = {n: (n, n) for n in range(len(G))}
+    drawn_edges = nx.draw_networkx_edges(G, pos)
+    if isinstance(drawn_edges, list):  # directed case: list of FancyArrowPatch
+        drawn_edges = drawn_edges[0]
+    assert drawn_edges.get_linewidth() == 1
+
+
+@pytest.mark.parametrize(
+    ("edgewidth", "expected"),
+    (
+        (3, 3),  # single-value, non-default
+        ([3], 3),  # Single value as a list
+    ),
+)
+def test_edge_width_single_value_undirected(edgewidth, expected):
+    G = nx.path_graph(4)
+    pos = {n: (n, n) for n in range(len(G))}
+    drawn_edges = nx.draw_networkx_edges(G, pos, width=edgewidth)
+    assert len(drawn_edges.get_paths()) == 3
+    assert drawn_edges.get_linewidth() == expected
+
+
+@pytest.mark.parametrize(
+    ("edgewidth", "expected"),
+    (
+        (3, 3),  # single-value, non-default
+        ([3], 3),  # Single value as a list
+    ),
+)
+def test_edge_width_single_value_directed(edgewidth, expected):
+    G = nx.path_graph(4, create_using=nx.DiGraph)
+    pos = {n: (n, n) for n in range(len(G))}
+    drawn_edges = nx.draw_networkx_edges(G, pos, width=edgewidth)
+    assert len(drawn_edges) == 3
+    for fap in drawn_edges:
+        assert fap.get_linewidth() == expected
+
+
+@pytest.mark.parametrize(
+    "edgelist",
+    (
+        [(0, 1), (1, 2), (2, 3)],  # one width specification per edge
+        None,  #  fewer widths than edges - widths cycle
+        [(0, 1), (1, 2)],  # More widths than edges - unused widths ignored
+    ),
+)
+def test_edge_width_sequence(edgelist):
+    G = barbell.to_directed()
+    pos = nx.random_layout(G)
+    widths = (0.5, 2.0, 12.0)
+    drawn_edges = nx.draw_networkx_edges(G, pos, edgelist=edgelist, width=widths)
+    for fap, expected_width in zip(drawn_edges, itertools.cycle(widths)):
+        assert fap.get_linewidth() == expected_width
+
+
+def test_edge_color_with_edge_vmin_vmax():
+    """Test that edge_vmin and edge_vmax properly set the dynamic range of the
+    color map when num edges == len(edge_colors)."""
+    G = nx.path_graph(3, create_using=nx.DiGraph)
+    pos = nx.random_layout(G)
+    # Extract colors from the original (unscaled) colormap
+    drawn_edges = nx.draw_networkx_edges(G, pos, edge_color=[0, 1.0])
+    orig_colors = [e.get_edgecolor() for e in drawn_edges]
+    # Colors from scaled colormap
+    drawn_edges = nx.draw_networkx_edges(
+        G, pos, edge_color=[0.2, 0.8], edge_vmin=0.2, edge_vmax=0.8
+    )
+    scaled_colors = [e.get_edgecolor() for e in drawn_edges]
+    assert mpl.colors.same_color(orig_colors, scaled_colors)
+
+
+def test_directed_edges_linestyle_default():
+    """Test default linestyle for edges drawn with FancyArrowPatches."""
+    G = nx.path_graph(4, create_using=nx.DiGraph)  # Graph with 3 edges
+    pos = {n: (n, n) for n in range(len(G))}
+
+    # edge with default style
+    drawn_edges = nx.draw_networkx_edges(G, pos)
+    assert len(drawn_edges) == 3
+    for fap in drawn_edges:
+        assert fap.get_linestyle() == "solid"
+
+
+@pytest.mark.parametrize(
+    "style",
+    (
+        "dashed",  # edge with string style
+        "--",  # edge with simplified string style
+        (1, (1, 1)),  # edge with (offset, onoffseq) style
+    ),
+)
+def test_directed_edges_linestyle_single_value(style):
+    """Tests support for specifying linestyles with a single value to be applied to
+    all edges in ``draw_networkx_edges`` for FancyArrowPatch outputs
+    (e.g. directed edges)."""
+
+    G = nx.path_graph(4, create_using=nx.DiGraph)  # Graph with 3 edges
+    pos = {n: (n, n) for n in range(len(G))}
+
+    drawn_edges = nx.draw_networkx_edges(G, pos, style=style)
+    assert len(drawn_edges) == 3
+    for fap in drawn_edges:
+        assert fap.get_linestyle() == style
+
+
+@pytest.mark.parametrize(
+    "style_seq",
+    (
+        ["dashed"],  # edge with string style in list
+        ["--"],  # edge with simplified string style in list
+        [(1, (1, 1))],  # edge with (offset, onoffseq) style in list
+        ["--", "-", ":"],  # edges with styles for each edge
+        ["--", "-"],  # edges with fewer styles than edges (styles cycle)
+        ["--", "-", ":", "-."],  # edges with more styles than edges (extra unused)
+    ),
+)
+def test_directed_edges_linestyle_sequence(style_seq):
+    """Tests support for specifying linestyles with sequences in
+    ``draw_networkx_edges`` for FancyArrowPatch outputs (e.g. directed edges)."""
+
+    G = nx.path_graph(4, create_using=nx.DiGraph)  # Graph with 3 edges
+    pos = {n: (n, n) for n in range(len(G))}
+
+    drawn_edges = nx.draw_networkx_edges(G, pos, style=style_seq)
+    assert len(drawn_edges) == 3
+    for fap, style in zip(drawn_edges, itertools.cycle(style_seq)):
+        assert fap.get_linestyle() == style
+
+
+def test_labels_and_colors():
+    G = nx.cubical_graph()
+    pos = nx.spring_layout(G)  # positions for all nodes
+    # nodes
+    nx.draw_networkx_nodes(
+        G, pos, nodelist=[0, 1, 2, 3], node_color="r", node_size=500, alpha=0.75
+    )
+    nx.draw_networkx_nodes(
+        G,
+        pos,
+        nodelist=[4, 5, 6, 7],
+        node_color="b",
+        node_size=500,
+        alpha=[0.25, 0.5, 0.75, 1.0],
+    )
+    # edges
+    nx.draw_networkx_edges(G, pos, width=1.0, alpha=0.5)
+    nx.draw_networkx_edges(
+        G,
+        pos,
+        edgelist=[(0, 1), (1, 2), (2, 3), (3, 0)],
+        width=8,
+        alpha=0.5,
+        edge_color="r",
+    )
+    nx.draw_networkx_edges(
+        G,
+        pos,
+        edgelist=[(4, 5), (5, 6), (6, 7), (7, 4)],
+        width=8,
+        alpha=0.5,
+        edge_color="b",
+    )
+    nx.draw_networkx_edges(
+        G,
+        pos,
+        edgelist=[(4, 5), (5, 6), (6, 7), (7, 4)],
+        min_source_margin=0.5,
+        min_target_margin=0.75,
+        width=8,
+        edge_color="b",
+    )
+    # some math labels
+    labels = {}
+    labels[0] = r"$a$"
+    labels[1] = r"$b$"
+    labels[2] = r"$c$"
+    labels[3] = r"$d$"
+    labels[4] = r"$\alpha$"
+    labels[5] = r"$\beta$"
+    labels[6] = r"$\gamma$"
+    labels[7] = r"$\delta$"
+    nx.draw_networkx_labels(G, pos, labels, font_size=16)
+    nx.draw_networkx_edge_labels(G, pos, edge_labels=None, rotate=False)
+    nx.draw_networkx_edge_labels(G, pos, edge_labels={(4, 5): "4-5"})
+    # plt.show()
+
+
+@pytest.mark.mpl_image_compare
+def test_house_with_colors():
+    G = nx.house_graph()
+    # explicitly set positions
+    fig, ax = plt.subplots()
+    pos = {0: (0, 0), 1: (1, 0), 2: (0, 1), 3: (1, 1), 4: (0.5, 2.0)}
+
+    # Plot nodes with different properties for the "wall" and "roof" nodes
+    nx.draw_networkx_nodes(
+        G,
+        pos,
+        node_size=3000,
+        nodelist=[0, 1, 2, 3],
+        node_color="tab:blue",
+    )
+    nx.draw_networkx_nodes(
+        G, pos, node_size=2000, nodelist=[4], node_color="tab:orange"
+    )
+    nx.draw_networkx_edges(G, pos, alpha=0.5, width=6)
+    # Customize axes
+    ax.margins(0.11)
+    plt.tight_layout()
+    plt.axis("off")
+    return fig
+
+
+def test_axes():
+    fig, ax = plt.subplots()
+    nx.draw(barbell, ax=ax)
+    nx.draw_networkx_edge_labels(barbell, nx.circular_layout(barbell), ax=ax)
+
+
+def test_empty_graph():
+    G = nx.Graph()
+    nx.draw(G)
+
+
+def test_draw_empty_nodes_return_values():
+    # See Issue #3833
+    import matplotlib.collections  # call as mpl.collections
+
+    G = nx.Graph([(1, 2), (2, 3)])
+    DG = nx.DiGraph([(1, 2), (2, 3)])
+    pos = nx.circular_layout(G)
+    assert isinstance(
+        nx.draw_networkx_nodes(G, pos, nodelist=[]), mpl.collections.PathCollection
+    )
+    assert isinstance(
+        nx.draw_networkx_nodes(DG, pos, nodelist=[]), mpl.collections.PathCollection
+    )
+
+    # drawing empty edges used to return an empty LineCollection or empty list.
+    # Now it is always an empty list (because edges are now lists of FancyArrows)
+    assert nx.draw_networkx_edges(G, pos, edgelist=[], arrows=True) == []
+    assert nx.draw_networkx_edges(G, pos, edgelist=[], arrows=False) == []
+    assert nx.draw_networkx_edges(DG, pos, edgelist=[], arrows=False) == []
+    assert nx.draw_networkx_edges(DG, pos, edgelist=[], arrows=True) == []
+
+
+def test_multigraph_edgelist_tuples():
+    # See Issue #3295
+    G = nx.path_graph(3, create_using=nx.MultiDiGraph)
+    nx.draw_networkx(G, edgelist=[(0, 1, 0)])
+    nx.draw_networkx(G, edgelist=[(0, 1, 0)], node_size=[10, 20, 0])
+
+
+def test_alpha_iter():
+    pos = nx.random_layout(barbell)
+    # with fewer alpha elements than nodes
+    plt.subplot(131)
+    nx.draw_networkx_nodes(barbell, pos, alpha=[0.1, 0.2])
+    # with equal alpha elements and nodes
+    num_nodes = len(barbell.nodes)
+    alpha = [x / num_nodes for x in range(num_nodes)]
+    colors = range(num_nodes)
+    plt.subplot(132)
+    nx.draw_networkx_nodes(barbell, pos, node_color=colors, alpha=alpha)
+    # with more alpha elements than nodes
+    alpha.append(1)
+    plt.subplot(133)
+    nx.draw_networkx_nodes(barbell, pos, alpha=alpha)
+
+
+def test_error_invalid_kwds():
+    with pytest.raises(ValueError, match="Received invalid argument"):
+        nx.draw(barbell, foo="bar")
+
+
+def test_draw_networkx_arrowsize_incorrect_size():
+    G = nx.DiGraph([(0, 1), (0, 2), (0, 3), (1, 3)])
+    arrowsize = [1, 2, 3]
+    with pytest.raises(
+        ValueError, match="arrowsize should have the same length as edgelist"
+    ):
+        nx.draw(G, arrowsize=arrowsize)
+
+
+@pytest.mark.parametrize("arrowsize", (30, [10, 20, 30]))
+def test_draw_edges_arrowsize(arrowsize):
+    G = nx.DiGraph([(0, 1), (0, 2), (1, 2)])
+    pos = {0: (0, 0), 1: (0, 1), 2: (1, 0)}
+    edges = nx.draw_networkx_edges(G, pos=pos, arrowsize=arrowsize)
+
+    arrowsize = itertools.repeat(arrowsize) if isinstance(arrowsize, int) else arrowsize
+
+    for fap, expected in zip(edges, arrowsize):
+        assert isinstance(fap, mpl.patches.FancyArrowPatch)
+        assert fap.get_mutation_scale() == expected
+
+
+def test_np_edgelist():
+    # see issue #4129
+    nx.draw_networkx(barbell, edgelist=np.array([(0, 2), (0, 3)]))
+
+
+def test_draw_nodes_missing_node_from_position():
+    G = nx.path_graph(3)
+    pos = {0: (0, 0), 1: (1, 1)}  # No position for node 2
+    with pytest.raises(nx.NetworkXError, match="has no position"):
+        nx.draw_networkx_nodes(G, pos)
+
+
+# NOTE: parametrizing on marker to test both branches of internal
+# nx.draw_networkx_edges.to_marker_edge function
+@pytest.mark.parametrize("node_shape", ("o", "s"))
+def test_draw_edges_min_source_target_margins(node_shape):
+    """Test that there is a wider gap between the node and the start of an
+    incident edge when min_source_margin is specified.
+
+    This test checks that the use of min_{source/target}_margin kwargs result
+    in shorter (more padding) between the edges and source and target nodes.
+    As a crude visual example, let 's' and 't' represent source and target
+    nodes, respectively:
+
+       Default:
+       s-----------------------------t
+
+       With margins:
+       s   -----------------------   t
+
+    """
+    # Create a single axis object to get consistent pixel coords across
+    # multiple draws
+    fig, ax = plt.subplots()
+    G = nx.DiGraph([(0, 1)])
+    pos = {0: (0, 0), 1: (1, 0)}  # horizontal layout
+    # Get leftmost and rightmost points of the FancyArrowPatch object
+    # representing the edge between nodes 0 and 1 (in pixel coordinates)
+    default_patch = nx.draw_networkx_edges(G, pos, ax=ax, node_shape=node_shape)[0]
+    default_extent = default_patch.get_extents().corners()[::2, 0]
+    # Now, do the same but with "padding" for the source and target via the
+    # min_{source/target}_margin kwargs
+    padded_patch = nx.draw_networkx_edges(
+        G,
+        pos,
+        ax=ax,
+        node_shape=node_shape,
+        min_source_margin=100,
+        min_target_margin=100,
+    )[0]
+    padded_extent = padded_patch.get_extents().corners()[::2, 0]
+
+    # With padding, the left-most extent of the edge should be further to the
+    # right
+    assert padded_extent[0] > default_extent[0]
+    # And the rightmost extent of the edge, further to the left
+    assert padded_extent[1] < default_extent[1]
+
+
+def test_nonzero_selfloop_with_single_node():
+    """Ensure that selfloop extent is non-zero when there is only one node."""
+    # Create explicit axis object for test
+    fig, ax = plt.subplots()
+    # Graph with single node + self loop
+    G = nx.DiGraph()
+    G.add_node(0)
+    G.add_edge(0, 0)
+    # Draw
+    patch = nx.draw_networkx_edges(G, {0: (0, 0)})[0]
+    # The resulting patch must have non-zero extent
+    bbox = patch.get_extents()
+    assert bbox.width > 0 and bbox.height > 0
+    # Cleanup
+    plt.delaxes(ax)
+
+
+def test_nonzero_selfloop_with_single_edge_in_edgelist():
+    """Ensure that selfloop extent is non-zero when only a single edge is
+    specified in the edgelist.
+    """
+    # Create explicit axis object for test
+    fig, ax = plt.subplots()
+    # Graph with selfloop
+    G = nx.path_graph(2, create_using=nx.DiGraph)
+    G.add_edge(1, 1)
+    pos = {n: (n, n) for n in G.nodes}
+    # Draw only the selfloop edge via the `edgelist` kwarg
+    patch = nx.draw_networkx_edges(G, pos, edgelist=[(1, 1)])[0]
+    # The resulting patch must have non-zero extent
+    bbox = patch.get_extents()
+    assert bbox.width > 0 and bbox.height > 0
+    # Cleanup
+    plt.delaxes(ax)
+
+
+def test_apply_alpha():
+    """Test apply_alpha when there is a mismatch between the number of
+    supplied colors and elements.
+    """
+    nodelist = [0, 1, 2]
+    colorlist = ["r", "g", "b"]
+    alpha = 0.5
+    rgba_colors = nx.drawing.nx_pylab.apply_alpha(colorlist, alpha, nodelist)
+    assert all(rgba_colors[:, -1] == alpha)
+
+
+def test_draw_edges_toggling_with_arrows_kwarg():
+    """
+    The `arrows` keyword argument is used as a 3-way switch to select which
+    type of object to use for drawing edges:
+      - ``arrows=None`` -> default (FancyArrowPatches for directed, else LineCollection)
+      - ``arrows=True`` -> FancyArrowPatches
+      - ``arrows=False`` -> LineCollection
+    """
+    import matplotlib.collections
+    import matplotlib.patches
+
+    UG = nx.path_graph(3)
+    DG = nx.path_graph(3, create_using=nx.DiGraph)
+    pos = {n: (n, n) for n in UG}
+
+    # Use FancyArrowPatches when arrows=True, regardless of graph type
+    for G in (UG, DG):
+        edges = nx.draw_networkx_edges(G, pos, arrows=True)
+        assert len(edges) == len(G.edges)
+        assert isinstance(edges[0], mpl.patches.FancyArrowPatch)
+
+    # Use LineCollection when arrows=False, regardless of graph type
+    for G in (UG, DG):
+        edges = nx.draw_networkx_edges(G, pos, arrows=False)
+        assert isinstance(edges, mpl.collections.LineCollection)
+
+    # Default behavior when arrows=None: FAPs for directed, LC's for undirected
+    edges = nx.draw_networkx_edges(UG, pos)
+    assert isinstance(edges, mpl.collections.LineCollection)
+    edges = nx.draw_networkx_edges(DG, pos)
+    assert len(edges) == len(G.edges)
+    assert isinstance(edges[0], mpl.patches.FancyArrowPatch)
+
+
+@pytest.mark.parametrize("drawing_func", (nx.draw, nx.draw_networkx))
+def test_draw_networkx_arrows_default_undirected(drawing_func):
+    import matplotlib.collections
+
+    G = nx.path_graph(3)
+    fig, ax = plt.subplots()
+    drawing_func(G, ax=ax)
+    assert any(isinstance(c, mpl.collections.LineCollection) for c in ax.collections)
+    assert not ax.patches
+    plt.delaxes(ax)
+
+
+@pytest.mark.parametrize("drawing_func", (nx.draw, nx.draw_networkx))
+def test_draw_networkx_arrows_default_directed(drawing_func):
+    import matplotlib.collections
+
+    G = nx.path_graph(3, create_using=nx.DiGraph)
+    fig, ax = plt.subplots()
+    drawing_func(G, ax=ax)
+    assert not any(
+        isinstance(c, mpl.collections.LineCollection) for c in ax.collections
+    )
+    assert ax.patches
+    plt.delaxes(ax)
+
+
+def test_edgelist_kwarg_not_ignored():
+    # See gh-4994
+    G = nx.path_graph(3)
+    G.add_edge(0, 0)
+    fig, ax = plt.subplots()
+    nx.draw(G, edgelist=[(0, 1), (1, 2)], ax=ax)  # Exclude self-loop from edgelist
+    assert not ax.patches
+    plt.delaxes(ax)
+
+
+def test_draw_networkx_edge_label_multiedge_exception():
+    """
+    draw_networkx_edge_labels should raise an informative error message when
+    the edge label includes keys
+    """
+    exception_msg = "draw_networkx_edge_labels does not support multiedges"
+    G = nx.MultiGraph()
+    G.add_edge(0, 1, weight=10)
+    G.add_edge(0, 1, weight=20)
+    edge_labels = nx.get_edge_attributes(G, "weight")  # Includes edge keys
+    pos = {n: (n, n) for n in G}
+    with pytest.raises(nx.NetworkXError, match=exception_msg):
+        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
+
+
+def test_draw_networkx_edge_label_empty_dict():
+    """Regression test for draw_networkx_edge_labels with empty dict. See
+    gh-5372."""
+    G = nx.path_graph(3)
+    pos = {n: (n, n) for n in G.nodes}
+    assert nx.draw_networkx_edge_labels(G, pos, edge_labels={}) == {}
+
+
+def test_draw_networkx_edges_undirected_selfloop_colors():
+    """When an edgelist is supplied along with a sequence of colors, check that
+    the self-loops have the correct colors."""
+    fig, ax = plt.subplots()
+    # Edge list and corresponding colors
+    edgelist = [(1, 3), (1, 2), (2, 3), (1, 1), (3, 3), (2, 2)]
+    edge_colors = ["pink", "cyan", "black", "red", "blue", "green"]
+
+    G = nx.Graph(edgelist)
+    pos = {n: (n, n) for n in G.nodes}
+    nx.draw_networkx_edges(G, pos, ax=ax, edgelist=edgelist, edge_color=edge_colors)
+
+    # Verify that there are three fancy arrow patches (1 per self loop)
+    assert len(ax.patches) == 3
+
+    # These are points that should be contained in the self loops. For example,
+    # sl_points[0] will be (1, 1.1), which is inside the "path" of the first
+    # self-loop but outside the others
+    sl_points = np.array(edgelist[-3:]) + np.array([0, 0.1])
+
+    # Check that the mapping between self-loop locations and their colors is
+    # correct
+    for fap, clr, slp in zip(ax.patches, edge_colors[-3:], sl_points):
+        assert fap.get_path().contains_point(slp)
+        assert mpl.colors.same_color(fap.get_edgecolor(), clr)
diff --git a/myenv/lib/python3.9/site-packages/networkx/exception.py b/myenv/lib/python3.9/site-packages/networkx/exception.py
new file mode 100644
index 0000000..96694cc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/exception.py
@@ -0,0 +1,125 @@
+"""
+**********
+Exceptions
+**********
+
+Base exceptions and errors for NetworkX.
+"""
+
+__all__ = [
+    "HasACycle",
+    "NodeNotFound",
+    "PowerIterationFailedConvergence",
+    "ExceededMaxIterations",
+    "AmbiguousSolution",
+    "NetworkXAlgorithmError",
+    "NetworkXException",
+    "NetworkXError",
+    "NetworkXNoCycle",
+    "NetworkXNoPath",
+    "NetworkXNotImplemented",
+    "NetworkXPointlessConcept",
+    "NetworkXUnbounded",
+    "NetworkXUnfeasible",
+]
+
+
+class NetworkXException(Exception):
+    """Base class for exceptions in NetworkX."""
+
+
+class NetworkXError(NetworkXException):
+    """Exception for a serious error in NetworkX"""
+
+
+class NetworkXPointlessConcept(NetworkXException):
+    """Raised when a null graph is provided as input to an algorithm
+    that cannot use it.
+
+    The null graph is sometimes considered a pointless concept [1]_,
+    thus the name of the exception.
+
+    References
+    ----------
+    .. [1] Harary, F. and Read, R. "Is the Null Graph a Pointless
+       Concept?"  In Graphs and Combinatorics Conference, George
+       Washington University.  New York: Springer-Verlag, 1973.
+
+    """
+
+
+class NetworkXAlgorithmError(NetworkXException):
+    """Exception for unexpected termination of algorithms."""
+
+
+class NetworkXUnfeasible(NetworkXAlgorithmError):
+    """Exception raised by algorithms trying to solve a problem
+    instance that has no feasible solution."""
+
+
+class NetworkXNoPath(NetworkXUnfeasible):
+    """Exception for algorithms that should return a path when running
+    on graphs where such a path does not exist."""
+
+
+class NetworkXNoCycle(NetworkXUnfeasible):
+    """Exception for algorithms that should return a cycle when running
+    on graphs where such a cycle does not exist."""
+
+
+class HasACycle(NetworkXException):
+    """Raised if a graph has a cycle when an algorithm expects that it
+    will have no cycles.
+
+    """
+
+
+class NetworkXUnbounded(NetworkXAlgorithmError):
+    """Exception raised by algorithms trying to solve a maximization
+    or a minimization problem instance that is unbounded."""
+
+
+class NetworkXNotImplemented(NetworkXException):
+    """Exception raised by algorithms not implemented for a type of graph."""
+
+
+class NodeNotFound(NetworkXException):
+    """Exception raised if requested node is not present in the graph"""
+
+
+class AmbiguousSolution(NetworkXException):
+    """Raised if more than one valid solution exists for an intermediary step
+    of an algorithm.
+
+    In the face of ambiguity, refuse the temptation to guess.
+    This may occur, for example, when trying to determine the
+    bipartite node sets in a disconnected bipartite graph when
+    computing bipartite matchings.
+
+    """
+
+
+class ExceededMaxIterations(NetworkXException):
+    """Raised if a loop iterates too many times without breaking.
+
+    This may occur, for example, in an algorithm that computes
+    progressively better approximations to a value but exceeds an
+    iteration bound specified by the user.
+
+    """
+
+
+class PowerIterationFailedConvergence(ExceededMaxIterations):
+    """Raised when the power iteration method fails to converge within a
+    specified iteration limit.
+
+    `num_iterations` is the number of iterations that have been
+    completed when this exception was raised.
+
+    """
+
+    def __init__(self, num_iterations, *args, **kw):
+        msg = f"power iteration failed to converge within {num_iterations} iterations"
+        exception_message = msg
+        superinit = super().__init__
+        superinit(self, exception_message, *args, **kw)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/__init__.py b/myenv/lib/python3.9/site-packages/networkx/generators/__init__.py
new file mode 100644
index 0000000..a9cb1e1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/__init__.py
@@ -0,0 +1,31 @@
+"""
+A package for generating various graphs in networkx.
+
+"""
+from networkx.generators.atlas import *
+from networkx.generators.classic import *
+from networkx.generators.cographs import *
+from networkx.generators.community import *
+from networkx.generators.degree_seq import *
+from networkx.generators.directed import *
+from networkx.generators.duplication import *
+from networkx.generators.ego import *
+from networkx.generators.expanders import *
+from networkx.generators.geometric import *
+from networkx.generators.internet_as_graphs import *
+from networkx.generators.intersection import *
+from networkx.generators.interval_graph import *
+from networkx.generators.joint_degree_seq import *
+from networkx.generators.lattice import *
+from networkx.generators.line import *
+from networkx.generators.mycielski import *
+from networkx.generators.nonisomorphic_trees import *
+from networkx.generators.random_clustered import *
+from networkx.generators.random_graphs import *
+from networkx.generators.small import *
+from networkx.generators.social import *
+from networkx.generators.sudoku import *
+from networkx.generators.spectral_graph_forge import *
+from networkx.generators.stochastic import *
+from networkx.generators.trees import *
+from networkx.generators.triads import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/atlas.dat.gz b/myenv/lib/python3.9/site-packages/networkx/generators/atlas.dat.gz
new file mode 100644
index 0000000..b0a9870
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/networkx/generators/atlas.dat.gz differ
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/atlas.py b/myenv/lib/python3.9/site-packages/networkx/generators/atlas.py
new file mode 100644
index 0000000..a5c7f49
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/atlas.py
@@ -0,0 +1,177 @@
+"""
+Generators for the small graph atlas.
+"""
+import gzip
+import os
+import os.path
+from itertools import islice
+
+import networkx as nx
+
+__all__ = ["graph_atlas", "graph_atlas_g"]
+
+#: The total number of graphs in the atlas.
+#:
+#: The graphs are labeled starting from 0 and extending to (but not
+#: including) this number.
+NUM_GRAPHS = 1253
+
+#: The absolute path representing the directory containing this file.
+THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+
+#: The path to the data file containing the graph edge lists.
+#:
+#: This is the absolute path of the gzipped text file containing the
+#: edge list for each graph in the atlas. The file contains one entry
+#: per graph in the atlas, in sequential order, starting from graph
+#: number 0 and extending through graph number 1252 (see
+#: :data:`NUM_GRAPHS`). Each entry looks like
+#:
+#: .. sourcecode:: text
+#:
+#:    GRAPH 6
+#:    NODES 3
+#:    0 1
+#:    0 2
+#:
+#: where the first two lines are the graph's index in the atlas and the
+#: number of nodes in the graph, and the remaining lines are the edge
+#: list.
+#:
+#: This file was generated from a Python list of graphs via code like
+#: the following::
+#:
+#:     import gzip
+#:     from networkx.generators.atlas import graph_atlas_g
+#:     from networkx.readwrite.edgelist import write_edgelist
+#:
+#:     with gzip.open('atlas.dat.gz', 'wb') as f:
+#:         for i, G in enumerate(graph_atlas_g()):
+#:             f.write(bytes(f'GRAPH {i}\n', encoding='utf-8'))
+#:             f.write(bytes(f'NODES {len(G)}\n', encoding='utf-8'))
+#:             write_edgelist(G, f, data=False)
+#:
+ATLAS_FILE = os.path.join(THIS_DIR, "atlas.dat.gz")
+
+
+def _generate_graphs():
+    """Sequentially read the file containing the edge list data for the
+    graphs in the atlas and generate the graphs one at a time.
+
+    This function reads the file given in :data:`.ATLAS_FILE`.
+
+    """
+    with gzip.open(ATLAS_FILE, "rb") as f:
+        line = f.readline()
+        while line and line.startswith(b"GRAPH"):
+            # The first two lines of each entry tell us the index of the
+            # graph in the list and the number of nodes in the graph.
+            # They look like this:
+            #
+            #     GRAPH 3
+            #     NODES 2
+            #
+            graph_index = int(line[6:].rstrip())
+            line = f.readline()
+            num_nodes = int(line[6:].rstrip())
+            # The remaining lines contain the edge list, until the next
+            # GRAPH line (or until the end of the file).
+            edgelist = []
+            line = f.readline()
+            while line and not line.startswith(b"GRAPH"):
+                edgelist.append(line.rstrip())
+                line = f.readline()
+            G = nx.Graph()
+            G.name = f"G{graph_index}"
+            G.add_nodes_from(range(num_nodes))
+            G.add_edges_from(tuple(map(int, e.split())) for e in edgelist)
+            yield G
+
+
+def graph_atlas(i):
+    """Returns graph number `i` from the Graph Atlas.
+
+    For more information, see :func:`.graph_atlas_g`.
+
+    Parameters
+    ----------
+    i : int
+        The index of the graph from the atlas to get. The graph at index
+        0 is assumed to be the null graph.
+
+    Returns
+    -------
+    list
+        A list of :class:`~networkx.Graph` objects, the one at index *i*
+        corresponding to the graph *i* in the Graph Atlas.
+
+    See also
+    --------
+    graph_atlas_g
+
+    Notes
+    -----
+    The time required by this function increases linearly with the
+    argument `i`, since it reads a large file sequentially in order to
+    generate the graph [1]_.
+
+    References
+    ----------
+    .. [1] Ronald C. Read and Robin J. Wilson, *An Atlas of Graphs*.
+           Oxford University Press, 1998.
+
+    """
+    if not (0 <= i < NUM_GRAPHS):
+        raise ValueError(f"index must be between 0 and {NUM_GRAPHS}")
+    return next(islice(_generate_graphs(), i, None))
+
+
+def graph_atlas_g():
+    """Returns the list of all graphs with up to seven nodes named in the
+    Graph Atlas.
+
+    The graphs are listed in increasing order by
+
+    1. number of nodes,
+    2. number of edges,
+    3. degree sequence (for example 111223 < 112222),
+    4. number of automorphisms,
+
+    in that order, with three exceptions as described in the *Notes*
+    section below. This causes the list to correspond with the index of
+    the graphs in the Graph Atlas [atlas]_, with the first graph,
+    ``G[0]``, being the null graph.
+
+    Returns
+    -------
+    list
+        A list of :class:`~networkx.Graph` objects, the one at index *i*
+        corresponding to the graph *i* in the Graph Atlas.
+
+    See also
+    --------
+    graph_atlas
+
+    Notes
+    -----
+    This function may be expensive in both time and space, since it
+    reads a large file sequentially in order to populate the list.
+
+    Although the NetworkX atlas functions match the order of graphs
+    given in the "Atlas of Graphs" book, there are (at least) three
+    errors in the ordering described in the book. The following three
+    pairs of nodes violate the lexicographically nondecreasing sorted
+    degree sequence rule:
+
+    - graphs 55 and 56 with degree sequences 001111 and 000112,
+    - graphs 1007 and 1008 with degree sequences 3333444 and 3333336,
+    - graphs 1012 and 1213 with degree sequences 1244555 and 1244456.
+
+    References
+    ----------
+    .. [atlas] Ronald C. Read and Robin J. Wilson,
+               *An Atlas of Graphs*.
+               Oxford University Press, 1998.
+
+    """
+    return list(_generate_graphs())
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/classic.py b/myenv/lib/python3.9/site-packages/networkx/generators/classic.py
new file mode 100644
index 0000000..d83062a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/classic.py
@@ -0,0 +1,780 @@
+"""Generators for some classic graphs.
+
+The typical graph builder function is called as follows:
+
+>>> G = nx.complete_graph(100)
+
+returning the complete graph on n nodes labeled 0, .., 99
+as a simple graph. Except for `empty_graph`, all the functions
+in this module return a Graph class (i.e. a simple, undirected graph).
+
+"""
+
+import itertools
+import numbers
+
+import networkx as nx
+from networkx.classes import Graph
+from networkx.exception import NetworkXError
+from networkx.utils import nodes_or_number, pairwise
+
+__all__ = [
+    "balanced_tree",
+    "barbell_graph",
+    "binomial_tree",
+    "complete_graph",
+    "complete_multipartite_graph",
+    "circular_ladder_graph",
+    "circulant_graph",
+    "cycle_graph",
+    "dorogovtsev_goltsev_mendes_graph",
+    "empty_graph",
+    "full_rary_tree",
+    "ladder_graph",
+    "lollipop_graph",
+    "null_graph",
+    "path_graph",
+    "star_graph",
+    "trivial_graph",
+    "turan_graph",
+    "wheel_graph",
+]
+
+
+# -------------------------------------------------------------------
+#   Some Classic Graphs
+# -------------------------------------------------------------------
+
+
+def _tree_edges(n, r):
+    if n == 0:
+        return
+    # helper function for trees
+    # yields edges in rooted tree at 0 with n nodes and branching ratio r
+    nodes = iter(range(n))
+    parents = [next(nodes)]  # stack of max length r
+    while parents:
+        source = parents.pop(0)
+        for i in range(r):
+            try:
+                target = next(nodes)
+                parents.append(target)
+                yield source, target
+            except StopIteration:
+                break
+
+
+def full_rary_tree(r, n, create_using=None):
+    """Creates a full r-ary tree of `n` nodes.
+
+    Sometimes called a k-ary, n-ary, or m-ary tree.
+    "... all non-leaf nodes have exactly r children and all levels
+    are full except for some rightmost position of the bottom level
+    (if a leaf at the bottom level is missing, then so are all of the
+    leaves to its right." [1]_
+
+    Parameters
+    ----------
+    r : int
+        branching factor of the tree
+    n : int
+        Number of nodes in the tree
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        An r-ary tree with n nodes
+
+    References
+    ----------
+    .. [1] An introduction to data structures and algorithms,
+           James Andrew Storer,  Birkhauser Boston 2001, (page 225).
+    """
+    G = empty_graph(n, create_using)
+    G.add_edges_from(_tree_edges(n, r))
+    return G
+
+
+def balanced_tree(r, h, create_using=None):
+    """Returns the perfectly balanced `r`-ary tree of height `h`.
+
+    Parameters
+    ----------
+    r : int
+        Branching factor of the tree; each node will have `r`
+        children.
+
+    h : int
+        Height of the tree.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : NetworkX graph
+        A balanced `r`-ary tree of height `h`.
+
+    Notes
+    -----
+    This is the rooted tree where all leaves are at distance `h` from
+    the root. The root has degree `r` and all other internal nodes
+    have degree `r + 1`.
+
+    Node labels are integers, starting from zero.
+
+    A balanced tree is also known as a *complete r-ary tree*.
+
+    """
+    # The number of nodes in the balanced tree is `1 + r + ... + r^h`,
+    # which is computed by using the closed-form formula for a geometric
+    # sum with ratio `r`. In the special case that `r` is 1, the number
+    # of nodes is simply `h + 1` (since the tree is actually a path
+    # graph).
+    if r == 1:
+        n = h + 1
+    else:
+        # This must be an integer if both `r` and `h` are integers. If
+        # they are not, we force integer division anyway.
+        n = (1 - r ** (h + 1)) // (1 - r)
+    return full_rary_tree(r, n, create_using=create_using)
+
+
+def barbell_graph(m1, m2, create_using=None):
+    """Returns the Barbell Graph: two complete graphs connected by a path.
+
+    For $m1 > 1$ and $m2 >= 0$.
+
+    Two identical complete graphs $K_{m1}$ form the left and right bells,
+    and are connected by a path $P_{m2}$.
+
+    The `2*m1+m2`  nodes are numbered
+        `0, ..., m1-1` for the left barbell,
+        `m1, ..., m1+m2-1` for the path,
+        and `m1+m2, ..., 2*m1+m2-1` for the right barbell.
+
+    The 3 subgraphs are joined via the edges `(m1-1, m1)` and
+    `(m1+m2-1, m1+m2)`. If `m2=0`, this is merely two complete
+    graphs joined together.
+
+    This graph is an extremal example in David Aldous
+    and Jim Fill's e-text on Random Walks on Graphs.
+
+    """
+    if m1 < 2:
+        raise NetworkXError("Invalid graph description, m1 should be >=2")
+    if m2 < 0:
+        raise NetworkXError("Invalid graph description, m2 should be >=0")
+
+    # left barbell
+    G = complete_graph(m1, create_using)
+    if G.is_directed():
+        raise NetworkXError("Directed Graph not supported")
+
+    # connecting path
+    G.add_nodes_from(range(m1, m1 + m2 - 1))
+    if m2 > 1:
+        G.add_edges_from(pairwise(range(m1, m1 + m2)))
+    # right barbell
+    G.add_edges_from(
+        (u, v) for u in range(m1 + m2, 2 * m1 + m2) for v in range(u + 1, 2 * m1 + m2)
+    )
+    # connect it up
+    G.add_edge(m1 - 1, m1)
+    if m2 > 0:
+        G.add_edge(m1 + m2 - 1, m1 + m2)
+    return G
+
+
+def binomial_tree(n, create_using=None):
+    """Returns the Binomial Tree of order n.
+
+    The binomial tree of order 0 consists of a single node. A binomial tree of order k
+    is defined recursively by linking two binomial trees of order k-1: the root of one is
+    the leftmost child of the root of the other.
+
+    Parameters
+    ----------
+    n : int
+        Order of the binomial tree.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : NetworkX graph
+        A binomial tree of $2^n$ nodes and $2^n - 1$ edges.
+
+    """
+    G = nx.empty_graph(1, create_using)
+
+    N = 1
+    for i in range(n):
+        # Use G.edges() to ensure 2-tuples. G.edges is 3-tuple for MultiGraph
+        edges = [(u + N, v + N) for (u, v) in G.edges()]
+        G.add_edges_from(edges)
+        G.add_edge(0, N)
+        N *= 2
+    return G
+
+
+@nodes_or_number(0)
+def complete_graph(n, create_using=None):
+    """Return the complete graph `K_n` with n nodes.
+
+    A complete graph on `n` nodes means that all pairs
+    of distinct nodes have an edge connecting them.
+
+    Parameters
+    ----------
+    n : int or iterable container of nodes
+        If n is an integer, nodes are from range(n).
+        If n is a container of nodes, those nodes appear in the graph.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(9)
+    >>> len(G)
+    9
+    >>> G.size()
+    36
+    >>> G = nx.complete_graph(range(11, 14))
+    >>> list(G.nodes())
+    [11, 12, 13]
+    >>> G = nx.complete_graph(4, nx.DiGraph())
+    >>> G.is_directed()
+    True
+
+    """
+    _, nodes = n
+    G = empty_graph(nodes, create_using)
+    if len(nodes) > 1:
+        if G.is_directed():
+            edges = itertools.permutations(nodes, 2)
+        else:
+            edges = itertools.combinations(nodes, 2)
+        G.add_edges_from(edges)
+    return G
+
+
+def circular_ladder_graph(n, create_using=None):
+    """Returns the circular ladder graph $CL_n$ of length n.
+
+    $CL_n$ consists of two concentric n-cycles in which
+    each of the n pairs of concentric nodes are joined by an edge.
+
+    Node labels are the integers 0 to n-1
+
+    """
+    G = ladder_graph(n, create_using)
+    G.add_edge(0, n - 1)
+    G.add_edge(n, 2 * n - 1)
+    return G
+
+
+def circulant_graph(n, offsets, create_using=None):
+    r"""Returns the circulant graph $Ci_n(x_1, x_2, ..., x_m)$ with $n$ nodes.
+
+    The circulant graph $Ci_n(x_1, ..., x_m)$ consists of $n$ nodes $0, ..., n-1$
+    such that node $i$ is connected to nodes $(i + x) \mod n$ and $(i - x) \mod n$
+    for all $x$ in $x_1, ..., x_m$. Thus $Ci_n(1)$ is a cycle graph.
+
+    Parameters
+    ----------
+    n : integer
+        The number of nodes in the graph.
+    offsets : list of integers
+        A list of node offsets, $x_1$ up to $x_m$, as described above.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    NetworkX Graph of type create_using
+
+    Examples
+    --------
+    Many well-known graph families are subfamilies of the circulant graphs;
+    for example, to create the cycle graph on n points, we connect every
+    node to nodes on either side (with offset plus or minus one). For n = 10,
+
+    >>> G = nx.circulant_graph(10, [1])
+    >>> edges = [
+    ...     (0, 9),
+    ...     (0, 1),
+    ...     (1, 2),
+    ...     (2, 3),
+    ...     (3, 4),
+    ...     (4, 5),
+    ...     (5, 6),
+    ...     (6, 7),
+    ...     (7, 8),
+    ...     (8, 9),
+    ... ]
+    ...
+    >>> sorted(edges) == sorted(G.edges())
+    True
+
+    Similarly, we can create the complete graph
+    on 5 points with the set of offsets [1, 2]:
+
+    >>> G = nx.circulant_graph(5, [1, 2])
+    >>> edges = [
+    ...     (0, 1),
+    ...     (0, 2),
+    ...     (0, 3),
+    ...     (0, 4),
+    ...     (1, 2),
+    ...     (1, 3),
+    ...     (1, 4),
+    ...     (2, 3),
+    ...     (2, 4),
+    ...     (3, 4),
+    ... ]
+    ...
+    >>> sorted(edges) == sorted(G.edges())
+    True
+
+    """
+    G = empty_graph(n, create_using)
+    for i in range(n):
+        for j in offsets:
+            G.add_edge(i, (i - j) % n)
+            G.add_edge(i, (i + j) % n)
+    return G
+
+
+@nodes_or_number(0)
+def cycle_graph(n, create_using=None):
+    """Returns the cycle graph $C_n$ of cyclically connected nodes.
+
+    $C_n$ is a path with its two end-nodes connected.
+
+    Parameters
+    ----------
+    n : int or iterable container of nodes
+        If n is an integer, nodes are from `range(n)`.
+        If n is a container of nodes, those nodes appear in the graph.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Notes
+    -----
+    If create_using is directed, the direction is in increasing order.
+
+    """
+    _, nodes = n
+    G = empty_graph(nodes, create_using)
+    G.add_edges_from(pairwise(nodes, cyclic=True))
+    return G
+
+
+def dorogovtsev_goltsev_mendes_graph(n, create_using=None):
+    """Returns the hierarchically constructed Dorogovtsev-Goltsev-Mendes graph.
+
+    n is the generation.
+    See: arXiv:/cond-mat/0112143 by Dorogovtsev, Goltsev and Mendes.
+
+    """
+    G = empty_graph(0, create_using)
+    if G.is_directed():
+        raise NetworkXError("Directed Graph not supported")
+    if G.is_multigraph():
+        raise NetworkXError("Multigraph not supported")
+
+    G.add_edge(0, 1)
+    if n == 0:
+        return G
+    new_node = 2  # next node to be added
+    for i in range(1, n + 1):  # iterate over number of generations.
+        last_generation_edges = list(G.edges())
+        number_of_edges_in_last_generation = len(last_generation_edges)
+        for j in range(0, number_of_edges_in_last_generation):
+            G.add_edge(new_node, last_generation_edges[j][0])
+            G.add_edge(new_node, last_generation_edges[j][1])
+            new_node += 1
+    return G
+
+
+@nodes_or_number(0)
+def empty_graph(n=0, create_using=None, default=Graph):
+    """Returns the empty graph with n nodes and zero edges.
+
+    Parameters
+    ----------
+    n : int or iterable container of nodes (default = 0)
+        If n is an integer, nodes are from `range(n)`.
+        If n is a container of nodes, those nodes appear in the graph.
+    create_using : Graph Instance, Constructor or None
+        Indicator of type of graph to return.
+        If a Graph-type instance, then clear and use it.
+        If None, use the `default` constructor.
+        If a constructor, call it to create an empty graph.
+    default : Graph constructor (optional, default = nx.Graph)
+        The constructor to use if create_using is None.
+        If None, then nx.Graph is used.
+        This is used when passing an unknown `create_using` value
+        through your home-grown function to `empty_graph` and
+        you want a default constructor other than nx.Graph.
+
+    Examples
+    --------
+    >>> G = nx.empty_graph(10)
+    >>> G.number_of_nodes()
+    10
+    >>> G.number_of_edges()
+    0
+    >>> G = nx.empty_graph("ABC")
+    >>> G.number_of_nodes()
+    3
+    >>> sorted(G)
+    ['A', 'B', 'C']
+
+    Notes
+    -----
+    The variable create_using should be a Graph Constructor or a
+    "graph"-like object. Constructors, e.g. `nx.Graph` or `nx.MultiGraph`
+    will be used to create the returned graph. "graph"-like objects
+    will be cleared (nodes and edges will be removed) and refitted as
+    an empty "graph" with nodes specified in n. This capability
+    is useful for specifying the class-nature of the resulting empty
+    "graph" (i.e. Graph, DiGraph, MyWeirdGraphClass, etc.).
+
+    The variable create_using has three main uses:
+    Firstly, the variable create_using can be used to create an
+    empty digraph, multigraph, etc.  For example,
+
+    >>> n = 10
+    >>> G = nx.empty_graph(n, create_using=nx.DiGraph)
+
+    will create an empty digraph on n nodes.
+
+    Secondly, one can pass an existing graph (digraph, multigraph,
+    etc.) via create_using. For example, if G is an existing graph
+    (resp. digraph, multigraph, etc.), then empty_graph(n, create_using=G)
+    will empty G (i.e. delete all nodes and edges using G.clear())
+    and then add n nodes and zero edges, and return the modified graph.
+
+    Thirdly, when constructing your home-grown graph creation function
+    you can use empty_graph to construct the graph by passing a user
+    defined create_using to empty_graph. In this case, if you want the
+    default constructor to be other than nx.Graph, specify `default`.
+
+    >>> def mygraph(n, create_using=None):
+    ...     G = nx.empty_graph(n, create_using, nx.MultiGraph)
+    ...     G.add_edges_from([(0, 1), (0, 1)])
+    ...     return G
+    >>> G = mygraph(3)
+    >>> G.is_multigraph()
+    True
+    >>> G = mygraph(3, nx.Graph)
+    >>> G.is_multigraph()
+    False
+
+    See also create_empty_copy(G).
+
+    """
+    if create_using is None:
+        G = default()
+    elif type(create_using) is type:
+        G = create_using()
+    elif not hasattr(create_using, "adj"):
+        raise TypeError("create_using is not a valid NetworkX graph type or instance")
+    else:
+        # create_using is a NetworkX style Graph
+        create_using.clear()
+        G = create_using
+
+    _, nodes = n
+    G.add_nodes_from(nodes)
+    return G
+
+
+def ladder_graph(n, create_using=None):
+    """Returns the Ladder graph of length n.
+
+    This is two paths of n nodes, with
+    each pair connected by a single edge.
+
+    Node labels are the integers 0 to 2*n - 1.
+
+    """
+    G = empty_graph(2 * n, create_using)
+    if G.is_directed():
+        raise NetworkXError("Directed Graph not supported")
+    G.add_edges_from(pairwise(range(n)))
+    G.add_edges_from(pairwise(range(n, 2 * n)))
+    G.add_edges_from((v, v + n) for v in range(n))
+    return G
+
+
+@nodes_or_number([0, 1])
+def lollipop_graph(m, n, create_using=None):
+    """Returns the Lollipop Graph; `K_m` connected to `P_n`.
+
+    This is the Barbell Graph without the right barbell.
+
+    Parameters
+    ----------
+    m, n : int or iterable container of nodes (default = 0)
+        If an integer, nodes are from `range(m)` and `range(m,m+n)`.
+        If a container, the entries are the coordinate of the node.
+
+        The nodes for m appear in the complete graph $K_m$ and the nodes
+        for n appear in the path $P_n$
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Notes
+    -----
+    The 2 subgraphs are joined via an edge (m-1, m).
+    If n=0, this is merely a complete graph.
+
+    (This graph is an extremal example in David Aldous and Jim
+    Fill's etext on Random Walks on Graphs.)
+
+    """
+    m, m_nodes = m
+    M = len(m_nodes)
+    if M < 2:
+        raise NetworkXError("Invalid description: m should indicate at least 2 nodes")
+
+    n, n_nodes = n
+    if isinstance(m, numbers.Integral) and isinstance(n, numbers.Integral):
+        n_nodes = list(range(M, M + n))
+    N = len(n_nodes)
+
+    # the ball
+    G = complete_graph(m_nodes, create_using)
+    if G.is_directed():
+        raise NetworkXError("Directed Graph not supported")
+
+    # the stick
+    G.add_nodes_from(n_nodes)
+    if N > 1:
+        G.add_edges_from(pairwise(n_nodes))
+
+    if len(G) != M + N:
+        raise NetworkXError("Nodes must be distinct in containers m and n")
+
+    # connect ball to stick
+    if M > 0 and N > 0:
+        G.add_edge(m_nodes[-1], n_nodes[0])
+    return G
+
+
+def null_graph(create_using=None):
+    """Returns the Null graph with no nodes or edges.
+
+    See empty_graph for the use of create_using.
+
+    """
+    G = empty_graph(0, create_using)
+    return G
+
+
+@nodes_or_number(0)
+def path_graph(n, create_using=None):
+    """Returns the Path graph `P_n` of linearly connected nodes.
+
+    Parameters
+    ----------
+    n : int or iterable
+        If an integer, nodes are 0 to n - 1.
+        If an iterable of nodes, in the order they appear in the path.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    """
+    _, nodes = n
+    G = empty_graph(nodes, create_using)
+    G.add_edges_from(pairwise(nodes))
+    return G
+
+
+@nodes_or_number(0)
+def star_graph(n, create_using=None):
+    """Return the star graph
+
+    The star graph consists of one center node connected to n outer nodes.
+
+    Parameters
+    ----------
+    n : int or iterable
+        If an integer, node labels are 0 to n with center 0.
+        If an iterable of nodes, the center is the first.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Notes
+    -----
+    The graph has n+1 nodes for integer n.
+    So star_graph(3) is the same as star_graph(range(4)).
+    """
+    n, nodes = n
+    if isinstance(n, numbers.Integral):
+        nodes.append(n)  # there should be n+1 nodes
+    G = empty_graph(nodes, create_using)
+    if G.is_directed():
+        raise NetworkXError("Directed Graph not supported")
+
+    if len(nodes) > 1:
+        hub, *spokes = nodes
+        G.add_edges_from((hub, node) for node in spokes)
+    return G
+
+
+def trivial_graph(create_using=None):
+    """Return the Trivial graph with one node (with label 0) and no edges."""
+    G = empty_graph(1, create_using)
+    return G
+
+
+def turan_graph(n, r):
+    r"""Return the Turan Graph
+
+    The Turan Graph is a complete multipartite graph on $n$ nodes
+    with $r$ disjoint subsets. That is, edges connect each node to
+    every node not in its subset.
+
+    Given $n$ and $r$, we create a complete multipartite graph with
+    $r-(n \mod r)$ partitions of size $n/r$, rounded down, and
+    $n \mod r$ partitions of size $n/r+1$, rounded down.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes.
+    r : int
+        The number of partitions.
+        Must be less than or equal to n.
+
+    Notes
+    -----
+    Must satisfy $1 <= r <= n$.
+    The graph has $(r-1)(n^2)/(2r)$ edges, rounded down.
+    """
+
+    if not 1 <= r <= n:
+        raise NetworkXError("Must satisfy 1 <= r <= n")
+
+    partitions = [n // r] * (r - (n % r)) + [n // r + 1] * (n % r)
+    G = complete_multipartite_graph(*partitions)
+    return G
+
+
+@nodes_or_number(0)
+def wheel_graph(n, create_using=None):
+    """Return the wheel graph
+
+    The wheel graph consists of a hub node connected to a cycle of (n-1) nodes.
+
+    Parameters
+    ----------
+    n : int or iterable
+        If an integer, node labels are 0 to n with center 0.
+        If an iterable of nodes, the center is the first.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Node labels are the integers 0 to n - 1.
+    """
+    _, nodes = n
+    G = empty_graph(nodes, create_using)
+    if G.is_directed():
+        raise NetworkXError("Directed Graph not supported")
+
+    if len(nodes) > 1:
+        hub, *rim = nodes
+        G.add_edges_from((hub, node) for node in rim)
+        if len(rim) > 1:
+            G.add_edges_from(pairwise(rim, cyclic=True))
+    return G
+
+
+def complete_multipartite_graph(*subset_sizes):
+    """Returns the complete multipartite graph with the specified subset sizes.
+
+    Parameters
+    ----------
+    subset_sizes : tuple of integers or tuple of node iterables
+       The arguments can either all be integer number of nodes or they
+       can all be iterables of nodes. If integers, they represent the
+       number of nodes in each subset of the multipartite graph.
+       If iterables, each is used to create the nodes for that subset.
+       The length of subset_sizes is the number of subsets.
+
+    Returns
+    -------
+    G : NetworkX Graph
+       Returns the complete multipartite graph with the specified subsets.
+
+       For each node, the node attribute 'subset' is an integer
+       indicating which subset contains the node.
+
+    Examples
+    --------
+    Creating a complete tripartite graph, with subsets of one, two, and three
+    nodes, respectively.
+
+        >>> G = nx.complete_multipartite_graph(1, 2, 3)
+        >>> [G.nodes[u]["subset"] for u in G]
+        [0, 1, 1, 2, 2, 2]
+        >>> list(G.edges(0))
+        [(0, 1), (0, 2), (0, 3), (0, 4), (0, 5)]
+        >>> list(G.edges(2))
+        [(2, 0), (2, 3), (2, 4), (2, 5)]
+        >>> list(G.edges(4))
+        [(4, 0), (4, 1), (4, 2)]
+
+        >>> G = nx.complete_multipartite_graph("a", "bc", "def")
+        >>> [G.nodes[u]["subset"] for u in sorted(G)]
+        [0, 1, 1, 2, 2, 2]
+
+    Notes
+    -----
+    This function generalizes several other graph builder functions.
+
+    - If no subset sizes are given, this returns the null graph.
+    - If a single subset size `n` is given, this returns the empty graph on
+      `n` nodes.
+    - If two subset sizes `m` and `n` are given, this returns the complete
+      bipartite graph on `m + n` nodes.
+    - If subset sizes `1` and `n` are given, this returns the star graph on
+      `n + 1` nodes.
+
+    See also
+    --------
+    complete_bipartite_graph
+    """
+    # The complete multipartite graph is an undirected simple graph.
+    G = Graph()
+
+    if len(subset_sizes) == 0:
+        return G
+
+    # set up subsets of nodes
+    try:
+        extents = pairwise(itertools.accumulate((0,) + subset_sizes))
+        subsets = [range(start, end) for start, end in extents]
+    except TypeError:
+        subsets = subset_sizes
+
+    # add nodes with subset attribute
+    # while checking that ints are not mixed with iterables
+    try:
+        for (i, subset) in enumerate(subsets):
+            G.add_nodes_from(subset, subset=i)
+    except TypeError as err:
+        raise NetworkXError("Arguments must be all ints or all iterables") from err
+
+    # Across subsets, all nodes should be adjacent.
+    # We can use itertools.combinations() because undirected.
+    for subset1, subset2 in itertools.combinations(subsets, 2):
+        G.add_edges_from(itertools.product(subset1, subset2))
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/cographs.py b/myenv/lib/python3.9/site-packages/networkx/generators/cographs.py
new file mode 100644
index 0000000..e876358
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/cographs.py
@@ -0,0 +1,66 @@
+r"""Generators for cographs
+
+A cograph is a graph containing no path on four vertices.
+Cographs or $P_4$-free graphs can be obtained from a single vertex
+by disjoint union and complementation operations.
+
+References
+----------
+.. [0] D.G. Corneil, H. Lerchs, L.Stewart Burlingham,
+    "Complement reducible graphs",
+    Discrete Applied Mathematics, Volume 3, Issue 3, 1981, Pages 163-174,
+    ISSN 0166-218X.
+"""
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = ["random_cograph"]
+
+
+@py_random_state(1)
+def random_cograph(n, seed=None):
+    r"""Returns a random cograph with $2 ^ n$ nodes.
+
+    A cograph is a graph containing no path on four vertices.
+    Cographs or $P_4$-free graphs can be obtained from a single vertex
+    by disjoint union and complementation operations.
+
+    This generator starts off from a single vertex and performes disjoint
+    union and full join operations on itself.
+    The decision on which operation will take place is random.
+
+    Parameters
+    ----------
+    n : int
+            The order of the cograph.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : A random graph containing no path on four vertices.
+
+    See Also
+    --------
+    full_join
+    union
+
+    References
+    ----------
+    .. [1] D.G. Corneil, H. Lerchs, L.Stewart Burlingham,
+       "Complement reducible graphs",
+       Discrete Applied Mathematics, Volume 3, Issue 3, 1981, Pages 163-174,
+       ISSN 0166-218X.
+    """
+    R = nx.empty_graph(1)
+
+    for i in range(n):
+        RR = nx.relabel_nodes(R.copy(), lambda x: x + len(R))
+
+        if seed.randint(0, 1) == 0:
+            R = nx.full_join(R, RR)
+        else:
+            R = nx.disjoint_union(R, RR)
+
+    return R
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/community.py b/myenv/lib/python3.9/site-packages/networkx/generators/community.py
new file mode 100644
index 0000000..f1f4d67
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/community.py
@@ -0,0 +1,1061 @@
+"""Generators for classes of graphs used in studying social networks."""
+import itertools
+import math
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = [
+    "caveman_graph",
+    "connected_caveman_graph",
+    "relaxed_caveman_graph",
+    "random_partition_graph",
+    "planted_partition_graph",
+    "gaussian_random_partition_graph",
+    "ring_of_cliques",
+    "windmill_graph",
+    "stochastic_block_model",
+    "LFR_benchmark_graph",
+]
+
+
+def caveman_graph(l, k):
+    """Returns a caveman graph of `l` cliques of size `k`.
+
+    Parameters
+    ----------
+    l : int
+      Number of cliques
+    k : int
+      Size of cliques
+
+    Returns
+    -------
+    G : NetworkX Graph
+      caveman graph
+
+    Notes
+    -----
+    This returns an undirected graph, it can be converted to a directed
+    graph using :func:`nx.to_directed`, or a multigraph using
+    ``nx.MultiGraph(nx.caveman_graph(l, k))``. Only the undirected version is
+    described in [1]_ and it is unclear which of the directed
+    generalizations is most useful.
+
+    Examples
+    --------
+    >>> G = nx.caveman_graph(3, 3)
+
+    See also
+    --------
+
+    connected_caveman_graph
+
+    References
+    ----------
+    .. [1] Watts, D. J. 'Networks, Dynamics, and the Small-World Phenomenon.'
+       Amer. J. Soc. 105, 493-527, 1999.
+    """
+    # l disjoint cliques of size k
+    G = nx.empty_graph(l * k)
+    if k > 1:
+        for start in range(0, l * k, k):
+            edges = itertools.combinations(range(start, start + k), 2)
+            G.add_edges_from(edges)
+    return G
+
+
+def connected_caveman_graph(l, k):
+    """Returns a connected caveman graph of `l` cliques of size `k`.
+
+    The connected caveman graph is formed by creating `n` cliques of size
+    `k`, then a single edge in each clique is rewired to a node in an
+    adjacent clique.
+
+    Parameters
+    ----------
+    l : int
+      number of cliques
+    k : int
+      size of cliques (k at least 2 or NetworkXError is raised)
+
+    Returns
+    -------
+    G : NetworkX Graph
+      connected caveman graph
+
+    Raises
+    ------
+    NetworkXError
+        If the size of cliques `k` is smaller than 2.
+
+    Notes
+    -----
+    This returns an undirected graph, it can be converted to a directed
+    graph using :func:`nx.to_directed`, or a multigraph using
+    ``nx.MultiGraph(nx.caveman_graph(l, k))``. Only the undirected version is
+    described in [1]_ and it is unclear which of the directed
+    generalizations is most useful.
+
+    Examples
+    --------
+    >>> G = nx.connected_caveman_graph(3, 3)
+
+    References
+    ----------
+    .. [1] Watts, D. J. 'Networks, Dynamics, and the Small-World Phenomenon.'
+       Amer. J. Soc. 105, 493-527, 1999.
+    """
+    if k < 2:
+        raise nx.NetworkXError(
+            "The size of cliques in a connected caveman graph " "must be at least 2."
+        )
+
+    G = nx.caveman_graph(l, k)
+    for start in range(0, l * k, k):
+        G.remove_edge(start, start + 1)
+        G.add_edge(start, (start - 1) % (l * k))
+    return G
+
+
+@py_random_state(3)
+def relaxed_caveman_graph(l, k, p, seed=None):
+    """Returns a relaxed caveman graph.
+
+    A relaxed caveman graph starts with `l` cliques of size `k`.  Edges are
+    then randomly rewired with probability `p` to link different cliques.
+
+    Parameters
+    ----------
+    l : int
+      Number of groups
+    k : int
+      Size of cliques
+    p : float
+      Probabilty of rewiring each edge.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : NetworkX Graph
+      Relaxed Caveman Graph
+
+    Raises
+    ------
+    NetworkXError
+     If p is not in [0,1]
+
+    Examples
+    --------
+    >>> G = nx.relaxed_caveman_graph(2, 3, 0.1, seed=42)
+
+    References
+    ----------
+    .. [1] Santo Fortunato, Community Detection in Graphs,
+       Physics Reports Volume 486, Issues 3-5, February 2010, Pages 75-174.
+       https://arxiv.org/abs/0906.0612
+    """
+    G = nx.caveman_graph(l, k)
+    nodes = list(G)
+    for (u, v) in G.edges():
+        if seed.random() < p:  # rewire the edge
+            x = seed.choice(nodes)
+            if G.has_edge(u, x):
+                continue
+            G.remove_edge(u, v)
+            G.add_edge(u, x)
+    return G
+
+
+@py_random_state(3)
+def random_partition_graph(sizes, p_in, p_out, seed=None, directed=False):
+    """Returns the random partition graph with a partition of sizes.
+
+    A partition graph is a graph of communities with sizes defined by
+    s in sizes. Nodes in the same group are connected with probability
+    p_in and nodes of different groups are connected with probability
+    p_out.
+
+    Parameters
+    ----------
+    sizes : list of ints
+      Sizes of groups
+    p_in : float
+      probability of edges with in groups
+    p_out : float
+      probability of edges between groups
+    directed : boolean optional, default=False
+      Whether to create a directed graph
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : NetworkX Graph or DiGraph
+      random partition graph of size sum(gs)
+
+    Raises
+    ------
+    NetworkXError
+      If p_in or p_out is not in [0,1]
+
+    Examples
+    --------
+    >>> G = nx.random_partition_graph([10, 10, 10], 0.25, 0.01)
+    >>> len(G)
+    30
+    >>> partition = G.graph["partition"]
+    >>> len(partition)
+    3
+
+    Notes
+    -----
+    This is a generalization of the planted-l-partition described in
+    [1]_.  It allows for the creation of groups of any size.
+
+    The partition is store as a graph attribute 'partition'.
+
+    References
+    ----------
+    .. [1] Santo Fortunato 'Community Detection in Graphs' Physical Reports
+       Volume 486, Issue 3-5 p. 75-174. https://arxiv.org/abs/0906.0612
+    """
+    # Use geometric method for O(n+m) complexity algorithm
+    # partition = nx.community_sets(nx.get_node_attributes(G, 'affiliation'))
+    if not 0.0 <= p_in <= 1.0:
+        raise nx.NetworkXError("p_in must be in [0,1]")
+    if not 0.0 <= p_out <= 1.0:
+        raise nx.NetworkXError("p_out must be in [0,1]")
+
+    # create connection matrix
+    num_blocks = len(sizes)
+    p = [[p_out for s in range(num_blocks)] for r in range(num_blocks)]
+    for r in range(num_blocks):
+        p[r][r] = p_in
+
+    return stochastic_block_model(
+        sizes,
+        p,
+        nodelist=None,
+        seed=seed,
+        directed=directed,
+        selfloops=False,
+        sparse=True,
+    )
+
+
+@py_random_state(4)
+def planted_partition_graph(l, k, p_in, p_out, seed=None, directed=False):
+    """Returns the planted l-partition graph.
+
+    This model partitions a graph with n=l*k vertices in
+    l groups with k vertices each. Vertices of the same
+    group are linked with a probability p_in, and vertices
+    of different groups are linked with probability p_out.
+
+    Parameters
+    ----------
+    l : int
+      Number of groups
+    k : int
+      Number of vertices in each group
+    p_in : float
+      probability of connecting vertices within a group
+    p_out : float
+      probability of connected vertices between groups
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    directed : bool,optional (default=False)
+      If True return a directed graph
+
+    Returns
+    -------
+    G : NetworkX Graph or DiGraph
+      planted l-partition graph
+
+    Raises
+    ------
+    NetworkXError
+      If p_in,p_out are not in [0,1] or
+
+    Examples
+    --------
+    >>> G = nx.planted_partition_graph(4, 3, 0.5, 0.1, seed=42)
+
+    See Also
+    --------
+    random_partition_model
+
+    References
+    ----------
+    .. [1] A. Condon, R.M. Karp, Algorithms for graph partitioning
+        on the planted partition model,
+        Random Struct. Algor. 18 (2001) 116-140.
+
+    .. [2] Santo Fortunato 'Community Detection in Graphs' Physical Reports
+       Volume 486, Issue 3-5 p. 75-174. https://arxiv.org/abs/0906.0612
+    """
+    return random_partition_graph([k] * l, p_in, p_out, seed=seed, directed=directed)
+
+
+@py_random_state(6)
+def gaussian_random_partition_graph(n, s, v, p_in, p_out, directed=False, seed=None):
+    """Generate a Gaussian random partition graph.
+
+    A Gaussian random partition graph is created by creating k partitions
+    each with a size drawn from a normal distribution with mean s and variance
+    s/v. Nodes are connected within clusters with probability p_in and
+    between clusters with probability p_out[1]
+
+    Parameters
+    ----------
+    n : int
+      Number of nodes in the graph
+    s : float
+      Mean cluster size
+    v : float
+      Shape parameter. The variance of cluster size distribution is s/v.
+    p_in : float
+      Probabilty of intra cluster connection.
+    p_out : float
+      Probability of inter cluster connection.
+    directed : boolean, optional default=False
+      Whether to create a directed graph or not
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : NetworkX Graph or DiGraph
+      gaussian random partition graph
+
+    Raises
+    ------
+    NetworkXError
+      If s is > n
+      If p_in or p_out is not in [0,1]
+
+    Notes
+    -----
+    Note the number of partitions is dependent on s,v and n, and that the
+    last partition may be considerably smaller, as it is sized to simply
+    fill out the nodes [1]
+
+    See Also
+    --------
+    random_partition_graph
+
+    Examples
+    --------
+    >>> G = nx.gaussian_random_partition_graph(100, 10, 10, 0.25, 0.1)
+    >>> len(G)
+    100
+
+    References
+    ----------
+    .. [1] Ulrik Brandes, Marco Gaertler, Dorothea Wagner,
+       Experiments on Graph Clustering Algorithms,
+       In the proceedings of the 11th Europ. Symp. Algorithms, 2003.
+    """
+    if s > n:
+        raise nx.NetworkXError("s must be <= n")
+    assigned = 0
+    sizes = []
+    while True:
+        size = int(seed.gauss(s, s / v + 0.5))
+        if size < 1:  # how to handle 0 or negative sizes?
+            continue
+        if assigned + size >= n:
+            sizes.append(n - assigned)
+            break
+        assigned += size
+        sizes.append(size)
+    return random_partition_graph(sizes, p_in, p_out, seed=seed, directed=directed)
+
+
+def ring_of_cliques(num_cliques, clique_size):
+    """Defines a "ring of cliques" graph.
+
+    A ring of cliques graph is consisting of cliques, connected through single
+    links. Each clique is a complete graph.
+
+    Parameters
+    ----------
+    num_cliques : int
+        Number of cliques
+    clique_size : int
+        Size of cliques
+
+    Returns
+    -------
+    G : NetworkX Graph
+        ring of cliques graph
+
+    Raises
+    ------
+    NetworkXError
+        If the number of cliques is lower than 2 or
+        if the size of cliques is smaller than 2.
+
+    Examples
+    --------
+    >>> G = nx.ring_of_cliques(8, 4)
+
+    See Also
+    --------
+    connected_caveman_graph
+
+    Notes
+    -----
+    The `connected_caveman_graph` graph removes a link from each clique to
+    connect it with the next clique. Instead, the `ring_of_cliques` graph
+    simply adds the link without removing any link from the cliques.
+    """
+    if num_cliques < 2:
+        raise nx.NetworkXError("A ring of cliques must have at least " "two cliques")
+    if clique_size < 2:
+        raise nx.NetworkXError("The cliques must have at least two nodes")
+
+    G = nx.Graph()
+    for i in range(num_cliques):
+        edges = itertools.combinations(
+            range(i * clique_size, i * clique_size + clique_size), 2
+        )
+        G.add_edges_from(edges)
+        G.add_edge(
+            i * clique_size + 1, (i + 1) * clique_size % (num_cliques * clique_size)
+        )
+    return G
+
+
+def windmill_graph(n, k):
+    """Generate a windmill graph.
+    A windmill graph is a graph of `n` cliques each of size `k` that are all
+    joined at one node.
+    It can be thought of as taking a disjoint union of `n` cliques of size `k`,
+    selecting one point from each, and contracting all of the selected points.
+    Alternatively, one could generate `n` cliques of size `k-1` and one node
+    that is connected to all other nodes in the graph.
+
+    Parameters
+    ----------
+    n : int
+        Number of cliques
+    k : int
+        Size of cliques
+
+    Returns
+    -------
+    G : NetworkX Graph
+        windmill graph with n cliques of size k
+
+    Raises
+    ------
+    NetworkXError
+        If the number of cliques is less than two
+        If the size of the cliques are less than two
+
+    Examples
+    --------
+    >>> G = nx.windmill_graph(4, 5)
+
+    Notes
+    -----
+    The node labeled `0` will be the node connected to all other nodes.
+    Note that windmill graphs are usually denoted `Wd(k,n)`, so the parameters
+    are in the opposite order as the parameters of this method.
+    """
+    if n < 2:
+        msg = "A windmill graph must have at least two cliques"
+        raise nx.NetworkXError(msg)
+    if k < 2:
+        raise nx.NetworkXError("The cliques must have at least two nodes")
+
+    G = nx.disjoint_union_all(
+        itertools.chain(
+            [nx.complete_graph(k)], (nx.complete_graph(k - 1) for _ in range(n - 1))
+        )
+    )
+    G.add_edges_from((0, i) for i in range(k, G.number_of_nodes()))
+    return G
+
+
+@py_random_state(3)
+def stochastic_block_model(
+    sizes, p, nodelist=None, seed=None, directed=False, selfloops=False, sparse=True
+):
+    """Returns a stochastic block model graph.
+
+    This model partitions the nodes in blocks of arbitrary sizes, and places
+    edges between pairs of nodes independently, with a probability that depends
+    on the blocks.
+
+    Parameters
+    ----------
+    sizes : list of ints
+        Sizes of blocks
+    p : list of list of floats
+        Element (r,s) gives the density of edges going from the nodes
+        of group r to nodes of group s.
+        p must match the number of groups (len(sizes) == len(p)),
+        and it must be symmetric if the graph is undirected.
+    nodelist : list, optional
+        The block tags are assigned according to the node identifiers
+        in nodelist. If nodelist is None, then the ordering is the
+        range [0,sum(sizes)-1].
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    directed : boolean optional, default=False
+        Whether to create a directed graph or not.
+    selfloops : boolean optional, default=False
+        Whether to include self-loops or not.
+    sparse: boolean optional, default=True
+        Use the sparse heuristic to speed up the generator.
+
+    Returns
+    -------
+    g : NetworkX Graph or DiGraph
+        Stochastic block model graph of size sum(sizes)
+
+    Raises
+    ------
+    NetworkXError
+      If probabilities are not in [0,1].
+      If the probability matrix is not square (directed case).
+      If the probability matrix is not symmetric (undirected case).
+      If the sizes list does not match nodelist or the probability matrix.
+      If nodelist contains duplicate.
+
+    Examples
+    --------
+    >>> sizes = [75, 75, 300]
+    >>> probs = [[0.25, 0.05, 0.02], [0.05, 0.35, 0.07], [0.02, 0.07, 0.40]]
+    >>> g = nx.stochastic_block_model(sizes, probs, seed=0)
+    >>> len(g)
+    450
+    >>> H = nx.quotient_graph(g, g.graph["partition"], relabel=True)
+    >>> for v in H.nodes(data=True):
+    ...     print(round(v[1]["density"], 3))
+    ...
+    0.245
+    0.348
+    0.405
+    >>> for v in H.edges(data=True):
+    ...     print(round(1.0 * v[2]["weight"] / (sizes[v[0]] * sizes[v[1]]), 3))
+    ...
+    0.051
+    0.022
+    0.07
+
+    See Also
+    --------
+    random_partition_graph
+    planted_partition_graph
+    gaussian_random_partition_graph
+    gnp_random_graph
+
+    References
+    ----------
+    .. [1] Holland, P. W., Laskey, K. B., & Leinhardt, S.,
+           "Stochastic blockmodels: First steps",
+           Social networks, 5(2), 109-137, 1983.
+    """
+    # Check if dimensions match
+    if len(sizes) != len(p):
+        raise nx.NetworkXException("'sizes' and 'p' do not match.")
+    # Check for probability symmetry (undirected) and shape (directed)
+    for row in p:
+        if len(p) != len(row):
+            raise nx.NetworkXException("'p' must be a square matrix.")
+    if not directed:
+        p_transpose = [list(i) for i in zip(*p)]
+        for i in zip(p, p_transpose):
+            for j in zip(i[0], i[1]):
+                if abs(j[0] - j[1]) > 1e-08:
+                    raise nx.NetworkXException("'p' must be symmetric.")
+    # Check for probability range
+    for row in p:
+        for prob in row:
+            if prob < 0 or prob > 1:
+                raise nx.NetworkXException("Entries of 'p' not in [0,1].")
+    # Check for nodelist consistency
+    if nodelist is not None:
+        if len(nodelist) != sum(sizes):
+            raise nx.NetworkXException("'nodelist' and 'sizes' do not match.")
+        if len(nodelist) != len(set(nodelist)):
+            raise nx.NetworkXException("nodelist contains duplicate.")
+    else:
+        nodelist = range(0, sum(sizes))
+
+    # Setup the graph conditionally to the directed switch.
+    block_range = range(len(sizes))
+    if directed:
+        g = nx.DiGraph()
+        block_iter = itertools.product(block_range, block_range)
+    else:
+        g = nx.Graph()
+        block_iter = itertools.combinations_with_replacement(block_range, 2)
+    # Split nodelist in a partition (list of sets).
+    size_cumsum = [sum(sizes[0:x]) for x in range(0, len(sizes) + 1)]
+    g.graph["partition"] = [
+        set(nodelist[size_cumsum[x] : size_cumsum[x + 1]])
+        for x in range(0, len(size_cumsum) - 1)
+    ]
+    # Setup nodes and graph name
+    for block_id, nodes in enumerate(g.graph["partition"]):
+        for node in nodes:
+            g.add_node(node, block=block_id)
+
+    g.name = "stochastic_block_model"
+
+    # Test for edge existence
+    parts = g.graph["partition"]
+    for i, j in block_iter:
+        if i == j:
+            if directed:
+                if selfloops:
+                    edges = itertools.product(parts[i], parts[i])
+                else:
+                    edges = itertools.permutations(parts[i], 2)
+            else:
+                edges = itertools.combinations(parts[i], 2)
+                if selfloops:
+                    edges = itertools.chain(edges, zip(parts[i], parts[i]))
+            for e in edges:
+                if seed.random() < p[i][j]:
+                    g.add_edge(*e)
+        else:
+            edges = itertools.product(parts[i], parts[j])
+        if sparse:
+            if p[i][j] == 1:  # Test edges cases p_ij = 0 or 1
+                for e in edges:
+                    g.add_edge(*e)
+            elif p[i][j] > 0:
+                while True:
+                    try:
+                        logrand = math.log(seed.random())
+                        skip = math.floor(logrand / math.log(1 - p[i][j]))
+                        # consume "skip" edges
+                        next(itertools.islice(edges, skip, skip), None)
+                        e = next(edges)
+                        g.add_edge(*e)  # __safe
+                    except StopIteration:
+                        break
+        else:
+            for e in edges:
+                if seed.random() < p[i][j]:
+                    g.add_edge(*e)  # __safe
+    return g
+
+
+def _zipf_rv_below(gamma, xmin, threshold, seed):
+    """Returns a random value chosen from the bounded Zipf distribution.
+
+    Repeatedly draws values from the Zipf distribution until the
+    threshold is met, then returns that value.
+    """
+    result = nx.utils.zipf_rv(gamma, xmin, seed)
+    while result > threshold:
+        result = nx.utils.zipf_rv(gamma, xmin, seed)
+    return result
+
+
+def _powerlaw_sequence(gamma, low, high, condition, length, max_iters, seed):
+    """Returns a list of numbers obeying a constrained power law distribution.
+
+    ``gamma`` and ``low`` are the parameters for the Zipf distribution.
+
+    ``high`` is the maximum allowed value for values draw from the Zipf
+    distribution. For more information, see :func:`_zipf_rv_below`.
+
+    ``condition`` and ``length`` are Boolean-valued functions on
+    lists. While generating the list, random values are drawn and
+    appended to the list until ``length`` is satisfied by the created
+    list. Once ``condition`` is satisfied, the sequence generated in
+    this way is returned.
+
+    ``max_iters`` indicates the number of times to generate a list
+    satisfying ``length``. If the number of iterations exceeds this
+    value, :exc:`~networkx.exception.ExceededMaxIterations` is raised.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    """
+    for i in range(max_iters):
+        seq = []
+        while not length(seq):
+            seq.append(_zipf_rv_below(gamma, low, high, seed))
+        if condition(seq):
+            return seq
+    raise nx.ExceededMaxIterations("Could not create power law sequence")
+
+
+def _hurwitz_zeta(x, q, tolerance):
+    """The Hurwitz zeta function, or the Riemann zeta function of two arguments.
+
+    ``x`` must be greater than one and ``q`` must be positive.
+
+    This function repeatedly computes subsequent partial sums until
+    convergence, as decided by ``tolerance``.
+    """
+    z = 0
+    z_prev = -float("inf")
+    k = 0
+    while abs(z - z_prev) > tolerance:
+        z_prev = z
+        z += 1 / ((k + q) ** x)
+        k += 1
+    return z
+
+
+def _generate_min_degree(gamma, average_degree, max_degree, tolerance, max_iters):
+    """Returns a minimum degree from the given average degree."""
+    # Defines zeta function whether or not Scipy is available
+    try:
+        from scipy.special import zeta
+    except ImportError:
+
+        def zeta(x, q):
+            return _hurwitz_zeta(x, q, tolerance)
+
+    min_deg_top = max_degree
+    min_deg_bot = 1
+    min_deg_mid = (min_deg_top - min_deg_bot) / 2 + min_deg_bot
+    itrs = 0
+    mid_avg_deg = 0
+    while abs(mid_avg_deg - average_degree) > tolerance:
+        if itrs > max_iters:
+            raise nx.ExceededMaxIterations("Could not match average_degree")
+        mid_avg_deg = 0
+        for x in range(int(min_deg_mid), max_degree + 1):
+            mid_avg_deg += (x ** (-gamma + 1)) / zeta(gamma, min_deg_mid)
+        if mid_avg_deg > average_degree:
+            min_deg_top = min_deg_mid
+            min_deg_mid = (min_deg_top - min_deg_bot) / 2 + min_deg_bot
+        else:
+            min_deg_bot = min_deg_mid
+            min_deg_mid = (min_deg_top - min_deg_bot) / 2 + min_deg_bot
+        itrs += 1
+    # return int(min_deg_mid + 0.5)
+    return round(min_deg_mid)
+
+
+def _generate_communities(degree_seq, community_sizes, mu, max_iters, seed):
+    """Returns a list of sets, each of which represents a community.
+
+    ``degree_seq`` is the degree sequence that must be met by the
+    graph.
+
+    ``community_sizes`` is the community size distribution that must be
+    met by the generated list of sets.
+
+    ``mu`` is a float in the interval [0, 1] indicating the fraction of
+    intra-community edges incident to each node.
+
+    ``max_iters`` is the number of times to try to add a node to a
+    community. This must be greater than the length of
+    ``degree_seq``, otherwise this function will always fail. If
+    the number of iterations exceeds this value,
+    :exc:`~networkx.exception.ExceededMaxIterations` is raised.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    The communities returned by this are sets of integers in the set {0,
+    ..., *n* - 1}, where *n* is the length of ``degree_seq``.
+
+    """
+    # This assumes the nodes in the graph will be natural numbers.
+    result = [set() for _ in community_sizes]
+    n = len(degree_seq)
+    free = list(range(n))
+    for i in range(max_iters):
+        v = free.pop()
+        c = seed.choice(range(len(community_sizes)))
+        # s = int(degree_seq[v] * (1 - mu) + 0.5)
+        s = round(degree_seq[v] * (1 - mu))
+        # If the community is large enough, add the node to the chosen
+        # community. Otherwise, return it to the list of unaffiliated
+        # nodes.
+        if s < community_sizes[c]:
+            result[c].add(v)
+        else:
+            free.append(v)
+        # If the community is too big, remove a node from it.
+        if len(result[c]) > community_sizes[c]:
+            free.append(result[c].pop())
+        if not free:
+            return result
+    msg = "Could not assign communities; try increasing min_community"
+    raise nx.ExceededMaxIterations(msg)
+
+
+@py_random_state(11)
+def LFR_benchmark_graph(
+    n,
+    tau1,
+    tau2,
+    mu,
+    average_degree=None,
+    min_degree=None,
+    max_degree=None,
+    min_community=None,
+    max_community=None,
+    tol=1.0e-7,
+    max_iters=500,
+    seed=None,
+):
+    r"""Returns the LFR benchmark graph.
+
+    This algorithm proceeds as follows:
+
+    1) Find a degree sequence with a power law distribution, and minimum
+       value ``min_degree``, which has approximate average degree
+       ``average_degree``. This is accomplished by either
+
+       a) specifying ``min_degree`` and not ``average_degree``,
+       b) specifying ``average_degree`` and not ``min_degree``, in which
+          case a suitable minimum degree will be found.
+
+       ``max_degree`` can also be specified, otherwise it will be set to
+       ``n``. Each node *u* will have $\mu \mathrm{deg}(u)$ edges
+       joining it to nodes in communities other than its own and $(1 -
+       \mu) \mathrm{deg}(u)$ edges joining it to nodes in its own
+       community.
+    2) Generate community sizes according to a power law distribution
+       with exponent ``tau2``. If ``min_community`` and
+       ``max_community`` are not specified they will be selected to be
+       ``min_degree`` and ``max_degree``, respectively.  Community sizes
+       are generated until the sum of their sizes equals ``n``.
+    3) Each node will be randomly assigned a community with the
+       condition that the community is large enough for the node's
+       intra-community degree, $(1 - \mu) \mathrm{deg}(u)$ as
+       described in step 2. If a community grows too large, a random node
+       will be selected for reassignment to a new community, until all
+       nodes have been assigned a community.
+    4) Each node *u* then adds $(1 - \mu) \mathrm{deg}(u)$
+       intra-community edges and $\mu \mathrm{deg}(u)$ inter-community
+       edges.
+
+    Parameters
+    ----------
+    n : int
+        Number of nodes in the created graph.
+
+    tau1 : float
+        Power law exponent for the degree distribution of the created
+        graph. This value must be strictly greater than one.
+
+    tau2 : float
+        Power law exponent for the community size distribution in the
+        created graph. This value must be strictly greater than one.
+
+    mu : float
+        Fraction of inter-community edges incident to each node. This
+        value must be in the interval [0, 1].
+
+    average_degree : float
+        Desired average degree of nodes in the created graph. This value
+        must be in the interval [0, *n*]. Exactly one of this and
+        ``min_degree`` must be specified, otherwise a
+        :exc:`NetworkXError` is raised.
+
+    min_degree : int
+        Minimum degree of nodes in the created graph. This value must be
+        in the interval [0, *n*]. Exactly one of this and
+        ``average_degree`` must be specified, otherwise a
+        :exc:`NetworkXError` is raised.
+
+    max_degree : int
+        Maximum degree of nodes in the created graph. If not specified,
+        this is set to ``n``, the total number of nodes in the graph.
+
+    min_community : int
+        Minimum size of communities in the graph. If not specified, this
+        is set to ``min_degree``.
+
+    max_community : int
+        Maximum size of communities in the graph. If not specified, this
+        is set to ``n``, the total number of nodes in the graph.
+
+    tol : float
+        Tolerance when comparing floats, specifically when comparing
+        average degree values.
+
+    max_iters : int
+        Maximum number of iterations to try to create the community sizes,
+        degree distribution, and community affiliations.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : NetworkX graph
+        The LFR benchmark graph generated according to the specified
+        parameters.
+
+        Each node in the graph has a node attribute ``'community'`` that
+        stores the community (that is, the set of nodes) that includes
+        it.
+
+    Raises
+    ------
+    NetworkXError
+        If any of the parameters do not meet their upper and lower bounds:
+
+        - ``tau1`` and ``tau2`` must be strictly greater than 1.
+        - ``mu`` must be in [0, 1].
+        - ``max_degree`` must be in {1, ..., *n*}.
+        - ``min_community`` and ``max_community`` must be in {0, ...,
+          *n*}.
+
+        If not exactly one of ``average_degree`` and ``min_degree`` is
+        specified.
+
+        If ``min_degree`` is not specified and a suitable ``min_degree``
+        cannot be found.
+
+    ExceededMaxIterations
+        If a valid degree sequence cannot be created within
+        ``max_iters`` number of iterations.
+
+        If a valid set of community sizes cannot be created within
+        ``max_iters`` number of iterations.
+
+        If a valid community assignment cannot be created within ``10 *
+        n * max_iters`` number of iterations.
+
+    Examples
+    --------
+    Basic usage::
+
+        >>> from networkx.generators.community import LFR_benchmark_graph
+        >>> n = 250
+        >>> tau1 = 3
+        >>> tau2 = 1.5
+        >>> mu = 0.1
+        >>> G = LFR_benchmark_graph(
+        ...     n, tau1, tau2, mu, average_degree=5, min_community=20, seed=10
+        ... )
+
+    Continuing the example above, you can get the communities from the
+    node attributes of the graph::
+
+        >>> communities = {frozenset(G.nodes[v]["community"]) for v in G}
+
+    Notes
+    -----
+    This algorithm differs slightly from the original way it was
+    presented in [1].
+
+    1) Rather than connecting the graph via a configuration model then
+       rewiring to match the intra-community and inter-community
+       degrees, we do this wiring explicitly at the end, which should be
+       equivalent.
+    2) The code posted on the author's website [2] calculates the random
+       power law distributed variables and their average using
+       continuous approximations, whereas we use the discrete
+       distributions here as both degree and community size are
+       discrete.
+
+    Though the authors describe the algorithm as quite robust, testing
+    during development indicates that a somewhat narrower parameter set
+    is likely to successfully produce a graph. Some suggestions have
+    been provided in the event of exceptions.
+
+    References
+    ----------
+    .. [1] "Benchmark graphs for testing community detection algorithms",
+           Andrea Lancichinetti, Santo Fortunato, and Filippo Radicchi,
+           Phys. Rev. E 78, 046110 2008
+    .. [2] https://www.santofortunato.net/resources
+
+    """
+    # Perform some basic parameter validation.
+    if not tau1 > 1:
+        raise nx.NetworkXError("tau1 must be greater than one")
+    if not tau2 > 1:
+        raise nx.NetworkXError("tau2 must be greater than one")
+    if not 0 <= mu <= 1:
+        raise nx.NetworkXError("mu must be in the interval [0, 1]")
+
+    # Validate parameters for generating the degree sequence.
+    if max_degree is None:
+        max_degree = n
+    elif not 0 < max_degree <= n:
+        raise nx.NetworkXError("max_degree must be in the interval (0, n]")
+    if not ((min_degree is None) ^ (average_degree is None)):
+        raise nx.NetworkXError(
+            "Must assign exactly one of min_degree and" " average_degree"
+        )
+    if min_degree is None:
+        min_degree = _generate_min_degree(
+            tau1, average_degree, max_degree, tol, max_iters
+        )
+
+    # Generate a degree sequence with a power law distribution.
+    low, high = min_degree, max_degree
+
+    def condition(seq):
+        return sum(seq) % 2 == 0
+
+    def length(seq):
+        return len(seq) >= n
+
+    deg_seq = _powerlaw_sequence(tau1, low, high, condition, length, max_iters, seed)
+
+    # Validate parameters for generating the community size sequence.
+    if min_community is None:
+        min_community = min(deg_seq)
+    if max_community is None:
+        max_community = max(deg_seq)
+
+    # Generate a community size sequence with a power law distribution.
+    #
+    # TODO The original code incremented the number of iterations each
+    # time a new Zipf random value was drawn from the distribution. This
+    # differed from the way the number of iterations was incremented in
+    # `_powerlaw_degree_sequence`, so this code was changed to match
+    # that one. As a result, this code is allowed many more chances to
+    # generate a valid community size sequence.
+    low, high = min_community, max_community
+
+    def condition(seq):
+        return sum(seq) == n
+
+    def length(seq):
+        return sum(seq) >= n
+
+    comms = _powerlaw_sequence(tau2, low, high, condition, length, max_iters, seed)
+
+    # Generate the communities based on the given degree sequence and
+    # community sizes.
+    max_iters *= 10 * n
+    communities = _generate_communities(deg_seq, comms, mu, max_iters, seed)
+
+    # Finally, generate the benchmark graph based on the given
+    # communities, joining nodes according to the intra- and
+    # inter-community degrees.
+    G = nx.Graph()
+    G.add_nodes_from(range(n))
+    for c in communities:
+        for u in c:
+            while G.degree(u) < round(deg_seq[u] * (1 - mu)):
+                v = seed.choice(list(c))
+                G.add_edge(u, v)
+            while G.degree(u) < deg_seq[u]:
+                v = seed.choice(range(n))
+                if v not in c:
+                    G.add_edge(u, v)
+            G.nodes[u]["community"] = c
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/degree_seq.py b/myenv/lib/python3.9/site-packages/networkx/generators/degree_seq.py
new file mode 100644
index 0000000..3c83e06
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/degree_seq.py
@@ -0,0 +1,861 @@
+"""Generate graphs with a given degree sequence or expected degree sequence.
+"""
+
+import heapq
+import math
+from itertools import chain, combinations, zip_longest
+from operator import itemgetter
+
+import networkx as nx
+from networkx.utils import py_random_state, random_weighted_sample
+
+__all__ = [
+    "configuration_model",
+    "directed_configuration_model",
+    "expected_degree_graph",
+    "havel_hakimi_graph",
+    "directed_havel_hakimi_graph",
+    "degree_sequence_tree",
+    "random_degree_sequence_graph",
+]
+
+chaini = chain.from_iterable
+
+
+def _to_stublist(degree_sequence):
+    """Returns a list of degree-repeated node numbers.
+
+    ``degree_sequence`` is a list of nonnegative integers representing
+    the degrees of nodes in a graph.
+
+    This function returns a list of node numbers with multiplicities
+    according to the given degree sequence. For example, if the first
+    element of ``degree_sequence`` is ``3``, then the first node number,
+    ``0``, will appear at the head of the returned list three times. The
+    node numbers are assumed to be the numbers zero through
+    ``len(degree_sequence) - 1``.
+
+    Examples
+    --------
+
+    >>> degree_sequence = [1, 2, 3]
+    >>> _to_stublist(degree_sequence)
+    [0, 1, 1, 2, 2, 2]
+
+    If a zero appears in the sequence, that means the node exists but
+    has degree zero, so that number will be skipped in the returned
+    list::
+
+    >>> degree_sequence = [2, 0, 1]
+    >>> _to_stublist(degree_sequence)
+    [0, 0, 2]
+
+    """
+    return list(chaini([n] * d for n, d in enumerate(degree_sequence)))
+
+
+def _configuration_model(
+    deg_sequence, create_using, directed=False, in_deg_sequence=None, seed=None
+):
+    """Helper function for generating either undirected or directed
+    configuration model graphs.
+
+    ``deg_sequence`` is a list of nonnegative integers representing the
+    degree of the node whose label is the index of the list element.
+
+    ``create_using`` see :func:`~networkx.empty_graph`.
+
+    ``directed`` and ``in_deg_sequence`` are required if you want the
+    returned graph to be generated using the directed configuration
+    model algorithm. If ``directed`` is ``False``, then ``deg_sequence``
+    is interpreted as the degree sequence of an undirected graph and
+    ``in_deg_sequence`` is ignored. Otherwise, if ``directed`` is
+    ``True``, then ``deg_sequence`` is interpreted as the out-degree
+    sequence and ``in_deg_sequence`` as the in-degree sequence of a
+    directed graph.
+
+    .. note::
+
+       ``deg_sequence`` and ``in_deg_sequence`` need not be the same
+       length.
+
+    ``seed`` is a random.Random or numpy.random.RandomState instance
+
+    This function returns a graph, directed if and only if ``directed``
+    is ``True``, generated according to the configuration model
+    algorithm. For more information on the algorithm, see the
+    :func:`configuration_model` or :func:`directed_configuration_model`
+    functions.
+
+    """
+    n = len(deg_sequence)
+    G = nx.empty_graph(n, create_using)
+    # If empty, return the null graph immediately.
+    if n == 0:
+        return G
+    # Build a list of available degree-repeated nodes.  For example,
+    # for degree sequence [3, 2, 1, 1, 1], the "stub list" is
+    # initially [0, 0, 0, 1, 1, 2, 3, 4], that is, node 0 has degree
+    # 3 and thus is repeated 3 times, etc.
+    #
+    # Also, shuffle the stub list in order to get a random sequence of
+    # node pairs.
+    if directed:
+        pairs = zip_longest(deg_sequence, in_deg_sequence, fillvalue=0)
+        # Unzip the list of pairs into a pair of lists.
+        out_deg, in_deg = zip(*pairs)
+
+        out_stublist = _to_stublist(out_deg)
+        in_stublist = _to_stublist(in_deg)
+
+        seed.shuffle(out_stublist)
+        seed.shuffle(in_stublist)
+    else:
+        stublist = _to_stublist(deg_sequence)
+        # Choose a random balanced bipartition of the stublist, which
+        # gives a random pairing of nodes. In this implementation, we
+        # shuffle the list and then split it in half.
+        n = len(stublist)
+        half = n // 2
+        seed.shuffle(stublist)
+        out_stublist, in_stublist = stublist[:half], stublist[half:]
+    G.add_edges_from(zip(out_stublist, in_stublist))
+    return G
+
+
+@py_random_state(2)
+def configuration_model(deg_sequence, create_using=None, seed=None):
+    """Returns a random graph with the given degree sequence.
+
+    The configuration model generates a random pseudograph (graph with
+    parallel edges and self loops) by randomly assigning edges to
+    match the given degree sequence.
+
+    Parameters
+    ----------
+    deg_sequence :  list of nonnegative integers
+        Each list entry corresponds to the degree of a node.
+    create_using : NetworkX graph constructor, optional (default MultiGraph)
+        Graph type to create. If graph instance, then cleared before populated.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : MultiGraph
+        A graph with the specified degree sequence.
+        Nodes are labeled starting at 0 with an index
+        corresponding to the position in deg_sequence.
+
+    Raises
+    ------
+    NetworkXError
+        If the degree sequence does not have an even sum.
+
+    See Also
+    --------
+    is_graphical
+
+    Notes
+    -----
+    As described by Newman [1]_.
+
+    A non-graphical degree sequence (not realizable by some simple
+    graph) is allowed since this function returns graphs with self
+    loops and parallel edges.  An exception is raised if the degree
+    sequence does not have an even sum.
+
+    This configuration model construction process can lead to
+    duplicate edges and loops.  You can remove the self-loops and
+    parallel edges (see below) which will likely result in a graph
+    that doesn't have the exact degree sequence specified.
+
+    The density of self-loops and parallel edges tends to decrease as
+    the number of nodes increases. However, typically the number of
+    self-loops will approach a Poisson distribution with a nonzero mean,
+    and similarly for the number of parallel edges.  Consider a node
+    with *k* stubs. The probability of being joined to another stub of
+    the same node is basically (*k* - *1*) / *N*, where *k* is the
+    degree and *N* is the number of nodes. So the probability of a
+    self-loop scales like *c* / *N* for some constant *c*. As *N* grows,
+    this means we expect *c* self-loops. Similarly for parallel edges.
+
+    References
+    ----------
+    .. [1] M.E.J. Newman, "The structure and function of complex networks",
+       SIAM REVIEW 45-2, pp 167-256, 2003.
+
+    Examples
+    --------
+    You can create a degree sequence following a particular distribution
+    by using the one of the distribution functions in
+    :mod:`~networkx.utils.random_sequence` (or one of your own). For
+    example, to create an undirected multigraph on one hundred nodes
+    with degree sequence chosen from the power law distribution:
+
+    >>> sequence = nx.random_powerlaw_tree_sequence(100, tries=5000)
+    >>> G = nx.configuration_model(sequence)
+    >>> len(G)
+    100
+    >>> actual_degrees = [d for v, d in G.degree()]
+    >>> actual_degrees == sequence
+    True
+
+    The returned graph is a multigraph, which may have parallel
+    edges. To remove any parallel edges from the returned graph:
+
+    >>> G = nx.Graph(G)
+
+    Similarly, to remove self-loops:
+
+    >>> G.remove_edges_from(nx.selfloop_edges(G))
+
+    """
+    if sum(deg_sequence) % 2 != 0:
+        msg = "Invalid degree sequence: sum of degrees must be even, not odd"
+        raise nx.NetworkXError(msg)
+
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXNotImplemented("not implemented for directed graphs")
+
+    G = _configuration_model(deg_sequence, G, seed=seed)
+
+    return G
+
+
+@py_random_state(3)
+def directed_configuration_model(
+    in_degree_sequence, out_degree_sequence, create_using=None, seed=None
+):
+    """Returns a directed_random graph with the given degree sequences.
+
+    The configuration model generates a random directed pseudograph
+    (graph with parallel edges and self loops) by randomly assigning
+    edges to match the given degree sequences.
+
+    Parameters
+    ----------
+    in_degree_sequence :  list of nonnegative integers
+       Each list entry corresponds to the in-degree of a node.
+    out_degree_sequence :  list of nonnegative integers
+       Each list entry corresponds to the out-degree of a node.
+    create_using : NetworkX graph constructor, optional (default MultiDiGraph)
+        Graph type to create. If graph instance, then cleared before populated.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : MultiDiGraph
+        A graph with the specified degree sequences.
+        Nodes are labeled starting at 0 with an index
+        corresponding to the position in deg_sequence.
+
+    Raises
+    ------
+    NetworkXError
+        If the degree sequences do not have the same sum.
+
+    See Also
+    --------
+    configuration_model
+
+    Notes
+    -----
+    Algorithm as described by Newman [1]_.
+
+    A non-graphical degree sequence (not realizable by some simple
+    graph) is allowed since this function returns graphs with self
+    loops and parallel edges.  An exception is raised if the degree
+    sequences does not have the same sum.
+
+    This configuration model construction process can lead to
+    duplicate edges and loops.  You can remove the self-loops and
+    parallel edges (see below) which will likely result in a graph
+    that doesn't have the exact degree sequence specified.  This
+    "finite-size effect" decreases as the size of the graph increases.
+
+    References
+    ----------
+    .. [1] Newman, M. E. J. and Strogatz, S. H. and Watts, D. J.
+       Random graphs with arbitrary degree distributions and their applications
+       Phys. Rev. E, 64, 026118 (2001)
+
+    Examples
+    --------
+    One can modify the in- and out-degree sequences from an existing
+    directed graph in order to create a new directed graph. For example,
+    here we modify the directed path graph:
+
+    >>> D = nx.DiGraph([(0, 1), (1, 2), (2, 3)])
+    >>> din = list(d for n, d in D.in_degree())
+    >>> dout = list(d for n, d in D.out_degree())
+    >>> din.append(1)
+    >>> dout[0] = 2
+    >>> # We now expect an edge from node 0 to a new node, node 3.
+    ... D = nx.directed_configuration_model(din, dout)
+
+    The returned graph is a directed multigraph, which may have parallel
+    edges. To remove any parallel edges from the returned graph:
+
+    >>> D = nx.DiGraph(D)
+
+    Similarly, to remove self-loops:
+
+    >>> D.remove_edges_from(nx.selfloop_edges(D))
+
+    """
+    if sum(in_degree_sequence) != sum(out_degree_sequence):
+        msg = "Invalid degree sequences: sequences must have equal sums"
+        raise nx.NetworkXError(msg)
+
+    if create_using is None:
+        create_using = nx.MultiDiGraph
+
+    G = _configuration_model(
+        out_degree_sequence,
+        create_using,
+        directed=True,
+        in_deg_sequence=in_degree_sequence,
+        seed=seed,
+    )
+
+    name = "directed configuration_model {} nodes {} edges"
+    return G
+
+
+@py_random_state(1)
+def expected_degree_graph(w, seed=None, selfloops=True):
+    r"""Returns a random graph with given expected degrees.
+
+    Given a sequence of expected degrees $W=(w_0,w_1,\ldots,w_{n-1})$
+    of length $n$ this algorithm assigns an edge between node $u$ and
+    node $v$ with probability
+
+    .. math::
+
+       p_{uv} = \frac{w_u w_v}{\sum_k w_k} .
+
+    Parameters
+    ----------
+    w : list
+        The list of expected degrees.
+    selfloops: bool (default=True)
+        Set to False to remove the possibility of self-loop edges.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    Graph
+
+    Examples
+    --------
+    >>> z = [10 for i in range(100)]
+    >>> G = nx.expected_degree_graph(z)
+
+    Notes
+    -----
+    The nodes have integer labels corresponding to index of expected degrees
+    input sequence.
+
+    The complexity of this algorithm is $\mathcal{O}(n+m)$ where $n$ is the
+    number of nodes and $m$ is the expected number of edges.
+
+    The model in [1]_ includes the possibility of self-loop edges.
+    Set selfloops=False to produce a graph without self loops.
+
+    For finite graphs this model doesn't produce exactly the given
+    expected degree sequence.  Instead the expected degrees are as
+    follows.
+
+    For the case without self loops (selfloops=False),
+
+    .. math::
+
+       E[deg(u)] = \sum_{v \ne u} p_{uv}
+                = w_u \left( 1 - \frac{w_u}{\sum_k w_k} \right) .
+
+
+    NetworkX uses the standard convention that a self-loop edge counts 2
+    in the degree of a node, so with self loops (selfloops=True),
+
+    .. math::
+
+       E[deg(u)] =  \sum_{v \ne u} p_{uv}  + 2 p_{uu}
+                = w_u \left( 1 + \frac{w_u}{\sum_k w_k} \right) .
+
+    References
+    ----------
+    .. [1] Fan Chung and L. Lu, Connected components in random graphs with
+       given expected degree sequences, Ann. Combinatorics, 6,
+       pp. 125-145, 2002.
+    .. [2] Joel Miller and Aric Hagberg,
+       Efficient generation of networks with given expected degrees,
+       in Algorithms and Models for the Web-Graph (WAW 2011),
+       Alan Frieze, Paul Horn, and Paweł Prałat (Eds), LNCS 6732,
+       pp. 115-126, 2011.
+    """
+    n = len(w)
+    G = nx.empty_graph(n)
+
+    # If there are no nodes are no edges in the graph, return the empty graph.
+    if n == 0 or max(w) == 0:
+        return G
+
+    rho = 1 / sum(w)
+    # Sort the weights in decreasing order. The original order of the
+    # weights dictates the order of the (integer) node labels, so we
+    # need to remember the permutation applied in the sorting.
+    order = sorted(enumerate(w), key=itemgetter(1), reverse=True)
+    mapping = {c: u for c, (u, v) in enumerate(order)}
+    seq = [v for u, v in order]
+    last = n
+    if not selfloops:
+        last -= 1
+    for u in range(last):
+        v = u
+        if not selfloops:
+            v += 1
+        factor = seq[u] * rho
+        p = min(seq[v] * factor, 1)
+        while v < n and p > 0:
+            if p != 1:
+                r = seed.random()
+                v += math.floor(math.log(r, 1 - p))
+            if v < n:
+                q = min(seq[v] * factor, 1)
+                if seed.random() < q / p:
+                    G.add_edge(mapping[u], mapping[v])
+                v += 1
+                p = q
+    return G
+
+
+def havel_hakimi_graph(deg_sequence, create_using=None):
+    """Returns a simple graph with given degree sequence constructed
+    using the Havel-Hakimi algorithm.
+
+    Parameters
+    ----------
+    deg_sequence: list of integers
+        Each integer corresponds to the degree of a node (need not be sorted).
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+        Graph type to create. If graph instance, then cleared before populated.
+        Directed graphs are not allowed.
+
+    Raises
+    ------
+    NetworkXException
+        For a non-graphical degree sequence (i.e. one
+        not realizable by some simple graph).
+
+    Notes
+    -----
+    The Havel-Hakimi algorithm constructs a simple graph by
+    successively connecting the node of highest degree to other nodes
+    of highest degree, resorting remaining nodes by degree, and
+    repeating the process. The resulting graph has a high
+    degree-associativity.  Nodes are labeled 1,.., len(deg_sequence),
+    corresponding to their position in deg_sequence.
+
+    The basic algorithm is from Hakimi [1]_ and was generalized by
+    Kleitman and Wang [2]_.
+
+    References
+    ----------
+    .. [1] Hakimi S., On Realizability of a Set of Integers as
+       Degrees of the Vertices of a Linear Graph. I,
+       Journal of SIAM, 10(3), pp. 496-506 (1962)
+    .. [2] Kleitman D.J. and Wang D.L.
+       Algorithms for Constructing Graphs and Digraphs with Given Valences
+       and Factors  Discrete Mathematics, 6(1), pp. 79-88 (1973)
+    """
+    if not nx.is_graphical(deg_sequence):
+        raise nx.NetworkXError("Invalid degree sequence")
+
+    p = len(deg_sequence)
+    G = nx.empty_graph(p, create_using)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed graphs are not supported")
+    num_degs = [[] for i in range(p)]
+    dmax, dsum, n = 0, 0, 0
+    for d in deg_sequence:
+        # Process only the non-zero integers
+        if d > 0:
+            num_degs[d].append(n)
+            dmax, dsum, n = max(dmax, d), dsum + d, n + 1
+    # Return graph if no edges
+    if n == 0:
+        return G
+
+    modstubs = [(0, 0)] * (dmax + 1)
+    # Successively reduce degree sequence by removing the maximum degree
+    while n > 0:
+        # Retrieve the maximum degree in the sequence
+        while len(num_degs[dmax]) == 0:
+            dmax -= 1
+        # If there are not enough stubs to connect to, then the sequence is
+        # not graphical
+        if dmax > n - 1:
+            raise nx.NetworkXError("Non-graphical integer sequence")
+
+        # Remove largest stub in list
+        source = num_degs[dmax].pop()
+        n -= 1
+        # Reduce the next dmax largest stubs
+        mslen = 0
+        k = dmax
+        for i in range(dmax):
+            while len(num_degs[k]) == 0:
+                k -= 1
+            target = num_degs[k].pop()
+            G.add_edge(source, target)
+            n -= 1
+            if k > 1:
+                modstubs[mslen] = (k - 1, target)
+                mslen += 1
+        # Add back to the list any nonzero stubs that were removed
+        for i in range(mslen):
+            (stubval, stubtarget) = modstubs[i]
+            num_degs[stubval].append(stubtarget)
+            n += 1
+
+    return G
+
+
+def directed_havel_hakimi_graph(in_deg_sequence, out_deg_sequence, create_using=None):
+    """Returns a directed graph with the given degree sequences.
+
+    Parameters
+    ----------
+    in_deg_sequence :  list of integers
+        Each list entry corresponds to the in-degree of a node.
+    out_deg_sequence : list of integers
+        Each list entry corresponds to the out-degree of a node.
+    create_using : NetworkX graph constructor, optional (default DiGraph)
+        Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : DiGraph
+        A graph with the specified degree sequences.
+        Nodes are labeled starting at 0 with an index
+        corresponding to the position in deg_sequence
+
+    Raises
+    ------
+    NetworkXError
+        If the degree sequences are not digraphical.
+
+    See Also
+    --------
+    configuration_model
+
+    Notes
+    -----
+    Algorithm as described by Kleitman and Wang [1]_.
+
+    References
+    ----------
+    .. [1] D.J. Kleitman and D.L. Wang
+       Algorithms for Constructing Graphs and Digraphs with Given Valences
+       and Factors Discrete Mathematics, 6(1), pp. 79-88 (1973)
+    """
+    in_deg_sequence = nx.utils.make_list_of_ints(in_deg_sequence)
+    out_deg_sequence = nx.utils.make_list_of_ints(out_deg_sequence)
+
+    # Process the sequences and form two heaps to store degree pairs with
+    # either zero or nonzero out degrees
+    sumin, sumout = 0, 0
+    nin, nout = len(in_deg_sequence), len(out_deg_sequence)
+    maxn = max(nin, nout)
+    G = nx.empty_graph(maxn, create_using, default=nx.DiGraph)
+    if maxn == 0:
+        return G
+    maxin = 0
+    stubheap, zeroheap = [], []
+    for n in range(maxn):
+        in_deg, out_deg = 0, 0
+        if n < nout:
+            out_deg = out_deg_sequence[n]
+        if n < nin:
+            in_deg = in_deg_sequence[n]
+        if in_deg < 0 or out_deg < 0:
+            raise nx.NetworkXError(
+                "Invalid degree sequences. Sequence values must be positive."
+            )
+        sumin, sumout, maxin = sumin + in_deg, sumout + out_deg, max(maxin, in_deg)
+        if in_deg > 0:
+            stubheap.append((-1 * out_deg, -1 * in_deg, n))
+        elif out_deg > 0:
+            zeroheap.append((-1 * out_deg, n))
+    if sumin != sumout:
+        raise nx.NetworkXError(
+            "Invalid degree sequences. Sequences must have equal sums."
+        )
+    heapq.heapify(stubheap)
+    heapq.heapify(zeroheap)
+
+    modstubs = [(0, 0, 0)] * (maxin + 1)
+    # Successively reduce degree sequence by removing the maximum
+    while stubheap:
+        # Remove first value in the sequence with a non-zero in degree
+        (freeout, freein, target) = heapq.heappop(stubheap)
+        freein *= -1
+        if freein > len(stubheap) + len(zeroheap):
+            raise nx.NetworkXError("Non-digraphical integer sequence")
+
+        # Attach arcs from the nodes with the most stubs
+        mslen = 0
+        for i in range(freein):
+            if zeroheap and (not stubheap or stubheap[0][0] > zeroheap[0][0]):
+                (stubout, stubsource) = heapq.heappop(zeroheap)
+                stubin = 0
+            else:
+                (stubout, stubin, stubsource) = heapq.heappop(stubheap)
+            if stubout == 0:
+                raise nx.NetworkXError("Non-digraphical integer sequence")
+            G.add_edge(stubsource, target)
+            # Check if source is now totally connected
+            if stubout + 1 < 0 or stubin < 0:
+                modstubs[mslen] = (stubout + 1, stubin, stubsource)
+                mslen += 1
+
+        # Add the nodes back to the heaps that still have available stubs
+        for i in range(mslen):
+            stub = modstubs[i]
+            if stub[1] < 0:
+                heapq.heappush(stubheap, stub)
+            else:
+                heapq.heappush(zeroheap, (stub[0], stub[2]))
+        if freeout < 0:
+            heapq.heappush(zeroheap, (freeout, target))
+
+    return G
+
+
+def degree_sequence_tree(deg_sequence, create_using=None):
+    """Make a tree for the given degree sequence.
+
+    A tree has #nodes-#edges=1 so
+    the degree sequence must have
+    len(deg_sequence)-sum(deg_sequence)/2=1
+    """
+    # The sum of the degree sequence must be even (for any undirected graph).
+    degree_sum = sum(deg_sequence)
+    if degree_sum % 2 != 0:
+        msg = "Invalid degree sequence: sum of degrees must be even, not odd"
+        raise nx.NetworkXError(msg)
+    if len(deg_sequence) - degree_sum // 2 != 1:
+        msg = (
+            "Invalid degree sequence: tree must have number of nodes equal"
+            " to one less than the number of edges"
+        )
+        raise nx.NetworkXError(msg)
+    G = nx.empty_graph(0, create_using)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    # Sort all degrees greater than 1 in decreasing order.
+    #
+    # TODO Does this need to be sorted in reverse order?
+    deg = sorted((s for s in deg_sequence if s > 1), reverse=True)
+
+    # make path graph as backbone
+    n = len(deg) + 2
+    nx.add_path(G, range(n))
+    last = n
+
+    # add the leaves
+    for source in range(1, n - 1):
+        nedges = deg.pop() - 2
+        for target in range(last, last + nedges):
+            G.add_edge(source, target)
+        last += nedges
+
+    # in case we added one too many
+    if len(G) > len(deg_sequence):
+        G.remove_node(0)
+    return G
+
+
+@py_random_state(1)
+def random_degree_sequence_graph(sequence, seed=None, tries=10):
+    r"""Returns a simple random graph with the given degree sequence.
+
+    If the maximum degree $d_m$ in the sequence is $O(m^{1/4})$ then the
+    algorithm produces almost uniform random graphs in $O(m d_m)$ time
+    where $m$ is the number of edges.
+
+    Parameters
+    ----------
+    sequence :  list of integers
+        Sequence of degrees
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    tries : int, optional
+        Maximum number of tries to create a graph
+
+    Returns
+    -------
+    G : Graph
+        A graph with the specified degree sequence.
+        Nodes are labeled starting at 0 with an index
+        corresponding to the position in the sequence.
+
+    Raises
+    ------
+    NetworkXUnfeasible
+        If the degree sequence is not graphical.
+    NetworkXError
+        If a graph is not produced in specified number of tries
+
+    See Also
+    --------
+    is_graphical, configuration_model
+
+    Notes
+    -----
+    The generator algorithm [1]_ is not guaranteed to produce a graph.
+
+    References
+    ----------
+    .. [1] Moshen Bayati, Jeong Han Kim, and Amin Saberi,
+       A sequential algorithm for generating random graphs.
+       Algorithmica, Volume 58, Number 4, 860-910,
+       DOI: 10.1007/s00453-009-9340-1
+
+    Examples
+    --------
+    >>> sequence = [1, 2, 2, 3]
+    >>> G = nx.random_degree_sequence_graph(sequence, seed=42)
+    >>> sorted(d for n, d in G.degree())
+    [1, 2, 2, 3]
+    """
+    DSRG = DegreeSequenceRandomGraph(sequence, seed)
+    for try_n in range(tries):
+        try:
+            return DSRG.generate()
+        except nx.NetworkXUnfeasible:
+            pass
+    raise nx.NetworkXError(f"failed to generate graph in {tries} tries")
+
+
+class DegreeSequenceRandomGraph:
+    # class to generate random graphs with a given degree sequence
+    # use random_degree_sequence_graph()
+    def __init__(self, degree, rng):
+        if not nx.is_graphical(degree):
+            raise nx.NetworkXUnfeasible("degree sequence is not graphical")
+        self.rng = rng
+        self.degree = list(degree)
+        # node labels are integers 0,...,n-1
+        self.m = sum(self.degree) / 2.0  # number of edges
+        try:
+            self.dmax = max(self.degree)  # maximum degree
+        except ValueError:
+            self.dmax = 0
+
+    def generate(self):
+        # remaining_degree is mapping from int->remaining degree
+        self.remaining_degree = dict(enumerate(self.degree))
+        # add all nodes to make sure we get isolated nodes
+        self.graph = nx.Graph()
+        self.graph.add_nodes_from(self.remaining_degree)
+        # remove zero degree nodes
+        for n, d in list(self.remaining_degree.items()):
+            if d == 0:
+                del self.remaining_degree[n]
+        if len(self.remaining_degree) > 0:
+            # build graph in three phases according to how many unmatched edges
+            self.phase1()
+            self.phase2()
+            self.phase3()
+        return self.graph
+
+    def update_remaining(self, u, v, aux_graph=None):
+        # decrement remaining nodes, modify auxiliary graph if in phase3
+        if aux_graph is not None:
+            # remove edges from auxiliary graph
+            aux_graph.remove_edge(u, v)
+        if self.remaining_degree[u] == 1:
+            del self.remaining_degree[u]
+            if aux_graph is not None:
+                aux_graph.remove_node(u)
+        else:
+            self.remaining_degree[u] -= 1
+        if self.remaining_degree[v] == 1:
+            del self.remaining_degree[v]
+            if aux_graph is not None:
+                aux_graph.remove_node(v)
+        else:
+            self.remaining_degree[v] -= 1
+
+    def p(self, u, v):
+        # degree probability
+        return 1 - self.degree[u] * self.degree[v] / (4.0 * self.m)
+
+    def q(self, u, v):
+        # remaining degree probability
+        norm = max(self.remaining_degree.values()) ** 2
+        return self.remaining_degree[u] * self.remaining_degree[v] / norm
+
+    def suitable_edge(self):
+        """Returns True if and only if an arbitrary remaining node can
+        potentially be joined with some other remaining node.
+
+        """
+        nodes = iter(self.remaining_degree)
+        u = next(nodes)
+        return any(v not in self.graph[u] for v in nodes)
+
+    def phase1(self):
+        # choose node pairs from (degree) weighted distribution
+        rem_deg = self.remaining_degree
+        while sum(rem_deg.values()) >= 2 * self.dmax**2:
+            u, v = sorted(random_weighted_sample(rem_deg, 2, self.rng))
+            if self.graph.has_edge(u, v):
+                continue
+            if self.rng.random() < self.p(u, v):  # accept edge
+                self.graph.add_edge(u, v)
+                self.update_remaining(u, v)
+
+    def phase2(self):
+        # choose remaining nodes uniformly at random and use rejection sampling
+        remaining_deg = self.remaining_degree
+        rng = self.rng
+        while len(remaining_deg) >= 2 * self.dmax:
+            while True:
+                u, v = sorted(rng.sample(list(remaining_deg.keys()), 2))
+                if self.graph.has_edge(u, v):
+                    continue
+                if rng.random() < self.q(u, v):
+                    break
+            if rng.random() < self.p(u, v):  # accept edge
+                self.graph.add_edge(u, v)
+                self.update_remaining(u, v)
+
+    def phase3(self):
+        # build potential remaining edges and choose with rejection sampling
+        potential_edges = combinations(self.remaining_degree, 2)
+        # build auxiliary graph of potential edges not already in graph
+        H = nx.Graph(
+            [(u, v) for (u, v) in potential_edges if not self.graph.has_edge(u, v)]
+        )
+        rng = self.rng
+        while self.remaining_degree:
+            if not self.suitable_edge():
+                raise nx.NetworkXUnfeasible("no suitable edges left")
+            while True:
+                u, v = sorted(rng.choice(list(H.edges())))
+                if rng.random() < self.q(u, v):
+                    break
+            if rng.random() < self.p(u, v):  # accept edge
+                self.graph.add_edge(u, v)
+                self.update_remaining(u, v, aux_graph=H)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/directed.py b/myenv/lib/python3.9/site-packages/networkx/generators/directed.py
new file mode 100644
index 0000000..21afab4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/directed.py
@@ -0,0 +1,530 @@
+"""
+Generators for some directed graphs, including growing network (GN) graphs and
+scale-free graphs.
+
+"""
+
+import numbers
+from collections import Counter
+
+import networkx as nx
+from networkx.generators.classic import empty_graph
+from networkx.utils import discrete_sequence, py_random_state, weighted_choice
+
+__all__ = [
+    "gn_graph",
+    "gnc_graph",
+    "gnr_graph",
+    "random_k_out_graph",
+    "scale_free_graph",
+]
+
+
+@py_random_state(3)
+def gn_graph(n, kernel=None, create_using=None, seed=None):
+    """Returns the growing network (GN) digraph with `n` nodes.
+
+    The GN graph is built by adding nodes one at a time with a link to one
+    previously added node.  The target node for the link is chosen with
+    probability based on degree.  The default attachment kernel is a linear
+    function of the degree of a node.
+
+    The graph is always a (directed) tree.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes for the generated graph.
+    kernel : function
+        The attachment kernel.
+    create_using : NetworkX graph constructor, optional (default DiGraph)
+        Graph type to create. If graph instance, then cleared before populated.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Examples
+    --------
+    To create the undirected GN graph, use the :meth:`~DiGraph.to_directed`
+    method::
+
+    >>> D = nx.gn_graph(10)  # the GN graph
+    >>> G = D.to_undirected()  # the undirected version
+
+    To specify an attachment kernel, use the `kernel` keyword argument::
+
+    >>> D = nx.gn_graph(10, kernel=lambda x: x ** 1.5)  # A_k = k^1.5
+
+    References
+    ----------
+    .. [1] P. L. Krapivsky and S. Redner,
+           Organization of Growing Random Networks,
+           Phys. Rev. E, 63, 066123, 2001.
+    """
+    G = empty_graph(1, create_using, default=nx.DiGraph)
+    if not G.is_directed():
+        raise nx.NetworkXError("create_using must indicate a Directed Graph")
+
+    if kernel is None:
+
+        def kernel(x):
+            return x
+
+    if n == 1:
+        return G
+
+    G.add_edge(1, 0)  # get started
+    ds = [1, 1]  # degree sequence
+
+    for source in range(2, n):
+        # compute distribution from kernel and degree
+        dist = [kernel(d) for d in ds]
+        # choose target from discrete distribution
+        target = discrete_sequence(1, distribution=dist, seed=seed)[0]
+        G.add_edge(source, target)
+        ds.append(1)  # the source has only one link (degree one)
+        ds[target] += 1  # add one to the target link degree
+    return G
+
+
+@py_random_state(3)
+def gnr_graph(n, p, create_using=None, seed=None):
+    """Returns the growing network with redirection (GNR) digraph with `n`
+    nodes and redirection probability `p`.
+
+    The GNR graph is built by adding nodes one at a time with a link to one
+    previously added node.  The previous target node is chosen uniformly at
+    random.  With probabiliy `p` the link is instead "redirected" to the
+    successor node of the target.
+
+    The graph is always a (directed) tree.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes for the generated graph.
+    p : float
+        The redirection probability.
+    create_using : NetworkX graph constructor, optional (default DiGraph)
+        Graph type to create. If graph instance, then cleared before populated.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Examples
+    --------
+    To create the undirected GNR graph, use the :meth:`~DiGraph.to_directed`
+    method::
+
+    >>> D = nx.gnr_graph(10, 0.5)  # the GNR graph
+    >>> G = D.to_undirected()  # the undirected version
+
+    References
+    ----------
+    .. [1] P. L. Krapivsky and S. Redner,
+           Organization of Growing Random Networks,
+           Phys. Rev. E, 63, 066123, 2001.
+    """
+    G = empty_graph(1, create_using, default=nx.DiGraph)
+    if not G.is_directed():
+        raise nx.NetworkXError("create_using must indicate a Directed Graph")
+
+    if n == 1:
+        return G
+
+    for source in range(1, n):
+        target = seed.randrange(0, source)
+        if seed.random() < p and target != 0:
+            target = next(G.successors(target))
+        G.add_edge(source, target)
+    return G
+
+
+@py_random_state(2)
+def gnc_graph(n, create_using=None, seed=None):
+    """Returns the growing network with copying (GNC) digraph with `n` nodes.
+
+    The GNC graph is built by adding nodes one at a time with a link to one
+    previously added node (chosen uniformly at random) and to all of that
+    node's successors.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes for the generated graph.
+    create_using : NetworkX graph constructor, optional (default DiGraph)
+        Graph type to create. If graph instance, then cleared before populated.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    References
+    ----------
+    .. [1] P. L. Krapivsky and S. Redner,
+           Network Growth by Copying,
+           Phys. Rev. E, 71, 036118, 2005k.},
+    """
+    G = empty_graph(1, create_using, default=nx.DiGraph)
+    if not G.is_directed():
+        raise nx.NetworkXError("create_using must indicate a Directed Graph")
+
+    if n == 1:
+        return G
+
+    for source in range(1, n):
+        target = seed.randrange(0, source)
+        for succ in G.successors(target):
+            G.add_edge(source, succ)
+        G.add_edge(source, target)
+    return G
+
+
+@py_random_state(7)
+def scale_free_graph(
+    n,
+    alpha=0.41,
+    beta=0.54,
+    gamma=0.05,
+    delta_in=0.2,
+    delta_out=0,
+    create_using=None,
+    seed=None,
+    initial_graph=None,
+):
+    """Returns a scale-free directed graph.
+
+    Parameters
+    ----------
+    n : integer
+        Number of nodes in graph
+    alpha : float
+        Probability for adding a new node connected to an existing node
+        chosen randomly according to the in-degree distribution.
+    beta : float
+        Probability for adding an edge between two existing nodes.
+        One existing node is chosen randomly according the in-degree
+        distribution and the other chosen randomly according to the out-degree
+        distribution.
+    gamma : float
+        Probability for adding a new node connected to an existing node
+        chosen randomly according to the out-degree distribution.
+    delta_in : float
+        Bias for choosing nodes from in-degree distribution.
+    delta_out : float
+        Bias for choosing nodes from out-degree distribution.
+    create_using : NetworkX graph constructor, optional
+        The default is a MultiDiGraph 3-cycle.
+        If a graph instance, use it without clearing first.
+        If a graph constructor, call it to construct an empty graph.
+
+        .. deprecated:: 3.0
+
+           create_using is deprecated, use `initial_graph` instead.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    initial_graph : MultiDiGraph instance, optional
+        Build the scale-free graph starting from this initial MultiDiGraph,
+        if provided.
+
+
+    Returns
+    -------
+    MultiDiGraph
+
+    Examples
+    --------
+    Create a scale-free graph on one hundred nodes::
+
+    >>> G = nx.scale_free_graph(100)
+
+    Notes
+    -----
+    The sum of `alpha`, `beta`, and `gamma` must be 1.
+
+    References
+    ----------
+    .. [1] B. Bollobás, C. Borgs, J. Chayes, and O. Riordan,
+           Directed scale-free graphs,
+           Proceedings of the fourteenth annual ACM-SIAM Symposium on
+           Discrete Algorithms, 132--139, 2003.
+    """
+
+    def _choose_node(candidates, node_list, delta):
+        if delta > 0:
+            bias_sum = len(node_list) * delta
+            p_delta = bias_sum / (bias_sum + len(candidates))
+            if seed.random() < p_delta:
+                return seed.choice(node_list)
+        return seed.choice(candidates)
+
+    if create_using is not None:
+        import warnings
+
+        warnings.warn(
+            "The create_using argument is deprecated and will be removed in the future.\n\n"
+            "To create a scale free graph from an existing MultiDiGraph, use\n"
+            "initial_graph instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+    # TODO: Rm all this complicated logic when deprecation expires and replace
+    # with commented code:
+    #    if initial_graph is not None and hasattr(initial_graph, "_adj"):
+    #        G = initial_graph
+    #    else:
+    #        # Start with 3-cycle
+    #        G = nx.MultiDiGraph([(0, 1), (1, 2), (2, 0)])
+    if create_using is not None and hasattr(create_using, "_adj"):
+        if initial_graph is not None:
+            raise ValueError(
+                "Cannot set both create_using and initial_graph. Set create_using=None."
+            )
+        G = create_using
+    else:
+        if initial_graph is not None and hasattr(initial_graph, "_adj"):
+            G = initial_graph
+        else:
+            G = nx.MultiDiGraph([(0, 1), (1, 2), (2, 0)])
+    if not (G.is_directed() and G.is_multigraph()):
+        raise nx.NetworkXError("MultiDiGraph required in initial_graph")
+
+    if alpha <= 0:
+        raise ValueError("alpha must be > 0.")
+    if beta <= 0:
+        raise ValueError("beta must be > 0.")
+    if gamma <= 0:
+        raise ValueError("gamma must be > 0.")
+
+    if abs(alpha + beta + gamma - 1.0) >= 1e-9:
+        raise ValueError("alpha+beta+gamma must equal 1.")
+
+    if delta_in < 0:
+        raise ValueError("delta_in must be >= 0.")
+
+    if delta_out < 0:
+        raise ValueError("delta_out must be >= 0.")
+
+    # pre-populate degree states
+    vs = sum((count * [idx] for idx, count in G.out_degree()), [])
+    ws = sum((count * [idx] for idx, count in G.in_degree()), [])
+
+    # pre-populate node state
+    node_list = list(G.nodes())
+
+    # see if there already are number-based nodes
+    numeric_nodes = [n for n in node_list if isinstance(n, numbers.Number)]
+    if len(numeric_nodes) > 0:
+        # set cursor for new nodes appropriately
+        cursor = max(int(n.real) for n in numeric_nodes) + 1
+    else:
+        # or start at zero
+        cursor = 0
+
+    while len(G) < n:
+        r = seed.random()
+
+        # random choice in alpha,beta,gamma ranges
+        if r < alpha:
+            # alpha
+            # add new node v
+            v = cursor
+            cursor += 1
+            # also add to node state
+            node_list.append(v)
+            # choose w according to in-degree and delta_in
+            w = _choose_node(ws, node_list, delta_in)
+
+        elif r < alpha + beta:
+            # beta
+            # choose v according to out-degree and delta_out
+            v = _choose_node(vs, node_list, delta_out)
+            # choose w according to in-degree and delta_in
+            w = _choose_node(ws, node_list, delta_in)
+
+        else:
+            # gamma
+            # choose v according to out-degree and delta_out
+            v = _choose_node(vs, node_list, delta_out)
+            # add new node w
+            w = cursor
+            cursor += 1
+            # also add to node state
+            node_list.append(w)
+
+        # add edge to graph
+        G.add_edge(v, w)
+
+        # update degree states
+        vs.append(v)
+        ws.append(w)
+
+    return G
+
+
+@py_random_state(4)
+def random_uniform_k_out_graph(n, k, self_loops=True, with_replacement=True, seed=None):
+    """Returns a random `k`-out graph with uniform attachment.
+
+    A random `k`-out graph with uniform attachment is a multidigraph
+    generated by the following algorithm. For each node *u*, choose
+    `k` nodes *v* uniformly at random (with replacement). Add a
+    directed edge joining *u* to *v*.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes in the returned graph.
+
+    k : int
+        The out-degree of each node in the returned graph.
+
+    self_loops : bool
+        If True, self-loops are allowed when generating the graph.
+
+    with_replacement : bool
+        If True, neighbors are chosen with replacement and the
+        returned graph will be a directed multigraph. Otherwise,
+        neighbors are chosen without replacement and the returned graph
+        will be a directed graph.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    NetworkX graph
+        A `k`-out-regular directed graph generated according to the
+        above algorithm. It will be a multigraph if and only if
+        `with_replacement` is True.
+
+    Raises
+    ------
+    ValueError
+        If `with_replacement` is False and `k` is greater than
+        `n`.
+
+    See also
+    --------
+    random_k_out_graph
+
+    Notes
+    -----
+    The return digraph or multidigraph may not be strongly connected, or
+    even weakly connected.
+
+    If `with_replacement` is True, this function is similar to
+    :func:`random_k_out_graph`, if that function had parameter `alpha`
+    set to positive infinity.
+
+    """
+    if with_replacement:
+        create_using = nx.MultiDiGraph()
+
+        def sample(v, nodes):
+            if not self_loops:
+                nodes = nodes - {v}
+            return (seed.choice(list(nodes)) for i in range(k))
+
+    else:
+        create_using = nx.DiGraph()
+
+        def sample(v, nodes):
+            if not self_loops:
+                nodes = nodes - {v}
+            return seed.sample(list(nodes), k)
+
+    G = nx.empty_graph(n, create_using)
+    nodes = set(G)
+    for u in G:
+        G.add_edges_from((u, v) for v in sample(u, nodes))
+    return G
+
+
+@py_random_state(4)
+def random_k_out_graph(n, k, alpha, self_loops=True, seed=None):
+    """Returns a random `k`-out graph with preferential attachment.
+
+    A random `k`-out graph with preferential attachment is a
+    multidigraph generated by the following algorithm.
+
+    1. Begin with an empty digraph, and initially set each node to have
+       weight `alpha`.
+    2. Choose a node `u` with out-degree less than `k` uniformly at
+       random.
+    3. Choose a node `v` from with probability proportional to its
+       weight.
+    4. Add a directed edge from `u` to `v`, and increase the weight
+       of `v` by one.
+    5. If each node has out-degree `k`, halt, otherwise repeat from
+       step 2.
+
+    For more information on this model of random graph, see [1].
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes in the returned graph.
+
+    k : int
+        The out-degree of each node in the returned graph.
+
+    alpha : float
+        A positive :class:`float` representing the initial weight of
+        each vertex. A higher number means that in step 3 above, nodes
+        will be chosen more like a true uniformly random sample, and a
+        lower number means that nodes are more likely to be chosen as
+        their in-degree increases. If this parameter is not positive, a
+        :exc:`ValueError` is raised.
+
+    self_loops : bool
+        If True, self-loops are allowed when generating the graph.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    :class:`~networkx.classes.MultiDiGraph`
+        A `k`-out-regular multidigraph generated according to the above
+        algorithm.
+
+    Raises
+    ------
+    ValueError
+        If `alpha` is not positive.
+
+    Notes
+    -----
+    The returned multidigraph may not be strongly connected, or even
+    weakly connected.
+
+    References
+    ----------
+    [1]: Peterson, Nicholas R., and Boris Pittel.
+         "Distance between two random `k`-out digraphs, with and without
+         preferential attachment."
+         arXiv preprint arXiv:1311.5961 (2013).
+         <https://arxiv.org/abs/1311.5961>
+
+    """
+    if alpha < 0:
+        raise ValueError("alpha must be positive")
+    G = nx.empty_graph(n, create_using=nx.MultiDiGraph)
+    weights = Counter({v: alpha for v in G})
+    for i in range(k * n):
+        u = seed.choice([v for v, d in G.out_degree() if d < k])
+        # If self-loops are not allowed, make the source node `u` have
+        # weight zero.
+        if not self_loops:
+            adjustment = Counter({u: weights[u]})
+        else:
+            adjustment = Counter()
+        v = weighted_choice(weights - adjustment, seed=seed)
+        G.add_edge(u, v)
+        weights[v] += 1
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/duplication.py b/myenv/lib/python3.9/site-packages/networkx/generators/duplication.py
new file mode 100644
index 0000000..9a8dd85
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/duplication.py
@@ -0,0 +1,161 @@
+"""Functions for generating graphs based on the "duplication" method.
+
+These graph generators start with a small initial graph then duplicate
+nodes and (partially) duplicate their edges. These functions are
+generally inspired by biological networks.
+
+"""
+import networkx as nx
+from networkx.exception import NetworkXError
+from networkx.utils import py_random_state
+
+__all__ = ["partial_duplication_graph", "duplication_divergence_graph"]
+
+
+@py_random_state(4)
+def partial_duplication_graph(N, n, p, q, seed=None):
+    """Returns a random graph using the partial duplication model.
+
+    Parameters
+    ----------
+    N : int
+        The total number of nodes in the final graph.
+
+    n : int
+        The number of nodes in the initial clique.
+
+    p : float
+        The probability of joining each neighbor of a node to the
+        duplicate node. Must be a number in the between zero and one,
+        inclusive.
+
+    q : float
+        The probability of joining the source node to the duplicate
+        node. Must be a number in the between zero and one, inclusive.
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Notes
+    -----
+    A graph of nodes is grown by creating a fully connected graph
+    of size `n`. The following procedure is then repeated until
+    a total of `N` nodes have been reached.
+
+    1. A random node, *u*, is picked and a new node, *v*, is created.
+    2. For each neighbor of *u* an edge from the neighbor to *v* is created
+       with probability `p`.
+    3. An edge from *u* to *v* is created with probability `q`.
+
+    This algorithm appears in [1].
+
+    This implementation allows the possibility of generating
+    disconnected graphs.
+
+    References
+    ----------
+    .. [1] Knudsen Michael, and Carsten Wiuf. "A Markov chain approach to
+           randomly grown graphs." Journal of Applied Mathematics 2008.
+           <https://doi.org/10.1155/2008/190836>
+
+    """
+    if p < 0 or p > 1 or q < 0 or q > 1:
+        msg = "partial duplication graph must have 0 <= p, q <= 1."
+        raise NetworkXError(msg)
+    if n > N:
+        raise NetworkXError("partial duplication graph must have n <= N.")
+
+    G = nx.complete_graph(n)
+    for new_node in range(n, N):
+        # Pick a random vertex, u, already in the graph.
+        src_node = seed.randint(0, new_node - 1)
+
+        # Add a new vertex, v, to the graph.
+        G.add_node(new_node)
+
+        # For each neighbor of u...
+        for neighbor_node in list(nx.all_neighbors(G, src_node)):
+            # Add the neighbor to v with probability p.
+            if seed.random() < p:
+                G.add_edge(new_node, neighbor_node)
+
+        # Join v and u with probability q.
+        if seed.random() < q:
+            G.add_edge(new_node, src_node)
+    return G
+
+
+@py_random_state(2)
+def duplication_divergence_graph(n, p, seed=None):
+    """Returns an undirected graph using the duplication-divergence model.
+
+    A graph of `n` nodes is created by duplicating the initial nodes
+    and retaining edges incident to the original nodes with a retention
+    probability `p`.
+
+    Parameters
+    ----------
+    n : int
+        The desired number of nodes in the graph.
+    p : float
+        The probability for retaining the edge of the replicated node.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : Graph
+
+    Raises
+    ------
+    NetworkXError
+        If `p` is not a valid probability.
+        If `n` is less than 2.
+
+    Notes
+    -----
+    This algorithm appears in [1].
+
+    This implementation disallows the possibility of generating
+    disconnected graphs.
+
+    References
+    ----------
+    .. [1] I. Ispolatov, P. L. Krapivsky, A. Yuryev,
+       "Duplication-divergence model of protein interaction network",
+       Phys. Rev. E, 71, 061911, 2005.
+
+    """
+    if p > 1 or p < 0:
+        msg = f"NetworkXError p={p} is not in [0,1]."
+        raise nx.NetworkXError(msg)
+    if n < 2:
+        msg = "n must be greater than or equal to 2"
+        raise nx.NetworkXError(msg)
+
+    G = nx.Graph()
+
+    # Initialize the graph with two connected nodes.
+    G.add_edge(0, 1)
+    i = 2
+    while i < n:
+        # Choose a random node from current graph to duplicate.
+        random_node = seed.choice(list(G))
+        # Make the replica.
+        G.add_node(i)
+        # flag indicates whether at least one edge is connected on the replica.
+        flag = False
+        for nbr in G.neighbors(random_node):
+            if seed.random() < p:
+                # Link retention step.
+                G.add_edge(i, nbr)
+                flag = True
+        if not flag:
+            # Delete replica if no edges retained.
+            G.remove_node(i)
+        else:
+            # Successful duplication.
+            i += 1
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/ego.py b/myenv/lib/python3.9/site-packages/networkx/generators/ego.py
new file mode 100644
index 0000000..cca7dfa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/ego.py
@@ -0,0 +1,64 @@
+"""
+Ego graph.
+"""
+__all__ = ["ego_graph"]
+
+import networkx as nx
+
+
+def ego_graph(G, n, radius=1, center=True, undirected=False, distance=None):
+    """Returns induced subgraph of neighbors centered at node n within
+    a given radius.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX Graph or DiGraph
+
+    n : node
+      A single node
+
+    radius : number, optional
+      Include all neighbors of distance<=radius from n.
+
+    center : bool, optional
+      If False, do not include center node in graph
+
+    undirected : bool, optional
+      If True use both in- and out-neighbors of directed graphs.
+
+    distance : key, optional
+      Use specified edge data key as distance.  For example, setting
+      distance='weight' will use the edge weight to measure the
+      distance from the node n.
+
+    Notes
+    -----
+    For directed graphs D this produces the "out" neighborhood
+    or successors.  If you want the neighborhood of predecessors
+    first reverse the graph with D.reverse().  If you want both
+    directions use the keyword argument undirected=True.
+
+    Node, edge, and graph attributes are copied to the returned subgraph.
+    """
+    if undirected:
+        if distance is not None:
+            sp, _ = nx.single_source_dijkstra(
+                G.to_undirected(), n, cutoff=radius, weight=distance
+            )
+        else:
+            sp = dict(
+                nx.single_source_shortest_path_length(
+                    G.to_undirected(), n, cutoff=radius
+                )
+            )
+    else:
+        if distance is not None:
+            sp, _ = nx.single_source_dijkstra(G, n, cutoff=radius, weight=distance)
+        else:
+            sp = dict(nx.single_source_shortest_path_length(G, n, cutoff=radius))
+
+    H = G.subgraph(sp).copy()
+    if not center:
+        H.remove_node(n)
+    return H
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/expanders.py b/myenv/lib/python3.9/site-packages/networkx/generators/expanders.py
new file mode 100644
index 0000000..30b6702
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/expanders.py
@@ -0,0 +1,203 @@
+"""Provides explicit constructions of expander graphs.
+
+"""
+import itertools
+
+import networkx as nx
+
+__all__ = ["margulis_gabber_galil_graph", "chordal_cycle_graph", "paley_graph"]
+
+
+# Other discrete torus expanders can be constructed by using the following edge
+# sets. For more information, see Chapter 4, "Expander Graphs", in
+# "Pseudorandomness", by Salil Vadhan.
+#
+# For a directed expander, add edges from (x, y) to:
+#
+#     (x, y),
+#     ((x + 1) % n, y),
+#     (x, (y + 1) % n),
+#     (x, (x + y) % n),
+#     (-y % n, x)
+#
+# For an undirected expander, add the reverse edges.
+#
+# Also appearing in the paper of Gabber and Galil:
+#
+#     (x, y),
+#     (x, (x + y) % n),
+#     (x, (x + y + 1) % n),
+#     ((x + y) % n, y),
+#     ((x + y + 1) % n, y)
+#
+# and:
+#
+#     (x, y),
+#     ((x + 2*y) % n, y),
+#     ((x + (2*y + 1)) % n, y),
+#     ((x + (2*y + 2)) % n, y),
+#     (x, (y + 2*x) % n),
+#     (x, (y + (2*x + 1)) % n),
+#     (x, (y + (2*x + 2)) % n),
+#
+def margulis_gabber_galil_graph(n, create_using=None):
+    r"""Returns the Margulis-Gabber-Galil undirected MultiGraph on `n^2` nodes.
+
+    The undirected MultiGraph is regular with degree `8`. Nodes are integer
+    pairs. The second-largest eigenvalue of the adjacency matrix of the graph
+    is at most `5 \sqrt{2}`, regardless of `n`.
+
+    Parameters
+    ----------
+    n : int
+        Determines the number of nodes in the graph: `n^2`.
+    create_using : NetworkX graph constructor, optional (default MultiGraph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : graph
+        The constructed undirected multigraph.
+
+    Raises
+    ------
+    NetworkXError
+        If the graph is directed or not a multigraph.
+
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed() or not G.is_multigraph():
+        msg = "`create_using` must be an undirected multigraph."
+        raise nx.NetworkXError(msg)
+
+    for (x, y) in itertools.product(range(n), repeat=2):
+        for (u, v) in (
+            ((x + 2 * y) % n, y),
+            ((x + (2 * y + 1)) % n, y),
+            (x, (y + 2 * x) % n),
+            (x, (y + (2 * x + 1)) % n),
+        ):
+            G.add_edge((x, y), (u, v))
+    G.graph["name"] = f"margulis_gabber_galil_graph({n})"
+    return G
+
+
+def chordal_cycle_graph(p, create_using=None):
+    """Returns the chordal cycle graph on `p` nodes.
+
+    The returned graph is a cycle graph on `p` nodes with chords joining each
+    vertex `x` to its inverse modulo `p`. This graph is a (mildly explicit)
+    3-regular expander [1]_.
+
+    `p` *must* be a prime number.
+
+    Parameters
+    ----------
+    p : a prime number
+
+        The number of vertices in the graph. This also indicates where the
+        chordal edges in the cycle will be created.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : graph
+        The constructed undirected multigraph.
+
+    Raises
+    ------
+    NetworkXError
+
+        If `create_using` indicates directed or not a multigraph.
+
+    References
+    ----------
+
+    .. [1] Theorem 4.4.2 in A. Lubotzky. "Discrete groups, expanding graphs and
+           invariant measures", volume 125 of Progress in Mathematics.
+           Birkhäuser Verlag, Basel, 1994.
+
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed() or not G.is_multigraph():
+        msg = "`create_using` must be an undirected multigraph."
+        raise nx.NetworkXError(msg)
+
+    for x in range(p):
+        left = (x - 1) % p
+        right = (x + 1) % p
+        # Here we apply Fermat's Little Theorem to compute the multiplicative
+        # inverse of x in Z/pZ. By Fermat's Little Theorem,
+        #
+        #     x^p = x (mod p)
+        #
+        # Therefore,
+        #
+        #     x * x^(p - 2) = 1 (mod p)
+        #
+        # The number 0 is a special case: we just let its inverse be itself.
+        chord = pow(x, p - 2, p) if x > 0 else 0
+        for y in (left, right, chord):
+            G.add_edge(x, y)
+    G.graph["name"] = f"chordal_cycle_graph({p})"
+    return G
+
+
+def paley_graph(p, create_using=None):
+    """Returns the Paley (p-1)/2-regular graph on p nodes.
+
+    The returned graph is a graph on Z/pZ with edges between x and y
+    if and only if x-y is a nonzero square in Z/pZ.
+
+    If p = 1 mod 4, -1 is a square in Z/pZ and therefore x-y is a square if and
+    only if y-x is also a square, i.e the edges in the Paley graph are symmetric.
+
+    If p = 3 mod 4, -1 is not a square in Z/pZ and therefore either x-y or y-x
+    is a square in Z/pZ but not both.
+
+    Note that a more general definition of Paley graphs extends this construction
+    to graphs over q=p^n vertices, by using the finite field F_q instead of Z/pZ.
+    This construction requires to compute squares in general finite fields and is
+    not what is implemented here (i.e paley_graph(25) does not return the true
+    Paley graph associated with 5^2).
+
+    Parameters
+    ----------
+    p : int, an odd prime number.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : graph
+        The constructed directed graph.
+
+    Raises
+    ------
+    NetworkXError
+        If the graph is a multigraph.
+
+    References
+    ----------
+    Chapter 13 in B. Bollobas, Random Graphs. Second edition.
+    Cambridge Studies in Advanced Mathematics, 73.
+    Cambridge University Press, Cambridge (2001).
+    """
+    G = nx.empty_graph(0, create_using, default=nx.DiGraph)
+    if G.is_multigraph():
+        msg = "`create_using` cannot be a multigraph."
+        raise nx.NetworkXError(msg)
+
+    # Compute the squares in Z/pZ.
+    # Make it a set to uniquify (there are exactly (p-1)/2 squares in Z/pZ
+    # when is prime).
+    square_set = {(x**2) % p for x in range(1, p) if (x**2) % p != 0}
+
+    for x in range(p):
+        for x2 in square_set:
+            G.add_edge(x, (x + x2) % p)
+    G.graph["name"] = f"paley({p})"
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/geometric.py b/myenv/lib/python3.9/site-packages/networkx/generators/geometric.py
new file mode 100644
index 0000000..de5fbd4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/geometric.py
@@ -0,0 +1,804 @@
+"""Generators for geometric graphs.
+"""
+
+import math
+from bisect import bisect_left
+from itertools import accumulate, combinations, product
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = [
+    "geometric_edges",
+    "geographical_threshold_graph",
+    "navigable_small_world_graph",
+    "random_geometric_graph",
+    "soft_random_geometric_graph",
+    "thresholded_random_geometric_graph",
+    "waxman_graph",
+]
+
+
+def euclidean(x, y):
+    """Returns the Euclidean distance between the vectors ``x`` and ``y``.
+
+    Each of ``x`` and ``y`` can be any iterable of numbers. The
+    iterables must be of the same length.
+
+     .. deprecated:: 2.7
+    """
+    import warnings
+
+    msg = (
+        "euclidean is deprecated and will be removed in 3.0."
+        "Use math.dist(x, y) instead."
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    return math.dist(x, y)
+
+
+def geometric_edges(G, radius, p=2):
+    """Returns edge list of node pairs within `radius` of each other.
+
+    Parameters
+    ----------
+    G : networkx graph
+        The graph from which to generate the edge list. The nodes in `G` should
+        have an attribute ``pos`` corresponding to the node position, which is
+        used to compute the distance to other nodes.
+    radius : scalar
+        The distance threshold. Edges are included in the edge list if the
+        distance between the two nodes is less than `radius`.
+    p : scalar, default=2
+        The `Minkowski distance metric
+        <https://en.wikipedia.org/wiki/Minkowski_distance>`_ used to compute
+        distances. The default value is 2, i.e. Euclidean distance.
+
+    Returns
+    -------
+    edges : list
+        List of edges whose distances are less than `radius`
+
+    Notes
+    -----
+    Radius uses Minkowski distance metric `p`.
+    If scipy is available, `scipy.spatial.cKDTree` is used to speed computation.
+
+    Examples
+    --------
+    Create a graph with nodes that have a "pos" attribute representing 2D
+    coordinates.
+
+    >>> G = nx.Graph()
+    >>> G.add_nodes_from([
+    ...     (0, {"pos": (0, 0)}),
+    ...     (1, {"pos": (3, 0)}),
+    ...     (2, {"pos": (8, 0)}),
+    ... ])
+    >>> nx.geometric_edges(G, radius=1)
+    []
+    >>> nx.geometric_edges(G, radius=4)
+    [(0, 1)]
+    >>> nx.geometric_edges(G, radius=6)
+    [(0, 1), (1, 2)]
+    >>> nx.geometric_edges(G, radius=9)
+    [(0, 1), (0, 2), (1, 2)]
+    """
+    # Input validation - every node must have a "pos" attribute
+    for n, pos in G.nodes(data="pos"):
+        if pos is None:
+            raise nx.NetworkXError(
+                f"All nodes in `G` must have a 'pos' attribute. Check node {n}"
+            )
+
+    # NOTE: See _geometric_edges for the actual implementation. The reason this
+    # is split into two functions is to avoid the overhead of input validation
+    # every time the function is called internally in one of the other
+    # geometric generators
+    return _geometric_edges(G, radius, p)
+
+
+def _geometric_edges(G, radius, p=2):
+    """
+    Implements `geometric_edges` without input validation. See `geometric_edges`
+    for complete docstring.
+    """
+    nodes_pos = G.nodes(data="pos")
+    try:
+        import scipy as sp
+        import scipy.spatial  # call as sp.spatial
+    except ImportError:
+        # no scipy KDTree so compute by for-loop
+        radius_p = radius**p
+        edges = [
+            (u, v)
+            for (u, pu), (v, pv) in combinations(nodes_pos, 2)
+            if sum(abs(a - b) ** p for a, b in zip(pu, pv)) <= radius_p
+        ]
+        return edges
+    # scipy KDTree is available
+    nodes, coords = list(zip(*nodes_pos))
+    kdtree = sp.spatial.cKDTree(coords)  # Cannot provide generator.
+    edge_indexes = kdtree.query_pairs(radius, p)
+    edges = [(nodes[u], nodes[v]) for u, v in sorted(edge_indexes)]
+    return edges
+
+
+@py_random_state(5)
+def random_geometric_graph(n, radius, dim=2, pos=None, p=2, seed=None):
+    """Returns a random geometric graph in the unit cube of dimensions `dim`.
+
+    The random geometric graph model places `n` nodes uniformly at
+    random in the unit cube. Two nodes are joined by an edge if the
+    distance between the nodes is at most `radius`.
+
+    Edges are determined using a KDTree when SciPy is available.
+    This reduces the time complexity from $O(n^2)$ to $O(n)$.
+
+    Parameters
+    ----------
+    n : int or iterable
+        Number of nodes or iterable of nodes
+    radius: float
+        Distance threshold value
+    dim : int, optional
+        Dimension of graph
+    pos : dict, optional
+        A dictionary keyed by node with node positions as values.
+    p : float, optional
+        Which Minkowski distance metric to use.  `p` has to meet the condition
+        ``1 <= p <= infinity``.
+
+        If this argument is not specified, the :math:`L^2` metric
+        (the Euclidean distance metric), p = 2 is used.
+        This should not be confused with the `p` of an Erdős-Rényi random
+        graph, which represents probability.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    Graph
+        A random geometric graph, undirected and without self-loops.
+        Each node has a node attribute ``'pos'`` that stores the
+        position of that node in Euclidean space as provided by the
+        ``pos`` keyword argument or, if ``pos`` was not provided, as
+        generated by this function.
+
+    Examples
+    --------
+    Create a random geometric graph on twenty nodes where nodes are joined by
+    an edge if their distance is at most 0.1::
+
+    >>> G = nx.random_geometric_graph(20, 0.1)
+
+    Notes
+    -----
+    This uses a *k*-d tree to build the graph.
+
+    The `pos` keyword argument can be used to specify node positions so you
+    can create an arbitrary distribution and domain for positions.
+
+    For example, to use a 2D Gaussian distribution of node positions with mean
+    (0, 0) and standard deviation 2::
+
+    >>> import random
+    >>> n = 20
+    >>> pos = {i: (random.gauss(0, 2), random.gauss(0, 2)) for i in range(n)}
+    >>> G = nx.random_geometric_graph(n, 0.2, pos=pos)
+
+    References
+    ----------
+    .. [1] Penrose, Mathew, *Random Geometric Graphs*,
+           Oxford Studies in Probability, 5, 2003.
+
+    """
+    # TODO Is this function just a special case of the geographical
+    # threshold graph?
+    #
+    #     half_radius = {v: radius / 2 for v in n}
+    #     return geographical_threshold_graph(nodes, theta=1, alpha=1,
+    #                                         weight=half_radius)
+    #
+    G = nx.empty_graph(n)
+    # If no positions are provided, choose uniformly random vectors in
+    # Euclidean space of the specified dimension.
+    if pos is None:
+        pos = {v: [seed.random() for i in range(dim)] for v in G}
+    nx.set_node_attributes(G, pos, "pos")
+
+    G.add_edges_from(_geometric_edges(G, radius, p))
+    return G
+
+
+@py_random_state(6)
+def soft_random_geometric_graph(
+    n, radius, dim=2, pos=None, p=2, p_dist=None, seed=None
+):
+    r"""Returns a soft random geometric graph in the unit cube.
+
+    The soft random geometric graph [1] model places `n` nodes uniformly at
+    random in the unit cube in dimension `dim`. Two nodes of distance, `dist`,
+    computed by the `p`-Minkowski distance metric are joined by an edge with
+    probability `p_dist` if the computed distance metric value of the nodes
+    is at most `radius`, otherwise they are not joined.
+
+    Edges within `radius` of each other are determined using a KDTree when
+    SciPy is available. This reduces the time complexity from :math:`O(n^2)`
+    to :math:`O(n)`.
+
+    Parameters
+    ----------
+    n : int or iterable
+        Number of nodes or iterable of nodes
+    radius: float
+        Distance threshold value
+    dim : int, optional
+        Dimension of graph
+    pos : dict, optional
+        A dictionary keyed by node with node positions as values.
+    p : float, optional
+        Which Minkowski distance metric to use.
+        `p` has to meet the condition ``1 <= p <= infinity``.
+
+        If this argument is not specified, the :math:`L^2` metric
+        (the Euclidean distance metric), p = 2 is used.
+
+        This should not be confused with the `p` of an Erdős-Rényi random
+        graph, which represents probability.
+    p_dist : function, optional
+        A probability density function computing the probability of
+        connecting two nodes that are of distance, dist, computed by the
+        Minkowski distance metric. The probability density function, `p_dist`,
+        must be any function that takes the metric value as input
+        and outputs a single probability value between 0-1. The scipy.stats
+        package has many probability distribution functions implemented and
+        tools for custom probability distribution definitions [2], and passing
+        the .pdf method of scipy.stats distributions can be used here.  If the
+        probability function, `p_dist`, is not supplied, the default function
+        is an exponential distribution with rate parameter :math:`\lambda=1`.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    Graph
+        A soft random geometric graph, undirected and without self-loops.
+        Each node has a node attribute ``'pos'`` that stores the
+        position of that node in Euclidean space as provided by the
+        ``pos`` keyword argument or, if ``pos`` was not provided, as
+        generated by this function.
+
+    Examples
+    --------
+    Default Graph:
+
+    G = nx.soft_random_geometric_graph(50, 0.2)
+
+    Custom Graph:
+
+    Create a soft random geometric graph on 100 uniformly distributed nodes
+    where nodes are joined by an edge with probability computed from an
+    exponential distribution with rate parameter :math:`\lambda=1` if their
+    Euclidean distance is at most 0.2.
+
+    Notes
+    -----
+    This uses a *k*-d tree to build the graph.
+
+    The `pos` keyword argument can be used to specify node positions so you
+    can create an arbitrary distribution and domain for positions.
+
+    For example, to use a 2D Gaussian distribution of node positions with mean
+    (0, 0) and standard deviation 2
+
+    The scipy.stats package can be used to define the probability distribution
+    with the .pdf method used as `p_dist`.
+
+    ::
+
+    >>> import random
+    >>> import math
+    >>> n = 100
+    >>> pos = {i: (random.gauss(0, 2), random.gauss(0, 2)) for i in range(n)}
+    >>> p_dist = lambda dist: math.exp(-dist)
+    >>> G = nx.soft_random_geometric_graph(n, 0.2, pos=pos, p_dist=p_dist)
+
+    References
+    ----------
+    .. [1] Penrose, Mathew D. "Connectivity of soft random geometric graphs."
+           The Annals of Applied Probability 26.2 (2016): 986-1028.
+    .. [2] scipy.stats -
+           https://docs.scipy.org/doc/scipy/reference/tutorial/stats.html
+
+    """
+    G = nx.empty_graph(n)
+    G.name = f"soft_random_geometric_graph({n}, {radius}, {dim})"
+    # If no positions are provided, choose uniformly random vectors in
+    # Euclidean space of the specified dimension.
+    if pos is None:
+        pos = {v: [seed.random() for i in range(dim)] for v in G}
+    nx.set_node_attributes(G, pos, "pos")
+
+    # if p_dist function not supplied the default function is an exponential
+    # distribution with rate parameter :math:`\lambda=1`.
+    if p_dist is None:
+
+        def p_dist(dist):
+            return math.exp(-dist)
+
+    def should_join(edge):
+        u, v = edge
+        dist = (sum(abs(a - b) ** p for a, b in zip(pos[u], pos[v]))) ** (1 / p)
+        return seed.random() < p_dist(dist)
+
+    G.add_edges_from(filter(should_join, _geometric_edges(G, radius, p)))
+    return G
+
+
+@py_random_state(7)
+def geographical_threshold_graph(
+    n, theta, dim=2, pos=None, weight=None, metric=None, p_dist=None, seed=None
+):
+    r"""Returns a geographical threshold graph.
+
+    The geographical threshold graph model places $n$ nodes uniformly at
+    random in a rectangular domain.  Each node $u$ is assigned a weight
+    $w_u$. Two nodes $u$ and $v$ are joined by an edge if
+
+    .. math::
+
+       (w_u + w_v)p_{dist}(r) \ge \theta
+
+    where `r` is the distance between `u` and `v`, `p_dist` is any function of
+    `r`, and :math:`\theta` as the threshold parameter. `p_dist` is used to
+    give weight to the distance between nodes when deciding whether or not
+    they should be connected. The larger `p_dist` is, the more prone nodes
+    separated by `r` are to be connected, and vice versa.
+
+    Parameters
+    ----------
+    n : int or iterable
+        Number of nodes or iterable of nodes
+    theta: float
+        Threshold value
+    dim : int, optional
+        Dimension of graph
+    pos : dict
+        Node positions as a dictionary of tuples keyed by node.
+    weight : dict
+        Node weights as a dictionary of numbers keyed by node.
+    metric : function
+        A metric on vectors of numbers (represented as lists or
+        tuples). This must be a function that accepts two lists (or
+        tuples) as input and yields a number as output. The function
+        must also satisfy the four requirements of a `metric`_.
+        Specifically, if $d$ is the function and $x$, $y$,
+        and $z$ are vectors in the graph, then $d$ must satisfy
+
+        1. $d(x, y) \ge 0$,
+        2. $d(x, y) = 0$ if and only if $x = y$,
+        3. $d(x, y) = d(y, x)$,
+        4. $d(x, z) \le d(x, y) + d(y, z)$.
+
+        If this argument is not specified, the Euclidean distance metric is
+        used.
+
+        .. _metric: https://en.wikipedia.org/wiki/Metric_%28mathematics%29
+    p_dist : function, optional
+        Any function used to give weight to the distance between nodes when
+        deciding whether or not they should be connected. `p_dist` was
+        originally conceived as a probability density function giving the
+        probability of connecting two nodes that are of metric distance `r`
+        apart. The implementation here allows for more arbitrary definitions
+        of `p_dist` that do not need to correspond to valid probability
+        density functions. The :mod:`scipy.stats` package has many
+        probability density functions implemented and tools for custom
+        probability density definitions, and passing the ``.pdf`` method of
+        scipy.stats distributions can be used here. If ``p_dist=None``
+        (the default), the exponential function :math:`r^{-2}` is used.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    Graph
+        A random geographic threshold graph, undirected and without
+        self-loops.
+
+        Each node has a node attribute ``pos`` that stores the
+        position of that node in Euclidean space as provided by the
+        ``pos`` keyword argument or, if ``pos`` was not provided, as
+        generated by this function. Similarly, each node has a node
+        attribute ``weight`` that stores the weight of that node as
+        provided or as generated.
+
+    Examples
+    --------
+    Specify an alternate distance metric using the ``metric`` keyword
+    argument. For example, to use the `taxicab metric`_ instead of the
+    default `Euclidean metric`_::
+
+        >>> dist = lambda x, y: sum(abs(a - b) for a, b in zip(x, y))
+        >>> G = nx.geographical_threshold_graph(10, 0.1, metric=dist)
+
+    .. _taxicab metric: https://en.wikipedia.org/wiki/Taxicab_geometry
+    .. _Euclidean metric: https://en.wikipedia.org/wiki/Euclidean_distance
+
+    Notes
+    -----
+    If weights are not specified they are assigned to nodes by drawing randomly
+    from the exponential distribution with rate parameter $\lambda=1$.
+    To specify weights from a different distribution, use the `weight` keyword
+    argument::
+
+    >>> import random
+    >>> n = 20
+    >>> w = {i: random.expovariate(5.0) for i in range(n)}
+    >>> G = nx.geographical_threshold_graph(20, 50, weight=w)
+
+    If node positions are not specified they are randomly assigned from the
+    uniform distribution.
+
+    References
+    ----------
+    .. [1] Masuda, N., Miwa, H., Konno, N.:
+       Geographical threshold graphs with small-world and scale-free
+       properties.
+       Physical Review E 71, 036108 (2005)
+    .. [2]  Milan Bradonjić, Aric Hagberg and Allon G. Percus,
+       Giant component and connectivity in geographical threshold graphs,
+       in Algorithms and Models for the Web-Graph (WAW 2007),
+       Antony Bonato and Fan Chung (Eds), pp. 209--216, 2007
+    """
+    G = nx.empty_graph(n)
+    # If no weights are provided, choose them from an exponential
+    # distribution.
+    if weight is None:
+        weight = {v: seed.expovariate(1) for v in G}
+    # If no positions are provided, choose uniformly random vectors in
+    # Euclidean space of the specified dimension.
+    if pos is None:
+        pos = {v: [seed.random() for i in range(dim)] for v in G}
+    # If no distance metric is provided, use Euclidean distance.
+    if metric is None:
+        metric = math.dist
+    nx.set_node_attributes(G, weight, "weight")
+    nx.set_node_attributes(G, pos, "pos")
+
+    # if p_dist is not supplied, use default r^-2
+    if p_dist is None:
+
+        def p_dist(r):
+            return r**-2
+
+    # Returns ``True`` if and only if the nodes whose attributes are
+    # ``du`` and ``dv`` should be joined, according to the threshold
+    # condition.
+    def should_join(pair):
+        u, v = pair
+        u_pos, v_pos = pos[u], pos[v]
+        u_weight, v_weight = weight[u], weight[v]
+        return (u_weight + v_weight) * p_dist(metric(u_pos, v_pos)) >= theta
+
+    G.add_edges_from(filter(should_join, combinations(G, 2)))
+    return G
+
+
+@py_random_state(6)
+def waxman_graph(
+    n, beta=0.4, alpha=0.1, L=None, domain=(0, 0, 1, 1), metric=None, seed=None
+):
+    r"""Returns a Waxman random graph.
+
+    The Waxman random graph model places `n` nodes uniformly at random
+    in a rectangular domain. Each pair of nodes at distance `d` is
+    joined by an edge with probability
+
+    .. math::
+            p = \beta \exp(-d / \alpha L).
+
+    This function implements both Waxman models, using the `L` keyword
+    argument.
+
+    * Waxman-1: if `L` is not specified, it is set to be the maximum distance
+      between any pair of nodes.
+    * Waxman-2: if `L` is specified, the distance between a pair of nodes is
+      chosen uniformly at random from the interval `[0, L]`.
+
+    Parameters
+    ----------
+    n : int or iterable
+        Number of nodes or iterable of nodes
+    beta: float
+        Model parameter
+    alpha: float
+        Model parameter
+    L : float, optional
+        Maximum distance between nodes.  If not specified, the actual distance
+        is calculated.
+    domain : four-tuple of numbers, optional
+        Domain size, given as a tuple of the form `(x_min, y_min, x_max,
+        y_max)`.
+    metric : function
+        A metric on vectors of numbers (represented as lists or
+        tuples). This must be a function that accepts two lists (or
+        tuples) as input and yields a number as output. The function
+        must also satisfy the four requirements of a `metric`_.
+        Specifically, if $d$ is the function and $x$, $y$,
+        and $z$ are vectors in the graph, then $d$ must satisfy
+
+        1. $d(x, y) \ge 0$,
+        2. $d(x, y) = 0$ if and only if $x = y$,
+        3. $d(x, y) = d(y, x)$,
+        4. $d(x, z) \le d(x, y) + d(y, z)$.
+
+        If this argument is not specified, the Euclidean distance metric is
+        used.
+
+        .. _metric: https://en.wikipedia.org/wiki/Metric_%28mathematics%29
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    Graph
+        A random Waxman graph, undirected and without self-loops. Each
+        node has a node attribute ``'pos'`` that stores the position of
+        that node in Euclidean space as generated by this function.
+
+    Examples
+    --------
+    Specify an alternate distance metric using the ``metric`` keyword
+    argument. For example, to use the "`taxicab metric`_" instead of the
+    default `Euclidean metric`_::
+
+        >>> dist = lambda x, y: sum(abs(a - b) for a, b in zip(x, y))
+        >>> G = nx.waxman_graph(10, 0.5, 0.1, metric=dist)
+
+    .. _taxicab metric: https://en.wikipedia.org/wiki/Taxicab_geometry
+    .. _Euclidean metric: https://en.wikipedia.org/wiki/Euclidean_distance
+
+    Notes
+    -----
+    Starting in NetworkX 2.0 the parameters alpha and beta align with their
+    usual roles in the probability distribution. In earlier versions their
+    positions in the expression were reversed. Their position in the calling
+    sequence reversed as well to minimize backward incompatibility.
+
+    References
+    ----------
+    .. [1]  B. M. Waxman, *Routing of multipoint connections*.
+       IEEE J. Select. Areas Commun. 6(9),(1988) 1617--1622.
+    """
+    G = nx.empty_graph(n)
+    (xmin, ymin, xmax, ymax) = domain
+    # Each node gets a uniformly random position in the given rectangle.
+    pos = {v: (seed.uniform(xmin, xmax), seed.uniform(ymin, ymax)) for v in G}
+    nx.set_node_attributes(G, pos, "pos")
+    # If no distance metric is provided, use Euclidean distance.
+    if metric is None:
+        metric = math.dist
+    # If the maximum distance L is not specified (that is, we are in the
+    # Waxman-1 model), then find the maximum distance between any pair
+    # of nodes.
+    #
+    # In the Waxman-1 model, join nodes randomly based on distance. In
+    # the Waxman-2 model, join randomly based on random l.
+    if L is None:
+        L = max(metric(x, y) for x, y in combinations(pos.values(), 2))
+
+        def dist(u, v):
+            return metric(pos[u], pos[v])
+
+    else:
+
+        def dist(u, v):
+            return seed.random() * L
+
+    # `pair` is the pair of nodes to decide whether to join.
+    def should_join(pair):
+        return seed.random() < beta * math.exp(-dist(*pair) / (alpha * L))
+
+    G.add_edges_from(filter(should_join, combinations(G, 2)))
+    return G
+
+
+@py_random_state(5)
+def navigable_small_world_graph(n, p=1, q=1, r=2, dim=2, seed=None):
+    r"""Returns a navigable small-world graph.
+
+    A navigable small-world graph is a directed grid with additional long-range
+    connections that are chosen randomly.
+
+      [...] we begin with a set of nodes [...] that are identified with the set
+      of lattice points in an $n \times n$ square,
+      $\{(i, j): i \in \{1, 2, \ldots, n\}, j \in \{1, 2, \ldots, n\}\}$,
+      and we define the *lattice distance* between two nodes $(i, j)$ and
+      $(k, l)$ to be the number of "lattice steps" separating them:
+      $d((i, j), (k, l)) = |k - i| + |l - j|$.
+
+      For a universal constant $p >= 1$, the node $u$ has a directed edge to
+      every other node within lattice distance $p$---these are its *local
+      contacts*. For universal constants $q >= 0$ and $r >= 0$ we also
+      construct directed edges from $u$ to $q$ other nodes (the *long-range
+      contacts*) using independent random trials; the $i$th directed edge from
+      $u$ has endpoint $v$ with probability proportional to $[d(u,v)]^{-r}$.
+
+      -- [1]_
+
+    Parameters
+    ----------
+    n : int
+        The length of one side of the lattice; the number of nodes in
+        the graph is therefore $n^2$.
+    p : int
+        The diameter of short range connections. Each node is joined with every
+        other node within this lattice distance.
+    q : int
+        The number of long-range connections for each node.
+    r : float
+        Exponent for decaying probability of connections.  The probability of
+        connecting to a node at lattice distance $d$ is $1/d^r$.
+    dim : int
+        Dimension of grid
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    References
+    ----------
+    .. [1] J. Kleinberg. The small-world phenomenon: An algorithmic
+       perspective. Proc. 32nd ACM Symposium on Theory of Computing, 2000.
+    """
+    if p < 1:
+        raise nx.NetworkXException("p must be >= 1")
+    if q < 0:
+        raise nx.NetworkXException("q must be >= 0")
+    if r < 0:
+        raise nx.NetworkXException("r must be >= 1")
+
+    G = nx.DiGraph()
+    nodes = list(product(range(n), repeat=dim))
+    for p1 in nodes:
+        probs = [0]
+        for p2 in nodes:
+            if p1 == p2:
+                continue
+            d = sum((abs(b - a) for a, b in zip(p1, p2)))
+            if d <= p:
+                G.add_edge(p1, p2)
+            probs.append(d**-r)
+        cdf = list(accumulate(probs))
+        for _ in range(q):
+            target = nodes[bisect_left(cdf, seed.uniform(0, cdf[-1]))]
+            G.add_edge(p1, target)
+    return G
+
+
+@py_random_state(7)
+def thresholded_random_geometric_graph(
+    n, radius, theta, dim=2, pos=None, weight=None, p=2, seed=None
+):
+    r"""Returns a thresholded random geometric graph in the unit cube.
+
+    The thresholded random geometric graph [1] model places `n` nodes
+    uniformly at random in the unit cube of dimensions `dim`. Each node
+    `u` is assigned a weight :math:`w_u`. Two nodes `u` and `v` are
+    joined by an edge if they are within the maximum connection distance,
+    `radius` computed by the `p`-Minkowski distance and the summation of
+    weights :math:`w_u` + :math:`w_v` is greater than or equal
+    to the threshold parameter `theta`.
+
+    Edges within `radius` of each other are determined using a KDTree when
+    SciPy is available. This reduces the time complexity from :math:`O(n^2)`
+    to :math:`O(n)`.
+
+    Parameters
+    ----------
+    n : int or iterable
+        Number of nodes or iterable of nodes
+    radius: float
+        Distance threshold value
+    theta: float
+        Threshold value
+    dim : int, optional
+        Dimension of graph
+    pos : dict, optional
+        A dictionary keyed by node with node positions as values.
+    weight : dict, optional
+        Node weights as a dictionary of numbers keyed by node.
+    p : float, optional (default 2)
+        Which Minkowski distance metric to use.  `p` has to meet the condition
+        ``1 <= p <= infinity``.
+
+        If this argument is not specified, the :math:`L^2` metric
+        (the Euclidean distance metric), p = 2 is used.
+
+        This should not be confused with the `p` of an Erdős-Rényi random
+        graph, which represents probability.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    Graph
+        A thresholded random geographic graph, undirected and without
+        self-loops.
+
+        Each node has a node attribute ``'pos'`` that stores the
+        position of that node in Euclidean space as provided by the
+        ``pos`` keyword argument or, if ``pos`` was not provided, as
+        generated by this function. Similarly, each node has a nodethre
+        attribute ``'weight'`` that stores the weight of that node as
+        provided or as generated.
+
+    Examples
+    --------
+    Default Graph:
+
+    G = nx.thresholded_random_geometric_graph(50, 0.2, 0.1)
+
+    Custom Graph:
+
+    Create a thresholded random geometric graph on 50 uniformly distributed
+    nodes where nodes are joined by an edge if their sum weights drawn from
+    a exponential distribution with rate = 5 are >= theta = 0.1 and their
+    Euclidean distance is at most 0.2.
+
+    Notes
+    -----
+    This uses a *k*-d tree to build the graph.
+
+    The `pos` keyword argument can be used to specify node positions so you
+    can create an arbitrary distribution and domain for positions.
+
+    For example, to use a 2D Gaussian distribution of node positions with mean
+    (0, 0) and standard deviation 2
+
+    If weights are not specified they are assigned to nodes by drawing randomly
+    from the exponential distribution with rate parameter :math:`\lambda=1`.
+    To specify weights from a different distribution, use the `weight` keyword
+    argument::
+
+    ::
+
+    >>> import random
+    >>> import math
+    >>> n = 50
+    >>> pos = {i: (random.gauss(0, 2), random.gauss(0, 2)) for i in range(n)}
+    >>> w = {i: random.expovariate(5.0) for i in range(n)}
+    >>> G = nx.thresholded_random_geometric_graph(n, 0.2, 0.1, 2, pos, w)
+
+    References
+    ----------
+    .. [1] http://cole-maclean.github.io/blog/files/thesis.pdf
+
+    """
+    G = nx.empty_graph(n)
+    G.name = f"thresholded_random_geometric_graph({n}, {radius}, {theta}, {dim})"
+    # If no weights are provided, choose them from an exponential
+    # distribution.
+    if weight is None:
+        weight = {v: seed.expovariate(1) for v in G}
+    # If no positions are provided, choose uniformly random vectors in
+    # Euclidean space of the specified dimension.
+    if pos is None:
+        pos = {v: [seed.random() for i in range(dim)] for v in G}
+    # If no distance metric is provided, use Euclidean distance.
+    nx.set_node_attributes(G, weight, "weight")
+    nx.set_node_attributes(G, pos, "pos")
+
+    edges = (
+        (u, v)
+        for u, v in _geometric_edges(G, radius, p)
+        if weight[u] + weight[v] >= theta
+    )
+    G.add_edges_from(edges)
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/harary_graph.py b/myenv/lib/python3.9/site-packages/networkx/generators/harary_graph.py
new file mode 100644
index 0000000..7af21b3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/harary_graph.py
@@ -0,0 +1,197 @@
+"""Generators for Harary graphs
+
+This module gives two generators for the Harary graph, which was
+introduced by the famous mathematician Frank Harary in his 1962 work [H]_.
+The first generator gives the Harary graph that maximizes the node
+connectivity with given number of nodes and given number of edges.
+The second generator gives the Harary graph that minimizes
+the number of edges in the graph with given node connectivity and
+number of nodes.
+
+References
+----------
+.. [H] Harary, F. "The Maximum Connectivity of a Graph."
+       Proc. Nat. Acad. Sci. USA 48, 1142-1146, 1962.
+
+"""
+
+import networkx as nx
+from networkx.exception import NetworkXError
+
+__all__ = ["hnm_harary_graph", "hkn_harary_graph"]
+
+
+def hnm_harary_graph(n, m, create_using=None):
+    """Returns the Harary graph with given numbers of nodes and edges.
+
+    The Harary graph $H_{n,m}$ is the graph that maximizes node connectivity
+    with $n$ nodes and $m$ edges.
+
+    This maximum node connectivity is known to be floor($2m/n$). [1]_
+
+    Parameters
+    ----------
+    n: integer
+       The number of nodes the generated graph is to contain
+
+    m: integer
+       The number of edges the generated graph is to contain
+
+    create_using : NetworkX graph constructor, optional Graph type
+     to create (default=nx.Graph). If graph instance, then cleared
+     before populated.
+
+    Returns
+    -------
+    NetworkX graph
+        The Harary graph $H_{n,m}$.
+
+    See Also
+    --------
+    hkn_harary_graph
+
+    Notes
+    -----
+    This algorithm runs in $O(m)$ time.
+    It is implemented by following the Reference [2]_.
+
+    References
+    ----------
+    .. [1] F. T. Boesch, A. Satyanarayana, and C. L. Suffel,
+       "A Survey of Some Network Reliability Analysis and Synthesis Results,"
+       Networks, pp. 99-107, 2009.
+
+    .. [2] Harary, F. "The Maximum Connectivity of a Graph."
+       Proc. Nat. Acad. Sci. USA 48, 1142-1146, 1962.
+    """
+
+    if n < 1:
+        raise NetworkXError("The number of nodes must be >= 1!")
+    if m < n - 1:
+        raise NetworkXError("The number of edges must be >= n - 1 !")
+    if m > n * (n - 1) // 2:
+        raise NetworkXError("The number of edges must be <= n(n-1)/2")
+
+    # Construct an empty graph with n nodes first
+    H = nx.empty_graph(n, create_using)
+    # Get the floor of average node degree
+    d = 2 * m // n
+
+    # Test the parity of n and d
+    if (n % 2 == 0) or (d % 2 == 0):
+        # Start with a regular graph of d degrees
+        offset = d // 2
+        for i in range(n):
+            for j in range(1, offset + 1):
+                H.add_edge(i, (i - j) % n)
+                H.add_edge(i, (i + j) % n)
+        if d & 1:
+            # in case d is odd; n must be even in this case
+            half = n // 2
+            for i in range(0, half):
+                # add edges diagonally
+                H.add_edge(i, i + half)
+        # Get the remainder of 2*m modulo n
+        r = 2 * m % n
+        if r > 0:
+            # add remaining edges at offset+1
+            for i in range(0, r // 2):
+                H.add_edge(i, i + offset + 1)
+    else:
+        # Start with a regular graph of (d - 1) degrees
+        offset = (d - 1) // 2
+        for i in range(n):
+            for j in range(1, offset + 1):
+                H.add_edge(i, (i - j) % n)
+                H.add_edge(i, (i + j) % n)
+        half = n // 2
+        for i in range(0, m - n * offset):
+            # add the remaining m - n*offset edges between i and i+half
+            H.add_edge(i, (i + half) % n)
+
+    return H
+
+
+def hkn_harary_graph(k, n, create_using=None):
+    """Returns the Harary graph with given node connectivity and node number.
+
+    The Harary graph $H_{k,n}$ is the graph that minimizes the number of
+    edges needed with given node connectivity $k$ and node number $n$.
+
+    This smallest number of edges is known to be ceil($kn/2$) [1]_.
+
+    Parameters
+    ----------
+    k: integer
+       The node connectivity of the generated graph
+
+    n: integer
+       The number of nodes the generated graph is to contain
+
+    create_using : NetworkX graph constructor, optional Graph type
+     to create (default=nx.Graph). If graph instance, then cleared
+     before populated.
+
+    Returns
+    -------
+    NetworkX graph
+        The Harary graph $H_{k,n}$.
+
+    See Also
+    --------
+    hnm_harary_graph
+
+    Notes
+    -----
+    This algorithm runs in $O(kn)$ time.
+    It is implemented by following the Reference [2]_.
+
+    References
+    ----------
+    .. [1] Weisstein, Eric W. "Harary Graph." From MathWorld--A Wolfram Web
+     Resource. http://mathworld.wolfram.com/HararyGraph.html.
+
+    .. [2] Harary, F. "The Maximum Connectivity of a Graph."
+      Proc. Nat. Acad. Sci. USA 48, 1142-1146, 1962.
+    """
+
+    if k < 1:
+        raise NetworkXError("The node connectivity must be >= 1!")
+    if n < k + 1:
+        raise NetworkXError("The number of nodes must be >= k+1 !")
+
+    # in case of connectivity 1, simply return the path graph
+    if k == 1:
+        H = nx.path_graph(n, create_using)
+        return H
+
+    # Construct an empty graph with n nodes first
+    H = nx.empty_graph(n, create_using)
+
+    # Test the parity of k and n
+    if (k % 2 == 0) or (n % 2 == 0):
+        # Construct a regular graph with k degrees
+        offset = k // 2
+        for i in range(n):
+            for j in range(1, offset + 1):
+                H.add_edge(i, (i - j) % n)
+                H.add_edge(i, (i + j) % n)
+        if k & 1:
+            # odd degree; n must be even in this case
+            half = n // 2
+            for i in range(0, half):
+                # add edges diagonally
+                H.add_edge(i, i + half)
+    else:
+        # Construct a regular graph with (k - 1) degrees
+        offset = (k - 1) // 2
+        for i in range(n):
+            for j in range(1, offset + 1):
+                H.add_edge(i, (i - j) % n)
+                H.add_edge(i, (i + j) % n)
+        half = n // 2
+        for i in range(0, half + 1):
+            # add half+1 edges between i and i+half
+            H.add_edge(i, (i + half) % n)
+
+    return H
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/internet_as_graphs.py b/myenv/lib/python3.9/site-packages/networkx/generators/internet_as_graphs.py
new file mode 100644
index 0000000..c3c1278
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/internet_as_graphs.py
@@ -0,0 +1,440 @@
+"""Generates graphs resembling the Internet Autonomous System network"""
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = ["random_internet_as_graph"]
+
+
+def uniform_int_from_avg(a, m, seed):
+    """Pick a random integer with uniform probability.
+
+    Returns a random integer uniformly taken from a distribution with
+    minimum value 'a' and average value 'm', X~U(a,b), E[X]=m, X in N where
+    b = 2*m - a.
+
+    Notes
+    -----
+    p = (b-floor(b))/2
+    X = X1 + X2; X1~U(a,floor(b)), X2~B(p)
+    E[X] = E[X1] + E[X2] = (floor(b)+a)/2 + (b-floor(b))/2 = (b+a)/2 = m
+    """
+
+    from math import floor
+
+    assert m >= a
+    b = 2 * m - a
+    p = (b - floor(b)) / 2
+    X1 = round(seed.random() * (floor(b) - a) + a)
+    if seed.random() < p:
+        X2 = 1
+    else:
+        X2 = 0
+    return X1 + X2
+
+
+def choose_pref_attach(degs, seed):
+    """Pick a random value, with a probability given by its weight.
+
+    Returns a random choice among degs keys, each of which has a
+    probability proportional to the corresponding dictionary value.
+
+    Parameters
+    ----------
+    degs: dictionary
+        It contains the possible values (keys) and the corresponding
+        probabilities (values)
+    seed: random state
+
+    Returns
+    -------
+    v: object
+        A key of degs or None if degs is empty
+    """
+
+    if len(degs) == 0:
+        return None
+    s = sum(degs.values())
+    if s == 0:
+        return seed.choice(list(degs.keys()))
+    v = seed.random() * s
+
+    nodes = list(degs.keys())
+    i = 0
+    acc = degs[nodes[i]]
+    while v > acc:
+        i += 1
+        acc += degs[nodes[i]]
+    return nodes[i]
+
+
+class AS_graph_generator:
+    """Generates random internet AS graphs."""
+
+    def __init__(self, n, seed):
+        """Initializes variables. Immediate numbers are taken from [1].
+
+        Parameters
+        ----------
+        n: integer
+            Number of graph nodes
+        seed: random state
+            Indicator of random number generation state.
+            See :ref:`Randomness<randomness>`.
+
+        Returns
+        -------
+        GG: AS_graph_generator object
+
+        References
+        ----------
+        [1] A. Elmokashfi, A. Kvalbein and C. Dovrolis, "On the Scalability of
+        BGP: The Role of Topology Growth," in IEEE Journal on Selected Areas
+        in Communications, vol. 28, no. 8, pp. 1250-1261, October 2010.
+        """
+
+        self.seed = seed
+        self.n_t = min(n, round(self.seed.random() * 2 + 4))  # num of T nodes
+        self.n_m = round(0.15 * n)  # number of M nodes
+        self.n_cp = round(0.05 * n)  # number of CP nodes
+        self.n_c = max(0, n - self.n_t - self.n_m - self.n_cp)  # number of C nodes
+
+        self.d_m = 2 + (2.5 * n) / 10000  # average multihoming degree for M nodes
+        self.d_cp = 2 + (1.5 * n) / 10000  # avg multihoming degree for CP nodes
+        self.d_c = 1 + (5 * n) / 100000  # average multihoming degree for C nodes
+
+        self.p_m_m = 1 + (2 * n) / 10000  # avg num of peer edges between M and M
+        self.p_cp_m = 0.2 + (2 * n) / 10000  # avg num of peer edges between CP, M
+        self.p_cp_cp = 0.05 + (2 * n) / 100000  # avg num of peer edges btwn CP, CP
+
+        self.t_m = 0.375  # probability M's provider is T
+        self.t_cp = 0.375  # probability CP's provider is T
+        self.t_c = 0.125  # probability C's provider is T
+
+    def t_graph(self):
+        """Generates the core mesh network of tier one nodes of a AS graph.
+
+        Returns
+        -------
+        G: Networkx Graph
+            Core network
+        """
+
+        self.G = nx.Graph()
+        for i in range(self.n_t):
+            self.G.add_node(i, type="T")
+            for r in self.regions:
+                self.regions[r].add(i)
+            for j in self.G.nodes():
+                if i != j:
+                    self.add_edge(i, j, "peer")
+            self.customers[i] = set()
+            self.providers[i] = set()
+        return self.G
+
+    def add_edge(self, i, j, kind):
+        if kind == "transit":
+            customer = str(i)
+        else:
+            customer = "none"
+        self.G.add_edge(i, j, type=kind, customer=customer)
+
+    def choose_peer_pref_attach(self, node_list):
+        """Pick a node with a probability weighted by its peer degree.
+
+        Pick a node from node_list with preferential attachment
+        computed only on their peer degree
+        """
+
+        d = {}
+        for n in node_list:
+            d[n] = self.G.nodes[n]["peers"]
+        return choose_pref_attach(d, self.seed)
+
+    def choose_node_pref_attach(self, node_list):
+        """Pick a node with a probability weighted by its degree.
+
+        Pick a node from node_list with preferential attachment
+        computed on their degree
+        """
+
+        degs = dict(self.G.degree(node_list))
+        return choose_pref_attach(degs, self.seed)
+
+    def add_customer(self, i, j):
+        """Keep the dictionaries 'customers' and 'providers' consistent."""
+
+        self.customers[j].add(i)
+        self.providers[i].add(j)
+        for z in self.providers[j]:
+            self.customers[z].add(i)
+            self.providers[i].add(z)
+
+    def add_node(self, i, kind, reg2prob, avg_deg, t_edge_prob):
+        """Add a node and its customer transit edges to the graph.
+
+        Parameters
+        ----------
+        i: object
+            Identifier of the new node
+        kind: string
+            Type of the new node. Options are: 'M' for middle node, 'CP' for
+            content provider and 'C' for customer.
+        reg2prob: float
+            Probability the new node can be in two different regions.
+        avg_deg: float
+            Average number of transit nodes of which node i is customer.
+        t_edge_prob: float
+            Probability node i establish a customer transit edge with a tier
+            one (T) node
+
+        Returns
+        -------
+        i: object
+            Identifier of the new node
+        """
+
+        regs = 1  # regions in which node resides
+        if self.seed.random() < reg2prob:  # node is in two regions
+            regs = 2
+        node_options = set()
+
+        self.G.add_node(i, type=kind, peers=0)
+        self.customers[i] = set()
+        self.providers[i] = set()
+        self.nodes[kind].add(i)
+        for r in self.seed.sample(list(self.regions), regs):
+            node_options = node_options.union(self.regions[r])
+            self.regions[r].add(i)
+
+        edge_num = uniform_int_from_avg(1, avg_deg, self.seed)
+
+        t_options = node_options.intersection(self.nodes["T"])
+        m_options = node_options.intersection(self.nodes["M"])
+        if i in m_options:
+            m_options.remove(i)
+        d = 0
+        while d < edge_num and (len(t_options) > 0 or len(m_options) > 0):
+            if len(m_options) == 0 or (
+                len(t_options) > 0 and self.seed.random() < t_edge_prob
+            ):  # add edge to a T node
+                j = self.choose_node_pref_attach(t_options)
+                t_options.remove(j)
+            else:
+                j = self.choose_node_pref_attach(m_options)
+                m_options.remove(j)
+            self.add_edge(i, j, "transit")
+            self.add_customer(i, j)
+            d += 1
+
+        return i
+
+    def add_m_peering_link(self, m, to_kind):
+        """Add a peering link between two middle tier (M) nodes.
+
+        Target node j is drawn considering a preferential attachment based on
+        other M node peering degree.
+
+        Parameters
+        ----------
+        m: object
+            Node identifier
+        to_kind: string
+            type for target node j (must be always M)
+
+        Returns
+        -------
+        success: boolean
+        """
+
+        # candidates are of type 'M' and are not customers of m
+        node_options = self.nodes["M"].difference(self.customers[m])
+        # candidates are not providers of m
+        node_options = node_options.difference(self.providers[m])
+        # remove self
+        if m in node_options:
+            node_options.remove(m)
+
+        # remove candidates we are already connected to
+        for j in self.G.neighbors(m):
+            if j in node_options:
+                node_options.remove(j)
+
+        if len(node_options) > 0:
+            j = self.choose_peer_pref_attach(node_options)
+            self.add_edge(m, j, "peer")
+            self.G.nodes[m]["peers"] += 1
+            self.G.nodes[j]["peers"] += 1
+            return True
+        else:
+            return False
+
+    def add_cp_peering_link(self, cp, to_kind):
+        """Add a peering link to a content provider (CP) node.
+
+        Target node j can be CP or M and it is drawn uniformely among the nodes
+        belonging to the same region as cp.
+
+        Parameters
+        ----------
+        cp: object
+            Node identifier
+        to_kind: string
+            type for target node j (must be M or CP)
+
+        Returns
+        -------
+        success: boolean
+        """
+
+        node_options = set()
+        for r in self.regions:  # options include nodes in the same region(s)
+            if cp in self.regions[r]:
+                node_options = node_options.union(self.regions[r])
+
+        # options are restricted to the indicated kind ('M' or 'CP')
+        node_options = self.nodes[to_kind].intersection(node_options)
+
+        # remove self
+        if cp in node_options:
+            node_options.remove(cp)
+
+        # remove nodes that are cp's providers
+        node_options = node_options.difference(self.providers[cp])
+
+        # remove nodes we are already connected to
+        for j in self.G.neighbors(cp):
+            if j in node_options:
+                node_options.remove(j)
+
+        if len(node_options) > 0:
+            j = self.seed.sample(list(node_options), 1)[0]
+            self.add_edge(cp, j, "peer")
+            self.G.nodes[cp]["peers"] += 1
+            self.G.nodes[j]["peers"] += 1
+            return True
+        else:
+            return False
+
+    def graph_regions(self, rn):
+        """Initializes AS network regions.
+
+        Parameters
+        ----------
+        rn: integer
+            Number of regions
+        """
+
+        self.regions = {}
+        for i in range(rn):
+            self.regions["REG" + str(i)] = set()
+
+    def add_peering_links(self, from_kind, to_kind):
+        """Utility function to add peering links among node groups."""
+        peer_link_method = None
+        if from_kind == "M":
+            peer_link_method = self.add_m_peering_link
+            m = self.p_m_m
+        if from_kind == "CP":
+            peer_link_method = self.add_cp_peering_link
+            if to_kind == "M":
+                m = self.p_cp_m
+            else:
+                m = self.p_cp_cp
+
+        for i in self.nodes[from_kind]:
+            num = uniform_int_from_avg(0, m, self.seed)
+            for _ in range(num):
+                peer_link_method(i, to_kind)
+
+    def generate(self):
+        """Generates a random AS network graph as described in [1].
+
+        Returns
+        -------
+        G: Graph object
+
+        Notes
+        -----
+        The process steps are the following: first we create the core network
+        of tier one nodes, then we add the middle tier (M), the content
+        provider (CP) and the customer (C) nodes along with their transit edges
+        (link i,j means i is customer of j). Finally we add peering links
+        between M nodes, between M and CP nodes and between CP node couples.
+        For a detailed description of the algorithm, please refer to [1].
+
+        References
+        ----------
+        [1] A. Elmokashfi, A. Kvalbein and C. Dovrolis, "On the Scalability of
+        BGP: The Role of Topology Growth," in IEEE Journal on Selected Areas
+        in Communications, vol. 28, no. 8, pp. 1250-1261, October 2010.
+        """
+
+        self.graph_regions(5)
+        self.customers = {}
+        self.providers = {}
+        self.nodes = {"T": set(), "M": set(), "CP": set(), "C": set()}
+
+        self.t_graph()
+        self.nodes["T"] = set(list(self.G.nodes()))
+
+        i = len(self.nodes["T"])
+        for _ in range(self.n_m):
+            self.nodes["M"].add(self.add_node(i, "M", 0.2, self.d_m, self.t_m))
+            i += 1
+        for _ in range(self.n_cp):
+            self.nodes["CP"].add(self.add_node(i, "CP", 0.05, self.d_cp, self.t_cp))
+            i += 1
+        for _ in range(self.n_c):
+            self.nodes["C"].add(self.add_node(i, "C", 0, self.d_c, self.t_c))
+            i += 1
+
+        self.add_peering_links("M", "M")
+        self.add_peering_links("CP", "M")
+        self.add_peering_links("CP", "CP")
+
+        return self.G
+
+
+@py_random_state(1)
+def random_internet_as_graph(n, seed=None):
+    """Generates a random undirected graph resembling the Internet AS network
+
+    Parameters
+    ----------
+    n: integer in [1000, 10000]
+        Number of graph nodes
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G: Networkx Graph object
+        A randomly generated undirected graph
+
+    Notes
+    -----
+    This algorithm returns an undirected graph resembling the Internet
+    Autonomous System (AS) network, it uses the approach by Elmokashfi et al.
+    [1]_ and it grants the properties described in the related paper [1]_.
+
+    Each node models an autonomous system, with an attribute 'type' specifying
+    its kind; tier-1 (T), mid-level (M), customer (C) or content-provider (CP).
+    Each edge models an ADV communication link (hence, bidirectional) with
+    attributes:
+
+      - type: transit|peer, the kind of commercial agreement between nodes;
+      - customer: <node id>, the identifier of the node acting as customer
+        ('none' if type is peer).
+
+    References
+    ----------
+    .. [1] A. Elmokashfi, A. Kvalbein and C. Dovrolis, "On the Scalability of
+       BGP: The Role of Topology Growth," in IEEE Journal on Selected Areas
+       in Communications, vol. 28, no. 8, pp. 1250-1261, October 2010.
+    """
+
+    GG = AS_graph_generator(n, seed)
+    G = GG.generate()
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/intersection.py b/myenv/lib/python3.9/site-packages/networkx/generators/intersection.py
new file mode 100644
index 0000000..2efc4ea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/intersection.py
@@ -0,0 +1,121 @@
+"""
+Generators for random intersection graphs.
+"""
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = [
+    "uniform_random_intersection_graph",
+    "k_random_intersection_graph",
+    "general_random_intersection_graph",
+]
+
+
+@py_random_state(3)
+def uniform_random_intersection_graph(n, m, p, seed=None):
+    """Returns a uniform random intersection graph.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes in the first bipartite set (nodes)
+    m : int
+        The number of nodes in the second bipartite set (attributes)
+    p : float
+        Probability of connecting nodes between bipartite sets
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    See Also
+    --------
+    gnp_random_graph
+
+    References
+    ----------
+    .. [1] K.B. Singer-Cohen, Random Intersection Graphs, 1995,
+       PhD thesis, Johns Hopkins University
+    .. [2] Fill, J. A., Scheinerman, E. R., and Singer-Cohen, K. B.,
+       Random intersection graphs when m = !(n):
+       An equivalence theorem relating the evolution of the g(n, m, p)
+       and g(n, p) models. Random Struct. Algorithms 16, 2 (2000), 156–176.
+    """
+    from networkx.algorithms import bipartite
+
+    G = bipartite.random_graph(n, m, p, seed)
+    return nx.projected_graph(G, range(n))
+
+
+@py_random_state(3)
+def k_random_intersection_graph(n, m, k, seed=None):
+    """Returns a intersection graph with randomly chosen attribute sets for
+    each node that are of equal size (k).
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes in the first bipartite set (nodes)
+    m : int
+        The number of nodes in the second bipartite set (attributes)
+    k : float
+        Size of attribute set to assign to each node.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    See Also
+    --------
+    gnp_random_graph, uniform_random_intersection_graph
+
+    References
+    ----------
+    .. [1] Godehardt, E., and Jaworski, J.
+       Two models of random intersection graphs and their applications.
+       Electronic Notes in Discrete Mathematics 10 (2001), 129--132.
+    """
+    G = nx.empty_graph(n + m)
+    mset = range(n, n + m)
+    for v in range(n):
+        targets = seed.sample(mset, k)
+        G.add_edges_from(zip([v] * len(targets), targets))
+    return nx.projected_graph(G, range(n))
+
+
+@py_random_state(3)
+def general_random_intersection_graph(n, m, p, seed=None):
+    """Returns a random intersection graph with independent probabilities
+    for connections between node and attribute sets.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes in the first bipartite set (nodes)
+    m : int
+        The number of nodes in the second bipartite set (attributes)
+    p : list of floats of length m
+        Probabilities for connecting nodes to each attribute
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    See Also
+    --------
+    gnp_random_graph, uniform_random_intersection_graph
+
+    References
+    ----------
+    .. [1] Nikoletseas, S. E., Raptopoulos, C., and Spirakis, P. G.
+       The existence and efficient construction of large independent sets
+       in general random intersection graphs. In ICALP (2004), J. D´ıaz,
+       J. Karhum¨aki, A. Lepist¨o, and D. Sannella, Eds., vol. 3142
+       of Lecture Notes in Computer Science, Springer, pp. 1029–1040.
+    """
+    if len(p) != m:
+        raise ValueError("Probability list p must have m elements.")
+    G = nx.empty_graph(n + m)
+    mset = range(n, n + m)
+    for u in range(n):
+        for v, q in zip(mset, p):
+            if seed.random() < q:
+                G.add_edge(u, v)
+    return nx.projected_graph(G, range(n))
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/interval_graph.py b/myenv/lib/python3.9/site-packages/networkx/generators/interval_graph.py
new file mode 100644
index 0000000..01c33b0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/interval_graph.py
@@ -0,0 +1,70 @@
+"""
+Generators for interval graph.
+"""
+from collections.abc import Sequence
+
+import networkx as nx
+
+__all__ = ["interval_graph"]
+
+
+def interval_graph(intervals):
+    """Generates an interval graph for a list of intervals given.
+
+    In graph theory, an interval graph is an undirected graph formed from a set
+    of closed intervals on the real line, with a vertex for each interval
+    and an edge between vertices whose intervals intersect.
+    It is the intersection graph of the intervals.
+
+    More information can be found at:
+    https://en.wikipedia.org/wiki/Interval_graph
+
+    Parameters
+    ----------
+    intervals : a sequence of intervals, say (l, r) where l is the left end,
+    and r is the right end of the closed interval.
+
+    Returns
+    -------
+    G : networkx graph
+
+    Examples
+    --------
+    >>> intervals = [(-2, 3), [1, 4], (2, 3), (4, 6)]
+    >>> G = nx.interval_graph(intervals)
+    >>> sorted(G.edges)
+    [((-2, 3), (1, 4)), ((-2, 3), (2, 3)), ((1, 4), (2, 3)), ((1, 4), (4, 6))]
+
+    Raises
+    ------
+    :exc:`TypeError`
+        if `intervals` contains None or an element which is not
+        collections.abc.Sequence or not a length of 2.
+    :exc:`ValueError`
+        if `intervals` contains an interval such that min1 > max1
+        where min1,max1 = interval
+    """
+    intervals = list(intervals)
+    for interval in intervals:
+        if not (isinstance(interval, Sequence) and len(interval) == 2):
+            raise TypeError(
+                "Each interval must have length 2, and be a "
+                "collections.abc.Sequence such as tuple or list."
+            )
+        if interval[0] > interval[1]:
+            raise ValueError(
+                f"Interval must have lower value first. " f"Got {interval}"
+            )
+
+    graph = nx.Graph()
+
+    tupled_intervals = [tuple(interval) for interval in intervals]
+    graph.add_nodes_from(tupled_intervals)
+
+    while tupled_intervals:
+        min1, max1 = interval1 = tupled_intervals.pop()
+        for interval2 in tupled_intervals:
+            min2, max2 = interval2
+            if max1 >= min2 and max2 >= min1:
+                graph.add_edge(interval1, interval2)
+    return graph
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/joint_degree_seq.py b/myenv/lib/python3.9/site-packages/networkx/generators/joint_degree_seq.py
new file mode 100644
index 0000000..7ab7c76
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/joint_degree_seq.py
@@ -0,0 +1,670 @@
+"""Generate graphs with a given joint degree and directed joint degree"""
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = [
+    "is_valid_joint_degree",
+    "is_valid_directed_joint_degree",
+    "joint_degree_graph",
+    "directed_joint_degree_graph",
+]
+
+
+def is_valid_joint_degree(joint_degrees):
+    """Checks whether the given joint degree dictionary is realizable.
+
+    A *joint degree dictionary* is a dictionary of dictionaries, in
+    which entry ``joint_degrees[k][l]`` is an integer representing the
+    number of edges joining nodes of degree *k* with nodes of degree
+    *l*. Such a dictionary is realizable as a simple graph if and only
+    if the following conditions are satisfied.
+
+    - each entry must be an integer,
+    - the total number of nodes of degree *k*, computed by
+      ``sum(joint_degrees[k].values()) / k``, must be an integer,
+    - the total number of edges joining nodes of degree *k* with
+      nodes of degree *l* cannot exceed the total number of possible edges,
+    - each diagonal entry ``joint_degrees[k][k]`` must be even (this is
+      a convention assumed by the :func:`joint_degree_graph` function).
+
+
+    Parameters
+    ----------
+    joint_degrees :  dictionary of dictionary of integers
+        A joint degree dictionary in which entry ``joint_degrees[k][l]``
+        is the number of edges joining nodes of degree *k* with nodes of
+        degree *l*.
+
+    Returns
+    -------
+    bool
+        Whether the given joint degree dictionary is realizable as a
+        simple graph.
+
+    References
+    ----------
+    .. [1] M. Gjoka, M. Kurant, A. Markopoulou, "2.5K Graphs: from Sampling
+       to Generation", IEEE Infocom, 2013.
+    .. [2] I. Stanton, A. Pinar, "Constructing and sampling graphs with a
+       prescribed joint degree distribution", Journal of Experimental
+       Algorithmics, 2012.
+    """
+
+    degree_count = {}
+    for k in joint_degrees:
+        if k > 0:
+            k_size = sum(joint_degrees[k].values()) / k
+            if not k_size.is_integer():
+                return False
+            degree_count[k] = k_size
+
+    for k in joint_degrees:
+        for l in joint_degrees[k]:
+            if not float(joint_degrees[k][l]).is_integer():
+                return False
+
+            if (k != l) and (joint_degrees[k][l] > degree_count[k] * degree_count[l]):
+                return False
+            elif k == l:
+                if joint_degrees[k][k] > degree_count[k] * (degree_count[k] - 1):
+                    return False
+                if joint_degrees[k][k] % 2 != 0:
+                    return False
+
+    # if all above conditions have been satisfied then the input
+    # joint degree is realizable as a simple graph.
+    return True
+
+
+def _neighbor_switch(G, w, unsat, h_node_residual, avoid_node_id=None):
+    """Releases one free stub for ``w``, while preserving joint degree in G.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Graph in which the neighbor switch will take place.
+    w : integer
+        Node id for which we will execute this neighbor switch.
+    unsat : set of integers
+        Set of unsaturated node ids that have the same degree as w.
+    h_node_residual: dictionary of integers
+        Keeps track of the remaining stubs  for a given node.
+    avoid_node_id: integer
+        Node id to avoid when selecting w_prime.
+
+    Notes
+    -----
+    First, it selects *w_prime*, an  unsaturated node that has the same degree
+    as ``w``. Second, it selects *switch_node*, a neighbor node of ``w`` that
+    is not  connected to *w_prime*. Then it executes an edge swap i.e. removes
+    (``w``,*switch_node*) and adds (*w_prime*,*switch_node*). Gjoka et. al. [1]
+    prove that such an edge swap is always possible.
+
+    References
+    ----------
+    .. [1] M. Gjoka, B. Tillman, A. Markopoulou, "Construction of Simple
+       Graphs with a Target Joint Degree Matrix and Beyond", IEEE Infocom, '15
+    """
+
+    if (avoid_node_id is None) or (h_node_residual[avoid_node_id] > 1):
+        # select unsatured node w_prime that has the same degree as w
+        w_prime = next(iter(unsat))
+    else:
+        # assume that the node pair (v,w) has been selected for connection. if
+        # - neighbor_switch is called for node w,
+        # - nodes v and w have the same degree,
+        # - node v=avoid_node_id has only one stub left,
+        # then prevent v=avoid_node_id from being selected as w_prime.
+
+        iter_var = iter(unsat)
+        while True:
+            w_prime = next(iter_var)
+            if w_prime != avoid_node_id:
+                break
+
+    # select switch_node, a neighbor of w, that is not connected to w_prime
+    w_prime_neighbs = G[w_prime]  # slightly faster declaring this variable
+    for v in G[w]:
+        if (v not in w_prime_neighbs) and (v != w_prime):
+            switch_node = v
+            break
+
+    # remove edge (w,switch_node), add edge (w_prime,switch_node) and update
+    # data structures
+    G.remove_edge(w, switch_node)
+    G.add_edge(w_prime, switch_node)
+    h_node_residual[w] += 1
+    h_node_residual[w_prime] -= 1
+    if h_node_residual[w_prime] == 0:
+        unsat.remove(w_prime)
+
+
+@py_random_state(1)
+def joint_degree_graph(joint_degrees, seed=None):
+    """Generates a random simple graph with the given joint degree dictionary.
+
+    Parameters
+    ----------
+    joint_degrees :  dictionary of dictionary of integers
+        A joint degree dictionary in which entry ``joint_degrees[k][l]`` is the
+        number of edges joining nodes of degree *k* with nodes of degree *l*.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : Graph
+        A graph with the specified joint degree dictionary.
+
+    Raises
+    ------
+    NetworkXError
+        If *joint_degrees* dictionary is not realizable.
+
+    Notes
+    -----
+    In each iteration of the "while loop" the algorithm picks two disconnected
+    nodes *v* and *w*, of degree *k* and *l* correspondingly,  for which
+    ``joint_degrees[k][l]`` has not reached its target yet. It then adds
+    edge (*v*, *w*) and increases the number of edges in graph G by one.
+
+    The intelligence of the algorithm lies in the fact that  it is always
+    possible to add an edge between such disconnected nodes *v* and *w*,
+    even if one or both nodes do not have free stubs. That is made possible by
+    executing a "neighbor switch", an edge rewiring move that releases
+    a free stub while keeping the joint degree of G the same.
+
+    The algorithm continues for E (number of edges) iterations of
+    the "while loop", at the which point all entries of the given
+    ``joint_degrees[k][l]`` have reached their target values and the
+    construction is complete.
+
+    References
+    ----------
+    ..  [1] M. Gjoka, B. Tillman, A. Markopoulou, "Construction of Simple
+        Graphs with a Target Joint Degree Matrix and Beyond", IEEE Infocom, '15
+
+    Examples
+    --------
+    >>> joint_degrees = {
+    ...     1: {4: 1},
+    ...     2: {2: 2, 3: 2, 4: 2},
+    ...     3: {2: 2, 4: 1},
+    ...     4: {1: 1, 2: 2, 3: 1},
+    ... }
+    >>> G = nx.joint_degree_graph(joint_degrees)
+    >>>
+    """
+
+    if not is_valid_joint_degree(joint_degrees):
+        msg = "Input joint degree dict not realizable as a simple graph"
+        raise nx.NetworkXError(msg)
+
+    # compute degree count from joint_degrees
+    degree_count = {k: sum(l.values()) // k for k, l in joint_degrees.items() if k > 0}
+
+    # start with empty N-node graph
+    N = sum(degree_count.values())
+    G = nx.empty_graph(N)
+
+    # for a given degree group, keep the list of all node ids
+    h_degree_nodelist = {}
+
+    # for a given node, keep track of the remaining stubs
+    h_node_residual = {}
+
+    # populate h_degree_nodelist and h_node_residual
+    nodeid = 0
+    for degree, num_nodes in degree_count.items():
+        h_degree_nodelist[degree] = range(nodeid, nodeid + num_nodes)
+        for v in h_degree_nodelist[degree]:
+            h_node_residual[v] = degree
+        nodeid += int(num_nodes)
+
+    # iterate over every degree pair (k,l) and add the number of edges given
+    # for each pair
+    for k in joint_degrees:
+        for l in joint_degrees[k]:
+
+            # n_edges_add is the number of edges to add for the
+            # degree pair (k,l)
+            n_edges_add = joint_degrees[k][l]
+
+            if (n_edges_add > 0) and (k >= l):
+
+                # number of nodes with degree k and l
+                k_size = degree_count[k]
+                l_size = degree_count[l]
+
+                # k_nodes and l_nodes consist of all nodes of degree k and l
+                k_nodes = h_degree_nodelist[k]
+                l_nodes = h_degree_nodelist[l]
+
+                # k_unsat and l_unsat consist of nodes of degree k and l that
+                # are unsaturated (nodes that have at least 1 available stub)
+                k_unsat = {v for v in k_nodes if h_node_residual[v] > 0}
+
+                if k != l:
+                    l_unsat = {w for w in l_nodes if h_node_residual[w] > 0}
+                else:
+                    l_unsat = k_unsat
+                    n_edges_add = joint_degrees[k][l] // 2
+
+                while n_edges_add > 0:
+
+                    # randomly pick nodes v and w that have degrees k and l
+                    v = k_nodes[seed.randrange(k_size)]
+                    w = l_nodes[seed.randrange(l_size)]
+
+                    # if nodes v and w are disconnected then attempt to connect
+                    if not G.has_edge(v, w) and (v != w):
+
+                        # if node v has no free stubs then do neighbor switch
+                        if h_node_residual[v] == 0:
+                            _neighbor_switch(G, v, k_unsat, h_node_residual)
+
+                        # if node w has no free stubs then do neighbor switch
+                        if h_node_residual[w] == 0:
+                            if k != l:
+                                _neighbor_switch(G, w, l_unsat, h_node_residual)
+                            else:
+                                _neighbor_switch(
+                                    G, w, l_unsat, h_node_residual, avoid_node_id=v
+                                )
+
+                        # add edge (v, w) and update data structures
+                        G.add_edge(v, w)
+                        h_node_residual[v] -= 1
+                        h_node_residual[w] -= 1
+                        n_edges_add -= 1
+
+                        if h_node_residual[v] == 0:
+                            k_unsat.discard(v)
+                        if h_node_residual[w] == 0:
+                            l_unsat.discard(w)
+    return G
+
+
+def is_valid_directed_joint_degree(in_degrees, out_degrees, nkk):
+    """Checks whether the given directed joint degree input is realizable
+
+    Parameters
+    ----------
+    in_degrees :  list of integers
+        in degree sequence contains the in degrees of nodes.
+    out_degrees : list of integers
+        out degree sequence contains the out degrees of nodes.
+    nkk  :  dictionary of dictionary of integers
+        directed joint degree dictionary. for nodes of out degree k (first
+        level of dict) and nodes of in degree l (seconnd level of dict)
+        describes the number of edges.
+
+    Returns
+    -------
+    boolean
+        returns true if given input is realizable, else returns false.
+
+    Notes
+    -----
+    Here is the list of conditions that the inputs (in/out degree sequences,
+    nkk) need to satisfy for simple directed graph realizability:
+
+    - Condition 0: in_degrees and out_degrees have the same length
+    - Condition 1: nkk[k][l]  is integer for all k,l
+    - Condition 2: sum(nkk[k])/k = number of nodes with partition id k, is an
+                   integer and matching degree sequence
+    - Condition 3: number of edges and non-chords between k and l cannot exceed
+                   maximum possible number of edges
+
+
+    References
+    ----------
+    [1] B. Tillman, A. Markopoulou, C. T. Butts & M. Gjoka,
+        "Construction of Directed 2K Graphs". In Proc. of KDD 2017.
+    """
+    V = {}  # number of nodes with in/out degree.
+    forbidden = {}
+    if len(in_degrees) != len(out_degrees):
+        return False
+
+    for idx in range(0, len(in_degrees)):
+        i = in_degrees[idx]
+        o = out_degrees[idx]
+        V[(i, 0)] = V.get((i, 0), 0) + 1
+        V[(o, 1)] = V.get((o, 1), 0) + 1
+
+        forbidden[(o, i)] = forbidden.get((o, i), 0) + 1
+
+    S = {}  # number of edges going from in/out degree nodes.
+    for k in nkk:
+        for l in nkk[k]:
+            val = nkk[k][l]
+            if not float(val).is_integer():  # condition 1
+                return False
+
+            if val > 0:
+                S[(k, 1)] = S.get((k, 1), 0) + val
+                S[(l, 0)] = S.get((l, 0), 0) + val
+                # condition 3
+                if val + forbidden.get((k, l), 0) > V[(k, 1)] * V[(l, 0)]:
+                    return False
+
+    for s in S:
+        if not S[s] / s[0] == V[s]:  # condition 2
+            return False
+
+    # if all conditions abive have been satisfied then the input nkk is
+    # realizable as a simple graph.
+    return True
+
+
+def _directed_neighbor_switch(
+    G, w, unsat, h_node_residual_out, chords, h_partition_in, partition
+):
+    """Releases one free stub for node w, while preserving joint degree in G.
+
+    Parameters
+    ----------
+    G : networkx directed graph
+        graph within which the edge swap will take place.
+    w : integer
+        node id for which we need to perform a neighbor switch.
+    unsat: set of integers
+        set of node ids that have the same degree as w and are unsaturated.
+    h_node_residual_out: dict of integers
+        for a given node, keeps track of the remaining stubs to be added.
+    chords: set of tuples
+        keeps track of available positions to add edges.
+    h_partition_in: dict of integers
+        for a given node, keeps track of its partition id (in degree).
+    partition: integer
+        partition id to check if chords have to be updated.
+
+    Notes
+    -----
+    First, it selects node w_prime that (1) has the same degree as w and
+    (2) is unsaturated. Then, it selects node v, a neighbor of w, that is
+    not connected to w_prime and does an edge swap i.e. removes (w,v) and
+    adds (w_prime,v). If neighbor switch is not possible for w using
+    w_prime and v, then return w_prime; in [1] it's proven that
+    such unsaturated nodes can be used.
+
+    References
+    ----------
+    [1] B. Tillman, A. Markopoulou, C. T. Butts & M. Gjoka,
+        "Construction of Directed 2K Graphs". In Proc. of KDD 2017.
+    """
+    w_prime = unsat.pop()
+    unsat.add(w_prime)
+    # select node t, a neighbor of w, that is not connected to w_prime
+    w_neighbs = list(G.successors(w))
+    # slightly faster declaring this variable
+    w_prime_neighbs = list(G.successors(w_prime))
+
+    for v in w_neighbs:
+        if (v not in w_prime_neighbs) and w_prime != v:
+            # removes (w,v), add (w_prime,v)  and update data structures
+            G.remove_edge(w, v)
+            G.add_edge(w_prime, v)
+
+            if h_partition_in[v] == partition:
+                chords.add((w, v))
+                chords.discard((w_prime, v))
+
+            h_node_residual_out[w] += 1
+            h_node_residual_out[w_prime] -= 1
+            if h_node_residual_out[w_prime] == 0:
+                unsat.remove(w_prime)
+            return None
+
+    # If neighbor switch didn't work, use unsaturated node
+    return w_prime
+
+
+def _directed_neighbor_switch_rev(
+    G, w, unsat, h_node_residual_in, chords, h_partition_out, partition
+):
+    """The reverse of directed_neighbor_switch.
+
+    Parameters
+    ----------
+    G : networkx directed graph
+        graph within which the edge swap will take place.
+    w : integer
+        node id for which we need to perform a neighbor switch.
+    unsat: set of integers
+        set of node ids that have the same degree as w and are unsaturated.
+    h_node_residual_in: dict of integers
+        for a given node, keeps track of the remaining stubs to be added.
+    chords: set of tuples
+        keeps track of available positions to add edges.
+    h_partition_out: dict of integers
+        for a given node, keeps track of its partition id (out degree).
+    partition: integer
+        partition id to check if chords have to be updated.
+
+    Notes
+    -----
+    Same operation as directed_neighbor_switch except it handles this operation
+    for incoming edges instead of outgoing.
+    """
+    w_prime = unsat.pop()
+    unsat.add(w_prime)
+    # slightly faster declaring these as variables.
+    w_neighbs = list(G.predecessors(w))
+    w_prime_neighbs = list(G.predecessors(w_prime))
+    # select node v, a neighbor of w, that is not connected to w_prime.
+    for v in w_neighbs:
+        if (v not in w_prime_neighbs) and w_prime != v:
+            # removes (v,w), add (v,w_prime) and update data structures.
+            G.remove_edge(v, w)
+            G.add_edge(v, w_prime)
+            if h_partition_out[v] == partition:
+                chords.add((v, w))
+                chords.discard((v, w_prime))
+
+            h_node_residual_in[w] += 1
+            h_node_residual_in[w_prime] -= 1
+            if h_node_residual_in[w_prime] == 0:
+                unsat.remove(w_prime)
+            return None
+
+    # If neighbor switch didn't work, use the unsaturated node.
+    return w_prime
+
+
+@py_random_state(3)
+def directed_joint_degree_graph(in_degrees, out_degrees, nkk, seed=None):
+    """Generates a random simple directed graph with the joint degree.
+
+    Parameters
+    ----------
+    degree_seq :  list of tuples (of size 3)
+        degree sequence contains tuples of nodes with node id, in degree and
+        out degree.
+    nkk  :  dictionary of dictionary of integers
+        directed joint degree dictionary, for nodes of out degree k (first
+        level of dict) and nodes of in degree l (second level of dict)
+        describes the number of edges.
+    seed : hashable object, optional
+        Seed for random number generator.
+
+    Returns
+    -------
+    G : Graph
+        A directed graph with the specified inputs.
+
+    Raises
+    ------
+    NetworkXError
+        If degree_seq and nkk are not realizable as a simple directed graph.
+
+
+    Notes
+    -----
+    Similarly to the undirected version:
+    In each iteration of the "while loop" the algorithm picks two disconnected
+    nodes v and w, of degree k and l correspondingly,  for which nkk[k][l] has
+    not reached its target yet i.e. (for given k,l): n_edges_add < nkk[k][l].
+    It then adds edge (v,w) and always increases the number of edges in graph G
+    by one.
+
+    The intelligence of the algorithm lies in the fact that  it is always
+    possible to add an edge between disconnected nodes v and w, for which
+    nkk[degree(v)][degree(w)] has not reached its target, even if one or both
+    nodes do not have free stubs. If either node v or w does not have a free
+    stub, we perform a "neighbor switch", an edge rewiring move that releases a
+    free stub while keeping nkk the same.
+
+    The difference for the directed version lies in the fact that neighbor
+    switches might not be able to rewire, but in these cases unsaturated nodes
+    can be reassigned to use instead, see [1] for detailed description and
+    proofs.
+
+    The algorithm continues for E (number of edges in the graph) iterations of
+    the "while loop", at which point all entries of the given nkk[k][l] have
+    reached their target values and the construction is complete.
+
+    References
+    ----------
+    [1] B. Tillman, A. Markopoulou, C. T. Butts & M. Gjoka,
+        "Construction of Directed 2K Graphs". In Proc. of KDD 2017.
+
+    Examples
+    --------
+    >>> in_degrees = [0, 1, 1, 2]
+    >>> out_degrees = [1, 1, 1, 1]
+    >>> nkk = {1: {1: 2, 2: 2}}
+    >>> G = nx.directed_joint_degree_graph(in_degrees, out_degrees, nkk)
+    >>>
+    """
+    if not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk):
+        msg = "Input is not realizable as a simple graph"
+        raise nx.NetworkXError(msg)
+
+    # start with an empty directed graph.
+    G = nx.DiGraph()
+
+    # for a given group, keep the list of all node ids.
+    h_degree_nodelist_in = {}
+    h_degree_nodelist_out = {}
+    # for a given group, keep the list of all unsaturated node ids.
+    h_degree_nodelist_in_unsat = {}
+    h_degree_nodelist_out_unsat = {}
+    # for a given node, keep track of the remaining stubs to be added.
+    h_node_residual_out = {}
+    h_node_residual_in = {}
+    # for a given node, keep track of the partition id.
+    h_partition_out = {}
+    h_partition_in = {}
+    # keep track of non-chords between pairs of partition ids.
+    non_chords = {}
+
+    # populate data structures
+    for idx, i in enumerate(in_degrees):
+        idx = int(idx)
+        if i > 0:
+            h_degree_nodelist_in.setdefault(i, [])
+            h_degree_nodelist_in_unsat.setdefault(i, set())
+            h_degree_nodelist_in[i].append(idx)
+            h_degree_nodelist_in_unsat[i].add(idx)
+            h_node_residual_in[idx] = i
+            h_partition_in[idx] = i
+
+    for idx, o in enumerate(out_degrees):
+        o = out_degrees[idx]
+        non_chords[(o, in_degrees[idx])] = non_chords.get((o, in_degrees[idx]), 0) + 1
+        idx = int(idx)
+        if o > 0:
+            h_degree_nodelist_out.setdefault(o, [])
+            h_degree_nodelist_out_unsat.setdefault(o, set())
+            h_degree_nodelist_out[o].append(idx)
+            h_degree_nodelist_out_unsat[o].add(idx)
+            h_node_residual_out[idx] = o
+            h_partition_out[idx] = o
+
+        G.add_node(idx)
+
+    nk_in = {}
+    nk_out = {}
+    for p in h_degree_nodelist_in:
+        nk_in[p] = len(h_degree_nodelist_in[p])
+    for p in h_degree_nodelist_out:
+        nk_out[p] = len(h_degree_nodelist_out[p])
+
+    # iterate over every degree pair (k,l) and add the number of edges given
+    # for each pair.
+    for k in nkk:
+        for l in nkk[k]:
+            n_edges_add = nkk[k][l]
+
+            if n_edges_add > 0:
+                # chords contains a random set of potential edges.
+                chords = set()
+
+                k_len = nk_out[k]
+                l_len = nk_in[l]
+                chords_sample = seed.sample(
+                    range(k_len * l_len), n_edges_add + non_chords.get((k, l), 0)
+                )
+
+                num = 0
+                while len(chords) < n_edges_add:
+                    i = h_degree_nodelist_out[k][chords_sample[num] % k_len]
+                    j = h_degree_nodelist_in[l][chords_sample[num] // k_len]
+                    num += 1
+                    if i != j:
+                        chords.add((i, j))
+
+                # k_unsat and l_unsat consist of nodes of in/out degree k and l
+                # that are unsaturated i.e. those nodes that have at least one
+                # available stub
+                k_unsat = h_degree_nodelist_out_unsat[k]
+                l_unsat = h_degree_nodelist_in_unsat[l]
+
+                while n_edges_add > 0:
+                    v, w = chords.pop()
+                    chords.add((v, w))
+
+                    # if node v has no free stubs then do neighbor switch.
+                    if h_node_residual_out[v] == 0:
+                        _v = _directed_neighbor_switch(
+                            G,
+                            v,
+                            k_unsat,
+                            h_node_residual_out,
+                            chords,
+                            h_partition_in,
+                            l,
+                        )
+                        if _v is not None:
+                            v = _v
+
+                    # if node w has no free stubs then do neighbor switch.
+                    if h_node_residual_in[w] == 0:
+                        _w = _directed_neighbor_switch_rev(
+                            G,
+                            w,
+                            l_unsat,
+                            h_node_residual_in,
+                            chords,
+                            h_partition_out,
+                            k,
+                        )
+                        if _w is not None:
+                            w = _w
+
+                    # add edge (v,w) and update data structures.
+                    G.add_edge(v, w)
+                    h_node_residual_out[v] -= 1
+                    h_node_residual_in[w] -= 1
+                    n_edges_add -= 1
+                    chords.discard((v, w))
+
+                    if h_node_residual_out[v] == 0:
+                        k_unsat.discard(v)
+                    if h_node_residual_in[w] == 0:
+                        l_unsat.discard(w)
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/lattice.py b/myenv/lib/python3.9/site-packages/networkx/generators/lattice.py
new file mode 100644
index 0000000..47f1292
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/lattice.py
@@ -0,0 +1,361 @@
+"""Functions for generating grid graphs and lattices
+
+The :func:`grid_2d_graph`, :func:`triangular_lattice_graph`, and
+:func:`hexagonal_lattice_graph` functions correspond to the three
+`regular tilings of the plane`_, the square, triangular, and hexagonal
+tilings, respectively. :func:`grid_graph` and :func:`hypercube_graph`
+are similar for arbitrary dimensions. Useful relevant discussion can
+be found about `Triangular Tiling`_, and `Square, Hex and Triangle Grids`_
+
+.. _regular tilings of the plane: https://en.wikipedia.org/wiki/List_of_regular_polytopes_and_compounds#Euclidean_tilings
+.. _Square, Hex and Triangle Grids: http://www-cs-students.stanford.edu/~amitp/game-programming/grids/
+.. _Triangular Tiling: https://en.wikipedia.org/wiki/Triangular_tiling
+
+"""
+
+from itertools import repeat
+from math import sqrt
+
+from networkx.classes import set_node_attributes
+from networkx.exception import NetworkXError
+from networkx.generators.classic import cycle_graph, empty_graph, path_graph
+from networkx.relabel import relabel_nodes
+from networkx.utils import flatten, nodes_or_number, pairwise
+
+__all__ = [
+    "grid_2d_graph",
+    "grid_graph",
+    "hypercube_graph",
+    "triangular_lattice_graph",
+    "hexagonal_lattice_graph",
+]
+
+
+@nodes_or_number([0, 1])
+def grid_2d_graph(m, n, periodic=False, create_using=None):
+    """Returns the two-dimensional grid graph.
+
+    The grid graph has each node connected to its four nearest neighbors.
+
+    Parameters
+    ----------
+    m, n : int or iterable container of nodes
+        If an integer, nodes are from `range(n)`.
+        If a container, elements become the coordinate of the nodes.
+
+    periodic : bool or iterable
+        If `periodic` is True, both dimensions are periodic. If False, none
+        are periodic.  If `periodic` is iterable, it should yield 2 bool
+        values indicating whether the 1st and 2nd axes, respectively, are
+        periodic.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+        Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    NetworkX graph
+        The (possibly periodic) grid graph of the specified dimensions.
+
+    """
+    G = empty_graph(0, create_using)
+    row_name, rows = m
+    col_name, cols = n
+    G.add_nodes_from((i, j) for i in rows for j in cols)
+    G.add_edges_from(((i, j), (pi, j)) for pi, i in pairwise(rows) for j in cols)
+    G.add_edges_from(((i, j), (i, pj)) for i in rows for pj, j in pairwise(cols))
+
+    try:
+        periodic_r, periodic_c = periodic
+    except TypeError:
+        periodic_r = periodic_c = periodic
+
+    if periodic_r and len(rows) > 2:
+        first = rows[0]
+        last = rows[-1]
+        G.add_edges_from(((first, j), (last, j)) for j in cols)
+    if periodic_c and len(cols) > 2:
+        first = cols[0]
+        last = cols[-1]
+        G.add_edges_from(((i, first), (i, last)) for i in rows)
+    # both directions for directed
+    if G.is_directed():
+        G.add_edges_from((v, u) for u, v in G.edges())
+    return G
+
+
+def grid_graph(dim, periodic=False):
+    """Returns the *n*-dimensional grid graph.
+
+    The dimension *n* is the length of the list `dim` and the size in
+    each dimension is the value of the corresponding list element.
+
+    Parameters
+    ----------
+    dim : list or tuple of numbers or iterables of nodes
+        'dim' is a tuple or list with, for each dimension, either a number
+        that is the size of that dimension or an iterable of nodes for
+        that dimension. The dimension of the grid_graph is the length
+        of `dim`.
+
+    periodic : bool or iterable
+        If `periodic` is True, all dimensions are periodic. If False all
+        dimensions are not periodic. If `periodic` is iterable, it should
+        yield `dim` bool values each of which indicates whether the
+        corresponding axis is periodic.
+
+    Returns
+    -------
+    NetworkX graph
+        The (possibly periodic) grid graph of the specified dimensions.
+
+    Examples
+    --------
+    To produce a 2 by 3 by 4 grid graph, a graph on 24 nodes:
+
+    >>> from networkx import grid_graph
+    >>> G = grid_graph(dim=(2, 3, 4))
+    >>> len(G)
+    24
+    >>> G = grid_graph(dim=(range(7, 9), range(3, 6)))
+    >>> len(G)
+    6
+    """
+    from networkx.algorithms.operators.product import cartesian_product
+
+    if not dim:
+        return empty_graph(0)
+
+    try:
+        func = (cycle_graph if p else path_graph for p in periodic)
+    except TypeError:
+        func = repeat(cycle_graph if periodic else path_graph)
+
+    G = next(func)(dim[0])
+    for current_dim in dim[1:]:
+        Gnew = next(func)(current_dim)
+        G = cartesian_product(Gnew, G)
+    # graph G is done but has labels of the form (1, (2, (3, 1))) so relabel
+    H = relabel_nodes(G, flatten)
+    return H
+
+
+def hypercube_graph(n):
+    """Returns the *n*-dimensional hypercube graph.
+
+    The nodes are the integers between 0 and ``2 ** n - 1``, inclusive.
+
+    For more information on the hypercube graph, see the Wikipedia
+    article `Hypercube graph`_.
+
+    .. _Hypercube graph: https://en.wikipedia.org/wiki/Hypercube_graph
+
+    Parameters
+    ----------
+    n : int
+        The dimension of the hypercube.
+        The number of nodes in the graph will be ``2 ** n``.
+
+    Returns
+    -------
+    NetworkX graph
+        The hypercube graph of dimension *n*.
+    """
+    dim = n * [2]
+    G = grid_graph(dim)
+    return G
+
+
+def triangular_lattice_graph(
+    m, n, periodic=False, with_positions=True, create_using=None
+):
+    r"""Returns the $m$ by $n$ triangular lattice graph.
+
+    The `triangular lattice graph`_ is a two-dimensional `grid graph`_ in
+    which each square unit has a diagonal edge (each grid unit has a chord).
+
+    The returned graph has $m$ rows and $n$ columns of triangles. Rows and
+    columns include both triangles pointing up and down. Rows form a strip
+    of constant height. Columns form a series of diamond shapes, staggered
+    with the columns on either side. Another way to state the size is that
+    the nodes form a grid of `m+1` rows and `(n + 1) // 2` columns.
+    The odd row nodes are shifted horizontally relative to the even rows.
+
+    Directed graph types have edges pointed up or right.
+
+    Positions of nodes are computed by default or `with_positions is True`.
+    The position of each node (embedded in a euclidean plane) is stored in
+    the graph using equilateral triangles with sidelength 1.
+    The height between rows of nodes is thus $\sqrt(3)/2$.
+    Nodes lie in the first quadrant with the node $(0, 0)$ at the origin.
+
+    .. _triangular lattice graph: http://mathworld.wolfram.com/TriangularGrid.html
+    .. _grid graph: http://www-cs-students.stanford.edu/~amitp/game-programming/grids/
+    .. _Triangular Tiling: https://en.wikipedia.org/wiki/Triangular_tiling
+
+    Parameters
+    ----------
+    m : int
+        The number of rows in the lattice.
+
+    n : int
+        The number of columns in the lattice.
+
+    periodic : bool (default: False)
+        If True, join the boundary vertices of the grid using periodic
+        boundary conditions. The join between boundaries is the final row
+        and column of triangles. This means there is one row and one column
+        fewer nodes for the periodic lattice. Periodic lattices require
+        `m >= 3`, `n >= 5` and are allowed but misaligned if `m` or `n` are odd
+
+    with_positions : bool (default: True)
+        Store the coordinates of each node in the graph node attribute 'pos'.
+        The coordinates provide a lattice with equilateral triangles.
+        Periodic positions shift the nodes vertically in a nonlinear way so
+        the edges don't overlap so much.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+        Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    NetworkX graph
+        The *m* by *n* triangular lattice graph.
+    """
+    H = empty_graph(0, create_using)
+    if n == 0 or m == 0:
+        return H
+    if periodic:
+        if n < 5 or m < 3:
+            msg = f"m > 2 and n > 4 required for periodic. m={m}, n={n}"
+            raise NetworkXError(msg)
+
+    N = (n + 1) // 2  # number of nodes in row
+    rows = range(m + 1)
+    cols = range(N + 1)
+    # Make grid
+    H.add_edges_from(((i, j), (i + 1, j)) for j in rows for i in cols[:N])
+    H.add_edges_from(((i, j), (i, j + 1)) for j in rows[:m] for i in cols)
+    # add diagonals
+    H.add_edges_from(((i, j), (i + 1, j + 1)) for j in rows[1:m:2] for i in cols[:N])
+    H.add_edges_from(((i + 1, j), (i, j + 1)) for j in rows[:m:2] for i in cols[:N])
+    # identify boundary nodes if periodic
+    from networkx.algorithms.minors import contracted_nodes
+
+    if periodic is True:
+        for i in cols:
+            H = contracted_nodes(H, (i, 0), (i, m))
+        for j in rows[:m]:
+            H = contracted_nodes(H, (0, j), (N, j))
+    elif n % 2:
+        # remove extra nodes
+        H.remove_nodes_from((N, j) for j in rows[1::2])
+
+    # Add position node attributes
+    if with_positions:
+        ii = (i for i in cols for j in rows)
+        jj = (j for i in cols for j in rows)
+        xx = (0.5 * (j % 2) + i for i in cols for j in rows)
+        h = sqrt(3) / 2
+        if periodic:
+            yy = (h * j + 0.01 * i * i for i in cols for j in rows)
+        else:
+            yy = (h * j for i in cols for j in rows)
+        pos = {(i, j): (x, y) for i, j, x, y in zip(ii, jj, xx, yy) if (i, j) in H}
+        set_node_attributes(H, pos, "pos")
+    return H
+
+
+def hexagonal_lattice_graph(
+    m, n, periodic=False, with_positions=True, create_using=None
+):
+    """Returns an `m` by `n` hexagonal lattice graph.
+
+    The *hexagonal lattice graph* is a graph whose nodes and edges are
+    the `hexagonal tiling`_ of the plane.
+
+    The returned graph will have `m` rows and `n` columns of hexagons.
+    `Odd numbered columns`_ are shifted up relative to even numbered columns.
+
+    Positions of nodes are computed by default or `with_positions is True`.
+    Node positions creating the standard embedding in the plane
+    with sidelength 1 and are stored in the node attribute 'pos'.
+    `pos = nx.get_node_attributes(G, 'pos')` creates a dict ready for drawing.
+
+    .. _hexagonal tiling: https://en.wikipedia.org/wiki/Hexagonal_tiling
+    .. _Odd numbered columns: http://www-cs-students.stanford.edu/~amitp/game-programming/grids/
+
+    Parameters
+    ----------
+    m : int
+        The number of rows of hexagons in the lattice.
+
+    n : int
+        The number of columns of hexagons in the lattice.
+
+    periodic : bool
+        Whether to make a periodic grid by joining the boundary vertices.
+        For this to work `n` must be odd and both `n > 1` and `m > 1`.
+        The periodic connections create another row and column of hexagons
+        so these graphs have fewer nodes as boundary nodes are identified.
+
+    with_positions : bool (default: True)
+        Store the coordinates of each node in the graph node attribute 'pos'.
+        The coordinates provide a lattice with vertical columns of hexagons
+        offset to interleave and cover the plane.
+        Periodic positions shift the nodes vertically in a nonlinear way so
+        the edges don't overlap so much.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+        Graph type to create. If graph instance, then cleared before populated.
+        If graph is directed, edges will point up or right.
+
+    Returns
+    -------
+    NetworkX graph
+        The *m* by *n* hexagonal lattice graph.
+    """
+    G = empty_graph(0, create_using)
+    if m == 0 or n == 0:
+        return G
+    if periodic and (n % 2 == 1 or m < 2 or n < 2):
+        msg = "periodic hexagonal lattice needs m > 1, n > 1 and even n"
+        raise NetworkXError(msg)
+
+    M = 2 * m  # twice as many nodes as hexagons vertically
+    rows = range(M + 2)
+    cols = range(n + 1)
+    # make lattice
+    col_edges = (((i, j), (i, j + 1)) for i in cols for j in rows[: M + 1])
+    row_edges = (((i, j), (i + 1, j)) for i in cols[:n] for j in rows if i % 2 == j % 2)
+    G.add_edges_from(col_edges)
+    G.add_edges_from(row_edges)
+    # Remove corner nodes with one edge
+    G.remove_node((0, M + 1))
+    G.remove_node((n, (M + 1) * (n % 2)))
+
+    # identify boundary nodes if periodic
+    from networkx.algorithms.minors import contracted_nodes
+
+    if periodic:
+        for i in cols[:n]:
+            G = contracted_nodes(G, (i, 0), (i, M))
+        for i in cols[1:]:
+            G = contracted_nodes(G, (i, 1), (i, M + 1))
+        for j in rows[1:M]:
+            G = contracted_nodes(G, (0, j), (n, j))
+        G.remove_node((n, M))
+
+    # calc position in embedded space
+    ii = (i for i in cols for j in rows)
+    jj = (j for i in cols for j in rows)
+    xx = (0.5 + i + i // 2 + (j % 2) * ((i % 2) - 0.5) for i in cols for j in rows)
+    h = sqrt(3) / 2
+    if periodic:
+        yy = (h * j + 0.01 * i * i for i in cols for j in rows)
+    else:
+        yy = (h * j for i in cols for j in rows)
+    # exclude nodes not in G
+    pos = {(i, j): (x, y) for i, j, x, y in zip(ii, jj, xx, yy) if (i, j) in G}
+    set_node_attributes(G, pos, "pos")
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/line.py b/myenv/lib/python3.9/site-packages/networkx/generators/line.py
new file mode 100644
index 0000000..7432c2f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/line.py
@@ -0,0 +1,501 @@
+"""Functions for generating line graphs."""
+from collections import defaultdict
+from functools import partial
+from itertools import combinations
+
+import networkx as nx
+from networkx.utils import arbitrary_element
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = ["line_graph", "inverse_line_graph"]
+
+
+def line_graph(G, create_using=None):
+    r"""Returns the line graph of the graph or digraph `G`.
+
+    The line graph of a graph `G` has a node for each edge in `G` and an
+    edge joining those nodes if the two edges in `G` share a common node. For
+    directed graphs, nodes are adjacent exactly when the edges they represent
+    form a directed path of length two.
+
+    The nodes of the line graph are 2-tuples of nodes in the original graph (or
+    3-tuples for multigraphs, with the key of the edge as the third element).
+
+    For information about self-loops and more discussion, see the **Notes**
+    section below.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX Graph, DiGraph, MultiGraph, or MultiDigraph.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    L : graph
+        The line graph of G.
+
+    Examples
+    --------
+    >>> G = nx.star_graph(3)
+    >>> L = nx.line_graph(G)
+    >>> print(sorted(map(sorted, L.edges())))  # makes a 3-clique, K3
+    [[(0, 1), (0, 2)], [(0, 1), (0, 3)], [(0, 2), (0, 3)]]
+
+    Edge attributes from `G` are not copied over as node attributes in `L`, but
+    attributes can be copied manually:
+
+    >>> G = nx.path_graph(4)
+    >>> G.add_edges_from((u, v, {"tot": u+v}) for u, v in G.edges)
+    >>> G.edges(data=True)
+    EdgeDataView([(0, 1, {'tot': 1}), (1, 2, {'tot': 3}), (2, 3, {'tot': 5})])
+    >>> H = nx.line_graph(G)
+    >>> H.add_nodes_from((node, G.edges[node]) for node in H)
+    >>> H.nodes(data=True)
+    NodeDataView({(0, 1): {'tot': 1}, (2, 3): {'tot': 5}, (1, 2): {'tot': 3}})
+
+    Notes
+    -----
+    Graph, node, and edge data are not propagated to the new graph. For
+    undirected graphs, the nodes in G must be sortable, otherwise the
+    constructed line graph may not be correct.
+
+    *Self-loops in undirected graphs*
+
+    For an undirected graph `G` without multiple edges, each edge can be
+    written as a set `\{u, v\}`.  Its line graph `L` has the edges of `G` as
+    its nodes. If `x` and `y` are two nodes in `L`, then `\{x, y\}` is an edge
+    in `L` if and only if the intersection of `x` and `y` is nonempty. Thus,
+    the set of all edges is determined by the set of all pairwise intersections
+    of edges in `G`.
+
+    Trivially, every edge in G would have a nonzero intersection with itself,
+    and so every node in `L` should have a self-loop. This is not so
+    interesting, and the original context of line graphs was with simple
+    graphs, which had no self-loops or multiple edges. The line graph was also
+    meant to be a simple graph and thus, self-loops in `L` are not part of the
+    standard definition of a line graph. In a pairwise intersection matrix,
+    this is analogous to excluding the diagonal entries from the line graph
+    definition.
+
+    Self-loops and multiple edges in `G` add nodes to `L` in a natural way, and
+    do not require any fundamental changes to the definition. It might be
+    argued that the self-loops we excluded before should now be included.
+    However, the self-loops are still "trivial" in some sense and thus, are
+    usually excluded.
+
+    *Self-loops in directed graphs*
+
+    For a directed graph `G` without multiple edges, each edge can be written
+    as a tuple `(u, v)`. Its line graph `L` has the edges of `G` as its
+    nodes. If `x` and `y` are two nodes in `L`, then `(x, y)` is an edge in `L`
+    if and only if the tail of `x` matches the head of `y`, for example, if `x
+    = (a, b)` and `y = (b, c)` for some vertices `a`, `b`, and `c` in `G`.
+
+    Due to the directed nature of the edges, it is no longer the case that
+    every edge in `G` should have a self-loop in `L`. Now, the only time
+    self-loops arise is if a node in `G` itself has a self-loop.  So such
+    self-loops are no longer "trivial" but instead, represent essential
+    features of the topology of `G`. For this reason, the historical
+    development of line digraphs is such that self-loops are included. When the
+    graph `G` has multiple edges, once again only superficial changes are
+    required to the definition.
+
+    References
+    ----------
+    * Harary, Frank, and Norman, Robert Z., "Some properties of line digraphs",
+      Rend. Circ. Mat. Palermo, II. Ser. 9 (1960), 161--168.
+    * Hemminger, R. L.; Beineke, L. W. (1978), "Line graphs and line digraphs",
+      in Beineke, L. W.; Wilson, R. J., Selected Topics in Graph Theory,
+      Academic Press Inc., pp. 271--305.
+
+    """
+    if G.is_directed():
+        L = _lg_directed(G, create_using=create_using)
+    else:
+        L = _lg_undirected(G, selfloops=False, create_using=create_using)
+    return L
+
+
+def _lg_directed(G, create_using=None):
+    """Returns the line graph L of the (multi)digraph G.
+
+    Edges in G appear as nodes in L, represented as tuples of the form (u,v)
+    or (u,v,key) if G is a multidigraph. A node in L corresponding to the edge
+    (u,v) is connected to every node corresponding to an edge (v,w).
+
+    Parameters
+    ----------
+    G : digraph
+        A directed graph or directed multigraph.
+    create_using : NetworkX graph constructor, optional
+       Graph type to create. If graph instance, then cleared before populated.
+       Default is to use the same graph class as `G`.
+
+    """
+    L = nx.empty_graph(0, create_using, default=G.__class__)
+
+    # Create a graph specific edge function.
+    get_edges = partial(G.edges, keys=True) if G.is_multigraph() else G.edges
+
+    for from_node in get_edges():
+        # from_node is: (u,v) or (u,v,key)
+        L.add_node(from_node)
+        for to_node in get_edges(from_node[1]):
+            L.add_edge(from_node, to_node)
+
+    return L
+
+
+def _lg_undirected(G, selfloops=False, create_using=None):
+    """Returns the line graph L of the (multi)graph G.
+
+    Edges in G appear as nodes in L, represented as sorted tuples of the form
+    (u,v), or (u,v,key) if G is a multigraph. A node in L corresponding to
+    the edge {u,v} is connected to every node corresponding to an edge that
+    involves u or v.
+
+    Parameters
+    ----------
+    G : graph
+        An undirected graph or multigraph.
+    selfloops : bool
+        If `True`, then self-loops are included in the line graph. If `False`,
+        they are excluded.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Notes
+    -----
+    The standard algorithm for line graphs of undirected graphs does not
+    produce self-loops.
+
+    """
+    L = nx.empty_graph(0, create_using, default=G.__class__)
+
+    # Graph specific functions for edges.
+    get_edges = partial(G.edges, keys=True) if G.is_multigraph() else G.edges
+
+    # Determine if we include self-loops or not.
+    shift = 0 if selfloops else 1
+
+    # Introduce numbering of nodes
+    node_index = {n: i for i, n in enumerate(G)}
+
+    # Lift canonical representation of nodes to edges in line graph
+    edge_key_function = lambda edge: (node_index[edge[0]], node_index[edge[1]])
+
+    edges = set()
+    for u in G:
+        # Label nodes as a sorted tuple of nodes in original graph.
+        # Decide on representation of {u, v} as (u, v) or (v, u) depending on node_index.
+        # -> This ensures a canonical representation and avoids comparing values of different types.
+        nodes = [tuple(sorted(x[:2], key=node_index.get)) + x[2:] for x in get_edges(u)]
+
+        if len(nodes) == 1:
+            # Then the edge will be an isolated node in L.
+            L.add_node(nodes[0])
+
+        # Add a clique of `nodes` to graph. To prevent double adding edges,
+        # especially important for multigraphs, we store the edges in
+        # canonical form in a set.
+        for i, a in enumerate(nodes):
+            edges.update(
+                [
+                    tuple(sorted((a, b), key=edge_key_function))
+                    for b in nodes[i + shift :]
+                ]
+            )
+
+    L.add_edges_from(edges)
+    return L
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def inverse_line_graph(G):
+    """Returns the inverse line graph of graph G.
+
+    If H is a graph, and G is the line graph of H, such that G = L(H).
+    Then H is the inverse line graph of G.
+
+    Not all graphs are line graphs and these do not have an inverse line graph.
+    In these cases this function raises a NetworkXError.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX Graph
+
+    Returns
+    -------
+    H : graph
+        The inverse line graph of G.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is directed or a multigraph
+
+    NetworkXError
+        If G is not a line graph
+
+    Notes
+    -----
+    This is an implementation of the Roussopoulos algorithm.
+
+    If G consists of multiple components, then the algorithm doesn't work.
+    You should invert every component seperately:
+
+    >>> K5 = nx.complete_graph(5)
+    >>> P4 = nx.Graph([("a", "b"), ("b", "c"), ("c", "d")])
+    >>> G = nx.union(K5, P4)
+    >>> root_graphs = []
+    >>> for comp in nx.connected_components(G):
+    ...     root_graphs.append(nx.inverse_line_graph(G.subgraph(comp)))
+    >>> len(root_graphs)
+    2
+
+    References
+    ----------
+    * Roussopolous, N, "A max {m, n} algorithm for determining the graph H from
+      its line graph G", Information Processing Letters 2, (1973), 108--112.
+
+    """
+    if G.number_of_nodes() == 0:
+        return nx.empty_graph(1)
+    elif G.number_of_nodes() == 1:
+        v = arbitrary_element(G)
+        a = (v, 0)
+        b = (v, 1)
+        H = nx.Graph([(a, b)])
+        return H
+    elif G.number_of_nodes() > 1 and G.number_of_edges() == 0:
+        msg = (
+            "inverse_line_graph() doesn't work on an edgeless graph. "
+            "Please use this function on each component seperately."
+        )
+        raise nx.NetworkXError(msg)
+
+    starting_cell = _select_starting_cell(G)
+    P = _find_partition(G, starting_cell)
+    # count how many times each vertex appears in the partition set
+    P_count = {u: 0 for u in G.nodes}
+    for p in P:
+        for u in p:
+            P_count[u] += 1
+
+    if max(P_count.values()) > 2:
+        msg = "G is not a line graph (vertex found in more than two partition cells)"
+        raise nx.NetworkXError(msg)
+    W = tuple((u,) for u in P_count if P_count[u] == 1)
+    H = nx.Graph()
+    H.add_nodes_from(P)
+    H.add_nodes_from(W)
+    for a, b in combinations(H.nodes, 2):
+        if any(a_bit in b for a_bit in a):
+            H.add_edge(a, b)
+    return H
+
+
+def _triangles(G, e):
+    """Return list of all triangles containing edge e"""
+    u, v = e
+    if u not in G:
+        raise nx.NetworkXError(f"Vertex {u} not in graph")
+    if v not in G[u]:
+        raise nx.NetworkXError(f"Edge ({u}, {v}) not in graph")
+    triangle_list = []
+    for x in G[u]:
+        if x in G[v]:
+            triangle_list.append((u, v, x))
+    return triangle_list
+
+
+def _odd_triangle(G, T):
+    """Test whether T is an odd triangle in G
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    T : 3-tuple of vertices forming triangle in G
+
+    Returns
+    -------
+    True is T is an odd triangle
+    False otherwise
+
+    Raises
+    ------
+    NetworkXError
+        T is not a triangle in G
+
+    Notes
+    -----
+    An odd triangle is one in which there exists another vertex in G which is
+    adjacent to either exactly one or exactly all three of the vertices in the
+    triangle.
+
+    """
+    for u in T:
+        if u not in G.nodes():
+            raise nx.NetworkXError(f"Vertex {u} not in graph")
+    for e in list(combinations(T, 2)):
+        if e[0] not in G[e[1]]:
+            raise nx.NetworkXError(f"Edge ({e[0]}, {e[1]}) not in graph")
+
+    T_neighbors = defaultdict(int)
+    for t in T:
+        for v in G[t]:
+            if v not in T:
+                T_neighbors[v] += 1
+    for v in T_neighbors:
+        if T_neighbors[v] in [1, 3]:
+            return True
+    return False
+
+
+def _find_partition(G, starting_cell):
+    """Find a partition of the vertices of G into cells of complete graphs
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    starting_cell : tuple of vertices in G which form a cell
+
+    Returns
+    -------
+    List of tuples of vertices of G
+
+    Raises
+    ------
+    NetworkXError
+        If a cell is not a complete subgraph then G is not a line graph
+    """
+    G_partition = G.copy()
+    P = [starting_cell]  # partition set
+    G_partition.remove_edges_from(list(combinations(starting_cell, 2)))
+    # keep list of partitioned nodes which might have an edge in G_partition
+    partitioned_vertices = list(starting_cell)
+    while G_partition.number_of_edges() > 0:
+        # there are still edges left and so more cells to be made
+        u = partitioned_vertices[-1]
+        deg_u = len(G_partition[u])
+        if deg_u == 0:
+            # if u has no edges left in G_partition then we have found
+            # all of its cells so we do not need to keep looking
+            partitioned_vertices.pop()
+        else:
+            # if u still has edges then we need to find its other cell
+            # this other cell must be a complete subgraph or else G is
+            # not a line graph
+            new_cell = [u] + list(G_partition[u])
+            for u in new_cell:
+                for v in new_cell:
+                    if (u != v) and (v not in G_partition[u]):
+                        msg = (
+                            "G is not a line graph"
+                            "(partition cell not a complete subgraph)"
+                        )
+                        raise nx.NetworkXError(msg)
+            P.append(tuple(new_cell))
+            G_partition.remove_edges_from(list(combinations(new_cell, 2)))
+            partitioned_vertices += new_cell
+    return P
+
+
+def _select_starting_cell(G, starting_edge=None):
+    """Select a cell to initiate _find_partition
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+    starting_edge: an edge to build the starting cell from
+
+    Returns
+    -------
+    Tuple of vertices in G
+
+    Raises
+    ------
+    NetworkXError
+        If it is determined that G is not a line graph
+
+    Notes
+    -----
+    If starting edge not specified then pick an arbitrary edge - doesn't
+    matter which. However, this function may call itself requiring a
+    specific starting edge. Note that the r, s notation for counting
+    triangles is the same as in the Roussopoulos paper cited above.
+    """
+    if starting_edge is None:
+        e = arbitrary_element(G.edges())
+    else:
+        e = starting_edge
+        if e[1] not in G[e[0]]:
+            msg = f"starting_edge ({e[0]}, {e[1]}) is not in the Graph"
+            raise nx.NetworkXError(msg)
+    e_triangles = _triangles(G, e)
+    r = len(e_triangles)
+    if r == 0:
+        # there are no triangles containing e, so the starting cell is just e
+        starting_cell = e
+    elif r == 1:
+        # there is exactly one triangle, T, containing e. If other 2 edges
+        # of T belong only to this triangle then T is starting cell
+        T = e_triangles[0]
+        a, b, c = T
+        # ab was original edge so check the other 2 edges
+        ac_edges = [x for x in _triangles(G, (a, c))]
+        bc_edges = [x for x in _triangles(G, (b, c))]
+        if len(ac_edges) == 1:
+            if len(bc_edges) == 1:
+                starting_cell = T
+            else:
+                return _select_starting_cell(G, starting_edge=(b, c))
+        else:
+            return _select_starting_cell(G, starting_edge=(a, c))
+    else:
+        # r >= 2 so we need to count the number of odd triangles, s
+        s = 0
+        odd_triangles = []
+        for T in e_triangles:
+            if _odd_triangle(G, T):
+                s += 1
+                odd_triangles.append(T)
+        if r == 2 and s == 0:
+            # in this case either triangle works, so just use T
+            starting_cell = T
+        elif r - 1 <= s <= r:
+            # check if odd triangles containing e form complete subgraph
+            # there must be exactly s+2 of them
+            # and they must all be connected
+            triangle_nodes = set()
+            for T in odd_triangles:
+                for x in T:
+                    triangle_nodes.add(x)
+            if len(triangle_nodes) == s + 2:
+                for u in triangle_nodes:
+                    for v in triangle_nodes:
+                        if u != v and (v not in G[u]):
+                            msg = (
+                                "G is not a line graph (odd triangles "
+                                "do not form complete subgraph)"
+                            )
+                            raise nx.NetworkXError(msg)
+                # otherwise then we can use this as the starting cell
+                starting_cell = tuple(triangle_nodes)
+            else:
+                msg = (
+                    "G is not a line graph (odd triangles "
+                    "do not form complete subgraph)"
+                )
+                raise nx.NetworkXError(msg)
+        else:
+            msg = (
+                "G is not a line graph (incorrect number of "
+                "odd triangles around starting edge)"
+            )
+            raise nx.NetworkXError(msg)
+    return starting_cell
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/mycielski.py b/myenv/lib/python3.9/site-packages/networkx/generators/mycielski.py
new file mode 100644
index 0000000..a1729c6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/mycielski.py
@@ -0,0 +1,108 @@
+"""Functions related to the Mycielski Operation and the Mycielskian family
+of graphs.
+
+"""
+
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["mycielskian", "mycielski_graph"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def mycielskian(G, iterations=1):
+    r"""Returns the Mycielskian of a simple, undirected graph G
+
+    The Mycielskian of graph preserves a graph's triangle free
+    property while increasing the chromatic number by 1.
+
+    The Mycielski Operation on a graph, :math:`G=(V, E)`, constructs a new
+    graph with :math:`2|V| + 1` nodes and :math:`3|E| + |V|` edges.
+
+    The construction is as follows:
+
+    Let :math:`V = {0, ..., n-1}`. Construct another vertex set
+    :math:`U = {n, ..., 2n}` and a vertex, `w`.
+    Construct a new graph, `M`, with vertices :math:`U \bigcup V \bigcup w`.
+    For edges, :math:`(u, v) \in E` add edges :math:`(u, v), (u, v + n)`, and
+    :math:`(u + n, v)` to M. Finally, for all vertices :math:`u \in U`, add
+    edge :math:`(u, w)` to M.
+
+    The Mycielski Operation can be done multiple times by repeating the above
+    process iteratively.
+
+    More information can be found at https://en.wikipedia.org/wiki/Mycielskian
+
+    Parameters
+    ----------
+    G : graph
+        A simple, undirected NetworkX graph
+    iterations : int
+        The number of iterations of the Mycielski operation to
+        perform on G. Defaults to 1. Must be a non-negative integer.
+
+    Returns
+    -------
+    M : graph
+        The Mycielskian of G after the specified number of iterations.
+
+    Notes
+    -----
+    Graph, node, and edge data are not necessarily propagated to the new graph.
+
+    """
+
+    M = nx.convert_node_labels_to_integers(G)
+
+    for i in range(iterations):
+        n = M.number_of_nodes()
+        M.add_nodes_from(range(n, 2 * n))
+        old_edges = list(M.edges())
+        M.add_edges_from((u, v + n) for u, v in old_edges)
+        M.add_edges_from((u + n, v) for u, v in old_edges)
+        M.add_node(2 * n)
+        M.add_edges_from((u + n, 2 * n) for u in range(n))
+
+    return M
+
+
+def mycielski_graph(n):
+    """Generator for the n_th Mycielski Graph.
+
+    The Mycielski family of graphs is an infinite set of graphs.
+    :math:`M_1` is the singleton graph, :math:`M_2` is two vertices with an
+    edge, and, for :math:`i > 2`, :math:`M_i` is the Mycielskian of
+    :math:`M_{i-1}`.
+
+    More information can be found at
+    http://mathworld.wolfram.com/MycielskiGraph.html
+
+    Parameters
+    ----------
+    n : int
+        The desired Mycielski Graph.
+
+    Returns
+    -------
+    M : graph
+        The n_th Mycielski Graph
+
+    Notes
+    -----
+    The first graph in the Mycielski sequence is the singleton graph.
+    The Mycielskian of this graph is not the :math:`P_2` graph, but rather the
+    :math:`P_2` graph with an extra, isolated vertex. The second Mycielski
+    graph is the :math:`P_2` graph, so the first two are hard coded.
+    The remaining graphs are generated using the Mycielski operation.
+
+    """
+
+    if n < 1:
+        raise nx.NetworkXError("must satisfy n >= 0")
+
+    if n == 1:
+        return nx.empty_graph(1)
+
+    else:
+        return mycielskian(nx.path_graph(2), n - 2)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/nonisomorphic_trees.py b/myenv/lib/python3.9/site-packages/networkx/generators/nonisomorphic_trees.py
new file mode 100644
index 0000000..5a3a335
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/nonisomorphic_trees.py
@@ -0,0 +1,190 @@
+"""
+Implementation of the Wright, Richmond, Odlyzko and McKay (WROM)
+algorithm for the enumeration of all non-isomorphic free trees of a
+given order.  Rooted trees are represented by level sequences, i.e.,
+lists in which the i-th element specifies the distance of vertex i to
+the root.
+
+"""
+
+__all__ = ["nonisomorphic_trees", "number_of_nonisomorphic_trees"]
+
+import networkx as nx
+
+
+def nonisomorphic_trees(order, create="graph"):
+    """Returns a list of nonisomporphic trees
+
+    Parameters
+    ----------
+    order : int
+      order of the desired tree(s)
+
+    create : graph or matrix (default="Graph)
+      If graph is selected a list of trees will be returned,
+      if matrix is selected a list of adjancency matrix will
+      be returned
+
+    Returns
+    -------
+    G : List of NetworkX Graphs
+
+    M : List of Adjacency matrices
+
+    References
+    ----------
+
+    """
+
+    if order < 2:
+        raise ValueError
+    # start at the path graph rooted at its center
+    layout = list(range(order // 2 + 1)) + list(range(1, (order + 1) // 2))
+
+    while layout is not None:
+        layout = _next_tree(layout)
+        if layout is not None:
+            if create == "graph":
+                yield _layout_to_graph(layout)
+            elif create == "matrix":
+                yield _layout_to_matrix(layout)
+            layout = _next_rooted_tree(layout)
+
+
+def number_of_nonisomorphic_trees(order):
+    """Returns the number of nonisomorphic trees
+
+    Parameters
+    ----------
+    order : int
+      order of the desired tree(s)
+
+    Returns
+    -------
+    length : Number of nonisomorphic graphs for the given order
+
+    References
+    ----------
+
+    """
+    return sum(1 for _ in nonisomorphic_trees(order))
+
+
+def _next_rooted_tree(predecessor, p=None):
+    """One iteration of the Beyer-Hedetniemi algorithm."""
+
+    if p is None:
+        p = len(predecessor) - 1
+        while predecessor[p] == 1:
+            p -= 1
+    if p == 0:
+        return None
+
+    q = p - 1
+    while predecessor[q] != predecessor[p] - 1:
+        q -= 1
+    result = list(predecessor)
+    for i in range(p, len(result)):
+        result[i] = result[i - p + q]
+    return result
+
+
+def _next_tree(candidate):
+    """One iteration of the Wright, Richmond, Odlyzko and McKay
+    algorithm."""
+
+    # valid representation of a free tree if:
+    # there are at least two vertices at layer 1
+    # (this is always the case because we start at the path graph)
+    left, rest = _split_tree(candidate)
+
+    # and the left subtree of the root
+    # is less high than the tree with the left subtree removed
+    left_height = max(left)
+    rest_height = max(rest)
+    valid = rest_height >= left_height
+
+    if valid and rest_height == left_height:
+        # and, if left and rest are of the same height,
+        # if left does not encompass more vertices
+        if len(left) > len(rest):
+            valid = False
+        # and, if they have the same number or vertices,
+        # if left does not come after rest lexicographically
+        elif len(left) == len(rest) and left > rest:
+            valid = False
+
+    if valid:
+        return candidate
+    else:
+        # jump to the next valid free tree
+        p = len(left)
+        new_candidate = _next_rooted_tree(candidate, p)
+        if candidate[p] > 2:
+            new_left, new_rest = _split_tree(new_candidate)
+            new_left_height = max(new_left)
+            suffix = range(1, new_left_height + 2)
+            new_candidate[-len(suffix) :] = suffix
+        return new_candidate
+
+
+def _split_tree(layout):
+    """Returns a tuple of two layouts, one containing the left
+    subtree of the root vertex, and one containing the original tree
+    with the left subtree removed."""
+
+    one_found = False
+    m = None
+    for i in range(len(layout)):
+        if layout[i] == 1:
+            if one_found:
+                m = i
+                break
+            else:
+                one_found = True
+
+    if m is None:
+        m = len(layout)
+
+    left = [layout[i] - 1 for i in range(1, m)]
+    rest = [0] + [layout[i] for i in range(m, len(layout))]
+    return (left, rest)
+
+
+def _layout_to_matrix(layout):
+    """Create the adjacency matrix for the tree specified by the
+    given layout (level sequence)."""
+
+    result = [[0] * len(layout) for i in range(len(layout))]
+    stack = []
+    for i in range(len(layout)):
+        i_level = layout[i]
+        if stack:
+            j = stack[-1]
+            j_level = layout[j]
+            while j_level >= i_level:
+                stack.pop()
+                j = stack[-1]
+                j_level = layout[j]
+            result[i][j] = result[j][i] = 1
+        stack.append(i)
+    return result
+
+
+def _layout_to_graph(layout):
+    """Create a NetworkX Graph for the tree specified by the
+    given layout(level sequence)"""
+    G = nx.Graph()
+    stack = []
+    for i in range(len(layout)):
+        i_level = layout[i]
+        if stack:
+            j = stack[-1]
+            j_level = layout[j]
+            while j_level >= i_level:
+                stack.pop()
+                j = stack[-1]
+                j_level = layout[j]
+            G.add_edge(i, j)
+        stack.append(i)
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/random_clustered.py b/myenv/lib/python3.9/site-packages/networkx/generators/random_clustered.py
new file mode 100644
index 0000000..622fb91
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/random_clustered.py
@@ -0,0 +1,116 @@
+"""Generate graphs with given degree and triangle sequence.
+"""
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = ["random_clustered_graph"]
+
+
+@py_random_state(2)
+def random_clustered_graph(joint_degree_sequence, create_using=None, seed=None):
+    r"""Generate a random graph with the given joint independent edge degree and
+    triangle degree sequence.
+
+    This uses a configuration model-like approach to generate a random graph
+    (with parallel edges and self-loops) by randomly assigning edges to match
+    the given joint degree sequence.
+
+    The joint degree sequence is a list of pairs of integers of the form
+    $[(d_{1,i}, d_{1,t}), \dotsc, (d_{n,i}, d_{n,t})]$. According to this list,
+    vertex $u$ is a member of $d_{u,t}$ triangles and has $d_{u, i}$ other
+    edges. The number $d_{u,t}$ is the *triangle degree* of $u$ and the number
+    $d_{u,i}$ is the *independent edge degree*.
+
+    Parameters
+    ----------
+    joint_degree_sequence : list of integer pairs
+        Each list entry corresponds to the independent edge degree and
+        triangle degree of a node.
+    create_using : NetworkX graph constructor, optional (default MultiGraph)
+       Graph type to create. If graph instance, then cleared before populated.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : MultiGraph
+        A graph with the specified degree sequence. Nodes are labeled
+        starting at 0 with an index corresponding to the position in
+        deg_sequence.
+
+    Raises
+    ------
+    NetworkXError
+        If the independent edge degree sequence sum is not even
+        or the triangle degree sequence sum is not divisible by 3.
+
+    Notes
+    -----
+    As described by Miller [1]_ (see also Newman [2]_ for an equivalent
+    description).
+
+    A non-graphical degree sequence (not realizable by some simple
+    graph) is allowed since this function returns graphs with self
+    loops and parallel edges.  An exception is raised if the
+    independent degree sequence does not have an even sum or the
+    triangle degree sequence sum is not divisible by 3.
+
+    This configuration model-like construction process can lead to
+    duplicate edges and loops.  You can remove the self-loops and
+    parallel edges (see below) which will likely result in a graph
+    that doesn't have the exact degree sequence specified.  This
+    "finite-size effect" decreases as the size of the graph increases.
+
+    References
+    ----------
+    .. [1] Joel C. Miller. "Percolation and epidemics in random clustered
+           networks". In: Physical review. E, Statistical, nonlinear, and soft
+           matter physics 80 (2 Part 1 August 2009).
+    .. [2] M. E. J. Newman. "Random Graphs with Clustering".
+           In: Physical Review Letters 103 (5 July 2009)
+
+    Examples
+    --------
+    >>> deg = [(1, 0), (1, 0), (1, 0), (2, 0), (1, 0), (2, 1), (0, 1), (0, 1)]
+    >>> G = nx.random_clustered_graph(deg)
+
+    To remove parallel edges:
+
+    >>> G = nx.Graph(G)
+
+    To remove self loops:
+
+    >>> G.remove_edges_from(nx.selfloop_edges(G))
+
+    """
+    # In Python 3, zip() returns an iterator. Make this into a list.
+    joint_degree_sequence = list(joint_degree_sequence)
+
+    N = len(joint_degree_sequence)
+    G = nx.empty_graph(N, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    ilist = []
+    tlist = []
+    for n in G:
+        degrees = joint_degree_sequence[n]
+        for icount in range(degrees[0]):
+            ilist.append(n)
+        for tcount in range(degrees[1]):
+            tlist.append(n)
+
+    if len(ilist) % 2 != 0 or len(tlist) % 3 != 0:
+        raise nx.NetworkXError("Invalid degree sequence")
+
+    seed.shuffle(ilist)
+    seed.shuffle(tlist)
+    while ilist:
+        G.add_edge(ilist.pop(), ilist.pop())
+    while tlist:
+        n1 = tlist.pop()
+        n2 = tlist.pop()
+        n3 = tlist.pop()
+        G.add_edges_from([(n1, n2), (n1, n3), (n2, n3)])
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/random_graphs.py b/myenv/lib/python3.9/site-packages/networkx/generators/random_graphs.py
new file mode 100644
index 0000000..d75bbd3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/random_graphs.py
@@ -0,0 +1,1316 @@
+"""
+Generators for random graphs.
+
+"""
+
+import itertools
+import math
+from collections import defaultdict
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+from .classic import complete_graph, empty_graph, path_graph, star_graph
+from .degree_seq import degree_sequence_tree
+
+__all__ = [
+    "fast_gnp_random_graph",
+    "gnp_random_graph",
+    "dense_gnm_random_graph",
+    "gnm_random_graph",
+    "erdos_renyi_graph",
+    "binomial_graph",
+    "newman_watts_strogatz_graph",
+    "watts_strogatz_graph",
+    "connected_watts_strogatz_graph",
+    "random_regular_graph",
+    "barabasi_albert_graph",
+    "dual_barabasi_albert_graph",
+    "extended_barabasi_albert_graph",
+    "powerlaw_cluster_graph",
+    "random_lobster",
+    "random_shell_graph",
+    "random_powerlaw_tree",
+    "random_powerlaw_tree_sequence",
+    "random_kernel_graph",
+]
+
+
+@py_random_state(2)
+def fast_gnp_random_graph(n, p, seed=None, directed=False):
+    """Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph or
+    a binomial graph.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes.
+    p : float
+        Probability for edge creation.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    directed : bool, optional (default=False)
+        If True, this function returns a directed graph.
+
+    Notes
+    -----
+    The $G_{n,p}$ graph algorithm chooses each of the $[n (n - 1)] / 2$
+    (undirected) or $n (n - 1)$ (directed) possible edges with probability $p$.
+
+    This algorithm [1]_ runs in $O(n + m)$ time, where `m` is the expected number of
+    edges, which equals $p n (n - 1) / 2$. This should be faster than
+    :func:`gnp_random_graph` when $p$ is small and the expected number of edges
+    is small (that is, the graph is sparse).
+
+    See Also
+    --------
+    gnp_random_graph
+
+    References
+    ----------
+    .. [1] Vladimir Batagelj and Ulrik Brandes,
+       "Efficient generation of large random networks",
+       Phys. Rev. E, 71, 036113, 2005.
+    """
+    G = empty_graph(n)
+
+    if p <= 0 or p >= 1:
+        return nx.gnp_random_graph(n, p, seed=seed, directed=directed)
+
+    lp = math.log(1.0 - p)
+
+    if directed:
+        G = nx.DiGraph(G)
+        v = 1
+        w = -1
+        while v < n:
+            lr = math.log(1.0 - seed.random())
+            w = w + 1 + int(lr / lp)
+            while w >= v and v < n:
+                w = w - v
+                v = v + 1
+            if v < n:
+                G.add_edge(w, v)
+
+    # Nodes in graph are from 0,n-1 (start with v as the second node index).
+    v = 1
+    w = -1
+    while v < n:
+        lr = math.log(1.0 - seed.random())
+        w = w + 1 + int(lr / lp)
+        while w >= v and v < n:
+            w = w - v
+            v = v + 1
+        if v < n:
+            G.add_edge(v, w)
+    return G
+
+
+@py_random_state(2)
+def gnp_random_graph(n, p, seed=None, directed=False):
+    """Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph
+    or a binomial graph.
+
+    The $G_{n,p}$ model chooses each of the possible edges with probability $p$.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes.
+    p : float
+        Probability for edge creation.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    directed : bool, optional (default=False)
+        If True, this function returns a directed graph.
+
+    See Also
+    --------
+    fast_gnp_random_graph
+
+    Notes
+    -----
+    This algorithm [2]_ runs in $O(n^2)$ time.  For sparse graphs (that is, for
+    small values of $p$), :func:`fast_gnp_random_graph` is a faster algorithm.
+
+    :func:`binomial_graph` and :func:`erdos_renyi_graph` are
+    aliases for :func:`gnp_random_graph`.
+
+    >>> nx.binomial_graph is nx.gnp_random_graph
+    True
+    >>> nx.erdos_renyi_graph is nx.gnp_random_graph
+    True
+
+    References
+    ----------
+    .. [1] P. Erdős and A. Rényi, On Random Graphs, Publ. Math. 6, 290 (1959).
+    .. [2] E. N. Gilbert, Random Graphs, Ann. Math. Stat., 30, 1141 (1959).
+    """
+    if directed:
+        edges = itertools.permutations(range(n), 2)
+        G = nx.DiGraph()
+    else:
+        edges = itertools.combinations(range(n), 2)
+        G = nx.Graph()
+    G.add_nodes_from(range(n))
+    if p <= 0:
+        return G
+    if p >= 1:
+        return complete_graph(n, create_using=G)
+
+    for e in edges:
+        if seed.random() < p:
+            G.add_edge(*e)
+    return G
+
+
+# add some aliases to common names
+binomial_graph = gnp_random_graph
+erdos_renyi_graph = gnp_random_graph
+
+
+@py_random_state(2)
+def dense_gnm_random_graph(n, m, seed=None):
+    """Returns a $G_{n,m}$ random graph.
+
+    In the $G_{n,m}$ model, a graph is chosen uniformly at random from the set
+    of all graphs with $n$ nodes and $m$ edges.
+
+    This algorithm should be faster than :func:`gnm_random_graph` for dense
+    graphs.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes.
+    m : int
+        The number of edges.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    See Also
+    --------
+    gnm_random_graph
+
+    Notes
+    -----
+    Algorithm by Keith M. Briggs Mar 31, 2006.
+    Inspired by Knuth's Algorithm S (Selection sampling technique),
+    in section 3.4.2 of [1]_.
+
+    References
+    ----------
+    .. [1] Donald E. Knuth, The Art of Computer Programming,
+        Volume 2/Seminumerical algorithms, Third Edition, Addison-Wesley, 1997.
+    """
+    mmax = n * (n - 1) // 2
+    if m >= mmax:
+        G = complete_graph(n)
+    else:
+        G = empty_graph(n)
+
+    if n == 1 or m >= mmax:
+        return G
+
+    u = 0
+    v = 1
+    t = 0
+    k = 0
+    while True:
+        if seed.randrange(mmax - t) < m - k:
+            G.add_edge(u, v)
+            k += 1
+            if k == m:
+                return G
+        t += 1
+        v += 1
+        if v == n:  # go to next row of adjacency matrix
+            u += 1
+            v = u + 1
+
+
+@py_random_state(2)
+def gnm_random_graph(n, m, seed=None, directed=False):
+    """Returns a $G_{n,m}$ random graph.
+
+    In the $G_{n,m}$ model, a graph is chosen uniformly at random from the set
+    of all graphs with $n$ nodes and $m$ edges.
+
+    This algorithm should be faster than :func:`dense_gnm_random_graph` for
+    sparse graphs.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes.
+    m : int
+        The number of edges.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    directed : bool, optional (default=False)
+        If True return a directed graph
+
+    See also
+    --------
+    dense_gnm_random_graph
+
+    """
+    if directed:
+        G = nx.DiGraph()
+    else:
+        G = nx.Graph()
+    G.add_nodes_from(range(n))
+
+    if n == 1:
+        return G
+    max_edges = n * (n - 1)
+    if not directed:
+        max_edges /= 2.0
+    if m >= max_edges:
+        return complete_graph(n, create_using=G)
+
+    nlist = list(G)
+    edge_count = 0
+    while edge_count < m:
+        # generate random edge,u,v
+        u = seed.choice(nlist)
+        v = seed.choice(nlist)
+        if u == v or G.has_edge(u, v):
+            continue
+        else:
+            G.add_edge(u, v)
+            edge_count = edge_count + 1
+    return G
+
+
+@py_random_state(3)
+def newman_watts_strogatz_graph(n, k, p, seed=None):
+    """Returns a Newman–Watts–Strogatz small-world graph.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes.
+    k : int
+        Each node is joined with its `k` nearest neighbors in a ring
+        topology.
+    p : float
+        The probability of adding a new edge for each edge.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Notes
+    -----
+    First create a ring over $n$ nodes [1]_.  Then each node in the ring is
+    connected with its $k$ nearest neighbors (or $k - 1$ neighbors if $k$
+    is odd).  Then shortcuts are created by adding new edges as follows: for
+    each edge $(u, v)$ in the underlying "$n$-ring with $k$ nearest
+    neighbors" with probability $p$ add a new edge $(u, w)$ with
+    randomly-chosen existing node $w$.  In contrast with
+    :func:`watts_strogatz_graph`, no edges are removed.
+
+    See Also
+    --------
+    watts_strogatz_graph
+
+    References
+    ----------
+    .. [1] M. E. J. Newman and D. J. Watts,
+       Renormalization group analysis of the small-world network model,
+       Physics Letters A, 263, 341, 1999.
+       https://doi.org/10.1016/S0375-9601(99)00757-4
+    """
+    if k > n:
+        raise nx.NetworkXError("k>=n, choose smaller k or larger n")
+
+    # If k == n the graph return is a complete graph
+    if k == n:
+        return nx.complete_graph(n)
+
+    G = empty_graph(n)
+    nlist = list(G.nodes())
+    fromv = nlist
+    # connect the k/2 neighbors
+    for j in range(1, k // 2 + 1):
+        tov = fromv[j:] + fromv[0:j]  # the first j are now last
+        for i in range(len(fromv)):
+            G.add_edge(fromv[i], tov[i])
+    # for each edge u-v, with probability p, randomly select existing
+    # node w and add new edge u-w
+    e = list(G.edges())
+    for (u, v) in e:
+        if seed.random() < p:
+            w = seed.choice(nlist)
+            # no self-loops and reject if edge u-w exists
+            # is that the correct NWS model?
+            while w == u or G.has_edge(u, w):
+                w = seed.choice(nlist)
+                if G.degree(u) >= n - 1:
+                    break  # skip this rewiring
+            else:
+                G.add_edge(u, w)
+    return G
+
+
+@py_random_state(3)
+def watts_strogatz_graph(n, k, p, seed=None):
+    """Returns a Watts–Strogatz small-world graph.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes
+    k : int
+        Each node is joined with its `k` nearest neighbors in a ring
+        topology.
+    p : float
+        The probability of rewiring each edge
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    See Also
+    --------
+    newman_watts_strogatz_graph
+    connected_watts_strogatz_graph
+
+    Notes
+    -----
+    First create a ring over $n$ nodes [1]_.  Then each node in the ring is joined
+    to its $k$ nearest neighbors (or $k - 1$ neighbors if $k$ is odd).
+    Then shortcuts are created by replacing some edges as follows: for each
+    edge $(u, v)$ in the underlying "$n$-ring with $k$ nearest neighbors"
+    with probability $p$ replace it with a new edge $(u, w)$ with uniformly
+    random choice of existing node $w$.
+
+    In contrast with :func:`newman_watts_strogatz_graph`, the random rewiring
+    does not increase the number of edges. The rewired graph is not guaranteed
+    to be connected as in :func:`connected_watts_strogatz_graph`.
+
+    References
+    ----------
+    .. [1] Duncan J. Watts and Steven H. Strogatz,
+       Collective dynamics of small-world networks,
+       Nature, 393, pp. 440--442, 1998.
+    """
+    if k > n:
+        raise nx.NetworkXError("k>n, choose smaller k or larger n")
+
+    # If k == n, the graph is complete not Watts-Strogatz
+    if k == n:
+        return nx.complete_graph(n)
+
+    G = nx.Graph()
+    nodes = list(range(n))  # nodes are labeled 0 to n-1
+    # connect each node to k/2 neighbors
+    for j in range(1, k // 2 + 1):
+        targets = nodes[j:] + nodes[0:j]  # first j nodes are now last in list
+        G.add_edges_from(zip(nodes, targets))
+    # rewire edges from each node
+    # loop over all nodes in order (label) and neighbors in order (distance)
+    # no self loops or multiple edges allowed
+    for j in range(1, k // 2 + 1):  # outer loop is neighbors
+        targets = nodes[j:] + nodes[0:j]  # first j nodes are now last in list
+        # inner loop in node order
+        for u, v in zip(nodes, targets):
+            if seed.random() < p:
+                w = seed.choice(nodes)
+                # Enforce no self-loops or multiple edges
+                while w == u or G.has_edge(u, w):
+                    w = seed.choice(nodes)
+                    if G.degree(u) >= n - 1:
+                        break  # skip this rewiring
+                else:
+                    G.remove_edge(u, v)
+                    G.add_edge(u, w)
+    return G
+
+
+@py_random_state(4)
+def connected_watts_strogatz_graph(n, k, p, tries=100, seed=None):
+    """Returns a connected Watts–Strogatz small-world graph.
+
+    Attempts to generate a connected graph by repeated generation of
+    Watts–Strogatz small-world graphs.  An exception is raised if the maximum
+    number of tries is exceeded.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes
+    k : int
+        Each node is joined with its `k` nearest neighbors in a ring
+        topology.
+    p : float
+        The probability of rewiring each edge
+    tries : int
+        Number of attempts to generate a connected graph.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Notes
+    -----
+    First create a ring over $n$ nodes [1]_.  Then each node in the ring is joined
+    to its $k$ nearest neighbors (or $k - 1$ neighbors if $k$ is odd).
+    Then shortcuts are created by replacing some edges as follows: for each
+    edge $(u, v)$ in the underlying "$n$-ring with $k$ nearest neighbors"
+    with probability $p$ replace it with a new edge $(u, w)$ with uniformly
+    random choice of existing node $w$.
+    The entire process is repeated until a connected graph results.
+
+    See Also
+    --------
+    newman_watts_strogatz_graph
+    watts_strogatz_graph
+
+    References
+    ----------
+    .. [1] Duncan J. Watts and Steven H. Strogatz,
+       Collective dynamics of small-world networks,
+       Nature, 393, pp. 440--442, 1998.
+    """
+    for i in range(tries):
+        # seed is an RNG so should change sequence each call
+        G = watts_strogatz_graph(n, k, p, seed)
+        if nx.is_connected(G):
+            return G
+    raise nx.NetworkXError("Maximum number of tries exceeded")
+
+
+@py_random_state(2)
+def random_regular_graph(d, n, seed=None):
+    r"""Returns a random $d$-regular graph on $n$ nodes.
+
+    The resulting graph has no self-loops or parallel edges.
+
+    Parameters
+    ----------
+    d : int
+      The degree of each node.
+    n : integer
+      The number of nodes. The value of $n \times d$ must be even.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Notes
+    -----
+    The nodes are numbered from $0$ to $n - 1$.
+
+    Kim and Vu's paper [2]_ shows that this algorithm samples in an
+    asymptotically uniform way from the space of random graphs when
+    $d = O(n^{1 / 3 - \epsilon})$.
+
+    Raises
+    ------
+
+    NetworkXError
+        If $n \times d$ is odd or $d$ is greater than or equal to $n$.
+
+    References
+    ----------
+    .. [1] A. Steger and N. Wormald,
+       Generating random regular graphs quickly,
+       Probability and Computing 8 (1999), 377-396, 1999.
+       http://citeseer.ist.psu.edu/steger99generating.html
+
+    .. [2] Jeong Han Kim and Van H. Vu,
+       Generating random regular graphs,
+       Proceedings of the thirty-fifth ACM symposium on Theory of computing,
+       San Diego, CA, USA, pp 213--222, 2003.
+       http://portal.acm.org/citation.cfm?id=780542.780576
+    """
+    if (n * d) % 2 != 0:
+        raise nx.NetworkXError("n * d must be even")
+
+    if not 0 <= d < n:
+        raise nx.NetworkXError("the 0 <= d < n inequality must be satisfied")
+
+    if d == 0:
+        return empty_graph(n)
+
+    def _suitable(edges, potential_edges):
+        # Helper subroutine to check if there are suitable edges remaining
+        # If False, the generation of the graph has failed
+        if not potential_edges:
+            return True
+        for s1 in potential_edges:
+            for s2 in potential_edges:
+                # Two iterators on the same dictionary are guaranteed
+                # to visit it in the same order if there are no
+                # intervening modifications.
+                if s1 == s2:
+                    # Only need to consider s1-s2 pair one time
+                    break
+                if s1 > s2:
+                    s1, s2 = s2, s1
+                if (s1, s2) not in edges:
+                    return True
+        return False
+
+    def _try_creation():
+        # Attempt to create an edge set
+
+        edges = set()
+        stubs = list(range(n)) * d
+
+        while stubs:
+            potential_edges = defaultdict(lambda: 0)
+            seed.shuffle(stubs)
+            stubiter = iter(stubs)
+            for s1, s2 in zip(stubiter, stubiter):
+                if s1 > s2:
+                    s1, s2 = s2, s1
+                if s1 != s2 and ((s1, s2) not in edges):
+                    edges.add((s1, s2))
+                else:
+                    potential_edges[s1] += 1
+                    potential_edges[s2] += 1
+
+            if not _suitable(edges, potential_edges):
+                return None  # failed to find suitable edge set
+
+            stubs = [
+                node
+                for node, potential in potential_edges.items()
+                for _ in range(potential)
+            ]
+        return edges
+
+    # Even though a suitable edge set exists,
+    # the generation of such a set is not guaranteed.
+    # Try repeatedly to find one.
+    edges = _try_creation()
+    while edges is None:
+        edges = _try_creation()
+
+    G = nx.Graph()
+    G.add_edges_from(edges)
+
+    return G
+
+
+def _random_subset(seq, m, rng):
+    """Return m unique elements from seq.
+
+    This differs from random.sample which can return repeated
+    elements if seq holds repeated elements.
+
+    Note: rng is a random.Random or numpy.random.RandomState instance.
+    """
+    targets = set()
+    while len(targets) < m:
+        x = rng.choice(seq)
+        targets.add(x)
+    return targets
+
+
+@py_random_state(2)
+def barabasi_albert_graph(n, m, seed=None, initial_graph=None):
+    """Returns a random graph using Barabási–Albert preferential attachment
+
+    A graph of $n$ nodes is grown by attaching new nodes each with $m$
+    edges that are preferentially attached to existing nodes with high degree.
+
+    Parameters
+    ----------
+    n : int
+        Number of nodes
+    m : int
+        Number of edges to attach from a new node to existing nodes
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    initial_graph : Graph or None (default)
+        Initial network for Barabási–Albert algorithm.
+        It should be a connected graph for most use cases.
+        A copy of `initial_graph` is used.
+        If None, starts from a star graph on (m+1) nodes.
+
+    Returns
+    -------
+    G : Graph
+
+    Raises
+    ------
+    NetworkXError
+        If `m` does not satisfy ``1 <= m < n``, or
+        the initial graph number of nodes m0 does not satisfy ``m <= m0 <= n``.
+
+    References
+    ----------
+    .. [1] A. L. Barabási and R. Albert "Emergence of scaling in
+       random networks", Science 286, pp 509-512, 1999.
+    """
+
+    if m < 1 or m >= n:
+        raise nx.NetworkXError(
+            f"Barabási–Albert network must have m >= 1 and m < n, m = {m}, n = {n}"
+        )
+
+    if initial_graph is None:
+        # Default initial graph : star graph on (m + 1) nodes
+        G = star_graph(m)
+    else:
+        if len(initial_graph) < m or len(initial_graph) > n:
+            raise nx.NetworkXError(
+                f"Barabási–Albert initial graph needs between m={m} and n={n} nodes"
+            )
+        G = initial_graph.copy()
+
+    # List of existing nodes, with nodes repeated once for each adjacent edge
+    repeated_nodes = [n for n, d in G.degree() for _ in range(d)]
+    # Start adding the other n - m0 nodes.
+    source = len(G)
+    while source < n:
+        # Now choose m unique nodes from the existing nodes
+        # Pick uniformly from repeated_nodes (preferential attachment)
+        targets = _random_subset(repeated_nodes, m, seed)
+        # Add edges to m nodes from the source.
+        G.add_edges_from(zip([source] * m, targets))
+        # Add one node to the list for each new edge just created.
+        repeated_nodes.extend(targets)
+        # And the new node "source" has m edges to add to the list.
+        repeated_nodes.extend([source] * m)
+
+        source += 1
+    return G
+
+
+@py_random_state(4)
+def dual_barabasi_albert_graph(n, m1, m2, p, seed=None, initial_graph=None):
+    """Returns a random graph using dual Barabási–Albert preferential attachment
+
+    A graph of $n$ nodes is grown by attaching new nodes each with either $m_1$
+    edges (with probability $p$) or $m_2$ edges (with probability $1-p$) that
+    are preferentially attached to existing nodes with high degree.
+
+    Parameters
+    ----------
+    n : int
+        Number of nodes
+    m1 : int
+        Number of edges to link each new node to existing nodes with probability $p$
+    m2 : int
+        Number of edges to link each new node to existing nodes with probability $1-p$
+    p : float
+        The probability of attaching $m_1$ edges (as opposed to $m_2$ edges)
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    initial_graph : Graph or None (default)
+        Initial network for Barabási–Albert algorithm.
+        A copy of `initial_graph` is used.
+        It should be connected for most use cases.
+        If None, starts from an star graph on max(m1, m2) + 1 nodes.
+
+    Returns
+    -------
+    G : Graph
+
+    Raises
+    ------
+    NetworkXError
+        If `m1` and `m2` do not satisfy ``1 <= m1,m2 < n``, or
+        `p` does not satisfy ``0 <= p <= 1``, or
+        the initial graph number of nodes m0 does not satisfy m1, m2 <= m0 <= n.
+
+    References
+    ----------
+    .. [1] N. Moshiri "The dual-Barabasi-Albert model", arXiv:1810.10538.
+    """
+
+    if m1 < 1 or m1 >= n:
+        raise nx.NetworkXError(
+            f"Dual Barabási–Albert must have m1 >= 1 and m1 < n, m1 = {m1}, n = {n}"
+        )
+    if m2 < 1 or m2 >= n:
+        raise nx.NetworkXError(
+            f"Dual Barabási–Albert must have m2 >= 1 and m2 < n, m2 = {m2}, n = {n}"
+        )
+    if p < 0 or p > 1:
+        raise nx.NetworkXError(
+            f"Dual Barabási–Albert network must have 0 <= p <= 1, p = {p}"
+        )
+
+    # For simplicity, if p == 0 or 1, just return BA
+    if p == 1:
+        return barabasi_albert_graph(n, m1, seed)
+    elif p == 0:
+        return barabasi_albert_graph(n, m2, seed)
+
+    if initial_graph is None:
+        # Default initial graph : empty graph on max(m1, m2) nodes
+        G = star_graph(max(m1, m2))
+    else:
+        if len(initial_graph) < max(m1, m2) or len(initial_graph) > n:
+            raise nx.NetworkXError(
+                f"Barabási–Albert initial graph must have between "
+                f"max(m1, m2) = {max(m1, m2)} and n = {n} nodes"
+            )
+        G = initial_graph.copy()
+
+    # Target nodes for new edges
+    targets = list(G)
+    # List of existing nodes, with nodes repeated once for each adjacent edge
+    repeated_nodes = [n for n, d in G.degree() for _ in range(d)]
+    # Start adding the remaining nodes.
+    source = len(G)
+    while source < n:
+        # Pick which m to use (m1 or m2)
+        if seed.random() < p:
+            m = m1
+        else:
+            m = m2
+        # Now choose m unique nodes from the existing nodes
+        # Pick uniformly from repeated_nodes (preferential attachment)
+        targets = _random_subset(repeated_nodes, m, seed)
+        # Add edges to m nodes from the source.
+        G.add_edges_from(zip([source] * m, targets))
+        # Add one node to the list for each new edge just created.
+        repeated_nodes.extend(targets)
+        # And the new node "source" has m edges to add to the list.
+        repeated_nodes.extend([source] * m)
+
+        source += 1
+    return G
+
+
+@py_random_state(4)
+def extended_barabasi_albert_graph(n, m, p, q, seed=None):
+    """Returns an extended Barabási–Albert model graph.
+
+    An extended Barabási–Albert model graph is a random graph constructed
+    using preferential attachment. The extended model allows new edges,
+    rewired edges or new nodes. Based on the probabilities $p$ and $q$
+    with $p + q < 1$, the growing behavior of the graph is determined as:
+
+    1) With $p$ probability, $m$ new edges are added to the graph,
+    starting from randomly chosen existing nodes and attached preferentially at the other end.
+
+    2) With $q$ probability, $m$ existing edges are rewired
+    by randomly choosing an edge and rewiring one end to a preferentially chosen node.
+
+    3) With $(1 - p - q)$ probability, $m$ new nodes are added to the graph
+    with edges attached preferentially.
+
+    When $p = q = 0$, the model behaves just like the Barabási–Alber model.
+
+    Parameters
+    ----------
+    n : int
+        Number of nodes
+    m : int
+        Number of edges with which a new node attaches to existing nodes
+    p : float
+        Probability value for adding an edge between existing nodes. p + q < 1
+    q : float
+        Probability value of rewiring of existing edges. p + q < 1
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    G : Graph
+
+    Raises
+    ------
+    NetworkXError
+        If `m` does not satisfy ``1 <= m < n`` or ``1 >= p + q``
+
+    References
+    ----------
+    .. [1] Albert, R., & Barabási, A. L. (2000)
+       Topology of evolving networks: local events and universality
+       Physical review letters, 85(24), 5234.
+    """
+    if m < 1 or m >= n:
+        msg = f"Extended Barabasi-Albert network needs m>=1 and m<n, m={m}, n={n}"
+        raise nx.NetworkXError(msg)
+    if p + q >= 1:
+        msg = f"Extended Barabasi-Albert network needs p + q <= 1, p={p}, q={q}"
+        raise nx.NetworkXError(msg)
+
+    # Add m initial nodes (m0 in barabasi-speak)
+    G = empty_graph(m)
+
+    # List of nodes to represent the preferential attachment random selection.
+    # At the creation of the graph, all nodes are added to the list
+    # so that even nodes that are not connected have a chance to get selected,
+    # for rewiring and adding of edges.
+    # With each new edge, nodes at the ends of the edge are added to the list.
+    attachment_preference = []
+    attachment_preference.extend(range(m))
+
+    # Start adding the other n-m nodes. The first node is m.
+    new_node = m
+    while new_node < n:
+        a_probability = seed.random()
+
+        # Total number of edges of a Clique of all the nodes
+        clique_degree = len(G) - 1
+        clique_size = (len(G) * clique_degree) / 2
+
+        # Adding m new edges, if there is room to add them
+        if a_probability < p and G.size() <= clique_size - m:
+            # Select the nodes where an edge can be added
+            elligible_nodes = [nd for nd, deg in G.degree() if deg < clique_degree]
+            for i in range(m):
+                # Choosing a random source node from elligible_nodes
+                src_node = seed.choice(elligible_nodes)
+
+                # Picking a possible node that is not 'src_node' or
+                # neighbor with 'src_node', with preferential attachment
+                prohibited_nodes = list(G[src_node])
+                prohibited_nodes.append(src_node)
+                # This will raise an exception if the sequence is empty
+                dest_node = seed.choice(
+                    [nd for nd in attachment_preference if nd not in prohibited_nodes]
+                )
+                # Adding the new edge
+                G.add_edge(src_node, dest_node)
+
+                # Appending both nodes to add to their preferential attachment
+                attachment_preference.append(src_node)
+                attachment_preference.append(dest_node)
+
+                # Adjusting the elligible nodes. Degree may be saturated.
+                if G.degree(src_node) == clique_degree:
+                    elligible_nodes.remove(src_node)
+                if (
+                    G.degree(dest_node) == clique_degree
+                    and dest_node in elligible_nodes
+                ):
+                    elligible_nodes.remove(dest_node)
+
+        # Rewiring m edges, if there are enough edges
+        elif p <= a_probability < (p + q) and m <= G.size() < clique_size:
+            # Selecting nodes that have at least 1 edge but that are not
+            # fully connected to ALL other nodes (center of star).
+            # These nodes are the pivot nodes of the edges to rewire
+            elligible_nodes = [nd for nd, deg in G.degree() if 0 < deg < clique_degree]
+            for i in range(m):
+                # Choosing a random source node
+                node = seed.choice(elligible_nodes)
+
+                # The available nodes do have a neighbor at least.
+                neighbor_nodes = list(G[node])
+
+                # Choosing the other end that will get dettached
+                src_node = seed.choice(neighbor_nodes)
+
+                # Picking a target node that is not 'node' or
+                # neighbor with 'node', with preferential attachment
+                neighbor_nodes.append(node)
+                dest_node = seed.choice(
+                    [nd for nd in attachment_preference if nd not in neighbor_nodes]
+                )
+                # Rewire
+                G.remove_edge(node, src_node)
+                G.add_edge(node, dest_node)
+
+                # Adjusting the preferential attachment list
+                attachment_preference.remove(src_node)
+                attachment_preference.append(dest_node)
+
+                # Adjusting the elligible nodes.
+                # nodes may be saturated or isolated.
+                if G.degree(src_node) == 0 and src_node in elligible_nodes:
+                    elligible_nodes.remove(src_node)
+                if dest_node in elligible_nodes:
+                    if G.degree(dest_node) == clique_degree:
+                        elligible_nodes.remove(dest_node)
+                else:
+                    if G.degree(dest_node) == 1:
+                        elligible_nodes.append(dest_node)
+
+        # Adding new node with m edges
+        else:
+            # Select the edges' nodes by preferential attachment
+            targets = _random_subset(attachment_preference, m, seed)
+            G.add_edges_from(zip([new_node] * m, targets))
+
+            # Add one node to the list for each new edge just created.
+            attachment_preference.extend(targets)
+            # The new node has m edges to it, plus itself: m + 1
+            attachment_preference.extend([new_node] * (m + 1))
+            new_node += 1
+    return G
+
+
+@py_random_state(3)
+def powerlaw_cluster_graph(n, m, p, seed=None):
+    """Holme and Kim algorithm for growing graphs with powerlaw
+    degree distribution and approximate average clustering.
+
+    Parameters
+    ----------
+    n : int
+        the number of nodes
+    m : int
+        the number of random edges to add for each new node
+    p : float,
+        Probability of adding a triangle after adding a random edge
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Notes
+    -----
+    The average clustering has a hard time getting above a certain
+    cutoff that depends on `m`.  This cutoff is often quite low.  The
+    transitivity (fraction of triangles to possible triangles) seems to
+    decrease with network size.
+
+    It is essentially the Barabási–Albert (BA) growth model with an
+    extra step that each random edge is followed by a chance of
+    making an edge to one of its neighbors too (and thus a triangle).
+
+    This algorithm improves on BA in the sense that it enables a
+    higher average clustering to be attained if desired.
+
+    It seems possible to have a disconnected graph with this algorithm
+    since the initial `m` nodes may not be all linked to a new node
+    on the first iteration like the BA model.
+
+    Raises
+    ------
+    NetworkXError
+        If `m` does not satisfy ``1 <= m <= n`` or `p` does not
+        satisfy ``0 <= p <= 1``.
+
+    References
+    ----------
+    .. [1] P. Holme and B. J. Kim,
+       "Growing scale-free networks with tunable clustering",
+       Phys. Rev. E, 65, 026107, 2002.
+    """
+
+    if m < 1 or n < m:
+        raise nx.NetworkXError(f"NetworkXError must have m>1 and m<n, m={m},n={n}")
+
+    if p > 1 or p < 0:
+        raise nx.NetworkXError(f"NetworkXError p must be in [0,1], p={p}")
+
+    G = empty_graph(m)  # add m initial nodes (m0 in barabasi-speak)
+    repeated_nodes = list(G.nodes())  # list of existing nodes to sample from
+    # with nodes repeated once for each adjacent edge
+    source = m  # next node is m
+    while source < n:  # Now add the other n-1 nodes
+        possible_targets = _random_subset(repeated_nodes, m, seed)
+        # do one preferential attachment for new node
+        target = possible_targets.pop()
+        G.add_edge(source, target)
+        repeated_nodes.append(target)  # add one node to list for each new link
+        count = 1
+        while count < m:  # add m-1 more new links
+            if seed.random() < p:  # clustering step: add triangle
+                neighborhood = [
+                    nbr
+                    for nbr in G.neighbors(target)
+                    if not G.has_edge(source, nbr) and not nbr == source
+                ]
+                if neighborhood:  # if there is a neighbor without a link
+                    nbr = seed.choice(neighborhood)
+                    G.add_edge(source, nbr)  # add triangle
+                    repeated_nodes.append(nbr)
+                    count = count + 1
+                    continue  # go to top of while loop
+            # else do preferential attachment step if above fails
+            target = possible_targets.pop()
+            G.add_edge(source, target)
+            repeated_nodes.append(target)
+            count = count + 1
+
+        repeated_nodes.extend([source] * m)  # add source node to list m times
+        source += 1
+    return G
+
+
+@py_random_state(3)
+def random_lobster(n, p1, p2, seed=None):
+    """Returns a random lobster graph.
+
+    A lobster is a tree that reduces to a caterpillar when pruning all
+    leaf nodes. A caterpillar is a tree that reduces to a path graph
+    when pruning all leaf nodes; setting `p2` to zero produces a caterpillar.
+
+    This implementation iterates on the probabilities `p1` and `p2` to add
+    edges at levels 1 and 2, respectively. Graphs are therefore constructed
+    iteratively with uniform randomness at each level rather than being selected
+    uniformly at random from the set of all possible lobsters.
+
+    Parameters
+    ----------
+    n : int
+        The expected number of nodes in the backbone
+    p1 : float
+        Probability of adding an edge to the backbone
+    p2 : float
+        Probability of adding an edge one level beyond backbone
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Raises
+    ------
+    NetworkXError
+        If `p1` or `p2` parameters are >= 1 because the while loops would never finish.
+    """
+    p1, p2 = abs(p1), abs(p2)
+    if any([p >= 1 for p in [p1, p2]]):
+        raise nx.NetworkXError("Probability values for `p1` and `p2` must both be < 1.")
+
+    # a necessary ingredient in any self-respecting graph library
+    llen = int(2 * seed.random() * n + 0.5)
+    L = path_graph(llen)
+    # build caterpillar: add edges to path graph with probability p1
+    current_node = llen - 1
+    for n in range(llen):
+        while seed.random() < p1:  # add fuzzy caterpillar parts
+            current_node += 1
+            L.add_edge(n, current_node)
+            cat_node = current_node
+            while seed.random() < p2:  # add crunchy lobster bits
+                current_node += 1
+                L.add_edge(cat_node, current_node)
+    return L  # voila, un lobster!
+
+
+@py_random_state(1)
+def random_shell_graph(constructor, seed=None):
+    """Returns a random shell graph for the constructor given.
+
+    Parameters
+    ----------
+    constructor : list of three-tuples
+        Represents the parameters for a shell, starting at the center
+        shell.  Each element of the list must be of the form `(n, m,
+        d)`, where `n` is the number of nodes in the shell, `m` is
+        the number of edges in the shell, and `d` is the ratio of
+        inter-shell (next) edges to intra-shell edges. If `d` is zero,
+        there will be no intra-shell edges, and if `d` is one there
+        will be all possible intra-shell edges.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Examples
+    --------
+    >>> constructor = [(10, 20, 0.8), (20, 40, 0.8)]
+    >>> G = nx.random_shell_graph(constructor)
+
+    """
+    G = empty_graph(0)
+
+    glist = []
+    intra_edges = []
+    nnodes = 0
+    # create gnm graphs for each shell
+    for (n, m, d) in constructor:
+        inter_edges = int(m * d)
+        intra_edges.append(m - inter_edges)
+        g = nx.convert_node_labels_to_integers(
+            gnm_random_graph(n, inter_edges, seed=seed), first_label=nnodes
+        )
+        glist.append(g)
+        nnodes += n
+        G = nx.operators.union(G, g)
+
+    # connect the shells randomly
+    for gi in range(len(glist) - 1):
+        nlist1 = list(glist[gi])
+        nlist2 = list(glist[gi + 1])
+        total_edges = intra_edges[gi]
+        edge_count = 0
+        while edge_count < total_edges:
+            u = seed.choice(nlist1)
+            v = seed.choice(nlist2)
+            if u == v or G.has_edge(u, v):
+                continue
+            else:
+                G.add_edge(u, v)
+                edge_count = edge_count + 1
+    return G
+
+
+@py_random_state(2)
+def random_powerlaw_tree(n, gamma=3, seed=None, tries=100):
+    """Returns a tree with a power law degree distribution.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes.
+    gamma : float
+        Exponent of the power law.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    tries : int
+        Number of attempts to adjust the sequence to make it a tree.
+
+    Raises
+    ------
+    NetworkXError
+        If no valid sequence is found within the maximum number of
+        attempts.
+
+    Notes
+    -----
+    A trial power law degree sequence is chosen and then elements are
+    swapped with new elements from a powerlaw distribution until the
+    sequence makes a tree (by checking, for example, that the number of
+    edges is one smaller than the number of nodes).
+
+    """
+    # This call may raise a NetworkXError if the number of tries is succeeded.
+    seq = random_powerlaw_tree_sequence(n, gamma=gamma, seed=seed, tries=tries)
+    G = degree_sequence_tree(seq)
+    return G
+
+
+@py_random_state(2)
+def random_powerlaw_tree_sequence(n, gamma=3, seed=None, tries=100):
+    """Returns a degree sequence for a tree with a power law distribution.
+
+    Parameters
+    ----------
+    n : int,
+        The number of nodes.
+    gamma : float
+        Exponent of the power law.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    tries : int
+        Number of attempts to adjust the sequence to make it a tree.
+
+    Raises
+    ------
+    NetworkXError
+        If no valid sequence is found within the maximum number of
+        attempts.
+
+    Notes
+    -----
+    A trial power law degree sequence is chosen and then elements are
+    swapped with new elements from a power law distribution until
+    the sequence makes a tree (by checking, for example, that the number of
+    edges is one smaller than the number of nodes).
+
+    """
+    # get trial sequence
+    z = nx.utils.powerlaw_sequence(n, exponent=gamma, seed=seed)
+    # round to integer values in the range [0,n]
+    zseq = [min(n, max(round(s), 0)) for s in z]
+
+    # another sequence to swap values from
+    z = nx.utils.powerlaw_sequence(tries, exponent=gamma, seed=seed)
+    # round to integer values in the range [0,n]
+    swap = [min(n, max(round(s), 0)) for s in z]
+
+    for deg in swap:
+        # If this degree sequence can be the degree sequence of a tree, return
+        # it. It can be a tree if the number of edges is one fewer than the
+        # number of nodes, or in other words, `n - sum(zseq) / 2 == 1`. We
+        # use an equivalent condition below that avoids floating point
+        # operations.
+        if 2 * n - sum(zseq) == 2:
+            return zseq
+        index = seed.randint(0, n - 1)
+        zseq[index] = swap.pop()
+
+    raise nx.NetworkXError(
+        f"Exceeded max ({tries}) attempts for a valid tree sequence."
+    )
+
+
+@py_random_state(3)
+def random_kernel_graph(n, kernel_integral, kernel_root=None, seed=None):
+    r"""Returns an random graph based on the specified kernel.
+
+    The algorithm chooses each of the $[n(n-1)]/2$ possible edges with
+    probability specified by a kernel $\kappa(x,y)$ [1]_.  The kernel
+    $\kappa(x,y)$ must be a symmetric (in $x,y$), non-negative,
+    bounded function.
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes
+    kernel_integral : function
+        Function that returns the definite integral of the kernel $\kappa(x,y)$,
+        $F(y,a,b) := \int_a^b \kappa(x,y)dx$
+    kernel_root: function (optional)
+        Function that returns the root $b$ of the equation $F(y,a,b) = r$.
+        If None, the root is found using :func:`scipy.optimize.brentq`
+        (this requires SciPy).
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Notes
+    -----
+    The kernel is specified through its definite integral which must be
+    provided as one of the arguments. If the integral and root of the
+    kernel integral can be found in $O(1)$ time then this algorithm runs in
+    time $O(n+m)$ where m is the expected number of edges [2]_.
+
+    The nodes are set to integers from $0$ to $n-1$.
+
+    Examples
+    --------
+    Generate an Erdős–Rényi random graph $G(n,c/n)$, with kernel
+    $\kappa(x,y)=c$ where $c$ is the mean expected degree.
+
+    >>> def integral(u, w, z):
+    ...     return c * (z - w)
+    >>> def root(u, w, r):
+    ...     return r / c + w
+    >>> c = 1
+    >>> graph = nx.random_kernel_graph(1000, integral, root)
+
+    See Also
+    --------
+    gnp_random_graph
+    expected_degree_graph
+
+    References
+    ----------
+    .. [1] Bollobás, Béla,  Janson, S. and Riordan, O.
+       "The phase transition in inhomogeneous random graphs",
+       *Random Structures Algorithms*, 31, 3--122, 2007.
+
+    .. [2] Hagberg A, Lemons N (2015),
+       "Fast Generation of Sparse Random Kernel Graphs".
+       PLoS ONE 10(9): e0135177, 2015. doi:10.1371/journal.pone.0135177
+    """
+    if kernel_root is None:
+        import scipy as sp
+        import scipy.optimize  # call as sp.optimize
+
+        def kernel_root(y, a, r):
+            def my_function(b):
+                return kernel_integral(y, a, b) - r
+
+            return sp.optimize.brentq(my_function, a, 1)
+
+    graph = nx.Graph()
+    graph.add_nodes_from(range(n))
+    (i, j) = (1, 1)
+    while i < n:
+        r = -math.log(1 - seed.random())  # (1-seed.random()) in (0, 1]
+        if kernel_integral(i / n, j / n, 1) <= r:
+            i, j = i + 1, i + 1
+        else:
+            j = math.ceil(n * kernel_root(i / n, j / n, r))
+            graph.add_edge(i - 1, j - 1)
+    return graph
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/small.py b/myenv/lib/python3.9/site-packages/networkx/generators/small.py
new file mode 100644
index 0000000..7b4dd57
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/small.py
@@ -0,0 +1,1065 @@
+"""
+Various small and named graphs, together with some compact generators.
+
+"""
+
+__all__ = [
+    "make_small_graph",
+    "LCF_graph",
+    "bull_graph",
+    "chvatal_graph",
+    "cubical_graph",
+    "desargues_graph",
+    "diamond_graph",
+    "dodecahedral_graph",
+    "frucht_graph",
+    "heawood_graph",
+    "hoffman_singleton_graph",
+    "house_graph",
+    "house_x_graph",
+    "icosahedral_graph",
+    "krackhardt_kite_graph",
+    "moebius_kantor_graph",
+    "octahedral_graph",
+    "pappus_graph",
+    "petersen_graph",
+    "sedgewick_maze_graph",
+    "tetrahedral_graph",
+    "truncated_cube_graph",
+    "truncated_tetrahedron_graph",
+    "tutte_graph",
+]
+
+from functools import wraps
+
+import networkx as nx
+from networkx.exception import NetworkXError
+from networkx.generators.classic import (
+    complete_graph,
+    cycle_graph,
+    empty_graph,
+    path_graph,
+)
+
+
+def _raise_on_directed(func):
+    """
+    A decorator which inspects the `create_using` argument and raises a
+    NetworkX exception when `create_using` is a DiGraph (class or instance) for
+    graph generators that do not support directed outputs.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if kwargs.get("create_using") is not None:
+            G = nx.empty_graph(create_using=kwargs["create_using"])
+            if G.is_directed():
+                raise NetworkXError("Directed Graph not supported")
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+def make_small_undirected_graph(graph_description, create_using=None):
+    """
+    Return a small undirected graph described by graph_description.
+
+    .. deprecated:: 2.7
+
+       make_small_undirected_graph is deprecated and will be removed in
+       version 3.0. If "ltype" == "adjacencylist", convert the list to a dict
+       and use `from_dict_of_lists`. If "ltype" == "edgelist", use
+       `from_edgelist`.
+
+    See make_small_graph.
+    """
+    import warnings
+
+    msg = (
+        "\n\nmake_small_undirected_graph is deprecated and will be removed in "
+        "version 3.0.\n"
+        "If `ltype` == 'adjacencylist', convert `xlist` to a dict and use\n"
+        "`from_dict_of_lists` instead.\n"
+        "If `ltype` == 'edgelist', use `from_edgelist` instead."
+    )
+    warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+
+    G = empty_graph(0, create_using)
+    if G.is_directed():
+        raise NetworkXError("Directed Graph not supported")
+    return make_small_graph(graph_description, G)
+
+
+def make_small_graph(graph_description, create_using=None):
+    """
+    Return the small graph described by graph_description.
+
+    .. deprecated:: 2.7
+
+       make_small_graph is deprecated and will be removed in
+       version 3.0. If "ltype" == "adjacencylist", convert the list to a dict
+       and use `from_dict_of_lists`. If "ltype" == "edgelist", use
+       `from_edgelist`.
+
+    graph_description is a list of the form [ltype,name,n,xlist]
+
+    Here ltype is one of "adjacencylist" or "edgelist",
+    name is the name of the graph and n the number of nodes.
+    This constructs a graph of n nodes with integer labels 0,..,n-1.
+
+    If ltype="adjacencylist"  then xlist is an adjacency list
+    with exactly n entries, in with the j'th entry (which can be empty)
+    specifies the nodes connected to vertex j.
+    e.g. the "square" graph C_4 can be obtained by
+
+    >>> G = nx.make_small_graph(
+    ...     ["adjacencylist", "C_4", 4, [[2, 4], [1, 3], [2, 4], [1, 3]]]
+    ... )
+
+    or, since we do not need to add edges twice,
+
+    >>> G = nx.make_small_graph(["adjacencylist", "C_4", 4, [[2, 4], [3], [4], []]])
+
+    If ltype="edgelist" then xlist is an edge list
+    written as [[v1,w2],[v2,w2],...,[vk,wk]],
+    where vj and wj integers in the range 1,..,n
+    e.g. the "square" graph C_4 can be obtained by
+
+    >>> G = nx.make_small_graph(
+    ...     ["edgelist", "C_4", 4, [[1, 2], [3, 4], [2, 3], [4, 1]]]
+    ... )
+
+    Use the create_using argument to choose the graph class/type.
+    """
+    import warnings
+
+    msg = (
+        "\n\nmake_small_graph is deprecated and will be removed in version 3.0.\n"
+        "If `ltype` == 'adjacencylist', convert `xlist` to a dict and use\n"
+        "`from_dict_of_lists` instead.\n"
+        "If `ltype` == 'edgelist', use `from_edgelist` instead."
+    )
+    warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+
+    if graph_description[0] not in ("adjacencylist", "edgelist"):
+        raise NetworkXError("ltype must be either adjacencylist or edgelist")
+
+    ltype = graph_description[0]
+    name = graph_description[1]
+    n = graph_description[2]
+
+    G = empty_graph(n, create_using)
+    nodes = G.nodes()
+
+    if ltype == "adjacencylist":
+        adjlist = graph_description[3]
+        if len(adjlist) != n:
+            raise NetworkXError("invalid graph_description")
+        G.add_edges_from([(u - 1, v) for v in nodes for u in adjlist[v]])
+    elif ltype == "edgelist":
+        edgelist = graph_description[3]
+        for e in edgelist:
+            v1 = e[0] - 1
+            v2 = e[1] - 1
+            if v1 < 0 or v1 > n - 1 or v2 < 0 or v2 > n - 1:
+                raise NetworkXError("invalid graph_description")
+            else:
+                G.add_edge(v1, v2)
+    G.name = name
+    return G
+
+
+def LCF_graph(n, shift_list, repeats, create_using=None):
+    """
+    Return the cubic graph specified in LCF notation.
+
+    LCF notation (LCF=Lederberg-Coxeter-Fruchte) is a compressed
+    notation used in the generation of various cubic Hamiltonian
+    graphs of high symmetry. See, for example, dodecahedral_graph,
+    desargues_graph, heawood_graph and pappus_graph below.
+
+    n (number of nodes)
+      The starting graph is the n-cycle with nodes 0,...,n-1.
+      (The null graph is returned if n < 0.)
+
+    shift_list = [s1,s2,..,sk], a list of integer shifts mod n,
+
+    repeats
+      integer specifying the number of times that shifts in shift_list
+      are successively applied to each v_current in the n-cycle
+      to generate an edge between v_current and v_current+shift mod n.
+
+    For v1 cycling through the n-cycle a total of k*repeats
+    with shift cycling through shiftlist repeats times connect
+    v1 with v1+shift mod n
+
+    The utility graph $K_{3,3}$
+
+    >>> G = nx.LCF_graph(6, [3, -3], 3)
+
+    The Heawood graph
+
+    >>> G = nx.LCF_graph(14, [5, -5], 7)
+
+    See http://mathworld.wolfram.com/LCFNotation.html for a description
+    and references.
+
+    """
+    if n <= 0:
+        return empty_graph(0, create_using)
+
+    # start with the n-cycle
+    G = cycle_graph(n, create_using)
+    if G.is_directed():
+        raise NetworkXError("Directed Graph not supported")
+    G.name = "LCF_graph"
+    nodes = sorted(list(G))
+
+    n_extra_edges = repeats * len(shift_list)
+    # edges are added n_extra_edges times
+    # (not all of these need be new)
+    if n_extra_edges < 1:
+        return G
+
+    for i in range(n_extra_edges):
+        shift = shift_list[i % len(shift_list)]  # cycle through shift_list
+        v1 = nodes[i % n]  # cycle repeatedly through nodes
+        v2 = nodes[(i + shift) % n]
+        G.add_edge(v1, v2)
+    return G
+
+
+# -------------------------------------------------------------------------------
+#   Various small and named graphs
+# -------------------------------------------------------------------------------
+
+
+@_raise_on_directed
+def bull_graph(create_using=None):
+    """
+    Returns the Bull Graph
+
+    The Bull Graph has 5 nodes and 5 edges. It is a planar undirected
+    graph in the form of a triangle with two disjoint pendant edges [1]_
+    The name comes from the triangle and pendant edges representing
+    respectively the body and legs of a bull.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        A bull graph with 5 nodes
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Bull_graph.
+
+    """
+    G = nx.from_dict_of_lists(
+        {0: [1, 2], 1: [0, 2, 3], 2: [0, 1, 4], 3: [1], 4: [2]},
+        create_using=create_using,
+    )
+    G.name = "Bull Graph"
+    return G
+
+
+@_raise_on_directed
+def chvatal_graph(create_using=None):
+    """
+    Returns the Chvátal Graph
+
+    The Chvátal Graph is an undirected graph with 12 nodes and 24 edges [1]_.
+    It has 370 distinct (directed) Hamiltonian cycles, giving a unique generalized
+    LCF notation of order 4, two of order 6 , and 43 of order 1 [2]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        The Chvátal graph with 12 nodes and 24 edges
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Chv%C3%A1tal_graph
+    .. [2] https://mathworld.wolfram.com/ChvatalGraph.html
+
+    """
+    G = nx.from_dict_of_lists(
+        {
+            0: [1, 4, 6, 9],
+            1: [2, 5, 7],
+            2: [3, 6, 8],
+            3: [4, 7, 9],
+            4: [5, 8],
+            5: [10, 11],
+            6: [10, 11],
+            7: [8, 11],
+            8: [10],
+            9: [10, 11],
+        },
+        create_using=create_using,
+    )
+    G.name = "Chvatal Graph"
+    return G
+
+
+@_raise_on_directed
+def cubical_graph(create_using=None):
+    """
+    Returns the 3-regular Platonic Cubical Graph
+
+    The skeleton of the cube (the nodes and edges) form a graph, with 8
+    nodes, and 12 edges. It is a special case of the hypercube graph.
+    It is one of 5 Platonic graphs, each a skeleton of its
+    Platonic solid [1]_.
+    Such graphs arise in parallel processing in computers.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        A cubical graph with 8 nodes and 12 edges
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Cube#Cubical_graph
+
+    """
+    G = nx.from_dict_of_lists(
+        {
+            0: [1, 3, 4],
+            1: [0, 2, 7],
+            2: [1, 3, 6],
+            3: [0, 2, 5],
+            4: [0, 5, 7],
+            5: [3, 4, 6],
+            6: [2, 5, 7],
+            7: [1, 4, 6],
+        },
+        create_using=create_using,
+    )
+    G.name = ("Platonic Cubical Graph",)
+    return G
+
+
+def desargues_graph(create_using=None):
+    """
+    Returns the Desargues Graph
+
+    The Desargues Graph is a non-planar, distance-transitive cubic graph
+    with 20 nodes and 30 edges [1]_.
+    It is a symmetric graph. It can be represented in LCF notation
+    as [5,-5,9,-9]^5 [2]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Desargues Graph with 20 nodes and 30 edges
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Desargues_graph
+    .. [2] https://mathworld.wolfram.com/DesarguesGraph.html
+    """
+    G = LCF_graph(20, [5, -5, 9, -9], 5, create_using)
+    G.name = "Desargues Graph"
+    return G
+
+
+@_raise_on_directed
+def diamond_graph(create_using=None):
+    """
+    Returns the Diamond graph
+
+    The Diamond Graph is  planar undirected graph with 4 nodes and 5 edges.
+    It is also sometimes known as the double triangle graph or kite graph [1]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Diamond Graph with 4 nodes and 5 edges
+
+    References
+    ----------
+    .. [1] https://mathworld.wolfram.com/DiamondGraph.html
+    """
+    G = nx.from_dict_of_lists(
+        {0: [1, 2], 1: [0, 2, 3], 2: [0, 1, 3], 3: [1, 2]}, create_using=create_using
+    )
+    G.name = "Diamond Graph"
+    return G
+
+
+def dodecahedral_graph(create_using=None):
+    """
+    Returns the Platonic Dodecahedral graph.
+
+    The dodecahedral graph has 20 nodes and 30 edges. The skeleton of the
+    dodecahedron forms a graph. It is one of 5 Platonic graphs [1]_.
+    It can be described in LCF notation as:
+    ``[10, 7, 4, -4, -7, 10, -4, 7, -7, 4]^2`` [2]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Dodecahedral Graph with 20 nodes and 30 edges
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Regular_dodecahedron#Dodecahedral_graph
+    .. [2] https://mathworld.wolfram.com/DodecahedralGraph.html
+
+    """
+    G = LCF_graph(20, [10, 7, 4, -4, -7, 10, -4, 7, -7, 4], 2, create_using)
+    G.name = "Dodecahedral Graph"
+    return G
+
+
+def frucht_graph(create_using=None):
+    """
+    Returns the Frucht Graph.
+
+    The Frucht Graph is the smallest cubical graph whose
+    automorphism group consists only of the identity element [1]_.
+    It has 12 nodes and 18 edges and no nontrivial symmetries.
+    It is planar and Hamiltonian [2]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Frucht Graph with 12 nodes and 18 edges
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Frucht_graph
+    .. [2] https://mathworld.wolfram.com/FruchtGraph.html
+
+    """
+    G = cycle_graph(7, create_using)
+    G.add_edges_from(
+        [
+            [0, 7],
+            [1, 7],
+            [2, 8],
+            [3, 9],
+            [4, 9],
+            [5, 10],
+            [6, 10],
+            [7, 11],
+            [8, 11],
+            [8, 9],
+            [10, 11],
+        ]
+    )
+
+    G.name = "Frucht Graph"
+    return G
+
+
+def heawood_graph(create_using=None):
+    """
+    Returns the Heawood Graph, a (3,6) cage.
+
+    The Heawood Graph is an undirected graph with 14 nodes and 21 edges,
+    named after Percy John Heawood [1]_.
+    It is cubic symmetric, nonplanar, Hamiltonian, and can be represented
+    in LCF notation as ``[5,-5]^7`` [2]_.
+    It is the unique (3,6)-cage: the regular cubic graph of girth 6 with
+    minimal number of vertices [3]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Heawood Graph with 14 nodes and 21 edges
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Heawood_graph
+    .. [2] https://mathworld.wolfram.com/HeawoodGraph.html
+    .. [3] https://www.win.tue.nl/~aeb/graphs/Heawood.html
+
+    """
+    G = LCF_graph(14, [5, -5], 7, create_using)
+    G.name = "Heawood Graph"
+    return G
+
+
+def hoffman_singleton_graph():
+    """
+    Returns the Hoffman-Singleton Graph.
+
+    The Hoffman–Singleton graph is a symmetrical undirected graph
+    with 50 nodes and 175 edges.
+    All indices lie in ``Z % 5``: that is, the integers mod 5 [1]_.
+    It is the only regular graph of vertex degree 7, diameter 2, and girth 5.
+    It is the unique (7,5)-cage graph and Moore graph, and contains many
+    copies of the Petersen graph [2]_.
+
+    Returns
+    -------
+    G : networkx Graph
+        Hoffman–Singleton Graph with 50 nodes and 175 edges
+
+    Notes
+    -----
+    Constructed from pentagon and pentagram as follows: Take five pentagons $P_h$
+    and five pentagrams $Q_i$ . Join vertex $j$ of $P_h$ to vertex $h·i+j$ of $Q_i$ [3]_.
+
+    References
+    ----------
+    .. [1] https://blogs.ams.org/visualinsight/2016/02/01/hoffman-singleton-graph/
+    .. [2] https://mathworld.wolfram.com/Hoffman-SingletonGraph.html
+    .. [3] https://en.wikipedia.org/wiki/Hoffman%E2%80%93Singleton_graph
+
+    """
+    G = nx.Graph()
+    for i in range(5):
+        for j in range(5):
+            G.add_edge(("pentagon", i, j), ("pentagon", i, (j - 1) % 5))
+            G.add_edge(("pentagon", i, j), ("pentagon", i, (j + 1) % 5))
+            G.add_edge(("pentagram", i, j), ("pentagram", i, (j - 2) % 5))
+            G.add_edge(("pentagram", i, j), ("pentagram", i, (j + 2) % 5))
+            for k in range(5):
+                G.add_edge(("pentagon", i, j), ("pentagram", k, (i * k + j) % 5))
+    G = nx.convert_node_labels_to_integers(G)
+    G.name = "Hoffman-Singleton Graph"
+    return G
+
+
+@_raise_on_directed
+def house_graph(create_using=None):
+    """
+    Returns the House graph (square with triangle on top)
+
+    The house graph is a simple undirected graph with
+    5 nodes and 6 edges [1]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        House graph in the form of a square with a triangle on top
+
+    References
+    ----------
+    .. [1] https://mathworld.wolfram.com/HouseGraph.html
+    """
+    G = nx.from_dict_of_lists(
+        {0: [1, 2], 1: [0, 3], 2: [0, 3, 4], 3: [1, 2, 4], 4: [2, 3]},
+        create_using=create_using,
+    )
+    G.name = "House Graph"
+    return G
+
+
+@_raise_on_directed
+def house_x_graph(create_using=None):
+    """
+    Returns the House graph with a cross inside the house square.
+
+    The House X-graph is the House graph plus the two edges connecting diagonally
+    opposite vertices of the square base. It is also one of the two graphs
+    obtained by removing two edges from the pentatope graph [1]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        House graph with diagonal vertices connected
+
+    References
+    ----------
+    .. [1] https://mathworld.wolfram.com/HouseGraph.html
+    """
+    G = house_graph(create_using)
+    G.add_edges_from([(0, 3), (1, 2)])
+    G.name = "House-with-X-inside Graph"
+    return G
+
+
+@_raise_on_directed
+def icosahedral_graph(create_using=None):
+    """
+    Returns the Platonic Icosahedral graph.
+
+    The icosahedral graph has 12 nodes and 30 edges. It is a Platonic graph
+    whose nodes have the connectivity of the icosahedron. It is undirected,
+    regular and Hamiltonian [1]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Icosahedral graph with 12 nodes and 30 edges.
+
+    References
+    ----------
+    .. [1] https://mathworld.wolfram.com/IcosahedralGraph.html
+    """
+    G = nx.from_dict_of_lists(
+        {
+            0: [1, 5, 7, 8, 11],
+            1: [2, 5, 6, 8],
+            2: [3, 6, 8, 9],
+            3: [4, 6, 9, 10],
+            4: [5, 6, 10, 11],
+            5: [6, 11],
+            7: [8, 9, 10, 11],
+            8: [9],
+            9: [10],
+            10: [11],
+        },
+        create_using=create_using,
+    )
+    G.name = "Platonic Icosahedral Graph"
+    return G
+
+
+@_raise_on_directed
+def krackhardt_kite_graph(create_using=None):
+    """
+    Returns the Krackhardt Kite Social Network.
+
+    A 10 actor social network introduced by David Krackhardt
+    to illustrate different centrality measures [1]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Krackhardt Kite graph with 10 nodes and 18 edges
+
+    Notes
+    -----
+    The traditional labeling is:
+    Andre=1, Beverley=2, Carol=3, Diane=4,
+    Ed=5, Fernando=6, Garth=7, Heather=8, Ike=9, Jane=10.
+
+    References
+    ----------
+    .. [1] Krackhardt, David. "Assessing the Political Landscape: Structure,
+       Cognition, and Power in Organizations". Administrative Science Quarterly.
+       35 (2): 342–369. doi:10.2307/2393394. JSTOR 2393394. June 1990.
+
+    """
+    G = nx.from_dict_of_lists(
+        {
+            0: [1, 2, 3, 5],
+            1: [0, 3, 4, 6],
+            2: [0, 3, 5],
+            3: [0, 1, 2, 4, 5, 6],
+            4: [1, 3, 6],
+            5: [0, 2, 3, 6, 7],
+            6: [1, 3, 4, 5, 7],
+            7: [5, 6, 8],
+            8: [7, 9],
+            9: [8],
+        },
+        create_using=create_using,
+    )
+    G.name = "Krackhardt Kite Social Network"
+    return G
+
+
+def moebius_kantor_graph(create_using=None):
+    """
+    Returns the Moebius-Kantor graph.
+
+    The Möbius-Kantor graph is the cubic symmetric graph on 16 nodes.
+    Its LCF notation is [5,-5]^8, and it is isomorphic to the generalized
+    Petersen graph [1]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Moebius-Kantor graph
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/M%C3%B6bius%E2%80%93Kantor_graph
+
+    """
+    G = LCF_graph(16, [5, -5], 8, create_using)
+    G.name = "Moebius-Kantor Graph"
+    return G
+
+
+@_raise_on_directed
+def octahedral_graph(create_using=None):
+    """
+    Returns the Platonic Octahedral graph.
+
+    The octahedral graph is the 6-node 12-edge Platonic graph having the
+    connectivity of the octahedron [1]_. If 6 couples go to a party,
+    and each person shakes hands with every person except his or her partner,
+    then this graph describes the set of handshakes that take place;
+    for this reason it is also called the cocktail party graph [2]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Octahedral graph
+
+    References
+    ----------
+    .. [1] https://mathworld.wolfram.com/OctahedralGraph.html
+    .. [2] https://en.wikipedia.org/wiki/Tur%C3%A1n_graph#Special_cases
+
+    """
+    G = nx.from_dict_of_lists(
+        {0: [1, 2, 3, 4], 1: [2, 3, 5], 2: [4, 5], 3: [4, 5], 4: [5]},
+        create_using=create_using,
+    )
+    G.name = "Platonic Octahedral Graph"
+    return G
+
+
+def pappus_graph():
+    """
+    Returns the Pappus graph.
+
+    The Pappus graph is a cubic symmetric distance-regular graph with 18 nodes
+    and 27 edges. It is Hamiltonian and can be represented in LCF notation as
+    [5,7,-7,7,-7,-5]^3 [1]_.
+
+    Returns
+    -------
+    G : networkx Graph
+        Pappus graph
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Pappus_graph
+    """
+    G = LCF_graph(18, [5, 7, -7, 7, -7, -5], 3)
+    G.name = "Pappus Graph"
+    return G
+
+
+@_raise_on_directed
+def petersen_graph(create_using=None):
+    """
+    Returns the Petersen graph.
+
+    The Peterson graph is a cubic, undirected graph with 10 nodes and 15 edges [1]_.
+    Julius Petersen constructed the graph as the smallest counterexample
+    against the claim that a connected bridgeless cubic graph
+    has an edge colouring with three colours [2]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Petersen graph
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Petersen_graph
+    .. [2] https://www.win.tue.nl/~aeb/drg/graphs/Petersen.html
+    """
+    G = nx.from_dict_of_lists(
+        {
+            0: [1, 4, 5],
+            1: [0, 2, 6],
+            2: [1, 3, 7],
+            3: [2, 4, 8],
+            4: [3, 0, 9],
+            5: [0, 7, 8],
+            6: [1, 8, 9],
+            7: [2, 5, 9],
+            8: [3, 5, 6],
+            9: [4, 6, 7],
+        },
+        create_using=create_using,
+    )
+    G.name = "Petersen Graph"
+    return G
+
+
+def sedgewick_maze_graph(create_using=None):
+    """
+    Return a small maze with a cycle.
+
+    This is the maze used in Sedgewick, 3rd Edition, Part 5, Graph
+    Algorithms, Chapter 18, e.g. Figure 18.2 and following [1]_.
+    Nodes are numbered 0,..,7
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Small maze with a cycle
+
+    References
+    ----------
+    .. [1] Figure 18.2, Chapter 18, Graph Algorithms (3rd Ed), Sedgewick
+    """
+    G = empty_graph(0, create_using)
+    G.add_nodes_from(range(8))
+    G.add_edges_from([[0, 2], [0, 7], [0, 5]])
+    G.add_edges_from([[1, 7], [2, 6]])
+    G.add_edges_from([[3, 4], [3, 5]])
+    G.add_edges_from([[4, 5], [4, 7], [4, 6]])
+    G.name = "Sedgewick Maze"
+    return G
+
+
+def tetrahedral_graph(create_using=None):
+    """
+    Returns the 3-regular Platonic Tetrahedral graph.
+
+    Tetrahedral graph has 4 nodes and 6 edges. It is a
+    special case of the complete graph, K4, and wheel graph, W4.
+    It is one of the 5 platonic graphs [1]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Tetrahedral Grpah
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Tetrahedron#Tetrahedral_graph
+
+    """
+    G = complete_graph(4, create_using)
+    G.name = "Platonic Tetrahedral graph"
+    return G
+
+
+@_raise_on_directed
+def truncated_cube_graph(create_using=None):
+    """
+    Returns the skeleton of the truncated cube.
+
+    The truncated cube is an Archimedean solid with 14 regular
+    faces (6 octagonal and 8 triangular), 36 edges and 24 nodes [1]_.
+    The truncated cube is created by truncating (cutting off) the tips
+    of the cube one third of the way into each edge [2]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Skeleton of the truncated cube
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Truncated_cube
+    .. [2] https://www.coolmath.com/reference/polyhedra-truncated-cube
+
+    """
+    G = nx.from_dict_of_lists(
+        {
+            0: [1, 2, 4],
+            1: [11, 14],
+            2: [3, 4],
+            3: [6, 8],
+            4: [5],
+            5: [16, 18],
+            6: [7, 8],
+            7: [10, 12],
+            8: [9],
+            9: [17, 20],
+            10: [11, 12],
+            11: [14],
+            12: [13],
+            13: [21, 22],
+            14: [15],
+            15: [19, 23],
+            16: [17, 18],
+            17: [20],
+            18: [19],
+            19: [23],
+            20: [21],
+            21: [22],
+            22: [23],
+        },
+        create_using=create_using,
+    )
+    G.name = "Truncated Cube Graph"
+    return G
+
+
+def truncated_tetrahedron_graph(create_using=None):
+    """
+    Returns the skeleton of the truncated Platonic tetrahedron.
+
+    The truncated tetrahedron is an Archimedean solid with 4 regular hexagonal faces,
+    4 equilateral triangle faces, 12 nodes and 18 edges. It can be constructed by truncating
+    all 4 vertices of a regular tetrahedron at one third of the original edge length [1]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Skeleton of the truncated tetrahedron
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Truncated_tetrahedron
+
+    """
+    G = path_graph(12, create_using)
+    G.add_edges_from([(0, 2), (0, 9), (1, 6), (3, 11), (4, 11), (5, 7), (8, 10)])
+    G.name = "Truncated Tetrahedron Graph"
+    return G
+
+
+@_raise_on_directed
+def tutte_graph(create_using=None):
+    """
+    Returns the Tutte graph.
+
+    The Tutte graph is a cubic polyhedral, non-Hamiltonian graph. It has
+    46 nodes and 69 edges.
+    It is a counterexample to Tait's conjecture that every 3-regular polyhedron
+    has a Hamiltonian cycle.
+    It can be realized geometrically from a tetrahedron by multiply truncating
+    three of its vertices [1]_.
+
+    Parameters
+    ----------
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    G : networkx Graph
+        Tutte graph
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Tutte_graph
+    """
+    G = nx.from_dict_of_lists(
+        {
+            0: [1, 2, 3],
+            1: [4, 26],
+            2: [10, 11],
+            3: [18, 19],
+            4: [5, 33],
+            5: [6, 29],
+            6: [7, 27],
+            7: [8, 14],
+            8: [9, 38],
+            9: [10, 37],
+            10: [39],
+            11: [12, 39],
+            12: [13, 35],
+            13: [14, 15],
+            14: [34],
+            15: [16, 22],
+            16: [17, 44],
+            17: [18, 43],
+            18: [45],
+            19: [20, 45],
+            20: [21, 41],
+            21: [22, 23],
+            22: [40],
+            23: [24, 27],
+            24: [25, 32],
+            25: [26, 31],
+            26: [33],
+            27: [28],
+            28: [29, 32],
+            29: [30],
+            30: [31, 33],
+            31: [32],
+            34: [35, 38],
+            35: [36],
+            36: [37, 39],
+            37: [38],
+            40: [41, 44],
+            41: [42],
+            42: [43, 45],
+            43: [44],
+        },
+        create_using=create_using,
+    )
+    G.name = "Tutte's Graph"
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/social.py b/myenv/lib/python3.9/site-packages/networkx/generators/social.py
new file mode 100644
index 0000000..23910e6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/social.py
@@ -0,0 +1,542 @@
+"""
+Famous social networks.
+"""
+import networkx as nx
+
+__all__ = [
+    "karate_club_graph",
+    "davis_southern_women_graph",
+    "florentine_families_graph",
+    "les_miserables_graph",
+]
+
+
+def karate_club_graph():
+    """Returns Zachary's Karate Club graph.
+
+    Each node in the returned graph has a node attribute 'club' that
+    indicates the name of the club to which the member represented by that node
+    belongs, either 'Mr. Hi' or 'Officer'. Each edge has a weight based on the
+    number of contexts in which that edge's incident node members interacted.
+
+    Examples
+    --------
+    To get the name of the club to which a node belongs::
+
+        >>> G = nx.karate_club_graph()
+        >>> G.nodes[5]["club"]
+        'Mr. Hi'
+        >>> G.nodes[9]["club"]
+        'Officer'
+
+    References
+    ----------
+    .. [1] Zachary, Wayne W.
+       "An Information Flow Model for Conflict and Fission in Small Groups."
+       *Journal of Anthropological Research*, 33, 452--473, (1977).
+    """
+    # Create the set of all members, and the members of each club.
+    all_members = set(range(34))
+    club1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 16, 17, 19, 21}
+    # club2 = all_members - club1
+
+    G = nx.Graph()
+    G.add_nodes_from(all_members)
+    G.name = "Zachary's Karate Club"
+
+    zacharydat = """\
+0 4 5 3 3 3 3 2 2 0 2 3 2 3 0 0 0 2 0 2 0 2 0 0 0 0 0 0 0 0 0 2 0 0
+4 0 6 3 0 0 0 4 0 0 0 0 0 5 0 0 0 1 0 2 0 2 0 0 0 0 0 0 0 0 2 0 0 0
+5 6 0 3 0 0 0 4 5 1 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0 0 2 2 0 0 0 3 0
+3 3 3 0 0 0 0 3 0 0 0 0 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+3 0 0 0 0 0 2 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+3 0 0 0 0 0 5 0 0 0 3 0 0 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+3 0 0 0 2 5 0 0 0 0 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+2 4 4 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+2 0 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 0 4 3
+0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2
+2 0 0 0 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+1 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+3 5 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 2
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 4
+0 0 0 0 0 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+2 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2
+2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 1
+2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 0 4 0 2 0 0 5 4
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 3 0 0 0 2 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 2 0 0 0 0 0 0 7 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 0 0 0 2
+0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 3 0 0 0 0 0 0 0 0 4
+0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 2
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 0 0 4 0 0 0 0 0 3 2
+0 2 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 3
+2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 7 0 0 2 0 0 0 4 4
+0 0 2 0 0 0 0 0 3 0 0 0 0 0 3 3 0 0 1 0 3 0 2 5 0 0 0 0 0 4 3 4 0 5
+0 0 0 0 0 0 0 0 4 2 0 0 0 3 2 4 0 0 2 1 1 0 3 4 0 0 2 4 2 2 3 4 5 0"""
+
+    for row, line in enumerate(zacharydat.split("\n")):
+        thisrow = [int(b) for b in line.split()]
+        for col, entry in enumerate(thisrow):
+            if entry >= 1:
+                G.add_edge(row, col, weight=entry)
+
+    # Add the name of each member's club as a node attribute.
+    for v in G:
+        G.nodes[v]["club"] = "Mr. Hi" if v in club1 else "Officer"
+    return G
+
+
+def davis_southern_women_graph():
+    """Returns Davis Southern women social network.
+
+    This is a bipartite graph.
+
+    References
+    ----------
+    .. [1] A. Davis, Gardner, B. B., Gardner, M. R., 1941. Deep South.
+        University of Chicago Press, Chicago, IL.
+    """
+    G = nx.Graph()
+    # Top nodes
+    women = [
+        "Evelyn Jefferson",
+        "Laura Mandeville",
+        "Theresa Anderson",
+        "Brenda Rogers",
+        "Charlotte McDowd",
+        "Frances Anderson",
+        "Eleanor Nye",
+        "Pearl Oglethorpe",
+        "Ruth DeSand",
+        "Verne Sanderson",
+        "Myra Liddel",
+        "Katherina Rogers",
+        "Sylvia Avondale",
+        "Nora Fayette",
+        "Helen Lloyd",
+        "Dorothy Murchison",
+        "Olivia Carleton",
+        "Flora Price",
+    ]
+    G.add_nodes_from(women, bipartite=0)
+    # Bottom nodes
+    events = [
+        "E1",
+        "E2",
+        "E3",
+        "E4",
+        "E5",
+        "E6",
+        "E7",
+        "E8",
+        "E9",
+        "E10",
+        "E11",
+        "E12",
+        "E13",
+        "E14",
+    ]
+    G.add_nodes_from(events, bipartite=1)
+
+    G.add_edges_from(
+        [
+            ("Evelyn Jefferson", "E1"),
+            ("Evelyn Jefferson", "E2"),
+            ("Evelyn Jefferson", "E3"),
+            ("Evelyn Jefferson", "E4"),
+            ("Evelyn Jefferson", "E5"),
+            ("Evelyn Jefferson", "E6"),
+            ("Evelyn Jefferson", "E8"),
+            ("Evelyn Jefferson", "E9"),
+            ("Laura Mandeville", "E1"),
+            ("Laura Mandeville", "E2"),
+            ("Laura Mandeville", "E3"),
+            ("Laura Mandeville", "E5"),
+            ("Laura Mandeville", "E6"),
+            ("Laura Mandeville", "E7"),
+            ("Laura Mandeville", "E8"),
+            ("Theresa Anderson", "E2"),
+            ("Theresa Anderson", "E3"),
+            ("Theresa Anderson", "E4"),
+            ("Theresa Anderson", "E5"),
+            ("Theresa Anderson", "E6"),
+            ("Theresa Anderson", "E7"),
+            ("Theresa Anderson", "E8"),
+            ("Theresa Anderson", "E9"),
+            ("Brenda Rogers", "E1"),
+            ("Brenda Rogers", "E3"),
+            ("Brenda Rogers", "E4"),
+            ("Brenda Rogers", "E5"),
+            ("Brenda Rogers", "E6"),
+            ("Brenda Rogers", "E7"),
+            ("Brenda Rogers", "E8"),
+            ("Charlotte McDowd", "E3"),
+            ("Charlotte McDowd", "E4"),
+            ("Charlotte McDowd", "E5"),
+            ("Charlotte McDowd", "E7"),
+            ("Frances Anderson", "E3"),
+            ("Frances Anderson", "E5"),
+            ("Frances Anderson", "E6"),
+            ("Frances Anderson", "E8"),
+            ("Eleanor Nye", "E5"),
+            ("Eleanor Nye", "E6"),
+            ("Eleanor Nye", "E7"),
+            ("Eleanor Nye", "E8"),
+            ("Pearl Oglethorpe", "E6"),
+            ("Pearl Oglethorpe", "E8"),
+            ("Pearl Oglethorpe", "E9"),
+            ("Ruth DeSand", "E5"),
+            ("Ruth DeSand", "E7"),
+            ("Ruth DeSand", "E8"),
+            ("Ruth DeSand", "E9"),
+            ("Verne Sanderson", "E7"),
+            ("Verne Sanderson", "E8"),
+            ("Verne Sanderson", "E9"),
+            ("Verne Sanderson", "E12"),
+            ("Myra Liddel", "E8"),
+            ("Myra Liddel", "E9"),
+            ("Myra Liddel", "E10"),
+            ("Myra Liddel", "E12"),
+            ("Katherina Rogers", "E8"),
+            ("Katherina Rogers", "E9"),
+            ("Katherina Rogers", "E10"),
+            ("Katherina Rogers", "E12"),
+            ("Katherina Rogers", "E13"),
+            ("Katherina Rogers", "E14"),
+            ("Sylvia Avondale", "E7"),
+            ("Sylvia Avondale", "E8"),
+            ("Sylvia Avondale", "E9"),
+            ("Sylvia Avondale", "E10"),
+            ("Sylvia Avondale", "E12"),
+            ("Sylvia Avondale", "E13"),
+            ("Sylvia Avondale", "E14"),
+            ("Nora Fayette", "E6"),
+            ("Nora Fayette", "E7"),
+            ("Nora Fayette", "E9"),
+            ("Nora Fayette", "E10"),
+            ("Nora Fayette", "E11"),
+            ("Nora Fayette", "E12"),
+            ("Nora Fayette", "E13"),
+            ("Nora Fayette", "E14"),
+            ("Helen Lloyd", "E7"),
+            ("Helen Lloyd", "E8"),
+            ("Helen Lloyd", "E10"),
+            ("Helen Lloyd", "E11"),
+            ("Helen Lloyd", "E12"),
+            ("Dorothy Murchison", "E8"),
+            ("Dorothy Murchison", "E9"),
+            ("Olivia Carleton", "E9"),
+            ("Olivia Carleton", "E11"),
+            ("Flora Price", "E9"),
+            ("Flora Price", "E11"),
+        ]
+    )
+    G.graph["top"] = women
+    G.graph["bottom"] = events
+    return G
+
+
+def florentine_families_graph():
+    """Returns Florentine families graph.
+
+    References
+    ----------
+    .. [1] Ronald L. Breiger and Philippa E. Pattison
+       Cumulated social roles: The duality of persons and their algebras,1
+       Social Networks, Volume 8, Issue 3, September 1986, Pages 215-256
+    """
+    G = nx.Graph()
+    G.add_edge("Acciaiuoli", "Medici")
+    G.add_edge("Castellani", "Peruzzi")
+    G.add_edge("Castellani", "Strozzi")
+    G.add_edge("Castellani", "Barbadori")
+    G.add_edge("Medici", "Barbadori")
+    G.add_edge("Medici", "Ridolfi")
+    G.add_edge("Medici", "Tornabuoni")
+    G.add_edge("Medici", "Albizzi")
+    G.add_edge("Medici", "Salviati")
+    G.add_edge("Salviati", "Pazzi")
+    G.add_edge("Peruzzi", "Strozzi")
+    G.add_edge("Peruzzi", "Bischeri")
+    G.add_edge("Strozzi", "Ridolfi")
+    G.add_edge("Strozzi", "Bischeri")
+    G.add_edge("Ridolfi", "Tornabuoni")
+    G.add_edge("Tornabuoni", "Guadagni")
+    G.add_edge("Albizzi", "Ginori")
+    G.add_edge("Albizzi", "Guadagni")
+    G.add_edge("Bischeri", "Guadagni")
+    G.add_edge("Guadagni", "Lamberteschi")
+    return G
+
+
+def les_miserables_graph():
+    """Returns coappearance network of characters in the novel Les Miserables.
+
+    References
+    ----------
+    .. [1] D. E. Knuth, 1993.
+       The Stanford GraphBase: a platform for combinatorial computing,
+       pp. 74-87. New York: AcM Press.
+    """
+    G = nx.Graph()
+    G.add_edge("Napoleon", "Myriel", weight=1)
+    G.add_edge("MlleBaptistine", "Myriel", weight=8)
+    G.add_edge("MmeMagloire", "Myriel", weight=10)
+    G.add_edge("MmeMagloire", "MlleBaptistine", weight=6)
+    G.add_edge("CountessDeLo", "Myriel", weight=1)
+    G.add_edge("Geborand", "Myriel", weight=1)
+    G.add_edge("Champtercier", "Myriel", weight=1)
+    G.add_edge("Cravatte", "Myriel", weight=1)
+    G.add_edge("Count", "Myriel", weight=2)
+    G.add_edge("OldMan", "Myriel", weight=1)
+    G.add_edge("Valjean", "Labarre", weight=1)
+    G.add_edge("Valjean", "MmeMagloire", weight=3)
+    G.add_edge("Valjean", "MlleBaptistine", weight=3)
+    G.add_edge("Valjean", "Myriel", weight=5)
+    G.add_edge("Marguerite", "Valjean", weight=1)
+    G.add_edge("MmeDeR", "Valjean", weight=1)
+    G.add_edge("Isabeau", "Valjean", weight=1)
+    G.add_edge("Gervais", "Valjean", weight=1)
+    G.add_edge("Listolier", "Tholomyes", weight=4)
+    G.add_edge("Fameuil", "Tholomyes", weight=4)
+    G.add_edge("Fameuil", "Listolier", weight=4)
+    G.add_edge("Blacheville", "Tholomyes", weight=4)
+    G.add_edge("Blacheville", "Listolier", weight=4)
+    G.add_edge("Blacheville", "Fameuil", weight=4)
+    G.add_edge("Favourite", "Tholomyes", weight=3)
+    G.add_edge("Favourite", "Listolier", weight=3)
+    G.add_edge("Favourite", "Fameuil", weight=3)
+    G.add_edge("Favourite", "Blacheville", weight=4)
+    G.add_edge("Dahlia", "Tholomyes", weight=3)
+    G.add_edge("Dahlia", "Listolier", weight=3)
+    G.add_edge("Dahlia", "Fameuil", weight=3)
+    G.add_edge("Dahlia", "Blacheville", weight=3)
+    G.add_edge("Dahlia", "Favourite", weight=5)
+    G.add_edge("Zephine", "Tholomyes", weight=3)
+    G.add_edge("Zephine", "Listolier", weight=3)
+    G.add_edge("Zephine", "Fameuil", weight=3)
+    G.add_edge("Zephine", "Blacheville", weight=3)
+    G.add_edge("Zephine", "Favourite", weight=4)
+    G.add_edge("Zephine", "Dahlia", weight=4)
+    G.add_edge("Fantine", "Tholomyes", weight=3)
+    G.add_edge("Fantine", "Listolier", weight=3)
+    G.add_edge("Fantine", "Fameuil", weight=3)
+    G.add_edge("Fantine", "Blacheville", weight=3)
+    G.add_edge("Fantine", "Favourite", weight=4)
+    G.add_edge("Fantine", "Dahlia", weight=4)
+    G.add_edge("Fantine", "Zephine", weight=4)
+    G.add_edge("Fantine", "Marguerite", weight=2)
+    G.add_edge("Fantine", "Valjean", weight=9)
+    G.add_edge("MmeThenardier", "Fantine", weight=2)
+    G.add_edge("MmeThenardier", "Valjean", weight=7)
+    G.add_edge("Thenardier", "MmeThenardier", weight=13)
+    G.add_edge("Thenardier", "Fantine", weight=1)
+    G.add_edge("Thenardier", "Valjean", weight=12)
+    G.add_edge("Cosette", "MmeThenardier", weight=4)
+    G.add_edge("Cosette", "Valjean", weight=31)
+    G.add_edge("Cosette", "Tholomyes", weight=1)
+    G.add_edge("Cosette", "Thenardier", weight=1)
+    G.add_edge("Javert", "Valjean", weight=17)
+    G.add_edge("Javert", "Fantine", weight=5)
+    G.add_edge("Javert", "Thenardier", weight=5)
+    G.add_edge("Javert", "MmeThenardier", weight=1)
+    G.add_edge("Javert", "Cosette", weight=1)
+    G.add_edge("Fauchelevent", "Valjean", weight=8)
+    G.add_edge("Fauchelevent", "Javert", weight=1)
+    G.add_edge("Bamatabois", "Fantine", weight=1)
+    G.add_edge("Bamatabois", "Javert", weight=1)
+    G.add_edge("Bamatabois", "Valjean", weight=2)
+    G.add_edge("Perpetue", "Fantine", weight=1)
+    G.add_edge("Simplice", "Perpetue", weight=2)
+    G.add_edge("Simplice", "Valjean", weight=3)
+    G.add_edge("Simplice", "Fantine", weight=2)
+    G.add_edge("Simplice", "Javert", weight=1)
+    G.add_edge("Scaufflaire", "Valjean", weight=1)
+    G.add_edge("Woman1", "Valjean", weight=2)
+    G.add_edge("Woman1", "Javert", weight=1)
+    G.add_edge("Judge", "Valjean", weight=3)
+    G.add_edge("Judge", "Bamatabois", weight=2)
+    G.add_edge("Champmathieu", "Valjean", weight=3)
+    G.add_edge("Champmathieu", "Judge", weight=3)
+    G.add_edge("Champmathieu", "Bamatabois", weight=2)
+    G.add_edge("Brevet", "Judge", weight=2)
+    G.add_edge("Brevet", "Champmathieu", weight=2)
+    G.add_edge("Brevet", "Valjean", weight=2)
+    G.add_edge("Brevet", "Bamatabois", weight=1)
+    G.add_edge("Chenildieu", "Judge", weight=2)
+    G.add_edge("Chenildieu", "Champmathieu", weight=2)
+    G.add_edge("Chenildieu", "Brevet", weight=2)
+    G.add_edge("Chenildieu", "Valjean", weight=2)
+    G.add_edge("Chenildieu", "Bamatabois", weight=1)
+    G.add_edge("Cochepaille", "Judge", weight=2)
+    G.add_edge("Cochepaille", "Champmathieu", weight=2)
+    G.add_edge("Cochepaille", "Brevet", weight=2)
+    G.add_edge("Cochepaille", "Chenildieu", weight=2)
+    G.add_edge("Cochepaille", "Valjean", weight=2)
+    G.add_edge("Cochepaille", "Bamatabois", weight=1)
+    G.add_edge("Pontmercy", "Thenardier", weight=1)
+    G.add_edge("Boulatruelle", "Thenardier", weight=1)
+    G.add_edge("Eponine", "MmeThenardier", weight=2)
+    G.add_edge("Eponine", "Thenardier", weight=3)
+    G.add_edge("Anzelma", "Eponine", weight=2)
+    G.add_edge("Anzelma", "Thenardier", weight=2)
+    G.add_edge("Anzelma", "MmeThenardier", weight=1)
+    G.add_edge("Woman2", "Valjean", weight=3)
+    G.add_edge("Woman2", "Cosette", weight=1)
+    G.add_edge("Woman2", "Javert", weight=1)
+    G.add_edge("MotherInnocent", "Fauchelevent", weight=3)
+    G.add_edge("MotherInnocent", "Valjean", weight=1)
+    G.add_edge("Gribier", "Fauchelevent", weight=2)
+    G.add_edge("MmeBurgon", "Jondrette", weight=1)
+    G.add_edge("Gavroche", "MmeBurgon", weight=2)
+    G.add_edge("Gavroche", "Thenardier", weight=1)
+    G.add_edge("Gavroche", "Javert", weight=1)
+    G.add_edge("Gavroche", "Valjean", weight=1)
+    G.add_edge("Gillenormand", "Cosette", weight=3)
+    G.add_edge("Gillenormand", "Valjean", weight=2)
+    G.add_edge("Magnon", "Gillenormand", weight=1)
+    G.add_edge("Magnon", "MmeThenardier", weight=1)
+    G.add_edge("MlleGillenormand", "Gillenormand", weight=9)
+    G.add_edge("MlleGillenormand", "Cosette", weight=2)
+    G.add_edge("MlleGillenormand", "Valjean", weight=2)
+    G.add_edge("MmePontmercy", "MlleGillenormand", weight=1)
+    G.add_edge("MmePontmercy", "Pontmercy", weight=1)
+    G.add_edge("MlleVaubois", "MlleGillenormand", weight=1)
+    G.add_edge("LtGillenormand", "MlleGillenormand", weight=2)
+    G.add_edge("LtGillenormand", "Gillenormand", weight=1)
+    G.add_edge("LtGillenormand", "Cosette", weight=1)
+    G.add_edge("Marius", "MlleGillenormand", weight=6)
+    G.add_edge("Marius", "Gillenormand", weight=12)
+    G.add_edge("Marius", "Pontmercy", weight=1)
+    G.add_edge("Marius", "LtGillenormand", weight=1)
+    G.add_edge("Marius", "Cosette", weight=21)
+    G.add_edge("Marius", "Valjean", weight=19)
+    G.add_edge("Marius", "Tholomyes", weight=1)
+    G.add_edge("Marius", "Thenardier", weight=2)
+    G.add_edge("Marius", "Eponine", weight=5)
+    G.add_edge("Marius", "Gavroche", weight=4)
+    G.add_edge("BaronessT", "Gillenormand", weight=1)
+    G.add_edge("BaronessT", "Marius", weight=1)
+    G.add_edge("Mabeuf", "Marius", weight=1)
+    G.add_edge("Mabeuf", "Eponine", weight=1)
+    G.add_edge("Mabeuf", "Gavroche", weight=1)
+    G.add_edge("Enjolras", "Marius", weight=7)
+    G.add_edge("Enjolras", "Gavroche", weight=7)
+    G.add_edge("Enjolras", "Javert", weight=6)
+    G.add_edge("Enjolras", "Mabeuf", weight=1)
+    G.add_edge("Enjolras", "Valjean", weight=4)
+    G.add_edge("Combeferre", "Enjolras", weight=15)
+    G.add_edge("Combeferre", "Marius", weight=5)
+    G.add_edge("Combeferre", "Gavroche", weight=6)
+    G.add_edge("Combeferre", "Mabeuf", weight=2)
+    G.add_edge("Prouvaire", "Gavroche", weight=1)
+    G.add_edge("Prouvaire", "Enjolras", weight=4)
+    G.add_edge("Prouvaire", "Combeferre", weight=2)
+    G.add_edge("Feuilly", "Gavroche", weight=2)
+    G.add_edge("Feuilly", "Enjolras", weight=6)
+    G.add_edge("Feuilly", "Prouvaire", weight=2)
+    G.add_edge("Feuilly", "Combeferre", weight=5)
+    G.add_edge("Feuilly", "Mabeuf", weight=1)
+    G.add_edge("Feuilly", "Marius", weight=1)
+    G.add_edge("Courfeyrac", "Marius", weight=9)
+    G.add_edge("Courfeyrac", "Enjolras", weight=17)
+    G.add_edge("Courfeyrac", "Combeferre", weight=13)
+    G.add_edge("Courfeyrac", "Gavroche", weight=7)
+    G.add_edge("Courfeyrac", "Mabeuf", weight=2)
+    G.add_edge("Courfeyrac", "Eponine", weight=1)
+    G.add_edge("Courfeyrac", "Feuilly", weight=6)
+    G.add_edge("Courfeyrac", "Prouvaire", weight=3)
+    G.add_edge("Bahorel", "Combeferre", weight=5)
+    G.add_edge("Bahorel", "Gavroche", weight=5)
+    G.add_edge("Bahorel", "Courfeyrac", weight=6)
+    G.add_edge("Bahorel", "Mabeuf", weight=2)
+    G.add_edge("Bahorel", "Enjolras", weight=4)
+    G.add_edge("Bahorel", "Feuilly", weight=3)
+    G.add_edge("Bahorel", "Prouvaire", weight=2)
+    G.add_edge("Bahorel", "Marius", weight=1)
+    G.add_edge("Bossuet", "Marius", weight=5)
+    G.add_edge("Bossuet", "Courfeyrac", weight=12)
+    G.add_edge("Bossuet", "Gavroche", weight=5)
+    G.add_edge("Bossuet", "Bahorel", weight=4)
+    G.add_edge("Bossuet", "Enjolras", weight=10)
+    G.add_edge("Bossuet", "Feuilly", weight=6)
+    G.add_edge("Bossuet", "Prouvaire", weight=2)
+    G.add_edge("Bossuet", "Combeferre", weight=9)
+    G.add_edge("Bossuet", "Mabeuf", weight=1)
+    G.add_edge("Bossuet", "Valjean", weight=1)
+    G.add_edge("Joly", "Bahorel", weight=5)
+    G.add_edge("Joly", "Bossuet", weight=7)
+    G.add_edge("Joly", "Gavroche", weight=3)
+    G.add_edge("Joly", "Courfeyrac", weight=5)
+    G.add_edge("Joly", "Enjolras", weight=5)
+    G.add_edge("Joly", "Feuilly", weight=5)
+    G.add_edge("Joly", "Prouvaire", weight=2)
+    G.add_edge("Joly", "Combeferre", weight=5)
+    G.add_edge("Joly", "Mabeuf", weight=1)
+    G.add_edge("Joly", "Marius", weight=2)
+    G.add_edge("Grantaire", "Bossuet", weight=3)
+    G.add_edge("Grantaire", "Enjolras", weight=3)
+    G.add_edge("Grantaire", "Combeferre", weight=1)
+    G.add_edge("Grantaire", "Courfeyrac", weight=2)
+    G.add_edge("Grantaire", "Joly", weight=2)
+    G.add_edge("Grantaire", "Gavroche", weight=1)
+    G.add_edge("Grantaire", "Bahorel", weight=1)
+    G.add_edge("Grantaire", "Feuilly", weight=1)
+    G.add_edge("Grantaire", "Prouvaire", weight=1)
+    G.add_edge("MotherPlutarch", "Mabeuf", weight=3)
+    G.add_edge("Gueulemer", "Thenardier", weight=5)
+    G.add_edge("Gueulemer", "Valjean", weight=1)
+    G.add_edge("Gueulemer", "MmeThenardier", weight=1)
+    G.add_edge("Gueulemer", "Javert", weight=1)
+    G.add_edge("Gueulemer", "Gavroche", weight=1)
+    G.add_edge("Gueulemer", "Eponine", weight=1)
+    G.add_edge("Babet", "Thenardier", weight=6)
+    G.add_edge("Babet", "Gueulemer", weight=6)
+    G.add_edge("Babet", "Valjean", weight=1)
+    G.add_edge("Babet", "MmeThenardier", weight=1)
+    G.add_edge("Babet", "Javert", weight=2)
+    G.add_edge("Babet", "Gavroche", weight=1)
+    G.add_edge("Babet", "Eponine", weight=1)
+    G.add_edge("Claquesous", "Thenardier", weight=4)
+    G.add_edge("Claquesous", "Babet", weight=4)
+    G.add_edge("Claquesous", "Gueulemer", weight=4)
+    G.add_edge("Claquesous", "Valjean", weight=1)
+    G.add_edge("Claquesous", "MmeThenardier", weight=1)
+    G.add_edge("Claquesous", "Javert", weight=1)
+    G.add_edge("Claquesous", "Eponine", weight=1)
+    G.add_edge("Claquesous", "Enjolras", weight=1)
+    G.add_edge("Montparnasse", "Javert", weight=1)
+    G.add_edge("Montparnasse", "Babet", weight=2)
+    G.add_edge("Montparnasse", "Gueulemer", weight=2)
+    G.add_edge("Montparnasse", "Claquesous", weight=2)
+    G.add_edge("Montparnasse", "Valjean", weight=1)
+    G.add_edge("Montparnasse", "Gavroche", weight=1)
+    G.add_edge("Montparnasse", "Eponine", weight=1)
+    G.add_edge("Montparnasse", "Thenardier", weight=1)
+    G.add_edge("Toussaint", "Cosette", weight=2)
+    G.add_edge("Toussaint", "Javert", weight=1)
+    G.add_edge("Toussaint", "Valjean", weight=1)
+    G.add_edge("Child1", "Gavroche", weight=2)
+    G.add_edge("Child2", "Gavroche", weight=2)
+    G.add_edge("Child2", "Child1", weight=3)
+    G.add_edge("Brujon", "Babet", weight=3)
+    G.add_edge("Brujon", "Gueulemer", weight=3)
+    G.add_edge("Brujon", "Thenardier", weight=3)
+    G.add_edge("Brujon", "Gavroche", weight=1)
+    G.add_edge("Brujon", "Eponine", weight=1)
+    G.add_edge("Brujon", "Claquesous", weight=1)
+    G.add_edge("Brujon", "Montparnasse", weight=1)
+    G.add_edge("MmeHucheloup", "Bossuet", weight=1)
+    G.add_edge("MmeHucheloup", "Joly", weight=1)
+    G.add_edge("MmeHucheloup", "Grantaire", weight=1)
+    G.add_edge("MmeHucheloup", "Bahorel", weight=1)
+    G.add_edge("MmeHucheloup", "Courfeyrac", weight=1)
+    G.add_edge("MmeHucheloup", "Gavroche", weight=1)
+    G.add_edge("MmeHucheloup", "Enjolras", weight=1)
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/spectral_graph_forge.py b/myenv/lib/python3.9/site-packages/networkx/generators/spectral_graph_forge.py
new file mode 100644
index 0000000..e46851e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/spectral_graph_forge.py
@@ -0,0 +1,121 @@
+"""Generates graphs with a given eigenvector structure"""
+
+
+import networkx as nx
+from networkx.utils import np_random_state
+
+__all__ = ["spectral_graph_forge"]
+
+
+@np_random_state(3)
+def spectral_graph_forge(G, alpha, transformation="identity", seed=None):
+    """Returns a random simple graph with spectrum resembling that of `G`
+
+    This algorithm, called Spectral Graph Forge (SGF), computes the
+    eigenvectors of a given graph adjacency matrix, filters them and
+    builds a random graph with a similar eigenstructure.
+    SGF has been proved to be particularly useful for synthesizing
+    realistic social networks and it can also be used to anonymize
+    graph sensitive data.
+
+    Parameters
+    ----------
+    G : Graph
+    alpha :  float
+        Ratio representing the percentage of eigenvectors of G to consider,
+        values in [0,1].
+    transformation : string, optional
+        Represents the intended matrix linear transformation, possible values
+        are 'identity' and 'modularity'
+    seed : integer, random_state, or None (default)
+        Indicator of numpy random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    H : Graph
+        A graph with a similar eigenvector structure of the input one.
+
+    Raises
+    ------
+    NetworkXError
+        If transformation has a value different from 'identity' or 'modularity'
+
+    Notes
+    -----
+    Spectral Graph Forge (SGF) generates a random simple graph resembling the
+    global properties of the given one.
+    It leverages the low-rank approximation of the associated adjacency matrix
+    driven by the *alpha* precision parameter.
+    SGF preserves the number of nodes of the input graph and their ordering.
+    This way, nodes of output graphs resemble the properties of the input one
+    and attributes can be directly mapped.
+
+    It considers the graph adjacency matrices which can optionally be
+    transformed to other symmetric real matrices (currently transformation
+    options include *identity* and *modularity*).
+    The *modularity* transformation, in the sense of Newman's modularity matrix
+    allows the focusing on community structure related properties of the graph.
+
+    SGF applies a low-rank approximation whose fixed rank is computed from the
+    ratio *alpha* of the input graph adjacency matrix dimension.
+    This step performs a filtering on the input eigenvectors similar to the low
+    pass filtering common in telecommunications.
+
+    The filtered values (after truncation) are used as input to a Bernoulli
+    sampling for constructing a random adjacency matrix.
+
+    References
+    ----------
+    ..  [1] L. Baldesi, C. T. Butts, A. Markopoulou, "Spectral Graph Forge:
+        Graph Generation Targeting Modularity", IEEE Infocom, '18.
+        https://arxiv.org/abs/1801.01715
+    ..  [2] M. Newman, "Networks: an introduction", Oxford university press,
+        2010
+
+    Examples
+    --------
+    >>> G = nx.karate_club_graph()
+    >>> H = nx.spectral_graph_forge(G, 0.3)
+    >>>
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.stats  # call as sp.stats
+
+    available_transformations = ["identity", "modularity"]
+    alpha = np.clip(alpha, 0, 1)
+    A = nx.to_numpy_array(G)
+    n = A.shape[1]
+    level = round(n * alpha)
+
+    if transformation not in available_transformations:
+        msg = f"{transformation!r} is not a valid transformation. "
+        msg += f"Transformations: {available_transformations}"
+        raise nx.NetworkXError(msg)
+
+    K = np.ones((1, n)) @ A
+
+    B = A
+    if transformation == "modularity":
+        B -= K.T @ K / K.sum()
+
+    # Compute low-rank approximation of B
+    evals, evecs = np.linalg.eigh(B)
+    k = np.argsort(np.abs(evals))[::-1]  # indices of evals in descending order
+    evecs[:, k[np.arange(level, n)]] = 0  # set smallest eigenvectors to 0
+    B = evecs @ np.diag(evals) @ evecs.T
+
+    if transformation == "modularity":
+        B += K.T @ K / K.sum()
+
+    B = np.clip(B, 0, 1)
+    np.fill_diagonal(B, 0)
+
+    for i in range(n - 1):
+        B[i, i + 1 :] = sp.stats.bernoulli.rvs(B[i, i + 1 :], random_state=seed)
+        B[i + 1 :, i] = np.transpose(B[i, i + 1 :])
+
+    H = nx.from_numpy_array(B)
+
+    return H
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/stochastic.py b/myenv/lib/python3.9/site-packages/networkx/generators/stochastic.py
new file mode 100644
index 0000000..49a7c1a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/stochastic.py
@@ -0,0 +1,49 @@
+"""Functions for generating stochastic graphs from a given weighted directed
+graph.
+
+"""
+
+from networkx.classes import DiGraph, MultiDiGraph
+from networkx.utils import not_implemented_for
+
+__all__ = ["stochastic_graph"]
+
+
+@not_implemented_for("undirected")
+def stochastic_graph(G, copy=True, weight="weight"):
+    """Returns a right-stochastic representation of directed graph `G`.
+
+    A right-stochastic graph is a weighted digraph in which for each
+    node, the sum of the weights of all the out-edges of that node is
+    1. If the graph is already weighted (for example, via a 'weight'
+    edge attribute), the reweighting takes that into account.
+
+    Parameters
+    ----------
+    G : directed graph
+        A :class:`~networkx.DiGraph` or :class:`~networkx.MultiDiGraph`.
+
+    copy : boolean, optional
+        If this is True, then this function returns a new graph with
+        the stochastic reweighting. Otherwise, the original graph is
+        modified in-place (and also returned, for convenience).
+
+    weight : edge attribute key (optional, default='weight')
+        Edge attribute key used for reading the existing weight and
+        setting the new weight.  If no attribute with this key is found
+        for an edge, then the edge weight is assumed to be 1. If an edge
+        has a weight, it must be a positive number.
+
+    """
+    if copy:
+        G = MultiDiGraph(G) if G.is_multigraph() else DiGraph(G)
+    # There is a tradeoff here: the dictionary of node degrees may
+    # require a lot of memory, whereas making a call to `G.out_degree`
+    # inside the loop may be costly in computation time.
+    degree = dict(G.out_degree(weight=weight))
+    for u, v, d in G.edges(data=True):
+        if degree[u] == 0:
+            d[weight] = 0
+        else:
+            d[weight] = d.get(weight, 1) / degree[u]
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/sudoku.py b/myenv/lib/python3.9/site-packages/networkx/generators/sudoku.py
new file mode 100644
index 0000000..4cc8df3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/sudoku.py
@@ -0,0 +1,130 @@
+"""Generator for Sudoku graphs
+
+This module gives a generator for n-Sudoku graphs. It can be used to develop
+algorithms for solving or generating Sudoku puzzles.
+
+A completed Sudoku grid is a 9x9 array of integers between 1 and 9, with no
+number appearing twice in the same row, column, or 3x3 box.
+
++---------+---------+---------+
+| | 8 6 4 | | 3 7 1 | | 2 5 9 |
+| | 3 2 5 | | 8 4 9 | | 7 6 1 |
+| | 9 7 1 | | 2 6 5 | | 8 4 3 |
++---------+---------+---------+
+| | 4 3 6 | | 1 9 2 | | 5 8 7 |
+| | 1 9 8 | | 6 5 7 | | 4 3 2 |
+| | 2 5 7 | | 4 8 3 | | 9 1 6 |
++---------+---------+---------+
+| | 6 8 9 | | 7 3 4 | | 1 2 5 |
+| | 7 1 3 | | 5 2 8 | | 6 9 4 |
+| | 5 4 2 | | 9 1 6 | | 3 7 8 |
++---------+---------+---------+
+
+
+The Sudoku graph is an undirected graph with 81 vertices, corresponding to
+the cells of a Sudoku grid. It is a regular graph of degree 20. Two distinct
+vertices are adjacent if and only if the corresponding cells belong to the
+same row, column, or box. A completed Sudoku grid corresponds to a vertex
+coloring of the Sudoku graph with nine colors.
+
+More generally, the n-Sudoku graph is a graph with n^4 vertices, corresponding
+to the cells of an n^2 by n^2 grid. Two distinct vertices are adjacent if and
+only if they belong to the same row, column, or n by n box.
+
+References
+----------
+.. [1] Herzberg, A. M., & Murty, M. R. (2007). Sudoku squares and chromatic
+    polynomials. Notices of the AMS, 54(6), 708-717.
+.. [2] Sander, Torsten (2009), "Sudoku graphs are integral",
+    Electronic Journal of Combinatorics, 16 (1): Note 25, 7pp, MR 2529816
+.. [3] Wikipedia contributors. "Glossary of Sudoku." Wikipedia, The Free
+    Encyclopedia, 3 Dec. 2019. Web. 22 Dec. 2019.
+"""
+
+import networkx as nx
+from networkx.exception import NetworkXError
+
+__all__ = ["sudoku_graph"]
+
+
+def sudoku_graph(n=3):
+    """Returns the n-Sudoku graph. The default value of n is 3.
+
+    The n-Sudoku graph is a graph with n^4 vertices, corresponding to the
+    cells of an n^2 by n^2 grid. Two distinct vertices are adjacent if and
+    only if they belong to the same row, column, or n-by-n box.
+
+    Parameters
+    ----------
+    n: integer
+       The order of the Sudoku graph, equal to the square root of the
+       number of rows. The default is 3.
+
+    Returns
+    -------
+    NetworkX graph
+        The n-Sudoku graph Sud(n).
+
+    Examples
+    --------
+    >>> G = nx.sudoku_graph()
+    >>> G.number_of_nodes()
+    81
+    >>> G.number_of_edges()
+    810
+    >>> sorted(G.neighbors(42))
+    [6, 15, 24, 33, 34, 35, 36, 37, 38, 39, 40, 41, 43, 44, 51, 52, 53, 60, 69, 78]
+    >>> G = nx.sudoku_graph(2)
+    >>> G.number_of_nodes()
+    16
+    >>> G.number_of_edges()
+    56
+
+    References
+    ----------
+    .. [1] Herzberg, A. M., & Murty, M. R. (2007). Sudoku squares and chromatic
+       polynomials. Notices of the AMS, 54(6), 708-717.
+    .. [2] Sander, Torsten (2009), "Sudoku graphs are integral",
+       Electronic Journal of Combinatorics, 16 (1): Note 25, 7pp, MR 2529816
+    .. [3] Wikipedia contributors. "Glossary of Sudoku." Wikipedia, The Free
+       Encyclopedia, 3 Dec. 2019. Web. 22 Dec. 2019.
+    """
+
+    if n < 0:
+        raise NetworkXError("The order must be greater than or equal to zero.")
+
+    n2 = n * n
+    n3 = n2 * n
+    n4 = n3 * n
+
+    # Construct an empty graph with n^4 nodes
+    G = nx.empty_graph(n4)
+
+    # A Sudoku graph of order 0 or 1 has no edges
+    if n < 2:
+        return G
+
+    # Add edges for cells in the same row
+    for row_no in range(0, n2):
+        row_start = row_no * n2
+        for j in range(1, n2):
+            for i in range(j):
+                G.add_edge(row_start + i, row_start + j)
+
+    # Add edges for cells in the same column
+    for col_no in range(0, n2):
+        for j in range(col_no, n4, n2):
+            for i in range(col_no, j, n2):
+                G.add_edge(i, j)
+
+    # Add edges for cells in the same box
+    for band_no in range(n):
+        for stack_no in range(n):
+            box_start = n3 * band_no + n * stack_no
+            for j in range(1, n2):
+                for i in range(j):
+                    u = box_start + (i % n) + n2 * (i // n)
+                    v = box_start + (j % n) + n2 * (j // n)
+                    G.add_edge(u, v)
+
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_atlas.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_atlas.py
new file mode 100644
index 0000000..add4741
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_atlas.py
@@ -0,0 +1,75 @@
+from itertools import groupby
+
+import pytest
+
+import networkx as nx
+from networkx import graph_atlas, graph_atlas_g
+from networkx.generators.atlas import NUM_GRAPHS
+from networkx.utils import edges_equal, nodes_equal, pairwise
+
+
+class TestAtlasGraph:
+    """Unit tests for the :func:`~networkx.graph_atlas` function."""
+
+    def test_index_too_small(self):
+        with pytest.raises(ValueError):
+            graph_atlas(-1)
+
+    def test_index_too_large(self):
+        with pytest.raises(ValueError):
+            graph_atlas(NUM_GRAPHS)
+
+    def test_graph(self):
+        G = graph_atlas(6)
+        assert nodes_equal(G.nodes(), range(3))
+        assert edges_equal(G.edges(), [(0, 1), (0, 2)])
+
+
+class TestAtlasGraphG:
+    """Unit tests for the :func:`~networkx.graph_atlas_g` function."""
+
+    @classmethod
+    def setup_class(cls):
+        cls.GAG = graph_atlas_g()
+
+    def test_sizes(self):
+        G = self.GAG[0]
+        assert G.number_of_nodes() == 0
+        assert G.number_of_edges() == 0
+
+        G = self.GAG[7]
+        assert G.number_of_nodes() == 3
+        assert G.number_of_edges() == 3
+
+    def test_names(self):
+        for i, G in enumerate(self.GAG):
+            assert int(G.name[1:]) == i
+
+    def test_nondecreasing_nodes(self):
+        # check for nondecreasing number of nodes
+        for n1, n2 in pairwise(map(len, self.GAG)):
+            assert n2 <= n1 + 1
+
+    def test_nondecreasing_edges(self):
+        # check for nondecreasing number of edges (for fixed number of
+        # nodes)
+        for n, group in groupby(self.GAG, key=nx.number_of_nodes):
+            for m1, m2 in pairwise(map(nx.number_of_edges, group)):
+                assert m2 <= m1 + 1
+
+    def test_nondecreasing_degree_sequence(self):
+        # Check for lexicographically nondecreasing degree sequences
+        # (for fixed number of nodes and edges).
+        #
+        # There are three exceptions to this rule in the order given in
+        # the "Atlas of Graphs" book, so we need to manually exclude
+        # those.
+        exceptions = [("G55", "G56"), ("G1007", "G1008"), ("G1012", "G1013")]
+        for n, group in groupby(self.GAG, key=nx.number_of_nodes):
+            for m, group in groupby(group, key=nx.number_of_edges):
+                for G1, G2 in pairwise(group):
+                    if (G1.name, G2.name) in exceptions:
+                        continue
+                    d1 = sorted(d for v, d in G1.degree())
+                    d2 = sorted(d for v, d in G2.degree())
+                    assert d1 <= d2
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_classic.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_classic.py
new file mode 100644
index 0000000..9cb0866
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_classic.py
@@ -0,0 +1,549 @@
+"""
+====================
+Generators - Classic
+====================
+
+Unit tests for various classic graph generators in generators/classic.py
+"""
+import itertools
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.isomorphism.isomorph import graph_could_be_isomorphic
+from networkx.utils import edges_equal, nodes_equal
+
+is_isomorphic = graph_could_be_isomorphic
+
+
+class TestGeneratorClassic:
+    def test_balanced_tree(self):
+        # balanced_tree(r,h) is a tree with (r**(h+1)-1)/(r-1) edges
+        for r, h in [(2, 2), (3, 3), (6, 2)]:
+            t = nx.balanced_tree(r, h)
+            order = t.order()
+            assert order == (r ** (h + 1) - 1) / (r - 1)
+            assert nx.is_connected(t)
+            assert t.size() == order - 1
+            dh = nx.degree_histogram(t)
+            assert dh[0] == 0  # no nodes of 0
+            assert dh[1] == r**h  # nodes of degree 1 are leaves
+            assert dh[r] == 1  # root is degree r
+            assert dh[r + 1] == order - r**h - 1  # everyone else is degree r+1
+            assert len(dh) == r + 2
+
+    def test_balanced_tree_star(self):
+        # balanced_tree(r,1) is the r-star
+        t = nx.balanced_tree(r=2, h=1)
+        assert is_isomorphic(t, nx.star_graph(2))
+        t = nx.balanced_tree(r=5, h=1)
+        assert is_isomorphic(t, nx.star_graph(5))
+        t = nx.balanced_tree(r=10, h=1)
+        assert is_isomorphic(t, nx.star_graph(10))
+
+    def test_balanced_tree_path(self):
+        """Tests that the balanced tree with branching factor one is the
+        path graph.
+
+        """
+        # A tree of height four has five levels.
+        T = nx.balanced_tree(1, 4)
+        P = nx.path_graph(5)
+        assert is_isomorphic(T, P)
+
+    def test_full_rary_tree(self):
+        r = 2
+        n = 9
+        t = nx.full_rary_tree(r, n)
+        assert t.order() == n
+        assert nx.is_connected(t)
+        dh = nx.degree_histogram(t)
+        assert dh[0] == 0  # no nodes of 0
+        assert dh[1] == 5  # nodes of degree 1 are leaves
+        assert dh[r] == 1  # root is degree r
+        assert dh[r + 1] == 9 - 5 - 1  # everyone else is degree r+1
+        assert len(dh) == r + 2
+
+    def test_full_rary_tree_balanced(self):
+        t = nx.full_rary_tree(2, 15)
+        th = nx.balanced_tree(2, 3)
+        assert is_isomorphic(t, th)
+
+    def test_full_rary_tree_path(self):
+        t = nx.full_rary_tree(1, 10)
+        assert is_isomorphic(t, nx.path_graph(10))
+
+    def test_full_rary_tree_empty(self):
+        t = nx.full_rary_tree(0, 10)
+        assert is_isomorphic(t, nx.empty_graph(10))
+        t = nx.full_rary_tree(3, 0)
+        assert is_isomorphic(t, nx.empty_graph(0))
+
+    def test_full_rary_tree_3_20(self):
+        t = nx.full_rary_tree(3, 20)
+        assert t.order() == 20
+
+    def test_barbell_graph(self):
+        # number of nodes = 2*m1 + m2 (2 m1-complete graphs + m2-path + 2 edges)
+        # number of edges = 2*(nx.number_of_edges(m1-complete graph) + m2 + 1
+        m1 = 3
+        m2 = 5
+        b = nx.barbell_graph(m1, m2)
+        assert nx.number_of_nodes(b) == 2 * m1 + m2
+        assert nx.number_of_edges(b) == m1 * (m1 - 1) + m2 + 1
+
+        m1 = 4
+        m2 = 10
+        b = nx.barbell_graph(m1, m2)
+        assert nx.number_of_nodes(b) == 2 * m1 + m2
+        assert nx.number_of_edges(b) == m1 * (m1 - 1) + m2 + 1
+
+        m1 = 3
+        m2 = 20
+        b = nx.barbell_graph(m1, m2)
+        assert nx.number_of_nodes(b) == 2 * m1 + m2
+        assert nx.number_of_edges(b) == m1 * (m1 - 1) + m2 + 1
+
+        # Raise NetworkXError if m1<2
+        m1 = 1
+        m2 = 20
+        pytest.raises(nx.NetworkXError, nx.barbell_graph, m1, m2)
+
+        # Raise NetworkXError if m2<0
+        m1 = 5
+        m2 = -2
+        pytest.raises(nx.NetworkXError, nx.barbell_graph, m1, m2)
+
+        # nx.barbell_graph(2,m) = nx.path_graph(m+4)
+        m1 = 2
+        m2 = 5
+        b = nx.barbell_graph(m1, m2)
+        assert is_isomorphic(b, nx.path_graph(m2 + 4))
+
+        m1 = 2
+        m2 = 10
+        b = nx.barbell_graph(m1, m2)
+        assert is_isomorphic(b, nx.path_graph(m2 + 4))
+
+        m1 = 2
+        m2 = 20
+        b = nx.barbell_graph(m1, m2)
+        assert is_isomorphic(b, nx.path_graph(m2 + 4))
+
+        pytest.raises(
+            nx.NetworkXError, nx.barbell_graph, m1, m2, create_using=nx.DiGraph()
+        )
+
+        mb = nx.barbell_graph(m1, m2, create_using=nx.MultiGraph())
+        assert edges_equal(mb.edges(), b.edges())
+
+    def test_binomial_tree(self):
+        graphs = (None, nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph)
+        for create_using in graphs:
+            for n in range(0, 4):
+                b = nx.binomial_tree(n, create_using)
+                assert nx.number_of_nodes(b) == 2**n
+                assert nx.number_of_edges(b) == (2**n - 1)
+
+    def test_complete_graph(self):
+        # complete_graph(m) is a connected graph with
+        # m nodes and  m*(m+1)/2 edges
+        for m in [0, 1, 3, 5]:
+            g = nx.complete_graph(m)
+            assert nx.number_of_nodes(g) == m
+            assert nx.number_of_edges(g) == m * (m - 1) // 2
+
+        mg = nx.complete_graph(m, create_using=nx.MultiGraph)
+        assert edges_equal(mg.edges(), g.edges())
+
+        g = nx.complete_graph("abc")
+        assert nodes_equal(g.nodes(), ["a", "b", "c"])
+        assert g.size() == 3
+
+        # creates a self-loop... should it? <backward compatible says yes>
+        g = nx.complete_graph("abcb")
+        assert nodes_equal(g.nodes(), ["a", "b", "c"])
+        assert g.size() == 4
+
+        g = nx.complete_graph("abcb", create_using=nx.MultiGraph)
+        assert nodes_equal(g.nodes(), ["a", "b", "c"])
+        assert g.size() == 6
+
+    def test_complete_digraph(self):
+        # complete_graph(m) is a connected graph with
+        # m nodes and  m*(m+1)/2 edges
+        for m in [0, 1, 3, 5]:
+            g = nx.complete_graph(m, create_using=nx.DiGraph)
+            assert nx.number_of_nodes(g) == m
+            assert nx.number_of_edges(g) == m * (m - 1)
+
+        g = nx.complete_graph("abc", create_using=nx.DiGraph)
+        assert len(g) == 3
+        assert g.size() == 6
+        assert g.is_directed()
+
+    def test_circular_ladder_graph(self):
+        G = nx.circular_ladder_graph(5)
+        pytest.raises(
+            nx.NetworkXError, nx.circular_ladder_graph, 5, create_using=nx.DiGraph
+        )
+        mG = nx.circular_ladder_graph(5, create_using=nx.MultiGraph)
+        assert edges_equal(mG.edges(), G.edges())
+
+    def test_circulant_graph(self):
+        # Ci_n(1) is the cycle graph for all n
+        Ci6_1 = nx.circulant_graph(6, [1])
+        C6 = nx.cycle_graph(6)
+        assert edges_equal(Ci6_1.edges(), C6.edges())
+
+        # Ci_n(1, 2, ..., n div 2) is the complete graph for all n
+        Ci7 = nx.circulant_graph(7, [1, 2, 3])
+        K7 = nx.complete_graph(7)
+        assert edges_equal(Ci7.edges(), K7.edges())
+
+        # Ci_6(1, 3) is K_3,3 i.e. the utility graph
+        Ci6_1_3 = nx.circulant_graph(6, [1, 3])
+        K3_3 = nx.complete_bipartite_graph(3, 3)
+        assert is_isomorphic(Ci6_1_3, K3_3)
+
+    def test_cycle_graph(self):
+        G = nx.cycle_graph(4)
+        assert edges_equal(G.edges(), [(0, 1), (0, 3), (1, 2), (2, 3)])
+        mG = nx.cycle_graph(4, create_using=nx.MultiGraph)
+        assert edges_equal(mG.edges(), [(0, 1), (0, 3), (1, 2), (2, 3)])
+        G = nx.cycle_graph(4, create_using=nx.DiGraph)
+        assert not G.has_edge(2, 1)
+        assert G.has_edge(1, 2)
+        assert G.is_directed()
+
+        G = nx.cycle_graph("abc")
+        assert len(G) == 3
+        assert G.size() == 3
+        G = nx.cycle_graph("abcb")
+        assert len(G) == 3
+        assert G.size() == 2
+        g = nx.cycle_graph("abc", nx.DiGraph)
+        assert len(g) == 3
+        assert g.size() == 3
+        assert g.is_directed()
+        g = nx.cycle_graph("abcb", nx.DiGraph)
+        assert len(g) == 3
+        assert g.size() == 4
+
+    def test_dorogovtsev_goltsev_mendes_graph(self):
+        G = nx.dorogovtsev_goltsev_mendes_graph(0)
+        assert edges_equal(G.edges(), [(0, 1)])
+        assert nodes_equal(list(G), [0, 1])
+        G = nx.dorogovtsev_goltsev_mendes_graph(1)
+        assert edges_equal(G.edges(), [(0, 1), (0, 2), (1, 2)])
+        assert nx.average_clustering(G) == 1.0
+        assert sorted(nx.triangles(G).values()) == [1, 1, 1]
+        G = nx.dorogovtsev_goltsev_mendes_graph(10)
+        assert nx.number_of_nodes(G) == 29526
+        assert nx.number_of_edges(G) == 59049
+        assert G.degree(0) == 1024
+        assert G.degree(1) == 1024
+        assert G.degree(2) == 1024
+
+        pytest.raises(
+            nx.NetworkXError,
+            nx.dorogovtsev_goltsev_mendes_graph,
+            7,
+            create_using=nx.DiGraph,
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            nx.dorogovtsev_goltsev_mendes_graph,
+            7,
+            create_using=nx.MultiGraph,
+        )
+
+    def test_create_using(self):
+        G = nx.empty_graph()
+        assert isinstance(G, nx.Graph)
+        pytest.raises(TypeError, nx.empty_graph, create_using=0.0)
+        pytest.raises(TypeError, nx.empty_graph, create_using="Graph")
+
+        G = nx.empty_graph(create_using=nx.MultiGraph)
+        assert isinstance(G, nx.MultiGraph)
+        G = nx.empty_graph(create_using=nx.DiGraph)
+        assert isinstance(G, nx.DiGraph)
+
+        G = nx.empty_graph(create_using=nx.DiGraph, default=nx.MultiGraph)
+        assert isinstance(G, nx.DiGraph)
+        G = nx.empty_graph(create_using=None, default=nx.MultiGraph)
+        assert isinstance(G, nx.MultiGraph)
+        G = nx.empty_graph(default=nx.MultiGraph)
+        assert isinstance(G, nx.MultiGraph)
+
+        G = nx.path_graph(5)
+        H = nx.empty_graph(create_using=G)
+        assert not H.is_multigraph()
+        assert not H.is_directed()
+        assert len(H) == 0
+        assert G is H
+
+        H = nx.empty_graph(create_using=nx.MultiGraph())
+        assert H.is_multigraph()
+        assert not H.is_directed()
+        assert G is not H
+
+    def test_empty_graph(self):
+        G = nx.empty_graph()
+        assert nx.number_of_nodes(G) == 0
+        G = nx.empty_graph(42)
+        assert nx.number_of_nodes(G) == 42
+        assert nx.number_of_edges(G) == 0
+
+        G = nx.empty_graph("abc")
+        assert len(G) == 3
+        assert G.size() == 0
+
+        # create empty digraph
+        G = nx.empty_graph(42, create_using=nx.DiGraph(name="duh"))
+        assert nx.number_of_nodes(G) == 42
+        assert nx.number_of_edges(G) == 0
+        assert isinstance(G, nx.DiGraph)
+
+        # create empty multigraph
+        G = nx.empty_graph(42, create_using=nx.MultiGraph(name="duh"))
+        assert nx.number_of_nodes(G) == 42
+        assert nx.number_of_edges(G) == 0
+        assert isinstance(G, nx.MultiGraph)
+
+        # create empty graph from another
+        pete = nx.petersen_graph()
+        G = nx.empty_graph(42, create_using=pete)
+        assert nx.number_of_nodes(G) == 42
+        assert nx.number_of_edges(G) == 0
+        assert isinstance(G, nx.Graph)
+
+    def test_ladder_graph(self):
+        for i, G in [
+            (0, nx.empty_graph(0)),
+            (1, nx.path_graph(2)),
+            (2, nx.hypercube_graph(2)),
+            (10, nx.grid_graph([2, 10])),
+        ]:
+            assert is_isomorphic(nx.ladder_graph(i), G)
+
+        pytest.raises(nx.NetworkXError, nx.ladder_graph, 2, create_using=nx.DiGraph)
+
+        g = nx.ladder_graph(2)
+        mg = nx.ladder_graph(2, create_using=nx.MultiGraph)
+        assert edges_equal(mg.edges(), g.edges())
+
+    def test_lollipop_graph_right_sizes(self):
+        # number of nodes = m1 + m2
+        # number of edges = nx.number_of_edges(nx.complete_graph(m1)) + m2
+        for m1, m2 in [(3, 5), (4, 10), (3, 20)]:
+            G = nx.lollipop_graph(m1, m2)
+            assert nx.number_of_nodes(G) == m1 + m2
+            assert nx.number_of_edges(G) == m1 * (m1 - 1) / 2 + m2
+        for first, second in [("ab", ""), ("abc", "defg")]:
+            m1, m2 = len(first), len(second)
+            G = nx.lollipop_graph(first, second)
+            assert nx.number_of_nodes(G) == m1 + m2
+            assert nx.number_of_edges(G) == m1 * (m1 - 1) / 2 + m2
+
+    def test_lollipop_graph_exceptions(self):
+        # Raise NetworkXError if m<2
+        pytest.raises(nx.NetworkXError, nx.lollipop_graph, -1, 2)
+        pytest.raises(nx.NetworkXError, nx.lollipop_graph, 1, 20)
+        pytest.raises(nx.NetworkXError, nx.lollipop_graph, "", 20)
+        pytest.raises(nx.NetworkXError, nx.lollipop_graph, "a", 20)
+
+        # Raise NetworkXError if n<0
+        pytest.raises(nx.NetworkXError, nx.lollipop_graph, 5, -2)
+
+        # raise NetworkXError if create_using is directed
+        with pytest.raises(nx.NetworkXError):
+            nx.lollipop_graph(2, 20, create_using=nx.DiGraph)
+        with pytest.raises(nx.NetworkXError):
+            nx.lollipop_graph(2, 20, create_using=nx.MultiDiGraph)
+
+    def test_lollipop_graph_same_as_path_when_m1_is_2(self):
+        # lollipop_graph(2,m) = path_graph(m+2)
+        for m1, m2 in [(2, 0), (2, 5), (2, 10), ("ab", 20)]:
+            G = nx.lollipop_graph(m1, m2)
+            assert is_isomorphic(G, nx.path_graph(m2 + 2))
+
+    def test_lollipop_graph_for_multigraph(self):
+        G = nx.lollipop_graph(5, 20)
+        MG = nx.lollipop_graph(5, 20, create_using=nx.MultiGraph)
+        assert edges_equal(MG.edges(), G.edges())
+
+    def test_lollipop_graph_mixing_input_types(self):
+        cases = [(4, "abc"), ("abcd", 3), ([1, 2, 3, 4], "abc"), ("abcd", [1, 2, 3])]
+        for m1, m2 in cases:
+            G = nx.lollipop_graph(m1, m2)
+            assert len(G) == 7
+            assert G.size() == 9
+
+    def test_lollipop_graph_not_int_integer_inputs(self):
+        # test non-int integers
+        np = pytest.importorskip("numpy")
+        G = nx.lollipop_graph(np.int32(4), np.int64(3))
+        assert len(G) == 7
+        assert G.size() == 9
+
+    def test_null_graph(self):
+        assert nx.number_of_nodes(nx.null_graph()) == 0
+
+    def test_path_graph(self):
+        p = nx.path_graph(0)
+        assert is_isomorphic(p, nx.null_graph())
+
+        p = nx.path_graph(1)
+        assert is_isomorphic(p, nx.empty_graph(1))
+
+        p = nx.path_graph(10)
+        assert nx.is_connected(p)
+        assert sorted(d for n, d in p.degree()) == [1, 1, 2, 2, 2, 2, 2, 2, 2, 2]
+        assert p.order() - 1 == p.size()
+
+        dp = nx.path_graph(3, create_using=nx.DiGraph)
+        assert dp.has_edge(0, 1)
+        assert not dp.has_edge(1, 0)
+
+        mp = nx.path_graph(10, create_using=nx.MultiGraph)
+        assert edges_equal(mp.edges(), p.edges())
+
+        G = nx.path_graph("abc")
+        assert len(G) == 3
+        assert G.size() == 2
+        G = nx.path_graph("abcb")
+        assert len(G) == 3
+        assert G.size() == 2
+        g = nx.path_graph("abc", nx.DiGraph)
+        assert len(g) == 3
+        assert g.size() == 2
+        assert g.is_directed()
+        g = nx.path_graph("abcb", nx.DiGraph)
+        assert len(g) == 3
+        assert g.size() == 3
+
+        G = nx.path_graph((1, 2, 3, 2, 4))
+        assert G.has_edge(2, 4)
+
+    def test_star_graph(self):
+        assert is_isomorphic(nx.star_graph(""), nx.empty_graph(0))
+        assert is_isomorphic(nx.star_graph([]), nx.empty_graph(0))
+        assert is_isomorphic(nx.star_graph(0), nx.empty_graph(1))
+        assert is_isomorphic(nx.star_graph(1), nx.path_graph(2))
+        assert is_isomorphic(nx.star_graph(2), nx.path_graph(3))
+        assert is_isomorphic(nx.star_graph(5), nx.complete_bipartite_graph(1, 5))
+
+        s = nx.star_graph(10)
+        assert sorted(d for n, d in s.degree()) == [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10]
+
+        pytest.raises(nx.NetworkXError, nx.star_graph, 10, create_using=nx.DiGraph)
+
+        ms = nx.star_graph(10, create_using=nx.MultiGraph)
+        assert edges_equal(ms.edges(), s.edges())
+
+        G = nx.star_graph("abc")
+        assert len(G) == 3
+        assert G.size() == 2
+
+        G = nx.star_graph("abcb")
+        assert len(G) == 3
+        assert G.size() == 2
+        G = nx.star_graph("abcb", create_using=nx.MultiGraph)
+        assert len(G) == 3
+        assert G.size() == 3
+
+        G = nx.star_graph("abcdefg")
+        assert len(G) == 7
+        assert G.size() == 6
+
+    def test_non_int_integers_for_star_graph(self):
+        np = pytest.importorskip("numpy")
+        G = nx.star_graph(np.int32(3))
+        assert len(G) == 4
+        assert G.size() == 3
+
+    def test_trivial_graph(self):
+        assert nx.number_of_nodes(nx.trivial_graph()) == 1
+
+    def test_turan_graph(self):
+        assert nx.number_of_edges(nx.turan_graph(13, 4)) == 63
+        assert is_isomorphic(
+            nx.turan_graph(13, 4), nx.complete_multipartite_graph(3, 4, 3, 3)
+        )
+
+    def test_wheel_graph(self):
+        for n, G in [
+            ("", nx.null_graph()),
+            (0, nx.null_graph()),
+            (1, nx.empty_graph(1)),
+            (2, nx.path_graph(2)),
+            (3, nx.complete_graph(3)),
+            (4, nx.complete_graph(4)),
+        ]:
+            g = nx.wheel_graph(n)
+            assert is_isomorphic(g, G)
+
+        g = nx.wheel_graph(10)
+        assert sorted(d for n, d in g.degree()) == [3, 3, 3, 3, 3, 3, 3, 3, 3, 9]
+
+        pytest.raises(nx.NetworkXError, nx.wheel_graph, 10, create_using=nx.DiGraph)
+
+        mg = nx.wheel_graph(10, create_using=nx.MultiGraph())
+        assert edges_equal(mg.edges(), g.edges())
+
+        G = nx.wheel_graph("abc")
+        assert len(G) == 3
+        assert G.size() == 3
+
+        G = nx.wheel_graph("abcb")
+        assert len(G) == 3
+        assert G.size() == 4
+        G = nx.wheel_graph("abcb", nx.MultiGraph)
+        assert len(G) == 3
+        assert G.size() == 6
+
+    def test_non_int_integers_for_wheel_graph(self):
+        np = pytest.importorskip("numpy")
+        G = nx.wheel_graph(np.int32(3))
+        assert len(G) == 3
+        assert G.size() == 3
+
+    def test_complete_0_partite_graph(self):
+        """Tests that the complete 0-partite graph is the null graph."""
+        G = nx.complete_multipartite_graph()
+        H = nx.null_graph()
+        assert nodes_equal(G, H)
+        assert edges_equal(G.edges(), H.edges())
+
+    def test_complete_1_partite_graph(self):
+        """Tests that the complete 1-partite graph is the empty graph."""
+        G = nx.complete_multipartite_graph(3)
+        H = nx.empty_graph(3)
+        assert nodes_equal(G, H)
+        assert edges_equal(G.edges(), H.edges())
+
+    def test_complete_2_partite_graph(self):
+        """Tests that the complete 2-partite graph is the complete bipartite
+        graph.
+
+        """
+        G = nx.complete_multipartite_graph(2, 3)
+        H = nx.complete_bipartite_graph(2, 3)
+        assert nodes_equal(G, H)
+        assert edges_equal(G.edges(), H.edges())
+
+    def test_complete_multipartite_graph(self):
+        """Tests for generating the complete multipartite graph."""
+        G = nx.complete_multipartite_graph(2, 3, 4)
+        blocks = [(0, 1), (2, 3, 4), (5, 6, 7, 8)]
+        # Within each block, no two vertices should be adjacent.
+        for block in blocks:
+            for u, v in itertools.combinations_with_replacement(block, 2):
+                assert v not in G[u]
+                assert G.nodes[u] == G.nodes[v]
+        # Across blocks, all vertices should be adjacent.
+        for (block1, block2) in itertools.combinations(blocks, 2):
+            for u, v in itertools.product(block1, block2):
+                assert v in G[u]
+                assert G.nodes[u] != G.nodes[v]
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_cographs.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_cographs.py
new file mode 100644
index 0000000..4d84196
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_cographs.py
@@ -0,0 +1,20 @@
+"""Unit tests for the :mod:`networkx.generators.cographs` module.
+
+"""
+
+import networkx as nx
+
+
+def test_random_cograph():
+    n = 3
+    G = nx.random_cograph(n)
+
+    assert len(G) == 2**n
+
+    # Every connected subgraph of G has diameter <= 2
+    if nx.is_connected(G):
+        assert nx.diameter(G) <= 2
+    else:
+        components = nx.connected_components(G)
+        for component in components:
+            assert nx.diameter(G.subgraph(component)) <= 2
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_community.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_community.py
new file mode 100644
index 0000000..9f4a2e4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_community.py
@@ -0,0 +1,268 @@
+import pytest
+
+import networkx as nx
+
+
+def test_random_partition_graph():
+    G = nx.random_partition_graph([3, 3, 3], 1, 0, seed=42)
+    C = G.graph["partition"]
+    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
+    assert len(G) == 9
+    assert len(list(G.edges())) == 9
+
+    G = nx.random_partition_graph([3, 3, 3], 0, 1)
+    C = G.graph["partition"]
+    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
+    assert len(G) == 9
+    assert len(list(G.edges())) == 27
+
+    G = nx.random_partition_graph([3, 3, 3], 1, 0, directed=True)
+    C = G.graph["partition"]
+    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
+    assert len(G) == 9
+    assert len(list(G.edges())) == 18
+
+    G = nx.random_partition_graph([3, 3, 3], 0, 1, directed=True)
+    C = G.graph["partition"]
+    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
+    assert len(G) == 9
+    assert len(list(G.edges())) == 54
+
+    G = nx.random_partition_graph([1, 2, 3, 4, 5], 0.5, 0.1)
+    C = G.graph["partition"]
+    assert C == [{0}, {1, 2}, {3, 4, 5}, {6, 7, 8, 9}, {10, 11, 12, 13, 14}]
+    assert len(G) == 15
+
+    rpg = nx.random_partition_graph
+    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], 1.1, 0.1)
+    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], -0.1, 0.1)
+    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], 0.1, 1.1)
+    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], 0.1, -0.1)
+
+
+def test_planted_partition_graph():
+    G = nx.planted_partition_graph(4, 3, 1, 0, seed=42)
+    C = G.graph["partition"]
+    assert len(C) == 4
+    assert len(G) == 12
+    assert len(list(G.edges())) == 12
+
+    G = nx.planted_partition_graph(4, 3, 0, 1)
+    C = G.graph["partition"]
+    assert len(C) == 4
+    assert len(G) == 12
+    assert len(list(G.edges())) == 54
+
+    G = nx.planted_partition_graph(10, 4, 0.5, 0.1, seed=42)
+    C = G.graph["partition"]
+    assert len(C) == 10
+    assert len(G) == 40
+
+    G = nx.planted_partition_graph(4, 3, 1, 0, directed=True)
+    C = G.graph["partition"]
+    assert len(C) == 4
+    assert len(G) == 12
+    assert len(list(G.edges())) == 24
+
+    G = nx.planted_partition_graph(4, 3, 0, 1, directed=True)
+    C = G.graph["partition"]
+    assert len(C) == 4
+    assert len(G) == 12
+    assert len(list(G.edges())) == 108
+
+    G = nx.planted_partition_graph(10, 4, 0.5, 0.1, seed=42, directed=True)
+    C = G.graph["partition"]
+    assert len(C) == 10
+    assert len(G) == 40
+
+    ppg = nx.planted_partition_graph
+    pytest.raises(nx.NetworkXError, ppg, 3, 3, 1.1, 0.1)
+    pytest.raises(nx.NetworkXError, ppg, 3, 3, -0.1, 0.1)
+    pytest.raises(nx.NetworkXError, ppg, 3, 3, 0.1, 1.1)
+    pytest.raises(nx.NetworkXError, ppg, 3, 3, 0.1, -0.1)
+
+
+def test_relaxed_caveman_graph():
+    G = nx.relaxed_caveman_graph(4, 3, 0)
+    assert len(G) == 12
+    G = nx.relaxed_caveman_graph(4, 3, 1)
+    assert len(G) == 12
+    G = nx.relaxed_caveman_graph(4, 3, 0.5)
+    assert len(G) == 12
+    G = nx.relaxed_caveman_graph(4, 3, 0.5, seed=42)
+    assert len(G) == 12
+
+
+def test_connected_caveman_graph():
+    G = nx.connected_caveman_graph(4, 3)
+    assert len(G) == 12
+
+    G = nx.connected_caveman_graph(1, 5)
+    K5 = nx.complete_graph(5)
+    K5.remove_edge(3, 4)
+    assert nx.is_isomorphic(G, K5)
+
+    # need at least 2 nodes in each clique
+    pytest.raises(nx.NetworkXError, nx.connected_caveman_graph, 4, 1)
+
+
+def test_caveman_graph():
+    G = nx.caveman_graph(4, 3)
+    assert len(G) == 12
+
+    G = nx.caveman_graph(1, 5)
+    K5 = nx.complete_graph(5)
+    assert nx.is_isomorphic(G, K5)
+
+
+def test_gaussian_random_partition_graph():
+    G = nx.gaussian_random_partition_graph(100, 10, 10, 0.3, 0.01)
+    assert len(G) == 100
+    G = nx.gaussian_random_partition_graph(100, 10, 10, 0.3, 0.01, directed=True)
+    assert len(G) == 100
+    G = nx.gaussian_random_partition_graph(
+        100, 10, 10, 0.3, 0.01, directed=False, seed=42
+    )
+    assert len(G) == 100
+    assert not isinstance(G, nx.DiGraph)
+    G = nx.gaussian_random_partition_graph(
+        100, 10, 10, 0.3, 0.01, directed=True, seed=42
+    )
+    assert len(G) == 100
+    assert isinstance(G, nx.DiGraph)
+    pytest.raises(
+        nx.NetworkXError, nx.gaussian_random_partition_graph, 100, 101, 10, 1, 0
+    )
+
+
+def test_ring_of_cliques():
+    for i in range(2, 20, 3):
+        for j in range(2, 20, 3):
+            G = nx.ring_of_cliques(i, j)
+            assert G.number_of_nodes() == i * j
+            if i != 2 or j != 1:
+                expected_num_edges = i * (((j * (j - 1)) // 2) + 1)
+            else:
+                # the edge that already exists cannot be duplicated
+                expected_num_edges = i * (((j * (j - 1)) // 2) + 1) - 1
+            assert G.number_of_edges() == expected_num_edges
+    pytest.raises(nx.NetworkXError, nx.ring_of_cliques, 1, 5)
+    pytest.raises(nx.NetworkXError, nx.ring_of_cliques, 3, 0)
+
+
+def test_windmill_graph():
+    for n in range(2, 20, 3):
+        for k in range(2, 20, 3):
+            G = nx.windmill_graph(n, k)
+            assert G.number_of_nodes() == (k - 1) * n + 1
+            assert G.number_of_edges() == n * k * (k - 1) / 2
+            assert G.degree(0) == G.number_of_nodes() - 1
+            for i in range(1, G.number_of_nodes()):
+                assert G.degree(i) == k - 1
+    pytest.raises(nx.NetworkXError, nx.ring_of_cliques, 1, 3)
+    pytest.raises(nx.NetworkXError, nx.ring_of_cliques, 15, 0)
+
+
+def test_stochastic_block_model():
+    sizes = [75, 75, 300]
+    probs = [[0.25, 0.05, 0.02], [0.05, 0.35, 0.07], [0.02, 0.07, 0.40]]
+    G = nx.stochastic_block_model(sizes, probs, seed=0)
+    C = G.graph["partition"]
+    assert len(C) == 3
+    assert len(G) == 450
+    assert G.size() == 22160
+
+    GG = nx.stochastic_block_model(sizes, probs, range(450), seed=0)
+    assert G.nodes == GG.nodes
+
+    # Test Exceptions
+    sbm = nx.stochastic_block_model
+    badnodelist = list(range(400))  # not enough nodes to match sizes
+    badprobs1 = [[0.25, 0.05, 1.02], [0.05, 0.35, 0.07], [0.02, 0.07, 0.40]]
+    badprobs2 = [[0.25, 0.05, 0.02], [0.05, -0.35, 0.07], [0.02, 0.07, 0.40]]
+    probs_rect1 = [[0.25, 0.05, 0.02], [0.05, -0.35, 0.07]]
+    probs_rect2 = [[0.25, 0.05], [0.05, -0.35], [0.02, 0.07]]
+    asymprobs = [[0.25, 0.05, 0.01], [0.05, -0.35, 0.07], [0.02, 0.07, 0.40]]
+    pytest.raises(nx.NetworkXException, sbm, sizes, badprobs1)
+    pytest.raises(nx.NetworkXException, sbm, sizes, badprobs2)
+    pytest.raises(nx.NetworkXException, sbm, sizes, probs_rect1, directed=True)
+    pytest.raises(nx.NetworkXException, sbm, sizes, probs_rect2, directed=True)
+    pytest.raises(nx.NetworkXException, sbm, sizes, asymprobs, directed=False)
+    pytest.raises(nx.NetworkXException, sbm, sizes, probs, badnodelist)
+    nodelist = [0] + list(range(449))  # repeated node name in nodelist
+    pytest.raises(nx.NetworkXException, sbm, sizes, probs, nodelist)
+
+    # Extra keyword arguments test
+    GG = nx.stochastic_block_model(sizes, probs, seed=0, selfloops=True)
+    assert G.nodes == GG.nodes
+    GG = nx.stochastic_block_model(sizes, probs, selfloops=True, directed=True)
+    assert G.nodes == GG.nodes
+    GG = nx.stochastic_block_model(sizes, probs, seed=0, sparse=False)
+    assert G.nodes == GG.nodes
+
+
+def test_generator():
+    n = 250
+    tau1 = 3
+    tau2 = 1.5
+    mu = 0.1
+    G = nx.LFR_benchmark_graph(
+        n, tau1, tau2, mu, average_degree=5, min_community=20, seed=10
+    )
+    assert len(G) == 250
+    C = {frozenset(G.nodes[v]["community"]) for v in G}
+    assert nx.community.is_partition(G.nodes(), C)
+
+
+def test_invalid_tau1():
+    with pytest.raises(nx.NetworkXError):
+        n = 100
+        tau1 = 2
+        tau2 = 1
+        mu = 0.1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
+
+
+def test_invalid_tau2():
+    with pytest.raises(nx.NetworkXError):
+        n = 100
+        tau1 = 1
+        tau2 = 2
+        mu = 0.1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
+
+
+def test_mu_too_large():
+    with pytest.raises(nx.NetworkXError):
+        n = 100
+        tau1 = 2
+        tau2 = 2
+        mu = 1.1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
+
+
+def test_mu_too_small():
+    with pytest.raises(nx.NetworkXError):
+        n = 100
+        tau1 = 2
+        tau2 = 2
+        mu = -1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
+
+
+def test_both_degrees_none():
+    with pytest.raises(nx.NetworkXError):
+        n = 100
+        tau1 = 2
+        tau2 = 2
+        mu = -1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu)
+
+
+def test_neither_degrees_none():
+    with pytest.raises(nx.NetworkXError):
+        n = 100
+        tau1 = 2
+        tau2 = 2
+        mu = -1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2, average_degree=5)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_degree_seq.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_degree_seq.py
new file mode 100644
index 0000000..70a63b6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_degree_seq.py
@@ -0,0 +1,230 @@
+import pytest
+
+import networkx as nx
+
+
+class TestConfigurationModel:
+    """Unit tests for the :func:`~networkx.configuration_model`
+    function.
+
+    """
+
+    def test_empty_degree_sequence(self):
+        """Tests that an empty degree sequence yields the null graph."""
+        G = nx.configuration_model([])
+        assert len(G) == 0
+
+    def test_degree_zero(self):
+        """Tests that a degree sequence of all zeros yields the empty
+        graph.
+
+        """
+        G = nx.configuration_model([0, 0, 0])
+        assert len(G) == 3
+        assert G.number_of_edges() == 0
+
+    def test_degree_sequence(self):
+        """Tests that the degree sequence of the generated graph matches
+        the input degree sequence.
+
+        """
+        deg_seq = [5, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
+        G = nx.configuration_model(deg_seq, seed=12345678)
+        assert sorted((d for n, d in G.degree()), reverse=True) == [
+            5,
+            3,
+            3,
+            3,
+            3,
+            2,
+            2,
+            2,
+            1,
+            1,
+            1,
+        ]
+        assert sorted((d for n, d in G.degree(range(len(deg_seq)))), reverse=True) == [
+            5,
+            3,
+            3,
+            3,
+            3,
+            2,
+            2,
+            2,
+            1,
+            1,
+            1,
+        ]
+
+    def test_random_seed(self):
+        """Tests that each call with the same random seed generates the
+        same graph.
+
+        """
+        deg_seq = [3] * 12
+        G1 = nx.configuration_model(deg_seq, seed=1000)
+        G2 = nx.configuration_model(deg_seq, seed=1000)
+        assert nx.is_isomorphic(G1, G2)
+        G1 = nx.configuration_model(deg_seq, seed=10)
+        G2 = nx.configuration_model(deg_seq, seed=10)
+        assert nx.is_isomorphic(G1, G2)
+
+    def test_directed_disallowed(self):
+        """Tests that attempting to create a configuration model graph
+        using a directed graph yields an exception.
+
+        """
+        with pytest.raises(nx.NetworkXNotImplemented):
+            nx.configuration_model([], create_using=nx.DiGraph())
+
+    def test_odd_degree_sum(self):
+        """Tests that a degree sequence whose sum is odd yields an
+        exception.
+
+        """
+        with pytest.raises(nx.NetworkXError):
+            nx.configuration_model([1, 2])
+
+
+def test_directed_configuation_raise_unequal():
+    with pytest.raises(nx.NetworkXError):
+        zin = [5, 3, 3, 3, 3, 2, 2, 2, 1, 1]
+        zout = [5, 3, 3, 3, 3, 2, 2, 2, 1, 2]
+        nx.directed_configuration_model(zin, zout)
+
+
+def test_directed_configuation_model():
+    G = nx.directed_configuration_model([], [], seed=0)
+    assert len(G) == 0
+
+
+def test_simple_directed_configuation_model():
+    G = nx.directed_configuration_model([1, 1], [1, 1], seed=0)
+    assert len(G) == 2
+
+
+def test_expected_degree_graph_empty():
+    # empty graph has empty degree sequence
+    deg_seq = []
+    G = nx.expected_degree_graph(deg_seq)
+    assert dict(G.degree()) == {}
+
+
+def test_expected_degree_graph():
+    # test that fixed seed delivers the same graph
+    deg_seq = [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
+    G1 = nx.expected_degree_graph(deg_seq, seed=1000)
+    assert len(G1) == 12
+
+    G2 = nx.expected_degree_graph(deg_seq, seed=1000)
+    assert nx.is_isomorphic(G1, G2)
+
+    G1 = nx.expected_degree_graph(deg_seq, seed=10)
+    G2 = nx.expected_degree_graph(deg_seq, seed=10)
+    assert nx.is_isomorphic(G1, G2)
+
+
+def test_expected_degree_graph_selfloops():
+    deg_seq = [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
+    G1 = nx.expected_degree_graph(deg_seq, seed=1000, selfloops=False)
+    G2 = nx.expected_degree_graph(deg_seq, seed=1000, selfloops=False)
+    assert nx.is_isomorphic(G1, G2)
+    assert len(G1) == 12
+
+
+def test_expected_degree_graph_skew():
+    deg_seq = [10, 2, 2, 2, 2]
+    G1 = nx.expected_degree_graph(deg_seq, seed=1000)
+    G2 = nx.expected_degree_graph(deg_seq, seed=1000)
+    assert nx.is_isomorphic(G1, G2)
+    assert len(G1) == 5
+
+
+def test_havel_hakimi_construction():
+    G = nx.havel_hakimi_graph([])
+    assert len(G) == 0
+
+    z = [1000, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
+    pytest.raises(nx.NetworkXError, nx.havel_hakimi_graph, z)
+    z = ["A", 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
+    pytest.raises(nx.NetworkXError, nx.havel_hakimi_graph, z)
+
+    z = [5, 4, 3, 3, 3, 2, 2, 2]
+    G = nx.havel_hakimi_graph(z)
+    G = nx.configuration_model(z)
+    z = [6, 5, 4, 4, 2, 1, 1, 1]
+    pytest.raises(nx.NetworkXError, nx.havel_hakimi_graph, z)
+
+    z = [10, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2]
+
+    G = nx.havel_hakimi_graph(z)
+
+    pytest.raises(nx.NetworkXError, nx.havel_hakimi_graph, z, create_using=nx.DiGraph())
+
+
+def test_directed_havel_hakimi():
+    # Test range of valid directed degree sequences
+    n, r = 100, 10
+    p = 1.0 / r
+    for i in range(r):
+        G1 = nx.erdos_renyi_graph(n, p * (i + 1), None, True)
+        din1 = list(d for n, d in G1.in_degree())
+        dout1 = list(d for n, d in G1.out_degree())
+        G2 = nx.directed_havel_hakimi_graph(din1, dout1)
+        din2 = list(d for n, d in G2.in_degree())
+        dout2 = list(d for n, d in G2.out_degree())
+        assert sorted(din1) == sorted(din2)
+        assert sorted(dout1) == sorted(dout2)
+
+    # Test non-graphical sequence
+    dout = [1000, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
+    din = [103, 102, 102, 102, 102, 102, 102, 102, 102, 102]
+    pytest.raises(nx.exception.NetworkXError, nx.directed_havel_hakimi_graph, din, dout)
+    # Test valid sequences
+    dout = [1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
+    din = [2, 2, 2, 2, 2, 2, 2, 2, 0, 2]
+    G2 = nx.directed_havel_hakimi_graph(din, dout)
+    dout2 = (d for n, d in G2.out_degree())
+    din2 = (d for n, d in G2.in_degree())
+    assert sorted(dout) == sorted(dout2)
+    assert sorted(din) == sorted(din2)
+    # Test unequal sums
+    din = [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
+    pytest.raises(nx.exception.NetworkXError, nx.directed_havel_hakimi_graph, din, dout)
+    # Test for negative values
+    din = [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -2]
+    pytest.raises(nx.exception.NetworkXError, nx.directed_havel_hakimi_graph, din, dout)
+
+
+def test_degree_sequence_tree():
+    z = [1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
+    G = nx.degree_sequence_tree(z)
+    assert len(G) == len(z)
+    assert len(list(G.edges())) == sum(z) / 2
+
+    pytest.raises(
+        nx.NetworkXError, nx.degree_sequence_tree, z, create_using=nx.DiGraph()
+    )
+
+    z = [1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
+    pytest.raises(nx.NetworkXError, nx.degree_sequence_tree, z)
+
+
+def test_random_degree_sequence_graph():
+    d = [1, 2, 2, 3]
+    G = nx.random_degree_sequence_graph(d, seed=42)
+    assert d == sorted(d for n, d in G.degree())
+
+
+def test_random_degree_sequence_graph_raise():
+    z = [1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
+    pytest.raises(nx.NetworkXUnfeasible, nx.random_degree_sequence_graph, z)
+
+
+def test_random_degree_sequence_large():
+    G1 = nx.fast_gnp_random_graph(100, 0.1, seed=42)
+    d1 = (d for n, d in G1.degree())
+    G2 = nx.random_degree_sequence_graph(d1, seed=42)
+    d2 = (d for n, d in G2.degree())
+    assert sorted(d1) == sorted(d2)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_directed.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_directed.py
new file mode 100644
index 0000000..157c9ab
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_directed.py
@@ -0,0 +1,128 @@
+"""Generators - Directed Graphs
+----------------------------
+"""
+import pytest
+
+import networkx as nx
+from networkx.classes import Graph, MultiDiGraph
+from networkx.generators.directed import (
+    gn_graph,
+    gnc_graph,
+    gnr_graph,
+    random_k_out_graph,
+    random_uniform_k_out_graph,
+    scale_free_graph,
+)
+
+
+class TestGeneratorsDirected:
+    def test_smoke_test_random_graphs(self):
+        gn_graph(100)
+        gnr_graph(100, 0.5)
+        gnc_graph(100)
+        scale_free_graph(100)
+
+        gn_graph(100, seed=42)
+        gnr_graph(100, 0.5, seed=42)
+        gnc_graph(100, seed=42)
+        scale_free_graph(100, seed=42)
+
+    def test_create_using_keyword_arguments(self):
+        pytest.raises(nx.NetworkXError, gn_graph, 100, create_using=Graph())
+        pytest.raises(nx.NetworkXError, gnr_graph, 100, 0.5, create_using=Graph())
+        pytest.raises(nx.NetworkXError, gnc_graph, 100, create_using=Graph())
+        pytest.raises(nx.NetworkXError, scale_free_graph, 100, create_using=Graph())
+        G = gn_graph(100, seed=1)
+        MG = gn_graph(100, create_using=MultiDiGraph(), seed=1)
+        assert sorted(G.edges()) == sorted(MG.edges())
+        G = gnr_graph(100, 0.5, seed=1)
+        MG = gnr_graph(100, 0.5, create_using=MultiDiGraph(), seed=1)
+        assert sorted(G.edges()) == sorted(MG.edges())
+        G = gnc_graph(100, seed=1)
+        MG = gnc_graph(100, create_using=MultiDiGraph(), seed=1)
+        assert sorted(G.edges()) == sorted(MG.edges())
+
+        G = scale_free_graph(
+            100,
+            alpha=0.3,
+            beta=0.4,
+            gamma=0.3,
+            delta_in=0.3,
+            delta_out=0.1,
+            initial_graph=nx.cycle_graph(4, create_using=MultiDiGraph),
+            seed=1,
+        )
+        pytest.raises(ValueError, scale_free_graph, 100, 0.5, 0.4, 0.3)
+        pytest.raises(ValueError, scale_free_graph, 100, alpha=-0.3)
+        pytest.raises(ValueError, scale_free_graph, 100, beta=-0.3)
+        pytest.raises(ValueError, scale_free_graph, 100, gamma=-0.3)
+
+
+@pytest.mark.parametrize("ig", (nx.Graph(), nx.DiGraph([(0, 1)])))
+def test_scale_free_graph_initial_graph_kwarg(ig):
+    with pytest.raises(nx.NetworkXError):
+        scale_free_graph(100, initial_graph=ig)
+
+
+class TestRandomKOutGraph:
+    """Unit tests for the
+    :func:`~networkx.generators.directed.random_k_out_graph` function.
+
+    """
+
+    def test_regularity(self):
+        """Tests that the generated graph is `k`-out-regular."""
+        n = 10
+        k = 3
+        alpha = 1
+        G = random_k_out_graph(n, k, alpha)
+        assert all(d == k for v, d in G.out_degree())
+        G = random_k_out_graph(n, k, alpha, seed=42)
+        assert all(d == k for v, d in G.out_degree())
+
+    def test_no_self_loops(self):
+        """Tests for forbidding self-loops."""
+        n = 10
+        k = 3
+        alpha = 1
+        G = random_k_out_graph(n, k, alpha, self_loops=False)
+        assert nx.number_of_selfloops(G) == 0
+
+
+class TestUniformRandomKOutGraph:
+    """Unit tests for the
+    :func:`~networkx.generators.directed.random_uniform_k_out_graph`
+    function.
+
+    """
+
+    def test_regularity(self):
+        """Tests that the generated graph is `k`-out-regular."""
+        n = 10
+        k = 3
+        G = random_uniform_k_out_graph(n, k)
+        assert all(d == k for v, d in G.out_degree())
+        G = random_uniform_k_out_graph(n, k, seed=42)
+        assert all(d == k for v, d in G.out_degree())
+
+    def test_no_self_loops(self):
+        """Tests for forbidding self-loops."""
+        n = 10
+        k = 3
+        G = random_uniform_k_out_graph(n, k, self_loops=False)
+        assert nx.number_of_selfloops(G) == 0
+        assert all(d == k for v, d in G.out_degree())
+
+    def test_with_replacement(self):
+        n = 10
+        k = 3
+        G = random_uniform_k_out_graph(n, k, with_replacement=True)
+        assert G.is_multigraph()
+        assert all(d == k for v, d in G.out_degree())
+
+    def test_without_replacement(self):
+        n = 10
+        k = 3
+        G = random_uniform_k_out_graph(n, k, with_replacement=False)
+        assert not G.is_multigraph()
+        assert all(d == k for v, d in G.out_degree())
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_duplication.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_duplication.py
new file mode 100644
index 0000000..fa97f40
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_duplication.py
@@ -0,0 +1,73 @@
+"""Unit tests for the :mod:`networkx.generators.duplication` module.
+
+"""
+import pytest
+
+from networkx.exception import NetworkXError
+from networkx.generators.duplication import (
+    duplication_divergence_graph,
+    partial_duplication_graph,
+)
+
+
+class TestDuplicationDivergenceGraph:
+    """Unit tests for the
+    :func:`networkx.generators.duplication.duplication_divergence_graph`
+    function.
+
+    """
+
+    def test_final_size(self):
+        G = duplication_divergence_graph(3, 1)
+        assert len(G) == 3
+        G = duplication_divergence_graph(3, 1, seed=42)
+        assert len(G) == 3
+
+    def test_probability_too_large(self):
+        with pytest.raises(NetworkXError):
+            duplication_divergence_graph(3, 2)
+
+    def test_probability_too_small(self):
+        with pytest.raises(NetworkXError):
+            duplication_divergence_graph(3, -1)
+
+
+class TestPartialDuplicationGraph:
+    """Unit tests for the
+    :func:`networkx.generators.duplication.partial_duplication_graph`
+    function.
+
+    """
+
+    def test_final_size(self):
+        N = 10
+        n = 5
+        p = 0.5
+        q = 0.5
+        G = partial_duplication_graph(N, n, p, q)
+        assert len(G) == N
+        G = partial_duplication_graph(N, n, p, q, seed=42)
+        assert len(G) == N
+
+    def test_initial_clique_size(self):
+        N = 10
+        n = 10
+        p = 0.5
+        q = 0.5
+        G = partial_duplication_graph(N, n, p, q)
+        assert len(G) == n
+
+    def test_invalid_initial_size(self):
+        with pytest.raises(NetworkXError):
+            N = 5
+            n = 10
+            p = 0.5
+            q = 0.5
+            G = partial_duplication_graph(N, n, p, q)
+
+    def test_invalid_probabilities(self):
+        N = 1
+        n = 1
+        for p, q in [(0.5, 2), (0.5, -1), (2, 0.5), (-1, 0.5)]:
+            args = (N, n, p, q)
+            pytest.raises(NetworkXError, partial_duplication_graph, *args)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_ego.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_ego.py
new file mode 100644
index 0000000..f6fc779
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_ego.py
@@ -0,0 +1,39 @@
+"""
+ego graph
+---------
+"""
+
+import networkx as nx
+from networkx.utils import edges_equal, nodes_equal
+
+
+class TestGeneratorEgo:
+    def test_ego(self):
+        G = nx.star_graph(3)
+        H = nx.ego_graph(G, 0)
+        assert nx.is_isomorphic(G, H)
+        G.add_edge(1, 11)
+        G.add_edge(2, 22)
+        G.add_edge(3, 33)
+        H = nx.ego_graph(G, 0)
+        assert nx.is_isomorphic(nx.star_graph(3), H)
+        G = nx.path_graph(3)
+        H = nx.ego_graph(G, 0)
+        assert edges_equal(H.edges(), [(0, 1)])
+        H = nx.ego_graph(G, 0, undirected=True)
+        assert edges_equal(H.edges(), [(0, 1)])
+        H = nx.ego_graph(G, 0, center=False)
+        assert edges_equal(H.edges(), [])
+
+    def test_ego_distance(self):
+        G = nx.Graph()
+        G.add_edge(0, 1, weight=2, distance=1)
+        G.add_edge(1, 2, weight=2, distance=2)
+        G.add_edge(2, 3, weight=2, distance=1)
+        assert nodes_equal(nx.ego_graph(G, 0, radius=3).nodes(), [0, 1, 2, 3])
+        eg = nx.ego_graph(G, 0, radius=3, distance="weight")
+        assert nodes_equal(eg.nodes(), [0, 1])
+        eg = nx.ego_graph(G, 0, radius=3, distance="weight", undirected=True)
+        assert nodes_equal(eg.nodes(), [0, 1])
+        eg = nx.ego_graph(G, 0, radius=3, distance="distance")
+        assert nodes_equal(eg.nodes(), [0, 1, 2])
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_expanders.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_expanders.py
new file mode 100644
index 0000000..738773f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_expanders.py
@@ -0,0 +1,73 @@
+"""Unit tests for the :mod:`networkx.generators.expanders` module.
+
+"""
+
+import pytest
+
+import networkx as nx
+from networkx import adjacency_matrix, number_of_nodes
+from networkx.generators.expanders import (
+    chordal_cycle_graph,
+    margulis_gabber_galil_graph,
+    paley_graph,
+)
+
+
+def test_margulis_gabber_galil_graph():
+    for n in 2, 3, 5, 6, 10:
+        g = margulis_gabber_galil_graph(n)
+        assert number_of_nodes(g) == n * n
+        for node in g:
+            assert g.degree(node) == 8
+            assert len(node) == 2
+            for i in node:
+                assert int(i) == i
+                assert 0 <= i < n
+
+    np = pytest.importorskip("numpy")
+    sp = pytest.importorskip("scipy")
+    import scipy.linalg
+
+    # Eigenvalues are already sorted using the scipy eigvalsh,
+    # but the implementation in numpy does not guarantee order.
+    w = sorted(sp.linalg.eigvalsh(adjacency_matrix(g).A))
+    assert w[-2] < 5 * np.sqrt(2)
+
+
+def test_chordal_cycle_graph():
+    """Test for the :func:`networkx.chordal_cycle_graph` function."""
+    primes = [3, 5, 7, 11]
+    for p in primes:
+        G = chordal_cycle_graph(p)
+        assert len(G) == p
+        # TODO The second largest eigenvalue should be smaller than a constant,
+        # independent of the number of nodes in the graph:
+        #
+        #     eigs = sorted(sp.linalg.eigvalsh(adjacency_matrix(G).A))
+        #     assert_less(eigs[-2], ...)
+        #
+
+
+def test_paley_graph():
+    """Test for the :func:`networkx.paley_graph` function."""
+    primes = [3, 5, 7, 11, 13]
+    for p in primes:
+        G = paley_graph(p)
+        # G has p nodes
+        assert len(G) == p
+        # G is (p-1)/2-regular
+        in_degrees = {G.in_degree(node) for node in G.nodes}
+        out_degrees = {G.out_degree(node) for node in G.nodes}
+        assert len(in_degrees) == 1 and in_degrees.pop() == (p - 1) // 2
+        assert len(out_degrees) == 1 and out_degrees.pop() == (p - 1) // 2
+
+        # If p = 1 mod 4, -1 is a square mod 4 and therefore the
+        # edge in the Paley graph are symmetric.
+        if p % 4 == 1:
+            for (u, v) in G.edges:
+                assert (v, u) in G.edges
+
+
+def test_margulis_gabber_galil_graph_badinput():
+    pytest.raises(nx.NetworkXError, margulis_gabber_galil_graph, 3, nx.DiGraph())
+    pytest.raises(nx.NetworkXError, margulis_gabber_galil_graph, 3, nx.Graph())
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_geometric.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_geometric.py
new file mode 100644
index 0000000..58490bf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_geometric.py
@@ -0,0 +1,329 @@
+import math
+import random
+from itertools import combinations
+
+import pytest
+
+import networkx as nx
+
+
+def l1dist(x, y):
+    return sum(abs(a - b) for a, b in zip(x, y))
+
+
+class TestRandomGeometricGraph:
+    """Unit tests for the :func:`~networkx.random_geometric_graph`
+    function.
+
+    """
+
+    def test_number_of_nodes(self):
+        G = nx.random_geometric_graph(50, 0.25, seed=42)
+        assert len(G) == 50
+        G = nx.random_geometric_graph(range(50), 0.25, seed=42)
+        assert len(G) == 50
+
+    def test_distances(self):
+        """Tests that pairs of vertices adjacent if and only if they are
+        within the prescribed radius.
+
+        """
+        # Use the Euclidean metric, the default according to the
+        # documentation.
+        G = nx.random_geometric_graph(50, 0.25)
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must be within the given distance.
+            if v in G[u]:
+                assert math.dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+            # Nonadjacent vertices must be at greater distance.
+            else:
+                assert not math.dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+
+    def test_p(self):
+        """Tests for providing an alternate distance metric to the
+        generator.
+
+        """
+        # Use the L1 metric.
+        G = nx.random_geometric_graph(50, 0.25, p=1)
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must be within the given distance.
+            if v in G[u]:
+                assert l1dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+            # Nonadjacent vertices must be at greater distance.
+            else:
+                assert not l1dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+
+    def test_node_names(self):
+        """Tests using values other than sequential numbers as node IDs."""
+        import string
+
+        nodes = list(string.ascii_lowercase)
+        G = nx.random_geometric_graph(nodes, 0.25)
+        assert len(G) == len(nodes)
+
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must be within the given distance.
+            if v in G[u]:
+                assert math.dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+            # Nonadjacent vertices must be at greater distance.
+            else:
+                assert not math.dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+
+
+class TestSoftRandomGeometricGraph:
+    """Unit tests for the :func:`~networkx.soft_random_geometric_graph`
+    function.
+
+    """
+
+    def test_number_of_nodes(self):
+        G = nx.soft_random_geometric_graph(50, 0.25, seed=42)
+        assert len(G) == 50
+        G = nx.soft_random_geometric_graph(range(50), 0.25, seed=42)
+        assert len(G) == 50
+
+    def test_distances(self):
+        """Tests that pairs of vertices adjacent if and only if they are
+        within the prescribed radius.
+
+        """
+        # Use the Euclidean metric, the default according to the
+        # documentation.
+        G = nx.soft_random_geometric_graph(50, 0.25)
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must be within the given distance.
+            if v in G[u]:
+                assert math.dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+
+    def test_p(self):
+        """Tests for providing an alternate distance metric to the
+        generator.
+
+        """
+        # Use the L1 metric.
+        def dist(x, y):
+            return sum(abs(a - b) for a, b in zip(x, y))
+
+        G = nx.soft_random_geometric_graph(50, 0.25, p=1)
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must be within the given distance.
+            if v in G[u]:
+                assert dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+
+    def test_node_names(self):
+        """Tests using values other than sequential numbers as node IDs."""
+        import string
+
+        nodes = list(string.ascii_lowercase)
+        G = nx.soft_random_geometric_graph(nodes, 0.25)
+        assert len(G) == len(nodes)
+
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must be within the given distance.
+            if v in G[u]:
+                assert math.dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+
+    def test_p_dist_default(self):
+        """Tests default p_dict = 0.5 returns graph with edge count <= RGG with
+        same n, radius, dim and positions
+
+        """
+        nodes = 50
+        dim = 2
+        pos = {v: [random.random() for i in range(dim)] for v in range(nodes)}
+        RGG = nx.random_geometric_graph(50, 0.25, pos=pos)
+        SRGG = nx.soft_random_geometric_graph(50, 0.25, pos=pos)
+        assert len(SRGG.edges()) <= len(RGG.edges())
+
+    def test_p_dist_zero(self):
+        """Tests if p_dict = 0 returns disconencted graph with 0 edges"""
+
+        def p_dist(dist):
+            return 0
+
+        G = nx.soft_random_geometric_graph(50, 0.25, p_dist=p_dist)
+        assert len(G.edges) == 0
+
+
+def join(G, u, v, theta, alpha, metric):
+    """Returns ``True`` if and only if the nodes whose attributes are
+    ``du`` and ``dv`` should be joined, according to the threshold
+    condition for geographical threshold graphs.
+
+    ``G`` is an undirected NetworkX graph, and ``u`` and ``v`` are nodes
+    in that graph. The nodes must have node attributes ``'pos'`` and
+    ``'weight'``.
+
+    ``metric`` is a distance metric.
+
+    """
+    du, dv = G.nodes[u], G.nodes[v]
+    u_pos, v_pos = du["pos"], dv["pos"]
+    u_weight, v_weight = du["weight"], dv["weight"]
+    return (u_weight + v_weight) * metric(u_pos, v_pos) ** alpha >= theta
+
+
+class TestGeographicalThresholdGraph:
+    """Unit tests for the :func:`~networkx.geographical_threshold_graph`
+    function.
+
+    """
+
+    def test_number_of_nodes(self):
+        G = nx.geographical_threshold_graph(50, 100, seed=42)
+        assert len(G) == 50
+        G = nx.geographical_threshold_graph(range(50), 100, seed=42)
+        assert len(G) == 50
+
+    def test_distances(self):
+        """Tests that pairs of vertices adjacent if and only if their
+        distances meet the given threshold.
+
+        """
+        # Use the Euclidean metric and alpha = -2
+        # the default according to the documentation.
+        G = nx.geographical_threshold_graph(50, 10)
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must exceed the threshold.
+            if v in G[u]:
+                assert join(G, u, v, 10, -2, math.dist)
+            # Nonadjacent vertices must not exceed the threshold.
+            else:
+                assert not join(G, u, v, 10, -2, math.dist)
+
+    def test_metric(self):
+        """Tests for providing an alternate distance metric to the
+        generator.
+
+        """
+        # Use the L1 metric.
+        G = nx.geographical_threshold_graph(50, 10, metric=l1dist)
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must exceed the threshold.
+            if v in G[u]:
+                assert join(G, u, v, 10, -2, l1dist)
+            # Nonadjacent vertices must not exceed the threshold.
+            else:
+                assert not join(G, u, v, 10, -2, l1dist)
+
+    def test_p_dist_zero(self):
+        """Tests if p_dict = 0 returns disconencted graph with 0 edges"""
+
+        def p_dist(dist):
+            return 0
+
+        G = nx.geographical_threshold_graph(50, 1, p_dist=p_dist)
+        assert len(G.edges) == 0
+
+
+class TestWaxmanGraph:
+    """Unit tests for the :func:`~networkx.waxman_graph` function."""
+
+    def test_number_of_nodes_1(self):
+        G = nx.waxman_graph(50, 0.5, 0.1, seed=42)
+        assert len(G) == 50
+        G = nx.waxman_graph(range(50), 0.5, 0.1, seed=42)
+        assert len(G) == 50
+
+    def test_number_of_nodes_2(self):
+        G = nx.waxman_graph(50, 0.5, 0.1, L=1)
+        assert len(G) == 50
+        G = nx.waxman_graph(range(50), 0.5, 0.1, L=1)
+        assert len(G) == 50
+
+    def test_metric(self):
+        """Tests for providing an alternate distance metric to the
+        generator.
+
+        """
+        # Use the L1 metric.
+        G = nx.waxman_graph(50, 0.5, 0.1, metric=l1dist)
+        assert len(G) == 50
+
+
+class TestNavigableSmallWorldGraph:
+    def test_navigable_small_world(self):
+        G = nx.navigable_small_world_graph(5, p=1, q=0, seed=42)
+        gg = nx.grid_2d_graph(5, 5).to_directed()
+        assert nx.is_isomorphic(G, gg)
+
+        G = nx.navigable_small_world_graph(5, p=1, q=0, dim=3)
+        gg = nx.grid_graph([5, 5, 5]).to_directed()
+        assert nx.is_isomorphic(G, gg)
+
+        G = nx.navigable_small_world_graph(5, p=1, q=0, dim=1)
+        gg = nx.grid_graph([5]).to_directed()
+        assert nx.is_isomorphic(G, gg)
+
+
+class TestThresholdedRandomGeometricGraph:
+    """Unit tests for the :func:`~networkx.thresholded_random_geometric_graph`
+    function.
+
+    """
+
+    def test_number_of_nodes(self):
+        G = nx.thresholded_random_geometric_graph(50, 0.2, 0.1, seed=42)
+        assert len(G) == 50
+        G = nx.thresholded_random_geometric_graph(range(50), 0.2, 0.1)
+        assert len(G) == 50
+
+    def test_distances(self):
+        """Tests that pairs of vertices adjacent if and only if they are
+        within the prescribed radius.
+
+        """
+        # Use the Euclidean metric, the default according to the
+        # documentation.
+        G = nx.thresholded_random_geometric_graph(50, 0.25, 0.1)
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must be within the given distance.
+            if v in G[u]:
+                assert math.dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+
+    def test_p(self):
+        """Tests for providing an alternate distance metric to the
+        generator.
+
+        """
+        # Use the L1 metric.
+        def dist(x, y):
+            return sum(abs(a - b) for a, b in zip(x, y))
+
+        G = nx.thresholded_random_geometric_graph(50, 0.25, 0.1, p=1)
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must be within the given distance.
+            if v in G[u]:
+                assert dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+
+    def test_node_names(self):
+        """Tests using values other than sequential numbers as node IDs."""
+        import string
+
+        nodes = list(string.ascii_lowercase)
+        G = nx.thresholded_random_geometric_graph(nodes, 0.25, 0.1)
+        assert len(G) == len(nodes)
+
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must be within the given distance.
+            if v in G[u]:
+                assert math.dist(G.nodes[u]["pos"], G.nodes[v]["pos"]) <= 0.25
+
+    def test_theta(self):
+        """Tests that pairs of vertices adjacent if and only if their sum
+        weights exceeds the threshold parameter theta.
+        """
+        G = nx.thresholded_random_geometric_graph(50, 0.25, 0.1)
+
+        for u, v in combinations(G, 2):
+            # Adjacent vertices must be within the given distance.
+            if v in G[u]:
+                assert (G.nodes[u]["weight"] + G.nodes[v]["weight"]) >= 0.1
+
+
+def test_geometric_edges_raises_no_pos():
+    G = nx.path_graph(3)
+    msg = "All nodes in `G` must have a 'pos' attribute"
+    with pytest.raises(nx.NetworkXError, match=msg):
+        nx.geometric_edges(G, radius=1)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_harary_graph.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_harary_graph.py
new file mode 100644
index 0000000..82647e3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_harary_graph.py
@@ -0,0 +1,134 @@
+"""Unit tests for the :mod:`networkx.generators.harary_graph` module.
+"""
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.isomorphism.isomorph import is_isomorphic
+from networkx.generators.harary_graph import hkn_harary_graph, hnm_harary_graph
+
+
+class TestHararyGraph:
+    """
+    Suppose n nodes, m >= n-1 edges, d = 2m // n, r = 2m % n
+    """
+
+    def test_hnm_harary_graph(self):
+        # When d is even and r = 0, the hnm_harary_graph(n,m) is
+        # the circulant_graph(n, list(range(1,d/2+1)))
+        for (n, m) in [(5, 5), (6, 12), (7, 14)]:
+            G1 = hnm_harary_graph(n, m)
+            d = 2 * m // n
+            G2 = nx.circulant_graph(n, list(range(1, d // 2 + 1)))
+            assert is_isomorphic(G1, G2)
+
+        # When d is even and r > 0, the hnm_harary_graph(n,m) is
+        # the circulant_graph(n, list(range(1,d/2+1)))
+        # with r edges added arbitrarily
+        for (n, m) in [(5, 7), (6, 13), (7, 16)]:
+            G1 = hnm_harary_graph(n, m)
+            d = 2 * m // n
+            G2 = nx.circulant_graph(n, list(range(1, d // 2 + 1)))
+            assert set(G2.edges) < set(G1.edges)
+            assert G1.number_of_edges() == m
+
+        # When d is odd and n is even and r = 0, the hnm_harary_graph(n,m)
+        # is the circulant_graph(n, list(range(1,(d+1)/2) plus [n//2])
+        for (n, m) in [(6, 9), (8, 12), (10, 15)]:
+            G1 = hnm_harary_graph(n, m)
+            d = 2 * m // n
+            L = list(range(1, (d + 1) // 2))
+            L.append(n // 2)
+            G2 = nx.circulant_graph(n, L)
+            assert is_isomorphic(G1, G2)
+
+        # When d is odd and n is even and r > 0, the hnm_harary_graph(n,m)
+        # is the circulant_graph(n, list(range(1,(d+1)/2) plus [n//2])
+        # with r edges added arbitrarily
+        for (n, m) in [(6, 10), (8, 13), (10, 17)]:
+            G1 = hnm_harary_graph(n, m)
+            d = 2 * m // n
+            L = list(range(1, (d + 1) // 2))
+            L.append(n // 2)
+            G2 = nx.circulant_graph(n, L)
+            assert set(G2.edges) < set(G1.edges)
+            assert G1.number_of_edges() == m
+
+        # When d is odd and n is odd, the hnm_harary_graph(n,m) is
+        # the circulant_graph(n, list(range(1,(d+1)/2))
+        # with m - n*(d-1)/2 edges added arbitrarily
+        for (n, m) in [(5, 4), (7, 12), (9, 14)]:
+            G1 = hnm_harary_graph(n, m)
+            d = 2 * m // n
+            L = list(range(1, (d + 1) // 2))
+            G2 = nx.circulant_graph(n, L)
+            assert set(G2.edges) < set(G1.edges)
+            assert G1.number_of_edges() == m
+
+        # Raise NetworkXError if n<1
+        n = 0
+        m = 0
+        pytest.raises(nx.NetworkXError, hnm_harary_graph, n, m)
+
+        # Raise NetworkXError if m < n-1
+        n = 6
+        m = 4
+        pytest.raises(nx.NetworkXError, hnm_harary_graph, n, m)
+
+        # Raise NetworkXError if m > n(n-1)/2
+        n = 6
+        m = 16
+        pytest.raises(nx.NetworkXError, hnm_harary_graph, n, m)
+
+    """
+        Suppose connectivity k, number of nodes n
+    """
+
+    def test_hkn_harary_graph(self):
+        # When k == 1, the hkn_harary_graph(k,n) is
+        # the path_graph(n)
+        for (k, n) in [(1, 6), (1, 7)]:
+            G1 = hkn_harary_graph(k, n)
+            G2 = nx.path_graph(n)
+            assert is_isomorphic(G1, G2)
+
+        # When k is even, the hkn_harary_graph(k,n) is
+        # the circulant_graph(n, list(range(1,k/2+1)))
+        for (k, n) in [(2, 6), (2, 7), (4, 6), (4, 7)]:
+            G1 = hkn_harary_graph(k, n)
+            G2 = nx.circulant_graph(n, list(range(1, k // 2 + 1)))
+            assert is_isomorphic(G1, G2)
+
+        # When k is odd and n is even, the hkn_harary_graph(k,n) is
+        # the circulant_graph(n, list(range(1,(k+1)/2)) plus [n/2])
+        for (k, n) in [(3, 6), (5, 8), (7, 10)]:
+            G1 = hkn_harary_graph(k, n)
+            L = list(range(1, (k + 1) // 2))
+            L.append(n // 2)
+            G2 = nx.circulant_graph(n, L)
+            assert is_isomorphic(G1, G2)
+
+        # When k is odd and n is odd, the hkn_harary_graph(k,n) is
+        # the circulant_graph(n, list(range(1,(k+1)/2))) with
+        # n//2+1 edges added between node i and node i+n//2+1
+        for (k, n) in [(3, 5), (5, 9), (7, 11)]:
+            G1 = hkn_harary_graph(k, n)
+            G2 = nx.circulant_graph(n, list(range(1, (k + 1) // 2)))
+            eSet1 = set(G1.edges)
+            eSet2 = set(G2.edges)
+            eSet3 = set()
+            half = n // 2
+            for i in range(0, half + 1):
+                # add half+1 edges between i and i+half
+                eSet3.add((i, (i + half) % n))
+            assert eSet1 == eSet2 | eSet3
+
+        # Raise NetworkXError if k<1
+        k = 0
+        n = 0
+        pytest.raises(nx.NetworkXError, hkn_harary_graph, k, n)
+
+        # Raise NetworkXError if n<k+1
+        k = 6
+        n = 6
+        pytest.raises(nx.NetworkXError, hkn_harary_graph, k, n)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_internet_as_graphs.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_internet_as_graphs.py
new file mode 100644
index 0000000..fdfbf05
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_internet_as_graphs.py
@@ -0,0 +1,190 @@
+from pytest import approx
+
+from networkx import is_connected, neighbors
+from networkx.generators.internet_as_graphs import random_internet_as_graph
+
+
+class TestInternetASTopology:
+    @classmethod
+    def setup_class(cls):
+        cls.n = 1000
+        cls.seed = 42
+        cls.G = random_internet_as_graph(cls.n, cls.seed)
+        cls.T = []
+        cls.M = []
+        cls.C = []
+        cls.CP = []
+        cls.customers = {}
+        cls.providers = {}
+
+        for i in cls.G.nodes():
+            if cls.G.nodes[i]["type"] == "T":
+                cls.T.append(i)
+            elif cls.G.nodes[i]["type"] == "M":
+                cls.M.append(i)
+            elif cls.G.nodes[i]["type"] == "C":
+                cls.C.append(i)
+            elif cls.G.nodes[i]["type"] == "CP":
+                cls.CP.append(i)
+            else:
+                raise ValueError(
+                    "Inconsistent data in the graph\
+                        node attributes"
+                )
+            cls.set_customers(i)
+            cls.set_providers(i)
+
+    @classmethod
+    def set_customers(cls, i):
+        if i not in cls.customers:
+            cls.customers[i] = set()
+            for j in neighbors(cls.G, i):
+                e = cls.G.edges[(i, j)]
+                if e["type"] == "transit":
+                    customer = int(e["customer"])
+                    if j == customer:
+                        cls.set_customers(j)
+                        cls.customers[i] = cls.customers[i].union(cls.customers[j])
+                        cls.customers[i].add(j)
+                    elif i != customer:
+                        raise ValueError(
+                            "Inconsistent data in the graph\
+                                edge attributes"
+                        )
+
+    @classmethod
+    def set_providers(cls, i):
+        if i not in cls.providers:
+            cls.providers[i] = set()
+            for j in neighbors(cls.G, i):
+                e = cls.G.edges[(i, j)]
+                if e["type"] == "transit":
+                    customer = int(e["customer"])
+                    if i == customer:
+                        cls.set_providers(j)
+                        cls.providers[i] = cls.providers[i].union(cls.providers[j])
+                        cls.providers[i].add(j)
+                    elif j != customer:
+                        raise ValueError(
+                            "Inconsistent data in the graph\
+                                edge attributes"
+                        )
+
+    def test_wrong_input(self):
+        G = random_internet_as_graph(0)
+        assert len(G.nodes()) == 0
+
+        G = random_internet_as_graph(-1)
+        assert len(G.nodes()) == 0
+
+        G = random_internet_as_graph(1)
+        assert len(G.nodes()) == 1
+
+    def test_node_numbers(self):
+        assert len(self.G.nodes()) == self.n
+        assert len(self.T) < 7
+        assert len(self.M) == round(self.n * 0.15)
+        assert len(self.CP) == round(self.n * 0.05)
+        numb = self.n - len(self.T) - len(self.M) - len(self.CP)
+        assert len(self.C) == numb
+
+    def test_connectivity(self):
+        assert is_connected(self.G)
+
+    def test_relationships(self):
+        # T nodes are not customers of anyone
+        for i in self.T:
+            assert len(self.providers[i]) == 0
+
+        # C nodes are not providers of anyone
+        for i in self.C:
+            assert len(self.customers[i]) == 0
+
+        # CP nodes are not providers of anyone
+        for i in self.CP:
+            assert len(self.customers[i]) == 0
+
+        # test whether there is a customer-provider loop
+        for i in self.G.nodes():
+            assert len(self.customers[i].intersection(self.providers[i])) == 0
+
+        # test whether there is a peering with a customer or provider
+        for i, j in self.G.edges():
+            if self.G.edges[(i, j)]["type"] == "peer":
+                assert j not in self.customers[i]
+                assert i not in self.customers[j]
+                assert j not in self.providers[i]
+                assert i not in self.providers[j]
+
+    def test_degree_values(self):
+        d_m = 0  # multihoming degree for M nodes
+        d_cp = 0  # multihoming degree for CP nodes
+        d_c = 0  # multihoming degree for C nodes
+        p_m_m = 0  # avg number of peering edges between M and M
+        p_cp_m = 0  # avg number of peering edges between CP and M
+        p_cp_cp = 0  # avg number of peering edges between CP and CP
+        t_m = 0  # probability M's provider is T
+        t_cp = 0  # probability CP's provider is T
+        t_c = 0  # probability C's provider is T
+
+        for i, j in self.G.edges():
+            e = self.G.edges[(i, j)]
+            if e["type"] == "transit":
+                cust = int(e["customer"])
+                if i == cust:
+                    prov = j
+                elif j == cust:
+                    prov = i
+                else:
+                    raise ValueError(
+                        "Inconsistent data in the graph edge\
+                            attributes"
+                    )
+                if cust in self.M:
+                    d_m += 1
+                    if self.G.nodes[prov]["type"] == "T":
+                        t_m += 1
+                elif cust in self.C:
+                    d_c += 1
+                    if self.G.nodes[prov]["type"] == "T":
+                        t_c += 1
+                elif cust in self.CP:
+                    d_cp += 1
+                    if self.G.nodes[prov]["type"] == "T":
+                        t_cp += 1
+                else:
+                    raise ValueError(
+                        "Inconsistent data in the graph edge\
+                            attributes"
+                    )
+            elif e["type"] == "peer":
+                if self.G.nodes[i]["type"] == "M" and self.G.nodes[j]["type"] == "M":
+                    p_m_m += 1
+                if self.G.nodes[i]["type"] == "CP" and self.G.nodes[j]["type"] == "CP":
+                    p_cp_cp += 1
+                if (
+                    self.G.nodes[i]["type"] == "M"
+                    and self.G.nodes[j]["type"] == "CP"
+                    or self.G.nodes[i]["type"] == "CP"
+                    and self.G.nodes[j]["type"] == "M"
+                ):
+                    p_cp_m += 1
+            else:
+                raise ValueError(
+                    "Unexpected data in the graph edge\
+                        attributes"
+                )
+
+        assert d_m / len(self.M) == approx((2 + (2.5 * self.n) / 10000), abs=1e-0)
+        assert d_cp / len(self.CP) == approx((2 + (1.5 * self.n) / 10000), abs=1e-0)
+        assert d_c / len(self.C) == approx((1 + (5 * self.n) / 100000), abs=1e-0)
+
+        assert p_m_m / len(self.M) == approx((1 + (2 * self.n) / 10000), abs=1e-0)
+        assert p_cp_m / len(self.CP) == approx((0.2 + (2 * self.n) / 10000), abs=1e-0)
+        assert p_cp_cp / len(self.CP) == approx(
+            (0.05 + (2 * self.n) / 100000), abs=1e-0
+        )
+
+        assert t_m / d_m == approx(0.375, abs=1e-1)
+        assert t_cp / d_cp == approx(0.375, abs=1e-1)
+        assert t_c / d_c == approx(0.125, abs=1e-1)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_intersection.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_intersection.py
new file mode 100644
index 0000000..f52551b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_intersection.py
@@ -0,0 +1,28 @@
+import pytest
+
+import networkx as nx
+
+
+class TestIntersectionGraph:
+    def test_random_intersection_graph(self):
+        G = nx.uniform_random_intersection_graph(10, 5, 0.5)
+        assert len(G) == 10
+
+    def test_k_random_intersection_graph(self):
+        G = nx.k_random_intersection_graph(10, 5, 2)
+        assert len(G) == 10
+
+    def test_k_random_intersection_graph_seeded(self):
+        G = nx.k_random_intersection_graph(10, 5, 2, seed=1234)
+        assert len(G) == 10
+
+    def test_general_random_intersection_graph(self):
+        G = nx.general_random_intersection_graph(10, 5, [0.1, 0.2, 0.2, 0.1, 0.1])
+        assert len(G) == 10
+        pytest.raises(
+            ValueError,
+            nx.general_random_intersection_graph,
+            10,
+            5,
+            [0.1, 0.2, 0.2, 0.1],
+        )
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_interval_graph.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_interval_graph.py
new file mode 100644
index 0000000..a64d9c4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_interval_graph.py
@@ -0,0 +1,145 @@
+"""Unit tests for the :mod:`networkx.generators.interval_graph` module.
+
+"""
+import math
+
+import pytest
+
+import networkx as nx
+from networkx.generators.interval_graph import interval_graph
+from networkx.utils import edges_equal
+
+
+class TestIntervalGraph:
+    """Unit tests for :func:`networkx.generators.interval_graph.interval_graph`"""
+
+    def test_empty(self):
+        """Tests for trivial case of empty input"""
+        assert len(interval_graph([])) == 0
+
+    def test_interval_graph_check_invalid(self):
+        """Tests for conditions that raise Exceptions"""
+
+        invalids_having_none = [None, (1, 2)]
+        with pytest.raises(TypeError):
+            interval_graph(invalids_having_none)
+
+        invalids_having_set = [{1, 2}]
+        with pytest.raises(TypeError):
+            interval_graph(invalids_having_set)
+
+        invalids_having_seq_but_not_length2 = [(1, 2, 3)]
+        with pytest.raises(TypeError):
+            interval_graph(invalids_having_seq_but_not_length2)
+
+        invalids_interval = [[3, 2]]
+        with pytest.raises(ValueError):
+            interval_graph(invalids_interval)
+
+    def test_interval_graph_0(self):
+        intervals = [(1, 2), (1, 3)]
+
+        expected_graph = nx.Graph()
+        expected_graph.add_edge(*intervals)
+
+        actual_g = interval_graph(intervals)
+
+        assert set(actual_g.nodes) == set(expected_graph.nodes)
+        assert edges_equal(expected_graph, actual_g)
+
+    def test_interval_graph_1(self):
+        intervals = [(1, 2), (2, 3), (3, 4), (1, 4)]
+
+        expected_graph = nx.Graph()
+        expected_graph.add_nodes_from(intervals)
+        e1 = ((1, 4), (1, 2))
+        e2 = ((1, 4), (2, 3))
+        e3 = ((1, 4), (3, 4))
+        e4 = ((3, 4), (2, 3))
+        e5 = ((1, 2), (2, 3))
+
+        expected_graph.add_edges_from([e1, e2, e3, e4, e5])
+
+        actual_g = interval_graph(intervals)
+
+        assert set(actual_g.nodes) == set(expected_graph.nodes)
+        assert edges_equal(expected_graph, actual_g)
+
+    def test_interval_graph_2(self):
+        intervals = [(1, 2), [3, 5], [6, 8], (9, 10)]
+
+        expected_graph = nx.Graph()
+        expected_graph.add_nodes_from([(1, 2), (3, 5), (6, 8), (9, 10)])
+
+        actual_g = interval_graph(intervals)
+
+        assert set(actual_g.nodes) == set(expected_graph.nodes)
+        assert edges_equal(expected_graph, actual_g)
+
+    def test_interval_graph_3(self):
+        intervals = [(1, 4), [3, 5], [2.5, 4]]
+
+        expected_graph = nx.Graph()
+        expected_graph.add_nodes_from([(1, 4), (3, 5), (2.5, 4)])
+        e1 = ((1, 4), (3, 5))
+        e2 = ((1, 4), (2.5, 4))
+        e3 = ((3, 5), (2.5, 4))
+
+        expected_graph.add_edges_from([e1, e2, e3])
+
+        actual_g = interval_graph(intervals)
+
+        assert set(actual_g.nodes) == set(expected_graph.nodes)
+        assert edges_equal(expected_graph, actual_g)
+
+    def test_interval_graph_4(self):
+        """test all possible overlaps"""
+        intervals = [
+            (0, 2),
+            (-2, -1),
+            (-2, 0),
+            (-2, 1),
+            (-2, 2),
+            (-2, 3),
+            (0, 1),
+            (0, 2),
+            (0, 3),
+            (1, 2),
+            (1, 3),
+            (2, 3),
+            (3, 4),
+        ]
+
+        expected_graph = nx.Graph()
+        expected_graph.add_nodes_from(intervals)
+        expected_nbrs = {
+            (-2, 0),
+            (-2, 1),
+            (-2, 2),
+            (-2, 3),
+            (0, 1),
+            (0, 2),
+            (0, 3),
+            (1, 2),
+            (1, 3),
+            (2, 3),
+        }
+        actual_g = nx.interval_graph(intervals)
+        actual_nbrs = nx.neighbors(actual_g, (0, 2))
+
+        assert set(actual_nbrs) == expected_nbrs
+
+    def test_interval_graph_5(self):
+        """this test is to see that an interval supports infinite number"""
+        intervals = {(-math.inf, 0), (-1, -1), (0.5, 0.5), (1, 1), (1, math.inf)}
+
+        expected_graph = nx.Graph()
+        expected_graph.add_nodes_from(intervals)
+        e1 = ((-math.inf, 0), (-1, -1))
+        e2 = ((1, 1), (1, math.inf))
+
+        expected_graph.add_edges_from([e1, e2])
+        actual_g = interval_graph(intervals)
+
+        assert set(actual_g.nodes) == set(expected_graph.nodes)
+        assert edges_equal(expected_graph, actual_g)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_joint_degree_seq.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_joint_degree_seq.py
new file mode 100644
index 0000000..aa581c5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_joint_degree_seq.py
@@ -0,0 +1,127 @@
+import time
+
+from networkx.algorithms.assortativity import degree_mixing_dict
+from networkx.generators import gnm_random_graph, powerlaw_cluster_graph
+from networkx.generators.joint_degree_seq import (
+    directed_joint_degree_graph,
+    is_valid_directed_joint_degree,
+    is_valid_joint_degree,
+    joint_degree_graph,
+)
+
+
+def test_is_valid_joint_degree():
+    """Tests for conditions that invalidate a joint degree dict"""
+
+    # valid joint degree that satisfies all five conditions
+    joint_degrees = {
+        1: {4: 1},
+        2: {2: 2, 3: 2, 4: 2},
+        3: {2: 2, 4: 1},
+        4: {1: 1, 2: 2, 3: 1},
+    }
+    assert is_valid_joint_degree(joint_degrees)
+
+    # test condition 1
+    # joint_degrees_1[1][4] not integer
+    joint_degrees_1 = {
+        1: {4: 1.5},
+        2: {2: 2, 3: 2, 4: 2},
+        3: {2: 2, 4: 1},
+        4: {1: 1.5, 2: 2, 3: 1},
+    }
+    assert not is_valid_joint_degree(joint_degrees_1)
+
+    # test condition 2
+    # degree_count[2] = sum(joint_degrees_2[2][j)/2, is not an int
+    # degree_count[4] = sum(joint_degrees_2[4][j)/4, is not an int
+    joint_degrees_2 = {
+        1: {4: 1},
+        2: {2: 2, 3: 2, 4: 3},
+        3: {2: 2, 4: 1},
+        4: {1: 1, 2: 3, 3: 1},
+    }
+    assert not is_valid_joint_degree(joint_degrees_2)
+
+    # test conditions 3 and 4
+    # joint_degrees_3[1][4]>degree_count[1]*degree_count[4]
+    joint_degrees_3 = {
+        1: {4: 2},
+        2: {2: 2, 3: 2, 4: 2},
+        3: {2: 2, 4: 1},
+        4: {1: 2, 2: 2, 3: 1},
+    }
+    assert not is_valid_joint_degree(joint_degrees_3)
+
+    # test condition 5
+    # joint_degrees_5[1][1] not even
+    joint_degrees_5 = {1: {1: 9}}
+    assert not is_valid_joint_degree(joint_degrees_5)
+
+
+def test_joint_degree_graph(ntimes=10):
+    for _ in range(ntimes):
+        seed = int(time.time())
+
+        n, m, p = 20, 10, 1
+        # generate random graph with model powerlaw_cluster and calculate
+        # its joint degree
+        g = powerlaw_cluster_graph(n, m, p, seed=seed)
+        joint_degrees_g = degree_mixing_dict(g, normalized=False)
+
+        # generate simple undirected graph with given joint degree
+        # joint_degrees_g
+        G = joint_degree_graph(joint_degrees_g)
+        joint_degrees_G = degree_mixing_dict(G, normalized=False)
+
+        # assert that the given joint degree is equal to the generated
+        # graph's joint degree
+        assert joint_degrees_g == joint_degrees_G
+
+
+def test_is_valid_directed_joint_degree():
+
+    in_degrees = [0, 1, 1, 2]
+    out_degrees = [1, 1, 1, 1]
+    nkk = {1: {1: 2, 2: 2}}
+    assert is_valid_directed_joint_degree(in_degrees, out_degrees, nkk)
+
+    # not realizable, values are not integers.
+    nkk = {1: {1: 1.5, 2: 2.5}}
+    assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk)
+
+    # not realizable, number of edges between 1-2 are insufficient.
+    nkk = {1: {1: 2, 2: 1}}
+    assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk)
+
+    # not realizable, in/out degree sequences have different number of nodes.
+    out_degrees = [1, 1, 1]
+    nkk = {1: {1: 2, 2: 2}}
+    assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk)
+
+    # not realizable, degree seqeunces have fewer than required nodes.
+    in_degrees = [0, 1, 2]
+    assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk)
+
+
+def test_directed_joint_degree_graph(n=15, m=100, ntimes=1000):
+    for _ in range(ntimes):
+
+        # generate gnm random graph and calculate its joint degree.
+        g = gnm_random_graph(n, m, None, directed=True)
+
+        # in-degree seqeunce of g as a list of integers.
+        in_degrees = list(dict(g.in_degree()).values())
+        # out-degree sequence of g as a list of integers.
+        out_degrees = list(dict(g.out_degree()).values())
+        nkk = degree_mixing_dict(g)
+
+        # generate simple directed graph with given degree sequence and joint
+        # degree matrix.
+        G = directed_joint_degree_graph(in_degrees, out_degrees, nkk)
+
+        # assert degree sequence correctness.
+        assert in_degrees == list(dict(G.in_degree()).values())
+        assert out_degrees == list(dict(G.out_degree()).values())
+        # assert joint degree matrix correctness.
+        assert nkk == degree_mixing_dict(G)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_lattice.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_lattice.py
new file mode 100644
index 0000000..bb99f62
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_lattice.py
@@ -0,0 +1,246 @@
+"""Unit tests for the :mod:`networkx.generators.lattice` module."""
+
+from itertools import product
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal
+
+
+class TestGrid2DGraph:
+    """Unit tests for :func:`networkx.generators.lattice.grid_2d_graph`"""
+
+    def test_number_of_vertices(self):
+        m, n = 5, 6
+        G = nx.grid_2d_graph(m, n)
+        assert len(G) == m * n
+
+    def test_degree_distribution(self):
+        m, n = 5, 6
+        G = nx.grid_2d_graph(m, n)
+        expected_histogram = [0, 0, 4, 2 * (m + n) - 8, (m - 2) * (n - 2)]
+        assert nx.degree_histogram(G) == expected_histogram
+
+    def test_directed(self):
+        m, n = 5, 6
+        G = nx.grid_2d_graph(m, n)
+        H = nx.grid_2d_graph(m, n, create_using=nx.DiGraph())
+        assert H.succ == G.adj
+        assert H.pred == G.adj
+
+    def test_multigraph(self):
+        m, n = 5, 6
+        G = nx.grid_2d_graph(m, n)
+        H = nx.grid_2d_graph(m, n, create_using=nx.MultiGraph())
+        assert list(H.edges()) == list(G.edges())
+
+    def test_periodic(self):
+        G = nx.grid_2d_graph(0, 0, periodic=True)
+        assert dict(G.degree()) == {}
+
+        for m, n, H in [
+            (2, 2, nx.cycle_graph(4)),
+            (1, 7, nx.cycle_graph(7)),
+            (7, 1, nx.cycle_graph(7)),
+            (2, 5, nx.circular_ladder_graph(5)),
+            (5, 2, nx.circular_ladder_graph(5)),
+            (2, 4, nx.cubical_graph()),
+            (4, 2, nx.cubical_graph()),
+        ]:
+            G = nx.grid_2d_graph(m, n, periodic=True)
+            assert nx.could_be_isomorphic(G, H)
+
+    def test_periodic_iterable(self):
+        m, n = 3, 7
+        for a, b in product([0, 1], [0, 1]):
+            G = nx.grid_2d_graph(m, n, periodic=(a, b))
+            assert G.number_of_nodes() == m * n
+            assert G.number_of_edges() == (m + a - 1) * n + (n + b - 1) * m
+
+    def test_periodic_directed(self):
+        G = nx.grid_2d_graph(4, 2, periodic=True)
+        H = nx.grid_2d_graph(4, 2, periodic=True, create_using=nx.DiGraph())
+        assert H.succ == G.adj
+        assert H.pred == G.adj
+
+    def test_periodic_multigraph(self):
+        G = nx.grid_2d_graph(4, 2, periodic=True)
+        H = nx.grid_2d_graph(4, 2, periodic=True, create_using=nx.MultiGraph())
+        assert list(G.edges()) == list(H.edges())
+
+    def test_exceptions(self):
+        pytest.raises(nx.NetworkXError, nx.grid_2d_graph, -3, 2)
+        pytest.raises(nx.NetworkXError, nx.grid_2d_graph, 3, -2)
+        pytest.raises(TypeError, nx.grid_2d_graph, 3.3, 2)
+        pytest.raises(TypeError, nx.grid_2d_graph, 3, 2.2)
+
+    def test_node_input(self):
+        G = nx.grid_2d_graph(4, 2, periodic=True)
+        H = nx.grid_2d_graph(range(4), range(2), periodic=True)
+        assert nx.is_isomorphic(H, G)
+        H = nx.grid_2d_graph("abcd", "ef", periodic=True)
+        assert nx.is_isomorphic(H, G)
+        G = nx.grid_2d_graph(5, 6)
+        H = nx.grid_2d_graph(range(5), range(6))
+        assert edges_equal(H, G)
+
+
+class TestGridGraph:
+    """Unit tests for :func:`networkx.generators.lattice.grid_graph`"""
+
+    def test_grid_graph(self):
+        """grid_graph([n,m]) is a connected simple graph with the
+        following properties:
+        number_of_nodes = n*m
+        degree_histogram = [0,0,4,2*(n+m)-8,(n-2)*(m-2)]
+        """
+        for n, m in [(3, 5), (5, 3), (4, 5), (5, 4)]:
+            dim = [n, m]
+            g = nx.grid_graph(dim)
+            assert len(g) == n * m
+            assert nx.degree_histogram(g) == [
+                0,
+                0,
+                4,
+                2 * (n + m) - 8,
+                (n - 2) * (m - 2),
+            ]
+
+        for n, m in [(1, 5), (5, 1)]:
+            dim = [n, m]
+            g = nx.grid_graph(dim)
+            assert len(g) == n * m
+            assert nx.is_isomorphic(g, nx.path_graph(5))
+
+    #        mg = nx.grid_graph([n,m], create_using=MultiGraph())
+    #        assert_equal(mg.edges(), g.edges())
+
+    def test_node_input(self):
+        G = nx.grid_graph([range(7, 9), range(3, 6)])
+        assert len(G) == 2 * 3
+        assert nx.is_isomorphic(G, nx.grid_graph([2, 3]))
+
+    def test_periodic_iterable(self):
+        m, n, k = 3, 7, 5
+        for a, b, c in product([0, 1], [0, 1], [0, 1]):
+            G = nx.grid_graph([m, n, k], periodic=(a, b, c))
+            num_e = (m + a - 1) * n * k + (n + b - 1) * m * k + (k + c - 1) * m * n
+            assert G.number_of_nodes() == m * n * k
+            assert G.number_of_edges() == num_e
+
+
+class TestHypercubeGraph:
+    """Unit tests for :func:`networkx.generators.lattice.hypercube_graph`"""
+
+    def test_special_cases(self):
+        for n, H in [
+            (0, nx.null_graph()),
+            (1, nx.path_graph(2)),
+            (2, nx.cycle_graph(4)),
+            (3, nx.cubical_graph()),
+        ]:
+            G = nx.hypercube_graph(n)
+            assert nx.could_be_isomorphic(G, H)
+
+    def test_degree_distribution(self):
+        for n in range(1, 10):
+            G = nx.hypercube_graph(n)
+            expected_histogram = [0] * n + [2**n]
+            assert nx.degree_histogram(G) == expected_histogram
+
+
+class TestTriangularLatticeGraph:
+    "Tests for :func:`networkx.generators.lattice.triangular_lattice_graph`"
+
+    def test_lattice_points(self):
+        """Tests that the graph is really a triangular lattice."""
+        for m, n in [(2, 3), (2, 2), (2, 1), (3, 3), (3, 2), (3, 4)]:
+            G = nx.triangular_lattice_graph(m, n)
+            N = (n + 1) // 2
+            assert len(G) == (m + 1) * (1 + N) - (n % 2) * ((m + 1) // 2)
+        for (i, j) in G.nodes():
+            nbrs = G[(i, j)]
+            if i < N:
+                assert (i + 1, j) in nbrs
+            if j < m:
+                assert (i, j + 1) in nbrs
+            if j < m and (i > 0 or j % 2) and (i < N or (j + 1) % 2):
+                assert (i + 1, j + 1) in nbrs or (i - 1, j + 1) in nbrs
+
+    def test_directed(self):
+        """Tests for creating a directed triangular lattice."""
+        G = nx.triangular_lattice_graph(3, 4, create_using=nx.Graph())
+        H = nx.triangular_lattice_graph(3, 4, create_using=nx.DiGraph())
+        assert H.is_directed()
+        for u, v in H.edges():
+            assert v[1] >= u[1]
+            if v[1] == u[1]:
+                assert v[0] > u[0]
+
+    def test_multigraph(self):
+        """Tests for creating a triangular lattice multigraph."""
+        G = nx.triangular_lattice_graph(3, 4, create_using=nx.Graph())
+        H = nx.triangular_lattice_graph(3, 4, create_using=nx.MultiGraph())
+        assert list(H.edges()) == list(G.edges())
+
+    def test_periodic(self):
+        G = nx.triangular_lattice_graph(4, 6, periodic=True)
+        assert len(G) == 12
+        assert G.size() == 36
+        # all degrees are 6
+        assert len([n for n, d in G.degree() if d != 6]) == 0
+        G = nx.triangular_lattice_graph(5, 7, periodic=True)
+        TLG = nx.triangular_lattice_graph
+        pytest.raises(nx.NetworkXError, TLG, 2, 4, periodic=True)
+        pytest.raises(nx.NetworkXError, TLG, 4, 4, periodic=True)
+        pytest.raises(nx.NetworkXError, TLG, 2, 6, periodic=True)
+
+
+class TestHexagonalLatticeGraph:
+    "Tests for :func:`networkx.generators.lattice.hexagonal_lattice_graph`"
+
+    def test_lattice_points(self):
+        """Tests that the graph is really a hexagonal lattice."""
+        for m, n in [(4, 5), (4, 4), (4, 3), (3, 2), (3, 3), (3, 5)]:
+            G = nx.hexagonal_lattice_graph(m, n)
+            assert len(G) == 2 * (m + 1) * (n + 1) - 2
+        C_6 = nx.cycle_graph(6)
+        hexagons = [
+            [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)],
+            [(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4)],
+            [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3)],
+            [(2, 0), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2)],
+            [(2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4)],
+        ]
+        for hexagon in hexagons:
+            assert nx.is_isomorphic(G.subgraph(hexagon), C_6)
+
+    def test_directed(self):
+        """Tests for creating a directed hexagonal lattice."""
+        G = nx.hexagonal_lattice_graph(3, 5, create_using=nx.Graph())
+        H = nx.hexagonal_lattice_graph(3, 5, create_using=nx.DiGraph())
+        assert H.is_directed()
+        pos = nx.get_node_attributes(H, "pos")
+        for u, v in H.edges():
+            assert pos[v][1] >= pos[u][1]
+            if pos[v][1] == pos[u][1]:
+                assert pos[v][0] > pos[u][0]
+
+    def test_multigraph(self):
+        """Tests for creating a hexagonal lattice multigraph."""
+        G = nx.hexagonal_lattice_graph(3, 5, create_using=nx.Graph())
+        H = nx.hexagonal_lattice_graph(3, 5, create_using=nx.MultiGraph())
+        assert list(H.edges()) == list(G.edges())
+
+    def test_periodic(self):
+        G = nx.hexagonal_lattice_graph(4, 6, periodic=True)
+        assert len(G) == 48
+        assert G.size() == 72
+        # all degrees are 3
+        assert len([n for n, d in G.degree() if d != 3]) == 0
+        G = nx.hexagonal_lattice_graph(5, 8, periodic=True)
+        HLG = nx.hexagonal_lattice_graph
+        pytest.raises(nx.NetworkXError, HLG, 2, 7, periodic=True)
+        pytest.raises(nx.NetworkXError, HLG, 1, 4, periodic=True)
+        pytest.raises(nx.NetworkXError, HLG, 2, 1, periodic=True)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_line.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_line.py
new file mode 100644
index 0000000..96380ac
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_line.py
@@ -0,0 +1,277 @@
+import pytest
+
+import networkx as nx
+import networkx.generators.line as line
+from networkx.utils import edges_equal
+
+
+class TestGeneratorLine:
+    def test_star(self):
+        G = nx.star_graph(5)
+        L = nx.line_graph(G)
+        assert nx.is_isomorphic(L, nx.complete_graph(5))
+
+    def test_path(self):
+        G = nx.path_graph(5)
+        L = nx.line_graph(G)
+        assert nx.is_isomorphic(L, nx.path_graph(4))
+
+    def test_cycle(self):
+        G = nx.cycle_graph(5)
+        L = nx.line_graph(G)
+        assert nx.is_isomorphic(L, G)
+
+    def test_digraph1(self):
+        G = nx.DiGraph([(0, 1), (0, 2), (0, 3)])
+        L = nx.line_graph(G)
+        # no edge graph, but with nodes
+        assert L.adj == {(0, 1): {}, (0, 2): {}, (0, 3): {}}
+
+    def test_multigraph1(self):
+        G = nx.MultiGraph([(0, 1), (0, 1), (1, 0), (0, 2), (2, 0), (0, 3)])
+        L = nx.line_graph(G)
+        # no edge graph, but with nodes
+        assert edges_equal(
+            L.edges(),
+            [
+                ((0, 3, 0), (0, 1, 0)),
+                ((0, 3, 0), (0, 2, 0)),
+                ((0, 3, 0), (0, 2, 1)),
+                ((0, 3, 0), (0, 1, 1)),
+                ((0, 3, 0), (0, 1, 2)),
+                ((0, 1, 0), (0, 1, 1)),
+                ((0, 1, 0), (0, 2, 0)),
+                ((0, 1, 0), (0, 1, 2)),
+                ((0, 1, 0), (0, 2, 1)),
+                ((0, 1, 1), (0, 1, 2)),
+                ((0, 1, 1), (0, 2, 0)),
+                ((0, 1, 1), (0, 2, 1)),
+                ((0, 1, 2), (0, 2, 0)),
+                ((0, 1, 2), (0, 2, 1)),
+                ((0, 2, 0), (0, 2, 1)),
+            ],
+        )
+
+    def test_multigraph2(self):
+        G = nx.MultiGraph([(1, 2), (2, 1)])
+        L = nx.line_graph(G)
+        assert edges_equal(L.edges(), [((1, 2, 0), (1, 2, 1))])
+
+    def test_multidigraph1(self):
+        G = nx.MultiDiGraph([(1, 2), (2, 1)])
+        L = nx.line_graph(G)
+        assert edges_equal(L.edges(), [((1, 2, 0), (2, 1, 0)), ((2, 1, 0), (1, 2, 0))])
+
+    def test_multidigraph2(self):
+        G = nx.MultiDiGraph([(0, 1), (0, 1), (0, 1), (1, 2)])
+        L = nx.line_graph(G)
+        assert edges_equal(
+            L.edges(),
+            [((0, 1, 0), (1, 2, 0)), ((0, 1, 1), (1, 2, 0)), ((0, 1, 2), (1, 2, 0))],
+        )
+
+    def test_digraph2(self):
+        G = nx.DiGraph([(0, 1), (1, 2), (2, 3)])
+        L = nx.line_graph(G)
+        assert edges_equal(L.edges(), [((0, 1), (1, 2)), ((1, 2), (2, 3))])
+
+    def test_create1(self):
+        G = nx.DiGraph([(0, 1), (1, 2), (2, 3)])
+        L = nx.line_graph(G, create_using=nx.Graph())
+        assert edges_equal(L.edges(), [((0, 1), (1, 2)), ((1, 2), (2, 3))])
+
+    def test_create2(self):
+        G = nx.Graph([(0, 1), (1, 2), (2, 3)])
+        L = nx.line_graph(G, create_using=nx.DiGraph())
+        assert edges_equal(L.edges(), [((0, 1), (1, 2)), ((1, 2), (2, 3))])
+
+
+class TestGeneratorInverseLine:
+    def test_example(self):
+        G = nx.Graph()
+        G_edges = [
+            [1, 2],
+            [1, 3],
+            [1, 4],
+            [1, 5],
+            [2, 3],
+            [2, 5],
+            [2, 6],
+            [2, 7],
+            [3, 4],
+            [3, 5],
+            [6, 7],
+            [6, 8],
+            [7, 8],
+        ]
+        G.add_edges_from(G_edges)
+        H = nx.inverse_line_graph(G)
+        solution = nx.Graph()
+        solution_edges = [
+            ("a", "b"),
+            ("a", "c"),
+            ("a", "d"),
+            ("a", "e"),
+            ("c", "d"),
+            ("e", "f"),
+            ("e", "g"),
+            ("f", "g"),
+        ]
+        solution.add_edges_from(solution_edges)
+        assert nx.is_isomorphic(H, solution)
+
+    def test_example_2(self):
+        G = nx.Graph()
+        G_edges = [[1, 2], [1, 3], [2, 3], [3, 4], [3, 5], [4, 5]]
+        G.add_edges_from(G_edges)
+        H = nx.inverse_line_graph(G)
+        solution = nx.Graph()
+        solution_edges = [("a", "c"), ("b", "c"), ("c", "d"), ("d", "e"), ("d", "f")]
+        solution.add_edges_from(solution_edges)
+        assert nx.is_isomorphic(H, solution)
+
+    def test_pair(self):
+        G = nx.path_graph(2)
+        H = nx.inverse_line_graph(G)
+        solution = nx.path_graph(3)
+        assert nx.is_isomorphic(H, solution)
+
+    def test_line(self):
+        G = nx.path_graph(5)
+        solution = nx.path_graph(6)
+        H = nx.inverse_line_graph(G)
+        assert nx.is_isomorphic(H, solution)
+
+    def test_triangle_graph(self):
+        G = nx.complete_graph(3)
+        H = nx.inverse_line_graph(G)
+        alternative_solution = nx.Graph()
+        alternative_solution.add_edges_from([[0, 1], [0, 2], [0, 3]])
+        # there are two alternative inverse line graphs for this case
+        # so long as we get one of them the test should pass
+        assert nx.is_isomorphic(H, G) or nx.is_isomorphic(H, alternative_solution)
+
+    def test_cycle(self):
+        G = nx.cycle_graph(5)
+        H = nx.inverse_line_graph(G)
+        assert nx.is_isomorphic(H, G)
+
+    def test_empty(self):
+        G = nx.Graph()
+        H = nx.inverse_line_graph(G)
+        assert nx.is_isomorphic(H, nx.complete_graph(1))
+
+    def test_K1(self):
+        G = nx.complete_graph(1)
+        H = nx.inverse_line_graph(G)
+        solution = nx.path_graph(2)
+        assert nx.is_isomorphic(H, solution)
+
+    def test_claw(self):
+        # This is the simplest non-line graph
+        G = nx.Graph()
+        G_edges = [[0, 1], [0, 2], [0, 3]]
+        G.add_edges_from(G_edges)
+        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, G)
+
+    def test_non_line_graph(self):
+        # These are other non-line graphs
+
+        # wheel graph with 6 nodes
+        G = nx.Graph()
+        G_edges = [
+            [0, 1],
+            [0, 2],
+            [0, 3],
+            [0, 4],
+            [0, 5],
+            [1, 2],
+            [2, 3],
+            [3, 4],
+            [4, 5],
+            [5, 1],
+        ]
+        G.add_edges_from(G_edges)
+        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, G)
+
+        #   3---4---5
+        #  / \ / \ /
+        # 0---1---2
+        G = nx.Graph()
+        G_edges = [
+            [0, 1],
+            [1, 2],
+            [3, 4],
+            [4, 5],
+            [0, 3],
+            [1, 3],
+            [1, 4],
+            [2, 4],
+            [2, 5],
+        ]
+        G.add_edges_from(G_edges)
+        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, G)
+
+        # K_5 minus an edge
+        K5me = nx.complete_graph(5)
+        K5me.remove_edge(0, 1)
+        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, K5me)
+
+    def test_wrong_graph_type(self):
+        G = nx.DiGraph()
+        G_edges = [[0, 1], [0, 2], [0, 3]]
+        G.add_edges_from(G_edges)
+        pytest.raises(nx.NetworkXNotImplemented, nx.inverse_line_graph, G)
+
+        G = nx.MultiGraph()
+        G_edges = [[0, 1], [0, 2], [0, 3]]
+        G.add_edges_from(G_edges)
+        pytest.raises(nx.NetworkXNotImplemented, nx.inverse_line_graph, G)
+
+    def test_line_inverse_line_complete(self):
+        G = nx.complete_graph(10)
+        H = nx.line_graph(G)
+        J = nx.inverse_line_graph(H)
+        assert nx.is_isomorphic(G, J)
+
+    def test_line_inverse_line_path(self):
+        G = nx.path_graph(10)
+        H = nx.line_graph(G)
+        J = nx.inverse_line_graph(H)
+        assert nx.is_isomorphic(G, J)
+
+    def test_line_inverse_line_hypercube(self):
+        G = nx.hypercube_graph(5)
+        H = nx.line_graph(G)
+        J = nx.inverse_line_graph(H)
+        assert nx.is_isomorphic(G, J)
+
+    def test_line_inverse_line_cycle(self):
+        G = nx.cycle_graph(10)
+        H = nx.line_graph(G)
+        J = nx.inverse_line_graph(H)
+        assert nx.is_isomorphic(G, J)
+
+    def test_line_inverse_line_star(self):
+        G = nx.star_graph(20)
+        H = nx.line_graph(G)
+        J = nx.inverse_line_graph(H)
+        assert nx.is_isomorphic(G, J)
+
+    def test_line_inverse_line_multipartite(self):
+        G = nx.complete_multipartite_graph(3, 4, 5)
+        H = nx.line_graph(G)
+        J = nx.inverse_line_graph(H)
+        assert nx.is_isomorphic(G, J)
+
+    def test_line_inverse_line_dgm(self):
+        G = nx.dorogovtsev_goltsev_mendes_graph(4)
+        H = nx.line_graph(G)
+        J = nx.inverse_line_graph(H)
+        assert nx.is_isomorphic(G, J)
+
+    def test_line_different_node_types(self):
+        G = nx.path_graph([1, 2, 3, "a", "b", "c"])
+        H = nx.line_graph(G)
+        J = nx.inverse_line_graph(H)
+        assert nx.is_isomorphic(G, J)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_mycielski.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_mycielski.py
new file mode 100644
index 0000000..d71260e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_mycielski.py
@@ -0,0 +1,26 @@
+"""Unit tests for the :mod:`networkx.generators.mycielski` module."""
+
+import networkx as nx
+
+
+class TestMycielski:
+    def test_construction(self):
+        G = nx.path_graph(2)
+        M = nx.mycielskian(G)
+        assert nx.is_isomorphic(M, nx.cycle_graph(5))
+
+    def test_size(self):
+        G = nx.path_graph(2)
+        M = nx.mycielskian(G, 2)
+        assert len(M) == 11
+        assert M.size() == 20
+
+    def test_mycielski_graph_generator(self):
+        G = nx.mycielski_graph(1)
+        assert nx.is_isomorphic(G, nx.empty_graph(1))
+        G = nx.mycielski_graph(2)
+        assert nx.is_isomorphic(G, nx.path_graph(2))
+        G = nx.mycielski_graph(3)
+        assert nx.is_isomorphic(G, nx.cycle_graph(5))
+        G = nx.mycielski_graph(4)
+        assert nx.is_isomorphic(G, nx.mycielskian(nx.cycle_graph(5)))
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_nonisomorphic_trees.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_nonisomorphic_trees.py
new file mode 100644
index 0000000..ced1cbe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_nonisomorphic_trees.py
@@ -0,0 +1,64 @@
+"""
+====================
+Generators - Non Isomorphic Trees
+====================
+
+Unit tests for WROM algorithm generator in generators/nonisomorphic_trees.py
+"""
+import networkx as nx
+from networkx.utils import edges_equal
+
+
+class TestGeneratorNonIsomorphicTrees:
+    def test_tree_structure(self):
+        # test for tree structure for nx.nonisomorphic_trees()
+        def f(x):
+            return list(nx.nonisomorphic_trees(x))
+
+        for i in f(6):
+            assert nx.is_tree(i)
+        for i in f(8):
+            assert nx.is_tree(i)
+
+    def test_nonisomorphism(self):
+        # test for nonisomorphism of trees for nx.nonisomorphic_trees()
+        def f(x):
+            return list(nx.nonisomorphic_trees(x))
+
+        trees = f(6)
+        for i in range(len(trees)):
+            for j in range(i + 1, len(trees)):
+                assert not nx.is_isomorphic(trees[i], trees[j])
+        trees = f(8)
+        for i in range(len(trees)):
+            for j in range(i + 1, len(trees)):
+                assert not nx.is_isomorphic(trees[i], trees[j])
+
+    def test_number_of_nonisomorphic_trees(self):
+        # http://oeis.org/A000055
+        assert nx.number_of_nonisomorphic_trees(2) == 1
+        assert nx.number_of_nonisomorphic_trees(3) == 1
+        assert nx.number_of_nonisomorphic_trees(4) == 2
+        assert nx.number_of_nonisomorphic_trees(5) == 3
+        assert nx.number_of_nonisomorphic_trees(6) == 6
+        assert nx.number_of_nonisomorphic_trees(7) == 11
+        assert nx.number_of_nonisomorphic_trees(8) == 23
+
+    def test_nonisomorphic_trees(self):
+        def f(x):
+            return list(nx.nonisomorphic_trees(x))
+
+        assert edges_equal(f(3)[0].edges(), [(0, 1), (0, 2)])
+        assert edges_equal(f(4)[0].edges(), [(0, 1), (0, 3), (1, 2)])
+        assert edges_equal(f(4)[1].edges(), [(0, 1), (0, 2), (0, 3)])
+
+    def test_nonisomorphic_trees_matrix(self):
+        trees_2 = [[[0, 1], [1, 0]]]
+        assert list(nx.nonisomorphic_trees(2, create="matrix")) == trees_2
+        trees_3 = [[[0, 1, 1], [1, 0, 0], [1, 0, 0]]]
+        assert list(nx.nonisomorphic_trees(3, create="matrix")) == trees_3
+        trees_4 = [
+            [[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]],
+            [[0, 1, 1, 1], [1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0]],
+        ]
+        assert list(nx.nonisomorphic_trees(4, create="matrix")) == trees_4
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_random_clustered.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_random_clustered.py
new file mode 100644
index 0000000..e3a37b6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_random_clustered.py
@@ -0,0 +1,34 @@
+import pytest
+
+import networkx
+
+
+class TestRandomClusteredGraph:
+    def test_valid(self):
+        node = [1, 1, 1, 2, 1, 2, 0, 0]
+        tri = [0, 0, 0, 0, 0, 1, 1, 1]
+        joint_degree_sequence = zip(node, tri)
+        G = networkx.random_clustered_graph(joint_degree_sequence)
+        assert G.number_of_nodes() == 8
+        assert G.number_of_edges() == 7
+
+    def test_valid2(self):
+        G = networkx.random_clustered_graph(
+            [(1, 2), (2, 1), (1, 1), (1, 1), (1, 1), (2, 0)]
+        )
+        assert G.number_of_nodes() == 6
+        assert G.number_of_edges() == 10
+
+    def test_invalid1(self):
+        pytest.raises(
+            (TypeError, networkx.NetworkXError),
+            networkx.random_clustered_graph,
+            [[1, 1], [2, 1], [0, 1]],
+        )
+
+    def test_invalid2(self):
+        pytest.raises(
+            (TypeError, networkx.NetworkXError),
+            networkx.random_clustered_graph,
+            [[1, 1], [1, 2], [0, 1]],
+        )
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_random_graphs.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_random_graphs.py
new file mode 100644
index 0000000..c614ded
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_random_graphs.py
@@ -0,0 +1,336 @@
+"""Unit tests for the :mod:`networkx.generators.random_graphs` module."""
+import pytest
+
+import networkx as nx
+
+_gnp_generators = [
+    nx.gnp_random_graph,
+    nx.fast_gnp_random_graph,
+    nx.binomial_graph,
+    nx.erdos_renyi_graph,
+]
+
+
+@pytest.mark.parametrize("generator", _gnp_generators)
+@pytest.mark.parametrize("directed", (True, False))
+def test_gnp_generators_negative_edge_probability(generator, directed):
+    """If the edge probability `p` is <=0, the resulting graph should have no edges."""
+    G = generator(10, -1.1, directed=directed)
+    assert len(G) == 10
+    assert G.number_of_edges() == 0
+    assert G.is_directed() == directed
+
+
+@pytest.mark.parametrize("generator", _gnp_generators)
+@pytest.mark.parametrize(
+    ("directed", "expected_num_edges"),
+    [(False, 45), (True, 90)],
+)
+def test_gnp_generators_greater_than_1_edge_probability(
+    generator, directed, expected_num_edges
+):
+    """If the edge probability `p` is >=1, the resulting graph should be complete."""
+    G = generator(10, 1.1, directed=directed)
+    assert len(G) == 10
+    assert G.number_of_edges() == expected_num_edges
+    assert G.is_directed() == directed
+
+
+@pytest.mark.parametrize("generator", _gnp_generators)
+@pytest.mark.parametrize("directed", (True, False))
+def test_gnp_generators_basic(generator, directed):
+    """If the edge probability `p` is >0 and <1, test only the basic properties."""
+    G = generator(10, 0.1, directed=directed)
+    assert len(G) == 10
+    assert G.is_directed() == directed
+
+
+@pytest.mark.parametrize("generator", _gnp_generators)
+def test_gnp_generators_for_p_close_to_1(generator):
+    """If the edge probability `p` is close to 1, the resulting graph should have all edges."""
+    runs = 100
+    edges = sum(
+        generator(10, 0.99999, directed=True).number_of_edges() for _ in range(runs)
+    )
+    assert abs(edges / float(runs) - 90) <= runs * 2.0 / 100
+
+
+@pytest.mark.parametrize("generator", _gnp_generators)
+@pytest.mark.parametrize("p", (0.2, 0.8))
+@pytest.mark.parametrize("directed", (True, False))
+def test_gnp_generators_edge_probability(generator, p, directed):
+    """Test that gnp generators generate edges according to the their probability `p`."""
+    runs = 5000
+    n = 5
+    edge_counts = [[0] * n for _ in range(n)]
+    for i in range(runs):
+        G = generator(n, p, directed=directed)
+        for (v, w) in G.edges:
+            edge_counts[v][w] += 1
+            if not directed:
+                edge_counts[w][v] += 1
+    for v in range(n):
+        for w in range(n):
+            if v == w:
+                # There should be no loops
+                assert edge_counts[v][w] == 0
+            else:
+                # Each edge should have been generated with probability close to p
+                assert abs(edge_counts[v][w] / float(runs) - p) <= 0.03
+
+
+@pytest.mark.parametrize(
+    "generator", [nx.gnp_random_graph, nx.binomial_graph, nx.erdos_renyi_graph]
+)
+@pytest.mark.parametrize(
+    ("seed", "directed", "expected_num_edges"),
+    [(42, False, 1219), (42, True, 2454), (314, False, 1247), (314, True, 2476)],
+)
+def test_gnp_random_graph_aliases(generator, seed, directed, expected_num_edges):
+    """Test that aliases give the same result with the same seed."""
+    G = generator(100, 0.25, seed=seed, directed=directed)
+    assert len(G) == 100
+    assert G.number_of_edges() == expected_num_edges
+    assert G.is_directed() == directed
+
+
+class TestGeneratorsRandom:
+    def test_random_graph(self):
+        seed = 42
+        G = nx.gnm_random_graph(100, 20, seed)
+        G = nx.gnm_random_graph(100, 20, seed, directed=True)
+        G = nx.dense_gnm_random_graph(100, 20, seed)
+
+        G = nx.watts_strogatz_graph(10, 2, 0.25, seed)
+        assert len(G) == 10
+        assert G.number_of_edges() == 10
+
+        G = nx.connected_watts_strogatz_graph(10, 2, 0.1, tries=10, seed=seed)
+        assert len(G) == 10
+        assert G.number_of_edges() == 10
+        pytest.raises(
+            nx.NetworkXError, nx.connected_watts_strogatz_graph, 10, 2, 0.1, tries=0
+        )
+
+        G = nx.watts_strogatz_graph(10, 4, 0.25, seed)
+        assert len(G) == 10
+        assert G.number_of_edges() == 20
+
+        G = nx.newman_watts_strogatz_graph(10, 2, 0.0, seed)
+        assert len(G) == 10
+        assert G.number_of_edges() == 10
+
+        G = nx.newman_watts_strogatz_graph(10, 4, 0.25, seed)
+        assert len(G) == 10
+        assert G.number_of_edges() >= 20
+
+        G = nx.barabasi_albert_graph(100, 1, seed)
+        G = nx.barabasi_albert_graph(100, 3, seed)
+        assert G.number_of_edges() == (97 * 3)
+
+        G = nx.barabasi_albert_graph(100, 3, seed, nx.complete_graph(5))
+        assert G.number_of_edges() == (10 + 95 * 3)
+
+        G = nx.extended_barabasi_albert_graph(100, 1, 0, 0, seed)
+        assert G.number_of_edges() == 99
+        G = nx.extended_barabasi_albert_graph(100, 3, 0, 0, seed)
+        assert G.number_of_edges() == 97 * 3
+        G = nx.extended_barabasi_albert_graph(100, 1, 0, 0.5, seed)
+        assert G.number_of_edges() == 99
+        G = nx.extended_barabasi_albert_graph(100, 2, 0.5, 0, seed)
+        assert G.number_of_edges() > 100 * 3
+        assert G.number_of_edges() < 100 * 4
+
+        G = nx.extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed)
+        assert G.number_of_edges() > 100 * 2
+        assert G.number_of_edges() < 100 * 4
+
+        G = nx.powerlaw_cluster_graph(100, 1, 1.0, seed)
+        G = nx.powerlaw_cluster_graph(100, 3, 0.0, seed)
+        assert G.number_of_edges() == (97 * 3)
+
+        G = nx.random_regular_graph(10, 20, seed)
+
+        pytest.raises(nx.NetworkXError, nx.random_regular_graph, 3, 21)
+        pytest.raises(nx.NetworkXError, nx.random_regular_graph, 33, 21)
+
+        constructor = [(10, 20, 0.8), (20, 40, 0.8)]
+        G = nx.random_shell_graph(constructor, seed)
+
+        def is_caterpillar(g):
+            """
+            A tree is a caterpillar iff all nodes of degree >=3 are surrounded
+            by at most two nodes of degree two or greater.
+            ref: http://mathworld.wolfram.com/CaterpillarGraph.html
+            """
+            deg_over_3 = [n for n in g if g.degree(n) >= 3]
+            for n in deg_over_3:
+                nbh_deg_over_2 = [nbh for nbh in g.neighbors(n) if g.degree(nbh) >= 2]
+                if not len(nbh_deg_over_2) <= 2:
+                    return False
+            return True
+
+        def is_lobster(g):
+            """
+            A tree is a lobster if it has the property that the removal of leaf
+            nodes leaves a caterpillar graph (Gallian 2007)
+            ref: http://mathworld.wolfram.com/LobsterGraph.html
+            """
+            non_leafs = [n for n in g if g.degree(n) > 1]
+            return is_caterpillar(g.subgraph(non_leafs))
+
+        G = nx.random_lobster(10, 0.1, 0.5, seed)
+        assert max(G.degree(n) for n in G.nodes()) > 3
+        assert is_lobster(G)
+        pytest.raises(nx.NetworkXError, nx.random_lobster, 10, 0.1, 1, seed)
+        pytest.raises(nx.NetworkXError, nx.random_lobster, 10, 1, 1, seed)
+        pytest.raises(nx.NetworkXError, nx.random_lobster, 10, 1, 0.5, seed)
+
+        # docstring says this should be a caterpillar
+        G = nx.random_lobster(10, 0.1, 0.0, seed)
+        assert is_caterpillar(G)
+
+        # difficult to find seed that requires few tries
+        seq = nx.random_powerlaw_tree_sequence(10, 3, seed=14, tries=1)
+        G = nx.random_powerlaw_tree(10, 3, seed=14, tries=1)
+
+    def test_dual_barabasi_albert(self, m1=1, m2=4, p=0.5):
+        """
+        Tests that the dual BA random graph generated behaves consistently.
+
+        Tests the exceptions are raised as expected.
+
+        The graphs generation are repeated several times to prevent lucky shots
+
+        """
+        seeds = [42, 314, 2718]
+        initial_graph = nx.complete_graph(10)
+
+        for seed in seeds:
+
+            # This should be BA with m = m1
+            BA1 = nx.barabasi_albert_graph(100, m1, seed)
+            DBA1 = nx.dual_barabasi_albert_graph(100, m1, m2, 1, seed)
+            assert BA1.edges() == DBA1.edges()
+
+            # This should be BA with m = m2
+            BA2 = nx.barabasi_albert_graph(100, m2, seed)
+            DBA2 = nx.dual_barabasi_albert_graph(100, m1, m2, 0, seed)
+            assert BA2.edges() == DBA2.edges()
+
+            BA3 = nx.barabasi_albert_graph(100, m1, seed)
+            DBA3 = nx.dual_barabasi_albert_graph(100, m1, m1, p, seed)
+            # We can't compare edges here since randomness is "consumed" when drawing
+            # between m1 and m2
+            assert BA3.size() == DBA3.size()
+
+            DBA = nx.dual_barabasi_albert_graph(100, m1, m2, p, seed, initial_graph)
+            BA1 = nx.barabasi_albert_graph(100, m1, seed, initial_graph)
+            BA2 = nx.barabasi_albert_graph(100, m2, seed, initial_graph)
+            assert (
+                min(BA1.size(), BA2.size()) <= DBA.size() <= max(BA1.size(), BA2.size())
+            )
+
+        # Testing exceptions
+        dbag = nx.dual_barabasi_albert_graph
+        pytest.raises(nx.NetworkXError, dbag, m1, m1, m2, 0)
+        pytest.raises(nx.NetworkXError, dbag, m2, m1, m2, 0)
+        pytest.raises(nx.NetworkXError, dbag, 100, m1, m2, -0.5)
+        pytest.raises(nx.NetworkXError, dbag, 100, m1, m2, 1.5)
+        initial = nx.complete_graph(max(m1, m2) - 1)
+        pytest.raises(nx.NetworkXError, dbag, 100, m1, m2, p, initial_graph=initial)
+
+    def test_extended_barabasi_albert(self, m=2):
+        """
+        Tests that the extended BA random graph generated behaves consistently.
+
+        Tests the exceptions are raised as expected.
+
+        The graphs generation are repeated several times to prevent lucky-shots
+
+        """
+        seeds = [42, 314, 2718]
+
+        for seed in seeds:
+            BA_model = nx.barabasi_albert_graph(100, m, seed)
+            BA_model_edges = BA_model.number_of_edges()
+
+            # This behaves just like BA, the number of edges must be the same
+            G1 = nx.extended_barabasi_albert_graph(100, m, 0, 0, seed)
+            assert G1.size() == BA_model_edges
+
+            # More than twice more edges should have been added
+            G1 = nx.extended_barabasi_albert_graph(100, m, 0.8, 0, seed)
+            assert G1.size() > BA_model_edges * 2
+
+            # Only edge rewiring, so the number of edges less than original
+            G2 = nx.extended_barabasi_albert_graph(100, m, 0, 0.8, seed)
+            assert G2.size() == BA_model_edges
+
+            # Mixed scenario: less edges than G1 and more edges than G2
+            G3 = nx.extended_barabasi_albert_graph(100, m, 0.3, 0.3, seed)
+            assert G3.size() > G2.size()
+            assert G3.size() < G1.size()
+
+        # Testing exceptions
+        ebag = nx.extended_barabasi_albert_graph
+        pytest.raises(nx.NetworkXError, ebag, m, m, 0, 0)
+        pytest.raises(nx.NetworkXError, ebag, 1, 0.5, 0, 0)
+        pytest.raises(nx.NetworkXError, ebag, 100, 2, 0.5, 0.5)
+
+    def test_random_zero_regular_graph(self):
+        """Tests that a 0-regular graph has the correct number of nodes and
+        edges.
+
+        """
+        seed = 42
+        G = nx.random_regular_graph(0, 10, seed)
+        assert len(G) == 10
+        assert G.number_of_edges() == 0
+
+    def test_gnm(self):
+        G = nx.gnm_random_graph(10, 3)
+        assert len(G) == 10
+        assert G.number_of_edges() == 3
+
+        G = nx.gnm_random_graph(10, 3, seed=42)
+        assert len(G) == 10
+        assert G.number_of_edges() == 3
+
+        G = nx.gnm_random_graph(10, 100)
+        assert len(G) == 10
+        assert G.number_of_edges() == 45
+
+        G = nx.gnm_random_graph(10, 100, directed=True)
+        assert len(G) == 10
+        assert G.number_of_edges() == 90
+
+        G = nx.gnm_random_graph(10, -1.1)
+        assert len(G) == 10
+        assert G.number_of_edges() == 0
+
+    def test_watts_strogatz_big_k(self):
+        # Test to make sure than n <= k
+        pytest.raises(nx.NetworkXError, nx.watts_strogatz_graph, 10, 11, 0.25)
+        pytest.raises(nx.NetworkXError, nx.newman_watts_strogatz_graph, 10, 11, 0.25)
+
+        # could create an infinite loop, now doesn't
+        # infinite loop used to occur when a node has degree n-1 and needs to rewire
+        nx.watts_strogatz_graph(10, 9, 0.25, seed=0)
+        nx.newman_watts_strogatz_graph(10, 9, 0.5, seed=0)
+
+        # Test k==n scenario
+        nx.watts_strogatz_graph(10, 10, 0.25, seed=0)
+        nx.newman_watts_strogatz_graph(10, 10, 0.25, seed=0)
+
+    def test_random_kernel_graph(self):
+        def integral(u, w, z):
+            return c * (z - w)
+
+        def root(u, w, r):
+            return r / c + w
+
+        c = 1
+        graph = nx.random_kernel_graph(1000, integral, root)
+        graph = nx.random_kernel_graph(1000, integral, root, seed=42)
+        assert len(graph) == 1000
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_small.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_small.py
new file mode 100644
index 0000000..5f5406f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_small.py
@@ -0,0 +1,214 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms.isomorphism.isomorph import graph_could_be_isomorphic
+
+is_isomorphic = graph_could_be_isomorphic
+
+"""Generators - Small
+=====================
+
+Some small graphs
+"""
+
+null = nx.null_graph()
+
+
+class TestGeneratorsSmall:
+    def test_make_small_graph(self):
+        d = ["adjacencylist", "Bull Graph", 5, [[2, 3], [1, 3, 4], [1, 2, 5], [2], [3]]]
+        G = nx.make_small_graph(d)
+        assert is_isomorphic(G, nx.bull_graph())
+
+        # Test small graph creation error with wrong ltype
+        d[0] = "erroneouslist"
+        pytest.raises(nx.NetworkXError, nx.make_small_graph, graph_description=d)
+
+    def test__LCF_graph(self):
+        # If n<=0, then return the null_graph
+        G = nx.LCF_graph(-10, [1, 2], 100)
+        assert is_isomorphic(G, null)
+        G = nx.LCF_graph(0, [1, 2], 3)
+        assert is_isomorphic(G, null)
+        G = nx.LCF_graph(0, [1, 2], 10)
+        assert is_isomorphic(G, null)
+
+        # Test that LCF(n,[],0) == cycle_graph(n)
+        for a, b, c in [(5, [], 0), (10, [], 0), (5, [], 1), (10, [], 10)]:
+            G = nx.LCF_graph(a, b, c)
+            assert is_isomorphic(G, nx.cycle_graph(a))
+
+        # Generate the utility graph K_{3,3}
+        G = nx.LCF_graph(6, [3, -3], 3)
+        utility_graph = nx.complete_bipartite_graph(3, 3)
+        assert is_isomorphic(G, utility_graph)
+
+    def test_properties_named_small_graphs(self):
+        G = nx.bull_graph()
+        assert sorted(G) == list(range(5))
+        assert G.number_of_edges() == 5
+        assert sorted(d for n, d in G.degree()) == [1, 1, 2, 3, 3]
+        assert nx.diameter(G) == 3
+        assert nx.radius(G) == 2
+
+        G = nx.chvatal_graph()
+        assert sorted(G) == list(range(12))
+        assert G.number_of_edges() == 24
+        assert list(d for n, d in G.degree()) == 12 * [4]
+        assert nx.diameter(G) == 2
+        assert nx.radius(G) == 2
+
+        G = nx.cubical_graph()
+        assert sorted(G) == list(range(8))
+        assert G.number_of_edges() == 12
+        assert list(d for n, d in G.degree()) == 8 * [3]
+        assert nx.diameter(G) == 3
+        assert nx.radius(G) == 3
+
+        G = nx.desargues_graph()
+        assert sorted(G) == list(range(20))
+        assert G.number_of_edges() == 30
+        assert list(d for n, d in G.degree()) == 20 * [3]
+
+        G = nx.diamond_graph()
+        assert sorted(G) == list(range(4))
+        assert sorted(d for n, d in G.degree()) == [2, 2, 3, 3]
+        assert nx.diameter(G) == 2
+        assert nx.radius(G) == 1
+
+        G = nx.dodecahedral_graph()
+        assert sorted(G) == list(range(20))
+        assert G.number_of_edges() == 30
+        assert list(d for n, d in G.degree()) == 20 * [3]
+        assert nx.diameter(G) == 5
+        assert nx.radius(G) == 5
+
+        G = nx.frucht_graph()
+        assert sorted(G) == list(range(12))
+        assert G.number_of_edges() == 18
+        assert list(d for n, d in G.degree()) == 12 * [3]
+        assert nx.diameter(G) == 4
+        assert nx.radius(G) == 3
+
+        G = nx.heawood_graph()
+        assert sorted(G) == list(range(14))
+        assert G.number_of_edges() == 21
+        assert list(d for n, d in G.degree()) == 14 * [3]
+        assert nx.diameter(G) == 3
+        assert nx.radius(G) == 3
+
+        G = nx.hoffman_singleton_graph()
+        assert sorted(G) == list(range(50))
+        assert G.number_of_edges() == 175
+        assert list(d for n, d in G.degree()) == 50 * [7]
+        assert nx.diameter(G) == 2
+        assert nx.radius(G) == 2
+
+        G = nx.house_graph()
+        assert sorted(G) == list(range(5))
+        assert G.number_of_edges() == 6
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 3, 3]
+        assert nx.diameter(G) == 2
+        assert nx.radius(G) == 2
+
+        G = nx.house_x_graph()
+        assert sorted(G) == list(range(5))
+        assert G.number_of_edges() == 8
+        assert sorted(d for n, d in G.degree()) == [2, 3, 3, 4, 4]
+        assert nx.diameter(G) == 2
+        assert nx.radius(G) == 1
+
+        G = nx.icosahedral_graph()
+        assert sorted(G) == list(range(12))
+        assert G.number_of_edges() == 30
+        assert list(d for n, d in G.degree()) == [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
+        assert nx.diameter(G) == 3
+        assert nx.radius(G) == 3
+
+        G = nx.krackhardt_kite_graph()
+        assert sorted(G) == list(range(10))
+        assert G.number_of_edges() == 18
+        assert sorted(d for n, d in G.degree()) == [1, 2, 3, 3, 3, 4, 4, 5, 5, 6]
+
+        G = nx.moebius_kantor_graph()
+        assert sorted(G) == list(range(16))
+        assert G.number_of_edges() == 24
+        assert list(d for n, d in G.degree()) == 16 * [3]
+        assert nx.diameter(G) == 4
+
+        G = nx.octahedral_graph()
+        assert sorted(G) == list(range(6))
+        assert G.number_of_edges() == 12
+        assert list(d for n, d in G.degree()) == 6 * [4]
+        assert nx.diameter(G) == 2
+        assert nx.radius(G) == 2
+
+        G = nx.pappus_graph()
+        assert sorted(G) == list(range(18))
+        assert G.number_of_edges() == 27
+        assert list(d for n, d in G.degree()) == 18 * [3]
+        assert nx.diameter(G) == 4
+
+        G = nx.petersen_graph()
+        assert sorted(G) == list(range(10))
+        assert G.number_of_edges() == 15
+        assert list(d for n, d in G.degree()) == 10 * [3]
+        assert nx.diameter(G) == 2
+        assert nx.radius(G) == 2
+
+        G = nx.sedgewick_maze_graph()
+        assert sorted(G) == list(range(8))
+        assert G.number_of_edges() == 10
+        assert sorted(d for n, d in G.degree()) == [1, 2, 2, 2, 3, 3, 3, 4]
+
+        G = nx.tetrahedral_graph()
+        assert sorted(G) == list(range(4))
+        assert G.number_of_edges() == 6
+        assert list(d for n, d in G.degree()) == [3, 3, 3, 3]
+        assert nx.diameter(G) == 1
+        assert nx.radius(G) == 1
+
+        G = nx.truncated_cube_graph()
+        assert sorted(G) == list(range(24))
+        assert G.number_of_edges() == 36
+        assert list(d for n, d in G.degree()) == 24 * [3]
+
+        G = nx.truncated_tetrahedron_graph()
+        assert sorted(G) == list(range(12))
+        assert G.number_of_edges() == 18
+        assert list(d for n, d in G.degree()) == 12 * [3]
+
+        G = nx.tutte_graph()
+        assert sorted(G) == list(range(46))
+        assert G.number_of_edges() == 69
+        assert list(d for n, d in G.degree()) == 46 * [3]
+
+        # Test create_using with directed or multigraphs on small graphs
+        pytest.raises(nx.NetworkXError, nx.tutte_graph, create_using=nx.DiGraph)
+        MG = nx.tutte_graph(create_using=nx.MultiGraph)
+        assert sorted(MG.edges()) == sorted(G.edges())
+
+
+@pytest.mark.parametrize(
+    "fn",
+    (
+        nx.bull_graph,
+        nx.chvatal_graph,
+        nx.cubical_graph,
+        nx.diamond_graph,
+        nx.house_graph,
+        nx.house_x_graph,
+        nx.icosahedral_graph,
+        nx.krackhardt_kite_graph,
+        nx.octahedral_graph,
+        nx.petersen_graph,
+        nx.truncated_cube_graph,
+        nx.tutte_graph,
+    ),
+)
+@pytest.mark.parametrize(
+    "create_using", (nx.DiGraph, nx.MultiDiGraph, nx.DiGraph([(0, 1)]))
+)
+def tests_raises_with_directed_create_using(fn, create_using):
+    with pytest.raises(nx.NetworkXError, match="Directed Graph not supported"):
+        fn(create_using=create_using)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_spectral_graph_forge.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_spectral_graph_forge.py
new file mode 100644
index 0000000..b554bfd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_spectral_graph_forge.py
@@ -0,0 +1,49 @@
+import pytest
+
+pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+
+from networkx import is_isomorphic
+from networkx.exception import NetworkXError
+from networkx.generators import karate_club_graph
+from networkx.generators.spectral_graph_forge import spectral_graph_forge
+from networkx.utils import nodes_equal
+
+
+def test_spectral_graph_forge():
+    G = karate_club_graph()
+
+    seed = 54321
+
+    # common cases, just checking node number preserving and difference
+    # between identity and modularity cases
+    H = spectral_graph_forge(G, 0.1, transformation="identity", seed=seed)
+    assert nodes_equal(G, H)
+
+    I = spectral_graph_forge(G, 0.1, transformation="identity", seed=seed)
+    assert nodes_equal(G, H)
+    assert is_isomorphic(I, H)
+
+    I = spectral_graph_forge(G, 0.1, transformation="modularity", seed=seed)
+    assert nodes_equal(G, I)
+
+    assert not is_isomorphic(I, H)
+
+    # with all the eigenvectors, output graph is identical to the input one
+    H = spectral_graph_forge(G, 1, transformation="modularity", seed=seed)
+    assert nodes_equal(G, H)
+    assert is_isomorphic(G, H)
+
+    # invalid alpha input value, it is silently truncated in [0,1]
+    H = spectral_graph_forge(G, -1, transformation="identity", seed=seed)
+    assert nodes_equal(G, H)
+
+    H = spectral_graph_forge(G, 10, transformation="identity", seed=seed)
+    assert nodes_equal(G, H)
+    assert is_isomorphic(G, H)
+
+    # invalid transformation mode, checking the error raising
+    pytest.raises(
+        NetworkXError, spectral_graph_forge, G, 0.1, transformation="unknown", seed=seed
+    )
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_stochastic.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_stochastic.py
new file mode 100644
index 0000000..d75a6a0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_stochastic.py
@@ -0,0 +1,60 @@
+"""Unit tests for the :mod:`networkx.generators.stochastic` module."""
+import pytest
+
+import networkx as nx
+
+
+class TestStochasticGraph:
+    """Unit tests for the :func:`~networkx.stochastic_graph` function."""
+
+    def test_default_weights(self):
+        G = nx.DiGraph()
+        G.add_edge(0, 1)
+        G.add_edge(0, 2)
+        S = nx.stochastic_graph(G)
+        assert nx.is_isomorphic(G, S)
+        assert sorted(S.edges(data=True)) == [
+            (0, 1, {"weight": 0.5}),
+            (0, 2, {"weight": 0.5}),
+        ]
+
+    def test_in_place(self):
+        """Tests for an in-place reweighting of the edges of the graph."""
+        G = nx.DiGraph()
+        G.add_edge(0, 1, weight=1)
+        G.add_edge(0, 2, weight=1)
+        nx.stochastic_graph(G, copy=False)
+        assert sorted(G.edges(data=True)) == [
+            (0, 1, {"weight": 0.5}),
+            (0, 2, {"weight": 0.5}),
+        ]
+
+    def test_arbitrary_weights(self):
+        G = nx.DiGraph()
+        G.add_edge(0, 1, weight=1)
+        G.add_edge(0, 2, weight=1)
+        S = nx.stochastic_graph(G)
+        assert sorted(S.edges(data=True)) == [
+            (0, 1, {"weight": 0.5}),
+            (0, 2, {"weight": 0.5}),
+        ]
+
+    def test_multidigraph(self):
+        G = nx.MultiDiGraph()
+        G.add_edges_from([(0, 1), (0, 1), (0, 2), (0, 2)])
+        S = nx.stochastic_graph(G)
+        d = dict(weight=0.25)
+        assert sorted(S.edges(data=True)) == [
+            (0, 1, d),
+            (0, 1, d),
+            (0, 2, d),
+            (0, 2, d),
+        ]
+
+    def test_graph_disallowed(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            nx.stochastic_graph(nx.Graph())
+
+    def test_multigraph_disallowed(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            nx.stochastic_graph(nx.MultiGraph())
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_sudoku.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_sudoku.py
new file mode 100644
index 0000000..7c3560a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_sudoku.py
@@ -0,0 +1,92 @@
+"""Unit tests for the :mod:`networkx.generators.sudoku_graph` module."""
+
+import pytest
+
+import networkx as nx
+
+
+def test_sudoku_negative():
+    """Raise an error when generating a Sudoku graph of order -1."""
+    pytest.raises(nx.NetworkXError, nx.sudoku_graph, n=-1)
+
+
+@pytest.mark.parametrize("n", [0, 1, 2, 3, 4])
+def test_sudoku_generator(n):
+    """Generate Sudoku graphs of various sizes and verify their properties."""
+    G = nx.sudoku_graph(n)
+    expected_nodes = n**4
+    expected_degree = (n - 1) * (3 * n + 1)
+    expected_edges = expected_nodes * expected_degree // 2
+    assert not G.is_directed()
+    assert not G.is_multigraph()
+    assert G.number_of_nodes() == expected_nodes
+    assert G.number_of_edges() == expected_edges
+    assert all(d == expected_degree for _, d in G.degree)
+
+    if n == 2:
+        assert sorted(G.neighbors(6)) == [2, 3, 4, 5, 7, 10, 14]
+    elif n == 3:
+        assert sorted(G.neighbors(42)) == [
+            6,
+            15,
+            24,
+            33,
+            34,
+            35,
+            36,
+            37,
+            38,
+            39,
+            40,
+            41,
+            43,
+            44,
+            51,
+            52,
+            53,
+            60,
+            69,
+            78,
+        ]
+    elif n == 4:
+        assert sorted(G.neighbors(0)) == [
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15,
+            16,
+            17,
+            18,
+            19,
+            32,
+            33,
+            34,
+            35,
+            48,
+            49,
+            50,
+            51,
+            64,
+            80,
+            96,
+            112,
+            128,
+            144,
+            160,
+            176,
+            192,
+            208,
+            224,
+            240,
+        ]
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_trees.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_trees.py
new file mode 100644
index 0000000..a13644a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_trees.py
@@ -0,0 +1,88 @@
+import pytest
+
+import networkx as nx
+from networkx.utils import arbitrary_element, graphs_equal
+
+
+@pytest.mark.parametrize("prefix_tree_fn", (nx.prefix_tree, nx.prefix_tree_recursive))
+def test_basic_prefix_tree(prefix_tree_fn):
+    # This example is from the Wikipedia article "Trie"
+    # <https://en.wikipedia.org/wiki/Trie>.
+    strings = ["a", "to", "tea", "ted", "ten", "i", "in", "inn"]
+    T = prefix_tree_fn(strings)
+    root, NIL = 0, -1
+
+    def source_label(v):
+        return T.nodes[v]["source"]
+
+    # First, we check that the tree has the expected
+    # structure. Recall that each node that corresponds to one of
+    # the input strings has an edge to the NIL node.
+    #
+    # Consider the three children at level 1 in the trie.
+    a, i, t = sorted(T[root], key=source_label)
+    # Check the 'a' branch.
+    assert len(T[a]) == 1
+    nil = arbitrary_element(T[a])
+    assert len(T[nil]) == 0
+    # Check the 'i' branch.
+    assert len(T[i]) == 2
+    nil, in_ = sorted(T[i], key=source_label)
+    assert len(T[nil]) == 0
+    assert len(T[in_]) == 2
+    nil, inn = sorted(T[in_], key=source_label)
+    assert len(T[nil]) == 0
+    assert len(T[inn]) == 1
+    nil = arbitrary_element(T[inn])
+    assert len(T[nil]) == 0
+    # Check the 't' branch.
+    te, to = sorted(T[t], key=source_label)
+    assert len(T[to]) == 1
+    nil = arbitrary_element(T[to])
+    assert len(T[nil]) == 0
+    tea, ted, ten = sorted(T[te], key=source_label)
+    assert len(T[tea]) == 1
+    assert len(T[ted]) == 1
+    assert len(T[ten]) == 1
+    nil = arbitrary_element(T[tea])
+    assert len(T[nil]) == 0
+    nil = arbitrary_element(T[ted])
+    assert len(T[nil]) == 0
+    nil = arbitrary_element(T[ten])
+    assert len(T[nil]) == 0
+
+    # Next, we check that the "sources" of each of the nodes is the
+    # rightmost letter in the string corresponding to the path to
+    # that node.
+    assert source_label(root) is None
+    assert source_label(a) == "a"
+    assert source_label(i) == "i"
+    assert source_label(t) == "t"
+    assert source_label(in_) == "n"
+    assert source_label(inn) == "n"
+    assert source_label(to) == "o"
+    assert source_label(te) == "e"
+    assert source_label(tea) == "a"
+    assert source_label(ted) == "d"
+    assert source_label(ten) == "n"
+    assert source_label(NIL) == "NIL"
+
+
+@pytest.mark.parametrize(
+    "strings",
+    (
+        ["a", "to", "tea", "ted", "ten", "i", "in", "inn"],
+        ["ab", "abs", "ad"],
+        ["ab", "abs", "ad", ""],
+        ["distant", "disparaging", "distant", "diamond", "ruby"],
+    ),
+)
+def test_implementations_consistent(strings):
+    """Ensure results are consistent between prefix_tree implementations."""
+    assert graphs_equal(nx.prefix_tree(strings), nx.prefix_tree_recursive(strings))
+
+
+def test_random_tree():
+    """Tests that a random tree is in fact a tree."""
+    T = nx.random_tree(10, seed=1234)
+    assert nx.is_tree(T)
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_triads.py b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_triads.py
new file mode 100644
index 0000000..6fc51ae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/tests/test_triads.py
@@ -0,0 +1,14 @@
+"""Unit tests for the :mod:`networkx.generators.triads` module."""
+import pytest
+
+from networkx import triad_graph
+
+
+def test_triad_graph():
+    G = triad_graph("030T")
+    assert [tuple(e) for e in ("ab", "ac", "cb")] == sorted(G.edges())
+
+
+def test_invalid_name():
+    with pytest.raises(ValueError):
+        triad_graph("bogus")
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/trees.py b/myenv/lib/python3.9/site-packages/networkx/generators/trees.py
new file mode 100644
index 0000000..e380826
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/trees.py
@@ -0,0 +1,374 @@
+"""Functions for generating trees."""
+from collections import defaultdict
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = ["prefix_tree", "random_tree", "prefix_tree_recursive"]
+
+
+def prefix_tree(paths):
+    """Creates a directed prefix tree from a list of paths.
+
+    Usually the paths are described as strings or lists of integers.
+
+    A "prefix tree" represents the prefix structure of the strings.
+    Each node represents a prefix of some string. The root represents
+    the empty prefix with children for the single letter prefixes which
+    in turn have children for each double letter prefix starting with
+    the single letter corresponding to the parent node, and so on.
+
+    More generally the prefixes do not need to be strings. A prefix refers
+    to the start of a sequence. The root has children for each one element
+    prefix and they have children for each two element prefix that starts
+    with the one element sequence of the parent, and so on.
+
+    Note that this implementation uses integer nodes with an attribute.
+    Each node has an attribute "source" whose value is the original element
+    of the path to which this node corresponds. For example, suppose `paths`
+    consists of one path: "can". Then the nodes `[1, 2, 3]` which represent
+    this path have "source" values "c", "a" and "n".
+
+    All the descendants of a node have a common prefix in the sequence/path
+    associated with that node. From the returned tree, the prefix for each
+    node can be constructed by traversing the tree up to the root and
+    accumulating the "source" values along the way.
+
+    The root node is always `0` and has "source" attribute `None`.
+    The root is the only node with in-degree zero.
+    The nil node is always `-1` and has "source" attribute `"NIL"`.
+    The nil node is the only node with out-degree zero.
+
+
+    Parameters
+    ----------
+    paths: iterable of paths
+        An iterable of paths which are themselves sequences.
+        Matching prefixes among these sequences are identified with
+        nodes of the prefix tree. One leaf of the tree is associated
+        with each path. (Identical paths are associated with the same
+        leaf of the tree.)
+
+
+    Returns
+    -------
+    tree: DiGraph
+        A directed graph representing an arborescence consisting of the
+        prefix tree generated by `paths`. Nodes are directed "downward",
+        from parent to child. A special "synthetic" root node is added
+        to be the parent of the first node in each path. A special
+        "synthetic" leaf node, the "nil" node `-1`, is added to be the child
+        of all nodes representing the last element in a path. (The
+        addition of this nil node technically makes this not an
+        arborescence but a directed acyclic graph; removing the nil node
+        makes it an arborescence.)
+
+
+    Notes
+    -----
+    The prefix tree is also known as a *trie*.
+
+
+    Examples
+    --------
+    Create a prefix tree from a list of strings with common prefixes::
+
+        >>> paths = ["ab", "abs", "ad"]
+        >>> T = nx.prefix_tree(paths)
+        >>> list(T.edges)
+        [(0, 1), (1, 2), (1, 4), (2, -1), (2, 3), (3, -1), (4, -1)]
+
+    The leaf nodes can be obtained as predecessors of the nil node::
+
+        >>> root, NIL = 0, -1
+        >>> list(T.predecessors(NIL))
+        [2, 3, 4]
+
+    To recover the original paths that generated the prefix tree,
+    traverse up the tree from the node `-1` to the node `0`::
+
+        >>> recovered = []
+        >>> for v in T.predecessors(NIL):
+        ...     prefix = ""
+        ...     while v != root:
+        ...         prefix = str(T.nodes[v]["source"]) + prefix
+        ...         v = next(T.predecessors(v))  # only one predecessor
+        ...     recovered.append(prefix)
+        >>> sorted(recovered)
+        ['ab', 'abs', 'ad']
+    """
+
+    def get_children(parent, paths):
+        children = defaultdict(list)
+        # Populate dictionary with key(s) as the child/children of the root and
+        # value(s) as the remaining paths of the corresponding child/children
+        for path in paths:
+            # If path is empty, we add an edge to the NIL node.
+            if not path:
+                tree.add_edge(parent, NIL)
+                continue
+            child, *rest = path
+            # `child` may exist as the head of more than one path in `paths`.
+            children[child].append(rest)
+        return children
+
+    # Initialize the prefix tree with a root node and a nil node.
+    tree = nx.DiGraph()
+    root = 0
+    tree.add_node(root, source=None)
+    NIL = -1
+    tree.add_node(NIL, source="NIL")
+    children = get_children(root, paths)
+    stack = [(root, iter(children.items()))]
+    while stack:
+        parent, remaining_children = stack[-1]
+        try:
+            child, remaining_paths = next(remaining_children)
+        # Pop item off stack if there are no remaining children
+        except StopIteration:
+            stack.pop()
+            continue
+        # We relabel each child with an unused name.
+        new_name = len(tree) - 1
+        # The "source" node attribute stores the original node name.
+        tree.add_node(new_name, source=child)
+        tree.add_edge(parent, new_name)
+        children = get_children(new_name, remaining_paths)
+        stack.append((new_name, iter(children.items())))
+
+    return tree
+
+
+def prefix_tree_recursive(paths):
+    """Recursively creates a directed prefix tree from a list of paths.
+
+    The original recursive version of prefix_tree for comparison. It is
+    the same algorithm but the recursion is unrolled onto a stack.
+
+    Usually the paths are described as strings or lists of integers.
+
+    A "prefix tree" represents the prefix structure of the strings.
+    Each node represents a prefix of some string. The root represents
+    the empty prefix with children for the single letter prefixes which
+    in turn have children for each double letter prefix starting with
+    the single letter corresponding to the parent node, and so on.
+
+    More generally the prefixes do not need to be strings. A prefix refers
+    to the start of a sequence. The root has children for each one element
+    prefix and they have children for each two element prefix that starts
+    with the one element sequence of the parent, and so on.
+
+    Note that this implementation uses integer nodes with an attribute.
+    Each node has an attribute "source" whose value is the original element
+    of the path to which this node corresponds. For example, suppose `paths`
+    consists of one path: "can". Then the nodes `[1, 2, 3]` which represent
+    this path have "source" values "c", "a" and "n".
+
+    All the descendants of a node have a common prefix in the sequence/path
+    associated with that node. From the returned tree, ehe prefix for each
+    node can be constructed by traversing the tree up to the root and
+    accumulating the "source" values along the way.
+
+    The root node is always `0` and has "source" attribute `None`.
+    The root is the only node with in-degree zero.
+    The nil node is always `-1` and has "source" attribute `"NIL"`.
+    The nil node is the only node with out-degree zero.
+
+
+    Parameters
+    ----------
+    paths: iterable of paths
+        An iterable of paths which are themselves sequences.
+        Matching prefixes among these sequences are identified with
+        nodes of the prefix tree. One leaf of the tree is associated
+        with each path. (Identical paths are associated with the same
+        leaf of the tree.)
+
+
+    Returns
+    -------
+    tree: DiGraph
+        A directed graph representing an arborescence consisting of the
+        prefix tree generated by `paths`. Nodes are directed "downward",
+        from parent to child. A special "synthetic" root node is added
+        to be the parent of the first node in each path. A special
+        "synthetic" leaf node, the "nil" node `-1`, is added to be the child
+        of all nodes representing the last element in a path. (The
+        addition of this nil node technically makes this not an
+        arborescence but a directed acyclic graph; removing the nil node
+        makes it an arborescence.)
+
+
+    Notes
+    -----
+    The prefix tree is also known as a *trie*.
+
+
+    Examples
+    --------
+    Create a prefix tree from a list of strings with common prefixes::
+
+        >>> paths = ["ab", "abs", "ad"]
+        >>> T = nx.prefix_tree(paths)
+        >>> list(T.edges)
+        [(0, 1), (1, 2), (1, 4), (2, -1), (2, 3), (3, -1), (4, -1)]
+
+    The leaf nodes can be obtained as predecessors of the nil node.
+
+        >>> root, NIL = 0, -1
+        >>> list(T.predecessors(NIL))
+        [2, 3, 4]
+
+    To recover the original paths that generated the prefix tree,
+    traverse up the tree from the node `-1` to the node `0`::
+
+        >>> recovered = []
+        >>> for v in T.predecessors(NIL):
+        ...     prefix = ""
+        ...     while v != root:
+        ...         prefix = str(T.nodes[v]["source"]) + prefix
+        ...         v = next(T.predecessors(v))  # only one predecessor
+        ...     recovered.append(prefix)
+        >>> sorted(recovered)
+        ['ab', 'abs', 'ad']
+    """
+
+    def _helper(paths, root, tree):
+        """Recursively create a trie from the given list of paths.
+
+        `paths` is a list of paths, each of which is itself a list of
+        nodes, relative to the given `root` (but not including it). This
+        list of paths will be interpreted as a tree-like structure, in
+        which two paths that share a prefix represent two branches of
+        the tree with the same initial segment.
+
+        `root` is the parent of the node at index 0 in each path.
+
+        `tree` is the "accumulator", the :class:`networkx.DiGraph`
+        representing the branching to which the new nodes and edges will
+        be added.
+
+        """
+        # For each path, remove the first node and make it a child of root.
+        # Any remaining paths then get processed recursively.
+        children = defaultdict(list)
+        for path in paths:
+            # If path is empty, we add an edge to the NIL node.
+            if not path:
+                tree.add_edge(root, NIL)
+                continue
+            child, *rest = path
+            # `child` may exist as the head of more than one path in `paths`.
+            children[child].append(rest)
+        # Add a node for each child, connect root, recurse to remaining paths
+        for child, remaining_paths in children.items():
+            # We relabel each child with an unused name.
+            new_name = len(tree) - 1
+            # The "source" node attribute stores the original node name.
+            tree.add_node(new_name, source=child)
+            tree.add_edge(root, new_name)
+            _helper(remaining_paths, new_name, tree)
+
+    # Initialize the prefix tree with a root node and a nil node.
+    tree = nx.DiGraph()
+    root = 0
+    tree.add_node(root, source=None)
+    NIL = -1
+    tree.add_node(NIL, source="NIL")
+    # Populate the tree.
+    _helper(paths, root, tree)
+    return tree
+
+
+# From the Wikipedia article on Prüfer sequences:
+#
+# > Generating uniformly distributed random Prüfer sequences and
+# > converting them into the corresponding trees is a straightforward
+# > method of generating uniformly distributed random labelled trees.
+#
+@py_random_state(1)
+def random_tree(n, seed=None, create_using=None):
+    """Returns a uniformly random tree on `n` nodes.
+
+    Parameters
+    ----------
+    n : int
+        A positive integer representing the number of nodes in the tree.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+        Graph type to create. If graph instance, then cleared before populated.
+
+    Returns
+    -------
+    NetworkX graph
+        A tree, given as an undirected graph, whose nodes are numbers in
+        the set {0, …, *n* - 1}.
+
+    Raises
+    ------
+    NetworkXPointlessConcept
+        If `n` is zero (because the null graph is not a tree).
+
+    Notes
+    -----
+    The current implementation of this function generates a uniformly
+    random Prüfer sequence then converts that to a tree via the
+    :func:`~networkx.from_prufer_sequence` function. Since there is a
+    bijection between Prüfer sequences of length *n* - 2 and trees on
+    *n* nodes, the tree is chosen uniformly at random from the set of
+    all trees on *n* nodes.
+
+    Examples
+    --------
+    >>> tree = nx.random_tree(n=10, seed=0)
+    >>> print(nx.forest_str(tree, sources=[0]))
+    ╙── 0
+        ├── 3
+        └── 4
+            ├── 6
+            │   ├── 1
+            │   ├── 2
+            │   └── 7
+            │       └── 8
+            │           └── 5
+            └── 9
+
+    >>> tree = nx.random_tree(n=10, seed=0, create_using=nx.DiGraph)
+    >>> print(nx.forest_str(tree))
+    ╙── 0
+        ├─╼ 3
+        └─╼ 4
+            ├─╼ 6
+            │   ├─╼ 1
+            │   ├─╼ 2
+            │   └─╼ 7
+            │       └─╼ 8
+            │           └─╼ 5
+            └─╼ 9
+    """
+    if n == 0:
+        raise nx.NetworkXPointlessConcept("the null graph is not a tree")
+    # Cannot create a Prüfer sequence unless `n` is at least two.
+    if n == 1:
+        utree = nx.empty_graph(1, create_using)
+    else:
+        sequence = [seed.choice(range(n)) for i in range(n - 2)]
+        utree = nx.from_prufer_sequence(sequence)
+
+    if create_using is None:
+        tree = utree
+    else:
+        tree = nx.empty_graph(0, create_using)
+        if tree.is_directed():
+            # Use a arbitrary root node and dfs to define edge directions
+            edges = nx.dfs_edges(utree, source=0)
+        else:
+            edges = utree.edges
+
+        # Populate the specified graph type
+        tree.add_nodes_from(utree.nodes)
+        tree.add_edges_from(edges)
+
+    return tree
diff --git a/myenv/lib/python3.9/site-packages/networkx/generators/triads.py b/myenv/lib/python3.9/site-packages/networkx/generators/triads.py
new file mode 100644
index 0000000..7557d42
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/generators/triads.py
@@ -0,0 +1,75 @@
+# See https://github.com/networkx/networkx/pull/1474
+# Copyright 2011 Reya Group <http://www.reyagroup.com>
+# Copyright 2011 Alex Levenson <alex@isnotinvain.com>
+# Copyright 2011 Diederik van Liere <diederik.vanliere@rotman.utoronto.ca>
+"""Functions that generate the triad graphs, that is, the possible
+digraphs on three nodes.
+
+"""
+from networkx.classes import DiGraph
+
+__all__ = ["triad_graph"]
+
+#: Dictionary mapping triad name to list of directed edges in the
+#: digraph representation of that triad (with nodes 'a', 'b', and 'c').
+TRIAD_EDGES = {
+    "003": [],
+    "012": ["ab"],
+    "102": ["ab", "ba"],
+    "021D": ["ba", "bc"],
+    "021U": ["ab", "cb"],
+    "021C": ["ab", "bc"],
+    "111D": ["ac", "ca", "bc"],
+    "111U": ["ac", "ca", "cb"],
+    "030T": ["ab", "cb", "ac"],
+    "030C": ["ba", "cb", "ac"],
+    "201": ["ab", "ba", "ac", "ca"],
+    "120D": ["bc", "ba", "ac", "ca"],
+    "120U": ["ab", "cb", "ac", "ca"],
+    "120C": ["ab", "bc", "ac", "ca"],
+    "210": ["ab", "bc", "cb", "ac", "ca"],
+    "300": ["ab", "ba", "bc", "cb", "ac", "ca"],
+}
+
+
+def triad_graph(triad_name):
+    """Returns the triad graph with the given name.
+
+    Each string in the following tuple is a valid triad name::
+
+        ('003', '012', '102', '021D', '021U', '021C', '111D', '111U',
+         '030T', '030C', '201', '120D', '120U', '120C', '210', '300')
+
+    Each triad name corresponds to one of the possible valid digraph on
+    three nodes.
+
+    Parameters
+    ----------
+    triad_name : string
+        The name of a triad, as described above.
+
+    Returns
+    -------
+    :class:`~networkx.DiGraph`
+        The digraph on three nodes with the given name. The nodes of the
+        graph are the single-character strings 'a', 'b', and 'c'.
+
+    Raises
+    ------
+    ValueError
+        If `triad_name` is not the name of a triad.
+
+    See also
+    --------
+    triadic_census
+
+    """
+    if triad_name not in TRIAD_EDGES:
+        raise ValueError(
+            f'unknown triad name "{triad_name}"; use one of the triad names'
+            " in the TRIAD_NAMES constant"
+        )
+    G = DiGraph()
+    G.add_nodes_from("abc")
+    G.add_edges_from(TRIAD_EDGES[triad_name])
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/lazy_imports.py b/myenv/lib/python3.9/site-packages/networkx/lazy_imports.py
new file mode 100644
index 0000000..49344db
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/lazy_imports.py
@@ -0,0 +1,190 @@
+import importlib
+import importlib.util
+import inspect
+import os
+import sys
+import types
+
+__all__ = ["attach", "_lazy_import"]
+
+
+def attach(module_name, submodules=None, submod_attrs=None):
+    """Attach lazily loaded submodules, and functions or other attributes.
+
+    Typically, modules import submodules and attributes as follows::
+
+      import mysubmodule
+      import anothersubmodule
+
+      from .foo import someattr
+
+    The idea of  this function is to replace the `__init__.py`
+    module's `__getattr__`, `__dir__`, and `__all__` attributes such that
+    all imports work exactly the way they normally would, except that the
+    actual import is delayed until the resulting module object is first used.
+
+    The typical way to call this function, replacing the above imports, is::
+
+      __getattr__, __lazy_dir__, __all__ = lazy.attach(
+          __name__,
+          ['mysubmodule', 'anothersubmodule'],
+          {'foo': 'someattr'}
+      )
+
+    This functionality requires Python 3.7 or higher.
+
+    Parameters
+    ----------
+    module_name : str
+        Typically use __name__.
+    submodules : set
+        List of submodules to lazily import.
+    submod_attrs : dict
+        Dictionary of submodule -> list of attributes / functions.
+        These attributes are imported as they are used.
+
+    Returns
+    -------
+    __getattr__, __dir__, __all__
+
+    """
+    if submod_attrs is None:
+        submod_attrs = {}
+
+    if submodules is None:
+        submodules = set()
+    else:
+        submodules = set(submodules)
+
+    attr_to_modules = {
+        attr: mod for mod, attrs in submod_attrs.items() for attr in attrs
+    }
+
+    __all__ = list(submodules | attr_to_modules.keys())
+
+    def __getattr__(name):
+        if name in submodules:
+            return importlib.import_module(f"{module_name}.{name}")
+        elif name in attr_to_modules:
+            submod = importlib.import_module(f"{module_name}.{attr_to_modules[name]}")
+            return getattr(submod, name)
+        else:
+            raise AttributeError(f"No {module_name} attribute {name}")
+
+    def __dir__():
+        return __all__
+
+    if os.environ.get("EAGER_IMPORT", ""):
+        for attr in set(attr_to_modules.keys()) | submodules:
+            __getattr__(attr)
+
+    return __getattr__, __dir__, list(__all__)
+
+
+class DelayedImportErrorModule(types.ModuleType):
+    def __init__(self, frame_data, *args, **kwargs):
+        self.__frame_data = frame_data
+        super().__init__(*args, **kwargs)
+
+    def __getattr__(self, x):
+        if x in ("__class__", "__file__", "__frame_data"):
+            super().__getattr__(x)
+        else:
+            fd = self.__frame_data
+            raise ModuleNotFoundError(
+                f"No module named '{fd['spec']}'\n\n"
+                "This error is lazily reported, having originally occured in\n"
+                f'  File {fd["filename"]}, line {fd["lineno"]}, in {fd["function"]}\n\n'
+                f'----> {"".join(fd["code_context"]).strip()}'
+            )
+
+
+def _lazy_import(fullname):
+    """Return a lazily imported proxy for a module or library.
+
+    Warning
+    -------
+    Importing using this function can currently cause trouble
+    when the user tries to import from a subpackage of a module before
+    the package is fully imported. In particular, this idiom may not work:
+
+      np = lazy_import("numpy")
+      from numpy.lib import recfunctions
+
+    This is due to a difference in the way Python's LazyLoader handles
+    subpackage imports compared to the normal import process. Hopefully
+    we will get Python's LazyLoader to fix this, or find a workaround.
+    In the meantime, this is a potential problem.
+
+    The workaround is to import numpy before importing from the subpackage.
+
+    Notes
+    -----
+    We often see the following pattern::
+
+      def myfunc():
+          import scipy as sp
+          sp.argmin(...)
+          ....
+
+    This is to prevent a library, in this case `scipy`, from being
+    imported at function definition time, since that can be slow.
+
+    This function provides a proxy module that, upon access, imports
+    the actual module.  So the idiom equivalent to the above example is::
+
+      sp = lazy.load("scipy")
+
+      def myfunc():
+          sp.argmin(...)
+          ....
+
+    The initial import time is fast because the actual import is delayed
+    until the first attribute is requested. The overall import time may
+    decrease as well for users that don't make use of large portions
+    of the library.
+
+    Parameters
+    ----------
+    fullname : str
+        The full name of the package or subpackage to import.  For example::
+
+          sp = lazy.load('scipy')  # import scipy as sp
+          spla = lazy.load('scipy.linalg')  # import scipy.linalg as spla
+
+    Returns
+    -------
+    pm : importlib.util._LazyModule
+        Proxy module. Can be used like any regularly imported module.
+        Actual loading of the module occurs upon first attribute request.
+
+    """
+    try:
+        return sys.modules[fullname]
+    except:
+        pass
+
+    # Not previously loaded -- look it up
+    spec = importlib.util.find_spec(fullname)
+
+    if spec is None:
+        try:
+            parent = inspect.stack()[1]
+            frame_data = {
+                "spec": fullname,
+                "filename": parent.filename,
+                "lineno": parent.lineno,
+                "function": parent.function,
+                "code_context": parent.code_context,
+            }
+            return DelayedImportErrorModule(frame_data, "DelayedImportErrorModule")
+        finally:
+            del parent
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[fullname] = module
+
+    loader = importlib.util.LazyLoader(spec.loader)
+    loader.exec_module(module)
+
+    return module
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/__init__.py b/myenv/lib/python3.9/site-packages/networkx/linalg/__init__.py
new file mode 100644
index 0000000..119db18
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/__init__.py
@@ -0,0 +1,13 @@
+from networkx.linalg.attrmatrix import *
+from networkx.linalg import attrmatrix
+from networkx.linalg.spectrum import *
+from networkx.linalg import spectrum
+from networkx.linalg.graphmatrix import *
+from networkx.linalg import graphmatrix
+from networkx.linalg.laplacianmatrix import *
+from networkx.linalg import laplacianmatrix
+from networkx.linalg.algebraicconnectivity import *
+from networkx.linalg.modularitymatrix import *
+from networkx.linalg import modularitymatrix
+from networkx.linalg.bethehessianmatrix import *
+from networkx.linalg import bethehessianmatrix
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/algebraicconnectivity.py b/myenv/lib/python3.9/site-packages/networkx/linalg/algebraicconnectivity.py
new file mode 100644
index 0000000..9a7fe8c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/algebraicconnectivity.py
@@ -0,0 +1,562 @@
+"""
+Algebraic connectivity and Fiedler vectors of undirected graphs.
+"""
+from functools import partial
+
+import networkx as nx
+from networkx.utils import (
+    not_implemented_for,
+    np_random_state,
+    reverse_cuthill_mckee_ordering,
+)
+
+__all__ = ["algebraic_connectivity", "fiedler_vector", "spectral_ordering"]
+
+
+class _PCGSolver:
+    """Preconditioned conjugate gradient method.
+
+    To solve Ax = b:
+        M = A.diagonal() # or some other preconditioner
+        solver = _PCGSolver(lambda x: A * x, lambda x: M * x)
+        x = solver.solve(b)
+
+    The inputs A and M are functions which compute
+    matrix multiplication on the argument.
+    A - multiply by the matrix A in Ax=b
+    M - multiply by M, the preconditioner surrogate for A
+
+    Warning: There is no limit on number of iterations.
+    """
+
+    def __init__(self, A, M):
+        self._A = A
+        self._M = M
+
+    def solve(self, B, tol):
+        import numpy as np
+
+        # Densifying step - can this be kept sparse?
+        B = np.asarray(B)
+        X = np.ndarray(B.shape, order="F")
+        for j in range(B.shape[1]):
+            X[:, j] = self._solve(B[:, j], tol)
+        return X
+
+    def _solve(self, b, tol):
+        import numpy as np
+        import scipy as sp
+        import scipy.linalg.blas  # call as sp.linalg.blas
+
+        A = self._A
+        M = self._M
+        tol *= sp.linalg.blas.dasum(b)
+        # Initialize.
+        x = np.zeros(b.shape)
+        r = b.copy()
+        z = M(r)
+        rz = sp.linalg.blas.ddot(r, z)
+        p = z.copy()
+        # Iterate.
+        while True:
+            Ap = A(p)
+            alpha = rz / sp.linalg.blas.ddot(p, Ap)
+            x = sp.linalg.blas.daxpy(p, x, a=alpha)
+            r = sp.linalg.blas.daxpy(Ap, r, a=-alpha)
+            if sp.linalg.blas.dasum(r) < tol:
+                return x
+            z = M(r)
+            beta = sp.linalg.blas.ddot(r, z)
+            beta, rz = beta / rz, beta
+            p = sp.linalg.blas.daxpy(p, z, a=beta)
+
+
+class _LUSolver:
+    """LU factorization.
+
+    To solve Ax = b:
+        solver = _LUSolver(A)
+        x = solver.solve(b)
+
+    optional argument `tol` on solve method is ignored but included
+    to match _PCGsolver API.
+    """
+
+    def __init__(self, A):
+        import scipy as sp
+        import scipy.sparse.linalg  # call as sp.sparse.linalg
+
+        self._LU = sp.sparse.linalg.splu(
+            A,
+            permc_spec="MMD_AT_PLUS_A",
+            diag_pivot_thresh=0.0,
+            options={"Equil": True, "SymmetricMode": True},
+        )
+
+    def solve(self, B, tol=None):
+        import numpy as np
+
+        B = np.asarray(B)
+        X = np.ndarray(B.shape, order="F")
+        for j in range(B.shape[1]):
+            X[:, j] = self._LU.solve(B[:, j])
+        return X
+
+
+def _preprocess_graph(G, weight):
+    """Compute edge weights and eliminate zero-weight edges."""
+    if G.is_directed():
+        H = nx.MultiGraph()
+        H.add_nodes_from(G)
+        H.add_weighted_edges_from(
+            ((u, v, e.get(weight, 1.0)) for u, v, e in G.edges(data=True) if u != v),
+            weight=weight,
+        )
+        G = H
+    if not G.is_multigraph():
+        edges = (
+            (u, v, abs(e.get(weight, 1.0))) for u, v, e in G.edges(data=True) if u != v
+        )
+    else:
+        edges = (
+            (u, v, sum(abs(e.get(weight, 1.0)) for e in G[u][v].values()))
+            for u, v in G.edges()
+            if u != v
+        )
+    H = nx.Graph()
+    H.add_nodes_from(G)
+    H.add_weighted_edges_from((u, v, e) for u, v, e in edges if e != 0)
+    return H
+
+
+def _rcm_estimate(G, nodelist):
+    """Estimate the Fiedler vector using the reverse Cuthill-McKee ordering."""
+    import numpy as np
+
+    G = G.subgraph(nodelist)
+    order = reverse_cuthill_mckee_ordering(G)
+    n = len(nodelist)
+    index = dict(zip(nodelist, range(n)))
+    x = np.ndarray(n, dtype=float)
+    for i, u in enumerate(order):
+        x[index[u]] = i
+    x -= (n - 1) / 2.0
+    return x
+
+
+def _tracemin_fiedler(L, X, normalized, tol, method):
+    """Compute the Fiedler vector of L using the TraceMIN-Fiedler algorithm.
+
+    The Fiedler vector of a connected undirected graph is the eigenvector
+    corresponding to the second smallest eigenvalue of the Laplacian matrix
+    of the graph. This function starts with the Laplacian L, not the Graph.
+
+    Parameters
+    ----------
+    L : Laplacian of a possibly weighted or normalized, but undirected graph
+
+    X : Initial guess for a solution. Usually a matrix of random numbers.
+        This function allows more than one column in X to identify more than
+        one eigenvector if desired.
+
+    normalized : bool
+        Whether the normalized Laplacian matrix is used.
+
+    tol : float
+        Tolerance of relative residual in eigenvalue computation.
+        Warning: There is no limit on number of iterations.
+
+    method : string
+        Should be 'tracemin_pcg' or 'tracemin_lu'.
+        Otherwise exception is raised.
+
+    Returns
+    -------
+    sigma, X : Two NumPy arrays of floats.
+        The lowest eigenvalues and corresponding eigenvectors of L.
+        The size of input X determines the size of these outputs.
+        As this is for Fiedler vectors, the zero eigenvalue (and
+        constant eigenvector) are avoided.
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.linalg  # call as sp.linalg
+    import scipy.linalg.blas  # call as sp.linalg.blas
+    import scipy.sparse  # call as sp.sparse
+
+    n = X.shape[0]
+
+    if normalized:
+        # Form the normalized Laplacian matrix and determine the eigenvector of
+        # its nullspace.
+        e = np.sqrt(L.diagonal())
+        # TODO: rm csr_array wrapper when spdiags array creation becomes available
+        D = sp.sparse.csr_array(sp.sparse.spdiags(1 / e, 0, n, n, format="csr"))
+        L = D @ L @ D
+        e *= 1.0 / np.linalg.norm(e, 2)
+
+    if normalized:
+
+        def project(X):
+            """Make X orthogonal to the nullspace of L."""
+            X = np.asarray(X)
+            for j in range(X.shape[1]):
+                X[:, j] -= (X[:, j] @ e) * e
+
+    else:
+
+        def project(X):
+            """Make X orthogonal to the nullspace of L."""
+            X = np.asarray(X)
+            for j in range(X.shape[1]):
+                X[:, j] -= X[:, j].sum() / n
+
+    if method == "tracemin_pcg":
+        D = L.diagonal().astype(float)
+        solver = _PCGSolver(lambda x: L @ x, lambda x: D * x)
+    elif method == "tracemin_lu":
+        # Convert A to CSC to suppress SparseEfficiencyWarning.
+        A = sp.sparse.csc_array(L, dtype=float, copy=True)
+        # Force A to be nonsingular. Since A is the Laplacian matrix of a
+        # connected graph, its rank deficiency is one, and thus one diagonal
+        # element needs to modified. Changing to infinity forces a zero in the
+        # corresponding element in the solution.
+        i = (A.indptr[1:] - A.indptr[:-1]).argmax()
+        A[i, i] = float("inf")
+        solver = _LUSolver(A)
+    else:
+        raise nx.NetworkXError(f"Unknown linear system solver: {method}")
+
+    # Initialize.
+    Lnorm = abs(L).sum(axis=1).flatten().max()
+    project(X)
+    W = np.ndarray(X.shape, order="F")
+
+    while True:
+        # Orthonormalize X.
+        X = np.linalg.qr(X)[0]
+        # Compute iteration matrix H.
+        W[:, :] = L @ X
+        H = X.T @ W
+        sigma, Y = sp.linalg.eigh(H, overwrite_a=True)
+        # Compute the Ritz vectors.
+        X = X @ Y
+        # Test for convergence exploiting the fact that L * X == W * Y.
+        res = sp.linalg.blas.dasum(W @ Y[:, 0] - sigma[0] * X[:, 0]) / Lnorm
+        if res < tol:
+            break
+        # Compute X = L \ X / (X' * (L \ X)).
+        # L \ X can have an arbitrary projection on the nullspace of L,
+        # which will be eliminated.
+        W[:, :] = solver.solve(X, tol)
+        X = (sp.linalg.inv(W.T @ X) @ W.T).T  # Preserves Fortran storage order.
+        project(X)
+
+    return sigma, np.asarray(X)
+
+
+def _get_fiedler_func(method):
+    """Returns a function that solves the Fiedler eigenvalue problem."""
+    import numpy as np
+
+    if method == "tracemin":  # old style keyword <v2.1
+        method = "tracemin_pcg"
+    if method in ("tracemin_pcg", "tracemin_lu"):
+
+        def find_fiedler(L, x, normalized, tol, seed):
+            q = 1 if method == "tracemin_pcg" else min(4, L.shape[0] - 1)
+            X = np.asarray(seed.normal(size=(q, L.shape[0]))).T
+            sigma, X = _tracemin_fiedler(L, X, normalized, tol, method)
+            return sigma[0], X[:, 0]
+
+    elif method == "lanczos" or method == "lobpcg":
+
+        def find_fiedler(L, x, normalized, tol, seed):
+            import scipy as sp
+            import scipy.sparse  # call as sp.sparse
+            import scipy.sparse.linalg  # call as sp.sparse.linalg
+
+            L = sp.sparse.csc_array(L, dtype=float)
+            n = L.shape[0]
+            if normalized:
+                # TODO: rm csc_array wrapping when spdiags array becomes available
+                D = sp.sparse.csc_array(
+                    sp.sparse.spdiags(
+                        1.0 / np.sqrt(L.diagonal()), [0], n, n, format="csc"
+                    )
+                )
+                L = D @ L @ D
+            if method == "lanczos" or n < 10:
+                # Avoid LOBPCG when n < 10 due to
+                # https://github.com/scipy/scipy/issues/3592
+                # https://github.com/scipy/scipy/pull/3594
+                sigma, X = sp.sparse.linalg.eigsh(
+                    L, 2, which="SM", tol=tol, return_eigenvectors=True
+                )
+                return sigma[1], X[:, 1]
+            else:
+                X = np.asarray(np.atleast_2d(x).T)
+                # TODO: rm csr_array wrapping when spdiags array becomes available
+                M = sp.sparse.csr_array(sp.sparse.spdiags(1.0 / L.diagonal(), 0, n, n))
+                Y = np.ones(n)
+                if normalized:
+                    Y /= D.diagonal()
+                sigma, X = sp.sparse.linalg.lobpcg(
+                    L, X, M=M, Y=np.atleast_2d(Y).T, tol=tol, maxiter=n, largest=False
+                )
+                return sigma[0], X[:, 0]
+
+    else:
+        raise nx.NetworkXError(f"unknown method {method!r}.")
+
+    return find_fiedler
+
+
+@np_random_state(5)
+@not_implemented_for("directed")
+def algebraic_connectivity(
+    G, weight="weight", normalized=False, tol=1e-8, method="tracemin_pcg", seed=None
+):
+    """Returns the algebraic connectivity of an undirected graph.
+
+    The algebraic connectivity of a connected undirected graph is the second
+    smallest eigenvalue of its Laplacian matrix.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+
+    weight : object, optional (default: None)
+        The data key used to determine the weight of each edge. If None, then
+        each edge has unit weight.
+
+    normalized : bool, optional (default: False)
+        Whether the normalized Laplacian matrix is used.
+
+    tol : float, optional (default: 1e-8)
+        Tolerance of relative residual in eigenvalue computation.
+
+    method : string, optional (default: 'tracemin_pcg')
+        Method of eigenvalue computation. It must be one of the tracemin
+        options shown below (TraceMIN), 'lanczos' (Lanczos iteration)
+        or 'lobpcg' (LOBPCG).
+
+        The TraceMIN algorithm uses a linear system solver. The following
+        values allow specifying the solver to be used.
+
+        =============== ========================================
+        Value           Solver
+        =============== ========================================
+        'tracemin_pcg'  Preconditioned conjugate gradient method
+        'tracemin_lu'   LU factorization
+        =============== ========================================
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    algebraic_connectivity : float
+        Algebraic connectivity.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is directed.
+
+    NetworkXError
+        If G has less than two nodes.
+
+    Notes
+    -----
+    Edge weights are interpreted by their absolute values. For MultiGraph's,
+    weights of parallel edges are summed. Zero-weighted edges are ignored.
+
+    See Also
+    --------
+    laplacian_matrix
+    """
+    if len(G) < 2:
+        raise nx.NetworkXError("graph has less than two nodes.")
+    G = _preprocess_graph(G, weight)
+    if not nx.is_connected(G):
+        return 0.0
+
+    L = nx.laplacian_matrix(G)
+    if L.shape[0] == 2:
+        return 2.0 * L[0, 0] if not normalized else 2.0
+
+    find_fiedler = _get_fiedler_func(method)
+    x = None if method != "lobpcg" else _rcm_estimate(G, G)
+    sigma, fiedler = find_fiedler(L, x, normalized, tol, seed)
+    return sigma
+
+
+@np_random_state(5)
+@not_implemented_for("directed")
+def fiedler_vector(
+    G, weight="weight", normalized=False, tol=1e-8, method="tracemin_pcg", seed=None
+):
+    """Returns the Fiedler vector of a connected undirected graph.
+
+    The Fiedler vector of a connected undirected graph is the eigenvector
+    corresponding to the second smallest eigenvalue of the Laplacian matrix
+    of the graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected graph.
+
+    weight : object, optional (default: None)
+        The data key used to determine the weight of each edge. If None, then
+        each edge has unit weight.
+
+    normalized : bool, optional (default: False)
+        Whether the normalized Laplacian matrix is used.
+
+    tol : float, optional (default: 1e-8)
+        Tolerance of relative residual in eigenvalue computation.
+
+    method : string, optional (default: 'tracemin_pcg')
+        Method of eigenvalue computation. It must be one of the tracemin
+        options shown below (TraceMIN), 'lanczos' (Lanczos iteration)
+        or 'lobpcg' (LOBPCG).
+
+        The TraceMIN algorithm uses a linear system solver. The following
+        values allow specifying the solver to be used.
+
+        =============== ========================================
+        Value           Solver
+        =============== ========================================
+        'tracemin_pcg'  Preconditioned conjugate gradient method
+        'tracemin_lu'   LU factorization
+        =============== ========================================
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    fiedler_vector : NumPy array of floats.
+        Fiedler vector.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is directed.
+
+    NetworkXError
+        If G has less than two nodes or is not connected.
+
+    Notes
+    -----
+    Edge weights are interpreted by their absolute values. For MultiGraph's,
+    weights of parallel edges are summed. Zero-weighted edges are ignored.
+
+    See Also
+    --------
+    laplacian_matrix
+    """
+    import numpy as np
+
+    if len(G) < 2:
+        raise nx.NetworkXError("graph has less than two nodes.")
+    G = _preprocess_graph(G, weight)
+    if not nx.is_connected(G):
+        raise nx.NetworkXError("graph is not connected.")
+
+    if len(G) == 2:
+        return np.array([1.0, -1.0])
+
+    find_fiedler = _get_fiedler_func(method)
+    L = nx.laplacian_matrix(G)
+    x = None if method != "lobpcg" else _rcm_estimate(G, G)
+    sigma, fiedler = find_fiedler(L, x, normalized, tol, seed)
+    return fiedler
+
+
+@np_random_state(5)
+def spectral_ordering(
+    G, weight="weight", normalized=False, tol=1e-8, method="tracemin_pcg", seed=None
+):
+    """Compute the spectral_ordering of a graph.
+
+    The spectral ordering of a graph is an ordering of its nodes where nodes
+    in the same weakly connected components appear contiguous and ordered by
+    their corresponding elements in the Fiedler vector of the component.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A graph.
+
+    weight : object, optional (default: None)
+        The data key used to determine the weight of each edge. If None, then
+        each edge has unit weight.
+
+    normalized : bool, optional (default: False)
+        Whether the normalized Laplacian matrix is used.
+
+    tol : float, optional (default: 1e-8)
+        Tolerance of relative residual in eigenvalue computation.
+
+    method : string, optional (default: 'tracemin_pcg')
+        Method of eigenvalue computation. It must be one of the tracemin
+        options shown below (TraceMIN), 'lanczos' (Lanczos iteration)
+        or 'lobpcg' (LOBPCG).
+
+        The TraceMIN algorithm uses a linear system solver. The following
+        values allow specifying the solver to be used.
+
+        =============== ========================================
+        Value           Solver
+        =============== ========================================
+        'tracemin_pcg'  Preconditioned conjugate gradient method
+        'tracemin_lu'   LU factorization
+        =============== ========================================
+
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    spectral_ordering : NumPy array of floats.
+        Spectral ordering of nodes.
+
+    Raises
+    ------
+    NetworkXError
+        If G is empty.
+
+    Notes
+    -----
+    Edge weights are interpreted by their absolute values. For MultiGraph's,
+    weights of parallel edges are summed. Zero-weighted edges are ignored.
+
+    See Also
+    --------
+    laplacian_matrix
+    """
+    if len(G) == 0:
+        raise nx.NetworkXError("graph is empty.")
+    G = _preprocess_graph(G, weight)
+
+    find_fiedler = _get_fiedler_func(method)
+    order = []
+    for component in nx.connected_components(G):
+        size = len(component)
+        if size > 2:
+            L = nx.laplacian_matrix(G, component)
+            x = None if method != "lobpcg" else _rcm_estimate(G, component)
+            sigma, fiedler = find_fiedler(L, x, normalized, tol, seed)
+            sort_info = zip(fiedler, range(size), component)
+            order.extend(u for x, c, u in sorted(sort_info))
+        else:
+            order.extend(component)
+
+    return order
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/attrmatrix.py b/myenv/lib/python3.9/site-packages/networkx/linalg/attrmatrix.py
new file mode 100644
index 0000000..685d393
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/attrmatrix.py
@@ -0,0 +1,475 @@
+"""
+    Functions for constructing matrix-like objects from graph attributes.
+"""
+
+__all__ = ["attr_matrix", "attr_sparse_matrix"]
+
+
+def _node_value(G, node_attr):
+    """Returns a function that returns a value from G.nodes[u].
+
+    We return a function expecting a node as its sole argument. Then, in the
+    simplest scenario, the returned function will return G.nodes[u][node_attr].
+    However, we also handle the case when `node_attr` is None or when it is a
+    function itself.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph
+
+    node_attr : {None, str, callable}
+        Specification of how the value of the node attribute should be obtained
+        from the node attribute dictionary.
+
+    Returns
+    -------
+    value : function
+        A function expecting a node as its sole argument. The function will
+        returns a value from G.nodes[u] that depends on `edge_attr`.
+
+    """
+    if node_attr is None:
+
+        def value(u):
+            return u
+
+    elif not callable(node_attr):
+        # assume it is a key for the node attribute dictionary
+        def value(u):
+            return G.nodes[u][node_attr]
+
+    else:
+        # Advanced:  Allow users to specify something else.
+        #
+        # For example,
+        #     node_attr = lambda u: G.nodes[u].get('size', .5) * 3
+        #
+        value = node_attr
+
+    return value
+
+
+def _edge_value(G, edge_attr):
+    """Returns a function that returns a value from G[u][v].
+
+    Suppose there exists an edge between u and v.  Then we return a function
+    expecting u and v as arguments.  For Graph and DiGraph, G[u][v] is
+    the edge attribute dictionary, and the function (essentially) returns
+    G[u][v][edge_attr].  However, we also handle cases when `edge_attr` is None
+    and when it is a function itself. For MultiGraph and MultiDiGraph, G[u][v]
+    is a dictionary of all edges between u and v.  In this case, the returned
+    function sums the value of `edge_attr` for every edge between u and v.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    edge_attr : {None, str, callable}
+        Specification of how the value of the edge attribute should be obtained
+        from the edge attribute dictionary, G[u][v].  For multigraphs, G[u][v]
+        is a dictionary of all the edges between u and v.  This allows for
+        special treatment of multiedges.
+
+    Returns
+    -------
+    value : function
+        A function expecting two nodes as parameters. The nodes should
+        represent the from- and to- node of an edge. The function will
+        return a value from G[u][v] that depends on `edge_attr`.
+
+    """
+
+    if edge_attr is None:
+        # topological count of edges
+
+        if G.is_multigraph():
+
+            def value(u, v):
+                return len(G[u][v])
+
+        else:
+
+            def value(u, v):
+                return 1
+
+    elif not callable(edge_attr):
+        # assume it is a key for the edge attribute dictionary
+
+        if edge_attr == "weight":
+            # provide a default value
+            if G.is_multigraph():
+
+                def value(u, v):
+                    return sum(d.get(edge_attr, 1) for d in G[u][v].values())
+
+            else:
+
+                def value(u, v):
+                    return G[u][v].get(edge_attr, 1)
+
+        else:
+            # otherwise, the edge attribute MUST exist for each edge
+            if G.is_multigraph():
+
+                def value(u, v):
+                    return sum(d[edge_attr] for d in G[u][v].values())
+
+            else:
+
+                def value(u, v):
+                    return G[u][v][edge_attr]
+
+    else:
+        # Advanced:  Allow users to specify something else.
+        #
+        # Alternative default value:
+        #     edge_attr = lambda u,v: G[u][v].get('thickness', .5)
+        #
+        # Function on an attribute:
+        #     edge_attr = lambda u,v: abs(G[u][v]['weight'])
+        #
+        # Handle Multi(Di)Graphs differently:
+        #     edge_attr = lambda u,v: numpy.prod([d['size'] for d in G[u][v].values()])
+        #
+        # Ignore multiple edges
+        #     edge_attr = lambda u,v: 1 if len(G[u][v]) else 0
+        #
+        value = edge_attr
+
+    return value
+
+
+def attr_matrix(
+    G,
+    edge_attr=None,
+    node_attr=None,
+    normalized=False,
+    rc_order=None,
+    dtype=None,
+    order=None,
+):
+    """Returns a NumPy matrix using attributes from G.
+
+    If only `G` is passed in, then the adjacency matrix is constructed.
+
+    Let A be a discrete set of values for the node attribute `node_attr`. Then
+    the elements of A represent the rows and columns of the constructed matrix.
+    Now, iterate through every edge e=(u,v) in `G` and consider the value
+    of the edge attribute `edge_attr`.  If ua and va are the values of the
+    node attribute `node_attr` for u and v, respectively, then the value of
+    the edge attribute is added to the matrix element at (ua, va).
+
+    Parameters
+    ----------
+    G : graph
+        The NetworkX graph used to construct the NumPy matrix.
+
+    edge_attr : str, optional
+        Each element of the matrix represents a running total of the
+        specified edge attribute for edges whose node attributes correspond
+        to the rows/cols of the matirx. The attribute must be present for
+        all edges in the graph. If no attribute is specified, then we
+        just count the number of edges whose node attributes correspond
+        to the matrix element.
+
+    node_attr : str, optional
+        Each row and column in the matrix represents a particular value
+        of the node attribute.  The attribute must be present for all nodes
+        in the graph. Note, the values of this attribute should be reliably
+        hashable. So, float values are not recommended. If no attribute is
+        specified, then the rows and columns will be the nodes of the graph.
+
+    normalized : bool, optional
+        If True, then each row is normalized by the summation of its values.
+
+    rc_order : list, optional
+        A list of the node attribute values. This list specifies the ordering
+        of rows and columns of the array. If no ordering is provided, then
+        the ordering will be random (and also, a return value).
+
+    Other Parameters
+    ----------------
+    dtype : NumPy data-type, optional
+        A valid NumPy dtype used to initialize the array. Keep in mind certain
+        dtypes can yield unexpected results if the array is to be normalized.
+        The parameter is passed to numpy.zeros(). If unspecified, the NumPy
+        default is used.
+
+    order : {'C', 'F'}, optional
+        Whether to store multidimensional data in C- or Fortran-contiguous
+        (row- or column-wise) order in memory. This parameter is passed to
+        numpy.zeros(). If unspecified, the NumPy default is used.
+
+    Returns
+    -------
+    M : NumPy matrix
+        The attribute matrix.
+
+    ordering : list
+        If `rc_order` was specified, then only the matrix is returned.
+        However, if `rc_order` was None, then the ordering used to construct
+        the matrix is returned as well.
+
+    Examples
+    --------
+    Construct an adjacency matrix:
+
+    >>> G = nx.Graph()
+    >>> G.add_edge(0, 1, thickness=1, weight=3)
+    >>> G.add_edge(0, 2, thickness=2)
+    >>> G.add_edge(1, 2, thickness=3)
+    >>> nx.attr_matrix(G, rc_order=[0, 1, 2])
+    matrix([[0., 1., 1.],
+            [1., 0., 1.],
+            [1., 1., 0.]])
+
+    Alternatively, we can obtain the matrix describing edge thickness.
+
+    >>> nx.attr_matrix(G, edge_attr="thickness", rc_order=[0, 1, 2])
+    matrix([[0., 1., 2.],
+            [1., 0., 3.],
+            [2., 3., 0.]])
+
+    We can also color the nodes and ask for the probability distribution over
+    all edges (u,v) describing:
+
+        Pr(v has color Y | u has color X)
+
+    >>> G.nodes[0]["color"] = "red"
+    >>> G.nodes[1]["color"] = "red"
+    >>> G.nodes[2]["color"] = "blue"
+    >>> rc = ["red", "blue"]
+    >>> nx.attr_matrix(G, node_attr="color", normalized=True, rc_order=rc)
+    matrix([[0.33333333, 0.66666667],
+            [1.        , 0.        ]])
+
+    For example, the above tells us that for all edges (u,v):
+
+        Pr( v is red  | u is red)  = 1/3
+        Pr( v is blue | u is red)  = 2/3
+
+        Pr( v is red  | u is blue) = 1
+        Pr( v is blue | u is blue) = 0
+
+    Finally, we can obtain the total weights listed by the node colors.
+
+    >>> nx.attr_matrix(G, edge_attr="weight", node_attr="color", rc_order=rc)
+    matrix([[3., 2.],
+            [2., 0.]])
+
+    Thus, the total weight over all edges (u,v) with u and v having colors:
+
+        (red, red)   is 3   # the sole contribution is from edge (0,1)
+        (red, blue)  is 2   # contributions from edges (0,2) and (1,2)
+        (blue, red)  is 2   # same as (red, blue) since graph is undirected
+        (blue, blue) is 0   # there are no edges with blue endpoints
+
+    """
+    import numpy as np
+
+    edge_value = _edge_value(G, edge_attr)
+    node_value = _node_value(G, node_attr)
+
+    if rc_order is None:
+        ordering = list({node_value(n) for n in G})
+    else:
+        ordering = rc_order
+
+    N = len(ordering)
+    undirected = not G.is_directed()
+    index = dict(zip(ordering, range(N)))
+    M = np.zeros((N, N), dtype=dtype, order=order)
+
+    seen = set()
+    for u, nbrdict in G.adjacency():
+        for v in nbrdict:
+            # Obtain the node attribute values.
+            i, j = index[node_value(u)], index[node_value(v)]
+            if v not in seen:
+                M[i, j] += edge_value(u, v)
+                if undirected:
+                    M[j, i] = M[i, j]
+
+        if undirected:
+            seen.add(u)
+
+    if normalized:
+        M /= M.sum(axis=1).reshape((N, 1))
+
+    import warnings
+
+    warnings.warn(
+        (
+            "attr_matrix will return an numpy.ndarray instead of a numpy.matrix "
+            "in NetworkX 3.0."
+        ),
+        category=FutureWarning,
+        stacklevel=2,
+    )
+    # TODO: Remove asmatrix in NetworkX 3.0
+    M = np.asmatrix(M)
+
+    if rc_order is None:
+        return M, ordering
+    else:
+        return M
+
+
+def attr_sparse_matrix(
+    G, edge_attr=None, node_attr=None, normalized=False, rc_order=None, dtype=None
+):
+    """Returns a SciPy sparse matrix using attributes from G.
+
+    If only `G` is passed in, then the adjacency matrix is constructed.
+
+    Let A be a discrete set of values for the node attribute `node_attr`. Then
+    the elements of A represent the rows and columns of the constructed matrix.
+    Now, iterate through every edge e=(u,v) in `G` and consider the value
+    of the edge attribute `edge_attr`.  If ua and va are the values of the
+    node attribute `node_attr` for u and v, respectively, then the value of
+    the edge attribute is added to the matrix element at (ua, va).
+
+    Parameters
+    ----------
+    G : graph
+        The NetworkX graph used to construct the NumPy matrix.
+
+    edge_attr : str, optional
+        Each element of the matrix represents a running total of the
+        specified edge attribute for edges whose node attributes correspond
+        to the rows/cols of the matirx. The attribute must be present for
+        all edges in the graph. If no attribute is specified, then we
+        just count the number of edges whose node attributes correspond
+        to the matrix element.
+
+    node_attr : str, optional
+        Each row and column in the matrix represents a particular value
+        of the node attribute.  The attribute must be present for all nodes
+        in the graph. Note, the values of this attribute should be reliably
+        hashable. So, float values are not recommended. If no attribute is
+        specified, then the rows and columns will be the nodes of the graph.
+
+    normalized : bool, optional
+        If True, then each row is normalized by the summation of its values.
+
+    rc_order : list, optional
+        A list of the node attribute values. This list specifies the ordering
+        of rows and columns of the array. If no ordering is provided, then
+        the ordering will be random (and also, a return value).
+
+    Other Parameters
+    ----------------
+    dtype : NumPy data-type, optional
+        A valid NumPy dtype used to initialize the array. Keep in mind certain
+        dtypes can yield unexpected results if the array is to be normalized.
+        The parameter is passed to numpy.zeros(). If unspecified, the NumPy
+        default is used.
+
+    Returns
+    -------
+    M : SciPy sparse matrix
+        The attribute matrix.
+
+    ordering : list
+        If `rc_order` was specified, then only the matrix is returned.
+        However, if `rc_order` was None, then the ordering used to construct
+        the matrix is returned as well.
+
+    Examples
+    --------
+    Construct an adjacency matrix:
+
+    >>> G = nx.Graph()
+    >>> G.add_edge(0, 1, thickness=1, weight=3)
+    >>> G.add_edge(0, 2, thickness=2)
+    >>> G.add_edge(1, 2, thickness=3)
+    >>> M = nx.attr_sparse_matrix(G, rc_order=[0, 1, 2])
+    >>> M.toarray()
+    array([[0., 1., 1.],
+           [1., 0., 1.],
+           [1., 1., 0.]])
+
+    Alternatively, we can obtain the matrix describing edge thickness.
+
+    >>> M = nx.attr_sparse_matrix(G, edge_attr="thickness", rc_order=[0, 1, 2])
+    >>> M.toarray()
+    array([[0., 1., 2.],
+           [1., 0., 3.],
+           [2., 3., 0.]])
+
+    We can also color the nodes and ask for the probability distribution over
+    all edges (u,v) describing:
+
+        Pr(v has color Y | u has color X)
+
+    >>> G.nodes[0]["color"] = "red"
+    >>> G.nodes[1]["color"] = "red"
+    >>> G.nodes[2]["color"] = "blue"
+    >>> rc = ["red", "blue"]
+    >>> M = nx.attr_sparse_matrix(G, node_attr="color", normalized=True, rc_order=rc)
+    >>> M.toarray()
+    array([[0.33333333, 0.66666667],
+           [1.        , 0.        ]])
+
+    For example, the above tells us that for all edges (u,v):
+
+        Pr( v is red  | u is red)  = 1/3
+        Pr( v is blue | u is red)  = 2/3
+
+        Pr( v is red  | u is blue) = 1
+        Pr( v is blue | u is blue) = 0
+
+    Finally, we can obtain the total weights listed by the node colors.
+
+    >>> M = nx.attr_sparse_matrix(G, edge_attr="weight", node_attr="color", rc_order=rc)
+    >>> M.toarray()
+    array([[3., 2.],
+           [2., 0.]])
+
+    Thus, the total weight over all edges (u,v) with u and v having colors:
+
+        (red, red)   is 3   # the sole contribution is from edge (0,1)
+        (red, blue)  is 2   # contributions from edges (0,2) and (1,2)
+        (blue, red)  is 2   # same as (red, blue) since graph is undirected
+        (blue, blue) is 0   # there are no edges with blue endpoints
+
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    edge_value = _edge_value(G, edge_attr)
+    node_value = _node_value(G, node_attr)
+
+    if rc_order is None:
+        ordering = list({node_value(n) for n in G})
+    else:
+        ordering = rc_order
+
+    N = len(ordering)
+    undirected = not G.is_directed()
+    index = dict(zip(ordering, range(N)))
+    M = sp.sparse.lil_array((N, N), dtype=dtype)
+
+    seen = set()
+    for u, nbrdict in G.adjacency():
+        for v in nbrdict:
+            # Obtain the node attribute values.
+            i, j = index[node_value(u)], index[node_value(v)]
+            if v not in seen:
+                M[i, j] += edge_value(u, v)
+                if undirected:
+                    M[j, i] = M[i, j]
+
+        if undirected:
+            seen.add(u)
+
+    if normalized:
+        M *= 1 / M.sum(axis=1)[:, np.newaxis]  # in-place mult preserves sparse
+
+    if rc_order is None:
+        return M, ordering
+    else:
+        return M
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/bethehessianmatrix.py b/myenv/lib/python3.9/site-packages/networkx/linalg/bethehessianmatrix.py
new file mode 100644
index 0000000..c2595e4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/bethehessianmatrix.py
@@ -0,0 +1,86 @@
+"""Bethe Hessian or deformed Laplacian matrix of graphs."""
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["bethe_hessian_matrix"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def bethe_hessian_matrix(G, r=None, nodelist=None):
+    r"""Returns the Bethe Hessian matrix of G.
+
+    The Bethe Hessian is a family of matrices parametrized by r, defined as
+    H(r) = (r^2 - 1) I - r A + D where A is the adjacency matrix, D is the
+    diagonal matrix of node degrees, and I is the identify matrix. It is equal
+    to the graph laplacian when the regularizer r = 1.
+
+    The default choice of regularizer should be the ratio [2]_
+
+    .. math::
+      r_m = \left(\sum k_i \right)^{-1}\left(\sum k_i^2 \right) - 1
+
+    Parameters
+    ----------
+    G : Graph
+       A NetworkX graph
+    r : float
+       Regularizer parameter
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in nodelist.
+       If nodelist is None, then the ordering is produced by ``G.nodes()``.
+
+    Returns
+    -------
+    H : scipy.sparse.csr_matrix
+      The Bethe Hessian matrix of `G`, with parameter `r`.
+
+    Examples
+    --------
+    >>> k = [3, 2, 2, 1, 0]
+    >>> G = nx.havel_hakimi_graph(k)
+    >>> H = nx.bethe_hessian_matrix(G)
+    >>> H.toarray()
+    array([[ 3.5625, -1.25  , -1.25  , -1.25  ,  0.    ],
+           [-1.25  ,  2.5625, -1.25  ,  0.    ,  0.    ],
+           [-1.25  , -1.25  ,  2.5625,  0.    ,  0.    ],
+           [-1.25  ,  0.    ,  0.    ,  1.5625,  0.    ],
+           [ 0.    ,  0.    ,  0.    ,  0.    ,  0.5625]])
+
+    See Also
+    --------
+    bethe_hessian_spectrum
+    adjacency_matrix
+    laplacian_matrix
+
+    References
+    ----------
+    .. [1] A. Saade, F. Krzakala and L. Zdeborová
+       "Spectral Clustering of Graphs with the Bethe Hessian",
+       Advances in Neural Information Processing Systems, 2014.
+    .. [2] C. M. Le, E. Levina
+       "Estimating the number of communities in networks by spectral methods"
+       arXiv:1507.00827, 2015.
+    """
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    if nodelist is None:
+        nodelist = list(G)
+    if r is None:
+        r = sum(d**2 for v, d in nx.degree(G)) / sum(d for v, d in nx.degree(G)) - 1
+    A = nx.to_scipy_sparse_array(G, nodelist=nodelist, format="csr")
+    n, m = A.shape
+    # TODO: Rm csr_array wrapper when spdiags array creation becomes available
+    D = sp.sparse.csr_array(sp.sparse.spdiags(A.sum(axis=1), 0, m, n, format="csr"))
+    # TODO: Rm csr_array wrapper when eye array creation becomes available
+    I = sp.sparse.csr_array(sp.sparse.eye(m, n, format="csr"))
+    import warnings
+
+    warnings.warn(
+        "bethe_hessian_matrix will return a scipy.sparse array instead of a matrix in Networkx 3.0",
+        FutureWarning,
+        stacklevel=2,
+    )
+    # TODO: Remove the csr_matrix wrapper in NetworkX 3.0
+    return sp.sparse.csr_matrix((r**2 - 1) * I - r * A + D)
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/graphmatrix.py b/myenv/lib/python3.9/site-packages/networkx/linalg/graphmatrix.py
new file mode 100644
index 0000000..ad0d2e3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/graphmatrix.py
@@ -0,0 +1,190 @@
+"""
+Adjacency matrix and incidence matrix of graphs.
+"""
+import networkx as nx
+
+__all__ = ["incidence_matrix", "adj_matrix", "adjacency_matrix"]
+
+
+def incidence_matrix(G, nodelist=None, edgelist=None, oriented=False, weight=None):
+    """Returns incidence matrix of G.
+
+    The incidence matrix assigns each row to a node and each column to an edge.
+    For a standard incidence matrix a 1 appears wherever a row's node is
+    incident on the column's edge.  For an oriented incidence matrix each
+    edge is assigned an orientation (arbitrarily for undirected and aligning to
+    direction for directed).  A -1 appears for the source (tail) of an edge and
+    1 for the destination (head) of the edge.  The elements are zero otherwise.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    nodelist : list, optional   (default= all nodes in G)
+       The rows are ordered according to the nodes in nodelist.
+       If nodelist is None, then the ordering is produced by G.nodes().
+
+    edgelist : list, optional (default= all edges in G)
+       The columns are ordered according to the edges in edgelist.
+       If edgelist is None, then the ordering is produced by G.edges().
+
+    oriented: bool, optional (default=False)
+       If True, matrix elements are +1 or -1 for the head or tail node
+       respectively of each edge.  If False, +1 occurs at both nodes.
+
+    weight : string or None, optional (default=None)
+       The edge data key used to provide each value in the matrix.
+       If None, then each edge has weight 1.  Edge weights, if used,
+       should be positive so that the orientation can provide the sign.
+
+    Returns
+    -------
+    A : SciPy sparse matrix
+      The incidence matrix of G.
+
+    Notes
+    -----
+    For MultiGraph/MultiDiGraph, the edges in edgelist should be
+    (u,v,key) 3-tuples.
+
+    "Networks are the best discrete model for so many problems in
+    applied mathematics" [1]_.
+
+    References
+    ----------
+    .. [1] Gil Strang, Network applications: A = incidence matrix,
+       http://videolectures.net/mit18085f07_strang_lec03/
+    """
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    if nodelist is None:
+        nodelist = list(G)
+    if edgelist is None:
+        if G.is_multigraph():
+            edgelist = list(G.edges(keys=True))
+        else:
+            edgelist = list(G.edges())
+    A = sp.sparse.lil_array((len(nodelist), len(edgelist)))
+    node_index = {node: i for i, node in enumerate(nodelist)}
+    for ei, e in enumerate(edgelist):
+        (u, v) = e[:2]
+        if u == v:
+            continue  # self loops give zero column
+        try:
+            ui = node_index[u]
+            vi = node_index[v]
+        except KeyError as err:
+            raise nx.NetworkXError(
+                f"node {u} or {v} in edgelist but not in nodelist"
+            ) from err
+        if weight is None:
+            wt = 1
+        else:
+            if G.is_multigraph():
+                ekey = e[2]
+                wt = G[u][v][ekey].get(weight, 1)
+            else:
+                wt = G[u][v].get(weight, 1)
+        if oriented:
+            A[ui, ei] = -wt
+            A[vi, ei] = wt
+        else:
+            A[ui, ei] = wt
+            A[vi, ei] = wt
+    import warnings
+
+    warnings.warn(
+        "incidence_matrix will return a scipy.sparse array instead of a matrix in Networkx 3.0.",
+        FutureWarning,
+        stacklevel=2,
+    )
+    # TODO: Rm sp.sparse.csc_matrix in Networkx 3.0
+    return A.asformat("csc")
+
+
+def adjacency_matrix(G, nodelist=None, dtype=None, weight="weight"):
+    """Returns adjacency matrix of G.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in nodelist.
+       If nodelist is None, then the ordering is produced by G.nodes().
+
+    dtype : NumPy data-type, optional
+        The desired data-type for the array.
+        If None, then the NumPy default is used.
+
+    weight : string or None, optional (default='weight')
+       The edge data key used to provide each value in the matrix.
+       If None, then each edge has weight 1.
+
+    Returns
+    -------
+    A : SciPy sparse matrix
+      Adjacency matrix representation of G.
+
+    Notes
+    -----
+    For directed graphs, entry i,j corresponds to an edge from i to j.
+
+    If you want a pure Python adjacency matrix representation try
+    networkx.convert.to_dict_of_dicts which will return a
+    dictionary-of-dictionaries format that can be addressed as a
+    sparse matrix.
+
+    For MultiGraph/MultiDiGraph with parallel edges the weights are summed.
+    See `to_numpy_array` for other options.
+
+    The convention used for self-loop edges in graphs is to assign the
+    diagonal matrix entry value to the edge weight attribute
+    (or the number 1 if the edge has no weight attribute).  If the
+    alternate convention of doubling the edge weight is desired the
+    resulting Scipy sparse matrix can be modified as follows:
+
+    >>> G = nx.Graph([(1, 1)])
+    >>> A = nx.adjacency_matrix(G)
+    >>> print(A.todense())
+    [[1]]
+    >>> A.setdiag(A.diagonal() * 2)
+    >>> print(A.todense())
+    [[2]]
+
+    See Also
+    --------
+    to_numpy_array
+    to_scipy_sparse_array
+    to_dict_of_dicts
+    adjacency_spectrum
+    """
+    import warnings
+
+    warnings.warn(
+        "adjacency_matrix will return a scipy.sparse array instead of a matrix in Networkx 3.0.",
+        FutureWarning,
+        stacklevel=2,
+    )
+    # TODO: Change to `to_scipy_sparse_array` for networkx 3.0
+    return nx.to_scipy_sparse_matrix(G, nodelist=nodelist, dtype=dtype, weight=weight)
+
+
+def _adj_matrix_warning(G, nodelist=None, dtype=None, weight="weight"):
+    import warnings
+
+    warnings.warn(
+        (
+            "adj_matrix is deprecated and will be removed in version 3.0.\n"
+            "Use `adjacency_matrix` instead\n"
+        ),
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return adjacency_matrix(G, nodelist, dtype, weight)
+
+
+adj_matrix = _adj_matrix_warning
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/laplacianmatrix.py b/myenv/lib/python3.9/site-packages/networkx/linalg/laplacianmatrix.py
new file mode 100644
index 0000000..f1053b7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/laplacianmatrix.py
@@ -0,0 +1,448 @@
+"""Laplacian matrix of graphs.
+"""
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "laplacian_matrix",
+    "normalized_laplacian_matrix",
+    "total_spanning_tree_weight",
+    "directed_laplacian_matrix",
+    "directed_combinatorial_laplacian_matrix",
+]
+
+
+@not_implemented_for("directed")
+def laplacian_matrix(G, nodelist=None, weight="weight"):
+    """Returns the Laplacian matrix of G.
+
+    The graph Laplacian is the matrix L = D - A, where
+    A is the adjacency matrix and D is the diagonal matrix of node degrees.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in nodelist.
+       If nodelist is None, then the ordering is produced by G.nodes().
+
+    weight : string or None, optional (default='weight')
+       The edge data key used to compute each value in the matrix.
+       If None, then each edge has weight 1.
+
+    Returns
+    -------
+    L : SciPy sparse matrix
+      The Laplacian matrix of G.
+
+    Notes
+    -----
+    For MultiGraph, the edges weights are summed.
+
+    See Also
+    --------
+    to_numpy_array
+    normalized_laplacian_matrix
+    laplacian_spectrum
+    """
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    if nodelist is None:
+        nodelist = list(G)
+    A = nx.to_scipy_sparse_array(G, nodelist=nodelist, weight=weight, format="csr")
+    n, m = A.shape
+    # TODO: rm csr_array wrapper when spdiags can produce arrays
+    D = sp.sparse.csr_array(sp.sparse.spdiags(A.sum(axis=1), 0, m, n, format="csr"))
+    import warnings
+
+    warnings.warn(
+        "laplacian_matrix will return a scipy.sparse array instead of a matrix in Networkx 3.0.",
+        FutureWarning,
+        stacklevel=2,
+    )
+    # TODO: rm sp.sparse.csr_matrix in version 3.0
+    return sp.sparse.csr_matrix(D - A)
+
+
+@not_implemented_for("directed")
+def normalized_laplacian_matrix(G, nodelist=None, weight="weight"):
+    r"""Returns the normalized Laplacian matrix of G.
+
+    The normalized graph Laplacian is the matrix
+
+    .. math::
+
+        N = D^{-1/2} L D^{-1/2}
+
+    where `L` is the graph Laplacian and `D` is the diagonal matrix of
+    node degrees [1]_.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in nodelist.
+       If nodelist is None, then the ordering is produced by G.nodes().
+
+    weight : string or None, optional (default='weight')
+       The edge data key used to compute each value in the matrix.
+       If None, then each edge has weight 1.
+
+    Returns
+    -------
+    N : Scipy sparse matrix
+      The normalized Laplacian matrix of G.
+
+    Notes
+    -----
+    For MultiGraph, the edges weights are summed.
+    See :func:`to_numpy_array` for other options.
+
+    If the Graph contains selfloops, D is defined as ``diag(sum(A, 1))``, where A is
+    the adjacency matrix [2]_.
+
+    See Also
+    --------
+    laplacian_matrix
+    normalized_laplacian_spectrum
+
+    References
+    ----------
+    .. [1] Fan Chung-Graham, Spectral Graph Theory,
+       CBMS Regional Conference Series in Mathematics, Number 92, 1997.
+    .. [2] Steve Butler, Interlacing For Weighted Graphs Using The Normalized
+       Laplacian, Electronic Journal of Linear Algebra, Volume 16, pp. 90-98,
+       March 2007.
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    if nodelist is None:
+        nodelist = list(G)
+    A = nx.to_scipy_sparse_array(G, nodelist=nodelist, weight=weight, format="csr")
+    n, m = A.shape
+    diags = A.sum(axis=1)
+    # TODO: rm csr_array wrapper when spdiags can produce arrays
+    D = sp.sparse.csr_array(sp.sparse.spdiags(diags, 0, m, n, format="csr"))
+    L = D - A
+    with sp.errstate(divide="ignore"):
+        diags_sqrt = 1.0 / np.sqrt(diags)
+    diags_sqrt[np.isinf(diags_sqrt)] = 0
+    # TODO: rm csr_array wrapper when spdiags can produce arrays
+    DH = sp.sparse.csr_array(sp.sparse.spdiags(diags_sqrt, 0, m, n, format="csr"))
+    import warnings
+
+    warnings.warn(
+        "normalized_laplacian_matrix will return a scipy.sparse array instead of a matrix in Networkx 3.0.",
+        FutureWarning,
+        stacklevel=2,
+    )
+    # TODO: rm csr_matrix wrapper for NX 3.0
+    return sp.sparse.csr_matrix(DH @ (L @ DH))
+
+
+def total_spanning_tree_weight(G, weight=None):
+    """
+    Returns the total weight of all spanning trees of `G`.
+
+    Kirchoff's Tree Matrix Theorem states that the determinant of any cofactor of the
+    Laplacian matrix of a graph is the number of spanning trees in the graph. For a
+    weighted Laplacian matrix, it is the sum across all spanning trees of the
+    multiplicative weight of each tree. That is, the weight of each tree is the
+    product of its edge weights.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        The graph to use Kirchhoff's theorem on.
+
+    weight : string or None
+        The key for the edge attribute holding the edge weight. If `None`, then
+        each edge is assumed to have a weight of 1 and this function returns the
+        total number of spanning trees in `G`.
+
+    Returns
+    -------
+    float
+        The sum of the total multiplicative weights for all spanning trees in `G`
+    """
+    import numpy as np
+
+    G_laplacian = nx.laplacian_matrix(G, weight=weight).toarray()
+    # Determinant ignoring first row and column
+    return abs(np.linalg.det(G_laplacian[1:, 1:]))
+
+
+###############################################################################
+# Code based on work from https://github.com/bjedwards
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def directed_laplacian_matrix(
+    G, nodelist=None, weight="weight", walk_type=None, alpha=0.95
+):
+    r"""Returns the directed Laplacian matrix of G.
+
+    The graph directed Laplacian is the matrix
+
+    .. math::
+
+        L = I - (\Phi^{1/2} P \Phi^{-1/2} + \Phi^{-1/2} P^T \Phi^{1/2} ) / 2
+
+    where `I` is the identity matrix, `P` is the transition matrix of the
+    graph, and `\Phi` a matrix with the Perron vector of `P` in the diagonal and
+    zeros elsewhere [1]_.
+
+    Depending on the value of walk_type, `P` can be the transition matrix
+    induced by a random walk, a lazy random walk, or a random walk with
+    teleportation (PageRank).
+
+    Parameters
+    ----------
+    G : DiGraph
+       A NetworkX graph
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in nodelist.
+       If nodelist is None, then the ordering is produced by G.nodes().
+
+    weight : string or None, optional (default='weight')
+       The edge data key used to compute each value in the matrix.
+       If None, then each edge has weight 1.
+
+    walk_type : string or None, optional (default=None)
+       If None, `P` is selected depending on the properties of the
+       graph. Otherwise is one of 'random', 'lazy', or 'pagerank'
+
+    alpha : real
+       (1 - alpha) is the teleportation probability used with pagerank
+
+    Returns
+    -------
+    L : NumPy matrix
+      Normalized Laplacian of G.
+
+    Notes
+    -----
+    Only implemented for DiGraphs
+
+    See Also
+    --------
+    laplacian_matrix
+
+    References
+    ----------
+    .. [1] Fan Chung (2005).
+       Laplacians and the Cheeger inequality for directed graphs.
+       Annals of Combinatorics, 9(1), 2005
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+    import scipy.sparse.linalg  # call as sp.sparse.linalg
+
+    # NOTE: P has type ndarray if walk_type=="pagerank", else csr_array
+    P = _transition_matrix(
+        G, nodelist=nodelist, weight=weight, walk_type=walk_type, alpha=alpha
+    )
+
+    n, m = P.shape
+
+    evals, evecs = sp.sparse.linalg.eigs(P.T, k=1)
+    v = evecs.flatten().real
+    p = v / v.sum()
+    sqrtp = np.sqrt(p)
+    Q = (
+        # TODO: rm csr_array wrapper when spdiags creates arrays
+        sp.sparse.csr_array(sp.sparse.spdiags(sqrtp, 0, n, n))
+        @ P
+        # TODO: rm csr_array wrapper when spdiags creates arrays
+        @ sp.sparse.csr_array(sp.sparse.spdiags(1.0 / sqrtp, 0, n, n))
+    )
+    # NOTE: This could be sparsified for the non-pagerank cases
+    I = np.identity(len(G))
+
+    import warnings
+
+    warnings.warn(
+        "directed_laplacian_matrix will return a numpy array instead of a matrix in NetworkX 3.0",
+        FutureWarning,
+        stacklevel=2,
+    )
+    # TODO: rm np.asmatrix for networkx 3.0
+    return np.asmatrix(I - (Q + Q.T) / 2.0)
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def directed_combinatorial_laplacian_matrix(
+    G, nodelist=None, weight="weight", walk_type=None, alpha=0.95
+):
+    r"""Return the directed combinatorial Laplacian matrix of G.
+
+    The graph directed combinatorial Laplacian is the matrix
+
+    .. math::
+
+        L = \Phi - (\Phi P + P^T \Phi) / 2
+
+    where `P` is the transition matrix of the graph and `\Phi` a matrix
+    with the Perron vector of `P` in the diagonal and zeros elsewhere [1]_.
+
+    Depending on the value of walk_type, `P` can be the transition matrix
+    induced by a random walk, a lazy random walk, or a random walk with
+    teleportation (PageRank).
+
+    Parameters
+    ----------
+    G : DiGraph
+       A NetworkX graph
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in nodelist.
+       If nodelist is None, then the ordering is produced by G.nodes().
+
+    weight : string or None, optional (default='weight')
+       The edge data key used to compute each value in the matrix.
+       If None, then each edge has weight 1.
+
+    walk_type : string or None, optional (default=None)
+       If None, `P` is selected depending on the properties of the
+       graph. Otherwise is one of 'random', 'lazy', or 'pagerank'
+
+    alpha : real
+       (1 - alpha) is the teleportation probability used with pagerank
+
+    Returns
+    -------
+    L : NumPy matrix
+      Combinatorial Laplacian of G.
+
+    Notes
+    -----
+    Only implemented for DiGraphs
+
+    See Also
+    --------
+    laplacian_matrix
+
+    References
+    ----------
+    .. [1] Fan Chung (2005).
+       Laplacians and the Cheeger inequality for directed graphs.
+       Annals of Combinatorics, 9(1), 2005
+    """
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+    import scipy.sparse.linalg  # call as sp.sparse.linalg
+
+    P = _transition_matrix(
+        G, nodelist=nodelist, weight=weight, walk_type=walk_type, alpha=alpha
+    )
+
+    n, m = P.shape
+
+    evals, evecs = sp.sparse.linalg.eigs(P.T, k=1)
+    v = evecs.flatten().real
+    p = v / v.sum()
+    # NOTE: could be improved by not densifying
+    # TODO: Rm csr_array wrapper when spdiags array creation becomes available
+    Phi = sp.sparse.csr_array(sp.sparse.spdiags(p, 0, n, n)).toarray()
+
+    import warnings
+
+    warnings.warn(
+        "directed_combinatorial_laplacian_matrix will return a numpy array instead of a matrix in NetworkX 3.0",
+        FutureWarning,
+        stacklevel=2,
+    )
+    # TODO: Rm np.asmatrix for networkx 3.0
+    import numpy as np
+
+    return np.asmatrix(Phi - (Phi @ P + P.T @ Phi) / 2.0)
+
+
+def _transition_matrix(G, nodelist=None, weight="weight", walk_type=None, alpha=0.95):
+    """Returns the transition matrix of G.
+
+    This is a row stochastic giving the transition probabilities while
+    performing a random walk on the graph. Depending on the value of walk_type,
+    P can be the transition matrix induced by a random walk, a lazy random walk,
+    or a random walk with teleportation (PageRank).
+
+    Parameters
+    ----------
+    G : DiGraph
+       A NetworkX graph
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in nodelist.
+       If nodelist is None, then the ordering is produced by G.nodes().
+
+    weight : string or None, optional (default='weight')
+       The edge data key used to compute each value in the matrix.
+       If None, then each edge has weight 1.
+
+    walk_type : string or None, optional (default=None)
+       If None, `P` is selected depending on the properties of the
+       graph. Otherwise is one of 'random', 'lazy', or 'pagerank'
+
+    alpha : real
+       (1 - alpha) is the teleportation probability used with pagerank
+
+    Returns
+    -------
+    P : numpy.ndarray
+      transition matrix of G.
+
+    Raises
+    ------
+    NetworkXError
+        If walk_type not specified or alpha not in valid range
+    """
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse  # call as sp.sparse
+
+    if walk_type is None:
+        if nx.is_strongly_connected(G):
+            if nx.is_aperiodic(G):
+                walk_type = "random"
+            else:
+                walk_type = "lazy"
+        else:
+            walk_type = "pagerank"
+
+    A = nx.to_scipy_sparse_array(G, nodelist=nodelist, weight=weight, dtype=float)
+    n, m = A.shape
+    if walk_type in ["random", "lazy"]:
+        # TODO: Rm csr_array wrapper when spdiags array creation becomes available
+        DI = sp.sparse.csr_array(sp.sparse.spdiags(1.0 / A.sum(axis=1), 0, n, n))
+        if walk_type == "random":
+            P = DI @ A
+        else:
+            # TODO: Rm csr_array wrapper when identity array creation becomes available
+            I = sp.sparse.csr_array(sp.sparse.identity(n))
+            P = (I + DI @ A) / 2.0
+
+    elif walk_type == "pagerank":
+        if not (0 < alpha < 1):
+            raise nx.NetworkXError("alpha must be between 0 and 1")
+        # this is using a dense representation. NOTE: This should be sparsified!
+        A = A.toarray()
+        # add constant to dangling nodes' row
+        A[A.sum(axis=1) == 0, :] = 1 / n
+        # normalize
+        A = A / A.sum(axis=1)[np.newaxis, :].T
+        P = alpha * A + (1 - alpha) / n
+    else:
+        raise nx.NetworkXError("walk_type must be random, lazy, or pagerank")
+
+    return P
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/modularitymatrix.py b/myenv/lib/python3.9/site-packages/networkx/linalg/modularitymatrix.py
new file mode 100644
index 0000000..978d226
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/modularitymatrix.py
@@ -0,0 +1,180 @@
+"""Modularity matrix of graphs.
+"""
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = ["modularity_matrix", "directed_modularity_matrix"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def modularity_matrix(G, nodelist=None, weight=None):
+    r"""Returns the modularity matrix of G.
+
+    The modularity matrix is the matrix B = A - <A>, where A is the adjacency
+    matrix and <A> is the average adjacency matrix, assuming that the graph
+    is described by the configuration model.
+
+    More specifically, the element B_ij of B is defined as
+
+    .. math::
+        A_{ij} - {k_i k_j \over 2 m}
+
+    where k_i is the degree of node i, and where m is the number of edges
+    in the graph. When weight is set to a name of an attribute edge, Aij, k_i,
+    k_j and m are computed using its value.
+
+    Parameters
+    ----------
+    G : Graph
+       A NetworkX graph
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in nodelist.
+       If nodelist is None, then the ordering is produced by G.nodes().
+
+    weight : string or None, optional (default=None)
+       The edge attribute that holds the numerical value used for
+       the edge weight.  If None then all edge weights are 1.
+
+    Returns
+    -------
+    B : Numpy matrix
+      The modularity matrix of G.
+
+    Examples
+    --------
+    >>> k = [3, 2, 2, 1, 0]
+    >>> G = nx.havel_hakimi_graph(k)
+    >>> B = nx.modularity_matrix(G)
+
+
+    See Also
+    --------
+    to_numpy_array
+    modularity_spectrum
+    adjacency_matrix
+    directed_modularity_matrix
+
+    References
+    ----------
+    .. [1] M. E. J. Newman, "Modularity and community structure in networks",
+           Proc. Natl. Acad. Sci. USA, vol. 103, pp. 8577-8582, 2006.
+    """
+    import numpy as np
+
+    if nodelist is None:
+        nodelist = list(G)
+    A = nx.to_scipy_sparse_array(G, nodelist=nodelist, weight=weight, format="csr")
+    k = A.sum(axis=1)
+    m = k.sum() * 0.5
+    # Expected adjacency matrix
+    X = np.outer(k, k) / (2 * m)
+
+    import warnings
+
+    warnings.warn(
+        "modularity_matrix will return a numpy array instead of a matrix in NetworkX 3.0.",
+        FutureWarning,
+        stacklevel=2,
+    )
+    # TODO: rm np.asmatrix for networkx 3.0
+    return np.asmatrix(A - X)
+
+
+@not_implemented_for("undirected")
+@not_implemented_for("multigraph")
+def directed_modularity_matrix(G, nodelist=None, weight=None):
+    """Returns the directed modularity matrix of G.
+
+    The modularity matrix is the matrix B = A - <A>, where A is the adjacency
+    matrix and <A> is the expected adjacency matrix, assuming that the graph
+    is described by the configuration model.
+
+    More specifically, the element B_ij of B is defined as
+
+    .. math::
+        B_{ij} = A_{ij} - k_i^{out} k_j^{in} / m
+
+    where :math:`k_i^{in}` is the in degree of node i, and :math:`k_j^{out}` is the out degree
+    of node j, with m the number of edges in the graph. When weight is set
+    to a name of an attribute edge, Aij, k_i, k_j and m are computed using
+    its value.
+
+    Parameters
+    ----------
+    G : DiGraph
+       A NetworkX DiGraph
+
+    nodelist : list, optional
+       The rows and columns are ordered according to the nodes in nodelist.
+       If nodelist is None, then the ordering is produced by G.nodes().
+
+    weight : string or None, optional (default=None)
+       The edge attribute that holds the numerical value used for
+       the edge weight.  If None then all edge weights are 1.
+
+    Returns
+    -------
+    B : Numpy matrix
+      The modularity matrix of G.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_edges_from(
+    ...     (
+    ...         (1, 2),
+    ...         (1, 3),
+    ...         (3, 1),
+    ...         (3, 2),
+    ...         (3, 5),
+    ...         (4, 5),
+    ...         (4, 6),
+    ...         (5, 4),
+    ...         (5, 6),
+    ...         (6, 4),
+    ...     )
+    ... )
+    >>> B = nx.directed_modularity_matrix(G)
+
+
+    Notes
+    -----
+    NetworkX defines the element A_ij of the adjacency matrix as 1 if there
+    is a link going from node i to node j. Leicht and Newman use the opposite
+    definition. This explains the different expression for B_ij.
+
+    See Also
+    --------
+    to_numpy_array
+    modularity_spectrum
+    adjacency_matrix
+    modularity_matrix
+
+    References
+    ----------
+    .. [1] E. A. Leicht, M. E. J. Newman,
+        "Community structure in directed networks",
+        Phys. Rev Lett., vol. 100, no. 11, p. 118703, 2008.
+    """
+    import numpy as np
+
+    if nodelist is None:
+        nodelist = list(G)
+    A = nx.to_scipy_sparse_array(G, nodelist=nodelist, weight=weight, format="csr")
+    k_in = A.sum(axis=0)
+    k_out = A.sum(axis=1)
+    m = k_in.sum()
+    # Expected adjacency matrix
+    X = np.outer(k_out, k_in) / m
+
+    import warnings
+
+    warnings.warn(
+        "directed_modularity_matrix will return a numpy array instead of a matrix in NetworkX 3.0.",
+        FutureWarning,
+        stacklevel=2,
+    )
+    # TODO: rm np.asmatrix for networkx 3.0
+    return np.asmatrix(A - X)
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/spectrum.py b/myenv/lib/python3.9/site-packages/networkx/linalg/spectrum.py
new file mode 100644
index 0000000..caa95fc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/spectrum.py
@@ -0,0 +1,173 @@
+"""
+Eigenvalue spectrum of graphs.
+"""
+import networkx as nx
+
+__all__ = [
+    "laplacian_spectrum",
+    "adjacency_spectrum",
+    "modularity_spectrum",
+    "normalized_laplacian_spectrum",
+    "bethe_hessian_spectrum",
+]
+
+
+def laplacian_spectrum(G, weight="weight"):
+    """Returns eigenvalues of the Laplacian of G
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    weight : string or None, optional (default='weight')
+       The edge data key used to compute each value in the matrix.
+       If None, then each edge has weight 1.
+
+    Returns
+    -------
+    evals : NumPy array
+      Eigenvalues
+
+    Notes
+    -----
+    For MultiGraph/MultiDiGraph, the edges weights are summed.
+    See to_numpy_array for other options.
+
+    See Also
+    --------
+    laplacian_matrix
+    """
+    import scipy as sp
+    import scipy.linalg  # call as sp.linalg
+
+    return sp.linalg.eigvalsh(nx.laplacian_matrix(G, weight=weight).todense())
+
+
+def normalized_laplacian_spectrum(G, weight="weight"):
+    """Return eigenvalues of the normalized Laplacian of G
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    weight : string or None, optional (default='weight')
+       The edge data key used to compute each value in the matrix.
+       If None, then each edge has weight 1.
+
+    Returns
+    -------
+    evals : NumPy array
+      Eigenvalues
+
+    Notes
+    -----
+    For MultiGraph/MultiDiGraph, the edges weights are summed.
+    See to_numpy_array for other options.
+
+    See Also
+    --------
+    normalized_laplacian_matrix
+    """
+    import scipy as sp
+    import scipy.linalg  # call as sp.linalg
+
+    return sp.linalg.eigvalsh(
+        nx.normalized_laplacian_matrix(G, weight=weight).todense()
+    )
+
+
+def adjacency_spectrum(G, weight="weight"):
+    """Returns eigenvalues of the adjacency matrix of G.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    weight : string or None, optional (default='weight')
+       The edge data key used to compute each value in the matrix.
+       If None, then each edge has weight 1.
+
+    Returns
+    -------
+    evals : NumPy array
+      Eigenvalues
+
+    Notes
+    -----
+    For MultiGraph/MultiDiGraph, the edges weights are summed.
+    See to_numpy_array for other options.
+
+    See Also
+    --------
+    adjacency_matrix
+    """
+    import scipy as sp
+    import scipy.linalg  # call as sp.linalg
+
+    return sp.linalg.eigvals(nx.adjacency_matrix(G, weight=weight).todense())
+
+
+def modularity_spectrum(G):
+    """Returns eigenvalues of the modularity matrix of G.
+
+    Parameters
+    ----------
+    G : Graph
+       A NetworkX Graph or DiGraph
+
+    Returns
+    -------
+    evals : NumPy array
+      Eigenvalues
+
+    See Also
+    --------
+    modularity_matrix
+
+    References
+    ----------
+    .. [1] M. E. J. Newman, "Modularity and community structure in networks",
+       Proc. Natl. Acad. Sci. USA, vol. 103, pp. 8577-8582, 2006.
+    """
+    import scipy as sp
+    import scipy.linalg  # call as sp.linalg
+
+    if G.is_directed():
+        return sp.linalg.eigvals(nx.directed_modularity_matrix(G))
+    else:
+        return sp.linalg.eigvals(nx.modularity_matrix(G))
+
+
+def bethe_hessian_spectrum(G, r=None):
+    """Returns eigenvalues of the Bethe Hessian matrix of G.
+
+    Parameters
+    ----------
+    G : Graph
+       A NetworkX Graph or DiGraph
+
+    r : float
+       Regularizer parameter
+
+    Returns
+    -------
+    evals : NumPy array
+      Eigenvalues
+
+    See Also
+    --------
+    bethe_hessian_matrix
+
+    References
+    ----------
+    .. [1] A. Saade, F. Krzakala and L. Zdeborová
+       "Spectral clustering of graphs with the bethe hessian",
+       Advances in Neural Information Processing Systems. 2014.
+    """
+    import scipy as sp
+    import scipy.linalg  # call as sp.linalg
+
+    return sp.linalg.eigvalsh(nx.bethe_hessian_matrix(G, r).todense())
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_algebraic_connectivity.py b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_algebraic_connectivity.py
new file mode 100644
index 0000000..7a86bd0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_algebraic_connectivity.py
@@ -0,0 +1,387 @@
+from math import sqrt
+
+import pytest
+
+np = pytest.importorskip("numpy")
+
+
+import networkx as nx
+
+methods = ("tracemin_pcg", "tracemin_lu", "lanczos", "lobpcg")
+
+
+def test_algebraic_connectivity_tracemin_chol():
+    """Test that "tracemin_chol" raises an exception."""
+    pytest.importorskip("scipy")
+    G = nx.barbell_graph(5, 4)
+    with pytest.raises(nx.NetworkXError):
+        nx.algebraic_connectivity(G, method="tracemin_chol")
+
+
+def test_fiedler_vector_tracemin_chol():
+    """Test that "tracemin_chol" raises an exception."""
+    pytest.importorskip("scipy")
+    G = nx.barbell_graph(5, 4)
+    with pytest.raises(nx.NetworkXError):
+        nx.fiedler_vector(G, method="tracemin_chol")
+
+
+def test_spectral_ordering_tracemin_chol():
+    """Test that "tracemin_chol" raises an exception."""
+    pytest.importorskip("scipy")
+    G = nx.barbell_graph(5, 4)
+    with pytest.raises(nx.NetworkXError):
+        nx.spectral_ordering(G, method="tracemin_chol")
+
+
+def test_fiedler_vector_tracemin_unknown():
+    """Test that "tracemin_unknown" raises an exception."""
+    pytest.importorskip("scipy")
+    G = nx.barbell_graph(5, 4)
+    L = nx.laplacian_matrix(G)
+    X = np.asarray(np.random.normal(size=(1, L.shape[0]))).T
+    with pytest.raises(nx.NetworkXError, match="Unknown linear system solver"):
+        nx.linalg.algebraicconnectivity._tracemin_fiedler(
+            L, X, normalized=False, tol=1e-8, method="tracemin_unknown"
+        )
+
+
+def check_eigenvector(A, l, x):
+    nx = np.linalg.norm(x)
+    # Check zeroness.
+    assert not nx == pytest.approx(0, abs=1e-7)
+    y = A @ x
+    ny = np.linalg.norm(y)
+    # Check collinearity.
+    assert x @ y == pytest.approx(nx * ny, abs=1e-7)
+    # Check eigenvalue.
+    assert ny == pytest.approx(l * nx, abs=1e-7)
+
+
+class TestAlgebraicConnectivity:
+    @pytest.mark.parametrize("method", methods)
+    def test_directed(self, method):
+        G = nx.DiGraph()
+        pytest.raises(
+            nx.NetworkXNotImplemented, nx.algebraic_connectivity, G, method=method
+        )
+        pytest.raises(nx.NetworkXNotImplemented, nx.fiedler_vector, G, method=method)
+
+    @pytest.mark.parametrize("method", methods)
+    def test_null_and_singleton(self, method):
+        G = nx.Graph()
+        pytest.raises(nx.NetworkXError, nx.algebraic_connectivity, G, method=method)
+        pytest.raises(nx.NetworkXError, nx.fiedler_vector, G, method=method)
+        G.add_edge(0, 0)
+        pytest.raises(nx.NetworkXError, nx.algebraic_connectivity, G, method=method)
+        pytest.raises(nx.NetworkXError, nx.fiedler_vector, G, method=method)
+
+    @pytest.mark.parametrize("method", methods)
+    def test_disconnected(self, method):
+        G = nx.Graph()
+        G.add_nodes_from(range(2))
+        assert nx.algebraic_connectivity(G) == 0
+        pytest.raises(nx.NetworkXError, nx.fiedler_vector, G, method=method)
+        G.add_edge(0, 1, weight=0)
+        assert nx.algebraic_connectivity(G) == 0
+        pytest.raises(nx.NetworkXError, nx.fiedler_vector, G, method=method)
+
+    def test_unrecognized_method(self):
+        pytest.importorskip("scipy")
+        G = nx.path_graph(4)
+        pytest.raises(nx.NetworkXError, nx.algebraic_connectivity, G, method="unknown")
+        pytest.raises(nx.NetworkXError, nx.fiedler_vector, G, method="unknown")
+
+    @pytest.mark.parametrize("method", methods)
+    def test_two_nodes(self, method):
+        pytest.importorskip("scipy")
+        G = nx.Graph()
+        G.add_edge(0, 1, weight=1)
+        A = nx.laplacian_matrix(G)
+        assert nx.algebraic_connectivity(G, tol=1e-12, method=method) == pytest.approx(
+            2, abs=1e-7
+        )
+        x = nx.fiedler_vector(G, tol=1e-12, method=method)
+        check_eigenvector(A, 2, x)
+
+    @pytest.mark.parametrize("method", methods)
+    def test_two_nodes_multigraph(self, method):
+        pytest.importorskip("scipy")
+        G = nx.MultiGraph()
+        G.add_edge(0, 0, spam=1e8)
+        G.add_edge(0, 1, spam=1)
+        G.add_edge(0, 1, spam=-2)
+        A = -3 * nx.laplacian_matrix(G, weight="spam")
+        assert nx.algebraic_connectivity(
+            G, weight="spam", tol=1e-12, method=method
+        ) == pytest.approx(6, abs=1e-7)
+        x = nx.fiedler_vector(G, weight="spam", tol=1e-12, method=method)
+        check_eigenvector(A, 6, x)
+
+    def test_abbreviation_of_method(self):
+        pytest.importorskip("scipy")
+        G = nx.path_graph(8)
+        A = nx.laplacian_matrix(G)
+        sigma = 2 - sqrt(2 + sqrt(2))
+        ac = nx.algebraic_connectivity(G, tol=1e-12, method="tracemin")
+        assert ac == pytest.approx(sigma, abs=1e-7)
+        x = nx.fiedler_vector(G, tol=1e-12, method="tracemin")
+        check_eigenvector(A, sigma, x)
+
+    @pytest.mark.parametrize("method", methods)
+    def test_path(self, method):
+        pytest.importorskip("scipy")
+        G = nx.path_graph(8)
+        A = nx.laplacian_matrix(G)
+        sigma = 2 - sqrt(2 + sqrt(2))
+        ac = nx.algebraic_connectivity(G, tol=1e-12, method=method)
+        assert ac == pytest.approx(sigma, abs=1e-7)
+        x = nx.fiedler_vector(G, tol=1e-12, method=method)
+        check_eigenvector(A, sigma, x)
+
+    @pytest.mark.parametrize("method", methods)
+    def test_problematic_graph_issue_2381(self, method):
+        pytest.importorskip("scipy")
+        G = nx.path_graph(4)
+        G.add_edges_from([(4, 2), (5, 1)])
+        A = nx.laplacian_matrix(G)
+        sigma = 0.438447187191
+        ac = nx.algebraic_connectivity(G, tol=1e-12, method=method)
+        assert ac == pytest.approx(sigma, abs=1e-7)
+        x = nx.fiedler_vector(G, tol=1e-12, method=method)
+        check_eigenvector(A, sigma, x)
+
+    @pytest.mark.parametrize("method", methods)
+    def test_cycle(self, method):
+        pytest.importorskip("scipy")
+        G = nx.cycle_graph(8)
+        A = nx.laplacian_matrix(G)
+        sigma = 2 - sqrt(2)
+        ac = nx.algebraic_connectivity(G, tol=1e-12, method=method)
+        assert ac == pytest.approx(sigma, abs=1e-7)
+        x = nx.fiedler_vector(G, tol=1e-12, method=method)
+        check_eigenvector(A, sigma, x)
+
+    @pytest.mark.parametrize("method", methods)
+    def test_seed_argument(self, method):
+        pytest.importorskip("scipy")
+        G = nx.cycle_graph(8)
+        A = nx.laplacian_matrix(G)
+        sigma = 2 - sqrt(2)
+        ac = nx.algebraic_connectivity(G, tol=1e-12, method=method, seed=1)
+        assert ac == pytest.approx(sigma, abs=1e-7)
+        x = nx.fiedler_vector(G, tol=1e-12, method=method, seed=1)
+        check_eigenvector(A, sigma, x)
+
+    @pytest.mark.parametrize(
+        ("normalized", "sigma", "laplacian_fn"),
+        (
+            (False, 0.2434017461399311, nx.laplacian_matrix),
+            (True, 0.08113391537997749, nx.normalized_laplacian_matrix),
+        ),
+    )
+    @pytest.mark.parametrize("method", methods)
+    def test_buckminsterfullerene(self, normalized, sigma, laplacian_fn, method):
+        pytest.importorskip("scipy")
+        G = nx.Graph(
+            [
+                (1, 10),
+                (1, 41),
+                (1, 59),
+                (2, 12),
+                (2, 42),
+                (2, 60),
+                (3, 6),
+                (3, 43),
+                (3, 57),
+                (4, 8),
+                (4, 44),
+                (4, 58),
+                (5, 13),
+                (5, 56),
+                (5, 57),
+                (6, 10),
+                (6, 31),
+                (7, 14),
+                (7, 56),
+                (7, 58),
+                (8, 12),
+                (8, 32),
+                (9, 23),
+                (9, 53),
+                (9, 59),
+                (10, 15),
+                (11, 24),
+                (11, 53),
+                (11, 60),
+                (12, 16),
+                (13, 14),
+                (13, 25),
+                (14, 26),
+                (15, 27),
+                (15, 49),
+                (16, 28),
+                (16, 50),
+                (17, 18),
+                (17, 19),
+                (17, 54),
+                (18, 20),
+                (18, 55),
+                (19, 23),
+                (19, 41),
+                (20, 24),
+                (20, 42),
+                (21, 31),
+                (21, 33),
+                (21, 57),
+                (22, 32),
+                (22, 34),
+                (22, 58),
+                (23, 24),
+                (25, 35),
+                (25, 43),
+                (26, 36),
+                (26, 44),
+                (27, 51),
+                (27, 59),
+                (28, 52),
+                (28, 60),
+                (29, 33),
+                (29, 34),
+                (29, 56),
+                (30, 51),
+                (30, 52),
+                (30, 53),
+                (31, 47),
+                (32, 48),
+                (33, 45),
+                (34, 46),
+                (35, 36),
+                (35, 37),
+                (36, 38),
+                (37, 39),
+                (37, 49),
+                (38, 40),
+                (38, 50),
+                (39, 40),
+                (39, 51),
+                (40, 52),
+                (41, 47),
+                (42, 48),
+                (43, 49),
+                (44, 50),
+                (45, 46),
+                (45, 54),
+                (46, 55),
+                (47, 54),
+                (48, 55),
+            ]
+        )
+        A = laplacian_fn(G)
+        try:
+            assert nx.algebraic_connectivity(
+                G, normalized=normalized, tol=1e-12, method=method
+            ) == pytest.approx(sigma, abs=1e-7)
+            x = nx.fiedler_vector(G, normalized=normalized, tol=1e-12, method=method)
+            check_eigenvector(A, sigma, x)
+        except nx.NetworkXError as err:
+            if err.args not in (
+                ("Cholesky solver unavailable.",),
+                ("LU solver unavailable.",),
+            ):
+                raise
+
+
+class TestSpectralOrdering:
+    _graphs = (nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph)
+
+    @pytest.mark.parametrize("graph", _graphs)
+    def test_nullgraph(self, graph):
+        G = graph()
+        pytest.raises(nx.NetworkXError, nx.spectral_ordering, G)
+
+    @pytest.mark.parametrize("graph", _graphs)
+    def test_singleton(self, graph):
+        G = graph()
+        G.add_node("x")
+        assert nx.spectral_ordering(G) == ["x"]
+        G.add_edge("x", "x", weight=33)
+        G.add_edge("x", "x", weight=33)
+        assert nx.spectral_ordering(G) == ["x"]
+
+    def test_unrecognized_method(self):
+        G = nx.path_graph(4)
+        pytest.raises(nx.NetworkXError, nx.spectral_ordering, G, method="unknown")
+
+    @pytest.mark.parametrize("method", methods)
+    def test_three_nodes(self, method):
+        pytest.importorskip("scipy")
+        G = nx.Graph()
+        G.add_weighted_edges_from([(1, 2, 1), (1, 3, 2), (2, 3, 1)], weight="spam")
+        order = nx.spectral_ordering(G, weight="spam", method=method)
+        assert set(order) == set(G)
+        assert {1, 3} in (set(order[:-1]), set(order[1:]))
+
+    @pytest.mark.parametrize("method", methods)
+    def test_three_nodes_multigraph(self, method):
+        pytest.importorskip("scipy")
+        G = nx.MultiDiGraph()
+        G.add_weighted_edges_from([(1, 2, 1), (1, 3, 2), (2, 3, 1), (2, 3, 2)])
+        order = nx.spectral_ordering(G, method=method)
+        assert set(order) == set(G)
+        assert {2, 3} in (set(order[:-1]), set(order[1:]))
+
+    @pytest.mark.parametrize("method", methods)
+    def test_path(self, method):
+        pytest.importorskip("scipy")
+        path = list(range(10))
+        np.random.shuffle(path)
+        G = nx.Graph()
+        nx.add_path(G, path)
+        order = nx.spectral_ordering(G, method=method)
+        assert order in [path, list(reversed(path))]
+
+    @pytest.mark.parametrize("method", methods)
+    def test_seed_argument(self, method):
+        pytest.importorskip("scipy")
+        path = list(range(10))
+        np.random.shuffle(path)
+        G = nx.Graph()
+        nx.add_path(G, path)
+        order = nx.spectral_ordering(G, method=method, seed=1)
+        assert order in [path, list(reversed(path))]
+
+    @pytest.mark.parametrize("method", methods)
+    def test_disconnected(self, method):
+        pytest.importorskip("scipy")
+        G = nx.Graph()
+        nx.add_path(G, range(0, 10, 2))
+        nx.add_path(G, range(1, 10, 2))
+        order = nx.spectral_ordering(G, method=method)
+        assert set(order) == set(G)
+        seqs = [
+            list(range(0, 10, 2)),
+            list(range(8, -1, -2)),
+            list(range(1, 10, 2)),
+            list(range(9, -1, -2)),
+        ]
+        assert order[:5] in seqs
+        assert order[5:] in seqs
+
+    @pytest.mark.parametrize(
+        ("normalized", "expected_order"),
+        (
+            (False, [[1, 2, 0, 3, 4, 5, 6, 9, 7, 8], [8, 7, 9, 6, 5, 4, 3, 0, 2, 1]]),
+            (True, [[1, 2, 3, 0, 4, 5, 9, 6, 7, 8], [8, 7, 6, 9, 5, 4, 0, 3, 2, 1]]),
+        ),
+    )
+    @pytest.mark.parametrize("method", methods)
+    def test_cycle(self, normalized, expected_order, method):
+        pytest.importorskip("scipy")
+        path = list(range(10))
+        G = nx.Graph()
+        nx.add_path(G, path, weight=5)
+        G.add_edge(path[-1], path[0], weight=1)
+        A = nx.laplacian_matrix(G).todense()
+        order = nx.spectral_ordering(G, normalized=normalized, method=method)
+        assert order in expected_order
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_attrmatrix.py b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_attrmatrix.py
new file mode 100644
index 0000000..01574bb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_attrmatrix.py
@@ -0,0 +1,108 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+
+import networkx as nx
+
+
+def test_attr_matrix():
+    G = nx.Graph()
+    G.add_edge(0, 1, thickness=1, weight=3)
+    G.add_edge(0, 1, thickness=1, weight=3)
+    G.add_edge(0, 2, thickness=2)
+    G.add_edge(1, 2, thickness=3)
+
+    def node_attr(u):
+        return G.nodes[u].get("size", 0.5) * 3
+
+    def edge_attr(u, v):
+        return G[u][v].get("thickness", 0.5)
+
+    M = nx.attr_matrix(G, edge_attr=edge_attr, node_attr=node_attr)
+    np.testing.assert_equal(M[0], np.array([[6.0]]))
+    assert M[1] == [1.5]
+
+
+def test_attr_matrix_directed():
+    G = nx.DiGraph()
+    G.add_edge(0, 1, thickness=1, weight=3)
+    G.add_edge(0, 1, thickness=1, weight=3)
+    G.add_edge(0, 2, thickness=2)
+    G.add_edge(1, 2, thickness=3)
+    M = nx.attr_matrix(G, rc_order=[0, 1, 2])
+    # fmt: off
+    data = np.array(
+        [[0., 1., 1.],
+         [0., 0., 1.],
+         [0., 0., 0.]]
+    )
+    # fmt: on
+    np.testing.assert_equal(M, np.array(data))
+
+
+def test_attr_matrix_multigraph():
+    G = nx.MultiGraph()
+    G.add_edge(0, 1, thickness=1, weight=3)
+    G.add_edge(0, 1, thickness=1, weight=3)
+    G.add_edge(0, 1, thickness=1, weight=3)
+    G.add_edge(0, 2, thickness=2)
+    G.add_edge(1, 2, thickness=3)
+    M = nx.attr_matrix(G, rc_order=[0, 1, 2])
+    # fmt: off
+    data = np.array(
+        [[0., 3., 1.],
+         [3., 0., 1.],
+         [1., 1., 0.]]
+    )
+    # fmt: on
+    np.testing.assert_equal(M, np.array(data))
+    M = nx.attr_matrix(G, edge_attr="weight", rc_order=[0, 1, 2])
+    # fmt: off
+    data = np.array(
+        [[0., 9., 1.],
+         [9., 0., 1.],
+         [1., 1., 0.]]
+    )
+    # fmt: on
+    np.testing.assert_equal(M, np.array(data))
+    M = nx.attr_matrix(G, edge_attr="thickness", rc_order=[0, 1, 2])
+    # fmt: off
+    data = np.array(
+        [[0., 3., 2.],
+         [3., 0., 3.],
+         [2., 3., 0.]]
+    )
+    # fmt: on
+    np.testing.assert_equal(M, np.array(data))
+
+
+def test_attr_sparse_matrix():
+    pytest.importorskip("scipy")
+    G = nx.Graph()
+    G.add_edge(0, 1, thickness=1, weight=3)
+    G.add_edge(0, 2, thickness=2)
+    G.add_edge(1, 2, thickness=3)
+    M = nx.attr_sparse_matrix(G)
+    mtx = M[0]
+    data = np.ones((3, 3), float)
+    np.fill_diagonal(data, 0)
+    np.testing.assert_equal(mtx.todense(), np.array(data))
+    assert M[1] == [0, 1, 2]
+
+
+def test_attr_sparse_matrix_directed():
+    pytest.importorskip("scipy")
+    G = nx.DiGraph()
+    G.add_edge(0, 1, thickness=1, weight=3)
+    G.add_edge(0, 1, thickness=1, weight=3)
+    G.add_edge(0, 2, thickness=2)
+    G.add_edge(1, 2, thickness=3)
+    M = nx.attr_sparse_matrix(G, rc_order=[0, 1, 2])
+    # fmt: off
+    data = np.array(
+        [[0., 1., 1.],
+         [0., 0., 1.],
+         [0., 0., 0.]]
+    )
+    # fmt: on
+    np.testing.assert_equal(M.todense(), np.array(data))
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_bethehessian.py b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_bethehessian.py
new file mode 100644
index 0000000..339fe1b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_bethehessian.py
@@ -0,0 +1,41 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+from networkx.generators.degree_seq import havel_hakimi_graph
+
+
+class TestBetheHessian:
+    @classmethod
+    def setup_class(cls):
+        deg = [3, 2, 2, 1, 0]
+        cls.G = havel_hakimi_graph(deg)
+        cls.P = nx.path_graph(3)
+
+    def test_bethe_hessian(self):
+        "Bethe Hessian matrix"
+        # fmt: off
+        H = np.array([[4, -2, 0],
+                      [-2, 5, -2],
+                      [0, -2, 4]])
+        # fmt: on
+        permutation = [2, 0, 1]
+        # Bethe Hessian gives expected form
+        np.testing.assert_equal(nx.bethe_hessian_matrix(self.P, r=2).todense(), H)
+        # nodelist is correctly implemented
+        np.testing.assert_equal(
+            nx.bethe_hessian_matrix(self.P, r=2, nodelist=permutation).todense(),
+            H[np.ix_(permutation, permutation)],
+        )
+        # Equal to Laplacian matrix when r=1
+        np.testing.assert_equal(
+            nx.bethe_hessian_matrix(self.G, r=1).todense(),
+            nx.laplacian_matrix(self.G).todense(),
+        )
+        # Correct default for the regularizer r
+        np.testing.assert_equal(
+            nx.bethe_hessian_matrix(self.G).todense(),
+            nx.bethe_hessian_matrix(self.G, r=1.25).todense(),
+        )
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_graphmatrix.py b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_graphmatrix.py
new file mode 100644
index 0000000..cb1587e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_graphmatrix.py
@@ -0,0 +1,297 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+from networkx.exception import NetworkXError
+from networkx.generators.degree_seq import havel_hakimi_graph
+
+
+def test_incidence_matrix_simple():
+    deg = [3, 2, 2, 1, 0]
+    G = havel_hakimi_graph(deg)
+    deg = [(1, 0), (1, 0), (1, 0), (2, 0), (1, 0), (2, 1), (0, 1), (0, 1)]
+    MG = nx.random_clustered_graph(deg, seed=42)
+
+    I = nx.incidence_matrix(G).todense().astype(int)
+    # fmt: off
+    expected = np.array(
+        [[1, 1, 1, 0],
+         [0, 1, 0, 1],
+         [1, 0, 0, 1],
+         [0, 0, 1, 0],
+         [0, 0, 0, 0]]
+    )
+    # fmt: on
+    np.testing.assert_equal(I, expected)
+
+    I = nx.incidence_matrix(MG).todense().astype(int)
+    # fmt: off
+    expected = np.array(
+        [[1, 0, 0, 0, 0, 0, 0],
+         [1, 0, 0, 0, 0, 0, 0],
+         [0, 1, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0],
+         [0, 1, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 1, 1, 0],
+         [0, 0, 0, 0, 0, 1, 1],
+         [0, 0, 0, 0, 1, 0, 1]]
+    )
+    # fmt: on
+    np.testing.assert_equal(I, expected)
+
+    with pytest.raises(NetworkXError):
+        nx.incidence_matrix(G, nodelist=[0, 1])
+
+
+class TestGraphMatrix:
+    @classmethod
+    def setup_class(cls):
+        deg = [3, 2, 2, 1, 0]
+        cls.G = havel_hakimi_graph(deg)
+        # fmt: off
+        cls.OI = np.array(
+            [[-1, -1, -1, 0],
+             [1, 0, 0, -1],
+             [0, 1, 0, 1],
+             [0, 0, 1, 0],
+             [0, 0, 0, 0]]
+        )
+        cls.A = np.array(
+            [[0, 1, 1, 1, 0],
+             [1, 0, 1, 0, 0],
+             [1, 1, 0, 0, 0],
+             [1, 0, 0, 0, 0],
+             [0, 0, 0, 0, 0]]
+        )
+        # fmt: on
+        cls.WG = havel_hakimi_graph(deg)
+        cls.WG.add_edges_from(
+            (u, v, {"weight": 0.5, "other": 0.3}) for (u, v) in cls.G.edges()
+        )
+        # fmt: off
+        cls.WA = np.array(
+            [[0, 0.5, 0.5, 0.5, 0],
+             [0.5, 0, 0.5, 0, 0],
+             [0.5, 0.5, 0, 0, 0],
+             [0.5, 0, 0, 0, 0],
+             [0, 0, 0, 0, 0]]
+        )
+        # fmt: on
+        cls.MG = nx.MultiGraph(cls.G)
+        cls.MG2 = cls.MG.copy()
+        cls.MG2.add_edge(0, 1)
+        # fmt: off
+        cls.MG2A = np.array(
+            [[0, 2, 1, 1, 0],
+             [2, 0, 1, 0, 0],
+             [1, 1, 0, 0, 0],
+             [1, 0, 0, 0, 0],
+             [0, 0, 0, 0, 0]]
+        )
+        cls.MGOI = np.array(
+            [[-1, -1, -1, -1, 0],
+             [1, 1, 0, 0, -1],
+             [0, 0, 1, 0, 1],
+             [0, 0, 0, 1, 0],
+             [0, 0, 0, 0, 0]]
+        )
+        # fmt: on
+        cls.no_edges_G = nx.Graph([(1, 2), (3, 2, {"weight": 8})])
+        cls.no_edges_A = np.array([[0, 0], [0, 0]])
+
+    def test_incidence_matrix(self):
+        "Conversion to incidence matrix"
+        I = (
+            nx.incidence_matrix(
+                self.G,
+                nodelist=sorted(self.G),
+                edgelist=sorted(self.G.edges()),
+                oriented=True,
+            )
+            .todense()
+            .astype(int)
+        )
+        np.testing.assert_equal(I, self.OI)
+
+        I = (
+            nx.incidence_matrix(
+                self.G,
+                nodelist=sorted(self.G),
+                edgelist=sorted(self.G.edges()),
+                oriented=False,
+            )
+            .todense()
+            .astype(int)
+        )
+        np.testing.assert_equal(I, np.abs(self.OI))
+
+        I = (
+            nx.incidence_matrix(
+                self.MG,
+                nodelist=sorted(self.MG),
+                edgelist=sorted(self.MG.edges()),
+                oriented=True,
+            )
+            .todense()
+            .astype(int)
+        )
+        np.testing.assert_equal(I, self.OI)
+
+        I = (
+            nx.incidence_matrix(
+                self.MG,
+                nodelist=sorted(self.MG),
+                edgelist=sorted(self.MG.edges()),
+                oriented=False,
+            )
+            .todense()
+            .astype(int)
+        )
+        np.testing.assert_equal(I, np.abs(self.OI))
+
+        I = (
+            nx.incidence_matrix(
+                self.MG2,
+                nodelist=sorted(self.MG2),
+                edgelist=sorted(self.MG2.edges()),
+                oriented=True,
+            )
+            .todense()
+            .astype(int)
+        )
+        np.testing.assert_equal(I, self.MGOI)
+
+        I = (
+            nx.incidence_matrix(
+                self.MG2,
+                nodelist=sorted(self.MG),
+                edgelist=sorted(self.MG2.edges()),
+                oriented=False,
+            )
+            .todense()
+            .astype(int)
+        )
+        np.testing.assert_equal(I, np.abs(self.MGOI))
+
+    def test_weighted_incidence_matrix(self):
+        I = (
+            nx.incidence_matrix(
+                self.WG,
+                nodelist=sorted(self.WG),
+                edgelist=sorted(self.WG.edges()),
+                oriented=True,
+            )
+            .todense()
+            .astype(int)
+        )
+        np.testing.assert_equal(I, self.OI)
+
+        I = (
+            nx.incidence_matrix(
+                self.WG,
+                nodelist=sorted(self.WG),
+                edgelist=sorted(self.WG.edges()),
+                oriented=False,
+            )
+            .todense()
+            .astype(int)
+        )
+        np.testing.assert_equal(I, np.abs(self.OI))
+
+        # np.testing.assert_equal(nx.incidence_matrix(self.WG,oriented=True,
+        #                                  weight='weight').todense(),0.5*self.OI)
+        # np.testing.assert_equal(nx.incidence_matrix(self.WG,weight='weight').todense(),
+        #              np.abs(0.5*self.OI))
+        # np.testing.assert_equal(nx.incidence_matrix(self.WG,oriented=True,weight='other').todense(),
+        #              0.3*self.OI)
+
+        I = nx.incidence_matrix(
+            self.WG,
+            nodelist=sorted(self.WG),
+            edgelist=sorted(self.WG.edges()),
+            oriented=True,
+            weight="weight",
+        ).todense()
+        np.testing.assert_equal(I, 0.5 * self.OI)
+
+        I = nx.incidence_matrix(
+            self.WG,
+            nodelist=sorted(self.WG),
+            edgelist=sorted(self.WG.edges()),
+            oriented=False,
+            weight="weight",
+        ).todense()
+        np.testing.assert_equal(I, np.abs(0.5 * self.OI))
+
+        I = nx.incidence_matrix(
+            self.WG,
+            nodelist=sorted(self.WG),
+            edgelist=sorted(self.WG.edges()),
+            oriented=True,
+            weight="other",
+        ).todense()
+        np.testing.assert_equal(I, 0.3 * self.OI)
+
+        # WMG=nx.MultiGraph(self.WG)
+        # WMG.add_edge(0,1,weight=0.5,other=0.3)
+        # np.testing.assert_equal(nx.incidence_matrix(WMG,weight='weight').todense(),
+        #              np.abs(0.5*self.MGOI))
+        # np.testing.assert_equal(nx.incidence_matrix(WMG,weight='weight',oriented=True).todense(),
+        #              0.5*self.MGOI)
+        # np.testing.assert_equal(nx.incidence_matrix(WMG,weight='other',oriented=True).todense(),
+        #              0.3*self.MGOI)
+
+        WMG = nx.MultiGraph(self.WG)
+        WMG.add_edge(0, 1, weight=0.5, other=0.3)
+
+        I = nx.incidence_matrix(
+            WMG,
+            nodelist=sorted(WMG),
+            edgelist=sorted(WMG.edges(keys=True)),
+            oriented=True,
+            weight="weight",
+        ).todense()
+        np.testing.assert_equal(I, 0.5 * self.MGOI)
+
+        I = nx.incidence_matrix(
+            WMG,
+            nodelist=sorted(WMG),
+            edgelist=sorted(WMG.edges(keys=True)),
+            oriented=False,
+            weight="weight",
+        ).todense()
+        np.testing.assert_equal(I, np.abs(0.5 * self.MGOI))
+
+        I = nx.incidence_matrix(
+            WMG,
+            nodelist=sorted(WMG),
+            edgelist=sorted(WMG.edges(keys=True)),
+            oriented=True,
+            weight="other",
+        ).todense()
+        np.testing.assert_equal(I, 0.3 * self.MGOI)
+
+    def test_adjacency_matrix(self):
+        "Conversion to adjacency matrix"
+        np.testing.assert_equal(nx.adjacency_matrix(self.G).todense(), self.A)
+        np.testing.assert_equal(nx.adjacency_matrix(self.MG).todense(), self.A)
+        np.testing.assert_equal(nx.adjacency_matrix(self.MG2).todense(), self.MG2A)
+        np.testing.assert_equal(
+            nx.adjacency_matrix(self.G, nodelist=[0, 1]).todense(), self.A[:2, :2]
+        )
+        np.testing.assert_equal(nx.adjacency_matrix(self.WG).todense(), self.WA)
+        np.testing.assert_equal(
+            nx.adjacency_matrix(self.WG, weight=None).todense(), self.A
+        )
+        np.testing.assert_equal(
+            nx.adjacency_matrix(self.MG2, weight=None).todense(), self.MG2A
+        )
+        np.testing.assert_equal(
+            nx.adjacency_matrix(self.WG, weight="other").todense(), 0.6 * self.WA
+        )
+        np.testing.assert_equal(
+            nx.adjacency_matrix(self.no_edges_G, nodelist=[1, 3]).todense(),
+            self.no_edges_A,
+        )
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_laplacian.py b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_laplacian.py
new file mode 100644
index 0000000..78cddac
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_laplacian.py
@@ -0,0 +1,242 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+from networkx.generators.degree_seq import havel_hakimi_graph
+from networkx.generators.expanders import margulis_gabber_galil_graph
+
+
+class TestLaplacian:
+    @classmethod
+    def setup_class(cls):
+        deg = [3, 2, 2, 1, 0]
+        cls.G = havel_hakimi_graph(deg)
+        cls.WG = nx.Graph(
+            (u, v, {"weight": 0.5, "other": 0.3}) for (u, v) in cls.G.edges()
+        )
+        cls.WG.add_node(4)
+        cls.MG = nx.MultiGraph(cls.G)
+
+        # Graph with clsloops
+        cls.Gsl = cls.G.copy()
+        for node in cls.Gsl.nodes():
+            cls.Gsl.add_edge(node, node)
+
+    def test_laplacian(self):
+        "Graph Laplacian"
+        # fmt: off
+        NL = np.array([[ 3, -1, -1, -1,  0],
+                       [-1,  2, -1,  0,  0],
+                       [-1, -1,  2,  0,  0],
+                       [-1,  0,  0,  1,  0],
+                       [ 0,  0,  0,  0,  0]])
+        # fmt: on
+        WL = 0.5 * NL
+        OL = 0.3 * NL
+        np.testing.assert_equal(nx.laplacian_matrix(self.G).todense(), NL)
+        np.testing.assert_equal(nx.laplacian_matrix(self.MG).todense(), NL)
+        np.testing.assert_equal(
+            nx.laplacian_matrix(self.G, nodelist=[0, 1]).todense(),
+            np.array([[1, -1], [-1, 1]]),
+        )
+        np.testing.assert_equal(nx.laplacian_matrix(self.WG).todense(), WL)
+        np.testing.assert_equal(nx.laplacian_matrix(self.WG, weight=None).todense(), NL)
+        np.testing.assert_equal(
+            nx.laplacian_matrix(self.WG, weight="other").todense(), OL
+        )
+
+    def test_normalized_laplacian(self):
+        "Generalized Graph Laplacian"
+        # fmt: off
+        G = np.array([[ 1.   , -0.408, -0.408, -0.577,  0.],
+                      [-0.408,  1.   , -0.5  ,  0.   ,  0.],
+                      [-0.408, -0.5  ,  1.   ,  0.   ,  0.],
+                      [-0.577,  0.   ,  0.   ,  1.   ,  0.],
+                      [ 0.   ,  0.   ,  0.   ,  0.   ,  0.]])
+        GL = np.array([[ 1.   , -0.408, -0.408, -0.577,  0.   ],
+                       [-0.408,  1.   , -0.5  ,  0.   ,  0.   ],
+                       [-0.408, -0.5  ,  1.   ,  0.   ,  0.   ],
+                       [-0.577,  0.   ,  0.   ,  1.   ,  0.   ],
+                       [ 0.   ,  0.   ,  0.   ,  0.   ,  0.   ]])
+        Lsl = np.array([[ 0.75  , -0.2887, -0.2887, -0.3536,  0.    ],
+                        [-0.2887,  0.6667, -0.3333,  0.    ,  0.    ],
+                        [-0.2887, -0.3333,  0.6667,  0.    ,  0.    ],
+                        [-0.3536,  0.    ,  0.    ,  0.5   ,  0.    ],
+                        [ 0.    ,  0.    ,  0.    ,  0.    ,  0.    ]])
+        # fmt: on
+
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(self.G, nodelist=range(5)).todense(),
+            G,
+            decimal=3,
+        )
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(self.G).todense(), GL, decimal=3
+        )
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(self.MG).todense(), GL, decimal=3
+        )
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(self.WG).todense(), GL, decimal=3
+        )
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(self.WG, weight="other").todense(),
+            GL,
+            decimal=3,
+        )
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(self.Gsl).todense(), Lsl, decimal=3
+        )
+
+
+def test_directed_laplacian():
+    "Directed Laplacian"
+    # Graph used as an example in Sec. 4.1 of Langville and Meyer,
+    # "Google's PageRank and Beyond". The graph contains dangling nodes, so
+    # the pagerank random walk is selected by directed_laplacian
+    G = nx.DiGraph()
+    G.add_edges_from(
+        (
+            (1, 2),
+            (1, 3),
+            (3, 1),
+            (3, 2),
+            (3, 5),
+            (4, 5),
+            (4, 6),
+            (5, 4),
+            (5, 6),
+            (6, 4),
+        )
+    )
+    # fmt: off
+    GL = np.array([[ 0.9833, -0.2941, -0.3882, -0.0291, -0.0231, -0.0261],
+                   [-0.2941,  0.8333, -0.2339, -0.0536, -0.0589, -0.0554],
+                   [-0.3882, -0.2339,  0.9833, -0.0278, -0.0896, -0.0251],
+                   [-0.0291, -0.0536, -0.0278,  0.9833, -0.4878, -0.6675],
+                   [-0.0231, -0.0589, -0.0896, -0.4878,  0.9833, -0.2078],
+                   [-0.0261, -0.0554, -0.0251, -0.6675, -0.2078,  0.9833]])
+    # fmt: on
+    L = nx.directed_laplacian_matrix(G, alpha=0.9, nodelist=sorted(G))
+    np.testing.assert_almost_equal(L, GL, decimal=3)
+
+    # Make the graph strongly connected, so we can use a random and lazy walk
+    G.add_edges_from(((2, 5), (6, 1)))
+    # fmt: off
+    GL = np.array([[ 1.    , -0.3062, -0.4714,  0.    ,  0.    , -0.3227],
+                   [-0.3062,  1.    , -0.1443,  0.    , -0.3162,  0.    ],
+                   [-0.4714, -0.1443,  1.    ,  0.    , -0.0913,  0.    ],
+                   [ 0.    ,  0.    ,  0.    ,  1.    , -0.5   , -0.5   ],
+                   [ 0.    , -0.3162, -0.0913, -0.5   ,  1.    , -0.25  ],
+                   [-0.3227,  0.    ,  0.    , -0.5   , -0.25  ,  1.    ]])
+    # fmt: on
+    L = nx.directed_laplacian_matrix(
+        G, alpha=0.9, nodelist=sorted(G), walk_type="random"
+    )
+    np.testing.assert_almost_equal(L, GL, decimal=3)
+
+    # fmt: off
+    GL = np.array([[ 0.5   , -0.1531, -0.2357,  0.    ,  0.    , -0.1614],
+                   [-0.1531,  0.5   , -0.0722,  0.    , -0.1581,  0.    ],
+                   [-0.2357, -0.0722,  0.5   ,  0.    , -0.0456,  0.    ],
+                   [ 0.    ,  0.    ,  0.    ,  0.5   , -0.25  , -0.25  ],
+                   [ 0.    , -0.1581, -0.0456, -0.25  ,  0.5   , -0.125 ],
+                   [-0.1614,  0.    ,  0.    , -0.25  , -0.125 ,  0.5   ]])  
+    # fmt: on
+    L = nx.directed_laplacian_matrix(G, alpha=0.9, nodelist=sorted(G), walk_type="lazy")
+    np.testing.assert_almost_equal(L, GL, decimal=3)
+
+    # Make a strongly connected periodic graph
+    G = nx.DiGraph()
+    G.add_edges_from(((1, 2), (2, 4), (4, 1), (1, 3), (3, 4)))
+    # fmt: off
+    GL = np.array([[ 0.5  , -0.176, -0.176, -0.25 ],
+                   [-0.176,  0.5  ,  0.   , -0.176],
+                   [-0.176,  0.   ,  0.5  , -0.176],
+                   [-0.25 , -0.176, -0.176,  0.5  ]])
+    # fmt: on
+    L = nx.directed_laplacian_matrix(G, alpha=0.9, nodelist=sorted(G))
+    np.testing.assert_almost_equal(L, GL, decimal=3)
+
+
+def test_directed_combinatorial_laplacian():
+    "Directed combinatorial Laplacian"
+    # Graph used as an example in Sec. 4.1 of Langville and Meyer,
+    # "Google's PageRank and Beyond". The graph contains dangling nodes, so
+    # the pagerank random walk is selected by directed_laplacian
+    G = nx.DiGraph()
+    G.add_edges_from(
+        (
+            (1, 2),
+            (1, 3),
+            (3, 1),
+            (3, 2),
+            (3, 5),
+            (4, 5),
+            (4, 6),
+            (5, 4),
+            (5, 6),
+            (6, 4),
+        )
+    )
+    # fmt: off
+    GL = np.array([[ 0.0366, -0.0132, -0.0153, -0.0034, -0.0020, -0.0027],
+                   [-0.0132,  0.0450, -0.0111, -0.0076, -0.0062, -0.0069],
+                   [-0.0153, -0.0111,  0.0408, -0.0035, -0.0083, -0.0027],
+                   [-0.0034, -0.0076, -0.0035,  0.3688, -0.1356, -0.2187],
+                   [-0.0020, -0.0062, -0.0083, -0.1356,  0.2026, -0.0505],
+                   [-0.0027, -0.0069, -0.0027, -0.2187, -0.0505,  0.2815]])
+    # fmt: on
+
+    L = nx.directed_combinatorial_laplacian_matrix(G, alpha=0.9, nodelist=sorted(G))
+    np.testing.assert_almost_equal(L, GL, decimal=3)
+
+    # Make the graph strongly connected, so we can use a random and lazy walk
+    G.add_edges_from(((2, 5), (6, 1)))
+
+    # fmt: off
+    GL = np.array([[ 0.1395, -0.0349, -0.0465,  0.    ,  0.    , -0.0581],
+                   [-0.0349,  0.093 , -0.0116,  0.    , -0.0465,  0.    ],
+                   [-0.0465, -0.0116,  0.0698,  0.    , -0.0116,  0.    ],
+                   [ 0.    ,  0.    ,  0.    ,  0.2326, -0.1163, -0.1163],
+                   [ 0.    , -0.0465, -0.0116, -0.1163,  0.2326, -0.0581],
+                   [-0.0581,  0.    ,  0.    , -0.1163, -0.0581,  0.2326]])
+    # fmt: on
+
+    L = nx.directed_combinatorial_laplacian_matrix(
+        G, alpha=0.9, nodelist=sorted(G), walk_type="random"
+    )
+    np.testing.assert_almost_equal(L, GL, decimal=3)
+
+    # fmt: off
+    GL = np.array([[ 0.0698, -0.0174, -0.0233,  0.    ,  0.    , -0.0291],
+                   [-0.0174,  0.0465, -0.0058,  0.    , -0.0233,  0.    ],
+                   [-0.0233, -0.0058,  0.0349,  0.    , -0.0058,  0.    ],
+                   [ 0.    ,  0.    ,  0.    ,  0.1163, -0.0581, -0.0581],
+                   [ 0.    , -0.0233, -0.0058, -0.0581,  0.1163, -0.0291],
+                   [-0.0291,  0.    ,  0.    , -0.0581, -0.0291,  0.1163]])
+    # fmt: on
+
+    L = nx.directed_combinatorial_laplacian_matrix(
+        G, alpha=0.9, nodelist=sorted(G), walk_type="lazy"
+    )
+    np.testing.assert_almost_equal(L, GL, decimal=3)
+
+    E = nx.DiGraph(margulis_gabber_galil_graph(2))
+    L = nx.directed_combinatorial_laplacian_matrix(E)
+    # fmt: off
+    expected = np.array(
+        [[ 0.16666667, -0.08333333, -0.08333333,  0.        ],
+         [-0.08333333,  0.16666667,  0.        , -0.08333333],
+         [-0.08333333,  0.        ,  0.16666667, -0.08333333],
+         [ 0.        , -0.08333333, -0.08333333,  0.16666667]]
+    )
+    # fmt: on
+    np.testing.assert_almost_equal(L, expected, decimal=6)
+
+    with pytest.raises(nx.NetworkXError):
+        nx.directed_combinatorial_laplacian_matrix(G, walk_type="pagerank", alpha=100)
+    with pytest.raises(nx.NetworkXError):
+        nx.directed_combinatorial_laplacian_matrix(G, walk_type="silly")
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_modularity.py b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_modularity.py
new file mode 100644
index 0000000..9f94ff4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_modularity.py
@@ -0,0 +1,87 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+from networkx.generators.degree_seq import havel_hakimi_graph
+
+
+class TestModularity:
+    @classmethod
+    def setup_class(cls):
+        deg = [3, 2, 2, 1, 0]
+        cls.G = havel_hakimi_graph(deg)
+        # Graph used as an example in Sec. 4.1 of Langville and Meyer,
+        # "Google's PageRank and Beyond". (Used for test_directed_laplacian)
+        cls.DG = nx.DiGraph()
+        cls.DG.add_edges_from(
+            (
+                (1, 2),
+                (1, 3),
+                (3, 1),
+                (3, 2),
+                (3, 5),
+                (4, 5),
+                (4, 6),
+                (5, 4),
+                (5, 6),
+                (6, 4),
+            )
+        )
+
+    def test_modularity(self):
+        "Modularity matrix"
+        # fmt: off
+        B = np.array([[-1.125,  0.25,  0.25,  0.625,  0.],
+                      [0.25, -0.5,  0.5, -0.25,  0.],
+                      [0.25,  0.5, -0.5, -0.25,  0.],
+                      [0.625, -0.25, -0.25, -0.125,  0.],
+                      [0.,  0.,  0.,  0.,  0.]])
+        # fmt: on
+
+        permutation = [4, 0, 1, 2, 3]
+        np.testing.assert_equal(nx.modularity_matrix(self.G), B)
+        np.testing.assert_equal(
+            nx.modularity_matrix(self.G, nodelist=permutation),
+            B[np.ix_(permutation, permutation)],
+        )
+
+    def test_modularity_weight(self):
+        "Modularity matrix with weights"
+        # fmt: off
+        B = np.array([[-1.125,  0.25,  0.25,  0.625,  0.],
+                      [0.25, -0.5,  0.5, -0.25,  0.],
+                      [0.25,  0.5, -0.5, -0.25,  0.],
+                      [0.625, -0.25, -0.25, -0.125,  0.],
+                      [0.,  0.,  0.,  0.,  0.]])
+        # fmt: on
+
+        G_weighted = self.G.copy()
+        for n1, n2 in G_weighted.edges():
+            G_weighted.edges[n1, n2]["weight"] = 0.5
+        # The following test would fail in networkx 1.1
+        np.testing.assert_equal(nx.modularity_matrix(G_weighted), B)
+        # The following test that the modularity matrix get rescaled accordingly
+        np.testing.assert_equal(
+            nx.modularity_matrix(G_weighted, weight="weight"), 0.5 * B
+        )
+
+    def test_directed_modularity(self):
+        "Directed Modularity matrix"
+        # fmt: off
+        B = np.array([[-0.2,  0.6,  0.8, -0.4, -0.4, -0.4],
+                      [0.,  0.,  0.,  0.,  0.,  0.],
+                      [0.7,  0.4, -0.3, -0.6,  0.4, -0.6],
+                      [-0.2, -0.4, -0.2, -0.4,  0.6,  0.6],
+                      [-0.2, -0.4, -0.2,  0.6, -0.4,  0.6],
+                      [-0.1, -0.2, -0.1,  0.8, -0.2, -0.2]])
+        # fmt: on
+        node_permutation = [5, 1, 2, 3, 4, 6]
+        idx_permutation = [4, 0, 1, 2, 3, 5]
+        mm = nx.directed_modularity_matrix(self.DG, nodelist=sorted(self.DG))
+        np.testing.assert_equal(mm, B)
+        np.testing.assert_equal(
+            nx.directed_modularity_matrix(self.DG, nodelist=node_permutation),
+            B[np.ix_(idx_permutation, idx_permutation)],
+        )
diff --git a/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_spectrum.py b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_spectrum.py
new file mode 100644
index 0000000..e910130
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/linalg/tests/test_spectrum.py
@@ -0,0 +1,71 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+pytest.importorskip("scipy")
+
+import networkx as nx
+from networkx.generators.degree_seq import havel_hakimi_graph
+
+
+class TestSpectrum:
+    @classmethod
+    def setup_class(cls):
+        deg = [3, 2, 2, 1, 0]
+        cls.G = havel_hakimi_graph(deg)
+        cls.P = nx.path_graph(3)
+        cls.WG = nx.Graph(
+            (u, v, {"weight": 0.5, "other": 0.3}) for (u, v) in cls.G.edges()
+        )
+        cls.WG.add_node(4)
+        cls.DG = nx.DiGraph()
+        nx.add_path(cls.DG, [0, 1, 2])
+
+    def test_laplacian_spectrum(self):
+        "Laplacian eigenvalues"
+        evals = np.array([0, 0, 1, 3, 4])
+        e = sorted(nx.laplacian_spectrum(self.G))
+        np.testing.assert_almost_equal(e, evals)
+        e = sorted(nx.laplacian_spectrum(self.WG, weight=None))
+        np.testing.assert_almost_equal(e, evals)
+        e = sorted(nx.laplacian_spectrum(self.WG))
+        np.testing.assert_almost_equal(e, 0.5 * evals)
+        e = sorted(nx.laplacian_spectrum(self.WG, weight="other"))
+        np.testing.assert_almost_equal(e, 0.3 * evals)
+
+    def test_normalized_laplacian_spectrum(self):
+        "Normalized Laplacian eigenvalues"
+        evals = np.array([0, 0, 0.7712864461218, 1.5, 1.7287135538781])
+        e = sorted(nx.normalized_laplacian_spectrum(self.G))
+        np.testing.assert_almost_equal(e, evals)
+        e = sorted(nx.normalized_laplacian_spectrum(self.WG, weight=None))
+        np.testing.assert_almost_equal(e, evals)
+        e = sorted(nx.normalized_laplacian_spectrum(self.WG))
+        np.testing.assert_almost_equal(e, evals)
+        e = sorted(nx.normalized_laplacian_spectrum(self.WG, weight="other"))
+        np.testing.assert_almost_equal(e, evals)
+
+    def test_adjacency_spectrum(self):
+        "Adjacency eigenvalues"
+        evals = np.array([-np.sqrt(2), 0, np.sqrt(2)])
+        e = sorted(nx.adjacency_spectrum(self.P))
+        np.testing.assert_almost_equal(e, evals)
+
+    def test_modularity_spectrum(self):
+        "Modularity eigenvalues"
+        evals = np.array([-1.5, 0.0, 0.0])
+        e = sorted(nx.modularity_spectrum(self.P))
+        np.testing.assert_almost_equal(e, evals)
+        # Directed modularity eigenvalues
+        evals = np.array([-0.5, 0.0, 0.0])
+        e = sorted(nx.modularity_spectrum(self.DG))
+        np.testing.assert_almost_equal(e, evals)
+
+    def test_bethe_hessian_spectrum(self):
+        "Bethe Hessian eigenvalues"
+        evals = np.array([0.5 * (9 - np.sqrt(33)), 4, 0.5 * (9 + np.sqrt(33))])
+        e = sorted(nx.bethe_hessian_spectrum(self.P, r=2))
+        np.testing.assert_almost_equal(e, evals)
+        # Collapses back to Laplacian:
+        e1 = sorted(nx.bethe_hessian_spectrum(self.P, r=1))
+        e2 = sorted(nx.laplacian_spectrum(self.P))
+        np.testing.assert_almost_equal(e1, e2)
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/__init__.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/__init__.py
new file mode 100644
index 0000000..b97724b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/__init__.py
@@ -0,0 +1,60 @@
+"""
+A package for reading and writing graphs in various formats.
+
+"""
+
+
+def __getattr__(name):
+    """Remove functions and provide informative error messages."""
+    if name == "nx_yaml":
+        raise ImportError(
+            "\nThe nx_yaml module has been removed from NetworkX.\n"
+            "Please use the `yaml` package directly for working with yaml data.\n"
+            "For example, a networkx.Graph `G` can be written to and loaded\n"
+            "from a yaml file with:\n\n"
+            "    import yaml\n\n"
+            "    with open('path_to_yaml_file', 'w') as fh:\n"
+            "        yaml.dump(G, fh)\n"
+            "    with open('path_to_yaml_file', 'r') as fh:\n"
+            "        G = yaml.load(fh, Loader=yaml.Loader)\n\n"
+            "Note that yaml.Loader is considered insecure - see the pyyaml\n"
+            "documentation for further details.\n\n"
+            "This message will be removed in NetworkX 3.0."
+        )
+    if name == "read_yaml":
+        raise ImportError(
+            "\nread_yaml has been removed from NetworkX, please use `yaml`\n"
+            "directly:\n\n"
+            "    import yaml\n\n"
+            "    with open('path', 'r') as fh:\n"
+            "        yaml.load(fh, Loader=yaml.Loader)\n\n"
+            "Note that yaml.Loader is considered insecure - see the pyyaml\n"
+            "documentation for further details.\n\n"
+            "This message will be removed in NetworkX 3.0."
+        )
+    if name == "write_yaml":
+        raise ImportError(
+            "\nwrite_yaml has been removed from NetworkX, please use `yaml`\n"
+            "directly:\n\n"
+            "    import yaml\n\n"
+            "    with open('path_for_yaml_output', 'w') as fh:\n"
+            "        yaml.dump(G_to_be_yaml, fh)\n\n"
+            "This message will be removed in NetworkX 3.0."
+        )
+    raise AttributeError(f"module {__name__} has no attribute {name}")
+
+
+from networkx.readwrite.adjlist import *
+from networkx.readwrite.multiline_adjlist import *
+from networkx.readwrite.edgelist import *
+from networkx.readwrite.gpickle import *
+from networkx.readwrite.pajek import *
+from networkx.readwrite.leda import *
+from networkx.readwrite.sparse6 import *
+from networkx.readwrite.graph6 import *
+from networkx.readwrite.gml import *
+from networkx.readwrite.graphml import *
+from networkx.readwrite.gexf import *
+from networkx.readwrite.nx_shp import *
+from networkx.readwrite.json_graph import *
+from networkx.readwrite.text import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/adjlist.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/adjlist.py
new file mode 100644
index 0000000..c27b836
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/adjlist.py
@@ -0,0 +1,295 @@
+"""
+**************
+Adjacency List
+**************
+Read and write NetworkX graphs as adjacency lists.
+
+Adjacency list format is useful for graphs without data associated
+with nodes or edges and for nodes that can be meaningfully represented
+as strings.
+
+Format
+------
+The adjacency list format consists of lines with node labels.  The
+first label in a line is the source node.  Further labels in the line
+are considered target nodes and are added to the graph along with an edge
+between the source node and target node.
+
+The graph with edges a-b, a-c, d-e can be represented as the following
+adjacency list (anything following the # in a line is a comment)::
+
+     a b c # source target target
+     d e
+"""
+
+__all__ = ["generate_adjlist", "write_adjlist", "parse_adjlist", "read_adjlist"]
+
+import networkx as nx
+from networkx.utils import open_file
+
+
+def generate_adjlist(G, delimiter=" "):
+    """Generate a single line of the graph G in adjacency list format.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    delimiter : string, optional
+       Separator for node labels
+
+    Returns
+    -------
+    lines : string
+        Lines of data in adjlist format.
+
+    Examples
+    --------
+    >>> G = nx.lollipop_graph(4, 3)
+    >>> for line in nx.generate_adjlist(G):
+    ...     print(line)
+    0 1 2 3
+    1 2 3
+    2 3
+    3 4
+    4 5
+    5 6
+    6
+
+    See Also
+    --------
+    write_adjlist, read_adjlist
+
+    """
+    directed = G.is_directed()
+    seen = set()
+    for s, nbrs in G.adjacency():
+        line = str(s) + delimiter
+        for t, data in nbrs.items():
+            if not directed and t in seen:
+                continue
+            if G.is_multigraph():
+                for d in data.values():
+                    line += str(t) + delimiter
+            else:
+                line += str(t) + delimiter
+        if not directed:
+            seen.add(s)
+        yield line[: -len(delimiter)]
+
+
+@open_file(1, mode="wb")
+def write_adjlist(G, path, comments="#", delimiter=" ", encoding="utf-8"):
+    """Write graph G in single-line adjacency-list format to path.
+
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    path : string or file
+       Filename or file handle for data output.
+       Filenames ending in .gz or .bz2 will be compressed.
+
+    comments : string, optional
+       Marker for comment lines
+
+    delimiter : string, optional
+       Separator for node labels
+
+    encoding : string, optional
+       Text encoding.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_adjlist(G, "test.adjlist")
+
+    The path can be a filehandle or a string with the name of the file. If a
+    filehandle is provided, it has to be opened in 'wb' mode.
+
+    >>> fh = open("test.adjlist", "wb")
+    >>> nx.write_adjlist(G, fh)
+
+    Notes
+    -----
+    This format does not store graph, node, or edge data.
+
+    See Also
+    --------
+    read_adjlist, generate_adjlist
+    """
+    import sys
+    import time
+
+    pargs = comments + " ".join(sys.argv) + "\n"
+    header = (
+        pargs
+        + comments
+        + f" GMT {time.asctime(time.gmtime())}\n"
+        + comments
+        + f" {G.name}\n"
+    )
+    path.write(header.encode(encoding))
+
+    for line in generate_adjlist(G, delimiter):
+        line += "\n"
+        path.write(line.encode(encoding))
+
+
+def parse_adjlist(
+    lines, comments="#", delimiter=None, create_using=None, nodetype=None
+):
+    """Parse lines of a graph adjacency list representation.
+
+    Parameters
+    ----------
+    lines : list or iterator of strings
+        Input data in adjlist format
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    nodetype : Python type, optional
+       Convert nodes to this type.
+
+    comments : string, optional
+       Marker for comment lines
+
+    delimiter : string, optional
+       Separator for node labels.  The default is whitespace.
+
+    Returns
+    -------
+    G: NetworkX graph
+        The graph corresponding to the lines in adjacency list format.
+
+    Examples
+    --------
+    >>> lines = ["1 2 5", "2 3 4", "3 5", "4", "5"]
+    >>> G = nx.parse_adjlist(lines, nodetype=int)
+    >>> nodes = [1, 2, 3, 4, 5]
+    >>> all(node in G for node in nodes)
+    True
+    >>> edges = [(1, 2), (1, 5), (2, 3), (2, 4), (3, 5)]
+    >>> all((u, v) in G.edges() or (v, u) in G.edges() for (u, v) in edges)
+    True
+
+    See Also
+    --------
+    read_adjlist
+
+    """
+    G = nx.empty_graph(0, create_using)
+    for line in lines:
+        p = line.find(comments)
+        if p >= 0:
+            line = line[:p]
+        if not len(line):
+            continue
+        vlist = line.strip().split(delimiter)
+        u = vlist.pop(0)
+        # convert types
+        if nodetype is not None:
+            try:
+                u = nodetype(u)
+            except BaseException as err:
+                raise TypeError(
+                    f"Failed to convert node ({u}) to type " f"{nodetype}"
+                ) from err
+        G.add_node(u)
+        if nodetype is not None:
+            try:
+                vlist = list(map(nodetype, vlist))
+            except BaseException as err:
+                raise TypeError(
+                    f"Failed to convert nodes ({','.join(vlist)}) to type {nodetype}"
+                ) from err
+        G.add_edges_from([(u, v) for v in vlist])
+    return G
+
+
+@open_file(0, mode="rb")
+def read_adjlist(
+    path,
+    comments="#",
+    delimiter=None,
+    create_using=None,
+    nodetype=None,
+    encoding="utf-8",
+):
+    """Read graph in adjacency list format from path.
+
+    Parameters
+    ----------
+    path : string or file
+       Filename or file handle to read.
+       Filenames ending in .gz or .bz2 will be uncompressed.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    nodetype : Python type, optional
+       Convert nodes to this type.
+
+    comments : string, optional
+       Marker for comment lines
+
+    delimiter : string, optional
+       Separator for node labels.  The default is whitespace.
+
+    Returns
+    -------
+    G: NetworkX graph
+        The graph corresponding to the lines in adjacency list format.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_adjlist(G, "test.adjlist")
+    >>> G = nx.read_adjlist("test.adjlist")
+
+    The path can be a filehandle or a string with the name of the file. If a
+    filehandle is provided, it has to be opened in 'rb' mode.
+
+    >>> fh = open("test.adjlist", "rb")
+    >>> G = nx.read_adjlist(fh)
+
+    Filenames ending in .gz or .bz2 will be compressed.
+
+    >>> nx.write_adjlist(G, "test.adjlist.gz")
+    >>> G = nx.read_adjlist("test.adjlist.gz")
+
+    The optional nodetype is a function to convert node strings to nodetype.
+
+    For example
+
+    >>> G = nx.read_adjlist("test.adjlist", nodetype=int)
+
+    will attempt to convert all nodes to integer type.
+
+    Since nodes must be hashable, the function nodetype must return hashable
+    types (e.g. int, float, str, frozenset - or tuples of those, etc.)
+
+    The optional create_using parameter indicates the type of NetworkX graph
+    created.  The default is `nx.Graph`, an undirected graph.
+    To read the data as a directed graph use
+
+    >>> G = nx.read_adjlist("test.adjlist", create_using=nx.DiGraph)
+
+    Notes
+    -----
+    This format does not store graph or node data.
+
+    See Also
+    --------
+    write_adjlist
+    """
+    lines = (line.decode(encoding) for line in path)
+    return parse_adjlist(
+        lines,
+        comments=comments,
+        delimiter=delimiter,
+        create_using=create_using,
+        nodetype=nodetype,
+    )
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/edgelist.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/edgelist.py
new file mode 100644
index 0000000..558cbae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/edgelist.py
@@ -0,0 +1,486 @@
+"""
+**********
+Edge Lists
+**********
+Read and write NetworkX graphs as edge lists.
+
+The multi-line adjacency list format is useful for graphs with nodes
+that can be meaningfully represented as strings.  With the edgelist
+format simple edge data can be stored but node or graph data is not.
+There is no way of representing isolated nodes unless the node has a
+self-loop edge.
+
+Format
+------
+You can read or write three formats of edge lists with these functions.
+
+Node pairs with no data::
+
+ 1 2
+
+Python dictionary as data::
+
+ 1 2 {'weight':7, 'color':'green'}
+
+Arbitrary data::
+
+ 1 2 7 green
+"""
+
+__all__ = [
+    "generate_edgelist",
+    "write_edgelist",
+    "parse_edgelist",
+    "read_edgelist",
+    "read_weighted_edgelist",
+    "write_weighted_edgelist",
+]
+
+import networkx as nx
+from networkx.utils import open_file
+
+
+def generate_edgelist(G, delimiter=" ", data=True):
+    """Generate a single line of the graph G in edge list format.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    delimiter : string, optional
+       Separator for node labels
+
+    data : bool or list of keys
+       If False generate no edge data.  If True use a dictionary
+       representation of edge data.  If a list of keys use a list of data
+       values corresponding to the keys.
+
+    Returns
+    -------
+    lines : string
+        Lines of data in adjlist format.
+
+    Examples
+    --------
+    >>> G = nx.lollipop_graph(4, 3)
+    >>> G[1][2]["weight"] = 3
+    >>> G[3][4]["capacity"] = 12
+    >>> for line in nx.generate_edgelist(G, data=False):
+    ...     print(line)
+    0 1
+    0 2
+    0 3
+    1 2
+    1 3
+    2 3
+    3 4
+    4 5
+    5 6
+
+    >>> for line in nx.generate_edgelist(G):
+    ...     print(line)
+    0 1 {}
+    0 2 {}
+    0 3 {}
+    1 2 {'weight': 3}
+    1 3 {}
+    2 3 {}
+    3 4 {'capacity': 12}
+    4 5 {}
+    5 6 {}
+
+    >>> for line in nx.generate_edgelist(G, data=["weight"]):
+    ...     print(line)
+    0 1
+    0 2
+    0 3
+    1 2 3
+    1 3
+    2 3
+    3 4
+    4 5
+    5 6
+
+    See Also
+    --------
+    write_adjlist, read_adjlist
+    """
+    if data is True:
+        for u, v, d in G.edges(data=True):
+            e = u, v, dict(d)
+            yield delimiter.join(map(str, e))
+    elif data is False:
+        for u, v in G.edges(data=False):
+            e = u, v
+            yield delimiter.join(map(str, e))
+    else:
+        for u, v, d in G.edges(data=True):
+            e = [u, v]
+            try:
+                e.extend(d[k] for k in data)
+            except KeyError:
+                pass  # missing data for this edge, should warn?
+            yield delimiter.join(map(str, e))
+
+
+@open_file(1, mode="wb")
+def write_edgelist(G, path, comments="#", delimiter=" ", data=True, encoding="utf-8"):
+    """Write graph as a list of edges.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+    path : file or string
+       File or filename to write. If a file is provided, it must be
+       opened in 'wb' mode. Filenames ending in .gz or .bz2 will be compressed.
+    comments : string, optional
+       The character used to indicate the start of a comment
+    delimiter : string, optional
+       The string used to separate values.  The default is whitespace.
+    data : bool or list, optional
+       If False write no edge data.
+       If True write a string representation of the edge data dictionary..
+       If a list (or other iterable) is provided, write the  keys specified
+       in the list.
+    encoding: string, optional
+       Specify which encoding to use when writing file.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_edgelist(G, "test.edgelist")
+    >>> G = nx.path_graph(4)
+    >>> fh = open("test.edgelist", "wb")
+    >>> nx.write_edgelist(G, fh)
+    >>> nx.write_edgelist(G, "test.edgelist.gz")
+    >>> nx.write_edgelist(G, "test.edgelist.gz", data=False)
+
+    >>> G = nx.Graph()
+    >>> G.add_edge(1, 2, weight=7, color="red")
+    >>> nx.write_edgelist(G, "test.edgelist", data=False)
+    >>> nx.write_edgelist(G, "test.edgelist", data=["color"])
+    >>> nx.write_edgelist(G, "test.edgelist", data=["color", "weight"])
+
+    See Also
+    --------
+    read_edgelist
+    write_weighted_edgelist
+    """
+
+    for line in generate_edgelist(G, delimiter, data):
+        line += "\n"
+        path.write(line.encode(encoding))
+
+
+def parse_edgelist(
+    lines, comments="#", delimiter=None, create_using=None, nodetype=None, data=True
+):
+    """Parse lines of an edge list representation of a graph.
+
+    Parameters
+    ----------
+    lines : list or iterator of strings
+        Input data in edgelist format
+    comments : string, optional
+       Marker for comment lines. Default is `'#'`. To specify that no character
+       should be treated as a comment, use ``comments=None``.
+    delimiter : string, optional
+       Separator for node labels. Default is `None`, meaning any whitespace.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+    nodetype : Python type, optional
+       Convert nodes to this type. Default is `None`, meaning no conversion is
+       performed.
+    data : bool or list of (label,type) tuples
+       If `False` generate no edge data or if `True` use a dictionary
+       representation of edge data or a list tuples specifying dictionary
+       key names and types for edge data.
+
+    Returns
+    -------
+    G: NetworkX Graph
+        The graph corresponding to lines
+
+    Examples
+    --------
+    Edgelist with no data:
+
+    >>> lines = ["1 2", "2 3", "3 4"]
+    >>> G = nx.parse_edgelist(lines, nodetype=int)
+    >>> list(G)
+    [1, 2, 3, 4]
+    >>> list(G.edges())
+    [(1, 2), (2, 3), (3, 4)]
+
+    Edgelist with data in Python dictionary representation:
+
+    >>> lines = ["1 2 {'weight': 3}", "2 3 {'weight': 27}", "3 4 {'weight': 3.0}"]
+    >>> G = nx.parse_edgelist(lines, nodetype=int)
+    >>> list(G)
+    [1, 2, 3, 4]
+    >>> list(G.edges(data=True))
+    [(1, 2, {'weight': 3}), (2, 3, {'weight': 27}), (3, 4, {'weight': 3.0})]
+
+    Edgelist with data in a list:
+
+    >>> lines = ["1 2 3", "2 3 27", "3 4 3.0"]
+    >>> G = nx.parse_edgelist(lines, nodetype=int, data=(("weight", float),))
+    >>> list(G)
+    [1, 2, 3, 4]
+    >>> list(G.edges(data=True))
+    [(1, 2, {'weight': 3.0}), (2, 3, {'weight': 27.0}), (3, 4, {'weight': 3.0})]
+
+    See Also
+    --------
+    read_weighted_edgelist
+    """
+    from ast import literal_eval
+
+    G = nx.empty_graph(0, create_using)
+    for line in lines:
+        if comments is not None:
+            p = line.find(comments)
+            if p >= 0:
+                line = line[:p]
+            if not line:
+                continue
+        # split line, should have 2 or more
+        s = line.strip().split(delimiter)
+        if len(s) < 2:
+            continue
+        u = s.pop(0)
+        v = s.pop(0)
+        d = s
+        if nodetype is not None:
+            try:
+                u = nodetype(u)
+                v = nodetype(v)
+            except Exception as err:
+                raise TypeError(
+                    f"Failed to convert nodes {u},{v} to type {nodetype}."
+                ) from err
+
+        if len(d) == 0 or data is False:
+            # no data or data type specified
+            edgedata = {}
+        elif data is True:
+            # no edge types specified
+            try:  # try to evaluate as dictionary
+                if delimiter == ",":
+                    edgedata_str = ",".join(d)
+                else:
+                    edgedata_str = " ".join(d)
+                edgedata = dict(literal_eval(edgedata_str.strip()))
+            except Exception as err:
+                raise TypeError(
+                    f"Failed to convert edge data ({d}) to dictionary."
+                ) from err
+        else:
+            # convert edge data to dictionary with specified keys and type
+            if len(d) != len(data):
+                raise IndexError(
+                    f"Edge data {d} and data_keys {data} are not the same length"
+                )
+            edgedata = {}
+            for (edge_key, edge_type), edge_value in zip(data, d):
+                try:
+                    edge_value = edge_type(edge_value)
+                except Exception as err:
+                    raise TypeError(
+                        f"Failed to convert {edge_key} data {edge_value} "
+                        f"to type {edge_type}."
+                    ) from err
+                edgedata.update({edge_key: edge_value})
+        G.add_edge(u, v, **edgedata)
+    return G
+
+
+@open_file(0, mode="rb")
+def read_edgelist(
+    path,
+    comments="#",
+    delimiter=None,
+    create_using=None,
+    nodetype=None,
+    data=True,
+    edgetype=None,
+    encoding="utf-8",
+):
+    """Read a graph from a list of edges.
+
+    Parameters
+    ----------
+    path : file or string
+       File or filename to read. If a file is provided, it must be
+       opened in 'rb' mode.
+       Filenames ending in .gz or .bz2 will be uncompressed.
+    comments : string, optional
+       The character used to indicate the start of a comment. To specify that
+       no character should be treated as a comment, use ``comments=None``.
+    delimiter : string, optional
+       The string used to separate values.  The default is whitespace.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+    nodetype : int, float, str, Python type, optional
+       Convert node data from strings to specified type
+    data : bool or list of (label,type) tuples
+       Tuples specifying dictionary key names and types for edge data
+    edgetype : int, float, str, Python type, optional OBSOLETE
+       Convert edge data from strings to specified type and use as 'weight'
+    encoding: string, optional
+       Specify which encoding to use when reading file.
+
+    Returns
+    -------
+    G : graph
+       A networkx Graph or other type specified with create_using
+
+    Examples
+    --------
+    >>> nx.write_edgelist(nx.path_graph(4), "test.edgelist")
+    >>> G = nx.read_edgelist("test.edgelist")
+
+    >>> fh = open("test.edgelist", "rb")
+    >>> G = nx.read_edgelist(fh)
+    >>> fh.close()
+
+    >>> G = nx.read_edgelist("test.edgelist", nodetype=int)
+    >>> G = nx.read_edgelist("test.edgelist", create_using=nx.DiGraph)
+
+    Edgelist with data in a list:
+
+    >>> textline = "1 2 3"
+    >>> fh = open("test.edgelist", "w")
+    >>> d = fh.write(textline)
+    >>> fh.close()
+    >>> G = nx.read_edgelist("test.edgelist", nodetype=int, data=(("weight", float),))
+    >>> list(G)
+    [1, 2]
+    >>> list(G.edges(data=True))
+    [(1, 2, {'weight': 3.0})]
+
+    See parse_edgelist() for more examples of formatting.
+
+    See Also
+    --------
+    parse_edgelist
+    write_edgelist
+
+    Notes
+    -----
+    Since nodes must be hashable, the function nodetype must return hashable
+    types (e.g. int, float, str, frozenset - or tuples of those, etc.)
+    """
+    lines = (line if isinstance(line, str) else line.decode(encoding) for line in path)
+    return parse_edgelist(
+        lines,
+        comments=comments,
+        delimiter=delimiter,
+        create_using=create_using,
+        nodetype=nodetype,
+        data=data,
+    )
+
+
+def write_weighted_edgelist(G, path, comments="#", delimiter=" ", encoding="utf-8"):
+    """Write graph G as a list of edges with numeric weights.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+    path : file or string
+       File or filename to write. If a file is provided, it must be
+       opened in 'wb' mode.
+       Filenames ending in .gz or .bz2 will be compressed.
+    comments : string, optional
+       The character used to indicate the start of a comment
+    delimiter : string, optional
+       The string used to separate values.  The default is whitespace.
+    encoding: string, optional
+       Specify which encoding to use when writing file.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_edge(1, 2, weight=7)
+    >>> nx.write_weighted_edgelist(G, "test.weighted.edgelist")
+
+    See Also
+    --------
+    read_edgelist
+    write_edgelist
+    read_weighted_edgelist
+    """
+    write_edgelist(
+        G,
+        path,
+        comments=comments,
+        delimiter=delimiter,
+        data=("weight",),
+        encoding=encoding,
+    )
+
+
+def read_weighted_edgelist(
+    path,
+    comments="#",
+    delimiter=None,
+    create_using=None,
+    nodetype=None,
+    encoding="utf-8",
+):
+    """Read a graph as list of edges with numeric weights.
+
+    Parameters
+    ----------
+    path : file or string
+       File or filename to read. If a file is provided, it must be
+       opened in 'rb' mode.
+       Filenames ending in .gz or .bz2 will be uncompressed.
+    comments : string, optional
+       The character used to indicate the start of a comment.
+    delimiter : string, optional
+       The string used to separate values.  The default is whitespace.
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+    nodetype : int, float, str, Python type, optional
+       Convert node data from strings to specified type
+    encoding: string, optional
+       Specify which encoding to use when reading file.
+
+    Returns
+    -------
+    G : graph
+       A networkx Graph or other type specified with create_using
+
+    Notes
+    -----
+    Since nodes must be hashable, the function nodetype must return hashable
+    types (e.g. int, float, str, frozenset - or tuples of those, etc.)
+
+    Example edgelist file format.
+
+    With numeric edge data::
+
+     # read with
+     # >>> G=nx.read_weighted_edgelist(fh)
+     # source target data
+     a b 1
+     a c 3.14159
+     d e 42
+
+    See Also
+    --------
+    write_weighted_edgelist
+    """
+    return read_edgelist(
+        path,
+        comments=comments,
+        delimiter=delimiter,
+        create_using=create_using,
+        nodetype=nodetype,
+        data=(("weight", float),),
+        encoding=encoding,
+    )
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/gexf.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/gexf.py
new file mode 100644
index 0000000..b7c5a5a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/gexf.py
@@ -0,0 +1,1060 @@
+"""Read and write graphs in GEXF format.
+
+.. warning::
+    This parser uses the standard xml library present in Python, which is
+    insecure - see :doc:`library/xml` for additional information.
+    Only parse GEFX files you trust.
+
+GEXF (Graph Exchange XML Format) is a language for describing complex
+network structures, their associated data and dynamics.
+
+This implementation does not support mixed graphs (directed and
+undirected edges together).
+
+Format
+------
+GEXF is an XML format.  See http://gexf.net/schema.html for the
+specification and http://gexf.net/basic.html for examples.
+"""
+import itertools
+import time
+from xml.etree.ElementTree import (
+    Element,
+    ElementTree,
+    SubElement,
+    register_namespace,
+    tostring,
+)
+
+import networkx as nx
+from networkx.utils import open_file
+
+__all__ = ["write_gexf", "read_gexf", "relabel_gexf_graph", "generate_gexf"]
+
+
+@open_file(1, mode="wb")
+def write_gexf(G, path, encoding="utf-8", prettyprint=True, version="1.2draft"):
+    """Write G in GEXF format to path.
+
+    "GEXF (Graph Exchange XML Format) is a language for describing
+    complex networks structures, their associated data and dynamics" [1]_.
+
+    Node attributes are checked according to the version of the GEXF
+    schemas used for parameters which are not user defined,
+    e.g. visualization 'viz' [2]_. See example for usage.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+    path : file or string
+       File or file name to write.
+       File names ending in .gz or .bz2 will be compressed.
+    encoding : string (optional, default: 'utf-8')
+       Encoding for text data.
+    prettyprint : bool (optional, default: True)
+       If True use line breaks and indenting in output XML.
+    version: string (optional, default: '1.2draft')
+       The version of GEXF to be used for nodes attributes checking
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_gexf(G, "test.gexf")
+
+    # visualization data
+    >>> G.nodes[0]["viz"] = {"size": 54}
+    >>> G.nodes[0]["viz"]["position"] = {"x": 0, "y": 1}
+    >>> G.nodes[0]["viz"]["color"] = {"r": 0, "g": 0, "b": 256}
+
+
+    Notes
+    -----
+    This implementation does not support mixed graphs (directed and undirected
+    edges together).
+
+    The node id attribute is set to be the string of the node label.
+    If you want to specify an id use set it as node data, e.g.
+    node['a']['id']=1 to set the id of node 'a' to 1.
+
+    References
+    ----------
+    .. [1] GEXF File Format, http://gexf.net/
+    .. [2] GEXF schema, http://gexf.net/schema.html
+    """
+    writer = GEXFWriter(encoding=encoding, prettyprint=prettyprint, version=version)
+    writer.add_graph(G)
+    writer.write(path)
+
+
+def generate_gexf(G, encoding="utf-8", prettyprint=True, version="1.2draft"):
+    """Generate lines of GEXF format representation of G.
+
+    "GEXF (Graph Exchange XML Format) is a language for describing
+    complex networks structures, their associated data and dynamics" [1]_.
+
+    Parameters
+    ----------
+    G : graph
+    A NetworkX graph
+    encoding : string (optional, default: 'utf-8')
+    Encoding for text data.
+    prettyprint : bool (optional, default: True)
+    If True use line breaks and indenting in output XML.
+    version : string (default: 1.2draft)
+    Version of GEFX File Format (see http://gexf.net/schema.html)
+    Supported values: "1.1draft", "1.2draft"
+
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> linefeed = chr(10)  # linefeed=\n
+    >>> s = linefeed.join(nx.generate_gexf(G))
+    >>> for line in nx.generate_gexf(G):  # doctest: +SKIP
+    ...     print(line)
+
+    Notes
+    -----
+    This implementation does not support mixed graphs (directed and undirected
+    edges together).
+
+    The node id attribute is set to be the string of the node label.
+    If you want to specify an id use set it as node data, e.g.
+    node['a']['id']=1 to set the id of node 'a' to 1.
+
+    References
+    ----------
+    .. [1] GEXF File Format, https://gephi.org/gexf/format/
+    """
+    writer = GEXFWriter(encoding=encoding, prettyprint=prettyprint, version=version)
+    writer.add_graph(G)
+    yield from str(writer).splitlines()
+
+
+@open_file(0, mode="rb")
+def read_gexf(path, node_type=None, relabel=False, version="1.2draft"):
+    """Read graph in GEXF format from path.
+
+    "GEXF (Graph Exchange XML Format) is a language for describing
+    complex networks structures, their associated data and dynamics" [1]_.
+
+    Parameters
+    ----------
+    path : file or string
+       File or file name to read.
+       File names ending in .gz or .bz2 will be decompressed.
+    node_type: Python type (default: None)
+       Convert node ids to this type if not None.
+    relabel : bool (default: False)
+       If True relabel the nodes to use the GEXF node "label" attribute
+       instead of the node "id" attribute as the NetworkX node label.
+    version : string (default: 1.2draft)
+    Version of GEFX File Format (see http://gexf.net/schema.html)
+       Supported values: "1.1draft", "1.2draft"
+
+    Returns
+    -------
+    graph: NetworkX graph
+        If no parallel edges are found a Graph or DiGraph is returned.
+        Otherwise a MultiGraph or MultiDiGraph is returned.
+
+    Notes
+    -----
+    This implementation does not support mixed graphs (directed and undirected
+    edges together).
+
+    References
+    ----------
+    .. [1] GEXF File Format, http://gexf.net/
+    """
+    reader = GEXFReader(node_type=node_type, version=version)
+    if relabel:
+        G = relabel_gexf_graph(reader(path))
+    else:
+        G = reader(path)
+    return G
+
+
+class GEXF:
+    versions = {}
+    d = {
+        "NS_GEXF": "http://www.gexf.net/1.1draft",
+        "NS_VIZ": "http://www.gexf.net/1.1draft/viz",
+        "NS_XSI": "http://www.w3.org/2001/XMLSchema-instance",
+        "SCHEMALOCATION": " ".join(
+            ["http://www.gexf.net/1.1draft", "http://www.gexf.net/1.1draft/gexf.xsd"]
+        ),
+        "VERSION": "1.1",
+    }
+    versions["1.1draft"] = d
+    d = {
+        "NS_GEXF": "http://www.gexf.net/1.2draft",
+        "NS_VIZ": "http://www.gexf.net/1.2draft/viz",
+        "NS_XSI": "http://www.w3.org/2001/XMLSchema-instance",
+        "SCHEMALOCATION": " ".join(
+            ["http://www.gexf.net/1.2draft", "http://www.gexf.net/1.2draft/gexf.xsd"]
+        ),
+        "VERSION": "1.2",
+    }
+    versions["1.2draft"] = d
+
+    def construct_types(self):
+        types = [
+            (int, "integer"),
+            (float, "float"),
+            (float, "double"),
+            (bool, "boolean"),
+            (list, "string"),
+            (dict, "string"),
+            (int, "long"),
+            (str, "liststring"),
+            (str, "anyURI"),
+            (str, "string"),
+        ]
+
+        # These additions to types allow writing numpy types
+        try:
+            import numpy as np
+        except ImportError:
+            pass
+        else:
+            # prepend so that python types are created upon read (last entry wins)
+            types = [
+                (np.float64, "float"),
+                (np.float32, "float"),
+                (np.float16, "float"),
+                (np.float_, "float"),
+                (np.int_, "int"),
+                (np.int8, "int"),
+                (np.int16, "int"),
+                (np.int32, "int"),
+                (np.int64, "int"),
+                (np.uint8, "int"),
+                (np.uint16, "int"),
+                (np.uint32, "int"),
+                (np.uint64, "int"),
+                (np.int_, "int"),
+                (np.intc, "int"),
+                (np.intp, "int"),
+            ] + types
+
+        self.xml_type = dict(types)
+        self.python_type = dict(reversed(a) for a in types)
+
+    # http://www.w3.org/TR/xmlschema-2/#boolean
+    convert_bool = {
+        "true": True,
+        "false": False,
+        "True": True,
+        "False": False,
+        "0": False,
+        0: False,
+        "1": True,
+        1: True,
+    }
+
+    def set_version(self, version):
+        d = self.versions.get(version)
+        if d is None:
+            raise nx.NetworkXError(f"Unknown GEXF version {version}.")
+        self.NS_GEXF = d["NS_GEXF"]
+        self.NS_VIZ = d["NS_VIZ"]
+        self.NS_XSI = d["NS_XSI"]
+        self.SCHEMALOCATION = d["SCHEMALOCATION"]
+        self.VERSION = d["VERSION"]
+        self.version = version
+
+
+class GEXFWriter(GEXF):
+    # class for writing GEXF format files
+    # use write_gexf() function
+    def __init__(
+        self, graph=None, encoding="utf-8", prettyprint=True, version="1.2draft"
+    ):
+        self.construct_types()
+        self.prettyprint = prettyprint
+        self.encoding = encoding
+        self.set_version(version)
+        self.xml = Element(
+            "gexf",
+            {
+                "xmlns": self.NS_GEXF,
+                "xmlns:xsi": self.NS_XSI,
+                "xsi:schemaLocation": self.SCHEMALOCATION,
+                "version": self.VERSION,
+            },
+        )
+
+        # Make meta element a non-graph element
+        # Also add lastmodifieddate as attribute, not tag
+        meta_element = Element("meta")
+        subelement_text = f"NetworkX {nx.__version__}"
+        SubElement(meta_element, "creator").text = subelement_text
+        meta_element.set("lastmodifieddate", time.strftime("%Y-%m-%d"))
+        self.xml.append(meta_element)
+
+        register_namespace("viz", self.NS_VIZ)
+
+        # counters for edge and attribute identifiers
+        self.edge_id = itertools.count()
+        self.attr_id = itertools.count()
+        self.all_edge_ids = set()
+        # default attributes are stored in dictionaries
+        self.attr = {}
+        self.attr["node"] = {}
+        self.attr["edge"] = {}
+        self.attr["node"]["dynamic"] = {}
+        self.attr["node"]["static"] = {}
+        self.attr["edge"]["dynamic"] = {}
+        self.attr["edge"]["static"] = {}
+
+        if graph is not None:
+            self.add_graph(graph)
+
+    def __str__(self):
+        if self.prettyprint:
+            self.indent(self.xml)
+        s = tostring(self.xml).decode(self.encoding)
+        return s
+
+    def add_graph(self, G):
+        # first pass through G collecting edge ids
+        for u, v, dd in G.edges(data=True):
+            eid = dd.get("id")
+            if eid is not None:
+                self.all_edge_ids.add(str(eid))
+        # set graph attributes
+        if G.graph.get("mode") == "dynamic":
+            mode = "dynamic"
+        else:
+            mode = "static"
+        # Add a graph element to the XML
+        if G.is_directed():
+            default = "directed"
+        else:
+            default = "undirected"
+        name = G.graph.get("name", "")
+        graph_element = Element("graph", defaultedgetype=default, mode=mode, name=name)
+        self.graph_element = graph_element
+        self.add_nodes(G, graph_element)
+        self.add_edges(G, graph_element)
+        self.xml.append(graph_element)
+
+    def add_nodes(self, G, graph_element):
+        nodes_element = Element("nodes")
+        for node, data in G.nodes(data=True):
+            node_data = data.copy()
+            node_id = str(node_data.pop("id", node))
+            kw = {"id": node_id}
+            label = str(node_data.pop("label", node))
+            kw["label"] = label
+            try:
+                pid = node_data.pop("pid")
+                kw["pid"] = str(pid)
+            except KeyError:
+                pass
+            try:
+                start = node_data.pop("start")
+                kw["start"] = str(start)
+                self.alter_graph_mode_timeformat(start)
+            except KeyError:
+                pass
+            try:
+                end = node_data.pop("end")
+                kw["end"] = str(end)
+                self.alter_graph_mode_timeformat(end)
+            except KeyError:
+                pass
+            # add node element with attributes
+            node_element = Element("node", **kw)
+            # add node element and attr subelements
+            default = G.graph.get("node_default", {})
+            node_data = self.add_parents(node_element, node_data)
+            if self.VERSION == "1.1":
+                node_data = self.add_slices(node_element, node_data)
+            else:
+                node_data = self.add_spells(node_element, node_data)
+            node_data = self.add_viz(node_element, node_data)
+            node_data = self.add_attributes("node", node_element, node_data, default)
+            nodes_element.append(node_element)
+        graph_element.append(nodes_element)
+
+    def add_edges(self, G, graph_element):
+        def edge_key_data(G):
+            # helper function to unify multigraph and graph edge iterator
+            if G.is_multigraph():
+                for u, v, key, data in G.edges(data=True, keys=True):
+                    edge_data = data.copy()
+                    edge_data.update(key=key)
+                    edge_id = edge_data.pop("id", None)
+                    if edge_id is None:
+                        edge_id = next(self.edge_id)
+                        while str(edge_id) in self.all_edge_ids:
+                            edge_id = next(self.edge_id)
+                        self.all_edge_ids.add(str(edge_id))
+                    yield u, v, edge_id, edge_data
+            else:
+                for u, v, data in G.edges(data=True):
+                    edge_data = data.copy()
+                    edge_id = edge_data.pop("id", None)
+                    if edge_id is None:
+                        edge_id = next(self.edge_id)
+                        while str(edge_id) in self.all_edge_ids:
+                            edge_id = next(self.edge_id)
+                        self.all_edge_ids.add(str(edge_id))
+                    yield u, v, edge_id, edge_data
+
+        edges_element = Element("edges")
+        for u, v, key, edge_data in edge_key_data(G):
+            kw = {"id": str(key)}
+            try:
+                edge_label = edge_data.pop("label")
+                kw["label"] = str(edge_label)
+            except KeyError:
+                pass
+            try:
+                edge_weight = edge_data.pop("weight")
+                kw["weight"] = str(edge_weight)
+            except KeyError:
+                pass
+            try:
+                edge_type = edge_data.pop("type")
+                kw["type"] = str(edge_type)
+            except KeyError:
+                pass
+            try:
+                start = edge_data.pop("start")
+                kw["start"] = str(start)
+                self.alter_graph_mode_timeformat(start)
+            except KeyError:
+                pass
+            try:
+                end = edge_data.pop("end")
+                kw["end"] = str(end)
+                self.alter_graph_mode_timeformat(end)
+            except KeyError:
+                pass
+            source_id = str(G.nodes[u].get("id", u))
+            target_id = str(G.nodes[v].get("id", v))
+            edge_element = Element("edge", source=source_id, target=target_id, **kw)
+            default = G.graph.get("edge_default", {})
+            if self.VERSION == "1.1":
+                edge_data = self.add_slices(edge_element, edge_data)
+            else:
+                edge_data = self.add_spells(edge_element, edge_data)
+            edge_data = self.add_viz(edge_element, edge_data)
+            edge_data = self.add_attributes("edge", edge_element, edge_data, default)
+            edges_element.append(edge_element)
+        graph_element.append(edges_element)
+
+    def add_attributes(self, node_or_edge, xml_obj, data, default):
+        # Add attrvalues to node or edge
+        attvalues = Element("attvalues")
+        if len(data) == 0:
+            return data
+        mode = "static"
+        for k, v in data.items():
+            # rename generic multigraph key to avoid any name conflict
+            if k == "key":
+                k = "networkx_key"
+            val_type = type(v)
+            if val_type not in self.xml_type:
+                raise TypeError(f"attribute value type is not allowed: {val_type}")
+            if isinstance(v, list):
+                # dynamic data
+                for val, start, end in v:
+                    val_type = type(val)
+                    if start is not None or end is not None:
+                        mode = "dynamic"
+                        self.alter_graph_mode_timeformat(start)
+                        self.alter_graph_mode_timeformat(end)
+                        break
+                attr_id = self.get_attr_id(
+                    str(k), self.xml_type[val_type], node_or_edge, default, mode
+                )
+                for val, start, end in v:
+                    e = Element("attvalue")
+                    e.attrib["for"] = attr_id
+                    e.attrib["value"] = str(val)
+                    # Handle nan, inf, -inf differently
+                    if val_type == float:
+                        if e.attrib["value"] == "inf":
+                            e.attrib["value"] = "INF"
+                        elif e.attrib["value"] == "nan":
+                            e.attrib["value"] = "NaN"
+                        elif e.attrib["value"] == "-inf":
+                            e.attrib["value"] = "-INF"
+                    if start is not None:
+                        e.attrib["start"] = str(start)
+                    if end is not None:
+                        e.attrib["end"] = str(end)
+                    attvalues.append(e)
+            else:
+                # static data
+                mode = "static"
+                attr_id = self.get_attr_id(
+                    str(k), self.xml_type[val_type], node_or_edge, default, mode
+                )
+                e = Element("attvalue")
+                e.attrib["for"] = attr_id
+                if isinstance(v, bool):
+                    e.attrib["value"] = str(v).lower()
+                else:
+                    e.attrib["value"] = str(v)
+                    # Handle float nan, inf, -inf differently
+                    if val_type == float:
+                        if e.attrib["value"] == "inf":
+                            e.attrib["value"] = "INF"
+                        elif e.attrib["value"] == "nan":
+                            e.attrib["value"] = "NaN"
+                        elif e.attrib["value"] == "-inf":
+                            e.attrib["value"] = "-INF"
+                attvalues.append(e)
+        xml_obj.append(attvalues)
+        return data
+
+    def get_attr_id(self, title, attr_type, edge_or_node, default, mode):
+        # find the id of the attribute or generate a new id
+        try:
+            return self.attr[edge_or_node][mode][title]
+        except KeyError:
+            # generate new id
+            new_id = str(next(self.attr_id))
+            self.attr[edge_or_node][mode][title] = new_id
+            attr_kwargs = {"id": new_id, "title": title, "type": attr_type}
+            attribute = Element("attribute", **attr_kwargs)
+            # add subelement for data default value if present
+            default_title = default.get(title)
+            if default_title is not None:
+                default_element = Element("default")
+                default_element.text = str(default_title)
+                attribute.append(default_element)
+            # new insert it into the XML
+            attributes_element = None
+            for a in self.graph_element.findall("attributes"):
+                # find existing attributes element by class and mode
+                a_class = a.get("class")
+                a_mode = a.get("mode", "static")
+                if a_class == edge_or_node and a_mode == mode:
+                    attributes_element = a
+            if attributes_element is None:
+                # create new attributes element
+                attr_kwargs = {"mode": mode, "class": edge_or_node}
+                attributes_element = Element("attributes", **attr_kwargs)
+                self.graph_element.insert(0, attributes_element)
+            attributes_element.append(attribute)
+        return new_id
+
+    def add_viz(self, element, node_data):
+        viz = node_data.pop("viz", False)
+        if viz:
+            color = viz.get("color")
+            if color is not None:
+                if self.VERSION == "1.1":
+                    e = Element(
+                        f"{{{self.NS_VIZ}}}color",
+                        r=str(color.get("r")),
+                        g=str(color.get("g")),
+                        b=str(color.get("b")),
+                    )
+                else:
+                    e = Element(
+                        f"{{{self.NS_VIZ}}}color",
+                        r=str(color.get("r")),
+                        g=str(color.get("g")),
+                        b=str(color.get("b")),
+                        a=str(color.get("a")),
+                    )
+                element.append(e)
+
+            size = viz.get("size")
+            if size is not None:
+                e = Element(f"{{{self.NS_VIZ}}}size", value=str(size))
+                element.append(e)
+
+            thickness = viz.get("thickness")
+            if thickness is not None:
+                e = Element(f"{{{self.NS_VIZ}}}thickness", value=str(thickness))
+                element.append(e)
+
+            shape = viz.get("shape")
+            if shape is not None:
+                if shape.startswith("http"):
+                    e = Element(
+                        f"{{{self.NS_VIZ}}}shape", value="image", uri=str(shape)
+                    )
+                else:
+                    e = Element(f"{{{self.NS_VIZ}}}shape", value=str(shape))
+                element.append(e)
+
+            position = viz.get("position")
+            if position is not None:
+                e = Element(
+                    f"{{{self.NS_VIZ}}}position",
+                    x=str(position.get("x")),
+                    y=str(position.get("y")),
+                    z=str(position.get("z")),
+                )
+                element.append(e)
+        return node_data
+
+    def add_parents(self, node_element, node_data):
+        parents = node_data.pop("parents", False)
+        if parents:
+            parents_element = Element("parents")
+            for p in parents:
+                e = Element("parent")
+                e.attrib["for"] = str(p)
+                parents_element.append(e)
+            node_element.append(parents_element)
+        return node_data
+
+    def add_slices(self, node_or_edge_element, node_or_edge_data):
+        slices = node_or_edge_data.pop("slices", False)
+        if slices:
+            slices_element = Element("slices")
+            for start, end in slices:
+                e = Element("slice", start=str(start), end=str(end))
+                slices_element.append(e)
+            node_or_edge_element.append(slices_element)
+        return node_or_edge_data
+
+    def add_spells(self, node_or_edge_element, node_or_edge_data):
+        spells = node_or_edge_data.pop("spells", False)
+        if spells:
+            spells_element = Element("spells")
+            for start, end in spells:
+                e = Element("spell")
+                if start is not None:
+                    e.attrib["start"] = str(start)
+                    self.alter_graph_mode_timeformat(start)
+                if end is not None:
+                    e.attrib["end"] = str(end)
+                    self.alter_graph_mode_timeformat(end)
+                spells_element.append(e)
+            node_or_edge_element.append(spells_element)
+        return node_or_edge_data
+
+    def alter_graph_mode_timeformat(self, start_or_end):
+        # If 'start' or 'end' appears, alter Graph mode to dynamic and
+        # set timeformat
+        if self.graph_element.get("mode") == "static":
+            if start_or_end is not None:
+                if isinstance(start_or_end, str):
+                    timeformat = "date"
+                elif isinstance(start_or_end, float):
+                    timeformat = "double"
+                elif isinstance(start_or_end, int):
+                    timeformat = "long"
+                else:
+                    raise nx.NetworkXError(
+                        "timeformat should be of the type int, float or str"
+                    )
+                self.graph_element.set("timeformat", timeformat)
+                self.graph_element.set("mode", "dynamic")
+
+    def write(self, fh):
+        # Serialize graph G in GEXF to the open fh
+        if self.prettyprint:
+            self.indent(self.xml)
+        document = ElementTree(self.xml)
+        document.write(fh, encoding=self.encoding, xml_declaration=True)
+
+    def indent(self, elem, level=0):
+        # in-place prettyprint formatter
+        i = "\n" + "  " * level
+        if len(elem):
+            if not elem.text or not elem.text.strip():
+                elem.text = i + "  "
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+            for elem in elem:
+                self.indent(elem, level + 1)
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+        else:
+            if level and (not elem.tail or not elem.tail.strip()):
+                elem.tail = i
+
+
+class GEXFReader(GEXF):
+    # Class to read GEXF format files
+    # use read_gexf() function
+    def __init__(self, node_type=None, version="1.2draft"):
+        self.construct_types()
+        self.node_type = node_type
+        # assume simple graph and test for multigraph on read
+        self.simple_graph = True
+        self.set_version(version)
+
+    def __call__(self, stream):
+        self.xml = ElementTree(file=stream)
+        g = self.xml.find(f"{{{self.NS_GEXF}}}graph")
+        if g is not None:
+            return self.make_graph(g)
+        # try all the versions
+        for version in self.versions:
+            self.set_version(version)
+            g = self.xml.find(f"{{{self.NS_GEXF}}}graph")
+            if g is not None:
+                return self.make_graph(g)
+        raise nx.NetworkXError("No <graph> element in GEXF file.")
+
+    def make_graph(self, graph_xml):
+        # start with empty DiGraph or MultiDiGraph
+        edgedefault = graph_xml.get("defaultedgetype", None)
+        if edgedefault == "directed":
+            G = nx.MultiDiGraph()
+        else:
+            G = nx.MultiGraph()
+
+        # graph attributes
+        graph_name = graph_xml.get("name", "")
+        if graph_name != "":
+            G.graph["name"] = graph_name
+        graph_start = graph_xml.get("start")
+        if graph_start is not None:
+            G.graph["start"] = graph_start
+        graph_end = graph_xml.get("end")
+        if graph_end is not None:
+            G.graph["end"] = graph_end
+        graph_mode = graph_xml.get("mode", "")
+        if graph_mode == "dynamic":
+            G.graph["mode"] = "dynamic"
+        else:
+            G.graph["mode"] = "static"
+
+        # timeformat
+        self.timeformat = graph_xml.get("timeformat")
+        if self.timeformat == "date":
+            self.timeformat = "string"
+
+        # node and edge attributes
+        attributes_elements = graph_xml.findall(f"{{{self.NS_GEXF}}}attributes")
+        # dictionaries to hold attributes and attribute defaults
+        node_attr = {}
+        node_default = {}
+        edge_attr = {}
+        edge_default = {}
+        for a in attributes_elements:
+            attr_class = a.get("class")
+            if attr_class == "node":
+                na, nd = self.find_gexf_attributes(a)
+                node_attr.update(na)
+                node_default.update(nd)
+                G.graph["node_default"] = node_default
+            elif attr_class == "edge":
+                ea, ed = self.find_gexf_attributes(a)
+                edge_attr.update(ea)
+                edge_default.update(ed)
+                G.graph["edge_default"] = edge_default
+            else:
+                raise  # unknown attribute class
+
+        # Hack to handle Gephi0.7beta bug
+        # add weight attribute
+        ea = {"weight": {"type": "double", "mode": "static", "title": "weight"}}
+        ed = {}
+        edge_attr.update(ea)
+        edge_default.update(ed)
+        G.graph["edge_default"] = edge_default
+
+        # add nodes
+        nodes_element = graph_xml.find(f"{{{self.NS_GEXF}}}nodes")
+        if nodes_element is not None:
+            for node_xml in nodes_element.findall(f"{{{self.NS_GEXF}}}node"):
+                self.add_node(G, node_xml, node_attr)
+
+        # add edges
+        edges_element = graph_xml.find(f"{{{self.NS_GEXF}}}edges")
+        if edges_element is not None:
+            for edge_xml in edges_element.findall(f"{{{self.NS_GEXF}}}edge"):
+                self.add_edge(G, edge_xml, edge_attr)
+
+        # switch to Graph or DiGraph if no parallel edges were found.
+        if self.simple_graph:
+            if G.is_directed():
+                G = nx.DiGraph(G)
+            else:
+                G = nx.Graph(G)
+        return G
+
+    def add_node(self, G, node_xml, node_attr, node_pid=None):
+        # add a single node with attributes to the graph
+
+        # get attributes and subattributues for node
+        data = self.decode_attr_elements(node_attr, node_xml)
+        data = self.add_parents(data, node_xml)  # add any parents
+        if self.VERSION == "1.1":
+            data = self.add_slices(data, node_xml)  # add slices
+        else:
+            data = self.add_spells(data, node_xml)  # add spells
+        data = self.add_viz(data, node_xml)  # add viz
+        data = self.add_start_end(data, node_xml)  # add start/end
+
+        # find the node id and cast it to the appropriate type
+        node_id = node_xml.get("id")
+        if self.node_type is not None:
+            node_id = self.node_type(node_id)
+
+        # every node should have a label
+        node_label = node_xml.get("label")
+        data["label"] = node_label
+
+        # parent node id
+        node_pid = node_xml.get("pid", node_pid)
+        if node_pid is not None:
+            data["pid"] = node_pid
+
+        # check for subnodes, recursive
+        subnodes = node_xml.find(f"{{{self.NS_GEXF}}}nodes")
+        if subnodes is not None:
+            for node_xml in subnodes.findall(f"{{{self.NS_GEXF}}}node"):
+                self.add_node(G, node_xml, node_attr, node_pid=node_id)
+
+        G.add_node(node_id, **data)
+
+    def add_start_end(self, data, xml):
+        # start and end times
+        ttype = self.timeformat
+        node_start = xml.get("start")
+        if node_start is not None:
+            data["start"] = self.python_type[ttype](node_start)
+        node_end = xml.get("end")
+        if node_end is not None:
+            data["end"] = self.python_type[ttype](node_end)
+        return data
+
+    def add_viz(self, data, node_xml):
+        # add viz element for node
+        viz = {}
+        color = node_xml.find(f"{{{self.NS_VIZ}}}color")
+        if color is not None:
+            if self.VERSION == "1.1":
+                viz["color"] = {
+                    "r": int(color.get("r")),
+                    "g": int(color.get("g")),
+                    "b": int(color.get("b")),
+                }
+            else:
+                viz["color"] = {
+                    "r": int(color.get("r")),
+                    "g": int(color.get("g")),
+                    "b": int(color.get("b")),
+                    "a": float(color.get("a", 1)),
+                }
+
+        size = node_xml.find(f"{{{self.NS_VIZ}}}size")
+        if size is not None:
+            viz["size"] = float(size.get("value"))
+
+        thickness = node_xml.find(f"{{{self.NS_VIZ}}}thickness")
+        if thickness is not None:
+            viz["thickness"] = float(thickness.get("value"))
+
+        shape = node_xml.find(f"{{{self.NS_VIZ}}}shape")
+        if shape is not None:
+            viz["shape"] = shape.get("shape")
+            if viz["shape"] == "image":
+                viz["shape"] = shape.get("uri")
+
+        position = node_xml.find(f"{{{self.NS_VIZ}}}position")
+        if position is not None:
+            viz["position"] = {
+                "x": float(position.get("x", 0)),
+                "y": float(position.get("y", 0)),
+                "z": float(position.get("z", 0)),
+            }
+
+        if len(viz) > 0:
+            data["viz"] = viz
+        return data
+
+    def add_parents(self, data, node_xml):
+        parents_element = node_xml.find(f"{{{self.NS_GEXF}}}parents")
+        if parents_element is not None:
+            data["parents"] = []
+            for p in parents_element.findall(f"{{{self.NS_GEXF}}}parent"):
+                parent = p.get("for")
+                data["parents"].append(parent)
+        return data
+
+    def add_slices(self, data, node_or_edge_xml):
+        slices_element = node_or_edge_xml.find(f"{{{self.NS_GEXF}}}slices")
+        if slices_element is not None:
+            data["slices"] = []
+            for s in slices_element.findall(f"{{{self.NS_GEXF}}}slice"):
+                start = s.get("start")
+                end = s.get("end")
+                data["slices"].append((start, end))
+        return data
+
+    def add_spells(self, data, node_or_edge_xml):
+        spells_element = node_or_edge_xml.find(f"{{{self.NS_GEXF}}}spells")
+        if spells_element is not None:
+            data["spells"] = []
+            ttype = self.timeformat
+            for s in spells_element.findall(f"{{{self.NS_GEXF}}}spell"):
+                start = self.python_type[ttype](s.get("start"))
+                end = self.python_type[ttype](s.get("end"))
+                data["spells"].append((start, end))
+        return data
+
+    def add_edge(self, G, edge_element, edge_attr):
+        # add an edge to the graph
+
+        # raise error if we find mixed directed and undirected edges
+        edge_direction = edge_element.get("type")
+        if G.is_directed() and edge_direction == "undirected":
+            raise nx.NetworkXError("Undirected edge found in directed graph.")
+        if (not G.is_directed()) and edge_direction == "directed":
+            raise nx.NetworkXError("Directed edge found in undirected graph.")
+
+        # Get source and target and recast type if required
+        source = edge_element.get("source")
+        target = edge_element.get("target")
+        if self.node_type is not None:
+            source = self.node_type(source)
+            target = self.node_type(target)
+
+        data = self.decode_attr_elements(edge_attr, edge_element)
+        data = self.add_start_end(data, edge_element)
+
+        if self.VERSION == "1.1":
+            data = self.add_slices(data, edge_element)  # add slices
+        else:
+            data = self.add_spells(data, edge_element)  # add spells
+
+        # GEXF stores edge ids as an attribute
+        # NetworkX uses them as keys in multigraphs
+        # if networkx_key is not specified as an attribute
+        edge_id = edge_element.get("id")
+        if edge_id is not None:
+            data["id"] = edge_id
+
+        # check if there is a 'multigraph_key' and use that as edge_id
+        multigraph_key = data.pop("networkx_key", None)
+        if multigraph_key is not None:
+            edge_id = multigraph_key
+
+        weight = edge_element.get("weight")
+        if weight is not None:
+            data["weight"] = float(weight)
+
+        edge_label = edge_element.get("label")
+        if edge_label is not None:
+            data["label"] = edge_label
+
+        if G.has_edge(source, target):
+            # seen this edge before - this is a multigraph
+            self.simple_graph = False
+        G.add_edge(source, target, key=edge_id, **data)
+        if edge_direction == "mutual":
+            G.add_edge(target, source, key=edge_id, **data)
+
+    def decode_attr_elements(self, gexf_keys, obj_xml):
+        # Use the key information to decode the attr XML
+        attr = {}
+        # look for outer '<attvalues>' element
+        attr_element = obj_xml.find(f"{{{self.NS_GEXF}}}attvalues")
+        if attr_element is not None:
+            # loop over <attvalue> elements
+            for a in attr_element.findall(f"{{{self.NS_GEXF}}}attvalue"):
+                key = a.get("for")  # for is required
+                try:  # should be in our gexf_keys dictionary
+                    title = gexf_keys[key]["title"]
+                except KeyError as err:
+                    raise nx.NetworkXError(f"No attribute defined for={key}.") from err
+                atype = gexf_keys[key]["type"]
+                value = a.get("value")
+                if atype == "boolean":
+                    value = self.convert_bool[value]
+                else:
+                    value = self.python_type[atype](value)
+                if gexf_keys[key]["mode"] == "dynamic":
+                    # for dynamic graphs use list of three-tuples
+                    # [(value1,start1,end1), (value2,start2,end2), etc]
+                    ttype = self.timeformat
+                    start = self.python_type[ttype](a.get("start"))
+                    end = self.python_type[ttype](a.get("end"))
+                    if title in attr:
+                        attr[title].append((value, start, end))
+                    else:
+                        attr[title] = [(value, start, end)]
+                else:
+                    # for static graphs just assign the value
+                    attr[title] = value
+        return attr
+
+    def find_gexf_attributes(self, attributes_element):
+        # Extract all the attributes and defaults
+        attrs = {}
+        defaults = {}
+        mode = attributes_element.get("mode")
+        for k in attributes_element.findall(f"{{{self.NS_GEXF}}}attribute"):
+            attr_id = k.get("id")
+            title = k.get("title")
+            atype = k.get("type")
+            attrs[attr_id] = {"title": title, "type": atype, "mode": mode}
+            # check for the 'default' subelement of key element and add
+            default = k.find(f"{{{self.NS_GEXF}}}default")
+            if default is not None:
+                if atype == "boolean":
+                    value = self.convert_bool[default.text]
+                else:
+                    value = self.python_type[atype](default.text)
+                defaults[title] = value
+        return attrs, defaults
+
+
+def relabel_gexf_graph(G):
+    """Relabel graph using "label" node keyword for node label.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph read from GEXF data
+
+    Returns
+    -------
+    H : graph
+      A NetworkX graph with relabeled nodes
+
+    Raises
+    ------
+    NetworkXError
+        If node labels are missing or not unique while relabel=True.
+
+    Notes
+    -----
+    This function relabels the nodes in a NetworkX graph with the
+    "label" attribute.  It also handles relabeling the specific GEXF
+    node attributes "parents", and "pid".
+    """
+    # build mapping of node labels, do some error checking
+    try:
+        mapping = [(u, G.nodes[u]["label"]) for u in G]
+    except KeyError as err:
+        raise nx.NetworkXError(
+            "Failed to relabel nodes: missing node labels found. Use relabel=False."
+        ) from err
+    x, y = zip(*mapping)
+    if len(set(y)) != len(G):
+        raise nx.NetworkXError(
+            "Failed to relabel nodes: "
+            "duplicate node labels found. "
+            "Use relabel=False."
+        )
+    mapping = dict(mapping)
+    H = nx.relabel_nodes(G, mapping)
+    # relabel attributes
+    for n in G:
+        m = mapping[n]
+        H.nodes[m]["id"] = n
+        H.nodes[m].pop("label")
+        if "pid" in H.nodes[m]:
+            H.nodes[m]["pid"] = mapping[G.nodes[n]["pid"]]
+        if "parents" in H.nodes[m]:
+            H.nodes[m]["parents"] = [mapping[p] for p in G.nodes[n]["parents"]]
+    return H
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/gml.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/gml.py
new file mode 100644
index 0000000..1a14b80
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/gml.py
@@ -0,0 +1,856 @@
+"""
+Read graphs in GML format.
+
+"GML, the Graph Modelling Language, is our proposal for a portable
+file format for graphs. GML's key features are portability, simple
+syntax, extensibility and flexibility. A GML file consists of a
+hierarchical key-value lists. Graphs can be annotated with arbitrary
+data structures. The idea for a common file format was born at the
+GD'95; this proposal is the outcome of many discussions. GML is the
+standard file format in the Graphlet graph editor system. It has been
+overtaken and adapted by several other systems for drawing graphs."
+
+GML files are stored using a 7-bit ASCII encoding with any extended
+ASCII characters (iso8859-1) appearing as HTML character entities.
+You will need to give some thought into how the exported data should
+interact with different languages and even different Python versions.
+Re-importing from gml is also a concern.
+
+Without specifying a `stringizer`/`destringizer`, the code is capable of
+writing `int`/`float`/`str`/`dict`/`list` data as required by the GML 
+specification.  For writing other data types, and for reading data other
+than `str` you need to explicitly supply a `stringizer`/`destringizer`.
+
+For additional documentation on the GML file format, please see the
+`GML website <https://web.archive.org/web/20190207140002/http://www.fim.uni-passau.de/index.php?id=17297&L=1>`_.
+
+Several example graphs in GML format may be found on Mark Newman's
+`Network data page <http://www-personal.umich.edu/~mejn/netdata/>`_.
+"""
+import html.entities as htmlentitydefs
+import re
+import warnings
+from ast import literal_eval
+from collections import defaultdict
+from enum import Enum
+from io import StringIO
+from typing import Any, NamedTuple
+
+import networkx as nx
+from networkx.exception import NetworkXError
+from networkx.utils import open_file
+
+__all__ = ["read_gml", "parse_gml", "generate_gml", "write_gml"]
+
+
+def escape(text):
+    """Use XML character references to escape characters.
+
+    Use XML character references for unprintable or non-ASCII
+    characters, double quotes and ampersands in a string
+    """
+
+    def fixup(m):
+        ch = m.group(0)
+        return "&#" + str(ord(ch)) + ";"
+
+    text = re.sub('[^ -~]|[&"]', fixup, text)
+    return text if isinstance(text, str) else str(text)
+
+
+def unescape(text):
+    """Replace XML character references with the referenced characters"""
+
+    def fixup(m):
+        text = m.group(0)
+        if text[1] == "#":
+            # Character reference
+            if text[2] == "x":
+                code = int(text[3:-1], 16)
+            else:
+                code = int(text[2:-1])
+        else:
+            # Named entity
+            try:
+                code = htmlentitydefs.name2codepoint[text[1:-1]]
+            except KeyError:
+                return text  # leave unchanged
+        try:
+            return chr(code)
+        except (ValueError, OverflowError):
+            return text  # leave unchanged
+
+    return re.sub("&(?:[0-9A-Za-z]+|#(?:[0-9]+|x[0-9A-Fa-f]+));", fixup, text)
+
+
+def literal_destringizer(rep):
+    """Convert a Python literal to the value it represents.
+
+    Parameters
+    ----------
+    rep : string
+        A Python literal.
+
+    Returns
+    -------
+    value : object
+        The value of the Python literal.
+
+    Raises
+    ------
+    ValueError
+        If `rep` is not a Python literal.
+    """
+    msg = "literal_destringizer is deprecated and will be removed in 3.0."
+    warnings.warn(msg, DeprecationWarning)
+    if isinstance(rep, str):
+        orig_rep = rep
+        try:
+            return literal_eval(rep)
+        except SyntaxError as err:
+            raise ValueError(f"{orig_rep!r} is not a valid Python literal") from err
+    else:
+        raise ValueError(f"{rep!r} is not a string")
+
+
+@open_file(0, mode="rb")
+def read_gml(path, label="label", destringizer=None):
+    """Read graph in GML format from `path`.
+
+    Parameters
+    ----------
+    path : filename or filehandle
+        The filename or filehandle to read from.
+
+    label : string, optional
+        If not None, the parsed nodes will be renamed according to node
+        attributes indicated by `label`. Default value: 'label'.
+
+    destringizer : callable, optional
+        A `destringizer` that recovers values stored as strings in GML. If it
+        cannot convert a string to a value, a `ValueError` is raised. Default
+        value : None.
+
+    Returns
+    -------
+    G : NetworkX graph
+        The parsed graph.
+
+    Raises
+    ------
+    NetworkXError
+        If the input cannot be parsed.
+
+    See Also
+    --------
+    write_gml, parse_gml
+    literal_destringizer
+
+    Notes
+    -----
+    GML files are stored using a 7-bit ASCII encoding with any extended
+    ASCII characters (iso8859-1) appearing as HTML character entities.
+    Without specifying a `stringizer`/`destringizer`, the code is capable of
+    writing `int`/`float`/`str`/`dict`/`list` data as required by the GML
+    specification.  For writing other data types, and for reading data other
+    than `str` you need to explicitly supply a `stringizer`/`destringizer`.
+
+    For additional documentation on the GML file format, please see the
+    `GML url <https://web.archive.org/web/20190207140002/http://www.fim.uni-passau.de/index.php?id=17297&L=1>`_.
+
+    See the module docstring :mod:`networkx.readwrite.gml` for more details.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_gml(G, "test.gml")
+
+    GML values are interpreted as strings by default:
+
+    >>> H = nx.read_gml("test.gml")
+    >>> H.nodes
+    NodeView(('0', '1', '2', '3'))
+
+    When a `destringizer` is provided, GML values are converted to the provided type.
+    For example, integer nodes can be recovered as shown below:
+
+    >>> J = nx.read_gml("test.gml", destringizer=int)
+    >>> J.nodes
+    NodeView((0, 1, 2, 3))
+
+    """
+
+    def filter_lines(lines):
+        for line in lines:
+            try:
+                line = line.decode("ascii")
+            except UnicodeDecodeError as err:
+                raise NetworkXError("input is not ASCII-encoded") from err
+            if not isinstance(line, str):
+                lines = str(lines)
+            if line and line[-1] == "\n":
+                line = line[:-1]
+            yield line
+
+    G = parse_gml_lines(filter_lines(path), label, destringizer)
+    return G
+
+
+def parse_gml(lines, label="label", destringizer=None):
+    """Parse GML graph from a string or iterable.
+
+    Parameters
+    ----------
+    lines : string or iterable of strings
+       Data in GML format.
+
+    label : string, optional
+        If not None, the parsed nodes will be renamed according to node
+        attributes indicated by `label`. Default value: 'label'.
+
+    destringizer : callable, optional
+        A `destringizer` that recovers values stored as strings in GML. If it
+        cannot convert a string to a value, a `ValueError` is raised. Default
+        value : None.
+
+    Returns
+    -------
+    G : NetworkX graph
+        The parsed graph.
+
+    Raises
+    ------
+    NetworkXError
+        If the input cannot be parsed.
+
+    See Also
+    --------
+    write_gml, read_gml
+
+    Notes
+    -----
+    This stores nested GML attributes as dictionaries in the NetworkX graph,
+    node, and edge attribute structures.
+
+    GML files are stored using a 7-bit ASCII encoding with any extended
+    ASCII characters (iso8859-1) appearing as HTML character entities.
+    Without specifying a `stringizer`/`destringizer`, the code is capable of
+    writing `int`/`float`/`str`/`dict`/`list` data as required by the GML
+    specification.  For writing other data types, and for reading data other
+    than `str` you need to explicitly supply a `stringizer`/`destringizer`.
+
+    For additional documentation on the GML file format, please see the
+    `GML url <https://web.archive.org/web/20190207140002/http://www.fim.uni-passau.de/index.php?id=17297&L=1>`_.
+
+    See the module docstring :mod:`networkx.readwrite.gml` for more details.
+    """
+
+    def decode_line(line):
+        if isinstance(line, bytes):
+            try:
+                line.decode("ascii")
+            except UnicodeDecodeError as err:
+                raise NetworkXError("input is not ASCII-encoded") from err
+        if not isinstance(line, str):
+            line = str(line)
+        return line
+
+    def filter_lines(lines):
+        if isinstance(lines, str):
+            lines = decode_line(lines)
+            lines = lines.splitlines()
+            yield from lines
+        else:
+            for line in lines:
+                line = decode_line(line)
+                if line and line[-1] == "\n":
+                    line = line[:-1]
+                if line.find("\n") != -1:
+                    raise NetworkXError("input line contains newline")
+                yield line
+
+    G = parse_gml_lines(filter_lines(lines), label, destringizer)
+    return G
+
+
+class Pattern(Enum):
+    """encodes the index of each token-matching pattern in `tokenize`."""
+
+    KEYS = 0
+    REALS = 1
+    INTS = 2
+    STRINGS = 3
+    DICT_START = 4
+    DICT_END = 5
+    COMMENT_WHITESPACE = 6
+
+
+class Token(NamedTuple):
+    category: Pattern
+    value: Any
+    line: int
+    position: int
+
+
+LIST_START_VALUE = "_networkx_list_start"
+
+
+def parse_gml_lines(lines, label, destringizer):
+    """Parse GML `lines` into a graph."""
+
+    def tokenize():
+        patterns = [
+            r"[A-Za-z][0-9A-Za-z_]*\b",  # keys
+            # reals
+            r"[+-]?(?:[0-9]*\.[0-9]+|[0-9]+\.[0-9]*|INF)(?:[Ee][+-]?[0-9]+)?",
+            r"[+-]?[0-9]+",  # ints
+            r'".*?"',  # strings
+            r"\[",  # dict start
+            r"\]",  # dict end
+            r"#.*$|\s+",  # comments and whitespaces
+        ]
+        tokens = re.compile("|".join(f"({pattern})" for pattern in patterns))
+        lineno = 0
+        for line in lines:
+            length = len(line)
+            pos = 0
+            while pos < length:
+                match = tokens.match(line, pos)
+                if match is None:
+                    m = f"cannot tokenize {line[pos:]} at ({lineno + 1}, {pos + 1})"
+                    raise NetworkXError(m)
+                for i in range(len(patterns)):
+                    group = match.group(i + 1)
+                    if group is not None:
+                        if i == 0:  # keys
+                            value = group.rstrip()
+                        elif i == 1:  # reals
+                            value = float(group)
+                        elif i == 2:  # ints
+                            value = int(group)
+                        else:
+                            value = group
+                        if i != 6:  # comments and whitespaces
+                            yield Token(Pattern(i), value, lineno + 1, pos + 1)
+                        pos += len(group)
+                        break
+            lineno += 1
+        yield Token(None, None, lineno + 1, 1)  # EOF
+
+    def unexpected(curr_token, expected):
+        category, value, lineno, pos = curr_token
+        value = repr(value) if value is not None else "EOF"
+        raise NetworkXError(f"expected {expected}, found {value} at ({lineno}, {pos})")
+
+    def consume(curr_token, category, expected):
+        if curr_token.category == category:
+            return next(tokens)
+        unexpected(curr_token, expected)
+
+    def parse_kv(curr_token):
+        dct = defaultdict(list)
+        while curr_token.category == Pattern.KEYS:
+            key = curr_token.value
+            curr_token = next(tokens)
+            category = curr_token.category
+            if category == Pattern.REALS or category == Pattern.INTS:
+                value = curr_token.value
+                curr_token = next(tokens)
+            elif category == Pattern.STRINGS:
+                value = unescape(curr_token.value[1:-1])
+                if destringizer:
+                    try:
+                        value = destringizer(value)
+                    except ValueError:
+                        pass
+                curr_token = next(tokens)
+            elif category == Pattern.DICT_START:
+                curr_token, value = parse_dict(curr_token)
+            else:
+                # Allow for string convertible id and label values
+                if key in ("id", "label", "source", "target"):
+                    try:
+                        # String convert the token value
+                        value = unescape(str(curr_token.value))
+                        if destringizer:
+                            try:
+                                value = destringizer(value)
+                            except ValueError:
+                                pass
+                        curr_token = next(tokens)
+                    except Exception:
+                        msg = (
+                            "an int, float, string, '[' or string"
+                            + " convertable ASCII value for node id or label"
+                        )
+                        unexpected(curr_token, msg)
+                # Special handling for nan and infinity.  Since the gml language
+                # defines unquoted strings as keys, the numeric and string branches
+                # are skipped and we end up in this special branch, so we need to
+                # convert the current token value to a float for NAN and plain INF.
+                # +/-INF are handled in the pattern for 'reals' in tokenize().  This
+                # allows labels and values to be nan or infinity, but not keys.
+                elif curr_token.value in {"NAN", "INF"}:
+                    value = float(curr_token.value)
+                    curr_token = next(tokens)
+                else:  # Otherwise error out
+                    unexpected(curr_token, "an int, float, string or '['")
+            dct[key].append(value)
+
+        def clean_dict_value(value):
+            if not isinstance(value, list):
+                return value
+            if len(value) == 1:
+                return value[0]
+            if value[0] == LIST_START_VALUE:
+                return value[1:]
+            return value
+
+        dct = {key: clean_dict_value(value) for key, value in dct.items()}
+        return curr_token, dct
+
+    def parse_dict(curr_token):
+        # dict start
+        curr_token = consume(curr_token, Pattern.DICT_START, "'['")
+        # dict contents
+        curr_token, dct = parse_kv(curr_token)
+        # dict end
+        curr_token = consume(curr_token, Pattern.DICT_END, "']'")
+        return curr_token, dct
+
+    def parse_graph():
+        curr_token, dct = parse_kv(next(tokens))
+        if curr_token.category is not None:  # EOF
+            unexpected(curr_token, "EOF")
+        if "graph" not in dct:
+            raise NetworkXError("input contains no graph")
+        graph = dct["graph"]
+        if isinstance(graph, list):
+            raise NetworkXError("input contains more than one graph")
+        return graph
+
+    tokens = tokenize()
+    graph = parse_graph()
+
+    directed = graph.pop("directed", False)
+    multigraph = graph.pop("multigraph", False)
+    if not multigraph:
+        G = nx.DiGraph() if directed else nx.Graph()
+    else:
+        G = nx.MultiDiGraph() if directed else nx.MultiGraph()
+    graph_attr = {k: v for k, v in graph.items() if k not in ("node", "edge")}
+    G.graph.update(graph_attr)
+
+    def pop_attr(dct, category, attr, i):
+        try:
+            return dct.pop(attr)
+        except KeyError as err:
+            raise NetworkXError(f"{category} #{i} has no {attr!r} attribute") from err
+
+    nodes = graph.get("node", [])
+    mapping = {}
+    node_labels = set()
+    for i, node in enumerate(nodes if isinstance(nodes, list) else [nodes]):
+        id = pop_attr(node, "node", "id", i)
+        if id in G:
+            raise NetworkXError(f"node id {id!r} is duplicated")
+        if label is not None and label != "id":
+            node_label = pop_attr(node, "node", label, i)
+            if node_label in node_labels:
+                raise NetworkXError(f"node label {node_label!r} is duplicated")
+            node_labels.add(node_label)
+            mapping[id] = node_label
+        G.add_node(id, **node)
+
+    edges = graph.get("edge", [])
+    for i, edge in enumerate(edges if isinstance(edges, list) else [edges]):
+        source = pop_attr(edge, "edge", "source", i)
+        target = pop_attr(edge, "edge", "target", i)
+        if source not in G:
+            raise NetworkXError(f"edge #{i} has undefined source {source!r}")
+        if target not in G:
+            raise NetworkXError(f"edge #{i} has undefined target {target!r}")
+        if not multigraph:
+            if not G.has_edge(source, target):
+                G.add_edge(source, target, **edge)
+            else:
+                arrow = "->" if directed else "--"
+                msg = f"edge #{i} ({source!r}{arrow}{target!r}) is duplicated"
+                raise nx.NetworkXError(msg)
+        else:
+            key = edge.pop("key", None)
+            if key is not None and G.has_edge(source, target, key):
+                arrow = "->" if directed else "--"
+                msg = f"edge #{i} ({source!r}{arrow}{target!r}, {key!r})"
+                msg2 = 'Hint: If multigraph add "multigraph 1" to file header.'
+                raise nx.NetworkXError(msg + " is duplicated\n" + msg2)
+            G.add_edge(source, target, key, **edge)
+
+    if label is not None and label != "id":
+        G = nx.relabel_nodes(G, mapping)
+    return G
+
+
+def literal_stringizer(value):
+    """Convert a `value` to a Python literal in GML representation.
+
+    Parameters
+    ----------
+    value : object
+        The `value` to be converted to GML representation.
+
+    Returns
+    -------
+    rep : string
+        A double-quoted Python literal representing value. Unprintable
+        characters are replaced by XML character references.
+
+    Raises
+    ------
+    ValueError
+        If `value` cannot be converted to GML.
+
+    Notes
+    -----
+    `literal_stringizer` is largely the same as `repr` in terms of
+    functionality but attempts prefix `unicode` and `bytes` literals with
+    `u` and `b` to provide better interoperability of data generated by
+    Python 2 and Python 3.
+
+    The original value can be recovered using the
+    :func:`networkx.readwrite.gml.literal_destringizer` function.
+    """
+    msg = "literal_stringizer is deprecated and will be removed in 3.0."
+    warnings.warn(msg, DeprecationWarning)
+
+    def stringize(value):
+        if isinstance(value, (int, bool)) or value is None:
+            if value is True:  # GML uses 1/0 for boolean values.
+                buf.write(str(1))
+            elif value is False:
+                buf.write(str(0))
+            else:
+                buf.write(str(value))
+        elif isinstance(value, str):
+            text = repr(value)
+            if text[0] != "u":
+                try:
+                    value.encode("latin1")
+                except UnicodeEncodeError:
+                    text = "u" + text
+            buf.write(text)
+        elif isinstance(value, (float, complex, str, bytes)):
+            buf.write(repr(value))
+        elif isinstance(value, list):
+            buf.write("[")
+            first = True
+            for item in value:
+                if not first:
+                    buf.write(",")
+                else:
+                    first = False
+                stringize(item)
+            buf.write("]")
+        elif isinstance(value, tuple):
+            if len(value) > 1:
+                buf.write("(")
+                first = True
+                for item in value:
+                    if not first:
+                        buf.write(",")
+                    else:
+                        first = False
+                    stringize(item)
+                buf.write(")")
+            elif value:
+                buf.write("(")
+                stringize(value[0])
+                buf.write(",)")
+            else:
+                buf.write("()")
+        elif isinstance(value, dict):
+            buf.write("{")
+            first = True
+            for key, value in value.items():
+                if not first:
+                    buf.write(",")
+                else:
+                    first = False
+                stringize(key)
+                buf.write(":")
+                stringize(value)
+            buf.write("}")
+        elif isinstance(value, set):
+            buf.write("{")
+            first = True
+            for item in value:
+                if not first:
+                    buf.write(",")
+                else:
+                    first = False
+                stringize(item)
+            buf.write("}")
+        else:
+            msg = f"{value!r} cannot be converted into a Python literal"
+            raise ValueError(msg)
+
+    buf = StringIO()
+    stringize(value)
+    return buf.getvalue()
+
+
+def generate_gml(G, stringizer=None):
+    r"""Generate a single entry of the graph `G` in GML format.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The graph to be converted to GML.
+
+    stringizer : callable, optional
+        A `stringizer` which converts non-int/non-float/non-dict values into
+        strings. If it cannot convert a value into a string, it should raise a
+        `ValueError` to indicate that. Default value: None.
+
+    Returns
+    -------
+    lines: generator of strings
+        Lines of GML data. Newlines are not appended.
+
+    Raises
+    ------
+    NetworkXError
+        If `stringizer` cannot convert a value into a string, or the value to
+        convert is not a string while `stringizer` is None.
+
+    See Also
+    --------
+    literal_stringizer
+
+    Notes
+    -----
+    Graph attributes named 'directed', 'multigraph', 'node' or
+    'edge', node attributes named 'id' or 'label', edge attributes
+    named 'source' or 'target' (or 'key' if `G` is a multigraph)
+    are ignored because these attribute names are used to encode the graph
+    structure.
+
+    GML files are stored using a 7-bit ASCII encoding with any extended
+    ASCII characters (iso8859-1) appearing as HTML character entities.
+    Without specifying a `stringizer`/`destringizer`, the code is capable of
+    writing `int`/`float`/`str`/`dict`/`list` data as required by the GML
+    specification.  For writing other data types, and for reading data other
+    than `str` you need to explicitly supply a `stringizer`/`destringizer`.
+
+    For additional documentation on the GML file format, please see the
+    `GML url <https://web.archive.org/web/20190207140002/http://www.fim.uni-passau.de/index.php?id=17297&L=1>`_.
+
+    See the module docstring :mod:`networkx.readwrite.gml` for more details.
+
+    Examples
+    --------
+    >>> G = nx.Graph()
+    >>> G.add_node("1")
+    >>> print("\n".join(nx.generate_gml(G)))
+    graph [
+      node [
+        id 0
+        label "1"
+      ]
+    ]
+    >>> G = nx.OrderedMultiGraph([("a", "b"), ("a", "b")])
+    >>> print("\n".join(nx.generate_gml(G)))
+    graph [
+      multigraph 1
+      node [
+        id 0
+        label "a"
+      ]
+      node [
+        id 1
+        label "b"
+      ]
+      edge [
+        source 0
+        target 1
+        key 0
+      ]
+      edge [
+        source 0
+        target 1
+        key 1
+      ]
+    ]
+    """
+    valid_keys = re.compile("^[A-Za-z][0-9A-Za-z_]*$")
+
+    def stringize(key, value, ignored_keys, indent, in_list=False):
+        if not isinstance(key, str):
+            raise NetworkXError(f"{key!r} is not a string")
+        if not valid_keys.match(key):
+            raise NetworkXError(f"{key!r} is not a valid key")
+        if not isinstance(key, str):
+            key = str(key)
+        if key not in ignored_keys:
+            if isinstance(value, (int, bool)):
+                if key == "label":
+                    yield indent + key + ' "' + str(value) + '"'
+                elif value is True:
+                    # python bool is an instance of int
+                    yield indent + key + " 1"
+                elif value is False:
+                    yield indent + key + " 0"
+                # GML only supports signed 32-bit integers
+                elif value < -(2**31) or value >= 2**31:
+                    yield indent + key + ' "' + str(value) + '"'
+                else:
+                    yield indent + key + " " + str(value)
+            elif isinstance(value, float):
+                text = repr(value).upper()
+                # GML matches INF to keys, so prepend + to INF. Use repr(float(*))
+                # instead of string literal to future proof against changes to repr.
+                if text == repr(float("inf")).upper():
+                    text = "+" + text
+                else:
+                    # GML requires that a real literal contain a decimal point, but
+                    # repr may not output a decimal point when the mantissa is
+                    # integral and hence needs fixing.
+                    epos = text.rfind("E")
+                    if epos != -1 and text.find(".", 0, epos) == -1:
+                        text = text[:epos] + "." + text[epos:]
+                if key == "label":
+                    yield indent + key + ' "' + text + '"'
+                else:
+                    yield indent + key + " " + text
+            elif isinstance(value, dict):
+                yield indent + key + " ["
+                next_indent = indent + "  "
+                for key, value in value.items():
+                    yield from stringize(key, value, (), next_indent)
+                yield indent + "]"
+            elif (
+                isinstance(value, (list, tuple))
+                and key != "label"
+                and value
+                and not in_list
+            ):
+                if len(value) == 1:
+                    yield indent + key + " " + f'"{LIST_START_VALUE}"'
+                for val in value:
+                    yield from stringize(key, val, (), indent, True)
+            else:
+                if stringizer:
+                    try:
+                        value = stringizer(value)
+                    except ValueError as err:
+                        raise NetworkXError(
+                            f"{value!r} cannot be converted into a string"
+                        ) from err
+                if not isinstance(value, str):
+                    raise NetworkXError(f"{value!r} is not a string")
+                yield indent + key + ' "' + escape(value) + '"'
+
+    multigraph = G.is_multigraph()
+    yield "graph ["
+
+    # Output graph attributes
+    if G.is_directed():
+        yield "  directed 1"
+    if multigraph:
+        yield "  multigraph 1"
+    ignored_keys = {"directed", "multigraph", "node", "edge"}
+    for attr, value in G.graph.items():
+        yield from stringize(attr, value, ignored_keys, "  ")
+
+    # Output node data
+    node_id = dict(zip(G, range(len(G))))
+    ignored_keys = {"id", "label"}
+    for node, attrs in G.nodes.items():
+        yield "  node ["
+        yield "    id " + str(node_id[node])
+        yield from stringize("label", node, (), "    ")
+        for attr, value in attrs.items():
+            yield from stringize(attr, value, ignored_keys, "    ")
+        yield "  ]"
+
+    # Output edge data
+    ignored_keys = {"source", "target"}
+    kwargs = {"data": True}
+    if multigraph:
+        ignored_keys.add("key")
+        kwargs["keys"] = True
+    for e in G.edges(**kwargs):
+        yield "  edge ["
+        yield "    source " + str(node_id[e[0]])
+        yield "    target " + str(node_id[e[1]])
+        if multigraph:
+            yield from stringize("key", e[2], (), "    ")
+        for attr, value in e[-1].items():
+            yield from stringize(attr, value, ignored_keys, "    ")
+        yield "  ]"
+    yield "]"
+
+
+@open_file(1, mode="wb")
+def write_gml(G, path, stringizer=None):
+    """Write a graph `G` in GML format to the file or file handle `path`.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The graph to be converted to GML.
+
+    path : filename or filehandle
+        The filename or filehandle to write. Files whose names end with .gz or
+        .bz2 will be compressed.
+
+    stringizer : callable, optional
+        A `stringizer` which converts non-int/non-float/non-dict values into
+        strings. If it cannot convert a value into a string, it should raise a
+        `ValueError` to indicate that. Default value: None.
+
+    Raises
+    ------
+    NetworkXError
+        If `stringizer` cannot convert a value into a string, or the value to
+        convert is not a string while `stringizer` is None.
+
+    See Also
+    --------
+    read_gml, generate_gml
+    literal_stringizer
+
+    Notes
+    -----
+    Graph attributes named 'directed', 'multigraph', 'node' or
+    'edge', node attributes named 'id' or 'label', edge attributes
+    named 'source' or 'target' (or 'key' if `G` is a multigraph)
+    are ignored because these attribute names are used to encode the graph
+    structure.
+
+    GML files are stored using a 7-bit ASCII encoding with any extended
+    ASCII characters (iso8859-1) appearing as HTML character entities.
+    Without specifying a `stringizer`/`destringizer`, the code is capable of
+    writing `int`/`float`/`str`/`dict`/`list` data as required by the GML
+    specification.  For writing other data types, and for reading data other
+    than `str` you need to explicitly supply a `stringizer`/`destringizer`.
+
+    Note that while we allow non-standard GML to be read from a file, we make
+    sure to write GML format. In particular, underscores are not allowed in
+    attribute names.
+    For additional documentation on the GML file format, please see the
+    `GML url <https://web.archive.org/web/20190207140002/http://www.fim.uni-passau.de/index.php?id=17297&L=1>`_.
+
+    See the module docstring :mod:`networkx.readwrite.gml` for more details.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_gml(G, "test.gml")
+
+    Filenames ending in .gz or .bz2 will be compressed.
+
+    >>> nx.write_gml(G, "test.gml.gz")
+    """
+    for line in generate_gml(G, stringizer):
+        path.write((line + "\n").encode("ascii"))
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/gpickle.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/gpickle.py
new file mode 100644
index 0000000..0054afd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/gpickle.py
@@ -0,0 +1,109 @@
+"""
+**************
+Pickled Graphs
+**************
+Read and write NetworkX graphs as Python pickles.
+
+.. warning::
+    The pickle library is not secure and can be used to create arbitray objects. 
+    Only unpickle data you trust - see :doc:`library/pickle` for additional information.
+
+"The pickle module implements a fundamental, but powerful algorithm
+for serializing and de-serializing a Python object
+structure. "Pickling" is the process whereby a Python object hierarchy
+is converted into a byte stream, and "unpickling" is the inverse
+operation, whereby a byte stream is converted back into an object
+hierarchy."
+
+Note that NetworkX graphs can contain any hashable Python object as
+node (not just integers and strings).  For arbitrary data types it may
+be difficult to represent the data as text.  In that case using Python
+pickles to store the graph data can be used.
+
+Format
+------
+See https://docs.python.org/3/library/pickle.html
+"""
+
+__all__ = ["read_gpickle", "write_gpickle"]
+
+import pickle
+import warnings
+
+from networkx.utils import open_file
+
+
+@open_file(1, mode="wb")
+def write_gpickle(G, path, protocol=pickle.HIGHEST_PROTOCOL):
+    """Write graph in Python pickle format.
+
+    Pickles are a serialized byte stream of a Python object [1]_.
+    This format will preserve Python objects used as nodes or edges.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    path : file or string
+       File or filename to write.
+       Filenames ending in .gz or .bz2 will be compressed.
+
+    protocol : integer
+        Pickling protocol to use. Default value: ``pickle.HIGHEST_PROTOCOL``.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_gpickle(G, "test.gpickle")
+
+    References
+    ----------
+    .. [1] https://docs.python.org/3/library/pickle.html
+
+    .. deprecated:: 2.6
+    """
+    msg = (
+        "write_gpickle is deprecated and will be removed in 3.0."
+        "Use ``pickle.dump(G, path, protocol)``"
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    pickle.dump(G, path, protocol)
+
+
+@open_file(0, mode="rb")
+def read_gpickle(path):
+    """Read graph object in Python pickle format.
+
+    Pickles are a serialized byte stream of a Python object [1]_.
+    This format will preserve Python objects used as nodes or edges.
+
+    Parameters
+    ----------
+    path : file or string
+       File or filename to write.
+       Filenames ending in .gz or .bz2 will be uncompressed.
+
+    Returns
+    -------
+    G : graph
+       A NetworkX graph
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_gpickle(G, "test.gpickle")
+    >>> G = nx.read_gpickle("test.gpickle")
+
+    References
+    ----------
+    .. [1] https://docs.python.org/3/library/pickle.html
+
+    .. deprecated:: 2.6
+    """
+    msg = (
+        "read_gpickle is deprecated and will be removed in 3.0."
+        "Use ``pickle.load(path)``"
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    return pickle.load(path)
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/graph6.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/graph6.py
new file mode 100644
index 0000000..cb579ec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/graph6.py
@@ -0,0 +1,414 @@
+# Original author: D. Eppstein, UC Irvine, August 12, 2003.
+# The original code at http://www.ics.uci.edu/~eppstein/PADS/ is public domain.
+"""Functions for reading and writing graphs in the *graph6* format.
+
+The *graph6* file format is suitable for small graphs or large dense
+graphs. For large sparse graphs, use the *sparse6* format.
+
+For more information, see the `graph6`_ homepage.
+
+.. _graph6: http://users.cecs.anu.edu.au/~bdm/data/formats.html
+
+"""
+from itertools import islice
+
+import networkx as nx
+from networkx.exception import NetworkXError
+from networkx.utils import not_implemented_for, open_file
+
+__all__ = ["from_graph6_bytes", "read_graph6", "to_graph6_bytes", "write_graph6"]
+
+
+def _generate_graph6_bytes(G, nodes, header):
+    """Yield bytes in the graph6 encoding of a graph.
+
+    `G` is an undirected simple graph. `nodes` is the list of nodes for
+    which the node-induced subgraph will be encoded; if `nodes` is the
+    list of all nodes in the graph, the entire graph will be
+    encoded. `header` is a Boolean that specifies whether to generate
+    the header ``b'>>graph6<<'`` before the remaining data.
+
+    This function generates `bytes` objects in the following order:
+
+    1. the header (if requested),
+    2. the encoding of the number of nodes,
+    3. each character, one-at-a-time, in the encoding of the requested
+       node-induced subgraph,
+    4. a newline character.
+
+    This function raises :exc:`ValueError` if the graph is too large for
+    the graph6 format (that is, greater than ``2 ** 36`` nodes).
+
+    """
+    n = len(G)
+    if n >= 2**36:
+        raise ValueError(
+            "graph6 is only defined if number of nodes is less " "than 2 ** 36"
+        )
+    if header:
+        yield b">>graph6<<"
+    for d in n_to_data(n):
+        yield str.encode(chr(d + 63))
+    # This generates the same as `(v in G[u] for u, v in combinations(G, 2))`,
+    # but in "column-major" order instead of "row-major" order.
+    bits = (nodes[j] in G[nodes[i]] for j in range(1, n) for i in range(j))
+    chunk = list(islice(bits, 6))
+    while chunk:
+        d = sum(b << 5 - i for i, b in enumerate(chunk))
+        yield str.encode(chr(d + 63))
+        chunk = list(islice(bits, 6))
+    yield b"\n"
+
+
+def from_graph6_bytes(bytes_in):
+    """Read a simple undirected graph in graph6 format from bytes.
+
+    Parameters
+    ----------
+    bytes_in : bytes
+       Data in graph6 format, without a trailing newline.
+
+    Returns
+    -------
+    G : Graph
+
+    Raises
+    ------
+    NetworkXError
+        If bytes_in is unable to be parsed in graph6 format
+
+    ValueError
+        If any character ``c`` in bytes_in does not satisfy
+        ``63 <= ord(c) < 127``.
+
+    Examples
+    --------
+    >>> G = nx.from_graph6_bytes(b"A_")
+    >>> sorted(G.edges())
+    [(0, 1)]
+
+    See Also
+    --------
+    read_graph6, write_graph6
+
+    References
+    ----------
+    .. [1] Graph6 specification
+           <http://users.cecs.anu.edu.au/~bdm/data/formats.html>
+
+    """
+
+    def bits():
+        """Returns sequence of individual bits from 6-bit-per-value
+        list of data values."""
+        for d in data:
+            for i in [5, 4, 3, 2, 1, 0]:
+                yield (d >> i) & 1
+
+    if bytes_in.startswith(b">>graph6<<"):
+        bytes_in = bytes_in[10:]
+
+    data = [c - 63 for c in bytes_in]
+    if any(c > 63 for c in data):
+        raise ValueError("each input character must be in range(63, 127)")
+
+    n, data = data_to_n(data)
+    nd = (n * (n - 1) // 2 + 5) // 6
+    if len(data) != nd:
+        raise NetworkXError(
+            f"Expected {n * (n - 1) // 2} bits but got {len(data) * 6} in graph6"
+        )
+
+    G = nx.Graph()
+    G.add_nodes_from(range(n))
+    for (i, j), b in zip([(i, j) for j in range(1, n) for i in range(j)], bits()):
+        if b:
+            G.add_edge(i, j)
+
+    return G
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def to_graph6_bytes(G, nodes=None, header=True):
+    """Convert a simple undirected graph to bytes in graph6 format.
+
+    Parameters
+    ----------
+    G : Graph (undirected)
+
+    nodes: list or iterable
+       Nodes are labeled 0...n-1 in the order provided.  If None the ordering
+       given by ``G.nodes()`` is used.
+
+    header: bool
+       If True add '>>graph6<<' bytes to head of data.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
+
+    ValueError
+        If the graph has at least ``2 ** 36`` nodes; the graph6 format
+        is only defined for graphs of order less than ``2 ** 36``.
+
+    Examples
+    --------
+    >>> nx.to_graph6_bytes(nx.path_graph(2))
+    b'>>graph6<<A_\\n'
+
+    See Also
+    --------
+    from_graph6_bytes, read_graph6, write_graph6_bytes
+
+    Notes
+    -----
+    The returned bytes end with a newline character.
+
+    The format does not support edge or node labels, parallel edges or
+    self loops. If self loops are present they are silently ignored.
+
+    References
+    ----------
+    .. [1] Graph6 specification
+           <http://users.cecs.anu.edu.au/~bdm/data/formats.html>
+
+    """
+    if nodes is not None:
+        G = G.subgraph(nodes)
+    H = nx.convert_node_labels_to_integers(G)
+    nodes = sorted(H.nodes())
+    return b"".join(_generate_graph6_bytes(H, nodes, header))
+
+
+@open_file(0, mode="rb")
+def read_graph6(path):
+    """Read simple undirected graphs in graph6 format from path.
+
+    Parameters
+    ----------
+    path : file or string
+       File or filename to write.
+
+    Returns
+    -------
+    G : Graph or list of Graphs
+       If the file contains multiple lines then a list of graphs is returned
+
+    Raises
+    ------
+    NetworkXError
+        If the string is unable to be parsed in graph6 format
+
+    Examples
+    --------
+    You can read a graph6 file by giving the path to the file::
+
+        >>> import tempfile
+        >>> with tempfile.NamedTemporaryFile() as f:
+        ...     _ = f.write(b">>graph6<<A_\\n")
+        ...     _ = f.seek(0)
+        ...     G = nx.read_graph6(f.name)
+        >>> list(G.edges())
+        [(0, 1)]
+
+    You can also read a graph6 file by giving an open file-like object::
+
+        >>> import tempfile
+        >>> with tempfile.NamedTemporaryFile() as f:
+        ...     _ = f.write(b">>graph6<<A_\\n")
+        ...     _ = f.seek(0)
+        ...     G = nx.read_graph6(f)
+        >>> list(G.edges())
+        [(0, 1)]
+
+    See Also
+    --------
+    from_graph6_bytes, write_graph6
+
+    References
+    ----------
+    .. [1] Graph6 specification
+           <http://users.cecs.anu.edu.au/~bdm/data/formats.html>
+
+    """
+    glist = []
+    for line in path:
+        line = line.strip()
+        if not len(line):
+            continue
+        glist.append(from_graph6_bytes(line))
+    if len(glist) == 1:
+        return glist[0]
+    else:
+        return glist
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+@open_file(1, mode="wb")
+def write_graph6(G, path, nodes=None, header=True):
+    """Write a simple undirected graph to a path in graph6 format.
+
+    Parameters
+    ----------
+    G : Graph (undirected)
+
+    path : str
+       The path naming the file to which to write the graph.
+
+    nodes: list or iterable
+       Nodes are labeled 0...n-1 in the order provided.  If None the ordering
+       given by ``G.nodes()`` is used.
+
+    header: bool
+       If True add '>>graph6<<' string to head of data
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
+
+    ValueError
+        If the graph has at least ``2 ** 36`` nodes; the graph6 format
+        is only defined for graphs of order less than ``2 ** 36``.
+
+    Examples
+    --------
+    You can write a graph6 file by giving the path to a file::
+
+        >>> import tempfile
+        >>> with tempfile.NamedTemporaryFile() as f:
+        ...     nx.write_graph6(nx.path_graph(2), f.name)
+        ...     _ = f.seek(0)
+        ...     print(f.read())
+        b'>>graph6<<A_\\n'
+
+    See Also
+    --------
+    from_graph6_bytes, read_graph6
+
+    Notes
+    -----
+    The function writes a newline character after writing the encoding
+    of the graph.
+
+    The format does not support edge or node labels, parallel edges or
+    self loops.  If self loops are present they are silently ignored.
+
+    References
+    ----------
+    .. [1] Graph6 specification
+           <http://users.cecs.anu.edu.au/~bdm/data/formats.html>
+
+    """
+    return write_graph6_file(G, path, nodes=nodes, header=header)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def write_graph6_file(G, f, nodes=None, header=True):
+    """Write a simple undirected graph to a file-like object in graph6 format.
+
+    Parameters
+    ----------
+    G : Graph (undirected)
+
+    f : file-like object
+       The file to write.
+
+    nodes: list or iterable
+       Nodes are labeled 0...n-1 in the order provided.  If None the ordering
+       given by ``G.nodes()`` is used.
+
+    header: bool
+       If True add '>>graph6<<' string to head of data
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
+
+    ValueError
+        If the graph has at least ``2 ** 36`` nodes; the graph6 format
+        is only defined for graphs of order less than ``2 ** 36``.
+
+    Examples
+    --------
+    You can write a graph6 file by giving an open file-like object::
+
+        >>> import tempfile
+        >>> with tempfile.NamedTemporaryFile() as f:
+        ...     nx.write_graph6(nx.path_graph(2), f)
+        ...     _ = f.seek(0)
+        ...     print(f.read())
+        b'>>graph6<<A_\\n'
+
+    See Also
+    --------
+    from_graph6_bytes, read_graph6
+
+    Notes
+    -----
+    The function writes a newline character after writing the encoding
+    of the graph.
+
+    The format does not support edge or node labels, parallel edges or
+    self loops.  If self loops are present they are silently ignored.
+
+    References
+    ----------
+    .. [1] Graph6 specification
+           <http://users.cecs.anu.edu.au/~bdm/data/formats.html>
+
+    """
+    if nodes is not None:
+        G = G.subgraph(nodes)
+    H = nx.convert_node_labels_to_integers(G)
+    nodes = sorted(H.nodes())
+    for b in _generate_graph6_bytes(H, nodes, header):
+        f.write(b)
+
+
+def data_to_n(data):
+    """Read initial one-, four- or eight-unit value from graph6
+    integer sequence.
+
+    Return (value, rest of seq.)"""
+    if data[0] <= 62:
+        return data[0], data[1:]
+    if data[1] <= 62:
+        return (data[1] << 12) + (data[2] << 6) + data[3], data[4:]
+    return (
+        (data[2] << 30)
+        + (data[3] << 24)
+        + (data[4] << 18)
+        + (data[5] << 12)
+        + (data[6] << 6)
+        + data[7],
+        data[8:],
+    )
+
+
+def n_to_data(n):
+    """Convert an integer to one-, four- or eight-unit graph6 sequence.
+
+    This function is undefined if `n` is not in ``range(2 ** 36)``.
+
+    """
+    if n <= 62:
+        return [n]
+    elif n <= 258047:
+        return [63, (n >> 12) & 0x3F, (n >> 6) & 0x3F, n & 0x3F]
+    else:  # if n <= 68719476735:
+        return [
+            63,
+            63,
+            (n >> 30) & 0x3F,
+            (n >> 24) & 0x3F,
+            (n >> 18) & 0x3F,
+            (n >> 12) & 0x3F,
+            (n >> 6) & 0x3F,
+            n & 0x3F,
+        ]
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/graphml.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/graphml.py
new file mode 100644
index 0000000..0a17592
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/graphml.py
@@ -0,0 +1,1050 @@
+"""
+*******
+GraphML
+*******
+Read and write graphs in GraphML format.
+
+.. warning::
+
+    This parser uses the standard xml library present in Python, which is
+    insecure - see :doc:`library/xml` for additional information.
+    Only parse GraphML files you trust.
+
+This implementation does not support mixed graphs (directed and unidirected
+edges together), hyperedges, nested graphs, or ports.
+
+"GraphML is a comprehensive and easy-to-use file format for graphs. It
+consists of a language core to describe the structural properties of a
+graph and a flexible extension mechanism to add application-specific
+data. Its main features include support of
+
+    * directed, undirected, and mixed graphs,
+    * hypergraphs,
+    * hierarchical graphs,
+    * graphical representations,
+    * references to external data,
+    * application-specific attribute data, and
+    * light-weight parsers.
+
+Unlike many other file formats for graphs, GraphML does not use a
+custom syntax. Instead, it is based on XML and hence ideally suited as
+a common denominator for all kinds of services generating, archiving,
+or processing graphs."
+
+http://graphml.graphdrawing.org/
+
+Format
+------
+GraphML is an XML format.  See
+http://graphml.graphdrawing.org/specification.html for the specification and
+http://graphml.graphdrawing.org/primer/graphml-primer.html
+for examples.
+"""
+import warnings
+from collections import defaultdict
+
+import networkx as nx
+from networkx.utils import open_file
+
+__all__ = [
+    "write_graphml",
+    "read_graphml",
+    "generate_graphml",
+    "write_graphml_xml",
+    "write_graphml_lxml",
+    "parse_graphml",
+    "GraphMLWriter",
+    "GraphMLReader",
+]
+
+
+@open_file(1, mode="wb")
+def write_graphml_xml(
+    G,
+    path,
+    encoding="utf-8",
+    prettyprint=True,
+    infer_numeric_types=False,
+    named_key_ids=False,
+    edge_id_from_attribute=None,
+):
+    """Write G in GraphML XML format to path
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    path : file or string
+       File or filename to write.
+       Filenames ending in .gz or .bz2 will be compressed.
+    encoding : string (optional)
+       Encoding for text data.
+    prettyprint : bool (optional)
+       If True use line breaks and indenting in output XML.
+    infer_numeric_types : boolean
+       Determine if numeric types should be generalized.
+       For example, if edges have both int and float 'weight' attributes,
+       we infer in GraphML that both are floats.
+    named_key_ids : bool (optional)
+       If True use attr.name as value for key elements' id attribute.
+    edge_id_from_attribute : dict key (optional)
+        If provided, the graphml edge id is set by looking up the corresponding
+        edge data attribute keyed by this parameter. If `None` or the key does not exist in edge data,
+        the edge id is set by the edge key if `G` is a MultiGraph, else the edge id is left unset.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_graphml(G, "test.graphml")
+
+    Notes
+    -----
+    This implementation does not support mixed graphs (directed
+    and unidirected edges together) hyperedges, nested graphs, or ports.
+    """
+    writer = GraphMLWriter(
+        encoding=encoding,
+        prettyprint=prettyprint,
+        infer_numeric_types=infer_numeric_types,
+        named_key_ids=named_key_ids,
+        edge_id_from_attribute=edge_id_from_attribute,
+    )
+    writer.add_graph_element(G)
+    writer.dump(path)
+
+
+@open_file(1, mode="wb")
+def write_graphml_lxml(
+    G,
+    path,
+    encoding="utf-8",
+    prettyprint=True,
+    infer_numeric_types=False,
+    named_key_ids=False,
+    edge_id_from_attribute=None,
+):
+    """Write G in GraphML XML format to path
+
+    This function uses the LXML framework and should be faster than
+    the version using the xml library.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    path : file or string
+       File or filename to write.
+       Filenames ending in .gz or .bz2 will be compressed.
+    encoding : string (optional)
+       Encoding for text data.
+    prettyprint : bool (optional)
+       If True use line breaks and indenting in output XML.
+    infer_numeric_types : boolean
+       Determine if numeric types should be generalized.
+       For example, if edges have both int and float 'weight' attributes,
+       we infer in GraphML that both are floats.
+    named_key_ids : bool (optional)
+       If True use attr.name as value for key elements' id attribute.
+    edge_id_from_attribute : dict key (optional)
+        If provided, the graphml edge id is set by looking up the corresponding
+        edge data attribute keyed by this parameter. If `None` or the key does not exist in edge data,
+        the edge id is set by the edge key if `G` is a MultiGraph, else the edge id is left unset.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_graphml_lxml(G, "fourpath.graphml")
+
+    Notes
+    -----
+    This implementation does not support mixed graphs (directed
+    and unidirected edges together) hyperedges, nested graphs, or ports.
+    """
+    try:
+        import lxml.etree as lxmletree
+    except ImportError:
+        return write_graphml_xml(
+            G,
+            path,
+            encoding,
+            prettyprint,
+            infer_numeric_types,
+            named_key_ids,
+            edge_id_from_attribute,
+        )
+
+    writer = GraphMLWriterLxml(
+        path,
+        graph=G,
+        encoding=encoding,
+        prettyprint=prettyprint,
+        infer_numeric_types=infer_numeric_types,
+        named_key_ids=named_key_ids,
+        edge_id_from_attribute=edge_id_from_attribute,
+    )
+    writer.dump()
+
+
+def generate_graphml(
+    G,
+    encoding="utf-8",
+    prettyprint=True,
+    named_key_ids=False,
+    edge_id_from_attribute=None,
+):
+    """Generate GraphML lines for G
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    encoding : string (optional)
+       Encoding for text data.
+    prettyprint : bool (optional)
+       If True use line breaks and indenting in output XML.
+    named_key_ids : bool (optional)
+       If True use attr.name as value for key elements' id attribute.
+    edge_id_from_attribute : dict key (optional)
+        If provided, the graphml edge id is set by looking up the corresponding
+        edge data attribute keyed by this parameter. If `None` or the key does not exist in edge data,
+        the edge id is set by the edge key if `G` is a MultiGraph, else the edge id is left unset.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> linefeed = chr(10)  # linefeed = \n
+    >>> s = linefeed.join(nx.generate_graphml(G))
+    >>> for line in nx.generate_graphml(G):  # doctest: +SKIP
+    ...     print(line)
+
+    Notes
+    -----
+    This implementation does not support mixed graphs (directed and unidirected
+    edges together) hyperedges, nested graphs, or ports.
+    """
+    writer = GraphMLWriter(
+        encoding=encoding,
+        prettyprint=prettyprint,
+        named_key_ids=named_key_ids,
+        edge_id_from_attribute=edge_id_from_attribute,
+    )
+    writer.add_graph_element(G)
+    yield from str(writer).splitlines()
+
+
+@open_file(0, mode="rb")
+def read_graphml(path, node_type=str, edge_key_type=int, force_multigraph=False):
+    """Read graph in GraphML format from path.
+
+    Parameters
+    ----------
+    path : file or string
+       File or filename to write.
+       Filenames ending in .gz or .bz2 will be compressed.
+
+    node_type: Python type (default: str)
+       Convert node ids to this type
+
+    edge_key_type: Python type (default: int)
+       Convert graphml edge ids to this type. Multigraphs use id as edge key.
+       Non-multigraphs add to edge attribute dict with name "id".
+
+    force_multigraph : bool (default: False)
+       If True, return a multigraph with edge keys. If False (the default)
+       return a multigraph when multiedges are in the graph.
+
+    Returns
+    -------
+    graph: NetworkX graph
+        If parallel edges are present or `force_multigraph=True` then
+        a MultiGraph or MultiDiGraph is returned. Otherwise a Graph/DiGraph.
+        The returned graph is directed if the file indicates it should be.
+
+    Notes
+    -----
+    Default node and edge attributes are not propagated to each node and edge.
+    They can be obtained from `G.graph` and applied to node and edge attributes
+    if desired using something like this:
+
+    >>> default_color = G.graph["node_default"]["color"]  # doctest: +SKIP
+    >>> for node, data in G.nodes(data=True):  # doctest: +SKIP
+    ...     if "color" not in data:
+    ...         data["color"] = default_color
+    >>> default_color = G.graph["edge_default"]["color"]  # doctest: +SKIP
+    >>> for u, v, data in G.edges(data=True):  # doctest: +SKIP
+    ...     if "color" not in data:
+    ...         data["color"] = default_color
+
+    This implementation does not support mixed graphs (directed and unidirected
+    edges together), hypergraphs, nested graphs, or ports.
+
+    For multigraphs the GraphML edge "id" will be used as the edge
+    key.  If not specified then they "key" attribute will be used.  If
+    there is no "key" attribute a default NetworkX multigraph edge key
+    will be provided.
+
+    Files with the yEd "yfiles" extension can be read. The type of the node's
+    shape is preserved in the `shape_type` node attribute.
+
+    yEd compressed files ("file.graphmlz" extension) can be read by renaming
+    the file to "file.graphml.gz".
+
+    """
+    reader = GraphMLReader(node_type, edge_key_type, force_multigraph)
+    # need to check for multiple graphs
+    glist = list(reader(path=path))
+    if len(glist) == 0:
+        # If no graph comes back, try looking for an incomplete header
+        header = b'<graphml xmlns="http://graphml.graphdrawing.org/xmlns">'
+        path.seek(0)
+        old_bytes = path.read()
+        new_bytes = old_bytes.replace(b"<graphml>", header)
+        glist = list(reader(string=new_bytes))
+        if len(glist) == 0:
+            raise nx.NetworkXError("file not successfully read as graphml")
+    return glist[0]
+
+
+def parse_graphml(
+    graphml_string, node_type=str, edge_key_type=int, force_multigraph=False
+):
+    """Read graph in GraphML format from string.
+
+    Parameters
+    ----------
+    graphml_string : string
+       String containing graphml information
+       (e.g., contents of a graphml file).
+
+    node_type: Python type (default: str)
+       Convert node ids to this type
+
+    edge_key_type: Python type (default: int)
+       Convert graphml edge ids to this type. Multigraphs use id as edge key.
+       Non-multigraphs add to edge attribute dict with name "id".
+
+    force_multigraph : bool (default: False)
+       If True, return a multigraph with edge keys. If False (the default)
+       return a multigraph when multiedges are in the graph.
+
+
+    Returns
+    -------
+    graph: NetworkX graph
+        If no parallel edges are found a Graph or DiGraph is returned.
+        Otherwise a MultiGraph or MultiDiGraph is returned.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> linefeed = chr(10)  # linefeed = \n
+    >>> s = linefeed.join(nx.generate_graphml(G))
+    >>> H = nx.parse_graphml(s)
+
+    Notes
+    -----
+    Default node and edge attributes are not propagated to each node and edge.
+    They can be obtained from `G.graph` and applied to node and edge attributes
+    if desired using something like this:
+
+    >>> default_color = G.graph["node_default"]["color"]  # doctest: +SKIP
+    >>> for node, data in G.nodes(data=True):  # doctest: +SKIP
+    ...     if "color" not in data:
+    ...         data["color"] = default_color
+    >>> default_color = G.graph["edge_default"]["color"]  # doctest: +SKIP
+    >>> for u, v, data in G.edges(data=True):  # doctest: +SKIP
+    ...     if "color" not in data:
+    ...         data["color"] = default_color
+
+    This implementation does not support mixed graphs (directed and unidirected
+    edges together), hypergraphs, nested graphs, or ports.
+
+    For multigraphs the GraphML edge "id" will be used as the edge
+    key.  If not specified then they "key" attribute will be used.  If
+    there is no "key" attribute a default NetworkX multigraph edge key
+    will be provided.
+
+    """
+    reader = GraphMLReader(node_type, edge_key_type, force_multigraph)
+    # need to check for multiple graphs
+    glist = list(reader(string=graphml_string))
+    if len(glist) == 0:
+        # If no graph comes back, try looking for an incomplete header
+        header = '<graphml xmlns="http://graphml.graphdrawing.org/xmlns">'
+        new_string = graphml_string.replace("<graphml>", header)
+        glist = list(reader(string=new_string))
+        if len(glist) == 0:
+            raise nx.NetworkXError("file not successfully read as graphml")
+    return glist[0]
+
+
+class GraphML:
+    NS_GRAPHML = "http://graphml.graphdrawing.org/xmlns"
+    NS_XSI = "http://www.w3.org/2001/XMLSchema-instance"
+    # xmlns:y="http://www.yworks.com/xml/graphml"
+    NS_Y = "http://www.yworks.com/xml/graphml"
+    SCHEMALOCATION = " ".join(
+        [
+            "http://graphml.graphdrawing.org/xmlns",
+            "http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd",
+        ]
+    )
+
+    def construct_types(self):
+        types = [
+            (int, "integer"),  # for Gephi GraphML bug
+            (str, "yfiles"),
+            (str, "string"),
+            (int, "int"),
+            (int, "long"),
+            (float, "float"),
+            (float, "double"),
+            (bool, "boolean"),
+        ]
+
+        # These additions to types allow writing numpy types
+        try:
+            import numpy as np
+        except:
+            pass
+        else:
+            # prepend so that python types are created upon read (last entry wins)
+            types = [
+                (np.float64, "float"),
+                (np.float32, "float"),
+                (np.float16, "float"),
+                (np.float_, "float"),
+                (np.int_, "int"),
+                (np.int8, "int"),
+                (np.int16, "int"),
+                (np.int32, "int"),
+                (np.int64, "int"),
+                (np.uint8, "int"),
+                (np.uint16, "int"),
+                (np.uint32, "int"),
+                (np.uint64, "int"),
+                (np.int_, "int"),
+                (np.intc, "int"),
+                (np.intp, "int"),
+            ] + types
+
+        self.xml_type = dict(types)
+        self.python_type = dict(reversed(a) for a in types)
+
+    # This page says that data types in GraphML follow Java(TM).
+    #  http://graphml.graphdrawing.org/primer/graphml-primer.html#AttributesDefinition
+    # true and false are the only boolean literals:
+    #  http://en.wikibooks.org/wiki/Java_Programming/Literals#Boolean_Literals
+    convert_bool = {
+        # We use data.lower() in actual use.
+        "true": True,
+        "false": False,
+        # Include integer strings for convenience.
+        "0": False,
+        0: False,
+        "1": True,
+        1: True,
+    }
+
+    def get_xml_type(self, key):
+        """Wrapper around the xml_type dict that raises a more informative
+        exception message when a user attempts to use data of a type not
+        supported by GraphML."""
+        try:
+            return self.xml_type[key]
+        except KeyError as err:
+            raise TypeError(
+                f"GraphML does not support type {type(key)} as data values."
+            ) from err
+
+
+class GraphMLWriter(GraphML):
+    def __init__(
+        self,
+        graph=None,
+        encoding="utf-8",
+        prettyprint=True,
+        infer_numeric_types=False,
+        named_key_ids=False,
+        edge_id_from_attribute=None,
+    ):
+        self.construct_types()
+        from xml.etree.ElementTree import Element
+
+        self.myElement = Element
+
+        self.infer_numeric_types = infer_numeric_types
+        self.prettyprint = prettyprint
+        self.named_key_ids = named_key_ids
+        self.edge_id_from_attribute = edge_id_from_attribute
+        self.encoding = encoding
+        self.xml = self.myElement(
+            "graphml",
+            {
+                "xmlns": self.NS_GRAPHML,
+                "xmlns:xsi": self.NS_XSI,
+                "xsi:schemaLocation": self.SCHEMALOCATION,
+            },
+        )
+        self.keys = {}
+        self.attributes = defaultdict(list)
+        self.attribute_types = defaultdict(set)
+
+        if graph is not None:
+            self.add_graph_element(graph)
+
+    def __str__(self):
+        from xml.etree.ElementTree import tostring
+
+        if self.prettyprint:
+            self.indent(self.xml)
+        s = tostring(self.xml).decode(self.encoding)
+        return s
+
+    def attr_type(self, name, scope, value):
+        """Infer the attribute type of data named name. Currently this only
+        supports inference of numeric types.
+
+        If self.infer_numeric_types is false, type is used. Otherwise, pick the
+        most general of types found across all values with name and scope. This
+        means edges with data named 'weight' are treated separately from nodes
+        with data named 'weight'.
+        """
+        if self.infer_numeric_types:
+            types = self.attribute_types[(name, scope)]
+
+            if len(types) > 1:
+                types = {self.get_xml_type(t) for t in types}
+                if "string" in types:
+                    return str
+                elif "float" in types or "double" in types:
+                    return float
+                else:
+                    return int
+            else:
+                return list(types)[0]
+        else:
+            return type(value)
+
+    def get_key(self, name, attr_type, scope, default):
+        keys_key = (name, attr_type, scope)
+        try:
+            return self.keys[keys_key]
+        except KeyError:
+            if self.named_key_ids:
+                new_id = name
+            else:
+                new_id = f"d{len(list(self.keys))}"
+
+            self.keys[keys_key] = new_id
+            key_kwargs = {
+                "id": new_id,
+                "for": scope,
+                "attr.name": name,
+                "attr.type": attr_type,
+            }
+            key_element = self.myElement("key", **key_kwargs)
+            # add subelement for data default value if present
+            if default is not None:
+                default_element = self.myElement("default")
+                default_element.text = str(default)
+                key_element.append(default_element)
+            self.xml.insert(0, key_element)
+        return new_id
+
+    def add_data(self, name, element_type, value, scope="all", default=None):
+        """
+        Make a data element for an edge or a node. Keep a log of the
+        type in the keys table.
+        """
+        if element_type not in self.xml_type:
+            raise nx.NetworkXError(
+                f"GraphML writer does not support {element_type} as data values."
+            )
+        keyid = self.get_key(name, self.get_xml_type(element_type), scope, default)
+        data_element = self.myElement("data", key=keyid)
+        data_element.text = str(value)
+        return data_element
+
+    def add_attributes(self, scope, xml_obj, data, default):
+        """Appends attribute data to edges or nodes, and stores type information
+        to be added later. See add_graph_element.
+        """
+        for k, v in data.items():
+            self.attribute_types[(str(k), scope)].add(type(v))
+            self.attributes[xml_obj].append([k, v, scope, default.get(k)])
+
+    def add_nodes(self, G, graph_element):
+        default = G.graph.get("node_default", {})
+        for node, data in G.nodes(data=True):
+            node_element = self.myElement("node", id=str(node))
+            self.add_attributes("node", node_element, data, default)
+            graph_element.append(node_element)
+
+    def add_edges(self, G, graph_element):
+        if G.is_multigraph():
+            for u, v, key, data in G.edges(data=True, keys=True):
+                edge_element = self.myElement(
+                    "edge",
+                    source=str(u),
+                    target=str(v),
+                    id=str(data.get(self.edge_id_from_attribute))
+                    if self.edge_id_from_attribute
+                    and self.edge_id_from_attribute in data
+                    else str(key),
+                )
+                default = G.graph.get("edge_default", {})
+                self.add_attributes("edge", edge_element, data, default)
+                graph_element.append(edge_element)
+        else:
+            for u, v, data in G.edges(data=True):
+                if self.edge_id_from_attribute and self.edge_id_from_attribute in data:
+                    # select attribute to be edge id
+                    edge_element = self.myElement(
+                        "edge",
+                        source=str(u),
+                        target=str(v),
+                        id=str(data.get(self.edge_id_from_attribute)),
+                    )
+                else:
+                    # default: no edge id
+                    edge_element = self.myElement("edge", source=str(u), target=str(v))
+                default = G.graph.get("edge_default", {})
+                self.add_attributes("edge", edge_element, data, default)
+                graph_element.append(edge_element)
+
+    def add_graph_element(self, G):
+        """
+        Serialize graph G in GraphML to the stream.
+        """
+        if G.is_directed():
+            default_edge_type = "directed"
+        else:
+            default_edge_type = "undirected"
+
+        graphid = G.graph.pop("id", None)
+        if graphid is None:
+            graph_element = self.myElement("graph", edgedefault=default_edge_type)
+        else:
+            graph_element = self.myElement(
+                "graph", edgedefault=default_edge_type, id=graphid
+            )
+        default = {}
+        data = {
+            k: v
+            for (k, v) in G.graph.items()
+            if k not in ["node_default", "edge_default"]
+        }
+        self.add_attributes("graph", graph_element, data, default)
+        self.add_nodes(G, graph_element)
+        self.add_edges(G, graph_element)
+
+        # self.attributes contains a mapping from XML Objects to a list of
+        # data that needs to be added to them.
+        # We postpone processing in order to do type inference/generalization.
+        # See self.attr_type
+        for (xml_obj, data) in self.attributes.items():
+            for (k, v, scope, default) in data:
+                xml_obj.append(
+                    self.add_data(
+                        str(k), self.attr_type(k, scope, v), str(v), scope, default
+                    )
+                )
+        self.xml.append(graph_element)
+
+    def add_graphs(self, graph_list):
+        """Add many graphs to this GraphML document."""
+        for G in graph_list:
+            self.add_graph_element(G)
+
+    def dump(self, stream):
+        from xml.etree.ElementTree import ElementTree
+
+        if self.prettyprint:
+            self.indent(self.xml)
+        document = ElementTree(self.xml)
+        document.write(stream, encoding=self.encoding, xml_declaration=True)
+
+    def indent(self, elem, level=0):
+        # in-place prettyprint formatter
+        i = "\n" + level * "  "
+        if len(elem):
+            if not elem.text or not elem.text.strip():
+                elem.text = i + "  "
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+            for elem in elem:
+                self.indent(elem, level + 1)
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+        else:
+            if level and (not elem.tail or not elem.tail.strip()):
+                elem.tail = i
+
+
+class IncrementalElement:
+    """Wrapper for _IncrementalWriter providing an Element like interface.
+
+    This wrapper does not intend to be a complete implementation but rather to
+    deal with those calls used in GraphMLWriter.
+    """
+
+    def __init__(self, xml, prettyprint):
+        self.xml = xml
+        self.prettyprint = prettyprint
+
+    def append(self, element):
+        self.xml.write(element, pretty_print=self.prettyprint)
+
+
+class GraphMLWriterLxml(GraphMLWriter):
+    def __init__(
+        self,
+        path,
+        graph=None,
+        encoding="utf-8",
+        prettyprint=True,
+        infer_numeric_types=False,
+        named_key_ids=False,
+        edge_id_from_attribute=None,
+    ):
+        self.construct_types()
+        import lxml.etree as lxmletree
+
+        self.myElement = lxmletree.Element
+
+        self._encoding = encoding
+        self._prettyprint = prettyprint
+        self.named_key_ids = named_key_ids
+        self.edge_id_from_attribute = edge_id_from_attribute
+        self.infer_numeric_types = infer_numeric_types
+
+        self._xml_base = lxmletree.xmlfile(path, encoding=encoding)
+        self._xml = self._xml_base.__enter__()
+        self._xml.write_declaration()
+
+        # We need to have a xml variable that support insertion. This call is
+        # used for adding the keys to the document.
+        # We will store those keys in a plain list, and then after the graph
+        # element is closed we will add them to the main graphml element.
+        self.xml = []
+        self._keys = self.xml
+        self._graphml = self._xml.element(
+            "graphml",
+            {
+                "xmlns": self.NS_GRAPHML,
+                "xmlns:xsi": self.NS_XSI,
+                "xsi:schemaLocation": self.SCHEMALOCATION,
+            },
+        )
+        self._graphml.__enter__()
+        self.keys = {}
+        self.attribute_types = defaultdict(set)
+
+        if graph is not None:
+            self.add_graph_element(graph)
+
+    def add_graph_element(self, G):
+        """
+        Serialize graph G in GraphML to the stream.
+        """
+        if G.is_directed():
+            default_edge_type = "directed"
+        else:
+            default_edge_type = "undirected"
+
+        graphid = G.graph.pop("id", None)
+        if graphid is None:
+            graph_element = self._xml.element("graph", edgedefault=default_edge_type)
+        else:
+            graph_element = self._xml.element(
+                "graph", edgedefault=default_edge_type, id=graphid
+            )
+
+        # gather attributes types for the whole graph
+        # to find the most general numeric format needed.
+        # Then pass through attributes to create key_id for each.
+        graphdata = {
+            k: v
+            for k, v in G.graph.items()
+            if k not in ("node_default", "edge_default")
+        }
+        node_default = G.graph.get("node_default", {})
+        edge_default = G.graph.get("edge_default", {})
+        # Graph attributes
+        for k, v in graphdata.items():
+            self.attribute_types[(str(k), "graph")].add(type(v))
+        for k, v in graphdata.items():
+            element_type = self.get_xml_type(self.attr_type(k, "graph", v))
+            self.get_key(str(k), element_type, "graph", None)
+        # Nodes and data
+        for node, d in G.nodes(data=True):
+            for k, v in d.items():
+                self.attribute_types[(str(k), "node")].add(type(v))
+        for node, d in G.nodes(data=True):
+            for k, v in d.items():
+                T = self.get_xml_type(self.attr_type(k, "node", v))
+                self.get_key(str(k), T, "node", node_default.get(k))
+        # Edges and data
+        if G.is_multigraph():
+            for u, v, ekey, d in G.edges(keys=True, data=True):
+                for k, v in d.items():
+                    self.attribute_types[(str(k), "edge")].add(type(v))
+            for u, v, ekey, d in G.edges(keys=True, data=True):
+                for k, v in d.items():
+                    T = self.get_xml_type(self.attr_type(k, "edge", v))
+                    self.get_key(str(k), T, "edge", edge_default.get(k))
+        else:
+            for u, v, d in G.edges(data=True):
+                for k, v in d.items():
+                    self.attribute_types[(str(k), "edge")].add(type(v))
+            for u, v, d in G.edges(data=True):
+                for k, v in d.items():
+                    T = self.get_xml_type(self.attr_type(k, "edge", v))
+                    self.get_key(str(k), T, "edge", edge_default.get(k))
+
+        # Now add attribute keys to the xml file
+        for key in self.xml:
+            self._xml.write(key, pretty_print=self._prettyprint)
+
+        # The incremental_writer writes each node/edge as it is created
+        incremental_writer = IncrementalElement(self._xml, self._prettyprint)
+        with graph_element:
+            self.add_attributes("graph", incremental_writer, graphdata, {})
+            self.add_nodes(G, incremental_writer)  # adds attributes too
+            self.add_edges(G, incremental_writer)  # adds attributes too
+
+    def add_attributes(self, scope, xml_obj, data, default):
+        """Appends attribute data."""
+        for k, v in data.items():
+            data_element = self.add_data(
+                str(k), self.attr_type(str(k), scope, v), str(v), scope, default.get(k)
+            )
+            xml_obj.append(data_element)
+
+    def __str__(self):
+        return object.__str__(self)
+
+    def dump(self):
+        self._graphml.__exit__(None, None, None)
+        self._xml_base.__exit__(None, None, None)
+
+
+# default is lxml is present.
+write_graphml = write_graphml_lxml
+
+
+class GraphMLReader(GraphML):
+    """Read a GraphML document.  Produces NetworkX graph objects."""
+
+    def __init__(self, node_type=str, edge_key_type=int, force_multigraph=False):
+        self.construct_types()
+        self.node_type = node_type
+        self.edge_key_type = edge_key_type
+        self.multigraph = force_multigraph  # If False, test for multiedges
+        self.edge_ids = {}  # dict mapping (u,v) tuples to edge id attributes
+
+    def __call__(self, path=None, string=None):
+        from xml.etree.ElementTree import ElementTree, fromstring
+
+        if path is not None:
+            self.xml = ElementTree(file=path)
+        elif string is not None:
+            self.xml = fromstring(string)
+        else:
+            raise ValueError("Must specify either 'path' or 'string' as kwarg")
+        (keys, defaults) = self.find_graphml_keys(self.xml)
+        for g in self.xml.findall(f"{{{self.NS_GRAPHML}}}graph"):
+            yield self.make_graph(g, keys, defaults)
+
+    def make_graph(self, graph_xml, graphml_keys, defaults, G=None):
+        # set default graph type
+        edgedefault = graph_xml.get("edgedefault", None)
+        if G is None:
+            if edgedefault == "directed":
+                G = nx.MultiDiGraph()
+            else:
+                G = nx.MultiGraph()
+        # set defaults for graph attributes
+        G.graph["node_default"] = {}
+        G.graph["edge_default"] = {}
+        for key_id, value in defaults.items():
+            key_for = graphml_keys[key_id]["for"]
+            name = graphml_keys[key_id]["name"]
+            python_type = graphml_keys[key_id]["type"]
+            if key_for == "node":
+                G.graph["node_default"].update({name: python_type(value)})
+            if key_for == "edge":
+                G.graph["edge_default"].update({name: python_type(value)})
+        # hyperedges are not supported
+        hyperedge = graph_xml.find(f"{{{self.NS_GRAPHML}}}hyperedge")
+        if hyperedge is not None:
+            raise nx.NetworkXError("GraphML reader doesn't support hyperedges")
+        # add nodes
+        for node_xml in graph_xml.findall(f"{{{self.NS_GRAPHML}}}node"):
+            self.add_node(G, node_xml, graphml_keys, defaults)
+        # add edges
+        for edge_xml in graph_xml.findall(f"{{{self.NS_GRAPHML}}}edge"):
+            self.add_edge(G, edge_xml, graphml_keys)
+        # add graph data
+        data = self.decode_data_elements(graphml_keys, graph_xml)
+        G.graph.update(data)
+
+        # switch to Graph or DiGraph if no parallel edges were found
+        if self.multigraph:
+            return G
+
+        G = nx.DiGraph(G) if G.is_directed() else nx.Graph(G)
+        # add explicit edge "id" from file as attribute in NX graph.
+        nx.set_edge_attributes(G, values=self.edge_ids, name="id")
+        return G
+
+    def add_node(self, G, node_xml, graphml_keys, defaults):
+        """Add a node to the graph."""
+        # warn on finding unsupported ports tag
+        ports = node_xml.find(f"{{{self.NS_GRAPHML}}}port")
+        if ports is not None:
+            warnings.warn("GraphML port tag not supported.")
+        # find the node by id and cast it to the appropriate type
+        node_id = self.node_type(node_xml.get("id"))
+        # get data/attributes for node
+        data = self.decode_data_elements(graphml_keys, node_xml)
+        G.add_node(node_id, **data)
+        # get child nodes
+        if node_xml.attrib.get("yfiles.foldertype") == "group":
+            graph_xml = node_xml.find(f"{{{self.NS_GRAPHML}}}graph")
+            self.make_graph(graph_xml, graphml_keys, defaults, G)
+
+    def add_edge(self, G, edge_element, graphml_keys):
+        """Add an edge to the graph."""
+        # warn on finding unsupported ports tag
+        ports = edge_element.find(f"{{{self.NS_GRAPHML}}}port")
+        if ports is not None:
+            warnings.warn("GraphML port tag not supported.")
+
+        # raise error if we find mixed directed and undirected edges
+        directed = edge_element.get("directed")
+        if G.is_directed() and directed == "false":
+            msg = "directed=false edge found in directed graph."
+            raise nx.NetworkXError(msg)
+        if (not G.is_directed()) and directed == "true":
+            msg = "directed=true edge found in undirected graph."
+            raise nx.NetworkXError(msg)
+
+        source = self.node_type(edge_element.get("source"))
+        target = self.node_type(edge_element.get("target"))
+        data = self.decode_data_elements(graphml_keys, edge_element)
+        # GraphML stores edge ids as an attribute
+        # NetworkX uses them as keys in multigraphs too if no key
+        # attribute is specified
+        edge_id = edge_element.get("id")
+        if edge_id:
+            # self.edge_ids is used by `make_graph` method for non-multigraphs
+            self.edge_ids[source, target] = edge_id
+            try:
+                edge_id = self.edge_key_type(edge_id)
+            except ValueError:  # Could not convert.
+                pass
+        else:
+            edge_id = data.get("key")
+
+        if G.has_edge(source, target):
+            # mark this as a multigraph
+            self.multigraph = True
+
+        # Use add_edges_from to avoid error with add_edge when `'key' in data`
+        # Note there is only one edge here...
+        G.add_edges_from([(source, target, edge_id, data)])
+
+    def decode_data_elements(self, graphml_keys, obj_xml):
+        """Use the key information to decode the data XML if present."""
+        data = {}
+        for data_element in obj_xml.findall(f"{{{self.NS_GRAPHML}}}data"):
+            key = data_element.get("key")
+            try:
+                data_name = graphml_keys[key]["name"]
+                data_type = graphml_keys[key]["type"]
+            except KeyError as err:
+                raise nx.NetworkXError(f"Bad GraphML data: no key {key}") from err
+            text = data_element.text
+            # assume anything with subelements is a yfiles extension
+            if text is not None and len(list(data_element)) == 0:
+                if data_type == bool:
+                    # Ignore cases.
+                    # http://docs.oracle.com/javase/6/docs/api/java/lang/
+                    # Boolean.html#parseBoolean%28java.lang.String%29
+                    data[data_name] = self.convert_bool[text.lower()]
+                else:
+                    data[data_name] = data_type(text)
+            elif len(list(data_element)) > 0:
+                # Assume yfiles as subelements, try to extract node_label
+                node_label = None
+                # set GenericNode's configuration as shape type
+                gn = data_element.find(f"{{{self.NS_Y}}}GenericNode")
+                if gn:
+                    data["shape_type"] = gn.get("configuration")
+                for node_type in ["GenericNode", "ShapeNode", "SVGNode", "ImageNode"]:
+                    pref = f"{{{self.NS_Y}}}{node_type}/{{{self.NS_Y}}}"
+                    geometry = data_element.find(f"{pref}Geometry")
+                    if geometry is not None:
+                        data["x"] = geometry.get("x")
+                        data["y"] = geometry.get("y")
+                    if node_label is None:
+                        node_label = data_element.find(f"{pref}NodeLabel")
+                    shape = data_element.find(f"{pref}Shape")
+                    if shape is not None:
+                        data["shape_type"] = shape.get("type")
+                if node_label is not None:
+                    data["label"] = node_label.text
+
+                # check all the different types of edges avaivable in yEd.
+                for edge_type in [
+                    "PolyLineEdge",
+                    "SplineEdge",
+                    "QuadCurveEdge",
+                    "BezierEdge",
+                    "ArcEdge",
+                ]:
+                    pref = f"{{{self.NS_Y}}}{edge_type}/{{{self.NS_Y}}}"
+                    edge_label = data_element.find(f"{pref}EdgeLabel")
+                    if edge_label is not None:
+                        break
+
+                if edge_label is not None:
+                    data["label"] = edge_label.text
+        return data
+
+    def find_graphml_keys(self, graph_element):
+        """Extracts all the keys and key defaults from the xml."""
+        graphml_keys = {}
+        graphml_key_defaults = {}
+        for k in graph_element.findall(f"{{{self.NS_GRAPHML}}}key"):
+            attr_id = k.get("id")
+            attr_type = k.get("attr.type")
+            attr_name = k.get("attr.name")
+            yfiles_type = k.get("yfiles.type")
+            if yfiles_type is not None:
+                attr_name = yfiles_type
+                attr_type = "yfiles"
+            if attr_type is None:
+                attr_type = "string"
+                warnings.warn(f"No key type for id {attr_id}. Using string")
+            if attr_name is None:
+                raise nx.NetworkXError(f"Unknown key for id {attr_id}.")
+            graphml_keys[attr_id] = {
+                "name": attr_name,
+                "type": self.python_type[attr_type],
+                "for": k.get("for"),
+            }
+            # check for "default" sub-element of key element
+            default = k.find(f"{{{self.NS_GRAPHML}}}default")
+            if default is not None:
+                # Handle default values identically to data element values
+                python_type = graphml_keys[attr_id]["type"]
+                if python_type == bool:
+                    graphml_key_defaults[attr_id] = self.convert_bool[
+                        default.text.lower()
+                    ]
+                else:
+                    graphml_key_defaults[attr_id] = python_type(default.text)
+        return graphml_keys, graphml_key_defaults
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/__init__.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/__init__.py
new file mode 100644
index 0000000..7715fbb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/__init__.py
@@ -0,0 +1,19 @@
+"""
+*********
+JSON data
+*********
+Generate and parse JSON serializable data for NetworkX graphs.
+
+These formats are suitable for use with the d3.js examples https://d3js.org/
+
+The three formats that you can generate with NetworkX are:
+
+ - node-link like in the d3.js example https://bl.ocks.org/mbostock/4062045
+ - tree like in the d3.js example https://bl.ocks.org/mbostock/4063550
+ - adjacency like in the d3.js example https://bost.ocks.org/mike/miserables/
+"""
+from networkx.readwrite.json_graph.node_link import *
+from networkx.readwrite.json_graph.adjacency import *
+from networkx.readwrite.json_graph.tree import *
+from networkx.readwrite.json_graph.jit import *
+from networkx.readwrite.json_graph.cytoscape import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/adjacency.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/adjacency.py
new file mode 100644
index 0000000..7962ea9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/adjacency.py
@@ -0,0 +1,157 @@
+from itertools import chain
+
+import networkx as nx
+
+__all__ = ["adjacency_data", "adjacency_graph"]
+
+_attrs = dict(id="id", key="key")
+
+
+def adjacency_data(G, attrs=_attrs):
+    """Returns data in adjacency format that is suitable for JSON serialization
+    and use in Javascript documents.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    attrs : dict
+        A dictionary that contains two keys 'id' and 'key'. The corresponding
+        values provide the attribute names for storing NetworkX-internal graph
+        data. The values should be unique. Default value:
+        :samp:`dict(id='id', key='key')`.
+
+        If some user-defined graph data use these attribute names as data keys,
+        they may be silently dropped.
+
+    Returns
+    -------
+    data : dict
+       A dictionary with adjacency formatted data.
+
+    Raises
+    ------
+    NetworkXError
+        If values in attrs are not unique.
+
+    Examples
+    --------
+    >>> from networkx.readwrite import json_graph
+    >>> G = nx.Graph([(1, 2)])
+    >>> data = json_graph.adjacency_data(G)
+
+    To serialize with json
+
+    >>> import json
+    >>> s = json.dumps(data)
+
+    Notes
+    -----
+    Graph, node, and link attributes will be written when using this format
+    but attribute keys must be strings if you want to serialize the resulting
+    data with JSON.
+
+    The default value of attrs will be changed in a future release of NetworkX.
+
+    See Also
+    --------
+    adjacency_graph, node_link_data, tree_data
+    """
+    multigraph = G.is_multigraph()
+    id_ = attrs["id"]
+    # Allow 'key' to be omitted from attrs if the graph is not a multigraph.
+    key = None if not multigraph else attrs["key"]
+    if id_ == key:
+        raise nx.NetworkXError("Attribute names are not unique.")
+    data = {}
+    data["directed"] = G.is_directed()
+    data["multigraph"] = multigraph
+    data["graph"] = list(G.graph.items())
+    data["nodes"] = []
+    data["adjacency"] = []
+    for n, nbrdict in G.adjacency():
+        data["nodes"].append(dict(chain(G.nodes[n].items(), [(id_, n)])))
+        adj = []
+        if multigraph:
+            for nbr, keys in nbrdict.items():
+                for k, d in keys.items():
+                    adj.append(dict(chain(d.items(), [(id_, nbr), (key, k)])))
+        else:
+            for nbr, d in nbrdict.items():
+                adj.append(dict(chain(d.items(), [(id_, nbr)])))
+        data["adjacency"].append(adj)
+    return data
+
+
+def adjacency_graph(data, directed=False, multigraph=True, attrs=_attrs):
+    """Returns graph from adjacency data format.
+
+    Parameters
+    ----------
+    data : dict
+        Adjacency list formatted graph data
+
+    directed : bool
+        If True, and direction not specified in data, return a directed graph.
+
+    multigraph : bool
+        If True, and multigraph not specified in data, return a multigraph.
+
+    attrs : dict
+        A dictionary that contains two keys 'id' and 'key'. The corresponding
+        values provide the attribute names for storing NetworkX-internal graph
+        data. The values should be unique. Default value:
+        :samp:`dict(id='id', key='key')`.
+
+    Returns
+    -------
+    G : NetworkX graph
+       A NetworkX graph object
+
+    Examples
+    --------
+    >>> from networkx.readwrite import json_graph
+    >>> G = nx.Graph([(1, 2)])
+    >>> data = json_graph.adjacency_data(G)
+    >>> H = json_graph.adjacency_graph(data)
+
+    Notes
+    -----
+    The default value of attrs will be changed in a future release of NetworkX.
+
+    See Also
+    --------
+    adjacency_graph, node_link_data, tree_data
+    """
+    multigraph = data.get("multigraph", multigraph)
+    directed = data.get("directed", directed)
+    if multigraph:
+        graph = nx.MultiGraph()
+    else:
+        graph = nx.Graph()
+    if directed:
+        graph = graph.to_directed()
+    id_ = attrs["id"]
+    # Allow 'key' to be omitted from attrs if the graph is not a multigraph.
+    key = None if not multigraph else attrs["key"]
+    graph.graph = dict(data.get("graph", []))
+    mapping = []
+    for d in data["nodes"]:
+        node_data = d.copy()
+        node = node_data.pop(id_)
+        mapping.append(node)
+        graph.add_node(node)
+        graph.nodes[node].update(node_data)
+    for i, d in enumerate(data["adjacency"]):
+        source = mapping[i]
+        for tdata in d:
+            target_data = tdata.copy()
+            target = target_data.pop(id_)
+            if not multigraph:
+                graph.add_edge(source, target)
+                graph[source][target].update(tdata)
+            else:
+                ky = target_data.pop(key, None)
+                graph.add_edge(source, target, key=ky)
+                graph[source][target][ky].update(tdata)
+    return graph
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/cytoscape.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/cytoscape.py
new file mode 100644
index 0000000..296242c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/cytoscape.py
@@ -0,0 +1,242 @@
+import networkx as nx
+
+__all__ = ["cytoscape_data", "cytoscape_graph"]
+
+
+def cytoscape_data(G, attrs=None, name="name", ident="id"):
+    """Returns data in Cytoscape JSON format (cyjs).
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        The graph to convert to cytoscape format
+    attrs : dict or None (default=None)
+        A dictionary containing the keys 'name' and 'ident' which are mapped to
+        the 'name' and 'id' node elements in cyjs format. All other keys are
+        ignored. Default is `None` which results in the default mapping
+        ``dict(name="name", ident="id")``.
+
+        .. deprecated:: 2.6
+
+           The `attrs` keyword argument will be replaced with `name` and
+           `ident` in networkx 3.0
+
+    name : string
+        A string which is mapped to the 'name' node element in cyjs format.
+        Must not have the same value as `ident`.
+    ident : string
+        A string which is mapped to the 'id' node element in cyjs format.
+        Must not have the same value as `name`.
+
+    Returns
+    -------
+    data: dict
+        A dictionary with cyjs formatted data.
+
+    Raises
+    ------
+    NetworkXError
+        If the values for `name` and `ident` are identical.
+
+    See Also
+    --------
+    cytoscape_graph: convert a dictionary in cyjs format to a graph
+
+    References
+    ----------
+    .. [1] Cytoscape user's manual:
+       http://manual.cytoscape.org/en/stable/index.html
+
+    Examples
+    --------
+    >>> G = nx.path_graph(2)
+    >>> nx.cytoscape_data(G)  # doctest: +SKIP
+    {'data': [],
+     'directed': False,
+     'multigraph': False,
+     'elements': {'nodes': [{'data': {'id': '0', 'value': 0, 'name': '0'}},
+       {'data': {'id': '1', 'value': 1, 'name': '1'}}],
+      'edges': [{'data': {'source': 0, 'target': 1}}]}}
+    """
+    # ------ TODO: Remove between the lines in 3.0 ----- #
+    if attrs is not None:
+        import warnings
+
+        msg = (
+            "\nThe `attrs` keyword argument of cytoscape_data is deprecated\n"
+            "and will be removed in networkx 3.0.\n"
+            "It is replaced with explicit `name` and `ident` keyword\n"
+            "arguments.\n"
+            "To make this warning go away and ensure usage is forward\n"
+            "compatible, replace `attrs` with `name` and `ident`,\n"
+            "for example:\n\n"
+            "   >>> cytoscape_data(G, attrs={'name': 'foo', 'ident': 'bar'})\n\n"
+            "should instead be written as\n\n"
+            "   >>> cytoscape_data(G, name='foo', ident='bar')\n\n"
+            "in networkx 3.0.\n"
+            "The default values of 'name' and 'id' will not change."
+        )
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+
+        name = attrs["name"]
+        ident = attrs["ident"]
+    # -------------------------------------------------- #
+
+    if name == ident:
+        raise nx.NetworkXError("name and ident must be different.")
+
+    jsondata = {"data": list(G.graph.items())}
+    jsondata["directed"] = G.is_directed()
+    jsondata["multigraph"] = G.is_multigraph()
+    jsondata["elements"] = {"nodes": [], "edges": []}
+    nodes = jsondata["elements"]["nodes"]
+    edges = jsondata["elements"]["edges"]
+
+    for i, j in G.nodes.items():
+        n = {"data": j.copy()}
+        n["data"]["id"] = j.get(ident) or str(i)
+        n["data"]["value"] = i
+        n["data"]["name"] = j.get(name) or str(i)
+        nodes.append(n)
+
+    if G.is_multigraph():
+        for e in G.edges(keys=True):
+            n = {"data": G.adj[e[0]][e[1]][e[2]].copy()}
+            n["data"]["source"] = e[0]
+            n["data"]["target"] = e[1]
+            n["data"]["key"] = e[2]
+            edges.append(n)
+    else:
+        for e in G.edges():
+            n = {"data": G.adj[e[0]][e[1]].copy()}
+            n["data"]["source"] = e[0]
+            n["data"]["target"] = e[1]
+            edges.append(n)
+    return jsondata
+
+
+def cytoscape_graph(data, attrs=None, name="name", ident="id"):
+    """
+    Create a NetworkX graph from a dictionary in cytoscape JSON format.
+
+    Parameters
+    ----------
+    data : dict
+        A dictionary of data conforming to cytoscape JSON format.
+    attrs : dict or None (default=None)
+        A dictionary containing the keys 'name' and 'ident' which are mapped to
+        the 'name' and 'id' node elements in cyjs format. All other keys are
+        ignored. Default is `None` which results in the default mapping
+        ``dict(name="name", ident="id")``.
+
+        .. deprecated:: 2.6
+
+           The `attrs` keyword argument will be replaced with `name` and
+           `ident` in networkx 3.0
+
+    name : string
+        A string which is mapped to the 'name' node element in cyjs format.
+        Must not have the same value as `ident`.
+    ident : string
+        A string which is mapped to the 'id' node element in cyjs format.
+        Must not have the same value as `name`.
+
+    Returns
+    -------
+    graph : a NetworkX graph instance
+        The `graph` can be an instance of `Graph`, `DiGraph`, `MultiGraph`, or
+        `MultiDiGraph` depending on the input data.
+
+    Raises
+    ------
+    NetworkXError
+        If the `name` and `ident` attributes are identical.
+
+    See Also
+    --------
+    cytoscape_data: convert a NetworkX graph to a dict in cyjs format
+
+    References
+    ----------
+    .. [1] Cytoscape user's manual:
+       http://manual.cytoscape.org/en/stable/index.html
+
+    Examples
+    --------
+    >>> data_dict = {
+    ...     'data': [],
+    ...     'directed': False,
+    ...     'multigraph': False,
+    ...     'elements': {'nodes': [{'data': {'id': '0', 'value': 0, 'name': '0'}},
+    ...       {'data': {'id': '1', 'value': 1, 'name': '1'}}],
+    ...      'edges': [{'data': {'source': 0, 'target': 1}}]}
+    ... }
+    >>> G = nx.cytoscape_graph(data_dict)
+    >>> G.name
+    ''
+    >>> G.nodes()
+    NodeView((0, 1))
+    >>> G.nodes(data=True)[0]
+    {'id': '0', 'value': 0, 'name': '0'}
+    >>> G.edges(data=True)
+    EdgeDataView([(0, 1, {'source': 0, 'target': 1})])
+    """
+    # ------ TODO: Remove between the lines in 3.0 ----- #
+    if attrs is not None:
+        import warnings
+
+        msg = (
+            "\nThe `attrs` keyword argument of cytoscape_data is deprecated\n"
+            "and will be removed in networkx 3.0.\n"
+            "It is replaced with explicit `name` and `ident` keyword\n"
+            "arguments.\n"
+            "To make this warning go away and ensure usage is forward\n"
+            "compatible, replace `attrs` with `name` and `ident`,\n"
+            "for example:\n\n"
+            "   >>> cytoscape_data(G, attrs={'name': 'foo', 'ident': 'bar'})\n\n"
+            "should instead be written as\n\n"
+            "   >>> cytoscape_data(G, name='foo', ident='bar')\n\n"
+            "The default values of 'name' and 'id' will not change."
+        )
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+
+        name = attrs["name"]
+        ident = attrs["ident"]
+    # -------------------------------------------------- #
+
+    if name == ident:
+        raise nx.NetworkXError("name and ident must be different.")
+
+    multigraph = data.get("multigraph")
+    directed = data.get("directed")
+    if multigraph:
+        graph = nx.MultiGraph()
+    else:
+        graph = nx.Graph()
+    if directed:
+        graph = graph.to_directed()
+    graph.graph = dict(data.get("data"))
+    for d in data["elements"]["nodes"]:
+        node_data = d["data"].copy()
+        node = d["data"]["value"]
+
+        if d["data"].get(name):
+            node_data[name] = d["data"].get(name)
+        if d["data"].get(ident):
+            node_data[ident] = d["data"].get(ident)
+
+        graph.add_node(node)
+        graph.nodes[node].update(node_data)
+
+    for d in data["elements"]["edges"]:
+        edge_data = d["data"].copy()
+        sour = d["data"]["source"]
+        targ = d["data"]["target"]
+        if multigraph:
+            key = d["data"].get("key", 0)
+            graph.add_edge(sour, targ, key=key)
+            graph.edges[sour, targ, key].update(edge_data)
+        else:
+            graph.add_edge(sour, targ)
+            graph.edges[sour, targ].update(edge_data)
+    return graph
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/jit.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/jit.py
new file mode 100644
index 0000000..043f1a1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/jit.py
@@ -0,0 +1,118 @@
+"""
+Read and write NetworkX graphs as JavaScript InfoVis Toolkit (JIT) format JSON.
+
+See the `JIT documentation`_ for more examples.
+
+Format
+------
+var json = [
+  {
+    "id": "aUniqueIdentifier",
+    "name": "usually a nodes name",
+    "data": {
+      "some key": "some value",
+      "some other key": "some other value"
+     },
+    "adjacencies": [
+    {
+      nodeTo:"aNodeId",
+      data: {} //put whatever you want here
+    },
+    'other adjacencies go here...'
+  },
+
+  'other nodes go here...'
+];
+.. _JIT documentation: http://thejit.org
+"""
+
+import json
+import warnings
+
+import networkx as nx
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = ["jit_graph", "jit_data"]
+
+
+def jit_graph(data, create_using=None):
+    """Read a graph from JIT JSON.
+
+    Parameters
+    ----------
+    data : JSON Graph Object
+
+    create_using : Networkx Graph, optional (default: Graph())
+        Return graph of this type. The provided instance will be cleared.
+
+    Returns
+    -------
+    G : NetworkX Graph built from create_using if provided.
+
+    .. deprecated:: 2.6
+    """
+    warnings.warn(
+        ("jit_graph is deprecated and will be removed in NetworkX 3.0."),
+        DeprecationWarning,
+    )
+
+    if create_using is None:
+        G = nx.Graph()
+    else:
+        G = create_using
+        G.clear()
+
+    if isinstance(data, str):
+        data = json.loads(data)
+
+    for node in data:
+        G.add_node(node["id"], **node["data"])
+        if node.get("adjacencies") is not None:
+            for adj in node["adjacencies"]:
+                G.add_edge(node["id"], adj["nodeTo"], **adj["data"])
+    return G
+
+
+@not_implemented_for("multigraph")
+def jit_data(G, indent=None, default=None):
+    """Returns data in JIT JSON format.
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+
+    indent: optional, default=None
+        If indent is a non-negative integer, then JSON array elements and
+        object members will be pretty-printed with that indent level.
+        An indent level of 0, or negative, will only insert newlines.
+        None (the default) selects the most compact representation.
+
+    default: optional, default=None
+         It will pass the value to the json.dumps function in order to
+         be able to serialize custom objects used as nodes.
+
+    Returns
+    -------
+    data: JIT JSON string
+
+    .. deprecated:: 2.6
+    """
+    warnings.warn(
+        ("jit_data is deprecated and will be removed in NetworkX 3.0."),
+        DeprecationWarning,
+    )
+    json_graph = []
+    for node in G.nodes():
+        json_node = {"id": node, "name": node}
+        # node data
+        json_node["data"] = G.nodes[node]
+        # adjacencies
+        if G[node]:
+            json_node["adjacencies"] = []
+            for neighbour in G[node]:
+                adjacency = {"nodeTo": neighbour}
+                # adjacency data
+                adjacency["data"] = G.edges[node, neighbour]
+                json_node["adjacencies"].append(adjacency)
+        json_graph.append(json_node)
+    return json.dumps(json_graph, indent=indent, default=default)
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/node_link.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/node_link.py
new file mode 100644
index 0000000..be18658
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/node_link.py
@@ -0,0 +1,201 @@
+from itertools import chain, count
+
+import networkx as nx
+
+__all__ = ["node_link_data", "node_link_graph"]
+
+
+_attrs = dict(source="source", target="target", name="id", key="key", link="links")
+
+
+def _to_tuple(x):
+    """Converts lists to tuples, including nested lists.
+
+    All other non-list inputs are passed through unmodified. This function is
+    intended to be used to convert potentially nested lists from json files
+    into valid nodes.
+
+    Examples
+    --------
+    >>> _to_tuple([1, 2, [3, 4]])
+    (1, 2, (3, 4))
+    """
+    if not isinstance(x, (tuple, list)):
+        return x
+    return tuple(map(_to_tuple, x))
+
+
+def node_link_data(G, attrs=None):
+    """Returns data in node-link format that is suitable for JSON serialization
+    and use in Javascript documents.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    attrs : dict
+        A dictionary that contains five keys 'source', 'target', 'name',
+        'key' and 'link'.  The corresponding values provide the attribute
+        names for storing NetworkX-internal graph data.  The values should
+        be unique.  Default value::
+
+            dict(source='source', target='target', name='id',
+                 key='key', link='links')
+
+        If some user-defined graph data use these attribute names as data keys,
+        they may be silently dropped.
+
+    Returns
+    -------
+    data : dict
+       A dictionary with node-link formatted data.
+
+    Raises
+    ------
+    NetworkXError
+        If values in attrs are not unique.
+
+    Examples
+    --------
+    >>> from networkx.readwrite import json_graph
+    >>> G = nx.Graph([("A", "B")])
+    >>> data1 = json_graph.node_link_data(G)
+    >>> H = nx.gn_graph(2)
+    >>> data2 = json_graph.node_link_data(
+    ...     H, {"link": "edges", "source": "from", "target": "to"}
+    ... )
+
+    To serialize with json
+
+    >>> import json
+    >>> s1 = json.dumps(data1)
+    >>> s2 = json.dumps(
+    ...     data2, default={"link": "edges", "source": "from", "target": "to"}
+    ... )
+
+    Notes
+    -----
+    Graph, node, and link attributes are stored in this format.  Note that
+    attribute keys will be converted to strings in order to comply with JSON.
+
+    Attribute 'key' is only used for multigraphs.
+
+    See Also
+    --------
+    node_link_graph, adjacency_data, tree_data
+    """
+    multigraph = G.is_multigraph()
+    # Allow 'attrs' to keep default values.
+    if attrs is None:
+        attrs = _attrs
+    else:
+        attrs.update({k: v for (k, v) in _attrs.items() if k not in attrs})
+    name = attrs["name"]
+    source = attrs["source"]
+    target = attrs["target"]
+    links = attrs["link"]
+    # Allow 'key' to be omitted from attrs if the graph is not a multigraph.
+    key = None if not multigraph else attrs["key"]
+    if len({source, target, key}) < 3:
+        raise nx.NetworkXError("Attribute names are not unique.")
+    data = {
+        "directed": G.is_directed(),
+        "multigraph": multigraph,
+        "graph": G.graph,
+        "nodes": [dict(chain(G.nodes[n].items(), [(name, n)])) for n in G],
+    }
+    if multigraph:
+        data[links] = [
+            dict(chain(d.items(), [(source, u), (target, v), (key, k)]))
+            for u, v, k, d in G.edges(keys=True, data=True)
+        ]
+    else:
+        data[links] = [
+            dict(chain(d.items(), [(source, u), (target, v)]))
+            for u, v, d in G.edges(data=True)
+        ]
+    return data
+
+
+def node_link_graph(data, directed=False, multigraph=True, attrs=None):
+    """Returns graph from node-link data format.
+
+    Parameters
+    ----------
+    data : dict
+        node-link formatted graph data
+
+    directed : bool
+        If True, and direction not specified in data, return a directed graph.
+
+    multigraph : bool
+        If True, and multigraph not specified in data, return a multigraph.
+
+    attrs : dict
+        A dictionary that contains five keys 'source', 'target', 'name',
+        'key' and 'link'.  The corresponding values provide the attribute
+        names for storing NetworkX-internal graph data.  Default value:
+
+            dict(source='source', target='target', name='id',
+                key='key', link='links')
+
+    Returns
+    -------
+    G : NetworkX graph
+        A NetworkX graph object
+
+    Examples
+    --------
+    >>> from networkx.readwrite import json_graph
+    >>> G = nx.Graph([("A", "B")])
+    >>> data = json_graph.node_link_data(G)
+    >>> H = json_graph.node_link_graph(data)
+
+    Notes
+    -----
+    Attribute 'key' is only used for multigraphs.
+
+    See Also
+    --------
+    node_link_data, adjacency_data, tree_data
+    """
+    # Allow 'attrs' to keep default values.
+    if attrs is None:
+        attrs = _attrs
+    else:
+        attrs.update({k: v for k, v in _attrs.items() if k not in attrs})
+    multigraph = data.get("multigraph", multigraph)
+    directed = data.get("directed", directed)
+    if multigraph:
+        graph = nx.MultiGraph()
+    else:
+        graph = nx.Graph()
+    if directed:
+        graph = graph.to_directed()
+    name = attrs["name"]
+    source = attrs["source"]
+    target = attrs["target"]
+    links = attrs["link"]
+    # Allow 'key' to be omitted from attrs if the graph is not a multigraph.
+    key = None if not multigraph else attrs["key"]
+    graph.graph = data.get("graph", {})
+    c = count()
+    for d in data["nodes"]:
+        node = _to_tuple(d.get(name, next(c)))
+        nodedata = {str(k): v for k, v in d.items() if k != name}
+        graph.add_node(node, **nodedata)
+    for d in data[links]:
+        src = tuple(d[source]) if isinstance(d[source], list) else d[source]
+        tgt = tuple(d[target]) if isinstance(d[target], list) else d[target]
+        if not multigraph:
+            edgedata = {str(k): v for k, v in d.items() if k != source and k != target}
+            graph.add_edge(src, tgt, **edgedata)
+        else:
+            ky = d.get(key, None)
+            edgedata = {
+                str(k): v
+                for k, v in d.items()
+                if k != source and k != target and k != key
+            }
+            graph.add_edge(src, tgt, ky, **edgedata)
+    return graph
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_adjacency.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_adjacency.py
new file mode 100644
index 0000000..48f3440
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_adjacency.py
@@ -0,0 +1,60 @@
+import json
+
+import pytest
+
+import networkx as nx
+from networkx.readwrite.json_graph import adjacency_data, adjacency_graph
+
+
+class TestAdjacency:
+    def test_graph(self):
+        G = nx.path_graph(4)
+        H = adjacency_graph(adjacency_data(G))
+        nx.is_isomorphic(G, H)
+
+    def test_graph_attributes(self):
+        G = nx.path_graph(4)
+        G.add_node(1, color="red")
+        G.add_edge(1, 2, width=7)
+        G.graph["foo"] = "bar"
+        G.graph[1] = "one"
+
+        H = adjacency_graph(adjacency_data(G))
+        assert H.graph["foo"] == "bar"
+        assert H.nodes[1]["color"] == "red"
+        assert H[1][2]["width"] == 7
+
+        d = json.dumps(adjacency_data(G))
+        H = adjacency_graph(json.loads(d))
+        assert H.graph["foo"] == "bar"
+        assert H.graph[1] == "one"
+        assert H.nodes[1]["color"] == "red"
+        assert H[1][2]["width"] == 7
+
+    def test_digraph(self):
+        G = nx.DiGraph()
+        nx.add_path(G, [1, 2, 3])
+        H = adjacency_graph(adjacency_data(G))
+        assert H.is_directed()
+        nx.is_isomorphic(G, H)
+
+    def test_multidigraph(self):
+        G = nx.MultiDiGraph()
+        nx.add_path(G, [1, 2, 3])
+        H = adjacency_graph(adjacency_data(G))
+        assert H.is_directed()
+        assert H.is_multigraph()
+
+    def test_multigraph(self):
+        G = nx.MultiGraph()
+        G.add_edge(1, 2, key="first")
+        G.add_edge(1, 2, key="second", color="blue")
+        H = adjacency_graph(adjacency_data(G))
+        nx.is_isomorphic(G, H)
+        assert H[1][2]["second"]["color"] == "blue"
+
+    def test_exception(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.MultiDiGraph()
+            attrs = dict(id="node", key="node")
+            adjacency_data(G, attrs)
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_cytoscape.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_cytoscape.py
new file mode 100644
index 0000000..cdb101f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_cytoscape.py
@@ -0,0 +1,95 @@
+import copy
+import json
+
+import pytest
+
+import networkx as nx
+from networkx.readwrite.json_graph import cytoscape_data, cytoscape_graph
+
+
+# TODO: To be removed when signature change complete in 3.0
+def test_attrs_deprecation(recwarn):
+    G = nx.path_graph(3)
+
+    # No warnings when `attrs` kwarg not used
+    data = cytoscape_data(G)
+    H = cytoscape_graph(data)
+    assert len(recwarn) == 0
+
+    # Future warning raised with `attrs` kwarg
+    attrs = {"name": "foo", "ident": "bar"}
+    with pytest.warns(DeprecationWarning):
+        data = cytoscape_data(G, attrs)
+    with pytest.warns(DeprecationWarning):
+        H = cytoscape_graph(data, attrs)
+
+
+def test_graph():
+    G = nx.path_graph(4)
+    H = cytoscape_graph(cytoscape_data(G))
+    nx.is_isomorphic(G, H)
+
+
+def test_input_data_is_not_modified_when_building_graph():
+    G = nx.path_graph(4)
+    input_data = cytoscape_data(G)
+    orig_data = copy.deepcopy(input_data)
+    # Ensure input is unmodified by cytoscape_graph (gh-4173)
+    cytoscape_graph(input_data)
+    assert input_data == orig_data
+
+
+def test_graph_attributes():
+    G = nx.path_graph(4)
+    G.add_node(1, color="red")
+    G.add_edge(1, 2, width=7)
+    G.graph["foo"] = "bar"
+    G.graph[1] = "one"
+    G.add_node(3, name="node", id="123")
+
+    H = cytoscape_graph(cytoscape_data(G))
+    assert H.graph["foo"] == "bar"
+    assert H.nodes[1]["color"] == "red"
+    assert H[1][2]["width"] == 7
+    assert H.nodes[3]["name"] == "node"
+    assert H.nodes[3]["id"] == "123"
+
+    d = json.dumps(cytoscape_data(G))
+    H = cytoscape_graph(json.loads(d))
+    assert H.graph["foo"] == "bar"
+    assert H.graph[1] == "one"
+    assert H.nodes[1]["color"] == "red"
+    assert H[1][2]["width"] == 7
+    assert H.nodes[3]["name"] == "node"
+    assert H.nodes[3]["id"] == "123"
+
+
+def test_digraph():
+    G = nx.DiGraph()
+    nx.add_path(G, [1, 2, 3])
+    H = cytoscape_graph(cytoscape_data(G))
+    assert H.is_directed()
+    nx.is_isomorphic(G, H)
+
+
+def test_multidigraph():
+    G = nx.MultiDiGraph()
+    nx.add_path(G, [1, 2, 3])
+    H = cytoscape_graph(cytoscape_data(G))
+    assert H.is_directed()
+    assert H.is_multigraph()
+
+
+def test_multigraph():
+    G = nx.MultiGraph()
+    G.add_edge(1, 2, key="first")
+    G.add_edge(1, 2, key="second", color="blue")
+    H = cytoscape_graph(cytoscape_data(G))
+    assert nx.is_isomorphic(G, H)
+    assert H[1][2]["second"]["color"] == "blue"
+
+
+def test_exception():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.MultiDiGraph()
+        cytoscape_data(G, name="foo", ident="foo")
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_jit.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_jit.py
new file mode 100644
index 0000000..309c405
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_jit.py
@@ -0,0 +1,66 @@
+import json
+
+import pytest
+
+import networkx as nx
+from networkx.readwrite.json_graph import jit_data, jit_graph
+
+
+class TestJIT:
+    def test_jit(self):
+        G = nx.Graph()
+        G.add_node("Node1", node_data="foobar")
+        G.add_node("Node3", node_data="bar")
+        G.add_node("Node4")
+        G.add_edge("Node1", "Node2", weight=9, something="isSomething")
+        G.add_edge("Node2", "Node3", weight=4, something="isNotSomething")
+        G.add_edge("Node1", "Node2")
+        d = jit_data(G)
+        K = jit_graph(json.loads(d))
+        assert nx.is_isomorphic(G, K)
+
+    def test_jit_2(self):
+        G = nx.Graph()
+        G.add_node(1, node_data=3)
+        G.add_node(3, node_data=0)
+        G.add_edge(1, 2, weight=9, something=0)
+        G.add_edge(2, 3, weight=4, something=3)
+        G.add_edge(1, 2)
+        d = jit_data(G)
+        K = jit_graph(json.loads(d))
+        assert nx.is_isomorphic(G, K)
+
+    def test_jit_directed(self):
+        G = nx.DiGraph()
+        G.add_node(1, node_data=3)
+        G.add_node(3, node_data=0)
+        G.add_edge(1, 2, weight=9, something=0)
+        G.add_edge(2, 3, weight=4, something=3)
+        G.add_edge(1, 2)
+        d = jit_data(G)
+        K = jit_graph(json.loads(d), create_using=nx.DiGraph())
+        assert nx.is_isomorphic(G, K)
+
+    def test_jit_multi_directed(self):
+        G = nx.MultiDiGraph()
+        G.add_node(1, node_data=3)
+        G.add_node(3, node_data=0)
+        G.add_edge(1, 2, weight=9, something=0)
+        G.add_edge(2, 3, weight=4, something=3)
+        G.add_edge(1, 2)
+        pytest.raises(nx.NetworkXNotImplemented, jit_data, G)
+
+        H = nx.DiGraph(G)
+        d = jit_data(H)
+        K = jit_graph(json.loads(d), create_using=nx.MultiDiGraph())
+        assert nx.is_isomorphic(H, K)
+        K.add_edge(1, 2)
+        assert not nx.is_isomorphic(H, K)
+        assert nx.is_isomorphic(G, K)
+
+    def test_jit_round_trip(self):
+        G = nx.Graph()
+        d = nx.jit_data(G)
+        H = jit_graph(json.loads(d))
+        K = jit_graph(d)
+        assert nx.is_isomorphic(H, K)
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_node_link.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_node_link.py
new file mode 100644
index 0000000..bc46e7b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_node_link.py
@@ -0,0 +1,106 @@
+import json
+
+import pytest
+
+import networkx as nx
+from networkx.readwrite.json_graph import node_link_data, node_link_graph
+
+
+class TestNodeLink:
+    def test_graph(self):
+        G = nx.path_graph(4)
+        H = node_link_graph(node_link_data(G))
+        assert nx.is_isomorphic(G, H)
+
+    def test_graph_attributes(self):
+        G = nx.path_graph(4)
+        G.add_node(1, color="red")
+        G.add_edge(1, 2, width=7)
+        G.graph[1] = "one"
+        G.graph["foo"] = "bar"
+
+        H = node_link_graph(node_link_data(G))
+        assert H.graph["foo"] == "bar"
+        assert H.nodes[1]["color"] == "red"
+        assert H[1][2]["width"] == 7
+
+        d = json.dumps(node_link_data(G))
+        H = node_link_graph(json.loads(d))
+        assert H.graph["foo"] == "bar"
+        assert H.graph["1"] == "one"
+        assert H.nodes[1]["color"] == "red"
+        assert H[1][2]["width"] == 7
+
+    def test_digraph(self):
+        G = nx.DiGraph()
+        H = node_link_graph(node_link_data(G))
+        assert H.is_directed()
+
+    def test_multigraph(self):
+        G = nx.MultiGraph()
+        G.add_edge(1, 2, key="first")
+        G.add_edge(1, 2, key="second", color="blue")
+        H = node_link_graph(node_link_data(G))
+        nx.is_isomorphic(G, H)
+        assert H[1][2]["second"]["color"] == "blue"
+
+    def test_graph_with_tuple_nodes(self):
+        G = nx.Graph()
+        G.add_edge((0, 0), (1, 0), color=[255, 255, 0])
+        d = node_link_data(G)
+        dumped_d = json.dumps(d)
+        dd = json.loads(dumped_d)
+        H = node_link_graph(dd)
+        assert H.nodes[(0, 0)] == G.nodes[(0, 0)]
+        assert H[(0, 0)][(1, 0)]["color"] == [255, 255, 0]
+
+    def test_unicode_keys(self):
+        q = "qualité"
+        G = nx.Graph()
+        G.add_node(1, **{q: q})
+        s = node_link_data(G)
+        output = json.dumps(s, ensure_ascii=False)
+        data = json.loads(output)
+        H = node_link_graph(data)
+        assert H.nodes[1][q] == q
+
+    def test_exception(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.MultiDiGraph()
+            attrs = dict(name="node", source="node", target="node", key="node")
+            node_link_data(G, attrs)
+
+    def test_string_ids(self):
+        q = "qualité"
+        G = nx.DiGraph()
+        G.add_node("A")
+        G.add_node(q)
+        G.add_edge("A", q)
+        data = node_link_data(G)
+        assert data["links"][0]["source"] == "A"
+        assert data["links"][0]["target"] == q
+        H = node_link_graph(data)
+        assert nx.is_isomorphic(G, H)
+
+    def test_custom_attrs(self):
+        G = nx.path_graph(4)
+        G.add_node(1, color="red")
+        G.add_edge(1, 2, width=7)
+        G.graph[1] = "one"
+        G.graph["foo"] = "bar"
+
+        attrs = dict(
+            source="c_source",
+            target="c_target",
+            name="c_id",
+            key="c_key",
+            link="c_links",
+        )
+
+        H = node_link_graph(
+            node_link_data(G, attrs=attrs), multigraph=False, attrs=attrs
+        )
+        assert nx.is_isomorphic(G, H)
+        assert H.graph["foo"] == "bar"
+        assert H.nodes[1]["color"] == "red"
+        assert H[1][2]["width"] == 7
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_tree.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_tree.py
new file mode 100644
index 0000000..ea19810
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tests/test_tree.py
@@ -0,0 +1,65 @@
+import json
+
+import pytest
+
+import networkx as nx
+from networkx.readwrite.json_graph import tree_data, tree_graph
+
+
+def test_graph():
+    G = nx.DiGraph()
+    G.add_nodes_from([1, 2, 3], color="red")
+    G.add_edge(1, 2, foo=7)
+    G.add_edge(1, 3, foo=10)
+    G.add_edge(3, 4, foo=10)
+    H = tree_graph(tree_data(G, 1))
+    nx.is_isomorphic(G, H)
+
+
+def test_graph_attributes():
+    G = nx.DiGraph()
+    G.add_nodes_from([1, 2, 3], color="red")
+    G.add_edge(1, 2, foo=7)
+    G.add_edge(1, 3, foo=10)
+    G.add_edge(3, 4, foo=10)
+    H = tree_graph(tree_data(G, 1))
+    assert H.nodes[1]["color"] == "red"
+
+    d = json.dumps(tree_data(G, 1))
+    H = tree_graph(json.loads(d))
+    assert H.nodes[1]["color"] == "red"
+
+
+def test_exceptions():
+    with pytest.raises(TypeError, match="is not a tree."):
+        G = nx.complete_graph(3)
+        tree_data(G, 0)
+    with pytest.raises(TypeError, match="is not directed."):
+        G = nx.path_graph(3)
+        tree_data(G, 0)
+    with pytest.raises(TypeError, match="is not weakly connected."):
+        G = nx.path_graph(3, create_using=nx.DiGraph)
+        G.add_edge(2, 0)
+        G.add_node(3)
+        tree_data(G, 0)
+    with pytest.raises(nx.NetworkXError, match="must be different."):
+        G = nx.MultiDiGraph()
+        G.add_node(0)
+        tree_data(G, 0, ident="node", children="node")
+
+
+# NOTE: To be removed when deprecation expires in 3.0
+def test_attrs_deprecation(recwarn):
+    G = nx.path_graph(3, create_using=nx.DiGraph)
+
+    # No warnings when `attrs` kwarg not used
+    data = tree_data(G, 0)
+    H = tree_graph(data)
+    assert len(recwarn) == 0
+
+    # DeprecationWarning issued when `attrs` is used
+    attrs = {"id": "foo", "children": "bar"}
+    with pytest.warns(DeprecationWarning):
+        data = tree_data(G, 0, attrs=attrs)
+    with pytest.warns(DeprecationWarning):
+        H = tree_graph(data, attrs=attrs)
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tree.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tree.py
new file mode 100644
index 0000000..ab7098c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/json_graph/tree.py
@@ -0,0 +1,205 @@
+from itertools import chain
+
+import networkx as nx
+
+__all__ = ["tree_data", "tree_graph"]
+
+
+# NOTE: Remove attrs from signature in 3.0
+def tree_data(G, root, attrs=None, ident="id", children="children"):
+    """Returns data in tree format that is suitable for JSON serialization
+    and use in Javascript documents.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       G must be an oriented tree
+
+    root : node
+       The root of the tree
+
+    attrs : dict
+        A dictionary that contains two keys 'id' and 'children'. The
+        corresponding values provide the attribute names for storing
+        NetworkX-internal graph data. The values should be unique. Default
+        value: :samp:`dict(id='id', children='children')`.
+
+        If some user-defined graph data use these attribute names as data keys,
+        they may be silently dropped.
+
+        .. deprecated:: 2.6
+
+           The `attrs` keyword argument is replaced by `ident` and `children`
+           and will be removed in networkx 3.0
+
+    ident : string
+        Attribute name for storing NetworkX-internal graph data. `ident` must
+        have a different value than `children`. The default is 'id'.
+
+    children : string
+        Attribute name for storing NetworkX-internal graph data. `children`
+        must have a different value than `ident`. The default is 'children'.
+
+    Returns
+    -------
+    data : dict
+       A dictionary with node-link formatted data.
+
+    Raises
+    ------
+    NetworkXError
+        If `children` and `ident` attributes are identical.
+
+    Examples
+    --------
+    >>> from networkx.readwrite import json_graph
+    >>> G = nx.DiGraph([(1, 2)])
+    >>> data = json_graph.tree_data(G, root=1)
+
+    To serialize with json
+
+    >>> import json
+    >>> s = json.dumps(data)
+
+    Notes
+    -----
+    Node attributes are stored in this format but keys
+    for attributes must be strings if you want to serialize with JSON.
+
+    Graph and edge attributes are not stored.
+
+    See Also
+    --------
+    tree_graph, node_link_data, adjacency_data
+    """
+    if G.number_of_nodes() != G.number_of_edges() + 1:
+        raise TypeError("G is not a tree.")
+    if not G.is_directed():
+        raise TypeError("G is not directed.")
+    if not nx.is_weakly_connected(G):
+        raise TypeError("G is not weakly connected.")
+
+    # NOTE: to be removed in 3.0
+    if attrs is not None:
+        import warnings
+
+        msg = (
+            "\nThe `attrs` keyword argument of tree_data is deprecated\n"
+            "and will be removed in networkx 3.0.\n"
+            "It is replaced with explicit `ident` and `children` "
+            "keyword arguments.\n"
+            "To make this warning go away and ensure usage is forward\n"
+            "compatible, replace `attrs` with `ident` and `children,\n"
+            "for example:\n\n"
+            "    >>> tree_data(G, root, attrs={'id': 'foo', 'children': 'bar'})\n\n"
+            "should instead be written as\n\n"
+            "    >>> tree_data(G, root, ident='foo', children='bar')\n\n"
+            "The default values of 'id' and 'children' will not change."
+        )
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+
+        ident = attrs["id"]
+        children = attrs["children"]
+
+    if ident == children:
+        raise nx.NetworkXError("The values for `id` and `children` must be different.")
+
+    def add_children(n, G):
+        nbrs = G[n]
+        if len(nbrs) == 0:
+            return []
+        children_ = []
+        for child in nbrs:
+            d = dict(chain(G.nodes[child].items(), [(ident, child)]))
+            c = add_children(child, G)
+            if c:
+                d[children] = c
+            children_.append(d)
+        return children_
+
+    data = dict(chain(G.nodes[root].items(), [(ident, root)]))
+    data[children] = add_children(root, G)
+    return data
+
+
+def tree_graph(data, attrs=None, ident="id", children="children"):
+    """Returns graph from tree data format.
+
+    Parameters
+    ----------
+    data : dict
+        Tree formatted graph data
+    attrs : dict
+        A dictionary that contains two keys 'id' and 'children'. The
+        corresponding values provide the attribute names for storing
+        NetworkX-internal graph data. The values should be unique. Default
+        value: :samp:`dict(id='id', children='children')`.
+
+        .. deprecated:: 2.6
+
+           The `attrs` keyword argument is replaced by `ident` and `children`
+           and will be removed in networkx 3.0
+
+    ident : string
+        Attribute name for storing NetworkX-internal graph data. `ident` must
+        have a different value than `children`. The default is 'id'.
+
+    children : string
+        Attribute name for storing NetworkX-internal graph data. `children`
+        must have a different value than `ident`. The default is 'children'.
+
+    Returns
+    -------
+    G : NetworkX DiGraph
+
+    Examples
+    --------
+    >>> from networkx.readwrite import json_graph
+    >>> G = nx.DiGraph([(1, 2)])
+    >>> data = json_graph.tree_data(G, root=1)
+    >>> H = json_graph.tree_graph(data)
+
+    See Also
+    --------
+    tree_data, node_link_data, adjacency_data
+    """
+    graph = nx.DiGraph()
+    if attrs is not None:
+        import warnings
+
+        msg = (
+            "\nThe `attrs` keyword argument of tree_graph is deprecated\n"
+            "and will be removed in networkx 3.0.\n"
+            "It is replaced with explicit `ident` and `children` "
+            "keyword arguments.\n"
+            "To make this warning go away and ensure usage is\n"
+            "forward compatible, replace `attrs` with `ident` and `children,\n"
+            "for example:\n\n"
+            "    >>> tree_graph(data, attrs={'id': 'foo', 'children': 'bar'})\n\n"
+            "should instead be written as\n\n"
+            "    >>> tree_graph(data, ident='foo', children='bar')\n\n"
+            "The default values of 'id' and 'children' will not change."
+        )
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+
+        ident = attrs["id"]
+        children = attrs["children"]
+
+    def add_children(parent, children_):
+        for data in children_:
+            child = data[ident]
+            graph.add_edge(parent, child)
+            grandchildren = data.get(children, [])
+            if grandchildren:
+                add_children(child, grandchildren)
+            nodedata = {
+                str(k): v for k, v in data.items() if k != ident and k != children
+            }
+            graph.add_node(child, **nodedata)
+
+    root = data[ident]
+    children_ = data.get(children, [])
+    nodedata = {str(k): v for k, v in data.items() if k != ident and k != children}
+    graph.add_node(root, **nodedata)
+    add_children(root, children_)
+    return graph
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/leda.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/leda.py
new file mode 100644
index 0000000..cde778d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/leda.py
@@ -0,0 +1,106 @@
+"""
+Read graphs in LEDA format.
+
+LEDA is a C++ class library for efficient data types and algorithms.
+
+Format
+------
+See http://www.algorithmic-solutions.info/leda_guide/graphs/leda_native_graph_fileformat.html
+
+"""
+# Original author: D. Eppstein, UC Irvine, August 12, 2003.
+# The original code at http://www.ics.uci.edu/~eppstein/PADS/ is public domain.
+
+__all__ = ["read_leda", "parse_leda"]
+
+import networkx as nx
+from networkx.exception import NetworkXError
+from networkx.utils import open_file
+
+
+@open_file(0, mode="rb")
+def read_leda(path, encoding="UTF-8"):
+    """Read graph in LEDA format from path.
+
+    Parameters
+    ----------
+    path : file or string
+       File or filename to read.  Filenames ending in .gz or .bz2  will be
+       uncompressed.
+
+    Returns
+    -------
+    G : NetworkX graph
+
+    Examples
+    --------
+    G=nx.read_leda('file.leda')
+
+    References
+    ----------
+    .. [1] http://www.algorithmic-solutions.info/leda_guide/graphs/leda_native_graph_fileformat.html
+    """
+    lines = (line.decode(encoding) for line in path)
+    G = parse_leda(lines)
+    return G
+
+
+def parse_leda(lines):
+    """Read graph in LEDA format from string or iterable.
+
+    Parameters
+    ----------
+    lines : string or iterable
+       Data in LEDA format.
+
+    Returns
+    -------
+    G : NetworkX graph
+
+    Examples
+    --------
+    G=nx.parse_leda(string)
+
+    References
+    ----------
+    .. [1] http://www.algorithmic-solutions.info/leda_guide/graphs/leda_native_graph_fileformat.html
+    """
+    if isinstance(lines, str):
+        lines = iter(lines.split("\n"))
+    lines = iter(
+        [
+            line.rstrip("\n")
+            for line in lines
+            if not (line.startswith("#") or line.startswith("\n") or line == "")
+        ]
+    )
+    for i in range(3):
+        next(lines)
+    # Graph
+    du = int(next(lines))  # -1=directed, -2=undirected
+    if du == -1:
+        G = nx.DiGraph()
+    else:
+        G = nx.Graph()
+
+    # Nodes
+    n = int(next(lines))  # number of nodes
+    node = {}
+    for i in range(1, n + 1):  # LEDA counts from 1 to n
+        symbol = next(lines).rstrip().strip("|{}|  ")
+        if symbol == "":
+            symbol = str(i)  # use int if no label - could be trouble
+        node[i] = symbol
+
+    G.add_nodes_from([s for i, s in node.items()])
+
+    # Edges
+    m = int(next(lines))  # number of edges
+    for i in range(m):
+        try:
+            s, t, reversal, label = next(lines).split()
+        except BaseException as err:
+            raise NetworkXError(f"Too few fields in LEDA.GRAPH edge {i+1}") from err
+        # BEWARE: no handling of reversal edges
+        G.add_edge(node[int(s)], node[int(t)], label=label[2:-2])
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/multiline_adjlist.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/multiline_adjlist.py
new file mode 100644
index 0000000..8398685
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/multiline_adjlist.py
@@ -0,0 +1,391 @@
+"""
+*************************
+Multi-line Adjacency List
+*************************
+Read and write NetworkX graphs as multi-line adjacency lists.
+
+The multi-line adjacency list format is useful for graphs with
+nodes that can be meaningfully represented as strings.  With this format
+simple edge data can be stored but node or graph data is not.
+
+Format
+------
+The first label in a line is the source node label followed by the node degree
+d.  The next d lines are target node labels and optional edge data.
+That pattern repeats for all nodes in the graph.
+
+The graph with edges a-b, a-c, d-e can be represented as the following
+adjacency list (anything following the # in a line is a comment)::
+
+     # example.multiline-adjlist
+     a 2
+     b
+     c
+     d 1
+     e
+"""
+
+__all__ = [
+    "generate_multiline_adjlist",
+    "write_multiline_adjlist",
+    "parse_multiline_adjlist",
+    "read_multiline_adjlist",
+]
+
+import networkx as nx
+from networkx.utils import open_file
+
+
+def generate_multiline_adjlist(G, delimiter=" "):
+    """Generate a single line of the graph G in multiline adjacency list format.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    delimiter : string, optional
+       Separator for node labels
+
+    Returns
+    -------
+    lines : string
+        Lines of data in multiline adjlist format.
+
+    Examples
+    --------
+    >>> G = nx.lollipop_graph(4, 3)
+    >>> for line in nx.generate_multiline_adjlist(G):
+    ...     print(line)
+    0 3
+    1 {}
+    2 {}
+    3 {}
+    1 2
+    2 {}
+    3 {}
+    2 1
+    3 {}
+    3 1
+    4 {}
+    4 1
+    5 {}
+    5 1
+    6 {}
+    6 0
+
+    See Also
+    --------
+    write_multiline_adjlist, read_multiline_adjlist
+    """
+    if G.is_directed():
+        if G.is_multigraph():
+            for s, nbrs in G.adjacency():
+                nbr_edges = [
+                    (u, data)
+                    for u, datadict in nbrs.items()
+                    for key, data in datadict.items()
+                ]
+                deg = len(nbr_edges)
+                yield str(s) + delimiter + str(deg)
+                for u, d in nbr_edges:
+                    if d is None:
+                        yield str(u)
+                    else:
+                        yield str(u) + delimiter + str(d)
+        else:  # directed single edges
+            for s, nbrs in G.adjacency():
+                deg = len(nbrs)
+                yield str(s) + delimiter + str(deg)
+                for u, d in nbrs.items():
+                    if d is None:
+                        yield str(u)
+                    else:
+                        yield str(u) + delimiter + str(d)
+    else:  # undirected
+        if G.is_multigraph():
+            seen = set()  # helper dict used to avoid duplicate edges
+            for s, nbrs in G.adjacency():
+                nbr_edges = [
+                    (u, data)
+                    for u, datadict in nbrs.items()
+                    if u not in seen
+                    for key, data in datadict.items()
+                ]
+                deg = len(nbr_edges)
+                yield str(s) + delimiter + str(deg)
+                for u, d in nbr_edges:
+                    if d is None:
+                        yield str(u)
+                    else:
+                        yield str(u) + delimiter + str(d)
+                seen.add(s)
+        else:  # undirected single edges
+            seen = set()  # helper dict used to avoid duplicate edges
+            for s, nbrs in G.adjacency():
+                nbr_edges = [(u, d) for u, d in nbrs.items() if u not in seen]
+                deg = len(nbr_edges)
+                yield str(s) + delimiter + str(deg)
+                for u, d in nbr_edges:
+                    if d is None:
+                        yield str(u)
+                    else:
+                        yield str(u) + delimiter + str(d)
+                seen.add(s)
+
+
+@open_file(1, mode="wb")
+def write_multiline_adjlist(G, path, delimiter=" ", comments="#", encoding="utf-8"):
+    """Write the graph G in multiline adjacency list format to path
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    path : string or file
+       Filename or file handle to write to.
+       Filenames ending in .gz or .bz2 will be compressed.
+
+    comments : string, optional
+       Marker for comment lines
+
+    delimiter : string, optional
+       Separator for node labels
+
+    encoding : string, optional
+       Text encoding.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_multiline_adjlist(G, "test.adjlist")
+
+    The path can be a file handle or a string with the name of the file. If a
+    file handle is provided, it has to be opened in 'wb' mode.
+
+    >>> fh = open("test.adjlist", "wb")
+    >>> nx.write_multiline_adjlist(G, fh)
+
+    Filenames ending in .gz or .bz2 will be compressed.
+
+    >>> nx.write_multiline_adjlist(G, "test.adjlist.gz")
+
+    See Also
+    --------
+    read_multiline_adjlist
+    """
+    import sys
+    import time
+
+    pargs = comments + " ".join(sys.argv)
+    header = (
+        f"{pargs}\n"
+        + comments
+        + f" GMT {time.asctime(time.gmtime())}\n"
+        + comments
+        + f" {G.name}\n"
+    )
+    path.write(header.encode(encoding))
+
+    for multiline in generate_multiline_adjlist(G, delimiter):
+        multiline += "\n"
+        path.write(multiline.encode(encoding))
+
+
+def parse_multiline_adjlist(
+    lines, comments="#", delimiter=None, create_using=None, nodetype=None, edgetype=None
+):
+    """Parse lines of a multiline adjacency list representation of a graph.
+
+    Parameters
+    ----------
+    lines : list or iterator of strings
+        Input data in multiline adjlist format
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    nodetype : Python type, optional
+       Convert nodes to this type.
+
+    edgetype : Python type, optional
+       Convert edges to this type.
+
+    comments : string, optional
+       Marker for comment lines
+
+    delimiter : string, optional
+       Separator for node labels.  The default is whitespace.
+
+    Returns
+    -------
+    G: NetworkX graph
+        The graph corresponding to the lines in multiline adjacency list format.
+
+    Examples
+    --------
+    >>> lines = [
+    ...     "1 2",
+    ...     "2 {'weight':3, 'name': 'Frodo'}",
+    ...     "3 {}",
+    ...     "2 1",
+    ...     "5 {'weight':6, 'name': 'Saruman'}",
+    ... ]
+    >>> G = nx.parse_multiline_adjlist(iter(lines), nodetype=int)
+    >>> list(G)
+    [1, 2, 3, 5]
+
+    """
+    from ast import literal_eval
+
+    G = nx.empty_graph(0, create_using)
+    for line in lines:
+        p = line.find(comments)
+        if p >= 0:
+            line = line[:p]
+        if not line:
+            continue
+        try:
+            (u, deg) = line.strip().split(delimiter)
+            deg = int(deg)
+        except BaseException as err:
+            raise TypeError(f"Failed to read node and degree on line ({line})") from err
+        if nodetype is not None:
+            try:
+                u = nodetype(u)
+            except BaseException as err:
+                raise TypeError(
+                    f"Failed to convert node ({u}) to " f"type {nodetype}"
+                ) from err
+        G.add_node(u)
+        for i in range(deg):
+            while True:
+                try:
+                    line = next(lines)
+                except StopIteration as err:
+                    msg = f"Failed to find neighbor for node ({u})"
+                    raise TypeError(msg) from err
+                p = line.find(comments)
+                if p >= 0:
+                    line = line[:p]
+                if line:
+                    break
+            vlist = line.strip().split(delimiter)
+            numb = len(vlist)
+            if numb < 1:
+                continue  # isolated node
+            v = vlist.pop(0)
+            data = "".join(vlist)
+            if nodetype is not None:
+                try:
+                    v = nodetype(v)
+                except BaseException as err:
+                    raise TypeError(
+                        f"Failed to convert node ({v}) " f"to type {nodetype}"
+                    ) from err
+            if edgetype is not None:
+                try:
+                    edgedata = {"weight": edgetype(data)}
+                except BaseException as err:
+                    raise TypeError(
+                        f"Failed to convert edge data ({data}) " f"to type {edgetype}"
+                    ) from err
+            else:
+                try:  # try to evaluate
+                    edgedata = literal_eval(data)
+                except:
+                    edgedata = {}
+            G.add_edge(u, v, **edgedata)
+
+    return G
+
+
+@open_file(0, mode="rb")
+def read_multiline_adjlist(
+    path,
+    comments="#",
+    delimiter=None,
+    create_using=None,
+    nodetype=None,
+    edgetype=None,
+    encoding="utf-8",
+):
+    """Read graph in multi-line adjacency list format from path.
+
+    Parameters
+    ----------
+    path : string or file
+       Filename or file handle to read.
+       Filenames ending in .gz or .bz2 will be uncompressed.
+
+    create_using : NetworkX graph constructor, optional (default=nx.Graph)
+       Graph type to create. If graph instance, then cleared before populated.
+
+    nodetype : Python type, optional
+       Convert nodes to this type.
+
+    edgetype : Python type, optional
+       Convert edge data to this type.
+
+    comments : string, optional
+       Marker for comment lines
+
+    delimiter : string, optional
+       Separator for node labels.  The default is whitespace.
+
+    Returns
+    -------
+    G: NetworkX graph
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_multiline_adjlist(G, "test.adjlist")
+    >>> G = nx.read_multiline_adjlist("test.adjlist")
+
+    The path can be a file or a string with the name of the file. If a
+    file s provided, it has to be opened in 'rb' mode.
+
+    >>> fh = open("test.adjlist", "rb")
+    >>> G = nx.read_multiline_adjlist(fh)
+
+    Filenames ending in .gz or .bz2 will be compressed.
+
+    >>> nx.write_multiline_adjlist(G, "test.adjlist.gz")
+    >>> G = nx.read_multiline_adjlist("test.adjlist.gz")
+
+    The optional nodetype is a function to convert node strings to nodetype.
+
+    For example
+
+    >>> G = nx.read_multiline_adjlist("test.adjlist", nodetype=int)
+
+    will attempt to convert all nodes to integer type.
+
+    The optional edgetype is a function to convert edge data strings to
+    edgetype.
+
+    >>> G = nx.read_multiline_adjlist("test.adjlist")
+
+    The optional create_using parameter is a NetworkX graph container.
+    The default is Graph(), an undirected graph.  To read the data as
+    a directed graph use
+
+    >>> G = nx.read_multiline_adjlist("test.adjlist", create_using=nx.DiGraph)
+
+    Notes
+    -----
+    This format does not store graph, node, or edge data.
+
+    See Also
+    --------
+    write_multiline_adjlist
+    """
+    lines = (line.decode(encoding) for line in path)
+    return parse_multiline_adjlist(
+        lines,
+        comments=comments,
+        delimiter=delimiter,
+        create_using=create_using,
+        nodetype=nodetype,
+        edgetype=edgetype,
+    )
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/nx_shp.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/nx_shp.py
new file mode 100644
index 0000000..dd48712
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/nx_shp.py
@@ -0,0 +1,350 @@
+"""
+*********
+Shapefile
+*********
+
+Generates a networkx.DiGraph from point and line shapefiles.
+
+"The Esri Shapefile or simply a shapefile is a popular geospatial vector
+data format for geographic information systems software. It is developed
+and regulated by Esri as a (mostly) open specification for data
+interoperability among Esri and other software products."
+See https://en.wikipedia.org/wiki/Shapefile for additional information.
+"""
+import warnings
+
+import networkx as nx
+
+__all__ = ["read_shp", "write_shp"]
+
+
+def read_shp(path, simplify=True, geom_attrs=True, strict=True):
+    """Generates a networkx.DiGraph from shapefiles.
+
+    .. deprecated:: 2.6
+
+       read_shp is deprecated and will be removed in NetworkX 3.0.
+       See https://networkx.org/documentation/latest/auto_examples/index.html#geospatial.
+
+    Point geometries are
+    translated into nodes, lines into edges. Coordinate tuples are used as
+    keys. Attributes are preserved, line geometries are simplified into start
+    and end coordinates. Accepts a single shapefile or directory of many
+    shapefiles.
+
+    "The Esri Shapefile or simply a shapefile is a popular geospatial vector
+    data format for geographic information systems software [1]_."
+
+    Parameters
+    ----------
+    path : file or string
+       File, directory, or filename to read.
+
+    simplify:  bool
+        If True, simplify line geometries to start and end coordinates.
+        If False, and line feature geometry has multiple segments, the
+        non-geometric attributes for that feature will be repeated for each
+        edge comprising that feature.
+
+    geom_attrs: bool
+        If True, include the Wkb, Wkt and Json geometry attributes with
+        each edge.
+
+        NOTE:  if these attributes are available, write_shp will use them
+        to write the geometry.  If nodes store the underlying coordinates for
+        the edge geometry as well (as they do when they are read via
+        this method) and they change, your geomety will be out of sync.
+
+    strict: bool
+        If True, raise NetworkXError when feature geometry is missing or
+        GeometryType is not supported.
+        If False, silently ignore missing or unsupported geometry in features.
+
+    Returns
+    -------
+    G : NetworkX graph
+
+    Raises
+    ------
+    ImportError
+       If ogr module is not available.
+
+    RuntimeError
+       If file cannot be open or read.
+
+    NetworkXError
+       If strict=True and feature is missing geometry or GeometryType is
+       not supported.
+
+    Examples
+    --------
+    >>> G = nx.read_shp("test.shp")  # doctest: +SKIP
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Shapefile
+    """
+    msg = (
+        "read_shp is deprecated and will be removed in 3.0."
+        "See https://networkx.org/documentation/latest/auto_examples/index.html#geospatial."
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    try:
+        from osgeo import ogr
+    except ImportError as err:
+        raise ImportError("read_shp requires OGR: http://www.gdal.org/") from err
+
+    if not isinstance(path, str):
+        return
+
+    net = nx.DiGraph()
+    shp = ogr.Open(path)
+    if shp is None:
+        raise RuntimeError(f"Unable to open {path}")
+    for lyr in shp:
+        fields = [x.GetName() for x in lyr.schema]
+        for f in lyr:
+            g = f.geometry()
+            if g is None:
+                if strict:
+                    raise nx.NetworkXError("Bad data: feature missing geometry")
+                else:
+                    continue
+            flddata = [f.GetField(f.GetFieldIndex(x)) for x in fields]
+            attributes = dict(zip(fields, flddata))
+            attributes["ShpName"] = lyr.GetName()
+            # Note:  Using layer level geometry type
+            if g.GetGeometryType() == ogr.wkbPoint:
+                net.add_node((g.GetPoint_2D(0)), **attributes)
+            elif g.GetGeometryType() in (ogr.wkbLineString, ogr.wkbMultiLineString):
+                for edge in edges_from_line(g, attributes, simplify, geom_attrs):
+                    e1, e2, attr = edge
+                    net.add_edge(e1, e2)
+                    net[e1][e2].update(attr)
+            else:
+                if strict:
+                    raise nx.NetworkXError(
+                        f"GeometryType {g.GetGeometryType()} not supported"
+                    )
+
+    return net
+
+
+def edges_from_line(geom, attrs, simplify=True, geom_attrs=True):
+    """
+    Generate edges for each line in geom
+    Written as a helper for read_shp
+
+    Parameters
+    ----------
+
+    geom:  ogr line geometry
+        To be converted into an edge or edges
+
+    attrs:  dict
+        Attributes to be associated with all geoms
+
+    simplify:  bool
+        If True, simplify the line as in read_shp
+
+    geom_attrs:  bool
+        If True, add geom attributes to edge as in read_shp
+
+
+    Returns
+    -------
+     edges:  generator of edges
+        each edge is a tuple of form
+        (node1_coord, node2_coord, attribute_dict)
+        suitable for expanding into a networkx Graph add_edge call
+
+    .. deprecated:: 2.6
+    """
+    msg = (
+        "edges_from_line is deprecated and will be removed in 3.0."
+        "See https://networkx.org/documentation/latest/auto_examples/index.html#geospatial."
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    try:
+        from osgeo import ogr
+    except ImportError as err:
+        raise ImportError(
+            "edges_from_line requires OGR: " "http://www.gdal.org/"
+        ) from err
+
+    if geom.GetGeometryType() == ogr.wkbLineString:
+        if simplify:
+            edge_attrs = attrs.copy()
+            last = geom.GetPointCount() - 1
+            if geom_attrs:
+                edge_attrs["Wkb"] = geom.ExportToWkb()
+                edge_attrs["Wkt"] = geom.ExportToWkt()
+                edge_attrs["Json"] = geom.ExportToJson()
+            yield (geom.GetPoint_2D(0), geom.GetPoint_2D(last), edge_attrs)
+        else:
+            for i in range(0, geom.GetPointCount() - 1):
+                pt1 = geom.GetPoint_2D(i)
+                pt2 = geom.GetPoint_2D(i + 1)
+                edge_attrs = attrs.copy()
+                if geom_attrs:
+                    segment = ogr.Geometry(ogr.wkbLineString)
+                    segment.AddPoint_2D(pt1[0], pt1[1])
+                    segment.AddPoint_2D(pt2[0], pt2[1])
+                    edge_attrs["Wkb"] = segment.ExportToWkb()
+                    edge_attrs["Wkt"] = segment.ExportToWkt()
+                    edge_attrs["Json"] = segment.ExportToJson()
+                    del segment
+                yield (pt1, pt2, edge_attrs)
+
+    elif geom.GetGeometryType() == ogr.wkbMultiLineString:
+        for i in range(geom.GetGeometryCount()):
+            geom_i = geom.GetGeometryRef(i)
+            yield from edges_from_line(geom_i, attrs, simplify, geom_attrs)
+
+
+def write_shp(G, outdir):
+    """Writes a networkx.DiGraph to two shapefiles, edges and nodes.
+
+    .. deprecated:: 2.6
+
+       write_shp is deprecated and will be removed in 3.0.
+       See https://networkx.org/documentation/latest/auto_examples/index.html#geospatial.
+
+    Nodes and edges are expected to have a Well Known Binary (Wkb) or
+    Well Known Text (Wkt) key in order to generate geometries. Also
+    acceptable are nodes with a numeric tuple key (x,y).
+
+    "The Esri Shapefile or simply a shapefile is a popular geospatial vector
+    data format for geographic information systems software [1]_."
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Directed graph
+    outdir : directory path
+       Output directory for the two shapefiles.
+
+    Returns
+    -------
+    None
+
+    Examples
+    --------
+    nx.write_shp(digraph, '/shapefiles') # doctest +SKIP
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Shapefile
+    """
+    msg = (
+        "write_shp is deprecated and will be removed in 3.0."
+        "See https://networkx.org/documentation/latest/auto_examples/index.html#geospatial."
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    try:
+        from osgeo import ogr
+    except ImportError as err:
+        raise ImportError("write_shp requires OGR: http://www.gdal.org/") from err
+    # easier to debug in python if ogr throws exceptions
+    ogr.UseExceptions()
+
+    def netgeometry(key, data):
+        if "Wkb" in data:
+            geom = ogr.CreateGeometryFromWkb(data["Wkb"])
+        elif "Wkt" in data:
+            geom = ogr.CreateGeometryFromWkt(data["Wkt"])
+        elif type(key[0]).__name__ == "tuple":  # edge keys are packed tuples
+            geom = ogr.Geometry(ogr.wkbLineString)
+            _from, _to = key[0], key[1]
+            try:
+                geom.SetPoint(0, *_from)
+                geom.SetPoint(1, *_to)
+            except TypeError:
+                # assume user used tuple of int and choked ogr
+                _ffrom = [float(x) for x in _from]
+                _fto = [float(x) for x in _to]
+                geom.SetPoint(0, *_ffrom)
+                geom.SetPoint(1, *_fto)
+        else:
+            geom = ogr.Geometry(ogr.wkbPoint)
+            try:
+                geom.SetPoint(0, *key)
+            except TypeError:
+                # assume user used tuple of int and choked ogr
+                fkey = [float(x) for x in key]
+                geom.SetPoint(0, *fkey)
+
+        return geom
+
+    # Create_feature with new optional attributes arg (should be dict type)
+    def create_feature(geometry, lyr, attributes=None):
+        feature = ogr.Feature(lyr.GetLayerDefn())
+        feature.SetGeometry(g)
+        if attributes is not None:
+            # Loop through attributes, assigning data to each field
+            for field, data in attributes.items():
+                feature.SetField(field, data)
+        lyr.CreateFeature(feature)
+        feature.Destroy()
+
+    # Conversion dict between python and ogr types
+    OGRTypes = {int: ogr.OFTInteger, str: ogr.OFTString, float: ogr.OFTReal}
+
+    # Check/add fields from attribute data to Shapefile layers
+    def add_fields_to_layer(key, value, fields, layer):
+        # Field not in previous edges so add to dict
+        if type(value) in OGRTypes:
+            fields[key] = OGRTypes[type(value)]
+        else:
+            # Data type not supported, default to string (char 80)
+            fields[key] = ogr.OFTString
+        # Create the new field
+        newfield = ogr.FieldDefn(key, fields[key])
+        layer.CreateField(newfield)
+
+    drv = ogr.GetDriverByName("ESRI Shapefile")
+    shpdir = drv.CreateDataSource(outdir)
+    # delete pre-existing output first otherwise ogr chokes
+    try:
+        shpdir.DeleteLayer("nodes")
+    except:
+        pass
+    nodes = shpdir.CreateLayer("nodes", None, ogr.wkbPoint)
+
+    # Storage for node field names and their data types
+    node_fields = {}
+
+    def create_attributes(data, fields, layer):
+        attributes = {}  # storage for attribute data (indexed by field names)
+        for key, value in data.items():
+            # Reject spatial data not required for attribute table
+            if key != "Json" and key != "Wkt" and key != "Wkb" and key != "ShpName":
+                # Check/add field and data type to fields dict
+                if key not in fields:
+                    add_fields_to_layer(key, value, fields, layer)
+                # Store the data from new field to dict for CreateLayer()
+                attributes[key] = value
+        return attributes, layer
+
+    for n in G:
+        data = G.nodes[n]
+        g = netgeometry(n, data)
+        attributes, nodes = create_attributes(data, node_fields, nodes)
+        create_feature(g, nodes, attributes)
+
+    try:
+        shpdir.DeleteLayer("edges")
+    except:
+        pass
+    edges = shpdir.CreateLayer("edges", None, ogr.wkbLineString)
+
+    # New edge attribute write support merged into edge loop
+    edge_fields = {}  # storage for field names and their data types
+
+    for edge in G.edges(data=True):
+        data = G.get_edge_data(*edge)
+        g = netgeometry(edge, data)
+        attributes, edges = create_attributes(edge[2], edge_fields, edges)
+        create_feature(g, edges, attributes)
+
+    nodes, edges = None, None
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/nx_yaml.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/nx_yaml.py
new file mode 100644
index 0000000..b8ed9e5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/nx_yaml.py
@@ -0,0 +1,59 @@
+"""
+****
+YAML
+****
+Read and write NetworkX graphs in YAML format.
+
+"YAML is a data serialization format designed for human readability
+and interaction with scripting languages."
+See http://www.yaml.org for documentation.
+
+Format
+------
+http://pyyaml.org/wiki/PyYAML
+
+"""
+
+
+def __dir__():
+    return ["read_yaml", "write_yaml"]
+
+
+def __getattr__(name):
+    """Remove functions and provide informative error messages."""
+    if name == "nx_yaml":
+        raise ImportError(
+            "\nThe nx_yaml module has been removed from NetworkX.\n"
+            "Please use the `yaml` package directly for working with yaml data.\n"
+            "For example, a networkx.Graph `G` can be written to and loaded\n"
+            "from a yaml file with:\n\n"
+            "    import yaml\n\n"
+            "    with open('path_to_yaml_file', 'w') as fh:\n"
+            "        yaml.dump(G, fh)\n"
+            "    with open('path_to_yaml_file', 'r') as fh:\n"
+            "        G = yaml.load(fh, Loader=yaml.Loader)\n\n"
+            "Note that yaml.Loader is considered insecure - see the pyyaml\n"
+            "documentation for further details.\n\n"
+            "This message will be removed in NetworkX 3.0."
+        )
+    if name == "read_yaml":
+        raise ImportError(
+            "\nread_yaml has been removed from NetworkX, please use `yaml`\n"
+            "directly:\n\n"
+            "    import yaml\n\n"
+            "    with open('path', 'r') as fh:\n"
+            "        yaml.load(fh, Loader=yaml.Loader)\n\n"
+            "Note that yaml.Loader is considered insecure - see the pyyaml\n"
+            "documentation for further details.\n\n"
+            "This message will be removed in NetworkX 3.0."
+        )
+    if name == "write_yaml":
+        raise ImportError(
+            "\nwrite_yaml has been removed from NetworkX, please use `yaml`\n"
+            "directly:\n\n"
+            "    import yaml\n\n"
+            "    with open('path_for_yaml_output', 'w') as fh:\n"
+            "        yaml.dump(G_to_be_yaml, fh)\n\n"
+            "This message will be removed in NetworkX 3.0."
+        )
+    raise AttributeError(f"module {__name__} has no attribute {name}")
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/p2g.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/p2g.py
new file mode 100644
index 0000000..6e23812
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/p2g.py
@@ -0,0 +1,102 @@
+"""
+This module provides the following: read and write of p2g format
+used in metabolic pathway studies.
+
+See https://web.archive.org/web/20080626113807/http://www.cs.purdue.edu/homes/koyuturk/pathway/ for a description.
+
+The summary is included here:
+
+A file that describes a uniquely labeled graph (with extension ".gr")
+format looks like the following:
+
+
+name
+3 4
+a
+1 2
+b
+
+c
+0 2
+
+"name" is simply a description of what the graph corresponds to. The
+second line displays the number of nodes and number of edges,
+respectively. This sample graph contains three nodes labeled "a", "b",
+and "c". The rest of the graph contains two lines for each node. The
+first line for a node contains the node label. After the declaration
+of the node label, the out-edges of that node in the graph are
+provided. For instance, "a" is linked to nodes 1 and 2, which are
+labeled "b" and "c", while the node labeled "b" has no outgoing
+edges. Observe that node labeled "c" has an outgoing edge to
+itself. Indeed, self-loops are allowed. Node index starts from 0.
+
+"""
+import networkx
+from networkx.utils import open_file
+
+
+@open_file(1, mode="w")
+def write_p2g(G, path, encoding="utf-8"):
+    """Write NetworkX graph in p2g format.
+
+    Notes
+    -----
+    This format is meant to be used with directed graphs with
+    possible self loops.
+    """
+    path.write((f"{G.name}\n").encode(encoding))
+    path.write((f"{G.order()} {G.size()}\n").encode(encoding))
+    nodes = list(G)
+    # make dictionary mapping nodes to integers
+    nodenumber = dict(zip(nodes, range(len(nodes))))
+    for n in nodes:
+        path.write((f"{n}\n").encode(encoding))
+        for nbr in G.neighbors(n):
+            path.write((f"{nodenumber[nbr]} ").encode(encoding))
+        path.write("\n".encode(encoding))
+
+
+@open_file(0, mode="r")
+def read_p2g(path, encoding="utf-8"):
+    """Read graph in p2g format from path.
+
+    Returns
+    -------
+    MultiDiGraph
+
+    Notes
+    -----
+    If you want a DiGraph (with no self loops allowed and no edge data)
+    use D=networkx.DiGraph(read_p2g(path))
+    """
+    lines = (line.decode(encoding) for line in path)
+    G = parse_p2g(lines)
+    return G
+
+
+def parse_p2g(lines):
+    """Parse p2g format graph from string or iterable.
+
+    Returns
+    -------
+    MultiDiGraph
+    """
+    description = next(lines).strip()
+    # are multiedges (parallel edges) allowed?
+    G = networkx.MultiDiGraph(name=description, selfloops=True)
+    nnodes, nedges = map(int, next(lines).split())
+    nodelabel = {}
+    nbrs = {}
+    # loop over the nodes keeping track of node labels and out neighbors
+    # defer adding edges until all node labels are known
+    for i in range(nnodes):
+        n = next(lines).strip()
+        nodelabel[i] = n
+        G.add_node(n)
+        nbrs[n] = map(int, next(lines).split())
+    # now we know all of the node labels so we can add the edges
+    # with the correct labels
+    for n in G:
+        for nbr in nbrs[n]:
+            G.add_edge(n, nodelabel[nbr])
+    return G
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/pajek.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/pajek.py
new file mode 100644
index 0000000..6b4f519
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/pajek.py
@@ -0,0 +1,284 @@
+"""
+*****
+Pajek
+*****
+Read graphs in Pajek format.
+
+This implementation handles directed and undirected graphs including
+those with self loops and parallel edges.
+
+Format
+------
+See http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/draweps.htm
+for format information.
+
+"""
+
+import warnings
+
+import networkx as nx
+from networkx.utils import open_file
+
+__all__ = ["read_pajek", "parse_pajek", "generate_pajek", "write_pajek"]
+
+
+def generate_pajek(G):
+    """Generate lines in Pajek graph format.
+
+    Parameters
+    ----------
+    G : graph
+       A Networkx graph
+
+    References
+    ----------
+    See http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/draweps.htm
+    for format information.
+    """
+    if G.name == "":
+        name = "NetworkX"
+    else:
+        name = G.name
+    # Apparently many Pajek format readers can't process this line
+    # So we'll leave it out for now.
+    # yield '*network %s'%name
+
+    # write nodes with attributes
+    yield f"*vertices {G.order()}"
+    nodes = list(G)
+    # make dictionary mapping nodes to integers
+    nodenumber = dict(zip(nodes, range(1, len(nodes) + 1)))
+    for n in nodes:
+        # copy node attributes and pop mandatory attributes
+        # to avoid duplication.
+        na = G.nodes.get(n, {}).copy()
+        x = na.pop("x", 0.0)
+        y = na.pop("y", 0.0)
+        try:
+            id = int(na.pop("id", nodenumber[n]))
+        except ValueError as err:
+            err.args += (
+                (
+                    "Pajek format requires 'id' to be an int()."
+                    " Refer to the 'Relabeling nodes' section."
+                ),
+            )
+            raise
+        nodenumber[n] = id
+        shape = na.pop("shape", "ellipse")
+        s = " ".join(map(make_qstr, (id, n, x, y, shape)))
+        # only optional attributes are left in na.
+        for k, v in na.items():
+            if isinstance(v, str) and v.strip() != "":
+                s += f" {make_qstr(k)} {make_qstr(v)}"
+            else:
+                warnings.warn(
+                    f"Node attribute {k} is not processed. {('Empty attribute' if isinstance(v, str) else 'Non-string attribute')}."
+                )
+        yield s
+
+    # write edges with attributes
+    if G.is_directed():
+        yield "*arcs"
+    else:
+        yield "*edges"
+    for u, v, edgedata in G.edges(data=True):
+        d = edgedata.copy()
+        value = d.pop("weight", 1.0)  # use 1 as default edge value
+        s = " ".join(map(make_qstr, (nodenumber[u], nodenumber[v], value)))
+        for k, v in d.items():
+            if isinstance(v, str) and v.strip() != "":
+                s += f" {make_qstr(k)} {make_qstr(v)}"
+            else:
+                warnings.warn(
+                    f"Edge attribute {k} is not processed. {('Empty attribute' if isinstance(v, str) else 'Non-string attribute')}."
+                )
+        yield s
+
+
+@open_file(1, mode="wb")
+def write_pajek(G, path, encoding="UTF-8"):
+    """Write graph in Pajek format to path.
+
+    Parameters
+    ----------
+    G : graph
+       A Networkx graph
+    path : file or string
+       File or filename to write.
+       Filenames ending in .gz or .bz2 will be compressed.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_pajek(G, "test.net")
+
+    Warnings
+    --------
+    Optional node attributes and edge attributes must be non-empty strings.
+    Otherwise it will not be written into the file. You will need to
+    convert those attributes to strings if you want to keep them.
+
+    References
+    ----------
+    See http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/draweps.htm
+    for format information.
+    """
+    for line in generate_pajek(G):
+        line += "\n"
+        path.write(line.encode(encoding))
+
+
+@open_file(0, mode="rb")
+def read_pajek(path, encoding="UTF-8"):
+    """Read graph in Pajek format from path.
+
+    Parameters
+    ----------
+    path : file or string
+       File or filename to write.
+       Filenames ending in .gz or .bz2 will be uncompressed.
+
+    Returns
+    -------
+    G : NetworkX MultiGraph or MultiDiGraph.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> nx.write_pajek(G, "test.net")
+    >>> G = nx.read_pajek("test.net")
+
+    To create a Graph instead of a MultiGraph use
+
+    >>> G1 = nx.Graph(G)
+
+    References
+    ----------
+    See http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/draweps.htm
+    for format information.
+    """
+    lines = (line.decode(encoding) for line in path)
+    return parse_pajek(lines)
+
+
+def parse_pajek(lines):
+    """Parse Pajek format graph from string or iterable.
+
+    Parameters
+    ----------
+    lines : string or iterable
+       Data in Pajek format.
+
+    Returns
+    -------
+    G : NetworkX graph
+
+    See Also
+    --------
+    read_pajek
+
+    """
+    import shlex
+
+    # multigraph=False
+    if isinstance(lines, str):
+        lines = iter(lines.split("\n"))
+    lines = iter([line.rstrip("\n") for line in lines])
+    G = nx.MultiDiGraph()  # are multiedges allowed in Pajek? assume yes
+    labels = []  # in the order of the file, needed for matrix
+    while lines:
+        try:
+            l = next(lines)
+        except:  # EOF
+            break
+        if l.lower().startswith("*network"):
+            try:
+                label, name = l.split(None, 1)
+            except ValueError:
+                # Line was not of the form:  *network NAME
+                pass
+            else:
+                G.graph["name"] = name
+        elif l.lower().startswith("*vertices"):
+            nodelabels = {}
+            l, nnodes = l.split()
+            for i in range(int(nnodes)):
+                l = next(lines)
+                try:
+                    splitline = [
+                        x.decode("utf-8") for x in shlex.split(str(l).encode("utf-8"))
+                    ]
+                except AttributeError:
+                    splitline = shlex.split(str(l))
+                id, label = splitline[0:2]
+                labels.append(label)
+                G.add_node(label)
+                nodelabels[id] = label
+                G.nodes[label]["id"] = id
+                try:
+                    x, y, shape = splitline[2:5]
+                    G.nodes[label].update(
+                        {"x": float(x), "y": float(y), "shape": shape}
+                    )
+                except:
+                    pass
+                extra_attr = zip(splitline[5::2], splitline[6::2])
+                G.nodes[label].update(extra_attr)
+        elif l.lower().startswith("*edges") or l.lower().startswith("*arcs"):
+            if l.lower().startswith("*edge"):
+                # switch from multidigraph to multigraph
+                G = nx.MultiGraph(G)
+            if l.lower().startswith("*arcs"):
+                # switch to directed with multiple arcs for each existing edge
+                G = G.to_directed()
+            for l in lines:
+                try:
+                    splitline = [
+                        x.decode("utf-8") for x in shlex.split(str(l).encode("utf-8"))
+                    ]
+                except AttributeError:
+                    splitline = shlex.split(str(l))
+
+                if len(splitline) < 2:
+                    continue
+                ui, vi = splitline[0:2]
+                u = nodelabels.get(ui, ui)
+                v = nodelabels.get(vi, vi)
+                # parse the data attached to this edge and put in a dictionary
+                edge_data = {}
+                try:
+                    # there should always be a single value on the edge?
+                    w = splitline[2:3]
+                    edge_data.update({"weight": float(w[0])})
+                except:
+                    pass
+                    # if there isn't, just assign a 1
+                #                    edge_data.update({'value':1})
+                extra_attr = zip(splitline[3::2], splitline[4::2])
+                edge_data.update(extra_attr)
+                # if G.has_edge(u,v):
+                #     multigraph=True
+                G.add_edge(u, v, **edge_data)
+        elif l.lower().startswith("*matrix"):
+            G = nx.DiGraph(G)
+            adj_list = (
+                (labels[row], labels[col], {"weight": int(data)})
+                for (row, line) in enumerate(lines)
+                for (col, data) in enumerate(line.split())
+                if int(data) != 0
+            )
+            G.add_edges_from(adj_list)
+
+    return G
+
+
+def make_qstr(t):
+    """Returns the string representation of t.
+    Add outer double-quotes if the string has a space.
+    """
+    if not isinstance(t, str):
+        t = str(t)
+    if " " in t:
+        t = f'"{t}"'
+    return t
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/sparse6.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/sparse6.py
new file mode 100644
index 0000000..e7c3638
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/sparse6.py
@@ -0,0 +1,374 @@
+# Original author: D. Eppstein, UC Irvine, August 12, 2003.
+# The original code at https://www.ics.uci.edu/~eppstein/PADS/ is public domain.
+"""Functions for reading and writing graphs in the *sparse6* format.
+
+The *sparse6* file format is a space-efficient format for large sparse
+graphs. For small graphs or large dense graphs, use the *graph6* file
+format.
+
+For more information, see the `sparse6`_ homepage.
+
+.. _sparse6: https://users.cecs.anu.edu.au/~bdm/data/formats.html
+
+"""
+import networkx as nx
+from networkx.exception import NetworkXError
+from networkx.readwrite.graph6 import data_to_n, n_to_data
+from networkx.utils import not_implemented_for, open_file
+
+__all__ = ["from_sparse6_bytes", "read_sparse6", "to_sparse6_bytes", "write_sparse6"]
+
+
+def _generate_sparse6_bytes(G, nodes, header):
+    """Yield bytes in the sparse6 encoding of a graph.
+
+    `G` is an undirected simple graph. `nodes` is the list of nodes for
+    which the node-induced subgraph will be encoded; if `nodes` is the
+    list of all nodes in the graph, the entire graph will be
+    encoded. `header` is a Boolean that specifies whether to generate
+    the header ``b'>>sparse6<<'`` before the remaining data.
+
+    This function generates `bytes` objects in the following order:
+
+    1. the header (if requested),
+    2. the encoding of the number of nodes,
+    3. each character, one-at-a-time, in the encoding of the requested
+       node-induced subgraph,
+    4. a newline character.
+
+    This function raises :exc:`ValueError` if the graph is too large for
+    the graph6 format (that is, greater than ``2 ** 36`` nodes).
+
+    """
+    n = len(G)
+    if n >= 2**36:
+        raise ValueError(
+            "sparse6 is only defined if number of nodes is less " "than 2 ** 36"
+        )
+    if header:
+        yield b">>sparse6<<"
+    yield b":"
+    for d in n_to_data(n):
+        yield str.encode(chr(d + 63))
+
+    k = 1
+    while 1 << k < n:
+        k += 1
+
+    def enc(x):
+        """Big endian k-bit encoding of x"""
+        return [1 if (x & 1 << (k - 1 - i)) else 0 for i in range(k)]
+
+    edges = sorted((max(u, v), min(u, v)) for u, v in G.edges())
+    bits = []
+    curv = 0
+    for (v, u) in edges:
+        if v == curv:  # current vertex edge
+            bits.append(0)
+            bits.extend(enc(u))
+        elif v == curv + 1:  # next vertex edge
+            curv += 1
+            bits.append(1)
+            bits.extend(enc(u))
+        else:  # skip to vertex v and then add edge to u
+            curv = v
+            bits.append(1)
+            bits.extend(enc(v))
+            bits.append(0)
+            bits.extend(enc(u))
+    if k < 6 and n == (1 << k) and ((-len(bits)) % 6) >= k and curv < (n - 1):
+        # Padding special case: small k, n=2^k,
+        # more than k bits of padding needed,
+        # current vertex is not (n-1) --
+        # appending 1111... would add a loop on (n-1)
+        bits.append(0)
+        bits.extend([1] * ((-len(bits)) % 6))
+    else:
+        bits.extend([1] * ((-len(bits)) % 6))
+
+    data = [
+        (bits[i + 0] << 5)
+        + (bits[i + 1] << 4)
+        + (bits[i + 2] << 3)
+        + (bits[i + 3] << 2)
+        + (bits[i + 4] << 1)
+        + (bits[i + 5] << 0)
+        for i in range(0, len(bits), 6)
+    ]
+
+    for d in data:
+        yield str.encode(chr(d + 63))
+    yield b"\n"
+
+
+def from_sparse6_bytes(string):
+    """Read an undirected graph in sparse6 format from string.
+
+    Parameters
+    ----------
+    string : string
+       Data in sparse6 format
+
+    Returns
+    -------
+    G : Graph
+
+    Raises
+    ------
+    NetworkXError
+        If the string is unable to be parsed in sparse6 format
+
+    Examples
+    --------
+    >>> G = nx.from_sparse6_bytes(b":A_")
+    >>> sorted(G.edges())
+    [(0, 1), (0, 1), (0, 1)]
+
+    See Also
+    --------
+    read_sparse6, write_sparse6
+
+    References
+    ----------
+    .. [1] Sparse6 specification
+           <https://users.cecs.anu.edu.au/~bdm/data/formats.html>
+
+    """
+    if string.startswith(b">>sparse6<<"):
+        string = string[11:]
+    if not string.startswith(b":"):
+        raise NetworkXError("Expected leading colon in sparse6")
+
+    chars = [c - 63 for c in string[1:]]
+    n, data = data_to_n(chars)
+    k = 1
+    while 1 << k < n:
+        k += 1
+
+    def parseData():
+        """Returns stream of pairs b[i], x[i] for sparse6 format."""
+        chunks = iter(data)
+        d = None  # partial data word
+        dLen = 0  # how many unparsed bits are left in d
+
+        while 1:
+            if dLen < 1:
+                try:
+                    d = next(chunks)
+                except StopIteration:
+                    return
+                dLen = 6
+            dLen -= 1
+            b = (d >> dLen) & 1  # grab top remaining bit
+
+            x = d & ((1 << dLen) - 1)  # partially built up value of x
+            xLen = dLen  # how many bits included so far in x
+            while xLen < k:  # now grab full chunks until we have enough
+                try:
+                    d = next(chunks)
+                except StopIteration:
+                    return
+                dLen = 6
+                x = (x << 6) + d
+                xLen += 6
+            x = x >> (xLen - k)  # shift back the extra bits
+            dLen = xLen - k
+            yield b, x
+
+    v = 0
+
+    G = nx.MultiGraph()
+    G.add_nodes_from(range(n))
+
+    multigraph = False
+    for b, x in parseData():
+        if b == 1:
+            v += 1
+        # padding with ones can cause overlarge number here
+        if x >= n or v >= n:
+            break
+        elif x > v:
+            v = x
+        else:
+            if G.has_edge(x, v):
+                multigraph = True
+            G.add_edge(x, v)
+    if not multigraph:
+        G = nx.Graph(G)
+    return G
+
+
+def to_sparse6_bytes(G, nodes=None, header=True):
+    """Convert an undirected graph to bytes in sparse6 format.
+
+    Parameters
+    ----------
+    G : Graph (undirected)
+
+    nodes: list or iterable
+       Nodes are labeled 0...n-1 in the order provided.  If None the ordering
+       given by ``G.nodes()`` is used.
+
+    header: bool
+       If True add '>>sparse6<<' bytes to head of data.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed.
+
+    ValueError
+        If the graph has at least ``2 ** 36`` nodes; the sparse6 format
+        is only defined for graphs of order less than ``2 ** 36``.
+
+    Examples
+    --------
+    >>> nx.to_sparse6_bytes(nx.path_graph(2))
+    b'>>sparse6<<:An\\n'
+
+    See Also
+    --------
+    to_sparse6_bytes, read_sparse6, write_sparse6_bytes
+
+    Notes
+    -----
+    The returned bytes end with a newline character.
+
+    The format does not support edge or node labels.
+
+    References
+    ----------
+    .. [1] Graph6 specification
+           <https://users.cecs.anu.edu.au/~bdm/data/formats.html>
+
+    """
+    if nodes is not None:
+        G = G.subgraph(nodes)
+    G = nx.convert_node_labels_to_integers(G, ordering="sorted")
+    return b"".join(_generate_sparse6_bytes(G, nodes, header))
+
+
+@open_file(0, mode="rb")
+def read_sparse6(path):
+    """Read an undirected graph in sparse6 format from path.
+
+    Parameters
+    ----------
+    path : file or string
+       File or filename to write.
+
+    Returns
+    -------
+    G : Graph/Multigraph or list of Graphs/MultiGraphs
+       If the file contains multiple lines then a list of graphs is returned
+
+    Raises
+    ------
+    NetworkXError
+        If the string is unable to be parsed in sparse6 format
+
+    Examples
+    --------
+    You can read a sparse6 file by giving the path to the file::
+
+        >>> import tempfile
+        >>> with tempfile.NamedTemporaryFile() as f:
+        ...     _ = f.write(b">>sparse6<<:An\\n")
+        ...     _ = f.seek(0)
+        ...     G = nx.read_sparse6(f.name)
+        >>> list(G.edges())
+        [(0, 1)]
+
+    You can also read a sparse6 file by giving an open file-like object::
+
+        >>> import tempfile
+        >>> with tempfile.NamedTemporaryFile() as f:
+        ...     _ = f.write(b">>sparse6<<:An\\n")
+        ...     _ = f.seek(0)
+        ...     G = nx.read_sparse6(f)
+        >>> list(G.edges())
+        [(0, 1)]
+
+    See Also
+    --------
+    read_sparse6, from_sparse6_bytes
+
+    References
+    ----------
+    .. [1] Sparse6 specification
+           <https://users.cecs.anu.edu.au/~bdm/data/formats.html>
+
+    """
+    glist = []
+    for line in path:
+        line = line.strip()
+        if not len(line):
+            continue
+        glist.append(from_sparse6_bytes(line))
+    if len(glist) == 1:
+        return glist[0]
+    else:
+        return glist
+
+
+@not_implemented_for("directed")
+@open_file(1, mode="wb")
+def write_sparse6(G, path, nodes=None, header=True):
+    """Write graph G to given path in sparse6 format.
+
+    Parameters
+    ----------
+    G : Graph (undirected)
+
+    path : file or string
+       File or filename to write
+
+    nodes: list or iterable
+       Nodes are labeled 0...n-1 in the order provided.  If None the ordering
+       given by G.nodes() is used.
+
+    header: bool
+       If True add '>>sparse6<<' string to head of data
+
+    Raises
+    ------
+    NetworkXError
+        If the graph is directed
+
+    Examples
+    --------
+    You can write a sparse6 file by giving the path to the file::
+
+        >>> import tempfile
+        >>> with tempfile.NamedTemporaryFile() as f:
+        ...     nx.write_sparse6(nx.path_graph(2), f.name)
+        ...     print(f.read())
+        b'>>sparse6<<:An\\n'
+
+    You can also write a sparse6 file by giving an open file-like object::
+
+        >>> with tempfile.NamedTemporaryFile() as f:
+        ...     nx.write_sparse6(nx.path_graph(2), f)
+        ...     _ = f.seek(0)
+        ...     print(f.read())
+        b'>>sparse6<<:An\\n'
+
+    See Also
+    --------
+    read_sparse6, from_sparse6_bytes
+
+    Notes
+    -----
+    The format does not support edge or node labels.
+
+    References
+    ----------
+    .. [1] Sparse6 specification
+           <https://users.cecs.anu.edu.au/~bdm/data/formats.html>
+
+    """
+    if nodes is not None:
+        G = G.subgraph(nodes)
+    G = nx.convert_node_labels_to_integers(G, ordering="sorted")
+    for b in _generate_sparse6_bytes(G, nodes, header):
+        path.write(b)
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_adjlist.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_adjlist.py
new file mode 100644
index 0000000..aecfb87
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_adjlist.py
@@ -0,0 +1,268 @@
+"""
+    Unit tests for adjlist.
+"""
+import io
+import os
+import tempfile
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, graphs_equal, nodes_equal
+
+
+class TestAdjlist:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.Graph(name="test")
+        e = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("a", "f")]
+        cls.G.add_edges_from(e)
+        cls.G.add_node("g")
+        cls.DG = nx.DiGraph(cls.G)
+        cls.XG = nx.MultiGraph()
+        cls.XG.add_weighted_edges_from([(1, 2, 5), (1, 2, 5), (1, 2, 1), (3, 3, 42)])
+        cls.XDG = nx.MultiDiGraph(cls.XG)
+
+    def test_read_multiline_adjlist_1(self):
+        # Unit test for https://networkx.lanl.gov/trac/ticket/252
+        s = b"""# comment line
+1 2
+# comment line
+2
+3
+"""
+        bytesIO = io.BytesIO(s)
+        G = nx.read_multiline_adjlist(bytesIO)
+        adj = {"1": {"3": {}, "2": {}}, "3": {"1": {}}, "2": {"1": {}}}
+        assert graphs_equal(G, nx.Graph(adj))
+
+    def test_unicode(self):
+        G = nx.Graph()
+        name1 = chr(2344) + chr(123) + chr(6543)
+        name2 = chr(5543) + chr(1543) + chr(324)
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        fd, fname = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(fname)
+        assert graphs_equal(G, H)
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_latin1_err(self):
+        G = nx.Graph()
+        name1 = chr(2344) + chr(123) + chr(6543)
+        name2 = chr(5543) + chr(1543) + chr(324)
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        fd, fname = tempfile.mkstemp()
+        pytest.raises(
+            UnicodeEncodeError, nx.write_multiline_adjlist, G, fname, encoding="latin-1"
+        )
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_latin1(self):
+        G = nx.Graph()
+        name1 = "Bj" + chr(246) + "rk"
+        name2 = chr(220) + "ber"
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        fd, fname = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname, encoding="latin-1")
+        H = nx.read_multiline_adjlist(fname, encoding="latin-1")
+        assert graphs_equal(G, H)
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_parse_adjlist(self):
+        lines = ["1 2 5", "2 3 4", "3 5", "4", "5"]
+        nx.parse_adjlist(lines, nodetype=int)  # smoke test
+        with pytest.raises(TypeError):
+            nx.parse_adjlist(lines, nodetype="int")
+        lines = ["1 2 5", "2 b", "c"]
+        with pytest.raises(TypeError):
+            nx.parse_adjlist(lines, nodetype=int)
+
+    def test_adjlist_graph(self):
+        G = self.G
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_adjlist(G, fname)
+        H = nx.read_adjlist(fname)
+        H2 = nx.read_adjlist(fname)
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_adjlist_digraph(self):
+        G = self.DG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_adjlist(G, fname)
+        H = nx.read_adjlist(fname, create_using=nx.DiGraph())
+        H2 = nx.read_adjlist(fname, create_using=nx.DiGraph())
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_adjlist_integers(self):
+        (fd, fname) = tempfile.mkstemp()
+        G = nx.convert_node_labels_to_integers(self.G)
+        nx.write_adjlist(G, fname)
+        H = nx.read_adjlist(fname, nodetype=int)
+        H2 = nx.read_adjlist(fname, nodetype=int)
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_adjlist_multigraph(self):
+        G = self.XG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_adjlist(G, fname)
+        H = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiGraph())
+        H2 = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiGraph())
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_adjlist_multidigraph(self):
+        G = self.XDG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_adjlist(G, fname)
+        H = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiDiGraph())
+        H2 = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiDiGraph())
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_adjlist_delimiter(self):
+        fh = io.BytesIO()
+        G = nx.path_graph(3)
+        nx.write_adjlist(G, fh, delimiter=":")
+        fh.seek(0)
+        H = nx.read_adjlist(fh, nodetype=int, delimiter=":")
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+
+
+class TestMultilineAdjlist:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.Graph(name="test")
+        e = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("a", "f")]
+        cls.G.add_edges_from(e)
+        cls.G.add_node("g")
+        cls.DG = nx.DiGraph(cls.G)
+        cls.DG.remove_edge("b", "a")
+        cls.DG.remove_edge("b", "c")
+        cls.XG = nx.MultiGraph()
+        cls.XG.add_weighted_edges_from([(1, 2, 5), (1, 2, 5), (1, 2, 1), (3, 3, 42)])
+        cls.XDG = nx.MultiDiGraph(cls.XG)
+
+    def test_parse_multiline_adjlist(self):
+        lines = [
+            "1 2",
+            "b {'weight':3, 'name': 'Frodo'}",
+            "c {}",
+            "d 1",
+            "e {'weight':6, 'name': 'Saruman'}",
+        ]
+        nx.parse_multiline_adjlist(iter(lines))  # smoke test
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines), nodetype=int)
+        nx.parse_multiline_adjlist(iter(lines), edgetype=str)  # smoke test
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines), nodetype=int)
+        lines = ["1 a"]
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines))
+        lines = ["a 2"]
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines), nodetype=int)
+        lines = ["1 2"]
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines))
+        lines = ["1 2", "2 {}"]
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines))
+
+    def test_multiline_adjlist_graph(self):
+        G = self.G
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(fname)
+        H2 = nx.read_multiline_adjlist(fname)
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multiline_adjlist_digraph(self):
+        G = self.DG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(fname, create_using=nx.DiGraph())
+        H2 = nx.read_multiline_adjlist(fname, create_using=nx.DiGraph())
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multiline_adjlist_integers(self):
+        (fd, fname) = tempfile.mkstemp()
+        G = nx.convert_node_labels_to_integers(self.G)
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(fname, nodetype=int)
+        H2 = nx.read_multiline_adjlist(fname, nodetype=int)
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multiline_adjlist_multigraph(self):
+        G = self.XG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(fname, nodetype=int, create_using=nx.MultiGraph())
+        H2 = nx.read_multiline_adjlist(
+            fname, nodetype=int, create_using=nx.MultiGraph()
+        )
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multiline_adjlist_multidigraph(self):
+        G = self.XDG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(
+            fname, nodetype=int, create_using=nx.MultiDiGraph()
+        )
+        H2 = nx.read_multiline_adjlist(
+            fname, nodetype=int, create_using=nx.MultiDiGraph()
+        )
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multiline_adjlist_delimiter(self):
+        fh = io.BytesIO()
+        G = nx.path_graph(3)
+        nx.write_multiline_adjlist(G, fh, delimiter=":")
+        fh.seek(0)
+        H = nx.read_multiline_adjlist(fh, nodetype=int, delimiter=":")
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_edgelist.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_edgelist.py
new file mode 100644
index 0000000..abd1d3c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_edgelist.py
@@ -0,0 +1,314 @@
+"""
+    Unit tests for edgelists.
+"""
+import io
+import os
+import tempfile
+import textwrap
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, graphs_equal, nodes_equal
+
+edges_no_data = textwrap.dedent(
+    """
+    # comment line
+    1 2
+    # comment line
+    2 3
+    """
+)
+
+
+edges_with_values = textwrap.dedent(
+    """
+    # comment line
+    1 2 2.0
+    # comment line
+    2 3 3.0
+    """
+)
+
+
+edges_with_weight = textwrap.dedent(
+    """
+    # comment line
+    1 2 {'weight':2.0}
+    # comment line
+    2 3 {'weight':3.0}
+    """
+)
+
+
+edges_with_multiple_attrs = textwrap.dedent(
+    """
+    # comment line
+    1 2 {'weight':2.0, 'color':'green'}
+    # comment line
+    2 3 {'weight':3.0, 'color':'red'}
+    """
+)
+
+
+edges_with_multiple_attrs_csv = textwrap.dedent(
+    """
+    # comment line
+    1, 2, {'weight':2.0, 'color':'green'}
+    # comment line
+    2, 3, {'weight':3.0, 'color':'red'}
+    """
+)
+
+
+_expected_edges_weights = [(1, 2, {"weight": 2.0}), (2, 3, {"weight": 3.0})]
+_expected_edges_multiattr = [
+    (1, 2, {"weight": 2.0, "color": "green"}),
+    (2, 3, {"weight": 3.0, "color": "red"}),
+]
+
+
+@pytest.mark.parametrize(
+    ("data", "extra_kwargs"),
+    (
+        (edges_no_data, {}),
+        (edges_with_values, {}),
+        (edges_with_weight, {}),
+        (edges_with_multiple_attrs, {}),
+        (edges_with_multiple_attrs_csv, {"delimiter": ","}),
+    ),
+)
+def test_read_edgelist_no_data(data, extra_kwargs):
+    bytesIO = io.BytesIO(data.encode("utf-8"))
+    G = nx.read_edgelist(bytesIO, nodetype=int, data=False, **extra_kwargs)
+    assert edges_equal(G.edges(), [(1, 2), (2, 3)])
+
+
+def test_read_weighted_edgelist():
+    bytesIO = io.BytesIO(edges_with_values.encode("utf-8"))
+    G = nx.read_weighted_edgelist(bytesIO, nodetype=int)
+    assert edges_equal(G.edges(data=True), _expected_edges_weights)
+
+
+@pytest.mark.parametrize(
+    ("data", "extra_kwargs", "expected"),
+    (
+        (edges_with_weight, {}, _expected_edges_weights),
+        (edges_with_multiple_attrs, {}, _expected_edges_multiattr),
+        (edges_with_multiple_attrs_csv, {"delimiter": ","}, _expected_edges_multiattr),
+    ),
+)
+def test_read_edgelist_with_data(data, extra_kwargs, expected):
+    bytesIO = io.BytesIO(data.encode("utf-8"))
+    G = nx.read_edgelist(bytesIO, nodetype=int, **extra_kwargs)
+    assert edges_equal(G.edges(data=True), expected)
+
+
+@pytest.fixture
+def example_graph():
+    G = nx.Graph()
+    G.add_weighted_edges_from([(1, 2, 3.0), (2, 3, 27.0), (3, 4, 3.0)])
+    return G
+
+
+def test_parse_edgelist_no_data(example_graph):
+    G = example_graph
+    H = nx.parse_edgelist(["1 2", "2 3", "3 4"], nodetype=int)
+    assert nodes_equal(G.nodes, H.nodes)
+    assert edges_equal(G.edges, H.edges)
+
+
+def test_parse_edgelist_with_data_dict(example_graph):
+    G = example_graph
+    H = nx.parse_edgelist(
+        ["1 2 {'weight': 3}", "2 3 {'weight': 27}", "3 4 {'weight': 3.0}"], nodetype=int
+    )
+    assert nodes_equal(G.nodes, H.nodes)
+    assert edges_equal(G.edges(data=True), H.edges(data=True))
+
+
+def test_parse_edgelist_with_data_list(example_graph):
+    G = example_graph
+    H = nx.parse_edgelist(
+        ["1 2 3", "2 3 27", "3 4 3.0"], nodetype=int, data=(("weight", float),)
+    )
+    assert nodes_equal(G.nodes, H.nodes)
+    assert edges_equal(G.edges(data=True), H.edges(data=True))
+
+
+def test_parse_edgelist():
+    # ignore lines with less than 2 nodes
+    lines = ["1;2", "2 3", "3 4"]
+    G = nx.parse_edgelist(lines, nodetype=int)
+    assert list(G.edges()) == [(2, 3), (3, 4)]
+    # unknown nodetype
+    with pytest.raises(TypeError, match="Failed to convert nodes"):
+        lines = ["1 2", "2 3", "3 4"]
+        nx.parse_edgelist(lines, nodetype="nope")
+    # lines have invalid edge format
+    with pytest.raises(TypeError, match="Failed to convert edge data"):
+        lines = ["1 2 3", "2 3", "3 4"]
+        nx.parse_edgelist(lines, nodetype=int)
+    # edge data and data_keys not the same length
+    with pytest.raises(IndexError, match="not the same length"):
+        lines = ["1 2 3", "2 3 27", "3 4 3.0"]
+        nx.parse_edgelist(
+            lines, nodetype=int, data=(("weight", float), ("capacity", int))
+        )
+    # edge data can't be converted to edge type
+    with pytest.raises(TypeError, match="Failed to convert"):
+        lines = ["1 2 't1'", "2 3 't3'", "3 4 't3'"]
+        nx.parse_edgelist(lines, nodetype=int, data=(("weight", float),))
+
+
+def test_comments_None():
+    edgelist = ["node#1 node#2", "node#2 node#3"]
+    # comments=None supported to ignore all comment characters
+    G = nx.parse_edgelist(edgelist, comments=None)
+    H = nx.Graph([e.split(" ") for e in edgelist])
+    assert edges_equal(G.edges, H.edges)
+
+
+class TestEdgelist:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.Graph(name="test")
+        e = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("a", "f")]
+        cls.G.add_edges_from(e)
+        cls.G.add_node("g")
+        cls.DG = nx.DiGraph(cls.G)
+        cls.XG = nx.MultiGraph()
+        cls.XG.add_weighted_edges_from([(1, 2, 5), (1, 2, 5), (1, 2, 1), (3, 3, 42)])
+        cls.XDG = nx.MultiDiGraph(cls.XG)
+
+    def test_write_edgelist_1(self):
+        fh = io.BytesIO()
+        G = nx.OrderedGraph()
+        G.add_edges_from([(1, 2), (2, 3)])
+        nx.write_edgelist(G, fh, data=False)
+        fh.seek(0)
+        assert fh.read() == b"1 2\n2 3\n"
+
+    def test_write_edgelist_2(self):
+        fh = io.BytesIO()
+        G = nx.OrderedGraph()
+        G.add_edges_from([(1, 2), (2, 3)])
+        nx.write_edgelist(G, fh, data=True)
+        fh.seek(0)
+        assert fh.read() == b"1 2 {}\n2 3 {}\n"
+
+    def test_write_edgelist_3(self):
+        fh = io.BytesIO()
+        G = nx.OrderedGraph()
+        G.add_edge(1, 2, weight=2.0)
+        G.add_edge(2, 3, weight=3.0)
+        nx.write_edgelist(G, fh, data=True)
+        fh.seek(0)
+        assert fh.read() == b"1 2 {'weight': 2.0}\n2 3 {'weight': 3.0}\n"
+
+    def test_write_edgelist_4(self):
+        fh = io.BytesIO()
+        G = nx.OrderedGraph()
+        G.add_edge(1, 2, weight=2.0)
+        G.add_edge(2, 3, weight=3.0)
+        nx.write_edgelist(G, fh, data=[("weight")])
+        fh.seek(0)
+        assert fh.read() == b"1 2 2.0\n2 3 3.0\n"
+
+    def test_unicode(self):
+        G = nx.Graph()
+        name1 = chr(2344) + chr(123) + chr(6543)
+        name2 = chr(5543) + chr(1543) + chr(324)
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        fd, fname = tempfile.mkstemp()
+        nx.write_edgelist(G, fname)
+        H = nx.read_edgelist(fname)
+        assert graphs_equal(G, H)
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_latin1_issue(self):
+        G = nx.Graph()
+        name1 = chr(2344) + chr(123) + chr(6543)
+        name2 = chr(5543) + chr(1543) + chr(324)
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        fd, fname = tempfile.mkstemp()
+        pytest.raises(
+            UnicodeEncodeError, nx.write_edgelist, G, fname, encoding="latin-1"
+        )
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_latin1(self):
+        G = nx.Graph()
+        name1 = "Bj" + chr(246) + "rk"
+        name2 = chr(220) + "ber"
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        fd, fname = tempfile.mkstemp()
+        nx.write_edgelist(G, fname, encoding="latin-1")
+        H = nx.read_edgelist(fname, encoding="latin-1")
+        assert graphs_equal(G, H)
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_edgelist_graph(self):
+        G = self.G
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_edgelist(G, fname)
+        H = nx.read_edgelist(fname)
+        H2 = nx.read_edgelist(fname)
+        assert H is not H2  # they should be different graphs
+        G.remove_node("g")  # isolated nodes are not written in edgelist
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_edgelist_digraph(self):
+        G = self.DG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_edgelist(G, fname)
+        H = nx.read_edgelist(fname, create_using=nx.DiGraph())
+        H2 = nx.read_edgelist(fname, create_using=nx.DiGraph())
+        assert H is not H2  # they should be different graphs
+        G.remove_node("g")  # isolated nodes are not written in edgelist
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_edgelist_integers(self):
+        G = nx.convert_node_labels_to_integers(self.G)
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_edgelist(G, fname)
+        H = nx.read_edgelist(fname, nodetype=int)
+        # isolated nodes are not written in edgelist
+        G.remove_nodes_from(list(nx.isolates(G)))
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_edgelist_multigraph(self):
+        G = self.XG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_edgelist(G, fname)
+        H = nx.read_edgelist(fname, nodetype=int, create_using=nx.MultiGraph())
+        H2 = nx.read_edgelist(fname, nodetype=int, create_using=nx.MultiGraph())
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_edgelist_multidigraph(self):
+        G = self.XDG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_edgelist(G, fname)
+        H = nx.read_edgelist(fname, nodetype=int, create_using=nx.MultiDiGraph())
+        H2 = nx.read_edgelist(fname, nodetype=int, create_using=nx.MultiDiGraph())
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_getattr_nxyaml_removal.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_getattr_nxyaml_removal.py
new file mode 100644
index 0000000..83fc059
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_getattr_nxyaml_removal.py
@@ -0,0 +1,38 @@
+"""Test that informative exception messages are raised when attempting to
+access nx_yaml."""
+
+import pytest
+
+_msg_stub = "\n.* has been removed from NetworkX"
+
+
+def test_access_from_module():
+    with pytest.raises(ImportError, match=_msg_stub):
+        from networkx.readwrite.nx_yaml import read_yaml
+    with pytest.raises(ImportError, match=_msg_stub):
+        from networkx.readwrite.nx_yaml import write_yaml
+
+
+def test_access_from_nx_namespace():
+    import networkx as nx
+
+    with pytest.raises(ImportError, match=_msg_stub):
+        nx.read_yaml
+    with pytest.raises(ImportError, match=_msg_stub):
+        nx.write_yaml
+
+
+def test_access_from_readwrite_pkg():
+    from networkx import readwrite
+
+    with pytest.raises(ImportError, match=_msg_stub):
+        readwrite.read_yaml
+    with pytest.raises(ImportError, match=_msg_stub):
+        readwrite.write_yaml
+
+
+def test_accessing_nx_yaml():
+    import networkx as nx
+
+    with pytest.raises(ImportError, match=_msg_stub):
+        nx.nx_yaml
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_gexf.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_gexf.py
new file mode 100644
index 0000000..7166c09
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_gexf.py
@@ -0,0 +1,547 @@
+import io
+import time
+
+import pytest
+
+import networkx as nx
+
+
+class TestGEXF:
+    @classmethod
+    def setup_class(cls):
+        cls.simple_directed_data = """<?xml version="1.0" encoding="UTF-8"?>
+<gexf xmlns="http://www.gexf.net/1.2draft" version="1.2">
+    <graph mode="static" defaultedgetype="directed">
+        <nodes>
+            <node id="0" label="Hello" />
+            <node id="1" label="Word" />
+        </nodes>
+        <edges>
+            <edge id="0" source="0" target="1" />
+        </edges>
+    </graph>
+</gexf>
+"""
+        cls.simple_directed_graph = nx.DiGraph()
+        cls.simple_directed_graph.add_node("0", label="Hello")
+        cls.simple_directed_graph.add_node("1", label="World")
+        cls.simple_directed_graph.add_edge("0", "1", id="0")
+
+        cls.simple_directed_fh = io.BytesIO(cls.simple_directed_data.encode("UTF-8"))
+
+        cls.attribute_data = """<?xml version="1.0" encoding="UTF-8"?>\
+<gexf xmlns="http://www.gexf.net/1.2draft" xmlns:xsi="http://www.w3.\
+org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.gexf.net/\
+1.2draft http://www.gexf.net/1.2draft/gexf.xsd" version="1.2">
+  <meta lastmodifieddate="2009-03-20">
+    <creator>Gephi.org</creator>
+    <description>A Web network</description>
+  </meta>
+  <graph defaultedgetype="directed">
+    <attributes class="node">
+      <attribute id="0" title="url" type="string"/>
+      <attribute id="1" title="indegree" type="integer"/>
+      <attribute id="2" title="frog" type="boolean">
+        <default>true</default>
+      </attribute>
+    </attributes>
+    <nodes>
+      <node id="0" label="Gephi">
+        <attvalues>
+          <attvalue for="0" value="https://gephi.org"/>
+          <attvalue for="1" value="1"/>
+          <attvalue for="2" value="false"/>
+        </attvalues>
+      </node>
+      <node id="1" label="Webatlas">
+        <attvalues>
+          <attvalue for="0" value="http://webatlas.fr"/>
+          <attvalue for="1" value="2"/>
+          <attvalue for="2" value="false"/>
+        </attvalues>
+      </node>
+      <node id="2" label="RTGI">
+        <attvalues>
+          <attvalue for="0" value="http://rtgi.fr"/>
+          <attvalue for="1" value="1"/>
+          <attvalue for="2" value="true"/>
+        </attvalues>
+      </node>
+      <node id="3" label="BarabasiLab">
+        <attvalues>
+          <attvalue for="0" value="http://barabasilab.com"/>
+          <attvalue for="1" value="1"/>
+          <attvalue for="2" value="true"/>
+        </attvalues>
+      </node>
+    </nodes>
+    <edges>
+      <edge id="0" source="0" target="1" label="foo"/>
+      <edge id="1" source="0" target="2"/>
+      <edge id="2" source="1" target="0"/>
+      <edge id="3" source="2" target="1"/>
+      <edge id="4" source="0" target="3"/>
+    </edges>
+  </graph>
+</gexf>
+"""
+        cls.attribute_graph = nx.DiGraph()
+        cls.attribute_graph.graph["node_default"] = {"frog": True}
+        cls.attribute_graph.add_node(
+            "0", label="Gephi", url="https://gephi.org", indegree=1, frog=False
+        )
+        cls.attribute_graph.add_node(
+            "1", label="Webatlas", url="http://webatlas.fr", indegree=2, frog=False
+        )
+        cls.attribute_graph.add_node(
+            "2", label="RTGI", url="http://rtgi.fr", indegree=1, frog=True
+        )
+        cls.attribute_graph.add_node(
+            "3",
+            label="BarabasiLab",
+            url="http://barabasilab.com",
+            indegree=1,
+            frog=True,
+        )
+        cls.attribute_graph.add_edge("0", "1", id="0", label="foo")
+        cls.attribute_graph.add_edge("0", "2", id="1")
+        cls.attribute_graph.add_edge("1", "0", id="2")
+        cls.attribute_graph.add_edge("2", "1", id="3")
+        cls.attribute_graph.add_edge("0", "3", id="4")
+        cls.attribute_fh = io.BytesIO(cls.attribute_data.encode("UTF-8"))
+
+        cls.simple_undirected_data = """<?xml version="1.0" encoding="UTF-8"?>
+<gexf xmlns="http://www.gexf.net/1.2draft" version="1.2">
+    <graph mode="static" defaultedgetype="undirected">
+        <nodes>
+            <node id="0" label="Hello" />
+            <node id="1" label="Word" />
+        </nodes>
+        <edges>
+            <edge id="0" source="0" target="1" />
+        </edges>
+    </graph>
+</gexf>
+"""
+        cls.simple_undirected_graph = nx.Graph()
+        cls.simple_undirected_graph.add_node("0", label="Hello")
+        cls.simple_undirected_graph.add_node("1", label="World")
+        cls.simple_undirected_graph.add_edge("0", "1", id="0")
+
+        cls.simple_undirected_fh = io.BytesIO(
+            cls.simple_undirected_data.encode("UTF-8")
+        )
+
+    def test_read_simple_directed_graphml(self):
+        G = self.simple_directed_graph
+        H = nx.read_gexf(self.simple_directed_fh)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(G.edges()) == sorted(H.edges())
+        assert sorted(G.edges(data=True)) == sorted(H.edges(data=True))
+        self.simple_directed_fh.seek(0)
+
+    def test_write_read_simple_directed_graphml(self):
+        G = self.simple_directed_graph
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh)
+        fh.seek(0)
+        H = nx.read_gexf(fh)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(G.edges()) == sorted(H.edges())
+        assert sorted(G.edges(data=True)) == sorted(H.edges(data=True))
+        self.simple_directed_fh.seek(0)
+
+    def test_read_simple_undirected_graphml(self):
+        G = self.simple_undirected_graph
+        H = nx.read_gexf(self.simple_undirected_fh)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(sorted(e) for e in G.edges()) == sorted(
+            sorted(e) for e in H.edges()
+        )
+        self.simple_undirected_fh.seek(0)
+
+    def test_read_attribute_graphml(self):
+        G = self.attribute_graph
+        H = nx.read_gexf(self.attribute_fh)
+        assert sorted(G.nodes(True)) == sorted(H.nodes(data=True))
+        ge = sorted(G.edges(data=True))
+        he = sorted(H.edges(data=True))
+        for a, b in zip(ge, he):
+            assert a == b
+        self.attribute_fh.seek(0)
+
+    def test_directed_edge_in_undirected(self):
+        s = """<?xml version="1.0" encoding="UTF-8"?>
+<gexf xmlns="http://www.gexf.net/1.2draft" version='1.2'>
+    <graph mode="static" defaultedgetype="undirected" name="">
+        <nodes>
+            <node id="0" label="Hello" />
+            <node id="1" label="Word" />
+        </nodes>
+        <edges>
+            <edge id="0" source="0" target="1" type="directed"/>
+        </edges>
+    </graph>
+</gexf>
+"""
+        fh = io.BytesIO(s.encode("UTF-8"))
+        pytest.raises(nx.NetworkXError, nx.read_gexf, fh)
+
+    def test_undirected_edge_in_directed(self):
+        s = """<?xml version="1.0" encoding="UTF-8"?>
+<gexf xmlns="http://www.gexf.net/1.2draft" version='1.2'>
+    <graph mode="static" defaultedgetype="directed" name="">
+        <nodes>
+            <node id="0" label="Hello" />
+            <node id="1" label="Word" />
+        </nodes>
+        <edges>
+            <edge id="0" source="0" target="1" type="undirected"/>
+        </edges>
+    </graph>
+</gexf>
+"""
+        fh = io.BytesIO(s.encode("UTF-8"))
+        pytest.raises(nx.NetworkXError, nx.read_gexf, fh)
+
+    def test_key_raises(self):
+        s = """<?xml version="1.0" encoding="UTF-8"?>
+<gexf xmlns="http://www.gexf.net/1.2draft" version='1.2'>
+    <graph mode="static" defaultedgetype="directed" name="">
+        <nodes>
+            <node id="0" label="Hello">
+              <attvalues>
+                <attvalue for='0' value='1'/>
+              </attvalues>
+            </node>
+            <node id="1" label="Word" />
+        </nodes>
+        <edges>
+            <edge id="0" source="0" target="1" type="undirected"/>
+        </edges>
+    </graph>
+</gexf>
+"""
+        fh = io.BytesIO(s.encode("UTF-8"))
+        pytest.raises(nx.NetworkXError, nx.read_gexf, fh)
+
+    def test_relabel(self):
+        s = """<?xml version="1.0" encoding="UTF-8"?>
+<gexf xmlns="http://www.gexf.net/1.2draft" version='1.2'>
+    <graph mode="static" defaultedgetype="directed" name="">
+        <nodes>
+            <node id="0" label="Hello" />
+            <node id="1" label="Word" />
+        </nodes>
+        <edges>
+            <edge id="0" source="0" target="1"/>
+        </edges>
+    </graph>
+</gexf>
+"""
+        fh = io.BytesIO(s.encode("UTF-8"))
+        G = nx.read_gexf(fh, relabel=True)
+        assert sorted(G.nodes()) == ["Hello", "Word"]
+
+    def test_default_attribute(self):
+        G = nx.Graph()
+        G.add_node(1, label="1", color="green")
+        nx.add_path(G, [0, 1, 2, 3])
+        G.add_edge(1, 2, foo=3)
+        G.graph["node_default"] = {"color": "yellow"}
+        G.graph["edge_default"] = {"foo": 7}
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh)
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(sorted(e) for e in G.edges()) == sorted(
+            sorted(e) for e in H.edges()
+        )
+        # Reading a gexf graph always sets mode attribute to either
+        # 'static' or 'dynamic'. Remove the mode attribute from the
+        # read graph for the sake of comparing remaining attributes.
+        del H.graph["mode"]
+        assert G.graph == H.graph
+
+    def test_serialize_ints_to_strings(self):
+        G = nx.Graph()
+        G.add_node(1, id=7, label=77)
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh)
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+        assert list(H) == [7]
+        assert H.nodes[7]["label"] == "77"
+
+    def test_write_with_node_attributes(self):
+        # Addresses #673.
+        G = nx.OrderedGraph()
+        G.add_edges_from([(0, 1), (1, 2), (2, 3)])
+        for i in range(4):
+            G.nodes[i]["id"] = i
+            G.nodes[i]["label"] = i
+            G.nodes[i]["pid"] = i
+            G.nodes[i]["start"] = i
+            G.nodes[i]["end"] = i + 1
+
+        expected = f"""<gexf xmlns="http://www.gexf.net/1.2draft" xmlns:xsi\
+="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=\
+"http://www.gexf.net/1.2draft http://www.gexf.net/1.2draft/\
+gexf.xsd" version="1.2">
+  <meta lastmodifieddate="{time.strftime('%Y-%m-%d')}">
+    <creator>NetworkX {nx.__version__}</creator>
+  </meta>
+  <graph defaultedgetype="undirected" mode="dynamic" name="" timeformat="long">
+    <nodes>
+      <node id="0" label="0" pid="0" start="0" end="1" />
+      <node id="1" label="1" pid="1" start="1" end="2" />
+      <node id="2" label="2" pid="2" start="2" end="3" />
+      <node id="3" label="3" pid="3" start="3" end="4" />
+    </nodes>
+    <edges>
+      <edge source="0" target="1" id="0" />
+      <edge source="1" target="2" id="1" />
+      <edge source="2" target="3" id="2" />
+    </edges>
+  </graph>
+</gexf>"""
+        obtained = "\n".join(nx.generate_gexf(G))
+        assert expected == obtained
+
+    def test_edge_id_construct(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1, {"id": 0}), (1, 2, {"id": 2}), (2, 3)])
+
+        expected = f"""<gexf xmlns="http://www.gexf.net/1.2draft" xmlns:xsi\
+="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.\
+gexf.net/1.2draft http://www.gexf.net/1.2draft/gexf.xsd" version="1.2">
+  <meta lastmodifieddate="{time.strftime('%Y-%m-%d')}">
+    <creator>NetworkX {nx.__version__}</creator>
+  </meta>
+  <graph defaultedgetype="undirected" mode="static" name="">
+    <nodes>
+      <node id="0" label="0" />
+      <node id="1" label="1" />
+      <node id="2" label="2" />
+      <node id="3" label="3" />
+    </nodes>
+    <edges>
+      <edge source="0" target="1" id="0" />
+      <edge source="1" target="2" id="2" />
+      <edge source="2" target="3" id="1" />
+    </edges>
+  </graph>
+</gexf>"""
+
+        obtained = "\n".join(nx.generate_gexf(G))
+        assert expected == obtained
+
+    def test_numpy_type(self):
+        np = pytest.importorskip("numpy")
+        G = nx.path_graph(4)
+        nx.set_node_attributes(G, {n: n for n in np.arange(4)}, "number")
+        G[0][1]["edge-number"] = np.float64(1.1)
+
+        expected = f"""<gexf xmlns="http://www.gexf.net/1.2draft"\
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation\
+="http://www.gexf.net/1.2draft http://www.gexf.net/1.2draft/gexf.xsd"\
+ version="1.2">
+  <meta lastmodifieddate="{time.strftime('%Y-%m-%d')}">
+    <creator>NetworkX {nx.__version__}</creator>
+  </meta>
+  <graph defaultedgetype="undirected" mode="static" name="">
+    <attributes mode="static" class="edge">
+      <attribute id="1" title="edge-number" type="float" />
+    </attributes>
+    <attributes mode="static" class="node">
+      <attribute id="0" title="number" type="int" />
+    </attributes>
+    <nodes>
+      <node id="0" label="0">
+        <attvalues>
+          <attvalue for="0" value="0" />
+        </attvalues>
+      </node>
+      <node id="1" label="1">
+        <attvalues>
+          <attvalue for="0" value="1" />
+        </attvalues>
+      </node>
+      <node id="2" label="2">
+        <attvalues>
+          <attvalue for="0" value="2" />
+        </attvalues>
+      </node>
+      <node id="3" label="3">
+        <attvalues>
+          <attvalue for="0" value="3" />
+        </attvalues>
+      </node>
+    </nodes>
+    <edges>
+      <edge source="0" target="1" id="0">
+        <attvalues>
+          <attvalue for="1" value="1.1" />
+        </attvalues>
+      </edge>
+      <edge source="1" target="2" id="1" />
+      <edge source="2" target="3" id="2" />
+    </edges>
+  </graph>
+</gexf>"""
+        obtained = "\n".join(nx.generate_gexf(G))
+        assert expected == obtained
+
+    def test_bool(self):
+        G = nx.Graph()
+        G.add_node(1, testattr=True)
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh)
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+        assert H.nodes[1]["testattr"]
+
+    # Test for NaN, INF and -INF
+    def test_specials(self):
+        from math import isnan
+
+        inf, nan = float("inf"), float("nan")
+        G = nx.Graph()
+        G.add_node(1, testattr=inf, strdata="inf", key="a")
+        G.add_node(2, testattr=nan, strdata="nan", key="b")
+        G.add_node(3, testattr=-inf, strdata="-inf", key="c")
+
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh)
+        fh.seek(0)
+        filetext = fh.read()
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+
+        assert b"INF" in filetext
+        assert b"NaN" in filetext
+        assert b"-INF" in filetext
+
+        assert H.nodes[1]["testattr"] == inf
+        assert isnan(H.nodes[2]["testattr"])
+        assert H.nodes[3]["testattr"] == -inf
+
+        assert H.nodes[1]["strdata"] == "inf"
+        assert H.nodes[2]["strdata"] == "nan"
+        assert H.nodes[3]["strdata"] == "-inf"
+
+        assert H.nodes[1]["networkx_key"] == "a"
+        assert H.nodes[2]["networkx_key"] == "b"
+        assert H.nodes[3]["networkx_key"] == "c"
+
+    def test_simple_list(self):
+        G = nx.Graph()
+        list_value = [(1, 2, 3), (9, 1, 2)]
+        G.add_node(1, key=list_value)
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh)
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+        assert H.nodes[1]["networkx_key"] == list_value
+
+    def test_dynamic_mode(self):
+        G = nx.Graph()
+        G.add_node(1, label="1", color="green")
+        G.graph["mode"] = "dynamic"
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh)
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(sorted(e) for e in G.edges()) == sorted(
+            sorted(e) for e in H.edges()
+        )
+
+    def test_multigraph_with_missing_attributes(self):
+        G = nx.MultiGraph()
+        G.add_node(0, label="1", color="green")
+        G.add_node(1, label="2", color="green")
+        G.add_edge(0, 1, id="0", wight=3, type="undirected", start=0, end=1)
+        G.add_edge(0, 1, id="1", label="foo", start=0, end=1)
+        G.add_edge(0, 1)
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh)
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(sorted(e) for e in G.edges()) == sorted(
+            sorted(e) for e in H.edges()
+        )
+
+    def test_missing_viz_attributes(self):
+        G = nx.Graph()
+        G.add_node(0, label="1", color="green")
+        G.nodes[0]["viz"] = {"size": 54}
+        G.nodes[0]["viz"]["position"] = {"x": 0, "y": 1, "z": 0}
+        G.nodes[0]["viz"]["color"] = {"r": 0, "g": 0, "b": 256}
+        G.nodes[0]["viz"]["shape"] = "http://random.url"
+        G.nodes[0]["viz"]["thickness"] = 2
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh, version="1.1draft")
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(sorted(e) for e in G.edges()) == sorted(
+            sorted(e) for e in H.edges()
+        )
+
+        # Second graph for the other branch
+        G = nx.Graph()
+        G.add_node(0, label="1", color="green")
+        G.nodes[0]["viz"] = {"size": 54}
+        G.nodes[0]["viz"]["position"] = {"x": 0, "y": 1, "z": 0}
+        G.nodes[0]["viz"]["color"] = {"r": 0, "g": 0, "b": 256, "a": 0.5}
+        G.nodes[0]["viz"]["shape"] = "ftp://random.url"
+        G.nodes[0]["viz"]["thickness"] = 2
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh)
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(sorted(e) for e in G.edges()) == sorted(
+            sorted(e) for e in H.edges()
+        )
+
+    def test_slice_and_spell(self):
+        # Test spell first, so version = 1.2
+        G = nx.Graph()
+        G.add_node(0, label="1", color="green")
+        G.nodes[0]["spells"] = [(1, 2)]
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh)
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(sorted(e) for e in G.edges()) == sorted(
+            sorted(e) for e in H.edges()
+        )
+
+        G = nx.Graph()
+        G.add_node(0, label="1", color="green")
+        G.nodes[0]["slices"] = [(1, 2)]
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh, version="1.1draft")
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(sorted(e) for e in G.edges()) == sorted(
+            sorted(e) for e in H.edges()
+        )
+
+    def test_add_parent(self):
+        G = nx.Graph()
+        G.add_node(0, label="1", color="green", parents=[1, 2])
+        fh = io.BytesIO()
+        nx.write_gexf(G, fh)
+        fh.seek(0)
+        H = nx.read_gexf(fh, node_type=int)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(sorted(e) for e in G.edges()) == sorted(
+            sorted(e) for e in H.edges()
+        )
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_gml.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_gml.py
new file mode 100644
index 0000000..19fb7ed
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_gml.py
@@ -0,0 +1,714 @@
+import codecs
+import io
+import math
+import os
+import tempfile
+from ast import literal_eval
+from contextlib import contextmanager
+from textwrap import dedent
+
+import pytest
+
+import networkx as nx
+from networkx.readwrite.gml import literal_destringizer, literal_stringizer
+
+
+class TestGraph:
+    @classmethod
+    def setup_class(cls):
+        cls.simple_data = """Creator "me"
+Version "xx"
+graph [
+ comment "This is a sample graph"
+ directed 1
+ IsPlanar 1
+ pos  [ x 0 y 1 ]
+ node [
+   id 1
+   label "Node 1"
+   pos [ x 1 y 1 ]
+ ]
+ node [
+    id 2
+    pos [ x 1 y 2 ]
+    label "Node 2"
+    ]
+  node [
+    id 3
+    label "Node 3"
+    pos [ x 1 y 3 ]
+  ]
+  edge [
+    source 1
+    target 2
+    label "Edge from node 1 to node 2"
+    color [line "blue" thickness 3]
+
+  ]
+  edge [
+    source 2
+    target 3
+    label "Edge from node 2 to node 3"
+  ]
+  edge [
+    source 3
+    target 1
+    label "Edge from node 3 to node 1"
+  ]
+]
+"""
+
+    def test_parse_gml_cytoscape_bug(self):
+        # example from issue #321, originally #324 in trac
+        cytoscape_example = """
+Creator "Cytoscape"
+Version 1.0
+graph   [
+    node    [
+        root_index  -3
+        id  -3
+        graphics    [
+            x   -96.0
+            y   -67.0
+            w   40.0
+            h   40.0
+            fill    "#ff9999"
+            type    "ellipse"
+            outline "#666666"
+            outline_width   1.5
+        ]
+        label   "node2"
+    ]
+    node    [
+        root_index  -2
+        id  -2
+        graphics    [
+            x   63.0
+            y   37.0
+            w   40.0
+            h   40.0
+            fill    "#ff9999"
+            type    "ellipse"
+            outline "#666666"
+            outline_width   1.5
+        ]
+        label   "node1"
+    ]
+    node    [
+        root_index  -1
+        id  -1
+        graphics    [
+            x   -31.0
+            y   -17.0
+            w   40.0
+            h   40.0
+            fill    "#ff9999"
+            type    "ellipse"
+            outline "#666666"
+            outline_width   1.5
+        ]
+        label   "node0"
+    ]
+    edge    [
+        root_index  -2
+        target  -2
+        source  -1
+        graphics    [
+            width   1.5
+            fill    "#0000ff"
+            type    "line"
+            Line    [
+            ]
+            source_arrow    0
+            target_arrow    3
+        ]
+        label   "DirectedEdge"
+    ]
+    edge    [
+        root_index  -1
+        target  -1
+        source  -3
+        graphics    [
+            width   1.5
+            fill    "#0000ff"
+            type    "line"
+            Line    [
+            ]
+            source_arrow    0
+            target_arrow    3
+        ]
+        label   "DirectedEdge"
+    ]
+]
+"""
+        nx.parse_gml(cytoscape_example)
+
+    def test_parse_gml(self):
+        G = nx.parse_gml(self.simple_data, label="label")
+        assert sorted(G.nodes()) == ["Node 1", "Node 2", "Node 3"]
+        assert [e for e in sorted(G.edges())] == [
+            ("Node 1", "Node 2"),
+            ("Node 2", "Node 3"),
+            ("Node 3", "Node 1"),
+        ]
+
+        assert [e for e in sorted(G.edges(data=True))] == [
+            (
+                "Node 1",
+                "Node 2",
+                {
+                    "color": {"line": "blue", "thickness": 3},
+                    "label": "Edge from node 1 to node 2",
+                },
+            ),
+            ("Node 2", "Node 3", {"label": "Edge from node 2 to node 3"}),
+            ("Node 3", "Node 1", {"label": "Edge from node 3 to node 1"}),
+        ]
+
+    def test_read_gml(self):
+        (fd, fname) = tempfile.mkstemp()
+        fh = open(fname, "w")
+        fh.write(self.simple_data)
+        fh.close()
+        Gin = nx.read_gml(fname, label="label")
+        G = nx.parse_gml(self.simple_data, label="label")
+        assert sorted(G.nodes(data=True)) == sorted(Gin.nodes(data=True))
+        assert sorted(G.edges(data=True)) == sorted(Gin.edges(data=True))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_labels_are_strings(self):
+        # GML requires labels to be strings (i.e., in quotes)
+        answer = """graph [
+  node [
+    id 0
+    label "1203"
+  ]
+]"""
+        G = nx.Graph()
+        G.add_node(1203)
+        data = "\n".join(nx.generate_gml(G, stringizer=literal_stringizer))
+        assert data == answer
+
+    def test_relabel_duplicate(self):
+        data = """
+graph
+[
+        label   ""
+        directed        1
+        node
+        [
+                id      0
+                label   "same"
+        ]
+        node
+        [
+                id      1
+                label   "same"
+        ]
+]
+"""
+        fh = io.BytesIO(data.encode("UTF-8"))
+        fh.seek(0)
+        pytest.raises(nx.NetworkXError, nx.read_gml, fh, label="label")
+
+    def test_tuplelabels(self):
+        # https://github.com/networkx/networkx/pull/1048
+        # Writing tuple labels to GML failed.
+        G = nx.OrderedGraph()
+        G.add_edge((0, 1), (1, 0))
+        data = "\n".join(nx.generate_gml(G, stringizer=literal_stringizer))
+        answer = """graph [
+  node [
+    id 0
+    label "(0,1)"
+  ]
+  node [
+    id 1
+    label "(1,0)"
+  ]
+  edge [
+    source 0
+    target 1
+  ]
+]"""
+        assert data == answer
+
+    def test_quotes(self):
+        # https://github.com/networkx/networkx/issues/1061
+        # Encoding quotes as HTML entities.
+        G = nx.path_graph(1)
+        G.name = "path_graph(1)"
+        attr = 'This is "quoted" and this is a copyright: ' + chr(169)
+        G.nodes[0]["demo"] = attr
+        fobj = tempfile.NamedTemporaryFile()
+        nx.write_gml(G, fobj)
+        fobj.seek(0)
+        # Should be bytes in 2.x and 3.x
+        data = fobj.read().strip().decode("ascii")
+        answer = """graph [
+  name "path_graph(1)"
+  node [
+    id 0
+    label "0"
+    demo "This is &#34;quoted&#34; and this is a copyright: &#169;"
+  ]
+]"""
+        assert data == answer
+
+    def test_unicode_node(self):
+        node = "node" + chr(169)
+        G = nx.Graph()
+        G.add_node(node)
+        fobj = tempfile.NamedTemporaryFile()
+        nx.write_gml(G, fobj)
+        fobj.seek(0)
+        # Should be bytes in 2.x and 3.x
+        data = fobj.read().strip().decode("ascii")
+        answer = """graph [
+  node [
+    id 0
+    label "node&#169;"
+  ]
+]"""
+        assert data == answer
+
+    def test_float_label(self):
+        node = 1.0
+        G = nx.Graph()
+        G.add_node(node)
+        fobj = tempfile.NamedTemporaryFile()
+        nx.write_gml(G, fobj)
+        fobj.seek(0)
+        # Should be bytes in 2.x and 3.x
+        data = fobj.read().strip().decode("ascii")
+        answer = """graph [
+  node [
+    id 0
+    label "1.0"
+  ]
+]"""
+        assert data == answer
+
+    def test_special_float_label(self):
+        special_floats = [float("nan"), float("+inf"), float("-inf")]
+        try:
+            import numpy as np
+
+            special_floats += [np.nan, np.inf, np.inf * -1]
+        except ImportError:
+            special_floats += special_floats
+
+        G = nx.cycle_graph(len(special_floats))
+        attrs = dict(enumerate(special_floats))
+        nx.set_node_attributes(G, attrs, "nodefloat")
+        edges = list(G.edges)
+        attrs = {edges[i]: value for i, value in enumerate(special_floats)}
+        nx.set_edge_attributes(G, attrs, "edgefloat")
+
+        fobj = tempfile.NamedTemporaryFile()
+        nx.write_gml(G, fobj)
+        fobj.seek(0)
+        # Should be bytes in 2.x and 3.x
+        data = fobj.read().strip().decode("ascii")
+        answer = """graph [
+  node [
+    id 0
+    label "0"
+    nodefloat NAN
+  ]
+  node [
+    id 1
+    label "1"
+    nodefloat +INF
+  ]
+  node [
+    id 2
+    label "2"
+    nodefloat -INF
+  ]
+  node [
+    id 3
+    label "3"
+    nodefloat NAN
+  ]
+  node [
+    id 4
+    label "4"
+    nodefloat +INF
+  ]
+  node [
+    id 5
+    label "5"
+    nodefloat -INF
+  ]
+  edge [
+    source 0
+    target 1
+    edgefloat NAN
+  ]
+  edge [
+    source 0
+    target 5
+    edgefloat +INF
+  ]
+  edge [
+    source 1
+    target 2
+    edgefloat -INF
+  ]
+  edge [
+    source 2
+    target 3
+    edgefloat NAN
+  ]
+  edge [
+    source 3
+    target 4
+    edgefloat +INF
+  ]
+  edge [
+    source 4
+    target 5
+    edgefloat -INF
+  ]
+]"""
+        assert data == answer
+
+        fobj.seek(0)
+        graph = nx.read_gml(fobj)
+        for indx, value in enumerate(special_floats):
+            node_value = graph.nodes[str(indx)]["nodefloat"]
+            if math.isnan(value):
+                assert math.isnan(node_value)
+            else:
+                assert node_value == value
+
+            edge = edges[indx]
+            string_edge = (str(edge[0]), str(edge[1]))
+            edge_value = graph.edges[string_edge]["edgefloat"]
+            if math.isnan(value):
+                assert math.isnan(edge_value)
+            else:
+                assert edge_value == value
+
+    def test_name(self):
+        G = nx.parse_gml('graph [ name "x" node [ id 0 label "x" ] ]')
+        assert "x" == G.graph["name"]
+        G = nx.parse_gml('graph [ node [ id 0 label "x" ] ]')
+        assert "" == G.name
+        assert "name" not in G.graph
+
+    def test_graph_types(self):
+        for directed in [None, False, True]:
+            for multigraph in [None, False, True]:
+                gml = "graph ["
+                if directed is not None:
+                    gml += " directed " + str(int(directed))
+                if multigraph is not None:
+                    gml += " multigraph " + str(int(multigraph))
+                gml += ' node [ id 0 label "0" ]'
+                gml += " edge [ source 0 target 0 ]"
+                gml += " ]"
+                G = nx.parse_gml(gml)
+                assert bool(directed) == G.is_directed()
+                assert bool(multigraph) == G.is_multigraph()
+                gml = "graph [\n"
+                if directed is True:
+                    gml += "  directed 1\n"
+                if multigraph is True:
+                    gml += "  multigraph 1\n"
+                gml += """  node [
+    id 0
+    label "0"
+  ]
+  edge [
+    source 0
+    target 0
+"""
+                if multigraph:
+                    gml += "    key 0\n"
+                gml += "  ]\n]"
+                assert gml == "\n".join(nx.generate_gml(G))
+
+    def test_data_types(self):
+        data = [
+            True,
+            False,
+            10**20,
+            -2e33,
+            "'",
+            '"&&amp;&&#34;"',
+            [{(b"\xfd",): "\x7f", chr(0x4444): (1, 2)}, (2, "3")],
+        ]
+        data.append(chr(0x14444))
+        data.append(literal_eval("{2.3j, 1 - 2.3j, ()}"))
+        G = nx.Graph()
+        G.name = data
+        G.graph["data"] = data
+        G.add_node(0, int=-1, data=dict(data=data))
+        G.add_edge(0, 0, float=-2.5, data=data)
+        gml = "\n".join(nx.generate_gml(G, stringizer=literal_stringizer))
+        G = nx.parse_gml(gml, destringizer=literal_destringizer)
+        assert data == G.name
+        assert {"name": data, "data": data} == G.graph
+        assert list(G.nodes(data=True)) == [(0, dict(int=-1, data=dict(data=data)))]
+        assert list(G.edges(data=True)) == [(0, 0, dict(float=-2.5, data=data))]
+        G = nx.Graph()
+        G.graph["data"] = "frozenset([1, 2, 3])"
+        G = nx.parse_gml(nx.generate_gml(G), destringizer=literal_eval)
+        assert G.graph["data"] == "frozenset([1, 2, 3])"
+
+    def test_escape_unescape(self):
+        gml = """graph [
+  name "&amp;&#34;&#xf;&#x4444;&#1234567890;&#x1234567890abcdef;&unknown;"
+]"""
+        G = nx.parse_gml(gml)
+        assert (
+            '&"\x0f' + chr(0x4444) + "&#1234567890;&#x1234567890abcdef;&unknown;"
+            == G.name
+        )
+        gml = "\n".join(nx.generate_gml(G))
+        alnu = "#1234567890;&#38;#x1234567890abcdef"
+        answer = (
+            """graph [
+  name "&#38;&#34;&#15;&#17476;&#38;"""
+            + alnu
+            + """;&#38;unknown;"
+]"""
+        )
+        assert answer == gml
+
+    def test_exceptions(self):
+        pytest.raises(ValueError, literal_destringizer, "(")
+        pytest.raises(ValueError, literal_destringizer, "frozenset([1, 2, 3])")
+        pytest.raises(ValueError, literal_destringizer, literal_destringizer)
+        pytest.raises(ValueError, literal_stringizer, frozenset([1, 2, 3]))
+        pytest.raises(ValueError, literal_stringizer, literal_stringizer)
+        with tempfile.TemporaryFile() as f:
+            f.write(codecs.BOM_UTF8 + b"graph[]")
+            f.seek(0)
+            pytest.raises(nx.NetworkXError, nx.read_gml, f)
+
+        def assert_parse_error(gml):
+            pytest.raises(nx.NetworkXError, nx.parse_gml, gml)
+
+        assert_parse_error(["graph [\n\n", "]"])
+        assert_parse_error("")
+        assert_parse_error('Creator ""')
+        assert_parse_error("0")
+        assert_parse_error("graph ]")
+        assert_parse_error("graph [ 1 ]")
+        assert_parse_error("graph [ 1.E+2 ]")
+        assert_parse_error('graph [ "A" ]')
+        assert_parse_error("graph [ ] graph ]")
+        assert_parse_error("graph [ ] graph [ ]")
+        assert_parse_error("graph [ data [1, 2, 3] ]")
+        assert_parse_error("graph [ node [ ] ]")
+        assert_parse_error("graph [ node [ id 0 ] ]")
+        nx.parse_gml('graph [ node [ id "a" ] ]', label="id")
+        assert_parse_error("graph [ node [ id 0 label 0 ] node [ id 0 label 1 ] ]")
+        assert_parse_error("graph [ node [ id 0 label 0 ] node [ id 1 label 0 ] ]")
+        assert_parse_error("graph [ node [ id 0 label 0 ] edge [ ] ]")
+        assert_parse_error("graph [ node [ id 0 label 0 ] edge [ source 0 ] ]")
+        nx.parse_gml("graph [edge [ source 0 target 0 ] node [ id 0 label 0 ] ]")
+        assert_parse_error("graph [ node [ id 0 label 0 ] edge [ source 1 target 0 ] ]")
+        assert_parse_error("graph [ node [ id 0 label 0 ] edge [ source 0 target 1 ] ]")
+        assert_parse_error(
+            "graph [ node [ id 0 label 0 ] node [ id 1 label 1 ] "
+            "edge [ source 0 target 1 ] edge [ source 1 target 0 ] ]"
+        )
+        nx.parse_gml(
+            "graph [ node [ id 0 label 0 ] node [ id 1 label 1 ] "
+            "edge [ source 0 target 1 ] edge [ source 1 target 0 ] "
+            "directed 1 ]"
+        )
+        nx.parse_gml(
+            "graph [ node [ id 0 label 0 ] node [ id 1 label 1 ] "
+            "edge [ source 0 target 1 ] edge [ source 0 target 1 ]"
+            "multigraph 1 ]"
+        )
+        nx.parse_gml(
+            "graph [ node [ id 0 label 0 ] node [ id 1 label 1 ] "
+            "edge [ source 0 target 1 key 0 ] edge [ source 0 target 1 ]"
+            "multigraph 1 ]"
+        )
+        assert_parse_error(
+            "graph [ node [ id 0 label 0 ] node [ id 1 label 1 ] "
+            "edge [ source 0 target 1 key 0 ] edge [ source 0 target 1 key 0 ]"
+            "multigraph 1 ]"
+        )
+        nx.parse_gml(
+            "graph [ node [ id 0 label 0 ] node [ id 1 label 1 ] "
+            "edge [ source 0 target 1 key 0 ] edge [ source 1 target 0 key 0 ]"
+            "directed 1 multigraph 1 ]"
+        )
+
+        # Tests for string convertable alphanumeric id and label values
+        nx.parse_gml("graph [edge [ source a target a ] node [ id a label b ] ]")
+        nx.parse_gml(
+            "graph [ node [ id n42 label 0 ] node [ id x43 label 1 ]"
+            "edge [ source n42 target x43 key 0 ]"
+            "edge [ source x43 target n42 key 0 ]"
+            "directed 1 multigraph 1 ]"
+        )
+        assert_parse_error(
+            "graph [edge [ source u'u\4200' target u'u\4200' ] "
+            + "node [ id u'u\4200' label b ] ]"
+        )
+
+        def assert_generate_error(*args, **kwargs):
+            pytest.raises(
+                nx.NetworkXError, lambda: list(nx.generate_gml(*args, **kwargs))
+            )
+
+        G = nx.Graph()
+        G.graph[3] = 3
+        assert_generate_error(G)
+        G = nx.Graph()
+        G.graph["3"] = 3
+        assert_generate_error(G)
+        G = nx.Graph()
+        G.graph["data"] = frozenset([1, 2, 3])
+        assert_generate_error(G, stringizer=literal_stringizer)
+        G = nx.Graph()
+        G.graph["data"] = []
+        assert_generate_error(G)
+        assert_generate_error(G, stringizer=len)
+
+    def test_label_kwarg(self):
+        G = nx.parse_gml(self.simple_data, label="id")
+        assert sorted(G.nodes) == [1, 2, 3]
+        labels = [G.nodes[n]["label"] for n in sorted(G.nodes)]
+        assert labels == ["Node 1", "Node 2", "Node 3"]
+
+        G = nx.parse_gml(self.simple_data, label=None)
+        assert sorted(G.nodes) == [1, 2, 3]
+        labels = [G.nodes[n]["label"] for n in sorted(G.nodes)]
+        assert labels == ["Node 1", "Node 2", "Node 3"]
+
+    def test_outofrange_integers(self):
+        # GML restricts integers to 32 signed bits.
+        # Check that we honor this restriction on export
+        G = nx.Graph()
+        # Test export for numbers that barely fit or don't fit into 32 bits,
+        # and 3 numbers in the middle
+        numbers = {
+            "toosmall": (-(2**31)) - 1,
+            "small": -(2**31),
+            "med1": -4,
+            "med2": 0,
+            "med3": 17,
+            "big": (2**31) - 1,
+            "toobig": 2**31,
+        }
+        G.add_node("Node", **numbers)
+
+        fd, fname = tempfile.mkstemp()
+        try:
+            nx.write_gml(G, fname)
+            # Check that the export wrote the nonfitting numbers as strings
+            G2 = nx.read_gml(fname)
+            for attr, value in G2.nodes["Node"].items():
+                if attr == "toosmall" or attr == "toobig":
+                    assert type(value) == str
+                else:
+                    assert type(value) == int
+        finally:
+            os.close(fd)
+            os.unlink(fname)
+
+
+@contextmanager
+def byte_file():
+    _file_handle = io.BytesIO()
+    yield _file_handle
+    _file_handle.seek(0)
+
+
+class TestPropertyLists:
+    def test_writing_graph_with_multi_element_property_list(self):
+        g = nx.Graph()
+        g.add_node("n1", properties=["element", 0, 1, 2.5, True, False])
+        with byte_file() as f:
+            nx.write_gml(g, f)
+        result = f.read().decode()
+
+        assert result == dedent(
+            """\
+            graph [
+              node [
+                id 0
+                label "n1"
+                properties "element"
+                properties 0
+                properties 1
+                properties 2.5
+                properties 1
+                properties 0
+              ]
+            ]
+        """
+        )
+
+    def test_writing_graph_with_one_element_property_list(self):
+        g = nx.Graph()
+        g.add_node("n1", properties=["element"])
+        with byte_file() as f:
+            nx.write_gml(g, f)
+        result = f.read().decode()
+
+        assert result == dedent(
+            """\
+            graph [
+              node [
+                id 0
+                label "n1"
+                properties "_networkx_list_start"
+                properties "element"
+              ]
+            ]
+        """
+        )
+
+    def test_reading_graph_with_list_property(self):
+        with byte_file() as f:
+            f.write(
+                dedent(
+                    """
+              graph [
+                node [
+                  id 0
+                  label "n1"
+                  properties "element"
+                  properties 0
+                  properties 1
+                  properties 2.5
+                ]
+              ]
+            """
+                ).encode("ascii")
+            )
+            f.seek(0)
+            graph = nx.read_gml(f)
+        assert graph.nodes(data=True)["n1"] == {"properties": ["element", 0, 1, 2.5]}
+
+    def test_reading_graph_with_single_element_list_property(self):
+        with byte_file() as f:
+            f.write(
+                dedent(
+                    """
+              graph [
+                node [
+                  id 0
+                  label "n1"
+                  properties "_networkx_list_start"
+                  properties "element"
+                ]
+              ]
+            """
+                ).encode("ascii")
+            )
+            f.seek(0)
+            graph = nx.read_gml(f)
+        assert graph.nodes(data=True)["n1"] == {"properties": ["element"]}
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_gpickle.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_gpickle.py
new file mode 100644
index 0000000..3ef83b5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_gpickle.py
@@ -0,0 +1,75 @@
+import os
+import tempfile
+
+import networkx as nx
+from networkx.utils import edges_equal, graphs_equal, nodes_equal
+
+
+class TestGpickle:
+    @classmethod
+    def setup_class(cls):
+        G = nx.Graph(name="test")
+        e = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("a", "f")]
+        G.add_edges_from(e, width=10)
+        G.add_node("g", color="green")
+        G.graph["number"] = 1
+        DG = nx.DiGraph(G)
+        MG = nx.MultiGraph(G)
+        MG.add_edge("a", "a")
+        MDG = nx.MultiDiGraph(G)
+        MDG.add_edge("a", "a")
+        fG = G.copy()
+        fDG = DG.copy()
+        fMG = MG.copy()
+        fMDG = MDG.copy()
+        nx.freeze(fG)
+        nx.freeze(fDG)
+        nx.freeze(fMG)
+        nx.freeze(fMDG)
+        cls.G = G
+        cls.DG = DG
+        cls.MG = MG
+        cls.MDG = MDG
+        cls.fG = fG
+        cls.fDG = fDG
+        cls.fMG = fMG
+        cls.fMDG = fMDG
+
+    def test_gpickle(self):
+        for G in [
+            self.G,
+            self.DG,
+            self.MG,
+            self.MDG,
+            self.fG,
+            self.fDG,
+            self.fMG,
+            self.fMDG,
+        ]:
+            (fd, fname) = tempfile.mkstemp()
+            nx.write_gpickle(G, fname)
+            Gin = nx.read_gpickle(fname)
+            assert nodes_equal(list(G.nodes(data=True)), list(Gin.nodes(data=True)))
+            assert edges_equal(list(G.edges(data=True)), list(Gin.edges(data=True)))
+            assert graphs_equal(G, Gin)
+            os.close(fd)
+            os.unlink(fname)
+
+    def test_protocol(self):
+        for G in [
+            self.G,
+            self.DG,
+            self.MG,
+            self.MDG,
+            self.fG,
+            self.fDG,
+            self.fMG,
+            self.fMDG,
+        ]:
+            with tempfile.TemporaryFile() as f:
+                nx.write_gpickle(G, f, 0)
+                f.seek(0)
+                Gin = nx.read_gpickle(f)
+                assert nodes_equal(list(G.nodes(data=True)), list(Gin.nodes(data=True)))
+                assert edges_equal(list(G.edges(data=True)), list(Gin.edges(data=True)))
+                assert graphs_equal(G, Gin)
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_graph6.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_graph6.py
new file mode 100644
index 0000000..062a96f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_graph6.py
@@ -0,0 +1,169 @@
+import tempfile
+from io import BytesIO
+
+import pytest
+
+import networkx as nx
+import networkx.readwrite.graph6 as g6
+from networkx.utils import edges_equal, nodes_equal
+
+
+class TestGraph6Utils:
+    def test_n_data_n_conversion(self):
+        for i in [0, 1, 42, 62, 63, 64, 258047, 258048, 7744773, 68719476735]:
+            assert g6.data_to_n(g6.n_to_data(i))[0] == i
+            assert g6.data_to_n(g6.n_to_data(i))[1] == []
+            assert g6.data_to_n(g6.n_to_data(i) + [42, 43])[1] == [42, 43]
+
+
+class TestFromGraph6Bytes:
+    def test_from_graph6_bytes(self):
+        data = b"DF{"
+        G = nx.from_graph6_bytes(data)
+        assert nodes_equal(G.nodes(), [0, 1, 2, 3, 4])
+        assert edges_equal(
+            G.edges(), [(0, 3), (0, 4), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        )
+
+    def test_read_equals_from_bytes(self):
+        data = b"DF{"
+        G = nx.from_graph6_bytes(data)
+        fh = BytesIO(data)
+        Gin = nx.read_graph6(fh)
+        assert nodes_equal(G.nodes(), Gin.nodes())
+        assert edges_equal(G.edges(), Gin.edges())
+
+
+class TestReadGraph6:
+    def test_read_many_graph6(self):
+        """Test for reading many graphs from a file into a list."""
+        data = b"DF{\nD`{\nDqK\nD~{\n"
+        fh = BytesIO(data)
+        glist = nx.read_graph6(fh)
+        assert len(glist) == 4
+        for G in glist:
+            assert sorted(G) == list(range(5))
+
+
+class TestWriteGraph6:
+    """Unit tests for writing a graph to a file in graph6 format."""
+
+    def test_null_graph(self):
+        result = BytesIO()
+        nx.write_graph6(nx.null_graph(), result)
+        assert result.getvalue() == b">>graph6<<?\n"
+
+    def test_trivial_graph(self):
+        result = BytesIO()
+        nx.write_graph6(nx.trivial_graph(), result)
+        assert result.getvalue() == b">>graph6<<@\n"
+
+    def test_complete_graph(self):
+        result = BytesIO()
+        nx.write_graph6(nx.complete_graph(4), result)
+        assert result.getvalue() == b">>graph6<<C~\n"
+
+    def test_large_complete_graph(self):
+        result = BytesIO()
+        nx.write_graph6(nx.complete_graph(67), result, header=False)
+        assert result.getvalue() == b"~?@B" + b"~" * 368 + b"w\n"
+
+    def test_no_header(self):
+        result = BytesIO()
+        nx.write_graph6(nx.complete_graph(4), result, header=False)
+        assert result.getvalue() == b"C~\n"
+
+    def test_complete_bipartite_graph(self):
+        result = BytesIO()
+        G = nx.complete_bipartite_graph(6, 9)
+        nx.write_graph6(G, result, header=False)
+        # The expected encoding here was verified by Sage.
+        assert result.getvalue() == b"N??F~z{~Fw^_~?~?^_?\n"
+
+    @pytest.mark.parametrize("G", (nx.MultiGraph(), nx.DiGraph()))
+    def test_no_directed_or_multi_graphs(self, G):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            nx.write_graph6(G, BytesIO())
+
+    def test_length(self):
+        for i in list(range(13)) + [31, 47, 62, 63, 64, 72]:
+            g = nx.random_graphs.gnm_random_graph(i, i * i // 4, seed=i)
+            gstr = BytesIO()
+            nx.write_graph6(g, gstr, header=False)
+            # Strip the trailing newline.
+            gstr = gstr.getvalue().rstrip()
+            assert len(gstr) == ((i - 1) * i // 2 + 5) // 6 + (1 if i < 63 else 4)
+
+    def test_roundtrip(self):
+        for i in list(range(13)) + [31, 47, 62, 63, 64, 72]:
+            G = nx.random_graphs.gnm_random_graph(i, i * i // 4, seed=i)
+            f = BytesIO()
+            nx.write_graph6(G, f)
+            f.seek(0)
+            H = nx.read_graph6(f)
+            assert nodes_equal(G.nodes(), H.nodes())
+            assert edges_equal(G.edges(), H.edges())
+
+    def test_write_path(self):
+        with tempfile.NamedTemporaryFile() as f:
+            g6.write_graph6_file(nx.null_graph(), f)
+            f.seek(0)
+            assert f.read() == b">>graph6<<?\n"
+
+    @pytest.mark.parametrize("edge", ((0, 1), (1, 2), (1, 42)))
+    def test_relabeling(self, edge):
+        G = nx.Graph([edge])
+        f = BytesIO()
+        nx.write_graph6(G, f)
+        f.seek(0)
+        assert f.read() == b">>graph6<<A_\n"
+
+
+class TestToGraph6Bytes:
+    def test_null_graph(self):
+        G = nx.null_graph()
+        assert g6.to_graph6_bytes(G) == b">>graph6<<?\n"
+
+    def test_trivial_graph(self):
+        G = nx.trivial_graph()
+        assert g6.to_graph6_bytes(G) == b">>graph6<<@\n"
+
+    def test_complete_graph(self):
+        assert g6.to_graph6_bytes(nx.complete_graph(4)) == b">>graph6<<C~\n"
+
+    def test_large_complete_graph(self):
+        G = nx.complete_graph(67)
+        assert g6.to_graph6_bytes(G, header=False) == b"~?@B" + b"~" * 368 + b"w\n"
+
+    def test_no_header(self):
+        G = nx.complete_graph(4)
+        assert g6.to_graph6_bytes(G, header=False) == b"C~\n"
+
+    def test_complete_bipartite_graph(self):
+        G = nx.complete_bipartite_graph(6, 9)
+        assert g6.to_graph6_bytes(G, header=False) == b"N??F~z{~Fw^_~?~?^_?\n"
+
+    @pytest.mark.parametrize("G", (nx.MultiGraph(), nx.DiGraph()))
+    def test_no_directed_or_multi_graphs(self, G):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            g6.to_graph6_bytes(G)
+
+    def test_length(self):
+        for i in list(range(13)) + [31, 47, 62, 63, 64, 72]:
+            G = nx.random_graphs.gnm_random_graph(i, i * i // 4, seed=i)
+            # Strip the trailing newline.
+            gstr = g6.to_graph6_bytes(G, header=False).rstrip()
+            assert len(gstr) == ((i - 1) * i // 2 + 5) // 6 + (1 if i < 63 else 4)
+
+    def test_roundtrip(self):
+        for i in list(range(13)) + [31, 47, 62, 63, 64, 72]:
+            G = nx.random_graphs.gnm_random_graph(i, i * i // 4, seed=i)
+            data = g6.to_graph6_bytes(G)
+            H = nx.from_graph6_bytes(data.rstrip())
+            assert nodes_equal(G.nodes(), H.nodes())
+            assert edges_equal(G.edges(), H.edges())
+
+    @pytest.mark.parametrize("edge", ((0, 1), (1, 2), (1, 42)))
+    def test_relabeling(self, edge):
+        G = nx.Graph([edge])
+        assert g6.to_graph6_bytes(G) == b">>graph6<<A_\n"
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_graphml.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_graphml.py
new file mode 100644
index 0000000..cc37132
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_graphml.py
@@ -0,0 +1,1540 @@
+import io
+import os
+import tempfile
+
+import pytest
+
+import networkx as nx
+from networkx.readwrite.graphml import GraphMLWriter
+from networkx.utils import edges_equal, nodes_equal
+
+
+class BaseGraphML:
+    @classmethod
+    def setup_class(cls):
+        cls.simple_directed_data = """<?xml version="1.0" encoding="UTF-8"?>
+<!-- This file was written by the JAVA GraphML Library.-->
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <graph id="G" edgedefault="directed">
+    <node id="n0"/>
+    <node id="n1"/>
+    <node id="n2"/>
+    <node id="n3"/>
+    <node id="n4"/>
+    <node id="n5"/>
+    <node id="n6"/>
+    <node id="n7"/>
+    <node id="n8"/>
+    <node id="n9"/>
+    <node id="n10"/>
+    <edge id="foo" source="n0" target="n2"/>
+    <edge source="n1" target="n2"/>
+    <edge source="n2" target="n3"/>
+    <edge source="n3" target="n5"/>
+    <edge source="n3" target="n4"/>
+    <edge source="n4" target="n6"/>
+    <edge source="n6" target="n5"/>
+    <edge source="n5" target="n7"/>
+    <edge source="n6" target="n8"/>
+    <edge source="n8" target="n7"/>
+    <edge source="n8" target="n9"/>
+  </graph>
+</graphml>"""
+        cls.simple_directed_graph = nx.DiGraph()
+        cls.simple_directed_graph.add_node("n10")
+        cls.simple_directed_graph.add_edge("n0", "n2", id="foo")
+        cls.simple_directed_graph.add_edge("n0", "n2")
+        cls.simple_directed_graph.add_edges_from(
+            [
+                ("n1", "n2"),
+                ("n2", "n3"),
+                ("n3", "n5"),
+                ("n3", "n4"),
+                ("n4", "n6"),
+                ("n6", "n5"),
+                ("n5", "n7"),
+                ("n6", "n8"),
+                ("n8", "n7"),
+                ("n8", "n9"),
+            ]
+        )
+        cls.simple_directed_fh = io.BytesIO(cls.simple_directed_data.encode("UTF-8"))
+
+        cls.attribute_data = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+        http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <key id="d0" for="node" attr.name="color" attr.type="string">
+    <default>yellow</default>
+  </key>
+  <key id="d1" for="edge" attr.name="weight" attr.type="double"/>
+  <graph id="G" edgedefault="directed">
+    <node id="n0">
+      <data key="d0">green</data>
+    </node>
+    <node id="n1"/>
+    <node id="n2">
+      <data key="d0">blue</data>
+    </node>
+    <node id="n3">
+      <data key="d0">red</data>
+    </node>
+    <node id="n4"/>
+    <node id="n5">
+      <data key="d0">turquoise</data>
+    </node>
+    <edge id="e0" source="n0" target="n2">
+      <data key="d1">1.0</data>
+    </edge>
+    <edge id="e1" source="n0" target="n1">
+      <data key="d1">1.0</data>
+    </edge>
+    <edge id="e2" source="n1" target="n3">
+      <data key="d1">2.0</data>
+    </edge>
+    <edge id="e3" source="n3" target="n2"/>
+    <edge id="e4" source="n2" target="n4"/>
+    <edge id="e5" source="n3" target="n5"/>
+    <edge id="e6" source="n5" target="n4">
+      <data key="d1">1.1</data>
+    </edge>
+  </graph>
+</graphml>
+"""
+        cls.attribute_graph = nx.DiGraph(id="G")
+        cls.attribute_graph.graph["node_default"] = {"color": "yellow"}
+        cls.attribute_graph.add_node("n0", color="green")
+        cls.attribute_graph.add_node("n2", color="blue")
+        cls.attribute_graph.add_node("n3", color="red")
+        cls.attribute_graph.add_node("n4")
+        cls.attribute_graph.add_node("n5", color="turquoise")
+        cls.attribute_graph.add_edge("n0", "n2", id="e0", weight=1.0)
+        cls.attribute_graph.add_edge("n0", "n1", id="e1", weight=1.0)
+        cls.attribute_graph.add_edge("n1", "n3", id="e2", weight=2.0)
+        cls.attribute_graph.add_edge("n3", "n2", id="e3")
+        cls.attribute_graph.add_edge("n2", "n4", id="e4")
+        cls.attribute_graph.add_edge("n3", "n5", id="e5")
+        cls.attribute_graph.add_edge("n5", "n4", id="e6", weight=1.1)
+        cls.attribute_fh = io.BytesIO(cls.attribute_data.encode("UTF-8"))
+
+        cls.node_attribute_default_data = """<?xml version="1.0" encoding="UTF-8"?>
+        <graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+              xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+                http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+          <key id="d0" for="node" attr.name="boolean_attribute" attr.type="boolean"><default>false</default></key>
+          <key id="d1" for="node" attr.name="int_attribute" attr.type="int"><default>0</default></key>
+          <key id="d2" for="node" attr.name="long_attribute" attr.type="long"><default>0</default></key>
+          <key id="d3" for="node" attr.name="float_attribute" attr.type="float"><default>0.0</default></key>
+          <key id="d4" for="node" attr.name="double_attribute" attr.type="double"><default>0.0</default></key>
+          <key id="d5" for="node" attr.name="string_attribute" attr.type="string"><default>Foo</default></key>
+          <graph id="G" edgedefault="directed">
+            <node id="n0"/>
+            <node id="n1"/>
+            <edge id="e0" source="n0" target="n1"/>
+          </graph>
+        </graphml>
+        """
+        cls.node_attribute_default_graph = nx.DiGraph(id="G")
+        cls.node_attribute_default_graph.graph["node_default"] = {
+            "boolean_attribute": False,
+            "int_attribute": 0,
+            "long_attribute": 0,
+            "float_attribute": 0.0,
+            "double_attribute": 0.0,
+            "string_attribute": "Foo",
+        }
+        cls.node_attribute_default_graph.add_node("n0")
+        cls.node_attribute_default_graph.add_node("n1")
+        cls.node_attribute_default_graph.add_edge("n0", "n1", id="e0")
+        cls.node_attribute_default_fh = io.BytesIO(
+            cls.node_attribute_default_data.encode("UTF-8")
+        )
+
+        cls.attribute_named_key_ids_data = """<?xml version='1.0' encoding='utf-8'?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <key id="edge_prop" for="edge" attr.name="edge_prop" attr.type="string"/>
+  <key id="prop2" for="node" attr.name="prop2" attr.type="string"/>
+  <key id="prop1" for="node" attr.name="prop1" attr.type="string"/>
+  <graph edgedefault="directed">
+    <node id="0">
+      <data key="prop1">val1</data>
+      <data key="prop2">val2</data>
+    </node>
+    <node id="1">
+      <data key="prop1">val_one</data>
+      <data key="prop2">val2</data>
+    </node>
+    <edge source="0" target="1">
+      <data key="edge_prop">edge_value</data>
+    </edge>
+  </graph>
+</graphml>
+"""
+        cls.attribute_named_key_ids_graph = nx.DiGraph()
+        cls.attribute_named_key_ids_graph.add_node("0", prop1="val1", prop2="val2")
+        cls.attribute_named_key_ids_graph.add_node("1", prop1="val_one", prop2="val2")
+        cls.attribute_named_key_ids_graph.add_edge("0", "1", edge_prop="edge_value")
+        fh = io.BytesIO(cls.attribute_named_key_ids_data.encode("UTF-8"))
+        cls.attribute_named_key_ids_fh = fh
+
+        cls.attribute_numeric_type_data = """<?xml version='1.0' encoding='utf-8'?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <key attr.name="weight" attr.type="double" for="node" id="d1" />
+  <key attr.name="weight" attr.type="double" for="edge" id="d0" />
+  <graph edgedefault="directed">
+    <node id="n0">
+      <data key="d1">1</data>
+    </node>
+    <node id="n1">
+      <data key="d1">2.0</data>
+    </node>
+    <edge source="n0" target="n1">
+      <data key="d0">1</data>
+    </edge>
+    <edge source="n1" target="n0">
+      <data key="d0">k</data>
+    </edge>
+    <edge source="n1" target="n1">
+      <data key="d0">1.0</data>
+    </edge>
+  </graph>
+</graphml>
+"""
+        cls.attribute_numeric_type_graph = nx.DiGraph()
+        cls.attribute_numeric_type_graph.add_node("n0", weight=1)
+        cls.attribute_numeric_type_graph.add_node("n1", weight=2.0)
+        cls.attribute_numeric_type_graph.add_edge("n0", "n1", weight=1)
+        cls.attribute_numeric_type_graph.add_edge("n1", "n1", weight=1.0)
+        fh = io.BytesIO(cls.attribute_numeric_type_data.encode("UTF-8"))
+        cls.attribute_numeric_type_fh = fh
+
+        cls.simple_undirected_data = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <graph id="G">
+    <node id="n0"/>
+    <node id="n1"/>
+    <node id="n2"/>
+    <node id="n10"/>
+    <edge id="foo" source="n0" target="n2"/>
+    <edge source="n1" target="n2"/>
+    <edge source="n2" target="n3"/>
+  </graph>
+</graphml>"""
+        #    <edge source="n8" target="n10" directed="false"/>
+        cls.simple_undirected_graph = nx.Graph()
+        cls.simple_undirected_graph.add_node("n10")
+        cls.simple_undirected_graph.add_edge("n0", "n2", id="foo")
+        cls.simple_undirected_graph.add_edges_from([("n1", "n2"), ("n2", "n3")])
+        fh = io.BytesIO(cls.simple_undirected_data.encode("UTF-8"))
+        cls.simple_undirected_fh = fh
+
+        cls.undirected_multigraph_data = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <graph id="G">
+    <node id="n0"/>
+    <node id="n1"/>
+    <node id="n2"/>
+    <node id="n10"/>
+    <edge id="e0" source="n0" target="n2"/>
+    <edge id="e1" source="n1" target="n2"/>
+    <edge id="e2" source="n2" target="n1"/>
+  </graph>
+</graphml>"""
+        cls.undirected_multigraph = nx.MultiGraph()
+        cls.undirected_multigraph.add_node("n10")
+        cls.undirected_multigraph.add_edge("n0", "n2", id="e0")
+        cls.undirected_multigraph.add_edge("n1", "n2", id="e1")
+        cls.undirected_multigraph.add_edge("n2", "n1", id="e2")
+        fh = io.BytesIO(cls.undirected_multigraph_data.encode("UTF-8"))
+        cls.undirected_multigraph_fh = fh
+
+        cls.undirected_multigraph_no_multiedge_data = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <graph id="G">
+    <node id="n0"/>
+    <node id="n1"/>
+    <node id="n2"/>
+    <node id="n10"/>
+    <edge id="e0" source="n0" target="n2"/>
+    <edge id="e1" source="n1" target="n2"/>
+    <edge id="e2" source="n2" target="n3"/>
+  </graph>
+</graphml>"""
+        cls.undirected_multigraph_no_multiedge = nx.MultiGraph()
+        cls.undirected_multigraph_no_multiedge.add_node("n10")
+        cls.undirected_multigraph_no_multiedge.add_edge("n0", "n2", id="e0")
+        cls.undirected_multigraph_no_multiedge.add_edge("n1", "n2", id="e1")
+        cls.undirected_multigraph_no_multiedge.add_edge("n2", "n3", id="e2")
+        fh = io.BytesIO(cls.undirected_multigraph_no_multiedge_data.encode("UTF-8"))
+        cls.undirected_multigraph_no_multiedge_fh = fh
+
+        cls.multigraph_only_ids_for_multiedges_data = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <graph id="G">
+    <node id="n0"/>
+    <node id="n1"/>
+    <node id="n2"/>
+    <node id="n10"/>
+    <edge source="n0" target="n2"/>
+    <edge id="e1" source="n1" target="n2"/>
+    <edge id="e2" source="n2" target="n1"/>
+  </graph>
+</graphml>"""
+        cls.multigraph_only_ids_for_multiedges = nx.MultiGraph()
+        cls.multigraph_only_ids_for_multiedges.add_node("n10")
+        cls.multigraph_only_ids_for_multiedges.add_edge("n0", "n2")
+        cls.multigraph_only_ids_for_multiedges.add_edge("n1", "n2", id="e1")
+        cls.multigraph_only_ids_for_multiedges.add_edge("n2", "n1", id="e2")
+        fh = io.BytesIO(cls.multigraph_only_ids_for_multiedges_data.encode("UTF-8"))
+        cls.multigraph_only_ids_for_multiedges_fh = fh
+
+
+class TestReadGraphML(BaseGraphML):
+    def test_read_simple_directed_graphml(self):
+        G = self.simple_directed_graph
+        H = nx.read_graphml(self.simple_directed_fh)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(G.edges()) == sorted(H.edges())
+        assert sorted(G.edges(data=True)) == sorted(H.edges(data=True))
+        self.simple_directed_fh.seek(0)
+
+        PG = nx.parse_graphml(self.simple_directed_data)
+        assert sorted(G.nodes()) == sorted(PG.nodes())
+        assert sorted(G.edges()) == sorted(PG.edges())
+        assert sorted(G.edges(data=True)) == sorted(PG.edges(data=True))
+
+    def test_read_simple_undirected_graphml(self):
+        G = self.simple_undirected_graph
+        H = nx.read_graphml(self.simple_undirected_fh)
+        assert nodes_equal(G.nodes(), H.nodes())
+        assert edges_equal(G.edges(), H.edges())
+        self.simple_undirected_fh.seek(0)
+
+        PG = nx.parse_graphml(self.simple_undirected_data)
+        assert nodes_equal(G.nodes(), PG.nodes())
+        assert edges_equal(G.edges(), PG.edges())
+
+    def test_read_undirected_multigraph_graphml(self):
+        G = self.undirected_multigraph
+        H = nx.read_graphml(self.undirected_multigraph_fh)
+        assert nodes_equal(G.nodes(), H.nodes())
+        assert edges_equal(G.edges(), H.edges())
+        self.undirected_multigraph_fh.seek(0)
+
+        PG = nx.parse_graphml(self.undirected_multigraph_data)
+        assert nodes_equal(G.nodes(), PG.nodes())
+        assert edges_equal(G.edges(), PG.edges())
+
+    def test_read_undirected_multigraph_no_multiedge_graphml(self):
+        G = self.undirected_multigraph_no_multiedge
+        H = nx.read_graphml(self.undirected_multigraph_no_multiedge_fh)
+        assert nodes_equal(G.nodes(), H.nodes())
+        assert edges_equal(G.edges(), H.edges())
+        self.undirected_multigraph_no_multiedge_fh.seek(0)
+
+        PG = nx.parse_graphml(self.undirected_multigraph_no_multiedge_data)
+        assert nodes_equal(G.nodes(), PG.nodes())
+        assert edges_equal(G.edges(), PG.edges())
+
+    def test_read_undirected_multigraph_only_ids_for_multiedges_graphml(self):
+        G = self.multigraph_only_ids_for_multiedges
+        H = nx.read_graphml(self.multigraph_only_ids_for_multiedges_fh)
+        assert nodes_equal(G.nodes(), H.nodes())
+        assert edges_equal(G.edges(), H.edges())
+        self.multigraph_only_ids_for_multiedges_fh.seek(0)
+
+        PG = nx.parse_graphml(self.multigraph_only_ids_for_multiedges_data)
+        assert nodes_equal(G.nodes(), PG.nodes())
+        assert edges_equal(G.edges(), PG.edges())
+
+    def test_read_attribute_graphml(self):
+        G = self.attribute_graph
+        H = nx.read_graphml(self.attribute_fh)
+        assert nodes_equal(G.nodes(True), sorted(H.nodes(data=True)))
+        ge = sorted(G.edges(data=True))
+        he = sorted(H.edges(data=True))
+        for a, b in zip(ge, he):
+            assert a == b
+        self.attribute_fh.seek(0)
+
+        PG = nx.parse_graphml(self.attribute_data)
+        assert sorted(G.nodes(True)) == sorted(PG.nodes(data=True))
+        ge = sorted(G.edges(data=True))
+        he = sorted(PG.edges(data=True))
+        for a, b in zip(ge, he):
+            assert a == b
+
+    def test_node_default_attribute_graphml(self):
+        G = self.node_attribute_default_graph
+        H = nx.read_graphml(self.node_attribute_default_fh)
+        assert G.graph["node_default"] == H.graph["node_default"]
+
+    def test_directed_edge_in_undirected(self):
+        s = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <graph id="G">
+    <node id="n0"/>
+    <node id="n1"/>
+    <node id="n2"/>
+    <edge source="n0" target="n1"/>
+    <edge source="n1" target="n2" directed='true'/>
+  </graph>
+</graphml>"""
+        fh = io.BytesIO(s.encode("UTF-8"))
+        pytest.raises(nx.NetworkXError, nx.read_graphml, fh)
+        pytest.raises(nx.NetworkXError, nx.parse_graphml, s)
+
+    def test_undirected_edge_in_directed(self):
+        s = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <graph id="G" edgedefault='directed'>
+    <node id="n0"/>
+    <node id="n1"/>
+    <node id="n2"/>
+    <edge source="n0" target="n1"/>
+    <edge source="n1" target="n2" directed='false'/>
+  </graph>
+</graphml>"""
+        fh = io.BytesIO(s.encode("UTF-8"))
+        pytest.raises(nx.NetworkXError, nx.read_graphml, fh)
+        pytest.raises(nx.NetworkXError, nx.parse_graphml, s)
+
+    def test_key_raise(self):
+        s = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <key id="d0" for="node" attr.name="color" attr.type="string">
+    <default>yellow</default>
+  </key>
+  <key id="d1" for="edge" attr.name="weight" attr.type="double"/>
+  <graph id="G" edgedefault="directed">
+    <node id="n0">
+      <data key="d0">green</data>
+    </node>
+    <node id="n1"/>
+    <node id="n2">
+      <data key="d0">blue</data>
+    </node>
+    <edge id="e0" source="n0" target="n2">
+      <data key="d2">1.0</data>
+    </edge>
+  </graph>
+</graphml>
+"""
+        fh = io.BytesIO(s.encode("UTF-8"))
+        pytest.raises(nx.NetworkXError, nx.read_graphml, fh)
+        pytest.raises(nx.NetworkXError, nx.parse_graphml, s)
+
+    def test_hyperedge_raise(self):
+        s = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <key id="d0" for="node" attr.name="color" attr.type="string">
+    <default>yellow</default>
+  </key>
+  <key id="d1" for="edge" attr.name="weight" attr.type="double"/>
+  <graph id="G" edgedefault="directed">
+    <node id="n0">
+      <data key="d0">green</data>
+    </node>
+    <node id="n1"/>
+    <node id="n2">
+      <data key="d0">blue</data>
+    </node>
+    <hyperedge id="e0" source="n0" target="n2">
+       <endpoint node="n0"/>
+       <endpoint node="n1"/>
+       <endpoint node="n2"/>
+    </hyperedge>
+  </graph>
+</graphml>
+"""
+        fh = io.BytesIO(s.encode("UTF-8"))
+        pytest.raises(nx.NetworkXError, nx.read_graphml, fh)
+        pytest.raises(nx.NetworkXError, nx.parse_graphml, s)
+
+    def test_multigraph_keys(self):
+        # Test that reading multigraphs uses edge id attributes as keys
+        s = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <graph id="G" edgedefault="directed">
+    <node id="n0"/>
+    <node id="n1"/>
+    <edge id="e0" source="n0" target="n1"/>
+    <edge id="e1" source="n0" target="n1"/>
+  </graph>
+</graphml>
+"""
+        fh = io.BytesIO(s.encode("UTF-8"))
+        G = nx.read_graphml(fh)
+        expected = [("n0", "n1", "e0"), ("n0", "n1", "e1")]
+        assert sorted(G.edges(keys=True)) == expected
+        fh.seek(0)
+        H = nx.parse_graphml(s)
+        assert sorted(H.edges(keys=True)) == expected
+
+    def test_preserve_multi_edge_data(self):
+        """
+        Test that data and keys of edges are preserved on consequent
+        write and reads
+        """
+        G = nx.MultiGraph()
+        G.add_node(1)
+        G.add_node(2)
+        G.add_edges_from(
+            [
+                # edges with no data, no keys:
+                (1, 2),
+                # edges with only data:
+                (1, 2, dict(key="data_key1")),
+                (1, 2, dict(id="data_id2")),
+                (1, 2, dict(key="data_key3", id="data_id3")),
+                # edges with both data and keys:
+                (1, 2, 103, dict(key="data_key4")),
+                (1, 2, 104, dict(id="data_id5")),
+                (1, 2, 105, dict(key="data_key6", id="data_id7")),
+            ]
+        )
+        fh = io.BytesIO()
+        nx.write_graphml(G, fh)
+        fh.seek(0)
+        H = nx.read_graphml(fh, node_type=int)
+        assert edges_equal(G.edges(data=True, keys=True), H.edges(data=True, keys=True))
+        assert G._adj == H._adj
+
+        Gadj = {
+            str(node): {
+                str(nbr): {str(ekey): dd for ekey, dd in key_dict.items()}
+                for nbr, key_dict in nbr_dict.items()
+            }
+            for node, nbr_dict in G._adj.items()
+        }
+        fh.seek(0)
+        HH = nx.read_graphml(fh, node_type=str, edge_key_type=str)
+        assert Gadj == HH._adj
+
+        fh.seek(0)
+        string_fh = fh.read()
+        HH = nx.parse_graphml(string_fh, node_type=str, edge_key_type=str)
+        assert Gadj == HH._adj
+
+    def test_yfiles_extension(self):
+        data = """<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns:y="http://www.yworks.com/xml/graphml"
+         xmlns:yed="http://www.yworks.com/xml/yed/3"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <!--Created by yFiles for Java 2.7-->
+  <key for="graphml" id="d0" yfiles.type="resources"/>
+  <key attr.name="url" attr.type="string" for="node" id="d1"/>
+  <key attr.name="description" attr.type="string" for="node" id="d2"/>
+  <key for="node" id="d3" yfiles.type="nodegraphics"/>
+  <key attr.name="Description" attr.type="string" for="graph" id="d4">
+    <default/>
+  </key>
+  <key attr.name="url" attr.type="string" for="edge" id="d5"/>
+  <key attr.name="description" attr.type="string" for="edge" id="d6"/>
+  <key for="edge" id="d7" yfiles.type="edgegraphics"/>
+  <graph edgedefault="directed" id="G">
+    <node id="n0">
+      <data key="d3">
+        <y:ShapeNode>
+          <y:Geometry height="30.0" width="30.0" x="125.0" y="100.0"/>
+          <y:Fill color="#FFCC00" transparent="false"/>
+          <y:BorderStyle color="#000000" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content"
+           borderDistance="0.0" fontFamily="Dialog" fontSize="13"
+           fontStyle="plain" hasBackgroundColor="false" hasLineColor="false"
+           height="19.1328125" modelName="internal" modelPosition="c"
+           textColor="#000000" visible="true" width="12.27099609375"
+           x="8.864501953125" y="5.43359375">1</y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n1">
+      <data key="d3">
+        <y:ShapeNode>
+          <y:Geometry height="30.0" width="30.0" x="183.0" y="205.0"/>
+          <y:Fill color="#FFCC00" transparent="false"/>
+          <y:BorderStyle color="#000000" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content"
+          borderDistance="0.0" fontFamily="Dialog" fontSize="13"
+          fontStyle="plain" hasBackgroundColor="false" hasLineColor="false"
+          height="19.1328125" modelName="internal" modelPosition="c"
+          textColor="#000000" visible="true" width="12.27099609375"
+          x="8.864501953125" y="5.43359375">2</y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n2">
+      <data key="d6" xml:space="preserve"><![CDATA[description
+line1
+line2]]></data>
+      <data key="d3">
+        <y:GenericNode configuration="com.yworks.flowchart.terminator">
+          <y:Geometry height="40.0" width="80.0" x="950.0" y="286.0"/>
+          <y:Fill color="#E8EEF7" color2="#B7C9E3" transparent="false"/>
+          <y:BorderStyle color="#000000" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content"
+          fontFamily="Dialog" fontSize="12" fontStyle="plain"
+          hasBackgroundColor="false" hasLineColor="false" height="17.96875"
+          horizontalTextPosition="center" iconTextGap="4" modelName="custom"
+          textColor="#000000" verticalTextPosition="bottom" visible="true"
+          width="67.984375" x="6.0078125" xml:space="preserve"
+          y="11.015625">3<y:LabelModel>
+          <y:SmartNodeLabelModel distance="4.0"/></y:LabelModel>
+          <y:ModelParameter><y:SmartNodeLabelModelParameter labelRatioX="0.0"
+          labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0"
+          offsetY="0.0" upX="0.0" upY="-1.0"/></y:ModelParameter></y:NodeLabel>
+        </y:GenericNode>
+      </data>
+    </node>
+    <edge id="e0" source="n0" target="n1">
+      <data key="d7">
+        <y:PolyLineEdge>
+          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0"/>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+  </graph>
+  <data key="d0">
+    <y:Resources/>
+  </data>
+</graphml>
+"""
+        fh = io.BytesIO(data.encode("UTF-8"))
+        G = nx.read_graphml(fh, force_multigraph=True)
+        assert list(G.edges()) == [("n0", "n1")]
+        assert G.has_edge("n0", "n1", key="e0")
+        assert G.nodes["n0"]["label"] == "1"
+        assert G.nodes["n1"]["label"] == "2"
+        assert G.nodes["n2"]["label"] == "3"
+        assert G.nodes["n0"]["shape_type"] == "rectangle"
+        assert G.nodes["n1"]["shape_type"] == "rectangle"
+        assert G.nodes["n2"]["shape_type"] == "com.yworks.flowchart.terminator"
+        assert G.nodes["n2"]["description"] == "description\nline1\nline2"
+        fh.seek(0)
+        G = nx.read_graphml(fh)
+        assert list(G.edges()) == [("n0", "n1")]
+        assert G["n0"]["n1"]["id"] == "e0"
+        assert G.nodes["n0"]["label"] == "1"
+        assert G.nodes["n1"]["label"] == "2"
+        assert G.nodes["n2"]["label"] == "3"
+        assert G.nodes["n0"]["shape_type"] == "rectangle"
+        assert G.nodes["n1"]["shape_type"] == "rectangle"
+        assert G.nodes["n2"]["shape_type"] == "com.yworks.flowchart.terminator"
+        assert G.nodes["n2"]["description"] == "description\nline1\nline2"
+
+        H = nx.parse_graphml(data, force_multigraph=True)
+        assert list(H.edges()) == [("n0", "n1")]
+        assert H.has_edge("n0", "n1", key="e0")
+        assert H.nodes["n0"]["label"] == "1"
+        assert H.nodes["n1"]["label"] == "2"
+        assert H.nodes["n2"]["label"] == "3"
+
+        H = nx.parse_graphml(data)
+        assert list(H.edges()) == [("n0", "n1")]
+        assert H["n0"]["n1"]["id"] == "e0"
+        assert H.nodes["n0"]["label"] == "1"
+        assert H.nodes["n1"]["label"] == "2"
+        assert H.nodes["n2"]["label"] == "3"
+
+    def test_bool(self):
+        s = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <key id="d0" for="node" attr.name="test" attr.type="boolean">
+    <default>false</default>
+  </key>
+  <graph id="G" edgedefault="directed">
+    <node id="n0">
+      <data key="d0">true</data>
+    </node>
+    <node id="n1"/>
+    <node id="n2">
+      <data key="d0">false</data>
+    </node>
+    <node id="n3">
+      <data key="d0">FaLsE</data>
+    </node>
+    <node id="n4">
+      <data key="d0">True</data>
+    </node>
+    <node id="n5">
+      <data key="d0">0</data>
+    </node>
+    <node id="n6">
+      <data key="d0">1</data>
+    </node>
+  </graph>
+</graphml>
+"""
+        fh = io.BytesIO(s.encode("UTF-8"))
+        G = nx.read_graphml(fh)
+        H = nx.parse_graphml(s)
+        for graph in [G, H]:
+            assert graph.nodes["n0"]["test"]
+            assert not graph.nodes["n2"]["test"]
+            assert not graph.nodes["n3"]["test"]
+            assert graph.nodes["n4"]["test"]
+            assert not graph.nodes["n5"]["test"]
+            assert graph.nodes["n6"]["test"]
+
+    def test_graphml_header_line(self):
+        good = """<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <key id="d0" for="node" attr.name="test" attr.type="boolean">
+    <default>false</default>
+  </key>
+  <graph id="G">
+    <node id="n0">
+      <data key="d0">true</data>
+    </node>
+  </graph>
+</graphml>
+"""
+        bad = """<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<graphml>
+  <key id="d0" for="node" attr.name="test" attr.type="boolean">
+    <default>false</default>
+  </key>
+  <graph id="G">
+    <node id="n0">
+      <data key="d0">true</data>
+    </node>
+  </graph>
+</graphml>
+"""
+        ugly = """<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<graphml xmlns="https://ghghgh">
+  <key id="d0" for="node" attr.name="test" attr.type="boolean">
+    <default>false</default>
+  </key>
+  <graph id="G">
+    <node id="n0">
+      <data key="d0">true</data>
+    </node>
+  </graph>
+</graphml>
+"""
+        for s in (good, bad):
+            fh = io.BytesIO(s.encode("UTF-8"))
+            G = nx.read_graphml(fh)
+            H = nx.parse_graphml(s)
+            for graph in [G, H]:
+                assert graph.nodes["n0"]["test"]
+
+        fh = io.BytesIO(ugly.encode("UTF-8"))
+        pytest.raises(nx.NetworkXError, nx.read_graphml, fh)
+        pytest.raises(nx.NetworkXError, nx.parse_graphml, ugly)
+
+    def test_read_attributes_with_groups(self):
+        data = """\
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:java="http://www.yworks.com/xml/yfiles-common/1.0/java" xmlns:sys="http://www.yworks.com/xml/yfiles-common/markup/primitives/2.0" xmlns:x="http://www.yworks.com/xml/yfiles-common/markup/2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:y="http://www.yworks.com/xml/graphml" xmlns:yed="http://www.yworks.com/xml/yed/3" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://www.yworks.com/xml/schema/graphml/1.1/ygraphml.xsd">
+  <!--Created by yEd 3.17-->
+  <key attr.name="Description" attr.type="string" for="graph" id="d0"/>
+  <key for="port" id="d1" yfiles.type="portgraphics"/>
+  <key for="port" id="d2" yfiles.type="portgeometry"/>
+  <key for="port" id="d3" yfiles.type="portuserdata"/>
+  <key attr.name="CustomProperty" attr.type="string" for="node" id="d4">
+    <default/>
+  </key>
+  <key attr.name="url" attr.type="string" for="node" id="d5"/>
+  <key attr.name="description" attr.type="string" for="node" id="d6"/>
+  <key for="node" id="d7" yfiles.type="nodegraphics"/>
+  <key for="graphml" id="d8" yfiles.type="resources"/>
+  <key attr.name="url" attr.type="string" for="edge" id="d9"/>
+  <key attr.name="description" attr.type="string" for="edge" id="d10"/>
+  <key for="edge" id="d11" yfiles.type="edgegraphics"/>
+  <graph edgedefault="directed" id="G">
+    <data key="d0"/>
+    <node id="n0">
+      <data key="d4"><![CDATA[CustomPropertyValue]]></data>
+      <data key="d6"/>
+      <data key="d7">
+        <y:ShapeNode>
+          <y:Geometry height="30.0" width="30.0" x="125.0" y="-255.4611111111111"/>
+          <y:Fill color="#FFCC00" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="17.96875" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="11.634765625" x="9.1826171875" y="6.015625">2<y:LabelModel>
+              <y:SmartNodeLabelModel distance="4.0"/>
+            </y:LabelModel>
+            <y:ModelParameter>
+              <y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/>
+            </y:ModelParameter>
+          </y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n1" yfiles.foldertype="group">
+      <data key="d4"><![CDATA[CustomPropertyValue]]></data>
+      <data key="d5"/>
+      <data key="d6"/>
+      <data key="d7">
+        <y:ProxyAutoBoundsNode>
+          <y:Realizers active="0">
+            <y:GroupNode>
+              <y:Geometry height="250.38333333333333" width="140.0" x="-30.0" y="-330.3833333333333"/>
+              <y:Fill color="#F5F5F5" transparent="false"/>
+              <y:BorderStyle color="#000000" type="dashed" width="1.0"/>
+              <y:NodeLabel alignment="right" autoSizePolicy="node_width" backgroundColor="#EBEBEB" borderDistance="0.0" fontFamily="Dialog" fontSize="15" fontStyle="plain" hasLineColor="false" height="21.4609375" horizontalTextPosition="center" iconTextGap="4" modelName="internal" modelPosition="t" textColor="#000000" verticalTextPosition="bottom" visible="true" width="140.0" x="0.0" y="0.0">Group 3</y:NodeLabel>
+              <y:Shape type="roundrectangle"/>
+              <y:State closed="false" closedHeight="50.0" closedWidth="50.0" innerGraphDisplayEnabled="false"/>
+              <y:Insets bottom="15" bottomF="15.0" left="15" leftF="15.0" right="15" rightF="15.0" top="15" topF="15.0"/>
+              <y:BorderInsets bottom="1" bottomF="1.0" left="0" leftF="0.0" right="0" rightF="0.0" top="1" topF="1.0001736111111086"/>
+            </y:GroupNode>
+            <y:GroupNode>
+              <y:Geometry height="50.0" width="50.0" x="0.0" y="60.0"/>
+              <y:Fill color="#F5F5F5" transparent="false"/>
+              <y:BorderStyle color="#000000" type="dashed" width="1.0"/>
+              <y:NodeLabel alignment="right" autoSizePolicy="node_width" backgroundColor="#EBEBEB" borderDistance="0.0" fontFamily="Dialog" fontSize="15" fontStyle="plain" hasLineColor="false" height="21.4609375" horizontalTextPosition="center" iconTextGap="4" modelName="internal" modelPosition="t" textColor="#000000" verticalTextPosition="bottom" visible="true" width="65.201171875" x="-7.6005859375" y="0.0">Folder 3</y:NodeLabel>
+              <y:Shape type="roundrectangle"/>
+              <y:State closed="true" closedHeight="50.0" closedWidth="50.0" innerGraphDisplayEnabled="false"/>
+              <y:Insets bottom="5" bottomF="5.0" left="5" leftF="5.0" right="5" rightF="5.0" top="5" topF="5.0"/>
+              <y:BorderInsets bottom="0" bottomF="0.0" left="0" leftF="0.0" right="0" rightF="0.0" top="0" topF="0.0"/>
+            </y:GroupNode>
+          </y:Realizers>
+        </y:ProxyAutoBoundsNode>
+      </data>
+      <graph edgedefault="directed" id="n1:">
+        <node id="n1::n0" yfiles.foldertype="group">
+          <data key="d4"><![CDATA[CustomPropertyValue]]></data>
+          <data key="d5"/>
+          <data key="d6"/>
+          <data key="d7">
+            <y:ProxyAutoBoundsNode>
+              <y:Realizers active="0">
+                <y:GroupNode>
+                  <y:Geometry height="83.46111111111111" width="110.0" x="-15.0" y="-292.9222222222222"/>
+                  <y:Fill color="#F5F5F5" transparent="false"/>
+                  <y:BorderStyle color="#000000" type="dashed" width="1.0"/>
+                  <y:NodeLabel alignment="right" autoSizePolicy="node_width" backgroundColor="#EBEBEB" borderDistance="0.0" fontFamily="Dialog" fontSize="15" fontStyle="plain" hasLineColor="false" height="21.4609375" horizontalTextPosition="center" iconTextGap="4" modelName="internal" modelPosition="t" textColor="#000000" verticalTextPosition="bottom" visible="true" width="110.0" x="0.0" y="0.0">Group 1</y:NodeLabel>
+                  <y:Shape type="roundrectangle"/>
+                  <y:State closed="false" closedHeight="50.0" closedWidth="50.0" innerGraphDisplayEnabled="false"/>
+                  <y:Insets bottom="15" bottomF="15.0" left="15" leftF="15.0" right="15" rightF="15.0" top="15" topF="15.0"/>
+                  <y:BorderInsets bottom="1" bottomF="1.0" left="0" leftF="0.0" right="0" rightF="0.0" top="1" topF="1.0001736111111086"/>
+                </y:GroupNode>
+                <y:GroupNode>
+                  <y:Geometry height="50.0" width="50.0" x="0.0" y="60.0"/>
+                  <y:Fill color="#F5F5F5" transparent="false"/>
+                  <y:BorderStyle color="#000000" type="dashed" width="1.0"/>
+                  <y:NodeLabel alignment="right" autoSizePolicy="node_width" backgroundColor="#EBEBEB" borderDistance="0.0" fontFamily="Dialog" fontSize="15" fontStyle="plain" hasLineColor="false" height="21.4609375" horizontalTextPosition="center" iconTextGap="4" modelName="internal" modelPosition="t" textColor="#000000" verticalTextPosition="bottom" visible="true" width="65.201171875" x="-7.6005859375" y="0.0">Folder 1</y:NodeLabel>
+                  <y:Shape type="roundrectangle"/>
+                  <y:State closed="true" closedHeight="50.0" closedWidth="50.0" innerGraphDisplayEnabled="false"/>
+                  <y:Insets bottom="5" bottomF="5.0" left="5" leftF="5.0" right="5" rightF="5.0" top="5" topF="5.0"/>
+                  <y:BorderInsets bottom="0" bottomF="0.0" left="0" leftF="0.0" right="0" rightF="0.0" top="0" topF="0.0"/>
+                </y:GroupNode>
+              </y:Realizers>
+            </y:ProxyAutoBoundsNode>
+          </data>
+          <graph edgedefault="directed" id="n1::n0:">
+            <node id="n1::n0::n0">
+              <data key="d4"><![CDATA[CustomPropertyValue]]></data>
+              <data key="d6"/>
+              <data key="d7">
+                <y:ShapeNode>
+                  <y:Geometry height="30.0" width="30.0" x="50.0" y="-255.4611111111111"/>
+                  <y:Fill color="#FFCC00" transparent="false"/>
+                  <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+                  <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="17.96875" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="11.634765625" x="9.1826171875" y="6.015625">1<y:LabelModel>
+                      <y:SmartNodeLabelModel distance="4.0"/>
+                    </y:LabelModel>
+                    <y:ModelParameter>
+                      <y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/>
+                    </y:ModelParameter>
+                  </y:NodeLabel>
+                  <y:Shape type="rectangle"/>
+                </y:ShapeNode>
+              </data>
+            </node>
+            <node id="n1::n0::n1">
+              <data key="d4"><![CDATA[CustomPropertyValue]]></data>
+              <data key="d6"/>
+              <data key="d7">
+                <y:ShapeNode>
+                  <y:Geometry height="30.0" width="30.0" x="0.0" y="-255.4611111111111"/>
+                  <y:Fill color="#FFCC00" transparent="false"/>
+                  <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+                  <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="17.96875" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="11.634765625" x="9.1826171875" y="6.015625">3<y:LabelModel>
+                      <y:SmartNodeLabelModel distance="4.0"/>
+                    </y:LabelModel>
+                    <y:ModelParameter>
+                      <y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/>
+                    </y:ModelParameter>
+                  </y:NodeLabel>
+                  <y:Shape type="rectangle"/>
+                </y:ShapeNode>
+              </data>
+            </node>
+          </graph>
+        </node>
+        <node id="n1::n1" yfiles.foldertype="group">
+          <data key="d4"><![CDATA[CustomPropertyValue]]></data>
+          <data key="d5"/>
+          <data key="d6"/>
+          <data key="d7">
+            <y:ProxyAutoBoundsNode>
+              <y:Realizers active="0">
+                <y:GroupNode>
+                  <y:Geometry height="83.46111111111111" width="110.0" x="-15.0" y="-179.4611111111111"/>
+                  <y:Fill color="#F5F5F5" transparent="false"/>
+                  <y:BorderStyle color="#000000" type="dashed" width="1.0"/>
+                  <y:NodeLabel alignment="right" autoSizePolicy="node_width" backgroundColor="#EBEBEB" borderDistance="0.0" fontFamily="Dialog" fontSize="15" fontStyle="plain" hasLineColor="false" height="21.4609375" horizontalTextPosition="center" iconTextGap="4" modelName="internal" modelPosition="t" textColor="#000000" verticalTextPosition="bottom" visible="true" width="110.0" x="0.0" y="0.0">Group 2</y:NodeLabel>
+                  <y:Shape type="roundrectangle"/>
+                  <y:State closed="false" closedHeight="50.0" closedWidth="50.0" innerGraphDisplayEnabled="false"/>
+                  <y:Insets bottom="15" bottomF="15.0" left="15" leftF="15.0" right="15" rightF="15.0" top="15" topF="15.0"/>
+                  <y:BorderInsets bottom="1" bottomF="1.0" left="0" leftF="0.0" right="0" rightF="0.0" top="1" topF="1.0001736111111086"/>
+                </y:GroupNode>
+                <y:GroupNode>
+                  <y:Geometry height="50.0" width="50.0" x="0.0" y="60.0"/>
+                  <y:Fill color="#F5F5F5" transparent="false"/>
+                  <y:BorderStyle color="#000000" type="dashed" width="1.0"/>
+                  <y:NodeLabel alignment="right" autoSizePolicy="node_width" backgroundColor="#EBEBEB" borderDistance="0.0" fontFamily="Dialog" fontSize="15" fontStyle="plain" hasLineColor="false" height="21.4609375" horizontalTextPosition="center" iconTextGap="4" modelName="internal" modelPosition="t" textColor="#000000" verticalTextPosition="bottom" visible="true" width="65.201171875" x="-7.6005859375" y="0.0">Folder 2</y:NodeLabel>
+                  <y:Shape type="roundrectangle"/>
+                  <y:State closed="true" closedHeight="50.0" closedWidth="50.0" innerGraphDisplayEnabled="false"/>
+                  <y:Insets bottom="5" bottomF="5.0" left="5" leftF="5.0" right="5" rightF="5.0" top="5" topF="5.0"/>
+                  <y:BorderInsets bottom="0" bottomF="0.0" left="0" leftF="0.0" right="0" rightF="0.0" top="0" topF="0.0"/>
+                </y:GroupNode>
+              </y:Realizers>
+            </y:ProxyAutoBoundsNode>
+          </data>
+          <graph edgedefault="directed" id="n1::n1:">
+            <node id="n1::n1::n0">
+              <data key="d4"><![CDATA[CustomPropertyValue]]></data>
+              <data key="d6"/>
+              <data key="d7">
+                <y:ShapeNode>
+                  <y:Geometry height="30.0" width="30.0" x="0.0" y="-142.0"/>
+                  <y:Fill color="#FFCC00" transparent="false"/>
+                  <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+                  <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="17.96875" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="11.634765625" x="9.1826171875" y="6.015625">5<y:LabelModel>
+                      <y:SmartNodeLabelModel distance="4.0"/>
+                    </y:LabelModel>
+                    <y:ModelParameter>
+                      <y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/>
+                    </y:ModelParameter>
+                  </y:NodeLabel>
+                  <y:Shape type="rectangle"/>
+                </y:ShapeNode>
+              </data>
+            </node>
+            <node id="n1::n1::n1">
+              <data key="d4"><![CDATA[CustomPropertyValue]]></data>
+              <data key="d6"/>
+              <data key="d7">
+                <y:ShapeNode>
+                  <y:Geometry height="30.0" width="30.0" x="50.0" y="-142.0"/>
+                  <y:Fill color="#FFCC00" transparent="false"/>
+                  <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+                  <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="17.96875" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="11.634765625" x="9.1826171875" y="6.015625">6<y:LabelModel>
+                      <y:SmartNodeLabelModel distance="4.0"/>
+                    </y:LabelModel>
+                    <y:ModelParameter>
+                      <y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/>
+                    </y:ModelParameter>
+                  </y:NodeLabel>
+                  <y:Shape type="rectangle"/>
+                </y:ShapeNode>
+              </data>
+            </node>
+          </graph>
+        </node>
+      </graph>
+    </node>
+    <node id="n2">
+      <data key="d4"><![CDATA[CustomPropertyValue]]></data>
+      <data key="d6"/>
+      <data key="d7">
+        <y:ShapeNode>
+          <y:Geometry height="30.0" width="30.0" x="125.0" y="-142.0"/>
+          <y:Fill color="#FFCC00" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="17.96875" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="11.634765625" x="9.1826171875" y="6.015625">9<y:LabelModel>
+              <y:SmartNodeLabelModel distance="4.0"/>
+            </y:LabelModel>
+            <y:ModelParameter>
+              <y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/>
+            </y:ModelParameter>
+          </y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <edge id="n1::n1::e0" source="n1::n1::n0" target="n1::n1::n1">
+      <data key="d10"/>
+      <data key="d11">
+        <y:PolyLineEdge>
+          <y:Path sx="15.0" sy="-0.0" tx="-15.0" ty="-0.0"/>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+    <edge id="n1::n0::e0" source="n1::n0::n1" target="n1::n0::n0">
+      <data key="d10"/>
+      <data key="d11">
+        <y:PolyLineEdge>
+          <y:Path sx="15.0" sy="-0.0" tx="-15.0" ty="-0.0"/>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+    <edge id="e0" source="n1::n0::n0" target="n0">
+      <data key="d10"/>
+      <data key="d11">
+        <y:PolyLineEdge>
+          <y:Path sx="15.0" sy="-0.0" tx="-15.0" ty="-0.0"/>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+    <edge id="e1" source="n1::n1::n1" target="n2">
+      <data key="d10"/>
+      <data key="d11">
+        <y:PolyLineEdge>
+          <y:Path sx="15.0" sy="-0.0" tx="-15.0" ty="-0.0"/>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+  </graph>
+  <data key="d8">
+    <y:Resources/>
+  </data>
+</graphml>
+"""
+        # verify that nodes / attributes are correctly read when part of a group
+        fh = io.BytesIO(data.encode("UTF-8"))
+        G = nx.read_graphml(fh)
+        data = [x for _, x in G.nodes(data=True)]
+        assert len(data) == 9
+        for node_data in data:
+            assert node_data["CustomProperty"] != ""
+
+    def test_long_attribute_type(self):
+        # test that graphs with attr.type="long" (as produced by botch and
+        # dose3) can be parsed
+        s = """<?xml version='1.0' encoding='utf-8'?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <key attr.name="cudfversion" attr.type="long" for="node" id="d6" />
+  <graph edgedefault="directed">
+    <node id="n1">
+      <data key="d6">4284</data>
+    </node>
+  </graph>
+</graphml>"""
+        fh = io.BytesIO(s.encode("UTF-8"))
+        G = nx.read_graphml(fh)
+        expected = [("n1", {"cudfversion": 4284})]
+        assert sorted(G.nodes(data=True)) == expected
+        fh.seek(0)
+        H = nx.parse_graphml(s)
+        assert sorted(H.nodes(data=True)) == expected
+
+
+class TestWriteGraphML(BaseGraphML):
+    writer = staticmethod(nx.write_graphml_lxml)
+
+    @classmethod
+    def setup_class(cls):
+        BaseGraphML.setup_class()
+        _ = pytest.importorskip("lxml.etree")
+
+    def test_write_interface(self):
+        try:
+            import lxml.etree
+
+            assert nx.write_graphml == nx.write_graphml_lxml
+        except ImportError:
+            assert nx.write_graphml == nx.write_graphml_xml
+
+    def test_write_read_simple_directed_graphml(self):
+        G = self.simple_directed_graph
+        G.graph["hi"] = "there"
+        fh = io.BytesIO()
+        self.writer(G, fh)
+        fh.seek(0)
+        H = nx.read_graphml(fh)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(G.edges()) == sorted(H.edges())
+        assert sorted(G.edges(data=True)) == sorted(H.edges(data=True))
+        self.simple_directed_fh.seek(0)
+
+    def test_GraphMLWriter_add_graphs(self):
+        gmlw = GraphMLWriter()
+        G = self.simple_directed_graph
+        H = G.copy()
+        gmlw.add_graphs([G, H])
+
+    def test_write_read_simple_no_prettyprint(self):
+        G = self.simple_directed_graph
+        G.graph["hi"] = "there"
+        G.graph["id"] = "1"
+        fh = io.BytesIO()
+        self.writer(G, fh, prettyprint=False)
+        fh.seek(0)
+        H = nx.read_graphml(fh)
+        assert sorted(G.nodes()) == sorted(H.nodes())
+        assert sorted(G.edges()) == sorted(H.edges())
+        assert sorted(G.edges(data=True)) == sorted(H.edges(data=True))
+        self.simple_directed_fh.seek(0)
+
+    def test_write_read_attribute_named_key_ids_graphml(self):
+        from xml.etree.ElementTree import parse
+
+        G = self.attribute_named_key_ids_graph
+        fh = io.BytesIO()
+        self.writer(G, fh, named_key_ids=True)
+        fh.seek(0)
+        H = nx.read_graphml(fh)
+        fh.seek(0)
+
+        assert nodes_equal(G.nodes(), H.nodes())
+        assert edges_equal(G.edges(), H.edges())
+        assert edges_equal(G.edges(data=True), H.edges(data=True))
+        self.attribute_named_key_ids_fh.seek(0)
+
+        xml = parse(fh)
+        # Children are the key elements, and the graph element
+        children = list(xml.getroot())
+        assert len(children) == 4
+
+        keys = [child.items() for child in children[:3]]
+
+        assert len(keys) == 3
+        assert ("id", "edge_prop") in keys[0]
+        assert ("attr.name", "edge_prop") in keys[0]
+        assert ("id", "prop2") in keys[1]
+        assert ("attr.name", "prop2") in keys[1]
+        assert ("id", "prop1") in keys[2]
+        assert ("attr.name", "prop1") in keys[2]
+
+        # Confirm the read graph nodes/edge are identical when compared to
+        # default writing behavior.
+        default_behavior_fh = io.BytesIO()
+        nx.write_graphml(G, default_behavior_fh)
+        default_behavior_fh.seek(0)
+        H = nx.read_graphml(default_behavior_fh)
+
+        named_key_ids_behavior_fh = io.BytesIO()
+        nx.write_graphml(G, named_key_ids_behavior_fh, named_key_ids=True)
+        named_key_ids_behavior_fh.seek(0)
+        J = nx.read_graphml(named_key_ids_behavior_fh)
+
+        assert all(n1 == n2 for (n1, n2) in zip(H.nodes, J.nodes))
+        assert all(e1 == e2 for (e1, e2) in zip(H.edges, J.edges))
+
+    def test_write_read_attribute_numeric_type_graphml(self):
+        from xml.etree.ElementTree import parse
+
+        G = self.attribute_numeric_type_graph
+        fh = io.BytesIO()
+        self.writer(G, fh, infer_numeric_types=True)
+        fh.seek(0)
+        H = nx.read_graphml(fh)
+        fh.seek(0)
+
+        assert nodes_equal(G.nodes(), H.nodes())
+        assert edges_equal(G.edges(), H.edges())
+        assert edges_equal(G.edges(data=True), H.edges(data=True))
+        self.attribute_numeric_type_fh.seek(0)
+
+        xml = parse(fh)
+        # Children are the key elements, and the graph element
+        children = list(xml.getroot())
+        assert len(children) == 3
+
+        keys = [child.items() for child in children[:2]]
+
+        assert len(keys) == 2
+        assert ("attr.type", "double") in keys[0]
+        assert ("attr.type", "double") in keys[1]
+
+    def test_more_multigraph_keys(self):
+        """Writing keys as edge id attributes means keys become strings.
+        The original keys are stored as data, so read them back in
+        if `str(key) == edge_id`
+        This allows the adjacency to remain the same.
+        """
+        G = nx.MultiGraph()
+        G.add_edges_from([("a", "b", 2), ("a", "b", 3)])
+        fd, fname = tempfile.mkstemp()
+        self.writer(G, fname)
+        H = nx.read_graphml(fname)
+        assert H.is_multigraph()
+        assert edges_equal(G.edges(keys=True), H.edges(keys=True))
+        assert G._adj == H._adj
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_default_attribute(self):
+        G = nx.Graph(name="Fred")
+        G.add_node(1, label=1, color="green")
+        nx.add_path(G, [0, 1, 2, 3])
+        G.add_edge(1, 2, weight=3)
+        G.graph["node_default"] = {"color": "yellow"}
+        G.graph["edge_default"] = {"weight": 7}
+        fh = io.BytesIO()
+        self.writer(G, fh)
+        fh.seek(0)
+        H = nx.read_graphml(fh, node_type=int)
+        assert nodes_equal(G.nodes(), H.nodes())
+        assert edges_equal(G.edges(), H.edges())
+        assert G.graph == H.graph
+
+    def test_mixed_type_attributes(self):
+        G = nx.MultiGraph()
+        G.add_node("n0", special=False)
+        G.add_node("n1", special=0)
+        G.add_edge("n0", "n1", special=False)
+        G.add_edge("n0", "n1", special=0)
+        fh = io.BytesIO()
+        self.writer(G, fh)
+        fh.seek(0)
+        H = nx.read_graphml(fh)
+        assert not H.nodes["n0"]["special"]
+        assert H.nodes["n1"]["special"] == 0
+        assert not H.edges["n0", "n1", 0]["special"]
+        assert H.edges["n0", "n1", 1]["special"] == 0
+
+    def test_str_number_mixed_type_attributes(self):
+        G = nx.MultiGraph()
+        G.add_node("n0", special="hello")
+        G.add_node("n1", special=0)
+        G.add_edge("n0", "n1", special="hello")
+        G.add_edge("n0", "n1", special=0)
+        fh = io.BytesIO()
+        self.writer(G, fh)
+        fh.seek(0)
+        H = nx.read_graphml(fh)
+        assert H.nodes["n0"]["special"] == "hello"
+        assert H.nodes["n1"]["special"] == 0
+        assert H.edges["n0", "n1", 0]["special"] == "hello"
+        assert H.edges["n0", "n1", 1]["special"] == 0
+
+    def test_mixed_int_type_number_attributes(self):
+        np = pytest.importorskip("numpy")
+        G = nx.MultiGraph()
+        G.add_node("n0", special=np.int64(0))
+        G.add_node("n1", special=1)
+        G.add_edge("n0", "n1", special=np.int64(2))
+        G.add_edge("n0", "n1", special=3)
+        fh = io.BytesIO()
+        self.writer(G, fh)
+        fh.seek(0)
+        H = nx.read_graphml(fh)
+        assert H.nodes["n0"]["special"] == 0
+        assert H.nodes["n1"]["special"] == 1
+        assert H.edges["n0", "n1", 0]["special"] == 2
+        assert H.edges["n0", "n1", 1]["special"] == 3
+
+    def test_numpy_float(self):
+        np = pytest.importorskip("numpy")
+        wt = np.float_(3.4)
+        G = nx.Graph([(1, 2, {"weight": wt})])
+        fd, fname = tempfile.mkstemp()
+        self.writer(G, fname)
+        H = nx.read_graphml(fname, node_type=int)
+        assert G._adj == H._adj
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multigraph_to_graph(self):
+        # test converting multigraph to graph if no parallel edges found
+        G = nx.MultiGraph()
+        G.add_edges_from([("a", "b", 2), ("b", "c", 3)])  # no multiedges
+        fd, fname = tempfile.mkstemp()
+        self.writer(G, fname)
+        H = nx.read_graphml(fname)
+        assert not H.is_multigraph()
+        H = nx.read_graphml(fname, force_multigraph=True)
+        assert H.is_multigraph()
+        os.close(fd)
+        os.unlink(fname)
+
+        # add a multiedge
+        G.add_edge("a", "b", "e-id")
+        fd, fname = tempfile.mkstemp()
+        self.writer(G, fname)
+        H = nx.read_graphml(fname)
+        assert H.is_multigraph()
+        H = nx.read_graphml(fname, force_multigraph=True)
+        assert H.is_multigraph()
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_write_generate_edge_id_from_attribute(self):
+        from xml.etree.ElementTree import parse
+
+        G = nx.Graph()
+        G.add_edges_from([("a", "b"), ("b", "c"), ("a", "c")])
+        edge_attributes = {e: str(e) for e in G.edges}
+        nx.set_edge_attributes(G, edge_attributes, "eid")
+        fd, fname = tempfile.mkstemp()
+        # set edge_id_from_attribute e.g. "eid" for write_graphml()
+        self.writer(G, fname, edge_id_from_attribute="eid")
+        # set edge_id_from_attribute e.g. "eid" for generate_graphml()
+        generator = nx.generate_graphml(G, edge_id_from_attribute="eid")
+
+        H = nx.read_graphml(fname)
+        assert nodes_equal(G.nodes(), H.nodes())
+        assert edges_equal(G.edges(), H.edges())
+        # NetworkX adds explicit edge "id" from file as attribute
+        nx.set_edge_attributes(G, edge_attributes, "id")
+        assert edges_equal(G.edges(data=True), H.edges(data=True))
+
+        tree = parse(fname)
+        children = list(tree.getroot())
+        assert len(children) == 2
+        edge_ids = [
+            edge.attrib["id"]
+            for edge in tree.getroot().findall(
+                ".//{http://graphml.graphdrawing.org/xmlns}edge"
+            )
+        ]
+        # verify edge id value is equal to sepcified attribute value
+        assert sorted(edge_ids) == sorted(edge_attributes.values())
+
+        # check graphml generated from generate_graphml()
+        data = "".join(generator)
+        J = nx.parse_graphml(data)
+        assert sorted(G.nodes()) == sorted(J.nodes())
+        assert sorted(G.edges()) == sorted(J.edges())
+        # NetworkX adds explicit edge "id" from file as attribute
+        nx.set_edge_attributes(G, edge_attributes, "id")
+        assert edges_equal(G.edges(data=True), J.edges(data=True))
+
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multigraph_write_generate_edge_id_from_attribute(self):
+        from xml.etree.ElementTree import parse
+
+        G = nx.MultiGraph()
+        G.add_edges_from([("a", "b"), ("b", "c"), ("a", "c"), ("a", "b")])
+        edge_attributes = {e: str(e) for e in G.edges}
+        nx.set_edge_attributes(G, edge_attributes, "eid")
+        fd, fname = tempfile.mkstemp()
+        # set edge_id_from_attribute e.g. "eid" for write_graphml()
+        self.writer(G, fname, edge_id_from_attribute="eid")
+        # set edge_id_from_attribute e.g. "eid" for generate_graphml()
+        generator = nx.generate_graphml(G, edge_id_from_attribute="eid")
+
+        H = nx.read_graphml(fname)
+        assert H.is_multigraph()
+        H = nx.read_graphml(fname, force_multigraph=True)
+        assert H.is_multigraph()
+
+        assert nodes_equal(G.nodes(), H.nodes())
+        assert edges_equal(G.edges(), H.edges())
+        assert sorted(data.get("eid") for u, v, data in H.edges(data=True)) == sorted(
+            edge_attributes.values()
+        )
+        # NetworkX uses edge_ids as keys in multigraphs if no key
+        assert sorted(key for u, v, key in H.edges(keys=True)) == sorted(
+            edge_attributes.values()
+        )
+
+        tree = parse(fname)
+        children = list(tree.getroot())
+        assert len(children) == 2
+        edge_ids = [
+            edge.attrib["id"]
+            for edge in tree.getroot().findall(
+                ".//{http://graphml.graphdrawing.org/xmlns}edge"
+            )
+        ]
+        # verify edge id value is equal to sepcified attribute value
+        assert sorted(edge_ids) == sorted(edge_attributes.values())
+
+        # check graphml generated from generate_graphml()
+        graphml_data = "".join(generator)
+        J = nx.parse_graphml(graphml_data)
+        assert J.is_multigraph()
+
+        assert nodes_equal(G.nodes(), J.nodes())
+        assert edges_equal(G.edges(), J.edges())
+        assert sorted(data.get("eid") for u, v, data in J.edges(data=True)) == sorted(
+            edge_attributes.values()
+        )
+        # NetworkX uses edge_ids as keys in multigraphs if no key
+        assert sorted(key for u, v, key in J.edges(keys=True)) == sorted(
+            edge_attributes.values()
+        )
+
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_numpy_float64(self):
+        np = pytest.importorskip("numpy")
+        wt = np.float64(3.4)
+        G = nx.Graph([(1, 2, {"weight": wt})])
+        fd, fname = tempfile.mkstemp()
+        self.writer(G, fname)
+        H = nx.read_graphml(fname, node_type=int)
+        assert G.edges == H.edges
+        wtG = G[1][2]["weight"]
+        wtH = H[1][2]["weight"]
+        assert wtG == pytest.approx(wtH, abs=1e-6)
+        assert type(wtG) == np.float64
+        assert type(wtH) == float
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_numpy_float32(self):
+        np = pytest.importorskip("numpy")
+        wt = np.float32(3.4)
+        G = nx.Graph([(1, 2, {"weight": wt})])
+        fd, fname = tempfile.mkstemp()
+        self.writer(G, fname)
+        H = nx.read_graphml(fname, node_type=int)
+        assert G.edges == H.edges
+        wtG = G[1][2]["weight"]
+        wtH = H[1][2]["weight"]
+        assert wtG == pytest.approx(wtH, abs=1e-6)
+        assert type(wtG) == np.float32
+        assert type(wtH) == float
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_numpy_float64_inference(self):
+        np = pytest.importorskip("numpy")
+        G = self.attribute_numeric_type_graph
+        G.edges[("n1", "n1")]["weight"] = np.float64(1.1)
+        fd, fname = tempfile.mkstemp()
+        self.writer(G, fname, infer_numeric_types=True)
+        H = nx.read_graphml(fname)
+        assert G._adj == H._adj
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_unicode_attributes(self):
+        G = nx.Graph()
+        name1 = chr(2344) + chr(123) + chr(6543)
+        name2 = chr(5543) + chr(1543) + chr(324)
+        node_type = str
+        G.add_edge(name1, "Radiohead", foo=name2)
+        fd, fname = tempfile.mkstemp()
+        self.writer(G, fname)
+        H = nx.read_graphml(fname, node_type=node_type)
+        assert G._adj == H._adj
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_unicode_escape(self):
+        # test for handling json escaped stings in python 2 Issue #1880
+        import json
+
+        a = dict(a='{"a": "123"}')  # an object with many chars to escape
+        sa = json.dumps(a)
+        G = nx.Graph()
+        G.graph["test"] = sa
+        fh = io.BytesIO()
+        self.writer(G, fh)
+        fh.seek(0)
+        H = nx.read_graphml(fh)
+        assert G.graph["test"] == H.graph["test"]
+
+
+class TestXMLGraphML(TestWriteGraphML):
+    writer = staticmethod(nx.write_graphml_xml)
+
+    @classmethod
+    def setup_class(cls):
+        TestWriteGraphML.setup_class()
+
+
+def test_exception_for_unsupported_datatype_node_attr():
+    """Test that a detailed exception is raised when an attribute is of a type
+    not supported by GraphML, e.g. a list"""
+    pytest.importorskip("lxml.etree")
+    # node attribute
+    G = nx.Graph()
+    G.add_node(0, my_list_attribute=[0, 1, 2])
+    fh = io.BytesIO()
+    with pytest.raises(TypeError, match="GraphML does not support"):
+        nx.write_graphml(G, fh)
+
+
+def test_exception_for_unsupported_datatype_edge_attr():
+    """Test that a detailed exception is raised when an attribute is of a type
+    not supported by GraphML, e.g. a list"""
+    pytest.importorskip("lxml.etree")
+    # edge attribute
+    G = nx.Graph()
+    G.add_edge(0, 1, my_list_attribute=[0, 1, 2])
+    fh = io.BytesIO()
+    with pytest.raises(TypeError, match="GraphML does not support"):
+        nx.write_graphml(G, fh)
+
+
+def test_exception_for_unsupported_datatype_graph_attr():
+    """Test that a detailed exception is raised when an attribute is of a type
+    not supported by GraphML, e.g. a list"""
+    pytest.importorskip("lxml.etree")
+    # graph attribute
+    G = nx.Graph()
+    G.graph["my_list_attribute"] = [0, 1, 2]
+    fh = io.BytesIO()
+    with pytest.raises(TypeError, match="GraphML does not support"):
+        nx.write_graphml(G, fh)
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_leda.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_leda.py
new file mode 100644
index 0000000..8ac5ecc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_leda.py
@@ -0,0 +1,30 @@
+import io
+
+import networkx as nx
+
+
+class TestLEDA:
+    def test_parse_leda(self):
+        data = """#header section         \nLEDA.GRAPH \nstring\nint\n-1\n#nodes section\n5 \n|{v1}| \n|{v2}| \n|{v3}| \n|{v4}| \n|{v5}| \n\n#edges section\n7 \n1 2 0 |{4}| \n1 3 0 |{3}| \n2 3 0 |{2}| \n3 4 0 |{3}| \n3 5 0 |{7}| \n4 5 0 |{6}| \n5 1 0 |{foo}|"""
+        G = nx.parse_leda(data)
+        G = nx.parse_leda(data.split("\n"))
+        assert sorted(G.nodes()) == ["v1", "v2", "v3", "v4", "v5"]
+        assert sorted(G.edges(data=True)) == [
+            ("v1", "v2", {"label": "4"}),
+            ("v1", "v3", {"label": "3"}),
+            ("v2", "v3", {"label": "2"}),
+            ("v3", "v4", {"label": "3"}),
+            ("v3", "v5", {"label": "7"}),
+            ("v4", "v5", {"label": "6"}),
+            ("v5", "v1", {"label": "foo"}),
+        ]
+
+    def test_read_LEDA(self):
+        fh = io.BytesIO()
+        data = """#header section         \nLEDA.GRAPH \nstring\nint\n-1\n#nodes section\n5 \n|{v1}| \n|{v2}| \n|{v3}| \n|{v4}| \n|{v5}| \n\n#edges section\n7 \n1 2 0 |{4}| \n1 3 0 |{3}| \n2 3 0 |{2}| \n3 4 0 |{3}| \n3 5 0 |{7}| \n4 5 0 |{6}| \n5 1 0 |{foo}|"""
+        G = nx.parse_leda(data)
+        fh.write(data.encode("UTF-8"))
+        fh.seek(0)
+        Gin = nx.read_leda(fh)
+        assert sorted(G.nodes()) == sorted(Gin.nodes())
+        assert sorted(G.edges()) == sorted(Gin.edges())
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_p2g.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_p2g.py
new file mode 100644
index 0000000..8280870
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_p2g.py
@@ -0,0 +1,62 @@
+import io
+
+import networkx as nx
+from networkx.readwrite.p2g import read_p2g, write_p2g
+from networkx.utils import edges_equal
+
+
+class TestP2G:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.Graph(name="test")
+        e = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("a", "f")]
+        cls.G.add_edges_from(e)
+        cls.G.add_node("g")
+        cls.DG = nx.DiGraph(cls.G)
+
+    def test_read_p2g(self):
+        s = b"""\
+name
+3 4
+a
+1 2
+b
+
+c
+0 2
+"""
+        bytesIO = io.BytesIO(s)
+        G = read_p2g(bytesIO)
+        assert G.name == "name"
+        assert sorted(G) == ["a", "b", "c"]
+        edges = [(str(u), str(v)) for u, v in G.edges()]
+        assert edges_equal(G.edges(), [("a", "c"), ("a", "b"), ("c", "a"), ("c", "c")])
+
+    def test_write_p2g(self):
+        s = b"""foo
+3 2
+1
+1 
+2
+2 
+3
+
+"""
+        fh = io.BytesIO()
+        G = nx.OrderedDiGraph()
+        G.name = "foo"
+        G.add_edges_from([(1, 2), (2, 3)])
+        write_p2g(G, fh)
+        fh.seek(0)
+        r = fh.read()
+        assert r == s
+
+    def test_write_read_p2g(self):
+        fh = io.BytesIO()
+        G = nx.DiGraph()
+        G.name = "foo"
+        G.add_edges_from([("a", "b"), ("b", "c")])
+        write_p2g(G, fh)
+        fh.seek(0)
+        H = read_p2g(fh)
+        assert edges_equal(G.edges(), H.edges())
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_pajek.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_pajek.py
new file mode 100644
index 0000000..e617c3f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_pajek.py
@@ -0,0 +1,130 @@
+"""
+Pajek tests
+"""
+import os
+import tempfile
+
+import networkx as nx
+from networkx.utils import edges_equal, nodes_equal
+
+
+class TestPajek:
+    @classmethod
+    def setup_class(cls):
+        cls.data = """*network Tralala\n*vertices 4\n   1 "A1"         0.0938 0.0896   ellipse x_fact 1 y_fact 1\n   2 "Bb"         0.8188 0.2458   ellipse x_fact 1 y_fact 1\n   3 "C"          0.3688 0.7792   ellipse x_fact 1\n   4 "D2"         0.9583 0.8563   ellipse x_fact 1\n*arcs\n1 1 1  h2 0 w 3 c Blue s 3 a1 -130 k1 0.6 a2 -130 k2 0.6 ap 0.5 l "Bezier loop" lc BlueViolet fos 20 lr 58 lp 0.3 la 360\n2 1 1  h2 0 a1 120 k1 1.3 a2 -120 k2 0.3 ap 25 l "Bezier arc" lphi 270 la 180 lr 19 lp 0.5\n1 2 1  h2 0 a1 40 k1 2.8 a2 30 k2 0.8 ap 25 l "Bezier arc" lphi 90 la 0 lp 0.65\n4 2 -1  h2 0 w 1 k1 -2 k2 250 ap 25 l "Circular arc" c Red lc OrangeRed\n3 4 1  p Dashed h2 0 w 2 c OliveGreen ap 25 l "Straight arc" lc PineGreen\n1 3 1  p Dashed h2 0 w 5 k1 -1 k2 -20 ap 25 l "Oval arc" c Brown lc Black\n3 3 -1  h1 6 w 1 h2 12 k1 -2 k2 -15 ap 0.5 l "Circular loop" c Red lc OrangeRed lphi 270 la 180"""
+        cls.G = nx.MultiDiGraph()
+        cls.G.add_nodes_from(["A1", "Bb", "C", "D2"])
+        cls.G.add_edges_from(
+            [
+                ("A1", "A1"),
+                ("A1", "Bb"),
+                ("A1", "C"),
+                ("Bb", "A1"),
+                ("C", "C"),
+                ("C", "D2"),
+                ("D2", "Bb"),
+            ]
+        )
+
+        cls.G.graph["name"] = "Tralala"
+        (fd, cls.fname) = tempfile.mkstemp()
+        with os.fdopen(fd, "wb") as fh:
+            fh.write(cls.data.encode("UTF-8"))
+
+    @classmethod
+    def teardown_class(cls):
+        os.unlink(cls.fname)
+
+    def test_parse_pajek_simple(self):
+        # Example without node positions or shape
+        data = """*Vertices 2\n1 "1"\n2 "2"\n*Edges\n1 2\n2 1"""
+        G = nx.parse_pajek(data)
+        assert sorted(G.nodes()) == ["1", "2"]
+        assert edges_equal(G.edges(), [("1", "2"), ("1", "2")])
+
+    def test_parse_pajek(self):
+        G = nx.parse_pajek(self.data)
+        assert sorted(G.nodes()) == ["A1", "Bb", "C", "D2"]
+        assert edges_equal(
+            G.edges(),
+            [
+                ("A1", "A1"),
+                ("A1", "Bb"),
+                ("A1", "C"),
+                ("Bb", "A1"),
+                ("C", "C"),
+                ("C", "D2"),
+                ("D2", "Bb"),
+            ],
+        )
+
+    def test_parse_pajet_mat(self):
+        data = """*Vertices 3\n1 "one"\n2 "two"\n3 "three"\n*Matrix\n1 1 0\n0 1 0\n0 1 0\n"""
+        G = nx.parse_pajek(data)
+        assert set(G.nodes()) == {"one", "two", "three"}
+        assert G.nodes["two"] == {"id": "2"}
+        assert edges_equal(
+            set(G.edges()),
+            {("one", "one"), ("two", "one"), ("two", "two"), ("two", "three")},
+        )
+
+    def test_read_pajek(self):
+        G = nx.parse_pajek(self.data)
+        Gin = nx.read_pajek(self.fname)
+        assert sorted(G.nodes()) == sorted(Gin.nodes())
+        assert edges_equal(G.edges(), Gin.edges())
+        assert self.G.graph == Gin.graph
+        for n in G:
+            assert G.nodes[n] == Gin.nodes[n]
+
+    def test_write_pajek(self):
+        import io
+
+        G = nx.parse_pajek(self.data)
+        fh = io.BytesIO()
+        nx.write_pajek(G, fh)
+        fh.seek(0)
+        H = nx.read_pajek(fh)
+        assert nodes_equal(list(G), list(H))
+        assert edges_equal(list(G.edges()), list(H.edges()))
+        # Graph name is left out for now, therefore it is not tested.
+        # assert_equal(G.graph, H.graph)
+
+    def test_ignored_attribute(self):
+        import io
+
+        G = nx.Graph()
+        fh = io.BytesIO()
+        G.add_node(1, int_attr=1)
+        G.add_node(2, empty_attr="  ")
+        G.add_edge(1, 2, int_attr=2)
+        G.add_edge(2, 3, empty_attr="  ")
+
+        import warnings
+
+        with warnings.catch_warnings(record=True) as w:
+            nx.write_pajek(G, fh)
+            assert len(w) == 4
+
+    def test_noname(self):
+        # Make sure we can parse a line such as:  *network
+        # Issue #952
+        line = "*network\n"
+        other_lines = self.data.split("\n")[1:]
+        data = line + "\n".join(other_lines)
+        G = nx.parse_pajek(data)
+
+    def test_unicode(self):
+        import io
+
+        G = nx.Graph()
+        name1 = chr(2344) + chr(123) + chr(6543)
+        name2 = chr(5543) + chr(1543) + chr(324)
+        G.add_edge(name1, "Radiohead", foo=name2)
+        fh = io.BytesIO()
+        nx.write_pajek(G, fh)
+        fh.seek(0)
+        H = nx.read_pajek(fh)
+        assert nodes_equal(list(G), list(H))
+        assert edges_equal(list(G.edges()), list(H.edges()))
+        assert G.graph == H.graph
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_shp.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_shp.py
new file mode 100644
index 0000000..7ada2e8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_shp.py
@@ -0,0 +1,288 @@
+"""Unit tests for shp.
+"""
+
+import os
+import tempfile
+
+import pytest
+
+ogr = pytest.importorskip("osgeo.ogr")
+
+import networkx as nx
+
+
+class TestShp:
+    def setup_method(self):
+        def createlayer(driver, layerType=ogr.wkbLineString):
+            lyr = driver.CreateLayer("edges", None, layerType)
+            namedef = ogr.FieldDefn("Name", ogr.OFTString)
+            namedef.SetWidth(32)
+            lyr.CreateField(namedef)
+            return lyr
+
+        drv = ogr.GetDriverByName("ESRI Shapefile")
+
+        testdir = os.path.join(tempfile.gettempdir(), "shpdir")
+        shppath = os.path.join(tempfile.gettempdir(), "tmpshp.shp")
+        multi_shppath = os.path.join(tempfile.gettempdir(), "tmp_mshp.shp")
+
+        self.deletetmp(drv, testdir, shppath, multi_shppath)
+        os.mkdir(testdir)
+
+        self.names = ["a", "b", "c", "c"]  # edgenames
+        self.paths = (
+            [(1.0, 1.0), (2.0, 2.0)],
+            [(2.0, 2.0), (3.0, 3.0)],
+            [(0.9, 0.9), (4.0, 0.9), (4.0, 2.0)],
+        )
+
+        self.simplified_names = ["a", "b", "c"]  # edgenames
+        self.simplified_paths = (
+            [(1.0, 1.0), (2.0, 2.0)],
+            [(2.0, 2.0), (3.0, 3.0)],
+            [(0.9, 0.9), (4.0, 2.0)],
+        )
+
+        self.multi_names = ["a", "a", "a", "a"]  # edgenames
+
+        shp = drv.CreateDataSource(shppath)
+        lyr = createlayer(shp)
+
+        for path, name in zip(self.paths, self.names):
+            feat = ogr.Feature(lyr.GetLayerDefn())
+            g = ogr.Geometry(ogr.wkbLineString)
+            for p in path:
+                g.AddPoint_2D(*p)
+            feat.SetGeometry(g)
+            feat.SetField("Name", name)
+            lyr.CreateFeature(feat)
+
+        # create single record multiline shapefile for testing
+        multi_shp = drv.CreateDataSource(multi_shppath)
+        multi_lyr = createlayer(multi_shp, ogr.wkbMultiLineString)
+
+        multi_g = ogr.Geometry(ogr.wkbMultiLineString)
+        for path in self.paths:
+
+            g = ogr.Geometry(ogr.wkbLineString)
+            for p in path:
+                g.AddPoint_2D(*p)
+
+            multi_g.AddGeometry(g)
+
+        multi_feat = ogr.Feature(multi_lyr.GetLayerDefn())
+        multi_feat.SetGeometry(multi_g)
+        multi_feat.SetField("Name", "a")
+        multi_lyr.CreateFeature(multi_feat)
+
+        self.shppath = shppath
+        self.multi_shppath = multi_shppath
+        self.testdir = testdir
+        self.drv = drv
+
+    def deletetmp(self, drv, *paths):
+        for p in paths:
+            if os.path.exists(p):
+                drv.DeleteDataSource(p)
+
+    def testload(self):
+        def compare_graph_paths_names(g, paths, names):
+            expected = nx.DiGraph()
+            for p in paths:
+                nx.add_path(expected, p)
+            assert sorted(expected.nodes) == sorted(g.nodes)
+            assert sorted(expected.edges()) == sorted(g.edges())
+            g_names = [g.get_edge_data(s, e)["Name"] for s, e in g.edges()]
+            assert names == sorted(g_names)
+
+        # simplified
+        G = nx.read_shp(self.shppath)
+        compare_graph_paths_names(G, self.simplified_paths, self.simplified_names)
+
+        # unsimplified
+        G = nx.read_shp(self.shppath, simplify=False)
+        compare_graph_paths_names(G, self.paths, self.names)
+
+        # multiline unsimplified
+        G = nx.read_shp(self.multi_shppath, simplify=False)
+        compare_graph_paths_names(G, self.paths, self.multi_names)
+
+    def checkgeom(self, lyr, expected):
+        feature = lyr.GetNextFeature()
+        actualwkt = []
+        while feature:
+            actualwkt.append(feature.GetGeometryRef().ExportToWkt())
+            feature = lyr.GetNextFeature()
+        assert sorted(expected) == sorted(actualwkt)
+
+    def test_geometryexport(self):
+        expectedpoints_simple = (
+            "POINT (1 1)",
+            "POINT (2 2)",
+            "POINT (3 3)",
+            "POINT (0.9 0.9)",
+            "POINT (4 2)",
+        )
+        expectedlines_simple = (
+            "LINESTRING (1 1,2 2)",
+            "LINESTRING (2 2,3 3)",
+            "LINESTRING (0.9 0.9,4.0 0.9,4 2)",
+        )
+        expectedpoints = (
+            "POINT (1 1)",
+            "POINT (2 2)",
+            "POINT (3 3)",
+            "POINT (0.9 0.9)",
+            "POINT (4.0 0.9)",
+            "POINT (4 2)",
+        )
+        expectedlines = (
+            "LINESTRING (1 1,2 2)",
+            "LINESTRING (2 2,3 3)",
+            "LINESTRING (0.9 0.9,4.0 0.9)",
+            "LINESTRING (4.0 0.9,4 2)",
+        )
+
+        tpath = os.path.join(tempfile.gettempdir(), "shpdir")
+        G = nx.read_shp(self.shppath)
+        nx.write_shp(G, tpath)
+        shpdir = ogr.Open(tpath)
+        self.checkgeom(shpdir.GetLayerByName("nodes"), expectedpoints_simple)
+        self.checkgeom(shpdir.GetLayerByName("edges"), expectedlines_simple)
+
+        # Test unsimplified
+        # Nodes should have additional point,
+        # edges should be 'flattened'
+        G = nx.read_shp(self.shppath, simplify=False)
+        nx.write_shp(G, tpath)
+        shpdir = ogr.Open(tpath)
+        self.checkgeom(shpdir.GetLayerByName("nodes"), expectedpoints)
+        self.checkgeom(shpdir.GetLayerByName("edges"), expectedlines)
+
+    def test_attributeexport(self):
+        def testattributes(lyr, graph):
+            feature = lyr.GetNextFeature()
+            while feature:
+                coords = []
+                ref = feature.GetGeometryRef()
+                last = ref.GetPointCount() - 1
+                edge_nodes = (ref.GetPoint_2D(0), ref.GetPoint_2D(last))
+                name = feature.GetFieldAsString("Name")
+                assert graph.get_edge_data(*edge_nodes)["Name"] == name
+                feature = lyr.GetNextFeature()
+
+        tpath = os.path.join(tempfile.gettempdir(), "shpdir")
+
+        G = nx.read_shp(self.shppath)
+        nx.write_shp(G, tpath)
+        shpdir = ogr.Open(tpath)
+        edges = shpdir.GetLayerByName("edges")
+        testattributes(edges, G)
+
+    # Test export of node attributes in nx.write_shp (#2778)
+    def test_nodeattributeexport(self):
+        tpath = os.path.join(tempfile.gettempdir(), "shpdir")
+
+        G = nx.DiGraph()
+        A = (0, 0)
+        B = (1, 1)
+        C = (2, 2)
+        G.add_edge(A, B)
+        G.add_edge(A, C)
+        label = "node_label"
+        for n, d in G.nodes(data=True):
+            d["label"] = label
+        nx.write_shp(G, tpath)
+
+        H = nx.read_shp(tpath)
+        for n, d in H.nodes(data=True):
+            assert d["label"] == label
+
+    def test_wkt_export(self):
+        G = nx.DiGraph()
+        tpath = os.path.join(tempfile.gettempdir(), "shpdir")
+        points = ("POINT (0.9 0.9)", "POINT (4 2)")
+        line = ("LINESTRING (0.9 0.9,4 2)",)
+        G.add_node(1, Wkt=points[0])
+        G.add_node(2, Wkt=points[1])
+        G.add_edge(1, 2, Wkt=line[0])
+        try:
+            nx.write_shp(G, tpath)
+        except Exception as err:
+            assert False, err
+        shpdir = ogr.Open(tpath)
+        self.checkgeom(shpdir.GetLayerByName("nodes"), points)
+        self.checkgeom(shpdir.GetLayerByName("edges"), line)
+
+    def teardown_method(self):
+        self.deletetmp(self.drv, self.testdir, self.shppath)
+
+
+def test_read_shp_nofile():
+    with pytest.raises(RuntimeError):
+        G = nx.read_shp("hopefully_this_file_will_not_be_available")
+
+
+class TestMissingGeometry:
+    def setup_method(self):
+        self.setup_path()
+        self.delete_shapedir()
+        self.create_shapedir()
+
+    def teardown_method(self):
+        self.delete_shapedir()
+
+    def setup_path(self):
+        self.path = os.path.join(tempfile.gettempdir(), "missing_geometry")
+
+    def create_shapedir(self):
+        drv = ogr.GetDriverByName("ESRI Shapefile")
+        shp = drv.CreateDataSource(self.path)
+        lyr = shp.CreateLayer("nodes", None, ogr.wkbPoint)
+        feature = ogr.Feature(lyr.GetLayerDefn())
+        feature.SetGeometry(None)
+        lyr.CreateFeature(feature)
+        feature.Destroy()
+
+    def delete_shapedir(self):
+        drv = ogr.GetDriverByName("ESRI Shapefile")
+        if os.path.exists(self.path):
+            drv.DeleteDataSource(self.path)
+
+    def test_missing_geometry(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.read_shp(self.path)
+
+
+class TestMissingAttrWrite:
+    def setup_method(self):
+        self.setup_path()
+        self.delete_shapedir()
+
+    def teardown_method(self):
+        self.delete_shapedir()
+
+    def setup_path(self):
+        self.path = os.path.join(tempfile.gettempdir(), "missing_attributes")
+
+    def delete_shapedir(self):
+        drv = ogr.GetDriverByName("ESRI Shapefile")
+        if os.path.exists(self.path):
+            drv.DeleteDataSource(self.path)
+
+    def test_missing_attributes(self):
+        G = nx.DiGraph()
+        A = (0, 0)
+        B = (1, 1)
+        C = (2, 2)
+        G.add_edge(A, B, foo=100)
+        G.add_edge(A, C)
+
+        nx.write_shp(G, self.path)
+        H = nx.read_shp(self.path)
+
+        for u, v, d in H.edges(data=True):
+            if u == A and v == B:
+                assert d["foo"] == 100
+            if u == A and v == C:
+                assert d["foo"] is None
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_sparse6.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_sparse6.py
new file mode 100644
index 0000000..c8b5e4d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_sparse6.py
@@ -0,0 +1,173 @@
+import tempfile
+from io import BytesIO
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, nodes_equal
+
+
+class TestSparseGraph6:
+    def test_from_sparse6_bytes(self):
+        data = b":Q___eDcdFcDeFcE`GaJ`IaHbKNbLM"
+        G = nx.from_sparse6_bytes(data)
+        assert nodes_equal(
+            sorted(G.nodes()),
+            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17],
+        )
+        assert edges_equal(
+            G.edges(),
+            [
+                (0, 1),
+                (0, 2),
+                (0, 3),
+                (1, 12),
+                (1, 14),
+                (2, 13),
+                (2, 15),
+                (3, 16),
+                (3, 17),
+                (4, 7),
+                (4, 9),
+                (4, 11),
+                (5, 6),
+                (5, 8),
+                (5, 9),
+                (6, 10),
+                (6, 11),
+                (7, 8),
+                (7, 10),
+                (8, 12),
+                (9, 15),
+                (10, 14),
+                (11, 13),
+                (12, 16),
+                (13, 17),
+                (14, 17),
+                (15, 16),
+            ],
+        )
+
+    def test_from_bytes_multigraph_graph(self):
+        graph_data = b":An"
+        G = nx.from_sparse6_bytes(graph_data)
+        assert type(G) == nx.Graph
+        multigraph_data = b":Ab"
+        M = nx.from_sparse6_bytes(multigraph_data)
+        assert type(M) == nx.MultiGraph
+
+    def test_read_sparse6(self):
+        data = b":Q___eDcdFcDeFcE`GaJ`IaHbKNbLM"
+        G = nx.from_sparse6_bytes(data)
+        fh = BytesIO(data)
+        Gin = nx.read_sparse6(fh)
+        assert nodes_equal(G.nodes(), Gin.nodes())
+        assert edges_equal(G.edges(), Gin.edges())
+
+    def test_read_many_graph6(self):
+        # Read many graphs into list
+        data = b":Q___eDcdFcDeFcE`GaJ`IaHbKNbLM\n" b":Q___dCfDEdcEgcbEGbFIaJ`JaHN`IM"
+        fh = BytesIO(data)
+        glist = nx.read_sparse6(fh)
+        assert len(glist) == 2
+        for G in glist:
+            assert nodes_equal(
+                G.nodes(),
+                [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17],
+            )
+
+
+class TestWriteSparse6:
+    """Unit tests for writing graphs in the sparse6 format.
+
+    Most of the test cases were checked against the sparse6 encoder in Sage.
+
+    """
+
+    def test_null_graph(self):
+        G = nx.null_graph()
+        result = BytesIO()
+        nx.write_sparse6(G, result)
+        assert result.getvalue() == b">>sparse6<<:?\n"
+
+    def test_trivial_graph(self):
+        G = nx.trivial_graph()
+        result = BytesIO()
+        nx.write_sparse6(G, result)
+        assert result.getvalue() == b">>sparse6<<:@\n"
+
+    def test_empty_graph(self):
+        G = nx.empty_graph(5)
+        result = BytesIO()
+        nx.write_sparse6(G, result)
+        assert result.getvalue() == b">>sparse6<<:D\n"
+
+    def test_large_empty_graph(self):
+        G = nx.empty_graph(68)
+        result = BytesIO()
+        nx.write_sparse6(G, result)
+        assert result.getvalue() == b">>sparse6<<:~?@C\n"
+
+    def test_very_large_empty_graph(self):
+        G = nx.empty_graph(258049)
+        result = BytesIO()
+        nx.write_sparse6(G, result)
+        assert result.getvalue() == b">>sparse6<<:~~???~?@\n"
+
+    def test_complete_graph(self):
+        G = nx.complete_graph(4)
+        result = BytesIO()
+        nx.write_sparse6(G, result)
+        assert result.getvalue() == b">>sparse6<<:CcKI\n"
+
+    def test_no_header(self):
+        G = nx.complete_graph(4)
+        result = BytesIO()
+        nx.write_sparse6(G, result, header=False)
+        assert result.getvalue() == b":CcKI\n"
+
+    def test_padding(self):
+        codes = (b":Cdv", b":DaYn", b":EaYnN", b":FaYnL", b":GaYnLz")
+        for n, code in enumerate(codes, start=4):
+            G = nx.path_graph(n)
+            result = BytesIO()
+            nx.write_sparse6(G, result, header=False)
+            assert result.getvalue() == code + b"\n"
+
+    def test_complete_bipartite(self):
+        G = nx.complete_bipartite_graph(6, 9)
+        result = BytesIO()
+        nx.write_sparse6(G, result)
+        # Compared with sage
+        expected = b">>sparse6<<:Nk" + b"?G`cJ" * 9 + b"\n"
+        assert result.getvalue() == expected
+
+    def test_read_write_inverse(self):
+        for i in list(range(13)) + [31, 47, 62, 63, 64, 72]:
+            m = min(2 * i, i * i // 2)
+            g = nx.random_graphs.gnm_random_graph(i, m, seed=i)
+            gstr = BytesIO()
+            nx.write_sparse6(g, gstr, header=False)
+            # Strip the trailing newline.
+            gstr = gstr.getvalue().rstrip()
+            g2 = nx.from_sparse6_bytes(gstr)
+            assert g2.order() == g.order()
+            assert edges_equal(g2.edges(), g.edges())
+
+    def test_no_directed_graphs(self):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            nx.write_sparse6(nx.DiGraph(), BytesIO())
+
+    def test_write_path(self):
+        # On Windows, we can't reopen a file that is open
+        # So, for test we get a valid name from tempfile but close it.
+        with tempfile.NamedTemporaryFile() as f:
+            fullfilename = f.name
+        # file should be closed now, so write_sparse6 can open it
+        nx.write_sparse6(nx.null_graph(), fullfilename)
+        fh = open(fullfilename, mode="rb")
+        assert fh.read() == b">>sparse6<<:?\n"
+        fh.close()
+        import os
+
+        os.remove(fullfilename)
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_text.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_text.py
new file mode 100644
index 0000000..4cd618c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/tests/test_text.py
@@ -0,0 +1,317 @@
+from textwrap import dedent
+
+import pytest
+
+import networkx as nx
+
+
+def test_directed_tree_str():
+    # Create a directed forest with labels
+    graph = nx.balanced_tree(r=2, h=2, create_using=nx.DiGraph)
+    for node in graph.nodes:
+        graph.nodes[node]["label"] = "node_" + chr(ord("a") + node)
+
+    node_target = dedent(
+        """
+        ╙── 0
+            ├─╼ 1
+            │   ├─╼ 3
+            │   └─╼ 4
+            └─╼ 2
+                ├─╼ 5
+                └─╼ 6
+        """
+    ).strip()
+
+    label_target = dedent(
+        """
+        ╙── node_a
+            ├─╼ node_b
+            │   ├─╼ node_d
+            │   └─╼ node_e
+            └─╼ node_c
+                ├─╼ node_f
+                └─╼ node_g
+        """
+    ).strip()
+
+    # Basic node case
+    ret = nx.forest_str(graph, with_labels=False)
+    print(ret)
+    assert ret == node_target
+
+    # Basic label case
+    ret = nx.forest_str(graph, with_labels=True)
+    print(ret)
+    assert ret == label_target
+
+    # Custom write function case
+    lines = []
+    ret = nx.forest_str(graph, write=lines.append, with_labels=False)
+    assert ret is None
+    assert lines == node_target.split("\n")
+
+    # Smoke test to ensure passing the print function works. To properly test
+    # this case we would need to capture stdout. (for potential reference
+    # implementation see :class:`ubelt.util_stream.CaptureStdout`)
+    ret = nx.forest_str(graph, write=print)
+    assert ret is None
+
+
+def test_empty_graph():
+    assert nx.forest_str(nx.DiGraph()) == "╙"
+    assert nx.forest_str(nx.Graph()) == "╙"
+
+
+def test_directed_multi_tree_forest():
+    tree1 = nx.balanced_tree(r=2, h=2, create_using=nx.DiGraph)
+    tree2 = nx.balanced_tree(r=2, h=2, create_using=nx.DiGraph)
+    forest = nx.disjoint_union_all([tree1, tree2])
+    ret = nx.forest_str(forest)
+    print(ret)
+
+    target = dedent(
+        """
+        ╟── 0
+        ╎   ├─╼ 1
+        ╎   │   ├─╼ 3
+        ╎   │   └─╼ 4
+        ╎   └─╼ 2
+        ╎       ├─╼ 5
+        ╎       └─╼ 6
+        ╙── 7
+            ├─╼ 8
+            │   ├─╼ 10
+            │   └─╼ 11
+            └─╼ 9
+                ├─╼ 12
+                └─╼ 13
+        """
+    ).strip()
+    assert ret == target
+
+    tree3 = nx.balanced_tree(r=2, h=2, create_using=nx.DiGraph)
+    forest = nx.disjoint_union_all([tree1, tree2, tree3])
+    ret = nx.forest_str(forest, sources=[0, 14, 7])
+    print(ret)
+
+    target = dedent(
+        """
+        ╟── 0
+        ╎   ├─╼ 1
+        ╎   │   ├─╼ 3
+        ╎   │   └─╼ 4
+        ╎   └─╼ 2
+        ╎       ├─╼ 5
+        ╎       └─╼ 6
+        ╟── 14
+        ╎   ├─╼ 15
+        ╎   │   ├─╼ 17
+        ╎   │   └─╼ 18
+        ╎   └─╼ 16
+        ╎       ├─╼ 19
+        ╎       └─╼ 20
+        ╙── 7
+            ├─╼ 8
+            │   ├─╼ 10
+            │   └─╼ 11
+            └─╼ 9
+                ├─╼ 12
+                └─╼ 13
+        """
+    ).strip()
+    assert ret == target
+
+    ret = nx.forest_str(forest, sources=[0, 14, 7], ascii_only=True)
+    print(ret)
+
+    target = dedent(
+        """
+        +-- 0
+        :   |-> 1
+        :   |   |-> 3
+        :   |   L-> 4
+        :   L-> 2
+        :       |-> 5
+        :       L-> 6
+        +-- 14
+        :   |-> 15
+        :   |   |-> 17
+        :   |   L-> 18
+        :   L-> 16
+        :       |-> 19
+        :       L-> 20
+        +-- 7
+            |-> 8
+            |   |-> 10
+            |   L-> 11
+            L-> 9
+                |-> 12
+                L-> 13
+        """
+    ).strip()
+    assert ret == target
+
+
+def test_undirected_multi_tree_forest():
+    tree1 = nx.balanced_tree(r=2, h=2, create_using=nx.Graph)
+    tree2 = nx.balanced_tree(r=2, h=2, create_using=nx.Graph)
+    tree2 = nx.relabel_nodes(tree2, {n: n + len(tree1) for n in tree2.nodes})
+    forest = nx.union(tree1, tree2)
+    ret = nx.forest_str(forest, sources=[0, 7])
+    print(ret)
+
+    target = dedent(
+        """
+        ╟── 0
+        ╎   ├── 1
+        ╎   │   ├── 3
+        ╎   │   └── 4
+        ╎   └── 2
+        ╎       ├── 5
+        ╎       └── 6
+        ╙── 7
+            ├── 8
+            │   ├── 10
+            │   └── 11
+            └── 9
+                ├── 12
+                └── 13
+        """
+    ).strip()
+    assert ret == target
+
+    ret = nx.forest_str(forest, sources=[0, 7], ascii_only=True)
+    print(ret)
+
+    target = dedent(
+        """
+        +-- 0
+        :   |-- 1
+        :   |   |-- 3
+        :   |   L-- 4
+        :   L-- 2
+        :       |-- 5
+        :       L-- 6
+        +-- 7
+            |-- 8
+            |   |-- 10
+            |   L-- 11
+            L-- 9
+                |-- 12
+                L-- 13
+        """
+    ).strip()
+    assert ret == target
+
+
+def test_undirected_tree_str():
+    # Create a directed forest with labels
+    graph = nx.balanced_tree(r=2, h=2, create_using=nx.Graph)
+
+    # arbitrary starting point
+    nx.forest_str(graph)
+
+    node_target0 = dedent(
+        """
+        ╙── 0
+            ├── 1
+            │   ├── 3
+            │   └── 4
+            └── 2
+                ├── 5
+                └── 6
+        """
+    ).strip()
+
+    # defined starting point
+    ret = nx.forest_str(graph, sources=[0])
+    print(ret)
+    assert ret == node_target0
+
+    # defined starting point
+    node_target2 = dedent(
+        """
+        ╙── 2
+            ├── 0
+            │   └── 1
+            │       ├── 3
+            │       └── 4
+            ├── 5
+            └── 6
+        """
+    ).strip()
+    ret = nx.forest_str(graph, sources=[2])
+    print(ret)
+    assert ret == node_target2
+
+
+def test_forest_str_errors():
+    ugraph = nx.complete_graph(3, create_using=nx.Graph)
+
+    with pytest.raises(nx.NetworkXNotImplemented):
+        nx.forest_str(ugraph)
+
+    dgraph = nx.complete_graph(3, create_using=nx.DiGraph)
+
+    with pytest.raises(nx.NetworkXNotImplemented):
+        nx.forest_str(dgraph)
+
+
+def test_overspecified_sources():
+    """
+    When sources are directly specified, we wont be able to determine when we
+    are in the last component, so there will always be a trailing, leftmost
+    pipe.
+    """
+    graph = nx.disjoint_union_all(
+        [
+            nx.balanced_tree(r=2, h=1, create_using=nx.DiGraph),
+            nx.balanced_tree(r=1, h=2, create_using=nx.DiGraph),
+            nx.balanced_tree(r=2, h=1, create_using=nx.DiGraph),
+        ]
+    )
+
+    # defined starting point
+    target1 = dedent(
+        """
+        ╟── 0
+        ╎   ├─╼ 1
+        ╎   └─╼ 2
+        ╟── 3
+        ╎   └─╼ 4
+        ╎       └─╼ 5
+        ╟── 6
+        ╎   ├─╼ 7
+        ╎   └─╼ 8
+        """
+    ).strip()
+
+    target2 = dedent(
+        """
+        ╟── 0
+        ╎   ├─╼ 1
+        ╎   └─╼ 2
+        ╟── 3
+        ╎   └─╼ 4
+        ╎       └─╼ 5
+        ╙── 6
+            ├─╼ 7
+            └─╼ 8
+        """
+    ).strip()
+
+    lines = []
+    nx.forest_str(graph, write=lines.append, sources=graph.nodes)
+    got1 = chr(10).join(lines)
+    print("got1: ")
+    print(got1)
+
+    lines = []
+    nx.forest_str(graph, write=lines.append)
+    got2 = chr(10).join(lines)
+    print("got2: ")
+    print(got2)
+
+    assert got1 == target1
+    assert got2 == target2
diff --git a/myenv/lib/python3.9/site-packages/networkx/readwrite/text.py b/myenv/lib/python3.9/site-packages/networkx/readwrite/text.py
new file mode 100644
index 0000000..b38b08d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/readwrite/text.py
@@ -0,0 +1,192 @@
+"""
+Text-based visual representations of graphs
+"""
+
+__all__ = ["forest_str"]
+
+
+def forest_str(graph, with_labels=True, sources=None, write=None, ascii_only=False):
+    """
+    Creates a nice utf8 representation of a directed forest
+
+    Parameters
+    ----------
+    graph : nx.DiGraph | nx.Graph
+        Graph to represent (must be a tree, forest, or the empty graph)
+
+    with_labels : bool
+        If True will use the "label" attribute of a node to display if it
+        exists otherwise it will use the node value itself. Defaults to True.
+
+    sources : List
+        Mainly relevant for undirected forests, specifies which nodes to list
+        first. If unspecified the root nodes of each tree will be used for
+        directed forests; for undirected forests this defaults to the nodes
+        with the smallest degree.
+
+    write : callable
+        Function to use to write to, if None new lines are appended to
+        a list and returned. If set to the `print` function, lines will
+        be written to stdout as they are generated. If specified,
+        this function will return None. Defaults to None.
+
+    ascii_only : Boolean
+        If True only ASCII characters are used to construct the visualization
+
+    Returns
+    -------
+    str | None :
+        utf8 representation of the tree / forest
+
+    Example
+    -------
+    >>> graph = nx.balanced_tree(r=2, h=3, create_using=nx.DiGraph)
+    >>> print(nx.forest_str(graph))
+    ╙── 0
+        ├─╼ 1
+        │   ├─╼ 3
+        │   │   ├─╼ 7
+        │   │   └─╼ 8
+        │   └─╼ 4
+        │       ├─╼ 9
+        │       └─╼ 10
+        └─╼ 2
+            ├─╼ 5
+            │   ├─╼ 11
+            │   └─╼ 12
+            └─╼ 6
+                ├─╼ 13
+                └─╼ 14
+
+
+    >>> graph = nx.balanced_tree(r=1, h=2, create_using=nx.Graph)
+    >>> print(nx.forest_str(graph))
+    ╙── 0
+        └── 1
+            └── 2
+
+    >>> print(nx.forest_str(graph, ascii_only=True))
+    +-- 0
+        L-- 1
+            L-- 2
+    """
+    import networkx as nx
+
+    printbuf = []
+    if write is None:
+        _write = printbuf.append
+    else:
+        _write = write
+
+    # Define glphys
+    # Notes on available box and arrow characters
+    # https://en.wikipedia.org/wiki/Box-drawing_character
+    # https://stackoverflow.com/questions/2701192/triangle-arrow
+    if ascii_only:
+        glyph_empty = "+"
+        glyph_newtree_last = "+-- "
+        glyph_newtree_mid = "+-- "
+        glyph_endof_forest = "    "
+        glyph_within_forest = ":   "
+        glyph_within_tree = "|   "
+
+        glyph_directed_last = "L-> "
+        glyph_directed_mid = "|-> "
+
+        glyph_undirected_last = "L-- "
+        glyph_undirected_mid = "|-- "
+    else:
+        glyph_empty = "╙"
+        glyph_newtree_last = "╙── "
+        glyph_newtree_mid = "╟── "
+        glyph_endof_forest = "    "
+        glyph_within_forest = "╎   "
+        glyph_within_tree = "│   "
+
+        glyph_directed_last = "└─╼ "
+        glyph_directed_mid = "├─╼ "
+
+        glyph_undirected_last = "└── "
+        glyph_undirected_mid = "├── "
+
+    if len(graph.nodes) == 0:
+        _write(glyph_empty)
+    else:
+        if not nx.is_forest(graph):
+            raise nx.NetworkXNotImplemented("input must be a forest or the empty graph")
+
+        is_directed = graph.is_directed()
+        succ = graph.succ if is_directed else graph.adj
+
+        if sources is None:
+            if is_directed:
+                # use real source nodes for directed trees
+                sources = [n for n in graph.nodes if graph.in_degree[n] == 0]
+            else:
+                # use arbitrary sources for undirected trees
+                sources = [
+                    min(cc, key=lambda n: graph.degree[n])
+                    for cc in nx.connected_components(graph)
+                ]
+
+        # Populate the stack with each source node, empty indentation, and mark
+        # the final node. Reverse the stack so sources are popped in the
+        # correct order.
+        last_idx = len(sources) - 1
+        stack = [(node, "", (idx == last_idx)) for idx, node in enumerate(sources)][
+            ::-1
+        ]
+
+        seen = set()
+        while stack:
+            node, indent, islast = stack.pop()
+            if node in seen:
+                continue
+            seen.add(node)
+
+            if not indent:
+                # Top level items (i.e. trees in the forest) get different
+                # glyphs to indicate they are not actually connected
+                if islast:
+                    this_prefix = indent + glyph_newtree_last
+                    next_prefix = indent + glyph_endof_forest
+                else:
+                    this_prefix = indent + glyph_newtree_mid
+                    next_prefix = indent + glyph_within_forest
+
+            else:
+                # For individual tree edges distinguish between directed and
+                # undirected cases
+                if is_directed:
+                    if islast:
+                        this_prefix = indent + glyph_directed_last
+                        next_prefix = indent + glyph_endof_forest
+                    else:
+                        this_prefix = indent + glyph_directed_mid
+                        next_prefix = indent + glyph_within_tree
+                else:
+                    if islast:
+                        this_prefix = indent + glyph_undirected_last
+                        next_prefix = indent + glyph_endof_forest
+                    else:
+                        this_prefix = indent + glyph_undirected_mid
+                        next_prefix = indent + glyph_within_tree
+
+            if with_labels:
+                label = graph.nodes[node].get("label", node)
+            else:
+                label = node
+
+            _write(this_prefix + str(label))
+
+            # Push children on the stack in reverse order so they are popped in
+            # the original order.
+            children = [child for child in succ[node] if child not in seen]
+            for idx, child in enumerate(children[::-1], start=1):
+                islast_next = idx <= 1
+                try_frame = (child, next_prefix, islast_next)
+                stack.append(try_frame)
+
+    if write is None:
+        # Only return a string if the custom write function was not specified
+        return "\n".join(printbuf)
diff --git a/myenv/lib/python3.9/site-packages/networkx/relabel.py b/myenv/lib/python3.9/site-packages/networkx/relabel.py
new file mode 100644
index 0000000..80d973a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/relabel.py
@@ -0,0 +1,282 @@
+import networkx as nx
+
+__all__ = ["convert_node_labels_to_integers", "relabel_nodes"]
+
+
+def relabel_nodes(G, mapping, copy=True):
+    """Relabel the nodes of the graph G according to a given mapping.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    mapping : dictionary
+       A dictionary with the old labels as keys and new labels as values.
+       A partial mapping is allowed. Mapping 2 nodes to a single node is allowed.
+       Any non-node keys in the mapping are ignored.
+
+    copy : bool (optional, default=True)
+       If True return a copy, or if False relabel the nodes in place.
+
+    Examples
+    --------
+    To create a new graph with nodes relabeled according to a given
+    dictionary:
+
+    >>> G = nx.path_graph(3)
+    >>> sorted(G)
+    [0, 1, 2]
+    >>> mapping = {0: "a", 1: "b", 2: "c"}
+    >>> H = nx.relabel_nodes(G, mapping)
+    >>> sorted(H)
+    ['a', 'b', 'c']
+
+    Nodes can be relabeled with any hashable object, including numbers
+    and strings:
+
+    >>> import string
+    >>> G = nx.path_graph(26)  # nodes are integers 0 through 25
+    >>> sorted(G)[:3]
+    [0, 1, 2]
+    >>> mapping = dict(zip(G, string.ascii_lowercase))
+    >>> G = nx.relabel_nodes(G, mapping)  # nodes are characters a through z
+    >>> sorted(G)[:3]
+    ['a', 'b', 'c']
+    >>> mapping = dict(zip(G, range(1, 27)))
+    >>> G = nx.relabel_nodes(G, mapping)  # nodes are integers 1 through 26
+    >>> sorted(G)[:3]
+    [1, 2, 3]
+
+    To perform a partial in-place relabeling, provide a dictionary
+    mapping only a subset of the nodes, and set the `copy` keyword
+    argument to False:
+
+    >>> G = nx.path_graph(3)  # nodes 0-1-2
+    >>> mapping = {0: "a", 1: "b"}  # 0->'a' and 1->'b'
+    >>> G = nx.relabel_nodes(G, mapping, copy=False)
+    >>> sorted(G, key=str)
+    [2, 'a', 'b']
+
+    A mapping can also be given as a function:
+
+    >>> G = nx.path_graph(3)
+    >>> H = nx.relabel_nodes(G, lambda x: x ** 2)
+    >>> list(H)
+    [0, 1, 4]
+
+    In a multigraph, relabeling two or more nodes to the same new node
+    will retain all edges, but may change the edge keys in the process:
+
+    >>> G = nx.MultiGraph()
+    >>> G.add_edge(0, 1, value="a")  # returns the key for this edge
+    0
+    >>> G.add_edge(0, 2, value="b")
+    0
+    >>> G.add_edge(0, 3, value="c")
+    0
+    >>> mapping = {1: 4, 2: 4, 3: 4}
+    >>> H = nx.relabel_nodes(G, mapping, copy=True)
+    >>> print(H[0])
+    {4: {0: {'value': 'a'}, 1: {'value': 'b'}, 2: {'value': 'c'}}}
+
+    This works for in-place relabeling too:
+
+    >>> G = nx.relabel_nodes(G, mapping, copy=False)
+    >>> print(G[0])
+    {4: {0: {'value': 'a'}, 1: {'value': 'b'}, 2: {'value': 'c'}}}
+
+    Notes
+    -----
+    Only the nodes specified in the mapping will be relabeled.
+    Any non-node keys in the mapping are ignored.
+
+    The keyword setting copy=False modifies the graph in place.
+    Relabel_nodes avoids naming collisions by building a
+    directed graph from ``mapping`` which specifies the order of
+    relabelings. Naming collisions, such as a->b, b->c, are ordered
+    such that "b" gets renamed to "c" before "a" gets renamed "b".
+    In cases of circular mappings (e.g. a->b, b->a), modifying the
+    graph is not possible in-place and an exception is raised.
+    In that case, use copy=True.
+
+    If a relabel operation on a multigraph would cause two or more
+    edges to have the same source, target and key, the second edge must
+    be assigned a new key to retain all edges. The new key is set
+    to the lowest non-negative integer not already used as a key
+    for edges between these two nodes. Note that this means non-numeric
+    keys may be replaced by numeric keys.
+
+    See Also
+    --------
+    convert_node_labels_to_integers
+    """
+    # you can pass a function f(old_label)->new_label
+    # but we'll just make a dictionary here regardless
+    if not hasattr(mapping, "__getitem__"):
+        m = {n: mapping(n) for n in G}
+    else:
+        m = mapping
+    if copy:
+        return _relabel_copy(G, m)
+    else:
+        return _relabel_inplace(G, m)
+
+
+def _relabel_inplace(G, mapping):
+    old_labels = set(mapping.keys())
+    new_labels = set(mapping.values())
+    if len(old_labels & new_labels) > 0:
+        # labels sets overlap
+        # can we topological sort and still do the relabeling?
+        D = nx.DiGraph(list(mapping.items()))
+        D.remove_edges_from(nx.selfloop_edges(D))
+        try:
+            nodes = reversed(list(nx.topological_sort(D)))
+        except nx.NetworkXUnfeasible as err:
+            raise nx.NetworkXUnfeasible(
+                "The node label sets are overlapping and no ordering can "
+                "resolve the mapping. Use copy=True."
+            ) from err
+    else:
+        # non-overlapping label sets
+        nodes = old_labels
+
+    multigraph = G.is_multigraph()
+    directed = G.is_directed()
+
+    for old in nodes:
+        # Test that old is in both mapping and G, otherwise ignore.
+        try:
+            new = mapping[old]
+            G.add_node(new, **G.nodes[old])
+        except KeyError:
+            continue
+        if new == old:
+            continue
+        if multigraph:
+            new_edges = [
+                (new, new if old == target else target, key, data)
+                for (_, target, key, data) in G.edges(old, data=True, keys=True)
+            ]
+            if directed:
+                new_edges += [
+                    (new if old == source else source, new, key, data)
+                    for (source, _, key, data) in G.in_edges(old, data=True, keys=True)
+                ]
+            # Ensure new edges won't overwrite existing ones
+            seen = set()
+            for i, (source, target, key, data) in enumerate(new_edges):
+                if target in G[source] and key in G[source][target]:
+                    new_key = 0 if not isinstance(key, (int, float)) else key
+                    while new_key in G[source][target] or (target, new_key) in seen:
+                        new_key += 1
+                    new_edges[i] = (source, target, new_key, data)
+                    seen.add((target, new_key))
+        else:
+            new_edges = [
+                (new, new if old == target else target, data)
+                for (_, target, data) in G.edges(old, data=True)
+            ]
+            if directed:
+                new_edges += [
+                    (new if old == source else source, new, data)
+                    for (source, _, data) in G.in_edges(old, data=True)
+                ]
+        G.remove_node(old)
+        G.add_edges_from(new_edges)
+    return G
+
+
+def _relabel_copy(G, mapping):
+    H = G.__class__()
+    H.add_nodes_from(mapping.get(n, n) for n in G)
+    H._node.update((mapping.get(n, n), d.copy()) for n, d in G.nodes.items())
+    if G.is_multigraph():
+        new_edges = [
+            (mapping.get(n1, n1), mapping.get(n2, n2), k, d.copy())
+            for (n1, n2, k, d) in G.edges(keys=True, data=True)
+        ]
+
+        # check for conflicting edge-keys
+        undirected = not G.is_directed()
+        seen_edges = set()
+        for i, (source, target, key, data) in enumerate(new_edges):
+            while (source, target, key) in seen_edges:
+                if not isinstance(key, (int, float)):
+                    key = 0
+                key += 1
+            seen_edges.add((source, target, key))
+            if undirected:
+                seen_edges.add((target, source, key))
+            new_edges[i] = (source, target, key, data)
+
+        H.add_edges_from(new_edges)
+    else:
+        H.add_edges_from(
+            (mapping.get(n1, n1), mapping.get(n2, n2), d.copy())
+            for (n1, n2, d) in G.edges(data=True)
+        )
+    H.graph.update(G.graph)
+    return H
+
+
+def convert_node_labels_to_integers(
+    G, first_label=0, ordering="default", label_attribute=None
+):
+    """Returns a copy of the graph G with the nodes relabeled using
+    consecutive integers.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    first_label : int, optional (default=0)
+       An integer specifying the starting offset in numbering nodes.
+       The new integer labels are numbered first_label, ..., n-1+first_label.
+
+    ordering : string
+       "default" : inherit node ordering from G.nodes()
+       "sorted"  : inherit node ordering from sorted(G.nodes())
+       "increasing degree" : nodes are sorted by increasing degree
+       "decreasing degree" : nodes are sorted by decreasing degree
+
+    label_attribute : string, optional (default=None)
+       Name of node attribute to store old label.  If None no attribute
+       is created.
+
+    Notes
+    -----
+    Node and edge attribute data are copied to the new (relabeled) graph.
+
+    There is no guarantee that the relabeling of nodes to integers will
+    give the same two integers for two (even identical graphs).
+    Use the `ordering` argument to try to preserve the order.
+
+    See Also
+    --------
+    relabel_nodes
+    """
+    N = G.number_of_nodes() + first_label
+    if ordering == "default":
+        mapping = dict(zip(G.nodes(), range(first_label, N)))
+    elif ordering == "sorted":
+        nlist = sorted(G.nodes())
+        mapping = dict(zip(nlist, range(first_label, N)))
+    elif ordering == "increasing degree":
+        dv_pairs = [(d, n) for (n, d) in G.degree()]
+        dv_pairs.sort()  # in-place sort from lowest to highest degree
+        mapping = dict(zip([n for d, n in dv_pairs], range(first_label, N)))
+    elif ordering == "decreasing degree":
+        dv_pairs = [(d, n) for (n, d) in G.degree()]
+        dv_pairs.sort()  # in-place sort from lowest to highest degree
+        dv_pairs.reverse()
+        mapping = dict(zip([n for d, n in dv_pairs], range(first_label, N)))
+    else:
+        raise nx.NetworkXError(f"Unknown node ordering: {ordering}")
+    H = relabel_nodes(G, mapping)
+    # create node attribute with the old label
+    if label_attribute is not None:
+        nx.set_node_attributes(H, {v: k for k, v in mapping.items()}, label_attribute)
+    return H
diff --git a/myenv/lib/python3.9/site-packages/networkx/testing/__init__.py b/myenv/lib/python3.9/site-packages/networkx/testing/__init__.py
new file mode 100644
index 0000000..884ac83
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/testing/__init__.py
@@ -0,0 +1,2 @@
+from networkx.testing.utils import *
+from networkx.testing.test import run
diff --git a/myenv/lib/python3.9/site-packages/networkx/testing/test.py b/myenv/lib/python3.9/site-packages/networkx/testing/test.py
new file mode 100644
index 0000000..41739be
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/testing/test.py
@@ -0,0 +1,44 @@
+import warnings
+
+
+def run(verbosity=1, doctest=False):
+    """Run NetworkX tests.
+
+    Parameters
+    ----------
+    verbosity: integer, optional
+      Level of detail in test reports.  Higher numbers provide more detail.
+
+    doctest: bool, optional
+      True to run doctests in code modules
+    """
+    warnings.warn(
+        (
+            "`run` is deprecated and will be removed in version 3.0.\n"
+            "Call `pytest` directly from the commandline instead.\n"
+        ),
+        DeprecationWarning,
+    )
+
+    import pytest
+
+    pytest_args = ["-l"]
+
+    if verbosity and int(verbosity) > 1:
+        pytest_args += ["-" + "v" * (int(verbosity) - 1)]
+
+    if doctest:
+        pytest_args += ["--doctest-modules"]
+
+    pytest_args += ["--pyargs", "networkx"]
+
+    try:
+        code = pytest.main(pytest_args)
+    except SystemExit as err:
+        code = err.code
+
+    return code == 0
+
+
+if __name__ == "__main__":
+    run()
diff --git a/myenv/lib/python3.9/site-packages/networkx/testing/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/testing/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/testing/tests/test_utils.py b/myenv/lib/python3.9/site-packages/networkx/testing/tests/test_utils.py
new file mode 100644
index 0000000..32804f3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/testing/tests/test_utils.py
@@ -0,0 +1,160 @@
+import networkx as nx
+from networkx.testing import assert_edges_equal, assert_graphs_equal, assert_nodes_equal
+
+# thanks to numpy for this GenericTest class (numpy/testing/test_utils.py)
+
+
+class _GenericTest:
+    @classmethod
+    def _test_equal(cls, a, b):
+        cls._assert_func(a, b)
+
+    @classmethod
+    def _test_not_equal(cls, a, b):
+        try:
+            cls._assert_func(a, b)
+            passed = True
+        except AssertionError:
+            pass
+        else:
+            raise AssertionError("a and b are found equal but are not")
+
+
+class TestNodesEqual(_GenericTest):
+    _assert_func = assert_nodes_equal
+
+    def test_nodes_equal(self):
+        a = [1, 2, 5, 4]
+        b = [4, 5, 1, 2]
+        self._test_equal(a, b)
+
+    def test_nodes_not_equal(self):
+        a = [1, 2, 5, 4]
+        b = [4, 5, 1, 3]
+        self._test_not_equal(a, b)
+
+    def test_nodes_with_data_equal(self):
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3], color="red")
+        H = nx.Graph()
+        H.add_nodes_from([1, 2, 3], color="red")
+        self._test_equal(G.nodes(data=True), H.nodes(data=True))
+
+    def test_edges_with_data_not_equal(self):
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3], color="red")
+        H = nx.Graph()
+        H.add_nodes_from([1, 2, 3], color="blue")
+        self._test_not_equal(G.nodes(data=True), H.nodes(data=True))
+
+
+class TestEdgesEqual(_GenericTest):
+    _assert_func = assert_edges_equal
+
+    def test_edges_equal(self):
+        a = [(1, 2), (5, 4)]
+        b = [(4, 5), (1, 2)]
+        self._test_equal(a, b)
+
+    def test_edges_not_equal(self):
+        a = [(1, 2), (5, 4)]
+        b = [(4, 5), (1, 3)]
+        self._test_not_equal(a, b)
+
+    def test_edges_with_data_equal(self):
+        G = nx.MultiGraph()
+        nx.add_path(G, [0, 1, 2], weight=1)
+        H = nx.MultiGraph()
+        nx.add_path(H, [0, 1, 2], weight=1)
+        self._test_equal(G.edges(data=True, keys=True), H.edges(data=True, keys=True))
+
+    def test_edges_with_data_not_equal(self):
+        G = nx.MultiGraph()
+        nx.add_path(G, [0, 1, 2], weight=1)
+        H = nx.MultiGraph()
+        nx.add_path(H, [0, 1, 2], weight=2)
+        self._test_not_equal(
+            G.edges(data=True, keys=True), H.edges(data=True, keys=True)
+        )
+
+    def test_no_edges(self):
+        G = nx.MultiGraph()
+        H = nx.MultiGraph()
+        self._test_equal(G.edges(data=True, keys=True), H.edges(data=True, keys=True))
+
+    def test_duplicate_edges(self):
+        a = [(1, 2), (5, 4), (1, 2)]
+        b = [(4, 5), (1, 2)]
+        self._test_not_equal(a, b)
+
+    def test_duplicate_edges_with_data(self):
+        a = [(1, 2, {"weight": 10}), (5, 4), (1, 2, {"weight": 1})]
+        b = [(4, 5), (1, 2), (1, 2, {"weight": 1})]
+        self._test_not_equal(a, b)
+
+    def test_order_of_edges_with_data(self):
+        a = [(1, 2, {"weight": 10}), (1, 2, {"weight": 1})]
+        b = [(1, 2, {"weight": 1}), (1, 2, {"weight": 10})]
+        self._test_equal(a, b)
+
+    def test_order_of_multiedges(self):
+        wt1 = {"weight": 1}
+        wt2 = {"weight": 2}
+        a = [(1, 2, wt1), (1, 2, wt1), (1, 2, wt2)]
+        b = [(1, 2, wt1), (1, 2, wt2), (1, 2, wt2)]
+        self._test_not_equal(a, b)
+
+    def test_order_of_edges_with_keys(self):
+        a = [(1, 2, 0, {"weight": 10}), (1, 2, 1, {"weight": 1}), (1, 2, 2)]
+        b = [(1, 2, 1, {"weight": 1}), (1, 2, 2), (1, 2, 0, {"weight": 10})]
+        self._test_equal(a, b)
+        a = [(1, 2, 1, {"weight": 10}), (1, 2, 0, {"weight": 1}), (1, 2, 2)]
+        b = [(1, 2, 1, {"weight": 1}), (1, 2, 2), (1, 2, 0, {"weight": 10})]
+        self._test_not_equal(a, b)
+
+
+class TestGraphsEqual(_GenericTest):
+    _assert_func = assert_graphs_equal
+
+    def test_graphs_equal(self):
+        G = nx.path_graph(4)
+        H = nx.Graph()
+        nx.add_path(H, range(4))
+        self._test_equal(G, H)
+
+    def test_digraphs_equal(self):
+        G = nx.path_graph(4, create_using=nx.DiGraph())
+        H = nx.DiGraph()
+        nx.add_path(H, range(4))
+        self._test_equal(G, H)
+
+    def test_multigraphs_equal(self):
+        G = nx.path_graph(4, create_using=nx.MultiGraph())
+        H = nx.MultiGraph()
+        nx.add_path(H, range(4))
+        self._test_equal(G, H)
+
+    def test_multidigraphs_equal(self):
+        G = nx.path_graph(4, create_using=nx.MultiDiGraph())
+        H = nx.MultiDiGraph()
+        nx.add_path(H, range(4))
+        self._test_equal(G, H)
+
+    def test_graphs_not_equal(self):
+        G = nx.path_graph(4)
+        H = nx.Graph()
+        nx.add_cycle(H, range(4))
+        self._test_not_equal(G, H)
+
+    def test_graphs_not_equal2(self):
+        G = nx.path_graph(4)
+        H = nx.Graph()
+        nx.add_path(H, range(3))
+        self._test_not_equal(G, H)
+
+    def test_graphs_not_equal3(self):
+        G = nx.path_graph(4)
+        H = nx.Graph()
+        nx.add_path(H, range(4))
+        H.name = "path_graph(4)"
+        self._test_not_equal(G, H)
diff --git a/myenv/lib/python3.9/site-packages/networkx/testing/utils.py b/myenv/lib/python3.9/site-packages/networkx/testing/utils.py
new file mode 100644
index 0000000..cf6935d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/testing/utils.py
@@ -0,0 +1,54 @@
+import warnings
+
+from networkx.utils import edges_equal, graphs_equal, nodes_equal
+
+__all__ = [
+    "assert_nodes_equal",
+    "assert_edges_equal",
+    "assert_graphs_equal",
+    "almost_equal",
+]
+
+
+def almost_equal(x, y, places=7):
+    warnings.warn(
+        (
+            "`almost_equal` is deprecated and will be removed in version 3.0.\n"
+            "Use `pytest.approx` instead.\n"
+        ),
+        DeprecationWarning,
+    )
+    return round(abs(x - y), places) == 0
+
+
+def assert_nodes_equal(nodes1, nodes2):
+    warnings.warn(
+        (
+            "`assert_nodes_equal` is deprecated and will be removed in version 3.0.\n"
+            "Use `from networkx.utils import nodes_equal` and `assert nodes_equal` instead.\n"
+        ),
+        DeprecationWarning,
+    )
+    assert nodes_equal(nodes1, nodes2)
+
+
+def assert_edges_equal(edges1, edges2):
+    warnings.warn(
+        (
+            "`assert_edges_equal` is deprecated and will be removed in version 3.0.\n"
+            "Use `from networkx.utils import edges_equal` and `assert edges_equal` instead.\n"
+        ),
+        DeprecationWarning,
+    )
+    assert edges_equal(edges1, edges2)
+
+
+def assert_graphs_equal(graph1, graph2):
+    warnings.warn(
+        (
+            "`assert_graphs_equal` is deprecated and will be removed in version 3.0.\n"
+            "Use `from networkx.utils import graphs_equal` and `assert graphs_equal` instead.\n"
+        ),
+        DeprecationWarning,
+    )
+    assert graphs_equal(graph1, graph2)
diff --git a/myenv/lib/python3.9/site-packages/networkx/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/tests/test_all_random_functions.py b/myenv/lib/python3.9/site-packages/networkx/tests/test_all_random_functions.py
new file mode 100644
index 0000000..e8aaba1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/tests/test_all_random_functions.py
@@ -0,0 +1,247 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+import random
+
+import networkx as nx
+from networkx.algorithms import approximation as approx
+from networkx.algorithms import threshold
+
+progress = 0
+
+# store the random numbers after setting a global seed
+np.random.seed(42)
+np_rv = np.random.rand()
+random.seed(42)
+py_rv = random.random()
+
+
+def t(f, *args, **kwds):
+    """call one function and check if global RNG changed"""
+    global progress
+    progress += 1
+    print(progress, ",", end="")
+
+    f(*args, **kwds)
+
+    after_np_rv = np.random.rand()
+    # if np_rv != after_np_rv:
+    #    print(np_rv, after_np_rv, "don't match np!")
+    assert np_rv == after_np_rv
+    np.random.seed(42)
+
+    after_py_rv = random.random()
+    # if py_rv != after_py_rv:
+    #    print(py_rv, after_py_rv, "don't match py!")
+    assert py_rv == after_py_rv
+    random.seed(42)
+
+
+def run_all_random_functions(seed):
+    n = 20
+    m = 10
+    k = l = 2
+    s = v = 10
+    p = q = p1 = p2 = p_in = p_out = 0.4
+    alpha = radius = theta = 0.75
+    sizes = (20, 20, 10)
+    colors = [1, 2, 3]
+    G = nx.barbell_graph(12, 20)
+    H = nx.cycle_graph(3)
+    H.add_weighted_edges_from((u, v, 0.2) for u, v in H.edges)
+    deg_sequence = [3, 2, 1, 3, 2, 1, 3, 2, 1, 2, 1, 2, 1]
+    in_degree_sequence = w = sequence = aseq = bseq = deg_sequence
+
+    # print("starting...")
+    t(nx.maximal_independent_set, G, seed=seed)
+    t(nx.rich_club_coefficient, G, seed=seed, normalized=False)
+    t(nx.random_reference, G, seed=seed)
+    t(nx.lattice_reference, G, seed=seed)
+    t(nx.sigma, G, 1, 2, seed=seed)
+    t(nx.omega, G, 1, 2, seed=seed)
+    # print("out of smallworld.py")
+    t(nx.double_edge_swap, G, seed=seed)
+    # print("starting connected_double_edge_swap")
+    t(nx.connected_double_edge_swap, nx.complete_graph(9), seed=seed)
+    # print("ending connected_double_edge_swap")
+    t(nx.random_layout, G, seed=seed)
+    t(nx.fruchterman_reingold_layout, G, seed=seed)
+    t(nx.algebraic_connectivity, G, seed=seed)
+    t(nx.fiedler_vector, G, seed=seed)
+    t(nx.spectral_ordering, G, seed=seed)
+    # print('starting average_clustering')
+    t(approx.average_clustering, G, seed=seed)
+    t(approx.simulated_annealing_tsp, H, "greedy", source=1, seed=seed)
+    t(approx.threshold_accepting_tsp, H, "greedy", source=1, seed=seed)
+    t(
+        approx.traveling_salesman_problem,
+        H,
+        method=lambda G, wt: approx.simulated_annealing_tsp(G, "greedy", wt, seed=seed),
+    )
+    t(
+        approx.traveling_salesman_problem,
+        H,
+        method=lambda G, wt: approx.threshold_accepting_tsp(G, "greedy", wt, seed=seed),
+    )
+    t(nx.betweenness_centrality, G, seed=seed)
+    t(nx.edge_betweenness_centrality, G, seed=seed)
+    t(nx.edge_betweenness, G, seed=seed)
+    t(nx.approximate_current_flow_betweenness_centrality, G, seed=seed)
+    # print("kernighan")
+    t(nx.algorithms.community.kernighan_lin_bisection, G, seed=seed)
+    # nx.algorithms.community.asyn_lpa_communities(G, seed=seed)
+    t(nx.algorithms.tree.greedy_branching, G, seed=seed)
+    t(nx.algorithms.tree.Edmonds, G, seed=seed)
+    # print('done with graph argument functions')
+
+    t(nx.spectral_graph_forge, G, alpha, seed=seed)
+    t(nx.algorithms.community.asyn_fluidc, G, k, max_iter=1, seed=seed)
+    t(
+        nx.algorithms.connectivity.edge_augmentation.greedy_k_edge_augmentation,
+        G,
+        k,
+        seed=seed,
+    )
+    t(nx.algorithms.coloring.strategy_random_sequential, G, colors, seed=seed)
+
+    cs = ["d", "i", "i", "d", "d", "i"]
+    t(threshold.swap_d, cs, seed=seed)
+    t(nx.configuration_model, deg_sequence, seed=seed)
+    t(
+        nx.directed_configuration_model,
+        in_degree_sequence,
+        in_degree_sequence,
+        seed=seed,
+    )
+    t(nx.expected_degree_graph, w, seed=seed)
+    t(nx.random_degree_sequence_graph, sequence, seed=seed)
+    joint_degrees = {
+        1: {4: 1},
+        2: {2: 2, 3: 2, 4: 2},
+        3: {2: 2, 4: 1},
+        4: {1: 1, 2: 2, 3: 1},
+    }
+    t(nx.joint_degree_graph, joint_degrees, seed=seed)
+    joint_degree_sequence = [
+        (1, 0),
+        (1, 0),
+        (1, 0),
+        (2, 0),
+        (1, 0),
+        (2, 1),
+        (0, 1),
+        (0, 1),
+    ]
+    t(nx.random_clustered_graph, joint_degree_sequence, seed=seed)
+    constructor = [(3, 3, 0.5), (10, 10, 0.7)]
+    t(nx.random_shell_graph, constructor, seed=seed)
+    mapping = {1: 0.4, 2: 0.3, 3: 0.3}
+    t(nx.utils.random_weighted_sample, mapping, k, seed=seed)
+    t(nx.utils.weighted_choice, mapping, seed=seed)
+    t(nx.algorithms.bipartite.configuration_model, aseq, bseq, seed=seed)
+    t(nx.algorithms.bipartite.preferential_attachment_graph, aseq, p, seed=seed)
+
+    def kernel_integral(u, w, z):
+        return z - w
+
+    t(nx.random_kernel_graph, n, kernel_integral, seed=seed)
+
+    sizes = [75, 75, 300]
+    probs = [[0.25, 0.05, 0.02], [0.05, 0.35, 0.07], [0.02, 0.07, 0.40]]
+    t(nx.stochastic_block_model, sizes, probs, seed=seed)
+    t(nx.random_partition_graph, sizes, p_in, p_out, seed=seed)
+
+    # print("starting generator functions")
+    t(threshold.random_threshold_sequence, n, p, seed=seed)
+    t(nx.tournament.random_tournament, n, seed=seed)
+    t(nx.relaxed_caveman_graph, l, k, p, seed=seed)
+    t(nx.planted_partition_graph, l, k, p_in, p_out, seed=seed)
+    t(nx.gaussian_random_partition_graph, n, s, v, p_in, p_out, seed=seed)
+    t(nx.gn_graph, n, seed=seed)
+    t(nx.gnr_graph, n, p, seed=seed)
+    t(nx.gnc_graph, n, seed=seed)
+    t(nx.scale_free_graph, n, seed=seed)
+    t(nx.directed.random_uniform_k_out_graph, n, k, seed=seed)
+    t(nx.random_k_out_graph, n, k, alpha, seed=seed)
+    N = 1000
+    t(nx.partial_duplication_graph, N, n, p, q, seed=seed)
+    t(nx.duplication_divergence_graph, n, p, seed=seed)
+    t(nx.random_geometric_graph, n, radius, seed=seed)
+    t(nx.soft_random_geometric_graph, n, radius, seed=seed)
+    t(nx.geographical_threshold_graph, n, theta, seed=seed)
+    t(nx.waxman_graph, n, seed=seed)
+    t(nx.navigable_small_world_graph, n, seed=seed)
+    t(nx.thresholded_random_geometric_graph, n, radius, theta, seed=seed)
+    t(nx.uniform_random_intersection_graph, n, m, p, seed=seed)
+    t(nx.k_random_intersection_graph, n, m, k, seed=seed)
+
+    t(nx.general_random_intersection_graph, n, 2, [0.1, 0.5], seed=seed)
+    t(nx.fast_gnp_random_graph, n, p, seed=seed)
+    t(nx.gnp_random_graph, n, p, seed=seed)
+    t(nx.dense_gnm_random_graph, n, m, seed=seed)
+    t(nx.gnm_random_graph, n, m, seed=seed)
+    t(nx.newman_watts_strogatz_graph, n, k, p, seed=seed)
+    t(nx.watts_strogatz_graph, n, k, p, seed=seed)
+    t(nx.connected_watts_strogatz_graph, n, k, p, seed=seed)
+    t(nx.random_regular_graph, 3, n, seed=seed)
+    t(nx.barabasi_albert_graph, n, m, seed=seed)
+    t(nx.extended_barabasi_albert_graph, n, m, p, q, seed=seed)
+    t(nx.powerlaw_cluster_graph, n, m, p, seed=seed)
+    t(nx.random_lobster, n, p1, p2, seed=seed)
+    t(nx.random_powerlaw_tree, n, seed=seed, tries=5000)
+    t(nx.random_powerlaw_tree_sequence, 10, seed=seed, tries=5000)
+    t(nx.random_tree, n, seed=seed)
+    t(nx.utils.powerlaw_sequence, n, seed=seed)
+    t(nx.utils.zipf_rv, 2.3, seed=seed)
+    cdist = [0.2, 0.4, 0.5, 0.7, 0.9, 1.0]
+    t(nx.utils.discrete_sequence, n, cdistribution=cdist, seed=seed)
+    t(nx.algorithms.bipartite.random_graph, n, m, p, seed=seed)
+    t(nx.algorithms.bipartite.gnmk_random_graph, n, m, k, seed=seed)
+    LFR = nx.generators.LFR_benchmark_graph
+    t(
+        LFR,
+        25,
+        3,
+        1.5,
+        0.1,
+        average_degree=3,
+        min_community=10,
+        seed=seed,
+        max_community=20,
+    )
+    t(nx.random_internet_as_graph, n, seed=seed)
+    # print("done")
+
+
+# choose to test an integer seed, or whether a single RNG can be everywhere
+# np_rng = np.random.RandomState(14)
+# seed = np_rng
+# seed = 14
+
+
+@pytest.mark.slow
+# print("NetworkX Version:", nx.__version__)
+def test_rng_interface():
+    global progress
+
+    # try different kinds of seeds
+    for seed in [14, np.random.RandomState(14)]:
+        np.random.seed(42)
+        random.seed(42)
+        run_all_random_functions(seed)
+        progress = 0
+
+        # check that both global RNGs are unaffected
+        after_np_rv = np.random.rand()
+        #        if np_rv != after_np_rv:
+        #            print(np_rv, after_np_rv, "don't match np!")
+        assert np_rv == after_np_rv
+        after_py_rv = random.random()
+        #        if py_rv != after_py_rv:
+        #            print(py_rv, after_py_rv, "don't match py!")
+        assert py_rv == after_py_rv
+
+
+#        print("\nDone testing seed:", seed)
+
+# test_rng_interface()
diff --git a/myenv/lib/python3.9/site-packages/networkx/tests/test_convert.py b/myenv/lib/python3.9/site-packages/networkx/tests/test_convert.py
new file mode 100644
index 0000000..5c0a904
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/tests/test_convert.py
@@ -0,0 +1,321 @@
+import pytest
+
+import networkx as nx
+from networkx.convert import (
+    from_dict_of_dicts,
+    from_dict_of_lists,
+    to_dict_of_dicts,
+    to_dict_of_lists,
+    to_networkx_graph,
+)
+from networkx.generators.classic import barbell_graph, cycle_graph
+from networkx.utils import edges_equal, graphs_equal, nodes_equal
+
+
+class TestConvert:
+    def edgelists_equal(self, e1, e2):
+        return sorted(sorted(e) for e in e1) == sorted(sorted(e) for e in e2)
+
+    def test_simple_graphs(self):
+        for dest, source in [
+            (to_dict_of_dicts, from_dict_of_dicts),
+            (to_dict_of_lists, from_dict_of_lists),
+        ]:
+            G = barbell_graph(10, 3)
+            G.graph = {}
+            dod = dest(G)
+
+            # Dict of [dicts, lists]
+            GG = source(dod)
+            assert graphs_equal(G, GG)
+            GW = to_networkx_graph(dod)
+            assert graphs_equal(G, GW)
+            GI = nx.Graph(dod)
+            assert graphs_equal(G, GI)
+
+            # With nodelist keyword
+            P4 = nx.path_graph(4)
+            P3 = nx.path_graph(3)
+            P4.graph = {}
+            P3.graph = {}
+            dod = dest(P4, nodelist=[0, 1, 2])
+            Gdod = nx.Graph(dod)
+            assert graphs_equal(Gdod, P3)
+
+    def test_exceptions(self):
+        # NX graph
+        class G:
+            adj = None
+
+        pytest.raises(nx.NetworkXError, to_networkx_graph, G)
+
+        # pygraphviz  agraph
+        class G:
+            is_strict = None
+
+        pytest.raises(nx.NetworkXError, to_networkx_graph, G)
+
+        # Dict of [dicts, lists]
+        G = {"a": 0}
+        pytest.raises(TypeError, to_networkx_graph, G)
+
+        # list or generator of edges
+        class G:
+            next = None
+
+        pytest.raises(nx.NetworkXError, to_networkx_graph, G)
+
+        # no match
+        pytest.raises(nx.NetworkXError, to_networkx_graph, "a")
+
+    def test_digraphs(self):
+        for dest, source in [
+            (to_dict_of_dicts, from_dict_of_dicts),
+            (to_dict_of_lists, from_dict_of_lists),
+        ]:
+            G = cycle_graph(10)
+
+            # Dict of [dicts, lists]
+            dod = dest(G)
+            GG = source(dod)
+            assert nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
+            assert edges_equal(sorted(G.edges()), sorted(GG.edges()))
+            GW = to_networkx_graph(dod)
+            assert nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
+            assert edges_equal(sorted(G.edges()), sorted(GW.edges()))
+            GI = nx.Graph(dod)
+            assert nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
+            assert edges_equal(sorted(G.edges()), sorted(GI.edges()))
+
+            G = cycle_graph(10, create_using=nx.DiGraph)
+            dod = dest(G)
+            GG = source(dod, create_using=nx.DiGraph)
+            assert sorted(G.nodes()) == sorted(GG.nodes())
+            assert sorted(G.edges()) == sorted(GG.edges())
+            GW = to_networkx_graph(dod, create_using=nx.DiGraph)
+            assert sorted(G.nodes()) == sorted(GW.nodes())
+            assert sorted(G.edges()) == sorted(GW.edges())
+            GI = nx.DiGraph(dod)
+            assert sorted(G.nodes()) == sorted(GI.nodes())
+            assert sorted(G.edges()) == sorted(GI.edges())
+
+    def test_graph(self):
+        g = nx.cycle_graph(10)
+        G = nx.Graph()
+        G.add_nodes_from(g)
+        G.add_weighted_edges_from((u, v, u) for u, v in g.edges())
+
+        # Dict of dicts
+        dod = to_dict_of_dicts(G)
+        GG = from_dict_of_dicts(dod, create_using=nx.Graph)
+        assert nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
+        assert edges_equal(sorted(G.edges()), sorted(GG.edges()))
+        GW = to_networkx_graph(dod, create_using=nx.Graph)
+        assert nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
+        assert edges_equal(sorted(G.edges()), sorted(GW.edges()))
+        GI = nx.Graph(dod)
+        assert sorted(G.nodes()) == sorted(GI.nodes())
+        assert sorted(G.edges()) == sorted(GI.edges())
+
+        # Dict of lists
+        dol = to_dict_of_lists(G)
+        GG = from_dict_of_lists(dol, create_using=nx.Graph)
+        # dict of lists throws away edge data so set it to none
+        enone = [(u, v, {}) for (u, v, d) in G.edges(data=True)]
+        assert nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
+        assert edges_equal(enone, sorted(GG.edges(data=True)))
+        GW = to_networkx_graph(dol, create_using=nx.Graph)
+        assert nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
+        assert edges_equal(enone, sorted(GW.edges(data=True)))
+        GI = nx.Graph(dol)
+        assert nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
+        assert edges_equal(enone, sorted(GI.edges(data=True)))
+
+    def test_with_multiedges_self_loops(self):
+        G = cycle_graph(10)
+        XG = nx.Graph()
+        XG.add_nodes_from(G)
+        XG.add_weighted_edges_from((u, v, u) for u, v in G.edges())
+        XGM = nx.MultiGraph()
+        XGM.add_nodes_from(G)
+        XGM.add_weighted_edges_from((u, v, u) for u, v in G.edges())
+        XGM.add_edge(0, 1, weight=2)  # multiedge
+        XGS = nx.Graph()
+        XGS.add_nodes_from(G)
+        XGS.add_weighted_edges_from((u, v, u) for u, v in G.edges())
+        XGS.add_edge(0, 0, weight=100)  # self loop
+
+        # Dict of dicts
+        # with self loops, OK
+        dod = to_dict_of_dicts(XGS)
+        GG = from_dict_of_dicts(dod, create_using=nx.Graph)
+        assert nodes_equal(XGS.nodes(), GG.nodes())
+        assert edges_equal(XGS.edges(), GG.edges())
+        GW = to_networkx_graph(dod, create_using=nx.Graph)
+        assert nodes_equal(XGS.nodes(), GW.nodes())
+        assert edges_equal(XGS.edges(), GW.edges())
+        GI = nx.Graph(dod)
+        assert nodes_equal(XGS.nodes(), GI.nodes())
+        assert edges_equal(XGS.edges(), GI.edges())
+
+        # Dict of lists
+        # with self loops, OK
+        dol = to_dict_of_lists(XGS)
+        GG = from_dict_of_lists(dol, create_using=nx.Graph)
+        # dict of lists throws away edge data so set it to none
+        enone = [(u, v, {}) for (u, v, d) in XGS.edges(data=True)]
+        assert nodes_equal(sorted(XGS.nodes()), sorted(GG.nodes()))
+        assert edges_equal(enone, sorted(GG.edges(data=True)))
+        GW = to_networkx_graph(dol, create_using=nx.Graph)
+        assert nodes_equal(sorted(XGS.nodes()), sorted(GW.nodes()))
+        assert edges_equal(enone, sorted(GW.edges(data=True)))
+        GI = nx.Graph(dol)
+        assert nodes_equal(sorted(XGS.nodes()), sorted(GI.nodes()))
+        assert edges_equal(enone, sorted(GI.edges(data=True)))
+
+        # Dict of dicts
+        # with multiedges, OK
+        dod = to_dict_of_dicts(XGM)
+        GG = from_dict_of_dicts(dod, create_using=nx.MultiGraph, multigraph_input=True)
+        assert nodes_equal(sorted(XGM.nodes()), sorted(GG.nodes()))
+        assert edges_equal(sorted(XGM.edges()), sorted(GG.edges()))
+        GW = to_networkx_graph(dod, create_using=nx.MultiGraph, multigraph_input=True)
+        assert nodes_equal(sorted(XGM.nodes()), sorted(GW.nodes()))
+        assert edges_equal(sorted(XGM.edges()), sorted(GW.edges()))
+        GI = nx.MultiGraph(dod)
+        assert nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
+        assert sorted(XGM.edges()) == sorted(GI.edges())
+        GE = from_dict_of_dicts(dod, create_using=nx.MultiGraph, multigraph_input=False)
+        assert nodes_equal(sorted(XGM.nodes()), sorted(GE.nodes()))
+        assert sorted(XGM.edges()) != sorted(GE.edges())
+        GI = nx.MultiGraph(XGM)
+        assert nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
+        assert edges_equal(sorted(XGM.edges()), sorted(GI.edges()))
+        GM = nx.MultiGraph(G)
+        assert nodes_equal(sorted(GM.nodes()), sorted(G.nodes()))
+        assert edges_equal(sorted(GM.edges()), sorted(G.edges()))
+
+        # Dict of lists
+        # with multiedges, OK, but better write as DiGraph else you'll
+        # get double edges
+        dol = to_dict_of_lists(G)
+        GG = from_dict_of_lists(dol, create_using=nx.MultiGraph)
+        assert nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
+        assert edges_equal(sorted(G.edges()), sorted(GG.edges()))
+        GW = to_networkx_graph(dol, create_using=nx.MultiGraph)
+        assert nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
+        assert edges_equal(sorted(G.edges()), sorted(GW.edges()))
+        GI = nx.MultiGraph(dol)
+        assert nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
+        assert edges_equal(sorted(G.edges()), sorted(GI.edges()))
+
+    def test_edgelists(self):
+        P = nx.path_graph(4)
+        e = [(0, 1), (1, 2), (2, 3)]
+        G = nx.Graph(e)
+        assert nodes_equal(sorted(G.nodes()), sorted(P.nodes()))
+        assert edges_equal(sorted(G.edges()), sorted(P.edges()))
+        assert edges_equal(sorted(G.edges(data=True)), sorted(P.edges(data=True)))
+
+        e = [(0, 1, {}), (1, 2, {}), (2, 3, {})]
+        G = nx.Graph(e)
+        assert nodes_equal(sorted(G.nodes()), sorted(P.nodes()))
+        assert edges_equal(sorted(G.edges()), sorted(P.edges()))
+        assert edges_equal(sorted(G.edges(data=True)), sorted(P.edges(data=True)))
+
+        e = ((n, n + 1) for n in range(3))
+        G = nx.Graph(e)
+        assert nodes_equal(sorted(G.nodes()), sorted(P.nodes()))
+        assert edges_equal(sorted(G.edges()), sorted(P.edges()))
+        assert edges_equal(sorted(G.edges(data=True)), sorted(P.edges(data=True)))
+
+    def test_directed_to_undirected(self):
+        edges1 = [(0, 1), (1, 2), (2, 0)]
+        edges2 = [(0, 1), (1, 2), (0, 2)]
+        assert self.edgelists_equal(nx.Graph(nx.DiGraph(edges1)).edges(), edges1)
+        assert self.edgelists_equal(nx.Graph(nx.DiGraph(edges2)).edges(), edges1)
+        assert self.edgelists_equal(nx.MultiGraph(nx.DiGraph(edges1)).edges(), edges1)
+        assert self.edgelists_equal(nx.MultiGraph(nx.DiGraph(edges2)).edges(), edges1)
+
+        assert self.edgelists_equal(
+            nx.MultiGraph(nx.MultiDiGraph(edges1)).edges(), edges1
+        )
+        assert self.edgelists_equal(
+            nx.MultiGraph(nx.MultiDiGraph(edges2)).edges(), edges1
+        )
+
+        assert self.edgelists_equal(nx.Graph(nx.MultiDiGraph(edges1)).edges(), edges1)
+        assert self.edgelists_equal(nx.Graph(nx.MultiDiGraph(edges2)).edges(), edges1)
+
+    def test_attribute_dict_integrity(self):
+        # we must not replace dict-like graph data structures with dicts
+        G = nx.OrderedGraph()
+        G.add_nodes_from("abc")
+        H = to_networkx_graph(G, create_using=nx.OrderedGraph)
+        assert list(H.nodes) == list(G.nodes)
+        H = nx.OrderedDiGraph(G)
+        assert list(H.nodes) == list(G.nodes)
+
+    def test_to_edgelist(self):
+        G = nx.Graph([(1, 1)])
+        elist = nx.to_edgelist(G, nodelist=list(G))
+        assert edges_equal(G.edges(data=True), elist)
+
+    def test_custom_node_attr_dict_safekeeping(self):
+        class custom_dict(dict):
+            pass
+
+        class Custom(nx.Graph):
+            node_attr_dict_factory = custom_dict
+
+        g = nx.Graph()
+        g.add_node(1, weight=1)
+
+        h = Custom(g)
+        assert isinstance(g._node[1], dict)
+        assert isinstance(h._node[1], custom_dict)
+
+        # this raise exception
+        # h._node.update((n, dd.copy()) for n, dd in g.nodes.items())
+        # assert isinstance(h._node[1], custom_dict)
+
+
+@pytest.mark.parametrize(
+    "edgelist",
+    (
+        # Graph with no edge data
+        [(0, 1), (1, 2)],
+        # Graph with edge data
+        [(0, 1, {"weight": 1.0}), (1, 2, {"weight": 2.0})],
+    ),
+)
+def test_to_dict_of_dicts_with_edgedata_param(edgelist):
+    G = nx.Graph()
+    G.add_edges_from(edgelist)
+    # Innermost dict value == edge_data when edge_data != None.
+    # In the case when G has edge data, it is overwritten
+    expected = {0: {1: 10}, 1: {0: 10, 2: 10}, 2: {1: 10}}
+    assert nx.to_dict_of_dicts(G, edge_data=10) == expected
+
+
+def test_to_dict_of_dicts_with_edgedata_and_nodelist():
+    G = nx.path_graph(5)
+    nodelist = [2, 3, 4]
+    expected = {2: {3: 10}, 3: {2: 10, 4: 10}, 4: {3: 10}}
+    assert nx.to_dict_of_dicts(G, nodelist=nodelist, edge_data=10) == expected
+
+
+def test_to_dict_of_dicts_with_edgedata_multigraph():
+    """Multi edge data overwritten when edge_data != None"""
+    G = nx.MultiGraph()
+    G.add_edge(0, 1, key="a")
+    G.add_edge(0, 1, key="b")
+    # Multi edge data lost when edge_data is not None
+    expected = {0: {1: 10}, 1: {0: 10}}
+    assert nx.to_dict_of_dicts(G, edge_data=10) == expected
+
+
+def test_to_networkx_graph_non_edgelist():
+    invalid_edgelist = [1, 2, 3]
+    with pytest.raises(nx.NetworkXError, match="Input is not a valid edge list"):
+        nx.to_networkx_graph(invalid_edgelist)
diff --git a/myenv/lib/python3.9/site-packages/networkx/tests/test_convert_numpy.py b/myenv/lib/python3.9/site-packages/networkx/tests/test_convert_numpy.py
new file mode 100644
index 0000000..e341ab2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/tests/test_convert_numpy.py
@@ -0,0 +1,674 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+npt = pytest.importorskip("numpy.testing")
+
+import networkx as nx
+from networkx.generators.classic import barbell_graph, cycle_graph, path_graph
+from networkx.utils import graphs_equal
+
+
+def test_to_numpy_matrix_deprecation():
+    pytest.deprecated_call(nx.to_numpy_matrix, nx.Graph())
+
+
+def test_from_numpy_matrix_deprecation():
+    pytest.deprecated_call(nx.from_numpy_matrix, np.eye(2))
+
+
+def test_to_numpy_recarray_deprecation():
+    pytest.deprecated_call(nx.to_numpy_recarray, nx.Graph())
+
+
+class TestConvertNumpyMatrix:
+    # TODO: This entire class can be removed when to/from_numpy_matrix
+    # deprecation expires
+    def setup_method(self):
+        self.G1 = barbell_graph(10, 3)
+        self.G2 = cycle_graph(10, create_using=nx.DiGraph)
+
+        self.G3 = self.create_weighted(nx.Graph())
+        self.G4 = self.create_weighted(nx.DiGraph())
+
+    def test_exceptions(self):
+        G = np.array("a")
+        pytest.raises(nx.NetworkXError, nx.to_networkx_graph, G)
+
+    def create_weighted(self, G):
+        g = cycle_graph(4)
+        G.add_nodes_from(g)
+        G.add_weighted_edges_from((u, v, 10 + u) for u, v in g.edges())
+        return G
+
+    def assert_equal(self, G1, G2):
+        assert sorted(G1.nodes()) == sorted(G2.nodes())
+        assert sorted(G1.edges()) == sorted(G2.edges())
+
+    def identity_conversion(self, G, A, create_using):
+        assert A.sum() > 0
+        GG = nx.from_numpy_matrix(A, create_using=create_using)
+        self.assert_equal(G, GG)
+        GW = nx.to_networkx_graph(A, create_using=create_using)
+        self.assert_equal(G, GW)
+        GI = nx.empty_graph(0, create_using).__class__(A)
+        self.assert_equal(G, GI)
+
+    def test_shape(self):
+        "Conversion from non-square array."
+        A = np.array([[1, 2, 3], [4, 5, 6]])
+        pytest.raises(nx.NetworkXError, nx.from_numpy_matrix, A)
+
+    def test_identity_graph_matrix(self):
+        "Conversion from graph to matrix to graph."
+        A = nx.to_numpy_matrix(self.G1)
+        self.identity_conversion(self.G1, A, nx.Graph())
+
+    def test_identity_graph_array(self):
+        "Conversion from graph to array to graph."
+        A = nx.to_numpy_matrix(self.G1)
+        A = np.asarray(A)
+        self.identity_conversion(self.G1, A, nx.Graph())
+
+    def test_identity_digraph_matrix(self):
+        """Conversion from digraph to matrix to digraph."""
+        A = nx.to_numpy_matrix(self.G2)
+        self.identity_conversion(self.G2, A, nx.DiGraph())
+
+    def test_identity_digraph_array(self):
+        """Conversion from digraph to array to digraph."""
+        A = nx.to_numpy_matrix(self.G2)
+        A = np.asarray(A)
+        self.identity_conversion(self.G2, A, nx.DiGraph())
+
+    def test_identity_weighted_graph_matrix(self):
+        """Conversion from weighted graph to matrix to weighted graph."""
+        A = nx.to_numpy_matrix(self.G3)
+        self.identity_conversion(self.G3, A, nx.Graph())
+
+    def test_identity_weighted_graph_array(self):
+        """Conversion from weighted graph to array to weighted graph."""
+        A = nx.to_numpy_matrix(self.G3)
+        A = np.asarray(A)
+        self.identity_conversion(self.G3, A, nx.Graph())
+
+    def test_identity_weighted_digraph_matrix(self):
+        """Conversion from weighted digraph to matrix to weighted digraph."""
+        A = nx.to_numpy_matrix(self.G4)
+        self.identity_conversion(self.G4, A, nx.DiGraph())
+
+    def test_identity_weighted_digraph_array(self):
+        """Conversion from weighted digraph to array to weighted digraph."""
+        A = nx.to_numpy_matrix(self.G4)
+        A = np.asarray(A)
+        self.identity_conversion(self.G4, A, nx.DiGraph())
+
+    def test_nodelist(self):
+        """Conversion from graph to matrix to graph with nodelist."""
+        P4 = path_graph(4)
+        P3 = path_graph(3)
+        nodelist = list(P3)
+        A = nx.to_numpy_matrix(P4, nodelist=nodelist)
+        GA = nx.Graph(A)
+        self.assert_equal(GA, P3)
+
+        assert nx.to_numpy_matrix(P3, nodelist=[]).shape == (0, 0)
+        # Test nodelist duplicates.
+        long_nodelist = nodelist + [0]
+        pytest.raises(nx.NetworkXError, nx.to_numpy_matrix, P3, nodelist=long_nodelist)
+
+        # Test nodelist contains non-nodes
+        nonnodelist = [-1, 0, 1, 2]
+        pytest.raises(nx.NetworkXError, nx.to_numpy_matrix, P3, nodelist=nonnodelist)
+
+    def test_weight_keyword(self):
+        WP4 = nx.Graph()
+        WP4.add_edges_from((n, n + 1, dict(weight=0.5, other=0.3)) for n in range(3))
+        P4 = path_graph(4)
+        A = nx.to_numpy_matrix(P4)
+        np.testing.assert_equal(A, nx.to_numpy_matrix(WP4, weight=None))
+        np.testing.assert_equal(0.5 * A, nx.to_numpy_matrix(WP4))
+        np.testing.assert_equal(0.3 * A, nx.to_numpy_matrix(WP4, weight="other"))
+
+    def test_from_numpy_matrix_type(self):
+        pytest.importorskip("scipy")
+
+        A = np.matrix([[1]])
+        G = nx.from_numpy_matrix(A)
+        assert type(G[0][0]["weight"]) == int
+
+        A = np.matrix([[1]]).astype(float)
+        G = nx.from_numpy_matrix(A)
+        assert type(G[0][0]["weight"]) == float
+
+        A = np.matrix([[1]]).astype(str)
+        G = nx.from_numpy_matrix(A)
+        assert type(G[0][0]["weight"]) == str
+
+        A = np.matrix([[1]]).astype(bool)
+        G = nx.from_numpy_matrix(A)
+        assert type(G[0][0]["weight"]) == bool
+
+        A = np.matrix([[1]]).astype(complex)
+        G = nx.from_numpy_matrix(A)
+        assert type(G[0][0]["weight"]) == complex
+
+        A = np.matrix([[1]]).astype(object)
+        pytest.raises(TypeError, nx.from_numpy_matrix, A)
+
+        G = nx.cycle_graph(3)
+        A = nx.adjacency_matrix(G).todense()
+        H = nx.from_numpy_matrix(A)
+        assert all(type(m) == int and type(n) == int for m, n in H.edges())
+        H = nx.from_numpy_array(A)
+        assert all(type(m) == int and type(n) == int for m, n in H.edges())
+
+    def test_from_numpy_matrix_dtype(self):
+        dt = [("weight", float), ("cost", int)]
+        A = np.matrix([[(1.0, 2)]], dtype=dt)
+        G = nx.from_numpy_matrix(A)
+        assert type(G[0][0]["weight"]) == float
+        assert type(G[0][0]["cost"]) == int
+        assert G[0][0]["cost"] == 2
+        assert G[0][0]["weight"] == 1.0
+
+    def test_to_numpy_recarray(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=7.0, cost=5)
+        A = nx.to_numpy_recarray(G, dtype=[("weight", float), ("cost", int)])
+        assert sorted(A.dtype.names) == ["cost", "weight"]
+        assert A.weight[0, 1] == 7.0
+        assert A.weight[0, 0] == 0.0
+        assert A.cost[0, 1] == 5
+        assert A.cost[0, 0] == 0
+
+    def test_numpy_multigraph(self):
+        G = nx.MultiGraph()
+        G.add_edge(1, 2, weight=7)
+        G.add_edge(1, 2, weight=70)
+        A = nx.to_numpy_matrix(G)
+        assert A[1, 0] == 77
+        A = nx.to_numpy_matrix(G, multigraph_weight=min)
+        assert A[1, 0] == 7
+        A = nx.to_numpy_matrix(G, multigraph_weight=max)
+        assert A[1, 0] == 70
+
+    def test_from_numpy_matrix_parallel_edges(self):
+        """Tests that the :func:`networkx.from_numpy_matrix` function
+        interprets integer weights as the number of parallel edges when
+        creating a multigraph.
+
+        """
+        A = np.matrix([[1, 1], [1, 2]])
+        # First, with a simple graph, each integer entry in the adjacency
+        # matrix is interpreted as the weight of a single edge in the graph.
+        expected = nx.DiGraph()
+        edges = [(0, 0), (0, 1), (1, 0)]
+        expected.add_weighted_edges_from([(u, v, 1) for (u, v) in edges])
+        expected.add_edge(1, 1, weight=2)
+        actual = nx.from_numpy_matrix(A, parallel_edges=True, create_using=nx.DiGraph)
+        assert graphs_equal(actual, expected)
+        actual = nx.from_numpy_matrix(A, parallel_edges=False, create_using=nx.DiGraph)
+        assert graphs_equal(actual, expected)
+        # Now each integer entry in the adjacency matrix is interpreted as the
+        # number of parallel edges in the graph if the appropriate keyword
+        # argument is specified.
+        edges = [(0, 0), (0, 1), (1, 0), (1, 1), (1, 1)]
+        expected = nx.MultiDiGraph()
+        expected.add_weighted_edges_from([(u, v, 1) for (u, v) in edges])
+        actual = nx.from_numpy_matrix(
+            A, parallel_edges=True, create_using=nx.MultiDiGraph
+        )
+        assert graphs_equal(actual, expected)
+        expected = nx.MultiDiGraph()
+        expected.add_edges_from(set(edges), weight=1)
+        # The sole self-loop (edge 0) on vertex 1 should have weight 2.
+        expected[1][1][0]["weight"] = 2
+        actual = nx.from_numpy_matrix(
+            A, parallel_edges=False, create_using=nx.MultiDiGraph
+        )
+        assert graphs_equal(actual, expected)
+
+    def test_symmetric(self):
+        """Tests that a symmetric matrix has edges added only once to an
+        undirected multigraph when using :func:`networkx.from_numpy_matrix`.
+
+        """
+        A = np.matrix([[0, 1], [1, 0]])
+        G = nx.from_numpy_matrix(A, create_using=nx.MultiGraph)
+        expected = nx.MultiGraph()
+        expected.add_edge(0, 1, weight=1)
+        assert graphs_equal(G, expected)
+
+    def test_dtype_int_graph(self):
+        """Test that setting dtype int actually gives an integer matrix.
+
+        For more information, see GitHub pull request #1363.
+
+        """
+        G = nx.complete_graph(3)
+        A = nx.to_numpy_matrix(G, dtype=int)
+        assert A.dtype == int
+
+    def test_dtype_int_multigraph(self):
+        """Test that setting dtype int actually gives an integer matrix.
+
+        For more information, see GitHub pull request #1363.
+
+        """
+        G = nx.MultiGraph(nx.complete_graph(3))
+        A = nx.to_numpy_matrix(G, dtype=int)
+        assert A.dtype == int
+
+
+class TestConvertNumpyArray:
+    def setup_method(self):
+        self.G1 = barbell_graph(10, 3)
+        self.G2 = cycle_graph(10, create_using=nx.DiGraph)
+        self.G3 = self.create_weighted(nx.Graph())
+        self.G4 = self.create_weighted(nx.DiGraph())
+
+    def create_weighted(self, G):
+        g = cycle_graph(4)
+        G.add_nodes_from(g)
+        G.add_weighted_edges_from((u, v, 10 + u) for u, v in g.edges())
+        return G
+
+    def assert_equal(self, G1, G2):
+        assert sorted(G1.nodes()) == sorted(G2.nodes())
+        assert sorted(G1.edges()) == sorted(G2.edges())
+
+    def identity_conversion(self, G, A, create_using):
+        assert A.sum() > 0
+        GG = nx.from_numpy_array(A, create_using=create_using)
+        self.assert_equal(G, GG)
+        GW = nx.to_networkx_graph(A, create_using=create_using)
+        self.assert_equal(G, GW)
+        GI = nx.empty_graph(0, create_using).__class__(A)
+        self.assert_equal(G, GI)
+
+    def test_shape(self):
+        "Conversion from non-square array."
+        A = np.array([[1, 2, 3], [4, 5, 6]])
+        pytest.raises(nx.NetworkXError, nx.from_numpy_array, A)
+
+    def test_identity_graph_array(self):
+        "Conversion from graph to array to graph."
+        A = nx.to_numpy_array(self.G1)
+        self.identity_conversion(self.G1, A, nx.Graph())
+
+    def test_identity_digraph_array(self):
+        """Conversion from digraph to array to digraph."""
+        A = nx.to_numpy_array(self.G2)
+        self.identity_conversion(self.G2, A, nx.DiGraph())
+
+    def test_identity_weighted_graph_array(self):
+        """Conversion from weighted graph to array to weighted graph."""
+        A = nx.to_numpy_array(self.G3)
+        self.identity_conversion(self.G3, A, nx.Graph())
+
+    def test_identity_weighted_digraph_array(self):
+        """Conversion from weighted digraph to array to weighted digraph."""
+        A = nx.to_numpy_array(self.G4)
+        self.identity_conversion(self.G4, A, nx.DiGraph())
+
+    def test_nodelist(self):
+        """Conversion from graph to array to graph with nodelist."""
+        P4 = path_graph(4)
+        P3 = path_graph(3)
+        nodelist = list(P3)
+        A = nx.to_numpy_array(P4, nodelist=nodelist)
+        GA = nx.Graph(A)
+        self.assert_equal(GA, P3)
+
+        # Make nodelist ambiguous by containing duplicates.
+        nodelist += [nodelist[0]]
+        pytest.raises(nx.NetworkXError, nx.to_numpy_array, P3, nodelist=nodelist)
+
+    def test_weight_keyword(self):
+        WP4 = nx.Graph()
+        WP4.add_edges_from((n, n + 1, dict(weight=0.5, other=0.3)) for n in range(3))
+        P4 = path_graph(4)
+        A = nx.to_numpy_array(P4)
+        np.testing.assert_equal(A, nx.to_numpy_array(WP4, weight=None))
+        np.testing.assert_equal(0.5 * A, nx.to_numpy_array(WP4))
+        np.testing.assert_equal(0.3 * A, nx.to_numpy_array(WP4, weight="other"))
+
+    def test_from_numpy_array_type(self):
+        A = np.array([[1]])
+        G = nx.from_numpy_array(A)
+        assert type(G[0][0]["weight"]) == int
+
+        A = np.array([[1]]).astype(float)
+        G = nx.from_numpy_array(A)
+        assert type(G[0][0]["weight"]) == float
+
+        A = np.array([[1]]).astype(str)
+        G = nx.from_numpy_array(A)
+        assert type(G[0][0]["weight"]) == str
+
+        A = np.array([[1]]).astype(bool)
+        G = nx.from_numpy_array(A)
+        assert type(G[0][0]["weight"]) == bool
+
+        A = np.array([[1]]).astype(complex)
+        G = nx.from_numpy_array(A)
+        assert type(G[0][0]["weight"]) == complex
+
+        A = np.array([[1]]).astype(object)
+        pytest.raises(TypeError, nx.from_numpy_array, A)
+
+    def test_from_numpy_array_dtype(self):
+        dt = [("weight", float), ("cost", int)]
+        A = np.array([[(1.0, 2)]], dtype=dt)
+        G = nx.from_numpy_array(A)
+        assert type(G[0][0]["weight"]) == float
+        assert type(G[0][0]["cost"]) == int
+        assert G[0][0]["cost"] == 2
+        assert G[0][0]["weight"] == 1.0
+
+    def test_from_numpy_array_parallel_edges(self):
+        """Tests that the :func:`networkx.from_numpy_array` function
+        interprets integer weights as the number of parallel edges when
+        creating a multigraph.
+
+        """
+        A = np.array([[1, 1], [1, 2]])
+        # First, with a simple graph, each integer entry in the adjacency
+        # matrix is interpreted as the weight of a single edge in the graph.
+        expected = nx.DiGraph()
+        edges = [(0, 0), (0, 1), (1, 0)]
+        expected.add_weighted_edges_from([(u, v, 1) for (u, v) in edges])
+        expected.add_edge(1, 1, weight=2)
+        actual = nx.from_numpy_array(A, parallel_edges=True, create_using=nx.DiGraph)
+        assert graphs_equal(actual, expected)
+        actual = nx.from_numpy_array(A, parallel_edges=False, create_using=nx.DiGraph)
+        assert graphs_equal(actual, expected)
+        # Now each integer entry in the adjacency matrix is interpreted as the
+        # number of parallel edges in the graph if the appropriate keyword
+        # argument is specified.
+        edges = [(0, 0), (0, 1), (1, 0), (1, 1), (1, 1)]
+        expected = nx.MultiDiGraph()
+        expected.add_weighted_edges_from([(u, v, 1) for (u, v) in edges])
+        actual = nx.from_numpy_array(
+            A, parallel_edges=True, create_using=nx.MultiDiGraph
+        )
+        assert graphs_equal(actual, expected)
+        expected = nx.MultiDiGraph()
+        expected.add_edges_from(set(edges), weight=1)
+        # The sole self-loop (edge 0) on vertex 1 should have weight 2.
+        expected[1][1][0]["weight"] = 2
+        actual = nx.from_numpy_array(
+            A, parallel_edges=False, create_using=nx.MultiDiGraph
+        )
+        assert graphs_equal(actual, expected)
+
+    def test_symmetric(self):
+        """Tests that a symmetric array has edges added only once to an
+        undirected multigraph when using :func:`networkx.from_numpy_array`.
+
+        """
+        A = np.array([[0, 1], [1, 0]])
+        G = nx.from_numpy_array(A, create_using=nx.MultiGraph)
+        expected = nx.MultiGraph()
+        expected.add_edge(0, 1, weight=1)
+        assert graphs_equal(G, expected)
+
+    def test_dtype_int_graph(self):
+        """Test that setting dtype int actually gives an integer array.
+
+        For more information, see GitHub pull request #1363.
+
+        """
+        G = nx.complete_graph(3)
+        A = nx.to_numpy_array(G, dtype=int)
+        assert A.dtype == int
+
+    def test_dtype_int_multigraph(self):
+        """Test that setting dtype int actually gives an integer array.
+
+        For more information, see GitHub pull request #1363.
+
+        """
+        G = nx.MultiGraph(nx.complete_graph(3))
+        A = nx.to_numpy_array(G, dtype=int)
+        assert A.dtype == int
+
+
+@pytest.fixture
+def recarray_test_graph():
+    G = nx.Graph()
+    G.add_edge(1, 2, weight=7.0, cost=5)
+    return G
+
+
+def test_to_numpy_recarray(recarray_test_graph):
+    A = nx.to_numpy_recarray(
+        recarray_test_graph, dtype=[("weight", float), ("cost", int)]
+    )
+    assert sorted(A.dtype.names) == ["cost", "weight"]
+    assert A.weight[0, 1] == 7.0
+    assert A.weight[0, 0] == 0.0
+    assert A.cost[0, 1] == 5
+    assert A.cost[0, 0] == 0
+    with pytest.raises(AttributeError, match="has no attribute"):
+        A.color[0, 1]
+
+
+def test_to_numpy_recarray_default_dtype(recarray_test_graph):
+    A = nx.to_numpy_recarray(recarray_test_graph)
+    assert A.dtype.names == ("weight",)
+    assert A.weight[0, 0] == 0
+    assert A.weight[0, 1] == 7
+    with pytest.raises(AttributeError, match="has no attribute"):
+        A.cost[0, 1]
+
+
+def test_to_numpy_recarray_directed(recarray_test_graph):
+    G = recarray_test_graph.to_directed()
+    G.remove_edge(2, 1)
+    A = nx.to_numpy_recarray(G, dtype=[("weight", float), ("cost", int)])
+    np.testing.assert_array_equal(A.weight, np.array([[0, 7.0], [0, 0]]))
+    np.testing.assert_array_equal(A.cost, np.array([[0, 5], [0, 0]]))
+
+
+def test_to_numpy_recarray_default_dtype_no_weight():
+    G = nx.Graph()
+    G.add_edge(0, 1, color="red")
+    with pytest.raises(KeyError):
+        A = nx.to_numpy_recarray(G)
+    A = nx.to_numpy_recarray(G, dtype=[("color", "U8")])
+    assert A.color[0, 1] == "red"
+
+
+@pytest.fixture
+def recarray_nodelist_test_graph():
+    G = nx.Graph()
+    G.add_edges_from(
+        [(0, 1, {"weight": 1.0}), (0, 2, {"weight": 2.0}), (1, 2, {"weight": 0.5})]
+    )
+    return G
+
+
+def test_to_numpy_recarray_nodelist(recarray_nodelist_test_graph):
+    A = nx.to_numpy_recarray(recarray_nodelist_test_graph, nodelist=[0, 1])
+    np.testing.assert_array_equal(A.weight, np.array([[0, 1], [1, 0]]))
+
+
+@pytest.mark.parametrize(
+    ("nodelist", "errmsg"),
+    (([2, 3], "in nodelist is not in G"), ([1, 1], "nodelist contains duplicates")),
+)
+def test_to_numpy_recarray_bad_nodelist(recarray_nodelist_test_graph, nodelist, errmsg):
+    with pytest.raises(nx.NetworkXError, match=errmsg):
+        A = nx.to_numpy_recarray(recarray_nodelist_test_graph, nodelist=nodelist)
+
+
+@pytest.fixture
+def multigraph_test_graph():
+    G = nx.MultiGraph()
+    G.add_edge(1, 2, weight=7)
+    G.add_edge(1, 2, weight=70)
+    return G
+
+
+@pytest.mark.parametrize(("operator", "expected"), ((sum, 77), (min, 7), (max, 70)))
+def test_numpy_multigraph(multigraph_test_graph, operator, expected):
+    A = nx.to_numpy_array(multigraph_test_graph, multigraph_weight=operator)
+    assert A[1, 0] == expected
+
+
+def test_to_numpy_array_multigraph_nodelist(multigraph_test_graph):
+    G = multigraph_test_graph
+    G.add_edge(0, 1, weight=3)
+    A = nx.to_numpy_array(G, nodelist=[1, 2])
+    assert A.shape == (2, 2)
+    assert A[1, 0] == 77
+
+
+@pytest.mark.parametrize(
+    "G, expected",
+    [
+        (nx.Graph(), np.array([[0, 1 + 2j], [1 + 2j, 0]], dtype=complex)),
+        (nx.DiGraph(), np.array([[0, 1 + 2j], [0, 0]], dtype=complex)),
+    ],
+)
+def test_to_numpy_array_complex_weights(G, expected):
+    G.add_edge(0, 1, weight=1 + 2j)
+    A = nx.to_numpy_array(G, dtype=complex)
+    npt.assert_array_equal(A, expected)
+
+
+def test_to_numpy_array_arbitrary_weights():
+    G = nx.DiGraph()
+    w = 922337203685477580102  # Out of range for int64
+    G.add_edge(0, 1, weight=922337203685477580102)  # val not representable by int64
+    A = nx.to_numpy_array(G, dtype=object)
+    expected = np.array([[0, w], [0, 0]], dtype=object)
+    npt.assert_array_equal(A, expected)
+
+    # Undirected
+    A = nx.to_numpy_array(G.to_undirected(), dtype=object)
+    expected = np.array([[0, w], [w, 0]], dtype=object)
+    npt.assert_array_equal(A, expected)
+
+
+@pytest.mark.parametrize(
+    "func, expected",
+    ((min, -1), (max, 10), (sum, 11), (np.mean, 11 / 3), (np.median, 2)),
+)
+def test_to_numpy_array_multiweight_reduction(func, expected):
+    """Test various functions for reducing multiedge weights."""
+    G = nx.MultiDiGraph()
+    weights = [-1, 2, 10.0]
+    for w in weights:
+        G.add_edge(0, 1, weight=w)
+    A = nx.to_numpy_array(G, multigraph_weight=func, dtype=float)
+    assert np.allclose(A, [[0, expected], [0, 0]])
+
+    # Undirected case
+    A = nx.to_numpy_array(G.to_undirected(), multigraph_weight=func, dtype=float)
+    assert np.allclose(A, [[0, expected], [expected, 0]])
+
+
+@pytest.mark.parametrize(
+    ("G, expected"),
+    [
+        (nx.Graph(), [[(0, 0), (10, 5)], [(10, 5), (0, 0)]]),
+        (nx.DiGraph(), [[(0, 0), (10, 5)], [(0, 0), (0, 0)]]),
+    ],
+)
+def test_to_numpy_array_structured_dtype_attrs_from_fields(G, expected):
+    """When `dtype` is structured (i.e. has names) and `weight` is None, use
+    the named fields of the dtype to look up edge attributes."""
+    G.add_edge(0, 1, weight=10, cost=5.0)
+    dtype = np.dtype([("weight", int), ("cost", int)])
+    A = nx.to_numpy_array(G, dtype=dtype, weight=None)
+    expected = np.asarray(expected, dtype=dtype)
+    npt.assert_array_equal(A, expected)
+
+
+def test_to_numpy_array_structured_dtype_single_attr_default():
+    G = nx.path_graph(3)
+    dtype = np.dtype([("weight", float)])  # A single named field
+    A = nx.to_numpy_array(G, dtype=dtype, weight=None)
+    expected = np.array([[0, 1, 0], [1, 0, 1], [0, 1, 0]], dtype=float)
+    npt.assert_array_equal(A["weight"], expected)
+
+
+@pytest.mark.parametrize(
+    ("field_name", "expected_attr_val"),
+    [
+        ("weight", 1),
+        ("cost", 3),
+    ],
+)
+def test_to_numpy_array_structured_dtype_single_attr(field_name, expected_attr_val):
+    G = nx.Graph()
+    G.add_edge(0, 1, cost=3)
+    dtype = np.dtype([(field_name, float)])
+    A = nx.to_numpy_array(G, dtype=dtype, weight=None)
+    expected = np.array([[0, expected_attr_val], [expected_attr_val, 0]], dtype=float)
+    npt.assert_array_equal(A[field_name], expected)
+
+
+@pytest.mark.parametrize("graph_type", (nx.Graph, nx.DiGraph))
+@pytest.mark.parametrize(
+    "edge",
+    [
+        (0, 1),  # No edge attributes
+        (0, 1, {"weight": 10}),  # One edge attr
+        (0, 1, {"weight": 5, "flow": -4}),  # Multiple but not all edge attrs
+        (0, 1, {"weight": 2.0, "cost": 10, "flow": -45}),  # All attrs
+    ],
+)
+def test_to_numpy_array_structured_dtype_multiple_fields(graph_type, edge):
+    G = graph_type([edge])
+    dtype = np.dtype([("weight", float), ("cost", float), ("flow", float)])
+    A = nx.to_numpy_array(G, dtype=dtype, weight=None)
+    for attr in dtype.names:
+        expected = nx.to_numpy_array(G, dtype=float, weight=attr)
+        npt.assert_array_equal(A[attr], expected)
+
+
+@pytest.mark.parametrize("G", (nx.Graph(), nx.DiGraph()))
+def test_to_numpy_array_structured_dtype_scalar_nonedge(G):
+    G.add_edge(0, 1, weight=10)
+    dtype = np.dtype([("weight", float), ("cost", float)])
+    A = nx.to_numpy_array(G, dtype=dtype, weight=None, nonedge=np.nan)
+    for attr in dtype.names:
+        expected = nx.to_numpy_array(G, dtype=float, weight=attr, nonedge=np.nan)
+        npt.assert_array_equal(A[attr], expected)
+
+
+@pytest.mark.parametrize("G", (nx.Graph(), nx.DiGraph()))
+def test_to_numpy_array_structured_dtype_nonedge_ary(G):
+    """Similar to the scalar case, except has a different non-edge value for
+    each named field."""
+    G.add_edge(0, 1, weight=10)
+    dtype = np.dtype([("weight", float), ("cost", float)])
+    nonedges = np.array([(0, np.inf)], dtype=dtype)
+    A = nx.to_numpy_array(G, dtype=dtype, weight=None, nonedge=nonedges)
+    for attr in dtype.names:
+        nonedge = nonedges[attr]
+        expected = nx.to_numpy_array(G, dtype=float, weight=attr, nonedge=nonedge)
+        npt.assert_array_equal(A[attr], expected)
+
+
+def test_to_numpy_array_structured_dtype_with_weight_raises():
+    """Using both a structured dtype (with named fields) and specifying a `weight`
+    parameter is ambiguous."""
+    G = nx.path_graph(3)
+    dtype = np.dtype([("weight", int), ("cost", int)])
+    exception_msg = "Specifying `weight` not supported for structured dtypes"
+    with pytest.raises(ValueError, match=exception_msg):
+        nx.to_numpy_array(G, dtype=dtype)  # Default is weight="weight"
+    with pytest.raises(ValueError, match=exception_msg):
+        nx.to_numpy_array(G, dtype=dtype, weight="cost")
+
+
+@pytest.mark.parametrize("graph_type", (nx.MultiGraph, nx.MultiDiGraph))
+def test_to_numpy_array_structured_multigraph_raises(graph_type):
+    G = nx.path_graph(3, create_using=graph_type)
+    dtype = np.dtype([("weight", int), ("cost", int)])
+    with pytest.raises(nx.NetworkXError, match="Structured arrays are not supported"):
+        nx.to_numpy_array(G, dtype=dtype, weight=None)
diff --git a/myenv/lib/python3.9/site-packages/networkx/tests/test_convert_pandas.py b/myenv/lib/python3.9/site-packages/networkx/tests/test_convert_pandas.py
new file mode 100644
index 0000000..d3830e6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/tests/test_convert_pandas.py
@@ -0,0 +1,322 @@
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, graphs_equal, nodes_equal
+
+np = pytest.importorskip("numpy")
+pd = pytest.importorskip("pandas")
+
+
+class TestConvertPandas:
+    def setup_method(self):
+        self.rng = np.random.RandomState(seed=5)
+        ints = self.rng.randint(1, 11, size=(3, 2))
+        a = ["A", "B", "C"]
+        b = ["D", "A", "E"]
+        df = pd.DataFrame(ints, columns=["weight", "cost"])
+        df[0] = a  # Column label 0 (int)
+        df["b"] = b  # Column label 'b' (str)
+        self.df = df
+
+        mdf = pd.DataFrame([[4, 16, "A", "D"]], columns=["weight", "cost", 0, "b"])
+        self.mdf = pd.concat([df, mdf])
+
+    def test_exceptions(self):
+        G = pd.DataFrame(["a"])  # adj
+        pytest.raises(nx.NetworkXError, nx.to_networkx_graph, G)
+        G = pd.DataFrame(["a", 0.0])  # elist
+        pytest.raises(nx.NetworkXError, nx.to_networkx_graph, G)
+        df = pd.DataFrame([[1, 1], [1, 0]], dtype=int, index=[1, 2], columns=["a", "b"])
+        pytest.raises(nx.NetworkXError, nx.from_pandas_adjacency, df)
+
+    def test_from_edgelist_all_attr(self):
+        Gtrue = nx.Graph(
+            [
+                ("E", "C", {"cost": 9, "weight": 10}),
+                ("B", "A", {"cost": 1, "weight": 7}),
+                ("A", "D", {"cost": 7, "weight": 4}),
+            ]
+        )
+        G = nx.from_pandas_edgelist(self.df, 0, "b", True)
+        assert graphs_equal(G, Gtrue)
+        # MultiGraph
+        MGtrue = nx.MultiGraph(Gtrue)
+        MGtrue.add_edge("A", "D", cost=16, weight=4)
+        MG = nx.from_pandas_edgelist(self.mdf, 0, "b", True, nx.MultiGraph())
+        assert graphs_equal(MG, MGtrue)
+
+    def test_from_edgelist_multi_attr(self):
+        Gtrue = nx.Graph(
+            [
+                ("E", "C", {"cost": 9, "weight": 10}),
+                ("B", "A", {"cost": 1, "weight": 7}),
+                ("A", "D", {"cost": 7, "weight": 4}),
+            ]
+        )
+        G = nx.from_pandas_edgelist(self.df, 0, "b", ["weight", "cost"])
+        assert graphs_equal(G, Gtrue)
+
+    def test_from_edgelist_multi_attr_incl_target(self):
+        Gtrue = nx.Graph(
+            [
+                ("E", "C", {0: "C", "b": "E", "weight": 10}),
+                ("B", "A", {0: "B", "b": "A", "weight": 7}),
+                ("A", "D", {0: "A", "b": "D", "weight": 4}),
+            ]
+        )
+        G = nx.from_pandas_edgelist(self.df, 0, "b", [0, "b", "weight"])
+        assert graphs_equal(G, Gtrue)
+
+    def test_from_edgelist_multidigraph_and_edge_attr(self):
+        # example from issue #2374
+        edges = [
+            ("X1", "X4", {"Co": "zA", "Mi": 0, "St": "X1"}),
+            ("X1", "X4", {"Co": "zB", "Mi": 54, "St": "X2"}),
+            ("X1", "X4", {"Co": "zB", "Mi": 49, "St": "X3"}),
+            ("X1", "X4", {"Co": "zB", "Mi": 44, "St": "X4"}),
+            ("Y1", "Y3", {"Co": "zC", "Mi": 0, "St": "Y1"}),
+            ("Y1", "Y3", {"Co": "zC", "Mi": 34, "St": "Y2"}),
+            ("Y1", "Y3", {"Co": "zC", "Mi": 29, "St": "X2"}),
+            ("Y1", "Y3", {"Co": "zC", "Mi": 24, "St": "Y3"}),
+            ("Z1", "Z3", {"Co": "zD", "Mi": 0, "St": "Z1"}),
+            ("Z1", "Z3", {"Co": "zD", "Mi": 14, "St": "X3"}),
+        ]
+        Gtrue = nx.MultiDiGraph(edges)
+        data = {
+            "O": ["X1", "X1", "X1", "X1", "Y1", "Y1", "Y1", "Y1", "Z1", "Z1"],
+            "D": ["X4", "X4", "X4", "X4", "Y3", "Y3", "Y3", "Y3", "Z3", "Z3"],
+            "St": ["X1", "X2", "X3", "X4", "Y1", "Y2", "X2", "Y3", "Z1", "X3"],
+            "Co": ["zA", "zB", "zB", "zB", "zC", "zC", "zC", "zC", "zD", "zD"],
+            "Mi": [0, 54, 49, 44, 0, 34, 29, 24, 0, 14],
+        }
+        df = pd.DataFrame.from_dict(data)
+        G1 = nx.from_pandas_edgelist(
+            df, source="O", target="D", edge_attr=True, create_using=nx.MultiDiGraph
+        )
+        G2 = nx.from_pandas_edgelist(
+            df,
+            source="O",
+            target="D",
+            edge_attr=["St", "Co", "Mi"],
+            create_using=nx.MultiDiGraph,
+        )
+        assert graphs_equal(G1, Gtrue)
+        assert graphs_equal(G2, Gtrue)
+
+    def test_from_edgelist_one_attr(self):
+        Gtrue = nx.Graph(
+            [
+                ("E", "C", {"weight": 10}),
+                ("B", "A", {"weight": 7}),
+                ("A", "D", {"weight": 4}),
+            ]
+        )
+        G = nx.from_pandas_edgelist(self.df, 0, "b", "weight")
+        assert graphs_equal(G, Gtrue)
+
+    def test_from_edgelist_int_attr_name(self):
+        # note: this also tests that edge_attr can be `source`
+        Gtrue = nx.Graph(
+            [("E", "C", {0: "C"}), ("B", "A", {0: "B"}), ("A", "D", {0: "A"})]
+        )
+        G = nx.from_pandas_edgelist(self.df, 0, "b", 0)
+        assert graphs_equal(G, Gtrue)
+
+    def test_from_edgelist_invalid_attr(self):
+        pytest.raises(
+            nx.NetworkXError, nx.from_pandas_edgelist, self.df, 0, "b", "misspell"
+        )
+        pytest.raises(nx.NetworkXError, nx.from_pandas_edgelist, self.df, 0, "b", 1)
+        # see Issue #3562
+        edgeframe = pd.DataFrame([[0, 1], [1, 2], [2, 0]], columns=["s", "t"])
+        pytest.raises(
+            nx.NetworkXError, nx.from_pandas_edgelist, edgeframe, "s", "t", True
+        )
+        pytest.raises(
+            nx.NetworkXError, nx.from_pandas_edgelist, edgeframe, "s", "t", "weight"
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            nx.from_pandas_edgelist,
+            edgeframe,
+            "s",
+            "t",
+            ["weight", "size"],
+        )
+
+    def test_from_edgelist_no_attr(self):
+        Gtrue = nx.Graph([("E", "C", {}), ("B", "A", {}), ("A", "D", {})])
+        G = nx.from_pandas_edgelist(self.df, 0, "b")
+        assert graphs_equal(G, Gtrue)
+
+    def test_from_edgelist(self):
+        # Pandas DataFrame
+        G = nx.cycle_graph(10)
+        G.add_weighted_edges_from((u, v, u) for u, v in list(G.edges))
+
+        edgelist = nx.to_edgelist(G)
+        source = [s for s, t, d in edgelist]
+        target = [t for s, t, d in edgelist]
+        weight = [d["weight"] for s, t, d in edgelist]
+        edges = pd.DataFrame({"source": source, "target": target, "weight": weight})
+
+        GG = nx.from_pandas_edgelist(edges, edge_attr="weight")
+        assert nodes_equal(G.nodes(), GG.nodes())
+        assert edges_equal(G.edges(), GG.edges())
+        GW = nx.to_networkx_graph(edges, create_using=nx.Graph)
+        assert nodes_equal(G.nodes(), GW.nodes())
+        assert edges_equal(G.edges(), GW.edges())
+
+    def test_to_edgelist_default_source_or_target_col_exists(self):
+
+        G = nx.path_graph(10)
+        G.add_weighted_edges_from((u, v, u) for u, v in list(G.edges))
+        nx.set_edge_attributes(G, 0, name="source")
+        pytest.raises(nx.NetworkXError, nx.to_pandas_edgelist, G)
+
+        # drop source column to test an exception raised for the target column
+        for u, v, d in G.edges(data=True):
+            d.pop("source", None)
+
+        nx.set_edge_attributes(G, 0, name="target")
+        pytest.raises(nx.NetworkXError, nx.to_pandas_edgelist, G)
+
+    def test_to_edgelist_custom_source_or_target_col_exists(self):
+
+        G = nx.path_graph(10)
+        G.add_weighted_edges_from((u, v, u) for u, v in list(G.edges))
+        nx.set_edge_attributes(G, 0, name="source_col_name")
+        pytest.raises(
+            nx.NetworkXError, nx.to_pandas_edgelist, G, source="source_col_name"
+        )
+
+        # drop source column to test an exception raised for the target column
+        for u, v, d in G.edges(data=True):
+            d.pop("source_col_name", None)
+
+        nx.set_edge_attributes(G, 0, name="target_col_name")
+        pytest.raises(
+            nx.NetworkXError, nx.to_pandas_edgelist, G, target="target_col_name"
+        )
+
+    def test_to_edgelist_edge_key_col_exists(self):
+        G = nx.path_graph(10, create_using=nx.MultiGraph)
+        G.add_weighted_edges_from((u, v, u) for u, v in list(G.edges()))
+        nx.set_edge_attributes(G, 0, name="edge_key_name")
+        pytest.raises(
+            nx.NetworkXError, nx.to_pandas_edgelist, G, edge_key="edge_key_name"
+        )
+
+    def test_from_adjacency(self):
+        nodelist = [1, 2]
+        dftrue = pd.DataFrame(
+            [[1, 1], [1, 0]], dtype=int, index=nodelist, columns=nodelist
+        )
+        G = nx.Graph([(1, 1), (1, 2)])
+        df = nx.to_pandas_adjacency(G, dtype=int)
+        pd.testing.assert_frame_equal(df, dftrue)
+
+    @pytest.mark.parametrize("graph", [nx.Graph, nx.MultiGraph])
+    def test_roundtrip(self, graph):
+        # edgelist
+        Gtrue = graph([(1, 1), (1, 2)])
+        df = nx.to_pandas_edgelist(Gtrue)
+        G = nx.from_pandas_edgelist(df, create_using=graph)
+        assert graphs_equal(Gtrue, G)
+        # adjacency
+        adj = {1: {1: {"weight": 1}, 2: {"weight": 1}}, 2: {1: {"weight": 1}}}
+        Gtrue = graph(adj)
+        df = nx.to_pandas_adjacency(Gtrue, dtype=int)
+        G = nx.from_pandas_adjacency(df, create_using=graph)
+        assert graphs_equal(Gtrue, G)
+
+    def test_from_adjacency_named(self):
+        # example from issue #3105
+        data = {
+            "A": {"A": 0, "B": 0, "C": 0},
+            "B": {"A": 1, "B": 0, "C": 0},
+            "C": {"A": 0, "B": 1, "C": 0},
+        }
+        dftrue = pd.DataFrame(data, dtype=np.intp)
+        df = dftrue[["A", "C", "B"]]
+        G = nx.from_pandas_adjacency(df, create_using=nx.DiGraph())
+        df = nx.to_pandas_adjacency(G, dtype=np.intp)
+        pd.testing.assert_frame_equal(df, dftrue)
+
+    def test_edgekey_with_multigraph(self):
+        df = pd.DataFrame(
+            {
+                "source": {"A": "N1", "B": "N2", "C": "N1", "D": "N1"},
+                "target": {"A": "N2", "B": "N3", "C": "N1", "D": "N2"},
+                "attr1": {"A": "F1", "B": "F2", "C": "F3", "D": "F4"},
+                "attr2": {"A": 1, "B": 0, "C": 0, "D": 0},
+                "attr3": {"A": 0, "B": 1, "C": 0, "D": 1},
+            }
+        )
+        Gtrue = nx.MultiGraph(
+            [
+                ("N1", "N2", "F1", {"attr2": 1, "attr3": 0}),
+                ("N2", "N3", "F2", {"attr2": 0, "attr3": 1}),
+                ("N1", "N1", "F3", {"attr2": 0, "attr3": 0}),
+                ("N1", "N2", "F4", {"attr2": 0, "attr3": 1}),
+            ]
+        )
+        # example from issue #4065
+        G = nx.from_pandas_edgelist(
+            df,
+            source="source",
+            target="target",
+            edge_attr=["attr2", "attr3"],
+            edge_key="attr1",
+            create_using=nx.MultiGraph(),
+        )
+        assert graphs_equal(G, Gtrue)
+
+        df_roundtrip = nx.to_pandas_edgelist(G, edge_key="attr1")
+        df_roundtrip = df_roundtrip.sort_values("attr1")
+        df_roundtrip.index = ["A", "B", "C", "D"]
+        pd.testing.assert_frame_equal(
+            df, df_roundtrip[["source", "target", "attr1", "attr2", "attr3"]]
+        )
+
+    def test_edgekey_with_normal_graph_no_action(self):
+        Gtrue = nx.Graph(
+            [
+                ("E", "C", {"cost": 9, "weight": 10}),
+                ("B", "A", {"cost": 1, "weight": 7}),
+                ("A", "D", {"cost": 7, "weight": 4}),
+            ]
+        )
+        G = nx.from_pandas_edgelist(self.df, 0, "b", True, edge_key="weight")
+        assert graphs_equal(G, Gtrue)
+
+    def test_nonexisting_edgekey_raises(self):
+        with pytest.raises(nx.exception.NetworkXError):
+            nx.from_pandas_edgelist(
+                self.df,
+                source="source",
+                target="target",
+                edge_key="Not_real",
+                edge_attr=True,
+                create_using=nx.MultiGraph(),
+            )
+
+
+def test_to_pandas_adjacency_with_nodelist():
+    G = nx.complete_graph(5)
+    nodelist = [1, 4]
+    expected = pd.DataFrame(
+        [[0, 1], [1, 0]], dtype=int, index=nodelist, columns=nodelist
+    )
+    pd.testing.assert_frame_equal(
+        expected, nx.to_pandas_adjacency(G, nodelist, dtype=int)
+    )
+
+
+def test_to_pandas_edgelist_with_nodelist():
+    G = nx.Graph()
+    G.add_edges_from([(0, 1), (1, 2), (1, 3)], weight=2.0)
+    G.add_edge(0, 5, weight=100)
+    df = nx.to_pandas_edgelist(G, nodelist=[1, 2])
+    assert 0 not in df["source"].to_numpy()
+    assert 100 not in df["weight"].to_numpy()
diff --git a/myenv/lib/python3.9/site-packages/networkx/tests/test_convert_scipy.py b/myenv/lib/python3.9/site-packages/networkx/tests/test_convert_scipy.py
new file mode 100644
index 0000000..4b2537d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/tests/test_convert_scipy.py
@@ -0,0 +1,293 @@
+import pytest
+
+np = pytest.importorskip("numpy")
+sp = pytest.importorskip("scipy")
+import scipy.sparse  # call as sp.sparse
+
+import networkx as nx
+from networkx.generators.classic import barbell_graph, cycle_graph, path_graph
+from networkx.utils import graphs_equal
+
+
+class TestConvertScipy:
+    def setup_method(self):
+        self.G1 = barbell_graph(10, 3)
+        self.G2 = cycle_graph(10, create_using=nx.DiGraph)
+
+        self.G3 = self.create_weighted(nx.Graph())
+        self.G4 = self.create_weighted(nx.DiGraph())
+
+    def test_exceptions(self):
+        class G:
+            format = None
+
+        pytest.raises(nx.NetworkXError, nx.to_networkx_graph, G)
+
+    def create_weighted(self, G):
+        g = cycle_graph(4)
+        e = list(g.edges())
+        source = [u for u, v in e]
+        dest = [v for u, v in e]
+        weight = [s + 10 for s in source]
+        ex = zip(source, dest, weight)
+        G.add_weighted_edges_from(ex)
+        return G
+
+    def identity_conversion(self, G, A, create_using):
+        GG = nx.from_scipy_sparse_array(A, create_using=create_using)
+        assert nx.is_isomorphic(G, GG)
+
+        GW = nx.to_networkx_graph(A, create_using=create_using)
+        assert nx.is_isomorphic(G, GW)
+
+        GI = nx.empty_graph(0, create_using).__class__(A)
+        assert nx.is_isomorphic(G, GI)
+
+        ACSR = A.tocsr()
+        GI = nx.empty_graph(0, create_using).__class__(ACSR)
+        assert nx.is_isomorphic(G, GI)
+
+        ACOO = A.tocoo()
+        GI = nx.empty_graph(0, create_using).__class__(ACOO)
+        assert nx.is_isomorphic(G, GI)
+
+        ACSC = A.tocsc()
+        GI = nx.empty_graph(0, create_using).__class__(ACSC)
+        assert nx.is_isomorphic(G, GI)
+
+        AD = A.todense()
+        GI = nx.empty_graph(0, create_using).__class__(AD)
+        assert nx.is_isomorphic(G, GI)
+
+        AA = A.toarray()
+        GI = nx.empty_graph(0, create_using).__class__(AA)
+        assert nx.is_isomorphic(G, GI)
+
+    def test_shape(self):
+        "Conversion from non-square sparse array."
+        A = sp.sparse.lil_array([[1, 2, 3], [4, 5, 6]])
+        pytest.raises(nx.NetworkXError, nx.from_scipy_sparse_array, A)
+
+    def test_identity_graph_matrix(self):
+        "Conversion from graph to sparse matrix to graph."
+        A = nx.to_scipy_sparse_array(self.G1)
+        self.identity_conversion(self.G1, A, nx.Graph())
+
+    def test_identity_digraph_matrix(self):
+        "Conversion from digraph to sparse matrix to digraph."
+        A = nx.to_scipy_sparse_array(self.G2)
+        self.identity_conversion(self.G2, A, nx.DiGraph())
+
+    def test_identity_weighted_graph_matrix(self):
+        """Conversion from weighted graph to sparse matrix to weighted graph."""
+        A = nx.to_scipy_sparse_array(self.G3)
+        self.identity_conversion(self.G3, A, nx.Graph())
+
+    def test_identity_weighted_digraph_matrix(self):
+        """Conversion from weighted digraph to sparse matrix to weighted digraph."""
+        A = nx.to_scipy_sparse_array(self.G4)
+        self.identity_conversion(self.G4, A, nx.DiGraph())
+
+    def test_nodelist(self):
+        """Conversion from graph to sparse matrix to graph with nodelist."""
+        P4 = path_graph(4)
+        P3 = path_graph(3)
+        nodelist = list(P3.nodes())
+        A = nx.to_scipy_sparse_array(P4, nodelist=nodelist)
+        GA = nx.Graph(A)
+        assert nx.is_isomorphic(GA, P3)
+
+        pytest.raises(nx.NetworkXError, nx.to_scipy_sparse_array, P3, nodelist=[])
+        # Test nodelist duplicates.
+        long_nl = nodelist + [0]
+        pytest.raises(nx.NetworkXError, nx.to_scipy_sparse_array, P3, nodelist=long_nl)
+
+        # Test nodelist contains non-nodes
+        non_nl = [-1, 0, 1, 2]
+        pytest.raises(nx.NetworkXError, nx.to_scipy_sparse_array, P3, nodelist=non_nl)
+
+    def test_weight_keyword(self):
+        WP4 = nx.Graph()
+        WP4.add_edges_from((n, n + 1, dict(weight=0.5, other=0.3)) for n in range(3))
+        P4 = path_graph(4)
+        A = nx.to_scipy_sparse_array(P4)
+        np.testing.assert_equal(
+            A.todense(), nx.to_scipy_sparse_array(WP4, weight=None).todense()
+        )
+        np.testing.assert_equal(
+            0.5 * A.todense(), nx.to_scipy_sparse_array(WP4).todense()
+        )
+        np.testing.assert_equal(
+            0.3 * A.todense(), nx.to_scipy_sparse_array(WP4, weight="other").todense()
+        )
+
+    def test_format_keyword(self):
+        WP4 = nx.Graph()
+        WP4.add_edges_from((n, n + 1, dict(weight=0.5, other=0.3)) for n in range(3))
+        P4 = path_graph(4)
+        A = nx.to_scipy_sparse_array(P4, format="csr")
+        np.testing.assert_equal(
+            A.todense(), nx.to_scipy_sparse_array(WP4, weight=None).todense()
+        )
+
+        A = nx.to_scipy_sparse_array(P4, format="csc")
+        np.testing.assert_equal(
+            A.todense(), nx.to_scipy_sparse_array(WP4, weight=None).todense()
+        )
+
+        A = nx.to_scipy_sparse_array(P4, format="coo")
+        np.testing.assert_equal(
+            A.todense(), nx.to_scipy_sparse_array(WP4, weight=None).todense()
+        )
+
+        A = nx.to_scipy_sparse_array(P4, format="bsr")
+        np.testing.assert_equal(
+            A.todense(), nx.to_scipy_sparse_array(WP4, weight=None).todense()
+        )
+
+        A = nx.to_scipy_sparse_array(P4, format="lil")
+        np.testing.assert_equal(
+            A.todense(), nx.to_scipy_sparse_array(WP4, weight=None).todense()
+        )
+
+        A = nx.to_scipy_sparse_array(P4, format="dia")
+        np.testing.assert_equal(
+            A.todense(), nx.to_scipy_sparse_array(WP4, weight=None).todense()
+        )
+
+        A = nx.to_scipy_sparse_array(P4, format="dok")
+        np.testing.assert_equal(
+            A.todense(), nx.to_scipy_sparse_array(WP4, weight=None).todense()
+        )
+
+    def test_format_keyword_raise(self):
+        with pytest.raises(nx.NetworkXError):
+            WP4 = nx.Graph()
+            WP4.add_edges_from(
+                (n, n + 1, dict(weight=0.5, other=0.3)) for n in range(3)
+            )
+            P4 = path_graph(4)
+            nx.to_scipy_sparse_array(P4, format="any_other")
+
+    def test_null_raise(self):
+        with pytest.raises(nx.NetworkXError):
+            nx.to_scipy_sparse_array(nx.Graph())
+
+    def test_empty(self):
+        G = nx.Graph()
+        G.add_node(1)
+        M = nx.to_scipy_sparse_array(G)
+        np.testing.assert_equal(M.toarray(), np.array([[0]]))
+
+    def test_ordering(self):
+        G = nx.DiGraph()
+        G.add_edge(1, 2)
+        G.add_edge(2, 3)
+        G.add_edge(3, 1)
+        M = nx.to_scipy_sparse_array(G, nodelist=[3, 2, 1])
+        np.testing.assert_equal(
+            M.toarray(), np.array([[0, 0, 1], [1, 0, 0], [0, 1, 0]])
+        )
+
+    def test_selfloop_graph(self):
+        G = nx.Graph([(1, 1)])
+        M = nx.to_scipy_sparse_array(G)
+        np.testing.assert_equal(M.toarray(), np.array([[1]]))
+
+        G.add_edges_from([(2, 3), (3, 4)])
+        M = nx.to_scipy_sparse_array(G, nodelist=[2, 3, 4])
+        np.testing.assert_equal(
+            M.toarray(), np.array([[0, 1, 0], [1, 0, 1], [0, 1, 0]])
+        )
+
+    def test_selfloop_digraph(self):
+        G = nx.DiGraph([(1, 1)])
+        M = nx.to_scipy_sparse_array(G)
+        np.testing.assert_equal(M.toarray(), np.array([[1]]))
+
+        G.add_edges_from([(2, 3), (3, 4)])
+        M = nx.to_scipy_sparse_array(G, nodelist=[2, 3, 4])
+        np.testing.assert_equal(
+            M.toarray(), np.array([[0, 1, 0], [0, 0, 1], [0, 0, 0]])
+        )
+
+    def test_from_scipy_sparse_array_parallel_edges(self):
+        """Tests that the :func:`networkx.from_scipy_sparse_array` function
+        interprets integer weights as the number of parallel edges when
+        creating a multigraph.
+
+        """
+        A = sp.sparse.csr_array([[1, 1], [1, 2]])
+        # First, with a simple graph, each integer entry in the adjacency
+        # matrix is interpreted as the weight of a single edge in the graph.
+        expected = nx.DiGraph()
+        edges = [(0, 0), (0, 1), (1, 0)]
+        expected.add_weighted_edges_from([(u, v, 1) for (u, v) in edges])
+        expected.add_edge(1, 1, weight=2)
+        actual = nx.from_scipy_sparse_array(
+            A, parallel_edges=True, create_using=nx.DiGraph
+        )
+        assert graphs_equal(actual, expected)
+        actual = nx.from_scipy_sparse_array(
+            A, parallel_edges=False, create_using=nx.DiGraph
+        )
+        assert graphs_equal(actual, expected)
+        # Now each integer entry in the adjacency matrix is interpreted as the
+        # number of parallel edges in the graph if the appropriate keyword
+        # argument is specified.
+        edges = [(0, 0), (0, 1), (1, 0), (1, 1), (1, 1)]
+        expected = nx.MultiDiGraph()
+        expected.add_weighted_edges_from([(u, v, 1) for (u, v) in edges])
+        actual = nx.from_scipy_sparse_array(
+            A, parallel_edges=True, create_using=nx.MultiDiGraph
+        )
+        assert graphs_equal(actual, expected)
+        expected = nx.MultiDiGraph()
+        expected.add_edges_from(set(edges), weight=1)
+        # The sole self-loop (edge 0) on vertex 1 should have weight 2.
+        expected[1][1][0]["weight"] = 2
+        actual = nx.from_scipy_sparse_array(
+            A, parallel_edges=False, create_using=nx.MultiDiGraph
+        )
+        assert graphs_equal(actual, expected)
+
+    def test_symmetric(self):
+        """Tests that a symmetric matrix has edges added only once to an
+        undirected multigraph when using
+        :func:`networkx.from_scipy_sparse_array`.
+
+        """
+        A = sp.sparse.csr_array([[0, 1], [1, 0]])
+        G = nx.from_scipy_sparse_array(A, create_using=nx.MultiGraph)
+        expected = nx.MultiGraph()
+        expected.add_edge(0, 1, weight=1)
+        assert graphs_equal(G, expected)
+
+
+@pytest.mark.parametrize("sparse_format", ("csr", "csc", "dok"))
+def test_from_scipy_sparse_array_formats(sparse_format):
+    """Test all formats supported by _generate_weighted_edges."""
+    # trinode complete graph with non-uniform edge weights
+    expected = nx.Graph()
+    expected.add_edges_from(
+        [
+            (0, 1, {"weight": 3}),
+            (0, 2, {"weight": 2}),
+            (1, 0, {"weight": 3}),
+            (1, 2, {"weight": 1}),
+            (2, 0, {"weight": 2}),
+            (2, 1, {"weight": 1}),
+        ]
+    )
+    A = sp.sparse.coo_array([[0, 3, 2], [3, 0, 1], [2, 1, 0]]).asformat(sparse_format)
+    assert graphs_equal(expected, nx.from_scipy_sparse_array(A))
+
+
+# NOTE: remove when to/from_sparse_matrix deprecations expire
+def test_scipy_sparse_matrix_deprecations():
+    G = nx.path_graph(3)
+    msg = "\n\nThe scipy.sparse array containers will be used instead of matrices"
+    with pytest.warns(DeprecationWarning, match=msg):
+        M = nx.to_scipy_sparse_matrix(G)
+    with pytest.warns(DeprecationWarning, match=msg):
+        H = nx.from_scipy_sparse_matrix(M)
diff --git a/myenv/lib/python3.9/site-packages/networkx/tests/test_exceptions.py b/myenv/lib/python3.9/site-packages/networkx/tests/test_exceptions.py
new file mode 100644
index 0000000..cf59983
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/tests/test_exceptions.py
@@ -0,0 +1,40 @@
+import pytest
+
+import networkx as nx
+
+# smoke tests for exceptions
+
+
+def test_raises_networkxexception():
+    with pytest.raises(nx.NetworkXException):
+        raise nx.NetworkXException
+
+
+def test_raises_networkxerr():
+    with pytest.raises(nx.NetworkXError):
+        raise nx.NetworkXError
+
+
+def test_raises_networkx_pointless_concept():
+    with pytest.raises(nx.NetworkXPointlessConcept):
+        raise nx.NetworkXPointlessConcept
+
+
+def test_raises_networkxalgorithmerr():
+    with pytest.raises(nx.NetworkXAlgorithmError):
+        raise nx.NetworkXAlgorithmError
+
+
+def test_raises_networkx_unfeasible():
+    with pytest.raises(nx.NetworkXUnfeasible):
+        raise nx.NetworkXUnfeasible
+
+
+def test_raises_networkx_no_path():
+    with pytest.raises(nx.NetworkXNoPath):
+        raise nx.NetworkXNoPath
+
+
+def test_raises_networkx_unbounded():
+    with pytest.raises(nx.NetworkXUnbounded):
+        raise nx.NetworkXUnbounded
diff --git a/myenv/lib/python3.9/site-packages/networkx/tests/test_import.py b/myenv/lib/python3.9/site-packages/networkx/tests/test_import.py
new file mode 100644
index 0000000..32aafdf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/tests/test_import.py
@@ -0,0 +1,11 @@
+import pytest
+
+
+def test_namespace_alias():
+    with pytest.raises(ImportError):
+        from networkx import nx
+
+
+def test_namespace_nesting():
+    with pytest.raises(ImportError):
+        from networkx import networkx
diff --git a/myenv/lib/python3.9/site-packages/networkx/tests/test_lazy_imports.py b/myenv/lib/python3.9/site-packages/networkx/tests/test_lazy_imports.py
new file mode 100644
index 0000000..fe022c4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/tests/test_lazy_imports.py
@@ -0,0 +1,97 @@
+import importlib
+import sys
+import types
+
+import pytest
+
+import networkx.lazy_imports as lazy
+
+
+def test_lazy_import_basics():
+    math = lazy._lazy_import("math")
+    anything_not_real = lazy._lazy_import("anything_not_real")
+
+    # Now test that accessing attributes does what it should
+    assert math.sin(math.pi) == pytest.approx(0, 1e-6)
+    # poor-mans pytest.raises for testing errors on attribute access
+    try:
+        anything_not_real.pi
+        assert False  # Should not get here
+    except ModuleNotFoundError:
+        pass
+    assert isinstance(anything_not_real, lazy.DelayedImportErrorModule)
+    # see if it changes for second access
+    try:
+        anything_not_real.pi
+        assert False  # Should not get here
+    except ModuleNotFoundError:
+        pass
+
+
+def test_lazy_import_impact_on_sys_modules():
+    math = lazy._lazy_import("math")
+    anything_not_real = lazy._lazy_import("anything_not_real")
+
+    assert type(math) == types.ModuleType
+    assert "math" in sys.modules
+    assert type(anything_not_real) == lazy.DelayedImportErrorModule
+    assert "anything_not_real" not in sys.modules
+
+    # only do this if numpy is installed
+    np_test = pytest.importorskip("numpy")
+    np = lazy._lazy_import("numpy")
+    assert type(np) == types.ModuleType
+    assert "numpy" in sys.modules
+
+    np.pi  # trigger load of numpy
+
+    assert type(np) == types.ModuleType
+    assert "numpy" in sys.modules
+
+
+def test_lazy_import_nonbuiltins():
+    sp = lazy._lazy_import("scipy")
+    np = lazy._lazy_import("numpy")
+    if isinstance(sp, lazy.DelayedImportErrorModule):
+        try:
+            sp.pi
+            assert False
+        except ModuleNotFoundError:
+            pass
+    elif isinstance(np, lazy.DelayedImportErrorModule):
+        try:
+            np.sin(np.pi)
+            assert False
+        except ModuleNotFoundError:
+            pass
+    else:
+        assert np.sin(sp.pi) == pytest.approx(0, 1e-6)
+
+
+def test_lazy_attach():
+    name = "mymod"
+    submods = ["mysubmodule", "anothersubmodule"]
+    myall = {"not_real_submod": ["some_var_or_func"]}
+
+    locls = {
+        "attach": lazy.attach,
+        "name": name,
+        "submods": submods,
+        "myall": myall,
+    }
+    s = "__getattr__, __lazy_dir__, __all__ = attach(name, submods, myall)"
+
+    exec(s, {}, locls)
+    expected = {
+        "attach": lazy.attach,
+        "name": name,
+        "submods": submods,
+        "myall": myall,
+        "__getattr__": None,
+        "__lazy_dir__": None,
+        "__all__": None,
+    }
+    assert locls.keys() == expected.keys()
+    for k, v in expected.items():
+        if v is not None:
+            assert locls[k] == v
diff --git a/myenv/lib/python3.9/site-packages/networkx/tests/test_relabel.py b/myenv/lib/python3.9/site-packages/networkx/tests/test_relabel.py
new file mode 100644
index 0000000..a5d59f2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/tests/test_relabel.py
@@ -0,0 +1,302 @@
+import pytest
+
+import networkx as nx
+from networkx.generators.classic import empty_graph
+from networkx.utils import edges_equal, nodes_equal
+
+
+class TestRelabel:
+    def test_convert_node_labels_to_integers(self):
+        # test that empty graph converts fine for all options
+        G = empty_graph()
+        H = nx.convert_node_labels_to_integers(G, 100)
+        assert list(H.nodes()) == []
+        assert list(H.edges()) == []
+
+        for opt in ["default", "sorted", "increasing degree", "decreasing degree"]:
+            G = empty_graph()
+            H = nx.convert_node_labels_to_integers(G, 100, ordering=opt)
+            assert list(H.nodes()) == []
+            assert list(H.edges()) == []
+
+        G = empty_graph()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        H = nx.convert_node_labels_to_integers(G)
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+
+        H = nx.convert_node_labels_to_integers(G, 1000)
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+        assert nodes_equal(H.nodes(), [1000, 1001, 1002, 1003])
+
+        H = nx.convert_node_labels_to_integers(G, ordering="increasing degree")
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+        assert H.degree(0) == 1
+        assert H.degree(1) == 2
+        assert H.degree(2) == 2
+        assert H.degree(3) == 3
+
+        H = nx.convert_node_labels_to_integers(G, ordering="decreasing degree")
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+        assert H.degree(0) == 3
+        assert H.degree(1) == 2
+        assert H.degree(2) == 2
+        assert H.degree(3) == 1
+
+        H = nx.convert_node_labels_to_integers(
+            G, ordering="increasing degree", label_attribute="label"
+        )
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+        assert H.degree(0) == 1
+        assert H.degree(1) == 2
+        assert H.degree(2) == 2
+        assert H.degree(3) == 3
+
+        # check mapping
+        assert H.nodes[3]["label"] == "C"
+        assert H.nodes[0]["label"] == "D"
+        assert H.nodes[1]["label"] == "A" or H.nodes[2]["label"] == "A"
+        assert H.nodes[1]["label"] == "B" or H.nodes[2]["label"] == "B"
+
+    def test_convert_to_integers2(self):
+        G = empty_graph()
+        G.add_edges_from([("C", "D"), ("A", "B"), ("A", "C"), ("B", "C")])
+        H = nx.convert_node_labels_to_integers(G, ordering="sorted")
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+
+        H = nx.convert_node_labels_to_integers(
+            G, ordering="sorted", label_attribute="label"
+        )
+        assert H.nodes[0]["label"] == "A"
+        assert H.nodes[1]["label"] == "B"
+        assert H.nodes[2]["label"] == "C"
+        assert H.nodes[3]["label"] == "D"
+
+    def test_convert_to_integers_raise(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.Graph()
+            H = nx.convert_node_labels_to_integers(G, ordering="increasing age")
+
+    def test_relabel_nodes_copy(self):
+        G = nx.empty_graph()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        mapping = {"A": "aardvark", "B": "bear", "C": "cat", "D": "dog"}
+        H = nx.relabel_nodes(G, mapping)
+        assert nodes_equal(H.nodes(), ["aardvark", "bear", "cat", "dog"])
+
+    def test_relabel_nodes_function(self):
+        G = nx.empty_graph()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        # function mapping no longer encouraged but works
+
+        def mapping(n):
+            return ord(n)
+
+        H = nx.relabel_nodes(G, mapping)
+        assert nodes_equal(H.nodes(), [65, 66, 67, 68])
+
+    def test_relabel_nodes_graph(self):
+        G = nx.Graph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        mapping = {"A": "aardvark", "B": "bear", "C": "cat", "D": "dog"}
+        H = nx.relabel_nodes(G, mapping)
+        assert nodes_equal(H.nodes(), ["aardvark", "bear", "cat", "dog"])
+
+    def test_relabel_nodes_orderedgraph(self):
+        G = nx.OrderedGraph()
+        G.add_nodes_from([1, 2, 3])
+        G.add_edges_from([(1, 3), (2, 3)])
+        mapping = {1: "a", 2: "b", 3: "c"}
+        H = nx.relabel_nodes(G, mapping)
+        assert list(H.nodes) == ["a", "b", "c"]
+
+    def test_relabel_nodes_digraph(self):
+        G = nx.DiGraph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        mapping = {"A": "aardvark", "B": "bear", "C": "cat", "D": "dog"}
+        H = nx.relabel_nodes(G, mapping, copy=False)
+        assert nodes_equal(H.nodes(), ["aardvark", "bear", "cat", "dog"])
+
+    def test_relabel_nodes_multigraph(self):
+        G = nx.MultiGraph([("a", "b"), ("a", "b")])
+        mapping = {"a": "aardvark", "b": "bear"}
+        G = nx.relabel_nodes(G, mapping, copy=False)
+        assert nodes_equal(G.nodes(), ["aardvark", "bear"])
+        assert edges_equal(G.edges(), [("aardvark", "bear"), ("aardvark", "bear")])
+
+    def test_relabel_nodes_multidigraph(self):
+        G = nx.MultiDiGraph([("a", "b"), ("a", "b")])
+        mapping = {"a": "aardvark", "b": "bear"}
+        G = nx.relabel_nodes(G, mapping, copy=False)
+        assert nodes_equal(G.nodes(), ["aardvark", "bear"])
+        assert edges_equal(G.edges(), [("aardvark", "bear"), ("aardvark", "bear")])
+
+    def test_relabel_isolated_nodes_to_same(self):
+        G = nx.Graph()
+        G.add_nodes_from(range(4))
+        mapping = {1: 1}
+        H = nx.relabel_nodes(G, mapping, copy=False)
+        assert nodes_equal(H.nodes(), list(range(4)))
+
+    def test_relabel_nodes_missing(self):
+        G = nx.Graph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        mapping = {0: "aardvark"}
+        # copy=True
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        assert nodes_equal(H.nodes, G.nodes)
+        # copy=False
+        GG = G.copy()
+        nx.relabel_nodes(G, mapping, copy=False)
+        assert nodes_equal(G.nodes, GG.nodes)
+
+    def test_relabel_copy_name(self):
+        G = nx.Graph()
+        H = nx.relabel_nodes(G, {}, copy=True)
+        assert H.graph == G.graph
+        H = nx.relabel_nodes(G, {}, copy=False)
+        assert H.graph == G.graph
+        G.name = "first"
+        H = nx.relabel_nodes(G, {}, copy=True)
+        assert H.graph == G.graph
+        H = nx.relabel_nodes(G, {}, copy=False)
+        assert H.graph == G.graph
+
+    def test_relabel_toposort(self):
+        K5 = nx.complete_graph(4)
+        G = nx.complete_graph(4)
+        G = nx.relabel_nodes(G, {i: i + 1 for i in range(4)}, copy=False)
+        nx.is_isomorphic(K5, G)
+        G = nx.complete_graph(4)
+        G = nx.relabel_nodes(G, {i: i - 1 for i in range(4)}, copy=False)
+        nx.is_isomorphic(K5, G)
+
+    def test_relabel_selfloop(self):
+        G = nx.DiGraph([(1, 1), (1, 2), (2, 3)])
+        G = nx.relabel_nodes(G, {1: "One", 2: "Two", 3: "Three"}, copy=False)
+        assert nodes_equal(G.nodes(), ["One", "Three", "Two"])
+        G = nx.MultiDiGraph([(1, 1), (1, 2), (2, 3)])
+        G = nx.relabel_nodes(G, {1: "One", 2: "Two", 3: "Three"}, copy=False)
+        assert nodes_equal(G.nodes(), ["One", "Three", "Two"])
+        G = nx.MultiDiGraph([(1, 1)])
+        G = nx.relabel_nodes(G, {1: 0}, copy=False)
+        assert nodes_equal(G.nodes(), [0])
+
+    def test_relabel_multidigraph_inout_merge_nodes(self):
+        for MG in (nx.MultiGraph, nx.MultiDiGraph):
+            for cc in (True, False):
+                G = MG([(0, 4), (1, 4), (4, 2), (4, 3)])
+                G[0][4][0]["value"] = "a"
+                G[1][4][0]["value"] = "b"
+                G[4][2][0]["value"] = "c"
+                G[4][3][0]["value"] = "d"
+                G.add_edge(0, 4, key="x", value="e")
+                G.add_edge(4, 3, key="x", value="f")
+                mapping = {0: 9, 1: 9, 2: 9, 3: 9}
+                H = nx.relabel_nodes(G, mapping, copy=cc)
+                # No ordering on keys enforced
+                assert {"value": "a"} in H[9][4].values()
+                assert {"value": "b"} in H[9][4].values()
+                assert {"value": "c"} in H[4][9].values()
+                assert len(H[4][9]) == 3 if G.is_directed() else 6
+                assert {"value": "d"} in H[4][9].values()
+                assert {"value": "e"} in H[9][4].values()
+                assert {"value": "f"} in H[4][9].values()
+                assert len(H[9][4]) == 3 if G.is_directed() else 6
+
+    def test_relabel_multigraph_merge_inplace(self):
+        G = nx.MultiGraph([(0, 1), (0, 2), (0, 3), (0, 1), (0, 2), (0, 3)])
+        G[0][1][0]["value"] = "a"
+        G[0][2][0]["value"] = "b"
+        G[0][3][0]["value"] = "c"
+        mapping = {1: 4, 2: 4, 3: 4}
+        nx.relabel_nodes(G, mapping, copy=False)
+        # No ordering on keys enforced
+        assert {"value": "a"} in G[0][4].values()
+        assert {"value": "b"} in G[0][4].values()
+        assert {"value": "c"} in G[0][4].values()
+
+    def test_relabel_multidigraph_merge_inplace(self):
+        G = nx.MultiDiGraph([(0, 1), (0, 2), (0, 3)])
+        G[0][1][0]["value"] = "a"
+        G[0][2][0]["value"] = "b"
+        G[0][3][0]["value"] = "c"
+        mapping = {1: 4, 2: 4, 3: 4}
+        nx.relabel_nodes(G, mapping, copy=False)
+        # No ordering on keys enforced
+        assert {"value": "a"} in G[0][4].values()
+        assert {"value": "b"} in G[0][4].values()
+        assert {"value": "c"} in G[0][4].values()
+
+    def test_relabel_multidigraph_inout_copy(self):
+        G = nx.MultiDiGraph([(0, 4), (1, 4), (4, 2), (4, 3)])
+        G[0][4][0]["value"] = "a"
+        G[1][4][0]["value"] = "b"
+        G[4][2][0]["value"] = "c"
+        G[4][3][0]["value"] = "d"
+        G.add_edge(0, 4, key="x", value="e")
+        G.add_edge(4, 3, key="x", value="f")
+        mapping = {0: 9, 1: 9, 2: 9, 3: 9}
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        # No ordering on keys enforced
+        assert {"value": "a"} in H[9][4].values()
+        assert {"value": "b"} in H[9][4].values()
+        assert {"value": "c"} in H[4][9].values()
+        assert len(H[4][9]) == 3
+        assert {"value": "d"} in H[4][9].values()
+        assert {"value": "e"} in H[9][4].values()
+        assert {"value": "f"} in H[4][9].values()
+        assert len(H[9][4]) == 3
+
+    def test_relabel_multigraph_merge_copy(self):
+        G = nx.MultiGraph([(0, 1), (0, 2), (0, 3)])
+        G[0][1][0]["value"] = "a"
+        G[0][2][0]["value"] = "b"
+        G[0][3][0]["value"] = "c"
+        mapping = {1: 4, 2: 4, 3: 4}
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        assert {"value": "a"} in H[0][4].values()
+        assert {"value": "b"} in H[0][4].values()
+        assert {"value": "c"} in H[0][4].values()
+
+    def test_relabel_multidigraph_merge_copy(self):
+        G = nx.MultiDiGraph([(0, 1), (0, 2), (0, 3)])
+        G[0][1][0]["value"] = "a"
+        G[0][2][0]["value"] = "b"
+        G[0][3][0]["value"] = "c"
+        mapping = {1: 4, 2: 4, 3: 4}
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        assert {"value": "a"} in H[0][4].values()
+        assert {"value": "b"} in H[0][4].values()
+        assert {"value": "c"} in H[0][4].values()
+
+    def test_relabel_multigraph_nonnumeric_key(self):
+        for MG in (nx.MultiGraph, nx.MultiDiGraph):
+            for cc in (True, False):
+                G = nx.MultiGraph()
+                G.add_edge(0, 1, key="I", value="a")
+                G.add_edge(0, 2, key="II", value="b")
+                G.add_edge(0, 3, key="II", value="c")
+                mapping = {1: 4, 2: 4, 3: 4}
+                nx.relabel_nodes(G, mapping, copy=False)
+                assert {"value": "a"} in G[0][4].values()
+                assert {"value": "b"} in G[0][4].values()
+                assert {"value": "c"} in G[0][4].values()
+                assert 0 in G[0][4]
+                assert "I" in G[0][4]
+                assert "II" in G[0][4]
+
+    def test_relabel_circular(self):
+        G = nx.path_graph(3)
+        mapping = {0: 1, 1: 0}
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        with pytest.raises(nx.NetworkXUnfeasible):
+            H = nx.relabel_nodes(G, mapping, copy=False)
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/__init__.py b/myenv/lib/python3.9/site-packages/networkx/utils/__init__.py
new file mode 100644
index 0000000..9f168de
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/__init__.py
@@ -0,0 +1,7 @@
+from networkx.utils.misc import *
+from networkx.utils.decorators import *
+from networkx.utils.random_sequence import *
+from networkx.utils.union_find import *
+from networkx.utils.rcm import *
+from networkx.utils.heaps import *
+from networkx.utils.contextmanagers import *
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/contextmanagers.py b/myenv/lib/python3.9/site-packages/networkx/utils/contextmanagers.py
new file mode 100644
index 0000000..dcd6b9c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/contextmanagers.py
@@ -0,0 +1,47 @@
+import warnings
+from contextlib import contextmanager
+
+__all__ = ["reversed"]
+
+
+@contextmanager
+def reversed(G):
+    """A context manager for temporarily reversing a directed graph in place.
+
+    .. deprecated:: 2.6
+
+       This context manager is deprecated and will be removed in 3.0.
+       Use ``G.reverse(copy=False) if G.is_directed() else G`` instead.
+
+    This is a no-op for undirected graphs.
+
+    Parameters
+    ----------
+    G : graph
+        A NetworkX graph.
+
+    Warning
+    -------
+    The reversed context manager is deprecated in favor
+    of G.reverse(copy=False). The view allows multiple threads to use the
+    same graph without confusion while the context manager does not.
+    This context manager is scheduled to be removed in version 3.0.
+    """
+    msg = (
+        "context manager reversed is deprecated and to be removed in 3.0."
+        "Use G.reverse(copy=False) if G.is_directed() else G instead."
+    )
+    warnings.warn(msg, DeprecationWarning)
+
+    directed = G.is_directed()
+    if directed:
+        G._pred, G._succ = G._succ, G._pred
+        G._adj = G._succ
+
+    try:
+        yield
+    finally:
+        if directed:
+            # Reverse the reverse.
+            G._pred, G._succ = G._succ, G._pred
+            G._adj = G._succ
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/decorators.py b/myenv/lib/python3.9/site-packages/networkx/utils/decorators.py
new file mode 100644
index 0000000..d72af39
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/decorators.py
@@ -0,0 +1,1288 @@
+import bz2
+import collections
+import gzip
+import inspect
+import itertools
+import re
+from collections import defaultdict
+from contextlib import contextmanager
+from os.path import splitext
+from pathlib import Path
+
+import networkx as nx
+from networkx.utils import create_py_random_state, create_random_state
+
+__all__ = [
+    "not_implemented_for",
+    "open_file",
+    "nodes_or_number",
+    "preserve_random_state",
+    "random_state",
+    "np_random_state",
+    "py_random_state",
+    "argmap",
+]
+
+
+def not_implemented_for(*graph_types):
+    """Decorator to mark algorithms as not implemented
+
+    Parameters
+    ----------
+    graph_types : container of strings
+        Entries must be one of "directed", "undirected", "multigraph", or "graph".
+
+    Returns
+    -------
+    _require : function
+        The decorated function.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+    If any of the packages cannot be imported
+
+    Notes
+    -----
+    Multiple types are joined logically with "and".
+    For "or" use multiple @not_implemented_for() lines.
+
+    Examples
+    --------
+    Decorate functions like this::
+
+       @not_implemented_for("directed")
+       def sp_function(G):
+           pass
+
+       # rule out MultiDiGraph
+       @not_implemented_for("directed","multigraph")
+       def sp_np_function(G):
+           pass
+
+       # rule out all except DiGraph
+       @not_implemented_for("undirected")
+       @not_implemented_for("multigraph")
+       def sp_np_function(G):
+           pass
+    """
+    if ("directed" in graph_types) and ("undirected" in graph_types):
+        raise ValueError("Function not implemented on directed AND undirected graphs?")
+    if ("multigraph" in graph_types) and ("graph" in graph_types):
+        raise ValueError("Function not implemented on graph AND multigraphs?")
+    if not set(graph_types) < {"directed", "undirected", "multigraph", "graph"}:
+        raise KeyError(
+            "use one or more of directed, undirected, multigraph, graph.  "
+            f"You used {graph_types}"
+        )
+
+    # 3-way logic: True if "directed" input, False if "undirected" input, else None
+    dval = ("directed" in graph_types) or not ("undirected" in graph_types) and None
+    mval = ("multigraph" in graph_types) or not ("graph" in graph_types) and None
+    errmsg = f"not implemented for {' '.join(graph_types)} type"
+
+    def _not_implemented_for(g):
+        if (mval is None or mval == g.is_multigraph()) and (
+            dval is None or dval == g.is_directed()
+        ):
+            raise nx.NetworkXNotImplemented(errmsg)
+
+        return g
+
+    return argmap(_not_implemented_for, 0)
+
+
+# To handle new extensions, define a function accepting a `path` and `mode`.
+# Then add the extension to _dispatch_dict.
+fopeners = {
+    ".gz": gzip.open,
+    ".gzip": gzip.open,
+    ".bz2": bz2.BZ2File,
+}
+_dispatch_dict = defaultdict(lambda: open, **fopeners)  # type: ignore
+
+
+def open_file(path_arg, mode="r"):
+    """Decorator to ensure clean opening and closing of files.
+
+    Parameters
+    ----------
+    path_arg : string or int
+        Name or index of the argument that is a path.
+
+    mode : str
+        String for opening mode.
+
+    Returns
+    -------
+    _open_file : function
+        Function which cleanly executes the io.
+
+    Examples
+    --------
+    Decorate functions like this::
+
+       @open_file(0,"r")
+       def read_function(pathname):
+           pass
+
+       @open_file(1,"w")
+       def write_function(G, pathname):
+           pass
+
+       @open_file(1,"w")
+       def write_function(G, pathname="graph.dot"):
+           pass
+
+       @open_file("pathname","w")
+       def write_function(G, pathname="graph.dot"):
+           pass
+
+       @open_file("path", "w+")
+       def another_function(arg, **kwargs):
+           path = kwargs["path"]
+           pass
+
+    Notes
+    -----
+    Note that this decorator solves the problem when a path argument is
+    specified as a string, but it does not handle the situation when the
+    function wants to accept a default of None (and then handle it).
+
+    Here is an example of how to handle this case::
+
+      @open_file("path")
+      def some_function(arg1, arg2, path=None):
+         if path is None:
+             fobj = tempfile.NamedTemporaryFile(delete=False)
+         else:
+             # `path` could have been a string or file object or something
+             # similar. In any event, the decorator has given us a file object
+             # and it will close it for us, if it should.
+             fobj = path
+
+         try:
+             fobj.write("blah")
+         finally:
+             if path is None:
+                 fobj.close()
+
+    Normally, we'd want to use "with" to ensure that fobj gets closed.
+    However, the decorator will make `path` a file object for us,
+    and using "with" would undesirably close that file object.
+    Instead, we use a try block, as shown above.
+    When we exit the function, fobj will be closed, if it should be, by the decorator.
+    """
+
+    def _open_file(path):
+        # Now we have the path_arg. There are two types of input to consider:
+        #   1) string representing a path that should be opened
+        #   2) an already opened file object
+        if isinstance(path, str):
+            ext = splitext(path)[1]
+        elif isinstance(path, Path):
+            # path is a pathlib reference to a filename
+            ext = path.suffix
+            path = str(path)
+        else:
+            # could be None, or a file handle, in which case the algorithm will deal with it
+            return path, lambda: None
+
+        fobj = _dispatch_dict[ext](path, mode=mode)
+        return fobj, lambda: fobj.close()
+
+    return argmap(_open_file, path_arg, try_finally=True)
+
+
+def nodes_or_number(which_args):
+    """Decorator to allow number of nodes or container of nodes.
+
+    With this decorator, the specified argument can be either a number or a container
+    of nodes. If it is a number, the nodes used are `range(n)`.
+    This allows `nx.complete_graph(50)` in place of `nx.complete_graph(list(range(50)))`.
+    And it also allows `nx.complete_graph(any_list_of_nodes)`.
+
+    Parameters
+    ----------
+    which_args : string or int or sequence of strings or ints
+        If string, the name of the argument to be treated.
+        If int, the index of the argument to be treated.
+        If more than one node argument is allowed, can be a list of locations.
+
+    Returns
+    -------
+    _nodes_or_numbers : function
+        Function which replaces int args with ranges.
+
+    Examples
+    --------
+    Decorate functions like this::
+
+       @nodes_or_number("nodes")
+       def empty_graph(nodes):
+           # nodes is converted to a list of nodes
+
+       @nodes_or_number(0)
+       def empty_graph(nodes):
+           # nodes is converted to a list of nodes
+
+       @nodes_or_number(["m1", "m2"])
+       def grid_2d_graph(m1, m2, periodic=False):
+           # m1 and m2 are each converted to a list of nodes
+
+       @nodes_or_number([0, 1])
+       def grid_2d_graph(m1, m2, periodic=False):
+           # m1 and m2 are each converted to a list of nodes
+
+       @nodes_or_number(1)
+       def full_rary_tree(r, n)
+           # presumably r is a number. It is not handled by this decorator.
+           # n is converted to a list of nodes
+    """
+
+    def _nodes_or_number(n):
+        try:
+            nodes = list(range(n))
+        except TypeError:
+            nodes = tuple(n)
+        else:
+            if n < 0:
+                raise nx.NetworkXError(f"Negative number of nodes not valid: {n}")
+        return (n, nodes)
+
+    try:
+        iter_wa = iter(which_args)
+    except TypeError:
+        iter_wa = (which_args,)
+
+    return argmap(_nodes_or_number, *iter_wa)
+
+
+def preserve_random_state(func):
+    """Decorator to preserve the numpy.random state during a function.
+
+    .. deprecated:: 2.6
+        This is deprecated and will be removed in NetworkX v3.0.
+
+    Parameters
+    ----------
+    func : function
+        function around which to preserve the random state.
+
+    Returns
+    -------
+    wrapper : function
+        Function which wraps the input function by saving the state before
+        calling the function and restoring the function afterward.
+
+    Examples
+    --------
+    Decorate functions like this::
+
+        @preserve_random_state
+        def do_random_stuff(x, y):
+            return x + y * numpy.random.random()
+
+    Notes
+    -----
+    If numpy.random is not importable, the state is not saved or restored.
+    """
+    import warnings
+
+    msg = "preserve_random_state is deprecated and will be removed in 3.0."
+    warnings.warn(msg, DeprecationWarning)
+
+    try:
+        import numpy as np
+
+        @contextmanager
+        def save_random_state():
+            state = np.random.get_state()
+            try:
+                yield
+            finally:
+                np.random.set_state(state)
+
+        def wrapper(*args, **kwargs):
+            with save_random_state():
+                np.random.seed(1234567890)
+                return func(*args, **kwargs)
+
+        wrapper.__name__ = func.__name__
+        return wrapper
+    except ImportError:
+        return func
+
+
+def np_random_state(random_state_argument):
+    """Decorator to generate a `numpy.random.RandomState` instance.
+
+    The decorator processes the argument indicated by `random_state_argument`
+    using :func:`nx.utils.create_random_state`.
+    The argument value can be a seed (integer), or a `numpy.random.RandomState`
+    instance or (`None` or `numpy.random`). The latter options use the glocal
+    random number generator used by `numpy.random`.
+    The result is a `numpy.random.RandomState` instance.
+
+    Parameters
+    ----------
+    random_state_argument : string or int
+        The name or index of the argument to be converted
+        to a `numpy.random.RandomState` instance.
+
+    Returns
+    -------
+    _random_state : function
+        Function whose random_state keyword argument is a RandomState instance.
+
+    Examples
+    --------
+    Decorate functions like this::
+
+       @np_random_state("seed")
+       def random_float(seed=None):
+           return seed.rand()
+
+       @np_random_state(0)
+       def random_float(rng=None):
+           return rng.rand()
+
+       @np_random_state(1)
+       def random_array(dims, random_state=1):
+           return random_state.rand(*dims)
+
+    See Also
+    --------
+    py_random_state
+    """
+    return argmap(create_random_state, random_state_argument)
+
+
+def random_state(random_state_argument):
+    """Decorator to generate a `numpy.random.RandomState` instance.
+
+    .. deprecated:: 2.7
+
+       This function is a deprecated alias for `np_random_state` and will be
+       removed in version 3.0. Use np_random_state instead.
+    """
+    import warnings
+
+    warnings.warn(
+        (
+            "`random_state` is a deprecated alias for `np_random_state`\n"
+            "and will be removed in version 3.0. Use `np_random_state` instead."
+        ),
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return np_random_state(random_state_argument)
+
+
+def py_random_state(random_state_argument):
+    """Decorator to generate a random.Random instance (or equiv).
+
+    The decorator processes the argument indicated by `random_state_argument`
+    using :func:`nx.utils.create_py_random_state`.
+    The argument value can be a seed (integer), or a random number generator::
+
+        If int, return a random.Random instance set with seed=int.
+        If random.Random instance, return it.
+        If None or the `random` package, return the global random number
+        generator used by `random`.
+        If np.random package, return the global numpy random number
+        generator wrapped in a PythonRandomInterface class.
+        If np.random.RandomState instance, return it wrapped in
+        PythonRandomInterface
+        If a PythonRandomInterface instance, return it
+
+    Parameters
+    ----------
+    random_state_argument : string or int
+        The name of the argument or the index of the argument in args that is
+        to be converted to the random.Random instance or numpy.random.RandomState
+        instance that mimics basic methods of random.Random.
+
+    Returns
+    -------
+    _random_state : function
+        Function whose random_state_argument is converted to a Random instance.
+
+    Examples
+    --------
+    Decorate functions like this::
+
+       @py_random_state("random_state")
+       def random_float(random_state=None):
+           return random_state.rand()
+
+       @py_random_state(0)
+       def random_float(rng=None):
+           return rng.rand()
+
+       @py_random_state(1)
+       def random_array(dims, seed=12345):
+           return seed.rand(*dims)
+
+    See Also
+    --------
+    np_random_state
+    """
+
+    return argmap(create_py_random_state, random_state_argument)
+
+
+class argmap:
+    """A decorator to apply a map to arguments before calling the function
+
+    This class provides a decorator that maps (transforms) arguments of the function
+    before the function is called. Thus for example, we have similar code
+    in many functions to determine whether an argument is the number of nodes
+    to be created, or a list of nodes to be handled. The decorator provides
+    the code to accept either -- transforming the indicated argument into a
+    list of nodes before the actual function is called.
+
+    This decorator class allows us to process single or multiple arguments.
+    The arguments to be processed can be specified by string, naming the argument,
+    or by index, specifying the item in the args list.
+
+    Parameters
+    ----------
+    func : callable
+        The function to apply to arguments
+
+    *args : iterable of (int, str or tuple)
+        A list of parameters, specified either as strings (their names), ints
+        (numerical indices) or tuples, which may contain ints, strings, and
+        (recursively) tuples. Each indicates which parameters the decorator
+        should map. Tuples indicate that the map function takes (and returns)
+        multiple parameters in the same order and nested structure as indicated
+        here.
+
+    try_finally : bool (default: False)
+        When True, wrap the function call in a try-finally block with code
+        for the finally block created by `func`. This is used when the map
+        function constructs an object (like a file handle) that requires
+        post-processing (like closing).
+
+        Note: try_finally decorators cannot be used to decorate generator
+        functions.
+
+    Examples
+    --------
+    Most of these examples use `@argmap(...)` to apply the decorator to
+    the function defined on the next line.
+    In the NetworkX codebase however, `argmap` is used within a function to
+    construct a decorator. That is, the decorator defines a mapping function
+    and then uses `argmap` to build and return a decorated function.
+    A simple example is a decorator that specifies which currency to report money.
+    The decorator (named `convert_to`) would be used like::
+
+        @convert_to("US_Dollars", "income")
+        def show_me_the_money(name, income):
+            print(f"{name} : {income}")
+
+    And the code to create the decorator might be::
+
+        def convert_to(currency, which_arg):
+            def _convert(amount):
+                if amount.currency != currency:
+                    amount = amount.to_currency(currency)
+                return amount
+            return argmap(_convert, which_arg)
+
+    Despite this common idiom for argmap, most of the following examples
+    use the `@argmap(...)` idiom to save space.
+
+    Here's an example use of argmap to sum the elements of two of the functions
+    arguments. The decorated function::
+
+        @argmap(sum, "xlist", "zlist")
+        def foo(xlist, y, zlist):
+            return xlist - y + zlist
+
+    is syntactic sugar for::
+
+        def foo(xlist, y, zlist):
+            x = sum(xlist)
+            z = sum(zlist)
+            return x - y + z
+
+    and is equivalent to (using argument indexes)::
+
+        @argmap(sum, "xlist", 2)
+        def foo(xlist, y, zlist):
+            return xlist - y + zlist
+
+    or::
+
+        @argmap(sum, "zlist", 0)
+        def foo(xlist, y, zlist):
+            return xlist - y + zlist
+
+    Transforming functions can be applied to multiple arguments, such as::
+
+        def swap(x, y):
+            return y, x
+
+        # the 2-tuple tells argmap that the map `swap` has 2 inputs/outputs.
+        @argmap(swap, ("a", "b")):
+        def foo(a, b, c):
+            return a / b * c
+
+    is equivalent to::
+
+        def foo(a, b, c):
+            a, b = swap(a, b)
+            return a / b * c
+
+    More generally, the applied arguments can be nested tuples of strings or ints.
+    The syntax `@argmap(some_func, ("a", ("b", "c")))` would expect `some_func` to
+    accept 2 inputs with the second expected to be a 2-tuple. It should then return
+    2 outputs with the second a 2-tuple. The returns values would replace input "a"
+    "b" and "c" respectively. Similarly for `@argmap(some_func, (0, ("b", 2)))`.
+
+    Also, note that an index larger than the number of named parameters is allowed
+    for variadic functions. For example::
+
+        def double(a):
+            return 2 * a
+
+        @argmap(double, 3)
+        def overflow(a, *args):
+            return a, args
+
+        print(overflow(1, 2, 3, 4, 5, 6))  # output is 1, (2, 3, 8, 5, 6)
+
+    **Try Finally**
+
+    Additionally, this `argmap` class can be used to create a decorator that
+    initiates a try...finally block. The decorator must be written to return
+    both the transformed argument and a closing function.
+    This feature was included to enable the `open_file` decorator which might
+    need to close the file or not depending on whether it had to open that file.
+    This feature uses the keyword-only `try_finally` argument to `@argmap`.
+
+    For example this map opens a file and then makes sure it is closed::
+
+        def open_file(fn):
+            f = open(fn)
+            return f, lambda: f.close()
+
+    The decorator applies that to the function `foo`::
+
+        @argmap(open_file, "file", try_finally=True)
+        def foo(file):
+            print(file.read())
+
+    is syntactic sugar for::
+
+        def foo(file):
+            file, close_file = open_file(file)
+            try:
+                print(file.read())
+            finally:
+                close_file()
+
+    and is equivalent to (using indexes)::
+
+        @argmap(open_file, 0, try_finally=True)
+        def foo(file):
+            print(file.read())
+
+    Here's an example of the try_finally feature used to create a decorator::
+
+        def my_closing_decorator(which_arg):
+            def _opener(path):
+                if path is None:
+                    path = open(path)
+                    fclose = path.close
+                else:
+                    # assume `path` handles the closing
+                    fclose = lambda: None
+                return path, fclose
+            return argmap(_opener, which_arg, try_finally=True)
+
+    which can then be used as::
+
+        @my_closing_decorator("file")
+        def fancy_reader(file=None):
+            # this code doesn't need to worry about closing the file
+            print(file.read())
+
+    Decorators with try_finally = True cannot be used with generator functions,
+    because the `finally` block is evaluated before the generator is exhausted::
+
+        @argmap(open_file, "file", try_finally=True)
+        def file_to_lines(file):
+            for line in file.readlines():
+                yield line
+
+    is equivalent to::
+
+        def file_to_lines_wrapped(file):
+            for line in file.readlines():
+                yield line
+
+        def file_to_lines_wrapper(file):
+            try:
+                file = open_file(file)
+                return file_to_lines_wrapped(file)
+            finally:
+                file.close()
+
+    which behaves similarly to::
+
+        def file_to_lines_whoops(file):
+            file = open_file(file)
+            file.close()
+            for line in file.readlines():
+                yield line
+
+    because the `finally` block of `file_to_lines_wrapper` is executed before
+    the caller has a chance to exhaust the iterator.
+
+    Notes
+    -----
+    An object of this class is callable and intended to be used when
+    defining a decorator. Generally, a decorator takes a function as input
+    and constructs a function as output. Specifically, an `argmap` object
+    returns the input function decorated/wrapped so that specified arguments
+    are mapped (transformed) to new values before the decorated function is called.
+
+    As an overview, the argmap object returns a new function with all the
+    dunder values of the original function (like `__doc__`, `__name__`, etc).
+    Code for this decorated function is built based on the original function's
+    signature. It starts by mapping the input arguments to potentially new
+    values. Then it calls the decorated function with these new values in place
+    of the indicated arguments that have been mapped. The return value of the
+    original function is then returned. This new function is the function that
+    is actually called by the user.
+
+    Three additional features are provided.
+        1) The code is lazily compiled. That is, the new function is returned
+        as an object without the code compiled, but with all information
+        needed so it can be compiled upon it's first invocation. This saves
+        time on import at the cost of additional time on the first call of
+        the function. Subsequent calls are then just as fast as normal.
+
+        2) If the "try_finally" keyword-only argument is True, a try block
+        follows each mapped argument, matched on the other side of the wrapped
+        call, by a finally block closing that mapping.  We expect func to return
+        a 2-tuple: the mapped value and a function to be called in the finally
+        clause.  This feature was included so the `open_file` decorator could
+        provide a file handle to the decorated function and close the file handle
+        after the function call. It even keeps track of whether to close the file
+        handle or not based on whether it had to open the file or the input was
+        already open. So, the decorated function does not need to include any
+        code to open or close files.
+
+        3) The maps applied can process multiple arguments. For example,
+        you could swap two arguments using a mapping, or transform
+        them to their sum and their difference. This was included to allow
+        a decorator in the `quality.py` module that checks that an input
+        `partition` is a valid partition of the nodes of the input graph `G`.
+        In this example, the map has inputs `(G, partition)`. After checking
+        for a valid partition, the map either raises an exception or leaves
+        the inputs unchanged. Thus many functions that make this check can
+        use the decorator rather than copy the checking code into each function.
+        More complicated nested argument structures are described below.
+
+    The remaining notes describe the code structure and methods for this
+    class in broad terms to aid in understanding how to use it.
+
+    Instantiating an `argmap` object simply stores the mapping function and
+    the input identifiers of which arguments to map. The resulting decorator
+    is ready to use this map to decorate any function. Calling that object
+    (`argmap.__call__`, but usually done via `@my_decorator`) a lazily
+    compiled thin wrapper of the decorated function is constructed,
+    wrapped with the necessary function dunder attributes like `__doc__`
+    and `__name__`. That thinly wrapped function is returned as the
+    decorated function. When that decorated function is called, the thin
+    wrapper of code calls `argmap._lazy_compile` which compiles the decorated
+    function (using `argmap.compile`) and replaces the code of the thin
+    wrapper with the newly compiled code. This saves the compilation step
+    every import of networkx, at the cost of compiling upon the first call
+    to the decorated function.
+
+    When the decorated function is compiled, the code is recursively assembled
+    using the `argmap.assemble` method. The recursive nature is needed in
+    case of nested decorators. The result of the assembly is a number of
+    useful objects.
+
+      sig : the function signature of the original decorated function as
+          constructed by :func:`argmap.signature`. This is constructed
+          using `inspect.signature` but enhanced with attribute
+          strings `sig_def` and `sig_call`, and other information
+          specific to mapping arguments of this function.
+          This information is used to construct a string of code defining
+          the new decorated function.
+
+      wrapped_name : a unique internally used name constructed by argmap
+          for the decorated function.
+
+      functions : a dict of the functions used inside the code of this
+          decorated function, to be used as `globals` in `exec`.
+          This dict is recursively updated to allow for nested decorating.
+
+      mapblock : code (as a list of strings) to map the incoming argument
+          values to their mapped values.
+
+      finallys : code (as a list of strings) to provide the possibly nested
+          set of finally clauses if needed.
+
+      mutable_args : a bool indicating whether the `sig.args` tuple should be
+          converted to a list so mutation can occur.
+
+    After this recursive assembly process, the `argmap.compile` method
+    constructs code (as strings) to convert the tuple `sig.args` to a list
+    if needed. It joins the defining code with appropriate indents and
+    compiles the result.  Finally, this code is evaluated and the original
+    wrapper's implementation is replaced with the compiled version (see
+    `argmap._lazy_compile` for more details).
+
+    Other `argmap` methods include `_name` and `_count` which allow internally
+    generated names to be unique within a python session.
+    The methods `_flatten` and `_indent` process the nested lists of strings
+    into properly indented python code ready to be compiled.
+
+    More complicated nested tuples of arguments also allowed though
+    usually not used. For the simple 2 argument case, the argmap
+    input ("a", "b") implies the mapping function will take 2 arguments
+    and return a 2-tuple of mapped values. A more complicated example
+    with argmap input `("a", ("b", "c"))` requires the mapping function
+    take 2 inputs, with the second being a 2-tuple. It then must output
+    the 3 mapped values in the same nested structure `(newa, (newb, newc))`.
+    This level of generality is not often needed, but was convenient
+    to implement when handling the multiple arguments.
+
+    See Also
+    --------
+    not_implemented_for
+    open_file
+    nodes_or_number
+    random_state
+    py_random_state
+    networkx.community.quality.require_partition
+    require_partition
+
+    """
+
+    def __init__(self, func, *args, try_finally=False):
+        self._func = func
+        self._args = args
+        self._finally = try_finally
+
+    @staticmethod
+    def _lazy_compile(func):
+        """Compile the source of a wrapped function
+
+        Assemble and compile the decorated function, and intrusively replace its
+        code with the compiled version's.  The thinly wrapped function becomes
+        the decorated function.
+
+        Parameters
+        ----------
+        func : callable
+            A function returned by argmap.__call__ which is in the process
+            of being called for the first time.
+
+        Returns
+        -------
+        func : callable
+            The same function, with a new __code__ object.
+
+        Notes
+        -----
+        It was observed in NetworkX issue #4732 [1] that the import time of
+        NetworkX was significantly bloated by the use of decorators: over half
+        of the import time was being spent decorating functions.  This was
+        somewhat improved by a change made to the `decorator` library, at the
+        cost of a relatively heavy-weight call to `inspect.Signature.bind`
+        for each call to the decorated function.
+
+        The workaround we arrived at is to do minimal work at the time of
+        decoration.  When the decorated function is called for the first time,
+        we compile a function with the same function signature as the wrapped
+        function.  The resulting decorated function is faster than one made by
+        the `decorator` library, so that the overhead of the first call is
+        'paid off' after a small number of calls.
+
+        References
+        ----------
+
+        [1] https://github.com/networkx/networkx/issues/4732
+
+        """
+        real_func = func.__argmap__.compile(func.__wrapped__)
+        func.__code__ = real_func.__code__
+        func.__globals__.update(real_func.__globals__)
+        func.__dict__.update(real_func.__dict__)
+        return func
+
+    def __call__(self, f):
+        """Construct a lazily decorated wrapper of f.
+
+        The decorated function will be compiled when it is called for the first time,
+        and it will replace its own __code__ object so subsequent calls are fast.
+
+        Parameters
+        ----------
+        f : callable
+            A function to be decorated.
+
+        Returns
+        -------
+        func : callable
+            The decorated function.
+
+        See Also
+        --------
+        argmap._lazy_compile
+        """
+
+        def func(*args, __wrapper=None, **kwargs):
+            return argmap._lazy_compile(__wrapper)(*args, **kwargs)
+
+        # standard function-wrapping stuff
+        func.__name__ = f.__name__
+        func.__doc__ = f.__doc__
+        func.__defaults__ = f.__defaults__
+        func.__kwdefaults__.update(f.__kwdefaults__ or {})
+        func.__module__ = f.__module__
+        func.__qualname__ = f.__qualname__
+        func.__dict__.update(f.__dict__)
+        func.__wrapped__ = f
+
+        # now that we've wrapped f, we may have picked up some __dict__ or
+        # __kwdefaults__ items that were set by a previous argmap.  Thus, we set
+        # these values after those update() calls.
+
+        # If we attempt to access func from within itself, that happens through
+        # a closure -- which trips an error when we replace func.__code__.  The
+        # standard workaround for functions which can't see themselves is to use
+        # a Y-combinator, as we do here.
+        func.__kwdefaults__["_argmap__wrapper"] = func
+
+        # this self-reference is here because functools.wraps preserves
+        # everything in __dict__, and we don't want to mistake a non-argmap
+        # wrapper for an argmap wrapper
+        func.__self__ = func
+
+        # this is used to variously call self.assemble and self.compile
+        func.__argmap__ = self
+
+        if hasattr(f, "__argmap__"):
+            func.__is_generator = f.__is_generator
+        else:
+            func.__is_generator = inspect.isgeneratorfunction(f)
+
+        if self._finally and func.__is_generator:
+            raise nx.NetworkXError("argmap cannot decorate generators with try_finally")
+
+        return func
+
+    __count = 0
+
+    @classmethod
+    def _count(cls):
+        """Maintain a globally-unique identifier for function names and "file" names
+
+        Note that this counter is a class method reporting a class variable
+        so the count is unique within a Python session. It could differ from
+        session to session for a specific decorator depending on the order
+        that the decorators are created. But that doesn't disrupt `argmap`.
+
+        This is used in two places: to construct unique variable names
+        in the `_name` method and to construct unique fictitious filenames
+        in the `_compile` method.
+
+        Returns
+        -------
+        count : int
+            An integer unique to this Python session (simply counts from zero)
+        """
+        cls.__count += 1
+        return cls.__count
+
+    _bad_chars = re.compile("[^a-zA-Z0-9_]")
+
+    @classmethod
+    def _name(cls, f):
+        """Mangle the name of a function to be unique but somewhat human-readable
+
+        The names are unique within a Python session and set using `_count`.
+
+        Parameters
+        ----------
+        f : str or object
+
+        Returns
+        -------
+        name : str
+            The mangled version of `f.__name__` (if `f.__name__` exists) or `f`
+
+        """
+        f = f.__name__ if hasattr(f, "__name__") else f
+        fname = re.sub(cls._bad_chars, "_", f)
+        return f"argmap_{fname}_{cls._count()}"
+
+    def compile(self, f):
+        """Compile the decorated function.
+
+        Called once for a given decorated function -- collects the code from all
+        argmap decorators in the stack, and compiles the decorated function.
+
+        Much of the work done here uses the `assemble` method to allow recursive
+        treatment of multiple argmap decorators on a single decorated function.
+        That flattens the argmap decorators, collects the source code to construct
+        a single decorated function, then compiles/executes/returns that function.
+
+        The source code for the decorated function is stored as an attribute
+        `_code` on the function object itself.
+
+        Note that Python's `compile` function requires a filename, but this
+        code is constructed without a file, so a fictitious filename is used
+        to describe where the function comes from. The name is something like:
+        "argmap compilation 4".
+
+        Parameters
+        ----------
+        f : callable
+            The function to be decorated
+
+        Returns
+        -------
+        func : callable
+            The decorated file
+
+        """
+        sig, wrapped_name, functions, mapblock, finallys, mutable_args = self.assemble(
+            f
+        )
+
+        call = f"{sig.call_sig.format(wrapped_name)}#"
+        mut_args = f"{sig.args} = list({sig.args})" if mutable_args else ""
+        body = argmap._indent(sig.def_sig, mut_args, mapblock, call, finallys)
+        code = "\n".join(body)
+
+        locl = {}
+        globl = dict(functions.values())
+        filename = f"{self.__class__} compilation {self._count()}"
+        compiled = compile(code, filename, "exec")
+        exec(compiled, globl, locl)
+        func = locl[sig.name]
+        func._code = code
+        return func
+
+    def assemble(self, f):
+        """Collects components of the source for the decorated function wrapping f.
+
+        If `f` has multiple argmap decorators, we recursively assemble the stack of
+        decorators into a single flattened function.
+
+        This method is part of the `compile` method's process yet separated
+        from that method to allow recursive processing. The outputs are
+        strings, dictionaries and lists that collect needed info to
+        flatten any nested argmap-decoration.
+
+        Parameters
+        ----------
+        f : callable
+            The function to be decorated.  If f is argmapped, we assemble it.
+
+        Returns
+        -------
+        sig : argmap.Signature
+            The function signature as an `argmap.Signature` object.
+        wrapped_name : str
+            The mangled name used to represent the wrapped function in the code
+            being assembled.
+        functions : dict
+            A dictionary mapping id(g) -> (mangled_name(g), g) for functions g
+            referred to in the code being assembled. These need to be present
+            in the ``globals`` scope of ``exec`` when defining the decorated
+            function.
+        mapblock : list of lists and/or strings
+            Code that implements mapping of parameters including any try blocks
+            if needed. This code will precede the decorated function call.
+        finallys : list of lists and/or strings
+            Code that implements the finally blocks to post-process the
+            arguments (usually close any files if needed) after the
+            decorated function is called.
+        mutable_args : bool
+            True if the decorator needs to modify positional arguments
+            via their indices. The compile method then turns the argument
+            tuple into a list so that the arguments can be modified.
+        """
+
+        # first, we check if f is already argmapped -- if that's the case,
+        # build up the function recursively.
+        # > mapblock is generally a list of function calls of the sort
+        #     arg = func(arg)
+        # in addition to some try-blocks if needed.
+        # > finallys is a recursive list of finally blocks of the sort
+        #         finally:
+        #             close_func_1()
+        #     finally:
+        #         close_func_2()
+        # > functions is a dict of functions used in the scope of our decorated
+        # function. It will be used to construct globals used in compilation.
+        # We make functions[id(f)] = name_of_f, f to ensure that a given
+        # function is stored and named exactly once even if called by
+        # nested decorators.
+        if hasattr(f, "__argmap__") and f.__self__ is f:
+            (
+                sig,
+                wrapped_name,
+                functions,
+                mapblock,
+                finallys,
+                mutable_args,
+            ) = f.__argmap__.assemble(f.__wrapped__)
+            functions = dict(functions)  # shallow-copy just in case
+        else:
+            sig = self.signature(f)
+            wrapped_name = self._name(f)
+            mapblock, finallys = [], []
+            functions = {id(f): (wrapped_name, f)}
+            mutable_args = False
+
+        if id(self._func) in functions:
+            fname, _ = functions[id(self._func)]
+        else:
+            fname, _ = functions[id(self._func)] = self._name(self._func), self._func
+
+        # this is a bit complicated -- we can call functions with a variety of
+        # nested arguments, so long as their input and output are tuples with
+        # the same nested structure. e.g. ("a", "b") maps arguments a and b.
+        # A more complicated nesting like (0, (3, 4)) maps arguments 0, 3, 4
+        # expecting the mapping to output new values in the same nested shape.
+        # The ability to argmap multiple arguments was necessary for
+        # the decorator `nx.algorithms.community.quality.require_partition`, and
+        # while we're not taking full advantage of the ability to handle
+        # multiply-nested tuples, it was convenient to implement this in
+        # generality because the recursive call to `get_name` is necessary in
+        # any case.
+        applied = set()
+
+        def get_name(arg, first=True):
+            nonlocal mutable_args
+            if isinstance(arg, tuple):
+                name = ", ".join(get_name(x, False) for x in arg)
+                return name if first else f"({name})"
+            if arg in applied:
+                raise nx.NetworkXError(f"argument {arg} is specified multiple times")
+            applied.add(arg)
+            if arg in sig.names:
+                return sig.names[arg]
+            elif isinstance(arg, str):
+                if sig.kwargs is None:
+                    raise nx.NetworkXError(
+                        f"name {arg} is not a named parameter and this function doesn't have kwargs"
+                    )
+                return f"{sig.kwargs}[{arg!r}]"
+            else:
+                if sig.args is None:
+                    raise nx.NetworkXError(
+                        f"index {arg} not a parameter index and this function doesn't have args"
+                    )
+                mutable_args = True
+                return f"{sig.args}[{arg - sig.n_positional}]"
+
+        if self._finally:
+            # here's where we handle try_finally decorators.  Such a decorator
+            # returns a mapped argument and a function to be called in a
+            # finally block.  This feature was required by the open_file
+            # decorator.  The below generates the code
+            #
+            # name, final = func(name)                   #<--append to mapblock
+            # try:                                       #<--append to mapblock
+            #     ... more argmapping and try blocks
+            #     return WRAPPED_FUNCTION(...)
+            #     ... more finally blocks
+            # finally:                                   #<--prepend to finallys
+            #     final()                                #<--prepend to finallys
+            #
+            for a in self._args:
+                name = get_name(a)
+                final = self._name(name)
+                mapblock.append(f"{name}, {final} = {fname}({name})")
+                mapblock.append("try:")
+                finallys = ["finally:", f"{final}()#", "#", finallys]
+        else:
+            mapblock.extend(
+                f"{name} = {fname}({name})" for name in map(get_name, self._args)
+            )
+
+        return sig, wrapped_name, functions, mapblock, finallys, mutable_args
+
+    @classmethod
+    def signature(cls, f):
+        r"""Construct a Signature object describing `f`
+
+        Compute a Signature so that we can write a function wrapping f with
+        the same signature and call-type.
+
+        Parameters
+        ----------
+        f : callable
+            A function to be decorated
+
+        Returns
+        -------
+        sig : argmap.Signature
+            The Signature of f
+
+        Notes
+        -----
+        The Signature is a namedtuple with names:
+
+            name : a unique version of the name of the decorated function
+            signature : the inspect.signature of the decorated function
+            def_sig : a string used as code to define the new function
+            call_sig : a string used as code to call the decorated function
+            names : a dict keyed by argument name and index to the argument's name
+            n_positional : the number of positional arguments in the signature
+            args : the name of the VAR_POSITIONAL argument if any, i.e. \*theseargs
+            kwargs : the name of the VAR_KEYWORDS argument if any, i.e. \*\*kwargs
+
+        These named attributes of the signature are used in `assemble` and `compile`
+        to construct a string of source code for the decorated function.
+
+        """
+        sig = inspect.signature(f, follow_wrapped=False)
+        def_sig = []
+        call_sig = []
+        names = {}
+
+        kind = None
+        args = None
+        kwargs = None
+        npos = 0
+        for i, param in enumerate(sig.parameters.values()):
+            # parameters can be position-only, keyword-or-position, keyword-only
+            # in any combination, but only in the order as above.  we do edge
+            # detection to add the appropriate punctuation
+            prev = kind
+            kind = param.kind
+            if prev == param.POSITIONAL_ONLY != kind:
+                # the last token was position-only, but this one isn't
+                def_sig.append("/")
+            if prev != param.KEYWORD_ONLY == kind != param.VAR_POSITIONAL:
+                # param is the first keyword-only arg and isn't starred
+                def_sig.append("*")
+
+            # star arguments as appropriate
+            if kind == param.VAR_POSITIONAL:
+                name = "*" + param.name
+                args = param.name
+                count = 0
+            elif kind == param.VAR_KEYWORD:
+                name = "**" + param.name
+                kwargs = param.name
+                count = 0
+            else:
+                names[i] = names[param.name] = param.name
+                name = param.name
+                count = 1
+
+            # assign to keyword-only args in the function call
+            if kind == param.KEYWORD_ONLY:
+                call_sig.append(f"{name} = {name}")
+            else:
+                npos += count
+                call_sig.append(name)
+
+            def_sig.append(name)
+
+        fname = cls._name(f)
+        def_sig = f'def {fname}({", ".join(def_sig)}):'
+
+        call_sig = f"return {{}}({', '.join(call_sig)})"
+
+        return cls.Signature(fname, sig, def_sig, call_sig, names, npos, args, kwargs)
+
+    Signature = collections.namedtuple(
+        "Signature",
+        [
+            "name",
+            "signature",
+            "def_sig",
+            "call_sig",
+            "names",
+            "n_positional",
+            "args",
+            "kwargs",
+        ],
+    )
+
+    @staticmethod
+    def _flatten(nestlist, visited):
+        """flattens a recursive list of lists that doesn't have cyclic references
+
+        Parameters
+        ----------
+        nestlist : iterable
+            A recursive list of objects to be flattened into a single iterable
+
+        visited : set
+            A set of object ids which have been walked -- initialize with an
+            empty set
+
+        Yields
+        ------
+        Non-list objects contained in nestlist
+
+        """
+        for thing in nestlist:
+            if isinstance(thing, list):
+                if id(thing) in visited:
+                    raise ValueError("A cycle was found in nestlist.  Be a tree.")
+                else:
+                    visited.add(id(thing))
+                yield from argmap._flatten(thing, visited)
+            else:
+                yield thing
+
+    _tabs = " " * 64
+
+    @staticmethod
+    def _indent(*lines):
+        """Indent list of code lines to make executable Python code
+
+        Indents a tree-recursive list of strings, following the rule that one
+        space is added to the tab after a line that ends in a colon, and one is
+        removed after a line that ends in an hashmark.
+
+        Parameters
+        ----------
+        *lines : lists and/or strings
+            A recursive list of strings to be assembled into properly indented
+            code.
+
+        Returns
+        -------
+        code : str
+
+        Examples
+        --------
+
+            argmap._indent(*["try:", "try:", "pass#", "finally:", "pass#", "#",
+                             "finally:", "pass#"])
+
+        renders to
+
+            '''try:
+             try:
+              pass#
+             finally:
+              pass#
+             #
+            finally:
+             pass#'''
+        """
+        depth = 0
+        for line in argmap._flatten(lines, set()):
+            yield f"{argmap._tabs[:depth]}{line}"
+            depth += (line[-1:] == ":") - (line[-1:] == "#")
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/heaps.py b/myenv/lib/python3.9/site-packages/networkx/utils/heaps.py
new file mode 100644
index 0000000..f64d128
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/heaps.py
@@ -0,0 +1,340 @@
+"""
+Min-heaps.
+"""
+
+from heapq import heappop, heappush
+from itertools import count
+
+import networkx as nx
+
+__all__ = ["MinHeap", "PairingHeap", "BinaryHeap"]
+
+
+class MinHeap:
+    """Base class for min-heaps.
+
+    A MinHeap stores a collection of key-value pairs ordered by their values.
+    It supports querying the minimum pair, inserting a new pair, decreasing the
+    value in an existing pair and deleting the minimum pair.
+    """
+
+    class _Item:
+        """Used by subclassess to represent a key-value pair."""
+
+        __slots__ = ("key", "value")
+
+        def __init__(self, key, value):
+            self.key = key
+            self.value = value
+
+        def __repr__(self):
+            return repr((self.key, self.value))
+
+    def __init__(self):
+        """Initialize a new min-heap."""
+        self._dict = {}
+
+    def min(self):
+        """Query the minimum key-value pair.
+
+        Returns
+        -------
+        key, value : tuple
+            The key-value pair with the minimum value in the heap.
+
+        Raises
+        ------
+        NetworkXError
+            If the heap is empty.
+        """
+        raise NotImplementedError
+
+    def pop(self):
+        """Delete the minimum pair in the heap.
+
+        Returns
+        -------
+        key, value : tuple
+            The key-value pair with the minimum value in the heap.
+
+        Raises
+        ------
+        NetworkXError
+            If the heap is empty.
+        """
+        raise NotImplementedError
+
+    def get(self, key, default=None):
+        """Returns the value associated with a key.
+
+        Parameters
+        ----------
+        key : hashable object
+            The key to be looked up.
+
+        default : object
+            Default value to return if the key is not present in the heap.
+            Default value: None.
+
+        Returns
+        -------
+        value : object.
+            The value associated with the key.
+        """
+        raise NotImplementedError
+
+    def insert(self, key, value, allow_increase=False):
+        """Insert a new key-value pair or modify the value in an existing
+        pair.
+
+        Parameters
+        ----------
+        key : hashable object
+            The key.
+
+        value : object comparable with existing values.
+            The value.
+
+        allow_increase : bool
+            Whether the value is allowed to increase. If False, attempts to
+            increase an existing value have no effect. Default value: False.
+
+        Returns
+        -------
+        decreased : bool
+            True if a pair is inserted or the existing value is decreased.
+        """
+        raise NotImplementedError
+
+    def __nonzero__(self):
+        """Returns whether the heap if empty."""
+        return bool(self._dict)
+
+    def __bool__(self):
+        """Returns whether the heap if empty."""
+        return bool(self._dict)
+
+    def __len__(self):
+        """Returns the number of key-value pairs in the heap."""
+        return len(self._dict)
+
+    def __contains__(self, key):
+        """Returns whether a key exists in the heap.
+
+        Parameters
+        ----------
+        key : any hashable object.
+            The key to be looked up.
+        """
+        return key in self._dict
+
+
+class PairingHeap(MinHeap):
+    """A pairing heap."""
+
+    class _Node(MinHeap._Item):
+        """A node in a pairing heap.
+
+        A tree in a pairing heap is stored using the left-child, right-sibling
+        representation.
+        """
+
+        __slots__ = ("left", "next", "prev", "parent")
+
+        def __init__(self, key, value):
+            super(PairingHeap._Node, self).__init__(key, value)
+            # The leftmost child.
+            self.left = None
+            # The next sibling.
+            self.next = None
+            # The previous sibling.
+            self.prev = None
+            # The parent.
+            self.parent = None
+
+    def __init__(self):
+        """Initialize a pairing heap."""
+        super().__init__()
+        self._root = None
+
+    def min(self):
+        if self._root is None:
+            raise nx.NetworkXError("heap is empty.")
+        return (self._root.key, self._root.value)
+
+    def pop(self):
+        if self._root is None:
+            raise nx.NetworkXError("heap is empty.")
+        min_node = self._root
+        self._root = self._merge_children(self._root)
+        del self._dict[min_node.key]
+        return (min_node.key, min_node.value)
+
+    def get(self, key, default=None):
+        node = self._dict.get(key)
+        return node.value if node is not None else default
+
+    def insert(self, key, value, allow_increase=False):
+        node = self._dict.get(key)
+        root = self._root
+        if node is not None:
+            if value < node.value:
+                node.value = value
+                if node is not root and value < node.parent.value:
+                    self._cut(node)
+                    self._root = self._link(root, node)
+                return True
+            elif allow_increase and value > node.value:
+                node.value = value
+                child = self._merge_children(node)
+                # Nonstandard step: Link the merged subtree with the root. See
+                # below for the standard step.
+                if child is not None:
+                    self._root = self._link(self._root, child)
+                # Standard step: Perform a decrease followed by a pop as if the
+                # value were the smallest in the heap. Then insert the new
+                # value into the heap.
+                # if node is not root:
+                #     self._cut(node)
+                #     if child is not None:
+                #         root = self._link(root, child)
+                #     self._root = self._link(root, node)
+                # else:
+                #     self._root = (self._link(node, child)
+                #                   if child is not None else node)
+            return False
+        else:
+            # Insert a new key.
+            node = self._Node(key, value)
+            self._dict[key] = node
+            self._root = self._link(root, node) if root is not None else node
+            return True
+
+    def _link(self, root, other):
+        """Link two nodes, making the one with the smaller value the parent of
+        the other.
+        """
+        if other.value < root.value:
+            root, other = other, root
+        next = root.left
+        other.next = next
+        if next is not None:
+            next.prev = other
+        other.prev = None
+        root.left = other
+        other.parent = root
+        return root
+
+    def _merge_children(self, root):
+        """Merge the subtrees of the root using the standard two-pass method.
+        The resulting subtree is detached from the root.
+        """
+        node = root.left
+        root.left = None
+        if node is not None:
+            link = self._link
+            # Pass 1: Merge pairs of consecutive subtrees from left to right.
+            # At the end of the pass, only the prev pointers of the resulting
+            # subtrees have meaningful values. The other pointers will be fixed
+            # in pass 2.
+            prev = None
+            while True:
+                next = node.next
+                if next is None:
+                    node.prev = prev
+                    break
+                next_next = next.next
+                node = link(node, next)
+                node.prev = prev
+                prev = node
+                if next_next is None:
+                    break
+                node = next_next
+            # Pass 2: Successively merge the subtrees produced by pass 1 from
+            # right to left with the rightmost one.
+            prev = node.prev
+            while prev is not None:
+                prev_prev = prev.prev
+                node = link(prev, node)
+                prev = prev_prev
+            # Now node can become the new root. Its has no parent nor siblings.
+            node.prev = None
+            node.next = None
+            node.parent = None
+        return node
+
+    def _cut(self, node):
+        """Cut a node from its parent."""
+        prev = node.prev
+        next = node.next
+        if prev is not None:
+            prev.next = next
+        else:
+            node.parent.left = next
+        node.prev = None
+        if next is not None:
+            next.prev = prev
+            node.next = None
+        node.parent = None
+
+
+class BinaryHeap(MinHeap):
+    """A binary heap."""
+
+    def __init__(self):
+        """Initialize a binary heap."""
+        super().__init__()
+        self._heap = []
+        self._count = count()
+
+    def min(self):
+        dict = self._dict
+        if not dict:
+            raise nx.NetworkXError("heap is empty")
+        heap = self._heap
+        pop = heappop
+        # Repeatedly remove stale key-value pairs until a up-to-date one is
+        # met.
+        while True:
+            value, _, key = heap[0]
+            if key in dict and value == dict[key]:
+                break
+            pop(heap)
+        return (key, value)
+
+    def pop(self):
+        dict = self._dict
+        if not dict:
+            raise nx.NetworkXError("heap is empty")
+        heap = self._heap
+        pop = heappop
+        # Repeatedly remove stale key-value pairs until a up-to-date one is
+        # met.
+        while True:
+            value, _, key = heap[0]
+            pop(heap)
+            if key in dict and value == dict[key]:
+                break
+        del dict[key]
+        return (key, value)
+
+    def get(self, key, default=None):
+        return self._dict.get(key, default)
+
+    def insert(self, key, value, allow_increase=False):
+        dict = self._dict
+        if key in dict:
+            old_value = dict[key]
+            if value < old_value or (allow_increase and value > old_value):
+                # Since there is no way to efficiently obtain the location of a
+                # key-value pair in the heap, insert a new pair even if ones
+                # with the same key may already be present. Deem the old ones
+                # as stale and skip them when the minimum pair is queried.
+                dict[key] = value
+                heappush(self._heap, (value, next(self._count), key))
+                return value < old_value
+            return False
+        else:
+            dict[key] = value
+            heappush(self._heap, (value, next(self._count), key))
+            return True
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/mapped_queue.py b/myenv/lib/python3.9/site-packages/networkx/utils/mapped_queue.py
new file mode 100644
index 0000000..0ff53a0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/mapped_queue.py
@@ -0,0 +1,267 @@
+"""Priority queue class with updatable priorities.
+"""
+
+import heapq
+
+__all__ = ["MappedQueue"]
+
+
+class _HeapElement:
+    """This proxy class separates the heap element from its priority.
+
+    The idea is that using a 2-tuple (priority, element) works
+    for sorting, but not for dict lookup because priorities are
+    often floating point values so round-off can mess up equality.
+
+    So, we need inequalities to look at the priority (for sorting)
+    and equality (and hash) to look at the element to enable
+    updates to the priority.
+
+    Unfortunately, this class can be tricky to work with if you forget that
+    `__lt__` compares the priority while `__eq__` compares the element.
+    In `greedy_modularity_communities()` the following code is
+    used to check that two _HeapElements differ in either element or priority:
+
+        if d_oldmax != row_max or d_oldmax.priority != row_max.priority:
+
+    If the priorities are the same, this implementation uses the element
+    as a tiebreaker. This provides compatibility with older systems that
+    use tuples to combine priority and elements.
+    """
+
+    __slots__ = ["priority", "element", "_hash"]
+
+    def __init__(self, priority, element):
+        self.priority = priority
+        self.element = element
+        self._hash = hash(element)
+
+    def __lt__(self, other):
+        try:
+            other_priority = other.priority
+        except AttributeError:
+            return self.priority < other
+        # assume comparing to another _HeapElement
+        if self.priority == other_priority:
+            return self.element < other.element
+        return self.priority < other_priority
+
+    def __gt__(self, other):
+        try:
+            other_priority = other.priority
+        except AttributeError:
+            return self.priority > other
+        # assume comparing to another _HeapElement
+        if self.priority == other_priority:
+            return self.element < other.element
+        return self.priority > other_priority
+
+    def __eq__(self, other):
+        try:
+            return self.element == other.element
+        except AttributeError:
+            return self.element == other
+
+    def __hash__(self):
+        return self._hash
+
+    def __getitem__(self, indx):
+        return self.priority if indx == 0 else self.element[indx - 1]
+
+    def __iter__(self):
+        yield self.priority
+        try:
+            yield from self.element
+        except TypeError:
+            yield self.element
+
+    def __repr__(self):
+        return f"_HeapElement({self.priority}, {self.element})"
+
+
+class MappedQueue:
+    """The MappedQueue class implements a min-heap with removal and update-priority.
+
+    The min heap uses heapq as well as custom written _siftup and _siftdown
+    methods to allow the heap positions to be tracked by an additional dict
+    keyed by element to position. The smallest element can be popped in O(1) time,
+    new elements can be pushed in O(log n) time, and any element can be removed
+    or updated in O(log n) time. The queue cannot contain duplicate elements
+    and an attempt to push an element already in the queue will have no effect.
+
+    MappedQueue complements the heapq package from the python standard
+    library. While MappedQueue is designed for maximum compatibility with
+    heapq, it adds element removal, lookup, and priority update.
+
+    Examples
+    --------
+
+    A `MappedQueue` can be created empty or optionally given an array of
+    initial elements. Calling `push()` will add an element and calling `pop()`
+    will remove and return the smallest element.
+
+    >>> q = MappedQueue([916, 50, 4609, 493, 237])
+    >>> q.push(1310)
+    True
+    >>> [q.pop() for i in range(len(q.heap))]
+    [50, 237, 493, 916, 1310, 4609]
+
+    Elements can also be updated or removed from anywhere in the queue.
+
+    >>> q = MappedQueue([916, 50, 4609, 493, 237])
+    >>> q.remove(493)
+    >>> q.update(237, 1117)
+    >>> [q.pop() for i in range(len(q.heap))]
+    [50, 916, 1117, 4609]
+
+    References
+    ----------
+    .. [1] Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2001).
+       Introduction to algorithms second edition.
+    .. [2] Knuth, D. E. (1997). The art of computer programming (Vol. 3).
+       Pearson Education.
+    """
+
+    def __init__(self, data=[]):
+        """Priority queue class with updatable priorities."""
+        if isinstance(data, dict):
+            self.heap = [_HeapElement(v, k) for k, v in data.items()]
+        else:
+            self.heap = list(data)
+        self.position = dict()
+        self._heapify()
+
+    def _heapify(self):
+        """Restore heap invariant and recalculate map."""
+        heapq.heapify(self.heap)
+        self.position = {elt: pos for pos, elt in enumerate(self.heap)}
+        if len(self.heap) != len(self.position):
+            raise AssertionError("Heap contains duplicate elements")
+
+    def __len__(self):
+        return len(self.heap)
+
+    def push(self, elt, priority=None):
+        """Add an element to the queue."""
+        if priority is not None:
+            elt = _HeapElement(priority, elt)
+        # If element is already in queue, do nothing
+        if elt in self.position:
+            return False
+        # Add element to heap and dict
+        pos = len(self.heap)
+        self.heap.append(elt)
+        self.position[elt] = pos
+        # Restore invariant by sifting down
+        self._siftdown(0, pos)
+        return True
+
+    def pop(self):
+        """Remove and return the smallest element in the queue."""
+        # Remove smallest element
+        elt = self.heap[0]
+        del self.position[elt]
+        # If elt is last item, remove and return
+        if len(self.heap) == 1:
+            self.heap.pop()
+            return elt
+        # Replace root with last element
+        last = self.heap.pop()
+        self.heap[0] = last
+        self.position[last] = 0
+        # Restore invariant by sifting up
+        self._siftup(0)
+        # Return smallest element
+        return elt
+
+    def update(self, elt, new, priority=None):
+        """Replace an element in the queue with a new one."""
+        if priority is not None:
+            new = _HeapElement(priority, new)
+        # Replace
+        pos = self.position[elt]
+        self.heap[pos] = new
+        del self.position[elt]
+        self.position[new] = pos
+        # Restore invariant by sifting up
+        self._siftup(pos)
+
+    def remove(self, elt):
+        """Remove an element from the queue."""
+        # Find and remove element
+        try:
+            pos = self.position[elt]
+            del self.position[elt]
+        except KeyError:
+            # Not in queue
+            raise
+        # If elt is last item, remove and return
+        if pos == len(self.heap) - 1:
+            self.heap.pop()
+            return
+        # Replace elt with last element
+        last = self.heap.pop()
+        self.heap[pos] = last
+        self.position[last] = pos
+        # Restore invariant by sifting up
+        self._siftup(pos)
+
+    def _siftup(self, pos):
+        """Move smaller child up until hitting a leaf.
+
+        Built to mimic code for heapq._siftup
+        only updating position dict too.
+        """
+        heap, position = self.heap, self.position
+        end_pos = len(heap)
+        startpos = pos
+        newitem = heap[pos]
+        # Shift up the smaller child until hitting a leaf
+        child_pos = (pos << 1) + 1  # start with leftmost child position
+        while child_pos < end_pos:
+            # Set child_pos to index of smaller child.
+            child = heap[child_pos]
+            right_pos = child_pos + 1
+            if right_pos < end_pos:
+                right = heap[right_pos]
+                if not child < right:
+                    child = right
+                    child_pos = right_pos
+            # Move the smaller child up.
+            heap[pos] = child
+            position[child] = pos
+            pos = child_pos
+            child_pos = (pos << 1) + 1
+        # pos is a leaf position. Put newitem there, and bubble it up
+        # to its final resting place (by sifting its parents down).
+        while pos > 0:
+            parent_pos = (pos - 1) >> 1
+            parent = heap[parent_pos]
+            if not newitem < parent:
+                break
+            heap[pos] = parent
+            position[parent] = pos
+            pos = parent_pos
+        heap[pos] = newitem
+        position[newitem] = pos
+
+    def _siftdown(self, start_pos, pos):
+        """Restore invariant. keep swapping with parent until smaller.
+
+        Built to mimic code for heapq._siftdown
+        only updating position dict too.
+        """
+        heap, position = self.heap, self.position
+        newitem = heap[pos]
+        # Follow the path to the root, moving parents down until finding a place
+        # newitem fits.
+        while pos > start_pos:
+            parent_pos = (pos - 1) >> 1
+            parent = heap[parent_pos]
+            if not newitem < parent:
+                break
+            heap[pos] = parent
+            position[parent] = pos
+            pos = parent_pos
+        heap[pos] = newitem
+        position[newitem] = pos
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/misc.py b/myenv/lib/python3.9/site-packages/networkx/utils/misc.py
new file mode 100644
index 0000000..51a527d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/misc.py
@@ -0,0 +1,711 @@
+"""
+Miscellaneous Helpers for NetworkX.
+
+These are not imported into the base networkx namespace but
+can be accessed, for example, as
+
+>>> import networkx
+>>> networkx.utils.make_list_of_ints({1, 2, 3})
+[1, 2, 3]
+>>> networkx.utils.arbitrary_element({5, 1, 7})  # doctest: +SKIP
+1
+"""
+
+import sys
+import uuid
+import warnings
+from collections import defaultdict, deque
+from collections.abc import Iterable, Iterator, Sized
+from itertools import chain, tee
+
+import networkx as nx
+
+__all__ = [
+    "is_string_like",
+    "iterable",
+    "empty_generator",
+    "flatten",
+    "make_list_of_ints",
+    "is_list_of_ints",
+    "make_str",
+    "generate_unique_node",
+    "default_opener",
+    "dict_to_numpy_array",
+    "dict_to_numpy_array1",
+    "dict_to_numpy_array2",
+    "is_iterator",
+    "arbitrary_element",
+    "consume",
+    "pairwise",
+    "groups",
+    "to_tuple",
+    "create_random_state",
+    "create_py_random_state",
+    "PythonRandomInterface",
+    "nodes_equal",
+    "edges_equal",
+    "graphs_equal",
+]
+
+
+# some cookbook stuff
+# used in deciding whether something is a bunch of nodes, edges, etc.
+# see G.add_nodes and others in Graph Class in networkx/base.py
+
+
+def is_string_like(obj):  # from John Hunter, types-free version
+    """Check if obj is string.
+
+    .. deprecated:: 2.6
+        This is deprecated and will be removed in NetworkX v3.0.
+    """
+    msg = (
+        "is_string_like is deprecated and will be removed in 3.0."
+        "Use isinstance(obj, str) instead."
+    )
+    warnings.warn(msg, DeprecationWarning)
+    return isinstance(obj, str)
+
+
+def iterable(obj):
+    """Return True if obj is iterable with a well-defined len().
+
+    .. deprecated:: 2.6
+        This is deprecated and will be removed in NetworkX v3.0.
+    """
+    msg = (
+        "iterable is deprecated and will be removed in 3.0."
+        "Use isinstance(obj, (collections.abc.Iterable, collections.abc.Sized)) instead."
+    )
+    warnings.warn(msg, DeprecationWarning)
+    if hasattr(obj, "__iter__"):
+        return True
+    try:
+        len(obj)
+    except:
+        return False
+    return True
+
+
+def empty_generator():
+    """Return a generator with no members.
+
+    .. deprecated:: 2.6
+    """
+    warnings.warn(
+        "empty_generator is deprecated and will be removed in v3.0.", DeprecationWarning
+    )
+    return (i for i in ())
+
+
+def flatten(obj, result=None):
+    """Return flattened version of (possibly nested) iterable object."""
+    if not isinstance(obj, (Iterable, Sized)) or isinstance(obj, str):
+        return obj
+    if result is None:
+        result = []
+    for item in obj:
+        if not isinstance(item, (Iterable, Sized)) or isinstance(item, str):
+            result.append(item)
+        else:
+            flatten(item, result)
+    return tuple(result)
+
+
+def make_list_of_ints(sequence):
+    """Return list of ints from sequence of integral numbers.
+
+    All elements of the sequence must satisfy int(element) == element
+    or a ValueError is raised. Sequence is iterated through once.
+
+    If sequence is a list, the non-int values are replaced with ints.
+    So, no new list is created
+    """
+    if not isinstance(sequence, list):
+        result = []
+        for i in sequence:
+            errmsg = f"sequence is not all integers: {i}"
+            try:
+                ii = int(i)
+            except ValueError:
+                raise nx.NetworkXError(errmsg) from None
+            if ii != i:
+                raise nx.NetworkXError(errmsg)
+            result.append(ii)
+        return result
+    # original sequence is a list... in-place conversion to ints
+    for indx, i in enumerate(sequence):
+        errmsg = f"sequence is not all integers: {i}"
+        if isinstance(i, int):
+            continue
+        try:
+            ii = int(i)
+        except ValueError:
+            raise nx.NetworkXError(errmsg) from None
+        if ii != i:
+            raise nx.NetworkXError(errmsg)
+        sequence[indx] = ii
+    return sequence
+
+
+def is_list_of_ints(intlist):
+    """Return True if list is a list of ints.
+
+    .. deprecated:: 2.6
+        This is deprecated and will be removed in NetworkX v3.0.
+    """
+    msg = (
+        "is_list_of_ints is deprecated and will be removed in 3.0."
+        "See also: ``networkx.utils.make_list_of_ints.``"
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    if not isinstance(intlist, list):
+        return False
+    for i in intlist:
+        if not isinstance(i, int):
+            return False
+    return True
+
+
+def make_str(x):
+    """Returns the string representation of t.
+
+    .. deprecated:: 2.6
+        This is deprecated and will be removed in NetworkX v3.0.
+    """
+    msg = "make_str is deprecated and will be removed in 3.0. Use str instead."
+    warnings.warn(msg, DeprecationWarning)
+    return str(x)
+
+
+def generate_unique_node():
+    """Generate a unique node label.
+
+    .. deprecated:: 2.6
+        This is deprecated and will be removed in NetworkX v3.0.
+    """
+    msg = "generate_unique_node is deprecated and will be removed in 3.0. Use uuid.uuid4 instead."
+    warnings.warn(msg, DeprecationWarning)
+    return str(uuid.uuid4())
+
+
+def default_opener(filename):
+    """Opens `filename` using system's default program.
+
+    .. deprecated:: 2.6
+       default_opener is deprecated and will be removed in version 3.0.
+       Consider an image processing library to open images, such as Pillow::
+
+           from PIL import Image
+           Image.open(filename).show()
+
+    Parameters
+    ----------
+    filename : str
+        The path of the file to be opened.
+
+    """
+    warnings.warn(
+        "default_opener is deprecated and will be removed in version 3.0. ",
+        DeprecationWarning,
+    )
+    from subprocess import call
+
+    cmds = {
+        "darwin": ["open"],
+        "linux": ["xdg-open"],
+        "linux2": ["xdg-open"],
+        "win32": ["cmd.exe", "/C", "start", ""],
+    }
+    cmd = cmds[sys.platform] + [filename]
+    call(cmd)
+
+
+def dict_to_numpy_array(d, mapping=None):
+    """Convert a dictionary of dictionaries to a numpy array
+    with optional mapping."""
+    try:
+        return _dict_to_numpy_array2(d, mapping)
+    except (AttributeError, TypeError):
+        # AttributeError is when no mapping was provided and v.keys() fails.
+        # TypeError is when a mapping was provided and d[k1][k2] fails.
+        return _dict_to_numpy_array1(d, mapping)
+
+
+def dict_to_numpy_array2(d, mapping=None):
+    """Convert a dict of dicts to a 2d numpy array with optional mapping.
+
+    .. deprecated:: 2.8
+
+       dict_to_numpy_array2 is deprecated and will be removed in networkx 3.0.
+       Use `dict_to_numpy_array` instead.
+    """
+    msg = (
+        "dict_to_numpy_array2 is deprecated and will be removed in networkx 3.0.\n"
+        "Use dict_to_numpy_array instead."
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+
+    return _dict_to_numpy_array2(d, mapping)
+
+
+def _dict_to_numpy_array2(d, mapping=None):
+    """Convert a dictionary of dictionaries to a 2d numpy array
+    with optional mapping.
+
+    """
+    import numpy as np
+
+    if mapping is None:
+        s = set(d.keys())
+        for k, v in d.items():
+            s.update(v.keys())
+        mapping = dict(zip(s, range(len(s))))
+    n = len(mapping)
+    a = np.zeros((n, n))
+    for k1, i in mapping.items():
+        for k2, j in mapping.items():
+            try:
+                a[i, j] = d[k1][k2]
+            except KeyError:
+                pass
+    return a
+
+
+def dict_to_numpy_array1(d, mapping=None):
+    """Convert a dict of numbers to a 1d numpy array with optional mapping.
+
+    .. deprecated:: 2.8
+
+       dict_to_numpy_array1 is deprecated and will be removed in networkx 3.0.
+       Use dict_to_numpy_array instead.
+    """
+    msg = (
+        "dict_to_numpy_array1 is deprecated and will be removed in networkx 3.0.\n"
+        "Use dict_to_numpy_array instead."
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+
+    return _dict_to_numpy_array1(d, mapping)
+
+
+def _dict_to_numpy_array1(d, mapping=None):
+    """Convert a dictionary of numbers to a 1d numpy array with optional mapping."""
+    import numpy as np
+
+    if mapping is None:
+        s = set(d.keys())
+        mapping = dict(zip(s, range(len(s))))
+    n = len(mapping)
+    a = np.zeros(n)
+    for k1, i in mapping.items():
+        i = mapping[k1]
+        a[i] = d[k1]
+    return a
+
+
+def is_iterator(obj):
+    """Returns True if and only if the given object is an iterator object.
+
+    .. deprecated:: 2.6.0
+        Deprecated in favor of ``isinstance(obj, collections.abc.Iterator)``
+    """
+    msg = (
+        "is_iterator is deprecated and will be removed in version 3.0. "
+        "Use ``isinstance(obj, collections.abc.Iterator)`` instead."
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    has_next_attr = hasattr(obj, "__next__") or hasattr(obj, "next")
+    return iter(obj) is obj and has_next_attr
+
+
+def arbitrary_element(iterable):
+    """Returns an arbitrary element of `iterable` without removing it.
+
+    This is most useful for "peeking" at an arbitrary element of a set,
+    but can be used for any list, dictionary, etc., as well.
+
+    Parameters
+    ----------
+    iterable : `abc.collections.Iterable` instance
+        Any object that implements ``__iter__``, e.g. set, dict, list, tuple,
+        etc.
+
+    Returns
+    -------
+    The object that results from ``next(iter(iterable))``
+
+    Raises
+    ------
+    ValueError
+        If `iterable` is an iterator (because the current implementation of
+        this function would consume an element from the iterator).
+
+    Examples
+    --------
+    Arbitrary elements from common Iterable objects:
+
+    >>> nx.utils.arbitrary_element([1, 2, 3])  # list
+    1
+    >>> nx.utils.arbitrary_element((1, 2, 3))  # tuple
+    1
+    >>> nx.utils.arbitrary_element({1, 2, 3})  # set
+    1
+    >>> d = {k: v for k, v in zip([1, 2, 3], [3, 2, 1])}
+    >>> nx.utils.arbitrary_element(d)  # dict_keys
+    1
+    >>> nx.utils.arbitrary_element(d.values())   # dict values
+    3
+
+    `str` is also an Iterable:
+
+    >>> nx.utils.arbitrary_element("hello")
+    'h'
+
+    :exc:`ValueError` is raised if `iterable` is an iterator:
+
+    >>> iterator = iter([1, 2, 3])  # Iterator, *not* Iterable
+    >>> nx.utils.arbitrary_element(iterator)
+    Traceback (most recent call last):
+        ...
+    ValueError: cannot return an arbitrary item from an iterator
+
+    Notes
+    -----
+    This function does not return a *random* element. If `iterable` is
+    ordered, sequential calls will return the same value::
+
+        >>> l = [1, 2, 3]
+        >>> nx.utils.arbitrary_element(l)
+        1
+        >>> nx.utils.arbitrary_element(l)
+        1
+
+    """
+    if isinstance(iterable, Iterator):
+        raise ValueError("cannot return an arbitrary item from an iterator")
+    # Another possible implementation is ``for x in iterable: return x``.
+    return next(iter(iterable))
+
+
+# Recipe from the itertools documentation.
+def consume(iterator):
+    """Consume the iterator entirely.
+
+    .. deprecated:: 2.6
+        This is deprecated and will be removed in NetworkX v3.0.
+    """
+    # Feed the entire iterator into a zero-length deque.
+    msg = (
+        "consume is deprecated and will be removed in version 3.0. "
+        "Use ``collections.deque(iterator, maxlen=0)`` instead."
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    deque(iterator, maxlen=0)
+
+
+# Recipe from the itertools documentation.
+def pairwise(iterable, cyclic=False):
+    "s -> (s0, s1), (s1, s2), (s2, s3), ..."
+    a, b = tee(iterable)
+    first = next(b, None)
+    if cyclic is True:
+        return zip(a, chain(b, (first,)))
+    return zip(a, b)
+
+
+def groups(many_to_one):
+    """Converts a many-to-one mapping into a one-to-many mapping.
+
+    `many_to_one` must be a dictionary whose keys and values are all
+    :term:`hashable`.
+
+    The return value is a dictionary mapping values from `many_to_one`
+    to sets of keys from `many_to_one` that have that value.
+
+    Examples
+    --------
+    >>> from networkx.utils import groups
+    >>> many_to_one = {"a": 1, "b": 1, "c": 2, "d": 3, "e": 3}
+    >>> groups(many_to_one)  # doctest: +SKIP
+    {1: {'a', 'b'}, 2: {'c'}, 3: {'e', 'd'}}
+    """
+    one_to_many = defaultdict(set)
+    for v, k in many_to_one.items():
+        one_to_many[k].add(v)
+    return dict(one_to_many)
+
+
+def to_tuple(x):
+    """Converts lists to tuples.
+
+    .. deprecated:: 2.8
+
+       to_tuple is deprecated and will be removed in NetworkX 3.0.
+
+    Examples
+    --------
+    >>> from networkx.utils import to_tuple
+    >>> a_list = [1, 2, [1, 4]]
+    >>> to_tuple(a_list)
+    (1, 2, (1, 4))
+    """
+    warnings.warn(
+        "to_tuple is deprecated and will be removed in NetworkX 3.0.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    if not isinstance(x, (tuple, list)):
+        return x
+    return tuple(map(to_tuple, x))
+
+
+def create_random_state(random_state=None):
+    """Returns a numpy.random.RandomState or numpy.random.Generator instance
+    depending on input.
+
+    Parameters
+    ----------
+    random_state : int or NumPy RandomState or Generator instance, optional (default=None)
+        If int, return a numpy.random.RandomState instance set with seed=int.
+        if `numpy.random.RandomState` instance, return it.
+        if `numpy.random.Generator` instance, return it.
+        if None or numpy.random, return the global random number generator used
+        by numpy.random.
+    """
+    import numpy as np
+
+    if random_state is None or random_state is np.random:
+        return np.random.mtrand._rand
+    if isinstance(random_state, np.random.RandomState):
+        return random_state
+    if isinstance(random_state, int):
+        return np.random.RandomState(random_state)
+    if isinstance(random_state, np.random.Generator):
+        return random_state
+    msg = (
+        f"{random_state} cannot be used to create a numpy.random.RandomState or\n"
+        "numpy.random.Generator instance"
+    )
+    raise ValueError(msg)
+
+
+class PythonRandomInterface:
+    def __init__(self, rng=None):
+        try:
+            import numpy as np
+        except ImportError:
+            msg = "numpy not found, only random.random available."
+            warnings.warn(msg, ImportWarning)
+
+        if rng is None:
+            self._rng = np.random.mtrand._rand
+        else:
+            self._rng = rng
+
+    def random(self):
+        return self._rng.random()
+
+    def uniform(self, a, b):
+        return a + (b - a) * self._rng.random()
+
+    def randrange(self, a, b=None):
+        import numpy as np
+
+        if isinstance(self._rng, np.random.Generator):
+            return self._rng.integers(a, b)
+        return self._rng.randint(a, b)
+
+    # NOTE: the numpy implementations of `choice` don't support strings, so
+    # this cannot be replaced with self._rng.choice
+    def choice(self, seq):
+        import numpy as np
+
+        if isinstance(self._rng, np.random.Generator):
+            idx = self._rng.integers(0, len(seq))
+        else:
+            idx = self._rng.randint(0, len(seq))
+        return seq[idx]
+
+    def gauss(self, mu, sigma):
+        return self._rng.normal(mu, sigma)
+
+    def shuffle(self, seq):
+        return self._rng.shuffle(seq)
+
+    #    Some methods don't match API for numpy RandomState.
+    #    Commented out versions are not used by NetworkX
+
+    def sample(self, seq, k):
+        return self._rng.choice(list(seq), size=(k,), replace=False)
+
+    def randint(self, a, b):
+        import numpy as np
+
+        if isinstance(self._rng, np.random.Generator):
+            return self._rng.integers(a, b + 1)
+        return self._rng.randint(a, b + 1)
+
+    #    exponential as expovariate with 1/argument,
+    def expovariate(self, scale):
+        return self._rng.exponential(1 / scale)
+
+    #    pareto as paretovariate with 1/argument,
+    def paretovariate(self, shape):
+        return self._rng.pareto(shape)
+
+
+#    weibull as weibullvariate multiplied by beta,
+#    def weibullvariate(self, alpha, beta):
+#        return self._rng.weibull(alpha) * beta
+#
+#    def triangular(self, low, high, mode):
+#        return self._rng.triangular(low, mode, high)
+#
+#    def choices(self, seq, weights=None, cum_weights=None, k=1):
+#        return self._rng.choice(seq
+
+
+def create_py_random_state(random_state=None):
+    """Returns a random.Random instance depending on input.
+
+    Parameters
+    ----------
+    random_state : int or random number generator or None (default=None)
+        If int, return a random.Random instance set with seed=int.
+        if random.Random instance, return it.
+        if None or the `random` package, return the global random number
+        generator used by `random`.
+        if np.random package, return the global numpy random number
+        generator wrapped in a PythonRandomInterface class.
+        if np.random.RandomState or np.random.Generator instance, return it
+        wrapped in PythonRandomInterface
+        if a PythonRandomInterface instance, return it
+    """
+    import random
+
+    try:
+        import numpy as np
+
+        if random_state is np.random:
+            return PythonRandomInterface(np.random.mtrand._rand)
+        if isinstance(random_state, (np.random.RandomState, np.random.Generator)):
+            return PythonRandomInterface(random_state)
+        if isinstance(random_state, PythonRandomInterface):
+            return random_state
+    except ImportError:
+        pass
+
+    if random_state is None or random_state is random:
+        return random._inst
+    if isinstance(random_state, random.Random):
+        return random_state
+    if isinstance(random_state, int):
+        return random.Random(random_state)
+    msg = f"{random_state} cannot be used to generate a random.Random instance"
+    raise ValueError(msg)
+
+
+def nodes_equal(nodes1, nodes2):
+    """Check if nodes are equal.
+
+    Equality here means equal as Python objects.
+    Node data must match if included.
+    The order of nodes is not relevant.
+
+    Parameters
+    ----------
+    nodes1, nodes2 : iterables of nodes, or (node, datadict) tuples
+
+    Returns
+    -------
+    bool
+        True if nodes are equal, False otherwise.
+    """
+    nlist1 = list(nodes1)
+    nlist2 = list(nodes2)
+    try:
+        d1 = dict(nlist1)
+        d2 = dict(nlist2)
+    except (ValueError, TypeError):
+        d1 = dict.fromkeys(nlist1)
+        d2 = dict.fromkeys(nlist2)
+    return d1 == d2
+
+
+def edges_equal(edges1, edges2):
+    """Check if edges are equal.
+
+    Equality here means equal as Python objects.
+    Edge data must match if included.
+    The order of the edges is not relevant.
+
+    Parameters
+    ----------
+    edges1, edges2 : iterables of with u, v nodes as
+        edge tuples (u, v), or
+        edge tuples with data dicts (u, v, d), or
+        edge tuples with keys and data dicts (u, v, k, d)
+
+    Returns
+    -------
+    bool
+        True if edges are equal, False otherwise.
+    """
+    from collections import defaultdict
+
+    d1 = defaultdict(dict)
+    d2 = defaultdict(dict)
+    c1 = 0
+    for c1, e in enumerate(edges1):
+        u, v = e[0], e[1]
+        data = [e[2:]]
+        if v in d1[u]:
+            data = d1[u][v] + data
+        d1[u][v] = data
+        d1[v][u] = data
+    c2 = 0
+    for c2, e in enumerate(edges2):
+        u, v = e[0], e[1]
+        data = [e[2:]]
+        if v in d2[u]:
+            data = d2[u][v] + data
+        d2[u][v] = data
+        d2[v][u] = data
+    if c1 != c2:
+        return False
+    # can check one direction because lengths are the same.
+    for n, nbrdict in d1.items():
+        for nbr, datalist in nbrdict.items():
+            if n not in d2:
+                return False
+            if nbr not in d2[n]:
+                return False
+            d2datalist = d2[n][nbr]
+            for data in datalist:
+                if datalist.count(data) != d2datalist.count(data):
+                    return False
+    return True
+
+
+def graphs_equal(graph1, graph2):
+    """Check if graphs are equal.
+
+    Equality here means equal as Python objects (not isomorphism).
+    Node, edge and graph data must match.
+
+    Parameters
+    ----------
+    graph1, graph2 : graph
+
+    Returns
+    -------
+    bool
+        True if graphs are equal, False otherwise.
+    """
+    return (
+        graph1.adj == graph2.adj
+        and graph1.nodes == graph2.nodes
+        and graph1.graph == graph2.graph
+    )
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/random_sequence.py b/myenv/lib/python3.9/site-packages/networkx/utils/random_sequence.py
new file mode 100644
index 0000000..ed2346c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/random_sequence.py
@@ -0,0 +1,164 @@
+"""
+Utilities for generating random numbers, random sequences, and
+random selections.
+"""
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = [
+    "powerlaw_sequence",
+    "zipf_rv",
+    "cumulative_distribution",
+    "discrete_sequence",
+    "random_weighted_sample",
+    "weighted_choice",
+]
+
+
+# The same helpers for choosing random sequences from distributions
+# uses Python's random module
+# https://docs.python.org/3/library/random.html
+
+
+@py_random_state(2)
+def powerlaw_sequence(n, exponent=2.0, seed=None):
+    """
+    Return sample sequence of length n from a power law distribution.
+    """
+    return [seed.paretovariate(exponent - 1) for i in range(n)]
+
+
+@py_random_state(2)
+def zipf_rv(alpha, xmin=1, seed=None):
+    r"""Returns a random value chosen from the Zipf distribution.
+
+    The return value is an integer drawn from the probability distribution
+
+    .. math::
+
+        p(x)=\frac{x^{-\alpha}}{\zeta(\alpha, x_{\min})},
+
+    where $\zeta(\alpha, x_{\min})$ is the Hurwitz zeta function.
+
+    Parameters
+    ----------
+    alpha : float
+      Exponent value of the distribution
+    xmin : int
+      Minimum value
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    x : int
+      Random value from Zipf distribution
+
+    Raises
+    ------
+    ValueError:
+      If xmin < 1 or
+      If alpha <= 1
+
+    Notes
+    -----
+    The rejection algorithm generates random values for a the power-law
+    distribution in uniformly bounded expected time dependent on
+    parameters.  See [1]_ for details on its operation.
+
+    Examples
+    --------
+    >>> nx.utils.zipf_rv(alpha=2, xmin=3, seed=42)
+    8
+
+    References
+    ----------
+    .. [1] Luc Devroye, Non-Uniform Random Variate Generation,
+       Springer-Verlag, New York, 1986.
+    """
+    if xmin < 1:
+        raise ValueError("xmin < 1")
+    if alpha <= 1:
+        raise ValueError("a <= 1.0")
+    a1 = alpha - 1.0
+    b = 2**a1
+    while True:
+        u = 1.0 - seed.random()  # u in (0,1]
+        v = seed.random()  # v in [0,1)
+        x = int(xmin * u ** -(1.0 / a1))
+        t = (1.0 + (1.0 / x)) ** a1
+        if v * x * (t - 1.0) / (b - 1.0) <= t / b:
+            break
+    return x
+
+
+def cumulative_distribution(distribution):
+    """Returns normalized cumulative distribution from discrete distribution."""
+
+    cdf = [0.0]
+    psum = sum(distribution)
+    for i in range(0, len(distribution)):
+        cdf.append(cdf[i] + distribution[i] / psum)
+    return cdf
+
+
+@py_random_state(3)
+def discrete_sequence(n, distribution=None, cdistribution=None, seed=None):
+    """
+    Return sample sequence of length n from a given discrete distribution
+    or discrete cumulative distribution.
+
+    One of the following must be specified.
+
+    distribution = histogram of values, will be normalized
+
+    cdistribution = normalized discrete cumulative distribution
+
+    """
+    import bisect
+
+    if cdistribution is not None:
+        cdf = cdistribution
+    elif distribution is not None:
+        cdf = cumulative_distribution(distribution)
+    else:
+        raise nx.NetworkXError(
+            "discrete_sequence: distribution or cdistribution missing"
+        )
+
+    # get a uniform random number
+    inputseq = [seed.random() for i in range(n)]
+
+    # choose from CDF
+    seq = [bisect.bisect_left(cdf, s) - 1 for s in inputseq]
+    return seq
+
+
+@py_random_state(2)
+def random_weighted_sample(mapping, k, seed=None):
+    """Returns k items without replacement from a weighted sample.
+
+    The input is a dictionary of items with weights as values.
+    """
+    if k > len(mapping):
+        raise ValueError("sample larger than population")
+    sample = set()
+    while len(sample) < k:
+        sample.add(weighted_choice(mapping, seed))
+    return list(sample)
+
+
+@py_random_state(1)
+def weighted_choice(mapping, seed=None):
+    """Returns a single element from a weighted sample.
+
+    The input is a dictionary of items with weights as values.
+    """
+    # use roulette method
+    rnd = seed.random() * sum(mapping.values())
+    for k, w in mapping.items():
+        rnd -= w
+        if rnd < 0:
+            return k
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/rcm.py b/myenv/lib/python3.9/site-packages/networkx/utils/rcm.py
new file mode 100644
index 0000000..8499fd8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/rcm.py
@@ -0,0 +1,158 @@
+"""
+Cuthill-McKee ordering of graph nodes to produce sparse matrices
+"""
+from collections import deque
+from operator import itemgetter
+
+import networkx as nx
+
+from ..utils import arbitrary_element
+
+__all__ = ["cuthill_mckee_ordering", "reverse_cuthill_mckee_ordering"]
+
+
+def cuthill_mckee_ordering(G, heuristic=None):
+    """Generate an ordering (permutation) of the graph nodes to make
+    a sparse matrix.
+
+    Uses the Cuthill-McKee heuristic (based on breadth-first search) [1]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    heuristic : function, optional
+      Function to choose starting node for RCM algorithm.  If None
+      a node from a pseudo-peripheral pair is used.  A user-defined function
+      can be supplied that takes a graph object and returns a single node.
+
+    Returns
+    -------
+    nodes : generator
+       Generator of nodes in Cuthill-McKee ordering.
+
+    Examples
+    --------
+    >>> from networkx.utils import cuthill_mckee_ordering
+    >>> G = nx.path_graph(4)
+    >>> rcm = list(cuthill_mckee_ordering(G))
+    >>> A = nx.adjacency_matrix(G, nodelist=rcm)
+
+    Smallest degree node as heuristic function:
+
+    >>> def smallest_degree(G):
+    ...     return min(G, key=G.degree)
+    >>> rcm = list(cuthill_mckee_ordering(G, heuristic=smallest_degree))
+
+
+    See Also
+    --------
+    reverse_cuthill_mckee_ordering
+
+    Notes
+    -----
+    The optimal solution the bandwidth reduction is NP-complete [2]_.
+
+
+    References
+    ----------
+    .. [1] E. Cuthill and J. McKee.
+       Reducing the bandwidth of sparse symmetric matrices,
+       In Proc. 24th Nat. Conf. ACM, pages 157-172, 1969.
+       http://doi.acm.org/10.1145/800195.805928
+    .. [2]  Steven S. Skiena. 1997. The Algorithm Design Manual.
+       Springer-Verlag New York, Inc., New York, NY, USA.
+    """
+    for c in nx.connected_components(G):
+        yield from connected_cuthill_mckee_ordering(G.subgraph(c), heuristic)
+
+
+def reverse_cuthill_mckee_ordering(G, heuristic=None):
+    """Generate an ordering (permutation) of the graph nodes to make
+    a sparse matrix.
+
+    Uses the reverse Cuthill-McKee heuristic (based on breadth-first search)
+    [1]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    heuristic : function, optional
+      Function to choose starting node for RCM algorithm.  If None
+      a node from a pseudo-peripheral pair is used.  A user-defined function
+      can be supplied that takes a graph object and returns a single node.
+
+    Returns
+    -------
+    nodes : generator
+       Generator of nodes in reverse Cuthill-McKee ordering.
+
+    Examples
+    --------
+    >>> from networkx.utils import reverse_cuthill_mckee_ordering
+    >>> G = nx.path_graph(4)
+    >>> rcm = list(reverse_cuthill_mckee_ordering(G))
+    >>> A = nx.adjacency_matrix(G, nodelist=rcm)
+
+    Smallest degree node as heuristic function:
+
+    >>> def smallest_degree(G):
+    ...     return min(G, key=G.degree)
+    >>> rcm = list(reverse_cuthill_mckee_ordering(G, heuristic=smallest_degree))
+
+
+    See Also
+    --------
+    cuthill_mckee_ordering
+
+    Notes
+    -----
+    The optimal solution the bandwidth reduction is NP-complete [2]_.
+
+    References
+    ----------
+    .. [1] E. Cuthill and J. McKee.
+       Reducing the bandwidth of sparse symmetric matrices,
+       In Proc. 24th Nat. Conf. ACM, pages 157-72, 1969.
+       http://doi.acm.org/10.1145/800195.805928
+    .. [2]  Steven S. Skiena. 1997. The Algorithm Design Manual.
+       Springer-Verlag New York, Inc., New York, NY, USA.
+    """
+    return reversed(list(cuthill_mckee_ordering(G, heuristic=heuristic)))
+
+
+def connected_cuthill_mckee_ordering(G, heuristic=None):
+    # the cuthill mckee algorithm for connected graphs
+    if heuristic is None:
+        start = pseudo_peripheral_node(G)
+    else:
+        start = heuristic(G)
+    visited = {start}
+    queue = deque([start])
+    while queue:
+        parent = queue.popleft()
+        yield parent
+        nd = sorted(list(G.degree(set(G[parent]) - visited)), key=itemgetter(1))
+        children = [n for n, d in nd]
+        visited.update(children)
+        queue.extend(children)
+
+
+def pseudo_peripheral_node(G):
+    # helper for cuthill-mckee to find a node in a "pseudo peripheral pair"
+    # to use as good starting node
+    u = arbitrary_element(G)
+    lp = 0
+    v = u
+    while True:
+        spl = dict(nx.shortest_path_length(G, v))
+        l = max(spl.values())
+        if l <= lp:
+            break
+        lp = l
+        farthest = (n for n, dist in spl.items() if dist == l)
+        v, deg = min(G.degree(farthest), key=itemgetter(1))
+    return v
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/tests/__init__.py b/myenv/lib/python3.9/site-packages/networkx/utils/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/tests/test__init.py b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test__init.py
new file mode 100644
index 0000000..ecbcce3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test__init.py
@@ -0,0 +1,11 @@
+import pytest
+
+
+def test_utils_namespace():
+    """Ensure objects are not unintentionally exposed in utils namespace."""
+    with pytest.raises(ImportError):
+        from networkx.utils import nx
+    with pytest.raises(ImportError):
+        from networkx.utils import sys
+    with pytest.raises(ImportError):
+        from networkx.utils import defaultdict, deque
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_contextmanager.py b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_contextmanager.py
new file mode 100644
index 0000000..6924683
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_contextmanager.py
@@ -0,0 +1,18 @@
+import networkx as nx
+
+
+def test_reversed():
+    G = nx.DiGraph()
+    G.add_edge("A", "B")
+
+    # no exception
+    with nx.utils.reversed(G):
+        pass
+    assert "B" in G["A"]
+
+    # exception
+    try:
+        with nx.utils.reversed(G):
+            raise Exception
+    except:
+        assert "B" in G["A"]
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_decorators.py b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_decorators.py
new file mode 100644
index 0000000..93f22be
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_decorators.py
@@ -0,0 +1,506 @@
+import os
+import pathlib
+import random
+import tempfile
+
+import pytest
+
+import networkx as nx
+from networkx.utils.decorators import (
+    argmap,
+    not_implemented_for,
+    np_random_state,
+    open_file,
+    preserve_random_state,
+    py_random_state,
+    random_state,
+)
+from networkx.utils.misc import PythonRandomInterface
+
+
+def test_not_implemented_decorator():
+    @not_implemented_for("directed")
+    def test_d(G):
+        pass
+
+    test_d(nx.Graph())
+    with pytest.raises(nx.NetworkXNotImplemented):
+        test_d(nx.DiGraph())
+
+    @not_implemented_for("undirected")
+    def test_u(G):
+        pass
+
+    test_u(nx.DiGraph())
+    with pytest.raises(nx.NetworkXNotImplemented):
+        test_u(nx.Graph())
+
+    @not_implemented_for("multigraph")
+    def test_m(G):
+        pass
+
+    test_m(nx.Graph())
+    with pytest.raises(nx.NetworkXNotImplemented):
+        test_m(nx.MultiGraph())
+
+    @not_implemented_for("graph")
+    def test_g(G):
+        pass
+
+    test_g(nx.MultiGraph())
+    with pytest.raises(nx.NetworkXNotImplemented):
+        test_g(nx.Graph())
+
+    # not MultiDiGraph  (multiple arguments => AND)
+    @not_implemented_for("directed", "multigraph")
+    def test_not_md(G):
+        pass
+
+    test_not_md(nx.Graph())
+    test_not_md(nx.DiGraph())
+    test_not_md(nx.MultiGraph())
+    with pytest.raises(nx.NetworkXNotImplemented):
+        test_not_md(nx.MultiDiGraph())
+
+    # Graph only      (multiple decorators =>  OR)
+    @not_implemented_for("directed")
+    @not_implemented_for("multigraph")
+    def test_graph_only(G):
+        pass
+
+    test_graph_only(nx.Graph())
+    with pytest.raises(nx.NetworkXNotImplemented):
+        test_graph_only(nx.DiGraph())
+    with pytest.raises(nx.NetworkXNotImplemented):
+        test_graph_only(nx.MultiGraph())
+    with pytest.raises(nx.NetworkXNotImplemented):
+        test_graph_only(nx.MultiDiGraph())
+
+    with pytest.raises(ValueError):
+        not_implemented_for("directed", "undirected")
+
+    with pytest.raises(ValueError):
+        not_implemented_for("multigraph", "graph")
+
+
+def test_not_implemented_decorator_key():
+    with pytest.raises(KeyError):
+
+        @not_implemented_for("foo")
+        def test1(G):
+            pass
+
+        test1(nx.Graph())
+
+
+def test_not_implemented_decorator_raise():
+    with pytest.raises(nx.NetworkXNotImplemented):
+
+        @not_implemented_for("graph")
+        def test1(G):
+            pass
+
+        test1(nx.Graph())
+
+
+class TestOpenFileDecorator:
+    def setup_method(self):
+        self.text = ["Blah... ", "BLAH ", "BLAH!!!!"]
+        self.fobj = tempfile.NamedTemporaryFile("wb+", delete=False)
+        self.name = self.fobj.name
+
+    def teardown_method(self):
+        self.fobj.close()
+        os.unlink(self.name)
+
+    def write(self, path):
+        for text in self.text:
+            path.write(text.encode("ascii"))
+
+    @open_file(1, "r")
+    def read(self, path):
+        return path.readlines()[0]
+
+    @staticmethod
+    @open_file(0, "wb")
+    def writer_arg0(path):
+        path.write(b"demo")
+
+    @open_file(1, "wb+")
+    def writer_arg1(self, path):
+        self.write(path)
+
+    @open_file(2, "wb")
+    def writer_arg2default(self, x, path=None):
+        if path is None:
+            with tempfile.NamedTemporaryFile("wb+") as fh:
+                self.write(fh)
+        else:
+            self.write(path)
+
+    @open_file(4, "wb")
+    def writer_arg4default(self, x, y, other="hello", path=None, **kwargs):
+        if path is None:
+            with tempfile.NamedTemporaryFile("wb+") as fh:
+                self.write(fh)
+        else:
+            self.write(path)
+
+    @open_file("path", "wb")
+    def writer_kwarg(self, **kwargs):
+        path = kwargs.get("path", None)
+        if path is None:
+            with tempfile.NamedTemporaryFile("wb+") as fh:
+                self.write(fh)
+        else:
+            self.write(path)
+
+    def test_writer_arg0_str(self):
+        self.writer_arg0(self.name)
+
+    def test_writer_arg0_fobj(self):
+        self.writer_arg0(self.fobj)
+
+    def test_writer_arg0_pathlib(self):
+        self.writer_arg0(pathlib.Path(self.name))
+
+    def test_writer_arg1_str(self):
+        self.writer_arg1(self.name)
+        assert self.read(self.name) == "".join(self.text)
+
+    def test_writer_arg1_fobj(self):
+        self.writer_arg1(self.fobj)
+        assert not self.fobj.closed
+        self.fobj.close()
+        assert self.read(self.name) == "".join(self.text)
+
+    def test_writer_arg2default_str(self):
+        self.writer_arg2default(0, path=None)
+        self.writer_arg2default(0, path=self.name)
+        assert self.read(self.name) == "".join(self.text)
+
+    def test_writer_arg2default_fobj(self):
+        self.writer_arg2default(0, path=self.fobj)
+        assert not self.fobj.closed
+        self.fobj.close()
+        assert self.read(self.name) == "".join(self.text)
+
+    def test_writer_arg2default_fobj_path_none(self):
+        self.writer_arg2default(0, path=None)
+
+    def test_writer_arg4default_fobj(self):
+        self.writer_arg4default(0, 1, dog="dog", other="other")
+        self.writer_arg4default(0, 1, dog="dog", other="other", path=self.name)
+        assert self.read(self.name) == "".join(self.text)
+
+    def test_writer_kwarg_str(self):
+        self.writer_kwarg(path=self.name)
+        assert self.read(self.name) == "".join(self.text)
+
+    def test_writer_kwarg_fobj(self):
+        self.writer_kwarg(path=self.fobj)
+        self.fobj.close()
+        assert self.read(self.name) == "".join(self.text)
+
+    def test_writer_kwarg_path_none(self):
+        self.writer_kwarg(path=None)
+
+
+@preserve_random_state
+def test_preserve_random_state():
+    try:
+        import numpy.random
+
+        r = numpy.random.random()
+    except ImportError:
+        return
+    assert abs(r - 0.61879477158568) < 1e-16
+
+
+class TestRandomState:
+    @classmethod
+    def setup_class(cls):
+        global np
+        np = pytest.importorskip("numpy")
+
+    @np_random_state(1)
+    def instantiate_np_random_state(self, random_state):
+        assert isinstance(random_state, np.random.RandomState)
+        return random_state.random_sample()
+
+    @py_random_state(1)
+    def instantiate_py_random_state(self, random_state):
+        assert isinstance(random_state, random.Random) or isinstance(
+            random_state, PythonRandomInterface
+        )
+        return random_state.random()
+
+    def test_random_state_None(self):
+        np.random.seed(42)
+        rv = np.random.random_sample()
+        np.random.seed(42)
+        assert rv == self.instantiate_np_random_state(None)
+
+        random.seed(42)
+        rv = random.random()
+        random.seed(42)
+        assert rv == self.instantiate_py_random_state(None)
+
+    def test_random_state_np_random(self):
+        np.random.seed(42)
+        rv = np.random.random_sample()
+        np.random.seed(42)
+        assert rv == self.instantiate_np_random_state(np.random)
+        np.random.seed(42)
+        assert rv == self.instantiate_py_random_state(np.random)
+
+    def test_random_state_int(self):
+        np.random.seed(42)
+        np_rv = np.random.random_sample()
+        random.seed(42)
+        py_rv = random.random()
+
+        np.random.seed(42)
+        seed = 1
+        rval = self.instantiate_np_random_state(seed)
+        rval_expected = np.random.RandomState(seed).rand()
+        assert rval, rval_expected
+        # test that global seed wasn't changed in function
+        assert np_rv == np.random.random_sample()
+
+        random.seed(42)
+        rval = self.instantiate_py_random_state(seed)
+        rval_expected = random.Random(seed).random()
+        assert rval, rval_expected
+        # test that global seed wasn't changed in function
+        assert py_rv == random.random()
+
+    def test_random_state_np_random_RandomState(self):
+        np.random.seed(42)
+        np_rv = np.random.random_sample()
+
+        np.random.seed(42)
+        seed = 1
+        rng = np.random.RandomState(seed)
+        rval = self.instantiate_np_random_state(seed)
+        rval_expected = np.random.RandomState(seed).rand()
+        assert rval, rval_expected
+
+        rval = self.instantiate_py_random_state(seed)
+        rval_expected = np.random.RandomState(seed).rand()
+        assert rval, rval_expected
+        # test that global seed wasn't changed in function
+        assert np_rv == np.random.random_sample()
+
+    def test_random_state_py_random(self):
+        seed = 1
+        rng = random.Random(seed)
+        rv = self.instantiate_py_random_state(rng)
+        assert rv, random.Random(seed).random()
+
+        pytest.raises(ValueError, self.instantiate_np_random_state, rng)
+
+
+def test_random_state_string_arg_index():
+    with pytest.raises(nx.NetworkXError):
+
+        @np_random_state("a")
+        def make_random_state(rs):
+            pass
+
+        rstate = make_random_state(1)
+
+
+def test_py_random_state_string_arg_index():
+    with pytest.raises(nx.NetworkXError):
+
+        @py_random_state("a")
+        def make_random_state(rs):
+            pass
+
+        rstate = make_random_state(1)
+
+
+def test_random_state_invalid_arg_index():
+    with pytest.raises(nx.NetworkXError):
+
+        @np_random_state(2)
+        def make_random_state(rs):
+            pass
+
+        rstate = make_random_state(1)
+
+
+def test_py_random_state_invalid_arg_index():
+    with pytest.raises(nx.NetworkXError):
+
+        @py_random_state(2)
+        def make_random_state(rs):
+            pass
+
+        rstate = make_random_state(1)
+
+
+class TestArgmap:
+    class ArgmapError(RuntimeError):
+        pass
+
+    def test_trivial_function(self):
+        def do_not_call(x):
+            raise ArgmapError("do not call this function")
+
+        @argmap(do_not_call)
+        def trivial_argmap():
+            return 1
+
+        assert trivial_argmap() == 1
+
+    def test_trivial_iterator(self):
+        def do_not_call(x):
+            raise ArgmapError("do not call this function")
+
+        @argmap(do_not_call)
+        def trivial_argmap():
+            yield from (1, 2, 3)
+
+        assert tuple(trivial_argmap()) == (1, 2, 3)
+
+    def test_contextmanager(self):
+        container = []
+
+        def contextmanager(x):
+            nonlocal container
+            return x, lambda: container.append(x)
+
+        @argmap(contextmanager, 0, 1, 2, try_finally=True)
+        def foo(x, y, z):
+            return x, y, z
+
+        x, y, z = foo("a", "b", "c")
+
+        # context exits are called in reverse
+        assert container == ["c", "b", "a"]
+
+    def test_tryfinally_generator(self):
+        container = []
+
+        def singleton(x):
+            return (x,)
+
+        with pytest.raises(nx.NetworkXError):
+
+            @argmap(singleton, 0, 1, 2, try_finally=True)
+            def foo(x, y, z):
+                yield from (x, y, z)
+
+        @argmap(singleton, 0, 1, 2)
+        def foo(x, y, z):
+            return x + y + z
+
+        q = foo("a", "b", "c")
+
+        assert q == ("a", "b", "c")
+
+    def test_actual_vararg(self):
+        @argmap(lambda x: -x, 4)
+        def foo(x, y, *args):
+            return (x, y) + tuple(args)
+
+        assert foo(1, 2, 3, 4, 5, 6) == (1, 2, 3, 4, -5, 6)
+
+    def test_signature_destroying_intermediate_decorator(self):
+        def add_one_to_first_bad_decorator(f):
+            """Bad because it doesn't wrap the f signature (clobbers it)"""
+
+            def decorated(a, *args, **kwargs):
+                return f(a + 1, *args, **kwargs)
+
+            return decorated
+
+        add_two_to_second = argmap(lambda b: b + 2, 1)
+
+        @add_two_to_second
+        @add_one_to_first_bad_decorator
+        def add_one_and_two(a, b):
+            return a, b
+
+        assert add_one_and_two(5, 5) == (6, 7)
+
+    def test_actual_kwarg(self):
+        @argmap(lambda x: -x, "arg")
+        def foo(*, arg):
+            return arg
+
+        assert foo(arg=3) == -3
+
+    def test_nested_tuple(self):
+        def xform(x, y):
+            u, v = y
+            return x + u + v, (x + u, x + v)
+
+        # we're testing args and kwargs here, too
+        @argmap(xform, (0, ("t", 2)))
+        def foo(a, *args, **kwargs):
+            return a, args, kwargs
+
+        a, args, kwargs = foo(1, 2, 3, t=4)
+
+        assert a == 1 + 4 + 3
+        assert args == (2, 1 + 3)
+        assert kwargs == {"t": 1 + 4}
+
+    def test_flatten(self):
+        assert tuple(argmap._flatten([[[[[], []], [], []], [], [], []]], set())) == ()
+
+        rlist = ["a", ["b", "c"], [["d"], "e"], "f"]
+        assert "".join(argmap._flatten(rlist, set())) == "abcdef"
+
+    def test_indent(self):
+        code = "\n".join(
+            argmap._indent(
+                *[
+                    "try:",
+                    "try:",
+                    "pass#",
+                    "finally:",
+                    "pass#",
+                    "#",
+                    "finally:",
+                    "pass#",
+                ]
+            )
+        )
+        assert (
+            code
+            == """try:
+ try:
+  pass#
+ finally:
+  pass#
+ #
+finally:
+ pass#"""
+        )
+
+    def test_immediate_raise(self):
+        @not_implemented_for("directed")
+        def yield_nodes(G):
+            yield from G
+
+        G = nx.Graph([(1, 2)])
+        D = nx.DiGraph()
+
+        # test first call (argmap is compiled and executed)
+        with pytest.raises(nx.NetworkXNotImplemented):
+            node_iter = yield_nodes(D)
+
+        # test second call (argmap is only executed)
+        with pytest.raises(nx.NetworkXNotImplemented):
+            node_iter = yield_nodes(D)
+
+        # ensure that generators still make generators
+        node_iter = yield_nodes(G)
+        next(node_iter)
+        next(node_iter)
+        with pytest.raises(StopIteration):
+            next(node_iter)
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_heaps.py b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_heaps.py
new file mode 100644
index 0000000..5ea3871
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_heaps.py
@@ -0,0 +1,131 @@
+import pytest
+
+import networkx as nx
+from networkx.utils import BinaryHeap, PairingHeap
+
+
+class X:
+    def __eq__(self, other):
+        raise self is other
+
+    def __ne__(self, other):
+        raise self is not other
+
+    def __lt__(self, other):
+        raise TypeError("cannot compare")
+
+    def __le__(self, other):
+        raise TypeError("cannot compare")
+
+    def __ge__(self, other):
+        raise TypeError("cannot compare")
+
+    def __gt__(self, other):
+        raise TypeError("cannot compare")
+
+    def __hash__(self):
+        return hash(id(self))
+
+
+x = X()
+
+
+data = [  # min should not invent an element.
+    ("min", nx.NetworkXError),
+    # Popping an empty heap should fail.
+    ("pop", nx.NetworkXError),
+    # Getting nonexisting elements should return None.
+    ("get", 0, None),
+    ("get", x, None),
+    ("get", None, None),
+    # Inserting a new key should succeed.
+    ("insert", x, 1, True),
+    ("get", x, 1),
+    ("min", (x, 1)),
+    # min should not pop the top element.
+    ("min", (x, 1)),
+    # Inserting a new key of different type should succeed.
+    ("insert", 1, -2.0, True),
+    # int and float values should interop.
+    ("min", (1, -2.0)),
+    # pop removes minimum-valued element.
+    ("insert", 3, -(10**100), True),
+    ("insert", 4, 5, True),
+    ("pop", (3, -(10**100))),
+    ("pop", (1, -2.0)),
+    # Decrease-insert should succeed.
+    ("insert", 4, -50, True),
+    ("insert", 4, -60, False, True),
+    # Decrease-insert should not create duplicate keys.
+    ("pop", (4, -60)),
+    ("pop", (x, 1)),
+    # Popping all elements should empty the heap.
+    ("min", nx.NetworkXError),
+    ("pop", nx.NetworkXError),
+    # Non-value-changing insert should fail.
+    ("insert", x, 0, True),
+    ("insert", x, 0, False, False),
+    ("min", (x, 0)),
+    ("insert", x, 0, True, False),
+    ("min", (x, 0)),
+    # Failed insert should not create duplicate keys.
+    ("pop", (x, 0)),
+    ("pop", nx.NetworkXError),
+    # Increase-insert should succeed when allowed.
+    ("insert", None, 0, True),
+    ("insert", 2, -1, True),
+    ("min", (2, -1)),
+    ("insert", 2, 1, True, False),
+    ("min", (None, 0)),
+    # Increase-insert should fail when disallowed.
+    ("insert", None, 2, False, False),
+    ("min", (None, 0)),
+    # Failed increase-insert should not create duplicate keys.
+    ("pop", (None, 0)),
+    ("pop", (2, 1)),
+    ("min", nx.NetworkXError),
+    ("pop", nx.NetworkXError),
+]
+
+
+def _test_heap_class(cls, *args, **kwargs):
+    heap = cls(*args, **kwargs)
+    # Basic behavioral test
+    for op in data:
+        if op[-1] is not nx.NetworkXError:
+            assert op[-1] == getattr(heap, op[0])(*op[1:-1])
+        else:
+            pytest.raises(op[-1], getattr(heap, op[0]), *op[1:-1])
+    # Coverage test.
+    for i in range(99, -1, -1):
+        assert heap.insert(i, i)
+    for i in range(50):
+        assert heap.pop() == (i, i)
+    for i in range(100):
+        assert heap.insert(i, i) == (i < 50)
+    for i in range(100):
+        assert not heap.insert(i, i + 1)
+    for i in range(50):
+        assert heap.pop() == (i, i)
+    for i in range(100):
+        assert heap.insert(i, i + 1) == (i < 50)
+    for i in range(49):
+        assert heap.pop() == (i, i + 1)
+    assert sorted([heap.pop(), heap.pop()]) == [(49, 50), (50, 50)]
+    for i in range(51, 100):
+        assert not heap.insert(i, i + 1, True)
+    for i in range(51, 70):
+        assert heap.pop() == (i, i + 1)
+    for i in range(100):
+        assert heap.insert(i, i)
+    for i in range(100):
+        assert heap.pop() == (i, i)
+    pytest.raises(nx.NetworkXError, heap.pop)
+
+
+def test_PairingHeap():
+    _test_heap_class(PairingHeap)
+
+
+def test_BinaryHeap():
+    _test_heap_class(BinaryHeap)
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_mapped_queue.py b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_mapped_queue.py
new file mode 100644
index 0000000..d4df634
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_mapped_queue.py
@@ -0,0 +1,233 @@
+import pytest
+
+from networkx.utils.mapped_queue import MappedQueue, _HeapElement
+
+
+def test_HeapElement_gtlt():
+    bar = _HeapElement(1.1, "a")
+    foo = _HeapElement(1, "b")
+    assert foo < bar
+    assert bar > foo
+    assert foo < 1.1
+    assert 1 < bar
+
+
+def test_HeapElement_eq():
+    bar = _HeapElement(1.1, "a")
+    foo = _HeapElement(1, "a")
+    assert foo == bar
+    assert bar == foo
+    assert foo == "a"
+
+
+def test_HeapElement_iter():
+    foo = _HeapElement(1, "a")
+    bar = _HeapElement(1.1, (3, 2, 1))
+    assert list(foo) == [1, "a"]
+    assert list(bar) == [1.1, 3, 2, 1]
+
+
+def test_HeapElement_getitem():
+    foo = _HeapElement(1, "a")
+    bar = _HeapElement(1.1, (3, 2, 1))
+    assert foo[1] == "a"
+    assert foo[0] == 1
+    assert bar[0] == 1.1
+    assert bar[2] == 2
+    assert bar[3] == 1
+    pytest.raises(IndexError, bar.__getitem__, 4)
+    pytest.raises(IndexError, foo.__getitem__, 2)
+
+
+class TestMappedQueue:
+    def setup(self):
+        pass
+
+    def _check_map(self, q):
+        assert q.position == {elt: pos for pos, elt in enumerate(q.heap)}
+
+    def _make_mapped_queue(self, h):
+        q = MappedQueue()
+        q.heap = h
+        q.position = {elt: pos for pos, elt in enumerate(h)}
+        return q
+
+    def test_heapify(self):
+        h = [5, 4, 3, 2, 1, 0]
+        q = self._make_mapped_queue(h)
+        q._heapify()
+        self._check_map(q)
+
+    def test_init(self):
+        h = [5, 4, 3, 2, 1, 0]
+        q = MappedQueue(h)
+        self._check_map(q)
+
+    def test_len(self):
+        h = [5, 4, 3, 2, 1, 0]
+        q = MappedQueue(h)
+        self._check_map(q)
+        assert len(q) == 6
+
+    def test_siftup_leaf(self):
+        h = [2]
+        h_sifted = [2]
+        q = self._make_mapped_queue(h)
+        q._siftup(0)
+        assert q.heap == h_sifted
+        self._check_map(q)
+
+    def test_siftup_one_child(self):
+        h = [2, 0]
+        h_sifted = [0, 2]
+        q = self._make_mapped_queue(h)
+        q._siftup(0)
+        assert q.heap == h_sifted
+        self._check_map(q)
+
+    def test_siftup_left_child(self):
+        h = [2, 0, 1]
+        h_sifted = [0, 2, 1]
+        q = self._make_mapped_queue(h)
+        q._siftup(0)
+        assert q.heap == h_sifted
+        self._check_map(q)
+
+    def test_siftup_right_child(self):
+        h = [2, 1, 0]
+        h_sifted = [0, 1, 2]
+        q = self._make_mapped_queue(h)
+        q._siftup(0)
+        assert q.heap == h_sifted
+        self._check_map(q)
+
+    def test_siftup_multiple(self):
+        h = [0, 1, 2, 4, 3, 5, 6]
+        h_sifted = [0, 1, 2, 4, 3, 5, 6]
+        q = self._make_mapped_queue(h)
+        q._siftup(0)
+        assert q.heap == h_sifted
+        self._check_map(q)
+
+    def test_siftdown_leaf(self):
+        h = [2]
+        h_sifted = [2]
+        q = self._make_mapped_queue(h)
+        q._siftdown(0, 0)
+        assert q.heap == h_sifted
+        self._check_map(q)
+
+    def test_siftdown_single(self):
+        h = [1, 0]
+        h_sifted = [0, 1]
+        q = self._make_mapped_queue(h)
+        q._siftdown(0, len(h) - 1)
+        assert q.heap == h_sifted
+        self._check_map(q)
+
+    def test_siftdown_multiple(self):
+        h = [1, 2, 3, 4, 5, 6, 7, 0]
+        h_sifted = [0, 1, 3, 2, 5, 6, 7, 4]
+        q = self._make_mapped_queue(h)
+        q._siftdown(0, len(h) - 1)
+        assert q.heap == h_sifted
+        self._check_map(q)
+
+    def test_push(self):
+        to_push = [6, 1, 4, 3, 2, 5, 0]
+        h_sifted = [0, 2, 1, 6, 3, 5, 4]
+        q = MappedQueue()
+        for elt in to_push:
+            q.push(elt)
+        assert q.heap == h_sifted
+        self._check_map(q)
+
+    def test_push_duplicate(self):
+        to_push = [2, 1, 0]
+        h_sifted = [0, 2, 1]
+        q = MappedQueue()
+        for elt in to_push:
+            inserted = q.push(elt)
+            assert inserted
+        assert q.heap == h_sifted
+        self._check_map(q)
+        inserted = q.push(1)
+        assert not inserted
+
+    def test_pop(self):
+        h = [3, 4, 6, 0, 1, 2, 5]
+        h_sorted = sorted(h)
+        q = self._make_mapped_queue(h)
+        q._heapify()
+        popped = [q.pop() for _ in range(len(h))]
+        assert popped == h_sorted
+        self._check_map(q)
+
+    def test_remove_leaf(self):
+        h = [0, 2, 1, 6, 3, 5, 4]
+        h_removed = [0, 2, 1, 6, 4, 5]
+        q = self._make_mapped_queue(h)
+        removed = q.remove(3)
+        assert q.heap == h_removed
+
+    def test_remove_root(self):
+        h = [0, 2, 1, 6, 3, 5, 4]
+        h_removed = [1, 2, 4, 6, 3, 5]
+        q = self._make_mapped_queue(h)
+        removed = q.remove(0)
+        assert q.heap == h_removed
+
+    def test_update_leaf(self):
+        h = [0, 20, 10, 60, 30, 50, 40]
+        h_updated = [0, 15, 10, 60, 20, 50, 40]
+        q = self._make_mapped_queue(h)
+        removed = q.update(30, 15)
+        assert q.heap == h_updated
+
+    def test_update_root(self):
+        h = [0, 20, 10, 60, 30, 50, 40]
+        h_updated = [10, 20, 35, 60, 30, 50, 40]
+        q = self._make_mapped_queue(h)
+        removed = q.update(0, 35)
+        assert q.heap == h_updated
+
+
+class TestMappedDict(TestMappedQueue):
+    def _make_mapped_queue(self, h):
+        priority_dict = {elt: elt for elt in h}
+        return MappedQueue(priority_dict)
+
+    def test_push(self):
+        to_push = [6, 1, 4, 3, 2, 5, 0]
+        h_sifted = [0, 2, 1, 6, 3, 5, 4]
+        q = MappedQueue()
+        for elt in to_push:
+            q.push(elt, priority=elt)
+        assert q.heap == h_sifted
+        self._check_map(q)
+
+    def test_push_duplicate(self):
+        to_push = [2, 1, 0]
+        h_sifted = [0, 2, 1]
+        q = MappedQueue()
+        for elt in to_push:
+            inserted = q.push(elt, priority=elt)
+            assert inserted
+        assert q.heap == h_sifted
+        self._check_map(q)
+        inserted = q.push(1, priority=1)
+        assert not inserted
+
+    def test_update_leaf(self):
+        h = [0, 20, 10, 60, 30, 50, 40]
+        h_updated = [0, 15, 10, 60, 20, 50, 40]
+        q = self._make_mapped_queue(h)
+        removed = q.update(30, 15, priority=15)
+        assert q.heap == h_updated
+
+    def test_update_root(self):
+        h = [0, 20, 10, 60, 30, 50, 40]
+        h_updated = [10, 20, 35, 60, 30, 50, 40]
+        q = self._make_mapped_queue(h)
+        removed = q.update(0, 35, priority=35)
+        assert q.heap == h_updated
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_misc.py b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_misc.py
new file mode 100644
index 0000000..b886852
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_misc.py
@@ -0,0 +1,322 @@
+import random
+from copy import copy
+
+import pytest
+
+import networkx as nx
+from networkx.utils import (
+    PythonRandomInterface,
+    arbitrary_element,
+    create_py_random_state,
+    create_random_state,
+    dict_to_numpy_array,
+    discrete_sequence,
+    flatten,
+    groups,
+    is_string_like,
+    iterable,
+    make_list_of_ints,
+    make_str,
+    pairwise,
+    powerlaw_sequence,
+    to_tuple,
+)
+from networkx.utils.misc import _dict_to_numpy_array1, _dict_to_numpy_array2
+
+nested_depth = (
+    1,
+    2,
+    (3, 4, ((5, 6, (7,), (8, (9, 10), 11), (12, 13, (14, 15)), 16), 17), 18, 19),
+    20,
+)
+
+nested_set = {
+    (1, 2, 3, 4),
+    (5, 6, 7, 8, 9),
+    (10, 11, (12, 13, 14), (15, 16, 17, 18)),
+    19,
+    20,
+}
+
+nested_mixed = [
+    1,
+    (2, 3, {4, (5, 6), 7}, [8, 9]),
+    {10: "foo", 11: "bar", (12, 13): "baz"},
+    {(14, 15): "qwe", 16: "asd"},
+    (17, (18, "19"), 20),
+]
+
+
+@pytest.mark.parametrize("result", [None, [], ["existing"], ["existing1", "existing2"]])
+@pytest.mark.parametrize("nested", [nested_depth, nested_mixed, nested_set])
+def test_flatten(nested, result):
+    if result is None:
+        val = flatten(nested, result)
+        assert len(val) == 20
+    else:
+        _result = copy(result)  # because pytest passes parameters as is
+        nexisting = len(_result)
+        val = flatten(nested, _result)
+        assert len(val) == len(_result) == 20 + nexisting
+
+    assert issubclass(type(val), tuple)
+
+
+def test_is_string_like():
+    assert is_string_like("aaaa")
+    assert not is_string_like(None)
+    assert not is_string_like(123)
+
+
+def test_iterable():
+    assert not iterable(None)
+    assert not iterable(10)
+    assert iterable([1, 2, 3])
+    assert iterable((1, 2, 3))
+    assert iterable({1: "A", 2: "X"})
+    assert iterable("ABC")
+
+
+def test_graph_iterable():
+    K = nx.complete_graph(10)
+    assert iterable(K)
+    assert iterable(K.nodes())
+    assert iterable(K.edges())
+
+
+def test_make_list_of_ints():
+    mylist = [1, 2, 3.0, 42, -2]
+    assert make_list_of_ints(mylist) is mylist
+    assert make_list_of_ints(mylist) == mylist
+    assert type(make_list_of_ints(mylist)[2]) is int
+    pytest.raises(nx.NetworkXError, make_list_of_ints, [1, 2, 3, "kermit"])
+    pytest.raises(nx.NetworkXError, make_list_of_ints, [1, 2, 3.1])
+
+
+def test_random_number_distribution():
+    # smoke test only
+    z = powerlaw_sequence(20, exponent=2.5)
+    z = discrete_sequence(20, distribution=[0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3])
+
+
+def test_make_str_with_bytes():
+    x = "qualité"
+    y = make_str(x)
+    assert isinstance(y, str)
+    assert len(y) == 7
+
+
+def test_make_str_with_unicode():
+    x = "qualité"
+    y = make_str(x)
+    assert isinstance(y, str)
+    assert len(y) == 7
+
+
+class TestNumpyArray:
+    @classmethod
+    def setup_class(cls):
+        global np
+        np = pytest.importorskip("numpy")
+
+    def test_numpy_to_list_of_ints(self):
+        a = np.array([1, 2, 3], dtype=np.int64)
+        b = np.array([1.0, 2, 3])
+        c = np.array([1.1, 2, 3])
+        assert type(make_list_of_ints(a)) == list
+        assert make_list_of_ints(b) == list(b)
+        B = make_list_of_ints(b)
+        assert type(B[0]) == int
+        pytest.raises(nx.NetworkXError, make_list_of_ints, c)
+
+    def test__dict_to_numpy_array1(self):
+        d = {"a": 1, "b": 2}
+        a = _dict_to_numpy_array1(d, mapping={"a": 0, "b": 1})
+        np.testing.assert_allclose(a, np.array([1, 2]))
+        a = _dict_to_numpy_array1(d, mapping={"b": 0, "a": 1})
+        np.testing.assert_allclose(a, np.array([2, 1]))
+
+        a = _dict_to_numpy_array1(d)
+        np.testing.assert_allclose(a.sum(), 3)
+
+    def test__dict_to_numpy_array2(self):
+        d = {"a": {"a": 1, "b": 2}, "b": {"a": 10, "b": 20}}
+
+        mapping = {"a": 1, "b": 0}
+        a = _dict_to_numpy_array2(d, mapping=mapping)
+        np.testing.assert_allclose(a, np.array([[20, 10], [2, 1]]))
+
+        a = _dict_to_numpy_array2(d)
+        np.testing.assert_allclose(a.sum(), 33)
+
+    def test_dict_to_numpy_array_a(self):
+        d = {"a": {"a": 1, "b": 2}, "b": {"a": 10, "b": 20}}
+
+        mapping = {"a": 0, "b": 1}
+        a = dict_to_numpy_array(d, mapping=mapping)
+        np.testing.assert_allclose(a, np.array([[1, 2], [10, 20]]))
+
+        mapping = {"a": 1, "b": 0}
+        a = dict_to_numpy_array(d, mapping=mapping)
+        np.testing.assert_allclose(a, np.array([[20, 10], [2, 1]]))
+
+        a = _dict_to_numpy_array2(d)
+        np.testing.assert_allclose(a.sum(), 33)
+
+    def test_dict_to_numpy_array_b(self):
+        d = {"a": 1, "b": 2}
+
+        mapping = {"a": 0, "b": 1}
+        a = dict_to_numpy_array(d, mapping=mapping)
+        np.testing.assert_allclose(a, np.array([1, 2]))
+
+        a = _dict_to_numpy_array1(d)
+        np.testing.assert_allclose(a.sum(), 3)
+
+
+def test_pairwise():
+    nodes = range(4)
+    node_pairs = [(0, 1), (1, 2), (2, 3)]
+    node_pairs_cycle = node_pairs + [(3, 0)]
+    assert list(pairwise(nodes)) == node_pairs
+    assert list(pairwise(iter(nodes))) == node_pairs
+    assert list(pairwise(nodes, cyclic=True)) == node_pairs_cycle
+    empty_iter = iter(())
+    assert list(pairwise(empty_iter)) == []
+    empty_iter = iter(())
+    assert list(pairwise(empty_iter, cyclic=True)) == []
+
+
+def test_groups():
+    many_to_one = dict(zip("abcde", [0, 0, 1, 1, 2]))
+    actual = groups(many_to_one)
+    expected = {0: {"a", "b"}, 1: {"c", "d"}, 2: {"e"}}
+    assert actual == expected
+    assert {} == groups({})
+
+
+def test_to_tuple():
+    a_list = [1, 2, [1, 3]]
+    actual = to_tuple(a_list)
+    expected = (1, 2, (1, 3))
+    assert actual == expected
+
+    a_tuple = (1, 2)
+    actual = to_tuple(a_tuple)
+    expected = a_tuple
+    assert actual == expected
+
+    a_mix = (1, 2, [1, 3])
+    actual = to_tuple(a_mix)
+    expected = (1, 2, (1, 3))
+    assert actual == expected
+
+
+def test_create_random_state():
+    np = pytest.importorskip("numpy")
+    rs = np.random.RandomState
+
+    assert isinstance(create_random_state(1), rs)
+    assert isinstance(create_random_state(None), rs)
+    assert isinstance(create_random_state(np.random), rs)
+    assert isinstance(create_random_state(rs(1)), rs)
+    # Support for numpy.random.Generator
+    rng = np.random.default_rng()
+    assert isinstance(create_random_state(rng), np.random.Generator)
+    pytest.raises(ValueError, create_random_state, "a")
+
+    assert np.all(rs(1).rand(10) == create_random_state(1).rand(10))
+
+
+def test_create_py_random_state():
+    pyrs = random.Random
+
+    assert isinstance(create_py_random_state(1), pyrs)
+    assert isinstance(create_py_random_state(None), pyrs)
+    assert isinstance(create_py_random_state(pyrs(1)), pyrs)
+    pytest.raises(ValueError, create_py_random_state, "a")
+
+    np = pytest.importorskip("numpy")
+
+    rs = np.random.RandomState
+    rng = np.random.default_rng(1000)
+    rng_explicit = np.random.Generator(np.random.SFC64())
+    nprs = PythonRandomInterface
+    assert isinstance(create_py_random_state(np.random), nprs)
+    assert isinstance(create_py_random_state(rs(1)), nprs)
+    assert isinstance(create_py_random_state(rng), nprs)
+    assert isinstance(create_py_random_state(rng_explicit), nprs)
+    # test default rng input
+    assert isinstance(PythonRandomInterface(), nprs)
+
+
+def test_PythonRandomInterface_RandomState():
+    np = pytest.importorskip("numpy")
+
+    rs = np.random.RandomState
+    rng = PythonRandomInterface(rs(42))
+    rs42 = rs(42)
+
+    # make sure these functions are same as expected outcome
+    assert rng.randrange(3, 5) == rs42.randint(3, 5)
+    assert rng.choice([1, 2, 3]) == rs42.choice([1, 2, 3])
+    assert rng.gauss(0, 1) == rs42.normal(0, 1)
+    assert rng.expovariate(1.5) == rs42.exponential(1 / 1.5)
+    assert np.all(rng.shuffle([1, 2, 3]) == rs42.shuffle([1, 2, 3]))
+    assert np.all(
+        rng.sample([1, 2, 3], 2) == rs42.choice([1, 2, 3], (2,), replace=False)
+    )
+    assert np.all(
+        [rng.randint(3, 5) for _ in range(100)]
+        == [rs42.randint(3, 6) for _ in range(100)]
+    )
+    assert rng.random() == rs42.random_sample()
+
+
+def test_PythonRandomInterface_Generator():
+    np = pytest.importorskip("numpy")
+
+    rng = np.random.default_rng(42)
+    pri = PythonRandomInterface(np.random.default_rng(42))
+
+    # make sure these functions are same as expected outcome
+    assert pri.randrange(3, 5) == rng.integers(3, 5)
+    assert pri.choice([1, 2, 3]) == rng.choice([1, 2, 3])
+    assert pri.gauss(0, 1) == rng.normal(0, 1)
+    assert pri.expovariate(1.5) == rng.exponential(1 / 1.5)
+    assert np.all(pri.shuffle([1, 2, 3]) == rng.shuffle([1, 2, 3]))
+    assert np.all(
+        pri.sample([1, 2, 3], 2) == rng.choice([1, 2, 3], (2,), replace=False)
+    )
+    assert np.all(
+        [pri.randint(3, 5) for _ in range(100)]
+        == [rng.integers(3, 6) for _ in range(100)]
+    )
+    assert pri.random() == rng.random()
+
+
+@pytest.mark.parametrize(
+    ("iterable_type", "expected"), ((list, 1), (tuple, 1), (str, "["), (set, 1))
+)
+def test_arbitrary_element(iterable_type, expected):
+    iterable = iterable_type([1, 2, 3])
+    assert arbitrary_element(iterable) == expected
+
+
+@pytest.mark.parametrize(
+    "iterator", ((i for i in range(3)), iter([1, 2, 3]))  # generator
+)
+def test_arbitrary_element_raises(iterator):
+    """Value error is raised when input is an iterator."""
+    with pytest.raises(ValueError, match="from an iterator"):
+        arbitrary_element(iterator)
+
+
+def test_dict_to_numpy_array_deprecations():
+    np = pytest.importorskip("numpy")
+    d = {"a": 1}
+    with pytest.deprecated_call():
+        nx.utils.dict_to_numpy_array1(d)
+    d2 = {"a": {"b": 2}}
+    with pytest.deprecated_call():
+        nx.utils.dict_to_numpy_array2(d2)
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_random_sequence.py b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_random_sequence.py
new file mode 100644
index 0000000..1d1b957
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_random_sequence.py
@@ -0,0 +1,38 @@
+import pytest
+
+from networkx.utils import (
+    powerlaw_sequence,
+    random_weighted_sample,
+    weighted_choice,
+    zipf_rv,
+)
+
+
+def test_degree_sequences():
+    seq = powerlaw_sequence(10, seed=1)
+    seq = powerlaw_sequence(10)
+    assert len(seq) == 10
+
+
+def test_zipf_rv():
+    r = zipf_rv(2.3, xmin=2, seed=1)
+    r = zipf_rv(2.3, 2, 1)
+    r = zipf_rv(2.3)
+    assert type(r), int
+    pytest.raises(ValueError, zipf_rv, 0.5)
+    pytest.raises(ValueError, zipf_rv, 2, xmin=0)
+
+
+def test_random_weighted_sample():
+    mapping = {"a": 10, "b": 20}
+    s = random_weighted_sample(mapping, 2, seed=1)
+    s = random_weighted_sample(mapping, 2)
+    assert sorted(s) == sorted(mapping.keys())
+    pytest.raises(ValueError, random_weighted_sample, mapping, 3)
+
+
+def test_random_weighted_choice():
+    mapping = {"a": 10, "b": 0}
+    c = weighted_choice(mapping, seed=1)
+    c = weighted_choice(mapping)
+    assert c == "a"
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_rcm.py b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_rcm.py
new file mode 100644
index 0000000..88702b3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_rcm.py
@@ -0,0 +1,63 @@
+import networkx as nx
+from networkx.utils import reverse_cuthill_mckee_ordering
+
+
+def test_reverse_cuthill_mckee():
+    # example graph from
+    # http://www.boost.org/doc/libs/1_37_0/libs/graph/example/cuthill_mckee_ordering.cpp
+    G = nx.Graph(
+        [
+            (0, 3),
+            (0, 5),
+            (1, 2),
+            (1, 4),
+            (1, 6),
+            (1, 9),
+            (2, 3),
+            (2, 4),
+            (3, 5),
+            (3, 8),
+            (4, 6),
+            (5, 6),
+            (5, 7),
+            (6, 7),
+        ]
+    )
+    rcm = list(reverse_cuthill_mckee_ordering(G))
+    assert rcm in [[0, 8, 5, 7, 3, 6, 2, 4, 1, 9], [0, 8, 5, 7, 3, 6, 4, 2, 1, 9]]
+
+
+def test_rcm_alternate_heuristic():
+    # example from
+    G = nx.Graph(
+        [
+            (0, 0),
+            (0, 4),
+            (1, 1),
+            (1, 2),
+            (1, 5),
+            (1, 7),
+            (2, 2),
+            (2, 4),
+            (3, 3),
+            (3, 6),
+            (4, 4),
+            (5, 5),
+            (5, 7),
+            (6, 6),
+            (7, 7),
+        ]
+    )
+
+    answers = [
+        [6, 3, 5, 7, 1, 2, 4, 0],
+        [6, 3, 7, 5, 1, 2, 4, 0],
+        [7, 5, 1, 2, 4, 0, 6, 3],
+    ]
+
+    def smallest_degree(G):
+        deg, node = min((d, n) for n, d in G.degree())
+        return node
+
+    rcm = list(reverse_cuthill_mckee_ordering(G, heuristic=smallest_degree))
+    assert rcm in answers
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_unionfind.py b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_unionfind.py
new file mode 100644
index 0000000..2d30580
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/tests/test_unionfind.py
@@ -0,0 +1,55 @@
+import networkx as nx
+
+
+def test_unionfind():
+    # Fixed by: 2cddd5958689bdecdcd89b91ac9aaf6ce0e4f6b8
+    # Previously (in 2.x), the UnionFind class could handle mixed types.
+    # But in Python 3.x, this causes a TypeError such as:
+    #   TypeError: unorderable types: str() > int()
+    #
+    # Now we just make sure that no exception is raised.
+    x = nx.utils.UnionFind()
+    x.union(0, "a")
+
+
+def test_subtree_union():
+    # See https://github.com/networkx/networkx/pull/3224
+    # (35db1b551ee65780794a357794f521d8768d5049).
+    # Test if subtree unions hare handled correctly by to_sets().
+    uf = nx.utils.UnionFind()
+    uf.union(1, 2)
+    uf.union(3, 4)
+    uf.union(4, 5)
+    uf.union(1, 5)
+    assert list(uf.to_sets()) == [{1, 2, 3, 4, 5}]
+
+
+def test_unionfind_weights():
+    # Tests if weights are computed correctly with unions of many elements
+    uf = nx.utils.UnionFind()
+    uf.union(1, 4, 7)
+    uf.union(2, 5, 8)
+    uf.union(3, 6, 9)
+    uf.union(1, 2, 3, 4, 5, 6, 7, 8, 9)
+    assert uf.weights[uf[1]] == 9
+
+
+def test_unbalanced_merge_weights():
+    # Tests if the largest set's root is used as the new root when merging
+    uf = nx.utils.UnionFind()
+    uf.union(1, 2, 3)
+    uf.union(4, 5, 6, 7, 8, 9)
+    assert uf.weights[uf[1]] == 3
+    assert uf.weights[uf[4]] == 6
+    largest_root = uf[4]
+    uf.union(1, 4)
+    assert uf[1] == largest_root
+    assert uf.weights[largest_root] == 9
+
+
+def test_empty_union():
+    # Tests if a null-union does nothing.
+    uf = nx.utils.UnionFind((0, 1))
+    uf.union()
+    assert uf[0] == 0
+    assert uf[1] == 1
diff --git a/myenv/lib/python3.9/site-packages/networkx/utils/union_find.py b/myenv/lib/python3.9/site-packages/networkx/utils/union_find.py
new file mode 100644
index 0000000..27596c9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/networkx/utils/union_find.py
@@ -0,0 +1,105 @@
+"""
+Union-find data structure.
+"""
+
+from networkx.utils import groups
+
+
+class UnionFind:
+    """Union-find data structure.
+
+    Each unionFind instance X maintains a family of disjoint sets of
+    hashable objects, supporting the following two methods:
+
+    - X[item] returns a name for the set containing the given item.
+      Each set is named by an arbitrarily-chosen one of its members; as
+      long as the set remains unchanged it will keep the same name. If
+      the item is not yet part of a set in X, a new singleton set is
+      created for it.
+
+    - X.union(item1, item2, ...) merges the sets containing each item
+      into a single larger set.  If any item is not yet part of a set
+      in X, it is added to X as one of the members of the merged set.
+
+      Union-find data structure. Based on Josiah Carlson's code,
+      https://code.activestate.com/recipes/215912/
+      with significant additional changes by D. Eppstein.
+      http://www.ics.uci.edu/~eppstein/PADS/UnionFind.py
+
+    """
+
+    def __init__(self, elements=None):
+        """Create a new empty union-find structure.
+
+        If *elements* is an iterable, this structure will be initialized
+        with the discrete partition on the given set of elements.
+
+        """
+        if elements is None:
+            elements = ()
+        self.parents = {}
+        self.weights = {}
+        for x in elements:
+            self.weights[x] = 1
+            self.parents[x] = x
+
+    def __getitem__(self, object):
+        """Find and return the name of the set containing the object."""
+
+        # check for previously unknown object
+        if object not in self.parents:
+            self.parents[object] = object
+            self.weights[object] = 1
+            return object
+
+        # find path of objects leading to the root
+        path = [object]
+        root = self.parents[object]
+        while root != path[-1]:
+            path.append(root)
+            root = self.parents[root]
+
+        # compress the path and return
+        for ancestor in path:
+            self.parents[ancestor] = root
+        return root
+
+    def __iter__(self):
+        """Iterate through all items ever found or unioned by this structure."""
+        return iter(self.parents)
+
+    def to_sets(self):
+        """Iterates over the sets stored in this structure.
+
+        For example::
+
+            >>> partition = UnionFind("xyz")
+            >>> sorted(map(sorted, partition.to_sets()))
+            [['x'], ['y'], ['z']]
+            >>> partition.union("x", "y")
+            >>> sorted(map(sorted, partition.to_sets()))
+            [['x', 'y'], ['z']]
+
+        """
+        # Ensure fully pruned paths
+        for x in self.parents.keys():
+            _ = self[x]  # Evaluated for side-effect only
+
+        yield from groups(self.parents).values()
+
+    def union(self, *objects):
+        """Find the sets containing the objects and merge them all."""
+        # Find the heaviest root according to its weight.
+        roots = iter(
+            sorted(
+                {self[x] for x in objects}, key=lambda r: self.weights[r], reverse=True
+            )
+        )
+        try:
+            root = next(roots)
+        except StopIteration:
+            return
+
+        for r in roots:
+            self.weights[root] += self.weights[r]
+            self.parents[r] = root
diff --git a/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/LICENSE
new file mode 100644
index 0000000..6f62d44
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/LICENSE
@@ -0,0 +1,3 @@
+This software is made available under the terms of *either* of the licenses
+found in LICENSE.APACHE or LICENSE.BSD. Contributions to this software is made
+under the terms of *both* these licenses.
diff --git a/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/LICENSE.APACHE b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/LICENSE.APACHE
new file mode 100644
index 0000000..f433b1a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/LICENSE.APACHE
@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
diff --git a/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/LICENSE.BSD b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/LICENSE.BSD
new file mode 100644
index 0000000..42ce7b7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/LICENSE.BSD
@@ -0,0 +1,23 @@
+Copyright (c) Donald Stufft and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/METADATA b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/METADATA
new file mode 100644
index 0000000..358ace5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/METADATA
@@ -0,0 +1,453 @@
+Metadata-Version: 2.1
+Name: packaging
+Version: 21.3
+Summary: Core utilities for Python packages
+Home-page: https://github.com/pypa/packaging
+Author: Donald Stufft and individual contributors
+Author-email: donald@stufft.io
+License: BSD-2-Clause or Apache-2.0
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.6
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: LICENSE.APACHE
+License-File: LICENSE.BSD
+Requires-Dist: pyparsing (!=3.0.5,>=2.0.2)
+
+packaging
+=========
+
+.. start-intro
+
+Reusable core utilities for various Python Packaging
+`interoperability specifications <https://packaging.python.org/specifications/>`_.
+
+This library provides utilities that implement the interoperability
+specifications which have clearly one correct behaviour (eg: :pep:`440`)
+or benefit greatly from having a single shared implementation (eg: :pep:`425`).
+
+.. end-intro
+
+The ``packaging`` project includes the following: version handling, specifiers,
+markers, requirements, tags, utilities.
+
+Documentation
+-------------
+
+The `documentation`_ provides information and the API for the following:
+
+- Version Handling
+- Specifiers
+- Markers
+- Requirements
+- Tags
+- Utilities
+
+Installation
+------------
+
+Use ``pip`` to install these utilities::
+
+    pip install packaging
+
+Discussion
+----------
+
+If you run into bugs, you can file them in our `issue tracker`_.
+
+You can also join ``#pypa`` on Freenode to ask questions or get involved.
+
+
+.. _`documentation`: https://packaging.pypa.io/
+.. _`issue tracker`: https://github.com/pypa/packaging/issues
+
+
+Code of Conduct
+---------------
+
+Everyone interacting in the packaging project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.
+
+.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md
+
+Contributing
+------------
+
+The ``CONTRIBUTING.rst`` file outlines how to contribute to this project as
+well as how to report a potential security issue. The documentation for this
+project also covers information about `project development`_ and `security`_.
+
+.. _`project development`: https://packaging.pypa.io/en/latest/development/
+.. _`security`: https://packaging.pypa.io/en/latest/security/
+
+Project History
+---------------
+
+Please review the ``CHANGELOG.rst`` file or the `Changelog documentation`_ for
+recent changes and project history.
+
+.. _`Changelog documentation`: https://packaging.pypa.io/en/latest/changelog/
+
+Changelog
+---------
+
+21.3 - 2021-11-17
+~~~~~~~~~~~~~~~~~
+
+* Add a ``pp3-none-any`` tag (`#311 <https://github.com/pypa/packaging/issues/311>`__)
+* Replace the blank pyparsing 3 exclusion with a 3.0.5 exclusion (`#481 <https://github.com/pypa/packaging/issues/481>`__, `#486 <https://github.com/pypa/packaging/issues/486>`__)
+* Fix a spelling mistake (`#479 <https://github.com/pypa/packaging/issues/479>`__)
+
+21.2 - 2021-10-29
+~~~~~~~~~~~~~~~~~
+
+* Update documentation entry for 21.1.
+
+21.1 - 2021-10-29
+~~~~~~~~~~~~~~~~~
+
+* Update pin to pyparsing to exclude 3.0.0.
+
+21.0 - 2021-07-03
+~~~~~~~~~~~~~~~~~
+
+* PEP 656: musllinux support (`#411 <https://github.com/pypa/packaging/issues/411>`__)
+* Drop support for Python 2.7, Python 3.4 and Python 3.5.
+* Replace distutils usage with sysconfig (`#396 <https://github.com/pypa/packaging/issues/396>`__)
+* Add support for zip files in ``parse_sdist_filename`` (`#429 <https://github.com/pypa/packaging/issues/429>`__)
+* Use cached ``_hash`` attribute to short-circuit tag equality comparisons (`#417 <https://github.com/pypa/packaging/issues/417>`__)
+* Specify the default value for the ``specifier`` argument to ``SpecifierSet`` (`#437 <https://github.com/pypa/packaging/issues/437>`__)
+* Proper keyword-only "warn" argument in packaging.tags (`#403 <https://github.com/pypa/packaging/issues/403>`__)
+* Correctly remove prerelease suffixes from ~= check (`#366 <https://github.com/pypa/packaging/issues/366>`__)
+* Fix type hints for ``Version.post`` and ``Version.dev`` (`#393 <https://github.com/pypa/packaging/issues/393>`__)
+* Use typing alias ``UnparsedVersion`` (`#398 <https://github.com/pypa/packaging/issues/398>`__)
+* Improve type inference for ``packaging.specifiers.filter()`` (`#430 <https://github.com/pypa/packaging/issues/430>`__)
+* Tighten the return type of ``canonicalize_version()`` (`#402 <https://github.com/pypa/packaging/issues/402>`__)
+
+20.9 - 2021-01-29
+~~~~~~~~~~~~~~~~~
+
+* Run `isort <https://pypi.org/project/isort/>`_ over the code base (`#377 <https://github.com/pypa/packaging/issues/377>`__)
+* Add support for the ``macosx_10_*_universal2`` platform tags (`#379 <https://github.com/pypa/packaging/issues/379>`__)
+* Introduce ``packaging.utils.parse_wheel_filename()`` and ``parse_sdist_filename()``
+  (`#387 <https://github.com/pypa/packaging/issues/387>`__ and `#389 <https://github.com/pypa/packaging/issues/389>`__)
+
+20.8 - 2020-12-11
+~~~~~~~~~~~~~~~~~
+
+* Revert back to setuptools for compatibility purposes for some Linux distros (`#363 <https://github.com/pypa/packaging/issues/363>`__)
+* Do not insert an underscore in wheel tags when the interpreter version number
+  is more than 2 digits (`#372 <https://github.com/pypa/packaging/issues/372>`__)
+
+20.7 - 2020-11-28
+~~~~~~~~~~~~~~~~~
+
+No unreleased changes.
+
+20.6 - 2020-11-28
+~~~~~~~~~~~~~~~~~
+
+.. note:: This release was subsequently yanked, and these changes were included in 20.7.
+
+* Fix flit configuration, to include LICENSE files (`#357 <https://github.com/pypa/packaging/issues/357>`__)
+* Make `intel` a recognized CPU architecture for the `universal` macOS platform tag (`#361 <https://github.com/pypa/packaging/issues/361>`__)
+* Add some missing type hints to `packaging.requirements` (issue:`350`)
+
+20.5 - 2020-11-27
+~~~~~~~~~~~~~~~~~
+
+* Officially support Python 3.9 (`#343 <https://github.com/pypa/packaging/issues/343>`__)
+* Deprecate the ``LegacyVersion`` and ``LegacySpecifier`` classes (`#321 <https://github.com/pypa/packaging/issues/321>`__)
+* Handle ``OSError`` on non-dynamic executables when attempting to resolve
+  the glibc version string.
+
+20.4 - 2020-05-19
+~~~~~~~~~~~~~~~~~
+
+* Canonicalize version before comparing specifiers. (`#282 <https://github.com/pypa/packaging/issues/282>`__)
+* Change type hint for ``canonicalize_name`` to return
+  ``packaging.utils.NormalizedName``.
+  This enables the use of static typing tools (like mypy) to detect mixing of
+  normalized and un-normalized names.
+
+20.3 - 2020-03-05
+~~~~~~~~~~~~~~~~~
+
+* Fix changelog for 20.2.
+
+20.2 - 2020-03-05
+~~~~~~~~~~~~~~~~~
+
+* Fix a bug that caused a 32-bit OS that runs on a 64-bit ARM CPU (e.g. ARM-v8,
+  aarch64), to report the wrong bitness.
+
+20.1 - 2020-01-24
+~~~~~~~~~~~~~~~~~~~
+
+* Fix a bug caused by reuse of an exhausted iterator. (`#257 <https://github.com/pypa/packaging/issues/257>`__)
+
+20.0 - 2020-01-06
+~~~~~~~~~~~~~~~~~
+
+* Add type hints (`#191 <https://github.com/pypa/packaging/issues/191>`__)
+
+* Add proper trove classifiers for PyPy support (`#198 <https://github.com/pypa/packaging/issues/198>`__)
+
+* Scale back depending on ``ctypes`` for manylinux support detection (`#171 <https://github.com/pypa/packaging/issues/171>`__)
+
+* Use ``sys.implementation.name`` where appropriate for ``packaging.tags`` (`#193 <https://github.com/pypa/packaging/issues/193>`__)
+
+* Expand upon the API provided by ``packaging.tags``: ``interpreter_name()``, ``mac_platforms()``, ``compatible_tags()``, ``cpython_tags()``, ``generic_tags()`` (`#187 <https://github.com/pypa/packaging/issues/187>`__)
+
+* Officially support Python 3.8 (`#232 <https://github.com/pypa/packaging/issues/232>`__)
+
+* Add ``major``, ``minor``, and ``micro`` aliases to ``packaging.version.Version`` (`#226 <https://github.com/pypa/packaging/issues/226>`__)
+
+* Properly mark ``packaging`` has being fully typed by adding a `py.typed` file (`#226 <https://github.com/pypa/packaging/issues/226>`__)
+
+19.2 - 2019-09-18
+~~~~~~~~~~~~~~~~~
+
+* Remove dependency on ``attrs`` (`#178 <https://github.com/pypa/packaging/issues/178>`__, `#179 <https://github.com/pypa/packaging/issues/179>`__)
+
+* Use appropriate fallbacks for CPython ABI tag (`#181 <https://github.com/pypa/packaging/issues/181>`__, `#185 <https://github.com/pypa/packaging/issues/185>`__)
+
+* Add manylinux2014 support (`#186 <https://github.com/pypa/packaging/issues/186>`__)
+
+* Improve ABI detection (`#181 <https://github.com/pypa/packaging/issues/181>`__)
+
+* Properly handle debug wheels for Python 3.8 (`#172 <https://github.com/pypa/packaging/issues/172>`__)
+
+* Improve detection of debug builds on Windows (`#194 <https://github.com/pypa/packaging/issues/194>`__)
+
+19.1 - 2019-07-30
+~~~~~~~~~~~~~~~~~
+
+* Add the ``packaging.tags`` module. (`#156 <https://github.com/pypa/packaging/issues/156>`__)
+
+* Correctly handle two-digit versions in ``python_version`` (`#119 <https://github.com/pypa/packaging/issues/119>`__)
+
+
+19.0 - 2019-01-20
+~~~~~~~~~~~~~~~~~
+
+* Fix string representation of PEP 508 direct URL requirements with markers.
+
+* Better handling of file URLs
+
+  This allows for using ``file:///absolute/path``, which was previously
+  prevented due to the missing ``netloc``.
+
+  This allows for all file URLs that ``urlunparse`` turns back into the
+  original URL to be valid.
+
+
+18.0 - 2018-09-26
+~~~~~~~~~~~~~~~~~
+
+* Improve error messages when invalid requirements are given. (`#129 <https://github.com/pypa/packaging/issues/129>`__)
+
+
+17.1 - 2017-02-28
+~~~~~~~~~~~~~~~~~
+
+* Fix ``utils.canonicalize_version`` when supplying non PEP 440 versions.
+
+
+17.0 - 2017-02-28
+~~~~~~~~~~~~~~~~~
+
+* Drop support for python 2.6, 3.2, and 3.3.
+
+* Define minimal pyparsing version to 2.0.2 (`#91 <https://github.com/pypa/packaging/issues/91>`__).
+
+* Add ``epoch``, ``release``, ``pre``, ``dev``, and ``post`` attributes to
+  ``Version`` and ``LegacyVersion`` (`#34 <https://github.com/pypa/packaging/issues/34>`__).
+
+* Add ``Version().is_devrelease`` and ``LegacyVersion().is_devrelease`` to
+  make it easy to determine if a release is a development release.
+
+* Add ``utils.canonicalize_version`` to canonicalize version strings or
+  ``Version`` instances (`#121 <https://github.com/pypa/packaging/issues/121>`__).
+
+
+16.8 - 2016-10-29
+~~~~~~~~~~~~~~~~~
+
+* Fix markers that utilize ``in`` so that they render correctly.
+
+* Fix an erroneous test on Python RC releases.
+
+
+16.7 - 2016-04-23
+~~~~~~~~~~~~~~~~~
+
+* Add support for the deprecated ``python_implementation`` marker which was
+  an undocumented setuptools marker in addition to the newer markers.
+
+
+16.6 - 2016-03-29
+~~~~~~~~~~~~~~~~~
+
+* Add support for the deprecated, PEP 345 environment markers in addition to
+  the newer markers.
+
+
+16.5 - 2016-02-26
+~~~~~~~~~~~~~~~~~
+
+* Fix a regression in parsing requirements with whitespaces between the comma
+  separators.
+
+
+16.4 - 2016-02-22
+~~~~~~~~~~~~~~~~~
+
+* Fix a regression in parsing requirements like ``foo (==4)``.
+
+
+16.3 - 2016-02-21
+~~~~~~~~~~~~~~~~~
+
+* Fix a bug where ``packaging.requirements:Requirement`` was overly strict when
+  matching legacy requirements.
+
+
+16.2 - 2016-02-09
+~~~~~~~~~~~~~~~~~
+
+* Add a function that implements the name canonicalization from PEP 503.
+
+
+16.1 - 2016-02-07
+~~~~~~~~~~~~~~~~~
+
+* Implement requirement specifiers from PEP 508.
+
+
+16.0 - 2016-01-19
+~~~~~~~~~~~~~~~~~
+
+* Relicense so that packaging is available under *either* the Apache License,
+  Version 2.0 or a 2 Clause BSD license.
+
+* Support installation of packaging when only distutils is available.
+
+* Fix ``==`` comparison when there is a prefix and a local version in play.
+  (`#41 <https://github.com/pypa/packaging/issues/41>`__).
+
+* Implement environment markers from PEP 508.
+
+
+15.3 - 2015-08-01
+~~~~~~~~~~~~~~~~~
+
+* Normalize post-release spellings for rev/r prefixes. `#35 <https://github.com/pypa/packaging/issues/35>`__
+
+
+15.2 - 2015-05-13
+~~~~~~~~~~~~~~~~~
+
+* Fix an error where the arbitrary specifier (``===``) was not correctly
+  allowing pre-releases when it was being used.
+
+* Expose the specifier and version parts through properties on the
+  ``Specifier`` classes.
+
+* Allow iterating over the ``SpecifierSet`` to get access to all of the
+  ``Specifier`` instances.
+
+* Allow testing if a version is contained within a specifier via the ``in``
+  operator.
+
+
+15.1 - 2015-04-13
+~~~~~~~~~~~~~~~~~
+
+* Fix a logic error that was causing inconsistent answers about whether or not
+  a pre-release was contained within a ``SpecifierSet`` or not.
+
+
+15.0 - 2015-01-02
+~~~~~~~~~~~~~~~~~
+
+* Add ``Version().is_postrelease`` and ``LegacyVersion().is_postrelease`` to
+  make it easy to determine if a release is a post release.
+
+* Add ``Version().base_version`` and ``LegacyVersion().base_version`` to make
+  it easy to get the public version without any pre or post release markers.
+
+* Support the update to PEP 440 which removed the implied ``!=V.*`` when using
+  either ``>V`` or ``<V`` and which instead special cased the handling of
+  pre-releases, post-releases, and local versions when using ``>V`` or ``<V``.
+
+
+14.5 - 2014-12-17
+~~~~~~~~~~~~~~~~~
+
+* Normalize release candidates as ``rc`` instead of ``c``.
+
+* Expose the ``VERSION_PATTERN`` constant, a regular expression matching
+  a valid version.
+
+
+14.4 - 2014-12-15
+~~~~~~~~~~~~~~~~~
+
+* Ensure that versions are normalized before comparison when used in a
+  specifier with a less than (``<``) or greater than (``>``) operator.
+
+
+14.3 - 2014-11-19
+~~~~~~~~~~~~~~~~~
+
+* **BACKWARDS INCOMPATIBLE** Refactor specifier support so that it can sanely
+  handle legacy specifiers as well as PEP 440 specifiers.
+
+* **BACKWARDS INCOMPATIBLE** Move the specifier support out of
+  ``packaging.version`` into ``packaging.specifiers``.
+
+
+14.2 - 2014-09-10
+~~~~~~~~~~~~~~~~~
+
+* Add prerelease support to ``Specifier``.
+* Remove the ability to do ``item in Specifier()`` and replace it with
+  ``Specifier().contains(item)`` in order to allow flags that signal if a
+  prerelease should be accepted or not.
+* Add a method ``Specifier().filter()`` which will take an iterable and returns
+  an iterable with items that do not match the specifier filtered out.
+
+
+14.1 - 2014-09-08
+~~~~~~~~~~~~~~~~~
+
+* Allow ``LegacyVersion`` and ``Version`` to be sorted together.
+* Add ``packaging.version.parse()`` to enable easily parsing a version string
+  as either a ``Version`` or a ``LegacyVersion`` depending on it's PEP 440
+  validity.
+
+
+14.0 - 2014-09-05
+~~~~~~~~~~~~~~~~~
+
+* Initial release.
+
+
+.. _`master`: https://github.com/pypa/packaging/
+
+
diff --git a/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/RECORD b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/RECORD
new file mode 100644
index 0000000..6b2912e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/RECORD
@@ -0,0 +1,20 @@
+packaging/__about__.py,sha256=ugASIO2w1oUyH8_COqQ2X_s0rDhjbhQC3yJocD03h2c,661
+packaging/__init__.py,sha256=b9Kk5MF7KxhhLgcDmiUWukN-LatWFxPdNug0joPhHSk,497
+packaging/_manylinux.py,sha256=XcbiXB-qcjv3bcohp6N98TMpOP4_j3m-iOA8ptK2GWY,11488
+packaging/_musllinux.py,sha256=_KGgY_qc7vhMGpoqss25n2hiLCNKRtvz9mCrS7gkqyc,4378
+packaging/_structures.py,sha256=q3eVNmbWJGG_S0Dit_S3Ao8qQqz_5PYTXFAKBZe5yr4,1431
+packaging/markers.py,sha256=Fygi3_eZnjQ-3VJizW5AhI5wvo0Hb6RMk4DidsKpOC0,8475
+packaging/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+packaging/requirements.py,sha256=rjaGRCMepZS1mlYMjJ5Qh6rfq3gtsCRQUQmftGZ_bu8,4664
+packaging/specifiers.py,sha256=LRQ0kFsHrl5qfcFNEEJrIFYsnIHQUJXY9fIsakTrrqE,30110
+packaging/tags.py,sha256=lmsnGNiJ8C4D_Pf9PbM0qgbZvD9kmB9lpZBQUZa3R_Y,15699
+packaging/utils.py,sha256=dJjeat3BS-TYn1RrUFVwufUMasbtzLfYRoy_HXENeFQ,4200
+packaging/version.py,sha256=_fLRNrFrxYcHVfyo8vk9j8s6JM8N_xsSxVFr6RJyco8,14665
+packaging-21.3.dist-info/LICENSE,sha256=ytHvW9NA1z4HS6YU0m996spceUDD2MNIUuZcSQlobEg,197
+packaging-21.3.dist-info/LICENSE.APACHE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+packaging-21.3.dist-info/LICENSE.BSD,sha256=tw5-m3QvHMb5SLNMFqo5_-zpQZY2S8iP8NIYDwAo-sU,1344
+packaging-21.3.dist-info/METADATA,sha256=KuKIy6qDLP3svIt6ejCbxBDhvq11ebkgUN55MeyKFyc,15147
+packaging-21.3.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+packaging-21.3.dist-info/top_level.txt,sha256=zFdHrhWnPslzsiP455HutQsqPB6v0KCtNUMtUtrefDw,10
+packaging-21.3.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+packaging-21.3.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/WHEEL
new file mode 100644
index 0000000..5bad85f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/top_level.txt
new file mode 100644
index 0000000..748809f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging-21.3.dist-info/top_level.txt
@@ -0,0 +1 @@
+packaging
diff --git a/myenv/lib/python3.9/site-packages/packaging/__about__.py b/myenv/lib/python3.9/site-packages/packaging/__about__.py
new file mode 100644
index 0000000..3551bc2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging/__about__.py
@@ -0,0 +1,26 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
+
+__title__ = "packaging"
+__summary__ = "Core utilities for Python packages"
+__uri__ = "https://github.com/pypa/packaging"
+
+__version__ = "21.3"
+
+__author__ = "Donald Stufft and individual contributors"
+__email__ = "donald@stufft.io"
+
+__license__ = "BSD-2-Clause or Apache-2.0"
+__copyright__ = "2014-2019 %s" % __author__
diff --git a/myenv/lib/python3.9/site-packages/packaging/__init__.py b/myenv/lib/python3.9/site-packages/packaging/__init__.py
new file mode 100644
index 0000000..3c50c5d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging/__init__.py
@@ -0,0 +1,25 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from .__about__ import (
+    __author__,
+    __copyright__,
+    __email__,
+    __license__,
+    __summary__,
+    __title__,
+    __uri__,
+    __version__,
+)
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
diff --git a/myenv/lib/python3.9/site-packages/packaging/_manylinux.py b/myenv/lib/python3.9/site-packages/packaging/_manylinux.py
new file mode 100644
index 0000000..4c379aa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging/_manylinux.py
@@ -0,0 +1,301 @@
+import collections
+import functools
+import os
+import re
+import struct
+import sys
+import warnings
+from typing import IO, Dict, Iterator, NamedTuple, Optional, Tuple
+
+
+# Python does not provide platform information at sufficient granularity to
+# identify the architecture of the running executable in some cases, so we
+# determine it dynamically by reading the information from the running
+# process. This only applies on Linux, which uses the ELF format.
+class _ELFFileHeader:
+    # https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header
+    class _InvalidELFFileHeader(ValueError):
+        """
+        An invalid ELF file header was found.
+        """
+
+    ELF_MAGIC_NUMBER = 0x7F454C46
+    ELFCLASS32 = 1
+    ELFCLASS64 = 2
+    ELFDATA2LSB = 1
+    ELFDATA2MSB = 2
+    EM_386 = 3
+    EM_S390 = 22
+    EM_ARM = 40
+    EM_X86_64 = 62
+    EF_ARM_ABIMASK = 0xFF000000
+    EF_ARM_ABI_VER5 = 0x05000000
+    EF_ARM_ABI_FLOAT_HARD = 0x00000400
+
+    def __init__(self, file: IO[bytes]) -> None:
+        def unpack(fmt: str) -> int:
+            try:
+                data = file.read(struct.calcsize(fmt))
+                result: Tuple[int, ...] = struct.unpack(fmt, data)
+            except struct.error:
+                raise _ELFFileHeader._InvalidELFFileHeader()
+            return result[0]
+
+        self.e_ident_magic = unpack(">I")
+        if self.e_ident_magic != self.ELF_MAGIC_NUMBER:
+            raise _ELFFileHeader._InvalidELFFileHeader()
+        self.e_ident_class = unpack("B")
+        if self.e_ident_class not in {self.ELFCLASS32, self.ELFCLASS64}:
+            raise _ELFFileHeader._InvalidELFFileHeader()
+        self.e_ident_data = unpack("B")
+        if self.e_ident_data not in {self.ELFDATA2LSB, self.ELFDATA2MSB}:
+            raise _ELFFileHeader._InvalidELFFileHeader()
+        self.e_ident_version = unpack("B")
+        self.e_ident_osabi = unpack("B")
+        self.e_ident_abiversion = unpack("B")
+        self.e_ident_pad = file.read(7)
+        format_h = "<H" if self.e_ident_data == self.ELFDATA2LSB else ">H"
+        format_i = "<I" if self.e_ident_data == self.ELFDATA2LSB else ">I"
+        format_q = "<Q" if self.e_ident_data == self.ELFDATA2LSB else ">Q"
+        format_p = format_i if self.e_ident_class == self.ELFCLASS32 else format_q
+        self.e_type = unpack(format_h)
+        self.e_machine = unpack(format_h)
+        self.e_version = unpack(format_i)
+        self.e_entry = unpack(format_p)
+        self.e_phoff = unpack(format_p)
+        self.e_shoff = unpack(format_p)
+        self.e_flags = unpack(format_i)
+        self.e_ehsize = unpack(format_h)
+        self.e_phentsize = unpack(format_h)
+        self.e_phnum = unpack(format_h)
+        self.e_shentsize = unpack(format_h)
+        self.e_shnum = unpack(format_h)
+        self.e_shstrndx = unpack(format_h)
+
+
+def _get_elf_header() -> Optional[_ELFFileHeader]:
+    try:
+        with open(sys.executable, "rb") as f:
+            elf_header = _ELFFileHeader(f)
+    except (OSError, TypeError, _ELFFileHeader._InvalidELFFileHeader):
+        return None
+    return elf_header
+
+
+def _is_linux_armhf() -> bool:
+    # hard-float ABI can be detected from the ELF header of the running
+    # process
+    # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf
+    elf_header = _get_elf_header()
+    if elf_header is None:
+        return False
+    result = elf_header.e_ident_class == elf_header.ELFCLASS32
+    result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB
+    result &= elf_header.e_machine == elf_header.EM_ARM
+    result &= (
+        elf_header.e_flags & elf_header.EF_ARM_ABIMASK
+    ) == elf_header.EF_ARM_ABI_VER5
+    result &= (
+        elf_header.e_flags & elf_header.EF_ARM_ABI_FLOAT_HARD
+    ) == elf_header.EF_ARM_ABI_FLOAT_HARD
+    return result
+
+
+def _is_linux_i686() -> bool:
+    elf_header = _get_elf_header()
+    if elf_header is None:
+        return False
+    result = elf_header.e_ident_class == elf_header.ELFCLASS32
+    result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB
+    result &= elf_header.e_machine == elf_header.EM_386
+    return result
+
+
+def _have_compatible_abi(arch: str) -> bool:
+    if arch == "armv7l":
+        return _is_linux_armhf()
+    if arch == "i686":
+        return _is_linux_i686()
+    return arch in {"x86_64", "aarch64", "ppc64", "ppc64le", "s390x"}
+
+
+# If glibc ever changes its major version, we need to know what the last
+# minor version was, so we can build the complete list of all versions.
+# For now, guess what the highest minor version might be, assume it will
+# be 50 for testing. Once this actually happens, update the dictionary
+# with the actual value.
+_LAST_GLIBC_MINOR: Dict[int, int] = collections.defaultdict(lambda: 50)
+
+
+class _GLibCVersion(NamedTuple):
+    major: int
+    minor: int
+
+
+def _glibc_version_string_confstr() -> Optional[str]:
+    """
+    Primary implementation of glibc_version_string using os.confstr.
+    """
+    # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely
+    # to be broken or missing. This strategy is used in the standard library
+    # platform module.
+    # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183
+    try:
+        # os.confstr("CS_GNU_LIBC_VERSION") returns a string like "glibc 2.17".
+        version_string = os.confstr("CS_GNU_LIBC_VERSION")
+        assert version_string is not None
+        _, version = version_string.split()
+    except (AssertionError, AttributeError, OSError, ValueError):
+        # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)...
+        return None
+    return version
+
+
+def _glibc_version_string_ctypes() -> Optional[str]:
+    """
+    Fallback implementation of glibc_version_string using ctypes.
+    """
+    try:
+        import ctypes
+    except ImportError:
+        return None
+
+    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
+    # manpage says, "If filename is NULL, then the returned handle is for the
+    # main program". This way we can let the linker do the work to figure out
+    # which libc our process is actually using.
+    #
+    # We must also handle the special case where the executable is not a
+    # dynamically linked executable. This can occur when using musl libc,
+    # for example. In this situation, dlopen() will error, leading to an
+    # OSError. Interestingly, at least in the case of musl, there is no
+    # errno set on the OSError. The single string argument used to construct
+    # OSError comes from libc itself and is therefore not portable to
+    # hard code here. In any case, failure to call dlopen() means we
+    # can proceed, so we bail on our attempt.
+    try:
+        process_namespace = ctypes.CDLL(None)
+    except OSError:
+        return None
+
+    try:
+        gnu_get_libc_version = process_namespace.gnu_get_libc_version
+    except AttributeError:
+        # Symbol doesn't exist -> therefore, we are not linked to
+        # glibc.
+        return None
+
+    # Call gnu_get_libc_version, which returns a string like "2.5"
+    gnu_get_libc_version.restype = ctypes.c_char_p
+    version_str: str = gnu_get_libc_version()
+    # py2 / py3 compatibility:
+    if not isinstance(version_str, str):
+        version_str = version_str.decode("ascii")
+
+    return version_str
+
+
+def _glibc_version_string() -> Optional[str]:
+    """Returns glibc version string, or None if not using glibc."""
+    return _glibc_version_string_confstr() or _glibc_version_string_ctypes()
+
+
+def _parse_glibc_version(version_str: str) -> Tuple[int, int]:
+    """Parse glibc version.
+
+    We use a regexp instead of str.split because we want to discard any
+    random junk that might come after the minor version -- this might happen
+    in patched/forked versions of glibc (e.g. Linaro's version of glibc
+    uses version strings like "2.20-2014.11"). See gh-3588.
+    """
+    m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str)
+    if not m:
+        warnings.warn(
+            "Expected glibc version with 2 components major.minor,"
+            " got: %s" % version_str,
+            RuntimeWarning,
+        )
+        return -1, -1
+    return int(m.group("major")), int(m.group("minor"))
+
+
+@functools.lru_cache()
+def _get_glibc_version() -> Tuple[int, int]:
+    version_str = _glibc_version_string()
+    if version_str is None:
+        return (-1, -1)
+    return _parse_glibc_version(version_str)
+
+
+# From PEP 513, PEP 600
+def _is_compatible(name: str, arch: str, version: _GLibCVersion) -> bool:
+    sys_glibc = _get_glibc_version()
+    if sys_glibc < version:
+        return False
+    # Check for presence of _manylinux module.
+    try:
+        import _manylinux  # noqa
+    except ImportError:
+        return True
+    if hasattr(_manylinux, "manylinux_compatible"):
+        result = _manylinux.manylinux_compatible(version[0], version[1], arch)
+        if result is not None:
+            return bool(result)
+        return True
+    if version == _GLibCVersion(2, 5):
+        if hasattr(_manylinux, "manylinux1_compatible"):
+            return bool(_manylinux.manylinux1_compatible)
+    if version == _GLibCVersion(2, 12):
+        if hasattr(_manylinux, "manylinux2010_compatible"):
+            return bool(_manylinux.manylinux2010_compatible)
+    if version == _GLibCVersion(2, 17):
+        if hasattr(_manylinux, "manylinux2014_compatible"):
+            return bool(_manylinux.manylinux2014_compatible)
+    return True
+
+
+_LEGACY_MANYLINUX_MAP = {
+    # CentOS 7 w/ glibc 2.17 (PEP 599)
+    (2, 17): "manylinux2014",
+    # CentOS 6 w/ glibc 2.12 (PEP 571)
+    (2, 12): "manylinux2010",
+    # CentOS 5 w/ glibc 2.5 (PEP 513)
+    (2, 5): "manylinux1",
+}
+
+
+def platform_tags(linux: str, arch: str) -> Iterator[str]:
+    if not _have_compatible_abi(arch):
+        return
+    # Oldest glibc to be supported regardless of architecture is (2, 17).
+    too_old_glibc2 = _GLibCVersion(2, 16)
+    if arch in {"x86_64", "i686"}:
+        # On x86/i686 also oldest glibc to be supported is (2, 5).
+        too_old_glibc2 = _GLibCVersion(2, 4)
+    current_glibc = _GLibCVersion(*_get_glibc_version())
+    glibc_max_list = [current_glibc]
+    # We can assume compatibility across glibc major versions.
+    # https://sourceware.org/bugzilla/show_bug.cgi?id=24636
+    #
+    # Build a list of maximum glibc versions so that we can
+    # output the canonical list of all glibc from current_glibc
+    # down to too_old_glibc2, including all intermediary versions.
+    for glibc_major in range(current_glibc.major - 1, 1, -1):
+        glibc_minor = _LAST_GLIBC_MINOR[glibc_major]
+        glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor))
+    for glibc_max in glibc_max_list:
+        if glibc_max.major == too_old_glibc2.major:
+            min_minor = too_old_glibc2.minor
+        else:
+            # For other glibc major versions oldest supported is (x, 0).
+            min_minor = -1
+        for glibc_minor in range(glibc_max.minor, min_minor, -1):
+            glibc_version = _GLibCVersion(glibc_max.major, glibc_minor)
+            tag = "manylinux_{}_{}".format(*glibc_version)
+            if _is_compatible(tag, arch, glibc_version):
+                yield linux.replace("linux", tag)
+            # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags.
+            if glibc_version in _LEGACY_MANYLINUX_MAP:
+                legacy_tag = _LEGACY_MANYLINUX_MAP[glibc_version]
+                if _is_compatible(legacy_tag, arch, glibc_version):
+                    yield linux.replace("linux", legacy_tag)
diff --git a/myenv/lib/python3.9/site-packages/packaging/_musllinux.py b/myenv/lib/python3.9/site-packages/packaging/_musllinux.py
new file mode 100644
index 0000000..8ac3059
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging/_musllinux.py
@@ -0,0 +1,136 @@
+"""PEP 656 support.
+
+This module implements logic to detect if the currently running Python is
+linked against musl, and what musl version is used.
+"""
+
+import contextlib
+import functools
+import operator
+import os
+import re
+import struct
+import subprocess
+import sys
+from typing import IO, Iterator, NamedTuple, Optional, Tuple
+
+
+def _read_unpacked(f: IO[bytes], fmt: str) -> Tuple[int, ...]:
+    return struct.unpack(fmt, f.read(struct.calcsize(fmt)))
+
+
+def _parse_ld_musl_from_elf(f: IO[bytes]) -> Optional[str]:
+    """Detect musl libc location by parsing the Python executable.
+
+    Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca
+    ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html
+    """
+    f.seek(0)
+    try:
+        ident = _read_unpacked(f, "16B")
+    except struct.error:
+        return None
+    if ident[:4] != tuple(b"\x7fELF"):  # Invalid magic, not ELF.
+        return None
+    f.seek(struct.calcsize("HHI"), 1)  # Skip file type, machine, and version.
+
+    try:
+        # e_fmt: Format for program header.
+        # p_fmt: Format for section header.
+        # p_idx: Indexes to find p_type, p_offset, and p_filesz.
+        e_fmt, p_fmt, p_idx = {
+            1: ("IIIIHHH", "IIIIIIII", (0, 1, 4)),  # 32-bit.
+            2: ("QQQIHHH", "IIQQQQQQ", (0, 2, 5)),  # 64-bit.
+        }[ident[4]]
+    except KeyError:
+        return None
+    else:
+        p_get = operator.itemgetter(*p_idx)
+
+    # Find the interpreter section and return its content.
+    try:
+        _, e_phoff, _, _, _, e_phentsize, e_phnum = _read_unpacked(f, e_fmt)
+    except struct.error:
+        return None
+    for i in range(e_phnum + 1):
+        f.seek(e_phoff + e_phentsize * i)
+        try:
+            p_type, p_offset, p_filesz = p_get(_read_unpacked(f, p_fmt))
+        except struct.error:
+            return None
+        if p_type != 3:  # Not PT_INTERP.
+            continue
+        f.seek(p_offset)
+        interpreter = os.fsdecode(f.read(p_filesz)).strip("\0")
+        if "musl" not in interpreter:
+            return None
+        return interpreter
+    return None
+
+
+class _MuslVersion(NamedTuple):
+    major: int
+    minor: int
+
+
+def _parse_musl_version(output: str) -> Optional[_MuslVersion]:
+    lines = [n for n in (n.strip() for n in output.splitlines()) if n]
+    if len(lines) < 2 or lines[0][:4] != "musl":
+        return None
+    m = re.match(r"Version (\d+)\.(\d+)", lines[1])
+    if not m:
+        return None
+    return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2)))
+
+
+@functools.lru_cache()
+def _get_musl_version(executable: str) -> Optional[_MuslVersion]:
+    """Detect currently-running musl runtime version.
+
+    This is done by checking the specified executable's dynamic linking
+    information, and invoking the loader to parse its output for a version
+    string. If the loader is musl, the output would be something like::
+
+        musl libc (x86_64)
+        Version 1.2.2
+        Dynamic Program Loader
+    """
+    with contextlib.ExitStack() as stack:
+        try:
+            f = stack.enter_context(open(executable, "rb"))
+        except OSError:
+            return None
+        ld = _parse_ld_musl_from_elf(f)
+    if not ld:
+        return None
+    proc = subprocess.run([ld], stderr=subprocess.PIPE, universal_newlines=True)
+    return _parse_musl_version(proc.stderr)
+
+
+def platform_tags(arch: str) -> Iterator[str]:
+    """Generate musllinux tags compatible to the current platform.
+
+    :param arch: Should be the part of platform tag after the ``linux_``
+        prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a
+        prerequisite for the current platform to be musllinux-compatible.
+
+    :returns: An iterator of compatible musllinux tags.
+    """
+    sys_musl = _get_musl_version(sys.executable)
+    if sys_musl is None:  # Python not dynamically linked against musl.
+        return
+    for minor in range(sys_musl.minor, -1, -1):
+        yield f"musllinux_{sys_musl.major}_{minor}_{arch}"
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sysconfig
+
+    plat = sysconfig.get_platform()
+    assert plat.startswith("linux-"), "not linux"
+
+    print("plat:", plat)
+    print("musl:", _get_musl_version(sys.executable))
+    print("tags:", end=" ")
+    for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])):
+        print(t, end="\n      ")
diff --git a/myenv/lib/python3.9/site-packages/packaging/_structures.py b/myenv/lib/python3.9/site-packages/packaging/_structures.py
new file mode 100644
index 0000000..90a6465
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging/_structures.py
@@ -0,0 +1,61 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+
+class InfinityType:
+    def __repr__(self) -> str:
+        return "Infinity"
+
+    def __hash__(self) -> int:
+        return hash(repr(self))
+
+    def __lt__(self, other: object) -> bool:
+        return False
+
+    def __le__(self, other: object) -> bool:
+        return False
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, self.__class__)
+
+    def __gt__(self, other: object) -> bool:
+        return True
+
+    def __ge__(self, other: object) -> bool:
+        return True
+
+    def __neg__(self: object) -> "NegativeInfinityType":
+        return NegativeInfinity
+
+
+Infinity = InfinityType()
+
+
+class NegativeInfinityType:
+    def __repr__(self) -> str:
+        return "-Infinity"
+
+    def __hash__(self) -> int:
+        return hash(repr(self))
+
+    def __lt__(self, other: object) -> bool:
+        return True
+
+    def __le__(self, other: object) -> bool:
+        return True
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, self.__class__)
+
+    def __gt__(self, other: object) -> bool:
+        return False
+
+    def __ge__(self, other: object) -> bool:
+        return False
+
+    def __neg__(self: object) -> InfinityType:
+        return Infinity
+
+
+NegativeInfinity = NegativeInfinityType()
diff --git a/myenv/lib/python3.9/site-packages/packaging/markers.py b/myenv/lib/python3.9/site-packages/packaging/markers.py
new file mode 100644
index 0000000..cb640e8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging/markers.py
@@ -0,0 +1,304 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import operator
+import os
+import platform
+import sys
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+from pyparsing import (  # noqa: N817
+    Forward,
+    Group,
+    Literal as L,
+    ParseException,
+    ParseResults,
+    QuotedString,
+    ZeroOrMore,
+    stringEnd,
+    stringStart,
+)
+
+from .specifiers import InvalidSpecifier, Specifier
+
+__all__ = [
+    "InvalidMarker",
+    "UndefinedComparison",
+    "UndefinedEnvironmentName",
+    "Marker",
+    "default_environment",
+]
+
+Operator = Callable[[str, str], bool]
+
+
+class InvalidMarker(ValueError):
+    """
+    An invalid marker was found, users should refer to PEP 508.
+    """
+
+
+class UndefinedComparison(ValueError):
+    """
+    An invalid operation was attempted on a value that doesn't support it.
+    """
+
+
+class UndefinedEnvironmentName(ValueError):
+    """
+    A name was attempted to be used that does not exist inside of the
+    environment.
+    """
+
+
+class Node:
+    def __init__(self, value: Any) -> None:
+        self.value = value
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}('{self}')>"
+
+    def serialize(self) -> str:
+        raise NotImplementedError
+
+
+class Variable(Node):
+    def serialize(self) -> str:
+        return str(self)
+
+
+class Value(Node):
+    def serialize(self) -> str:
+        return f'"{self}"'
+
+
+class Op(Node):
+    def serialize(self) -> str:
+        return str(self)
+
+
+VARIABLE = (
+    L("implementation_version")
+    | L("platform_python_implementation")
+    | L("implementation_name")
+    | L("python_full_version")
+    | L("platform_release")
+    | L("platform_version")
+    | L("platform_machine")
+    | L("platform_system")
+    | L("python_version")
+    | L("sys_platform")
+    | L("os_name")
+    | L("os.name")  # PEP-345
+    | L("sys.platform")  # PEP-345
+    | L("platform.version")  # PEP-345
+    | L("platform.machine")  # PEP-345
+    | L("platform.python_implementation")  # PEP-345
+    | L("python_implementation")  # undocumented setuptools legacy
+    | L("extra")  # PEP-508
+)
+ALIASES = {
+    "os.name": "os_name",
+    "sys.platform": "sys_platform",
+    "platform.version": "platform_version",
+    "platform.machine": "platform_machine",
+    "platform.python_implementation": "platform_python_implementation",
+    "python_implementation": "platform_python_implementation",
+}
+VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))
+
+VERSION_CMP = (
+    L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<")
+)
+
+MARKER_OP = VERSION_CMP | L("not in") | L("in")
+MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))
+
+MARKER_VALUE = QuotedString("'") | QuotedString('"')
+MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
+
+BOOLOP = L("and") | L("or")
+
+MARKER_VAR = VARIABLE | MARKER_VALUE
+
+MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
+MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
+
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+
+MARKER_EXPR = Forward()
+MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
+MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
+
+MARKER = stringStart + MARKER_EXPR + stringEnd
+
+
+def _coerce_parse_result(results: Union[ParseResults, List[Any]]) -> List[Any]:
+    if isinstance(results, ParseResults):
+        return [_coerce_parse_result(i) for i in results]
+    else:
+        return results
+
+
+def _format_marker(
+    marker: Union[List[str], Tuple[Node, ...], str], first: Optional[bool] = True
+) -> str:
+
+    assert isinstance(marker, (list, tuple, str))
+
+    # Sometimes we have a structure like [[...]] which is a single item list
+    # where the single item is itself it's own list. In that case we want skip
+    # the rest of this function so that we don't get extraneous () on the
+    # outside.
+    if (
+        isinstance(marker, list)
+        and len(marker) == 1
+        and isinstance(marker[0], (list, tuple))
+    ):
+        return _format_marker(marker[0])
+
+    if isinstance(marker, list):
+        inner = (_format_marker(m, first=False) for m in marker)
+        if first:
+            return " ".join(inner)
+        else:
+            return "(" + " ".join(inner) + ")"
+    elif isinstance(marker, tuple):
+        return " ".join([m.serialize() for m in marker])
+    else:
+        return marker
+
+
+_operators: Dict[str, Operator] = {
+    "in": lambda lhs, rhs: lhs in rhs,
+    "not in": lambda lhs, rhs: lhs not in rhs,
+    "<": operator.lt,
+    "<=": operator.le,
+    "==": operator.eq,
+    "!=": operator.ne,
+    ">=": operator.ge,
+    ">": operator.gt,
+}
+
+
+def _eval_op(lhs: str, op: Op, rhs: str) -> bool:
+    try:
+        spec = Specifier("".join([op.serialize(), rhs]))
+    except InvalidSpecifier:
+        pass
+    else:
+        return spec.contains(lhs)
+
+    oper: Optional[Operator] = _operators.get(op.serialize())
+    if oper is None:
+        raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.")
+
+    return oper(lhs, rhs)
+
+
+class Undefined:
+    pass
+
+
+_undefined = Undefined()
+
+
+def _get_env(environment: Dict[str, str], name: str) -> str:
+    value: Union[str, Undefined] = environment.get(name, _undefined)
+
+    if isinstance(value, Undefined):
+        raise UndefinedEnvironmentName(
+            f"{name!r} does not exist in evaluation environment."
+        )
+
+    return value
+
+
+def _evaluate_markers(markers: List[Any], environment: Dict[str, str]) -> bool:
+    groups: List[List[bool]] = [[]]
+
+    for marker in markers:
+        assert isinstance(marker, (list, tuple, str))
+
+        if isinstance(marker, list):
+            groups[-1].append(_evaluate_markers(marker, environment))
+        elif isinstance(marker, tuple):
+            lhs, op, rhs = marker
+
+            if isinstance(lhs, Variable):
+                lhs_value = _get_env(environment, lhs.value)
+                rhs_value = rhs.value
+            else:
+                lhs_value = lhs.value
+                rhs_value = _get_env(environment, rhs.value)
+
+            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
+        else:
+            assert marker in ["and", "or"]
+            if marker == "or":
+                groups.append([])
+
+    return any(all(item) for item in groups)
+
+
+def format_full_version(info: "sys._version_info") -> str:
+    version = "{0.major}.{0.minor}.{0.micro}".format(info)
+    kind = info.releaselevel
+    if kind != "final":
+        version += kind[0] + str(info.serial)
+    return version
+
+
+def default_environment() -> Dict[str, str]:
+    iver = format_full_version(sys.implementation.version)
+    implementation_name = sys.implementation.name
+    return {
+        "implementation_name": implementation_name,
+        "implementation_version": iver,
+        "os_name": os.name,
+        "platform_machine": platform.machine(),
+        "platform_release": platform.release(),
+        "platform_system": platform.system(),
+        "platform_version": platform.version(),
+        "python_full_version": platform.python_version(),
+        "platform_python_implementation": platform.python_implementation(),
+        "python_version": ".".join(platform.python_version_tuple()[:2]),
+        "sys_platform": sys.platform,
+    }
+
+
+class Marker:
+    def __init__(self, marker: str) -> None:
+        try:
+            self._markers = _coerce_parse_result(MARKER.parseString(marker))
+        except ParseException as e:
+            raise InvalidMarker(
+                f"Invalid marker: {marker!r}, parse error at "
+                f"{marker[e.loc : e.loc + 8]!r}"
+            )
+
+    def __str__(self) -> str:
+        return _format_marker(self._markers)
+
+    def __repr__(self) -> str:
+        return f"<Marker('{self}')>"
+
+    def evaluate(self, environment: Optional[Dict[str, str]] = None) -> bool:
+        """Evaluate a marker.
+
+        Return the boolean from evaluating the given marker against the
+        environment. environment is an optional argument to override all or
+        part of the determined environment.
+
+        The environment is determined from the current Python process.
+        """
+        current_environment = default_environment()
+        if environment is not None:
+            current_environment.update(environment)
+
+        return _evaluate_markers(self._markers, current_environment)
diff --git a/myenv/lib/python3.9/site-packages/packaging/py.typed b/myenv/lib/python3.9/site-packages/packaging/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/packaging/requirements.py b/myenv/lib/python3.9/site-packages/packaging/requirements.py
new file mode 100644
index 0000000..53f9a3a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging/requirements.py
@@ -0,0 +1,146 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import re
+import string
+import urllib.parse
+from typing import List, Optional as TOptional, Set
+
+from pyparsing import (  # noqa
+    Combine,
+    Literal as L,
+    Optional,
+    ParseException,
+    Regex,
+    Word,
+    ZeroOrMore,
+    originalTextFor,
+    stringEnd,
+    stringStart,
+)
+
+from .markers import MARKER_EXPR, Marker
+from .specifiers import LegacySpecifier, Specifier, SpecifierSet
+
+
+class InvalidRequirement(ValueError):
+    """
+    An invalid requirement was found, users should refer to PEP 508.
+    """
+
+
+ALPHANUM = Word(string.ascii_letters + string.digits)
+
+LBRACKET = L("[").suppress()
+RBRACKET = L("]").suppress()
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+COMMA = L(",").suppress()
+SEMICOLON = L(";").suppress()
+AT = L("@").suppress()
+
+PUNCTUATION = Word("-_.")
+IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
+IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
+
+NAME = IDENTIFIER("name")
+EXTRA = IDENTIFIER
+
+URI = Regex(r"[^ ]+")("url")
+URL = AT + URI
+
+EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
+EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
+
+VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
+VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
+
+VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
+VERSION_MANY = Combine(
+    VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False
+)("_raw_spec")
+_VERSION_SPEC = Optional((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY)
+_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "")
+
+VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
+VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
+
+MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
+MARKER_EXPR.setParseAction(
+    lambda s, l, t: Marker(s[t._original_start : t._original_end])
+)
+MARKER_SEPARATOR = SEMICOLON
+MARKER = MARKER_SEPARATOR + MARKER_EXPR
+
+VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
+URL_AND_MARKER = URL + Optional(MARKER)
+
+NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
+
+REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
+# pyparsing isn't thread safe during initialization, so we do it eagerly, see
+# issue #104
+REQUIREMENT.parseString("x[]")
+
+
+class Requirement:
+    """Parse a requirement.
+
+    Parse a given requirement string into its parts, such as name, specifier,
+    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
+    string.
+    """
+
+    # TODO: Can we test whether something is contained within a requirement?
+    #       If so how do we do that? Do we need to test against the _name_ of
+    #       the thing as well as the version? What about the markers?
+    # TODO: Can we normalize the name and extra name?
+
+    def __init__(self, requirement_string: str) -> None:
+        try:
+            req = REQUIREMENT.parseString(requirement_string)
+        except ParseException as e:
+            raise InvalidRequirement(
+                f'Parse error at "{ requirement_string[e.loc : e.loc + 8]!r}": {e.msg}'
+            )
+
+        self.name: str = req.name
+        if req.url:
+            parsed_url = urllib.parse.urlparse(req.url)
+            if parsed_url.scheme == "file":
+                if urllib.parse.urlunparse(parsed_url) != req.url:
+                    raise InvalidRequirement("Invalid URL given")
+            elif not (parsed_url.scheme and parsed_url.netloc) or (
+                not parsed_url.scheme and not parsed_url.netloc
+            ):
+                raise InvalidRequirement(f"Invalid URL: {req.url}")
+            self.url: TOptional[str] = req.url
+        else:
+            self.url = None
+        self.extras: Set[str] = set(req.extras.asList() if req.extras else [])
+        self.specifier: SpecifierSet = SpecifierSet(req.specifier)
+        self.marker: TOptional[Marker] = req.marker if req.marker else None
+
+    def __str__(self) -> str:
+        parts: List[str] = [self.name]
+
+        if self.extras:
+            formatted_extras = ",".join(sorted(self.extras))
+            parts.append(f"[{formatted_extras}]")
+
+        if self.specifier:
+            parts.append(str(self.specifier))
+
+        if self.url:
+            parts.append(f"@ {self.url}")
+            if self.marker:
+                parts.append(" ")
+
+        if self.marker:
+            parts.append(f"; {self.marker}")
+
+        return "".join(parts)
+
+    def __repr__(self) -> str:
+        return f"<Requirement('{self}')>"
diff --git a/myenv/lib/python3.9/site-packages/packaging/specifiers.py b/myenv/lib/python3.9/site-packages/packaging/specifiers.py
new file mode 100644
index 0000000..0e218a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging/specifiers.py
@@ -0,0 +1,802 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import abc
+import functools
+import itertools
+import re
+import warnings
+from typing import (
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Pattern,
+    Set,
+    Tuple,
+    TypeVar,
+    Union,
+)
+
+from .utils import canonicalize_version
+from .version import LegacyVersion, Version, parse
+
+ParsedVersion = Union[Version, LegacyVersion]
+UnparsedVersion = Union[Version, LegacyVersion, str]
+VersionTypeVar = TypeVar("VersionTypeVar", bound=UnparsedVersion)
+CallableOperator = Callable[[ParsedVersion, str], bool]
+
+
+class InvalidSpecifier(ValueError):
+    """
+    An invalid specifier was found, users should refer to PEP 440.
+    """
+
+
+class BaseSpecifier(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def __str__(self) -> str:
+        """
+        Returns the str representation of this Specifier like object. This
+        should be representative of the Specifier itself.
+        """
+
+    @abc.abstractmethod
+    def __hash__(self) -> int:
+        """
+        Returns a hash value for this Specifier like object.
+        """
+
+    @abc.abstractmethod
+    def __eq__(self, other: object) -> bool:
+        """
+        Returns a boolean representing whether or not the two Specifier like
+        objects are equal.
+        """
+
+    @abc.abstractproperty
+    def prereleases(self) -> Optional[bool]:
+        """
+        Returns whether or not pre-releases as a whole are allowed by this
+        specifier.
+        """
+
+    @prereleases.setter
+    def prereleases(self, value: bool) -> None:
+        """
+        Sets whether or not pre-releases as a whole are allowed by this
+        specifier.
+        """
+
+    @abc.abstractmethod
+    def contains(self, item: str, prereleases: Optional[bool] = None) -> bool:
+        """
+        Determines if the given item is contained within this specifier.
+        """
+
+    @abc.abstractmethod
+    def filter(
+        self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
+    ) -> Iterable[VersionTypeVar]:
+        """
+        Takes an iterable of items and filters them so that only items which
+        are contained within this specifier are allowed in it.
+        """
+
+
+class _IndividualSpecifier(BaseSpecifier):
+
+    _operators: Dict[str, str] = {}
+    _regex: Pattern[str]
+
+    def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None:
+        match = self._regex.search(spec)
+        if not match:
+            raise InvalidSpecifier(f"Invalid specifier: '{spec}'")
+
+        self._spec: Tuple[str, str] = (
+            match.group("operator").strip(),
+            match.group("version").strip(),
+        )
+
+        # Store whether or not this Specifier should accept prereleases
+        self._prereleases = prereleases
+
+    def __repr__(self) -> str:
+        pre = (
+            f", prereleases={self.prereleases!r}"
+            if self._prereleases is not None
+            else ""
+        )
+
+        return f"<{self.__class__.__name__}({str(self)!r}{pre})>"
+
+    def __str__(self) -> str:
+        return "{}{}".format(*self._spec)
+
+    @property
+    def _canonical_spec(self) -> Tuple[str, str]:
+        return self._spec[0], canonicalize_version(self._spec[1])
+
+    def __hash__(self) -> int:
+        return hash(self._canonical_spec)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, str):
+            try:
+                other = self.__class__(str(other))
+            except InvalidSpecifier:
+                return NotImplemented
+        elif not isinstance(other, self.__class__):
+            return NotImplemented
+
+        return self._canonical_spec == other._canonical_spec
+
+    def _get_operator(self, op: str) -> CallableOperator:
+        operator_callable: CallableOperator = getattr(
+            self, f"_compare_{self._operators[op]}"
+        )
+        return operator_callable
+
+    def _coerce_version(self, version: UnparsedVersion) -> ParsedVersion:
+        if not isinstance(version, (LegacyVersion, Version)):
+            version = parse(version)
+        return version
+
+    @property
+    def operator(self) -> str:
+        return self._spec[0]
+
+    @property
+    def version(self) -> str:
+        return self._spec[1]
+
+    @property
+    def prereleases(self) -> Optional[bool]:
+        return self._prereleases
+
+    @prereleases.setter
+    def prereleases(self, value: bool) -> None:
+        self._prereleases = value
+
+    def __contains__(self, item: str) -> bool:
+        return self.contains(item)
+
+    def contains(
+        self, item: UnparsedVersion, prereleases: Optional[bool] = None
+    ) -> bool:
+
+        # Determine if prereleases are to be allowed or not.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # Normalize item to a Version or LegacyVersion, this allows us to have
+        # a shortcut for ``"2.0" in Specifier(">=2")
+        normalized_item = self._coerce_version(item)
+
+        # Determine if we should be supporting prereleases in this specifier
+        # or not, if we do not support prereleases than we can short circuit
+        # logic if this version is a prereleases.
+        if normalized_item.is_prerelease and not prereleases:
+            return False
+
+        # Actually do the comparison to determine if this item is contained
+        # within this Specifier or not.
+        operator_callable: CallableOperator = self._get_operator(self.operator)
+        return operator_callable(normalized_item, self.version)
+
+    def filter(
+        self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
+    ) -> Iterable[VersionTypeVar]:
+
+        yielded = False
+        found_prereleases = []
+
+        kw = {"prereleases": prereleases if prereleases is not None else True}
+
+        # Attempt to iterate over all the values in the iterable and if any of
+        # them match, yield them.
+        for version in iterable:
+            parsed_version = self._coerce_version(version)
+
+            if self.contains(parsed_version, **kw):
+                # If our version is a prerelease, and we were not set to allow
+                # prereleases, then we'll store it for later in case nothing
+                # else matches this specifier.
+                if parsed_version.is_prerelease and not (
+                    prereleases or self.prereleases
+                ):
+                    found_prereleases.append(version)
+                # Either this is not a prerelease, or we should have been
+                # accepting prereleases from the beginning.
+                else:
+                    yielded = True
+                    yield version
+
+        # Now that we've iterated over everything, determine if we've yielded
+        # any values, and if we have not and we have any prereleases stored up
+        # then we will go ahead and yield the prereleases.
+        if not yielded and found_prereleases:
+            for version in found_prereleases:
+                yield version
+
+
+class LegacySpecifier(_IndividualSpecifier):
+
+    _regex_str = r"""
+        (?P<operator>(==|!=|<=|>=|<|>))
+        \s*
+        (?P<version>
+            [^,;\s)]* # Since this is a "legacy" specifier, and the version
+                      # string can be just about anything, we match everything
+                      # except for whitespace, a semi-colon for marker support,
+                      # a closing paren since versions can be enclosed in
+                      # them, and a comma since it's a version separator.
+        )
+        """
+
+    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    _operators = {
+        "==": "equal",
+        "!=": "not_equal",
+        "<=": "less_than_equal",
+        ">=": "greater_than_equal",
+        "<": "less_than",
+        ">": "greater_than",
+    }
+
+    def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None:
+        super().__init__(spec, prereleases)
+
+        warnings.warn(
+            "Creating a LegacyVersion has been deprecated and will be "
+            "removed in the next major release",
+            DeprecationWarning,
+        )
+
+    def _coerce_version(self, version: UnparsedVersion) -> LegacyVersion:
+        if not isinstance(version, LegacyVersion):
+            version = LegacyVersion(str(version))
+        return version
+
+    def _compare_equal(self, prospective: LegacyVersion, spec: str) -> bool:
+        return prospective == self._coerce_version(spec)
+
+    def _compare_not_equal(self, prospective: LegacyVersion, spec: str) -> bool:
+        return prospective != self._coerce_version(spec)
+
+    def _compare_less_than_equal(self, prospective: LegacyVersion, spec: str) -> bool:
+        return prospective <= self._coerce_version(spec)
+
+    def _compare_greater_than_equal(
+        self, prospective: LegacyVersion, spec: str
+    ) -> bool:
+        return prospective >= self._coerce_version(spec)
+
+    def _compare_less_than(self, prospective: LegacyVersion, spec: str) -> bool:
+        return prospective < self._coerce_version(spec)
+
+    def _compare_greater_than(self, prospective: LegacyVersion, spec: str) -> bool:
+        return prospective > self._coerce_version(spec)
+
+
+def _require_version_compare(
+    fn: Callable[["Specifier", ParsedVersion, str], bool]
+) -> Callable[["Specifier", ParsedVersion, str], bool]:
+    @functools.wraps(fn)
+    def wrapped(self: "Specifier", prospective: ParsedVersion, spec: str) -> bool:
+        if not isinstance(prospective, Version):
+            return False
+        return fn(self, prospective, spec)
+
+    return wrapped
+
+
+class Specifier(_IndividualSpecifier):
+
+    _regex_str = r"""
+        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
+        (?P<version>
+            (?:
+                # The identity operators allow for an escape hatch that will
+                # do an exact string match of the version you wish to install.
+                # This will not be parsed by PEP 440 and we cannot determine
+                # any semantic meaning from it. This operator is discouraged
+                # but included entirely as an escape hatch.
+                (?<====)  # Only match for the identity operator
+                \s*
+                [^\s]*    # We just match everything, except for whitespace
+                          # since we are only testing for strict identity.
+            )
+            |
+            (?:
+                # The (non)equality operators allow for wild card and local
+                # versions to be specified so we have to define these two
+                # operators separately to enable that.
+                (?<===|!=)            # Only match for equals and not equals
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)*   # release
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+
+                # You cannot use a wild card and a dev or local version
+                # together so group them with a | and make them optional.
+                (?:
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
+                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
+                    |
+                    \.\*  # Wild card syntax of .*
+                )?
+            )
+            |
+            (?:
+                # The compatible operator requires at least two digits in the
+                # release segment.
+                (?<=~=)               # Only match for the compatible operator
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+            )
+            |
+            (?:
+                # All other operators only allow a sub set of what the
+                # (non)equality operators do. Specifically they do not allow
+                # local versions to be specified nor do they allow the prefix
+                # matching wild cards.
+                (?<!==|!=|~=)         # We have special cases for these
+                                      # operators so we want to make sure they
+                                      # don't match here.
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)*   # release
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+            )
+        )
+        """
+
+    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    _operators = {
+        "~=": "compatible",
+        "==": "equal",
+        "!=": "not_equal",
+        "<=": "less_than_equal",
+        ">=": "greater_than_equal",
+        "<": "less_than",
+        ">": "greater_than",
+        "===": "arbitrary",
+    }
+
+    @_require_version_compare
+    def _compare_compatible(self, prospective: ParsedVersion, spec: str) -> bool:
+
+        # Compatible releases have an equivalent combination of >= and ==. That
+        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
+        # implement this in terms of the other specifiers instead of
+        # implementing it ourselves. The only thing we need to do is construct
+        # the other specifiers.
+
+        # We want everything but the last item in the version, but we want to
+        # ignore suffix segments.
+        prefix = ".".join(
+            list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1]
+        )
+
+        # Add the prefix notation to the end of our string
+        prefix += ".*"
+
+        return self._get_operator(">=")(prospective, spec) and self._get_operator("==")(
+            prospective, prefix
+        )
+
+    @_require_version_compare
+    def _compare_equal(self, prospective: ParsedVersion, spec: str) -> bool:
+
+        # We need special logic to handle prefix matching
+        if spec.endswith(".*"):
+            # In the case of prefix matching we want to ignore local segment.
+            prospective = Version(prospective.public)
+            # Split the spec out by dots, and pretend that there is an implicit
+            # dot in between a release segment and a pre-release segment.
+            split_spec = _version_split(spec[:-2])  # Remove the trailing .*
+
+            # Split the prospective version out by dots, and pretend that there
+            # is an implicit dot in between a release segment and a pre-release
+            # segment.
+            split_prospective = _version_split(str(prospective))
+
+            # Shorten the prospective version to be the same length as the spec
+            # so that we can determine if the specifier is a prefix of the
+            # prospective version or not.
+            shortened_prospective = split_prospective[: len(split_spec)]
+
+            # Pad out our two sides with zeros so that they both equal the same
+            # length.
+            padded_spec, padded_prospective = _pad_version(
+                split_spec, shortened_prospective
+            )
+
+            return padded_prospective == padded_spec
+        else:
+            # Convert our spec string into a Version
+            spec_version = Version(spec)
+
+            # If the specifier does not have a local segment, then we want to
+            # act as if the prospective version also does not have a local
+            # segment.
+            if not spec_version.local:
+                prospective = Version(prospective.public)
+
+            return prospective == spec_version
+
+    @_require_version_compare
+    def _compare_not_equal(self, prospective: ParsedVersion, spec: str) -> bool:
+        return not self._compare_equal(prospective, spec)
+
+    @_require_version_compare
+    def _compare_less_than_equal(self, prospective: ParsedVersion, spec: str) -> bool:
+
+        # NB: Local version identifiers are NOT permitted in the version
+        # specifier, so local version labels can be universally removed from
+        # the prospective version.
+        return Version(prospective.public) <= Version(spec)
+
+    @_require_version_compare
+    def _compare_greater_than_equal(
+        self, prospective: ParsedVersion, spec: str
+    ) -> bool:
+
+        # NB: Local version identifiers are NOT permitted in the version
+        # specifier, so local version labels can be universally removed from
+        # the prospective version.
+        return Version(prospective.public) >= Version(spec)
+
+    @_require_version_compare
+    def _compare_less_than(self, prospective: ParsedVersion, spec_str: str) -> bool:
+
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
+        spec = Version(spec_str)
+
+        # Check to see if the prospective version is less than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective < spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a pre-release version, that we do not accept pre-release
+        # versions for the version mentioned in the specifier (e.g. <3.1 should
+        # not match 3.1.dev0, but should match 3.0.dev0).
+        if not spec.is_prerelease and prospective.is_prerelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # less than the spec version *and* it's not a pre-release of the same
+        # version in the spec.
+        return True
+
+    @_require_version_compare
+    def _compare_greater_than(self, prospective: ParsedVersion, spec_str: str) -> bool:
+
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
+        spec = Version(spec_str)
+
+        # Check to see if the prospective version is greater than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective > spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a post-release version, that we do not accept
+        # post-release versions for the version mentioned in the specifier
+        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
+        if not spec.is_postrelease and prospective.is_postrelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # Ensure that we do not allow a local version of the version mentioned
+        # in the specifier, which is technically greater than, to match.
+        if prospective.local is not None:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # greater than the spec version *and* it's not a pre-release of the
+        # same version in the spec.
+        return True
+
+    def _compare_arbitrary(self, prospective: Version, spec: str) -> bool:
+        return str(prospective).lower() == str(spec).lower()
+
+    @property
+    def prereleases(self) -> bool:
+
+        # If there is an explicit prereleases set for this, then we'll just
+        # blindly use that.
+        if self._prereleases is not None:
+            return self._prereleases
+
+        # Look at all of our specifiers and determine if they are inclusive
+        # operators, and if they are if they are including an explicit
+        # prerelease.
+        operator, version = self._spec
+        if operator in ["==", ">=", "<=", "~=", "==="]:
+            # The == specifier can include a trailing .*, if it does we
+            # want to remove before parsing.
+            if operator == "==" and version.endswith(".*"):
+                version = version[:-2]
+
+            # Parse the version, and if it is a pre-release than this
+            # specifier allows pre-releases.
+            if parse(version).is_prerelease:
+                return True
+
+        return False
+
+    @prereleases.setter
+    def prereleases(self, value: bool) -> None:
+        self._prereleases = value
+
+
+_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
+
+
+def _version_split(version: str) -> List[str]:
+    result: List[str] = []
+    for item in version.split("."):
+        match = _prefix_regex.search(item)
+        if match:
+            result.extend(match.groups())
+        else:
+            result.append(item)
+    return result
+
+
+def _is_not_suffix(segment: str) -> bool:
+    return not any(
+        segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post")
+    )
+
+
+def _pad_version(left: List[str], right: List[str]) -> Tuple[List[str], List[str]]:
+    left_split, right_split = [], []
+
+    # Get the release segment of our versions
+    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
+    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
+
+    # Get the rest of our versions
+    left_split.append(left[len(left_split[0]) :])
+    right_split.append(right[len(right_split[0]) :])
+
+    # Insert our padding
+    left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0])))
+    right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0])))
+
+    return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split)))
+
+
+class SpecifierSet(BaseSpecifier):
+    def __init__(
+        self, specifiers: str = "", prereleases: Optional[bool] = None
+    ) -> None:
+
+        # Split on , to break each individual specifier into it's own item, and
+        # strip each item to remove leading/trailing whitespace.
+        split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
+
+        # Parsed each individual specifier, attempting first to make it a
+        # Specifier and falling back to a LegacySpecifier.
+        parsed: Set[_IndividualSpecifier] = set()
+        for specifier in split_specifiers:
+            try:
+                parsed.add(Specifier(specifier))
+            except InvalidSpecifier:
+                parsed.add(LegacySpecifier(specifier))
+
+        # Turn our parsed specifiers into a frozen set and save them for later.
+        self._specs = frozenset(parsed)
+
+        # Store our prereleases value so we can use it later to determine if
+        # we accept prereleases or not.
+        self._prereleases = prereleases
+
+    def __repr__(self) -> str:
+        pre = (
+            f", prereleases={self.prereleases!r}"
+            if self._prereleases is not None
+            else ""
+        )
+
+        return f"<SpecifierSet({str(self)!r}{pre})>"
+
+    def __str__(self) -> str:
+        return ",".join(sorted(str(s) for s in self._specs))
+
+    def __hash__(self) -> int:
+        return hash(self._specs)
+
+    def __and__(self, other: Union["SpecifierSet", str]) -> "SpecifierSet":
+        if isinstance(other, str):
+            other = SpecifierSet(other)
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        specifier = SpecifierSet()
+        specifier._specs = frozenset(self._specs | other._specs)
+
+        if self._prereleases is None and other._prereleases is not None:
+            specifier._prereleases = other._prereleases
+        elif self._prereleases is not None and other._prereleases is None:
+            specifier._prereleases = self._prereleases
+        elif self._prereleases == other._prereleases:
+            specifier._prereleases = self._prereleases
+        else:
+            raise ValueError(
+                "Cannot combine SpecifierSets with True and False prerelease "
+                "overrides."
+            )
+
+        return specifier
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, (str, _IndividualSpecifier)):
+            other = SpecifierSet(str(other))
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        return self._specs == other._specs
+
+    def __len__(self) -> int:
+        return len(self._specs)
+
+    def __iter__(self) -> Iterator[_IndividualSpecifier]:
+        return iter(self._specs)
+
+    @property
+    def prereleases(self) -> Optional[bool]:
+
+        # If we have been given an explicit prerelease modifier, then we'll
+        # pass that through here.
+        if self._prereleases is not None:
+            return self._prereleases
+
+        # If we don't have any specifiers, and we don't have a forced value,
+        # then we'll just return None since we don't know if this should have
+        # pre-releases or not.
+        if not self._specs:
+            return None
+
+        # Otherwise we'll see if any of the given specifiers accept
+        # prereleases, if any of them do we'll return True, otherwise False.
+        return any(s.prereleases for s in self._specs)
+
+    @prereleases.setter
+    def prereleases(self, value: bool) -> None:
+        self._prereleases = value
+
+    def __contains__(self, item: UnparsedVersion) -> bool:
+        return self.contains(item)
+
+    def contains(
+        self, item: UnparsedVersion, prereleases: Optional[bool] = None
+    ) -> bool:
+
+        # Ensure that our item is a Version or LegacyVersion instance.
+        if not isinstance(item, (LegacyVersion, Version)):
+            item = parse(item)
+
+        # Determine if we're forcing a prerelease or not, if we're not forcing
+        # one for this particular filter call, then we'll use whatever the
+        # SpecifierSet thinks for whether or not we should support prereleases.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # We can determine if we're going to allow pre-releases by looking to
+        # see if any of the underlying items supports them. If none of them do
+        # and this item is a pre-release then we do not allow it and we can
+        # short circuit that here.
+        # Note: This means that 1.0.dev1 would not be contained in something
+        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
+        if not prereleases and item.is_prerelease:
+            return False
+
+        # We simply dispatch to the underlying specs here to make sure that the
+        # given version is contained within all of them.
+        # Note: This use of all() here means that an empty set of specifiers
+        #       will always return True, this is an explicit design decision.
+        return all(s.contains(item, prereleases=prereleases) for s in self._specs)
+
+    def filter(
+        self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
+    ) -> Iterable[VersionTypeVar]:
+
+        # Determine if we're forcing a prerelease or not, if we're not forcing
+        # one for this particular filter call, then we'll use whatever the
+        # SpecifierSet thinks for whether or not we should support prereleases.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # If we have any specifiers, then we want to wrap our iterable in the
+        # filter method for each one, this will act as a logical AND amongst
+        # each specifier.
+        if self._specs:
+            for spec in self._specs:
+                iterable = spec.filter(iterable, prereleases=bool(prereleases))
+            return iterable
+        # If we do not have any specifiers, then we need to have a rough filter
+        # which will filter out any pre-releases, unless there are no final
+        # releases, and which will filter out LegacyVersion in general.
+        else:
+            filtered: List[VersionTypeVar] = []
+            found_prereleases: List[VersionTypeVar] = []
+
+            item: UnparsedVersion
+            parsed_version: Union[Version, LegacyVersion]
+
+            for item in iterable:
+                # Ensure that we some kind of Version class for this item.
+                if not isinstance(item, (LegacyVersion, Version)):
+                    parsed_version = parse(item)
+                else:
+                    parsed_version = item
+
+                # Filter out any item which is parsed as a LegacyVersion
+                if isinstance(parsed_version, LegacyVersion):
+                    continue
+
+                # Store any item which is a pre-release for later unless we've
+                # already found a final version or we are accepting prereleases
+                if parsed_version.is_prerelease and not prereleases:
+                    if not filtered:
+                        found_prereleases.append(item)
+                else:
+                    filtered.append(item)
+
+            # If we've found no items except for pre-releases, then we'll go
+            # ahead and use the pre-releases
+            if not filtered and found_prereleases and prereleases is None:
+                return found_prereleases
+
+            return filtered
diff --git a/myenv/lib/python3.9/site-packages/packaging/tags.py b/myenv/lib/python3.9/site-packages/packaging/tags.py
new file mode 100644
index 0000000..9a3d25a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging/tags.py
@@ -0,0 +1,487 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import logging
+import platform
+import sys
+import sysconfig
+from importlib.machinery import EXTENSION_SUFFIXES
+from typing import (
+    Dict,
+    FrozenSet,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+    cast,
+)
+
+from . import _manylinux, _musllinux
+
+logger = logging.getLogger(__name__)
+
+PythonVersion = Sequence[int]
+MacVersion = Tuple[int, int]
+
+INTERPRETER_SHORT_NAMES: Dict[str, str] = {
+    "python": "py",  # Generic.
+    "cpython": "cp",
+    "pypy": "pp",
+    "ironpython": "ip",
+    "jython": "jy",
+}
+
+
+_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32
+
+
+class Tag:
+    """
+    A representation of the tag triple for a wheel.
+
+    Instances are considered immutable and thus are hashable. Equality checking
+    is also supported.
+    """
+
+    __slots__ = ["_interpreter", "_abi", "_platform", "_hash"]
+
+    def __init__(self, interpreter: str, abi: str, platform: str) -> None:
+        self._interpreter = interpreter.lower()
+        self._abi = abi.lower()
+        self._platform = platform.lower()
+        # The __hash__ of every single element in a Set[Tag] will be evaluated each time
+        # that a set calls its `.disjoint()` method, which may be called hundreds of
+        # times when scanning a page of links for packages with tags matching that
+        # Set[Tag]. Pre-computing the value here produces significant speedups for
+        # downstream consumers.
+        self._hash = hash((self._interpreter, self._abi, self._platform))
+
+    @property
+    def interpreter(self) -> str:
+        return self._interpreter
+
+    @property
+    def abi(self) -> str:
+        return self._abi
+
+    @property
+    def platform(self) -> str:
+        return self._platform
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Tag):
+            return NotImplemented
+
+        return (
+            (self._hash == other._hash)  # Short-circuit ASAP for perf reasons.
+            and (self._platform == other._platform)
+            and (self._abi == other._abi)
+            and (self._interpreter == other._interpreter)
+        )
+
+    def __hash__(self) -> int:
+        return self._hash
+
+    def __str__(self) -> str:
+        return f"{self._interpreter}-{self._abi}-{self._platform}"
+
+    def __repr__(self) -> str:
+        return f"<{self} @ {id(self)}>"
+
+
+def parse_tag(tag: str) -> FrozenSet[Tag]:
+    """
+    Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances.
+
+    Returning a set is required due to the possibility that the tag is a
+    compressed tag set.
+    """
+    tags = set()
+    interpreters, abis, platforms = tag.split("-")
+    for interpreter in interpreters.split("."):
+        for abi in abis.split("."):
+            for platform_ in platforms.split("."):
+                tags.add(Tag(interpreter, abi, platform_))
+    return frozenset(tags)
+
+
+def _get_config_var(name: str, warn: bool = False) -> Union[int, str, None]:
+    value = sysconfig.get_config_var(name)
+    if value is None and warn:
+        logger.debug(
+            "Config variable '%s' is unset, Python ABI tag may be incorrect", name
+        )
+    return value
+
+
+def _normalize_string(string: str) -> str:
+    return string.replace(".", "_").replace("-", "_")
+
+
+def _abi3_applies(python_version: PythonVersion) -> bool:
+    """
+    Determine if the Python version supports abi3.
+
+    PEP 384 was first implemented in Python 3.2.
+    """
+    return len(python_version) > 1 and tuple(python_version) >= (3, 2)
+
+
+def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> List[str]:
+    py_version = tuple(py_version)  # To allow for version comparison.
+    abis = []
+    version = _version_nodot(py_version[:2])
+    debug = pymalloc = ucs4 = ""
+    with_debug = _get_config_var("Py_DEBUG", warn)
+    has_refcount = hasattr(sys, "gettotalrefcount")
+    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
+    # extension modules is the best option.
+    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692
+    has_ext = "_d.pyd" in EXTENSION_SUFFIXES
+    if with_debug or (with_debug is None and (has_refcount or has_ext)):
+        debug = "d"
+    if py_version < (3, 8):
+        with_pymalloc = _get_config_var("WITH_PYMALLOC", warn)
+        if with_pymalloc or with_pymalloc is None:
+            pymalloc = "m"
+        if py_version < (3, 3):
+            unicode_size = _get_config_var("Py_UNICODE_SIZE", warn)
+            if unicode_size == 4 or (
+                unicode_size is None and sys.maxunicode == 0x10FFFF
+            ):
+                ucs4 = "u"
+    elif debug:
+        # Debug builds can also load "normal" extension modules.
+        # We can also assume no UCS-4 or pymalloc requirement.
+        abis.append(f"cp{version}")
+    abis.insert(
+        0,
+        "cp{version}{debug}{pymalloc}{ucs4}".format(
+            version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4
+        ),
+    )
+    return abis
+
+
+def cpython_tags(
+    python_version: Optional[PythonVersion] = None,
+    abis: Optional[Iterable[str]] = None,
+    platforms: Optional[Iterable[str]] = None,
+    *,
+    warn: bool = False,
+) -> Iterator[Tag]:
+    """
+    Yields the tags for a CPython interpreter.
+
+    The tags consist of:
+    - cp<python_version>-<abi>-<platform>
+    - cp<python_version>-abi3-<platform>
+    - cp<python_version>-none-<platform>
+    - cp<less than python_version>-abi3-<platform>  # Older Python versions down to 3.2.
+
+    If python_version only specifies a major version then user-provided ABIs and
+    the 'none' ABItag will be used.
+
+    If 'abi3' or 'none' are specified in 'abis' then they will be yielded at
+    their normal position and not at the beginning.
+    """
+    if not python_version:
+        python_version = sys.version_info[:2]
+
+    interpreter = f"cp{_version_nodot(python_version[:2])}"
+
+    if abis is None:
+        if len(python_version) > 1:
+            abis = _cpython_abis(python_version, warn)
+        else:
+            abis = []
+    abis = list(abis)
+    # 'abi3' and 'none' are explicitly handled later.
+    for explicit_abi in ("abi3", "none"):
+        try:
+            abis.remove(explicit_abi)
+        except ValueError:
+            pass
+
+    platforms = list(platforms or platform_tags())
+    for abi in abis:
+        for platform_ in platforms:
+            yield Tag(interpreter, abi, platform_)
+    if _abi3_applies(python_version):
+        yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms)
+    yield from (Tag(interpreter, "none", platform_) for platform_ in platforms)
+
+    if _abi3_applies(python_version):
+        for minor_version in range(python_version[1] - 1, 1, -1):
+            for platform_ in platforms:
+                interpreter = "cp{version}".format(
+                    version=_version_nodot((python_version[0], minor_version))
+                )
+                yield Tag(interpreter, "abi3", platform_)
+
+
+def _generic_abi() -> Iterator[str]:
+    abi = sysconfig.get_config_var("SOABI")
+    if abi:
+        yield _normalize_string(abi)
+
+
+def generic_tags(
+    interpreter: Optional[str] = None,
+    abis: Optional[Iterable[str]] = None,
+    platforms: Optional[Iterable[str]] = None,
+    *,
+    warn: bool = False,
+) -> Iterator[Tag]:
+    """
+    Yields the tags for a generic interpreter.
+
+    The tags consist of:
+    - <interpreter>-<abi>-<platform>
+
+    The "none" ABI will be added if it was not explicitly provided.
+    """
+    if not interpreter:
+        interp_name = interpreter_name()
+        interp_version = interpreter_version(warn=warn)
+        interpreter = "".join([interp_name, interp_version])
+    if abis is None:
+        abis = _generic_abi()
+    platforms = list(platforms or platform_tags())
+    abis = list(abis)
+    if "none" not in abis:
+        abis.append("none")
+    for abi in abis:
+        for platform_ in platforms:
+            yield Tag(interpreter, abi, platform_)
+
+
+def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]:
+    """
+    Yields Python versions in descending order.
+
+    After the latest version, the major-only version will be yielded, and then
+    all previous versions of that major version.
+    """
+    if len(py_version) > 1:
+        yield f"py{_version_nodot(py_version[:2])}"
+    yield f"py{py_version[0]}"
+    if len(py_version) > 1:
+        for minor in range(py_version[1] - 1, -1, -1):
+            yield f"py{_version_nodot((py_version[0], minor))}"
+
+
+def compatible_tags(
+    python_version: Optional[PythonVersion] = None,
+    interpreter: Optional[str] = None,
+    platforms: Optional[Iterable[str]] = None,
+) -> Iterator[Tag]:
+    """
+    Yields the sequence of tags that are compatible with a specific version of Python.
+
+    The tags consist of:
+    - py*-none-<platform>
+    - <interpreter>-none-any  # ... if `interpreter` is provided.
+    - py*-none-any
+    """
+    if not python_version:
+        python_version = sys.version_info[:2]
+    platforms = list(platforms or platform_tags())
+    for version in _py_interpreter_range(python_version):
+        for platform_ in platforms:
+            yield Tag(version, "none", platform_)
+    if interpreter:
+        yield Tag(interpreter, "none", "any")
+    for version in _py_interpreter_range(python_version):
+        yield Tag(version, "none", "any")
+
+
+def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str:
+    if not is_32bit:
+        return arch
+
+    if arch.startswith("ppc"):
+        return "ppc"
+
+    return "i386"
+
+
+def _mac_binary_formats(version: MacVersion, cpu_arch: str) -> List[str]:
+    formats = [cpu_arch]
+    if cpu_arch == "x86_64":
+        if version < (10, 4):
+            return []
+        formats.extend(["intel", "fat64", "fat32"])
+
+    elif cpu_arch == "i386":
+        if version < (10, 4):
+            return []
+        formats.extend(["intel", "fat32", "fat"])
+
+    elif cpu_arch == "ppc64":
+        # TODO: Need to care about 32-bit PPC for ppc64 through 10.2?
+        if version > (10, 5) or version < (10, 4):
+            return []
+        formats.append("fat64")
+
+    elif cpu_arch == "ppc":
+        if version > (10, 6):
+            return []
+        formats.extend(["fat32", "fat"])
+
+    if cpu_arch in {"arm64", "x86_64"}:
+        formats.append("universal2")
+
+    if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}:
+        formats.append("universal")
+
+    return formats
+
+
+def mac_platforms(
+    version: Optional[MacVersion] = None, arch: Optional[str] = None
+) -> Iterator[str]:
+    """
+    Yields the platform tags for a macOS system.
+
+    The `version` parameter is a two-item tuple specifying the macOS version to
+    generate platform tags for. The `arch` parameter is the CPU architecture to
+    generate platform tags for. Both parameters default to the appropriate value
+    for the current system.
+    """
+    version_str, _, cpu_arch = platform.mac_ver()
+    if version is None:
+        version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2])))
+    else:
+        version = version
+    if arch is None:
+        arch = _mac_arch(cpu_arch)
+    else:
+        arch = arch
+
+    if (10, 0) <= version and version < (11, 0):
+        # Prior to Mac OS 11, each yearly release of Mac OS bumped the
+        # "minor" version number.  The major version was always 10.
+        for minor_version in range(version[1], -1, -1):
+            compat_version = 10, minor_version
+            binary_formats = _mac_binary_formats(compat_version, arch)
+            for binary_format in binary_formats:
+                yield "macosx_{major}_{minor}_{binary_format}".format(
+                    major=10, minor=minor_version, binary_format=binary_format
+                )
+
+    if version >= (11, 0):
+        # Starting with Mac OS 11, each yearly release bumps the major version
+        # number.   The minor versions are now the midyear updates.
+        for major_version in range(version[0], 10, -1):
+            compat_version = major_version, 0
+            binary_formats = _mac_binary_formats(compat_version, arch)
+            for binary_format in binary_formats:
+                yield "macosx_{major}_{minor}_{binary_format}".format(
+                    major=major_version, minor=0, binary_format=binary_format
+                )
+
+    if version >= (11, 0):
+        # Mac OS 11 on x86_64 is compatible with binaries from previous releases.
+        # Arm64 support was introduced in 11.0, so no Arm binaries from previous
+        # releases exist.
+        #
+        # However, the "universal2" binary format can have a
+        # macOS version earlier than 11.0 when the x86_64 part of the binary supports
+        # that version of macOS.
+        if arch == "x86_64":
+            for minor_version in range(16, 3, -1):
+                compat_version = 10, minor_version
+                binary_formats = _mac_binary_formats(compat_version, arch)
+                for binary_format in binary_formats:
+                    yield "macosx_{major}_{minor}_{binary_format}".format(
+                        major=compat_version[0],
+                        minor=compat_version[1],
+                        binary_format=binary_format,
+                    )
+        else:
+            for minor_version in range(16, 3, -1):
+                compat_version = 10, minor_version
+                binary_format = "universal2"
+                yield "macosx_{major}_{minor}_{binary_format}".format(
+                    major=compat_version[0],
+                    minor=compat_version[1],
+                    binary_format=binary_format,
+                )
+
+
+def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]:
+    linux = _normalize_string(sysconfig.get_platform())
+    if is_32bit:
+        if linux == "linux_x86_64":
+            linux = "linux_i686"
+        elif linux == "linux_aarch64":
+            linux = "linux_armv7l"
+    _, arch = linux.split("_", 1)
+    yield from _manylinux.platform_tags(linux, arch)
+    yield from _musllinux.platform_tags(arch)
+    yield linux
+
+
+def _generic_platforms() -> Iterator[str]:
+    yield _normalize_string(sysconfig.get_platform())
+
+
+def platform_tags() -> Iterator[str]:
+    """
+    Provides the platform tags for this installation.
+    """
+    if platform.system() == "Darwin":
+        return mac_platforms()
+    elif platform.system() == "Linux":
+        return _linux_platforms()
+    else:
+        return _generic_platforms()
+
+
+def interpreter_name() -> str:
+    """
+    Returns the name of the running interpreter.
+    """
+    name = sys.implementation.name
+    return INTERPRETER_SHORT_NAMES.get(name) or name
+
+
+def interpreter_version(*, warn: bool = False) -> str:
+    """
+    Returns the version of the running interpreter.
+    """
+    version = _get_config_var("py_version_nodot", warn=warn)
+    if version:
+        version = str(version)
+    else:
+        version = _version_nodot(sys.version_info[:2])
+    return version
+
+
+def _version_nodot(version: PythonVersion) -> str:
+    return "".join(map(str, version))
+
+
+def sys_tags(*, warn: bool = False) -> Iterator[Tag]:
+    """
+    Returns the sequence of tag triples for the running interpreter.
+
+    The order of the sequence corresponds to priority order for the
+    interpreter, from most to least important.
+    """
+
+    interp_name = interpreter_name()
+    if interp_name == "cp":
+        yield from cpython_tags(warn=warn)
+    else:
+        yield from generic_tags()
+
+    if interp_name == "pp":
+        yield from compatible_tags(interpreter="pp3")
+    else:
+        yield from compatible_tags()
diff --git a/myenv/lib/python3.9/site-packages/packaging/utils.py b/myenv/lib/python3.9/site-packages/packaging/utils.py
new file mode 100644
index 0000000..bab11b8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging/utils.py
@@ -0,0 +1,136 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import re
+from typing import FrozenSet, NewType, Tuple, Union, cast
+
+from .tags import Tag, parse_tag
+from .version import InvalidVersion, Version
+
+BuildTag = Union[Tuple[()], Tuple[int, str]]
+NormalizedName = NewType("NormalizedName", str)
+
+
+class InvalidWheelFilename(ValueError):
+    """
+    An invalid wheel filename was found, users should refer to PEP 427.
+    """
+
+
+class InvalidSdistFilename(ValueError):
+    """
+    An invalid sdist filename was found, users should refer to the packaging user guide.
+    """
+
+
+_canonicalize_regex = re.compile(r"[-_.]+")
+# PEP 427: The build number must start with a digit.
+_build_tag_regex = re.compile(r"(\d+)(.*)")
+
+
+def canonicalize_name(name: str) -> NormalizedName:
+    # This is taken from PEP 503.
+    value = _canonicalize_regex.sub("-", name).lower()
+    return cast(NormalizedName, value)
+
+
+def canonicalize_version(version: Union[Version, str]) -> str:
+    """
+    This is very similar to Version.__str__, but has one subtle difference
+    with the way it handles the release segment.
+    """
+    if isinstance(version, str):
+        try:
+            parsed = Version(version)
+        except InvalidVersion:
+            # Legacy versions cannot be normalized
+            return version
+    else:
+        parsed = version
+
+    parts = []
+
+    # Epoch
+    if parsed.epoch != 0:
+        parts.append(f"{parsed.epoch}!")
+
+    # Release segment
+    # NB: This strips trailing '.0's to normalize
+    parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in parsed.release)))
+
+    # Pre-release
+    if parsed.pre is not None:
+        parts.append("".join(str(x) for x in parsed.pre))
+
+    # Post-release
+    if parsed.post is not None:
+        parts.append(f".post{parsed.post}")
+
+    # Development release
+    if parsed.dev is not None:
+        parts.append(f".dev{parsed.dev}")
+
+    # Local version segment
+    if parsed.local is not None:
+        parts.append(f"+{parsed.local}")
+
+    return "".join(parts)
+
+
+def parse_wheel_filename(
+    filename: str,
+) -> Tuple[NormalizedName, Version, BuildTag, FrozenSet[Tag]]:
+    if not filename.endswith(".whl"):
+        raise InvalidWheelFilename(
+            f"Invalid wheel filename (extension must be '.whl'): {filename}"
+        )
+
+    filename = filename[:-4]
+    dashes = filename.count("-")
+    if dashes not in (4, 5):
+        raise InvalidWheelFilename(
+            f"Invalid wheel filename (wrong number of parts): {filename}"
+        )
+
+    parts = filename.split("-", dashes - 2)
+    name_part = parts[0]
+    # See PEP 427 for the rules on escaping the project name
+    if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None:
+        raise InvalidWheelFilename(f"Invalid project name: {filename}")
+    name = canonicalize_name(name_part)
+    version = Version(parts[1])
+    if dashes == 5:
+        build_part = parts[2]
+        build_match = _build_tag_regex.match(build_part)
+        if build_match is None:
+            raise InvalidWheelFilename(
+                f"Invalid build number: {build_part} in '{filename}'"
+            )
+        build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2)))
+    else:
+        build = ()
+    tags = parse_tag(parts[-1])
+    return (name, version, build, tags)
+
+
+def parse_sdist_filename(filename: str) -> Tuple[NormalizedName, Version]:
+    if filename.endswith(".tar.gz"):
+        file_stem = filename[: -len(".tar.gz")]
+    elif filename.endswith(".zip"):
+        file_stem = filename[: -len(".zip")]
+    else:
+        raise InvalidSdistFilename(
+            f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):"
+            f" {filename}"
+        )
+
+    # We are requiring a PEP 440 version, which cannot contain dashes,
+    # so we split on the last dash.
+    name_part, sep, version_part = file_stem.rpartition("-")
+    if not sep:
+        raise InvalidSdistFilename(f"Invalid sdist filename: {filename}")
+
+    name = canonicalize_name(name_part)
+    version = Version(version_part)
+    return (name, version)
diff --git a/myenv/lib/python3.9/site-packages/packaging/version.py b/myenv/lib/python3.9/site-packages/packaging/version.py
new file mode 100644
index 0000000..de9a09a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/packaging/version.py
@@ -0,0 +1,504 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import collections
+import itertools
+import re
+import warnings
+from typing import Callable, Iterator, List, Optional, SupportsInt, Tuple, Union
+
+from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType
+
+__all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"]
+
+InfiniteTypes = Union[InfinityType, NegativeInfinityType]
+PrePostDevType = Union[InfiniteTypes, Tuple[str, int]]
+SubLocalType = Union[InfiniteTypes, int, str]
+LocalType = Union[
+    NegativeInfinityType,
+    Tuple[
+        Union[
+            SubLocalType,
+            Tuple[SubLocalType, str],
+            Tuple[NegativeInfinityType, SubLocalType],
+        ],
+        ...,
+    ],
+]
+CmpKey = Tuple[
+    int, Tuple[int, ...], PrePostDevType, PrePostDevType, PrePostDevType, LocalType
+]
+LegacyCmpKey = Tuple[int, Tuple[str, ...]]
+VersionComparisonMethod = Callable[
+    [Union[CmpKey, LegacyCmpKey], Union[CmpKey, LegacyCmpKey]], bool
+]
+
+_Version = collections.namedtuple(
+    "_Version", ["epoch", "release", "dev", "pre", "post", "local"]
+)
+
+
+def parse(version: str) -> Union["LegacyVersion", "Version"]:
+    """
+    Parse the given version string and return either a :class:`Version` object
+    or a :class:`LegacyVersion` object depending on if the given version is
+    a valid PEP 440 version or a legacy version.
+    """
+    try:
+        return Version(version)
+    except InvalidVersion:
+        return LegacyVersion(version)
+
+
+class InvalidVersion(ValueError):
+    """
+    An invalid version was found, users should refer to PEP 440.
+    """
+
+
+class _BaseVersion:
+    _key: Union[CmpKey, LegacyCmpKey]
+
+    def __hash__(self) -> int:
+        return hash(self._key)
+
+    # Please keep the duplicated `isinstance` check
+    # in the six comparisons hereunder
+    # unless you find a way to avoid adding overhead function calls.
+    def __lt__(self, other: "_BaseVersion") -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+
+        return self._key < other._key
+
+    def __le__(self, other: "_BaseVersion") -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+
+        return self._key <= other._key
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+
+        return self._key == other._key
+
+    def __ge__(self, other: "_BaseVersion") -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+
+        return self._key >= other._key
+
+    def __gt__(self, other: "_BaseVersion") -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+
+        return self._key > other._key
+
+    def __ne__(self, other: object) -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+
+        return self._key != other._key
+
+
+class LegacyVersion(_BaseVersion):
+    def __init__(self, version: str) -> None:
+        self._version = str(version)
+        self._key = _legacy_cmpkey(self._version)
+
+        warnings.warn(
+            "Creating a LegacyVersion has been deprecated and will be "
+            "removed in the next major release",
+            DeprecationWarning,
+        )
+
+    def __str__(self) -> str:
+        return self._version
+
+    def __repr__(self) -> str:
+        return f"<LegacyVersion('{self}')>"
+
+    @property
+    def public(self) -> str:
+        return self._version
+
+    @property
+    def base_version(self) -> str:
+        return self._version
+
+    @property
+    def epoch(self) -> int:
+        return -1
+
+    @property
+    def release(self) -> None:
+        return None
+
+    @property
+    def pre(self) -> None:
+        return None
+
+    @property
+    def post(self) -> None:
+        return None
+
+    @property
+    def dev(self) -> None:
+        return None
+
+    @property
+    def local(self) -> None:
+        return None
+
+    @property
+    def is_prerelease(self) -> bool:
+        return False
+
+    @property
+    def is_postrelease(self) -> bool:
+        return False
+
+    @property
+    def is_devrelease(self) -> bool:
+        return False
+
+
+_legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE)
+
+_legacy_version_replacement_map = {
+    "pre": "c",
+    "preview": "c",
+    "-": "final-",
+    "rc": "c",
+    "dev": "@",
+}
+
+
+def _parse_version_parts(s: str) -> Iterator[str]:
+    for part in _legacy_version_component_re.split(s):
+        part = _legacy_version_replacement_map.get(part, part)
+
+        if not part or part == ".":
+            continue
+
+        if part[:1] in "0123456789":
+            # pad for numeric comparison
+            yield part.zfill(8)
+        else:
+            yield "*" + part
+
+    # ensure that alpha/beta/candidate are before final
+    yield "*final"
+
+
+def _legacy_cmpkey(version: str) -> LegacyCmpKey:
+
+    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
+    # greater than or equal to 0. This will effectively put the LegacyVersion,
+    # which uses the defacto standard originally implemented by setuptools,
+    # as before all PEP 440 versions.
+    epoch = -1
+
+    # This scheme is taken from pkg_resources.parse_version setuptools prior to
+    # it's adoption of the packaging library.
+    parts: List[str] = []
+    for part in _parse_version_parts(version.lower()):
+        if part.startswith("*"):
+            # remove "-" before a prerelease tag
+            if part < "*final":
+                while parts and parts[-1] == "*final-":
+                    parts.pop()
+
+            # remove trailing zeros from each series of numeric parts
+            while parts and parts[-1] == "00000000":
+                parts.pop()
+
+        parts.append(part)
+
+    return epoch, tuple(parts)
+
+
+# Deliberately not anchored to the start and end of the string, to make it
+# easier for 3rd party code to reuse
+VERSION_PATTERN = r"""
+    v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
+        (?P<pre>                                          # pre-release
+            [-_\.]?
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>                                         # post release
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>                                          # dev release
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+
+
+class Version(_BaseVersion):
+
+    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    def __init__(self, version: str) -> None:
+
+        # Validate the version and parse it into pieces
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion(f"Invalid version: '{version}'")
+
+        # Store the parsed out pieces of the version
+        self._version = _Version(
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+            release=tuple(int(i) for i in match.group("release").split(".")),
+            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
+            post=_parse_letter_version(
+                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
+            ),
+            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
+            local=_parse_local_version(match.group("local")),
+        )
+
+        # Generate a key which will be used for sorting
+        self._key = _cmpkey(
+            self._version.epoch,
+            self._version.release,
+            self._version.pre,
+            self._version.post,
+            self._version.dev,
+            self._version.local,
+        )
+
+    def __repr__(self) -> str:
+        return f"<Version('{self}')>"
+
+    def __str__(self) -> str:
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append(f"{self.epoch}!")
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        # Pre-release
+        if self.pre is not None:
+            parts.append("".join(str(x) for x in self.pre))
+
+        # Post-release
+        if self.post is not None:
+            parts.append(f".post{self.post}")
+
+        # Development release
+        if self.dev is not None:
+            parts.append(f".dev{self.dev}")
+
+        # Local version segment
+        if self.local is not None:
+            parts.append(f"+{self.local}")
+
+        return "".join(parts)
+
+    @property
+    def epoch(self) -> int:
+        _epoch: int = self._version.epoch
+        return _epoch
+
+    @property
+    def release(self) -> Tuple[int, ...]:
+        _release: Tuple[int, ...] = self._version.release
+        return _release
+
+    @property
+    def pre(self) -> Optional[Tuple[str, int]]:
+        _pre: Optional[Tuple[str, int]] = self._version.pre
+        return _pre
+
+    @property
+    def post(self) -> Optional[int]:
+        return self._version.post[1] if self._version.post else None
+
+    @property
+    def dev(self) -> Optional[int]:
+        return self._version.dev[1] if self._version.dev else None
+
+    @property
+    def local(self) -> Optional[str]:
+        if self._version.local:
+            return ".".join(str(x) for x in self._version.local)
+        else:
+            return None
+
+    @property
+    def public(self) -> str:
+        return str(self).split("+", 1)[0]
+
+    @property
+    def base_version(self) -> str:
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append(f"{self.epoch}!")
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        return "".join(parts)
+
+    @property
+    def is_prerelease(self) -> bool:
+        return self.dev is not None or self.pre is not None
+
+    @property
+    def is_postrelease(self) -> bool:
+        return self.post is not None
+
+    @property
+    def is_devrelease(self) -> bool:
+        return self.dev is not None
+
+    @property
+    def major(self) -> int:
+        return self.release[0] if len(self.release) >= 1 else 0
+
+    @property
+    def minor(self) -> int:
+        return self.release[1] if len(self.release) >= 2 else 0
+
+    @property
+    def micro(self) -> int:
+        return self.release[2] if len(self.release) >= 3 else 0
+
+
+def _parse_letter_version(
+    letter: str, number: Union[str, bytes, SupportsInt]
+) -> Optional[Tuple[str, int]]:
+
+    if letter:
+        # We consider there to be an implicit 0 in a pre-release if there is
+        # not a numeral associated with it.
+        if number is None:
+            number = 0
+
+        # We normalize any letters to their lower case form
+        letter = letter.lower()
+
+        # We consider some words to be alternate spellings of other words and
+        # in those cases we want to normalize the spellings to our preferred
+        # spelling.
+        if letter == "alpha":
+            letter = "a"
+        elif letter == "beta":
+            letter = "b"
+        elif letter in ["c", "pre", "preview"]:
+            letter = "rc"
+        elif letter in ["rev", "r"]:
+            letter = "post"
+
+        return letter, int(number)
+    if not letter and number:
+        # We assume if we are given a number, but we are not given a letter
+        # then this is using the implicit post release syntax (e.g. 1.0-1)
+        letter = "post"
+
+        return letter, int(number)
+
+    return None
+
+
+_local_version_separators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local: str) -> Optional[LocalType]:
+    """
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+    """
+    if local is not None:
+        return tuple(
+            part.lower() if not part.isdigit() else int(part)
+            for part in _local_version_separators.split(local)
+        )
+    return None
+
+
+def _cmpkey(
+    epoch: int,
+    release: Tuple[int, ...],
+    pre: Optional[Tuple[str, int]],
+    post: Optional[Tuple[str, int]],
+    dev: Optional[Tuple[str, int]],
+    local: Optional[Tuple[SubLocalType]],
+) -> CmpKey:
+
+    # When we compare a release version, we want to compare it with all of the
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now
+    # leading zeros until we come to something non zero, then take the rest
+    # re-reverse it back into the correct order and make it a tuple and use
+    # that for our sorting key.
+    _release = tuple(
+        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
+    )
+
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+    # We'll do this by abusing the pre segment, but we _only_ want to do this
+    # if there is not a pre or a post segment. If we have one of those then
+    # the normal sorting rules will handle this case correctly.
+    if pre is None and post is None and dev is not None:
+        _pre: PrePostDevType = NegativeInfinity
+    # Versions without a pre-release (except as noted above) should sort after
+    # those with one.
+    elif pre is None:
+        _pre = Infinity
+    else:
+        _pre = pre
+
+    # Versions without a post segment should sort before those with one.
+    if post is None:
+        _post: PrePostDevType = NegativeInfinity
+
+    else:
+        _post = post
+
+    # Versions without a development segment should sort after those with one.
+    if dev is None:
+        _dev: PrePostDevType = Infinity
+
+    else:
+        _dev = dev
+
+    if local is None:
+        # Versions without a local segment should sort before those with one.
+        _local: LocalType = NegativeInfinity
+    else:
+        # Versions with a local segment need that segment parsed to implement
+        # the sorting rules in PEP440.
+        # - Alpha numeric segments sort before numeric segments
+        # - Alpha numeric segments sort lexicographically
+        # - Numeric segments sort numerically
+        # - Shorter versions sort before longer versions when the prefixes
+        #   match exactly
+        _local = tuple(
+            (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
+        )
+
+    return epoch, _release, _pre, _post, _dev, _local
diff --git a/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/LICENSE
new file mode 100644
index 0000000..48c0f72
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/LICENSE
@@ -0,0 +1,116 @@
+.. -*- restructuredtext -*-
+
+=====================
+Copyrights & Licenses
+=====================
+
+Credits
+=======
+Passlib is primarily developed by Eli Collins.
+
+Special thanks to Darin Gordon for testing and
+feedback on the :mod:`passlib.totp` module.
+
+License for Passlib
+===================
+Passlib is (c) `Assurance Technologies <http://www.assurancetechnologies.com>`_,
+and is released under the `BSD license <http://www.opensource.org/licenses/bsd-license.php>`_::
+
+    Passlib
+    Copyright (c) 2008-2020 Assurance Technologies, LLC.
+    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 Assurance Technologies, nor the names of the
+      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.
+
+Licenses for incorporated software
+==================================
+Passlib contains some code derived from the following sources:
+
+MD5-Crypt
+---------
+The source file ``passlib/handlers/md5_crypt.py`` contains code derived from the original
+`FreeBSD md5-crypt implementation <http://www.freebsd.org/cgi/cvsweb.cgi/~checkout~/src/lib/libcrypt/crypt.c?rev=1.2>`_,
+which is available under the following license::
+
+    "THE BEER-WARE LICENSE" (Revision 42):
+    <phk@login.dknet.dk> wrote this file.  As long as you retain this notice you
+    can do whatever you want with this stuff. If we meet some day, and you think
+    this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+
+    converted to python May 2008
+    by Eli Collins
+
+DES
+---
+The source file ``passlib/crypto/des.py`` contains code derived from
+`UnixCrypt.java <http://www.dynamic.net.au/christos/crypt/UnixCrypt2.txt>`_,
+a pure-java implementation of the historic unix-crypt password hash algorithm.
+It is available under the following license::
+
+    UnixCrypt.java 0.9 96/11/25
+    Copyright (c) 1996 Aki Yoshida. All rights reserved.
+    Permission to use, copy, modify and distribute this software
+    for non-commercial or commercial purposes and without fee is
+    hereby granted provided that this copyright notice appears in
+    all copies.
+
+    modified April 2001
+    by Iris Van den Broeke, Daniel Deville
+
+    modified Aug 2005
+    by Greg Wilkins (gregw)
+
+    converted to python Jun 2009
+    by Eli Collins
+
+jBCrypt
+-------
+The source file ``passlib/crypto/_blowfish/base.py`` contains code derived
+from `jBcrypt 0.2 <http://www.mindrot.org/projects/jBCrypt/>`_, a Java
+implementation of the BCrypt password hash algorithm. It is available under
+a BSD/ISC license::
+
+    Copyright (c) 2006 Damien Miller <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 TORTUOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+Wordsets
+--------
+The EFF wordsets in ``passlib/_data/wordsets`` are (c) 2016 the Electronic Freedom Foundation.
+They were downloaded from `<https://www.eff.org/deeplinks/2016/07/new-wordlists-random-passphrases>`_,
+and are released under the `Creative Commons License <https://www.eff.org/copyright>`_.
diff --git a/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/METADATA b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/METADATA
new file mode 100644
index 0000000..0665d8a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/METADATA
@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: passlib
+Version: 1.7.4
+Summary: comprehensive password hashing framework supporting over 30 schemes
+Home-page: https://passlib.readthedocs.io
+Author: Eli Collins
+Author-email: elic@assurancetechnologies.com
+License: BSD
+Download-URL: https://pypi.python.org/packages/source/p/passlib/passlib-1.7.4.tar.gz
+Keywords: password secret hash security
+Provides-Extra: argon2
+Requires-Dist: argon2-cffi (>=18.2.0) ; extra == 'argon2'
+Provides-Extra: bcrypt
+Requires-Dist: bcrypt (>=3.1.0) ; extra == 'bcrypt'
+Provides-Extra: build_docs
+Requires-Dist: sphinx (>=1.6) ; extra == 'build_docs'
+Requires-Dist: sphinxcontrib-fulltoc (>=1.2.0) ; extra == 'build_docs'
+Requires-Dist: cloud-sptheme (>=1.10.1) ; extra == 'build_docs'
+Provides-Extra: totp
+Requires-Dist: cryptography ; extra == 'totp'
+
+Passlib is a password hashing library for Python 2 & 3, which provides
+cross-platform implementations of over 30 password hashing algorithms, as well
+as a framework for managing existing password hashes. It's designed to be useful
+for a wide range of tasks, from verifying a hash found in /etc/shadow, to
+providing full-strength password hashing for multi-user applications.
+
+* See the `documentation <https://passlib.readthedocs.io>`_
+  for details, installation instructions, and examples.
+
+* See the `homepage <https://foss.heptapod.net/python-libs/passlib/wikis/home>`_
+  for the latest news and more information.
+
+* See the `changelog <https://passlib.readthedocs.io/en/stable/history>`_
+  for a description of what's new in Passlib.
+
+All releases are signed with the gpg key
+`4D8592DF4CE1ED31 <http://pgp.mit.edu:11371/pks/lookup?op=get&search=0x4D8592DF4CE1ED31>`_.
+
+
diff --git a/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/RECORD b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/RECORD
new file mode 100644
index 0000000..6c487f4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/RECORD
@@ -0,0 +1,108 @@
+passlib/__init__.py,sha256=nSZrPEtlMQSKZqxERmYcWCDBD6pJ1P_DL5TdeSjIReU,87
+passlib/apache.py,sha256=TsHUCur5W8tK3Rsb9jYeeBCc7Ua_hP9e2tSxzoUVzwc,46661
+passlib/apps.py,sha256=AYqni3QIelR7HCiPj_hv2Mcr8bsfdcUkh07DwQqZxWs,8067
+passlib/context.py,sha256=aJeTjA-h7ke3KObvEM8aSJzKdN3wrOyu0hTt-MTbJt0,109195
+passlib/exc.py,sha256=MIjUTBLcOai52paDLM1nFh6lMTLBLPAn1PTdbCm-9Fo,14481
+passlib/hash.py,sha256=9lVasGFiXDGcL8VOWuEwAjzlATQbmEYF30wOIVotP-U,3750
+passlib/hosts.py,sha256=odRo2WnSfjMuktSIwfR50rzxbKGfzUwZ2CUkvcxvJoA,3302
+passlib/ifc.py,sha256=kL2svtkF99VQDOim_6TE6OGhmSf2EyHrzp0v_UQksqA,14196
+passlib/pwd.py,sha256=VeU_PVkZSvwXPI6AQA96cjqIKyuTvXtUoCK7eI5ab7w,28690
+passlib/registry.py,sha256=5qLDF72XHGSQVoEVqhvEngfZsO2fxVsBpWntX_D0YRs,20301
+passlib/totp.py,sha256=Wryr57req8NFJnw1fI_eycCaTwmSY8WA7Z3OFjAwHOE,73033
+passlib/win32.py,sha256=E6Ca-4Ki5ZlCSzd86N1CXjh-xQoJYjW-74-kJ6VsHUU,2591
+passlib/_data/wordsets/bip39.txt,sha256=JM5Cwv1KlcG4a77pvOHhzyVb0AIuGbq2vVka_Wi379s,13117
+passlib/_data/wordsets/eff_long.txt,sha256=bVV_BpOVj7XmULaLW-5YXrgs9NoyllUFx4npJHQ7xSI,62144
+passlib/_data/wordsets/eff_prefixed.txt,sha256=eqV6TT7PZYFymZK62VdbrN6_fCg3ivKuxqUPEa7DJvU,10778
+passlib/_data/wordsets/eff_short.txt,sha256=NuzKSeT6IMqEsXbDLy6cgvmPRGWFGQ51-YealcCCR78,7180
+passlib/crypto/__init__.py,sha256=St6CGqhrfz3L5Da3aZvRK69le_FcLLE3gA2dEByOmC0,84
+passlib/crypto/_md4.py,sha256=_5RXBX_gowtN0x05PnN0EF_csO4Q_NA5whm6e_vJx08,6905
+passlib/crypto/des.py,sha256=1EsvVd34Z82BYmGb8JIzfVWvTMN70fWhJGmIfmNrBAU,51878
+passlib/crypto/digest.py,sha256=WsfpcC8IM-gvZh56m6v8bjzG4nsNAsaoSv2LNY1_5go,36158
+passlib/crypto/_blowfish/__init__.py,sha256=iZb7ft1vxBjCW7lpDtWwTxuMicgvi673M5F_1PKdVkg,6426
+passlib/crypto/_blowfish/_gen_files.py,sha256=fUrNGWA5NX9CyvoJbNhJv7PJmptbp1uSR9iaWzKkb1I,6176
+passlib/crypto/_blowfish/base.py,sha256=_zF7x6XSbqCl2HH5Eya8KIhhJVbDYuYAWKfxbjOQZWg,20390
+passlib/crypto/_blowfish/unrolled.py,sha256=FOMhVo_jnGS3bMafXfjEffDPSP5vMogFvupnVKAa1lg,37153
+passlib/crypto/scrypt/__init__.py,sha256=bXmeIerN6DKJSw8XsQEYcsUKCfRpXGb190e-gdHbbqU,9630
+passlib/crypto/scrypt/_builtin.py,sha256=82RZc_4LQv2JCL06bX70hCICBaK30Uy7PGzmZtiOjA0,8910
+passlib/crypto/scrypt/_gen_files.py,sha256=vRhjlIKqwvcILCo20sVf8dXr15tW636t5oojAZFssJE,4683
+passlib/crypto/scrypt/_salsa.py,sha256=b87_YEP3jJSmlU2BHSx-NKiJ4e_1eK-RlC4pWA4y71I,5719
+passlib/ext/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+passlib/ext/django/__init__.py,sha256=RvooHmuUwjLXuSuUJr-9URnY1CRVCzU2xdh-jW-mrN0,228
+passlib/ext/django/models.py,sha256=-XpQRLGG2kTuLWNoh-EhKOaeEV5aIfzavw8qTQ-p1fM,1314
+passlib/ext/django/utils.py,sha256=ObpILR1seOZyecYhuQ1G_R9_N6DMuS4kWZve_giRLiw,49409
+passlib/handlers/__init__.py,sha256=sIPjJgOGHpOIstAwDeHTfxKR8wLVqP4zSa4mvBhAZ_8,86
+passlib/handlers/argon2.py,sha256=XrMPknuG-16IAwrd7WUuTKdIkKOD-3UPlHHZOjXZe68,38934
+passlib/handlers/bcrypt.py,sha256=LF33HnoxOhjtr7aFtrKgU5SB4mtw3xGx7C4tqecosrk,53582
+passlib/handlers/cisco.py,sha256=Yz0KhmqVVAV_szNnuZq40WgYg6eomBRoAJBbRrSUkGg,16284
+passlib/handlers/des_crypt.py,sha256=W3srE5kIaRQdhfIObz237sm0vPgqR4p_9ZkSd-9UNPo,22367
+passlib/handlers/digests.py,sha256=AeuVSxas2793ILXX0s6xm1lA1u4RPpE9G8wZSaq0Bs4,6327
+passlib/handlers/django.py,sha256=MmoLua6kZWVItsjRrnDgfktzuEpqlvwlPaexvti6I9M,20185
+passlib/handlers/fshp.py,sha256=78sMdnAkW5YHCPC13bLptdElLFrWzZF7rm3bwUWHATo,7799
+passlib/handlers/ldap_digests.py,sha256=jgxtxcERep4xXgVVfKfSVe5JEE45b5tt87NKGvK9_Zk,13049
+passlib/handlers/md5_crypt.py,sha256=jLt3IP-l0HFfU1u2VEtGI1WBYVNjTqhjvwovfFREiwg,13740
+passlib/handlers/misc.py,sha256=o1tWKAdTp3EnCYJOERpdkQnRwrQfWWKeiJXSQurbVMo,10109
+passlib/handlers/mssql.py,sha256=BECU0VaVtc-RzhGx7E_LVu2moZpEI5GASChFJnzDVxA,8482
+passlib/handlers/mysql.py,sha256=8h83lpTHs5q8zflXP0TyMavrELgtlvgUbcLtFUHnbDY,4796
+passlib/handlers/oracle.py,sha256=WDCqJEo2rDihcuUs4Ka48JBpSm4_JnNqXIVsCGUrkO8,6691
+passlib/handlers/pbkdf2.py,sha256=jVqdo1MSD3_7B5m-osqUTBTwTXnhedLan9lQaM-gysU,19010
+passlib/handlers/phpass.py,sha256=0c7maDUNGxIuyiG_O2hK6MJbxcTu7V2vx67xOq8d7ps,4785
+passlib/handlers/postgres.py,sha256=y9AzGpxjK-z1HLHElRQtLzCMqqtvBwd_xxJraHdGpN4,2274
+passlib/handlers/roundup.py,sha256=lvYArKerC702_MHZXMi3F-iZ9Y2jH10h2UXKDpgqoO8,1178
+passlib/handlers/scram.py,sha256=wBsoBg0qLW8HA5Nsgcnd1bM7ZDYEFbapAGoP0_44N58,22539
+passlib/handlers/scrypt.py,sha256=OYfF2Jjltydr5BswyZ-uFgl4yEjQZowGdIZpEyB7s5Q,14146
+passlib/handlers/sha1_crypt.py,sha256=DZOdKExzlucHCfpgszG1cFdareTqpGUGORNIEn4FJCs,5873
+passlib/handlers/sha2_crypt.py,sha256=kTZm-jmRVnKRhquetVBbiDWi9eY87NTJvUYkjGEm7MY,21800
+passlib/handlers/sun_md5_crypt.py,sha256=uWhoKxBITVwPlh9MIQ3WjVrYjlRMgLrBjLR1Ui2kmZw,13933
+passlib/handlers/windows.py,sha256=nviGebFjOiJO_cDJRo7RiccEhlN2UM7nAQL0pTso9MQ,12384
+passlib/tests/__init__.py,sha256=JIK29mBP8OKz3ChmaEbyr9vvml3weGe7YHMTHzBJcr0,20
+passlib/tests/__main__.py,sha256=iKv9ZuQe5jBzp4Gyp_G3wXhQBxSTJguMx1BCCVVZL6Y,82
+passlib/tests/_test_bad_register.py,sha256=yws8uO2HsUWg8GRQPlxKvE5HniP84QSQW6ncCPiZDpw,541
+passlib/tests/backports.py,sha256=QTi9tD9DO_RlawkInpPDsFaol--5hsMI-cFvwLIE9B0,2593
+passlib/tests/sample1.cfg,sha256=lJsayArbi6FElINzcTQ1VbgTTGY5LKpMdbCJvK_6H8s,243
+passlib/tests/sample1b.cfg,sha256=2ZQnnpumQsEJpKFsTOHuv_ULhQY5PhQPnsa2rSZmTEU,252
+passlib/tests/sample1c.cfg,sha256=u-BGMklAN05efndzADJfFV9gP1Jbns1gDdwC__VfW-8,490
+passlib/tests/sample_config_1s.cfg,sha256=mMgYjX_UvxVVLFTfZ4m-vxVo31MbSNrZA0R7VY6DzTk,238
+passlib/tests/test_apache.py,sha256=_XhDKgV1nON4ddQQU3GdUfSXrwY_x2OoJQ6l7w2Gzbw,29432
+passlib/tests/test_apps.py,sha256=6MrGeFenjSACzbAtp6jf3PNHoITv_v5DbT_7nhrR-KA,5281
+passlib/tests/test_context.py,sha256=Vsl2hhouEi3yn4_J7J10E09OotLneRHzkAY_jS16F08,74546
+passlib/tests/test_context_deprecated.py,sha256=cVXqcPx_Xqlsh6QF2az34RY23wP3pv8SOBbJFQn65Jg,29282
+passlib/tests/test_crypto_builtin_md4.py,sha256=5PWKh1HoQKC4gI4BcgVDh89xw7lix0R1n9Jn0Y8t8mQ,5660
+passlib/tests/test_crypto_des.py,sha256=0xWgS74G6ygl7gIvF6uhjcoThVTt1TqIH4ZUeqXbVmA,8874
+passlib/tests/test_crypto_digest.py,sha256=b15XIFLDUsjsaxPEQUJkb-csM65IRz_9glwZz7qwN7U,20478
+passlib/tests/test_crypto_scrypt.py,sha256=xJDU3e4bt9N1X0fA9zBLBxESk3PsTR89qJeEWNX2Em4,26646
+passlib/tests/test_ext_django.py,sha256=QUKoa6rLn3hbCVNk7_0z9JW5aOFmyLbBwj0PiWhQJ7s,41364
+passlib/tests/test_ext_django_source.py,sha256=AW-PQRQeLz2cOpKGPeKPLSESC4o-ATbu3-Zd45Coi3k,11034
+passlib/tests/test_handlers.py,sha256=WxYhRTthTzDj-FIP2vS_mH0nlpjgrWOp2C-h3mN6DzE,68622
+passlib/tests/test_handlers_argon2.py,sha256=bSNARahGKPZTawLq-qhVdcuvprCDTNXGWPhSh8aRyaY,22837
+passlib/tests/test_handlers_bcrypt.py,sha256=izOVd0WthIi90YKkvskrW5DZPMMCvO2qtwRkefvgkdY,29549
+passlib/tests/test_handlers_cisco.py,sha256=TLvuGQZygEZbjA01t1hfGfBvx3THnv6ZwbNQCKUhsuI,20471
+passlib/tests/test_handlers_django.py,sha256=ADphUgbG9PwoXQPFbEAPeIDfqjK6DENl_wizP52wYSE,15538
+passlib/tests/test_handlers_pbkdf2.py,sha256=vDM9ipts9EYoauheNHtOOYq0Nl8-9ltTML4gnw2EB2g,18788
+passlib/tests/test_handlers_scrypt.py,sha256=wHsbgoV5xhY4SQtgWFCuit3lygkNvd0AQKZ0lmp72do,4188
+passlib/tests/test_hosts.py,sha256=n0gCywmbsw8q8p4WLp-AlQrQuPfe-29fYwUfWwXi4Co,3906
+passlib/tests/test_pwd.py,sha256=Si9qFDXwkbjTsJ9wQTYe-QhlprVoMQ2E79-eX11FPBk,7190
+passlib/tests/test_registry.py,sha256=9BgXvMhHKQQHBGdgV4WyDDZUboUh0tbHYdgPYr1upSo,9246
+passlib/tests/test_totp.py,sha256=T1o3B97SltvC1OKweXQpX1bBGf6KYQnMl8jcpBSg5DU,65746
+passlib/tests/test_utils.py,sha256=yMWrrnsMIg8b8guyzRK8lDJ243rul6ANhrIgImGlyVI,46118
+passlib/tests/test_utils_handlers.py,sha256=rVSuaNqRUb4Q520nVD4C5smzVs-LdFqQjFZMDRTz-zU,32134
+passlib/tests/test_utils_md4.py,sha256=CfQor3ZfV2JO_8x2RxY5Tl5ZsS0hDvIje46cLvLN5Ew,1474
+passlib/tests/test_utils_pbkdf2.py,sha256=gIhycQf4NUNd5yjUrtKfRm3eqqpklS9W2B7-8INp4Cg,12193
+passlib/tests/test_win32.py,sha256=BXVpHSm71ePXmmbBPTN4H38lUgGqG6-iZasbj_l1mVg,1920
+passlib/tests/tox_support.py,sha256=PDaO1ftDtOFzd299EXm0X5HWRzg37VsBiHsdiMOu5FA,2473
+passlib/tests/utils.py,sha256=mNbhjFNG16dmU13ChMyqOSY39OiR2d8LRUBi41dAMko,147541
+passlib/utils/__init__.py,sha256=VHkQHu7DcdVKyDjhPuyRG_2-25aI4Zwat3wr6K-rAlo,42925
+passlib/utils/binary.py,sha256=dZe2ZjuGr0g6iQseO-ThkQ5XM6KnQFISGQr68vUOOhM,31422
+passlib/utils/decor.py,sha256=svc2C-_DKfiCMmOBNhn_DK7IeS_WYNg26asjhx76LUA,7651
+passlib/utils/des.py,sha256=jFuvhUA3aaiR1xWX4NpXYm5XgcdewRT5Uas-7jLoSTE,2163
+passlib/utils/handlers.py,sha256=E3oRL908uudK_ZLZWeX5DoPxJL8uCfCGpmAkyfJoWQ8,105286
+passlib/utils/md4.py,sha256=pyxEpUe_t8E0u2ZDWOzYIJa0oXgTQBO7DQ8SMKGX8ag,1218
+passlib/utils/pbkdf2.py,sha256=foDGTAKeZywBAVlLZIRf4bX6fC3bzsoC1i_DtcdXr2I,6832
+passlib/utils/compat/__init__.py,sha256=xuPP5PsmLJh_I5NrlaYa012zmWrdzfrYbL_oHqc4tCk,14235
+passlib/utils/compat/_ordered_dict.py,sha256=1nga6blaxokrrDdY3UrQgRXYdifZHCDgPYie1aCJkuI,8368
+passlib-1.7.4.dist-info/LICENSE,sha256=qVuo8a-I_41fDQwzUZ9DC3-diZK2nUvDaawEI6egWok,4954
+passlib-1.7.4.dist-info/METADATA,sha256=l-uRq14ie328RCoVsayT7AfMHaJqv34ICbpQtKG00jM,1688
+passlib-1.7.4.dist-info/WHEEL,sha256=ADKeyaGyKF5DwBNE0sRE5pvW-bSkFMJfBuhzZ3rceP4,110
+passlib-1.7.4.dist-info/top_level.txt,sha256=BA9xbJpLdaTxqvYbKigYnMQkzp8-UQr6S4m3lBTkxzw,8
+passlib-1.7.4.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+passlib-1.7.4.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+passlib-1.7.4.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/WHEEL
new file mode 100644
index 0000000..6d38aa0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.35.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/top_level.txt
new file mode 100644
index 0000000..419829d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/top_level.txt
@@ -0,0 +1 @@
+passlib
diff --git a/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/zip-safe b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/zip-safe
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib-1.7.4.dist-info/zip-safe
@@ -0,0 +1 @@
+
diff --git a/myenv/lib/python3.9/site-packages/passlib/__init__.py b/myenv/lib/python3.9/site-packages/passlib/__init__.py
new file mode 100644
index 0000000..963bfcc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/__init__.py
@@ -0,0 +1,3 @@
+"""passlib - suite of password hashing & generation routines"""
+
+__version__ = '1.7.4'
diff --git a/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/bip39.txt b/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/bip39.txt
new file mode 100644
index 0000000..e29842e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/bip39.txt
@@ -0,0 +1,2049 @@
+abandon
+ability
+able
+about
+above
+absent
+absorb
+abstract
+absurd
+abuse
+access
+accident
+account
+accuse
+achieve
+acid
+acoustic
+acquire
+across
+act
+action
+actor
+actress
+actual
+adapt
+add
+addict
+address
+adjust
+admit
+adult
+advance
+advice
+aerobic
+affair
+afford
+afraid
+again
+age
+agent
+agree
+ahead
+aim
+air
+airport
+aisle
+alarm
+album
+alcohol
+alert
+alien
+all
+alley
+allow
+almost
+alone
+alpha
+already
+also
+alter
+always
+amateur
+amazing
+among
+amount
+amused
+analyst
+anchor
+ancient
+anger
+angle
+angry
+animal
+ankle
+announce
+annual
+another
+answer
+antenna
+antique
+anxiety
+any
+apart
+apology
+appear
+apple
+approve
+april
+arch
+arctic
+area
+arena
+argue
+arm
+armed
+armor
+army
+around
+arrange
+arrest
+arrive
+arrow
+art
+artefact
+artist
+artwork
+ask
+aspect
+assault
+asset
+assist
+assume
+asthma
+athlete
+atom
+attack
+attend
+attitude
+attract
+auction
+audit
+august
+aunt
+author
+auto
+autumn
+average
+avocado
+avoid
+awake
+aware
+away
+awesome
+awful
+awkward
+axis
+baby
+bachelor
+bacon
+badge
+bag
+balance
+balcony
+ball
+bamboo
+banana
+banner
+bar
+barely
+bargain
+barrel
+base
+basic
+basket
+battle
+beach
+bean
+beauty
+because
+become
+beef
+before
+begin
+behave
+behind
+believe
+below
+belt
+bench
+benefit
+best
+betray
+better
+between
+beyond
+bicycle
+bid
+bike
+bind
+biology
+bird
+birth
+bitter
+black
+blade
+blame
+blanket
+blast
+bleak
+bless
+blind
+blood
+blossom
+blouse
+blue
+blur
+blush
+board
+boat
+body
+boil
+bomb
+bone
+bonus
+book
+boost
+border
+boring
+borrow
+boss
+bottom
+bounce
+box
+boy
+bracket
+brain
+brand
+brass
+brave
+bread
+breeze
+brick
+bridge
+brief
+bright
+bring
+brisk
+broccoli
+broken
+bronze
+broom
+brother
+brown
+brush
+bubble
+buddy
+budget
+buffalo
+build
+bulb
+bulk
+bullet
+bundle
+bunker
+burden
+burger
+burst
+bus
+business
+busy
+butter
+buyer
+buzz
+cabbage
+cabin
+cable
+cactus
+cage
+cake
+call
+calm
+camera
+camp
+can
+canal
+cancel
+candy
+cannon
+canoe
+canvas
+canyon
+capable
+capital
+captain
+car
+carbon
+card
+cargo
+carpet
+carry
+cart
+case
+cash
+casino
+castle
+casual
+cat
+catalog
+catch
+category
+cattle
+caught
+cause
+caution
+cave
+ceiling
+celery
+cement
+census
+century
+cereal
+certain
+chair
+chalk
+champion
+change
+chaos
+chapter
+charge
+chase
+chat
+cheap
+check
+cheese
+chef
+cherry
+chest
+chicken
+chief
+child
+chimney
+choice
+choose
+chronic
+chuckle
+chunk
+churn
+cigar
+cinnamon
+circle
+citizen
+city
+civil
+claim
+clap
+clarify
+claw
+clay
+clean
+clerk
+clever
+click
+client
+cliff
+climb
+clinic
+clip
+clock
+clog
+close
+cloth
+cloud
+clown
+club
+clump
+cluster
+clutch
+coach
+coast
+coconut
+code
+coffee
+coil
+coin
+collect
+color
+column
+combine
+come
+comfort
+comic
+common
+company
+concert
+conduct
+confirm
+congress
+connect
+consider
+control
+convince
+cook
+cool
+copper
+copy
+coral
+core
+corn
+correct
+cost
+cotton
+couch
+country
+couple
+course
+cousin
+cover
+coyote
+crack
+cradle
+craft
+cram
+crane
+crash
+crater
+crawl
+crazy
+cream
+credit
+creek
+crew
+cricket
+crime
+crisp
+critic
+crop
+cross
+crouch
+crowd
+crucial
+cruel
+cruise
+crumble
+crunch
+crush
+cry
+crystal
+cube
+culture
+cup
+cupboard
+curious
+current
+curtain
+curve
+cushion
+custom
+cute
+cycle
+dad
+damage
+damp
+dance
+danger
+daring
+dash
+daughter
+dawn
+day
+deal
+debate
+debris
+decade
+december
+decide
+decline
+decorate
+decrease
+deer
+defense
+define
+defy
+degree
+delay
+deliver
+demand
+demise
+denial
+dentist
+deny
+depart
+depend
+deposit
+depth
+deputy
+derive
+describe
+desert
+design
+desk
+despair
+destroy
+detail
+detect
+develop
+device
+devote
+diagram
+dial
+diamond
+diary
+dice
+diesel
+diet
+differ
+digital
+dignity
+dilemma
+dinner
+dinosaur
+direct
+dirt
+disagree
+discover
+disease
+dish
+dismiss
+disorder
+display
+distance
+divert
+divide
+divorce
+dizzy
+doctor
+document
+dog
+doll
+dolphin
+domain
+donate
+donkey
+donor
+door
+dose
+double
+dove
+draft
+dragon
+drama
+drastic
+draw
+dream
+dress
+drift
+drill
+drink
+drip
+drive
+drop
+drum
+dry
+duck
+dumb
+dune
+during
+dust
+dutch
+duty
+dwarf
+dynamic
+eager
+eagle
+early
+earn
+earth
+easily
+east
+easy
+echo
+ecology
+economy
+edge
+edit
+educate
+effort
+egg
+eight
+either
+elbow
+elder
+electric
+elegant
+element
+elephant
+elevator
+elite
+else
+embark
+embody
+embrace
+emerge
+emotion
+employ
+empower
+empty
+enable
+enact
+end
+endless
+endorse
+enemy
+energy
+enforce
+engage
+engine
+enhance
+enjoy
+enlist
+enough
+enrich
+enroll
+ensure
+enter
+entire
+entry
+envelope
+episode
+equal
+equip
+era
+erase
+erode
+erosion
+error
+erupt
+escape
+essay
+essence
+estate
+eternal
+ethics
+evidence
+evil
+evoke
+evolve
+exact
+example
+excess
+exchange
+excite
+exclude
+excuse
+execute
+exercise
+exhaust
+exhibit
+exile
+exist
+exit
+exotic
+expand
+expect
+expire
+explain
+expose
+express
+extend
+extra
+eye
+eyebrow
+fabric
+face
+faculty
+fade
+faint
+faith
+fall
+false
+fame
+family
+famous
+fan
+fancy
+fantasy
+farm
+fashion
+fat
+fatal
+father
+fatigue
+fault
+favorite
+feature
+february
+federal
+fee
+feed
+feel
+female
+fence
+festival
+fetch
+fever
+few
+fiber
+fiction
+field
+figure
+file
+film
+filter
+final
+find
+fine
+finger
+finish
+fire
+firm
+first
+fiscal
+fish
+fit
+fitness
+fix
+flag
+flame
+flash
+flat
+flavor
+flee
+flight
+flip
+float
+flock
+floor
+flower
+fluid
+flush
+fly
+foam
+focus
+fog
+foil
+fold
+follow
+food
+foot
+force
+forest
+forget
+fork
+fortune
+forum
+forward
+fossil
+foster
+found
+fox
+fragile
+frame
+frequent
+fresh
+friend
+fringe
+frog
+front
+frost
+frown
+frozen
+fruit
+fuel
+fun
+funny
+furnace
+fury
+future
+gadget
+gain
+galaxy
+gallery
+game
+gap
+garage
+garbage
+garden
+garlic
+garment
+gas
+gasp
+gate
+gather
+gauge
+gaze
+general
+genius
+genre
+gentle
+genuine
+gesture
+ghost
+giant
+gift
+giggle
+ginger
+giraffe
+girl
+give
+glad
+glance
+glare
+glass
+glide
+glimpse
+globe
+gloom
+glory
+glove
+glow
+glue
+goat
+goddess
+gold
+good
+goose
+gorilla
+gospel
+gossip
+govern
+gown
+grab
+grace
+grain
+grant
+grape
+grass
+gravity
+great
+green
+grid
+grief
+grit
+grocery
+group
+grow
+grunt
+guard
+guess
+guide
+guilt
+guitar
+gun
+gym
+habit
+hair
+half
+hammer
+hamster
+hand
+happy
+harbor
+hard
+harsh
+harvest
+hat
+have
+hawk
+hazard
+head
+health
+heart
+heavy
+hedgehog
+height
+hello
+helmet
+help
+hen
+hero
+hidden
+high
+hill
+hint
+hip
+hire
+history
+hobby
+hockey
+hold
+hole
+holiday
+hollow
+home
+honey
+hood
+hope
+horn
+horror
+horse
+hospital
+host
+hotel
+hour
+hover
+hub
+huge
+human
+humble
+humor
+hundred
+hungry
+hunt
+hurdle
+hurry
+hurt
+husband
+hybrid
+ice
+icon
+idea
+identify
+idle
+ignore
+ill
+illegal
+illness
+image
+imitate
+immense
+immune
+impact
+impose
+improve
+impulse
+inch
+include
+income
+increase
+index
+indicate
+indoor
+industry
+infant
+inflict
+inform
+inhale
+inherit
+initial
+inject
+injury
+inmate
+inner
+innocent
+input
+inquiry
+insane
+insect
+inside
+inspire
+install
+intact
+interest
+into
+invest
+invite
+involve
+iron
+island
+isolate
+issue
+item
+ivory
+jacket
+jaguar
+jar
+jazz
+jealous
+jeans
+jelly
+jewel
+job
+join
+joke
+journey
+joy
+judge
+juice
+jump
+jungle
+junior
+junk
+just
+kangaroo
+keen
+keep
+ketchup
+key
+kick
+kid
+kidney
+kind
+kingdom
+kiss
+kit
+kitchen
+kite
+kitten
+kiwi
+knee
+knife
+knock
+know
+lab
+label
+labor
+ladder
+lady
+lake
+lamp
+language
+laptop
+large
+later
+latin
+laugh
+laundry
+lava
+law
+lawn
+lawsuit
+layer
+lazy
+leader
+leaf
+learn
+leave
+lecture
+left
+leg
+legal
+legend
+leisure
+lemon
+lend
+length
+lens
+leopard
+lesson
+letter
+level
+liar
+liberty
+library
+license
+life
+lift
+light
+like
+limb
+limit
+link
+lion
+liquid
+list
+little
+live
+lizard
+load
+loan
+lobster
+local
+lock
+logic
+lonely
+long
+loop
+lottery
+loud
+lounge
+love
+loyal
+lucky
+luggage
+lumber
+lunar
+lunch
+luxury
+lyrics
+machine
+mad
+magic
+magnet
+maid
+mail
+main
+major
+make
+mammal
+man
+manage
+mandate
+mango
+mansion
+manual
+maple
+marble
+march
+margin
+marine
+market
+marriage
+mask
+mass
+master
+match
+material
+math
+matrix
+matter
+maximum
+maze
+meadow
+mean
+measure
+meat
+mechanic
+medal
+media
+melody
+melt
+member
+memory
+mention
+menu
+mercy
+merge
+merit
+merry
+mesh
+message
+metal
+method
+middle
+midnight
+milk
+million
+mimic
+mind
+minimum
+minor
+minute
+miracle
+mirror
+misery
+miss
+mistake
+mix
+mixed
+mixture
+mobile
+model
+modify
+mom
+moment
+monitor
+monkey
+monster
+month
+moon
+moral
+more
+morning
+mosquito
+mother
+motion
+motor
+mountain
+mouse
+move
+movie
+much
+muffin
+mule
+multiply
+muscle
+museum
+mushroom
+music
+must
+mutual
+myself
+mystery
+myth
+naive
+name
+napkin
+narrow
+nasty
+nation
+nature
+near
+neck
+need
+negative
+neglect
+neither
+nephew
+nerve
+nest
+net
+network
+neutral
+never
+news
+next
+nice
+night
+noble
+noise
+nominee
+noodle
+normal
+north
+nose
+notable
+note
+nothing
+notice
+novel
+now
+nuclear
+number
+nurse
+nut
+oak
+obey
+object
+oblige
+obscure
+observe
+obtain
+obvious
+occur
+ocean
+october
+odor
+off
+offer
+office
+often
+oil
+okay
+old
+olive
+olympic
+omit
+once
+one
+onion
+online
+only
+open
+opera
+opinion
+oppose
+option
+orange
+orbit
+orchard
+order
+ordinary
+organ
+orient
+original
+orphan
+ostrich
+other
+outdoor
+outer
+output
+outside
+oval
+oven
+over
+own
+owner
+oxygen
+oyster
+ozone
+pact
+paddle
+page
+pair
+palace
+palm
+panda
+panel
+panic
+panther
+paper
+parade
+parent
+park
+parrot
+party
+pass
+patch
+path
+patient
+patrol
+pattern
+pause
+pave
+payment
+peace
+peanut
+pear
+peasant
+pelican
+pen
+penalty
+pencil
+people
+pepper
+perfect
+permit
+person
+pet
+phone
+photo
+phrase
+physical
+piano
+picnic
+picture
+piece
+pig
+pigeon
+pill
+pilot
+pink
+pioneer
+pipe
+pistol
+pitch
+pizza
+place
+planet
+plastic
+plate
+play
+please
+pledge
+pluck
+plug
+plunge
+poem
+poet
+point
+polar
+pole
+police
+pond
+pony
+pool
+popular
+portion
+position
+possible
+post
+potato
+pottery
+poverty
+powder
+power
+practice
+praise
+predict
+prefer
+prepare
+present
+pretty
+prevent
+price
+pride
+primary
+print
+priority
+prison
+private
+prize
+problem
+process
+produce
+profit
+program
+project
+promote
+proof
+property
+prosper
+protect
+proud
+provide
+public
+pudding
+pull
+pulp
+pulse
+pumpkin
+punch
+pupil
+puppy
+purchase
+purity
+purpose
+purse
+push
+put
+puzzle
+pyramid
+quality
+quantum
+quarter
+question
+quick
+quit
+quiz
+quote
+rabbit
+raccoon
+race
+rack
+radar
+radio
+rail
+rain
+raise
+rally
+ramp
+ranch
+random
+range
+rapid
+rare
+rate
+rather
+raven
+raw
+razor
+ready
+real
+reason
+rebel
+rebuild
+recall
+receive
+recipe
+record
+recycle
+reduce
+reflect
+reform
+refuse
+region
+regret
+regular
+reject
+relax
+release
+relief
+rely
+remain
+remember
+remind
+remove
+render
+renew
+rent
+reopen
+repair
+repeat
+replace
+report
+require
+rescue
+resemble
+resist
+resource
+response
+result
+retire
+retreat
+return
+reunion
+reveal
+review
+reward
+rhythm
+rib
+ribbon
+rice
+rich
+ride
+ridge
+rifle
+right
+rigid
+ring
+riot
+ripple
+risk
+ritual
+rival
+river
+road
+roast
+robot
+robust
+rocket
+romance
+roof
+rookie
+room
+rose
+rotate
+rough
+round
+route
+royal
+rubber
+rude
+rug
+rule
+run
+runway
+rural
+sad
+saddle
+sadness
+safe
+sail
+salad
+salmon
+salon
+salt
+salute
+same
+sample
+sand
+satisfy
+satoshi
+sauce
+sausage
+save
+say
+scale
+scan
+scare
+scatter
+scene
+scheme
+school
+science
+scissors
+scorpion
+scout
+scrap
+screen
+script
+scrub
+sea
+search
+season
+seat
+second
+secret
+section
+security
+seed
+seek
+segment
+select
+sell
+seminar
+senior
+sense
+sentence
+series
+service
+session
+settle
+setup
+seven
+shadow
+shaft
+shallow
+share
+shed
+shell
+sheriff
+shield
+shift
+shine
+ship
+shiver
+shock
+shoe
+shoot
+shop
+short
+shoulder
+shove
+shrimp
+shrug
+shuffle
+shy
+sibling
+sick
+side
+siege
+sight
+sign
+silent
+silk
+silly
+silver
+similar
+simple
+since
+sing
+siren
+sister
+situate
+six
+size
+skate
+sketch
+ski
+skill
+skin
+skirt
+skull
+slab
+slam
+sleep
+slender
+slice
+slide
+slight
+slim
+slogan
+slot
+slow
+slush
+small
+smart
+smile
+smoke
+smooth
+snack
+snake
+snap
+sniff
+snow
+soap
+soccer
+social
+sock
+soda
+soft
+solar
+soldier
+solid
+solution
+solve
+someone
+song
+soon
+sorry
+sort
+soul
+sound
+soup
+source
+south
+space
+spare
+spatial
+spawn
+speak
+special
+speed
+spell
+spend
+sphere
+spice
+spider
+spike
+spin
+spirit
+split
+spoil
+sponsor
+spoon
+sport
+spot
+spray
+spread
+spring
+spy
+square
+squeeze
+squirrel
+stable
+stadium
+staff
+stage
+stairs
+stamp
+stand
+start
+state
+stay
+steak
+steel
+stem
+step
+stereo
+stick
+still
+sting
+stock
+stomach
+stone
+stool
+story
+stove
+strategy
+street
+strike
+strong
+struggle
+student
+stuff
+stumble
+style
+subject
+submit
+subway
+success
+such
+sudden
+suffer
+sugar
+suggest
+suit
+summer
+sun
+sunny
+sunset
+super
+supply
+supreme
+sure
+surface
+surge
+surprise
+surround
+survey
+suspect
+sustain
+swallow
+swamp
+swap
+swarm
+swear
+sweet
+swift
+swim
+swing
+switch
+sword
+symbol
+symptom
+syrup
+system
+table
+tackle
+tag
+tail
+talent
+talk
+tank
+tape
+target
+task
+taste
+tattoo
+taxi
+teach
+team
+tell
+ten
+tenant
+tennis
+tent
+term
+test
+text
+thank
+that
+theme
+then
+theory
+there
+they
+thing
+this
+thought
+three
+thrive
+throw
+thumb
+thunder
+ticket
+tide
+tiger
+tilt
+timber
+time
+tiny
+tip
+tired
+tissue
+title
+toast
+tobacco
+today
+toddler
+toe
+together
+toilet
+token
+tomato
+tomorrow
+tone
+tongue
+tonight
+tool
+tooth
+top
+topic
+topple
+torch
+tornado
+tortoise
+toss
+total
+tourist
+toward
+tower
+town
+toy
+track
+trade
+traffic
+tragic
+train
+transfer
+trap
+trash
+travel
+tray
+treat
+tree
+trend
+trial
+tribe
+trick
+trigger
+trim
+trip
+trophy
+trouble
+truck
+true
+truly
+trumpet
+trust
+truth
+try
+tube
+tuition
+tumble
+tuna
+tunnel
+turkey
+turn
+turtle
+twelve
+twenty
+twice
+twin
+twist
+two
+type
+typical
+ugly
+umbrella
+unable
+unaware
+uncle
+uncover
+under
+undo
+unfair
+unfold
+unhappy
+uniform
+unique
+unit
+universe
+unknown
+unlock
+until
+unusual
+unveil
+update
+upgrade
+uphold
+upon
+upper
+upset
+urban
+urge
+usage
+use
+used
+useful
+useless
+usual
+utility
+vacant
+vacuum
+vague
+valid
+valley
+valve
+van
+vanish
+vapor
+various
+vast
+vault
+vehicle
+velvet
+vendor
+venture
+venue
+verb
+verify
+version
+very
+vessel
+veteran
+viable
+vibrant
+vicious
+victory
+video
+view
+village
+vintage
+violin
+virtual
+virus
+visa
+visit
+visual
+vital
+vivid
+vocal
+voice
+void
+volcano
+volume
+vote
+voyage
+wage
+wagon
+wait
+walk
+wall
+walnut
+want
+warfare
+warm
+warrior
+wash
+wasp
+waste
+water
+wave
+way
+wealth
+weapon
+wear
+weasel
+weather
+web
+wedding
+weekend
+weird
+welcome
+west
+wet
+whale
+what
+wheat
+wheel
+when
+where
+whip
+whisper
+wide
+width
+wife
+wild
+will
+win
+window
+wine
+wing
+wink
+winner
+winter
+wire
+wisdom
+wise
+wish
+witness
+wolf
+woman
+wonder
+wood
+wool
+word
+work
+world
+worry
+worth
+wrap
+wreck
+wrestle
+wrist
+write
+wrong
+yard
+year
+yellow
+you
+young
+youth
+zebra
+zero
+zone
+zoo
+
diff --git a/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/eff_long.txt b/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/eff_long.txt
new file mode 100644
index 0000000..caf71f5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/eff_long.txt
@@ -0,0 +1,7776 @@
+abacus
+abdomen
+abdominal
+abide
+abiding
+ability
+ablaze
+able
+abnormal
+abrasion
+abrasive
+abreast
+abridge
+abroad
+abruptly
+absence
+absentee
+absently
+absinthe
+absolute
+absolve
+abstain
+abstract
+absurd
+accent
+acclaim
+acclimate
+accompany
+account
+accuracy
+accurate
+accustom
+acetone
+achiness
+aching
+acid
+acorn
+acquaint
+acquire
+acre
+acrobat
+acronym
+acting
+action
+activate
+activator
+active
+activism
+activist
+activity
+actress
+acts
+acutely
+acuteness
+aeration
+aerobics
+aerosol
+aerospace
+afar
+affair
+affected
+affecting
+affection
+affidavit
+affiliate
+affirm
+affix
+afflicted
+affluent
+afford
+affront
+aflame
+afloat
+aflutter
+afoot
+afraid
+afterglow
+afterlife
+aftermath
+aftermost
+afternoon
+aged
+ageless
+agency
+agenda
+agent
+aggregate
+aghast
+agile
+agility
+aging
+agnostic
+agonize
+agonizing
+agony
+agreeable
+agreeably
+agreed
+agreeing
+agreement
+aground
+ahead
+ahoy
+aide
+aids
+aim
+ajar
+alabaster
+alarm
+albatross
+album
+alfalfa
+algebra
+algorithm
+alias
+alibi
+alienable
+alienate
+aliens
+alike
+alive
+alkaline
+alkalize
+almanac
+almighty
+almost
+aloe
+aloft
+aloha
+alone
+alongside
+aloof
+alphabet
+alright
+although
+altitude
+alto
+aluminum
+alumni
+always
+amaretto
+amaze
+amazingly
+amber
+ambiance
+ambiguity
+ambiguous
+ambition
+ambitious
+ambulance
+ambush
+amendable
+amendment
+amends
+amenity
+amiable
+amicably
+amid
+amigo
+amino
+amiss
+ammonia
+ammonium
+amnesty
+amniotic
+among
+amount
+amperage
+ample
+amplifier
+amplify
+amply
+amuck
+amulet
+amusable
+amused
+amusement
+amuser
+amusing
+anaconda
+anaerobic
+anagram
+anatomist
+anatomy
+anchor
+anchovy
+ancient
+android
+anemia
+anemic
+aneurism
+anew
+angelfish
+angelic
+anger
+angled
+angler
+angles
+angling
+angrily
+angriness
+anguished
+angular
+animal
+animate
+animating
+animation
+animator
+anime
+animosity
+ankle
+annex
+annotate
+announcer
+annoying
+annually
+annuity
+anointer
+another
+answering
+antacid
+antarctic
+anteater
+antelope
+antennae
+anthem
+anthill
+anthology
+antibody
+antics
+antidote
+antihero
+antiquely
+antiques
+antiquity
+antirust
+antitoxic
+antitrust
+antiviral
+antivirus
+antler
+antonym
+antsy
+anvil
+anybody
+anyhow
+anymore
+anyone
+anyplace
+anything
+anytime
+anyway
+anywhere
+aorta
+apache
+apostle
+appealing
+appear
+appease
+appeasing
+appendage
+appendix
+appetite
+appetizer
+applaud
+applause
+apple
+appliance
+applicant
+applied
+apply
+appointee
+appraisal
+appraiser
+apprehend
+approach
+approval
+approve
+apricot
+april
+apron
+aptitude
+aptly
+aqua
+aqueduct
+arbitrary
+arbitrate
+ardently
+area
+arena
+arguable
+arguably
+argue
+arise
+armadillo
+armband
+armchair
+armed
+armful
+armhole
+arming
+armless
+armoire
+armored
+armory
+armrest
+army
+aroma
+arose
+around
+arousal
+arrange
+array
+arrest
+arrival
+arrive
+arrogance
+arrogant
+arson
+art
+ascend
+ascension
+ascent
+ascertain
+ashamed
+ashen
+ashes
+ashy
+aside
+askew
+asleep
+asparagus
+aspect
+aspirate
+aspire
+aspirin
+astonish
+astound
+astride
+astrology
+astronaut
+astronomy
+astute
+atlantic
+atlas
+atom
+atonable
+atop
+atrium
+atrocious
+atrophy
+attach
+attain
+attempt
+attendant
+attendee
+attention
+attentive
+attest
+attic
+attire
+attitude
+attractor
+attribute
+atypical
+auction
+audacious
+audacity
+audible
+audibly
+audience
+audio
+audition
+augmented
+august
+authentic
+author
+autism
+autistic
+autograph
+automaker
+automated
+automatic
+autopilot
+available
+avalanche
+avatar
+avenge
+avenging
+avenue
+average
+aversion
+avert
+aviation
+aviator
+avid
+avoid
+await
+awaken
+award
+aware
+awhile
+awkward
+awning
+awoke
+awry
+axis
+babble
+babbling
+babied
+baboon
+backache
+backboard
+backboned
+backdrop
+backed
+backer
+backfield
+backfire
+backhand
+backing
+backlands
+backlash
+backless
+backlight
+backlit
+backlog
+backpack
+backpedal
+backrest
+backroom
+backshift
+backside
+backslid
+backspace
+backspin
+backstab
+backstage
+backtalk
+backtrack
+backup
+backward
+backwash
+backwater
+backyard
+bacon
+bacteria
+bacterium
+badass
+badge
+badland
+badly
+badness
+baffle
+baffling
+bagel
+bagful
+baggage
+bagged
+baggie
+bagginess
+bagging
+baggy
+bagpipe
+baguette
+baked
+bakery
+bakeshop
+baking
+balance
+balancing
+balcony
+balmy
+balsamic
+bamboo
+banana
+banish
+banister
+banjo
+bankable
+bankbook
+banked
+banker
+banking
+banknote
+bankroll
+banner
+bannister
+banshee
+banter
+barbecue
+barbed
+barbell
+barber
+barcode
+barge
+bargraph
+barista
+baritone
+barley
+barmaid
+barman
+barn
+barometer
+barrack
+barracuda
+barrel
+barrette
+barricade
+barrier
+barstool
+bartender
+barterer
+bash
+basically
+basics
+basil
+basin
+basis
+basket
+batboy
+batch
+bath
+baton
+bats
+battalion
+battered
+battering
+battery
+batting
+battle
+bauble
+bazooka
+blabber
+bladder
+blade
+blah
+blame
+blaming
+blanching
+blandness
+blank
+blaspheme
+blasphemy
+blast
+blatancy
+blatantly
+blazer
+blazing
+bleach
+bleak
+bleep
+blemish
+blend
+bless
+blighted
+blimp
+bling
+blinked
+blinker
+blinking
+blinks
+blip
+blissful
+blitz
+blizzard
+bloated
+bloating
+blob
+blog
+bloomers
+blooming
+blooper
+blot
+blouse
+blubber
+bluff
+bluish
+blunderer
+blunt
+blurb
+blurred
+blurry
+blurt
+blush
+blustery
+boaster
+boastful
+boasting
+boat
+bobbed
+bobbing
+bobble
+bobcat
+bobsled
+bobtail
+bodacious
+body
+bogged
+boggle
+bogus
+boil
+bok
+bolster
+bolt
+bonanza
+bonded
+bonding
+bondless
+boned
+bonehead
+boneless
+bonelike
+boney
+bonfire
+bonnet
+bonsai
+bonus
+bony
+boogeyman
+boogieman
+book
+boondocks
+booted
+booth
+bootie
+booting
+bootlace
+bootleg
+boots
+boozy
+borax
+boring
+borough
+borrower
+borrowing
+boss
+botanical
+botanist
+botany
+botch
+both
+bottle
+bottling
+bottom
+bounce
+bouncing
+bouncy
+bounding
+boundless
+bountiful
+bovine
+boxcar
+boxer
+boxing
+boxlike
+boxy
+breach
+breath
+breeches
+breeching
+breeder
+breeding
+breeze
+breezy
+brethren
+brewery
+brewing
+briar
+bribe
+brick
+bride
+bridged
+brigade
+bright
+brilliant
+brim
+bring
+brink
+brisket
+briskly
+briskness
+bristle
+brittle
+broadband
+broadcast
+broaden
+broadly
+broadness
+broadside
+broadways
+broiler
+broiling
+broken
+broker
+bronchial
+bronco
+bronze
+bronzing
+brook
+broom
+brought
+browbeat
+brownnose
+browse
+browsing
+bruising
+brunch
+brunette
+brunt
+brush
+brussels
+brute
+brutishly
+bubble
+bubbling
+bubbly
+buccaneer
+bucked
+bucket
+buckle
+buckshot
+buckskin
+bucktooth
+buckwheat
+buddhism
+buddhist
+budding
+buddy
+budget
+buffalo
+buffed
+buffer
+buffing
+buffoon
+buggy
+bulb
+bulge
+bulginess
+bulgur
+bulk
+bulldog
+bulldozer
+bullfight
+bullfrog
+bullhorn
+bullion
+bullish
+bullpen
+bullring
+bullseye
+bullwhip
+bully
+bunch
+bundle
+bungee
+bunion
+bunkbed
+bunkhouse
+bunkmate
+bunny
+bunt
+busboy
+bush
+busily
+busload
+bust
+busybody
+buzz
+cabana
+cabbage
+cabbie
+cabdriver
+cable
+caboose
+cache
+cackle
+cacti
+cactus
+caddie
+caddy
+cadet
+cadillac
+cadmium
+cage
+cahoots
+cake
+calamari
+calamity
+calcium
+calculate
+calculus
+caliber
+calibrate
+calm
+caloric
+calorie
+calzone
+camcorder
+cameo
+camera
+camisole
+camper
+campfire
+camping
+campsite
+campus
+canal
+canary
+cancel
+candied
+candle
+candy
+cane
+canine
+canister
+cannabis
+canned
+canning
+cannon
+cannot
+canola
+canon
+canopener
+canopy
+canteen
+canyon
+capable
+capably
+capacity
+cape
+capillary
+capital
+capitol
+capped
+capricorn
+capsize
+capsule
+caption
+captivate
+captive
+captivity
+capture
+caramel
+carat
+caravan
+carbon
+cardboard
+carded
+cardiac
+cardigan
+cardinal
+cardstock
+carefully
+caregiver
+careless
+caress
+caretaker
+cargo
+caring
+carless
+carload
+carmaker
+carnage
+carnation
+carnival
+carnivore
+carol
+carpenter
+carpentry
+carpool
+carport
+carried
+carrot
+carrousel
+carry
+cartel
+cartload
+carton
+cartoon
+cartridge
+cartwheel
+carve
+carving
+carwash
+cascade
+case
+cash
+casing
+casino
+casket
+cassette
+casually
+casualty
+catacomb
+catalog
+catalyst
+catalyze
+catapult
+cataract
+catatonic
+catcall
+catchable
+catcher
+catching
+catchy
+caterer
+catering
+catfight
+catfish
+cathedral
+cathouse
+catlike
+catnap
+catnip
+catsup
+cattail
+cattishly
+cattle
+catty
+catwalk
+caucasian
+caucus
+causal
+causation
+cause
+causing
+cauterize
+caution
+cautious
+cavalier
+cavalry
+caviar
+cavity
+cedar
+celery
+celestial
+celibacy
+celibate
+celtic
+cement
+census
+ceramics
+ceremony
+certainly
+certainty
+certified
+certify
+cesarean
+cesspool
+chafe
+chaffing
+chain
+chair
+chalice
+challenge
+chamber
+chamomile
+champion
+chance
+change
+channel
+chant
+chaos
+chaperone
+chaplain
+chapped
+chaps
+chapter
+character
+charbroil
+charcoal
+charger
+charging
+chariot
+charity
+charm
+charred
+charter
+charting
+chase
+chasing
+chaste
+chastise
+chastity
+chatroom
+chatter
+chatting
+chatty
+cheating
+cheddar
+cheek
+cheer
+cheese
+cheesy
+chef
+chemicals
+chemist
+chemo
+cherisher
+cherub
+chess
+chest
+chevron
+chevy
+chewable
+chewer
+chewing
+chewy
+chief
+chihuahua
+childcare
+childhood
+childish
+childless
+childlike
+chili
+chill
+chimp
+chip
+chirping
+chirpy
+chitchat
+chivalry
+chive
+chloride
+chlorine
+choice
+chokehold
+choking
+chomp
+chooser
+choosing
+choosy
+chop
+chosen
+chowder
+chowtime
+chrome
+chubby
+chuck
+chug
+chummy
+chump
+chunk
+churn
+chute
+cider
+cilantro
+cinch
+cinema
+cinnamon
+circle
+circling
+circular
+circulate
+circus
+citable
+citadel
+citation
+citizen
+citric
+citrus
+city
+civic
+civil
+clad
+claim
+clambake
+clammy
+clamor
+clamp
+clamshell
+clang
+clanking
+clapped
+clapper
+clapping
+clarify
+clarinet
+clarity
+clash
+clasp
+class
+clatter
+clause
+clavicle
+claw
+clay
+clean
+clear
+cleat
+cleaver
+cleft
+clench
+clergyman
+clerical
+clerk
+clever
+clicker
+client
+climate
+climatic
+cling
+clinic
+clinking
+clip
+clique
+cloak
+clobber
+clock
+clone
+cloning
+closable
+closure
+clothes
+clothing
+cloud
+clover
+clubbed
+clubbing
+clubhouse
+clump
+clumsily
+clumsy
+clunky
+clustered
+clutch
+clutter
+coach
+coagulant
+coastal
+coaster
+coasting
+coastland
+coastline
+coat
+coauthor
+cobalt
+cobbler
+cobweb
+cocoa
+coconut
+cod
+coeditor
+coerce
+coexist
+coffee
+cofounder
+cognition
+cognitive
+cogwheel
+coherence
+coherent
+cohesive
+coil
+coke
+cola
+cold
+coleslaw
+coliseum
+collage
+collapse
+collar
+collected
+collector
+collide
+collie
+collision
+colonial
+colonist
+colonize
+colony
+colossal
+colt
+coma
+come
+comfort
+comfy
+comic
+coming
+comma
+commence
+commend
+comment
+commerce
+commode
+commodity
+commodore
+common
+commotion
+commute
+commuting
+compacted
+compacter
+compactly
+compactor
+companion
+company
+compare
+compel
+compile
+comply
+component
+composed
+composer
+composite
+compost
+composure
+compound
+compress
+comprised
+computer
+computing
+comrade
+concave
+conceal
+conceded
+concept
+concerned
+concert
+conch
+concierge
+concise
+conclude
+concrete
+concur
+condense
+condiment
+condition
+condone
+conducive
+conductor
+conduit
+cone
+confess
+confetti
+confidant
+confident
+confider
+confiding
+configure
+confined
+confining
+confirm
+conflict
+conform
+confound
+confront
+confused
+confusing
+confusion
+congenial
+congested
+congrats
+congress
+conical
+conjoined
+conjure
+conjuror
+connected
+connector
+consensus
+consent
+console
+consoling
+consonant
+constable
+constant
+constrain
+constrict
+construct
+consult
+consumer
+consuming
+contact
+container
+contempt
+contend
+contented
+contently
+contents
+contest
+context
+contort
+contour
+contrite
+control
+contusion
+convene
+convent
+copartner
+cope
+copied
+copier
+copilot
+coping
+copious
+copper
+copy
+coral
+cork
+cornball
+cornbread
+corncob
+cornea
+corned
+corner
+cornfield
+cornflake
+cornhusk
+cornmeal
+cornstalk
+corny
+coronary
+coroner
+corporal
+corporate
+corral
+correct
+corridor
+corrode
+corroding
+corrosive
+corsage
+corset
+cortex
+cosigner
+cosmetics
+cosmic
+cosmos
+cosponsor
+cost
+cottage
+cotton
+couch
+cough
+could
+countable
+countdown
+counting
+countless
+country
+county
+courier
+covenant
+cover
+coveted
+coveting
+coyness
+cozily
+coziness
+cozy
+crabbing
+crabgrass
+crablike
+crabmeat
+cradle
+cradling
+crafter
+craftily
+craftsman
+craftwork
+crafty
+cramp
+cranberry
+crane
+cranial
+cranium
+crank
+crate
+crave
+craving
+crawfish
+crawlers
+crawling
+crayfish
+crayon
+crazed
+crazily
+craziness
+crazy
+creamed
+creamer
+creamlike
+crease
+creasing
+creatable
+create
+creation
+creative
+creature
+credible
+credibly
+credit
+creed
+creme
+creole
+crepe
+crept
+crescent
+crested
+cresting
+crestless
+crevice
+crewless
+crewman
+crewmate
+crib
+cricket
+cried
+crier
+crimp
+crimson
+cringe
+cringing
+crinkle
+crinkly
+crisped
+crisping
+crisply
+crispness
+crispy
+criteria
+critter
+croak
+crock
+crook
+croon
+crop
+cross
+crouch
+crouton
+crowbar
+crowd
+crown
+crucial
+crudely
+crudeness
+cruelly
+cruelness
+cruelty
+crumb
+crummiest
+crummy
+crumpet
+crumpled
+cruncher
+crunching
+crunchy
+crusader
+crushable
+crushed
+crusher
+crushing
+crust
+crux
+crying
+cryptic
+crystal
+cubbyhole
+cube
+cubical
+cubicle
+cucumber
+cuddle
+cuddly
+cufflink
+culinary
+culminate
+culpable
+culprit
+cultivate
+cultural
+culture
+cupbearer
+cupcake
+cupid
+cupped
+cupping
+curable
+curator
+curdle
+cure
+curfew
+curing
+curled
+curler
+curliness
+curling
+curly
+curry
+curse
+cursive
+cursor
+curtain
+curtly
+curtsy
+curvature
+curve
+curvy
+cushy
+cusp
+cussed
+custard
+custodian
+custody
+customary
+customer
+customize
+customs
+cut
+cycle
+cyclic
+cycling
+cyclist
+cylinder
+cymbal
+cytoplasm
+cytoplast
+dab
+dad
+daffodil
+dagger
+daily
+daintily
+dainty
+dairy
+daisy
+dallying
+dance
+dancing
+dandelion
+dander
+dandruff
+dandy
+danger
+dangle
+dangling
+daredevil
+dares
+daringly
+darkened
+darkening
+darkish
+darkness
+darkroom
+darling
+darn
+dart
+darwinism
+dash
+dastardly
+data
+datebook
+dating
+daughter
+daunting
+dawdler
+dawn
+daybed
+daybreak
+daycare
+daydream
+daylight
+daylong
+dayroom
+daytime
+dazzler
+dazzling
+deacon
+deafening
+deafness
+dealer
+dealing
+dealmaker
+dealt
+dean
+debatable
+debate
+debating
+debit
+debrief
+debtless
+debtor
+debug
+debunk
+decade
+decaf
+decal
+decathlon
+decay
+deceased
+deceit
+deceiver
+deceiving
+december
+decency
+decent
+deception
+deceptive
+decibel
+decidable
+decimal
+decimeter
+decipher
+deck
+declared
+decline
+decode
+decompose
+decorated
+decorator
+decoy
+decrease
+decree
+dedicate
+dedicator
+deduce
+deduct
+deed
+deem
+deepen
+deeply
+deepness
+deface
+defacing
+defame
+default
+defeat
+defection
+defective
+defendant
+defender
+defense
+defensive
+deferral
+deferred
+defiance
+defiant
+defile
+defiling
+define
+definite
+deflate
+deflation
+deflator
+deflected
+deflector
+defog
+deforest
+defraud
+defrost
+deftly
+defuse
+defy
+degraded
+degrading
+degrease
+degree
+dehydrate
+deity
+dejected
+delay
+delegate
+delegator
+delete
+deletion
+delicacy
+delicate
+delicious
+delighted
+delirious
+delirium
+deliverer
+delivery
+delouse
+delta
+deluge
+delusion
+deluxe
+demanding
+demeaning
+demeanor
+demise
+democracy
+democrat
+demote
+demotion
+demystify
+denatured
+deniable
+denial
+denim
+denote
+dense
+density
+dental
+dentist
+denture
+deny
+deodorant
+deodorize
+departed
+departure
+depict
+deplete
+depletion
+deplored
+deploy
+deport
+depose
+depraved
+depravity
+deprecate
+depress
+deprive
+depth
+deputize
+deputy
+derail
+deranged
+derby
+derived
+desecrate
+deserve
+deserving
+designate
+designed
+designer
+designing
+deskbound
+desktop
+deskwork
+desolate
+despair
+despise
+despite
+destiny
+destitute
+destruct
+detached
+detail
+detection
+detective
+detector
+detention
+detergent
+detest
+detonate
+detonator
+detoxify
+detract
+deuce
+devalue
+deviancy
+deviant
+deviate
+deviation
+deviator
+device
+devious
+devotedly
+devotee
+devotion
+devourer
+devouring
+devoutly
+dexterity
+dexterous
+diabetes
+diabetic
+diabolic
+diagnoses
+diagnosis
+diagram
+dial
+diameter
+diaper
+diaphragm
+diary
+dice
+dicing
+dictate
+dictation
+dictator
+difficult
+diffused
+diffuser
+diffusion
+diffusive
+dig
+dilation
+diligence
+diligent
+dill
+dilute
+dime
+diminish
+dimly
+dimmed
+dimmer
+dimness
+dimple
+diner
+dingbat
+dinghy
+dinginess
+dingo
+dingy
+dining
+dinner
+diocese
+dioxide
+diploma
+dipped
+dipper
+dipping
+directed
+direction
+directive
+directly
+directory
+direness
+dirtiness
+disabled
+disagree
+disallow
+disarm
+disarray
+disaster
+disband
+disbelief
+disburse
+discard
+discern
+discharge
+disclose
+discolor
+discount
+discourse
+discover
+discuss
+disdain
+disengage
+disfigure
+disgrace
+dish
+disinfect
+disjoin
+disk
+dislike
+disliking
+dislocate
+dislodge
+disloyal
+dismantle
+dismay
+dismiss
+dismount
+disobey
+disorder
+disown
+disparate
+disparity
+dispatch
+dispense
+dispersal
+dispersed
+disperser
+displace
+display
+displease
+disposal
+dispose
+disprove
+dispute
+disregard
+disrupt
+dissuade
+distance
+distant
+distaste
+distill
+distinct
+distort
+distract
+distress
+district
+distrust
+ditch
+ditto
+ditzy
+dividable
+divided
+dividend
+dividers
+dividing
+divinely
+diving
+divinity
+divisible
+divisibly
+division
+divisive
+divorcee
+dizziness
+dizzy
+doable
+docile
+dock
+doctrine
+document
+dodge
+dodgy
+doily
+doing
+dole
+dollar
+dollhouse
+dollop
+dolly
+dolphin
+domain
+domelike
+domestic
+dominion
+dominoes
+donated
+donation
+donator
+donor
+donut
+doodle
+doorbell
+doorframe
+doorknob
+doorman
+doormat
+doornail
+doorpost
+doorstep
+doorstop
+doorway
+doozy
+dork
+dormitory
+dorsal
+dosage
+dose
+dotted
+doubling
+douche
+dove
+down
+dowry
+doze
+drab
+dragging
+dragonfly
+dragonish
+dragster
+drainable
+drainage
+drained
+drainer
+drainpipe
+dramatic
+dramatize
+drank
+drapery
+drastic
+draw
+dreaded
+dreadful
+dreadlock
+dreamboat
+dreamily
+dreamland
+dreamless
+dreamlike
+dreamt
+dreamy
+drearily
+dreary
+drench
+dress
+drew
+dribble
+dried
+drier
+drift
+driller
+drilling
+drinkable
+drinking
+dripping
+drippy
+drivable
+driven
+driver
+driveway
+driving
+drizzle
+drizzly
+drone
+drool
+droop
+drop-down
+dropbox
+dropkick
+droplet
+dropout
+dropper
+drove
+drown
+drowsily
+drudge
+drum
+dry
+dubbed
+dubiously
+duchess
+duckbill
+ducking
+duckling
+ducktail
+ducky
+duct
+dude
+duffel
+dugout
+duh
+duke
+duller
+dullness
+duly
+dumping
+dumpling
+dumpster
+duo
+dupe
+duplex
+duplicate
+duplicity
+durable
+durably
+duration
+duress
+during
+dusk
+dust
+dutiful
+duty
+duvet
+dwarf
+dweeb
+dwelled
+dweller
+dwelling
+dwindle
+dwindling
+dynamic
+dynamite
+dynasty
+dyslexia
+dyslexic
+each
+eagle
+earache
+eardrum
+earflap
+earful
+earlobe
+early
+earmark
+earmuff
+earphone
+earpiece
+earplugs
+earring
+earshot
+earthen
+earthlike
+earthling
+earthly
+earthworm
+earthy
+earwig
+easeful
+easel
+easiest
+easily
+easiness
+easing
+eastbound
+eastcoast
+easter
+eastward
+eatable
+eaten
+eatery
+eating
+eats
+ebay
+ebony
+ebook
+ecard
+eccentric
+echo
+eclair
+eclipse
+ecologist
+ecology
+economic
+economist
+economy
+ecosphere
+ecosystem
+edge
+edginess
+edging
+edgy
+edition
+editor
+educated
+education
+educator
+eel
+effective
+effects
+efficient
+effort
+eggbeater
+egging
+eggnog
+eggplant
+eggshell
+egomaniac
+egotism
+egotistic
+either
+eject
+elaborate
+elastic
+elated
+elbow
+eldercare
+elderly
+eldest
+electable
+election
+elective
+elephant
+elevate
+elevating
+elevation
+elevator
+eleven
+elf
+eligible
+eligibly
+eliminate
+elite
+elitism
+elixir
+elk
+ellipse
+elliptic
+elm
+elongated
+elope
+eloquence
+eloquent
+elsewhere
+elude
+elusive
+elves
+email
+embargo
+embark
+embassy
+embattled
+embellish
+ember
+embezzle
+emblaze
+emblem
+embody
+embolism
+emboss
+embroider
+emcee
+emerald
+emergency
+emission
+emit
+emote
+emoticon
+emotion
+empathic
+empathy
+emperor
+emphases
+emphasis
+emphasize
+emphatic
+empirical
+employed
+employee
+employer
+emporium
+empower
+emptier
+emptiness
+empty
+emu
+enable
+enactment
+enamel
+enchanted
+enchilada
+encircle
+enclose
+enclosure
+encode
+encore
+encounter
+encourage
+encroach
+encrust
+encrypt
+endanger
+endeared
+endearing
+ended
+ending
+endless
+endnote
+endocrine
+endorphin
+endorse
+endowment
+endpoint
+endurable
+endurance
+enduring
+energetic
+energize
+energy
+enforced
+enforcer
+engaged
+engaging
+engine
+engorge
+engraved
+engraver
+engraving
+engross
+engulf
+enhance
+enigmatic
+enjoyable
+enjoyably
+enjoyer
+enjoying
+enjoyment
+enlarged
+enlarging
+enlighten
+enlisted
+enquirer
+enrage
+enrich
+enroll
+enslave
+ensnare
+ensure
+entail
+entangled
+entering
+entertain
+enticing
+entire
+entitle
+entity
+entomb
+entourage
+entrap
+entree
+entrench
+entrust
+entryway
+entwine
+enunciate
+envelope
+enviable
+enviably
+envious
+envision
+envoy
+envy
+enzyme
+epic
+epidemic
+epidermal
+epidermis
+epidural
+epilepsy
+epileptic
+epilogue
+epiphany
+episode
+equal
+equate
+equation
+equator
+equinox
+equipment
+equity
+equivocal
+eradicate
+erasable
+erased
+eraser
+erasure
+ergonomic
+errand
+errant
+erratic
+error
+erupt
+escalate
+escalator
+escapable
+escapade
+escapist
+escargot
+eskimo
+esophagus
+espionage
+espresso
+esquire
+essay
+essence
+essential
+establish
+estate
+esteemed
+estimate
+estimator
+estranged
+estrogen
+etching
+eternal
+eternity
+ethanol
+ether
+ethically
+ethics
+euphemism
+evacuate
+evacuee
+evade
+evaluate
+evaluator
+evaporate
+evasion
+evasive
+even
+everglade
+evergreen
+everybody
+everyday
+everyone
+evict
+evidence
+evident
+evil
+evoke
+evolution
+evolve
+exact
+exalted
+example
+excavate
+excavator
+exceeding
+exception
+excess
+exchange
+excitable
+exciting
+exclaim
+exclude
+excluding
+exclusion
+exclusive
+excretion
+excretory
+excursion
+excusable
+excusably
+excuse
+exemplary
+exemplify
+exemption
+exerciser
+exert
+exes
+exfoliate
+exhale
+exhaust
+exhume
+exile
+existing
+exit
+exodus
+exonerate
+exorcism
+exorcist
+expand
+expanse
+expansion
+expansive
+expectant
+expedited
+expediter
+expel
+expend
+expenses
+expensive
+expert
+expire
+expiring
+explain
+expletive
+explicit
+explode
+exploit
+explore
+exploring
+exponent
+exporter
+exposable
+expose
+exposure
+express
+expulsion
+exquisite
+extended
+extending
+extent
+extenuate
+exterior
+external
+extinct
+extortion
+extradite
+extras
+extrovert
+extrude
+extruding
+exuberant
+fable
+fabric
+fabulous
+facebook
+facecloth
+facedown
+faceless
+facelift
+faceplate
+faceted
+facial
+facility
+facing
+facsimile
+faction
+factoid
+factor
+factsheet
+factual
+faculty
+fade
+fading
+failing
+falcon
+fall
+false
+falsify
+fame
+familiar
+family
+famine
+famished
+fanatic
+fancied
+fanciness
+fancy
+fanfare
+fang
+fanning
+fantasize
+fantastic
+fantasy
+fascism
+fastball
+faster
+fasting
+fastness
+faucet
+favorable
+favorably
+favored
+favoring
+favorite
+fax
+feast
+federal
+fedora
+feeble
+feed
+feel
+feisty
+feline
+felt-tip
+feminine
+feminism
+feminist
+feminize
+femur
+fence
+fencing
+fender
+ferment
+fernlike
+ferocious
+ferocity
+ferret
+ferris
+ferry
+fervor
+fester
+festival
+festive
+festivity
+fetal
+fetch
+fever
+fiber
+fiction
+fiddle
+fiddling
+fidelity
+fidgeting
+fidgety
+fifteen
+fifth
+fiftieth
+fifty
+figment
+figure
+figurine
+filing
+filled
+filler
+filling
+film
+filter
+filth
+filtrate
+finale
+finalist
+finalize
+finally
+finance
+financial
+finch
+fineness
+finer
+finicky
+finished
+finisher
+finishing
+finite
+finless
+finlike
+fiscally
+fit
+five
+flaccid
+flagman
+flagpole
+flagship
+flagstick
+flagstone
+flail
+flakily
+flaky
+flame
+flammable
+flanked
+flanking
+flannels
+flap
+flaring
+flashback
+flashbulb
+flashcard
+flashily
+flashing
+flashy
+flask
+flatbed
+flatfoot
+flatly
+flatness
+flatten
+flattered
+flatterer
+flattery
+flattop
+flatware
+flatworm
+flavored
+flavorful
+flavoring
+flaxseed
+fled
+fleshed
+fleshy
+flick
+flier
+flight
+flinch
+fling
+flint
+flip
+flirt
+float
+flock
+flogging
+flop
+floral
+florist
+floss
+flounder
+flyable
+flyaway
+flyer
+flying
+flyover
+flypaper
+foam
+foe
+fog
+foil
+folic
+folk
+follicle
+follow
+fondling
+fondly
+fondness
+fondue
+font
+food
+fool
+footage
+football
+footbath
+footboard
+footer
+footgear
+foothill
+foothold
+footing
+footless
+footman
+footnote
+footpad
+footpath
+footprint
+footrest
+footsie
+footsore
+footwear
+footwork
+fossil
+foster
+founder
+founding
+fountain
+fox
+foyer
+fraction
+fracture
+fragile
+fragility
+fragment
+fragrance
+fragrant
+frail
+frame
+framing
+frantic
+fraternal
+frayed
+fraying
+frays
+freckled
+freckles
+freebase
+freebee
+freebie
+freedom
+freefall
+freehand
+freeing
+freeload
+freely
+freemason
+freeness
+freestyle
+freeware
+freeway
+freewill
+freezable
+freezing
+freight
+french
+frenzied
+frenzy
+frequency
+frequent
+fresh
+fretful
+fretted
+friction
+friday
+fridge
+fried
+friend
+frighten
+frightful
+frigidity
+frigidly
+frill
+fringe
+frisbee
+frisk
+fritter
+frivolous
+frolic
+from
+front
+frostbite
+frosted
+frostily
+frosting
+frostlike
+frosty
+froth
+frown
+frozen
+fructose
+frugality
+frugally
+fruit
+frustrate
+frying
+gab
+gaffe
+gag
+gainfully
+gaining
+gains
+gala
+gallantly
+galleria
+gallery
+galley
+gallon
+gallows
+gallstone
+galore
+galvanize
+gambling
+game
+gaming
+gamma
+gander
+gangly
+gangrene
+gangway
+gap
+garage
+garbage
+garden
+gargle
+garland
+garlic
+garment
+garnet
+garnish
+garter
+gas
+gatherer
+gathering
+gating
+gauging
+gauntlet
+gauze
+gave
+gawk
+gazing
+gear
+gecko
+geek
+geiger
+gem
+gender
+generic
+generous
+genetics
+genre
+gentile
+gentleman
+gently
+gents
+geography
+geologic
+geologist
+geology
+geometric
+geometry
+geranium
+gerbil
+geriatric
+germicide
+germinate
+germless
+germproof
+gestate
+gestation
+gesture
+getaway
+getting
+getup
+giant
+gibberish
+giblet
+giddily
+giddiness
+giddy
+gift
+gigabyte
+gigahertz
+gigantic
+giggle
+giggling
+giggly
+gigolo
+gilled
+gills
+gimmick
+girdle
+giveaway
+given
+giver
+giving
+gizmo
+gizzard
+glacial
+glacier
+glade
+gladiator
+gladly
+glamorous
+glamour
+glance
+glancing
+glandular
+glare
+glaring
+glass
+glaucoma
+glazing
+gleaming
+gleeful
+glider
+gliding
+glimmer
+glimpse
+glisten
+glitch
+glitter
+glitzy
+gloater
+gloating
+gloomily
+gloomy
+glorified
+glorifier
+glorify
+glorious
+glory
+gloss
+glove
+glowing
+glowworm
+glucose
+glue
+gluten
+glutinous
+glutton
+gnarly
+gnat
+goal
+goatskin
+goes
+goggles
+going
+goldfish
+goldmine
+goldsmith
+golf
+goliath
+gonad
+gondola
+gone
+gong
+good
+gooey
+goofball
+goofiness
+goofy
+google
+goon
+gopher
+gore
+gorged
+gorgeous
+gory
+gosling
+gossip
+gothic
+gotten
+gout
+gown
+grab
+graceful
+graceless
+gracious
+gradation
+graded
+grader
+gradient
+grading
+gradually
+graduate
+graffiti
+grafted
+grafting
+grain
+granddad
+grandkid
+grandly
+grandma
+grandpa
+grandson
+granite
+granny
+granola
+grant
+granular
+grape
+graph
+grapple
+grappling
+grasp
+grass
+gratified
+gratify
+grating
+gratitude
+gratuity
+gravel
+graveness
+graves
+graveyard
+gravitate
+gravity
+gravy
+gray
+grazing
+greasily
+greedily
+greedless
+greedy
+green
+greeter
+greeting
+grew
+greyhound
+grid
+grief
+grievance
+grieving
+grievous
+grill
+grimace
+grimacing
+grime
+griminess
+grimy
+grinch
+grinning
+grip
+gristle
+grit
+groggily
+groggy
+groin
+groom
+groove
+grooving
+groovy
+grope
+ground
+grouped
+grout
+grove
+grower
+growing
+growl
+grub
+grudge
+grudging
+grueling
+gruffly
+grumble
+grumbling
+grumbly
+grumpily
+grunge
+grunt
+guacamole
+guidable
+guidance
+guide
+guiding
+guileless
+guise
+gulf
+gullible
+gully
+gulp
+gumball
+gumdrop
+gumminess
+gumming
+gummy
+gurgle
+gurgling
+guru
+gush
+gusto
+gusty
+gutless
+guts
+gutter
+guy
+guzzler
+gyration
+habitable
+habitant
+habitat
+habitual
+hacked
+hacker
+hacking
+hacksaw
+had
+haggler
+haiku
+half
+halogen
+halt
+halved
+halves
+hamburger
+hamlet
+hammock
+hamper
+hamster
+hamstring
+handbag
+handball
+handbook
+handbrake
+handcart
+handclap
+handclasp
+handcraft
+handcuff
+handed
+handful
+handgrip
+handgun
+handheld
+handiness
+handiwork
+handlebar
+handled
+handler
+handling
+handmade
+handoff
+handpick
+handprint
+handrail
+handsaw
+handset
+handsfree
+handshake
+handstand
+handwash
+handwork
+handwoven
+handwrite
+handyman
+hangnail
+hangout
+hangover
+hangup
+hankering
+hankie
+hanky
+haphazard
+happening
+happier
+happiest
+happily
+happiness
+happy
+harbor
+hardcopy
+hardcore
+hardcover
+harddisk
+hardened
+hardener
+hardening
+hardhat
+hardhead
+hardiness
+hardly
+hardness
+hardship
+hardware
+hardwired
+hardwood
+hardy
+harmful
+harmless
+harmonica
+harmonics
+harmonize
+harmony
+harness
+harpist
+harsh
+harvest
+hash
+hassle
+haste
+hastily
+hastiness
+hasty
+hatbox
+hatchback
+hatchery
+hatchet
+hatching
+hatchling
+hate
+hatless
+hatred
+haunt
+haven
+hazard
+hazelnut
+hazily
+haziness
+hazing
+hazy
+headache
+headband
+headboard
+headcount
+headdress
+headed
+header
+headfirst
+headgear
+heading
+headlamp
+headless
+headlock
+headphone
+headpiece
+headrest
+headroom
+headscarf
+headset
+headsman
+headstand
+headstone
+headway
+headwear
+heap
+heat
+heave
+heavily
+heaviness
+heaving
+hedge
+hedging
+heftiness
+hefty
+helium
+helmet
+helper
+helpful
+helping
+helpless
+helpline
+hemlock
+hemstitch
+hence
+henchman
+henna
+herald
+herbal
+herbicide
+herbs
+heritage
+hermit
+heroics
+heroism
+herring
+herself
+hertz
+hesitancy
+hesitant
+hesitate
+hexagon
+hexagram
+hubcap
+huddle
+huddling
+huff
+hug
+hula
+hulk
+hull
+human
+humble
+humbling
+humbly
+humid
+humiliate
+humility
+humming
+hummus
+humongous
+humorist
+humorless
+humorous
+humpback
+humped
+humvee
+hunchback
+hundredth
+hunger
+hungrily
+hungry
+hunk
+hunter
+hunting
+huntress
+huntsman
+hurdle
+hurled
+hurler
+hurling
+hurray
+hurricane
+hurried
+hurry
+hurt
+husband
+hush
+husked
+huskiness
+hut
+hybrid
+hydrant
+hydrated
+hydration
+hydrogen
+hydroxide
+hyperlink
+hypertext
+hyphen
+hypnoses
+hypnosis
+hypnotic
+hypnotism
+hypnotist
+hypnotize
+hypocrisy
+hypocrite
+ibuprofen
+ice
+iciness
+icing
+icky
+icon
+icy
+idealism
+idealist
+idealize
+ideally
+idealness
+identical
+identify
+identity
+ideology
+idiocy
+idiom
+idly
+igloo
+ignition
+ignore
+iguana
+illicitly
+illusion
+illusive
+image
+imaginary
+imagines
+imaging
+imbecile
+imitate
+imitation
+immature
+immerse
+immersion
+imminent
+immobile
+immodest
+immorally
+immortal
+immovable
+immovably
+immunity
+immunize
+impaired
+impale
+impart
+impatient
+impeach
+impeding
+impending
+imperfect
+imperial
+impish
+implant
+implement
+implicate
+implicit
+implode
+implosion
+implosive
+imply
+impolite
+important
+importer
+impose
+imposing
+impotence
+impotency
+impotent
+impound
+imprecise
+imprint
+imprison
+impromptu
+improper
+improve
+improving
+improvise
+imprudent
+impulse
+impulsive
+impure
+impurity
+iodine
+iodize
+ion
+ipad
+iphone
+ipod
+irate
+irk
+iron
+irregular
+irrigate
+irritable
+irritably
+irritant
+irritate
+islamic
+islamist
+isolated
+isolating
+isolation
+isotope
+issue
+issuing
+italicize
+italics
+item
+itinerary
+itunes
+ivory
+ivy
+jab
+jackal
+jacket
+jackknife
+jackpot
+jailbird
+jailbreak
+jailer
+jailhouse
+jalapeno
+jam
+janitor
+january
+jargon
+jarring
+jasmine
+jaundice
+jaunt
+java
+jawed
+jawless
+jawline
+jaws
+jaybird
+jaywalker
+jazz
+jeep
+jeeringly
+jellied
+jelly
+jersey
+jester
+jet
+jiffy
+jigsaw
+jimmy
+jingle
+jingling
+jinx
+jitters
+jittery
+job
+jockey
+jockstrap
+jogger
+jogging
+john
+joining
+jokester
+jokingly
+jolliness
+jolly
+jolt
+jot
+jovial
+joyfully
+joylessly
+joyous
+joyride
+joystick
+jubilance
+jubilant
+judge
+judgingly
+judicial
+judiciary
+judo
+juggle
+juggling
+jugular
+juice
+juiciness
+juicy
+jujitsu
+jukebox
+july
+jumble
+jumbo
+jump
+junction
+juncture
+june
+junior
+juniper
+junkie
+junkman
+junkyard
+jurist
+juror
+jury
+justice
+justifier
+justify
+justly
+justness
+juvenile
+kabob
+kangaroo
+karaoke
+karate
+karma
+kebab
+keenly
+keenness
+keep
+keg
+kelp
+kennel
+kept
+kerchief
+kerosene
+kettle
+kick
+kiln
+kilobyte
+kilogram
+kilometer
+kilowatt
+kilt
+kimono
+kindle
+kindling
+kindly
+kindness
+kindred
+kinetic
+kinfolk
+king
+kinship
+kinsman
+kinswoman
+kissable
+kisser
+kissing
+kitchen
+kite
+kitten
+kitty
+kiwi
+kleenex
+knapsack
+knee
+knelt
+knickers
+knoll
+koala
+kooky
+kosher
+krypton
+kudos
+kung
+labored
+laborer
+laboring
+laborious
+labrador
+ladder
+ladies
+ladle
+ladybug
+ladylike
+lagged
+lagging
+lagoon
+lair
+lake
+lance
+landed
+landfall
+landfill
+landing
+landlady
+landless
+landline
+landlord
+landmark
+landmass
+landmine
+landowner
+landscape
+landside
+landslide
+language
+lankiness
+lanky
+lantern
+lapdog
+lapel
+lapped
+lapping
+laptop
+lard
+large
+lark
+lash
+lasso
+last
+latch
+late
+lather
+latitude
+latrine
+latter
+latticed
+launch
+launder
+laundry
+laurel
+lavender
+lavish
+laxative
+lazily
+laziness
+lazy
+lecturer
+left
+legacy
+legal
+legend
+legged
+leggings
+legible
+legibly
+legislate
+lego
+legroom
+legume
+legwarmer
+legwork
+lemon
+lend
+length
+lens
+lent
+leotard
+lesser
+letdown
+lethargic
+lethargy
+letter
+lettuce
+level
+leverage
+levers
+levitate
+levitator
+liability
+liable
+liberty
+librarian
+library
+licking
+licorice
+lid
+life
+lifter
+lifting
+liftoff
+ligament
+likely
+likeness
+likewise
+liking
+lilac
+lilly
+lily
+limb
+limeade
+limelight
+limes
+limit
+limping
+limpness
+line
+lingo
+linguini
+linguist
+lining
+linked
+linoleum
+linseed
+lint
+lion
+lip
+liquefy
+liqueur
+liquid
+lisp
+list
+litigate
+litigator
+litmus
+litter
+little
+livable
+lived
+lively
+liver
+livestock
+lividly
+living
+lizard
+lubricant
+lubricate
+lucid
+luckily
+luckiness
+luckless
+lucrative
+ludicrous
+lugged
+lukewarm
+lullaby
+lumber
+luminance
+luminous
+lumpiness
+lumping
+lumpish
+lunacy
+lunar
+lunchbox
+luncheon
+lunchroom
+lunchtime
+lung
+lurch
+lure
+luridness
+lurk
+lushly
+lushness
+luster
+lustfully
+lustily
+lustiness
+lustrous
+lusty
+luxurious
+luxury
+lying
+lyrically
+lyricism
+lyricist
+lyrics
+macarena
+macaroni
+macaw
+mace
+machine
+machinist
+magazine
+magenta
+maggot
+magical
+magician
+magma
+magnesium
+magnetic
+magnetism
+magnetize
+magnifier
+magnify
+magnitude
+magnolia
+mahogany
+maimed
+majestic
+majesty
+majorette
+majority
+makeover
+maker
+makeshift
+making
+malformed
+malt
+mama
+mammal
+mammary
+mammogram
+manager
+managing
+manatee
+mandarin
+mandate
+mandatory
+mandolin
+manger
+mangle
+mango
+mangy
+manhandle
+manhole
+manhood
+manhunt
+manicotti
+manicure
+manifesto
+manila
+mankind
+manlike
+manliness
+manly
+manmade
+manned
+mannish
+manor
+manpower
+mantis
+mantra
+manual
+many
+map
+marathon
+marauding
+marbled
+marbles
+marbling
+march
+mardi
+margarine
+margarita
+margin
+marigold
+marina
+marine
+marital
+maritime
+marlin
+marmalade
+maroon
+married
+marrow
+marry
+marshland
+marshy
+marsupial
+marvelous
+marxism
+mascot
+masculine
+mashed
+mashing
+massager
+masses
+massive
+mastiff
+matador
+matchbook
+matchbox
+matcher
+matching
+matchless
+material
+maternal
+maternity
+math
+mating
+matriarch
+matrimony
+matrix
+matron
+matted
+matter
+maturely
+maturing
+maturity
+mauve
+maverick
+maximize
+maximum
+maybe
+mayday
+mayflower
+moaner
+moaning
+mobile
+mobility
+mobilize
+mobster
+mocha
+mocker
+mockup
+modified
+modify
+modular
+modulator
+module
+moisten
+moistness
+moisture
+molar
+molasses
+mold
+molecular
+molecule
+molehill
+mollusk
+mom
+monastery
+monday
+monetary
+monetize
+moneybags
+moneyless
+moneywise
+mongoose
+mongrel
+monitor
+monkhood
+monogamy
+monogram
+monologue
+monopoly
+monorail
+monotone
+monotype
+monoxide
+monsieur
+monsoon
+monstrous
+monthly
+monument
+moocher
+moodiness
+moody
+mooing
+moonbeam
+mooned
+moonlight
+moonlike
+moonlit
+moonrise
+moonscape
+moonshine
+moonstone
+moonwalk
+mop
+morale
+morality
+morally
+morbidity
+morbidly
+morphine
+morphing
+morse
+mortality
+mortally
+mortician
+mortified
+mortify
+mortuary
+mosaic
+mossy
+most
+mothball
+mothproof
+motion
+motivate
+motivator
+motive
+motocross
+motor
+motto
+mountable
+mountain
+mounted
+mounting
+mourner
+mournful
+mouse
+mousiness
+moustache
+mousy
+mouth
+movable
+move
+movie
+moving
+mower
+mowing
+much
+muck
+mud
+mug
+mulberry
+mulch
+mule
+mulled
+mullets
+multiple
+multiply
+multitask
+multitude
+mumble
+mumbling
+mumbo
+mummified
+mummify
+mummy
+mumps
+munchkin
+mundane
+municipal
+muppet
+mural
+murkiness
+murky
+murmuring
+muscular
+museum
+mushily
+mushiness
+mushroom
+mushy
+music
+musket
+muskiness
+musky
+mustang
+mustard
+muster
+mustiness
+musty
+mutable
+mutate
+mutation
+mute
+mutilated
+mutilator
+mutiny
+mutt
+mutual
+muzzle
+myself
+myspace
+mystified
+mystify
+myth
+nacho
+nag
+nail
+name
+naming
+nanny
+nanometer
+nape
+napkin
+napped
+napping
+nappy
+narrow
+nastily
+nastiness
+national
+native
+nativity
+natural
+nature
+naturist
+nautical
+navigate
+navigator
+navy
+nearby
+nearest
+nearly
+nearness
+neatly
+neatness
+nebula
+nebulizer
+nectar
+negate
+negation
+negative
+neglector
+negligee
+negligent
+negotiate
+nemeses
+nemesis
+neon
+nephew
+nerd
+nervous
+nervy
+nest
+net
+neurology
+neuron
+neurosis
+neurotic
+neuter
+neutron
+never
+next
+nibble
+nickname
+nicotine
+niece
+nifty
+nimble
+nimbly
+nineteen
+ninetieth
+ninja
+nintendo
+ninth
+nuclear
+nuclei
+nucleus
+nugget
+nullify
+number
+numbing
+numbly
+numbness
+numeral
+numerate
+numerator
+numeric
+numerous
+nuptials
+nursery
+nursing
+nurture
+nutcase
+nutlike
+nutmeg
+nutrient
+nutshell
+nuttiness
+nutty
+nuzzle
+nylon
+oaf
+oak
+oasis
+oat
+obedience
+obedient
+obituary
+object
+obligate
+obliged
+oblivion
+oblivious
+oblong
+obnoxious
+oboe
+obscure
+obscurity
+observant
+observer
+observing
+obsessed
+obsession
+obsessive
+obsolete
+obstacle
+obstinate
+obstruct
+obtain
+obtrusive
+obtuse
+obvious
+occultist
+occupancy
+occupant
+occupier
+occupy
+ocean
+ocelot
+octagon
+octane
+october
+octopus
+ogle
+oil
+oink
+ointment
+okay
+old
+olive
+olympics
+omega
+omen
+ominous
+omission
+omit
+omnivore
+onboard
+oncoming
+ongoing
+onion
+online
+onlooker
+only
+onscreen
+onset
+onshore
+onslaught
+onstage
+onto
+onward
+onyx
+oops
+ooze
+oozy
+opacity
+opal
+open
+operable
+operate
+operating
+operation
+operative
+operator
+opium
+opossum
+opponent
+oppose
+opposing
+opposite
+oppressed
+oppressor
+opt
+opulently
+osmosis
+other
+otter
+ouch
+ought
+ounce
+outage
+outback
+outbid
+outboard
+outbound
+outbreak
+outburst
+outcast
+outclass
+outcome
+outdated
+outdoors
+outer
+outfield
+outfit
+outflank
+outgoing
+outgrow
+outhouse
+outing
+outlast
+outlet
+outline
+outlook
+outlying
+outmatch
+outmost
+outnumber
+outplayed
+outpost
+outpour
+output
+outrage
+outrank
+outreach
+outright
+outscore
+outsell
+outshine
+outshoot
+outsider
+outskirts
+outsmart
+outsource
+outspoken
+outtakes
+outthink
+outward
+outweigh
+outwit
+oval
+ovary
+oven
+overact
+overall
+overarch
+overbid
+overbill
+overbite
+overblown
+overboard
+overbook
+overbuilt
+overcast
+overcoat
+overcome
+overcook
+overcrowd
+overdraft
+overdrawn
+overdress
+overdrive
+overdue
+overeager
+overeater
+overexert
+overfed
+overfeed
+overfill
+overflow
+overfull
+overgrown
+overhand
+overhang
+overhaul
+overhead
+overhear
+overheat
+overhung
+overjoyed
+overkill
+overlabor
+overlaid
+overlap
+overlay
+overload
+overlook
+overlord
+overlying
+overnight
+overpass
+overpay
+overplant
+overplay
+overpower
+overprice
+overrate
+overreach
+overreact
+override
+overripe
+overrule
+overrun
+overshoot
+overshot
+oversight
+oversized
+oversleep
+oversold
+overspend
+overstate
+overstay
+overstep
+overstock
+overstuff
+oversweet
+overtake
+overthrow
+overtime
+overtly
+overtone
+overture
+overturn
+overuse
+overvalue
+overview
+overwrite
+owl
+oxford
+oxidant
+oxidation
+oxidize
+oxidizing
+oxygen
+oxymoron
+oyster
+ozone
+paced
+pacemaker
+pacific
+pacifier
+pacifism
+pacifist
+pacify
+padded
+padding
+paddle
+paddling
+padlock
+pagan
+pager
+paging
+pajamas
+palace
+palatable
+palm
+palpable
+palpitate
+paltry
+pampered
+pamperer
+pampers
+pamphlet
+panama
+pancake
+pancreas
+panda
+pandemic
+pang
+panhandle
+panic
+panning
+panorama
+panoramic
+panther
+pantomime
+pantry
+pants
+pantyhose
+paparazzi
+papaya
+paper
+paprika
+papyrus
+parabola
+parachute
+parade
+paradox
+paragraph
+parakeet
+paralegal
+paralyses
+paralysis
+paralyze
+paramedic
+parameter
+paramount
+parasail
+parasite
+parasitic
+parcel
+parched
+parchment
+pardon
+parish
+parka
+parking
+parkway
+parlor
+parmesan
+parole
+parrot
+parsley
+parsnip
+partake
+parted
+parting
+partition
+partly
+partner
+partridge
+party
+passable
+passably
+passage
+passcode
+passenger
+passerby
+passing
+passion
+passive
+passivism
+passover
+passport
+password
+pasta
+pasted
+pastel
+pastime
+pastor
+pastrami
+pasture
+pasty
+patchwork
+patchy
+paternal
+paternity
+path
+patience
+patient
+patio
+patriarch
+patriot
+patrol
+patronage
+patronize
+pauper
+pavement
+paver
+pavestone
+pavilion
+paving
+pawing
+payable
+payback
+paycheck
+payday
+payee
+payer
+paying
+payment
+payphone
+payroll
+pebble
+pebbly
+pecan
+pectin
+peculiar
+peddling
+pediatric
+pedicure
+pedigree
+pedometer
+pegboard
+pelican
+pellet
+pelt
+pelvis
+penalize
+penalty
+pencil
+pendant
+pending
+penholder
+penknife
+pennant
+penniless
+penny
+penpal
+pension
+pentagon
+pentagram
+pep
+perceive
+percent
+perch
+percolate
+perennial
+perfected
+perfectly
+perfume
+periscope
+perish
+perjurer
+perjury
+perkiness
+perky
+perm
+peroxide
+perpetual
+perplexed
+persecute
+persevere
+persuaded
+persuader
+pesky
+peso
+pessimism
+pessimist
+pester
+pesticide
+petal
+petite
+petition
+petri
+petroleum
+petted
+petticoat
+pettiness
+petty
+petunia
+phantom
+phobia
+phoenix
+phonebook
+phoney
+phonics
+phoniness
+phony
+phosphate
+photo
+phrase
+phrasing
+placard
+placate
+placidly
+plank
+planner
+plant
+plasma
+plaster
+plastic
+plated
+platform
+plating
+platinum
+platonic
+platter
+platypus
+plausible
+plausibly
+playable
+playback
+player
+playful
+playgroup
+playhouse
+playing
+playlist
+playmaker
+playmate
+playoff
+playpen
+playroom
+playset
+plaything
+playtime
+plaza
+pleading
+pleat
+pledge
+plentiful
+plenty
+plethora
+plexiglas
+pliable
+plod
+plop
+plot
+plow
+ploy
+pluck
+plug
+plunder
+plunging
+plural
+plus
+plutonium
+plywood
+poach
+pod
+poem
+poet
+pogo
+pointed
+pointer
+pointing
+pointless
+pointy
+poise
+poison
+poker
+poking
+polar
+police
+policy
+polio
+polish
+politely
+polka
+polo
+polyester
+polygon
+polygraph
+polymer
+poncho
+pond
+pony
+popcorn
+pope
+poplar
+popper
+poppy
+popsicle
+populace
+popular
+populate
+porcupine
+pork
+porous
+porridge
+portable
+portal
+portfolio
+porthole
+portion
+portly
+portside
+poser
+posh
+posing
+possible
+possibly
+possum
+postage
+postal
+postbox
+postcard
+posted
+poster
+posting
+postnasal
+posture
+postwar
+pouch
+pounce
+pouncing
+pound
+pouring
+pout
+powdered
+powdering
+powdery
+power
+powwow
+pox
+praising
+prance
+prancing
+pranker
+prankish
+prankster
+prayer
+praying
+preacher
+preaching
+preachy
+preamble
+precinct
+precise
+precision
+precook
+precut
+predator
+predefine
+predict
+preface
+prefix
+preflight
+preformed
+pregame
+pregnancy
+pregnant
+preheated
+prelaunch
+prelaw
+prelude
+premiere
+premises
+premium
+prenatal
+preoccupy
+preorder
+prepaid
+prepay
+preplan
+preppy
+preschool
+prescribe
+preseason
+preset
+preshow
+president
+presoak
+press
+presume
+presuming
+preteen
+pretended
+pretender
+pretense
+pretext
+pretty
+pretzel
+prevail
+prevalent
+prevent
+preview
+previous
+prewar
+prewashed
+prideful
+pried
+primal
+primarily
+primary
+primate
+primer
+primp
+princess
+print
+prior
+prism
+prison
+prissy
+pristine
+privacy
+private
+privatize
+prize
+proactive
+probable
+probably
+probation
+probe
+probing
+probiotic
+problem
+procedure
+process
+proclaim
+procreate
+procurer
+prodigal
+prodigy
+produce
+product
+profane
+profanity
+professed
+professor
+profile
+profound
+profusely
+progeny
+prognosis
+program
+progress
+projector
+prologue
+prolonged
+promenade
+prominent
+promoter
+promotion
+prompter
+promptly
+prone
+prong
+pronounce
+pronto
+proofing
+proofread
+proofs
+propeller
+properly
+property
+proponent
+proposal
+propose
+props
+prorate
+protector
+protegee
+proton
+prototype
+protozoan
+protract
+protrude
+proud
+provable
+proved
+proven
+provided
+provider
+providing
+province
+proving
+provoke
+provoking
+provolone
+prowess
+prowler
+prowling
+proximity
+proxy
+prozac
+prude
+prudishly
+prune
+pruning
+pry
+psychic
+public
+publisher
+pucker
+pueblo
+pug
+pull
+pulmonary
+pulp
+pulsate
+pulse
+pulverize
+puma
+pumice
+pummel
+punch
+punctual
+punctuate
+punctured
+pungent
+punisher
+punk
+pupil
+puppet
+puppy
+purchase
+pureblood
+purebred
+purely
+pureness
+purgatory
+purge
+purging
+purifier
+purify
+purist
+puritan
+purity
+purple
+purplish
+purposely
+purr
+purse
+pursuable
+pursuant
+pursuit
+purveyor
+pushcart
+pushchair
+pusher
+pushiness
+pushing
+pushover
+pushpin
+pushup
+pushy
+putdown
+putt
+puzzle
+puzzling
+pyramid
+pyromania
+python
+quack
+quadrant
+quail
+quaintly
+quake
+quaking
+qualified
+qualifier
+qualify
+quality
+qualm
+quantum
+quarrel
+quarry
+quartered
+quarterly
+quarters
+quartet
+quench
+query
+quicken
+quickly
+quickness
+quicksand
+quickstep
+quiet
+quill
+quilt
+quintet
+quintuple
+quirk
+quit
+quiver
+quizzical
+quotable
+quotation
+quote
+rabid
+race
+racing
+racism
+rack
+racoon
+radar
+radial
+radiance
+radiantly
+radiated
+radiation
+radiator
+radio
+radish
+raffle
+raft
+rage
+ragged
+raging
+ragweed
+raider
+railcar
+railing
+railroad
+railway
+raisin
+rake
+raking
+rally
+ramble
+rambling
+ramp
+ramrod
+ranch
+rancidity
+random
+ranged
+ranger
+ranging
+ranked
+ranking
+ransack
+ranting
+rants
+rare
+rarity
+rascal
+rash
+rasping
+ravage
+raven
+ravine
+raving
+ravioli
+ravishing
+reabsorb
+reach
+reacquire
+reaction
+reactive
+reactor
+reaffirm
+ream
+reanalyze
+reappear
+reapply
+reappoint
+reapprove
+rearrange
+rearview
+reason
+reassign
+reassure
+reattach
+reawake
+rebalance
+rebate
+rebel
+rebirth
+reboot
+reborn
+rebound
+rebuff
+rebuild
+rebuilt
+reburial
+rebuttal
+recall
+recant
+recapture
+recast
+recede
+recent
+recess
+recharger
+recipient
+recital
+recite
+reckless
+reclaim
+recliner
+reclining
+recluse
+reclusive
+recognize
+recoil
+recollect
+recolor
+reconcile
+reconfirm
+reconvene
+recopy
+record
+recount
+recoup
+recovery
+recreate
+rectal
+rectangle
+rectified
+rectify
+recycled
+recycler
+recycling
+reemerge
+reenact
+reenter
+reentry
+reexamine
+referable
+referee
+reference
+refill
+refinance
+refined
+refinery
+refining
+refinish
+reflected
+reflector
+reflex
+reflux
+refocus
+refold
+reforest
+reformat
+reformed
+reformer
+reformist
+refract
+refrain
+refreeze
+refresh
+refried
+refueling
+refund
+refurbish
+refurnish
+refusal
+refuse
+refusing
+refutable
+refute
+regain
+regalia
+regally
+reggae
+regime
+region
+register
+registrar
+registry
+regress
+regretful
+regroup
+regular
+regulate
+regulator
+rehab
+reheat
+rehire
+rehydrate
+reimburse
+reissue
+reiterate
+rejoice
+rejoicing
+rejoin
+rekindle
+relapse
+relapsing
+relatable
+related
+relation
+relative
+relax
+relay
+relearn
+release
+relenting
+reliable
+reliably
+reliance
+reliant
+relic
+relieve
+relieving
+relight
+relish
+relive
+reload
+relocate
+relock
+reluctant
+rely
+remake
+remark
+remarry
+rematch
+remedial
+remedy
+remember
+reminder
+remindful
+remission
+remix
+remnant
+remodeler
+remold
+remorse
+remote
+removable
+removal
+removed
+remover
+removing
+rename
+renderer
+rendering
+rendition
+renegade
+renewable
+renewably
+renewal
+renewed
+renounce
+renovate
+renovator
+rentable
+rental
+rented
+renter
+reoccupy
+reoccur
+reopen
+reorder
+repackage
+repacking
+repaint
+repair
+repave
+repaying
+repayment
+repeal
+repeated
+repeater
+repent
+rephrase
+replace
+replay
+replica
+reply
+reporter
+repose
+repossess
+repost
+repressed
+reprimand
+reprint
+reprise
+reproach
+reprocess
+reproduce
+reprogram
+reps
+reptile
+reptilian
+repugnant
+repulsion
+repulsive
+repurpose
+reputable
+reputably
+request
+require
+requisite
+reroute
+rerun
+resale
+resample
+rescuer
+reseal
+research
+reselect
+reseller
+resemble
+resend
+resent
+reset
+reshape
+reshoot
+reshuffle
+residence
+residency
+resident
+residual
+residue
+resigned
+resilient
+resistant
+resisting
+resize
+resolute
+resolved
+resonant
+resonate
+resort
+resource
+respect
+resubmit
+result
+resume
+resupply
+resurface
+resurrect
+retail
+retainer
+retaining
+retake
+retaliate
+retention
+rethink
+retinal
+retired
+retiree
+retiring
+retold
+retool
+retorted
+retouch
+retrace
+retract
+retrain
+retread
+retreat
+retrial
+retrieval
+retriever
+retry
+return
+retying
+retype
+reunion
+reunite
+reusable
+reuse
+reveal
+reveler
+revenge
+revenue
+reverb
+revered
+reverence
+reverend
+reversal
+reverse
+reversing
+reversion
+revert
+revisable
+revise
+revision
+revisit
+revivable
+revival
+reviver
+reviving
+revocable
+revoke
+revolt
+revolver
+revolving
+reward
+rewash
+rewind
+rewire
+reword
+rework
+rewrap
+rewrite
+rhyme
+ribbon
+ribcage
+rice
+riches
+richly
+richness
+rickety
+ricotta
+riddance
+ridden
+ride
+riding
+rifling
+rift
+rigging
+rigid
+rigor
+rimless
+rimmed
+rind
+rink
+rinse
+rinsing
+riot
+ripcord
+ripeness
+ripening
+ripping
+ripple
+rippling
+riptide
+rise
+rising
+risk
+risotto
+ritalin
+ritzy
+rival
+riverbank
+riverbed
+riverboat
+riverside
+riveter
+riveting
+roamer
+roaming
+roast
+robbing
+robe
+robin
+robotics
+robust
+rockband
+rocker
+rocket
+rockfish
+rockiness
+rocking
+rocklike
+rockslide
+rockstar
+rocky
+rogue
+roman
+romp
+rope
+roping
+roster
+rosy
+rotten
+rotting
+rotunda
+roulette
+rounding
+roundish
+roundness
+roundup
+roundworm
+routine
+routing
+rover
+roving
+royal
+rubbed
+rubber
+rubbing
+rubble
+rubdown
+ruby
+ruckus
+rudder
+rug
+ruined
+rule
+rumble
+rumbling
+rummage
+rumor
+runaround
+rundown
+runner
+running
+runny
+runt
+runway
+rupture
+rural
+ruse
+rush
+rust
+rut
+sabbath
+sabotage
+sacrament
+sacred
+sacrifice
+sadden
+saddlebag
+saddled
+saddling
+sadly
+sadness
+safari
+safeguard
+safehouse
+safely
+safeness
+saffron
+saga
+sage
+sagging
+saggy
+said
+saint
+sake
+salad
+salami
+salaried
+salary
+saline
+salon
+saloon
+salsa
+salt
+salutary
+salute
+salvage
+salvaging
+salvation
+same
+sample
+sampling
+sanction
+sanctity
+sanctuary
+sandal
+sandbag
+sandbank
+sandbar
+sandblast
+sandbox
+sanded
+sandfish
+sanding
+sandlot
+sandpaper
+sandpit
+sandstone
+sandstorm
+sandworm
+sandy
+sanitary
+sanitizer
+sank
+santa
+sapling
+sappiness
+sappy
+sarcasm
+sarcastic
+sardine
+sash
+sasquatch
+sassy
+satchel
+satiable
+satin
+satirical
+satisfied
+satisfy
+saturate
+saturday
+sauciness
+saucy
+sauna
+savage
+savanna
+saved
+savings
+savior
+savor
+saxophone
+say
+scabbed
+scabby
+scalded
+scalding
+scale
+scaling
+scallion
+scallop
+scalping
+scam
+scandal
+scanner
+scanning
+scant
+scapegoat
+scarce
+scarcity
+scarecrow
+scared
+scarf
+scarily
+scariness
+scarring
+scary
+scavenger
+scenic
+schedule
+schematic
+scheme
+scheming
+schilling
+schnapps
+scholar
+science
+scientist
+scion
+scoff
+scolding
+scone
+scoop
+scooter
+scope
+scorch
+scorebook
+scorecard
+scored
+scoreless
+scorer
+scoring
+scorn
+scorpion
+scotch
+scoundrel
+scoured
+scouring
+scouting
+scouts
+scowling
+scrabble
+scraggly
+scrambled
+scrambler
+scrap
+scratch
+scrawny
+screen
+scribble
+scribe
+scribing
+scrimmage
+script
+scroll
+scrooge
+scrounger
+scrubbed
+scrubber
+scruffy
+scrunch
+scrutiny
+scuba
+scuff
+sculptor
+sculpture
+scurvy
+scuttle
+secluded
+secluding
+seclusion
+second
+secrecy
+secret
+sectional
+sector
+secular
+securely
+security
+sedan
+sedate
+sedation
+sedative
+sediment
+seduce
+seducing
+segment
+seismic
+seizing
+seldom
+selected
+selection
+selective
+selector
+self
+seltzer
+semantic
+semester
+semicolon
+semifinal
+seminar
+semisoft
+semisweet
+senate
+senator
+send
+senior
+senorita
+sensation
+sensitive
+sensitize
+sensually
+sensuous
+sepia
+september
+septic
+septum
+sequel
+sequence
+sequester
+series
+sermon
+serotonin
+serpent
+serrated
+serve
+service
+serving
+sesame
+sessions
+setback
+setting
+settle
+settling
+setup
+sevenfold
+seventeen
+seventh
+seventy
+severity
+shabby
+shack
+shaded
+shadily
+shadiness
+shading
+shadow
+shady
+shaft
+shakable
+shakily
+shakiness
+shaking
+shaky
+shale
+shallot
+shallow
+shame
+shampoo
+shamrock
+shank
+shanty
+shape
+shaping
+share
+sharpener
+sharper
+sharpie
+sharply
+sharpness
+shawl
+sheath
+shed
+sheep
+sheet
+shelf
+shell
+shelter
+shelve
+shelving
+sherry
+shield
+shifter
+shifting
+shiftless
+shifty
+shimmer
+shimmy
+shindig
+shine
+shingle
+shininess
+shining
+shiny
+ship
+shirt
+shivering
+shock
+shone
+shoplift
+shopper
+shopping
+shoptalk
+shore
+shortage
+shortcake
+shortcut
+shorten
+shorter
+shorthand
+shortlist
+shortly
+shortness
+shorts
+shortwave
+shorty
+shout
+shove
+showbiz
+showcase
+showdown
+shower
+showgirl
+showing
+showman
+shown
+showoff
+showpiece
+showplace
+showroom
+showy
+shrank
+shrapnel
+shredder
+shredding
+shrewdly
+shriek
+shrill
+shrimp
+shrine
+shrink
+shrivel
+shrouded
+shrubbery
+shrubs
+shrug
+shrunk
+shucking
+shudder
+shuffle
+shuffling
+shun
+shush
+shut
+shy
+siamese
+siberian
+sibling
+siding
+sierra
+siesta
+sift
+sighing
+silenced
+silencer
+silent
+silica
+silicon
+silk
+silliness
+silly
+silo
+silt
+silver
+similarly
+simile
+simmering
+simple
+simplify
+simply
+sincere
+sincerity
+singer
+singing
+single
+singular
+sinister
+sinless
+sinner
+sinuous
+sip
+siren
+sister
+sitcom
+sitter
+sitting
+situated
+situation
+sixfold
+sixteen
+sixth
+sixties
+sixtieth
+sixtyfold
+sizable
+sizably
+size
+sizing
+sizzle
+sizzling
+skater
+skating
+skedaddle
+skeletal
+skeleton
+skeptic
+sketch
+skewed
+skewer
+skid
+skied
+skier
+skies
+skiing
+skilled
+skillet
+skillful
+skimmed
+skimmer
+skimming
+skimpily
+skincare
+skinhead
+skinless
+skinning
+skinny
+skintight
+skipper
+skipping
+skirmish
+skirt
+skittle
+skydiver
+skylight
+skyline
+skype
+skyrocket
+skyward
+slab
+slacked
+slacker
+slacking
+slackness
+slacks
+slain
+slam
+slander
+slang
+slapping
+slapstick
+slashed
+slashing
+slate
+slather
+slaw
+sled
+sleek
+sleep
+sleet
+sleeve
+slept
+sliceable
+sliced
+slicer
+slicing
+slick
+slider
+slideshow
+sliding
+slighted
+slighting
+slightly
+slimness
+slimy
+slinging
+slingshot
+slinky
+slip
+slit
+sliver
+slobbery
+slogan
+sloped
+sloping
+sloppily
+sloppy
+slot
+slouching
+slouchy
+sludge
+slug
+slum
+slurp
+slush
+sly
+small
+smartly
+smartness
+smasher
+smashing
+smashup
+smell
+smelting
+smile
+smilingly
+smirk
+smite
+smith
+smitten
+smock
+smog
+smoked
+smokeless
+smokiness
+smoking
+smoky
+smolder
+smooth
+smother
+smudge
+smudgy
+smuggler
+smuggling
+smugly
+smugness
+snack
+snagged
+snaking
+snap
+snare
+snarl
+snazzy
+sneak
+sneer
+sneeze
+sneezing
+snide
+sniff
+snippet
+snipping
+snitch
+snooper
+snooze
+snore
+snoring
+snorkel
+snort
+snout
+snowbird
+snowboard
+snowbound
+snowcap
+snowdrift
+snowdrop
+snowfall
+snowfield
+snowflake
+snowiness
+snowless
+snowman
+snowplow
+snowshoe
+snowstorm
+snowsuit
+snowy
+snub
+snuff
+snuggle
+snugly
+snugness
+speak
+spearfish
+spearhead
+spearman
+spearmint
+species
+specimen
+specked
+speckled
+specks
+spectacle
+spectator
+spectrum
+speculate
+speech
+speed
+spellbind
+speller
+spelling
+spendable
+spender
+spending
+spent
+spew
+sphere
+spherical
+sphinx
+spider
+spied
+spiffy
+spill
+spilt
+spinach
+spinal
+spindle
+spinner
+spinning
+spinout
+spinster
+spiny
+spiral
+spirited
+spiritism
+spirits
+spiritual
+splashed
+splashing
+splashy
+splatter
+spleen
+splendid
+splendor
+splice
+splicing
+splinter
+splotchy
+splurge
+spoilage
+spoiled
+spoiler
+spoiling
+spoils
+spoken
+spokesman
+sponge
+spongy
+sponsor
+spoof
+spookily
+spooky
+spool
+spoon
+spore
+sporting
+sports
+sporty
+spotless
+spotlight
+spotted
+spotter
+spotting
+spotty
+spousal
+spouse
+spout
+sprain
+sprang
+sprawl
+spray
+spree
+sprig
+spring
+sprinkled
+sprinkler
+sprint
+sprite
+sprout
+spruce
+sprung
+spry
+spud
+spur
+sputter
+spyglass
+squabble
+squad
+squall
+squander
+squash
+squatted
+squatter
+squatting
+squeak
+squealer
+squealing
+squeamish
+squeegee
+squeeze
+squeezing
+squid
+squiggle
+squiggly
+squint
+squire
+squirt
+squishier
+squishy
+stability
+stabilize
+stable
+stack
+stadium
+staff
+stage
+staging
+stagnant
+stagnate
+stainable
+stained
+staining
+stainless
+stalemate
+staleness
+stalling
+stallion
+stamina
+stammer
+stamp
+stand
+stank
+staple
+stapling
+starboard
+starch
+stardom
+stardust
+starfish
+stargazer
+staring
+stark
+starless
+starlet
+starlight
+starlit
+starring
+starry
+starship
+starter
+starting
+startle
+startling
+startup
+starved
+starving
+stash
+state
+static
+statistic
+statue
+stature
+status
+statute
+statutory
+staunch
+stays
+steadfast
+steadier
+steadily
+steadying
+steam
+steed
+steep
+steerable
+steering
+steersman
+stegosaur
+stellar
+stem
+stench
+stencil
+step
+stereo
+sterile
+sterility
+sterilize
+sterling
+sternness
+sternum
+stew
+stick
+stiffen
+stiffly
+stiffness
+stifle
+stifling
+stillness
+stilt
+stimulant
+stimulate
+stimuli
+stimulus
+stinger
+stingily
+stinging
+stingray
+stingy
+stinking
+stinky
+stipend
+stipulate
+stir
+stitch
+stock
+stoic
+stoke
+stole
+stomp
+stonewall
+stoneware
+stonework
+stoning
+stony
+stood
+stooge
+stool
+stoop
+stoplight
+stoppable
+stoppage
+stopped
+stopper
+stopping
+stopwatch
+storable
+storage
+storeroom
+storewide
+storm
+stout
+stove
+stowaway
+stowing
+straddle
+straggler
+strained
+strainer
+straining
+strangely
+stranger
+strangle
+strategic
+strategy
+stratus
+straw
+stray
+streak
+stream
+street
+strength
+strenuous
+strep
+stress
+stretch
+strewn
+stricken
+strict
+stride
+strife
+strike
+striking
+strive
+striving
+strobe
+strode
+stroller
+strongbox
+strongly
+strongman
+struck
+structure
+strudel
+struggle
+strum
+strung
+strut
+stubbed
+stubble
+stubbly
+stubborn
+stucco
+stuck
+student
+studied
+studio
+study
+stuffed
+stuffing
+stuffy
+stumble
+stumbling
+stump
+stung
+stunned
+stunner
+stunning
+stunt
+stupor
+sturdily
+sturdy
+styling
+stylishly
+stylist
+stylized
+stylus
+suave
+subarctic
+subatomic
+subdivide
+subdued
+subduing
+subfloor
+subgroup
+subheader
+subject
+sublease
+sublet
+sublevel
+sublime
+submarine
+submerge
+submersed
+submitter
+subpanel
+subpar
+subplot
+subprime
+subscribe
+subscript
+subsector
+subside
+subsiding
+subsidize
+subsidy
+subsoil
+subsonic
+substance
+subsystem
+subtext
+subtitle
+subtly
+subtotal
+subtract
+subtype
+suburb
+subway
+subwoofer
+subzero
+succulent
+such
+suction
+sudden
+sudoku
+suds
+sufferer
+suffering
+suffice
+suffix
+suffocate
+suffrage
+sugar
+suggest
+suing
+suitable
+suitably
+suitcase
+suitor
+sulfate
+sulfide
+sulfite
+sulfur
+sulk
+sullen
+sulphate
+sulphuric
+sultry
+superbowl
+superglue
+superhero
+superior
+superjet
+superman
+supermom
+supernova
+supervise
+supper
+supplier
+supply
+support
+supremacy
+supreme
+surcharge
+surely
+sureness
+surface
+surfacing
+surfboard
+surfer
+surgery
+surgical
+surging
+surname
+surpass
+surplus
+surprise
+surreal
+surrender
+surrogate
+surround
+survey
+survival
+survive
+surviving
+survivor
+sushi
+suspect
+suspend
+suspense
+sustained
+sustainer
+swab
+swaddling
+swagger
+swampland
+swan
+swapping
+swarm
+sway
+swear
+sweat
+sweep
+swell
+swept
+swerve
+swifter
+swiftly
+swiftness
+swimmable
+swimmer
+swimming
+swimsuit
+swimwear
+swinger
+swinging
+swipe
+swirl
+switch
+swivel
+swizzle
+swooned
+swoop
+swoosh
+swore
+sworn
+swung
+sycamore
+sympathy
+symphonic
+symphony
+symptom
+synapse
+syndrome
+synergy
+synopses
+synopsis
+synthesis
+synthetic
+syrup
+system
+t-shirt
+tabasco
+tabby
+tableful
+tables
+tablet
+tableware
+tabloid
+tackiness
+tacking
+tackle
+tackling
+tacky
+taco
+tactful
+tactical
+tactics
+tactile
+tactless
+tadpole
+taekwondo
+tag
+tainted
+take
+taking
+talcum
+talisman
+tall
+talon
+tamale
+tameness
+tamer
+tamper
+tank
+tanned
+tannery
+tanning
+tantrum
+tapeless
+tapered
+tapering
+tapestry
+tapioca
+tapping
+taps
+tarantula
+target
+tarmac
+tarnish
+tarot
+tartar
+tartly
+tartness
+task
+tassel
+taste
+tastiness
+tasting
+tasty
+tattered
+tattle
+tattling
+tattoo
+taunt
+tavern
+thank
+that
+thaw
+theater
+theatrics
+thee
+theft
+theme
+theology
+theorize
+thermal
+thermos
+thesaurus
+these
+thesis
+thespian
+thicken
+thicket
+thickness
+thieving
+thievish
+thigh
+thimble
+thing
+think
+thinly
+thinner
+thinness
+thinning
+thirstily
+thirsting
+thirsty
+thirteen
+thirty
+thong
+thorn
+those
+thousand
+thrash
+thread
+threaten
+threefold
+thrift
+thrill
+thrive
+thriving
+throat
+throbbing
+throng
+throttle
+throwaway
+throwback
+thrower
+throwing
+thud
+thumb
+thumping
+thursday
+thus
+thwarting
+thyself
+tiara
+tibia
+tidal
+tidbit
+tidiness
+tidings
+tidy
+tiger
+tighten
+tightly
+tightness
+tightrope
+tightwad
+tigress
+tile
+tiling
+till
+tilt
+timid
+timing
+timothy
+tinderbox
+tinfoil
+tingle
+tingling
+tingly
+tinker
+tinkling
+tinsel
+tinsmith
+tint
+tinwork
+tiny
+tipoff
+tipped
+tipper
+tipping
+tiptoeing
+tiptop
+tiring
+tissue
+trace
+tracing
+track
+traction
+tractor
+trade
+trading
+tradition
+traffic
+tragedy
+trailing
+trailside
+train
+traitor
+trance
+tranquil
+transfer
+transform
+translate
+transpire
+transport
+transpose
+trapdoor
+trapeze
+trapezoid
+trapped
+trapper
+trapping
+traps
+trash
+travel
+traverse
+travesty
+tray
+treachery
+treading
+treadmill
+treason
+treat
+treble
+tree
+trekker
+tremble
+trembling
+tremor
+trench
+trend
+trespass
+triage
+trial
+triangle
+tribesman
+tribunal
+tribune
+tributary
+tribute
+triceps
+trickery
+trickily
+tricking
+trickle
+trickster
+tricky
+tricolor
+tricycle
+trident
+tried
+trifle
+trifocals
+trillion
+trilogy
+trimester
+trimmer
+trimming
+trimness
+trinity
+trio
+tripod
+tripping
+triumph
+trivial
+trodden
+trolling
+trombone
+trophy
+tropical
+tropics
+trouble
+troubling
+trough
+trousers
+trout
+trowel
+truce
+truck
+truffle
+trump
+trunks
+trustable
+trustee
+trustful
+trusting
+trustless
+truth
+try
+tubby
+tubeless
+tubular
+tucking
+tuesday
+tug
+tuition
+tulip
+tumble
+tumbling
+tummy
+turban
+turbine
+turbofan
+turbojet
+turbulent
+turf
+turkey
+turmoil
+turret
+turtle
+tusk
+tutor
+tutu
+tux
+tweak
+tweed
+tweet
+tweezers
+twelve
+twentieth
+twenty
+twerp
+twice
+twiddle
+twiddling
+twig
+twilight
+twine
+twins
+twirl
+twistable
+twisted
+twister
+twisting
+twisty
+twitch
+twitter
+tycoon
+tying
+tyke
+udder
+ultimate
+ultimatum
+ultra
+umbilical
+umbrella
+umpire
+unabashed
+unable
+unadorned
+unadvised
+unafraid
+unaired
+unaligned
+unaltered
+unarmored
+unashamed
+unaudited
+unawake
+unaware
+unbaked
+unbalance
+unbeaten
+unbend
+unbent
+unbiased
+unbitten
+unblended
+unblessed
+unblock
+unbolted
+unbounded
+unboxed
+unbraided
+unbridle
+unbroken
+unbuckled
+unbundle
+unburned
+unbutton
+uncanny
+uncapped
+uncaring
+uncertain
+unchain
+unchanged
+uncharted
+uncheck
+uncivil
+unclad
+unclaimed
+unclamped
+unclasp
+uncle
+unclip
+uncloak
+unclog
+unclothed
+uncoated
+uncoiled
+uncolored
+uncombed
+uncommon
+uncooked
+uncork
+uncorrupt
+uncounted
+uncouple
+uncouth
+uncover
+uncross
+uncrown
+uncrushed
+uncured
+uncurious
+uncurled
+uncut
+undamaged
+undated
+undaunted
+undead
+undecided
+undefined
+underage
+underarm
+undercoat
+undercook
+undercut
+underdog
+underdone
+underfed
+underfeed
+underfoot
+undergo
+undergrad
+underhand
+underline
+underling
+undermine
+undermost
+underpaid
+underpass
+underpay
+underrate
+undertake
+undertone
+undertook
+undertow
+underuse
+underwear
+underwent
+underwire
+undesired
+undiluted
+undivided
+undocked
+undoing
+undone
+undrafted
+undress
+undrilled
+undusted
+undying
+unearned
+unearth
+unease
+uneasily
+uneasy
+uneatable
+uneaten
+unedited
+unelected
+unending
+unengaged
+unenvied
+unequal
+unethical
+uneven
+unexpired
+unexposed
+unfailing
+unfair
+unfasten
+unfazed
+unfeeling
+unfiled
+unfilled
+unfitted
+unfitting
+unfixable
+unfixed
+unflawed
+unfocused
+unfold
+unfounded
+unframed
+unfreeze
+unfrosted
+unfrozen
+unfunded
+unglazed
+ungloved
+unglue
+ungodly
+ungraded
+ungreased
+unguarded
+unguided
+unhappily
+unhappy
+unharmed
+unhealthy
+unheard
+unhearing
+unheated
+unhelpful
+unhidden
+unhinge
+unhitched
+unholy
+unhook
+unicorn
+unicycle
+unified
+unifier
+uniformed
+uniformly
+unify
+unimpeded
+uninjured
+uninstall
+uninsured
+uninvited
+union
+uniquely
+unisexual
+unison
+unissued
+unit
+universal
+universe
+unjustly
+unkempt
+unkind
+unknotted
+unknowing
+unknown
+unlaced
+unlatch
+unlawful
+unleaded
+unlearned
+unleash
+unless
+unleveled
+unlighted
+unlikable
+unlimited
+unlined
+unlinked
+unlisted
+unlit
+unlivable
+unloaded
+unloader
+unlocked
+unlocking
+unlovable
+unloved
+unlovely
+unloving
+unluckily
+unlucky
+unmade
+unmanaged
+unmanned
+unmapped
+unmarked
+unmasked
+unmasking
+unmatched
+unmindful
+unmixable
+unmixed
+unmolded
+unmoral
+unmovable
+unmoved
+unmoving
+unnamable
+unnamed
+unnatural
+unneeded
+unnerve
+unnerving
+unnoticed
+unopened
+unopposed
+unpack
+unpadded
+unpaid
+unpainted
+unpaired
+unpaved
+unpeeled
+unpicked
+unpiloted
+unpinned
+unplanned
+unplanted
+unpleased
+unpledged
+unplowed
+unplug
+unpopular
+unproven
+unquote
+unranked
+unrated
+unraveled
+unreached
+unread
+unreal
+unreeling
+unrefined
+unrelated
+unrented
+unrest
+unretired
+unrevised
+unrigged
+unripe
+unrivaled
+unroasted
+unrobed
+unroll
+unruffled
+unruly
+unrushed
+unsaddle
+unsafe
+unsaid
+unsalted
+unsaved
+unsavory
+unscathed
+unscented
+unscrew
+unsealed
+unseated
+unsecured
+unseeing
+unseemly
+unseen
+unselect
+unselfish
+unsent
+unsettled
+unshackle
+unshaken
+unshaved
+unshaven
+unsheathe
+unshipped
+unsightly
+unsigned
+unskilled
+unsliced
+unsmooth
+unsnap
+unsocial
+unsoiled
+unsold
+unsolved
+unsorted
+unspoiled
+unspoken
+unstable
+unstaffed
+unstamped
+unsteady
+unsterile
+unstirred
+unstitch
+unstopped
+unstuck
+unstuffed
+unstylish
+unsubtle
+unsubtly
+unsuited
+unsure
+unsworn
+untagged
+untainted
+untaken
+untamed
+untangled
+untapped
+untaxed
+unthawed
+unthread
+untidy
+untie
+until
+untimed
+untimely
+untitled
+untoasted
+untold
+untouched
+untracked
+untrained
+untreated
+untried
+untrimmed
+untrue
+untruth
+unturned
+untwist
+untying
+unusable
+unused
+unusual
+unvalued
+unvaried
+unvarying
+unveiled
+unveiling
+unvented
+unviable
+unvisited
+unvocal
+unwanted
+unwarlike
+unwary
+unwashed
+unwatched
+unweave
+unwed
+unwelcome
+unwell
+unwieldy
+unwilling
+unwind
+unwired
+unwitting
+unwomanly
+unworldly
+unworn
+unworried
+unworthy
+unwound
+unwoven
+unwrapped
+unwritten
+unzip
+upbeat
+upchuck
+upcoming
+upcountry
+update
+upfront
+upgrade
+upheaval
+upheld
+uphill
+uphold
+uplifted
+uplifting
+upload
+upon
+upper
+upright
+uprising
+upriver
+uproar
+uproot
+upscale
+upside
+upstage
+upstairs
+upstart
+upstate
+upstream
+upstroke
+upswing
+uptake
+uptight
+uptown
+upturned
+upward
+upwind
+uranium
+urban
+urchin
+urethane
+urgency
+urgent
+urging
+urologist
+urology
+usable
+usage
+useable
+used
+uselessly
+user
+usher
+usual
+utensil
+utility
+utilize
+utmost
+utopia
+utter
+vacancy
+vacant
+vacate
+vacation
+vagabond
+vagrancy
+vagrantly
+vaguely
+vagueness
+valiant
+valid
+valium
+valley
+valuables
+value
+vanilla
+vanish
+vanity
+vanquish
+vantage
+vaporizer
+variable
+variably
+varied
+variety
+various
+varmint
+varnish
+varsity
+varying
+vascular
+vaseline
+vastly
+vastness
+veal
+vegan
+veggie
+vehicular
+velcro
+velocity
+velvet
+vendetta
+vending
+vendor
+veneering
+vengeful
+venomous
+ventricle
+venture
+venue
+venus
+verbalize
+verbally
+verbose
+verdict
+verify
+verse
+version
+versus
+vertebrae
+vertical
+vertigo
+very
+vessel
+vest
+veteran
+veto
+vexingly
+viability
+viable
+vibes
+vice
+vicinity
+victory
+video
+viewable
+viewer
+viewing
+viewless
+viewpoint
+vigorous
+village
+villain
+vindicate
+vineyard
+vintage
+violate
+violation
+violator
+violet
+violin
+viper
+viral
+virtual
+virtuous
+virus
+visa
+viscosity
+viscous
+viselike
+visible
+visibly
+vision
+visiting
+visitor
+visor
+vista
+vitality
+vitalize
+vitally
+vitamins
+vivacious
+vividly
+vividness
+vixen
+vocalist
+vocalize
+vocally
+vocation
+voice
+voicing
+void
+volatile
+volley
+voltage
+volumes
+voter
+voting
+voucher
+vowed
+vowel
+voyage
+wackiness
+wad
+wafer
+waffle
+waged
+wager
+wages
+waggle
+wagon
+wake
+waking
+walk
+walmart
+walnut
+walrus
+waltz
+wand
+wannabe
+wanted
+wanting
+wasabi
+washable
+washbasin
+washboard
+washbowl
+washcloth
+washday
+washed
+washer
+washhouse
+washing
+washout
+washroom
+washstand
+washtub
+wasp
+wasting
+watch
+water
+waviness
+waving
+wavy
+whacking
+whacky
+wham
+wharf
+wheat
+whenever
+whiff
+whimsical
+whinny
+whiny
+whisking
+whoever
+whole
+whomever
+whoopee
+whooping
+whoops
+why
+wick
+widely
+widen
+widget
+widow
+width
+wieldable
+wielder
+wife
+wifi
+wikipedia
+wildcard
+wildcat
+wilder
+wildfire
+wildfowl
+wildland
+wildlife
+wildly
+wildness
+willed
+willfully
+willing
+willow
+willpower
+wilt
+wimp
+wince
+wincing
+wind
+wing
+winking
+winner
+winnings
+winter
+wipe
+wired
+wireless
+wiring
+wiry
+wisdom
+wise
+wish
+wisplike
+wispy
+wistful
+wizard
+wobble
+wobbling
+wobbly
+wok
+wolf
+wolverine
+womanhood
+womankind
+womanless
+womanlike
+womanly
+womb
+woof
+wooing
+wool
+woozy
+word
+work
+worried
+worrier
+worrisome
+worry
+worsening
+worshiper
+worst
+wound
+woven
+wow
+wrangle
+wrath
+wreath
+wreckage
+wrecker
+wrecking
+wrench
+wriggle
+wriggly
+wrinkle
+wrinkly
+wrist
+writing
+written
+wrongdoer
+wronged
+wrongful
+wrongly
+wrongness
+wrought
+xbox
+xerox
+yahoo
+yam
+yanking
+yapping
+yard
+yarn
+yeah
+yearbook
+yearling
+yearly
+yearning
+yeast
+yelling
+yelp
+yen
+yesterday
+yiddish
+yield
+yin
+yippee
+yo-yo
+yodel
+yoga
+yogurt
+yonder
+yoyo
+yummy
+zap
+zealous
+zebra
+zen
+zeppelin
+zero
+zestfully
+zesty
+zigzagged
+zipfile
+zipping
+zippy
+zips
+zit
+zodiac
+zombie
+zone
+zoning
+zookeeper
+zoologist
+zoology
+zoom
diff --git a/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/eff_prefixed.txt b/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/eff_prefixed.txt
new file mode 100644
index 0000000..9ac732f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/eff_prefixed.txt
@@ -0,0 +1,1296 @@
+aardvark
+abandoned
+abbreviate
+abdomen
+abhorrence
+abiding
+abnormal
+abrasion
+absorbing
+abundant
+abyss
+academy
+accountant
+acetone
+achiness
+acid
+acoustics
+acquire
+acrobat
+actress
+acuteness
+aerosol
+aesthetic
+affidavit
+afloat
+afraid
+aftershave
+again
+agency
+aggressor
+aghast
+agitate
+agnostic
+agonizing
+agreeing
+aidless
+aimlessly
+ajar
+alarmclock
+albatross
+alchemy
+alfalfa
+algae
+aliens
+alkaline
+almanac
+alongside
+alphabet
+already
+also
+altitude
+aluminum
+always
+amazingly
+ambulance
+amendment
+amiable
+ammunition
+amnesty
+amoeba
+amplifier
+amuser
+anagram
+anchor
+android
+anesthesia
+angelfish
+animal
+anklet
+announcer
+anonymous
+answer
+antelope
+anxiety
+anyplace
+aorta
+apartment
+apnea
+apostrophe
+apple
+apricot
+aquamarine
+arachnid
+arbitrate
+ardently
+arena
+argument
+aristocrat
+armchair
+aromatic
+arrowhead
+arsonist
+artichoke
+asbestos
+ascend
+aseptic
+ashamed
+asinine
+asleep
+asocial
+asparagus
+astronaut
+asymmetric
+atlas
+atmosphere
+atom
+atrocious
+attic
+atypical
+auctioneer
+auditorium
+augmented
+auspicious
+automobile
+auxiliary
+avalanche
+avenue
+aviator
+avocado
+awareness
+awhile
+awkward
+awning
+awoke
+axially
+azalea
+babbling
+backpack
+badass
+bagpipe
+bakery
+balancing
+bamboo
+banana
+barracuda
+basket
+bathrobe
+bazooka
+blade
+blender
+blimp
+blouse
+blurred
+boatyard
+bobcat
+body
+bogusness
+bohemian
+boiler
+bonnet
+boots
+borough
+bossiness
+bottle
+bouquet
+boxlike
+breath
+briefcase
+broom
+brushes
+bubblegum
+buckle
+buddhist
+buffalo
+bullfrog
+bunny
+busboy
+buzzard
+cabin
+cactus
+cadillac
+cafeteria
+cage
+cahoots
+cajoling
+cakewalk
+calculator
+camera
+canister
+capsule
+carrot
+cashew
+cathedral
+caucasian
+caviar
+ceasefire
+cedar
+celery
+cement
+census
+ceramics
+cesspool
+chalkboard
+cheesecake
+chimney
+chlorine
+chopsticks
+chrome
+chute
+cilantro
+cinnamon
+circle
+cityscape
+civilian
+clay
+clergyman
+clipboard
+clock
+clubhouse
+coathanger
+cobweb
+coconut
+codeword
+coexistent
+coffeecake
+cognitive
+cohabitate
+collarbone
+computer
+confetti
+copier
+cornea
+cosmetics
+cotton
+couch
+coverless
+coyote
+coziness
+crawfish
+crewmember
+crib
+croissant
+crumble
+crystal
+cubical
+cucumber
+cuddly
+cufflink
+cuisine
+culprit
+cup
+curry
+cushion
+cuticle
+cybernetic
+cyclist
+cylinder
+cymbal
+cynicism
+cypress
+cytoplasm
+dachshund
+daffodil
+dagger
+dairy
+dalmatian
+dandelion
+dartboard
+dastardly
+datebook
+daughter
+dawn
+daytime
+dazzler
+dealer
+debris
+decal
+dedicate
+deepness
+defrost
+degree
+dehydrator
+deliverer
+democrat
+dentist
+deodorant
+depot
+deranged
+desktop
+detergent
+device
+dexterity
+diamond
+dibs
+dictionary
+diffuser
+digit
+dilated
+dimple
+dinnerware
+dioxide
+diploma
+directory
+dishcloth
+ditto
+dividers
+dizziness
+doctor
+dodge
+doll
+dominoes
+donut
+doorstep
+dorsal
+double
+downstairs
+dozed
+drainpipe
+dresser
+driftwood
+droppings
+drum
+dryer
+dubiously
+duckling
+duffel
+dugout
+dumpster
+duplex
+durable
+dustpan
+dutiful
+duvet
+dwarfism
+dwelling
+dwindling
+dynamite
+dyslexia
+eagerness
+earlobe
+easel
+eavesdrop
+ebook
+eccentric
+echoless
+eclipse
+ecosystem
+ecstasy
+edged
+editor
+educator
+eelworm
+eerie
+effects
+eggnog
+egomaniac
+ejection
+elastic
+elbow
+elderly
+elephant
+elfishly
+eliminator
+elk
+elliptical
+elongated
+elsewhere
+elusive
+elves
+emancipate
+embroidery
+emcee
+emerald
+emission
+emoticon
+emperor
+emulate
+enactment
+enchilada
+endorphin
+energy
+enforcer
+engine
+enhance
+enigmatic
+enjoyably
+enlarged
+enormous
+enquirer
+enrollment
+ensemble
+entryway
+enunciate
+envoy
+enzyme
+epidemic
+equipment
+erasable
+ergonomic
+erratic
+eruption
+escalator
+eskimo
+esophagus
+espresso
+essay
+estrogen
+etching
+eternal
+ethics
+etiquette
+eucalyptus
+eulogy
+euphemism
+euthanize
+evacuation
+evergreen
+evidence
+evolution
+exam
+excerpt
+exerciser
+exfoliate
+exhale
+exist
+exorcist
+explode
+exquisite
+exterior
+exuberant
+fabric
+factory
+faded
+failsafe
+falcon
+family
+fanfare
+fasten
+faucet
+favorite
+feasibly
+february
+federal
+feedback
+feigned
+feline
+femur
+fence
+ferret
+festival
+fettuccine
+feudalist
+feverish
+fiberglass
+fictitious
+fiddle
+figurine
+fillet
+finalist
+fiscally
+fixture
+flashlight
+fleshiness
+flight
+florist
+flypaper
+foamless
+focus
+foggy
+folksong
+fondue
+footpath
+fossil
+fountain
+fox
+fragment
+freeway
+fridge
+frosting
+fruit
+fryingpan
+gadget
+gainfully
+gallstone
+gamekeeper
+gangway
+garlic
+gaslight
+gathering
+gauntlet
+gearbox
+gecko
+gem
+generator
+geographer
+gerbil
+gesture
+getaway
+geyser
+ghoulishly
+gibberish
+giddiness
+giftshop
+gigabyte
+gimmick
+giraffe
+giveaway
+gizmo
+glasses
+gleeful
+glisten
+glove
+glucose
+glycerin
+gnarly
+gnomish
+goatskin
+goggles
+goldfish
+gong
+gooey
+gorgeous
+gosling
+gothic
+gourmet
+governor
+grape
+greyhound
+grill
+groundhog
+grumbling
+guacamole
+guerrilla
+guitar
+gullible
+gumdrop
+gurgling
+gusto
+gutless
+gymnast
+gynecology
+gyration
+habitat
+hacking
+haggard
+haiku
+halogen
+hamburger
+handgun
+happiness
+hardhat
+hastily
+hatchling
+haughty
+hazelnut
+headband
+hedgehog
+hefty
+heinously
+helmet
+hemoglobin
+henceforth
+herbs
+hesitation
+hexagon
+hubcap
+huddling
+huff
+hugeness
+hullabaloo
+human
+hunter
+hurricane
+hushing
+hyacinth
+hybrid
+hydrant
+hygienist
+hypnotist
+ibuprofen
+icepack
+icing
+iconic
+identical
+idiocy
+idly
+igloo
+ignition
+iguana
+illuminate
+imaging
+imbecile
+imitator
+immigrant
+imprint
+iodine
+ionosphere
+ipad
+iphone
+iridescent
+irksome
+iron
+irrigation
+island
+isotope
+issueless
+italicize
+itemizer
+itinerary
+itunes
+ivory
+jabbering
+jackrabbit
+jaguar
+jailhouse
+jalapeno
+jamboree
+janitor
+jarring
+jasmine
+jaundice
+jawbreaker
+jaywalker
+jazz
+jealous
+jeep
+jelly
+jeopardize
+jersey
+jetski
+jezebel
+jiffy
+jigsaw
+jingling
+jobholder
+jockstrap
+jogging
+john
+joinable
+jokingly
+journal
+jovial
+joystick
+jubilant
+judiciary
+juggle
+juice
+jujitsu
+jukebox
+jumpiness
+junkyard
+juror
+justifying
+juvenile
+kabob
+kamikaze
+kangaroo
+karate
+kayak
+keepsake
+kennel
+kerosene
+ketchup
+khaki
+kickstand
+kilogram
+kimono
+kingdom
+kiosk
+kissing
+kite
+kleenex
+knapsack
+kneecap
+knickers
+koala
+krypton
+laboratory
+ladder
+lakefront
+lantern
+laptop
+laryngitis
+lasagna
+latch
+laundry
+lavender
+laxative
+lazybones
+lecturer
+leftover
+leggings
+leisure
+lemon
+length
+leopard
+leprechaun
+lettuce
+leukemia
+levers
+lewdness
+liability
+library
+licorice
+lifeboat
+lightbulb
+likewise
+lilac
+limousine
+lint
+lioness
+lipstick
+liquid
+listless
+litter
+liverwurst
+lizard
+llama
+luau
+lubricant
+lucidity
+ludicrous
+luggage
+lukewarm
+lullaby
+lumberjack
+lunchbox
+luridness
+luscious
+luxurious
+lyrics
+macaroni
+maestro
+magazine
+mahogany
+maimed
+majority
+makeover
+malformed
+mammal
+mango
+mapmaker
+marbles
+massager
+matchstick
+maverick
+maximum
+mayonnaise
+moaning
+mobilize
+moccasin
+modify
+moisture
+molecule
+momentum
+monastery
+moonshine
+mortuary
+mosquito
+motorcycle
+mousetrap
+movie
+mower
+mozzarella
+muckiness
+mudflow
+mugshot
+mule
+mummy
+mundane
+muppet
+mural
+mustard
+mutation
+myriad
+myspace
+myth
+nail
+namesake
+nanosecond
+napkin
+narrator
+nastiness
+natives
+nautically
+navigate
+nearest
+nebula
+nectar
+nefarious
+negotiator
+neither
+nemesis
+neoliberal
+nephew
+nervously
+nest
+netting
+neuron
+nevermore
+nextdoor
+nicotine
+niece
+nimbleness
+nintendo
+nirvana
+nuclear
+nugget
+nuisance
+nullify
+numbing
+nuptials
+nursery
+nutcracker
+nylon
+oasis
+oat
+obediently
+obituary
+object
+obliterate
+obnoxious
+observer
+obtain
+obvious
+occupation
+oceanic
+octopus
+ocular
+office
+oftentimes
+oiliness
+ointment
+older
+olympics
+omissible
+omnivorous
+oncoming
+onion
+onlooker
+onstage
+onward
+onyx
+oomph
+opaquely
+opera
+opium
+opossum
+opponent
+optical
+opulently
+oscillator
+osmosis
+ostrich
+otherwise
+ought
+outhouse
+ovation
+oven
+owlish
+oxford
+oxidize
+oxygen
+oyster
+ozone
+pacemaker
+padlock
+pageant
+pajamas
+palm
+pamphlet
+pantyhose
+paprika
+parakeet
+passport
+patio
+pauper
+pavement
+payphone
+pebble
+peculiarly
+pedometer
+pegboard
+pelican
+penguin
+peony
+pepperoni
+peroxide
+pesticide
+petroleum
+pewter
+pharmacy
+pheasant
+phonebook
+phrasing
+physician
+plank
+pledge
+plotted
+plug
+plywood
+pneumonia
+podiatrist
+poetic
+pogo
+poison
+poking
+policeman
+poncho
+popcorn
+porcupine
+postcard
+poultry
+powerboat
+prairie
+pretzel
+princess
+propeller
+prune
+pry
+pseudo
+psychopath
+publisher
+pucker
+pueblo
+pulley
+pumpkin
+punchbowl
+puppy
+purse
+pushup
+putt
+puzzle
+pyramid
+python
+quarters
+quesadilla
+quilt
+quote
+racoon
+radish
+ragweed
+railroad
+rampantly
+rancidity
+rarity
+raspberry
+ravishing
+rearrange
+rebuilt
+receipt
+reentry
+refinery
+register
+rehydrate
+reimburse
+rejoicing
+rekindle
+relic
+remote
+renovator
+reopen
+reporter
+request
+rerun
+reservoir
+retriever
+reunion
+revolver
+rewrite
+rhapsody
+rhetoric
+rhino
+rhubarb
+rhyme
+ribbon
+riches
+ridden
+rigidness
+rimmed
+riptide
+riskily
+ritzy
+riverboat
+roamer
+robe
+rocket
+romancer
+ropelike
+rotisserie
+roundtable
+royal
+rubber
+rudderless
+rugby
+ruined
+rulebook
+rummage
+running
+rupture
+rustproof
+sabotage
+sacrifice
+saddlebag
+saffron
+sainthood
+saltshaker
+samurai
+sandworm
+sapphire
+sardine
+sassy
+satchel
+sauna
+savage
+saxophone
+scarf
+scenario
+schoolbook
+scientist
+scooter
+scrapbook
+sculpture
+scythe
+secretary
+sedative
+segregator
+seismology
+selected
+semicolon
+senator
+septum
+sequence
+serpent
+sesame
+settler
+severely
+shack
+shelf
+shirt
+shovel
+shrimp
+shuttle
+shyness
+siamese
+sibling
+siesta
+silicon
+simmering
+singles
+sisterhood
+sitcom
+sixfold
+sizable
+skateboard
+skeleton
+skies
+skulk
+skylight
+slapping
+sled
+slingshot
+sloth
+slumbering
+smartphone
+smelliness
+smitten
+smokestack
+smudge
+snapshot
+sneezing
+sniff
+snowsuit
+snugness
+speakers
+sphinx
+spider
+splashing
+sponge
+sprout
+spur
+spyglass
+squirrel
+statue
+steamboat
+stingray
+stopwatch
+strawberry
+student
+stylus
+suave
+subway
+suction
+suds
+suffocate
+sugar
+suitcase
+sulphur
+superstore
+surfer
+sushi
+swan
+sweatshirt
+swimwear
+sword
+sycamore
+syllable
+symphony
+synagogue
+syringes
+systemize
+tablespoon
+taco
+tadpole
+taekwondo
+tagalong
+takeout
+tallness
+tamale
+tanned
+tapestry
+tarantula
+tastebud
+tattoo
+tavern
+thaw
+theater
+thimble
+thorn
+throat
+thumb
+thwarting
+tiara
+tidbit
+tiebreaker
+tiger
+timid
+tinsel
+tiptoeing
+tirade
+tissue
+tractor
+tree
+tripod
+trousers
+trucks
+tryout
+tubeless
+tuesday
+tugboat
+tulip
+tumbleweed
+tupperware
+turtle
+tusk
+tutorial
+tuxedo
+tweezers
+twins
+tyrannical
+ultrasound
+umbrella
+umpire
+unarmored
+unbuttoned
+uncle
+underwear
+unevenness
+unflavored
+ungloved
+unhinge
+unicycle
+unjustly
+unknown
+unlocking
+unmarked
+unnoticed
+unopened
+unpaved
+unquenched
+unroll
+unscrewing
+untied
+unusual
+unveiled
+unwrinkled
+unyielding
+unzip
+upbeat
+upcountry
+update
+upfront
+upgrade
+upholstery
+upkeep
+upload
+uppercut
+upright
+upstairs
+uptown
+upwind
+uranium
+urban
+urchin
+urethane
+urgent
+urologist
+username
+usher
+utensil
+utility
+utmost
+utopia
+utterance
+vacuum
+vagrancy
+valuables
+vanquished
+vaporizer
+varied
+vaseline
+vegetable
+vehicle
+velcro
+vendor
+vertebrae
+vestibule
+veteran
+vexingly
+vicinity
+videogame
+viewfinder
+vigilante
+village
+vinegar
+violin
+viperfish
+virus
+visor
+vitamins
+vivacious
+vixen
+vocalist
+vogue
+voicemail
+volleyball
+voucher
+voyage
+vulnerable
+waffle
+wagon
+wakeup
+walrus
+wanderer
+wasp
+water
+waving
+wheat
+whisper
+wholesaler
+wick
+widow
+wielder
+wifeless
+wikipedia
+wildcat
+windmill
+wipeout
+wired
+wishbone
+wizardry
+wobbliness
+wolverine
+womb
+woolworker
+workbasket
+wound
+wrangle
+wreckage
+wristwatch
+wrongdoing
+xerox
+xylophone
+yacht
+yahoo
+yard
+yearbook
+yesterday
+yiddish
+yield
+yo-yo
+yodel
+yogurt
+yuppie
+zealot
+zebra
+zeppelin
+zestfully
+zigzagged
+zillion
+zipping
+zirconium
+zodiac
+zombie
+zookeeper
+zucchini
diff --git a/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/eff_short.txt b/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/eff_short.txt
new file mode 100644
index 0000000..4c8baa4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/_data/wordsets/eff_short.txt
@@ -0,0 +1,1296 @@
+acid
+acorn
+acre
+acts
+afar
+affix
+aged
+agent
+agile
+aging
+agony
+ahead
+aide
+aids
+aim
+ajar
+alarm
+alias
+alibi
+alien
+alike
+alive
+aloe
+aloft
+aloha
+alone
+amend
+amino
+ample
+amuse
+angel
+anger
+angle
+ankle
+apple
+april
+apron
+aqua
+area
+arena
+argue
+arise
+armed
+armor
+army
+aroma
+array
+arson
+art
+ashen
+ashes
+atlas
+atom
+attic
+audio
+avert
+avoid
+awake
+award
+awoke
+axis
+bacon
+badge
+bagel
+baggy
+baked
+baker
+balmy
+banjo
+barge
+barn
+bash
+basil
+bask
+batch
+bath
+baton
+bats
+blade
+blank
+blast
+blaze
+bleak
+blend
+bless
+blimp
+blink
+bloat
+blob
+blog
+blot
+blunt
+blurt
+blush
+boast
+boat
+body
+boil
+bok
+bolt
+boned
+boney
+bonus
+bony
+book
+booth
+boots
+boss
+botch
+both
+boxer
+breed
+bribe
+brick
+bride
+brim
+bring
+brink
+brisk
+broad
+broil
+broke
+brook
+broom
+brush
+buck
+bud
+buggy
+bulge
+bulk
+bully
+bunch
+bunny
+bunt
+bush
+bust
+busy
+buzz
+cable
+cache
+cadet
+cage
+cake
+calm
+cameo
+canal
+candy
+cane
+canon
+cape
+card
+cargo
+carol
+carry
+carve
+case
+cash
+cause
+cedar
+chain
+chair
+chant
+chaos
+charm
+chase
+cheek
+cheer
+chef
+chess
+chest
+chew
+chief
+chili
+chill
+chip
+chomp
+chop
+chow
+chuck
+chump
+chunk
+churn
+chute
+cider
+cinch
+city
+civic
+civil
+clad
+claim
+clamp
+clap
+clash
+clasp
+class
+claw
+clay
+clean
+clear
+cleat
+cleft
+clerk
+click
+cling
+clink
+clip
+cloak
+clock
+clone
+cloth
+cloud
+clump
+coach
+coast
+coat
+cod
+coil
+coke
+cola
+cold
+colt
+coma
+come
+comic
+comma
+cone
+cope
+copy
+coral
+cork
+cost
+cot
+couch
+cough
+cover
+cozy
+craft
+cramp
+crane
+crank
+crate
+crave
+crawl
+crazy
+creme
+crepe
+crept
+crib
+cried
+crisp
+crook
+crop
+cross
+crowd
+crown
+crumb
+crush
+crust
+cub
+cult
+cupid
+cure
+curl
+curry
+curse
+curve
+curvy
+cushy
+cut
+cycle
+dab
+dad
+daily
+dairy
+daisy
+dance
+dandy
+darn
+dart
+dash
+data
+date
+dawn
+deaf
+deal
+dean
+debit
+debt
+debug
+decaf
+decal
+decay
+deck
+decor
+decoy
+deed
+delay
+denim
+dense
+dent
+depth
+derby
+desk
+dial
+diary
+dice
+dig
+dill
+dime
+dimly
+diner
+dingy
+disco
+dish
+disk
+ditch
+ditzy
+dizzy
+dock
+dodge
+doing
+doll
+dome
+donor
+donut
+dose
+dot
+dove
+down
+dowry
+doze
+drab
+drama
+drank
+draw
+dress
+dried
+drift
+drill
+drive
+drone
+droop
+drove
+drown
+drum
+dry
+duck
+duct
+dude
+dug
+duke
+duo
+dusk
+dust
+duty
+dwarf
+dwell
+eagle
+early
+earth
+easel
+east
+eaten
+eats
+ebay
+ebony
+ebook
+echo
+edge
+eel
+eject
+elbow
+elder
+elf
+elk
+elm
+elope
+elude
+elves
+email
+emit
+empty
+emu
+enter
+entry
+envoy
+equal
+erase
+error
+erupt
+essay
+etch
+evade
+even
+evict
+evil
+evoke
+exact
+exit
+fable
+faced
+fact
+fade
+fall
+false
+fancy
+fang
+fax
+feast
+feed
+femur
+fence
+fend
+ferry
+fetal
+fetch
+fever
+fiber
+fifth
+fifty
+film
+filth
+final
+finch
+fit
+five
+flag
+flaky
+flame
+flap
+flask
+fled
+flick
+fling
+flint
+flip
+flirt
+float
+flock
+flop
+floss
+flyer
+foam
+foe
+fog
+foil
+folic
+folk
+food
+fool
+found
+fox
+foyer
+frail
+frame
+fray
+fresh
+fried
+frill
+frisk
+from
+front
+frost
+froth
+frown
+froze
+fruit
+gag
+gains
+gala
+game
+gap
+gas
+gave
+gear
+gecko
+geek
+gem
+genre
+gift
+gig
+gills
+given
+giver
+glad
+glass
+glide
+gloss
+glove
+glow
+glue
+goal
+going
+golf
+gong
+good
+gooey
+goofy
+gore
+gown
+grab
+grain
+grant
+grape
+graph
+grasp
+grass
+grave
+gravy
+gray
+green
+greet
+grew
+grid
+grief
+grill
+grip
+grit
+groom
+grope
+growl
+grub
+grunt
+guide
+gulf
+gulp
+gummy
+guru
+gush
+gut
+guy
+habit
+half
+halo
+halt
+happy
+harm
+hash
+hasty
+hatch
+hate
+haven
+hazel
+hazy
+heap
+heat
+heave
+hedge
+hefty
+help
+herbs
+hers
+hub
+hug
+hula
+hull
+human
+humid
+hump
+hung
+hunk
+hunt
+hurry
+hurt
+hush
+hut
+ice
+icing
+icon
+icy
+igloo
+image
+ion
+iron
+islam
+issue
+item
+ivory
+ivy
+jab
+jam
+jaws
+jazz
+jeep
+jelly
+jet
+jiffy
+job
+jog
+jolly
+jolt
+jot
+joy
+judge
+juice
+juicy
+july
+jumbo
+jump
+junky
+juror
+jury
+keep
+keg
+kept
+kick
+kilt
+king
+kite
+kitty
+kiwi
+knee
+knelt
+koala
+kung
+ladle
+lady
+lair
+lake
+lance
+land
+lapel
+large
+lash
+lasso
+last
+latch
+late
+lazy
+left
+legal
+lemon
+lend
+lens
+lent
+level
+lever
+lid
+life
+lift
+lilac
+lily
+limb
+limes
+line
+lint
+lion
+lip
+list
+lived
+liver
+lunar
+lunch
+lung
+lurch
+lure
+lurk
+lying
+lyric
+mace
+maker
+malt
+mama
+mango
+manor
+many
+map
+march
+mardi
+marry
+mash
+match
+mate
+math
+moan
+mocha
+moist
+mold
+mom
+moody
+mop
+morse
+most
+motor
+motto
+mount
+mouse
+mousy
+mouth
+move
+movie
+mower
+mud
+mug
+mulch
+mule
+mull
+mumbo
+mummy
+mural
+muse
+music
+musky
+mute
+nacho
+nag
+nail
+name
+nanny
+nap
+navy
+near
+neat
+neon
+nerd
+nest
+net
+next
+niece
+ninth
+nutty
+oak
+oasis
+oat
+ocean
+oil
+old
+olive
+omen
+onion
+only
+ooze
+opal
+open
+opera
+opt
+otter
+ouch
+ounce
+outer
+oval
+oven
+owl
+ozone
+pace
+pagan
+pager
+palm
+panda
+panic
+pants
+panty
+paper
+park
+party
+pasta
+patch
+path
+patio
+payer
+pecan
+penny
+pep
+perch
+perky
+perm
+pest
+petal
+petri
+petty
+photo
+plank
+plant
+plaza
+plead
+plot
+plow
+pluck
+plug
+plus
+poach
+pod
+poem
+poet
+pogo
+point
+poise
+poker
+polar
+polio
+polka
+polo
+pond
+pony
+poppy
+pork
+poser
+pouch
+pound
+pout
+power
+prank
+press
+print
+prior
+prism
+prize
+probe
+prong
+proof
+props
+prude
+prune
+pry
+pug
+pull
+pulp
+pulse
+puma
+punch
+punk
+pupil
+puppy
+purr
+purse
+push
+putt
+quack
+quake
+query
+quiet
+quill
+quilt
+quit
+quota
+quote
+rabid
+race
+rack
+radar
+radio
+raft
+rage
+raid
+rail
+rake
+rally
+ramp
+ranch
+range
+rank
+rant
+rash
+raven
+reach
+react
+ream
+rebel
+recap
+relax
+relay
+relic
+remix
+repay
+repel
+reply
+rerun
+reset
+rhyme
+rice
+rich
+ride
+rigid
+rigor
+rinse
+riot
+ripen
+rise
+risk
+ritzy
+rival
+river
+roast
+robe
+robin
+rock
+rogue
+roman
+romp
+rope
+rover
+royal
+ruby
+rug
+ruin
+rule
+runny
+rush
+rust
+rut
+sadly
+sage
+said
+saint
+salad
+salon
+salsa
+salt
+same
+sandy
+santa
+satin
+sauna
+saved
+savor
+sax
+say
+scale
+scam
+scan
+scare
+scarf
+scary
+scoff
+scold
+scoop
+scoot
+scope
+score
+scorn
+scout
+scowl
+scrap
+scrub
+scuba
+scuff
+sect
+sedan
+self
+send
+sepia
+serve
+set
+seven
+shack
+shade
+shady
+shaft
+shaky
+sham
+shape
+share
+sharp
+shed
+sheep
+sheet
+shelf
+shell
+shine
+shiny
+ship
+shirt
+shock
+shop
+shore
+shout
+shove
+shown
+showy
+shred
+shrug
+shun
+shush
+shut
+shy
+sift
+silk
+silly
+silo
+sip
+siren
+sixth
+size
+skate
+skew
+skid
+skier
+skies
+skip
+skirt
+skit
+sky
+slab
+slack
+slain
+slam
+slang
+slash
+slate
+slaw
+sled
+sleek
+sleep
+sleet
+slept
+slice
+slick
+slimy
+sling
+slip
+slit
+slob
+slot
+slug
+slum
+slurp
+slush
+small
+smash
+smell
+smile
+smirk
+smog
+snack
+snap
+snare
+snarl
+sneak
+sneer
+sniff
+snore
+snort
+snout
+snowy
+snub
+snuff
+speak
+speed
+spend
+spent
+spew
+spied
+spill
+spiny
+spoil
+spoke
+spoof
+spool
+spoon
+sport
+spot
+spout
+spray
+spree
+spur
+squad
+squat
+squid
+stack
+staff
+stage
+stain
+stall
+stamp
+stand
+stank
+stark
+start
+stash
+state
+stays
+steam
+steep
+stem
+step
+stew
+stick
+sting
+stir
+stock
+stole
+stomp
+stony
+stood
+stool
+stoop
+stop
+storm
+stout
+stove
+straw
+stray
+strut
+stuck
+stud
+stuff
+stump
+stung
+stunt
+suds
+sugar
+sulk
+surf
+sushi
+swab
+swan
+swarm
+sway
+swear
+sweat
+sweep
+swell
+swept
+swim
+swing
+swipe
+swirl
+swoop
+swore
+syrup
+tacky
+taco
+tag
+take
+tall
+talon
+tamer
+tank
+taper
+taps
+tarot
+tart
+task
+taste
+tasty
+taunt
+thank
+thaw
+theft
+theme
+thigh
+thing
+think
+thong
+thorn
+those
+throb
+thud
+thumb
+thump
+thus
+tiara
+tidal
+tidy
+tiger
+tile
+tilt
+tint
+tiny
+trace
+track
+trade
+train
+trait
+trap
+trash
+tray
+treat
+tree
+trek
+trend
+trial
+tribe
+trick
+trio
+trout
+truce
+truck
+trump
+trunk
+try
+tug
+tulip
+tummy
+turf
+tusk
+tutor
+tutu
+tux
+tweak
+tweet
+twice
+twine
+twins
+twirl
+twist
+uncle
+uncut
+undo
+unify
+union
+unit
+untie
+upon
+upper
+urban
+used
+user
+usher
+utter
+value
+vapor
+vegan
+venue
+verse
+vest
+veto
+vice
+video
+view
+viral
+virus
+visa
+visor
+vixen
+vocal
+voice
+void
+volt
+voter
+vowel
+wad
+wafer
+wager
+wages
+wagon
+wake
+walk
+wand
+wasp
+watch
+water
+wavy
+wheat
+whiff
+whole
+whoop
+wick
+widen
+widow
+width
+wife
+wifi
+wilt
+wimp
+wind
+wing
+wink
+wipe
+wired
+wiry
+wise
+wish
+wispy
+wok
+wolf
+womb
+wool
+woozy
+word
+work
+worry
+wound
+woven
+wrath
+wreck
+wrist
+xerox
+yahoo
+yam
+yard
+year
+yeast
+yelp
+yield
+yo-yo
+yodel
+yoga
+yoyo
+yummy
+zebra
+zero
+zesty
+zippy
+zone
+zoom
diff --git a/myenv/lib/python3.9/site-packages/passlib/apache.py b/myenv/lib/python3.9/site-packages/passlib/apache.py
new file mode 100644
index 0000000..a75f2cf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/apache.py
@@ -0,0 +1,1255 @@
+"""passlib.apache - apache password support"""
+# XXX: relocate this to passlib.ext.apache?
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+import logging; log = logging.getLogger(__name__)
+import os
+from warnings import warn
+# site
+# pkg
+from passlib import exc, registry
+from passlib.context import CryptContext
+from passlib.exc import ExpectedStringError
+from passlib.hash import htdigest
+from passlib.utils import render_bytes, to_bytes, is_ascii_codec
+from passlib.utils.decor import deprecated_method
+from passlib.utils.compat import join_bytes, unicode, BytesIO, PY3
+# local
+__all__ = [
+    'HtpasswdFile',
+    'HtdigestFile',
+]
+
+#=============================================================================
+# constants & support
+#=============================================================================
+_UNSET = object()
+
+_BCOLON = b":"
+_BHASH = b"#"
+
+# byte values that aren't allowed in fields.
+_INVALID_FIELD_CHARS = b":\n\r\t\x00"
+
+#: _CommonFile._source token types
+_SKIPPED = "skipped"
+_RECORD = "record"
+
+#=============================================================================
+# common helpers
+#=============================================================================
+class _CommonFile(object):
+    """common framework for HtpasswdFile & HtdigestFile"""
+    #===================================================================
+    # instance attrs
+    #===================================================================
+
+    # charset encoding used by file (defaults to utf-8)
+    encoding = None
+
+    # whether users() and other public methods should return unicode or bytes?
+    # (defaults to False under PY2, True under PY3)
+    return_unicode = None
+
+    # if bound to local file, these will be set.
+    _path = None # local file path
+    _mtime = None # mtime when last loaded, or 0
+
+    # if true, automatically save to local file after changes are made.
+    autosave = False
+
+    # dict mapping key -> value for all records in database.
+    # (e.g. user => hash for Htpasswd)
+    _records = None
+
+    #: list of tokens for recreating original file contents when saving. if present,
+    #: will be sequence of (_SKIPPED, b"whitespace/comments") and (_RECORD, <record key>) tuples.
+    _source = None
+
+    #===================================================================
+    # alt constuctors
+    #===================================================================
+    @classmethod
+    def from_string(cls, data, **kwds):
+        """create new object from raw string.
+
+        :type data: unicode or bytes
+        :arg data:
+            database to load, as single string.
+
+        :param \\*\\*kwds:
+            all other keywords are the same as in the class constructor
+        """
+        if 'path' in kwds:
+            raise TypeError("'path' not accepted by from_string()")
+        self = cls(**kwds)
+        self.load_string(data)
+        return self
+
+    @classmethod
+    def from_path(cls, path, **kwds):
+        """create new object from file, without binding object to file.
+
+        :type path: str
+        :arg path:
+            local filepath to load from
+
+        :param \\*\\*kwds:
+            all other keywords are the same as in the class constructor
+        """
+        self = cls(**kwds)
+        self.load(path)
+        return self
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, path=None, new=False, autoload=True, autosave=False,
+                 encoding="utf-8", return_unicode=PY3,
+                 ):
+        # set encoding
+        if not encoding:
+            warn("``encoding=None`` is deprecated as of Passlib 1.6, "
+                 "and will cause a ValueError in Passlib 1.8, "
+                 "use ``return_unicode=False`` instead.",
+                 DeprecationWarning, stacklevel=2)
+            encoding = "utf-8"
+            return_unicode = False
+        elif not is_ascii_codec(encoding):
+            # htpasswd/htdigest files assumes 1-byte chars, and use ":" separator,
+            # so only ascii-compatible encodings are allowed.
+            raise ValueError("encoding must be 7-bit ascii compatible")
+        self.encoding = encoding
+
+        # set other attrs
+        self.return_unicode = return_unicode
+        self.autosave = autosave
+        self._path = path
+        self._mtime = 0
+
+        # init db
+        if not autoload:
+            warn("``autoload=False`` is deprecated as of Passlib 1.6, "
+                 "and will be removed in Passlib 1.8, use ``new=True`` instead",
+                 DeprecationWarning, stacklevel=2)
+            new = True
+        if path and not new:
+            self.load()
+        else:
+            self._records = {}
+            self._source = []
+
+    def __repr__(self):
+        tail = ''
+        if self.autosave:
+            tail += ' autosave=True'
+        if self._path:
+            tail += ' path=%r' % self._path
+        if self.encoding != "utf-8":
+            tail += ' encoding=%r' % self.encoding
+        return "<%s 0x%0x%s>" % (self.__class__.__name__, id(self), tail)
+
+    # NOTE: ``path`` is a property so that ``_mtime`` is wiped when it's set.
+
+    @property
+    def path(self):
+        return self._path
+
+    @path.setter
+    def path(self, value):
+        if value != self._path:
+            self._mtime = 0
+        self._path = value
+
+    @property
+    def mtime(self):
+        """modify time when last loaded (if bound to a local file)"""
+        return self._mtime
+
+    #===================================================================
+    # loading
+    #===================================================================
+    def load_if_changed(self):
+        """Reload from ``self.path`` only if file has changed since last load"""
+        if not self._path:
+            raise RuntimeError("%r is not bound to a local file" % self)
+        if self._mtime and self._mtime == os.path.getmtime(self._path):
+            return False
+        self.load()
+        return True
+
+    def load(self, path=None, force=True):
+        """Load state from local file.
+        If no path is specified, attempts to load from ``self.path``.
+
+        :type path: str
+        :arg path: local file to load from
+
+        :type force: bool
+        :param force:
+            if ``force=False``, only load from ``self.path`` if file
+            has changed since last load.
+
+            .. deprecated:: 1.6
+                This keyword will be removed in Passlib 1.8;
+                Applications should use :meth:`load_if_changed` instead.
+        """
+        if path is not None:
+            with open(path, "rb") as fh:
+                self._mtime = 0
+                self._load_lines(fh)
+        elif not force:
+            warn("%(name)s.load(force=False) is deprecated as of Passlib 1.6,"
+                 "and will be removed in Passlib 1.8; "
+                 "use %(name)s.load_if_changed() instead." %
+                 dict(name=self.__class__.__name__),
+                 DeprecationWarning, stacklevel=2)
+            return self.load_if_changed()
+        elif self._path:
+            with open(self._path, "rb") as fh:
+                self._mtime = os.path.getmtime(self._path)
+                self._load_lines(fh)
+        else:
+            raise RuntimeError("%s().path is not set, an explicit path is required" %
+                               self.__class__.__name__)
+        return True
+
+    def load_string(self, data):
+        """Load state from unicode or bytes string, replacing current state"""
+        data = to_bytes(data, self.encoding, "data")
+        self._mtime = 0
+        self._load_lines(BytesIO(data))
+
+    def _load_lines(self, lines):
+        """load from sequence of lists"""
+        parse = self._parse_record
+        records = {}
+        source = []
+        skipped = b''
+        for idx, line in enumerate(lines):
+            # NOTE: per htpasswd source (https://github.com/apache/httpd/blob/trunk/support/htpasswd.c),
+            #       lines with only whitespace, or with "#" as first non-whitespace char,
+            #       are left alone / ignored.
+            tmp = line.lstrip()
+            if not tmp or tmp.startswith(_BHASH):
+                skipped += line
+                continue
+
+            # parse valid line
+            key, value = parse(line, idx+1)
+
+            # NOTE: if multiple entries for a key, we use the first one,
+            #       which seems to match htpasswd source
+            if key in records:
+                log.warning("username occurs multiple times in source file: %r" % key)
+                skipped += line
+                continue
+
+            # flush buffer of skipped whitespace lines
+            if skipped:
+                source.append((_SKIPPED, skipped))
+                skipped = b''
+
+            # store new user line
+            records[key] = value
+            source.append((_RECORD, key))
+
+        # don't bother preserving trailing whitespace, but do preserve trailing comments
+        if skipped.rstrip():
+            source.append((_SKIPPED, skipped))
+
+        # NOTE: not replacing ._records until parsing succeeds, so loading is atomic.
+        self._records = records
+        self._source = source
+
+    def _parse_record(self, record, lineno): # pragma: no cover - abstract method
+        """parse line of file into (key, value) pair"""
+        raise NotImplementedError("should be implemented in subclass")
+
+    def _set_record(self, key, value):
+        """
+        helper for setting record which takes care of inserting source line if needed;
+
+        :returns:
+            bool if key already present
+        """
+        records = self._records
+        existing = (key in records)
+        records[key] = value
+        if not existing:
+            self._source.append((_RECORD, key))
+        return existing
+
+    #===================================================================
+    # saving
+    #===================================================================
+    def _autosave(self):
+        """subclass helper to call save() after any changes"""
+        if self.autosave and self._path:
+            self.save()
+
+    def save(self, path=None):
+        """Save current state to file.
+        If no path is specified, attempts to save to ``self.path``.
+        """
+        if path is not None:
+            with open(path, "wb") as fh:
+                fh.writelines(self._iter_lines())
+        elif self._path:
+            self.save(self._path)
+            self._mtime = os.path.getmtime(self._path)
+        else:
+            raise RuntimeError("%s().path is not set, cannot autosave" %
+                               self.__class__.__name__)
+
+    def to_string(self):
+        """Export current state as a string of bytes"""
+        return join_bytes(self._iter_lines())
+
+    # def clean(self):
+    #     """
+    #     discard any comments or whitespace that were being preserved from the source file,
+    #     and re-sort keys in alphabetical order
+    #     """
+    #     self._source = [(_RECORD, key) for key in sorted(self._records)]
+    #     self._autosave()
+
+    def _iter_lines(self):
+        """iterator yielding lines of database"""
+        # NOTE: this relies on <records> being an OrderedDict so that it outputs
+        #       records in a deterministic order.
+        records = self._records
+        if __debug__:
+            pending = set(records)
+        for action, content in self._source:
+            if action == _SKIPPED:
+                # 'content' is whitespace/comments to write
+                yield content
+            else:
+                assert action == _RECORD
+                # 'content' is record key
+                if content not in records:
+                    # record was deleted
+                    # NOTE: doing it lazily like this so deleting & re-adding user
+                    #       preserves their original location in the file.
+                    continue
+                yield self._render_record(content, records[content])
+                if __debug__:
+                    pending.remove(content)
+        if __debug__:
+            # sanity check that we actually wrote all the records
+            # (otherwise _source & _records are somehow out of sync)
+            assert not pending, "failed to write all records: missing=%r" % (pending,)
+
+    def _render_record(self, key, value): # pragma: no cover - abstract method
+        """given key/value pair, encode as line of file"""
+        raise NotImplementedError("should be implemented in subclass")
+
+    #===================================================================
+    # field encoding
+    #===================================================================
+    def _encode_user(self, user):
+        """user-specific wrapper for _encode_field()"""
+        return self._encode_field(user, "user")
+
+    def _encode_realm(self, realm): # pragma: no cover - abstract method
+        """realm-specific wrapper for _encode_field()"""
+        return self._encode_field(realm, "realm")
+
+    def _encode_field(self, value, param="field"):
+        """convert field to internal representation.
+
+        internal representation is always bytes. byte strings are left as-is,
+        unicode strings encoding using file's default encoding (or ``utf-8``
+        if no encoding has been specified).
+
+        :raises UnicodeEncodeError:
+            if unicode value cannot be encoded using default encoding.
+
+        :raises ValueError:
+            if resulting byte string contains a forbidden character,
+            or is too long (>255 bytes).
+
+        :returns:
+            encoded identifer as bytes
+        """
+        if isinstance(value, unicode):
+            value = value.encode(self.encoding)
+        elif not isinstance(value, bytes):
+            raise ExpectedStringError(value, param)
+        if len(value) > 255:
+            raise ValueError("%s must be at most 255 characters: %r" %
+                             (param, value))
+        if any(c in _INVALID_FIELD_CHARS for c in value):
+            raise ValueError("%s contains invalid characters: %r" %
+                             (param, value,))
+        return value
+
+    def _decode_field(self, value):
+        """decode field from internal representation to format
+        returns by users() method, etc.
+
+        :raises UnicodeDecodeError:
+            if unicode value cannot be decoded using default encoding.
+            (usually indicates wrong encoding set for file).
+
+        :returns:
+            field as unicode or bytes, as appropriate.
+        """
+        assert isinstance(value, bytes), "expected value to be bytes"
+        if self.return_unicode:
+            return value.decode(self.encoding)
+        else:
+            return value
+
+    # FIXME: htpasswd doc says passwords limited to 255 chars under Windows & MPE,
+    # and that longer ones are truncated. this may be side-effect of those
+    # platforms supporting the 'plaintext' scheme. these classes don't currently
+    # check for this.
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# htpasswd context
+#
+# This section sets up a CryptContexts to mimic what schemes Apache
+# (and the htpasswd tool) should support on the current system.
+#
+# Apache has long-time supported some basic builtin schemes (listed below),
+# as well as the host's crypt() method -- though it's limited to being able
+# to *verify* any scheme using that method, but can only generate "des_crypt" hashes.
+#
+# Apache 2.4 added builtin bcrypt support (even for platforms w/o native support).
+# c.f. http://httpd.apache.org/docs/2.4/programs/htpasswd.html vs the 2.2 docs.
+#=============================================================================
+
+#: set of default schemes that (if chosen) should be using bcrypt,
+#: but can't due to lack of bcrypt.
+_warn_no_bcrypt = set()
+
+def _init_default_schemes():
+
+    #: pick strongest one for host
+    host_best = None
+    for name in ["bcrypt", "sha256_crypt"]:
+        if registry.has_os_crypt_support(name):
+            host_best = name
+            break
+
+    # check if we have a bcrypt backend -- otherwise issue warning
+    # XXX: would like to not spam this unless the user *requests* apache 24
+    bcrypt = "bcrypt" if registry.has_backend("bcrypt") else None
+    _warn_no_bcrypt.clear()
+    if not bcrypt:
+        _warn_no_bcrypt.update(["portable_apache_24", "host_apache_24",
+                                "linux_apache_24", "portable", "host"])
+
+    defaults = dict(
+        # strongest hash builtin to specific apache version
+        portable_apache_24=bcrypt or "apr_md5_crypt",
+        portable_apache_22="apr_md5_crypt",
+
+        # strongest hash across current host & specific apache version
+        host_apache_24=bcrypt or host_best or "apr_md5_crypt",
+        host_apache_22=host_best or "apr_md5_crypt",
+
+        # strongest hash on a linux host
+        linux_apache_24=bcrypt or "sha256_crypt",
+        linux_apache_22="sha256_crypt",
+    )
+
+    # set latest-apache version aliases
+    # XXX: could check for apache install, and pick correct host 22/24 default?
+    #      could reuse _detect_htpasswd() helper in UTs
+    defaults.update(
+        portable=defaults['portable_apache_24'],
+        host=defaults['host_apache_24'],
+    )
+    return defaults
+
+#: dict mapping default alias -> appropriate scheme
+htpasswd_defaults = _init_default_schemes()
+
+def _init_htpasswd_context():
+
+    # start with schemes built into apache
+    schemes = [
+        # builtin support added in apache 2.4
+        # (https://bz.apache.org/bugzilla/show_bug.cgi?id=49288)
+        "bcrypt",
+
+        # support not "builtin" to apache, instead it requires support through host's crypt().
+        # adding them here to allow editing htpasswd under windows and then deploying under unix.
+        "sha256_crypt",
+        "sha512_crypt",
+        "des_crypt",
+
+        # apache default as of 2.2.18, and still default in 2.4
+        "apr_md5_crypt",
+
+        # NOTE: apache says ONLY intended for transitioning htpasswd <-> ldap
+        "ldap_sha1",
+
+        # NOTE: apache says ONLY supported on Windows, Netware, TPF
+        "plaintext"
+    ]
+
+    # apache can verify anything supported by the native crypt(),
+    # though htpasswd tool can only generate a limited set of hashes.
+    # (this list may overlap w/ builtin apache schemes)
+    schemes.extend(registry.get_supported_os_crypt_schemes())
+
+    # hack to remove dups and sort into preferred order
+    preferred = schemes[:3] + ["apr_md5_crypt"] + schemes
+    schemes = sorted(set(schemes), key=preferred.index)
+
+    # create context object
+    return CryptContext(
+        schemes=schemes,
+
+        # NOTE: default will change to "portable" in passlib 2.0
+        default=htpasswd_defaults['portable_apache_22'],
+
+        # NOTE: bcrypt "2y" is required, "2b" isn't recognized by libapr (issue 95)
+        bcrypt__ident="2y",
+    )
+
+#: CryptContext configured to match htpasswd
+htpasswd_context = _init_htpasswd_context()
+
+#=============================================================================
+# htpasswd editing
+#=============================================================================
+
+class HtpasswdFile(_CommonFile):
+    """class for reading & writing Htpasswd files.
+
+    The class constructor accepts the following arguments:
+
+    :type path: filepath
+    :param path:
+
+        Specifies path to htpasswd file, use to implicitly load from and save to.
+
+        This class has two modes of operation:
+
+        1. It can be "bound" to a local file by passing a ``path`` to the class
+           constructor. In this case it will load the contents of the file when
+           created, and the :meth:`load` and :meth:`save` methods will automatically
+           load from and save to that file if they are called without arguments.
+
+        2. Alternately, it can exist as an independant object, in which case
+           :meth:`load` and :meth:`save` will require an explicit path to be
+           provided whenever they are called. As well, ``autosave`` behavior
+           will not be available.
+
+           This feature is new in Passlib 1.6, and is the default if no
+           ``path`` value is provided to the constructor.
+
+        This is also exposed as a readonly instance attribute.
+
+    :type new: bool
+    :param new:
+
+        Normally, if *path* is specified, :class:`HtpasswdFile` will
+        immediately load the contents of the file. However, when creating
+        a new htpasswd file, applications can set ``new=True`` so that
+        the existing file (if any) will not be loaded.
+
+        .. versionadded:: 1.6
+            This feature was previously enabled by setting ``autoload=False``.
+            That alias has been deprecated, and will be removed in Passlib 1.8
+
+    :type autosave: bool
+    :param autosave:
+
+        Normally, any changes made to an :class:`HtpasswdFile` instance
+        will not be saved until :meth:`save` is explicitly called. However,
+        if ``autosave=True`` is specified, any changes made will be
+        saved to disk immediately (assuming *path* has been set).
+
+        This is also exposed as a writeable instance attribute.
+
+    :type encoding: str
+    :param encoding:
+
+        Optionally specify character encoding used to read/write file
+        and hash passwords. Defaults to ``utf-8``, though ``latin-1``
+        is the only other commonly encountered encoding.
+
+        This is also exposed as a readonly instance attribute.
+
+    :type default_scheme: str
+    :param default_scheme:
+        Optionally specify default scheme to use when encoding new passwords.
+
+        This can be any of the schemes with builtin Apache support,
+        OR natively supported by the host OS's :func:`crypt.crypt` function.
+
+        * Builtin schemes include ``"bcrypt"`` (apache 2.4+), ``"apr_md5_crypt"`,
+          and ``"des_crypt"``.
+
+        * Schemes commonly supported by Unix hosts
+          include ``"bcrypt"``, ``"sha256_crypt"``, and ``"des_crypt"``.
+
+        In order to not have to sort out what you should use,
+        passlib offers a number of aliases, that will resolve
+        to the most appropriate scheme based on your needs:
+
+        * ``"portable"``, ``"portable_apache_24"`` -- pick scheme that's portable across hosts
+          running apache >= 2.4. **This will be the default as of Passlib 2.0**.
+
+        * ``"portable_apache_22"`` -- pick scheme that's portable across hosts
+          running apache >= 2.4. **This is the default up to Passlib 1.9**.
+
+        * ``"host"``, ``"host_apache_24"`` -- pick strongest scheme supported by
+           apache >= 2.4 and/or host OS.
+
+        * ``"host_apache_22"`` -- pick strongest scheme supported by
+           apache >= 2.2 and/or host OS.
+
+        .. versionadded:: 1.6
+            This keyword was previously named ``default``. That alias
+            has been deprecated, and will be removed in Passlib 1.8.
+
+        .. versionchanged:: 1.6.3
+
+            Added support for ``"bcrypt"``, ``"sha256_crypt"``, and ``"portable"`` alias.
+
+        .. versionchanged:: 1.7
+
+            Added apache 2.4 semantics, and additional aliases.
+
+    :type context: :class:`~passlib.context.CryptContext`
+    :param context:
+        :class:`!CryptContext` instance used to create
+        and verify the hashes found in the htpasswd file.
+        The default value is a pre-built context which supports all
+        of the hashes officially allowed in an htpasswd file.
+
+        This is also exposed as a readonly instance attribute.
+
+        .. warning::
+
+            This option may be used to add support for non-standard hash
+            formats to an htpasswd file. However, the resulting file
+            will probably not be usable by another application,
+            and particularly not by Apache.
+
+    :param autoload:
+        Set to ``False`` to prevent the constructor from automatically
+        loaded the file from disk.
+
+        .. deprecated:: 1.6
+            This has been replaced by the *new* keyword.
+            Instead of setting ``autoload=False``, you should use
+            ``new=True``. Support for this keyword will be removed
+            in Passlib 1.8.
+
+    :param default:
+        Change the default algorithm used to hash new passwords.
+
+        .. deprecated:: 1.6
+            This has been renamed to *default_scheme* for clarity.
+            Support for this alias will be removed in Passlib 1.8.
+
+    Loading & Saving
+    ================
+    .. automethod:: load
+    .. automethod:: load_if_changed
+    .. automethod:: load_string
+    .. automethod:: save
+    .. automethod:: to_string
+
+    Inspection
+    ================
+    .. automethod:: users
+    .. automethod:: check_password
+    .. automethod:: get_hash
+
+    Modification
+    ================
+    .. automethod:: set_password
+    .. automethod:: delete
+
+    Alternate Constructors
+    ======================
+    .. automethod:: from_string
+
+    Attributes
+    ==========
+    .. attribute:: path
+
+        Path to local file that will be used as the default
+        for all :meth:`load` and :meth:`save` operations.
+        May be written to, initialized by the *path* constructor keyword.
+
+    .. attribute:: autosave
+
+        Writeable flag indicating whether changes will be automatically
+        written to *path*.
+
+    Errors
+    ======
+    :raises ValueError:
+        All of the methods in this class will raise a :exc:`ValueError` if
+        any user name contains a forbidden character (one of ``:\\r\\n\\t\\x00``),
+        or is longer than 255 characters.
+    """
+    #===================================================================
+    # instance attrs
+    #===================================================================
+
+    # NOTE: _records map stores <user> for the key, and <hash> for the value,
+    #       both in bytes which use self.encoding
+
+    #===================================================================
+    # init & serialization
+    #===================================================================
+    def __init__(self, path=None, default_scheme=None, context=htpasswd_context,
+                 **kwds):
+        if 'default' in kwds:
+            warn("``default`` is deprecated as of Passlib 1.6, "
+                 "and will be removed in Passlib 1.8, it has been renamed "
+                 "to ``default_scheem``.",
+                 DeprecationWarning, stacklevel=2)
+            default_scheme = kwds.pop("default")
+        if default_scheme:
+            if default_scheme in _warn_no_bcrypt:
+                warn("HtpasswdFile: no bcrypt backends available, "
+                     "using fallback for default scheme %r" % default_scheme,
+                     exc.PasslibSecurityWarning)
+            default_scheme = htpasswd_defaults.get(default_scheme, default_scheme)
+            context = context.copy(default=default_scheme)
+        self.context = context
+        super(HtpasswdFile, self).__init__(path, **kwds)
+
+    def _parse_record(self, record, lineno):
+        # NOTE: should return (user, hash) tuple
+        result = record.rstrip().split(_BCOLON)
+        if len(result) != 2:
+            raise ValueError("malformed htpasswd file (error reading line %d)"
+                             % lineno)
+        return result
+
+    def _render_record(self, user, hash):
+        return render_bytes("%s:%s\n", user, hash)
+
+    #===================================================================
+    # public methods
+    #===================================================================
+
+    def users(self):
+        """
+        Return list of all users in database
+        """
+        return [self._decode_field(user) for user in self._records]
+
+    ##def has_user(self, user):
+    ##    "check whether entry is present for user"
+    ##    return self._encode_user(user) in self._records
+
+    ##def rename(self, old, new):
+    ##    """rename user account"""
+    ##    old = self._encode_user(old)
+    ##    new = self._encode_user(new)
+    ##    hash = self._records.pop(old)
+    ##    self._records[new] = hash
+    ##    self._autosave()
+
+    def set_password(self, user, password):
+        """Set password for user; adds user if needed.
+
+        :returns:
+            * ``True`` if existing user was updated.
+            * ``False`` if user account was added.
+
+        .. versionchanged:: 1.6
+            This method was previously called ``update``, it was renamed
+            to prevent ambiguity with the dictionary method.
+            The old alias is deprecated, and will be removed in Passlib 1.8.
+        """
+        hash = self.context.hash(password)
+        return self.set_hash(user, hash)
+
+    @deprecated_method(deprecated="1.6", removed="1.8",
+                       replacement="set_password")
+    def update(self, user, password):
+        """set password for user"""
+        return self.set_password(user, password)
+
+    def get_hash(self, user):
+        """Return hash stored for user, or ``None`` if user not found.
+
+        .. versionchanged:: 1.6
+            This method was previously named ``find``, it was renamed
+            for clarity. The old name is deprecated, and will be removed
+            in Passlib 1.8.
+        """
+        try:
+            return self._records[self._encode_user(user)]
+        except KeyError:
+            return None
+
+    def set_hash(self, user, hash):
+        """
+        semi-private helper which allows writing a hash directly;
+        adds user if needed.
+
+        .. warning::
+            does not (currently) do any validation of the hash string
+
+        .. versionadded:: 1.7
+        """
+        # assert self.context.identify(hash), "unrecognized hash format"
+        if PY3 and isinstance(hash, str):
+            hash = hash.encode(self.encoding)
+        user = self._encode_user(user)
+        existing = self._set_record(user, hash)
+        self._autosave()
+        return existing
+
+    @deprecated_method(deprecated="1.6", removed="1.8",
+                       replacement="get_hash")
+    def find(self, user):
+        """return hash for user"""
+        return self.get_hash(user)
+
+    # XXX: rename to something more explicit, like delete_user()?
+    def delete(self, user):
+        """Delete user's entry.
+
+        :returns:
+            * ``True`` if user deleted.
+            * ``False`` if user not found.
+        """
+        try:
+            del self._records[self._encode_user(user)]
+        except KeyError:
+            return False
+        self._autosave()
+        return True
+
+    def check_password(self, user, password):
+        """
+        Verify password for specified user.
+        If algorithm marked as deprecated by CryptContext, will automatically be re-hashed.
+
+        :returns:
+            * ``None`` if user not found.
+            * ``False`` if user found, but password does not match.
+            * ``True`` if user found and password matches.
+
+        .. versionchanged:: 1.6
+            This method was previously called ``verify``, it was renamed
+            to prevent ambiguity with the :class:`!CryptContext` method.
+            The old alias is deprecated, and will be removed in Passlib 1.8.
+        """
+        user = self._encode_user(user)
+        hash = self._records.get(user)
+        if hash is None:
+            return None
+        if isinstance(password, unicode):
+            # NOTE: encoding password to match file, making the assumption
+            # that server will use same encoding to hash the password.
+            password = password.encode(self.encoding)
+        ok, new_hash = self.context.verify_and_update(password, hash)
+        if ok and new_hash is not None:
+            # rehash user's password if old hash was deprecated
+            assert user in self._records  # otherwise would have to use ._set_record()
+            self._records[user] = new_hash
+            self._autosave()
+        return ok
+
+    @deprecated_method(deprecated="1.6", removed="1.8",
+                       replacement="check_password")
+    def verify(self, user, password):
+        """verify password for user"""
+        return self.check_password(user, password)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# htdigest editing
+#=============================================================================
+class HtdigestFile(_CommonFile):
+    """class for reading & writing Htdigest files.
+
+    The class constructor accepts the following arguments:
+
+    :type path: filepath
+    :param path:
+
+        Specifies path to htdigest file, use to implicitly load from and save to.
+
+        This class has two modes of operation:
+
+        1. It can be "bound" to a local file by passing a ``path`` to the class
+           constructor. In this case it will load the contents of the file when
+           created, and the :meth:`load` and :meth:`save` methods will automatically
+           load from and save to that file if they are called without arguments.
+
+        2. Alternately, it can exist as an independant object, in which case
+           :meth:`load` and :meth:`save` will require an explicit path to be
+           provided whenever they are called. As well, ``autosave`` behavior
+           will not be available.
+
+           This feature is new in Passlib 1.6, and is the default if no
+           ``path`` value is provided to the constructor.
+
+        This is also exposed as a readonly instance attribute.
+
+    :type default_realm: str
+    :param default_realm:
+
+        If ``default_realm`` is set, all the :class:`HtdigestFile`
+        methods that require a realm will use this value if one is not
+        provided explicitly. If unset, they will raise an error stating
+        that an explicit realm is required.
+
+        This is also exposed as a writeable instance attribute.
+
+        .. versionadded:: 1.6
+
+    :type new: bool
+    :param new:
+
+        Normally, if *path* is specified, :class:`HtdigestFile` will
+        immediately load the contents of the file. However, when creating
+        a new htpasswd file, applications can set ``new=True`` so that
+        the existing file (if any) will not be loaded.
+
+        .. versionadded:: 1.6
+            This feature was previously enabled by setting ``autoload=False``.
+            That alias has been deprecated, and will be removed in Passlib 1.8
+
+    :type autosave: bool
+    :param autosave:
+
+        Normally, any changes made to an :class:`HtdigestFile` instance
+        will not be saved until :meth:`save` is explicitly called. However,
+        if ``autosave=True`` is specified, any changes made will be
+        saved to disk immediately (assuming *path* has been set).
+
+        This is also exposed as a writeable instance attribute.
+
+    :type encoding: str
+    :param encoding:
+
+        Optionally specify character encoding used to read/write file
+        and hash passwords. Defaults to ``utf-8``, though ``latin-1``
+        is the only other commonly encountered encoding.
+
+        This is also exposed as a readonly instance attribute.
+
+    :param autoload:
+        Set to ``False`` to prevent the constructor from automatically
+        loaded the file from disk.
+
+        .. deprecated:: 1.6
+            This has been replaced by the *new* keyword.
+            Instead of setting ``autoload=False``, you should use
+            ``new=True``. Support for this keyword will be removed
+            in Passlib 1.8.
+
+    Loading & Saving
+    ================
+    .. automethod:: load
+    .. automethod:: load_if_changed
+    .. automethod:: load_string
+    .. automethod:: save
+    .. automethod:: to_string
+
+    Inspection
+    ==========
+    .. automethod:: realms
+    .. automethod:: users
+    .. automethod:: check_password(user[, realm], password)
+    .. automethod:: get_hash
+
+    Modification
+    ============
+    .. automethod:: set_password(user[, realm], password)
+    .. automethod:: delete
+    .. automethod:: delete_realm
+
+    Alternate Constructors
+    ======================
+    .. automethod:: from_string
+
+    Attributes
+    ==========
+    .. attribute:: default_realm
+
+        The default realm that will be used if one is not provided
+        to methods that require it. By default this is ``None``,
+        in which case an explicit realm must be provided for every
+        method call. Can be written to.
+
+    .. attribute:: path
+
+        Path to local file that will be used as the default
+        for all :meth:`load` and :meth:`save` operations.
+        May be written to, initialized by the *path* constructor keyword.
+
+    .. attribute:: autosave
+
+        Writeable flag indicating whether changes will be automatically
+        written to *path*.
+
+    Errors
+    ======
+    :raises ValueError:
+        All of the methods in this class will raise a :exc:`ValueError` if
+        any user name or realm contains a forbidden character (one of ``:\\r\\n\\t\\x00``),
+        or is longer than 255 characters.
+    """
+    #===================================================================
+    # instance attrs
+    #===================================================================
+
+    # NOTE: _records map stores (<user>,<realm>) for the key,
+    # and <hash> as the value, all as <self.encoding> bytes.
+
+    # NOTE: unlike htpasswd, this class doesn't use a CryptContext,
+    # as only one hash format is supported: htdigest.
+
+    # optionally specify default realm that will be used if none
+    # is provided to a method call. otherwise realm is always required.
+    default_realm = None
+
+    #===================================================================
+    # init & serialization
+    #===================================================================
+    def __init__(self, path=None, default_realm=None, **kwds):
+        self.default_realm = default_realm
+        super(HtdigestFile, self).__init__(path, **kwds)
+
+    def _parse_record(self, record, lineno):
+        result = record.rstrip().split(_BCOLON)
+        if len(result) != 3:
+            raise ValueError("malformed htdigest file (error reading line %d)"
+                             % lineno)
+        user, realm, hash = result
+        return (user, realm), hash
+
+    def _render_record(self, key, hash):
+        user, realm = key
+        return render_bytes("%s:%s:%s\n", user, realm, hash)
+
+    def _require_realm(self, realm):
+        if realm is None:
+            realm = self.default_realm
+            if realm is None:
+                raise TypeError("you must specify a realm explicitly, "
+                                "or set the default_realm attribute")
+        return realm
+
+    def _encode_realm(self, realm):
+        realm = self._require_realm(realm)
+        return self._encode_field(realm, "realm")
+
+    def _encode_key(self, user, realm):
+        return self._encode_user(user), self._encode_realm(realm)
+
+    #===================================================================
+    # public methods
+    #===================================================================
+
+    def realms(self):
+        """Return list of all realms in database"""
+        realms = set(key[1] for key in self._records)
+        return [self._decode_field(realm) for realm in realms]
+
+    def users(self, realm=None):
+        """Return list of all users in specified realm.
+
+        * uses ``self.default_realm`` if no realm explicitly provided.
+        * returns empty list if realm not found.
+        """
+        realm = self._encode_realm(realm)
+        return [self._decode_field(key[0]) for key in self._records
+                if key[1] == realm]
+
+    ##def has_user(self, user, realm=None):
+    ##    "check if user+realm combination exists"
+    ##    return self._encode_key(user,realm) in self._records
+
+    ##def rename_realm(self, old, new):
+    ##    """rename all accounts in realm"""
+    ##    old = self._encode_realm(old)
+    ##    new = self._encode_realm(new)
+    ##    keys = [key for key in self._records if key[1] == old]
+    ##    for key in keys:
+    ##        hash = self._records.pop(key)
+    ##        self._set_record((key[0], new), hash)
+    ##    self._autosave()
+    ##    return len(keys)
+
+    ##def rename(self, old, new, realm=None):
+    ##    """rename user account"""
+    ##    old = self._encode_user(old)
+    ##    new = self._encode_user(new)
+    ##    realm = self._encode_realm(realm)
+    ##    hash = self._records.pop((old,realm))
+    ##    self._set_record((new, realm), hash)
+    ##    self._autosave()
+
+    def set_password(self, user, realm=None, password=_UNSET):
+        """Set password for user; adds user & realm if needed.
+
+        If ``self.default_realm`` has been set, this may be called
+        with the syntax ``set_password(user, password)``,
+        otherwise it must be called with all three arguments:
+        ``set_password(user, realm, password)``.
+
+        :returns:
+            * ``True`` if existing user was updated
+            * ``False`` if user account added.
+        """
+        if password is _UNSET:
+            # called w/ two args - (user, password), use default realm
+            realm, password = None, realm
+        realm = self._require_realm(realm)
+        hash = htdigest.hash(password, user, realm, encoding=self.encoding)
+        return self.set_hash(user, realm, hash)
+
+    @deprecated_method(deprecated="1.6", removed="1.8",
+                       replacement="set_password")
+    def update(self, user, realm, password):
+        """set password for user"""
+        return self.set_password(user, realm, password)
+
+    def get_hash(self, user, realm=None):
+        """Return :class:`~passlib.hash.htdigest` hash stored for user.
+
+        * uses ``self.default_realm`` if no realm explicitly provided.
+        * returns ``None`` if user or realm not found.
+
+        .. versionchanged:: 1.6
+            This method was previously named ``find``, it was renamed
+            for clarity. The old name is deprecated, and will be removed
+            in Passlib 1.8.
+        """
+        key = self._encode_key(user, realm)
+        hash = self._records.get(key)
+        if hash is None:
+            return None
+        if PY3:
+            hash = hash.decode(self.encoding)
+        return hash
+
+    def set_hash(self, user, realm=None, hash=_UNSET):
+        """
+        semi-private helper which allows writing a hash directly;
+        adds user & realm if needed.
+
+        If ``self.default_realm`` has been set, this may be called
+        with the syntax ``set_hash(user, hash)``,
+        otherwise it must be called with all three arguments:
+        ``set_hash(user, realm, hash)``.
+
+        .. warning::
+            does not (currently) do any validation of the hash string
+
+        .. versionadded:: 1.7
+        """
+        if hash is _UNSET:
+            # called w/ two args - (user, hash), use default realm
+            realm, hash = None, realm
+        # assert htdigest.identify(hash), "unrecognized hash format"
+        if PY3 and isinstance(hash, str):
+            hash = hash.encode(self.encoding)
+        key = self._encode_key(user, realm)
+        existing = self._set_record(key, hash)
+        self._autosave()
+        return existing
+
+    @deprecated_method(deprecated="1.6", removed="1.8",
+                       replacement="get_hash")
+    def find(self, user, realm):
+        """return hash for user"""
+        return self.get_hash(user, realm)
+
+    # XXX: rename to something more explicit, like delete_user()?
+    def delete(self, user, realm=None):
+        """Delete user's entry for specified realm.
+
+        if realm is not specified, uses ``self.default_realm``.
+
+        :returns:
+            * ``True`` if user deleted,
+            * ``False`` if user not found in realm.
+        """
+        key = self._encode_key(user, realm)
+        try:
+            del self._records[key]
+        except KeyError:
+            return False
+        self._autosave()
+        return True
+
+    def delete_realm(self, realm):
+        """Delete all users for specified realm.
+
+        if realm is not specified, uses ``self.default_realm``.
+
+        :returns: number of users deleted (0 if realm not found)
+        """
+        realm = self._encode_realm(realm)
+        records = self._records
+        keys = [key for key in records if key[1] == realm]
+        for key in keys:
+            del records[key]
+        self._autosave()
+        return len(keys)
+
+    def check_password(self, user, realm=None, password=_UNSET):
+        """Verify password for specified user + realm.
+
+        If ``self.default_realm`` has been set, this may be called
+        with the syntax ``check_password(user, password)``,
+        otherwise it must be called with all three arguments:
+        ``check_password(user, realm, password)``.
+
+        :returns:
+            * ``None`` if user or realm not found.
+            * ``False`` if user found, but password does not match.
+            * ``True`` if user found and password matches.
+
+        .. versionchanged:: 1.6
+            This method was previously called ``verify``, it was renamed
+            to prevent ambiguity with the :class:`!CryptContext` method.
+            The old alias is deprecated, and will be removed in Passlib 1.8.
+        """
+        if password is _UNSET:
+            # called w/ two args - (user, password), use default realm
+            realm, password = None, realm
+        user = self._encode_user(user)
+        realm = self._encode_realm(realm)
+        hash = self._records.get((user,realm))
+        if hash is None:
+            return None
+        return htdigest.verify(password, hash, user, realm,
+                               encoding=self.encoding)
+
+    @deprecated_method(deprecated="1.6", removed="1.8",
+                       replacement="check_password")
+    def verify(self, user, realm, password):
+        """verify password for user"""
+        return self.check_password(user, realm, password)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/apps.py b/myenv/lib/python3.9/site-packages/passlib/apps.py
new file mode 100644
index 0000000..682bbff
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/apps.py
@@ -0,0 +1,245 @@
+"""passlib.apps"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import logging; log = logging.getLogger(__name__)
+from itertools import chain
+# site
+# pkg
+from passlib import hash
+from passlib.context import LazyCryptContext
+from passlib.utils import sys_bits
+# local
+__all__ = [
+    'custom_app_context',
+    'django_context',
+    'ldap_context', 'ldap_nocrypt_context',
+    'mysql_context', 'mysql4_context', 'mysql3_context',
+    'phpass_context',
+    'phpbb3_context',
+    'postgres_context',
+]
+
+#=============================================================================
+# master containing all identifiable hashes
+#=============================================================================
+def _load_master_config():
+    from passlib.registry import list_crypt_handlers
+
+    # get master list
+    schemes = list_crypt_handlers()
+
+    # exclude the ones we know have ambiguous or greedy identify() methods.
+    excluded = [
+        # frequently confused for eachother
+        'bigcrypt',
+        'crypt16',
+
+        # no good identifiers
+        'cisco_pix',
+        'cisco_type7',
+        'htdigest',
+        'mysql323',
+        'oracle10',
+
+        # all have same size
+        'lmhash',
+        'msdcc',
+        'msdcc2',
+        'nthash',
+
+        # plaintext handlers
+        'plaintext',
+        'ldap_plaintext',
+
+        # disabled handlers
+        'django_disabled',
+        'unix_disabled',
+        'unix_fallback',
+    ]
+    for name in excluded:
+        schemes.remove(name)
+
+    # return config
+    return dict(schemes=schemes, default="sha256_crypt")
+master_context = LazyCryptContext(onload=_load_master_config)
+
+#=============================================================================
+# for quickly bootstrapping new custom applications
+#=============================================================================
+custom_app_context = LazyCryptContext(
+    # choose some reasonbly strong schemes
+    schemes=["sha512_crypt", "sha256_crypt"],
+
+    # set some useful global options
+    default="sha256_crypt" if sys_bits < 64 else "sha512_crypt",
+
+    # set a good starting point for rounds selection
+    sha512_crypt__min_rounds = 535000,
+    sha256_crypt__min_rounds = 535000,
+
+    # if the admin user category is selected, make a much stronger hash,
+    admin__sha512_crypt__min_rounds = 1024000,
+    admin__sha256_crypt__min_rounds = 1024000,
+    )
+
+#=============================================================================
+# django
+#=============================================================================
+
+#-----------------------------------------------------------------------
+# 1.0
+#-----------------------------------------------------------------------
+
+_django10_schemes = [
+    "django_salted_sha1",
+    "django_salted_md5",
+    "django_des_crypt",
+    "hex_md5",
+    "django_disabled",
+]
+
+django10_context = LazyCryptContext(
+    schemes=_django10_schemes,
+    default="django_salted_sha1",
+    deprecated=["hex_md5"],
+)
+
+#-----------------------------------------------------------------------
+# 1.4
+#-----------------------------------------------------------------------
+
+_django14_schemes = [
+    "django_pbkdf2_sha256",
+    "django_pbkdf2_sha1",
+    "django_bcrypt"
+] + _django10_schemes
+
+django14_context = LazyCryptContext(
+    schemes=_django14_schemes,
+    deprecated=_django10_schemes,
+)
+
+#-----------------------------------------------------------------------
+# 1.6
+#-----------------------------------------------------------------------
+
+_django16_schemes = list(_django14_schemes)
+_django16_schemes.insert(1, "django_bcrypt_sha256")
+django16_context = LazyCryptContext(
+    schemes=_django16_schemes,
+    deprecated=_django10_schemes,
+)
+
+#-----------------------------------------------------------------------
+# 1.10
+#-----------------------------------------------------------------------
+
+_django_110_schemes = [
+    "django_pbkdf2_sha256",
+    "django_pbkdf2_sha1",
+    "django_argon2",
+    "django_bcrypt",
+    "django_bcrypt_sha256",
+    "django_disabled",
+]
+django110_context = LazyCryptContext(schemes=_django_110_schemes)
+
+#-----------------------------------------------------------------------
+# 2.1
+#-----------------------------------------------------------------------
+
+_django21_schemes = list(_django_110_schemes)
+_django21_schemes.remove("django_bcrypt")
+django21_context = LazyCryptContext(schemes=_django21_schemes)
+
+#-----------------------------------------------------------------------
+# latest
+#-----------------------------------------------------------------------
+
+# this will always point to latest version in passlib
+django_context = django21_context
+
+#=============================================================================
+# ldap
+#=============================================================================
+
+#: standard ldap schemes
+std_ldap_schemes = [
+    "ldap_salted_sha512",
+    "ldap_salted_sha256",
+    "ldap_salted_sha1",
+    "ldap_salted_md5",
+    "ldap_sha1",
+    "ldap_md5",
+    "ldap_plaintext",
+]
+
+# create context with all std ldap schemes EXCEPT crypt
+ldap_nocrypt_context = LazyCryptContext(std_ldap_schemes)
+
+# create context with all possible std ldap + ldap crypt schemes
+def _iter_ldap_crypt_schemes():
+    from passlib.utils import unix_crypt_schemes
+    return ('ldap_' + name for name in unix_crypt_schemes)
+
+def _iter_ldap_schemes():
+    """helper which iterates over supported std ldap schemes"""
+    return chain(std_ldap_schemes, _iter_ldap_crypt_schemes())
+ldap_context = LazyCryptContext(_iter_ldap_schemes())
+
+### create context with all std ldap schemes + crypt schemes for localhost
+##def _iter_host_ldap_schemes():
+##    "helper which iterates over supported std ldap schemes"
+##    from passlib.handlers.ldap_digests import get_host_ldap_crypt_schemes
+##    return chain(std_ldap_schemes, get_host_ldap_crypt_schemes())
+##ldap_host_context = LazyCryptContext(_iter_host_ldap_schemes())
+
+#=============================================================================
+# mysql
+#=============================================================================
+mysql3_context = LazyCryptContext(["mysql323"])
+mysql4_context = LazyCryptContext(["mysql41", "mysql323"], deprecated="mysql323")
+mysql_context = mysql4_context # tracks latest mysql version supported
+
+#=============================================================================
+# postgres
+#=============================================================================
+postgres_context = LazyCryptContext(["postgres_md5"])
+
+#=============================================================================
+# phpass & variants
+#=============================================================================
+def _create_phpass_policy(**kwds):
+    """helper to choose default alg based on bcrypt availability"""
+    kwds['default'] = 'bcrypt' if hash.bcrypt.has_backend() else 'phpass'
+    return kwds
+
+phpass_context = LazyCryptContext(
+    schemes=["bcrypt", "phpass", "bsdi_crypt"],
+    onload=_create_phpass_policy,
+    )
+
+phpbb3_context = LazyCryptContext(["phpass"], phpass__ident="H")
+
+# TODO: support the drupal phpass variants (see phpass homepage)
+
+#=============================================================================
+# roundup
+#=============================================================================
+
+_std_roundup_schemes = [ "ldap_hex_sha1", "ldap_hex_md5", "ldap_des_crypt", "roundup_plaintext" ]
+roundup10_context = LazyCryptContext(_std_roundup_schemes)
+
+# NOTE: 'roundup15' really applies to roundup 1.4.17+
+roundup_context = roundup15_context = LazyCryptContext(
+    schemes=_std_roundup_schemes + [ "ldap_pbkdf2_sha1" ],
+    deprecated=_std_roundup_schemes,
+    default = "ldap_pbkdf2_sha1",
+    ldap_pbkdf2_sha1__default_rounds = 10000,
+    )
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/context.py b/myenv/lib/python3.9/site-packages/passlib/context.py
new file mode 100644
index 0000000..bc3cbf5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/context.py
@@ -0,0 +1,2637 @@
+"""passlib.context - CryptContext implementation"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+import re
+import logging; log = logging.getLogger(__name__)
+import threading
+import time
+from warnings import warn
+# site
+# pkg
+from passlib import exc
+from passlib.exc import ExpectedStringError, ExpectedTypeError, PasslibConfigWarning
+from passlib.registry import get_crypt_handler, _validate_handler_name
+from passlib.utils import (handlers as uh, to_bytes,
+                           to_unicode, splitcomma,
+                           as_bool, timer, rng, getrandstr,
+                           )
+from passlib.utils.binary import BASE64_CHARS
+from passlib.utils.compat import (iteritems, num_types, irange,
+                                  PY2, PY3, unicode, SafeConfigParser,
+                                  NativeStringIO, BytesIO,
+                                  unicode_or_bytes_types, native_string_types,
+                                  )
+from passlib.utils.decor import deprecated_method, memoized_property
+# local
+__all__ = [
+    'CryptContext',
+    'LazyCryptContext',
+    'CryptPolicy',
+]
+
+#=============================================================================
+# support
+#=============================================================================
+
+# private object to detect unset params
+_UNSET = object()
+
+def _coerce_vary_rounds(value):
+    """parse vary_rounds string to percent as [0,1) float, or integer"""
+    if value.endswith("%"):
+        # XXX: deprecate this in favor of raw float?
+        return float(value.rstrip("%"))*.01
+    try:
+        return int(value)
+    except ValueError:
+        return float(value)
+
+# set of options which aren't allowed to be set via policy
+_forbidden_scheme_options = set(["salt"])
+    # 'salt' - not allowed since a fixed salt would defeat the purpose.
+
+# dict containing funcs used to coerce strings to correct type for scheme option keys.
+# NOTE: this isn't really needed any longer, since Handler.using() handles the actual parsing.
+#       keeping this around for now, though, since it makes context.to_dict() output cleaner.
+_coerce_scheme_options = dict(
+    min_rounds=int,
+    max_rounds=int,
+    default_rounds=int,
+    vary_rounds=_coerce_vary_rounds,
+    salt_size=int,
+)
+
+def _is_handler_registered(handler):
+    """detect if handler is registered or a custom handler"""
+    return get_crypt_handler(handler.name, None) is handler
+
+@staticmethod
+def _always_needs_update(hash, secret=None):
+    """
+    dummy function patched into handler.needs_update() by _CryptConfig
+    when hash alg has been deprecated for context.
+    """
+    return True
+
+#: list of keys allowed under wildcard "all" scheme w/o a security warning.
+_global_settings = set(["truncate_error", "vary_rounds"])
+
+#=============================================================================
+# crypt policy
+#=============================================================================
+_preamble = ("The CryptPolicy class has been deprecated as of "
+             "Passlib 1.6, and will be removed in Passlib 1.8. ")
+
+class CryptPolicy(object):
+    """
+    .. deprecated:: 1.6
+        This class has been deprecated, and will be removed in Passlib 1.8.
+        All of its functionality has been rolled into :class:`CryptContext`.
+
+    This class previously stored the configuration options for the
+    CryptContext class. In the interest of interface simplification,
+    all of this class' functionality has been rolled into the CryptContext
+    class itself.
+    The documentation for this class is now focused on  documenting how to
+    migrate to the new api. Additionally, where possible, the deprecation
+    warnings issued by the CryptPolicy methods will list the replacement call
+    that should be used.
+
+    Constructors
+    ============
+    CryptPolicy objects can be constructed directly using any of
+    the keywords accepted by :class:`CryptContext`. Direct uses of the
+    :class:`!CryptPolicy` constructor should either pass the keywords
+    directly into the CryptContext constructor, or to :meth:`CryptContext.update`
+    if the policy object was being used to update an existing context object.
+
+    In addition to passing in keywords directly,
+    CryptPolicy objects can be constructed by the following methods:
+
+    .. automethod:: from_path
+    .. automethod:: from_string
+    .. automethod:: from_source
+    .. automethod:: from_sources
+    .. automethod:: replace
+
+    Introspection
+    =============
+    All of the informational methods provided by this class have been deprecated
+    by identical or similar methods in the :class:`CryptContext` class:
+
+    .. automethod:: has_schemes
+    .. automethod:: schemes
+    .. automethod:: iter_handlers
+    .. automethod:: get_handler
+    .. automethod:: get_options
+    .. automethod:: handler_is_deprecated
+    .. automethod:: get_min_verify_time
+
+    Exporting
+    =========
+    .. automethod:: iter_config
+    .. automethod:: to_dict
+    .. automethod:: to_file
+    .. automethod:: to_string
+
+    .. note::
+        CryptPolicy are immutable.
+        Use the :meth:`replace` method to mutate existing instances.
+
+    .. deprecated:: 1.6
+    """
+    #===================================================================
+    # class methods
+    #===================================================================
+    @classmethod
+    def from_path(cls, path, section="passlib", encoding="utf-8"):
+        """create a CryptPolicy instance from a local file.
+
+        .. deprecated:: 1.6
+
+        Creating a new CryptContext from a file, which was previously done via
+        ``CryptContext(policy=CryptPolicy.from_path(path))``, can now be
+        done via ``CryptContext.from_path(path)``.
+        See :meth:`CryptContext.from_path` for details.
+
+        Updating an existing CryptContext from a file, which was previously done
+        ``context.policy = CryptPolicy.from_path(path)``, can now be
+        done via ``context.load_path(path)``.
+        See :meth:`CryptContext.load_path` for details.
+        """
+        warn(_preamble +
+             "Instead of ``CryptPolicy.from_path(path)``, "
+             "use ``CryptContext.from_path(path)`` "
+             " or ``context.load_path(path)`` for an existing CryptContext.",
+             DeprecationWarning, stacklevel=2)
+        return cls(_internal_context=CryptContext.from_path(path, section,
+                                                            encoding))
+
+    @classmethod
+    def from_string(cls, source, section="passlib", encoding="utf-8"):
+        """create a CryptPolicy instance from a string.
+
+        .. deprecated:: 1.6
+
+        Creating a new CryptContext from a string, which was previously done via
+        ``CryptContext(policy=CryptPolicy.from_string(data))``, can now be
+        done via ``CryptContext.from_string(data)``.
+        See :meth:`CryptContext.from_string` for details.
+
+        Updating an existing CryptContext from a string, which was previously done
+        ``context.policy = CryptPolicy.from_string(data)``, can now be
+        done via ``context.load(data)``.
+        See :meth:`CryptContext.load` for details.
+        """
+        warn(_preamble +
+             "Instead of ``CryptPolicy.from_string(source)``, "
+             "use ``CryptContext.from_string(source)`` or "
+             "``context.load(source)`` for an existing CryptContext.",
+             DeprecationWarning, stacklevel=2)
+        return cls(_internal_context=CryptContext.from_string(source, section,
+                                                              encoding))
+
+    @classmethod
+    def from_source(cls, source, _warn=True):
+        """create a CryptPolicy instance from some source.
+
+        this method autodetects the source type, and invokes
+        the appropriate constructor automatically. it attempts
+        to detect whether the source is a configuration string, a filepath,
+        a dictionary, or an existing CryptPolicy instance.
+
+        .. deprecated:: 1.6
+
+        Create a new CryptContext, which could previously be done via
+        ``CryptContext(policy=CryptPolicy.from_source(source))``, should
+        now be done using an explicit method: the :class:`CryptContext`
+        constructor itself, :meth:`CryptContext.from_path`,
+        or :meth:`CryptContext.from_string`.
+
+        Updating an existing CryptContext, which could previously be done via
+        ``context.policy = CryptPolicy.from_source(source)``, should
+        now be done using an explicit method: :meth:`CryptContext.update`,
+        or :meth:`CryptContext.load`.
+        """
+        if _warn:
+            warn(_preamble +
+                 "Instead of ``CryptPolicy.from_source()``, "
+                 "use ``CryptContext.from_string(path)`` "
+                 " or ``CryptContext.from_path(source)``, as appropriate.",
+                 DeprecationWarning, stacklevel=2)
+        if isinstance(source, CryptPolicy):
+            return source
+        elif isinstance(source, dict):
+            return cls(_internal_context=CryptContext(**source))
+        elif not isinstance(source, (bytes,unicode)):
+            raise TypeError("source must be CryptPolicy, dict, config string, "
+                            "or file path: %r" % (type(source),))
+        elif any(c in source for c in "\n\r\t") or not source.strip(" \t./;:"):
+            return cls(_internal_context=CryptContext.from_string(source))
+        else:
+            return cls(_internal_context=CryptContext.from_path(source))
+
+    @classmethod
+    def from_sources(cls, sources, _warn=True):
+        """create a CryptPolicy instance by merging multiple sources.
+
+        each source is interpreted as by :meth:`from_source`,
+        and the results are merged together.
+
+        .. deprecated:: 1.6
+            Instead of using this method to merge multiple policies together,
+            a :class:`CryptContext` instance should be created, and then
+            the multiple sources merged together via :meth:`CryptContext.load`.
+        """
+        if _warn:
+            warn(_preamble +
+                 "Instead of ``CryptPolicy.from_sources()``, "
+                 "use the various CryptContext constructors "
+                 " followed by ``context.update()``.",
+                 DeprecationWarning, stacklevel=2)
+        if len(sources) == 0:
+            raise ValueError("no sources specified")
+        if len(sources) == 1:
+            return cls.from_source(sources[0], _warn=False)
+        kwds = {}
+        for source in sources:
+            kwds.update(cls.from_source(source, _warn=False)._context.to_dict(resolve=True))
+        return cls(_internal_context=CryptContext(**kwds))
+
+    def replace(self, *args, **kwds):
+        """create a new CryptPolicy, optionally updating parts of the
+        existing configuration.
+
+        .. deprecated:: 1.6
+            Callers of this method should :meth:`CryptContext.update` or
+            :meth:`CryptContext.copy` instead.
+        """
+        if self._stub_policy:
+            warn(_preamble + # pragma: no cover -- deprecated & unused
+                 "Instead of ``context.policy.replace()``, "
+                 "use ``context.update()`` or ``context.copy()``.",
+                 DeprecationWarning, stacklevel=2)
+        else:
+            warn(_preamble +
+                 "Instead of ``CryptPolicy().replace()``, "
+                 "create a CryptContext instance and "
+                 "use ``context.update()`` or ``context.copy()``.",
+                 DeprecationWarning, stacklevel=2)
+        sources = [ self ]
+        if args:
+            sources.extend(args)
+        if kwds:
+            sources.append(kwds)
+        return CryptPolicy.from_sources(sources, _warn=False)
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+
+    # internal CryptContext we're wrapping to handle everything
+    # until this class is removed.
+    _context = None
+
+    # flag indicating this is wrapper generated by the CryptContext.policy
+    # attribute, rather than one created independantly by the application.
+    _stub_policy = False
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, *args, **kwds):
+        context = kwds.pop("_internal_context", None)
+        if context:
+            assert isinstance(context, CryptContext)
+            self._context = context
+            self._stub_policy = kwds.pop("_stub_policy", False)
+            assert not (args or kwds), "unexpected args: %r %r" % (args,kwds)
+        else:
+            if args:
+                if len(args) != 1:
+                    raise TypeError("only one positional argument accepted")
+                if kwds:
+                    raise TypeError("cannot specify positional arg and kwds")
+                kwds = args[0]
+            warn(_preamble +
+                 "Instead of constructing a CryptPolicy instance, "
+                 "create a CryptContext directly, or use ``context.update()`` "
+                 "and ``context.load()`` to reconfigure existing CryptContext "
+                 "instances.",
+                 DeprecationWarning, stacklevel=2)
+            self._context = CryptContext(**kwds)
+
+    #===================================================================
+    # public interface for examining options
+    #===================================================================
+    def has_schemes(self):
+        """return True if policy defines *any* schemes for use.
+
+        .. deprecated:: 1.6
+            applications should use ``bool(context.schemes())`` instead.
+            see :meth:`CryptContext.schemes`.
+        """
+        if self._stub_policy:
+            warn(_preamble + # pragma: no cover -- deprecated & unused
+                 "Instead of ``context.policy.has_schemes()``, "
+                 "use ``bool(context.schemes())``.",
+                 DeprecationWarning, stacklevel=2)
+        else:
+            warn(_preamble +
+                 "Instead of ``CryptPolicy().has_schemes()``, "
+                 "create a CryptContext instance and "
+                 "use ``bool(context.schemes())``.",
+                 DeprecationWarning, stacklevel=2)
+        return bool(self._context.schemes())
+
+    def iter_handlers(self):
+        """return iterator over handlers defined in policy.
+
+        .. deprecated:: 1.6
+            applications should use ``context.schemes(resolve=True))`` instead.
+            see :meth:`CryptContext.schemes`.
+        """
+        if self._stub_policy:
+            warn(_preamble +
+                 "Instead of ``context.policy.iter_handlers()``, "
+                 "use ``context.schemes(resolve=True)``.",
+                 DeprecationWarning, stacklevel=2)
+        else:
+            warn(_preamble +
+                 "Instead of ``CryptPolicy().iter_handlers()``, "
+                 "create a CryptContext instance and "
+                 "use ``context.schemes(resolve=True)``.",
+                 DeprecationWarning, stacklevel=2)
+        return self._context.schemes(resolve=True, unconfigured=True)
+
+    def schemes(self, resolve=False):
+        """return list of schemes defined in policy.
+
+        .. deprecated:: 1.6
+            applications should use :meth:`CryptContext.schemes` instead.
+        """
+        if self._stub_policy:
+            warn(_preamble + # pragma: no cover -- deprecated & unused
+                 "Instead of ``context.policy.schemes()``, "
+                 "use ``context.schemes()``.",
+                 DeprecationWarning, stacklevel=2)
+        else:
+            warn(_preamble +
+                 "Instead of ``CryptPolicy().schemes()``, "
+                 "create a CryptContext instance and "
+                 "use ``context.schemes()``.",
+                 DeprecationWarning, stacklevel=2)
+        return list(self._context.schemes(resolve=resolve, unconfigured=True))
+
+    def get_handler(self, name=None, category=None, required=False):
+        """return handler as specified by name, or default handler.
+
+        .. deprecated:: 1.6
+            applications should use :meth:`CryptContext.handler` instead,
+            though note that the ``required`` keyword has been removed,
+            and the new method will always act as if ``required=True``.
+        """
+        if self._stub_policy:
+            warn(_preamble +
+                 "Instead of ``context.policy.get_handler()``, "
+                 "use ``context.handler()``.",
+                 DeprecationWarning, stacklevel=2)
+        else:
+            warn(_preamble +
+                 "Instead of ``CryptPolicy().get_handler()``, "
+                 "create a CryptContext instance and "
+                 "use ``context.handler()``.",
+                 DeprecationWarning, stacklevel=2)
+        # CryptContext.handler() doesn't support required=False,
+        # so wrapping it in try/except
+        try:
+            return self._context.handler(name, category, unconfigured=True)
+        except KeyError:
+            if required:
+                raise
+            else:
+                return None
+
+    def get_min_verify_time(self, category=None):
+        """get min_verify_time setting for policy.
+
+        .. deprecated:: 1.6
+            min_verify_time option will be removed entirely in passlib 1.8
+
+        .. versionchanged:: 1.7
+            this method now always returns the value automatically
+            calculated by :meth:`CryptContext.min_verify_time`,
+            any value specified by policy is ignored.
+        """
+        warn("get_min_verify_time() and min_verify_time option is deprecated and ignored, "
+             "and will be removed in Passlib 1.8", DeprecationWarning,
+             stacklevel=2)
+        return 0
+
+    def get_options(self, name, category=None):
+        """return dictionary of options specific to a given handler.
+
+        .. deprecated:: 1.6
+            this method has no direct replacement in the 1.6 api, as there
+            is not a clearly defined use-case. however, examining the output of
+            :meth:`CryptContext.to_dict` should serve as the closest alternative.
+        """
+        # XXX: might make a public replacement, but need more study of the use cases.
+        if self._stub_policy:
+            warn(_preamble + # pragma: no cover -- deprecated & unused
+                 "``context.policy.get_options()`` will no longer be available.",
+                 DeprecationWarning, stacklevel=2)
+        else:
+            warn(_preamble +
+                 "``CryptPolicy().get_options()`` will no longer be available.",
+                 DeprecationWarning, stacklevel=2)
+        if hasattr(name, "name"):
+            name = name.name
+        return self._context._config._get_record_options_with_flag(name, category)[0]
+
+    def handler_is_deprecated(self, name, category=None):
+        """check if handler has been deprecated by policy.
+
+        .. deprecated:: 1.6
+            this method has no direct replacement in the 1.6 api, as there
+            is not a clearly defined use-case. however, examining the output of
+            :meth:`CryptContext.to_dict` should serve as the closest alternative.
+        """
+        # XXX: might make a public replacement, but need more study of the use cases.
+        if self._stub_policy:
+            warn(_preamble +
+                 "``context.policy.handler_is_deprecated()`` will no longer be available.",
+                 DeprecationWarning, stacklevel=2)
+        else:
+            warn(_preamble +
+                 "``CryptPolicy().handler_is_deprecated()`` will no longer be available.",
+                 DeprecationWarning, stacklevel=2)
+        if hasattr(name, "name"):
+            name = name.name
+        return self._context.handler(name, category).deprecated
+
+    #===================================================================
+    # serialization
+    #===================================================================
+
+    def iter_config(self, ini=False, resolve=False):
+        """iterate over key/value pairs representing the policy object.
+
+        .. deprecated:: 1.6
+            applications should use :meth:`CryptContext.to_dict` instead.
+        """
+        if self._stub_policy:
+            warn(_preamble + # pragma: no cover -- deprecated & unused
+                 "Instead of ``context.policy.iter_config()``, "
+                 "use ``context.to_dict().items()``.",
+                 DeprecationWarning, stacklevel=2)
+        else:
+            warn(_preamble +
+                 "Instead of ``CryptPolicy().iter_config()``, "
+                 "create a CryptContext instance and "
+                 "use ``context.to_dict().items()``.",
+                 DeprecationWarning, stacklevel=2)
+        # hacked code that renders keys & values in manner that approximates
+        # old behavior. context.to_dict() is much cleaner.
+        context = self._context
+        if ini:
+            def render_key(key):
+                return context._render_config_key(key).replace("__", ".")
+            def render_value(value):
+                if isinstance(value, (list,tuple)):
+                    value = ", ".join(value)
+                return value
+            resolve = False
+        else:
+            render_key = context._render_config_key
+            render_value = lambda value: value
+        return (
+            (render_key(key), render_value(value))
+            for key, value in context._config.iter_config(resolve)
+        )
+
+    def to_dict(self, resolve=False):
+        """export policy object as dictionary of options.
+
+        .. deprecated:: 1.6
+            applications should use :meth:`CryptContext.to_dict` instead.
+        """
+        if self._stub_policy:
+            warn(_preamble +
+                 "Instead of ``context.policy.to_dict()``, "
+                 "use ``context.to_dict()``.",
+                 DeprecationWarning, stacklevel=2)
+        else:
+            warn(_preamble +
+                 "Instead of ``CryptPolicy().to_dict()``, "
+                 "create a CryptContext instance and "
+                 "use ``context.to_dict()``.",
+                 DeprecationWarning, stacklevel=2)
+        return self._context.to_dict(resolve)
+
+    def to_file(self, stream, section="passlib"): # pragma: no cover -- deprecated & unused
+        """export policy to file.
+
+        .. deprecated:: 1.6
+            applications should use :meth:`CryptContext.to_string` instead,
+            and then write the output to a file as desired.
+        """
+        if self._stub_policy:
+            warn(_preamble +
+                 "Instead of ``context.policy.to_file(stream)``, "
+                 "use ``stream.write(context.to_string())``.",
+                 DeprecationWarning, stacklevel=2)
+        else:
+            warn(_preamble +
+                 "Instead of ``CryptPolicy().to_file(stream)``, "
+                 "create a CryptContext instance and "
+                 "use ``stream.write(context.to_string())``.",
+                 DeprecationWarning, stacklevel=2)
+        out = self._context.to_string(section=section)
+        if PY2:
+            out = out.encode("utf-8")
+        stream.write(out)
+
+    def to_string(self, section="passlib", encoding=None):
+        """export policy to file.
+
+        .. deprecated:: 1.6
+            applications should use :meth:`CryptContext.to_string` instead.
+        """
+        if self._stub_policy:
+            warn(_preamble + # pragma: no cover -- deprecated & unused
+                 "Instead of ``context.policy.to_string()``, "
+                 "use ``context.to_string()``.",
+                 DeprecationWarning, stacklevel=2)
+        else:
+            warn(_preamble +
+                 "Instead of ``CryptPolicy().to_string()``, "
+                 "create a CryptContext instance and "
+                 "use ``context.to_string()``.",
+                 DeprecationWarning, stacklevel=2)
+        out = self._context.to_string(section=section)
+        if encoding:
+            out = out.encode(encoding)
+        return out
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# _CryptConfig helper class
+#=============================================================================
+class _CryptConfig(object):
+    """parses, validates, and stores CryptContext config
+
+    this is a helper used internally by CryptContext to handle
+    parsing, validation, and serialization of its config options.
+    split out from the main class, but not made public since
+    that just complicates interface too much (c.f. CryptPolicy)
+
+    :arg source: config as dict mapping ``(cat,scheme,option) -> value``
+    """
+    #===================================================================
+    # instance attrs
+    #===================================================================
+
+    # triple-nested dict which maps scheme -> category -> key -> value,
+    # storing all hash-specific options
+    _scheme_options = None
+
+    # double-nested dict which maps key -> category -> value
+    # storing all CryptContext options
+    _context_options = None
+
+    # tuple of handler objects
+    handlers = None
+
+    # tuple of scheme objects in same order as handlers
+    schemes = None
+
+    # tuple of categories in alphabetical order (not including None)
+    categories = None
+
+    # set of all context keywords used by active schemes
+    context_kwds = None
+
+    # dict mapping category -> default scheme
+    _default_schemes = None
+
+    # dict mapping (scheme, category) -> custom handler
+    _records = None
+
+    # dict mapping category -> list of custom handler instances for that category,
+    # in order of schemes(). populated on demand by _get_record_list()
+    _record_lists = None
+
+    #===================================================================
+    # constructor
+    #===================================================================
+    def __init__(self, source):
+        self._init_scheme_list(source.get((None,None,"schemes")))
+        self._init_options(source)
+        self._init_default_schemes()
+        self._init_records()
+
+    def _init_scheme_list(self, data):
+        """initialize .handlers and .schemes attributes"""
+        handlers  = []
+        schemes = []
+        if isinstance(data, native_string_types):
+            data = splitcomma(data)
+        for elem in data or ():
+            # resolve elem -> handler & scheme
+            if hasattr(elem, "name"):
+                handler = elem
+                scheme = handler.name
+                _validate_handler_name(scheme)
+            elif isinstance(elem, native_string_types):
+                handler = get_crypt_handler(elem)
+                scheme = handler.name
+            else:
+                raise TypeError("scheme must be name or CryptHandler, "
+                                "not %r" % type(elem))
+
+            # check scheme name isn't already in use
+            if scheme in schemes:
+                raise KeyError("multiple handlers with same name: %r" %
+                               (scheme,))
+
+            # add to handler list
+            handlers.append(handler)
+            schemes.append(scheme)
+
+        self.handlers = tuple(handlers)
+        self.schemes = tuple(schemes)
+
+    #===================================================================
+    # lowlevel options
+    #===================================================================
+
+    #---------------------------------------------------------------
+    # init lowlevel option storage
+    #---------------------------------------------------------------
+    def _init_options(self, source):
+        """load config dict into internal representation,
+        and init .categories attr
+        """
+        # prepare dicts & locals
+        norm_scheme_option = self._norm_scheme_option
+        norm_context_option = self._norm_context_option
+        self._scheme_options = scheme_options = {}
+        self._context_options = context_options = {}
+        categories = set()
+
+        # load source config into internal storage
+        for (cat, scheme, key), value in iteritems(source):
+            categories.add(cat)
+            explicit_scheme = scheme
+            if not cat and not scheme and key in _global_settings:
+                # going forward, not using "<cat>__all__<key>" format. instead...
+                # whitelisting set of keys which should be passed to (all) schemes,
+                # rather than passed to the CryptContext itself
+                scheme = "all"
+            if scheme:
+                # normalize scheme option
+                key, value = norm_scheme_option(key, value)
+
+                # e.g. things like "min_rounds" should never be set cross-scheme
+                # this will be fatal under 2.0.
+                if scheme == "all" and key not in _global_settings:
+                    warn("The '%s' option should be configured per-algorithm, and not set "
+                         "globally in the context; This will be an error in Passlib 2.0" %
+                         (key,), PasslibConfigWarning)
+
+                # this scheme is going away in 2.0;
+                # but most keys deserve an extra warning since it impacts security.
+                if explicit_scheme == "all":
+                    warn("The 'all' scheme is deprecated as of Passlib 1.7, "
+                         "and will be removed in Passlib 2.0; Please configure "
+                         "options on a per-algorithm basis.", DeprecationWarning)
+
+                # store in scheme_options
+                # map structure: scheme_options[scheme][category][key] = value
+                try:
+                    category_map = scheme_options[scheme]
+                except KeyError:
+                    scheme_options[scheme] = {cat: {key: value}}
+                else:
+                    try:
+                        option_map = category_map[cat]
+                    except KeyError:
+                        category_map[cat] = {key: value}
+                    else:
+                        option_map[key] = value
+            else:
+                # normalize context option
+                if cat and key == "schemes":
+                    raise KeyError("'schemes' context option is not allowed "
+                                   "per category")
+                key, value = norm_context_option(cat, key, value)
+                if key == "min_verify_time": # ignored in 1.7, to be removed in 1.8
+                    continue
+
+                # store in context_options
+                # map structure: context_options[key][category] = value
+                try:
+                    category_map = context_options[key]
+                except KeyError:
+                    context_options[key] = {cat: value}
+                else:
+                    category_map[cat] = value
+
+        # store list of configured categories
+        categories.discard(None)
+        self.categories = tuple(sorted(categories))
+
+    def _norm_scheme_option(self, key, value):
+        # check for invalid options
+        if key in _forbidden_scheme_options:
+            raise KeyError("%r option not allowed in CryptContext "
+                           "configuration" % (key,))
+        # coerce strings for certain fields (e.g. min_rounds uses ints)
+        if isinstance(value, native_string_types):
+            func = _coerce_scheme_options.get(key)
+            if func:
+                value = func(value)
+        return key, value
+
+    def _norm_context_option(self, cat, key, value):
+        schemes = self.schemes
+        if key == "default":
+            if hasattr(value, "name"):
+                value = value.name
+            elif not isinstance(value, native_string_types):
+                raise ExpectedTypeError(value, "str", "default")
+            if schemes and value not in schemes:
+                raise KeyError("default scheme not found in policy")
+        elif key == "deprecated":
+            if isinstance(value, native_string_types):
+                value = splitcomma(value)
+            elif not isinstance(value, (list,tuple)):
+                raise ExpectedTypeError(value, "str or seq", "deprecated")
+            if 'auto' in value:
+                # XXX: have any statements been made about when this is default?
+                #      should do it in 1.8 at latest.
+                if len(value) > 1:
+                    raise ValueError("cannot list other schemes if "
+                                     "``deprecated=['auto']`` is used")
+            elif schemes:
+                # make sure list of deprecated schemes is subset of configured schemes
+                for scheme in value:
+                    if not isinstance(scheme, native_string_types):
+                        raise ExpectedTypeError(value, "str", "deprecated element")
+                    if scheme not in schemes:
+                        raise KeyError("deprecated scheme not found "
+                                   "in policy: %r" % (scheme,))
+        elif key == "min_verify_time":
+            warn("'min_verify_time' was deprecated in Passlib 1.6, is "
+                 "ignored in 1.7, and will be removed in 1.8",
+                 DeprecationWarning)
+        elif key == "harden_verify":
+            warn("'harden_verify' is deprecated & ignored as of Passlib 1.7.1, "
+                 " and will be removed in 1.8",
+                 DeprecationWarning)
+        elif key != "schemes":
+            raise KeyError("unknown CryptContext keyword: %r" % (key,))
+        return key, value
+
+    #---------------------------------------------------------------
+    # reading context options
+    #---------------------------------------------------------------
+    def get_context_optionmap(self, key, _default={}):
+        """return dict mapping category->value for specific context option.
+
+        .. warning:: treat return value as readonly!
+        """
+        return self._context_options.get(key, _default)
+
+    def get_context_option_with_flag(self, category, key):
+        """return value of specific option, handling category inheritance.
+        also returns flag indicating whether value is category-specific.
+        """
+        try:
+            category_map = self._context_options[key]
+        except KeyError:
+            return None, False
+        value = category_map.get(None)
+        if category:
+            try:
+                alt = category_map[category]
+            except KeyError:
+                pass
+            else:
+                if value is None or alt != value:
+                    return alt, True
+        return value, False
+
+    #---------------------------------------------------------------
+    # reading scheme options
+    #---------------------------------------------------------------
+    def _get_scheme_optionmap(self, scheme, category, default={}):
+        """return all options for (scheme,category) combination
+
+        .. warning:: treat return value as readonly!
+        """
+        try:
+            return self._scheme_options[scheme][category]
+        except KeyError:
+            return default
+
+    def get_base_handler(self, scheme):
+        return self.handlers[self.schemes.index(scheme)]
+
+    @staticmethod
+    def expand_settings(handler):
+        setting_kwds = handler.setting_kwds
+        if 'rounds' in handler.setting_kwds:
+            # XXX: historically this extras won't be listed in setting_kwds
+            setting_kwds += uh.HasRounds.using_rounds_kwds
+        return setting_kwds
+
+    # NOTE: this is only used by _get_record_options_with_flag()...
+    def get_scheme_options_with_flag(self, scheme, category):
+        """return composite dict of all options set for scheme.
+        includes options inherited from 'all' and from default category.
+        result can be modified.
+        returns (kwds, has_cat_specific_options)
+        """
+        # start out with copy of global options
+        get_optionmap = self._get_scheme_optionmap
+        kwds = get_optionmap("all", None).copy()
+        has_cat_options = False
+
+        # add in category-specific global options
+        if category:
+            defkwds = kwds.copy() # <-- used to detect category-specific options
+            kwds.update(get_optionmap("all", category))
+
+        # filter out global settings not supported by handler
+        allowed_settings = self.expand_settings(self.get_base_handler(scheme))
+        for key in set(kwds).difference(allowed_settings):
+            kwds.pop(key)
+        if category:
+            for key in set(defkwds).difference(allowed_settings):
+                defkwds.pop(key)
+
+        # add in default options for scheme
+        other = get_optionmap(scheme, None)
+        kwds.update(other)
+
+        # load category-specific options for scheme
+        if category:
+            defkwds.update(other)
+            kwds.update(get_optionmap(scheme, category))
+
+            # compare default category options to see if there's anything
+            # category-specific
+            if kwds != defkwds:
+                has_cat_options = True
+
+        return kwds, has_cat_options
+
+    #===================================================================
+    # deprecated & default schemes
+    #===================================================================
+    def _init_default_schemes(self):
+        """initialize maps containing default scheme for each category.
+
+        have to do this after _init_options(), since the default scheme
+        is affected by the list of deprecated schemes.
+        """
+        # init maps & locals
+        get_optionmap = self.get_context_optionmap
+        default_map = self._default_schemes = get_optionmap("default").copy()
+        dep_map = get_optionmap("deprecated")
+        schemes = self.schemes
+        if not schemes:
+            return
+
+        # figure out default scheme
+        deps = dep_map.get(None) or ()
+        default = default_map.get(None)
+        if not default:
+            for scheme in schemes:
+                if scheme not in deps:
+                    default_map[None] = scheme
+                    break
+            else:
+                raise ValueError("must have at least one non-deprecated scheme")
+        elif default in deps:
+            raise ValueError("default scheme cannot be deprecated")
+
+        # figure out per-category default schemes,
+        for cat in self.categories:
+            cdeps = dep_map.get(cat, deps)
+            cdefault = default_map.get(cat, default)
+            if not cdefault:
+                for scheme in schemes:
+                    if scheme not in cdeps:
+                        default_map[cat] = scheme
+                        break
+                else:
+                    raise ValueError("must have at least one non-deprecated "
+                                     "scheme for %r category" % cat)
+            elif cdefault in cdeps:
+                raise ValueError("default scheme for %r category "
+                                 "cannot be deprecated" % cat)
+
+    def default_scheme(self, category):
+        """return default scheme for specific category"""
+        defaults = self._default_schemes
+        try:
+            return defaults[category]
+        except KeyError:
+            pass
+        if not self.schemes:
+            raise KeyError("no hash schemes configured for this "
+                           "CryptContext instance")
+        return defaults[None]
+
+    def is_deprecated_with_flag(self, scheme, category):
+        """is scheme deprecated under particular category?"""
+        depmap = self.get_context_optionmap("deprecated")
+        def test(cat):
+            source = depmap.get(cat, depmap.get(None))
+            if source is None:
+                return None
+            elif 'auto' in source:
+                return scheme != self.default_scheme(cat)
+            else:
+                return scheme in source
+        value = test(None) or False
+        if category:
+            alt = test(category)
+            if alt is not None and value != alt:
+                return alt, True
+        return value, False
+
+    #===================================================================
+    # CryptRecord objects
+    #===================================================================
+    def _init_records(self):
+        # NOTE: this step handles final validation of settings,
+        #       checking for violations against handler's internal invariants.
+        #       this is why we create all the records now,
+        #       so CryptContext throws error immediately rather than later.
+        self._record_lists = {}
+        records = self._records = {}
+        all_context_kwds = self.context_kwds = set()
+        get_options = self._get_record_options_with_flag
+        categories = (None,) + self.categories
+        for handler in self.handlers:
+            scheme = handler.name
+            all_context_kwds.update(handler.context_kwds)
+            for cat in categories:
+                kwds, has_cat_options = get_options(scheme, cat)
+                if cat is None or has_cat_options:
+                    records[scheme, cat] = self._create_record(handler, cat, **kwds)
+                # NOTE: if handler has no category-specific opts, get_record()
+                # will automatically use the default category's record.
+        # NOTE: default records for specific category stored under the
+        # key (None,category); these are populated on-demand by get_record().
+
+    @staticmethod
+    def _create_record(handler, category=None, deprecated=False, **settings):
+        # create custom handler if needed.
+        try:
+            # XXX: relaxed=True is mostly here to retain backwards-compat behavior.
+            #      could make this optional flag in future.
+            subcls = handler.using(relaxed=True, **settings)
+        except TypeError as err:
+            m = re.match(r".* unexpected keyword argument '(.*)'$", str(err))
+            if m and m.group(1) in settings:
+                # translate into KeyError, for backwards compat.
+                # XXX: push this down to GenericHandler.using() implementation?
+                key = m.group(1)
+                raise KeyError("keyword not supported by %s handler: %r" %
+                               (handler.name, key))
+            raise
+
+        # using private attrs to store some extra metadata in custom handler
+        assert subcls is not handler, "expected unique variant of handler"
+        ##subcls._Context__category = category
+        subcls._Context__orig_handler = handler
+        subcls.deprecated = deprecated  # attr reserved for this purpose
+        return subcls
+
+    def _get_record_options_with_flag(self, scheme, category):
+        """return composite dict of options for given scheme + category.
+
+        this is currently a private method, though some variant
+        of its output may eventually be made public.
+
+        given a scheme & category, it returns two things:
+        a set of all the keyword options to pass to :meth:`_create_record`,
+        and a bool flag indicating whether any of these options
+        were specific to the named category. if this flag is false,
+        the options are identical to the options for the default category.
+
+        the options dict includes all the scheme-specific settings,
+        as well as optional *deprecated* keyword.
+        """
+        # get scheme options
+        kwds, has_cat_options = self.get_scheme_options_with_flag(scheme, category)
+
+        # throw in deprecated flag
+        value, not_inherited = self.is_deprecated_with_flag(scheme, category)
+        if value:
+            kwds['deprecated'] = True
+        if not_inherited:
+            has_cat_options = True
+
+        return kwds, has_cat_options
+
+    def get_record(self, scheme, category):
+        """return record for specific scheme & category (cached)"""
+        # NOTE: this is part of the critical path shared by
+        #       all of CryptContext's PasswordHash methods,
+        #       hence all the caching and error checking.
+
+        # quick lookup in cache
+        try:
+            return self._records[scheme, category]
+        except KeyError:
+            pass
+
+        # type check
+        if category is not None and not isinstance(category, native_string_types):
+            if PY2 and isinstance(category, unicode):
+                # for compatibility with unicode-centric py2 apps
+                return self.get_record(scheme, category.encode("utf-8"))
+            raise ExpectedTypeError(category, "str or None", "category")
+        if scheme is not None and not isinstance(scheme, native_string_types):
+            raise ExpectedTypeError(scheme, "str or None", "scheme")
+
+        # if scheme=None,
+        # use record for category's default scheme, and cache result.
+        if not scheme:
+            default = self.default_scheme(category)
+            assert default
+            record = self._records[None, category] = self.get_record(default,
+                                                                      category)
+            return record
+
+        # if no record for (scheme, category),
+        # use record for (scheme, None), and cache result.
+        if category:
+            try:
+                cache = self._records
+                record = cache[scheme, category] = cache[scheme, None]
+                return record
+            except KeyError:
+                pass
+
+        # scheme not found in configuration for default category
+        raise KeyError("crypt algorithm not found in policy: %r" % (scheme,))
+
+    def _get_record_list(self, category=None):
+        """return list of records for category (cached)
+
+        this is an internal helper used only by identify_record()
+        """
+        # type check of category - handled by _get_record()
+        # quick lookup in cache
+        try:
+            return self._record_lists[category]
+        except KeyError:
+            pass
+        # cache miss - build list from scratch
+        value = self._record_lists[category] = [
+            self.get_record(scheme, category)
+            for scheme in self.schemes
+            ]
+        return value
+
+    def identify_record(self, hash, category, required=True):
+        """internal helper to identify appropriate custom handler for hash"""
+        # NOTE: this is part of the critical path shared by
+        #       all of CryptContext's PasswordHash methods,
+        #       hence all the caching and error checking.
+        # FIXME: if multiple hashes could match (e.g. lmhash vs nthash)
+        #        this will only return first match. might want to do something
+        #        about this in future, but for now only hashes with
+        #        unique identifiers will work properly in a CryptContext.
+        # XXX: if all handlers have a unique prefix (e.g. all are MCF / LDAP),
+        #      could use dict-lookup to speed up this search.
+        if not isinstance(hash, unicode_or_bytes_types):
+            raise ExpectedStringError(hash, "hash")
+        # type check of category - handled by _get_record_list()
+        for record in self._get_record_list(category):
+            if record.identify(hash):
+                return record
+        if not required:
+            return None
+        elif not self.schemes:
+            raise KeyError("no crypt algorithms supported")
+        else:
+            raise exc.UnknownHashError("hash could not be identified")
+
+    @memoized_property
+    def disabled_record(self):
+        for record in self._get_record_list(None):
+            if record.is_disabled:
+                return record
+        raise RuntimeError("no disabled hasher present "
+                           "(perhaps add 'unix_disabled' to list of schemes?)")
+
+    #===================================================================
+    # serialization
+    #===================================================================
+    def iter_config(self, resolve=False):
+        """regenerate original config.
+
+        this is an iterator which yields ``(cat,scheme,option),value`` items,
+        in the order they generally appear inside an INI file.
+        if interpreted as a dictionary, it should match the original
+        keywords passed to the CryptContext (aside from any canonization).
+
+        it's mainly used as the internal backend for most of the public
+        serialization methods.
+        """
+        # grab various bits of data
+        scheme_options = self._scheme_options
+        context_options = self._context_options
+        scheme_keys = sorted(scheme_options)
+        context_keys = sorted(context_options)
+
+        # write loaded schemes (may differ from 'schemes' local var)
+        if 'schemes' in context_keys:
+            context_keys.remove("schemes")
+        value = self.handlers if resolve else self.schemes
+        if value:
+            yield (None, None, "schemes"), list(value)
+
+        # then run through config for each user category
+        for cat in (None,) + self.categories:
+
+            # write context options
+            for key in context_keys:
+                try:
+                    value = context_options[key][cat]
+                except KeyError:
+                    pass
+                else:
+                    if isinstance(value, list):
+                        value = list(value)
+                    yield (cat, None, key), value
+
+            # write per-scheme options for all schemes.
+            for scheme in scheme_keys:
+                try:
+                    kwds = scheme_options[scheme][cat]
+                except KeyError:
+                    pass
+                else:
+                    for key in sorted(kwds):
+                        yield (cat, scheme, key), kwds[key]
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# main CryptContext class
+#=============================================================================
+class CryptContext(object):
+    """Helper for hashing & verifying passwords using multiple algorithms.
+
+    Instances of this class allow applications to choose a specific
+    set of hash algorithms which they wish to support, set limits and defaults
+    for the rounds and salt sizes those algorithms should use, flag
+    which algorithms should be deprecated, and automatically handle
+    migrating users to stronger hashes when they log in.
+
+    Basic usage::
+
+        >>> ctx = CryptContext(schemes=[...])
+
+    See the Passlib online documentation for details and full documentation.
+    """
+    # FIXME: altering the configuration of this object isn't threadsafe,
+    # but is generally only done during application init, so not a major
+    # issue (just yet).
+
+    # XXX: would like some way to restrict the categories that are allowed,
+    # to restrict what the app OR the config can use.
+
+    # XXX: add wrap/unwrap callback hooks so app can mutate hash format?
+
+    # XXX: add method for detecting and warning user about schemes
+    #      which don't have any good distinguishing marks?
+    #      or greedy ones (unix_disabled, plaintext) which are not listed at the end?
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+
+    # _CryptConfig instance holding current parsed config
+    _config = None
+
+    # copy of _config methods, stored in CryptContext instance for speed.
+    _get_record = None
+    _identify_record = None
+
+    #===================================================================
+    # secondary constructors
+    #===================================================================
+    @classmethod
+    def _norm_source(cls, source):
+        """internal helper - accepts string, dict, or context"""
+        if isinstance(source, dict):
+            return cls(**source)
+        elif isinstance(source, cls):
+            return source
+        else:
+            self = cls()
+            self.load(source)
+            return self
+
+    @classmethod
+    def from_string(cls, source, section="passlib", encoding="utf-8"):
+        """create new CryptContext instance from an INI-formatted string.
+
+        :type source: unicode or bytes
+        :arg source:
+            string containing INI-formatted content.
+
+        :type section: str
+        :param section:
+            option name of section to read from, defaults to ``"passlib"``.
+
+        :type encoding: str
+        :arg encoding:
+            optional encoding used when source is bytes, defaults to ``"utf-8"``.
+
+        :returns:
+            new :class:`CryptContext` instance, configured based on the
+            parameters in the *source* string.
+
+        Usage example::
+
+            >>> from passlib.context import CryptContext
+            >>> context = CryptContext.from_string('''
+            ... [passlib]
+            ... schemes = sha256_crypt, des_crypt
+            ... sha256_crypt__default_rounds = 30000
+            ... ''')
+
+        .. versionadded:: 1.6
+
+        .. seealso:: :meth:`to_string`, the inverse of this constructor.
+        """
+        if not isinstance(source, unicode_or_bytes_types):
+            raise ExpectedTypeError(source, "unicode or bytes", "source")
+        self = cls(_autoload=False)
+        self.load(source, section=section, encoding=encoding)
+        return self
+
+    @classmethod
+    def from_path(cls, path, section="passlib", encoding="utf-8"):
+        """create new CryptContext instance from an INI-formatted file.
+
+        this functions exactly the same as :meth:`from_string`,
+        except that it loads from a local file.
+
+        :type path: str
+        :arg path:
+            path to local file containing INI-formatted config.
+
+        :type section: str
+        :param section:
+            option name of section to read from, defaults to ``"passlib"``.
+
+        :type encoding: str
+        :arg encoding:
+            encoding used to load file, defaults to ``"utf-8"``.
+
+        :returns:
+            new CryptContext instance, configured based on the parameters
+            stored in the file *path*.
+
+        .. versionadded:: 1.6
+
+        .. seealso:: :meth:`from_string` for an equivalent usage example.
+        """
+        self = cls(_autoload=False)
+        self.load_path(path, section=section, encoding=encoding)
+        return self
+
+    def copy(self, **kwds):
+        """Return copy of existing CryptContext instance.
+
+        This function returns a new CryptContext instance whose configuration
+        is exactly the same as the original, with the exception that any keywords
+        passed in will take precedence over the original settings.
+        As an example::
+
+            >>> from passlib.context import CryptContext
+
+            >>> # given an existing context...
+            >>> ctx1 = CryptContext(["sha256_crypt", "md5_crypt"])
+
+            >>> # copy can be used to make a clone, and update
+            >>> # some of the settings at the same time...
+            >>> ctx2 = custom_app_context.copy(default="md5_crypt")
+
+            >>> # and the original will be unaffected by the change
+            >>> ctx1.default_scheme()
+            "sha256_crypt"
+            >>> ctx2.default_scheme()
+            "md5_crypt"
+
+        .. versionadded:: 1.6
+            This method was previously named :meth:`!replace`. That alias
+            has been deprecated, and will be removed in Passlib 1.8.
+
+        .. seealso:: :meth:`update`
+        """
+        # XXX: it would be faster to store ref to self._config,
+        #      but don't want to share config objects til sure
+        #      can rely on them being immutable.
+        other = CryptContext(_autoload=False)
+        other.load(self)
+        if kwds:
+            other.load(kwds, update=True)
+        return other
+
+    def using(self, **kwds):
+        """
+        alias for :meth:`copy`, to match PasswordHash.using()
+        """
+        return self.copy(**kwds)
+
+    def replace(self, **kwds):
+        """deprecated alias of :meth:`copy`"""
+        warn("CryptContext().replace() has been deprecated in Passlib 1.6, "
+             "and will be removed in Passlib 1.8, "
+             "it has been renamed to CryptContext().copy()",
+             DeprecationWarning, stacklevel=2)
+        return self.copy(**kwds)
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, schemes=None,
+                 # keyword only...
+                 policy=_UNSET, # <-- deprecated
+                 _autoload=True, **kwds):
+        # XXX: add ability to make flag certain contexts as immutable,
+        #      e.g. the builtin passlib ones?
+        # XXX: add a name or import path for the contexts, to help out repr?
+        if schemes is not None:
+            kwds['schemes'] = schemes
+        if policy is not _UNSET:
+            warn("The CryptContext ``policy`` keyword has been deprecated as of Passlib 1.6, "
+                 "and will be removed in Passlib 1.8; please use "
+                 "``CryptContext.from_string()` or "
+                 "``CryptContext.from_path()`` instead.",
+                 DeprecationWarning)
+            if policy is None:
+                self.load(kwds)
+            elif isinstance(policy, CryptPolicy):
+                self.load(policy._context)
+                self.update(kwds)
+            else:
+                raise TypeError("policy must be a CryptPolicy instance")
+        elif _autoload:
+            self.load(kwds)
+        else:
+            assert not kwds, "_autoload=False and kwds are mutually exclusive"
+
+    # XXX: would this be useful?
+    ##def __str__(self):
+    ##    if PY3:
+    ##        return self.to_string()
+    ##    else:
+    ##        return self.to_string().encode("utf-8")
+
+    def __repr__(self):
+        return "<CryptContext at 0x%0x>" % id(self)
+
+    #===================================================================
+    # deprecated policy object
+    #===================================================================
+    def _get_policy(self):
+        # The CryptPolicy class has been deprecated, so to support any
+        # legacy accesses, we create a stub policy object so .policy attr
+        # will continue to work.
+        #
+        # the code waits until app accesses a specific policy object attribute
+        # before issuing deprecation warning, so developer gets method-specific
+        # suggestion for how to upgrade.
+
+        # NOTE: making a copy of the context so the policy acts like a snapshot,
+        # to retain the pre-1.6 behavior.
+        return CryptPolicy(_internal_context=self.copy(), _stub_policy=True)
+
+    def _set_policy(self, policy):
+        warn("The CryptPolicy class and the ``context.policy`` attribute have "
+             "been deprecated as of Passlib 1.6, and will be removed in "
+             "Passlib 1.8; please use the ``context.load()`` and "
+             "``context.update()`` methods instead.",
+             DeprecationWarning, stacklevel=2)
+        if isinstance(policy, CryptPolicy):
+            self.load(policy._context)
+        else:
+            raise TypeError("expected CryptPolicy instance")
+
+    policy = property(_get_policy, _set_policy,
+                    doc="[deprecated] returns CryptPolicy instance "
+                        "tied to this CryptContext")
+
+    #===================================================================
+    # loading / updating configuration
+    #===================================================================
+    @staticmethod
+    def _parse_ini_stream(stream, section, filename):
+        """helper read INI from stream, extract passlib section as dict"""
+        # NOTE: this expects a unicode stream under py3,
+        # and a utf-8 bytes stream under py2,
+        # allowing the resulting dict to always use native strings.
+        p = SafeConfigParser()
+        if PY3:
+            # python 3.2 deprecated readfp in favor of read_file
+            p.read_file(stream, filename)
+        else:
+            p.readfp(stream, filename)
+        # XXX: could change load() to accept list of items,
+        #      and skip intermediate dict creation
+        return dict(p.items(section))
+
+    def load_path(self, path, update=False, section="passlib", encoding="utf-8"):
+        """Load new configuration into CryptContext from a local file.
+
+        This function is a wrapper for :meth:`load` which
+        loads a configuration string from the local file *path*,
+        instead of an in-memory source. Its behavior and options
+        are otherwise identical to :meth:`!load` when provided with
+        an INI-formatted string.
+
+        .. versionadded:: 1.6
+        """
+        def helper(stream):
+            kwds = self._parse_ini_stream(stream, section, path)
+            return self.load(kwds, update=update)
+        if PY3:
+            # decode to unicode, which load() expected under py3
+            with open(path, "rt", encoding=encoding) as stream:
+                return helper(stream)
+        elif encoding in ["utf-8", "ascii"]:
+            # keep as utf-8 bytes, which load() expects under py2
+            with open(path, "rb") as stream:
+                return helper(stream)
+        else:
+            # transcode to utf-8 bytes
+            with open(path, "rb") as fh:
+                tmp = fh.read().decode(encoding).encode("utf-8")
+                return helper(BytesIO(tmp))
+
+    def load(self, source, update=False, section="passlib", encoding="utf-8"):
+        """Load new configuration into CryptContext, replacing existing config.
+
+        :arg source:
+            source of new configuration to load.
+            this value can be a number of different types:
+
+            * a :class:`!dict` object, or compatible Mapping
+
+                the key/value pairs will be interpreted the same
+                keywords for the :class:`CryptContext` class constructor.
+
+            * a :class:`!unicode` or :class:`!bytes` string
+
+                this will be interpreted as an INI-formatted file,
+                and appropriate key/value pairs will be loaded from
+                the specified *section*.
+
+            * another :class:`!CryptContext` object.
+
+                this will export a snapshot of its configuration
+                using :meth:`to_dict`.
+
+        :type update: bool
+        :param update:
+            By default, :meth:`load` will replace the existing configuration
+            entirely. If ``update=True``, it will preserve any existing
+            configuration options that are not overridden by the new source,
+            much like the :meth:`update` method.
+
+        :type section: str
+        :param section:
+            When parsing an INI-formatted string, :meth:`load` will look for
+            a section named ``"passlib"``. This option allows an alternate
+            section name to be used. Ignored when loading from a dictionary.
+
+        :type encoding: str
+        :param encoding:
+            Encoding to use when **source** is bytes.
+            Defaults to ``"utf-8"``. Ignored when loading from a dictionary.
+
+            .. deprecated:: 1.8
+
+                This keyword, and support for bytes input, will be dropped in Passlib 2.0
+
+        :raises TypeError:
+            * If the source cannot be identified.
+            * If an unknown / malformed keyword is encountered.
+
+        :raises ValueError:
+            If an invalid keyword value is encountered.
+
+        .. note::
+
+            If an error occurs during a :meth:`!load` call, the :class:`!CryptContext`
+            instance will be restored to the configuration it was in before
+            the :meth:`!load` call was made; this is to ensure it is
+            *never* left in an inconsistent state due to a load error.
+
+        .. versionadded:: 1.6
+        """
+        #-----------------------------------------------------------
+        # autodetect source type, convert to dict
+        #-----------------------------------------------------------
+        parse_keys = True
+        if isinstance(source, unicode_or_bytes_types):
+            if PY3:
+                source = to_unicode(source, encoding, param="source")
+            else:
+                source = to_bytes(source, "utf-8", source_encoding=encoding,
+                                  param="source")
+            source = self._parse_ini_stream(NativeStringIO(source), section,
+                                            "<string passed to CryptContext.load()>")
+        elif isinstance(source, CryptContext):
+            # extract dict directly from config, so it can be merged later
+            source = dict(source._config.iter_config(resolve=True))
+            parse_keys = False
+        elif not hasattr(source, "items"):
+            # mappings are left alone, otherwise throw an error.
+            raise ExpectedTypeError(source, "string or dict", "source")
+
+        # XXX: add support for other iterable types, e.g. sequence of pairs?
+
+        #-----------------------------------------------------------
+        # parse dict keys into (category, scheme, option) format,
+        # and merge with existing configuration if needed.
+        #-----------------------------------------------------------
+        if parse_keys:
+            parse = self._parse_config_key
+            source = dict((parse(key), value)
+                          for key, value in iteritems(source))
+        if update and self._config is not None:
+            # if updating, do nothing if source is empty,
+            if not source:
+                return
+            # otherwise overlay source on top of existing config
+            tmp = source
+            source = dict(self._config.iter_config(resolve=True))
+            source.update(tmp)
+
+        #-----------------------------------------------------------
+        # compile into _CryptConfig instance, and update state
+        #-----------------------------------------------------------
+        config = _CryptConfig(source)
+        self._config = config
+        self._reset_dummy_verify()
+        self._get_record = config.get_record
+        self._identify_record = config.identify_record
+        if config.context_kwds:
+            # (re-)enable method for this instance (in case ELSE clause below ran last load).
+            self.__dict__.pop("_strip_unused_context_kwds", None)
+        else:
+            # disable method for this instance, it's not needed.
+            self._strip_unused_context_kwds = None
+
+    @staticmethod
+    def _parse_config_key(ckey):
+        """helper used to parse ``cat__scheme__option`` keys into a tuple"""
+        # split string into 1-3 parts
+        assert isinstance(ckey, native_string_types)
+        parts = ckey.replace(".", "__").split("__")
+        count = len(parts)
+        if count == 1:
+            cat, scheme, key = None, None, parts[0]
+        elif count == 2:
+            cat = None
+            scheme, key = parts
+        elif count == 3:
+            cat, scheme, key = parts
+        else:
+            raise TypeError("keys must have less than 3 separators: %r" %
+                            (ckey,))
+        # validate & normalize the parts
+        if cat == "default":
+            cat = None
+        elif not cat and cat is not None:
+            raise TypeError("empty category: %r" % ckey)
+        if scheme == "context":
+            scheme = None
+        elif not scheme and scheme is not None:
+            raise TypeError("empty scheme: %r" % ckey)
+        if not key:
+            raise TypeError("empty option: %r" % ckey)
+        return cat, scheme, key
+
+    def update(self, *args, **kwds):
+        """Helper for quickly changing configuration.
+
+        This acts much like the :meth:`!dict.update` method:
+        it updates the context's configuration,
+        replacing the original value(s) for the specified keys,
+        and preserving the rest.
+        It accepts any :ref:`keyword <context-options>`
+        accepted by the :class:`!CryptContext` constructor.
+
+        .. versionadded:: 1.6
+
+        .. seealso:: :meth:`copy`
+        """
+        if args:
+            if len(args) > 1:
+                raise TypeError("expected at most one positional argument")
+            if kwds:
+                raise TypeError("positional arg and keywords mutually exclusive")
+            self.load(args[0], update=True)
+        elif kwds:
+            self.load(kwds, update=True)
+
+    # XXX: make this public? even just as flag to load?
+    # FIXME: this function suffered some bitrot in 1.6.1,
+    #        will need to be updated before works again.
+    ##def _simplify(self):
+    ##    "helper to remove redundant/unused options"
+    ##    # don't do anything if no schemes are defined
+    ##    if not self._schemes:
+    ##        return
+    ##
+    ##    def strip_items(target, filter):
+    ##        keys = [key for key,value in iteritems(target)
+    ##                if filter(key,value)]
+    ##        for key in keys:
+    ##            del target[key]
+    ##
+    ##    # remove redundant default.
+    ##    defaults = self._default_schemes
+    ##    if defaults.get(None) == self._schemes[0]:
+    ##        del defaults[None]
+    ##
+    ##    # remove options for unused schemes.
+    ##    scheme_options = self._scheme_options
+    ##    schemes = self._schemes + ("all",)
+    ##    strip_items(scheme_options, lambda k,v: k not in schemes)
+    ##
+    ##    # remove rendundant cat defaults.
+    ##    cur = self.default_scheme()
+    ##    strip_items(defaults, lambda k,v: k and v==cur)
+    ##
+    ##    # remove redundant category deprecations.
+    ##    # TODO: this should work w/ 'auto', but needs closer inspection
+    ##    deprecated = self._deprecated_schemes
+    ##    cur = self._deprecated_schemes.get(None)
+    ##    strip_items(deprecated, lambda k,v: k and v==cur)
+    ##
+    ##    # remove redundant category options.
+    ##    for scheme, config in iteritems(scheme_options):
+    ##        if None in config:
+    ##            cur = config[None]
+    ##            strip_items(config, lambda k,v: k and v==cur)
+    ##
+    ##    # XXX: anything else?
+
+    #===================================================================
+    # reading configuration
+    #===================================================================
+    def schemes(self, resolve=False, category=None, unconfigured=False):
+        """return schemes loaded into this CryptContext instance.
+
+        :type resolve: bool
+        :arg resolve:
+            if ``True``, will return a tuple of :class:`~passlib.ifc.PasswordHash`
+            objects instead of their names.
+
+        :returns:
+            returns tuple of the schemes configured for this context
+            via the *schemes* option.
+
+        .. versionadded:: 1.6
+            This was previously available as ``CryptContext().policy.schemes()``
+
+        .. seealso:: the :ref:`schemes <context-schemes-option>` option for usage example.
+        """
+        # XXX: should resolv return records rather than handlers?
+        #      or deprecate resolve keyword completely?
+        #      offering up a .hashers Mapping in v1.8 would be great.
+        # NOTE: supporting 'category' and 'unconfigured' kwds as of 1.7
+        #       just to pass through to .handler(), but not documenting them...
+        #       may not need to put them to use.
+        schemes = self._config.schemes
+        if resolve:
+            return tuple(self.handler(scheme, category, unconfigured=unconfigured)
+                         for scheme in schemes)
+        else:
+            return schemes
+
+    def default_scheme(self, category=None, resolve=False, unconfigured=False):
+        """return name of scheme that :meth:`hash` will use by default.
+
+        :type resolve: bool
+        :arg resolve:
+            if ``True``, will return a :class:`~passlib.ifc.PasswordHash`
+            object instead of the name.
+
+        :type category: str or None
+        :param category:
+            Optional :ref:`user category <user-categories>`.
+            If specified, this will return the catgory-specific default scheme instead.
+
+        :returns:
+            name of the default scheme.
+
+        .. seealso:: the :ref:`default <context-default-option>` option for usage example.
+
+        .. versionadded:: 1.6
+
+        .. versionchanged:: 1.7
+
+            This now returns a hasher configured with any CryptContext-specific
+            options (custom rounds settings, etc).  Previously this returned
+            the base hasher from :mod:`passlib.hash`.
+        """
+        # XXX: deprecate this in favor of .handler() or whatever it's replaced with?
+        # NOTE: supporting 'unconfigured' kwds as of 1.7
+        #       just to pass through to .handler(), but not documenting them...
+        #       may not need to put them to use.
+        hasher = self.handler(None, category, unconfigured=unconfigured)
+        return hasher if resolve else hasher.name
+
+    # XXX: need to decide if exposing this would be useful in any way
+    ##def categories(self):
+    ##    """return user-categories with algorithm-specific options in this CryptContext.
+    ##
+    ##    this will always return a tuple.
+    ##    if no categories besides the default category have been configured,
+    ##    the tuple will be empty.
+    ##    """
+    ##    return self._config.categories
+
+    # XXX: need to decide if exposing this would be useful to applications
+    # in any meaningful way that isn't already served by to_dict()
+    ##def options(self, scheme, category=None):
+    ##    kwds, percat = self._config.get_options(scheme, category)
+    ##    return kwds
+
+    def handler(self, scheme=None, category=None, unconfigured=False):
+        """helper to resolve name of scheme -> :class:`~passlib.ifc.PasswordHash` object used by scheme.
+
+        :arg scheme:
+            This should identify the scheme to lookup.
+            If omitted or set to ``None``, this will return the handler
+            for the default scheme.
+
+        :arg category:
+            If a user category is specified, and no scheme is provided,
+            it will use the default for that category.
+            Otherwise this parameter is ignored.
+
+        :param unconfigured:
+
+            By default, this returns a handler object whose .hash()
+            and .needs_update() methods will honor the configured
+            provided by CryptContext.   See ``unconfigured=True``
+            to get the underlying handler from before any context-specific
+            configuration was applied.
+
+        :raises KeyError:
+            If the scheme does not exist OR is not being used within this context.
+
+        :returns:
+            :class:`~passlib.ifc.PasswordHash` object used to implement
+            the named scheme within this context (this will usually
+            be one of the objects from :mod:`passlib.hash`)
+
+        .. versionadded:: 1.6
+            This was previously available as ``CryptContext().policy.get_handler()``
+
+        .. versionchanged:: 1.7
+
+            This now returns a hasher configured with any CryptContext-specific
+            options (custom rounds settings, etc).  Previously this returned
+            the base hasher from :mod:`passlib.hash`.
+        """
+        try:
+            hasher = self._get_record(scheme, category)
+            if unconfigured:
+                return hasher._Context__orig_handler
+            else:
+                return hasher
+        except KeyError:
+            pass
+        if self._config.handlers:
+            raise KeyError("crypt algorithm not found in this "
+                           "CryptContext instance: %r" % (scheme,))
+        else:
+            raise KeyError("no crypt algorithms loaded in this "
+                           "CryptContext instance")
+
+    def _get_unregistered_handlers(self):
+        """check if any handlers in this context aren't in the global registry"""
+        return tuple(handler for handler in self._config.handlers
+                     if not _is_handler_registered(handler))
+
+    @property
+    def context_kwds(self):
+        """
+        return :class:`!set` containing union of all :ref:`contextual keywords <context-keywords>`
+        supported by the handlers in this context.
+
+        .. versionadded:: 1.6.6
+        """
+        return self._config.context_kwds
+
+    #===================================================================
+    # exporting config
+    #===================================================================
+    @staticmethod
+    def _render_config_key(key):
+        """convert 3-part config key to single string"""
+        cat, scheme, option = key
+        if cat:
+            return "%s__%s__%s" % (cat, scheme or "context", option)
+        elif scheme:
+            return "%s__%s" % (scheme, option)
+        else:
+            return option
+
+    @staticmethod
+    def _render_ini_value(key, value):
+        """render value to string suitable for INI file"""
+        # convert lists to comma separated lists
+        # (mainly 'schemes' & 'deprecated')
+        if isinstance(value, (list,tuple)):
+            value = ", ".join(value)
+
+        # convert numbers to strings
+        elif isinstance(value, num_types):
+            if isinstance(value, float) and key[2] == "vary_rounds":
+                value = ("%.2f" % value).rstrip("0") if value else "0"
+            else:
+                value = str(value)
+
+        assert isinstance(value, native_string_types), \
+               "expected string for key: %r %r" % (key, value)
+
+        # escape any percent signs.
+        return value.replace("%", "%%")
+
+    def to_dict(self, resolve=False):
+        """Return current configuration as a dictionary.
+
+        :type resolve: bool
+        :arg resolve:
+            if ``True``, the ``schemes`` key will contain a list of
+            a :class:`~passlib.ifc.PasswordHash` objects instead of just
+            their names.
+
+        This method dumps the current configuration of the CryptContext
+        instance. The key/value pairs should be in the format accepted
+        by the :class:`!CryptContext` class constructor, in fact
+        ``CryptContext(**myctx.to_dict())`` will create an exact copy of ``myctx``.
+        As an example::
+
+            >>> # you can dump the configuration of any crypt context...
+            >>> from passlib.apps import ldap_nocrypt_context
+            >>> ldap_nocrypt_context.to_dict()
+            {'schemes': ['ldap_salted_sha1',
+            'ldap_salted_md5',
+            'ldap_sha1',
+            'ldap_md5',
+            'ldap_plaintext']}
+
+        .. versionadded:: 1.6
+            This was previously available as ``CryptContext().policy.to_dict()``
+
+        .. seealso:: the :ref:`context-serialization-example` example in the tutorial.
+        """
+        # XXX: should resolve default to conditional behavior
+        # based on presence of unregistered handlers?
+        render_key = self._render_config_key
+        return dict((render_key(key), value)
+                    for key, value in self._config.iter_config(resolve))
+
+    def _write_to_parser(self, parser, section):
+        """helper to write to ConfigParser instance"""
+        render_key = self._render_config_key
+        render_value = self._render_ini_value
+        parser.add_section(section)
+        for k,v in self._config.iter_config():
+            v = render_value(k, v)
+            k = render_key(k)
+            parser.set(section, k, v)
+
+    def to_string(self, section="passlib"):
+        """serialize to INI format and return as unicode string.
+
+        :param section:
+            name of INI section to output, defaults to ``"passlib"``.
+
+        :returns:
+            CryptContext configuration, serialized to a INI unicode string.
+
+        This function acts exactly like :meth:`to_dict`, except that it
+        serializes all the contents into a single human-readable string,
+        which can be hand edited, and/or stored in a file. The
+        output of this method is accepted by :meth:`from_string`,
+        :meth:`from_path`, and :meth:`load`. As an example::
+
+            >>> # you can dump the configuration of any crypt context...
+            >>> from passlib.apps import ldap_nocrypt_context
+            >>> print ldap_nocrypt_context.to_string()
+            [passlib]
+            schemes = ldap_salted_sha1, ldap_salted_md5, ldap_sha1, ldap_md5, ldap_plaintext
+
+        .. versionadded:: 1.6
+            This was previously available as ``CryptContext().policy.to_string()``
+
+        .. seealso:: the :ref:`context-serialization-example` example in the tutorial.
+        """
+        parser = SafeConfigParser()
+        self._write_to_parser(parser, section)
+        buf = NativeStringIO()
+        parser.write(buf)
+        unregistered = self._get_unregistered_handlers()
+        if unregistered:
+            buf.write((
+                "# NOTE: the %s handler(s) are not registered with Passlib,\n"
+                "# this string may not correctly reproduce the current configuration.\n\n"
+                ) % ", ".join(repr(handler.name) for handler in unregistered))
+        out = buf.getvalue()
+        if not PY3:
+            out = out.decode("utf-8")
+        return out
+
+    # XXX: is this useful enough to enable?
+    ##def write_to_path(self, path, section="passlib", update=False):
+    ##    "write to INI file"
+    ##    parser = ConfigParser()
+    ##    if update and os.path.exists(path):
+    ##        if not parser.read([path]):
+    ##            raise EnvironmentError("failed to read existing file")
+    ##        parser.remove_section(section)
+    ##    self._write_to_parser(parser, section)
+    ##    fh = file(path, "w")
+    ##    parser.write(fh)
+    ##    fh.close()
+
+    #===================================================================
+    # verify() hardening
+    # NOTE: this entire feature has been disabled.
+    #       all contents of this section are NOOPs as of 1.7.1,
+    #       and will be removed in 1.8.
+    #===================================================================
+
+    mvt_estimate_max_samples = 20
+    mvt_estimate_min_samples = 10
+    mvt_estimate_max_time = 2
+    mvt_estimate_resolution = 0.01
+    harden_verify = None
+    min_verify_time = 0
+
+    def reset_min_verify_time(self):
+        self._reset_dummy_verify()
+
+    #===================================================================
+    # password hash api
+    #===================================================================
+
+    # NOTE: all the following methods do is look up the appropriate
+    #       custom handler for a given (scheme,category) combination,
+    #       and hand off the real work to the handler itself,
+    #       which is optimized for the specific (scheme,category) configuration.
+    #
+    #       The custom handlers are cached inside the _CryptConfig
+    #       instance stored in self._config, and are retrieved
+    #       via get_record() and identify_record().
+    #
+    #       _get_record() and _identify_record() are references
+    #       to _config methods of the same name,
+    #       stored in CryptContext for speed.
+
+    def _get_or_identify_record(self, hash, scheme=None, category=None):
+        """return record based on scheme, or failing that, by identifying hash"""
+        if scheme:
+            if not isinstance(hash, unicode_or_bytes_types):
+                raise ExpectedStringError(hash, "hash")
+            return self._get_record(scheme, category)
+        else:
+            # hash typecheck handled by identify_record()
+            return self._identify_record(hash, category)
+
+    def _strip_unused_context_kwds(self, kwds, record):
+        """
+        helper which removes any context keywords from **kwds**
+        that are known to be used by another scheme in this context,
+        but are NOT supported by handler specified by **record**.
+
+        .. note::
+            as optimization, load() will set this method to None on a per-instance basis
+            if there are no context kwds.
+        """
+        if not kwds:
+            return
+        unused_kwds = self._config.context_kwds.difference(record.context_kwds)
+        for key in unused_kwds:
+            kwds.pop(key, None)
+
+    def needs_update(self, hash, scheme=None, category=None, secret=None):
+        """Check if hash needs to be replaced for some reason,
+        in which case the secret should be re-hashed.
+
+        This function is the core of CryptContext's support for hash migration:
+        This function takes in a hash string, and checks the scheme,
+        number of rounds, and other properties against the current policy.
+        It returns ``True`` if the hash is using a deprecated scheme,
+        or is otherwise outside of the bounds specified by the policy
+        (e.g. the number of rounds is lower than :ref:`min_rounds <context-min-rounds-option>`
+        configuration for that algorithm).
+        If so, the password should be re-hashed using :meth:`hash`
+        Otherwise, it will return ``False``.
+
+        :type hash: unicode or bytes
+        :arg hash:
+            The hash string to examine.
+
+        :type scheme: str or None
+        :param scheme:
+
+            Optional scheme to use. Scheme must be one of the ones
+            configured for this context (see the
+            :ref:`schemes <context-schemes-option>` option).
+            If no scheme is specified, it will be identified
+            based on the value of *hash*.
+
+            .. deprecated:: 1.7
+
+                Support for this keyword is deprecated, and will be removed in Passlib 2.0.
+
+        :type category: str or None
+        :param category:
+            Optional :ref:`user category <user-categories>`.
+            If specified, this will cause any category-specific defaults to
+            be used when determining if the hash needs to be updated
+            (e.g. is below the minimum rounds).
+
+        :type secret: unicode, bytes, or None
+        :param secret:
+            Optional secret associated with the provided ``hash``.
+            This is not required, or even currently used for anything...
+            it's for forward-compatibility with any future
+            update checks that might need this information.
+            If provided, Passlib assumes the secret has already been
+            verified successfully against the hash.
+
+            .. versionadded:: 1.6
+
+        :returns: ``True`` if hash should be replaced, otherwise ``False``.
+
+        :raises ValueError:
+            If the hash did not match any of the configured :meth:`schemes`.
+
+        .. versionadded:: 1.6
+            This method was previously named :meth:`hash_needs_update`.
+
+        .. seealso:: the :ref:`context-migration-example` example in the tutorial.
+        """
+        if scheme is not None:
+            # TODO: offer replacement alternative.
+            #       ``context.handler(scheme).needs_update()`` would work,
+            #       but may deprecate .handler() in passlib 1.8.
+            warn("CryptContext.needs_update(): 'scheme' keyword is deprecated as of "
+                 "Passlib 1.7, and will be removed in Passlib 2.0",
+                 DeprecationWarning)
+        record = self._get_or_identify_record(hash, scheme, category)
+        return record.deprecated or record.needs_update(hash, secret=secret)
+
+    @deprecated_method(deprecated="1.6", removed="2.0", replacement="CryptContext.needs_update()")
+    def hash_needs_update(self, hash, scheme=None, category=None):
+        """Legacy alias for :meth:`needs_update`.
+
+        .. deprecated:: 1.6
+            This method was renamed to :meth:`!needs_update` in version 1.6.
+            This alias will be removed in version 2.0, and should only
+            be used for compatibility with Passlib 1.3 - 1.5.
+        """
+        return self.needs_update(hash, scheme, category)
+
+    @deprecated_method(deprecated="1.7", removed="2.0")
+    def genconfig(self, scheme=None, category=None, **settings):
+        """Generate a config string for specified scheme.
+
+        .. deprecated:: 1.7
+
+            This method will be removed in version 2.0, and should only
+            be used for compatibility with Passlib 1.3 - 1.6.
+        """
+        record = self._get_record(scheme, category)
+        strip_unused = self._strip_unused_context_kwds
+        if strip_unused:
+            strip_unused(settings, record)
+        return record.genconfig(**settings)
+
+    @deprecated_method(deprecated="1.7", removed="2.0")
+    def genhash(self, secret, config, scheme=None, category=None, **kwds):
+        """Generate hash for the specified secret using another hash.
+
+        .. deprecated:: 1.7
+
+            This method will be removed in version 2.0, and should only
+            be used for compatibility with Passlib 1.3 - 1.6.
+        """
+        record = self._get_or_identify_record(config, scheme, category)
+        strip_unused = self._strip_unused_context_kwds
+        if strip_unused:
+            strip_unused(kwds, record)
+        return record.genhash(secret, config, **kwds)
+
+    def identify(self, hash, category=None, resolve=False, required=False,
+                 unconfigured=False):
+        """Attempt to identify which algorithm the hash belongs to.
+
+        Note that this will only consider the algorithms
+        currently configured for this context
+        (see the :ref:`schemes <context-schemes-option>` option).
+        All registered algorithms will be checked, from first to last,
+        and whichever one positively identifies the hash first will be returned.
+
+        :type hash: unicode or bytes
+        :arg hash:
+            The hash string to test.
+
+        :type category: str or None
+        :param category:
+            Optional :ref:`user category <user-categories>`.
+            Ignored by this function, this parameter
+            is provided for symmetry with the other methods.
+
+        :type resolve: bool
+        :param resolve:
+            If ``True``, returns the hash handler itself,
+            instead of the name of the hash.
+
+        :type required: bool
+        :param required:
+            If ``True``, this will raise a ValueError if the hash
+            cannot be identified, instead of returning ``None``.
+
+        :returns:
+            The handler which first identifies the hash,
+            or ``None`` if none of the algorithms identify the hash.
+        """
+        record = self._identify_record(hash, category, required)
+        if record is None:
+            return None
+        elif resolve:
+            if unconfigured:
+                return record._Context__orig_handler
+            else:
+                return record
+        else:
+            return record.name
+
+    def hash(self, secret, scheme=None, category=None, **kwds):
+        """run secret through selected algorithm, returning resulting hash.
+
+        :type secret: unicode or bytes
+        :arg secret:
+            the password to hash.
+
+        :type scheme: str or None
+        :param scheme:
+
+            Optional scheme to use. Scheme must be one of the ones
+            configured for this context (see the
+            :ref:`schemes <context-schemes-option>` option).
+            If no scheme is specified, the configured default
+            will be used.
+
+            .. deprecated:: 1.7
+
+                Support for this keyword is deprecated, and will be removed in Passlib 2.0.
+
+        :type category: str or None
+        :param category:
+            Optional :ref:`user category <user-categories>`.
+            If specified, this will cause any category-specific defaults to
+            be used when hashing the password (e.g. different default scheme,
+            different default rounds values, etc).
+
+        :param \\*\\*kwds:
+            All other keyword options are passed to the selected algorithm's
+            :meth:`PasswordHash.hash() <passlib.ifc.PasswordHash.hash>` method.
+
+        :returns:
+            The secret as encoded by the specified algorithm and options.
+            The return value will always be a :class:`!str`.
+
+        :raises TypeError, ValueError:
+            * If any of the arguments have an invalid type or value.
+              This includes any keywords passed to the underlying hash's
+              :meth:`PasswordHash.hash() <passlib.ifc.PasswordHash.hash>` method.
+
+        .. seealso:: the :ref:`context-basic-example` example in the tutorial
+        """
+        # XXX: could insert normalization to preferred unicode encoding here
+        if scheme is not None:
+            # TODO: offer replacement alternative.
+            #       ``context.handler(scheme).hash()`` would work,
+            #       but may deprecate .handler() in passlib 1.8.
+            warn("CryptContext.hash(): 'scheme' keyword is deprecated as of "
+                 "Passlib 1.7, and will be removed in Passlib 2.0",
+                 DeprecationWarning)
+        record = self._get_record(scheme, category)
+        strip_unused = self._strip_unused_context_kwds
+        if strip_unused:
+            strip_unused(kwds, record)
+        return record.hash(secret, **kwds)
+
+    @deprecated_method(deprecated="1.7", removed="2.0", replacement="CryptContext.hash()")
+    def encrypt(self, *args, **kwds):
+        """
+        Legacy alias for :meth:`hash`.
+
+        .. deprecated:: 1.7
+            This method was renamed to :meth:`!hash` in version 1.7.
+            This alias will be removed in version 2.0, and should only
+            be used for compatibility with Passlib 1.3 - 1.6.
+        """
+        return self.hash(*args, **kwds)
+
+    def verify(self, secret, hash, scheme=None, category=None, **kwds):
+        """verify secret against an existing hash.
+
+        If no scheme is specified, this will attempt to identify
+        the scheme based on the contents of the provided hash
+        (limited to the schemes configured for this context).
+        It will then check whether the password verifies against the hash.
+
+        :type secret: unicode or bytes
+        :arg secret:
+            the secret to verify
+
+        :type hash: unicode or bytes
+        :arg hash:
+            hash string to compare to
+
+            if ``None`` is passed in, this will be treated as "never verifying"
+
+        :type scheme: str
+        :param scheme:
+            Optionally force context to use specific scheme.
+            This is usually not needed, as most hashes can be unambiguously
+            identified. Scheme must be one of the ones configured
+            for this context
+            (see the :ref:`schemes <context-schemes-option>` option).
+
+            .. deprecated:: 1.7
+
+                Support for this keyword is deprecated, and will be removed in Passlib 2.0.
+
+        :type category: str or None
+        :param category:
+            Optional :ref:`user category <user-categories>` string.
+            This is mainly used when generating new hashes, it has little
+            effect when verifying; this keyword is mainly provided for symmetry.
+
+        :param \\*\\*kwds:
+            All additional keywords are passed to the appropriate handler,
+            and should match its :attr:`~passlib.ifc.PasswordHash.context_kwds`.
+
+        :returns:
+            ``True`` if the password matched the hash, else ``False``.
+
+        :raises ValueError:
+            * if the hash did not match any of the configured :meth:`schemes`.
+
+            * if any of the arguments have an invalid value (this includes
+              any keywords passed to the underlying hash's
+              :meth:`PasswordHash.verify() <passlib.ifc.PasswordHash.verify>` method).
+
+        :raises TypeError:
+            * if any of the arguments have an invalid type (this includes
+              any keywords passed to the underlying hash's
+              :meth:`PasswordHash.verify() <passlib.ifc.PasswordHash.verify>` method).
+
+        .. seealso:: the :ref:`context-basic-example` example in the tutorial
+        """
+        # XXX: could insert normalization to preferred unicode encoding here
+        # XXX: what about supporting a setter() callback ala django 1.4 ?
+        if scheme is not None:
+            # TODO: offer replacement alternative.
+            #       ``context.handler(scheme).verify()`` would work,
+            #       but may deprecate .handler() in passlib 1.8.
+            warn("CryptContext.verify(): 'scheme' keyword is deprecated as of "
+                 "Passlib 1.7, and will be removed in Passlib 2.0",
+                 DeprecationWarning)
+        if hash is None:
+            # convenience feature -- let apps pass in hash=None when user
+            # isn't found / has no hash; useful because it invokes dummy_verify()
+            self.dummy_verify()
+            return False
+        record = self._get_or_identify_record(hash, scheme, category)
+        strip_unused = self._strip_unused_context_kwds
+        if strip_unused:
+            strip_unused(kwds, record)
+        return record.verify(secret, hash, **kwds)
+
+    def verify_and_update(self, secret, hash, scheme=None, category=None, **kwds):
+        """verify password and re-hash the password if needed, all in a single call.
+
+        This is a convenience method which takes care of all the following:
+        first it verifies the password (:meth:`~CryptContext.verify`), if this is successfull
+        it checks if the hash needs updating (:meth:`~CryptContext.needs_update`), and if so,
+        re-hashes the password (:meth:`~CryptContext.hash`), returning the replacement hash.
+        This series of steps is a very common task for applications
+        which wish to update deprecated hashes, and this call takes
+        care of all 3 steps efficiently.
+
+        :type secret: unicode or bytes
+        :arg secret:
+            the secret to verify
+
+        :type secret: unicode or bytes
+        :arg hash:
+            hash string to compare to.
+
+            if ``None`` is passed in, this will be treated as "never verifying"
+
+        :type scheme: str
+        :param scheme:
+            Optionally force context to use specific scheme.
+            This is usually not needed, as most hashes can be unambiguously
+            identified. Scheme must be one of the ones configured
+            for this context
+            (see the :ref:`schemes <context-schemes-option>` option).
+
+            .. deprecated:: 1.7
+
+                Support for this keyword is deprecated, and will be removed in Passlib 2.0.
+
+        :type category: str or None
+        :param category:
+            Optional :ref:`user category <user-categories>`.
+            If specified, this will cause any category-specific defaults to
+            be used if the password has to be re-hashed.
+
+        :param \\*\\*kwds:
+            all additional keywords are passed to the appropriate handler,
+            and should match that hash's
+            :attr:`PasswordHash.context_kwds <passlib.ifc.PasswordHash.context_kwds>`.
+
+        :returns:
+            This function returns a tuple containing two elements:
+            ``(verified, replacement_hash)``. The first is a boolean
+            flag indicating whether the password verified,
+            and the second an optional replacement hash.
+            The tuple will always match one of the following 3 cases:
+
+            * ``(False, None)`` indicates the secret failed to verify.
+            * ``(True, None)`` indicates the secret verified correctly,
+              and the hash does not need updating.
+            * ``(True, str)`` indicates the secret verified correctly,
+              but the current hash needs to be updated. The :class:`!str`
+              will be the freshly generated hash, to replace the old one.
+
+        :raises TypeError, ValueError:
+            For the same reasons as :meth:`verify`.
+
+        .. seealso:: the :ref:`context-migration-example` example in the tutorial.
+        """
+        # XXX: could insert normalization to preferred unicode encoding here.
+        if scheme is not None:
+            warn("CryptContext.verify(): 'scheme' keyword is deprecated as of "
+                 "Passlib 1.7, and will be removed in Passlib 2.0",
+                 DeprecationWarning)
+        if hash is None:
+            # convenience feature -- let apps pass in hash=None when user
+            # isn't found / has no hash; useful because it invokes dummy_verify()
+            self.dummy_verify()
+            return False, None
+        record = self._get_or_identify_record(hash, scheme, category)
+        strip_unused = self._strip_unused_context_kwds
+        if strip_unused and kwds:
+            clean_kwds = kwds.copy()
+            strip_unused(clean_kwds, record)
+        else:
+            clean_kwds = kwds
+        # XXX: if record is default scheme, could extend PasswordHash
+        #      api to combine verify & needs_update to single call,
+        #      potentially saving some round-trip parsing.
+        #      but might make these codepaths more complex...
+        if not record.verify(secret, hash, **clean_kwds):
+            return False, None
+        elif record.deprecated or record.needs_update(hash, secret=secret):
+            # NOTE: we re-hash with default scheme, not current one.
+            return True, self.hash(secret, category=category, **kwds)
+        else:
+            return True, None
+
+    #===================================================================
+    # missing-user helper
+    #===================================================================
+
+    #: secret used for dummy_verify()
+    _dummy_secret = "too many secrets"
+
+    @memoized_property
+    def _dummy_hash(self):
+        """
+        precalculated hash for dummy_verify() to use
+        """
+        return self.hash(self._dummy_secret)
+
+    def _reset_dummy_verify(self):
+        """
+        flush memoized values used by dummy_verify()
+        """
+        type(self)._dummy_hash.clear_cache(self)
+
+    def dummy_verify(self, elapsed=0):
+        """
+        Helper that applications can call when user wasn't found,
+        in order to simulate time it would take to hash a password.
+
+        Runs verify() against a dummy hash, to simulate verification
+        of a real account password.
+
+        :param elapsed:
+
+            .. deprecated:: 1.7.1
+
+                this option is ignored, and will be removed in passlib 1.8.
+
+        .. versionadded:: 1.7
+        """
+        self.verify(self._dummy_secret, self._dummy_hash)
+        return False
+
+    #===================================================================
+    # disabled hash support
+    #===================================================================
+
+    def is_enabled(self, hash):
+        """
+        test if hash represents a usuable password --
+        i.e. does not represent an unusuable password such as ``"!"``,
+        which is recognized by the :class:`~passlib.hash.unix_disabled` hash.
+
+        :raises ValueError:
+            if the hash is not recognized
+            (typically solved by adding ``unix_disabled`` to the list of schemes).
+        """
+        return not self._identify_record(hash, None).is_disabled
+
+    def disable(self, hash=None):
+        """
+        return a string to disable logins for user,
+        usually by returning a non-verifying string such as ``"!"``.
+
+        :param hash:
+            Callers can optionally provide the account's existing hash.
+            Some disabled handlers (such as :class:`!unix_disabled`)
+            will encode this into the returned value,
+            so that it can be recovered via :meth:`enable`.
+
+        :raises RuntimeError:
+            if this function is called w/o a disabled hasher
+            (such as :class:`~passlib.hash.unix_disabled`) included
+            in the list of schemes.
+
+        :returns:
+            hash string which will be recognized as valid by the context,
+            but is guaranteed to not validate against *any* password.
+        """
+        record = self._config.disabled_record
+        assert record.is_disabled
+        return record.disable(hash)
+
+    def enable(self, hash):
+        """
+        inverse of :meth:`disable` --
+        attempts to recover original hash which was converted
+        by a :meth:`!disable` call into a disabled hash --
+        thus restoring the user's original password.
+
+        :raises ValueError:
+            if original hash not present, or if the disabled handler doesn't
+            support encoding the original hash (e.g. ``django_disabled``)
+
+        :returns:
+            the original hash.
+        """
+        record = self._identify_record(hash, None)
+        if record.is_disabled:
+            # XXX: should we throw error if result can't be identified by context?
+            return record.enable(hash)
+        else:
+            # hash wasn't a disabled hash, so return unchanged
+            return hash
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class LazyCryptContext(CryptContext):
+    """CryptContext subclass which doesn't load handlers until needed.
+
+    This is a subclass of CryptContext which takes in a set of arguments
+    exactly like CryptContext, but won't import any handlers
+    (or even parse its arguments) until
+    the first time one of its methods is accessed.
+
+    :arg schemes:
+        The first positional argument can be a list of schemes, or omitted,
+        just like CryptContext.
+
+    :param onload:
+
+        If a callable is passed in via this keyword,
+        it will be invoked at lazy-load time
+        with the following signature:
+        ``onload(**kwds) -> kwds``;
+        where ``kwds`` is all the additional kwds passed to LazyCryptContext.
+        It should perform any additional deferred initialization,
+        and return the final dict of options to be passed to CryptContext.
+
+        .. versionadded:: 1.6
+
+    :param create_policy:
+
+        .. deprecated:: 1.6
+            This option will be removed in Passlib 1.8,
+            applications should use ``onload`` instead.
+
+    :param kwds:
+
+        All additional keywords are passed to CryptContext;
+        or to the *onload* function (if provided).
+
+    This is mainly used internally by modules such as :mod:`passlib.apps`,
+    which define a large number of contexts, but only a few of them will be needed
+    at any one time. Use of this class saves the memory needed to import
+    the specified handlers until the context instance is actually accessed.
+    As well, it allows constructing a context at *module-init* time,
+    but using :func:`!onload()` to provide dynamic configuration
+    at *application-run* time.
+
+    .. note:: 
+        This class is only useful if you're referencing handler objects by name,
+        and don't want them imported until runtime. If you want to have the config
+        validated before your application runs, or are passing in already-imported
+        handler instances, you should use :class:`CryptContext` instead.
+
+    .. versionadded:: 1.4
+    """
+    _lazy_kwds = None
+
+    # NOTE: the way this class works changed in 1.6.
+    #       previously it just called _lazy_init() when ``.policy`` was
+    #       first accessed. now that is done whenever any of the public
+    #       attributes are accessed, and the class itself is changed
+    #       to a regular CryptContext, to remove the overhead once it's unneeded.
+
+    def __init__(self, schemes=None, **kwds):
+        if schemes is not None:
+            kwds['schemes'] = schemes
+        self._lazy_kwds = kwds
+
+    def _lazy_init(self):
+        kwds = self._lazy_kwds
+        if 'create_policy' in kwds:
+            warn("The CryptPolicy class, and LazyCryptContext's "
+                 "``create_policy`` keyword have been deprecated as of "
+                 "Passlib 1.6, and will be removed in Passlib 1.8; "
+                 "please use the ``onload`` keyword instead.",
+                 DeprecationWarning)
+            create_policy = kwds.pop("create_policy")
+            result = create_policy(**kwds)
+            policy = CryptPolicy.from_source(result, _warn=False)
+            kwds = policy._context.to_dict()
+        elif 'onload' in kwds:
+            onload = kwds.pop("onload")
+            kwds = onload(**kwds)
+        del self._lazy_kwds
+        super(LazyCryptContext, self).__init__(**kwds)
+        self.__class__ = CryptContext
+
+    def __getattribute__(self, attr):
+        if (not attr.startswith("_") or attr.startswith("__")) and \
+            self._lazy_kwds is not None:
+                self._lazy_init()
+        return object.__getattribute__(self, attr)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/__init__.py b/myenv/lib/python3.9/site-packages/passlib/crypto/__init__.py
new file mode 100644
index 0000000..89f5484
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/__init__.py
@@ -0,0 +1 @@
+"""passlib.crypto -- package containing cryptographic primitives used by passlib"""
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/__init__.py b/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/__init__.py
new file mode 100644
index 0000000..1aa1c85
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/__init__.py
@@ -0,0 +1,169 @@
+"""passlib.crypto._blowfish - pure-python eks-blowfish implementation for bcrypt
+
+This is a pure-python implementation of the EKS-Blowfish algorithm described by
+Provos and Mazieres in `A Future-Adaptable Password Scheme
+<http://www.openbsd.org/papers/bcrypt-paper.ps>`_.
+
+This package contains two submodules:
+
+* ``_blowfish/base.py`` contains a class implementing the eks-blowfish algorithm
+  using easy-to-examine code.
+
+* ``_blowfish/unrolled.py`` contains a subclass which replaces some methods
+  of the original class with sped-up versions, mainly using unrolled loops
+  and local variables. this is the class which is actually used by
+  Passlib to perform BCrypt in pure python.
+
+  This module is auto-generated by a script, ``_blowfish/_gen_files.py``.
+
+Status
+------
+This implementation is usable, but is an order of magnitude too slow to be
+usable with real security. For "ok" security, BCrypt hashes should have at
+least 2**11 rounds (as of 2011). Assuming a desired response time <= 100ms,
+this means a BCrypt implementation should get at least 20 rounds/ms in order
+to be both usable *and* secure. On a 2 ghz cpu, this implementation gets
+roughly 0.09 rounds/ms under CPython (220x too slow), and 1.9 rounds/ms
+under PyPy (10x too slow).
+
+History
+-------
+While subsequently modified considerly for Passlib, this code was originally
+based on `jBcrypt 0.2 <http://www.mindrot.org/projects/jBCrypt/>`_, which was
+released under the BSD license::
+
+    Copyright (c) 2006 Damien Miller <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.
+
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from itertools import chain
+import struct
+# pkg
+from passlib.utils import getrandbytes, rng
+from passlib.utils.binary import bcrypt64
+from passlib.utils.compat import BytesIO, unicode, u, native_string_types
+from passlib.crypto._blowfish.unrolled import BlowfishEngine
+# local
+__all__ = [
+    'BlowfishEngine',
+    'raw_bcrypt',
+]
+
+#=============================================================================
+# bcrypt constants
+#=============================================================================
+
+# bcrypt constant data "OrpheanBeholderScryDoubt" as 6 integers
+BCRYPT_CDATA = [
+    0x4f727068, 0x65616e42, 0x65686f6c,
+    0x64657253, 0x63727944, 0x6f756274
+]
+
+# struct used to encode ciphertext as digest (last output byte discarded)
+digest_struct = struct.Struct(">6I")
+
+#=============================================================================
+# base bcrypt helper
+#
+# interface designed only for use by passlib.handlers.bcrypt:BCrypt
+# probably not suitable for other purposes
+#=============================================================================
+BNULL = b'\x00'
+
+def raw_bcrypt(password, ident, salt, log_rounds):
+    """perform central password hashing step in bcrypt scheme.
+
+    :param password: the password to hash
+    :param ident: identifier w/ minor version (e.g. 2, 2a)
+    :param salt: the binary salt to use (encoded in bcrypt-base64)
+    :param log_rounds: the log2 of the number of rounds (as int)
+    :returns: bcrypt-base64 encoded checksum
+    """
+    #===================================================================
+    # parse inputs
+    #===================================================================
+
+    # parse ident
+    assert isinstance(ident, native_string_types)
+    add_null_padding = True
+    if ident == u('2a') or ident == u('2y') or ident == u('2b'):
+        pass
+    elif ident == u('2'):
+        add_null_padding = False
+    elif ident == u('2x'):
+        raise ValueError("crypt_blowfish's buggy '2x' hashes are not "
+                         "currently supported")
+    else:
+        raise ValueError("unknown ident: %r" % (ident,))
+
+    # decode & validate salt
+    assert isinstance(salt, bytes)
+    salt = bcrypt64.decode_bytes(salt)
+    if len(salt) < 16:
+        raise ValueError("Missing salt bytes")
+    elif len(salt) > 16:
+        salt = salt[:16]
+
+    # prepare password
+    assert isinstance(password, bytes)
+    if add_null_padding:
+        password += BNULL
+
+    # validate rounds
+    if log_rounds < 4 or log_rounds > 31:
+        raise ValueError("Bad number of rounds")
+
+    #===================================================================
+    #
+    # run EKS-Blowfish algorithm
+    #
+    # This uses the "enhanced key schedule" step described by
+    # Provos and Mazieres in "A Future-Adaptable Password Scheme"
+    # http://www.openbsd.org/papers/bcrypt-paper.ps
+    #
+    #===================================================================
+
+    engine = BlowfishEngine()
+
+    # convert password & salt into list of 18 32-bit integers (72 bytes total).
+    pass_words = engine.key_to_words(password)
+    salt_words = engine.key_to_words(salt)
+
+    # truncate salt_words to original 16 byte salt, or loop won't wrap
+    # correctly when passed to .eks_salted_expand()
+    salt_words16 = salt_words[:4]
+
+    # do EKS key schedule setup
+    engine.eks_salted_expand(pass_words, salt_words16)
+
+    # apply password & salt keys to key schedule a bunch more times.
+    rounds = 1<<log_rounds
+    engine.eks_repeated_expand(pass_words, salt_words, rounds)
+
+    # encipher constant data, and encode to bytes as digest.
+    data = list(BCRYPT_CDATA)
+    i = 0
+    while i < 6:
+        data[i], data[i+1] = engine.repeat_encipher(data[i], data[i+1], 64)
+        i += 2
+    raw = digest_struct.pack(*data)[:-1]
+    return bcrypt64.encode_bytes(raw)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/_gen_files.py b/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/_gen_files.py
new file mode 100644
index 0000000..2f92cf8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/_gen_files.py
@@ -0,0 +1,204 @@
+"""passlib.crypto._blowfish._gen_files - meta script that generates unrolled.py"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import os
+import textwrap
+# pkg
+from passlib.utils.compat import irange
+# local
+
+#=============================================================================
+# helpers
+#=============================================================================
+def varlist(name, count):
+    return ", ".join(name + str(x) for x in irange(count))
+
+
+def indent_block(block, padding):
+    """ident block of text"""
+    lines = block.split("\n")
+    return "\n".join(
+        padding + line if line else ""
+        for line in lines
+    )
+
+BFSTR = """\
+                ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+                  S3[l & 0xff]) & 0xffffffff)
+""".strip()
+
+def render_encipher(write, indent=0):
+    for i in irange(0, 15, 2):
+        write(indent, """\
+            # Feistel substitution on left word (round %(i)d)
+            r ^= %(left)s ^ p%(i1)d
+
+            # Feistel substitution on right word (round %(i1)d)
+            l ^= %(right)s ^ p%(i2)d
+        """, i=i, i1=i+1, i2=i+2,
+             left=BFSTR, right=BFSTR.replace("l","r"),
+             )
+
+def write_encipher_function(write, indent=0):
+    write(indent, """\
+        def encipher(self, l, r):
+            \"""blowfish encipher a single 64-bit block encoded as two 32-bit ints\"""
+
+            (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9,
+              p10, p11, p12, p13, p14, p15, p16, p17) = self.P
+            S0, S1, S2, S3 = self.S
+
+            l ^= p0
+
+            """)
+    render_encipher(write, indent+1)
+
+    write(indent+1, """\
+
+        return r ^ p17, l
+
+        """)
+
+def write_expand_function(write, indent=0):
+    write(indent, """\
+        def expand(self, key_words):
+            \"""unrolled version of blowfish key expansion\"""
+            ##assert len(key_words) >= 18, "size of key_words must be >= 18"
+
+            P, S = self.P, self.S
+            S0, S1, S2, S3 = S
+
+            #=============================================================
+            # integrate key
+            #=============================================================
+        """)
+    for i in irange(18):
+        write(indent+1, """\
+            p%(i)d = P[%(i)d] ^ key_words[%(i)d]
+        """, i=i)
+    write(indent+1, """\
+
+        #=============================================================
+        # update P
+        #=============================================================
+
+        #------------------------------------------------
+        # update P[0] and P[1]
+        #------------------------------------------------
+        l, r = p0, 0
+
+        """)
+
+    render_encipher(write, indent+1)
+
+    write(indent+1, """\
+
+        p0, p1 = l, r = r ^ p17, l
+
+        """)
+
+    for i in irange(2, 18, 2):
+        write(indent+1, """\
+            #------------------------------------------------
+            # update P[%(i)d] and P[%(i1)d]
+            #------------------------------------------------
+            l ^= p0
+
+            """, i=i, i1=i+1)
+
+        render_encipher(write, indent+1)
+
+        write(indent+1, """\
+            p%(i)d, p%(i1)d = l, r = r ^ p17, l
+
+            """, i=i, i1=i+1)
+
+    write(indent+1, """\
+
+        #------------------------------------------------
+        # save changes to original P array
+        #------------------------------------------------
+        P[:] = (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9,
+          p10, p11, p12, p13, p14, p15, p16, p17)
+
+        #=============================================================
+        # update S
+        #=============================================================
+
+        for box in S:
+            j = 0
+            while j < 256:
+                l ^= p0
+
+        """)
+
+    render_encipher(write, indent+3)
+
+    write(indent+3, """\
+
+                box[j], box[j+1] = l, r = r ^ p17, l
+                j += 2
+        """)
+
+#=============================================================================
+# main
+#=============================================================================
+
+def main():
+    target = os.path.join(os.path.dirname(__file__), "unrolled.py")
+    fh = file(target, "w")
+
+    def write(indent, msg, **kwds):
+        literal = kwds.pop("literal", False)
+        if kwds:
+            msg %= kwds
+        if not literal:
+            msg = textwrap.dedent(msg.rstrip(" "))
+        if indent:
+            msg = indent_block(msg, " " * (indent*4))
+        fh.write(msg)
+
+    write(0, """\
+        \"""passlib.crypto._blowfish.unrolled - unrolled loop implementation of bcrypt,
+        autogenerated by _gen_files.py
+
+        currently this override the encipher() and expand() methods
+        with optimized versions, and leaves the other base.py methods alone.
+        \"""
+        #=================================================================
+        # imports
+        #=================================================================
+        # pkg
+        from passlib.crypto._blowfish.base import BlowfishEngine as _BlowfishEngine
+        # local
+        __all__ = [
+            "BlowfishEngine",
+        ]
+        #=================================================================
+        #
+        #=================================================================
+        class BlowfishEngine(_BlowfishEngine):
+
+        """)
+
+    write_encipher_function(write, indent=1)
+    write_expand_function(write, indent=1)
+
+    write(0, """\
+            #=================================================================
+            # eoc
+            #=================================================================
+
+        #=================================================================
+        # eof
+        #=================================================================
+        """)
+
+if __name__ == "__main__":
+    main()
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/base.py b/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/base.py
new file mode 100644
index 0000000..7b4f2cb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/base.py
@@ -0,0 +1,441 @@
+"""passlib.crypto._blowfish.base - unoptimized pure-python blowfish engine"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import struct
+# pkg
+from passlib.utils import repeat_string
+# local
+__all__ = [
+    "BlowfishEngine",
+]
+
+#=============================================================================
+# blowfish constants
+#=============================================================================
+BLOWFISH_P = BLOWFISH_S = None
+
+def _init_constants():
+    global BLOWFISH_P, BLOWFISH_S
+
+    # NOTE: blowfish's spec states these numbers are the hex representation
+    # of the fractional portion of PI, in order.
+
+    # Initial contents of key schedule - 18 integers
+    BLOWFISH_P = [
+        0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+        0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+        0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+        0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+        0x9216d5d9, 0x8979fb1b,
+    ]
+
+    # all 4 blowfish S boxes in one array - 256 integers per S box
+    BLOWFISH_S = [
+        # sbox 1
+        [
+        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,
+        ],
+        # sbox 2
+        [
+        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,
+        ],
+        # sbox 3
+        [
+        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,
+        ],
+        # sbox 4
+        [
+        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,
+        ]
+    ]
+
+#=============================================================================
+# engine
+#=============================================================================
+class BlowfishEngine(object):
+
+    def __init__(self):
+        if BLOWFISH_P is None:
+            _init_constants()
+        self.P = list(BLOWFISH_P)
+        self.S = [ list(box) for box in BLOWFISH_S ]
+
+    #===================================================================
+    # common helpers
+    #===================================================================
+    @staticmethod
+    def key_to_words(data, size=18):
+        """convert data to tuple of <size> 4-byte integers, repeating or
+        truncating data as needed to reach specified size"""
+        assert isinstance(data, bytes)
+        dlen = len(data)
+        if not dlen:
+            # return all zeros - original C code would just read the NUL after
+            # the password, so mimicing that behavior for this edge case.
+            return [0]*size
+
+        # repeat data until it fills up 4*size bytes
+        data = repeat_string(data, size<<2)
+
+        # unpack
+        return struct.unpack(">%dI" % (size,), data)
+
+    #===================================================================
+    # blowfish routines
+    #===================================================================
+    def encipher(self, l, r):
+        """loop version of blowfish encipher routine"""
+        P, S = self.P, self.S
+        l ^= P[0]
+        i = 1
+        while i < 17:
+            # Feistel substitution on left word
+            r = ((((S[0][l >> 24] + S[1][(l >> 16) & 0xff]) ^ S[2][(l >> 8) & 0xff]) +
+                  S[3][l & 0xff]) & 0xffffffff) ^ P[i] ^ r
+            # swap vars so even rounds do Feistel substition on right word
+            l, r = r, l
+            i += 1
+        return r ^ P[17], l
+
+    # NOTE: decipher is same as above, just with reversed(P) instead.
+
+    def expand(self, key_words):
+        """perform stock Blowfish keyschedule setup"""
+        assert len(key_words) >= 18, "key_words must be at least as large as P"
+        P, S, encipher = self.P, self.S, self.encipher
+
+        i = 0
+        while i < 18:
+            P[i] ^= key_words[i]
+            i += 1
+
+        i = l = r = 0
+        while i < 18:
+            P[i], P[i+1] = l,r = encipher(l,r)
+            i += 2
+
+        for box in S:
+            i = 0
+            while i < 256:
+                box[i], box[i+1] = l,r = encipher(l,r)
+                i += 2
+
+    #===================================================================
+    # eks-blowfish routines
+    #===================================================================
+    def eks_salted_expand(self, key_words, salt_words):
+        """perform EKS' salted version of Blowfish keyschedule setup"""
+        # NOTE: this is the same as expand(), except for the addition
+        #       of the operations involving *salt_words*.
+
+        assert len(key_words) >= 18, "key_words must be at least as large as P"
+        salt_size = len(salt_words)
+        assert salt_size, "salt_words must not be empty"
+        assert not salt_size & 1, "salt_words must have even length"
+        P, S, encipher = self.P, self.S, self.encipher
+
+        i = 0
+        while i < 18:
+            P[i] ^= key_words[i]
+            i += 1
+
+        s = i = l = r = 0
+        while i < 18:
+            l ^= salt_words[s]
+            r ^= salt_words[s+1]
+            s += 2
+            if s == salt_size:
+                s = 0
+            P[i], P[i+1] = l,r = encipher(l,r) # next()
+            i += 2
+
+        for box in S:
+            i = 0
+            while i < 256:
+                l ^= salt_words[s]
+                r ^= salt_words[s+1]
+                s += 2
+                if s == salt_size:
+                    s = 0
+                box[i], box[i+1] = l,r = encipher(l,r) # next()
+                i += 2
+
+    def eks_repeated_expand(self, key_words, salt_words, rounds):
+        """perform rounds stage of EKS keyschedule setup"""
+        expand = self.expand
+        n = 0
+        while n < rounds:
+            expand(key_words)
+            expand(salt_words)
+            n += 1
+
+    def repeat_encipher(self, l, r, count):
+        """repeatedly apply encipher operation to a block"""
+        encipher = self.encipher
+        n = 0
+        while n < count:
+            l, r = encipher(l, r)
+            n += 1
+        return l, r
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/unrolled.py b/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/unrolled.py
new file mode 100644
index 0000000..4acf6e1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/_blowfish/unrolled.py
@@ -0,0 +1,771 @@
+"""passlib.crypto._blowfish.unrolled - unrolled loop implementation of bcrypt,
+autogenerated by _gen_files.py
+
+currently this override the encipher() and expand() methods
+with optimized versions, and leaves the other base.py methods alone.
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# pkg
+from passlib.crypto._blowfish.base import BlowfishEngine as _BlowfishEngine
+# local
+__all__ = [
+    "BlowfishEngine",
+]
+#=============================================================================
+#
+#=============================================================================
+class BlowfishEngine(_BlowfishEngine):
+
+    def encipher(self, l, r):
+        """blowfish encipher a single 64-bit block encoded as two 32-bit ints"""
+
+        (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9,
+          p10, p11, p12, p13, p14, p15, p16, p17) = self.P
+        S0, S1, S2, S3 = self.S
+
+        l ^= p0
+
+        # Feistel substitution on left word (round 0)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p1
+
+        # Feistel substitution on right word (round 1)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p2
+        # Feistel substitution on left word (round 2)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p3
+
+        # Feistel substitution on right word (round 3)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p4
+        # Feistel substitution on left word (round 4)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p5
+
+        # Feistel substitution on right word (round 5)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p6
+        # Feistel substitution on left word (round 6)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p7
+
+        # Feistel substitution on right word (round 7)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p8
+        # Feistel substitution on left word (round 8)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p9
+
+        # Feistel substitution on right word (round 9)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p10
+        # Feistel substitution on left word (round 10)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p11
+
+        # Feistel substitution on right word (round 11)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p12
+        # Feistel substitution on left word (round 12)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p13
+
+        # Feistel substitution on right word (round 13)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p14
+        # Feistel substitution on left word (round 14)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p15
+
+        # Feistel substitution on right word (round 15)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p16
+
+        return r ^ p17, l
+
+    def expand(self, key_words):
+        """unrolled version of blowfish key expansion"""
+        ##assert len(key_words) >= 18, "size of key_words must be >= 18"
+
+        P, S = self.P, self.S
+        S0, S1, S2, S3 = S
+
+        #=============================================================
+        # integrate key
+        #=============================================================
+        p0 = P[0] ^ key_words[0]
+        p1 = P[1] ^ key_words[1]
+        p2 = P[2] ^ key_words[2]
+        p3 = P[3] ^ key_words[3]
+        p4 = P[4] ^ key_words[4]
+        p5 = P[5] ^ key_words[5]
+        p6 = P[6] ^ key_words[6]
+        p7 = P[7] ^ key_words[7]
+        p8 = P[8] ^ key_words[8]
+        p9 = P[9] ^ key_words[9]
+        p10 = P[10] ^ key_words[10]
+        p11 = P[11] ^ key_words[11]
+        p12 = P[12] ^ key_words[12]
+        p13 = P[13] ^ key_words[13]
+        p14 = P[14] ^ key_words[14]
+        p15 = P[15] ^ key_words[15]
+        p16 = P[16] ^ key_words[16]
+        p17 = P[17] ^ key_words[17]
+
+        #=============================================================
+        # update P
+        #=============================================================
+
+        #------------------------------------------------
+        # update P[0] and P[1]
+        #------------------------------------------------
+        l, r = p0, 0
+
+        # Feistel substitution on left word (round 0)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p1
+
+        # Feistel substitution on right word (round 1)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p2
+        # Feistel substitution on left word (round 2)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p3
+
+        # Feistel substitution on right word (round 3)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p4
+        # Feistel substitution on left word (round 4)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p5
+
+        # Feistel substitution on right word (round 5)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p6
+        # Feistel substitution on left word (round 6)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p7
+
+        # Feistel substitution on right word (round 7)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p8
+        # Feistel substitution on left word (round 8)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p9
+
+        # Feistel substitution on right word (round 9)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p10
+        # Feistel substitution on left word (round 10)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p11
+
+        # Feistel substitution on right word (round 11)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p12
+        # Feistel substitution on left word (round 12)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p13
+
+        # Feistel substitution on right word (round 13)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p14
+        # Feistel substitution on left word (round 14)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p15
+
+        # Feistel substitution on right word (round 15)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p16
+
+        p0, p1 = l, r = r ^ p17, l
+
+        #------------------------------------------------
+        # update P[2] and P[3]
+        #------------------------------------------------
+        l ^= p0
+
+        # Feistel substitution on left word (round 0)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p1
+
+        # Feistel substitution on right word (round 1)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p2
+        # Feistel substitution on left word (round 2)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p3
+
+        # Feistel substitution on right word (round 3)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p4
+        # Feistel substitution on left word (round 4)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p5
+
+        # Feistel substitution on right word (round 5)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p6
+        # Feistel substitution on left word (round 6)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p7
+
+        # Feistel substitution on right word (round 7)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p8
+        # Feistel substitution on left word (round 8)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p9
+
+        # Feistel substitution on right word (round 9)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p10
+        # Feistel substitution on left word (round 10)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p11
+
+        # Feistel substitution on right word (round 11)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p12
+        # Feistel substitution on left word (round 12)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p13
+
+        # Feistel substitution on right word (round 13)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p14
+        # Feistel substitution on left word (round 14)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p15
+
+        # Feistel substitution on right word (round 15)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p16
+        p2, p3 = l, r = r ^ p17, l
+
+        #------------------------------------------------
+        # update P[4] and P[5]
+        #------------------------------------------------
+        l ^= p0
+
+        # Feistel substitution on left word (round 0)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p1
+
+        # Feistel substitution on right word (round 1)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p2
+        # Feistel substitution on left word (round 2)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p3
+
+        # Feistel substitution on right word (round 3)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p4
+        # Feistel substitution on left word (round 4)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p5
+
+        # Feistel substitution on right word (round 5)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p6
+        # Feistel substitution on left word (round 6)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p7
+
+        # Feistel substitution on right word (round 7)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p8
+        # Feistel substitution on left word (round 8)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p9
+
+        # Feistel substitution on right word (round 9)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p10
+        # Feistel substitution on left word (round 10)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p11
+
+        # Feistel substitution on right word (round 11)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p12
+        # Feistel substitution on left word (round 12)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p13
+
+        # Feistel substitution on right word (round 13)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p14
+        # Feistel substitution on left word (round 14)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p15
+
+        # Feistel substitution on right word (round 15)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p16
+        p4, p5 = l, r = r ^ p17, l
+
+        #------------------------------------------------
+        # update P[6] and P[7]
+        #------------------------------------------------
+        l ^= p0
+
+        # Feistel substitution on left word (round 0)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p1
+
+        # Feistel substitution on right word (round 1)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p2
+        # Feistel substitution on left word (round 2)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p3
+
+        # Feistel substitution on right word (round 3)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p4
+        # Feistel substitution on left word (round 4)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p5
+
+        # Feistel substitution on right word (round 5)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p6
+        # Feistel substitution on left word (round 6)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p7
+
+        # Feistel substitution on right word (round 7)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p8
+        # Feistel substitution on left word (round 8)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p9
+
+        # Feistel substitution on right word (round 9)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p10
+        # Feistel substitution on left word (round 10)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p11
+
+        # Feistel substitution on right word (round 11)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p12
+        # Feistel substitution on left word (round 12)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p13
+
+        # Feistel substitution on right word (round 13)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p14
+        # Feistel substitution on left word (round 14)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p15
+
+        # Feistel substitution on right word (round 15)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p16
+        p6, p7 = l, r = r ^ p17, l
+
+        #------------------------------------------------
+        # update P[8] and P[9]
+        #------------------------------------------------
+        l ^= p0
+
+        # Feistel substitution on left word (round 0)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p1
+
+        # Feistel substitution on right word (round 1)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p2
+        # Feistel substitution on left word (round 2)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p3
+
+        # Feistel substitution on right word (round 3)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p4
+        # Feistel substitution on left word (round 4)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p5
+
+        # Feistel substitution on right word (round 5)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p6
+        # Feistel substitution on left word (round 6)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p7
+
+        # Feistel substitution on right word (round 7)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p8
+        # Feistel substitution on left word (round 8)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p9
+
+        # Feistel substitution on right word (round 9)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p10
+        # Feistel substitution on left word (round 10)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p11
+
+        # Feistel substitution on right word (round 11)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p12
+        # Feistel substitution on left word (round 12)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p13
+
+        # Feistel substitution on right word (round 13)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p14
+        # Feistel substitution on left word (round 14)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p15
+
+        # Feistel substitution on right word (round 15)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p16
+        p8, p9 = l, r = r ^ p17, l
+
+        #------------------------------------------------
+        # update P[10] and P[11]
+        #------------------------------------------------
+        l ^= p0
+
+        # Feistel substitution on left word (round 0)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p1
+
+        # Feistel substitution on right word (round 1)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p2
+        # Feistel substitution on left word (round 2)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p3
+
+        # Feistel substitution on right word (round 3)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p4
+        # Feistel substitution on left word (round 4)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p5
+
+        # Feistel substitution on right word (round 5)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p6
+        # Feistel substitution on left word (round 6)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p7
+
+        # Feistel substitution on right word (round 7)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p8
+        # Feistel substitution on left word (round 8)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p9
+
+        # Feistel substitution on right word (round 9)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p10
+        # Feistel substitution on left word (round 10)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p11
+
+        # Feistel substitution on right word (round 11)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p12
+        # Feistel substitution on left word (round 12)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p13
+
+        # Feistel substitution on right word (round 13)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p14
+        # Feistel substitution on left word (round 14)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p15
+
+        # Feistel substitution on right word (round 15)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p16
+        p10, p11 = l, r = r ^ p17, l
+
+        #------------------------------------------------
+        # update P[12] and P[13]
+        #------------------------------------------------
+        l ^= p0
+
+        # Feistel substitution on left word (round 0)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p1
+
+        # Feistel substitution on right word (round 1)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p2
+        # Feistel substitution on left word (round 2)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p3
+
+        # Feistel substitution on right word (round 3)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p4
+        # Feistel substitution on left word (round 4)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p5
+
+        # Feistel substitution on right word (round 5)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p6
+        # Feistel substitution on left word (round 6)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p7
+
+        # Feistel substitution on right word (round 7)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p8
+        # Feistel substitution on left word (round 8)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p9
+
+        # Feistel substitution on right word (round 9)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p10
+        # Feistel substitution on left word (round 10)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p11
+
+        # Feistel substitution on right word (round 11)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p12
+        # Feistel substitution on left word (round 12)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p13
+
+        # Feistel substitution on right word (round 13)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p14
+        # Feistel substitution on left word (round 14)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p15
+
+        # Feistel substitution on right word (round 15)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p16
+        p12, p13 = l, r = r ^ p17, l
+
+        #------------------------------------------------
+        # update P[14] and P[15]
+        #------------------------------------------------
+        l ^= p0
+
+        # Feistel substitution on left word (round 0)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p1
+
+        # Feistel substitution on right word (round 1)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p2
+        # Feistel substitution on left word (round 2)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p3
+
+        # Feistel substitution on right word (round 3)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p4
+        # Feistel substitution on left word (round 4)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p5
+
+        # Feistel substitution on right word (round 5)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p6
+        # Feistel substitution on left word (round 6)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p7
+
+        # Feistel substitution on right word (round 7)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p8
+        # Feistel substitution on left word (round 8)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p9
+
+        # Feistel substitution on right word (round 9)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p10
+        # Feistel substitution on left word (round 10)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p11
+
+        # Feistel substitution on right word (round 11)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p12
+        # Feistel substitution on left word (round 12)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p13
+
+        # Feistel substitution on right word (round 13)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p14
+        # Feistel substitution on left word (round 14)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p15
+
+        # Feistel substitution on right word (round 15)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p16
+        p14, p15 = l, r = r ^ p17, l
+
+        #------------------------------------------------
+        # update P[16] and P[17]
+        #------------------------------------------------
+        l ^= p0
+
+        # Feistel substitution on left word (round 0)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p1
+
+        # Feistel substitution on right word (round 1)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p2
+        # Feistel substitution on left word (round 2)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p3
+
+        # Feistel substitution on right word (round 3)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p4
+        # Feistel substitution on left word (round 4)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p5
+
+        # Feistel substitution on right word (round 5)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p6
+        # Feistel substitution on left word (round 6)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p7
+
+        # Feistel substitution on right word (round 7)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p8
+        # Feistel substitution on left word (round 8)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p9
+
+        # Feistel substitution on right word (round 9)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p10
+        # Feistel substitution on left word (round 10)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p11
+
+        # Feistel substitution on right word (round 11)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p12
+        # Feistel substitution on left word (round 12)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p13
+
+        # Feistel substitution on right word (round 13)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p14
+        # Feistel substitution on left word (round 14)
+        r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+              S3[l & 0xff]) & 0xffffffff) ^ p15
+
+        # Feistel substitution on right word (round 15)
+        l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+              S3[r & 0xff]) & 0xffffffff) ^ p16
+        p16, p17 = l, r = r ^ p17, l
+
+
+        #------------------------------------------------
+        # save changes to original P array
+        #------------------------------------------------
+        P[:] = (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9,
+          p10, p11, p12, p13, p14, p15, p16, p17)
+
+        #=============================================================
+        # update S
+        #=============================================================
+
+        for box in S:
+            j = 0
+            while j < 256:
+                l ^= p0
+
+                # Feistel substitution on left word (round 0)
+                r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+                      S3[l & 0xff]) & 0xffffffff) ^ p1
+
+                # Feistel substitution on right word (round 1)
+                l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+                      S3[r & 0xff]) & 0xffffffff) ^ p2
+                # Feistel substitution on left word (round 2)
+                r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+                      S3[l & 0xff]) & 0xffffffff) ^ p3
+
+                # Feistel substitution on right word (round 3)
+                l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+                      S3[r & 0xff]) & 0xffffffff) ^ p4
+                # Feistel substitution on left word (round 4)
+                r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+                      S3[l & 0xff]) & 0xffffffff) ^ p5
+
+                # Feistel substitution on right word (round 5)
+                l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+                      S3[r & 0xff]) & 0xffffffff) ^ p6
+                # Feistel substitution on left word (round 6)
+                r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+                      S3[l & 0xff]) & 0xffffffff) ^ p7
+
+                # Feistel substitution on right word (round 7)
+                l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+                      S3[r & 0xff]) & 0xffffffff) ^ p8
+                # Feistel substitution on left word (round 8)
+                r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+                      S3[l & 0xff]) & 0xffffffff) ^ p9
+
+                # Feistel substitution on right word (round 9)
+                l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+                      S3[r & 0xff]) & 0xffffffff) ^ p10
+                # Feistel substitution on left word (round 10)
+                r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+                      S3[l & 0xff]) & 0xffffffff) ^ p11
+
+                # Feistel substitution on right word (round 11)
+                l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+                      S3[r & 0xff]) & 0xffffffff) ^ p12
+                # Feistel substitution on left word (round 12)
+                r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+                      S3[l & 0xff]) & 0xffffffff) ^ p13
+
+                # Feistel substitution on right word (round 13)
+                l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+                      S3[r & 0xff]) & 0xffffffff) ^ p14
+                # Feistel substitution on left word (round 14)
+                r ^= ((((S0[l >> 24] + S1[(l >> 16) & 0xff]) ^ S2[(l >> 8) & 0xff]) +
+                      S3[l & 0xff]) & 0xffffffff) ^ p15
+
+                # Feistel substitution on right word (round 15)
+                l ^= ((((S0[r >> 24] + S1[(r >> 16) & 0xff]) ^ S2[(r >> 8) & 0xff]) +
+                      S3[r & 0xff]) & 0xffffffff) ^ p16
+
+                box[j], box[j+1] = l, r = r ^ p17, l
+                j += 2
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/_md4.py b/myenv/lib/python3.9/site-packages/passlib/crypto/_md4.py
new file mode 100644
index 0000000..bdc211f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/_md4.py
@@ -0,0 +1,244 @@
+"""
+passlib.crypto._md4 -- fallback implementation of MD4
+
+Helper implementing insecure and obsolete md4 algorithm.
+used for NTHASH format, which is also insecure and broken,
+since it's just md4(password).
+
+Implementated based on rfc at http://www.faqs.org/rfcs/rfc1320.html
+
+.. note::
+
+    This shouldn't be imported directly, it's merely used conditionally
+    by ``passlib.crypto.lookup_hash()`` when a native implementation can't be found.
+"""
+
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from binascii import hexlify
+import struct
+# site
+from passlib.utils.compat import bascii_to_str, irange, PY3
+# local
+__all__ = ["md4"]
+
+#=============================================================================
+# utils
+#=============================================================================
+def F(x,y,z):
+    return (x&y) | ((~x) & z)
+
+def G(x,y,z):
+    return (x&y) | (x&z) | (y&z)
+
+##def H(x,y,z):
+##    return x ^ y ^ z
+
+MASK_32 = 2**32-1
+
+#=============================================================================
+# main class
+#=============================================================================
+class md4(object):
+    """pep-247 compatible implementation of MD4 hash algorithm
+
+    .. attribute:: digest_size
+
+        size of md4 digest in bytes (16 bytes)
+
+    .. method:: update
+
+        update digest by appending additional content
+
+    .. method:: copy
+
+        create clone of digest object, including current state
+
+    .. method:: digest
+
+        return bytes representing md4 digest of current content
+
+    .. method:: hexdigest
+
+        return hexadecimal version of digest
+    """
+    # FIXME: make this follow hash object PEP better.
+    # FIXME: this isn't threadsafe
+
+    name = "md4"
+    digest_size = digestsize = 16
+    block_size = 64
+
+    _count = 0 # number of 64-byte blocks processed so far (not including _buf)
+    _state = None # list of [a,b,c,d] 32 bit ints used as internal register
+    _buf = None # data processed in 64 byte blocks, this holds leftover from last update
+
+    def __init__(self, content=None):
+        self._count = 0
+        self._state = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476]
+        self._buf = b''
+        if content:
+            self.update(content)
+
+    # round 1 table - [abcd k s]
+    _round1 = [
+        [0,1,2,3, 0,3],
+        [3,0,1,2, 1,7],
+        [2,3,0,1, 2,11],
+        [1,2,3,0, 3,19],
+
+        [0,1,2,3, 4,3],
+        [3,0,1,2, 5,7],
+        [2,3,0,1, 6,11],
+        [1,2,3,0, 7,19],
+
+        [0,1,2,3, 8,3],
+        [3,0,1,2, 9,7],
+        [2,3,0,1, 10,11],
+        [1,2,3,0, 11,19],
+
+        [0,1,2,3, 12,3],
+        [3,0,1,2, 13,7],
+        [2,3,0,1, 14,11],
+        [1,2,3,0, 15,19],
+    ]
+
+    # round 2 table - [abcd k s]
+    _round2 = [
+        [0,1,2,3, 0,3],
+        [3,0,1,2, 4,5],
+        [2,3,0,1, 8,9],
+        [1,2,3,0, 12,13],
+
+        [0,1,2,3, 1,3],
+        [3,0,1,2, 5,5],
+        [2,3,0,1, 9,9],
+        [1,2,3,0, 13,13],
+
+        [0,1,2,3, 2,3],
+        [3,0,1,2, 6,5],
+        [2,3,0,1, 10,9],
+        [1,2,3,0, 14,13],
+
+        [0,1,2,3, 3,3],
+        [3,0,1,2, 7,5],
+        [2,3,0,1, 11,9],
+        [1,2,3,0, 15,13],
+    ]
+
+    # round 3 table - [abcd k s]
+    _round3 = [
+        [0,1,2,3, 0,3],
+        [3,0,1,2, 8,9],
+        [2,3,0,1, 4,11],
+        [1,2,3,0, 12,15],
+
+        [0,1,2,3, 2,3],
+        [3,0,1,2, 10,9],
+        [2,3,0,1, 6,11],
+        [1,2,3,0, 14,15],
+
+        [0,1,2,3, 1,3],
+        [3,0,1,2, 9,9],
+        [2,3,0,1, 5,11],
+        [1,2,3,0, 13,15],
+
+        [0,1,2,3, 3,3],
+        [3,0,1,2, 11,9],
+        [2,3,0,1, 7,11],
+        [1,2,3,0, 15,15],
+    ]
+
+    def _process(self, block):
+        """process 64 byte block"""
+        # unpack block into 16 32-bit ints
+        X = struct.unpack("<16I", block)
+
+        # clone state
+        orig = self._state
+        state = list(orig)
+
+        # round 1 - F function - (x&y)|(~x & z)
+        for a,b,c,d,k,s in self._round1:
+            t = (state[a] + F(state[b],state[c],state[d]) + X[k]) & MASK_32
+            state[a] = ((t<<s) & MASK_32) + (t>>(32-s))
+
+        # round 2 - G function
+        for a,b,c,d,k,s in self._round2:
+            t = (state[a] + G(state[b],state[c],state[d]) + X[k] + 0x5a827999) & MASK_32
+            state[a] = ((t<<s) & MASK_32) + (t>>(32-s))
+
+        # round 3 - H function - x ^ y ^ z
+        for a,b,c,d,k,s in self._round3:
+            t = (state[a] + (state[b] ^ state[c] ^ state[d]) + X[k] + 0x6ed9eba1) & MASK_32
+            state[a] = ((t<<s) & MASK_32) + (t>>(32-s))
+
+        # add back into original state
+        for i in irange(4):
+            orig[i] = (orig[i]+state[i]) & MASK_32
+
+    def update(self, content):
+        if not isinstance(content, bytes):
+            if PY3:
+                raise TypeError("expected bytes")
+            else:
+                # replicate behavior of hashlib under py2
+                content = content.encode("ascii")
+        buf = self._buf
+        if buf:
+            content = buf + content
+        idx = 0
+        end = len(content)
+        while True:
+            next = idx + 64
+            if next <= end:
+                self._process(content[idx:next])
+                self._count += 1
+                idx = next
+            else:
+                self._buf = content[idx:]
+                return
+
+    def copy(self):
+        other = md4()
+        other._count = self._count
+        other._state = list(self._state)
+        other._buf = self._buf
+        return other
+
+    def digest(self):
+        # NOTE: backing up state so we can restore it after _process is called,
+        #       in case object is updated again (this is only attr altered by this method)
+        orig = list(self._state)
+
+        # final block: buf + 0x80,
+        # then 0x00 padding until congruent w/ 56 mod 64 bytes
+        # then last 8 bytes = msg length in bits
+        buf = self._buf
+        msglen = self._count*512 + len(buf)*8
+        block = buf + b'\x80' + b'\x00' * ((119-len(buf)) % 64) + \
+            struct.pack("<2I", msglen & MASK_32, (msglen>>32) & MASK_32)
+        if len(block) == 128:
+            self._process(block[:64])
+            self._process(block[64:])
+        else:
+            assert len(block) == 64
+            self._process(block)
+
+        # render digest & restore un-finalized state
+        out = struct.pack("<4I", *self._state)
+        self._state = orig
+        return out
+
+    def hexdigest(self):
+        return bascii_to_str(hexlify(self.digest()))
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/des.py b/myenv/lib/python3.9/site-packages/passlib/crypto/des.py
new file mode 100644
index 0000000..3f87aef
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/des.py
@@ -0,0 +1,848 @@
+"""passlib.crypto.des -- DES block encryption routines
+
+History
+=======
+These routines (which have since been drastically modified for python)
+are based on a Java implementation of the des-crypt algorithm,
+found at `<http://www.dynamic.net.au/christos/crypt/UnixCrypt2.txt>`_.
+
+The copyright & license for that source is as follows::
+
+    UnixCrypt.java 0.9 96/11/25
+    Copyright (c) 1996 Aki Yoshida. All rights reserved.
+    Permission to use, copy, modify and distribute this software
+    for non-commercial or commercial purposes and without fee is
+    hereby granted provided that this copyright notice appears in
+    all copies.
+
+    ---
+
+    Unix crypt(3C) utility
+    @version 0.9, 11/25/96
+    @author  Aki Yoshida
+
+    ---
+
+    modified April 2001
+    by Iris Van den Broeke, Daniel Deville
+
+    ---
+    Unix Crypt.
+    Implements the one way cryptography used by Unix systems for
+    simple password protection.
+    @version $Id: UnixCrypt2.txt,v 1.1.1.1 2005/09/13 22:20:13 christos Exp $
+    @author Greg Wilkins (gregw)
+
+The netbsd des-crypt implementation has some nice notes on how this all works -
+    http://fxr.googlebit.com/source/lib/libcrypt/crypt.c?v=NETBSD-CURRENT
+"""
+
+# TODO: could use an accelerated C version of this module to speed up lmhash,
+#       des-crypt, and ext-des-crypt
+
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import struct
+# pkg
+from passlib import exc
+from passlib.utils.compat import join_byte_values, byte_elem_value, \
+                                 irange, irange, int_types
+# local
+__all__ = [
+    "expand_des_key",
+    "des_encrypt_block",
+]
+
+#=============================================================================
+# constants
+#=============================================================================
+
+# masks/upper limits for various integer sizes
+INT_24_MASK = 0xffffff
+INT_56_MASK = 0xffffffffffffff
+INT_64_MASK = 0xffffffffffffffff
+
+# mask to clear parity bits from 64-bit key
+_KDATA_MASK = 0xfefefefefefefefe
+_KPARITY_MASK = 0x0101010101010101
+
+# mask used to setup key schedule
+_KS_MASK = 0xfcfcfcfcffffffff
+
+#=============================================================================
+# static DES tables
+#=============================================================================
+
+# placeholders filled in by _load_tables()
+PCXROT = IE3264 = SPE = CF6464 = None
+
+def _load_tables():
+    """delay loading tables until they are actually needed"""
+    global PCXROT, IE3264, SPE, CF6464
+
+    #---------------------------------------------------------------
+    # Initial key schedule permutation
+    # PC1ROT - bit reverse, then PC1, then Rotate, then PC2
+    #---------------------------------------------------------------
+    # NOTE: this was reordered from original table to make perm3264 logic simpler
+    PC1ROT=(
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000002000, 0x0000000000002000,
+      0x0000000000000020, 0x0000000000000020, 0x0000000000002020, 0x0000000000002020,
+      0x0000000000000400, 0x0000000000000400, 0x0000000000002400, 0x0000000000002400,
+      0x0000000000000420, 0x0000000000000420, 0x0000000000002420, 0x0000000000002420, ),
+    ( 0x0000000000000000, 0x2000000000000000, 0x0000000400000000, 0x2000000400000000,
+      0x0000800000000000, 0x2000800000000000, 0x0000800400000000, 0x2000800400000000,
+      0x0008000000000000, 0x2008000000000000, 0x0008000400000000, 0x2008000400000000,
+      0x0008800000000000, 0x2008800000000000, 0x0008800400000000, 0x2008800400000000, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000000040, 0x0000000000000040,
+      0x0000000020000000, 0x0000000020000000, 0x0000000020000040, 0x0000000020000040,
+      0x0000000000200000, 0x0000000000200000, 0x0000000000200040, 0x0000000000200040,
+      0x0000000020200000, 0x0000000020200000, 0x0000000020200040, 0x0000000020200040, ),
+    ( 0x0000000000000000, 0x0002000000000000, 0x0800000000000000, 0x0802000000000000,
+      0x0100000000000000, 0x0102000000000000, 0x0900000000000000, 0x0902000000000000,
+      0x4000000000000000, 0x4002000000000000, 0x4800000000000000, 0x4802000000000000,
+      0x4100000000000000, 0x4102000000000000, 0x4900000000000000, 0x4902000000000000, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000040000, 0x0000000000040000,
+      0x0000020000000000, 0x0000020000000000, 0x0000020000040000, 0x0000020000040000,
+      0x0000000000000004, 0x0000000000000004, 0x0000000000040004, 0x0000000000040004,
+      0x0000020000000004, 0x0000020000000004, 0x0000020000040004, 0x0000020000040004, ),
+    ( 0x0000000000000000, 0x0000400000000000, 0x0200000000000000, 0x0200400000000000,
+      0x0080000000000000, 0x0080400000000000, 0x0280000000000000, 0x0280400000000000,
+      0x0000008000000000, 0x0000408000000000, 0x0200008000000000, 0x0200408000000000,
+      0x0080008000000000, 0x0080408000000000, 0x0280008000000000, 0x0280408000000000, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000010000000, 0x0000000010000000,
+      0x0000000000001000, 0x0000000000001000, 0x0000000010001000, 0x0000000010001000,
+      0x0000000040000000, 0x0000000040000000, 0x0000000050000000, 0x0000000050000000,
+      0x0000000040001000, 0x0000000040001000, 0x0000000050001000, 0x0000000050001000, ),
+    ( 0x0000000000000000, 0x0000001000000000, 0x0000080000000000, 0x0000081000000000,
+      0x1000000000000000, 0x1000001000000000, 0x1000080000000000, 0x1000081000000000,
+      0x0004000000000000, 0x0004001000000000, 0x0004080000000000, 0x0004081000000000,
+      0x1004000000000000, 0x1004001000000000, 0x1004080000000000, 0x1004081000000000, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000000080, 0x0000000000000080,
+      0x0000000000080000, 0x0000000000080000, 0x0000000000080080, 0x0000000000080080,
+      0x0000000000800000, 0x0000000000800000, 0x0000000000800080, 0x0000000000800080,
+      0x0000000000880000, 0x0000000000880000, 0x0000000000880080, 0x0000000000880080, ),
+    ( 0x0000000000000000, 0x0000000008000000, 0x0000002000000000, 0x0000002008000000,
+      0x0000100000000000, 0x0000100008000000, 0x0000102000000000, 0x0000102008000000,
+      0x0000200000000000, 0x0000200008000000, 0x0000202000000000, 0x0000202008000000,
+      0x0000300000000000, 0x0000300008000000, 0x0000302000000000, 0x0000302008000000, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000400000, 0x0000000000400000,
+      0x0000000004000000, 0x0000000004000000, 0x0000000004400000, 0x0000000004400000,
+      0x0000000000000800, 0x0000000000000800, 0x0000000000400800, 0x0000000000400800,
+      0x0000000004000800, 0x0000000004000800, 0x0000000004400800, 0x0000000004400800, ),
+    ( 0x0000000000000000, 0x0000000000008000, 0x0040000000000000, 0x0040000000008000,
+      0x0000004000000000, 0x0000004000008000, 0x0040004000000000, 0x0040004000008000,
+      0x8000000000000000, 0x8000000000008000, 0x8040000000000000, 0x8040000000008000,
+      0x8000004000000000, 0x8000004000008000, 0x8040004000000000, 0x8040004000008000, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000004000, 0x0000000000004000,
+      0x0000000000000008, 0x0000000000000008, 0x0000000000004008, 0x0000000000004008,
+      0x0000000000000010, 0x0000000000000010, 0x0000000000004010, 0x0000000000004010,
+      0x0000000000000018, 0x0000000000000018, 0x0000000000004018, 0x0000000000004018, ),
+    ( 0x0000000000000000, 0x0000000200000000, 0x0001000000000000, 0x0001000200000000,
+      0x0400000000000000, 0x0400000200000000, 0x0401000000000000, 0x0401000200000000,
+      0x0020000000000000, 0x0020000200000000, 0x0021000000000000, 0x0021000200000000,
+      0x0420000000000000, 0x0420000200000000, 0x0421000000000000, 0x0421000200000000, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000010000000000, 0x0000010000000000,
+      0x0000000100000000, 0x0000000100000000, 0x0000010100000000, 0x0000010100000000,
+      0x0000000000100000, 0x0000000000100000, 0x0000010000100000, 0x0000010000100000,
+      0x0000000100100000, 0x0000000100100000, 0x0000010100100000, 0x0000010100100000, ),
+    ( 0x0000000000000000, 0x0000000080000000, 0x0000040000000000, 0x0000040080000000,
+      0x0010000000000000, 0x0010000080000000, 0x0010040000000000, 0x0010040080000000,
+      0x0000000800000000, 0x0000000880000000, 0x0000040800000000, 0x0000040880000000,
+      0x0010000800000000, 0x0010000880000000, 0x0010040800000000, 0x0010040880000000, ),
+        )
+    #---------------------------------------------------------------
+    # Subsequent key schedule rotation permutations
+    # PC2ROT - PC2 inverse, then Rotate, then PC2
+    #---------------------------------------------------------------
+    # NOTE: this was reordered from original table to make perm3264 logic simpler
+    PC2ROTA=(
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+      0x0000000000200000, 0x0000000000200000, 0x0000000000200000, 0x0000000000200000,
+      0x0000000004000000, 0x0000000004000000, 0x0000000004000000, 0x0000000004000000,
+      0x0000000004200000, 0x0000000004200000, 0x0000000004200000, 0x0000000004200000, ),
+    ( 0x0000000000000000, 0x0000000000000800, 0x0000010000000000, 0x0000010000000800,
+      0x0000000000002000, 0x0000000000002800, 0x0000010000002000, 0x0000010000002800,
+      0x0000000010000000, 0x0000000010000800, 0x0000010010000000, 0x0000010010000800,
+      0x0000000010002000, 0x0000000010002800, 0x0000010010002000, 0x0000010010002800, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+      0x0000000100000000, 0x0000000100000000, 0x0000000100000000, 0x0000000100000000,
+      0x0000000000800000, 0x0000000000800000, 0x0000000000800000, 0x0000000000800000,
+      0x0000000100800000, 0x0000000100800000, 0x0000000100800000, 0x0000000100800000, ),
+    ( 0x0000000000000000, 0x0000020000000000, 0x0000000080000000, 0x0000020080000000,
+      0x0000000000400000, 0x0000020000400000, 0x0000000080400000, 0x0000020080400000,
+      0x0000000008000000, 0x0000020008000000, 0x0000000088000000, 0x0000020088000000,
+      0x0000000008400000, 0x0000020008400000, 0x0000000088400000, 0x0000020088400000, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+      0x0000000000000040, 0x0000000000000040, 0x0000000000000040, 0x0000000000000040,
+      0x0000000000001000, 0x0000000000001000, 0x0000000000001000, 0x0000000000001000,
+      0x0000000000001040, 0x0000000000001040, 0x0000000000001040, 0x0000000000001040, ),
+    ( 0x0000000000000000, 0x0000000000000010, 0x0000000000000400, 0x0000000000000410,
+      0x0000000000000080, 0x0000000000000090, 0x0000000000000480, 0x0000000000000490,
+      0x0000000040000000, 0x0000000040000010, 0x0000000040000400, 0x0000000040000410,
+      0x0000000040000080, 0x0000000040000090, 0x0000000040000480, 0x0000000040000490, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+      0x0000000000080000, 0x0000000000080000, 0x0000000000080000, 0x0000000000080000,
+      0x0000000000100000, 0x0000000000100000, 0x0000000000100000, 0x0000000000100000,
+      0x0000000000180000, 0x0000000000180000, 0x0000000000180000, 0x0000000000180000, ),
+    ( 0x0000000000000000, 0x0000000000040000, 0x0000000000000020, 0x0000000000040020,
+      0x0000000000000004, 0x0000000000040004, 0x0000000000000024, 0x0000000000040024,
+      0x0000000200000000, 0x0000000200040000, 0x0000000200000020, 0x0000000200040020,
+      0x0000000200000004, 0x0000000200040004, 0x0000000200000024, 0x0000000200040024, ),
+    ( 0x0000000000000000, 0x0000000000000008, 0x0000000000008000, 0x0000000000008008,
+      0x0010000000000000, 0x0010000000000008, 0x0010000000008000, 0x0010000000008008,
+      0x0020000000000000, 0x0020000000000008, 0x0020000000008000, 0x0020000000008008,
+      0x0030000000000000, 0x0030000000000008, 0x0030000000008000, 0x0030000000008008, ),
+    ( 0x0000000000000000, 0x0000400000000000, 0x0000080000000000, 0x0000480000000000,
+      0x0000100000000000, 0x0000500000000000, 0x0000180000000000, 0x0000580000000000,
+      0x4000000000000000, 0x4000400000000000, 0x4000080000000000, 0x4000480000000000,
+      0x4000100000000000, 0x4000500000000000, 0x4000180000000000, 0x4000580000000000, ),
+    ( 0x0000000000000000, 0x0000000000004000, 0x0000000020000000, 0x0000000020004000,
+      0x0001000000000000, 0x0001000000004000, 0x0001000020000000, 0x0001000020004000,
+      0x0200000000000000, 0x0200000000004000, 0x0200000020000000, 0x0200000020004000,
+      0x0201000000000000, 0x0201000000004000, 0x0201000020000000, 0x0201000020004000, ),
+    ( 0x0000000000000000, 0x1000000000000000, 0x0004000000000000, 0x1004000000000000,
+      0x0002000000000000, 0x1002000000000000, 0x0006000000000000, 0x1006000000000000,
+      0x0000000800000000, 0x1000000800000000, 0x0004000800000000, 0x1004000800000000,
+      0x0002000800000000, 0x1002000800000000, 0x0006000800000000, 0x1006000800000000, ),
+    ( 0x0000000000000000, 0x0040000000000000, 0x2000000000000000, 0x2040000000000000,
+      0x0000008000000000, 0x0040008000000000, 0x2000008000000000, 0x2040008000000000,
+      0x0000001000000000, 0x0040001000000000, 0x2000001000000000, 0x2040001000000000,
+      0x0000009000000000, 0x0040009000000000, 0x2000009000000000, 0x2040009000000000, ),
+    ( 0x0000000000000000, 0x0400000000000000, 0x8000000000000000, 0x8400000000000000,
+      0x0000002000000000, 0x0400002000000000, 0x8000002000000000, 0x8400002000000000,
+      0x0100000000000000, 0x0500000000000000, 0x8100000000000000, 0x8500000000000000,
+      0x0100002000000000, 0x0500002000000000, 0x8100002000000000, 0x8500002000000000, ),
+    ( 0x0000000000000000, 0x0000800000000000, 0x0800000000000000, 0x0800800000000000,
+      0x0000004000000000, 0x0000804000000000, 0x0800004000000000, 0x0800804000000000,
+      0x0000000400000000, 0x0000800400000000, 0x0800000400000000, 0x0800800400000000,
+      0x0000004400000000, 0x0000804400000000, 0x0800004400000000, 0x0800804400000000, ),
+    ( 0x0000000000000000, 0x0080000000000000, 0x0000040000000000, 0x0080040000000000,
+      0x0008000000000000, 0x0088000000000000, 0x0008040000000000, 0x0088040000000000,
+      0x0000200000000000, 0x0080200000000000, 0x0000240000000000, 0x0080240000000000,
+      0x0008200000000000, 0x0088200000000000, 0x0008240000000000, 0x0088240000000000, ),
+        )
+
+    # NOTE: this was reordered from original table to make perm3264 logic simpler
+    PC2ROTB=(
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+      0x0000000000000400, 0x0000000000000400, 0x0000000000000400, 0x0000000000000400,
+      0x0000000000080000, 0x0000000000080000, 0x0000000000080000, 0x0000000000080000,
+      0x0000000000080400, 0x0000000000080400, 0x0000000000080400, 0x0000000000080400, ),
+    ( 0x0000000000000000, 0x0000000000800000, 0x0000000000004000, 0x0000000000804000,
+      0x0000000080000000, 0x0000000080800000, 0x0000000080004000, 0x0000000080804000,
+      0x0000000000040000, 0x0000000000840000, 0x0000000000044000, 0x0000000000844000,
+      0x0000000080040000, 0x0000000080840000, 0x0000000080044000, 0x0000000080844000, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+      0x0000000000000008, 0x0000000000000008, 0x0000000000000008, 0x0000000000000008,
+      0x0000000040000000, 0x0000000040000000, 0x0000000040000000, 0x0000000040000000,
+      0x0000000040000008, 0x0000000040000008, 0x0000000040000008, 0x0000000040000008, ),
+    ( 0x0000000000000000, 0x0000000020000000, 0x0000000200000000, 0x0000000220000000,
+      0x0000000000000080, 0x0000000020000080, 0x0000000200000080, 0x0000000220000080,
+      0x0000000000100000, 0x0000000020100000, 0x0000000200100000, 0x0000000220100000,
+      0x0000000000100080, 0x0000000020100080, 0x0000000200100080, 0x0000000220100080, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+      0x0000000000002000, 0x0000000000002000, 0x0000000000002000, 0x0000000000002000,
+      0x0000020000000000, 0x0000020000000000, 0x0000020000000000, 0x0000020000000000,
+      0x0000020000002000, 0x0000020000002000, 0x0000020000002000, 0x0000020000002000, ),
+    ( 0x0000000000000000, 0x0000000000000800, 0x0000000100000000, 0x0000000100000800,
+      0x0000000010000000, 0x0000000010000800, 0x0000000110000000, 0x0000000110000800,
+      0x0000000000000004, 0x0000000000000804, 0x0000000100000004, 0x0000000100000804,
+      0x0000000010000004, 0x0000000010000804, 0x0000000110000004, 0x0000000110000804, ),
+    ( 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+      0x0000000000001000, 0x0000000000001000, 0x0000000000001000, 0x0000000000001000,
+      0x0000000000000010, 0x0000000000000010, 0x0000000000000010, 0x0000000000000010,
+      0x0000000000001010, 0x0000000000001010, 0x0000000000001010, 0x0000000000001010, ),
+    ( 0x0000000000000000, 0x0000000000000040, 0x0000010000000000, 0x0000010000000040,
+      0x0000000000200000, 0x0000000000200040, 0x0000010000200000, 0x0000010000200040,
+      0x0000000000008000, 0x0000000000008040, 0x0000010000008000, 0x0000010000008040,
+      0x0000000000208000, 0x0000000000208040, 0x0000010000208000, 0x0000010000208040, ),
+    ( 0x0000000000000000, 0x0000000004000000, 0x0000000008000000, 0x000000000c000000,
+      0x0400000000000000, 0x0400000004000000, 0x0400000008000000, 0x040000000c000000,
+      0x8000000000000000, 0x8000000004000000, 0x8000000008000000, 0x800000000c000000,
+      0x8400000000000000, 0x8400000004000000, 0x8400000008000000, 0x840000000c000000, ),
+    ( 0x0000000000000000, 0x0002000000000000, 0x0200000000000000, 0x0202000000000000,
+      0x1000000000000000, 0x1002000000000000, 0x1200000000000000, 0x1202000000000000,
+      0x0008000000000000, 0x000a000000000000, 0x0208000000000000, 0x020a000000000000,
+      0x1008000000000000, 0x100a000000000000, 0x1208000000000000, 0x120a000000000000, ),
+    ( 0x0000000000000000, 0x0000000000400000, 0x0000000000000020, 0x0000000000400020,
+      0x0040000000000000, 0x0040000000400000, 0x0040000000000020, 0x0040000000400020,
+      0x0800000000000000, 0x0800000000400000, 0x0800000000000020, 0x0800000000400020,
+      0x0840000000000000, 0x0840000000400000, 0x0840000000000020, 0x0840000000400020, ),
+    ( 0x0000000000000000, 0x0080000000000000, 0x0000008000000000, 0x0080008000000000,
+      0x2000000000000000, 0x2080000000000000, 0x2000008000000000, 0x2080008000000000,
+      0x0020000000000000, 0x00a0000000000000, 0x0020008000000000, 0x00a0008000000000,
+      0x2020000000000000, 0x20a0000000000000, 0x2020008000000000, 0x20a0008000000000, ),
+    ( 0x0000000000000000, 0x0000002000000000, 0x0000040000000000, 0x0000042000000000,
+      0x4000000000000000, 0x4000002000000000, 0x4000040000000000, 0x4000042000000000,
+      0x0000400000000000, 0x0000402000000000, 0x0000440000000000, 0x0000442000000000,
+      0x4000400000000000, 0x4000402000000000, 0x4000440000000000, 0x4000442000000000, ),
+    ( 0x0000000000000000, 0x0000004000000000, 0x0000200000000000, 0x0000204000000000,
+      0x0000080000000000, 0x0000084000000000, 0x0000280000000000, 0x0000284000000000,
+      0x0000800000000000, 0x0000804000000000, 0x0000a00000000000, 0x0000a04000000000,
+      0x0000880000000000, 0x0000884000000000, 0x0000a80000000000, 0x0000a84000000000, ),
+    ( 0x0000000000000000, 0x0000000800000000, 0x0000000400000000, 0x0000000c00000000,
+      0x0000100000000000, 0x0000100800000000, 0x0000100400000000, 0x0000100c00000000,
+      0x0010000000000000, 0x0010000800000000, 0x0010000400000000, 0x0010000c00000000,
+      0x0010100000000000, 0x0010100800000000, 0x0010100400000000, 0x0010100c00000000, ),
+    ( 0x0000000000000000, 0x0100000000000000, 0x0001000000000000, 0x0101000000000000,
+      0x0000001000000000, 0x0100001000000000, 0x0001001000000000, 0x0101001000000000,
+      0x0004000000000000, 0x0104000000000000, 0x0005000000000000, 0x0105000000000000,
+      0x0004001000000000, 0x0104001000000000, 0x0005001000000000, 0x0105001000000000, ),
+        )
+    #---------------------------------------------------------------
+    # PCXROT - PC1ROT, PC2ROTA, PC2ROTB listed in order
+    # of the PC1 rotation schedule, as used by des_setkey
+    #---------------------------------------------------------------
+    ##ROTATES = (1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1)
+    ##PCXROT = (
+    ##        PC1ROT,  PC2ROTA, PC2ROTB, PC2ROTB,
+    ##        PC2ROTB, PC2ROTB, PC2ROTB, PC2ROTB,
+    ##        PC2ROTA, PC2ROTB, PC2ROTB, PC2ROTB,
+    ##        PC2ROTB, PC2ROTB, PC2ROTB, PC2ROTA,
+    ##        )
+
+    # NOTE: modified PCXROT to contain entrys broken into pairs,
+    #       to help generate them in format best used by encoder.
+    PCXROT = (
+            (PC1ROT,  PC2ROTA), (PC2ROTB, PC2ROTB),
+            (PC2ROTB, PC2ROTB), (PC2ROTB, PC2ROTB),
+            (PC2ROTA, PC2ROTB), (PC2ROTB, PC2ROTB),
+            (PC2ROTB, PC2ROTB), (PC2ROTB, PC2ROTA),
+            )
+
+    #---------------------------------------------------------------
+    # Bit reverse, intial permupation, expantion
+    # Initial permutation/expansion table
+    #---------------------------------------------------------------
+    # NOTE: this was reordered from original table to make perm3264 logic simpler
+    IE3264=(
+    ( 0x0000000000000000, 0x0000000000800800, 0x0000000000008008, 0x0000000000808808,
+      0x0000008008000000, 0x0000008008800800, 0x0000008008008008, 0x0000008008808808,
+      0x0000000080080000, 0x0000000080880800, 0x0000000080088008, 0x0000000080888808,
+      0x0000008088080000, 0x0000008088880800, 0x0000008088088008, 0x0000008088888808, ),
+    ( 0x0000000000000000, 0x0080080000000000, 0x0000800800000000, 0x0080880800000000,
+      0x0800000000000080, 0x0880080000000080, 0x0800800800000080, 0x0880880800000080,
+      0x8008000000000000, 0x8088080000000000, 0x8008800800000000, 0x8088880800000000,
+      0x8808000000000080, 0x8888080000000080, 0x8808800800000080, 0x8888880800000080, ),
+    ( 0x0000000000000000, 0x0000000000001000, 0x0000000000000010, 0x0000000000001010,
+      0x0000000010000000, 0x0000000010001000, 0x0000000010000010, 0x0000000010001010,
+      0x0000000000100000, 0x0000000000101000, 0x0000000000100010, 0x0000000000101010,
+      0x0000000010100000, 0x0000000010101000, 0x0000000010100010, 0x0000000010101010, ),
+    ( 0x0000000000000000, 0x0000100000000000, 0x0000001000000000, 0x0000101000000000,
+      0x1000000000000000, 0x1000100000000000, 0x1000001000000000, 0x1000101000000000,
+      0x0010000000000000, 0x0010100000000000, 0x0010001000000000, 0x0010101000000000,
+      0x1010000000000000, 0x1010100000000000, 0x1010001000000000, 0x1010101000000000, ),
+    ( 0x0000000000000000, 0x0000000000002000, 0x0000000000000020, 0x0000000000002020,
+      0x0000000020000000, 0x0000000020002000, 0x0000000020000020, 0x0000000020002020,
+      0x0000000000200000, 0x0000000000202000, 0x0000000000200020, 0x0000000000202020,
+      0x0000000020200000, 0x0000000020202000, 0x0000000020200020, 0x0000000020202020, ),
+    ( 0x0000000000000000, 0x0000200000000000, 0x0000002000000000, 0x0000202000000000,
+      0x2000000000000000, 0x2000200000000000, 0x2000002000000000, 0x2000202000000000,
+      0x0020000000000000, 0x0020200000000000, 0x0020002000000000, 0x0020202000000000,
+      0x2020000000000000, 0x2020200000000000, 0x2020002000000000, 0x2020202000000000, ),
+    ( 0x0000000000000000, 0x0000000000004004, 0x0400000000000040, 0x0400000000004044,
+      0x0000000040040000, 0x0000000040044004, 0x0400000040040040, 0x0400000040044044,
+      0x0000000000400400, 0x0000000000404404, 0x0400000000400440, 0x0400000000404444,
+      0x0000000040440400, 0x0000000040444404, 0x0400000040440440, 0x0400000040444444, ),
+    ( 0x0000000000000000, 0x0000400400000000, 0x0000004004000000, 0x0000404404000000,
+      0x4004000000000000, 0x4004400400000000, 0x4004004004000000, 0x4004404404000000,
+      0x0040040000000000, 0x0040440400000000, 0x0040044004000000, 0x0040444404000000,
+      0x4044040000000000, 0x4044440400000000, 0x4044044004000000, 0x4044444404000000, ),
+        )
+
+    #---------------------------------------------------------------
+    # Table that combines the S, P, and E operations.
+    #---------------------------------------------------------------
+    SPE=(
+    ( 0x0080088008200000, 0x0000008008000000, 0x0000000000200020, 0x0080088008200020,
+      0x0000000000200000, 0x0080088008000020, 0x0000008008000020, 0x0000000000200020,
+      0x0080088008000020, 0x0080088008200000, 0x0000008008200000, 0x0080080000000020,
+      0x0080080000200020, 0x0000000000200000, 0x0000000000000000, 0x0000008008000020,
+      0x0000008008000000, 0x0000000000000020, 0x0080080000200000, 0x0080088008000000,
+      0x0080088008200020, 0x0000008008200000, 0x0080080000000020, 0x0080080000200000,
+      0x0000000000000020, 0x0080080000000000, 0x0080088008000000, 0x0000008008200020,
+      0x0080080000000000, 0x0080080000200020, 0x0000008008200020, 0x0000000000000000,
+      0x0000000000000000, 0x0080088008200020, 0x0080080000200000, 0x0000008008000020,
+      0x0080088008200000, 0x0000008008000000, 0x0080080000000020, 0x0080080000200000,
+      0x0000008008200020, 0x0080080000000000, 0x0080088008000000, 0x0000000000200020,
+      0x0080088008000020, 0x0000000000000020, 0x0000000000200020, 0x0000008008200000,
+      0x0080088008200020, 0x0080088008000000, 0x0000008008200000, 0x0080080000200020,
+      0x0000000000200000, 0x0080080000000020, 0x0000008008000020, 0x0000000000000000,
+      0x0000008008000000, 0x0000000000200000, 0x0080080000200020, 0x0080088008200000,
+      0x0000000000000020, 0x0000008008200020, 0x0080080000000000, 0x0080088008000020, ),
+    ( 0x1000800810004004, 0x0000000000000000, 0x0000800810000000, 0x0000000010004004,
+      0x1000000000004004, 0x1000800800000000, 0x0000800800004004, 0x0000800810000000,
+      0x0000800800000000, 0x1000000010004004, 0x1000000000000000, 0x0000800800004004,
+      0x1000000010000000, 0x0000800810004004, 0x0000000010004004, 0x1000000000000000,
+      0x0000000010000000, 0x1000800800004004, 0x1000000010004004, 0x0000800800000000,
+      0x1000800810000000, 0x0000000000004004, 0x0000000000000000, 0x1000000010000000,
+      0x1000800800004004, 0x1000800810000000, 0x0000800810004004, 0x1000000000004004,
+      0x0000000000004004, 0x0000000010000000, 0x1000800800000000, 0x1000800810004004,
+      0x1000000010000000, 0x0000800810004004, 0x0000800800004004, 0x1000800810000000,
+      0x1000800810004004, 0x1000000010000000, 0x1000000000004004, 0x0000000000000000,
+      0x0000000000004004, 0x1000800800000000, 0x0000000010000000, 0x1000000010004004,
+      0x0000800800000000, 0x0000000000004004, 0x1000800810000000, 0x1000800800004004,
+      0x0000800810004004, 0x0000800800000000, 0x0000000000000000, 0x1000000000004004,
+      0x1000000000000000, 0x1000800810004004, 0x0000800810000000, 0x0000000010004004,
+      0x1000000010004004, 0x0000000010000000, 0x1000800800000000, 0x0000800800004004,
+      0x1000800800004004, 0x1000000000000000, 0x0000000010004004, 0x0000800810000000, ),
+    ( 0x0000000000400410, 0x0010004004400400, 0x0010000000000000, 0x0010000000400410,
+      0x0000004004000010, 0x0000000000400400, 0x0010000000400410, 0x0010004004000000,
+      0x0010000000400400, 0x0000004004000000, 0x0000004004400400, 0x0000000000000010,
+      0x0010004004400410, 0x0010000000000010, 0x0000000000000010, 0x0000004004400410,
+      0x0000000000000000, 0x0000004004000010, 0x0010004004400400, 0x0010000000000000,
+      0x0010000000000010, 0x0010004004400410, 0x0000004004000000, 0x0000000000400410,
+      0x0000004004400410, 0x0010000000400400, 0x0010004004000010, 0x0000004004400400,
+      0x0010004004000000, 0x0000000000000000, 0x0000000000400400, 0x0010004004000010,
+      0x0010004004400400, 0x0010000000000000, 0x0000000000000010, 0x0000004004000000,
+      0x0010000000000010, 0x0000004004000010, 0x0000004004400400, 0x0010000000400410,
+      0x0000000000000000, 0x0010004004400400, 0x0010004004000000, 0x0000004004400410,
+      0x0000004004000010, 0x0000000000400400, 0x0010004004400410, 0x0000000000000010,
+      0x0010004004000010, 0x0000000000400410, 0x0000000000400400, 0x0010004004400410,
+      0x0000004004000000, 0x0010000000400400, 0x0010000000400410, 0x0010004004000000,
+      0x0010000000400400, 0x0000000000000000, 0x0000004004400410, 0x0010000000000010,
+      0x0000000000400410, 0x0010004004000010, 0x0010000000000000, 0x0000004004400400, ),
+    ( 0x0800100040040080, 0x0000100000001000, 0x0800000000000080, 0x0800100040041080,
+      0x0000000000000000, 0x0000000040041000, 0x0800100000001080, 0x0800000040040080,
+      0x0000100040041000, 0x0800000000001080, 0x0000000000001000, 0x0800100000000080,
+      0x0800000000001080, 0x0800100040040080, 0x0000000040040000, 0x0000000000001000,
+      0x0800000040041080, 0x0000100040040000, 0x0000100000000000, 0x0800000000000080,
+      0x0000100040040000, 0x0800100000001080, 0x0000000040041000, 0x0000100000000000,
+      0x0800100000000080, 0x0000000000000000, 0x0800000040040080, 0x0000100040041000,
+      0x0000100000001000, 0x0800000040041080, 0x0800100040041080, 0x0000000040040000,
+      0x0800000040041080, 0x0800100000000080, 0x0000000040040000, 0x0800000000001080,
+      0x0000100040040000, 0x0000100000001000, 0x0800000000000080, 0x0000000040041000,
+      0x0800100000001080, 0x0000000000000000, 0x0000100000000000, 0x0800000040040080,
+      0x0000000000000000, 0x0800000040041080, 0x0000100040041000, 0x0000100000000000,
+      0x0000000000001000, 0x0800100040041080, 0x0800100040040080, 0x0000000040040000,
+      0x0800100040041080, 0x0800000000000080, 0x0000100000001000, 0x0800100040040080,
+      0x0800000040040080, 0x0000100040040000, 0x0000000040041000, 0x0800100000001080,
+      0x0800100000000080, 0x0000000000001000, 0x0800000000001080, 0x0000100040041000, ),
+    ( 0x0000000000800800, 0x0000001000000000, 0x0040040000000000, 0x2040041000800800,
+      0x2000001000800800, 0x0040040000800800, 0x2040041000000000, 0x0000001000800800,
+      0x0000001000000000, 0x2000000000000000, 0x2000000000800800, 0x0040041000000000,
+      0x2040040000800800, 0x2000001000800800, 0x0040041000800800, 0x0000000000000000,
+      0x0040041000000000, 0x0000000000800800, 0x2000001000000000, 0x2040040000000000,
+      0x0040040000800800, 0x2040041000000000, 0x0000000000000000, 0x2000000000800800,
+      0x2000000000000000, 0x2040040000800800, 0x2040041000800800, 0x2000001000000000,
+      0x0000001000800800, 0x0040040000000000, 0x2040040000000000, 0x0040041000800800,
+      0x0040041000800800, 0x2040040000800800, 0x2000001000000000, 0x0000001000800800,
+      0x0000001000000000, 0x2000000000000000, 0x2000000000800800, 0x0040040000800800,
+      0x0000000000800800, 0x0040041000000000, 0x2040041000800800, 0x0000000000000000,
+      0x2040041000000000, 0x0000000000800800, 0x0040040000000000, 0x2000001000000000,
+      0x2040040000800800, 0x0040040000000000, 0x0000000000000000, 0x2040041000800800,
+      0x2000001000800800, 0x0040041000800800, 0x2040040000000000, 0x0000001000000000,
+      0x0040041000000000, 0x2000001000800800, 0x0040040000800800, 0x2040040000000000,
+      0x2000000000000000, 0x2040041000000000, 0x0000001000800800, 0x2000000000800800, ),
+    ( 0x4004000000008008, 0x4004000020000000, 0x0000000000000000, 0x0000200020008008,
+      0x4004000020000000, 0x0000200000000000, 0x4004200000008008, 0x0000000020000000,
+      0x4004200000000000, 0x4004200020008008, 0x0000200020000000, 0x0000000000008008,
+      0x0000200000008008, 0x4004000000008008, 0x0000000020008008, 0x4004200020000000,
+      0x0000000020000000, 0x4004200000008008, 0x4004000020008008, 0x0000000000000000,
+      0x0000200000000000, 0x4004000000000000, 0x0000200020008008, 0x4004000020008008,
+      0x4004200020008008, 0x0000000020008008, 0x0000000000008008, 0x4004200000000000,
+      0x4004000000000000, 0x0000200020000000, 0x4004200020000000, 0x0000200000008008,
+      0x4004200000000000, 0x0000000000008008, 0x0000200000008008, 0x4004200020000000,
+      0x0000200020008008, 0x4004000020000000, 0x0000000000000000, 0x0000200000008008,
+      0x0000000000008008, 0x0000200000000000, 0x4004000020008008, 0x0000000020000000,
+      0x4004000020000000, 0x4004200020008008, 0x0000200020000000, 0x4004000000000000,
+      0x4004200020008008, 0x0000200020000000, 0x0000000020000000, 0x4004200000008008,
+      0x4004000000008008, 0x0000000020008008, 0x4004200020000000, 0x0000000000000000,
+      0x0000200000000000, 0x4004000000008008, 0x4004200000008008, 0x0000200020008008,
+      0x0000000020008008, 0x4004200000000000, 0x4004000000000000, 0x4004000020008008, ),
+    ( 0x0000400400000000, 0x0020000000000000, 0x0020000000100000, 0x0400000000100040,
+      0x0420400400100040, 0x0400400400000040, 0x0020400400000000, 0x0000000000000000,
+      0x0000000000100000, 0x0420000000100040, 0x0420000000000040, 0x0000400400100000,
+      0x0400000000000040, 0x0020400400100000, 0x0000400400100000, 0x0420000000000040,
+      0x0420000000100040, 0x0000400400000000, 0x0400400400000040, 0x0420400400100040,
+      0x0000000000000000, 0x0020000000100000, 0x0400000000100040, 0x0020400400000000,
+      0x0400400400100040, 0x0420400400000040, 0x0020400400100000, 0x0400000000000040,
+      0x0420400400000040, 0x0400400400100040, 0x0020000000000000, 0x0000000000100000,
+      0x0420400400000040, 0x0000400400100000, 0x0400400400100040, 0x0420000000000040,
+      0x0000400400000000, 0x0020000000000000, 0x0000000000100000, 0x0400400400100040,
+      0x0420000000100040, 0x0420400400000040, 0x0020400400000000, 0x0000000000000000,
+      0x0020000000000000, 0x0400000000100040, 0x0400000000000040, 0x0020000000100000,
+      0x0000000000000000, 0x0420000000100040, 0x0020000000100000, 0x0020400400000000,
+      0x0420000000000040, 0x0000400400000000, 0x0420400400100040, 0x0000000000100000,
+      0x0020400400100000, 0x0400000000000040, 0x0400400400000040, 0x0420400400100040,
+      0x0400000000100040, 0x0020400400100000, 0x0000400400100000, 0x0400400400000040, ),
+    ( 0x8008000080082000, 0x0000002080082000, 0x8008002000000000, 0x0000000000000000,
+      0x0000002000002000, 0x8008000080080000, 0x0000000080082000, 0x8008002080082000,
+      0x8008000000000000, 0x0000000000002000, 0x0000002080080000, 0x8008002000000000,
+      0x8008002080080000, 0x8008002000002000, 0x8008000000002000, 0x0000000080082000,
+      0x0000002000000000, 0x8008002080080000, 0x8008000080080000, 0x0000002000002000,
+      0x8008002080082000, 0x8008000000002000, 0x0000000000000000, 0x0000002080080000,
+      0x0000000000002000, 0x0000000080080000, 0x8008002000002000, 0x8008000080082000,
+      0x0000000080080000, 0x0000002000000000, 0x0000002080082000, 0x8008000000000000,
+      0x0000000080080000, 0x0000002000000000, 0x8008000000002000, 0x8008002080082000,
+      0x8008002000000000, 0x0000000000002000, 0x0000000000000000, 0x0000002080080000,
+      0x8008000080082000, 0x8008002000002000, 0x0000002000002000, 0x8008000080080000,
+      0x0000002080082000, 0x8008000000000000, 0x8008000080080000, 0x0000002000002000,
+      0x8008002080082000, 0x0000000080080000, 0x0000000080082000, 0x8008000000002000,
+      0x0000002080080000, 0x8008002000000000, 0x8008002000002000, 0x0000000080082000,
+      0x8008000000000000, 0x0000002080082000, 0x8008002080080000, 0x0000000000000000,
+      0x0000000000002000, 0x8008000080082000, 0x0000002000000000, 0x8008002080080000, ),
+        )
+
+    #---------------------------------------------------------------
+    # compressed/interleaved => final permutation table
+    # Compression, final permutation, bit reverse
+    #---------------------------------------------------------------
+    # NOTE: this was reordered from original table to make perm6464 logic simpler
+    CF6464=(
+    ( 0x0000000000000000, 0x0000002000000000, 0x0000200000000000, 0x0000202000000000,
+      0x0020000000000000, 0x0020002000000000, 0x0020200000000000, 0x0020202000000000,
+      0x2000000000000000, 0x2000002000000000, 0x2000200000000000, 0x2000202000000000,
+      0x2020000000000000, 0x2020002000000000, 0x2020200000000000, 0x2020202000000000, ),
+    ( 0x0000000000000000, 0x0000000200000000, 0x0000020000000000, 0x0000020200000000,
+      0x0002000000000000, 0x0002000200000000, 0x0002020000000000, 0x0002020200000000,
+      0x0200000000000000, 0x0200000200000000, 0x0200020000000000, 0x0200020200000000,
+      0x0202000000000000, 0x0202000200000000, 0x0202020000000000, 0x0202020200000000, ),
+    ( 0x0000000000000000, 0x0000000000000020, 0x0000000000002000, 0x0000000000002020,
+      0x0000000000200000, 0x0000000000200020, 0x0000000000202000, 0x0000000000202020,
+      0x0000000020000000, 0x0000000020000020, 0x0000000020002000, 0x0000000020002020,
+      0x0000000020200000, 0x0000000020200020, 0x0000000020202000, 0x0000000020202020, ),
+    ( 0x0000000000000000, 0x0000000000000002, 0x0000000000000200, 0x0000000000000202,
+      0x0000000000020000, 0x0000000000020002, 0x0000000000020200, 0x0000000000020202,
+      0x0000000002000000, 0x0000000002000002, 0x0000000002000200, 0x0000000002000202,
+      0x0000000002020000, 0x0000000002020002, 0x0000000002020200, 0x0000000002020202, ),
+    ( 0x0000000000000000, 0x0000008000000000, 0x0000800000000000, 0x0000808000000000,
+      0x0080000000000000, 0x0080008000000000, 0x0080800000000000, 0x0080808000000000,
+      0x8000000000000000, 0x8000008000000000, 0x8000800000000000, 0x8000808000000000,
+      0x8080000000000000, 0x8080008000000000, 0x8080800000000000, 0x8080808000000000, ),
+    ( 0x0000000000000000, 0x0000000800000000, 0x0000080000000000, 0x0000080800000000,
+      0x0008000000000000, 0x0008000800000000, 0x0008080000000000, 0x0008080800000000,
+      0x0800000000000000, 0x0800000800000000, 0x0800080000000000, 0x0800080800000000,
+      0x0808000000000000, 0x0808000800000000, 0x0808080000000000, 0x0808080800000000, ),
+    ( 0x0000000000000000, 0x0000000000000080, 0x0000000000008000, 0x0000000000008080,
+      0x0000000000800000, 0x0000000000800080, 0x0000000000808000, 0x0000000000808080,
+      0x0000000080000000, 0x0000000080000080, 0x0000000080008000, 0x0000000080008080,
+      0x0000000080800000, 0x0000000080800080, 0x0000000080808000, 0x0000000080808080, ),
+    ( 0x0000000000000000, 0x0000000000000008, 0x0000000000000800, 0x0000000000000808,
+      0x0000000000080000, 0x0000000000080008, 0x0000000000080800, 0x0000000000080808,
+      0x0000000008000000, 0x0000000008000008, 0x0000000008000800, 0x0000000008000808,
+      0x0000000008080000, 0x0000000008080008, 0x0000000008080800, 0x0000000008080808, ),
+    ( 0x0000000000000000, 0x0000001000000000, 0x0000100000000000, 0x0000101000000000,
+      0x0010000000000000, 0x0010001000000000, 0x0010100000000000, 0x0010101000000000,
+      0x1000000000000000, 0x1000001000000000, 0x1000100000000000, 0x1000101000000000,
+      0x1010000000000000, 0x1010001000000000, 0x1010100000000000, 0x1010101000000000, ),
+    ( 0x0000000000000000, 0x0000000100000000, 0x0000010000000000, 0x0000010100000000,
+      0x0001000000000000, 0x0001000100000000, 0x0001010000000000, 0x0001010100000000,
+      0x0100000000000000, 0x0100000100000000, 0x0100010000000000, 0x0100010100000000,
+      0x0101000000000000, 0x0101000100000000, 0x0101010000000000, 0x0101010100000000, ),
+    ( 0x0000000000000000, 0x0000000000000010, 0x0000000000001000, 0x0000000000001010,
+      0x0000000000100000, 0x0000000000100010, 0x0000000000101000, 0x0000000000101010,
+      0x0000000010000000, 0x0000000010000010, 0x0000000010001000, 0x0000000010001010,
+      0x0000000010100000, 0x0000000010100010, 0x0000000010101000, 0x0000000010101010, ),
+    ( 0x0000000000000000, 0x0000000000000001, 0x0000000000000100, 0x0000000000000101,
+      0x0000000000010000, 0x0000000000010001, 0x0000000000010100, 0x0000000000010101,
+      0x0000000001000000, 0x0000000001000001, 0x0000000001000100, 0x0000000001000101,
+      0x0000000001010000, 0x0000000001010001, 0x0000000001010100, 0x0000000001010101, ),
+    ( 0x0000000000000000, 0x0000004000000000, 0x0000400000000000, 0x0000404000000000,
+      0x0040000000000000, 0x0040004000000000, 0x0040400000000000, 0x0040404000000000,
+      0x4000000000000000, 0x4000004000000000, 0x4000400000000000, 0x4000404000000000,
+      0x4040000000000000, 0x4040004000000000, 0x4040400000000000, 0x4040404000000000, ),
+    ( 0x0000000000000000, 0x0000000400000000, 0x0000040000000000, 0x0000040400000000,
+      0x0004000000000000, 0x0004000400000000, 0x0004040000000000, 0x0004040400000000,
+      0x0400000000000000, 0x0400000400000000, 0x0400040000000000, 0x0400040400000000,
+      0x0404000000000000, 0x0404000400000000, 0x0404040000000000, 0x0404040400000000, ),
+    ( 0x0000000000000000, 0x0000000000000040, 0x0000000000004000, 0x0000000000004040,
+      0x0000000000400000, 0x0000000000400040, 0x0000000000404000, 0x0000000000404040,
+      0x0000000040000000, 0x0000000040000040, 0x0000000040004000, 0x0000000040004040,
+      0x0000000040400000, 0x0000000040400040, 0x0000000040404000, 0x0000000040404040, ),
+    ( 0x0000000000000000, 0x0000000000000004, 0x0000000000000400, 0x0000000000000404,
+      0x0000000000040000, 0x0000000000040004, 0x0000000000040400, 0x0000000000040404,
+      0x0000000004000000, 0x0000000004000004, 0x0000000004000400, 0x0000000004000404,
+      0x0000000004040000, 0x0000000004040004, 0x0000000004040400, 0x0000000004040404, ),
+    )
+    #===================================================================
+    # eof _load_tables()
+    #===================================================================
+
+#=============================================================================
+# support
+#=============================================================================
+
+def _permute(c, p):
+    """Returns the permutation of the given 32-bit or 64-bit code with
+    the specified permutation table."""
+    # NOTE: only difference between 32 & 64 bit permutations
+    #       is that len(p)==8 for 32 bit, and len(p)==16 for 64 bit.
+    out = 0
+    for r in p:
+        out |= r[c&0xf]
+        c >>= 4
+    return out
+
+#=============================================================================
+# packing & unpacking
+#=============================================================================
+# FIXME: more properly named _uint8_struct...
+_uint64_struct = struct.Struct(">Q")
+
+def _pack64(value):
+    return _uint64_struct.pack(value)
+
+def _unpack64(value):
+    return _uint64_struct.unpack(value)[0]
+
+def _pack56(value):
+    return _uint64_struct.pack(value)[1:]
+
+def _unpack56(value):
+    return _uint64_struct.unpack(b'\x00' + value)[0]
+
+#=============================================================================
+# 56->64 key manipulation
+#=============================================================================
+
+##def expand_7bit(value):
+##    "expand 7-bit integer => 7-bits + 1 odd-parity bit"
+##    # parity calc adapted from 32-bit even parity alg found at
+##    # http://graphics.stanford.edu/~seander/bithacks.html#ParityParallel
+##    assert 0 <= value < 0x80, "value out of range"
+##    return (value<<1) | (0x9669 >> ((value ^ (value >> 4)) & 0xf)) & 1
+
+_EXPAND_ITER = irange(49,-7,-7)
+
+def expand_des_key(key):
+    """convert DES from 7 bytes to 8 bytes (by inserting empty parity bits)"""
+    if isinstance(key, bytes):
+        if len(key) != 7:
+            raise ValueError("key must be 7 bytes in size")
+    elif isinstance(key, int_types):
+        if key < 0 or key > INT_56_MASK:
+            raise ValueError("key must be 56-bit non-negative integer")
+        return _unpack64(expand_des_key(_pack56(key)))
+    else:
+        raise exc.ExpectedTypeError(key, "bytes or int", "key")
+    key = _unpack56(key)
+    # NOTE: the following would insert correctly-valued parity bits in each key,
+    # but the parity bit would just be ignored in des_encrypt_block(),
+    # so not bothering to use it.
+    # XXX: could make parity-restoring optionally available via flag
+    ##return join_byte_values(expand_7bit((key >> shift) & 0x7f)
+    ##                        for shift in _EXPAND_ITER)
+    return join_byte_values(((key>>shift) & 0x7f)<<1 for shift in _EXPAND_ITER)
+
+def shrink_des_key(key):
+    """convert DES key from 8 bytes to 7 bytes (by discarding the parity bits)"""
+    if isinstance(key, bytes):
+        if len(key) != 8:
+            raise ValueError("key must be 8 bytes in size")
+        return _pack56(shrink_des_key(_unpack64(key)))
+    elif isinstance(key, int_types):
+        if key < 0 or key > INT_64_MASK:
+            raise ValueError("key must be 64-bit non-negative integer")
+    else:
+        raise exc.ExpectedTypeError(key, "bytes or int", "key")
+    key >>= 1
+    result = 0
+    offset = 0
+    while offset < 56:
+        result |= (key & 0x7f)<<offset
+        key >>= 8
+        offset += 7
+    assert not (result & ~INT_64_MASK)
+    return result
+
+#=============================================================================
+# des encryption
+#=============================================================================
+def des_encrypt_block(key, input, salt=0, rounds=1):
+    """encrypt single block of data using DES, operates on 8-byte strings.
+
+    :arg key:
+        DES key as 7 byte string, or 8 byte string with parity bits
+        (parity bit values are ignored).
+
+    :arg input:
+        plaintext block to encrypt, as 8 byte string.
+
+    :arg salt:
+        Optional 24-bit integer used to mutate the base DES algorithm in a
+        manner specific to :class:`~passlib.hash.des_crypt` and its variants.
+        The default value ``0`` provides the normal (unsalted) DES behavior.
+        The salt functions as follows:
+        if the ``i``'th bit of ``salt`` is set,
+        bits ``i`` and ``i+24`` are swapped in the DES E-box output.
+
+    :arg rounds:
+        Optional number of rounds of to apply the DES key schedule.
+        the default (``rounds=1``) provides the normal DES behavior,
+        but :class:`~passlib.hash.des_crypt` and its variants use
+        alternate rounds values.
+
+    :raises TypeError: if any of the provided args are of the wrong type.
+    :raises ValueError:
+        if any of the input blocks are the wrong size,
+        or the salt/rounds values are out of range.
+
+    :returns:
+        resulting 8-byte ciphertext block.
+    """
+    # validate & unpack key
+    if isinstance(key, bytes):
+        if len(key) == 7:
+            key = expand_des_key(key)
+        elif len(key) != 8:
+            raise ValueError("key must be 7 or 8 bytes")
+        key = _unpack64(key)
+    else:
+        raise exc.ExpectedTypeError(key, "bytes", "key")
+
+    # validate & unpack input
+    if isinstance(input, bytes):
+        if len(input) != 8:
+            raise ValueError("input block must be 8 bytes")
+        input = _unpack64(input)
+    else:
+        raise exc.ExpectedTypeError(input, "bytes", "input")
+
+    # hand things off to other func
+    result = des_encrypt_int_block(key, input, salt, rounds)
+
+    # repack result
+    return _pack64(result)
+
+def des_encrypt_int_block(key, input, salt=0, rounds=1):
+    """encrypt single block of data using DES, operates on 64-bit integers.
+
+    this function is essentially the same as :func:`des_encrypt_block`,
+    except that it operates on integers, and will NOT automatically
+    expand 56-bit keys if provided (since there's no way to detect them).
+
+    :arg key:
+        DES key as 64-bit integer (the parity bits are ignored).
+
+    :arg input:
+        input block as 64-bit integer
+
+    :arg salt:
+        optional 24-bit integer used to mutate the base DES algorithm.
+        defaults to ``0`` (no mutation applied).
+
+    :arg rounds:
+        optional number of rounds of to apply the DES key schedule.
+        defaults to ``1``.
+
+    :raises TypeError: if any of the provided args are of the wrong type.
+    :raises ValueError:
+        if any of the input blocks are the wrong size,
+        or the salt/rounds values are out of range.
+
+    :returns:
+        resulting ciphertext as 64-bit integer.
+    """
+    #---------------------------------------------------------------
+    # input validation
+    #---------------------------------------------------------------
+
+    # validate salt, rounds
+    if rounds < 1:
+        raise ValueError("rounds must be positive integer")
+    if salt < 0 or salt > INT_24_MASK:
+        raise ValueError("salt must be 24-bit non-negative integer")
+
+    # validate & unpack key
+    if not isinstance(key, int_types):
+        raise exc.ExpectedTypeError(key, "int", "key")
+    elif key < 0 or key > INT_64_MASK:
+        raise ValueError("key must be 64-bit non-negative integer")
+
+    # validate & unpack input
+    if not isinstance(input, int_types):
+        raise exc.ExpectedTypeError(input, "int", "input")
+    elif input < 0 or input > INT_64_MASK:
+        raise ValueError("input must be 64-bit non-negative integer")
+
+    #---------------------------------------------------------------
+    # DES setup
+    #---------------------------------------------------------------
+    # load tables if not already done
+    global SPE, PCXROT, IE3264, CF6464
+    if PCXROT is None:
+        _load_tables()
+
+    # load SPE into local vars to speed things up and remove an array access call
+    SPE0, SPE1, SPE2, SPE3, SPE4, SPE5, SPE6, SPE7 = SPE
+
+    # NOTE: parity bits are ignored completely
+    # (UTs do fuzz testing to ensure this)
+
+    # generate key schedule
+    # NOTE: generation was modified to output two elements at a time,
+    # so that per-round loop could do two passes at once.
+    def _iter_key_schedule(ks_odd):
+        """given 64-bit key, iterates over the 8 (even,odd) key schedule pairs"""
+        for p_even, p_odd in PCXROT:
+            ks_even = _permute(ks_odd, p_even)
+            ks_odd = _permute(ks_even, p_odd)
+            yield ks_even & _KS_MASK, ks_odd & _KS_MASK
+    ks_list = list(_iter_key_schedule(key))
+
+    # expand 24 bit salt -> 32 bit per des_crypt & bsdi_crypt
+    salt = (
+        ((salt & 0x00003f) << 26) |
+        ((salt & 0x000fc0) << 12) |
+        ((salt & 0x03f000) >> 2) |
+        ((salt & 0xfc0000) >> 16)
+        )
+
+    # init L & R
+    if input == 0:
+        L = R = 0
+    else:
+        L = ((input >> 31) & 0xaaaaaaaa) | (input & 0x55555555)
+        L = _permute(L, IE3264)
+
+        R = ((input >> 32) & 0xaaaaaaaa) | ((input >> 1) & 0x55555555)
+        R = _permute(R, IE3264)
+
+    #---------------------------------------------------------------
+    # main DES loop - run for specified number of rounds
+    #---------------------------------------------------------------
+    while rounds:
+        rounds -= 1
+
+        # run over each part of the schedule, 2 parts at a time
+        for ks_even, ks_odd in ks_list:
+            k = ((R>>32) ^ R) & salt # use the salt to flip specific bits
+            B = (k<<32) ^ k ^ R ^ ks_even
+
+            L ^= (SPE0[(B>>58)&0x3f] ^ SPE1[(B>>50)&0x3f] ^
+                  SPE2[(B>>42)&0x3f] ^ SPE3[(B>>34)&0x3f] ^
+                  SPE4[(B>>26)&0x3f] ^ SPE5[(B>>18)&0x3f] ^
+                  SPE6[(B>>10)&0x3f] ^ SPE7[(B>>2)&0x3f])
+
+            k = ((L>>32) ^ L) & salt # use the salt to flip specific bits
+            B = (k<<32) ^ k ^ L ^ ks_odd
+
+            R ^= (SPE0[(B>>58)&0x3f] ^ SPE1[(B>>50)&0x3f] ^
+                  SPE2[(B>>42)&0x3f] ^ SPE3[(B>>34)&0x3f] ^
+                  SPE4[(B>>26)&0x3f] ^ SPE5[(B>>18)&0x3f] ^
+                  SPE6[(B>>10)&0x3f] ^ SPE7[(B>>2)&0x3f])
+
+        # swap L and R
+        L, R = R, L
+
+    #---------------------------------------------------------------
+    # return final result
+    #---------------------------------------------------------------
+    C = (
+            ((L>>3) &  0x0f0f0f0f00000000)
+            |
+            ((L<<33) & 0xf0f0f0f000000000)
+            |
+            ((R>>35) & 0x000000000f0f0f0f)
+            |
+            ((R<<1) &  0x00000000f0f0f0f0)
+        )
+    return _permute(C, CF6464)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/digest.py b/myenv/lib/python3.9/site-packages/passlib/crypto/digest.py
new file mode 100644
index 0000000..90e0cad
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/digest.py
@@ -0,0 +1,1057 @@
+"""passlib.crypto.digest -- crytographic helpers used by the password hashes in passlib
+
+.. versionadded:: 1.7
+"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import division
+# core
+import hashlib
+import logging; log = logging.getLogger(__name__)
+try:
+    # new in py3.4
+    from hashlib import pbkdf2_hmac as _stdlib_pbkdf2_hmac
+    if _stdlib_pbkdf2_hmac.__module__ == "hashlib":
+        # builtin pure-python backends are slightly faster than stdlib's pure python fallback,
+        # so only using stdlib's version if it's backed by openssl's pbkdf2_hmac()
+        log.debug("ignoring pure-python hashlib.pbkdf2_hmac()")
+        _stdlib_pbkdf2_hmac = None
+except ImportError:
+    _stdlib_pbkdf2_hmac = None
+import re
+import os
+from struct import Struct
+from warnings import warn
+# site
+try:
+    # https://pypi.python.org/pypi/fastpbkdf2/
+    from fastpbkdf2 import pbkdf2_hmac as _fast_pbkdf2_hmac
+except ImportError:
+    _fast_pbkdf2_hmac = None
+# pkg
+from passlib import exc
+from passlib.utils import join_bytes, to_native_str, join_byte_values, to_bytes, \
+                          SequenceMixin, as_bool
+from passlib.utils.compat import irange, int_types, unicode_or_bytes_types, PY3, error_from
+from passlib.utils.decor import memoized_property
+# local
+__all__ = [
+    # hash utils
+    "lookup_hash",
+    "HashInfo",
+    "norm_hash_name",
+
+    # hmac utils
+    "compile_hmac",
+
+    # kdfs
+    "pbkdf1",
+    "pbkdf2_hmac",
+]
+
+#=============================================================================
+# generic constants
+#=============================================================================
+
+#: max 32-bit value
+MAX_UINT32 = (1 << 32) - 1
+
+#: max 64-bit value
+MAX_UINT64 = (1 << 64) - 1
+
+#=============================================================================
+# hash utils
+#=============================================================================
+
+#: list of known hash names, used by lookup_hash()'s _norm_hash_name() helper
+_known_hash_names = [
+    # format: (hashlib/ssl name, iana name or standin, other known aliases ...)
+
+    #----------------------------------------------------
+    # hashes with official IANA-assigned names
+    # (as of 2012-03 - http://www.iana.org/assignments/hash-function-text-names)
+    #----------------------------------------------------
+    ("md2", "md2"),  # NOTE: openssl dropped md2 support in v1.0.0
+    ("md5", "md5"),
+    ("sha1", "sha-1"),
+    ("sha224", "sha-224", "sha2-224"),
+    ("sha256", "sha-256", "sha2-256"),
+    ("sha384", "sha-384", "sha2-384"),
+    ("sha512", "sha-512", "sha2-512"),
+
+    # TODO: add sha3 to this table.
+
+    #----------------------------------------------------
+    # hashlib/ssl-supported hashes without official IANA names,
+    # (hopefully-) compatible stand-ins have been chosen.
+    #----------------------------------------------------
+
+    ("blake2b", "blake-2b"),
+    ("blake2s", "blake-2s"),
+    ("md4", "md4"),
+    # NOTE: there was an older "ripemd" and "ripemd-128",
+    #       but python 2.7+ resolves "ripemd" -> "ripemd160",
+    #       so treating "ripemd" as alias here.
+    ("ripemd160", "ripemd-160", "ripemd"),
+]
+
+
+#: dict mapping hashlib names to hardcoded digest info;
+#: so this is available even when hashes aren't present.
+_fallback_info = {
+    # name: (digest_size, block_size)
+    'blake2b': (64, 128),
+    'blake2s': (32, 64),
+    'md4': (16, 64),
+    'md5': (16, 64),
+    'sha1': (20, 64),
+    'sha224': (28, 64),
+    'sha256': (32, 64),
+    'sha384': (48, 128),
+    'sha3_224': (28, 144),
+    'sha3_256': (32, 136),
+    'sha3_384': (48, 104),
+    'sha3_512': (64, 72),
+    'sha512': (64, 128),
+    'shake128': (16, 168),
+    'shake256': (32, 136),
+}
+
+
+def _gen_fallback_info():
+    """
+    internal helper used to generate ``_fallback_info`` dict.
+    currently only run manually to update the above list;
+    not invoked at runtime.
+    """
+    out = {}
+    for alg in sorted(hashlib.algorithms_available | set(["md4"])):
+        info = lookup_hash(alg)
+        out[info.name] = (info.digest_size, info.block_size)
+    return out
+
+
+#: cache of hash info instances used by lookup_hash()
+_hash_info_cache = {}
+
+def _get_hash_aliases(name):
+    """
+    internal helper used by :func:`lookup_hash` --
+    normalize arbitrary hash name to hashlib format.
+    if name not recognized, returns dummy record and issues a warning.
+
+    :arg name:
+        unnormalized name
+
+    :returns:
+        tuple with 2+ elements: ``(hashlib_name, iana_name|None, ... 0+ aliases)``.
+    """
+
+    # normalize input
+    orig = name
+    if not isinstance(name, str):
+        name = to_native_str(name, 'utf-8', 'hash name')
+    name = re.sub("[_ /]", "-", name.strip().lower())
+    if name.startswith("scram-"): # helper for SCRAM protocol (see passlib.handlers.scram)
+        name = name[6:]
+        if name.endswith("-plus"):
+            name = name[:-5]
+
+    # look through standard names and known aliases
+    def check_table(name):
+        for row in _known_hash_names:
+            if name in row:
+                return row
+    result = check_table(name)
+    if result:
+        return result
+
+    # try to clean name up some more
+    m = re.match(r"(?i)^(?P<name>[a-z]+)-?(?P<rev>\d)?-?(?P<size>\d{3,4})?$", name)
+    if m:
+        # roughly follows "SHA2-256" style format, normalize representation,
+        # and checked table.
+        iana_name, rev, size = m.group("name", "rev", "size")
+        if rev:
+            iana_name += rev
+        hashlib_name = iana_name
+        if size:
+            iana_name += "-" + size
+            if rev:
+                hashlib_name += "_"
+            hashlib_name += size
+        result = check_table(iana_name)
+        if result:
+            return result
+
+        # not found in table, but roughly recognize format. use names we built up as fallback.
+        log.info("normalizing unrecognized hash name %r => %r / %r",
+                 orig, hashlib_name, iana_name)
+
+    else:
+        # just can't make sense of it. return something
+        iana_name = name
+        hashlib_name = name.replace("-", "_")
+        log.warning("normalizing unrecognized hash name and format %r => %r / %r",
+                    orig, hashlib_name, iana_name)
+
+    return hashlib_name, iana_name
+
+
+def _get_hash_const(name):
+    """
+    internal helper used by :func:`lookup_hash` --
+    lookup hash constructor by name
+
+    :arg name:
+        name (normalized to hashlib format, e.g. ``"sha256"``)
+
+    :returns:
+        hash constructor, e.g. ``hashlib.sha256()``;
+        or None if hash can't be located.
+    """
+    # check hashlib.<attr> for an efficient constructor
+    if not name.startswith("_") and name not in ("new", "algorithms"):
+        try:
+            return getattr(hashlib, name)
+        except AttributeError:
+            pass
+
+    # check hashlib.new() in case SSL supports the digest
+    new_ssl_hash = hashlib.new
+    try:
+        # new() should throw ValueError if alg is unknown
+        new_ssl_hash(name, b"")
+    except ValueError:
+        pass
+    else:
+        # create wrapper function
+        # XXX: is there a faster way to wrap this?
+        def const(msg=b""):
+            return new_ssl_hash(name, msg)
+        const.__name__ = name
+        const.__module__ = "hashlib"
+        const.__doc__ = ("wrapper for hashlib.new(%r),\n"
+                         "generated by passlib.crypto.digest.lookup_hash()") % name
+        return const
+
+    # use builtin md4 as fallback when not supported by hashlib
+    if name == "md4":
+        from passlib.crypto._md4 import md4
+        return md4
+
+    # XXX: any other modules / registries we should check?
+    # TODO: add pysha3 support.
+
+    return None
+
+
+def lookup_hash(digest,  # *,
+                return_unknown=False, required=True):
+    """
+    Returns a :class:`HashInfo` record containing information about a given hash function.
+    Can be used to look up a hash constructor by name, normalize hash name representation, etc.
+
+    :arg digest:
+        This can be any of:
+
+        * A string containing a :mod:`!hashlib` digest name (e.g. ``"sha256"``),
+        * A string containing an IANA-assigned hash name,
+        * A digest constructor function (e.g. ``hashlib.sha256``).
+
+        Case is ignored, underscores are converted to hyphens,
+        and various other cleanups are made.
+
+    :param required:
+        By default (True), this function will throw an :exc:`~passlib.exc.UnknownHashError` if no hash constructor
+        can be found, or if the hash is not actually available.
+
+        If this flag is False, it will instead return a dummy :class:`!HashInfo` record
+        which will defer throwing the error until it's constructor function is called.
+        This is mainly used by :func:`norm_hash_name`.
+
+    :param return_unknown:
+
+        .. deprecated:: 1.7.3
+
+            deprecated, and will be removed in passlib 2.0.
+            this acts like inverse of **required**.
+
+    :returns HashInfo:
+        :class:`HashInfo` instance containing information about specified digest.
+
+        Multiple calls resolving to the same hash should always
+        return the same :class:`!HashInfo` instance.
+    """
+    # check for cached entry
+    cache = _hash_info_cache
+    try:
+        return cache[digest]
+    except (KeyError, TypeError):
+        # NOTE: TypeError is to catch 'TypeError: unhashable type' (e.g. HashInfo)
+        pass
+
+    # legacy alias
+    if return_unknown:
+        required = False
+
+    # resolve ``digest`` to ``const`` & ``name_record``
+    cache_by_name = True
+    if isinstance(digest, unicode_or_bytes_types):
+        # normalize name
+        name_list = _get_hash_aliases(digest)
+        name = name_list[0]
+        assert name
+
+        # if name wasn't normalized to hashlib format,
+        # get info for normalized name and reuse it.
+        if name != digest:
+            info = lookup_hash(name, required=required)
+            cache[digest] = info
+            return info
+
+        # else look up constructor
+        # NOTE: may return None, which is handled by HashInfo constructor
+        const = _get_hash_const(name)
+
+        # if mock fips mode is enabled, replace with dummy constructor
+        # (to replicate how it would behave on a real fips system).
+        if const and mock_fips_mode and name not in _fips_algorithms:
+            def const(source=b""):
+                raise ValueError("%r disabled for fips by passlib set_mock_fips_mode()" % name)
+
+    elif isinstance(digest, HashInfo):
+        # handle border case where HashInfo is passed in.
+        return digest
+
+    elif callable(digest):
+        # try to lookup digest based on it's self-reported name
+        # (which we trust to be the canonical "hashlib" name)
+        const = digest
+        name_list = _get_hash_aliases(const().name)
+        name = name_list[0]
+        other_const = _get_hash_const(name)
+        if other_const is None:
+            # this is probably a third-party digest we don't know about,
+            # so just pass it on through, and register reverse lookup for it's name.
+            pass
+
+        elif other_const is const:
+            # if we got back same constructor, this is just a known stdlib constructor,
+            # which was passed in before we had cached it by name. proceed normally.
+            pass
+
+        else:
+            # if we got back different object, then ``const`` is something else
+            # (such as a mock object), in which case we want to skip caching it by name,
+            # as that would conflict with real hash.
+            cache_by_name = False
+
+    else:
+        raise exc.ExpectedTypeError(digest, "digest name or constructor", "digest")
+
+    # create new instance
+    info = HashInfo(const=const, names=name_list, required=required)
+
+    # populate cache
+    if const is not None:
+        cache[const] = info
+    if cache_by_name:
+        for name in name_list:
+            if name:  # (skips iana name if it's empty)
+                assert cache.get(name) in [None, info], "%r already in cache" % name
+                cache[name] = info
+    return info
+
+#: UT helper for clearing internal cache
+lookup_hash.clear_cache = _hash_info_cache.clear
+
+
+def norm_hash_name(name, format="hashlib"):
+    """Normalize hash function name (convenience wrapper for :func:`lookup_hash`).
+
+    :arg name:
+        Original hash function name.
+
+        This name can be a Python :mod:`~hashlib` digest name,
+        a SCRAM mechanism name, IANA assigned hash name, etc.
+        Case is ignored, and underscores are converted to hyphens.
+
+    :param format:
+        Naming convention to normalize to.
+        Possible values are:
+
+        * ``"hashlib"`` (the default) - normalizes name to be compatible
+          with Python's :mod:`!hashlib`.
+
+        * ``"iana"`` - normalizes name to IANA-assigned hash function name.
+          For hashes which IANA hasn't assigned a name for, this issues a warning,
+          and then uses a heuristic to return a "best guess" name.
+
+    :returns:
+        Hash name, returned as native :class:`!str`.
+    """
+    info = lookup_hash(name, required=False)
+    if info.unknown:
+        warn("norm_hash_name(): " + info.error_text, exc.PasslibRuntimeWarning)
+    if format == "hashlib":
+        return info.name
+    elif format == "iana":
+        return info.iana_name
+    else:
+        raise ValueError("unknown format: %r" % (format,))
+
+
+class HashInfo(SequenceMixin):
+    """
+    Record containing information about a given hash algorithm, as returned :func:`lookup_hash`.
+
+    This class exposes the following attributes:
+
+    .. autoattribute:: const
+    .. autoattribute:: digest_size
+    .. autoattribute:: block_size
+    .. autoattribute:: name
+    .. autoattribute:: iana_name
+    .. autoattribute:: aliases
+    .. autoattribute:: supported
+
+    This object can also be treated a 3-element sequence
+    containing ``(const, digest_size, block_size)``.
+    """
+    #=========================================================================
+    # instance attrs
+    #=========================================================================
+
+    #: Canonical / hashlib-compatible name (e.g. ``"sha256"``).
+    name = None
+
+    #: IANA assigned name (e.g. ``"sha-256"``), may be ``None`` if unknown.
+    iana_name = None
+
+    #: Tuple of other known aliases (may be empty)
+    aliases = ()
+
+    #: Hash constructor function (e.g. :func:`hashlib.sha256`)
+    const = None
+
+    #: Hash's digest size
+    digest_size = None
+
+    #: Hash's block size
+    block_size = None
+
+    #: set when hash isn't available, will be filled in with string containing error text
+    #: that const() will raise.
+    error_text = None
+
+    #: set when error_text is due to hash algorithm being completely unknown
+    #: (not just unavailable on current system)
+    unknown = False
+
+    #=========================================================================
+    # init
+    #=========================================================================
+
+    def __init__(self,  # *,
+                 const, names, required=True):
+        """
+        initialize new instance.
+        :arg const:
+            hash constructor
+        :arg names:
+            list of 2+ names. should be list of ``(name, iana_name, ... 0+ aliases)``.
+            names must be lower-case. only iana name may be None.
+        """
+        # init names
+        name = self.name = names[0]
+        self.iana_name = names[1]
+        self.aliases = names[2:]
+
+        def use_stub_const(msg):
+            """
+            helper that installs stub constructor which throws specified error <msg>.
+            """
+            def const(source=b""):
+                raise exc.UnknownHashError(msg, name)
+            if required:
+                # if caller only wants supported digests returned,
+                # just throw error immediately...
+                const()
+                assert "shouldn't get here"
+            self.error_text = msg
+            self.const = const
+            try:
+                self.digest_size, self.block_size = _fallback_info[name]
+            except KeyError:
+                pass
+
+        # handle "constructor not available" case
+        if const is None:
+            if names in _known_hash_names:
+                msg = "unsupported hash: %r" % name
+            else:
+                msg = "unknown hash: %r" % name
+                self.unknown = True
+            use_stub_const(msg)
+            # TODO: load in preset digest size info for known hashes.
+            return
+
+        # create hash instance to inspect
+        try:
+            hash = const()
+        except ValueError as err:
+            # per issue 116, FIPS compliant systems will have a constructor;
+            # but it will throw a ValueError with this message.  As of 1.7.3,
+            # translating this into DisabledHashError.
+            # "ValueError: error:060800A3:digital envelope routines:EVP_DigestInit_ex:disabled for fips"
+            if "disabled for fips" in str(err).lower():
+                msg = "%r hash disabled for fips" % name
+            else:
+                msg = "internal error in %r constructor\n(%s: %s)" % (name, type(err).__name__, err)
+            use_stub_const(msg)
+            return
+
+        # store stats about hash
+        self.const = const
+        self.digest_size = hash.digest_size
+        self.block_size = hash.block_size
+
+        # do sanity check on digest size
+        if len(hash.digest()) != hash.digest_size:
+            raise RuntimeError("%r constructor failed sanity check" % self.name)
+
+        # do sanity check on name.
+        if hash.name != self.name:
+            warn("inconsistent digest name: %r resolved to %r, which reports name as %r" %
+                 (self.name, const, hash.name), exc.PasslibRuntimeWarning)
+
+    #=========================================================================
+    # methods
+    #=========================================================================
+    def __repr__(self):
+        return "<lookup_hash(%r): digest_size=%r block_size=%r)" % \
+               (self.name, self.digest_size, self.block_size)
+
+    def _as_tuple(self):
+        return self.const, self.digest_size, self.block_size
+
+    @memoized_property
+    def supported(self):
+        """
+        whether hash is available for use
+        (if False, constructor will throw UnknownHashError if called)
+        """
+        return self.error_text is None
+
+    @memoized_property
+    def supported_by_fastpbkdf2(self):
+        """helper to detect if hash is supported by fastpbkdf2()"""
+        if not _fast_pbkdf2_hmac:
+            return None
+        try:
+            _fast_pbkdf2_hmac(self.name, b"p", b"s", 1)
+            return True
+        except ValueError:
+            # "unsupported hash type"
+            return False
+
+    @memoized_property
+    def supported_by_hashlib_pbkdf2(self):
+        """helper to detect if hash is supported by hashlib.pbkdf2_hmac()"""
+        if not _stdlib_pbkdf2_hmac:
+            return None
+        try:
+            _stdlib_pbkdf2_hmac(self.name, b"p", b"s", 1)
+            return True
+        except ValueError:
+            # "unsupported hash type"
+            return False
+
+    #=========================================================================
+    # eoc
+    #=========================================================================
+
+
+#---------------------------------------------------------------------
+# mock fips mode monkeypatch
+#---------------------------------------------------------------------
+
+#: flag for detecting if mock fips mode is enabled.
+mock_fips_mode = False
+
+
+#: algorithms allowed under FIPS mode (subset of hashlib.algorithms_available);
+#: per https://csrc.nist.gov/Projects/Hash-Functions FIPS 202 list.
+_fips_algorithms = set([
+    # FIPS 180-4  and FIPS 202
+    'sha1',
+    'sha224',
+    'sha256',
+    'sha384',
+    'sha512',
+    # 'sha512/224',
+    # 'sha512/256',
+
+    # FIPS 202 only
+    'sha3_224',
+    'sha3_256',
+    'sha3_384',
+    'sha3_512',
+    'shake_128',
+    'shake_256',
+])
+
+
+def _set_mock_fips_mode(enable=True):
+    """
+    UT helper which monkeypatches lookup_hash() internals to replicate FIPS mode.
+    """
+    global mock_fips_mode
+    mock_fips_mode = enable
+    lookup_hash.clear_cache()
+
+
+# helper for UTs
+if as_bool(os.environ.get("PASSLIB_MOCK_FIPS_MODE")):
+    _set_mock_fips_mode()
+
+#=============================================================================
+# hmac utils
+#=============================================================================
+
+#: translation tables used by compile_hmac()
+_TRANS_5C = join_byte_values((x ^ 0x5C) for x in irange(256))
+_TRANS_36 = join_byte_values((x ^ 0x36) for x in irange(256))
+
+def compile_hmac(digest, key, multipart=False):
+    """
+    This function returns an efficient HMAC function, hardcoded with a specific digest & key.
+    It can be used via ``hmac = compile_hmac(digest, key)``.
+
+    :arg digest:
+        digest name or constructor.
+
+    :arg key:
+        secret key as :class:`!bytes` or :class:`!unicode` (unicode will be encoded using utf-8).
+
+    :param multipart:
+        request a multipart constructor instead (see return description).
+
+    :returns:
+        By default, the returned function has the signature ``hmac(msg) -> digest output``.
+
+        However, if ``multipart=True``, the returned function has the signature
+        ``hmac() -> update, finalize``, where ``update(msg)`` may be called multiple times,
+        and ``finalize() -> digest_output`` may be repeatedly called at any point to
+        calculate the HMAC digest so far.
+
+        The returned object will also have a ``digest_info`` attribute, containing
+        a :class:`lookup_hash` instance for the specified digest.
+
+    This function exists, and has the weird signature it does, in order to squeeze as
+    provide as much efficiency as possible, by omitting much of the setup cost
+    and features of the stdlib :mod:`hmac` module.
+    """
+    # all the following was adapted from stdlib's hmac module
+
+    # resolve digest (cached)
+    digest_info = lookup_hash(digest)
+    const, digest_size, block_size = digest_info
+    assert block_size >= 16, "block size too small"
+
+    # prepare key
+    if not isinstance(key, bytes):
+        key = to_bytes(key, param="key")
+    klen = len(key)
+    if klen > block_size:
+        key = const(key).digest()
+        klen = digest_size
+    if klen < block_size:
+        key += b'\x00' * (block_size - klen)
+
+    # create pre-initialized hash constructors
+    _inner_copy = const(key.translate(_TRANS_36)).copy
+    _outer_copy = const(key.translate(_TRANS_5C)).copy
+
+    if multipart:
+        # create multi-part function
+        # NOTE: this is slightly slower than the single-shot version,
+        #       and should only be used if needed.
+        def hmac():
+            """generated by compile_hmac(multipart=True)"""
+            inner = _inner_copy()
+            def finalize():
+                outer = _outer_copy()
+                outer.update(inner.digest())
+                return outer.digest()
+            return inner.update, finalize
+    else:
+
+        # single-shot function
+        def hmac(msg):
+            """generated by compile_hmac()"""
+            inner = _inner_copy()
+            inner.update(msg)
+            outer = _outer_copy()
+            outer.update(inner.digest())
+            return outer.digest()
+
+    # add info attr
+    hmac.digest_info = digest_info
+    return hmac
+
+#=============================================================================
+# pbkdf1 
+#=============================================================================
+def pbkdf1(digest, secret, salt, rounds, keylen=None):
+    """pkcs#5 password-based key derivation v1.5
+
+    :arg digest:
+        digest name or constructor.
+        
+    :arg secret:
+        secret to use when generating the key.
+        may be :class:`!bytes` or :class:`unicode` (encoded using UTF-8).
+        
+    :arg salt:
+        salt string to use when generating key.
+        may be :class:`!bytes` or :class:`unicode` (encoded using UTF-8).
+
+    :param rounds:
+        number of rounds to use to generate key.
+
+    :arg keylen:
+        number of bytes to generate (if omitted / ``None``, uses digest's native size)
+
+    :returns:
+        raw :class:`bytes` of generated key
+
+    .. note::
+
+        This algorithm has been deprecated, new code should use PBKDF2.
+        Among other limitations, ``keylen`` cannot be larger
+        than the digest size of the specified hash.
+    """
+    # resolve digest
+    const, digest_size, block_size = lookup_hash(digest)
+    
+    # validate secret & salt
+    secret = to_bytes(secret, param="secret")
+    salt = to_bytes(salt, param="salt")
+
+    # validate rounds
+    if not isinstance(rounds, int_types):
+        raise exc.ExpectedTypeError(rounds, "int", "rounds")
+    if rounds < 1:
+        raise ValueError("rounds must be at least 1")
+
+    # validate keylen
+    if keylen is None:
+        keylen = digest_size
+    elif not isinstance(keylen, int_types):
+        raise exc.ExpectedTypeError(keylen, "int or None", "keylen")
+    elif keylen < 0:
+        raise ValueError("keylen must be at least 0")
+    elif keylen > digest_size:
+        raise ValueError("keylength too large for digest: %r > %r" %
+                         (keylen, digest_size))
+
+    # main pbkdf1 loop
+    block = secret + salt
+    for _ in irange(rounds):
+        block = const(block).digest()
+    return block[:keylen]
+
+#=============================================================================
+# pbkdf2
+#=============================================================================
+
+_pack_uint32 = Struct(">L").pack
+
+def pbkdf2_hmac(digest, secret, salt, rounds, keylen=None):
+    """pkcs#5 password-based key derivation v2.0 using HMAC + arbitrary digest.
+
+    :arg digest:
+        digest name or constructor.
+
+    :arg secret:
+        passphrase to use to generate key.
+        may be :class:`!bytes` or :class:`unicode` (encoded using UTF-8).
+
+    :arg salt:
+        salt string to use when generating key.
+        may be :class:`!bytes` or :class:`unicode` (encoded using UTF-8).
+
+    :param rounds:
+        number of rounds to use to generate key.
+
+    :arg keylen:
+        number of bytes to generate.
+        if omitted / ``None``, will use digest's native output size.
+
+    :returns:
+        raw bytes of generated key
+
+    .. versionchanged:: 1.7
+
+        This function will use the first available of the following backends:
+
+        * `fastpbk2 <https://pypi.python.org/pypi/fastpbkdf2>`_
+        * :func:`hashlib.pbkdf2_hmac` (only available in py2 >= 2.7.8, and py3 >= 3.4)
+        * builtin pure-python backend
+
+        See :data:`passlib.crypto.digest.PBKDF2_BACKENDS` to determine
+        which backend(s) are in use.
+    """
+    # validate secret & salt
+    secret = to_bytes(secret, param="secret")
+    salt = to_bytes(salt, param="salt")
+
+    # resolve digest
+    digest_info = lookup_hash(digest)
+    digest_size = digest_info.digest_size
+
+    # validate rounds
+    if not isinstance(rounds, int_types):
+        raise exc.ExpectedTypeError(rounds, "int", "rounds")
+    if rounds < 1:
+        raise ValueError("rounds must be at least 1")
+
+    # validate keylen
+    if keylen is None:
+        keylen = digest_size
+    elif not isinstance(keylen, int_types):
+        raise exc.ExpectedTypeError(keylen, "int or None", "keylen")
+    elif keylen < 1:
+        # XXX: could allow keylen=0, but want to be compat w/ stdlib
+        raise ValueError("keylen must be at least 1")
+
+    # find smallest block count s.t. keylen <= block_count * digest_size;
+    # make sure block count won't overflow (per pbkdf2 spec)
+    # this corresponds to throwing error if keylen > digest_size * MAX_UINT32
+    # NOTE: stdlib will throw error at lower bound (keylen > MAX_SINT32)
+    # NOTE: have do this before other backends checked, since fastpbkdf2 raises wrong error
+    #       (InvocationError, not OverflowError)
+    block_count = (keylen + digest_size - 1) // digest_size
+    if block_count > MAX_UINT32:
+        raise OverflowError("keylen too long for digest")
+
+    #
+    # check for various high-speed backends
+    #
+
+    # ~3x faster than pure-python backend
+    # NOTE: have to do this after above guards since fastpbkdf2 lacks bounds checks.
+    if digest_info.supported_by_fastpbkdf2:
+        return _fast_pbkdf2_hmac(digest_info.name, secret, salt, rounds, keylen)
+
+    # ~1.4x faster than pure-python backend
+    # NOTE: have to do this after fastpbkdf2 since hashlib-ssl is slower,
+    #       will support larger number of hashes.
+    if digest_info.supported_by_hashlib_pbkdf2:
+        return _stdlib_pbkdf2_hmac(digest_info.name, secret, salt, rounds, keylen)
+
+    #
+    # otherwise use our own implementation
+    #
+
+    # generated keyed hmac
+    keyed_hmac = compile_hmac(digest, secret)
+
+    # get helper to calculate pbkdf2 inner loop efficiently
+    calc_block = _get_pbkdf2_looper(digest_size)
+
+    # assemble & return result
+    return join_bytes(
+        calc_block(keyed_hmac, keyed_hmac(salt + _pack_uint32(i)), rounds)
+        for i in irange(1, block_count + 1)
+    )[:keylen]
+
+#-------------------------------------------------------------------------------------
+# pick best choice for pure-python helper
+# TODO: consider some alternatives, such as C-accelerated xor_bytes helper if available
+#-------------------------------------------------------------------------------------
+# NOTE: this env var is only present to support the admin/benchmark_pbkdf2 script
+_force_backend = os.environ.get("PASSLIB_PBKDF2_BACKEND") or "any"
+
+if PY3 and _force_backend in ["any", "from-bytes"]:
+    from functools import partial
+
+    def _get_pbkdf2_looper(digest_size):
+        return partial(_pbkdf2_looper, digest_size)
+
+    def _pbkdf2_looper(digest_size, keyed_hmac, digest, rounds):
+        """
+        py3-only implementation of pbkdf2 inner loop;
+        uses 'int.from_bytes' + integer XOR
+        """
+        from_bytes = int.from_bytes
+        BIG = "big"  # endianess doesn't matter, just has to be consistent
+        accum = from_bytes(digest, BIG)
+        for _ in irange(rounds - 1):
+            digest = keyed_hmac(digest)
+            accum ^= from_bytes(digest, BIG)
+        return accum.to_bytes(digest_size, BIG)
+
+    _builtin_backend = "from-bytes"
+
+elif _force_backend in ["any", "unpack", "from-bytes"]:
+    from struct import Struct
+    from passlib.utils import sys_bits
+
+    _have_64_bit = (sys_bits >= 64)
+
+    #: cache used by _get_pbkdf2_looper
+    _looper_cache = {}
+
+    def _get_pbkdf2_looper(digest_size):
+        """
+        We want a helper function which performs equivalent of the following::
+
+          def helper(keyed_hmac, digest, rounds):
+              accum = digest
+              for _ in irange(rounds - 1):
+                  digest = keyed_hmac(digest)
+                  accum ^= digest
+              return accum
+
+        However, no efficient way to implement "bytes ^ bytes" in python.
+        Instead, using approach where we dynamically compile a helper function based
+        on digest size.  Instead of a single `accum` var, this helper breaks the digest
+        into a series of integers.
+
+        It stores these in a series of`accum_<i>` vars, and performs `accum ^= digest`
+        by unpacking digest and perform xor for each "accum_<i> ^= digest_<i>".
+        this keeps everything in locals, avoiding excessive list creation, encoding or decoding,
+        etc.
+
+        :param digest_size:
+            digest size to compile for, in bytes. (must be multiple of 4).
+
+        :return:
+            helper function with call signature outlined above.
+        """
+        #
+        # cache helpers
+        #
+        try:
+            return _looper_cache[digest_size]
+        except KeyError:
+            pass
+
+        #
+        # figure out most efficient struct format to unpack digest into list of native ints
+        #
+        if _have_64_bit and not digest_size & 0x7:
+            # digest size multiple of 8, on a 64 bit system -- use array of UINT64
+            count = (digest_size >> 3)
+            fmt = "=%dQ" % count
+        elif not digest_size & 0x3:
+            if _have_64_bit:
+                # digest size multiple of 4, on a 64 bit system -- use array of UINT64 + 1 UINT32
+                count = (digest_size >> 3)
+                fmt = "=%dQI" % count
+                count += 1
+            else:
+                # digest size multiple of 4, on a 32 bit system -- use array of UINT32
+                count = (digest_size >> 2)
+                fmt = "=%dI" % count
+        else:
+            # stopping here, cause no known hashes have digest size that isn't multiple of 4 bytes.
+            # if needed, could go crazy w/ "H" & "B"
+            raise NotImplementedError("unsupported digest size: %d" % digest_size)
+        struct = Struct(fmt)
+
+        #
+        # build helper source
+        #
+        tdict = dict(
+            digest_size=digest_size,
+            accum_vars=", ".join("acc_%d" % i for i in irange(count)),
+            digest_vars=", ".join("dig_%d" % i for i in irange(count)),
+        )
+
+        # head of function
+        source = (
+                        "def helper(keyed_hmac, digest, rounds):\n"
+                        "    '''pbkdf2 loop helper for digest_size={digest_size}'''\n"
+                        "    unpack_digest = struct.unpack\n"
+                        "    {accum_vars} = unpack_digest(digest)\n"
+                        "    for _ in irange(1, rounds):\n"
+                        "        digest = keyed_hmac(digest)\n"
+                        "        {digest_vars} = unpack_digest(digest)\n"
+        ).format(**tdict)
+
+        # xor digest
+        for i in irange(count):
+            source +=   "        acc_%d ^= dig_%d\n" % (i, i)
+
+        # return result
+        source +=       "    return struct.pack({accum_vars})\n".format(**tdict)
+
+        #
+        # compile helper
+        #
+        code = compile(source, "<generated by passlib.crypto.digest._get_pbkdf2_looper()>", "exec")
+        gdict = dict(irange=irange, struct=struct)
+        ldict = dict()
+        eval(code, gdict, ldict)
+        helper = ldict['helper']
+        if __debug__:
+            helper.__source__ = source
+
+        #
+        # store in cache
+        #
+        _looper_cache[digest_size] = helper
+        return helper
+
+    _builtin_backend = "unpack"
+
+else:
+    assert _force_backend in ["any", "hexlify"]
+
+    # XXX: older & slower approach that used int(hexlify()),
+    #      keeping it around for a little while just for benchmarking.
+
+    from binascii import hexlify as _hexlify
+    from passlib.utils import int_to_bytes
+
+    def _get_pbkdf2_looper(digest_size):
+        return _pbkdf2_looper
+
+    def _pbkdf2_looper(keyed_hmac, digest, rounds):
+        hexlify = _hexlify
+        accum = int(hexlify(digest), 16)
+        for _ in irange(rounds - 1):
+            digest = keyed_hmac(digest)
+            accum ^= int(hexlify(digest), 16)
+        return int_to_bytes(accum, len(digest))
+
+    _builtin_backend = "hexlify"
+
+# helper for benchmark script -- disable hashlib, fastpbkdf2 support if builtin requested
+if _force_backend == _builtin_backend:
+    _fast_pbkdf2_hmac = _stdlib_pbkdf2_hmac = None
+
+# expose info about what backends are active
+PBKDF2_BACKENDS = [b for b in [
+    "fastpbkdf2" if _fast_pbkdf2_hmac else None,
+    "hashlib-ssl" if _stdlib_pbkdf2_hmac else None,
+    "builtin-" + _builtin_backend
+] if b]
+
+# *very* rough estimate of relative speed (compared to sha256 using 'unpack' backend on 64bit arch)
+if "fastpbkdf2" in PBKDF2_BACKENDS:
+    PBKDF2_SPEED_FACTOR = 3
+elif "hashlib-ssl" in PBKDF2_BACKENDS:
+    PBKDF2_SPEED_FACTOR = 1.4
+else:
+    # remaining backends have *some* difference in performance, but not enough to matter
+    PBKDF2_SPEED_FACTOR = 1
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/__init__.py b/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/__init__.py
new file mode 100644
index 0000000..c71873a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/__init__.py
@@ -0,0 +1,281 @@
+"""
+passlib.utils.scrypt -- scrypt hash frontend and help utilities
+
+XXX: add this module to public docs?
+"""
+#==========================================================================
+# imports
+#==========================================================================
+from __future__ import absolute_import
+# core
+import logging; log = logging.getLogger(__name__)
+from warnings import warn
+# pkg
+from passlib import exc
+from passlib.utils import to_bytes
+from passlib.utils.compat import PYPY
+# local
+__all__ =[
+    "validate",
+    "scrypt",
+]
+
+#==========================================================================
+# config validation
+#==========================================================================
+
+#: internal global constant for setting stdlib scrypt's maxmem (int bytes).
+#: set to -1 to auto-calculate (see _load_stdlib_backend() below)
+#: set to 0 for openssl default (32mb according to python docs)
+#: TODO: standardize this across backends, and expose support via scrypt hash config;
+#:       currently not very configurable, and only applies to stdlib backend.
+SCRYPT_MAXMEM = -1
+
+#: max output length in bytes
+MAX_KEYLEN = ((1 << 32) - 1) * 32
+
+#: max ``r * p`` limit
+MAX_RP = (1 << 30) - 1
+
+# TODO: unittests for this function
+def validate(n, r, p):
+    """
+    helper which validates a set of scrypt config parameters.
+    scrypt will take ``O(n * r * p)`` time and ``O(n * r)`` memory.
+    limitations are that ``n = 2**<positive integer>``, ``n < 2**(16*r)``, ``r * p < 2 ** 30``.
+
+    :param n: scrypt rounds
+    :param r: scrypt block size
+    :param p: scrypt parallel factor
+    """
+    if r < 1:
+        raise ValueError("r must be > 0: r=%r" % r)
+
+    if p < 1:
+        raise ValueError("p must be > 0: p=%r" % p)
+
+    if r * p > MAX_RP:
+        # pbkdf2-hmac-sha256 limitation - it will be requested to generate ``p*(2*r)*64`` bytes,
+        # but pbkdf2 can do max of (2**31-1) blocks, and sha-256 has 32 byte block size...
+        # so ``(2**31-1)*32 >= p*r*128`` -> ``r*p < 2**30``
+        raise ValueError("r * p must be < 2**30: r=%r, p=%r" % (r,p))
+
+    if n < 2 or n & (n - 1):
+        raise ValueError("n must be > 1, and a power of 2: n=%r" % n)
+
+    return True
+
+
+UINT32_SIZE = 4
+
+
+def estimate_maxmem(n, r, p, fudge=1.05):
+    """
+    calculate memory required for parameter combination.
+    assumes parameters have already been validated.
+
+    .. warning::
+        this is derived from OpenSSL's scrypt maxmem formula;
+        and may not be correct for other implementations
+        (additional buffers, different parallelism tradeoffs, etc).
+    """
+    # XXX: expand to provide upper bound for diff backends, or max across all of them?
+    # NOTE: openssl's scrypt() enforces it's maxmem parameter based on calc located at
+    # <openssl/providers/default/kdfs/scrypt.c>, ending in line containing "Blen + Vlen > maxmem"
+    # using the following formula:
+    #     Blen = p * 128 * r
+    #     Vlen = 32 * r * (N + 2) * sizeof(uint32_t)
+    #     total_bytes = Blen + Vlen
+    maxmem = r * (128 * p + 32 * (n + 2) * UINT32_SIZE)
+    # add fudge factor so we don't have off-by-one mismatch w/ openssl
+    maxmem = int(maxmem * fudge)
+    return maxmem
+
+
+# TODO: configuration picker (may need psutil for full effect)
+
+#==========================================================================
+# hash frontend
+#==========================================================================
+
+#: backend function used by scrypt(), filled in by _set_backend()
+_scrypt = None
+
+#: name of backend currently in use, exposed for informational purposes.
+backend = None
+
+def scrypt(secret, salt, n, r, p=1, keylen=32):
+    """run SCrypt key derivation function using specified parameters.
+
+    :arg secret:
+        passphrase string (unicode is encoded to bytes using utf-8).
+
+    :arg salt:
+        salt string (unicode is encoded to bytes using utf-8).
+
+    :arg n:
+        integer 'N' parameter
+
+    :arg r:
+        integer 'r' parameter
+
+    :arg p:
+        integer 'p' parameter
+
+    :arg keylen:
+        number of bytes of key to generate.
+        defaults to 32 (the internal block size).
+
+    :returns:
+        a *keylen*-sized bytes instance
+
+    SCrypt imposes a number of constraints on it's input parameters:
+
+    * ``r * p < 2**30`` -- due to a limitation of PBKDF2-HMAC-SHA256.
+    * ``keylen < (2**32 - 1) * 32`` -- due to a limitation of PBKDF2-HMAC-SHA256.
+    * ``n`` must a be a power of 2, and > 1 -- internal limitation of scrypt() implementation
+
+    :raises ValueError: if the provided parameters are invalid (see constraints above).
+
+    .. warning::
+
+        Unless the third-party ``scrypt <https://pypi.python.org/pypi/scrypt/>``_ package
+        is installed, passlib will use a builtin pure-python implementation of scrypt,
+        which is *considerably* slower (and thus requires a much lower / less secure
+        ``n`` value in order to be usuable). Installing the :mod:`!scrypt` package
+        is strongly recommended.
+    """
+    validate(n, r, p)
+    secret = to_bytes(secret, param="secret")
+    salt = to_bytes(salt, param="salt")
+    if keylen < 1:
+        raise ValueError("keylen must be at least 1")
+    if keylen > MAX_KEYLEN:
+        raise ValueError("keylen too large, must be <= %d" % MAX_KEYLEN)
+    return _scrypt(secret, salt, n, r, p, keylen)
+
+
+def _load_builtin_backend():
+    """
+    Load pure-python scrypt implementation built into passlib.
+    """
+    slowdown = 10 if PYPY else 100
+    warn("Using builtin scrypt backend, which is %dx slower than is required "
+         "for adequate security. Installing scrypt support (via 'pip install scrypt') "
+         "is strongly recommended" % slowdown, exc.PasslibSecurityWarning)
+    from ._builtin import ScryptEngine
+    return ScryptEngine.execute
+
+
+def _load_cffi_backend():
+    """
+    Try to import the ctypes-based scrypt hash function provided by the
+    ``scrypt <https://pypi.python.org/pypi/scrypt/>``_ package.
+    """
+    try:
+        from scrypt import hash
+        return hash
+    except ImportError:
+        pass
+    # not available, but check to see if package present but outdated / not installed right
+    try:
+        import scrypt
+    except ImportError as err:
+        if "scrypt" not in str(err):
+            # e.g. if cffi isn't set up right
+            # user should try importing scrypt explicitly to diagnose problem.
+            warn("'scrypt' package failed to import correctly (possible installation issue?)",
+                 exc.PasslibWarning)
+        # else: package just isn't installed
+    else:
+        warn("'scrypt' package is too old (lacks ``hash()`` method)", exc.PasslibWarning)
+    return None
+
+
+def _load_stdlib_backend():
+    """
+    Attempt to load stdlib scrypt() implement and return wrapper.
+    Returns None if not found.
+    """
+    try:
+        # new in python 3.6, if compiled with openssl >= 1.1
+        from hashlib import scrypt as stdlib_scrypt
+    except ImportError:
+        return None
+
+    def stdlib_scrypt_wrapper(secret, salt, n, r, p, keylen):
+        # work out appropriate "maxmem" parameter
+        #
+        # TODO: would like to enforce a single "maxmem" policy across all backends;
+        # and maybe expose this via scrypt hasher config.
+        #
+        # for now, since parameters should all be coming from internally-controlled sources
+        # (password hashes), using policy of "whatever memory the parameters needs".
+        # furthermore, since stdlib scrypt is only place that needs this,
+        # currently calculating exactly what maxmem needs to make things work for stdlib call.
+        # as hack, this can be overriden via SCRYPT_MAXMEM above,
+        # would like to formalize all of this.
+        maxmem = SCRYPT_MAXMEM
+        if maxmem < 0:
+            maxmem = estimate_maxmem(n, r, p)
+        return stdlib_scrypt(password=secret, salt=salt, n=n, r=r, p=p, dklen=keylen,
+                             maxmem=maxmem)
+
+    return stdlib_scrypt_wrapper
+
+
+#: list of potential backends
+backend_values = ("stdlib", "scrypt", "builtin")
+
+#: dict mapping backend name -> loader
+_backend_loaders = dict(
+    stdlib=_load_stdlib_backend,
+    scrypt=_load_cffi_backend,  # XXX: rename backend constant to "cffi"?
+    builtin=_load_builtin_backend,
+)
+
+
+def _set_backend(name, dryrun=False):
+    """
+    set backend for scrypt(). if name not specified, loads first available.
+
+    :raises ~passlib.exc.MissingBackendError: if backend can't be found
+
+    .. note:: mainly intended to be called by unittests, and scrypt hash handler
+    """
+    if name == "any":
+        return
+    elif name == "default":
+        for name in backend_values:
+            try:
+                return _set_backend(name, dryrun=dryrun)
+            except exc.MissingBackendError:
+                continue
+        raise exc.MissingBackendError("no scrypt backends available")
+    else:
+        loader = _backend_loaders.get(name)
+        if not loader:
+            raise ValueError("unknown scrypt backend: %r" % (name,))
+        hash = loader()
+        if not hash:
+            raise exc.MissingBackendError("scrypt backend %r not available" % name)
+        if dryrun:
+            return
+        global _scrypt, backend
+        backend = name
+        _scrypt = hash
+
+# initialize backend
+_set_backend("default")
+
+
+def _has_backend(name):
+    try:
+        _set_backend(name, dryrun=True)
+        return True
+    except exc.MissingBackendError:
+        return False
+
+#==========================================================================
+# eof
+#==========================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/_builtin.py b/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/_builtin.py
new file mode 100644
index 0000000..e9bb305
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/_builtin.py
@@ -0,0 +1,244 @@
+"""passlib.utils.scrypt._builtin -- scrypt() kdf in pure-python"""
+#==========================================================================
+# imports
+#==========================================================================
+# core
+import operator
+import struct
+# pkg
+from passlib.utils.compat import izip
+from passlib.crypto.digest import pbkdf2_hmac
+from passlib.crypto.scrypt._salsa import salsa20
+# local
+__all__ =[
+    "ScryptEngine",
+]
+
+#==========================================================================
+# scrypt engine
+#==========================================================================
+class ScryptEngine(object):
+    """
+    helper class used to run scrypt kdf, see scrypt() for frontend
+
+    .. warning::
+        this class does NO validation of the input ranges or types.
+
+        it's not intended to be used directly,
+        but only as a backend for :func:`passlib.utils.scrypt.scrypt()`.
+    """
+    #=================================================================
+    # instance attrs
+    #=================================================================
+
+    # primary scrypt config parameters
+    n = 0
+    r = 0
+    p = 0
+
+    # derived values & objects
+    smix_bytes = 0
+    iv_bytes = 0
+    bmix_len = 0
+    bmix_half_len = 0
+    bmix_struct = None
+    integerify = None
+
+    #=================================================================
+    # frontend
+    #=================================================================
+    @classmethod
+    def execute(cls, secret, salt, n, r, p, keylen):
+        """create engine & run scrypt() hash calculation"""
+        return cls(n, r, p).run(secret, salt, keylen)
+
+    #=================================================================
+    # init
+    #=================================================================
+    def __init__(self, n, r, p):
+        # store config
+        self.n = n
+        self.r = r
+        self.p = p
+        self.smix_bytes = r << 7  # num bytes in smix input - 2*r*16*4
+        self.iv_bytes = self.smix_bytes * p
+        self.bmix_len = bmix_len = r << 5  # length of bmix block list - 32*r integers
+        self.bmix_half_len = r << 4
+        assert struct.calcsize("I") == 4
+        self.bmix_struct = struct.Struct("<" + str(bmix_len) + "I")
+
+        # use optimized bmix for certain cases
+        if r == 1:
+            self.bmix = self._bmix_1
+
+        # pick best integerify function - integerify(bmix_block) should
+        # take last 64 bytes of block and return a little-endian integer.
+        # since it's immediately converted % n, we only have to extract
+        # the first 32 bytes if n < 2**32 - which due to the current
+        # internal representation, is already unpacked as a 32-bit int.
+        if n <= 0xFFFFffff:
+            integerify = operator.itemgetter(-16)
+        else:
+            assert n <= 0xFFFFffffFFFFffff
+            ig1 = operator.itemgetter(-16)
+            ig2 = operator.itemgetter(-17)
+            def integerify(X):
+                return ig1(X) | (ig2(X)<<32)
+        self.integerify = integerify
+
+    #=================================================================
+    # frontend
+    #=================================================================
+    def run(self, secret, salt, keylen):
+        """
+        run scrypt kdf for specified secret, salt, and keylen
+
+        .. note::
+
+            * time cost is ``O(n * r * p)``
+            * mem cost is ``O(n * r)``
+        """
+        # stretch salt into initial byte array via pbkdf2
+        iv_bytes = self.iv_bytes
+        input = pbkdf2_hmac("sha256", secret, salt, rounds=1, keylen=iv_bytes)
+
+        # split initial byte array into 'p' mflen-sized chunks,
+        # and run each chunk through smix() to generate output chunk.
+        smix = self.smix
+        if self.p == 1:
+            output = smix(input)
+        else:
+            # XXX: *could* use threading here, if really high p values encountered,
+            #      but would tradeoff for more memory usage.
+            smix_bytes = self.smix_bytes
+            output = b''.join(
+                smix(input[offset:offset+smix_bytes])
+                for offset in range(0, iv_bytes, smix_bytes)
+            )
+
+        # stretch final byte array into output via pbkdf2
+        return pbkdf2_hmac("sha256", secret, output, rounds=1, keylen=keylen)
+
+    #=================================================================
+    # smix() helper
+    #=================================================================
+    def smix(self, input):
+        """run SCrypt smix function on a single input block
+
+        :arg input:
+            byte string containing input data.
+            interpreted as 32*r little endian 4 byte integers.
+
+        :returns:
+            byte string containing output data
+            derived by mixing input using n & r parameters.
+
+        .. note:: time & mem cost are both ``O(n * r)``
+        """
+        # gather locals
+        bmix = self.bmix
+        bmix_struct = self.bmix_struct
+        integerify = self.integerify
+        n = self.n
+
+        # parse input into 32*r integers ('X' in scrypt source)
+        # mem cost -- O(r)
+        buffer = list(bmix_struct.unpack(input))
+
+        # starting with initial buffer contents, derive V s.t.
+        # V[0]=initial_buffer ... V[i] = bmix(V[i-1], V[i-1]) ... V[n-1] = bmix(V[n-2], V[n-2])
+        # final buffer contents should equal bmix(V[n-1], V[n-1])
+        #
+        # time cost -- O(n * r) -- n loops, bmix is O(r)
+        # mem cost -- O(n * r) -- V is n-element array of r-element tuples
+        # NOTE: could do time / memory tradeoff to shrink size of V
+        def vgen():
+            i = 0
+            while i < n:
+                last = tuple(buffer)
+                yield last
+                bmix(last, buffer)
+                i += 1
+        V = list(vgen())
+
+        # generate result from X & V.
+        #
+        # time cost -- O(n * r) -- loops n times, calls bmix() which has O(r) time cost
+        # mem cost -- O(1) -- allocates nothing, calls bmix() which has O(1) mem cost
+        get_v_elem = V.__getitem__
+        n_mask = n - 1
+        i = 0
+        while i < n:
+            j = integerify(buffer) & n_mask
+            result = tuple(a ^ b for a, b in izip(buffer, get_v_elem(j)))
+            bmix(result, buffer)
+            i += 1
+
+        # # NOTE: we could easily support arbitrary values of ``n``, not just powers of 2,
+        # #       but very few implementations have that ability, so not enabling it for now...
+        # if not n_is_log_2:
+        # while i < n:
+        #     j = integerify(buffer) % n
+        #     tmp = tuple(a^b for a,b in izip(buffer, get_v_elem(j)))
+        #     bmix(tmp,buffer)
+        #     i += 1
+
+        # repack tmp
+        return bmix_struct.pack(*buffer)
+
+    #=================================================================
+    # bmix() helper
+    #=================================================================
+    def bmix(self, source, target):
+        """
+        block mixing function used by smix()
+        uses salsa20/8 core to mix block contents.
+
+        :arg source:
+            source to read from.
+            should be list of 32*r 4-byte integers
+            (2*r salsa20 blocks).
+
+        :arg target:
+            target to write to.
+            should be list with same size as source.
+            the existing value of this buffer is ignored.
+
+        .. warning::
+
+            this operates *in place* on target,
+            so source & target should NOT be same list.
+
+        .. note::
+
+            * time cost is ``O(r)`` -- loops 16*r times, salsa20() has ``O(1)`` cost.
+
+            * memory cost is ``O(1)`` -- salsa20() uses 16 x uint4,
+              all other operations done in-place.
+        """
+        ## assert source is not target
+        # Y[-1] = B[2r-1], Y[i] = hash( Y[i-1] xor B[i])
+        # B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
+        half = self.bmix_half_len # 16*r out of 32*r - start of Y_1
+        tmp = source[-16:] # 'X' in scrypt source
+        siter = iter(source)
+        j = 0
+        while j < half:
+            jn = j+16
+            target[j:jn] = tmp = salsa20(a ^ b for a, b in izip(tmp, siter))
+            target[half+j:half+jn] = tmp = salsa20(a ^ b for a, b in izip(tmp, siter))
+            j = jn
+
+    def _bmix_1(self, source, target):
+        """special bmix() method optimized for ``r=1`` case"""
+        B = source[16:]
+        target[:16] = tmp = salsa20(a ^ b for a, b in izip(B, iter(source)))
+        target[16:] = salsa20(a ^ b for a, b in izip(tmp, B))
+
+    #=================================================================
+    # eoc
+    #=================================================================
+
+#==========================================================================
+# eof
+#==========================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/_gen_files.py b/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/_gen_files.py
new file mode 100644
index 0000000..55ddfae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/_gen_files.py
@@ -0,0 +1,154 @@
+"""passlib.utils.scrypt._gen_files - meta script that generates _salsa.py"""
+#==========================================================================
+# imports
+#==========================================================================
+# core
+import os
+# pkg
+# local
+#==========================================================================
+# constants
+#==========================================================================
+
+_SALSA_OPS = [
+        # row = (target idx, source idx 1, source idx 2, rotate)
+        # interpreted as salsa operation over uint32...
+        #   target = (source1+source2)<<rotate
+
+        ##/* Operate on columns. */
+        ##define R(a,b) (((a) << (b)) | ((a) >> (32 - (b))))
+        ##x[ 4] ^= R(x[ 0]+x[12], 7);  x[ 8] ^= R(x[ 4]+x[ 0], 9);
+        ##x[12] ^= R(x[ 8]+x[ 4],13);  x[ 0] ^= R(x[12]+x[ 8],18);
+        (  4,  0, 12,  7),
+        (  8,  4,  0,  9),
+        ( 12,  8,  4, 13),
+        (  0, 12,  8, 18),
+
+        ##x[ 9] ^= R(x[ 5]+x[ 1], 7);  x[13] ^= R(x[ 9]+x[ 5], 9);
+        ##x[ 1] ^= R(x[13]+x[ 9],13);  x[ 5] ^= R(x[ 1]+x[13],18);
+        (  9,  5,  1,  7),
+        ( 13,  9,  5,  9),
+        (  1, 13,  9, 13),
+        (  5,  1, 13, 18),
+
+        ##x[14] ^= R(x[10]+x[ 6], 7);  x[ 2] ^= R(x[14]+x[10], 9);
+        ##x[ 6] ^= R(x[ 2]+x[14],13);  x[10] ^= R(x[ 6]+x[ 2],18);
+        ( 14, 10,  6,  7),
+        (  2, 14, 10,  9),
+        (  6,  2, 14, 13),
+        ( 10,  6,  2, 18),
+
+        ##x[ 3] ^= R(x[15]+x[11], 7);  x[ 7] ^= R(x[ 3]+x[15], 9);
+        ##x[11] ^= R(x[ 7]+x[ 3],13);  x[15] ^= R(x[11]+x[ 7],18);
+        (  3, 15, 11,  7),
+        (  7,  3, 15,  9),
+        ( 11,  7,  3, 13),
+        ( 15, 11,  7, 18),
+
+        ##/* Operate on rows. */
+        ##x[ 1] ^= R(x[ 0]+x[ 3], 7);  x[ 2] ^= R(x[ 1]+x[ 0], 9);
+        ##x[ 3] ^= R(x[ 2]+x[ 1],13);  x[ 0] ^= R(x[ 3]+x[ 2],18);
+        (  1,  0,  3,  7),
+        (  2,  1,  0,  9),
+        (  3,  2,  1, 13),
+        (  0,  3,  2, 18),
+
+        ##x[ 6] ^= R(x[ 5]+x[ 4], 7);  x[ 7] ^= R(x[ 6]+x[ 5], 9);
+        ##x[ 4] ^= R(x[ 7]+x[ 6],13);  x[ 5] ^= R(x[ 4]+x[ 7],18);
+        (  6,  5,  4,  7),
+        (  7,  6,  5,  9),
+        (  4,  7,  6, 13),
+        (  5,  4,  7, 18),
+
+        ##x[11] ^= R(x[10]+x[ 9], 7);  x[ 8] ^= R(x[11]+x[10], 9);
+        ##x[ 9] ^= R(x[ 8]+x[11],13);  x[10] ^= R(x[ 9]+x[ 8],18);
+        ( 11, 10,  9,  7),
+        (  8, 11, 10,  9),
+        (  9,  8, 11, 13),
+        ( 10,  9,  8, 18),
+
+        ##x[12] ^= R(x[15]+x[14], 7);  x[13] ^= R(x[12]+x[15], 9);
+        ##x[14] ^= R(x[13]+x[12],13);  x[15] ^= R(x[14]+x[13],18);
+        ( 12, 15, 14,  7),
+        ( 13, 12, 15,  9),
+        ( 14, 13, 12, 13),
+        ( 15, 14, 13, 18),
+]
+
+def main():
+    target = os.path.join(os.path.dirname(__file__), "_salsa.py")
+    fh = file(target, "w")
+    write = fh.write
+
+    VNAMES = ["v%d" % i for i in range(16)]
+
+    PAD = " " * 4
+    PAD2 = " " * 8
+    PAD3 = " " * 12
+    TLIST = ", ".join("b%d" % i for i in range(16))
+    VLIST = ", ".join(VNAMES)
+    kwds = dict(
+        VLIST=VLIST,
+        TLIST=TLIST,
+    )
+
+    write('''\
+"""passlib.utils.scrypt._salsa - salsa 20/8 core, autogenerated by _gen_salsa.py"""
+#=================================================================
+# salsa function
+#=================================================================
+
+def salsa20(input):
+    \"""apply the salsa20/8 core to the provided input
+
+    :args input: input list containing 16 32-bit integers
+    :returns: result list containing 16 32-bit integers
+    \"""
+
+    %(TLIST)s = input
+    %(VLIST)s = \\
+        %(TLIST)s
+
+    i = 0
+    while i < 4:
+''' % kwds)
+
+    for idx, (target, source1, source2, rotate) in enumerate(_SALSA_OPS):
+        write('''\
+        # salsa op %(idx)d: [%(it)d] ^= ([%(is1)d]+[%(is2)d])<<<%(rot1)d
+        t = (%(src1)s + %(src2)s) & 0xffffffff
+        %(dst)s ^= ((t & 0x%(rmask)08x) << %(rot1)d) | (t >> %(rot2)d)
+
+''' % dict(
+        idx=idx, is1 = source1, is2=source2, it=target,
+        src1=VNAMES[source1],
+        src2=VNAMES[source2],
+        dst=VNAMES[target],
+        rmask=(1<<(32-rotate))-1,
+        rot1=rotate,
+        rot2=32-rotate,
+    ))
+
+    write('''\
+        i += 1
+
+''')
+
+    for idx in range(16):
+        write(PAD + "b%d = (b%d + v%d) & 0xffffffff\n" % (idx,idx,idx))
+
+    write('''\
+
+    return %(TLIST)s
+
+#=================================================================
+# eof
+#=================================================================
+''' % kwds)
+        
+if __name__ == "__main__":
+    main()
+
+#==========================================================================
+# eof
+#==========================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/_salsa.py b/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/_salsa.py
new file mode 100644
index 0000000..9112732
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/crypto/scrypt/_salsa.py
@@ -0,0 +1,170 @@
+"""passlib.utils.scrypt._salsa - salsa 20/8 core, autogenerated by _gen_salsa.py"""
+#=================================================================
+# salsa function
+#=================================================================
+
+def salsa20(input):
+    """apply the salsa20/8 core to the provided input
+
+    :args input: input list containing 16 32-bit integers
+    :returns: result list containing 16 32-bit integers
+    """
+
+    b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15 = input
+    v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 = \
+        b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15
+
+    i = 0
+    while i < 4:
+        # salsa op 0: [4] ^= ([0]+[12])<<<7
+        t = (v0 + v12) & 0xffffffff
+        v4 ^= ((t & 0x01ffffff) << 7) | (t >> 25)
+
+        # salsa op 1: [8] ^= ([4]+[0])<<<9
+        t = (v4 + v0) & 0xffffffff
+        v8 ^= ((t & 0x007fffff) << 9) | (t >> 23)
+
+        # salsa op 2: [12] ^= ([8]+[4])<<<13
+        t = (v8 + v4) & 0xffffffff
+        v12 ^= ((t & 0x0007ffff) << 13) | (t >> 19)
+
+        # salsa op 3: [0] ^= ([12]+[8])<<<18
+        t = (v12 + v8) & 0xffffffff
+        v0 ^= ((t & 0x00003fff) << 18) | (t >> 14)
+
+        # salsa op 4: [9] ^= ([5]+[1])<<<7
+        t = (v5 + v1) & 0xffffffff
+        v9 ^= ((t & 0x01ffffff) << 7) | (t >> 25)
+
+        # salsa op 5: [13] ^= ([9]+[5])<<<9
+        t = (v9 + v5) & 0xffffffff
+        v13 ^= ((t & 0x007fffff) << 9) | (t >> 23)
+
+        # salsa op 6: [1] ^= ([13]+[9])<<<13
+        t = (v13 + v9) & 0xffffffff
+        v1 ^= ((t & 0x0007ffff) << 13) | (t >> 19)
+
+        # salsa op 7: [5] ^= ([1]+[13])<<<18
+        t = (v1 + v13) & 0xffffffff
+        v5 ^= ((t & 0x00003fff) << 18) | (t >> 14)
+
+        # salsa op 8: [14] ^= ([10]+[6])<<<7
+        t = (v10 + v6) & 0xffffffff
+        v14 ^= ((t & 0x01ffffff) << 7) | (t >> 25)
+
+        # salsa op 9: [2] ^= ([14]+[10])<<<9
+        t = (v14 + v10) & 0xffffffff
+        v2 ^= ((t & 0x007fffff) << 9) | (t >> 23)
+
+        # salsa op 10: [6] ^= ([2]+[14])<<<13
+        t = (v2 + v14) & 0xffffffff
+        v6 ^= ((t & 0x0007ffff) << 13) | (t >> 19)
+
+        # salsa op 11: [10] ^= ([6]+[2])<<<18
+        t = (v6 + v2) & 0xffffffff
+        v10 ^= ((t & 0x00003fff) << 18) | (t >> 14)
+
+        # salsa op 12: [3] ^= ([15]+[11])<<<7
+        t = (v15 + v11) & 0xffffffff
+        v3 ^= ((t & 0x01ffffff) << 7) | (t >> 25)
+
+        # salsa op 13: [7] ^= ([3]+[15])<<<9
+        t = (v3 + v15) & 0xffffffff
+        v7 ^= ((t & 0x007fffff) << 9) | (t >> 23)
+
+        # salsa op 14: [11] ^= ([7]+[3])<<<13
+        t = (v7 + v3) & 0xffffffff
+        v11 ^= ((t & 0x0007ffff) << 13) | (t >> 19)
+
+        # salsa op 15: [15] ^= ([11]+[7])<<<18
+        t = (v11 + v7) & 0xffffffff
+        v15 ^= ((t & 0x00003fff) << 18) | (t >> 14)
+
+        # salsa op 16: [1] ^= ([0]+[3])<<<7
+        t = (v0 + v3) & 0xffffffff
+        v1 ^= ((t & 0x01ffffff) << 7) | (t >> 25)
+
+        # salsa op 17: [2] ^= ([1]+[0])<<<9
+        t = (v1 + v0) & 0xffffffff
+        v2 ^= ((t & 0x007fffff) << 9) | (t >> 23)
+
+        # salsa op 18: [3] ^= ([2]+[1])<<<13
+        t = (v2 + v1) & 0xffffffff
+        v3 ^= ((t & 0x0007ffff) << 13) | (t >> 19)
+
+        # salsa op 19: [0] ^= ([3]+[2])<<<18
+        t = (v3 + v2) & 0xffffffff
+        v0 ^= ((t & 0x00003fff) << 18) | (t >> 14)
+
+        # salsa op 20: [6] ^= ([5]+[4])<<<7
+        t = (v5 + v4) & 0xffffffff
+        v6 ^= ((t & 0x01ffffff) << 7) | (t >> 25)
+
+        # salsa op 21: [7] ^= ([6]+[5])<<<9
+        t = (v6 + v5) & 0xffffffff
+        v7 ^= ((t & 0x007fffff) << 9) | (t >> 23)
+
+        # salsa op 22: [4] ^= ([7]+[6])<<<13
+        t = (v7 + v6) & 0xffffffff
+        v4 ^= ((t & 0x0007ffff) << 13) | (t >> 19)
+
+        # salsa op 23: [5] ^= ([4]+[7])<<<18
+        t = (v4 + v7) & 0xffffffff
+        v5 ^= ((t & 0x00003fff) << 18) | (t >> 14)
+
+        # salsa op 24: [11] ^= ([10]+[9])<<<7
+        t = (v10 + v9) & 0xffffffff
+        v11 ^= ((t & 0x01ffffff) << 7) | (t >> 25)
+
+        # salsa op 25: [8] ^= ([11]+[10])<<<9
+        t = (v11 + v10) & 0xffffffff
+        v8 ^= ((t & 0x007fffff) << 9) | (t >> 23)
+
+        # salsa op 26: [9] ^= ([8]+[11])<<<13
+        t = (v8 + v11) & 0xffffffff
+        v9 ^= ((t & 0x0007ffff) << 13) | (t >> 19)
+
+        # salsa op 27: [10] ^= ([9]+[8])<<<18
+        t = (v9 + v8) & 0xffffffff
+        v10 ^= ((t & 0x00003fff) << 18) | (t >> 14)
+
+        # salsa op 28: [12] ^= ([15]+[14])<<<7
+        t = (v15 + v14) & 0xffffffff
+        v12 ^= ((t & 0x01ffffff) << 7) | (t >> 25)
+
+        # salsa op 29: [13] ^= ([12]+[15])<<<9
+        t = (v12 + v15) & 0xffffffff
+        v13 ^= ((t & 0x007fffff) << 9) | (t >> 23)
+
+        # salsa op 30: [14] ^= ([13]+[12])<<<13
+        t = (v13 + v12) & 0xffffffff
+        v14 ^= ((t & 0x0007ffff) << 13) | (t >> 19)
+
+        # salsa op 31: [15] ^= ([14]+[13])<<<18
+        t = (v14 + v13) & 0xffffffff
+        v15 ^= ((t & 0x00003fff) << 18) | (t >> 14)
+
+        i += 1
+
+    b0 = (b0 + v0) & 0xffffffff
+    b1 = (b1 + v1) & 0xffffffff
+    b2 = (b2 + v2) & 0xffffffff
+    b3 = (b3 + v3) & 0xffffffff
+    b4 = (b4 + v4) & 0xffffffff
+    b5 = (b5 + v5) & 0xffffffff
+    b6 = (b6 + v6) & 0xffffffff
+    b7 = (b7 + v7) & 0xffffffff
+    b8 = (b8 + v8) & 0xffffffff
+    b9 = (b9 + v9) & 0xffffffff
+    b10 = (b10 + v10) & 0xffffffff
+    b11 = (b11 + v11) & 0xffffffff
+    b12 = (b12 + v12) & 0xffffffff
+    b13 = (b13 + v13) & 0xffffffff
+    b14 = (b14 + v14) & 0xffffffff
+    b15 = (b15 + v15) & 0xffffffff
+
+    return b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15
+
+#=================================================================
+# eof
+#=================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/exc.py b/myenv/lib/python3.9/site-packages/passlib/exc.py
new file mode 100644
index 0000000..755c7dc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/exc.py
@@ -0,0 +1,397 @@
+"""passlib.exc -- exceptions & warnings raised by passlib"""
+#=============================================================================
+# exceptions
+#=============================================================================
+class UnknownBackendError(ValueError):
+    """
+    Error raised if multi-backend handler doesn't recognize backend name.
+    Inherits from :exc:`ValueError`.
+
+    .. versionadded:: 1.7
+    """
+    def __init__(self, hasher, backend):
+        self.hasher = hasher
+        self.backend = backend
+        message = "%s: unknown backend: %r" % (hasher.name, backend)
+        ValueError.__init__(self, message)
+
+
+# XXX: add a PasslibRuntimeError as base for Missing/Internal/Security runtime errors?
+
+
+class MissingBackendError(RuntimeError):
+    """Error raised if multi-backend handler has no available backends;
+    or if specifically requested backend is not available.
+
+    :exc:`!MissingBackendError` derives
+    from :exc:`RuntimeError`, since it usually indicates
+    lack of an external library or OS feature.
+    This is primarily raised by handlers which depend on
+    external libraries (which is currently just
+    :class:`~passlib.hash.bcrypt`).
+    """
+
+
+class InternalBackendError(RuntimeError):
+    """
+    Error raised if something unrecoverable goes wrong with backend call;
+    such as if ``crypt.crypt()`` returning a malformed hash.
+
+    .. versionadded:: 1.7.3
+    """
+
+
+class PasswordValueError(ValueError):
+    """
+    Error raised if a password can't be hashed / verified for various reasons.
+    This exception derives from the builtin :exc:`!ValueError`.
+
+    May be thrown directly when password violates internal invariants of hasher
+    (e.g. some don't support NULL characters).  Hashers may also throw more specific subclasses,
+    such as :exc:`!PasswordSizeError`.
+
+    .. versionadded:: 1.7.3
+    """
+    pass
+
+
+class PasswordSizeError(PasswordValueError):
+    """
+    Error raised if a password exceeds the maximum size allowed
+    by Passlib (by default, 4096 characters); or if password exceeds
+    a hash-specific size limitation.
+
+    This exception derives from :exc:`PasswordValueError` (above).
+
+    Many password hash algorithms take proportionately larger amounts of time and/or
+    memory depending on the size of the password provided. This could present
+    a potential denial of service (DOS) situation if a maliciously large
+    password is provided to an application. Because of this, Passlib enforces
+    a maximum size limit, but one which should be *much* larger
+    than any legitimate password. :exc:`PasswordSizeError` derives
+    from :exc:`!ValueError`.
+
+    .. note::
+        Applications wishing to use a different limit should set the
+        ``PASSLIB_MAX_PASSWORD_SIZE`` environmental variable before
+        Passlib is loaded. The value can be any large positive integer.
+
+    .. attribute:: max_size
+
+        indicates the maximum allowed size.
+
+    .. versionadded:: 1.6
+    """
+
+    max_size = None
+
+    def __init__(self, max_size, msg=None):
+        self.max_size = max_size
+        if msg is None:
+            msg = "password exceeds maximum allowed size"
+        PasswordValueError.__init__(self, msg)
+
+    # this also prevents a glibc crypt segfault issue, detailed here ...
+    # http://www.openwall.com/lists/oss-security/2011/11/15/1
+
+class PasswordTruncateError(PasswordSizeError):
+    """
+    Error raised if password would be truncated by hash.
+    This derives from :exc:`PasswordSizeError` (above).
+
+    Hashers such as :class:`~passlib.hash.bcrypt` can be configured to raises
+    this error by setting ``truncate_error=True``.
+
+    .. attribute:: max_size
+
+        indicates the maximum allowed size.
+
+    .. versionadded:: 1.7
+    """
+
+    def __init__(self, cls, msg=None):
+        if msg is None:
+            msg = ("Password too long (%s truncates to %d characters)" %
+                   (cls.name, cls.truncate_size))
+        PasswordSizeError.__init__(self, cls.truncate_size, msg)
+
+
+class PasslibSecurityError(RuntimeError):
+    """
+    Error raised if critical security issue is detected
+    (e.g. an attempt is made to use a vulnerable version of a bcrypt backend).
+
+    .. versionadded:: 1.6.3
+    """
+
+
+class TokenError(ValueError):
+    """
+    Base error raised by v:mod:`passlib.totp` when
+    a token can't be parsed / isn't valid / etc.
+    Derives from :exc:`!ValueError`.
+
+    Usually one of the more specific subclasses below will be raised:
+
+    * :class:`MalformedTokenError` -- invalid chars, too few digits
+    * :class:`InvalidTokenError` -- no match found
+    * :class:`UsedTokenError` -- match found, but token already used
+
+    .. versionadded:: 1.7
+    """
+
+    #: default message to use if none provided -- subclasses may fill this in
+    _default_message = 'Token not acceptable'
+
+    def __init__(self, msg=None, *args, **kwds):
+        if msg is None:
+            msg = self._default_message
+        ValueError.__init__(self, msg, *args, **kwds)
+
+
+class MalformedTokenError(TokenError):
+    """
+    Error raised by :mod:`passlib.totp` when a token isn't formatted correctly
+    (contains invalid characters, wrong number of digits, etc)
+    """
+    _default_message = "Unrecognized token"
+
+
+class InvalidTokenError(TokenError):
+    """
+    Error raised by :mod:`passlib.totp` when a token is formatted correctly,
+    but doesn't match any tokens within valid range.
+    """
+    _default_message = "Token did not match"
+
+
+class UsedTokenError(TokenError):
+    """
+    Error raised by :mod:`passlib.totp` if a token is reused.
+    Derives from :exc:`TokenError`.
+
+    .. autoattribute:: expire_time
+
+    .. versionadded:: 1.7
+    """
+    _default_message = "Token has already been used, please wait for another."
+
+    #: optional value indicating when current counter period will end,
+    #: and a new token can be generated.
+    expire_time = None
+
+    def __init__(self, *args, **kwds):
+        self.expire_time = kwds.pop("expire_time", None)
+        TokenError.__init__(self, *args, **kwds)
+
+
+class UnknownHashError(ValueError):
+    """
+    Error raised by :class:`~passlib.crypto.lookup_hash` if hash name is not recognized.
+    This exception derives from :exc:`!ValueError`.
+
+    As of version 1.7.3, this may also be raised if hash algorithm is known,
+    but has been disabled due to FIPS mode (message will include phrase "disabled for fips").
+
+    As of version 1.7.4, this may be raised if a :class:`~passlib.context.CryptContext`
+    is unable to identify the algorithm used by a password hash.
+
+    .. versionadded:: 1.7
+
+    .. versionchanged: 1.7.3
+        added 'message' argument.
+
+    .. versionchanged:: 1.7.4
+        altered call signature.
+    """
+    def __init__(self, message=None, value=None):
+        self.value = value
+        if message is None:
+            message = "unknown hash algorithm: %r" % value
+        self.message = message
+        ValueError.__init__(self, message, value)
+
+    def __str__(self):
+        return self.message
+
+
+#=============================================================================
+# warnings
+#=============================================================================
+class PasslibWarning(UserWarning):
+    """base class for Passlib's user warnings,
+    derives from the builtin :exc:`UserWarning`.
+
+    .. versionadded:: 1.6
+    """
+
+# XXX: there's only one reference to this class, and it will go away in 2.0;
+#      so can probably remove this along with this / roll this into PasslibHashWarning.
+class PasslibConfigWarning(PasslibWarning):
+    """Warning issued when non-fatal issue is found related to the configuration
+    of a :class:`~passlib.context.CryptContext` instance.
+
+    This occurs primarily in one of two cases:
+
+    * The CryptContext contains rounds limits which exceed the hard limits
+      imposed by the underlying algorithm.
+    * An explicit rounds value was provided which exceeds the limits
+      imposed by the CryptContext.
+
+    In both of these cases, the code will perform correctly & securely;
+    but the warning is issued as a sign the configuration may need updating.
+
+    .. versionadded:: 1.6
+    """
+
+class PasslibHashWarning(PasslibWarning):
+    """Warning issued when non-fatal issue is found with parameters
+    or hash string passed to a passlib hash class.
+
+    This occurs primarily in one of two cases:
+
+    * A rounds value or other setting was explicitly provided which
+      exceeded the handler's limits (and has been clamped
+      by the :ref:`relaxed<relaxed-keyword>` flag).
+
+    * A malformed hash string was encountered which (while parsable)
+      should be re-encoded.
+
+    .. versionadded:: 1.6
+    """
+
+class PasslibRuntimeWarning(PasslibWarning):
+    """Warning issued when something unexpected happens during runtime.
+
+    The fact that it's a warning instead of an error means Passlib
+    was able to correct for the issue, but that it's anomalous enough
+    that the developers would love to hear under what conditions it occurred.
+
+    .. versionadded:: 1.6
+    """
+
+class PasslibSecurityWarning(PasslibWarning):
+    """Special warning issued when Passlib encounters something
+    that might affect security.
+
+    .. versionadded:: 1.6
+    """
+
+#=============================================================================
+# error constructors
+#
+# note: these functions are used by the hashes in Passlib to raise common
+# error messages. They are currently just functions which return ValueError,
+# rather than subclasses of ValueError, since the specificity isn't needed
+# yet; and who wants to import a bunch of error classes when catching
+# ValueError will do?
+#=============================================================================
+
+def _get_name(handler):
+    return handler.name if handler else "<unnamed>"
+
+#------------------------------------------------------------------------
+# generic helpers
+#------------------------------------------------------------------------
+def type_name(value):
+    """return pretty-printed string containing name of value's type"""
+    cls = value.__class__
+    if cls.__module__ and cls.__module__ not in ["__builtin__", "builtins"]:
+        return "%s.%s" % (cls.__module__, cls.__name__)
+    elif value is None:
+        return 'None'
+    else:
+        return cls.__name__
+
+def ExpectedTypeError(value, expected, param):
+    """error message when param was supposed to be one type, but found another"""
+    # NOTE: value is never displayed, since it may sometimes be a password.
+    name = type_name(value)
+    return TypeError("%s must be %s, not %s" % (param, expected, name))
+
+def ExpectedStringError(value, param):
+    """error message when param was supposed to be unicode or bytes"""
+    return ExpectedTypeError(value, "unicode or bytes", param)
+
+#------------------------------------------------------------------------
+# hash/verify parameter errors
+#------------------------------------------------------------------------
+def MissingDigestError(handler=None):
+    """raised when verify() method gets passed config string instead of hash"""
+    name = _get_name(handler)
+    return ValueError("expected %s hash, got %s config string instead" %
+                     (name, name))
+
+def NullPasswordError(handler=None):
+    """raised by OS crypt() supporting hashes, which forbid NULLs in password"""
+    name = _get_name(handler)
+    return PasswordValueError("%s does not allow NULL bytes in password" % name)
+
+#------------------------------------------------------------------------
+# errors when parsing hashes
+#------------------------------------------------------------------------
+def InvalidHashError(handler=None):
+    """error raised if unrecognized hash provided to handler"""
+    return ValueError("not a valid %s hash" % _get_name(handler))
+
+def MalformedHashError(handler=None, reason=None):
+    """error raised if recognized-but-malformed hash provided to handler"""
+    text = "malformed %s hash" % _get_name(handler)
+    if reason:
+        text = "%s (%s)" % (text, reason)
+    return ValueError(text)
+
+def ZeroPaddedRoundsError(handler=None):
+    """error raised if hash was recognized but contained zero-padded rounds field"""
+    return MalformedHashError(handler, "zero-padded rounds")
+
+#------------------------------------------------------------------------
+# settings / hash component errors
+#------------------------------------------------------------------------
+def ChecksumSizeError(handler, raw=False):
+    """error raised if hash was recognized, but checksum was wrong size"""
+    # TODO: if handler.use_defaults is set, this came from app-provided value,
+    # not from parsing a hash string, might want different error msg.
+    checksum_size = handler.checksum_size
+    unit = "bytes" if raw else "chars"
+    reason = "checksum must be exactly %d %s" % (checksum_size, unit)
+    return MalformedHashError(handler, reason)
+
+#=============================================================================
+# sensitive info helpers
+#=============================================================================
+
+#: global flag, set temporarily by UTs to allow debug_only_repr() to display sensitive values.
+ENABLE_DEBUG_ONLY_REPR = False
+
+
+def debug_only_repr(value, param="hash"):
+    """
+    helper used to display sensitive data (hashes etc) within error messages.
+    currently returns placeholder test UNLESS unittests are running,
+    in which case the real value is displayed.
+
+    mainly useful to prevent hashes / secrets from being exposed in production tracebacks;
+    while still being visible from test failures.
+
+    NOTE: api subject to change, may formalize this more in the future.
+    """
+    if ENABLE_DEBUG_ONLY_REPR or value is None or isinstance(value, bool):
+        return repr(value)
+    return "<%s %s value omitted>" % (param, type(value))
+
+
+def CryptBackendError(handler, config, hash,  # *
+                      source="crypt.crypt()"):
+    """
+    helper to generate standard message when ``crypt.crypt()`` returns invalid result.
+    takes care of automatically masking contents of config & hash outside of UTs.
+    """
+    name = _get_name(handler)
+    msg = "%s returned invalid %s hash: config=%s hash=%s" % \
+          (source, name, debug_only_repr(config), debug_only_repr(hash))
+    raise InternalBackendError(msg)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/ext/__init__.py b/myenv/lib/python3.9/site-packages/passlib/ext/__init__.py
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/ext/__init__.py
@@ -0,0 +1 @@
+
diff --git a/myenv/lib/python3.9/site-packages/passlib/ext/django/__init__.py b/myenv/lib/python3.9/site-packages/passlib/ext/django/__init__.py
new file mode 100644
index 0000000..2dc9b28
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/ext/django/__init__.py
@@ -0,0 +1,6 @@
+"""passlib.ext.django.models -- monkeypatch django hashing framework
+
+this plugin monkeypatches django's hashing framework
+so that it uses a passlib context object, allowing handling of arbitrary
+hashes in Django databases.
+"""
diff --git a/myenv/lib/python3.9/site-packages/passlib/ext/django/models.py b/myenv/lib/python3.9/site-packages/passlib/ext/django/models.py
new file mode 100644
index 0000000..e766c2d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/ext/django/models.py
@@ -0,0 +1,36 @@
+"""passlib.ext.django.models -- monkeypatch django hashing framework"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+# site
+# pkg
+from passlib.context import CryptContext
+from passlib.ext.django.utils import DjangoContextAdapter
+# local
+__all__ = ["password_context"]
+
+#=============================================================================
+# global attrs
+#=============================================================================
+
+#: adapter instance used to drive most of this
+adapter = DjangoContextAdapter()
+
+# the context object which this patches contrib.auth to use for password hashing.
+# configuration controlled by ``settings.PASSLIB_CONFIG``.
+password_context = adapter.context
+
+#: hook callers should use if context is changed
+context_changed = adapter.reset_hashers
+
+#=============================================================================
+# main code
+#=============================================================================
+
+# load config & install monkeypatch
+adapter.load_model()
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/ext/django/utils.py b/myenv/lib/python3.9/site-packages/passlib/ext/django/utils.py
new file mode 100644
index 0000000..2f8a2ef
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/ext/django/utils.py
@@ -0,0 +1,1276 @@
+"""passlib.ext.django.utils - helper functions used by this plugin"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from functools import update_wrapper, wraps
+import logging; log = logging.getLogger(__name__)
+import sys
+import weakref
+from warnings import warn
+# site
+try:
+    from django import VERSION as DJANGO_VERSION
+    log.debug("found django %r installation", DJANGO_VERSION)
+except ImportError:
+    log.debug("django installation not found")
+    DJANGO_VERSION = ()
+# pkg
+from passlib import exc, registry
+from passlib.context import CryptContext
+from passlib.exc import PasslibRuntimeWarning
+from passlib.utils.compat import get_method_function, iteritems, OrderedDict, unicode
+from passlib.utils.decor import memoized_property
+# local
+__all__ = [
+    "DJANGO_VERSION",
+    "MIN_DJANGO_VERSION",
+    "get_preset_config",
+    "quirks",
+]
+
+#: minimum version supported by passlib.ext.django
+MIN_DJANGO_VERSION = (1, 8)
+
+#=============================================================================
+# quirk detection
+#=============================================================================
+
+class quirks:
+
+    #: django check_password() started throwing error on encoded=None
+    #: (really identify_hasher did)
+    none_causes_check_password_error = DJANGO_VERSION >= (2, 1)
+
+    #: django is_usable_password() started returning True for password = {None, ""} values.
+    empty_is_usable_password = DJANGO_VERSION >= (2, 1)
+
+    #: django is_usable_password() started returning True for non-hash strings in 2.1
+    invalid_is_usable_password = DJANGO_VERSION >= (2, 1)
+
+#=============================================================================
+# default policies
+#=============================================================================
+
+# map preset names -> passlib.app attrs
+_preset_map = {
+    "django-1.0": "django10_context",
+    "django-1.4": "django14_context",
+    "django-1.6": "django16_context",
+    "django-latest": "django_context",
+}
+
+def get_preset_config(name):
+    """Returns configuration string for one of the preset strings
+    supported by the ``PASSLIB_CONFIG`` setting.
+    Currently supported presets:
+
+    * ``"passlib-default"`` - default config used by this release of passlib.
+    * ``"django-default"`` - config matching currently installed django version.
+    * ``"django-latest"`` - config matching newest django version (currently same as ``"django-1.6"``).
+    * ``"django-1.0"`` - config used by stock Django 1.0 - 1.3 installs
+    * ``"django-1.4"`` - config used by stock Django 1.4 installs
+    * ``"django-1.6"`` - config used by stock Django 1.6 installs
+    """
+    # TODO: add preset which includes HASHERS + PREFERRED_HASHERS,
+    #       after having imported any custom hashers. e.g. "django-current"
+    if name == "django-default":
+        if not DJANGO_VERSION:
+            raise ValueError("can't resolve django-default preset, "
+                             "django not installed")
+        name = "django-1.6"
+    if name == "passlib-default":
+        return PASSLIB_DEFAULT
+    try:
+        attr = _preset_map[name]
+    except KeyError:
+        raise ValueError("unknown preset config name: %r" % name)
+    import passlib.apps
+    return getattr(passlib.apps, attr).to_string()
+
+# default context used by passlib 1.6
+PASSLIB_DEFAULT = """
+[passlib]
+
+; list of schemes supported by configuration
+; currently all django 1.6, 1.4, and 1.0 hashes,
+; and three common modular crypt format hashes.
+schemes =
+    django_pbkdf2_sha256, django_pbkdf2_sha1, django_bcrypt, django_bcrypt_sha256,
+    django_salted_sha1, django_salted_md5, django_des_crypt, hex_md5,
+    sha512_crypt, bcrypt, phpass
+
+; default scheme to use for new hashes
+default = django_pbkdf2_sha256
+
+; hashes using these schemes will automatically be re-hashed
+; when the user logs in (currently all django 1.0 hashes)
+deprecated =
+    django_pbkdf2_sha1, django_salted_sha1, django_salted_md5,
+    django_des_crypt, hex_md5
+
+; sets some common options, including minimum rounds for two primary hashes.
+; if a hash has less than this number of rounds, it will be re-hashed.
+sha512_crypt__min_rounds = 80000
+django_pbkdf2_sha256__min_rounds = 10000
+
+; set somewhat stronger iteration counts for ``User.is_staff``
+staff__sha512_crypt__default_rounds = 100000
+staff__django_pbkdf2_sha256__default_rounds = 12500
+
+; and even stronger ones for ``User.is_superuser``
+superuser__sha512_crypt__default_rounds = 120000
+superuser__django_pbkdf2_sha256__default_rounds = 15000
+"""
+
+#=============================================================================
+# helpers
+#=============================================================================
+
+#: prefix used to shoehorn passlib's handler names into django hasher namespace
+PASSLIB_WRAPPER_PREFIX = "passlib_"
+
+#: prefix used by all the django-specific hash formats in passlib;
+#: all of these hashes should have a ``.django_name`` attribute.
+DJANGO_COMPAT_PREFIX = "django_"
+
+#: set of hashes w/o "django_" prefix, but which also expose ``.django_name``.
+_other_django_hashes = set(["hex_md5"])
+
+def _wrap_method(method):
+    """wrap method object in bare function"""
+    @wraps(method)
+    def wrapper(*args, **kwds):
+        return method(*args, **kwds)
+    return wrapper
+
+#=============================================================================
+# translator
+#=============================================================================
+class DjangoTranslator(object):
+    """
+    Object which helps translate passlib hasher objects / names
+    to and from django hasher objects / names.
+
+    These methods are wrapped in a class so that results can be cached,
+    but with the ability to have independant caches, since django hasher
+    names may / may not correspond to the same instance (or even class).
+    """
+    #=============================================================================
+    # instance attrs
+    #=============================================================================
+
+    #: CryptContext instance
+    #: (if any -- generally only set by DjangoContextAdapter subclass)
+    context = None
+
+    #: internal cache of passlib hasher -> django hasher instance.
+    #: key stores weakref to passlib hasher.
+    _django_hasher_cache = None
+
+    #: special case -- unsalted_sha1
+    _django_unsalted_sha1 = None
+
+    #: internal cache of django name -> passlib hasher
+    #: value stores weakrefs to passlib hasher.
+    _passlib_hasher_cache = None
+
+    #=============================================================================
+    # init
+    #=============================================================================
+
+    def __init__(self, context=None, **kwds):
+        super(DjangoTranslator, self).__init__(**kwds)
+        if context is not None:
+            self.context = context
+
+        self._django_hasher_cache = weakref.WeakKeyDictionary()
+        self._passlib_hasher_cache = weakref.WeakValueDictionary()
+
+    def reset_hashers(self):
+        self._django_hasher_cache.clear()
+        self._passlib_hasher_cache.clear()
+        self._django_unsalted_sha1 = None
+
+    def _get_passlib_hasher(self, passlib_name):
+        """
+        resolve passlib hasher by name, using context if available.
+        """
+        context = self.context
+        if context is None:
+            return registry.get_crypt_handler(passlib_name)
+        else:
+            return context.handler(passlib_name)
+
+    #=============================================================================
+    # resolve passlib hasher -> django hasher
+    #=============================================================================
+
+    def passlib_to_django_name(self, passlib_name):
+        """
+        Convert passlib hasher / name to Django hasher name.
+        """
+        return self.passlib_to_django(passlib_name).algorithm
+
+    # XXX: add option (in class, or call signature) to always return a wrapper,
+    #      rather than native builtin -- would let HashersTest check that
+    #      our own wrapper + implementations are matching up with their tests.
+    def passlib_to_django(self, passlib_hasher, cached=True):
+        """
+        Convert passlib hasher / name to Django hasher.
+
+        :param passlib_hasher:
+            passlib hasher / name
+
+        :returns:
+            django hasher instance
+        """
+        # resolve names to hasher
+        if not hasattr(passlib_hasher, "name"):
+            passlib_hasher = self._get_passlib_hasher(passlib_hasher)
+
+        # check cache
+        if cached:
+            cache = self._django_hasher_cache
+            try:
+                return cache[passlib_hasher]
+            except KeyError:
+                pass
+            result = cache[passlib_hasher] = \
+                self.passlib_to_django(passlib_hasher, cached=False)
+            return result
+
+        # find native equivalent, and return wrapper if there isn't one
+        django_name = getattr(passlib_hasher, "django_name", None)
+        if django_name:
+            return self._create_django_hasher(django_name)
+        else:
+            return _PasslibHasherWrapper(passlib_hasher)
+
+    _builtin_django_hashers = dict(
+        md5="MD5PasswordHasher",
+    )
+
+    if DJANGO_VERSION > (2, 1):
+        # present but disabled by default as of django 2.1; not sure when added,
+        # so not listing it by default.
+        _builtin_django_hashers.update(
+            bcrypt="BCryptPasswordHasher",
+        )
+
+    def _create_django_hasher(self, django_name):
+        """
+        helper to create new django hasher by name.
+        wraps underlying django methods.
+        """
+        # if we haven't patched django, can use it directly
+        module = sys.modules.get("passlib.ext.django.models")
+        if module is None or not module.adapter.patched:
+            from django.contrib.auth.hashers import get_hasher
+            try:
+                return get_hasher(django_name)
+            except ValueError as err:
+                if not str(err).startswith("Unknown password hashing algorithm"):
+                    raise
+        else:
+            # We've patched django's get_hashers(), so calling django's get_hasher()
+            # or get_hashers_by_algorithm() would only land us back here.
+            # As non-ideal workaround, have to use original get_hashers(),
+            get_hashers = module.adapter._manager.getorig("django.contrib.auth.hashers:get_hashers").__wrapped__
+            for hasher in get_hashers():
+                if hasher.algorithm == django_name:
+                    return hasher
+
+        # hardcode a few for cases where get_hashers() lookup won't work
+        # (mainly, hashers that are present in django, but disabled by their default config)
+        path = self._builtin_django_hashers.get(django_name)
+        if path:
+            if "." not in path:
+                path = "django.contrib.auth.hashers." + path
+            from django.utils.module_loading import import_string
+            return import_string(path)()
+
+        raise ValueError("unknown hasher: %r" % django_name)
+
+    #=============================================================================
+    # reverse django -> passlib
+    #=============================================================================
+
+    def django_to_passlib_name(self, django_name):
+        """
+        Convert Django hasher / name to Passlib hasher name.
+        """
+        return self.django_to_passlib(django_name).name
+
+    def django_to_passlib(self, django_name, cached=True):
+        """
+        Convert Django hasher / name to Passlib hasher / name.
+        If present, CryptContext will be checked instead of main registry.
+
+        :param django_name:
+            Django hasher class or algorithm name.
+            "default" allowed if context provided.
+
+        :raises ValueError:
+            if can't resolve hasher.
+
+        :returns:
+            passlib hasher or name
+        """
+        # check for django hasher
+        if hasattr(django_name, "algorithm"):
+
+            # check for passlib adapter
+            if isinstance(django_name, _PasslibHasherWrapper):
+                return django_name.passlib_handler
+
+            # resolve django hasher -> name
+            django_name = django_name.algorithm
+
+        # check cache
+        if cached:
+            cache = self._passlib_hasher_cache
+            try:
+                return cache[django_name]
+            except KeyError:
+                pass
+            result = cache[django_name] = \
+                self.django_to_passlib(django_name, cached=False)
+            return result
+
+        # check if it's an obviously-wrapped name
+        if django_name.startswith(PASSLIB_WRAPPER_PREFIX):
+            passlib_name = django_name[len(PASSLIB_WRAPPER_PREFIX):]
+            return self._get_passlib_hasher(passlib_name)
+
+        # resolve default
+        if django_name == "default":
+            context = self.context
+            if context is None:
+                raise TypeError("can't determine default scheme w/ context")
+            return context.handler()
+
+        # special case: Django uses a separate hasher for "sha1$$digest"
+        # hashes (unsalted_sha1) and "sha1$salt$digest" (sha1);
+        # but passlib uses "django_salted_sha1" for both of these.
+        if django_name == "unsalted_sha1":
+            django_name = "sha1"
+
+        # resolve name
+        # XXX: bother caching these lists / mapping?
+        #      not needed in long-term due to cache above.
+        context = self.context
+        if context is None:
+            # check registry
+            # TODO: should make iteration via registry easier
+            candidates = (
+                registry.get_crypt_handler(passlib_name)
+                for passlib_name in registry.list_crypt_handlers()
+                if passlib_name.startswith(DJANGO_COMPAT_PREFIX) or
+                   passlib_name in _other_django_hashes
+            )
+        else:
+            # check context
+            candidates = context.schemes(resolve=True)
+        for handler in candidates:
+            if getattr(handler, "django_name", None) == django_name:
+                return handler
+
+        # give up
+        # NOTE: this should only happen for custom django hashers that we don't
+        #       know the equivalents for. _HasherHandler (below) is work in
+        #       progress that would allow us to at least return a wrapper.
+        raise ValueError("can't translate django name to passlib name: %r" %
+                         (django_name,))
+
+    #=============================================================================
+    # django hasher lookup
+    #=============================================================================
+
+    def resolve_django_hasher(self, django_name, cached=True):
+        """
+        Take in a django algorithm name, return django hasher.
+        """
+        # check for django hasher
+        if hasattr(django_name, "algorithm"):
+            return django_name
+
+        # resolve to passlib hasher
+        passlib_hasher = self.django_to_passlib(django_name, cached=cached)
+
+        # special case: Django uses a separate hasher for "sha1$$digest"
+        # hashes (unsalted_sha1) and "sha1$salt$digest" (sha1);
+        # but passlib uses "django_salted_sha1" for both of these.
+        # XXX: this isn't ideal way to handle this.  would like to do something
+        #      like pass "django_variant=django_name" into passlib_to_django(),
+        #      and have it cache separate hasher there.
+        #      but that creates a LOT of complication in it's cache structure,
+        #      for what is just one special case.
+        if django_name == "unsalted_sha1" and passlib_hasher.name == "django_salted_sha1":
+            if not cached:
+                return self._create_django_hasher(django_name)
+            result = self._django_unsalted_sha1
+            if result is None:
+                result = self._django_unsalted_sha1 = self._create_django_hasher(django_name)
+            return result
+
+        # lookup corresponding django hasher
+        return self.passlib_to_django(passlib_hasher, cached=cached)
+
+    #=============================================================================
+    # eoc
+    #=============================================================================
+
+#=============================================================================
+# adapter
+#=============================================================================
+class DjangoContextAdapter(DjangoTranslator):
+    """
+    Object which tries to adapt a Passlib CryptContext object,
+    using a Django-hasher compatible API.
+
+    When installed in django, :mod:`!passlib.ext.django` will create
+    an instance of this class, and then monkeypatch the appropriate
+    methods into :mod:`!django.contrib.auth` and other appropriate places.
+    """
+    #=============================================================================
+    # instance attrs
+    #=============================================================================
+
+    #: CryptContext instance we're wrapping
+    context = None
+
+    #: ref to original make_password(),
+    #: needed to generate usuable passwords that match django
+    _orig_make_password = None
+
+    #: ref to django helper of this name -- not monkeypatched
+    is_password_usable = None
+
+    #: PatchManager instance used to track installation
+    _manager = None
+
+    #: whether config=disabled flag was set
+    enabled = True
+
+    #: patch status
+    patched = False
+
+    #=============================================================================
+    # init
+    #=============================================================================
+    def __init__(self, context=None, get_user_category=None, **kwds):
+
+        # init log
+        self.log = logging.getLogger(__name__ + ".DjangoContextAdapter")
+
+        # init parent, filling in default context object
+        if context is None:
+            context = CryptContext()
+        super(DjangoContextAdapter, self).__init__(context=context, **kwds)
+
+        # setup user category
+        if get_user_category:
+            assert callable(get_user_category)
+            self.get_user_category = get_user_category
+
+        # install lru cache wrappers
+        try:
+            from functools import lru_cache  # new py32
+        except ImportError:
+            from django.utils.lru_cache import lru_cache  # py2 compat, removed in django 3 (or earlier?)
+        self.get_hashers = lru_cache()(self.get_hashers)
+
+        # get copy of original make_password
+        from django.contrib.auth.hashers import make_password
+        if make_password.__module__.startswith("passlib."):
+            make_password = _PatchManager.peek_unpatched_func(make_password)
+        self._orig_make_password = make_password
+
+        # get other django helpers
+        from django.contrib.auth.hashers import is_password_usable
+        self.is_password_usable = is_password_usable
+
+        # init manager
+        mlog = logging.getLogger(__name__ + ".DjangoContextAdapter._manager")
+        self._manager = _PatchManager(log=mlog)
+
+    def reset_hashers(self):
+        """
+        Wrapper to manually reset django's hasher lookup cache
+        """
+        # resets cache for .get_hashers() & .get_hashers_by_algorithm()
+        from django.contrib.auth.hashers import reset_hashers
+        reset_hashers(setting="PASSWORD_HASHERS")
+
+        # reset internal caches
+        super(DjangoContextAdapter, self).reset_hashers()
+
+    #=============================================================================
+    # django hashers helpers -- hasher lookup
+    #=============================================================================
+
+    # lru_cache()'ed by init
+    def get_hashers(self):
+        """
+        Passlib replacement for get_hashers() --
+        Return list of available django hasher classes
+        """
+        passlib_to_django = self.passlib_to_django
+        return [passlib_to_django(hasher)
+                for hasher in self.context.schemes(resolve=True)]
+
+    def get_hasher(self, algorithm="default"):
+        """
+        Passlib replacement for get_hasher() --
+        Return django hasher by name
+        """
+        return self.resolve_django_hasher(algorithm)
+
+    def identify_hasher(self, encoded):
+        """
+        Passlib replacement for identify_hasher() --
+        Identify django hasher based on hash.
+        """
+        handler = self.context.identify(encoded, resolve=True, required=True)
+        if handler.name == "django_salted_sha1" and encoded.startswith("sha1$$"):
+            # Django uses a separate hasher for "sha1$$digest" hashes, but
+            # passlib identifies it as belonging to "sha1$salt$digest" handler.
+            # We want to resolve to correct django hasher.
+            return self.get_hasher("unsalted_sha1")
+        return self.passlib_to_django(handler)
+
+    #=============================================================================
+    # django.contrib.auth.hashers helpers -- password helpers
+    #=============================================================================
+
+    def make_password(self, password, salt=None, hasher="default"):
+        """
+        Passlib replacement for make_password()
+        """
+        if password is None:
+            return self._orig_make_password(None)
+        # NOTE: relying on hasher coming from context, and thus having
+        #       context-specific config baked into it.
+        passlib_hasher = self.django_to_passlib(hasher)
+        if "salt" not in passlib_hasher.setting_kwds:
+            # ignore salt param even if preset
+            pass
+        elif hasher.startswith("unsalted_"):
+            # Django uses a separate 'unsalted_sha1' hasher for "sha1$$digest",
+            # but passlib just reuses it's "sha1" handler ("sha1$salt$digest"). To make
+            # this work, have to explicitly tell the sha1 handler to use an empty salt.
+            passlib_hasher = passlib_hasher.using(salt="")
+        elif salt:
+            # Django make_password() autogenerates a salt if salt is bool False (None / ''),
+            # so we only pass the keyword on if there's actually a fixed salt.
+            passlib_hasher = passlib_hasher.using(salt=salt)
+        return passlib_hasher.hash(password)
+
+    def check_password(self, password, encoded, setter=None, preferred="default"):
+        """
+        Passlib replacement for check_password()
+        """
+        # XXX: this currently ignores "preferred" keyword, since its purpose
+        #      was for hash migration, and that's handled by the context.
+        # XXX: honor "none_causes_check_password_error" quirk for django 2.2+?
+        #      seems safer to return False.
+        if password is None or not self.is_password_usable(encoded):
+            return False
+
+        # verify password
+        context = self.context
+        try:
+            correct = context.verify(password, encoded)
+        except exc.UnknownHashError:
+            # As of django 1.5, unidentifiable hashes returns False
+            # (side-effect of django issue 18453)
+            return False
+
+        if not (correct and setter):
+            return correct
+
+        # check if we need to rehash
+        if preferred == "default":
+            if not context.needs_update(encoded, secret=password):
+                return correct
+        else:
+            # Django's check_password() won't call setter() on a
+            # 'preferred' alg, even if it's otherwise deprecated. To try and
+            # replicate this behavior if preferred is set, we look up the
+            # passlib hasher, and call it's original needs_update() method.
+            # TODO: Solve redundancy that verify() call
+            #       above is already identifying hash.
+            hasher = self.django_to_passlib(preferred)
+            if (hasher.identify(encoded) and
+                    not hasher.needs_update(encoded, secret=password)):
+                # alg is 'preferred' and hash itself doesn't need updating,
+                # so nothing to do.
+                return correct
+            # else: either hash isn't preferred, or it needs updating.
+
+        # call setter to rehash
+        setter(password)
+        return correct
+
+    #=============================================================================
+    # django users helpers
+    #=============================================================================
+
+    def user_check_password(self, user, password):
+        """
+        Passlib replacement for User.check_password()
+        """
+        if password is None:
+            return False
+        hash = user.password
+        if not self.is_password_usable(hash):
+            return False
+        cat = self.get_user_category(user)
+        try:
+            ok, new_hash = self.context.verify_and_update(password, hash, category=cat)
+        except exc.UnknownHashError:
+            # As of django 1.5, unidentifiable hashes returns False
+            # (side-effect of django issue 18453)
+            return False
+        if ok and new_hash is not None:
+            # migrate to new hash if needed.
+            user.password = new_hash
+            user.save()
+        return ok
+
+    def user_set_password(self, user, password):
+        """
+        Passlib replacement for User.set_password()
+        """
+        if password is None:
+            user.set_unusable_password()
+        else:
+            cat = self.get_user_category(user)
+            user.password = self.context.hash(password, category=cat)
+
+    def get_user_category(self, user):
+        """
+        Helper for hashing passwords per-user --
+        figure out the CryptContext category for specified Django user object.
+        .. note::
+            This may be overridden via PASSLIB_GET_CATEGORY django setting
+        """
+        if user.is_superuser:
+            return "superuser"
+        elif user.is_staff:
+            return "staff"
+        else:
+            return None
+
+    #=============================================================================
+    # patch control
+    #=============================================================================
+
+    HASHERS_PATH = "django.contrib.auth.hashers"
+    MODELS_PATH = "django.contrib.auth.models"
+    USER_CLASS_PATH = MODELS_PATH + ":User"
+    FORMS_PATH = "django.contrib.auth.forms"
+
+    #: list of locations to patch
+    patch_locations = [
+        #
+        # User object
+        # NOTE: could leave defaults alone, but want to have user available
+        #       so that we can support get_user_category()
+        #
+        (USER_CLASS_PATH + ".check_password", "user_check_password", dict(method=True)),
+        (USER_CLASS_PATH + ".set_password", "user_set_password", dict(method=True)),
+
+        #
+        # Hashers module
+        #
+        (HASHERS_PATH + ":", "check_password"),
+        (HASHERS_PATH + ":", "make_password"),
+        (HASHERS_PATH + ":", "get_hashers"),
+        (HASHERS_PATH + ":", "get_hasher"),
+        (HASHERS_PATH + ":", "identify_hasher"),
+
+        #
+        # Patch known imports from hashers module
+        #
+        (MODELS_PATH + ":", "check_password"),
+        (MODELS_PATH + ":", "make_password"),
+        (FORMS_PATH + ":", "get_hasher"),
+        (FORMS_PATH + ":", "identify_hasher"),
+
+    ]
+
+    def install_patch(self):
+        """
+        Install monkeypatch to replace django hasher framework.
+        """
+        # don't reapply
+        log = self.log
+        if self.patched:
+            log.warning("monkeypatching already applied, refusing to reapply")
+            return False
+
+        # version check
+        if DJANGO_VERSION < MIN_DJANGO_VERSION:
+            raise RuntimeError("passlib.ext.django requires django >= %s" %
+                               (MIN_DJANGO_VERSION,))
+
+        # log start
+        log.debug("preparing to monkeypatch django ...")
+
+        # run through patch locations
+        manager = self._manager
+        for record in self.patch_locations:
+            if len(record) == 2:
+                record += ({},)
+            target, source, opts = record
+            if target.endswith((":", ",")):
+                target += source
+            value = getattr(self, source)
+            if opts.get("method"):
+                # have to wrap our method in a function,
+                # since we're installing it in a class *as* a method
+                # XXX: make this a flag for .patch()?
+                value = _wrap_method(value)
+            manager.patch(target, value)
+
+        # reset django's caches (e.g. get_hash_by_algorithm)
+        self.reset_hashers()
+
+        # done!
+        self.patched = True
+        log.debug("... finished monkeypatching django")
+        return True
+
+    def remove_patch(self):
+        """
+        Remove monkeypatch from django hasher framework.
+        As precaution in case there are lingering refs to context,
+        context object will be wiped.
+
+        .. warning::
+            This may cause problems if any other Django modules have imported
+            their own copies of the patched functions, though the patched
+            code has been designed to throw an error as soon as possible in
+            this case.
+        """
+        log = self.log
+        manager = self._manager
+
+        if self.patched:
+            log.debug("removing django monkeypatching...")
+            manager.unpatch_all(unpatch_conflicts=True)
+            self.context.load({})
+            self.patched = False
+            self.reset_hashers()
+            log.debug("...finished removing django monkeypatching")
+            return True
+
+        if manager.isactive():  # pragma: no cover -- sanity check
+            log.warning("reverting partial monkeypatching of django...")
+            manager.unpatch_all()
+            self.context.load({})
+            self.reset_hashers()
+            log.debug("...finished removing django monkeypatching")
+            return True
+
+        log.debug("django not monkeypatched")
+        return False
+
+    #=============================================================================
+    # loading config
+    #=============================================================================
+
+    def load_model(self):
+        """
+        Load configuration from django, and install patch.
+        """
+        self._load_settings()
+        if self.enabled:
+            try:
+                self.install_patch()
+            except:
+                # try to undo what we can
+                self.remove_patch()
+                raise
+        else:
+            if self.patched:  # pragma: no cover -- sanity check
+                log.error("didn't expect monkeypatching would be applied!")
+            self.remove_patch()
+        log.debug("passlib.ext.django loaded")
+
+    def _load_settings(self):
+        """
+        Update settings from django
+        """
+        from django.conf import settings
+
+        # TODO: would like to add support for inheriting config from a preset
+        #       (or from existing hasher state) and letting PASSLIB_CONFIG
+        #       be an update, not a replacement.
+
+        # TODO: wrap and import any custom hashers as passlib handlers,
+        #       so they could be used in the passlib config.
+
+        # load config from settings
+        _UNSET = object()
+        config = getattr(settings, "PASSLIB_CONFIG", _UNSET)
+        if config is _UNSET:
+            # XXX: should probably deprecate this alias
+            config = getattr(settings, "PASSLIB_CONTEXT", _UNSET)
+        if config is _UNSET:
+            config = "passlib-default"
+        if config is None:
+            warn("setting PASSLIB_CONFIG=None is deprecated, "
+                 "and support will be removed in Passlib 1.8, "
+                 "use PASSLIB_CONFIG='disabled' instead.",
+                 DeprecationWarning)
+            config = "disabled"
+        elif not isinstance(config, (unicode, bytes, dict)):
+            raise exc.ExpectedTypeError(config, "str or dict", "PASSLIB_CONFIG")
+
+        # load custom category func (if any)
+        get_category = getattr(settings, "PASSLIB_GET_CATEGORY", None)
+        if get_category and not callable(get_category):
+            raise exc.ExpectedTypeError(get_category, "callable", "PASSLIB_GET_CATEGORY")
+
+        # check if we've been disabled
+        if config == "disabled":
+            self.enabled = False
+            return
+        else:
+            self.__dict__.pop("enabled", None)
+
+        # resolve any preset aliases
+        if isinstance(config, str) and '\n' not in config:
+            config = get_preset_config(config)
+
+        # setup category func
+        if get_category:
+            self.get_user_category = get_category
+        else:
+            self.__dict__.pop("get_category", None)
+
+        # setup context
+        self.context.load(config)
+        self.reset_hashers()
+
+    #=============================================================================
+    # eof
+    #=============================================================================
+
+#=============================================================================
+# wrapping passlib handlers as django hashers
+#=============================================================================
+_GEN_SALT_SIGNAL = "--!!!generate-new-salt!!!--"
+
+class ProxyProperty(object):
+    """helper that proxies another attribute"""
+
+    def __init__(self, attr):
+        self.attr = attr
+
+    def __get__(self, obj, cls):
+        if obj is None:
+            cls = obj
+        return getattr(obj, self.attr)
+
+    def __set__(self, obj, value):
+        setattr(obj, self.attr, value)
+
+    def __delete__(self, obj):
+        delattr(obj, self.attr)
+
+
+class _PasslibHasherWrapper(object):
+    """
+    adapter which which wraps a :cls:`passlib.ifc.PasswordHash` class,
+    and provides an interface compatible with the Django hasher API.
+
+    :param passlib_handler:
+        passlib hash handler (e.g. :cls:`passlib.hash.sha256_crypt`.
+    """
+    #=====================================================================
+    # instance attrs
+    #=====================================================================
+
+    #: passlib handler that we're adapting.
+    passlib_handler = None
+
+    # NOTE: 'rounds' attr will store variable rounds, IF handler supports it.
+    #       'iterations' will act as proxy, for compatibility with django pbkdf2 hashers.
+    # rounds = None
+    # iterations = None
+
+    #=====================================================================
+    # init
+    #=====================================================================
+    def __init__(self, passlib_handler):
+        # init handler
+        if getattr(passlib_handler, "django_name", None):
+            raise ValueError("handlers that reflect an official django "
+                             "hasher shouldn't be wrapped: %r" %
+                             (passlib_handler.name,))
+        if passlib_handler.is_disabled:
+            # XXX: could this be implemented?
+            raise ValueError("can't wrap disabled-hash handlers: %r" %
+                             (passlib_handler.name))
+        self.passlib_handler = passlib_handler
+
+        # init rounds support
+        if self._has_rounds:
+            self.rounds = passlib_handler.default_rounds
+            self.iterations = ProxyProperty("rounds")
+
+    #=====================================================================
+    # internal methods
+    #=====================================================================
+    def __repr__(self):
+        return "<PasslibHasherWrapper handler=%r>" % self.passlib_handler
+
+    #=====================================================================
+    # internal properties
+    #=====================================================================
+
+    @memoized_property
+    def __name__(self):
+        return "Passlib_%s_PasswordHasher" % self.passlib_handler.name.title()
+
+    @memoized_property
+    def _has_rounds(self):
+        return "rounds" in self.passlib_handler.setting_kwds
+
+    @memoized_property
+    def _translate_kwds(self):
+        """
+        internal helper for safe_summary() --
+        used to translate passlib hash options -> django keywords
+        """
+        out = dict(checksum="hash")
+        if self._has_rounds and "pbkdf2" in self.passlib_handler.name:
+            out['rounds'] = 'iterations'
+        return out
+
+    #=====================================================================
+    # hasher properties
+    #=====================================================================
+
+    @memoized_property
+    def algorithm(self):
+        return PASSLIB_WRAPPER_PREFIX + self.passlib_handler.name
+
+    #=====================================================================
+    # hasher api
+    #=====================================================================
+    def salt(self):
+        # NOTE: passlib's handler.hash() should generate new salt each time,
+        #       so this just returns a special constant which tells
+        #       encode() (below) not to pass a salt keyword along.
+        return _GEN_SALT_SIGNAL
+
+    def verify(self, password, encoded):
+        return self.passlib_handler.verify(password, encoded)
+
+    def encode(self, password, salt=None, rounds=None, iterations=None):
+        kwds = {}
+        if salt is not None and salt != _GEN_SALT_SIGNAL:
+            kwds['salt'] = salt
+        if self._has_rounds:
+            if rounds is not None:
+                kwds['rounds'] = rounds
+            elif iterations is not None:
+                kwds['rounds'] = iterations
+            else:
+                kwds['rounds'] = self.rounds
+        elif rounds is not None or iterations is not None:
+            warn("%s.hash(): 'rounds' and 'iterations' are ignored" % self.__name__)
+        handler = self.passlib_handler
+        if kwds:
+            handler = handler.using(**kwds)
+        return handler.hash(password)
+
+    def safe_summary(self, encoded):
+        from django.contrib.auth.hashers import mask_hash
+        from django.utils.translation import ugettext_noop as _
+        handler = self.passlib_handler
+        items = [
+            # since this is user-facing, we're reporting passlib's name,
+            # without the distracting PASSLIB_HASHER_PREFIX prepended.
+            (_('algorithm'), handler.name),
+        ]
+        if hasattr(handler, "parsehash"):
+            kwds = handler.parsehash(encoded, sanitize=mask_hash)
+            for key, value in iteritems(kwds):
+                key = self._translate_kwds.get(key, key)
+                items.append((_(key), value))
+        return OrderedDict(items)
+
+    def must_update(self, encoded):
+        # TODO: would like access CryptContext, would need caller to pass it to get_passlib_hasher().
+        #       for now (as of passlib 1.6.6), replicating django policy that this returns True
+        #       if 'encoded' hash has different rounds value from self.rounds
+        if self._has_rounds:
+            # XXX: could cache this subclass somehow (would have to intercept writes to self.rounds)
+            # TODO: always call subcls/handler.needs_update() in case there's other things to check
+            subcls = self.passlib_handler.using(min_rounds=self.rounds, max_rounds=self.rounds)
+            if subcls.needs_update(encoded):
+                return True
+        return False
+
+    #=====================================================================
+    # eoc
+    #=====================================================================
+
+#=============================================================================
+# adapting django hashers -> passlib handlers
+#=============================================================================
+# TODO: this code probably halfway works, mainly just needs
+#       a routine to read HASHERS and PREFERRED_HASHER.
+
+##from passlib.registry import register_crypt_handler
+##from passlib.utils import classproperty, to_native_str, to_unicode
+##from passlib.utils.compat import unicode
+##
+##
+##class _HasherHandler(object):
+##    "helper for wrapping Hasher instances as passlib handlers"
+##    # FIXME: this generic wrapper doesn't handle custom settings
+##    # FIXME: genconfig / genhash not supported.
+##
+##    def __init__(self, hasher):
+##        self.django_hasher = hasher
+##        if hasattr(hasher, "iterations"):
+##            # assume encode() accepts an "iterations" parameter.
+##            # fake min/max rounds
+##            self.min_rounds = 1
+##            self.max_rounds = 0xFFFFffff
+##            self.default_rounds = self.django_hasher.iterations
+##            self.setting_kwds += ("rounds",)
+##
+##    # hasher instance - filled in by constructor
+##    django_hasher = None
+##
+##    setting_kwds = ("salt",)
+##    context_kwds = ()
+##
+##    @property
+##    def name(self):
+##        # XXX: need to make sure this wont' collide w/ builtin django hashes.
+##        #      maybe by renaming this to django compatible aliases?
+##        return DJANGO_PASSLIB_PREFIX + self.django_name
+##
+##    @property
+##    def django_name(self):
+##        # expose this so hasher_to_passlib_name() extracts original name
+##        return self.django_hasher.algorithm
+##
+##    @property
+##    def ident(self):
+##        # this should always be correct, as django relies on ident prefix.
+##        return unicode(self.django_name + "$")
+##
+##    @property
+##    def identify(self, hash):
+##        # this should always work, as django relies on ident prefix.
+##        return to_unicode(hash, "latin-1", "hash").startswith(self.ident)
+##
+##    @property
+##    def hash(self, secret, salt=None, **kwds):
+##        # NOTE: from how make_password() is coded, all hashers
+##        #       should have salt param. but only some will have
+##        #       'iterations' parameter.
+##        opts = {}
+##        if 'rounds' in self.setting_kwds and 'rounds' in kwds:
+##            opts['iterations'] = kwds.pop("rounds")
+##        if kwds:
+##            raise TypeError("unexpected keyword arguments: %r" % list(kwds))
+##        if isinstance(secret, unicode):
+##            secret = secret.encode("utf-8")
+##        if salt is None:
+##            salt = self.django_hasher.salt()
+##        return to_native_str(self.django_hasher(secret, salt, **opts))
+##
+##    @property
+##    def verify(self, secret, hash):
+##        hash = to_native_str(hash, "utf-8", "hash")
+##        if isinstance(secret, unicode):
+##            secret = secret.encode("utf-8")
+##        return self.django_hasher.verify(secret, hash)
+##
+##def register_hasher(hasher):
+##    handler = _HasherHandler(hasher)
+##    register_crypt_handler(handler)
+##    return handler
+
+#=============================================================================
+# monkeypatch helpers
+#=============================================================================
+# private singleton indicating lack-of-value
+_UNSET = object()
+
+class _PatchManager(object):
+    """helper to manage monkeypatches and run sanity checks"""
+
+    # NOTE: this could easily use a dict interface,
+    #       but keeping it distinct to make clear that it's not a dict,
+    #       since it has important side-effects.
+
+    #===================================================================
+    # init and support
+    #===================================================================
+    def __init__(self, log=None):
+        # map of key -> (original value, patched value)
+        # original value may be _UNSET
+        self.log = log or logging.getLogger(__name__ + "._PatchManager")
+        self._state = {}
+
+    def isactive(self):
+        return bool(self._state)
+
+    # bool value tests if any patches are currently applied.
+    # NOTE: this behavior is deprecated in favor of .isactive
+    __bool__ = __nonzero__ = isactive
+
+    def _import_path(self, path):
+        """retrieve obj and final attribute name from resource path"""
+        name, attr = path.split(":")
+        obj = __import__(name, fromlist=[attr], level=0)
+        while '.' in attr:
+           head, attr = attr.split(".", 1)
+           obj = getattr(obj, head)
+        return obj, attr
+
+    @staticmethod
+    def _is_same_value(left, right):
+        """check if two values are the same (stripping method wrappers, etc)"""
+        return get_method_function(left) == get_method_function(right)
+
+    #===================================================================
+    # reading
+    #===================================================================
+    def _get_path(self, key, default=_UNSET):
+        obj, attr = self._import_path(key)
+        return getattr(obj, attr, default)
+
+    def get(self, path, default=None):
+        """return current value for path"""
+        return self._get_path(path, default)
+
+    def getorig(self, path, default=None):
+        """return original (unpatched) value for path"""
+        try:
+            value, _= self._state[path]
+        except KeyError:
+            value = self._get_path(path)
+        return default if value is _UNSET else value
+
+    def check_all(self, strict=False):
+        """run sanity check on all keys, issue warning if out of sync"""
+        same = self._is_same_value
+        for path, (orig, expected) in iteritems(self._state):
+            if same(self._get_path(path), expected):
+                continue
+            msg = "another library has patched resource: %r" % path
+            if strict:
+                raise RuntimeError(msg)
+            else:
+                warn(msg, PasslibRuntimeWarning)
+
+    #===================================================================
+    # patching
+    #===================================================================
+    def _set_path(self, path, value):
+        obj, attr = self._import_path(path)
+        if value is _UNSET:
+            if hasattr(obj, attr):
+                delattr(obj, attr)
+        else:
+            setattr(obj, attr, value)
+
+    def patch(self, path, value, wrap=False):
+        """monkeypatch object+attr at <path> to have <value>, stores original"""
+        assert value != _UNSET
+        current = self._get_path(path)
+        try:
+            orig, expected = self._state[path]
+        except KeyError:
+            self.log.debug("patching resource: %r", path)
+            orig = current
+        else:
+            self.log.debug("modifying resource: %r", path)
+            if not self._is_same_value(current, expected):
+                warn("overridding resource another library has patched: %r"
+                     % path, PasslibRuntimeWarning)
+        if wrap:
+            assert callable(value)
+            wrapped = orig
+            wrapped_by = value
+            def wrapper(*args, **kwds):
+                return wrapped_by(wrapped, *args, **kwds)
+            update_wrapper(wrapper, value)
+            value = wrapper
+        if callable(value):
+            # needed by DjangoContextAdapter init
+            get_method_function(value)._patched_original_value = orig
+        self._set_path(path, value)
+        self._state[path] = (orig, value)
+
+    @classmethod
+    def peek_unpatched_func(cls, value):
+        return value._patched_original_value
+
+    ##def patch_many(self, **kwds):
+    ##    "override specified resources with new values"
+    ##    for path, value in iteritems(kwds):
+    ##        self.patch(path, value)
+
+    def monkeypatch(self, parent, name=None, enable=True, wrap=False):
+        """function decorator which patches function of same name in <parent>"""
+        def builder(func):
+            if enable:
+                sep = "." if ":" in parent else ":"
+                path = parent + sep + (name or func.__name__)
+                self.patch(path, func, wrap=wrap)
+            return func
+        if callable(name):
+            # called in non-decorator mode
+            func = name
+            name = None
+            builder(func)
+            return None
+        return builder
+
+    #===================================================================
+    # unpatching
+    #===================================================================
+    def unpatch(self, path, unpatch_conflicts=True):
+        try:
+            orig, expected = self._state[path]
+        except KeyError:
+            return
+        current = self._get_path(path)
+        self.log.debug("unpatching resource: %r", path)
+        if not self._is_same_value(current, expected):
+            if unpatch_conflicts:
+                warn("reverting resource another library has patched: %r"
+                     % path, PasslibRuntimeWarning)
+            else:
+                warn("not reverting resource another library has patched: %r"
+                     % path, PasslibRuntimeWarning)
+                del self._state[path]
+                return
+        self._set_path(path, orig)
+        del self._state[path]
+
+    def unpatch_all(self, **kwds):
+        for key in list(self._state):
+            self.unpatch(key, **kwds)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/__init__.py b/myenv/lib/python3.9/site-packages/passlib/handlers/__init__.py
new file mode 100644
index 0000000..0a0338c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/__init__.py
@@ -0,0 +1 @@
+"""passlib.handlers -- holds implementations of all passlib's builtin hash formats"""
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/argon2.py b/myenv/lib/python3.9/site-packages/passlib/handlers/argon2.py
new file mode 100644
index 0000000..4a5691b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/argon2.py
@@ -0,0 +1,1009 @@
+"""passlib.handlers.argon2 -- argon2 password hash wrapper
+
+References
+==========
+* argon2
+    - home: https://github.com/P-H-C/phc-winner-argon2
+    - whitepaper: https://github.com/P-H-C/phc-winner-argon2/blob/master/argon2-specs.pdf
+* argon2 cffi wrapper
+    - pypi: https://pypi.python.org/pypi/argon2_cffi
+    - home: https://github.com/hynek/argon2_cffi
+* argon2 pure python
+    - pypi: https://pypi.python.org/pypi/argon2pure
+    - home: https://github.com/bwesterb/argon2pure
+"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement, absolute_import
+# core
+import logging
+log = logging.getLogger(__name__)
+import re
+import types
+from warnings import warn
+# site
+_argon2_cffi = None  # loaded below
+_argon2pure = None  # dynamically imported by _load_backend_argon2pure()
+# pkg
+from passlib import exc
+from passlib.crypto.digest import MAX_UINT32
+from passlib.utils import classproperty, to_bytes, render_bytes
+from passlib.utils.binary import b64s_encode, b64s_decode
+from passlib.utils.compat import u, unicode, bascii_to_str, uascii_to_str, PY2
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "argon2",
+]
+
+#=============================================================================
+# helpers
+#=============================================================================
+
+# NOTE: when adding a new argon2 hash type, need to do the following:
+# * add TYPE_XXX constant, and add to ALL_TYPES
+# * make sure "_backend_type_map" constructors handle it correctly for all backends
+# * make sure _hash_regex & _ident_regex (below) support type string.
+# * add reference vectors for testing.
+
+#: argon2 type constants -- subclasses handle mapping these to backend-specific type constants.
+#: (should be lowercase, to match representation in hash string)
+TYPE_I = u("i")
+TYPE_D = u("d")
+TYPE_ID = u("id")  # new 2016-10-29; passlib 1.7.2 requires backends new enough for support
+
+#: list of all known types; first (supported) type will be used as default.
+ALL_TYPES = (TYPE_ID, TYPE_I, TYPE_D)
+ALL_TYPES_SET = set(ALL_TYPES)
+
+#=============================================================================
+# import argon2 package (https://pypi.python.org/pypi/argon2_cffi)
+#=============================================================================
+
+# import cffi package
+# NOTE: we try to do this even if caller is going to use argon2pure,
+#       so that we can always use the libargon2 default settings when possible.
+_argon2_cffi_error = None
+try:
+    import argon2 as _argon2_cffi
+except ImportError:
+    _argon2_cffi = None
+else:
+    if not hasattr(_argon2_cffi, "Type"):
+        # they have incompatible "argon2" package installed, instead of "argon2_cffi" package.
+        _argon2_cffi_error = (
+            "'argon2' module points to unsupported 'argon2' pypi package; "
+            "please install 'argon2-cffi' instead."
+        )
+        _argon2_cffi = None
+    elif not hasattr(_argon2_cffi, "low_level"):
+        # they have pre-v16 argon2_cffi package
+        _argon2_cffi_error = "'argon2-cffi' is too old, please update to argon2_cffi >= 18.2.0"
+        _argon2_cffi = None
+
+# init default settings for our hasher class --
+# if we have argon2_cffi >= 16.0, use their default hasher settings, otherwise use static default
+if hasattr(_argon2_cffi, "PasswordHasher"):
+    # use cffi's default settings
+    _default_settings = _argon2_cffi.PasswordHasher()
+    _default_version = _argon2_cffi.low_level.ARGON2_VERSION
+else:
+    # use fallback settings (for no backend, or argon2pure)
+    class _DummyCffiHasher:
+        """
+        dummy object to use as source of defaults when argon2_cffi isn't present.
+        this tries to mimic the attributes of ``argon2.PasswordHasher()`` which the rest of
+        this module reads.
+
+        .. note:: values last synced w/ argon2 19.2 as of 2019-11-09
+        """
+        time_cost = 2
+        memory_cost = 512
+        parallelism = 2
+        salt_len = 16
+        hash_len = 16
+        # NOTE: "type" attribute added in argon2_cffi v18.2; but currently not reading it
+        # type = _argon2_cffi.Type.ID
+
+    _default_settings = _DummyCffiHasher()
+    _default_version = 0x13  # v1.9
+
+#=============================================================================
+# handler
+#=============================================================================
+class _Argon2Common(uh.SubclassBackendMixin, uh.ParallelismMixin,
+                    uh.HasRounds, uh.HasRawSalt, uh.HasRawChecksum,
+                    uh.GenericHandler):
+    """
+    Base class which implements brunt of Argon2 code.
+    This is then subclassed by the various backends,
+    to override w/ backend-specific methods.
+
+    When a backend is loaded, the bases of the 'argon2' class proper
+    are modified to prepend the correct backend-specific subclass.
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #------------------------
+    # PasswordHash
+    #------------------------
+
+    name = "argon2"
+    setting_kwds = ("salt",
+                    "salt_size",
+                    "salt_len",  # 'salt_size' alias for compat w/ argon2 package
+                    "rounds",
+                    "time_cost",  # 'rounds' alias for compat w/ argon2 package
+                    "memory_cost",
+                    "parallelism",
+                    "digest_size",
+                    "hash_len",  # 'digest_size' alias for compat w/ argon2 package
+                    "type",  # the type of argon2 hash used
+                    )
+
+    # TODO: could support the optional 'data' parameter,
+    #       but need to research the uses, what a more descriptive name would be,
+    #       and deal w/ fact that argon2_cffi 16.1 doesn't currently support it.
+    #       (argon2_pure does though)
+
+    #------------------------
+    # GenericHandler
+    #------------------------
+
+    # NOTE: ident -- all argon2 hashes start with "$argon2<type>$"
+    # XXX: could programmaticaly generate "ident_values" string from ALL_TYPES above
+
+    checksum_size = _default_settings.hash_len
+
+    #: force parsing these kwds
+    _always_parse_settings = uh.GenericHandler._always_parse_settings + \
+                             ("type",)
+
+    #: exclude these kwds from parsehash() result (most are aliases for other keys)
+    _unparsed_settings = uh.GenericHandler._unparsed_settings + \
+                         ("salt_len", "time_cost", "hash_len", "digest_size")
+
+    #------------------------
+    # HasSalt
+    #------------------------
+    default_salt_size = _default_settings.salt_len
+    min_salt_size = 8
+    max_salt_size = MAX_UINT32
+
+    #------------------------
+    # HasRounds
+    # TODO: once rounds limit logic is factored out,
+    #       make 'rounds' and 'cost' an alias for 'time_cost'
+    #------------------------
+    default_rounds = _default_settings.time_cost
+    min_rounds = 1
+    max_rounds = MAX_UINT32
+    rounds_cost = "linear"
+
+    #------------------------
+    # ParalleismMixin
+    #------------------------
+    max_parallelism = (1 << 24) - 1  # from argon2.h / ARGON2_MAX_LANES
+
+    #------------------------
+    # custom
+    #------------------------
+
+    #: max version support
+    #: NOTE: this is dependant on the backend, and initialized/modified by set_backend()
+    max_version = _default_version
+
+    #: minimum version before needs_update() marks the hash; if None, defaults to max_version
+    min_desired_version = None
+
+    #: minimum valid memory_cost
+    min_memory_cost = 8  # from argon2.h / ARGON2_MIN_MEMORY
+
+    #: maximum number of threads (-1=unlimited);
+    #: number of threads used by .hash() will be min(parallelism, max_threads)
+    max_threads = -1
+
+    #: global flag signalling argon2pure backend to use threads
+    #: rather than subprocesses.
+    pure_use_threads = False
+
+    #: internal helper used to store mapping of TYPE_XXX constants -> backend-specific type constants;
+    #: this is populated by _load_backend_mixin(); and used to detect which types are supported.
+    #: XXX: could expose keys as class-level .supported_types property?
+    _backend_type_map = {}
+
+    @classproperty
+    def type_values(cls):
+        """
+        return tuple of types supported by this backend
+        
+        .. versionadded:: 1.7.2
+        """
+        cls.get_backend()  # make sure backend is loaded
+        return tuple(cls._backend_type_map)
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+
+    #: argon2 hash type, one of ALL_TYPES -- class value controls the default
+    #: .. versionadded:: 1.7.2
+    type = TYPE_ID
+
+    #: parallelism setting -- class value controls the default
+    parallelism = _default_settings.parallelism
+
+    #: hash version (int)
+    #: NOTE: this is modified by set_backend()
+    version = _default_version
+
+    #: memory cost -- class value controls the default
+    memory_cost = _default_settings.memory_cost
+
+    @property
+    def type_d(self):
+        """
+        flag indicating a Type D hash
+
+        .. deprecated:: 1.7.2; will be removed in passlib 2.0
+        """
+        return self.type == TYPE_D
+
+    #: optional secret data
+    data = None
+
+    #===================================================================
+    # variant constructor
+    #===================================================================
+
+    @classmethod
+    def using(cls, type=None, memory_cost=None, salt_len=None, time_cost=None, digest_size=None,
+              checksum_size=None, hash_len=None, max_threads=None, **kwds):
+        # support aliases which match argon2 naming convention
+        if time_cost is not None:
+            if "rounds" in kwds:
+                raise TypeError("'time_cost' and 'rounds' are mutually exclusive")
+            kwds['rounds'] = time_cost
+
+        if salt_len is not None:
+            if "salt_size" in kwds:
+                raise TypeError("'salt_len' and 'salt_size' are mutually exclusive")
+            kwds['salt_size'] = salt_len
+
+        if hash_len is not None:
+            if digest_size is not None:
+                raise TypeError("'hash_len' and 'digest_size' are mutually exclusive")
+            digest_size = hash_len
+
+        if checksum_size is not None:
+            if digest_size is not None:
+                raise TypeError("'checksum_size' and 'digest_size' are mutually exclusive")
+            digest_size = checksum_size
+
+        # create variant
+        subcls = super(_Argon2Common, cls).using(**kwds)
+
+        # set type
+        if type is not None:
+            subcls.type = subcls._norm_type(type)
+
+        # set checksum size
+        relaxed = kwds.get("relaxed")
+        if digest_size is not None:
+            if isinstance(digest_size, uh.native_string_types):
+                digest_size = int(digest_size)
+            # NOTE: this isn't *really* digest size minimum, but want to enforce secure minimum.
+            subcls.checksum_size = uh.norm_integer(subcls, digest_size, min=16, max=MAX_UINT32,
+                                                   param="digest_size", relaxed=relaxed)
+
+        # set memory cost
+        if memory_cost is not None:
+            if isinstance(memory_cost, uh.native_string_types):
+                memory_cost = int(memory_cost)
+            subcls.memory_cost = subcls._norm_memory_cost(memory_cost, relaxed=relaxed)
+
+        # validate constraints
+        subcls._validate_constraints(subcls.memory_cost, subcls.parallelism)
+
+        # set max threads
+        if max_threads is not None:
+            if isinstance(max_threads, uh.native_string_types):
+                max_threads = int(max_threads)
+            if max_threads < 1 and max_threads != -1:
+                raise ValueError("max_threads (%d) must be -1 (unlimited), or at least 1." %
+                                 (max_threads,))
+            subcls.max_threads = max_threads
+
+        return subcls
+
+    @classmethod
+    def _validate_constraints(cls, memory_cost, parallelism):
+        # NOTE: this is used by class & instance, hence passing in via arguments.
+        #       could switch and make this a hybrid method.
+        min_memory_cost = 8 * parallelism
+        if memory_cost < min_memory_cost:
+            raise ValueError("%s: memory_cost (%d) is too low, must be at least "
+                             "8 * parallelism (8 * %d = %d)" %
+                             (cls.name, memory_cost,
+                              parallelism, min_memory_cost))
+
+    #===================================================================
+    # public api
+    #===================================================================
+
+    #: shorter version of _hash_regex, used to quickly identify hashes
+    _ident_regex = re.compile(r"^\$argon2[a-z]+\$")
+
+    @classmethod
+    def identify(cls, hash):
+        hash = uh.to_unicode_for_identify(hash)
+        return cls._ident_regex.match(hash) is not None
+
+    # hash(), verify(), genhash() -- implemented by backend subclass
+
+    #===================================================================
+    # hash parsing / rendering
+    #===================================================================
+
+    # info taken from source of decode_string() function in
+    # <https://github.com/P-H-C/phc-winner-argon2/blob/master/src/encoding.c>
+    #
+    # hash format:
+    #   $argon2<T>[$v=<num>]$m=<num>,t=<num>,p=<num>[,keyid=<bin>][,data=<bin>][$<bin>[$<bin>]]
+    #
+    # NOTE: as of 2016-6-17, the official source (above) lists the "keyid" param in the comments,
+    #       but the actual source of decode_string & encode_string don't mention it at all.
+    #       we're supporting parsing it, but throw NotImplementedError if encountered.
+    #
+    # sample hashes:
+    #    v1.0: '$argon2i$m=512,t=2,p=2$5VtWOO3cGWYQHEMaYGbsfQ$AcmqasQgW/wI6wAHAMk4aQ'
+    #    v1.3: '$argon2i$v=19$m=512,t=2,p=2$5VtWOO3cGWYQHEMaYGbsfQ$AcmqasQgW/wI6wAHAMk4aQ'
+
+    #: regex to parse argon hash
+    _hash_regex = re.compile(br"""
+        ^
+        \$argon2(?P<type>[a-z]+)\$
+        (?:
+            v=(?P<version>\d+)
+            \$
+        )?
+        m=(?P<memory_cost>\d+)
+        ,
+        t=(?P<time_cost>\d+)
+        ,
+        p=(?P<parallelism>\d+)
+        (?:
+            ,keyid=(?P<keyid>[^,$]+)
+        )?
+        (?:
+            ,data=(?P<data>[^,$]+)
+        )?
+        (?:
+            \$
+            (?P<salt>[^$]+)
+            (?:
+                \$
+                (?P<digest>.+)
+            )?
+        )?
+        $
+    """, re.X)
+
+    @classmethod
+    def from_string(cls, hash):
+        # NOTE: assuming hash will be unicode, or use ascii-compatible encoding.
+        # TODO: switch to working w/ str or unicode
+        if isinstance(hash, unicode):
+            hash = hash.encode("utf-8")
+        if not isinstance(hash, bytes):
+            raise exc.ExpectedStringError(hash, "hash")
+        m = cls._hash_regex.match(hash)
+        if not m:
+            raise exc.MalformedHashError(cls)
+        type, version, memory_cost, time_cost, parallelism, keyid, data, salt, digest = \
+            m.group("type", "version", "memory_cost", "time_cost", "parallelism",
+                    "keyid", "data", "salt", "digest")
+        if keyid:
+            raise NotImplementedError("argon2 'keyid' parameter not supported")
+        return cls(
+            type=type.decode("ascii"),
+            version=int(version) if version else 0x10,
+            memory_cost=int(memory_cost),
+            rounds=int(time_cost),
+            parallelism=int(parallelism),
+            salt=b64s_decode(salt) if salt else None,
+            data=b64s_decode(data) if data else None,
+            checksum=b64s_decode(digest) if digest else None,
+        )
+
+    def to_string(self):
+        version = self.version
+        if version == 0x10:
+            vstr = ""
+        else:
+            vstr = "v=%d$" % version
+
+        data = self.data
+        if data:
+            kdstr = ",data=" + bascii_to_str(b64s_encode(self.data))
+        else:
+            kdstr = ""
+
+        # NOTE: 'keyid' param currently not supported
+        return "$argon2%s$%sm=%d,t=%d,p=%d%s$%s$%s" % (
+            uascii_to_str(self.type),
+            vstr, 
+            self.memory_cost,
+            self.rounds, 
+            self.parallelism,
+            kdstr,
+            bascii_to_str(b64s_encode(self.salt)),
+            bascii_to_str(b64s_encode(self.checksum)),
+        )
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, type=None, type_d=False, version=None, memory_cost=None, data=None, **kwds):
+
+        # handle deprecated kwds
+        if type_d:
+            warn('argon2 `type_d=True` keyword is deprecated, and will be removed in passlib 2.0; '
+                 'please use ``type="d"`` instead')
+            assert type is None
+            type = TYPE_D
+
+        # TODO: factor out variable checksum size support into a mixin.
+        # set checksum size to specific value before _norm_checksum() is called
+        checksum = kwds.get("checksum")
+        if checksum is not None:
+            self.checksum_size = len(checksum)
+
+        # call parent
+        super(_Argon2Common, self).__init__(**kwds)
+
+        # init type
+        if type is None:
+            assert uh.validate_default_value(self, self.type, self._norm_type, param="type")
+        else:
+            self.type = self._norm_type(type)
+
+        # init version
+        if version is None:
+            assert uh.validate_default_value(self, self.version, self._norm_version,
+                                             param="version")
+        else:
+            self.version = self._norm_version(version)
+
+        # init memory cost
+        if memory_cost is None:
+            assert uh.validate_default_value(self, self.memory_cost, self._norm_memory_cost,
+                                             param="memory_cost")
+        else:
+            self.memory_cost = self._norm_memory_cost(memory_cost)
+
+        # init data
+        if data is None:
+            assert self.data is None
+        else:
+            if not isinstance(data, bytes):
+                raise uh.exc.ExpectedTypeError(data, "bytes", "data")
+            self.data = data
+
+    #-------------------------------------------------------------------
+    # parameter guards
+    #-------------------------------------------------------------------
+
+    @classmethod
+    def _norm_type(cls, value):
+        # type check
+        if not isinstance(value, unicode):
+            if PY2 and isinstance(value, bytes):
+                value = value.decode('ascii')
+            else:
+                raise uh.exc.ExpectedTypeError(value, "str", "type")
+
+        # check if type is valid
+        if value in ALL_TYPES_SET:
+            return value
+
+        # translate from uppercase
+        temp = value.lower()
+        if temp in ALL_TYPES_SET:
+            return temp
+
+        # failure!
+        raise ValueError("unknown argon2 hash type: %r" % (value,))
+
+    @classmethod
+    def _norm_version(cls, version):
+        if not isinstance(version, uh.int_types):
+            raise uh.exc.ExpectedTypeError(version, "integer", "version")
+
+        # minimum valid version
+        if version < 0x13 and version != 0x10:
+            raise ValueError("invalid argon2 hash version: %d" % (version,))
+
+        # check this isn't past backend's max version
+        backend = cls.get_backend()
+        if version > cls.max_version:
+            raise ValueError("%s: hash version 0x%X not supported by %r backend "
+                             "(max version is 0x%X); try updating or switching backends" %
+                             (cls.name, version, backend, cls.max_version))
+        return version
+
+    @classmethod
+    def _norm_memory_cost(cls, memory_cost, relaxed=False):
+        return uh.norm_integer(cls, memory_cost, min=cls.min_memory_cost,
+                               param="memory_cost", relaxed=relaxed)
+
+    #===================================================================
+    # digest calculation
+    #===================================================================
+
+    # NOTE: _calc_checksum implemented by backend subclass
+
+    @classmethod
+    def _get_backend_type(cls, value):
+        """
+        helper to resolve backend constant from type
+        """
+        try:
+            return cls._backend_type_map[value]
+        except KeyError:
+            pass
+        # XXX: pick better error class?
+        msg = "unsupported argon2 hash (type %r not supported by %s backend)" % \
+              (value, cls.get_backend())
+        raise ValueError(msg)
+
+    #===================================================================
+    # hash migration
+    #===================================================================
+
+    def _calc_needs_update(self, **kwds):
+        cls = type(self)
+        if self.type != cls.type:
+            return True
+        minver = cls.min_desired_version
+        if minver is None or minver > cls.max_version:
+            minver = cls.max_version
+        if self.version < minver:
+            # version is too old.
+            return True
+        if self.memory_cost != cls.memory_cost:
+            return True
+        if self.checksum_size != cls.checksum_size:
+            return True
+        return super(_Argon2Common, self)._calc_needs_update(**kwds)
+    
+    #===================================================================
+    # backend loading
+    #===================================================================
+
+    _no_backend_suggestion = " -- recommend you install one (e.g. 'pip install argon2_cffi')"
+
+    @classmethod
+    def _finalize_backend_mixin(mixin_cls, name, dryrun):
+        """
+        helper called by from backend mixin classes' _load_backend_mixin() --
+        invoked after backend imports have been loaded, and performs
+        feature detection & testing common to all backends.
+        """
+        # check argon2 version
+        max_version = mixin_cls.max_version
+        assert isinstance(max_version, int) and max_version >= 0x10
+        if max_version < 0x13:
+            warn("%r doesn't support argon2 v1.3, and should be upgraded" % name,
+                 uh.exc.PasslibSecurityWarning)
+
+        # prefer best available type
+        for type in ALL_TYPES:
+            if type in mixin_cls._backend_type_map:
+                mixin_cls.type = type
+                break
+        else:
+            warn("%r lacks support for all known hash types" % name, uh.exc.PasslibRuntimeWarning)
+            # NOTE: class will just throw "unsupported argon2 hash" error if they try to use it...
+            mixin_cls.type = TYPE_ID
+
+        return True
+
+    @classmethod
+    def _adapt_backend_error(cls, err, hash=None, self=None):
+        """
+        internal helper invoked when backend has hash/verification error;
+        used to adapt to passlib message.
+        """
+        backend = cls.get_backend()
+
+        # parse hash to throw error if format was invalid, parameter out of range, etc.
+        if self is None and hash is not None:
+            self = cls.from_string(hash)
+
+        # check constraints on parsed object
+        # XXX: could move this to __init__, but not needed by needs_update calls
+        if self is not None:
+            self._validate_constraints(self.memory_cost, self.parallelism)
+
+            # as of cffi 16.1, lacks support in hash_secret(), so genhash() will get here.
+            # as of cffi 16.2, support removed from verify_secret() as well.
+            if backend == "argon2_cffi" and self.data is not None:
+                raise NotImplementedError("argon2_cffi backend doesn't support the 'data' parameter")
+
+        # fallback to reporting a malformed hash
+        text = str(err)
+        if text not in [
+            "Decoding failed"  # argon2_cffi's default message
+            ]:
+            reason = "%s reported: %s: hash=%r" % (backend, text, hash)
+        else:
+            reason = repr(hash)
+        raise exc.MalformedHashError(cls, reason=reason)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#-----------------------------------------------------------------------
+# stub backend
+#-----------------------------------------------------------------------
+class _NoBackend(_Argon2Common):
+    """
+    mixin used before any backend has been loaded.
+    contains stubs that force loading of one of the available backends.
+    """
+    #===================================================================
+    # primary methods
+    #===================================================================
+    @classmethod
+    def hash(cls, secret):
+        cls._stub_requires_backend()
+        return cls.hash(secret)
+
+    @classmethod
+    def verify(cls, secret, hash):
+        cls._stub_requires_backend()
+        return cls.verify(secret, hash)
+
+    @uh.deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genhash(cls, secret, config):
+        cls._stub_requires_backend()
+        return cls.genhash(secret, config)
+
+    #===================================================================
+    # digest calculation
+    #===================================================================
+    def _calc_checksum(self, secret):
+        # NOTE: since argon2_cffi takes care of rendering hash,
+        #       _calc_checksum() is only used by the argon2pure backend.
+        self._stub_requires_backend()
+        # NOTE: have to use super() here so that we don't recursively
+        #       call subclass's wrapped _calc_checksum
+        return super(argon2, self)._calc_checksum(secret)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#-----------------------------------------------------------------------
+# argon2_cffi backend
+#-----------------------------------------------------------------------
+class _CffiBackend(_Argon2Common):
+    """
+    argon2_cffi backend
+    """
+    #===================================================================
+    # backend loading
+    #===================================================================
+
+    @classmethod
+    def _load_backend_mixin(mixin_cls, name, dryrun):
+        # make sure we write info to base class's __dict__, not that of a subclass
+        assert mixin_cls is _CffiBackend
+
+        # we automatically import this at top, so just grab info
+        if _argon2_cffi is None:
+            if _argon2_cffi_error:
+                raise exc.PasslibSecurityError(_argon2_cffi_error)
+            return False
+        max_version = _argon2_cffi.low_level.ARGON2_VERSION
+        log.debug("detected 'argon2_cffi' backend, version %r, with support for 0x%x argon2 hashes",
+                  _argon2_cffi.__version__, max_version)
+
+        # build type map
+        TypeEnum = _argon2_cffi.Type
+        type_map = {}
+        for type in ALL_TYPES:
+            try:
+                type_map[type] = getattr(TypeEnum, type.upper())
+            except AttributeError:
+                # TYPE_ID support not added until v18.2
+                assert type not in (TYPE_I, TYPE_D), "unexpected missing type: %r" % type
+        mixin_cls._backend_type_map = type_map
+
+        # set version info, and run common setup
+        mixin_cls.version = mixin_cls.max_version = max_version
+        return mixin_cls._finalize_backend_mixin(name, dryrun)
+
+    #===================================================================
+    # primary methods
+    #===================================================================
+    @classmethod
+    def hash(cls, secret):
+        # TODO: add in 'encoding' support once that's finalized in 1.8 / 1.9.
+        uh.validate_secret(secret)
+        secret = to_bytes(secret, "utf-8")
+        # XXX: doesn't seem to be a way to make this honor max_threads
+        try:
+            return bascii_to_str(_argon2_cffi.low_level.hash_secret(
+                type=cls._get_backend_type(cls.type),
+                memory_cost=cls.memory_cost,
+                time_cost=cls.default_rounds,
+                parallelism=cls.parallelism,
+                salt=to_bytes(cls._generate_salt()),
+                hash_len=cls.checksum_size,
+                secret=secret,
+            ))
+        except _argon2_cffi.exceptions.HashingError as err:
+            raise cls._adapt_backend_error(err)
+
+    #: helper for verify() method below -- maps prefixes to type constants
+    _byte_ident_map = dict((render_bytes(b"$argon2%s$", type.encode("ascii")), type)
+                           for type in ALL_TYPES)
+
+    @classmethod
+    def verify(cls, secret, hash):
+        # TODO: add in 'encoding' support once that's finalized in 1.8 / 1.9.
+        uh.validate_secret(secret)
+        secret = to_bytes(secret, "utf-8")
+        hash = to_bytes(hash, "ascii")
+
+        # read type from start of hash
+        # NOTE: don't care about malformed strings, lowlevel will throw error for us
+        type = cls._byte_ident_map.get(hash[:1+hash.find(b"$", 1)], TYPE_I)
+        type_code = cls._get_backend_type(type)
+
+        # XXX: doesn't seem to be a way to make this honor max_threads
+        try:
+            result = _argon2_cffi.low_level.verify_secret(hash, secret, type_code)
+            assert result is True
+            return True
+        except _argon2_cffi.exceptions.VerifyMismatchError:
+            return False
+        except _argon2_cffi.exceptions.VerificationError as err:
+            raise cls._adapt_backend_error(err, hash=hash)
+
+    # NOTE: deprecated, will be removed in 2.0
+    @classmethod
+    def genhash(cls, secret, config):
+        # TODO: add in 'encoding' support once that's finalized in 1.8 / 1.9.
+        uh.validate_secret(secret)
+        secret = to_bytes(secret, "utf-8")
+        self = cls.from_string(config)
+        # XXX: doesn't seem to be a way to make this honor max_threads
+        try:
+            result = bascii_to_str(_argon2_cffi.low_level.hash_secret(
+                type=cls._get_backend_type(self.type),
+                memory_cost=self.memory_cost,
+                time_cost=self.rounds,
+                parallelism=self.parallelism,
+                salt=to_bytes(self.salt),
+                hash_len=self.checksum_size,
+                secret=secret,
+                version=self.version,
+            ))
+        except _argon2_cffi.exceptions.HashingError as err:
+            raise cls._adapt_backend_error(err, hash=config)
+        if self.version == 0x10:
+            # workaround: argon2 0x13 always returns "v=" segment, even for 0x10 hashes
+            result = result.replace("$v=16$", "$")
+        return result
+
+    #===================================================================
+    # digest calculation
+    #===================================================================
+    def _calc_checksum(self, secret):
+        raise AssertionError("shouldn't be called under argon2_cffi backend")
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#-----------------------------------------------------------------------
+# argon2pure backend
+#-----------------------------------------------------------------------
+class _PureBackend(_Argon2Common):
+    """
+    argon2pure backend
+    """
+    #===================================================================
+    # backend loading
+    #===================================================================
+
+    @classmethod
+    def _load_backend_mixin(mixin_cls, name, dryrun):
+        # make sure we write info to base class's __dict__, not that of a subclass
+        assert mixin_cls is _PureBackend
+
+        # import argon2pure
+        global _argon2pure
+        try:
+            import argon2pure as _argon2pure
+        except ImportError:
+            return False
+
+        # get default / max supported version -- added in v1.2.2
+        try:
+            from argon2pure import ARGON2_DEFAULT_VERSION as max_version
+        except ImportError:
+            log.warning("detected 'argon2pure' backend, but package is too old "
+                        "(passlib requires argon2pure >= 1.2.3)")
+            return False
+
+        log.debug("detected 'argon2pure' backend, with support for 0x%x argon2 hashes",
+                  max_version)
+
+        if not dryrun:
+            warn("Using argon2pure backend, which is 100x+ slower than is required "
+                 "for adequate security. Installing argon2_cffi (via 'pip install argon2_cffi') "
+                 "is strongly recommended", exc.PasslibSecurityWarning)
+
+        # build type map
+        type_map = {}
+        for type in ALL_TYPES:
+            try:
+                type_map[type] = getattr(_argon2pure, "ARGON2" + type.upper())
+            except AttributeError:
+                # TYPE_ID support not added until v1.3
+                assert type not in (TYPE_I, TYPE_D), "unexpected missing type: %r" % type
+        mixin_cls._backend_type_map = type_map
+
+        mixin_cls.version = mixin_cls.max_version = max_version
+        return mixin_cls._finalize_backend_mixin(name, dryrun)
+
+    #===================================================================
+    # primary methods
+    #===================================================================
+
+    # NOTE: this backend uses default .hash() & .verify() implementations.
+
+    #===================================================================
+    # digest calculation
+    #===================================================================
+    def _calc_checksum(self, secret):
+        # TODO: add in 'encoding' support once that's finalized in 1.8 / 1.9.
+        uh.validate_secret(secret)
+        secret = to_bytes(secret, "utf-8")
+        kwds = dict(
+            password=secret,
+            salt=self.salt,
+            time_cost=self.rounds,
+            memory_cost=self.memory_cost,
+            parallelism=self.parallelism,
+            tag_length=self.checksum_size,
+            type_code=self._get_backend_type(self.type),
+            version=self.version,
+        )
+        if self.max_threads > 0:
+            kwds['threads'] = self.max_threads
+        if self.pure_use_threads:
+            kwds['use_threads'] = True
+        if self.data:
+            kwds['associated_data'] = self.data
+        # NOTE: should return raw bytes
+        # NOTE: this may raise _argon2pure.Argon2ParameterError,
+        #       but it if does that, there's a bug in our own parameter checking code.
+        try:
+            return _argon2pure.argon2(**kwds)
+        except _argon2pure.Argon2Error as err:
+            raise self._adapt_backend_error(err, self=self)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class argon2(_NoBackend, _Argon2Common):
+    """
+    This class implements the Argon2 password hash [#argon2-home]_, and follows the :ref:`password-hash-api`.
+
+    Argon2 supports a variable-length salt, and variable time & memory cost,
+    and a number of other configurable parameters.
+
+    The :meth:`~passlib.ifc.PasswordHash.replace` method accepts the following optional keywords:
+
+    :type type: str
+    :param type:
+        Specify the type of argon2 hash to generate.
+        Can be one of "ID", "I", "D".
+
+        This defaults to "ID" if supported by the backend, otherwise "I".
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If specified, the length must be between 0-1024 bytes.
+        If not specified, one will be auto-generated (this is recommended).
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        This corresponds linearly to the amount of time hashing will take.
+
+    :type time_cost: int
+    :param time_cost:
+        An alias for **rounds**, for compatibility with underlying argon2 library.
+
+    :param int memory_cost:
+        Defines the memory usage in kibibytes.
+        This corresponds linearly to the amount of memory hashing will take.
+
+    :param int parallelism:
+        Defines the parallelization factor.
+        *NOTE: this will affect the resulting hash value.*
+
+    :param int digest_size:
+        Length of the digest in bytes.
+
+    :param int max_threads:
+        Maximum number of threads that will be used.
+        -1 means unlimited; otherwise hashing will use ``min(parallelism, max_threads)`` threads.
+
+        .. note::
+
+            This option is currently only honored by the argon2pure backend.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+    .. versionchanged:: 1.7.2
+
+        Added the "type" keyword, and support for type "D" and "ID" hashes.
+        (Prior versions could verify type "D" hashes, but not generate them).
+
+    .. todo::
+
+        * Support configurable threading limits.
+    """
+    #=============================================================================
+    # backend
+    #=============================================================================
+
+    # NOTE: the brunt of the argon2 class is implemented in _Argon2Common.
+    #       there are then subclass for each backend (e.g. _PureBackend),
+    #       these are dynamically prepended to this class's bases
+    #       in order to load the appropriate backend.
+
+    #: list of potential backends
+    backends = ("argon2_cffi", "argon2pure")
+
+    #: flag that this class's bases should be modified by SubclassBackendMixin
+    _backend_mixin_target = True
+
+    #: map of backend -> mixin class, used by _get_backend_loader()
+    _backend_mixin_map = {
+        None: _NoBackend,
+        "argon2_cffi": _CffiBackend,
+        "argon2pure": _PureBackend,
+    }
+
+    #=============================================================================
+    #
+    #=============================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/bcrypt.py b/myenv/lib/python3.9/site-packages/passlib/handlers/bcrypt.py
new file mode 100644
index 0000000..b83b110
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/bcrypt.py
@@ -0,0 +1,1243 @@
+"""passlib.bcrypt -- implementation of OpenBSD's BCrypt algorithm.
+
+TODO:
+
+* support 2x and altered-2a hashes?
+  http://www.openwall.com/lists/oss-security/2011/06/27/9
+
+* deal with lack of PY3-compatibile c-ext implementation
+"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement, absolute_import
+# core
+from base64 import b64encode
+from hashlib import sha256
+import os
+import re
+import logging; log = logging.getLogger(__name__)
+from warnings import warn
+# site
+_bcrypt = None # dynamically imported by _load_backend_bcrypt()
+_pybcrypt = None # dynamically imported by _load_backend_pybcrypt()
+_bcryptor = None # dynamically imported by _load_backend_bcryptor()
+# pkg
+_builtin_bcrypt = None  # dynamically imported by _load_backend_builtin()
+from passlib.crypto.digest import compile_hmac
+from passlib.exc import PasslibHashWarning, PasslibSecurityWarning, PasslibSecurityError
+from passlib.utils import safe_crypt, repeat_string, to_bytes, parse_version, \
+                          rng, getrandstr, test_crypt, to_unicode, \
+                          utf8_truncate, utf8_repeat_string, crypt_accepts_bytes
+from passlib.utils.binary import bcrypt64
+from passlib.utils.compat import get_unbound_method_function
+from passlib.utils.compat import u, uascii_to_str, unicode, str_to_uascii, PY3, error_from
+import passlib.utils.handlers as uh
+
+# local
+__all__ = [
+    "bcrypt",
+]
+
+#=============================================================================
+# support funcs & constants
+#=============================================================================
+IDENT_2 = u("$2$")
+IDENT_2A = u("$2a$")
+IDENT_2X = u("$2x$")
+IDENT_2Y = u("$2y$")
+IDENT_2B = u("$2b$")
+_BNULL = b'\x00'
+
+# reference hash of "test", used in various self-checks
+TEST_HASH_2A = "$2a$04$5BJqKfqMQvV7nS.yUguNcueVirQqDBGaLXSqj.rs.pZPlNR0UX/HK"
+
+def _detect_pybcrypt():
+    """
+    internal helper which tries to distinguish pybcrypt vs bcrypt.
+
+    :returns:
+        True if cext-based py-bcrypt,
+        False if ffi-based bcrypt,
+        None if 'bcrypt' module not found.
+
+    .. versionchanged:: 1.6.3
+
+        Now assuming bcrypt installed, unless py-bcrypt explicitly detected.
+        Previous releases assumed py-bcrypt by default.
+
+        Making this change since py-bcrypt is (apparently) unmaintained and static,
+        whereas bcrypt is being actively maintained, and it's internal structure may shift.
+    """
+    # NOTE: this is also used by the unittests.
+
+    # check for module.
+    try:
+        import bcrypt
+    except ImportError:
+        # XXX: this is ignoring case where py-bcrypt's "bcrypt._bcrypt" C Ext fails to import;
+        #      would need to inspect actual ImportError message to catch that.
+        return None
+
+    # py-bcrypt has a "._bcrypt.__version__" attribute (confirmed for v0.1 - 0.4),
+    # which bcrypt lacks (confirmed for v1.0 - 2.0)
+    # "._bcrypt" alone isn't sufficient, since bcrypt 2.0 now has that attribute.
+    try:
+        from bcrypt._bcrypt import __version__
+    except ImportError:
+        return False
+    return True
+
+#=============================================================================
+# backend mixins
+#=============================================================================
+class _BcryptCommon(uh.SubclassBackendMixin, uh.TruncateMixin, uh.HasManyIdents,
+                    uh.HasRounds, uh.HasSalt, uh.GenericHandler):
+    """
+    Base class which implements brunt of BCrypt code.
+    This is then subclassed by the various backends,
+    to override w/ backend-specific methods.
+
+    When a backend is loaded, the bases of the 'bcrypt' class proper
+    are modified to prepend the correct backend-specific subclass.
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #--------------------
+    # PasswordHash
+    #--------------------
+    name = "bcrypt"
+    setting_kwds = ("salt", "rounds", "ident", "truncate_error")
+
+    #--------------------
+    # GenericHandler
+    #--------------------
+    checksum_size = 31
+    checksum_chars = bcrypt64.charmap
+
+    #--------------------
+    # HasManyIdents
+    #--------------------
+    default_ident = IDENT_2B
+    ident_values = (IDENT_2, IDENT_2A, IDENT_2X, IDENT_2Y, IDENT_2B)
+    ident_aliases = {u("2"): IDENT_2, u("2a"): IDENT_2A,  u("2y"): IDENT_2Y,
+                     u("2b"): IDENT_2B}
+
+    #--------------------
+    # HasSalt
+    #--------------------
+    min_salt_size = max_salt_size = 22
+    salt_chars = bcrypt64.charmap
+
+    # NOTE: 22nd salt char must be in restricted set of ``final_salt_chars``, not full set above.
+    final_salt_chars = ".Oeu"  # bcrypt64._padinfo2[1]
+
+    #--------------------
+    # HasRounds
+    #--------------------
+    default_rounds = 12 # current passlib default
+    min_rounds = 4 # minimum from bcrypt specification
+    max_rounds = 31 # 32-bit integer limit (since real_rounds=1<<rounds)
+    rounds_cost = "log2"
+
+    #--------------------
+    # TruncateMixin
+    #--------------------
+    truncate_size = 72
+
+    #--------------------
+    # custom
+    #--------------------
+
+    # backend workaround detection flags
+    # NOTE: these are only set on the backend mixin classes
+    _workrounds_initialized = False
+    _has_2a_wraparound_bug = False
+    _lacks_20_support = False
+    _lacks_2y_support = False
+    _lacks_2b_support = False
+    _fallback_ident = IDENT_2A
+    _require_valid_utf8_bytes = False
+
+    #===================================================================
+    # formatting
+    #===================================================================
+
+    @classmethod
+    def from_string(cls, hash):
+        ident, tail = cls._parse_ident(hash)
+        if ident == IDENT_2X:
+            raise ValueError("crypt_blowfish's buggy '2x' hashes are not "
+                             "currently supported")
+        rounds_str, data = tail.split(u("$"))
+        rounds = int(rounds_str)
+        if rounds_str != u('%02d') % (rounds,):
+            raise uh.exc.MalformedHashError(cls, "malformed cost field")
+        salt, chk = data[:22], data[22:]
+        return cls(
+            rounds=rounds,
+            salt=salt,
+            checksum=chk or None,
+            ident=ident,
+        )
+
+    def to_string(self):
+        hash = u("%s%02d$%s%s") % (self.ident, self.rounds, self.salt, self.checksum)
+        return uascii_to_str(hash)
+
+    # NOTE: this should be kept separate from to_string()
+    #       so that bcrypt_sha256() can still use it, while overriding to_string()
+    def _get_config(self, ident):
+        """internal helper to prepare config string for backends"""
+        config = u("%s%02d$%s") % (ident, self.rounds, self.salt)
+        return uascii_to_str(config)
+
+    #===================================================================
+    # migration
+    #===================================================================
+
+    @classmethod
+    def needs_update(cls, hash, **kwds):
+        # NOTE: can't convert this to use _calc_needs_update() helper,
+        #       since _norm_hash() will correct salt padding before we can read it here.
+        # check for incorrect padding bits (passlib issue 25)
+        if isinstance(hash, bytes):
+            hash = hash.decode("ascii")
+        if hash.startswith(IDENT_2A) and hash[28] not in cls.final_salt_chars:
+            return True
+
+        # TODO: try to detect incorrect 8bit/wraparound hashes using kwds.get("secret")
+
+        # hand off to base implementation, so HasRounds can check rounds value.
+        return super(_BcryptCommon, cls).needs_update(hash, **kwds)
+
+    #===================================================================
+    # specialized salt generation - fixes passlib issue 25
+    #===================================================================
+
+    @classmethod
+    def normhash(cls, hash):
+        """helper to normalize hash, correcting any bcrypt padding bits"""
+        if cls.identify(hash):
+            return cls.from_string(hash).to_string()
+        else:
+            return hash
+
+    @classmethod
+    def _generate_salt(cls):
+        # generate random salt as normal,
+        # but repair last char so the padding bits always decode to zero.
+        salt = super(_BcryptCommon, cls)._generate_salt()
+        return bcrypt64.repair_unused(salt)
+
+    @classmethod
+    def _norm_salt(cls, salt, **kwds):
+        salt = super(_BcryptCommon, cls)._norm_salt(salt, **kwds)
+        assert salt is not None, "HasSalt didn't generate new salt!"
+        changed, salt = bcrypt64.check_repair_unused(salt)
+        if changed:
+            # FIXME: if salt was provided by user, this message won't be
+            # correct. not sure if we want to throw error, or use different warning.
+            warn(
+                "encountered a bcrypt salt with incorrectly set padding bits; "
+                "you may want to use bcrypt.normhash() "
+                "to fix this; this will be an error under Passlib 2.0",
+                PasslibHashWarning)
+        return salt
+
+    def _norm_checksum(self, checksum, relaxed=False):
+        checksum = super(_BcryptCommon, self)._norm_checksum(checksum, relaxed=relaxed)
+        changed, checksum = bcrypt64.check_repair_unused(checksum)
+        if changed:
+            warn(
+                "encountered a bcrypt hash with incorrectly set padding bits; "
+                "you may want to use bcrypt.normhash() "
+                "to fix this; this will be an error under Passlib 2.0",
+                PasslibHashWarning)
+        return checksum
+
+    #===================================================================
+    # backend configuration
+    # NOTE: backends are defined in terms of mixin classes,
+    #       which are dynamically inserted into the bases of the 'bcrypt' class
+    #       via the machinery in 'SubclassBackendMixin'.
+    #       this lets us load in a backend-specific implementation
+    #       of _calc_checksum() and similar methods.
+    #===================================================================
+
+    # NOTE: backend config is located down in <bcrypt> class
+
+    # NOTE: set_backend() will execute the ._load_backend_mixin()
+    #       of the matching mixin class, which will handle backend detection
+
+    # appended to HasManyBackends' "no backends available" error message
+    _no_backend_suggestion = " -- recommend you install one (e.g. 'pip install bcrypt')"
+
+    @classmethod
+    def _finalize_backend_mixin(mixin_cls, backend, dryrun):
+        """
+        helper called by from backend mixin classes' _load_backend_mixin() --
+        invoked after backend imports have been loaded, and performs
+        feature detection & testing common to all backends.
+        """
+        #----------------------------------------------------------------
+        # setup helpers
+        #----------------------------------------------------------------
+        assert mixin_cls is bcrypt._backend_mixin_map[backend], \
+            "_configure_workarounds() invoked from wrong class"
+
+        if mixin_cls._workrounds_initialized:
+            return True
+
+        verify = mixin_cls.verify
+
+        err_types = (ValueError, uh.exc.MissingBackendError)
+        if _bcryptor:
+            err_types += (_bcryptor.engine.SaltError,)
+
+        def safe_verify(secret, hash):
+            """verify() wrapper which traps 'unknown identifier' errors"""
+            try:
+                return verify(secret, hash)
+            except err_types:
+                # backends without support for given ident will throw various
+                # errors about unrecognized version:
+                #   os_crypt -- internal code below throws
+                #       - PasswordValueError if there's encoding issue w/ password.
+                #       - InternalBackendError if crypt fails for unknown reason
+                #         (trapped below so we can debug it)
+                #   pybcrypt, bcrypt -- raises ValueError
+                #   bcryptor -- raises bcryptor.engine.SaltError
+                return NotImplemented
+            except uh.exc.InternalBackendError:
+                # _calc_checksum() code may also throw CryptBackendError
+                # if correct hash isn't returned (e.g. 2y hash converted to 2b,
+                # such as happens with bcrypt 3.0.0)
+                log.debug("trapped unexpected response from %r backend: verify(%r, %r):",
+                          backend, secret, hash, exc_info=True)
+                return NotImplemented
+
+        def assert_lacks_8bit_bug(ident):
+            """
+            helper to check for cryptblowfish 8bit bug (fixed in 2y/2b);
+            even though it's not known to be present in any of passlib's backends.
+            this is treated as FATAL, because it can easily result in seriously malformed hashes,
+            and we can't correct for it ourselves.
+
+            test cases from <http://cvsweb.openwall.com/cgi/cvsweb.cgi/Owl/packages/glibc/crypt_blowfish/wrapper.c.diff?r1=1.9;r2=1.10>
+            reference hash is the incorrectly generated $2x$ hash taken from above url
+            """
+            # NOTE: passlib 1.7.2 and earlier used the commented-out LATIN-1 test vector to detect
+            #       this bug; but python3's crypt.crypt() only supports unicode inputs (and
+            #       always encodes them as UTF8 before passing to crypt); so passlib 1.7.3
+            #       switched to the UTF8-compatible test vector below.  This one's bug_hash value
+            #       ("$2x$...rcAS") was drawn from the same openwall source (above); and the correct
+            #       hash ("$2a$...X6eu") was generated by passing the raw bytes to python2's
+            #       crypt.crypt() using OpenBSD 6.7 (hash confirmed as same for $2a$ & $2b$).
+
+            # LATIN-1 test vector
+            # secret = b"\xA3"
+            # bug_hash = ident.encode("ascii") + b"05$/OK.fbVrR/bpIqNJ5ianF.CE5elHaaO4EbggVDjb8P19RukzXSM3e"
+            # correct_hash = ident.encode("ascii") + b"05$/OK.fbVrR/bpIqNJ5ianF.Sa7shbm4.OzKpvFnX1pQLmQW96oUlCq"
+
+            # UTF-8 test vector
+            secret = b"\xd1\x91"  # aka "\u0451"
+            bug_hash = ident.encode("ascii") + b"05$6bNw2HLQYeqHYyBfLMsv/OiwqTymGIGzFsA4hOTWebfehXHNprcAS"
+            correct_hash = ident.encode("ascii") + b"05$6bNw2HLQYeqHYyBfLMsv/OUcZd0LKP39b87nBw3.S2tVZSqiQX6eu"
+
+            if verify(secret, bug_hash):
+                # NOTE: this only EVER be observed in (broken) 2a and (backward-compat) 2x hashes
+                #       generated by crypt_blowfish library. 2y/2b hashes should not have the bug
+                #       (but we check w/ them anyways).
+                raise PasslibSecurityError(
+                    "passlib.hash.bcrypt: Your installation of the %r backend is vulnerable to "
+                    "the crypt_blowfish 8-bit bug (CVE-2011-2483) under %r hashes, "
+                    "and should be upgraded or replaced with another backend" % (backend, ident))
+
+            # it doesn't have wraparound bug, but make sure it *does* verify against the correct
+            # hash, or we're in some weird third case!
+            if not verify(secret, correct_hash):
+                raise RuntimeError("%s backend failed to verify %s 8bit hash" % (backend, ident))
+
+        def detect_wrap_bug(ident):
+            """
+            check for bsd wraparound bug (fixed in 2b)
+            this is treated as a warning, because it's rare in the field,
+            and pybcrypt (as of 2015-7-21) is unpatched, but some people may be stuck with it.
+
+            test cases from <http://www.openwall.com/lists/oss-security/2012/01/02/4>
+
+            NOTE: reference hash is of password "0"*72
+
+            NOTE: if in future we need to deliberately create hashes which have this bug,
+                  can use something like 'hashpw(repeat_string(secret[:((1+secret) % 256) or 1]), 72)'
+            """
+            # check if it exhibits wraparound bug
+            secret = (b"0123456789"*26)[:255]
+            bug_hash = ident.encode("ascii") + b"04$R1lJ2gkNaoPGdafE.H.16.nVyh2niHsGJhayOHLMiXlI45o8/DU.6"
+            if verify(secret, bug_hash):
+                return True
+
+            # if it doesn't have wraparound bug, make sure it *does* handle things
+            # correctly -- or we're in some weird third case.
+            correct_hash = ident.encode("ascii") + b"04$R1lJ2gkNaoPGdafE.H.16.1MKHPvmKwryeulRe225LKProWYwt9Oi"
+            if not verify(secret, correct_hash):
+                raise RuntimeError("%s backend failed to verify %s wraparound hash" % (backend, ident))
+
+            return False
+
+        def assert_lacks_wrap_bug(ident):
+            if not detect_wrap_bug(ident):
+                return
+            # should only see in 2a, later idents should NEVER exhibit this bug:
+            # * 2y implementations should have been free of it
+            # * 2b was what (supposedly) fixed it
+            raise RuntimeError("%s backend unexpectedly has wraparound bug for %s" % (backend, ident))
+
+        #----------------------------------------------------------------
+        # check for old 20 support
+        #----------------------------------------------------------------
+        test_hash_20 = b"$2$04$5BJqKfqMQvV7nS.yUguNcuRfMMOXK0xPWavM7pOzjEi5ze5T1k8/S"
+        result = safe_verify("test", test_hash_20)
+        if result is NotImplemented:
+            mixin_cls._lacks_20_support = True
+            log.debug("%r backend lacks $2$ support, enabling workaround", backend)
+        elif not result:
+            raise RuntimeError("%s incorrectly rejected $2$ hash" % backend)
+
+        #----------------------------------------------------------------
+        # check for 2a support
+        #----------------------------------------------------------------
+        result = safe_verify("test", TEST_HASH_2A)
+        if result is NotImplemented:
+            # 2a support is required, and should always be present
+            raise RuntimeError("%s lacks support for $2a$ hashes" % backend)
+        elif not result:
+            raise RuntimeError("%s incorrectly rejected $2a$ hash" % backend)
+        else:
+            assert_lacks_8bit_bug(IDENT_2A)
+            if detect_wrap_bug(IDENT_2A):
+                if backend == "os_crypt":
+                    # don't make this a warning for os crypt (e.g. openbsd);
+                    # they'll have proper 2b implementation which will be used for new hashes.
+                    # so even if we didn't have a workaround, this bug wouldn't be a concern.
+                    log.debug("%r backend has $2a$ bsd wraparound bug, enabling workaround", backend)
+                else:
+                    # installed library has the bug -- want to let users know,
+                    # so they can upgrade it to something better (e.g. bcrypt cffi library)
+                    warn("passlib.hash.bcrypt: Your installation of the %r backend is vulnerable to "
+                         "the bsd wraparound bug, "
+                         "and should be upgraded or replaced with another backend "
+                         "(enabling workaround for now)." % backend,
+                         uh.exc.PasslibSecurityWarning)
+                mixin_cls._has_2a_wraparound_bug = True
+
+        #----------------------------------------------------------------
+        # check for 2y support
+        #----------------------------------------------------------------
+        test_hash_2y = TEST_HASH_2A.replace("2a", "2y")
+        result = safe_verify("test", test_hash_2y)
+        if result is NotImplemented:
+            mixin_cls._lacks_2y_support = True
+            log.debug("%r backend lacks $2y$ support, enabling workaround", backend)
+        elif not result:
+            raise RuntimeError("%s incorrectly rejected $2y$ hash" % backend)
+        else:
+            # NOTE: Not using this as fallback candidate,
+            #       lacks wide enough support across implementations.
+            assert_lacks_8bit_bug(IDENT_2Y)
+            assert_lacks_wrap_bug(IDENT_2Y)
+
+        #----------------------------------------------------------------
+        # TODO: check for 2x support
+        #----------------------------------------------------------------
+
+        #----------------------------------------------------------------
+        # check for 2b support
+        #----------------------------------------------------------------
+        test_hash_2b = TEST_HASH_2A.replace("2a", "2b")
+        result = safe_verify("test", test_hash_2b)
+        if result is NotImplemented:
+            mixin_cls._lacks_2b_support = True
+            log.debug("%r backend lacks $2b$ support, enabling workaround", backend)
+        elif not result:
+            raise RuntimeError("%s incorrectly rejected $2b$ hash" % backend)
+        else:
+            mixin_cls._fallback_ident = IDENT_2B
+            assert_lacks_8bit_bug(IDENT_2B)
+            assert_lacks_wrap_bug(IDENT_2B)
+
+        # set flag so we don't have to run this again
+        mixin_cls._workrounds_initialized = True
+        return True
+
+    #===================================================================
+    # digest calculation
+    #===================================================================
+
+    # _calc_checksum() defined by backends
+
+    def _prepare_digest_args(self, secret):
+        """
+        common helper for backends to implement _calc_checksum().
+        takes in secret, returns (secret, ident) pair,
+        """
+        return self._norm_digest_args(secret, self.ident, new=self.use_defaults)
+
+    @classmethod
+    def _norm_digest_args(cls, secret, ident, new=False):
+        # make sure secret is unicode
+        require_valid_utf8_bytes = cls._require_valid_utf8_bytes
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        elif require_valid_utf8_bytes:
+            # if backend requires utf8 bytes (os_crypt);
+            # make sure input actually is utf8, or don't bother enabling utf-8 specific helpers.
+            try:
+                secret.decode("utf-8")
+            except UnicodeDecodeError:
+                # XXX: could just throw PasswordValueError here, backend will just do that
+                #      when _calc_digest() is actually called.
+                require_valid_utf8_bytes = False
+
+        # check max secret size
+        uh.validate_secret(secret)
+
+        # check for truncation (during .hash() calls only)
+        if new:
+            cls._check_truncate_policy(secret)
+
+        # NOTE: especially important to forbid NULLs for bcrypt, since many
+        # backends (bcryptor, bcrypt) happily accept them, and then
+        # silently truncate the password at first NULL they encounter!
+        if _BNULL in secret:
+            raise uh.exc.NullPasswordError(cls)
+
+        # TODO: figure out way to skip these tests when not needed...
+
+        # protect from wraparound bug by truncating secret before handing it to the backend.
+        # bcrypt only uses first 72 bytes anyways.
+        # NOTE: not needed for 2y/2b, but might use 2a as fallback for them.
+        if cls._has_2a_wraparound_bug and len(secret) >= 255:
+            if require_valid_utf8_bytes:
+                # backend requires valid utf8 bytes, so truncate secret to nearest valid segment.
+                # want to do this in constant time to not give away info about secret.
+                # NOTE: this only works because bcrypt will ignore everything past
+                #       secret[71], so padding to include a full utf8 sequence
+                #       won't break anything about the final output.
+                secret = utf8_truncate(secret, 72)
+            else:
+                secret = secret[:72]
+
+        # special case handling for variants (ordered most common first)
+        if ident == IDENT_2A:
+            # nothing needs to be done.
+            pass
+
+        elif ident == IDENT_2B:
+            if cls._lacks_2b_support:
+                # handle $2b$ hash format even if backend is too old.
+                # have it generate a 2A/2Y digest, then return it as a 2B hash.
+                # 2a-only backend could potentially exhibit wraparound bug --
+                # but we work around that issue above.
+                ident = cls._fallback_ident
+
+        elif ident == IDENT_2Y:
+            if cls._lacks_2y_support:
+                # handle $2y$ hash format (not supported by BSDs, being phased out on others)
+                # have it generate a 2A/2B digest, then return it as a 2Y hash.
+                ident = cls._fallback_ident
+
+        elif ident == IDENT_2:
+            if cls._lacks_20_support:
+                # handle legacy $2$ format (not supported by most backends except BSD os_crypt)
+                # we can fake $2$ behavior using the 2A/2Y/2B algorithm
+                # by repeating the password until it's at least 72 chars in length.
+                if secret:
+                    if require_valid_utf8_bytes:
+                        # NOTE: this only works because bcrypt will ignore everything past
+                        #       secret[71], so padding to include a full utf8 sequence
+                        #       won't break anything about the final output.
+                        secret = utf8_repeat_string(secret, 72)
+                    else:
+                        secret = repeat_string(secret, 72)
+                ident = cls._fallback_ident
+
+        elif ident == IDENT_2X:
+
+            # NOTE: shouldn't get here.
+            # XXX: could check if backend does actually offer 'support'
+            raise RuntimeError("$2x$ hashes not currently supported by passlib")
+
+        else:
+            raise AssertionError("unexpected ident value: %r" % ident)
+
+        return secret, ident
+
+#-----------------------------------------------------------------------
+# stub backend
+#-----------------------------------------------------------------------
+class _NoBackend(_BcryptCommon):
+    """
+    mixin used before any backend has been loaded.
+    contains stubs that force loading of one of the available backends.
+    """
+    #===================================================================
+    # digest calculation
+    #===================================================================
+    def _calc_checksum(self, secret):
+        self._stub_requires_backend()
+        # NOTE: have to use super() here so that we don't recursively
+        #       call subclass's wrapped _calc_checksum, e.g. bcrypt_sha256._calc_checksum
+        return super(bcrypt, self)._calc_checksum(secret)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#-----------------------------------------------------------------------
+# bcrypt backend
+#-----------------------------------------------------------------------
+class _BcryptBackend(_BcryptCommon):
+    """
+    backend which uses 'bcrypt' package
+    """
+
+    @classmethod
+    def _load_backend_mixin(mixin_cls, name, dryrun):
+        # try to import bcrypt
+        global _bcrypt
+        if _detect_pybcrypt():
+            # pybcrypt was installed instead
+            return False
+        try:
+            import bcrypt as _bcrypt
+        except ImportError: # pragma: no cover
+            return False
+        try:
+            version = _bcrypt.__about__.__version__
+        except:
+            log.warning("(trapped) error reading bcrypt version", exc_info=True)
+            version = '<unknown>'
+
+        log.debug("detected 'bcrypt' backend, version %r", version)
+        return mixin_cls._finalize_backend_mixin(name, dryrun)
+
+    # # TODO: would like to implementing verify() directly,
+    # #       to skip need for parsing hash strings.
+    # #       below method has a few edge cases where it chokes though.
+    # @classmethod
+    # def verify(cls, secret, hash):
+    #     if isinstance(hash, unicode):
+    #         hash = hash.encode("ascii")
+    #     ident = hash[:hash.index(b"$", 1)+1].decode("ascii")
+    #     if ident not in cls.ident_values:
+    #         raise uh.exc.InvalidHashError(cls)
+    #     secret, eff_ident = cls._norm_digest_args(secret, ident)
+    #     if eff_ident != ident:
+    #         # lacks support for original ident, replace w/ new one.
+    #         hash = eff_ident.encode("ascii") + hash[len(ident):]
+    #     result = _bcrypt.hashpw(secret, hash)
+    #     assert result.startswith(eff_ident)
+    #     return consteq(result, hash)
+
+    def _calc_checksum(self, secret):
+        # bcrypt behavior:
+        #   secret must be bytes
+        #   config must be ascii bytes
+        #   returns ascii bytes
+        secret, ident = self._prepare_digest_args(secret)
+        config = self._get_config(ident)
+        if isinstance(config, unicode):
+            config = config.encode("ascii")
+        hash = _bcrypt.hashpw(secret, config)
+        assert isinstance(hash, bytes)
+        if not hash.startswith(config) or len(hash) != len(config)+31:
+            raise uh.exc.CryptBackendError(self, config, hash, source="`bcrypt` package")
+        return hash[-31:].decode("ascii")
+
+#-----------------------------------------------------------------------
+# bcryptor backend
+#-----------------------------------------------------------------------
+class _BcryptorBackend(_BcryptCommon):
+    """
+    backend which uses 'bcryptor' package
+    """
+
+    @classmethod
+    def _load_backend_mixin(mixin_cls, name, dryrun):
+        # try to import bcryptor
+        global _bcryptor
+        try:
+            import bcryptor as _bcryptor
+        except ImportError: # pragma: no cover
+            return False
+
+        # deprecated as of 1.7.2
+        if not dryrun:
+            warn("Support for `bcryptor` is deprecated, and will be removed in Passlib 1.8; "
+                 "Please use `pip install bcrypt` instead", DeprecationWarning)
+
+        return mixin_cls._finalize_backend_mixin(name, dryrun)
+
+    def _calc_checksum(self, secret):
+        # bcryptor behavior:
+        #   py2: unicode secret/hash encoded as ascii bytes before use,
+        #        bytes taken as-is; returns ascii bytes.
+        #   py3: not supported
+        secret, ident = self._prepare_digest_args(secret)
+        config = self._get_config(ident)
+        hash = _bcryptor.engine.Engine(False).hash_key(secret, config)
+        if not hash.startswith(config) or len(hash) != len(config) + 31:
+            raise uh.exc.CryptBackendError(self, config, hash, source="bcryptor library")
+        return str_to_uascii(hash[-31:])
+
+#-----------------------------------------------------------------------
+# pybcrypt backend
+#-----------------------------------------------------------------------
+class _PyBcryptBackend(_BcryptCommon):
+    """
+    backend which uses 'pybcrypt' package
+    """
+
+    #: classwide thread lock used for pybcrypt < 0.3
+    _calc_lock = None
+
+    @classmethod
+    def _load_backend_mixin(mixin_cls, name, dryrun):
+        # try to import pybcrypt
+        global _pybcrypt
+        if not _detect_pybcrypt():
+            # not installed, or bcrypt installed instead
+            return False
+        try:
+            import bcrypt as _pybcrypt
+        except ImportError: # pragma: no cover
+            # XXX: should we raise AssertionError here? (if get here, _detect_pybcrypt() is broken)
+            return False
+
+        # deprecated as of 1.7.2
+        if not dryrun:
+            warn("Support for `py-bcrypt` is deprecated, and will be removed in Passlib 1.8; "
+                 "Please use `pip install bcrypt` instead", DeprecationWarning)
+
+        # determine pybcrypt version
+        try:
+            version = _pybcrypt._bcrypt.__version__
+        except:
+            log.warning("(trapped) error reading pybcrypt version", exc_info=True)
+            version = "<unknown>"
+        log.debug("detected 'pybcrypt' backend, version %r", version)
+
+        # return calc function based on version
+        vinfo = parse_version(version) or (0, 0)
+        if vinfo < (0, 3):
+            warn("py-bcrypt %s has a major security vulnerability, "
+                 "you should upgrade to py-bcrypt 0.3 immediately."
+                 % version, uh.exc.PasslibSecurityWarning)
+            if mixin_cls._calc_lock is None:
+                import threading
+                mixin_cls._calc_lock = threading.Lock()
+            mixin_cls._calc_checksum = get_unbound_method_function(mixin_cls._calc_checksum_threadsafe)
+
+        return mixin_cls._finalize_backend_mixin(name, dryrun)
+
+    def _calc_checksum_threadsafe(self, secret):
+        # as workaround for pybcrypt < 0.3's concurrency issue,
+        # we wrap everything in a thread lock. as long as bcrypt is only
+        # used through passlib, this should be safe.
+        with self._calc_lock:
+            return self._calc_checksum_raw(secret)
+
+    def _calc_checksum_raw(self, secret):
+        # py-bcrypt behavior:
+        #   py2: unicode secret/hash encoded as ascii bytes before use,
+        #        bytes taken as-is; returns ascii bytes.
+        #   py3: unicode secret encoded as utf-8 bytes,
+        #        hash encoded as ascii bytes, returns ascii unicode.
+        secret, ident = self._prepare_digest_args(secret)
+        config = self._get_config(ident)
+        hash = _pybcrypt.hashpw(secret, config)
+        if not hash.startswith(config) or len(hash) != len(config) + 31:
+            raise uh.exc.CryptBackendError(self, config, hash, source="pybcrypt library")
+        return str_to_uascii(hash[-31:])
+
+    _calc_checksum = _calc_checksum_raw
+
+#-----------------------------------------------------------------------
+# os crypt backend
+#-----------------------------------------------------------------------
+class _OsCryptBackend(_BcryptCommon):
+    """
+    backend which uses :func:`crypt.crypt`
+    """
+
+    #: set flag to ensure _prepare_digest_args() doesn't create invalid utf8 string
+    #: when truncating bytes.
+    _require_valid_utf8_bytes = not crypt_accepts_bytes
+
+    @classmethod
+    def _load_backend_mixin(mixin_cls, name, dryrun):
+        if not test_crypt("test", TEST_HASH_2A):
+            return False
+        return mixin_cls._finalize_backend_mixin(name, dryrun)
+
+    def _calc_checksum(self, secret):
+        #
+        # run secret through crypt.crypt().
+        # if everything goes right, we'll get back a properly formed bcrypt hash.
+        #
+        secret, ident = self._prepare_digest_args(secret)
+        config = self._get_config(ident)
+        hash = safe_crypt(secret, config)
+        if hash is not None:
+            if not hash.startswith(config) or len(hash) != len(config) + 31:
+                raise uh.exc.CryptBackendError(self, config, hash)
+            return hash[-31:]
+
+        #
+        # Check if this failed due to non-UTF8 bytes
+        # In detail: under py3, crypt.crypt() requires unicode inputs, which are then encoded to
+        # utf8 before passing them to os crypt() call.  this is done according to the "s" format
+        # specifier for PyArg_ParseTuple (https://docs.python.org/3/c-api/arg.html).
+        # There appears no way to get around that to pass raw bytes; so we just throw error here
+        # to let user know they need to use another backend if they want raw bytes support.
+        #
+        # XXX: maybe just let safe_crypt() throw UnicodeDecodeError under passlib 2.0,
+        #      and then catch it above? maybe have safe_crypt ALWAYS throw error
+        #      instead of returning None? (would save re-detecting what went wrong)
+        # XXX: isn't secret ALWAYS bytes at this point?
+        #
+        if PY3 and isinstance(secret, bytes):
+            try:
+                secret.decode("utf-8")
+            except UnicodeDecodeError:
+                raise error_from(uh.exc.PasswordValueError(
+                    "python3 crypt.crypt() ony supports bytes passwords using UTF8; "
+                    "passlib recommends running `pip install bcrypt` for general bcrypt support.",
+                    ), None)
+
+        #
+        # else crypt() call failed for unknown reason.
+        #
+        # NOTE: getting here should be considered a bug in passlib --
+        #       if os_crypt backend detection said there's support,
+        #       and we've already checked all known reasons above;
+        #       want them to file bug so we can figure out what happened.
+        #       in the meantime, users can avoid this by installing bcrypt-cffi backend;
+        #       which won't have this (or utf8) edgecases.
+        #
+        # XXX: throw something more specific, like an "InternalBackendError"?
+        # NOTE: if do change this error, need to update test_81_crypt_fallback() expectations
+        #       about what will be thrown; as well as safe_verify() above.
+        #
+        debug_only_repr = uh.exc.debug_only_repr
+        raise uh.exc.InternalBackendError(
+            "crypt.crypt() failed for unknown reason; "
+            "passlib recommends running `pip install bcrypt` for general bcrypt support."
+            # for debugging UTs --
+            "(config=%s, secret=%s)" % (debug_only_repr(config), debug_only_repr(secret)),
+            )
+
+#-----------------------------------------------------------------------
+# builtin backend
+#-----------------------------------------------------------------------
+class _BuiltinBackend(_BcryptCommon):
+    """
+    backend which uses passlib's pure-python implementation
+    """
+    @classmethod
+    def _load_backend_mixin(mixin_cls, name, dryrun):
+        from passlib.utils import as_bool
+        if not as_bool(os.environ.get("PASSLIB_BUILTIN_BCRYPT")):
+            log.debug("bcrypt 'builtin' backend not enabled via $PASSLIB_BUILTIN_BCRYPT")
+            return False
+        global _builtin_bcrypt
+        from passlib.crypto._blowfish import raw_bcrypt as _builtin_bcrypt
+        return mixin_cls._finalize_backend_mixin(name, dryrun)
+
+    def _calc_checksum(self, secret):
+        secret, ident = self._prepare_digest_args(secret)
+        chk = _builtin_bcrypt(secret, ident[1:-1],
+                              self.salt.encode("ascii"), self.rounds)
+        return chk.decode("ascii")
+
+#=============================================================================
+# handler
+#=============================================================================
+class bcrypt(_NoBackend, _BcryptCommon):
+    """This class implements the BCrypt password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a fixed-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 22 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 12, must be between 4 and 31, inclusive.
+        This value is logarithmic, the actual number of iterations used will be :samp:`2**{rounds}`
+        -- increasing the rounds by +1 will double the amount of time taken.
+
+    :type ident: str
+    :param ident:
+        Specifies which version of the BCrypt algorithm will be used when creating a new hash.
+        Typically this option is not needed, as the default (``"2b"``) is usually the correct choice.
+        If specified, it must be one of the following:
+
+        * ``"2"`` - the first revision of BCrypt, which suffers from a minor security flaw and is generally not used anymore.
+        * ``"2a"`` - some implementations suffered from rare security flaws, replaced by 2b.
+        * ``"2y"`` - format specific to the *crypt_blowfish* BCrypt implementation,
+          identical to ``"2b"`` in all but name.
+        * ``"2b"`` - latest revision of the official BCrypt algorithm, current default.
+
+    :param bool truncate_error:
+        By default, BCrypt will silently truncate passwords larger than 72 bytes.
+        Setting ``truncate_error=True`` will cause :meth:`~passlib.ifc.PasswordHash.hash`
+        to raise a :exc:`~passlib.exc.PasswordTruncateError` instead.
+
+        .. versionadded:: 1.7
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+
+    .. versionchanged:: 1.6
+        This class now supports ``"2y"`` hashes, and recognizes
+        (but does not support) the broken ``"2x"`` hashes.
+        (see the :ref:`crypt_blowfish bug <crypt-blowfish-bug>`
+        for details).
+
+    .. versionchanged:: 1.6
+        Added a pure-python backend.
+
+    .. versionchanged:: 1.6.3
+
+        Added support for ``"2b"`` variant.
+
+    .. versionchanged:: 1.7
+
+        Now defaults to ``"2b"`` variant.
+    """
+    #=============================================================================
+    # backend
+    #=============================================================================
+
+    # NOTE: the brunt of the bcrypt class is implemented in _BcryptCommon.
+    #       there are then subclass for each backend (e.g. _PyBcryptBackend),
+    #       these are dynamically prepended to this class's bases
+    #       in order to load the appropriate backend.
+
+    #: list of potential backends
+    backends = ("bcrypt", "pybcrypt", "bcryptor", "os_crypt", "builtin")
+
+    #: flag that this class's bases should be modified by SubclassBackendMixin
+    _backend_mixin_target = True
+
+    #: map of backend -> mixin class, used by _get_backend_loader()
+    _backend_mixin_map = {
+        None: _NoBackend,
+        "bcrypt": _BcryptBackend,
+        "pybcrypt": _PyBcryptBackend,
+        "bcryptor": _BcryptorBackend,
+        "os_crypt": _OsCryptBackend,
+        "builtin": _BuiltinBackend,
+    }
+
+    #=============================================================================
+    # eoc
+    #=============================================================================
+
+#=============================================================================
+# variants
+#=============================================================================
+_UDOLLAR = u("$")
+
+# XXX: it might be better to have all the bcrypt variants share a common base class,
+#      and have the (django_)bcrypt_sha256 wrappers just proxy bcrypt instead of subclassing it.
+class _wrapped_bcrypt(bcrypt):
+    """
+    abstracts out some bits bcrypt_sha256 & django_bcrypt_sha256 share.
+    - bypass backend-loading wrappers for hash() etc
+    - disable truncation support, sha256 wrappers don't need it.
+    """
+    setting_kwds = tuple(elem for elem in bcrypt.setting_kwds if elem not in ["truncate_error"])
+    truncate_size = None
+
+    # XXX: these will be needed if any bcrypt backends directly implement this...
+    # @classmethod
+    # def hash(cls, secret, **kwds):
+    #     # bypass bcrypt backend overriding this method
+    #     # XXX: would wrapping bcrypt make this easier than subclassing it?
+    #     return super(_BcryptCommon, cls).hash(secret, **kwds)
+    #
+    # @classmethod
+    # def verify(cls, secret, hash):
+    #     # bypass bcrypt backend overriding this method
+    #     return super(_BcryptCommon, cls).verify(secret, hash)
+    #
+    # @classmethod
+    # def genhash(cls, secret, hash):
+    #     # bypass bcrypt backend overriding this method
+    #     return super(_BcryptCommon, cls).genhash(secret, hash)
+
+    @classmethod
+    def _check_truncate_policy(cls, secret):
+        # disable check performed by bcrypt(), since this doesn't truncate passwords.
+        pass
+
+#=============================================================================
+# bcrypt sha256 wrapper
+#=============================================================================
+
+class bcrypt_sha256(_wrapped_bcrypt):
+    """
+    This class implements a composition of BCrypt + HMAC_SHA256,
+    and follows the :ref:`password-hash-api`.
+
+    It supports a fixed-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash` and :meth:`~passlib.ifc.PasswordHash.genconfig` methods accept
+    all the same optional keywords as the base :class:`bcrypt` hash.
+
+    .. versionadded:: 1.6.2
+
+    .. versionchanged:: 1.7
+
+        Now defaults to ``"2b"`` bcrypt variant; though supports older hashes
+        generated using the ``"2a"`` bcrypt variant.
+
+    .. versionchanged:: 1.7.3
+
+        For increased security, updated to use HMAC-SHA256 instead of plain SHA256.
+        Now only supports the ``"2b"`` bcrypt variant.  Hash format updated to "v=2".
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #--------------------
+    # PasswordHash
+    #--------------------
+    name = "bcrypt_sha256"
+
+    #--------------------
+    # GenericHandler
+    #--------------------
+    # this is locked at 2b for now (with 2a allowed only for legacy v1 format)
+    ident_values = (IDENT_2A, IDENT_2B)
+
+    # clone bcrypt's ident aliases so they can be used here as well...
+    ident_aliases = (lambda ident_values: dict(item for item in bcrypt.ident_aliases.items()
+                                               if item[1] in ident_values))(ident_values)
+    default_ident = IDENT_2B
+
+    #--------------------
+    # class specific
+    #--------------------
+
+    _supported_versions = set([1, 2])
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+
+    #: wrapper version.
+    #: v1 -- used prior to passlib 1.7.3; performs ``bcrypt(sha256(secret), salt, cost)``
+    #: v2 -- new in passlib 1.7.3; performs `bcrypt(sha256_hmac(salt, secret), salt, cost)``
+    version = 2
+
+    #===================================================================
+    # configuration
+    #===================================================================
+
+    @classmethod
+    def using(cls, version=None, **kwds):
+        subcls = super(bcrypt_sha256, cls).using(**kwds)
+        if version is not None:
+            subcls.version = subcls._norm_version(version)
+        ident = subcls.default_ident
+        if subcls.version > 1 and ident != IDENT_2B:
+            raise ValueError("bcrypt %r hashes not allowed for version %r" %
+                             (ident, subcls.version))
+        return subcls
+
+    #===================================================================
+    # formatting
+    #===================================================================
+
+    # sample hash:
+    # $bcrypt-sha256$2a,6$/3OeRpbOf8/l6nPPRdZPp.$nRiyYqPobEZGdNRBWihQhiFDh1ws1tu
+    # $bcrypt-sha256$           -- prefix/identifier
+    # 2a                        -- bcrypt variant
+    # ,                         -- field separator
+    # 6                         -- bcrypt work factor
+    # $                         -- section separator
+    # /3OeRpbOf8/l6nPPRdZPp.    -- salt
+    # $                         -- section separator
+    # nRiyYqPobEZGdNRBWihQhiFDh1ws1tu  -- digest
+
+    # XXX: we can't use .ident attr due to bcrypt code using it.
+    #      working around that via prefix.
+    prefix = u('$bcrypt-sha256$')
+
+    #: current version 2 hash format
+    _v2_hash_re = re.compile(r"""(?x)
+        ^
+        [$]bcrypt-sha256[$]
+        v=(?P<version>\d+),
+        t=(?P<type>2b),
+        r=(?P<rounds>\d{1,2})
+        [$](?P<salt>[^$]{22})
+        (?:[$](?P<digest>[^$]{31}))?
+        $
+        """)
+
+    #: old version 1 hash format
+    _v1_hash_re = re.compile(r"""(?x)
+        ^
+        [$]bcrypt-sha256[$]
+        (?P<type>2[ab]),
+        (?P<rounds>\d{1,2})
+        [$](?P<salt>[^$]{22})
+        (?:[$](?P<digest>[^$]{31}))?
+        $
+        """)
+
+    @classmethod
+    def identify(cls, hash):
+        hash = uh.to_unicode_for_identify(hash)
+        if not hash:
+            return False
+        return hash.startswith(cls.prefix)
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+        if not hash.startswith(cls.prefix):
+            raise uh.exc.InvalidHashError(cls)
+        m = cls._v2_hash_re.match(hash)
+        if m:
+            version = int(m.group("version"))
+            if version < 2:
+                raise uh.exc.MalformedHashError(cls)
+        else:
+            m = cls._v1_hash_re.match(hash)
+            if m:
+                version = 1
+            else:
+                raise uh.exc.MalformedHashError(cls)
+        rounds = m.group("rounds")
+        if rounds.startswith(uh._UZERO) and rounds != uh._UZERO:
+            raise uh.exc.ZeroPaddedRoundsError(cls)
+        return cls(
+            version=version,
+            ident=m.group("type"),
+            rounds=int(rounds),
+            salt=m.group("salt"),
+            checksum=m.group("digest"),
+        )
+
+    _v2_template = u("$bcrypt-sha256$v=2,t=%s,r=%d$%s$%s")
+    _v1_template = u("$bcrypt-sha256$%s,%d$%s$%s")
+
+    def to_string(self):
+        if self.version == 1:
+            template = self._v1_template
+        else:
+            template = self._v2_template
+        hash = template % (self.ident.strip(_UDOLLAR), self.rounds, self.salt, self.checksum)
+        return uascii_to_str(hash)
+
+    #===================================================================
+    # init
+    #===================================================================
+
+    def __init__(self, version=None, **kwds):
+        if version is not None:
+            self.version = self._norm_version(version)
+        super(bcrypt_sha256, self).__init__(**kwds)
+
+    #===================================================================
+    # version
+    #===================================================================
+
+    @classmethod
+    def _norm_version(cls, version):
+        if version not in cls._supported_versions:
+            raise ValueError("%s: unknown or unsupported version: %r" % (cls.name, version))
+        return version
+
+    #===================================================================
+    # checksum
+    #===================================================================
+
+    def _calc_checksum(self, secret):
+        # NOTE: can't use digest directly, since bcrypt stops at first NULL.
+        # NOTE: bcrypt doesn't fully mix entropy for bytes 55-72 of password
+        #       (XXX: citation needed), so we don't want key to be > 55 bytes.
+        #       thus, have to use base64 (44 bytes) rather than hex (64 bytes).
+        # XXX: it's later come out that 55-72 may be ok, so later revision of bcrypt_sha256
+        #      may switch to hex encoding, since it's simpler to implement elsewhere.
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+
+        if self.version == 1:
+            # version 1 -- old version just ran secret through sha256(),
+            # though this could be vulnerable to a breach attach
+            # (c.f. issue 114); which is why v2 switched to hmac wrapper.
+            digest = sha256(secret).digest()
+        else:
+            # version 2 -- running secret through HMAC keyed off salt.
+            # this prevents known secret -> sha256 password tables from being
+            # used to test against a bcrypt_sha256 hash.
+            # keying off salt (instead of constant string) should minimize chances of this
+            # colliding with existing table of hmac digest lookups as well.
+            # NOTE: salt in this case is the "bcrypt64"-encoded value, not the raw salt bytes,
+            #       to make things easier for parallel implementations of this hash --
+            #       saving them the trouble of implementing a "bcrypt64" decoder.
+            salt = self.salt
+            if salt[-1] not in self.final_salt_chars:
+                # forbidding salts with padding bits set, because bcrypt implementations
+                # won't consistently hash them the same.  since we control this format,
+                # just prevent these from even getting used.
+                raise ValueError("invalid salt string")
+            digest = compile_hmac("sha256", salt.encode("ascii"))(secret)
+
+        # NOTE: output of b64encode() uses "+/" altchars, "=" padding chars,
+        #       and no leading/trailing whitespace.
+        key = b64encode(digest)
+
+        # hand result off to normal bcrypt algorithm
+        return super(bcrypt_sha256, self)._calc_checksum(key)
+
+    #===================================================================
+    # other
+    #===================================================================
+
+    def _calc_needs_update(self, **kwds):
+        if self.version < type(self).version:
+            return True
+        return super(bcrypt_sha256, self)._calc_needs_update(**kwds)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/cisco.py b/myenv/lib/python3.9/site-packages/passlib/handlers/cisco.py
new file mode 100644
index 0000000..e715e1a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/cisco.py
@@ -0,0 +1,440 @@
+"""
+passlib.handlers.cisco -- Cisco password hashes
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from binascii import hexlify, unhexlify
+from hashlib import md5
+import logging; log = logging.getLogger(__name__)
+from warnings import warn
+# site
+# pkg
+from passlib.utils import right_pad_string, to_unicode, repeat_string, to_bytes
+from passlib.utils.binary import h64
+from passlib.utils.compat import unicode, u, join_byte_values, \
+             join_byte_elems, iter_byte_values, uascii_to_str
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "cisco_pix",
+    "cisco_asa",
+    "cisco_type7",
+]
+
+#=============================================================================
+# utils
+#=============================================================================
+
+#: dummy bytes used by spoil_digest var in cisco_pix._calc_checksum()
+_DUMMY_BYTES = b'\xFF' * 32
+
+#=============================================================================
+# cisco pix firewall hash
+#=============================================================================
+class cisco_pix(uh.HasUserContext, uh.StaticHandler):
+    """
+    This class implements the password hash used by older Cisco PIX firewalls,
+    and follows the :ref:`password-hash-api`.
+    It does a single round of hashing, and relies on the username
+    as the salt.
+
+    This class only allows passwords <= 16 bytes, anything larger
+    will result in a :exc:`~passlib.exc.PasswordSizeError` if passed to :meth:`~cisco_pix.hash`,
+    and be silently rejected if passed to :meth:`~cisco_pix.verify`.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash`,
+    :meth:`~passlib.ifc.PasswordHash.genhash`, and
+    :meth:`~passlib.ifc.PasswordHash.verify` methods
+    all support the following extra keyword:
+
+    :param str user:
+        String containing name of user account this password is associated with.
+
+        This is *required* in order to correctly hash passwords associated
+        with a user account on the Cisco device, as it is used to salt
+        the hash.
+
+        Conversely, this *must* be omitted or set to ``""`` in order to correctly
+        hash passwords which don't have an associated user account
+        (such as the "enable" password).
+
+    .. versionadded:: 1.6
+
+    .. versionchanged:: 1.7.1
+
+        Passwords > 16 bytes are now rejected / throw error instead of being silently truncated,
+        to match Cisco behavior.  A number of :ref:`bugs <passlib-asa96-bug>` were fixed
+        which caused prior releases to generate unverifiable hashes in certain cases.
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #--------------------
+    # PasswordHash
+    #--------------------
+    name = "cisco_pix"
+
+    truncate_size = 16
+
+    # NOTE: these are the default policy for PasswordHash,
+    #       but want to set them explicitly for now.
+    truncate_error = True
+    truncate_verify_reject = True
+
+    #--------------------
+    # GenericHandler
+    #--------------------
+    checksum_size = 16
+    checksum_chars = uh.HASH64_CHARS
+
+    #--------------------
+    # custom
+    #--------------------
+
+    #: control flag signalling "cisco_asa" mode, set by cisco_asa class
+    _is_asa = False
+
+    #===================================================================
+    # methods
+    #===================================================================
+    def _calc_checksum(self, secret):
+        """
+        This function implements the "encrypted" hash format used by Cisco
+        PIX & ASA. It's behavior has been confirmed for ASA 9.6,
+        but is presumed correct for PIX & other ASA releases,
+        as it fits with known test vectors, and existing literature.
+
+        While nearly the same, the PIX & ASA hashes have slight differences,
+        so this function performs differently based on the _is_asa class flag.
+        Noteable changes from PIX to ASA include password size limit
+        increased from 16 -> 32, and other internal changes.
+        """
+        # select PIX vs or ASA mode
+        asa = self._is_asa
+
+        #
+        # encode secret
+        #
+        # per ASA 8.4 documentation,
+        # http://www.cisco.com/c/en/us/td/docs/security/asa/asa84/configuration/guide/asa_84_cli_config/ref_cli.html#Supported_Character_Sets,
+        # it supposedly uses UTF-8 -- though some double-encoding issues have
+        # been observed when trying to actually *set* a non-ascii password
+        # via ASDM, and access via SSH seems to strip 8-bit chars.
+        #
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+
+        #
+        # check if password too large
+        #
+        # Per ASA 9.6 changes listed in
+        # http://www.cisco.com/c/en/us/td/docs/security/asa/roadmap/asa_new_features.html,
+        # prior releases had a maximum limit of 32 characters.
+        # Testing with an ASA 9.6 system bears this out --
+        # setting 32-char password for a user account,
+        # and logins will fail if any chars are appended.
+        # (ASA 9.6 added new PBKDF2-based hash algorithm,
+        #  which supports larger passwords).
+        #
+        # Per PIX documentation
+        # http://www.cisco.com/en/US/docs/security/pix/pix50/configuration/guide/commands.html,
+        # it would not allow passwords > 16 chars.
+        #
+        # Thus, we unconditionally throw a password size error here,
+        # as nothing valid can come from a larger password.
+        # NOTE: assuming PIX has same behavior, but at 16 char limit.
+        #
+        spoil_digest = None
+        if len(secret) > self.truncate_size:
+            if self.use_defaults:
+                # called from hash()
+                msg = "Password too long (%s allows at most %d bytes)" % \
+                      (self.name, self.truncate_size)
+                raise uh.exc.PasswordSizeError(self.truncate_size, msg=msg)
+            else:
+                # called from verify() --
+                # We don't want to throw error, or return early,
+                # as that would let attacker know too much.  Instead, we set a
+                # flag to add some dummy data into the md5 digest, so that
+                # output won't match truncated version of secret, or anything
+                # else that's fixed and predictable.
+                spoil_digest = secret + _DUMMY_BYTES
+
+        #
+        # append user to secret
+        #
+        # Policy appears to be:
+        #
+        # * Nothing appended for enable password (user = "")
+        #
+        # * ASA: If user present, but secret is >= 28 chars, nothing appended.
+        #
+        # * 1-2 byte users not allowed.
+        #   DEVIATION: we're letting them through, and repeating their
+        #   chars ala 3-char user, to simplify testing.
+        #   Could issue warning in the future though.
+        #
+        # * 3 byte user has first char repeated, to pad to 4.
+        #   (observed under ASA 9.6, assuming true elsewhere)
+        #
+        # * 4 byte users are used directly.
+        #
+        # * 5+ byte users are truncated to 4 bytes.
+        #
+        user = self.user
+        if user:
+            if isinstance(user, unicode):
+                user = user.encode("utf-8")
+            if not asa or len(secret) < 28:
+                secret += repeat_string(user, 4)
+
+        #
+        # pad / truncate result to limit
+        #
+        # While PIX always pads to 16 bytes, ASA increases to 32 bytes IFF
+        # secret+user > 16 bytes.  This makes PIX & ASA have different results
+        # where secret size in range(13,16), and user is present --
+        # PIX will truncate to 16, ASA will truncate to 32.
+        #
+        if asa and len(secret) > 16:
+            pad_size = 32
+        else:
+            pad_size = 16
+        secret = right_pad_string(secret, pad_size)
+
+        #
+        # md5 digest
+        #
+        if spoil_digest:
+            # make sure digest won't match truncated version of secret
+            secret += spoil_digest
+        digest = md5(secret).digest()
+
+        #
+        # drop every 4th byte
+        # NOTE: guessing this was done because it makes output exactly
+        #       16 bytes, which may have been a general 'char password[]'
+        #       size limit under PIX
+        #
+        digest = join_byte_elems(c for i, c in enumerate(digest) if (i + 1) & 3)
+
+        #
+        # encode using Hash64
+        #
+        return h64.encode_bytes(digest).decode("ascii")
+
+    # NOTE: works, but needs UTs.
+    # @classmethod
+    # def same_as_pix(cls, secret, user=""):
+    #     """
+    #     test whether (secret + user) combination should
+    #     have the same hash under PIX and ASA.
+    #
+    #     mainly present to help unittests.
+    #     """
+    #     # see _calc_checksum() above for details of this logic.
+    #     size = len(to_bytes(secret, "utf-8"))
+    #     if user and size < 28:
+    #         size += 4
+    #     return size < 17
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+
+class cisco_asa(cisco_pix):
+    """
+    This class implements the password hash used by Cisco ASA/PIX 7.0 and newer (2005).
+    Aside from a different internal algorithm, it's use and format is identical
+    to the older :class:`cisco_pix` class.
+
+    For passwords less than 13 characters, this should be identical to :class:`!cisco_pix`,
+    but will generate a different hash for most larger inputs
+    (See the `Format & Algorithm`_ section for the details).
+
+    This class only allows passwords <= 32 bytes, anything larger
+    will result in a :exc:`~passlib.exc.PasswordSizeError` if passed to :meth:`~cisco_asa.hash`,
+    and be silently rejected if passed to :meth:`~cisco_asa.verify`.
+
+    .. versionadded:: 1.7
+
+    .. versionchanged:: 1.7.1
+
+        Passwords > 32 bytes are now rejected / throw error instead of being silently truncated,
+        to match Cisco behavior.  A number of :ref:`bugs <passlib-asa96-bug>` were fixed
+        which caused prior releases to generate unverifiable hashes in certain cases.
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #--------------------
+    # PasswordHash
+    #--------------------
+    name = "cisco_asa"
+
+    #--------------------
+    # TruncateMixin
+    #--------------------
+    truncate_size = 32
+
+    #--------------------
+    # cisco_pix
+    #--------------------
+    _is_asa = True
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# type 7
+#=============================================================================
+class cisco_type7(uh.GenericHandler):
+    """
+    This class implements the "Type 7" password encoding used by Cisco IOS,
+    and follows the :ref:`password-hash-api`.
+    It has a simple 4-5 bit salt, but is nonetheless a reversible encoding
+    instead of a real hash.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: int
+    :param salt:
+        This may be an optional salt integer drawn from ``range(0,16)``.
+        If omitted, one will be chosen at random.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` values that are out of range.
+
+    Note that while this class outputs digests in upper-case hexadecimal,
+    it will accept lower-case as well.
+
+    This class also provides the following additional method:
+
+    .. automethod:: decode
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #--------------------
+    # PasswordHash
+    #--------------------
+    name = "cisco_type7"
+    setting_kwds = ("salt",)
+
+    #--------------------
+    # GenericHandler
+    #--------------------
+    checksum_chars = uh.UPPER_HEX_CHARS
+
+    #--------------------
+    # HasSalt
+    #--------------------
+
+    # NOTE: encoding could handle max_salt_value=99, but since key is only 52
+    #       chars in size, not sure what appropriate behavior is for that edge case.
+    min_salt_value = 0
+    max_salt_value = 52
+
+    #===================================================================
+    # methods
+    #===================================================================
+    @classmethod
+    def using(cls, salt=None, **kwds):
+        subcls = super(cisco_type7, cls).using(**kwds)
+        if salt is not None:
+            salt = subcls._norm_salt(salt, relaxed=kwds.get("relaxed"))
+            subcls._generate_salt = staticmethod(lambda: salt)
+        return subcls
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+        if len(hash) < 2:
+            raise uh.exc.InvalidHashError(cls)
+        salt = int(hash[:2]) # may throw ValueError
+        return cls(salt=salt, checksum=hash[2:].upper())
+
+    def __init__(self, salt=None, **kwds):
+        super(cisco_type7, self).__init__(**kwds)
+        if salt is not None:
+            salt = self._norm_salt(salt)
+        elif self.use_defaults:
+            salt = self._generate_salt()
+            assert self._norm_salt(salt) == salt, "generated invalid salt: %r" % (salt,)
+        else:
+            raise TypeError("no salt specified")
+        self.salt = salt
+
+    @classmethod
+    def _norm_salt(cls, salt, relaxed=False):
+        """
+        validate & normalize salt value.
+        .. note::
+            the salt for this algorithm is an integer 0-52, not a string
+        """
+        if not isinstance(salt, int):
+            raise uh.exc.ExpectedTypeError(salt, "integer", "salt")
+        if 0 <= salt <= cls.max_salt_value:
+            return salt
+        msg = "salt/offset must be in 0..52 range"
+        if relaxed:
+            warn(msg, uh.PasslibHashWarning)
+            return 0 if salt < 0 else cls.max_salt_value
+        else:
+            raise ValueError(msg)
+
+    @staticmethod
+    def _generate_salt():
+        return uh.rng.randint(0, 15)
+
+    def to_string(self):
+        return "%02d%s" % (self.salt, uascii_to_str(self.checksum))
+
+    def _calc_checksum(self, secret):
+        # XXX: no idea what unicode policy is, but all examples are
+        # 7-bit ascii compatible, so using UTF-8
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        return hexlify(self._cipher(secret, self.salt)).decode("ascii").upper()
+
+    @classmethod
+    def decode(cls, hash, encoding="utf-8"):
+        """decode hash, returning original password.
+
+        :arg hash: encoded password
+        :param encoding: optional encoding to use (defaults to ``UTF-8``).
+        :returns: password as unicode
+        """
+        self = cls.from_string(hash)
+        tmp = unhexlify(self.checksum.encode("ascii"))
+        raw = self._cipher(tmp, self.salt)
+        return raw.decode(encoding) if encoding else raw
+
+    # type7 uses a xor-based vingere variant, using the following secret key:
+    _key = u("dsfd;kfoA,.iyewrkldJKDHSUBsgvca69834ncxv9873254k;fg87")
+
+    @classmethod
+    def _cipher(cls, data, salt):
+        """xor static key against data - encrypts & decrypts"""
+        key = cls._key
+        key_size = len(key)
+        return join_byte_values(
+            value ^ ord(key[(salt + idx) % key_size])
+            for idx, value in enumerate(iter_byte_values(data))
+        )
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/des_crypt.py b/myenv/lib/python3.9/site-packages/passlib/handlers/des_crypt.py
new file mode 100644
index 0000000..68a4ca7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/des_crypt.py
@@ -0,0 +1,607 @@
+"""passlib.handlers.des_crypt - traditional unix (DES) crypt and variants"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import re
+import logging; log = logging.getLogger(__name__)
+from warnings import warn
+# site
+# pkg
+from passlib.utils import safe_crypt, test_crypt, to_unicode
+from passlib.utils.binary import h64, h64big
+from passlib.utils.compat import byte_elem_value, u, uascii_to_str, unicode, suppress_cause
+from passlib.crypto.des import des_encrypt_int_block
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "des_crypt",
+    "bsdi_crypt",
+    "bigcrypt",
+    "crypt16",
+]
+
+#=============================================================================
+# pure-python backend for des_crypt family
+#=============================================================================
+_BNULL = b'\x00'
+
+def _crypt_secret_to_key(secret):
+    """convert secret to 64-bit DES key.
+
+    this only uses the first 8 bytes of the secret,
+    and discards the high 8th bit of each byte at that.
+    a null parity bit is inserted after every 7th bit of the output.
+    """
+    # NOTE: this would set the parity bits correctly,
+    #       but des_encrypt_int_block() would just ignore them...
+    ##return sum(expand_7bit(byte_elem_value(c) & 0x7f) << (56-i*8)
+    ##           for i, c in enumerate(secret[:8]))
+    return sum((byte_elem_value(c) & 0x7f) << (57-i*8)
+               for i, c in enumerate(secret[:8]))
+
+def _raw_des_crypt(secret, salt):
+    """pure-python backed for des_crypt"""
+    assert len(salt) == 2
+
+    # NOTE: some OSes will accept non-HASH64 characters in the salt,
+    #       but what value they assign these characters varies wildy,
+    #       so just rejecting them outright.
+    #       the same goes for single-character salts...
+    #       some OSes duplicate the char, some insert a '.' char,
+    #       and openbsd does (something) which creates an invalid hash.
+    salt_value = h64.decode_int12(salt)
+
+    # gotta do something - no official policy since this predates unicode
+    if isinstance(secret, unicode):
+        secret = secret.encode("utf-8")
+    assert isinstance(secret, bytes)
+
+    # forbidding NULL char because underlying crypt() rejects them too.
+    if _BNULL in secret:
+        raise uh.exc.NullPasswordError(des_crypt)
+
+    # convert first 8 bytes of secret string into an integer
+    key_value = _crypt_secret_to_key(secret)
+
+    # run data through des using input of 0
+    result = des_encrypt_int_block(key_value, 0, salt_value, 25)
+
+    # run h64 encode on result
+    return h64big.encode_int64(result)
+
+def _bsdi_secret_to_key(secret):
+    """convert secret to DES key used by bsdi_crypt"""
+    key_value = _crypt_secret_to_key(secret)
+    idx = 8
+    end = len(secret)
+    while idx < end:
+        next = idx + 8
+        tmp_value = _crypt_secret_to_key(secret[idx:next])
+        key_value = des_encrypt_int_block(key_value, key_value) ^ tmp_value
+        idx = next
+    return key_value
+
+def _raw_bsdi_crypt(secret, rounds, salt):
+    """pure-python backend for bsdi_crypt"""
+
+    # decode salt
+    salt_value = h64.decode_int24(salt)
+
+    # gotta do something - no official policy since this predates unicode
+    if isinstance(secret, unicode):
+        secret = secret.encode("utf-8")
+    assert isinstance(secret, bytes)
+
+    # forbidding NULL char because underlying crypt() rejects them too.
+    if _BNULL in secret:
+        raise uh.exc.NullPasswordError(bsdi_crypt)
+
+    # convert secret string into an integer
+    key_value = _bsdi_secret_to_key(secret)
+
+    # run data through des using input of 0
+    result = des_encrypt_int_block(key_value, 0, salt_value, rounds)
+
+    # run h64 encode on result
+    return h64big.encode_int64(result)
+
+#=============================================================================
+# handlers
+#=============================================================================
+class des_crypt(uh.TruncateMixin, uh.HasManyBackends, uh.HasSalt, uh.GenericHandler):
+    """This class implements the des-crypt password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a fixed-length salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 2 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :param bool truncate_error:
+        By default, des_crypt will silently truncate passwords larger than 8 bytes.
+        Setting ``truncate_error=True`` will cause :meth:`~passlib.ifc.PasswordHash.hash`
+        to raise a :exc:`~passlib.exc.PasswordTruncateError` instead.
+
+        .. versionadded:: 1.7
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #--------------------
+    # PasswordHash
+    #--------------------
+    name = "des_crypt"
+    setting_kwds = ("salt", "truncate_error")
+
+    #--------------------
+    # GenericHandler
+    #--------------------
+    checksum_chars = uh.HASH64_CHARS
+    checksum_size = 11
+
+    #--------------------
+    # HasSalt
+    #--------------------
+    min_salt_size = max_salt_size = 2
+    salt_chars = uh.HASH64_CHARS
+
+    #--------------------
+    # TruncateMixin
+    #--------------------
+    truncate_size = 8
+
+    #===================================================================
+    # formatting
+    #===================================================================
+    # FORMAT: 2 chars of H64-encoded salt + 11 chars of H64-encoded checksum
+
+    _hash_regex = re.compile(u(r"""
+        ^
+        (?P<salt>[./a-z0-9]{2})
+        (?P<chk>[./a-z0-9]{11})?
+        $"""), re.X|re.I)
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+        salt, chk = hash[:2], hash[2:]
+        return cls(salt=salt, checksum=chk or None)
+
+    def to_string(self):
+        hash = u("%s%s") % (self.salt, self.checksum)
+        return uascii_to_str(hash)
+
+    #===================================================================
+    # digest calculation
+    #===================================================================
+    def _calc_checksum(self, secret):
+        # check for truncation (during .hash() calls only)
+        if self.use_defaults:
+            self._check_truncate_policy(secret)
+
+        return self._calc_checksum_backend(secret)
+
+    #===================================================================
+    # backend
+    #===================================================================
+    backends = ("os_crypt", "builtin")
+
+    #---------------------------------------------------------------
+    # os_crypt backend
+    #---------------------------------------------------------------
+    @classmethod
+    def _load_backend_os_crypt(cls):
+        if test_crypt("test", 'abgOeLfPimXQo'):
+            cls._set_calc_checksum_backend(cls._calc_checksum_os_crypt)
+            return True
+        else:
+            return False
+
+    def _calc_checksum_os_crypt(self, secret):
+        # NOTE: we let safe_crypt() encode unicode secret -> utf8;
+        #       no official policy since des-crypt predates unicode
+        hash = safe_crypt(secret, self.salt)
+        if hash is None:
+            # py3's crypt.crypt() can't handle non-utf8 bytes.
+            # fallback to builtin alg, which is always available.
+            return self._calc_checksum_builtin(secret)
+        if not hash.startswith(self.salt) or len(hash) != 13:
+            raise uh.exc.CryptBackendError(self, self.salt, hash)
+        return hash[2:]
+
+    #---------------------------------------------------------------
+    # builtin backend
+    #---------------------------------------------------------------
+    @classmethod
+    def _load_backend_builtin(cls):
+        cls._set_calc_checksum_backend(cls._calc_checksum_builtin)
+        return True
+
+    def _calc_checksum_builtin(self, secret):
+        return _raw_des_crypt(secret, self.salt.encode("ascii")).decode("ascii")
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class bsdi_crypt(uh.HasManyBackends, uh.HasRounds, uh.HasSalt, uh.GenericHandler):
+    """This class implements the BSDi-Crypt password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a fixed-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 4 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 5001, must be between 1 and 16777215, inclusive.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+
+    .. versionchanged:: 1.6
+        :meth:`hash` will now issue a warning if an even number of rounds is used
+        (see :ref:`bsdi-crypt-security-issues` regarding weak DES keys).
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+    #--GenericHandler--
+    name = "bsdi_crypt"
+    setting_kwds = ("salt", "rounds")
+    checksum_size = 11
+    checksum_chars = uh.HASH64_CHARS
+
+    #--HasSalt--
+    min_salt_size = max_salt_size = 4
+    salt_chars = uh.HASH64_CHARS
+
+    #--HasRounds--
+    default_rounds = 5001
+    min_rounds = 1
+    max_rounds = 16777215 # (1<<24)-1
+    rounds_cost = "linear"
+
+    # NOTE: OpenBSD login.conf reports 7250 as minimum allowed rounds,
+    # but that seems to be an OS policy, not a algorithm limitation.
+
+    #===================================================================
+    # parsing
+    #===================================================================
+    _hash_regex = re.compile(u(r"""
+        ^
+        _
+        (?P<rounds>[./a-z0-9]{4})
+        (?P<salt>[./a-z0-9]{4})
+        (?P<chk>[./a-z0-9]{11})?
+        $"""), re.X|re.I)
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+        m = cls._hash_regex.match(hash)
+        if not m:
+            raise uh.exc.InvalidHashError(cls)
+        rounds, salt, chk = m.group("rounds", "salt", "chk")
+        return cls(
+            rounds=h64.decode_int24(rounds.encode("ascii")),
+            salt=salt,
+            checksum=chk,
+        )
+
+    def to_string(self):
+        hash = u("_%s%s%s") % (h64.encode_int24(self.rounds).decode("ascii"),
+                               self.salt, self.checksum)
+        return uascii_to_str(hash)
+
+    #===================================================================
+    # validation
+    #===================================================================
+
+    # NOTE: keeping this flag for admin/choose_rounds.py script.
+    #       want to eventually expose rounds logic to that script in better way.
+    _avoid_even_rounds = True
+
+    @classmethod
+    def using(cls, **kwds):
+        subcls = super(bsdi_crypt, cls).using(**kwds)
+        if not subcls.default_rounds & 1:
+            # issue warning if caller set an even 'rounds' value.
+            warn("bsdi_crypt rounds should be odd, as even rounds may reveal weak DES keys",
+                 uh.exc.PasslibSecurityWarning)
+        return subcls
+
+    @classmethod
+    def _generate_rounds(cls):
+        rounds = super(bsdi_crypt, cls)._generate_rounds()
+        # ensure autogenerated rounds are always odd
+        # NOTE: doing this even for default_rounds so needs_update() doesn't get
+        #       caught in a loop.
+        # FIXME: this technically might generate a rounds value 1 larger
+        # than the requested upper bound - but better to err on side of safety.
+        return rounds|1
+
+    #===================================================================
+    # migration
+    #===================================================================
+
+    def _calc_needs_update(self, **kwds):
+        # mark bsdi_crypt hashes as deprecated if they have even rounds.
+        if not self.rounds & 1:
+            return True
+        # hand off to base implementation
+        return super(bsdi_crypt, self)._calc_needs_update(**kwds)
+
+    #===================================================================
+    # backends
+    #===================================================================
+    backends = ("os_crypt", "builtin")
+
+    #---------------------------------------------------------------
+    # os_crypt backend
+    #---------------------------------------------------------------
+    @classmethod
+    def _load_backend_os_crypt(cls):
+        if test_crypt("test", '_/...lLDAxARksGCHin.'):
+            cls._set_calc_checksum_backend(cls._calc_checksum_os_crypt)
+            return True
+        else:
+            return False
+
+    def _calc_checksum_os_crypt(self, secret):
+        config = self.to_string()
+        hash = safe_crypt(secret, config)
+        if hash is None:
+            # py3's crypt.crypt() can't handle non-utf8 bytes.
+            # fallback to builtin alg, which is always available.
+            return self._calc_checksum_builtin(secret)
+        if not hash.startswith(config[:9]) or len(hash) != 20:
+            raise uh.exc.CryptBackendError(self, config, hash)
+        return hash[-11:]
+
+    #---------------------------------------------------------------
+    # builtin backend
+    #---------------------------------------------------------------
+    @classmethod
+    def _load_backend_builtin(cls):
+        cls._set_calc_checksum_backend(cls._calc_checksum_builtin)
+        return True
+
+    def _calc_checksum_builtin(self, secret):
+        return _raw_bsdi_crypt(secret, self.rounds, self.salt.encode("ascii")).decode("ascii")
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class bigcrypt(uh.HasSalt, uh.GenericHandler):
+    """This class implements the BigCrypt password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a fixed-length salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 22 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+    #--GenericHandler--
+    name = "bigcrypt"
+    setting_kwds = ("salt",)
+    checksum_chars = uh.HASH64_CHARS
+    # NOTE: checksum chars must be multiple of 11
+
+    #--HasSalt--
+    min_salt_size = max_salt_size = 2
+    salt_chars = uh.HASH64_CHARS
+
+    #===================================================================
+    # internal helpers
+    #===================================================================
+    _hash_regex = re.compile(u(r"""
+        ^
+        (?P<salt>[./a-z0-9]{2})
+        (?P<chk>([./a-z0-9]{11})+)?
+        $"""), re.X|re.I)
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+        m = cls._hash_regex.match(hash)
+        if not m:
+            raise uh.exc.InvalidHashError(cls)
+        salt, chk = m.group("salt", "chk")
+        return cls(salt=salt, checksum=chk)
+
+    def to_string(self):
+        hash = u("%s%s") % (self.salt, self.checksum)
+        return uascii_to_str(hash)
+
+    def _norm_checksum(self, checksum, relaxed=False):
+        checksum = super(bigcrypt, self)._norm_checksum(checksum, relaxed=relaxed)
+        if len(checksum) % 11:
+            raise uh.exc.InvalidHashError(self)
+        return checksum
+
+    #===================================================================
+    # backend
+    #===================================================================
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        chk = _raw_des_crypt(secret, self.salt.encode("ascii"))
+        idx = 8
+        end = len(secret)
+        while idx < end:
+            next = idx + 8
+            chk += _raw_des_crypt(secret[idx:next], chk[-11:-9])
+            idx = next
+        return chk.decode("ascii")
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class crypt16(uh.TruncateMixin, uh.HasSalt, uh.GenericHandler):
+    """This class implements the crypt16 password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a fixed-length salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 2 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :param bool truncate_error:
+        By default, crypt16 will silently truncate passwords larger than 16 bytes.
+        Setting ``truncate_error=True`` will cause :meth:`~passlib.ifc.PasswordHash.hash`
+        to raise a :exc:`~passlib.exc.PasswordTruncateError` instead.
+
+        .. versionadded:: 1.7
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #--------------------
+    # PasswordHash
+    #--------------------
+    name = "crypt16"
+    setting_kwds = ("salt", "truncate_error")
+
+    #--------------------
+    # GenericHandler
+    #--------------------
+    checksum_size = 22
+    checksum_chars = uh.HASH64_CHARS
+
+    #--------------------
+    # HasSalt
+    #--------------------
+    min_salt_size = max_salt_size = 2
+    salt_chars = uh.HASH64_CHARS
+
+    #--------------------
+    # TruncateMixin
+    #--------------------
+    truncate_size = 16
+
+    #===================================================================
+    # internal helpers
+    #===================================================================
+    _hash_regex = re.compile(u(r"""
+        ^
+        (?P<salt>[./a-z0-9]{2})
+        (?P<chk>[./a-z0-9]{22})?
+        $"""), re.X|re.I)
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+        m = cls._hash_regex.match(hash)
+        if not m:
+            raise uh.exc.InvalidHashError(cls)
+        salt, chk = m.group("salt", "chk")
+        return cls(salt=salt, checksum=chk)
+
+    def to_string(self):
+        hash = u("%s%s") % (self.salt, self.checksum)
+        return uascii_to_str(hash)
+
+    #===================================================================
+    # backend
+    #===================================================================
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+
+        # check for truncation (during .hash() calls only)
+        if self.use_defaults:
+            self._check_truncate_policy(secret)
+
+        # parse salt value
+        try:
+            salt_value = h64.decode_int12(self.salt.encode("ascii"))
+        except ValueError: # pragma: no cover - caught by class
+            raise suppress_cause(ValueError("invalid chars in salt"))
+
+        # convert first 8 byts of secret string into an integer,
+        key1 = _crypt_secret_to_key(secret)
+
+        # run data through des using input of 0
+        result1 = des_encrypt_int_block(key1, 0, salt_value, 20)
+
+        # convert next 8 bytes of secret string into integer (key=0 if secret < 8 chars)
+        key2 = _crypt_secret_to_key(secret[8:16])
+
+        # run data through des using input of 0
+        result2 = des_encrypt_int_block(key2, 0, salt_value, 5)
+
+        # done
+        chk = h64big.encode_int64(result1) + h64big.encode_int64(result2)
+        return chk.decode("ascii")
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/digests.py b/myenv/lib/python3.9/site-packages/passlib/handlers/digests.py
new file mode 100644
index 0000000..982155c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/digests.py
@@ -0,0 +1,168 @@
+"""passlib.handlers.digests - plain hash digests
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import hashlib
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils import to_native_str, to_bytes, render_bytes, consteq
+from passlib.utils.compat import unicode, str_to_uascii
+import passlib.utils.handlers as uh
+from passlib.crypto.digest import lookup_hash
+# local
+__all__ = [
+    "create_hex_hash",
+    "hex_md4",
+    "hex_md5",
+    "hex_sha1",
+    "hex_sha256",
+    "hex_sha512",
+]
+
+#=============================================================================
+# helpers for hexadecimal hashes
+#=============================================================================
+class HexDigestHash(uh.StaticHandler):
+    """this provides a template for supporting passwords stored as plain hexadecimal hashes"""
+    #===================================================================
+    # class attrs
+    #===================================================================
+    _hash_func = None # hash function to use - filled in by create_hex_hash()
+    checksum_size = None # filled in by create_hex_hash()
+    checksum_chars = uh.HEX_CHARS
+
+    #: special for detecting if _hash_func is just a stub method.
+    supported = True
+
+    #===================================================================
+    # methods
+    #===================================================================
+    @classmethod
+    def _norm_hash(cls, hash):
+        return hash.lower()
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        return str_to_uascii(self._hash_func(secret).hexdigest())
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+def create_hex_hash(digest, module=__name__, django_name=None, required=True):
+    """
+    create hex-encoded unsalted hasher for specified digest algorithm.
+
+    .. versionchanged:: 1.7.3
+        If called with unknown/supported digest, won't throw error immediately,
+        but instead return a dummy hasher that will throw error when called.
+
+        set ``required=True`` to restore old behavior.
+    """
+    info = lookup_hash(digest, required=required)
+    name = "hex_" + info.name
+    if not info.supported:
+        info.digest_size = 0
+    hasher = type(name, (HexDigestHash,), dict(
+        name=name,
+        __module__=module, # so ABCMeta won't clobber it
+        _hash_func=staticmethod(info.const), # sometimes it's a function, sometimes not. so wrap it.
+        checksum_size=info.digest_size*2,
+        __doc__="""This class implements a plain hexadecimal %s hash, and follows the :ref:`password-hash-api`.
+
+It supports no optional or contextual keywords.
+""" % (info.name,)
+    ))
+    if not info.supported:
+        hasher.supported = False
+    if django_name:
+        hasher.django_name = django_name
+    return hasher
+
+#=============================================================================
+# predefined handlers
+#=============================================================================
+
+# NOTE: some digests below are marked as "required=False", because these may not be present on
+#       FIPS systems (see issue 116).  if missing, will return stub hasher that throws error
+#       if an attempt is made to actually use hash/verify with them.
+
+hex_md4     = create_hex_hash("md4", required=False)
+hex_md5     = create_hex_hash("md5", django_name="unsalted_md5", required=False)
+hex_sha1    = create_hex_hash("sha1", required=False)
+hex_sha256  = create_hex_hash("sha256")
+hex_sha512  = create_hex_hash("sha512")
+
+#=============================================================================
+# htdigest
+#=============================================================================
+class htdigest(uh.MinimalHandler):
+    """htdigest hash function.
+
+    .. todo::
+        document this hash
+    """
+    name = "htdigest"
+    setting_kwds = ()
+    context_kwds = ("user", "realm", "encoding")
+    default_encoding = "utf-8"
+
+    @classmethod
+    def hash(cls, secret, user, realm, encoding=None):
+        # NOTE: this was deliberately written so that raw bytes are passed through
+        # unchanged, the encoding kwd is only used to handle unicode values.
+        if not encoding:
+            encoding = cls.default_encoding
+        uh.validate_secret(secret)
+        if isinstance(secret, unicode):
+            secret = secret.encode(encoding)
+        user = to_bytes(user, encoding, "user")
+        realm = to_bytes(realm, encoding, "realm")
+        data = render_bytes("%s:%s:%s", user, realm, secret)
+        return hashlib.md5(data).hexdigest()
+
+    @classmethod
+    def _norm_hash(cls, hash):
+        """normalize hash to native string, and validate it"""
+        hash = to_native_str(hash, param="hash")
+        if len(hash) != 32:
+            raise uh.exc.MalformedHashError(cls, "wrong size")
+        for char in hash:
+            if char not in uh.LC_HEX_CHARS:
+                raise uh.exc.MalformedHashError(cls, "invalid chars in hash")
+        return hash
+
+    @classmethod
+    def verify(cls, secret, hash, user, realm, encoding="utf-8"):
+        hash = cls._norm_hash(hash)
+        other = cls.hash(secret, user, realm, encoding)
+        return consteq(hash, other)
+
+    @classmethod
+    def identify(cls, hash):
+        try:
+            cls._norm_hash(hash)
+        except ValueError:
+            return False
+        return True
+
+    @uh.deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genconfig(cls):
+        return cls.hash("", "", "")
+
+    @uh.deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genhash(cls, secret, config, user, realm, encoding=None):
+        # NOTE: 'config' is ignored, as this hash has no salting / other configuration.
+        #       just have to make sure it's valid.
+        cls._norm_hash(config)
+        return cls.hash(secret, user, realm, encoding)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/django.py b/myenv/lib/python3.9/site-packages/passlib/handlers/django.py
new file mode 100644
index 0000000..6dd499a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/django.py
@@ -0,0 +1,512 @@
+"""passlib.handlers.django- Django password hash support"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from base64 import b64encode
+from binascii import hexlify
+from hashlib import md5, sha1, sha256
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.handlers.bcrypt import _wrapped_bcrypt
+from passlib.hash import argon2, bcrypt, pbkdf2_sha1, pbkdf2_sha256
+from passlib.utils import to_unicode, rng, getrandstr
+from passlib.utils.binary import BASE64_CHARS
+from passlib.utils.compat import str_to_uascii, uascii_to_str, unicode, u
+from passlib.crypto.digest import pbkdf2_hmac
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "django_salted_sha1",
+    "django_salted_md5",
+    "django_bcrypt",
+    "django_pbkdf2_sha1",
+    "django_pbkdf2_sha256",
+    "django_argon2",
+    "django_des_crypt",
+    "django_disabled",
+]
+
+#=============================================================================
+# lazy imports & constants
+#=============================================================================
+
+# imported by django_des_crypt._calc_checksum()
+des_crypt = None
+
+def _import_des_crypt():
+    global des_crypt
+    if des_crypt is None:
+        from passlib.hash import des_crypt
+    return des_crypt
+
+# django 1.4's salt charset
+SALT_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+
+#=============================================================================
+# salted hashes
+#=============================================================================
+class DjangoSaltedHash(uh.HasSalt, uh.GenericHandler):
+    """base class providing common code for django hashes"""
+    # name, ident, checksum_size must be set by subclass.
+    # ident must include "$" suffix.
+    setting_kwds = ("salt", "salt_size")
+
+    # NOTE: django 1.0-1.3 would accept empty salt strings.
+    #       django 1.4 won't, but this appears to be regression
+    #       (https://code.djangoproject.com/ticket/18144)
+    #       so presumably it will be fixed in a later release.
+    default_salt_size = 12
+    max_salt_size = None
+    salt_chars = SALT_CHARS
+
+    checksum_chars = uh.LOWER_HEX_CHARS
+
+    @classmethod
+    def from_string(cls, hash):
+        salt, chk = uh.parse_mc2(hash, cls.ident, handler=cls)
+        return cls(salt=salt, checksum=chk)
+
+    def to_string(self):
+        return uh.render_mc2(self.ident, self.salt, self.checksum)
+
+# NOTE: only used by PBKDF2
+class DjangoVariableHash(uh.HasRounds, DjangoSaltedHash):
+    """base class providing common code for django hashes w/ variable rounds"""
+    setting_kwds = DjangoSaltedHash.setting_kwds + ("rounds",)
+
+    min_rounds = 1
+
+    @classmethod
+    def from_string(cls, hash):
+        rounds, salt, chk = uh.parse_mc3(hash, cls.ident, handler=cls)
+        return cls(rounds=rounds, salt=salt, checksum=chk)
+
+    def to_string(self):
+        return uh.render_mc3(self.ident, self.rounds, self.salt, self.checksum)
+
+class django_salted_sha1(DjangoSaltedHash):
+    """This class implements Django's Salted SHA1 hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and uses a single round of SHA1.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash` and :meth:`~passlib.ifc.PasswordHash.genconfig` methods accept the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, a 12 character one will be autogenerated (this is recommended).
+        If specified, may be any series of characters drawn from the regexp range ``[0-9a-zA-Z]``.
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of characters to use when autogenerating new salts.
+        Defaults to 12, but can be any positive value.
+
+    This should be compatible with Django 1.4's :class:`!SHA1PasswordHasher` class.
+
+    .. versionchanged: 1.6
+        This class now generates 12-character salts instead of 5,
+        and generated salts uses the character range ``[0-9a-zA-Z]`` instead of
+        the ``[0-9a-f]``. This is to be compatible with how Django >= 1.4
+        generates these hashes; but hashes generated in this manner will still be
+        correctly interpreted by earlier versions of Django.
+    """
+    name = "django_salted_sha1"
+    django_name = "sha1"
+    ident = u("sha1$")
+    checksum_size = 40
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        return str_to_uascii(sha1(self.salt.encode("ascii") + secret).hexdigest())
+
+class django_salted_md5(DjangoSaltedHash):
+    """This class implements Django's Salted MD5 hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and uses a single round of MD5.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash` and :meth:`~passlib.ifc.PasswordHash.genconfig` methods accept the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, a 12 character one will be autogenerated (this is recommended).
+        If specified, may be any series of characters drawn from the regexp range ``[0-9a-zA-Z]``.
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of characters to use when autogenerating new salts.
+        Defaults to 12, but can be any positive value.
+
+    This should be compatible with the hashes generated by
+    Django 1.4's :class:`!MD5PasswordHasher` class.
+
+    .. versionchanged: 1.6
+        This class now generates 12-character salts instead of 5,
+        and generated salts uses the character range ``[0-9a-zA-Z]`` instead of
+        the ``[0-9a-f]``. This is to be compatible with how Django >= 1.4
+        generates these hashes; but hashes generated in this manner will still be
+        correctly interpreted by earlier versions of Django.
+    """
+    name = "django_salted_md5"
+    django_name = "md5"
+    ident = u("md5$")
+    checksum_size = 32
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        return str_to_uascii(md5(self.salt.encode("ascii") + secret).hexdigest())
+
+#=============================================================================
+# BCrypt
+#=============================================================================
+
+django_bcrypt = uh.PrefixWrapper("django_bcrypt", bcrypt,
+    prefix=u('bcrypt$'), ident=u("bcrypt$"),
+    # NOTE: this docstring is duplicated in the docs, since sphinx
+    # seems to be having trouble reading it via autodata::
+    doc="""This class implements Django 1.4's BCrypt wrapper, and follows the :ref:`password-hash-api`.
+
+    This is identical to :class:`!bcrypt` itself, but with
+    the Django-specific prefix ``"bcrypt$"`` prepended.
+
+    See :doc:`/lib/passlib.hash.bcrypt` for more details,
+    the usage and behavior is identical.
+
+    This should be compatible with the hashes generated by
+    Django 1.4's :class:`!BCryptPasswordHasher` class.
+
+    .. versionadded:: 1.6
+    """)
+django_bcrypt.django_name = "bcrypt"
+django_bcrypt._using_clone_attrs += ("django_name",)
+
+#=============================================================================
+# BCRYPT + SHA256
+#=============================================================================
+
+class django_bcrypt_sha256(_wrapped_bcrypt):
+    """This class implements Django 1.6's Bcrypt+SHA256 hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    While the algorithm and format is somewhat different,
+    the api and options for this hash are identical to :class:`!bcrypt` itself,
+    see :doc:`bcrypt </lib/passlib.hash.bcrypt>` for more details.
+
+    .. versionadded:: 1.6.2
+    """
+    name = "django_bcrypt_sha256"
+    django_name = "bcrypt_sha256"
+    _digest = sha256
+
+    # sample hash:
+    # bcrypt_sha256$$2a$06$/3OeRpbOf8/l6nPPRdZPp.nRiyYqPobEZGdNRBWihQhiFDh1ws1tu
+
+    # XXX: we can't use .ident attr due to bcrypt code using it.
+    #      working around that via django_prefix
+    django_prefix = u('bcrypt_sha256$')
+
+    @classmethod
+    def identify(cls, hash):
+        hash = uh.to_unicode_for_identify(hash)
+        if not hash:
+            return False
+        return hash.startswith(cls.django_prefix)
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+        if not hash.startswith(cls.django_prefix):
+            raise uh.exc.InvalidHashError(cls)
+        bhash = hash[len(cls.django_prefix):]
+        if not bhash.startswith("$2"):
+            raise uh.exc.MalformedHashError(cls)
+        return super(django_bcrypt_sha256, cls).from_string(bhash)
+
+    def to_string(self):
+        bhash = super(django_bcrypt_sha256, self).to_string()
+        return uascii_to_str(self.django_prefix) + bhash
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        secret = hexlify(self._digest(secret).digest())
+        return super(django_bcrypt_sha256, self)._calc_checksum(secret)
+
+#=============================================================================
+# PBKDF2 variants
+#=============================================================================
+
+class django_pbkdf2_sha256(DjangoVariableHash):
+    """This class implements Django's PBKDF2-HMAC-SHA256 hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, a 12 character one will be autogenerated (this is recommended).
+        If specified, may be any series of characters drawn from the regexp range ``[0-9a-zA-Z]``.
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of characters to use when autogenerating new salts.
+        Defaults to 12, but can be any positive value.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 29000, but must be within ``range(1,1<<32)``.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+    This should be compatible with the hashes generated by
+    Django 1.4's :class:`!PBKDF2PasswordHasher` class.
+
+    .. versionadded:: 1.6
+    """
+    name = "django_pbkdf2_sha256"
+    django_name = "pbkdf2_sha256"
+    ident = u('pbkdf2_sha256$')
+    min_salt_size = 1
+    max_rounds = 0xffffffff # setting at 32-bit limit for now
+    checksum_chars = uh.PADDED_BASE64_CHARS
+    checksum_size = 44 # 32 bytes -> base64
+    default_rounds = pbkdf2_sha256.default_rounds # NOTE: django 1.6 uses 12000
+    _digest = "sha256"
+
+    def _calc_checksum(self, secret):
+        # NOTE: secret & salt will be encoded using UTF-8 by pbkdf2_hmac()
+        hash = pbkdf2_hmac(self._digest, secret, self.salt, self.rounds)
+        return b64encode(hash).rstrip().decode("ascii")
+
+class django_pbkdf2_sha1(django_pbkdf2_sha256):
+    """This class implements Django's PBKDF2-HMAC-SHA1 hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, a 12 character one will be autogenerated (this is recommended).
+        If specified, may be any series of characters drawn from the regexp range ``[0-9a-zA-Z]``.
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of characters to use when autogenerating new salts.
+        Defaults to 12, but can be any positive value.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 131000, but must be within ``range(1,1<<32)``.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+    This should be compatible with the hashes generated by
+    Django 1.4's :class:`!PBKDF2SHA1PasswordHasher` class.
+
+    .. versionadded:: 1.6
+    """
+    name = "django_pbkdf2_sha1"
+    django_name = "pbkdf2_sha1"
+    ident = u('pbkdf2_sha1$')
+    checksum_size = 28 # 20 bytes -> base64
+    default_rounds = pbkdf2_sha1.default_rounds # NOTE: django 1.6 uses 12000
+    _digest = "sha1"
+
+#=============================================================================
+# Argon2
+#=============================================================================
+
+# NOTE: as of 2019-11-11, Django's Argon2PasswordHasher only supports Type I;
+#       so limiting this to ensure that as well.
+
+django_argon2 = uh.PrefixWrapper(
+    name="django_argon2",
+    wrapped=argon2.using(type="I"),
+    prefix=u('argon2'),
+    ident=u('argon2$argon2i$'),
+    # NOTE: this docstring is duplicated in the docs, since sphinx
+    # seems to be having trouble reading it via autodata::
+    doc="""This class implements Django 1.10's Argon2 wrapper, and follows the :ref:`password-hash-api`.
+
+    This is identical to :class:`!argon2` itself, but with
+    the Django-specific prefix ``"argon2$"`` prepended.
+
+    See :doc:`argon2 </lib/passlib.hash.argon2>` for more details,
+    the usage and behavior is identical.
+
+    This should be compatible with the hashes generated by
+    Django 1.10's :class:`!Argon2PasswordHasher` class.
+
+    .. versionadded:: 1.7
+    """)
+django_argon2.django_name = "argon2"
+django_argon2._using_clone_attrs += ("django_name",)
+
+#=============================================================================
+# DES
+#=============================================================================
+class django_des_crypt(uh.TruncateMixin, uh.HasSalt, uh.GenericHandler):
+    """This class implements Django's :class:`des_crypt` wrapper, and follows the :ref:`password-hash-api`.
+
+    It supports a fixed-length salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash` and :meth:`~passlib.ifc.PasswordHash.genconfig` methods accept the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 2 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :param bool truncate_error:
+        By default, django_des_crypt will silently truncate passwords larger than 8 bytes.
+        Setting ``truncate_error=True`` will cause :meth:`~passlib.ifc.PasswordHash.hash`
+        to raise a :exc:`~passlib.exc.PasswordTruncateError` instead.
+
+        .. versionadded:: 1.7
+
+    This should be compatible with the hashes generated by
+    Django 1.4's :class:`!CryptPasswordHasher` class.
+    Note that Django only supports this hash on Unix systems
+    (though :class:`!django_des_crypt` is available cross-platform
+    under Passlib).
+
+    .. versionchanged:: 1.6
+        This class will now accept hashes with empty salt strings,
+        since Django 1.4 generates them this way.
+    """
+    name = "django_des_crypt"
+    django_name = "crypt"
+    setting_kwds = ("salt", "salt_size", "truncate_error")
+    ident = u("crypt$")
+    checksum_chars = salt_chars = uh.HASH64_CHARS
+    checksum_size = 11
+    min_salt_size = default_salt_size = 2
+    truncate_size = 8
+
+    # NOTE: regarding duplicate salt field:
+    #
+    # django 1.0 had a "crypt$<salt1>$<salt2><digest>" hash format,
+    # used [a-z0-9] to generate a 5 char salt, stored it in salt1,
+    # duplicated the first two chars of salt1 as salt2.
+    # it would throw an error if salt1 was empty.
+    #
+    # django 1.4 started generating 2 char salt using the full alphabet,
+    # left salt1 empty, and only paid attention to salt2.
+    #
+    # in order to be compatible with django 1.0, the hashes generated
+    # by this function will always include salt1, unless the following
+    # class-level field is disabled (mainly used for testing)
+    use_duplicate_salt = True
+
+    @classmethod
+    def from_string(cls, hash):
+        salt, chk = uh.parse_mc2(hash, cls.ident, handler=cls)
+        if chk:
+            # chk should be full des_crypt hash
+            if not salt:
+                # django 1.4 always uses empty salt field,
+                # so extract salt from des_crypt hash <chk>
+                salt = chk[:2]
+            elif salt[:2] != chk[:2]:
+                # django 1.0 stored 5 chars in salt field, and duplicated
+                # the first two chars in <chk>. we keep the full salt,
+                # but make sure the first two chars match as sanity check.
+                raise uh.exc.MalformedHashError(cls,
+                    "first two digits of salt and checksum must match")
+            # in all cases, strip salt chars from <chk>
+            chk = chk[2:]
+        return cls(salt=salt, checksum=chk)
+
+    def to_string(self):
+        salt = self.salt
+        chk = salt[:2] + self.checksum
+        if self.use_duplicate_salt:
+            # filling in salt field, so that we're compatible with django 1.0
+            return uh.render_mc2(self.ident, salt, chk)
+        else:
+            # django 1.4+ style hash
+            return uh.render_mc2(self.ident, "", chk)
+
+    def _calc_checksum(self, secret):
+        # NOTE: we lazily import des_crypt,
+        #       since most django deploys won't use django_des_crypt
+        global des_crypt
+        if des_crypt is None:
+            _import_des_crypt()
+        # check for truncation (during .hash() calls only)
+        if self.use_defaults:
+            self._check_truncate_policy(secret)
+        return des_crypt(salt=self.salt[:2])._calc_checksum(secret)
+
+class django_disabled(uh.ifc.DisabledHash, uh.StaticHandler):
+    """This class provides disabled password behavior for Django, and follows the :ref:`password-hash-api`.
+
+    This class does not implement a hash, but instead
+    claims the special hash string ``"!"`` which Django uses
+    to indicate an account's password has been disabled.
+
+    * newly encrypted passwords will hash to ``"!"``.
+    * it rejects all passwords.
+
+    .. note::
+
+        Django 1.6 prepends a randomly generated 40-char alphanumeric string
+        to each unusuable password. This class recognizes such strings,
+        but for backwards compatibility, still returns ``"!"``.
+
+        See `<https://code.djangoproject.com/ticket/20079>`_ for why
+        Django appends an alphanumeric string.
+
+    .. versionchanged:: 1.6.2 added Django 1.6 support
+
+    .. versionchanged:: 1.7 started appending an alphanumeric string.
+    """
+    name = "django_disabled"
+    _hash_prefix = u("!")
+    suffix_length = 40
+
+    # XXX: move this to StaticHandler, or wherever _hash_prefix is being used?
+    @classmethod
+    def identify(cls, hash):
+        hash = uh.to_unicode_for_identify(hash)
+        return hash.startswith(cls._hash_prefix)
+
+    def _calc_checksum(self, secret):
+        # generate random suffix to match django's behavior
+        return getrandstr(rng, BASE64_CHARS[:-2], self.suffix_length)
+
+    @classmethod
+    def verify(cls, secret, hash):
+        uh.validate_secret(secret)
+        if not cls.identify(hash):
+            raise uh.exc.InvalidHashError(cls)
+        return False
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/fshp.py b/myenv/lib/python3.9/site-packages/passlib/handlers/fshp.py
new file mode 100644
index 0000000..db13e74
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/fshp.py
@@ -0,0 +1,214 @@
+"""passlib.handlers.fshp
+"""
+
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from base64 import b64encode, b64decode
+import re
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils import to_unicode
+import passlib.utils.handlers as uh
+from passlib.utils.compat import bascii_to_str, iteritems, u,\
+                                 unicode
+from passlib.crypto.digest import pbkdf1
+# local
+__all__ = [
+    'fshp',
+]
+#=============================================================================
+# sha1-crypt
+#=============================================================================
+class fshp(uh.HasRounds, uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
+    """This class implements the FSHP password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :param salt:
+        Optional raw salt string.
+        If not specified, one will be autogenerated (this is recommended).
+
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to 16 bytes, but can be any non-negative value.
+
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 480000, must be between 1 and 4294967295, inclusive.
+
+    :param variant:
+        Optionally specifies variant of FSHP to use.
+
+        * ``0`` - uses SHA-1 digest (deprecated).
+        * ``1`` - uses SHA-2/256 digest (default).
+        * ``2`` - uses SHA-2/384 digest.
+        * ``3`` - uses SHA-2/512 digest.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+
+    #===================================================================
+    # class attrs
+    #===================================================================
+    #--GenericHandler--
+    name = "fshp"
+    setting_kwds = ("salt", "salt_size", "rounds", "variant")
+    checksum_chars = uh.PADDED_BASE64_CHARS
+    ident = u("{FSHP")
+    # checksum_size is property() that depends on variant
+
+    #--HasRawSalt--
+    default_salt_size = 16 # current passlib default, FSHP uses 8
+    max_salt_size = None
+
+    #--HasRounds--
+    # FIXME: should probably use different default rounds
+    # based on the variant. setting for default variant (sha256) for now.
+    default_rounds = 480000 # current passlib default, FSHP uses 4096
+    min_rounds = 1 # set by FSHP
+    max_rounds = 4294967295 # 32-bit integer limit - not set by FSHP
+    rounds_cost = "linear"
+
+    #--variants--
+    default_variant = 1
+    _variant_info = {
+        # variant: (hash name, digest size)
+        0: ("sha1",     20),
+        1: ("sha256",   32),
+        2: ("sha384",   48),
+        3: ("sha512",   64),
+        }
+    _variant_aliases = dict(
+        [(unicode(k),k) for k in _variant_info] +
+        [(v[0],k) for k,v in iteritems(_variant_info)]
+        )
+
+    #===================================================================
+    # configuration
+    #===================================================================
+    @classmethod
+    def using(cls, variant=None, **kwds):
+        subcls = super(fshp, cls).using(**kwds)
+        if variant is not None:
+            subcls.default_variant = cls._norm_variant(variant)
+        return subcls
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+    variant = None
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, variant=None, **kwds):
+        # NOTE: variant must be set first, since it controls checksum size, etc.
+        self.use_defaults = kwds.get("use_defaults") # load this early
+        if variant is not None:
+            variant = self._norm_variant(variant)
+        elif self.use_defaults:
+            variant = self.default_variant
+            assert self._norm_variant(variant) == variant, "invalid default variant: %r" % (variant,)
+        else:
+            raise TypeError("no variant specified")
+        self.variant = variant
+        super(fshp, self).__init__(**kwds)
+
+    @classmethod
+    def _norm_variant(cls, variant):
+        if isinstance(variant, bytes):
+            variant = variant.decode("ascii")
+        if isinstance(variant, unicode):
+            try:
+                variant = cls._variant_aliases[variant]
+            except KeyError:
+                raise ValueError("invalid fshp variant")
+        if not isinstance(variant, int):
+            raise TypeError("fshp variant must be int or known alias")
+        if variant not in cls._variant_info:
+            raise ValueError("invalid fshp variant")
+        return variant
+
+    @property
+    def checksum_alg(self):
+        return self._variant_info[self.variant][0]
+
+    @property
+    def checksum_size(self):
+        return self._variant_info[self.variant][1]
+
+    #===================================================================
+    # formatting
+    #===================================================================
+
+    _hash_regex = re.compile(u(r"""
+            ^
+            \{FSHP
+            (\d+)\| # variant
+            (\d+)\| # salt size
+            (\d+)\} # rounds
+            ([a-zA-Z0-9+/]+={0,3}) # digest
+            $"""), re.X)
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+        m = cls._hash_regex.match(hash)
+        if not m:
+            raise uh.exc.InvalidHashError(cls)
+        variant, salt_size, rounds, data = m.group(1,2,3,4)
+        variant = int(variant)
+        salt_size = int(salt_size)
+        rounds = int(rounds)
+        try:
+            data = b64decode(data.encode("ascii"))
+        except TypeError:
+            raise uh.exc.MalformedHashError(cls)
+        salt = data[:salt_size]
+        chk = data[salt_size:]
+        return cls(salt=salt, checksum=chk, rounds=rounds, variant=variant)
+
+    def to_string(self):
+        chk = self.checksum
+        salt = self.salt
+        data = bascii_to_str(b64encode(salt+chk))
+        return "{FSHP%d|%d|%d}%s" % (self.variant, len(salt), self.rounds, data)
+
+    #===================================================================
+    # backend
+    #===================================================================
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        # NOTE: for some reason, FSHP uses pbkdf1 with password & salt reversed.
+        #       this has only a minimal impact on security,
+        #       but it is worth noting this deviation.
+        return pbkdf1(
+            digest=self.checksum_alg,
+            secret=self.salt,
+            salt=secret,
+            rounds=self.rounds,
+            keylen=self.checksum_size,
+            )
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/ldap_digests.py b/myenv/lib/python3.9/site-packages/passlib/handlers/ldap_digests.py
new file mode 100644
index 0000000..30254f0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/ldap_digests.py
@@ -0,0 +1,359 @@
+"""passlib.handlers.digests - plain hash digests
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from base64 import b64encode, b64decode
+from hashlib import md5, sha1, sha256, sha512
+import logging; log = logging.getLogger(__name__)
+import re
+# site
+# pkg
+from passlib.handlers.misc import plaintext
+from passlib.utils import unix_crypt_schemes, to_unicode
+from passlib.utils.compat import uascii_to_str, unicode, u
+from passlib.utils.decor import classproperty
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "ldap_plaintext",
+    "ldap_md5",
+    "ldap_sha1",
+    "ldap_salted_md5",
+    "ldap_salted_sha1",
+    "ldap_salted_sha256",
+    "ldap_salted_sha512",
+
+    ##"get_active_ldap_crypt_schemes",
+    "ldap_des_crypt",
+    "ldap_bsdi_crypt",
+    "ldap_md5_crypt",
+    "ldap_sha1_crypt",
+    "ldap_bcrypt",
+    "ldap_sha256_crypt",
+    "ldap_sha512_crypt",
+]
+
+#=============================================================================
+# ldap helpers
+#=============================================================================
+class _Base64DigestHelper(uh.StaticHandler):
+    """helper for ldap_md5 / ldap_sha1"""
+    # XXX: could combine this with hex digests in digests.py
+
+    ident = None # required - prefix identifier
+    _hash_func = None # required - hash function
+    _hash_regex = None # required - regexp to recognize hash
+    checksum_chars = uh.PADDED_BASE64_CHARS
+
+    @classproperty
+    def _hash_prefix(cls):
+        """tell StaticHandler to strip ident from checksum"""
+        return cls.ident
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        chk = self._hash_func(secret).digest()
+        return b64encode(chk).decode("ascii")
+
+class _SaltedBase64DigestHelper(uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
+    """helper for ldap_salted_md5 / ldap_salted_sha1"""
+    setting_kwds = ("salt", "salt_size")
+    checksum_chars = uh.PADDED_BASE64_CHARS
+
+    ident = None # required - prefix identifier
+    _hash_func = None # required - hash function
+    _hash_regex = None # required - regexp to recognize hash
+    min_salt_size = max_salt_size = 4
+
+    # NOTE: openldap implementation uses 4 byte salt,
+    # but it's been reported (issue 30) that some servers use larger salts.
+    # the semi-related rfc3112 recommends support for up to 16 byte salts.
+    min_salt_size = 4
+    default_salt_size = 4
+    max_salt_size = 16
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+        m = cls._hash_regex.match(hash)
+        if not m:
+            raise uh.exc.InvalidHashError(cls)
+        try:
+            data = b64decode(m.group("tmp").encode("ascii"))
+        except TypeError:
+            raise uh.exc.MalformedHashError(cls)
+        cs = cls.checksum_size
+        assert cs
+        return cls(checksum=data[:cs], salt=data[cs:])
+
+    def to_string(self):
+        data = self.checksum + self.salt
+        hash = self.ident + b64encode(data).decode("ascii")
+        return uascii_to_str(hash)
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        return self._hash_func(secret + self.salt).digest()
+
+#=============================================================================
+# implementations
+#=============================================================================
+class ldap_md5(_Base64DigestHelper):
+    """This class stores passwords using LDAP's plain MD5 format, and follows the :ref:`password-hash-api`.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash` and :meth:`~passlib.ifc.PasswordHash.genconfig` methods have no optional keywords.
+    """
+    name = "ldap_md5"
+    ident = u("{MD5}")
+    _hash_func = md5
+    _hash_regex = re.compile(u(r"^\{MD5\}(?P<chk>[+/a-zA-Z0-9]{22}==)$"))
+
+class ldap_sha1(_Base64DigestHelper):
+    """This class stores passwords using LDAP's plain SHA1 format, and follows the :ref:`password-hash-api`.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash` and :meth:`~passlib.ifc.PasswordHash.genconfig` methods have no optional keywords.
+    """
+    name = "ldap_sha1"
+    ident = u("{SHA}")
+    _hash_func = sha1
+    _hash_regex = re.compile(u(r"^\{SHA\}(?P<chk>[+/a-zA-Z0-9]{27}=)$"))
+
+class ldap_salted_md5(_SaltedBase64DigestHelper):
+    """This class stores passwords using LDAP's salted MD5 format, and follows the :ref:`password-hash-api`.
+
+    It supports a 4-16 byte salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: bytes
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it may be any 4-16 byte string.
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to 4 bytes for compatibility with the LDAP spec,
+        but some systems use larger salts, and Passlib supports
+        any value between 4-16.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+
+    .. versionchanged:: 1.6
+        This format now supports variable length salts, instead of a fix 4 bytes.
+    """
+    name = "ldap_salted_md5"
+    ident = u("{SMD5}")
+    checksum_size = 16
+    _hash_func = md5
+    _hash_regex = re.compile(u(r"^\{SMD5\}(?P<tmp>[+/a-zA-Z0-9]{27,}={0,2})$"))
+
+class ldap_salted_sha1(_SaltedBase64DigestHelper):
+    """
+    This class stores passwords using LDAP's "Salted SHA1" format,
+    and follows the :ref:`password-hash-api`.
+
+    It supports a 4-16 byte salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: bytes
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it may be any 4-16 byte string.
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to 4 bytes for compatibility with the LDAP spec,
+        but some systems use larger salts, and Passlib supports
+        any value between 4-16.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+
+    .. versionchanged:: 1.6
+        This format now supports variable length salts, instead of a fix 4 bytes.
+    """
+    name = "ldap_salted_sha1"
+    ident = u("{SSHA}")
+    checksum_size = 20
+    _hash_func = sha1
+    # NOTE: 32 = ceil((20 + 4) * 4/3)
+    _hash_regex = re.compile(u(r"^\{SSHA\}(?P<tmp>[+/a-zA-Z0-9]{32,}={0,2})$"))
+
+
+
+class ldap_salted_sha256(_SaltedBase64DigestHelper):
+    """
+    This class stores passwords using LDAP's "Salted SHA2-256" format,
+    and follows the :ref:`password-hash-api`.
+
+    It supports a 4-16 byte salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: bytes
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it may be any 4-16 byte string.
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to 8 bytes for compatibility with the LDAP spec,
+        but Passlib supports any value between 4-16.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+
+    .. versionadded:: 1.7.3
+    """
+    name = "ldap_salted_sha256"
+    ident = u("{SSHA256}")
+    checksum_size = 32
+    default_salt_size = 8
+    _hash_func = sha256
+    # NOTE: 48 = ceil((32 + 4) * 4/3)
+    _hash_regex = re.compile(u(r"^\{SSHA256\}(?P<tmp>[+/a-zA-Z0-9]{48,}={0,2})$"))
+
+
+class ldap_salted_sha512(_SaltedBase64DigestHelper):
+    """
+    This class stores passwords using LDAP's "Salted SHA2-512" format,
+    and follows the :ref:`password-hash-api`.
+
+    It supports a 4-16 byte salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: bytes
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it may be any 4-16 byte string.
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to 8 bytes for compatibility with the LDAP spec,
+        but Passlib supports any value between 4-16.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+
+    .. versionadded:: 1.7.3
+    """
+    name = "ldap_salted_sha512"
+    ident = u("{SSHA512}")
+    checksum_size = 64
+    default_salt_size = 8
+    _hash_func = sha512
+    # NOTE: 91 = ceil((64 + 4) * 4/3)
+    _hash_regex = re.compile(u(r"^\{SSHA512\}(?P<tmp>[+/a-zA-Z0-9]{91,}={0,2})$"))
+
+
+class ldap_plaintext(plaintext):
+    """This class stores passwords in plaintext, and follows the :ref:`password-hash-api`.
+
+    This class acts much like the generic :class:`!passlib.hash.plaintext` handler,
+    except that it will identify a hash only if it does NOT begin with the ``{XXX}`` identifier prefix
+    used by RFC2307 passwords.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash`, :meth:`~passlib.ifc.PasswordHash.genhash`, and :meth:`~passlib.ifc.PasswordHash.verify` methods all require the
+    following additional contextual keyword:
+
+    :type encoding: str
+    :param encoding:
+        This controls the character encoding to use (defaults to ``utf-8``).
+
+        This encoding will be used to encode :class:`!unicode` passwords
+        under Python 2, and decode :class:`!bytes` hashes under Python 3.
+
+    .. versionchanged:: 1.6
+        The ``encoding`` keyword was added.
+    """
+    # NOTE: this subclasses plaintext, since all it does differently
+    # is override identify()
+
+    name = "ldap_plaintext"
+    _2307_pat = re.compile(u(r"^\{\w+\}.*$"))
+
+    @uh.deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genconfig(cls):
+        # Overridding plaintext.genconfig() since it returns "",
+        # but have to return non-empty value due to identify() below
+        return "!"
+
+    @classmethod
+    def identify(cls, hash):
+        # NOTE: identifies all strings EXCEPT those with {XXX} prefix
+        hash = uh.to_unicode_for_identify(hash)
+        return bool(hash) and cls._2307_pat.match(hash) is None
+
+#=============================================================================
+# {CRYPT} wrappers
+# the following are wrappers around the base crypt algorithms,
+# which add the ldap required {CRYPT} prefix
+#=============================================================================
+ldap_crypt_schemes = [ 'ldap_' + name for name in unix_crypt_schemes ]
+
+def _init_ldap_crypt_handlers():
+    # NOTE: I don't like to implicitly modify globals() like this,
+    #       but don't want to write out all these handlers out either :)
+    g = globals()
+    for wname in unix_crypt_schemes:
+        name = 'ldap_' + wname
+        g[name] = uh.PrefixWrapper(name, wname, prefix=u("{CRYPT}"), lazy=True)
+    del g
+_init_ldap_crypt_handlers()
+
+##_lcn_host = None
+##def get_host_ldap_crypt_schemes():
+##    global _lcn_host
+##    if _lcn_host is None:
+##        from passlib.hosts import host_context
+##        schemes = host_context.schemes()
+##        _lcn_host = [
+##            "ldap_" + name
+##            for name in unix_crypt_names
+##            if name in schemes
+##        ]
+##    return _lcn_host
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/md5_crypt.py b/myenv/lib/python3.9/site-packages/passlib/handlers/md5_crypt.py
new file mode 100644
index 0000000..e3a2dfa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/md5_crypt.py
@@ -0,0 +1,346 @@
+"""passlib.handlers.md5_crypt - md5-crypt algorithm"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from hashlib import md5
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils import safe_crypt, test_crypt, repeat_string
+from passlib.utils.binary import h64
+from passlib.utils.compat import unicode, u
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "md5_crypt",
+    "apr_md5_crypt",
+]
+
+#=============================================================================
+# pure-python backend
+#=============================================================================
+_BNULL = b"\x00"
+_MD5_MAGIC = b"$1$"
+_APR_MAGIC = b"$apr1$"
+
+# pre-calculated offsets used to speed up C digest stage (see notes below).
+# sequence generated using the following:
+    ##perms_order = "p,pp,ps,psp,sp,spp".split(",")
+    ##def offset(i):
+    ##    key = (("p" if i % 2 else "") + ("s" if i % 3 else "") +
+    ##        ("p" if i % 7 else "") + ("" if i % 2 else "p"))
+    ##    return perms_order.index(key)
+    ##_c_digest_offsets = [(offset(i), offset(i+1)) for i in range(0,42,2)]
+_c_digest_offsets = (
+    (0, 3), (5, 1), (5, 3), (1, 2), (5, 1), (5, 3), (1, 3),
+    (4, 1), (5, 3), (1, 3), (5, 0), (5, 3), (1, 3), (5, 1),
+    (4, 3), (1, 3), (5, 1), (5, 2), (1, 3), (5, 1), (5, 3),
+    )
+
+# map used to transpose bytes when encoding final digest
+_transpose_map = (12, 6, 0, 13, 7, 1, 14, 8, 2, 15, 9, 3, 5, 10, 4, 11)
+
+def _raw_md5_crypt(pwd, salt, use_apr=False):
+    """perform raw md5-crypt calculation
+
+    this function provides a pure-python implementation of the internals
+    for the MD5-Crypt algorithms; it doesn't handle any of the
+    parsing/validation of the hash strings themselves.
+
+    :arg pwd: password chars/bytes to hash
+    :arg salt: salt chars to use
+    :arg use_apr: use apache variant
+
+    :returns:
+        encoded checksum chars
+    """
+    # NOTE: regarding 'apr' format:
+    # really, apache? you had to invent a whole new "$apr1$" format,
+    # when all you did was change the ident incorporated into the hash?
+    # would love to find webpage explaining why just using a portable
+    # implementation of $1$ wasn't sufficient. *nothing else* was changed.
+
+    #===================================================================
+    # init & validate inputs
+    #===================================================================
+
+    # validate secret
+    # XXX: not sure what official unicode policy is, using this as default
+    if isinstance(pwd, unicode):
+        pwd = pwd.encode("utf-8")
+    assert isinstance(pwd, bytes), "pwd not unicode or bytes"
+    if _BNULL in pwd:
+        raise uh.exc.NullPasswordError(md5_crypt)
+    pwd_len = len(pwd)
+
+    # validate salt - should have been taken care of by caller
+    assert isinstance(salt, unicode), "salt not unicode"
+    salt = salt.encode("ascii")
+    assert len(salt) < 9, "salt too large"
+        # NOTE: spec says salts larger than 8 bytes should be truncated,
+        # instead of causing an error. this function assumes that's been
+        # taken care of by the handler class.
+
+    # load APR specific constants
+    if use_apr:
+        magic = _APR_MAGIC
+    else:
+        magic = _MD5_MAGIC
+
+    #===================================================================
+    # digest B - used as subinput to digest A
+    #===================================================================
+    db = md5(pwd + salt + pwd).digest()
+
+    #===================================================================
+    # digest A - used to initialize first round of digest C
+    #===================================================================
+    # start out with pwd + magic + salt
+    a_ctx = md5(pwd + magic + salt)
+    a_ctx_update = a_ctx.update
+
+    # add pwd_len bytes of b, repeating b as many times as needed.
+    a_ctx_update(repeat_string(db, pwd_len))
+
+    # add null chars & first char of password
+        # NOTE: this may have historically been a bug,
+        # where they meant to use db[0] instead of B_NULL,
+        # but the original code memclear'ed db,
+        # and now all implementations have to use this.
+    i = pwd_len
+    evenchar = pwd[:1]
+    while i:
+        a_ctx_update(_BNULL if i & 1 else evenchar)
+        i >>= 1
+
+    # finish A
+    da = a_ctx.digest()
+
+    #===================================================================
+    # digest C - for a 1000 rounds, combine A, S, and P
+    #            digests in various ways; in order to burn CPU time.
+    #===================================================================
+
+    # NOTE: the original MD5-Crypt implementation performs the C digest
+    # calculation using the following loop:
+    #
+    ##dc = da
+    ##i = 0
+    ##while i < rounds:
+    ##    tmp_ctx = md5(pwd if i & 1 else dc)
+    ##    if i % 3:
+    ##        tmp_ctx.update(salt)
+    ##    if i % 7:
+    ##        tmp_ctx.update(pwd)
+    ##    tmp_ctx.update(dc if i & 1 else pwd)
+    ##    dc = tmp_ctx.digest()
+    ##    i += 1
+    #
+    # The code Passlib uses (below) implements an equivalent algorithm,
+    # it's just been heavily optimized to pre-calculate a large number
+    # of things beforehand. It works off of a couple of observations
+    # about the original algorithm:
+    #
+    # 1. each round is a combination of 'dc', 'salt', and 'pwd'; and the exact
+    #    combination is determined by whether 'i' a multiple of 2,3, and/or 7.
+    # 2. since lcm(2,3,7)==42, the series of combinations will repeat
+    #    every 42 rounds.
+    # 3. even rounds 0-40 consist of 'hash(dc + round-specific-constant)';
+    #    while odd rounds 1-41 consist of hash(round-specific-constant + dc)
+    #
+    # Using these observations, the following code...
+    # * calculates the round-specific combination of salt & pwd for each round 0-41
+    # * runs through as many 42-round blocks as possible (23)
+    # * runs through as many pairs of rounds as needed for remaining rounds (17)
+    # * this results in the required 42*23+2*17=1000 rounds required by md5_crypt.
+    #
+    # this cuts out a lot of the control overhead incurred when running the
+    # original loop 1000 times in python, resulting in ~20% increase in
+    # speed under CPython (though still 2x slower than glibc crypt)
+
+    # prepare the 6 combinations of pwd & salt which are needed
+    # (order of 'perms' must match how _c_digest_offsets was generated)
+    pwd_pwd = pwd+pwd
+    pwd_salt = pwd+salt
+    perms = [pwd, pwd_pwd, pwd_salt, pwd_salt+pwd, salt+pwd, salt+pwd_pwd]
+
+    # build up list of even-round & odd-round constants,
+    # and store in 21-element list as (even,odd) pairs.
+    data = [ (perms[even], perms[odd]) for even, odd in _c_digest_offsets]
+
+    # perform 23 blocks of 42 rounds each (for a total of 966 rounds)
+    dc = da
+    blocks = 23
+    while blocks:
+        for even, odd in data:
+            dc = md5(odd + md5(dc + even).digest()).digest()
+        blocks -= 1
+
+    # perform 17 more pairs of rounds (34 more rounds, for a total of 1000)
+    for even, odd in data[:17]:
+        dc = md5(odd + md5(dc + even).digest()).digest()
+
+    #===================================================================
+    # encode digest using appropriate transpose map
+    #===================================================================
+    return h64.encode_transposed_bytes(dc, _transpose_map).decode("ascii")
+
+#=============================================================================
+# handler
+#=============================================================================
+class _MD5_Common(uh.HasSalt, uh.GenericHandler):
+    """common code for md5_crypt and apr_md5_crypt"""
+    #===================================================================
+    # class attrs
+    #===================================================================
+    # name - set in subclass
+    setting_kwds = ("salt", "salt_size")
+    # ident - set in subclass
+    checksum_size = 22
+    checksum_chars = uh.HASH64_CHARS
+
+    max_salt_size = 8
+    salt_chars = uh.HASH64_CHARS
+
+    #===================================================================
+    # methods
+    #===================================================================
+
+    @classmethod
+    def from_string(cls, hash):
+        salt, chk = uh.parse_mc2(hash, cls.ident, handler=cls)
+        return cls(salt=salt, checksum=chk)
+
+    def to_string(self):
+        return uh.render_mc2(self.ident, self.salt, self.checksum)
+
+    # _calc_checksum() - provided by subclass
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class md5_crypt(uh.HasManyBackends, _MD5_Common):
+    """This class implements the MD5-Crypt password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 0-8 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of characters to use when autogenerating new salts.
+        Defaults to 8, but can be any value between 0 and 8.
+        (This is mainly needed when generating Cisco-compatible hashes,
+        which require ``salt_size=4``).
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+    name = "md5_crypt"
+    ident = u("$1$")
+
+    #===================================================================
+    # methods
+    #===================================================================
+    # FIXME: can't find definitive policy on how md5-crypt handles non-ascii.
+    #        all backends currently coerce -> utf-8
+
+    backends = ("os_crypt", "builtin")
+
+    #---------------------------------------------------------------
+    # os_crypt backend
+    #---------------------------------------------------------------
+    @classmethod
+    def _load_backend_os_crypt(cls):
+        if test_crypt("test", '$1$test$pi/xDtU5WFVRqYS6BMU8X/'):
+            cls._set_calc_checksum_backend(cls._calc_checksum_os_crypt)
+            return True
+        else:
+            return False
+
+    def _calc_checksum_os_crypt(self, secret):
+        config = self.ident + self.salt
+        hash = safe_crypt(secret, config)
+        if hash is None:
+            # py3's crypt.crypt() can't handle non-utf8 bytes.
+            # fallback to builtin alg, which is always available.
+            return self._calc_checksum_builtin(secret)
+        if not hash.startswith(config) or len(hash) != len(config) + 23:
+            raise uh.exc.CryptBackendError(self, config, hash)
+        return hash[-22:]
+
+    #---------------------------------------------------------------
+    # builtin backend
+    #---------------------------------------------------------------
+    @classmethod
+    def _load_backend_builtin(cls):
+        cls._set_calc_checksum_backend(cls._calc_checksum_builtin)
+        return True
+
+    def _calc_checksum_builtin(self, secret):
+        return _raw_md5_crypt(secret, self.salt)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class apr_md5_crypt(_MD5_Common):
+    """This class implements the Apr-MD5-Crypt password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 0-8 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+    name = "apr_md5_crypt"
+    ident = u("$apr1$")
+
+    #===================================================================
+    # methods
+    #===================================================================
+    def _calc_checksum(self, secret):
+        return _raw_md5_crypt(secret, self.salt, use_apr=True)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/misc.py b/myenv/lib/python3.9/site-packages/passlib/handlers/misc.py
new file mode 100644
index 0000000..44abc34
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/misc.py
@@ -0,0 +1,269 @@
+"""passlib.handlers.misc - misc generic handlers
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import sys
+import logging; log = logging.getLogger(__name__)
+from warnings import warn
+# site
+# pkg
+from passlib.utils import to_native_str, str_consteq
+from passlib.utils.compat import unicode, u, unicode_or_bytes_types
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "unix_disabled",
+    "unix_fallback",
+    "plaintext",
+]
+
+#=============================================================================
+# handler
+#=============================================================================
+class unix_fallback(uh.ifc.DisabledHash, uh.StaticHandler):
+    """This class provides the fallback behavior for unix shadow files, and follows the :ref:`password-hash-api`.
+
+    This class does not implement a hash, but instead provides fallback
+    behavior as found in /etc/shadow on most unix variants.
+    If used, should be the last scheme in the context.
+
+    * this class will positively identify all hash strings.
+    * for security, passwords will always hash to ``!``.
+    * it rejects all passwords if the hash is NOT an empty string (``!`` or ``*`` are frequently used).
+    * by default it rejects all passwords if the hash is an empty string,
+      but if ``enable_wildcard=True`` is passed to verify(),
+      all passwords will be allowed through if the hash is an empty string.
+
+    .. deprecated:: 1.6
+        This has been deprecated due to its "wildcard" feature,
+        and will be removed in Passlib 1.8. Use :class:`unix_disabled` instead.
+    """
+    name = "unix_fallback"
+    context_kwds = ("enable_wildcard",)
+
+    @classmethod
+    def identify(cls, hash):
+        if isinstance(hash, unicode_or_bytes_types):
+            return True
+        else:
+            raise uh.exc.ExpectedStringError(hash, "hash")
+
+    def __init__(self, enable_wildcard=False, **kwds):
+        warn("'unix_fallback' is deprecated, "
+             "and will be removed in Passlib 1.8; "
+             "please use 'unix_disabled' instead.",
+             DeprecationWarning)
+        super(unix_fallback, self).__init__(**kwds)
+        self.enable_wildcard = enable_wildcard
+
+    def _calc_checksum(self, secret):
+        if self.checksum:
+            # NOTE: hash will generally be "!", but we want to preserve
+            # it in case it's something else, like "*".
+            return self.checksum
+        else:
+            return u("!")
+
+    @classmethod
+    def verify(cls, secret, hash, enable_wildcard=False):
+        uh.validate_secret(secret)
+        if not isinstance(hash, unicode_or_bytes_types):
+            raise uh.exc.ExpectedStringError(hash, "hash")
+        elif hash:
+            return False
+        else:
+            return enable_wildcard
+
+_MARKER_CHARS = u("*!")
+_MARKER_BYTES = b"*!"
+
+class unix_disabled(uh.ifc.DisabledHash, uh.MinimalHandler):
+    """This class provides disabled password behavior for unix shadow files,
+    and follows the :ref:`password-hash-api`.
+
+    This class does not implement a hash, but instead matches the "disabled account"
+    strings found in ``/etc/shadow`` on most Unix variants. "encrypting" a password
+    will simply return the disabled account marker. It will reject all passwords,
+    no matter the hash string. The :meth:`~passlib.ifc.PasswordHash.hash`
+    method supports one optional keyword:
+
+    :type marker: str
+    :param marker:
+        Optional marker string which overrides the platform default
+        used to indicate a disabled account.
+
+        If not specified, this will default to ``"*"`` on BSD systems,
+        and use the Linux default ``"!"`` for all other platforms.
+        (:attr:`!unix_disabled.default_marker` will contain the default value)
+
+    .. versionadded:: 1.6
+        This class was added as a replacement for the now-deprecated
+        :class:`unix_fallback` class, which had some undesirable features.
+    """
+    name = "unix_disabled"
+    setting_kwds = ("marker",)
+    context_kwds = ()
+
+    _disable_prefixes = tuple(str(_MARKER_CHARS))
+
+    # TODO: rename attr to 'marker'...
+    if 'bsd' in sys.platform: # pragma: no cover -- runtime detection
+        default_marker = u("*")
+    else:
+        # use the linux default for other systems
+        # (glibc also supports adding old hash after the marker
+        # so it can be restored later).
+        default_marker = u("!")
+
+    @classmethod
+    def using(cls, marker=None, **kwds):
+        subcls = super(unix_disabled, cls).using(**kwds)
+        if marker is not None:
+            if not cls.identify(marker):
+                raise ValueError("invalid marker: %r" % marker)
+            subcls.default_marker = marker
+        return subcls
+
+    @classmethod
+    def identify(cls, hash):
+        # NOTE: technically, anything in the /etc/shadow password field
+        #       which isn't valid crypt() output counts as "disabled".
+        #       but that's rather ambiguous, and it's hard to predict what
+        #       valid output is for unknown crypt() implementations.
+        #       so to be on the safe side, we only match things *known*
+        #       to be disabled field indicators, and will add others
+        #       as they are found. things beginning w/ "$" should *never* match.
+        #
+        # things currently matched:
+        #       * linux uses "!"
+        #       * bsd uses "*"
+        #       * linux may use "!" + hash to disable but preserve original hash
+        #       * linux counts empty string as "any password";
+        #         this code recognizes it, but treats it the same as "!"
+        if isinstance(hash, unicode):
+            start = _MARKER_CHARS
+        elif isinstance(hash, bytes):
+            start = _MARKER_BYTES
+        else:
+            raise uh.exc.ExpectedStringError(hash, "hash")
+        return not hash or hash[0] in start
+
+    @classmethod
+    def verify(cls, secret, hash):
+        uh.validate_secret(secret)
+        if not cls.identify(hash): # handles typecheck
+            raise uh.exc.InvalidHashError(cls)
+        return False
+
+    @classmethod
+    def hash(cls, secret, **kwds):
+        if kwds:
+            uh.warn_hash_settings_deprecation(cls, kwds)
+            return cls.using(**kwds).hash(secret)
+        uh.validate_secret(secret)
+        marker = cls.default_marker
+        assert marker and cls.identify(marker)
+        return to_native_str(marker, param="marker")
+
+    @uh.deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genhash(cls, secret, config, marker=None):
+        if not cls.identify(config):
+            raise uh.exc.InvalidHashError(cls)
+        elif config:
+            # preserve the existing str,since it might contain a disabled password hash ("!" + hash)
+            uh.validate_secret(secret)
+            return to_native_str(config, param="config")
+        else:
+            if marker is not None:
+                cls = cls.using(marker=marker)
+            return cls.hash(secret)
+
+    @classmethod
+    def disable(cls, hash=None):
+        out = cls.hash("")
+        if hash is not None:
+            hash = to_native_str(hash, param="hash")
+            if cls.identify(hash):
+                # extract original hash, so that we normalize marker
+                hash = cls.enable(hash)
+            if hash:
+                out += hash
+        return out
+
+    @classmethod
+    def enable(cls, hash):
+        hash = to_native_str(hash, param="hash")
+        for prefix in cls._disable_prefixes:
+            if hash.startswith(prefix):
+                orig = hash[len(prefix):]
+                if orig:
+                    return orig
+                else:
+                    raise ValueError("cannot restore original hash")
+        raise uh.exc.InvalidHashError(cls)
+
+class plaintext(uh.MinimalHandler):
+    """This class stores passwords in plaintext, and follows the :ref:`password-hash-api`.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash`, :meth:`~passlib.ifc.PasswordHash.genhash`, and :meth:`~passlib.ifc.PasswordHash.verify` methods all require the
+    following additional contextual keyword:
+
+    :type encoding: str
+    :param encoding:
+        This controls the character encoding to use (defaults to ``utf-8``).
+
+        This encoding will be used to encode :class:`!unicode` passwords
+        under Python 2, and decode :class:`!bytes` hashes under Python 3.
+
+    .. versionchanged:: 1.6
+        The ``encoding`` keyword was added.
+    """
+    # NOTE: this is subclassed by ldap_plaintext
+
+    name = "plaintext"
+    setting_kwds = ()
+    context_kwds = ("encoding",)
+    default_encoding = "utf-8"
+
+    @classmethod
+    def identify(cls, hash):
+        if isinstance(hash, unicode_or_bytes_types):
+            return True
+        else:
+            raise uh.exc.ExpectedStringError(hash, "hash")
+
+    @classmethod
+    def hash(cls, secret, encoding=None):
+        uh.validate_secret(secret)
+        if not encoding:
+            encoding = cls.default_encoding
+        return to_native_str(secret, encoding, "secret")
+
+    @classmethod
+    def verify(cls, secret, hash, encoding=None):
+        if not encoding:
+            encoding = cls.default_encoding
+        hash = to_native_str(hash, encoding, "hash")
+        if not cls.identify(hash):
+            raise uh.exc.InvalidHashError(cls)
+        return str_consteq(cls.hash(secret, encoding), hash)
+
+    @uh.deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genconfig(cls):
+        return cls.hash("")
+
+    @uh.deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genhash(cls, secret, config, encoding=None):
+        # NOTE: 'config' is ignored, as this hash has no salting / etc
+        if not cls.identify(config):
+            raise uh.exc.InvalidHashError(cls)
+        return cls.hash(secret, encoding=encoding)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/mssql.py b/myenv/lib/python3.9/site-packages/passlib/handlers/mssql.py
new file mode 100644
index 0000000..b060b36
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/mssql.py
@@ -0,0 +1,244 @@
+"""passlib.handlers.mssql - MS-SQL Password Hash
+
+Notes
+=====
+MS-SQL has used a number of hash algs over the years,
+most of which were exposed through the undocumented
+'pwdencrypt' and 'pwdcompare' sql functions.
+
+Known formats
+-------------
+6.5
+    snefru hash, ascii encoded password
+    no examples found
+
+7.0
+    snefru hash, unicode (what encoding?)
+    saw ref that these blobs were 16 bytes in size
+    no examples found
+
+2000
+    byte string using displayed as 0x hex, using 0x0100 prefix.
+    contains hashes of password and upper-case password.
+
+2007
+    same as 2000, but without the upper-case hash.
+
+refs
+----------
+https://blogs.msdn.com/b/lcris/archive/2007/04/30/sql-server-2005-about-login-password-hashes.aspx?Redirected=true
+http://us.generation-nt.com/securing-passwords-hash-help-35429432.html
+http://forum.md5decrypter.co.uk/topic230-mysql-and-mssql-get-password-hashes.aspx
+http://www.theregister.co.uk/2002/07/08/cracking_ms_sql_server_passwords/
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from binascii import hexlify, unhexlify
+from hashlib import sha1
+import re
+import logging; log = logging.getLogger(__name__)
+from warnings import warn
+# site
+# pkg
+from passlib.utils import consteq
+from passlib.utils.compat import bascii_to_str, unicode, u
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "mssql2000",
+    "mssql2005",
+]
+
+#=============================================================================
+# mssql 2000
+#=============================================================================
+def _raw_mssql(secret, salt):
+    assert isinstance(secret, unicode)
+    assert isinstance(salt, bytes)
+    return sha1(secret.encode("utf-16-le") + salt).digest()
+
+BIDENT = b"0x0100"
+##BIDENT2 = b("\x01\x00")
+UIDENT = u("0x0100")
+
+def _ident_mssql(hash, csize, bsize):
+    """common identify for mssql 2000/2005"""
+    if isinstance(hash, unicode):
+        if len(hash) == csize and hash.startswith(UIDENT):
+            return True
+    elif isinstance(hash, bytes):
+        if len(hash) == csize and hash.startswith(BIDENT):
+            return True
+        ##elif len(hash) == bsize and hash.startswith(BIDENT2): # raw bytes
+        ##    return True
+    else:
+        raise uh.exc.ExpectedStringError(hash, "hash")
+    return False
+
+def _parse_mssql(hash, csize, bsize, handler):
+    """common parser for mssql 2000/2005; returns 4 byte salt + checksum"""
+    if isinstance(hash, unicode):
+        if len(hash) == csize and hash.startswith(UIDENT):
+            try:
+                return unhexlify(hash[6:].encode("utf-8"))
+            except TypeError: # throw when bad char found
+                pass
+    elif isinstance(hash, bytes):
+        # assumes ascii-compat encoding
+        assert isinstance(hash, bytes)
+        if len(hash) == csize and hash.startswith(BIDENT):
+            try:
+                return unhexlify(hash[6:])
+            except TypeError: # throw when bad char found
+                pass
+        ##elif len(hash) == bsize and hash.startswith(BIDENT2): # raw bytes
+        ##    return hash[2:]
+    else:
+        raise uh.exc.ExpectedStringError(hash, "hash")
+    raise uh.exc.InvalidHashError(handler)
+
+class mssql2000(uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
+    """This class implements the password hash used by MS-SQL 2000, and follows the :ref:`password-hash-api`.
+
+    It supports a fixed-length salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: bytes
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 4 bytes in length.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+    """
+    #===================================================================
+    # algorithm information
+    #===================================================================
+    name = "mssql2000"
+    setting_kwds = ("salt",)
+    checksum_size = 40
+    min_salt_size = max_salt_size = 4
+
+    #===================================================================
+    # formatting
+    #===================================================================
+
+    # 0100 - 2 byte identifier
+    # 4 byte salt
+    # 20 byte checksum
+    # 20 byte checksum
+    # = 46 bytes
+    # encoded '0x' + 92 chars = 94
+
+    @classmethod
+    def identify(cls, hash):
+        return _ident_mssql(hash, 94, 46)
+
+    @classmethod
+    def from_string(cls, hash):
+        data = _parse_mssql(hash, 94, 46, cls)
+        return cls(salt=data[:4], checksum=data[4:])
+
+    def to_string(self):
+        raw = self.salt + self.checksum
+        # raw bytes format - BIDENT2 + raw
+        return "0x0100" + bascii_to_str(hexlify(raw).upper())
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, bytes):
+            secret = secret.decode("utf-8")
+        salt = self.salt
+        return _raw_mssql(secret, salt) + _raw_mssql(secret.upper(), salt)
+
+    @classmethod
+    def verify(cls, secret, hash):
+        # NOTE: we only compare against the upper-case hash
+        # XXX: add 'full' just to verify both checksums?
+        uh.validate_secret(secret)
+        self = cls.from_string(hash)
+        chk = self.checksum
+        if chk is None:
+            raise uh.exc.MissingDigestError(cls)
+        if isinstance(secret, bytes):
+            secret = secret.decode("utf-8")
+        result = _raw_mssql(secret.upper(), self.salt)
+        return consteq(result, chk[20:])
+
+#=============================================================================
+# handler
+#=============================================================================
+class mssql2005(uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
+    """This class implements the password hash used by MS-SQL 2005, and follows the :ref:`password-hash-api`.
+
+    It supports a fixed-length salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: bytes
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 4 bytes in length.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+    """
+    #===================================================================
+    # algorithm information
+    #===================================================================
+    name = "mssql2005"
+    setting_kwds = ("salt",)
+
+    checksum_size = 20
+    min_salt_size = max_salt_size = 4
+
+    #===================================================================
+    # formatting
+    #===================================================================
+
+    # 0x0100 - 2 byte identifier
+    # 4 byte salt
+    # 20 byte checksum
+    # = 26 bytes
+    # encoded '0x' + 52 chars = 54
+
+    @classmethod
+    def identify(cls, hash):
+        return _ident_mssql(hash, 54, 26)
+
+    @classmethod
+    def from_string(cls, hash):
+        data = _parse_mssql(hash, 54, 26, cls)
+        return cls(salt=data[:4], checksum=data[4:])
+
+    def to_string(self):
+        raw = self.salt + self.checksum
+        # raw bytes format - BIDENT2 + raw
+        return "0x0100" + bascii_to_str(hexlify(raw)).upper()
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, bytes):
+            secret = secret.decode("utf-8")
+        return _raw_mssql(secret, self.salt)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/mysql.py b/myenv/lib/python3.9/site-packages/passlib/handlers/mysql.py
new file mode 100644
index 0000000..4a71253
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/mysql.py
@@ -0,0 +1,128 @@
+"""passlib.handlers.mysql
+
+MySQL 3.2.3 / OLD_PASSWORD()
+
+    This implements Mysql's OLD_PASSWORD algorithm, introduced in version 3.2.3, deprecated in version 4.1.
+
+    See :mod:`passlib.handlers.mysql_41` for the new algorithm was put in place in version 4.1
+
+    This algorithm is known to be very insecure, and should only be used to verify existing password hashes.
+
+    http://djangosnippets.org/snippets/1508/
+
+MySQL 4.1.1 / NEW PASSWORD
+    This implements Mysql new PASSWORD algorithm, introduced in version 4.1.
+
+    This function is unsalted, and therefore not very secure against rainbow attacks.
+    It should only be used when dealing with mysql passwords,
+    for all other purposes, you should use a salted hash function.
+
+    Description taken from http://dev.mysql.com/doc/refman/6.0/en/password-hashing.html
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from hashlib import sha1
+import re
+import logging; log = logging.getLogger(__name__)
+from warnings import warn
+# site
+# pkg
+from passlib.utils import to_native_str
+from passlib.utils.compat import bascii_to_str, unicode, u, \
+                                 byte_elem_value, str_to_uascii
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    'mysql323',
+    'mysq41',
+]
+
+#=============================================================================
+# backend
+#=============================================================================
+class mysql323(uh.StaticHandler):
+    """This class implements the MySQL 3.2.3 password hash, and follows the :ref:`password-hash-api`.
+
+    It has no salt and a single fixed round.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash` and :meth:`~passlib.ifc.PasswordHash.genconfig` methods accept no optional keywords.
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+    name = "mysql323"
+    checksum_size = 16
+    checksum_chars = uh.HEX_CHARS
+
+    #===================================================================
+    # methods
+    #===================================================================
+    @classmethod
+    def _norm_hash(cls, hash):
+        return hash.lower()
+
+    def _calc_checksum(self, secret):
+        # FIXME: no idea if mysql has a policy about handling unicode passwords
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+
+        MASK_32 = 0xffffffff
+        MASK_31 = 0x7fffffff
+        WHITE = b' \t'
+
+        nr1 = 0x50305735
+        nr2 = 0x12345671
+        add = 7
+        for c in secret:
+            if c in WHITE:
+                continue
+            tmp = byte_elem_value(c)
+            nr1 ^= ((((nr1 & 63)+add)*tmp) + (nr1 << 8)) & MASK_32
+            nr2 = (nr2+((nr2 << 8) ^ nr1)) & MASK_32
+            add = (add+tmp) & MASK_32
+        return u("%08x%08x") % (nr1 & MASK_31, nr2 & MASK_31)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# handler
+#=============================================================================
+class mysql41(uh.StaticHandler):
+    """This class implements the MySQL 4.1 password hash, and follows the :ref:`password-hash-api`.
+
+    It has no salt and a single fixed round.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash` and :meth:`~passlib.ifc.PasswordHash.genconfig` methods accept no optional keywords.
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+    name = "mysql41"
+    _hash_prefix = u("*")
+    checksum_chars = uh.HEX_CHARS
+    checksum_size = 40
+
+    #===================================================================
+    # methods
+    #===================================================================
+    @classmethod
+    def _norm_hash(cls, hash):
+        return hash.upper()
+
+    def _calc_checksum(self, secret):
+        # FIXME: no idea if mysql has a policy about handling unicode passwords
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        return str_to_uascii(sha1(sha1(secret).digest()).hexdigest()).upper()
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/oracle.py b/myenv/lib/python3.9/site-packages/passlib/handlers/oracle.py
new file mode 100644
index 0000000..a094f37
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/oracle.py
@@ -0,0 +1,172 @@
+"""passlib.handlers.oracle - Oracle DB Password Hashes"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from binascii import hexlify, unhexlify
+from hashlib import sha1
+import re
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils import to_unicode, xor_bytes
+from passlib.utils.compat import irange, u, \
+                                 uascii_to_str, unicode, str_to_uascii
+from passlib.crypto.des import des_encrypt_block
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "oracle10g",
+    "oracle11g"
+]
+
+#=============================================================================
+# oracle10
+#=============================================================================
+def des_cbc_encrypt(key, value, iv=b'\x00' * 8, pad=b'\x00'):
+    """performs des-cbc encryption, returns only last block.
+
+    this performs a specific DES-CBC encryption implementation
+    as needed by the Oracle10 hash. it probably won't be useful for
+    other purposes as-is.
+
+    input value is null-padded to multiple of 8 bytes.
+
+    :arg key: des key as bytes
+    :arg value: value to encrypt, as bytes.
+    :param iv: optional IV
+    :param pad: optional pad byte
+
+    :returns: last block of DES-CBC encryption of all ``value``'s byte blocks.
+    """
+    value += pad * (-len(value) % 8) # null pad to multiple of 8
+    hash = iv # start things off
+    for offset in irange(0,len(value),8):
+        chunk = xor_bytes(hash, value[offset:offset+8])
+        hash = des_encrypt_block(key, chunk)
+    return hash
+
+# magic string used as initial des key by oracle10
+ORACLE10_MAGIC = b"\x01\x23\x45\x67\x89\xAB\xCD\xEF"
+
+class oracle10(uh.HasUserContext, uh.StaticHandler):
+    """This class implements the password hash used by Oracle up to version 10g, and follows the :ref:`password-hash-api`.
+
+    It does a single round of hashing, and relies on the username as the salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash`, :meth:`~passlib.ifc.PasswordHash.genhash`, and :meth:`~passlib.ifc.PasswordHash.verify` methods all require the
+    following additional contextual keywords:
+
+    :type user: str
+    :param user: name of oracle user account this password is associated with.
+    """
+    #===================================================================
+    # algorithm information
+    #===================================================================
+    name = "oracle10"
+    checksum_chars = uh.HEX_CHARS
+    checksum_size = 16
+
+    #===================================================================
+    # methods
+    #===================================================================
+    @classmethod
+    def _norm_hash(cls, hash):
+        return hash.upper()
+
+    def _calc_checksum(self, secret):
+        # FIXME: not sure how oracle handles unicode.
+        #        online docs about 10g hash indicate it puts ascii chars
+        #        in a 2-byte encoding w/ the high byte set to null.
+        #        they don't say how it handles other chars, or what encoding.
+        #
+        #        so for now, encoding secret & user to utf-16-be,
+        #        since that fits, and if secret/user is bytes,
+        #        we assume utf-8, and decode first.
+        #
+        #        this whole mess really needs someone w/ an oracle system,
+        #        and some answers :)
+        if isinstance(secret, bytes):
+            secret = secret.decode("utf-8")
+        user = to_unicode(self.user, "utf-8", param="user")
+        input = (user+secret).upper().encode("utf-16-be")
+        hash = des_cbc_encrypt(ORACLE10_MAGIC, input)
+        hash = des_cbc_encrypt(hash, input)
+        return hexlify(hash).decode("ascii").upper()
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# oracle11
+#=============================================================================
+class oracle11(uh.HasSalt, uh.GenericHandler):
+    """This class implements the Oracle11g password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a fixed-length salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 20 hexadecimal characters.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+    #--GenericHandler--
+    name = "oracle11"
+    setting_kwds = ("salt",)
+    checksum_size = 40
+    checksum_chars = uh.UPPER_HEX_CHARS
+
+    #--HasSalt--
+    min_salt_size = max_salt_size = 20
+    salt_chars = uh.UPPER_HEX_CHARS
+
+
+    #===================================================================
+    # methods
+    #===================================================================
+    _hash_regex = re.compile(u("^S:(?P<chk>[0-9a-f]{40})(?P<salt>[0-9a-f]{20})$"), re.I)
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+        m = cls._hash_regex.match(hash)
+        if not m:
+            raise uh.exc.InvalidHashError(cls)
+        salt, chk = m.group("salt", "chk")
+        return cls(salt=salt, checksum=chk.upper())
+
+    def to_string(self):
+        chk = self.checksum
+        hash = u("S:%s%s") % (chk.upper(), self.salt.upper())
+        return uascii_to_str(hash)
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        chk = sha1(secret + unhexlify(self.salt.encode("ascii"))).hexdigest()
+        return str_to_uascii(chk).upper()
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/pbkdf2.py b/myenv/lib/python3.9/site-packages/passlib/handlers/pbkdf2.py
new file mode 100644
index 0000000..274278d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/pbkdf2.py
@@ -0,0 +1,475 @@
+"""passlib.handlers.pbkdf - PBKDF2 based hashes"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from binascii import hexlify, unhexlify
+from base64 import b64encode, b64decode
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils import to_unicode
+from passlib.utils.binary import ab64_decode, ab64_encode
+from passlib.utils.compat import str_to_bascii, u, uascii_to_str, unicode
+from passlib.crypto.digest import pbkdf2_hmac
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "pbkdf2_sha1",
+    "pbkdf2_sha256",
+    "pbkdf2_sha512",
+    "cta_pbkdf2_sha1",
+    "dlitz_pbkdf2_sha1",
+    "grub_pbkdf2_sha512",
+]
+
+#=============================================================================
+#
+#=============================================================================
+class Pbkdf2DigestHandler(uh.HasRounds, uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
+    """base class for various pbkdf2_{digest} algorithms"""
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #--GenericHandler--
+    setting_kwds = ("salt", "salt_size", "rounds")
+    checksum_chars = uh.HASH64_CHARS
+
+    #--HasSalt--
+    default_salt_size = 16
+    max_salt_size = 1024
+
+    #--HasRounds--
+    default_rounds = None # set by subclass
+    min_rounds = 1
+    max_rounds = 0xffffffff # setting at 32-bit limit for now
+    rounds_cost = "linear"
+
+    #--this class--
+    _digest = None # name of subclass-specified hash
+
+    # NOTE: max_salt_size and max_rounds are arbitrarily chosen to provide sanity check.
+    #       the underlying pbkdf2 specifies no bounds for either.
+
+    # NOTE: defaults chosen to be at least as large as pbkdf2 rfc recommends...
+    #       >8 bytes of entropy in salt, >1000 rounds
+    #       increased due to time since rfc established
+
+    #===================================================================
+    # methods
+    #===================================================================
+
+    @classmethod
+    def from_string(cls, hash):
+        rounds, salt, chk = uh.parse_mc3(hash, cls.ident, handler=cls)
+        salt = ab64_decode(salt.encode("ascii"))
+        if chk:
+            chk = ab64_decode(chk.encode("ascii"))
+        return cls(rounds=rounds, salt=salt, checksum=chk)
+
+    def to_string(self):
+        salt = ab64_encode(self.salt).decode("ascii")
+        chk = ab64_encode(self.checksum).decode("ascii")
+        return uh.render_mc3(self.ident, self.rounds, salt, chk)
+
+    def _calc_checksum(self, secret):
+        # NOTE: pbkdf2_hmac() will encode secret & salt using UTF8
+        return pbkdf2_hmac(self._digest, secret, self.salt, self.rounds, self.checksum_size)
+
+def create_pbkdf2_hash(hash_name, digest_size, rounds=12000, ident=None, module=__name__):
+    """create new Pbkdf2DigestHandler subclass for a specific hash"""
+    name = 'pbkdf2_' + hash_name
+    if ident is None:
+        ident = u("$pbkdf2-%s$") % (hash_name,)
+    base = Pbkdf2DigestHandler
+    return type(name, (base,), dict(
+        __module__=module, # so ABCMeta won't clobber it.
+        name=name,
+        ident=ident,
+        _digest = hash_name,
+        default_rounds=rounds,
+        checksum_size=digest_size,
+        encoded_checksum_size=(digest_size*4+2)//3,
+        __doc__="""This class implements a generic ``PBKDF2-HMAC-%(digest)s``-based password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: bytes
+    :param salt:
+        Optional salt bytes.
+        If specified, the length must be between 0-1024 bytes.
+        If not specified, a %(dsc)d byte salt will be autogenerated (this is recommended).
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to %(dsc)d bytes, but can be any value between 0 and 1024.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to %(dr)d, but must be within ``range(1,1<<32)``.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """ % dict(digest=hash_name.upper(), dsc=base.default_salt_size, dr=rounds)
+    ))
+
+#------------------------------------------------------------------------
+# derived handlers
+#------------------------------------------------------------------------
+pbkdf2_sha1 = create_pbkdf2_hash("sha1", 20, 131000, ident=u("$pbkdf2$"))
+pbkdf2_sha256 = create_pbkdf2_hash("sha256", 32, 29000)
+pbkdf2_sha512 = create_pbkdf2_hash("sha512", 64, 25000)
+
+ldap_pbkdf2_sha1 = uh.PrefixWrapper("ldap_pbkdf2_sha1", pbkdf2_sha1, "{PBKDF2}", "$pbkdf2$", ident=True)
+ldap_pbkdf2_sha256 = uh.PrefixWrapper("ldap_pbkdf2_sha256", pbkdf2_sha256, "{PBKDF2-SHA256}", "$pbkdf2-sha256$", ident=True)
+ldap_pbkdf2_sha512 = uh.PrefixWrapper("ldap_pbkdf2_sha512", pbkdf2_sha512, "{PBKDF2-SHA512}", "$pbkdf2-sha512$", ident=True)
+
+#=============================================================================
+# cryptacular's pbkdf2 hash
+#=============================================================================
+
+# bytes used by cta hash for base64 values 63 & 64
+CTA_ALTCHARS = b"-_"
+
+class cta_pbkdf2_sha1(uh.HasRounds, uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
+    """This class implements Cryptacular's PBKDF2-based crypt algorithm, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: bytes
+    :param salt:
+        Optional salt bytes.
+        If specified, it may be any length.
+        If not specified, a one will be autogenerated (this is recommended).
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to 16 bytes, but can be any value between 0 and 1024.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 60000, must be within ``range(1,1<<32)``.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+
+    #===================================================================
+    # class attrs
+    #===================================================================
+    #--GenericHandler--
+    name = "cta_pbkdf2_sha1"
+    setting_kwds = ("salt", "salt_size", "rounds")
+    ident = u("$p5k2$")
+    checksum_size = 20
+
+    # NOTE: max_salt_size and max_rounds are arbitrarily chosen to provide a
+    #       sanity check. underlying algorithm (and reference implementation)
+    #       allows effectively unbounded values for both of these parameters.
+
+    #--HasSalt--
+    default_salt_size = 16
+    max_salt_size = 1024
+
+    #--HasRounds--
+    default_rounds = pbkdf2_sha1.default_rounds
+    min_rounds = 1
+    max_rounds = 0xffffffff # setting at 32-bit limit for now
+    rounds_cost = "linear"
+
+    #===================================================================
+    # formatting
+    #===================================================================
+
+    # hash       $p5k2$1000$ZxK4ZBJCfQg=$jJZVscWtO--p1-xIZl6jhO2LKR0=
+    # ident      $p5k2$
+    # rounds     1000
+    # salt       ZxK4ZBJCfQg=
+    # chk        jJZVscWtO--p1-xIZl6jhO2LKR0=
+    # NOTE: rounds in hex
+
+    @classmethod
+    def from_string(cls, hash):
+        # NOTE: passlib deviation - forbidding zero-padded rounds
+        rounds, salt, chk = uh.parse_mc3(hash, cls.ident, rounds_base=16, handler=cls)
+        salt = b64decode(salt.encode("ascii"), CTA_ALTCHARS)
+        if chk:
+            chk = b64decode(chk.encode("ascii"), CTA_ALTCHARS)
+        return cls(rounds=rounds, salt=salt, checksum=chk)
+
+    def to_string(self):
+        salt = b64encode(self.salt, CTA_ALTCHARS).decode("ascii")
+        chk = b64encode(self.checksum, CTA_ALTCHARS).decode("ascii")
+        return uh.render_mc3(self.ident, self.rounds, salt, chk, rounds_base=16)
+
+    #===================================================================
+    # backend
+    #===================================================================
+    def _calc_checksum(self, secret):
+        # NOTE: pbkdf2_hmac() will encode secret & salt using utf-8
+        return pbkdf2_hmac("sha1", secret, self.salt, self.rounds, 20)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# dlitz's pbkdf2 hash
+#=============================================================================
+class dlitz_pbkdf2_sha1(uh.HasRounds, uh.HasSalt, uh.GenericHandler):
+    """This class implements Dwayne Litzenberger's PBKDF2-based crypt algorithm, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If specified, it may be any length, but must use the characters in the regexp range ``[./0-9A-Za-z]``.
+        If not specified, a 16 character salt will be autogenerated (this is recommended).
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to 16 bytes, but can be any value between 0 and 1024.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 60000, must be within ``range(1,1<<32)``.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+
+    #===================================================================
+    # class attrs
+    #===================================================================
+    #--GenericHandler--
+    name = "dlitz_pbkdf2_sha1"
+    setting_kwds = ("salt", "salt_size", "rounds")
+    ident = u("$p5k2$")
+    _stub_checksum = u("0" * 48 + "=")
+
+    # NOTE: max_salt_size and max_rounds are arbitrarily chosen to provide a
+    #       sanity check. underlying algorithm (and reference implementation)
+    #       allows effectively unbounded values for both of these parameters.
+
+    #--HasSalt--
+    default_salt_size = 16
+    max_salt_size = 1024
+    salt_chars = uh.HASH64_CHARS
+
+    #--HasRounds--
+    # NOTE: for security, the default here is set to match pbkdf2_sha1,
+    #       even though this hash's extra block makes it twice as slow.
+    default_rounds = pbkdf2_sha1.default_rounds
+    min_rounds = 1
+    max_rounds = 0xffffffff # setting at 32-bit limit for now
+    rounds_cost = "linear"
+
+    #===================================================================
+    # formatting
+    #===================================================================
+
+    # hash       $p5k2$c$u9HvcT4d$Sd1gwSVCLZYAuqZ25piRnbBEoAesaa/g
+    # ident      $p5k2$
+    # rounds     c
+    # salt       u9HvcT4d
+    # chk        Sd1gwSVCLZYAuqZ25piRnbBEoAesaa/g
+    # rounds in lowercase hex, no zero padding
+
+    @classmethod
+    def from_string(cls, hash):
+        rounds, salt, chk = uh.parse_mc3(hash, cls.ident, rounds_base=16,
+                                         default_rounds=400, handler=cls)
+        return cls(rounds=rounds, salt=salt, checksum=chk)
+
+    def to_string(self):
+        rounds = self.rounds
+        if rounds == 400:
+            rounds = None # omit rounds measurement if == 400
+        return uh.render_mc3(self.ident, rounds, self.salt, self.checksum, rounds_base=16)
+
+    def _get_config(self):
+        rounds = self.rounds
+        if rounds == 400:
+            rounds = None # omit rounds measurement if == 400
+        return uh.render_mc3(self.ident, rounds, self.salt, None, rounds_base=16)
+
+    #===================================================================
+    # backend
+    #===================================================================
+    def _calc_checksum(self, secret):
+        # NOTE: pbkdf2_hmac() will encode secret & salt using utf-8
+        salt = self._get_config()
+        result = pbkdf2_hmac("sha1", secret, salt, self.rounds, 24)
+        return ab64_encode(result).decode("ascii")
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# crowd
+#=============================================================================
+class atlassian_pbkdf2_sha1(uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
+    """This class implements the PBKDF2 hash used by Atlassian.
+
+    It supports a fixed-length salt, and a fixed number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: bytes
+    :param salt:
+        Optional salt bytes.
+        If specified, the length must be exactly 16 bytes.
+        If not specified, a salt will be autogenerated (this is recommended).
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include
+        ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+    #--GenericHandler--
+    name = "atlassian_pbkdf2_sha1"
+    setting_kwds =("salt",)
+    ident = u("{PKCS5S2}")
+    checksum_size = 32
+
+    #--HasRawSalt--
+    min_salt_size = max_salt_size = 16
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+        ident = cls.ident
+        if not hash.startswith(ident):
+            raise uh.exc.InvalidHashError(cls)
+        data = b64decode(hash[len(ident):].encode("ascii"))
+        salt, chk = data[:16], data[16:]
+        return cls(salt=salt, checksum=chk)
+
+    def to_string(self):
+        data = self.salt + self.checksum
+        hash = self.ident + b64encode(data).decode("ascii")
+        return uascii_to_str(hash)
+
+    def _calc_checksum(self, secret):
+        # TODO: find out what crowd's policy is re: unicode
+        # crowd seems to use a fixed number of rounds.
+        # NOTE: pbkdf2_hmac() will encode secret & salt using utf-8
+        return pbkdf2_hmac("sha1", secret, self.salt, 10000, 32)
+
+#=============================================================================
+# grub
+#=============================================================================
+class grub_pbkdf2_sha512(uh.HasRounds, uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
+    """This class implements Grub's pbkdf2-hmac-sha512 hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: bytes
+    :param salt:
+        Optional salt bytes.
+        If specified, the length must be between 0-1024 bytes.
+        If not specified, a 64 byte salt will be autogenerated (this is recommended).
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to 64 bytes, but can be any value between 0 and 1024.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 19000, but must be within ``range(1,1<<32)``.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+    name = "grub_pbkdf2_sha512"
+    setting_kwds = ("salt", "salt_size", "rounds")
+
+    ident = u("grub.pbkdf2.sha512.")
+    checksum_size = 64
+
+    # NOTE: max_salt_size and max_rounds are arbitrarily chosen to provide a
+    #       sanity check. the underlying pbkdf2 specifies no bounds for either,
+    #       and it's not clear what grub specifies.
+
+    default_salt_size = 64
+    max_salt_size = 1024
+
+    default_rounds = pbkdf2_sha512.default_rounds
+    min_rounds = 1
+    max_rounds = 0xffffffff # setting at 32-bit limit for now
+    rounds_cost = "linear"
+
+    @classmethod
+    def from_string(cls, hash):
+        rounds, salt, chk = uh.parse_mc3(hash, cls.ident, sep=u("."),
+                                         handler=cls)
+        salt = unhexlify(salt.encode("ascii"))
+        if chk:
+            chk = unhexlify(chk.encode("ascii"))
+        return cls(rounds=rounds, salt=salt, checksum=chk)
+
+    def to_string(self):
+        salt = hexlify(self.salt).decode("ascii").upper()
+        chk = hexlify(self.checksum).decode("ascii").upper()
+        return uh.render_mc3(self.ident, self.rounds, salt, chk, sep=u("."))
+
+    def _calc_checksum(self, secret):
+        # TODO: find out what grub's policy is re: unicode
+        # NOTE: pbkdf2_hmac() will encode secret & salt using utf-8
+        return pbkdf2_hmac("sha512", secret, self.salt, self.rounds, 64)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/phpass.py b/myenv/lib/python3.9/site-packages/passlib/handlers/phpass.py
new file mode 100644
index 0000000..6736f0f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/phpass.py
@@ -0,0 +1,135 @@
+"""passlib.handlers.phpass - PHPass Portable Crypt
+
+phppass located - http://www.openwall.com/phpass/
+algorithm described - http://www.openwall.com/articles/PHP-Users-Passwords
+
+phpass context - blowfish, bsdi_crypt, phpass
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from hashlib import md5
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils.binary import h64
+from passlib.utils.compat import u, uascii_to_str, unicode
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "phpass",
+]
+
+#=============================================================================
+# phpass
+#=============================================================================
+class phpass(uh.HasManyIdents, uh.HasRounds, uh.HasSalt, uh.GenericHandler):
+    """This class implements the PHPass Portable Hash, and follows the :ref:`password-hash-api`.
+
+    It supports a fixed-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 8 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 19, must be between 7 and 30, inclusive.
+        This value is logarithmic, the actual number of iterations used will be :samp:`2**{rounds}`.
+
+    :type ident: str
+    :param ident:
+        phpBB3 uses ``H`` instead of ``P`` for its identifier,
+        this may be set to ``H`` in order to generate phpBB3 compatible hashes.
+        it defaults to ``P``.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+
+    #===================================================================
+    # class attrs
+    #===================================================================
+    #--GenericHandler--
+    name = "phpass"
+    setting_kwds = ("salt", "rounds", "ident")
+    checksum_chars = uh.HASH64_CHARS
+
+    #--HasSalt--
+    min_salt_size = max_salt_size = 8
+    salt_chars = uh.HASH64_CHARS
+
+    #--HasRounds--
+    default_rounds = 19
+    min_rounds = 7
+    max_rounds = 30
+    rounds_cost = "log2"
+
+    #--HasManyIdents--
+    default_ident = u("$P$")
+    ident_values = (u("$P$"), u("$H$"))
+    ident_aliases = {u("P"):u("$P$"), u("H"):u("$H$")}
+
+    #===================================================================
+    # formatting
+    #===================================================================
+
+    #$P$9IQRaTwmfeRo7ud9Fh4E2PdI0S3r.L0
+    # $P$
+    # 9
+    # IQRaTwmf
+    # eRo7ud9Fh4E2PdI0S3r.L0
+
+    @classmethod
+    def from_string(cls, hash):
+        ident, data = cls._parse_ident(hash)
+        rounds, salt, chk = data[0], data[1:9], data[9:]
+        return cls(
+            ident=ident,
+            rounds=h64.decode_int6(rounds.encode("ascii")),
+            salt=salt,
+            checksum=chk or None,
+        )
+
+    def to_string(self):
+        hash = u("%s%s%s%s") % (self.ident,
+                              h64.encode_int6(self.rounds).decode("ascii"),
+                              self.salt,
+                              self.checksum or u(''))
+        return uascii_to_str(hash)
+
+    #===================================================================
+    # backend
+    #===================================================================
+    def _calc_checksum(self, secret):
+        # FIXME: can't find definitive policy on how phpass handles non-ascii.
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        real_rounds = 1<<self.rounds
+        result = md5(self.salt.encode("ascii") + secret).digest()
+        r = 0
+        while r < real_rounds:
+            result = md5(result + secret).digest()
+            r += 1
+        return h64.encode_bytes(result).decode("ascii")
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/postgres.py b/myenv/lib/python3.9/site-packages/passlib/handlers/postgres.py
new file mode 100644
index 0000000..17156fa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/postgres.py
@@ -0,0 +1,55 @@
+"""passlib.handlers.postgres_md5 - MD5-based algorithm used by Postgres for pg_shadow table"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from hashlib import md5
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils import to_bytes
+from passlib.utils.compat import str_to_uascii, unicode, u
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "postgres_md5",
+]
+
+#=============================================================================
+# handler
+#=============================================================================
+class postgres_md5(uh.HasUserContext, uh.StaticHandler):
+    """This class implements the Postgres MD5 Password hash, and follows the :ref:`password-hash-api`.
+
+    It does a single round of hashing, and relies on the username as the salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash`, :meth:`~passlib.ifc.PasswordHash.genhash`, and :meth:`~passlib.ifc.PasswordHash.verify` methods all require the
+    following additional contextual keywords:
+
+    :type user: str
+    :param user: name of postgres user account this password is associated with.
+    """
+    #===================================================================
+    # algorithm information
+    #===================================================================
+    name = "postgres_md5"
+    _hash_prefix = u("md5")
+    checksum_chars = uh.HEX_CHARS
+    checksum_size = 32
+
+    #===================================================================
+    # primary interface
+    #===================================================================
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        user = to_bytes(self.user, "utf-8", param="user")
+        return str_to_uascii(md5(secret + user).hexdigest())
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/roundup.py b/myenv/lib/python3.9/site-packages/passlib/handlers/roundup.py
new file mode 100644
index 0000000..c7f99c1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/roundup.py
@@ -0,0 +1,29 @@
+"""passlib.handlers.roundup - Roundup issue tracker hashes"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+import passlib.utils.handlers as uh
+from passlib.utils.compat import u
+# local
+__all__ = [
+    "roundup_plaintext",
+    "ldap_hex_md5",
+    "ldap_hex_sha1",
+]
+#=============================================================================
+#
+#=============================================================================
+roundup_plaintext = uh.PrefixWrapper("roundup_plaintext", "plaintext",
+                                     prefix=u("{plaintext}"), lazy=True)
+
+# NOTE: these are here because they're currently only known to be used by roundup
+ldap_hex_md5 = uh.PrefixWrapper("ldap_hex_md5", "hex_md5", u("{MD5}"), lazy=True)
+ldap_hex_sha1 = uh.PrefixWrapper("ldap_hex_sha1", "hex_sha1", u("{SHA}"), lazy=True)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/scram.py b/myenv/lib/python3.9/site-packages/passlib/handlers/scram.py
new file mode 100644
index 0000000..87bfabd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/scram.py
@@ -0,0 +1,582 @@
+"""passlib.handlers.scram - hash for SCRAM credential storage"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils import consteq, saslprep, to_native_str, splitcomma
+from passlib.utils.binary import ab64_decode, ab64_encode
+from passlib.utils.compat import bascii_to_str, iteritems, u, native_string_types
+from passlib.crypto.digest import pbkdf2_hmac, norm_hash_name
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "scram",
+]
+
+#=============================================================================
+# scram credentials hash
+#=============================================================================
+class scram(uh.HasRounds, uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
+    """This class provides a format for storing SCRAM passwords, and follows
+    the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: bytes
+    :param salt:
+        Optional salt bytes.
+        If specified, the length must be between 0-1024 bytes.
+        If not specified, a 12 byte salt will be autogenerated
+        (this is recommended).
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to 12 bytes, but can be any value between 0 and 1024.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 100000, but must be within ``range(1,1<<32)``.
+
+    :type algs: list of strings
+    :param algs:
+        Specify list of digest algorithms to use.
+
+        By default each scram hash will contain digests for SHA-1,
+        SHA-256, and SHA-512. This can be overridden by specify either be a
+        list such as ``["sha-1", "sha-256"]``, or a comma-separated string
+        such as ``"sha-1, sha-256"``. Names are case insensitive, and may
+        use :mod:`!hashlib` or `IANA <http://www.iana.org/assignments/hash-function-text-names>`_
+        hash names.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+
+    In addition to the standard :ref:`password-hash-api` methods,
+    this class also provides the following methods for manipulating Passlib
+    scram hashes in ways useful for pluging into a SCRAM protocol stack:
+
+    .. automethod:: extract_digest_info
+    .. automethod:: extract_digest_algs
+    .. automethod:: derive_digest
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    # NOTE: unlike most GenericHandler classes, the 'checksum' attr of
+    # ScramHandler is actually a map from digest_name -> digest, so
+    # many of the standard methods have been overridden.
+
+    # NOTE: max_salt_size and max_rounds are arbitrarily chosen to provide
+    # a sanity check; the underlying pbkdf2 specifies no bounds for either.
+
+    #--GenericHandler--
+    name = "scram"
+    setting_kwds = ("salt", "salt_size", "rounds", "algs")
+    ident = u("$scram$")
+
+    #--HasSalt--
+    default_salt_size = 12
+    max_salt_size = 1024
+
+    #--HasRounds--
+    default_rounds = 100000
+    min_rounds = 1
+    max_rounds = 2**32-1
+    rounds_cost = "linear"
+
+    #--custom--
+
+    # default algorithms when creating new hashes.
+    default_algs = ["sha-1", "sha-256", "sha-512"]
+
+    # list of algs verify prefers to use, in order.
+    _verify_algs = ["sha-256", "sha-512", "sha-224", "sha-384", "sha-1"]
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+
+    # 'checksum' is different from most GenericHandler subclasses,
+    # in that it contains a dict mapping from alg -> digest,
+    # or None if no checksum present.
+
+    # list of algorithms to create/compare digests for.
+    algs = None
+
+    #===================================================================
+    # scram frontend helpers
+    #===================================================================
+    @classmethod
+    def extract_digest_info(cls, hash, alg):
+        """return (salt, rounds, digest) for specific hash algorithm.
+
+        :type hash: str
+        :arg hash:
+            :class:`!scram` hash stored for desired user
+
+        :type alg: str
+        :arg alg:
+            Name of digest algorithm (e.g. ``"sha-1"``) requested by client.
+
+            This value is run through :func:`~passlib.crypto.digest.norm_hash_name`,
+            so it is case-insensitive, and can be the raw SCRAM
+            mechanism name (e.g. ``"SCRAM-SHA-1"``), the IANA name,
+            or the hashlib name.
+
+        :raises KeyError:
+            If the hash does not contain an entry for the requested digest
+            algorithm.
+
+        :returns:
+            A tuple containing ``(salt, rounds, digest)``,
+            where *digest* matches the raw bytes returned by
+            SCRAM's :func:`Hi` function for the stored password,
+            the provided *salt*, and the iteration count (*rounds*).
+            *salt* and *digest* are both raw (unencoded) bytes.
+        """
+        # XXX: this could be sped up by writing custom parsing routine
+        # that just picks out relevant digest, and doesn't bother
+        # with full structure validation each time it's called.
+        alg = norm_hash_name(alg, 'iana')
+        self = cls.from_string(hash)
+        chkmap = self.checksum
+        if not chkmap:
+            raise ValueError("scram hash contains no digests")
+        return self.salt, self.rounds, chkmap[alg]
+
+    @classmethod
+    def extract_digest_algs(cls, hash, format="iana"):
+        """Return names of all algorithms stored in a given hash.
+
+        :type hash: str
+        :arg hash:
+            The :class:`!scram` hash to parse
+
+        :type format: str
+        :param format:
+            This changes the naming convention used by the
+            returned algorithm names. By default the names
+            are IANA-compatible; possible values are ``"iana"`` or ``"hashlib"``.
+
+        :returns:
+            Returns a list of digest algorithms; e.g. ``["sha-1"]``
+        """
+        # XXX: this could be sped up by writing custom parsing routine
+        # that just picks out relevant names, and doesn't bother
+        # with full structure validation each time it's called.
+        algs = cls.from_string(hash).algs
+        if format == "iana":
+            return algs
+        else:
+            return [norm_hash_name(alg, format) for alg in algs]
+
+    @classmethod
+    def derive_digest(cls, password, salt, rounds, alg):
+        """helper to create SaltedPassword digest for SCRAM.
+
+        This performs the step in the SCRAM protocol described as::
+
+            SaltedPassword  := Hi(Normalize(password), salt, i)
+
+        :type password: unicode or utf-8 bytes
+        :arg password: password to run through digest
+
+        :type salt: bytes
+        :arg salt: raw salt data
+
+        :type rounds: int
+        :arg rounds: number of iterations.
+
+        :type alg: str
+        :arg alg: name of digest to use (e.g. ``"sha-1"``).
+
+        :returns:
+            raw bytes of ``SaltedPassword``
+        """
+        if isinstance(password, bytes):
+            password = password.decode("utf-8")
+        # NOTE: pbkdf2_hmac() will encode secret & salt using utf-8,
+        #       and handle normalizing alg name.
+        return pbkdf2_hmac(alg, saslprep(password), salt, rounds)
+
+    #===================================================================
+    # serialization
+    #===================================================================
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_native_str(hash, "ascii", "hash")
+        if not hash.startswith("$scram$"):
+            raise uh.exc.InvalidHashError(cls)
+        parts = hash[7:].split("$")
+        if len(parts) != 3:
+            raise uh.exc.MalformedHashError(cls)
+        rounds_str, salt_str, chk_str = parts
+
+        # decode rounds
+        rounds = int(rounds_str)
+        if rounds_str != str(rounds): # forbid zero padding, etc.
+            raise uh.exc.MalformedHashError(cls)
+
+        # decode salt
+        try:
+            salt = ab64_decode(salt_str.encode("ascii"))
+        except TypeError:
+            raise uh.exc.MalformedHashError(cls)
+
+        # decode algs/digest list
+        if not chk_str:
+            # scram hashes MUST have something here.
+            raise uh.exc.MalformedHashError(cls)
+        elif "=" in chk_str:
+            # comma-separated list of 'alg=digest' pairs
+            algs = None
+            chkmap = {}
+            for pair in chk_str.split(","):
+                alg, digest = pair.split("=")
+                try:
+                    chkmap[alg] = ab64_decode(digest.encode("ascii"))
+                except TypeError:
+                    raise uh.exc.MalformedHashError(cls)
+        else:
+            # comma-separated list of alg names, no digests
+            algs = chk_str
+            chkmap = None
+
+        # return new object
+        return cls(
+            rounds=rounds,
+            salt=salt,
+            checksum=chkmap,
+            algs=algs,
+        )
+
+    def to_string(self):
+        salt = bascii_to_str(ab64_encode(self.salt))
+        chkmap = self.checksum
+        chk_str = ",".join(
+            "%s=%s" % (alg, bascii_to_str(ab64_encode(chkmap[alg])))
+            for alg in self.algs
+        )
+        return '$scram$%d$%s$%s' % (self.rounds, salt, chk_str)
+
+    #===================================================================
+    # variant constructor
+    #===================================================================
+    @classmethod
+    def using(cls, default_algs=None, algs=None, **kwds):
+        # parse aliases
+        if algs is not None:
+            assert default_algs is None
+            default_algs = algs
+
+        # create subclass
+        subcls = super(scram, cls).using(**kwds)
+
+        # fill in algs
+        if default_algs is not None:
+            subcls.default_algs = cls._norm_algs(default_algs)
+        return subcls
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, algs=None, **kwds):
+        super(scram, self).__init__(**kwds)
+
+        # init algs
+        digest_map = self.checksum
+        if algs is not None:
+            if digest_map is not None:
+                raise RuntimeError("checksum & algs kwds are mutually exclusive")
+            algs = self._norm_algs(algs)
+        elif digest_map is not None:
+            # derive algs list from digest map (if present).
+            algs = self._norm_algs(digest_map.keys())
+        elif self.use_defaults:
+            algs = list(self.default_algs)
+            assert self._norm_algs(algs) == algs, "invalid default algs: %r" % (algs,)
+        else:
+            raise TypeError("no algs list specified")
+        self.algs = algs
+
+    def _norm_checksum(self, checksum, relaxed=False):
+        if not isinstance(checksum, dict):
+            raise uh.exc.ExpectedTypeError(checksum, "dict", "checksum")
+        for alg, digest in iteritems(checksum):
+            if alg != norm_hash_name(alg, 'iana'):
+                raise ValueError("malformed algorithm name in scram hash: %r" %
+                                 (alg,))
+            if len(alg) > 9:
+                raise ValueError("SCRAM limits algorithm names to "
+                                 "9 characters: %r" % (alg,))
+            if not isinstance(digest, bytes):
+                raise uh.exc.ExpectedTypeError(digest, "raw bytes", "digests")
+            # TODO: verify digest size (if digest is known)
+        if 'sha-1' not in checksum:
+            # NOTE: required because of SCRAM spec.
+            raise ValueError("sha-1 must be in algorithm list of scram hash")
+        return checksum
+
+    @classmethod
+    def _norm_algs(cls, algs):
+        """normalize algs parameter"""
+        if isinstance(algs, native_string_types):
+            algs = splitcomma(algs)
+        algs = sorted(norm_hash_name(alg, 'iana') for alg in algs)
+        if any(len(alg)>9 for alg in algs):
+            raise ValueError("SCRAM limits alg names to max of 9 characters")
+        if 'sha-1' not in algs:
+            # NOTE: required because of SCRAM spec (rfc 5802)
+            raise ValueError("sha-1 must be in algorithm list of scram hash")
+        return algs
+
+    #===================================================================
+    # migration
+    #===================================================================
+    def _calc_needs_update(self, **kwds):
+        # marks hashes as deprecated if they don't include at least all default_algs.
+        # XXX: should we deprecate if they aren't exactly the same,
+        #      to permit removing legacy hashes?
+        if not set(self.algs).issuperset(self.default_algs):
+            return True
+
+        # hand off to base implementation
+        return super(scram, self)._calc_needs_update(**kwds)
+
+    #===================================================================
+    # digest methods
+    #===================================================================
+    def _calc_checksum(self, secret, alg=None):
+        rounds = self.rounds
+        salt = self.salt
+        hash = self.derive_digest
+        if alg:
+            # if requested, generate digest for specific alg
+            return hash(secret, salt, rounds, alg)
+        else:
+            # by default, return dict containing digests for all algs
+            return dict(
+                (alg, hash(secret, salt, rounds, alg))
+                for alg in self.algs
+            )
+
+    @classmethod
+    def verify(cls, secret, hash, full=False):
+        uh.validate_secret(secret)
+        self = cls.from_string(hash)
+        chkmap = self.checksum
+        if not chkmap:
+            raise ValueError("expected %s hash, got %s config string instead" %
+                             (cls.name, cls.name))
+
+        # NOTE: to make the verify method efficient, we just calculate hash
+        # of shortest digest by default. apps can pass in "full=True" to
+        # check entire hash for consistency.
+        if full:
+            correct = failed = False
+            for alg, digest in iteritems(chkmap):
+                other = self._calc_checksum(secret, alg)
+                # NOTE: could do this length check in norm_algs(),
+                # but don't need to be that strict, and want to be able
+                # to parse hashes containing algs not supported by platform.
+                # it's fine if we fail here though.
+                if len(digest) != len(other):
+                    raise ValueError("mis-sized %s digest in scram hash: %r != %r"
+                                     % (alg, len(digest), len(other)))
+                if consteq(other, digest):
+                    correct = True
+                else:
+                    failed = True
+            if correct and failed:
+                raise ValueError("scram hash verified inconsistently, "
+                                 "may be corrupted")
+            else:
+                return correct
+        else:
+            # XXX: should this just always use sha1 hash? would be faster.
+            # otherwise only verify against one hash, pick one w/ best security.
+            for alg in self._verify_algs:
+                if alg in chkmap:
+                    other = self._calc_checksum(secret, alg)
+                    return consteq(other, chkmap[alg])
+            # there should always be sha-1 at the very least,
+            # or something went wrong inside _norm_algs()
+            raise AssertionError("sha-1 digest not found!")
+
+    #===================================================================
+    #
+    #===================================================================
+
+#=============================================================================
+# code used for testing scram against protocol examples during development.
+#=============================================================================
+##def _test_reference_scram():
+##    "quick hack testing scram reference vectors"
+##    # NOTE: "n,," is GS2 header - see https://tools.ietf.org/html/rfc5801
+##    from passlib.utils.compat import print_
+##
+##    engine = _scram_engine(
+##        alg="sha-1",
+##        salt='QSXCR+Q6sek8bf92'.decode("base64"),
+##        rounds=4096,
+##        password=u("pencil"),
+##    )
+##    print_(engine.digest.encode("base64").rstrip())
+##
+##    msg = engine.format_auth_msg(
+##        username="user",
+##        client_nonce = "fyko+d2lbbFgONRv9qkxdawL",
+##        server_nonce = "3rfcNHYJY1ZVvWVs7j",
+##        header='c=biws',
+##    )
+##
+##    cp = engine.get_encoded_client_proof(msg)
+##    assert cp == "v0X8v3Bz2T0CJGbJQyF0X+HI4Ts=", cp
+##
+##    ss = engine.get_encoded_server_sig(msg)
+##    assert ss == "rmF9pqV8S7suAoZWja4dJRkFsKQ=", ss
+##
+##class _scram_engine(object):
+##    """helper class for verifying scram hash behavior
+##    against SCRAM protocol examples. not officially part of Passlib.
+##
+##    takes in alg, salt, rounds, and a digest or password.
+##
+##    can calculate the various keys & messages of the scram protocol.
+##
+##    """
+##    #=========================================================
+##    # init
+##    #=========================================================
+##
+##    @classmethod
+##    def from_string(cls, hash, alg):
+##        "create record from scram hash, for given alg"
+##        return cls(alg, *scram.extract_digest_info(hash, alg))
+##
+##    def __init__(self, alg, salt, rounds, digest=None, password=None):
+##        self.alg = norm_hash_name(alg)
+##        self.salt = salt
+##        self.rounds = rounds
+##        self.password = password
+##        if password:
+##            data = scram.derive_digest(password, salt, rounds, alg)
+##            if digest and data != digest:
+##                raise ValueError("password doesn't match digest")
+##            else:
+##                digest = data
+##        elif not digest:
+##            raise TypeError("must provide password or digest")
+##        self.digest = digest
+##
+##    #=========================================================
+##    # frontend methods
+##    #=========================================================
+##    def get_hash(self, data):
+##        "return hash of raw data"
+##        return hashlib.new(iana_to_hashlib(self.alg), data).digest()
+##
+##    def get_client_proof(self, msg):
+##        "return client proof of specified auth msg text"
+##        return xor_bytes(self.client_key, self.get_client_sig(msg))
+##
+##    def get_encoded_client_proof(self, msg):
+##        return self.get_client_proof(msg).encode("base64").rstrip()
+##
+##    def get_client_sig(self, msg):
+##        "return client signature of specified auth msg text"
+##        return self.get_hmac(self.stored_key, msg)
+##
+##    def get_server_sig(self, msg):
+##        "return server signature of specified auth msg text"
+##        return self.get_hmac(self.server_key, msg)
+##
+##    def get_encoded_server_sig(self, msg):
+##        return self.get_server_sig(msg).encode("base64").rstrip()
+##
+##    def format_server_response(self, client_nonce, server_nonce):
+##        return 'r={client_nonce}{server_nonce},s={salt},i={rounds}'.format(
+##            client_nonce=client_nonce,
+##            server_nonce=server_nonce,
+##            rounds=self.rounds,
+##            salt=self.encoded_salt,
+##            )
+##
+##    def format_auth_msg(self, username, client_nonce, server_nonce,
+##                        header='c=biws'):
+##        return (
+##            'n={username},r={client_nonce}'
+##                ','
+##            'r={client_nonce}{server_nonce},s={salt},i={rounds}'
+##                ','
+##            '{header},r={client_nonce}{server_nonce}'
+##            ).format(
+##                username=username,
+##                client_nonce=client_nonce,
+##                server_nonce=server_nonce,
+##                salt=self.encoded_salt,
+##                rounds=self.rounds,
+##                header=header,
+##                )
+##
+##    #=========================================================
+##    # helpers to calculate & cache constant data
+##    #=========================================================
+##    def _calc_get_hmac(self):
+##        return get_prf("hmac-" + iana_to_hashlib(self.alg))[0]
+##
+##    def _calc_client_key(self):
+##        return self.get_hmac(self.digest, b("Client Key"))
+##
+##    def _calc_stored_key(self):
+##        return self.get_hash(self.client_key)
+##
+##    def _calc_server_key(self):
+##        return self.get_hmac(self.digest, b("Server Key"))
+##
+##    def _calc_encoded_salt(self):
+##        return self.salt.encode("base64").rstrip()
+##
+##    #=========================================================
+##    # hacks for calculated attributes
+##    #=========================================================
+##
+##    def __getattr__(self, attr):
+##        if not attr.startswith("_"):
+##            f = getattr(self, "_calc_" + attr, None)
+##            if f:
+##                value = f()
+##                setattr(self, attr, value)
+##                return value
+##        raise AttributeError("attribute not found")
+##
+##    def __dir__(self):
+##        cdir = dir(self.__class__)
+##        attrs = set(cdir)
+##        attrs.update(self.__dict__)
+##        attrs.update(attr[6:] for attr in cdir
+##                     if attr.startswith("_calc_"))
+##        return sorted(attrs)
+##    #=========================================================
+##    # eoc
+##    #=========================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/scrypt.py b/myenv/lib/python3.9/site-packages/passlib/handlers/scrypt.py
new file mode 100644
index 0000000..1686fda
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/scrypt.py
@@ -0,0 +1,383 @@
+"""passlib.handlers.scrypt -- scrypt password hash"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement, absolute_import
+# core
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.crypto import scrypt as _scrypt
+from passlib.utils import h64, to_bytes
+from passlib.utils.binary import h64, b64s_decode, b64s_encode
+from passlib.utils.compat import u, bascii_to_str, suppress_cause
+from passlib.utils.decor import classproperty
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "scrypt",
+]
+
+#=============================================================================
+# scrypt format identifiers
+#=============================================================================
+
+IDENT_SCRYPT = u("$scrypt$")  # identifier used by passlib
+IDENT_7 = u("$7$")  # used by official scrypt spec
+
+_UDOLLAR = u("$")
+
+#=============================================================================
+# handler
+#=============================================================================
+class scrypt(uh.ParallelismMixin, uh.HasRounds, uh.HasRawSalt, uh.HasRawChecksum, uh.HasManyIdents,
+             uh.GenericHandler):
+    """This class implements an SCrypt-based password [#scrypt-home]_ hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, a variable number of rounds,
+    as well as some custom tuning parameters unique to scrypt (see below).
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If specified, the length must be between 0-1024 bytes.
+        If not specified, one will be auto-generated (this is recommended).
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to 16 bytes, but can be any value between 0 and 1024.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 16, but must be within ``range(1,32)``.
+
+        .. warning::
+
+            Unlike many hash algorithms, increasing the rounds value
+            will increase both the time *and memory* required to hash a password.
+
+    :type block_size: int
+    :param block_size:
+        Optional block size to pass to scrypt hash function (the ``r`` parameter).
+        Useful for tuning scrypt to optimal performance for your CPU architecture.
+        Defaults to 8.
+
+    :type parallelism: int
+    :param parallelism:
+        Optional parallelism to pass to scrypt hash function (the ``p`` parameter).
+        Defaults to 1.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+    .. note::
+
+        The underlying scrypt hash function has a number of limitations
+        on it's parameter values, which forbids certain combinations of settings.
+        The requirements are:
+
+        * ``linear_rounds = 2**<some positive integer>``
+        * ``linear_rounds < 2**(16 * block_size)``
+        * ``block_size * parallelism <= 2**30-1``
+
+    .. todo::
+
+        This class currently does not support configuring default values
+        for ``block_size`` or ``parallelism`` via a :class:`~passlib.context.CryptContext`
+        configuration.
+    """
+
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #------------------------
+    # PasswordHash
+    #------------------------
+    name = "scrypt"
+    setting_kwds = ("ident", "salt", "salt_size", "rounds", "block_size", "parallelism")
+
+    #------------------------
+    # GenericHandler
+    #------------------------
+    # NOTE: scrypt supports arbitrary output sizes. since it's output runs through
+    #       pbkdf2-hmac-sha256 before returning, and this could be raised eventually...
+    #       but a 256-bit digest is more than sufficient for password hashing.
+    # XXX: make checksum size configurable? could merge w/ argon2 code that does this.
+    checksum_size = 32
+
+    #------------------------
+    # HasManyIdents
+    #------------------------
+    default_ident = IDENT_SCRYPT
+    ident_values = (IDENT_SCRYPT, IDENT_7)
+
+    #------------------------
+    # HasRawSalt
+    #------------------------
+    default_salt_size = 16
+    max_salt_size = 1024
+
+    #------------------------
+    # HasRounds
+    #------------------------
+    # TODO: would like to dynamically pick this based on system
+    default_rounds = 16
+    min_rounds = 1
+    max_rounds = 31  # limited by scrypt alg
+    rounds_cost = "log2"
+
+    # TODO: make default block size configurable via using(), and deprecatable via .needs_update()
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+
+    #: default parallelism setting (min=1 currently hardcoded in mixin)
+    parallelism = 1
+
+    #: default block size setting
+    block_size = 8
+
+    #===================================================================
+    # variant constructor
+    #===================================================================
+
+    @classmethod
+    def using(cls, block_size=None, **kwds):
+        subcls = super(scrypt, cls).using(**kwds)
+        if block_size is not None:
+            if isinstance(block_size, uh.native_string_types):
+                block_size = int(block_size)
+            subcls.block_size = subcls._norm_block_size(block_size, relaxed=kwds.get("relaxed"))
+
+        # make sure param combination is valid for scrypt()
+        try:
+            _scrypt.validate(1 << cls.default_rounds, cls.block_size, cls.parallelism)
+        except ValueError as err:
+            raise suppress_cause(ValueError("scrypt: invalid settings combination: " + str(err)))
+
+        return subcls
+
+    #===================================================================
+    # parsing
+    #===================================================================
+
+    @classmethod
+    def from_string(cls, hash):
+        return cls(**cls.parse(hash))
+
+    @classmethod
+    def parse(cls, hash):
+        ident, suffix = cls._parse_ident(hash)
+        func = getattr(cls, "_parse_%s_string" % ident.strip(_UDOLLAR), None)
+        if func:
+            return func(suffix)
+        else:
+            raise uh.exc.InvalidHashError(cls)
+
+    #
+    # passlib's format:
+    #   $scrypt$ln=<logN>,r=<r>,p=<p>$<salt>[$<digest>]
+    # where:
+    #   logN, r, p -- decimal-encoded positive integer, no zero-padding
+    #   logN -- log cost setting
+    #   r -- block size setting (usually 8)
+    #   p -- parallelism setting (usually 1)
+    #   salt, digest -- b64-nopad encoded bytes
+    #
+
+    @classmethod
+    def _parse_scrypt_string(cls, suffix):
+        # break params, salt, and digest sections
+        parts = suffix.split("$")
+        if len(parts) == 3:
+            params, salt, digest = parts
+        elif len(parts) == 2:
+            params, salt = parts
+            digest = None
+        else:
+            raise uh.exc.MalformedHashError(cls, "malformed hash")
+
+        # break params apart
+        parts = params.split(",")
+        if len(parts) == 3:
+            nstr, bstr, pstr = parts
+            assert nstr.startswith("ln=")
+            assert bstr.startswith("r=")
+            assert pstr.startswith("p=")
+        else:
+            raise uh.exc.MalformedHashError(cls, "malformed settings field")
+
+        return dict(
+            ident=IDENT_SCRYPT,
+            rounds=int(nstr[3:]),
+            block_size=int(bstr[2:]),
+            parallelism=int(pstr[2:]),
+            salt=b64s_decode(salt.encode("ascii")),
+            checksum=b64s_decode(digest.encode("ascii")) if digest else None,
+            )
+
+    #
+    # official format specification defined at
+    #   https://gitlab.com/jas/scrypt-unix-crypt/blob/master/unix-scrypt.txt
+    # format:
+    #   $7$<N><rrrrr><ppppp><salt...>[$<digest>]
+    #       0  12345  67890  1
+    # where:
+    #   All bytes use h64-little-endian encoding
+    #   N: 6-bit log cost setting
+    #   r: 30-bit block size setting
+    #   p: 30-bit parallelism setting
+    #   salt: variable length salt bytes
+    #   digest: fixed 32-byte digest
+    #
+
+    @classmethod
+    def _parse_7_string(cls, suffix):
+        # XXX: annoyingly, official spec embeds salt *raw*, yet doesn't specify a hash encoding.
+        #      so assuming only h64 chars are valid for salt, and are ASCII encoded.
+
+        # split into params & digest
+        parts = suffix.encode("ascii").split(b"$")
+        if len(parts) == 2:
+            params, digest = parts
+        elif len(parts) == 1:
+            params, = parts
+            digest = None
+        else:
+            raise uh.exc.MalformedHashError()
+
+        # parse params & return
+        if len(params) < 11:
+            raise uh.exc.MalformedHashError(cls, "params field too short")
+        return dict(
+            ident=IDENT_7,
+            rounds=h64.decode_int6(params[:1]),
+            block_size=h64.decode_int30(params[1:6]),
+            parallelism=h64.decode_int30(params[6:11]),
+            salt=params[11:],
+            checksum=h64.decode_bytes(digest) if digest else None,
+        )
+
+    #===================================================================
+    # formatting
+    #===================================================================
+    def to_string(self):
+        ident = self.ident
+        if ident == IDENT_SCRYPT:
+            return "$scrypt$ln=%d,r=%d,p=%d$%s$%s" % (
+                self.rounds,
+                self.block_size,
+                self.parallelism,
+                bascii_to_str(b64s_encode(self.salt)),
+                bascii_to_str(b64s_encode(self.checksum)),
+            )
+        else:
+            assert ident == IDENT_7
+            salt = self.salt
+            try:
+                salt.decode("ascii")
+            except UnicodeDecodeError:
+                raise suppress_cause(NotImplementedError("scrypt $7$ hashes dont support non-ascii salts"))
+            return bascii_to_str(b"".join([
+                b"$7$",
+                h64.encode_int6(self.rounds),
+                h64.encode_int30(self.block_size),
+                h64.encode_int30(self.parallelism),
+                self.salt,
+                b"$",
+                h64.encode_bytes(self.checksum)
+            ]))
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, block_size=None, **kwds):
+        super(scrypt, self).__init__(**kwds)
+
+        # init block size
+        if block_size is None:
+            assert uh.validate_default_value(self, self.block_size, self._norm_block_size,
+                                             param="block_size")
+        else:
+            self.block_size = self._norm_block_size(block_size)
+
+        # NOTE: if hash contains invalid complex constraint, relying on error
+        #       being raised by scrypt call in _calc_checksum()
+
+    @classmethod
+    def _norm_block_size(cls, block_size, relaxed=False):
+        return uh.norm_integer(cls, block_size, min=1, param="block_size", relaxed=relaxed)
+
+    def _generate_salt(self):
+        salt = super(scrypt, self)._generate_salt()
+        if self.ident == IDENT_7:
+            # this format doesn't support non-ascii salts.
+            # as workaround, we take raw bytes, encoded to base64
+            salt = b64s_encode(salt)
+        return salt
+
+    #===================================================================
+    # backend configuration
+    # NOTE: this following HasManyBackends' API, but provides it's own implementation,
+    #       which actually switches the backend that 'passlib.crypto.scrypt.scrypt()' uses.
+    #===================================================================
+
+    @classproperty
+    def backends(cls):
+        return _scrypt.backend_values
+
+    @classmethod
+    def get_backend(cls):
+        return _scrypt.backend
+
+    @classmethod
+    def has_backend(cls, name="any"):
+        try:
+            cls.set_backend(name, dryrun=True)
+            return True
+        except uh.exc.MissingBackendError:
+            return False
+
+    @classmethod
+    def set_backend(cls, name="any", dryrun=False):
+        _scrypt._set_backend(name, dryrun=dryrun)
+
+    #===================================================================
+    # digest calculation
+    #===================================================================
+    def _calc_checksum(self, secret):
+        secret = to_bytes(secret, param="secret")
+        return _scrypt.scrypt(secret, self.salt, n=(1 << self.rounds), r=self.block_size,
+                              p=self.parallelism, keylen=self.checksum_size)
+
+    #===================================================================
+    # hash migration
+    #===================================================================
+
+    def _calc_needs_update(self, **kwds):
+        """
+        mark hash as needing update if rounds is outside desired bounds.
+        """
+        # XXX: for now, marking all hashes which don't have matching block_size setting
+        if self.block_size != type(self).block_size:
+            return True
+        return super(scrypt, self)._calc_needs_update(**kwds)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/sha1_crypt.py b/myenv/lib/python3.9/site-packages/passlib/handlers/sha1_crypt.py
new file mode 100644
index 0000000..8f9aa71
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/sha1_crypt.py
@@ -0,0 +1,158 @@
+"""passlib.handlers.sha1_crypt
+"""
+
+#=============================================================================
+# imports
+#=============================================================================
+
+# core
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils import safe_crypt, test_crypt
+from passlib.utils.binary import h64
+from passlib.utils.compat import u, unicode, irange
+from passlib.crypto.digest import compile_hmac
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+]
+#=============================================================================
+# sha1-crypt
+#=============================================================================
+_BNULL = b'\x00'
+
+class sha1_crypt(uh.HasManyBackends, uh.HasRounds, uh.HasSalt, uh.GenericHandler):
+    """This class implements the SHA1-Crypt password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, an 8 character one will be autogenerated (this is recommended).
+        If specified, it must be 0-64 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :type salt_size: int
+    :param salt_size:
+        Optional number of bytes to use when autogenerating new salts.
+        Defaults to 8 bytes, but can be any value between 0 and 64.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 480000, must be between 1 and 4294967295, inclusive.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+
+    #===================================================================
+    # class attrs
+    #===================================================================
+    #--GenericHandler--
+    name = "sha1_crypt"
+    setting_kwds = ("salt", "salt_size", "rounds")
+    ident = u("$sha1$")
+    checksum_size = 28
+    checksum_chars = uh.HASH64_CHARS
+
+    #--HasSalt--
+    default_salt_size = 8
+    max_salt_size = 64
+    salt_chars = uh.HASH64_CHARS
+
+    #--HasRounds--
+    default_rounds = 480000 # current passlib default
+    min_rounds = 1 # really, this should be higher.
+    max_rounds = 4294967295 # 32-bit integer limit
+    rounds_cost = "linear"
+
+    #===================================================================
+    # formatting
+    #===================================================================
+    @classmethod
+    def from_string(cls, hash):
+        rounds, salt, chk = uh.parse_mc3(hash, cls.ident, handler=cls)
+        return cls(rounds=rounds, salt=salt, checksum=chk)
+
+    def to_string(self, config=False):
+        chk = None if config else self.checksum
+        return uh.render_mc3(self.ident, self.rounds, self.salt, chk)
+
+    #===================================================================
+    # backend
+    #===================================================================
+    backends = ("os_crypt", "builtin")
+
+    #---------------------------------------------------------------
+    # os_crypt backend
+    #---------------------------------------------------------------
+    @classmethod
+    def _load_backend_os_crypt(cls):
+        if test_crypt("test", '$sha1$1$Wq3GL2Vp$C8U25GvfHS8qGHim'
+                              'ExLaiSFlGkAe'):
+            cls._set_calc_checksum_backend(cls._calc_checksum_os_crypt)
+            return True
+        else:
+            return False
+
+    def _calc_checksum_os_crypt(self, secret):
+        config = self.to_string(config=True)
+        hash = safe_crypt(secret, config)
+        if hash is None:
+            # py3's crypt.crypt() can't handle non-utf8 bytes.
+            # fallback to builtin alg, which is always available.
+            return self._calc_checksum_builtin(secret)
+        if not hash.startswith(config) or len(hash) != len(config) + 29:
+            raise uh.exc.CryptBackendError(self, config, hash)
+        return hash[-28:]
+
+    #---------------------------------------------------------------
+    # builtin backend
+    #---------------------------------------------------------------
+    @classmethod
+    def _load_backend_builtin(cls):
+        cls._set_calc_checksum_backend(cls._calc_checksum_builtin)
+        return True
+
+    def _calc_checksum_builtin(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        if _BNULL in secret:
+            raise uh.exc.NullPasswordError(self)
+        rounds = self.rounds
+        # NOTE: this seed value is NOT the same as the config string
+        result = (u("%s$sha1$%s") % (self.salt, rounds)).encode("ascii")
+        # NOTE: this algorithm is essentially PBKDF1, modified to use HMAC.
+        keyed_hmac = compile_hmac("sha1", secret)
+        for _ in irange(rounds):
+            result = keyed_hmac(result)
+        return h64.encode_transposed_bytes(result, self._chk_offsets).decode("ascii")
+
+    _chk_offsets = [
+        2,1,0,
+        5,4,3,
+        8,7,6,
+        11,10,9,
+        14,13,12,
+        17,16,15,
+        0,19,18,
+    ]
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/sha2_crypt.py b/myenv/lib/python3.9/site-packages/passlib/handlers/sha2_crypt.py
new file mode 100644
index 0000000..e6060c5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/sha2_crypt.py
@@ -0,0 +1,534 @@
+"""passlib.handlers.sha2_crypt - SHA256-Crypt / SHA512-Crypt"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import hashlib
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils import safe_crypt, test_crypt, \
+                          repeat_string, to_unicode
+from passlib.utils.binary import h64
+from passlib.utils.compat import byte_elem_value, u, \
+                                 uascii_to_str, unicode
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "sha512_crypt",
+    "sha256_crypt",
+]
+
+#=============================================================================
+# pure-python backend, used by both sha256_crypt & sha512_crypt
+# when crypt.crypt() backend is not available.
+#=============================================================================
+_BNULL = b'\x00'
+
+# pre-calculated offsets used to speed up C digest stage (see notes below).
+# sequence generated using the following:
+    ##perms_order = "p,pp,ps,psp,sp,spp".split(",")
+    ##def offset(i):
+    ##    key = (("p" if i % 2 else "") + ("s" if i % 3 else "") +
+    ##        ("p" if i % 7 else "") + ("" if i % 2 else "p"))
+    ##    return perms_order.index(key)
+    ##_c_digest_offsets = [(offset(i), offset(i+1)) for i in range(0,42,2)]
+_c_digest_offsets = (
+    (0, 3), (5, 1), (5, 3), (1, 2), (5, 1), (5, 3), (1, 3),
+    (4, 1), (5, 3), (1, 3), (5, 0), (5, 3), (1, 3), (5, 1),
+    (4, 3), (1, 3), (5, 1), (5, 2), (1, 3), (5, 1), (5, 3),
+    )
+
+# map used to transpose bytes when encoding final sha256_crypt digest
+_256_transpose_map = (
+    20, 10,  0, 11,  1, 21,  2, 22, 12, 23, 13,  3, 14,  4, 24,  5,
+    25, 15, 26, 16,  6, 17,  7, 27,  8, 28, 18, 29, 19,  9, 30, 31,
+)
+
+# map used to transpose bytes when encoding final sha512_crypt digest
+_512_transpose_map = (
+    42, 21,  0,  1, 43, 22, 23,  2, 44, 45, 24,  3,  4, 46, 25, 26,
+     5, 47, 48, 27,  6,  7, 49, 28, 29,  8, 50, 51, 30,  9, 10, 52,
+    31, 32, 11, 53, 54, 33, 12, 13, 55, 34, 35, 14, 56, 57, 36, 15,
+    16, 58, 37, 38, 17, 59, 60, 39, 18, 19, 61, 40, 41, 20, 62, 63,
+)
+
+def _raw_sha2_crypt(pwd, salt, rounds, use_512=False):
+    """perform raw sha256-crypt / sha512-crypt
+
+    this function provides a pure-python implementation of the internals
+    for the SHA256-Crypt and SHA512-Crypt algorithms; it doesn't
+    handle any of the parsing/validation of the hash strings themselves.
+
+    :arg pwd: password chars/bytes to hash
+    :arg salt: salt chars to use
+    :arg rounds: linear rounds cost
+    :arg use_512: use sha512-crypt instead of sha256-crypt mode
+
+    :returns:
+        encoded checksum chars
+    """
+    #===================================================================
+    # init & validate inputs
+    #===================================================================
+
+    # NOTE: the setup portion of this algorithm scales ~linearly in time
+    #       with the size of the password, making it vulnerable to a DOS from
+    #       unreasonably large inputs. the following code has some optimizations
+    #       which would make things even worse, using O(pwd_len**2) memory
+    #       when calculating digest P. 
+    #
+    #       to mitigate these two issues: 1) this code switches to a 
+    #       O(pwd_len)-memory algorithm for passwords that are much larger 
+    #       than average, and 2) Passlib enforces a library-wide max limit on
+    #       the size of passwords it will allow, to prevent this algorithm and 
+    #       others from being DOSed in this way (see passlib.exc.PasswordSizeError
+    #       for details).
+
+    # validate secret
+    if isinstance(pwd, unicode):
+        # XXX: not sure what official unicode policy is, using this as default
+        pwd = pwd.encode("utf-8")
+    assert isinstance(pwd, bytes)
+    if _BNULL in pwd:
+        raise uh.exc.NullPasswordError(sha512_crypt if use_512 else sha256_crypt)
+    pwd_len = len(pwd)
+
+    # validate rounds
+    assert 1000 <= rounds <= 999999999, "invalid rounds"
+        # NOTE: spec says out-of-range rounds should be clipped, instead of
+        # causing an error. this function assumes that's been taken care of
+        # by the handler class.
+
+    # validate salt
+    assert isinstance(salt, unicode), "salt not unicode"
+    salt = salt.encode("ascii")
+    salt_len = len(salt)
+    assert salt_len < 17, "salt too large"
+        # NOTE: spec says salts larger than 16 bytes should be truncated,
+        # instead of causing an error. this function assumes that's been
+        # taken care of by the handler class.
+
+    # load sha256/512 specific constants
+    if use_512:
+        hash_const = hashlib.sha512
+        transpose_map = _512_transpose_map
+    else:
+        hash_const = hashlib.sha256
+        transpose_map = _256_transpose_map
+
+    #===================================================================
+    # digest B - used as subinput to digest A
+    #===================================================================
+    db = hash_const(pwd + salt + pwd).digest()
+
+    #===================================================================
+    # digest A - used to initialize first round of digest C
+    #===================================================================
+    # start out with pwd + salt
+    a_ctx = hash_const(pwd + salt)
+    a_ctx_update = a_ctx.update
+
+    # add pwd_len bytes of b, repeating b as many times as needed.
+    a_ctx_update(repeat_string(db, pwd_len))
+
+    # for each bit in pwd_len: add b if it's 1, or pwd if it's 0
+    i = pwd_len
+    while i:
+        a_ctx_update(db if i & 1 else pwd)
+        i >>= 1
+
+    # finish A
+    da = a_ctx.digest()
+
+    #===================================================================
+    # digest P from password - used instead of password itself
+    #                          when calculating digest C.
+    #===================================================================
+    if pwd_len < 96:
+        # this method is faster under python, but uses O(pwd_len**2) memory;
+        # so we don't use it for larger passwords to avoid a potential DOS.
+        dp = repeat_string(hash_const(pwd * pwd_len).digest(), pwd_len)
+    else:
+        # this method is slower under python, but uses a fixed amount of memory.
+        tmp_ctx = hash_const(pwd)
+        tmp_ctx_update = tmp_ctx.update
+        i = pwd_len-1
+        while i:
+            tmp_ctx_update(pwd)
+            i -= 1
+        dp = repeat_string(tmp_ctx.digest(), pwd_len)
+    assert len(dp) == pwd_len
+
+    #===================================================================
+    # digest S  - used instead of salt itself when calculating digest C
+    #===================================================================
+    ds = hash_const(salt * (16 + byte_elem_value(da[0]))).digest()[:salt_len]
+    assert len(ds) == salt_len, "salt_len somehow > hash_len!"
+
+    #===================================================================
+    # digest C - for a variable number of rounds, combine A, S, and P
+    #            digests in various ways; in order to burn CPU time.
+    #===================================================================
+
+    # NOTE: the original SHA256/512-Crypt specification performs the C digest
+    # calculation using the following loop:
+    #
+    ##dc = da
+    ##i = 0
+    ##while i < rounds:
+    ##    tmp_ctx = hash_const(dp if i & 1 else dc)
+    ##    if i % 3:
+    ##        tmp_ctx.update(ds)
+    ##    if i % 7:
+    ##        tmp_ctx.update(dp)
+    ##    tmp_ctx.update(dc if i & 1 else dp)
+    ##    dc = tmp_ctx.digest()
+    ##    i += 1
+    #
+    # The code Passlib uses (below) implements an equivalent algorithm,
+    # it's just been heavily optimized to pre-calculate a large number
+    # of things beforehand. It works off of a couple of observations
+    # about the original algorithm:
+    #
+    # 1. each round is a combination of 'dc', 'ds', and 'dp'; determined
+    #    by the whether 'i' a multiple of 2,3, and/or 7.
+    # 2. since lcm(2,3,7)==42, the series of combinations will repeat
+    #    every 42 rounds.
+    # 3. even rounds 0-40 consist of 'hash(dc + round-specific-constant)';
+    #    while odd rounds 1-41 consist of hash(round-specific-constant + dc)
+    #
+    # Using these observations, the following code...
+    # * calculates the round-specific combination of ds & dp for each round 0-41
+    # * runs through as many 42-round blocks as possible
+    # * runs through as many pairs of rounds as possible for remaining rounds
+    # * performs once last round if the total rounds should be odd.
+    #
+    # this cuts out a lot of the control overhead incurred when running the
+    # original loop 40,000+ times in python, resulting in ~20% increase in
+    # speed under CPython (though still 2x slower than glibc crypt)
+
+    # prepare the 6 combinations of ds & dp which are needed
+    # (order of 'perms' must match how _c_digest_offsets was generated)
+    dp_dp = dp+dp
+    dp_ds = dp+ds
+    perms = [dp, dp_dp, dp_ds, dp_ds+dp, ds+dp, ds+dp_dp]
+
+    # build up list of even-round & odd-round constants,
+    # and store in 21-element list as (even,odd) pairs.
+    data = [ (perms[even], perms[odd]) for even, odd in _c_digest_offsets]
+
+    # perform as many full 42-round blocks as possible
+    dc = da
+    blocks, tail = divmod(rounds, 42)
+    while blocks:
+        for even, odd in data:
+            dc = hash_const(odd + hash_const(dc + even).digest()).digest()
+        blocks -= 1
+
+    # perform any leftover rounds
+    if tail:
+        # perform any pairs of rounds
+        pairs = tail>>1
+        for even, odd in data[:pairs]:
+            dc = hash_const(odd + hash_const(dc + even).digest()).digest()
+
+        # if rounds was odd, do one last round (since we started at 0,
+        # last round will be an even-numbered round)
+        if tail & 1:
+            dc = hash_const(dc + data[pairs][0]).digest()
+
+    #===================================================================
+    # encode digest using appropriate transpose map
+    #===================================================================
+    return h64.encode_transposed_bytes(dc, transpose_map).decode("ascii")
+
+#=============================================================================
+# handlers
+#=============================================================================
+_UROUNDS = u("rounds=")
+_UDOLLAR = u("$")
+_UZERO = u("0")
+
+class _SHA2_Common(uh.HasManyBackends, uh.HasRounds, uh.HasSalt,
+                   uh.GenericHandler):
+    """class containing common code shared by sha256_crypt & sha512_crypt"""
+    #===================================================================
+    # class attrs
+    #===================================================================
+    # name - set by subclass
+    setting_kwds = ("salt", "rounds", "implicit_rounds", "salt_size")
+    # ident - set by subclass
+    checksum_chars = uh.HASH64_CHARS
+    # checksum_size - set by subclass
+
+    max_salt_size = 16
+    salt_chars = uh.HASH64_CHARS
+
+    min_rounds = 1000 # bounds set by spec
+    max_rounds = 999999999 # bounds set by spec
+    rounds_cost = "linear"
+
+    _cdb_use_512 = False # flag for _calc_digest_builtin()
+    _rounds_prefix = None # ident + _UROUNDS
+
+    #===================================================================
+    # methods
+    #===================================================================
+    implicit_rounds = False
+
+    def __init__(self, implicit_rounds=None, **kwds):
+        super(_SHA2_Common, self).__init__(**kwds)
+        # if user calls hash() w/ 5000 rounds, default to compact form.
+        if implicit_rounds is None:
+            implicit_rounds = (self.use_defaults and self.rounds == 5000)
+        self.implicit_rounds = implicit_rounds
+
+    def _parse_salt(self, salt):
+        # required per SHA2-crypt spec -- truncate config salts rather than throwing error
+        return self._norm_salt(salt, relaxed=self.checksum is None)
+
+    def _parse_rounds(self, rounds):
+        # required per SHA2-crypt spec -- clip config rounds rather than throwing error
+        return self._norm_rounds(rounds, relaxed=self.checksum is None)
+
+    @classmethod
+    def from_string(cls, hash):
+        # basic format this parses -
+        # $5$[rounds=<rounds>$]<salt>[$<checksum>]
+
+        # TODO: this *could* use uh.parse_mc3(), except that the rounds
+        # portion has a slightly different grammar.
+
+        # convert to unicode, check for ident prefix, split on dollar signs.
+        hash = to_unicode(hash, "ascii", "hash")
+        ident = cls.ident
+        if not hash.startswith(ident):
+            raise uh.exc.InvalidHashError(cls)
+        assert len(ident) == 3
+        parts = hash[3:].split(_UDOLLAR)
+
+        # extract rounds value
+        if parts[0].startswith(_UROUNDS):
+            assert len(_UROUNDS) == 7
+            rounds = parts.pop(0)[7:]
+            if rounds.startswith(_UZERO) and rounds != _UZERO:
+                raise uh.exc.ZeroPaddedRoundsError(cls)
+            rounds = int(rounds)
+            implicit_rounds = False
+        else:
+            rounds = 5000
+            implicit_rounds = True
+
+        # rest should be salt and checksum
+        if len(parts) == 2:
+            salt, chk = parts
+        elif len(parts) == 1:
+            salt = parts[0]
+            chk = None
+        else:
+            raise uh.exc.MalformedHashError(cls)
+
+        # return new object
+        return cls(
+            rounds=rounds,
+            salt=salt,
+            checksum=chk or None,
+            implicit_rounds=implicit_rounds,
+            )
+
+    def to_string(self):
+        if self.rounds == 5000 and self.implicit_rounds:
+            hash = u("%s%s$%s") % (self.ident, self.salt,
+                                   self.checksum or u(''))
+        else:
+            hash = u("%srounds=%d$%s$%s") % (self.ident, self.rounds,
+                                             self.salt, self.checksum or u(''))
+        return uascii_to_str(hash)
+
+    #===================================================================
+    # backends
+    #===================================================================
+    backends = ("os_crypt", "builtin")
+
+    #---------------------------------------------------------------
+    # os_crypt backend
+    #---------------------------------------------------------------
+
+    #: test hash for OS detection -- provided by subclass
+    _test_hash = None
+
+    @classmethod
+    def _load_backend_os_crypt(cls):
+        if test_crypt(*cls._test_hash):
+            cls._set_calc_checksum_backend(cls._calc_checksum_os_crypt)
+            return True
+        else:
+            return False
+
+    def _calc_checksum_os_crypt(self, secret):
+        config = self.to_string()
+        hash = safe_crypt(secret, config)
+        if hash is None:
+            # py3's crypt.crypt() can't handle non-utf8 bytes.
+            # fallback to builtin alg, which is always available.
+            return self._calc_checksum_builtin(secret)
+        # NOTE: avoiding full parsing routine via from_string().checksum,
+        # and just extracting the bit we need.
+        cs = self.checksum_size
+        if not hash.startswith(self.ident) or hash[-cs-1] != _UDOLLAR:
+            raise uh.exc.CryptBackendError(self, config, hash)
+        return hash[-cs:]
+
+    #---------------------------------------------------------------
+    # builtin backend
+    #---------------------------------------------------------------
+    @classmethod
+    def _load_backend_builtin(cls):
+        cls._set_calc_checksum_backend(cls._calc_checksum_builtin)
+        return True
+
+    def _calc_checksum_builtin(self, secret):
+        return _raw_sha2_crypt(secret, self.salt, self.rounds,
+                               self._cdb_use_512)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class sha256_crypt(_SHA2_Common):
+    """This class implements the SHA256-Crypt password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 0-16 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 535000, must be between 1000 and 999999999, inclusive.
+
+        .. note::
+            per the official specification, when the rounds parameter is set to 5000,
+            it may be omitted from the hash string.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+
+    ..
+        commented out, currently only supported by :meth:`hash`, and not via :meth:`using`:
+
+        :type implicit_rounds: bool
+        :param implicit_rounds:
+            this is an internal option which generally doesn't need to be touched.
+
+            this flag determines whether the hash should omit the rounds parameter
+            when encoding it to a string; this is only permitted by the spec for rounds=5000,
+            and the flag is ignored otherwise. the spec requires the two different
+            encodings be preserved as they are, instead of normalizing them.
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+    name = "sha256_crypt"
+    ident = u("$5$")
+    checksum_size = 43
+    # NOTE: using 25/75 weighting of builtin & os_crypt backends
+    default_rounds = 535000
+
+    #===================================================================
+    # backends
+    #===================================================================
+    _test_hash = ("test", "$5$rounds=1000$test$QmQADEXMG8POI5W"
+                          "Dsaeho0P36yK3Tcrgboabng6bkb/")
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# sha 512 crypt
+#=============================================================================
+class sha512_crypt(_SHA2_Common):
+    """This class implements the SHA512-Crypt password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, one will be autogenerated (this is recommended).
+        If specified, it must be 0-16 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 656000, must be between 1000 and 999999999, inclusive.
+
+        .. note::
+            per the official specification, when the rounds parameter is set to 5000,
+            it may be omitted from the hash string.
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+
+    ..
+        commented out, currently only supported by :meth:`hash`, and not via :meth:`using`:
+
+        :type implicit_rounds: bool
+        :param implicit_rounds:
+            this is an internal option which generally doesn't need to be touched.
+
+            this flag determines whether the hash should omit the rounds parameter
+            when encoding it to a string; this is only permitted by the spec for rounds=5000,
+            and the flag is ignored otherwise. the spec requires the two different
+            encodings be preserved as they are, instead of normalizing them.
+    """
+
+    #===================================================================
+    # class attrs
+    #===================================================================
+    name = "sha512_crypt"
+    ident = u("$6$")
+    checksum_size = 86
+    _cdb_use_512 = True
+    # NOTE: using 25/75 weighting of builtin & os_crypt backends
+    default_rounds = 656000
+
+    #===================================================================
+    # backend
+    #===================================================================
+    _test_hash = ("test", "$6$rounds=1000$test$2M/Lx6Mtobqj"
+                          "Ljobw0Wmo4Q5OFx5nVLJvmgseatA6oMn"
+                          "yWeBdRDx4DU.1H3eGmse6pgsOgDisWBG"
+                          "I5c7TZauS0")
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/sun_md5_crypt.py b/myenv/lib/python3.9/site-packages/passlib/handlers/sun_md5_crypt.py
new file mode 100644
index 0000000..0eeb4e7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/sun_md5_crypt.py
@@ -0,0 +1,363 @@
+"""passlib.handlers.sun_md5_crypt - Sun's Md5 Crypt, used on Solaris
+
+.. warning::
+
+    This implementation may not reproduce
+    the original Solaris behavior in some border cases.
+    See documentation for details.
+"""
+
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from hashlib import md5
+import re
+import logging; log = logging.getLogger(__name__)
+from warnings import warn
+# site
+# pkg
+from passlib.utils import to_unicode
+from passlib.utils.binary import h64
+from passlib.utils.compat import byte_elem_value, irange, u, \
+                                 uascii_to_str, unicode, str_to_bascii
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "sun_md5_crypt",
+]
+
+#=============================================================================
+# backend
+#=============================================================================
+# constant data used by alg - Hamlet act 3 scene 1 + null char
+# exact bytes as in http://www.ibiblio.org/pub/docs/books/gutenberg/etext98/2ws2610.txt
+# from Project Gutenberg.
+
+MAGIC_HAMLET = (
+    b"To be, or not to be,--that is the question:--\n"
+    b"Whether 'tis nobler in the mind to suffer\n"
+    b"The slings and arrows of outrageous fortune\n"
+    b"Or to take arms against a sea of troubles,\n"
+    b"And by opposing end them?--To die,--to sleep,--\n"
+    b"No more; and by a sleep to say we end\n"
+    b"The heartache, and the thousand natural shocks\n"
+    b"That flesh is heir to,--'tis a consummation\n"
+    b"Devoutly to be wish'd. To die,--to sleep;--\n"
+    b"To sleep! perchance to dream:--ay, there's the rub;\n"
+    b"For in that sleep of death what dreams may come,\n"
+    b"When we have shuffled off this mortal coil,\n"
+    b"Must give us pause: there's the respect\n"
+    b"That makes calamity of so long life;\n"
+    b"For who would bear the whips and scorns of time,\n"
+    b"The oppressor's wrong, the proud man's contumely,\n"
+    b"The pangs of despis'd love, the law's delay,\n"
+    b"The insolence of office, and the spurns\n"
+    b"That patient merit of the unworthy takes,\n"
+    b"When he himself might his quietus make\n"
+    b"With a bare bodkin? who would these fardels bear,\n"
+    b"To grunt and sweat under a weary life,\n"
+    b"But that the dread of something after death,--\n"
+    b"The undiscover'd country, from whose bourn\n"
+    b"No traveller returns,--puzzles the will,\n"
+    b"And makes us rather bear those ills we have\n"
+    b"Than fly to others that we know not of?\n"
+    b"Thus conscience does make cowards of us all;\n"
+    b"And thus the native hue of resolution\n"
+    b"Is sicklied o'er with the pale cast of thought;\n"
+    b"And enterprises of great pith and moment,\n"
+    b"With this regard, their currents turn awry,\n"
+    b"And lose the name of action.--Soft you now!\n"
+    b"The fair Ophelia!--Nymph, in thy orisons\n"
+    b"Be all my sins remember'd.\n\x00" #<- apparently null at end of C string is included (test vector won't pass otherwise)
+)
+
+# NOTE: these sequences are pre-calculated iteration ranges used by X & Y loops w/in rounds function below
+xr = irange(7)
+_XY_ROUNDS = [
+    tuple((i,i,i+3) for i in xr), # xrounds 0
+    tuple((i,i+1,i+4) for i in xr), # xrounds 1
+    tuple((i,i+8,(i+11)&15) for i in xr), # yrounds 0
+    tuple((i,(i+9)&15, (i+12)&15) for i in xr), # yrounds 1
+]
+del xr
+
+def raw_sun_md5_crypt(secret, rounds, salt):
+    """given secret & salt, return encoded sun-md5-crypt checksum"""
+    global MAGIC_HAMLET
+    assert isinstance(secret, bytes)
+    assert isinstance(salt, bytes)
+
+    # validate rounds
+    if rounds <= 0:
+        rounds = 0
+    real_rounds = 4096 + rounds
+    # NOTE: spec seems to imply max 'rounds' is 2**32-1
+
+    # generate initial digest to start off round 0.
+    # NOTE: algorithm 'salt' includes full config string w/ trailing "$"
+    result = md5(secret + salt).digest()
+    assert len(result) == 16
+
+    # NOTE: many things in this function have been inlined (to speed up the loop
+    #       as much as possible), to the point that this code barely resembles
+    #       the algorithm as described in the docs. in particular:
+    #
+    #       * all accesses to a given bit have been inlined using the formula
+    #         rbitval(bit) = (rval((bit>>3) & 15) >> (bit & 7)) & 1
+    #
+    #       * the calculation of coinflip value R has been inlined
+    #
+    #       * the conditional division of coinflip value V has been inlined as
+    #         a shift right of 0 or 1.
+    #
+    #       * the i, i+3, etc iterations are precalculated in lists.
+    #
+    #       * the round-based conditional division of x & y is now performed
+    #         by choosing an appropriate precalculated list, so that it only
+    #         calculates the 7 bits which will actually be used.
+    #
+    X_ROUNDS_0, X_ROUNDS_1, Y_ROUNDS_0, Y_ROUNDS_1 = _XY_ROUNDS
+
+    # NOTE: % appears to be *slightly* slower than &, so we prefer & if possible
+
+    round = 0
+    while round < real_rounds:
+        # convert last result byte string to list of byte-ints for easy access
+        rval = [ byte_elem_value(c) for c in result ].__getitem__
+
+        # build up X bit by bit
+        x = 0
+        xrounds = X_ROUNDS_1 if (rval((round>>3) & 15)>>(round & 7)) & 1 else X_ROUNDS_0
+        for i, ia, ib in xrounds:
+            a = rval(ia)
+            b = rval(ib)
+            v = rval((a >> (b % 5)) & 15) >> ((b>>(a&7)) & 1)
+            x |= ((rval((v>>3)&15)>>(v&7))&1) << i
+
+        # build up Y bit by bit
+        y = 0
+        yrounds = Y_ROUNDS_1 if (rval(((round+64)>>3) & 15)>>(round & 7)) & 1 else Y_ROUNDS_0
+        for i, ia, ib in yrounds:
+            a = rval(ia)
+            b = rval(ib)
+            v = rval((a >> (b % 5)) & 15) >> ((b>>(a&7)) & 1)
+            y |= ((rval((v>>3)&15)>>(v&7))&1) << i
+
+        # extract x'th and y'th bit, xoring them together to yeild "coin flip"
+        coin = ((rval(x>>3) >> (x&7)) ^ (rval(y>>3) >> (y&7))) & 1
+
+        # construct hash for this round
+        h = md5(result)
+        if coin:
+            h.update(MAGIC_HAMLET)
+        h.update(unicode(round).encode("ascii"))
+        result = h.digest()
+
+        round += 1
+
+    # encode output
+    return h64.encode_transposed_bytes(result, _chk_offsets)
+
+# NOTE: same offsets as md5_crypt
+_chk_offsets = (
+    12,6,0,
+    13,7,1,
+    14,8,2,
+    15,9,3,
+    5,10,4,
+    11,
+)
+
+#=============================================================================
+# handler
+#=============================================================================
+class sun_md5_crypt(uh.HasRounds, uh.HasSalt, uh.GenericHandler):
+    """This class implements the Sun-MD5-Crypt password hash, and follows the :ref:`password-hash-api`.
+
+    It supports a variable-length salt, and a variable number of rounds.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords:
+
+    :type salt: str
+    :param salt:
+        Optional salt string.
+        If not specified, a salt will be autogenerated (this is recommended).
+        If specified, it must be drawn from the regexp range ``[./0-9A-Za-z]``.
+
+    :type salt_size: int
+    :param salt_size:
+        If no salt is specified, this parameter can be used to specify
+        the size (in characters) of the autogenerated salt.
+        It currently defaults to 8.
+
+    :type rounds: int
+    :param rounds:
+        Optional number of rounds to use.
+        Defaults to 34000, must be between 0 and 4294963199, inclusive.
+
+    :type bare_salt: bool
+    :param bare_salt:
+        Optional flag used to enable an alternate salt digest behavior
+        used by some hash strings in this scheme.
+        This flag can be ignored by most users.
+        Defaults to ``False``.
+        (see :ref:`smc-bare-salt` for details).
+
+    :type relaxed: bool
+    :param relaxed:
+        By default, providing an invalid value for one of the other
+        keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
+        and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
+        will be issued instead. Correctable errors include ``rounds``
+        that are too small or too large, and ``salt`` strings that are too long.
+
+        .. versionadded:: 1.6
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+    name = "sun_md5_crypt"
+    setting_kwds = ("salt", "rounds", "bare_salt", "salt_size")
+    checksum_chars = uh.HASH64_CHARS
+    checksum_size = 22
+
+    # NOTE: docs say max password length is 255.
+    # release 9u2
+
+    # NOTE: not sure if original crypt has a salt size limit,
+    # all instances that have been seen use 8 chars.
+    default_salt_size = 8
+    max_salt_size = None
+    salt_chars = uh.HASH64_CHARS
+
+    default_rounds = 34000 # current passlib default
+    min_rounds = 0
+    max_rounds = 4294963199 ##2**32-1-4096
+        # XXX: ^ not sure what it does if past this bound... does 32 int roll over?
+    rounds_cost = "linear"
+
+    ident_values = (u("$md5$"), u("$md5,"))
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+    bare_salt = False # flag to indicate legacy hashes that lack "$$" suffix
+
+    #===================================================================
+    # constructor
+    #===================================================================
+    def __init__(self, bare_salt=False, **kwds):
+        self.bare_salt = bare_salt
+        super(sun_md5_crypt, self).__init__(**kwds)
+
+    #===================================================================
+    # internal helpers
+    #===================================================================
+    @classmethod
+    def identify(cls, hash):
+        hash = uh.to_unicode_for_identify(hash)
+        return hash.startswith(cls.ident_values)
+
+    @classmethod
+    def from_string(cls, hash):
+        hash = to_unicode(hash, "ascii", "hash")
+
+        #
+        # detect if hash specifies rounds value.
+        # if so, parse and validate it.
+        # by end, set 'rounds' to int value, and 'tail' containing salt+chk
+        #
+        if hash.startswith(u("$md5$")):
+            rounds = 0
+            salt_idx = 5
+        elif hash.startswith(u("$md5,rounds=")):
+            idx = hash.find(u("$"), 12)
+            if idx == -1:
+                raise uh.exc.MalformedHashError(cls, "unexpected end of rounds")
+            rstr = hash[12:idx]
+            try:
+                rounds = int(rstr)
+            except ValueError:
+                raise uh.exc.MalformedHashError(cls, "bad rounds")
+            if rstr != unicode(rounds):
+                raise uh.exc.ZeroPaddedRoundsError(cls)
+            if rounds == 0:
+                # NOTE: not sure if this is forbidden by spec or not;
+                #      but allowing it would complicate things,
+                #      and it should never occur anyways.
+                raise uh.exc.MalformedHashError(cls, "explicit zero rounds")
+            salt_idx = idx+1
+        else:
+            raise uh.exc.InvalidHashError(cls)
+
+        #
+        # salt/checksum separation is kinda weird,
+        # to deal cleanly with some backward-compatible workarounds
+        # implemented by original implementation.
+        #
+        chk_idx = hash.rfind(u("$"), salt_idx)
+        if chk_idx == -1:
+            # ''-config for $-hash
+            salt = hash[salt_idx:]
+            chk = None
+            bare_salt = True
+        elif chk_idx == len(hash)-1:
+            if chk_idx > salt_idx and hash[-2] == u("$"):
+                raise uh.exc.MalformedHashError(cls, "too many '$' separators")
+            # $-config for $$-hash
+            salt = hash[salt_idx:-1]
+            chk = None
+            bare_salt = False
+        elif chk_idx > 0 and hash[chk_idx-1] == u("$"):
+            # $$-hash
+            salt = hash[salt_idx:chk_idx-1]
+            chk = hash[chk_idx+1:]
+            bare_salt = False
+        else:
+            # $-hash
+            salt = hash[salt_idx:chk_idx]
+            chk = hash[chk_idx+1:]
+            bare_salt = True
+
+        return cls(
+            rounds=rounds,
+            salt=salt,
+            checksum=chk,
+            bare_salt=bare_salt,
+        )
+
+    def to_string(self, _withchk=True):
+        ss = u('') if self.bare_salt else u('$')
+        rounds = self.rounds
+        if rounds > 0:
+            hash = u("$md5,rounds=%d$%s%s") % (rounds, self.salt, ss)
+        else:
+            hash = u("$md5$%s%s") % (self.salt, ss)
+        if _withchk:
+            chk = self.checksum
+            hash = u("%s$%s") % (hash, chk)
+        return uascii_to_str(hash)
+
+    #===================================================================
+    # primary interface
+    #===================================================================
+    # TODO: if we're on solaris, check for native crypt() support.
+    #       this will require extra testing, to make sure native crypt
+    #       actually behaves correctly. of particular importance:
+    #       when using ""-config, make sure to append "$x" to string.
+
+    def _calc_checksum(self, secret):
+        # NOTE: no reference for how sun_md5_crypt handles unicode
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        config = str_to_bascii(self.to_string(_withchk=False))
+        return raw_sun_md5_crypt(secret, self.rounds, config).decode("ascii")
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/handlers/windows.py b/myenv/lib/python3.9/site-packages/passlib/handlers/windows.py
new file mode 100644
index 0000000..e17beba
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/handlers/windows.py
@@ -0,0 +1,334 @@
+"""passlib.handlers.nthash - Microsoft Windows -related hashes"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from binascii import hexlify
+import logging; log = logging.getLogger(__name__)
+from warnings import warn
+# site
+# pkg
+from passlib.utils import to_unicode, right_pad_string
+from passlib.utils.compat import unicode
+from passlib.crypto.digest import lookup_hash
+md4 = lookup_hash("md4").const
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    "lmhash",
+    "nthash",
+    "bsd_nthash",
+    "msdcc",
+    "msdcc2",
+]
+
+#=============================================================================
+# lanman hash
+#=============================================================================
+class lmhash(uh.TruncateMixin, uh.HasEncodingContext, uh.StaticHandler):
+    """This class implements the Lan Manager Password hash, and follows the :ref:`password-hash-api`.
+
+    It has no salt and a single fixed round.
+
+    The :meth:`~passlib.ifc.PasswordHash.using` method accepts a single
+    optional keyword:
+
+    :param bool truncate_error:
+        By default, this will silently truncate passwords larger than 14 bytes.
+        Setting ``truncate_error=True`` will cause :meth:`~passlib.ifc.PasswordHash.hash`
+        to raise a :exc:`~passlib.exc.PasswordTruncateError` instead.
+
+        .. versionadded:: 1.7
+
+    The :meth:`~passlib.ifc.PasswordHash.hash` and :meth:`~passlib.ifc.PasswordHash.verify` methods accept a single
+    optional keyword:
+
+    :type encoding: str
+    :param encoding:
+
+        This specifies what character encoding LMHASH should use when
+        calculating digest. It defaults to ``cp437``, the most
+        common encoding encountered.
+
+    Note that while this class outputs digests in lower-case hexadecimal,
+    it will accept upper-case as well.
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #--------------------
+    # PasswordHash
+    #--------------------
+    name = "lmhash"
+    setting_kwds = ("truncate_error",)
+
+    #--------------------
+    # GenericHandler
+    #--------------------
+    checksum_chars = uh.HEX_CHARS
+    checksum_size = 32
+
+    #--------------------
+    # TruncateMixin
+    #--------------------
+    truncate_size = 14
+
+    #--------------------
+    # custom
+    #--------------------
+    default_encoding = "cp437"
+
+    #===================================================================
+    # methods
+    #===================================================================
+    @classmethod
+    def _norm_hash(cls, hash):
+        return hash.lower()
+
+    def _calc_checksum(self, secret):
+        # check for truncation (during .hash() calls only)
+        if self.use_defaults:
+            self._check_truncate_policy(secret)
+
+        return hexlify(self.raw(secret, self.encoding)).decode("ascii")
+
+    # magic constant used by LMHASH
+    _magic = b"KGS!@#$%"
+
+    @classmethod
+    def raw(cls, secret, encoding=None):
+        """encode password using LANMAN hash algorithm.
+
+        :type secret: unicode or utf-8 encoded bytes
+        :arg secret: secret to hash
+        :type encoding: str
+        :arg encoding:
+            optional encoding to use for unicode inputs.
+            this defaults to ``cp437``, which is the
+            common case for most situations.
+
+        :returns: returns string of raw bytes
+        """
+        if not encoding:
+            encoding = cls.default_encoding
+        # some nice empircal data re: different encodings is at...
+        # http://www.openwall.com/lists/john-dev/2011/08/01/2
+        # http://www.freerainbowtables.com/phpBB3/viewtopic.php?t=387&p=12163
+        from passlib.crypto.des import des_encrypt_block
+        MAGIC = cls._magic
+        if isinstance(secret, unicode):
+            # perform uppercasing while we're still unicode,
+            # to give a better shot at getting non-ascii chars right.
+            # (though some codepages do NOT upper-case the same as unicode).
+            secret = secret.upper().encode(encoding)
+        elif isinstance(secret, bytes):
+            # FIXME: just trusting ascii upper will work?
+            # and if not, how to do codepage specific case conversion?
+            # we could decode first using <encoding>,
+            # but *that* might not always be right.
+            secret = secret.upper()
+        else:
+            raise TypeError("secret must be unicode or bytes")
+        secret = right_pad_string(secret, 14)
+        return des_encrypt_block(secret[0:7], MAGIC) + \
+               des_encrypt_block(secret[7:14], MAGIC)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# ntlm hash
+#=============================================================================
+class nthash(uh.StaticHandler):
+    """This class implements the NT Password hash, and follows the :ref:`password-hash-api`.
+
+    It has no salt and a single fixed round.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash` and :meth:`~passlib.ifc.PasswordHash.genconfig` methods accept no optional keywords.
+
+    Note that while this class outputs lower-case hexadecimal digests,
+    it will accept upper-case digests as well.
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+    name = "nthash"
+    checksum_chars = uh.HEX_CHARS
+    checksum_size = 32
+
+    #===================================================================
+    # methods
+    #===================================================================
+    @classmethod
+    def _norm_hash(cls, hash):
+        return hash.lower()
+
+    def _calc_checksum(self, secret):
+        return hexlify(self.raw(secret)).decode("ascii")
+
+    @classmethod
+    def raw(cls, secret):
+        """encode password using MD4-based NTHASH algorithm
+
+        :arg secret: secret as unicode or utf-8 encoded bytes
+
+        :returns: returns string of raw bytes
+        """
+        secret = to_unicode(secret, "utf-8", param="secret")
+        # XXX: found refs that say only first 128 chars are used.
+        return md4(secret.encode("utf-16-le")).digest()
+
+    @classmethod
+    def raw_nthash(cls, secret, hex=False):
+        warn("nthash.raw_nthash() is deprecated, and will be removed "
+             "in Passlib 1.8, please use nthash.raw() instead",
+             DeprecationWarning)
+        ret = nthash.raw(secret)
+        return hexlify(ret).decode("ascii") if hex else ret
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+bsd_nthash = uh.PrefixWrapper("bsd_nthash", nthash, prefix="$3$$", ident="$3$$",
+    doc="""The class support FreeBSD's representation of NTHASH
+    (which is compatible with the :ref:`modular-crypt-format`),
+    and follows the :ref:`password-hash-api`.
+
+    It has no salt and a single fixed round.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash` and :meth:`~passlib.ifc.PasswordHash.genconfig` methods accept no optional keywords.
+    """)
+
+##class ntlm_pair(object):
+##    "combined lmhash & nthash"
+##    name = "ntlm_pair"
+##    setting_kwds = ()
+##    _hash_regex = re.compile(u"^(?P<lm>[0-9a-f]{32}):(?P<nt>[0-9][a-f]{32})$",
+##                             re.I)
+##
+##    @classmethod
+##    def identify(cls, hash):
+##        hash = to_unicode(hash, "latin-1", "hash")
+##        return len(hash) == 65 and cls._hash_regex.match(hash) is not None
+##
+##    @classmethod
+##    def hash(cls, secret, config=None):
+##        if config is not None and not cls.identify(config):
+##            raise uh.exc.InvalidHashError(cls)
+##        return lmhash.hash(secret) + ":" + nthash.hash(secret)
+##
+##    @classmethod
+##    def verify(cls, secret, hash):
+##        hash = to_unicode(hash, "ascii", "hash")
+##        m = cls._hash_regex.match(hash)
+##        if not m:
+##            raise uh.exc.InvalidHashError(cls)
+##        lm, nt = m.group("lm", "nt")
+##        # NOTE: verify against both in case encoding issue
+##        # causes one not to match.
+##        return lmhash.verify(secret, lm) or nthash.verify(secret, nt)
+
+#=============================================================================
+# msdcc v1
+#=============================================================================
+class msdcc(uh.HasUserContext, uh.StaticHandler):
+    """This class implements Microsoft's Domain Cached Credentials password hash,
+    and follows the :ref:`password-hash-api`.
+
+    It has a fixed number of rounds, and uses the associated
+    username as the salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash`, :meth:`~passlib.ifc.PasswordHash.genhash`, and :meth:`~passlib.ifc.PasswordHash.verify` methods
+    have the following optional keywords:
+
+    :type user: str
+    :param user:
+        String containing name of user account this password is associated with.
+        This is required to properly calculate the hash.
+
+        This keyword is case-insensitive, and should contain just the username
+        (e.g. ``Administrator``, not ``SOMEDOMAIN\\Administrator``).
+
+    Note that while this class outputs lower-case hexadecimal digests,
+    it will accept upper-case digests as well.
+    """
+    name = "msdcc"
+    checksum_chars = uh.HEX_CHARS
+    checksum_size = 32
+
+    @classmethod
+    def _norm_hash(cls, hash):
+        return hash.lower()
+
+    def _calc_checksum(self, secret):
+        return hexlify(self.raw(secret, self.user)).decode("ascii")
+
+    @classmethod
+    def raw(cls, secret, user):
+        """encode password using mscash v1 algorithm
+
+        :arg secret: secret as unicode or utf-8 encoded bytes
+        :arg user: username to use as salt
+
+        :returns: returns string of raw bytes
+        """
+        secret = to_unicode(secret, "utf-8", param="secret").encode("utf-16-le")
+        user = to_unicode(user, "utf-8", param="user").lower().encode("utf-16-le")
+        return md4(md4(secret).digest() + user).digest()
+
+#=============================================================================
+# msdcc2 aka mscash2
+#=============================================================================
+class msdcc2(uh.HasUserContext, uh.StaticHandler):
+    """This class implements version 2 of Microsoft's Domain Cached Credentials
+    password hash, and follows the :ref:`password-hash-api`.
+
+    It has a fixed number of rounds, and uses the associated
+    username as the salt.
+
+    The :meth:`~passlib.ifc.PasswordHash.hash`, :meth:`~passlib.ifc.PasswordHash.genhash`, and :meth:`~passlib.ifc.PasswordHash.verify` methods
+    have the following extra keyword:
+
+    :type user: str
+    :param user:
+        String containing name of user account this password is associated with.
+        This is required to properly calculate the hash.
+
+        This keyword is case-insensitive, and should contain just the username
+        (e.g. ``Administrator``, not ``SOMEDOMAIN\\Administrator``).
+    """
+    name = "msdcc2"
+    checksum_chars = uh.HEX_CHARS
+    checksum_size = 32
+
+    @classmethod
+    def _norm_hash(cls, hash):
+        return hash.lower()
+
+    def _calc_checksum(self, secret):
+        return hexlify(self.raw(secret, self.user)).decode("ascii")
+
+    @classmethod
+    def raw(cls, secret, user):
+        """encode password using msdcc v2 algorithm
+
+        :type secret: unicode or utf-8 bytes
+        :arg secret: secret
+
+        :type user: str
+        :arg user: username to use as salt
+
+        :returns: returns string of raw bytes
+        """
+        from passlib.crypto.digest import pbkdf2_hmac
+        secret = to_unicode(secret, "utf-8", param="secret").encode("utf-16-le")
+        user = to_unicode(user, "utf-8", param="user").lower().encode("utf-16-le")
+        tmp = md4(md4(secret).digest() + user).digest()
+        return pbkdf2_hmac("sha1", tmp, user, 10240, 16)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/hash.py b/myenv/lib/python3.9/site-packages/passlib/hash.py
new file mode 100644
index 0000000..2cc0628
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/hash.py
@@ -0,0 +1,68 @@
+"""
+passlib.hash - proxy object mapping hash scheme names -> handlers
+
+==================
+***** NOTICE *****
+==================
+
+This module does not actually contain any hashes. This file
+is a stub that replaces itself with a proxy object.
+
+This proxy object (passlib.registry._PasslibRegistryProxy)
+handles lazy-loading hashes as they are requested.
+
+The actual implementation of the various hashes is store elsewhere,
+mainly in the submodules of the ``passlib.handlers`` subpackage.
+"""
+
+#=============================================================================
+# import proxy object and replace this module
+#=============================================================================
+
+# XXX: if any platform has problem w/ lazy modules, could support 'non-lazy'
+#      version which just imports all schemes known to list_crypt_handlers()
+
+from passlib.registry import _proxy
+import sys
+sys.modules[__name__] = _proxy
+
+#=============================================================================
+# HACK: the following bit of code is unreachable, but it's presence seems to
+#       help make autocomplete work for certain IDEs such as PyCharm.
+#       this list is automatically regenerated using $SOURCE/admin/regen.py
+#=============================================================================
+
+#----------------------------------------------------
+# begin autocomplete hack (autogenerated 2016-11-10)
+#----------------------------------------------------
+if False:
+    from passlib.handlers.argon2 import argon2
+    from passlib.handlers.bcrypt import bcrypt, bcrypt_sha256
+    from passlib.handlers.cisco import cisco_asa, cisco_pix, cisco_type7
+    from passlib.handlers.des_crypt import bigcrypt, bsdi_crypt, crypt16, des_crypt
+    from passlib.handlers.digests import hex_md4, hex_md5, hex_sha1, hex_sha256, hex_sha512, htdigest
+    from passlib.handlers.django import django_bcrypt, django_bcrypt_sha256, django_des_crypt, django_disabled, django_pbkdf2_sha1, django_pbkdf2_sha256, django_salted_md5, django_salted_sha1
+    from passlib.handlers.fshp import fshp
+    from passlib.handlers.ldap_digests import ldap_bcrypt, ldap_bsdi_crypt, ldap_des_crypt, ldap_md5, ldap_md5_crypt, ldap_plaintext, ldap_salted_md5, ldap_salted_sha1, ldap_salted_sha256, ldap_salted_sha512, ldap_sha1, ldap_sha1_crypt, ldap_sha256_crypt, ldap_sha512_crypt
+    from passlib.handlers.md5_crypt import apr_md5_crypt, md5_crypt
+    from passlib.handlers.misc import plaintext, unix_disabled, unix_fallback
+    from passlib.handlers.mssql import mssql2000, mssql2005
+    from passlib.handlers.mysql import mysql323, mysql41
+    from passlib.handlers.oracle import oracle10, oracle11
+    from passlib.handlers.pbkdf2 import atlassian_pbkdf2_sha1, cta_pbkdf2_sha1, dlitz_pbkdf2_sha1, grub_pbkdf2_sha512, ldap_pbkdf2_sha1, ldap_pbkdf2_sha256, ldap_pbkdf2_sha512, pbkdf2_sha1, pbkdf2_sha256, pbkdf2_sha512
+    from passlib.handlers.phpass import phpass
+    from passlib.handlers.postgres import postgres_md5
+    from passlib.handlers.roundup import ldap_hex_md5, ldap_hex_sha1, roundup_plaintext
+    from passlib.handlers.scram import scram
+    from passlib.handlers.scrypt import scrypt
+    from passlib.handlers.sha1_crypt import sha1_crypt
+    from passlib.handlers.sha2_crypt import sha256_crypt, sha512_crypt
+    from passlib.handlers.sun_md5_crypt import sun_md5_crypt
+    from passlib.handlers.windows import bsd_nthash, lmhash, msdcc, msdcc2, nthash
+#----------------------------------------------------
+# end autocomplete hack
+#----------------------------------------------------
+
+#=============================================================================
+# eoc
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/hosts.py b/myenv/lib/python3.9/site-packages/passlib/hosts.py
new file mode 100644
index 0000000..1f137a2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/hosts.py
@@ -0,0 +1,106 @@
+"""passlib.hosts"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from warnings import warn
+# pkg
+from passlib.context import LazyCryptContext
+from passlib.exc import PasslibRuntimeWarning
+from passlib import registry
+from passlib.utils import has_crypt, unix_crypt_schemes
+# local
+__all__ = [
+    "linux_context", "linux2_context",
+    "openbsd_context",
+    "netbsd_context",
+    "freebsd_context",
+    "host_context",
+]
+
+#=============================================================================
+# linux support
+#=============================================================================
+
+# known platform names - linux2
+
+linux_context = linux2_context = LazyCryptContext(
+    schemes = [ "sha512_crypt", "sha256_crypt", "md5_crypt",
+               "des_crypt", "unix_disabled" ],
+    deprecated = [ "des_crypt" ],
+    )
+
+#=============================================================================
+# bsd support
+#=============================================================================
+
+# known platform names -
+#   freebsd2
+#   freebsd3
+#   freebsd4
+#   freebsd5
+#   freebsd6
+#   freebsd7
+#
+#   netbsd1
+
+# referencing source via -http://fxr.googlebit.com
+# freebsd 6,7,8 - des, md5, bcrypt, bsd_nthash
+# netbsd - des, ext, md5, bcrypt, sha1
+# openbsd - des, ext, md5, bcrypt
+
+freebsd_context = LazyCryptContext(["bcrypt", "md5_crypt", "bsd_nthash",
+                                    "des_crypt", "unix_disabled"])
+
+openbsd_context = LazyCryptContext(["bcrypt", "md5_crypt", "bsdi_crypt",
+                                    "des_crypt", "unix_disabled"])
+
+netbsd_context = LazyCryptContext(["bcrypt", "sha1_crypt", "md5_crypt",
+                                   "bsdi_crypt", "des_crypt", "unix_disabled"])
+
+# XXX: include darwin in this list? it's got a BSD crypt variant,
+# but that's not what it uses for user passwords.
+
+#=============================================================================
+# current host
+#=============================================================================
+if registry.os_crypt_present:
+    # NOTE: this is basically mimicing the output of os crypt(),
+    # except that it uses passlib's (usually stronger) defaults settings,
+    # and can be inspected and used much more flexibly.
+
+    def _iter_os_crypt_schemes():
+        """helper which iterates over supported os_crypt schemes"""
+        out = registry.get_supported_os_crypt_schemes()
+        if out:
+            # only offer disabled handler if there's another scheme in front,
+            # as this can't actually hash any passwords
+            out += ("unix_disabled",)
+        return out
+
+    host_context = LazyCryptContext(_iter_os_crypt_schemes())
+
+#=============================================================================
+# other platforms
+#=============================================================================
+
+# known platform strings -
+# aix3
+# aix4
+# atheos
+# beos5
+# darwin
+# generic
+# hp-ux11
+# irix5
+# irix6
+# mac
+# next3
+# os2emx
+# riscos
+# sunos5
+# unixware7
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/ifc.py b/myenv/lib/python3.9/site-packages/passlib/ifc.py
new file mode 100644
index 0000000..559d256
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/ifc.py
@@ -0,0 +1,353 @@
+"""passlib.ifc - abstract interfaces used by Passlib"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import logging; log = logging.getLogger(__name__)
+import sys
+# site
+# pkg
+from passlib.utils.decor import deprecated_method
+# local
+__all__ = [
+    "PasswordHash",
+]
+
+#=============================================================================
+# 2/3 compatibility helpers
+#=============================================================================
+def recreate_with_metaclass(meta):
+    """class decorator that re-creates class using metaclass"""
+    def builder(cls):
+        if meta is type(cls):
+            return cls
+        return meta(cls.__name__, cls.__bases__, cls.__dict__.copy())
+    return builder
+
+#=============================================================================
+# PasswordHash interface
+#=============================================================================
+from abc import ABCMeta, abstractmethod, abstractproperty
+
+# TODO: make this actually use abstractproperty(),
+#       now that we dropped py25, 'abc' is always available.
+
+# XXX: rename to PasswordHasher?
+
+@recreate_with_metaclass(ABCMeta)
+class PasswordHash(object):
+    """This class describes an abstract interface which all password hashes
+    in Passlib adhere to. Under Python 2.6 and up, this is an actual
+    Abstract Base Class built using the :mod:`!abc` module.
+
+    See the Passlib docs for full documentation.
+    """
+    #===================================================================
+    # class attributes
+    #===================================================================
+
+    #---------------------------------------------------------------
+    # general information
+    #---------------------------------------------------------------
+    ##name
+    ##setting_kwds
+    ##context_kwds
+
+    #: flag which indicates this hasher matches a "disabled" hash
+    #: (e.g. unix_disabled, or django_disabled); and doesn't actually
+    #: depend on the provided password.
+    is_disabled = False
+
+    #: Should be None, or a positive integer indicating hash
+    #: doesn't support secrets larger than this value.
+    #: Whether hash throws error or silently truncates secret
+    #: depends on .truncate_error and .truncate_verify_reject flags below.
+    #: NOTE: calls may treat as boolean, since value will never be 0.
+    #: .. versionadded:: 1.7
+    #: .. TODO: passlib 1.8: deprecate/rename this attr to "max_secret_size"?
+    truncate_size = None
+
+    # NOTE: these next two default to the optimistic "ideal",
+    #       most hashes in passlib have to default to False
+    #       for backward compat and/or expected behavior with existing hashes.
+
+    #: If True, .hash() should throw a :exc:`~passlib.exc.PasswordSizeError` for
+    #: any secrets larger than .truncate_size.  Many hashers default to False
+    #: for historical / compatibility purposes, indicating they will silently
+    #: truncate instead.  All such hashers SHOULD support changing
+    #: the policy via ``.using(truncate_error=True)``.
+    #: .. versionadded:: 1.7
+    #: .. TODO: passlib 1.8: deprecate/rename this attr to "truncate_hash_error"?
+    truncate_error = True
+
+    #: If True, .verify() should reject secrets larger than max_password_size.
+    #: Many hashers default to False for historical / compatibility purposes,
+    #: indicating they will match on the truncated portion instead.
+    #: .. versionadded:: 1.7.1
+    truncate_verify_reject = True
+
+    #---------------------------------------------------------------
+    # salt information -- if 'salt' in setting_kwds
+    #---------------------------------------------------------------
+    ##min_salt_size
+    ##max_salt_size
+    ##default_salt_size
+    ##salt_chars
+    ##default_salt_chars
+
+    #---------------------------------------------------------------
+    # rounds information -- if 'rounds' in setting_kwds
+    #---------------------------------------------------------------
+    ##min_rounds
+    ##max_rounds
+    ##default_rounds
+    ##rounds_cost
+
+    #---------------------------------------------------------------
+    # encoding info -- if 'encoding' in context_kwds
+    #---------------------------------------------------------------
+    ##default_encoding
+
+    #===================================================================
+    # primary methods
+    #===================================================================
+    @classmethod
+    @abstractmethod
+    def hash(cls, secret,  # *
+             **setting_and_context_kwds):  # pragma: no cover -- abstract method
+        r"""
+        Hash secret, returning result.
+        Should handle generating salt, etc, and should return string
+        containing identifier, salt & other configuration, as well as digest.
+
+        :param \\*\\*settings_kwds:
+
+            Pass in settings to customize configuration of resulting hash.
+
+            .. deprecated:: 1.7
+
+                Starting with Passlib 1.7, callers should no longer pass settings keywords
+                (e.g. ``rounds`` or ``salt`` directly to :meth:`!hash`); should use
+                ``.using(**settings).hash(secret)`` construction instead.
+
+                Support will be removed in Passlib 2.0.
+
+        :param \\*\\*context_kwds:
+
+            Specific algorithms may require context-specific information (such as the user login).
+        """
+        # FIXME:  need stub for classes that define .encrypt() instead ...
+        #         this should call .encrypt(), and check for recursion back to here.
+        raise NotImplementedError("must be implemented by subclass")
+
+    @deprecated_method(deprecated="1.7", removed="2.0", replacement=".hash()")
+    @classmethod
+    def encrypt(cls, *args, **kwds):
+        """
+        Legacy alias for :meth:`hash`.
+
+        .. deprecated:: 1.7
+            This method was renamed to :meth:`!hash` in version 1.7.
+            This alias will be removed in version 2.0, and should only
+            be used for compatibility with Passlib 1.3 - 1.6.
+        """
+        return cls.hash(*args, **kwds)
+
+    # XXX: could provide default implementation which hands value to
+    #      hash(), and then does constant-time comparision on the result
+    #      (after making both are same string type)
+    @classmethod
+    @abstractmethod
+    def verify(cls, secret, hash, **context_kwds): # pragma: no cover -- abstract method
+        """verify secret against hash, returns True/False"""
+        raise NotImplementedError("must be implemented by subclass")
+
+    #===================================================================
+    # configuration
+    #===================================================================
+    @classmethod
+    @abstractmethod
+    def using(cls, relaxed=False, **kwds):
+        """
+        Return another hasher object (typically a subclass of the current one),
+        which integrates the configuration options specified by ``kwds``.
+        This should *always* return a new object, even if no configuration options are changed.
+
+        .. todo::
+
+            document which options are accepted.
+
+        :returns:
+            typically returns a subclass for most hasher implementations.
+
+        .. todo::
+
+            add this method to main documentation.
+        """
+        raise NotImplementedError("must be implemented by subclass")
+
+    #===================================================================
+    # migration
+    #===================================================================
+    @classmethod
+    def needs_update(cls, hash, secret=None):
+        """
+        check if hash's configuration is outside desired bounds,
+        or contains some other internal option which requires
+        updating the password hash.
+
+        :param hash:
+            hash string to examine
+
+        :param secret:
+            optional secret known to have verified against the provided hash.
+            (this is used by some hashes to detect legacy algorithm mistakes).
+
+        :return:
+            whether secret needs re-hashing.
+
+        .. versionadded:: 1.7
+        """
+        # by default, always report that we don't need update
+        return False
+
+    #===================================================================
+    # additional methods
+    #===================================================================
+    @classmethod
+    @abstractmethod
+    def identify(cls, hash): # pragma: no cover -- abstract method
+        """check if hash belongs to this scheme, returns True/False"""
+        raise NotImplementedError("must be implemented by subclass")
+
+    @deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genconfig(cls, **setting_kwds): # pragma: no cover -- abstract method
+        """
+        compile settings into a configuration string for genhash()
+
+        .. deprecated:: 1.7
+
+            As of 1.7, this method is deprecated, and slated for complete removal in Passlib 2.0.
+
+            For all known real-world uses, hashing a constant string
+            should provide equivalent functionality.
+
+            This deprecation may be reversed if a use-case presents itself in the mean time.
+        """
+        # NOTE: this fallback runs full hash alg, w/ whatever cost param is passed along.
+        #       implementations (esp ones w/ variable cost) will want to subclass this
+        #       with a constant-time implementation that just renders a config string.
+        if cls.context_kwds:
+            raise NotImplementedError("must be implemented by subclass")
+        return cls.using(**setting_kwds).hash("")
+
+    @deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genhash(cls, secret, config, **context):
+        """
+        generated hash for secret, using settings from config/hash string
+
+        .. deprecated:: 1.7
+
+            As of 1.7, this method is deprecated, and slated for complete removal in Passlib 2.0.
+
+            This deprecation may be reversed if a use-case presents itself in the mean time.
+        """
+        # XXX: if hashes reliably offered a .parse() method, could make a fallback for this.
+        raise NotImplementedError("must be implemented by subclass")
+
+    #===================================================================
+    # undocumented methods / attributes
+    #===================================================================
+    # the following entry points are used internally by passlib,
+    # and aren't documented as part of the exposed interface.
+    # they are subject to change between releases,
+    # but are documented here so there's a list of them *somewhere*.
+
+    #---------------------------------------------------------------
+    # extra metdata
+    #---------------------------------------------------------------
+
+    #: this attribute shouldn't be used by hashers themselves,
+    #: it's reserved for the CryptContext to track which hashers are deprecated.
+    #: Note the context will only set this on objects it owns (and generated by .using()),
+    #: and WONT set it on global objects.
+    #: [added in 1.7]
+    #: TODO: document this, or at least the use of testing for
+    #:       'CryptContext().handler().deprecated'
+    deprecated = False
+
+    #: optionally present if hasher corresponds to format built into Django.
+    #: this attribute (if not None) should be the Django 'algorithm' name.
+    #: also indicates to passlib.ext.django that (when installed in django),
+    #: django's native hasher should be used in preference to this one.
+    ## django_name
+
+    #---------------------------------------------------------------
+    # checksum information - defined for many hashes
+    #---------------------------------------------------------------
+    ## checksum_chars
+    ## checksum_size
+
+    #---------------------------------------------------------------
+    # experimental methods
+    #---------------------------------------------------------------
+
+    ##@classmethod
+    ##def normhash(cls, hash):
+    ##    """helper to clean up non-canonic instances of hash.
+    ##    currently only provided by bcrypt() to fix an historical passlib issue.
+    ##    """
+
+    # experimental helper to parse hash into components.
+    ##@classmethod
+    ##def parsehash(cls, hash, checksum=True, sanitize=False):
+    ##    """helper to parse hash into components, returns dict"""
+
+    # experiment helper to estimate bitsize of different hashes,
+    # implement for GenericHandler, but may be currently be off for some hashes.
+    # want to expand this into a way to programmatically compare
+    # "strengths" of different hashes and hash algorithms.
+    # still needs to have some factor for estimate relative cost per round,
+    # ala in the style of the scrypt whitepaper.
+    ##@classmethod
+    ##def bitsize(cls, **kwds):
+    ##    """returns dict mapping component -> bits contributed.
+    ##    components currently include checksum, salt, rounds.
+    ##    """
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class DisabledHash(PasswordHash):
+    """
+    extended disabled-hash methods; only need be present if .disabled = True
+    """
+
+    is_disabled = True
+
+    @classmethod
+    def disable(cls, hash=None):
+        """
+        return string representing a 'disabled' hash;
+        optionally including previously enabled hash
+        (this is up to the individual scheme).
+        """
+        # default behavior: ignore original hash, return standalone marker
+        return cls.hash("")
+
+    @classmethod
+    def enable(cls, hash):
+        """
+        given a disabled-hash string,
+        extract previously-enabled hash if one is present,
+        otherwise raises ValueError
+        """
+        # default behavior: no way to restore original hash
+        raise ValueError("cannot restore original hash")
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/pwd.py b/myenv/lib/python3.9/site-packages/passlib/pwd.py
new file mode 100644
index 0000000..27ed228
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/pwd.py
@@ -0,0 +1,809 @@
+"""passlib.pwd -- password generation helpers"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import absolute_import, division, print_function, unicode_literals
+# core
+import codecs
+from collections import defaultdict
+try:
+    from collections.abc import MutableMapping
+except ImportError:
+    # py2 compat
+    from collections import MutableMapping
+from math import ceil, log as logf
+import logging; log = logging.getLogger(__name__)
+import pkg_resources
+import os
+# site
+# pkg
+from passlib import exc
+from passlib.utils.compat import PY2, irange, itervalues, int_types
+from passlib.utils import rng, getrandstr, to_unicode
+from passlib.utils.decor import memoized_property
+# local
+__all__ = [
+    "genword", "default_charsets",
+    "genphrase", "default_wordsets",
+]
+
+#=============================================================================
+# constants
+#=============================================================================
+
+# XXX: rename / publically document this map?
+entropy_aliases = dict(
+    # barest protection from throttled online attack
+    unsafe=12,
+
+    # some protection from unthrottled online attack
+    weak=24,
+
+    # some protection from offline attacks
+    fair=36,
+
+    # reasonable protection from offline attacks
+    strong=48,
+
+    # very good protection from offline attacks
+    secure=60,
+)
+
+#=============================================================================
+# internal helpers
+#=============================================================================
+
+def _superclasses(obj, cls):
+    """return remaining classes in object's MRO after cls"""
+    mro = type(obj).__mro__
+    return mro[mro.index(cls)+1:]
+
+
+def _self_info_rate(source):
+    """
+    returns 'rate of self-information' --
+    i.e. average (per-symbol) entropy of the sequence **source**,
+    where probability of a given symbol occurring is calculated based on
+    the number of occurrences within the sequence itself.
+
+    if all elements of the source are unique, this should equal ``log(len(source), 2)``.
+
+    :arg source:
+        iterable containing 0+ symbols
+        (e.g. list of strings or ints, string of characters, etc).
+
+    :returns:
+        float bits of entropy
+    """
+    try:
+        size = len(source)
+    except TypeError:
+        # if len() doesn't work, calculate size by summing counts later
+        size = None
+    counts = defaultdict(int)
+    for char in source:
+        counts[char] += 1
+    if size is None:
+        values = counts.values()
+        size = sum(values)
+    else:
+        values = itervalues(counts)
+    if not size:
+        return 0
+    # NOTE: the following performs ``- sum(value / size * logf(value / size, 2) for value in values)``,
+    #       it just does so with as much pulled out of the sum() loop as possible...
+    return logf(size, 2) - sum(value * logf(value, 2) for value in values) / size
+
+
+# def _total_self_info(source):
+#     """
+#     return total self-entropy of a sequence
+#     (the average entropy per symbol * size of sequence)
+#     """
+#     return _self_info_rate(source) * len(source)
+
+
+def _open_asset_path(path, encoding=None):
+    """
+    :param asset_path:
+        string containing absolute path to file,
+        or package-relative path using format
+        ``"python.module:relative/file/path"``.
+
+    :returns:
+        filehandle opened in 'rb' mode
+        (unless encoding explicitly specified)
+    """
+    if encoding:
+        return codecs.getreader(encoding)(_open_asset_path(path))
+    if os.path.isabs(path):
+        return open(path, "rb")
+    package, sep, subpath = path.partition(":")
+    if not sep:
+        raise ValueError("asset path must be absolute file path "
+                         "or use 'pkg.name:sub/path' format: %r" % (path,))
+    return pkg_resources.resource_stream(package, subpath)
+
+
+#: type aliases
+_sequence_types = (list, tuple)
+_set_types = (set, frozenset)
+
+#: set of elements that ensure_unique() has validated already.
+_ensure_unique_cache = set()
+
+
+def _ensure_unique(source, param="source"):
+    """
+    helper for generators --
+    Throws ValueError if source elements aren't unique.
+    Error message will display (abbreviated) repr of the duplicates in a string/list
+    """
+    # check cache to speed things up for frozensets / tuples / strings
+    cache = _ensure_unique_cache
+    hashable = True
+    try:
+        if source in cache:
+            return True
+    except TypeError:
+        hashable = False
+
+    # check if it has dup elements
+    if isinstance(source, _set_types) or len(set(source)) == len(source):
+        if hashable:
+            try:
+                cache.add(source)
+            except TypeError:
+                # XXX: under pypy, "list() in set()" above doesn't throw TypeError,
+                #      but trying to add unhashable it to a set *does*.
+                pass
+        return True
+
+    # build list of duplicate values
+    seen = set()
+    dups = set()
+    for elem in source:
+        (dups if elem in seen else seen).add(elem)
+    dups = sorted(dups)
+    trunc = 8
+    if len(dups) > trunc:
+        trunc = 5
+    dup_repr = ", ".join(repr(str(word)) for word in dups[:trunc])
+    if len(dups) > trunc:
+        dup_repr += ", ... plus %d others" % (len(dups) - trunc)
+
+    # throw error
+    raise ValueError("`%s` cannot contain duplicate elements: %s" %
+                     (param, dup_repr))
+
+#=============================================================================
+# base generator class
+#=============================================================================
+class SequenceGenerator(object):
+    """
+    Base class used by word & phrase generators.
+
+    These objects take a series of options, corresponding
+    to those of the :func:`generate` function.
+    They act as callables which can be used to generate a password
+    or a list of 1+ passwords. They also expose some read-only
+    informational attributes.
+
+    Parameters
+    ----------
+    :param entropy:
+        Optionally specify the amount of entropy the resulting passwords
+        should contain (as measured with respect to the generator itself).
+        This will be used to auto-calculate the required password size.
+
+    :param length:
+        Optionally specify the length of password to generate,
+        measured as count of whatever symbols the subclass uses (characters or words).
+        Note if ``entropy`` requires a larger minimum length,
+        that will be used instead.
+
+    :param rng:
+        Optionally provide a custom RNG source to use.
+        Should be an instance of :class:`random.Random`,
+        defaults to :class:`random.SystemRandom`.
+
+    Attributes
+    ----------
+    .. autoattribute:: length
+    .. autoattribute:: symbol_count
+    .. autoattribute:: entropy_per_symbol
+    .. autoattribute:: entropy
+
+    Subclassing
+    -----------
+    Subclasses must implement the ``.__next__()`` method,
+    and set ``.symbol_count`` before calling base ``__init__`` method.
+    """
+    #=============================================================================
+    # instance attrs
+    #=============================================================================
+
+    #: requested size of final password
+    length = None
+
+    #: requested entropy of final password
+    requested_entropy = "strong"
+
+    #: random number source to use
+    rng = rng
+
+    #: number of potential symbols (must be filled in by subclass)
+    symbol_count = None
+
+    #=============================================================================
+    # init
+    #=============================================================================
+    def __init__(self, entropy=None, length=None, rng=None, **kwds):
+
+        # make sure subclass set things up correctly
+        assert self.symbol_count is not None, "subclass must set .symbol_count"
+
+        # init length & requested entropy
+        if entropy is not None or length is None:
+            if entropy is None:
+                entropy = self.requested_entropy
+            entropy = entropy_aliases.get(entropy, entropy)
+            if entropy <= 0:
+                raise ValueError("`entropy` must be positive number")
+            min_length = int(ceil(entropy / self.entropy_per_symbol))
+            if length is None or length < min_length:
+                length = min_length
+
+        self.requested_entropy = entropy
+
+        if length < 1:
+            raise ValueError("`length` must be positive integer")
+        self.length = length
+
+        # init other common options
+        if rng is not None:
+            self.rng = rng
+
+        # hand off to parent
+        if kwds and _superclasses(self, SequenceGenerator) == (object,):
+            raise TypeError("Unexpected keyword(s): %s" % ", ".join(kwds.keys()))
+        super(SequenceGenerator, self).__init__(**kwds)
+
+    #=============================================================================
+    # informational helpers
+    #=============================================================================
+
+    @memoized_property
+    def entropy_per_symbol(self):
+        """
+        Average entropy per symbol (assuming all symbols have equal probability)
+        """
+        return logf(self.symbol_count, 2)
+
+    @memoized_property
+    def entropy(self):
+        """
+        Effective entropy of generated passwords.
+
+        This value will always be a multiple of :attr:`entropy_per_symbol`.
+        If entropy is specified in constructor, :attr:`length` will be chosen so
+        so that this value is the smallest multiple >= :attr:`requested_entropy`.
+        """
+        return self.length * self.entropy_per_symbol
+
+    #=============================================================================
+    # generation
+    #=============================================================================
+    def __next__(self):
+        """main generation function, should create one password/phrase"""
+        raise NotImplementedError("implement in subclass")
+
+    def __call__(self, returns=None):
+        """
+        frontend used by genword() / genphrase() to create passwords
+        """
+        if returns is None:
+            return next(self)
+        elif isinstance(returns, int_types):
+            return [next(self) for _ in irange(returns)]
+        elif returns is iter:
+            return self
+        else:
+            raise exc.ExpectedTypeError(returns, "<None>, int, or <iter>", "returns")
+
+    def __iter__(self):
+        return self
+
+    if PY2:
+        def next(self):
+            return self.__next__()
+
+    #=============================================================================
+    # eoc
+    #=============================================================================
+
+#=============================================================================
+# default charsets
+#=============================================================================
+
+#: global dict of predefined characters sets
+default_charsets = dict(
+    # ascii letters, digits, and some punctuation
+    ascii_72='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*?/',
+
+    # ascii letters and digits
+    ascii_62='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+
+    # ascii_50, without visually similar '1IiLl', '0Oo', '5S', '8B'
+    ascii_50='234679abcdefghjkmnpqrstuvwxyzACDEFGHJKMNPQRTUVWXYZ',
+
+    # lower case hexadecimal
+    hex='0123456789abcdef',
+)
+
+#=============================================================================
+# password generator
+#=============================================================================
+
+class WordGenerator(SequenceGenerator):
+    """
+    Class which generates passwords by randomly choosing from a string of unique characters.
+
+    Parameters
+    ----------
+    :param chars:
+        custom character string to draw from.
+
+    :param charset:
+        predefined charset to draw from.
+
+    :param \\*\\*kwds:
+        all other keywords passed to the :class:`SequenceGenerator` parent class.
+
+    Attributes
+    ----------
+    .. autoattribute:: chars
+    .. autoattribute:: charset
+    .. autoattribute:: default_charsets
+    """
+    #=============================================================================
+    # instance attrs
+    #=============================================================================
+
+    #: Predefined character set in use (set to None for instances using custom 'chars')
+    charset = "ascii_62"
+
+    #: string of chars to draw from -- usually filled in from charset
+    chars = None
+
+    #=============================================================================
+    # init
+    #=============================================================================
+    def __init__(self, chars=None, charset=None, **kwds):
+
+        # init chars and charset
+        if chars:
+            if charset:
+                raise TypeError("`chars` and `charset` are mutually exclusive")
+        else:
+            if not charset:
+                charset = self.charset
+                assert charset
+            chars = default_charsets[charset]
+        self.charset = charset
+        chars = to_unicode(chars, param="chars")
+        _ensure_unique(chars, param="chars")
+        self.chars = chars
+
+        # hand off to parent
+        super(WordGenerator, self).__init__(**kwds)
+        # log.debug("WordGenerator(): entropy/char=%r", self.entropy_per_symbol)
+
+    #=============================================================================
+    # informational helpers
+    #=============================================================================
+
+    @memoized_property
+    def symbol_count(self):
+        return len(self.chars)
+
+    #=============================================================================
+    # generation
+    #=============================================================================
+
+    def __next__(self):
+        # XXX: could do things like optionally ensure certain character groups
+        #      (e.g. letters & punctuation) are included
+        return getrandstr(self.rng, self.chars, self.length)
+
+    #=============================================================================
+    # eoc
+    #=============================================================================
+
+
+def genword(entropy=None, length=None, returns=None, **kwds):
+    """Generate one or more random passwords.
+
+    This function uses :mod:`random.SystemRandom` to generate
+    one or more passwords using various character sets.
+    The complexity of the password can be specified
+    by size, or by the desired amount of entropy.
+
+    Usage Example::
+
+        >>> # generate a random alphanumeric string with 48 bits of entropy (the default)
+        >>> from passlib import pwd
+        >>> pwd.genword()
+        'DnBHvDjMK6'
+
+        >>> # generate a random hexadecimal string with 52 bits of entropy
+        >>> pwd.genword(entropy=52, charset="hex")
+        '310f1a7ac793f'
+
+    :param entropy:
+        Strength of resulting password, measured in 'guessing entropy' bits.
+        An appropriate **length** value will be calculated
+        based on the requested entropy amount, and the size of the character set.
+
+        This can be a positive integer, or one of the following preset
+        strings: ``"weak"`` (24), ``"fair"`` (36),
+        ``"strong"`` (48), and ``"secure"`` (56).
+
+        If neither this or **length** is specified, **entropy** will default
+        to ``"strong"`` (48).
+
+    :param length:
+        Size of resulting password, measured in characters.
+        If omitted, the size is auto-calculated based on the **entropy** parameter.
+
+        If both **entropy** and **length** are specified,
+        the stronger value will be used.
+
+    :param returns:
+        Controls what this function returns:
+
+        * If ``None`` (the default), this function will generate a single password.
+        * If an integer, this function will return a list containing that many passwords.
+        * If the ``iter`` constant, will return an iterator that yields passwords.
+
+    :param chars:
+
+        Optionally specify custom string of characters to use when randomly
+        generating a password. This option cannot be combined with **charset**.
+
+    :param charset:
+
+        The predefined character set to draw from (if not specified by **chars**).
+        There are currently four presets available:
+
+        * ``"ascii_62"`` (the default) -- all digits and ascii upper & lowercase letters.
+          Provides ~5.95 entropy per character.
+
+        * ``"ascii_50"`` -- subset which excludes visually similar characters
+          (``1IiLl0Oo5S8B``). Provides ~5.64 entropy per character.
+
+        * ``"ascii_72"`` -- all digits and ascii upper & lowercase letters,
+          as well as some punctuation. Provides ~6.17 entropy per character.
+
+        * ``"hex"`` -- Lower case hexadecimal.  Providers 4 bits of entropy per character.
+
+    :returns:
+        :class:`!unicode` string containing randomly generated password;
+        or list of 1+ passwords if :samp:`returns={int}` is specified.
+    """
+    gen = WordGenerator(length=length, entropy=entropy, **kwds)
+    return gen(returns)
+
+#=============================================================================
+# default wordsets
+#=============================================================================
+
+def _load_wordset(asset_path):
+    """
+    load wordset from compressed datafile within package data.
+    file should be utf-8 encoded
+
+    :param asset_path:
+        string containing  absolute path to wordset file,
+        or "python.module:relative/file/path".
+
+    :returns:
+        tuple of words, as loaded from specified words file.
+    """
+    # open resource file, convert to tuple of words (strip blank lines & ws)
+    with _open_asset_path(asset_path, "utf-8") as fh:
+        gen = (word.strip() for word in fh)
+        words = tuple(word for word in gen if word)
+
+    # NOTE: works but not used
+    # # detect if file uses "<int> <word>" format, and strip numeric prefix
+    # def extract(row):
+    #     idx, word = row.replace("\t", " ").split(" ", 1)
+    #     if not idx.isdigit():
+    #         raise ValueError("row is not dice index + word")
+    #     return word
+    # try:
+    #     extract(words[-1])
+    # except ValueError:
+    #     pass
+    # else:
+    #     words = tuple(extract(word) for word in words)
+
+    log.debug("loaded %d-element wordset from %r", len(words), asset_path)
+    return words
+
+
+class WordsetDict(MutableMapping):
+    """
+    Special mapping used to store dictionary of wordsets.
+    Different from a regular dict in that some wordsets
+    may be lazy-loaded from an asset path.
+    """
+
+    #: dict of key -> asset path
+    paths = None
+
+    #: dict of key -> value
+    _loaded = None
+
+    def __init__(self, *args, **kwds):
+        self.paths = {}
+        self._loaded = {}
+        super(WordsetDict, self).__init__(*args, **kwds)
+
+    def __getitem__(self, key):
+        try:
+            return self._loaded[key]
+        except KeyError:
+            pass
+        path = self.paths[key]
+        value = self._loaded[key] = _load_wordset(path)
+        return value
+
+    def set_path(self, key, path):
+        """
+        set asset path to lazy-load wordset from.
+        """
+        self.paths[key] = path
+
+    def __setitem__(self, key, value):
+        self._loaded[key] = value
+
+    def __delitem__(self, key):
+        if key in self:
+            del self._loaded[key]
+            self.paths.pop(key, None)
+        else:
+            del self.paths[key]
+
+    @property
+    def _keyset(self):
+        keys = set(self._loaded)
+        keys.update(self.paths)
+        return keys
+
+    def __iter__(self):
+        return iter(self._keyset)
+
+    def __len__(self):
+        return len(self._keyset)
+
+    # NOTE: speeds things up, and prevents contains from lazy-loading
+    def __contains__(self, key):
+        return key in self._loaded or key in self.paths
+
+
+#: dict of predefined word sets.
+#: key is name of wordset, value should be sequence of words.
+default_wordsets = WordsetDict()
+
+# register the wordsets built into passlib
+for name in "eff_long eff_short eff_prefixed bip39".split():
+    default_wordsets.set_path(name, "passlib:_data/wordsets/%s.txt" % name)
+
+#=============================================================================
+# passphrase generator
+#=============================================================================
+class PhraseGenerator(SequenceGenerator):
+    """class which generates passphrases by randomly choosing
+    from a list of unique words.
+
+    :param wordset:
+        wordset to draw from.
+    :param preset:
+        name of preset wordlist to use instead of ``wordset``.
+    :param spaces:
+        whether to insert spaces between words in output (defaults to ``True``).
+    :param \\*\\*kwds:
+        all other keywords passed to the :class:`SequenceGenerator` parent class.
+
+    .. autoattribute:: wordset
+    """
+    #=============================================================================
+    # instance attrs
+    #=============================================================================
+
+    #: predefined wordset to use
+    wordset = "eff_long"
+
+    #: list of words to draw from
+    words = None
+
+    #: separator to use when joining words
+    sep = " "
+
+    #=============================================================================
+    # init
+    #=============================================================================
+    def __init__(self, wordset=None, words=None, sep=None, **kwds):
+
+        # load wordset
+        if words is not None:
+            if wordset is not None:
+                raise TypeError("`words` and `wordset` are mutually exclusive")
+        else:
+            if wordset is None:
+                wordset = self.wordset
+                assert wordset
+            words = default_wordsets[wordset]
+        self.wordset = wordset
+
+        # init words
+        if not isinstance(words, _sequence_types):
+            words = tuple(words)
+        _ensure_unique(words, param="words")
+        self.words = words
+
+        # init separator
+        if sep is None:
+            sep = self.sep
+        sep = to_unicode(sep, param="sep")
+        self.sep = sep
+
+        # hand off to parent
+        super(PhraseGenerator, self).__init__(**kwds)
+        ##log.debug("PhraseGenerator(): entropy/word=%r entropy/char=%r min_chars=%r",
+        ##          self.entropy_per_symbol, self.entropy_per_char, self.min_chars)
+
+    #=============================================================================
+    # informational helpers
+    #=============================================================================
+
+    @memoized_property
+    def symbol_count(self):
+        return len(self.words)
+
+    #=============================================================================
+    # generation
+    #=============================================================================
+
+    def __next__(self):
+        words = (self.rng.choice(self.words) for _ in irange(self.length))
+        return self.sep.join(words)
+
+    #=============================================================================
+    # eoc
+    #=============================================================================
+
+
+def genphrase(entropy=None, length=None, returns=None, **kwds):
+    """Generate one or more random password / passphrases.
+
+    This function uses :mod:`random.SystemRandom` to generate
+    one or more passwords; it can be configured to generate
+    alphanumeric passwords, or full english phrases.
+    The complexity of the password can be specified
+    by size, or by the desired amount of entropy.
+
+    Usage Example::
+
+        >>> # generate random phrase with 48 bits of entropy
+        >>> from passlib import pwd
+        >>> pwd.genphrase()
+        'gangly robbing salt shove'
+
+        >>> # generate a random phrase with 52 bits of entropy
+        >>> # using a particular wordset
+        >>> pwd.genword(entropy=52, wordset="bip39")
+        'wheat dilemma reward rescue diary'
+
+    :param entropy:
+        Strength of resulting password, measured in 'guessing entropy' bits.
+        An appropriate **length** value will be calculated
+        based on the requested entropy amount, and the size of the word set.
+
+        This can be a positive integer, or one of the following preset
+        strings: ``"weak"`` (24), ``"fair"`` (36),
+        ``"strong"`` (48), and ``"secure"`` (56).
+
+        If neither this or **length** is specified, **entropy** will default
+        to ``"strong"`` (48).
+
+    :param length:
+        Length of resulting password, measured in words.
+        If omitted, the size is auto-calculated based on the **entropy** parameter.
+
+        If both **entropy** and **length** are specified,
+        the stronger value will be used.
+
+    :param returns:
+        Controls what this function returns:
+
+        * If ``None`` (the default), this function will generate a single password.
+        * If an integer, this function will return a list containing that many passwords.
+        * If the ``iter`` builtin, will return an iterator that yields passwords.
+
+    :param words:
+
+        Optionally specifies a list/set of words to use when randomly generating a passphrase.
+        This option cannot be combined with **wordset**.
+
+    :param wordset:
+
+        The predefined word set to draw from (if not specified by **words**).
+        There are currently four presets available:
+
+        ``"eff_long"`` (the default)
+
+            Wordset containing 7776 english words of ~7 letters.
+            Constructed by the EFF, it offers ~12.9 bits of entropy per word.
+
+            This wordset (and the other ``"eff_"`` wordsets)
+            were `created by the EFF <https://www.eff.org/deeplinks/2016/07/new-wordlists-random-passphrases>`_
+            to aid in generating passwords.  See their announcement page
+            for more details about the design & properties of these wordsets.
+
+        ``"eff_short"``
+
+            Wordset containing 1296 english words of ~4.5 letters.
+            Constructed by the EFF, it offers ~10.3 bits of entropy per word.
+
+        ``"eff_prefixed"``
+
+            Wordset containing 1296 english words of ~8 letters,
+            selected so that they each have a unique 3-character prefix.
+            Constructed by the EFF, it offers ~10.3 bits of entropy per word.
+
+        ``"bip39"``
+
+            Wordset of 2048 english words of ~5 letters,
+            selected so that they each have a unique 4-character prefix.
+            Published as part of Bitcoin's `BIP 39 <https://github.com/bitcoin/bips/blob/master/bip-0039/english.txt>`_,
+            this wordset has exactly 11 bits of entropy per word.
+
+            This list offers words that are typically shorter than ``"eff_long"``
+            (at the cost of slightly less entropy); and much shorter than
+            ``"eff_prefixed"`` (at the cost of a longer unique prefix).
+
+    :param sep:
+        Optional separator to use when joining words.
+        Defaults to ``" "`` (a space), but can be an empty string, a hyphen, etc.
+
+    :returns:
+        :class:`!unicode` string containing randomly generated passphrase;
+        or list of 1+ passphrases if :samp:`returns={int}` is specified.
+    """
+    gen = PhraseGenerator(entropy=entropy, length=length, **kwds)
+    return gen(returns)
+
+#=============================================================================
+# strength measurement
+#
+# NOTE:
+# for a little while, had rough draft of password strength measurement alg here.
+# but not sure if there's value in yet another measurement algorithm,
+# that's not just duplicating the effort of libraries like zxcbn.
+# may revive it later, but for now, leaving some refs to others out there:
+#    * NIST 800-63 has simple alg
+#    * zxcvbn (https://tech.dropbox.com/2012/04/zxcvbn-realistic-password-strength-estimation/)
+#      might also be good, and has approach similar to composite approach i was already thinking about,
+#      but much more well thought out.
+#    * passfault (https://github.com/c-a-m/passfault) looks thorough,
+#      but may have licensing issues, plus porting to python looks like very big job :(
+#    * give a look at running things through zlib - might be able to cheaply
+#      catch extra redundancies.
+#=============================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/registry.py b/myenv/lib/python3.9/site-packages/passlib/registry.py
new file mode 100644
index 0000000..9964b25
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/registry.py
@@ -0,0 +1,547 @@
+"""passlib.registry - registry for password hash handlers"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import re
+import logging; log = logging.getLogger(__name__)
+from warnings import warn
+# pkg
+from passlib import exc
+from passlib.exc import ExpectedTypeError, PasslibWarning
+from passlib.ifc import PasswordHash
+from passlib.utils import (
+    is_crypt_handler, has_crypt as os_crypt_present,
+    unix_crypt_schemes as os_crypt_schemes,
+)
+from passlib.utils.compat import unicode_or_str
+from passlib.utils.decor import memoize_single_value
+# local
+__all__ = [
+    "register_crypt_handler_path",
+    "register_crypt_handler",
+    "get_crypt_handler",
+    "list_crypt_handlers",
+]
+
+#=============================================================================
+# proxy object used in place of 'passlib.hash' module
+#=============================================================================
+class _PasslibRegistryProxy(object):
+    """proxy module passlib.hash
+
+    this module is in fact an object which lazy-loads
+    the requested password hash algorithm from wherever it has been stored.
+    it acts as a thin wrapper around :func:`passlib.registry.get_crypt_handler`.
+    """
+    __name__ = "passlib.hash"
+    __package__ = None
+
+    def __getattr__(self, attr):
+        if attr.startswith("_"):
+            raise AttributeError("missing attribute: %r" % (attr,))
+        handler = get_crypt_handler(attr, None)
+        if handler:
+            return handler
+        else:
+            raise AttributeError("unknown password hash: %r" % (attr,))
+
+    def __setattr__(self, attr, value):
+        if attr.startswith("_"):
+            # writing to private attributes should behave normally.
+            # (required so GAE can write to the __loader__ attribute).
+            object.__setattr__(self, attr, value)
+        else:
+            # writing to public attributes should be treated
+            # as attempting to register a handler.
+            register_crypt_handler(value, _attr=attr)
+
+    def __repr__(self):
+        return "<proxy module 'passlib.hash'>"
+
+    def __dir__(self):
+        # this adds in lazy-loaded handler names,
+        # otherwise this is the standard dir() implementation.
+        attrs = set(dir(self.__class__))
+        attrs.update(self.__dict__)
+        attrs.update(_locations)
+        return sorted(attrs)
+
+# create single instance - available publically as 'passlib.hash'
+_proxy = _PasslibRegistryProxy()
+
+#=============================================================================
+# internal registry state
+#=============================================================================
+
+# singleton uses to detect omitted keywords
+_UNSET = object()
+
+# dict mapping name -> loaded handlers (just uses proxy object's internal dict)
+_handlers = _proxy.__dict__
+
+# dict mapping names -> import path for lazy loading.
+#     * import path should be "module.path" or "module.path:attr"
+#     * if attr omitted, "name" used as default.
+_locations = dict(
+    # NOTE: this is a hardcoded list of the handlers built into passlib,
+    #       applications should call register_crypt_handler_path()
+    apr_md5_crypt = "passlib.handlers.md5_crypt",
+    argon2 = "passlib.handlers.argon2",
+    atlassian_pbkdf2_sha1 = "passlib.handlers.pbkdf2",
+    bcrypt = "passlib.handlers.bcrypt",
+    bcrypt_sha256 = "passlib.handlers.bcrypt",
+    bigcrypt = "passlib.handlers.des_crypt",
+    bsd_nthash = "passlib.handlers.windows",
+    bsdi_crypt = "passlib.handlers.des_crypt",
+    cisco_pix = "passlib.handlers.cisco",
+    cisco_asa = "passlib.handlers.cisco",
+    cisco_type7 = "passlib.handlers.cisco",
+    cta_pbkdf2_sha1 = "passlib.handlers.pbkdf2",
+    crypt16 = "passlib.handlers.des_crypt",
+    des_crypt = "passlib.handlers.des_crypt",
+    django_argon2 = "passlib.handlers.django",
+    django_bcrypt = "passlib.handlers.django",
+    django_bcrypt_sha256 = "passlib.handlers.django",
+    django_pbkdf2_sha256 = "passlib.handlers.django",
+    django_pbkdf2_sha1 = "passlib.handlers.django",
+    django_salted_sha1 = "passlib.handlers.django",
+    django_salted_md5 = "passlib.handlers.django",
+    django_des_crypt = "passlib.handlers.django",
+    django_disabled = "passlib.handlers.django",
+    dlitz_pbkdf2_sha1 = "passlib.handlers.pbkdf2",
+    fshp = "passlib.handlers.fshp",
+    grub_pbkdf2_sha512 = "passlib.handlers.pbkdf2",
+    hex_md4 = "passlib.handlers.digests",
+    hex_md5 = "passlib.handlers.digests",
+    hex_sha1 = "passlib.handlers.digests",
+    hex_sha256 = "passlib.handlers.digests",
+    hex_sha512 = "passlib.handlers.digests",
+    htdigest = "passlib.handlers.digests",
+    ldap_plaintext = "passlib.handlers.ldap_digests",
+    ldap_md5 = "passlib.handlers.ldap_digests",
+    ldap_sha1 = "passlib.handlers.ldap_digests",
+    ldap_hex_md5 = "passlib.handlers.roundup",
+    ldap_hex_sha1 = "passlib.handlers.roundup",
+    ldap_salted_md5 = "passlib.handlers.ldap_digests",
+    ldap_salted_sha1 = "passlib.handlers.ldap_digests",
+    ldap_salted_sha256 = "passlib.handlers.ldap_digests",
+    ldap_salted_sha512 = "passlib.handlers.ldap_digests",
+    ldap_des_crypt = "passlib.handlers.ldap_digests",
+    ldap_bsdi_crypt = "passlib.handlers.ldap_digests",
+    ldap_md5_crypt = "passlib.handlers.ldap_digests",
+    ldap_bcrypt = "passlib.handlers.ldap_digests",
+    ldap_sha1_crypt = "passlib.handlers.ldap_digests",
+    ldap_sha256_crypt = "passlib.handlers.ldap_digests",
+    ldap_sha512_crypt = "passlib.handlers.ldap_digests",
+    ldap_pbkdf2_sha1 = "passlib.handlers.pbkdf2",
+    ldap_pbkdf2_sha256 = "passlib.handlers.pbkdf2",
+    ldap_pbkdf2_sha512 = "passlib.handlers.pbkdf2",
+    lmhash = "passlib.handlers.windows",
+    md5_crypt = "passlib.handlers.md5_crypt",
+    msdcc = "passlib.handlers.windows",
+    msdcc2 = "passlib.handlers.windows",
+    mssql2000 = "passlib.handlers.mssql",
+    mssql2005 = "passlib.handlers.mssql",
+    mysql323 = "passlib.handlers.mysql",
+    mysql41 = "passlib.handlers.mysql",
+    nthash = "passlib.handlers.windows",
+    oracle10 = "passlib.handlers.oracle",
+    oracle11 = "passlib.handlers.oracle",
+    pbkdf2_sha1 = "passlib.handlers.pbkdf2",
+    pbkdf2_sha256 = "passlib.handlers.pbkdf2",
+    pbkdf2_sha512 = "passlib.handlers.pbkdf2",
+    phpass = "passlib.handlers.phpass",
+    plaintext = "passlib.handlers.misc",
+    postgres_md5 = "passlib.handlers.postgres",
+    roundup_plaintext = "passlib.handlers.roundup",
+    scram = "passlib.handlers.scram",
+    scrypt = "passlib.handlers.scrypt",
+    sha1_crypt = "passlib.handlers.sha1_crypt",
+    sha256_crypt = "passlib.handlers.sha2_crypt",
+    sha512_crypt = "passlib.handlers.sha2_crypt",
+    sun_md5_crypt = "passlib.handlers.sun_md5_crypt",
+    unix_disabled = "passlib.handlers.misc",
+    unix_fallback = "passlib.handlers.misc",
+)
+
+# master regexp for detecting valid handler names
+_name_re = re.compile("^[a-z][a-z0-9_]+[a-z0-9]$")
+
+# names which aren't allowed for various reasons
+# (mainly keyword conflicts in CryptContext)
+_forbidden_names = frozenset(["onload", "policy", "context", "all",
+                              "default", "none", "auto"])
+
+#=============================================================================
+# registry frontend functions
+#=============================================================================
+def _validate_handler_name(name):
+    """helper to validate handler name
+
+    :raises ValueError:
+        * if empty name
+        * if name not lower case
+        * if name contains double underscores
+        * if name is reserved (e.g. ``context``, ``all``).
+    """
+    if not name:
+        raise ValueError("handler name cannot be empty: %r" % (name,))
+    if name.lower() != name:
+        raise ValueError("name must be lower-case: %r" % (name,))
+    if not _name_re.match(name):
+        raise ValueError("invalid name (must be 3+ characters, "
+                         " begin with a-z, and contain only underscore, a-z, "
+                         "0-9): %r" % (name,))
+    if '__' in name:
+        raise ValueError("name may not contain double-underscores: %r" %
+                         (name,))
+    if name in _forbidden_names:
+        raise ValueError("that name is not allowed: %r" % (name,))
+    return True
+
+def register_crypt_handler_path(name, path):
+    """register location to lazy-load handler when requested.
+
+    custom hashes may be registered via :func:`register_crypt_handler`,
+    or they may be registered by this function,
+    which will delay actually importing and loading the handler
+    until a call to :func:`get_crypt_handler` is made for the specified name.
+
+    :arg name: name of handler
+    :arg path: module import path
+
+    the specified module path should contain a password hash handler
+    called :samp:`{name}`, or the path may contain a colon,
+    specifying the module and module attribute to use.
+    for example, the following would cause ``get_handler("myhash")`` to look
+    for a class named ``myhash`` within the ``myapp.helpers`` module::
+
+        >>> from passlib.registry import registry_crypt_handler_path
+        >>> registry_crypt_handler_path("myhash", "myapp.helpers")
+
+    ...while this form would cause ``get_handler("myhash")`` to look
+    for a class name ``MyHash`` within the ``myapp.helpers`` module::
+
+        >>> from passlib.registry import registry_crypt_handler_path
+        >>> registry_crypt_handler_path("myhash", "myapp.helpers:MyHash")
+    """
+    # validate name
+    _validate_handler_name(name)
+
+    # validate path
+    if path.startswith("."):
+        raise ValueError("path cannot start with '.'")
+    if ':' in path:
+        if path.count(':') > 1:
+            raise ValueError("path cannot have more than one ':'")
+        if path.find('.', path.index(':')) > -1:
+            raise ValueError("path cannot have '.' to right of ':'")
+
+    # store location
+    _locations[name] = path
+    log.debug("registered path to %r handler: %r", name, path)
+
+def register_crypt_handler(handler, force=False, _attr=None):
+    """register password hash handler.
+
+    this method immediately registers a handler with the internal passlib registry,
+    so that it will be returned by :func:`get_crypt_handler` when requested.
+
+    :arg handler: the password hash handler to register
+    :param force: force override of existing handler (defaults to False)
+    :param _attr:
+        [internal kwd] if specified, ensures ``handler.name``
+        matches this value, or raises :exc:`ValueError`.
+
+    :raises TypeError:
+        if the specified object does not appear to be a valid handler.
+
+    :raises ValueError:
+        if the specified object's name (or other required attributes)
+        contain invalid values.
+
+    :raises KeyError:
+        if a (different) handler was already registered with
+        the same name, and ``force=True`` was not specified.
+    """
+    # validate handler
+    if not is_crypt_handler(handler):
+        raise ExpectedTypeError(handler, "password hash handler", "handler")
+    if not handler:
+        raise AssertionError("``bool(handler)`` must be True")
+
+    # validate name
+    name = handler.name
+    _validate_handler_name(name)
+    if _attr and _attr != name:
+        raise ValueError("handlers must be stored only under their own name (%r != %r)" %
+                         (_attr, name))
+
+    # check for existing handler
+    other = _handlers.get(name)
+    if other:
+        if other is handler:
+            log.debug("same %r handler already registered: %r", name, handler)
+            return
+        elif force:
+            log.warning("overriding previously registered %r handler: %r",
+                        name, other)
+        else:
+            raise KeyError("another %r handler has already been registered: %r" %
+                           (name, other))
+
+    # register handler
+    _handlers[name] = handler
+    log.debug("registered %r handler: %r", name, handler)
+
+def get_crypt_handler(name, default=_UNSET):
+    """return handler for specified password hash scheme.
+
+    this method looks up a handler for the specified scheme.
+    if the handler is not already loaded,
+    it checks if the location is known, and loads it first.
+
+    :arg name: name of handler to return
+    :param default: optional default value to return if no handler with specified name is found.
+
+    :raises KeyError: if no handler matching that name is found, and no default specified, a KeyError will be raised.
+
+    :returns: handler attached to name, or default value (if specified).
+    """
+    # catch invalid names before we check _handlers,
+    # since it's a module dict, and exposes things like __package__, etc.
+    if name.startswith("_"):
+        if default is _UNSET:
+            raise KeyError("invalid handler name: %r" % (name,))
+        else:
+            return default
+
+    # check if handler is already loaded
+    try:
+        return _handlers[name]
+    except KeyError:
+        pass
+
+    # normalize name (and if changed, check dict again)
+    assert isinstance(name, unicode_or_str), "name must be string instance"
+    alt = name.replace("-","_").lower()
+    if alt != name:
+        warn("handler names should be lower-case, and use underscores instead "
+             "of hyphens: %r => %r" % (name, alt), PasslibWarning,
+             stacklevel=2)
+        name = alt
+
+        # try to load using new name
+        try:
+            return _handlers[name]
+        except KeyError:
+            pass
+
+    # check if lazy load mapping has been specified for this driver
+    path = _locations.get(name)
+    if path:
+        if ':' in path:
+            modname, modattr = path.split(":")
+        else:
+            modname, modattr = path, name
+        ##log.debug("loading %r handler from path: '%s:%s'", name, modname, modattr)
+
+        # try to load the module - any import errors indicate runtime config, usually
+        # either missing package, or bad path provided to register_crypt_handler_path()
+        mod = __import__(modname, fromlist=[modattr], level=0)
+
+        # first check if importing module triggered register_crypt_handler(),
+        # (this is discouraged due to its magical implicitness)
+        handler = _handlers.get(name)
+        if handler:
+            # XXX: issue deprecation warning here?
+            assert is_crypt_handler(handler), "unexpected object: name=%r object=%r" % (name, handler)
+            return handler
+
+        # then get real handler & register it
+        handler = getattr(mod, modattr)
+        register_crypt_handler(handler, _attr=name)
+        return handler
+
+    # fail!
+    if default is _UNSET:
+        raise KeyError("no crypt handler found for algorithm: %r" % (name,))
+    else:
+        return default
+
+def list_crypt_handlers(loaded_only=False):
+    """return sorted list of all known crypt handler names.
+
+    :param loaded_only: if ``True``, only returns names of handlers which have actually been loaded.
+
+    :returns: list of names of all known handlers
+    """
+    names = set(_handlers)
+    if not loaded_only:
+        names.update(_locations)
+    # strip private attrs out of namespace and sort.
+    # TODO: make _handlers a separate list, so we don't have module namespace mixed in.
+    return sorted(name for name in names if not name.startswith("_"))
+
+# NOTE: these two functions mainly exist just for the unittests...
+
+def _has_crypt_handler(name, loaded_only=False):
+    """check if handler name is known.
+
+    this is only useful for two cases:
+
+    * quickly checking if handler has already been loaded
+    * checking if handler exists, without actually loading it
+
+    :arg name: name of handler
+    :param loaded_only: if ``True``, returns False if handler exists but hasn't been loaded
+    """
+    return (name in _handlers) or (not loaded_only and name in _locations)
+
+def _unload_handler_name(name, locations=True):
+    """unloads a handler from the registry.
+
+    .. warning::
+
+        this is an internal function,
+        used only by the unittests.
+
+    if loaded handler is found with specified name, it's removed.
+    if path to lazy load handler is found, it's removed.
+
+    missing names are a noop.
+
+    :arg name: name of handler to unload
+    :param locations: if False, won't purge registered handler locations (default True)
+    """
+    if name in _handlers:
+        del _handlers[name]
+    if locations and name in _locations:
+        del _locations[name]
+
+#=============================================================================
+# inspection helpers
+#=============================================================================
+
+#------------------------------------------------------------------
+# general
+#------------------------------------------------------------------
+
+# TODO: needs UTs
+def _resolve(hasher, param="value"):
+    """
+    internal helper to resolve argument to hasher object
+    """
+    if is_crypt_handler(hasher):
+        return hasher
+    elif isinstance(hasher, unicode_or_str):
+        return get_crypt_handler(hasher)
+    else:
+        raise exc.ExpectedTypeError(hasher, unicode_or_str, param)
+
+
+#: backend aliases
+ANY = "any"
+BUILTIN = "builtin"
+OS_CRYPT = "os_crypt"
+
+# TODO: needs UTs
+def has_backend(hasher, backend=ANY, safe=False):
+    """
+    Test if specified backend is available for hasher.
+
+    :param hasher:
+        Hasher name or object.
+
+    :param backend:
+        Name of backend, or ``"any"`` if any backend will do.
+        For hashers without multiple backends, will pretend
+        they have a single backend named ``"builtin"``.
+
+    :param safe:
+        By default, throws error if backend is unknown.
+        If ``safe=True``, will just return false value.
+
+    :raises ValueError:
+        * if hasher name is unknown.
+        * if backend is unknown to hasher, and safe=False.
+
+    :return:
+        True if backend available, False if not available,
+        and None if unknown + safe=True.
+    """
+    hasher = _resolve(hasher)
+
+    if backend == ANY:
+        if not hasattr(hasher, "get_backend"):
+            # single backend, assume it's loaded
+            return True
+
+        # multiple backends, check at least one is loadable
+        try:
+            hasher.get_backend()
+            return True
+        except exc.MissingBackendError:
+            return False
+
+    # test for specific backend
+    if hasattr(hasher, "has_backend"):
+        # multiple backends
+        if safe and backend not in hasher.backends:
+            return None
+        return hasher.has_backend(backend)
+
+    # single builtin backend
+    if backend == BUILTIN:
+        return True
+    elif safe:
+        return None
+    else:
+        raise exc.UnknownBackendError(hasher, backend)
+
+#------------------------------------------------------------------
+# os crypt
+#------------------------------------------------------------------
+
+# TODO: move unix_crypt_schemes list to here.
+# os_crypt_schemes -- alias for unix_crypt_schemes above
+
+
+# TODO: needs UTs
+@memoize_single_value
+def get_supported_os_crypt_schemes():
+    """
+    return tuple of schemes which :func:`crypt.crypt` natively supports.
+    """
+    if not os_crypt_present:
+        return ()
+    cache = tuple(name for name in os_crypt_schemes
+                  if get_crypt_handler(name).has_backend(OS_CRYPT))
+    if not cache:  # pragma: no cover -- sanity check
+        # no idea what OS this could happen on...
+        import platform
+        warn("crypt.crypt() function is present, but doesn't support any "
+             "formats known to passlib! (system=%r release=%r)" %
+             (platform.system(), platform.release()),
+             exc.PasslibRuntimeWarning)
+    return cache
+
+
+# TODO: needs UTs
+def has_os_crypt_support(hasher):
+    """
+    check if hash is supported by native :func:`crypt.crypt` function.
+    if :func:`crypt.crypt` is not present, will always return False.
+
+    :param hasher:
+        name or hasher object.
+
+    :returns bool:
+        True if hash format is supported by OS, else False.
+    """
+    return os_crypt_present and has_backend(hasher, OS_CRYPT, safe=True)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/__init__.py b/myenv/lib/python3.9/site-packages/passlib/tests/__init__.py
new file mode 100644
index 0000000..389da76
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/__init__.py
@@ -0,0 +1 @@
+"""passlib tests"""
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/__main__.py b/myenv/lib/python3.9/site-packages/passlib/tests/__main__.py
new file mode 100644
index 0000000..2424576
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/__main__.py
@@ -0,0 +1,6 @@
+import os
+from nose import run
+run(
+    defaultTest=os.path.dirname(__file__),
+)
+
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/_test_bad_register.py b/myenv/lib/python3.9/site-packages/passlib/tests/_test_bad_register.py
new file mode 100644
index 0000000..f0683fc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/_test_bad_register.py
@@ -0,0 +1,15 @@
+"""helper for method in test_registry.py"""
+from passlib.registry import register_crypt_handler
+import passlib.utils.handlers as uh
+
+class dummy_bad(uh.StaticHandler):
+    name = "dummy_bad"
+
+class alt_dummy_bad(uh.StaticHandler):
+    name = "dummy_bad"
+
+# NOTE: if passlib.tests is being run from symlink (e.g. via gaeunit),
+#       this module may be imported a second time as test._test_bad_registry.
+#       we don't want it to do anything in that case.
+if __name__.startswith("passlib.tests"):
+    register_crypt_handler(alt_dummy_bad)
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/backports.py b/myenv/lib/python3.9/site-packages/passlib/tests/backports.py
new file mode 100644
index 0000000..5058cec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/backports.py
@@ -0,0 +1,67 @@
+"""backports of needed unittest2 features"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+import logging; log = logging.getLogger(__name__)
+import re
+import sys
+##from warnings import warn
+# site
+# pkg
+from passlib.utils.compat import PY26
+# local
+__all__ = [
+    "TestCase",
+    "unittest",
+    # TODO: deprecate these exports in favor of "unittest.XXX"
+    "skip", "skipIf", "skipUnless",
+]
+
+#=============================================================================
+# import latest unittest module available
+#=============================================================================
+try:
+    import unittest2 as unittest
+except ImportError:
+    if PY26:
+        raise ImportError("Passlib's tests require 'unittest2' under Python 2.6 (as of Passlib 1.7)")
+    # python 2.7 and python 3.2 both have unittest2 features (at least, the ones we use)
+    import unittest
+
+#=============================================================================
+# unittest aliases
+#=============================================================================
+skip = unittest.skip
+skipIf = unittest.skipIf
+skipUnless = unittest.skipUnless
+SkipTest = unittest.SkipTest
+
+#=============================================================================
+# custom test harness
+#=============================================================================
+class TestCase(unittest.TestCase):
+    """backports a number of unittest2 features in TestCase"""
+
+    #===================================================================
+    # backport some unittest2 names
+    #===================================================================
+
+    #---------------------------------------------------------------
+    # backport assertRegex() alias from 3.2 to 2.7
+    # was present in 2.7 under an alternate name
+    #---------------------------------------------------------------
+    if not hasattr(unittest.TestCase, "assertRegex"):
+        assertRegex = unittest.TestCase.assertRegexpMatches
+
+    if not hasattr(unittest.TestCase, "assertRaisesRegex"):
+        assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/sample1.cfg b/myenv/lib/python3.9/site-packages/passlib/tests/sample1.cfg
new file mode 100644
index 0000000..56e3ae8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/sample1.cfg
@@ -0,0 +1,9 @@
+[passlib]
+schemes = des_crypt, md5_crypt, bsdi_crypt, sha512_crypt
+default = md5_crypt
+all__vary_rounds = 0.1
+bsdi_crypt__default_rounds = 25001
+bsdi_crypt__max_rounds = 30001
+sha512_crypt__max_rounds = 50000
+sha512_crypt__min_rounds = 40000
+
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/sample1b.cfg b/myenv/lib/python3.9/site-packages/passlib/tests/sample1b.cfg
new file mode 100644
index 0000000..542a603
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/sample1b.cfg
@@ -0,0 +1,9 @@
+[passlib]
+schemes = des_crypt, md5_crypt, bsdi_crypt, sha512_crypt
+default = md5_crypt
+all__vary_rounds = 0.1
+bsdi_crypt__default_rounds = 25001
+bsdi_crypt__max_rounds = 30001
+sha512_crypt__max_rounds = 50000
+sha512_crypt__min_rounds = 40000
+
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/sample1c.cfg b/myenv/lib/python3.9/site-packages/passlib/tests/sample1c.cfg
new file mode 100644
index 0000000..a5033eb
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/passlib/tests/sample1c.cfg differ
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/sample_config_1s.cfg b/myenv/lib/python3.9/site-packages/passlib/tests/sample_config_1s.cfg
new file mode 100644
index 0000000..495a13e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/sample_config_1s.cfg
@@ -0,0 +1,8 @@
+[passlib]
+schemes = des_crypt, md5_crypt, bsdi_crypt, sha512_crypt
+default = md5_crypt
+all.vary_rounds = 10%%
+bsdi_crypt.max_rounds = 30000
+bsdi_crypt.default_rounds = 25000
+sha512_crypt.max_rounds = 50000
+sha512_crypt.min_rounds = 40000
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_apache.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_apache.py
new file mode 100644
index 0000000..198b425
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_apache.py
@@ -0,0 +1,769 @@
+"""tests for passlib.apache -- (c) Assurance Technologies 2008-2011"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+from logging import getLogger
+import os
+import subprocess
+# site
+# pkg
+from passlib import apache, registry
+from passlib.exc import MissingBackendError
+from passlib.utils.compat import irange
+from passlib.tests.backports import unittest
+from passlib.tests.utils import TestCase, get_file, set_file, ensure_mtime_changed
+from passlib.utils.compat import u
+from passlib.utils import to_bytes
+from passlib.utils.handlers import to_unicode_for_identify
+# module
+log = getLogger(__name__)
+
+#=============================================================================
+# helpers
+#=============================================================================
+
+def backdate_file_mtime(path, offset=10):
+    """backdate file's mtime by specified amount"""
+    # NOTE: this is used so we can test code which detects mtime changes,
+    #       without having to actually *pause* for that long.
+    atime = os.path.getatime(path)
+    mtime = os.path.getmtime(path)-offset
+    os.utime(path, (atime, mtime))
+
+#=============================================================================
+# detect external HTPASSWD tool
+#=============================================================================
+
+
+htpasswd_path = os.environ.get("PASSLIB_TEST_HTPASSWD_PATH") or "htpasswd"
+
+
+def _call_htpasswd(args, stdin=None):
+    """
+    helper to run htpasswd cmd
+    """
+    if stdin is not None:
+        stdin = stdin.encode("utf-8")
+    proc = subprocess.Popen([htpasswd_path] + args, stdout=subprocess.PIPE,
+                            stderr=subprocess.STDOUT, stdin=subprocess.PIPE if stdin else None)
+    out, err = proc.communicate(stdin)
+    rc = proc.wait()
+    out = to_unicode_for_identify(out or "")
+    return out, rc
+
+
+def _call_htpasswd_verify(path, user, password):
+    """
+    wrapper for htpasswd verify
+    """
+    out, rc = _call_htpasswd(["-vi", path, user], password)
+    return not rc
+
+
+def _detect_htpasswd():
+    """
+    helper to check if htpasswd is present
+    """
+    try:
+        out, rc = _call_htpasswd([])
+    except OSError:
+        # TODO: under py3, could trap the more specific FileNotFoundError
+        # cmd not found
+        return False, False
+    # when called w/o args, it should print usage to stderr & return rc=2
+    if not rc:
+        log.warning("htpasswd test returned with rc=0")
+    have_bcrypt = " -B " in out
+    return True, have_bcrypt
+
+
+HAVE_HTPASSWD, HAVE_HTPASSWD_BCRYPT = _detect_htpasswd()
+
+requires_htpasswd_cmd = unittest.skipUnless(HAVE_HTPASSWD, "requires `htpasswd` cmdline tool")
+
+
+#=============================================================================
+# htpasswd
+#=============================================================================
+class HtpasswdFileTest(TestCase):
+    """test HtpasswdFile class"""
+    descriptionPrefix = "HtpasswdFile"
+
+    # sample with 4 users
+    sample_01 = (b'user2:2CHkkwa2AtqGs\n'
+                 b'user3:{SHA}3ipNV1GrBtxPmHFC21fCbVCSXIo=\n'
+                 b'user4:pass4\n'
+                 b'user1:$apr1$t4tc7jTh$GPIWVUo8sQKJlUdV8V5vu0\n')
+
+    # sample 1 with user 1, 2 deleted; 4 changed
+    sample_02 = b'user3:{SHA}3ipNV1GrBtxPmHFC21fCbVCSXIo=\nuser4:pass4\n'
+
+    # sample 1 with user2 updated, user 1 first entry removed, and user 5 added
+    sample_03 = (b'user2:pass2x\n'
+                 b'user3:{SHA}3ipNV1GrBtxPmHFC21fCbVCSXIo=\n'
+                 b'user4:pass4\n'
+                 b'user1:$apr1$t4tc7jTh$GPIWVUo8sQKJlUdV8V5vu0\n'
+                 b'user5:pass5\n')
+
+    # standalone sample with 8-bit username
+    sample_04_utf8 = b'user\xc3\xa6:2CHkkwa2AtqGs\n'
+    sample_04_latin1 = b'user\xe6:2CHkkwa2AtqGs\n'
+
+    sample_dup = b'user1:pass1\nuser1:pass2\n'
+
+    # sample with bcrypt & sha256_crypt hashes
+    sample_05 = (b'user2:2CHkkwa2AtqGs\n'
+                 b'user3:{SHA}3ipNV1GrBtxPmHFC21fCbVCSXIo=\n'
+                 b'user4:pass4\n'
+                 b'user1:$apr1$t4tc7jTh$GPIWVUo8sQKJlUdV8V5vu0\n'
+                 b'user5:$2a$12$yktDxraxijBZ360orOyCOePFGhuis/umyPNJoL5EbsLk.s6SWdrRO\n'
+                 b'user6:$5$rounds=110000$cCRp/xUUGVgwR4aP$'
+                     b'p0.QKFS5qLNRqw1/47lXYiAcgIjJK.WjCO8nrEKuUK.\n')
+
+    def test_00_constructor_autoload(self):
+        """test constructor autoload"""
+        # check with existing file
+        path = self.mktemp()
+        set_file(path, self.sample_01)
+        ht = apache.HtpasswdFile(path)
+        self.assertEqual(ht.to_string(), self.sample_01)
+        self.assertEqual(ht.path, path)
+        self.assertTrue(ht.mtime)
+
+        # check changing path
+        ht.path = path + "x"
+        self.assertEqual(ht.path, path + "x")
+        self.assertFalse(ht.mtime)
+
+        # check new=True
+        ht = apache.HtpasswdFile(path, new=True)
+        self.assertEqual(ht.to_string(), b"")
+        self.assertEqual(ht.path, path)
+        self.assertFalse(ht.mtime)
+
+        # check autoload=False (deprecated alias for new=True)
+        with self.assertWarningList("``autoload=False`` is deprecated"):
+            ht = apache.HtpasswdFile(path, autoload=False)
+        self.assertEqual(ht.to_string(), b"")
+        self.assertEqual(ht.path, path)
+        self.assertFalse(ht.mtime)
+
+        # check missing file
+        os.remove(path)
+        self.assertRaises(IOError, apache.HtpasswdFile, path)
+
+        # NOTE: "default_scheme" option checked via set_password() test, among others
+
+    def test_00_from_path(self):
+        path = self.mktemp()
+        set_file(path, self.sample_01)
+        ht = apache.HtpasswdFile.from_path(path)
+        self.assertEqual(ht.to_string(), self.sample_01)
+        self.assertEqual(ht.path, None)
+        self.assertFalse(ht.mtime)
+
+    def test_01_delete(self):
+        """test delete()"""
+        ht = apache.HtpasswdFile.from_string(self.sample_01)
+        self.assertTrue(ht.delete("user1")) # should delete both entries
+        self.assertTrue(ht.delete("user2"))
+        self.assertFalse(ht.delete("user5")) # user not present
+        self.assertEqual(ht.to_string(), self.sample_02)
+
+        # invalid user
+        self.assertRaises(ValueError, ht.delete, "user:")
+
+    def test_01_delete_autosave(self):
+        path = self.mktemp()
+        sample = b'user1:pass1\nuser2:pass2\n'
+        set_file(path, sample)
+
+        ht = apache.HtpasswdFile(path)
+        ht.delete("user1")
+        self.assertEqual(get_file(path), sample)
+
+        ht = apache.HtpasswdFile(path, autosave=True)
+        ht.delete("user1")
+        self.assertEqual(get_file(path), b"user2:pass2\n")
+
+    def test_02_set_password(self):
+        """test set_password()"""
+        ht = apache.HtpasswdFile.from_string(
+            self.sample_01, default_scheme="plaintext")
+        self.assertTrue(ht.set_password("user2", "pass2x"))
+        self.assertFalse(ht.set_password("user5", "pass5"))
+        self.assertEqual(ht.to_string(), self.sample_03)
+
+        # test legacy default kwd
+        with self.assertWarningList("``default`` is deprecated"):
+            ht = apache.HtpasswdFile.from_string(self.sample_01, default="plaintext")
+        self.assertTrue(ht.set_password("user2", "pass2x"))
+        self.assertFalse(ht.set_password("user5", "pass5"))
+        self.assertEqual(ht.to_string(), self.sample_03)
+
+        # invalid user
+        self.assertRaises(ValueError, ht.set_password, "user:", "pass")
+
+        # test that legacy update() still works
+        with self.assertWarningList("update\(\) is deprecated"):
+            ht.update("user2", "test")
+        self.assertTrue(ht.check_password("user2", "test"))
+
+    def test_02_set_password_autosave(self):
+        path = self.mktemp()
+        sample = b'user1:pass1\n'
+        set_file(path, sample)
+
+        ht = apache.HtpasswdFile(path)
+        ht.set_password("user1", "pass2")
+        self.assertEqual(get_file(path), sample)
+
+        ht = apache.HtpasswdFile(path, default_scheme="plaintext", autosave=True)
+        ht.set_password("user1", "pass2")
+        self.assertEqual(get_file(path), b"user1:pass2\n")
+
+    def test_02_set_password_default_scheme(self):
+        """test set_password() -- default_scheme"""
+
+        def check(scheme):
+            ht = apache.HtpasswdFile(default_scheme=scheme)
+            ht.set_password("user1", "pass1")
+            return ht.context.identify(ht.get_hash("user1"))
+
+        # explicit scheme
+        self.assertEqual(check("sha256_crypt"), "sha256_crypt")
+        self.assertEqual(check("des_crypt"), "des_crypt")
+
+        # unknown scheme
+        self.assertRaises(KeyError, check, "xxx")
+
+        # alias resolution
+        self.assertEqual(check("portable"), apache.htpasswd_defaults["portable"])
+        self.assertEqual(check("portable_apache_22"), apache.htpasswd_defaults["portable_apache_22"])
+        self.assertEqual(check("host_apache_22"), apache.htpasswd_defaults["host_apache_22"])
+
+        # default
+        self.assertEqual(check(None), apache.htpasswd_defaults["portable_apache_22"])
+
+    def test_03_users(self):
+        """test users()"""
+        ht = apache.HtpasswdFile.from_string(self.sample_01)
+        ht.set_password("user5", "pass5")
+        ht.delete("user3")
+        ht.set_password("user3", "pass3")
+        self.assertEqual(sorted(ht.users()), ["user1", "user2", "user3", "user4", "user5"])
+
+    def test_04_check_password(self):
+        """test check_password()"""
+        ht = apache.HtpasswdFile.from_string(self.sample_05)
+        self.assertRaises(TypeError, ht.check_password, 1, 'pass9')
+        self.assertTrue(ht.check_password("user9","pass9") is None)
+
+        # users 1..6 of sample_01 run through all the main hash formats,
+        # to make sure they're recognized.
+        for i in irange(1, 7):
+            i = str(i)
+            try:
+                self.assertTrue(ht.check_password("user"+i, "pass"+i))
+                self.assertTrue(ht.check_password("user"+i, "pass9") is False)
+            except MissingBackendError:
+                if i == "5":
+                    # user5 uses bcrypt, which is apparently not available right now
+                    continue
+                raise
+
+        self.assertRaises(ValueError, ht.check_password, "user:", "pass")
+
+        # test that legacy verify() still works
+        with self.assertWarningList(["verify\(\) is deprecated"]*2):
+            self.assertTrue(ht.verify("user1", "pass1"))
+            self.assertFalse(ht.verify("user1", "pass2"))
+
+    def test_05_load(self):
+        """test load()"""
+        # setup empty file
+        path = self.mktemp()
+        set_file(path, "")
+        backdate_file_mtime(path, 5)
+        ha = apache.HtpasswdFile(path, default_scheme="plaintext")
+        self.assertEqual(ha.to_string(), b"")
+
+        # make changes, check load_if_changed() does nothing
+        ha.set_password("user1", "pass1")
+        ha.load_if_changed()
+        self.assertEqual(ha.to_string(), b"user1:pass1\n")
+
+        # change file
+        set_file(path, self.sample_01)
+        ha.load_if_changed()
+        self.assertEqual(ha.to_string(), self.sample_01)
+
+        # make changes, check load() overwrites them
+        ha.set_password("user5", "pass5")
+        ha.load()
+        self.assertEqual(ha.to_string(), self.sample_01)
+
+        # test load w/ no path
+        hb = apache.HtpasswdFile()
+        self.assertRaises(RuntimeError, hb.load)
+        self.assertRaises(RuntimeError, hb.load_if_changed)
+
+        # test load w/ dups and explicit path
+        set_file(path, self.sample_dup)
+        hc = apache.HtpasswdFile()
+        hc.load(path)
+        self.assertTrue(hc.check_password('user1','pass1'))
+
+    # NOTE: load_string() tested via from_string(), which is used all over this file
+
+    def test_06_save(self):
+        """test save()"""
+        # load from file
+        path = self.mktemp()
+        set_file(path, self.sample_01)
+        ht = apache.HtpasswdFile(path)
+
+        # make changes, check they saved
+        ht.delete("user1")
+        ht.delete("user2")
+        ht.save()
+        self.assertEqual(get_file(path), self.sample_02)
+
+        # test save w/ no path
+        hb = apache.HtpasswdFile(default_scheme="plaintext")
+        hb.set_password("user1", "pass1")
+        self.assertRaises(RuntimeError, hb.save)
+
+        # test save w/ explicit path
+        hb.save(path)
+        self.assertEqual(get_file(path), b"user1:pass1\n")
+
+    def test_07_encodings(self):
+        """test 'encoding' kwd"""
+        # test bad encodings cause failure in constructor
+        self.assertRaises(ValueError, apache.HtpasswdFile, encoding="utf-16")
+
+        # check sample utf-8
+        ht = apache.HtpasswdFile.from_string(self.sample_04_utf8, encoding="utf-8",
+                                             return_unicode=True)
+        self.assertEqual(ht.users(), [ u("user\u00e6") ])
+
+        # test deprecated encoding=None
+        with self.assertWarningList("``encoding=None`` is deprecated"):
+            ht = apache.HtpasswdFile.from_string(self.sample_04_utf8, encoding=None)
+        self.assertEqual(ht.users(), [ b'user\xc3\xa6' ])
+
+        # check sample latin-1
+        ht = apache.HtpasswdFile.from_string(self.sample_04_latin1,
+                                              encoding="latin-1", return_unicode=True)
+        self.assertEqual(ht.users(), [ u("user\u00e6") ])
+
+    def test_08_get_hash(self):
+        """test get_hash()"""
+        ht = apache.HtpasswdFile.from_string(self.sample_01)
+        self.assertEqual(ht.get_hash("user3"), b"{SHA}3ipNV1GrBtxPmHFC21fCbVCSXIo=")
+        self.assertEqual(ht.get_hash("user4"), b"pass4")
+        self.assertEqual(ht.get_hash("user5"), None)
+
+        with self.assertWarningList("find\(\) is deprecated"):
+            self.assertEqual(ht.find("user4"), b"pass4")
+
+    def test_09_to_string(self):
+        """test to_string"""
+
+        # check with known sample
+        ht = apache.HtpasswdFile.from_string(self.sample_01)
+        self.assertEqual(ht.to_string(), self.sample_01)
+
+        # test blank
+        ht = apache.HtpasswdFile()
+        self.assertEqual(ht.to_string(), b"")
+
+    def test_10_repr(self):
+        ht = apache.HtpasswdFile("fakepath", autosave=True, new=True, encoding="latin-1")
+        repr(ht)
+
+    def test_11_malformed(self):
+        self.assertRaises(ValueError, apache.HtpasswdFile.from_string,
+            b'realm:user1:pass1\n')
+        self.assertRaises(ValueError, apache.HtpasswdFile.from_string,
+            b'pass1\n')
+
+    def test_12_from_string(self):
+        # forbid path kwd
+        self.assertRaises(TypeError, apache.HtpasswdFile.from_string,
+                          b'', path=None)
+
+    def test_13_whitespace(self):
+        """whitespace & comment handling"""
+
+        # per htpasswd source (https://github.com/apache/httpd/blob/trunk/support/htpasswd.c),
+        # lines that match "^\s*(#.*)?$" should be ignored
+        source = to_bytes(
+            '\n'
+            'user2:pass2\n'
+            'user4:pass4\n'
+            'user7:pass7\r\n'
+            ' \t \n'
+            'user1:pass1\n'
+            ' # legacy users\n'
+            '#user6:pass6\n'
+            'user5:pass5\n\n'
+        )
+
+        # loading should see all users (except user6, who was commented out)
+        ht = apache.HtpasswdFile.from_string(source)
+        self.assertEqual(sorted(ht.users()), ["user1", "user2", "user4", "user5", "user7"])
+
+        # update existing user
+        ht.set_hash("user4", "althash4")
+        self.assertEqual(sorted(ht.users()), ["user1", "user2", "user4", "user5", "user7"])
+
+        # add a new user
+        ht.set_hash("user6", "althash6")
+        self.assertEqual(sorted(ht.users()), ["user1", "user2", "user4", "user5", "user6", "user7"])
+
+        # delete existing user
+        ht.delete("user7")
+        self.assertEqual(sorted(ht.users()), ["user1", "user2", "user4", "user5", "user6"])
+
+        # re-serialization should preserve whitespace
+        target = to_bytes(
+            '\n'
+            'user2:pass2\n'
+            'user4:althash4\n'
+            ' \t \n'
+            'user1:pass1\n'
+            ' # legacy users\n'
+            '#user6:pass6\n'
+            'user5:pass5\n'
+            'user6:althash6\n'
+        )
+        self.assertEqual(ht.to_string(), target)
+
+    @requires_htpasswd_cmd
+    def test_htpasswd_cmd_verify(self):
+        """
+        verify "htpasswd" command can read output
+        """
+        path = self.mktemp()
+        ht = apache.HtpasswdFile(path=path, new=True)
+
+        def hash_scheme(pwd, scheme):
+            return ht.context.handler(scheme).hash(pwd)
+
+        # base scheme
+        ht.set_hash("user1", hash_scheme("password","apr_md5_crypt"))
+
+        # 2.2-compat scheme
+        host_no_bcrypt = apache.htpasswd_defaults["host_apache_22"]
+        ht.set_hash("user2", hash_scheme("password", host_no_bcrypt))
+
+        # 2.4-compat scheme
+        host_best = apache.htpasswd_defaults["host"]
+        ht.set_hash("user3", hash_scheme("password", host_best))
+
+        # unsupported scheme -- should always fail to verify
+        ht.set_hash("user4", "$xxx$foo$bar$baz")
+
+        # make sure htpasswd properly recognizes hashes
+        ht.save()
+
+        self.assertFalse(_call_htpasswd_verify(path, "user1", "wrong"))
+        self.assertFalse(_call_htpasswd_verify(path, "user2", "wrong"))
+        self.assertFalse(_call_htpasswd_verify(path, "user3", "wrong"))
+        self.assertFalse(_call_htpasswd_verify(path, "user4", "wrong"))
+
+        self.assertTrue(_call_htpasswd_verify(path, "user1", "password"))
+        self.assertTrue(_call_htpasswd_verify(path, "user2", "password"))
+        self.assertTrue(_call_htpasswd_verify(path, "user3", "password"))
+
+    @requires_htpasswd_cmd
+    @unittest.skipUnless(registry.has_backend("bcrypt"), "bcrypt support required")
+    def test_htpasswd_cmd_verify_bcrypt(self):
+        """
+        verify "htpasswd" command can read bcrypt format
+
+        this tests for regression of issue 95, where we output "$2b$" instead of "$2y$";
+        fixed in v1.7.2.
+        """
+        path = self.mktemp()
+        ht = apache.HtpasswdFile(path=path, new=True)
+        def hash_scheme(pwd, scheme):
+            return ht.context.handler(scheme).hash(pwd)
+        ht.set_hash("user1", hash_scheme("password", "bcrypt"))
+        ht.save()
+        self.assertFalse(_call_htpasswd_verify(path, "user1", "wrong"))
+        if HAVE_HTPASSWD_BCRYPT:
+            self.assertTrue(_call_htpasswd_verify(path, "user1", "password"))
+        else:
+            # apache2.2 should fail, acting like it's an unknown hash format
+            self.assertFalse(_call_htpasswd_verify(path, "user1", "password"))
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# htdigest
+#=============================================================================
+class HtdigestFileTest(TestCase):
+    """test HtdigestFile class"""
+    descriptionPrefix = "HtdigestFile"
+
+    # sample with 4 users
+    sample_01 = (b'user2:realm:549d2a5f4659ab39a80dac99e159ab19\n'
+                 b'user3:realm:a500bb8c02f6a9170ae46af10c898744\n'
+                 b'user4:realm:ab7b5d5f28ccc7666315f508c7358519\n'
+                 b'user1:realm:2a6cf53e7d8f8cf39d946dc880b14128\n')
+
+    # sample 1 with user 1, 2 deleted; 4 changed
+    sample_02 = (b'user3:realm:a500bb8c02f6a9170ae46af10c898744\n'
+                 b'user4:realm:ab7b5d5f28ccc7666315f508c7358519\n')
+
+    # sample 1 with user2 updated, user 1 first entry removed, and user 5 added
+    sample_03 = (b'user2:realm:5ba6d8328943c23c64b50f8b29566059\n'
+                 b'user3:realm:a500bb8c02f6a9170ae46af10c898744\n'
+                 b'user4:realm:ab7b5d5f28ccc7666315f508c7358519\n'
+                 b'user1:realm:2a6cf53e7d8f8cf39d946dc880b14128\n'
+                 b'user5:realm:03c55fdc6bf71552356ad401bdb9af19\n')
+
+    # standalone sample with 8-bit username & realm
+    sample_04_utf8 = b'user\xc3\xa6:realm\xc3\xa6:549d2a5f4659ab39a80dac99e159ab19\n'
+    sample_04_latin1 = b'user\xe6:realm\xe6:549d2a5f4659ab39a80dac99e159ab19\n'
+
+    def test_00_constructor_autoload(self):
+        """test constructor autoload"""
+        # check with existing file
+        path = self.mktemp()
+        set_file(path, self.sample_01)
+        ht = apache.HtdigestFile(path)
+        self.assertEqual(ht.to_string(), self.sample_01)
+
+        # check without autoload
+        ht = apache.HtdigestFile(path, new=True)
+        self.assertEqual(ht.to_string(), b"")
+
+        # check missing file
+        os.remove(path)
+        self.assertRaises(IOError, apache.HtdigestFile, path)
+
+        # NOTE: default_realm option checked via other tests.
+
+    def test_01_delete(self):
+        """test delete()"""
+        ht = apache.HtdigestFile.from_string(self.sample_01)
+        self.assertTrue(ht.delete("user1", "realm"))
+        self.assertTrue(ht.delete("user2", "realm"))
+        self.assertFalse(ht.delete("user5", "realm"))
+        self.assertFalse(ht.delete("user3", "realm5"))
+        self.assertEqual(ht.to_string(), self.sample_02)
+
+        # invalid user
+        self.assertRaises(ValueError, ht.delete, "user:", "realm")
+
+        # invalid realm
+        self.assertRaises(ValueError, ht.delete, "user", "realm:")
+
+    def test_01_delete_autosave(self):
+        path = self.mktemp()
+        set_file(path, self.sample_01)
+
+        ht = apache.HtdigestFile(path)
+        self.assertTrue(ht.delete("user1", "realm"))
+        self.assertFalse(ht.delete("user3", "realm5"))
+        self.assertFalse(ht.delete("user5", "realm"))
+        self.assertEqual(get_file(path), self.sample_01)
+
+        ht.autosave = True
+        self.assertTrue(ht.delete("user2", "realm"))
+        self.assertEqual(get_file(path), self.sample_02)
+
+    def test_02_set_password(self):
+        """test update()"""
+        ht = apache.HtdigestFile.from_string(self.sample_01)
+        self.assertTrue(ht.set_password("user2", "realm", "pass2x"))
+        self.assertFalse(ht.set_password("user5", "realm", "pass5"))
+        self.assertEqual(ht.to_string(), self.sample_03)
+
+        # default realm
+        self.assertRaises(TypeError, ht.set_password, "user2", "pass3")
+        ht.default_realm = "realm2"
+        ht.set_password("user2", "pass3")
+        ht.check_password("user2", "realm2", "pass3")
+
+        # invalid user
+        self.assertRaises(ValueError, ht.set_password, "user:", "realm", "pass")
+        self.assertRaises(ValueError, ht.set_password, "u"*256, "realm", "pass")
+
+        # invalid realm
+        self.assertRaises(ValueError, ht.set_password, "user", "realm:", "pass")
+        self.assertRaises(ValueError, ht.set_password, "user", "r"*256, "pass")
+
+        # test that legacy update() still works
+        with self.assertWarningList("update\(\) is deprecated"):
+            ht.update("user2", "realm2", "test")
+        self.assertTrue(ht.check_password("user2", "test"))
+
+    # TODO: test set_password autosave
+
+    def test_03_users(self):
+        """test users()"""
+        ht = apache.HtdigestFile.from_string(self.sample_01)
+        ht.set_password("user5", "realm", "pass5")
+        ht.delete("user3", "realm")
+        ht.set_password("user3", "realm", "pass3")
+        self.assertEqual(sorted(ht.users("realm")), ["user1", "user2", "user3", "user4", "user5"])
+
+        self.assertRaises(TypeError, ht.users, 1)
+
+    def test_04_check_password(self):
+        """test check_password()"""
+        ht = apache.HtdigestFile.from_string(self.sample_01)
+        self.assertRaises(TypeError, ht.check_password, 1, 'realm', 'pass5')
+        self.assertRaises(TypeError, ht.check_password, 'user', 1, 'pass5')
+        self.assertIs(ht.check_password("user5", "realm","pass5"), None)
+        for i in irange(1,5):
+            i = str(i)
+            self.assertTrue(ht.check_password("user"+i, "realm", "pass"+i))
+            self.assertIs(ht.check_password("user"+i, "realm", "pass5"), False)
+
+        # default realm
+        self.assertRaises(TypeError, ht.check_password, "user5", "pass5")
+        ht.default_realm = "realm"
+        self.assertTrue(ht.check_password("user1", "pass1"))
+        self.assertIs(ht.check_password("user5", "pass5"), None)
+
+        # test that legacy verify() still works
+        with self.assertWarningList(["verify\(\) is deprecated"]*2):
+            self.assertTrue(ht.verify("user1", "realm", "pass1"))
+            self.assertFalse(ht.verify("user1", "realm", "pass2"))
+
+        # invalid user
+        self.assertRaises(ValueError, ht.check_password, "user:", "realm", "pass")
+
+    def test_05_load(self):
+        """test load()"""
+        # setup empty file
+        path = self.mktemp()
+        set_file(path, "")
+        backdate_file_mtime(path, 5)
+        ha = apache.HtdigestFile(path)
+        self.assertEqual(ha.to_string(), b"")
+
+        # make changes, check load_if_changed() does nothing
+        ha.set_password("user1", "realm", "pass1")
+        ha.load_if_changed()
+        self.assertEqual(ha.to_string(), b'user1:realm:2a6cf53e7d8f8cf39d946dc880b14128\n')
+
+        # change file
+        set_file(path, self.sample_01)
+        ha.load_if_changed()
+        self.assertEqual(ha.to_string(), self.sample_01)
+
+        # make changes, check load_if_changed overwrites them
+        ha.set_password("user5", "realm", "pass5")
+        ha.load()
+        self.assertEqual(ha.to_string(), self.sample_01)
+
+        # test load w/ no path
+        hb = apache.HtdigestFile()
+        self.assertRaises(RuntimeError, hb.load)
+        self.assertRaises(RuntimeError, hb.load_if_changed)
+
+        # test load w/ explicit path
+        hc = apache.HtdigestFile()
+        hc.load(path)
+        self.assertEqual(hc.to_string(), self.sample_01)
+
+        # change file, test deprecated force=False kwd
+        ensure_mtime_changed(path)
+        set_file(path, "")
+        with self.assertWarningList(r"load\(force=False\) is deprecated"):
+            ha.load(force=False)
+        self.assertEqual(ha.to_string(), b"")
+
+    def test_06_save(self):
+        """test save()"""
+        # load from file
+        path = self.mktemp()
+        set_file(path, self.sample_01)
+        ht = apache.HtdigestFile(path)
+
+        # make changes, check they saved
+        ht.delete("user1", "realm")
+        ht.delete("user2", "realm")
+        ht.save()
+        self.assertEqual(get_file(path), self.sample_02)
+
+        # test save w/ no path
+        hb = apache.HtdigestFile()
+        hb.set_password("user1", "realm", "pass1")
+        self.assertRaises(RuntimeError, hb.save)
+
+        # test save w/ explicit path
+        hb.save(path)
+        self.assertEqual(get_file(path), hb.to_string())
+
+    def test_07_realms(self):
+        """test realms() & delete_realm()"""
+        ht = apache.HtdigestFile.from_string(self.sample_01)
+
+        self.assertEqual(ht.delete_realm("x"), 0)
+        self.assertEqual(ht.realms(), ['realm'])
+
+        self.assertEqual(ht.delete_realm("realm"), 4)
+        self.assertEqual(ht.realms(), [])
+        self.assertEqual(ht.to_string(), b"")
+
+    def test_08_get_hash(self):
+        """test get_hash()"""
+        ht = apache.HtdigestFile.from_string(self.sample_01)
+        self.assertEqual(ht.get_hash("user3", "realm"), "a500bb8c02f6a9170ae46af10c898744")
+        self.assertEqual(ht.get_hash("user4", "realm"), "ab7b5d5f28ccc7666315f508c7358519")
+        self.assertEqual(ht.get_hash("user5", "realm"), None)
+
+        with self.assertWarningList("find\(\) is deprecated"):
+            self.assertEqual(ht.find("user4", "realm"), "ab7b5d5f28ccc7666315f508c7358519")
+
+    def test_09_encodings(self):
+        """test encoding parameter"""
+        # test bad encodings cause failure in constructor
+        self.assertRaises(ValueError, apache.HtdigestFile, encoding="utf-16")
+
+        # check sample utf-8
+        ht = apache.HtdigestFile.from_string(self.sample_04_utf8, encoding="utf-8", return_unicode=True)
+        self.assertEqual(ht.realms(), [ u("realm\u00e6") ])
+        self.assertEqual(ht.users(u("realm\u00e6")), [ u("user\u00e6") ])
+
+        # check sample latin-1
+        ht = apache.HtdigestFile.from_string(self.sample_04_latin1, encoding="latin-1", return_unicode=True)
+        self.assertEqual(ht.realms(), [ u("realm\u00e6") ])
+        self.assertEqual(ht.users(u("realm\u00e6")), [ u("user\u00e6") ])
+
+    def test_10_to_string(self):
+        """test to_string()"""
+
+        # check sample
+        ht = apache.HtdigestFile.from_string(self.sample_01)
+        self.assertEqual(ht.to_string(), self.sample_01)
+
+        # check blank
+        ht = apache.HtdigestFile()
+        self.assertEqual(ht.to_string(), b"")
+
+    def test_11_malformed(self):
+        self.assertRaises(ValueError, apache.HtdigestFile.from_string,
+            b'realm:user1:pass1:other\n')
+        self.assertRaises(ValueError, apache.HtdigestFile.from_string,
+            b'user1:pass1\n')
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_apps.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_apps.py
new file mode 100644
index 0000000..167437f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_apps.py
@@ -0,0 +1,139 @@
+"""test passlib.apps"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib import apps, hash as hashmod
+from passlib.tests.utils import TestCase
+# module
+
+#=============================================================================
+# test predefined app contexts
+#=============================================================================
+class AppsTest(TestCase):
+    """perform general tests to make sure contexts work"""
+    # NOTE: these tests are not really comprehensive,
+    #       since they would do little but duplicate
+    #       the presets in apps.py
+    #
+    #       they mainly try to ensure no typos
+    #       or dynamic behavior foul-ups.
+
+    def test_master_context(self):
+        ctx = apps.master_context
+        self.assertGreater(len(ctx.schemes()), 50)
+
+    def test_custom_app_context(self):
+        ctx = apps.custom_app_context
+        self.assertEqual(ctx.schemes(), ("sha512_crypt", "sha256_crypt"))
+        for hash in [
+            ('$6$rounds=41128$VoQLvDjkaZ6L6BIE$4pt.1Ll1XdDYduEwEYPCMOBiR6W6'
+                'znsyUEoNlcVXpv2gKKIbQolgmTGe6uEEVJ7azUxuc8Tf7zV9SD2z7Ij751'),
+            ('$5$rounds=31817$iZGmlyBQ99JSB5n6$p4E.pdPBWx19OajgjLRiOW0itGny'
+                 'xDGgMlDcOsfaI17'),
+        ]:
+            self.assertTrue(ctx.verify("test", hash))
+
+    def test_django16_context(self):
+        ctx = apps.django16_context
+        for hash in [
+            'pbkdf2_sha256$29000$ZsgquwnCyBs2$fBxRQpfKd2PIeMxtkKPy0h7SrnrN+EU/cm67aitoZ2s=',
+            'sha1$0d082$cdb462ae8b6be8784ef24b20778c4d0c82d5957f',
+            'md5$b887a$37767f8a745af10612ad44c80ff52e92',
+            'crypt$95a6d$95x74hLDQKXI2',
+            '098f6bcd4621d373cade4e832627b4f6',
+        ]:
+            self.assertTrue(ctx.verify("test", hash))
+
+        self.assertEqual(ctx.identify("!"), "django_disabled")
+        self.assertFalse(ctx.verify("test", "!"))
+
+    def test_django_context(self):
+        ctx = apps.django_context
+        for hash in [
+            'pbkdf2_sha256$29000$ZsgquwnCyBs2$fBxRQpfKd2PIeMxtkKPy0h7SrnrN+EU/cm67aitoZ2s=',
+        ]:
+            self.assertTrue(ctx.verify("test", hash))
+
+        self.assertEqual(ctx.identify("!"), "django_disabled")
+        self.assertFalse(ctx.verify("test", "!"))
+
+    def test_ldap_nocrypt_context(self):
+        ctx = apps.ldap_nocrypt_context
+        for hash in [
+            '{SSHA}cPusOzd6d5n3OjSVK3R329ZGCNyFcC7F',
+            'test',
+        ]:
+            self.assertTrue(ctx.verify("test", hash))
+
+        self.assertIs(ctx.identify('{CRYPT}$5$rounds=31817$iZGmlyBQ99JSB5'
+                'n6$p4E.pdPBWx19OajgjLRiOW0itGnyxDGgMlDcOsfaI17'), None)
+
+    def test_ldap_context(self):
+        ctx = apps.ldap_context
+        for hash in [
+            ('{CRYPT}$5$rounds=31817$iZGmlyBQ99JSB5n6$p4E.pdPBWx19OajgjLRiOW0'
+                'itGnyxDGgMlDcOsfaI17'),
+            '{SSHA}cPusOzd6d5n3OjSVK3R329ZGCNyFcC7F',
+            'test',
+        ]:
+            self.assertTrue(ctx.verify("test", hash))
+
+    def test_ldap_mysql_context(self):
+        ctx = apps.mysql_context
+        for hash in [
+            '*94BDCEBE19083CE2A1F959FD02F964C7AF4CFC29',
+            '378b243e220ca493',
+        ]:
+            self.assertTrue(ctx.verify("test", hash))
+
+    def test_postgres_context(self):
+        ctx = apps.postgres_context
+        hash = 'md55d9c68c6c50ed3d02a2fcf54f63993b6'
+        self.assertTrue(ctx.verify("test", hash, user='user'))
+
+    def test_phppass_context(self):
+        ctx = apps.phpass_context
+        for hash in [
+            '$P$8Ja1vJsKa5qyy/b3mCJGXM7GyBnt6..',
+            '$H$8b95CoYQnQ9Y6fSTsACyphNh5yoM02.',
+            '_cD..aBxeRhYFJvtUvsI',
+        ]:
+            self.assertTrue(ctx.verify("test", hash))
+
+        h1 = "$2a$04$yjDgE74RJkeqC0/1NheSSOrvKeu9IbKDpcQf/Ox3qsrRS/Kw42qIS"
+        if hashmod.bcrypt.has_backend():
+            self.assertTrue(ctx.verify("test", h1))
+            self.assertEqual(ctx.default_scheme(), "bcrypt")
+            self.assertEqual(ctx.handler().name, "bcrypt")
+        else:
+            self.assertEqual(ctx.identify(h1), "bcrypt")
+            self.assertEqual(ctx.default_scheme(), "phpass")
+            self.assertEqual(ctx.handler().name, "phpass")
+
+    def test_phpbb3_context(self):
+        ctx = apps.phpbb3_context
+        for hash in [
+            '$P$8Ja1vJsKa5qyy/b3mCJGXM7GyBnt6..',
+            '$H$8b95CoYQnQ9Y6fSTsACyphNh5yoM02.',
+        ]:
+            self.assertTrue(ctx.verify("test", hash))
+        self.assertTrue(ctx.hash("test").startswith("$H$"))
+
+    def test_roundup_context(self):
+        ctx = apps.roundup_context
+        for hash in [
+            '{PBKDF2}9849$JMTYu3eOUSoFYExprVVqbQ$N5.gV.uR1.BTgLSvi0qyPiRlGZ0',
+            '{SHA}a94a8fe5ccb19ba61c4c0873d391e987982fbbd3',
+            '{CRYPT}dptOmKDriOGfU',
+            '{plaintext}test',
+        ]:
+            self.assertTrue(ctx.verify("test", hash))
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_context.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_context.py
new file mode 100644
index 0000000..09b52c0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_context.py
@@ -0,0 +1,1786 @@
+"""tests for passlib.context"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from __future__ import with_statement
+from passlib.utils.compat import PY3
+if PY3:
+    from configparser import NoSectionError
+else:
+    from ConfigParser import NoSectionError
+import datetime
+from functools import partial
+import logging; log = logging.getLogger(__name__)
+import os
+import warnings
+# site
+# pkg
+from passlib import hash
+from passlib.context import CryptContext, LazyCryptContext
+from passlib.exc import PasslibConfigWarning, PasslibHashWarning
+from passlib.utils import tick, to_unicode
+from passlib.utils.compat import irange, u, unicode, str_to_uascii, PY2, PY26
+import passlib.utils.handlers as uh
+from passlib.tests.utils import (TestCase, set_file, TICK_RESOLUTION,
+                                 quicksleep, time_call, handler_derived_from)
+from passlib.registry import (register_crypt_handler_path,
+                        _has_crypt_handler as has_crypt_handler,
+                        _unload_handler_name as unload_handler_name,
+                        get_crypt_handler,
+                        )
+# local
+#=============================================================================
+# support
+#=============================================================================
+here = os.path.abspath(os.path.dirname(__file__))
+
+def merge_dicts(first, *args, **kwds):
+    target = first.copy()
+    for arg in args:
+        target.update(arg)
+    if kwds:
+        target.update(kwds)
+    return target
+
+#=============================================================================
+#
+#=============================================================================
+class CryptContextTest(TestCase):
+    descriptionPrefix = "CryptContext"
+
+    # TODO: these unittests could really use a good cleanup
+    # and reorganizing, to ensure they're getting everything.
+
+    #===================================================================
+    # sample configurations used in tests
+    #===================================================================
+
+    #---------------------------------------------------------------
+    # sample 1 - typical configuration
+    #---------------------------------------------------------------
+    sample_1_schemes = ["des_crypt", "md5_crypt", "bsdi_crypt", "sha512_crypt"]
+    sample_1_handlers = [get_crypt_handler(name) for name in sample_1_schemes]
+
+    sample_1_dict = dict(
+        schemes = sample_1_schemes,
+        default = "md5_crypt",
+        all__vary_rounds = 0.1,
+        bsdi_crypt__max_rounds = 30001,
+        bsdi_crypt__default_rounds = 25001,
+        sha512_crypt__max_rounds = 50000,
+        sha512_crypt__min_rounds = 40000,
+    )
+
+    sample_1_resolved_dict = merge_dicts(sample_1_dict,
+                                         schemes = sample_1_handlers)
+
+    sample_1_unnormalized = u("""\
+[passlib]
+schemes = des_crypt, md5_crypt, bsdi_crypt, sha512_crypt
+default = md5_crypt
+; this is using %...
+all__vary_rounds = 10%%
+bsdi_crypt__default_rounds = 25001
+bsdi_crypt__max_rounds = 30001
+sha512_crypt__max_rounds = 50000
+sha512_crypt__min_rounds = 40000
+""")
+
+    sample_1_unicode = u("""\
+[passlib]
+schemes = des_crypt, md5_crypt, bsdi_crypt, sha512_crypt
+default = md5_crypt
+all__vary_rounds = 0.1
+bsdi_crypt__default_rounds = 25001
+bsdi_crypt__max_rounds = 30001
+sha512_crypt__max_rounds = 50000
+sha512_crypt__min_rounds = 40000
+
+""")
+
+    #---------------------------------------------------------------
+    # sample 1 external files
+    #---------------------------------------------------------------
+
+    # sample 1 string with '\n' linesep
+    sample_1_path = os.path.join(here, "sample1.cfg")
+
+    # sample 1 with '\r\n' linesep
+    sample_1b_unicode = sample_1_unicode.replace(u("\n"), u("\r\n"))
+    sample_1b_path = os.path.join(here, "sample1b.cfg")
+
+    # sample 1 using UTF-16 and alt section
+    sample_1c_bytes = sample_1_unicode.replace(u("[passlib]"),
+                                               u("[mypolicy]")).encode("utf-16")
+    sample_1c_path = os.path.join(here, "sample1c.cfg")
+
+    # enable to regenerate sample files
+    if False:
+        set_file(sample_1_path, sample_1_unicode)
+        set_file(sample_1b_path, sample_1b_unicode)
+        set_file(sample_1c_path, sample_1c_bytes)
+
+    #---------------------------------------------------------------
+    # sample 2 & 12 - options patch
+    #---------------------------------------------------------------
+    sample_2_dict = dict(
+        # using this to test full replacement of existing options
+        bsdi_crypt__min_rounds = 29001,
+        bsdi_crypt__max_rounds = 35001,
+        bsdi_crypt__default_rounds = 31001,
+        # using this to test partial replacement of existing options
+        sha512_crypt__min_rounds=45000,
+    )
+
+    sample_2_unicode = """\
+[passlib]
+bsdi_crypt__min_rounds = 29001
+bsdi_crypt__max_rounds = 35001
+bsdi_crypt__default_rounds = 31001
+sha512_crypt__min_rounds = 45000
+"""
+
+    # sample 2 overlayed on top of sample 1
+    sample_12_dict = merge_dicts(sample_1_dict, sample_2_dict)
+
+    #---------------------------------------------------------------
+    # sample 3 & 123 - just changing default from sample 1
+    #---------------------------------------------------------------
+    sample_3_dict = dict(
+        default="sha512_crypt",
+    )
+
+    # sample 3 overlayed on 2 overlayed on 1
+    sample_123_dict = merge_dicts(sample_12_dict, sample_3_dict)
+
+    #---------------------------------------------------------------
+    # sample 4 - used by api tests
+    #---------------------------------------------------------------
+    sample_4_dict = dict(
+        schemes = [ "des_crypt", "md5_crypt", "phpass", "bsdi_crypt",
+                   "sha256_crypt"],
+        deprecated = [ "des_crypt", ],
+        default = "sha256_crypt",
+        bsdi_crypt__max_rounds = 31,
+        bsdi_crypt__default_rounds = 25,
+        bsdi_crypt__vary_rounds = 0,
+        sha256_crypt__max_rounds = 3000,
+        sha256_crypt__min_rounds = 2000,
+        sha256_crypt__default_rounds = 3000,
+        phpass__ident = "H",
+        phpass__default_rounds = 7,
+    )
+
+    #===================================================================
+    # setup
+    #===================================================================
+    def setUp(self):
+        super(CryptContextTest, self).setUp()
+        warnings.filterwarnings("ignore", "The 'all' scheme is deprecated.*")
+        warnings.filterwarnings("ignore", ".*'scheme' keyword is deprecated as of Passlib 1.7.*")
+
+    #===================================================================
+    # constructors
+    #===================================================================
+    def test_01_constructor(self):
+        """test class constructor"""
+
+        # test blank constructor works correctly
+        ctx = CryptContext()
+        self.assertEqual(ctx.to_dict(), {})
+
+        # test sample 1 with scheme=names
+        ctx = CryptContext(**self.sample_1_dict)
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # test sample 1 with scheme=handlers
+        ctx = CryptContext(**self.sample_1_resolved_dict)
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # test sample 2: options w/o schemes
+        ctx = CryptContext(**self.sample_2_dict)
+        self.assertEqual(ctx.to_dict(), self.sample_2_dict)
+
+        # test sample 3: default only
+        ctx = CryptContext(**self.sample_3_dict)
+        self.assertEqual(ctx.to_dict(), self.sample_3_dict)
+
+        # test unicode scheme names (issue 54)
+        ctx = CryptContext(schemes=[u("sha256_crypt")])
+        self.assertEqual(ctx.schemes(), ("sha256_crypt",))
+
+    def test_02_from_string(self):
+        """test from_string() constructor"""
+        # test sample 1 unicode
+        ctx = CryptContext.from_string(self.sample_1_unicode)
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # test sample 1 with unnormalized inputs
+        ctx = CryptContext.from_string(self.sample_1_unnormalized)
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # test sample 1 utf-8
+        ctx = CryptContext.from_string(self.sample_1_unicode.encode("utf-8"))
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # test sample 1 w/ '\r\n' linesep
+        ctx = CryptContext.from_string(self.sample_1b_unicode)
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # test sample 1 using UTF-16 and alt section
+        ctx = CryptContext.from_string(self.sample_1c_bytes, section="mypolicy",
+                                     encoding="utf-16")
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # test wrong type
+        self.assertRaises(TypeError, CryptContext.from_string, None)
+
+        # test missing section
+        self.assertRaises(NoSectionError, CryptContext.from_string,
+                          self.sample_1_unicode, section="fakesection")
+
+    def test_03_from_path(self):
+        """test from_path() constructor"""
+        # make sure sample files exist
+        if not os.path.exists(self.sample_1_path):
+            raise RuntimeError("can't find data file: %r" % self.sample_1_path)
+
+        # test sample 1
+        ctx = CryptContext.from_path(self.sample_1_path)
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # test sample 1 w/ '\r\n' linesep
+        ctx = CryptContext.from_path(self.sample_1b_path)
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # test sample 1 encoding using UTF-16 and alt section
+        ctx = CryptContext.from_path(self.sample_1c_path, section="mypolicy",
+                                     encoding="utf-16")
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # test missing file
+        self.assertRaises(EnvironmentError, CryptContext.from_path,
+                          os.path.join(here, "sample1xxx.cfg"))
+
+        # test missing section
+        self.assertRaises(NoSectionError, CryptContext.from_path,
+                          self.sample_1_path, section="fakesection")
+
+    def test_04_copy(self):
+        """test copy() method"""
+        cc1 = CryptContext(**self.sample_1_dict)
+
+        # overlay sample 2 onto copy
+        cc2 = cc1.copy(**self.sample_2_dict)
+        self.assertEqual(cc1.to_dict(), self.sample_1_dict)
+        self.assertEqual(cc2.to_dict(), self.sample_12_dict)
+
+        # check that repeating overlay makes no change
+        cc2b = cc2.copy(**self.sample_2_dict)
+        self.assertEqual(cc1.to_dict(), self.sample_1_dict)
+        self.assertEqual(cc2b.to_dict(), self.sample_12_dict)
+
+        # overlay sample 3 on copy
+        cc3 = cc2.copy(**self.sample_3_dict)
+        self.assertEqual(cc3.to_dict(), self.sample_123_dict)
+
+        # test empty copy creates separate copy
+        cc4 = cc1.copy()
+        self.assertIsNot(cc4, cc1)
+        self.assertEqual(cc1.to_dict(), self.sample_1_dict)
+        self.assertEqual(cc4.to_dict(), self.sample_1_dict)
+
+        # ... and that modifying copy doesn't affect original
+        cc4.update(**self.sample_2_dict)
+        self.assertEqual(cc1.to_dict(), self.sample_1_dict)
+        self.assertEqual(cc4.to_dict(), self.sample_12_dict)
+
+    def test_09_repr(self):
+        """test repr()"""
+        cc1 = CryptContext(**self.sample_1_dict)
+        # NOTE: "0x-1234" format used by Pyston 0.5.1 (support deprecated 2019-11)
+        self.assertRegex(repr(cc1), "^<CryptContext at 0x-?[0-9a-f]+>$")
+
+    #===================================================================
+    # modifiers
+    #===================================================================
+    def test_10_load(self):
+        """test load() / load_path() method"""
+        # NOTE: load() is the workhorse that handles all policy parsing,
+        # compilation, and validation. most of its features are tested
+        # elsewhere, since all the constructors and modifiers are just
+        # wrappers for it.
+
+        # source_type 'auto'
+        ctx = CryptContext()
+
+            # detect dict
+        ctx.load(self.sample_1_dict)
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+            # detect unicode string
+        ctx.load(self.sample_1_unicode)
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+            # detect bytes string
+        ctx.load(self.sample_1_unicode.encode("utf-8"))
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+            # anything else - TypeError
+        self.assertRaises(TypeError, ctx.load, None)
+
+        # NOTE: load_path() tested by from_path()
+        # NOTE: additional string tests done by from_string()
+
+        # update flag - tested by update() method tests
+        # encoding keyword - tested by from_string() & from_path()
+        # section keyword - tested by from_string() & from_path()
+
+        # test load empty
+        ctx = CryptContext(**self.sample_1_dict)
+        ctx.load({}, update=True)
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # multiple loads should clear the state
+        ctx = CryptContext()
+        ctx.load(self.sample_1_dict)
+        ctx.load(self.sample_2_dict)
+        self.assertEqual(ctx.to_dict(), self.sample_2_dict)
+
+    def test_11_load_rollback(self):
+        """test load() errors restore old state"""
+        # create initial context
+        cc = CryptContext(["des_crypt", "sha256_crypt"],
+            sha256_crypt__default_rounds=5000,
+            all__vary_rounds=0.1,
+            )
+        result = cc.to_string()
+
+        # do an update operation that should fail during parsing
+        # XXX: not sure what the right error type is here.
+        self.assertRaises(TypeError, cc.update, too__many__key__parts=True)
+        self.assertEqual(cc.to_string(), result)
+
+        # do an update operation that should fail during extraction
+        # FIXME: this isn't failing even in broken case, need to figure out
+        # way to ensure some keys come after this one.
+        self.assertRaises(KeyError, cc.update, fake_context_option=True)
+        self.assertEqual(cc.to_string(), result)
+
+        # do an update operation that should fail during compilation
+        self.assertRaises(ValueError, cc.update, sha256_crypt__min_rounds=10000)
+        self.assertEqual(cc.to_string(), result)
+
+    def test_12_update(self):
+        """test update() method"""
+
+        # empty overlay
+        ctx = CryptContext(**self.sample_1_dict)
+        ctx.update()
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+
+        # test basic overlay
+        ctx = CryptContext(**self.sample_1_dict)
+        ctx.update(**self.sample_2_dict)
+        self.assertEqual(ctx.to_dict(), self.sample_12_dict)
+
+        # ... and again
+        ctx.update(**self.sample_3_dict)
+        self.assertEqual(ctx.to_dict(), self.sample_123_dict)
+
+        # overlay w/ dict arg
+        ctx = CryptContext(**self.sample_1_dict)
+        ctx.update(self.sample_2_dict)
+        self.assertEqual(ctx.to_dict(), self.sample_12_dict)
+
+        # overlay w/ string
+        ctx = CryptContext(**self.sample_1_dict)
+        ctx.update(self.sample_2_unicode)
+        self.assertEqual(ctx.to_dict(), self.sample_12_dict)
+
+        # too many args
+        self.assertRaises(TypeError, ctx.update, {}, {})
+        self.assertRaises(TypeError, ctx.update, {}, schemes=['des_crypt'])
+
+        # wrong arg type
+        self.assertRaises(TypeError, ctx.update, None)
+
+    #===================================================================
+    # option parsing
+    #===================================================================
+    def test_20_options(self):
+        """test basic option parsing"""
+        def parse(**kwds):
+            return CryptContext(**kwds).to_dict()
+
+        #
+        # common option parsing tests
+        #
+
+        # test keys with blank fields are rejected
+            # blank option
+        self.assertRaises(TypeError, CryptContext, __=0.1)
+        self.assertRaises(TypeError, CryptContext, default__scheme__='x')
+
+            # blank scheme
+        self.assertRaises(TypeError, CryptContext, __option='x')
+        self.assertRaises(TypeError, CryptContext, default____option='x')
+
+            # blank category
+        self.assertRaises(TypeError, CryptContext, __scheme__option='x')
+
+        # test keys with too many field are rejected
+        self.assertRaises(TypeError, CryptContext,
+                          category__scheme__option__invalid = 30000)
+
+        # keys with mixed separators should be handled correctly.
+        # (testing actual data, not to_dict(), since re-render hid original bug)
+        self.assertRaises(KeyError, parse,
+                          **{"admin.context__schemes":"md5_crypt"})
+        ctx = CryptContext(**{"schemes":"md5_crypt,des_crypt",
+                              "admin.context__default":"des_crypt"})
+        self.assertEqual(ctx.default_scheme("admin"), "des_crypt")
+
+        #
+        # context option -specific tests
+        #
+
+        # test context option key parsing
+        result = dict(default="md5_crypt")
+        self.assertEqual(parse(default="md5_crypt"), result)
+        self.assertEqual(parse(context__default="md5_crypt"), result)
+        self.assertEqual(parse(default__context__default="md5_crypt"), result)
+        self.assertEqual(parse(**{"context.default":"md5_crypt"}), result)
+        self.assertEqual(parse(**{"default.context.default":"md5_crypt"}), result)
+
+        # test context option key parsing w/ category
+        result = dict(admin__context__default="md5_crypt")
+        self.assertEqual(parse(admin__context__default="md5_crypt"), result)
+        self.assertEqual(parse(**{"admin.context.default":"md5_crypt"}), result)
+
+        #
+        # hash option -specific tests
+        #
+
+        # test hash option key parsing
+        result = dict(all__vary_rounds=0.1)
+        self.assertEqual(parse(all__vary_rounds=0.1), result)
+        self.assertEqual(parse(default__all__vary_rounds=0.1), result)
+        self.assertEqual(parse(**{"all.vary_rounds":0.1}), result)
+        self.assertEqual(parse(**{"default.all.vary_rounds":0.1}), result)
+
+        # test hash option key parsing w/ category
+        result = dict(admin__all__vary_rounds=0.1)
+        self.assertEqual(parse(admin__all__vary_rounds=0.1), result)
+        self.assertEqual(parse(**{"admin.all.vary_rounds":0.1}), result)
+
+        # settings not allowed if not in hash.setting_kwds
+        ctx = CryptContext(["phpass", "md5_crypt"], phpass__ident="P")
+        self.assertRaises(KeyError, ctx.copy, md5_crypt__ident="P")
+
+        # hash options 'salt' and 'rounds' not allowed
+        self.assertRaises(KeyError, CryptContext, schemes=["des_crypt"],
+                                                  des_crypt__salt="xx")
+        self.assertRaises(KeyError, CryptContext, schemes=["des_crypt"],
+                                                  all__salt="xx")
+
+    def test_21_schemes(self):
+        """test 'schemes' context option parsing"""
+
+        # schemes can be empty
+        cc = CryptContext(schemes=None)
+        self.assertEqual(cc.schemes(), ())
+
+        # schemes can be list of names
+        cc = CryptContext(schemes=["des_crypt", "md5_crypt"])
+        self.assertEqual(cc.schemes(), ("des_crypt", "md5_crypt"))
+
+        # schemes can be comma-sep string
+        cc = CryptContext(schemes=" des_crypt, md5_crypt, ")
+        self.assertEqual(cc.schemes(), ("des_crypt", "md5_crypt"))
+
+        # schemes can be list of handlers
+        cc = CryptContext(schemes=[hash.des_crypt, hash.md5_crypt])
+        self.assertEqual(cc.schemes(), ("des_crypt", "md5_crypt"))
+
+        # scheme must be name or handler
+        self.assertRaises(TypeError, CryptContext, schemes=[uh.StaticHandler])
+
+        # handlers must have a name
+        class nameless(uh.StaticHandler):
+            name = None
+        self.assertRaises(ValueError, CryptContext, schemes=[nameless])
+
+        # names must be unique
+        class dummy_1(uh.StaticHandler):
+            name = 'dummy_1'
+        self.assertRaises(KeyError, CryptContext, schemes=[dummy_1, dummy_1])
+
+        # schemes not allowed per-category
+        self.assertRaises(KeyError, CryptContext,
+                          admin__context__schemes=["md5_crypt"])
+
+    def test_22_deprecated(self):
+        """test 'deprecated' context option parsing"""
+        def getdep(ctx, category=None):
+            return [name for name in ctx.schemes()
+                    if ctx.handler(name, category).deprecated]
+
+        # no schemes - all deprecated values allowed
+        cc = CryptContext(deprecated=["md5_crypt"])
+        cc.update(schemes=["md5_crypt", "des_crypt"])
+        self.assertEqual(getdep(cc),["md5_crypt"])
+
+        # deprecated values allowed if subset of schemes
+        cc = CryptContext(deprecated=["md5_crypt"], schemes=["md5_crypt", "des_crypt"])
+        self.assertEqual(getdep(cc), ["md5_crypt"])
+
+        # can be handler
+        # XXX: allow handlers in deprecated list? not for now.
+        self.assertRaises(TypeError, CryptContext, deprecated=[hash.md5_crypt],
+                          schemes=["md5_crypt", "des_crypt"])
+##        cc = CryptContext(deprecated=[hash.md5_crypt], schemes=["md5_crypt", "des_crypt"])
+##        self.assertEqual(getdep(cc), ["md5_crypt"])
+
+        # comma sep list
+        cc = CryptContext(deprecated="md5_crypt,des_crypt", schemes=["md5_crypt", "des_crypt", "sha256_crypt"])
+        self.assertEqual(getdep(cc), ["md5_crypt", "des_crypt"])
+
+        # values outside of schemes not allowed
+        self.assertRaises(KeyError, CryptContext, schemes=['des_crypt'],
+                                                  deprecated=['md5_crypt'])
+
+        # deprecating ALL schemes should cause ValueError
+        self.assertRaises(ValueError, CryptContext,
+                          schemes=['des_crypt'],
+                          deprecated=['des_crypt'])
+        self.assertRaises(ValueError, CryptContext,
+                          schemes=['des_crypt', 'md5_crypt'],
+                          admin__context__deprecated=['des_crypt', 'md5_crypt'])
+
+        # deprecating explicit default scheme should cause ValueError
+
+            # ... default listed as deprecated
+        self.assertRaises(ValueError, CryptContext,
+                          schemes=['des_crypt', 'md5_crypt'],
+                          default="md5_crypt",
+                          deprecated="md5_crypt")
+
+            # ... global default deprecated per-category
+        self.assertRaises(ValueError, CryptContext,
+                          schemes=['des_crypt', 'md5_crypt'],
+                          default="md5_crypt",
+                          admin__context__deprecated="md5_crypt")
+
+            # ... category default deprecated globally
+        self.assertRaises(ValueError, CryptContext,
+                          schemes=['des_crypt', 'md5_crypt'],
+                          admin__context__default="md5_crypt",
+                          deprecated="md5_crypt")
+
+            # ... category default deprecated in category
+        self.assertRaises(ValueError, CryptContext,
+                          schemes=['des_crypt', 'md5_crypt'],
+                          admin__context__default="md5_crypt",
+                          admin__context__deprecated="md5_crypt")
+
+        # category deplist should shadow default deplist
+        CryptContext(
+                          schemes=['des_crypt', 'md5_crypt'],
+                          deprecated="md5_crypt",
+                          admin__context__default="md5_crypt",
+                          admin__context__deprecated=[])
+
+        # wrong type
+        self.assertRaises(TypeError, CryptContext, deprecated=123)
+
+        # deprecated per-category
+        cc = CryptContext(deprecated=["md5_crypt"],
+                          schemes=["md5_crypt", "des_crypt"],
+                          admin__context__deprecated=["des_crypt"],
+                          )
+        self.assertEqual(getdep(cc), ["md5_crypt"])
+        self.assertEqual(getdep(cc, "user"), ["md5_crypt"])
+        self.assertEqual(getdep(cc, "admin"), ["des_crypt"])
+
+        # blank per-category deprecated list, shadowing default list
+        cc = CryptContext(deprecated=["md5_crypt"],
+                          schemes=["md5_crypt", "des_crypt"],
+                          admin__context__deprecated=[],
+                          )
+        self.assertEqual(getdep(cc), ["md5_crypt"])
+        self.assertEqual(getdep(cc, "user"), ["md5_crypt"])
+        self.assertEqual(getdep(cc, "admin"), [])
+
+    def test_23_default(self):
+        """test 'default' context option parsing"""
+
+        # anything allowed if no schemes
+        self.assertEqual(CryptContext(default="md5_crypt").to_dict(),
+                         dict(default="md5_crypt"))
+
+        # default allowed if in scheme list
+        ctx = CryptContext(default="md5_crypt", schemes=["des_crypt", "md5_crypt"])
+        self.assertEqual(ctx.default_scheme(), "md5_crypt")
+
+        # default can be handler
+        # XXX: sure we want to allow this ? maybe deprecate in future.
+        ctx = CryptContext(default=hash.md5_crypt, schemes=["des_crypt", "md5_crypt"])
+        self.assertEqual(ctx.default_scheme(), "md5_crypt")
+
+        # implicit default should be first non-deprecated scheme
+        ctx = CryptContext(schemes=["des_crypt", "md5_crypt"])
+        self.assertEqual(ctx.default_scheme(), "des_crypt")
+        ctx.update(deprecated="des_crypt")
+        self.assertEqual(ctx.default_scheme(), "md5_crypt")
+
+        # error if not in scheme list
+        self.assertRaises(KeyError, CryptContext, schemes=['des_crypt'],
+                                                  default='md5_crypt')
+
+        # wrong type
+        self.assertRaises(TypeError, CryptContext, default=1)
+
+        # per-category
+        ctx = CryptContext(default="des_crypt",
+                           schemes=["des_crypt", "md5_crypt"],
+                           admin__context__default="md5_crypt")
+        self.assertEqual(ctx.default_scheme(), "des_crypt")
+        self.assertEqual(ctx.default_scheme("user"), "des_crypt")
+        self.assertEqual(ctx.default_scheme("admin"), "md5_crypt")
+
+    def test_24_vary_rounds(self):
+        """test 'vary_rounds' hash option parsing"""
+        def parse(v):
+            return CryptContext(all__vary_rounds=v).to_dict()['all__vary_rounds']
+
+        # floats should be preserved
+        self.assertEqual(parse(0.1), 0.1)
+        self.assertEqual(parse('0.1'), 0.1)
+
+        # 'xx%' should be converted to float
+        self.assertEqual(parse('10%'), 0.1)
+
+        # ints should be preserved
+        self.assertEqual(parse(1000), 1000)
+        self.assertEqual(parse('1000'), 1000)
+
+    #===================================================================
+    # inspection & serialization
+    #===================================================================
+
+    def assertHandlerDerivedFrom(self, handler, base, msg=None):
+        self.assertTrue(handler_derived_from(handler, base), msg=msg)
+
+    def test_30_schemes(self):
+        """test schemes() method"""
+        # NOTE: also checked under test_21
+
+        # test empty
+        ctx = CryptContext()
+        self.assertEqual(ctx.schemes(), ())
+        self.assertEqual(ctx.schemes(resolve=True), ())
+
+        # test sample 1
+        ctx = CryptContext(**self.sample_1_dict)
+        self.assertEqual(ctx.schemes(), tuple(self.sample_1_schemes))
+        self.assertEqual(ctx.schemes(resolve=True, unconfigured=True), tuple(self.sample_1_handlers))
+        for result, correct in zip(ctx.schemes(resolve=True), self.sample_1_handlers):
+            self.assertTrue(handler_derived_from(result, correct))
+
+        # test sample 2
+        ctx = CryptContext(**self.sample_2_dict)
+        self.assertEqual(ctx.schemes(), ())
+
+    def test_31_default_scheme(self):
+        """test default_scheme() method"""
+        # NOTE: also checked under test_23
+
+        # test empty
+        ctx = CryptContext()
+        self.assertRaises(KeyError, ctx.default_scheme)
+
+        # test sample 1
+        ctx = CryptContext(**self.sample_1_dict)
+        self.assertEqual(ctx.default_scheme(), "md5_crypt")
+        self.assertEqual(ctx.default_scheme(resolve=True, unconfigured=True), hash.md5_crypt)
+        self.assertHandlerDerivedFrom(ctx.default_scheme(resolve=True), hash.md5_crypt)
+
+        # test sample 2
+        ctx = CryptContext(**self.sample_2_dict)
+        self.assertRaises(KeyError, ctx.default_scheme)
+
+        # test defaults to first in scheme
+        ctx = CryptContext(schemes=self.sample_1_schemes)
+        self.assertEqual(ctx.default_scheme(), "des_crypt")
+
+        # categories tested under test_23
+
+    def test_32_handler(self):
+        """test handler() method"""
+
+        # default for empty
+        ctx = CryptContext()
+        self.assertRaises(KeyError, ctx.handler)
+        self.assertRaises(KeyError, ctx.handler, "md5_crypt")
+
+        # default for sample 1
+        ctx = CryptContext(**self.sample_1_dict)
+        self.assertEqual(ctx.handler(unconfigured=True), hash.md5_crypt)
+        self.assertHandlerDerivedFrom(ctx.handler(), hash.md5_crypt)
+
+        # by name
+        self.assertEqual(ctx.handler("des_crypt", unconfigured=True), hash.des_crypt)
+        self.assertHandlerDerivedFrom(ctx.handler("des_crypt"), hash.des_crypt)
+
+        # name not in schemes
+        self.assertRaises(KeyError, ctx.handler, "mysql323")
+
+        # check handler() honors category default
+        ctx = CryptContext("sha256_crypt,md5_crypt", admin__context__default="md5_crypt")
+        self.assertEqual(ctx.handler(unconfigured=True), hash.sha256_crypt)
+        self.assertHandlerDerivedFrom(ctx.handler(), hash.sha256_crypt)
+
+        self.assertEqual(ctx.handler(category="staff", unconfigured=True), hash.sha256_crypt)
+        self.assertHandlerDerivedFrom(ctx.handler(category="staff"), hash.sha256_crypt)
+
+        self.assertEqual(ctx.handler(category="admin", unconfigured=True), hash.md5_crypt)
+        self.assertHandlerDerivedFrom(ctx.handler(category="staff"), hash.sha256_crypt)
+
+        # test unicode category strings are accepted under py2
+        if PY2:
+            self.assertEqual(ctx.handler(category=u("staff"), unconfigured=True), hash.sha256_crypt)
+            self.assertEqual(ctx.handler(category=u("admin"), unconfigured=True), hash.md5_crypt)
+
+    def test_33_options(self):
+        """test internal _get_record_options() method"""
+
+        def options(ctx, scheme, category=None):
+            return ctx._config._get_record_options_with_flag(scheme, category)[0]
+
+        # this checks that (3 schemes, 3 categories) inherit options correctly.
+        # the 'user' category is not present in the options.
+        cc4 = CryptContext(
+            truncate_error=True,
+            schemes = [ "sha512_crypt", "des_crypt", "bsdi_crypt"],
+            deprecated = ["sha512_crypt", "des_crypt"],
+            all__vary_rounds = 0.1,
+            bsdi_crypt__vary_rounds=0.2,
+            sha512_crypt__max_rounds = 20000,
+            admin__context__deprecated = [ "des_crypt", "bsdi_crypt" ],
+            admin__all__vary_rounds = 0.05,
+            admin__bsdi_crypt__vary_rounds=0.3,
+            admin__sha512_crypt__max_rounds = 40000,
+        )
+        self.assertEqual(cc4._config.categories, ("admin",))
+
+        #
+        # sha512_crypt
+        # NOTE: 'truncate_error' shouldn't be passed along...
+        #
+        self.assertEqual(options(cc4, "sha512_crypt"), dict(
+            deprecated=True,
+            vary_rounds=0.1, # inherited from all__
+            max_rounds=20000,
+        ))
+
+        self.assertEqual(options(cc4, "sha512_crypt", "user"), dict(
+            deprecated=True, # unconfigured category inherits from default
+            vary_rounds=0.1,
+            max_rounds=20000,
+        ))
+
+        self.assertEqual(options(cc4, "sha512_crypt", "admin"), dict(
+            # NOT deprecated - context option overridden per-category
+            vary_rounds=0.05, # global overridden per-cateogry
+            max_rounds=40000, # overridden per-category
+        ))
+
+        #
+        # des_crypt
+        # NOTE: vary_rounds shouldn't be passed along...
+        #
+        self.assertEqual(options(cc4, "des_crypt"), dict(
+            deprecated=True,
+            truncate_error=True,
+        ))
+
+        self.assertEqual(options(cc4, "des_crypt", "user"), dict(
+            deprecated=True, # unconfigured category inherits from default
+            truncate_error=True,
+        ))
+
+        self.assertEqual(options(cc4, "des_crypt", "admin"), dict(
+            deprecated=True, # unchanged though overidden
+            truncate_error=True,
+        ))
+
+        #
+        # bsdi_crypt
+        #
+        self.assertEqual(options(cc4, "bsdi_crypt"), dict(
+            vary_rounds=0.2, # overridden from all__vary_rounds
+        ))
+
+        self.assertEqual(options(cc4, "bsdi_crypt", "user"), dict(
+            vary_rounds=0.2, # unconfigured category inherits from default
+        ))
+
+        self.assertEqual(options(cc4, "bsdi_crypt", "admin"), dict(
+            vary_rounds=0.3,
+            deprecated=True, # deprecation set per-category
+        ))
+
+    def test_34_to_dict(self):
+        """test to_dict() method"""
+        # NOTE: this is tested all throughout this test case.
+        ctx = CryptContext(**self.sample_1_dict)
+        self.assertEqual(ctx.to_dict(), self.sample_1_dict)
+        self.assertEqual(ctx.to_dict(resolve=True), self.sample_1_resolved_dict)
+
+    def test_35_to_string(self):
+        """test to_string() method"""
+
+        # create ctx and serialize
+        ctx = CryptContext(**self.sample_1_dict)
+        dump = ctx.to_string()
+
+        # check ctx->string returns canonical format.
+        # NOTE: ConfigParser for PY26 doesn't use OrderedDict,
+        #       making to_string()'s ordering unpredictable...
+        #       so we skip this test under PY26.
+        if not PY26:
+            self.assertEqual(dump, self.sample_1_unicode)
+
+        # check ctx->string->ctx->dict returns original
+        ctx2 = CryptContext.from_string(dump)
+        self.assertEqual(ctx2.to_dict(), self.sample_1_dict)
+
+        # test section kwd is honored
+        other = ctx.to_string(section="password-security")
+        self.assertEqual(other, dump.replace("[passlib]","[password-security]"))
+
+        # test unmanaged handler warning
+        from passlib.tests.test_utils_handlers import UnsaltedHash
+        ctx3 = CryptContext([UnsaltedHash, "md5_crypt"])
+        dump = ctx3.to_string()
+        self.assertRegex(dump, r"# NOTE: the 'unsalted_test_hash' handler\(s\)"
+                               r" are not registered with Passlib")
+
+    #===================================================================
+    # password hash api
+    #===================================================================
+    nonstring_vectors =  [
+        (None, {}),
+        (None, {"scheme": "des_crypt"}),
+        (1, {}),
+        ((), {}),
+        ]
+
+    def test_40_basic(self):
+        """test basic hash/identify/verify functionality"""
+        handlers = [hash.md5_crypt, hash.des_crypt, hash.bsdi_crypt]
+        cc = CryptContext(handlers, bsdi_crypt__default_rounds=5)
+
+        # run through handlers
+        for crypt in handlers:
+            h = cc.hash("test", scheme=crypt.name)
+            self.assertEqual(cc.identify(h), crypt.name)
+            self.assertEqual(cc.identify(h, resolve=True, unconfigured=True), crypt)
+            self.assertHandlerDerivedFrom(cc.identify(h, resolve=True), crypt)
+            self.assertTrue(cc.verify('test', h))
+            self.assertFalse(cc.verify('notest', h))
+
+        # test default
+        h = cc.hash("test")
+        self.assertEqual(cc.identify(h), "md5_crypt")
+
+        # test genhash
+        h = cc.genhash('secret', cc.genconfig())
+        self.assertEqual(cc.identify(h), 'md5_crypt')
+
+        h = cc.genhash('secret', cc.genconfig(), scheme='md5_crypt')
+        self.assertEqual(cc.identify(h), 'md5_crypt')
+
+        self.assertRaises(ValueError, cc.genhash, 'secret', cc.genconfig(), scheme="des_crypt")
+
+    def test_41_genconfig(self):
+        """test genconfig() method"""
+        cc = CryptContext(schemes=["md5_crypt", "phpass"],
+                          phpass__ident="H",
+                          phpass__default_rounds=7,
+                          admin__phpass__ident="P",
+                         )
+
+        # uses default scheme
+        self.assertTrue(cc.genconfig().startswith("$1$"))
+
+        # override scheme
+        self.assertTrue(cc.genconfig(scheme="phpass").startswith("$H$5"))
+
+        # category override
+        self.assertTrue(cc.genconfig(scheme="phpass", category="admin").startswith("$P$5"))
+        self.assertTrue(cc.genconfig(scheme="phpass", category="staff").startswith("$H$5"))
+
+        # override scheme & custom settings
+        self.assertEqual(
+            cc.genconfig(scheme="phpass", salt='.'*8, rounds=8, ident='P'),
+            '$P$6........22zGEuacuPOqEpYPDeR0R/',  # NOTE: config string generated w/ rounds=1
+            )
+
+        #--------------------------------------------------------------
+        # border cases
+        #--------------------------------------------------------------
+
+        # test unicode category strings are accepted under py2
+        # this tests basic _get_record() used by hash/genhash/verify.
+        # we have to omit scheme=xxx so codepath is tested fully
+        if PY2:
+            c2 = cc.copy(default="phpass")
+            self.assertTrue(c2.genconfig(category=u("admin")).startswith("$P$5"))
+            self.assertTrue(c2.genconfig(category=u("staff")).startswith("$H$5"))
+
+        # throws error without schemes
+        self.assertRaises(KeyError, CryptContext().genconfig)
+        self.assertRaises(KeyError, CryptContext().genconfig, scheme='md5_crypt')
+
+        # bad scheme values
+        self.assertRaises(KeyError, cc.genconfig, scheme="fake") # XXX: should this be ValueError?
+        self.assertRaises(TypeError, cc.genconfig, scheme=1, category='staff')
+        self.assertRaises(TypeError, cc.genconfig, scheme=1)
+
+        # bad category values
+        self.assertRaises(TypeError, cc.genconfig, category=1)
+
+
+    def test_42_genhash(self):
+        """test genhash() method"""
+
+        #--------------------------------------------------------------
+        # border cases
+        #--------------------------------------------------------------
+
+        # rejects non-string secrets
+        cc = CryptContext(["des_crypt"])
+        hash = cc.hash('stub')
+        for secret, kwds in self.nonstring_vectors:
+            self.assertRaises(TypeError, cc.genhash, secret, hash, **kwds)
+
+        # rejects non-string config strings
+        cc = CryptContext(["des_crypt"])
+        for config, kwds in self.nonstring_vectors:
+            if hash is None:
+                # NOTE: as of 1.7, genhash is just wrapper for hash(),
+                #       and handles genhash(secret, None) fine.
+                continue
+            self.assertRaises(TypeError, cc.genhash, 'secret', config, **kwds)
+
+        # rejects config=None, even if default scheme lacks config string
+        cc = CryptContext(["mysql323"])
+        self.assertRaises(TypeError, cc.genhash, "stub", None)
+
+        # throws error without schemes
+        self.assertRaises(KeyError, CryptContext().genhash, 'secret', 'hash')
+
+        # bad scheme values
+        self.assertRaises(KeyError, cc.genhash, 'secret', hash, scheme="fake") # XXX: should this be ValueError?
+        self.assertRaises(TypeError, cc.genhash, 'secret', hash, scheme=1)
+
+        # bad category values
+        self.assertRaises(TypeError, cc.genconfig, 'secret', hash, category=1)
+
+    def test_43_hash(self,):
+        """test hash() method"""
+        # XXX: what more can we test here that isn't deprecated
+        #      or handled under another test (e.g. context kwds?)
+
+        # respects rounds
+        cc = CryptContext(**self.sample_4_dict)
+        hash = cc.hash("password")
+        self.assertTrue(hash.startswith("$5$rounds=3000$"))
+        self.assertTrue(cc.verify("password", hash))
+        self.assertFalse(cc.verify("passwordx", hash))
+
+        # make default > max throws error if attempted
+        # XXX: move this to copy() test?
+        self.assertRaises(ValueError, cc.copy,
+                          sha256_crypt__default_rounds=4000)
+
+        # rejects non-string secrets
+        cc = CryptContext(["des_crypt"])
+        for secret, kwds in self.nonstring_vectors:
+            self.assertRaises(TypeError, cc.hash, secret, **kwds)
+
+        # throws error without schemes
+        self.assertRaises(KeyError, CryptContext().hash, 'secret')
+
+        # bad category values
+        self.assertRaises(TypeError, cc.hash, 'secret', category=1)
+
+    def test_43_hash_legacy(self, use_16_legacy=False):
+        """test hash() method -- legacy 'scheme' and settings keywords"""
+        cc = CryptContext(**self.sample_4_dict)
+
+        # TODO: should migrate these tests elsewhere, or remove them.
+        #       can be replaced with following equivalent:
+        #
+        #       def wrapper(secret, scheme=None, category=None, **kwds):
+        #         handler = cc.handler(scheme, category)
+        #         if kwds:
+        #             handler = handler.using(**kwds)
+        #         return handler.hash(secret)
+        #
+        #       need to make sure bits being tested here are tested
+        #       under the tests for the equivalent methods called above,
+        #       and then discard the rest of these under 2.0.
+
+        # hash specific settings
+        with self.assertWarningList(["passing settings to.*is deprecated"]):
+            self.assertEqual(
+                cc.hash("password", scheme="phpass", salt='.'*8),
+                '$H$5........De04R5Egz0aq8Tf.1eVhY/',
+                )
+        with self.assertWarningList(["passing settings to.*is deprecated"]):
+            self.assertEqual(
+                cc.hash("password", scheme="phpass", salt='.'*8, ident="P"),
+                '$P$5........De04R5Egz0aq8Tf.1eVhY/',
+                )
+
+        # NOTE: more thorough job of rounds limits done below.
+
+        # min rounds
+        with self.assertWarningList(["passing settings to.*is deprecated"]):
+            self.assertEqual(
+                cc.hash("password", rounds=1999, salt="nacl"),
+                '$5$rounds=1999$nacl$nmfwJIxqj0csloAAvSER0B8LU0ERCAbhmMug4Twl609',
+                )
+
+        with self.assertWarningList(["passing settings to.*is deprecated"]):
+            self.assertEqual(
+                cc.hash("password", rounds=2001, salt="nacl"),
+                '$5$rounds=2001$nacl$8PdeoPL4aXQnJ0woHhqgIw/efyfCKC2WHneOpnvF.31'
+                )
+        # NOTE: max rounds, etc tested in genconfig()
+
+        # bad scheme values
+        self.assertRaises(KeyError, cc.hash, 'secret', scheme="fake") # XXX: should this be ValueError?
+        self.assertRaises(TypeError, cc.hash, 'secret', scheme=1)
+
+    def test_44_identify(self):
+        """test identify() border cases"""
+        handlers = ["md5_crypt", "des_crypt", "bsdi_crypt"]
+        cc = CryptContext(handlers, bsdi_crypt__default_rounds=5)
+
+        # check unknown hash
+        self.assertEqual(cc.identify('$9$232323123$1287319827'), None)
+        self.assertRaises(ValueError, cc.identify, '$9$232323123$1287319827', required=True)
+
+        #--------------------------------------------------------------
+        # border cases
+        #--------------------------------------------------------------
+
+        # rejects non-string hashes
+        cc = CryptContext(["des_crypt"])
+        for hash, kwds in self.nonstring_vectors:
+            self.assertRaises(TypeError, cc.identify, hash, **kwds)
+
+        # throws error without schemes
+        cc = CryptContext()
+        self.assertIs(cc.identify('hash'), None)
+        self.assertRaises(KeyError, cc.identify, 'hash', required=True)
+
+        # bad category values
+        self.assertRaises(TypeError, cc.identify, None, category=1)
+
+    def test_45_verify(self):
+        """test verify() scheme kwd"""
+        handlers = ["md5_crypt", "des_crypt", "bsdi_crypt"]
+        cc = CryptContext(handlers, bsdi_crypt__default_rounds=5)
+
+        h = hash.md5_crypt.hash("test")
+
+        # check base verify
+        self.assertTrue(cc.verify("test", h))
+        self.assertTrue(not cc.verify("notest", h))
+
+        # check verify using right alg
+        self.assertTrue(cc.verify('test', h, scheme='md5_crypt'))
+        self.assertTrue(not cc.verify('notest', h, scheme='md5_crypt'))
+
+        # check verify using wrong alg
+        self.assertRaises(ValueError, cc.verify, 'test', h, scheme='bsdi_crypt')
+
+        #--------------------------------------------------------------
+        # border cases
+        #--------------------------------------------------------------
+
+        # unknown hash should throw error
+        self.assertRaises(ValueError, cc.verify, 'stub', '$6$232323123$1287319827')
+
+        # rejects non-string secrets
+        cc = CryptContext(["des_crypt"])
+        h = refhash = cc.hash('stub')
+        for secret, kwds in self.nonstring_vectors:
+            self.assertRaises(TypeError, cc.verify, secret, h, **kwds)
+
+        # always treat hash=None as False
+        self.assertFalse(cc.verify(secret, None))
+
+        # rejects non-string hashes
+        cc = CryptContext(["des_crypt"])
+        for h, kwds in self.nonstring_vectors:
+            if h is None:
+                continue
+            self.assertRaises(TypeError, cc.verify, 'secret', h, **kwds)
+
+        # throws error without schemes
+        self.assertRaises(KeyError, CryptContext().verify, 'secret', 'hash')
+
+        # bad scheme values
+        self.assertRaises(KeyError, cc.verify, 'secret', refhash, scheme="fake") # XXX: should this be ValueError?
+        self.assertRaises(TypeError, cc.verify, 'secret', refhash, scheme=1)
+
+        # bad category values
+        self.assertRaises(TypeError, cc.verify, 'secret', refhash, category=1)
+
+    def test_46_needs_update(self):
+        """test needs_update() method"""
+        cc = CryptContext(**self.sample_4_dict)
+
+        # check deprecated scheme
+        self.assertTrue(cc.needs_update('9XXD4trGYeGJA'))
+        self.assertFalse(cc.needs_update('$1$J8HC2RCr$HcmM.7NxB2weSvlw2FgzU0'))
+
+        # check min rounds
+        self.assertTrue(cc.needs_update('$5$rounds=1999$jD81UCoo.zI.UETs$Y7qSTQ6mTiU9qZB4fRr43wRgQq4V.5AAf7F97Pzxey/'))
+        self.assertFalse(cc.needs_update('$5$rounds=2000$228SSRje04cnNCaQ$YGV4RYu.5sNiBvorQDlO0WWQjyJVGKBcJXz3OtyQ2u8'))
+
+        # check max rounds
+        self.assertFalse(cc.needs_update('$5$rounds=3000$fS9iazEwTKi7QPW4$VasgBC8FqlOvD7x2HhABaMXCTh9jwHclPA9j5YQdns.'))
+        self.assertTrue(cc.needs_update('$5$rounds=3001$QlFHHifXvpFX4PLs$/0ekt7lSs/lOikSerQ0M/1porEHxYq7W/2hdFpxA3fA'))
+
+        #--------------------------------------------------------------
+        # test hash.needs_update() interface
+        #--------------------------------------------------------------
+        check_state = []
+        class dummy(uh.StaticHandler):
+            name = 'dummy'
+            _hash_prefix = '@'
+
+            @classmethod
+            def needs_update(cls, hash, secret=None):
+                check_state.append((hash, secret))
+                return secret == "nu"
+
+            def _calc_checksum(self, secret):
+                from hashlib import md5
+                if isinstance(secret, unicode):
+                    secret = secret.encode("utf-8")
+                return str_to_uascii(md5(secret).hexdigest())
+
+        # calling needs_update should query callback
+        ctx = CryptContext([dummy])
+        hash = refhash = dummy.hash("test")
+        self.assertFalse(ctx.needs_update(hash))
+        self.assertEqual(check_state, [(hash,None)])
+        del check_state[:]
+
+        # now with a password
+        self.assertFalse(ctx.needs_update(hash, secret='bob'))
+        self.assertEqual(check_state, [(hash,'bob')])
+        del check_state[:]
+
+        # now when it returns True
+        self.assertTrue(ctx.needs_update(hash, secret='nu'))
+        self.assertEqual(check_state, [(hash,'nu')])
+        del check_state[:]
+
+        #--------------------------------------------------------------
+        # border cases
+        #--------------------------------------------------------------
+
+        # rejects non-string hashes
+        cc = CryptContext(["des_crypt"])
+        for hash, kwds in self.nonstring_vectors:
+            self.assertRaises(TypeError, cc.needs_update, hash, **kwds)
+
+        # throws error without schemes
+        self.assertRaises(KeyError, CryptContext().needs_update, 'hash')
+
+        # bad scheme values
+        self.assertRaises(KeyError, cc.needs_update, refhash, scheme="fake") # XXX: should this be ValueError?
+        self.assertRaises(TypeError, cc.needs_update, refhash, scheme=1)
+
+        # bad category values
+        self.assertRaises(TypeError, cc.needs_update, refhash, category=1)
+
+    def test_47_verify_and_update(self):
+        """test verify_and_update()"""
+        cc = CryptContext(**self.sample_4_dict)
+
+        # create some hashes
+        h1 = cc.handler("des_crypt").hash("password")
+        h2 = cc.handler("sha256_crypt").hash("password")
+
+        # check bad password, deprecated hash
+        ok, new_hash = cc.verify_and_update("wrongpass", h1)
+        self.assertFalse(ok)
+        self.assertIs(new_hash, None)
+
+        # check bad password, good hash
+        ok, new_hash = cc.verify_and_update("wrongpass", h2)
+        self.assertFalse(ok)
+        self.assertIs(new_hash, None)
+
+        # check right password, deprecated hash
+        ok, new_hash = cc.verify_and_update("password", h1)
+        self.assertTrue(ok)
+        self.assertTrue(cc.identify(new_hash), "sha256_crypt")
+
+        # check right password, good hash
+        ok, new_hash = cc.verify_and_update("password", h2)
+        self.assertTrue(ok)
+        self.assertIs(new_hash, None)
+
+        #--------------------------------------------------------------
+        # border cases
+        #--------------------------------------------------------------
+
+        # rejects non-string secrets
+        cc = CryptContext(["des_crypt"])
+        hash = refhash = cc.hash('stub')
+        for secret, kwds in self.nonstring_vectors:
+            self.assertRaises(TypeError, cc.verify_and_update, secret, hash, **kwds)
+
+        # always treat hash=None as False
+        self.assertEqual(cc.verify_and_update(secret, None), (False, None))
+
+        # rejects non-string hashes
+        cc = CryptContext(["des_crypt"])
+        for hash, kwds in self.nonstring_vectors:
+            if hash is None:
+                continue
+            self.assertRaises(TypeError, cc.verify_and_update, 'secret', hash, **kwds)
+
+        # throws error without schemes
+        self.assertRaises(KeyError, CryptContext().verify_and_update, 'secret', 'hash')
+
+        # bad scheme values
+        self.assertRaises(KeyError, cc.verify_and_update, 'secret', refhash, scheme="fake") # XXX: should this be ValueError?
+        self.assertRaises(TypeError, cc.verify_and_update, 'secret', refhash, scheme=1)
+
+        # bad category values
+        self.assertRaises(TypeError, cc.verify_and_update, 'secret', refhash, category=1)
+
+    def test_48_context_kwds(self):
+        """hash(), verify(), and verify_and_update() -- discard unused context keywords"""
+
+        # setup test case
+        # NOTE: postgres_md5 hash supports 'user' context kwd, which is used for this test.
+        from passlib.hash import des_crypt, md5_crypt, postgres_md5
+        des_hash = des_crypt.hash("stub")
+        pg_root_hash = postgres_md5.hash("stub", user="root")
+        pg_admin_hash = postgres_md5.hash("stub", user="admin")
+
+        #------------------------------------------------------------
+        # case 1: contextual kwds not supported by any hash in CryptContext
+        #------------------------------------------------------------
+        cc1 = CryptContext([des_crypt, md5_crypt])
+        self.assertEqual(cc1.context_kwds, set())
+
+        # des_scrypt should work w/o any contextual kwds
+        self.assertTrue(des_crypt.identify(cc1.hash("stub")), "des_crypt")
+        self.assertTrue(cc1.verify("stub", des_hash))
+        self.assertEqual(cc1.verify_and_update("stub", des_hash), (True, None))
+
+        # des_crypt should throw error due to unknown context keyword
+        with self.assertWarningList(["passing settings to.*is deprecated"]):
+            self.assertRaises(TypeError, cc1.hash, "stub", user="root")
+        self.assertRaises(TypeError, cc1.verify, "stub", des_hash, user="root")
+        self.assertRaises(TypeError, cc1.verify_and_update, "stub", des_hash, user="root")
+
+        #------------------------------------------------------------
+        # case 2: at least one contextual kwd supported by non-default hash
+        #------------------------------------------------------------
+        cc2 = CryptContext([des_crypt, postgres_md5])
+        self.assertEqual(cc2.context_kwds, set(["user"]))
+
+        # verify des_crypt works w/o "user" kwd
+        self.assertTrue(des_crypt.identify(cc2.hash("stub")), "des_crypt")
+        self.assertTrue(cc2.verify("stub", des_hash))
+        self.assertEqual(cc2.verify_and_update("stub", des_hash), (True, None))
+
+        # verify des_crypt ignores "user" kwd
+        self.assertTrue(des_crypt.identify(cc2.hash("stub", user="root")), "des_crypt")
+        self.assertTrue(cc2.verify("stub", des_hash, user="root"))
+        self.assertEqual(cc2.verify_and_update("stub", des_hash, user="root"), (True, None))
+
+        # verify error with unknown kwd
+        with self.assertWarningList(["passing settings to.*is deprecated"]):
+            self.assertRaises(TypeError, cc2.hash, "stub", badkwd="root")
+        self.assertRaises(TypeError, cc2.verify, "stub", des_hash, badkwd="root")
+        self.assertRaises(TypeError, cc2.verify_and_update, "stub", des_hash, badkwd="root")
+
+        #------------------------------------------------------------
+        # case 3: at least one contextual kwd supported by default hash
+        #------------------------------------------------------------
+        cc3 = CryptContext([postgres_md5, des_crypt], deprecated="auto")
+        self.assertEqual(cc3.context_kwds, set(["user"]))
+
+        # postgres_md5 should have error w/o context kwd
+        self.assertRaises(TypeError, cc3.hash, "stub")
+        self.assertRaises(TypeError, cc3.verify, "stub", pg_root_hash)
+        self.assertRaises(TypeError, cc3.verify_and_update, "stub", pg_root_hash)
+
+        # postgres_md5 should work w/ context kwd
+        self.assertEqual(cc3.hash("stub", user="root"), pg_root_hash)
+        self.assertTrue(cc3.verify("stub", pg_root_hash, user="root"))
+        self.assertEqual(cc3.verify_and_update("stub", pg_root_hash, user="root"), (True, None))
+
+        # verify_and_update() should fail against wrong user
+        self.assertEqual(cc3.verify_and_update("stub", pg_root_hash, user="admin"), (False, None))
+
+        # verify_and_update() should pass all context kwds through when rehashing
+        self.assertEqual(cc3.verify_and_update("stub", des_hash, user="root"),
+                         (True, pg_root_hash))
+
+    #===================================================================
+    # rounds options
+    #===================================================================
+
+    # TODO: now that rounds generation has moved out of _CryptRecord to HasRounds,
+    #       this should just test that we're passing right options to handler.using(),
+    #       and that resulting handler has right settings.
+    #       Can then just let HasRounds tests (which are a copy of this) deal with things.
+
+    # NOTE: the follow tests check how _CryptRecord handles
+    # the min/max/default/vary_rounds options, via the output of
+    # genconfig(). it's assumed hash() takes the same codepath.
+
+    def test_50_rounds_limits(self):
+        """test rounds limits"""
+        cc = CryptContext(schemes=["sha256_crypt"],
+                          sha256_crypt__min_rounds=2000,
+                          sha256_crypt__max_rounds=3000,
+                          sha256_crypt__default_rounds=2500,
+                          )
+
+        # stub digest returned by sha256_crypt's genconfig calls..
+        STUB = '...........................................'
+
+        #--------------------------------------------------
+        # settings should have been applied to custom handler,
+        # it should take care of the rest
+        #--------------------------------------------------
+        custom_handler = cc._get_record("sha256_crypt", None)
+        self.assertEqual(custom_handler.min_desired_rounds, 2000)
+        self.assertEqual(custom_handler.max_desired_rounds, 3000)
+        self.assertEqual(custom_handler.default_rounds, 2500)
+
+        #--------------------------------------------------
+        # min_rounds
+        #--------------------------------------------------
+
+        # set below handler minimum
+        with self.assertWarningList([PasslibHashWarning]*2):
+            c2 = cc.copy(sha256_crypt__min_rounds=500, sha256_crypt__max_rounds=None,
+                            sha256_crypt__default_rounds=500)
+        self.assertEqual(c2.genconfig(salt="nacl"), "$5$rounds=1000$nacl$" + STUB)
+
+        # below policy minimum
+        # NOTE: formerly issued a warning in passlib 1.6, now just a wrapper for .replace()
+        with self.assertWarningList([]):
+            self.assertEqual(
+                cc.genconfig(rounds=1999, salt="nacl"), '$5$rounds=1999$nacl$' + STUB)
+
+        # equal to policy minimum
+        self.assertEqual(
+            cc.genconfig(rounds=2000, salt="nacl"), '$5$rounds=2000$nacl$' + STUB)
+
+        # above policy minimum
+        self.assertEqual(
+            cc.genconfig(rounds=2001, salt="nacl"), '$5$rounds=2001$nacl$' + STUB)
+
+        #--------------------------------------------------
+        # max rounds
+        #--------------------------------------------------
+
+        # set above handler max
+        with self.assertWarningList([PasslibHashWarning]*2):
+            c2 = cc.copy(sha256_crypt__max_rounds=int(1e9)+500, sha256_crypt__min_rounds=None,
+                            sha256_crypt__default_rounds=int(1e9)+500)
+
+        self.assertEqual(c2.genconfig(salt="nacl"), "$5$rounds=999999999$nacl$" + STUB)
+
+        # above policy max
+        # NOTE: formerly issued a warning in passlib 1.6, now just a wrapper for .using()
+        with self.assertWarningList([]):
+            self.assertEqual(
+                cc.genconfig(rounds=3001, salt="nacl"), '$5$rounds=3001$nacl$' + STUB)
+
+        # equal policy max
+        self.assertEqual(
+            cc.genconfig(rounds=3000, salt="nacl"), '$5$rounds=3000$nacl$' + STUB)
+
+        # below policy max
+        self.assertEqual(
+            cc.genconfig(rounds=2999, salt="nacl"), '$5$rounds=2999$nacl$' + STUB)
+
+        #--------------------------------------------------
+        # default_rounds
+        #--------------------------------------------------
+
+        # explicit default rounds
+        self.assertEqual(cc.genconfig(salt="nacl"), '$5$rounds=2500$nacl$' + STUB)
+
+        # fallback default rounds - use handler's
+        df = hash.sha256_crypt.default_rounds
+        c2 = cc.copy(sha256_crypt__default_rounds=None, sha256_crypt__max_rounds=df<<1)
+        self.assertEqual(c2.genconfig(salt="nacl"), '$5$rounds=%d$nacl$%s' % (df, STUB))
+
+        # fallback default rounds - use handler's, but clipped to max rounds
+        c2 = cc.copy(sha256_crypt__default_rounds=None, sha256_crypt__max_rounds=3000)
+        self.assertEqual(c2.genconfig(salt="nacl"), '$5$rounds=3000$nacl$' + STUB)
+
+        # TODO: test default falls back to mx / mn if handler has no default.
+
+        # default rounds - out of bounds
+        self.assertRaises(ValueError, cc.copy, sha256_crypt__default_rounds=1999)
+        cc.copy(sha256_crypt__default_rounds=2000)
+        cc.copy(sha256_crypt__default_rounds=3000)
+        self.assertRaises(ValueError, cc.copy, sha256_crypt__default_rounds=3001)
+
+        #--------------------------------------------------
+        # border cases
+        #--------------------------------------------------
+
+        # invalid min/max bounds
+        c2 = CryptContext(schemes=["sha256_crypt"])
+        # NOTE: as of v1.7, these are clipped w/ a warning instead...
+        # self.assertRaises(ValueError, c2.copy, sha256_crypt__min_rounds=-1)
+        # self.assertRaises(ValueError, c2.copy, sha256_crypt__max_rounds=-1)
+        self.assertRaises(ValueError, c2.copy, sha256_crypt__min_rounds=2000,
+                          sha256_crypt__max_rounds=1999)
+
+        # test bad values
+        self.assertRaises(ValueError, CryptContext, sha256_crypt__min_rounds='x')
+        self.assertRaises(ValueError, CryptContext, sha256_crypt__max_rounds='x')
+        self.assertRaises(ValueError, CryptContext, all__vary_rounds='x')
+        self.assertRaises(ValueError, CryptContext, sha256_crypt__default_rounds='x')
+
+        # test bad types rejected
+        bad = datetime.datetime.now()  # picked cause can't be compared to int
+        self.assertRaises(TypeError, CryptContext, "sha256_crypt", sha256_crypt__min_rounds=bad)
+        self.assertRaises(TypeError, CryptContext, "sha256_crypt", sha256_crypt__max_rounds=bad)
+        self.assertRaises(TypeError, CryptContext, "sha256_crypt", all__vary_rounds=bad)
+        self.assertRaises(TypeError, CryptContext, "sha256_crypt", sha256_crypt__default_rounds=bad)
+
+    def test_51_linear_vary_rounds(self):
+        """test linear vary rounds"""
+        cc = CryptContext(schemes=["sha256_crypt"],
+                          sha256_crypt__min_rounds=1995,
+                          sha256_crypt__max_rounds=2005,
+                          sha256_crypt__default_rounds=2000,
+                          )
+
+        # test negative
+        self.assertRaises(ValueError, cc.copy, all__vary_rounds=-1)
+        self.assertRaises(ValueError, cc.copy, all__vary_rounds="-1%")
+        self.assertRaises(ValueError, cc.copy, all__vary_rounds="101%")
+
+        # test static
+        c2 = cc.copy(all__vary_rounds=0)
+        self.assertEqual(c2._get_record("sha256_crypt", None).vary_rounds, 0)
+        self.assert_rounds_range(c2, "sha256_crypt", 2000, 2000)
+
+        c2 = cc.copy(all__vary_rounds="0%")
+        self.assertEqual(c2._get_record("sha256_crypt", None).vary_rounds, 0)
+        self.assert_rounds_range(c2, "sha256_crypt", 2000, 2000)
+
+        # test absolute
+        c2 = cc.copy(all__vary_rounds=1)
+        self.assertEqual(c2._get_record("sha256_crypt", None).vary_rounds, 1)
+        self.assert_rounds_range(c2, "sha256_crypt", 1999, 2001)
+        c2 = cc.copy(all__vary_rounds=100)
+        self.assertEqual(c2._get_record("sha256_crypt", None).vary_rounds, 100)
+        self.assert_rounds_range(c2, "sha256_crypt", 1995, 2005)
+
+        # test relative
+        c2 = cc.copy(all__vary_rounds="0.1%")
+        self.assertEqual(c2._get_record("sha256_crypt", None).vary_rounds, 0.001)
+        self.assert_rounds_range(c2, "sha256_crypt", 1998, 2002)
+        c2 = cc.copy(all__vary_rounds="100%")
+        self.assertEqual(c2._get_record("sha256_crypt", None).vary_rounds, 1.0)
+        self.assert_rounds_range(c2, "sha256_crypt", 1995, 2005)
+
+    def test_52_log2_vary_rounds(self):
+        """test log2 vary rounds"""
+        cc = CryptContext(schemes=["bcrypt"],
+                          bcrypt__min_rounds=15,
+                          bcrypt__max_rounds=25,
+                          bcrypt__default_rounds=20,
+                          )
+
+        # test negative
+        self.assertRaises(ValueError, cc.copy, all__vary_rounds=-1)
+        self.assertRaises(ValueError, cc.copy, all__vary_rounds="-1%")
+        self.assertRaises(ValueError, cc.copy, all__vary_rounds="101%")
+
+        # test static
+        c2 = cc.copy(all__vary_rounds=0)
+        self.assertEqual(c2._get_record("bcrypt", None).vary_rounds, 0)
+        self.assert_rounds_range(c2, "bcrypt", 20, 20)
+
+        c2 = cc.copy(all__vary_rounds="0%")
+        self.assertEqual(c2._get_record("bcrypt", None).vary_rounds, 0)
+        self.assert_rounds_range(c2, "bcrypt", 20, 20)
+
+        # test absolute
+        c2 = cc.copy(all__vary_rounds=1)
+        self.assertEqual(c2._get_record("bcrypt", None).vary_rounds, 1)
+        self.assert_rounds_range(c2, "bcrypt", 19, 21)
+        c2 = cc.copy(all__vary_rounds=100)
+        self.assertEqual(c2._get_record("bcrypt", None).vary_rounds, 100)
+        self.assert_rounds_range(c2, "bcrypt", 15, 25)
+
+        # test relative - should shift over at 50% mark
+        c2 = cc.copy(all__vary_rounds="1%")
+        self.assertEqual(c2._get_record("bcrypt", None).vary_rounds, 0.01)
+        self.assert_rounds_range(c2, "bcrypt", 20, 20)
+
+        c2 = cc.copy(all__vary_rounds="49%")
+        self.assertEqual(c2._get_record("bcrypt", None).vary_rounds, 0.49)
+        self.assert_rounds_range(c2, "bcrypt", 20, 20)
+
+        c2 = cc.copy(all__vary_rounds="50%")
+        self.assertEqual(c2._get_record("bcrypt", None).vary_rounds, 0.5)
+        self.assert_rounds_range(c2, "bcrypt", 19, 20)
+
+        c2 = cc.copy(all__vary_rounds="100%")
+        self.assertEqual(c2._get_record("bcrypt", None).vary_rounds, 1.0)
+        self.assert_rounds_range(c2, "bcrypt", 15, 21)
+
+    def assert_rounds_range(self, context, scheme, lower, upper):
+        """helper to check vary_rounds covers specified range"""
+        # NOTE: this runs enough times the min and max *should* be hit,
+        # though there's a faint chance it will randomly fail.
+        handler = context.handler(scheme)
+        salt = handler.default_salt_chars[0:1] * handler.max_salt_size
+        seen = set()
+        for i in irange(300):
+            h = context.genconfig(scheme, salt=salt)
+            r = handler.from_string(h).rounds
+            seen.add(r)
+        self.assertEqual(min(seen), lower, "vary_rounds had wrong lower limit:")
+        self.assertEqual(max(seen), upper, "vary_rounds had wrong upper limit:")
+
+    #===================================================================
+    # harden_verify / min_verify_time
+    #===================================================================
+    def test_harden_verify_parsing(self):
+        """harden_verify -- parsing"""
+        warnings.filterwarnings("ignore", ".*harden_verify.*",
+                                category=DeprecationWarning)
+
+        # valid values
+        ctx = CryptContext(schemes=["sha256_crypt"])
+        self.assertEqual(ctx.harden_verify, None)
+        self.assertEqual(ctx.using(harden_verify="").harden_verify, None)
+        self.assertEqual(ctx.using(harden_verify="true").harden_verify, None)
+        self.assertEqual(ctx.using(harden_verify="false").harden_verify, None)
+
+    def test_dummy_verify(self):
+        """
+        dummy_verify() method
+        """
+        # check dummy_verify() takes expected time
+        expected = 0.05
+        accuracy = 0.2
+        handler = DelayHash.using()
+        handler.delay = expected
+        ctx = CryptContext(schemes=[handler])
+        ctx.dummy_verify()  # prime the memoized helpers
+        elapsed, _ = time_call(ctx.dummy_verify)
+        self.assertAlmostEqual(elapsed, expected, delta=expected * accuracy)
+
+        # TODO: test dummy_verify() invoked by .verify() when hash is None,
+        #       and same for .verify_and_update()
+
+    #===================================================================
+    # feature tests
+    #===================================================================
+    def test_61_autodeprecate(self):
+        """test deprecated='auto' is handled correctly"""
+
+        def getstate(ctx, category=None):
+            return [ctx.handler(scheme, category).deprecated for scheme in ctx.schemes()]
+
+        # correctly reports default
+        ctx = CryptContext("sha256_crypt,md5_crypt,des_crypt", deprecated="auto")
+        self.assertEqual(getstate(ctx,    None), [False, True, True])
+        self.assertEqual(getstate(ctx, "admin"), [False, True, True])
+
+        # correctly reports changed default
+        ctx.update(default="md5_crypt")
+        self.assertEqual(getstate(ctx,    None), [True, False, True])
+        self.assertEqual(getstate(ctx, "admin"), [True, False, True])
+
+        # category default is handled correctly
+        ctx.update(admin__context__default="des_crypt")
+        self.assertEqual(getstate(ctx,    None), [True, False, True])
+        self.assertEqual(getstate(ctx, "admin"), [True, True, False])
+
+        # handles 1 scheme
+        ctx = CryptContext(["sha256_crypt"], deprecated="auto")
+        self.assertEqual(getstate(ctx,    None), [False])
+        self.assertEqual(getstate(ctx, "admin"), [False])
+
+        # disallow auto & other deprecated schemes at same time.
+        self.assertRaises(ValueError, CryptContext, "sha256_crypt,md5_crypt",
+                          deprecated="auto,md5_crypt")
+        self.assertRaises(ValueError, CryptContext, "sha256_crypt,md5_crypt",
+                          deprecated="md5_crypt,auto")
+
+    def test_disabled_hashes(self):
+        """disabled hash support"""
+        #
+        # init ref info
+        #
+        from passlib.exc import UnknownHashError
+        from passlib.hash import md5_crypt, unix_disabled
+
+        ctx = CryptContext(["des_crypt"])
+        ctx2 = CryptContext(["des_crypt", "unix_disabled"])
+        h_ref = ctx.hash("foo")
+        h_other = md5_crypt.hash('foo')
+
+        #
+        # ctx.disable()
+        #
+
+        # test w/o disabled hash support
+        self.assertRaisesRegex(RuntimeError, "no disabled hasher present",
+                               ctx.disable)
+        self.assertRaisesRegex(RuntimeError, "no disabled hasher present",
+                               ctx.disable, h_ref)
+        self.assertRaisesRegex(RuntimeError, "no disabled hasher present",
+                               ctx.disable, h_other)
+
+        # test w/ disabled hash support
+        h_dis = ctx2.disable()
+        self.assertEqual(h_dis, unix_disabled.default_marker)
+        h_dis_ref = ctx2.disable(h_ref)
+        self.assertEqual(h_dis_ref, unix_disabled.default_marker + h_ref)
+
+        h_dis_other = ctx2.disable(h_other)
+        self.assertEqual(h_dis_other, unix_disabled.default_marker + h_other)
+
+        # don't double-wrap existing disabled hash
+        self.assertEqual(ctx2.disable(h_dis_ref), h_dis_ref)
+
+        #
+        # ctx.is_enabled()
+        #
+
+        # test w/o disabled hash support
+        self.assertTrue(ctx.is_enabled(h_ref))
+        self.assertRaises(UnknownHashError, ctx.is_enabled, h_other)
+        self.assertRaises(UnknownHashError, ctx.is_enabled, h_dis)
+        self.assertRaises(UnknownHashError, ctx.is_enabled, h_dis_ref)
+
+        # test w/ disabled hash support
+        self.assertTrue(ctx2.is_enabled(h_ref))
+        self.assertRaises(UnknownHashError, ctx.is_enabled, h_other)
+        self.assertFalse(ctx2.is_enabled(h_dis))
+        self.assertFalse(ctx2.is_enabled(h_dis_ref))
+
+        #
+        # ctx.enable()
+        #
+
+        # test w/o disabled hash support
+        self.assertRaises(UnknownHashError, ctx.enable, "")
+        self.assertRaises(TypeError, ctx.enable, None)
+        self.assertEqual(ctx.enable(h_ref), h_ref)
+        self.assertRaises(UnknownHashError, ctx.enable, h_other)
+        self.assertRaises(UnknownHashError, ctx.enable, h_dis)
+        self.assertRaises(UnknownHashError, ctx.enable, h_dis_ref)
+
+        # test w/ disabled hash support
+        self.assertRaises(UnknownHashError, ctx.enable, "")
+        self.assertRaises(TypeError, ctx2.enable, None)
+        self.assertEqual(ctx2.enable(h_ref), h_ref)
+        self.assertRaises(UnknownHashError, ctx2.enable, h_other)
+        self.assertRaisesRegex(ValueError, "cannot restore original hash",
+                               ctx2.enable, h_dis)
+        self.assertEqual(ctx2.enable(h_dis_ref), h_ref)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+import hashlib, time
+
+class DelayHash(uh.StaticHandler):
+    """dummy hasher which delays by specified amount"""
+    name = "delay_hash"
+    checksum_chars = uh.LOWER_HEX_CHARS
+    checksum_size = 40
+    delay = 0
+    _hash_prefix = u("$x$")
+
+    def _calc_checksum(self, secret):
+        time.sleep(self.delay)
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        return str_to_uascii(hashlib.sha1(b"prefix" + secret).hexdigest())
+
+#=============================================================================
+# LazyCryptContext
+#=============================================================================
+class dummy_2(uh.StaticHandler):
+    name = "dummy_2"
+
+class LazyCryptContextTest(TestCase):
+    descriptionPrefix = "LazyCryptContext"
+
+    def setUp(self):
+        # make sure this isn't registered before OR after
+        unload_handler_name("dummy_2")
+        self.addCleanup(unload_handler_name, "dummy_2")
+
+    def test_kwd_constructor(self):
+        """test plain kwds"""
+        self.assertFalse(has_crypt_handler("dummy_2"))
+        register_crypt_handler_path("dummy_2", "passlib.tests.test_context")
+
+        cc = LazyCryptContext(iter(["dummy_2", "des_crypt"]), deprecated=["des_crypt"])
+
+        self.assertFalse(has_crypt_handler("dummy_2", True))
+
+        self.assertEqual(cc.schemes(), ("dummy_2", "des_crypt"))
+        self.assertTrue(cc.handler("des_crypt").deprecated)
+
+        self.assertTrue(has_crypt_handler("dummy_2", True))
+
+    def test_callable_constructor(self):
+        self.assertFalse(has_crypt_handler("dummy_2"))
+        register_crypt_handler_path("dummy_2", "passlib.tests.test_context")
+
+        def onload(flag=False):
+            self.assertTrue(flag)
+            return dict(schemes=iter(["dummy_2", "des_crypt"]), deprecated=["des_crypt"])
+
+        cc = LazyCryptContext(onload=onload, flag=True)
+
+        self.assertFalse(has_crypt_handler("dummy_2", True))
+
+        self.assertEqual(cc.schemes(), ("dummy_2", "des_crypt"))
+        self.assertTrue(cc.handler("des_crypt").deprecated)
+
+        self.assertTrue(has_crypt_handler("dummy_2", True))
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_context_deprecated.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_context_deprecated.py
new file mode 100644
index 0000000..0f76624
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_context_deprecated.py
@@ -0,0 +1,743 @@
+"""tests for passlib.context
+
+this file is a clone of the 1.5 test_context.py,
+containing the tests using the legacy CryptPolicy api.
+it's being preserved here to ensure the old api doesn't break
+(until Passlib 1.8, when this and the legacy api will be removed).
+"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+from logging import getLogger
+import os
+import warnings
+# site
+try:
+    from pkg_resources import resource_filename
+except ImportError:
+    resource_filename = None
+# pkg
+from passlib import hash
+from passlib.context import CryptContext, CryptPolicy, LazyCryptContext
+from passlib.utils import to_bytes, to_unicode
+import passlib.utils.handlers as uh
+from passlib.tests.utils import TestCase, set_file
+from passlib.registry import (register_crypt_handler_path,
+                        _has_crypt_handler as has_crypt_handler,
+                        _unload_handler_name as unload_handler_name,
+                        )
+# module
+log = getLogger(__name__)
+
+#=============================================================================
+#
+#=============================================================================
+class CryptPolicyTest(TestCase):
+    """test CryptPolicy object"""
+
+    # TODO: need to test user categories w/in all this
+
+    descriptionPrefix = "CryptPolicy"
+
+    #===================================================================
+    # sample crypt policies used for testing
+    #===================================================================
+
+    #---------------------------------------------------------------
+    # sample 1 - average config file
+    #---------------------------------------------------------------
+    # NOTE: copy of this is stored in file passlib/tests/sample_config_1s.cfg
+    sample_config_1s = """\
+[passlib]
+schemes = des_crypt, md5_crypt, bsdi_crypt, sha512_crypt
+default = md5_crypt
+all.vary_rounds = 10%%
+bsdi_crypt.max_rounds = 30000
+bsdi_crypt.default_rounds = 25000
+sha512_crypt.max_rounds = 50000
+sha512_crypt.min_rounds = 40000
+"""
+    sample_config_1s_path = os.path.abspath(os.path.join(
+        os.path.dirname(__file__), "sample_config_1s.cfg"))
+    if not os.path.exists(sample_config_1s_path) and resource_filename:
+        # in case we're zipped up in an egg.
+        sample_config_1s_path = resource_filename("passlib.tests",
+                                                  "sample_config_1s.cfg")
+
+    # make sure sample_config_1s uses \n linesep - tests rely on this
+    assert sample_config_1s.startswith("[passlib]\nschemes")
+
+    sample_config_1pd = dict(
+        schemes = [ "des_crypt", "md5_crypt", "bsdi_crypt", "sha512_crypt"],
+        default = "md5_crypt",
+        # NOTE: not maintaining backwards compat for rendering to "10%"
+        all__vary_rounds = 0.1,
+        bsdi_crypt__max_rounds = 30000,
+        bsdi_crypt__default_rounds = 25000,
+        sha512_crypt__max_rounds = 50000,
+        sha512_crypt__min_rounds = 40000,
+    )
+
+    sample_config_1pid = {
+        "schemes": "des_crypt, md5_crypt, bsdi_crypt, sha512_crypt",
+        "default": "md5_crypt",
+        # NOTE: not maintaining backwards compat for rendering to "10%"
+        "all.vary_rounds": 0.1,
+        "bsdi_crypt.max_rounds": 30000,
+        "bsdi_crypt.default_rounds": 25000,
+        "sha512_crypt.max_rounds": 50000,
+        "sha512_crypt.min_rounds": 40000,
+    }
+
+    sample_config_1prd = dict(
+        schemes = [ hash.des_crypt, hash.md5_crypt, hash.bsdi_crypt, hash.sha512_crypt],
+        default = "md5_crypt", # NOTE: passlib <= 1.5 was handler obj.
+        # NOTE: not maintaining backwards compat for rendering to "10%"
+        all__vary_rounds = 0.1,
+        bsdi_crypt__max_rounds = 30000,
+        bsdi_crypt__default_rounds = 25000,
+        sha512_crypt__max_rounds = 50000,
+        sha512_crypt__min_rounds = 40000,
+    )
+
+    #---------------------------------------------------------------
+    # sample 2 - partial policy & result of overlay on sample 1
+    #---------------------------------------------------------------
+    sample_config_2s = """\
+[passlib]
+bsdi_crypt.min_rounds = 29000
+bsdi_crypt.max_rounds = 35000
+bsdi_crypt.default_rounds = 31000
+sha512_crypt.min_rounds = 45000
+"""
+
+    sample_config_2pd = dict(
+        # using this to test full replacement of existing options
+        bsdi_crypt__min_rounds = 29000,
+        bsdi_crypt__max_rounds = 35000,
+        bsdi_crypt__default_rounds = 31000,
+        # using this to test partial replacement of existing options
+        sha512_crypt__min_rounds=45000,
+    )
+
+    sample_config_12pd = dict(
+        schemes = [ "des_crypt", "md5_crypt", "bsdi_crypt", "sha512_crypt"],
+        default = "md5_crypt",
+        # NOTE: not maintaining backwards compat for rendering to "10%"
+        all__vary_rounds = 0.1,
+        bsdi_crypt__min_rounds = 29000,
+        bsdi_crypt__max_rounds = 35000,
+        bsdi_crypt__default_rounds = 31000,
+        sha512_crypt__max_rounds = 50000,
+        sha512_crypt__min_rounds=45000,
+    )
+
+    #---------------------------------------------------------------
+    # sample 3 - just changing default
+    #---------------------------------------------------------------
+    sample_config_3pd = dict(
+        default="sha512_crypt",
+    )
+
+    sample_config_123pd = dict(
+        schemes = [ "des_crypt", "md5_crypt", "bsdi_crypt", "sha512_crypt"],
+        default = "sha512_crypt",
+        # NOTE: not maintaining backwards compat for rendering to "10%"
+        all__vary_rounds = 0.1,
+        bsdi_crypt__min_rounds = 29000,
+        bsdi_crypt__max_rounds = 35000,
+        bsdi_crypt__default_rounds = 31000,
+        sha512_crypt__max_rounds = 50000,
+        sha512_crypt__min_rounds=45000,
+    )
+
+    #---------------------------------------------------------------
+    # sample 4 - category specific
+    #---------------------------------------------------------------
+    sample_config_4s = """
+[passlib]
+schemes = sha512_crypt
+all.vary_rounds = 10%%
+default.sha512_crypt.max_rounds = 20000
+admin.all.vary_rounds = 5%%
+admin.sha512_crypt.max_rounds = 40000
+"""
+
+    sample_config_4pd = dict(
+        schemes = [ "sha512_crypt" ],
+        # NOTE: not maintaining backwards compat for rendering to "10%"
+        all__vary_rounds = 0.1,
+        sha512_crypt__max_rounds = 20000,
+        # NOTE: not maintaining backwards compat for rendering to "5%"
+        admin__all__vary_rounds = 0.05,
+        admin__sha512_crypt__max_rounds = 40000,
+        )
+
+    #---------------------------------------------------------------
+    # sample 5 - to_string & deprecation testing
+    #---------------------------------------------------------------
+    sample_config_5s = sample_config_1s + """\
+deprecated = des_crypt
+admin__context__deprecated = des_crypt, bsdi_crypt
+"""
+
+    sample_config_5pd = sample_config_1pd.copy()
+    sample_config_5pd.update(
+        deprecated = [ "des_crypt" ],
+        admin__context__deprecated = [ "des_crypt", "bsdi_crypt" ],
+    )
+
+    sample_config_5pid = sample_config_1pid.copy()
+    sample_config_5pid.update({
+        "deprecated": "des_crypt",
+        "admin.context.deprecated": "des_crypt, bsdi_crypt",
+    })
+
+    sample_config_5prd = sample_config_1prd.copy()
+    sample_config_5prd.update({
+        # XXX: should deprecated return the actual handlers in this case?
+        #      would have to modify how policy stores info, for one.
+        "deprecated": ["des_crypt"],
+        "admin__context__deprecated": ["des_crypt", "bsdi_crypt"],
+    })
+
+    #===================================================================
+    # constructors
+    #===================================================================
+    def setUp(self):
+        TestCase.setUp(self)
+        warnings.filterwarnings("ignore",
+                                r"The CryptPolicy class has been deprecated")
+        warnings.filterwarnings("ignore",
+                                r"the method.*hash_needs_update.*is deprecated")
+        warnings.filterwarnings("ignore", "The 'all' scheme is deprecated.*")
+        warnings.filterwarnings("ignore", "bsdi_crypt rounds should be odd")
+
+    def test_00_constructor(self):
+        """test CryptPolicy() constructor"""
+        policy = CryptPolicy(**self.sample_config_1pd)
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        policy = CryptPolicy(self.sample_config_1pd)
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        self.assertRaises(TypeError, CryptPolicy, {}, {})
+        self.assertRaises(TypeError, CryptPolicy, {}, dummy=1)
+
+        # check key with too many separators is rejected
+        self.assertRaises(TypeError, CryptPolicy,
+            schemes = [ "des_crypt", "md5_crypt", "bsdi_crypt", "sha512_crypt"],
+            bad__key__bsdi_crypt__max_rounds = 30000,
+            )
+
+        # check nameless handler rejected
+        class nameless(uh.StaticHandler):
+            name = None
+        self.assertRaises(ValueError, CryptPolicy, schemes=[nameless])
+
+        # check scheme must be name or crypt handler
+        self.assertRaises(TypeError, CryptPolicy, schemes=[uh.StaticHandler])
+
+        # check name conflicts are rejected
+        class dummy_1(uh.StaticHandler):
+            name = 'dummy_1'
+        self.assertRaises(KeyError, CryptPolicy, schemes=[dummy_1, dummy_1])
+
+        # with unknown deprecated value
+        self.assertRaises(KeyError, CryptPolicy,
+                          schemes=['des_crypt'],
+                          deprecated=['md5_crypt'])
+
+        # with unknown default value
+        self.assertRaises(KeyError, CryptPolicy,
+                          schemes=['des_crypt'],
+                          default='md5_crypt')
+
+    def test_01_from_path_simple(self):
+        """test CryptPolicy.from_path() constructor"""
+        # NOTE: this is separate so it can also run under GAE
+
+        # test preset stored in existing file
+        path = self.sample_config_1s_path
+        policy = CryptPolicy.from_path(path)
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        # test if path missing
+        self.assertRaises(EnvironmentError, CryptPolicy.from_path, path + 'xxx')
+
+    def test_01_from_path(self):
+        """test CryptPolicy.from_path() constructor with encodings"""
+        path = self.mktemp()
+
+        # test "\n" linesep
+        set_file(path, self.sample_config_1s)
+        policy = CryptPolicy.from_path(path)
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        # test "\r\n" linesep
+        set_file(path, self.sample_config_1s.replace("\n","\r\n"))
+        policy = CryptPolicy.from_path(path)
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        # test with custom encoding
+        uc2 = to_bytes(self.sample_config_1s, "utf-16", source_encoding="utf-8")
+        set_file(path, uc2)
+        policy = CryptPolicy.from_path(path, encoding="utf-16")
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+    def test_02_from_string(self):
+        """test CryptPolicy.from_string() constructor"""
+        # test "\n" linesep
+        policy = CryptPolicy.from_string(self.sample_config_1s)
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        # test "\r\n" linesep
+        policy = CryptPolicy.from_string(
+            self.sample_config_1s.replace("\n","\r\n"))
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        # test with unicode
+        data = to_unicode(self.sample_config_1s)
+        policy = CryptPolicy.from_string(data)
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        # test with non-ascii-compatible encoding
+        uc2 = to_bytes(self.sample_config_1s, "utf-16", source_encoding="utf-8")
+        policy = CryptPolicy.from_string(uc2, encoding="utf-16")
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        # test category specific options
+        policy = CryptPolicy.from_string(self.sample_config_4s)
+        self.assertEqual(policy.to_dict(), self.sample_config_4pd)
+
+    def test_03_from_source(self):
+        """test CryptPolicy.from_source() constructor"""
+        # pass it a path
+        policy = CryptPolicy.from_source(self.sample_config_1s_path)
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        # pass it a string
+        policy = CryptPolicy.from_source(self.sample_config_1s)
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        # pass it a dict (NOTE: make a copy to detect in-place modifications)
+        policy = CryptPolicy.from_source(self.sample_config_1pd.copy())
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        # pass it existing policy
+        p2 = CryptPolicy.from_source(policy)
+        self.assertIs(policy, p2)
+
+        # pass it something wrong
+        self.assertRaises(TypeError, CryptPolicy.from_source, 1)
+        self.assertRaises(TypeError, CryptPolicy.from_source, [])
+
+    def test_04_from_sources(self):
+        """test CryptPolicy.from_sources() constructor"""
+
+        # pass it empty list
+        self.assertRaises(ValueError, CryptPolicy.from_sources, [])
+
+        # pass it one-element list
+        policy = CryptPolicy.from_sources([self.sample_config_1s])
+        self.assertEqual(policy.to_dict(), self.sample_config_1pd)
+
+        # pass multiple sources
+        policy = CryptPolicy.from_sources(
+            [
+            self.sample_config_1s_path,
+            self.sample_config_2s,
+            self.sample_config_3pd,
+            ])
+        self.assertEqual(policy.to_dict(), self.sample_config_123pd)
+
+    def test_05_replace(self):
+        """test CryptPolicy.replace() constructor"""
+
+        p1 = CryptPolicy(**self.sample_config_1pd)
+
+        # check overlaying sample 2
+        p2 = p1.replace(**self.sample_config_2pd)
+        self.assertEqual(p2.to_dict(), self.sample_config_12pd)
+
+        # check repeating overlay makes no change
+        p2b = p2.replace(**self.sample_config_2pd)
+        self.assertEqual(p2b.to_dict(), self.sample_config_12pd)
+
+        # check overlaying sample 3
+        p3 = p2.replace(self.sample_config_3pd)
+        self.assertEqual(p3.to_dict(), self.sample_config_123pd)
+
+    def test_06_forbidden(self):
+        """test CryptPolicy() forbidden kwds"""
+
+        # salt not allowed to be set
+        self.assertRaises(KeyError, CryptPolicy,
+            schemes=["des_crypt"],
+            des_crypt__salt="xx",
+        )
+        self.assertRaises(KeyError, CryptPolicy,
+            schemes=["des_crypt"],
+            all__salt="xx",
+        )
+
+        # schemes not allowed for category
+        self.assertRaises(KeyError, CryptPolicy,
+            schemes=["des_crypt"],
+            user__context__schemes=["md5_crypt"],
+        )
+
+    #===================================================================
+    # reading
+    #===================================================================
+    def test_10_has_schemes(self):
+        """test has_schemes() method"""
+
+        p1 = CryptPolicy(**self.sample_config_1pd)
+        self.assertTrue(p1.has_schemes())
+
+        p3 = CryptPolicy(**self.sample_config_3pd)
+        self.assertTrue(not p3.has_schemes())
+
+    def test_11_iter_handlers(self):
+        """test iter_handlers() method"""
+
+        p1 = CryptPolicy(**self.sample_config_1pd)
+        s = self.sample_config_1prd['schemes']
+        self.assertEqual(list(p1.iter_handlers()), s)
+
+        p3 = CryptPolicy(**self.sample_config_3pd)
+        self.assertEqual(list(p3.iter_handlers()), [])
+
+    def test_12_get_handler(self):
+        """test get_handler() method"""
+
+        p1 = CryptPolicy(**self.sample_config_1pd)
+
+        # check by name
+        self.assertIs(p1.get_handler("bsdi_crypt"), hash.bsdi_crypt)
+
+        # check by missing name
+        self.assertIs(p1.get_handler("sha256_crypt"), None)
+        self.assertRaises(KeyError, p1.get_handler, "sha256_crypt", required=True)
+
+        # check default
+        self.assertIs(p1.get_handler(), hash.md5_crypt)
+
+    def test_13_get_options(self):
+        """test get_options() method"""
+
+        p12 = CryptPolicy(**self.sample_config_12pd)
+
+        self.assertEqual(p12.get_options("bsdi_crypt"),dict(
+            # NOTE: not maintaining backwards compat for rendering to "10%"
+            vary_rounds = 0.1,
+            min_rounds = 29000,
+            max_rounds = 35000,
+            default_rounds = 31000,
+        ))
+
+        self.assertEqual(p12.get_options("sha512_crypt"),dict(
+            # NOTE: not maintaining backwards compat for rendering to "10%"
+            vary_rounds = 0.1,
+            min_rounds = 45000,
+            max_rounds = 50000,
+        ))
+
+        p4 = CryptPolicy.from_string(self.sample_config_4s)
+        self.assertEqual(p4.get_options("sha512_crypt"), dict(
+            # NOTE: not maintaining backwards compat for rendering to "10%"
+            vary_rounds=0.1,
+            max_rounds=20000,
+        ))
+
+        self.assertEqual(p4.get_options("sha512_crypt", "user"), dict(
+            # NOTE: not maintaining backwards compat for rendering to "10%"
+            vary_rounds=0.1,
+            max_rounds=20000,
+        ))
+
+        self.assertEqual(p4.get_options("sha512_crypt", "admin"), dict(
+            # NOTE: not maintaining backwards compat for rendering to "5%"
+            vary_rounds=0.05,
+            max_rounds=40000,
+        ))
+
+    def test_14_handler_is_deprecated(self):
+        """test handler_is_deprecated() method"""
+        pa = CryptPolicy(**self.sample_config_1pd)
+        pb = CryptPolicy(**self.sample_config_5pd)
+
+        self.assertFalse(pa.handler_is_deprecated("des_crypt"))
+        self.assertFalse(pa.handler_is_deprecated(hash.bsdi_crypt))
+        self.assertFalse(pa.handler_is_deprecated("sha512_crypt"))
+
+        self.assertTrue(pb.handler_is_deprecated("des_crypt"))
+        self.assertFalse(pb.handler_is_deprecated(hash.bsdi_crypt))
+        self.assertFalse(pb.handler_is_deprecated("sha512_crypt"))
+
+        # check categories as well
+        self.assertTrue(pb.handler_is_deprecated("des_crypt", "user"))
+        self.assertFalse(pb.handler_is_deprecated("bsdi_crypt", "user"))
+        self.assertTrue(pb.handler_is_deprecated("des_crypt", "admin"))
+        self.assertTrue(pb.handler_is_deprecated("bsdi_crypt", "admin"))
+
+        # check deprecation is overridden per category
+        pc = CryptPolicy(
+            schemes=["md5_crypt", "des_crypt"],
+            deprecated=["md5_crypt"],
+            user__context__deprecated=["des_crypt"],
+        )
+        self.assertTrue(pc.handler_is_deprecated("md5_crypt"))
+        self.assertFalse(pc.handler_is_deprecated("des_crypt"))
+        self.assertFalse(pc.handler_is_deprecated("md5_crypt", "user"))
+        self.assertTrue(pc.handler_is_deprecated("des_crypt", "user"))
+
+    def test_15_min_verify_time(self):
+        """test get_min_verify_time() method"""
+        # silence deprecation warnings for min verify time
+        warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+        pa = CryptPolicy()
+        self.assertEqual(pa.get_min_verify_time(), 0)
+        self.assertEqual(pa.get_min_verify_time('admin'), 0)
+
+        pb = pa.replace(min_verify_time=.1)
+        self.assertEqual(pb.get_min_verify_time(), 0)
+        self.assertEqual(pb.get_min_verify_time('admin'), 0)
+
+    #===================================================================
+    # serialization
+    #===================================================================
+    def test_20_iter_config(self):
+        """test iter_config() method"""
+        p5 = CryptPolicy(**self.sample_config_5pd)
+        self.assertEqual(dict(p5.iter_config()), self.sample_config_5pd)
+        self.assertEqual(dict(p5.iter_config(resolve=True)), self.sample_config_5prd)
+        self.assertEqual(dict(p5.iter_config(ini=True)), self.sample_config_5pid)
+
+    def test_21_to_dict(self):
+        """test to_dict() method"""
+        p5 = CryptPolicy(**self.sample_config_5pd)
+        self.assertEqual(p5.to_dict(), self.sample_config_5pd)
+        self.assertEqual(p5.to_dict(resolve=True), self.sample_config_5prd)
+
+    def test_22_to_string(self):
+        """test to_string() method"""
+        pa = CryptPolicy(**self.sample_config_5pd)
+        s = pa.to_string() # NOTE: can't compare string directly, ordering etc may not match
+        pb = CryptPolicy.from_string(s)
+        self.assertEqual(pb.to_dict(), self.sample_config_5pd)
+
+        s = pa.to_string(encoding="latin-1")
+        self.assertIsInstance(s, bytes)
+
+    #===================================================================
+    #
+    #===================================================================
+
+#=============================================================================
+# CryptContext
+#=============================================================================
+class CryptContextTest(TestCase):
+    """test CryptContext class"""
+    descriptionPrefix = "CryptContext"
+
+    def setUp(self):
+        TestCase.setUp(self)
+        warnings.filterwarnings("ignore",
+                                r"CryptContext\(\)\.replace\(\) has been deprecated.*")
+        warnings.filterwarnings("ignore",
+                                r"The CryptContext ``policy`` keyword has been deprecated.*")
+        warnings.filterwarnings("ignore", ".*(CryptPolicy|context\.policy).*(has|have) been deprecated.*")
+        warnings.filterwarnings("ignore",
+                                r"the method.*hash_needs_update.*is deprecated")
+
+    #===================================================================
+    # constructor
+    #===================================================================
+    def test_00_constructor(self):
+        """test constructor"""
+        # create crypt context using handlers
+        cc = CryptContext([hash.md5_crypt, hash.bsdi_crypt, hash.des_crypt])
+        c,b,a = cc.policy.iter_handlers()
+        self.assertIs(a, hash.des_crypt)
+        self.assertIs(b, hash.bsdi_crypt)
+        self.assertIs(c, hash.md5_crypt)
+
+        # create context using names
+        cc = CryptContext(["md5_crypt", "bsdi_crypt", "des_crypt"])
+        c,b,a = cc.policy.iter_handlers()
+        self.assertIs(a, hash.des_crypt)
+        self.assertIs(b, hash.bsdi_crypt)
+        self.assertIs(c, hash.md5_crypt)
+
+        # policy kwd
+        policy = cc.policy
+        cc = CryptContext(policy=policy)
+        self.assertEqual(cc.to_dict(), policy.to_dict())
+
+        cc = CryptContext(policy=policy, default="bsdi_crypt")
+        self.assertNotEqual(cc.to_dict(), policy.to_dict())
+        self.assertEqual(cc.to_dict(), dict(schemes=["md5_crypt","bsdi_crypt","des_crypt"],
+                                            default="bsdi_crypt"))
+
+        self.assertRaises(TypeError, setattr, cc, 'policy', None)
+        self.assertRaises(TypeError, CryptContext, policy='x')
+
+    def test_01_replace(self):
+        """test replace()"""
+
+        cc = CryptContext(["md5_crypt", "bsdi_crypt", "des_crypt"])
+        self.assertIs(cc.policy.get_handler(), hash.md5_crypt)
+
+        cc2 = cc.replace()
+        self.assertIsNot(cc2, cc)
+        # NOTE: was not able to maintain backward compatibility with this...
+        ##self.assertIs(cc2.policy, cc.policy)
+
+        cc3 = cc.replace(default="bsdi_crypt")
+        self.assertIsNot(cc3, cc)
+        # NOTE: was not able to maintain backward compatibility with this...
+        ##self.assertIs(cc3.policy, cc.policy)
+        self.assertIs(cc3.policy.get_handler(), hash.bsdi_crypt)
+
+    def test_02_no_handlers(self):
+        """test no handlers"""
+
+        # check constructor...
+        cc = CryptContext()
+        self.assertRaises(KeyError, cc.identify, 'hash', required=True)
+        self.assertRaises(KeyError, cc.hash, 'secret')
+        self.assertRaises(KeyError, cc.verify, 'secret', 'hash')
+
+        # check updating policy after the fact...
+        cc = CryptContext(['md5_crypt'])
+        p = CryptPolicy(schemes=[])
+        cc.policy = p
+
+        self.assertRaises(KeyError, cc.identify, 'hash', required=True)
+        self.assertRaises(KeyError, cc.hash, 'secret')
+        self.assertRaises(KeyError, cc.verify, 'secret', 'hash')
+
+    #===================================================================
+    # policy adaptation
+    #===================================================================
+    sample_policy_1 = dict(
+            schemes = [ "des_crypt", "md5_crypt", "phpass", "bsdi_crypt",
+                       "sha256_crypt"],
+            deprecated = [ "des_crypt", ],
+            default = "sha256_crypt",
+            bsdi_crypt__max_rounds = 30,
+            bsdi_crypt__default_rounds = 25,
+            bsdi_crypt__vary_rounds = 0,
+            sha256_crypt__max_rounds = 3000,
+            sha256_crypt__min_rounds = 2000,
+            sha256_crypt__default_rounds = 3000,
+            phpass__ident = "H",
+            phpass__default_rounds = 7,
+    )
+
+    def test_12_hash_needs_update(self):
+        """test hash_needs_update() method"""
+        cc = CryptContext(**self.sample_policy_1)
+
+        # check deprecated scheme
+        self.assertTrue(cc.hash_needs_update('9XXD4trGYeGJA'))
+        self.assertFalse(cc.hash_needs_update('$1$J8HC2RCr$HcmM.7NxB2weSvlw2FgzU0'))
+
+        # check min rounds
+        self.assertTrue(cc.hash_needs_update('$5$rounds=1999$jD81UCoo.zI.UETs$Y7qSTQ6mTiU9qZB4fRr43wRgQq4V.5AAf7F97Pzxey/'))
+        self.assertFalse(cc.hash_needs_update('$5$rounds=2000$228SSRje04cnNCaQ$YGV4RYu.5sNiBvorQDlO0WWQjyJVGKBcJXz3OtyQ2u8'))
+
+        # check max rounds
+        self.assertFalse(cc.hash_needs_update('$5$rounds=3000$fS9iazEwTKi7QPW4$VasgBC8FqlOvD7x2HhABaMXCTh9jwHclPA9j5YQdns.'))
+        self.assertTrue(cc.hash_needs_update('$5$rounds=3001$QlFHHifXvpFX4PLs$/0ekt7lSs/lOikSerQ0M/1porEHxYq7W/2hdFpxA3fA'))
+
+    #===================================================================
+    # border cases
+    #===================================================================
+    def test_30_nonstring_hash(self):
+        """test non-string hash values cause error"""
+        warnings.filterwarnings("ignore", ".*needs_update.*'scheme' keyword is deprecated.*")
+
+        #
+        # test hash=None or some other non-string causes TypeError
+        # and that explicit-scheme code path behaves the same.
+        #
+        cc = CryptContext(["des_crypt"])
+        for hash, kwds in [
+                (None, {}),
+                # NOTE: 'scheme' kwd is deprecated...
+                (None, {"scheme": "des_crypt"}),
+                (1, {}),
+                ((), {}),
+                ]:
+
+            self.assertRaises(TypeError, cc.hash_needs_update, hash, **kwds)
+
+        cc2 = CryptContext(["mysql323"])
+        self.assertRaises(TypeError, cc2.hash_needs_update, None)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# LazyCryptContext
+#=============================================================================
+class dummy_2(uh.StaticHandler):
+    name = "dummy_2"
+
+class LazyCryptContextTest(TestCase):
+    descriptionPrefix = "LazyCryptContext"
+
+    def setUp(self):
+        TestCase.setUp(self)
+
+        # make sure this isn't registered before OR after
+        unload_handler_name("dummy_2")
+        self.addCleanup(unload_handler_name, "dummy_2")
+
+        # silence some warnings
+        warnings.filterwarnings("ignore",
+                                r"CryptContext\(\)\.replace\(\) has been deprecated")
+        warnings.filterwarnings("ignore", ".*(CryptPolicy|context\.policy).*(has|have) been deprecated.*")
+
+    def test_kwd_constructor(self):
+        """test plain kwds"""
+        self.assertFalse(has_crypt_handler("dummy_2"))
+        register_crypt_handler_path("dummy_2", "passlib.tests.test_context")
+
+        cc = LazyCryptContext(iter(["dummy_2", "des_crypt"]), deprecated=["des_crypt"])
+
+        self.assertFalse(has_crypt_handler("dummy_2", True))
+
+        self.assertTrue(cc.policy.handler_is_deprecated("des_crypt"))
+        self.assertEqual(cc.policy.schemes(), ["dummy_2", "des_crypt"])
+
+        self.assertTrue(has_crypt_handler("dummy_2", True))
+
+    def test_callable_constructor(self):
+        """test create_policy() hook, returning CryptPolicy"""
+        self.assertFalse(has_crypt_handler("dummy_2"))
+        register_crypt_handler_path("dummy_2", "passlib.tests.test_context")
+
+        def create_policy(flag=False):
+            self.assertTrue(flag)
+            return CryptPolicy(schemes=iter(["dummy_2", "des_crypt"]), deprecated=["des_crypt"])
+
+        cc = LazyCryptContext(create_policy=create_policy, flag=True)
+
+        self.assertFalse(has_crypt_handler("dummy_2", True))
+
+        self.assertTrue(cc.policy.handler_is_deprecated("des_crypt"))
+        self.assertEqual(cc.policy.schemes(), ["dummy_2", "des_crypt"])
+
+        self.assertTrue(has_crypt_handler("dummy_2", True))
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_builtin_md4.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_builtin_md4.py
new file mode 100644
index 0000000..0aca1eb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_builtin_md4.py
@@ -0,0 +1,160 @@
+"""passlib.tests -- unittests for passlib.crypto._md4"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement, division
+# core
+from binascii import hexlify
+import hashlib
+# site
+# pkg
+# module
+from passlib.utils.compat import bascii_to_str, PY3, u
+from passlib.crypto.digest import lookup_hash
+from passlib.tests.utils import TestCase, skipUnless
+# local
+__all__ = [
+    "_Common_MD4_Test",
+    "MD4_Builtin_Test",
+    "MD4_SSL_Test",
+]
+#=============================================================================
+# test pure-python MD4 implementation
+#=============================================================================
+class _Common_MD4_Test(TestCase):
+    """common code for testing md4 backends"""
+
+    vectors = [
+        # input -> hex digest
+        # test vectors from http://www.faqs.org/rfcs/rfc1320.html - A.5
+        (b"", "31d6cfe0d16ae931b73c59d7e0c089c0"),
+        (b"a", "bde52cb31de33e46245e05fbdbd6fb24"),
+        (b"abc", "a448017aaf21d8525fc10ae87aa6729d"),
+        (b"message digest", "d9130a8164549fe818874806e1c7014b"),
+        (b"abcdefghijklmnopqrstuvwxyz", "d79e1c308aa5bbcdeea8ed63df412da9"),
+        (b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", "043f8582f241db351ce627e153e7f0e4"),
+        (b"12345678901234567890123456789012345678901234567890123456789012345678901234567890", "e33b4ddc9c38f2199c3e7b164fcc0536"),
+    ]
+
+    def get_md4_const(self):
+        """
+        get md4 constructor --
+        overridden by subclasses to use alternate backends.
+        """
+        return lookup_hash("md4").const
+
+    def test_attrs(self):
+        """informational attributes"""
+        h = self.get_md4_const()()
+        self.assertEqual(h.name, "md4")
+        self.assertEqual(h.digest_size, 16)
+        self.assertEqual(h.block_size, 64)
+
+    def test_md4_update(self):
+        """update() method"""
+        md4 = self.get_md4_const()
+        h = md4(b'')
+        self.assertEqual(h.hexdigest(), "31d6cfe0d16ae931b73c59d7e0c089c0")
+
+        h.update(b'a')
+        self.assertEqual(h.hexdigest(), "bde52cb31de33e46245e05fbdbd6fb24")
+
+        h.update(b'bcdefghijklmnopqrstuvwxyz')
+        self.assertEqual(h.hexdigest(), "d79e1c308aa5bbcdeea8ed63df412da9")
+
+        if PY3:
+            # reject unicode, hash should return digest of b''
+            h = md4()
+            self.assertRaises(TypeError, h.update, u('a'))
+            self.assertEqual(h.hexdigest(), "31d6cfe0d16ae931b73c59d7e0c089c0")
+        else:
+            # coerce unicode to ascii, hash should return digest of b'a'
+            h = md4()
+            h.update(u('a'))
+            self.assertEqual(h.hexdigest(), "bde52cb31de33e46245e05fbdbd6fb24")
+
+    def test_md4_hexdigest(self):
+        """hexdigest() method"""
+        md4 = self.get_md4_const()
+        for input, hex in self.vectors:
+            out = md4(input).hexdigest()
+            self.assertEqual(out, hex)
+
+    def test_md4_digest(self):
+        """digest() method"""
+        md4 = self.get_md4_const()
+        for input, hex in self.vectors:
+            out = bascii_to_str(hexlify(md4(input).digest()))
+            self.assertEqual(out, hex)
+
+    def test_md4_copy(self):
+        """copy() method"""
+        md4 = self.get_md4_const()
+        h = md4(b'abc')
+
+        h2 = h.copy()
+        h2.update(b'def')
+        self.assertEqual(h2.hexdigest(), '804e7f1c2586e50b49ac65db5b645131')
+
+        h.update(b'ghi')
+        self.assertEqual(h.hexdigest(), 'c5225580bfe176f6deeee33dee98732c')
+
+
+#------------------------------------------------------------------------
+# create subclasses to test various backends
+#------------------------------------------------------------------------
+
+def has_native_md4(): # pragma: no cover -- runtime detection
+    """
+    check if hashlib natively supports md4.
+    """
+    try:
+        hashlib.new("md4")
+        return True
+    except ValueError:
+        # not supported - ssl probably missing (e.g. ironpython)
+        return False
+
+
+@skipUnless(has_native_md4(), "hashlib lacks ssl/md4 support")
+class MD4_SSL_Test(_Common_MD4_Test):
+    descriptionPrefix = "hashlib.new('md4')"
+
+    # NOTE: we trust ssl got md4 implementation right,
+    #       this is more to test our test is correct :)
+
+    def setUp(self):
+        super(MD4_SSL_Test, self).setUp()
+
+        # make sure we're using right constructor.
+        self.assertEqual(self.get_md4_const().__module__, "hashlib")
+
+
+class MD4_Builtin_Test(_Common_MD4_Test):
+    descriptionPrefix = "passlib.crypto._md4.md4()"
+
+    def setUp(self):
+        super(MD4_Builtin_Test, self).setUp()
+
+        if has_native_md4():
+
+            # Temporarily make lookup_hash() use builtin pure-python implementation,
+            # by monkeypatching hashlib.new() to ensure we fall back to passlib's md4 class.
+            orig = hashlib.new
+            def wrapper(name, *args):
+                if name == "md4":
+                    raise ValueError("md4 disabled for testing")
+                return orig(name, *args)
+            self.patchAttr(hashlib, "new", wrapper)
+
+            # flush cache before & after test, since we're mucking with it.
+            lookup_hash.clear_cache()
+            self.addCleanup(lookup_hash.clear_cache)
+
+        # make sure we're using right constructor.
+        self.assertEqual(self.get_md4_const().__module__, "passlib.crypto._md4")
+
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_des.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_des.py
new file mode 100644
index 0000000..ab31845
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_des.py
@@ -0,0 +1,194 @@
+"""passlib.tests -- unittests for passlib.crypto.des"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement, division
+# core
+from functools import partial
+# site
+# pkg
+# module
+from passlib.utils import getrandbytes
+from passlib.tests.utils import TestCase
+
+#=============================================================================
+# test DES routines
+#=============================================================================
+class DesTest(TestCase):
+    descriptionPrefix = "passlib.crypto.des"
+
+    # test vectors taken from http://www.skepticfiles.org/faq/testdes.htm
+    des_test_vectors = [
+        # key, plaintext, ciphertext
+        (0x0000000000000000, 0x0000000000000000, 0x8CA64DE9C1B123A7),
+        (0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x7359B2163E4EDC58),
+        (0x3000000000000000, 0x1000000000000001, 0x958E6E627A05557B),
+        (0x1111111111111111, 0x1111111111111111, 0xF40379AB9E0EC533),
+        (0x0123456789ABCDEF, 0x1111111111111111, 0x17668DFC7292532D),
+        (0x1111111111111111, 0x0123456789ABCDEF, 0x8A5AE1F81AB8F2DD),
+        (0x0000000000000000, 0x0000000000000000, 0x8CA64DE9C1B123A7),
+        (0xFEDCBA9876543210, 0x0123456789ABCDEF, 0xED39D950FA74BCC4),
+        (0x7CA110454A1A6E57, 0x01A1D6D039776742, 0x690F5B0D9A26939B),
+        (0x0131D9619DC1376E, 0x5CD54CA83DEF57DA, 0x7A389D10354BD271),
+        (0x07A1133E4A0B2686, 0x0248D43806F67172, 0x868EBB51CAB4599A),
+        (0x3849674C2602319E, 0x51454B582DDF440A, 0x7178876E01F19B2A),
+        (0x04B915BA43FEB5B6, 0x42FD443059577FA2, 0xAF37FB421F8C4095),
+        (0x0113B970FD34F2CE, 0x059B5E0851CF143A, 0x86A560F10EC6D85B),
+        (0x0170F175468FB5E6, 0x0756D8E0774761D2, 0x0CD3DA020021DC09),
+        (0x43297FAD38E373FE, 0x762514B829BF486A, 0xEA676B2CB7DB2B7A),
+        (0x07A7137045DA2A16, 0x3BDD119049372802, 0xDFD64A815CAF1A0F),
+        (0x04689104C2FD3B2F, 0x26955F6835AF609A, 0x5C513C9C4886C088),
+        (0x37D06BB516CB7546, 0x164D5E404F275232, 0x0A2AEEAE3FF4AB77),
+        (0x1F08260D1AC2465E, 0x6B056E18759F5CCA, 0xEF1BF03E5DFA575A),
+        (0x584023641ABA6176, 0x004BD6EF09176062, 0x88BF0DB6D70DEE56),
+        (0x025816164629B007, 0x480D39006EE762F2, 0xA1F9915541020B56),
+        (0x49793EBC79B3258F, 0x437540C8698F3CFA, 0x6FBF1CAFCFFD0556),
+        (0x4FB05E1515AB73A7, 0x072D43A077075292, 0x2F22E49BAB7CA1AC),
+        (0x49E95D6D4CA229BF, 0x02FE55778117F12A, 0x5A6B612CC26CCE4A),
+        (0x018310DC409B26D6, 0x1D9D5C5018F728C2, 0x5F4C038ED12B2E41),
+        (0x1C587F1C13924FEF, 0x305532286D6F295A, 0x63FAC0D034D9F793),
+        (0x0101010101010101, 0x0123456789ABCDEF, 0x617B3A0CE8F07100),
+        (0x1F1F1F1F0E0E0E0E, 0x0123456789ABCDEF, 0xDB958605F8C8C606),
+        (0xE0FEE0FEF1FEF1FE, 0x0123456789ABCDEF, 0xEDBFD1C66C29CCC7),
+        (0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0x355550B2150E2451),
+        (0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0xCAAAAF4DEAF1DBAE),
+        (0x0123456789ABCDEF, 0x0000000000000000, 0xD5D44FF720683D0D),
+        (0xFEDCBA9876543210, 0xFFFFFFFFFFFFFFFF, 0x2A2BB008DF97C2F2),
+    ]
+
+    def test_01_expand(self):
+        """expand_des_key()"""
+        from passlib.crypto.des import expand_des_key, shrink_des_key, \
+                                             _KDATA_MASK, INT_56_MASK
+
+        # make sure test vectors are preserved (sans parity bits)
+        # uses ints, bytes are tested under # 02
+        for key1, _, _ in self.des_test_vectors:
+            key2 = shrink_des_key(key1)
+            key3 = expand_des_key(key2)
+            # NOTE: this assumes expand_des_key() sets parity bits to 0
+            self.assertEqual(key3, key1 & _KDATA_MASK)
+
+        # type checks
+        self.assertRaises(TypeError, expand_des_key, 1.0)
+
+        # too large
+        self.assertRaises(ValueError, expand_des_key, INT_56_MASK+1)
+        self.assertRaises(ValueError, expand_des_key, b"\x00"*8)
+
+        # too small
+        self.assertRaises(ValueError, expand_des_key, -1)
+        self.assertRaises(ValueError, expand_des_key, b"\x00"*6)
+
+    def test_02_shrink(self):
+        """shrink_des_key()"""
+        from passlib.crypto.des import expand_des_key, shrink_des_key, INT_64_MASK
+        rng = self.getRandom()
+
+        # make sure reverse works for some random keys
+        # uses bytes, ints are tested under # 01
+        for i in range(20):
+            key1 = getrandbytes(rng, 7)
+            key2 = expand_des_key(key1)
+            key3 = shrink_des_key(key2)
+            self.assertEqual(key3, key1)
+
+        # type checks
+        self.assertRaises(TypeError, shrink_des_key, 1.0)
+
+        # too large
+        self.assertRaises(ValueError, shrink_des_key, INT_64_MASK+1)
+        self.assertRaises(ValueError, shrink_des_key, b"\x00"*9)
+
+        # too small
+        self.assertRaises(ValueError, shrink_des_key, -1)
+        self.assertRaises(ValueError, shrink_des_key, b"\x00"*7)
+
+    def _random_parity(self, key):
+        """randomize parity bits"""
+        from passlib.crypto.des import _KDATA_MASK, _KPARITY_MASK, INT_64_MASK
+        rng = self.getRandom()
+        return (key & _KDATA_MASK) | (rng.randint(0,INT_64_MASK) & _KPARITY_MASK)
+
+    def test_03_encrypt_bytes(self):
+        """des_encrypt_block()"""
+        from passlib.crypto.des import (des_encrypt_block, shrink_des_key,
+                                              _pack64, _unpack64)
+
+        # run through test vectors
+        for key, plaintext, correct in self.des_test_vectors:
+            # convert to bytes
+            key = _pack64(key)
+            plaintext = _pack64(plaintext)
+            correct = _pack64(correct)
+
+            # test 64-bit key
+            result = des_encrypt_block(key, plaintext)
+            self.assertEqual(result, correct, "key=%r plaintext=%r:" %
+                                              (key, plaintext))
+
+            # test 56-bit version
+            key2 = shrink_des_key(key)
+            result = des_encrypt_block(key2, plaintext)
+            self.assertEqual(result, correct, "key=%r shrink(key)=%r plaintext=%r:" %
+                                              (key, key2, plaintext))
+
+            # test with random parity bits
+            for _ in range(20):
+                key3 = _pack64(self._random_parity(_unpack64(key)))
+                result = des_encrypt_block(key3, plaintext)
+                self.assertEqual(result, correct, "key=%r rndparity(key)=%r plaintext=%r:" %
+                                                  (key, key3, plaintext))
+
+        # check invalid keys
+        stub = b'\x00' * 8
+        self.assertRaises(TypeError, des_encrypt_block, 0, stub)
+        self.assertRaises(ValueError, des_encrypt_block, b'\x00'*6, stub)
+
+        # check invalid input
+        self.assertRaises(TypeError, des_encrypt_block, stub, 0)
+        self.assertRaises(ValueError, des_encrypt_block, stub, b'\x00'*7)
+
+        # check invalid salts
+        self.assertRaises(ValueError, des_encrypt_block, stub, stub, salt=-1)
+        self.assertRaises(ValueError, des_encrypt_block, stub, stub, salt=1<<24)
+
+        # check invalid rounds
+        self.assertRaises(ValueError, des_encrypt_block, stub, stub, 0, rounds=0)
+
+    def test_04_encrypt_ints(self):
+        """des_encrypt_int_block()"""
+        from passlib.crypto.des import des_encrypt_int_block
+
+        # run through test vectors
+        for key, plaintext, correct in self.des_test_vectors:
+            # test 64-bit key
+            result = des_encrypt_int_block(key, plaintext)
+            self.assertEqual(result, correct, "key=%r plaintext=%r:" %
+                                              (key, plaintext))
+
+            # test with random parity bits
+            for _ in range(20):
+                key3 = self._random_parity(key)
+                result = des_encrypt_int_block(key3, plaintext)
+                self.assertEqual(result, correct, "key=%r rndparity(key)=%r plaintext=%r:" %
+                                                  (key, key3, plaintext))
+
+        # check invalid keys
+        self.assertRaises(TypeError, des_encrypt_int_block, b'\x00', 0)
+        self.assertRaises(ValueError, des_encrypt_int_block, -1, 0)
+
+        # check invalid input
+        self.assertRaises(TypeError, des_encrypt_int_block, 0, b'\x00')
+        self.assertRaises(ValueError, des_encrypt_int_block, 0, -1)
+
+        # check invalid salts
+        self.assertRaises(ValueError, des_encrypt_int_block, 0, 0, salt=-1)
+        self.assertRaises(ValueError, des_encrypt_int_block, 0, 0, salt=1<<24)
+
+        # check invalid rounds
+        self.assertRaises(ValueError, des_encrypt_int_block, 0, 0, 0, rounds=0)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_digest.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_digest.py
new file mode 100644
index 0000000..461d209
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_digest.py
@@ -0,0 +1,544 @@
+"""tests for passlib.utils.(des|pbkdf2|md4)"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement, division
+# core
+from binascii import hexlify
+import hashlib
+import warnings
+# site
+# pkg
+# module
+from passlib.exc import UnknownHashError
+from passlib.utils.compat import PY3, u, JYTHON
+from passlib.tests.utils import TestCase, TEST_MODE, skipUnless, hb
+
+#=============================================================================
+# test assorted crypto helpers
+#=============================================================================
+class HashInfoTest(TestCase):
+    """test various crypto functions"""
+    descriptionPrefix = "passlib.crypto.digest"
+
+    #: list of formats norm_hash_name() should support
+    norm_hash_formats = ["hashlib", "iana"]
+
+    #: test cases for norm_hash_name()
+    #: each row contains (iana name, hashlib name, ... 0+ unnormalized names)
+    norm_hash_samples = [
+        # real hashes
+        ("md5",       "md5",         "SCRAM-MD5-PLUS",   "MD-5"),
+        ("sha1",      "sha-1",       "SCRAM-SHA-1",      "SHA1"),
+        ("sha256",    "sha-256",     "SHA_256",          "sha2-256"),
+        ("ripemd160", "ripemd-160",  "SCRAM-RIPEMD-160", "RIPEmd160",
+            # NOTE: there was an older "RIPEMD" & "RIPEMD-128", but python treates "RIPEMD"
+            #       as alias for "RIPEMD-160"
+            "ripemd", "SCRAM-RIPEMD"),
+
+        # fake hashes (to check if fallback normalization behaves sanely)
+        ("sha4_256",  "sha4-256",    "SHA4-256",         "SHA-4-256"),
+        ("test128",   "test-128",    "TEST128"),
+        ("test2",     "test2",       "TEST-2"),
+        ("test3_128",  "test3-128",   "TEST-3-128"),
+    ]
+
+    def test_norm_hash_name(self):
+        """norm_hash_name()"""
+        from itertools import chain
+        from passlib.crypto.digest import norm_hash_name, _known_hash_names
+
+        # snapshot warning state, ignore unknown hash warnings
+        ctx = warnings.catch_warnings()
+        ctx.__enter__()
+        self.addCleanup(ctx.__exit__)
+        warnings.filterwarnings("ignore", '.*unknown hash')
+        warnings.filterwarnings("ignore", '.*unsupported hash')
+
+        # test string types
+        self.assertEqual(norm_hash_name(u("MD4")), "md4")
+        self.assertEqual(norm_hash_name(b"MD4"), "md4")
+        self.assertRaises(TypeError, norm_hash_name, None)
+
+        # test selected results
+        for row in chain(_known_hash_names, self.norm_hash_samples):
+            for idx, format in enumerate(self.norm_hash_formats):
+                correct = row[idx]
+                for value in row:
+                    result = norm_hash_name(value, format)
+                    self.assertEqual(result, correct,
+                                     "name=%r, format=%r:" % (value,
+                                                              format))
+
+    def test_lookup_hash_ctor(self):
+        """lookup_hash() -- constructor"""
+        from passlib.crypto.digest import lookup_hash
+
+        # invalid/unknown names should be rejected
+        self.assertRaises(ValueError, lookup_hash, "new")
+        self.assertRaises(ValueError, lookup_hash, "__name__")
+        self.assertRaises(ValueError, lookup_hash, "sha4")
+
+        # 1. should return hashlib builtin if found
+        self.assertEqual(lookup_hash("md5"), (hashlib.md5, 16, 64))
+
+        # 2. should return wrapper around hashlib.new() if found
+        try:
+            hashlib.new("sha")
+            has_sha = True
+        except ValueError:
+            has_sha = False
+        if has_sha:
+            record = lookup_hash("sha")
+            const = record[0]
+            self.assertEqual(record, (const, 20, 64))
+            self.assertEqual(hexlify(const(b"abc").digest()),
+                             b"0164b8a914cd2a5e74c4f7ff082c4d97f1edf880")
+
+        else:
+            self.assertRaises(ValueError, lookup_hash, "sha")
+
+        # 3. should fall back to builtin md4
+        try:
+            hashlib.new("md4")
+            has_md4 = True
+        except ValueError:
+            has_md4 = False
+        record = lookup_hash("md4")
+        const = record[0]
+        if not has_md4:
+            from passlib.crypto._md4 import md4
+            self.assertIs(const, md4)
+        self.assertEqual(record, (const, 16, 64))
+        self.assertEqual(hexlify(const(b"abc").digest()),
+                         b"a448017aaf21d8525fc10ae87aa6729d")
+
+        # should memoize records
+        self.assertIs(lookup_hash("md5"), lookup_hash("md5"))
+
+    def test_lookup_hash_w_unknown_name(self):
+        """lookup_hash() -- unknown hash name"""
+        from passlib.crypto.digest import lookup_hash
+
+        # unknown names should be rejected by default
+        self.assertRaises(UnknownHashError, lookup_hash, "xxx256")
+
+        # required=False should return stub record instead
+        info = lookup_hash("xxx256", required=False)
+        self.assertFalse(info.supported)
+        self.assertRaisesRegex(UnknownHashError, "unknown hash: 'xxx256'", info.const)
+        self.assertEqual(info.name, "xxx256")
+        self.assertEqual(info.digest_size, None)
+        self.assertEqual(info.block_size, None)
+
+        # should cache stub records
+        info2 = lookup_hash("xxx256", required=False)
+        self.assertIs(info2, info)
+
+    def test_mock_fips_mode(self):
+        """
+        lookup_hash() -- test set_mock_fips_mode()
+        """
+        from passlib.crypto.digest import lookup_hash, _set_mock_fips_mode
+
+        # check if md5 is available so we can test mock helper
+        if not lookup_hash("md5", required=False).supported:
+            raise self.skipTest("md5 not supported")
+
+        # enable monkeypatch to mock up fips mode
+        _set_mock_fips_mode()
+        self.addCleanup(_set_mock_fips_mode, False)
+
+        pat = "'md5' hash disabled for fips"
+        self.assertRaisesRegex(UnknownHashError, pat, lookup_hash, "md5")
+
+        info = lookup_hash("md5", required=False)
+        self.assertRegex(info.error_text, pat)
+        self.assertRaisesRegex(UnknownHashError, pat, info.const)
+
+        # should use hardcoded fallback info
+        self.assertEqual(info.digest_size, 16)
+        self.assertEqual(info.block_size, 64)
+
+    def test_lookup_hash_metadata(self):
+        """lookup_hash() -- metadata"""
+
+        from passlib.crypto.digest import lookup_hash
+
+        # quick test of metadata using known reference - sha256
+        info = lookup_hash("sha256")
+        self.assertEqual(info.name, "sha256")
+        self.assertEqual(info.iana_name, "sha-256")
+        self.assertEqual(info.block_size, 64)
+        self.assertEqual(info.digest_size, 32)
+        self.assertIs(lookup_hash("SHA2-256"), info)
+
+        # quick test of metadata using known reference - md5
+        info = lookup_hash("md5")
+        self.assertEqual(info.name, "md5")
+        self.assertEqual(info.iana_name, "md5")
+        self.assertEqual(info.block_size, 64)
+        self.assertEqual(info.digest_size, 16)
+
+    def test_lookup_hash_alt_types(self):
+        """lookup_hash() -- alternate types"""
+
+        from passlib.crypto.digest import lookup_hash
+
+        info = lookup_hash("sha256")
+        self.assertIs(lookup_hash(info), info)
+        self.assertIs(lookup_hash(info.const), info)
+
+        self.assertRaises(TypeError, lookup_hash, 123)
+
+    # TODO: write full test of compile_hmac() -- currently relying on pbkdf2_hmac() tests
+
+#=============================================================================
+# test PBKDF1 support
+#=============================================================================
+class Pbkdf1_Test(TestCase):
+    """test kdf helpers"""
+    descriptionPrefix = "passlib.crypto.digest.pbkdf1"
+
+    pbkdf1_tests = [
+        # (password, salt, rounds, keylen, hash, result)
+
+        #
+        # from http://www.di-mgt.com.au/cryptoKDFs.html
+        #
+        (b'password', hb('78578E5A5D63CB06'), 1000, 16, 'sha1', hb('dc19847e05c64d2faf10ebfb4a3d2a20')),
+
+        #
+        # custom
+        #
+        (b'password', b'salt', 1000, 0, 'md5',    b''),
+        (b'password', b'salt', 1000, 1, 'md5',    hb('84')),
+        (b'password', b'salt', 1000, 8, 'md5',    hb('8475c6a8531a5d27')),
+        (b'password', b'salt', 1000, 16, 'md5', hb('8475c6a8531a5d27e386cd496457812c')),
+        (b'password', b'salt', 1000, None, 'md5', hb('8475c6a8531a5d27e386cd496457812c')),
+        (b'password', b'salt', 1000, None, 'sha1', hb('4a8fd48e426ed081b535be5769892fa396293efb')),
+    ]
+    if not JYTHON: # FIXME: find out why not jython, or reenable this.
+        pbkdf1_tests.append(
+            (b'password', b'salt', 1000, None, 'md4', hb('f7f2e91100a8f96190f2dd177cb26453'))
+        )
+
+    def test_known(self):
+        """test reference vectors"""
+        from passlib.crypto.digest import pbkdf1
+        for secret, salt, rounds, keylen, digest, correct in self.pbkdf1_tests:
+            result = pbkdf1(digest, secret, salt, rounds, keylen)
+            self.assertEqual(result, correct)
+
+    def test_border(self):
+        """test border cases"""
+        from passlib.crypto.digest import pbkdf1
+        def helper(secret=b'secret', salt=b'salt', rounds=1, keylen=1, hash='md5'):
+            return pbkdf1(hash, secret, salt, rounds, keylen)
+        helper()
+
+        # salt/secret wrong type
+        self.assertRaises(TypeError, helper, secret=1)
+        self.assertRaises(TypeError, helper, salt=1)
+
+        # non-existent hashes
+        self.assertRaises(ValueError, helper, hash='missing')
+
+        # rounds < 1 and wrong type
+        self.assertRaises(ValueError, helper, rounds=0)
+        self.assertRaises(TypeError, helper, rounds='1')
+
+        # keylen < 0, keylen > block_size, and wrong type
+        self.assertRaises(ValueError, helper, keylen=-1)
+        self.assertRaises(ValueError, helper, keylen=17, hash='md5')
+        self.assertRaises(TypeError, helper, keylen='1')
+
+#=============================================================================
+# test PBKDF2-HMAC support
+#=============================================================================
+
+# import the test subject
+from passlib.crypto.digest import pbkdf2_hmac, PBKDF2_BACKENDS
+
+# NOTE: relying on tox to verify this works under all the various backends.
+class Pbkdf2Test(TestCase):
+    """test pbkdf2() support"""
+    descriptionPrefix = "passlib.crypto.digest.pbkdf2_hmac() <backends: %s>" % ", ".join(PBKDF2_BACKENDS)
+
+    pbkdf2_test_vectors = [
+        # (result, secret, salt, rounds, keylen, digest="sha1")
+
+        #
+        # from rfc 3962
+        #
+
+            # test case 1 / 128 bit
+            (
+                hb("cdedb5281bb2f801565a1122b2563515"),
+                b"password", b"ATHENA.MIT.EDUraeburn", 1, 16
+            ),
+
+            # test case 2 / 128 bit
+            (
+                hb("01dbee7f4a9e243e988b62c73cda935d"),
+                b"password", b"ATHENA.MIT.EDUraeburn", 2, 16
+            ),
+
+            # test case 2 / 256 bit
+            (
+                hb("01dbee7f4a9e243e988b62c73cda935da05378b93244ec8f48a99e61ad799d86"),
+                b"password", b"ATHENA.MIT.EDUraeburn", 2, 32
+            ),
+
+            # test case 3 / 256 bit
+            (
+                hb("5c08eb61fdf71e4e4ec3cf6ba1f5512ba7e52ddbc5e5142f708a31e2e62b1e13"),
+                b"password", b"ATHENA.MIT.EDUraeburn", 1200, 32
+            ),
+
+            # test case 4 / 256 bit
+            (
+                hb("d1daa78615f287e6a1c8b120d7062a493f98d203e6be49a6adf4fa574b6e64ee"),
+                b"password", b'\x12\x34\x56\x78\x78\x56\x34\x12', 5, 32
+            ),
+
+            # test case 5 / 256 bit
+            (
+                hb("139c30c0966bc32ba55fdbf212530ac9c5ec59f1a452f5cc9ad940fea0598ed1"),
+                b"X"*64, b"pass phrase equals block size", 1200, 32
+            ),
+
+            # test case 6 / 256 bit
+            (
+                hb("9ccad6d468770cd51b10e6a68721be611a8b4d282601db3b36be9246915ec82a"),
+                b"X"*65, b"pass phrase exceeds block size", 1200, 32
+            ),
+
+        #
+        # from rfc 6070
+        #
+            (
+                hb("0c60c80f961f0e71f3a9b524af6012062fe037a6"),
+                b"password", b"salt", 1, 20,
+            ),
+
+            (
+                hb("ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957"),
+                b"password", b"salt", 2, 20,
+            ),
+
+            (
+                hb("4b007901b765489abead49d926f721d065a429c1"),
+                b"password", b"salt", 4096, 20,
+            ),
+
+            # just runs too long - could enable if ALL option is set
+            ##(
+            ##
+            ##    hb("eefe3d61cd4da4e4e9945b3d6ba2158c2634e984"),
+            ##    "password", "salt", 16777216, 20,
+            ##),
+
+            (
+                hb("3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038"),
+                b"passwordPASSWORDpassword",
+                b"saltSALTsaltSALTsaltSALTsaltSALTsalt",
+                4096, 25,
+            ),
+
+            (
+                hb("56fa6aa75548099dcc37d7f03425e0c3"),
+                b"pass\00word", b"sa\00lt", 4096, 16,
+            ),
+
+        #
+        # from example in http://grub.enbug.org/Authentication
+        #
+            (
+               hb("887CFF169EA8335235D8004242AA7D6187A41E3187DF0CE14E256D85ED"
+                  "97A97357AAA8FF0A3871AB9EEFF458392F462F495487387F685B7472FC"
+                  "6C29E293F0A0"),
+               b"hello",
+               hb("9290F727ED06C38BA4549EF7DE25CF5642659211B7FC076F2D28FEFD71"
+                  "784BB8D8F6FB244A8CC5C06240631B97008565A120764C0EE9C2CB0073"
+                  "994D79080136"),
+               10000, 64, "sha512"
+            ),
+
+        #
+        # test vectors from fastpbkdf2 <https://github.com/ctz/fastpbkdf2/blob/master/testdata.py>
+        #
+            (
+                hb('55ac046e56e3089fec1691c22544b605f94185216dde0465e68b9d57c20dacbc'
+                   '49ca9cccf179b645991664b39d77ef317c71b845b1e30bd509112041d3a19783'),
+                b'passwd', b'salt', 1, 64, 'sha256',
+            ),
+
+            (
+                hb('4ddcd8f60b98be21830cee5ef22701f9641a4418d04c0414aeff08876b34ab56'
+                   'a1d425a1225833549adb841b51c9b3176a272bdebba1d078478f62b397f33c8d'),
+                b'Password', b'NaCl', 80000, 64, 'sha256',
+            ),
+
+            (
+                hb('120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b'),
+                b'password', b'salt', 1, 32, 'sha256',
+            ),
+
+            (
+                hb('ae4d0c95af6b46d32d0adff928f06dd02a303f8ef3c251dfd6e2d85a95474c43'),
+                b'password', b'salt', 2, 32, 'sha256',
+            ),
+
+            (
+                hb('c5e478d59288c841aa530db6845c4c8d962893a001ce4e11a4963873aa98134a'),
+                b'password', b'salt', 4096, 32, 'sha256',
+            ),
+
+            (
+                hb('348c89dbcbd32b2f32d814b8116e84cf2b17347ebc1800181c4e2a1fb8dd53e1c'
+                   '635518c7dac47e9'),
+                b'passwordPASSWORDpassword', b'saltSALTsaltSALTsaltSALTsaltSALTsalt',
+                4096, 40, 'sha256',
+            ),
+
+            (
+                hb('9e83f279c040f2a11aa4a02b24c418f2d3cb39560c9627fa4f47e3bcc2897c3d'),
+                b'', b'salt', 1024, 32, 'sha256',
+            ),
+
+            (
+                hb('ea5808411eb0c7e830deab55096cee582761e22a9bc034e3ece925225b07bf46'),
+                b'password', b'', 1024, 32, 'sha256',
+            ),
+
+            (
+                hb('89b69d0516f829893c696226650a8687'),
+                b'pass\x00word', b'sa\x00lt', 4096, 16, 'sha256',
+            ),
+
+            (
+                hb('867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252'),
+                b'password', b'salt', 1, 32, 'sha512',
+            ),
+
+            (
+                hb('e1d9c16aa681708a45f5c7c4e215ceb66e011a2e9f0040713f18aefdb866d53c'),
+                b'password', b'salt', 2, 32, 'sha512',
+            ),
+
+            (
+                hb('d197b1b33db0143e018b12f3d1d1479e6cdebdcc97c5c0f87f6902e072f457b5'),
+                b'password', b'salt', 4096, 32, 'sha512',
+            ),
+
+            (
+                hb('6e23f27638084b0f7ea1734e0d9841f55dd29ea60a834466f3396bac801fac1eeb'
+                   '63802f03a0b4acd7603e3699c8b74437be83ff01ad7f55dac1ef60f4d56480c35e'
+                   'e68fd52c6936'),
+                b'passwordPASSWORDpassword', b'saltSALTsaltSALTsaltSALTsaltSALTsalt',
+                1, 72, 'sha512',
+            ),
+
+            (
+                hb('0c60c80f961f0e71f3a9b524af6012062fe037a6'),
+                b'password', b'salt', 1, 20, 'sha1',
+            ),
+
+        #
+        # custom tests
+        #
+            (
+                hb('e248fb6b13365146f8ac6307cc222812'),
+                b"secret", b"salt", 10, 16, "sha1",
+            ),
+            (
+                hb('e248fb6b13365146f8ac6307cc2228127872da6d'),
+                b"secret", b"salt", 10, None, "sha1",
+            ),
+            (
+                hb('b1d5485772e6f76d5ebdc11b38d3eff0a5b2bd50dc11f937e86ecacd0cd40d1b'
+                   '9113e0734e3b76a3'),
+                b"secret", b"salt", 62, 40, "md5",
+            ),
+            (
+                hb('ea014cc01f78d3883cac364bb5d054e2be238fb0b6081795a9d84512126e3129'
+                   '062104d2183464c4'),
+                b"secret", b"salt", 62, 40, "md4",
+            ),
+        ]
+
+    def test_known(self):
+        """test reference vectors"""
+        for row in self.pbkdf2_test_vectors:
+            correct, secret, salt, rounds, keylen = row[:5]
+            digest = row[5] if len(row) == 6 else "sha1"
+            result = pbkdf2_hmac(digest, secret, salt, rounds, keylen)
+            self.assertEqual(result, correct)
+
+    def test_backends(self):
+        """verify expected backends are present"""
+        from passlib.crypto.digest import PBKDF2_BACKENDS
+
+        # check for fastpbkdf2
+        try:
+            import fastpbkdf2
+            has_fastpbkdf2 = True
+        except ImportError:
+            has_fastpbkdf2 = False
+        self.assertEqual("fastpbkdf2" in PBKDF2_BACKENDS, has_fastpbkdf2)
+
+        # check for hashlib
+        try:
+            from hashlib import pbkdf2_hmac
+            has_hashlib_ssl = pbkdf2_hmac.__module__ != "hashlib"
+        except ImportError:
+            has_hashlib_ssl = False
+        self.assertEqual("hashlib-ssl" in PBKDF2_BACKENDS, has_hashlib_ssl)
+
+        # check for appropriate builtin
+        from passlib.utils.compat import PY3
+        if PY3:
+            self.assertIn("builtin-from-bytes", PBKDF2_BACKENDS)
+        else:
+            # XXX: only true as long as this is preferred over hexlify
+            self.assertIn("builtin-unpack", PBKDF2_BACKENDS)
+
+    def test_border(self):
+        """test border cases"""
+        def helper(secret=b'password', salt=b'salt', rounds=1, keylen=None, digest="sha1"):
+            return pbkdf2_hmac(digest, secret, salt, rounds, keylen)
+        helper()
+
+        # invalid rounds
+        self.assertRaises(ValueError, helper, rounds=-1)
+        self.assertRaises(ValueError, helper, rounds=0)
+        self.assertRaises(TypeError, helper, rounds='x')
+
+        # invalid keylen
+        helper(keylen=1)
+        self.assertRaises(ValueError, helper, keylen=-1)
+        self.assertRaises(ValueError, helper, keylen=0)
+        # NOTE: hashlib actually throws error for keylen>=MAX_SINT32,
+        #       but pbkdf2 forbids anything > MAX_UINT32 * digest_size
+        self.assertRaises(OverflowError, helper, keylen=20*(2**32-1)+1)
+        self.assertRaises(TypeError, helper, keylen='x')
+
+        # invalid secret/salt type
+        self.assertRaises(TypeError, helper, salt=5)
+        self.assertRaises(TypeError, helper, secret=5)
+
+        # invalid hash
+        self.assertRaises(ValueError, helper, digest='foo')
+        self.assertRaises(TypeError, helper, digest=5)
+
+    def test_default_keylen(self):
+        """test keylen==None"""
+        def helper(secret=b'password', salt=b'salt', rounds=1, keylen=None, digest="sha1"):
+            return pbkdf2_hmac(digest, secret, salt, rounds, keylen)
+        self.assertEqual(len(helper(digest='sha1')), 20)
+        self.assertEqual(len(helper(digest='sha256')), 32)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_scrypt.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_scrypt.py
new file mode 100644
index 0000000..73ff1fa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_crypto_scrypt.py
@@ -0,0 +1,634 @@
+"""tests for passlib.utils.scrypt"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from binascii import hexlify
+import hashlib
+import logging; log = logging.getLogger(__name__)
+import struct
+import warnings
+warnings.filterwarnings("ignore", ".*using builtin scrypt backend.*")
+# site
+# pkg
+from passlib import exc
+from passlib.utils import getrandbytes
+from passlib.utils.compat import PYPY, u, bascii_to_str
+from passlib.utils.decor import classproperty
+from passlib.tests.utils import TestCase, skipUnless, TEST_MODE, hb
+# subject
+from passlib.crypto import scrypt as scrypt_mod
+# local
+__all__ = [
+    "ScryptEngineTest",
+    "BuiltinScryptTest",
+    "FastScryptTest",
+]
+
+#=============================================================================
+# support functions
+#=============================================================================
+def hexstr(data):
+    """return bytes as hex str"""
+    return bascii_to_str(hexlify(data))
+
+def unpack_uint32_list(data, check_count=None):
+    """unpack bytes as list of uint32 values"""
+    count = len(data) // 4
+    assert check_count is None or check_count == count
+    return struct.unpack("<%dI" % count, data)
+
+def seed_bytes(seed, count):
+    """
+    generate random reference bytes from specified seed.
+    used to generate some predictable test vectors.
+    """
+    if hasattr(seed, "encode"):
+        seed = seed.encode("ascii")
+    buf = b''
+    i = 0
+    while len(buf) < count:
+        buf += hashlib.sha256(seed + struct.pack("<I", i)).digest()
+        i += 1
+    return buf[:count]
+
+#=============================================================================
+# test builtin engine's internals
+#=============================================================================
+class ScryptEngineTest(TestCase):
+    descriptionPrefix = "passlib.crypto.scrypt._builtin"
+
+    def test_smix(self):
+        """smix()"""
+        from passlib.crypto.scrypt._builtin import ScryptEngine
+        rng = self.getRandom()
+
+        #-----------------------------------------------------------------------
+        # test vector from (expired) scrypt rfc draft
+        # (https://tools.ietf.org/html/draft-josefsson-scrypt-kdf-01, section 9)
+        #-----------------------------------------------------------------------
+
+        input = hb("""
+            f7 ce 0b 65 3d 2d 72 a4 10 8c f5 ab e9 12 ff dd
+            77 76 16 db bb 27 a7 0e 82 04 f3 ae 2d 0f 6f ad
+            89 f6 8f 48 11 d1 e8 7b cc 3b d7 40 0a 9f fd 29
+            09 4f 01 84 63 95 74 f3 9a e5 a1 31 52 17 bc d7
+            89 49 91 44 72 13 bb 22 6c 25 b5 4d a8 63 70 fb
+            cd 98 43 80 37 46 66 bb 8f fc b5 bf 40 c2 54 b0
+            67 d2 7c 51 ce 4a d5 fe d8 29 c9 0b 50 5a 57 1b
+            7f 4d 1c ad 6a 52 3c da 77 0e 67 bc ea af 7e 89
+            """)
+
+        output = hb("""
+            79 cc c1 93 62 9d eb ca 04 7f 0b 70 60 4b f6 b6
+            2c e3 dd 4a 96 26 e3 55 fa fc 61 98 e6 ea 2b 46
+            d5 84 13 67 3b 99 b0 29 d6 65 c3 57 60 1f b4 26
+            a0 b2 f4 bb a2 00 ee 9f 0a 43 d1 9b 57 1a 9c 71
+            ef 11 42 e6 5d 5a 26 6f dd ca 83 2c e5 9f aa 7c
+            ac 0b 9c f1 be 2b ff ca 30 0d 01 ee 38 76 19 c4
+            ae 12 fd 44 38 f2 03 a0 e4 e1 c4 7e c3 14 86 1f
+            4e 90 87 cb 33 39 6a 68 73 e8 f9 d2 53 9a 4b 8e
+            """)
+
+        # NOTE: p value should be ignored, so testing w/ random inputs.
+        engine = ScryptEngine(n=16, r=1, p=rng.randint(1, 1023))
+        self.assertEqual(engine.smix(input), output)
+
+    def test_bmix(self):
+        """bmix()"""
+        from passlib.crypto.scrypt._builtin import ScryptEngine
+        rng = self.getRandom()
+
+        # NOTE: bmix() call signature currently takes in list of 32*r uint32 elements,
+        #       and writes to target buffer of same size.
+
+        def check_bmix(r, input, output):
+            """helper to check bmix() output against reference"""
+            # NOTE: * n & p values should be ignored, so testing w/ rng inputs.
+            #       * target buffer contents should be ignored, so testing w/ random inputs.
+            engine = ScryptEngine(r=r, n=1 << rng.randint(1, 32), p=rng.randint(1, 1023))
+            target = [rng.randint(0, 1 << 32) for _ in range((2 * r) * 16)]
+            engine.bmix(input, target)
+            self.assertEqual(target, list(output))
+
+            # ScryptEngine special-cases bmix() for r=1.
+            # this removes the special case patching, so we also test original bmix function.
+            if r == 1:
+                del engine.bmix
+                target = [rng.randint(0, 1 << 32) for _ in range((2 * r) * 16)]
+                engine.bmix(input, target)
+                self.assertEqual(target, list(output))
+
+        #-----------------------------------------------------------------------
+        # test vector from (expired) scrypt rfc draft
+        # (https://tools.ietf.org/html/draft-josefsson-scrypt-kdf-01, section 8)
+        #-----------------------------------------------------------------------
+
+        # NOTE: this pair corresponds to the first input & output pair
+        #       from the test vector in test_smix(), above.
+        # NOTE: original reference lists input & output as two separate 64 byte blocks.
+        #       current internal representation used by bmix() uses single 2*r*16 array of uint32,
+        #       combining all the B blocks into a single flat array.
+        input = unpack_uint32_list(hb("""
+                f7 ce 0b 65 3d 2d 72 a4 10 8c f5 ab e9 12 ff dd
+                77 76 16 db bb 27 a7 0e 82 04 f3 ae 2d 0f 6f ad
+                89 f6 8f 48 11 d1 e8 7b cc 3b d7 40 0a 9f fd 29
+                09 4f 01 84 63 95 74 f3 9a e5 a1 31 52 17 bc d7
+
+                89 49 91 44 72 13 bb 22 6c 25 b5 4d a8 63 70 fb
+                cd 98 43 80 37 46 66 bb 8f fc b5 bf 40 c2 54 b0
+                67 d2 7c 51 ce 4a d5 fe d8 29 c9 0b 50 5a 57 1b
+                7f 4d 1c ad 6a 52 3c da 77 0e 67 bc ea af 7e 89
+            """), 32)
+
+        output = unpack_uint32_list(hb("""
+                a4 1f 85 9c 66 08 cc 99 3b 81 ca cb 02 0c ef 05
+                04 4b 21 81 a2 fd 33 7d fd 7b 1c 63 96 68 2f 29
+                b4 39 31 68 e3 c9 e6 bc fe 6b c5 b7 a0 6d 96 ba
+                e4 24 cc 10 2c 91 74 5c 24 ad 67 3d c7 61 8f 81
+
+                20 ed c9 75 32 38 81 a8 05 40 f6 4c 16 2d cd 3c
+                21 07 7c fe 5f 8d 5f e2 b1 a4 16 8f 95 36 78 b7
+                7d 3b 3d 80 3b 60 e4 ab 92 09 96 e5 9b 4d 53 b6
+                5d 2a 22 58 77 d5 ed f5 84 2c b9 f1 4e ef e4 25
+            """), 32)
+
+#        check_bmix(1, input, output)
+
+        #-----------------------------------------------------------------------
+        # custom test vector for r=2
+        # used to check for bmix() breakage while optimizing implementation.
+        #-----------------------------------------------------------------------
+
+        r = 2
+        input = unpack_uint32_list(seed_bytes("bmix with r=2", 128 * r))
+
+        output = unpack_uint32_list(hb("""
+            ba240854954f4585f3d0573321f10beee96f12acdc1feb498131e40512934fd7
+            43e8139c17d0743c89d09ac8c3582c273c60ab85db63e410d049a9e17a42c6a1
+
+            6c7831b11bf370266afdaff997ae1286920dea1dedf0f4a1795ba710ba9017f1
+            a374400766f13ebd8969362de2d153965e9941bdde0768fa5b53e8522f116ce0
+
+            d14774afb88f46cd919cba4bc64af7fca0ecb8732d1fc2191e0d7d1b6475cb2e
+            e3db789ee478d056c4eb6c6e28b99043602dbb8dfb60c6e048bf90719da8d57d
+
+            3c42250e40ab79a1ada6aae9299b9790f767f54f388d024a1465b30cbbe9eb89
+            002d4f5c215c4259fac4d083bac5fb0b47463747d568f40bb7fa87c42f0a1dc1
+            """), 32 * r)
+
+        check_bmix(r, input, output)
+
+        #-----------------------------------------------------------------------
+        # custom test vector for r=3
+        # used to check for bmix() breakage while optimizing implementation.
+        #-----------------------------------------------------------------------
+
+        r = 3
+        input = unpack_uint32_list(seed_bytes("bmix with r=3", 128 * r))
+
+        output = unpack_uint32_list(hb("""
+            11ddd8cf60c61f59a6e5b128239bdc77b464101312c88bd1ccf6be6e75461b29
+            7370d4770c904d0b09c402573cf409bf2db47b91ba87d5a3de469df8fb7a003c
+
+            95a66af96dbdd88beddc8df51a2f72a6f588d67e7926e9c2b676c875da13161e
+            b6262adac39e6b3003e9a6fbc8c1a6ecf1e227c03bc0af3e5f8736c339b14f84
+
+            c7ae5b89f5e16d0faf8983551165f4bb712d97e4f81426e6b78eb63892d3ff54
+            80bf406c98e479496d0f76d23d728e67d2a3d2cdbc4a932be6db36dc37c60209
+
+            a5ca76ca2d2979f995f73fe8182eefa1ce0ba0d4fc27d5b827cb8e67edd6552f
+            00a5b3ab6b371bd985a158e728011314eb77f32ade619b3162d7b5078a19886c
+
+            06f12bc8ae8afa46489e5b0239954d5216967c928982984101e4a88bae1f60ae
+            3f8a456e169a8a1c7450e7955b8a13a202382ae19d41ce8ef8b6a15eeef569a7
+
+            20f54c48e44cb5543dda032c1a50d5ddf2919030624978704eb8db0290052a1f
+            5d88989b0ef931b6befcc09e9d5162320e71e80b89862de7e2f0b6c67229b93f
+            """), 32 * r)
+
+        check_bmix(r, input, output)
+
+        #-----------------------------------------------------------------------
+        # custom test vector for r=4
+        # used to check for bmix() breakage while optimizing implementation.
+        #-----------------------------------------------------------------------
+
+        r = 4
+        input = unpack_uint32_list(seed_bytes("bmix with r=4", 128 * r))
+
+        output = unpack_uint32_list(hb("""
+            803fcf7362702f30ef43250f20bc6b1b8925bf5c4a0f5a14bbfd90edce545997
+            3047bd81655f72588ca93f5c2f4128adaea805e0705a35e14417101fdb1c498c
+
+            33bec6f4e5950d66098da8469f3fe633f9a17617c0ea21275185697c0e4608f7
+            e6b38b7ec71704a810424637e2c296ca30d9cbf8172a71a266e0393deccf98eb
+
+            abc430d5f144eb0805308c38522f2973b7b6a48498851e4c762874497da76b88
+            b769b471fbfc144c0e8e859b2b3f5a11f51604d268c8fd28db55dff79832741a
+
+            1ac0dfdaff10f0ada0d93d3b1f13062e4107c640c51df05f4110bdda15f51b53
+            3a75bfe56489a6d8463440c78fb8c0794135e38591bdc5fa6cec96a124178a4a
+
+            d1a976e985bfe13d2b4af51bd0fc36dd4cfc3af08efe033b2323a235205dc43d
+            e57778a492153f9527338b3f6f5493a03d8015cd69737ee5096ad4cbe660b10f
+
+            b75b1595ddc96e3748f5c9f61fba1ef1f0c51b6ceef8bbfcc34b46088652e6f7
+            edab61521cbad6e69b77be30c9c97ea04a4af359dafc205c7878cc9a6c5d122f
+
+            8d77f3cbe65ab14c3c491ef94ecb3f5d2c2dd13027ea4c3606262bb3c9ce46e7
+            dc424729dc75f6e8f06096c0ad8ad4d549c42f0cad9b33cb95d10fb3cadba27c
+
+            5f4bf0c1ac677c23ba23b64f56afc3546e62d96f96b58d7afc5029f8168cbab4
+            533fd29fc83c8d2a32b81923992e4938281334e0c3694f0ee56f8ff7df7dc4ae
+            """), 32 * r)
+
+        check_bmix(r, input, output)
+
+    def test_salsa(self):
+        """salsa20()"""
+        from passlib.crypto.scrypt._builtin import salsa20
+
+        # NOTE: salsa2() currently operates on lists of 16 uint32 elements,
+        #       which is what unpack_uint32_list(hb(() is for...
+
+        #-----------------------------------------------------------------------
+        # test vector from (expired) scrypt rfc draft
+        # (https://tools.ietf.org/html/draft-josefsson-scrypt-kdf-01, section 7)
+        #-----------------------------------------------------------------------
+
+        # NOTE: this pair corresponds to the first input & output pair
+        #       from the test vector in test_bmix(), above.
+
+        input = unpack_uint32_list(hb("""
+            7e 87 9a 21 4f 3e c9 86 7c a9 40 e6 41 71 8f 26
+            ba ee 55 5b 8c 61 c1 b5 0d f8 46 11 6d cd 3b 1d
+            ee 24 f3 19 df 9b 3d 85 14 12 1e 4b 5a c5 aa 32
+            76 02 1d 29 09 c7 48 29 ed eb c6 8d b8 b8 c2 5e
+            """))
+
+        output = unpack_uint32_list(hb("""
+            a4 1f 85 9c 66 08 cc 99 3b 81 ca cb 02 0c ef 05
+            04 4b 21 81 a2 fd 33 7d fd 7b 1c 63 96 68 2f 29
+            b4 39 31 68 e3 c9 e6 bc fe 6b c5 b7 a0 6d 96 ba
+            e4 24 cc 10 2c 91 74 5c 24 ad 67 3d c7 61 8f 81
+            """))
+        self.assertEqual(salsa20(input), output)
+
+        #-----------------------------------------------------------------------
+        # custom test vector,
+        # used to check for salsa20() breakage while optimizing _gen_files output.
+        #-----------------------------------------------------------------------
+        input = list(range(16))
+        output = unpack_uint32_list(hb("""
+            f518dd4fb98883e0a87954c05cab867083bb8808552810752285a05822f56c16
+            9d4a2a0fd2142523d758c60b36411b682d53860514b871d27659042a5afa475d
+            """))
+        self.assertEqual(salsa20(input), output)
+
+    #=============================================================================
+    # eof
+    #=============================================================================
+
+#=============================================================================
+# test scrypt
+#=============================================================================
+class _CommonScryptTest(TestCase):
+    """
+    base class for testing various scrypt backends against same set of reference vectors.
+    """
+    #=============================================================================
+    # class attrs
+    #=============================================================================
+
+    @classproperty
+    def descriptionPrefix(cls):
+        return "passlib.utils.scrypt.scrypt() <%s backend>" % cls.backend
+    backend = None
+
+    #=============================================================================
+    # setup
+    #=============================================================================
+    def setUp(self):
+        assert self.backend
+        scrypt_mod._set_backend(self.backend)
+        super(_CommonScryptTest, self).setUp()
+
+    #=============================================================================
+    # reference vectors
+    #=============================================================================
+
+    reference_vectors = [
+        # entry format: (secret, salt, n, r, p, keylen, result)
+
+        #------------------------------------------------------------------------
+        # test vectors from scrypt whitepaper --
+        # http://www.tarsnap.com/scrypt/scrypt.pdf, appendix b
+        #
+        # also present in (expired) scrypt rfc draft --
+        # https://tools.ietf.org/html/draft-josefsson-scrypt-kdf-01, section 11
+        #------------------------------------------------------------------------
+        ("", "", 16, 1, 1, 64, hb("""
+        77 d6 57 62 38 65 7b 20 3b 19 ca 42 c1 8a 04 97
+        f1 6b 48 44 e3 07 4a e8 df df fa 3f ed e2 14 42
+        fc d0 06 9d ed 09 48 f8 32 6a 75 3a 0f c8 1f 17
+        e8 d3 e0 fb 2e 0d 36 28 cf 35 e2 0c 38 d1 89 06
+        """)),
+
+        ("password", "NaCl", 1024, 8, 16, 64, hb("""
+        fd ba be 1c 9d 34 72 00 78 56 e7 19 0d 01 e9 fe
+        7c 6a d7 cb c8 23 78 30 e7 73 76 63 4b 37 31 62
+        2e af 30 d9 2e 22 a3 88 6f f1 09 27 9d 98 30 da
+        c7 27 af b9 4a 83 ee 6d 83 60 cb df a2 cc 06 40
+        """)),
+
+        # NOTE: the following are skipped for all backends unless TEST_MODE="full"
+
+        ("pleaseletmein", "SodiumChloride", 16384, 8, 1, 64, hb("""
+        70 23 bd cb 3a fd 73 48 46 1c 06 cd 81 fd 38 eb
+        fd a8 fb ba 90 4f 8e 3e a9 b5 43 f6 54 5d a1 f2
+        d5 43 29 55 61 3f 0f cf 62 d4 97 05 24 2a 9a f9
+        e6 1e 85 dc 0d 65 1e 40 df cf 01 7b 45 57 58 87
+        """)),
+
+        # NOTE: the following are always skipped for the builtin backend,
+        #       (just takes too long to be worth it)
+
+        ("pleaseletmein", "SodiumChloride", 1048576, 8, 1, 64, hb("""
+        21 01 cb 9b 6a 51 1a ae ad db be 09 cf 70 f8 81
+        ec 56 8d 57 4a 2f fd 4d ab e5 ee 98 20 ad aa 47
+        8e 56 fd 8f 4b a5 d0 9f fa 1c 6d 92 7c 40 f4 c3
+        37 30 40 49 e8 a9 52 fb cb f4 5c 6f a7 7a 41 a4
+        """)),
+    ]
+
+    def test_reference_vectors(self):
+        """reference vectors"""
+        for secret, salt, n, r, p, keylen, result in self.reference_vectors:
+            if n >= 1024 and TEST_MODE(max="default"):
+                # skip large values unless we're running full test suite
+                continue
+            if n > 16384 and self.backend == "builtin":
+                # skip largest vector for builtin, takes WAAY too long
+                # (46s under pypy, ~5m under cpython)
+                continue
+            log.debug("scrypt reference vector: %r %r n=%r r=%r p=%r", secret, salt, n, r, p)
+            self.assertEqual(scrypt_mod.scrypt(secret, salt, n, r, p, keylen), result)
+
+    #=============================================================================
+    # fuzz testing
+    #=============================================================================
+
+    _already_tested_others = None
+
+    def test_other_backends(self):
+        """compare output to other backends"""
+        # only run once, since test is symetric.
+        # maybe this means it should go somewhere else?
+        if self._already_tested_others:
+            raise self.skipTest("already run under %r backend test" % self._already_tested_others)
+        self._already_tested_others = self.backend
+        rng = self.getRandom()
+
+        # get available backends
+        orig = scrypt_mod.backend
+        available = set(name for name in scrypt_mod.backend_values
+                        if scrypt_mod._has_backend(name))
+        scrypt_mod._set_backend(orig)
+        available.discard(self.backend)
+        if not available:
+            raise self.skipTest("no other backends found")
+
+        warnings.filterwarnings("ignore", "(?i)using builtin scrypt backend",
+                                category=exc.PasslibSecurityWarning)
+
+        # generate some random options, and cross-check output
+        for _ in range(10):
+            # NOTE: keeping values low due to builtin test
+            secret = getrandbytes(rng, rng.randint(0, 64))
+            salt = getrandbytes(rng, rng.randint(0, 64))
+            n = 1 << rng.randint(1, 10)
+            r = rng.randint(1, 8)
+            p = rng.randint(1, 3)
+            ks = rng.randint(1, 64)
+            previous = None
+            backends = set()
+            for name in available:
+                scrypt_mod._set_backend(name)
+                self.assertNotIn(scrypt_mod._scrypt, backends)
+                backends.add(scrypt_mod._scrypt)
+                result = hexstr(scrypt_mod.scrypt(secret, salt, n, r, p, ks))
+                self.assertEqual(len(result), 2*ks)
+                if previous is not None:
+                    self.assertEqual(result, previous,
+                                     msg="%r output differs from others %r: %r" %
+                                         (name, available, [secret, salt, n, r, p, ks]))
+
+    #=============================================================================
+    # test input types
+    #=============================================================================
+    def test_backend(self):
+        """backend management"""
+        # clobber backend
+        scrypt_mod.backend = None
+        scrypt_mod._scrypt = None
+        self.assertRaises(TypeError, scrypt_mod.scrypt, 's', 's', 2, 2, 2, 16)
+
+        # reload backend
+        scrypt_mod._set_backend(self.backend)
+        self.assertEqual(scrypt_mod.backend, self.backend)
+        scrypt_mod.scrypt('s', 's', 2, 2, 2, 16)
+
+        # throw error for unknown backend
+        self.assertRaises(ValueError, scrypt_mod._set_backend, 'xxx')
+        self.assertEqual(scrypt_mod.backend, self.backend)
+
+    def test_secret_param(self):
+        """'secret' parameter"""
+
+        def run_scrypt(secret):
+            return hexstr(scrypt_mod.scrypt(secret, "salt", 2, 2, 2, 16))
+
+        # unicode
+        TEXT = u("abc\u00defg")
+        self.assertEqual(run_scrypt(TEXT), '05717106997bfe0da42cf4779a2f8bd8')
+
+        # utf8 bytes
+        TEXT_UTF8 = b'abc\xc3\x9efg'
+        self.assertEqual(run_scrypt(TEXT_UTF8), '05717106997bfe0da42cf4779a2f8bd8')
+
+        # latin1 bytes
+        TEXT_LATIN1 = b'abc\xdefg'
+        self.assertEqual(run_scrypt(TEXT_LATIN1), '770825d10eeaaeaf98e8a3c40f9f441d')
+
+        # accept empty string
+        self.assertEqual(run_scrypt(""), 'ca1399e5fae5d3b9578dcd2b1faff6e2')
+
+        # reject other types
+        self.assertRaises(TypeError, run_scrypt, None)
+        self.assertRaises(TypeError, run_scrypt, 1)
+
+    def test_salt_param(self):
+        """'salt' parameter"""
+
+        def run_scrypt(salt):
+            return hexstr(scrypt_mod.scrypt("secret", salt, 2, 2, 2, 16))
+
+        # unicode
+        TEXT = u("abc\u00defg")
+        self.assertEqual(run_scrypt(TEXT), 'a748ec0f4613929e9e5f03d1ab741d88')
+
+        # utf8 bytes
+        TEXT_UTF8 = b'abc\xc3\x9efg'
+        self.assertEqual(run_scrypt(TEXT_UTF8), 'a748ec0f4613929e9e5f03d1ab741d88')
+
+        # latin1 bytes
+        TEXT_LATIN1 = b'abc\xdefg'
+        self.assertEqual(run_scrypt(TEXT_LATIN1), '91d056fb76fb6e9a7d1cdfffc0a16cd1')
+
+        # reject other types
+        self.assertRaises(TypeError, run_scrypt, None)
+        self.assertRaises(TypeError, run_scrypt, 1)
+
+    def test_n_param(self):
+        """'n' (rounds) parameter"""
+
+        def run_scrypt(n):
+            return hexstr(scrypt_mod.scrypt("secret", "salt", n, 2, 2, 16))
+
+        # must be > 1, and a power of 2
+        self.assertRaises(ValueError, run_scrypt, -1)
+        self.assertRaises(ValueError, run_scrypt, 0)
+        self.assertRaises(ValueError, run_scrypt, 1)
+        self.assertEqual(run_scrypt(2), 'dacf2bca255e2870e6636fa8c8957a66')
+        self.assertRaises(ValueError, run_scrypt, 3)
+        self.assertRaises(ValueError, run_scrypt, 15)
+        self.assertEqual(run_scrypt(16), '0272b8fc72bc54b1159340ed99425233')
+
+    def test_r_param(self):
+        """'r' (block size) parameter"""
+        def run_scrypt(r, n=2, p=2):
+            return hexstr(scrypt_mod.scrypt("secret", "salt", n, r, p, 16))
+
+        # must be > 1
+        self.assertRaises(ValueError, run_scrypt, -1)
+        self.assertRaises(ValueError, run_scrypt, 0)
+        self.assertEqual(run_scrypt(1), '3d630447d9f065363b8a79b0b3670251')
+        self.assertEqual(run_scrypt(2), 'dacf2bca255e2870e6636fa8c8957a66')
+        self.assertEqual(run_scrypt(5), '114f05e985a903c27237b5578e763736')
+
+        # reject r*p >= 2**30
+        self.assertRaises(ValueError, run_scrypt, (1<<30), p=1)
+        self.assertRaises(ValueError, run_scrypt, (1<<30) / 2, p=2)
+
+    def test_p_param(self):
+        """'p' (parallelism) parameter"""
+        def run_scrypt(p, n=2, r=2):
+            return hexstr(scrypt_mod.scrypt("secret", "salt", n, r, p, 16))
+
+        # must be > 1
+        self.assertRaises(ValueError, run_scrypt, -1)
+        self.assertRaises(ValueError, run_scrypt, 0)
+        self.assertEqual(run_scrypt(1), 'f2960ea8b7d48231fcec1b89b784a6fa')
+        self.assertEqual(run_scrypt(2), 'dacf2bca255e2870e6636fa8c8957a66')
+        self.assertEqual(run_scrypt(5), '848a0eeb2b3543e7f543844d6ca79782')
+
+        # reject r*p >= 2**30
+        self.assertRaises(ValueError, run_scrypt, (1<<30), r=1)
+        self.assertRaises(ValueError, run_scrypt, (1<<30) / 2, r=2)
+
+    def test_keylen_param(self):
+        """'keylen' parameter"""
+        rng = self.getRandom()
+
+        def run_scrypt(keylen):
+            return hexstr(scrypt_mod.scrypt("secret", "salt", 2, 2, 2, keylen))
+
+        # must be > 0
+        self.assertRaises(ValueError, run_scrypt, -1)
+        self.assertRaises(ValueError, run_scrypt, 0)
+        self.assertEqual(run_scrypt(1), 'da')
+
+        # pick random value
+        ksize = rng.randint(1, 1 << 10)
+        self.assertEqual(len(run_scrypt(ksize)), 2*ksize) # 2 hex chars per output
+
+        # one more than upper bound
+        self.assertRaises(ValueError, run_scrypt, ((2**32) - 1) * 32 + 1)
+
+    #=============================================================================
+    # eoc
+    #=============================================================================
+
+
+#-----------------------------------------------------------------------
+# check what backends 'should' be available
+#-----------------------------------------------------------------------
+
+def _can_import_cffi_scrypt():
+    try:
+        import scrypt
+    except ImportError as err:
+        if "scrypt" in str(err):
+            return False
+        raise
+    return True
+
+has_cffi_scrypt = _can_import_cffi_scrypt()
+
+
+def _can_import_stdlib_scrypt():
+    try:
+        from hashlib import scrypt
+        return True
+    except ImportError:
+        return False
+
+has_stdlib_scrypt = _can_import_stdlib_scrypt()
+
+#-----------------------------------------------------------------------
+# test individual backends
+#-----------------------------------------------------------------------
+
+# NOTE: builtin version runs VERY slow (except under PyPy, where it's only 11x slower),
+#       so skipping under quick test mode.
+@skipUnless(PYPY or TEST_MODE(min="default"), "skipped under current test mode")
+class BuiltinScryptTest(_CommonScryptTest):
+    backend = "builtin"
+
+    def setUp(self):
+        super(BuiltinScryptTest, self).setUp()
+        warnings.filterwarnings("ignore", "(?i)using builtin scrypt backend",
+                                category=exc.PasslibSecurityWarning)
+
+    def test_missing_backend(self):
+        """backend management -- missing backend"""
+        if has_stdlib_scrypt or has_cffi_scrypt:
+            raise self.skipTest("non-builtin backend is present")
+        self.assertRaises(exc.MissingBackendError, scrypt_mod._set_backend, 'scrypt')
+
+
+@skipUnless(has_cffi_scrypt, "'scrypt' package not found")
+class ScryptPackageTest(_CommonScryptTest):
+    backend = "scrypt"
+
+    def test_default_backend(self):
+        """backend management -- default backend"""
+        if has_stdlib_scrypt:
+            raise self.skipTest("higher priority backend present")
+        scrypt_mod._set_backend("default")
+        self.assertEqual(scrypt_mod.backend, "scrypt")
+
+
+@skipUnless(has_stdlib_scrypt, "'hashlib.scrypt()' not found")
+class StdlibScryptTest(_CommonScryptTest):
+    backend = "stdlib"
+
+    def test_default_backend(self):
+        """backend management -- default backend"""
+        scrypt_mod._set_backend("default")
+        self.assertEqual(scrypt_mod.backend, "stdlib")
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_ext_django.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_ext_django.py
new file mode 100644
index 0000000..2a0b418
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_ext_django.py
@@ -0,0 +1,1080 @@
+"""test passlib.ext.django"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from __future__ import absolute_import, division, print_function
+import logging; log = logging.getLogger(__name__)
+import sys
+import re
+# site
+# pkg
+from passlib import apps as _apps, exc, registry
+from passlib.apps import django10_context, django14_context, django16_context
+from passlib.context import CryptContext
+from passlib.ext.django.utils import (
+    DJANGO_VERSION, MIN_DJANGO_VERSION, DjangoTranslator, quirks,
+)
+from passlib.utils.compat import iteritems, get_method_function, u
+from passlib.utils.decor import memoized_property
+# tests
+from passlib.tests.utils import TestCase, TEST_MODE, handler_derived_from
+from passlib.tests.test_handlers import get_handler_case
+# local
+__all__ = [
+    "DjangoBehaviorTest",
+    "ExtensionBehaviorTest",
+    "DjangoExtensionTest",
+
+    "_ExtensionSupport",
+    "_ExtensionTest",
+]
+#=============================================================================
+# configure django settings for testcases
+#=============================================================================
+
+# whether we have supported django version
+has_min_django = DJANGO_VERSION >= MIN_DJANGO_VERSION
+
+# import and configure empty django settings
+# NOTE: we don't want to set up entirety of django, so not using django.setup() directly.
+#       instead, manually configuring the settings, and setting it up w/ no apps installed.
+#       in future, may need to alter this so we call django.setup() after setting
+#       DJANGO_SETTINGS_MODULE to a custom settings module w/ a dummy django app.
+if has_min_django:
+    #
+    # initialize django settings manually
+    #
+    from django.conf import settings, LazySettings
+
+    if not isinstance(settings, LazySettings):
+        # this probably means django globals have been configured already,
+        # which we don't want, since test cases reset and manipulate settings.
+        raise RuntimeError("expected django.conf.settings to be LazySettings: %r" % (settings,))
+
+    # else configure a blank settings instance for the unittests
+    if not settings.configured:
+        settings.configure()
+
+    #
+    # init django apps w/ NO installed apps.
+    # NOTE: required for django >= 1.9
+    #
+    from django.apps import apps
+    apps.populate(["django.contrib.contenttypes", "django.contrib.auth"])
+
+# log a warning if tested w/ newer version.
+# NOTE: this is mainly here as place to mark what version it was run against before release.
+if DJANGO_VERSION >= (3, 2):
+    log.info("this release hasn't been tested against Django %r", DJANGO_VERSION)
+
+#=============================================================================
+# support funcs
+#=============================================================================
+
+# flag for update_settings() to remove specified key entirely
+UNSET = object()
+
+def update_settings(**kwds):
+    """helper to update django settings from kwds"""
+    for k,v in iteritems(kwds):
+        if v is UNSET:
+            if hasattr(settings, k):
+                delattr(settings, k)
+        else:
+            setattr(settings, k, v)
+
+if has_min_django:
+    from django.contrib.auth.models import User
+
+    class FakeUser(User):
+        """mock user object for use in testing"""
+        # NOTE: this mainly just overrides .save() to test commit behavior.
+
+        # NOTE: .Meta.app_label required for django >= 1.9
+        class Meta:
+            app_label = __name__
+
+        @memoized_property
+        def saved_passwords(self):
+            return []
+
+        def pop_saved_passwords(self):
+            try:
+                return self.saved_passwords[:]
+            finally:
+                del self.saved_passwords[:]
+
+        def save(self, update_fields=None):
+            # NOTE: ignoring update_fields for test purposes
+            self.saved_passwords.append(self.password)
+
+def create_mock_setter():
+    state = []
+    def setter(password):
+        state.append(password)
+    def popstate():
+        try:
+            return state[:]
+        finally:
+            del state[:]
+    setter.popstate = popstate
+    return setter
+
+
+def check_django_hasher_has_backend(name):
+    """
+    check whether django hasher is available;
+    or if it should be skipped because django lacks third-party library.
+    """
+    assert name
+    from django.contrib.auth.hashers import make_password
+    try:
+        make_password("", hasher=name)
+        return True
+    except ValueError as err:
+        if re.match("Couldn't load '.*?' algorithm .* No module named .*", str(err)):
+            return False
+        raise
+
+#=============================================================================
+# work up stock django config
+#=============================================================================
+
+def _modify_django_config(kwds, sha_rounds=None):
+    """
+    helper to build django CryptContext config matching expected setup for stock django deploy.
+    :param kwds:
+    :param sha_rounds:
+    :return:
+    """
+    # make sure we have dict
+    if hasattr(kwds, "to_dict"):
+        # type: CryptContext
+        kwds = kwds.to_dict()
+
+    # update defaults
+    kwds.update(
+        # TODO: push this to passlib.apps django contexts
+        deprecated="auto",
+    )
+
+    # fill in default rounds for current django version, so our sample hashes come back
+    # unchanged, instead of being upgraded in-place by check_password().
+    if sha_rounds is None and has_min_django:
+        from django.contrib.auth.hashers import PBKDF2PasswordHasher
+        sha_rounds = PBKDF2PasswordHasher.iterations
+
+    # modify rounds
+    if sha_rounds:
+        kwds.update(
+            django_pbkdf2_sha1__default_rounds=sha_rounds,
+            django_pbkdf2_sha256__default_rounds=sha_rounds,
+        )
+
+    return kwds
+
+#----------------------------------------------------
+# build config dict that matches stock django
+#----------------------------------------------------
+
+# XXX: replace this with code that interrogates default django config directly?
+#      could then separate out "validation of djangoXX_context objects"
+#      and "validation that individual hashers match django".
+#      or maybe add a "get_django_context(django_version)" helper to passlib.apps?
+if DJANGO_VERSION >= (2, 1):
+    stock_config = _modify_django_config(_apps.django21_context)
+elif DJANGO_VERSION >= (1, 10):
+    stock_config = _modify_django_config(_apps.django110_context)
+else:
+    # assert DJANGO_VERSION >= (1, 8)
+    stock_config = _modify_django_config(_apps.django16_context)
+
+#----------------------------------------------------
+# override sample hashes used in test cases
+#----------------------------------------------------
+from passlib.hash import django_pbkdf2_sha256
+sample_hashes = dict(
+    django_pbkdf2_sha256=("not a password", django_pbkdf2_sha256
+                          .using(rounds=stock_config.get("django_pbkdf2_sha256__default_rounds"))
+                          .hash("not a password"))
+)
+
+#=============================================================================
+# test utils
+#=============================================================================
+
+class _ExtensionSupport(object):
+    """
+    test support funcs for loading/unloading extension.
+    this class is mixed in to various TestCase subclasses.
+    """
+    #===================================================================
+    # support funcs
+    #===================================================================
+
+    @classmethod
+    def _iter_patch_candidates(cls):
+        """helper to scan for monkeypatches.
+
+        returns tuple containing:
+        * object (module or class)
+        * attribute of object
+        * value of attribute
+        * whether it should or should not be patched
+        """
+        # XXX: this and assert_unpatched() could probably be refactored to use
+        #      the PatchManager class to do the heavy lifting.
+        from django.contrib.auth import models, hashers
+        user_attrs = ["check_password", "set_password"]
+        model_attrs = ["check_password", "make_password"]
+        hasher_attrs = ["check_password", "make_password", "get_hasher", "identify_hasher",
+                        "get_hashers"]
+        objs = [(models, model_attrs),
+                (models.User, user_attrs),
+                (hashers, hasher_attrs),
+        ]
+        for obj, patched in objs:
+            for attr in dir(obj):
+                if attr.startswith("_"):
+                    continue
+                value = obj.__dict__.get(attr, UNSET) # can't use getattr() due to GAE
+                if value is UNSET and attr not in patched:
+                    continue
+                value = get_method_function(value)
+                source = getattr(value, "__module__", None)
+                if source:
+                    yield obj, attr, source, (attr in patched)
+
+    #===================================================================
+    # verify current patch state
+    #===================================================================
+
+    def assert_unpatched(self):
+        """
+        test that django is in unpatched state
+        """
+        # make sure we aren't currently patched
+        mod = sys.modules.get("passlib.ext.django.models")
+        self.assertFalse(mod and mod.adapter.patched, "patch should not be enabled")
+
+        # make sure no objects have been replaced, by checking __module__
+        for obj, attr, source, patched in self._iter_patch_candidates():
+            if patched:
+                self.assertTrue(source.startswith("django.contrib.auth."),
+                                "obj=%r attr=%r was not reverted: %r" %
+                                (obj, attr, source))
+            else:
+                self.assertFalse(source.startswith("passlib."),
+                                "obj=%r attr=%r should not have been patched: %r" %
+                                (obj, attr, source))
+
+    def assert_patched(self, context=None):
+        """
+        helper to ensure django HAS been patched, and is using specified config
+        """
+        # make sure we're currently patched
+        mod = sys.modules.get("passlib.ext.django.models")
+        self.assertTrue(mod and mod.adapter.patched, "patch should have been enabled")
+
+        # make sure only the expected objects have been patched
+        for obj, attr, source, patched in self._iter_patch_candidates():
+            if patched:
+                self.assertTrue(source == "passlib.ext.django.utils",
+                                "obj=%r attr=%r should have been patched: %r" %
+                                (obj, attr, source))
+            else:
+                self.assertFalse(source.startswith("passlib."),
+                                "obj=%r attr=%r should not have been patched: %r" %
+                                (obj, attr, source))
+
+        # check context matches
+        if context is not None:
+            context = CryptContext._norm_source(context)
+            self.assertEqual(mod.password_context.to_dict(resolve=True),
+                             context.to_dict(resolve=True))
+
+    #===================================================================
+    # load / unload the extension (and verify it worked)
+    #===================================================================
+
+    _config_keys = ["PASSLIB_CONFIG", "PASSLIB_CONTEXT", "PASSLIB_GET_CATEGORY"]
+
+    def load_extension(self, check=True, **kwds):
+        """
+        helper to load extension with specified config & patch django
+        """
+        self.unload_extension()
+        if check:
+            config = kwds.get("PASSLIB_CONFIG") or kwds.get("PASSLIB_CONTEXT")
+        for key in self._config_keys:
+            kwds.setdefault(key, UNSET)
+        update_settings(**kwds)
+        import passlib.ext.django.models
+        if check:
+            self.assert_patched(context=config)
+
+    def unload_extension(self):
+        """
+        helper to remove patches and unload extension
+        """
+        # remove patches and unload module
+        mod = sys.modules.get("passlib.ext.django.models")
+        if mod:
+            mod.adapter.remove_patch()
+            del sys.modules["passlib.ext.django.models"]
+        # wipe config from django settings
+        update_settings(**dict((key, UNSET) for key in self._config_keys))
+        # check everything's gone
+        self.assert_unpatched()
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+
+# XXX: rename to ExtensionFixture?
+# NOTE: would roll this into _ExtensionSupport class;
+#       but we have to mix that one into django's TestCase classes as well;
+#       and our TestCase class (and this setUp() method) would foul things up.
+class _ExtensionTest(TestCase, _ExtensionSupport):
+    """
+    TestCase mixin which makes sure extension is unloaded before test;
+    and make sure it's unloaded after test as well.
+    """
+    #=============================================================================
+    # setup
+    #=============================================================================
+
+    def setUp(self):
+        super(_ExtensionTest, self).setUp()
+
+        self.require_TEST_MODE("default")
+
+        if not DJANGO_VERSION:
+            raise self.skipTest("Django not installed")
+        elif not has_min_django:
+            raise self.skipTest("Django version too old")
+
+        # reset to baseline, and verify it worked
+        self.unload_extension()
+
+        # and do the same when the test exits
+        self.addCleanup(self.unload_extension)
+
+    #=============================================================================
+    # eoc
+    #=============================================================================
+
+#=============================================================================
+# extension tests
+#=============================================================================
+
+#: static passwords used by DjangoBehaviorTest methods
+PASS1 = "toomanysecrets"
+WRONG1 = "letmein"
+
+
+class DjangoBehaviorTest(_ExtensionTest):
+    """
+    tests model to verify it matches django's behavior.
+
+    running this class verifies the tests correctly assert what Django itself does.
+
+    running the ExtensionBehaviorTest subclass below verifies "passlib.ext.django"
+    matches what the tests assert.
+    """
+    #=============================================================================
+    # class attrs
+    #=============================================================================
+
+    descriptionPrefix = "verify django behavior"
+
+    #: tracks whether tests should assume "passlib.ext.django" monkeypatch is applied.
+    #: (set to True by ExtensionBehaviorTest subclass)
+    patched = False
+
+    #: dict containing CryptContext() config which should match current django deploy.
+    #: used by tests to verify expected behavior.
+    config = stock_config
+
+    # NOTE: if this test fails, it means we're not accounting for
+    #       some part of django's hashing logic, or that this is
+    #       running against an untested version of django with a new
+    #       hashing policy.
+
+    #=============================================================================
+    # test helpers
+    #=============================================================================
+
+    @memoized_property
+    def context(self):
+        """
+        per-test CryptContext() created from .config.
+        """
+        return CryptContext._norm_source(self.config)
+
+    def assert_unusable_password(self, user):
+        """
+        check that user object is set to 'unusable password' constant
+        """
+        self.assertTrue(user.password.startswith("!"))
+        self.assertFalse(user.has_usable_password())
+        self.assertEqual(user.pop_saved_passwords(), [])
+
+    def assert_valid_password(self, user, hash=UNSET, saved=None):
+        """
+        check that user object has a usable password hash.
+        :param hash: optionally check it has this exact hash
+        :param saved: check that mock commit history for user.password matches this list
+        """
+        if hash is UNSET:
+            self.assertNotEqual(user.password, "!")
+            self.assertNotEqual(user.password, None)
+        else:
+            self.assertEqual(user.password, hash)
+        self.assertTrue(user.has_usable_password(),
+                        "hash should be usable: %r" % (user.password,))
+        self.assertEqual(user.pop_saved_passwords(),
+                         [] if saved is None else [saved])
+
+    #=============================================================================
+    # test hashing interface
+    #-----------------------------------------------------------------------------
+    # these functions are run against both the actual django code,
+    # to verify the assumptions of the unittests are correct;
+    # and run against the passlib extension, to verify it matches those assumptions.
+    #
+    # these tests check the following django methods:
+    #   User.set_password()
+    #   User.check_password()
+    #   make_password() -- 1.4 only
+    #   check_password()
+    #   identify_hasher()
+    #   User.has_usable_password()
+    #   User.set_unusable_password()
+    #
+    # XXX: this take a while to run. what could be trimmed?
+    #
+    # TODO: add get_hasher() checks where appropriate in tests below.
+    #=============================================================================
+
+    def test_extension_config(self):
+        """
+        test extension config is loaded correctly
+        """
+        if not self.patched:
+            raise self.skipTest("extension not loaded")
+
+        ctx = self.context
+
+        # contexts should match
+        from django.contrib.auth.hashers import check_password
+        from passlib.ext.django.models import password_context
+        self.assertEqual(password_context.to_dict(resolve=True), ctx.to_dict(resolve=True))
+
+        # should have patched both places
+        from django.contrib.auth.models import check_password as check_password2
+        self.assertEqual(check_password2, check_password)
+
+    def test_default_algorithm(self):
+        """
+        test django's default algorithm
+        """
+        ctx = self.context
+
+        # NOTE: import has to be done w/in method, in case monkeypatching is applied by setUp()
+        from django.contrib.auth.hashers import make_password
+
+        # User.set_password() should use default alg
+        user = FakeUser()
+        user.set_password(PASS1)
+        self.assertTrue(ctx.handler().verify(PASS1, user.password))
+        self.assert_valid_password(user)
+
+        # User.check_password() - n/a
+
+        # make_password() should use default alg
+        hash = make_password(PASS1)
+        self.assertTrue(ctx.handler().verify(PASS1, hash))
+
+        # check_password() - n/a
+
+    def test_empty_password(self):
+        """
+        test how methods handle empty string as password
+        """
+        ctx = self.context
+
+        # NOTE: import has to be done w/in method, in case monkeypatching is applied by setUp()
+        from django.contrib.auth.hashers import (
+            check_password,
+            make_password,
+            is_password_usable,
+            identify_hasher,
+        )
+
+        # User.set_password() should use default alg
+        user = FakeUser()
+        user.set_password('')
+        hash = user.password
+        self.assertTrue(ctx.handler().verify('', hash))
+        self.assert_valid_password(user, hash)
+
+        # User.check_password() should return True
+        self.assertTrue(user.check_password(""))
+        self.assert_valid_password(user, hash)
+
+        # XXX: test make_password() ?
+
+        # TODO: is_password_usable()
+
+        # identify_hasher() -- na
+
+        # check_password() should return True
+        self.assertTrue(check_password("", hash))
+
+    def test_unusable_flag(self):
+        """
+        test how methods handle 'unusable flag' in hash
+        """
+        # NOTE: import has to be done w/in method, in case monkeypatching is applied by setUp()
+        from django.contrib.auth.hashers import (
+            check_password,
+            make_password,
+            is_password_usable,
+            identify_hasher,
+        )
+
+        # sanity check via user.set_unusable_password()
+        user = FakeUser()
+        user.set_unusable_password()
+        self.assert_unusable_password(user)
+
+        # ensure User.set_password() sets unusable flag
+        user = FakeUser()
+        user.set_password(None)
+        self.assert_unusable_password(user)
+
+        # User.check_password() should always fail
+        self.assertFalse(user.check_password(None))
+        self.assertFalse(user.check_password('None'))
+        self.assertFalse(user.check_password(''))
+        self.assertFalse(user.check_password(PASS1))
+        self.assertFalse(user.check_password(WRONG1))
+        self.assert_unusable_password(user)
+
+        # make_password() should also set flag
+        self.assertTrue(make_password(None).startswith("!"))
+
+        # check_password() should return False (didn't handle disabled under 1.3)
+        self.assertFalse(check_password(PASS1, '!'))
+
+        # identify_hasher() and is_password_usable() should reject it
+        self.assertFalse(is_password_usable(user.password))
+        self.assertRaises(ValueError, identify_hasher, user.password)
+
+    def test_none_hash_value(self):
+        """
+        test how methods handle None as hash value
+        """
+        patched = self.patched
+
+        # NOTE: import has to be done w/in method, in case monkeypatching is applied by setUp()
+        from django.contrib.auth.hashers import (
+            check_password,
+            make_password,
+            is_password_usable,
+            identify_hasher,
+        )
+
+        # User.set_password() - n/a
+
+        # User.check_password() - returns False
+        user = FakeUser()
+        user.password = None
+        if quirks.none_causes_check_password_error and not patched:
+            # django 2.1+
+            self.assertRaises(TypeError, user.check_password, PASS1)
+        else:
+            self.assertFalse(user.check_password(PASS1))
+
+        self.assertEqual(user.has_usable_password(),
+                         quirks.empty_is_usable_password)
+
+        # TODO: is_password_usable()
+
+        # make_password() - n/a
+
+        # check_password() - error
+        if quirks.none_causes_check_password_error and not patched:
+            self.assertRaises(TypeError, check_password, PASS1, None)
+        else:
+            self.assertFalse(check_password(PASS1, None))
+
+        # identify_hasher() - error
+        self.assertRaises(TypeError, identify_hasher, None)
+
+    def test_empty_hash_value(self):
+        """
+        test how methods handle empty string as hash value
+        """
+        # NOTE: import has to be done w/in method, in case monkeypatching is applied by setUp()
+        from django.contrib.auth.hashers import (
+            check_password,
+            make_password,
+            is_password_usable,
+            identify_hasher,
+        )
+
+        # User.set_password() - n/a
+
+        # User.check_password()
+        # As of django 1.5, blank hash returns False (django issue 18453)
+        user = FakeUser()
+        user.password = ""
+        self.assertFalse(user.check_password(PASS1))
+
+        # verify hash wasn't changed/upgraded during check_password() call
+        self.assertEqual(user.password, "")
+        self.assertEqual(user.pop_saved_passwords(), [])
+
+        # User.has_usable_password()
+        self.assertEqual(user.has_usable_password(), quirks.empty_is_usable_password)
+
+        # TODO: is_password_usable()
+
+        # make_password() - n/a
+
+        # check_password()
+        self.assertFalse(check_password(PASS1, ""))
+
+        # identify_hasher() - throws error
+        self.assertRaises(ValueError, identify_hasher, "")
+
+    def test_invalid_hash_values(self):
+        """
+        test how methods handle invalid hash values.
+        """
+        for hash in [
+            "$789$foo",  # empty identifier
+        ]:
+            with self.subTest(hash=hash):
+                self._do_test_invalid_hash_value(hash)
+
+    def _do_test_invalid_hash_value(self, hash):
+
+        # NOTE: import has to be done w/in method, in case monkeypatching is applied by setUp()
+        from django.contrib.auth.hashers import (
+            check_password,
+            make_password,
+            is_password_usable,
+            identify_hasher,
+        )
+
+        # User.set_password() - n/a
+
+        # User.check_password()
+        # As of django 1.5, invalid hash returns False (side effect of django issue 18453)
+        user = FakeUser()
+        user.password = hash
+        self.assertFalse(user.check_password(PASS1))
+
+        # verify hash wasn't changed/upgraded during check_password() call
+        self.assertEqual(user.password, hash)
+        self.assertEqual(user.pop_saved_passwords(), [])
+
+        # User.has_usable_password()
+        self.assertEqual(user.has_usable_password(), quirks.invalid_is_usable_password)
+
+        # TODO: is_password_usable()
+
+        # make_password() - n/a
+
+        # check_password()
+        self.assertFalse(check_password(PASS1, hash))
+
+        # identify_hasher() - throws error
+        self.assertRaises(ValueError, identify_hasher, hash)
+
+    def test_available_schemes(self):
+        """
+        run a bunch of subtests for each hasher available in the default django setup
+        (as determined by reading self.context)
+        """
+        for scheme in self.context.schemes():
+            with self.subTest(scheme=scheme):
+                self._do_test_available_scheme(scheme)
+
+    def _do_test_available_scheme(self, scheme):
+        """
+        helper to test how specific hasher behaves.
+        :param scheme: *passlib* name of hasher (e.g. "django_pbkdf2_sha256")
+        """
+        log = self.getLogger()
+        ctx = self.context
+        patched = self.patched
+        setter = create_mock_setter()
+
+        # NOTE: import has to be done w/in method, in case monkeypatching is applied by setUp()
+        from django.contrib.auth.hashers import (
+            check_password,
+            make_password,
+            is_password_usable,
+            identify_hasher,
+        )
+
+        #-------------------------------------------------------
+        # setup constants & imports, pick a sample secret/hash combo
+        #-------------------------------------------------------
+        handler = ctx.handler(scheme)
+        log.debug("testing scheme: %r => %r", scheme, handler)
+        deprecated = ctx.handler(scheme).deprecated
+        assert not deprecated or scheme != ctx.default_scheme()
+        try:
+            testcase = get_handler_case(scheme)
+        except exc.MissingBackendError:
+            raise self.skipTest("backend not available")
+        assert handler_derived_from(handler, testcase.handler)
+        if handler.is_disabled:
+            raise self.skipTest("skip disabled hasher")
+
+        # verify that django has a backend available
+        # (since our hasher may use different set of backends,
+        #  get_handler_case() above may work, but django will have nothing)
+        if not patched and not check_django_hasher_has_backend(handler.django_name):
+            assert scheme in ["django_bcrypt", "django_bcrypt_sha256", "django_argon2"], \
+                "%r scheme should always have active backend" % scheme
+            log.warning("skipping scheme %r due to missing django dependency", scheme)
+            raise self.skipTest("skip due to missing dependency")
+
+        # find a sample (secret, hash) pair to test with
+        try:
+            secret, hash = sample_hashes[scheme]
+        except KeyError:
+            get_sample_hash = testcase("setUp").get_sample_hash
+            while True:
+                secret, hash = get_sample_hash()
+                if secret:  # don't select blank passwords
+                    break
+        other = 'dontletmein'
+
+        #-------------------------------------------------------
+        # User.set_password() - not tested here
+        #-------------------------------------------------------
+
+        #-------------------------------------------------------
+        # User.check_password()+migration against known hash
+        #-------------------------------------------------------
+        user = FakeUser()
+        user.password = hash
+
+        # check against invalid password
+        self.assertFalse(user.check_password(None))
+        ##self.assertFalse(user.check_password(''))
+        self.assertFalse(user.check_password(other))
+        self.assert_valid_password(user, hash)
+
+        # check against valid password
+        self.assertTrue(user.check_password(secret))
+
+        # check if it upgraded the hash
+        # NOTE: needs_update kept separate in case we need to test rounds.
+        needs_update = deprecated
+        if needs_update:
+            self.assertNotEqual(user.password, hash)
+            self.assertFalse(handler.identify(user.password))
+            self.assertTrue(ctx.handler().verify(secret, user.password))
+            self.assert_valid_password(user, saved=user.password)
+        else:
+            self.assert_valid_password(user, hash)
+
+        # don't need to check rest for most deployments
+        if TEST_MODE(max="default"):
+            return
+
+        #-------------------------------------------------------
+        # make_password() correctly selects algorithm
+        #-------------------------------------------------------
+        alg = DjangoTranslator().passlib_to_django_name(scheme)
+        hash2 = make_password(secret, hasher=alg)
+        self.assertTrue(handler.verify(secret, hash2))
+
+        #-------------------------------------------------------
+        # check_password()+setter against known hash
+        #-------------------------------------------------------
+        # should call setter only if it needs_update
+        self.assertTrue(check_password(secret, hash, setter=setter))
+        self.assertEqual(setter.popstate(), [secret] if needs_update else [])
+
+        # should not call setter
+        self.assertFalse(check_password(other, hash, setter=setter))
+        self.assertEqual(setter.popstate(), [])
+
+        ### check preferred kwd is ignored (feature we don't currently support fully)
+        ##self.assertTrue(check_password(secret, hash, setter=setter, preferred='fooey'))
+        ##self.assertEqual(setter.popstate(), [secret])
+
+        # TODO: get_hasher()
+
+        #-------------------------------------------------------
+        # identify_hasher() recognizes known hash
+        #-------------------------------------------------------
+        self.assertTrue(is_password_usable(hash))
+        name = DjangoTranslator().django_to_passlib_name(identify_hasher(hash).algorithm)
+        self.assertEqual(name, scheme)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#===================================================================
+# extension fidelity tests
+#===================================================================
+
+class ExtensionBehaviorTest(DjangoBehaviorTest):
+    """
+    test that "passlib.ext.django" conforms to behavioral assertions in DjangoBehaviorTest
+    """
+    descriptionPrefix = "verify extension behavior"
+
+    config = dict(
+            schemes="sha256_crypt,md5_crypt,des_crypt",
+            deprecated="des_crypt",
+            )
+
+    def setUp(self):
+        super(ExtensionBehaviorTest, self).setUp()
+
+        # always load extension before each test
+        self.load_extension(PASSLIB_CONFIG=self.config)
+        self.patched = True
+
+#===================================================================
+# extension internal tests
+#===================================================================
+
+class DjangoExtensionTest(_ExtensionTest):
+    """
+    test the ``passlib.ext.django`` plugin
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    descriptionPrefix = "passlib.ext.django plugin"
+
+    #===================================================================
+    # monkeypatch testing
+    #===================================================================
+
+    def test_00_patch_control(self):
+        """test set_django_password_context patch/unpatch"""
+
+        # check config="disabled"
+        self.load_extension(PASSLIB_CONFIG="disabled", check=False)
+        self.assert_unpatched()
+
+        # check legacy config=None
+        with self.assertWarningList("PASSLIB_CONFIG=None is deprecated"):
+            self.load_extension(PASSLIB_CONFIG=None, check=False)
+        self.assert_unpatched()
+
+        # try stock django 1.0 context
+        self.load_extension(PASSLIB_CONFIG="django-1.0", check=False)
+        self.assert_patched(context=django10_context)
+
+        # try to remove patch
+        self.unload_extension()
+
+        # patch to use stock django 1.4 context
+        self.load_extension(PASSLIB_CONFIG="django-1.4", check=False)
+        self.assert_patched(context=django14_context)
+
+        # try to remove patch again
+        self.unload_extension()
+
+    def test_01_overwrite_detection(self):
+        """test detection of foreign monkeypatching"""
+        # NOTE: this sets things up, and spot checks two methods,
+        #       this should be enough to verify patch manager is working.
+        # TODO: test unpatch behavior honors flag.
+
+        # configure plugin to use sample context
+        config = "[passlib]\nschemes=des_crypt\n"
+        self.load_extension(PASSLIB_CONFIG=config)
+
+        # setup helpers
+        import django.contrib.auth.models as models
+        from passlib.ext.django.models import adapter
+        def dummy():
+            pass
+
+        # mess with User.set_password, make sure it's detected
+        orig = models.User.set_password
+        models.User.set_password = dummy
+        with self.assertWarningList("another library has patched.*User\.set_password"):
+            adapter._manager.check_all()
+        models.User.set_password = orig
+
+        # mess with models.check_password, make sure it's detected
+        orig = models.check_password
+        models.check_password = dummy
+        with self.assertWarningList("another library has patched.*models:check_password"):
+            adapter._manager.check_all()
+        models.check_password = orig
+
+    def test_02_handler_wrapper(self):
+        """test Hasher-compatible handler wrappers"""
+        from django.contrib.auth import hashers
+
+        passlib_to_django = DjangoTranslator().passlib_to_django
+
+        # should return native django hasher if available
+        if DJANGO_VERSION > (1, 10):
+            self.assertRaises(ValueError, passlib_to_django, "hex_md5")
+        else:
+            hasher = passlib_to_django("hex_md5")
+            self.assertIsInstance(hasher, hashers.UnsaltedMD5PasswordHasher)
+
+        # should return native django hasher
+        # NOTE: present but not enabled by default in django as of 2.1
+        #       (see _builtin_django_hashers)
+        hasher = passlib_to_django("django_bcrypt")
+        self.assertIsInstance(hasher, hashers.BCryptPasswordHasher)
+
+        # otherwise should return wrapper
+        from passlib.hash import sha256_crypt
+        hasher = passlib_to_django("sha256_crypt")
+        self.assertEqual(hasher.algorithm, "passlib_sha256_crypt")
+
+        # and wrapper should return correct hash
+        encoded = hasher.encode("stub")
+        self.assertTrue(sha256_crypt.verify("stub", encoded))
+        self.assertTrue(hasher.verify("stub", encoded))
+        self.assertFalse(hasher.verify("xxxx", encoded))
+
+        # test wrapper accepts options
+        encoded = hasher.encode("stub", "abcd"*4, rounds=1234)
+        self.assertEqual(encoded, "$5$rounds=1234$abcdabcdabcdabcd$"
+                                  "v2RWkZQzctPdejyRqmmTDQpZN6wTh7.RUy9zF2LftT6")
+        self.assertEqual(hasher.safe_summary(encoded),
+            {'algorithm': 'sha256_crypt',
+             'salt': u('abcdab**********'),
+             'rounds': 1234,
+             'hash': u('v2RWkZ*************************************'),
+             })
+
+        # made up name should throw error
+        # XXX: should this throw ValueError instead, to match django?
+        self.assertRaises(KeyError, passlib_to_django, "does_not_exist")
+
+    #===================================================================
+    # PASSLIB_CONFIG settings
+    #===================================================================
+    def test_11_config_disabled(self):
+        """test PASSLIB_CONFIG='disabled'"""
+        # test config=None (deprecated)
+        with self.assertWarningList("PASSLIB_CONFIG=None is deprecated"):
+            self.load_extension(PASSLIB_CONFIG=None, check=False)
+        self.assert_unpatched()
+
+        # test disabled config
+        self.load_extension(PASSLIB_CONFIG="disabled", check=False)
+        self.assert_unpatched()
+
+    def test_12_config_presets(self):
+        """test PASSLIB_CONFIG='<preset>'"""
+        # test django presets
+        self.load_extension(PASSLIB_CONTEXT="django-default", check=False)
+        ctx = django16_context
+        self.assert_patched(ctx)
+
+        self.load_extension(PASSLIB_CONFIG="django-1.0", check=False)
+        self.assert_patched(django10_context)
+
+        self.load_extension(PASSLIB_CONFIG="django-1.4", check=False)
+        self.assert_patched(django14_context)
+
+    def test_13_config_defaults(self):
+        """test PASSLIB_CONFIG default behavior"""
+        # check implicit default
+        from passlib.ext.django.utils import PASSLIB_DEFAULT
+        default = CryptContext.from_string(PASSLIB_DEFAULT)
+        self.load_extension()
+        self.assert_patched(PASSLIB_DEFAULT)
+
+        # check default preset
+        self.load_extension(PASSLIB_CONTEXT="passlib-default", check=False)
+        self.assert_patched(PASSLIB_DEFAULT)
+
+        # check explicit string
+        self.load_extension(PASSLIB_CONTEXT=PASSLIB_DEFAULT, check=False)
+        self.assert_patched(PASSLIB_DEFAULT)
+
+    def test_14_config_invalid(self):
+        """test PASSLIB_CONFIG type checks"""
+        update_settings(PASSLIB_CONTEXT=123, PASSLIB_CONFIG=UNSET)
+        self.assertRaises(TypeError, __import__, 'passlib.ext.django.models')
+
+        self.unload_extension()
+        update_settings(PASSLIB_CONFIG="missing-preset", PASSLIB_CONTEXT=UNSET)
+        self.assertRaises(ValueError, __import__, 'passlib.ext.django.models')
+
+    #===================================================================
+    # PASSLIB_GET_CATEGORY setting
+    #===================================================================
+    def test_21_category_setting(self):
+        """test PASSLIB_GET_CATEGORY parameter"""
+        # define config where rounds can be used to detect category
+        config = dict(
+            schemes = ["sha256_crypt"],
+            sha256_crypt__default_rounds = 1000,
+            staff__sha256_crypt__default_rounds = 2000,
+            superuser__sha256_crypt__default_rounds = 3000,
+            )
+        from passlib.hash import sha256_crypt
+
+        def run(**kwds):
+            """helper to take in user opts, return rounds used in password"""
+            user = FakeUser(**kwds)
+            user.set_password("stub")
+            return sha256_crypt.from_string(user.password).rounds
+
+        # test default get_category
+        self.load_extension(PASSLIB_CONFIG=config)
+        self.assertEqual(run(), 1000)
+        self.assertEqual(run(is_staff=True), 2000)
+        self.assertEqual(run(is_superuser=True), 3000)
+
+        # test patch uses explicit get_category function
+        def get_category(user):
+            return user.first_name or None
+        self.load_extension(PASSLIB_CONTEXT=config,
+                            PASSLIB_GET_CATEGORY=get_category)
+        self.assertEqual(run(), 1000)
+        self.assertEqual(run(first_name='other'), 1000)
+        self.assertEqual(run(first_name='staff'), 2000)
+        self.assertEqual(run(first_name='superuser'), 3000)
+
+        # test patch can disable get_category entirely
+        def get_category(user):
+            return None
+        self.load_extension(PASSLIB_CONTEXT=config,
+                            PASSLIB_GET_CATEGORY=get_category)
+        self.assertEqual(run(), 1000)
+        self.assertEqual(run(first_name='other'), 1000)
+        self.assertEqual(run(first_name='staff', is_staff=True), 1000)
+        self.assertEqual(run(first_name='superuser', is_superuser=True), 1000)
+
+        # test bad value
+        self.assertRaises(TypeError, self.load_extension, PASSLIB_CONTEXT=config,
+                          PASSLIB_GET_CATEGORY='x')
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_ext_django_source.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_ext_django_source.py
new file mode 100644
index 0000000..4b42e59
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_ext_django_source.py
@@ -0,0 +1,250 @@
+"""
+test passlib.ext.django against django source tests
+"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import absolute_import, division, print_function
+# core
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils.compat import suppress_cause
+from passlib.ext.django.utils import DJANGO_VERSION, DjangoTranslator, _PasslibHasherWrapper
+# tests
+from passlib.tests.utils import TestCase, TEST_MODE
+from .test_ext_django import (
+    has_min_django, stock_config, _ExtensionSupport,
+)
+if has_min_django:
+    from .test_ext_django import settings
+# local
+__all__ = [
+    "HashersTest",
+]
+#=============================================================================
+# HashersTest --
+# hack up the some of the real django tests to run w/ extension loaded,
+# to ensure we mimic their behavior.
+# however, the django tests were moved out of the package, and into a source-only location
+# as of django 1.7. so we disable tests from that point on unless test-runner specifies
+#=============================================================================
+
+#: ref to django unittest root module (if found)
+test_hashers_mod = None
+
+#: message about why test module isn't present (if not found)
+hashers_skip_msg = None
+
+#----------------------------------------------------------------------
+# try to load django's tests/auth_tests/test_hasher.py module,
+# or note why we failed.
+#----------------------------------------------------------------------
+if TEST_MODE(max="quick"):
+    hashers_skip_msg = "requires >= 'default' test mode"
+
+elif has_min_django:
+    import os
+    import sys
+    source_path = os.environ.get("PASSLIB_TESTS_DJANGO_SOURCE_PATH")
+
+    if source_path:
+        if not os.path.exists(source_path):
+            raise EnvironmentError("django source path not found: %r" % source_path)
+        if not all(os.path.exists(os.path.join(source_path, name))
+                   for name in ["django", "tests"]):
+            raise EnvironmentError("invalid django source path: %r" % source_path)
+        log.info("using django tests from source path: %r", source_path)
+        tests_path = os.path.join(source_path, "tests")
+        sys.path.insert(0, tests_path)
+        try:
+            from auth_tests import test_hashers as test_hashers_mod
+        except ImportError as err:
+            raise suppress_cause(
+                EnvironmentError("error trying to import django tests "
+                                 "from source path (%r): %r" %
+                                 (source_path, err)))
+        finally:
+            sys.path.remove(tests_path)
+
+    else:
+        hashers_skip_msg = "requires PASSLIB_TESTS_DJANGO_SOURCE_PATH to be set"
+
+        if TEST_MODE("full"):
+            # print warning so user knows what's happening
+            sys.stderr.write("\nWARNING: $PASSLIB_TESTS_DJANGO_SOURCE_PATH is not set; "
+                             "can't run Django's own unittests against passlib.ext.django\n")
+
+elif DJANGO_VERSION:
+    hashers_skip_msg = "django version too old"
+
+else:
+    hashers_skip_msg = "django not installed"
+
+#----------------------------------------------------------------------
+# if found module, create wrapper to run django's own tests,
+# but with passlib monkeypatched in.
+#----------------------------------------------------------------------
+if test_hashers_mod:
+    from django.core.signals import setting_changed
+    from django.dispatch import receiver
+    from django.utils.module_loading import import_string
+    from passlib.utils.compat import get_unbound_method_function
+
+    class HashersTest(test_hashers_mod.TestUtilsHashPass, _ExtensionSupport):
+        """
+        Run django's hasher unittests against passlib's extension
+        and workalike implementations
+        """
+
+        #==================================================================
+        # helpers
+        #==================================================================
+
+        # port patchAttr() helper method from passlib.tests.utils.TestCase
+        patchAttr = get_unbound_method_function(TestCase.patchAttr)
+
+        #==================================================================
+        # custom setup
+        #==================================================================
+        def setUp(self):
+            #---------------------------------------------------------
+            # install passlib.ext.django adapter, and get context
+            #---------------------------------------------------------
+            self.load_extension(PASSLIB_CONTEXT=stock_config, check=False)
+            from passlib.ext.django.models import adapter
+            context = adapter.context
+
+            #---------------------------------------------------------
+            # patch tests module to use our versions of patched funcs
+            # (which should be installed in hashers module)
+            #---------------------------------------------------------
+            from django.contrib.auth import hashers
+            for attr in ["make_password",
+                         "check_password",
+                         "identify_hasher",
+                         "is_password_usable",
+                         "get_hasher"]:
+                self.patchAttr(test_hashers_mod, attr, getattr(hashers, attr))
+
+            #---------------------------------------------------------
+            # django tests expect empty django_des_crypt salt field
+            #---------------------------------------------------------
+            from passlib.hash import django_des_crypt
+            self.patchAttr(django_des_crypt, "use_duplicate_salt", False)
+
+            #---------------------------------------------------------
+            # install receiver to update scheme list if test changes settings
+            #---------------------------------------------------------
+            django_to_passlib_name = DjangoTranslator().django_to_passlib_name
+
+            @receiver(setting_changed, weak=False)
+            def update_schemes(**kwds):
+                if kwds and kwds['setting'] != 'PASSWORD_HASHERS':
+                    return
+                assert context is adapter.context
+                schemes = [
+                    django_to_passlib_name(import_string(hash_path)())
+                    for hash_path in settings.PASSWORD_HASHERS
+                ]
+                # workaround for a few tests that only specify hex_md5,
+                # but test for django_salted_md5 format.
+                if "hex_md5" in schemes and "django_salted_md5" not in schemes:
+                    schemes.append("django_salted_md5")
+                schemes.append("django_disabled")
+                context.update(schemes=schemes, deprecated="auto")
+                adapter.reset_hashers()
+
+            self.addCleanup(setting_changed.disconnect, update_schemes)
+
+            update_schemes()
+
+            #---------------------------------------------------------
+            # need password_context to keep up to date with django_hasher.iterations,
+            # which is frequently patched by django tests.
+            #
+            # HACK: to fix this, inserting wrapper around a bunch of context
+            #       methods so that any time adapter calls them,
+            #       attrs are resynced first.
+            #---------------------------------------------------------
+
+            def update_rounds():
+                """
+                sync django hasher config -> passlib hashers
+                """
+                for handler in context.schemes(resolve=True):
+                    if 'rounds' not in handler.setting_kwds:
+                        continue
+                    hasher = adapter.passlib_to_django(handler)
+                    if isinstance(hasher, _PasslibHasherWrapper):
+                        continue
+                    rounds = getattr(hasher, "rounds", None) or \
+                             getattr(hasher, "iterations", None)
+                    if rounds is None:
+                        continue
+                    # XXX: this doesn't modify the context, which would
+                    #      cause other weirdness (since it would replace handler factories completely,
+                    #      instead of just updating their state)
+                    handler.min_desired_rounds = handler.max_desired_rounds = handler.default_rounds = rounds
+
+            _in_update = [False]
+
+            def update_wrapper(wrapped, *args, **kwds):
+                """
+                wrapper around arbitrary func, that first triggers sync
+                """
+                if not _in_update[0]:
+                    _in_update[0] = True
+                    try:
+                        update_rounds()
+                    finally:
+                        _in_update[0] = False
+                return wrapped(*args, **kwds)
+
+            # sync before any context call
+            for attr in ["schemes", "handler", "default_scheme", "hash",
+                         "verify", "needs_update", "verify_and_update"]:
+                self.patchAttr(context, attr, update_wrapper, wrap=True)
+
+            # sync whenever adapter tries to resolve passlib hasher
+            self.patchAttr(adapter, "django_to_passlib", update_wrapper, wrap=True)
+
+        def tearDown(self):
+            # NOTE: could rely on addCleanup() instead, but need py26 compat
+            self.unload_extension()
+            super(HashersTest, self).tearDown()
+
+        #==================================================================
+        # skip a few methods that can't be replicated properly
+        # *want to minimize these as much as possible*
+        #==================================================================
+
+        _OMIT = lambda self: self.skipTest("omitted by passlib")
+
+        # XXX: this test registers two classes w/ same algorithm id,
+        #      something we don't support -- how does django sanely handle
+        #      that anyways? get_hashers_by_algorithm() should throw KeyError, right?
+        test_pbkdf2_upgrade_new_hasher = _OMIT
+
+        # TODO: support wrapping django's harden-runtime feature?
+        #       would help pass their tests.
+        test_check_password_calls_harden_runtime = _OMIT
+        test_bcrypt_harden_runtime = _OMIT
+        test_pbkdf2_harden_runtime = _OMIT
+
+        #==================================================================
+        # eoc
+        #==================================================================
+
+else:
+    # otherwise leave a stub so test log tells why test was skipped.
+
+    class HashersTest(TestCase):
+
+        def test_external_django_hasher_tests(self):
+            """external django hasher tests"""
+            raise self.skipTest(hashers_skip_msg)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers.py
new file mode 100644
index 0000000..cad5ef9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers.py
@@ -0,0 +1,1819 @@
+"""passlib.tests.test_handlers - tests for passlib hash algorithms"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+import logging; log = logging.getLogger(__name__)
+import os
+import sys
+import warnings
+# site
+# pkg
+from passlib import exc, hash
+from passlib.utils import repeat_string
+from passlib.utils.compat import irange, PY3, u, get_method_function
+from passlib.tests.utils import TestCase, HandlerCase, skipUnless, \
+        TEST_MODE, UserHandlerMixin, EncodingHandlerMixin
+# module
+
+#=============================================================================
+# constants & support
+#=============================================================================
+
+# some common unicode passwords which used as test cases
+UPASS_WAV = u('\u0399\u03c9\u03b1\u03bd\u03bd\u03b7\u03c2')
+UPASS_USD = u("\u20AC\u00A5$")
+UPASS_TABLE = u("t\u00e1\u0411\u2113\u0259")
+
+PASS_TABLE_UTF8 = b't\xc3\xa1\xd0\x91\xe2\x84\x93\xc9\x99' # utf-8
+
+# handlers which support multiple backends, but don't have multi-backend tests.
+_omitted_backend_tests = ["django_bcrypt", "django_bcrypt_sha256", "django_argon2"]
+
+#: modules where get_handler_case() should search for test cases.
+_handler_test_modules = [
+    "test_handlers",
+    "test_handlers_argon2",
+    "test_handlers_bcrypt",
+    "test_handlers_cisco",
+    "test_handlers_django",
+    "test_handlers_pbkdf2",
+    "test_handlers_scrypt",
+]
+
+def get_handler_case(scheme):
+    """
+    return HandlerCase instance for scheme, used by other tests.
+
+    :param scheme: name of hasher to locate test for (e.g. "bcrypt")
+
+    :raises KeyError:
+        if scheme isn't known hasher.
+
+    :raises MissingBackendError:
+        if hasher doesn't have any available backends.
+
+    :returns:
+        HandlerCase subclass (which derives from TestCase)
+    """
+    from passlib.registry import get_crypt_handler
+    handler = get_crypt_handler(scheme)
+    if hasattr(handler, "backends") and scheme not in _omitted_backend_tests:
+        # XXX: if no backends available, could proceed to pick first backend for test lookup;
+        #      should investigate if that would be useful to callers.
+        try:
+            backend = handler.get_backend()
+        except exc.MissingBackendError:
+            assert scheme in conditionally_available_hashes
+            raise
+        name = "%s_%s_test" % (scheme, backend)
+    else:
+        name = "%s_test" % scheme
+    for module in _handler_test_modules:
+        modname = "passlib.tests." + module
+        __import__(modname)
+        mod = sys.modules[modname]
+        try:
+            return getattr(mod, name)
+        except AttributeError:
+            pass
+    # every hasher should have test suite, so if we get here, means test is either missing,
+    # misnamed, or _handler_test_modules list is out of date.
+    raise RuntimeError("can't find test case named %r for %r" % (name, scheme))
+
+#: hashes which there may not be a backend available for,
+#: and get_handler_case() may (correctly) throw a MissingBackendError
+conditionally_available_hashes = ["argon2", "bcrypt", "bcrypt_sha256"]
+
+#=============================================================================
+# apr md5 crypt
+#=============================================================================
+class apr_md5_crypt_test(HandlerCase):
+    handler = hash.apr_md5_crypt
+
+    known_correct_hashes = [
+        #
+        # http://httpd.apache.org/docs/2.2/misc/password_encryptions.html
+        #
+        ('myPassword', '$apr1$r31.....$HqJZimcKQFAMYayBlzkrA/'),
+
+        #
+        # custom
+        #
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '$apr1$bzYrOHUx$a1FcpXuQDJV3vPY20CS6N1'),
+        ]
+
+    known_malformed_hashes = [
+        # bad char in otherwise correct hash ----\/
+            '$apr1$r31.....$HqJZimcKQFAMYayBlzkrA!'
+        ]
+
+#=============================================================================
+# bigcrypt
+#=============================================================================
+class bigcrypt_test(HandlerCase):
+    handler = hash.bigcrypt
+
+    # TODO: find an authoritative source of test vectors
+    known_correct_hashes = [
+
+        #
+        # various docs & messages on the web.
+        #
+        ("passphrase",               "qiyh4XPJGsOZ2MEAyLkfWqeQ"),
+        ("This is very long passwd", "f8.SVpL2fvwjkAnxn8/rgTkwvrif6bjYB5c"),
+
+        #
+        # custom
+        #
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, 'SEChBAyMbMNhgGLyP7kD1HZU'),
+    ]
+
+    known_unidentified_hashes = [
+        # one char short (10 % 11)
+        "qiyh4XPJGsOZ2MEAyLkfWqe"
+
+        # one char too many (1 % 11)
+        "f8.SVpL2fvwjkAnxn8/rgTkwvrif6bjYB5cd"
+    ]
+
+    # omit des_crypt from known_other since it's a valid bigcrypt hash too.
+    known_other_hashes = [row for row in HandlerCase.known_other_hashes
+                          if row[0] != "des_crypt"]
+
+    def test_90_internal(self):
+        # check that _norm_checksum() also validates checksum size.
+        # (current code uses regex in parser)
+        self.assertRaises(ValueError, hash.bigcrypt, use_defaults=True,
+                          checksum=u('yh4XPJGsOZ'))
+
+#=============================================================================
+# bsdi crypt
+#=============================================================================
+class _bsdi_crypt_test(HandlerCase):
+    """test BSDiCrypt algorithm"""
+    handler = hash.bsdi_crypt
+
+    known_correct_hashes = [
+        #
+        # from JTR 1.7.9
+        #
+        ('U*U*U*U*', '_J9..CCCCXBrJUJV154M'),
+        ('U*U***U', '_J9..CCCCXUhOBTXzaiE'),
+        ('U*U***U*', '_J9..CCCC4gQ.mB/PffM'),
+        ('*U*U*U*U', '_J9..XXXXvlzQGqpPPdk'),
+        ('*U*U*U*U*', '_J9..XXXXsqM/YSSP..Y'),
+        ('*U*U*U*U*U*U*U*U', '_J9..XXXXVL7qJCnku0I'),
+        ('*U*U*U*U*U*U*U*U*', '_J9..XXXXAj8cFbP5scI'),
+        ('ab1234567', '_J9..SDizh.vll5VED9g'),
+        ('cr1234567', '_J9..SDizRjWQ/zePPHc'),
+        ('zxyDPWgydbQjgq', '_J9..SDizxmRI1GjnQuE'),
+        ('726 even', '_K9..SaltNrQgIYUAeoY'),
+        ('', '_J9..SDSD5YGyRCr4W4c'),
+
+        #
+        # custom
+        #
+        (" ", "_K1..crsmZxOLzfJH8iw"),
+        ("my", '_KR/.crsmykRplHbAvwA'), # <-- to detect old 12-bit rounds bug
+        ("my socra", "_K1..crsmf/9NzZr1fLM"),
+        ("my socrates", '_K1..crsmOv1rbde9A9o'),
+        ("my socrates note", "_K1..crsm/2qeAhdISMA"),
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '_7C/.ABw0WIKy0ILVqo2'),
+    ]
+    known_unidentified_hashes = [
+        # bad char in otherwise correctly formatted hash
+        #    \/
+        "_K1.!crsmZxOLzfJH8iw"
+    ]
+
+    platform_crypt_support = [
+        # openbsd 5.8 dropped everything except bcrypt
+        ("openbsd[6789]", False),
+        ("openbsd5", None),
+        ("openbsd", True),
+
+        ("freebsd|netbsd|darwin", True),
+        ("solaris", False),
+        ("linux", None),  # may be present if libxcrypt is in use
+    ]
+
+    def test_77_fuzz_input(self, **kwds):
+        # we want to generate even rounds to verify it's correct, but want to ignore warnings
+        warnings.filterwarnings("ignore", "bsdi_crypt rounds should be odd.*")
+        super(_bsdi_crypt_test, self).test_77_fuzz_input(**kwds)
+
+    def test_needs_update_w_even_rounds(self):
+        """needs_update() should flag even rounds"""
+        handler = self.handler
+        even_hash = '_Y/../cG0zkJa6LY6k4c'
+        odd_hash = '_Z/..TgFg0/ptQtpAgws'
+        secret = 'test'
+
+        # don't issue warning
+        self.assertTrue(handler.verify(secret, even_hash))
+        self.assertTrue(handler.verify(secret, odd_hash))
+
+        # *do* signal as needing updates
+        self.assertTrue(handler.needs_update(even_hash))
+        self.assertFalse(handler.needs_update(odd_hash))
+
+        # new hashes shouldn't have even rounds
+        new_hash = handler.hash("stub")
+        self.assertFalse(handler.needs_update(new_hash))
+
+# create test cases for specific backends
+bsdi_crypt_os_crypt_test = _bsdi_crypt_test.create_backend_case("os_crypt")
+bsdi_crypt_builtin_test = _bsdi_crypt_test.create_backend_case("builtin")
+
+#=============================================================================
+# crypt16
+#=============================================================================
+class crypt16_test(HandlerCase):
+    handler = hash.crypt16
+
+    # TODO: find an authortative source of test vectors
+    known_correct_hashes = [
+        #
+        # from messages around the web, including
+        # http://seclists.org/bugtraq/1999/Mar/76
+        #
+        ("passphrase",  "qi8H8R7OM4xMUNMPuRAZxlY."),
+        ("printf",      "aaCjFz4Sh8Eg2QSqAReePlq6"),
+        ("printf",      "AA/xje2RyeiSU0iBY3PDwjYo"),
+        ("LOLOAQICI82QB4IP", "/.FcK3mad6JwYt8LVmDqz9Lc"),
+        ("LOLOAQICI",   "/.FcK3mad6JwYSaRHJoTPzY2"),
+        ("LOLOAQIC",    "/.FcK3mad6JwYelhbtlysKy6"),
+        ("L",           "/.CIu/PzYCkl6elhbtlysKy6"),
+
+        #
+        # custom
+        #
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, 'YeDc9tKkkmDvwP7buzpwhoqQ'),
+        ]
+
+#=============================================================================
+# des crypt
+#=============================================================================
+class _des_crypt_test(HandlerCase):
+    """test des-crypt algorithm"""
+    handler = hash.des_crypt
+
+    known_correct_hashes = [
+        #
+        # from JTR 1.7.9
+        #
+        ('U*U*U*U*', 'CCNf8Sbh3HDfQ'),
+        ('U*U***U', 'CCX.K.MFy4Ois'),
+        ('U*U***U*', 'CC4rMpbg9AMZ.'),
+        ('*U*U*U*U', 'XXxzOu6maQKqQ'),
+        ('', 'SDbsugeBiC58A'),
+
+        #
+        # custom
+        #
+        ('', 'OgAwTx2l6NADI'),
+        (' ', '/Hk.VPuwQTXbc'),
+        ('test', 'N1tQbOFcM5fpg'),
+        ('Compl3X AlphaNu3meric', 'um.Wguz3eVCx2'),
+        ('4lpHa N|_|M3r1K W/ Cur5Es: #$%(*)(*%#', 'sNYqfOyauIyic'),
+        ('AlOtBsOl', 'cEpWz5IUCShqM'),
+
+        # ensures utf-8 used for unicode
+        (u('hell\u00D6'), 'saykDgk3BPZ9E'),
+        ]
+    known_unidentified_hashes = [
+        # bad char in otherwise correctly formatted hash
+        #\/
+        '!gAwTx2l6NADI',
+
+        # wrong size
+        'OgAwTx2l6NAD',
+        'OgAwTx2l6NADIj',
+        ]
+
+    platform_crypt_support = [
+        # openbsd 5.8 dropped everything except bcrypt
+        ("openbsd[6789]", False),
+        ("openbsd5", None),
+        ("openbsd", True),
+
+        ("freebsd|netbsd|linux|solaris|darwin", True),
+    ]
+
+# create test cases for specific backends
+des_crypt_os_crypt_test = _des_crypt_test.create_backend_case("os_crypt")
+des_crypt_builtin_test = _des_crypt_test.create_backend_case("builtin")
+
+#=============================================================================
+# fshp
+#=============================================================================
+class fshp_test(HandlerCase):
+    """test fshp algorithm"""
+    handler = hash.fshp
+
+    known_correct_hashes = [
+        #
+        # test vectors from FSHP reference implementation
+        # https://github.com/bdd/fshp-is-not-secure-anymore/blob/master/python/test.py
+        #
+        ('test', '{FSHP0|0|1}qUqP5cyxm6YcTAhz05Hph5gvu9M='),
+
+        ('test',
+            '{FSHP1|8|4096}MTIzNDU2NzjTdHcmoXwNc0f'
+            'f9+ArUHoN0CvlbPZpxFi1C6RDM/MHSA=='
+            ),
+
+        ('OrpheanBeholderScryDoubt',
+            '{FSHP1|8|4096}GVSUFDAjdh0vBosn1GUhz'
+            'GLHP7BmkbCZVH/3TQqGIjADXpc+6NCg3g=='
+            ),
+        ('ExecuteOrder66',
+            '{FSHP3|16|8192}0aY7rZQ+/PR+Rd5/I9ss'
+            'RM7cjguyT8ibypNaSp/U1uziNO3BVlg5qPU'
+            'ng+zHUDQC3ao/JbzOnIBUtAeWHEy7a2vZeZ'
+            '7jAwyJJa2EqOsq4Io='
+            ),
+
+        #
+        # custom
+        #
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '{FSHP1|16|16384}9v6/l3Lu/d9by5nznpOS'
+         'cqQo8eKu/b/CKli3RCkgYg4nRTgZu5y659YV8cCZ68UL'),
+        ]
+
+    known_unidentified_hashes = [
+        # incorrect header
+        '{FSHX0|0|1}qUqP5cyxm6YcTAhz05Hph5gvu9M=',
+        'FSHP0|0|1}qUqP5cyxm6YcTAhz05Hph5gvu9M=',
+        ]
+
+    known_malformed_hashes = [
+        # bad base64 padding
+        '{FSHP0|0|1}qUqP5cyxm6YcTAhz05Hph5gvu9M',
+
+        # wrong salt size
+        '{FSHP0|1|1}qUqP5cyxm6YcTAhz05Hph5gvu9M=',
+
+        # bad rounds
+        '{FSHP0|0|A}qUqP5cyxm6YcTAhz05Hph5gvu9M=',
+    ]
+
+    def test_90_variant(self):
+        """test variant keyword"""
+        handler = self.handler
+        kwds = dict(salt=b'a', rounds=1)
+
+        # accepts ints
+        handler(variant=1, **kwds)
+
+        # accepts bytes or unicode
+        handler(variant=u('1'), **kwds)
+        handler(variant=b'1', **kwds)
+
+        # aliases
+        handler(variant=u('sha256'), **kwds)
+        handler(variant=b'sha256', **kwds)
+
+        # rejects None
+        self.assertRaises(TypeError, handler, variant=None, **kwds)
+
+        # rejects other types
+        self.assertRaises(TypeError, handler, variant=complex(1,1), **kwds)
+
+        # invalid variant
+        self.assertRaises(ValueError, handler, variant='9', **kwds)
+        self.assertRaises(ValueError, handler, variant=9, **kwds)
+
+#=============================================================================
+# hex digests
+#=============================================================================
+class hex_md4_test(HandlerCase):
+    handler = hash.hex_md4
+    known_correct_hashes = [
+        ("password", '8a9d093f14f8701df17732b2bb182c74'),
+        (UPASS_TABLE, '876078368c47817ce5f9115f3a42cf74'),
+    ]
+
+class hex_md5_test(HandlerCase):
+    handler = hash.hex_md5
+    known_correct_hashes = [
+        ("password", '5f4dcc3b5aa765d61d8327deb882cf99'),
+        (UPASS_TABLE, '05473f8a19f66815e737b33264a0d0b0'),
+    ]
+
+    # XXX: should test this for ALL the create_hex_md5() hashers.
+    def test_mock_fips_mode(self):
+        """
+        if md5 isn't available, a dummy instance should be created.
+        (helps on FIPS systems).
+        """
+        from passlib.exc import UnknownHashError
+        from passlib.crypto.digest import lookup_hash, _set_mock_fips_mode
+
+        # check if md5 is available so we can test mock helper
+        supported = lookup_hash("md5", required=False).supported
+        self.assertEqual(self.handler.supported, supported)
+        if supported:
+            _set_mock_fips_mode()
+            self.addCleanup(_set_mock_fips_mode, False)
+
+        # HACK: have to recreate hasher, since underlying HashInfo has changed.
+        #       could reload module and re-import, but this should be good enough.
+        from passlib.handlers.digests import create_hex_hash
+        hasher = create_hex_hash("md5", required=False)
+        self.assertFalse(hasher.supported)
+
+        # can identify hashes even if disabled
+        ref1 = '5f4dcc3b5aa765d61d8327deb882cf99'
+        ref2 = 'xxx'
+        self.assertTrue(hasher.identify(ref1))
+        self.assertFalse(hasher.identify(ref2))
+
+        # throw error if try to use it
+        pat = "'md5' hash disabled for fips"
+        self.assertRaisesRegex(UnknownHashError, pat, hasher.hash, "password")
+        self.assertRaisesRegex(UnknownHashError, pat, hasher.verify, "password", ref1)
+
+
+class hex_sha1_test(HandlerCase):
+    handler = hash.hex_sha1
+    known_correct_hashes = [
+        ("password", '5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8'),
+        (UPASS_TABLE, 'e059b2628e3a3e2de095679de9822c1d1466e0f0'),
+    ]
+
+class hex_sha256_test(HandlerCase):
+    handler = hash.hex_sha256
+    known_correct_hashes = [
+        ("password", '5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8'),
+        (UPASS_TABLE, '6ed729e19bf24d3d20f564375820819932029df05547116cfc2cc868a27b4493'),
+    ]
+
+class hex_sha512_test(HandlerCase):
+    handler = hash.hex_sha512
+    known_correct_hashes = [
+        ("password", 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c'
+         '706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cac'
+         'bc86'),
+        (UPASS_TABLE, 'd91bb0a23d66dca07a1781fd63ae6a05f6919ee5fc368049f350c9f'
+         '293b078a18165d66097cf0d89fdfbeed1ad6e7dba2344e57348cd6d51308c843a06f'
+         '29caf'),
+    ]
+
+#=============================================================================
+# htdigest hash
+#=============================================================================
+class htdigest_test(UserHandlerMixin, HandlerCase):
+    handler = hash.htdigest
+
+    known_correct_hashes = [
+        # secret, user, realm
+
+        # from RFC 2617
+        (("Circle Of Life", "Mufasa", "testrealm@host.com"),
+            '939e7578ed9e3c518a452acee763bce9'),
+
+        # custom
+        ((UPASS_TABLE, UPASS_USD, UPASS_WAV),
+            '4dabed2727d583178777fab468dd1f17'),
+    ]
+
+    known_unidentified_hashes = [
+        # bad char \/ - currently rejecting upper hex chars, may change
+        '939e7578edAe3c518a452acee763bce9',
+
+        # bad char \/
+        '939e7578edxe3c518a452acee763bce9',
+    ]
+
+    def test_80_user(self):
+        raise self.skipTest("test case doesn't support 'realm' keyword")
+
+    def populate_context(self, secret, kwds):
+        """insert username into kwds"""
+        if isinstance(secret, tuple):
+            secret, user, realm = secret
+        else:
+            user, realm = "user", "realm"
+        kwds.setdefault("user", user)
+        kwds.setdefault("realm", realm)
+        return secret
+
+#=============================================================================
+# ldap hashes
+#=============================================================================
+class ldap_md5_test(HandlerCase):
+    handler = hash.ldap_md5
+    known_correct_hashes = [
+        ("helloworld", '{MD5}/F4DjTilcDIIVEHn/nAQsA=='),
+        (UPASS_TABLE, '{MD5}BUc/ihn2aBXnN7MyZKDQsA=='),
+    ]
+
+class ldap_sha1_test(HandlerCase):
+    handler = hash.ldap_sha1
+    known_correct_hashes = [
+        ("helloworld", '{SHA}at+xg6SiyUovktq1redipHiJpaE='),
+        (UPASS_TABLE, '{SHA}4FmyYo46Pi3glWed6YIsHRRm4PA='),
+    ]
+
+class ldap_salted_md5_test(HandlerCase):
+    handler = hash.ldap_salted_md5
+    known_correct_hashes = [
+        ("testing1234", '{SMD5}UjFY34os/pnZQ3oQOzjqGu4yeXE='),
+        (UPASS_TABLE, '{SMD5}Z0ioJ58LlzUeRxm3K6JPGAvBGIM='),
+
+        # alternate salt sizes (8, 15, 16)
+        ('test', '{SMD5}LnuZPJhiaY95/4lmVFpg548xBsD4P4cw'),
+        ('test', '{SMD5}XRlncfRzvGi0FDzgR98tUgBg7B3jXOs9p9S615qTkg=='),
+        ('test', '{SMD5}FbAkzOMOxRbMp6Nn4hnZuel9j9Gas7a2lvI+x5hT6j0='),
+    ]
+
+    known_malformed_hashes = [
+        # salt too small (3)
+        '{SMD5}IGVhwK+anvspmfDt2t0vgGjt/Q==',
+
+        # incorrect base64 encoding
+        '{SMD5}LnuZPJhiaY95/4lmVFpg548xBsD4P4c',
+        '{SMD5}LnuZPJhiaY95/4lmVFpg548xBsD4P4cw'
+        '{SMD5}LnuZPJhiaY95/4lmVFpg548xBsD4P4cw=',
+        '{SMD5}LnuZPJhiaY95/4lmV=pg548xBsD4P4cw',
+        '{SMD5}LnuZPJhiaY95/4lmVFpg548xBsD4P===',
+    ]
+
+class ldap_salted_sha1_test(HandlerCase):
+    handler = hash.ldap_salted_sha1
+    known_correct_hashes = [
+        ("testing123", '{SSHA}0c0blFTXXNuAMHECS4uxrj3ZieMoWImr'),
+        ("secret", "{SSHA}0H+zTv8o4MR4H43n03eCsvw1luG8LdB7"),
+        (UPASS_TABLE, '{SSHA}3yCSD1nLZXznra4N8XzZgAL+s1sQYsx5'),
+
+        # alternate salt sizes (8, 15, 16)
+        ('test', '{SSHA}P90+qijSp8MJ1tN25j5o1PflUvlqjXHOGeOckw=='),
+        ('test', '{SSHA}/ZMF5KymNM+uEOjW+9STKlfCFj51bg3BmBNCiPHeW2ttbU0='),
+        ('test', '{SSHA}Pfx6Vf48AT9x3FVv8znbo8WQkEVSipHSWovxXmvNWUvp/d/7'),
+    ]
+
+    known_malformed_hashes = [
+        # salt too small (3)
+        '{SSHA}ZQK3Yvtvl6wtIRoISgMGPkcWU7Nfq5U=',
+
+        # incorrect base64 encoding
+        '{SSHA}P90+qijSp8MJ1tN25j5o1PflUvlqjXHOGeOck',
+        '{SSHA}P90+qijSp8MJ1tN25j5o1PflUvlqjXHOGeOckw=',
+        '{SSHA}P90+qijSp8MJ1tN25j5o1Pf=UvlqjXHOGeOckw==',
+        '{SSHA}P90+qijSp8MJ1tN25j5o1PflUvlqjXHOGeOck===',
+    ]
+
+
+class ldap_salted_sha256_test(HandlerCase):
+    handler = hash.ldap_salted_sha256
+    known_correct_hashes = [
+        # generated locally
+        # salt size = 8
+        ("password", '{SSHA256}x1tymSTVjozxQ2PtT46ysrzhZxbcskK0o2f8hEFx7fAQQmhtDSEkJA=='),
+        ("test", '{SSHA256}xfqc9aOR6z15YaEk3/Ufd7UL9+JozB/1EPmCDTizL0GkdA7BuNda6w=='),
+        ("toomanysecrets", '{SSHA256}RrTKrg6HFXcjJ+eDAq4UtbODxOr9RLeG+I69FoJvutcbY0zpfU+p1Q=='),
+        (u('letm\xe8\xefn'), '{SSHA256}km7UjUTBZN8a+gf1ND2/qn15N7LsO/jmGYJXvyTfJKAbI0RoLWWslQ=='),
+
+        # alternate salt sizes (4, 15, 16)
+        # generated locally
+        ('test', '{SSHA256}TFv2RpwyO0U9mA0Hk8FsXRa1I+4dNUtv27Qa8dzGVLinlDIm'),
+        ('test', '{SSHA256}J6MFQdkfjdmXz9UyUPb773kekJdm4dgSL4y8WQEQW11VipHSundOKaV0LsV4L6U='),
+        ('test', '{SSHA256}uBLazLaiBaPb6Cpnvq2XTYDkvXbYIuqRW1anMKk85d1/j1GqFQIgpHSOMUYIIcS4'),
+    ]
+
+    known_malformed_hashes = [
+        # salt too small (3)
+        '{SSHA256}Lpdyr1+lR+rtxgp3SpQnUuNw33ENivTl28nzF2ZI4Gm41/o=',
+
+        # incorrect base64 encoding
+        '{SSHA256}TFv2RpwyO0U9mA0Hk8FsXRa1I+4dNUtv27Qa8dzGVLinlDI@',
+        '{SSHA256}TFv2RpwyO0U9mA0Hk8FsXRa1I+4dNUtv27Qa8dzGVLinlDI',
+        '{SSHA256}TFv2RpwyO0U9mA0Hk8FsXRa1I+4dNUtv27Qa8dzGVLinlDIm===',
+    ]
+
+
+
+class ldap_salted_sha512_test(HandlerCase):
+    handler = hash.ldap_salted_sha512
+    known_correct_hashes = [
+        # generated by testing ldap server web interface (see issue 124 comments)
+        # salt size = 8
+        ("toomanysecrets", '{SSHA512}wExp4xjiCHS0zidJDC4UJq9EEeIebAQPJ1PWSwfhxWjfutI9XiiKuHm2AE41cEFfK+8HyI8bh+ztbczUGsvVFIgICWWPt7qu'),
+        (u('letm\xe8\xefn'), '{SSHA512}mpNUSmZc3TNx+RnPwkIAVMf7ocEKLPrIoQNsg4Eu8dHvyCeb2xzHp5A6n4tF7ntknSvfvRZaJII4ImvNJlYsgiwAm0FMqR+3'),
+
+        # generated locally
+        # salt size = 8
+        ("password", '{SSHA512}f/lFQskkl7PdMsTGJxHZq8LDt/l+UqRMm6/pj4pV7/xZkcOaKCgvQqp+KCeXc/Vd4RY6vEHWn4y0DnFcQ6wgyv9fyxk='),
+        ("test", '{SSHA512}Tgx/uhHnlM9/GgQvI31dN7cheDXg7WypZwaaIkyRsgV/BKIzBG3G/wUd9o1dpi06p3SYzMedg0lvTc3b6CtdO0Xo/f9/L+Uc'),
+
+        # alternate salt sizes (4, 15, 16)
+        # generated locally
+        ('test', '{SSHA512}Yg9DQ2wURCFGwobu7R2O6cq7nVbnGMPrFCX0aPQ9kj/y1hd6k9PEzkgWCB5aXdPwPzNrVb0PkiHiBnG1CxFiT+B8L8U='),
+        ('test', '{SSHA512}5ecDGWs5RY4xLszUO6hAcl90W3wAozGQoI4Gqj8xSZdcfU1lVEM4aY8s+4xVeLitcn7BO8i7xkzMFWLoxas7SeHc23sP4dx77937PyeE0A=='),
+        ('test', '{SSHA512}6FQv5W47HGg2MFBFZofoiIbO8KRW75Pm51NKoInpthYQQ5ujazHGhVGzrj3JXgA7j0k+UNmkHdbJjdY5xcUHPzynFEII4fwfIySEcG5NKSU='),
+    ]
+
+    known_malformed_hashes = [
+        # salt too small (3)
+        '{SSHA512}zFnn4/8x8GveUaMqgrYWyIWqFQ0Irt6gADPtRk4Uv3nUC6uR5cD8+YdQni/0ZNij9etm6p17kSFuww3M6l+d6AbAeA==',
+
+        # incorrect base64 encoding
+        '{SSHA512}Tgx/uhHnlM9/GgQvI31dN7cheDXg7WypZwaaIkyRsgV/BKIzBG3G/wUd9o1dpi06p3SYzMedg0lvTc3b6CtdO0Xo/f9/L+U',
+        '{SSHA512}Tgx/uhHnlM9/GgQvI31dN7cheDXg7WypZwaaIkyRsgV/BKIzBG3G/wUd9o1dpi06p3SYzMedg0lvTc3b6CtdO0Xo/f9/L+U@',
+        '{SSHA512}Tgx/uhHnlM9/GgQvI31dN7cheDXg7WypZwaaIkyRsgV/BKIzBG3G/wUd9o1dpi06p3SYzMedg0lvTc3b6CtdO0Xo/f9/L+U===',
+    ]
+
+
+class ldap_plaintext_test(HandlerCase):
+    # TODO: integrate EncodingHandlerMixin
+    handler = hash.ldap_plaintext
+    known_correct_hashes = [
+        ("password", 'password'),
+        (UPASS_TABLE, UPASS_TABLE if PY3 else PASS_TABLE_UTF8),
+        (PASS_TABLE_UTF8, UPASS_TABLE if PY3 else PASS_TABLE_UTF8),
+    ]
+    known_unidentified_hashes = [
+        "{FOO}bar",
+
+        # NOTE: this hash currently rejects the empty string.
+        "",
+    ]
+
+    known_other_hashes = [
+        ("ldap_md5", "{MD5}/F4DjTilcDIIVEHn/nAQsA==")
+    ]
+
+    class FuzzHashGenerator(HandlerCase.FuzzHashGenerator):
+
+        def random_password(self):
+            # NOTE: this hash currently rejects the empty string.
+            while True:
+                pwd = super(ldap_plaintext_test.FuzzHashGenerator, self).random_password()
+                if pwd:
+                    return pwd
+
+class _ldap_md5_crypt_test(HandlerCase):
+    # NOTE: since the ldap_{crypt} handlers are all wrappers, don't need
+    #       separate test; this is just to test the codebase end-to-end
+    handler = hash.ldap_md5_crypt
+
+    known_correct_hashes = [
+        #
+        # custom
+        #
+        ('', '{CRYPT}$1$dOHYPKoP$tnxS1T8Q6VVn3kpV8cN6o.'),
+        (' ', '{CRYPT}$1$m/5ee7ol$bZn0kIBFipq39e.KDXX8I0'),
+        ('test', '{CRYPT}$1$ec6XvcoW$ghEtNK2U1MC5l.Dwgi3020'),
+        ('Compl3X AlphaNu3meric', '{CRYPT}$1$nX1e7EeI$ljQn72ZUgt6Wxd9hfvHdV0'),
+        ('4lpHa N|_|M3r1K W/ Cur5Es: #$%(*)(*%#', '{CRYPT}$1$jQS7o98J$V6iTcr71CGgwW2laf17pi1'),
+        ('test', '{CRYPT}$1$SuMrG47N$ymvzYjr7QcEQjaK5m1PGx1'),
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '{CRYPT}$1$d6/Ky1lU$/xpf8m7ftmWLF.TjHCqel0'),
+        ]
+
+    known_malformed_hashes = [
+        # bad char in otherwise correct hash
+        '{CRYPT}$1$dOHYPKoP$tnxS1T8Q6VVn3kpV8cN6o!',
+        ]
+
+# create test cases for specific backends
+ldap_md5_crypt_os_crypt_test =_ldap_md5_crypt_test.create_backend_case("os_crypt")
+ldap_md5_crypt_builtin_test =_ldap_md5_crypt_test.create_backend_case("builtin")
+
+class _ldap_sha1_crypt_test(HandlerCase):
+    # NOTE: this isn't for testing the hash (see ldap_md5_crypt note)
+    # but as a self-test of the os_crypt patching code in HandlerCase.
+    handler = hash.ldap_sha1_crypt
+
+    known_correct_hashes = [
+        ('password', '{CRYPT}$sha1$10$c.mcTzCw$gF8UeYst9yXX7WNZKc5Fjkq0.au7'),
+        (UPASS_TABLE, '{CRYPT}$sha1$10$rnqXlOsF$aGJf.cdRPewJAXo1Rn1BkbaYh0fP'),
+    ]
+
+    def populate_settings(self, kwds):
+        kwds.setdefault("rounds", 10)
+        super(_ldap_sha1_crypt_test, self).populate_settings(kwds)
+
+    def test_77_fuzz_input(self, **ignored):
+        raise self.skipTest("unneeded")
+
+# create test cases for specific backends
+ldap_sha1_crypt_os_crypt_test = _ldap_sha1_crypt_test.create_backend_case("os_crypt")
+
+#=============================================================================
+# lanman
+#=============================================================================
+class lmhash_test(EncodingHandlerMixin, HandlerCase):
+    handler = hash.lmhash
+    secret_case_insensitive = True
+
+    known_correct_hashes = [
+        #
+        # http://msdn.microsoft.com/en-us/library/cc245828(v=prot.10).aspx
+        #
+        ("OLDPASSWORD", "c9b81d939d6fd80cd408e6b105741864"),
+        ("NEWPASSWORD", '09eeab5aa415d6e4d408e6b105741864'),
+        ("welcome", "c23413a8a1e7665faad3b435b51404ee"),
+
+        #
+        # custom
+        #
+        ('', 'aad3b435b51404eeaad3b435b51404ee'),
+        ('zzZZZzz', 'a5e6066de61c3e35aad3b435b51404ee'),
+        ('passphrase', '855c3697d9979e78ac404c4ba2c66533'),
+        ('Yokohama', '5ecd9236d21095ce7584248b8d2c9f9e'),
+
+        # ensures cp437 used for unicode
+        (u('ENCYCLOP\xC6DIA'), 'fed6416bffc9750d48462b9d7aaac065'),
+        (u('encyclop\xE6dia'), 'fed6416bffc9750d48462b9d7aaac065'),
+
+        # test various encoding values
+        ((u("\xC6"), None), '25d8ab4a0659c97aaad3b435b51404ee'),
+        ((u("\xC6"), "cp437"), '25d8ab4a0659c97aaad3b435b51404ee'),
+        ((u("\xC6"), "latin-1"), '184eecbbe9991b44aad3b435b51404ee'),
+        ((u("\xC6"), "utf-8"), '00dd240fcfab20b8aad3b435b51404ee'),
+    ]
+
+    known_unidentified_hashes = [
+        # bad char in otherwise correct hash
+        '855c3697d9979e78ac404c4ba2c6653X',
+    ]
+
+    def test_90_raw(self):
+        """test lmhash.raw() method"""
+        from binascii import unhexlify
+        from passlib.utils.compat import str_to_bascii
+        lmhash = self.handler
+        for secret, hash in self.known_correct_hashes:
+            kwds = {}
+            secret = self.populate_context(secret, kwds)
+            data = unhexlify(str_to_bascii(hash))
+            self.assertEqual(lmhash.raw(secret, **kwds), data)
+        self.assertRaises(TypeError, lmhash.raw, 1)
+
+#=============================================================================
+# md5 crypt
+#=============================================================================
+class _md5_crypt_test(HandlerCase):
+    handler = hash.md5_crypt
+
+    known_correct_hashes = [
+        #
+        # from JTR 1.7.9
+        #
+        ('U*U*U*U*', '$1$dXc3I7Rw$ctlgjDdWJLMT.qwHsWhXR1'),
+        ('U*U***U', '$1$dXc3I7Rw$94JPyQc/eAgQ3MFMCoMF.0'),
+        ('U*U***U*', '$1$dXc3I7Rw$is1mVIAEtAhIzSdfn5JOO0'),
+        ('*U*U*U*U', '$1$eQT9Hwbt$XtuElNJD.eW5MN5UCWyTQ0'),
+        ('', '$1$Eu.GHtia$CFkL/nE1BYTlEPiVx1VWX0'),
+
+        #
+        # custom
+        #
+
+        # NOTE: would need to patch HandlerCase to coerce hashes
+        # to native str for this first one to work under py3.
+##        ('', b('$1$dOHYPKoP$tnxS1T8Q6VVn3kpV8cN6o.')),
+        ('', '$1$dOHYPKoP$tnxS1T8Q6VVn3kpV8cN6o.'),
+        (' ', '$1$m/5ee7ol$bZn0kIBFipq39e.KDXX8I0'),
+        ('test', '$1$ec6XvcoW$ghEtNK2U1MC5l.Dwgi3020'),
+        ('Compl3X AlphaNu3meric', '$1$nX1e7EeI$ljQn72ZUgt6Wxd9hfvHdV0'),
+        ('4lpHa N|_|M3r1K W/ Cur5Es: #$%(*)(*%#', '$1$jQS7o98J$V6iTcr71CGgwW2laf17pi1'),
+        ('test', '$1$SuMrG47N$ymvzYjr7QcEQjaK5m1PGx1'),
+        (b'test', '$1$SuMrG47N$ymvzYjr7QcEQjaK5m1PGx1'),
+        (u('s'), '$1$ssssssss$YgmLTApYTv12qgTwBoj8i/'),
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '$1$d6/Ky1lU$/xpf8m7ftmWLF.TjHCqel0'),
+        ]
+
+    known_malformed_hashes = [
+        # bad char in otherwise correct hash \/
+           '$1$dOHYPKoP$tnxS1T8Q6VVn3kpV8cN6o!',
+
+        # too many fields
+        '$1$dOHYPKoP$tnxS1T8Q6VVn3kpV8cN6o.$',
+        ]
+
+    platform_crypt_support = [
+        # openbsd 5.8 dropped everything except bcrypt
+        ("openbsd[6789]", False),
+        ("openbsd5", None),
+        ("openbsd", True),
+
+        ("freebsd|netbsd|linux|solaris", True),
+        ("darwin", False),
+    ]
+
+# create test cases for specific backends
+md5_crypt_os_crypt_test = _md5_crypt_test.create_backend_case("os_crypt")
+md5_crypt_builtin_test = _md5_crypt_test.create_backend_case("builtin")
+
+#=============================================================================
+# msdcc 1 & 2
+#=============================================================================
+class msdcc_test(UserHandlerMixin, HandlerCase):
+    handler = hash.msdcc
+    user_case_insensitive = True
+
+    known_correct_hashes = [
+
+        #
+        # http://www.jedge.com/wordpress/windows-password-cache/
+        #
+        (("Asdf999", "sevans"), "b1176c2587478785ec1037e5abc916d0"),
+
+        #
+        # http://infosecisland.com/blogview/12156-Cachedump-for-Meterpreter-in-Action.html
+        #
+        (("ASDqwe123", "jdoe"), "592cdfbc3f1ef77ae95c75f851e37166"),
+
+        #
+        # http://comments.gmane.org/gmane.comp.security.openwall.john.user/1917
+        #
+        (("test1", "test1"), "64cd29e36a8431a2b111378564a10631"),
+        (("test2", "test2"), "ab60bdb4493822b175486810ac2abe63"),
+        (("test3", "test3"), "14dd041848e12fc48c0aa7a416a4a00c"),
+        (("test4", "test4"), "b945d24866af4b01a6d89b9d932a153c"),
+
+        #
+        # http://ciscoit.wordpress.com/2011/04/13/metasploit-hashdump-vs-cachedump/
+        #
+        (("1234qwer!@#$", "Administrator"), "7b69d06ef494621e3f47b9802fe7776d"),
+
+        #
+        # http://www.securiteam.com/tools/5JP0I2KFPA.html
+        #
+        (("password", "user"), "2d9f0b052932ad18b87f315641921cda"),
+
+        #
+        # from JTR 1.7.9
+        #
+        (("", "root"), "176a4c2bd45ac73687676c2f09045353"),
+        (("test1", "TEST1"), "64cd29e36a8431a2b111378564a10631"),
+        (("okolada", "nineteen_characters"), "290efa10307e36a79b3eebf2a6b29455"),
+        ((u("\u00FC"), u("\u00FC")), "48f84e6f73d6d5305f6558a33fa2c9bb"),
+        ((u("\u00FC\u00FC"), u("\u00FC\u00FC")), "593246a8335cf0261799bda2a2a9c623"),
+        ((u("\u20AC\u20AC"), "user"), "9121790702dda0fa5d353014c334c2ce"),
+
+        #
+        # custom
+        #
+
+        # ensures utf-8 used for unicode
+        ((UPASS_TABLE, 'bob'), 'fcb82eb4212865c7ac3503156ca3f349'),
+    ]
+
+    known_alternate_hashes = [
+        # check uppercase accepted.
+        ("B1176C2587478785EC1037E5ABC916D0", ("Asdf999", "sevans"),
+            "b1176c2587478785ec1037e5abc916d0"),
+    ]
+
+class msdcc2_test(UserHandlerMixin, HandlerCase):
+    handler = hash.msdcc2
+    user_case_insensitive = True
+
+    known_correct_hashes = [
+        #
+        # from JTR 1.7.9
+        #
+        (("test1", "test1"), "607bbe89611e37446e736f7856515bf8"),
+        (("qerwt", "Joe"), "e09b38f84ab0be586b730baf61781e30"),
+        (("12345", "Joe"), "6432f517a900b3fc34ffe57f0f346e16"),
+        (("", "bin"), "c0cbe0313a861062e29f92ede58f9b36"),
+        (("w00t", "nineteen_characters"), "87136ae0a18b2dafe4a41d555425b2ed"),
+        (("w00t", "eighteencharacters"), "fc5df74eca97afd7cd5abb0032496223"),
+        (("longpassword", "twentyXXX_characters"), "cfc6a1e33eb36c3d4f84e4c2606623d2"),
+        (("longpassword", "twentyoneX_characters"), "99ff74cea552799da8769d30b2684bee"),
+        (("longpassword", "twentytwoXX_characters"), "0a721bdc92f27d7fb23b87a445ec562f"),
+        (("test2", "TEST2"), "c6758e5be7fc943d00b97972a8a97620"),
+        (("test3", "test3"), "360e51304a2d383ea33467ab0b639cc4"),
+        (("test4", "test4"), "6f79ee93518306f071c47185998566ae"),
+        ((u("\u00FC"), "joe"), "bdb80f2c4656a8b8591bd27d39064a54"),
+        ((u("\u20AC\u20AC"), "joe"), "1e1e20f482ff748038e47d801d0d1bda"),
+        ((u("\u00FC\u00FC"), "admin"), "0839e4a07c00f18a8c65cf5b985b9e73"),
+
+        #
+        # custom
+        #
+
+        # custom unicode test
+        ((UPASS_TABLE, 'bob'), 'cad511dc9edefcf69201da72efb6bb55'),
+    ]
+
+#=============================================================================
+# mssql 2000 & 2005
+#=============================================================================
+class mssql2000_test(HandlerCase):
+    handler = hash.mssql2000
+    secret_case_insensitive = "verify-only"
+    # FIXME: fix UT framework - this hash is sensitive to password case, but verify() is not
+
+    known_correct_hashes = [
+        #
+        # http://hkashfi.blogspot.com/2007/08/breaking-sql-server-2005-hashes.html
+        #
+        ('Test', '0x010034767D5C0CFA5FDCA28C4A56085E65E882E71CB0ED2503412FD54D6119FFF04129A1D72E7C3194F7284A7F3A'),
+        ('TEST', '0x010034767D5C2FD54D6119FFF04129A1D72E7C3194F7284A7F3A2FD54D6119FFF04129A1D72E7C3194F7284A7F3A'),
+
+        #
+        # http://www.sqlmag.com/forums/aft/68438
+        #
+        ('x', '0x010086489146C46DD7318D2514D1AC706457CBF6CD3DF8407F071DB4BBC213939D484BF7A766E974F03C96524794'),
+
+        #
+        # http://stackoverflow.com/questions/173329/how-to-decrypt-a-password-from-sql-server
+        #
+        ('AAAA', '0x0100CF465B7B12625EF019E157120D58DD46569AC7BF4118455D12625EF019E157120D58DD46569AC7BF4118455D'),
+
+        #
+        # http://msmvps.com/blogs/gladchenko/archive/2005/04/06/41083.aspx
+        #
+        ('123', '0x01002D60BA07FE612C8DE537DF3BFCFA49CD9968324481C1A8A8FE612C8DE537DF3BFCFA49CD9968324481C1A8A8'),
+
+        #
+        # http://www.simple-talk.com/sql/t-sql-programming/temporarily-changing-an-unknown-password-of-the-sa-account-/
+        #
+        ('12345', '0x01005B20054332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B3'),
+
+        #
+        # XXX: sample is incomplete, password unknown
+        # https://anthonystechblog.wordpress.com/2011/04/20/password-encryption-in-sql-server-how-to-tell-if-a-user-is-using-a-weak-password/
+        # (????, '0x0100813F782D66EF15E40B1A3FDF7AB88B322F51401A87D8D3E3A8483C4351A3D96FC38499E6CDD2B6F?????????'),
+        #
+
+        #
+        # from JTR 1.7.9
+        #
+        ('foo', '0x0100A607BA7C54A24D17B565C59F1743776A10250F581D482DA8B6D6261460D3F53B279CC6913CE747006A2E3254'),
+        ('bar', '0x01000508513EADDF6DB7DDD270CCA288BF097F2FF69CC2DB74FBB9644D6901764F999BAB9ECB80DE578D92E3F80D'),
+        ('canard', '0x01008408C523CF06DCB237835D701C165E68F9460580132E28ED8BC558D22CEDF8801F4503468A80F9C52A12C0A3'),
+        ('lapin', '0x0100BF088517935FC9183FE39FDEC77539FD5CB52BA5F5761881E5B9638641A79DBF0F1501647EC941F3355440A2'),
+
+        #
+        # custom
+        #
+
+        # ensures utf-8 used for unicode
+        (UPASS_USD,   '0x0100624C0961B28E39FEE13FD0C35F57B4523F0DA1861C11D5A5B28E39FEE13FD0C35F57B4523F0DA1861C11D5A5'),
+        (UPASS_TABLE, '0x010083104228FAD559BE52477F2131E538BE9734E5C4B0ADEFD7F6D784B03C98585DC634FE2B8CA3A6DFFEC729B4'),
+
+    ]
+
+    known_alternate_hashes = [
+        # lower case hex
+        ('0x01005b20054332752e1bc2e7c5df0f9ebfe486e9bee063e8d3b332752e1bc2e7c5df0f9ebfe486e9bee063e8d3b3',
+         '12345', '0x01005B20054332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B3'),
+    ]
+
+    known_unidentified_hashes = [
+        # malformed start
+        '0X01005B20054332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B3',
+
+        # wrong magic value
+        '0x02005B20054332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B3',
+
+        # wrong size
+        '0x01005B20054332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3',
+        '0x01005B20054332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B3AF',
+
+        # mssql2005
+        '0x01005B20054332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B3',
+    ]
+
+    known_malformed_hashes = [
+        # non-hex char -----\/
+        b'0x01005B200543327G2E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B3',
+        u('0x01005B200543327G2E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B3'),
+    ]
+
+class mssql2005_test(HandlerCase):
+    handler = hash.mssql2005
+
+    known_correct_hashes = [
+        #
+        # http://hkashfi.blogspot.com/2007/08/breaking-sql-server-2005-hashes.html
+        #
+        ('TEST', '0x010034767D5C2FD54D6119FFF04129A1D72E7C3194F7284A7F3A'),
+
+        #
+        # http://www.openwall.com/lists/john-users/2009/07/14/2
+        #
+        ('toto', '0x01004086CEB6BF932BC4151A1AF1F13CD17301D70816A8886908'),
+
+        #
+        # http://msmvps.com/blogs/gladchenko/archive/2005/04/06/41083.aspx
+        #
+        ('123', '0x01004A335DCEDB366D99F564D460B1965B146D6184E4E1025195'),
+        ('123', '0x0100E11D573F359629B344990DCD3D53DE82CF8AD6BBA7B638B6'),
+
+        #
+        # XXX: password unknown
+        # http://www.simple-talk.com/sql/t-sql-programming/temporarily-changing-an-unknown-password-of-the-sa-account-/
+        # (???, '0x01004086CEB6301EEC0A994E49E30DA235880057410264030797'),
+        #
+
+        #
+        # http://therelentlessfrontend.com/2010/03/26/encrypting-and-decrypting-passwords-in-sql-server/
+        #
+        ('AAAA', '0x010036D726AE86834E97F20B198ACD219D60B446AC5E48C54F30'),
+
+        #
+        # from JTR 1.7.9
+        #
+        ("toto", "0x01004086CEB6BF932BC4151A1AF1F13CD17301D70816A8886908"),
+        ("titi", "0x01004086CEB60ED526885801C23B366965586A43D3DEAC6DD3FD"),
+        ("foo", "0x0100A607BA7C54A24D17B565C59F1743776A10250F581D482DA8"),
+        ("bar", "0x01000508513EADDF6DB7DDD270CCA288BF097F2FF69CC2DB74FB"),
+        ("canard", "0x01008408C523CF06DCB237835D701C165E68F9460580132E28ED"),
+        ("lapin", "0x0100BF088517935FC9183FE39FDEC77539FD5CB52BA5F5761881"),
+
+        #
+        # adapted from mssql2000.known_correct_hashes (above)
+        #
+        ('Test',  '0x010034767D5C0CFA5FDCA28C4A56085E65E882E71CB0ED250341'),
+        ('Test',  '0x0100993BF2315F36CC441485B35C4D84687DC02C78B0E680411F'),
+        ('x',     '0x010086489146C46DD7318D2514D1AC706457CBF6CD3DF8407F07'),
+        ('AAAA',  '0x0100CF465B7B12625EF019E157120D58DD46569AC7BF4118455D'),
+        ('123',   '0x01002D60BA07FE612C8DE537DF3BFCFA49CD9968324481C1A8A8'),
+        ('12345', '0x01005B20054332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B3'),
+
+        #
+        # custom
+        #
+
+        # ensures utf-8 used for unicode
+        (UPASS_USD,   '0x0100624C0961B28E39FEE13FD0C35F57B4523F0DA1861C11D5A5'),
+        (UPASS_TABLE, '0x010083104228FAD559BE52477F2131E538BE9734E5C4B0ADEFD7'),
+    ]
+
+    known_alternate_hashes = [
+        # lower case hex
+        ('0x01005b20054332752e1bc2e7c5df0f9ebfe486e9bee063e8d3b3',
+         '12345', '0x01005B20054332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B3'),
+    ]
+
+    known_unidentified_hashes = [
+        # malformed start
+        '0X010036D726AE86834E97F20B198ACD219D60B446AC5E48C54F30',
+
+        # wrong magic value
+        '0x020036D726AE86834E97F20B198ACD219D60B446AC5E48C54F30',
+
+        # wrong size
+        '0x010036D726AE86834E97F20B198ACD219D60B446AC5E48C54F',
+        '0x010036D726AE86834E97F20B198ACD219D60B446AC5E48C54F3012',
+
+        # mssql2000
+        '0x01005B20054332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B332752E1BC2E7C5DF0F9EBFE486E9BEE063E8D3B3',
+    ]
+
+    known_malformed_hashes = [
+        # non-hex char --\/
+        '0x010036D726AE86G34E97F20B198ACD219D60B446AC5E48C54F30',
+    ]
+
+#=============================================================================
+# mysql 323 & 41
+#=============================================================================
+class mysql323_test(HandlerCase):
+    handler = hash.mysql323
+
+    known_correct_hashes = [
+        #
+        # from JTR 1.7.9
+        #
+        ('drew', '697a7de87c5390b2'),
+        ('password', "5d2e19393cc5ef67"),
+
+        #
+        # custom
+        #
+        ('mypass', '6f8c114b58f2ce9e'),
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '4ef327ca5491c8d7'),
+    ]
+
+    known_unidentified_hashes = [
+        # bad char in otherwise correct hash
+        '6z8c114b58f2ce9e',
+    ]
+
+    def test_90_whitespace(self):
+        """check whitespace is ignored per spec"""
+        h = self.do_encrypt("mypass")
+        h2 = self.do_encrypt("my pass")
+        self.assertEqual(h, h2)
+
+    class FuzzHashGenerator(HandlerCase.FuzzHashGenerator):
+
+        def accept_password_pair(self, secret, other):
+            # override to handle whitespace
+            return secret.replace(" ","") != other.replace(" ","")
+
+class mysql41_test(HandlerCase):
+    handler = hash.mysql41
+    known_correct_hashes = [
+        #
+        # from JTR 1.7.9
+        #
+        ('verysecretpassword', '*2C905879F74F28F8570989947D06A8429FB943E6'),
+        ('12345678123456781234567812345678', '*F9F1470004E888963FB466A5452C9CBD9DF6239C'),
+        ("' OR 1 /*'", '*97CF7A3ACBE0CA58D5391AC8377B5D9AC11D46D9'),
+
+        #
+        # custom
+        #
+        ('mypass', '*6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4'),
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '*E7AFE21A9CFA2FC9D15D942AE8FB5C240FE5837B'),
+    ]
+    known_unidentified_hashes = [
+        # bad char in otherwise correct hash
+        '*6Z8989366EAF75BB670AD8EA7A7FC1176A95CEF4',
+    ]
+
+#=============================================================================
+# NTHASH
+#=============================================================================
+class nthash_test(HandlerCase):
+    handler = hash.nthash
+
+    known_correct_hashes = [
+        #
+        # http://msdn.microsoft.com/en-us/library/cc245828(v=prot.10).aspx
+        #
+        ("OLDPASSWORD", u("6677b2c394311355b54f25eec5bfacf5")),
+        ("NEWPASSWORD", u("256781a62031289d3c2c98c14f1efc8c")),
+
+        #
+        # from JTR 1.7.9
+        #
+
+        # ascii
+        ('', '31d6cfe0d16ae931b73c59d7e0c089c0'),
+        ('tigger', 'b7e0ea9fbffcf6dd83086e905089effd'),
+
+        # utf-8
+        (b'\xC3\xBC', '8bd6e4fb88e01009818749c5443ea712'),
+        (b'\xC3\xBC\xC3\xBC', 'cc1260adb6985ca749f150c7e0b22063'),
+        (b'\xE2\x82\xAC', '030926b781938db4365d46adc7cfbcb8'),
+        (b'\xE2\x82\xAC\xE2\x82\xAC','682467b963bb4e61943e170a04f7db46'),
+
+        #
+        # custom
+        #
+        ('passphrase', '7f8fe03093cc84b267b109625f6bbf4b'),
+    ]
+
+    known_unidentified_hashes = [
+        # bad char in otherwise correct hash
+        '7f8fe03093cc84b267b109625f6bbfxb',
+    ]
+
+class bsd_nthash_test(HandlerCase):
+    handler = hash.bsd_nthash
+
+    known_correct_hashes = [
+        ('passphrase', '$3$$7f8fe03093cc84b267b109625f6bbf4b'),
+        (b'\xC3\xBC', '$3$$8bd6e4fb88e01009818749c5443ea712'),
+    ]
+
+    known_unidentified_hashes = [
+        # bad char in otherwise correct hash --\/
+            '$3$$7f8fe03093cc84b267b109625f6bbfxb',
+    ]
+
+#=============================================================================
+# oracle 10 & 11
+#=============================================================================
+class oracle10_test(UserHandlerMixin, HandlerCase):
+    handler = hash.oracle10
+    secret_case_insensitive = True
+    user_case_insensitive = True
+
+    # TODO: get more test vectors (especially ones which properly test unicode)
+    known_correct_hashes = [
+        # ((secret,user),hash)
+
+        #
+        # http://www.petefinnigan.com/default/default_password_list.htm
+        #
+        (('tiger', 'scott'), 'F894844C34402B67'),
+        ((u('ttTiGGeR'), u('ScO')), '7AA1A84E31ED7771'),
+        (("d_syspw", "SYSTEM"), '1B9F1F9A5CB9EB31'),
+        (("strat_passwd", "strat_user"), 'AEBEDBB4EFB5225B'),
+
+        #
+        # http://openwall.info/wiki/john/sample-hashes
+        #
+        (('#95LWEIGHTS', 'USER'), '000EA4D72A142E29'),
+        (('CIAO2010', 'ALFREDO'), 'EB026A76F0650F7B'),
+
+        #
+        # from JTR 1.7.9
+        #
+        (('GLOUGlou', 'Bob'), 'CDC6B483874B875B'),
+        (('GLOUGLOUTER', 'bOB'), 'EF1F9139DB2D5279'),
+        (('LONG_MOT_DE_PASSE_OUI', 'BOB'), 'EC8147ABB3373D53'),
+
+        #
+        # custom
+        #
+        ((UPASS_TABLE, 'System'), 'B915A853F297B281'),
+    ]
+
+    known_unidentified_hashes = [
+        # bad char in hash --\
+             'F894844C34402B6Z',
+    ]
+
+class oracle11_test(HandlerCase):
+    handler = hash.oracle11
+    # TODO: find more test vectors (especially ones which properly test unicode)
+    known_correct_hashes = [
+        #
+        # from JTR 1.7.9
+        #
+        ("abc123", "S:5FDAB69F543563582BA57894FE1C1361FB8ED57B903603F2C52ED1B4D642"),
+        ("SyStEm123!@#", "S:450F957ECBE075D2FA009BA822A9E28709FBC3DA82B44D284DDABEC14C42"),
+        ("oracle", "S:3437FF72BD69E3FB4D10C750B92B8FB90B155E26227B9AB62D94F54E5951"),
+        ("11g", "S:61CE616647A4F7980AFD7C7245261AF25E0AFE9C9763FCF0D54DA667D4E6"),
+        ("11g", "S:B9E7556F53500C8C78A58F50F24439D79962DE68117654B6700CE7CC71CF"),
+
+        #
+        # source?
+        #
+        ("SHAlala", "S:2BFCFDF5895014EE9BB2B9BA067B01E0389BB5711B7B5F82B7235E9E182C"),
+
+        #
+        # custom
+        #
+        (UPASS_TABLE, 'S:51586343E429A6DF024B8F242F2E9F8507B1096FACD422E29142AA4974B0'),
+    ]
+
+#=============================================================================
+# PHPass Portable Crypt
+#=============================================================================
+class phpass_test(HandlerCase):
+    handler = hash.phpass
+
+    known_correct_hashes = [
+        #
+        # from official 0.3 implementation
+        # http://www.openwall.com/phpass/
+        #
+        ('test12345', '$P$9IQRaTwmfeRo7ud9Fh4E2PdI0S3r.L0'), # from the source
+
+        #
+        # from JTR 1.7.9
+        #
+        ('test1', '$H$9aaaaaSXBjgypwqm.JsMssPLiS8YQ00'),
+        ('123456', '$H$9PE8jEklgZhgLmZl5.HYJAzfGCQtzi1'),
+        ('123456', '$H$9pdx7dbOW3Nnt32sikrjAxYFjX8XoK1'),
+        ('thisisalongertestPW', '$P$912345678LIjjb6PhecupozNBmDndU0'),
+        ('JohnRipper', '$P$612345678si5M0DDyPpmRCmcltU/YW/'),
+        ('JohnRipper', '$H$712345678WhEyvy1YWzT4647jzeOmo0'),
+        ('JohnRipper', '$P$B12345678L6Lpt4BxNotVIMILOa9u81'),
+
+        #
+        # custom
+        #
+        ('', '$P$7JaFQsPzJSuenezefD/3jHgt5hVfNH0'),
+        ('compL3X!', '$P$FiS0N5L672xzQx1rt1vgdJQRYKnQM9/'),
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '$P$7SMy8VxnfsIy2Sxm7fJxDSdil.h7TW.'),
+        ]
+
+    known_malformed_hashes = [
+        # bad char in otherwise correct hash
+        #                            ---\/
+        '$P$9IQRaTwmfeRo7ud9Fh4E2PdI0S3r!L0',
+        ]
+
+#=============================================================================
+# plaintext
+#=============================================================================
+class plaintext_test(HandlerCase):
+    # TODO: integrate EncodingHandlerMixin
+    handler = hash.plaintext
+    accepts_all_hashes = True
+
+    known_correct_hashes = [
+        ('',''),
+        ('password', 'password'),
+
+        # ensure unicode uses utf-8
+        (UPASS_TABLE, UPASS_TABLE if PY3 else PASS_TABLE_UTF8),
+        (PASS_TABLE_UTF8, UPASS_TABLE if PY3 else PASS_TABLE_UTF8),
+    ]
+
+#=============================================================================
+# postgres_md5
+#=============================================================================
+class postgres_md5_test(UserHandlerMixin, HandlerCase):
+    handler = hash.postgres_md5
+    known_correct_hashes = [
+        # ((secret,user),hash)
+
+        #
+        # generated using postgres 8.1
+        #
+        (('mypass', 'postgres'), 'md55fba2ea04fd36069d2574ea71c8efe9d'),
+        (('mypass', 'root'), 'md540c31989b20437833f697e485811254b'),
+        (("testpassword",'testuser'), 'md5d4fc5129cc2c25465a5370113ae9835f'),
+
+        #
+        # custom
+        #
+
+        # verify unicode->utf8
+        ((UPASS_TABLE, 'postgres'), 'md5cb9f11283265811ce076db86d18a22d2'),
+    ]
+    known_unidentified_hashes = [
+        # bad 'z' char in otherwise correct hash
+        'md54zc31989b20437833f697e485811254b',
+    ]
+
+#=============================================================================
+# (netbsd's) sha1 crypt
+#=============================================================================
+class _sha1_crypt_test(HandlerCase):
+    handler = hash.sha1_crypt
+
+    known_correct_hashes = [
+        #
+        # custom
+        #
+        ("password", "$sha1$19703$iVdJqfSE$v4qYKl1zqYThwpjJAoKX6UvlHq/a"),
+        ("password", "$sha1$21773$uV7PTeux$I9oHnvwPZHMO0Nq6/WgyGV/tDJIH"),
+        (UPASS_TABLE, '$sha1$40000$uJ3Sp7LE$.VEmLO5xntyRFYihC7ggd3297T/D'),
+    ]
+
+    known_malformed_hashes = [
+        # bad char in otherwise correct hash
+        '$sha1$21773$u!7PTeux$I9oHnvwPZHMO0Nq6/WgyGV/tDJIH',
+
+        # zero padded rounds
+        '$sha1$01773$uV7PTeux$I9oHnvwPZHMO0Nq6/WgyGV/tDJIH',
+
+        # too many fields
+        '$sha1$21773$uV7PTeux$I9oHnvwPZHMO0Nq6/WgyGV/tDJIH$',
+
+        # empty rounds field
+        '$sha1$$uV7PTeux$I9oHnvwPZHMO0Nq6/WgyGV/tDJIH$',
+    ]
+
+    platform_crypt_support = [
+        ("netbsd", True),
+        ("freebsd|openbsd|solaris|darwin", False),
+        ("linux", None),  # may be present if libxcrypt is in use
+    ]
+
+# create test cases for specific backends
+sha1_crypt_os_crypt_test = _sha1_crypt_test.create_backend_case("os_crypt")
+sha1_crypt_builtin_test = _sha1_crypt_test.create_backend_case("builtin")
+
+#=============================================================================
+# roundup
+#=============================================================================
+
+# NOTE: all roundup hashes use PrefixWrapper,
+#       so there's nothing natively to test.
+#       so we just have a few quick cases...
+
+class RoundupTest(TestCase):
+
+    def _test_pair(self, h, secret, hash):
+        self.assertTrue(h.verify(secret, hash))
+        self.assertFalse(h.verify('x'+secret, hash))
+
+    def test_pairs(self):
+        self._test_pair(
+            hash.ldap_hex_sha1,
+            "sekrit",
+            '{SHA}8d42e738c7adee551324955458b5e2c0b49ee655')
+
+        self._test_pair(
+            hash.ldap_hex_md5,
+            "sekrit",
+            '{MD5}ccbc53f4464604e714f69dd11138d8b5')
+
+        self._test_pair(
+            hash.ldap_des_crypt,
+            "sekrit",
+            '{CRYPT}nFia0rj2TT59A')
+
+        self._test_pair(
+            hash.roundup_plaintext,
+            "sekrit",
+            '{plaintext}sekrit')
+
+        self._test_pair(
+            hash.ldap_pbkdf2_sha1,
+            "sekrit",
+            '{PBKDF2}5000$7BvbBq.EZzz/O0HuwX3iP.nAG3s$g3oPnFFaga2BJaX5PoPRljl4XIE')
+
+#=============================================================================
+# sha256-crypt
+#=============================================================================
+class _sha256_crypt_test(HandlerCase):
+    handler = hash.sha256_crypt
+
+    known_correct_hashes = [
+        #
+        # from JTR 1.7.9
+        #
+        ('U*U*U*U*', '$5$LKO/Ute40T3FNF95$U0prpBQd4PloSGU0pnpM4z9wKn4vZ1.jsrzQfPqxph9'),
+        ('U*U***U', '$5$LKO/Ute40T3FNF95$fdgfoJEBoMajNxCv3Ru9LyQ0xZgv0OBMQoq80LQ/Qd.'),
+        ('U*U***U*', '$5$LKO/Ute40T3FNF95$8Ry82xGnnPI/6HtFYnvPBTYgOL23sdMXn8C29aO.x/A'),
+        ('*U*U*U*U', '$5$9mx1HkCz7G1xho50$O7V7YgleJKLUhcfk9pgzdh3RapEaWqMtEp9UUBAKIPA'),
+        ('', '$5$kc7lRD1fpYg0g.IP$d7CMTcEqJyTXyeq8hTdu/jB/I6DGkoo62NXbHIR7S43'),
+
+        #
+        # custom tests
+        #
+        ('', '$5$rounds=10428$uy/jIAhCetNCTtb0$YWvUOXbkqlqhyoPMpN8BMe.ZGsGx2aBvxTvDFI613c3'),
+        (' ', '$5$rounds=10376$I5lNtXtRmf.OoMd8$Ko3AI1VvTANdyKhBPavaRjJzNpSatKU6QVN9uwS9MH.'),
+        ('test', '$5$rounds=11858$WH1ABM5sKhxbkgCK$aTQsjPkz0rBsH3lQlJxw9HDTDXPKBxC0LlVeV69P.t1'),
+        ('Compl3X AlphaNu3meric', '$5$rounds=10350$o.pwkySLCzwTdmQX$nCMVsnF3TXWcBPOympBUUSQi6LGGloZoOsVJMGJ09UB'),
+        ('4lpHa N|_|M3r1K W/ Cur5Es: #$%(*)(*%#', '$5$rounds=11944$9dhlu07dQMRWvTId$LyUI5VWkGFwASlzntk1RLurxX54LUhgAcJZIt0pYGT7'),
+        (u('with unic\u00D6de'), '$5$rounds=1000$IbG0EuGQXw5EkMdP$LQ5AfPf13KufFsKtmazqnzSGZ4pxtUNw3woQ.ELRDF4'),
+        ]
+
+    if TEST_MODE("full"):
+        # builtin alg was changed in 1.6, and had possibility of fencepost
+        # errors near rounds that are multiples of 42. these hashes test rounds
+        # 1004..1012 (42*24=1008 +/- 4) to ensure no mistakes were made.
+        # (also relying on fuzz testing against os_crypt backend).
+        known_correct_hashes.extend([
+        ("secret", '$5$rounds=1004$nacl$oiWPbm.kQ7.jTCZoOtdv7/tO5mWv/vxw5yTqlBagVR7'),
+        ("secret", '$5$rounds=1005$nacl$6Mo/TmGDrXxg.bMK9isRzyWH3a..6HnSVVsJMEX7ud/'),
+        ("secret", '$5$rounds=1006$nacl$I46VwuAiUBwmVkfPFakCtjVxYYaOJscsuIeuZLbfKID'),
+        ("secret", '$5$rounds=1007$nacl$9fY4j1AV3N/dV/YMUn1enRHKH.7nEL4xf1wWB6wfDD4'),
+        ("secret", '$5$rounds=1008$nacl$CiFWCfn8ODmWs0I1xAdXFo09tM8jr075CyP64bu3by9'),
+        ("secret", '$5$rounds=1009$nacl$QtpFX.CJHgVQ9oAjVYStxAeiU38OmFILWm684c6FyED'),
+        ("secret", '$5$rounds=1010$nacl$ktAwXuT5WbjBW/0ZU1eNMpqIWY1Sm4twfRE1zbZyo.B'),
+        ("secret", '$5$rounds=1011$nacl$QJWLBEhO9qQHyMx4IJojSN9sS41P1Yuz9REddxdO721'),
+        ("secret", '$5$rounds=1012$nacl$mmf/k2PkbBF4VCtERgky3bEVavmLZKFwAcvxD1p3kV2'),
+        ])
+
+    known_malformed_hashes = [
+        # bad char in otherwise correct hash
+        '$5$rounds=10428$uy/:jIAhCetNCTtb0$YWvUOXbkqlqhyoPMpN8BMeZGsGx2aBvxTvDFI613c3',
+
+        # zero-padded rounds
+       '$5$rounds=010428$uy/jIAhCetNCTtb0$YWvUOXbkqlqhyoPMpN8BMe.ZGsGx2aBvxTvDFI613c3',
+
+        # extra "$"
+       '$5$rounds=10428$uy/jIAhCetNCTtb0$YWvUOXbkqlqhyoPMpN8BMe.ZGsGx2aBvxTvDFI613c3$',
+    ]
+
+    known_correct_configs = [
+        # config, secret, result
+
+        #
+        # taken from official specification at http://www.akkadia.org/drepper/SHA-crypt.txt
+        #
+        ( "$5$saltstring", "Hello world!",
+          "$5$saltstring$5B8vYYiY.CVt1RlTTf8KbXBH3hsxY/GNooZaBBGWEc5" ),
+        ( "$5$rounds=10000$saltstringsaltstring", "Hello world!",
+          "$5$rounds=10000$saltstringsaltst$3xv.VbSHBb41AL9AvLeujZkZRBAwqFMz2."
+          "opqey6IcA" ),
+        ( "$5$rounds=5000$toolongsaltstring", "This is just a test",
+          "$5$rounds=5000$toolongsaltstrin$Un/5jzAHMgOGZ5.mWJpuVolil07guHPvOW8"
+          "mGRcvxa5" ),
+        ( "$5$rounds=1400$anotherlongsaltstring",
+          "a very much longer text to encrypt.  This one even stretches over more"
+          "than one line.",
+          "$5$rounds=1400$anotherlongsalts$Rx.j8H.h8HjEDGomFU8bDkXm3XIUnzyxf12"
+          "oP84Bnq1" ),
+        ( "$5$rounds=77777$short",
+          "we have a short salt string but not a short password",
+          "$5$rounds=77777$short$JiO1O3ZpDAxGJeaDIuqCoEFysAe1mZNJRs3pw0KQRd/" ),
+        ( "$5$rounds=123456$asaltof16chars..", "a short string",
+          "$5$rounds=123456$asaltof16chars..$gP3VQ/6X7UUEW3HkBn2w1/Ptq2jxPyzV/"
+          "cZKmF/wJvD" ),
+        ( "$5$rounds=10$roundstoolow", "the minimum number is still observed",
+          "$5$rounds=1000$roundstoolow$yfvwcWrQ8l/K0DAWyuPMDNHpIVlTQebY9l/gL97"
+          "2bIC" ),
+    ]
+
+    filter_config_warnings = True # rounds too low, salt too small
+
+    platform_crypt_support = [
+        ("freebsd(9|1\d)|linux", True),
+        ("freebsd8", None),  # added in freebsd 8.3
+        ("freebsd|openbsd|netbsd|darwin", False),
+        ("solaris", None),  # depends on policy
+    ]
+
+# create test cases for specific backends
+sha256_crypt_os_crypt_test = _sha256_crypt_test.create_backend_case("os_crypt")
+sha256_crypt_builtin_test = _sha256_crypt_test.create_backend_case("builtin")
+
+#=============================================================================
+# test sha512-crypt
+#=============================================================================
+class _sha512_crypt_test(HandlerCase):
+    handler = hash.sha512_crypt
+
+    known_correct_hashes = [
+        #
+        # from JTR 1.7.9
+        #
+        ('U*U*U*U*', "$6$LKO/Ute40T3FNF95$6S/6T2YuOIHY0N3XpLKABJ3soYcXD9mB7uVbtEZDj/LNscVhZoZ9DEH.sBciDrMsHOWOoASbNLTypH/5X26gN0"),
+        ('U*U***U', "$6$LKO/Ute40T3FNF95$wK80cNqkiAUzFuVGxW6eFe8J.fSVI65MD5yEm8EjYMaJuDrhwe5XXpHDJpwF/kY.afsUs1LlgQAaOapVNbggZ1"),
+        ('U*U***U*', "$6$LKO/Ute40T3FNF95$YS81pp1uhOHTgKLhSMtQCr2cDiUiN03Ud3gyD4ameviK1Zqz.w3oXsMgO6LrqmIEcG3hiqaUqHi/WEE2zrZqa/"),
+        ('*U*U*U*U', "$6$OmBOuxFYBZCYAadG$WCckkSZok9xhp4U1shIZEV7CCVwQUwMVea7L3A77th6SaE9jOPupEMJB.z0vIWCDiN9WLh2m9Oszrj5G.gt330"),
+        ('', "$6$ojWH1AiTee9x1peC$QVEnTvRVlPRhcLQCk/HnHaZmlGAAjCfrAN0FtOsOnUk5K5Bn/9eLHHiRzrTzaIKjW9NTLNIBUCtNVOowWS2mN."),
+
+        #
+        # custom tests
+        #
+        ('', '$6$rounds=11021$KsvQipYPWpr93wWP$v7xjI4X6vyVptJjB1Y02vZC5SaSijBkGmq1uJhPr3cvqvvkd42Xvo48yLVPFt8dvhCsnlUgpX.//Cxn91H4qy1'),
+        (' ', '$6$rounds=11104$ED9SA4qGmd57Fq2m$q/.PqACDM/JpAHKmr86nkPzzuR5.YpYa8ZJJvI8Zd89ZPUYTJExsFEIuTYbM7gAGcQtTkCEhBKmp1S1QZwaXx0'),
+        ('test', '$6$rounds=11531$G/gkPn17kHYo0gTF$Kq.uZBHlSBXyzsOJXtxJruOOH4yc0Is13uY7yK0PvAvXxbvc1w8DO1RzREMhKsc82K/Jh8OquV8FZUlreYPJk1'),
+        ('Compl3X AlphaNu3meric', '$6$rounds=10787$wakX8nGKEzgJ4Scy$X78uqaX1wYXcSCtS4BVYw2trWkvpa8p7lkAtS9O/6045fK4UB2/Jia0Uy/KzCpODlfVxVNZzCCoV9s2hoLfDs/'),
+        ('4lpHa N|_|M3r1K W/ Cur5Es: #$%(*)(*%#', '$6$rounds=11065$5KXQoE1bztkY5IZr$Jf6krQSUKKOlKca4hSW07MSerFFzVIZt/N3rOTsUgKqp7cUdHrwV8MoIVNCk9q9WL3ZRMsdbwNXpVk0gVxKtz1'),
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '$6$rounds=40000$PEZTJDiyzV28M3.m$GTlnzfzGB44DGd1XqlmC4erAJKCP.rhvLvrYxiT38htrNzVGBnplFOHjejUGVrCfusGWxLQCc3pFO0A/1jYYr0'),
+        ]
+
+    known_malformed_hashes = [
+        # zero-padded rounds
+        '$6$rounds=011021$KsvQipYPWpr93wWP$v7xjI4X6vyVptJjB1Y02vZC5SaSijBkGmq1uJhPr3cvqvvkd42Xvo48yLVPFt8dvhCsnlUgpX.//Cxn91H4qy1',
+        # bad char in otherwise correct hash
+        '$6$rounds=11021$KsvQipYPWpr9:wWP$v7xjI4X6vyVptJjB1Y02vZC5SaSijBkGmq1uJhPr3cvqvvkd42Xvo48yLVPFt8dvhCsnlUgpX.//Cxn91H4qy1',
+    ]
+
+    known_correct_configs = [
+        # config, secret, result
+
+        #
+        # taken from official specification at http://www.akkadia.org/drepper/SHA-crypt.txt
+        #
+        ("$6$saltstring", "Hello world!",
+        "$6$saltstring$svn8UoSVapNtMuq1ukKS4tPQd8iKwSMHWjl/O817G3uBnIFNjnQJu"
+        "esI68u4OTLiBFdcbYEdFCoEOfaS35inz1" ),
+
+      ( "$6$rounds=10000$saltstringsaltstring", "Hello world!",
+        "$6$rounds=10000$saltstringsaltst$OW1/O6BYHV6BcXZu8QVeXbDWra3Oeqh0sb"
+        "HbbMCVNSnCM/UrjmM0Dp8vOuZeHBy/YTBmSK6H9qs/y3RnOaw5v." ),
+
+      ( "$6$rounds=5000$toolongsaltstring", "This is just a test",
+        "$6$rounds=5000$toolongsaltstrin$lQ8jolhgVRVhY4b5pZKaysCLi0QBxGoNeKQ"
+        "zQ3glMhwllF7oGDZxUhx1yxdYcz/e1JSbq3y6JMxxl8audkUEm0" ),
+
+      ( "$6$rounds=1400$anotherlongsaltstring",
+        "a very much longer text to encrypt.  This one even stretches over more"
+        "than one line.",
+        "$6$rounds=1400$anotherlongsalts$POfYwTEok97VWcjxIiSOjiykti.o/pQs.wP"
+        "vMxQ6Fm7I6IoYN3CmLs66x9t0oSwbtEW7o7UmJEiDwGqd8p4ur1" ),
+
+      ( "$6$rounds=77777$short",
+        "we have a short salt string but not a short password",
+        "$6$rounds=77777$short$WuQyW2YR.hBNpjjRhpYD/ifIw05xdfeEyQoMxIXbkvr0g"
+        "ge1a1x3yRULJ5CCaUeOxFmtlcGZelFl5CxtgfiAc0" ),
+
+      ( "$6$rounds=123456$asaltof16chars..", "a short string",
+        "$6$rounds=123456$asaltof16chars..$BtCwjqMJGx5hrJhZywWvt0RLE8uZ4oPwc"
+        "elCjmw2kSYu.Ec6ycULevoBK25fs2xXgMNrCzIMVcgEJAstJeonj1" ),
+
+      ( "$6$rounds=10$roundstoolow", "the minimum number is still observed",
+        "$6$rounds=1000$roundstoolow$kUMsbe306n21p9R.FRkW3IGn.S9NPN0x50YhH1x"
+        "hLsPuWGsUSklZt58jaTfF4ZEQpyUNGc0dqbpBYYBaHHrsX." ),
+    ]
+
+    filter_config_warnings = True # rounds too low, salt too small
+
+    platform_crypt_support = _sha256_crypt_test.platform_crypt_support
+
+# create test cases for specific backends
+sha512_crypt_os_crypt_test = _sha512_crypt_test.create_backend_case("os_crypt")
+sha512_crypt_builtin_test = _sha512_crypt_test.create_backend_case("builtin")
+
+#=============================================================================
+# sun md5 crypt
+#=============================================================================
+class sun_md5_crypt_test(HandlerCase):
+    handler = hash.sun_md5_crypt
+
+    # TODO: this scheme needs some real test vectors, especially due to
+    # the "bare salt" issue which plagued the official parser.
+    known_correct_hashes = [
+        #
+        # http://forums.halcyoninc.com/showthread.php?t=258
+        #
+        ("Gpcs3_adm", "$md5$zrdhpMlZ$$wBvMOEqbSjU.hu5T2VEP01"),
+
+        #
+        # http://www.c0t0d0s0.org/archives/4453-Less-known-Solaris-features-On-passwords-Part-2-Using-stronger-password-hashing.html
+        #
+        ("aa12345678", "$md5$vyy8.OVF$$FY4TWzuauRl4.VQNobqMY."),
+
+        #
+        # http://www.cuddletech.com/blog/pivot/entry.php?id=778
+        #
+        ("this", "$md5$3UqYqndY$$6P.aaWOoucxxq.l00SS9k0"),
+
+        #
+        # http://compgroups.net/comp.unix.solaris/password-file-in-linux-and-solaris-8-9
+        #
+        ("passwd", "$md5$RPgLF6IJ$WTvAlUJ7MqH5xak2FMEwS/"),
+
+        #
+        # source: http://solaris-training.com/301_HTML/docs/deepdiv.pdf page 27
+        # FIXME: password unknown
+        # "$md5,rounds=8000$kS9FT1JC$$mnUrRO618lLah5iazwJ9m1"
+
+        #
+        # source: http://www.visualexams.com/310-303.htm
+        # XXX: this has 9 salt chars unlike all other hashes. is that valid?
+        # FIXME: password unknown
+        # "$md5,rounds=2006$2amXesSj5$$kCF48vfPsHDjlKNXeEw7V."
+        #
+
+        #
+        # custom
+        #
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '$md5,rounds=5000$10VYDzAA$$1arAVtMA3trgE1qJ2V0Ez1'),
+        ]
+
+    known_correct_configs = [
+        # (config, secret, hash)
+
+        #---------------------------
+        # test salt string handling
+        #
+        # these tests attempt to verify that passlib is handling
+        # the "bare salt" issue (see sun md5 crypt docs)
+        # in a sane manner
+        #---------------------------
+
+        # config with "$" suffix, hash strings with "$$" suffix,
+        # should all be treated the same, with one "$" added to salt digest.
+        ("$md5$3UqYqndY$",
+            "this", "$md5$3UqYqndY$$6P.aaWOoucxxq.l00SS9k0"),
+        ("$md5$3UqYqndY$$.................DUMMY",
+            "this", "$md5$3UqYqndY$$6P.aaWOoucxxq.l00SS9k0"),
+
+        # config with no suffix, hash strings with "$" suffix,
+        # should all be treated the same, and no suffix added to salt digest.
+        # NOTE: this is just a guess re: config w/ no suffix,
+        #       but otherwise there's no sane way to encode bare_salt=False
+        #       within config string.
+        ("$md5$3UqYqndY",
+            "this", "$md5$3UqYqndY$HIZVnfJNGCPbDZ9nIRSgP1"),
+        ("$md5$3UqYqndY$.................DUMMY",
+            "this", "$md5$3UqYqndY$HIZVnfJNGCPbDZ9nIRSgP1"),
+    ]
+
+    known_malformed_hashes = [
+        # unexpected end of hash
+        "$md5,rounds=5000",
+
+        # bad rounds
+        "$md5,rounds=500A$xxxx",
+        "$md5,rounds=0500$xxxx",
+        "$md5,rounds=0$xxxx",
+
+        # bad char in otherwise correct hash
+        "$md5$RPgL!6IJ$WTvAlUJ7MqH5xak2FMEwS/",
+
+        # digest too short
+        "$md5$RPgLa6IJ$WTvAlUJ7MqH5xak2FMEwS",
+
+        # digest too long
+        "$md5$RPgLa6IJ$WTvAlUJ7MqH5xak2FMEwS/.",
+
+        # 2+ "$" at end of salt in config
+        # NOTE: not sure what correct behavior is, so forbidding format for now.
+        "$md5$3UqYqndY$$",
+
+        # 3+ "$" at end of salt in hash
+        # NOTE: not sure what correct behavior is, so forbidding format for now.
+        "$md5$RPgLa6IJ$$$WTvAlUJ7MqH5xak2FMEwS/",
+
+        ]
+
+    platform_crypt_support = [
+        ("solaris", True),
+        ("freebsd|openbsd|netbsd|linux|darwin", False),
+    ]
+    def do_verify(self, secret, hash):
+        # Override to fake error for "$..." hash string listed in known_correct_configs (above)
+        # These have to be hash strings, in order to test bare salt issue.
+        if isinstance(hash, str) and hash.endswith("$.................DUMMY"):
+            raise ValueError("pretending '$...' stub hash is config string")
+        return self.handler.verify(secret, hash)
+
+#=============================================================================
+# unix disabled / fallback
+#=============================================================================
+class unix_disabled_test(HandlerCase):
+    handler = hash.unix_disabled
+#    accepts_all_hashes = True # TODO: turn this off.
+
+    known_correct_hashes = [
+        # everything should hash to "!" (or "*" on BSD),
+        # and nothing should verify against either string
+        ("password", "!"),
+        (UPASS_TABLE, "*"),
+    ]
+
+    known_unidentified_hashes = [
+        # should never identify anything crypt() could return...
+        "$1$xxx",
+        "abc",
+        "./az",
+        "{SHA}xxx",
+    ]
+
+    def test_76_hash_border(self):
+        # so empty strings pass
+        self.accepts_all_hashes = True
+        super(unix_disabled_test, self).test_76_hash_border()
+
+    def test_90_special(self):
+        """test marker option & special behavior"""
+        warnings.filterwarnings("ignore", "passing settings to .*.hash\(\) is deprecated")
+        handler = self.handler
+
+        # preserve hash if provided
+        self.assertEqual(handler.genhash("stub", "!asd"), "!asd")
+
+        # use marker if no hash
+        self.assertEqual(handler.genhash("stub", ""), handler.default_marker)
+        self.assertEqual(handler.hash("stub"), handler.default_marker)
+        self.assertEqual(handler.using().default_marker, handler.default_marker)
+
+        # custom marker
+        self.assertEqual(handler.genhash("stub", "", marker="*xxx"), "*xxx")
+        self.assertEqual(handler.hash("stub", marker="*xxx"), "*xxx")
+        self.assertEqual(handler.using(marker="*xxx").hash("stub"), "*xxx")
+
+        # reject invalid marker
+        self.assertRaises(ValueError, handler.genhash, 'stub', "", marker='abc')
+        self.assertRaises(ValueError, handler.hash, 'stub', marker='abc')
+        self.assertRaises(ValueError, handler.using, marker='abc')
+
+class unix_fallback_test(HandlerCase):
+    handler = hash.unix_fallback
+    accepts_all_hashes = True
+
+    known_correct_hashes = [
+        # *everything* should hash to "!", and nothing should verify
+        ("password", "!"),
+        (UPASS_TABLE, "!"),
+    ]
+
+    # silence annoying deprecation warning
+    def setUp(self):
+        super(unix_fallback_test, self).setUp()
+        warnings.filterwarnings("ignore", "'unix_fallback' is deprecated")
+
+    def test_90_wildcard(self):
+        """test enable_wildcard flag"""
+        h = self.handler
+        self.assertTrue(h.verify('password','', enable_wildcard=True))
+        self.assertFalse(h.verify('password',''))
+        for c in "!*x":
+            self.assertFalse(h.verify('password',c, enable_wildcard=True))
+            self.assertFalse(h.verify('password',c))
+
+    def test_91_preserves_existing(self):
+        """test preserves existing disabled hash"""
+        handler = self.handler
+
+        # use marker if no hash
+        self.assertEqual(handler.genhash("stub", ""), "!")
+        self.assertEqual(handler.hash("stub"), "!")
+
+        # use hash if provided and valid
+        self.assertEqual(handler.genhash("stub", "!asd"), "!asd")
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_argon2.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_argon2.py
new file mode 100644
index 0000000..e771769
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_argon2.py
@@ -0,0 +1,507 @@
+"""passlib.tests.test_handlers_argon2 - tests for passlib hash algorithms"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import logging
+log = logging.getLogger(__name__)
+import re
+import warnings
+# site
+# pkg
+from passlib import hash
+from passlib.utils.compat import unicode
+from passlib.tests.utils import HandlerCase, TEST_MODE
+from passlib.tests.test_handlers import UPASS_TABLE, PASS_TABLE_UTF8
+# module
+
+#=============================================================================
+# a bunch of tests lifted nearlky verbatim from official argon2 UTs...
+# https://github.com/P-H-C/phc-winner-argon2/blob/master/src/test.c
+#=============================================================================
+def hashtest(version, t, logM, p, secret, salt, hex_digest, hash):
+    return dict(version=version, rounds=t, logM=logM, memory_cost=1<<logM, parallelism=p,
+                secret=secret, salt=salt, hex_digest=hex_digest, hash=hash)
+
+# version 1.3 "I" tests
+version = 0x10
+reference_data = [
+    hashtest(version, 2, 16, 1, "password", "somesalt",
+             "f6c4db4a54e2a370627aff3db6176b94a2a209a62c8e36152711802f7b30c694",
+             "$argon2i$m=65536,t=2,p=1$c29tZXNhbHQ"
+             "$9sTbSlTio3Biev89thdrlKKiCaYsjjYVJxGAL3swxpQ"),
+    hashtest(version, 2, 20, 1, "password", "somesalt",
+             "9690ec55d28d3ed32562f2e73ea62b02b018757643a2ae6e79528459de8106e9",
+             "$argon2i$m=1048576,t=2,p=1$c29tZXNhbHQ"
+             "$lpDsVdKNPtMlYvLnPqYrArAYdXZDoq5ueVKEWd6BBuk"),
+    hashtest(version, 2, 18, 1, "password", "somesalt",
+             "3e689aaa3d28a77cf2bc72a51ac53166761751182f1ee292e3f677a7da4c2467",
+             "$argon2i$m=262144,t=2,p=1$c29tZXNhbHQ"
+             "$Pmiaqj0op3zyvHKlGsUxZnYXURgvHuKS4/Z3p9pMJGc"),
+    hashtest(version, 2, 8, 1, "password", "somesalt",
+             "fd4dd83d762c49bdeaf57c47bdcd0c2f1babf863fdeb490df63ede9975fccf06",
+             "$argon2i$m=256,t=2,p=1$c29tZXNhbHQ"
+             "$/U3YPXYsSb3q9XxHvc0MLxur+GP960kN9j7emXX8zwY"),
+    hashtest(version, 2, 8, 2, "password", "somesalt",
+             "b6c11560a6a9d61eac706b79a2f97d68b4463aa3ad87e00c07e2b01e90c564fb",
+             "$argon2i$m=256,t=2,p=2$c29tZXNhbHQ"
+             "$tsEVYKap1h6scGt5ovl9aLRGOqOth+AMB+KwHpDFZPs"),
+    hashtest(version, 1, 16, 1, "password", "somesalt",
+             "81630552b8f3b1f48cdb1992c4c678643d490b2b5eb4ff6c4b3438b5621724b2",
+             "$argon2i$m=65536,t=1,p=1$c29tZXNhbHQ"
+             "$gWMFUrjzsfSM2xmSxMZ4ZD1JCytetP9sSzQ4tWIXJLI"),
+    hashtest(version, 4, 16, 1, "password", "somesalt",
+             "f212f01615e6eb5d74734dc3ef40ade2d51d052468d8c69440a3a1f2c1c2847b",
+             "$argon2i$m=65536,t=4,p=1$c29tZXNhbHQ"
+             "$8hLwFhXm6110c03D70Ct4tUdBSRo2MaUQKOh8sHChHs"),
+    hashtest(version, 2, 16, 1, "differentpassword", "somesalt",
+             "e9c902074b6754531a3a0be519e5baf404b30ce69b3f01ac3bf21229960109a3",
+             "$argon2i$m=65536,t=2,p=1$c29tZXNhbHQ"
+             "$6ckCB0tnVFMaOgvlGeW69ASzDOabPwGsO/ISKZYBCaM"),
+    hashtest(version, 2, 16, 1, "password", "diffsalt",
+             "79a103b90fe8aef8570cb31fc8b22259778916f8336b7bdac3892569d4f1c497",
+             "$argon2i$m=65536,t=2,p=1$ZGlmZnNhbHQ"
+             "$eaEDuQ/orvhXDLMfyLIiWXeJFvgza3vaw4kladTxxJc"),
+]
+
+# version 1.9 "I" tests
+version = 0x13
+reference_data.extend([
+    hashtest(version, 2, 16, 1, "password", "somesalt",
+             "c1628832147d9720c5bd1cfd61367078729f6dfb6f8fea9ff98158e0d7816ed0",
+             "$argon2i$v=19$m=65536,t=2,p=1$c29tZXNhbHQ"
+             "$wWKIMhR9lyDFvRz9YTZweHKfbftvj+qf+YFY4NeBbtA"),
+    hashtest(version, 2, 20, 1, "password", "somesalt",
+             "d1587aca0922c3b5d6a83edab31bee3c4ebaef342ed6127a55d19b2351ad1f41",
+             "$argon2i$v=19$m=1048576,t=2,p=1$c29tZXNhbHQ"
+             "$0Vh6ygkiw7XWqD7asxvuPE667zQu1hJ6VdGbI1GtH0E"),
+    hashtest(version, 2, 18, 1, "password", "somesalt",
+             "296dbae80b807cdceaad44ae741b506f14db0959267b183b118f9b24229bc7cb",
+             "$argon2i$v=19$m=262144,t=2,p=1$c29tZXNhbHQ"
+             "$KW266AuAfNzqrUSudBtQbxTbCVkmexg7EY+bJCKbx8s"),
+    hashtest(version, 2, 8, 1, "password", "somesalt",
+             "89e9029f4637b295beb027056a7336c414fadd43f6b208645281cb214a56452f",
+             "$argon2i$v=19$m=256,t=2,p=1$c29tZXNhbHQ"
+             "$iekCn0Y3spW+sCcFanM2xBT63UP2sghkUoHLIUpWRS8"),
+    hashtest(version, 2, 8, 2, "password", "somesalt",
+             "4ff5ce2769a1d7f4c8a491df09d41a9fbe90e5eb02155a13e4c01e20cd4eab61",
+             "$argon2i$v=19$m=256,t=2,p=2$c29tZXNhbHQ"
+             "$T/XOJ2mh1/TIpJHfCdQan76Q5esCFVoT5MAeIM1Oq2E"),
+    hashtest(version, 1, 16, 1, "password", "somesalt",
+             "d168075c4d985e13ebeae560cf8b94c3b5d8a16c51916b6f4ac2da3ac11bbecf",
+             "$argon2i$v=19$m=65536,t=1,p=1$c29tZXNhbHQ"
+             "$0WgHXE2YXhPr6uVgz4uUw7XYoWxRkWtvSsLaOsEbvs8"),
+    hashtest(version, 4, 16, 1, "password", "somesalt",
+             "aaa953d58af3706ce3df1aefd4a64a84e31d7f54175231f1285259f88174ce5b",
+             "$argon2i$v=19$m=65536,t=4,p=1$c29tZXNhbHQ"
+             "$qqlT1YrzcGzj3xrv1KZKhOMdf1QXUjHxKFJZ+IF0zls"),
+    hashtest(version, 2, 16, 1, "differentpassword", "somesalt",
+             "14ae8da01afea8700c2358dcef7c5358d9021282bd88663a4562f59fb74d22ee",
+             "$argon2i$v=19$m=65536,t=2,p=1$c29tZXNhbHQ"
+             "$FK6NoBr+qHAMI1jc73xTWNkCEoK9iGY6RWL1n7dNIu4"),
+    hashtest(version, 2, 16, 1, "password", "diffsalt",
+             "b0357cccfbef91f3860b0dba447b2348cbefecadaf990abfe9cc40726c521271",
+             "$argon2i$v=19$m=65536,t=2,p=1$ZGlmZnNhbHQ"
+             "$sDV8zPvvkfOGCw26RHsjSMvv7K2vmQq/6cxAcmxSEnE"),
+])
+
+# version 1.9 "ID" tests
+version = 0x13
+reference_data.extend([
+    hashtest(version, 2, 16, 1, "password", "somesalt",
+             "09316115d5cf24ed5a15a31a3ba326e5cf32edc24702987c02b6566f61913cf7",
+             "$argon2id$v=19$m=65536,t=2,p=1$c29tZXNhbHQ"
+             "$CTFhFdXPJO1aFaMaO6Mm5c8y7cJHAph8ArZWb2GRPPc"),
+    hashtest(version, 2, 18, 1, "password", "somesalt",
+             "78fe1ec91fb3aa5657d72e710854e4c3d9b9198c742f9616c2f085bed95b2e8c",
+             "$argon2id$v=19$m=262144,t=2,p=1$c29tZXNhbHQ"
+             "$eP4eyR+zqlZX1y5xCFTkw9m5GYx0L5YWwvCFvtlbLow"),
+    hashtest(version, 2, 8, 1, "password", "somesalt",
+             "9dfeb910e80bad0311fee20f9c0e2b12c17987b4cac90c2ef54d5b3021c68bfe",
+             "$argon2id$v=19$m=256,t=2,p=1$c29tZXNhbHQ"
+             "$nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4"),
+    hashtest(version, 2, 8, 2, "password", "somesalt",
+             "6d093c501fd5999645e0ea3bf620d7b8be7fd2db59c20d9fff9539da2bf57037",
+             "$argon2id$v=19$m=256,t=2,p=2$c29tZXNhbHQ"
+             "$bQk8UB/VmZZF4Oo79iDXuL5/0ttZwg2f/5U52iv1cDc"),
+    hashtest(version, 1, 16, 1, "password", "somesalt",
+             "f6a5adc1ba723dddef9b5ac1d464e180fcd9dffc9d1cbf76cca2fed795d9ca98",
+             "$argon2id$v=19$m=65536,t=1,p=1$c29tZXNhbHQ"
+             "$9qWtwbpyPd3vm1rB1GThgPzZ3/ydHL92zKL+15XZypg"),
+    hashtest(version, 4, 16, 1, "password", "somesalt",
+             "9025d48e68ef7395cca9079da4c4ec3affb3c8911fe4f86d1a2520856f63172c",
+             "$argon2id$v=19$m=65536,t=4,p=1$c29tZXNhbHQ"
+             "$kCXUjmjvc5XMqQedpMTsOv+zyJEf5PhtGiUghW9jFyw"),
+    hashtest(version, 2, 16, 1, "differentpassword", "somesalt",
+             "0b84d652cf6b0c4beaef0dfe278ba6a80df6696281d7e0d2891b817d8c458fde",
+             "$argon2id$v=19$m=65536,t=2,p=1$c29tZXNhbHQ"
+             "$C4TWUs9rDEvq7w3+J4umqA32aWKB1+DSiRuBfYxFj94"),
+    hashtest(version, 2, 16, 1, "password", "diffsalt",
+             "bdf32b05ccc42eb15d58fd19b1f856b113da1e9a5874fdcc544308565aa8141c",
+             "$argon2id$v=19$m=65536,t=2,p=1$ZGlmZnNhbHQ"
+             "$vfMrBczELrFdWP0ZsfhWsRPaHppYdP3MVEMIVlqoFBw"),
+])
+
+#=============================================================================
+# argon2
+#=============================================================================
+class _base_argon2_test(HandlerCase):
+    handler = hash.argon2
+
+    known_correct_hashes = [
+        #
+        # custom
+        #
+
+        # sample test
+        ("password", '$argon2i$v=19$m=256,t=1,p=1$c29tZXNhbHQ$AJFIsNZTMKTAewB4+ETN1A'),
+
+        # sample w/ all parameters different
+        ("password", '$argon2i$v=19$m=380,t=2,p=2$c29tZXNhbHQ$SrssP8n7m/12VWPM8dvNrw'),
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '$argon2i$v=19$m=512,t=2,p=2$1sV0O4PWLtc12Ypv1f7oGw$'
+                      'z+yqzlKtrq3SaNfXDfIDnQ'),
+        (PASS_TABLE_UTF8, '$argon2i$v=19$m=512,t=2,p=2$1sV0O4PWLtc12Ypv1f7oGw$'
+                          'z+yqzlKtrq3SaNfXDfIDnQ'),
+
+        # ensure trailing null bytes handled correctly
+        ('password\x00', '$argon2i$v=19$m=512,t=2,p=2$c29tZXNhbHQ$Fb5+nPuLzZvtqKRwqUEtUQ'),
+
+        # sample with type D (generated via argon_cffi2.PasswordHasher)
+        ("password", '$argon2d$v=19$m=102400,t=2,p=8$g2RodLh8j8WbSdCp+lUy/A$zzAJqL/HSjm809PYQu6qkA'),
+
+        ]
+
+    known_malformed_hashes = [
+        # unknown hash type
+        "$argon2qq$v=19$t=2,p=4$c29tZXNhbHQAAAAAAAAAAA$QWLzI4TY9HkL2ZTLc8g6SinwdhZewYrzz9zxCo0bkGY",
+
+        # missing 'm' param
+        "$argon2i$v=19$t=2,p=4$c29tZXNhbHQAAAAAAAAAAA$QWLzI4TY9HkL2ZTLc8g6SinwdhZewYrzz9zxCo0bkGY",
+
+        # 't' param > max uint32
+        "$argon2i$v=19$m=65536,t=8589934592,p=4$c29tZXNhbHQAAAAAAAAAAA$QWLzI4TY9HkL2ZTLc8g6SinwdhZewYrzz9zxCo0bkGY",
+
+        # unexpected param
+        "$argon2i$v=19$m=65536,t=2,p=4,q=5$c29tZXNhbHQAAAAAAAAAAA$QWLzI4TY9HkL2ZTLc8g6SinwdhZewYrzz9zxCo0bkGY",
+
+        # wrong param order
+        "$argon2i$v=19$t=2,m=65536,p=4,q=5$c29tZXNhbHQAAAAAAAAAAA$QWLzI4TY9HkL2ZTLc8g6SinwdhZewYrzz9zxCo0bkGY",
+
+        # constraint violation: m < 8 * p
+        "$argon2i$v=19$m=127,t=2,p=16$c29tZXNhbHQ$IMit9qkFULCMA/ViizL57cnTLOa5DiVM9eMwpAvPwr4",
+    ]
+
+    known_parsehash_results = [
+        ('$argon2i$v=19$m=256,t=2,p=3$c29tZXNhbHQ$AJFIsNZTMKTAewB4+ETN1A',
+         dict(type="i", memory_cost=256, rounds=2, parallelism=3, salt=b'somesalt',
+              checksum=b'\x00\x91H\xb0\xd6S0\xa4\xc0{\x00x\xf8D\xcd\xd4')),
+    ]
+
+    def setUpWarnings(self):
+        super(_base_argon2_test, self).setUpWarnings()
+        warnings.filterwarnings("ignore", ".*Using argon2pure backend.*")
+
+    def do_stub_encrypt(self, handler=None, **settings):
+        if self.backend == "argon2_cffi":
+            # overriding default since no way to get stub config from argon2._calc_hash()
+            # (otherwise test_21b_max_rounds blocks trying to do max rounds)
+            handler = (handler or self.handler).using(**settings)
+            self = handler(use_defaults=True)
+            self.checksum = self._stub_checksum
+            assert self.checksum
+            return self.to_string()
+        else:
+            return super(_base_argon2_test, self).do_stub_encrypt(handler, **settings)
+
+    def test_03_legacy_hash_workflow(self):
+        # override base method
+        raise self.skipTest("legacy 1.6 workflow not supported")
+
+    def test_keyid_parameter(self):
+        # NOTE: keyid parameter currently not supported by official argon2 hash parser,
+        #       even though it's mentioned in the format spec.
+        #       we're trying to be consistent w/ this, so hashes w/ keyid should
+        #       always through a NotImplementedError.
+        self.assertRaises(NotImplementedError, self.handler.verify, 'password',
+                          "$argon2i$v=19$m=65536,t=2,p=4,keyid=ABCD$c29tZXNhbHQ$"
+                          "IMit9qkFULCMA/ViizL57cnTLOa5DiVM9eMwpAvPwr4")
+
+    def test_data_parameter(self):
+        # NOTE: argon2 c library doesn't support passing in a data parameter to argon2_hash();
+        #       but argon2_verify() appears to parse that info... but then discards it (!?).
+        #       not sure what proper behavior is, filed issue -- https://github.com/P-H-C/phc-winner-argon2/issues/143
+        #       For now, replicating behavior we have for the two backends, to detect when things change.
+        handler = self.handler
+
+        # ref hash of 'password' when 'data' is correctly passed into argon2()
+        sample1 = '$argon2i$v=19$m=512,t=2,p=2,data=c29tZWRhdGE$c29tZXNhbHQ$KgHyCesFyyjkVkihZ5VNFw'
+
+        # ref hash of 'password' when 'data' is silently discarded (same digest as w/o data)
+        sample2 = '$argon2i$v=19$m=512,t=2,p=2,data=c29tZWRhdGE$c29tZXNhbHQ$uEeXt1dxN1iFKGhklseW4w'
+
+        # hash of 'password' w/o the data field
+        sample3 = '$argon2i$v=19$m=512,t=2,p=2$c29tZXNhbHQ$uEeXt1dxN1iFKGhklseW4w'
+
+        #
+        # test sample 1
+        #
+
+        if self.backend == "argon2_cffi":
+            # argon2_cffi v16.1 would incorrectly return False here.
+            # but v16.2 patches so it throws error on data parameter.
+            # our code should detect that, and adapt it into a NotImplementedError
+            self.assertRaises(NotImplementedError, handler.verify, "password", sample1)
+
+            # incorrectly returns sample3, dropping data parameter
+            self.assertEqual(handler.genhash("password", sample1), sample3)
+
+        else:
+            assert self.backend == "argon2pure"
+            # should parse and verify
+            self.assertTrue(handler.verify("password", sample1))
+
+            # should preserve sample1
+            self.assertEqual(handler.genhash("password", sample1), sample1)
+
+        #
+        # test sample 2
+        #
+
+        if self.backend == "argon2_cffi":
+            # argon2_cffi v16.1 would incorrectly return True here.
+            # but v16.2 patches so it throws error on data parameter.
+            # our code should detect that, and adapt it into a NotImplementedError
+            self.assertRaises(NotImplementedError, handler.verify,"password", sample2)
+
+            # incorrectly returns sample3, dropping data parameter
+            self.assertEqual(handler.genhash("password", sample1), sample3)
+
+        else:
+            assert self.backend == "argon2pure"
+            # should parse, but fail to verify
+            self.assertFalse(self.handler.verify("password", sample2))
+
+            # should return sample1 (corrected digest)
+            self.assertEqual(handler.genhash("password", sample2), sample1)
+
+    def test_keyid_and_data_parameters(self):
+        # test combination of the two, just in case
+        self.assertRaises(NotImplementedError, self.handler.verify, 'stub',
+                          "$argon2i$v=19$m=65536,t=2,p=4,keyid=ABCD,data=EFGH$c29tZXNhbHQ$"
+                          "IMit9qkFULCMA/ViizL57cnTLOa5DiVM9eMwpAvPwr4")
+
+    def test_type_kwd(self):
+        cls = self.handler
+        
+        # XXX: this mirrors test_30_HasManyIdents();
+        #      maybe switch argon2 class to use that mixin instead of "type" kwd?
+        
+        # check settings
+        self.assertTrue("type" in cls.setting_kwds)
+        
+        # check supported type_values
+        for value in cls.type_values:
+            self.assertIsInstance(value, unicode)
+        self.assertTrue("i" in cls.type_values)
+        self.assertTrue("d" in cls.type_values)
+        
+        # check default
+        self.assertTrue(cls.type in cls.type_values)
+        
+        # check constructor validates ident correctly.
+        handler = cls
+        hash = self.get_sample_hash()[1]
+        kwds = handler.parsehash(hash)
+        del kwds['type']
+        
+        # ... accepts good type
+        handler(type=cls.type, **kwds)
+
+        # XXX: this is policy "ident" uses, maybe switch to it?
+        # # ... requires type w/o defaults
+        # self.assertRaises(TypeError, handler, **kwds)
+        handler(**kwds)
+
+        # ... supplies default type
+        handler(use_defaults=True, **kwds)
+
+        # ... rejects bad type
+        self.assertRaises(ValueError, handler, type='xXx', **kwds)
+        
+    def test_type_using(self):
+        handler = self.handler
+
+        # XXX: this mirrors test_has_many_idents_using();
+        #      maybe switch argon2 class to use that mixin instead of "type" kwd?
+        
+        orig_type = handler.type
+        for alt_type in handler.type_values:
+            if alt_type != orig_type:
+                break
+        else:
+            raise AssertionError("expected to find alternate type: default=%r values=%r" %
+                                 (orig_type, handler.type_values))
+        
+        def effective_type(cls):
+            return cls(use_defaults=True).type
+
+        # keep default if nothing else specified
+        subcls = handler.using()
+        self.assertEqual(subcls.type, orig_type)
+
+        # accepts alt type
+        subcls = handler.using(type=alt_type)
+        self.assertEqual(subcls.type, alt_type)
+        self.assertEqual(handler.type, orig_type)
+
+        # check subcls actually *generates* default type,
+        # and that we didn't affect orig handler
+        self.assertEqual(effective_type(subcls), alt_type)
+        self.assertEqual(effective_type(handler), orig_type)
+
+        # rejects bad type
+        self.assertRaises(ValueError, handler.using, type='xXx')
+
+        # honor 'type' alias
+        subcls = handler.using(type=alt_type)
+        self.assertEqual(subcls.type, alt_type)
+        self.assertEqual(handler.type, orig_type)
+
+        # check type aliases are being honored
+        self.assertEqual(effective_type(handler.using(type="I")), "i")
+
+    def test_needs_update_w_type(self):
+        handler = self.handler
+
+        hash = handler.hash("stub")
+        self.assertFalse(handler.needs_update(hash))
+
+        hash2 = re.sub(r"\$argon2\w+\$", "$argon2d$", hash)
+        self.assertTrue(handler.needs_update(hash2))
+
+    def test_needs_update_w_version(self):
+        handler = self.handler.using(memory_cost=65536, time_cost=2, parallelism=4,
+                                     digest_size=32)
+        hash = ("$argon2i$m=65536,t=2,p=4$c29tZXNhbHQAAAAAAAAAAA$"
+                "QWLzI4TY9HkL2ZTLc8g6SinwdhZewYrzz9zxCo0bkGY")
+        if handler.max_version == 0x10:
+            self.assertFalse(handler.needs_update(hash))
+        else:
+            self.assertTrue(handler.needs_update(hash))
+
+    def test_argon_byte_encoding(self):
+        """verify we're using right base64 encoding for argon2"""
+        handler = self.handler
+        if handler.version != 0x13:
+            # TODO: make this fatal, and add refs for other version.
+            raise self.skipTest("handler uses wrong version for sample hashes")
+
+        # 8 byte salt
+        salt = b'somesalt'
+        temp = handler.using(memory_cost=256, time_cost=2, parallelism=2, salt=salt,
+                             checksum_size=32, type="i")
+        hash = temp.hash("password")
+        self.assertEqual(hash, "$argon2i$v=19$m=256,t=2,p=2"
+                               "$c29tZXNhbHQ"
+                               "$T/XOJ2mh1/TIpJHfCdQan76Q5esCFVoT5MAeIM1Oq2E")
+
+        # 16 byte salt
+        salt = b'somesalt\x00\x00\x00\x00\x00\x00\x00\x00'
+        temp = handler.using(memory_cost=256, time_cost=2, parallelism=2, salt=salt,
+                             checksum_size=32, type="i")
+        hash = temp.hash("password")
+        self.assertEqual(hash, "$argon2i$v=19$m=256,t=2,p=2"
+                               "$c29tZXNhbHQAAAAAAAAAAA"
+                               "$rqnbEp1/jFDUEKZZmw+z14amDsFqMDC53dIe57ZHD38")
+
+    class FuzzHashGenerator(HandlerCase.FuzzHashGenerator):
+
+        settings_map = HandlerCase.FuzzHashGenerator.settings_map.copy()
+        settings_map.update(memory_cost="random_memory_cost", type="random_type")
+
+        def random_type(self):
+            return self.rng.choice(self.handler.type_values)
+
+        def random_memory_cost(self):
+            if self.test.backend == "argon2pure":
+                return self.randintgauss(128, 384, 256, 128)
+            else:
+                return self.randintgauss(128, 32767, 16384, 4096)
+
+        # TODO: fuzz parallelism, digest_size
+
+#-----------------------------------------
+# test suites for specific backends
+#-----------------------------------------
+
+class argon2_argon2_cffi_test(_base_argon2_test.create_backend_case("argon2_cffi")):
+
+    # add some more test vectors that take too long under argon2pure
+    known_correct_hashes = _base_argon2_test.known_correct_hashes + [
+        #
+        # sample hashes from argon2 cffi package's unittests,
+        # which in turn were generated by official argon2 cmdline tool.
+        #
+
+        # v1.2, type I, w/o a version tag
+        ('password', "$argon2i$m=65536,t=2,p=4$c29tZXNhbHQAAAAAAAAAAA$"
+                     "QWLzI4TY9HkL2ZTLc8g6SinwdhZewYrzz9zxCo0bkGY"),
+
+        # v1.3, type I
+        ('password', "$argon2i$v=19$m=65536,t=2,p=4$c29tZXNhbHQ$"
+                     "IMit9qkFULCMA/ViizL57cnTLOa5DiVM9eMwpAvPwr4"),
+
+        # v1.3, type D
+        ('password', "$argon2d$v=19$m=65536,t=2,p=4$c29tZXNhbHQ$"
+                     "cZn5d+rFh+ZfuRhm2iGUGgcrW5YLeM6q7L3vBsdmFA0"),
+
+        # v1.3, type ID
+        ('password', "$argon2id$v=19$m=65536,t=2,p=4$c29tZXNhbHQ$"
+                     "GpZ3sK/oH9p7VIiV56G/64Zo/8GaUw434IimaPqxwCo"),
+
+        #
+        # custom
+        #
+
+        # ensure trailing null bytes handled correctly
+        ('password\x00', "$argon2i$v=19$m=65536,t=2,p=4$c29tZXNhbHQ$"
+                         "Vpzuc0v0SrP88LcVvmg+z5RoOYpMDKH/lt6O+CZabIQ"),
+
+        ]
+
+    # add reference hashes from argon2 clib tests
+    known_correct_hashes.extend(
+        (info['secret'], info['hash']) for info in reference_data
+        if info['logM'] <= (18 if TEST_MODE("full") else 16)
+    )
+
+class argon2_argon2pure_test(_base_argon2_test.create_backend_case("argon2pure")):
+
+    # XXX: setting max_threads at 1 to prevent argon2pure from using multiprocessing,
+    #      which causes big problems when testing under pypy. 
+    #      would like a "pure_use_threads" option instead, to make it use multiprocessing.dummy instead.
+    handler = hash.argon2.using(memory_cost=32, parallelism=2)
+
+    # don't use multiprocessing for unittests, makes it a lot harder to ctrl-c
+    # XXX: make this controlled by env var?
+    handler.pure_use_threads = True
+
+    # add reference hashes from argon2 clib tests
+    known_correct_hashes = _base_argon2_test.known_correct_hashes[:]
+
+    known_correct_hashes.extend(
+        (info['secret'], info['hash']) for info in reference_data
+        if info['logM'] < 16
+    )
+
+    class FuzzHashGenerator(_base_argon2_test.FuzzHashGenerator):
+
+        def random_rounds(self):
+            # decrease default rounds for fuzz testing to speed up volume.
+            return self.randintgauss(1, 3, 2, 1)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_bcrypt.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_bcrypt.py
new file mode 100644
index 0000000..64fc8bf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_bcrypt.py
@@ -0,0 +1,688 @@
+"""passlib.tests.test_handlers - tests for passlib hash algorithms"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+import logging; log = logging.getLogger(__name__)
+import os
+import warnings
+# site
+# pkg
+from passlib import hash
+from passlib.handlers.bcrypt import IDENT_2, IDENT_2X
+from passlib.utils import repeat_string, to_bytes, is_safe_crypt_input
+from passlib.utils.compat import irange, PY3
+from passlib.tests.utils import HandlerCase, TEST_MODE
+from passlib.tests.test_handlers import UPASS_TABLE
+# module
+
+#=============================================================================
+# bcrypt
+#=============================================================================
+class _bcrypt_test(HandlerCase):
+    """base for BCrypt test cases"""
+    handler = hash.bcrypt
+    reduce_default_rounds = True
+    fuzz_salts_need_bcrypt_repair = True
+
+    known_correct_hashes = [
+        #
+        # from JTR 1.7.9
+        #
+        ('U*U*U*U*', '$2a$05$c92SVSfjeiCD6F2nAD6y0uBpJDjdRkt0EgeC4/31Rf2LUZbDRDE.O'),
+        ('U*U***U', '$2a$05$WY62Xk2TXZ7EvVDQ5fmjNu7b0GEzSzUXUh2cllxJwhtOeMtWV3Ujq'),
+        ('U*U***U*', '$2a$05$Fa0iKV3E2SYVUlMknirWU.CFYGvJ67UwVKI1E2FP6XeLiZGcH3MJi'),
+        ('*U*U*U*U', '$2a$05$.WRrXibc1zPgIdRXYfv.4uu6TD1KWf0VnHzq/0imhUhuxSxCyeBs2'),
+        ('', '$2a$05$Otz9agnajgrAe0.kFVF9V.tzaStZ2s1s4ZWi/LY4sw2k/MTVFj/IO'),
+
+        #
+        # test vectors from http://www.openwall.com/crypt v1.2
+        # note that this omits any hashes that depend on crypt_blowfish's
+        # various CVE-2011-2483 workarounds (hash 2a and \xff\xff in password,
+        # and any 2x hashes); and only contain hashes which are correct
+        # under both crypt_blowfish 1.2 AND OpenBSD.
+        #
+        ('U*U', '$2a$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW'),
+        ('U*U*', '$2a$05$CCCCCCCCCCCCCCCCCCCCC.VGOzA784oUp/Z0DY336zx7pLYAy0lwK'),
+        ('U*U*U', '$2a$05$XXXXXXXXXXXXXXXXXXXXXOAcXxm9kjPGEMsLznoKqmqw7tc8WCx4a'),
+        ('', '$2a$05$CCCCCCCCCCCCCCCCCCCCC.7uG0VCzI2bS7j6ymqJi9CdcdxiRTWNy'),
+        ('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+         '0123456789chars after 72 are ignored',
+                '$2a$05$abcdefghijklmnopqrstuu5s2v8.iXieOjg/.AySBTTZIIVFJeBui'),
+        (b'\xa3',
+                '$2a$05$/OK.fbVrR/bpIqNJ5ianF.Sa7shbm4.OzKpvFnX1pQLmQW96oUlCq'),
+        (b'\xff\xa3345',
+            '$2a$05$/OK.fbVrR/bpIqNJ5ianF.nRht2l/HRhr6zmCp9vYUvvsqynflf9e'),
+        (b'\xa3ab',
+                '$2a$05$/OK.fbVrR/bpIqNJ5ianF.6IflQkJytoRVc1yuaNtHfiuq.FRlSIS'),
+        (b'\xaa'*72 + b'chars after 72 are ignored as usual',
+                '$2a$05$/OK.fbVrR/bpIqNJ5ianF.swQOIzjOiJ9GHEPuhEkvqrUyvWhEMx6'),
+        (b'\xaa\x55'*36,
+                '$2a$05$/OK.fbVrR/bpIqNJ5ianF.R9xrDjiycxMbQE2bp.vgqlYpW5wx2yy'),
+        (b'\x55\xaa\xff'*24,
+                '$2a$05$/OK.fbVrR/bpIqNJ5ianF.9tQZzcJfm3uj2NvJ/n5xkhpqLrMpWCe'),
+
+        # keeping one of their 2y tests, because we are supporting that.
+        (b'\xa3',
+                '$2y$05$/OK.fbVrR/bpIqNJ5ianF.Sa7shbm4.OzKpvFnX1pQLmQW96oUlCq'),
+
+        #
+        # 8bit bug (fixed in 2y/2b)
+        #
+
+        # NOTE: see assert_lacks_8bit_bug() for origins of this test vector.
+        (b"\xd1\x91", "$2y$05$6bNw2HLQYeqHYyBfLMsv/OUcZd0LKP39b87nBw3.S2tVZSqiQX6eu"),
+
+        #
+        # bsd wraparound bug (fixed in 2b)
+        #
+
+        # NOTE: if backend is vulnerable, password will hash the same as '0'*72
+        #       ("$2a$04$R1lJ2gkNaoPGdafE.H.16.nVyh2niHsGJhayOHLMiXlI45o8/DU.6"),
+        #       rather than same as ("0123456789"*8)[:72]
+        # 255 should be sufficient, but checking
+        (("0123456789"*26)[:254], '$2a$04$R1lJ2gkNaoPGdafE.H.16.1MKHPvmKwryeulRe225LKProWYwt9Oi'),
+        (("0123456789"*26)[:255], '$2a$04$R1lJ2gkNaoPGdafE.H.16.1MKHPvmKwryeulRe225LKProWYwt9Oi'),
+        (("0123456789"*26)[:256], '$2a$04$R1lJ2gkNaoPGdafE.H.16.1MKHPvmKwryeulRe225LKProWYwt9Oi'),
+        (("0123456789"*26)[:257], '$2a$04$R1lJ2gkNaoPGdafE.H.16.1MKHPvmKwryeulRe225LKProWYwt9Oi'),
+
+
+        #
+        # from py-bcrypt tests
+        #
+        ('', '$2a$06$DCq7YPn5Rq63x1Lad4cll.TV4S6ytwfsfvkgY8jIucDrjc8deX1s.'),
+        ('a', '$2a$10$k87L/MF28Q673VKh8/cPi.SUl7MU/rWuSiIDDFayrKk/1tBsSQu4u'),
+        ('abc', '$2a$10$WvvTPHKwdBJ3uk0Z37EMR.hLA2W6N9AEBhEgrAOljy2Ae5MtaSIUi'),
+        ('abcdefghijklmnopqrstuvwxyz',
+                '$2a$10$fVH8e28OQRj9tqiDXs1e1uxpsjN0c7II7YPKXua2NAKYvM6iQk7dq'),
+        ('~!@#$%^&*()      ~!@#$%^&*()PNBFRD',
+                '$2a$10$LgfYWkbzEvQ4JakH7rOvHe0y8pHKF9OaFgwUZ2q7W2FFZmZzJYlfS'),
+
+        #
+        # custom test vectors
+        #
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE,
+                '$2a$05$Z17AXnnlpzddNUvnC6cZNOSwMA/8oNiKnHTHTwLlBijfucQQlHjaG'),
+
+        # ensure 2b support
+        (UPASS_TABLE,
+                '$2b$05$Z17AXnnlpzddNUvnC6cZNOSwMA/8oNiKnHTHTwLlBijfucQQlHjaG'),
+
+        ]
+
+    if TEST_MODE("full"):
+        #
+        # add some extra tests related to 2/2a
+        #
+        CONFIG_2 = '$2$05$' + '.'*22
+        CONFIG_A = '$2a$05$' + '.'*22
+        known_correct_hashes.extend([
+            ("", CONFIG_2 + 'J2ihDv8vVf7QZ9BsaRrKyqs2tkn55Yq'),
+            ("", CONFIG_A + 'J2ihDv8vVf7QZ9BsaRrKyqs2tkn55Yq'),
+            ("abc", CONFIG_2 + 'XuQjdH.wPVNUZ/bOfstdW/FqB8QSjte'),
+            ("abc", CONFIG_A + 'ev6gDwpVye3oMCUpLY85aTpfBNHD0Ga'),
+            ("abc"*23, CONFIG_2 + 'XuQjdH.wPVNUZ/bOfstdW/FqB8QSjte'),
+            ("abc"*23, CONFIG_A + '2kIdfSj/4/R/Q6n847VTvc68BXiRYZC'),
+            ("abc"*24, CONFIG_2 + 'XuQjdH.wPVNUZ/bOfstdW/FqB8QSjte'),
+            ("abc"*24, CONFIG_A + 'XuQjdH.wPVNUZ/bOfstdW/FqB8QSjte'),
+            ("abc"*24+'x', CONFIG_2 + 'XuQjdH.wPVNUZ/bOfstdW/FqB8QSjte'),
+            ("abc"*24+'x', CONFIG_A + 'XuQjdH.wPVNUZ/bOfstdW/FqB8QSjte'),
+        ])
+
+    known_correct_configs = [
+        ('$2a$04$uM6csdM8R9SXTex/gbTaye', UPASS_TABLE,
+         '$2a$04$uM6csdM8R9SXTex/gbTayezuvzFEufYGd2uB6of7qScLjQ4GwcD4G'),
+    ]
+
+    known_unidentified_hashes = [
+        # invalid minor version
+        "$2f$12$EXRkfkdmXnagzds2SSitu.MW9.gAVqa9eLS1//RYtYCmB1eLHg.9q",
+        "$2`$12$EXRkfkdmXnagzds2SSitu.MW9.gAVqa9eLS1//RYtYCmB1eLHg.9q",
+    ]
+
+    known_malformed_hashes = [
+        # bad char in otherwise correct hash
+        #                 \/
+        "$2a$12$EXRkfkdmXn!gzds2SSitu.MW9.gAVqa9eLS1//RYtYCmB1eLHg.9q",
+
+        # unsupported (but recognized) minor version
+        "$2x$12$EXRkfkdmXnagzds2SSitu.MW9.gAVqa9eLS1//RYtYCmB1eLHg.9q",
+
+        # rounds not zero-padded (py-bcrypt rejects this, therefore so do we)
+        '$2a$6$DCq7YPn5Rq63x1Lad4cll.TV4S6ytwfsfvkgY8jIucDrjc8deX1s.'
+
+        # NOTE: salts with padding bits set are technically malformed,
+        #      but we can reliably correct & issue a warning for that.
+        ]
+
+    platform_crypt_support = [
+        ("freedbsd|openbsd|netbsd", True),
+        ("darwin", False),
+        ("linux", None),  # may be present via addon, e.g. debian's libpam-unix2
+        ("solaris", None),  # depends on system policy
+    ]
+
+    #===================================================================
+    # override some methods
+    #===================================================================
+    def setUp(self):
+        # ensure builtin is enabled for duration of test.
+        if TEST_MODE("full") and self.backend == "builtin":
+            key = "PASSLIB_BUILTIN_BCRYPT"
+            orig = os.environ.get(key)
+            if orig:
+                self.addCleanup(os.environ.__setitem__, key, orig)
+            else:
+                self.addCleanup(os.environ.__delitem__, key)
+            os.environ[key] = "true"
+
+        super(_bcrypt_test, self).setUp()
+
+        # silence this warning, will come up a bunch during testing of old 2a hashes.
+        warnings.filterwarnings("ignore", ".*backend is vulnerable to the bsd wraparound bug.*")
+
+    def populate_settings(self, kwds):
+        # builtin is still just way too slow.
+        if self.backend == "builtin":
+            kwds.setdefault("rounds", 4)
+        super(_bcrypt_test, self).populate_settings(kwds)
+
+    #===================================================================
+    # fuzz testing
+    #===================================================================
+    def crypt_supports_variant(self, hash):
+        """check if OS crypt is expected to support given ident"""
+        from passlib.handlers.bcrypt import bcrypt, IDENT_2X, IDENT_2Y
+        from passlib.utils import safe_crypt
+        ident = bcrypt.from_string(hash)
+        return (safe_crypt("test", ident + "04$5BJqKfqMQvV7nS.yUguNcu") or "").startswith(ident)
+
+    fuzz_verifiers = HandlerCase.fuzz_verifiers + (
+        "fuzz_verifier_bcrypt",
+        "fuzz_verifier_pybcrypt",
+        "fuzz_verifier_bcryptor",
+    )
+
+    def fuzz_verifier_bcrypt(self):
+        # test against bcrypt, if available
+        from passlib.handlers.bcrypt import IDENT_2, IDENT_2A, IDENT_2B, IDENT_2X, IDENT_2Y, _detect_pybcrypt
+        from passlib.utils import to_native_str, to_bytes
+        try:
+            import bcrypt
+        except ImportError:
+            return
+        if _detect_pybcrypt():
+            return
+        def check_bcrypt(secret, hash):
+            """bcrypt"""
+            secret = to_bytes(secret, self.FuzzHashGenerator.password_encoding)
+            if hash.startswith(IDENT_2B):
+                # bcrypt <1.1 lacks 2B support
+                hash = IDENT_2A + hash[4:]
+            elif hash.startswith(IDENT_2):
+                # bcrypt doesn't support $2$ hashes; but we can fake it
+                # using the $2a$ algorithm, by repeating the password until
+                # it's 72 chars in length.
+                hash = IDENT_2A + hash[3:]
+                if secret:
+                    secret = repeat_string(secret, 72)
+            elif hash.startswith(IDENT_2Y) and bcrypt.__version__ == "3.0.0":
+                hash = IDENT_2B + hash[4:]
+            hash = to_bytes(hash)
+            try:
+                return bcrypt.hashpw(secret, hash) == hash
+            except ValueError:
+                raise ValueError("bcrypt rejected hash: %r (secret=%r)" % (hash, secret))
+        return check_bcrypt
+
+    def fuzz_verifier_pybcrypt(self):
+        # test against py-bcrypt, if available
+        from passlib.handlers.bcrypt import (
+            IDENT_2, IDENT_2A, IDENT_2B, IDENT_2X, IDENT_2Y,
+            _PyBcryptBackend,
+        )
+        from passlib.utils import to_native_str
+
+        loaded = _PyBcryptBackend._load_backend_mixin("pybcrypt", False)
+        if not loaded:
+            return
+
+        from passlib.handlers.bcrypt import _pybcrypt as bcrypt_mod
+
+        lock = _PyBcryptBackend._calc_lock # reuse threadlock workaround for pybcrypt 0.2
+
+        def check_pybcrypt(secret, hash):
+            """pybcrypt"""
+            secret = to_native_str(secret, self.FuzzHashGenerator.password_encoding)
+            if len(secret) > 200:  # vulnerable to wraparound bug
+                secret = secret[:200]
+            if hash.startswith((IDENT_2B, IDENT_2Y)):
+                hash = IDENT_2A + hash[4:]
+            try:
+                if lock:
+                    with lock:
+                        return bcrypt_mod.hashpw(secret, hash) == hash
+                else:
+                    return bcrypt_mod.hashpw(secret, hash) == hash
+            except ValueError:
+                raise ValueError("py-bcrypt rejected hash: %r" % (hash,))
+        return check_pybcrypt
+
+    def fuzz_verifier_bcryptor(self):
+        # test against bcryptor if available
+        from passlib.handlers.bcrypt import IDENT_2, IDENT_2A, IDENT_2Y, IDENT_2B
+        from passlib.utils import to_native_str
+        try:
+            from bcryptor.engine import Engine
+        except ImportError:
+            return
+        def check_bcryptor(secret, hash):
+            """bcryptor"""
+            secret = to_native_str(secret, self.FuzzHashGenerator.password_encoding)
+            if hash.startswith((IDENT_2B, IDENT_2Y)):
+                hash = IDENT_2A + hash[4:]
+            elif hash.startswith(IDENT_2):
+                # bcryptor doesn't support $2$ hashes; but we can fake it
+                # using the $2a$ algorithm, by repeating the password until
+                # it's 72 chars in length.
+                hash = IDENT_2A + hash[3:]
+                if secret:
+                    secret = repeat_string(secret, 72)
+            return Engine(False).hash_key(secret, hash) == hash
+        return check_bcryptor
+
+    class FuzzHashGenerator(HandlerCase.FuzzHashGenerator):
+
+        def generate(self):
+            opts = super(_bcrypt_test.FuzzHashGenerator, self).generate()
+
+            secret = opts['secret']
+            other = opts['other']
+            settings = opts['settings']
+            ident = settings.get('ident')
+
+            if ident == IDENT_2X:
+                # 2x is just recognized, not supported. don't test with it.
+                del settings['ident']
+
+            elif ident == IDENT_2 and other and repeat_string(to_bytes(other), len(to_bytes(secret))) == to_bytes(secret):
+                # avoid false failure due to flaw in 0-revision bcrypt:
+                # repeated strings like 'abc' and 'abcabc' hash identically.
+                opts['secret'], opts['other'] = self.random_password_pair()
+
+            return opts
+
+        def random_rounds(self):
+            # decrease default rounds for fuzz testing to speed up volume.
+            return self.randintgauss(5, 8, 6, 1)
+
+    #===================================================================
+    # custom tests
+    #===================================================================
+    known_incorrect_padding = [
+        # password, bad hash, good hash
+
+        # 2 bits of salt padding set
+#        ("loppux",                  # \/
+#         "$2a$12$oaQbBqq8JnSM1NHRPQGXORm4GCUMqp7meTnkft4zgSnrbhoKdDV0C",
+#         "$2a$12$oaQbBqq8JnSM1NHRPQGXOOm4GCUMqp7meTnkft4zgSnrbhoKdDV0C"),
+        ("test",                    # \/
+         '$2a$04$oaQbBqq8JnSM1NHRPQGXORY4Vw3bdHKLIXTecPDRAcJ98cz1ilveO',
+         '$2a$04$oaQbBqq8JnSM1NHRPQGXOOY4Vw3bdHKLIXTecPDRAcJ98cz1ilveO'),
+
+        # all 4 bits of salt padding set
+#        ("Passlib11",               # \/
+#         "$2a$12$M8mKpW9a2vZ7PYhq/8eJVcUtKxpo6j0zAezu0G/HAMYgMkhPu4fLK",
+#         "$2a$12$M8mKpW9a2vZ7PYhq/8eJVOUtKxpo6j0zAezu0G/HAMYgMkhPu4fLK"),
+        ("test",                    # \/
+         "$2a$04$yjDgE74RJkeqC0/1NheSScrvKeu9IbKDpcQf/Ox3qsrRS/Kw42qIS",
+         "$2a$04$yjDgE74RJkeqC0/1NheSSOrvKeu9IbKDpcQf/Ox3qsrRS/Kw42qIS"),
+
+        # bad checksum padding
+        ("test",                                                   # \/
+         "$2a$04$yjDgE74RJkeqC0/1NheSSOrvKeu9IbKDpcQf/Ox3qsrRS/Kw42qIV",
+         "$2a$04$yjDgE74RJkeqC0/1NheSSOrvKeu9IbKDpcQf/Ox3qsrRS/Kw42qIS"),
+    ]
+
+    def test_90_bcrypt_padding(self):
+        """test passlib correctly handles bcrypt padding bits"""
+        self.require_TEST_MODE("full")
+        #
+        # prevents reccurrence of issue 25 (https://code.google.com/p/passlib/issues/detail?id=25)
+        # were some unused bits were incorrectly set in bcrypt salt strings.
+        # (fixed since 1.5.3)
+        #
+        bcrypt = self.handler
+        corr_desc = ".*incorrectly set padding bits"
+
+        #
+        # test hash() / genconfig() don't generate invalid salts anymore
+        #
+        def check_padding(hash):
+            assert hash.startswith(("$2a$", "$2b$")) and len(hash) >= 28, \
+                "unexpectedly malformed hash: %r" % (hash,)
+            self.assertTrue(hash[28] in '.Oeu',
+                            "unused bits incorrectly set in hash: %r" % (hash,))
+        for i in irange(6):
+            check_padding(bcrypt.genconfig())
+        for i in irange(3):
+            check_padding(bcrypt.using(rounds=bcrypt.min_rounds).hash("bob"))
+
+        #
+        # test genconfig() corrects invalid salts & issues warning.
+        #
+        with self.assertWarningList(["salt too large", corr_desc]):
+            hash = bcrypt.genconfig(salt="."*21 + "A.", rounds=5, relaxed=True)
+        self.assertEqual(hash, "$2b$05$" + "." * (22 + 31))
+
+        #
+        # test public methods against good & bad hashes
+        #
+        samples = self.known_incorrect_padding
+        for pwd, bad, good in samples:
+
+            # make sure genhash() corrects bad configs, leaves good unchanged
+            with self.assertWarningList([corr_desc]):
+                self.assertEqual(bcrypt.genhash(pwd, bad), good)
+            with self.assertWarningList([]):
+                self.assertEqual(bcrypt.genhash(pwd, good), good)
+
+            # make sure verify() works correctly with good & bad hashes
+            with self.assertWarningList([corr_desc]):
+                self.assertTrue(bcrypt.verify(pwd, bad))
+            with self.assertWarningList([]):
+                self.assertTrue(bcrypt.verify(pwd, good))
+
+            # make sure normhash() corrects bad hashes, leaves good unchanged
+            with self.assertWarningList([corr_desc]):
+                self.assertEqual(bcrypt.normhash(bad), good)
+            with self.assertWarningList([]):
+                self.assertEqual(bcrypt.normhash(good), good)
+
+        # make sure normhash() leaves non-bcrypt hashes alone
+        self.assertEqual(bcrypt.normhash("$md5$abc"), "$md5$abc")
+
+    def test_needs_update_w_padding(self):
+        """needs_update corrects bcrypt padding"""
+        # NOTE: see padding test above for details about issue this detects
+        bcrypt = self.handler.using(rounds=4)
+
+        # PASS1 = "test"
+        # bad contains invalid 'c' char at end of salt:
+        #                                    \/
+        BAD1 =  "$2a$04$yjDgE74RJkeqC0/1NheSScrvKeu9IbKDpcQf/Ox3qsrRS/Kw42qIS"
+        GOOD1 = "$2a$04$yjDgE74RJkeqC0/1NheSSOrvKeu9IbKDpcQf/Ox3qsrRS/Kw42qIS"
+
+        self.assertTrue(bcrypt.needs_update(BAD1))
+        self.assertFalse(bcrypt.needs_update(GOOD1))
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+# create test cases for specific backends
+bcrypt_bcrypt_test = _bcrypt_test.create_backend_case("bcrypt")
+bcrypt_pybcrypt_test = _bcrypt_test.create_backend_case("pybcrypt")
+bcrypt_bcryptor_test = _bcrypt_test.create_backend_case("bcryptor")
+
+class bcrypt_os_crypt_test(_bcrypt_test.create_backend_case("os_crypt")):
+
+    # os crypt doesn't support non-utf8 secret bytes
+    known_correct_hashes = [row for row in _bcrypt_test.known_correct_hashes
+                            if is_safe_crypt_input(row[0])]
+
+    # os crypt backend doesn't currently implement a per-call fallback if it fails
+    has_os_crypt_fallback = False
+
+bcrypt_builtin_test = _bcrypt_test.create_backend_case("builtin")
+
+#=============================================================================
+# bcrypt
+#=============================================================================
+class _bcrypt_sha256_test(HandlerCase):
+    "base for BCrypt-SHA256 test cases"
+    handler = hash.bcrypt_sha256
+    reduce_default_rounds = True
+    forbidden_characters = None
+    fuzz_salts_need_bcrypt_repair = True
+
+    known_correct_hashes = [
+        #-------------------------------------------------------------------
+        # custom test vectors for old v1 format
+        #-------------------------------------------------------------------
+
+        # empty
+        ("",
+            '$bcrypt-sha256$2a,5$E/e/2AOhqM5W/KJTFQzLce$F6dYSxOdAEoJZO2eoHUZWZljW/e0TXO'),
+
+        # ascii
+        ("password",
+            '$bcrypt-sha256$2a,5$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu'),
+
+        # unicode / utf8
+        (UPASS_TABLE,
+            '$bcrypt-sha256$2a,5$.US1fQ4TQS.ZTz/uJ5Kyn.$QNdPDOTKKT5/sovNz1iWg26quOU4Pje'),
+        (UPASS_TABLE.encode("utf-8"),
+            '$bcrypt-sha256$2a,5$.US1fQ4TQS.ZTz/uJ5Kyn.$QNdPDOTKKT5/sovNz1iWg26quOU4Pje'),
+
+        # ensure 2b support
+        ("password",
+            '$bcrypt-sha256$2b,5$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu'),
+        (UPASS_TABLE,
+            '$bcrypt-sha256$2b,5$.US1fQ4TQS.ZTz/uJ5Kyn.$QNdPDOTKKT5/sovNz1iWg26quOU4Pje'),
+
+        # test >72 chars is hashed correctly -- under bcrypt these hash the same.
+        # NOTE: test_60_truncate_size() handles this already, this is just for overkill :)
+        (repeat_string("abc123", 72),
+            '$bcrypt-sha256$2b,5$X1g1nh3g0v4h6970O68cxe$r/hyEtqJ0teqPEmfTLoZ83ciAI1Q74.'),
+        (repeat_string("abc123", 72) + "qwr",
+            '$bcrypt-sha256$2b,5$X1g1nh3g0v4h6970O68cxe$021KLEif6epjot5yoxk0m8I0929ohEa'),
+        (repeat_string("abc123", 72) + "xyz",
+            '$bcrypt-sha256$2b,5$X1g1nh3g0v4h6970O68cxe$7.1kgpHduMGEjvM3fX6e/QCvfn6OKja'),
+
+        #-------------------------------------------------------------------
+        # custom test vectors for v2 format
+        # TODO: convert to v2 format
+        #-------------------------------------------------------------------
+
+        # empty
+        ("",
+            '$bcrypt-sha256$v=2,t=2b,r=5$E/e/2AOhqM5W/KJTFQzLce$WFPIZKtDDTriqWwlmRFfHiOTeheAZWe'),
+
+        # ascii
+        ("password",
+            '$bcrypt-sha256$v=2,t=2b,r=5$5Hg1DKFqPE8C2aflZ5vVoe$wOK1VFFtS8IGTrGa7.h5fs0u84qyPbS'),
+
+        # unicode / utf8
+        (UPASS_TABLE,
+            '$bcrypt-sha256$v=2,t=2b,r=5$.US1fQ4TQS.ZTz/uJ5Kyn.$pzzgp40k8reM1CuQb03PvE0IDPQSdV6'),
+        (UPASS_TABLE.encode("utf-8"),
+            '$bcrypt-sha256$v=2,t=2b,r=5$.US1fQ4TQS.ZTz/uJ5Kyn.$pzzgp40k8reM1CuQb03PvE0IDPQSdV6'),
+
+        # test >72 chars is hashed correctly -- under bcrypt these hash the same.
+        # NOTE: test_60_truncate_size() handles this already, this is just for overkill :)
+        (repeat_string("abc123", 72),
+            '$bcrypt-sha256$v=2,t=2b,r=5$X1g1nh3g0v4h6970O68cxe$zu1cloESVFIOsUIo7fCEgkdHaI9SSue'),
+        (repeat_string("abc123", 72) + "qwr",
+            '$bcrypt-sha256$v=2,t=2b,r=5$X1g1nh3g0v4h6970O68cxe$CBF9csfEdW68xv3DwE6xSULXMtqEFP.'),
+        (repeat_string("abc123", 72) + "xyz",
+            '$bcrypt-sha256$v=2,t=2b,r=5$X1g1nh3g0v4h6970O68cxe$zC/1UDUG2ofEXB6Onr2vvyFzfhEOS3S'),
+        ]
+
+    known_correct_configs =[
+        # v1
+        ('$bcrypt-sha256$2a,5$5Hg1DKFqPE8C2aflZ5vVoe',
+         "password", '$bcrypt-sha256$2a,5$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu'),
+        # v2
+        ('$bcrypt-sha256$v=2,t=2b,r=5$5Hg1DKFqPE8C2aflZ5vVoe',
+         "password", '$bcrypt-sha256$v=2,t=2b,r=5$5Hg1DKFqPE8C2aflZ5vVoe$wOK1VFFtS8IGTrGa7.h5fs0u84qyPbS'),
+    ]
+
+    known_malformed_hashes = [
+        #-------------------------------------------------------------------
+        # v1 format
+        #-------------------------------------------------------------------
+
+        # bad char in otherwise correct hash
+        #                           \/
+        '$bcrypt-sha256$2a,5$5Hg1DKF!PE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu',
+
+        # unrecognized bcrypt variant
+        '$bcrypt-sha256$2c,5$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu',
+
+        # unsupported bcrypt variant
+        '$bcrypt-sha256$2x,5$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu',
+
+        # rounds zero-padded
+        '$bcrypt-sha256$2a,05$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu',
+
+        # config string w/ $ added
+        '$bcrypt-sha256$2a,5$5Hg1DKFqPE8C2aflZ5vVoe$',
+
+        #-------------------------------------------------------------------
+        # v2 format
+        #-------------------------------------------------------------------
+
+        # bad char in otherwise correct hash
+        #                                   \/
+        '$bcrypt-sha256$v=2,t=2b,r=5$5Hg1DKF!PE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu',
+
+        # unsupported version (for this format)
+        '$bcrypt-sha256$v=1,t=2b,r=5$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu',
+
+        # unrecognized version
+        '$bcrypt-sha256$v=3,t=2b,r=5$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu',
+
+        # unrecognized bcrypt variant
+        '$bcrypt-sha256$v=2,t=2c,r=5$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu',
+
+        # unsupported bcrypt variant
+        '$bcrypt-sha256$v=2,t=2a,r=5$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu',
+        '$bcrypt-sha256$v=2,t=2x,r=5$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu',
+
+        # rounds zero-padded
+        '$bcrypt-sha256$v=2,t=2b,r=05$5Hg1DKFqPE8C2aflZ5vVoe$12BjNE0p7axMg55.Y/mHsYiVuFBDQyu',
+
+        # config string w/ $ added
+        '$bcrypt-sha256$v=2,t=2b,r=5$5Hg1DKFqPE8C2aflZ5vVoe$',
+    ]
+
+    #===================================================================
+    # override some methods -- cloned from bcrypt
+    #===================================================================
+    def setUp(self):
+        # ensure builtin is enabled for duration of test.
+        if TEST_MODE("full") and self.backend == "builtin":
+            key = "PASSLIB_BUILTIN_BCRYPT"
+            orig = os.environ.get(key)
+            if orig:
+                self.addCleanup(os.environ.__setitem__, key, orig)
+            else:
+                self.addCleanup(os.environ.__delitem__, key)
+            os.environ[key] = "enabled"
+        super(_bcrypt_sha256_test, self).setUp()
+        warnings.filterwarnings("ignore", ".*backend is vulnerable to the bsd wraparound bug.*")
+
+    def populate_settings(self, kwds):
+        # builtin is still just way too slow.
+        if self.backend == "builtin":
+            kwds.setdefault("rounds", 4)
+        super(_bcrypt_sha256_test, self).populate_settings(kwds)
+
+    #===================================================================
+    # override ident tests for now
+    #===================================================================
+
+    def require_many_idents(self):
+        raise self.skipTest("multiple idents not supported")
+
+    def test_30_HasOneIdent(self):
+        # forbidding ident keyword, we only support "2b" for now
+        handler = self.handler
+        handler(use_defaults=True)
+        self.assertRaises(ValueError, handler, ident="$2y$", use_defaults=True)
+
+    #===================================================================
+    # fuzz testing -- cloned from bcrypt
+    #===================================================================
+
+    class FuzzHashGenerator(HandlerCase.FuzzHashGenerator):
+
+        def random_rounds(self):
+            # decrease default rounds for fuzz testing to speed up volume.
+            return self.randintgauss(5, 8, 6, 1)
+
+        def random_ident(self):
+            return "2b"
+
+    #===================================================================
+    # custom tests
+    #===================================================================
+
+    def test_using_version(self):
+        # default to v2
+        handler = self.handler
+        self.assertEqual(handler.version, 2)
+
+        # allow v1 explicitly
+        subcls = handler.using(version=1)
+        self.assertEqual(subcls.version, 1)
+
+        # forbid unknown ver
+        self.assertRaises(ValueError, handler.using, version=999)
+
+        # allow '2a' only for v1
+        subcls = handler.using(version=1, ident="2a")
+        self.assertRaises(ValueError, handler.using, ident="2a")
+
+    def test_calc_digest_v2(self):
+        """
+        test digest calc v2 matches bcrypt()
+        """
+        from passlib.hash import bcrypt
+        from passlib.crypto.digest import compile_hmac
+        from passlib.utils.binary import b64encode
+
+        # manually calc intermediary digest
+        salt = "nyKYxTAvjmy6lMDYMl11Uu"
+        secret = "test"
+        temp_digest = compile_hmac("sha256", salt.encode("ascii"))(secret.encode("ascii"))
+        temp_digest = b64encode(temp_digest).decode("ascii")
+        self.assertEqual(temp_digest, "J5TlyIDm+IcSWmKiDJm+MeICndBkFVPn4kKdJW8f+xY=")
+
+        # manually final hash from intermediary
+        # XXX: genhash() could be useful here
+        bcrypt_digest = bcrypt(ident="2b", salt=salt, rounds=12)._calc_checksum(temp_digest)
+        self.assertEqual(bcrypt_digest, "M0wE0Ov/9LXoQFCe.jRHu3MSHPF54Ta")
+        self.assertTrue(bcrypt.verify(temp_digest, "$2b$12$" + salt + bcrypt_digest))
+
+        # confirm handler outputs same thing.
+        # XXX: genhash() could be useful here
+        result = self.handler(ident="2b", salt=salt, rounds=12)._calc_checksum(secret)
+        self.assertEqual(result, bcrypt_digest)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+# create test cases for specific backends
+bcrypt_sha256_bcrypt_test = _bcrypt_sha256_test.create_backend_case("bcrypt")
+bcrypt_sha256_pybcrypt_test = _bcrypt_sha256_test.create_backend_case("pybcrypt")
+bcrypt_sha256_bcryptor_test = _bcrypt_sha256_test.create_backend_case("bcryptor")
+
+class bcrypt_sha256_os_crypt_test(_bcrypt_sha256_test.create_backend_case("os_crypt")):
+
+    @classmethod
+    def _get_safe_crypt_handler_backend(cls):
+        return bcrypt_os_crypt_test._get_safe_crypt_handler_backend()
+
+    has_os_crypt_fallback = False
+
+bcrypt_sha256_builtin_test = _bcrypt_sha256_test.create_backend_case("builtin")
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_cisco.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_cisco.py
new file mode 100644
index 0000000..ea6594b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_cisco.py
@@ -0,0 +1,457 @@
+"""
+passlib.tests.test_handlers_cisco - tests for Cisco-specific algorithms
+"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import absolute_import, division, print_function
+# core
+import logging
+log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib import hash, exc
+from passlib.utils.compat import u
+from .utils import UserHandlerMixin, HandlerCase, repeat_string
+from .test_handlers import UPASS_TABLE
+# module
+__all__ = [
+    "cisco_pix_test",
+    "cisco_asa_test",
+    "cisco_type7_test",
+]
+#=============================================================================
+# shared code for cisco PIX & ASA
+#=============================================================================
+
+class _PixAsaSharedTest(UserHandlerMixin, HandlerCase):
+    """
+    class w/ shared info for PIX & ASA tests.
+    """
+    __unittest_skip = True   # for TestCase
+    requires_user = False  # for UserHandlerMixin
+
+    #: shared list of hashes which should be identical under pix & asa7
+    #: (i.e. combined secret + user < 17 bytes)
+    pix_asa_shared_hashes = [
+        #
+        # http://www.perlmonks.org/index.pl?node_id=797623
+        #
+        (("cisco", ""), "2KFQnbNIdI.2KYOU"),  # confirmed ASA 9.6
+
+        #
+        # http://www.hsc.fr/ressources/breves/pix_crack.html.en
+        #
+        (("hsc", ""), "YtT8/k6Np8F1yz2c"),  # confirmed ASA 9.6
+
+        #
+        # www.freerainbowtables.com/phpBB3/viewtopic.php?f=2&t=1441
+        #
+        (("", ""), "8Ry2YjIyt7RRXU24"),  # confirmed ASA 9.6
+        (("cisco", "john"), "hN7LzeyYjw12FSIU"),
+        (("cisco", "jack"), "7DrfeZ7cyOj/PslD"),
+
+        #
+        # http://comments.gmane.org/gmane.comp.security.openwall.john.user/2529
+        #
+        (("ripper", "alex"), "h3mJrcH0901pqX/m"),
+        (("cisco", "cisco"), "3USUcOPFUiMCO4Jk"),
+        (("cisco", "cisco1"), "3USUcOPFUiMCO4Jk"),
+        (("CscFw-ITC!", "admcom"), "lZt7HSIXw3.QP7.R"),
+        ("cangetin", "TynyB./ftknE77QP"),
+        (("cangetin", "rramsey"), "jgBZqYtsWfGcUKDi"),
+
+        #
+        # http://openwall.info/wiki/john/sample-hashes
+        #
+        (("phonehome", "rharris"), "zyIIMSYjiPm0L7a6"),
+
+        #
+        # http://www.openwall.com/lists/john-users/2010/08/08/3
+        #
+        (("cangetin", ""), "TynyB./ftknE77QP"),
+        (("cangetin", "rramsey"), "jgBZqYtsWfGcUKDi"),
+
+        #
+        # from JTR 1.7.9
+        #
+        ("test1", "TRPEas6f/aa6JSPL"),
+        ("test2", "OMT6mXmAvGyzrCtp"),
+        ("test3", "gTC7RIy1XJzagmLm"),
+        ("test4", "oWC1WRwqlBlbpf/O"),
+        ("password", "NuLKvvWGg.x9HEKO"),
+        ("0123456789abcdef", ".7nfVBEIEu4KbF/1"),
+
+        #
+        # http://www.cisco.com/en/US/docs/security/pix/pix50/configuration/guide/commands.html#wp5472
+        #
+        (("1234567890123456", ""), "feCkwUGktTCAgIbD"),  # canonical source
+        (("watag00s1am", ""), "jMorNbK0514fadBh"),  # canonical source
+
+        #
+        # custom
+        #
+        (("cisco1", "cisco1"), "jmINXNH6p1BxUppp"),
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, 'CaiIvkLMu2TOHXGT'),
+
+        #
+        # passlib reference vectors
+        #
+        # Some of these have been confirmed on various ASA firewalls,
+        # and the exact version is noted next to each hash.
+        # Would like to verify these under more PIX & ASA versions.
+        #
+        # Those without a note are generally an extrapolation,
+        # to ensure the code stays consistent, but for various reasons,
+        # hasn't been verified.
+        #
+        # * One such case is usernames w/ 1 & 2 digits --
+        #   ASA (9.6 at least) requires 3+ digits in username.
+        #
+        # The following hashes (below 13 chars) should be identical for PIX/ASA.
+        # Ones which differ are listed separately in the known_correct_hashes
+        # list for the two test classes.
+        #
+
+        # 4 char password
+        (('1234', ''), 'RLPMUQ26KL4blgFN'),  # confirmed ASA 9.6
+
+        # 8 char password
+        (('01234567', ''), '0T52THgnYdV1tlOF'),  # confirmed ASA 9.6
+        (('01234567', '3'), '.z0dT9Alkdc7EIGS'),
+        (('01234567', '36'), 'CC3Lam53t/mHhoE7'),
+        (('01234567', '365'), '8xPrWpNnBdD2DzdZ'),  # confirmed ASA 9.6
+        (('01234567', '3333'), '.z0dT9Alkdc7EIGS'),  # confirmed ASA 9.6
+        (('01234567', '3636'), 'CC3Lam53t/mHhoE7'),  # confirmed ASA 9.6
+        (('01234567', '3653'), '8xPrWpNnBdD2DzdZ'),  # confirmed ASA 9.6
+        (('01234567', 'adm'), 'dfWs2qiao6KD/P2L'),  # confirmed ASA 9.6
+        (('01234567', 'adma'), 'dfWs2qiao6KD/P2L'),  # confirmed ASA 9.6
+        (('01234567', 'admad'), 'dfWs2qiao6KD/P2L'),  # confirmed ASA 9.6
+        (('01234567', 'user'), 'PNZ4ycbbZ0jp1.j1'),  # confirmed ASA 9.6
+        (('01234567', 'user1234'), 'PNZ4ycbbZ0jp1.j1'),  # confirmed ASA 9.6
+
+        # 12 char password
+        (('0123456789ab', ''), 'S31BxZOGlAigndcJ'),  # confirmed ASA 9.6
+        (('0123456789ab', '36'), 'wFqSX91X5.YaRKsi'),
+        (('0123456789ab', '365'), 'qjgo3kNgTVxExbno'),  # confirmed ASA 9.6
+        (('0123456789ab', '3333'), 'mcXPL/vIZcIxLUQs'),  # confirmed ASA 9.6
+        (('0123456789ab', '3636'), 'wFqSX91X5.YaRKsi'),  # confirmed ASA 9.6
+        (('0123456789ab', '3653'), 'qjgo3kNgTVxExbno'),  # confirmed ASA 9.6
+        (('0123456789ab', 'user'), 'f.T4BKdzdNkjxQl7'),  # confirmed ASA 9.6
+        (('0123456789ab', 'user1234'), 'f.T4BKdzdNkjxQl7'),  # confirmed ASA 9.6
+
+        # NOTE: remaining reference vectors for 13+ char passwords
+        # are split up between cisco_pix & cisco_asa tests.
+
+        # unicode passwords
+        # ASA supposedly uses utf-8 encoding, but entering non-ascii
+        # chars is error-prone, and while UTF-8 appears to be intended,
+        # observed behaviors include:
+        # * ssh cli stripping non-ascii chars entirely
+        # * ASDM web iface double-encoding utf-8 strings
+        ((u("t\xe1ble").encode("utf-8"), 'user'), 'Og8fB4NyF0m5Ed9c'),
+        ((u("t\xe1ble").encode("utf-8").decode("latin-1").encode("utf-8"),
+          'user'), 'cMvFC2XVBmK/68yB'),  # confirmed ASA 9.6 when typed into ASDM
+        ]
+
+    def test_calc_digest_spoiler(self):
+        """
+        _calc_checksum() -- spoil oversize passwords during verify
+
+        for details, see 'spoil_digest' flag instead that function.
+        this helps cisco_pix/cisco_asa implement their policy of
+        ``.truncate_verify_reject=True``.
+        """
+        def calc(secret, for_hash=False):
+            return self.handler(use_defaults=for_hash)._calc_checksum(secret)
+
+        # short (non-truncated) password
+        short_secret = repeat_string("1234", self.handler.truncate_size)
+        short_hash = calc(short_secret)
+
+        # longer password should have totally different hash,
+        # to prevent verify from matching (i.e. "spoiled").
+        long_secret = short_secret + "X"
+        long_hash = calc(long_secret)
+        self.assertNotEqual(long_hash, short_hash)
+
+        # spoiled hash should depend on whole secret,
+        # so that output isn't predictable
+        alt_long_secret = short_secret + "Y"
+        alt_long_hash = calc(alt_long_secret)
+        self.assertNotEqual(alt_long_hash, short_hash)
+        self.assertNotEqual(alt_long_hash, long_hash)
+
+        # for hash(), should throw error if password too large
+        calc(short_secret, for_hash=True)
+        self.assertRaises(exc.PasswordSizeError, calc, long_secret, for_hash=True)
+        self.assertRaises(exc.PasswordSizeError, calc, alt_long_secret, for_hash=True)
+
+#=============================================================================
+# cisco pix
+#=============================================================================
+class cisco_pix_test(_PixAsaSharedTest):
+    handler = hash.cisco_pix
+
+    #: known correct pix hashes
+    known_correct_hashes = _PixAsaSharedTest.pix_asa_shared_hashes + [
+        #
+        # passlib reference vectors (PIX-specific)
+        #
+        # NOTE: See 'pix_asa_shared_hashes' for general PIX+ASA vectors,
+        #       and general notes about the 'passlib reference vectors' test set.
+        #
+        #       All of the following are PIX-specific, as ASA starts
+        #       to use a different padding size at 13 characters.
+        #
+        # TODO: these need confirming w/ an actual PIX system.
+        #
+
+        # 13 char password
+        (('0123456789abc', ''), 'eacOpB7vE7ZDukSF'),
+        (('0123456789abc', '3'), 'ylJTd/qei66WZe3w'),
+        (('0123456789abc', '36'), 'hDx8QRlUhwd6bU8N'),
+        (('0123456789abc', '365'), 'vYOOtnkh1HXcMrM7'),
+        (('0123456789abc', '3333'), 'ylJTd/qei66WZe3w'),
+        (('0123456789abc', '3636'), 'hDx8QRlUhwd6bU8N'),
+        (('0123456789abc', '3653'), 'vYOOtnkh1HXcMrM7'),
+        (('0123456789abc', 'user'), 'f4/.SALxqDo59mfV'),
+        (('0123456789abc', 'user1234'), 'f4/.SALxqDo59mfV'),
+
+        # 14 char password
+        (('0123456789abcd', ''), '6r8888iMxEoPdLp4'),
+        (('0123456789abcd', '3'), 'f5lvmqWYj9gJqkIH'),
+        (('0123456789abcd', '36'), 'OJJ1Khg5HeAYBH1c'),
+        (('0123456789abcd', '365'), 'OJJ1Khg5HeAYBH1c'),
+        (('0123456789abcd', '3333'), 'f5lvmqWYj9gJqkIH'),
+        (('0123456789abcd', '3636'), 'OJJ1Khg5HeAYBH1c'),
+        (('0123456789abcd', '3653'), 'OJJ1Khg5HeAYBH1c'),
+        (('0123456789abcd', 'adm'), 'DbPLCFIkHc2SiyDk'),
+        (('0123456789abcd', 'adma'), 'DbPLCFIkHc2SiyDk'),
+        (('0123456789abcd', 'user'), 'WfO2UiTapPkF/FSn'),
+        (('0123456789abcd', 'user1234'), 'WfO2UiTapPkF/FSn'),
+
+        # 15 char password
+        (('0123456789abcde', ''), 'al1e0XFIugTYLai3'),
+        (('0123456789abcde', '3'), 'lYbwBu.f82OIApQB'),
+        (('0123456789abcde', '36'), 'lYbwBu.f82OIApQB'),
+        (('0123456789abcde', '365'), 'lYbwBu.f82OIApQB'),
+        (('0123456789abcde', '3333'), 'lYbwBu.f82OIApQB'),
+        (('0123456789abcde', '3636'), 'lYbwBu.f82OIApQB'),
+        (('0123456789abcde', '3653'), 'lYbwBu.f82OIApQB'),
+        (('0123456789abcde', 'adm'), 'KgKx1UQvdR/09i9u'),
+        (('0123456789abcde', 'adma'), 'KgKx1UQvdR/09i9u'),
+        (('0123456789abcde', 'user'), 'qLopkenJ4WBqxaZN'),
+        (('0123456789abcde', 'user1234'), 'qLopkenJ4WBqxaZN'),
+
+        # 16 char password
+        (('0123456789abcdef', ''), '.7nfVBEIEu4KbF/1'),
+        (('0123456789abcdef', '36'), '.7nfVBEIEu4KbF/1'),
+        (('0123456789abcdef', '365'), '.7nfVBEIEu4KbF/1'),
+        (('0123456789abcdef', '3333'), '.7nfVBEIEu4KbF/1'),
+        (('0123456789abcdef', '3636'), '.7nfVBEIEu4KbF/1'),
+        (('0123456789abcdef', '3653'), '.7nfVBEIEu4KbF/1'),
+        (('0123456789abcdef', 'user'), '.7nfVBEIEu4KbF/1'),
+        (('0123456789abcdef', 'user1234'), '.7nfVBEIEu4KbF/1'),
+    ]
+
+
+#=============================================================================
+# cisco asa
+#=============================================================================
+class cisco_asa_test(_PixAsaSharedTest):
+    handler = hash.cisco_asa
+
+    known_correct_hashes = _PixAsaSharedTest.pix_asa_shared_hashes + [
+        #
+        # passlib reference vectors (ASA-specific)
+        #
+        # NOTE: See 'pix_asa_shared_hashes' for general PIX+ASA vectors,
+        #       and general notes about the 'passlib reference vectors' test set.
+        #
+
+        # 13 char password
+        # NOTE: past this point, ASA pads to 32 bytes instead of 16
+        #       for all cases where user is set (secret + 4 bytes > 16),
+        #       but still uses 16 bytes for enable pwds (secret <= 16).
+        #       hashes w/ user WON'T match PIX, but "enable" passwords will.
+        (('0123456789abc', ''), 'eacOpB7vE7ZDukSF'),  # confirmed ASA 9.6
+        (('0123456789abc', '36'), 'FRV9JG18UBEgX0.O'),
+        (('0123456789abc', '365'), 'NIwkusG9hmmMy6ZQ'),  # confirmed ASA 9.6
+        (('0123456789abc', '3333'), 'NmrkP98nT7RAeKZz'),  # confirmed ASA 9.6
+        (('0123456789abc', '3636'), 'FRV9JG18UBEgX0.O'),  # confirmed ASA 9.6
+        (('0123456789abc', '3653'), 'NIwkusG9hmmMy6ZQ'),  # confirmed ASA 9.6
+        (('0123456789abc', 'user'), '8Q/FZeam5ai1A47p'),  # confirmed ASA 9.6
+        (('0123456789abc', 'user1234'), '8Q/FZeam5ai1A47p'),  # confirmed ASA 9.6
+
+        # 14 char password
+        (('0123456789abcd', ''), '6r8888iMxEoPdLp4'),  # confirmed ASA 9.6
+        (('0123456789abcd', '3'), 'yxGoujXKPduTVaYB'),
+        (('0123456789abcd', '36'), 'W0jckhnhjnr/DiT/'),
+        (('0123456789abcd', '365'), 'HuVOxfMQNahaoF8u'),  # confirmed ASA 9.6
+        (('0123456789abcd', '3333'), 'yxGoujXKPduTVaYB'),  # confirmed ASA 9.6
+        (('0123456789abcd', '3636'), 'W0jckhnhjnr/DiT/'),  # confirmed ASA 9.6
+        (('0123456789abcd', '3653'), 'HuVOxfMQNahaoF8u'),  # confirmed ASA 9.6
+        (('0123456789abcd', 'adm'), 'RtOmSeoCs4AUdZqZ'),  # confirmed ASA 9.6
+        (('0123456789abcd', 'adma'), 'RtOmSeoCs4AUdZqZ'),  # confirmed ASA 9.6
+        (('0123456789abcd', 'user'), 'rrucwrcM0h25pr.m'),  # confirmed ASA 9.6
+        (('0123456789abcd', 'user1234'), 'rrucwrcM0h25pr.m'),  # confirmed ASA 9.6
+
+        # 15 char password
+        (('0123456789abcde', ''), 'al1e0XFIugTYLai3'),  # confirmed ASA 9.6
+        (('0123456789abcde', '3'), 'nAZrQoHaL.fgrIqt'),
+        (('0123456789abcde', '36'), '2GxIQ6ICE795587X'),
+        (('0123456789abcde', '365'), 'QmDsGwCRBbtGEKqM'),  # confirmed ASA 9.6
+        (('0123456789abcde', '3333'), 'nAZrQoHaL.fgrIqt'),  # confirmed ASA 9.6
+        (('0123456789abcde', '3636'), '2GxIQ6ICE795587X'),  # confirmed ASA 9.6
+        (('0123456789abcde', '3653'), 'QmDsGwCRBbtGEKqM'),  # confirmed ASA 9.6
+        (('0123456789abcde', 'adm'), 'Aj2aP0d.nk62wl4m'),  # confirmed ASA 9.6
+        (('0123456789abcde', 'adma'), 'Aj2aP0d.nk62wl4m'),  # confirmed ASA 9.6
+        (('0123456789abcde', 'user'), 'etxiXfo.bINJcXI7'),  # confirmed ASA 9.6
+        (('0123456789abcde', 'user1234'), 'etxiXfo.bINJcXI7'),  # confirmed ASA 9.6
+
+        # 16 char password
+        (('0123456789abcdef', ''), '.7nfVBEIEu4KbF/1'),  # confirmed ASA 9.6
+        (('0123456789abcdef', '36'), 'GhI8.yFSC5lwoafg'),
+        (('0123456789abcdef', '365'), 'KFBI6cNQauyY6h/G'),  # confirmed ASA 9.6
+        (('0123456789abcdef', '3333'), 'Ghdi1IlsswgYzzMH'),  # confirmed ASA 9.6
+        (('0123456789abcdef', '3636'), 'GhI8.yFSC5lwoafg'),  # confirmed ASA 9.6
+        (('0123456789abcdef', '3653'), 'KFBI6cNQauyY6h/G'),  # confirmed ASA 9.6
+        (('0123456789abcdef', 'user'), 'IneB.wc9sfRzLPoh'),  # confirmed ASA 9.6
+        (('0123456789abcdef', 'user1234'), 'IneB.wc9sfRzLPoh'),  # confirmed ASA 9.6
+
+        # 17 char password
+        # NOTE: past this point, ASA pads to 32 bytes instead of 16
+        #       for ALL cases, since secret > 16 bytes even for enable pwds;
+        #       and so none of these rest here should match PIX.
+        (('0123456789abcdefq', ''), 'bKshl.EN.X3CVFRQ'),  # confirmed ASA 9.6
+        (('0123456789abcdefq', '36'), 'JAeTXHs0n30svlaG'),
+        (('0123456789abcdefq', '365'), '4fKSSUBHT1ChGqHp'),  # confirmed ASA 9.6
+        (('0123456789abcdefq', '3333'), 'USEJbxI6.VY4ecBP'),  # confirmed ASA 9.6
+        (('0123456789abcdefq', '3636'), 'JAeTXHs0n30svlaG'),  # confirmed ASA 9.6
+        (('0123456789abcdefq', '3653'), '4fKSSUBHT1ChGqHp'),  # confirmed ASA 9.6
+        (('0123456789abcdefq', 'user'), '/dwqyD7nGdwSrDwk'),  # confirmed ASA 9.6
+        (('0123456789abcdefq', 'user1234'), '/dwqyD7nGdwSrDwk'),  # confirmed ASA 9.6
+
+        # 27 char password
+        (('0123456789abcdefqwertyuiopa', ''), '4wp19zS3OCe.2jt5'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopa', '36'), 'PjUoGqWBKPyV9qOe'),
+        (('0123456789abcdefqwertyuiopa', '365'), 'bfCy6xFAe5O/gzvM'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopa', '3333'), 'rd/ZMuGTJFIb2BNG'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopa', '3636'), 'PjUoGqWBKPyV9qOe'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopa', '3653'), 'bfCy6xFAe5O/gzvM'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopa', 'user'), 'zynfWw3UtszxLMgL'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopa', 'user1234'), 'zynfWw3UtszxLMgL'),  # confirmed ASA 9.6
+
+        # 28 char password
+        # NOTE: past this point, ASA stops appending the username AT ALL,
+        #       even though there's still room for the first few chars.
+        (('0123456789abcdefqwertyuiopas', ''), 'W6nbOddI0SutTK7m'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopas', '36'), 'W6nbOddI0SutTK7m'),
+        (('0123456789abcdefqwertyuiopas', '365'), 'W6nbOddI0SutTK7m'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopas', 'user'), 'W6nbOddI0SutTK7m'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopas', 'user1234'), 'W6nbOddI0SutTK7m'),  # confirmed ASA 9.6
+
+        # 32 char password
+        # NOTE: this is max size that ASA allows, and throws error for larger
+        (('0123456789abcdefqwertyuiopasdfgh', ''), '5hPT/iC6DnoBxo6a'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopasdfgh', '36'), '5hPT/iC6DnoBxo6a'),
+        (('0123456789abcdefqwertyuiopasdfgh', '365'), '5hPT/iC6DnoBxo6a'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopasdfgh', 'user'), '5hPT/iC6DnoBxo6a'),  # confirmed ASA 9.6
+        (('0123456789abcdefqwertyuiopasdfgh', 'user1234'), '5hPT/iC6DnoBxo6a'),  # confirmed ASA 9.6
+    ]
+
+
+#=============================================================================
+# cisco type 7
+#=============================================================================
+class cisco_type7_test(HandlerCase):
+    handler = hash.cisco_type7
+    salt_bits = 4
+    salt_type = int
+
+    known_correct_hashes = [
+        #
+        # http://mccltd.net/blog/?p=1034
+        #
+        ("secure ", "04480E051A33490E"),
+
+        #
+        # http://insecure.org/sploits/cisco.passwords.html
+        #
+        ("Its time to go to lunch!",
+         "153B1F1F443E22292D73212D5300194315591954465A0D0B59"),
+
+        #
+        # http://blog.ioshints.info/2007/11/type-7-decryption-in-cisco-ios.html
+        #
+        ("t35t:pa55w0rd", "08351F1B1D431516475E1B54382F"),
+
+        #
+        # http://www.m00nie.com/2011/09/cisco-type-7-password-decryption-and-encryption-with-perl/
+        #
+        ("hiImTesting:)", "020E0D7206320A325847071E5F5E"),
+
+        #
+        # http://packetlife.net/forums/thread/54/
+        #
+        ("cisco123", "060506324F41584B56"),
+        ("cisco123", "1511021F07257A767B"),
+
+        #
+        # source ?
+        #
+        ('Supe&8ZUbeRp4SS', "06351A3149085123301517391C501918"),
+
+        #
+        # custom
+        #
+
+        # ensures utf-8 used for unicode
+        (UPASS_TABLE, '0958EDC8A9F495F6F8A5FD'),
+    ]
+
+    known_unidentified_hashes = [
+        # salt with hex value
+        "0A480E051A33490E",
+
+        # salt value > 52. this may in fact be valid, but we reject it for now
+        # (see docs for more).
+        '99400E4812',
+    ]
+
+    def test_90_decode(self):
+        """test cisco_type7.decode()"""
+        from passlib.utils import to_unicode, to_bytes
+
+        handler = self.handler
+        for secret, hash in self.known_correct_hashes:
+            usecret = to_unicode(secret)
+            bsecret = to_bytes(secret)
+            self.assertEqual(handler.decode(hash), usecret)
+            self.assertEqual(handler.decode(hash, None), bsecret)
+
+        self.assertRaises(UnicodeDecodeError, handler.decode,
+                          '0958EDC8A9F495F6F8A5FD', 'ascii')
+
+    def test_91_salt(self):
+        """test salt value border cases"""
+        handler = self.handler
+        self.assertRaises(TypeError, handler, salt=None)
+        handler(salt=None, use_defaults=True)
+        self.assertRaises(TypeError, handler, salt='abc')
+        self.assertRaises(ValueError, handler, salt=-10)
+        self.assertRaises(ValueError, handler, salt=100)
+
+        self.assertRaises(TypeError, handler.using, salt='abc')
+        self.assertRaises(ValueError, handler.using, salt=-10)
+        self.assertRaises(ValueError, handler.using, salt=100)
+        with self.assertWarningList("salt/offset must be.*"):
+            subcls = handler.using(salt=100, relaxed=True)
+        self.assertEqual(subcls(use_defaults=True).salt, 52)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_django.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_django.py
new file mode 100644
index 0000000..f7c9a0d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_django.py
@@ -0,0 +1,413 @@
+"""passlib.tests.test_handlers_django - tests for passlib hash algorithms"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+import logging; log = logging.getLogger(__name__)
+import re
+import warnings
+# site
+# pkg
+from passlib import hash
+from passlib.utils import repeat_string
+from passlib.utils.compat import u
+from passlib.tests.utils import TestCase, HandlerCase, skipUnless, SkipTest
+from passlib.tests.test_handlers import UPASS_USD, UPASS_TABLE
+from passlib.tests.test_ext_django import DJANGO_VERSION, MIN_DJANGO_VERSION, \
+    check_django_hasher_has_backend
+# module
+
+#=============================================================================
+# django
+#=============================================================================
+
+# standard string django uses
+UPASS_LETMEIN = u('l\xe8tmein')
+
+def vstr(version):
+    return ".".join(str(e) for e in version)
+
+class _DjangoHelper(TestCase):
+    """
+    mixin for HandlerCase subclasses that are testing a hasher
+    which is also present in django.
+    """
+    __unittest_skip = True
+
+    #: minimum django version where hash alg is present / that we support testing against
+    min_django_version = MIN_DJANGO_VERSION
+
+    #: max django version where hash alg is present
+    #: TODO: for a bunch of the tests below, this is just max version where
+    #:       settings.PASSWORD_HASHERS includes it by default -- could add helper to patch
+    #:       desired django hasher back in for duration of test.
+    #: XXX: change this to "disabled_in_django_version" instead?
+    max_django_version = None
+
+    def _require_django_support(self):
+        # make sure min django version
+        if DJANGO_VERSION < self.min_django_version:
+            raise self.skipTest("Django >= %s not installed" % vstr(self.min_django_version))
+        if self.max_django_version and DJANGO_VERSION > self.max_django_version:
+            raise self.skipTest("Django <= %s not installed" % vstr(self.max_django_version))
+
+        # make sure django has a backend for specified hasher
+        name = self.handler.django_name
+        if not check_django_hasher_has_backend(name):
+            raise self.skipTest('django hasher %r not available' % name)
+
+        return True
+
+    extra_fuzz_verifiers = HandlerCase.fuzz_verifiers + (
+        "fuzz_verifier_django",
+    )
+
+    def fuzz_verifier_django(self):
+        try:
+            self._require_django_support()
+        except SkipTest:
+            return None
+        from django.contrib.auth.hashers import check_password
+
+        def verify_django(secret, hash):
+            """django/check_password"""
+            if self.handler.name == "django_bcrypt" and hash.startswith("bcrypt$$2y$"):
+                hash = hash.replace("$$2y$", "$$2a$")
+            if isinstance(secret, bytes):
+                secret = secret.decode("utf-8")
+            return check_password(secret, hash)
+        return verify_django
+
+    def test_90_django_reference(self):
+        """run known correct hashes through Django's check_password()"""
+        self._require_django_support()
+        # XXX: esp. when it's no longer supported by django,
+        #      should verify it's *NOT* recognized
+        from django.contrib.auth.hashers import check_password
+        assert self.known_correct_hashes
+        for secret, hash in self.iter_known_hashes():
+            self.assertTrue(check_password(secret, hash),
+                            "secret=%r hash=%r failed to verify" %
+                            (secret, hash))
+            self.assertFalse(check_password('x' + secret, hash),
+                            "mangled secret=%r hash=%r incorrect verified" %
+                            (secret, hash))
+
+    def test_91_django_generation(self):
+        """test against output of Django's make_password()"""
+        self._require_django_support()
+        # XXX: esp. when it's no longer supported by django,
+        #      should verify it's *NOT* recognized
+        from passlib.utils import tick
+        from django.contrib.auth.hashers import make_password
+        name = self.handler.django_name # set for all the django_* handlers
+        end = tick() + self.max_fuzz_time/2
+        generator = self.FuzzHashGenerator(self, self.getRandom())
+        while tick() < end:
+            secret, other = generator.random_password_pair()
+            if not secret: # django rejects empty passwords.
+                continue
+            if isinstance(secret, bytes):
+                secret = secret.decode("utf-8")
+            hash = make_password(secret, hasher=name)
+            self.assertTrue(self.do_identify(hash))
+            self.assertTrue(self.do_verify(secret, hash))
+            self.assertFalse(self.do_verify(other, hash))
+
+class django_disabled_test(HandlerCase):
+    """test django_disabled"""
+    handler = hash.django_disabled
+    disabled_contains_salt = True
+
+    known_correct_hashes = [
+        # *everything* should hash to "!", and nothing should verify
+        ("password", "!"),
+        ("", "!"),
+        (UPASS_TABLE, "!"),
+    ]
+
+    known_alternate_hashes = [
+        # django 1.6 appends random alpnum string
+        ("!9wa845vn7098ythaehasldkfj", "password", "!"),
+    ]
+
+class django_des_crypt_test(HandlerCase, _DjangoHelper):
+    """test django_des_crypt"""
+    handler = hash.django_des_crypt
+    max_django_version = (1,9)
+
+    known_correct_hashes = [
+        # ensures only first two digits of salt count.
+        ("password",         'crypt$c2$c2M87q...WWcU'),
+        ("password",         'crypt$c2e86$c2M87q...WWcU'),
+        ("passwordignoreme", 'crypt$c2.AZ$c2M87q...WWcU'),
+
+        # ensures utf-8 used for unicode
+        (UPASS_USD, 'crypt$c2e86$c2hN1Bxd6ZiWs'),
+        (UPASS_TABLE, 'crypt$0.aQs$0.wB.TT0Czvlo'),
+        (u("hell\u00D6"), "crypt$sa$saykDgk3BPZ9E"),
+
+        # prevent regression of issue 22
+        ("foo", 'crypt$MNVY.9ajgdvDQ$MNVY.9ajgdvDQ'),
+    ]
+
+    known_alternate_hashes = [
+        # ensure django 1.4 empty salt field is accepted;
+        # but that salt field is re-filled (for django 1.0 compatibility)
+        ('crypt$$c2M87q...WWcU', "password", 'crypt$c2$c2M87q...WWcU'),
+    ]
+
+    known_unidentified_hashes = [
+        'sha1$aa$bb',
+    ]
+
+    known_malformed_hashes = [
+        # checksum too short
+        'crypt$c2$c2M87q',
+
+        # salt must be >2
+        'crypt$f$c2M87q...WWcU',
+
+        # make sure first 2 chars of salt & chk field agree.
+        'crypt$ffe86$c2M87q...WWcU',
+    ]
+
+class django_salted_md5_test(HandlerCase, _DjangoHelper):
+    """test django_salted_md5"""
+    handler = hash.django_salted_md5
+    max_django_version = (1,9)
+
+    known_correct_hashes = [
+        # test extra large salt
+        ("password",    'md5$123abcdef$c8272612932975ee80e8a35995708e80'),
+
+        # test django 1.4 alphanumeric salt
+        ("test", 'md5$3OpqnFAHW5CT$54b29300675271049a1ebae07b395e20'),
+
+        # ensures utf-8 used for unicode
+        (UPASS_USD,     'md5$c2e86$92105508419a81a6babfaecf876a2fa0'),
+        (UPASS_TABLE,   'md5$d9eb8$01495b32852bffb27cf5d4394fe7a54c'),
+    ]
+
+    known_unidentified_hashes = [
+        'sha1$aa$bb',
+    ]
+
+    known_malformed_hashes = [
+        # checksum too short
+        'md5$aa$bb',
+    ]
+
+    class FuzzHashGenerator(HandlerCase.FuzzHashGenerator):
+
+        def random_salt_size(self):
+            # workaround for django14 regression --
+            # 1.4 won't accept hashes with empty salt strings, unlike 1.3 and earlier.
+            # looks to be fixed in a future release -- https://code.djangoproject.com/ticket/18144
+            # for now, we avoid salt_size==0 under 1.4
+            handler = self.handler
+            default = handler.default_salt_size
+            assert handler.min_salt_size == 0
+            lower = 1
+            upper = handler.max_salt_size or default*4
+            return self.randintgauss(lower, upper, default, default*.5)
+
+class django_salted_sha1_test(HandlerCase, _DjangoHelper):
+    """test django_salted_sha1"""
+    handler = hash.django_salted_sha1
+    max_django_version = (1,9)
+
+    known_correct_hashes = [
+        # test extra large salt
+        ("password",'sha1$123abcdef$e4a1877b0e35c47329e7ed7e58014276168a37ba'),
+
+        # test django 1.4 alphanumeric salt
+        ("test", 'sha1$bcwHF9Hy8lxS$6b4cfa0651b43161c6f1471ce9523acf1f751ba3'),
+
+        # ensures utf-8 used for unicode
+        (UPASS_USD,     'sha1$c2e86$0f75c5d7fbd100d587c127ef0b693cde611b4ada'),
+        (UPASS_TABLE,   'sha1$6d853$ef13a4d8fb57aed0cb573fe9c82e28dc7fd372d4'),
+
+        # generic password
+        ("MyPassword",  'sha1$54123$893cf12e134c3c215f3a76bd50d13f92404a54d3'),
+    ]
+
+    known_unidentified_hashes = [
+        'md5$aa$bb',
+    ]
+
+    known_malformed_hashes = [
+        # checksum too short
+        'sha1$c2e86$0f75',
+    ]
+
+    # reuse custom random_salt_size() helper...
+    FuzzHashGenerator = django_salted_md5_test.FuzzHashGenerator
+
+class django_pbkdf2_sha256_test(HandlerCase, _DjangoHelper):
+    """test django_pbkdf2_sha256"""
+    handler = hash.django_pbkdf2_sha256
+
+    known_correct_hashes = [
+        #
+        # custom - generated via django 1.4 hasher
+        #
+        ('not a password',
+         'pbkdf2_sha256$10000$kjVJaVz6qsnJ$5yPHw3rwJGECpUf70daLGhOrQ5+AMxIJdz1c3bqK1Rs='),
+        (UPASS_TABLE,
+         'pbkdf2_sha256$10000$bEwAfNrH1TlQ$OgYUblFNUX1B8GfMqaCYUK/iHyO0pa7STTDdaEJBuY0='),
+    ]
+
+class django_pbkdf2_sha1_test(HandlerCase, _DjangoHelper):
+    """test django_pbkdf2_sha1"""
+    handler = hash.django_pbkdf2_sha1
+
+    known_correct_hashes = [
+        #
+        # custom - generated via django 1.4 hashers
+        #
+        ('not a password',
+         'pbkdf2_sha1$10000$wz5B6WkasRoF$atJmJ1o+XfJxKq1+Nu1f1i57Z5I='),
+        (UPASS_TABLE,
+         'pbkdf2_sha1$10000$KZKWwvqb8BfL$rw5pWsxJEU4JrZAQhHTCO+u0f5Y='),
+    ]
+
+@skipUnless(hash.bcrypt.has_backend(), "no bcrypt backends available")
+class django_bcrypt_test(HandlerCase, _DjangoHelper):
+    """test django_bcrypt"""
+    handler = hash.django_bcrypt
+    # XXX: not sure when this wasn't in default list anymore. somewhere in [2.0 - 2.2]
+    max_django_version = (2, 0)
+    fuzz_salts_need_bcrypt_repair = True
+
+    known_correct_hashes = [
+        #
+        # just copied and adapted a few test vectors from bcrypt (above),
+        # since django_bcrypt is just a wrapper for the real bcrypt class.
+        #
+        ('', 'bcrypt$$2a$06$DCq7YPn5Rq63x1Lad4cll.TV4S6ytwfsfvkgY8jIucDrjc8deX1s.'),
+        ('abcdefghijklmnopqrstuvwxyz',
+             'bcrypt$$2a$10$fVH8e28OQRj9tqiDXs1e1uxpsjN0c7II7YPKXua2NAKYvM6iQk7dq'),
+        (UPASS_TABLE,
+                'bcrypt$$2a$05$Z17AXnnlpzddNUvnC6cZNOSwMA/8oNiKnHTHTwLlBijfucQQlHjaG'),
+    ]
+
+    # NOTE: the following have been cloned from _bcrypt_test()
+
+    def populate_settings(self, kwds):
+        # speed up test w/ lower rounds
+        kwds.setdefault("rounds", 4)
+        super(django_bcrypt_test, self).populate_settings(kwds)
+
+    class FuzzHashGenerator(HandlerCase.FuzzHashGenerator):
+
+        def random_rounds(self):
+            # decrease default rounds for fuzz testing to speed up volume.
+            return self.randintgauss(5, 8, 6, 1)
+
+        def random_ident(self):
+            # omit multi-ident tests, only $2a$ counts for this class
+            # XXX: enable this to check 2a / 2b?
+            return None
+
+@skipUnless(hash.bcrypt.has_backend(), "no bcrypt backends available")
+class django_bcrypt_sha256_test(HandlerCase, _DjangoHelper):
+    """test django_bcrypt_sha256"""
+    handler = hash.django_bcrypt_sha256
+    forbidden_characters = None
+    fuzz_salts_need_bcrypt_repair = True
+
+    known_correct_hashes = [
+        #
+        # custom - generated via django 1.6 hasher
+        #
+        ('',
+            'bcrypt_sha256$$2a$06$/3OeRpbOf8/l6nPPRdZPp.nRiyYqPobEZGdNRBWihQhiFDh1ws1tu'),
+        (UPASS_LETMEIN,
+            'bcrypt_sha256$$2a$08$NDjSAIcas.EcoxCRiArvT.MkNiPYVhrsrnJsRkLueZOoV1bsQqlmC'),
+        (UPASS_TABLE,
+            'bcrypt_sha256$$2a$06$kCXUnRFQptGg491siDKNTu8RxjBGSjALHRuvhPYNFsa4Ea5d9M48u'),
+
+        # test >72 chars is hashed correctly -- under bcrypt these hash the same.
+        (repeat_string("abc123",72),
+            'bcrypt_sha256$$2a$06$Tg/oYyZTyAf.Nb3qSgN61OySmyXA8FoY4PjGizjE1QSDfuL5MXNni'),
+        (repeat_string("abc123",72)+"qwr",
+            'bcrypt_sha256$$2a$06$Tg/oYyZTyAf.Nb3qSgN61Ocy0BEz1RK6xslSNi8PlaLX2pe7x/KQG'),
+        (repeat_string("abc123",72)+"xyz",
+            'bcrypt_sha256$$2a$06$Tg/oYyZTyAf.Nb3qSgN61OvY2zoRVUa2Pugv2ExVOUT2YmhvxUFUa'),
+    ]
+
+    known_malformed_hashers = [
+        # data in django salt field
+        'bcrypt_sha256$xyz$2a$06$/3OeRpbOf8/l6nPPRdZPp.nRiyYqPobEZGdNRBWihQhiFDh1ws1tu',
+    ]
+
+    # NOTE: the following have been cloned from _bcrypt_test()
+
+    def populate_settings(self, kwds):
+        # speed up test w/ lower rounds
+        kwds.setdefault("rounds", 4)
+        super(django_bcrypt_sha256_test, self).populate_settings(kwds)
+
+    class FuzzHashGenerator(HandlerCase.FuzzHashGenerator):
+
+        def random_rounds(self):
+            # decrease default rounds for fuzz testing to speed up volume.
+            return self.randintgauss(5, 8, 6, 1)
+
+        def random_ident(self):
+            # omit multi-ident tests, only $2a$ counts for this class
+            # XXX: enable this to check 2a / 2b?
+            return None
+
+from passlib.tests.test_handlers_argon2 import _base_argon2_test
+
+@skipUnless(hash.argon2.has_backend(), "no argon2 backends available")
+class django_argon2_test(HandlerCase, _DjangoHelper):
+    """test django_bcrypt"""
+    handler = hash.django_argon2
+
+    # NOTE: most of this adapted from _base_argon2_test & argon2pure test
+
+    known_correct_hashes = [
+        # sample test
+        ("password", 'argon2$argon2i$v=19$m=256,t=1,p=1$c29tZXNhbHQ$AJFIsNZTMKTAewB4+ETN1A'),
+
+        # sample w/ all parameters different
+        ("password", 'argon2$argon2i$v=19$m=380,t=2,p=2$c29tZXNhbHQ$SrssP8n7m/12VWPM8dvNrw'),
+
+        # generated from django 1.10.3
+        (UPASS_LETMEIN, 'argon2$argon2i$v=19$m=512,t=2,p=2$V25jN1l4UUJZWkR1$MxpA1BD2Gh7+D79gaAw6sQ'),
+    ]
+
+    def setUpWarnings(self):
+        super(django_argon2_test, self).setUpWarnings()
+        warnings.filterwarnings("ignore", ".*Using argon2pure backend.*")
+
+    def do_stub_encrypt(self, handler=None, **settings):
+        # overriding default since no way to get stub config from argon2._calc_hash()
+        # (otherwise test_21b_max_rounds blocks trying to do max rounds)
+        handler = (handler or self.handler).using(**settings)
+        self = handler.wrapped(use_defaults=True)
+        self.checksum = self._stub_checksum
+        assert self.checksum
+        return handler._wrap_hash(self.to_string())
+
+    def test_03_legacy_hash_workflow(self):
+        # override base method
+        raise self.skipTest("legacy 1.6 workflow not supported")
+
+    class FuzzHashGenerator(_base_argon2_test.FuzzHashGenerator):
+
+        def random_type(self):
+            # override default since django only uses type I (see note in class)
+            return "I"
+
+        def random_rounds(self):
+            # decrease default rounds for fuzz testing to speed up volume.
+            return self.randintgauss(1, 3, 2, 1)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_pbkdf2.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_pbkdf2.py
new file mode 100644
index 0000000..4d2f048
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_pbkdf2.py
@@ -0,0 +1,480 @@
+"""passlib.tests.test_handlers - tests for passlib hash algorithms"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import logging
+log = logging.getLogger(__name__)
+import warnings
+# site
+# pkg
+from passlib import hash
+from passlib.utils.compat import u
+from passlib.tests.utils import TestCase, HandlerCase
+from passlib.tests.test_handlers import UPASS_WAV
+# module
+
+#=============================================================================
+# ldap_pbkdf2_{digest}
+#=============================================================================
+# NOTE: since these are all wrappers for the pbkdf2_{digest} hasehs,
+#       they don't extensive separate testing.
+
+class ldap_pbkdf2_test(TestCase):
+
+    def test_wrappers(self):
+        """test ldap pbkdf2 wrappers"""
+
+        self.assertTrue(
+            hash.ldap_pbkdf2_sha1.verify(
+                "password",
+                '{PBKDF2}1212$OB.dtnSEXZK8U5cgxU/GYQ$y5LKPOplRmok7CZp/aqVDVg8zGI',
+            )
+        )
+
+        self.assertTrue(
+            hash.ldap_pbkdf2_sha256.verify(
+                "password",
+                '{PBKDF2-SHA256}1212$4vjV83LKPjQzk31VI4E0Vw$hsYF68OiOUPdDZ1Fg'
+                '.fJPeq1h/gXXY7acBp9/6c.tmQ'
+            )
+        )
+
+        self.assertTrue(
+            hash.ldap_pbkdf2_sha512.verify(
+                "password",
+                '{PBKDF2-SHA512}1212$RHY0Fr3IDMSVO/RSZyb5ow$eNLfBK.eVozomMr.1gYa1'
+                '7k9B7KIK25NOEshvhrSX.esqY3s.FvWZViXz4KoLlQI.BzY/YTNJOiKc5gBYFYGww'
+            )
+        )
+
+#=============================================================================
+# pbkdf2 hashes
+#=============================================================================
+class atlassian_pbkdf2_sha1_test(HandlerCase):
+    handler = hash.atlassian_pbkdf2_sha1
+
+    known_correct_hashes = [
+        #
+        # generated using Jira
+        #
+        ("admin", '{PKCS5S2}c4xaeTQM0lUieMS3V5voiexyX9XhqC2dBd5ecVy60IPksHChwoTAVYFrhsgoq8/p'),
+        (UPASS_WAV,
+                  "{PKCS5S2}cE9Yq6Am5tQGdHSHhky2XLeOnURwzaLBG2sur7FHKpvy2u0qDn6GcVGRjlmJoIUy"),
+    ]
+
+    known_malformed_hashes = [
+        # bad char                                    ---\/
+        '{PKCS5S2}c4xaeTQM0lUieMS3V5voiexyX9XhqC2dBd5ecVy!0IPksHChwoTAVYFrhsgoq8/p'
+
+        # bad size, missing padding
+        '{PKCS5S2}c4xaeTQM0lUieMS3V5voiexyX9XhqC2dBd5ecVy60IPksHChwoTAVYFrhsgoq8/'
+
+        # bad size, with correct padding
+        '{PKCS5S2}c4xaeTQM0lUieMS3V5voiexyX9XhqC2dBd5ecVy60IPksHChwoTAVYFrhsgoq8/='
+    ]
+
+class pbkdf2_sha1_test(HandlerCase):
+    handler = hash.pbkdf2_sha1
+    known_correct_hashes = [
+        ("password", '$pbkdf2$1212$OB.dtnSEXZK8U5cgxU/GYQ$y5LKPOplRmok7CZp/aqVDVg8zGI'),
+        (UPASS_WAV,
+            '$pbkdf2$1212$THDqatpidANpadlLeTeOEg$HV3oi1k5C5LQCgG1BMOL.BX4YZc'),
+    ]
+
+    known_malformed_hashes = [
+        # zero padded rounds field
+        '$pbkdf2$01212$THDqatpidANpadlLeTeOEg$HV3oi1k5C5LQCgG1BMOL.BX4YZc',
+
+        # empty rounds field
+        '$pbkdf2$$THDqatpidANpadlLeTeOEg$HV3oi1k5C5LQCgG1BMOL.BX4YZc',
+
+        # too many field
+        '$pbkdf2$1212$THDqatpidANpadlLeTeOEg$HV3oi1k5C5LQCgG1BMOL.BX4YZc$',
+    ]
+
+class pbkdf2_sha256_test(HandlerCase):
+    handler = hash.pbkdf2_sha256
+    known_correct_hashes = [
+        ("password",
+            '$pbkdf2-sha256$1212$4vjV83LKPjQzk31VI4E0Vw$hsYF68OiOUPdDZ1Fg.fJPeq1h/gXXY7acBp9/6c.tmQ'
+            ),
+        (UPASS_WAV,
+            '$pbkdf2-sha256$1212$3SABFJGDtyhrQMVt1uABPw$WyaUoqCLgvz97s523nF4iuOqZNbp5Nt8do/cuaa7AiI'
+            ),
+    ]
+
+class pbkdf2_sha512_test(HandlerCase):
+    handler = hash.pbkdf2_sha512
+    known_correct_hashes = [
+        ("password",
+            '$pbkdf2-sha512$1212$RHY0Fr3IDMSVO/RSZyb5ow$eNLfBK.eVozomMr.1gYa1'
+            '7k9B7KIK25NOEshvhrSX.esqY3s.FvWZViXz4KoLlQI.BzY/YTNJOiKc5gBYFYGww'
+            ),
+        (UPASS_WAV,
+            '$pbkdf2-sha512$1212$KkbvoKGsAIcF8IslDR6skQ$8be/PRmd88Ps8fmPowCJt'
+            'tH9G3vgxpG.Krjt3KT.NP6cKJ0V4Prarqf.HBwz0dCkJ6xgWnSj2ynXSV7MlvMa8Q'
+            ),
+    ]
+
+class cta_pbkdf2_sha1_test(HandlerCase):
+    handler = hash.cta_pbkdf2_sha1
+    known_correct_hashes = [
+        #
+        # test vectors from original implementation
+        #
+        (u("hashy the \N{SNOWMAN}"), '$p5k2$1000$ZxK4ZBJCfQg=$jJZVscWtO--p1-xIZl6jhO2LKR0='),
+
+        #
+        # custom
+        #
+        ("password", "$p5k2$1$$h1TDLGSw9ST8UMAPeIE13i0t12c="),
+        (UPASS_WAV,
+            "$p5k2$4321$OTg3NjU0MzIx$jINJrSvZ3LXeIbUdrJkRpN62_WQ="),
+        ]
+
+class dlitz_pbkdf2_sha1_test(HandlerCase):
+    handler = hash.dlitz_pbkdf2_sha1
+    known_correct_hashes = [
+        #
+        # test vectors from original implementation
+        #
+        ('cloadm',  '$p5k2$$exec$r1EWMCMk7Rlv3L/RNcFXviDefYa0hlql'),
+        ('gnu',     '$p5k2$c$u9HvcT4d$Sd1gwSVCLZYAuqZ25piRnbBEoAesaa/g'),
+        ('dcl',     '$p5k2$d$tUsch7fU$nqDkaxMDOFBeJsTSfABsyn.PYUXilHwL'),
+        ('spam',    '$p5k2$3e8$H0NX9mT/$wk/sE8vv6OMKuMaqazCJYDSUhWY9YB2J'),
+        (UPASS_WAV,
+                    '$p5k2$$KosHgqNo$9mjN8gqjt02hDoP0c2J0ABtLIwtot8cQ'),
+        ]
+
+class grub_pbkdf2_sha512_test(HandlerCase):
+    handler = hash.grub_pbkdf2_sha512
+    known_correct_hashes = [
+        #
+        # test vectors generated from cmd line tool
+        #
+
+        # salt=32 bytes
+        (UPASS_WAV,
+            'grub.pbkdf2.sha512.10000.BCAC1CEC5E4341C8C511C529'
+            '7FA877BE91C2817B32A35A3ECF5CA6B8B257F751.6968526A'
+            '2A5B1AEEE0A29A9E057336B48D388FFB3F600233237223C21'
+            '04DE1752CEC35B0DD1ED49563398A282C0F471099C2803FBA'
+            '47C7919CABC43192C68F60'),
+
+        # salt=64 bytes
+        ('toomanysecrets',
+            'grub.pbkdf2.sha512.10000.9B436BB6978682363D5C449B'
+            'BEAB322676946C632208BC1294D51F47174A9A3B04A7E4785'
+            '986CD4EA7470FAB8FE9F6BD522D1FC6C51109A8596FB7AD48'
+            '7C4493.0FE5EF169AFFCB67D86E2581B1E251D88C777B98BA'
+            '2D3256ECC9F765D84956FC5CA5C4B6FD711AA285F0A04DCF4'
+            '634083F9A20F4B6F339A52FBD6BED618E527B'),
+
+        ]
+
+#=============================================================================
+# scram hash
+#=============================================================================
+class scram_test(HandlerCase):
+    handler = hash.scram
+
+    # TODO: need a bunch more reference vectors from some real
+    # SCRAM transactions.
+    known_correct_hashes = [
+        #
+        # taken from example in SCRAM specification (rfc 5802)
+        #
+        ('pencil', '$scram$4096$QSXCR.Q6sek8bf92$'
+                   'sha-1=HZbuOlKbWl.eR8AfIposuKbhX30'),
+
+        #
+        # custom
+        #
+
+        # same as 5802 example hash, but with sha-256 & sha-512 added.
+        ('pencil', '$scram$4096$QSXCR.Q6sek8bf92$'
+                   'sha-1=HZbuOlKbWl.eR8AfIposuKbhX30,'
+                   'sha-256=qXUXrlcvnaxxWG00DdRgVioR2gnUpuX5r.3EZ1rdhVY,'
+                   'sha-512=lzgniLFcvglRLS0gt.C4gy.NurS3OIOVRAU1zZOV4P.qFiVFO2/'
+                       'edGQSu/kD1LwdX0SNV/KsPdHSwEl5qRTuZQ'),
+
+        # test unicode passwords & saslprep (all the passwords below
+        # should normalize to the same value: 'IX \xE0')
+        (u('IX \xE0'),             '$scram$6400$0BojBCBE6P2/N4bQ$'
+                                   'sha-1=YniLes.b8WFMvBhtSACZyyvxeCc'),
+        (u('\u2168\u3000a\u0300'), '$scram$6400$0BojBCBE6P2/N4bQ$'
+                                   'sha-1=YniLes.b8WFMvBhtSACZyyvxeCc'),
+        (u('\u00ADIX \xE0'),       '$scram$6400$0BojBCBE6P2/N4bQ$'
+                                   'sha-1=YniLes.b8WFMvBhtSACZyyvxeCc'),
+    ]
+
+    known_malformed_hashes = [
+        # zero-padding in rounds
+        '$scram$04096$QSXCR.Q6sek8bf92$sha-1=HZbuOlKbWl.eR8AfIposuKbhX30',
+
+        # non-digit in rounds
+        '$scram$409A$QSXCR.Q6sek8bf92$sha-1=HZbuOlKbWl.eR8AfIposuKbhX30',
+
+        # bad char in salt       ---\/
+        '$scram$4096$QSXCR.Q6sek8bf9-$sha-1=HZbuOlKbWl.eR8AfIposuKbhX30',
+
+        # bad char in digest                                       ---\/
+        '$scram$4096$QSXCR.Q6sek8bf92$sha-1=HZbuOlKbWl.eR8AfIposuKbhX3-',
+
+        # missing sections
+        '$scram$4096$QSXCR.Q6sek8bf92',
+        '$scram$4096$QSXCR.Q6sek8bf92$',
+
+        # too many sections
+        '$scram$4096$QSXCR.Q6sek8bf92$sha-1=HZbuOlKbWl.eR8AfIposuKbhX30$',
+
+        # missing separator
+        '$scram$4096$QSXCR.Q6sek8bf92$sha-1=HZbuOlKbWl.eR8AfIposuKbhX30'
+                   'sha-256=qXUXrlcvnaxxWG00DdRgVioR2gnUpuX5r.3EZ1rdhVY',
+
+        # too many chars in alg name
+        '$scram$4096$QSXCR.Q6sek8bf92$sha-1=HZbuOlKbWl.eR8AfIposuKbhX30,'
+                                 'shaxxx-190=HZbuOlKbWl.eR8AfIposuKbhX30',
+
+        # missing sha-1 alg
+        '$scram$4096$QSXCR.Q6sek8bf92$sha-256=HZbuOlKbWl.eR8AfIposuKbhX30',
+
+        # non-iana name
+        '$scram$4096$QSXCR.Q6sek8bf92$sha1=HZbuOlKbWl.eR8AfIposuKbhX30',
+    ]
+
+    def setUp(self):
+        super(scram_test, self).setUp()
+
+        # some platforms lack stringprep (e.g. Jython, IronPython)
+        self.require_stringprep()
+
+        # silence norm_hash_name() warning
+        warnings.filterwarnings("ignore", r"norm_hash_name\(\): unknown hash")
+
+    def test_90_algs(self):
+        """test parsing of 'algs' setting"""
+        defaults = dict(salt=b'A'*10, rounds=1000)
+        def parse(algs, **kwds):
+            for k in defaults:
+                kwds.setdefault(k, defaults[k])
+            return self.handler(algs=algs, **kwds).algs
+
+        # None -> default list
+        self.assertEqual(parse(None, use_defaults=True), hash.scram.default_algs)
+        self.assertRaises(TypeError, parse, None)
+
+        # strings should be parsed
+        self.assertEqual(parse("sha1"), ["sha-1"])
+        self.assertEqual(parse("sha1, sha256, md5"), ["md5","sha-1","sha-256"])
+
+        # lists should be normalized
+        self.assertEqual(parse(["sha-1","sha256"]), ["sha-1","sha-256"])
+
+        # sha-1 required
+        self.assertRaises(ValueError, parse, ["sha-256"])
+        self.assertRaises(ValueError, parse, algs=[], use_defaults=True)
+
+        # alg names must be < 10 chars
+        self.assertRaises(ValueError, parse, ["sha-1","shaxxx-190"])
+
+        # alg & checksum mutually exclusive.
+        self.assertRaises(RuntimeError, parse, ['sha-1'],
+                          checksum={"sha-1": b"\x00"*20})
+
+    def test_90_checksums(self):
+        """test internal parsing of 'checksum' keyword"""
+        # check non-bytes checksum values are rejected
+        self.assertRaises(TypeError, self.handler, use_defaults=True,
+                          checksum={'sha-1':  u('X')*20})
+
+        # check sha-1 is required
+        self.assertRaises(ValueError, self.handler, use_defaults=True,
+                          checksum={'sha-256':  b'X'*32})
+
+        # XXX: anything else that's not tested by the other code already?
+
+    def test_91_extract_digest_info(self):
+        """test scram.extract_digest_info()"""
+        edi = self.handler.extract_digest_info
+
+        # return appropriate value or throw KeyError
+        h = "$scram$10$AAAAAA$sha-1=AQ,bbb=Ag,ccc=Aw"
+        s = b'\x00'*4
+        self.assertEqual(edi(h,"SHA1"), (s,10, b'\x01'))
+        self.assertEqual(edi(h,"bbb"), (s,10, b'\x02'))
+        self.assertEqual(edi(h,"ccc"), (s,10, b'\x03'))
+        self.assertRaises(KeyError, edi, h, "ddd")
+
+        # config strings should cause value error.
+        c = "$scram$10$....$sha-1,bbb,ccc"
+        self.assertRaises(ValueError, edi, c, "sha-1")
+        self.assertRaises(ValueError, edi, c, "bbb")
+        self.assertRaises(ValueError, edi, c, "ddd")
+
+    def test_92_extract_digest_algs(self):
+        """test scram.extract_digest_algs()"""
+        eda = self.handler.extract_digest_algs
+
+        self.assertEqual(eda('$scram$4096$QSXCR.Q6sek8bf92$'
+                   'sha-1=HZbuOlKbWl.eR8AfIposuKbhX30'), ["sha-1"])
+
+        self.assertEqual(eda('$scram$4096$QSXCR.Q6sek8bf92$'
+                   'sha-1=HZbuOlKbWl.eR8AfIposuKbhX30', format="hashlib"),
+                         ["sha1"])
+
+        self.assertEqual(eda('$scram$4096$QSXCR.Q6sek8bf92$'
+                   'sha-1=HZbuOlKbWl.eR8AfIposuKbhX30,'
+                   'sha-256=qXUXrlcvnaxxWG00DdRgVioR2gnUpuX5r.3EZ1rdhVY,'
+                   'sha-512=lzgniLFcvglRLS0gt.C4gy.NurS3OIOVRAU1zZOV4P.qFiVFO2/'
+                       'edGQSu/kD1LwdX0SNV/KsPdHSwEl5qRTuZQ'),
+                          ["sha-1","sha-256","sha-512"])
+
+    def test_93_derive_digest(self):
+        """test scram.derive_digest()"""
+        # NOTE: this just does a light test, since derive_digest
+        # is used by hash / verify, and is tested pretty well via those.
+        hash = self.handler.derive_digest
+
+        # check various encodings of password work.
+        s1 = b'\x01\x02\x03'
+        d1 = b'\xb2\xfb\xab\x82[tNuPnI\x8aZZ\x19\x87\xcen\xe9\xd3'
+        self.assertEqual(hash(u("\u2168"), s1, 1000, 'sha-1'), d1)
+        self.assertEqual(hash(b"\xe2\x85\xa8", s1, 1000, 'SHA-1'), d1)
+        self.assertEqual(hash(u("IX"), s1, 1000, 'sha1'), d1)
+        self.assertEqual(hash(b"IX", s1, 1000, 'SHA1'), d1)
+
+        # check algs
+        self.assertEqual(hash("IX", s1, 1000, 'md5'),
+                         b'3\x19\x18\xc0\x1c/\xa8\xbf\xe4\xa3\xc2\x8eM\xe8od')
+        self.assertRaises(ValueError, hash, "IX", s1, 1000, 'sha-666')
+
+        # check rounds
+        self.assertRaises(ValueError, hash, "IX", s1, 0, 'sha-1')
+
+        # unicode salts accepted as of passlib 1.7 (previous caused TypeError)
+        self.assertEqual(hash(u("IX"), s1.decode("latin-1"), 1000, 'sha1'), d1)
+
+    def test_94_saslprep(self):
+        """test hash/verify use saslprep"""
+        # NOTE: this just does a light test that saslprep() is being
+        # called in various places, relying in saslpreps()'s tests
+        # to verify full normalization behavior.
+
+        # hash unnormalized
+        h = self.do_encrypt(u("I\u00ADX"))
+        self.assertTrue(self.do_verify(u("IX"), h))
+        self.assertTrue(self.do_verify(u("\u2168"), h))
+
+        # hash normalized
+        h = self.do_encrypt(u("\xF3"))
+        self.assertTrue(self.do_verify(u("o\u0301"), h))
+        self.assertTrue(self.do_verify(u("\u200Do\u0301"), h))
+
+        # throws error if forbidden char provided
+        self.assertRaises(ValueError, self.do_encrypt, u("\uFDD0"))
+        self.assertRaises(ValueError, self.do_verify, u("\uFDD0"), h)
+
+    def test_94_using_w_default_algs(self, param="default_algs"):
+        """using() -- 'default_algs' parameter"""
+        # create subclass
+        handler = self.handler
+        orig = list(handler.default_algs) # in case it's modified in place
+        subcls = handler.using(**{param: "sha1,md5"})
+
+        # shouldn't have changed handler
+        self.assertEqual(handler.default_algs, orig)
+
+        # should have own set
+        self.assertEqual(subcls.default_algs, ["md5", "sha-1"])
+
+        # test hash output
+        h1 = subcls.hash("dummy")
+        self.assertEqual(handler.extract_digest_algs(h1), ["md5", "sha-1"])
+
+    def test_94_using_w_algs(self):
+        """using() -- 'algs' parameter"""
+        self.test_94_using_w_default_algs(param="algs")
+
+    def test_94_needs_update_algs(self):
+        """needs_update() -- algs setting"""
+        handler1 = self.handler.using(algs="sha1,md5")
+
+        # shouldn't need update, has same algs
+        h1 = handler1.hash("dummy")
+        self.assertFalse(handler1.needs_update(h1))
+
+        # *currently* shouldn't need update, has superset of algs required by handler2
+        # (may change this policy)
+        handler2 = handler1.using(algs="sha1")
+        self.assertFalse(handler2.needs_update(h1))
+
+        # should need update, doesn't have all algs required by handler3
+        handler3 = handler1.using(algs="sha1,sha256")
+        self.assertTrue(handler3.needs_update(h1))
+
+    def test_95_context_algs(self):
+        """test handling of 'algs' in context object"""
+        handler = self.handler
+        from passlib.context import CryptContext
+        c1 = CryptContext(["scram"], scram__algs="sha1,md5")
+
+        h = c1.hash("dummy")
+        self.assertEqual(handler.extract_digest_algs(h), ["md5", "sha-1"])
+        self.assertFalse(c1.needs_update(h))
+
+        c2 = c1.copy(scram__algs="sha1")
+        self.assertFalse(c2.needs_update(h))
+
+        c2 = c1.copy(scram__algs="sha1,sha256")
+        self.assertTrue(c2.needs_update(h))
+
+    def test_96_full_verify(self):
+        """test verify(full=True) flag"""
+        def vpart(s, h):
+            return self.handler.verify(s, h)
+        def vfull(s, h):
+            return self.handler.verify(s, h, full=True)
+
+        # reference
+        h = ('$scram$4096$QSXCR.Q6sek8bf92$'
+             'sha-1=HZbuOlKbWl.eR8AfIposuKbhX30,'
+             'sha-256=qXUXrlcvnaxxWG00DdRgVioR2gnUpuX5r.3EZ1rdhVY,'
+             'sha-512=lzgniLFcvglRLS0gt.C4gy.NurS3OIOVRAU1zZOV4P.qFiVFO2/'
+                'edGQSu/kD1LwdX0SNV/KsPdHSwEl5qRTuZQ')
+        self.assertTrue(vfull('pencil', h))
+        self.assertFalse(vfull('tape', h))
+
+        # catch truncated digests.
+        h = ('$scram$4096$QSXCR.Q6sek8bf92$'
+             'sha-1=HZbuOlKbWl.eR8AfIposuKbhX30,'
+             'sha-256=qXUXrlcvnaxxWG00DdRgVioR2gnUpuX5r.3EZ1rdhV,' # -1 char
+             'sha-512=lzgniLFcvglRLS0gt.C4gy.NurS3OIOVRAU1zZOV4P.qFiVFO2/'
+                'edGQSu/kD1LwdX0SNV/KsPdHSwEl5qRTuZQ')
+        self.assertRaises(ValueError, vfull, 'pencil', h)
+
+        # catch padded digests.
+        h = ('$scram$4096$QSXCR.Q6sek8bf92$'
+             'sha-1=HZbuOlKbWl.eR8AfIposuKbhX30,'
+             'sha-256=qXUXrlcvnaxxWG00DdRgVioR2gnUpuX5r.3EZ1rdhVYa,' # +1 char
+             'sha-512=lzgniLFcvglRLS0gt.C4gy.NurS3OIOVRAU1zZOV4P.qFiVFO2/'
+                'edGQSu/kD1LwdX0SNV/KsPdHSwEl5qRTuZQ')
+        self.assertRaises(ValueError, vfull, 'pencil', h)
+
+        # catch hash containing digests belonging to diff passwords.
+        # proper behavior for quick-verify (the default) is undefined,
+        # but full-verify should throw error.
+        h = ('$scram$4096$QSXCR.Q6sek8bf92$'
+             'sha-1=HZbuOlKbWl.eR8AfIposuKbhX30,' # 'pencil'
+             'sha-256=R7RJDWIbeKRTFwhE9oxh04kab0CllrQ3kCcpZUcligc,' # 'tape'
+             'sha-512=lzgniLFcvglRLS0gt.C4gy.NurS3OIOVRAU1zZOV4P.qFiVFO2/' # 'pencil'
+                'edGQSu/kD1LwdX0SNV/KsPdHSwEl5qRTuZQ')
+        self.assertTrue(vpart('tape', h))
+        self.assertFalse(vpart('pencil', h))
+        self.assertRaises(ValueError, vfull, 'pencil', h)
+        self.assertRaises(ValueError, vfull, 'tape', h)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_scrypt.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_scrypt.py
new file mode 100644
index 0000000..5ab6d9f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_handlers_scrypt.py
@@ -0,0 +1,111 @@
+"""passlib.tests.test_handlers - tests for passlib hash algorithms"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import logging; log = logging.getLogger(__name__)
+import warnings
+warnings.filterwarnings("ignore", ".*using builtin scrypt backend.*")
+# site
+# pkg
+from passlib import hash
+from passlib.tests.utils import HandlerCase, TEST_MODE
+from passlib.tests.test_handlers import UPASS_TABLE, PASS_TABLE_UTF8
+# module
+
+#=============================================================================
+# scrypt hash
+#=============================================================================
+class _scrypt_test(HandlerCase):
+    handler = hash.scrypt
+
+    known_correct_hashes = [
+        #
+        # excepted from test vectors from scrypt whitepaper
+        # (http://www.tarsnap.com/scrypt/scrypt.pdf, appendix b),
+        # and encoded using passlib's custom format
+        #
+
+        # salt=b""
+        ("", "$scrypt$ln=4,r=1,p=1$$d9ZXYjhleyA7GcpCwYoEl/FrSETjB0ro39/6P+3iFEI"),
+
+        # salt=b"NaCl"
+        ("password", "$scrypt$ln=10,r=8,p=16$TmFDbA$/bq+HJ00cgB4VucZDQHp/nxq18vII3gw53N2Y0s3MWI"),
+
+        #
+        # custom
+        #
+
+        # simple test
+        ("test", '$scrypt$ln=8,r=8,p=1$wlhLyXmP8b53bm1NKYVQqg$mTpvG8lzuuDk+DWz8HZIB6Vum6erDuUm0As5yU+VxWA'),
+
+        # different block value
+        ("password", '$scrypt$ln=8,r=2,p=1$dO6d0xoDoLT2PofQGoNQag$g/Wf2A0vhHhaJM+addK61QPBthSmYB6uVTtQzh8CM3o'),
+
+        # different rounds
+        (UPASS_TABLE, '$scrypt$ln=7,r=8,p=1$jjGmtDamdA4BQAjBeA9BSA$OiWRHhQtpDx7M/793x6UXK14AD512jg/qNm/hkWZG4M'),
+
+        # alt encoding
+        (PASS_TABLE_UTF8, '$scrypt$ln=7,r=8,p=1$jjGmtDamdA4BQAjBeA9BSA$OiWRHhQtpDx7M/793x6UXK14AD512jg/qNm/hkWZG4M'),
+
+        # diff block & parallel counts as well
+        ("nacl", '$scrypt$ln=1,r=4,p=2$yhnD+J+Tci4lZCwFgHCuVQ$fAsEWmxSHuC0cHKMwKVFPzrQukgvK09Sj+NueTSxKds')
+    ]
+
+    if TEST_MODE("full"):
+        # add some hashes with larger rounds value.
+        known_correct_hashes.extend([
+            #
+            # from scrypt whitepaper
+            #
+
+            # salt=b"SodiumChloride"
+            ("pleaseletmein", "$scrypt$ln=14,r=8,p=1$U29kaXVtQ2hsb3JpZGU"
+                              "$cCO9yzr9c0hGHAbNgf046/2o+7qQT44+qbVD9lRdofI"),
+
+            #
+            # openwall format (https://gitlab.com/jas/scrypt-unix-crypt/blob/master/unix-scrypt.txt)
+            #
+            ("pleaseletmein",
+             "$7$C6..../....SodiumChloride$kBGj9fHznVYFQMEn/qDCfrDevf9YDtcDdKvEqHJLV8D"),
+
+        ])
+
+    known_malformed_hashes = [
+        # missing 'p' value
+        '$scrypt$ln=10,r=1$wvif8/4fg1Cq9V7L2dv73w$bJcLia1lyfQ1X2x0xflehwVXPzWIUQWWdnlGwfVzBeQ',
+
+        # rounds too low
+        '$scrypt$ln=0,r=1,p=1$wvif8/4fg1Cq9V7L2dv73w$bJcLia1lyfQ1X2x0xflehwVXPzWIUQWWdnlGwfVzBeQ',
+
+        # invalid block size
+        '$scrypt$ln=10,r=A,p=1$wvif8/4fg1Cq9V7L2dv73w$bJcLia1lyfQ1X2x0xflehwVXPzWIUQWWdnlGwfVzBeQ',
+
+        # r*p too large
+        '$scrypt$ln=10,r=134217728,p=8$wvif8/4fg1Cq9V7L2dv73w$bJcLia1lyfQ1X2x0xflehwVXPzWIUQWWdnlGwfVzBeQ',
+    ]
+
+    def setUpWarnings(self):
+        super(_scrypt_test, self).setUpWarnings()
+        warnings.filterwarnings("ignore", ".*using builtin scrypt backend.*")
+
+    def populate_settings(self, kwds):
+        # builtin is still just way too slow.
+        if self.backend == "builtin":
+            kwds.setdefault("rounds", 6)
+        super(_scrypt_test, self).populate_settings(kwds)
+
+    class FuzzHashGenerator(HandlerCase.FuzzHashGenerator):
+
+        def random_rounds(self):
+            # decrease default rounds for fuzz testing to speed up volume.
+            return self.randintgauss(4, 10, 6, 1)
+
+# create test cases for specific backends
+scrypt_stdlib_test = _scrypt_test.create_backend_case("stdlib")
+scrypt_scrypt_test = _scrypt_test.create_backend_case("scrypt")
+scrypt_builtin_test = _scrypt_test.create_backend_case("builtin")
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_hosts.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_hosts.py
new file mode 100644
index 0000000..cbf93ab
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_hosts.py
@@ -0,0 +1,97 @@
+"""test passlib.hosts"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib import hosts, hash as hashmod
+from passlib.utils import unix_crypt_schemes
+from passlib.tests.utils import TestCase
+# module
+
+#=============================================================================
+# test predefined app contexts
+#=============================================================================
+class HostsTest(TestCase):
+    """perform general tests to make sure contexts work"""
+    # NOTE: these tests are not really comprehensive,
+    #       since they would do little but duplicate
+    #       the presets in apps.py
+    #
+    #       they mainly try to ensure no typos
+    #       or dynamic behavior foul-ups.
+
+    def check_unix_disabled(self, ctx):
+        for hash in [
+            "",
+            "!",
+            "*",
+            "!$1$TXl/FX/U$BZge.lr.ux6ekjEjxmzwz0",
+        ]:
+            self.assertEqual(ctx.identify(hash), 'unix_disabled')
+            self.assertFalse(ctx.verify('test', hash))
+
+    def test_linux_context(self):
+        ctx = hosts.linux_context
+        for hash in [
+            ('$6$rounds=41128$VoQLvDjkaZ6L6BIE$4pt.1Ll1XdDYduEwEYPCMOBiR6W6'
+                'znsyUEoNlcVXpv2gKKIbQolgmTGe6uEEVJ7azUxuc8Tf7zV9SD2z7Ij751'),
+            ('$5$rounds=31817$iZGmlyBQ99JSB5n6$p4E.pdPBWx19OajgjLRiOW0itGny'
+                 'xDGgMlDcOsfaI17'),
+            '$1$TXl/FX/U$BZge.lr.ux6ekjEjxmzwz0',
+            'kAJJz.Rwp0A/I',
+        ]:
+            self.assertTrue(ctx.verify("test", hash))
+        self.check_unix_disabled(ctx)
+
+    def test_bsd_contexts(self):
+        for ctx in [
+            hosts.freebsd_context,
+            hosts.openbsd_context,
+            hosts.netbsd_context,
+        ]:
+            for hash in [
+                '$1$TXl/FX/U$BZge.lr.ux6ekjEjxmzwz0',
+                'kAJJz.Rwp0A/I',
+            ]:
+                self.assertTrue(ctx.verify("test", hash))
+            h1 = "$2a$04$yjDgE74RJkeqC0/1NheSSOrvKeu9IbKDpcQf/Ox3qsrRS/Kw42qIS"
+            if hashmod.bcrypt.has_backend():
+                self.assertTrue(ctx.verify("test", h1))
+            else:
+                self.assertEqual(ctx.identify(h1), "bcrypt")
+            self.check_unix_disabled(ctx)
+
+    def test_host_context(self):
+        ctx = getattr(hosts, "host_context", None)
+        if not ctx:
+            return self.skipTest("host_context not available on this platform")
+
+        # validate schemes is non-empty,
+        # and contains unix_disabled + at least one real scheme
+        schemes = list(ctx.schemes())
+        self.assertTrue(schemes, "appears to be unix system, but no known schemes supported by crypt")
+        self.assertTrue('unix_disabled' in schemes)
+        schemes.remove("unix_disabled")
+        self.assertTrue(schemes, "should have schemes beside fallback scheme")
+        self.assertTrue(set(unix_crypt_schemes).issuperset(schemes))
+
+        # check for hash support
+        self.check_unix_disabled(ctx)
+        for scheme, hash in [
+            ("sha512_crypt", ('$6$rounds=41128$VoQLvDjkaZ6L6BIE$4pt.1Ll1XdDYduEwEYPCMOBiR6W6'
+                'znsyUEoNlcVXpv2gKKIbQolgmTGe6uEEVJ7azUxuc8Tf7zV9SD2z7Ij751')),
+            ("sha256_crypt", ('$5$rounds=31817$iZGmlyBQ99JSB5n6$p4E.pdPBWx19OajgjLRiOW0itGny'
+                 'xDGgMlDcOsfaI17')),
+            ("md5_crypt", '$1$TXl/FX/U$BZge.lr.ux6ekjEjxmzwz0'),
+            ("des_crypt", 'kAJJz.Rwp0A/I'),
+        ]:
+            if scheme in schemes:
+                self.assertTrue(ctx.verify("test", hash))
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_pwd.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_pwd.py
new file mode 100644
index 0000000..2c983cd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_pwd.py
@@ -0,0 +1,205 @@
+"""passlib.tests -- tests for passlib.pwd"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import itertools
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.tests.utils import TestCase
+# local
+__all__ = [
+    "UtilsTest",
+    "GenerateTest",
+    "StrengthTest",
+]
+
+#=============================================================================
+#
+#=============================================================================
+class UtilsTest(TestCase):
+    """test internal utilities"""
+    descriptionPrefix = "passlib.pwd"
+
+    def test_self_info_rate(self):
+        """_self_info_rate()"""
+        from passlib.pwd import _self_info_rate
+
+        self.assertEqual(_self_info_rate(""), 0)
+
+        self.assertEqual(_self_info_rate("a" * 8), 0)
+
+        self.assertEqual(_self_info_rate("ab"), 1)
+        self.assertEqual(_self_info_rate("ab" * 8), 1)
+
+        self.assertEqual(_self_info_rate("abcd"), 2)
+        self.assertEqual(_self_info_rate("abcd" * 8), 2)
+        self.assertAlmostEqual(_self_info_rate("abcdaaaa"), 1.5488, places=4)
+
+    # def test_total_self_info(self):
+    #     """_total_self_info()"""
+    #     from passlib.pwd import _total_self_info
+    #
+    #     self.assertEqual(_total_self_info(""), 0)
+    #
+    #     self.assertEqual(_total_self_info("a" * 8), 0)
+    #
+    #     self.assertEqual(_total_self_info("ab"), 2)
+    #     self.assertEqual(_total_self_info("ab" * 8), 16)
+    #
+    #     self.assertEqual(_total_self_info("abcd"), 8)
+    #     self.assertEqual(_total_self_info("abcd" * 8), 64)
+    #     self.assertAlmostEqual(_total_self_info("abcdaaaa"), 12.3904, places=4)
+
+#=============================================================================
+# word generation
+#=============================================================================
+
+# import subject
+from passlib.pwd import genword, default_charsets
+ascii_62 = default_charsets['ascii_62']
+hex = default_charsets['hex']
+
+class WordGeneratorTest(TestCase):
+    """test generation routines"""
+    descriptionPrefix = "passlib.pwd.genword()"
+
+    def setUp(self):
+        super(WordGeneratorTest, self).setUp()
+
+        # patch some RNG references so they're reproducible.
+        from passlib.pwd import SequenceGenerator
+        self.patchAttr(SequenceGenerator, "rng",
+                       self.getRandom("pwd generator"))
+
+    def assertResultContents(self, results, count, chars, unique=True):
+        """check result list matches expected count & charset"""
+        self.assertEqual(len(results), count)
+        if unique:
+            if unique is True:
+                unique = count
+            self.assertEqual(len(set(results)), unique)
+        self.assertEqual(set("".join(results)), set(chars))
+
+    def test_general(self):
+        """general behavior"""
+
+        # basic usage
+        result = genword()
+        self.assertEqual(len(result), 9)
+
+        # malformed keyword should have useful error.
+        self.assertRaisesRegex(TypeError, "(?i)unexpected keyword.*badkwd", genword, badkwd=True)
+
+    def test_returns(self):
+        """'returns' keyword"""
+        # returns=int option
+        results = genword(returns=5000)
+        self.assertResultContents(results, 5000, ascii_62)
+
+        # returns=iter option
+        gen = genword(returns=iter)
+        results = [next(gen) for _ in range(5000)]
+        self.assertResultContents(results, 5000, ascii_62)
+
+        # invalid returns option
+        self.assertRaises(TypeError, genword, returns='invalid-type')
+
+    def test_charset(self):
+        """'charset' & 'chars' options"""
+        # charset option
+        results = genword(charset="hex", returns=5000)
+        self.assertResultContents(results, 5000, hex)
+
+        # chars option
+        # there are 3**3=27 possible combinations
+        results = genword(length=3, chars="abc", returns=5000)
+        self.assertResultContents(results, 5000, "abc", unique=27)
+
+        # chars + charset
+        self.assertRaises(TypeError, genword, chars='abc', charset='hex')
+
+    # TODO: test rng option
+
+#=============================================================================
+# phrase generation
+#=============================================================================
+
+# import subject
+from passlib.pwd import genphrase
+simple_words = ["alpha", "beta", "gamma"]
+
+class PhraseGeneratorTest(TestCase):
+    """test generation routines"""
+    descriptionPrefix = "passlib.pwd.genphrase()"
+
+    def assertResultContents(self, results, count, words, unique=True, sep=" "):
+        """check result list matches expected count & charset"""
+        self.assertEqual(len(results), count)
+        if unique:
+            if unique is True:
+                unique = count
+            self.assertEqual(len(set(results)), unique)
+        out = set(itertools.chain.from_iterable(elem.split(sep) for elem in results))
+        self.assertEqual(out, set(words))
+
+    def test_general(self):
+        """general behavior"""
+
+        # basic usage
+        result = genphrase()
+        self.assertEqual(len(result.split(" ")), 4)  # 48 / log(7776, 2) ~= 3.7 -> 4
+
+        # malformed keyword should have useful error.
+        self.assertRaisesRegex(TypeError, "(?i)unexpected keyword.*badkwd", genphrase, badkwd=True)
+
+    def test_entropy(self):
+        """'length' & 'entropy' keywords"""
+
+        # custom entropy
+        result = genphrase(entropy=70)
+        self.assertEqual(len(result.split(" ")), 6)  # 70 / log(7776, 2) ~= 5.4 -> 6
+
+        # custom length
+        result = genphrase(length=3)
+        self.assertEqual(len(result.split(" ")), 3)
+
+        # custom length < entropy
+        result = genphrase(length=3, entropy=48)
+        self.assertEqual(len(result.split(" ")), 4)
+
+        # custom length > entropy
+        result = genphrase(length=4, entropy=12)
+        self.assertEqual(len(result.split(" ")), 4)
+
+    def test_returns(self):
+        """'returns' keyword"""
+        # returns=int option
+        results = genphrase(returns=1000, words=simple_words)
+        self.assertResultContents(results, 1000, simple_words)
+
+        # returns=iter option
+        gen = genphrase(returns=iter, words=simple_words)
+        results = [next(gen) for _ in range(1000)]
+        self.assertResultContents(results, 1000, simple_words)
+
+        # invalid returns option
+        self.assertRaises(TypeError, genphrase, returns='invalid-type')
+
+    def test_wordset(self):
+        """'wordset' & 'words' options"""
+        # wordset option
+        results = genphrase(words=simple_words, returns=5000)
+        self.assertResultContents(results, 5000, simple_words)
+
+        # words option
+        results = genphrase(length=3, words=simple_words, returns=5000)
+        self.assertResultContents(results, 5000, simple_words, unique=3**3)
+
+        # words + wordset
+        self.assertRaises(TypeError, genphrase, words=simple_words, wordset='bip39')
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_registry.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_registry.py
new file mode 100644
index 0000000..8cec48d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_registry.py
@@ -0,0 +1,228 @@
+"""tests for passlib.hash -- (c) Assurance Technologies 2003-2009"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+from logging import getLogger
+import warnings
+import sys
+# site
+# pkg
+from passlib import hash, registry, exc
+from passlib.registry import register_crypt_handler, register_crypt_handler_path, \
+    get_crypt_handler, list_crypt_handlers, _unload_handler_name as unload_handler_name
+import passlib.utils.handlers as uh
+from passlib.tests.utils import TestCase
+# module
+log = getLogger(__name__)
+
+#=============================================================================
+# dummy handlers
+#
+# NOTE: these are defined outside of test case
+#       since they're used by test_register_crypt_handler_path(),
+#       which needs them to be available as module globals.
+#=============================================================================
+class dummy_0(uh.StaticHandler):
+    name = "dummy_0"
+
+class alt_dummy_0(uh.StaticHandler):
+    name = "dummy_0"
+
+dummy_x = 1
+
+#=============================================================================
+# test registry
+#=============================================================================
+class RegistryTest(TestCase):
+
+    descriptionPrefix = "passlib.registry"
+
+    def setUp(self):
+        super(RegistryTest, self).setUp()
+
+        # backup registry state & restore it after test.
+        locations = dict(registry._locations)
+        handlers = dict(registry._handlers)
+        def restore():
+            registry._locations.clear()
+            registry._locations.update(locations)
+            registry._handlers.clear()
+            registry._handlers.update(handlers)
+        self.addCleanup(restore)
+
+    def test_hash_proxy(self):
+        """test passlib.hash proxy object"""
+        # check dir works
+        dir(hash)
+
+        # check repr works
+        repr(hash)
+
+        # check non-existent attrs raise error
+        self.assertRaises(AttributeError, getattr, hash, 'fooey')
+
+        # GAE tries to set __loader__,
+        # make sure that doesn't call register_crypt_handler.
+        old = getattr(hash, "__loader__", None)
+        test = object()
+        hash.__loader__ = test
+        self.assertIs(hash.__loader__, test)
+        if old is None:
+            del hash.__loader__
+            self.assertFalse(hasattr(hash, "__loader__"))
+        else:
+            hash.__loader__ = old
+            self.assertIs(hash.__loader__, old)
+
+        # check storing attr calls register_crypt_handler
+        class dummy_1(uh.StaticHandler):
+            name = "dummy_1"
+        hash.dummy_1 = dummy_1
+        self.assertIs(get_crypt_handler("dummy_1"), dummy_1)
+
+        # check storing under wrong name results in error
+        self.assertRaises(ValueError, setattr, hash, "dummy_1x", dummy_1)
+
+    def test_register_crypt_handler_path(self):
+        """test register_crypt_handler_path()"""
+        # NOTE: this messes w/ internals of registry, shouldn't be used publically.
+        paths = registry._locations
+
+        # check namespace is clear
+        self.assertTrue('dummy_0' not in paths)
+        self.assertFalse(hasattr(hash, 'dummy_0'))
+
+        # check invalid names are rejected
+        self.assertRaises(ValueError, register_crypt_handler_path,
+                          "dummy_0", ".test_registry")
+        self.assertRaises(ValueError, register_crypt_handler_path,
+                          "dummy_0", __name__ + ":dummy_0:xxx")
+        self.assertRaises(ValueError, register_crypt_handler_path,
+                          "dummy_0", __name__ + ":dummy_0.xxx")
+
+        # try lazy load
+        register_crypt_handler_path('dummy_0', __name__)
+        self.assertTrue('dummy_0' in list_crypt_handlers())
+        self.assertTrue('dummy_0' not in list_crypt_handlers(loaded_only=True))
+        self.assertIs(hash.dummy_0, dummy_0)
+        self.assertTrue('dummy_0' in list_crypt_handlers(loaded_only=True))
+        unload_handler_name('dummy_0')
+
+        # try lazy load w/ alt
+        register_crypt_handler_path('dummy_0', __name__ + ':alt_dummy_0')
+        self.assertIs(hash.dummy_0, alt_dummy_0)
+        unload_handler_name('dummy_0')
+
+        # check lazy load w/ wrong type fails
+        register_crypt_handler_path('dummy_x', __name__)
+        self.assertRaises(TypeError, get_crypt_handler, 'dummy_x')
+
+        # check lazy load w/ wrong name fails
+        register_crypt_handler_path('alt_dummy_0', __name__)
+        self.assertRaises(ValueError, get_crypt_handler, "alt_dummy_0")
+        unload_handler_name("alt_dummy_0")
+
+        # TODO: check lazy load which calls register_crypt_handler (warning should be issued)
+        sys.modules.pop("passlib.tests._test_bad_register", None)
+        register_crypt_handler_path("dummy_bad", "passlib.tests._test_bad_register")
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", "xxxxxxxxxx", DeprecationWarning)
+            h = get_crypt_handler("dummy_bad")
+        from passlib.tests import _test_bad_register as tbr
+        self.assertIs(h, tbr.alt_dummy_bad)
+
+    def test_register_crypt_handler(self):
+        """test register_crypt_handler()"""
+
+        self.assertRaises(TypeError, register_crypt_handler, {})
+
+        self.assertRaises(ValueError, register_crypt_handler, type('x', (uh.StaticHandler,), dict(name=None)))
+        self.assertRaises(ValueError, register_crypt_handler, type('x', (uh.StaticHandler,), dict(name="AB_CD")))
+        self.assertRaises(ValueError, register_crypt_handler, type('x', (uh.StaticHandler,), dict(name="ab-cd")))
+        self.assertRaises(ValueError, register_crypt_handler, type('x', (uh.StaticHandler,), dict(name="ab__cd")))
+        self.assertRaises(ValueError, register_crypt_handler, type('x', (uh.StaticHandler,), dict(name="default")))
+
+        class dummy_1(uh.StaticHandler):
+            name = "dummy_1"
+
+        class dummy_1b(uh.StaticHandler):
+            name = "dummy_1"
+
+        self.assertTrue('dummy_1' not in list_crypt_handlers())
+
+        register_crypt_handler(dummy_1)
+        register_crypt_handler(dummy_1)
+        self.assertIs(get_crypt_handler("dummy_1"), dummy_1)
+
+        self.assertRaises(KeyError, register_crypt_handler, dummy_1b)
+        self.assertIs(get_crypt_handler("dummy_1"), dummy_1)
+
+        register_crypt_handler(dummy_1b, force=True)
+        self.assertIs(get_crypt_handler("dummy_1"), dummy_1b)
+
+        self.assertTrue('dummy_1' in list_crypt_handlers())
+
+    def test_get_crypt_handler(self):
+        """test get_crypt_handler()"""
+
+        class dummy_1(uh.StaticHandler):
+            name = "dummy_1"
+
+        # without available handler
+        self.assertRaises(KeyError, get_crypt_handler, "dummy_1")
+        self.assertIs(get_crypt_handler("dummy_1", None), None)
+
+        # already loaded handler
+        register_crypt_handler(dummy_1)
+        self.assertIs(get_crypt_handler("dummy_1"), dummy_1)
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", "handler names should be lower-case, and use underscores instead of hyphens:.*", UserWarning)
+
+            # already loaded handler, using incorrect name
+            self.assertIs(get_crypt_handler("DUMMY-1"), dummy_1)
+
+            # lazy load of unloaded handler, using incorrect name
+            register_crypt_handler_path('dummy_0', __name__)
+            self.assertIs(get_crypt_handler("DUMMY-0"), dummy_0)
+
+        # check system & private names aren't returned
+        from passlib import hash
+        hash.__dict__["_fake"] = "dummy"
+        for name in ["_fake", "__package__"]:
+            self.assertRaises(KeyError, get_crypt_handler, name)
+            self.assertIs(get_crypt_handler(name, None), None)
+
+    def test_list_crypt_handlers(self):
+        """test list_crypt_handlers()"""
+        from passlib.registry import list_crypt_handlers
+
+        # check system & private names aren't returned
+        hash.__dict__["_fake"] = "dummy"
+        for name in list_crypt_handlers():
+            self.assertFalse(name.startswith("_"), "%r: " % name)
+        unload_handler_name("_fake")
+
+    def test_handlers(self):
+        """verify we have tests for all builtin handlers"""
+        from passlib.registry import list_crypt_handlers
+        from passlib.tests.test_handlers import get_handler_case, conditionally_available_hashes
+        for name in list_crypt_handlers():
+            # skip some wrappers that don't need independant testing
+            if name.startswith("ldap_") and name[5:] in list_crypt_handlers():
+                continue
+            if name in ["roundup_plaintext"]:
+                continue
+            # check the remaining ones all have a handler
+            try:
+                self.assertTrue(get_handler_case(name))
+            except exc.MissingBackendError:
+                if name in conditionally_available_hashes: # expected to fail on some setups
+                    continue
+                raise
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_totp.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_totp.py
new file mode 100644
index 0000000..604d2e9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_totp.py
@@ -0,0 +1,1604 @@
+"""passlib.tests -- test passlib.totp"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import datetime
+from functools import partial
+import logging; log = logging.getLogger(__name__)
+import sys
+import time as _time
+# site
+# pkg
+from passlib import exc
+from passlib.utils.compat import unicode, u
+from passlib.tests.utils import TestCase, time_call
+# subject
+from passlib import totp as totp_module
+from passlib.totp import TOTP, AppWallet, AES_SUPPORT
+# local
+__all__ = [
+    "EngineTest",
+]
+
+#=============================================================================
+# helpers
+#=============================================================================
+
+# XXX: python 3 changed what error base64.b16decode() throws, from TypeError to base64.Error().
+#      it wasn't until 3.3 that base32decode() also got changed.
+#      really should normalize this in the code to a single BinaryDecodeError,
+#      predicting this cross-version is getting unmanagable.
+Base32DecodeError = Base16DecodeError = TypeError
+if sys.version_info >= (3,0):
+    from binascii import Error as Base16DecodeError
+if sys.version_info >= (3,3):
+    from binascii import Error as Base32DecodeError
+
+PASS1 = "abcdef"
+PASS2 = b"\x00\xFF"
+KEY1 = '4AOGGDBBQSYHNTUZ'
+KEY1_RAW = b'\xe0\x1cc\x0c!\x84\xb0v\xce\x99'
+KEY2_RAW = b'\xee]\xcb9\x870\x06 D\xc8y/\xa54&\xe4\x9c\x13\xc2\x18'
+KEY3 = 'S3JDVB7QD2R7JPXX' # used in docstrings
+KEY4 = 'JBSWY3DPEHPK3PXP' # from google keyuri spec
+KEY4_RAW = b'Hello!\xde\xad\xbe\xef'
+
+# NOTE: for randtime() below,
+#       * want at least 7 bits on fractional side, to test fractional times to at least 0.01s precision
+#       * want at least 32 bits on integer side, to test for 32-bit epoch issues.
+#       most systems *should* have 53 bit mantissa, leaving plenty of room on both ends,
+#       so using (1<<37) as scale, to allocate 16 bits on fractional side, but generate reasonable # of > 1<<32 times.
+#       sanity check that we're above 44 ensures minimum requirements (44 - 37 int = 7 frac)
+assert sys.float_info.radix == 2, "unexpected float_info.radix"
+assert sys.float_info.mant_dig >= 44, "double precision unexpectedly small"
+
+def _get_max_time_t():
+    """
+    helper to calc max_time_t constant (see below)
+    """
+    value = 1 << 30  # even for 32 bit systems will handle this
+    year = 0
+    while True:
+        next_value = value << 1
+        try:
+            next_year = datetime.datetime.utcfromtimestamp(next_value-1).year
+        except (ValueError, OSError, OverflowError):
+            # utcfromtimestamp() may throw any of the following:
+            #
+            # * year out of range for datetime:
+            #   py < 3.6 throws ValueError.
+            #   (py 3.6.0 returns odd value instead, see workaround below)
+            #
+            # * int out of range for host's gmtime/localtime:
+            #   py2 throws ValueError, py3 throws OSError.
+            #
+            # * int out of range for host's time_t:
+            #   py2 throws ValueError, py3 throws OverflowError.
+            #
+            break
+
+        # Workaround for python 3.6.0 issue --
+        # Instead of throwing ValueError if year out of range for datetime,
+        # Python 3.6 will do some weird behavior that masks high bits
+        # e.g. (1<<40) -> year 36812, but (1<<41) -> year 6118.
+        # (Appears to be bug http://bugs.python.org/issue29100)
+        # This check stops at largest non-wrapping bit size.
+        if next_year < year:
+            break
+
+        value = next_value
+
+    # 'value-1' is maximum.
+    value -= 1
+
+    # check for crazy case where we're beyond what datetime supports
+    # (caused by bug 29100 again). compare to max value that datetime
+    # module supports -- datetime.datetime(9999, 12, 31, 23, 59, 59, 999999)
+    max_datetime_timestamp = 253402318800
+    return min(value, max_datetime_timestamp)
+
+#: Rough approximation of max value acceptable by hosts's time_t.
+#: This is frequently ~2**37 on 64 bit, and ~2**31 on 32 bit systems.
+max_time_t = _get_max_time_t()
+
+def to_b32_size(raw_size):
+    return (raw_size * 8 + 4) // 5
+
+#=============================================================================
+# wallet
+#=============================================================================
+class AppWalletTest(TestCase):
+    descriptionPrefix = "passlib.totp.AppWallet"
+
+    #=============================================================================
+    # constructor
+    #=============================================================================
+
+    def test_secrets_types(self):
+        """constructor -- 'secrets' param -- input types"""
+
+        # no secrets
+        wallet = AppWallet()
+        self.assertEqual(wallet._secrets, {})
+        self.assertFalse(wallet.has_secrets)
+
+        # dict
+        ref = {"1": b"aaa", "2": b"bbb"}
+        wallet = AppWallet(ref)
+        self.assertEqual(wallet._secrets, ref)
+        self.assertTrue(wallet.has_secrets)
+
+        # # list
+        # wallet = AppWallet(list(ref.items()))
+        # self.assertEqual(wallet._secrets, ref)
+
+        # # iter
+        # wallet = AppWallet(iter(ref.items()))
+        # self.assertEqual(wallet._secrets, ref)
+
+        # "tag:value" string
+        wallet = AppWallet("\n 1: aaa\n# comment\n \n2: bbb   ")
+        self.assertEqual(wallet._secrets, ref)
+
+        # ensure ":" allowed in secret
+        wallet = AppWallet("1: aaa: bbb \n# comment\n \n2: bbb   ")
+        self.assertEqual(wallet._secrets, {"1": b"aaa: bbb", "2": b"bbb"})
+
+        # json dict
+        wallet = AppWallet('{"1":"aaa","2":"bbb"}')
+        self.assertEqual(wallet._secrets, ref)
+
+        # # json list
+        # wallet = AppWallet('[["1","aaa"],["2","bbb"]]')
+        # self.assertEqual(wallet._secrets, ref)
+
+        # invalid type
+        self.assertRaises(TypeError, AppWallet, 123)
+
+        # invalid json obj
+        self.assertRaises(TypeError, AppWallet, "[123]")
+
+        # # invalid list items
+        # self.assertRaises(ValueError, AppWallet, ["1", b"aaa"])
+
+        # forbid empty secret
+        self.assertRaises(ValueError, AppWallet, {"1": "aaa", "2": ""})
+
+    def test_secrets_tags(self):
+        """constructor -- 'secrets' param -- tag/value normalization"""
+
+        # test reference
+        ref = {"1": b"aaa", "02": b"bbb", "C": b"ccc"}
+        wallet = AppWallet(ref)
+        self.assertEqual(wallet._secrets, ref)
+
+        # accept unicode
+        wallet = AppWallet({u("1"): b"aaa", u("02"): b"bbb", u("C"): b"ccc"})
+        self.assertEqual(wallet._secrets, ref)
+
+        # normalize int tags
+        wallet = AppWallet({1: b"aaa", "02": b"bbb", "C": b"ccc"})
+        self.assertEqual(wallet._secrets, ref)
+
+        # forbid non-str/int tags
+        self.assertRaises(TypeError, AppWallet, {(1,): "aaa"})
+
+        # accept valid tags
+        wallet = AppWallet({"1-2_3.4": b"aaa"})
+
+        # forbid invalid tags
+        self.assertRaises(ValueError, AppWallet, {"-abc": "aaa"})
+        self.assertRaises(ValueError, AppWallet, {"ab*$": "aaa"})
+
+        # coerce value to bytes
+        wallet = AppWallet({"1": u("aaa"), "02": "bbb", "C": b"ccc"})
+        self.assertEqual(wallet._secrets, ref)
+
+        # forbid invalid value types
+        self.assertRaises(TypeError, AppWallet, {"1": 123})
+        self.assertRaises(TypeError, AppWallet, {"1": None})
+        self.assertRaises(TypeError, AppWallet, {"1": []})
+
+    # TODO: test secrets_path
+
+    def test_default_tag(self):
+        """constructor -- 'default_tag' param"""
+
+        # should sort numerically
+        wallet = AppWallet({"1": "one", "02": "two"})
+        self.assertEqual(wallet.default_tag, "02")
+        self.assertEqual(wallet.get_secret(wallet.default_tag), b"two")
+
+        # should sort alphabetically if non-digit present
+        wallet = AppWallet({"1": "one", "02": "two", "A": "aaa"})
+        self.assertEqual(wallet.default_tag, "A")
+        self.assertEqual(wallet.get_secret(wallet.default_tag), b"aaa")
+
+        # should use honor custom tag
+        wallet = AppWallet({"1": "one", "02": "two", "A": "aaa"}, default_tag="1")
+        self.assertEqual(wallet.default_tag, "1")
+        self.assertEqual(wallet.get_secret(wallet.default_tag), b"one")
+
+        # throw error on unknown value
+        self.assertRaises(KeyError, AppWallet, {"1": "one", "02": "two", "A": "aaa"},
+                          default_tag="B")
+
+        # should be empty
+        wallet = AppWallet()
+        self.assertEqual(wallet.default_tag, None)
+        self.assertRaises(KeyError, wallet.get_secret, None)
+
+    # TODO: test 'cost' param
+
+    #=============================================================================
+    # encrypt_key() & decrypt_key() helpers
+    #=============================================================================
+    def require_aes_support(self, canary=None):
+        if AES_SUPPORT:
+            canary and canary()
+        else:
+            canary and self.assertRaises(RuntimeError, canary)
+            raise self.skipTest("'cryptography' package not installed")
+
+    def test_decrypt_key(self):
+        """.decrypt_key()"""
+
+        wallet = AppWallet({"1": PASS1, "2": PASS2})
+
+        # check for support
+        CIPHER1 = dict(v=1, c=13, s='6D7N7W53O7HHS37NLUFQ',
+                       k='MHCTEGSNPFN5CGBJ', t='1')
+        self.require_aes_support(canary=partial(wallet.decrypt_key, CIPHER1))
+
+        # reference key
+        self.assertEqual(wallet.decrypt_key(CIPHER1)[0], KEY1_RAW)
+
+        # different salt used to encrypt same raw key
+        CIPHER2 = dict(v=1, c=13, s='SPZJ54Y6IPUD2BYA4C6A',
+                       k='ZGDXXTVQOWYLC2AU', t='1')
+        self.assertEqual(wallet.decrypt_key(CIPHER2)[0], KEY1_RAW)
+
+        # different sized key, password, and cost
+        CIPHER3 = dict(v=1, c=8, s='FCCTARTIJWE7CPQHUDKA',
+                       k='D2DRS32YESGHHINWFFCELKN7Z6NAHM4M', t='2')
+        self.assertEqual(wallet.decrypt_key(CIPHER3)[0], KEY2_RAW)
+
+        # wrong password should silently result in wrong key
+        temp = CIPHER1.copy()
+        temp.update(t='2')
+        self.assertEqual(wallet.decrypt_key(temp)[0], b'\xafD6.F7\xeb\x19\x05Q')
+
+        # missing tag should throw error
+        temp = CIPHER1.copy()
+        temp.update(t='3')
+        self.assertRaises(KeyError, wallet.decrypt_key, temp)
+
+        # unknown version should throw error
+        temp = CIPHER1.copy()
+        temp.update(v=999)
+        self.assertRaises(ValueError, wallet.decrypt_key, temp)
+
+    def test_decrypt_key_needs_recrypt(self):
+        """.decrypt_key() -- needs_recrypt flag"""
+        self.require_aes_support()
+
+        wallet = AppWallet({"1": PASS1, "2": PASS2}, encrypt_cost=13)
+
+        # ref should be accepted
+        ref = dict(v=1, c=13, s='AAAA', k='AAAA', t='2')
+        self.assertFalse(wallet.decrypt_key(ref)[1])
+
+        # wrong cost
+        temp = ref.copy()
+        temp.update(c=8)
+        self.assertTrue(wallet.decrypt_key(temp)[1])
+
+        # wrong tag
+        temp = ref.copy()
+        temp.update(t="1")
+        self.assertTrue(wallet.decrypt_key(temp)[1])
+
+        # XXX: should this check salt_size?
+
+    def assertSaneResult(self, result, wallet, key, tag="1",
+                         needs_recrypt=False):
+        """check encrypt_key() result has expected format"""
+
+        self.assertEqual(set(result), set(["v", "t", "c", "s", "k"]))
+
+        self.assertEqual(result['v'], 1)
+        self.assertEqual(result['t'], tag)
+        self.assertEqual(result['c'], wallet.encrypt_cost)
+
+        self.assertEqual(len(result['s']), to_b32_size(wallet.salt_size))
+        self.assertEqual(len(result['k']), to_b32_size(len(key)))
+
+        result_key, result_needs_recrypt = wallet.decrypt_key(result)
+        self.assertEqual(result_key, key)
+        self.assertEqual(result_needs_recrypt, needs_recrypt)
+
+    def test_encrypt_key(self):
+        """.encrypt_key()"""
+
+        # check for support
+        wallet = AppWallet({"1": PASS1}, encrypt_cost=5)
+        self.require_aes_support(canary=partial(wallet.encrypt_key, KEY1_RAW))
+
+        # basic behavior
+        result = wallet.encrypt_key(KEY1_RAW)
+        self.assertSaneResult(result, wallet, KEY1_RAW)
+
+        # creates new salt each time
+        other = wallet.encrypt_key(KEY1_RAW)
+        self.assertSaneResult(result, wallet, KEY1_RAW)
+        self.assertNotEqual(other['s'], result['s'])
+        self.assertNotEqual(other['k'], result['k'])
+
+        # honors custom cost
+        wallet2 = AppWallet({"1": PASS1}, encrypt_cost=6)
+        result = wallet2.encrypt_key(KEY1_RAW)
+        self.assertSaneResult(result, wallet2, KEY1_RAW)
+
+        # honors default tag
+        wallet2 = AppWallet({"1": PASS1, "2": PASS2})
+        result = wallet2.encrypt_key(KEY1_RAW)
+        self.assertSaneResult(result, wallet2, KEY1_RAW, tag="2")
+
+        # honor salt size
+        wallet2 = AppWallet({"1": PASS1})
+        wallet2.salt_size = 64
+        result = wallet2.encrypt_key(KEY1_RAW)
+        self.assertSaneResult(result, wallet2, KEY1_RAW)
+
+        # larger key
+        result = wallet.encrypt_key(KEY2_RAW)
+        self.assertSaneResult(result, wallet, KEY2_RAW)
+
+        # border case: empty key
+        # XXX: might want to allow this, but documenting behavior for now
+        self.assertRaises(ValueError, wallet.encrypt_key, b"")
+
+    def test_encrypt_cost_timing(self):
+        """verify cost parameter via timing"""
+        self.require_aes_support()
+
+        # time default cost
+        wallet = AppWallet({"1": "aaa"})
+        wallet.encrypt_cost -= 2
+        delta, _ = time_call(partial(wallet.encrypt_key, KEY1_RAW), maxtime=0)
+
+        # this should take (2**3=8) times as long
+        wallet.encrypt_cost += 3
+        delta2, _ = time_call(partial(wallet.encrypt_key, KEY1_RAW), maxtime=0)
+
+        # TODO: rework timing test here to inject mock pbkdf2_hmac() function instead;
+        #       and test that it's being invoked w/ proper options.
+        self.assertAlmostEqual(delta2, delta*8, delta=(delta*8)*0.5)
+
+    #=============================================================================
+    # eoc
+    #=============================================================================
+
+#=============================================================================
+# common OTP code
+#=============================================================================
+
+#: used as base value for RFC test vector keys
+RFC_KEY_BYTES_20 = "12345678901234567890".encode("ascii")
+RFC_KEY_BYTES_32 = (RFC_KEY_BYTES_20*2)[:32]
+RFC_KEY_BYTES_64 = (RFC_KEY_BYTES_20*4)[:64]
+
+# TODO: this class is separate from TotpTest due to historical issue,
+#       when there was a base class, and a separate HOTP class.
+#       these test case classes should probably be combined.
+class TotpTest(TestCase):
+    """
+    common code shared by TotpTest & HotpTest
+    """
+    #=============================================================================
+    # class attrs
+    #=============================================================================
+
+    descriptionPrefix = "passlib.totp.TOTP"
+
+    #=============================================================================
+    # setup
+    #=============================================================================
+    def setUp(self):
+        super(TotpTest, self).setUp()
+
+        # clear norm_hash_name() cache so 'unknown hash' warnings get emitted each time
+        from passlib.crypto.digest import lookup_hash
+        lookup_hash.clear_cache()
+
+        # monkeypatch module's rng to be deterministic
+        self.patchAttr(totp_module, "rng", self.getRandom())
+
+    #=============================================================================
+    # general helpers
+    #=============================================================================
+    def randtime(self):
+        """
+        helper to generate random epoch time
+        :returns float: epoch time
+        """
+        return self.getRandom().random() * max_time_t
+
+    def randotp(self, cls=None, **kwds):
+        """
+        helper which generates a random TOTP instance.
+        """
+        rng = self.getRandom()
+        if "key" not in kwds:
+            kwds['new'] = True
+        kwds.setdefault("digits", rng.randint(6, 10))
+        kwds.setdefault("alg", rng.choice(["sha1", "sha256", "sha512"]))
+        kwds.setdefault("period", rng.randint(10, 120))
+        return (cls or TOTP)(**kwds)
+
+    def test_randotp(self):
+        """
+        internal test -- randotp()
+        """
+        otp1 = self.randotp()
+        otp2 = self.randotp()
+
+        self.assertNotEqual(otp1.key, otp2.key, "key not randomized:")
+
+        # NOTE: has (1/5)**10 odds of failure
+        for _ in range(10):
+            if otp1.digits != otp2.digits:
+                break
+            otp2 = self.randotp()
+        else:
+            self.fail("digits not randomized")
+
+        # NOTE: has (1/3)**10 odds of failure
+        for _ in range(10):
+            if otp1.alg != otp2.alg:
+                break
+            otp2 = self.randotp()
+        else:
+            self.fail("alg not randomized")
+
+    #=============================================================================
+    # reference vector helpers
+    #=============================================================================
+
+    #: default options used by test vectors (unless otherwise stated)
+    vector_defaults = dict(format="base32", alg="sha1", period=30, digits=8)
+
+    #: various TOTP test vectors,
+    #: each element in list has format [options, (time, token <, int(expires)>), ...]
+    vectors = [
+
+        #-------------------------------------------------------------------------
+        # passlib test vectors
+        #-------------------------------------------------------------------------
+
+        # 10 byte key, 6 digits
+        [dict(key="ACDEFGHJKL234567", digits=6),
+            # test fencepost to make sure we're rounding right
+            (1412873399, '221105'), # == 29 mod 30
+            (1412873400, '178491'), # == 0 mod 30
+            (1412873401, '178491'), # == 1 mod 30
+            (1412873429, '178491'), # == 29 mod 30
+            (1412873430, '915114'), # == 0 mod 30
+        ],
+
+        # 10 byte key, 8 digits
+        [dict(key="ACDEFGHJKL234567", digits=8),
+            # should be same as 6 digits (above), but w/ 2 more digits on left side of token.
+            (1412873399, '20221105'), # == 29 mod 30
+            (1412873400, '86178491'), # == 0 mod 30
+            (1412873401, '86178491'), # == 1 mod 30
+            (1412873429, '86178491'), # == 29 mod 30
+            (1412873430, '03915114'), # == 0 mod 30
+        ],
+
+        # sanity check on key used in docstrings
+        [dict(key="S3JD-VB7Q-D2R7-JPXX", digits=6),
+            (1419622709, '000492'),
+            (1419622739, '897212'),
+        ],
+
+        #-------------------------------------------------------------------------
+        # reference vectors taken from http://tools.ietf.org/html/rfc6238, appendix B
+        # NOTE: while appendix B states same key used for all tests, the reference
+        #       code in the appendix repeats the key up to the alg's block size,
+        #       and uses *that* as the secret... so that's what we're doing here.
+        #-------------------------------------------------------------------------
+
+        # sha1 test vectors
+        [dict(key=RFC_KEY_BYTES_20, format="raw", alg="sha1"),
+            (59, '94287082'),
+            (1111111109, '07081804'),
+            (1111111111, '14050471'),
+            (1234567890, '89005924'),
+            (2000000000, '69279037'),
+            (20000000000, '65353130'),
+        ],
+
+        # sha256 test vectors
+        [dict(key=RFC_KEY_BYTES_32, format="raw", alg="sha256"),
+            (59, '46119246'),
+            (1111111109, '68084774'),
+            (1111111111, '67062674'),
+            (1234567890, '91819424'),
+            (2000000000, '90698825'),
+            (20000000000, '77737706'),
+        ],
+
+        # sha512 test vectors
+        [dict(key=RFC_KEY_BYTES_64, format="raw", alg="sha512"),
+            (59, '90693936'),
+            (1111111109, '25091201'),
+            (1111111111, '99943326'),
+            (1234567890, '93441116'),
+            (2000000000, '38618901'),
+            (20000000000, '47863826'),
+        ],
+
+        #-------------------------------------------------------------------------
+        # other test vectors
+        #-------------------------------------------------------------------------
+
+        # generated at http://blog.tinisles.com/2011/10/google-authenticator-one-time-password-algorithm-in-javascript
+        [dict(key="JBSWY3DPEHPK3PXP", digits=6), (1409192430, '727248'), (1419890990, '122419')],
+        [dict(key="JBSWY3DPEHPK3PXP", digits=9, period=41), (1419891152, '662331049')],
+
+        # found in https://github.com/eloquent/otis/blob/develop/test/suite/Totp/Value/TotpValueGeneratorTest.php, line 45
+        [dict(key=RFC_KEY_BYTES_20, format="raw", period=60), (1111111111, '19360094')],
+        [dict(key=RFC_KEY_BYTES_32, format="raw", alg="sha256", period=60), (1111111111, '40857319')],
+        [dict(key=RFC_KEY_BYTES_64, format="raw", alg="sha512", period=60), (1111111111, '37023009')],
+
+    ]
+
+    def iter_test_vectors(self):
+        """
+        helper to iterate over test vectors.
+        yields ``(totp, time, token, expires, prefix)`` tuples.
+        """
+        from passlib.totp import TOTP
+        for row in self.vectors:
+            kwds = self.vector_defaults.copy()
+            kwds.update(row[0])
+            for entry in row[1:]:
+                if len(entry) == 3:
+                    time, token, expires = entry
+                else:
+                    time, token = entry
+                    expires = None
+                # NOTE: not re-using otp between calls so that stateful methods
+                #       (like .match) don't have problems.
+                log.debug("test vector: %r time=%r token=%r expires=%r", kwds, time, token, expires)
+                otp = TOTP(**kwds)
+                prefix = "alg=%r time=%r token=%r: " % (otp.alg, time, token)
+                yield otp, time, token, expires, prefix
+
+    #=============================================================================
+    # constructor tests
+    #=============================================================================
+    def test_ctor_w_new(self):
+        """constructor -- 'new'  parameter"""
+
+        # exactly one of 'key' or 'new' is required
+        self.assertRaises(TypeError, TOTP)
+        self.assertRaises(TypeError, TOTP, key='4aoggdbbqsyhntuz', new=True)
+
+        # generates new key
+        otp = TOTP(new=True)
+        otp2 = TOTP(new=True)
+        self.assertNotEqual(otp.key, otp2.key)
+
+    def test_ctor_w_size(self):
+        """constructor -- 'size'  parameter"""
+
+        # should default to digest size, per RFC
+        self.assertEqual(len(TOTP(new=True, alg="sha1").key), 20)
+        self.assertEqual(len(TOTP(new=True, alg="sha256").key), 32)
+        self.assertEqual(len(TOTP(new=True, alg="sha512").key), 64)
+
+        # explicit key size
+        self.assertEqual(len(TOTP(new=True, size=10).key), 10)
+        self.assertEqual(len(TOTP(new=True, size=16).key), 16)
+
+        # for new=True, maximum size enforced (based on alg)
+        self.assertRaises(ValueError, TOTP, new=True, size=21, alg="sha1")
+
+        # for new=True, minimum size enforced
+        self.assertRaises(ValueError, TOTP, new=True, size=9)
+
+        # for existing key, minimum size is only warned about
+        with self.assertWarningList([
+                dict(category=exc.PasslibSecurityWarning, message_re=".*for security purposes, secret key must be.*")
+                ]):
+            _ = TOTP('0A'*9, 'hex')
+
+    def test_ctor_w_key_and_format(self):
+        """constructor -- 'key' and 'format' parameters"""
+
+        # handle base32 encoding (the default)
+        self.assertEqual(TOTP(KEY1).key, KEY1_RAW)
+
+            # .. w/ lower case
+        self.assertEqual(TOTP(KEY1.lower()).key, KEY1_RAW)
+
+            # .. w/ spaces (e.g. user-entered data)
+        self.assertEqual(TOTP(' 4aog gdbb qsyh ntuz ').key, KEY1_RAW)
+
+            # .. w/ invalid char
+        self.assertRaises(Base32DecodeError, TOTP, 'ao!ggdbbqsyhntuz')
+
+        # handle hex encoding
+        self.assertEqual(TOTP('e01c630c2184b076ce99', 'hex').key, KEY1_RAW)
+
+            # .. w/ invalid char
+        self.assertRaises(Base16DecodeError, TOTP, 'X01c630c2184b076ce99', 'hex')
+
+        # handle raw bytes
+        self.assertEqual(TOTP(KEY1_RAW, "raw").key, KEY1_RAW)
+
+    def test_ctor_w_alg(self):
+        """constructor -- 'alg' parameter"""
+
+        # normalize hash names
+        self.assertEqual(TOTP(KEY1, alg="SHA-256").alg, "sha256")
+        self.assertEqual(TOTP(KEY1, alg="SHA256").alg, "sha256")
+
+        # invalid alg
+        self.assertRaises(ValueError, TOTP, KEY1, alg="SHA-333")
+
+    def test_ctor_w_digits(self):
+        """constructor -- 'digits' parameter"""
+        self.assertRaises(ValueError, TOTP, KEY1, digits=5)
+        self.assertEqual(TOTP(KEY1, digits=6).digits, 6)  # min value
+        self.assertEqual(TOTP(KEY1, digits=10).digits, 10)  # max value
+        self.assertRaises(ValueError, TOTP, KEY1, digits=11)
+
+    def test_ctor_w_period(self):
+        """constructor -- 'period' parameter"""
+
+        # default
+        self.assertEqual(TOTP(KEY1).period, 30)
+
+        # explicit value
+        self.assertEqual(TOTP(KEY1, period=63).period, 63)
+
+        # reject wrong type
+        self.assertRaises(TypeError, TOTP, KEY1, period=1.5)
+        self.assertRaises(TypeError, TOTP, KEY1, period='abc')
+
+        # reject non-positive values
+        self.assertRaises(ValueError, TOTP, KEY1, period=0)
+        self.assertRaises(ValueError, TOTP, KEY1, period=-1)
+
+    def test_ctor_w_label(self):
+        """constructor -- 'label' parameter"""
+        self.assertEqual(TOTP(KEY1).label, None)
+        self.assertEqual(TOTP(KEY1, label="foo@bar").label, "foo@bar")
+        self.assertRaises(ValueError, TOTP, KEY1, label="foo:bar")
+
+    def test_ctor_w_issuer(self):
+        """constructor -- 'issuer' parameter"""
+        self.assertEqual(TOTP(KEY1).issuer, None)
+        self.assertEqual(TOTP(KEY1, issuer="foo.com").issuer, "foo.com")
+        self.assertRaises(ValueError, TOTP, KEY1, issuer="foo.com:bar")
+
+    #=============================================================================
+    # using() tests
+    #=============================================================================
+
+    # TODO: test using() w/ 'digits', 'alg', 'issue', 'wallet', **wallet_kwds
+
+    def test_using_w_period(self):
+        """using() -- 'period' parameter"""
+
+        # default
+        self.assertEqual(TOTP(KEY1).period, 30)
+
+        # explicit value
+        self.assertEqual(TOTP.using(period=63)(KEY1).period, 63)
+
+        # reject wrong type
+        self.assertRaises(TypeError, TOTP.using, period=1.5)
+        self.assertRaises(TypeError, TOTP.using, period='abc')
+
+        # reject non-positive values
+        self.assertRaises(ValueError, TOTP.using, period=0)
+        self.assertRaises(ValueError, TOTP.using, period=-1)
+
+    def test_using_w_now(self):
+        """using -- 'now' parameter"""
+
+        # NOTE: reading time w/ normalize_time() to make sure custom .now actually has effect.
+
+        # default -- time.time
+        otp = self.randotp()
+        self.assertIs(otp.now, _time.time)
+        self.assertAlmostEqual(otp.normalize_time(None), int(_time.time()))
+
+        # custom function
+        counter = [123.12]
+        def now():
+            counter[0] += 1
+            return counter[0]
+        otp = self.randotp(cls=TOTP.using(now=now))
+        # NOTE: TOTP() constructor invokes this as part of test, using up counter values 124 & 125
+        self.assertEqual(otp.normalize_time(None), 126)
+        self.assertEqual(otp.normalize_time(None), 127)
+
+        # require callable
+        self.assertRaises(TypeError, TOTP.using, now=123)
+
+        # require returns int/float
+        msg_re = r"now\(\) function must return non-negative"
+        self.assertRaisesRegex(AssertionError, msg_re, TOTP.using, now=lambda: 'abc')
+
+        # require returns non-negative value
+        self.assertRaisesRegex(AssertionError, msg_re, TOTP.using, now=lambda: -1)
+
+    #=============================================================================
+    # internal method tests
+    #=============================================================================
+
+    def test_normalize_token_instance(self, otp=None):
+        """normalize_token() -- instance method"""
+        if otp is None:
+            otp = self.randotp(digits=7)
+
+        # unicode & bytes
+        self.assertEqual(otp.normalize_token(u('1234567')), '1234567')
+        self.assertEqual(otp.normalize_token(b'1234567'), '1234567')
+
+        # int
+        self.assertEqual(otp.normalize_token(1234567), '1234567')
+
+        # int which needs 0 padding
+        self.assertEqual(otp.normalize_token(234567), '0234567')
+
+        # reject wrong types (float, None)
+        self.assertRaises(TypeError, otp.normalize_token, 1234567.0)
+        self.assertRaises(TypeError, otp.normalize_token, None)
+
+        # too few digits
+        self.assertRaises(exc.MalformedTokenError, otp.normalize_token, '123456')
+
+        # too many digits
+        self.assertRaises(exc.MalformedTokenError, otp.normalize_token, '01234567')
+        self.assertRaises(exc.MalformedTokenError, otp.normalize_token, 12345678)
+
+    def test_normalize_token_class(self):
+        """normalize_token() -- class method"""
+        self.test_normalize_token_instance(otp=TOTP.using(digits=7))
+
+    def test_normalize_time(self):
+        """normalize_time()"""
+        TotpFactory = TOTP.using()
+        otp = self.randotp(TotpFactory)
+
+        for _ in range(10):
+            time = self.randtime()
+            tint = int(time)
+
+            self.assertEqual(otp.normalize_time(time), tint)
+            self.assertEqual(otp.normalize_time(tint + 0.5), tint)
+
+            self.assertEqual(otp.normalize_time(tint), tint)
+
+            dt = datetime.datetime.utcfromtimestamp(time)
+            self.assertEqual(otp.normalize_time(dt), tint)
+
+            orig = TotpFactory.now
+            try:
+                TotpFactory.now = staticmethod(lambda: time)
+                self.assertEqual(otp.normalize_time(None), tint)
+            finally:
+                TotpFactory.now = orig
+
+        self.assertRaises(TypeError, otp.normalize_time, '1234')
+
+    #=============================================================================
+    # key attr tests
+    #=============================================================================
+
+    def test_key_attrs(self):
+        """pretty_key() and .key attributes"""
+        rng = self.getRandom()
+
+        # test key attrs
+        otp = TOTP(KEY1_RAW, "raw")
+        self.assertEqual(otp.key, KEY1_RAW)
+        self.assertEqual(otp.hex_key, 'e01c630c2184b076ce99')
+        self.assertEqual(otp.base32_key, KEY1)
+
+        # test pretty_key()
+        self.assertEqual(otp.pretty_key(), '4AOG-GDBB-QSYH-NTUZ')
+        self.assertEqual(otp.pretty_key(sep=" "), '4AOG GDBB QSYH NTUZ')
+        self.assertEqual(otp.pretty_key(sep=False), KEY1)
+        self.assertEqual(otp.pretty_key(format="hex"), 'e01c-630c-2184-b076-ce99')
+
+        # quick fuzz test: make attr access works for random key & random size
+        otp = TOTP(new=True, size=rng.randint(10, 20))
+        _ = otp.hex_key
+        _ = otp.base32_key
+        _ = otp.pretty_key()
+
+    #=============================================================================
+    # generate() tests
+    #=============================================================================
+    def test_totp_token(self):
+        """generate() -- TotpToken() class"""
+        from passlib.totp import TOTP, TotpToken
+
+        # test known set of values
+        otp = TOTP('s3jdvb7qd2r7jpxx')
+        result = otp.generate(1419622739)
+        self.assertIsInstance(result, TotpToken)
+        self.assertEqual(result.token, '897212')
+        self.assertEqual(result.counter, 47320757)
+        ##self.assertEqual(result.start_time, 1419622710)
+        self.assertEqual(result.expire_time, 1419622740)
+        self.assertEqual(result, ('897212', 1419622740))
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result[0], '897212')
+        self.assertEqual(result[1], 1419622740)
+        self.assertRaises(IndexError, result.__getitem__, -3)
+        self.assertRaises(IndexError, result.__getitem__, 2)
+        self.assertTrue(result)
+
+        # time dependant bits...
+        otp.now = lambda : 1419622739.5
+        self.assertEqual(result.remaining, 0.5)
+        self.assertTrue(result.valid)
+
+        otp.now = lambda : 1419622741
+        self.assertEqual(result.remaining, 0)
+        self.assertFalse(result.valid)
+
+        # same time -- shouldn't return same object, but should be equal
+        result2 = otp.generate(1419622739)
+        self.assertIsNot(result2, result)
+        self.assertEqual(result2, result)
+
+        # diff time in period -- shouldn't return same object, but should be equal
+        result3 = otp.generate(1419622711)
+        self.assertIsNot(result3, result)
+        self.assertEqual(result3, result)
+
+        # shouldn't be equal
+        result4 = otp.generate(1419622999)
+        self.assertNotEqual(result4, result)
+
+    def test_generate(self):
+        """generate()"""
+        from passlib.totp import TOTP
+
+        # generate token
+        otp = TOTP(new=True)
+        time = self.randtime()
+        result = otp.generate(time)
+        token = result.token
+        self.assertIsInstance(token, unicode)
+        start_time = result.counter * 30
+
+        # should generate same token for next 29s
+        self.assertEqual(otp.generate(start_time + 29).token, token)
+
+        # and new one at 30s
+        self.assertNotEqual(otp.generate(start_time + 30).token, token)
+
+        # verify round-trip conversion of datetime
+        dt = datetime.datetime.utcfromtimestamp(time)
+        self.assertEqual(int(otp.normalize_time(dt)), int(time))
+
+        # handle datetime object
+        self.assertEqual(otp.generate(dt).token, token)
+
+        # omitting value should use current time
+        otp2 = TOTP.using(now=lambda: time)(key=otp.base32_key)
+        self.assertEqual(otp2.generate().token, token)
+
+        # reject invalid time
+        self.assertRaises(ValueError, otp.generate, -1)
+
+    def test_generate_w_reference_vectors(self):
+        """generate() -- reference vectors"""
+        for otp, time, token, expires, prefix in self.iter_test_vectors():
+            # should output correct token for specified time
+            result = otp.generate(time)
+            self.assertEqual(result.token, token, msg=prefix)
+            self.assertEqual(result.counter, time // otp.period, msg=prefix)
+            if expires:
+                self.assertEqual(result.expire_time, expires)
+
+    #=============================================================================
+    # TotpMatch() tests
+    #=============================================================================
+
+    def assertTotpMatch(self, match, time, skipped=0, period=30, window=30, msg=''):
+        from passlib.totp import TotpMatch
+
+        # test type
+        self.assertIsInstance(match, TotpMatch)
+
+        # totp sanity check
+        self.assertIsInstance(match.totp, TOTP)
+        self.assertEqual(match.totp.period, period)
+
+        # test attrs
+        self.assertEqual(match.time, time, msg=msg + " matched time:")
+        expected = time // period
+        counter = expected + skipped
+        self.assertEqual(match.counter, counter, msg=msg + " matched counter:")
+        self.assertEqual(match.expected_counter, expected, msg=msg + " expected counter:")
+        self.assertEqual(match.skipped, skipped, msg=msg + " skipped:")
+        self.assertEqual(match.cache_seconds, period + window)
+        expire_time = (counter + 1) * period
+        self.assertEqual(match.expire_time, expire_time)
+        self.assertEqual(match.cache_time, expire_time + window)
+
+        # test tuple
+        self.assertEqual(len(match), 2)
+        self.assertEqual(match, (counter, time))
+        self.assertRaises(IndexError, match.__getitem__, -3)
+        self.assertEqual(match[0], counter)
+        self.assertEqual(match[1], time)
+        self.assertRaises(IndexError, match.__getitem__, 2)
+
+        # test bool
+        self.assertTrue(match)
+
+    def test_totp_match_w_valid_token(self):
+        """match() -- valid TotpMatch object"""
+        time = 141230981
+        token = '781501'
+        otp = TOTP.using(now=lambda: time + 24 * 3600)(KEY3)
+        result = otp.match(token, time)
+        self.assertTotpMatch(result, time=time, skipped=0)
+
+    def test_totp_match_w_older_token(self):
+        """match() -- valid TotpMatch object with future token"""
+        from passlib.totp import TotpMatch
+
+        time = 141230981
+        token = '781501'
+        otp = TOTP.using(now=lambda: time + 24 * 3600)(KEY3)
+        result = otp.match(token, time - 30)
+        self.assertTotpMatch(result, time=time - 30, skipped=1)
+
+    def test_totp_match_w_new_token(self):
+        """match() -- valid TotpMatch object with past token"""
+        time = 141230981
+        token = '781501'
+        otp = TOTP.using(now=lambda: time + 24 * 3600)(KEY3)
+        result = otp.match(token, time + 30)
+        self.assertTotpMatch(result, time=time + 30, skipped=-1)
+
+    def test_totp_match_w_invalid_token(self):
+        """match() -- invalid TotpMatch object"""
+        time = 141230981
+        token = '781501'
+        otp = TOTP.using(now=lambda: time + 24 * 3600)(KEY3)
+        self.assertRaises(exc.InvalidTokenError, otp.match, token, time + 60)
+
+    #=============================================================================
+    # match() tests
+    #=============================================================================
+
+    def assertVerifyMatches(self, expect_skipped, token, time,  # *
+                            otp, gen_time=None, **kwds):
+        """helper to test otp.match() output is correct"""
+        # NOTE: TotpMatch return type tested more throughly above ^^^
+        msg = "key=%r alg=%r period=%r token=%r gen_time=%r time=%r:" % \
+              (otp.base32_key, otp.alg, otp.period, token, gen_time, time)
+        result = otp.match(token, time, **kwds)
+        self.assertTotpMatch(result,
+                             time=otp.normalize_time(time),
+                             period=otp.period,
+                             window=kwds.get("window", 30),
+                             skipped=expect_skipped,
+                             msg=msg)
+
+    def assertVerifyRaises(self, exc_class, token, time,  # *
+                          otp, gen_time=None,
+                          **kwds):
+        """helper to test otp.match() throws correct error"""
+        # NOTE: TotpMatch return type tested more throughly above ^^^
+        msg = "key=%r alg=%r period=%r token=%r gen_time=%r time=%r:" % \
+              (otp.base32_key, otp.alg, otp.period, token, gen_time, time)
+        return self.assertRaises(exc_class, otp.match, token, time,
+                                 __msg__=msg, **kwds)
+
+    def test_match_w_window(self):
+        """match() -- 'time' and 'window' parameters"""
+
+        # init generator & helper
+        otp = self.randotp()
+        period = otp.period
+        time = self.randtime()
+        token = otp.generate(time).token
+        common = dict(otp=otp, gen_time=time)
+        assertMatches = partial(self.assertVerifyMatches, **common)
+        assertRaises = partial(self.assertVerifyRaises, **common)
+
+        #-------------------------------
+        # basic validation, and 'window' parameter
+        #-------------------------------
+
+        # validate against previous counter (passes if window >= period)
+        assertRaises(exc.InvalidTokenError, token, time - period, window=0)
+        assertMatches(+1, token, time - period, window=period)
+        assertMatches(+1, token, time - period, window=2 * period)
+
+        # validate against current counter
+        assertMatches(0, token, time, window=0)
+
+        # validate against next counter (passes if window >= period)
+        assertRaises(exc.InvalidTokenError, token, time + period, window=0)
+        assertMatches(-1, token, time + period, window=period)
+        assertMatches(-1, token, time + period, window=2 * period)
+
+        # validate against two time steps later (should never pass)
+        assertRaises(exc.InvalidTokenError, token, time + 2 * period, window=0)
+        assertRaises(exc.InvalidTokenError, token, time + 2 * period, window=period)
+        assertMatches(-2, token, time + 2 * period, window=2 * period)
+
+        # TODO: test window values that aren't multiples of period
+        #       (esp ensure counter rounding works correctly)
+
+        #-------------------------------
+        # time normalization
+        #-------------------------------
+
+        # handle datetimes
+        dt = datetime.datetime.utcfromtimestamp(time)
+        assertMatches(0, token, dt, window=0)
+
+        # reject invalid time
+        assertRaises(ValueError, token, -1)
+
+    def test_match_w_skew(self):
+        """match() -- 'skew' parameters"""
+        # init generator & helper
+        otp = self.randotp()
+        period = otp.period
+        time = self.randtime()
+        common = dict(otp=otp, gen_time=time)
+        assertMatches = partial(self.assertVerifyMatches, **common)
+        assertRaises = partial(self.assertVerifyRaises, **common)
+
+        # assume client is running far behind server / has excessive transmission delay
+        skew = 3 * period
+        behind_token = otp.generate(time - skew).token
+        assertRaises(exc.InvalidTokenError, behind_token, time, window=0)
+        assertMatches(-3, behind_token, time, window=0, skew=-skew)
+
+        # assume client is running far ahead of server
+        ahead_token = otp.generate(time + skew).token
+        assertRaises(exc.InvalidTokenError, ahead_token, time, window=0)
+        assertMatches(+3, ahead_token, time, window=0, skew=skew)
+
+        # TODO: test skew + larger window
+
+    def test_match_w_reuse(self):
+        """match() -- 'reuse' and 'last_counter' parameters"""
+
+        # init generator & helper
+        otp = self.randotp()
+        period = otp.period
+        time = self.randtime()
+        tdata = otp.generate(time)
+        token = tdata.token
+        counter = tdata.counter
+        expire_time = tdata.expire_time
+        common = dict(otp=otp, gen_time=time)
+        assertMatches = partial(self.assertVerifyMatches, **common)
+        assertRaises = partial(self.assertVerifyRaises, **common)
+
+        # last counter unset --
+        # previous period's token should count as valid
+        assertMatches(-1, token, time + period, window=period)
+
+        # last counter set 2 periods ago --
+        # previous period's token should count as valid
+        assertMatches(-1, token, time + period, last_counter=counter-1,
+                      window=period)
+
+        # last counter set 2 periods ago --
+        # 2 periods ago's token should NOT count as valid
+        assertRaises(exc.InvalidTokenError, token, time + 2 * period,
+                     last_counter=counter, window=period)
+
+        # last counter set 1 period ago --
+        # previous period's token should now be rejected as 'used'
+        err = assertRaises(exc.UsedTokenError, token, time + period,
+                           last_counter=counter, window=period)
+        self.assertEqual(err.expire_time, expire_time)
+
+        # last counter set to current period --
+        # current period's token should be rejected
+        err = assertRaises(exc.UsedTokenError, token, time,
+                           last_counter=counter, window=0)
+        self.assertEqual(err.expire_time, expire_time)
+
+    def test_match_w_token_normalization(self):
+        """match() -- token normalization"""
+        # setup test helper
+        otp = TOTP('otxl2f5cctbprpzx')
+        match = otp.match
+        time = 1412889861
+
+        # separators / spaces should be stripped (orig token '332136')
+        self.assertTrue(match('    3 32-136  ', time))
+
+        # ascii bytes
+        self.assertTrue(match(b'332136', time))
+
+        # too few digits
+        self.assertRaises(exc.MalformedTokenError, match, '12345', time)
+
+        # invalid char
+        self.assertRaises(exc.MalformedTokenError, match, '12345X', time)
+
+        # leading zeros count towards size
+        self.assertRaises(exc.MalformedTokenError, match, '0123456', time)
+
+    def test_match_w_reference_vectors(self):
+        """match() -- reference vectors"""
+        for otp, time, token, expires, msg in self.iter_test_vectors():
+            # create wrapper
+            match = otp.match
+
+            # token should match against time
+            result = match(token, time)
+            self.assertTrue(result)
+            self.assertEqual(result.counter, time // otp.period, msg=msg)
+
+            # should NOT match against another time
+            self.assertRaises(exc.InvalidTokenError, match, token, time + 100, window=0)
+
+    #=============================================================================
+    # verify() tests
+    #=============================================================================
+    def test_verify(self):
+        """verify()"""
+        # NOTE: since this is thin wrapper around .from_source() and .match(),
+        #       just testing basic behavior here.
+
+        from passlib.totp import TOTP
+
+        time = 1412889861
+        TotpFactory = TOTP.using(now=lambda: time)
+
+        # successful match
+        source1 = dict(v=1, type="totp", key='otxl2f5cctbprpzx')
+        match = TotpFactory.verify('332136', source1)
+        self.assertTotpMatch(match, time=time)
+
+        # failed match
+        source1 = dict(v=1, type="totp", key='otxl2f5cctbprpzx')
+        self.assertRaises(exc.InvalidTokenError, TotpFactory.verify, '332155', source1)
+
+        # bad source
+        source1 = dict(v=1, type="totp")
+        self.assertRaises(ValueError, TotpFactory.verify, '332155', source1)
+
+        # successful match -- json source
+        source1json = '{"v": 1, "type": "totp", "key": "otxl2f5cctbprpzx"}'
+        match = TotpFactory.verify('332136', source1json)
+        self.assertTotpMatch(match, time=time)
+
+        # successful match -- URI
+        source1uri = 'otpauth://totp/Label?secret=otxl2f5cctbprpzx'
+        match = TotpFactory.verify('332136', source1uri)
+        self.assertTotpMatch(match, time=time)
+
+    #=============================================================================
+    # serialization frontend tests
+    #=============================================================================
+    def test_from_source(self):
+        """from_source()"""
+        from passlib.totp import TOTP
+        from_source = TOTP.from_source
+
+        # uri (unicode)
+        otp = from_source(u("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&"
+                            "issuer=Example"))
+        self.assertEqual(otp.key, KEY4_RAW)
+
+        # uri (bytes)
+        otp = from_source(b"otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&"
+                          b"issuer=Example")
+        self.assertEqual(otp.key, KEY4_RAW)
+
+        # dict
+        otp = from_source(dict(v=1, type="totp", key=KEY4))
+        self.assertEqual(otp.key, KEY4_RAW)
+
+        # json (unicode)
+        otp = from_source(u('{"v": 1, "type": "totp", "key": "JBSWY3DPEHPK3PXP"}'))
+        self.assertEqual(otp.key, KEY4_RAW)
+
+        # json (bytes)
+        otp = from_source(b'{"v": 1, "type": "totp", "key": "JBSWY3DPEHPK3PXP"}')
+        self.assertEqual(otp.key, KEY4_RAW)
+
+        # TOTP object -- return unchanged
+        self.assertIs(from_source(otp), otp)
+
+        # TOTP object w/ different wallet -- return new one.
+        wallet1 = AppWallet()
+        otp1 = TOTP.using(wallet=wallet1).from_source(otp)
+        self.assertIsNot(otp1, otp)
+        self.assertEqual(otp1.to_dict(), otp.to_dict())
+
+        # TOTP object w/ same wallet -- return original
+        otp2 = TOTP.using(wallet=wallet1).from_source(otp1)
+        self.assertIs(otp2, otp1)
+
+        # random string
+        self.assertRaises(ValueError, from_source, u("foo"))
+        self.assertRaises(ValueError, from_source, b"foo")
+
+    #=============================================================================
+    # uri serialization tests
+    #=============================================================================
+    def test_from_uri(self):
+        """from_uri()"""
+        from passlib.totp import TOTP
+        from_uri = TOTP.from_uri
+
+        # URIs from https://code.google.com/p/google-authenticator/wiki/KeyUriFormat
+
+        #--------------------------------------------------------------------------------
+        # canonical uri
+        #--------------------------------------------------------------------------------
+        otp = from_uri("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&"
+                       "issuer=Example")
+        self.assertIsInstance(otp, TOTP)
+        self.assertEqual(otp.key, KEY4_RAW)
+        self.assertEqual(otp.label, "alice@google.com")
+        self.assertEqual(otp.issuer, "Example")
+        self.assertEqual(otp.alg, "sha1") # default
+        self.assertEqual(otp.period, 30) # default
+        self.assertEqual(otp.digits, 6) # default
+
+        #--------------------------------------------------------------------------------
+        # secret param
+        #--------------------------------------------------------------------------------
+
+        # secret case insensitive
+        otp = from_uri("otpauth://totp/Example:alice@google.com?secret=jbswy3dpehpk3pxp&"
+                       "issuer=Example")
+        self.assertEqual(otp.key, KEY4_RAW)
+
+        # missing secret
+        self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?digits=6")
+
+        # undecodable secret
+        self.assertRaises(Base32DecodeError, from_uri, "otpauth://totp/Example:alice@google.com?"
+                                                       "secret=JBSWY3DPEHP@3PXP")
+
+        #--------------------------------------------------------------------------------
+        # label param
+        #--------------------------------------------------------------------------------
+
+        # w/ encoded space
+        otp = from_uri("otpauth://totp/Provider1:Alice%20Smith?secret=JBSWY3DPEHPK3PXP&"
+                       "issuer=Provider1")
+        self.assertEqual(otp.label, "Alice Smith")
+        self.assertEqual(otp.issuer, "Provider1")
+
+        # w/ encoded space and colon
+        # (note url has leading space before 'alice') -- taken from KeyURI spec
+        otp = from_uri("otpauth://totp/Big%20Corporation%3A%20alice@bigco.com?"
+                       "secret=JBSWY3DPEHPK3PXP")
+        self.assertEqual(otp.label, "alice@bigco.com")
+        self.assertEqual(otp.issuer, "Big Corporation")
+
+        #--------------------------------------------------------------------------------
+        # issuer param / prefix
+        #--------------------------------------------------------------------------------
+
+        # 'new style' issuer only
+        otp = from_uri("otpauth://totp/alice@bigco.com?secret=JBSWY3DPEHPK3PXP&issuer=Big%20Corporation")
+        self.assertEqual(otp.label, "alice@bigco.com")
+        self.assertEqual(otp.issuer, "Big Corporation")
+
+        # new-vs-old issuer mismatch
+        self.assertRaises(ValueError, TOTP.from_uri,
+                          "otpauth://totp/Provider1:alice?secret=JBSWY3DPEHPK3PXP&issuer=Provider2")
+
+        #--------------------------------------------------------------------------------
+        # algorithm param
+        #--------------------------------------------------------------------------------
+
+        # custom alg
+        otp = from_uri("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&algorithm=SHA256")
+        self.assertEqual(otp.alg, "sha256")
+
+        # unknown alg
+        self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?"
+                                                "secret=JBSWY3DPEHPK3PXP&algorithm=SHA333")
+
+        #--------------------------------------------------------------------------------
+        # digit param
+        #--------------------------------------------------------------------------------
+
+        # custom digits
+        otp = from_uri("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&digits=8")
+        self.assertEqual(otp.digits, 8)
+
+        # digits out of range / invalid
+        self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&digits=A")
+        self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&digits=%20")
+        self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&digits=15")
+
+        #--------------------------------------------------------------------------------
+        # period param
+        #--------------------------------------------------------------------------------
+
+        # custom period
+        otp = from_uri("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&period=63")
+        self.assertEqual(otp.period, 63)
+
+        # reject period < 1
+        self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?"
+                                                "secret=JBSWY3DPEHPK3PXP&period=0")
+
+        self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?"
+                                                "secret=JBSWY3DPEHPK3PXP&period=-1")
+
+        #--------------------------------------------------------------------------------
+        # unrecognized param
+        #--------------------------------------------------------------------------------
+
+        # should issue warning, but otherwise ignore extra param
+        with self.assertWarningList([
+            dict(category=exc.PasslibRuntimeWarning, message_re="unexpected parameters encountered")
+        ]):
+            otp = from_uri("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&"
+                           "foo=bar&period=63")
+        self.assertEqual(otp.base32_key, KEY4)
+        self.assertEqual(otp.period, 63)
+
+    def test_to_uri(self):
+        """to_uri()"""
+
+        #-------------------------------------------------------------------------
+        # label & issuer parameters
+        #-------------------------------------------------------------------------
+
+        # with label & issuer
+        otp = TOTP(KEY4, alg="sha1", digits=6, period=30)
+        self.assertEqual(otp.to_uri("alice@google.com", "Example Org"),
+                         "otpauth://totp/Example%20Org:alice@google.com?secret=JBSWY3DPEHPK3PXP&"
+                         "issuer=Example%20Org")
+
+        # label is required
+        self.assertRaises(ValueError, otp.to_uri, None, "Example Org")
+
+        # with label only
+        self.assertEqual(otp.to_uri("alice@google.com"),
+                         "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP")
+
+        # with default label from constructor
+        otp.label = "alice@google.com"
+        self.assertEqual(otp.to_uri(),
+                         "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP")
+
+        # with default label & default issuer from constructor
+        otp.issuer = "Example Org"
+        self.assertEqual(otp.to_uri(),
+                         "otpauth://totp/Example%20Org:alice@google.com?secret=JBSWY3DPEHPK3PXP"
+                         "&issuer=Example%20Org")
+
+        # reject invalid label
+        self.assertRaises(ValueError, otp.to_uri, "label:with:semicolons")
+
+        # reject invalid issuer
+        self.assertRaises(ValueError, otp.to_uri, "alice@google.com", "issuer:with:semicolons")
+
+        #-------------------------------------------------------------------------
+        # algorithm parameter
+        #-------------------------------------------------------------------------
+        self.assertEqual(TOTP(KEY4, alg="sha256").to_uri("alice@google.com"),
+                         "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP&"
+                         "algorithm=SHA256")
+
+        #-------------------------------------------------------------------------
+        # digits parameter
+        #-------------------------------------------------------------------------
+        self.assertEqual(TOTP(KEY4, digits=8).to_uri("alice@google.com"),
+                         "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP&"
+                         "digits=8")
+
+        #-------------------------------------------------------------------------
+        # period parameter
+        #-------------------------------------------------------------------------
+        self.assertEqual(TOTP(KEY4, period=63).to_uri("alice@google.com"),
+                         "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP&"
+                         "period=63")
+
+    #=============================================================================
+    # dict serialization tests
+    #=============================================================================
+    def test_from_dict(self):
+        """from_dict()"""
+        from passlib.totp import TOTP
+        from_dict = TOTP.from_dict
+
+        #--------------------------------------------------------------------------------
+        # canonical simple example
+        #--------------------------------------------------------------------------------
+        otp = from_dict(dict(v=1, type="totp", key=KEY4, label="alice@google.com", issuer="Example"))
+        self.assertIsInstance(otp, TOTP)
+        self.assertEqual(otp.key, KEY4_RAW)
+        self.assertEqual(otp.label, "alice@google.com")
+        self.assertEqual(otp.issuer, "Example")
+        self.assertEqual(otp.alg, "sha1")  # default
+        self.assertEqual(otp.period, 30)  # default
+        self.assertEqual(otp.digits, 6)  # default
+
+        #--------------------------------------------------------------------------------
+        # metadata
+        #--------------------------------------------------------------------------------
+
+        # missing version
+        self.assertRaises(ValueError, from_dict, dict(type="totp", key=KEY4))
+
+        # invalid version
+        self.assertRaises(ValueError, from_dict, dict(v=0, type="totp", key=KEY4))
+        self.assertRaises(ValueError, from_dict, dict(v=999, type="totp", key=KEY4))
+
+        # missing type
+        self.assertRaises(ValueError, from_dict, dict(v=1, key=KEY4))
+
+        #--------------------------------------------------------------------------------
+        # secret param
+        #--------------------------------------------------------------------------------
+
+        # secret case insensitive
+        otp = from_dict(dict(v=1, type="totp", key=KEY4.lower(), label="alice@google.com", issuer="Example"))
+        self.assertEqual(otp.key, KEY4_RAW)
+
+        # missing secret
+        self.assertRaises(ValueError, from_dict, dict(v=1, type="totp"))
+
+        # undecodable secret
+        self.assertRaises(Base32DecodeError, from_dict,
+                          dict(v=1, type="totp", key="JBSWY3DPEHP@3PXP"))
+
+        #--------------------------------------------------------------------------------
+        # label & issuer params
+        #--------------------------------------------------------------------------------
+
+        otp = from_dict(dict(v=1, type="totp", key=KEY4, label="Alice Smith", issuer="Provider1"))
+        self.assertEqual(otp.label, "Alice Smith")
+        self.assertEqual(otp.issuer, "Provider1")
+
+        #--------------------------------------------------------------------------------
+        # algorithm param
+        #--------------------------------------------------------------------------------
+
+        # custom alg
+        otp = from_dict(dict(v=1, type="totp", key=KEY4, alg="sha256"))
+        self.assertEqual(otp.alg, "sha256")
+
+        # unknown alg
+        self.assertRaises(ValueError, from_dict, dict(v=1, type="totp", key=KEY4, alg="sha333"))
+
+        #--------------------------------------------------------------------------------
+        # digit param
+        #--------------------------------------------------------------------------------
+
+        # custom digits
+        otp = from_dict(dict(v=1, type="totp", key=KEY4, digits=8))
+        self.assertEqual(otp.digits, 8)
+
+        # digits out of range / invalid
+        self.assertRaises(TypeError, from_dict, dict(v=1, type="totp", key=KEY4, digits="A"))
+        self.assertRaises(ValueError, from_dict, dict(v=1, type="totp", key=KEY4, digits=15))
+
+        #--------------------------------------------------------------------------------
+        # period param
+        #--------------------------------------------------------------------------------
+
+        # custom period
+        otp = from_dict(dict(v=1, type="totp", key=KEY4, period=63))
+        self.assertEqual(otp.period, 63)
+
+        # reject period < 1
+        self.assertRaises(ValueError, from_dict, dict(v=1, type="totp", key=KEY4, period=0))
+        self.assertRaises(ValueError, from_dict, dict(v=1, type="totp", key=KEY4, period=-1))
+
+        #--------------------------------------------------------------------------------
+        # unrecognized param
+        #--------------------------------------------------------------------------------
+        self.assertRaises(TypeError, from_dict, dict(v=1, type="totp", key=KEY4, INVALID=123))
+
+    def test_to_dict(self):
+        """to_dict()"""
+
+        #-------------------------------------------------------------------------
+        # label & issuer parameters
+        #-------------------------------------------------------------------------
+
+        # without label or issuer
+        otp = TOTP(KEY4, alg="sha1", digits=6, period=30)
+        self.assertEqual(otp.to_dict(), dict(v=1, type="totp", key=KEY4))
+
+        # with label & issuer from constructor
+        otp = TOTP(KEY4, alg="sha1", digits=6, period=30,
+                   label="alice@google.com", issuer="Example Org")
+        self.assertEqual(otp.to_dict(),
+                         dict(v=1, type="totp", key=KEY4,
+                              label="alice@google.com", issuer="Example Org"))
+
+        # with label only
+        otp = TOTP(KEY4, alg="sha1", digits=6, period=30,
+                   label="alice@google.com")
+        self.assertEqual(otp.to_dict(),
+                         dict(v=1, type="totp", key=KEY4,
+                              label="alice@google.com"))
+
+        # with issuer only
+        otp = TOTP(KEY4, alg="sha1", digits=6, period=30,
+                   issuer="Example Org")
+        self.assertEqual(otp.to_dict(),
+                         dict(v=1, type="totp", key=KEY4,
+                              issuer="Example Org"))
+
+        # don't serialize default issuer
+        TotpFactory = TOTP.using(issuer="Example Org")
+        otp = TotpFactory(KEY4)
+        self.assertEqual(otp.to_dict(), dict(v=1, type="totp", key=KEY4))
+
+        # don't serialize default issuer *even if explicitly set*
+        otp = TotpFactory(KEY4, issuer="Example Org")
+        self.assertEqual(otp.to_dict(),  dict(v=1, type="totp", key=KEY4))
+
+        #-------------------------------------------------------------------------
+        # algorithm parameter
+        #-------------------------------------------------------------------------
+        self.assertEqual(TOTP(KEY4, alg="sha256").to_dict(),
+                         dict(v=1, type="totp", key=KEY4, alg="sha256"))
+
+        #-------------------------------------------------------------------------
+        # digits parameter
+        #-------------------------------------------------------------------------
+        self.assertEqual(TOTP(KEY4, digits=8).to_dict(),
+                         dict(v=1, type="totp", key=KEY4, digits=8))
+
+        #-------------------------------------------------------------------------
+        # period parameter
+        #-------------------------------------------------------------------------
+        self.assertEqual(TOTP(KEY4, period=63).to_dict(),
+                         dict(v=1, type="totp", key=KEY4, period=63))
+
+    # TODO: to_dict()
+    #           with encrypt=False
+    #           with encrypt="auto" + wallet + secrets
+    #           with encrypt="auto" + wallet + no secrets
+    #           with encrypt="auto" + no wallet
+    #           with encrypt=True + wallet + secrets
+    #           with encrypt=True + wallet + no secrets
+    #           with encrypt=True + no wallet
+    #           that 'changed' is set for old versions, and old encryption tags.
+
+    #=============================================================================
+    # json serialization tests
+    #=============================================================================
+
+    # TODO: from_json() / to_json().
+    #       (skipped for right now cause just wrapper for from_dict/to_dict)
+
+    #=============================================================================
+    # eoc
+    #=============================================================================
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_utils.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_utils.py
new file mode 100644
index 0000000..59ba160
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_utils.py
@@ -0,0 +1,1171 @@
+"""tests for passlib.util"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+from functools import partial
+import warnings
+# site
+# pkg
+# module
+from passlib.utils import is_ascii_safe, to_bytes
+from passlib.utils.compat import irange, PY2, PY3, u, unicode, join_bytes, PYPY
+from passlib.tests.utils import TestCase, hb, run_with_fixed_seeds
+
+#=============================================================================
+# byte funcs
+#=============================================================================
+class MiscTest(TestCase):
+    """tests various parts of utils module"""
+
+    # NOTE: could test xor_bytes(), but it's exercised well enough by pbkdf2 test
+
+    def test_compat(self):
+        """test compat's lazymodule"""
+        from passlib.utils import compat
+        # "<module 'passlib.utils.compat' from 'passlib/utils/compat.pyc'>"
+        self.assertRegex(repr(compat),
+                         r"^<module 'passlib.utils.compat' from '.*?'>$")
+
+        # test synthentic dir()
+        dir(compat)
+        self.assertTrue('UnicodeIO' in dir(compat))
+        self.assertTrue('irange' in dir(compat))
+
+    def test_classproperty(self):
+        from passlib.utils.decor import classproperty
+
+        class test(object):
+            xvar = 1
+            @classproperty
+            def xprop(cls):
+                return cls.xvar
+
+        self.assertEqual(test.xprop, 1)
+        prop = test.__dict__['xprop']
+        self.assertIs(prop.im_func, prop.__func__)
+
+    def test_deprecated_function(self):
+        from passlib.utils.decor import deprecated_function
+        # NOTE: not comprehensive, just tests the basic behavior
+
+        @deprecated_function(deprecated="1.6", removed="1.8")
+        def test_func(*args):
+            """test docstring"""
+            return args
+
+        self.assertTrue(".. deprecated::" in test_func.__doc__)
+
+        with self.assertWarningList(dict(category=DeprecationWarning,
+                message="the function passlib.tests.test_utils.test_func() "
+                        "is deprecated as of Passlib 1.6, and will be "
+                        "removed in Passlib 1.8."
+                )):
+            self.assertEqual(test_func(1,2), (1,2))
+
+    def test_memoized_property(self):
+        from passlib.utils.decor import memoized_property
+
+        class dummy(object):
+            counter = 0
+
+            @memoized_property
+            def value(self):
+                value = self.counter
+                self.counter = value+1
+                return value
+
+        d = dummy()
+        self.assertEqual(d.value, 0)
+        self.assertEqual(d.value, 0)
+        self.assertEqual(d.counter, 1)
+
+        prop = dummy.value
+        if not PY3:
+            self.assertIs(prop.im_func, prop.__func__)
+
+    def test_getrandbytes(self):
+        """getrandbytes()"""
+        from passlib.utils import getrandbytes
+        wrapper = partial(getrandbytes, self.getRandom())
+        self.assertEqual(len(wrapper(0)), 0)
+        a = wrapper(10)
+        b = wrapper(10)
+        self.assertIsInstance(a, bytes)
+        self.assertEqual(len(a), 10)
+        self.assertEqual(len(b), 10)
+        self.assertNotEqual(a, b)
+
+    @run_with_fixed_seeds(count=1024)
+    def test_getrandstr(self, seed):
+        """getrandstr()"""
+        from passlib.utils import getrandstr
+
+        wrapper = partial(getrandstr, self.getRandom(seed=seed))
+
+        # count 0
+        self.assertEqual(wrapper('abc',0), '')
+
+        # count <0
+        self.assertRaises(ValueError, wrapper, 'abc', -1)
+
+        # letters 0
+        self.assertRaises(ValueError, wrapper, '', 0)
+
+        # letters 1
+        self.assertEqual(wrapper('a', 5), 'aaaaa')
+
+        # NOTE: the following parts are non-deterministic,
+        #       with a small chance of failure (outside chance it may pick
+        #       a string w/o one char, even more remote chance of picking
+        #       same string).  to combat this, we run it against multiple
+        #       fixed seeds (using run_with_fixed_seeds decorator),
+        #       and hope that they're sufficient to test the range of behavior.
+
+        # letters
+        x = wrapper(u('abc'), 32)
+        y = wrapper(u('abc'), 32)
+        self.assertIsInstance(x, unicode)
+        self.assertNotEqual(x,y)
+        self.assertEqual(sorted(set(x)), [u('a'),u('b'),u('c')])
+
+        # bytes
+        x = wrapper(b'abc', 32)
+        y = wrapper(b'abc', 32)
+        self.assertIsInstance(x, bytes)
+        self.assertNotEqual(x,y)
+        # NOTE: decoding this due to py3 bytes
+        self.assertEqual(sorted(set(x.decode("ascii"))), [u('a'),u('b'),u('c')])
+
+    def test_generate_password(self):
+        """generate_password()"""
+        from passlib.utils import generate_password
+        warnings.filterwarnings("ignore", "The function.*generate_password\(\) is deprecated")
+        self.assertEqual(len(generate_password(15)), 15)
+
+    def test_is_crypt_context(self):
+        """test is_crypt_context()"""
+        from passlib.utils import is_crypt_context
+        from passlib.context import CryptContext
+        cc = CryptContext(["des_crypt"])
+        self.assertTrue(is_crypt_context(cc))
+        self.assertFalse(not is_crypt_context(cc))
+
+    def test_genseed(self):
+        """test genseed()"""
+        import random
+        from passlib.utils import genseed
+        rng = random.Random(genseed())
+        a = rng.randint(0, 10**10)
+
+        rng = random.Random(genseed())
+        b = rng.randint(0, 10**10)
+
+        self.assertNotEqual(a,b)
+
+        rng.seed(genseed(rng))
+
+    def test_crypt(self):
+        """test crypt.crypt() wrappers"""
+        from passlib.utils import has_crypt, safe_crypt, test_crypt
+        from passlib.registry import get_supported_os_crypt_schemes, get_crypt_handler
+
+        # test everything is disabled
+        supported = get_supported_os_crypt_schemes()
+        if not has_crypt:
+            self.assertEqual(supported, ())
+            self.assertEqual(safe_crypt("test", "aa"), None)
+            self.assertFalse(test_crypt("test", "aaqPiZY5xR5l."))  # des_crypt() hash of "test"
+            raise self.skipTest("crypt.crypt() not available")
+
+        # expect there to be something supported, if crypt() is present
+        if not supported:
+            # NOTE: failures here should be investigated.  usually means one of:
+            # 1) at least one of passlib's os_crypt detection routines is giving false negative
+            # 2) crypt() ONLY supports some hash alg which passlib doesn't know about
+            # 3) crypt() is present but completely disabled (never encountered this yet)
+            raise self.fail("crypt() present, but no supported schemes found!")
+
+        # pick cheap alg if possible, with minimum rounds, to speed up this test.
+        # NOTE: trusting hasher class works properly (should have been verified using it's own UTs)
+        for scheme in ("md5_crypt", "sha256_crypt"):
+            if scheme in supported:
+                break
+        else:
+            scheme = supported[-1]
+        hasher = get_crypt_handler(scheme)
+        if getattr(hasher, "min_rounds", None):
+            hasher = hasher.using(rounds=hasher.min_rounds)
+
+        # helpers to generate hashes & config strings to work with
+        def get_hash(secret):
+            assert isinstance(secret, unicode)
+            hash = hasher.hash(secret)
+            if isinstance(hash, bytes):  # py2
+                hash = hash.decode("utf-8")
+            assert isinstance(hash, unicode)
+            return hash
+
+        # test ascii password & return type
+        s1 = u("test")
+        h1 = get_hash(s1)
+        result = safe_crypt(s1, h1)
+        self.assertIsInstance(result, unicode)
+        self.assertEqual(result, h1)
+        self.assertEqual(safe_crypt(to_bytes(s1), to_bytes(h1)), h1)
+
+        # make sure crypt doesn't just blindly return h1 for whatever we pass in
+        h1x = h1[:-2] + 'xx'
+        self.assertEqual(safe_crypt(s1, h1x), h1)
+
+        # test utf-8 / unicode password
+        s2 = u('test\u1234')
+        h2 = get_hash(s2)
+        self.assertEqual(safe_crypt(s2, h2), h2)
+        self.assertEqual(safe_crypt(to_bytes(s2), to_bytes(h2)), h2)
+
+        # test rejects null chars in password
+        self.assertRaises(ValueError, safe_crypt, '\x00', h1)
+
+        # check test_crypt()
+        self.assertTrue(test_crypt("test", h1))
+        self.assertFalse(test_crypt("test", h1x))
+
+        # check crypt returning variant error indicators
+        # some platforms return None on errors, others empty string,
+        # The BSDs in some cases return ":"
+        import passlib.utils as mod
+        orig = mod._crypt
+        try:
+            retval = None
+            mod._crypt = lambda secret, hash: retval
+
+            for retval in [None, "", ":", ":0", "*0"]:
+                self.assertEqual(safe_crypt("test", h1), None)
+                self.assertFalse(test_crypt("test", h1))
+
+            retval = 'xxx'
+            self.assertEqual(safe_crypt("test", h1), "xxx")
+            self.assertFalse(test_crypt("test", h1))
+
+        finally:
+            mod._crypt = orig
+
+    def test_consteq(self):
+        """test consteq()"""
+        # NOTE: this test is kind of over the top, but that's only because
+        # this is used for the critical task of comparing hashes for equality.
+        from passlib.utils import consteq, str_consteq
+
+        # ensure error raises for wrong types
+        self.assertRaises(TypeError, consteq, u(''), b'')
+        self.assertRaises(TypeError, consteq, u(''), 1)
+        self.assertRaises(TypeError, consteq, u(''), None)
+
+        self.assertRaises(TypeError, consteq, b'', u(''))
+        self.assertRaises(TypeError, consteq, b'', 1)
+        self.assertRaises(TypeError, consteq, b'', None)
+
+        self.assertRaises(TypeError, consteq, None, u(''))
+        self.assertRaises(TypeError, consteq, None, b'')
+        self.assertRaises(TypeError, consteq, 1, u(''))
+        self.assertRaises(TypeError, consteq, 1, b'')
+
+        def consteq_supports_string(value):
+            # under PY2, it supports all unicode strings (when present at all),
+            # under PY3, compare_digest() only supports ascii unicode strings.
+            # confirmed for: cpython 2.7.9, cpython 3.4, pypy, pypy3, pyston
+            return (consteq is str_consteq or PY2 or is_ascii_safe(value))
+
+        # check equal inputs compare correctly
+        for value in [
+                u("a"),
+                u("abc"),
+                u("\xff\xa2\x12\x00")*10,
+            ]:
+            if consteq_supports_string(value):
+                self.assertTrue(consteq(value, value), "value %r:" % (value,))
+            else:
+                self.assertRaises(TypeError, consteq, value, value)
+            self.assertTrue(str_consteq(value, value), "value %r:" % (value,))
+
+            value = value.encode("latin-1")
+            self.assertTrue(consteq(value, value), "value %r:" % (value,))
+
+        # check non-equal inputs compare correctly
+        for l,r in [
+                # check same-size comparisons with differing contents fail.
+                (u("a"),         u("c")),
+                (u("abcabc"),    u("zbaabc")),
+                (u("abcabc"),    u("abzabc")),
+                (u("abcabc"),    u("abcabz")),
+                ((u("\xff\xa2\x12\x00")*10)[:-1] + u("\x01"),
+                    u("\xff\xa2\x12\x00")*10),
+
+                # check different-size comparisons fail.
+                (u(""),       u("a")),
+                (u("abc"),    u("abcdef")),
+                (u("abc"),    u("defabc")),
+                (u("qwertyuiopasdfghjklzxcvbnm"), u("abc")),
+            ]:
+            if consteq_supports_string(l) and consteq_supports_string(r):
+                self.assertFalse(consteq(l, r), "values %r %r:" % (l,r))
+                self.assertFalse(consteq(r, l), "values %r %r:" % (r,l))
+            else:
+                self.assertRaises(TypeError, consteq, l, r)
+                self.assertRaises(TypeError, consteq, r, l)
+            self.assertFalse(str_consteq(l, r), "values %r %r:" % (l,r))
+            self.assertFalse(str_consteq(r, l), "values %r %r:" % (r,l))
+
+            l = l.encode("latin-1")
+            r = r.encode("latin-1")
+            self.assertFalse(consteq(l, r), "values %r %r:" % (l,r))
+            self.assertFalse(consteq(r, l), "values %r %r:" % (r,l))
+
+        # TODO: add some tests to ensure we take THETA(strlen) time.
+        # this might be hard to do reproducably.
+        # NOTE: below code was used to generate stats for analysis
+        ##from math import log as logb
+        ##import timeit
+        ##multipliers = [ 1<<s for s in irange(9)]
+        ##correct =   u"abcdefgh"*(1<<4)
+        ##incorrect = u"abcdxfgh"
+        ##print
+        ##first = True
+        ##for run in irange(1):
+        ##    times = []
+        ##    chars = []
+        ##    for m in multipliers:
+        ##        supplied = incorrect * m
+        ##        def test():
+        ##            self.assertFalse(consteq(supplied,correct))
+        ##            ##self.assertFalse(supplied == correct)
+        ##        times.append(timeit.timeit(test, number=100000))
+        ##        chars.append(len(supplied))
+        ##    # output for wolfram alpha
+        ##    print ", ".join("{%r, %r}" % (c,round(t,4)) for c,t in zip(chars,times))
+        ##    def scale(c):
+        ##        return logb(c,2)
+        ##    print ", ".join("{%r, %r}" % (scale(c),round(t,4)) for c,t in zip(chars,times))
+        ##    # output for spreadsheet
+        ##    ##if first:
+        ##    ##    print "na, " + ", ".join(str(c) for c in chars)
+        ##    ##    first = False
+        ##    ##print ", ".join(str(c) for c in [run] + times)
+
+    def test_saslprep(self):
+        """test saslprep() unicode normalizer"""
+        self.require_stringprep()
+        from passlib.utils import saslprep as sp
+
+        # invalid types
+        self.assertRaises(TypeError, sp, None)
+        self.assertRaises(TypeError, sp, 1)
+        self.assertRaises(TypeError, sp, b'')
+
+        # empty strings
+        self.assertEqual(sp(u('')), u(''))
+        self.assertEqual(sp(u('\u00AD')), u(''))
+
+        # verify B.1 chars are stripped,
+        self.assertEqual(sp(u("$\u00AD$\u200D$")), u("$$$"))
+
+        # verify C.1.2 chars are replaced with space
+        self.assertEqual(sp(u("$ $\u00A0$\u3000$")), u("$ $ $ $"))
+
+        # verify normalization to KC
+        self.assertEqual(sp(u("a\u0300")), u("\u00E0"))
+        self.assertEqual(sp(u("\u00E0")), u("\u00E0"))
+
+        # verify various forbidden characters
+            # control chars
+        self.assertRaises(ValueError, sp, u("\u0000"))
+        self.assertRaises(ValueError, sp, u("\u007F"))
+        self.assertRaises(ValueError, sp, u("\u180E"))
+        self.assertRaises(ValueError, sp, u("\uFFF9"))
+            # private use
+        self.assertRaises(ValueError, sp, u("\uE000"))
+            # non-characters
+        self.assertRaises(ValueError, sp, u("\uFDD0"))
+            # surrogates
+        self.assertRaises(ValueError, sp, u("\uD800"))
+            # non-plaintext chars
+        self.assertRaises(ValueError, sp, u("\uFFFD"))
+            # non-canon
+        self.assertRaises(ValueError, sp, u("\u2FF0"))
+            # change display properties
+        self.assertRaises(ValueError, sp, u("\u200E"))
+        self.assertRaises(ValueError, sp, u("\u206F"))
+            # unassigned code points (as of unicode 3.2)
+        self.assertRaises(ValueError, sp, u("\u0900"))
+        self.assertRaises(ValueError, sp, u("\uFFF8"))
+            # tagging characters
+        self.assertRaises(ValueError, sp, u("\U000e0001"))
+
+        # verify bidi behavior
+            # if starts with R/AL -- must end with R/AL
+        self.assertRaises(ValueError, sp, u("\u0627\u0031"))
+        self.assertEqual(sp(u("\u0627")), u("\u0627"))
+        self.assertEqual(sp(u("\u0627\u0628")), u("\u0627\u0628"))
+        self.assertEqual(sp(u("\u0627\u0031\u0628")), u("\u0627\u0031\u0628"))
+            # if starts with R/AL --  cannot contain L
+        self.assertRaises(ValueError, sp, u("\u0627\u0041\u0628"))
+            # if doesn't start with R/AL -- can contain R/AL, but L & EN allowed
+        self.assertRaises(ValueError, sp, u("x\u0627z"))
+        self.assertEqual(sp(u("x\u0041z")), u("x\u0041z"))
+
+        #------------------------------------------------------
+        # examples pulled from external sources, to be thorough
+        #------------------------------------------------------
+
+        # rfc 4031 section 3 examples
+        self.assertEqual(sp(u("I\u00ADX")), u("IX")) # strip SHY
+        self.assertEqual(sp(u("user")), u("user")) # unchanged
+        self.assertEqual(sp(u("USER")), u("USER")) # case preserved
+        self.assertEqual(sp(u("\u00AA")), u("a")) # normalize to KC form
+        self.assertEqual(sp(u("\u2168")), u("IX")) # normalize to KC form
+        self.assertRaises(ValueError, sp, u("\u0007")) # forbid control chars
+        self.assertRaises(ValueError, sp, u("\u0627\u0031")) # invalid bidi
+
+        # rfc 3454 section 6 examples
+            # starts with RAL char, must end with RAL char
+        self.assertRaises(ValueError, sp, u("\u0627\u0031"))
+        self.assertEqual(sp(u("\u0627\u0031\u0628")), u("\u0627\u0031\u0628"))
+
+    def test_splitcomma(self):
+        from passlib.utils import splitcomma
+        self.assertEqual(splitcomma(""), [])
+        self.assertEqual(splitcomma(","), [])
+        self.assertEqual(splitcomma("a"), ['a'])
+        self.assertEqual(splitcomma(" a , "), ['a'])
+        self.assertEqual(splitcomma(" a , b"), ['a', 'b'])
+        self.assertEqual(splitcomma(" a, b, "), ['a', 'b'])
+
+    def test_utf8_truncate(self):
+        """
+        utf8_truncate()
+        """
+        from passlib.utils import utf8_truncate
+
+        #
+        # run through a bunch of reference strings,
+        # and make sure they truncate properly across all possible indexes
+        #
+        for source in [
+            # empty string
+            b"",
+            # strings w/ only single-byte chars
+            b"1",
+            b"123",
+            b'\x1a',
+            b'\x1a' * 10,
+            b'\x7f',
+            b'\x7f' * 10,
+            # strings w/ properly formed UTF8 continuation sequences
+            b'a\xc2\xa0\xc3\xbe\xc3\xbe',
+            b'abcdefghjusdfaoiu\xc2\xa0\xc3\xbe\xc3\xbedsfioauweoiruer',
+        ]:
+            source.decode("utf-8") # sanity check - should always be valid UTF8
+
+            end = len(source)
+            for idx in range(end + 16):
+                prefix = "source=%r index=%r: " % (source, idx)
+
+                result = utf8_truncate(source, idx)
+
+                # result should always be valid utf-8
+                result.decode("utf-8")
+
+                # result should never be larger than source
+                self.assertLessEqual(len(result), end, msg=prefix)
+
+                # result should always be in range(idx, idx+4)
+                self.assertGreaterEqual(len(result), min(idx, end), msg=prefix)
+                self.assertLess(len(result), min(idx + 4, end + 1), msg=prefix)
+
+                # should be strict prefix of source
+                self.assertEqual(result, source[:len(result)], msg=prefix)
+
+        #
+        # malformed utf8 --
+        # strings w/ only initial chars (should cut just like single-byte chars)
+        #
+        for source in [
+            b'\xca',
+            b'\xca' * 10,
+            # also test null bytes (not valid utf8, but this func should treat them like ascii)
+            b'\x00',
+            b'\x00' * 10,
+        ]:
+            end = len(source)
+            for idx in range(end + 16):
+                prefix = "source=%r index=%r: " % (source, idx)
+                result = utf8_truncate(source, idx)
+                self.assertEqual(result, source[:idx], msg=prefix)
+
+        #
+        # malformed utf8 --
+        # strings w/ only continuation chars (should cut at index+3)
+        #
+        for source in [
+            b'\xaa',
+            b'\xaa' * 10,
+        ]:
+            end = len(source)
+            for idx in range(end + 16):
+                prefix = "source=%r index=%r: " % (source, idx)
+                result = utf8_truncate(source, idx)
+                self.assertEqual(result, source[:idx+3], msg=prefix)
+
+        #
+        # string w/ some invalid utf8 --
+        # * \xaa byte is too many continuation byte after \xff start byte
+        # * \xab byte doesn't have preceding start byte
+        # XXX: could also test continuation bytes w/o start byte, WITHIN the string.
+        #      but think this covers edges well enough...
+        #
+        source = b'MN\xff\xa0\xa1\xa2\xaaOP\xab'
+
+        self.assertEqual(utf8_truncate(source, 0), b'')  # index="M", stops there
+
+        self.assertEqual(utf8_truncate(source, 1), b'M')  # index="N", stops there
+
+        self.assertEqual(utf8_truncate(source, 2), b'MN')  # index="\xff", stops there
+
+        self.assertEqual(utf8_truncate(source, 3),
+                         b'MN\xff\xa0\xa1\xa2')  # index="\xa0", runs out after index+3="\xa2"
+
+        self.assertEqual(utf8_truncate(source, 4),
+                         b'MN\xff\xa0\xa1\xa2\xaa')  # index="\xa1", runs out after index+3="\xaa"
+
+        self.assertEqual(utf8_truncate(source, 5),
+                         b'MN\xff\xa0\xa1\xa2\xaa')  # index="\xa2", stops before "O"
+
+        self.assertEqual(utf8_truncate(source, 6),
+                         b'MN\xff\xa0\xa1\xa2\xaa')  # index="\xaa", stops before "O"
+
+        self.assertEqual(utf8_truncate(source, 7),
+                         b'MN\xff\xa0\xa1\xa2\xaa')  # index="O", stops there
+
+        self.assertEqual(utf8_truncate(source, 8),
+                         b'MN\xff\xa0\xa1\xa2\xaaO')  # index="P", stops there
+
+        self.assertEqual(utf8_truncate(source, 9),
+                         b'MN\xff\xa0\xa1\xa2\xaaOP\xab')  # index="\xab", runs out at end
+
+        self.assertEqual(utf8_truncate(source, 10),
+                         b'MN\xff\xa0\xa1\xa2\xaaOP\xab')  # index=end
+
+        self.assertEqual(utf8_truncate(source, 11),
+                         b'MN\xff\xa0\xa1\xa2\xaaOP\xab')  # index=end+1
+
+
+#=============================================================================
+# byte/unicode helpers
+#=============================================================================
+class CodecTest(TestCase):
+    """tests bytes/unicode helpers in passlib.utils"""
+
+    def test_bytes(self):
+        """test b() helper, bytes and native str type"""
+        if PY3:
+            import builtins
+            self.assertIs(bytes, builtins.bytes)
+        else:
+            import __builtin__ as builtins
+            self.assertIs(bytes, builtins.str)
+
+        self.assertIsInstance(b'', bytes)
+        self.assertIsInstance(b'\x00\xff', bytes)
+        if PY3:
+            self.assertEqual(b'\x00\xff'.decode("latin-1"), "\x00\xff")
+        else:
+            self.assertEqual(b'\x00\xff', "\x00\xff")
+
+    def test_to_bytes(self):
+        """test to_bytes()"""
+        from passlib.utils import to_bytes
+
+        # check unicode inputs
+        self.assertEqual(to_bytes(u('abc')),                  b'abc')
+        self.assertEqual(to_bytes(u('\x00\xff')),             b'\x00\xc3\xbf')
+
+        # check unicode w/ encodings
+        self.assertEqual(to_bytes(u('\x00\xff'), 'latin-1'),  b'\x00\xff')
+        self.assertRaises(ValueError, to_bytes, u('\x00\xff'), 'ascii')
+
+        # check bytes inputs
+        self.assertEqual(to_bytes(b'abc'),                b'abc')
+        self.assertEqual(to_bytes(b'\x00\xff'),           b'\x00\xff')
+        self.assertEqual(to_bytes(b'\x00\xc3\xbf'),       b'\x00\xc3\xbf')
+
+        # check byte inputs ignores enocding
+        self.assertEqual(to_bytes(b'\x00\xc3\xbf', "latin-1"),
+                                                            b'\x00\xc3\xbf')
+
+        # check bytes transcoding
+        self.assertEqual(to_bytes(b'\x00\xc3\xbf', "latin-1", "", "utf-8"),
+                                                            b'\x00\xff')
+
+        # check other
+        self.assertRaises(AssertionError, to_bytes, 'abc', None)
+        self.assertRaises(TypeError, to_bytes, None)
+
+    def test_to_unicode(self):
+        """test to_unicode()"""
+        from passlib.utils import to_unicode
+
+        # check unicode inputs
+        self.assertEqual(to_unicode(u('abc')),                u('abc'))
+        self.assertEqual(to_unicode(u('\x00\xff')),           u('\x00\xff'))
+
+        # check unicode input ignores encoding
+        self.assertEqual(to_unicode(u('\x00\xff'), "ascii"),  u('\x00\xff'))
+
+        # check bytes input
+        self.assertEqual(to_unicode(b'abc'),              u('abc'))
+        self.assertEqual(to_unicode(b'\x00\xc3\xbf'),     u('\x00\xff'))
+        self.assertEqual(to_unicode(b'\x00\xff', 'latin-1'),
+                                                            u('\x00\xff'))
+        self.assertRaises(ValueError, to_unicode, b'\x00\xff')
+
+        # check other
+        self.assertRaises(AssertionError, to_unicode, 'abc', None)
+        self.assertRaises(TypeError, to_unicode, None)
+
+    def test_to_native_str(self):
+        """test to_native_str()"""
+        from passlib.utils import to_native_str
+
+        # test plain ascii
+        self.assertEqual(to_native_str(u('abc'), 'ascii'), 'abc')
+        self.assertEqual(to_native_str(b'abc', 'ascii'), 'abc')
+
+        # test invalid ascii
+        if PY3:
+            self.assertEqual(to_native_str(u('\xE0'), 'ascii'), '\xE0')
+            self.assertRaises(UnicodeDecodeError, to_native_str, b'\xC3\xA0',
+                              'ascii')
+        else:
+            self.assertRaises(UnicodeEncodeError, to_native_str, u('\xE0'),
+                              'ascii')
+            self.assertEqual(to_native_str(b'\xC3\xA0', 'ascii'), '\xC3\xA0')
+
+        # test latin-1
+        self.assertEqual(to_native_str(u('\xE0'), 'latin-1'), '\xE0')
+        self.assertEqual(to_native_str(b'\xE0', 'latin-1'), '\xE0')
+
+        # test utf-8
+        self.assertEqual(to_native_str(u('\xE0'), 'utf-8'),
+                         '\xE0' if PY3 else '\xC3\xA0')
+        self.assertEqual(to_native_str(b'\xC3\xA0', 'utf-8'),
+                         '\xE0' if PY3 else '\xC3\xA0')
+
+        # other types rejected
+        self.assertRaises(TypeError, to_native_str, None, 'ascii')
+
+    def test_is_ascii_safe(self):
+        """test is_ascii_safe()"""
+        from passlib.utils import is_ascii_safe
+        self.assertTrue(is_ascii_safe(b"\x00abc\x7f"))
+        self.assertTrue(is_ascii_safe(u("\x00abc\x7f")))
+        self.assertFalse(is_ascii_safe(b"\x00abc\x80"))
+        self.assertFalse(is_ascii_safe(u("\x00abc\x80")))
+
+    def test_is_same_codec(self):
+        """test is_same_codec()"""
+        from passlib.utils import is_same_codec
+
+        self.assertTrue(is_same_codec(None, None))
+        self.assertFalse(is_same_codec(None, 'ascii'))
+
+        self.assertTrue(is_same_codec("ascii", "ascii"))
+        self.assertTrue(is_same_codec("ascii", "ASCII"))
+
+        self.assertTrue(is_same_codec("utf-8", "utf-8"))
+        self.assertTrue(is_same_codec("utf-8", "utf8"))
+        self.assertTrue(is_same_codec("utf-8", "UTF_8"))
+
+        self.assertFalse(is_same_codec("ascii", "utf-8"))
+
+#=============================================================================
+# base64engine
+#=============================================================================
+class Base64EngineTest(TestCase):
+    """test standalone parts of Base64Engine"""
+    # NOTE: most Base64Engine testing done via _Base64Test subclasses below.
+
+    def test_constructor(self):
+        from passlib.utils.binary import Base64Engine, AB64_CHARS
+
+        # bad charmap type
+        self.assertRaises(TypeError, Base64Engine, 1)
+
+        # bad charmap size
+        self.assertRaises(ValueError, Base64Engine, AB64_CHARS[:-1])
+
+        # dup charmap letter
+        self.assertRaises(ValueError, Base64Engine, AB64_CHARS[:-1] + "A")
+
+    def test_ab64_decode(self):
+        """ab64_decode()"""
+        from passlib.utils.binary import ab64_decode
+
+        # accept bytes or unicode
+        self.assertEqual(ab64_decode(b"abc"), hb("69b7"))
+        self.assertEqual(ab64_decode(u("abc")), hb("69b7"))
+
+        # reject non-ascii unicode
+        self.assertRaises(ValueError, ab64_decode, u("ab\xff"))
+
+        # underlying a2b_ascii treats non-base64 chars as "Incorrect padding"
+        self.assertRaises(TypeError, ab64_decode, b"ab\xff")
+        self.assertRaises(TypeError, ab64_decode, b"ab!")
+        self.assertRaises(TypeError, ab64_decode, u("ab!"))
+
+        # insert correct padding, handle dirty padding bits
+        self.assertEqual(ab64_decode(b"abcd"), hb("69b71d"))  # 0 mod 4
+        self.assertRaises(ValueError, ab64_decode, b"abcde")  # 1 mod 4
+        self.assertEqual(ab64_decode(b"abcdef"), hb("69b71d79"))  # 2 mod 4, dirty padding bits
+        self.assertEqual(ab64_decode(b"abcdeQ"), hb("69b71d79"))  # 2 mod 4, clean padding bits
+        self.assertEqual(ab64_decode(b"abcdefg"), hb("69b71d79f8"))  # 3 mod 4, clean padding bits
+
+        # support "./" or "+/" altchars
+        # (lets us transition to "+/" representation, merge w/ b64s_decode)
+        self.assertEqual(ab64_decode(b"ab+/"), hb("69bfbf"))
+        self.assertEqual(ab64_decode(b"ab./"), hb("69bfbf"))
+
+    def test_ab64_encode(self):
+        """ab64_encode()"""
+        from passlib.utils.binary import ab64_encode
+
+        # accept bytes
+        self.assertEqual(ab64_encode(hb("69b7")), b"abc")
+
+        # reject unicode
+        self.assertRaises(TypeError if PY3 else UnicodeEncodeError,
+                          ab64_encode, hb("69b7").decode("latin-1"))
+
+        # insert correct padding before decoding
+        self.assertEqual(ab64_encode(hb("69b71d")), b"abcd")  # 0 mod 4
+        self.assertEqual(ab64_encode(hb("69b71d79")), b"abcdeQ")  # 2 mod 4
+        self.assertEqual(ab64_encode(hb("69b71d79f8")), b"abcdefg")  # 3 mod 4
+
+        # output "./" altchars
+        self.assertEqual(ab64_encode(hb("69bfbf")), b"ab./")
+
+    def test_b64s_decode(self):
+        """b64s_decode()"""
+        from passlib.utils.binary import b64s_decode
+
+        # accept bytes or unicode
+        self.assertEqual(b64s_decode(b"abc"), hb("69b7"))
+        self.assertEqual(b64s_decode(u("abc")), hb("69b7"))
+
+        # reject non-ascii unicode
+        self.assertRaises(ValueError, b64s_decode, u("ab\xff"))
+
+        # underlying a2b_ascii treats non-base64 chars as "Incorrect padding"
+        self.assertRaises(TypeError, b64s_decode, b"ab\xff")
+        self.assertRaises(TypeError, b64s_decode, b"ab!")
+        self.assertRaises(TypeError, b64s_decode, u("ab!"))
+
+        # insert correct padding, handle dirty padding bits
+        self.assertEqual(b64s_decode(b"abcd"), hb("69b71d"))  # 0 mod 4
+        self.assertRaises(ValueError, b64s_decode, b"abcde")  # 1 mod 4
+        self.assertEqual(b64s_decode(b"abcdef"), hb("69b71d79"))  # 2 mod 4, dirty padding bits
+        self.assertEqual(b64s_decode(b"abcdeQ"), hb("69b71d79"))  # 2 mod 4, clean padding bits
+        self.assertEqual(b64s_decode(b"abcdefg"), hb("69b71d79f8"))  # 3 mod 4, clean padding bits
+
+    def test_b64s_encode(self):
+        """b64s_encode()"""
+        from passlib.utils.binary import b64s_encode
+
+        # accept bytes
+        self.assertEqual(b64s_encode(hb("69b7")), b"abc")
+
+        # reject unicode
+        self.assertRaises(TypeError if PY3 else UnicodeEncodeError,
+                          b64s_encode, hb("69b7").decode("latin-1"))
+
+        # insert correct padding before decoding
+        self.assertEqual(b64s_encode(hb("69b71d")), b"abcd")  # 0 mod 4
+        self.assertEqual(b64s_encode(hb("69b71d79")), b"abcdeQ")  # 2 mod 4
+        self.assertEqual(b64s_encode(hb("69b71d79f8")), b"abcdefg")  # 3 mod 4
+
+        # output "+/" altchars
+        self.assertEqual(b64s_encode(hb("69bfbf")), b"ab+/")
+
+class _Base64Test(TestCase):
+    """common tests for all Base64Engine instances"""
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    # Base64Engine instance to test
+    engine = None
+
+    # pairs of (raw, encoded) bytes to test - should encode/decode correctly
+    encoded_data = None
+
+    # tuples of (encoded, value, bits) for known integer encodings
+    encoded_ints = None
+
+    # invalid encoded byte
+    bad_byte = b"?"
+
+    # helper to generate bytemap-specific strings
+    def m(self, *offsets):
+        """generate byte string from offsets"""
+        return join_bytes(self.engine.bytemap[o:o+1] for o in offsets)
+
+    #===================================================================
+    # test encode_bytes
+    #===================================================================
+    def test_encode_bytes(self):
+        """test encode_bytes() against reference inputs"""
+        engine = self.engine
+        encode = engine.encode_bytes
+        for raw, encoded in self.encoded_data:
+            result = encode(raw)
+            self.assertEqual(result, encoded, "encode %r:" % (raw,))
+
+    def test_encode_bytes_bad(self):
+        """test encode_bytes() with bad input"""
+        engine = self.engine
+        encode = engine.encode_bytes
+        self.assertRaises(TypeError, encode, u('\x00'))
+        self.assertRaises(TypeError, encode, None)
+
+    #===================================================================
+    # test decode_bytes
+    #===================================================================
+    def test_decode_bytes(self):
+        """test decode_bytes() against reference inputs"""
+        engine = self.engine
+        decode = engine.decode_bytes
+        for raw, encoded in self.encoded_data:
+            result = decode(encoded)
+            self.assertEqual(result, raw, "decode %r:" % (encoded,))
+
+    def test_decode_bytes_padding(self):
+        """test decode_bytes() ignores padding bits"""
+        bchr = (lambda v: bytes([v])) if PY3 else chr
+        engine = self.engine
+        m = self.m
+        decode = engine.decode_bytes
+        BNULL = b"\x00"
+
+        # length == 2 mod 4: 4 bits of padding
+        self.assertEqual(decode(m(0,0)), BNULL)
+        for i in range(0,6):
+            if engine.big: # 4 lsb padding
+                correct = BNULL if i < 4 else bchr(1<<(i-4))
+            else: # 4 msb padding
+                correct = bchr(1<<(i+6)) if i < 2 else BNULL
+            self.assertEqual(decode(m(0,1<<i)), correct, "%d/4 bits:" % i)
+
+        # length == 3 mod 4: 2 bits of padding
+        self.assertEqual(decode(m(0,0,0)), BNULL*2)
+        for i in range(0,6):
+            if engine.big: # 2 lsb are padding
+                correct = BNULL if i < 2 else bchr(1<<(i-2))
+            else: # 2 msg are padding
+                correct = bchr(1<<(i+4)) if i < 4 else BNULL
+            self.assertEqual(decode(m(0,0,1<<i)), BNULL + correct,
+                             "%d/2 bits:" % i)
+
+    def test_decode_bytes_bad(self):
+        """test decode_bytes() with bad input"""
+        engine = self.engine
+        decode = engine.decode_bytes
+
+        # wrong size (1 % 4)
+        self.assertRaises(ValueError, decode, engine.bytemap[:5])
+
+        # wrong char
+        self.assertTrue(self.bad_byte not in engine.bytemap)
+        self.assertRaises(ValueError, decode, self.bad_byte*4)
+
+        # wrong type
+        self.assertRaises(TypeError, decode, engine.charmap[:4])
+        self.assertRaises(TypeError, decode, None)
+
+    #===================================================================
+    # encode_bytes+decode_bytes
+    #===================================================================
+    def test_codec(self):
+        """test encode_bytes/decode_bytes against random data"""
+        engine = self.engine
+        from passlib.utils import getrandbytes, getrandstr
+        rng = self.getRandom()
+        saw_zero = False
+        for i in irange(500):
+            #
+            # test raw -> encode() -> decode() -> raw
+            #
+
+            # generate some random bytes
+            size = rng.randint(1 if saw_zero else 0, 12)
+            if not size:
+                saw_zero = True
+            enc_size = (4*size+2)//3
+            raw = getrandbytes(rng, size)
+
+            # encode them, check invariants
+            encoded = engine.encode_bytes(raw)
+            self.assertEqual(len(encoded), enc_size)
+
+            # make sure decode returns original
+            result = engine.decode_bytes(encoded)
+            self.assertEqual(result, raw)
+
+            #
+            # test encoded -> decode() -> encode() -> encoded
+            #
+
+            # generate some random encoded data
+            if size % 4 == 1:
+                size += rng.choice([-1,1,2])
+            raw_size = 3*size//4
+            encoded = getrandstr(rng, engine.bytemap, size)
+
+            # decode them, check invariants
+            raw = engine.decode_bytes(encoded)
+            self.assertEqual(len(raw), raw_size, "encoded %d:" % size)
+
+            # make sure encode returns original (barring padding bits)
+            result = engine.encode_bytes(raw)
+            if size % 4:
+                self.assertEqual(result[:-1], encoded[:-1])
+            else:
+                self.assertEqual(result, encoded)
+
+    def test_repair_unused(self):
+        """test repair_unused()"""
+        # NOTE: this test relies on encode_bytes() always returning clear
+        # padding bits - which should be ensured by test vectors.
+        from passlib.utils import getrandstr
+        rng = self.getRandom()
+        engine = self.engine
+        check_repair_unused = self.engine.check_repair_unused
+        i = 0
+        while i < 300:
+            size = rng.randint(0,23)
+            cdata = getrandstr(rng, engine.charmap, size).encode("ascii")
+            if size & 3 == 1:
+                # should throw error
+                self.assertRaises(ValueError, check_repair_unused, cdata)
+                continue
+            rdata = engine.encode_bytes(engine.decode_bytes(cdata))
+            if rng.random() < .5:
+                cdata = cdata.decode("ascii")
+                rdata = rdata.decode("ascii")
+            if cdata == rdata:
+                # should leave unchanged
+                ok, result = check_repair_unused(cdata)
+                self.assertFalse(ok)
+                self.assertEqual(result, rdata)
+            else:
+                # should repair bits
+                self.assertNotEqual(size % 4, 0)
+                ok, result = check_repair_unused(cdata)
+                self.assertTrue(ok)
+                self.assertEqual(result, rdata)
+            i += 1
+
+    #===================================================================
+    # test transposed encode/decode - encoding independant
+    #===================================================================
+    # NOTE: these tests assume normal encode/decode has been tested elsewhere.
+
+    transposed = [
+        # orig, result, transpose map
+        (b"\x33\x22\x11", b"\x11\x22\x33",[2,1,0]),
+        (b"\x22\x33\x11", b"\x11\x22\x33",[1,2,0]),
+    ]
+
+    transposed_dups = [
+        # orig, result, transpose projection
+        (b"\x11\x11\x22", b"\x11\x22\x33",[0,0,1]),
+    ]
+
+    def test_encode_transposed_bytes(self):
+        """test encode_transposed_bytes()"""
+        engine = self.engine
+        for result, input, offsets in self.transposed + self.transposed_dups:
+            tmp = engine.encode_transposed_bytes(input, offsets)
+            out = engine.decode_bytes(tmp)
+            self.assertEqual(out, result)
+
+        self.assertRaises(TypeError, engine.encode_transposed_bytes, u("a"), [])
+
+    def test_decode_transposed_bytes(self):
+        """test decode_transposed_bytes()"""
+        engine = self.engine
+        for input, result, offsets in self.transposed:
+            tmp = engine.encode_bytes(input)
+            out = engine.decode_transposed_bytes(tmp, offsets)
+            self.assertEqual(out, result)
+
+    def test_decode_transposed_bytes_bad(self):
+        """test decode_transposed_bytes() fails if map is a one-way"""
+        engine = self.engine
+        for input, _, offsets in self.transposed_dups:
+            tmp = engine.encode_bytes(input)
+            self.assertRaises(TypeError, engine.decode_transposed_bytes, tmp,
+                              offsets)
+
+    #===================================================================
+    # test 6bit handling
+    #===================================================================
+    def check_int_pair(self, bits, encoded_pairs):
+        """helper to check encode_intXX & decode_intXX functions"""
+        rng = self.getRandom()
+        engine = self.engine
+        encode = getattr(engine, "encode_int%s" % bits)
+        decode = getattr(engine, "decode_int%s" % bits)
+        pad = -bits % 6
+        chars = (bits+pad)//6
+        upper = 1<<bits
+
+        # test encode func
+        for value, encoded in encoded_pairs:
+            result = encode(value)
+            self.assertIsInstance(result, bytes)
+            self.assertEqual(result, encoded)
+        self.assertRaises(ValueError, encode, -1)
+        self.assertRaises(ValueError, encode, upper)
+
+        # test decode func
+        for value, encoded in encoded_pairs:
+            self.assertEqual(decode(encoded), value, "encoded %r:" % (encoded,))
+        m = self.m
+        self.assertRaises(ValueError, decode, m(0)*(chars+1))
+        self.assertRaises(ValueError, decode, m(0)*(chars-1))
+        self.assertRaises(ValueError, decode, self.bad_byte*chars)
+        self.assertRaises(TypeError, decode, engine.charmap[0])
+        self.assertRaises(TypeError, decode, None)
+
+        # do random testing.
+        from passlib.utils import getrandstr
+        for i in irange(100):
+            # generate random value, encode, and then decode
+            value = rng.randint(0, upper-1)
+            encoded = encode(value)
+            self.assertEqual(len(encoded), chars)
+            self.assertEqual(decode(encoded), value)
+
+            # generate some random encoded data, decode, then encode.
+            encoded = getrandstr(rng, engine.bytemap, chars)
+            value = decode(encoded)
+            self.assertGreaterEqual(value, 0, "decode %r out of bounds:" % encoded)
+            self.assertLess(value, upper, "decode %r out of bounds:" % encoded)
+            result = encode(value)
+            if pad:
+                self.assertEqual(result[:-2], encoded[:-2])
+            else:
+                self.assertEqual(result, encoded)
+
+    def test_int6(self):
+        engine = self.engine
+        m = self.m
+        self.check_int_pair(6, [(0, m(0)), (63, m(63))])
+
+    def test_int12(self):
+        engine = self.engine
+        m = self.m
+        self.check_int_pair(12,[(0, m(0,0)),
+            (63, m(0,63) if engine.big else m(63,0)), (0xFFF, m(63,63))])
+
+    def test_int24(self):
+        engine = self.engine
+        m = self.m
+        self.check_int_pair(24,[(0, m(0,0,0,0)),
+            (63, m(0,0,0,63) if engine.big else m(63,0,0,0)),
+            (0xFFFFFF, m(63,63,63,63))])
+
+    def test_int64(self):
+        # NOTE: this isn't multiple of 6, it has 2 padding bits appended
+        # before encoding.
+        engine = self.engine
+        m = self.m
+        self.check_int_pair(64, [(0, m(0,0,0,0, 0,0,0,0, 0,0,0)),
+                (63, m(0,0,0,0, 0,0,0,0, 0,3,60) if engine.big else
+                     m(63,0,0,0, 0,0,0,0, 0,0,0)),
+                ((1<<64)-1, m(63,63,63,63, 63,63,63,63, 63,63,60) if engine.big
+                    else m(63,63,63,63, 63,63,63,63, 63,63,15))])
+
+    def test_encoded_ints(self):
+        """test against reference integer encodings"""
+        if not self.encoded_ints:
+            raise self.skipTests("none defined for class")
+        engine = self.engine
+        for data, value, bits in self.encoded_ints:
+            encode = getattr(engine, "encode_int%d" % bits)
+            decode = getattr(engine, "decode_int%d" % bits)
+            self.assertEqual(encode(value), data)
+            self.assertEqual(decode(data), value)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+# NOTE: testing H64 & H64Big should be sufficient to verify
+# that Base64Engine() works in general.
+from passlib.utils.binary import h64, h64big
+
+class H64_Test(_Base64Test):
+    """test H64 codec functions"""
+    engine = h64
+    descriptionPrefix = "h64 codec"
+
+    encoded_data = [
+        # test lengths 0..6 to ensure tail is encoded properly
+        (b"",b""),
+        (b"\x55",b"J/"),
+        (b"\x55\xaa",b"Jd8"),
+        (b"\x55\xaa\x55",b"JdOJ"),
+        (b"\x55\xaa\x55\xaa",b"JdOJe0"),
+        (b"\x55\xaa\x55\xaa\x55",b"JdOJeK3"),
+        (b"\x55\xaa\x55\xaa\x55\xaa",b"JdOJeKZe"),
+
+        # test padding bits are null
+        (b"\x55\xaa\x55\xaf",b"JdOJj0"), # len = 1 mod 3
+        (b"\x55\xaa\x55\xaa\x5f",b"JdOJey3"), # len = 2 mod 3
+    ]
+
+    encoded_ints = [
+        (b"z.", 63, 12),
+        (b".z", 4032, 12),
+    ]
+
+class H64Big_Test(_Base64Test):
+    """test H64Big codec functions"""
+    engine = h64big
+    descriptionPrefix = "h64big codec"
+
+    encoded_data = [
+        # test lengths 0..6 to ensure tail is encoded properly
+        (b"",b""),
+        (b"\x55",b"JE"),
+        (b"\x55\xaa",b"JOc"),
+        (b"\x55\xaa\x55",b"JOdJ"),
+        (b"\x55\xaa\x55\xaa",b"JOdJeU"),
+        (b"\x55\xaa\x55\xaa\x55",b"JOdJeZI"),
+        (b"\x55\xaa\x55\xaa\x55\xaa",b"JOdJeZKe"),
+
+        # test padding bits are null
+        (b"\x55\xaa\x55\xaf",b"JOdJfk"), # len = 1 mod 3
+        (b"\x55\xaa\x55\xaa\x5f",b"JOdJeZw"), # len = 2 mod 3
+    ]
+
+    encoded_ints = [
+        (b".z", 63, 12),
+        (b"z.", 4032, 12),
+    ]
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_utils_handlers.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_utils_handlers.py
new file mode 100644
index 0000000..19cd4ca
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_utils_handlers.py
@@ -0,0 +1,870 @@
+"""tests for passlib.hash -- (c) Assurance Technologies 2003-2009"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+import re
+import hashlib
+from logging import getLogger
+import warnings
+# site
+# pkg
+from passlib.hash import ldap_md5, sha256_crypt
+from passlib.exc import MissingBackendError, PasslibHashWarning
+from passlib.utils.compat import str_to_uascii, \
+                                 uascii_to_str, unicode
+import passlib.utils.handlers as uh
+from passlib.tests.utils import HandlerCase, TestCase
+from passlib.utils.compat import u
+# module
+log = getLogger(__name__)
+
+#=============================================================================
+# utils
+#=============================================================================
+def _makelang(alphabet, size):
+    """generate all strings of given size using alphabet"""
+    def helper(size):
+        if size < 2:
+            for char in alphabet:
+                yield char
+        else:
+            for char in alphabet:
+                for tail in helper(size-1):
+                    yield char+tail
+    return set(helper(size))
+
+#=============================================================================
+# test GenericHandler & associates mixin classes
+#=============================================================================
+class SkeletonTest(TestCase):
+    """test hash support classes"""
+
+    #===================================================================
+    # StaticHandler
+    #===================================================================
+    def test_00_static_handler(self):
+        """test StaticHandler class"""
+
+        class d1(uh.StaticHandler):
+            name = "d1"
+            context_kwds = ("flag",)
+            _hash_prefix = u("_")
+            checksum_chars = u("ab")
+            checksum_size = 1
+
+            def __init__(self, flag=False, **kwds):
+                super(d1, self).__init__(**kwds)
+                self.flag = flag
+
+            def _calc_checksum(self, secret):
+                return u('b') if self.flag else u('a')
+
+        # check default identify method
+        self.assertTrue(d1.identify(u('_a')))
+        self.assertTrue(d1.identify(b'_a'))
+        self.assertTrue(d1.identify(u('_b')))
+
+        self.assertFalse(d1.identify(u('_c')))
+        self.assertFalse(d1.identify(b'_c'))
+        self.assertFalse(d1.identify(u('a')))
+        self.assertFalse(d1.identify(u('b')))
+        self.assertFalse(d1.identify(u('c')))
+        self.assertRaises(TypeError, d1.identify, None)
+        self.assertRaises(TypeError, d1.identify, 1)
+
+        # check default genconfig method
+        self.assertEqual(d1.genconfig(), d1.hash(""))
+
+        # check default verify method
+        self.assertTrue(d1.verify('s', b'_a'))
+        self.assertTrue(d1.verify('s',u('_a')))
+        self.assertFalse(d1.verify('s', b'_b'))
+        self.assertFalse(d1.verify('s',u('_b')))
+        self.assertTrue(d1.verify('s', b'_b', flag=True))
+        self.assertRaises(ValueError, d1.verify, 's', b'_c')
+        self.assertRaises(ValueError, d1.verify, 's', u('_c'))
+
+        # check default hash method
+        self.assertEqual(d1.hash('s'), '_a')
+        self.assertEqual(d1.hash('s', flag=True), '_b')
+
+    def test_01_calc_checksum_hack(self):
+        """test StaticHandler legacy attr"""
+        # release 1.5 StaticHandler required genhash(),
+        # not _calc_checksum, be implemented. we have backward compat wrapper,
+        # this tests that it works.
+
+        class d1(uh.StaticHandler):
+            name = "d1"
+
+            @classmethod
+            def identify(cls, hash):
+                if not hash or len(hash) != 40:
+                    return False
+                try:
+                    int(hash, 16)
+                except ValueError:
+                    return False
+                return True
+
+            @classmethod
+            def genhash(cls, secret, hash):
+                if secret is None:
+                    raise TypeError("no secret provided")
+                if isinstance(secret, unicode):
+                    secret = secret.encode("utf-8")
+                # NOTE: have to support hash=None since this is test of legacy 1.5 api
+                if hash is not None and not cls.identify(hash):
+                    raise ValueError("invalid hash")
+                return hashlib.sha1(b"xyz" + secret).hexdigest()
+
+            @classmethod
+            def verify(cls, secret, hash):
+                if hash is None:
+                    raise ValueError("no hash specified")
+                return cls.genhash(secret, hash) == hash.lower()
+
+        # hash should issue api warnings, but everything else should be fine.
+        with self.assertWarningList("d1.*should be updated.*_calc_checksum"):
+            hash = d1.hash("test")
+        self.assertEqual(hash, '7c622762588a0e5cc786ad0a143156f9fd38eea3')
+
+        self.assertTrue(d1.verify("test", hash))
+        self.assertFalse(d1.verify("xtest", hash))
+
+        # not defining genhash either, however, should cause NotImplementedError
+        del d1.genhash
+        self.assertRaises(NotImplementedError, d1.hash, 'test')
+
+    #===================================================================
+    # GenericHandler & mixins
+    #===================================================================
+    def test_10_identify(self):
+        """test GenericHandler.identify()"""
+        class d1(uh.GenericHandler):
+            @classmethod
+            def from_string(cls, hash):
+                if isinstance(hash, bytes):
+                    hash = hash.decode("ascii")
+                if hash == u('a'):
+                    return cls(checksum=hash)
+                else:
+                    raise ValueError
+
+        # check fallback
+        self.assertRaises(TypeError, d1.identify, None)
+        self.assertRaises(TypeError, d1.identify, 1)
+        self.assertFalse(d1.identify(''))
+        self.assertTrue(d1.identify('a'))
+        self.assertFalse(d1.identify('b'))
+
+        # check regexp
+        d1._hash_regex = re.compile(u('@.'))
+        self.assertRaises(TypeError, d1.identify, None)
+        self.assertRaises(TypeError, d1.identify, 1)
+        self.assertTrue(d1.identify('@a'))
+        self.assertFalse(d1.identify('a'))
+        del d1._hash_regex
+
+        # check ident-based
+        d1.ident = u('!')
+        self.assertRaises(TypeError, d1.identify, None)
+        self.assertRaises(TypeError, d1.identify, 1)
+        self.assertTrue(d1.identify('!a'))
+        self.assertFalse(d1.identify('a'))
+        del d1.ident
+
+    def test_11_norm_checksum(self):
+        """test GenericHandler checksum handling"""
+        # setup helpers
+        class d1(uh.GenericHandler):
+            name = 'd1'
+            checksum_size = 4
+            checksum_chars = u('xz')
+
+        def norm_checksum(checksum=None, **k):
+            return d1(checksum=checksum, **k).checksum
+
+        # too small
+        self.assertRaises(ValueError, norm_checksum, u('xxx'))
+
+        # right size
+        self.assertEqual(norm_checksum(u('xxxx')), u('xxxx'))
+        self.assertEqual(norm_checksum(u('xzxz')), u('xzxz'))
+
+        # too large
+        self.assertRaises(ValueError, norm_checksum, u('xxxxx'))
+
+        # wrong chars
+        self.assertRaises(ValueError, norm_checksum, u('xxyx'))
+
+        # wrong type
+        self.assertRaises(TypeError, norm_checksum, b'xxyx')
+
+        # relaxed
+        # NOTE: this could be turned back on if we test _norm_checksum() directly...
+        #with self.assertWarningList("checksum should be unicode"):
+        #    self.assertEqual(norm_checksum(b'xxzx', relaxed=True), u('xxzx'))
+        #self.assertRaises(TypeError, norm_checksum, 1, relaxed=True)
+
+        # test _stub_checksum behavior
+        self.assertEqual(d1()._stub_checksum, u('xxxx'))
+
+    def test_12_norm_checksum_raw(self):
+        """test GenericHandler + HasRawChecksum mixin"""
+        class d1(uh.HasRawChecksum, uh.GenericHandler):
+            name = 'd1'
+            checksum_size = 4
+
+        def norm_checksum(*a, **k):
+            return d1(*a, **k).checksum
+
+        # test bytes
+        self.assertEqual(norm_checksum(b'1234'), b'1234')
+
+        # test unicode
+        self.assertRaises(TypeError, norm_checksum, u('xxyx'))
+
+        # NOTE: this could be turned back on if we test _norm_checksum() directly...
+        # self.assertRaises(TypeError, norm_checksum, u('xxyx'), relaxed=True)
+
+        # test _stub_checksum behavior
+        self.assertEqual(d1()._stub_checksum, b'\x00'*4)
+
+    def test_20_norm_salt(self):
+        """test GenericHandler + HasSalt mixin"""
+        # setup helpers
+        class d1(uh.HasSalt, uh.GenericHandler):
+            name = 'd1'
+            setting_kwds = ('salt',)
+            min_salt_size = 2
+            max_salt_size = 4
+            default_salt_size = 3
+            salt_chars = 'ab'
+
+        def norm_salt(**k):
+            return d1(**k).salt
+
+        def gen_salt(sz, **k):
+            return d1.using(salt_size=sz, **k)(use_defaults=True).salt
+
+        salts2 = _makelang('ab', 2)
+        salts3 = _makelang('ab', 3)
+        salts4 = _makelang('ab', 4)
+
+        # check salt=None
+        self.assertRaises(TypeError, norm_salt)
+        self.assertRaises(TypeError, norm_salt, salt=None)
+        self.assertIn(norm_salt(use_defaults=True), salts3)
+
+        # check explicit salts
+        with warnings.catch_warnings(record=True) as wlog:
+
+            # check too-small salts
+            self.assertRaises(ValueError, norm_salt, salt='')
+            self.assertRaises(ValueError, norm_salt, salt='a')
+            self.consumeWarningList(wlog)
+
+            # check correct salts
+            self.assertEqual(norm_salt(salt='ab'), 'ab')
+            self.assertEqual(norm_salt(salt='aba'), 'aba')
+            self.assertEqual(norm_salt(salt='abba'), 'abba')
+            self.consumeWarningList(wlog)
+
+            # check too-large salts
+            self.assertRaises(ValueError, norm_salt, salt='aaaabb')
+            self.consumeWarningList(wlog)
+
+        # check generated salts
+        with warnings.catch_warnings(record=True) as wlog:
+
+            # check too-small salt size
+            self.assertRaises(ValueError, gen_salt, 0)
+            self.assertRaises(ValueError, gen_salt, 1)
+            self.consumeWarningList(wlog)
+
+            # check correct salt size
+            self.assertIn(gen_salt(2), salts2)
+            self.assertIn(gen_salt(3), salts3)
+            self.assertIn(gen_salt(4), salts4)
+            self.consumeWarningList(wlog)
+
+            # check too-large salt size
+            self.assertRaises(ValueError, gen_salt, 5)
+            self.consumeWarningList(wlog)
+
+            self.assertIn(gen_salt(5, relaxed=True), salts4)
+            self.consumeWarningList(wlog, ["salt_size.*above max_salt_size"])
+
+        # test with max_salt_size=None
+        del d1.max_salt_size
+        with self.assertWarningList([]):
+            self.assertEqual(len(gen_salt(None)), 3)
+            self.assertEqual(len(gen_salt(5)), 5)
+
+    # TODO: test HasRawSalt mixin
+
+    def test_30_init_rounds(self):
+        """test GenericHandler + HasRounds mixin"""
+        # setup helpers
+        class d1(uh.HasRounds, uh.GenericHandler):
+            name = 'd1'
+            setting_kwds = ('rounds',)
+            min_rounds = 1
+            max_rounds = 3
+            default_rounds = 2
+
+        # NOTE: really is testing _init_rounds(), could dup to test _norm_rounds() via .replace
+        def norm_rounds(**k):
+            return d1(**k).rounds
+
+        # check rounds=None
+        self.assertRaises(TypeError, norm_rounds)
+        self.assertRaises(TypeError, norm_rounds, rounds=None)
+        self.assertEqual(norm_rounds(use_defaults=True), 2)
+
+        # check rounds=non int
+        self.assertRaises(TypeError, norm_rounds, rounds=1.5)
+
+        # check explicit rounds
+        with warnings.catch_warnings(record=True) as wlog:
+            # too small
+            self.assertRaises(ValueError, norm_rounds, rounds=0)
+            self.consumeWarningList(wlog)
+
+            # just right
+            self.assertEqual(norm_rounds(rounds=1), 1)
+            self.assertEqual(norm_rounds(rounds=2), 2)
+            self.assertEqual(norm_rounds(rounds=3), 3)
+            self.consumeWarningList(wlog)
+
+            # too large
+            self.assertRaises(ValueError, norm_rounds, rounds=4)
+            self.consumeWarningList(wlog)
+
+        # check no default rounds
+        d1.default_rounds = None
+        self.assertRaises(TypeError, norm_rounds, use_defaults=True)
+
+    def test_40_backends(self):
+        """test GenericHandler + HasManyBackends mixin"""
+        class d1(uh.HasManyBackends, uh.GenericHandler):
+            name = 'd1'
+            setting_kwds = ()
+
+            backends = ("a", "b")
+
+            _enable_a = False
+            _enable_b = False
+
+            @classmethod
+            def _load_backend_a(cls):
+                if cls._enable_a:
+                    cls._set_calc_checksum_backend(cls._calc_checksum_a)
+                    return True
+                else:
+                    return False
+
+            @classmethod
+            def _load_backend_b(cls):
+                if cls._enable_b:
+                    cls._set_calc_checksum_backend(cls._calc_checksum_b)
+                    return True
+                else:
+                    return False
+
+            def _calc_checksum_a(self, secret):
+                return 'a'
+
+            def _calc_checksum_b(self, secret):
+                return 'b'
+
+        # test no backends
+        self.assertRaises(MissingBackendError, d1.get_backend)
+        self.assertRaises(MissingBackendError, d1.set_backend)
+        self.assertRaises(MissingBackendError, d1.set_backend, 'any')
+        self.assertRaises(MissingBackendError, d1.set_backend, 'default')
+        self.assertFalse(d1.has_backend())
+
+        # enable 'b' backend
+        d1._enable_b = True
+
+        # test lazy load
+        obj = d1()
+        self.assertEqual(obj._calc_checksum('s'), 'b')
+
+        # test repeat load
+        d1.set_backend('b')
+        d1.set_backend('any')
+        self.assertEqual(obj._calc_checksum('s'), 'b')
+
+        # test unavailable
+        self.assertRaises(MissingBackendError, d1.set_backend, 'a')
+        self.assertTrue(d1.has_backend('b'))
+        self.assertFalse(d1.has_backend('a'))
+
+        # enable 'a' backend also
+        d1._enable_a = True
+
+        # test explicit
+        self.assertTrue(d1.has_backend())
+        d1.set_backend('a')
+        self.assertEqual(obj._calc_checksum('s'), 'a')
+
+        # test unknown backend
+        self.assertRaises(ValueError, d1.set_backend, 'c')
+        self.assertRaises(ValueError, d1.has_backend, 'c')
+
+        # test error thrown if _has & _load are mixed
+        d1.set_backend("b")  # switch away from 'a' so next call actually checks loader
+        class d2(d1):
+            _has_backend_a = True
+        self.assertRaises(AssertionError, d2.has_backend, "a")
+
+    def test_41_backends(self):
+        """test GenericHandler + HasManyBackends mixin (deprecated api)"""
+        warnings.filterwarnings("ignore",
+            category=DeprecationWarning,
+            message=r".* support for \._has_backend_.* is deprecated.*",
+            )
+
+        class d1(uh.HasManyBackends, uh.GenericHandler):
+            name = 'd1'
+            setting_kwds = ()
+
+            backends = ("a", "b")
+
+            _has_backend_a = False
+            _has_backend_b = False
+
+            def _calc_checksum_a(self, secret):
+                return 'a'
+
+            def _calc_checksum_b(self, secret):
+                return 'b'
+
+        # test no backends
+        self.assertRaises(MissingBackendError, d1.get_backend)
+        self.assertRaises(MissingBackendError, d1.set_backend)
+        self.assertRaises(MissingBackendError, d1.set_backend, 'any')
+        self.assertRaises(MissingBackendError, d1.set_backend, 'default')
+        self.assertFalse(d1.has_backend())
+
+        # enable 'b' backend
+        d1._has_backend_b = True
+
+        # test lazy load
+        obj = d1()
+        self.assertEqual(obj._calc_checksum('s'), 'b')
+
+        # test repeat load
+        d1.set_backend('b')
+        d1.set_backend('any')
+        self.assertEqual(obj._calc_checksum('s'), 'b')
+
+        # test unavailable
+        self.assertRaises(MissingBackendError, d1.set_backend, 'a')
+        self.assertTrue(d1.has_backend('b'))
+        self.assertFalse(d1.has_backend('a'))
+
+        # enable 'a' backend also
+        d1._has_backend_a = True
+
+        # test explicit
+        self.assertTrue(d1.has_backend())
+        d1.set_backend('a')
+        self.assertEqual(obj._calc_checksum('s'), 'a')
+
+        # test unknown backend
+        self.assertRaises(ValueError, d1.set_backend, 'c')
+        self.assertRaises(ValueError, d1.has_backend, 'c')
+
+    def test_50_norm_ident(self):
+        """test GenericHandler + HasManyIdents"""
+        # setup helpers
+        class d1(uh.HasManyIdents, uh.GenericHandler):
+            name = 'd1'
+            setting_kwds = ('ident',)
+            default_ident = u("!A")
+            ident_values = (u("!A"), u("!B"))
+            ident_aliases = { u("A"): u("!A")}
+
+        def norm_ident(**k):
+            return d1(**k).ident
+
+        # check ident=None
+        self.assertRaises(TypeError, norm_ident)
+        self.assertRaises(TypeError, norm_ident, ident=None)
+        self.assertEqual(norm_ident(use_defaults=True), u('!A'))
+
+        # check valid idents
+        self.assertEqual(norm_ident(ident=u('!A')), u('!A'))
+        self.assertEqual(norm_ident(ident=u('!B')), u('!B'))
+        self.assertRaises(ValueError, norm_ident, ident=u('!C'))
+
+        # check aliases
+        self.assertEqual(norm_ident(ident=u('A')), u('!A'))
+
+        # check invalid idents
+        self.assertRaises(ValueError, norm_ident, ident=u('B'))
+
+        # check identify is honoring ident system
+        self.assertTrue(d1.identify(u("!Axxx")))
+        self.assertTrue(d1.identify(u("!Bxxx")))
+        self.assertFalse(d1.identify(u("!Cxxx")))
+        self.assertFalse(d1.identify(u("A")))
+        self.assertFalse(d1.identify(u("")))
+        self.assertRaises(TypeError, d1.identify, None)
+        self.assertRaises(TypeError, d1.identify, 1)
+
+        # check default_ident missing is detected.
+        d1.default_ident = None
+        self.assertRaises(AssertionError, norm_ident, use_defaults=True)
+
+    #===================================================================
+    # experimental - the following methods are not finished or tested,
+    # but way work correctly for some hashes
+    #===================================================================
+    def test_91_parsehash(self):
+        """test parsehash()"""
+        # NOTE: this just tests some existing GenericHandler classes
+        from passlib import hash
+
+        #
+        # parsehash()
+        #
+
+        # simple hash w/ salt
+        result = hash.des_crypt.parsehash("OgAwTx2l6NADI")
+        self.assertEqual(result, {'checksum': u('AwTx2l6NADI'), 'salt': u('Og')})
+
+        # parse rounds and extra implicit_rounds flag
+        h = '$5$LKO/Ute40T3FNF95$U0prpBQd4PloSGU0pnpM4z9wKn4vZ1.jsrzQfPqxph9'
+        s = u('LKO/Ute40T3FNF95')
+        c = u('U0prpBQd4PloSGU0pnpM4z9wKn4vZ1.jsrzQfPqxph9')
+        result = hash.sha256_crypt.parsehash(h)
+        self.assertEqual(result, dict(salt=s, rounds=5000,
+                                      implicit_rounds=True, checksum=c))
+
+        # omit checksum
+        result = hash.sha256_crypt.parsehash(h, checksum=False)
+        self.assertEqual(result, dict(salt=s, rounds=5000, implicit_rounds=True))
+
+        # sanitize
+        result = hash.sha256_crypt.parsehash(h, sanitize=True)
+        self.assertEqual(result, dict(rounds=5000, implicit_rounds=True,
+            salt=u('LK**************'),
+             checksum=u('U0pr***************************************')))
+
+        # parse w/o implicit rounds flag
+        result = hash.sha256_crypt.parsehash('$5$rounds=10428$uy/jIAhCetNCTtb0$YWvUOXbkqlqhyoPMpN8BMe.ZGsGx2aBvxTvDFI613c3')
+        self.assertEqual(result, dict(
+            checksum=u('YWvUOXbkqlqhyoPMpN8BMe.ZGsGx2aBvxTvDFI613c3'),
+            salt=u('uy/jIAhCetNCTtb0'),
+            rounds=10428,
+        ))
+
+        # parsing of raw checksums & salts
+        h1 = '$pbkdf2$60000$DoEwpvQeA8B4T.k951yLUQ$O26Y3/NJEiLCVaOVPxGXshyjW8k'
+        result = hash.pbkdf2_sha1.parsehash(h1)
+        self.assertEqual(result, dict(
+            checksum=b';n\x98\xdf\xf3I\x12"\xc2U\xa3\x95?\x11\x97\xb2\x1c\xa3[\xc9',
+            rounds=60000,
+            salt=b'\x0e\x810\xa6\xf4\x1e\x03\xc0xO\xe9=\xe7\\\x8bQ',
+        ))
+
+        # sanitizing of raw checksums & salts
+        result = hash.pbkdf2_sha1.parsehash(h1, sanitize=True)
+        self.assertEqual(result, dict(
+            checksum=u('O26************************'),
+            rounds=60000,
+            salt=u('Do********************'),
+        ))
+
+    def test_92_bitsize(self):
+        """test bitsize()"""
+        # NOTE: this just tests some existing GenericHandler classes
+        from passlib import hash
+
+        # no rounds
+        self.assertEqual(hash.des_crypt.bitsize(),
+                         {'checksum': 66, 'salt': 12})
+
+        # log2 rounds
+        self.assertEqual(hash.bcrypt.bitsize(),
+                         {'checksum': 186, 'salt': 132})
+
+        # linear rounds
+        # NOTE: +3 comes from int(math.log(.1,2)),
+        #       where 0.1 = 10% = default allowed variation in rounds
+        self.patchAttr(hash.sha256_crypt, "default_rounds", 1 << (14 + 3))
+        self.assertEqual(hash.sha256_crypt.bitsize(),
+                         {'checksum': 258, 'rounds': 14, 'salt': 96})
+
+        # raw checksum
+        self.patchAttr(hash.pbkdf2_sha1, "default_rounds", 1 << (13 + 3))
+        self.assertEqual(hash.pbkdf2_sha1.bitsize(),
+                         {'checksum': 160, 'rounds': 13, 'salt': 128})
+
+        # TODO: handle fshp correctly, and other glitches noted in code.
+        ##self.assertEqual(hash.fshp.bitsize(variant=1),
+        ##                {'checksum': 256, 'rounds': 13, 'salt': 128})
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# PrefixWrapper
+#=============================================================================
+class dummy_handler_in_registry(object):
+    """context manager that inserts dummy handler in registry"""
+    def __init__(self, name):
+        self.name = name
+        self.dummy = type('dummy_' + name, (uh.GenericHandler,), dict(
+            name=name,
+            setting_kwds=(),
+        ))
+
+    def __enter__(self):
+        from passlib import registry
+        registry._unload_handler_name(self.name, locations=False)
+        registry.register_crypt_handler(self.dummy)
+        assert registry.get_crypt_handler(self.name) is self.dummy
+        return self.dummy
+
+    def __exit__(self, *exc_info):
+        from passlib import registry
+        registry._unload_handler_name(self.name, locations=False)
+
+class PrefixWrapperTest(TestCase):
+    """test PrefixWrapper class"""
+
+    def test_00_lazy_loading(self):
+        """test PrefixWrapper lazy loading of handler"""
+        d1 = uh.PrefixWrapper("d1", "ldap_md5", "{XXX}", "{MD5}", lazy=True)
+
+        # check base state
+        self.assertEqual(d1._wrapped_name, "ldap_md5")
+        self.assertIs(d1._wrapped_handler, None)
+
+        # check loading works
+        self.assertIs(d1.wrapped, ldap_md5)
+        self.assertIs(d1._wrapped_handler, ldap_md5)
+
+        # replace w/ wrong handler, make sure doesn't reload w/ dummy
+        with dummy_handler_in_registry("ldap_md5") as dummy:
+            self.assertIs(d1.wrapped, ldap_md5)
+
+    def test_01_active_loading(self):
+        """test PrefixWrapper active loading of handler"""
+        d1 = uh.PrefixWrapper("d1", "ldap_md5", "{XXX}", "{MD5}")
+
+        # check base state
+        self.assertEqual(d1._wrapped_name, "ldap_md5")
+        self.assertIs(d1._wrapped_handler, ldap_md5)
+        self.assertIs(d1.wrapped, ldap_md5)
+
+        # replace w/ wrong handler, make sure doesn't reload w/ dummy
+        with dummy_handler_in_registry("ldap_md5") as dummy:
+            self.assertIs(d1.wrapped, ldap_md5)
+
+    def test_02_explicit(self):
+        """test PrefixWrapper with explicitly specified handler"""
+
+        d1 = uh.PrefixWrapper("d1", ldap_md5, "{XXX}", "{MD5}")
+
+        # check base state
+        self.assertEqual(d1._wrapped_name, None)
+        self.assertIs(d1._wrapped_handler, ldap_md5)
+        self.assertIs(d1.wrapped, ldap_md5)
+
+        # replace w/ wrong handler, make sure doesn't reload w/ dummy
+        with dummy_handler_in_registry("ldap_md5") as dummy:
+            self.assertIs(d1.wrapped, ldap_md5)
+
+    def test_10_wrapped_attributes(self):
+        d1 = uh.PrefixWrapper("d1", "ldap_md5", "{XXX}", "{MD5}")
+        self.assertEqual(d1.name, "d1")
+        self.assertIs(d1.setting_kwds, ldap_md5.setting_kwds)
+        self.assertFalse('max_rounds' in dir(d1))
+
+        d2 = uh.PrefixWrapper("d2", "sha256_crypt", "{XXX}")
+        self.assertIs(d2.setting_kwds, sha256_crypt.setting_kwds)
+        self.assertTrue('max_rounds' in dir(d2))
+
+    def test_11_wrapped_methods(self):
+        d1 = uh.PrefixWrapper("d1", "ldap_md5", "{XXX}", "{MD5}")
+        dph = "{XXX}X03MO1qnZdYdgyfeuILPmQ=="
+        lph = "{MD5}X03MO1qnZdYdgyfeuILPmQ=="
+
+        # genconfig
+        self.assertEqual(d1.genconfig(), '{XXX}1B2M2Y8AsgTpgAmY7PhCfg==')
+
+        # genhash
+        self.assertRaises(TypeError, d1.genhash, "password", None)
+        self.assertEqual(d1.genhash("password", dph), dph)
+        self.assertRaises(ValueError, d1.genhash, "password", lph)
+
+        # hash
+        self.assertEqual(d1.hash("password"), dph)
+
+        # identify
+        self.assertTrue(d1.identify(dph))
+        self.assertFalse(d1.identify(lph))
+
+        # verify
+        self.assertRaises(ValueError, d1.verify, "password", lph)
+        self.assertTrue(d1.verify("password", dph))
+
+    def test_12_ident(self):
+        # test ident is proxied
+        h = uh.PrefixWrapper("h2", "ldap_md5", "{XXX}")
+        self.assertEqual(h.ident, u("{XXX}{MD5}"))
+        self.assertIs(h.ident_values, None)
+
+        # test lack of ident means no proxy
+        h = uh.PrefixWrapper("h2", "des_crypt", "{XXX}")
+        self.assertIs(h.ident, None)
+        self.assertIs(h.ident_values, None)
+
+        # test orig_prefix disabled ident proxy
+        h = uh.PrefixWrapper("h1", "ldap_md5", "{XXX}", "{MD5}")
+        self.assertIs(h.ident, None)
+        self.assertIs(h.ident_values, None)
+
+        # test custom ident overrides default
+        h = uh.PrefixWrapper("h3", "ldap_md5", "{XXX}", ident="{X")
+        self.assertEqual(h.ident, u("{X"))
+        self.assertIs(h.ident_values, None)
+
+        # test custom ident must match
+        h = uh.PrefixWrapper("h3", "ldap_md5", "{XXX}", ident="{XXX}A")
+        self.assertRaises(ValueError, uh.PrefixWrapper, "h3", "ldap_md5",
+                          "{XXX}", ident="{XY")
+        self.assertRaises(ValueError, uh.PrefixWrapper, "h3", "ldap_md5",
+                          "{XXX}", ident="{XXXX")
+
+        # test ident_values is proxied
+        h = uh.PrefixWrapper("h4", "phpass", "{XXX}")
+        self.assertIs(h.ident, None)
+        self.assertEqual(h.ident_values, (u("{XXX}$P$"), u("{XXX}$H$")))
+
+        # test ident=True means use prefix even if hash has no ident.
+        h = uh.PrefixWrapper("h5", "des_crypt", "{XXX}", ident=True)
+        self.assertEqual(h.ident, u("{XXX}"))
+        self.assertIs(h.ident_values, None)
+
+        # ... but requires prefix
+        self.assertRaises(ValueError, uh.PrefixWrapper, "h6", "des_crypt", ident=True)
+
+        # orig_prefix + HasManyIdent - warning
+        with self.assertWarningList("orig_prefix.*may not work correctly"):
+            h = uh.PrefixWrapper("h7", "phpass", orig_prefix="$", prefix="?")
+        self.assertEqual(h.ident_values, None) # TODO: should output (u("?P$"), u("?H$")))
+        self.assertEqual(h.ident, None)
+
+    def test_13_repr(self):
+        """test repr()"""
+        h = uh.PrefixWrapper("h2", "md5_crypt", "{XXX}", orig_prefix="$1$")
+        self.assertRegex(repr(h),
+            r"""(?x)^PrefixWrapper\(
+                ['"]h2['"],\s+
+                ['"]md5_crypt['"],\s+
+                prefix=u?["']{XXX}['"],\s+
+                orig_prefix=u?["']\$1\$['"]
+            \)$""")
+
+    def test_14_bad_hash(self):
+        """test orig_prefix sanity check"""
+        # shoudl throw InvalidHashError if wrapped hash doesn't begin
+        # with orig_prefix.
+        h = uh.PrefixWrapper("h2", "md5_crypt", orig_prefix="$6$")
+        self.assertRaises(ValueError, h.hash, 'test')
+
+#=============================================================================
+# sample algorithms - these serve as known quantities
+# to test the unittests themselves, as well as other
+# parts of passlib. they shouldn't be used as actual password schemes.
+#=============================================================================
+class UnsaltedHash(uh.StaticHandler):
+    """test algorithm which lacks a salt"""
+    name = "unsalted_test_hash"
+    checksum_chars = uh.LOWER_HEX_CHARS
+    checksum_size = 40
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        data = b"boblious" + secret
+        return str_to_uascii(hashlib.sha1(data).hexdigest())
+
+class SaltedHash(uh.HasSalt, uh.GenericHandler):
+    """test algorithm with a salt"""
+    name = "salted_test_hash"
+    setting_kwds = ("salt",)
+
+    min_salt_size = 2
+    max_salt_size = 4
+    checksum_size = 40
+    salt_chars = checksum_chars = uh.LOWER_HEX_CHARS
+
+    _hash_regex = re.compile(u("^@salt[0-9a-f]{42,44}$"))
+
+    @classmethod
+    def from_string(cls, hash):
+        if not cls.identify(hash):
+            raise uh.exc.InvalidHashError(cls)
+        if isinstance(hash, bytes):
+            hash = hash.decode("ascii")
+        return cls(salt=hash[5:-40], checksum=hash[-40:])
+
+    def to_string(self):
+        hash = u("@salt%s%s") % (self.salt, self.checksum)
+        return uascii_to_str(hash)
+
+    def _calc_checksum(self, secret):
+        if isinstance(secret, unicode):
+            secret = secret.encode("utf-8")
+        data = self.salt.encode("ascii") + secret + self.salt.encode("ascii")
+        return str_to_uascii(hashlib.sha1(data).hexdigest())
+
+#=============================================================================
+# test sample algorithms - really a self-test of HandlerCase
+#=============================================================================
+
+# TODO: provide data samples for algorithms
+#       (positive knowns, negative knowns, invalid identify)
+
+UPASS_TEMP = u('\u0399\u03c9\u03b1\u03bd\u03bd\u03b7\u03c2')
+
+class UnsaltedHashTest(HandlerCase):
+    handler = UnsaltedHash
+
+    known_correct_hashes = [
+        ("password", "61cfd32684c47de231f1f982c214e884133762c0"),
+        (UPASS_TEMP, '96b329d120b97ff81ada770042e44ba87343ad2b'),
+    ]
+
+    def test_bad_kwds(self):
+        self.assertRaises(TypeError, UnsaltedHash, salt='x')
+        self.assertRaises(TypeError, UnsaltedHash.genconfig, rounds=1)
+
+class SaltedHashTest(HandlerCase):
+    handler = SaltedHash
+
+    known_correct_hashes = [
+        ("password", '@salt77d71f8fe74f314dac946766c1ac4a2a58365482c0'),
+        (UPASS_TEMP, '@salt9f978a9bfe360d069b0c13f2afecd570447407fa7e48'),
+    ]
+
+    def test_bad_kwds(self):
+        stub = SaltedHash(use_defaults=True)._stub_checksum
+        self.assertRaises(TypeError, SaltedHash, checksum=stub, salt=None)
+        self.assertRaises(ValueError, SaltedHash, checksum=stub, salt='xxx')
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_utils_md4.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_utils_md4.py
new file mode 100644
index 0000000..5d824a1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_utils_md4.py
@@ -0,0 +1,41 @@
+"""
+passlib.tests -- tests for passlib.utils.md4
+
+.. warning::
+
+    This module & it's functions have been deprecated, and superceded
+    by the functions in passlib.crypto.  This file is being maintained
+    until the deprecated functions are removed, and is only present prevent
+    historical regressions up to that point.  New and more thorough testing
+    is being done by the replacement tests in ``test_utils_crypto_builtin_md4``.
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import warnings
+# site
+# pkg
+# module
+from passlib.tests.test_crypto_builtin_md4 import _Common_MD4_Test
+# local
+__all__ = [
+    "Legacy_MD4_Test",
+]
+#=============================================================================
+# test pure-python MD4 implementation
+#=============================================================================
+class Legacy_MD4_Test(_Common_MD4_Test):
+    descriptionPrefix = "passlib.utils.md4.md4()"
+
+    def setUp(self):
+        super(Legacy_MD4_Test, self).setUp()
+        warnings.filterwarnings("ignore", ".*passlib.utils.md4.*deprecated", DeprecationWarning)
+
+    def get_md4_const(self):
+        from passlib.utils.md4 import md4
+        return md4
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_utils_pbkdf2.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_utils_pbkdf2.py
new file mode 100644
index 0000000..443eb53
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_utils_pbkdf2.py
@@ -0,0 +1,323 @@
+"""
+passlib.tests -- tests for passlib.utils.pbkdf2
+
+.. warning::
+
+    This module & it's functions have been deprecated, and superceded
+    by the functions in passlib.crypto.  This file is being maintained
+    until the deprecated functions are removed, and is only present prevent
+    historical regressions up to that point.  New and more thorough testing
+    is being done by the replacement tests in ``test_utils_crypto.py``.
+"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+import hashlib
+import warnings
+# site
+# pkg
+# module
+from passlib.utils.compat import u, JYTHON
+from passlib.tests.utils import TestCase, hb
+
+#=============================================================================
+# test assorted crypto helpers
+#=============================================================================
+class UtilsTest(TestCase):
+    """test various utils functions"""
+    descriptionPrefix = "passlib.utils.pbkdf2"
+
+    ndn_formats = ["hashlib", "iana"]
+    ndn_values = [
+        # (iana name, hashlib name, ... other unnormalized names)
+        ("md5", "md5",          "SCRAM-MD5-PLUS", "MD-5"),
+        ("sha1", "sha-1",       "SCRAM-SHA-1", "SHA1"),
+        ("sha256", "sha-256",   "SHA_256", "sha2-256"),
+        ("ripemd160", "ripemd-160", "SCRAM-RIPEMD-160", "RIPEmd160",
+            # NOTE: there was an older "RIPEMD" & "RIPEMD-128", but python treates "RIPEMD"
+            #       as alias for "RIPEMD-160"
+            "ripemd", "SCRAM-RIPEMD"),
+        ("test128", "test-128", "TEST128"),
+        ("test2", "test2", "TEST-2"),
+        ("test3_128", "test3-128", "TEST-3-128"),
+    ]
+
+    def setUp(self):
+        super(UtilsTest, self).setUp()
+        warnings.filterwarnings("ignore", ".*passlib.utils.pbkdf2.*deprecated", DeprecationWarning)
+
+    def test_norm_hash_name(self):
+        """norm_hash_name()"""
+        from itertools import chain
+        from passlib.utils.pbkdf2 import norm_hash_name
+        from passlib.crypto.digest import _known_hash_names
+
+        # test formats
+        for format in self.ndn_formats:
+            norm_hash_name("md4", format)
+        self.assertRaises(ValueError, norm_hash_name, "md4", None)
+        self.assertRaises(ValueError, norm_hash_name, "md4", "fake")
+
+        # test types
+        self.assertEqual(norm_hash_name(u("MD4")), "md4")
+        self.assertEqual(norm_hash_name(b"MD4"), "md4")
+        self.assertRaises(TypeError, norm_hash_name, None)
+
+        # test selected results
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", '.*unknown hash')
+            for row in chain(_known_hash_names, self.ndn_values):
+                for idx, format in enumerate(self.ndn_formats):
+                    correct = row[idx]
+                    for value in row:
+                        result = norm_hash_name(value, format)
+                        self.assertEqual(result, correct,
+                                         "name=%r, format=%r:" % (value,
+                                                                  format))
+
+#=============================================================================
+# test PBKDF1 support
+#=============================================================================
+class Pbkdf1_Test(TestCase):
+    """test kdf helpers"""
+    descriptionPrefix = "passlib.utils.pbkdf2.pbkdf1()"
+
+    pbkdf1_tests = [
+        # (password, salt, rounds, keylen, hash, result)
+
+        #
+        # from http://www.di-mgt.com.au/cryptoKDFs.html
+        #
+        (b'password', hb('78578E5A5D63CB06'), 1000, 16, 'sha1', hb('dc19847e05c64d2faf10ebfb4a3d2a20')),
+
+        #
+        # custom
+        #
+        (b'password', b'salt', 1000, 0, 'md5',    b''),
+        (b'password', b'salt', 1000, 1, 'md5',    hb('84')),
+        (b'password', b'salt', 1000, 8, 'md5',    hb('8475c6a8531a5d27')),
+        (b'password', b'salt', 1000, 16, 'md5', hb('8475c6a8531a5d27e386cd496457812c')),
+        (b'password', b'salt', 1000, None, 'md5', hb('8475c6a8531a5d27e386cd496457812c')),
+        (b'password', b'salt', 1000, None, 'sha1', hb('4a8fd48e426ed081b535be5769892fa396293efb')),
+    ]
+    if not JYTHON:
+        pbkdf1_tests.append(
+            (b'password', b'salt', 1000, None, 'md4', hb('f7f2e91100a8f96190f2dd177cb26453'))
+        )
+
+    def setUp(self):
+        super(Pbkdf1_Test, self).setUp()
+        warnings.filterwarnings("ignore", ".*passlib.utils.pbkdf2.*deprecated", DeprecationWarning)
+
+    def test_known(self):
+        """test reference vectors"""
+        from passlib.utils.pbkdf2 import pbkdf1
+        for secret, salt, rounds, keylen, digest, correct in self.pbkdf1_tests:
+            result = pbkdf1(secret, salt, rounds, keylen, digest)
+            self.assertEqual(result, correct)
+
+    def test_border(self):
+        """test border cases"""
+        from passlib.utils.pbkdf2 import pbkdf1
+        def helper(secret=b'secret', salt=b'salt', rounds=1, keylen=1, hash='md5'):
+            return pbkdf1(secret, salt, rounds, keylen, hash)
+        helper()
+
+        # salt/secret wrong type
+        self.assertRaises(TypeError, helper, secret=1)
+        self.assertRaises(TypeError, helper, salt=1)
+
+        # non-existent hashes
+        self.assertRaises(ValueError, helper, hash='missing')
+
+        # rounds < 1 and wrong type
+        self.assertRaises(ValueError, helper, rounds=0)
+        self.assertRaises(TypeError, helper, rounds='1')
+
+        # keylen < 0, keylen > block_size, and wrong type
+        self.assertRaises(ValueError, helper, keylen=-1)
+        self.assertRaises(ValueError, helper, keylen=17, hash='md5')
+        self.assertRaises(TypeError, helper, keylen='1')
+
+#=============================================================================
+# test PBKDF2 support
+#=============================================================================
+class Pbkdf2_Test(TestCase):
+    """test pbkdf2() support"""
+    descriptionPrefix = "passlib.utils.pbkdf2.pbkdf2()"
+
+    pbkdf2_test_vectors = [
+        # (result, secret, salt, rounds, keylen, prf="sha1")
+
+        #
+        # from rfc 3962
+        #
+
+            # test case 1 / 128 bit
+            (
+                hb("cdedb5281bb2f801565a1122b2563515"),
+                b"password", b"ATHENA.MIT.EDUraeburn", 1, 16
+            ),
+
+            # test case 2 / 128 bit
+            (
+                hb("01dbee7f4a9e243e988b62c73cda935d"),
+                b"password", b"ATHENA.MIT.EDUraeburn", 2, 16
+            ),
+
+            # test case 2 / 256 bit
+            (
+                hb("01dbee7f4a9e243e988b62c73cda935da05378b93244ec8f48a99e61ad799d86"),
+                b"password", b"ATHENA.MIT.EDUraeburn", 2, 32
+            ),
+
+            # test case 3 / 256 bit
+            (
+                hb("5c08eb61fdf71e4e4ec3cf6ba1f5512ba7e52ddbc5e5142f708a31e2e62b1e13"),
+                b"password", b"ATHENA.MIT.EDUraeburn", 1200, 32
+            ),
+
+            # test case 4 / 256 bit
+            (
+                hb("d1daa78615f287e6a1c8b120d7062a493f98d203e6be49a6adf4fa574b6e64ee"),
+                b"password", b'\x12\x34\x56\x78\x78\x56\x34\x12', 5, 32
+            ),
+
+            # test case 5 / 256 bit
+            (
+                hb("139c30c0966bc32ba55fdbf212530ac9c5ec59f1a452f5cc9ad940fea0598ed1"),
+                b"X"*64, b"pass phrase equals block size", 1200, 32
+            ),
+
+            # test case 6 / 256 bit
+            (
+                hb("9ccad6d468770cd51b10e6a68721be611a8b4d282601db3b36be9246915ec82a"),
+                b"X"*65, b"pass phrase exceeds block size", 1200, 32
+            ),
+
+        #
+        # from rfc 6070
+        #
+            (
+                hb("0c60c80f961f0e71f3a9b524af6012062fe037a6"),
+                b"password", b"salt", 1, 20,
+            ),
+
+            (
+                hb("ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957"),
+                b"password", b"salt", 2, 20,
+            ),
+
+            (
+                hb("4b007901b765489abead49d926f721d065a429c1"),
+                b"password", b"salt", 4096, 20,
+            ),
+
+            # just runs too long - could enable if ALL option is set
+            ##(
+            ##
+            ##    unhexlify("eefe3d61cd4da4e4e9945b3d6ba2158c2634e984"),
+            ##    "password", "salt", 16777216, 20,
+            ##),
+
+            (
+                hb("3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038"),
+                b"passwordPASSWORDpassword",
+                b"saltSALTsaltSALTsaltSALTsaltSALTsalt",
+                4096, 25,
+            ),
+
+            (
+                hb("56fa6aa75548099dcc37d7f03425e0c3"),
+                b"pass\00word", b"sa\00lt", 4096, 16,
+            ),
+
+        #
+        # from example in http://grub.enbug.org/Authentication
+        #
+            (
+               hb("887CFF169EA8335235D8004242AA7D6187A41E3187DF0CE14E256D85ED"
+                  "97A97357AAA8FF0A3871AB9EEFF458392F462F495487387F685B7472FC"
+                  "6C29E293F0A0"),
+               b"hello",
+               hb("9290F727ED06C38BA4549EF7DE25CF5642659211B7FC076F2D28FEFD71"
+                  "784BB8D8F6FB244A8CC5C06240631B97008565A120764C0EE9C2CB0073"
+                  "994D79080136"),
+               10000, 64, "hmac-sha512"
+            ),
+
+        #
+        # custom
+        #
+            (
+                hb('e248fb6b13365146f8ac6307cc222812'),
+                b"secret", b"salt", 10, 16, "hmac-sha1",
+            ),
+            (
+                hb('e248fb6b13365146f8ac6307cc2228127872da6d'),
+                b"secret", b"salt", 10, None, "hmac-sha1",
+            ),
+
+        ]
+
+    def setUp(self):
+        super(Pbkdf2_Test, self).setUp()
+        warnings.filterwarnings("ignore", ".*passlib.utils.pbkdf2.*deprecated", DeprecationWarning)
+
+    def test_known(self):
+        """test reference vectors"""
+        from passlib.utils.pbkdf2 import pbkdf2
+        for row in self.pbkdf2_test_vectors:
+            correct, secret, salt, rounds, keylen = row[:5]
+            prf = row[5] if len(row) == 6 else "hmac-sha1"
+            result = pbkdf2(secret, salt, rounds, keylen, prf)
+            self.assertEqual(result, correct)
+
+    def test_border(self):
+        """test border cases"""
+        from passlib.utils.pbkdf2 import pbkdf2
+        def helper(secret=b'password', salt=b'salt', rounds=1, keylen=None, prf="hmac-sha1"):
+            return pbkdf2(secret, salt, rounds, keylen, prf)
+        helper()
+
+        # invalid rounds
+        self.assertRaises(ValueError, helper, rounds=-1)
+        self.assertRaises(ValueError, helper, rounds=0)
+        self.assertRaises(TypeError, helper, rounds='x')
+
+        # invalid keylen
+        self.assertRaises(ValueError, helper, keylen=-1)
+        self.assertRaises(ValueError, helper, keylen=0)
+        helper(keylen=1)
+        self.assertRaises(OverflowError, helper, keylen=20*(2**32-1)+1)
+        self.assertRaises(TypeError, helper, keylen='x')
+
+        # invalid secret/salt type
+        self.assertRaises(TypeError, helper, salt=5)
+        self.assertRaises(TypeError, helper, secret=5)
+
+        # invalid hash
+        self.assertRaises(ValueError, helper, prf='hmac-foo')
+        self.assertRaises(NotImplementedError, helper, prf='foo')
+        self.assertRaises(TypeError, helper, prf=5)
+
+    def test_default_keylen(self):
+        """test keylen==None"""
+        from passlib.utils.pbkdf2 import pbkdf2
+        def helper(secret=b'password', salt=b'salt', rounds=1, keylen=None, prf="hmac-sha1"):
+            return pbkdf2(secret, salt, rounds, keylen, prf)
+        self.assertEqual(len(helper(prf='hmac-sha1')), 20)
+        self.assertEqual(len(helper(prf='hmac-sha256')), 32)
+
+    def test_custom_prf(self):
+        """test custom prf function"""
+        from passlib.utils.pbkdf2 import pbkdf2
+        def prf(key, msg):
+            return hashlib.md5(key+msg+b'fooey').digest()
+        self.assertRaises(NotImplementedError, pbkdf2, b'secret', b'salt', 1000, 20, prf)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/test_win32.py b/myenv/lib/python3.9/site-packages/passlib/tests/test_win32.py
new file mode 100644
index 0000000..e818b62
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/test_win32.py
@@ -0,0 +1,50 @@
+"""tests for passlib.win32 -- (c) Assurance Technologies 2003-2009"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import warnings
+# site
+# pkg
+from passlib.tests.utils import TestCase
+# module
+from passlib.utils.compat import u
+
+#=============================================================================
+#
+#=============================================================================
+class UtilTest(TestCase):
+    """test util funcs in passlib.win32"""
+
+    ##test hashes from http://msdn.microsoft.com/en-us/library/cc245828(v=prot.10).aspx
+    ## among other places
+
+    def setUp(self):
+        super(UtilTest, self).setUp()
+        warnings.filterwarnings("ignore",
+                                "the 'passlib.win32' module is deprecated")
+
+    def test_lmhash(self):
+        from passlib.win32 import raw_lmhash
+        for secret, hash in [
+            ("OLDPASSWORD", u("c9b81d939d6fd80cd408e6b105741864")),
+            ("NEWPASSWORD", u('09eeab5aa415d6e4d408e6b105741864')),
+            ("welcome", u("c23413a8a1e7665faad3b435b51404ee")),
+            ]:
+            result = raw_lmhash(secret, hex=True)
+            self.assertEqual(result, hash)
+
+    def test_nthash(self):
+        warnings.filterwarnings("ignore",
+                                r"nthash\.raw_nthash\(\) is deprecated")
+        from passlib.win32 import raw_nthash
+        for secret, hash in [
+            ("OLDPASSWORD", u("6677b2c394311355b54f25eec5bfacf5")),
+            ("NEWPASSWORD", u("256781a62031289d3c2c98c14f1efc8c")),
+            ]:
+            result = raw_nthash(secret, hex=True)
+            self.assertEqual(result, hash)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/tox_support.py b/myenv/lib/python3.9/site-packages/passlib/tests/tox_support.py
new file mode 100644
index 0000000..43170bc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/tox_support.py
@@ -0,0 +1,83 @@
+"""passlib.tests.tox_support - helper script for tox tests"""
+#=============================================================================
+# init script env
+#=============================================================================
+import os, sys
+root_dir = os.path.join(os.path.dirname(__file__), os.pardir, os.pardir)
+sys.path.insert(0, root_dir)
+
+#=============================================================================
+# imports
+#=============================================================================
+# core
+import re
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.utils.compat import print_
+# local
+__all__ = [
+]
+
+#=============================================================================
+# main
+#=============================================================================
+TH_PATH = "passlib.tests.test_handlers"
+
+def do_hash_tests(*args):
+    """return list of hash algorithm tests that match regexes"""
+    if not args:
+        print(TH_PATH)
+        return
+    suffix = ''
+    args = list(args)
+    while True:
+        if args[0] == "--method":
+            suffix = '.' + args[1]
+            del args[:2]
+        else:
+            break
+    from passlib.tests import test_handlers
+    names = [TH_PATH + ":" + name + suffix for name in dir(test_handlers)
+             if not name.startswith("_") and any(re.match(arg,name) for arg in args)]
+    print_("\n".join(names))
+    return not names
+
+def do_preset_tests(name):
+    """return list of preset test names"""
+    if name == "django" or name == "django-hashes":
+        do_hash_tests("django_.*_test", "hex_md5_test")
+        if name == "django":
+            print_("passlib.tests.test_ext_django")
+    else:
+        raise ValueError("unknown name: %r" % name)
+
+def do_setup_gae(path, runtime):
+    """write fake GAE ``app.yaml`` to current directory so nosegae will work"""
+    from passlib.tests.utils import set_file
+    set_file(os.path.join(path, "app.yaml"), """\
+application: fake-app
+version: 2
+runtime: %s
+api_version: 1
+threadsafe: no
+
+handlers:
+- url: /.*
+  script: dummy.py
+
+libraries:
+- name: django
+  version: "latest"
+""" % runtime)
+
+def main(cmd, *args):
+    return globals()["do_" + cmd](*args)
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main(*sys.argv[1:]) or 0)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/tests/utils.py b/myenv/lib/python3.9/site-packages/passlib/tests/utils.py
new file mode 100644
index 0000000..79a9f9f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/tests/utils.py
@@ -0,0 +1,3621 @@
+"""helpers for passlib unittests"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+from binascii import unhexlify
+import contextlib
+from functools import wraps, partial
+import hashlib
+import logging; log = logging.getLogger(__name__)
+import random
+import re
+import os
+import sys
+import tempfile
+import threading
+import time
+from passlib.exc import PasslibHashWarning, PasslibConfigWarning
+from passlib.utils.compat import PY3, JYTHON
+import warnings
+from warnings import warn
+# site
+# pkg
+from passlib import exc
+from passlib.exc import MissingBackendError
+import passlib.registry as registry
+from passlib.tests.backports import TestCase as _TestCase, skip, skipIf, skipUnless, SkipTest
+from passlib.utils import has_rounds_info, has_salt_info, rounds_cost_values, \
+                          rng as sys_rng, getrandstr, is_ascii_safe, to_native_str, \
+                          repeat_string, tick, batch
+from passlib.utils.compat import iteritems, irange, u, unicode, PY2, nullcontext
+from passlib.utils.decor import classproperty
+import passlib.utils.handlers as uh
+# local
+__all__ = [
+    # util funcs
+    'TEST_MODE',
+    'set_file', 'get_file',
+
+    # unit testing
+    'TestCase',
+    'HandlerCase',
+]
+
+#=============================================================================
+# environment detection
+#=============================================================================
+# figure out if we're running under GAE;
+# some tests (e.g. FS writing) should be skipped.
+# XXX: is there better way to do this?
+try:
+    import google.appengine
+except ImportError:
+    GAE = False
+else:
+    GAE = True
+
+def ensure_mtime_changed(path):
+    """ensure file's mtime has changed"""
+    # NOTE: this is hack to deal w/ filesystems whose mtime resolution is >= 1s,
+    #       when a test needs to be sure the mtime changed after writing to the file.
+    last = os.path.getmtime(path)
+    while os.path.getmtime(path) == last:
+        time.sleep(0.1)
+        os.utime(path, None)
+
+def _get_timer_resolution(timer):
+    def sample():
+        start = cur = timer()
+        while start == cur:
+            cur = timer()
+        return cur-start
+    return min(sample() for _ in range(3))
+TICK_RESOLUTION = _get_timer_resolution(tick)
+
+#=============================================================================
+# test mode
+#=============================================================================
+_TEST_MODES = ["quick", "default", "full"]
+_test_mode = _TEST_MODES.index(os.environ.get("PASSLIB_TEST_MODE",
+                                              "default").strip().lower())
+
+def TEST_MODE(min=None, max=None):
+    """check if test for specified mode should be enabled.
+
+    ``"quick"``
+        run the bare minimum tests to ensure functionality.
+        variable-cost hashes are tested at their lowest setting.
+        hash algorithms are only tested against the backend that will
+        be used on the current host. no fuzz testing is done.
+
+    ``"default"``
+        same as ``"quick"``, except: hash algorithms are tested
+        at default levels, and a brief round of fuzz testing is done
+        for each hash.
+
+    ``"full"``
+        extra regression and internal tests are enabled, hash algorithms are tested
+        against all available backends, unavailable ones are mocked whre possible,
+        additional time is devoted to fuzz testing.
+    """
+    if min and _test_mode < _TEST_MODES.index(min):
+        return False
+    if max and _test_mode > _TEST_MODES.index(max):
+        return False
+    return True
+
+#=============================================================================
+# hash object inspection
+#=============================================================================
+def has_relaxed_setting(handler):
+    """check if handler supports 'relaxed' kwd"""
+    # FIXME: I've been lazy, should probably just add 'relaxed' kwd
+    # to all handlers that derive from GenericHandler
+
+    # ignore wrapper classes for now.. though could introspec.
+    if hasattr(handler, "orig_prefix"):
+        return False
+
+    return 'relaxed' in handler.setting_kwds or issubclass(handler,
+                                                           uh.GenericHandler)
+
+def get_effective_rounds(handler, rounds=None):
+    """get effective rounds value from handler"""
+    handler = unwrap_handler(handler)
+    return handler(rounds=rounds, use_defaults=True).rounds
+
+def is_default_backend(handler, backend):
+    """check if backend is the default for source"""
+    try:
+        orig = handler.get_backend()
+    except MissingBackendError:
+        return False
+    try:
+        handler.set_backend("default")
+        return handler.get_backend() == backend
+    finally:
+        handler.set_backend(orig)
+
+def iter_alt_backends(handler, current=None, fallback=False):
+    """
+    iterate over alternate backends available to handler.
+
+    .. warning::
+        not thread-safe due to has_backend() call
+    """
+    if current is None:
+        current = handler.get_backend()
+    backends = handler.backends
+    idx = backends.index(current)+1 if fallback else 0
+    for backend in backends[idx:]:
+        if backend != current and handler.has_backend(backend):
+            yield backend
+
+def get_alt_backend(*args, **kwds):
+    for backend in iter_alt_backends(*args, **kwds):
+        return backend
+    return None
+
+def unwrap_handler(handler):
+    """return original handler, removing any wrapper objects"""
+    while hasattr(handler, "wrapped"):
+        handler = handler.wrapped
+    return handler
+
+def handler_derived_from(handler, base):
+    """
+    test if <handler> was derived from <base> via <base.using()>.
+    """
+    # XXX: need way to do this more formally via ifc,
+    #      for now just hacking in the cases we encounter in testing.
+    if handler == base:
+        return True
+    elif isinstance(handler, uh.PrefixWrapper):
+        while handler:
+            if handler == base:
+                return True
+            # helper set by PrefixWrapper().using() just for this case...
+            handler = handler._derived_from
+        return False
+    elif isinstance(handler, type) and issubclass(handler, uh.MinimalHandler):
+        return issubclass(handler, base)
+    else:
+        raise NotImplementedError("don't know how to inspect handler: %r" % (handler,))
+
+@contextlib.contextmanager
+def patch_calc_min_rounds(handler):
+    """
+    internal helper for do_config_encrypt() --
+    context manager which temporarily replaces handler's _calc_checksum()
+    with one that uses min_rounds; useful when trying to generate config
+    with high rounds value, but don't care if output is correct.
+    """
+    if isinstance(handler, type) and issubclass(handler, uh.HasRounds):
+        # XXX: also require GenericHandler for this branch?
+        wrapped = handler._calc_checksum
+        def wrapper(self, *args, **kwds):
+            rounds = self.rounds
+            try:
+                self.rounds = self.min_rounds
+                return wrapped(self, *args, **kwds)
+            finally:
+                self.rounds = rounds
+        handler._calc_checksum = wrapper
+        try:
+            yield
+        finally:
+            handler._calc_checksum = wrapped
+    elif isinstance(handler, uh.PrefixWrapper):
+        with patch_calc_min_rounds(handler.wrapped):
+            yield
+    else:
+        yield
+        return
+
+#=============================================================================
+# misc helpers
+#=============================================================================
+def set_file(path, content):
+    """set file to specified bytes"""
+    if isinstance(content, unicode):
+        content = content.encode("utf-8")
+    with open(path, "wb") as fh:
+        fh.write(content)
+
+def get_file(path):
+    """read file as bytes"""
+    with open(path, "rb") as fh:
+        return fh.read()
+
+def tonn(source):
+    """convert native string to non-native string"""
+    if not isinstance(source, str):
+        return source
+    elif PY3:
+        return source.encode("utf-8")
+    else:
+        try:
+            return source.decode("utf-8")
+        except UnicodeDecodeError:
+            return source.decode("latin-1")
+
+def hb(source):
+    """
+    helper for represent byte strings in hex.
+
+    usage: ``hb("deadbeef23")``
+    """
+    return unhexlify(re.sub(r"\s", "", source))
+
+def limit(value, lower, upper):
+    if value < lower:
+        return lower
+    elif value > upper:
+        return upper
+    return value
+
+def quicksleep(delay):
+    """because time.sleep() doesn't even have 10ms accuracy on some OSes"""
+    start = tick()
+    while tick()-start < delay:
+        pass
+
+def time_call(func, setup=None, maxtime=1, bestof=10):
+    """
+    timeit() wrapper which tries to get as accurate a measurement as possible w/in maxtime seconds.
+
+    :returns:
+        ``(avg_seconds_per_call, log10_number_of_repetitions)``
+    """
+    from timeit import Timer
+    from math import log
+    timer = Timer(func, setup=setup or '')
+    number = 1
+    end = tick() + maxtime
+    while True:
+        delta = min(timer.repeat(bestof, number))
+        if tick() >= end:
+            return delta/number, int(log(number, 10))
+        number *= 10
+
+def run_with_fixed_seeds(count=128, master_seed=0x243F6A8885A308D3):
+    """
+    decorator run test method w/ multiple fixed seeds.
+    """
+    def builder(func):
+        @wraps(func)
+        def wrapper(*args, **kwds):
+            rng = random.Random(master_seed)
+            for _ in irange(count):
+                kwds['seed'] = rng.getrandbits(32)
+                func(*args, **kwds)
+        return wrapper
+    return builder
+
+#=============================================================================
+# custom test harness
+#=============================================================================
+
+class TestCase(_TestCase):
+    """passlib-specific test case class
+
+    this class adds a number of features to the standard TestCase...
+    * common prefix for all test descriptions
+    * resets warnings filter & registry for every test
+    * tweaks to message formatting
+    * __msg__ kwd added to assertRaises()
+    * suite of methods for matching against warnings
+    """
+    #===================================================================
+    # add various custom features
+    #===================================================================
+
+    #---------------------------------------------------------------
+    # make it easy for test cases to add common prefix to shortDescription
+    #---------------------------------------------------------------
+
+    # string prepended to all tests in TestCase
+    descriptionPrefix = None
+
+    def shortDescription(self):
+        """wrap shortDescription() method to prepend descriptionPrefix"""
+        desc = super(TestCase, self).shortDescription()
+        prefix = self.descriptionPrefix
+        if prefix:
+            desc = "%s: %s" % (prefix, desc or str(self))
+        return desc
+
+    #---------------------------------------------------------------
+    # hack things so nose and ut2 both skip subclasses who have
+    # "__unittest_skip=True" set, or whose names start with "_"
+    #---------------------------------------------------------------
+    @classproperty
+    def __unittest_skip__(cls):
+        # NOTE: this attr is technically a unittest2 internal detail.
+        name = cls.__name__
+        return name.startswith("_") or \
+               getattr(cls, "_%s__unittest_skip" % name, False)
+
+    @classproperty
+    def __test__(cls):
+        # make nose just proxy __unittest_skip__
+        return not cls.__unittest_skip__
+
+    # flag to skip *this* class
+    __unittest_skip = True
+
+    #---------------------------------------------------------------
+    # reset warning filters & registry before each test
+    #---------------------------------------------------------------
+
+    # flag to reset all warning filters & ignore state
+    resetWarningState = True
+
+    def setUp(self):
+        super(TestCase, self).setUp()
+        self.setUpWarnings()
+        # have uh.debug_only_repr() return real values for duration of test
+        self.patchAttr(exc, "ENABLE_DEBUG_ONLY_REPR", True)
+
+    def setUpWarnings(self):
+        """helper to init warning filters before subclass setUp()"""
+        if self.resetWarningState:
+            ctx = reset_warnings()
+            ctx.__enter__()
+            self.addCleanup(ctx.__exit__)
+
+            # ignore security warnings, tests may deliberately cause these
+            # TODO: may want to filter out a few of this, but not blanket filter...
+            # warnings.filterwarnings("ignore", category=exc.PasslibSecurityWarning)
+
+            # ignore warnings about PasswordHash features deprecated in 1.7
+            # TODO: should be cleaned in 2.0, when support will be dropped.
+            #       should be kept until then, so we test the legacy paths.
+            warnings.filterwarnings("ignore", r"the method .*\.(encrypt|genconfig|genhash)\(\) is deprecated")
+            warnings.filterwarnings("ignore", r"the 'vary_rounds' option is deprecated")
+            warnings.filterwarnings("ignore", r"Support for `(py-bcrypt|bcryptor)` is deprecated")
+
+    #---------------------------------------------------------------
+    # tweak message formatting so longMessage mode is only enabled
+    # if msg ends with ":", and turn on longMessage by default.
+    #---------------------------------------------------------------
+    longMessage = True
+
+    def _formatMessage(self, msg, std):
+        if self.longMessage and msg and msg.rstrip().endswith(":"):
+            return '%s %s' % (msg.rstrip(), std)
+        else:
+            return msg or std
+
+    #---------------------------------------------------------------
+    # override assertRaises() to support '__msg__' keyword,
+    # and to return the caught exception for further examination
+    #---------------------------------------------------------------
+    def assertRaises(self, _exc_type, _callable=None, *args, **kwds):
+        msg = kwds.pop("__msg__", None)
+        if _callable is None:
+            # FIXME: this ignores 'msg'
+            return super(TestCase, self).assertRaises(_exc_type, None,
+                                                      *args, **kwds)
+        try:
+            result = _callable(*args, **kwds)
+        except _exc_type as err:
+            return err
+        std = "function returned %r, expected it to raise %r" % (result,
+                                                                 _exc_type)
+        raise self.failureException(self._formatMessage(msg, std))
+
+    #---------------------------------------------------------------
+    # forbid a bunch of deprecated aliases so I stop using them
+    #---------------------------------------------------------------
+    def assertEquals(self, *a, **k):
+        raise AssertionError("this alias is deprecated by unittest2")
+    assertNotEquals = assertRegexMatches = assertEquals
+
+    #===================================================================
+    # custom methods for matching warnings
+    #===================================================================
+    def assertWarning(self, warning,
+                             message_re=None, message=None,
+                             category=None,
+                             filename_re=None, filename=None,
+                             lineno=None,
+                             msg=None,
+                             ):
+        """check if warning matches specified parameters.
+        'warning' is the instance of Warning to match against;
+        can also be instance of WarningMessage (as returned by catch_warnings).
+        """
+        # check input type
+        if hasattr(warning, "category"):
+            # resolve WarningMessage -> Warning, but preserve original
+            wmsg = warning
+            warning = warning.message
+        else:
+            # no original WarningMessage, passed raw Warning
+            wmsg = None
+
+        # tests that can use a warning instance or WarningMessage object
+        if message:
+            self.assertEqual(str(warning), message, msg)
+        if message_re:
+            self.assertRegex(str(warning), message_re, msg)
+        if category:
+            self.assertIsInstance(warning, category, msg)
+
+        # tests that require a WarningMessage object
+        if filename or filename_re:
+            if not wmsg:
+                raise TypeError("matching on filename requires a "
+                                "WarningMessage instance")
+            real = wmsg.filename
+            if real.endswith(".pyc") or real.endswith(".pyo"):
+                # FIXME: should use a stdlib call to resolve this back
+                #        to module's original filename.
+                real = real[:-1]
+            if filename:
+                self.assertEqual(real, filename, msg)
+            if filename_re:
+                self.assertRegex(real, filename_re, msg)
+        if lineno:
+            if not wmsg:
+                raise TypeError("matching on lineno requires a "
+                                "WarningMessage instance")
+            self.assertEqual(wmsg.lineno, lineno, msg)
+
+    class _AssertWarningList(warnings.catch_warnings):
+        """context manager for assertWarningList()"""
+        def __init__(self, case, **kwds):
+            self.case = case
+            self.kwds = kwds
+            self.__super = super(TestCase._AssertWarningList, self)
+            self.__super.__init__(record=True)
+
+        def __enter__(self):
+            self.log = self.__super.__enter__()
+
+        def __exit__(self, *exc_info):
+            self.__super.__exit__(*exc_info)
+            if exc_info[0] is None:
+                self.case.assertWarningList(self.log, **self.kwds)
+
+    def assertWarningList(self, wlist=None, desc=None, msg=None):
+        """check that warning list (e.g. from catch_warnings) matches pattern"""
+        if desc is None:
+            assert wlist is not None
+            return self._AssertWarningList(self, desc=wlist, msg=msg)
+        # TODO: make this display better diff of *which* warnings did not match
+        assert desc is not None
+        if not isinstance(desc, (list,tuple)):
+            desc = [desc]
+        for idx, entry in enumerate(desc):
+            if isinstance(entry, str):
+                entry = dict(message_re=entry)
+            elif isinstance(entry, type) and issubclass(entry, Warning):
+                entry = dict(category=entry)
+            elif not isinstance(entry, dict):
+                raise TypeError("entry must be str, warning, or dict")
+            try:
+                data = wlist[idx]
+            except IndexError:
+                break
+            self.assertWarning(data, msg=msg, **entry)
+        else:
+            if len(wlist) == len(desc):
+                return
+        std = "expected %d warnings, found %d: wlist=%s desc=%r" % \
+                (len(desc), len(wlist), self._formatWarningList(wlist), desc)
+        raise self.failureException(self._formatMessage(msg, std))
+
+    def consumeWarningList(self, wlist, desc=None, *args, **kwds):
+        """[deprecated] assertWarningList() variant that clears list afterwards"""
+        if desc is None:
+            desc = []
+        self.assertWarningList(wlist, desc, *args, **kwds)
+        del wlist[:]
+
+    def _formatWarning(self, entry):
+        tail = ""
+        if hasattr(entry, "message"):
+            # WarningMessage instance.
+            tail = " filename=%r lineno=%r" % (entry.filename, entry.lineno)
+            if entry.line:
+                tail += " line=%r" % (entry.line,)
+            entry = entry.message
+        cls = type(entry)
+        return "<%s.%s message=%r%s>" % (cls.__module__, cls.__name__,
+                                           str(entry), tail)
+
+    def _formatWarningList(self, wlist):
+        return "[%s]" % ", ".join(self._formatWarning(entry) for entry in wlist)
+
+    #===================================================================
+    # capability tests
+    #===================================================================
+    def require_stringprep(self):
+        """helper to skip test if stringprep is missing"""
+        from passlib.utils import stringprep
+        if not stringprep:
+            from passlib.utils import _stringprep_missing_reason
+            raise self.skipTest("not available - stringprep module is " +
+                                _stringprep_missing_reason)
+
+    def require_TEST_MODE(self, level):
+        """skip test for all PASSLIB_TEST_MODE values below <level>"""
+        if not TEST_MODE(level):
+            raise self.skipTest("requires >= %r test mode" % level)
+
+    def require_writeable_filesystem(self):
+        """skip test if writeable FS not available"""
+        if GAE:
+            return self.skipTest("GAE doesn't offer read/write filesystem access")
+
+    #===================================================================
+    # reproducible random helpers
+    #===================================================================
+
+    #: global thread lock for random state
+    #: XXX: could split into global & per-instance locks if need be
+    _random_global_lock = threading.Lock()
+
+    #: cache of global seed value, initialized on first call to getRandom()
+    _random_global_seed = None
+
+    #: per-instance cache of name -> RNG
+    _random_cache = None
+
+    def getRandom(self, name="default", seed=None):
+        """
+        Return a :class:`random.Random` object for current test method to use.
+        Within an instance, multiple calls with the same name will return
+        the same object.
+
+        When first created, each RNG will be seeded with value derived from
+        a global seed, the test class module & name, the current test method name,
+        and the **name** parameter.
+
+        The global seed taken from the $RANDOM_TEST_SEED env var,
+        the $PYTHONHASHSEED env var, or a randomly generated the
+        first time this method is called. In all cases, the value
+        is logged for reproducibility.
+
+        :param name:
+            name to uniquely identify separate RNGs w/in a test
+            (e.g. for threaded tests).
+
+        :param seed:
+            override global seed when initialzing rng.
+
+        :rtype: random.Random
+        """
+        # check cache
+        cache = self._random_cache
+        if cache and name in cache:
+            return cache[name]
+
+        with self._random_global_lock:
+
+            # check cache again, and initialize it
+            cache = self._random_cache
+            if cache and name in cache:
+                return cache[name]
+            elif not cache:
+                cache = self._random_cache = {}
+
+            # init global seed
+            global_seed = seed or TestCase._random_global_seed
+            if global_seed is None:
+                # NOTE: checking PYTHONHASHSEED, because if that's set,
+                #       the test runner wants something reproducible.
+                global_seed = TestCase._random_global_seed = \
+                    int(os.environ.get("RANDOM_TEST_SEED") or
+                        os.environ.get("PYTHONHASHSEED") or
+                        sys_rng.getrandbits(32))
+                # XXX: would it be better to print() this?
+                log.info("using RANDOM_TEST_SEED=%d", global_seed)
+
+            # create seed
+            cls = type(self)
+            source = "\n".join([str(global_seed), cls.__module__, cls.__name__,
+                                self._testMethodName, name])
+            digest = hashlib.sha256(source.encode("utf-8")).hexdigest()
+            seed = int(digest[:16], 16)
+
+            # create rng
+            value = cache[name] = random.Random(seed)
+            return value
+
+    #===================================================================
+    # subtests
+    #===================================================================
+
+    has_real_subtest = hasattr(_TestCase, "subTest")
+
+    @contextlib.contextmanager
+    def subTest(self, *args, **kwds):
+        """
+        wrapper/backport for .subTest() which also traps SkipTest errors.
+        (see source for details)
+        """
+        # this function works around two things:
+        # * TestCase.subTest() wasn't added until Py34; so for older python versions,
+        #   we either need unittest2 installed, or provide stub of our own.
+        #   this method provides a stub if needed (based on .has_real_subtest check)
+        #
+        # * as 2020-10-08, .subTest() doesn't play nicely w/ .skipTest();
+        #   and also makes it hard to debug which subtest had a failure.
+        #   (see https://bugs.python.org/issue25894 and https://bugs.python.org/issue35327)
+        #   this method traps skipTest exceptions, and adds some logging to help debug
+        #   which subtest caused the issue.
+
+        # setup way to log subtest info
+        # XXX: would like better way to inject messages into test output;
+        #      but this at least gets us something for debugging...
+        # NOTE: this hack will miss parent params if called from nested .subTest()
+        def _render_title(_msg=None, **params):
+            out = ("[%s] " % _msg if _msg else "")
+            if params:
+                out += "(%s)" % " ".join("%s=%r" % tuple(item) for item in params.items())
+            return out.strip() or "<subtest>"
+
+        test_log = self.getLogger()
+        title = _render_title(*args, **kwds)
+
+        # use real subtest manager if available
+        if self.has_real_subtest:
+            ctx = super(TestCase, self).subTest(*args, **kwds)
+        else:
+            ctx = nullcontext()
+
+        # run the subtest
+        with ctx:
+            test_log.info("running subtest: %s", title)
+            try:
+                yield
+            except SkipTest:
+                # silence "SkipTest" exceptions, want to keep running next subtest.
+                test_log.info("subtest skipped: %s", title)
+                pass
+            except Exception as err:
+                # log unhandled exception occurred
+                # (assuming traceback will be reported up higher, so not bothering here)
+                test_log.warning("subtest failed: %s: %s: %r", title, type(err).__name__, str(err))
+                raise
+
+        # XXX: check for "failed" state in ``self._outcome`` before writing this?
+        test_log.info("subtest passed: %s", title)
+
+    #===================================================================
+    # other
+    #===================================================================
+    _mktemp_queue = None
+
+    def mktemp(self, *args, **kwds):
+        """create temp file that's cleaned up at end of test"""
+        self.require_writeable_filesystem()
+        fd, path = tempfile.mkstemp(*args, **kwds)
+        os.close(fd)
+        queue = self._mktemp_queue
+        if queue is None:
+            queue = self._mktemp_queue = []
+            def cleaner():
+                for path in queue:
+                    if os.path.exists(path):
+                        os.remove(path)
+                del queue[:]
+            self.addCleanup(cleaner)
+        queue.append(path)
+        return path
+
+    def patchAttr(self, obj, attr, value, require_existing=True, wrap=False):
+        """monkeypatch object value, restoring original value on cleanup"""
+        try:
+            orig = getattr(obj, attr)
+        except AttributeError:
+            if require_existing:
+                raise
+            def cleanup():
+                try:
+                    delattr(obj, attr)
+                except AttributeError:
+                    pass
+            self.addCleanup(cleanup)
+        else:
+            self.addCleanup(setattr, obj, attr, orig)
+        if wrap:
+            value = partial(value, orig)
+            wraps(orig)(value)
+        setattr(obj, attr, value)
+
+    def getLogger(self):
+        """
+        return logger named after current test.
+        """
+        cls = type(self)
+        # NOTE: conditional on qualname for PY2 compat
+        path = cls.__module__ + "." + getattr(cls, "__qualname__", cls.__name__)
+        name = self._testMethodName
+        if name:
+            path = path + "." + name
+        return logging.getLogger(path)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# other unittest helpers
+#=============================================================================
+
+RESERVED_BACKEND_NAMES = ["any", "default"]
+
+
+def doesnt_require_backend(func):
+    """
+    decorator for HandlerCase.create_backend_case() --
+    used to decorate methods that should be run even if backend isn't present
+    (by default, full test suite is skipped when backend is missing)
+
+    NOTE: tests decorated with this should not rely on handler have expected (or any!) backend.
+    """
+    func._doesnt_require_backend = True
+    return func
+
+
+class HandlerCase(TestCase):
+    """base class for testing password hash handlers (esp passlib.utils.handlers subclasses)
+
+    In order to use this to test a handler,
+    create a subclass will all the appropriate attributes
+    filled as listed in the example below,
+    and run the subclass via unittest.
+
+    .. todo::
+
+        Document all of the options HandlerCase offers.
+
+    .. note::
+
+        This is subclass of :class:`unittest.TestCase`
+        (or :class:`unittest2.TestCase` if available).
+    """
+    #===================================================================
+    # class attrs - should be filled in by subclass
+    #===================================================================
+
+    #---------------------------------------------------------------
+    # handler setup
+    #---------------------------------------------------------------
+
+    # handler class to test [required]
+    handler = None
+
+    # if set, run tests against specified backend
+    backend = None
+
+    #---------------------------------------------------------------
+    # test vectors
+    #---------------------------------------------------------------
+
+    # list of (secret, hash) tuples which are known to be correct
+    known_correct_hashes = []
+
+    # list of (config, secret, hash) tuples are known to be correct
+    known_correct_configs = []
+
+    # list of (alt_hash, secret, hash) tuples, where alt_hash is a hash
+    # using an alternate representation that should be recognized and verify
+    # correctly, but should be corrected to match hash when passed through
+    # genhash()
+    known_alternate_hashes = []
+
+    # hashes so malformed they aren't even identified properly
+    known_unidentified_hashes = []
+
+    # hashes which are identifiabled but malformed - they should identify()
+    # as True, but cause an error when passed to genhash/verify.
+    known_malformed_hashes = []
+
+    # list of (handler name, hash) pairs for other algorithm's hashes that
+    # handler shouldn't identify as belonging to it this list should generally
+    # be sufficient (if handler name in list, that entry will be skipped)
+    known_other_hashes = [
+        ('des_crypt', '6f8c114b58f2c'),
+        ('md5_crypt', '$1$dOHYPKoP$tnxS1T8Q6VVn3kpV8cN6o.'),
+        ('sha512_crypt', "$6$rounds=123456$asaltof16chars..$BtCwjqMJGx5hrJhZywW"
+         "vt0RLE8uZ4oPwcelCjmw2kSYu.Ec6ycULevoBK25fs2xXgMNrCzIMVcgEJAstJeonj1"),
+    ]
+
+    # passwords used to test basic hash behavior - generally
+    # don't need to be overidden.
+    stock_passwords = [
+        u("test"),
+        u("\u20AC\u00A5$"),
+        b'\xe2\x82\xac\xc2\xa5$'
+    ]
+
+    #---------------------------------------------------------------
+    # option flags
+    #---------------------------------------------------------------
+
+    # whether hash is case insensitive
+    # True, False, or special value "verify-only" (which indicates
+    # hash contains case-sensitive portion, but verifies is case-insensitive)
+    secret_case_insensitive = False
+
+    # flag if scheme accepts ALL hash strings (e.g. plaintext)
+    accepts_all_hashes = False
+
+    # flag if scheme has "is_disabled" set, and contains 'salted' data
+    disabled_contains_salt = False
+
+    # flag/hack to filter PasslibHashWarning issued by test_72_configs()
+    filter_config_warnings = False
+
+    # forbid certain characters in passwords
+    @classproperty
+    def forbidden_characters(cls):
+        # anything that supports crypt() interface should forbid null chars,
+        # since crypt() uses null-terminated strings.
+        if 'os_crypt' in getattr(cls.handler, "backends", ()):
+            return b"\x00"
+        return None
+
+    #===================================================================
+    # internal class attrs
+    #===================================================================
+    __unittest_skip = True
+
+    @property
+    def descriptionPrefix(self):
+        handler = self.handler
+        name = handler.name
+        if hasattr(handler, "get_backend"):
+            name += " (%s backend)" % (handler.get_backend(),)
+        return name
+
+    #===================================================================
+    # support methods
+    #===================================================================
+
+    #---------------------------------------------------------------
+    # configuration helpers
+    #---------------------------------------------------------------
+    @classmethod
+    def iter_known_hashes(cls):
+        """iterate through known (secret, hash) pairs"""
+        for secret, hash in cls.known_correct_hashes:
+            yield secret, hash
+        for config, secret, hash in cls.known_correct_configs:
+            yield secret, hash
+        for alt, secret, hash in cls.known_alternate_hashes:
+            yield secret, hash
+
+    def get_sample_hash(self):
+        """test random sample secret/hash pair"""
+        known = list(self.iter_known_hashes())
+        return self.getRandom().choice(known)
+
+    #---------------------------------------------------------------
+    # test helpers
+    #---------------------------------------------------------------
+    def check_verify(self, secret, hash, msg=None, negate=False):
+        """helper to check verify() outcome, honoring is_disabled_handler"""
+        result = self.do_verify(secret, hash)
+        self.assertTrue(result is True or result is False,
+                        "verify() returned non-boolean value: %r" % (result,))
+        if self.handler.is_disabled or negate:
+            if not result:
+                return
+            if not msg:
+                msg = ("verify incorrectly returned True: secret=%r, hash=%r" %
+                       (secret, hash))
+            raise self.failureException(msg)
+        else:
+            if result:
+                return
+            if not msg:
+                msg = "verify failed: secret=%r, hash=%r" % (secret, hash)
+            raise self.failureException(msg)
+
+    def check_returned_native_str(self, result, func_name):
+        self.assertIsInstance(result, str,
+            "%s() failed to return native string: %r" % (func_name, result,))
+
+    #---------------------------------------------------------------
+    # PasswordHash helpers - wraps all calls to PasswordHash api,
+    # so that subclasses can fill in defaults and account for other specialized behavior
+    #---------------------------------------------------------------
+    def populate_settings(self, kwds):
+        """subclassable method to populate default settings"""
+        # use lower rounds settings for certain test modes
+        handler = self.handler
+        if 'rounds' in handler.setting_kwds and 'rounds' not in kwds:
+            mn = handler.min_rounds
+            df = handler.default_rounds
+            if TEST_MODE(max="quick"):
+                # use minimum rounds for quick mode
+                kwds['rounds'] = max(3, mn)
+            else:
+                # use default/16 otherwise
+                factor = 3
+                if getattr(handler, "rounds_cost", None) == "log2":
+                    df -= factor
+                else:
+                    df //= (1<<factor)
+                kwds['rounds'] = max(3, mn, df)
+
+    def populate_context(self, secret, kwds):
+        """subclassable method allowing 'secret' to be encode context kwds"""
+        return secret
+
+    # TODO: rename to do_hash() to match new API
+    def do_encrypt(self, secret, use_encrypt=False, handler=None, context=None, **settings):
+        """call handler's hash() method with specified options"""
+        self.populate_settings(settings)
+        if context is None:
+            context = {}
+        secret = self.populate_context(secret, context)
+        if use_encrypt:
+            # use legacy 1.6 api
+            warnings = []
+            if settings:
+                context.update(**settings)
+                warnings.append("passing settings to.*is deprecated")
+            with self.assertWarningList(warnings):
+                return (handler or self.handler).encrypt(secret, **context)
+        else:
+            # use 1.7 api
+            return (handler or self.handler).using(**settings).hash(secret, **context)
+
+    def do_verify(self, secret, hash, handler=None, **kwds):
+        """call handler's verify method"""
+        secret = self.populate_context(secret, kwds)
+        return (handler or self.handler).verify(secret, hash, **kwds)
+
+    def do_identify(self, hash):
+        """call handler's identify method"""
+        return self.handler.identify(hash)
+
+    def do_genconfig(self, **kwds):
+        """call handler's genconfig method with specified options"""
+        self.populate_settings(kwds)
+        return self.handler.genconfig(**kwds)
+
+    def do_genhash(self, secret, config, **kwds):
+        """call handler's genhash method with specified options"""
+        secret = self.populate_context(secret, kwds)
+        return self.handler.genhash(secret, config, **kwds)
+
+    def do_stub_encrypt(self, handler=None, context=None, **settings):
+        """
+        return sample hash for handler, w/o caring if digest is valid
+        (uses some monkeypatching to minimize digest calculation cost)
+        """
+        handler = (handler or self.handler).using(**settings)
+        if context is None:
+            context = {}
+        secret = self.populate_context("", context)
+        with patch_calc_min_rounds(handler):
+            return handler.hash(secret, **context)
+
+    #---------------------------------------------------------------
+    # automatically generate subclasses for testing specific backends,
+    # and other backend helpers
+    #---------------------------------------------------------------
+
+    #: default message used by _get_skip_backend_reason()
+    _BACKEND_NOT_AVAILABLE = "backend not available"
+
+    @classmethod
+    def _get_skip_backend_reason(cls, backend):
+        """
+        helper for create_backend_case() --
+        returns reason to skip backend, or None if backend should be tested
+        """
+        handler = cls.handler
+        if not is_default_backend(handler, backend) and not TEST_MODE("full"):
+            return "only default backend is being tested"
+        if handler.has_backend(backend):
+            return None
+        return cls._BACKEND_NOT_AVAILABLE
+
+    @classmethod
+    def create_backend_case(cls, backend):
+        handler = cls.handler
+        name = handler.name
+        assert hasattr(handler, "backends"), "handler must support uh.HasManyBackends protocol"
+        assert backend in handler.backends, "unknown backend: %r" % (backend,)
+        bases = (cls,)
+        if backend == "os_crypt":
+            bases += (OsCryptMixin,)
+        subcls = type(
+            "%s_%s_test" % (name, backend),
+            bases,
+            dict(
+                descriptionPrefix="%s (%s backend)" % (name, backend),
+                backend=backend,
+                _skip_backend_reason=cls._get_skip_backend_reason(backend),
+                __module__=cls.__module__,
+            )
+        )
+        return subcls
+
+    #: flag for setUp() indicating this class is disabled due to backend issue;
+    #: this is only set for dynamic subclasses generated by create_backend_case()
+    _skip_backend_reason = None
+
+    def _test_requires_backend(self):
+        """
+        check if current test method decorated with doesnt_require_backend() helper
+        """
+        meth = getattr(self, self._testMethodName, None)
+        return not getattr(meth, "_doesnt_require_backend", False)
+
+    #===================================================================
+    # setup
+    #===================================================================
+    def setUp(self):
+
+        # check if test is disabled due to missing backend;
+        # and that it wasn't exempted via @doesnt_require_backend() decorator
+        test_requires_backend = self._test_requires_backend()
+        if test_requires_backend and self._skip_backend_reason:
+            raise self.skipTest(self._skip_backend_reason)
+
+        super(HandlerCase, self).setUp()
+
+        # if needed, select specific backend for duration of test
+        # NOTE: skipping this if create_backend_case() signalled we're skipping backend
+        #       (can only get here for @doesnt_require_backend decorated methods)
+        handler = self.handler
+        backend = self.backend
+        if backend:
+            if not hasattr(handler, "set_backend"):
+                raise RuntimeError("handler doesn't support multiple backends")
+            try:
+                self.addCleanup(handler.set_backend, handler.get_backend())
+                handler.set_backend(backend)
+            except uh.exc.MissingBackendError:
+                if test_requires_backend:
+                    raise
+                # else test is decorated with @doesnt_require_backend, let it through.
+
+        # patch some RNG references so they're reproducible.
+        from passlib.utils import handlers
+        self.patchAttr(handlers, "rng", self.getRandom("salt generator"))
+
+    #===================================================================
+    # basic tests
+    #===================================================================
+    def test_01_required_attributes(self):
+        """validate required attributes"""
+        handler = self.handler
+        def ga(name):
+            return getattr(handler, name, None)
+
+        #
+        # name should be a str, and valid
+        #
+        name = ga("name")
+        self.assertTrue(name, "name not defined:")
+        self.assertIsInstance(name, str, "name must be native str")
+        self.assertTrue(name.lower() == name, "name not lower-case:")
+        self.assertTrue(re.match("^[a-z0-9_]+$", name),
+                        "name must be alphanum + underscore: %r" % (name,))
+
+        #
+        # setting_kwds should be specified
+        #
+        settings = ga("setting_kwds")
+        self.assertTrue(settings is not None, "setting_kwds must be defined:")
+        self.assertIsInstance(settings, tuple, "setting_kwds must be a tuple:")
+
+        #
+        # context_kwds should be specified
+        #
+        context = ga("context_kwds")
+        self.assertTrue(context is not None, "context_kwds must be defined:")
+        self.assertIsInstance(context, tuple, "context_kwds must be a tuple:")
+
+        # XXX: any more checks needed?
+
+    def test_02_config_workflow(self):
+        """test basic config-string workflow
+
+        this tests that genconfig() returns the expected types,
+        and that identify() and genhash() handle the result correctly.
+        """
+        #
+        # genconfig() should return native string.
+        # NOTE: prior to 1.7 could return None, but that's no longer allowed.
+        #
+        config = self.do_genconfig()
+        self.check_returned_native_str(config, "genconfig")
+
+        #
+        # genhash() should always accept genconfig()'s output,
+        # whether str OR None.
+        #
+        result = self.do_genhash('stub', config)
+        self.check_returned_native_str(result, "genhash")
+
+        #
+        # verify() should never accept config strings
+        #
+
+        # NOTE: changed as of 1.7 -- previously, .verify() should have
+        #       rejected partial config strings returned by genconfig().
+        #       as of 1.7, that feature is deprecated, and genconfig()
+        #       always returns a hash (usually of the empty string)
+        #       so verify should always accept it's output
+        self.do_verify('', config)  # usually true, but not required by protocol
+
+        #
+        # identify() should positively identify config strings if not None.
+        #
+
+        # NOTE: changed as of 1.7 -- genconfig() previously might return None,
+        #       now must always return valid hash
+        self.assertTrue(self.do_identify(config),
+            "identify() failed to identify genconfig() output: %r" %
+            (config,))
+
+    def test_02_using_workflow(self):
+        """test basic using() workflow"""
+        handler = self.handler
+        subcls = handler.using()
+        self.assertIsNot(subcls, handler)
+        self.assertEqual(subcls.name, handler.name)
+        # NOTE: other info attrs should match as well, just testing basic behavior.
+        # NOTE: mixin-specific args like using(min_rounds=xxx) tested later.
+
+    def test_03_hash_workflow(self, use_16_legacy=False):
+        """test basic hash-string workflow.
+
+        this tests that hash()'s hashes are accepted
+        by verify() and identify(), and regenerated correctly by genhash().
+        the test is run against a couple of different stock passwords.
+        """
+        wrong_secret = 'stub'
+        for secret in self.stock_passwords:
+
+            #
+            # hash() should generate native str hash
+            #
+            result = self.do_encrypt(secret, use_encrypt=use_16_legacy)
+            self.check_returned_native_str(result, "hash")
+
+            #
+            # verify() should work only against secret
+            #
+            self.check_verify(secret, result)
+            self.check_verify(wrong_secret, result, negate=True)
+
+            #
+            # genhash() should reproduce original hash
+            #
+            other = self.do_genhash(secret, result)
+            self.check_returned_native_str(other, "genhash")
+            if self.handler.is_disabled and self.disabled_contains_salt:
+                self.assertNotEqual(other, result, "genhash() failed to salt result "
+                                    "hash: secret=%r hash=%r: result=%r" %
+                                    (secret, result, other))
+            else:
+                self.assertEqual(other, result, "genhash() failed to reproduce "
+                                 "hash: secret=%r hash=%r: result=%r" %
+                                 (secret, result, other))
+
+            #
+            # genhash() should NOT reproduce original hash for wrong password
+            #
+            other = self.do_genhash(wrong_secret, result)
+            self.check_returned_native_str(other, "genhash")
+            if self.handler.is_disabled and not self.disabled_contains_salt:
+                self.assertEqual(other, result, "genhash() failed to reproduce "
+                                 "disabled-hash: secret=%r hash=%r other_secret=%r: result=%r" %
+                                 (secret, result, wrong_secret, other))
+            else:
+                self.assertNotEqual(other, result, "genhash() duplicated "
+                                 "hash: secret=%r hash=%r wrong_secret=%r: result=%r" %
+                                 (secret, result, wrong_secret, other))
+
+            #
+            # identify() should positively identify hash
+            #
+            self.assertTrue(self.do_identify(result))
+
+    def test_03_legacy_hash_workflow(self):
+        """test hash-string workflow with legacy .encrypt() & .genhash() methods"""
+        self.test_03_hash_workflow(use_16_legacy=True)
+
+    def test_04_hash_types(self):
+        """test hashes can be unicode or bytes"""
+        # this runs through workflow similar to 03, but wraps
+        # everything using tonn() so we test unicode under py2,
+        # and bytes under py3.
+
+        # hash using non-native secret
+        result = self.do_encrypt(tonn('stub'))
+        self.check_returned_native_str(result, "hash")
+
+        # verify using non-native hash
+        self.check_verify('stub', tonn(result))
+
+        # verify using non-native hash AND secret
+        self.check_verify(tonn('stub'), tonn(result))
+
+        # genhash using non-native hash
+        other = self.do_genhash('stub', tonn(result))
+        self.check_returned_native_str(other, "genhash")
+        if self.handler.is_disabled and self.disabled_contains_salt:
+            self.assertNotEqual(other, result)
+        else:
+            self.assertEqual(other, result)
+
+        # genhash using non-native hash AND secret
+        other = self.do_genhash(tonn('stub'), tonn(result))
+        self.check_returned_native_str(other, "genhash")
+        if self.handler.is_disabled and self.disabled_contains_salt:
+            self.assertNotEqual(other, result)
+        else:
+            self.assertEqual(other, result)
+
+        # identify using non-native hash
+        self.assertTrue(self.do_identify(tonn(result)))
+
+    def test_05_backends(self):
+        """test multi-backend support"""
+
+        # check that handler supports multiple backends
+        handler = self.handler
+        if not hasattr(handler, "set_backend"):
+            raise self.skipTest("handler only has one backend")
+
+        # add cleanup func to restore old backend
+        self.addCleanup(handler.set_backend, handler.get_backend())
+
+        # run through each backend, make sure it works
+        for backend in handler.backends:
+
+            #
+            # validate backend name
+            #
+            self.assertIsInstance(backend, str)
+            self.assertNotIn(backend, RESERVED_BACKEND_NAMES,
+                             "invalid backend name: %r" % (backend,))
+
+            #
+            # ensure has_backend() returns bool value
+            #
+            ret = handler.has_backend(backend)
+            if ret is True:
+                # verify backend can be loaded
+                handler.set_backend(backend)
+                self.assertEqual(handler.get_backend(), backend)
+
+            elif ret is False:
+                # verify backend CAN'T be loaded
+                self.assertRaises(MissingBackendError, handler.set_backend,
+                                  backend)
+
+            else:
+                # didn't return boolean object. commonly fails due to
+                # use of 'classmethod' decorator instead of 'classproperty'
+                raise TypeError("has_backend(%r) returned invalid "
+                                "value: %r" % (backend, ret))
+
+    #===================================================================
+    # salts
+    #===================================================================
+    def require_salt(self):
+        if 'salt' not in self.handler.setting_kwds:
+            raise self.skipTest("handler doesn't have salt")
+
+    def require_salt_info(self):
+        self.require_salt()
+        if not has_salt_info(self.handler):
+            raise self.skipTest("handler doesn't provide salt info")
+
+    def test_10_optional_salt_attributes(self):
+        """validate optional salt attributes"""
+        self.require_salt_info()
+        AssertionError = self.failureException
+        cls = self.handler
+
+        # check max_salt_size
+        mx_set = (cls.max_salt_size is not None)
+        if mx_set and cls.max_salt_size < 1:
+            raise AssertionError("max_salt_chars must be >= 1")
+
+        # check min_salt_size
+        if cls.min_salt_size < 0:
+            raise AssertionError("min_salt_chars must be >= 0")
+        if mx_set and cls.min_salt_size > cls.max_salt_size:
+            raise AssertionError("min_salt_chars must be <= max_salt_chars")
+
+        # check default_salt_size
+        if cls.default_salt_size < cls.min_salt_size:
+            raise AssertionError("default_salt_size must be >= min_salt_size")
+        if mx_set and cls.default_salt_size > cls.max_salt_size:
+            raise AssertionError("default_salt_size must be <= max_salt_size")
+
+        # check for 'salt_size' keyword
+        # NOTE: skipping warning if default salt size is already maxed out
+        #       (might change that in future)
+        if 'salt_size' not in cls.setting_kwds and (not mx_set or cls.default_salt_size < cls.max_salt_size):
+            warn('%s: hash handler supports range of salt sizes, '
+                 'but doesn\'t offer \'salt_size\' setting' % (cls.name,))
+
+        # check salt_chars & default_salt_chars
+        if cls.salt_chars:
+            if not cls.default_salt_chars:
+                raise AssertionError("default_salt_chars must not be empty")
+            for c in cls.default_salt_chars:
+                if c not in cls.salt_chars:
+                    raise AssertionError("default_salt_chars must be subset of salt_chars: %r not in salt_chars" % (c,))
+        else:
+            if not cls.default_salt_chars:
+                raise AssertionError("default_salt_chars MUST be specified if salt_chars is empty")
+
+    @property
+    def salt_bits(self):
+        """calculate number of salt bits in hash"""
+        # XXX: replace this with bitsize() method?
+        handler = self.handler
+        assert has_salt_info(handler), "need explicit bit-size for " + handler.name
+        from math import log
+        # FIXME: this may be off for case-insensitive hashes, but that accounts
+        # for ~1 bit difference, which is good enough for test_11()
+        return int(handler.default_salt_size *
+                   log(len(handler.default_salt_chars), 2))
+
+    def test_11_unique_salt(self):
+        """test hash() / genconfig() creates new salt each time"""
+        self.require_salt()
+        # odds of picking 'n' identical salts at random is '(.5**salt_bits)**n'.
+        # we want to pick the smallest N needed s.t. odds are <1/10**d, just
+        # to eliminate false-positives. which works out to n>3.33+d-salt_bits.
+        # for 1/1e12 odds, n=1 is sufficient for most hashes, but a few border cases (e.g.
+        # cisco_type7) have < 16 bits of salt, requiring more.
+        samples = max(1, 4 + 12 - self.salt_bits)
+
+        def sampler(func):
+            value1 = func()
+            for _ in irange(samples):
+                value2 = func()
+                if value1 != value2:
+                    return
+            raise self.failureException("failed to find different salt after "
+                                        "%d samples" % (samples,))
+        sampler(self.do_genconfig)
+        sampler(lambda: self.do_encrypt("stub"))
+
+    def test_12_min_salt_size(self):
+        """test hash() / genconfig() honors min_salt_size"""
+        self.require_salt_info()
+
+        handler = self.handler
+        salt_char = handler.salt_chars[0:1]
+        min_size = handler.min_salt_size
+
+        #
+        # check min is accepted
+        #
+        s1 = salt_char * min_size
+        self.do_genconfig(salt=s1)
+
+        self.do_encrypt('stub', salt_size=min_size)
+
+        #
+        # check min-1 is rejected
+        #
+        if min_size > 0:
+            self.assertRaises(ValueError, self.do_genconfig,
+                              salt=s1[:-1])
+
+        self.assertRaises(ValueError, self.do_encrypt, 'stub',
+                          salt_size=min_size-1)
+
+    def test_13_max_salt_size(self):
+        """test hash() / genconfig() honors max_salt_size"""
+        self.require_salt_info()
+
+        handler = self.handler
+        max_size = handler.max_salt_size
+        salt_char = handler.salt_chars[0:1]
+
+        # NOTE: skipping this for hashes like argon2 since max_salt_size takes WAY too much memory
+        if max_size is None or max_size > (1 << 20):
+            #
+            # if it's not set, salt should never be truncated; so test it
+            # with an unreasonably large salt.
+            #
+            s1 = salt_char * 1024
+            c1 = self.do_stub_encrypt(salt=s1)
+            c2 = self.do_stub_encrypt(salt=s1 + salt_char)
+            self.assertNotEqual(c1, c2)
+
+            self.do_stub_encrypt(salt_size=1024)
+
+        else:
+            #
+            # check max size is accepted
+            #
+            s1 = salt_char * max_size
+            c1 = self.do_stub_encrypt(salt=s1)
+
+            self.do_stub_encrypt(salt_size=max_size)
+
+            #
+            # check max size + 1 is rejected
+            #
+            s2 = s1 + salt_char
+            self.assertRaises(ValueError, self.do_stub_encrypt, salt=s2)
+
+            self.assertRaises(ValueError, self.do_stub_encrypt, salt_size=max_size + 1)
+
+            #
+            # should accept too-large salt in relaxed mode
+            #
+            if has_relaxed_setting(handler):
+                with warnings.catch_warnings(record=True): # issues passlibhandlerwarning
+                    c2 = self.do_stub_encrypt(salt=s2, relaxed=True)
+                self.assertEqual(c2, c1)
+
+            #
+            # if min_salt supports it, check smaller than mx is NOT truncated
+            #
+            if handler.min_salt_size < max_size:
+                c3 = self.do_stub_encrypt(salt=s1[:-1])
+                self.assertNotEqual(c3, c1)
+
+    # whether salt should be passed through bcrypt repair function
+    fuzz_salts_need_bcrypt_repair = False
+
+    def prepare_salt(self, salt):
+        """prepare generated salt"""
+        if self.fuzz_salts_need_bcrypt_repair:
+            from passlib.utils.binary import bcrypt64
+            salt = bcrypt64.repair_unused(salt)
+        return salt
+
+    def test_14_salt_chars(self):
+        """test hash() honors salt_chars"""
+        self.require_salt_info()
+
+        handler = self.handler
+        mx = handler.max_salt_size
+        mn = handler.min_salt_size
+        cs = handler.salt_chars
+        raw = isinstance(cs, bytes)
+
+        # make sure all listed chars are accepted
+        for salt in batch(cs, mx or 32):
+            if len(salt) < mn:
+                salt = repeat_string(salt, mn)
+            salt = self.prepare_salt(salt)
+            self.do_stub_encrypt(salt=salt)
+
+        # check some invalid salt chars, make sure they're rejected
+        source = u('\x00\xff')
+        if raw:
+            source = source.encode("latin-1")
+        chunk = max(mn, 1)
+        for c in source:
+            if c not in cs:
+                self.assertRaises(ValueError, self.do_stub_encrypt, salt=c*chunk,
+                                  __msg__="invalid salt char %r:" % (c,))
+
+    @property
+    def salt_type(self):
+        """hack to determine salt keyword's datatype"""
+        # NOTE: cisco_type7 uses 'int'
+        if getattr(self.handler, "_salt_is_bytes", False):
+            return bytes
+        else:
+            return unicode
+
+    def test_15_salt_type(self):
+        """test non-string salt values"""
+        self.require_salt()
+        salt_type = self.salt_type
+        salt_size = getattr(self.handler, "min_salt_size", 0) or 8
+
+        # should always throw error for random class.
+        class fake(object):
+            pass
+        self.assertRaises(TypeError, self.do_encrypt, 'stub', salt=fake())
+
+        # unicode should be accepted only if salt_type is unicode.
+        if salt_type is not unicode:
+            self.assertRaises(TypeError, self.do_encrypt, 'stub', salt=u('x') * salt_size)
+
+        # bytes should be accepted only if salt_type is bytes,
+        # OR if salt type is unicode and running PY2 - to allow native strings.
+        if not (salt_type is bytes or (PY2 and salt_type is unicode)):
+            self.assertRaises(TypeError, self.do_encrypt, 'stub', salt=b'x' * salt_size)
+
+    def test_using_salt_size(self):
+        """Handler.using() -- default_salt_size"""
+        self.require_salt_info()
+
+        handler = self.handler
+        mn = handler.min_salt_size
+        mx = handler.max_salt_size
+        df = handler.default_salt_size
+
+        # should prevent setting below handler limit
+        self.assertRaises(ValueError, handler.using, default_salt_size=-1)
+        with self.assertWarningList([PasslibHashWarning]):
+            temp = handler.using(default_salt_size=-1, relaxed=True)
+        self.assertEqual(temp.default_salt_size, mn)
+
+        # should prevent setting above handler limit
+        if mx:
+            self.assertRaises(ValueError, handler.using, default_salt_size=mx+1)
+            with self.assertWarningList([PasslibHashWarning]):
+                temp = handler.using(default_salt_size=mx+1, relaxed=True)
+            self.assertEqual(temp.default_salt_size, mx)
+
+        # try setting to explicit value
+        if mn != mx:
+            temp = handler.using(default_salt_size=mn+1)
+            self.assertEqual(temp.default_salt_size, mn+1)
+            self.assertEqual(handler.default_salt_size, df)
+
+            temp = handler.using(default_salt_size=mn+2)
+            self.assertEqual(temp.default_salt_size, mn+2)
+            self.assertEqual(handler.default_salt_size, df)
+
+        # accept strings
+        if mn == mx:
+            ref = mn
+        else:
+            ref = mn + 1
+        temp = handler.using(default_salt_size=str(ref))
+        self.assertEqual(temp.default_salt_size, ref)
+
+        # reject invalid strings
+        self.assertRaises(ValueError, handler.using, default_salt_size=str(ref) + "xxx")
+
+        # honor 'salt_size' alias
+        temp = handler.using(salt_size=ref)
+        self.assertEqual(temp.default_salt_size, ref)
+
+    #===================================================================
+    # rounds
+    #===================================================================
+    def require_rounds_info(self):
+        if not has_rounds_info(self.handler):
+            raise self.skipTest("handler lacks rounds attributes")
+
+    def test_20_optional_rounds_attributes(self):
+        """validate optional rounds attributes"""
+        self.require_rounds_info()
+
+        cls = self.handler
+        AssertionError = self.failureException
+
+        # check max_rounds
+        if cls.max_rounds is None:
+            raise AssertionError("max_rounds not specified")
+        if cls.max_rounds < 1:
+            raise AssertionError("max_rounds must be >= 1")
+
+        # check min_rounds
+        if cls.min_rounds < 0:
+            raise AssertionError("min_rounds must be >= 0")
+        if cls.min_rounds > cls.max_rounds:
+            raise AssertionError("min_rounds must be <= max_rounds")
+
+        # check default_rounds
+        if cls.default_rounds is not None:
+            if cls.default_rounds < cls.min_rounds:
+                raise AssertionError("default_rounds must be >= min_rounds")
+            if cls.default_rounds > cls.max_rounds:
+                raise AssertionError("default_rounds must be <= max_rounds")
+
+        # check rounds_cost
+        if cls.rounds_cost not in rounds_cost_values:
+            raise AssertionError("unknown rounds cost constant: %r" % (cls.rounds_cost,))
+
+    def test_21_min_rounds(self):
+        """test hash() / genconfig() honors min_rounds"""
+        self.require_rounds_info()
+        handler = self.handler
+        min_rounds = handler.min_rounds
+
+        # check min is accepted
+        self.do_genconfig(rounds=min_rounds)
+        self.do_encrypt('stub', rounds=min_rounds)
+
+        # check min-1 is rejected
+        self.assertRaises(ValueError, self.do_genconfig, rounds=min_rounds-1)
+        self.assertRaises(ValueError, self.do_encrypt, 'stub', rounds=min_rounds-1)
+
+        # TODO: check relaxed mode clips min-1
+
+    def test_21b_max_rounds(self):
+        """test hash() / genconfig() honors max_rounds"""
+        self.require_rounds_info()
+        handler = self.handler
+        max_rounds = handler.max_rounds
+
+        if max_rounds is not None:
+            # check max+1 is rejected
+            self.assertRaises(ValueError, self.do_genconfig, rounds=max_rounds+1)
+            self.assertRaises(ValueError, self.do_encrypt, 'stub', rounds=max_rounds+1)
+
+        # handle max rounds
+        if max_rounds is None:
+            self.do_stub_encrypt(rounds=(1 << 31) - 1)
+        else:
+            self.do_stub_encrypt(rounds=max_rounds)
+
+            # TODO: check relaxed mode clips max+1
+
+    #--------------------------------------------------------------------------------------
+    # HasRounds.using() / .needs_update() -- desired rounds limits
+    #--------------------------------------------------------------------------------------
+    def _create_using_rounds_helper(self):
+        """
+        setup test helpers for testing handler.using()'s rounds parameters.
+        """
+        self.require_rounds_info()
+        handler = self.handler
+
+        if handler.name == "bsdi_crypt":
+            # hack to bypass bsdi-crypt's "odd rounds only" behavior, messes up this test
+            orig_handler = handler
+            handler = handler.using()
+            handler._generate_rounds = classmethod(lambda cls: super(orig_handler, cls)._generate_rounds())
+
+        # create some fake values to test with
+        orig_min_rounds = handler.min_rounds
+        orig_max_rounds = handler.max_rounds
+        orig_default_rounds = handler.default_rounds
+        medium = ((orig_max_rounds or 9999) + orig_min_rounds) // 2
+        if medium == orig_default_rounds:
+            medium += 1
+        small = (orig_min_rounds + medium) // 2
+        large = ((orig_max_rounds or 9999) + medium) // 2
+
+        if handler.name == "bsdi_crypt":
+            # hack to avoid even numbered rounds
+            small |= 1
+            medium |= 1
+            large |= 1
+            adj = 2
+        else:
+            adj = 1
+
+        # create a subclass with small/medium/large as new default desired values
+        with self.assertWarningList([]):
+            subcls = handler.using(
+                min_desired_rounds=small,
+                max_desired_rounds=large,
+                default_rounds=medium,
+            )
+
+        # return helpers
+        return handler, subcls, small, medium, large, adj
+
+    def test_has_rounds_using_harness(self):
+        """
+        HasRounds.using() -- sanity check test harness
+        """
+        # setup helpers
+        self.require_rounds_info()
+        handler = self.handler
+        orig_min_rounds = handler.min_rounds
+        orig_max_rounds = handler.max_rounds
+        orig_default_rounds = handler.default_rounds
+        handler, subcls, small, medium, large, adj = self._create_using_rounds_helper()
+
+        # shouldn't affect original handler at all
+        self.assertEqual(handler.min_rounds, orig_min_rounds)
+        self.assertEqual(handler.max_rounds, orig_max_rounds)
+        self.assertEqual(handler.min_desired_rounds, None)
+        self.assertEqual(handler.max_desired_rounds, None)
+        self.assertEqual(handler.default_rounds, orig_default_rounds)
+
+        # should affect subcls' desired value, but not hard min/max
+        self.assertEqual(subcls.min_rounds, orig_min_rounds)
+        self.assertEqual(subcls.max_rounds, orig_max_rounds)
+        self.assertEqual(subcls.default_rounds, medium)
+        self.assertEqual(subcls.min_desired_rounds, small)
+        self.assertEqual(subcls.max_desired_rounds, large)
+
+    def test_has_rounds_using_w_min_rounds(self):
+        """
+        HasRounds.using() -- min_rounds / min_desired_rounds
+        """
+        # setup helpers
+        handler, subcls, small, medium, large, adj = self._create_using_rounds_helper()
+        orig_min_rounds = handler.min_rounds
+        orig_max_rounds = handler.max_rounds
+        orig_default_rounds = handler.default_rounds
+
+        # .using() should clip values below valid minimum, w/ warning
+        if orig_min_rounds > 0:
+            self.assertRaises(ValueError, handler.using, min_desired_rounds=orig_min_rounds - adj)
+            with self.assertWarningList([PasslibHashWarning]):
+                temp = handler.using(min_desired_rounds=orig_min_rounds - adj, relaxed=True)
+            self.assertEqual(temp.min_desired_rounds, orig_min_rounds)
+
+        # .using() should clip values above valid maximum, w/ warning
+        if orig_max_rounds:
+            self.assertRaises(ValueError, handler.using, min_desired_rounds=orig_max_rounds + adj)
+            with self.assertWarningList([PasslibHashWarning]):
+                temp = handler.using(min_desired_rounds=orig_max_rounds + adj, relaxed=True)
+            self.assertEqual(temp.min_desired_rounds, orig_max_rounds)
+
+        # .using() should allow values below previous desired minimum, w/o warning
+        with self.assertWarningList([]):
+            temp = subcls.using(min_desired_rounds=small - adj)
+        self.assertEqual(temp.min_desired_rounds, small - adj)
+
+        # .using() should allow values w/in previous range
+        temp = subcls.using(min_desired_rounds=small + 2 * adj)
+        self.assertEqual(temp.min_desired_rounds, small + 2 * adj)
+
+        # .using() should allow values above previous desired maximum, w/o warning
+        with self.assertWarningList([]):
+            temp = subcls.using(min_desired_rounds=large + adj)
+        self.assertEqual(temp.min_desired_rounds, large + adj)
+
+        # hash() etc should allow explicit values below desired minimum
+        # NOTE: formerly issued a warning in passlib 1.6, now just a wrapper for .using()
+        self.assertEqual(get_effective_rounds(subcls, small + adj), small + adj)
+        self.assertEqual(get_effective_rounds(subcls, small), small)
+        with self.assertWarningList([]):
+            self.assertEqual(get_effective_rounds(subcls, small - adj), small - adj)
+
+        # 'min_rounds' should be treated as alias for 'min_desired_rounds'
+        temp = handler.using(min_rounds=small)
+        self.assertEqual(temp.min_desired_rounds, small)
+
+        # should be able to specify strings
+        temp = handler.using(min_rounds=str(small))
+        self.assertEqual(temp.min_desired_rounds, small)
+
+        # invalid strings should cause error
+        self.assertRaises(ValueError, handler.using, min_rounds=str(small) + "xxx")
+
+    def test_has_rounds_replace_w_max_rounds(self):
+        """
+        HasRounds.using() -- max_rounds / max_desired_rounds
+        """
+        # setup helpers
+        handler, subcls, small, medium, large, adj = self._create_using_rounds_helper()
+        orig_min_rounds = handler.min_rounds
+        orig_max_rounds = handler.max_rounds
+
+        # .using() should clip values below valid minimum w/ warning
+        if orig_min_rounds > 0:
+            self.assertRaises(ValueError, handler.using, max_desired_rounds=orig_min_rounds - adj)
+            with self.assertWarningList([PasslibHashWarning]):
+                temp = handler.using(max_desired_rounds=orig_min_rounds - adj, relaxed=True)
+            self.assertEqual(temp.max_desired_rounds, orig_min_rounds)
+
+        # .using() should clip values above valid maximum, w/ warning
+        if orig_max_rounds:
+            self.assertRaises(ValueError, handler.using, max_desired_rounds=orig_max_rounds + adj)
+            with self.assertWarningList([PasslibHashWarning]):
+                temp = handler.using(max_desired_rounds=orig_max_rounds + adj, relaxed=True)
+            self.assertEqual(temp.max_desired_rounds, orig_max_rounds)
+
+        # .using() should clip values below previous minimum, w/ warning
+        with self.assertWarningList([PasslibConfigWarning]):
+            temp = subcls.using(max_desired_rounds=small - adj)
+        self.assertEqual(temp.max_desired_rounds, small)
+
+        # .using() should reject explicit min > max
+        self.assertRaises(ValueError, subcls.using,
+                          min_desired_rounds=medium+adj,
+                          max_desired_rounds=medium-adj)
+
+        # .using() should allow values w/in previous range
+        temp = subcls.using(min_desired_rounds=large - 2 * adj)
+        self.assertEqual(temp.min_desired_rounds, large - 2 * adj)
+
+        # .using() should allow values above previous desired maximum, w/o warning
+        with self.assertWarningList([]):
+            temp = subcls.using(max_desired_rounds=large + adj)
+        self.assertEqual(temp.max_desired_rounds, large + adj)
+
+        # hash() etc should allow explicit values above desired minimum, w/o warning
+        # NOTE: formerly issued a warning in passlib 1.6, now just a wrapper for .using()
+        self.assertEqual(get_effective_rounds(subcls, large - adj), large - adj)
+        self.assertEqual(get_effective_rounds(subcls, large), large)
+        with self.assertWarningList([]):
+            self.assertEqual(get_effective_rounds(subcls, large + adj), large + adj)
+
+        # 'max_rounds' should be treated as alias for 'max_desired_rounds'
+        temp = handler.using(max_rounds=large)
+        self.assertEqual(temp.max_desired_rounds, large)
+
+        # should be able to specify strings
+        temp = handler.using(max_desired_rounds=str(large))
+        self.assertEqual(temp.max_desired_rounds, large)
+
+        # invalid strings should cause error
+        self.assertRaises(ValueError, handler.using, max_desired_rounds=str(large) + "xxx")
+
+    def test_has_rounds_using_w_default_rounds(self):
+        """
+        HasRounds.using() -- default_rounds
+        """
+        # setup helpers
+        handler, subcls, small, medium, large, adj = self._create_using_rounds_helper()
+        orig_max_rounds = handler.max_rounds
+
+        # XXX: are there any other cases that need testing?
+
+        # implicit default rounds -- increase to min_rounds
+        temp = subcls.using(min_rounds=medium+adj)
+        self.assertEqual(temp.default_rounds, medium+adj)
+
+        # implicit default rounds -- decrease to max_rounds
+        temp = subcls.using(max_rounds=medium-adj)
+        self.assertEqual(temp.default_rounds, medium-adj)
+
+        # explicit default rounds below desired minimum
+        # XXX: make this a warning if min is implicit?
+        self.assertRaises(ValueError, subcls.using, default_rounds=small-adj)
+
+        # explicit default rounds above desired maximum
+        # XXX: make this a warning if max is implicit?
+        if orig_max_rounds:
+            self.assertRaises(ValueError, subcls.using, default_rounds=large+adj)
+
+        # hash() etc should implicit default rounds, but get overridden
+        self.assertEqual(get_effective_rounds(subcls), medium)
+        self.assertEqual(get_effective_rounds(subcls, medium+adj), medium+adj)
+
+        # should be able to specify strings
+        temp = handler.using(default_rounds=str(medium))
+        self.assertEqual(temp.default_rounds, medium)
+
+        # invalid strings should cause error
+        self.assertRaises(ValueError, handler.using, default_rounds=str(medium) + "xxx")
+
+    def test_has_rounds_using_w_rounds(self):
+        """
+        HasRounds.using() -- rounds
+        """
+        # setup helpers
+        handler, subcls, small, medium, large, adj = self._create_using_rounds_helper()
+        orig_max_rounds = handler.max_rounds
+
+        # 'rounds' should be treated as fallback for min, max, and default
+        temp = subcls.using(rounds=medium+adj)
+        self.assertEqual(temp.min_desired_rounds, medium+adj)
+        self.assertEqual(temp.default_rounds, medium+adj)
+        self.assertEqual(temp.max_desired_rounds, medium+adj)
+
+        # 'rounds' should be treated as fallback for min, max, and default
+        temp = subcls.using(rounds=medium+1, min_rounds=small+adj,
+                            default_rounds=medium, max_rounds=large-adj)
+        self.assertEqual(temp.min_desired_rounds, small+adj)
+        self.assertEqual(temp.default_rounds, medium)
+        self.assertEqual(temp.max_desired_rounds, large-adj)
+
+    def test_has_rounds_using_w_vary_rounds_parsing(self):
+        """
+        HasRounds.using() -- vary_rounds parsing
+        """
+        # setup helpers
+        handler, subcls, small, medium, large, adj = self._create_using_rounds_helper()
+
+        def parse(value):
+            return subcls.using(vary_rounds=value).vary_rounds
+
+        # floats should be preserved
+        self.assertEqual(parse(0.1), 0.1)
+        self.assertEqual(parse('0.1'), 0.1)
+
+        # 'xx%' should be converted to float
+        self.assertEqual(parse('10%'), 0.1)
+
+        # ints should be preserved
+        self.assertEqual(parse(1000), 1000)
+        self.assertEqual(parse('1000'), 1000)
+
+        # float bounds should be enforced
+        self.assertRaises(ValueError, parse, -0.1)
+        self.assertRaises(ValueError, parse, 1.1)
+
+    def test_has_rounds_using_w_vary_rounds_generation(self):
+        """
+        HasRounds.using() -- vary_rounds generation
+        """
+        handler, subcls, small, medium, large, adj = self._create_using_rounds_helper()
+
+        def get_effective_range(cls):
+            seen = set(get_effective_rounds(cls) for _ in irange(1000))
+            return min(seen), max(seen)
+
+        def assert_rounds_range(vary_rounds, lower, upper):
+            temp = subcls.using(vary_rounds=vary_rounds)
+            seen_lower, seen_upper = get_effective_range(temp)
+            self.assertEqual(seen_lower, lower, "vary_rounds had wrong lower limit:")
+            self.assertEqual(seen_upper, upper, "vary_rounds had wrong upper limit:")
+
+        # test static
+        assert_rounds_range(0, medium, medium)
+        assert_rounds_range("0%", medium, medium)
+
+        # test absolute
+        assert_rounds_range(adj, medium - adj, medium + adj)
+        assert_rounds_range(50, max(small, medium - 50), min(large, medium + 50))
+
+        # test relative - should shift over at 50% mark
+        if handler.rounds_cost == "log2":
+            # log rounds "50%" variance should only increase/decrease by 1 cost value
+            assert_rounds_range("1%", medium, medium)
+            assert_rounds_range("49%", medium, medium)
+            assert_rounds_range("50%", medium - adj, medium)
+        else:
+            # for linear rounds, range is frequently so huge, won't ever see ends.
+            # so we just check it's within an expected range.
+            lower, upper = get_effective_range(subcls.using(vary_rounds="50%"))
+
+            self.assertGreaterEqual(lower, max(small, medium * 0.5))
+            self.assertLessEqual(lower, max(small, medium * 0.8))
+
+            self.assertGreaterEqual(upper, min(large, medium * 1.2))
+            self.assertLessEqual(upper, min(large, medium * 1.5))
+
+    def test_has_rounds_using_and_needs_update(self):
+        """
+        HasRounds.using() -- desired_rounds + needs_update()
+        """
+        handler, subcls, small, medium, large, adj = self._create_using_rounds_helper()
+
+        temp = subcls.using(min_desired_rounds=small+2, max_desired_rounds=large-2)
+
+        # generate some sample hashes
+        small_hash = self.do_stub_encrypt(subcls, rounds=small)
+        medium_hash = self.do_stub_encrypt(subcls, rounds=medium)
+        large_hash = self.do_stub_encrypt(subcls, rounds=large)
+
+        # everything should be w/in bounds for original handler
+        self.assertFalse(subcls.needs_update(small_hash))
+        self.assertFalse(subcls.needs_update(medium_hash))
+        self.assertFalse(subcls.needs_update(large_hash))
+
+        # small & large should require update for temp handler
+        self.assertTrue(temp.needs_update(small_hash))
+        self.assertFalse(temp.needs_update(medium_hash))
+        self.assertTrue(temp.needs_update(large_hash))
+
+    #===================================================================
+    # idents
+    #===================================================================
+    def require_many_idents(self):
+        handler = self.handler
+        if not isinstance(handler, type) or not issubclass(handler, uh.HasManyIdents):
+            raise self.skipTest("handler doesn't derive from HasManyIdents")
+
+    def test_30_HasManyIdents(self):
+        """validate HasManyIdents configuration"""
+        cls = self.handler
+        self.require_many_idents()
+
+        # check settings
+        self.assertTrue('ident' in cls.setting_kwds)
+
+        # check ident_values list
+        for value in cls.ident_values:
+            self.assertIsInstance(value, unicode,
+                                  "cls.ident_values must be unicode:")
+        self.assertTrue(len(cls.ident_values)>1,
+                        "cls.ident_values must have 2+ elements:")
+
+        # check default_ident value
+        self.assertIsInstance(cls.default_ident, unicode,
+                              "cls.default_ident must be unicode:")
+        self.assertTrue(cls.default_ident in cls.ident_values,
+                        "cls.default_ident must specify member of cls.ident_values")
+
+        # check optional aliases list
+        if cls.ident_aliases:
+            for alias, ident in iteritems(cls.ident_aliases):
+                self.assertIsInstance(alias, unicode,
+                                      "cls.ident_aliases keys must be unicode:") # XXX: allow ints?
+                self.assertIsInstance(ident, unicode,
+                                      "cls.ident_aliases values must be unicode:")
+                self.assertTrue(ident in cls.ident_values,
+                                "cls.ident_aliases must map to cls.ident_values members: %r" % (ident,))
+
+        # check constructor validates ident correctly.
+        handler = cls
+        hash = self.get_sample_hash()[1]
+        kwds = handler.parsehash(hash)
+        del kwds['ident']
+
+        # ... accepts good ident
+        handler(ident=cls.default_ident, **kwds)
+
+        # ... requires ident w/o defaults
+        self.assertRaises(TypeError, handler, **kwds)
+
+        # ... supplies default ident
+        handler(use_defaults=True, **kwds)
+
+        # ... rejects bad ident
+        self.assertRaises(ValueError, handler, ident='xXx', **kwds)
+
+    # TODO: check various supported idents
+
+    def test_has_many_idents_using(self):
+        """HasManyIdents.using() -- 'default_ident' and 'ident' keywords"""
+        self.require_many_idents()
+
+        # pick alt ident to test with
+        handler = self.handler
+        orig_ident = handler.default_ident
+        for alt_ident in handler.ident_values:
+            if alt_ident != orig_ident:
+                break
+        else:
+            raise AssertionError("expected to find alternate ident: default=%r values=%r" %
+                                 (orig_ident, handler.ident_values))
+
+        def effective_ident(cls):
+            cls = unwrap_handler(cls)
+            return cls(use_defaults=True).ident
+
+        # keep default if nothing else specified
+        subcls = handler.using()
+        self.assertEqual(subcls.default_ident, orig_ident)
+
+        # accepts alt ident
+        subcls = handler.using(default_ident=alt_ident)
+        self.assertEqual(subcls.default_ident, alt_ident)
+        self.assertEqual(handler.default_ident, orig_ident)
+
+        # check subcls actually *generates* default ident,
+        # and that we didn't affect orig handler
+        self.assertEqual(effective_ident(subcls), alt_ident)
+        self.assertEqual(effective_ident(handler), orig_ident)
+
+        # rejects bad ident
+        self.assertRaises(ValueError, handler.using, default_ident='xXx')
+
+        # honor 'ident' alias
+        subcls = handler.using(ident=alt_ident)
+        self.assertEqual(subcls.default_ident, alt_ident)
+        self.assertEqual(handler.default_ident, orig_ident)
+
+        # forbid both at same time
+        self.assertRaises(TypeError, handler.using, default_ident=alt_ident, ident=alt_ident)
+
+        # check ident aliases are being honored
+        if handler.ident_aliases:
+            for alias, ident in handler.ident_aliases.items():
+                subcls = handler.using(ident=alias)
+                self.assertEqual(subcls.default_ident, ident, msg="alias %r:" % alias)
+
+    #===================================================================
+    # password size limits
+    #===================================================================
+    def test_truncate_error_setting(self):
+        """
+        validate 'truncate_error' setting & related attributes
+        """
+        # If it doesn't have truncate_size set,
+        # it shouldn't support truncate_error
+        hasher = self.handler
+        if hasher.truncate_size is None:
+            self.assertNotIn("truncate_error", hasher.setting_kwds)
+            return
+
+        # if hasher defaults to silently truncating,
+        # it MUST NOT use .truncate_verify_reject,
+        # because resulting hashes wouldn't verify!
+        if not hasher.truncate_error:
+            self.assertFalse(hasher.truncate_verify_reject)
+
+        # if hasher doesn't have configurable policy,
+        # it must throw error by default
+        if "truncate_error" not in hasher.setting_kwds:
+            self.assertTrue(hasher.truncate_error)
+            return
+
+        # test value parsing
+        def parse_value(value):
+            return hasher.using(truncate_error=value).truncate_error
+        self.assertEqual(parse_value(None), hasher.truncate_error)
+        self.assertEqual(parse_value(True), True)
+        self.assertEqual(parse_value("true"), True)
+        self.assertEqual(parse_value(False), False)
+        self.assertEqual(parse_value("false"), False)
+        self.assertRaises(ValueError, parse_value, "xxx")
+
+    def test_secret_wo_truncate_size(self):
+        """
+        test no password size limits enforced (if truncate_size=None)
+        """
+        # skip if hasher has a maximum password size
+        hasher = self.handler
+        if hasher.truncate_size is not None:
+            self.assertGreaterEqual(hasher.truncate_size, 1)
+            raise self.skipTest("truncate_size is set")
+
+        # NOTE: this doesn't do an exhaustive search to verify algorithm
+        # doesn't have some cutoff point, it just tries
+        # 1024-character string, and alters the last char.
+        # as long as algorithm doesn't clip secret at point <1024,
+        # the new secret shouldn't verify.
+
+        # hash a 1024-byte secret
+        secret = "too many secrets" * 16
+        alt = "x"
+        hash = self.do_encrypt(secret)
+
+        # check that verify doesn't silently reject secret
+        # (i.e. hasher mistakenly honors .truncate_verify_reject)
+        verify_success = not hasher.is_disabled
+        self.assertEqual(self.do_verify(secret, hash), verify_success,
+                         msg="verify rejected correct secret")
+
+        # alter last byte, should get different hash, which won't verify
+        alt_secret = secret[:-1] + alt
+        self.assertFalse(self.do_verify(alt_secret, hash),
+                         "full password not used in digest")
+
+    def test_secret_w_truncate_size(self):
+        """
+        test password size limits raise truncate_error (if appropriate)
+        """
+        #--------------------------------------------------
+        # check if test is applicable
+        #--------------------------------------------------
+        handler = self.handler
+        truncate_size = handler.truncate_size
+        if not truncate_size:
+            raise self.skipTest("truncate_size not set")
+
+        #--------------------------------------------------
+        # setup vars
+        #--------------------------------------------------
+        # try to get versions w/ and w/o truncate_error set.
+        # set to None if policy isn't configruable
+        size_error_type = exc.PasswordSizeError
+        if "truncate_error" in handler.setting_kwds:
+            without_error = handler.using(truncate_error=False)
+            with_error = handler.using(truncate_error=True)
+            size_error_type = exc.PasswordTruncateError
+        elif handler.truncate_error:
+            without_error = None
+            with_error = handler
+        else:
+            # NOTE: this mode is currently an error in test_truncate_error_setting()
+            without_error = handler
+            with_error = None
+
+        # create some test secrets
+        base = "too many secrets"
+        alt = "x"  # char that's not in base, used to mutate test secrets
+        long_secret = repeat_string(base, truncate_size+1)
+        short_secret = long_secret[:-1]
+        alt_long_secret = long_secret[:-1] + alt
+        alt_short_secret = short_secret[:-1] + alt
+
+        # init flags
+        short_verify_success = not handler.is_disabled
+        long_verify_success = short_verify_success and \
+                              not handler.truncate_verify_reject
+
+        #--------------------------------------------------
+        # do tests on <truncate_size> length secret, and resulting hash.
+        # should pass regardless of truncate_error policy.
+        #--------------------------------------------------
+        assert without_error or with_error
+        for cand_hasher in [without_error, with_error]:
+
+            # create & hash string that's exactly <truncate_size> chars.
+            short_hash = self.do_encrypt(short_secret, handler=cand_hasher)
+
+            # check hash verifies, regardless of .truncate_verify_reject
+            self.assertEqual(self.do_verify(short_secret, short_hash,
+                                           handler=cand_hasher),
+                             short_verify_success)
+
+            # changing <truncate_size-1>'th char should invalidate hash
+            # if this fails, means (reported) truncate_size is too large.
+            self.assertFalse(self.do_verify(alt_short_secret, short_hash,
+                                            handler=with_error),
+                             "truncate_size value is too large")
+
+            # verify should truncate long secret before comparing
+            # (unless truncate_verify_reject is set)
+            self.assertEqual(self.do_verify(long_secret, short_hash,
+                                            handler=cand_hasher),
+                             long_verify_success)
+
+        #--------------------------------------------------
+        # do tests on <truncate_size+1> length secret,
+        # w/ truncate error disabled (should silently truncate)
+        #--------------------------------------------------
+        if without_error:
+
+            # create & hash string that's exactly truncate_size+1 chars
+            long_hash = self.do_encrypt(long_secret, handler=without_error)
+
+            # check verifies against secret (unless truncate_verify_reject=True)
+            self.assertEqual(self.do_verify(long_secret, long_hash,
+                                            handler=without_error),
+                             short_verify_success)
+
+            # check mutating last char doesn't change outcome.
+            # if this fails, means (reported) truncate_size is too small.
+            self.assertEqual(self.do_verify(alt_long_secret, long_hash,
+                                            handler=without_error),
+                             short_verify_success)
+
+            # check short_secret verifies against this hash
+            # if this fails, means (reported) truncate_size is too large.
+            self.assertTrue(self.do_verify(short_secret, long_hash,
+                                           handler=without_error))
+
+        #--------------------------------------------------
+        # do tests on <truncate_size+1> length secret,
+        # w/ truncate error
+        #--------------------------------------------------
+        if with_error:
+
+            # with errors enabled, should forbid truncation.
+            err = self.assertRaises(size_error_type, self.do_encrypt,
+                                    long_secret, handler=with_error)
+            self.assertEqual(err.max_size, truncate_size)
+
+    #===================================================================
+    # password contents
+    #===================================================================
+    def test_61_secret_case_sensitive(self):
+        """test password case sensitivity"""
+        hash_insensitive = self.secret_case_insensitive is True
+        verify_insensitive = self.secret_case_insensitive in [True,
+                                                              "verify-only"]
+
+        # test hashing lower-case verifies against lower & upper
+        lower = 'test'
+        upper = 'TEST'
+        h1 = self.do_encrypt(lower)
+        if verify_insensitive and not self.handler.is_disabled:
+            self.assertTrue(self.do_verify(upper, h1),
+                            "verify() should not be case sensitive")
+        else:
+            self.assertFalse(self.do_verify(upper, h1),
+                             "verify() should be case sensitive")
+
+        # test hashing upper-case verifies against lower & upper
+        h2 = self.do_encrypt(upper)
+        if verify_insensitive and not self.handler.is_disabled:
+            self.assertTrue(self.do_verify(lower, h2),
+                            "verify() should not be case sensitive")
+        else:
+            self.assertFalse(self.do_verify(lower, h2),
+                             "verify() should be case sensitive")
+
+        # test genhash
+        # XXX: 2.0: what about 'verify-only' hashes once genhash() is removed?
+        #      won't have easy way to recreate w/ same config to see if hash differs.
+        #      (though only hash this applies to is mssql2000)
+        h2 = self.do_genhash(upper, h1)
+        if hash_insensitive or (self.handler.is_disabled and not self.disabled_contains_salt):
+            self.assertEqual(h2, h1,
+                             "genhash() should not be case sensitive")
+        else:
+            self.assertNotEqual(h2, h1,
+                                "genhash() should be case sensitive")
+
+    def test_62_secret_border(self):
+        """test non-string passwords are rejected"""
+        hash = self.get_sample_hash()[1]
+
+        # secret=None
+        self.assertRaises(TypeError, self.do_encrypt, None)
+        self.assertRaises(TypeError, self.do_genhash, None, hash)
+        self.assertRaises(TypeError, self.do_verify, None, hash)
+
+        # secret=int (picked as example of entirely wrong class)
+        self.assertRaises(TypeError, self.do_encrypt, 1)
+        self.assertRaises(TypeError, self.do_genhash, 1, hash)
+        self.assertRaises(TypeError, self.do_verify, 1, hash)
+
+    # xxx: move to password size limits section, above?
+    def test_63_large_secret(self):
+        """test MAX_PASSWORD_SIZE is enforced"""
+        from passlib.exc import PasswordSizeError
+        from passlib.utils import MAX_PASSWORD_SIZE
+        secret = '.' * (1+MAX_PASSWORD_SIZE)
+        hash = self.get_sample_hash()[1]
+        err = self.assertRaises(PasswordSizeError, self.do_genhash, secret, hash)
+        self.assertEqual(err.max_size, MAX_PASSWORD_SIZE)
+        self.assertRaises(PasswordSizeError, self.do_encrypt, secret)
+        self.assertRaises(PasswordSizeError, self.do_verify, secret, hash)
+
+    def test_64_forbidden_chars(self):
+        """test forbidden characters not allowed in password"""
+        chars = self.forbidden_characters
+        if not chars:
+            raise self.skipTest("none listed")
+        base = u('stub')
+        if isinstance(chars, bytes):
+            from passlib.utils.compat import iter_byte_chars
+            chars = iter_byte_chars(chars)
+            base = base.encode("ascii")
+        for c in chars:
+            self.assertRaises(ValueError, self.do_encrypt, base + c + base)
+
+    #===================================================================
+    # check identify(), verify(), genhash() against test vectors
+    #===================================================================
+    def is_secret_8bit(self, secret):
+        secret = self.populate_context(secret, {})
+        return not is_ascii_safe(secret)
+
+    def expect_os_crypt_failure(self, secret):
+        """
+        check if we're expecting potential verify failure due to crypt.crypt() encoding limitation
+        """
+        if PY3 and self.backend == "os_crypt" and isinstance(secret, bytes):
+            try:
+                secret.decode("utf-8")
+            except UnicodeDecodeError:
+                return True
+        return False
+
+    def test_70_hashes(self):
+        """test known hashes"""
+
+        # sanity check
+        self.assertTrue(self.known_correct_hashes or self.known_correct_configs,
+                        "test must set at least one of 'known_correct_hashes' "
+                        "or 'known_correct_configs'")
+
+        # run through known secret/hash pairs
+        saw8bit = False
+        for secret, hash in self.iter_known_hashes():
+            if self.is_secret_8bit(secret):
+                saw8bit = True
+
+            # hash should be positively identified by handler
+            self.assertTrue(self.do_identify(hash),
+                "identify() failed to identify hash: %r" % (hash,))
+
+            # check if what we're about to do is expected to fail due to crypt.crypt() limitation.
+            expect_os_crypt_failure = self.expect_os_crypt_failure(secret)
+            try:
+
+                # secret should verify successfully against hash
+                self.check_verify(secret, hash, "verify() of known hash failed: "
+                                  "secret=%r, hash=%r" % (secret, hash))
+
+                # genhash() should reproduce same hash
+                result = self.do_genhash(secret, hash)
+                self.assertIsInstance(result, str,
+                    "genhash() failed to return native string: %r" % (result,))
+                if self.handler.is_disabled and self.disabled_contains_salt:
+                    continue
+                self.assertEqual(result, hash,  "genhash() failed to reproduce "
+                    "known hash: secret=%r, hash=%r: result=%r" %
+                    (secret, hash, result))
+
+            except MissingBackendError:
+                if not expect_os_crypt_failure:
+                    raise
+
+        # would really like all handlers to have at least one 8-bit test vector
+        if not saw8bit:
+            warn("%s: no 8-bit secrets tested" % self.__class__)
+
+    def test_71_alternates(self):
+        """test known alternate hashes"""
+        if not self.known_alternate_hashes:
+            raise self.skipTest("no alternate hashes provided")
+        for alt, secret, hash in self.known_alternate_hashes:
+
+            # hash should be positively identified by handler
+            self.assertTrue(self.do_identify(hash),
+                "identify() failed to identify alternate hash: %r" %
+                (hash,))
+
+            # secret should verify successfully against hash
+            self.check_verify(secret, alt, "verify() of known alternate hash "
+                              "failed: secret=%r, hash=%r" % (secret, alt))
+
+            # genhash() should reproduce canonical hash
+            result = self.do_genhash(secret, alt)
+            self.assertIsInstance(result, str,
+                "genhash() failed to return native string: %r" % (result,))
+            if self.handler.is_disabled and self.disabled_contains_salt:
+                continue
+            self.assertEqual(result, hash,  "genhash() failed to normalize "
+                "known alternate hash: secret=%r, alt=%r, hash=%r: "
+                "result=%r" % (secret, alt, hash, result))
+
+    def test_72_configs(self):
+        """test known config strings"""
+        # special-case handlers without settings
+        if not self.handler.setting_kwds:
+            self.assertFalse(self.known_correct_configs,
+                            "handler should not have config strings")
+            raise self.skipTest("hash has no settings")
+
+        if not self.known_correct_configs:
+            # XXX: make this a requirement?
+            raise self.skipTest("no config strings provided")
+
+        # make sure config strings work (hashes in list tested in test_70)
+        if self.filter_config_warnings:
+            warnings.filterwarnings("ignore", category=PasslibHashWarning)
+        for config, secret, hash in self.known_correct_configs:
+
+            # config should be positively identified by handler
+            self.assertTrue(self.do_identify(config),
+                "identify() failed to identify known config string: %r" %
+                (config,))
+
+            # verify() should throw error for config strings.
+            self.assertRaises(ValueError, self.do_verify, secret, config,
+                __msg__="verify() failed to reject config string: %r" %
+                (config,))
+
+            # genhash() should reproduce hash from config.
+            result = self.do_genhash(secret, config)
+            self.assertIsInstance(result, str,
+                "genhash() failed to return native string: %r" % (result,))
+            self.assertEqual(result, hash,  "genhash() failed to reproduce "
+                "known hash from config: secret=%r, config=%r, hash=%r: "
+                "result=%r" % (secret, config, hash, result))
+
+    def test_73_unidentified(self):
+        """test known unidentifiably-mangled strings"""
+        if not self.known_unidentified_hashes:
+            raise self.skipTest("no unidentified hashes provided")
+        for hash in self.known_unidentified_hashes:
+
+            # identify() should reject these
+            self.assertFalse(self.do_identify(hash),
+                "identify() incorrectly identified known unidentifiable "
+                "hash: %r" % (hash,))
+
+            # verify() should throw error
+            self.assertRaises(ValueError, self.do_verify, 'stub', hash,
+                __msg__= "verify() failed to throw error for unidentifiable "
+                "hash: %r" % (hash,))
+
+            # genhash() should throw error
+            self.assertRaises(ValueError, self.do_genhash, 'stub', hash,
+                __msg__= "genhash() failed to throw error for unidentifiable "
+                "hash: %r" % (hash,))
+
+    def test_74_malformed(self):
+        """test known identifiable-but-malformed strings"""
+        if not self.known_malformed_hashes:
+            raise self.skipTest("no malformed hashes provided")
+        for hash in self.known_malformed_hashes:
+
+            # identify() should accept these
+            self.assertTrue(self.do_identify(hash),
+                "identify() failed to identify known malformed "
+                "hash: %r" % (hash,))
+
+            # verify() should throw error
+            self.assertRaises(ValueError, self.do_verify, 'stub', hash,
+                __msg__= "verify() failed to throw error for malformed "
+                "hash: %r" % (hash,))
+
+            # genhash() should throw error
+            self.assertRaises(ValueError, self.do_genhash, 'stub', hash,
+                __msg__= "genhash() failed to throw error for malformed "
+                "hash: %r" % (hash,))
+
+    def test_75_foreign(self):
+        """test known foreign hashes"""
+        if self.accepts_all_hashes:
+            raise self.skipTest("not applicable")
+        if not self.known_other_hashes:
+            raise self.skipTest("no foreign hashes provided")
+        for name, hash in self.known_other_hashes:
+            # NOTE: most tests use default list of foreign hashes,
+            # so they may include ones belonging to that hash...
+            # hence the 'own' logic.
+
+            if name == self.handler.name:
+                # identify should accept these
+                self.assertTrue(self.do_identify(hash),
+                    "identify() failed to identify known hash: %r" % (hash,))
+
+                # verify & genhash should NOT throw error
+                self.do_verify('stub', hash)
+                result = self.do_genhash('stub', hash)
+                self.assertIsInstance(result, str,
+                    "genhash() failed to return native string: %r" % (result,))
+
+            else:
+                # identify should reject these
+                self.assertFalse(self.do_identify(hash),
+                    "identify() incorrectly identified hash belonging to "
+                    "%s: %r" % (name, hash))
+
+                # verify should throw error
+                self.assertRaises(ValueError, self.do_verify, 'stub', hash,
+                    __msg__= "verify() failed to throw error for hash "
+                    "belonging to %s: %r" % (name, hash,))
+
+                # genhash() should throw error
+                self.assertRaises(ValueError, self.do_genhash, 'stub', hash,
+                    __msg__= "genhash() failed to throw error for hash "
+                    "belonging to %s: %r" % (name, hash))
+
+    def test_76_hash_border(self):
+        """test non-string hashes are rejected"""
+        #
+        # test hash=None is handled correctly
+        #
+        self.assertRaises(TypeError, self.do_identify, None)
+        self.assertRaises(TypeError, self.do_verify, 'stub', None)
+
+        # NOTE: changed in 1.7 -- previously 'None' would be accepted when config strings not supported.
+        self.assertRaises(TypeError, self.do_genhash, 'stub', None)
+
+        #
+        # test hash=int is rejected (picked as example of entirely wrong type)
+        #
+        self.assertRaises(TypeError, self.do_identify, 1)
+        self.assertRaises(TypeError, self.do_verify, 'stub', 1)
+        self.assertRaises(TypeError, self.do_genhash, 'stub', 1)
+
+        #
+        # test hash='' is rejected for all but the plaintext hashes
+        #
+        for hash in [u(''), b'']:
+            if self.accepts_all_hashes:
+                # then it accepts empty string as well.
+                self.assertTrue(self.do_identify(hash))
+                self.do_verify('stub', hash)
+                result = self.do_genhash('stub', hash)
+                self.check_returned_native_str(result, "genhash")
+            else:
+                # otherwise it should reject them
+                self.assertFalse(self.do_identify(hash),
+                    "identify() incorrectly identified empty hash")
+                self.assertRaises(ValueError, self.do_verify, 'stub', hash,
+                    __msg__="verify() failed to reject empty hash")
+                self.assertRaises(ValueError, self.do_genhash, 'stub', hash,
+                    __msg__="genhash() failed to reject empty hash")
+
+        #
+        # test identify doesn't throw decoding errors on 8-bit input
+        #
+        self.do_identify('\xe2\x82\xac\xc2\xa5$') # utf-8
+        self.do_identify('abc\x91\x00') # non-utf8
+
+    #===================================================================
+    # test parsehash()
+    #===================================================================
+
+    #: optional list of known parse hash results for hasher
+    known_parsehash_results = []
+
+    def require_parsehash(self):
+        if not hasattr(self.handler, "parsehash"):
+            raise SkipTest("parsehash() not implemented")
+
+    def test_70_parsehash(self):
+        """
+        parsehash()
+        """
+        # TODO: would like to enhance what this test covers
+
+        self.require_parsehash()
+        handler = self.handler
+
+        # calls should succeed, and return dict
+        hash = self.do_encrypt("stub")
+        result = handler.parsehash(hash)
+        self.assertIsInstance(result, dict)
+        # TODO: figure out what invariants we can reliably parse,
+        #       or maybe make subclasses specify that?
+
+        # w/ checksum=False, should omit that key
+        result2 = handler.parsehash(hash, checksum=False)
+        correct2 = result.copy()
+        correct2.pop("checksum", None)
+        self.assertEqual(result2, correct2)
+
+        # w/ sanitize=True
+        # correct output should mask salt / checksum;
+        # but all else should be the same
+        result3 = handler.parsehash(hash, sanitize=True)
+        correct3 = result.copy()
+        if PY2:
+            # silence warning about bytes & unicode not comparing
+            # (sanitize may convert bytes into base64 text)
+            warnings.filterwarnings("ignore", ".*unequal comparison failed to convert.*",
+                                    category=UnicodeWarning)
+        for key in ("salt", "checksum"):
+            if key in result3:
+                self.assertNotEqual(result3[key], correct3[key])
+                self.assert_is_masked(result3[key])
+                correct3[key] = result3[key]
+        self.assertEqual(result3, correct3)
+
+    def assert_is_masked(self, value):
+        """
+        check value properly masked by :func:`passlib.utils.mask_value`
+        """
+        if value is None:
+            return
+        self.assertIsInstance(value, unicode)
+        # assumes mask_value() defaults will never show more than <show> chars (4);
+        # and show nothing if size less than 1/<pct> (8).
+        ref = value if len(value) < 8 else value[4:]
+        if set(ref) == set(["*"]):
+            return True
+        raise self.fail("value not masked: %r" % value)
+
+    def test_71_parsehash_results(self):
+        """
+        parsehash() -- known outputs
+        """
+        self.require_parsehash()
+        samples = self.known_parsehash_results
+        if not samples:
+            raise self.skipTest("no samples present")
+        # XXX: expand to test w/ checksum=False and/or sanitize=True?
+        #      or read "_unsafe_settings"?
+        for hash, correct in self.known_parsehash_results:
+            result = self.handler.parsehash(hash)
+            self.assertEqual(result, correct, "hash=%r:" % hash)
+
+    #===================================================================
+    # fuzz testing
+    #===================================================================
+    def test_77_fuzz_input(self, threaded=False):
+        """fuzz testing -- random passwords and options
+
+        This test attempts to perform some basic fuzz testing of the hash,
+        based on whatever information can be found about it.
+        It does as much as it can within a fixed amount of time
+        (defaults to 1 second, but can be overridden via $PASSLIB_TEST_FUZZ_TIME).
+        It tests the following:
+
+        * randomly generated passwords including extended unicode chars
+        * randomly selected rounds values (if rounds supported)
+        * randomly selected salt sizes (if salts supported)
+        * randomly selected identifiers (if multiple found)
+        * runs output of selected backend against other available backends
+          (if any) to detect errors occurring between different backends.
+        * runs output against other "external" verifiers such as OS crypt()
+
+        :param report_thread_state:
+            if true, writes state of loop to current_thread().passlib_fuzz_state.
+            used to help debug multi-threaded fuzz test issues (below)
+        """
+        if self.handler.is_disabled:
+            raise self.skipTest("not applicable")
+
+        # gather info
+        from passlib.utils import tick
+        max_time = self.max_fuzz_time
+        if max_time <= 0:
+            raise self.skipTest("disabled by test mode")
+        verifiers = self.get_fuzz_verifiers(threaded=threaded)
+        def vname(v):
+            return (v.__doc__ or v.__name__).splitlines()[0]
+
+        # init rng -- using separate one for each thread
+        # so things are predictable for given RANDOM_TEST_SEED
+        # (relies on test_78_fuzz_threading() to give threads unique names)
+        if threaded:
+            thread_name = threading.current_thread().name
+        else:
+            thread_name = "fuzz test"
+        rng = self.getRandom(name=thread_name)
+        generator = self.FuzzHashGenerator(self, rng)
+
+        # do as many tests as possible for max_time seconds
+        log.debug("%s: %s: started; max_time=%r verifiers=%d (%s)",
+                  self.descriptionPrefix, thread_name, max_time, len(verifiers),
+                  ", ".join(vname(v) for v in verifiers))
+        start = tick()
+        stop = start + max_time
+        count = 0
+        while tick() <= stop:
+            # generate random password & options
+            opts = generator.generate()
+            secret = opts['secret']
+            other = opts['other']
+            settings = opts['settings']
+            ctx = opts['context']
+            if ctx:
+                settings['context'] = ctx
+
+            # create new hash
+            hash = self.do_encrypt(secret, **settings)
+            ##log.debug("fuzz test: hash=%r secret=%r other=%r",
+            ##          hash, secret, other)
+
+            # run through all verifiers we found.
+            for verify in verifiers:
+                name = vname(verify)
+                result = verify(secret, hash, **ctx)
+                if result == "skip": # let verifiers signal lack of support
+                    continue
+                assert result is True or result is False
+                if not result:
+                    raise self.failureException("failed to verify against %r verifier: "
+                                                "secret=%r config=%r hash=%r" %
+                                                (name, secret, settings, hash))
+                # occasionally check that some other secrets WON'T verify
+                # against this hash.
+                if rng.random() < .1:
+                    result = verify(other, hash, **ctx)
+                    if result and result != "skip":
+                        raise self.failureException("was able to verify wrong "
+                            "password using %s: wrong_secret=%r real_secret=%r "
+                            "config=%r hash=%r" % (name, other, secret, settings, hash))
+            count += 1
+
+        log.debug("%s: %s: done; elapsed=%r count=%r",
+                  self.descriptionPrefix, thread_name, tick() - start, count)
+
+    def test_78_fuzz_threading(self):
+        """multithreaded fuzz testing -- random password & options using multiple threads
+
+        run test_77 simultaneously in multiple threads
+        in an attempt to detect any concurrency issues
+        (e.g. the bug fixed by pybcrypt 0.3)
+        """
+        self.require_TEST_MODE("full")
+        import threading
+
+        # check if this test should run
+        if self.handler.is_disabled:
+            raise self.skipTest("not applicable")
+        thread_count = self.fuzz_thread_count
+        if thread_count < 1 or self.max_fuzz_time <= 0:
+            raise self.skipTest("disabled by test mode")
+
+        # buffer to hold errors thrown by threads
+        failed_lock = threading.Lock()
+        failed = [0]
+
+        # launch <thread count> threads, all of which run
+        # test_77_fuzz_input(), and see if any errors get thrown.
+        # if hash has concurrency issues, this should reveal it.
+        def wrapper():
+            try:
+                self.test_77_fuzz_input(threaded=True)
+            except SkipTest:
+                pass
+            except:
+                with failed_lock:
+                    failed[0] += 1
+                raise
+        def launch(n):
+            cls = type(self)
+            name = "Fuzz-Thread-%d ('%s:%s.%s')" % (n, cls.__module__, cls.__name__,
+                                                    self._testMethodName)
+            thread = threading.Thread(target=wrapper, name=name)
+            thread.setDaemon(True)
+            thread.start()
+            return thread
+        threads = [launch(n) for n in irange(thread_count)]
+
+        # wait until all threads exit
+        timeout = self.max_fuzz_time * thread_count * 4
+        stalled = 0
+        for thread in threads:
+            thread.join(timeout)
+            if not thread.is_alive():
+                continue
+            # XXX: not sure why this is happening, main one seems 1/4 times for sun_md5_crypt
+            log.error("%s timed out after %f seconds", thread.name, timeout)
+            stalled += 1
+
+        # if any thread threw an error, raise one ourselves.
+        if failed[0]:
+            raise self.fail("%d/%d threads failed concurrent fuzz testing "
+                      "(see error log for details)" % (failed[0], thread_count))
+        if stalled:
+            raise self.fail("%d/%d threads stalled during concurrent fuzz testing "
+                      "(see error log for details)" % (stalled, thread_count))
+
+    #---------------------------------------------------------------
+    # fuzz constants & helpers
+    #---------------------------------------------------------------
+
+    @property
+    def max_fuzz_time(self):
+        """amount of time to spend on fuzz testing"""
+        value = float(os.environ.get("PASSLIB_TEST_FUZZ_TIME") or 0)
+        if value:
+            return value
+        elif TEST_MODE(max="quick"):
+            return 0
+        elif TEST_MODE(max="default"):
+            return 1
+        else:
+            return 5
+
+    @property
+    def fuzz_thread_count(self):
+        """number of threads for threaded fuzz testing"""
+        value = int(os.environ.get("PASSLIB_TEST_FUZZ_THREADS") or 0)
+        if value:
+            return value
+        elif TEST_MODE(max="quick"):
+            return 0
+        else:
+            return 10
+
+    #---------------------------------------------------------------
+    # fuzz verifiers
+    #---------------------------------------------------------------
+
+    #: list of custom fuzz-test verifiers (in addition to hasher itself,
+    #: and backend-specific wrappers of hasher).  each element is
+    #: name of method that will return None / a verifier callable.
+    fuzz_verifiers = ("fuzz_verifier_default",)
+
+    def get_fuzz_verifiers(self, threaded=False):
+        """return list of password verifiers (including external libs)
+
+        used by fuzz testing.
+        verifiers should be callable with signature
+        ``func(password: unicode, hash: ascii str) -> ok: bool``.
+        """
+        handler = self.handler
+        verifiers = []
+
+        # call all methods starting with prefix in order to create
+        for method_name in self.fuzz_verifiers:
+            func = getattr(self, method_name)()
+            if func is not None:
+                verifiers.append(func)
+
+        # create verifiers for any other available backends
+        # NOTE: skipping this under threading test,
+        #       since backend switching isn't threadsafe (yet)
+        if hasattr(handler, "backends") and TEST_MODE("full") and not threaded:
+            def maker(backend):
+                def func(secret, hash):
+                    orig_backend = handler.get_backend()
+                    try:
+                        handler.set_backend(backend)
+                        return handler.verify(secret, hash)
+                    finally:
+                        handler.set_backend(orig_backend)
+                func.__name__ = "check_" + backend + "_backend"
+                func.__doc__ = backend + "-backend"
+                return func
+            for backend in iter_alt_backends(handler):
+                verifiers.append(maker(backend))
+
+        return verifiers
+
+    def fuzz_verifier_default(self):
+        # test against self
+        def check_default(secret, hash, **ctx):
+            return self.do_verify(secret, hash, **ctx)
+        if self.backend:
+            check_default.__doc__ = self.backend + "-backend"
+        else:
+            check_default.__doc__ = "self"
+        return check_default
+
+    #---------------------------------------------------------------
+    # fuzz settings generation
+    #---------------------------------------------------------------
+    class FuzzHashGenerator(object):
+        """
+        helper which takes care of generating random
+        passwords & configuration options to test hash with.
+        separate from test class so we can create one per thread.
+        """
+        #==========================================================
+        # class attrs
+        #==========================================================
+
+        # alphabet for randomly generated passwords
+        password_alphabet = u('qwertyASDF1234<>.@*#! \u00E1\u0259\u0411\u2113')
+
+        # encoding when testing bytes
+        password_encoding = "utf-8"
+
+        # map of setting kwd -> method name.
+        # will ignore setting if method returns None.
+        # subclasses should make copy of dict.
+        settings_map = dict(rounds="random_rounds",
+                            salt_size="random_salt_size",
+                            ident="random_ident")
+
+        # map of context kwd -> method name.
+        context_map = {}
+
+        #==========================================================
+        # init / generation
+        #==========================================================
+
+        def __init__(self, test, rng):
+            self.test = test
+            self.handler = test.handler
+            self.rng = rng
+
+        def generate(self):
+            """
+            generate random password and options for fuzz testing.
+            :returns:
+                `(secret, other_secret, settings_kwds, context_kwds)`
+            """
+            def gendict(map):
+                out = {}
+                for key, meth in map.items():
+                    value = getattr(self, meth)()
+                    if value is not None:
+                        out[key] = value
+                return out
+            secret, other = self.random_password_pair()
+            return dict(secret=secret,
+                        other=other,
+                        settings=gendict(self.settings_map),
+                        context=gendict(self.context_map),
+                        )
+
+        #==========================================================
+        # helpers
+        #==========================================================
+        def randintgauss(self, lower, upper, mu, sigma):
+            """generate random int w/ gauss distirbution"""
+            value = self.rng.normalvariate(mu, sigma)
+            return int(limit(value, lower, upper))
+
+        #==========================================================
+        # settings generation
+        #==========================================================
+
+        def random_rounds(self):
+            handler = self.handler
+            if not has_rounds_info(handler):
+                return None
+            default = handler.default_rounds or handler.min_rounds
+            lower = handler.min_rounds
+            if handler.rounds_cost == "log2":
+                upper = default
+            else:
+                upper = min(default*2, handler.max_rounds)
+            return self.randintgauss(lower, upper, default, default*.5)
+
+        def random_salt_size(self):
+            handler = self.handler
+            if not (has_salt_info(handler) and 'salt_size' in handler.setting_kwds):
+                return None
+            default = handler.default_salt_size
+            lower = handler.min_salt_size
+            upper = handler.max_salt_size or default*4
+            return self.randintgauss(lower, upper, default, default*.5)
+
+        def random_ident(self):
+            rng = self.rng
+            handler = self.handler
+            if 'ident' not in handler.setting_kwds or not hasattr(handler, "ident_values"):
+                return None
+            if rng.random() < .5:
+                return None
+            # resolve wrappers before reading values
+            handler = getattr(handler, "wrapped", handler)
+            return rng.choice(handler.ident_values)
+
+        #==========================================================
+        # fuzz password generation
+        #==========================================================
+        def random_password_pair(self):
+            """generate random password, and non-matching alternate password"""
+            secret = self.random_password()
+            while True:
+                other = self.random_password()
+                if self.accept_password_pair(secret, other):
+                    break
+            rng = self.rng
+            if rng.randint(0,1):
+                secret = secret.encode(self.password_encoding)
+            if rng.randint(0,1):
+                other = other.encode(self.password_encoding)
+            return secret, other
+
+        def random_password(self):
+            """generate random passwords for fuzz testing"""
+            # occasionally try an empty password
+            rng = self.rng
+            if rng.random() < .0001:
+                return u('')
+
+            # check if truncate size needs to be considered
+            handler = self.handler
+            truncate_size = handler.truncate_error and handler.truncate_size
+            max_size = truncate_size or 999999
+
+            # pick endpoint
+            if max_size < 50 or rng.random() < .5:
+                # chance of small password (~15 chars)
+                size = self.randintgauss(1, min(max_size, 50), 15, 15)
+            else:
+                # otherwise large password (~70 chars)
+                size = self.randintgauss(50, min(max_size, 99), 70, 20)
+
+            # generate random password
+            result = getrandstr(rng, self.password_alphabet, size)
+
+            # trim ones that encode past truncate point.
+            if truncate_size and isinstance(result, unicode):
+                while len(result.encode("utf-8")) > truncate_size:
+                    result = result[:-1]
+
+            return result
+
+        def accept_password_pair(self, secret, other):
+            """verify fuzz pair contains different passwords"""
+            return secret != other
+
+        #==========================================================
+        # eoc FuzzGenerator
+        #==========================================================
+
+    #===================================================================
+    # "disabled hasher" api
+    #===================================================================
+
+    def test_disable_and_enable(self):
+        """.disable() / .enable() methods"""
+        #
+        # setup
+        #
+        handler = self.handler
+        if not handler.is_disabled:
+            self.assertFalse(hasattr(handler, "disable"))
+            self.assertFalse(hasattr(handler, "enable"))
+            self.assertFalse(self.disabled_contains_salt)
+            raise self.skipTest("not applicable")
+
+        #
+        # disable()
+        #
+
+        # w/o existing hash
+        disabled_default = handler.disable()
+        self.assertIsInstance(disabled_default, str,
+                              msg="disable() must return native string")
+        self.assertTrue(handler.identify(disabled_default),
+                        msg="identify() didn't recognize disable() result: %r" % (disabled_default))
+
+        # w/ existing hash
+        stub = self.getRandom().choice(self.known_other_hashes)[1]
+        disabled_stub = handler.disable(stub)
+        self.assertIsInstance(disabled_stub, str,
+                              msg="disable() must return native string")
+        self.assertTrue(handler.identify(disabled_stub),
+                        msg="identify() didn't recognize disable() result: %r" % (disabled_stub))
+
+        #
+        # enable()
+        #
+
+        # w/o original hash
+        self.assertRaisesRegex(ValueError, "cannot restore original hash",
+                               handler.enable, disabled_default)
+
+        # w/ original hash
+        try:
+            result = handler.enable(disabled_stub)
+            error = None
+        except ValueError as e:
+            result = None
+            error = e
+
+        if error is None:
+            # if supports recovery, should have returned stub (e.g. unix_disabled);
+            self.assertIsInstance(result, str,
+                                  msg="enable() must return native string")
+            self.assertEqual(result, stub)
+        else:
+            # if doesn't, should have thrown appropriate error
+            self.assertIsInstance(error, ValueError)
+            self.assertRegex("cannot restore original hash", str(error))
+
+        #
+        # test repeating disable() & salting state
+        #
+
+        # repeating disabled
+        disabled_default2 = handler.disable()
+        if self.disabled_contains_salt:
+            # should return new salt for each call (e.g. django_disabled)
+            self.assertNotEqual(disabled_default2, disabled_default)
+        elif error is None:
+            # should return same result for each hash, but unique across hashes
+            self.assertEqual(disabled_default2, disabled_default)
+
+        # repeating same hash ...
+        disabled_stub2 = handler.disable(stub)
+        if self.disabled_contains_salt:
+            # ... should return different string (if salted)
+            self.assertNotEqual(disabled_stub2, disabled_stub)
+        else:
+            # ... should return same string
+            self.assertEqual(disabled_stub2, disabled_stub)
+
+        # using different hash ...
+        disabled_other = handler.disable(stub + 'xxx')
+        if self.disabled_contains_salt or error is None:
+            # ... should return different string (if salted or hash encoded)
+            self.assertNotEqual(disabled_other, disabled_stub)
+        else:
+            # ... should return same string
+            self.assertEqual(disabled_other, disabled_stub)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# HandlerCase mixins providing additional tests for certain hashes
+#=============================================================================
+class OsCryptMixin(HandlerCase):
+    """helper used by create_backend_case() which adds additional features
+    to test the os_crypt backend.
+
+    * if crypt support is missing, inserts fake crypt support to simulate
+      a working safe_crypt, to test passlib's codepath as fully as possible.
+
+    * extra tests to verify non-conformant crypt implementations are handled
+      correctly.
+
+    * check that native crypt support is detected correctly for known platforms.
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    # platforms that are known to support / not support this hash natively.
+    # list of (platform_regex, True|False|None) entries.
+    platform_crypt_support = []
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+    __unittest_skip = True
+
+    # force this backend
+    backend = "os_crypt"
+
+    # flag read by HandlerCase to detect if fake os crypt is enabled.
+    using_patched_crypt = False
+
+    #===================================================================
+    # setup
+    #===================================================================
+    def setUp(self):
+        assert self.backend == "os_crypt"
+        if not self.handler.has_backend("os_crypt"):
+            # XXX: currently, any tests that use this are skipped entirely! (see issue 120)
+            self._patch_safe_crypt()
+        super(OsCryptMixin, self).setUp()
+
+    @classmethod
+    def _get_safe_crypt_handler_backend(cls):
+        """
+        return (handler, backend) pair to use for faking crypt.crypt() support for hash.
+        backend will be None if none availabe.
+        """
+        # find handler that generates safe_crypt() compatible hash
+        handler = unwrap_handler(cls.handler)
+
+        # hack to prevent recursion issue when .has_backend() is called
+        handler.get_backend()
+
+        # find backend which isn't os_crypt
+        alt_backend = get_alt_backend(handler, "os_crypt")
+        return handler, alt_backend
+
+    @property
+    def has_os_crypt_fallback(self):
+        """
+        test if there's a fallback handler to test against if os_crypt can't support
+        a specified secret (may be explicitly set to False for some subclasses)
+        """
+        return self._get_safe_crypt_handler_backend()[0] is not None
+
+    def _patch_safe_crypt(self):
+        """if crypt() doesn't support current hash alg, this patches
+        safe_crypt() so that it transparently uses another one of the handler's
+        backends, so that we can go ahead and test as much of code path
+        as possible.
+        """
+        # find handler & backend
+        handler, alt_backend = self._get_safe_crypt_handler_backend()
+        if not alt_backend:
+            raise AssertionError("handler has no available alternate backends!")
+
+        # create subclass of handler, which we swap to an alternate backend
+        alt_handler = handler.using()
+        alt_handler.set_backend(alt_backend)
+
+        def crypt_stub(secret, hash):
+            hash = alt_handler.genhash(secret, hash)
+            assert isinstance(hash, str)
+            return hash
+
+        import passlib.utils as mod
+        self.patchAttr(mod, "_crypt", crypt_stub)
+        self.using_patched_crypt = True
+
+    @classmethod
+    def _get_skip_backend_reason(cls, backend):
+        """
+        make sure os_crypt backend is tested
+        when it's known os_crypt will be faked by _patch_safe_crypt()
+        """
+        assert backend == "os_crypt"
+        reason = super(OsCryptMixin, cls)._get_skip_backend_reason(backend)
+
+        from passlib.utils import has_crypt
+        if reason == cls._BACKEND_NOT_AVAILABLE and has_crypt:
+            if TEST_MODE("full") and cls._get_safe_crypt_handler_backend()[1]:
+                # in this case, _patch_safe_crypt() will monkeypatch os_crypt
+                # to use another backend, just so we can test os_crypt fully.
+                return None
+            else:
+                return "hash not supported by os crypt()"
+
+        return reason
+
+    #===================================================================
+    # custom tests
+    #===================================================================
+
+    # TODO: turn into decorator, and use mock library.
+    def _use_mock_crypt(self):
+        """
+        patch passlib.utils.safe_crypt() so it returns mock value for duration of test.
+        returns function whose .return_value controls what's returned.
+        this defaults to None.
+        """
+        import passlib.utils as mod
+
+        def mock_crypt(secret, config):
+            # let 'test' string through so _load_os_crypt_backend() will still work
+            if secret == "test":
+                return mock_crypt.__wrapped__(secret, config)
+            else:
+                return mock_crypt.return_value
+
+        mock_crypt.__wrapped__ = mod._crypt
+        mock_crypt.return_value = None
+
+        self.patchAttr(mod, "_crypt", mock_crypt)
+
+        return mock_crypt
+
+    def test_80_faulty_crypt(self):
+        """test with faulty crypt()"""
+        hash = self.get_sample_hash()[1]
+        exc_types = (exc.InternalBackendError,)
+        mock_crypt = self._use_mock_crypt()
+
+        def test(value):
+            # set safe_crypt() to return specified value, and
+            # make sure assertion error is raised by handler.
+            mock_crypt.return_value = value
+            self.assertRaises(exc_types, self.do_genhash, "stub", hash)
+            self.assertRaises(exc_types, self.do_encrypt, "stub")
+            self.assertRaises(exc_types, self.do_verify, "stub", hash)
+
+        test('$x' + hash[2:]) # detect wrong prefix
+        test(hash[:-1]) # detect too short
+        test(hash + 'x') # detect too long
+
+    def test_81_crypt_fallback(self):
+        """test per-call crypt() fallback"""
+
+        # mock up safe_crypt to return None
+        mock_crypt = self._use_mock_crypt()
+        mock_crypt.return_value = None
+
+        if self.has_os_crypt_fallback:
+            # handler should have a fallback to use when os_crypt backend refuses to handle secret.
+            h1 = self.do_encrypt("stub")
+            h2 = self.do_genhash("stub", h1)
+            self.assertEqual(h2, h1)
+            self.assertTrue(self.do_verify("stub", h1))
+        else:
+            # handler should give up
+            from passlib.exc import InternalBackendError as err_type
+            hash = self.get_sample_hash()[1]
+            self.assertRaises(err_type, self.do_encrypt, 'stub')
+            self.assertRaises(err_type, self.do_genhash, 'stub', hash)
+            self.assertRaises(err_type, self.do_verify, 'stub', hash)
+
+    @doesnt_require_backend
+    def test_82_crypt_support(self):
+        """
+        test platform-specific crypt() support detection
+
+        NOTE: this is mainly just a sanity check to ensure the runtime
+              detection is functioning correctly on some known platforms,
+              so that we can feel more confident it'll work right on unknown ones.
+        """
+
+        # skip wrapper handlers, won't ever have crypt support
+        if hasattr(self.handler, "orig_prefix"):
+            raise self.skipTest("not applicable to wrappers")
+
+        # look for first entry that matches current system
+        # XXX: append "/" + platform.release() to string?
+        # XXX: probably should rework to support rows being dicts w/ "minver" / "maxver" keys,
+        #      instead of hack where we add major # as part of platform regex.
+        using_backend = not self.using_patched_crypt
+        name = self.handler.name
+        platform = sys.platform
+        for pattern, expected in self.platform_crypt_support:
+            if re.match(pattern, platform):
+                break
+        else:
+            raise self.skipTest("no data for %r platform (current host support = %r)" %
+                                (platform, using_backend))
+
+        # rules can use "state=None" to signal varied support;
+        # e.g. platform='freebsd8' ... sha256_crypt not added until 8.3
+        if expected is None:
+            raise self.skipTest("varied support on %r platform (current host support = %r)" %
+                                (platform, using_backend))
+
+        # compare expectation vs reality
+        if expected == using_backend:
+            pass
+        elif expected:
+            self.fail("expected %r platform would have native support for %r" %
+                      (platform, name))
+        else:
+            self.fail("did not expect %r platform would have native support for %r" %
+                      (platform, name))
+
+    #===================================================================
+    # fuzzy verified support -- add additional verifier that uses os crypt()
+    #===================================================================
+
+    def fuzz_verifier_crypt(self):
+        """test results against OS crypt()"""
+
+        # don't use this if we're faking safe_crypt (pointless test),
+        # or if handler is a wrapper (only original handler will be supported by os)
+        handler = self.handler
+        if self.using_patched_crypt or hasattr(handler, "wrapped"):
+            return None
+
+        # create a wrapper for fuzzy verified to use
+        from crypt import crypt
+        from passlib.utils import _safe_crypt_lock
+        encoding = self.FuzzHashGenerator.password_encoding
+
+        def check_crypt(secret, hash):
+            """stdlib-crypt"""
+            if not self.crypt_supports_variant(hash):
+                return "skip"
+            # XXX: any reason not to use safe_crypt() here?  or just want to test against bare metal?
+            secret = to_native_str(secret, encoding)
+            with _safe_crypt_lock:
+                return crypt(secret, hash) == hash
+
+        return check_crypt
+
+    def crypt_supports_variant(self, hash):
+        """
+        fuzzy_verified_crypt() helper --
+        used to determine if os crypt() supports a particular hash variant.
+        """
+        return True
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class UserHandlerMixin(HandlerCase):
+    """helper for handlers w/ 'user' context kwd; mixin for HandlerCase
+
+    this overrides the HandlerCase test harness methods
+    so that a username is automatically inserted to hash/verify
+    calls. as well, passing in a pair of strings as the password
+    will be interpreted as (secret,user)
+    """
+    #===================================================================
+    # option flags
+    #===================================================================
+    default_user = "user"
+    requires_user = True
+    user_case_insensitive = False
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+    __unittest_skip = True
+
+    #===================================================================
+    # custom tests
+    #===================================================================
+    def test_80_user(self):
+        """test user context keyword"""
+        handler = self.handler
+        password = 'stub'
+        hash = handler.hash(password, user=self.default_user)
+
+        if self.requires_user:
+            self.assertRaises(TypeError, handler.hash, password)
+            self.assertRaises(TypeError, handler.genhash, password, hash)
+            self.assertRaises(TypeError, handler.verify, password, hash)
+        else:
+            # e.g. cisco_pix works with or without one.
+            handler.hash(password)
+            handler.genhash(password, hash)
+            handler.verify(password, hash)
+
+    def test_81_user_case(self):
+        """test user case sensitivity"""
+        lower = self.default_user.lower()
+        upper = lower.upper()
+        hash = self.do_encrypt('stub', context=dict(user=lower))
+        if self.user_case_insensitive:
+            self.assertTrue(self.do_verify('stub', hash, user=upper),
+                            "user should not be case sensitive")
+        else:
+            self.assertFalse(self.do_verify('stub', hash, user=upper),
+                             "user should be case sensitive")
+
+    def test_82_user_salt(self):
+        """test user used as salt"""
+        config = self.do_stub_encrypt()
+        h1 = self.do_genhash('stub', config, user='admin')
+        h2 = self.do_genhash('stub', config, user='admin')
+        self.assertEqual(h2, h1)
+        h3 = self.do_genhash('stub', config, user='root')
+        self.assertNotEqual(h3, h1)
+
+    # TODO: user size? kinda dicey, depends on algorithm.
+
+    #===================================================================
+    # override test helpers
+    #===================================================================
+    def populate_context(self, secret, kwds):
+        """insert username into kwds"""
+        if isinstance(secret, tuple):
+            secret, user = secret
+        elif not self.requires_user:
+            return secret
+        else:
+            user = self.default_user
+        if 'user' not in kwds:
+            kwds['user'] = user
+        return secret
+
+    #===================================================================
+    # modify fuzz testing
+    #===================================================================
+    class FuzzHashGenerator(HandlerCase.FuzzHashGenerator):
+
+        context_map = HandlerCase.FuzzHashGenerator.context_map.copy()
+        context_map.update(user="random_user")
+
+        user_alphabet = u("asdQWE123")
+
+        def random_user(self):
+            rng = self.rng
+            if not self.test.requires_user and rng.random() < .1:
+                return None
+            return getrandstr(rng, self.user_alphabet, rng.randint(2,10))
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class EncodingHandlerMixin(HandlerCase):
+    """helper for handlers w/ 'encoding' context kwd; mixin for HandlerCase
+
+    this overrides the HandlerCase test harness methods
+    so that an encoding can be inserted to hash/verify
+    calls by passing in a pair of strings as the password
+    will be interpreted as (secret,encoding)
+    """
+    #===================================================================
+    # instance attrs
+    #===================================================================
+    __unittest_skip = True
+
+    # restrict stock passwords & fuzz alphabet to latin-1,
+    # so different encodings can be tested safely.
+    stock_passwords = [
+        u("test"),
+        b"test",
+        u("\u00AC\u00BA"),
+    ]
+
+    class FuzzHashGenerator(HandlerCase.FuzzHashGenerator):
+
+        password_alphabet = u('qwerty1234<>.@*#! \u00AC')
+
+    def populate_context(self, secret, kwds):
+        """insert encoding into kwds"""
+        if isinstance(secret, tuple):
+            secret, encoding = secret
+            kwds.setdefault('encoding', encoding)
+        return secret
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# warnings helpers
+#=============================================================================
+class reset_warnings(warnings.catch_warnings):
+    """catch_warnings() wrapper which clears warning registry & filters"""
+
+    def __init__(self, reset_filter="always", reset_registry=".*", **kwds):
+        super(reset_warnings, self).__init__(**kwds)
+        self._reset_filter = reset_filter
+        self._reset_registry = re.compile(reset_registry) if reset_registry else None
+
+    def __enter__(self):
+        # let parent class archive filter state
+        ret = super(reset_warnings, self).__enter__()
+
+        # reset the filter to list everything
+        if self._reset_filter:
+            warnings.resetwarnings()
+            warnings.simplefilter(self._reset_filter)
+
+        # archive and clear the __warningregistry__ key for all modules
+        # that match the 'reset' pattern.
+        pattern = self._reset_registry
+        if pattern:
+            backup = self._orig_registry = {}
+            for name, mod in list(sys.modules.items()):
+                if mod is None or not pattern.match(name):
+                    continue
+                reg = getattr(mod, "__warningregistry__", None)
+                if reg:
+                    backup[name] = reg.copy()
+                    reg.clear()
+        return ret
+
+    def __exit__(self, *exc_info):
+        # restore warning registry for all modules
+        pattern = self._reset_registry
+        if pattern:
+            # restore registry backup, clearing all registry entries that we didn't archive
+            backup = self._orig_registry
+            for name, mod in list(sys.modules.items()):
+                if mod is None or not pattern.match(name):
+                    continue
+                reg = getattr(mod, "__warningregistry__", None)
+                if reg:
+                    reg.clear()
+                orig = backup.get(name)
+                if orig:
+                    if reg is None:
+                        setattr(mod, "__warningregistry__", orig)
+                    else:
+                        reg.update(orig)
+        super(reset_warnings, self).__exit__(*exc_info)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/totp.py b/myenv/lib/python3.9/site-packages/passlib/totp.py
new file mode 100644
index 0000000..9ad5000
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/totp.py
@@ -0,0 +1,1908 @@
+"""passlib.totp -- TOTP / RFC6238 / Google Authenticator utilities."""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import absolute_import, division, print_function
+from passlib.utils.compat import PY3
+# core
+import base64
+import calendar
+import json
+import logging; log = logging.getLogger(__name__)
+import math
+import struct
+import sys
+import time as _time
+import re
+if PY3:
+    from urllib.parse import urlparse, parse_qsl, quote, unquote
+else:
+    from urllib import quote, unquote
+    from urlparse import urlparse, parse_qsl
+from warnings import warn
+# site
+try:
+    # TOTP encrypted keys only supported if cryptography (https://cryptography.io) is installed
+    from cryptography.hazmat.backends import default_backend as _cg_default_backend
+    import cryptography.hazmat.primitives.ciphers.algorithms
+    import cryptography.hazmat.primitives.ciphers.modes
+    from cryptography.hazmat.primitives import ciphers as _cg_ciphers
+    del cryptography
+except ImportError:
+    log.debug("can't import 'cryptography' package, totp encryption disabled")
+    _cg_ciphers = _cg_default_backend = None
+# pkg
+from passlib import exc
+from passlib.exc import TokenError, MalformedTokenError, InvalidTokenError, UsedTokenError
+from passlib.utils import (to_unicode, to_bytes, consteq,
+                           getrandbytes, rng, SequenceMixin, xor_bytes, getrandstr)
+from passlib.utils.binary import BASE64_CHARS, b32encode, b32decode
+from passlib.utils.compat import (u, unicode, native_string_types, bascii_to_str, int_types, num_types,
+                                  irange, byte_elem_value, UnicodeIO, suppress_cause)
+from passlib.utils.decor import hybrid_method, memoized_property
+from passlib.crypto.digest import lookup_hash, compile_hmac, pbkdf2_hmac
+from passlib.hash import pbkdf2_sha256
+# local
+__all__ = [
+    # frontend classes
+    "AppWallet",
+    "TOTP",
+
+    # errors (defined in passlib.exc, but exposed here for convenience)
+    "TokenError",
+        "MalformedTokenError",
+        "InvalidTokenError",
+        "UsedTokenError",
+
+    # internal helper classes
+    "TotpToken",
+    "TotpMatch",
+]
+
+#=============================================================================
+# HACK: python < 2.7.4's urlparse() won't parse query strings unless the url scheme
+#       is one of the schemes in the urlparse.uses_query list. 2.7 abandoned
+#       this, and parses query if present, regardless of the scheme.
+#       as a workaround for older versions, we add "otpauth" to the known list.
+#       this was fixed by https://bugs.python.org/issue9374, in 2.7.4 release.
+#=============================================================================
+if sys.version_info < (2,7,4):
+    from urlparse import uses_query
+    if "otpauth" not in uses_query:
+        uses_query.append("otpauth")
+        log.debug("registered 'otpauth' scheme with urlparse.uses_query")
+    del uses_query
+
+#=============================================================================
+# internal helpers
+#=============================================================================
+
+#-----------------------------------------------------------------------------
+# token parsing / rendering helpers
+#-----------------------------------------------------------------------------
+
+#: regex used to clean whitespace from tokens & keys
+_clean_re = re.compile(u(r"\s|[-=]"), re.U)
+
+_chunk_sizes = [4,6,5]
+
+def _get_group_size(klen):
+    """
+    helper for group_string() --
+    calculates optimal size of group for given string size.
+    """
+    # look for exact divisor
+    for size in _chunk_sizes:
+        if not klen % size:
+            return size
+    # fallback to divisor with largest remainder
+    # (so chunks are as close to even as possible)
+    best = _chunk_sizes[0]
+    rem = 0
+    for size in _chunk_sizes:
+        if klen % size > rem:
+            best = size
+            rem = klen % size
+    return best
+
+def group_string(value, sep="-"):
+    """
+    reformat string into (roughly) evenly-sized groups, separated by **sep**.
+    useful for making tokens & keys easier to read by humans.
+    """
+    klen = len(value)
+    size = _get_group_size(klen)
+    return sep.join(value[o:o+size] for o in irange(0, klen, size))
+
+#-----------------------------------------------------------------------------
+# encoding helpers
+#-----------------------------------------------------------------------------
+
+def _decode_bytes(key, format):
+    """
+    internal TOTP() helper --
+    decodes key according to specified format.
+    """
+    if format == "raw":
+        if not isinstance(key, bytes):
+            raise exc.ExpectedTypeError(key, "bytes", "key")
+        return key
+    # for encoded data, key must be either unicode or ascii-encoded bytes,
+    # and must contain a hex or base32 string.
+    key = to_unicode(key, param="key")
+    key = _clean_re.sub("", key).encode("utf-8") # strip whitespace & hypens
+    if format == "hex" or format == "base16":
+        return base64.b16decode(key.upper())
+    elif format == "base32":
+        return b32decode(key)
+    # XXX: add base64 support?
+    else:
+        raise ValueError("unknown byte-encoding format: %r" % (format,))
+
+#=============================================================================
+# OTP management
+#=============================================================================
+
+#: flag for detecting if encrypted totp support is present
+AES_SUPPORT = bool(_cg_ciphers)
+
+#: regex for validating secret tags
+_tag_re = re.compile("(?i)^[a-z0-9][a-z0-9_.-]*$")
+
+class AppWallet(object):
+    """
+    This class stores application-wide secrets that can be used
+    to encrypt & decrypt TOTP keys for storage.
+    It's mostly an internal detail, applications usually just need
+    to pass ``secrets`` or ``secrets_path`` to :meth:`TOTP.using`.
+
+    .. seealso::
+
+        :ref:`totp-storing-instances` for more details on this workflow.
+
+    Arguments
+    =========
+    :param secrets:
+        Dict of application secrets to use when encrypting/decrypting
+        stored TOTP keys.  This should include a secret to use when encrypting
+        new keys, but may contain additional older secrets to decrypt
+        existing stored keys.
+
+        The dict should map tags -> secrets, so that each secret is identified
+        by a unique tag.  This tag will be stored along with the encrypted
+        key in order to determine which secret should be used for decryption.
+        Tag should be string that starts with regex range ``[a-z0-9]``,
+        and the remaining characters must be in ``[a-z0-9_.-]``.
+
+        It is recommended to use something like a incremental counter
+        ("1", "2", ...), an ISO date ("2016-01-01", "2016-05-16", ...), 
+        or a timestamp ("19803495", "19813495", ...) when assigning tags.
+
+        This mapping be provided in three formats:
+
+        * A python dict mapping tag -> secret
+        * A JSON-formatted string containing the dict
+        * A multiline string with the format ``"tag: value\\ntag: value\\n..."``
+
+        (This last format is mainly useful when loading from a text file via **secrets_path**)
+
+        .. seealso:: :func:`generate_secret` to create a secret with sufficient entropy
+
+    :param secrets_path:
+        Alternately, callers can specify a separate file where the
+        application-wide secrets are stored, using either of the string
+        formats described in **secrets**.
+
+    :param default_tag:
+        Specifies which tag in **secrets** should be used as the default
+        for encrypting new keys. If omitted, the tags will be sorted,
+        and the largest tag used as the default.
+
+        if all tags are numeric, they will be sorted numerically;
+        otherwise they will be sorted alphabetically.
+        this permits tags to be assigned numerically,
+        or e.g. using ``YYYY-MM-DD`` dates.
+
+    :param encrypt_cost:
+        Optional time-cost factor for key encryption.
+        This value corresponds to log2() of the number of PBKDF2
+        rounds used.
+
+    .. warning::
+
+        The application secret(s) should be stored in a secure location by
+        your application, and each secret should contain a large amount
+        of entropy (to prevent brute-force attacks if the encrypted keys
+        are leaked).
+
+        :func:`generate_secret` is provided as a convenience helper
+        to generate a new application secret of suitable size.
+
+        Best practice is to load these values from a file via **secrets_path**,
+        and then have your application give up permission to read this file
+        once it's running.
+
+    Public Methods
+    ==============
+    .. autoattribute:: has_secrets
+    .. autoattribute:: default_tag
+
+    Semi-Private Methods
+    ====================
+    The following methods are used internally by the :class:`TOTP`
+    class in order to encrypt & decrypt keys using the provided application
+    secrets.  They will generally not be publically useful, and may have their
+    API changed periodically.
+
+    .. automethod:: get_secret
+    .. automethod:: encrypt_key
+    .. automethod:: decrypt_key
+    """
+    #========================================================================
+    # instance attrs
+    #========================================================================
+
+    #: default salt size for encrypt_key() output
+    salt_size = 12
+
+    #: default cost (log2 of pbkdf2 rounds) for encrypt_key() output
+    #: NOTE: this is relatively low, since the majority of the security
+    #: relies on a high entropy secret to pass to AES.
+    encrypt_cost = 14
+
+    #: map of secret tag -> secret bytes
+    _secrets = None
+
+    #: tag for default secret
+    default_tag = None
+
+    #========================================================================
+    # init
+    #========================================================================
+    def __init__(self, secrets=None, default_tag=None, encrypt_cost=None,
+                 secrets_path=None):
+
+        # TODO: allow a lot more things to be customized from here,
+        #       e.g. setting default TOTP constructor options.
+
+        #
+        # init cost
+        #
+        if encrypt_cost is not None:
+            if isinstance(encrypt_cost, native_string_types):
+                encrypt_cost = int(encrypt_cost)
+            assert encrypt_cost >= 0
+            self.encrypt_cost = encrypt_cost
+
+        #
+        # init secrets map
+        #
+
+        # load secrets from file (if needed)
+        if secrets_path is not None:
+            if secrets is not None:
+                raise TypeError("'secrets' and 'secrets_path' are mutually exclusive")
+            secrets = open(secrets_path, "rt").read()
+
+        # parse & store secrets
+        secrets = self._secrets = self._parse_secrets(secrets)
+
+        #
+        # init default tag/secret
+        #
+        if secrets:
+            if default_tag is not None:
+                # verify that tag is present in map
+                self.get_secret(default_tag)
+            elif all(tag.isdigit() for tag in secrets):
+                default_tag = max(secrets, key=int)
+            else:
+                default_tag = max(secrets)
+            self.default_tag = default_tag
+
+    def _parse_secrets(self, source):
+        """
+        parse 'secrets' parameter
+
+        :returns:
+            Dict[tag:str, secret:bytes]
+        """
+        # parse string formats
+        # to make this easy to pass in configuration from a separate file,
+        # 'secrets' can be string using two formats -- json & "tag:value\n"
+        check_type = True
+        if isinstance(source, native_string_types):
+            if source.lstrip().startswith(("[", "{")):
+                # json list / dict
+                source = json.loads(source)
+            elif "\n" in source and ":" in source:
+                # multiline string containing series of "tag: value\n" rows;
+                # empty and "#\n" rows are ignored
+                def iter_pairs(source):
+                    for line in source.splitlines():
+                        line = line.strip()
+                        if line and not line.startswith("#"):
+                            tag, secret = line.split(":", 1)
+                            yield tag.strip(), secret.strip()
+                source = iter_pairs(source)
+                check_type = False
+            else:
+                raise ValueError("unrecognized secrets string format")
+
+        # ensure we have iterable of (tag, value) pairs
+        if source is None:
+            return {}
+        elif isinstance(source, dict):
+            source = source.items()
+        # XXX: could support iterable of (tag,value) pairs, but not yet needed...
+        # elif check_type and (isinstance(source, str) or not isinstance(source, Iterable)):
+        elif check_type:
+            raise TypeError("'secrets' must be mapping, or list of items")
+
+        # parse into final dict, normalizing contents
+        return dict(self._parse_secret_pair(tag, value)
+                    for tag, value in source)
+
+    def _parse_secret_pair(self, tag, value):
+        if isinstance(tag, native_string_types):
+            pass
+        elif isinstance(tag, int):
+            tag = str(tag)
+        else:
+            raise TypeError("tag must be unicode/string: %r" % (tag,))
+        if not _tag_re.match(tag):
+            raise ValueError("tag contains invalid characters: %r" % (tag,))
+        if not isinstance(value, bytes):
+            value = to_bytes(value, param="secret %r" % (tag,))
+        if not value:
+            raise ValueError("tag contains empty secret: %r" % (tag,))
+        return tag, value
+
+    #========================================================================
+    # accessing secrets
+    #========================================================================
+
+    @property
+    def has_secrets(self):
+        """whether at least one application secret is present"""
+        return self.default_tag is not None
+
+    def get_secret(self, tag):
+        """
+        resolve a secret tag to the secret (as bytes).
+        throws a KeyError if not found.
+        """
+        secrets = self._secrets
+        if not secrets:
+            raise KeyError("no application secrets configured")
+        try:
+            return secrets[tag]
+        except KeyError:
+            raise suppress_cause(KeyError("unknown secret tag: %r" % (tag,)))
+
+    #========================================================================
+    # encrypted key helpers -- used internally by TOTP
+    #========================================================================
+
+    @staticmethod
+    def _cipher_aes_key(value, secret, salt, cost, decrypt=False):
+        """
+        Internal helper for :meth:`encrypt_key` --
+        handles lowlevel encryption/decryption.
+
+        Algorithm details:
+
+        This function uses PBKDF2-HMAC-SHA256 to generate a 32-byte AES key
+        and a 16-byte IV from the application secret & random salt.
+        It then uses AES-256-CTR to encrypt/decrypt the TOTP key.
+
+        CTR mode was chosen over CBC because the main attack scenario here
+        is that the attacker has stolen the database, and is trying to decrypt a TOTP key
+        (the plaintext value here).  To make it hard for them, we want every password
+        to decrypt to a potentially valid key -- thus need to avoid any authentication
+        or padding oracle attacks.  While some random padding construction could be devised
+        to make this work for CBC mode, a stream cipher mode is just plain simpler.
+        OFB/CFB modes would also work here, but seeing as they have malleability
+        and cyclic issues (though remote and barely relevant here),
+        CTR was picked as the best overall choice.
+        """
+        # make sure backend AES support is available
+        if _cg_ciphers is None:
+            raise RuntimeError("TOTP encryption requires 'cryptography' package "
+                               "(https://cryptography.io)")
+
+        # use pbkdf2 to derive both key (32 bytes) & iv (16 bytes)
+        # NOTE: this requires 2 sha256 blocks to be calculated.
+        keyiv = pbkdf2_hmac("sha256", secret, salt=salt, rounds=(1 << cost), keylen=48)
+
+        # use AES-256-CTR to encrypt/decrypt input value
+        cipher = _cg_ciphers.Cipher(_cg_ciphers.algorithms.AES(keyiv[:32]),
+                                    _cg_ciphers.modes.CTR(keyiv[32:]),
+                                    _cg_default_backend())
+        ctx = cipher.decryptor() if decrypt else cipher.encryptor()
+        return ctx.update(value) + ctx.finalize()
+
+    def encrypt_key(self, key):
+        """
+        Helper used to encrypt TOTP keys for storage.
+
+        :param key:
+            TOTP key to encrypt, as raw bytes.
+
+        :returns:
+            dict containing encrypted TOTP key & configuration parameters.
+            this format should be treated as opaque, and potentially subject
+            to change, though it is designed to be easily serialized/deserialized
+            (e.g. via JSON).
+
+        .. note::
+
+            This function requires installation of the external
+            `cryptography <https://cryptography.io>`_ package.
+
+        To give some algorithm details:  This function uses AES-256-CTR to encrypt
+        the provided data.  It takes the application secret and randomly generated salt,
+        and uses PBKDF2-HMAC-SHA256 to combine them and generate the AES key & IV.
+        """
+        if not key:
+            raise ValueError("no key provided")
+        salt = getrandbytes(rng, self.salt_size)
+        cost = self.encrypt_cost
+        tag = self.default_tag
+        if not tag:
+            raise TypeError("no application secrets configured, can't encrypt OTP key")
+        ckey = self._cipher_aes_key(key, self.get_secret(tag), salt, cost)
+        # XXX: switch to base64?
+        return dict(v=1, c=cost, t=tag, s=b32encode(salt), k=b32encode(ckey))
+
+    def decrypt_key(self, enckey):
+        """
+        Helper used to decrypt TOTP keys from storage format.
+        Consults configured secrets to decrypt key.
+
+        :param source:
+            source object, as returned by :meth:`encrypt_key`.
+
+        :returns:
+            ``(key, needs_recrypt)`` --
+
+            **key** will be the decrypted key, as bytes.
+
+            **needs_recrypt** will be a boolean flag indicating
+            whether encryption cost or default tag is too old,
+            and henace that key needs re-encrypting before storing.
+
+        .. note::
+
+            This function requires installation of the external
+            `cryptography <https://cryptography.io>`_ package.
+        """
+        if not isinstance(enckey, dict):
+            raise TypeError("'enckey' must be dictionary")
+        version = enckey.get("v", None)
+        needs_recrypt = False
+        if version == 1:
+            _cipher_key = self._cipher_aes_key
+        else:
+            raise ValueError("missing / unrecognized 'enckey' version: %r" % (version,))
+        tag = enckey['t']
+        cost = enckey['c']
+        key = _cipher_key(
+            value=b32decode(enckey['k']),
+            secret=self.get_secret(tag),
+            salt=b32decode(enckey['s']),
+            cost=cost,
+        )
+        if cost != self.encrypt_cost or tag != self.default_tag:
+            needs_recrypt = True
+        return key, needs_recrypt
+
+    #=============================================================================
+    # eoc
+    #=============================================================================
+
+#=============================================================================
+# TOTP class
+#=============================================================================
+
+#: helper to convert HOTP counter to bytes
+_pack_uint64 = struct.Struct(">Q").pack
+
+#: helper to extract value from HOTP digest
+_unpack_uint32 = struct.Struct(">I").unpack
+
+#: dummy bytes used as temp key for .using() method
+_DUMMY_KEY = b"\x00" * 16
+
+class TOTP(object):
+    """
+    Helper for generating and verifying TOTP codes.
+
+    Given a secret key and set of configuration options, this object
+    offers methods for token generation, token validation, and serialization.
+    It can also be used to track important persistent TOTP state,
+    such as the last counter used.
+
+    This class accepts the following options
+    (only **key** and **format** may be specified as positional arguments).
+
+    :arg str key:
+        The secret key to use. By default, should be encoded as
+        a base32 string (see **format** for other encodings).
+
+        Exactly one of **key** or ``new=True`` must be specified.
+
+    :arg str format:
+        The encoding used by the **key** parameter. May be one of:
+        ``"base32"`` (base32-encoded string),
+        ``"hex"`` (hexadecimal string), or ``"raw"`` (raw bytes).
+        Defaults to ``"base32"``.
+
+    :param bool new:
+        If ``True``, a new key will be generated using :class:`random.SystemRandom`.
+
+        Exactly one ``new=True`` or **key** must be specified.
+
+    :param str label:
+        Label to associate with this token when generating a URI.
+        Displayed to user by most OTP client applications (e.g. Google Authenticator),
+        and typically has format such as ``"John Smith"`` or ``"jsmith@webservice.example.org"``.
+        Defaults to ``None``.
+        See :meth:`to_uri` for details.
+
+    :param str issuer:
+        String identifying the token issuer (e.g. the domain name of your service).
+        Used internally by some OTP client applications (e.g. Google Authenticator) to distinguish entries
+        which otherwise have the same label.
+        Optional but strongly recommended if you're rendering to a URI.
+        Defaults to ``None``.
+        See :meth:`to_uri` for details.
+
+    :param int size:
+        Number of bytes when generating new keys. Defaults to size of hash algorithm (e.g. 20 for SHA1).
+
+        .. warning::
+
+            Overriding the default values for ``digits``, ``period``, or ``alg`` may
+            cause problems with some OTP client programs (such as Google Authenticator),
+            which may have these defaults hardcoded.
+
+    :param int digits:
+        The number of digits in the generated / accepted tokens. Defaults to ``6``.
+        Must be in range [6 .. 10].
+
+        .. rst-class:: inline-title
+        .. caution::
+           Due to a limitation of the HOTP algorithm, the 10th digit can only take on values 0 .. 2,
+           and thus offers very little extra security.
+
+    :param str alg:
+        Name of hash algorithm to use. Defaults to ``"sha1"``.
+        ``"sha256"`` and ``"sha512"`` are also accepted, per :rfc:`6238`.
+
+    :param int period:
+        The time-step period to use, in integer seconds. Defaults to ``30``.
+
+    ..
+        See the passlib documentation for a full list of attributes & methods.
+    """
+    #=============================================================================
+    # class attrs
+    #=============================================================================
+
+    #: minimum number of bytes to allow in key, enforced by passlib.
+    # XXX: see if spec says anything relevant to this.
+    _min_key_size = 10
+
+    #: minimum & current serialization version (may be set independently by subclasses)
+    min_json_version = json_version = 1
+
+    #: AppWallet that this class will use for encrypting/decrypting keys.
+    #: (can be overwritten via the :meth:`TOTP.using()` constructor)
+    wallet = None
+
+    #: function to get system time in seconds, as needed by :meth:`generate` and :meth:`verify`.
+    #: defaults to :func:`time.time`, but can be overridden on a per-instance basis.
+    now = _time.time
+
+    #=============================================================================
+    # instance attrs
+    #=============================================================================
+
+    #---------------------------------------------------------------------------
+    # configuration attrs
+    #---------------------------------------------------------------------------
+
+    #: [private] secret key as raw :class:`!bytes`
+    #: see .key property for public access.
+    _key = None
+
+    #: [private] cached copy of encrypted secret,
+    #: so .to_json() doesn't have to re-encrypt on each call.
+    _encrypted_key = None
+
+    #: [private] cached copy of keyed HMAC function,
+    #: so ._generate() doesn't have to rebuild this each time
+    #: ._find_match() invokes it.
+    _keyed_hmac = None
+
+    #: number of digits in the generated tokens.
+    digits = 6
+
+    #: name of hash algorithm in use (e.g. ``"sha1"``)
+    alg = "sha1"
+
+    #: default label for :meth:`to_uri`
+    label = None
+
+    #: default issuer for :meth:`to_uri`
+    issuer = None
+
+    #: number of seconds per counter step.
+    #: *(TOTP uses an internal time-derived counter which
+    #: increments by 1 every* :attr:`!period` *seconds)*.
+    period = 30
+
+    #---------------------------------------------------------------------------
+    # state attrs
+    #---------------------------------------------------------------------------
+
+    #: Flag set by deserialization methods to indicate the object needs to be re-serialized.
+    #: This can be for a number of reasons -- encoded using deprecated format,
+    #: or encrypted using a deprecated key or too few rounds.
+    changed = False
+
+    #=============================================================================
+    # prototype construction
+    #=============================================================================
+    @classmethod
+    def using(cls, digits=None, alg=None, period=None,
+              issuer=None, wallet=None, now=None, **kwds):
+        """
+        Dynamically create subtype of :class:`!TOTP` class
+        which has the specified defaults set.
+
+        :parameters: **digits, alg, period, issuer**:
+
+            All these options are the same as in the :class:`TOTP` constructor,
+            and the resulting class will use any values you specify here
+            as the default for all TOTP instances it creates.
+
+        :param wallet:
+            Optional :class:`AppWallet` that will be used for encrypting/decrypting keys.
+
+        :param secrets, secrets_path, encrypt_cost:
+
+            If specified, these options will be passed to the :class:`AppWallet` constructor,
+            allowing you to directly specify the secret keys that should be used
+            to encrypt & decrypt stored keys.
+
+        :returns:
+            subclass of :class:`!TOTP`.
+
+        This method is useful for creating a TOTP class configured
+        to use your application's secrets for encrypting & decrypting
+        keys, as well as create new keys using it's desired configuration defaults.
+
+        As an example::
+
+            >>> # your application can create a custom class when it initializes
+            >>> from passlib.totp import TOTP, generate_secret
+            >>> TotpFactory = TOTP.using(secrets={"1": generate_secret()})
+
+            >>> # subsequent TOTP objects created from this factory
+            >>> # will use the specified secrets to encrypt their keys...
+            >>> totp = TotpFactory.new()
+            >>> totp.to_dict()
+            {'enckey': {'c': 14,
+              'k': 'H77SYXWORDPGVOQTFRR2HFUB3C45XXI7',
+              's': 'G5DOQPIHIBUM2OOHHADQ',
+              't': '1',
+              'v': 1},
+             'type': 'totp',
+             'v': 1}
+
+        .. seealso:: :ref:`totp-creation` and :ref:`totp-storing-instances` tutorials for a usage example
+        """
+        # XXX: could add support for setting default match 'window' and 'reuse' policy
+
+        # :param now:
+        #     Optional callable that should return current time for generator to use.
+        #     Default to :func:`time.time`. This optional is generally not needed,
+        #     and is mainly present for examples & unit-testing.
+
+        subcls = type("TOTP", (cls,), {})
+
+        def norm_param(attr, value):
+            """
+            helper which uses constructor to validate parameter value.
+            it returns corresponding attribute, so we use normalized value.
+            """
+            # NOTE: this creates *subclass* instance,
+            #       so normalization takes into account any custom params
+            #       already stored.
+            kwds = dict(key=_DUMMY_KEY, format="raw")
+            kwds[attr] = value
+            obj = subcls(**kwds)
+            return getattr(obj, attr)
+
+        if digits is not None:
+            subcls.digits = norm_param("digits", digits)
+
+        if alg is not None:
+            subcls.alg = norm_param("alg", alg)
+
+        if period is not None:
+            subcls.period = norm_param("period", period)
+
+        # XXX: add default size as configurable parameter?
+
+        if issuer is not None:
+            subcls.issuer = norm_param("issuer", issuer)
+
+        if kwds:
+            subcls.wallet = AppWallet(**kwds)
+            if wallet:
+                raise TypeError("'wallet' and 'secrets' keywords are mutually exclusive")
+        elif wallet is not None:
+            if not isinstance(wallet, AppWallet):
+                raise exc.ExpectedTypeError(wallet, AppWallet, "wallet")
+            subcls.wallet = wallet
+
+        if now is not None:
+            assert isinstance(now(), num_types) and now() >= 0, \
+                "now() function must return non-negative int/float"
+            subcls.now = staticmethod(now)
+
+        return subcls
+
+    #=============================================================================
+    # init
+    #=============================================================================
+
+    @classmethod
+    def new(cls, **kwds):
+        """
+        convenience alias for creating new TOTP key, same as ``TOTP(new=True)``
+        """
+        return cls(new=True, **kwds)
+
+    def __init__(self, key=None, format="base32",
+                 # keyword only...
+                 new=False, digits=None, alg=None, size=None, period=None,
+                 label=None, issuer=None, changed=False,
+                 **kwds):
+        super(TOTP, self).__init__(**kwds)
+        if changed:
+            self.changed = changed
+
+        # validate & normalize alg
+        info = lookup_hash(alg or self.alg)
+        self.alg = info.name
+        digest_size = info.digest_size
+        if digest_size < 4:
+            raise RuntimeError("%r hash digest too small" % alg)
+
+        # parse or generate new key
+        if new:
+            # generate new key
+            if key:
+                raise TypeError("'key' and 'new=True' are mutually exclusive")
+            if size is None:
+                # default to digest size, per RFC 6238 Section 5.1
+                size = digest_size
+            elif size > digest_size:
+                # not forbidden by spec, but would just be wasted bytes.
+                # maybe just warn about this?
+                raise ValueError("'size' should be less than digest size "
+                                 "(%d)" % digest_size)
+            self.key = getrandbytes(rng, size)
+        elif not key:
+            raise TypeError("must specify either an existing 'key', or 'new=True'")
+        elif format == "encrypted":
+            # NOTE: this handles decrypting & setting '.key'
+            self.encrypted_key = key
+        elif key:
+            # use existing key, encoded using specified <format>
+            self.key = _decode_bytes(key, format)
+
+        # enforce min key size
+        if len(self.key) < self._min_key_size:
+            # only making this fatal for new=True,
+            # so that existing (but ridiculously small) keys can still be used.
+            msg = "for security purposes, secret key must be >= %d bytes" % self._min_key_size
+            if new:
+                raise ValueError(msg)
+            else:
+                warn(msg, exc.PasslibSecurityWarning, stacklevel=1)
+
+        # validate digits
+        if digits is None:
+            digits = self.digits
+        if not isinstance(digits, int_types):
+            raise TypeError("digits must be an integer, not a %r" % type(digits))
+        if digits < 6 or digits > 10:
+            raise ValueError("digits must in range(6,11)")
+        self.digits = digits
+
+        # validate label
+        if label:
+            self._check_label(label)
+            self.label = label
+
+        # validate issuer
+        if issuer:
+            self._check_issuer(issuer)
+            self.issuer = issuer
+
+        # init period
+        if period is not None:
+            self._check_serial(period, "period", minval=1)
+            self.period = period
+
+    #=============================================================================
+    # helpers to verify value types & ranges
+    #=============================================================================
+
+    @staticmethod
+    def _check_serial(value, param, minval=0):
+        """
+        check that serial value (e.g. 'counter') is non-negative integer
+        """
+        if not isinstance(value, int_types):
+            raise exc.ExpectedTypeError(value, "int", param)
+        if value < minval:
+            raise ValueError("%s must be >= %d" % (param, minval))
+
+    @staticmethod
+    def _check_label(label):
+        """
+        check that label doesn't contain chars forbidden by KeyURI spec
+        """
+        if label and ":" in label:
+            raise ValueError("label may not contain ':'")
+
+    @staticmethod
+    def _check_issuer(issuer):
+        """
+        check that issuer doesn't contain chars forbidden by KeyURI spec
+        """
+        if issuer and ":" in issuer:
+            raise ValueError("issuer may not contain ':'")
+
+    #=============================================================================
+    # key attributes
+    #=============================================================================
+
+    #------------------------------------------------------------------
+    # raw key
+    #------------------------------------------------------------------
+    @property
+    def key(self):
+        """
+        secret key as raw bytes
+        """
+        return self._key
+
+    @key.setter
+    def key(self, value):
+        # set key
+        if not isinstance(value, bytes):
+            raise exc.ExpectedTypeError(value, bytes, "key")
+        self._key = value
+
+        # clear cached properties derived from key
+        self._encrypted_key = self._keyed_hmac = None
+
+    #------------------------------------------------------------------
+    # encrypted key
+    #------------------------------------------------------------------
+    @property
+    def encrypted_key(self):
+        """
+        secret key, encrypted using application secret.
+        this match the output of :meth:`AppWallet.encrypt_key`,
+        and should be treated as an opaque json serializable object.
+        """
+        enckey = self._encrypted_key
+        if enckey is None:
+            wallet = self.wallet
+            if not wallet:
+                raise TypeError("no application secrets present, can't encrypt TOTP key")
+            enckey = self._encrypted_key = wallet.encrypt_key(self.key)
+        return enckey
+
+    @encrypted_key.setter
+    def encrypted_key(self, value):
+        wallet = self.wallet
+        if not wallet:
+            raise TypeError("no application secrets present, can't decrypt TOTP key")
+        self.key, needs_recrypt = wallet.decrypt_key(value)
+        if needs_recrypt:
+            # mark as changed so it gets re-encrypted & written to db
+            self.changed = True
+        else:
+            # cache encrypted key for re-use
+            self._encrypted_key = value
+
+    #------------------------------------------------------------------
+    # pretty-printed / encoded key helpers
+    #------------------------------------------------------------------
+
+    @property
+    def hex_key(self):
+        """
+        secret key encoded as hexadecimal string
+        """
+        return bascii_to_str(base64.b16encode(self.key)).lower()
+
+    @property
+    def base32_key(self):
+        """
+        secret key encoded as base32 string
+        """
+        return b32encode(self.key)
+
+    def pretty_key(self, format="base32", sep="-"):
+        """
+        pretty-print the secret key.
+
+        This is mainly useful for situations where the user cannot get the qrcode to work,
+        and must enter the key manually into their TOTP client. It tries to format
+        the key in a manner that is easier for humans to read.
+
+        :param format:
+            format to output secret key. ``"hex"`` and ``"base32"`` are both accepted.
+
+        :param sep:
+            separator to insert to break up key visually.
+            can be any of ``"-"`` (the default), ``" "``, or ``False`` (no separator).
+
+        :return:
+            key as native string.
+
+        Usage example::
+
+            >>> t = TOTP('s3jdvb7qd2r7jpxx')
+            >>> t.pretty_key()
+            'S3JD-VB7Q-D2R7-JPXX'
+        """
+        if format == "hex" or format == "base16":
+            key = self.hex_key
+        elif format == "base32":
+            key = self.base32_key
+        else:
+            raise ValueError("unknown byte-encoding format: %r" % (format,))
+        if sep:
+            key = group_string(key, sep)
+        return key
+
+    #=============================================================================
+    # time & token parsing
+    #=============================================================================
+
+    @classmethod
+    def normalize_time(cls, time):
+        """
+        Normalize time value to unix epoch seconds.
+
+        :arg time:
+            Can be ``None``, :class:`!datetime`,
+            or unix epoch timestamp as :class:`!float` or :class:`!int`.
+            If ``None``, uses current system time.
+            Naive datetimes are treated as UTC.
+
+        :returns:
+            unix epoch timestamp as :class:`int`.
+        """
+        if isinstance(time, int_types):
+            return time
+        elif isinstance(time, float):
+            return int(time)
+        elif time is None:
+            return int(cls.now())
+        elif hasattr(time, "utctimetuple"):
+            # coerce datetime to UTC timestamp
+            # NOTE: utctimetuple() assumes naive datetimes are in UTC
+            # NOTE: we explicitly *don't* want microseconds.
+            return calendar.timegm(time.utctimetuple())
+        else:
+            raise exc.ExpectedTypeError(time, "int, float, or datetime", "time")
+
+    def _time_to_counter(self, time):
+        """
+        convert timestamp to HOTP counter using :attr:`period`.
+        """
+        return time // self.period
+
+    def _counter_to_time(self, counter):
+        """
+        convert HOTP counter to timestamp using :attr:`period`.
+        """
+        return counter * self.period
+
+    @hybrid_method
+    def normalize_token(self_or_cls, token):
+        """
+        Normalize OTP token representation:
+        strips whitespace, converts integers to a zero-padded string,
+        validates token content & number of digits.
+
+        This is a hybrid method -- it can be called at the class level,
+        as ``TOTP.normalize_token()``, or the instance level as ``TOTP().normalize_token()``.
+        It will normalize to the instance-specific number of :attr:`~TOTP.digits`,
+        or use the class default.
+
+        :arg token:
+            token as ascii bytes, unicode, or an integer.
+
+        :raises ValueError:
+            if token has wrong number of digits, or contains non-numeric characters.
+
+        :returns:
+            token as :class:`!unicode` string, containing only digits 0-9.
+        """
+        digits = self_or_cls.digits
+        if isinstance(token, int_types):
+            token = u("%0*d") % (digits, token)
+        else:
+            token = to_unicode(token, param="token")
+            token = _clean_re.sub(u(""), token)
+            if not token.isdigit():
+                raise MalformedTokenError("Token must contain only the digits 0-9")
+        if len(token) != digits:
+            raise MalformedTokenError("Token must have exactly %d digits" % digits)
+        return token
+
+    #=============================================================================
+    # token generation
+    #=============================================================================
+
+# # debug helper
+#    def generate_range(self, size, time=None):
+#        counter = self._time_to_counter(time) - (size + 1) // 2
+#        end = counter + size
+#        while counter <= end:
+#            token = self._generate(counter)
+#            yield TotpToken(self, token, counter)
+#            counter += 1
+
+    def generate(self, time=None):
+        """
+        Generate token for specified time
+        (uses current time if none specified).
+
+        :arg time:
+            Can be ``None``, a :class:`!datetime`,
+            or class:`!float` / :class:`!int` unix epoch timestamp.
+            If ``None`` (the default), uses current system time.
+            Naive datetimes are treated as UTC.
+
+        :returns:
+
+            A :class:`TotpToken` instance, which can be treated
+            as a sequence of ``(token, expire_time)`` -- see that class
+            for more details.
+
+        Usage example::
+
+            >>> # generate a new token, wrapped in a TotpToken instance...
+            >>> otp = TOTP('s3jdvb7qd2r7jpxx')
+            >>> otp.generate(1419622739)
+            <TotpToken token='897212' expire_time=1419622740>
+
+            >>> # when you just need the token...
+            >>> otp.generate(1419622739).token
+            '897212'
+        """
+        time = self.normalize_time(time)
+        counter = self._time_to_counter(time)
+        if counter < 0:
+            raise ValueError("timestamp must be >= 0")
+        token = self._generate(counter)
+        return TotpToken(self, token, counter)
+
+    def _generate(self, counter):
+        """
+        base implementation of HOTP token generation algorithm.
+
+        :arg counter: HOTP counter, as non-negative integer
+        :returns: token as unicode string
+        """
+        # generate digest
+        assert isinstance(counter, int_types), "counter must be integer"
+        assert counter >= 0, "counter must be non-negative"
+        keyed_hmac = self._keyed_hmac
+        if keyed_hmac is None:
+            keyed_hmac = self._keyed_hmac = compile_hmac(self.alg, self.key)
+        digest = keyed_hmac(_pack_uint64(counter))
+        digest_size = keyed_hmac.digest_info.digest_size
+        assert len(digest) == digest_size, "digest_size: sanity check failed"
+
+        # derive 31-bit token value
+        assert digest_size >= 20, "digest_size: sanity check 2 failed" # otherwise 0xF+4 will run off end of hash.
+        offset = byte_elem_value(digest[-1]) & 0xF
+        value = _unpack_uint32(digest[offset:offset+4])[0] & 0x7fffffff
+
+        # render to decimal string, return last <digits> chars
+        # NOTE: the 10'th digit is not as secure, as it can only take on values 0-2, not 0-9,
+        #       due to 31-bit mask on int ">I". But some servers / clients use it :|
+        #       if 31-bit mask removed (which breaks spec), would only get values 0-4.
+        digits = self.digits
+        assert 0 < digits < 11, "digits: sanity check failed"
+        return (u("%0*d") % (digits, value))[-digits:]
+
+    #=============================================================================
+    # token verification
+    #=============================================================================
+
+    @classmethod
+    def verify(cls, token, source, **kwds):
+        r"""
+        Convenience wrapper around :meth:`TOTP.from_source` and :meth:`TOTP.match`.
+
+        This parses a TOTP key & configuration from the specified source,
+        and tries and match the token.
+        It's designed to parallel the :meth:`passlib.ifc.PasswordHash.verify` method.
+
+        :param token:
+            Token string to match.
+
+        :param source:
+            Serialized TOTP key.
+            Can be anything accepted by :meth:`TOTP.from_source`.
+
+        :param \\*\\*kwds:
+            All additional keywords passed to :meth:`TOTP.match`.
+
+        :return:
+            A :class:`TotpMatch` instance, or raises a :exc:`TokenError`.
+        """
+        return cls.from_source(source).match(token, **kwds)
+
+    def match(self, token, time=None, window=30, skew=0, last_counter=None):
+        """
+        Match TOTP token against specified timestamp.
+        Searches within a window before & after the provided time,
+        in order to account for transmission delay and small amounts of skew in the client's clock.
+
+        :arg token:
+            Token to validate.
+            may be integer or string (whitespace and hyphens are ignored).
+
+        :param time:
+            Unix epoch timestamp, can be any of :class:`!float`, :class:`!int`, or :class:`!datetime`.
+            if ``None`` (the default), uses current system time.
+            *this should correspond to the time the token was received from the client*.
+
+        :param int window:
+            How far backward and forward in time to search for a match.
+            Measured in seconds. Defaults to ``30``.  Typically only useful if set
+            to multiples of :attr:`period`.
+
+        :param int skew:
+            Adjust timestamp by specified value, to account for excessive
+            client clock skew. Measured in seconds. Defaults to ``0``.
+
+            Negative skew (the common case) indicates transmission delay,
+            and/or that the client clock is running behind the server.
+
+            Positive skew indicates the client clock is running ahead of the server
+            (and by enough that it cancels out any negative skew added by
+            the transmission delay).
+
+            You should ensure the server clock uses a reliable time source such as NTP,
+            so that only the client clock's inaccuracy needs to be accounted for.
+
+            This is an advanced parameter that should usually be left at ``0``;
+            The **window** parameter is usually enough to account
+            for any observed transmission delay.
+
+        :param last_counter:
+            Optional value of last counter value that was successfully used.
+            If specified, verify will never search earlier counters,
+            no matter how large the window is.
+
+            Useful when client has previously authenticated,
+            and thus should never provide a token older than previously
+            verified value.
+
+        :raises ~passlib.exc.TokenError:
+
+            If the token is malformed, fails to match, or has already been used.
+
+        :returns TotpMatch:
+
+            Returns a :class:`TotpMatch` instance on successful match.
+            Can be treated as tuple of ``(counter, time)``.
+            Raises error if token is malformed / can't be verified.
+
+        Usage example::
+
+            >>> totp = TOTP('s3jdvb7qd2r7jpxx')
+
+            >>> # valid token for this time period
+            >>> totp.match('897212', 1419622729)
+            <TotpMatch counter=47320757 time=1419622729 cache_seconds=60>
+
+            >>> # token from counter step 30 sec ago (within allowed window)
+            >>> totp.match('000492', 1419622729)
+            <TotpMatch counter=47320756 time=1419622729 cache_seconds=60>
+
+            >>> # invalid token -- token from 60 sec ago (outside of window)
+            >>> totp.match('760389', 1419622729)
+            Traceback:
+                ...
+            InvalidTokenError: Token did not match
+        """
+        time = self.normalize_time(time)
+        self._check_serial(window, "window")
+
+        client_time = time + skew
+        if last_counter is None:
+            last_counter = -1
+        start = max(last_counter, self._time_to_counter(client_time - window))
+        end = self._time_to_counter(client_time + window) + 1
+        # XXX: could pass 'expected = _time_to_counter(client_time + TRANSMISSION_DELAY)'
+        #      to the _find_match() method, would help if window set to very large value.
+
+        counter = self._find_match(token, start, end)
+        assert counter >= last_counter, "sanity check failed: counter went backward"
+
+        if counter == last_counter:
+            raise UsedTokenError(expire_time=(last_counter + 1) * self.period)
+
+        # NOTE: By returning match tied to <time>, not <client_time>, we're
+        #       causing .skipped to reflect the observed skew, independent of
+        #       the 'skew' param.  This is deliberately done so that caller
+        #       can use historical .skipped values to estimate future skew.
+        return TotpMatch(self, counter, time, window)
+
+    def _find_match(self, token, start, end, expected=None):
+        """
+        helper for verify() --
+        returns counter value within specified range that matches token.
+
+        :arg token:
+            token value to match (will be normalized internally)
+
+        :arg start:
+            starting counter value to check
+
+        :arg end:
+            check up to (but not including) this counter value
+
+        :arg expected:
+            optional expected value where search should start,
+            to help speed up searches.
+
+        :raises ~passlib.exc.TokenError:
+            If the token is malformed, or fails to verify.
+
+        :returns:
+            counter value that matched
+        """
+        token = self.normalize_token(token)
+        if start < 0:
+            start = 0
+        if end <= start:
+            raise InvalidTokenError()
+        generate = self._generate
+        if not (expected is None or expected < start) and consteq(token, generate(expected)):
+            return expected
+        # XXX: if (end - start) is very large (e.g. for resync purposes),
+        #      could start with expected value, and work outward from there,
+        #      alternately checking before & after it until match is found.
+        # XXX: can't use irange(start, end) here since py2x/win32
+        #      throws error on values >= (1<<31), which 'end' can be.
+        counter = start
+        while counter < end:
+            if consteq(token, generate(counter)):
+                return counter
+            counter += 1
+        raise InvalidTokenError()
+
+    #-------------------------------------------------------------------------
+    # TODO: resync(self, tokens, time=None, min_tokens=10, window=100)
+    #       helper to re-synchronize using series of sequential tokens,
+    #       all of which must validate; per RFC recommendation.
+    # NOTE: need to make sure this function is constant time
+    #       (i.e. scans ALL tokens, and doesn't short-circuit after first mismatch)
+    #-------------------------------------------------------------------------
+
+    #=============================================================================
+    # generic parsing
+    #=============================================================================
+
+    @classmethod
+    def from_source(cls, source):
+        """
+        Load / create a TOTP object from a serialized source.
+        This acts as a wrapper for the various deserialization methods:
+
+        * TOTP URIs are handed off to :meth:`from_uri`
+        * Any other strings are handed off to :meth:`from_json`
+        * Dicts are handed off to :meth:`from_dict`
+
+        :param source:
+            Serialized TOTP object.
+
+        :raises ValueError:
+            If the key has been encrypted, but the application secret isn't available;
+            or if the string cannot be recognized, parsed, or decoded.
+
+            See :meth:`TOTP.using()` for how to configure application secrets.
+
+        :returns:
+            a :class:`TOTP` instance.
+        """
+        if isinstance(source, TOTP):
+            # return object unchanged if they share same wallet.
+            # otherwise make a new one that's bound to expected wallet.
+            if cls.wallet == source.wallet:
+                return source
+            source = source.to_dict(encrypt=False)
+        if isinstance(source, dict):
+            return cls.from_dict(source)
+        # NOTE: letting to_unicode() raise TypeError in this case
+        source = to_unicode(source, param="totp source")
+        if source.startswith("otpauth://"):
+            return cls.from_uri(source)
+        else:
+            return cls.from_json(source)
+
+    #=============================================================================
+    # uri parsing
+    #=============================================================================
+    @classmethod
+    def from_uri(cls, uri):
+        """
+        create an OTP instance from a URI (such as returned by :meth:`to_uri`).
+
+        :returns:
+            :class:`TOTP` instance.
+
+        :raises ValueError:
+            if the uri cannot be parsed or contains errors.
+
+        .. seealso:: :ref:`totp-configuring-clients` tutorial for a usage example
+        """
+        # check for valid uri
+        uri = to_unicode(uri, param="uri").strip()
+        result = urlparse(uri)
+        if result.scheme != "otpauth":
+            raise cls._uri_parse_error("wrong uri scheme")
+
+        # validate netloc, and hand off to helper
+        cls._check_otp_type(result.netloc)
+        return cls._from_parsed_uri(result)
+
+    @classmethod
+    def _check_otp_type(cls, type):
+        """
+        validate otp URI type is supported.
+        returns True or raises appropriate error.
+        """
+        if type == "totp":
+            return True
+        if type == "hotp":
+            raise NotImplementedError("HOTP not supported")
+        raise ValueError("unknown otp type: %r" % type)
+
+    @classmethod
+    def _from_parsed_uri(cls, result):
+        """
+        internal from_uri() helper --
+        handles parsing a validated TOTP URI
+
+        :param result:
+            a urlparse() instance
+
+        :returns:
+            cls instance
+        """
+
+        # decode label from uri path
+        label = result.path
+        if label.startswith("/") and len(label) > 1:
+            label = unquote(label[1:])
+        else:
+            raise cls._uri_parse_error("missing label")
+
+        # extract old-style issuer prefix
+        if ":" in label:
+            try:
+                issuer, label = label.split(":")
+            except ValueError:  # too many ":"
+                raise cls._uri_parse_error("malformed label")
+        else:
+            issuer = None
+        if label:
+            # NOTE: KeyURI spec says there may be leading spaces
+            label = label.strip() or None
+
+        # parse query params
+        params = dict(label=label)
+        for k, v in parse_qsl(result.query):
+            if k in params:
+                raise cls._uri_parse_error("duplicate parameter (%r)" % k)
+            params[k] = v
+
+        # synchronize issuer prefix w/ issuer param
+        if issuer:
+            if "issuer" not in params:
+                params['issuer'] = issuer
+            elif params['issuer'] != issuer:
+                raise cls._uri_parse_error("conflicting issuer identifiers")
+
+        # convert query params to constructor kwds, and call constructor
+        return cls(**cls._adapt_uri_params(**params))
+
+    @classmethod
+    def _adapt_uri_params(cls, label=None, secret=None, issuer=None,
+                          digits=None, algorithm=None, period=None,
+                          **extra):
+        """
+        from_uri() helper --
+        converts uri params into constructor args.
+        """
+        assert label, "from_uri() failed to provide label"
+        if not secret:
+            raise cls._uri_parse_error("missing 'secret' parameter")
+        kwds = dict(label=label, issuer=issuer, key=secret, format="base32")
+        if digits:
+            kwds['digits'] = cls._uri_parse_int(digits, "digits")
+        if algorithm:
+            kwds['alg'] = algorithm
+        if period:
+            kwds['period'] = cls._uri_parse_int(period, "period")
+        if extra:
+            # malicious uri, deviation from spec, or newer revision of spec?
+            # in either case, we issue warning and ignore extra params.
+            warn("%s: unexpected parameters encountered in otp uri: %r" %
+                 (cls, extra), exc.PasslibRuntimeWarning)
+        return kwds
+
+    @staticmethod
+    def _uri_parse_error(reason):
+        """uri parsing helper -- creates preformatted error message"""
+        return ValueError("Invalid otpauth uri: %s" % (reason,))
+
+    @classmethod
+    def _uri_parse_int(cls, source, param):
+        """uri parsing helper -- int() wrapper"""
+        try:
+            return int(source)
+        except ValueError:
+            raise cls._uri_parse_error("Malformed %r parameter" % param)
+
+    #=============================================================================
+    # uri rendering
+    #=============================================================================
+    def to_uri(self, label=None, issuer=None):
+        """
+        Serialize key and configuration into a URI, per
+        Google Auth's `KeyUriFormat <http://code.google.com/p/google-authenticator/wiki/KeyUriFormat>`_.
+
+        :param str label:
+            Label to associate with this token when generating a URI.
+            Displayed to user by most OTP client applications (e.g. Google Authenticator),
+            and typically has format such as ``"John Smith"`` or ``"jsmith@webservice.example.org"``.
+
+            Defaults to **label** constructor argument. Must be provided in one or the other location.
+            May not contain ``:``.
+
+        :param str issuer:
+            String identifying the token issuer (e.g. the domain or canonical name of your service).
+            Optional but strongly recommended if you're rendering to a URI.
+            Used internally by some OTP client applications (e.g. Google Authenticator) to distinguish entries
+            which otherwise have the same label.
+
+            Defaults to **issuer** constructor argument, or ``None``.
+            May not contain ``:``.
+
+        :raises ValueError:
+            * if a label was not provided either as an argument, or in the constructor.
+            * if the label or issuer contains invalid characters.
+
+        :returns:
+            all the configuration information for this OTP token generator,
+            encoded into a URI.
+
+        These URIs are frequently converted to a QRCode for transferring
+        to a TOTP client application such as Google Auth.
+        Usage example::
+
+            >>> from passlib.totp import TOTP
+            >>> tp = TOTP('s3jdvb7qd2r7jpxx')
+            >>> uri = tp.to_uri("user@example.org", "myservice.another-example.org")
+            >>> uri
+            'otpauth://totp/user@example.org?secret=S3JDVB7QD2R7JPXX&issuer=myservice.another-example.org'
+
+        .. versionchanged:: 1.7.2
+
+            This method now prepends the issuer URI label.  This is recommended by the KeyURI
+            specification, for compatibility with older clients.
+        """
+        # encode label
+        if label is None:
+            label = self.label
+        if not label:
+            raise ValueError("a label must be specified as argument, or in the constructor")
+        self._check_label(label)
+        # NOTE: reference examples in spec seem to indicate the '@' in a label
+        #       shouldn't be escaped, though spec doesn't explicitly address this.
+        # XXX: is '/' ok to leave unencoded?
+        label = quote(label, '@')
+
+        # encode query parameters
+        params = self._to_uri_params()
+        if issuer is None:
+            issuer = self.issuer
+        if issuer:
+            self._check_issuer(issuer)
+            # NOTE: per KeyURI spec, including issuer as part of label is deprecated,
+            #       in favor of adding it to query params.  however, some QRCode clients
+            #       don't recognize the 'issuer' query parameter, so spec recommends (as of 2018-7)
+            #       to include both.
+            label = "%s:%s" % (quote(issuer, '@'), label)
+            params.append(("issuer", issuer))
+        # NOTE: not using urllib.urlencode() because it encodes ' ' as '+';
+        #       but spec says to use '%20', and not sure how fragile
+        #       the various totp clients' parsers are.
+        param_str = u("&").join(u("%s=%s") % (key, quote(value, '')) for key, value in params)
+        assert param_str, "param_str should never be empty"
+
+        # render uri
+        return u("otpauth://totp/%s?%s") % (label, param_str)
+
+    def _to_uri_params(self):
+        """return list of (key, param) entries for URI"""
+        args = [("secret", self.base32_key)]
+        if self.alg != "sha1":
+            args.append(("algorithm", self.alg.upper()))
+        if self.digits != 6:
+            args.append(("digits", str(self.digits)))
+        if self.period != 30:
+            args.append(("period", str(self.period)))
+        return args
+
+    #=============================================================================
+    # json rendering / parsing
+    #=============================================================================
+
+    @classmethod
+    def from_json(cls, source):
+        """
+        Load / create an OTP object from a serialized json string
+        (as generated by :meth:`to_json`).
+
+        :arg json:
+            Serialized output from :meth:`to_json`, as unicode or ascii bytes.
+
+        :raises ValueError:
+            If the key has been encrypted, but the application secret isn't available;
+            or if the string cannot be recognized, parsed, or decoded.
+
+            See :meth:`TOTP.using()` for how to configure application secrets.
+
+        :returns:
+            a :class:`TOTP` instance.
+
+        .. seealso:: :ref:`totp-storing-instances` tutorial for a usage example
+        """
+        source = to_unicode(source, param="json source")
+        return cls.from_dict(json.loads(source))
+
+    def to_json(self, encrypt=None):
+        """
+        Serialize configuration & internal state to a json string,
+        mainly useful for persisting client-specific state in a database.
+        All keywords passed to :meth:`to_dict`.
+
+        :returns:
+            json string containing serializes configuration & state.
+        """
+        state = self.to_dict(encrypt=encrypt)
+        return json.dumps(state, sort_keys=True, separators=(",", ":"))
+
+    #=============================================================================
+    # dict rendering / parsing
+    #=============================================================================
+
+    @classmethod
+    def from_dict(cls, source):
+        """
+        Load / create a TOTP object from a dictionary
+        (as generated by :meth:`to_dict`)
+
+        :param source:
+            dict containing serialized TOTP key & configuration.
+
+        :raises ValueError:
+            If the key has been encrypted, but the application secret isn't available;
+            or if the dict cannot be recognized, parsed, or decoded.
+
+            See :meth:`TOTP.using()` for how to configure application secrets.
+
+        :returns:
+            A :class:`TOTP` instance.
+
+        .. seealso:: :ref:`totp-storing-instances` tutorial for a usage example
+        """
+        if not isinstance(source, dict) or "type" not in source:
+            raise cls._dict_parse_error("unrecognized format")
+        return cls(**cls._adapt_dict_kwds(**source))
+
+    @classmethod
+    def _adapt_dict_kwds(cls, type, **kwds):
+        """
+        Internal helper for .from_json() --
+        Adapts serialized json dict into constructor keywords.
+        """
+        # default json format is just serialization of constructor kwds.
+        # XXX: just pass all this through to _from_json / constructor?
+        # go ahead and mark as changed (needs re-saving) if the version is too old
+        assert cls._check_otp_type(type)
+        ver = kwds.pop("v", None)
+        if not ver or ver < cls.min_json_version or ver > cls.json_version:
+            raise cls._dict_parse_error("missing/unsupported version (%r)" % (ver,))
+        elif ver != cls.json_version:
+            # mark older version as needing re-serializing
+            kwds['changed'] = True
+        if 'enckey' in kwds:
+            # handing encrypted key off to constructor, which handles the
+            # decryption. this lets it get ahold of (and store) the original
+            # encrypted key, so if to_json() is called again, the encrypted
+            # key can be re-used.
+            # XXX: wallet is known at this point, could decrypt key here.
+            assert 'key' not in kwds  # shouldn't be present w/ enckey
+            kwds.update(key=kwds.pop("enckey"), format="encrypted")
+        elif 'key' not in kwds:
+            raise cls._dict_parse_error("missing 'enckey' / 'key'")
+        # XXX: could should set changed=True if active wallet is available,
+        #      and source wasn't encrypted.
+        kwds.pop("last_counter", None) # extract legacy counter parameter
+        return kwds
+
+    @staticmethod
+    def _dict_parse_error(reason):
+        """dict parsing helper -- creates preformatted error message"""
+        return ValueError("Invalid totp data: %s" % (reason,))
+
+    def to_dict(self, encrypt=None):
+        """
+        Serialize configuration & internal state to a dict,
+        mainly useful for persisting client-specific state in a database.
+
+        :param encrypt:
+            Whether to output should be encrypted.
+
+            * ``None`` (the default) -- uses encrypted key if application
+              secrets are available, otherwise uses plaintext key.
+            * ``True`` -- uses encrypted key, or raises TypeError
+              if application secret wasn't provided to OTP constructor.
+            * ``False`` -- uses raw key.
+
+        :returns:
+            dictionary, containing basic (json serializable) datatypes.
+        """
+        # NOTE: 'type' may seem redundant, but using it so code can try to
+        #       detect that this *is* a TOTP json string / dict.
+        state = dict(v=self.json_version, type="totp")
+        if self.alg != "sha1":
+            state['alg'] = self.alg
+        if self.digits != 6:
+            state['digits'] = self.digits
+        if self.period != 30:
+            state['period'] = self.period
+        # XXX: should we include label as part of json format?
+        if self.label:
+            state['label'] = self.label
+        issuer = self.issuer
+        if issuer and issuer != type(self).issuer:
+            # (omit issuer if it matches class default)
+            state['issuer'] = issuer
+        if encrypt is None:
+            wallet = self.wallet
+            encrypt = wallet and wallet.has_secrets
+        if encrypt:
+            state['enckey'] = self.encrypted_key
+        else:
+            state['key'] = self.base32_key
+        # NOTE: in the future, may add a "history" parameter
+        #       containing a list of (time, skipped) pairs, encoding
+        #       the last X successful verifications, to allow persisting
+        #       & estimating client clock skew over time.
+        return state
+
+    #=============================================================================
+    # eoc
+    #=============================================================================
+
+#=============================================================================
+# TOTP helpers
+#=============================================================================
+class TotpToken(SequenceMixin):
+    """
+    Object returned by :meth:`TOTP.generate`.
+    It can be treated as a sequence of ``(token, expire_time)``,
+    or accessed via the following attributes:
+
+    .. autoattribute:: token
+    .. autoattribute:: expire_time
+    .. autoattribute:: counter
+    .. autoattribute:: remaining
+    .. autoattribute:: valid
+    """
+    #: TOTP object that generated this token
+    totp = None
+
+    #: Token as decimal-encoded ascii string.
+    token = None
+
+    #: HOTP counter value used to generate token (derived from time)
+    counter = None
+
+    def __init__(self, totp, token, counter):
+        """
+        .. warning::
+            the constructor signature is an internal detail, and is subject to change.
+        """
+        self.totp = totp
+        self.token = token
+        self.counter = counter
+
+    @memoized_property
+    def start_time(self):
+        """Timestamp marking beginning of period when token is valid"""
+        return self.totp._counter_to_time(self.counter)
+
+    @memoized_property
+    def expire_time(self):
+        """Timestamp marking end of period when token is valid"""
+        return self.totp._counter_to_time(self.counter + 1)
+
+    @property
+    def remaining(self):
+        """number of (float) seconds before token expires"""
+        return max(0, self.expire_time - self.totp.now())
+
+    @property
+    def valid(self):
+        """whether token is still valid"""
+        return bool(self.remaining)
+
+    def _as_tuple(self):
+        return self.token, self.expire_time
+
+    def __repr__(self):
+        expired = "" if self.remaining else " expired"
+        return "<TotpToken token='%s' expire_time=%d%s>" % \
+               (self.token, self.expire_time, expired)
+
+
+class TotpMatch(SequenceMixin):
+    """
+    Object returned by :meth:`TOTP.match` and :meth:`TOTP.verify` on a successful match.
+
+    It can be treated as a sequence of ``(counter, time)``,
+    or accessed via the following attributes:
+
+    .. autoattribute:: counter
+        :annotation: = 0
+
+    .. autoattribute:: time
+        :annotation: = 0
+
+    .. autoattribute:: expected_counter
+        :annotation: = 0
+
+    .. autoattribute:: skipped
+        :annotation: = 0
+
+    .. autoattribute:: expire_time
+        :annotation: = 0
+
+    .. autoattribute:: cache_seconds
+        :annotation: = 60
+
+    .. autoattribute:: cache_time
+        :annotation: = 0
+
+    This object will always have a ``True`` boolean value.
+    """
+
+    #: TOTP object that generated this token
+    totp = None
+
+    #: TOTP counter value which matched token.
+    #: (Best practice is to subsequently ignore tokens matching this counter
+    #: or earlier)
+    counter = 0
+
+    #: Timestamp when verification was performed.
+    time = 0
+
+    #: Search window used by verify() (affects cache_time)
+    window = 30
+
+    def __init__(self, totp, counter, time, window=30):
+        """
+        .. warning::
+            the constructor signature is an internal detail, and is subject to change.
+        """
+        self.totp = totp
+        self.counter = counter
+        self.time = time
+        self.window = window
+
+    @memoized_property
+    def expected_counter(self):
+        """
+        Counter value expected for timestamp.
+        """
+        return self.totp._time_to_counter(self.time)
+
+    @memoized_property
+    def skipped(self):
+        """
+        How many steps were skipped between expected and actual matched counter
+        value (may be positive, zero, or negative).
+        """
+        return self.counter - self.expected_counter
+
+    # @memoized_property
+    # def start_time(self):
+    #     """Timestamp marking start of period when token is valid"""
+    #     return self.totp._counter_to_time(self.counter + 1)
+
+    @memoized_property
+    def expire_time(self):
+        """Timestamp marking end of period when token is valid"""
+        return self.totp._counter_to_time(self.counter + 1)
+
+    @memoized_property
+    def cache_seconds(self):
+        """
+        Number of seconds counter should be cached
+        before it's guaranteed to have passed outside of verification window.
+        """
+        # XXX: real value is 'cache_time - now()',
+        #      but this is a cheaper upper bound.
+        return self.totp.period + self.window
+
+    @memoized_property
+    def cache_time(self):
+        """
+        Timestamp marking when counter has passed outside of verification window.
+        """
+        return self.expire_time + self.window
+
+    def _as_tuple(self):
+        return self.counter, self.time
+
+    def __repr__(self):
+        args = (self.counter, self.time, self.cache_seconds)
+        return "<TotpMatch counter=%d time=%d cache_seconds=%d>" % args
+
+#=============================================================================
+# convenience helpers
+#=============================================================================
+
+def generate_secret(entropy=256, charset=BASE64_CHARS[:-2]):
+    """
+    generate a random string suitable for use as an
+    :class:`AppWallet` application secret.
+
+    :param entropy:
+        number of bits of entropy (controls size/complexity of password).
+    """
+    assert entropy > 0
+    assert len(charset) > 1
+    count = int(math.ceil(entropy * math.log(2, len(charset))))
+    return getrandstr(rng, charset, count)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/utils/__init__.py b/myenv/lib/python3.9/site-packages/passlib/utils/__init__.py
new file mode 100644
index 0000000..6147886
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/utils/__init__.py
@@ -0,0 +1,1220 @@
+"""passlib.utils -- helpers for writing password hashes"""
+#=============================================================================
+# imports
+#=============================================================================
+from passlib.utils.compat import JYTHON
+# core
+from binascii import b2a_base64, a2b_base64, Error as _BinAsciiError
+from base64 import b64encode, b64decode
+try:
+    from collections.abc import Sequence
+    from collections.abc import Iterable
+except ImportError:
+    # py2 compat
+    from collections import Sequence
+    from collections import Iterable
+from codecs import lookup as _lookup_codec
+from functools import update_wrapper
+import itertools
+import inspect
+import logging; log = logging.getLogger(__name__)
+import math
+import os
+import sys
+import random
+import re
+if JYTHON: # pragma: no cover -- runtime detection
+    # Jython 2.5.2 lacks stringprep module -
+    # see http://bugs.jython.org/issue1758320
+    try:
+        import stringprep
+    except ImportError:
+        stringprep = None
+        _stringprep_missing_reason = "not present under Jython"
+else:
+    import stringprep
+import time
+if stringprep:
+    import unicodedata
+try:
+    import threading
+except ImportError:
+    # module optional before py37
+    threading = None
+import timeit
+import types
+from warnings import warn
+# site
+# pkg
+from passlib.utils.binary import (
+    # [remove these aliases in 2.0]
+    BASE64_CHARS, AB64_CHARS, HASH64_CHARS, BCRYPT_CHARS,
+    Base64Engine, LazyBase64Engine, h64, h64big, bcrypt64,
+    ab64_encode, ab64_decode, b64s_encode, b64s_decode
+)
+from passlib.utils.decor import (
+    # [remove these aliases in 2.0]
+    deprecated_function,
+    deprecated_method,
+    memoized_property,
+    classproperty,
+    hybrid_method,
+)
+from passlib.exc import ExpectedStringError, ExpectedTypeError
+from passlib.utils.compat import (add_doc, join_bytes, join_byte_values,
+                                  join_byte_elems, irange, imap, PY3, u,
+                                  join_unicode, unicode, byte_elem_value, nextgetter,
+                                  unicode_or_str, unicode_or_bytes_types,
+                                  get_method_function, suppress_cause, PYPY)
+# local
+__all__ = [
+    # constants
+    'JYTHON',
+    'sys_bits',
+    'unix_crypt_schemes',
+    'rounds_cost_values',
+
+    # unicode helpers
+    'consteq',
+    'saslprep',
+
+    # bytes helpers
+    "xor_bytes",
+    "render_bytes",
+
+    # encoding helpers
+    'is_same_codec',
+    'is_ascii_safe',
+    'to_bytes',
+    'to_unicode',
+    'to_native_str',
+
+    # host OS
+    'has_crypt',
+    'test_crypt',
+    'safe_crypt',
+    'tick',
+
+    # randomness
+    'rng',
+    'getrandbytes',
+    'getrandstr',
+    'generate_password',
+
+    # object type / interface tests
+    'is_crypt_handler',
+    'is_crypt_context',
+    'has_rounds_info',
+    'has_salt_info',
+]
+
+#=============================================================================
+# constants
+#=============================================================================
+
+# bitsize of system architecture (32 or 64)
+sys_bits = int(math.log(sys.maxsize if PY3 else sys.maxint, 2) + 1.5)
+
+# list of hashes algs supported by crypt() on at least one OS.
+# XXX: move to .registry for passlib 2.0?
+unix_crypt_schemes = [
+    "sha512_crypt", "sha256_crypt",
+    "sha1_crypt", "bcrypt",
+    "md5_crypt",
+    # "bsd_nthash",
+    "bsdi_crypt", "des_crypt",
+    ]
+
+# list of rounds_cost constants
+rounds_cost_values = [ "linear", "log2" ]
+
+# legacy import, will be removed in 1.8
+from passlib.exc import MissingBackendError
+
+# internal helpers
+_BEMPTY = b''
+_UEMPTY = u("")
+_USPACE = u(" ")
+
+# maximum password size which passlib will allow; see exc.PasswordSizeError
+MAX_PASSWORD_SIZE = int(os.environ.get("PASSLIB_MAX_PASSWORD_SIZE") or 4096)
+
+#=============================================================================
+# type helpers
+#=============================================================================
+
+class SequenceMixin(object):
+    """
+    helper which lets result object act like a fixed-length sequence.
+    subclass just needs to provide :meth:`_as_tuple()`.
+    """
+    def _as_tuple(self):
+        raise NotImplementedError("implement in subclass")
+
+    def __repr__(self):
+        return repr(self._as_tuple())
+
+    def __getitem__(self, idx):
+        return self._as_tuple()[idx]
+
+    def __iter__(self):
+        return iter(self._as_tuple())
+
+    def __len__(self):
+        return len(self._as_tuple())
+
+    def __eq__(self, other):
+        return self._as_tuple() == other
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+if PY3:
+    # getargspec() is deprecated, use this under py3.
+    # even though it's a lot more awkward to get basic info :|
+
+    _VAR_KEYWORD = inspect.Parameter.VAR_KEYWORD
+    _VAR_ANY_SET = set([_VAR_KEYWORD, inspect.Parameter.VAR_POSITIONAL])
+
+    def accepts_keyword(func, key):
+        """test if function accepts specified keyword"""
+        params = inspect.signature(get_method_function(func)).parameters
+        if not params:
+            return False
+        arg = params.get(key)
+        if arg and arg.kind not in _VAR_ANY_SET:
+            return True
+        # XXX: annoying what we have to do to determine if VAR_KWDS in use.
+        return params[list(params)[-1]].kind == _VAR_KEYWORD
+
+else:
+
+    def accepts_keyword(func, key):
+        """test if function accepts specified keyword"""
+        spec = inspect.getargspec(get_method_function(func))
+        return key in spec.args or spec.keywords is not None
+
+def update_mixin_classes(target, add=None, remove=None, append=False,
+                         before=None, after=None, dryrun=False):
+    """
+    helper to update mixin classes installed in target class.
+
+    :param target:
+        target class whose bases will be modified.
+
+    :param add:
+        class / classes to install into target's base class list.
+
+    :param remove:
+        class / classes to remove from target's base class list.
+
+    :param append:
+        by default, prepends mixins to front of list.
+        if True, appends to end of list instead.
+
+    :param after:
+        optionally make sure all mixins are inserted after
+        this class / classes.
+
+    :param before:
+        optionally make sure all mixins are inserted before
+        this class / classes.
+
+    :param dryrun:
+        optionally perform all calculations / raise errors,
+        but don't actually modify the class.
+    """
+    if isinstance(add, type):
+        add = [add]
+
+    bases = list(target.__bases__)
+
+    # strip out requested mixins
+    if remove:
+        if isinstance(remove, type):
+            remove = [remove]
+        for mixin in remove:
+            if add and mixin in add:
+                continue
+            if mixin in bases:
+                bases.remove(mixin)
+
+    # add requested mixins
+    if add:
+        for mixin in add:
+            # if mixin already present (explicitly or not), leave alone
+            if any(issubclass(base, mixin) for base in bases):
+                continue
+
+            # determine insertion point
+            if append:
+                for idx, base in enumerate(bases):
+                    if issubclass(mixin, base):
+                        # don't insert mixin after one of it's own bases
+                        break
+                    if before and issubclass(base, before):
+                        # don't insert mixin after any <before> classes.
+                        break
+                else:
+                    # append to end
+                    idx = len(bases)
+            elif after:
+                for end_idx, base in enumerate(reversed(bases)):
+                    if issubclass(base, after):
+                        # don't insert mixin before any <after> classes.
+                        idx = len(bases) - end_idx
+                        assert bases[idx-1] == base
+                        break
+                else:
+                    idx = 0
+            else:
+                # insert at start
+                idx = 0
+
+            # insert mixin
+            bases.insert(idx, mixin)
+
+    # modify class
+    if not dryrun:
+        target.__bases__ = tuple(bases)
+
+#=============================================================================
+# collection helpers
+#=============================================================================
+def batch(source, size):
+    """
+    split iterable into chunks of <size> elements.
+    """
+    if size < 1:
+        raise ValueError("size must be positive integer")
+    if isinstance(source, Sequence):
+        end = len(source)
+        i = 0
+        while i < end:
+            n = i + size
+            yield source[i:n]
+            i = n
+    elif isinstance(source, Iterable):
+        itr = iter(source)
+        while True:
+            chunk_itr = itertools.islice(itr, size)
+            try:
+                first = next(chunk_itr)
+            except StopIteration:
+                break
+            yield itertools.chain((first,), chunk_itr)
+    else:
+        raise TypeError("source must be iterable")
+
+#=============================================================================
+# unicode helpers
+#=============================================================================
+
+# XXX: should this be moved to passlib.crypto, or compat backports?
+
+def consteq(left, right):
+    """Check two strings/bytes for equality.
+
+    This function uses an approach designed to prevent
+    timing analysis, making it appropriate for cryptography.
+    a and b must both be of the same type: either str (ASCII only),
+    or any type that supports the buffer protocol (e.g. bytes).
+
+    Note: If a and b are of different lengths, or if an error occurs,
+    a timing attack could theoretically reveal information about the
+    types and lengths of a and b--but not their values.
+    """
+    # NOTE:
+    # resources & discussions considered in the design of this function:
+    #   hmac timing attack --
+    #       http://rdist.root.org/2009/05/28/timing-attack-in-google-keyczar-library/
+    #   python developer discussion surrounding similar function --
+    #       http://bugs.python.org/issue15061
+    #       http://bugs.python.org/issue14955
+
+    # validate types
+    if isinstance(left, unicode):
+        if not isinstance(right, unicode):
+            raise TypeError("inputs must be both unicode or both bytes")
+        is_py3_bytes = False
+    elif isinstance(left, bytes):
+        if not isinstance(right, bytes):
+            raise TypeError("inputs must be both unicode or both bytes")
+        is_py3_bytes = PY3
+    else:
+        raise TypeError("inputs must be both unicode or both bytes")
+
+    # do size comparison.
+    # NOTE: the double-if construction below is done deliberately, to ensure
+    # the same number of operations (including branches) is performed regardless
+    # of whether left & right are the same size.
+    same_size = (len(left) == len(right))
+    if same_size:
+        # if sizes are the same, setup loop to perform actual check of contents.
+        tmp = left
+        result = 0
+    if not same_size:
+        # if sizes aren't the same, set 'result' so equality will fail regardless
+        # of contents. then, to ensure we do exactly 'len(right)' iterations
+        # of the loop, just compare 'right' against itself.
+        tmp = right
+        result = 1
+
+    # run constant-time string comparision
+    # TODO: use izip instead (but first verify it's faster than zip for this case)
+    if is_py3_bytes:
+        for l,r in zip(tmp, right):
+            result |= l ^ r
+    else:
+        for l,r in zip(tmp, right):
+            result |= ord(l) ^ ord(r)
+    return result == 0
+
+# keep copy of this around since stdlib's version throws error on non-ascii chars in unicode strings.
+# our version does, but suffers from some underlying VM issues.  but something is better than
+# nothing for plaintext hashes, which need this.  everything else should use consteq(),
+# since the stdlib one is going to be as good / better in the general case.
+str_consteq = consteq
+
+try:
+    # for py3.3 and up, use the stdlib version
+    from hmac import compare_digest as consteq
+except ImportError:
+    pass
+
+    # TODO: could check for cryptography package's version,
+    #       but only operates on bytes, so would need a wrapper,
+    #       or separate consteq() into a unicode & a bytes variant.
+    # from cryptography.hazmat.primitives.constant_time import bytes_eq as consteq
+
+def splitcomma(source, sep=","):
+    """split comma-separated string into list of elements,
+    stripping whitespace.
+    """
+    source = source.strip()
+    if source.endswith(sep):
+        source = source[:-1]
+    if not source:
+        return []
+    return [ elem.strip() for elem in source.split(sep) ]
+
+def saslprep(source, param="value"):
+    """Normalizes unicode strings using SASLPrep stringprep profile.
+
+    The SASLPrep profile is defined in :rfc:`4013`.
+    It provides a uniform scheme for normalizing unicode usernames
+    and passwords before performing byte-value sensitive operations
+    such as hashing. Among other things, it normalizes diacritic
+    representations, removes non-printing characters, and forbids
+    invalid characters such as ``\\n``. Properly internationalized
+    applications should run user passwords through this function
+    before hashing.
+
+    :arg source:
+        unicode string to normalize & validate
+
+    :param param:
+        Optional noun identifying source parameter in error messages
+        (Defaults to the string ``"value"``). This is mainly useful to make the caller's error
+        messages make more sense contextually.
+
+    :raises ValueError:
+        if any characters forbidden by the SASLPrep profile are encountered.
+
+    :raises TypeError:
+        if input is not :class:`!unicode`
+
+    :returns:
+        normalized unicode string
+
+    .. note::
+
+        This function is not available under Jython,
+        as the Jython stdlib is missing the :mod:`!stringprep` module
+        (`Jython issue 1758320 <http://bugs.jython.org/issue1758320>`_).
+
+    .. versionadded:: 1.6
+    """
+    # saslprep - http://tools.ietf.org/html/rfc4013
+    # stringprep - http://tools.ietf.org/html/rfc3454
+    #              http://docs.python.org/library/stringprep.html
+
+    # validate type
+    # XXX: support bytes (e.g. run through want_unicode)?
+    #      might be easier to just integrate this into cryptcontext.
+    if not isinstance(source, unicode):
+        raise TypeError("input must be unicode string, not %s" %
+                        (type(source),))
+
+    # mapping stage
+    #   - map non-ascii spaces to U+0020 (stringprep C.1.2)
+    #   - strip 'commonly mapped to nothing' chars (stringprep B.1)
+    in_table_c12 = stringprep.in_table_c12
+    in_table_b1 = stringprep.in_table_b1
+    data = join_unicode(
+        _USPACE if in_table_c12(c) else c
+        for c in source
+        if not in_table_b1(c)
+        )
+
+    # normalize to KC form
+    data = unicodedata.normalize('NFKC', data)
+    if not data:
+        return _UEMPTY
+
+    # check for invalid bi-directional strings.
+    # stringprep requires the following:
+    #   - chars in C.8 must be prohibited.
+    #   - if any R/AL chars in string:
+    #       - no L chars allowed in string
+    #       - first and last must be R/AL chars
+    # this checks if start/end are R/AL chars. if so, prohibited loop
+    # will forbid all L chars. if not, prohibited loop will forbid all
+    # R/AL chars instead. in both cases, prohibited loop takes care of C.8.
+    is_ral_char = stringprep.in_table_d1
+    if is_ral_char(data[0]):
+        if not is_ral_char(data[-1]):
+            raise ValueError("malformed bidi sequence in " + param)
+        # forbid L chars within R/AL sequence.
+        is_forbidden_bidi_char = stringprep.in_table_d2
+    else:
+        # forbid R/AL chars if start not setup correctly; L chars allowed.
+        is_forbidden_bidi_char = is_ral_char
+
+    # check for prohibited output - stringprep tables A.1, B.1, C.1.2, C.2 - C.9
+    in_table_a1 = stringprep.in_table_a1
+    in_table_c21_c22 = stringprep.in_table_c21_c22
+    in_table_c3 = stringprep.in_table_c3
+    in_table_c4 = stringprep.in_table_c4
+    in_table_c5 = stringprep.in_table_c5
+    in_table_c6 = stringprep.in_table_c6
+    in_table_c7 = stringprep.in_table_c7
+    in_table_c8 = stringprep.in_table_c8
+    in_table_c9 = stringprep.in_table_c9
+    for c in data:
+        # check for chars mapping stage should have removed
+        assert not in_table_b1(c), "failed to strip B.1 in mapping stage"
+        assert not in_table_c12(c), "failed to replace C.1.2 in mapping stage"
+
+        # check for forbidden chars
+        if in_table_a1(c):
+            raise ValueError("unassigned code points forbidden in " + param)
+        if in_table_c21_c22(c):
+            raise ValueError("control characters forbidden in " + param)
+        if in_table_c3(c):
+            raise ValueError("private use characters forbidden in " + param)
+        if in_table_c4(c):
+            raise ValueError("non-char code points forbidden in " + param)
+        if in_table_c5(c):
+            raise ValueError("surrogate codes forbidden in " + param)
+        if in_table_c6(c):
+            raise ValueError("non-plaintext chars forbidden in " + param)
+        if in_table_c7(c):
+            # XXX: should these have been caught by normalize?
+            # if so, should change this to an assert
+            raise ValueError("non-canonical chars forbidden in " + param)
+        if in_table_c8(c):
+            raise ValueError("display-modifying / deprecated chars "
+                             "forbidden in" + param)
+        if in_table_c9(c):
+            raise ValueError("tagged characters forbidden in " + param)
+
+        # do bidi constraint check chosen by bidi init, above
+        if is_forbidden_bidi_char(c):
+            raise ValueError("forbidden bidi character in " + param)
+
+    return data
+
+# replace saslprep() with stub when stringprep is missing
+if stringprep is None: # pragma: no cover -- runtime detection
+    def saslprep(source, param="value"):
+        """stub for saslprep()"""
+        raise NotImplementedError("saslprep() support requires the 'stringprep' "
+                            "module, which is " + _stringprep_missing_reason)
+
+#=============================================================================
+# bytes helpers
+#=============================================================================
+def render_bytes(source, *args):
+    """Peform ``%`` formating using bytes in a uniform manner across Python 2/3.
+
+    This function is motivated by the fact that
+    :class:`bytes` instances do not support ``%`` or ``{}`` formatting under Python 3.
+    This function is an attempt to provide a replacement:
+    it converts everything to unicode (decoding bytes instances as ``latin-1``),
+    performs the required formatting, then encodes the result to ``latin-1``.
+
+    Calling ``render_bytes(source, *args)`` should function roughly the same as
+    ``source % args`` under Python 2.
+
+    .. todo::
+        python >= 3.5 added back limited support for bytes %,
+        can revisit when 3.3/3.4 is dropped.
+    """
+    if isinstance(source, bytes):
+        source = source.decode("latin-1")
+    result = source % tuple(arg.decode("latin-1") if isinstance(arg, bytes)
+                            else arg for arg in args)
+    return result.encode("latin-1")
+
+if PY3:
+    # new in py32
+    def bytes_to_int(value):
+        return int.from_bytes(value, 'big')
+    def int_to_bytes(value, count):
+        return value.to_bytes(count, 'big')
+else:
+    # XXX: can any of these be sped up?
+    from binascii import hexlify, unhexlify
+    def bytes_to_int(value):
+        return int(hexlify(value),16)
+    def int_to_bytes(value, count):
+        return unhexlify(('%%0%dx' % (count<<1)) % value)
+
+add_doc(bytes_to_int, "decode byte string as single big-endian integer")
+add_doc(int_to_bytes, "encode integer as single big-endian byte string")
+
+def xor_bytes(left, right):
+    """Perform bitwise-xor of two byte strings (must be same size)"""
+    return int_to_bytes(bytes_to_int(left) ^ bytes_to_int(right), len(left))
+
+def repeat_string(source, size):
+    """
+    repeat or truncate <source> string, so it has length <size>
+    """
+    mult = 1 + (size - 1) // len(source)
+    return (source * mult)[:size]
+
+
+def utf8_repeat_string(source, size):
+    """
+    variant of repeat_string() which truncates to nearest UTF8 boundary.
+    """
+    mult = 1 + (size - 1) // len(source)
+    return utf8_truncate(source * mult, size)
+
+
+_BNULL = b"\x00"
+_UNULL = u("\x00")
+
+def right_pad_string(source, size, pad=None):
+    """right-pad or truncate <source> string, so it has length <size>"""
+    cur = len(source)
+    if size > cur:
+        if pad is None:
+            pad = _UNULL if isinstance(source, unicode) else _BNULL
+        return source+pad*(size-cur)
+    else:
+        return source[:size]
+
+
+def utf8_truncate(source, index):
+    """
+    helper to truncate UTF8 byte string to nearest character boundary ON OR AFTER <index>.
+    returned prefix will always have length of at least <index>, and will stop on the
+    first byte that's not a UTF8 continuation byte (128 - 191 inclusive).
+    since utf8 should never take more than 4 bytes to encode known unicode values,
+    we can stop after ``index+3`` is reached.
+
+    :param bytes source:
+    :param int index:
+    :rtype: bytes
+    """
+    # general approach:
+    #
+    # * UTF8 bytes will have high two bits (0xC0) as one of:
+    #   00 -- ascii char
+    #   01 -- ascii char
+    #   10 -- continuation of multibyte char
+    #   11 -- start of multibyte char.
+    #   thus we can cut on anything where high bits aren't "10" (0x80; continuation byte)
+    #
+    # * UTF8 characters SHOULD always be 1 to 4 bytes, though they may be unbounded.
+    #   so we just keep going until first non-continuation byte is encountered, or end of str.
+    #   this should work predictably even for malformed/non UTF8 inputs.
+
+    if not isinstance(source, bytes):
+        raise ExpectedTypeError(source, bytes, "source")
+
+    # validate index
+    end = len(source)
+    if index < 0:
+        index = max(0, index + end)
+    if index >= end:
+        return source
+
+    # can stop search after 4 bytes, won't ever have longer utf8 sequence.
+    end = min(index + 3, end)
+
+    # loop until we find non-continuation byte
+    while index < end:
+        if byte_elem_value(source[index]) & 0xC0 != 0x80:
+            # found single-char byte, or start-char byte.
+            break
+        # else: found continuation byte.
+        index += 1
+    else:
+        assert index == end
+
+    # truncate at final index
+    result = source[:index]
+
+    def sanity_check():
+        # try to decode source
+        try:
+            text = source.decode("utf-8")
+        except UnicodeDecodeError:
+            # if source isn't valid utf8, byte level match is enough
+            return True
+
+        # validate that result was cut on character boundary
+        assert text.startswith(result.decode("utf-8"))
+        return True
+
+    assert sanity_check()
+
+    return result
+
+#=============================================================================
+# encoding helpers
+#=============================================================================
+_ASCII_TEST_BYTES = b"\x00\n aA:#!\x7f"
+_ASCII_TEST_UNICODE = _ASCII_TEST_BYTES.decode("ascii")
+
+def is_ascii_codec(codec):
+    """Test if codec is compatible with 7-bit ascii (e.g. latin-1, utf-8; but not utf-16)"""
+    return _ASCII_TEST_UNICODE.encode(codec) == _ASCII_TEST_BYTES
+
+def is_same_codec(left, right):
+    """Check if two codec names are aliases for same codec"""
+    if left == right:
+        return True
+    if not (left and right):
+        return False
+    return _lookup_codec(left).name == _lookup_codec(right).name
+
+_B80 = b'\x80'[0]
+_U80 = u('\x80')
+def is_ascii_safe(source):
+    """Check if string (bytes or unicode) contains only 7-bit ascii"""
+    r = _B80 if isinstance(source, bytes) else _U80
+    return all(c < r for c in source)
+
+def to_bytes(source, encoding="utf-8", param="value", source_encoding=None):
+    """Helper to normalize input to bytes.
+
+    :arg source:
+        Source bytes/unicode to process.
+
+    :arg encoding:
+        Target encoding (defaults to ``"utf-8"``).
+
+    :param param:
+        Optional name of variable/noun to reference when raising errors
+
+    :param source_encoding:
+        If this is specified, and the source is bytes,
+        the source will be transcoded from *source_encoding* to *encoding*
+        (via unicode).
+
+    :raises TypeError: if source is not unicode or bytes.
+
+    :returns:
+        * unicode strings will be encoded using *encoding*, and returned.
+        * if *source_encoding* is not specified, byte strings will be
+          returned unchanged.
+        * if *source_encoding* is specified, byte strings will be transcoded
+          to *encoding*.
+    """
+    assert encoding
+    if isinstance(source, bytes):
+        if source_encoding and not is_same_codec(source_encoding, encoding):
+            return source.decode(source_encoding).encode(encoding)
+        else:
+            return source
+    elif isinstance(source, unicode):
+        return source.encode(encoding)
+    else:
+        raise ExpectedStringError(source, param)
+
+def to_unicode(source, encoding="utf-8", param="value"):
+    """Helper to normalize input to unicode.
+
+    :arg source:
+        source bytes/unicode to process.
+
+    :arg encoding:
+        encoding to use when decoding bytes instances.
+
+    :param param:
+        optional name of variable/noun to reference when raising errors.
+
+    :raises TypeError: if source is not unicode or bytes.
+
+    :returns:
+        * returns unicode strings unchanged.
+        * returns bytes strings decoded using *encoding*
+    """
+    assert encoding
+    if isinstance(source, unicode):
+        return source
+    elif isinstance(source, bytes):
+        return source.decode(encoding)
+    else:
+        raise ExpectedStringError(source, param)
+
+if PY3:
+    def to_native_str(source, encoding="utf-8", param="value"):
+        if isinstance(source, bytes):
+            return source.decode(encoding)
+        elif isinstance(source, unicode):
+            return source
+        else:
+            raise ExpectedStringError(source, param)
+else:
+    def to_native_str(source, encoding="utf-8", param="value"):
+        if isinstance(source, bytes):
+            return source
+        elif isinstance(source, unicode):
+            return source.encode(encoding)
+        else:
+            raise ExpectedStringError(source, param)
+
+add_doc(to_native_str,
+    """Take in unicode or bytes, return native string.
+
+    Python 2: encodes unicode using specified encoding, leaves bytes alone.
+    Python 3: leaves unicode alone, decodes bytes using specified encoding.
+
+    :raises TypeError: if source is not unicode or bytes.
+
+    :arg source:
+        source unicode or bytes string.
+
+    :arg encoding:
+        encoding to use when encoding unicode or decoding bytes.
+        this defaults to ``"utf-8"``.
+
+    :param param:
+        optional name of variable/noun to reference when raising errors.
+
+    :returns: :class:`str` instance
+    """)
+
+@deprecated_function(deprecated="1.6", removed="1.7")
+def to_hash_str(source, encoding="ascii"): # pragma: no cover -- deprecated & unused
+    """deprecated, use to_native_str() instead"""
+    return to_native_str(source, encoding, param="hash")
+
+_true_set = set("true t yes y on 1 enable enabled".split())
+_false_set = set("false f no n off 0 disable disabled".split())
+_none_set = set(["", "none"])
+
+def as_bool(value, none=None, param="boolean"):
+    """
+    helper to convert value to boolean.
+    recognizes strings such as "true", "false"
+    """
+    assert none in [True, False, None]
+    if isinstance(value, unicode_or_bytes_types):
+        clean = value.lower().strip()
+        if clean in _true_set:
+            return True
+        if clean in _false_set:
+            return False
+        if clean in _none_set:
+            return none
+        raise ValueError("unrecognized %s value: %r" % (param, value))
+    elif isinstance(value, bool):
+        return value
+    elif value is None:
+        return none
+    else:
+        return bool(value)
+
+#=============================================================================
+# host OS helpers
+#=============================================================================
+
+def is_safe_crypt_input(value):
+    """
+    UT helper --
+    test if value is safe to pass to crypt.crypt();
+    under PY3, can't pass non-UTF8 bytes to crypt.crypt.
+    """
+    if crypt_accepts_bytes or not isinstance(value, bytes):
+        return True
+    try:
+        value.decode("utf-8")
+        return True
+    except UnicodeDecodeError:
+        return False
+
+try:
+    from crypt import crypt as _crypt
+except ImportError: # pragma: no cover
+    _crypt = None
+    has_crypt = False
+    crypt_accepts_bytes = False
+    crypt_needs_lock = False
+    _safe_crypt_lock = None
+    def safe_crypt(secret, hash):
+        return None
+else:
+    has_crypt = True
+    _NULL = '\x00'
+
+    # XXX: replace this with lazy-evaluated bug detection?
+    if threading and PYPY and (7, 2, 0) <= sys.pypy_version_info <= (7, 3, 3):
+        #: internal lock used to wrap crypt() calls.
+        #: WARNING: if non-passlib code invokes crypt(), this lock won't be enough!
+        _safe_crypt_lock = threading.Lock()
+
+        #: detect if crypt.crypt() needs a thread lock around calls.
+        crypt_needs_lock = True
+
+    else:
+        from passlib.utils.compat import nullcontext
+        _safe_crypt_lock = nullcontext()
+        crypt_needs_lock = False
+
+    # some crypt() variants will return various constant strings when
+    # an invalid/unrecognized config string is passed in; instead of
+    # returning NULL / None. examples include ":", ":0", "*0", etc.
+    # safe_crypt() returns None for any string starting with one of the
+    # chars in this string...
+    _invalid_prefixes = u("*:!")
+
+    if PY3:
+
+        # * pypy3 (as of v7.3.1) has a crypt which accepts bytes, or ASCII-only unicode.
+        # * whereas CPython3 (as of v3.9) has a crypt which doesn't take bytes,
+        #   but accepts ANY unicode (which it always encodes to UTF8).
+        crypt_accepts_bytes = True
+        try:
+            _crypt(b"\xEE", "xx")
+        except TypeError:
+            # CPython will throw TypeError
+            crypt_accepts_bytes = False
+        except:  # no pragma
+            # don't care about other errors this might throw,
+            # just want to see if we get past initial type-coercion step.
+            pass
+
+        def safe_crypt(secret, hash):
+            if crypt_accepts_bytes:
+                # PyPy3 -- all bytes accepted, but unicode encoded to ASCII,
+                # so handling that ourselves.
+                if isinstance(secret, unicode):
+                    secret = secret.encode("utf-8")
+                if _BNULL in secret:
+                    raise ValueError("null character in secret")
+                if isinstance(hash, unicode):
+                    hash = hash.encode("ascii")
+            else:
+                # CPython3's crypt() doesn't take bytes, only unicode; unicode which is then
+                # encoding using utf-8 before passing to the C-level crypt().
+                # so we have to decode the secret.
+                if isinstance(secret, bytes):
+                    orig = secret
+                    try:
+                        secret = secret.decode("utf-8")
+                    except UnicodeDecodeError:
+                        return None
+                    # sanity check it encodes back to original byte string,
+                    # otherwise when crypt() does it's encoding, it'll hash the wrong bytes!
+                    assert secret.encode("utf-8") == orig, \
+                                "utf-8 spec says this can't happen!"
+                if _NULL in secret:
+                    raise ValueError("null character in secret")
+                if isinstance(hash, bytes):
+                    hash = hash.decode("ascii")
+            try:
+                with _safe_crypt_lock:
+                    result = _crypt(secret, hash)
+            except OSError:
+                # new in py39 -- per https://bugs.python.org/issue39289,
+                # crypt() now throws OSError for various things, mainly unknown hash formats
+                # translating that to None for now (may revise safe_crypt behavior in future)
+                return None
+            # NOTE: per issue 113, crypt() may return bytes in some odd cases.
+            #       assuming it should still return an ASCII hash though,
+            #       or there's a bigger issue at hand.
+            if isinstance(result, bytes):
+                result = result.decode("ascii")
+            if not result or result[0] in _invalid_prefixes:
+                return None
+            return result
+    else:
+
+        #: see feature-detection in PY3 fork above
+        crypt_accepts_bytes = True
+
+        # Python 2 crypt handler
+        def safe_crypt(secret, hash):
+            if isinstance(secret, unicode):
+                secret = secret.encode("utf-8")
+            if _NULL in secret:
+                raise ValueError("null character in secret")
+            if isinstance(hash, unicode):
+                hash = hash.encode("ascii")
+            with _safe_crypt_lock:
+                result = _crypt(secret, hash)
+            if not result:
+                return None
+            result = result.decode("ascii")
+            if result[0] in _invalid_prefixes:
+                return None
+            return result
+
+add_doc(safe_crypt, """Wrapper around stdlib's crypt.
+
+    This is a wrapper around stdlib's :func:`!crypt.crypt`, which attempts
+    to provide uniform behavior across Python 2 and 3.
+
+    :arg secret:
+        password, as bytes or unicode (unicode will be encoded as ``utf-8``).
+
+    :arg hash:
+        hash or config string, as ascii bytes or unicode.
+
+    :returns:
+        resulting hash as ascii unicode; or ``None`` if the password
+        couldn't be hashed due to one of the issues:
+
+        * :func:`crypt()` not available on platform.
+
+        * Under Python 3, if *secret* is specified as bytes,
+          it must be use ``utf-8`` or it can't be passed
+          to :func:`crypt()`.
+
+        * Some OSes will return ``None`` if they don't recognize
+          the algorithm being used (though most will simply fall
+          back to des-crypt).
+
+        * Some OSes will return an error string if the input config
+          is recognized but malformed; current code converts these to ``None``
+          as well.
+    """)
+
+def test_crypt(secret, hash):
+    """check if :func:`crypt.crypt` supports specific hash
+    :arg secret: password to test
+    :arg hash: known hash of password to use as reference
+    :returns: True or False
+    """
+    # safe_crypt() always returns unicode, which means that for py3,
+    # 'hash' can't be bytes, or "== hash" will never be True.
+    # under py2 unicode & str(bytes) will compare fine;
+    # so just enforcing "unicode_or_str" limitation
+    assert isinstance(hash, unicode_or_str), \
+        "hash must be unicode_or_str, got %s" % type(hash)
+    assert hash, "hash must be non-empty"
+    return safe_crypt(secret, hash) == hash
+
+timer = timeit.default_timer
+# legacy alias, will be removed in passlib 2.0
+tick = timer
+
+def parse_version(source):
+    """helper to parse version string"""
+    m = re.search(r"(\d+(?:\.\d+)+)", source)
+    if m:
+        return tuple(int(elem) for elem in m.group(1).split("."))
+    return None
+
+#=============================================================================
+# randomness
+#=============================================================================
+
+#------------------------------------------------------------------------
+# setup rng for generating salts
+#------------------------------------------------------------------------
+
+# NOTE:
+# generating salts (e.g. h64_gensalt, below) doesn't require cryptographically
+# strong randomness. it just requires enough range of possible outputs
+# that making a rainbow table is too costly. so it should be ok to
+# fall back on python's builtin mersenne twister prng, as long as it's seeded each time
+# this module is imported, using a couple of minor entropy sources.
+
+try:
+    os.urandom(1)
+    has_urandom = True
+except NotImplementedError: # pragma: no cover
+    has_urandom = False
+
+def genseed(value=None):
+    """generate prng seed value from system resources"""
+    from hashlib import sha512
+    if hasattr(value, "getstate") and hasattr(value, "getrandbits"):
+        # caller passed in RNG as seed value
+        try:
+            value = value.getstate()
+        except NotImplementedError:
+            # this method throws error for e.g. SystemRandom instances,
+            # so fall back to extracting 4k of state
+            value = value.getrandbits(1 << 15)
+    text = u("%s %s %s %.15f %.15f %s") % (
+        # if caller specified a seed value, mix it in
+        value,
+
+        # add current process id
+        # NOTE: not available in some environments, e.g. GAE
+        os.getpid() if hasattr(os, "getpid") else None,
+
+        # id of a freshly created object.
+        # (at least 1 byte of which should be hard to predict)
+        id(object()),
+
+        # the current time, to whatever precision os uses
+        time.time(),
+        tick(),
+
+        # if urandom available, might as well mix some bytes in.
+        os.urandom(32).decode("latin-1") if has_urandom else 0,
+        )
+    # hash it all up and return it as int/long
+    return int(sha512(text.encode("utf-8")).hexdigest(), 16)
+
+if has_urandom:
+    rng = random.SystemRandom()
+else: # pragma: no cover -- runtime detection
+    # NOTE: to reseed use ``rng.seed(genseed(rng))``
+    # XXX: could reseed on every call
+    rng = random.Random(genseed())
+
+#------------------------------------------------------------------------
+# some rng helpers
+#------------------------------------------------------------------------
+def getrandbytes(rng, count):
+    """return byte-string containing *count* number of randomly generated bytes, using specified rng"""
+    # NOTE: would be nice if this was present in stdlib Random class
+
+    ###just in case rng provides this...
+    ##meth = getattr(rng, "getrandbytes", None)
+    ##if meth:
+    ##    return meth(count)
+
+    if not count:
+        return _BEMPTY
+    def helper():
+        # XXX: break into chunks for large number of bits?
+        value = rng.getrandbits(count<<3)
+        i = 0
+        while i < count:
+            yield value & 0xff
+            value >>= 3
+            i += 1
+    return join_byte_values(helper())
+
+def getrandstr(rng, charset, count):
+    """return string containing *count* number of chars/bytes, whose elements are drawn from specified charset, using specified rng"""
+    # NOTE: tests determined this is 4x faster than rng.sample(),
+    # which is why that's not being used here.
+
+    # check alphabet & count
+    if count < 0:
+        raise ValueError("count must be >= 0")
+    letters = len(charset)
+    if letters == 0:
+        raise ValueError("alphabet must not be empty")
+    if letters == 1:
+        return charset * count
+
+    # get random value, and write out to buffer
+    def helper():
+        # XXX: break into chunks for large number of letters?
+        value = rng.randrange(0, letters**count)
+        i = 0
+        while i < count:
+            yield charset[value % letters]
+            value //= letters
+            i += 1
+
+    if isinstance(charset, unicode):
+        return join_unicode(helper())
+    else:
+        return join_byte_elems(helper())
+
+_52charset = '2346789ABCDEFGHJKMNPQRTUVWXYZabcdefghjkmnpqrstuvwxyz'
+
+@deprecated_function(deprecated="1.7", removed="2.0",
+                     replacement="passlib.pwd.genword() / passlib.pwd.genphrase()")
+def generate_password(size=10, charset=_52charset):
+    """generate random password using given length & charset
+
+    :param size:
+        size of password.
+
+    :param charset:
+        optional string specified set of characters to draw from.
+
+        the default charset contains all normal alphanumeric characters,
+        except for the characters ``1IiLl0OoS5``, which were omitted
+        due to their visual similarity.
+
+    :returns: :class:`!str` containing randomly generated password.
+
+    .. note::
+
+        Using the default character set, on a OS with :class:`!SystemRandom` support,
+        this function should generate passwords with 5.7 bits of entropy per character.
+    """
+    return getrandstr(rng, charset, size)
+
+#=============================================================================
+# object type / interface tests
+#=============================================================================
+_handler_attrs = (
+        "name",
+        "setting_kwds", "context_kwds",
+        "verify", "hash", "identify",
+        )
+
+def is_crypt_handler(obj):
+    """check if object follows the :ref:`password-hash-api`"""
+    # XXX: change to use isinstance(obj, PasswordHash) under py26+?
+    return all(hasattr(obj, name) for name in _handler_attrs)
+
+_context_attrs = (
+        "needs_update",
+        "genconfig", "genhash",
+        "verify", "encrypt", "identify",
+        )
+
+def is_crypt_context(obj):
+    """check if object appears to be a :class:`~passlib.context.CryptContext` instance"""
+    # XXX: change to use isinstance(obj, CryptContext)?
+    return all(hasattr(obj, name) for name in _context_attrs)
+
+##def has_many_backends(handler):
+##    "check if handler provides multiple baceknds"
+##    # NOTE: should also provide get_backend(), .has_backend(), and .backends attr
+##    return hasattr(handler, "set_backend")
+
+def has_rounds_info(handler):
+    """check if handler provides the optional :ref:`rounds information <rounds-attributes>` attributes"""
+    return ('rounds' in handler.setting_kwds and
+            getattr(handler, "min_rounds", None) is not None)
+
+def has_salt_info(handler):
+    """check if handler provides the optional :ref:`salt information <salt-attributes>` attributes"""
+    return ('salt' in handler.setting_kwds and
+            getattr(handler, "min_salt_size", None) is not None)
+
+##def has_raw_salt(handler):
+##    "check if handler takes in encoded salt as unicode (False), or decoded salt as bytes (True)"
+##    sc = getattr(handler, "salt_chars", None)
+##    if sc is None:
+##        return None
+##    elif isinstance(sc, unicode):
+##        return False
+##    elif isinstance(sc, bytes):
+##        return True
+##    else:
+##        raise TypeError("handler.salt_chars must be None/unicode/bytes")
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/utils/binary.py b/myenv/lib/python3.9/site-packages/passlib/utils/binary.py
new file mode 100644
index 0000000..521b64a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/utils/binary.py
@@ -0,0 +1,884 @@
+"""
+passlib.utils.binary - binary data encoding/decoding/manipulation
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from __future__ import absolute_import, division, print_function
+from base64 import (
+    b64encode,
+    b64decode,
+    b32decode as _b32decode,
+    b32encode as _b32encode,
+)
+from binascii import b2a_base64, a2b_base64, Error as _BinAsciiError
+import logging
+log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib import exc
+from passlib.utils.compat import (
+    PY3, bascii_to_str,
+    irange, imap, iter_byte_chars, join_byte_values, join_byte_elems,
+    nextgetter, suppress_cause,
+    u, unicode, unicode_or_bytes_types,
+)
+from passlib.utils.decor import memoized_property
+# from passlib.utils import BASE64_CHARS, HASH64_CHARS
+# local
+__all__ = [
+    # constants
+    "BASE64_CHARS", "PADDED_BASE64_CHARS",
+    "AB64_CHARS",
+    "HASH64_CHARS",
+    "BCRYPT_CHARS",
+    "HEX_CHARS", "LOWER_HEX_CHARS", "UPPER_HEX_CHARS",
+
+    "ALL_BYTE_VALUES",
+
+    # misc
+    "compile_byte_translation",
+
+    # base64
+    'ab64_encode', 'ab64_decode',
+    'b64s_encode', 'b64s_decode',
+
+    # base32
+    "b32encode", "b32decode",
+
+    # custom encodings
+    'Base64Engine',
+    'LazyBase64Engine',
+    'h64',
+    'h64big',
+    'bcrypt64',
+]
+
+#=============================================================================
+# constant strings
+#=============================================================================
+
+#-------------------------------------------------------------
+# common salt_chars & checksum_chars values
+#-------------------------------------------------------------
+
+#: standard base64 charmap
+BASE64_CHARS = u("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
+
+#: alt base64 charmap -- "." instead of "+"
+AB64_CHARS =   u("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789./")
+
+#: charmap used by HASH64 encoding.
+HASH64_CHARS = u("./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
+
+#: charmap used by BCrypt
+BCRYPT_CHARS = u("./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")
+
+#: std base64 chars + padding char
+PADDED_BASE64_CHARS = BASE64_CHARS + u("=")
+
+#: all hex chars
+HEX_CHARS = u("0123456789abcdefABCDEF")
+
+#: upper case hex chars
+UPPER_HEX_CHARS = u("0123456789ABCDEF")
+
+#: lower case hex chars
+LOWER_HEX_CHARS = u("0123456789abcdef")
+
+#-------------------------------------------------------------
+# byte strings
+#-------------------------------------------------------------
+
+#: special byte string containing all possible byte values
+#: NOTE: for efficiency, this is treated as singleton by some of the code
+ALL_BYTE_VALUES = join_byte_values(irange(256))
+
+#: some string constants we reuse
+B_EMPTY = b''
+B_NULL = b'\x00'
+B_EQUAL = b'='
+
+#=============================================================================
+# byte translation
+#=============================================================================
+
+#: base list used to compile byte translations
+_TRANSLATE_SOURCE = list(iter_byte_chars(ALL_BYTE_VALUES))
+
+def compile_byte_translation(mapping, source=None):
+    """
+    return a 256-byte string for translating bytes using specified mapping.
+    bytes not specified by mapping will be left alone.
+
+    :param mapping:
+        dict mapping input byte (str or int) -> output byte (str or int).
+
+    :param source:
+        optional existing byte translation string to use as base.
+        (must be 255-length byte string).  defaults to identity mapping.
+
+    :returns:
+        255-length byte string for passing to bytes().translate.
+    """
+    if source is None:
+        target = _TRANSLATE_SOURCE[:]
+    else:
+        assert isinstance(source, bytes) and len(source) == 255
+        target = list(iter_byte_chars(source))
+    for k, v in mapping.items():
+        if isinstance(k, unicode_or_bytes_types):
+            k = ord(k)
+        assert isinstance(k, int) and 0 <= k < 256
+        if isinstance(v, unicode):
+            v = v.encode("ascii")
+        assert isinstance(v, bytes) and len(v) == 1
+        target[k] = v
+    return B_EMPTY.join(target)
+
+#=============================================================================
+# unpadding / stripped base64 encoding
+#=============================================================================
+def b64s_encode(data):
+    """
+    encode using shortened base64 format which omits padding & whitespace.
+    uses default ``+/`` altchars.
+    """
+    return b2a_base64(data).rstrip(_BASE64_STRIP)
+
+def b64s_decode(data):
+    """
+    decode from shortened base64 format which omits padding & whitespace.
+    uses default ``+/`` altchars.
+    """
+    if isinstance(data, unicode):
+        # needs bytes for replace() call, but want to accept ascii-unicode ala a2b_base64()
+        try:
+            data = data.encode("ascii")
+        except UnicodeEncodeError:
+            raise suppress_cause(ValueError("string argument should contain only ASCII characters"))
+    off = len(data) & 3
+    if off == 0:
+        pass
+    elif off == 2:
+        data += _BASE64_PAD2
+    elif off == 3:
+        data += _BASE64_PAD1
+    else:  # off == 1
+        raise ValueError("invalid base64 input")
+    try:
+        return a2b_base64(data)
+    except _BinAsciiError as err:
+        raise suppress_cause(TypeError(err))
+
+#=============================================================================
+# adapted-base64 encoding
+#=============================================================================
+_BASE64_STRIP = b"=\n"
+_BASE64_PAD1 = b"="
+_BASE64_PAD2 = b"=="
+
+# XXX: Passlib 1.8/1.9 -- deprecate everything that's using ab64_encode(),
+#      have it start outputing b64s_encode() instead? can use a64_decode() to retain backwards compat.
+
+def ab64_encode(data):
+    """
+    encode using shortened base64 format which omits padding & whitespace.
+    uses custom ``./`` altchars.
+
+    it is primarily used by Passlib's custom pbkdf2 hashes.
+    """
+    return b64s_encode(data).replace(b"+", b".")
+
+def ab64_decode(data):
+    """
+    decode from shortened base64 format which omits padding & whitespace.
+    uses custom ``./`` altchars, but supports decoding normal ``+/`` altchars as well.
+
+    it is primarily used by Passlib's custom pbkdf2 hashes.
+    """
+    if isinstance(data, unicode):
+        # needs bytes for replace() call, but want to accept ascii-unicode ala a2b_base64()
+        try:
+            data = data.encode("ascii")
+        except UnicodeEncodeError:
+            raise suppress_cause(ValueError("string argument should contain only ASCII characters"))
+    return b64s_decode(data.replace(b".", b"+"))
+
+#=============================================================================
+# base32 codec
+#=============================================================================
+
+def b32encode(source):
+    """
+    wrapper around :func:`base64.b32encode` which strips padding,
+    and returns a native string.
+    """
+    # NOTE: using upper case by default here, since 'I & L' are less
+    #       visually ambiguous than 'i & l'
+    return bascii_to_str(_b32encode(source).rstrip(B_EQUAL))
+
+#: byte translation map to replace common mistyped base32 chars.
+#: XXX: could correct '1' -> 'I', but could be a mistyped lower-case 'l', so leaving it alone.
+_b32_translate = compile_byte_translation({"8": "B", "0": "O"})
+
+#: helper to add padding
+_b32_decode_pad = B_EQUAL * 8
+
+def b32decode(source):
+    """
+    wrapper around :func:`base64.b32decode`
+    which handles common mistyped chars.
+    padding optional, ignored if present.
+    """
+    # encode & correct for typos
+    if isinstance(source, unicode):
+        source = source.encode("ascii")
+    source = source.translate(_b32_translate)
+
+    # pad things so final string is multiple of 8
+    remainder = len(source) & 0x7
+    if remainder:
+        source += _b32_decode_pad[:-remainder]
+
+    # XXX: py27 stdlib's version of this has some inefficiencies,
+    #      could look into using optimized version.
+    return _b32decode(source, True)
+
+#=============================================================================
+# base64-variant encoding
+#=============================================================================
+
+class Base64Engine(object):
+    """Provides routines for encoding/decoding base64 data using
+    arbitrary character mappings, selectable endianness, etc.
+
+    :arg charmap:
+        A string of 64 unique characters,
+        which will be used to encode successive 6-bit chunks of data.
+        A character's position within the string should correspond
+        to its 6-bit value.
+
+    :param big:
+        Whether the encoding should be big-endian (default False).
+
+    .. note::
+        This class does not currently handle base64's padding characters
+        in any way what so ever.
+
+    Raw Bytes <-> Encoded Bytes
+    ===========================
+    The following methods convert between raw bytes,
+    and strings encoded using the engine's specific base64 variant:
+
+    .. automethod:: encode_bytes
+    .. automethod:: decode_bytes
+    .. automethod:: encode_transposed_bytes
+    .. automethod:: decode_transposed_bytes
+
+    ..
+        .. automethod:: check_repair_unused
+        .. automethod:: repair_unused
+
+    Integers <-> Encoded Bytes
+    ==========================
+    The following methods allow encoding and decoding
+    unsigned integers to and from the engine's specific base64 variant.
+    Endianess is determined by the engine's ``big`` constructor keyword.
+
+    .. automethod:: encode_int6
+    .. automethod:: decode_int6
+
+    .. automethod:: encode_int12
+    .. automethod:: decode_int12
+
+    .. automethod:: encode_int24
+    .. automethod:: decode_int24
+
+    .. automethod:: encode_int64
+    .. automethod:: decode_int64
+
+    Informational Attributes
+    ========================
+    .. attribute:: charmap
+
+        unicode string containing list of characters used in encoding;
+        position in string matches 6bit value of character.
+
+    .. attribute:: bytemap
+
+        bytes version of :attr:`charmap`
+
+    .. attribute:: big
+
+        boolean flag indicating this using big-endian encoding.
+    """
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+    # public config
+    bytemap = None # charmap as bytes
+    big = None # little or big endian
+
+    # filled in by init based on charmap.
+    # (byte elem: single byte under py2, 8bit int under py3)
+    _encode64 = None # maps 6bit value -> byte elem
+    _decode64 = None # maps byte elem -> 6bit value
+
+    # helpers filled in by init based on endianness
+    _encode_bytes = None # throws IndexError if bad value (shouldn't happen)
+    _decode_bytes = None # throws KeyError if bad char.
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, charmap, big=False):
+        # validate charmap, generate encode64/decode64 helper functions.
+        if isinstance(charmap, unicode):
+            charmap = charmap.encode("latin-1")
+        elif not isinstance(charmap, bytes):
+            raise exc.ExpectedStringError(charmap, "charmap")
+        if len(charmap) != 64:
+            raise ValueError("charmap must be 64 characters in length")
+        if len(set(charmap)) != 64:
+            raise ValueError("charmap must not contain duplicate characters")
+        self.bytemap = charmap
+        self._encode64 = charmap.__getitem__
+        lookup = dict((value, idx) for idx, value in enumerate(charmap))
+        self._decode64 = lookup.__getitem__
+
+        # validate big, set appropriate helper functions.
+        self.big = big
+        if big:
+            self._encode_bytes = self._encode_bytes_big
+            self._decode_bytes = self._decode_bytes_big
+        else:
+            self._encode_bytes = self._encode_bytes_little
+            self._decode_bytes = self._decode_bytes_little
+
+        # TODO: support padding character
+        ##if padding is not None:
+        ##    if isinstance(padding, unicode):
+        ##        padding = padding.encode("latin-1")
+        ##    elif not isinstance(padding, bytes):
+        ##        raise TypeError("padding char must be unicode or bytes")
+        ##    if len(padding) != 1:
+        ##        raise ValueError("padding must be single character")
+        ##self.padding = padding
+
+    @property
+    def charmap(self):
+        """charmap as unicode"""
+        return self.bytemap.decode("latin-1")
+
+    #===================================================================
+    # encoding byte strings
+    #===================================================================
+    def encode_bytes(self, source):
+        """encode bytes to base64 string.
+
+        :arg source: byte string to encode.
+        :returns: byte string containing encoded data.
+        """
+        if not isinstance(source, bytes):
+            raise TypeError("source must be bytes, not %s" % (type(source),))
+        chunks, tail = divmod(len(source), 3)
+        if PY3:
+            next_value = nextgetter(iter(source))
+        else:
+            next_value = nextgetter(ord(elem) for elem in source)
+        gen = self._encode_bytes(next_value, chunks, tail)
+        out = join_byte_elems(imap(self._encode64, gen))
+        ##if tail:
+        ##    padding = self.padding
+        ##    if padding:
+        ##        out += padding * (3-tail)
+        return out
+
+    def _encode_bytes_little(self, next_value, chunks, tail):
+        """helper used by encode_bytes() to handle little-endian encoding"""
+        #
+        # output bit layout:
+        #
+        # first byte:   v1 543210
+        #
+        # second byte:  v1 ....76
+        #              +v2 3210..
+        #
+        # third byte:   v2 ..7654
+        #              +v3 10....
+        #
+        # fourth byte:  v3 765432
+        #
+        idx = 0
+        while idx < chunks:
+            v1 = next_value()
+            v2 = next_value()
+            v3 = next_value()
+            yield v1 & 0x3f
+            yield ((v2 & 0x0f)<<2)|(v1>>6)
+            yield ((v3 & 0x03)<<4)|(v2>>4)
+            yield v3>>2
+            idx += 1
+        if tail:
+            v1 = next_value()
+            if tail == 1:
+                # note: 4 msb of last byte are padding
+                yield v1 & 0x3f
+                yield v1>>6
+            else:
+                assert tail == 2
+                # note: 2 msb of last byte are padding
+                v2 = next_value()
+                yield v1 & 0x3f
+                yield ((v2 & 0x0f)<<2)|(v1>>6)
+                yield v2>>4
+
+    def _encode_bytes_big(self, next_value, chunks, tail):
+        """helper used by encode_bytes() to handle big-endian encoding"""
+        #
+        # output bit layout:
+        #
+        # first byte:   v1 765432
+        #
+        # second byte:  v1 10....
+        #              +v2 ..7654
+        #
+        # third byte:   v2 3210..
+        #              +v3 ....76
+        #
+        # fourth byte:  v3 543210
+        #
+        idx = 0
+        while idx < chunks:
+            v1 = next_value()
+            v2 = next_value()
+            v3 = next_value()
+            yield v1>>2
+            yield ((v1&0x03)<<4)|(v2>>4)
+            yield ((v2&0x0f)<<2)|(v3>>6)
+            yield v3 & 0x3f
+            idx += 1
+        if tail:
+            v1 = next_value()
+            if tail == 1:
+                # note: 4 lsb of last byte are padding
+                yield v1>>2
+                yield (v1&0x03)<<4
+            else:
+                assert tail == 2
+                # note: 2 lsb of last byte are padding
+                v2 = next_value()
+                yield v1>>2
+                yield ((v1&0x03)<<4)|(v2>>4)
+                yield ((v2&0x0f)<<2)
+
+    #===================================================================
+    # decoding byte strings
+    #===================================================================
+
+    def decode_bytes(self, source):
+        """decode bytes from base64 string.
+
+        :arg source: byte string to decode.
+        :returns: byte string containing decoded data.
+        """
+        if not isinstance(source, bytes):
+            raise TypeError("source must be bytes, not %s" % (type(source),))
+        ##padding = self.padding
+        ##if padding:
+        ##    # TODO: add padding size check?
+        ##    source = source.rstrip(padding)
+        chunks, tail = divmod(len(source), 4)
+        if tail == 1:
+            # only 6 bits left, can't encode a whole byte!
+            raise ValueError("input string length cannot be == 1 mod 4")
+        next_value = nextgetter(imap(self._decode64, source))
+        try:
+            return join_byte_values(self._decode_bytes(next_value, chunks, tail))
+        except KeyError as err:
+            raise ValueError("invalid character: %r" % (err.args[0],))
+
+    def _decode_bytes_little(self, next_value, chunks, tail):
+        """helper used by decode_bytes() to handle little-endian encoding"""
+        #
+        # input bit layout:
+        #
+        # first byte:   v1 ..543210
+        #              +v2 10......
+        #
+        # second byte:  v2 ....5432
+        #              +v3 3210....
+        #
+        # third byte:   v3 ......54
+        #              +v4 543210..
+        #
+        idx = 0
+        while idx < chunks:
+            v1 = next_value()
+            v2 = next_value()
+            v3 = next_value()
+            v4 = next_value()
+            yield v1 | ((v2 & 0x3) << 6)
+            yield (v2>>2) | ((v3 & 0xF) << 4)
+            yield (v3>>4) | (v4<<2)
+            idx += 1
+        if tail:
+            # tail is 2 or 3
+            v1 = next_value()
+            v2 = next_value()
+            yield v1 | ((v2 & 0x3) << 6)
+            # NOTE: if tail == 2, 4 msb of v2 are ignored (should be 0)
+            if tail == 3:
+                # NOTE: 2 msb of v3 are ignored (should be 0)
+                v3 = next_value()
+                yield (v2>>2) | ((v3 & 0xF) << 4)
+
+    def _decode_bytes_big(self, next_value, chunks, tail):
+        """helper used by decode_bytes() to handle big-endian encoding"""
+        #
+        # input bit layout:
+        #
+        # first byte:   v1 543210..
+        #              +v2 ......54
+        #
+        # second byte:  v2 3210....
+        #              +v3 ....5432
+        #
+        # third byte:   v3 10......
+        #              +v4 ..543210
+        #
+        idx = 0
+        while idx < chunks:
+            v1 = next_value()
+            v2 = next_value()
+            v3 = next_value()
+            v4 = next_value()
+            yield (v1<<2) | (v2>>4)
+            yield ((v2&0xF)<<4) | (v3>>2)
+            yield ((v3&0x3)<<6) | v4
+            idx += 1
+        if tail:
+            # tail is 2 or 3
+            v1 = next_value()
+            v2 = next_value()
+            yield (v1<<2) | (v2>>4)
+            # NOTE: if tail == 2, 4 lsb of v2 are ignored (should be 0)
+            if tail == 3:
+                # NOTE: 2 lsb of v3 are ignored (should be 0)
+                v3 = next_value()
+                yield ((v2&0xF)<<4) | (v3>>2)
+
+    #===================================================================
+    # encode/decode helpers
+    #===================================================================
+
+    # padmap2/3 - dict mapping last char of string ->
+    # equivalent char with no padding bits set.
+
+    def __make_padset(self, bits):
+        """helper to generate set of valid last chars & bytes"""
+        pset = set(c for i,c in enumerate(self.bytemap) if not i & bits)
+        pset.update(c for i,c in enumerate(self.charmap) if not i & bits)
+        return frozenset(pset)
+
+    @memoized_property
+    def _padinfo2(self):
+        """mask to clear padding bits, and valid last bytes (for strings 2 % 4)"""
+        # 4 bits of last char unused (lsb for big, msb for little)
+        bits = 15 if self.big else (15<<2)
+        return ~bits, self.__make_padset(bits)
+
+    @memoized_property
+    def _padinfo3(self):
+        """mask to clear padding bits, and valid last bytes (for strings 3 % 4)"""
+        # 2 bits of last char unused (lsb for big, msb for little)
+        bits = 3 if self.big else (3<<4)
+        return ~bits, self.__make_padset(bits)
+
+    def check_repair_unused(self, source):
+        """helper to detect & clear invalid unused bits in last character.
+
+        :arg source:
+            encoded data (as ascii bytes or unicode).
+
+        :returns:
+            `(True, result)` if the string was repaired,
+            `(False, source)` if the string was ok as-is.
+        """
+        # figure out how many padding bits there are in last char.
+        tail = len(source) & 3
+        if tail == 2:
+            mask, padset = self._padinfo2
+        elif tail == 3:
+            mask, padset = self._padinfo3
+        elif not tail:
+            return False, source
+        else:
+            raise ValueError("source length must != 1 mod 4")
+
+        # check if last char is ok (padset contains bytes & unicode versions)
+        last = source[-1]
+        if last in padset:
+            return False, source
+
+        # we have dirty bits - repair the string by decoding last char,
+        # clearing the padding bits via <mask>, and encoding new char.
+        if isinstance(source, unicode):
+            cm = self.charmap
+            last = cm[cm.index(last) & mask]
+            assert last in padset, "failed to generate valid padding char"
+        else:
+            # NOTE: this assumes ascii-compat encoding, and that
+            # all chars used by encoding are 7-bit ascii.
+            last = self._encode64(self._decode64(last) & mask)
+            assert last in padset, "failed to generate valid padding char"
+            if PY3:
+                last = bytes([last])
+        return True, source[:-1] + last
+
+    def repair_unused(self, source):
+        return self.check_repair_unused(source)[1]
+
+    ##def transcode(self, source, other):
+    ##    return ''.join(
+    ##        other.charmap[self.charmap.index(char)]
+    ##        for char in source
+    ##    )
+
+    ##def random_encoded_bytes(self, size, random=None, unicode=False):
+    ##    "return random encoded string of given size"
+    ##    data = getrandstr(random or rng,
+    ##                      self.charmap if unicode else self.bytemap, size)
+    ##    return self.repair_unused(data)
+
+    #===================================================================
+    # transposed encoding/decoding
+    #===================================================================
+    def encode_transposed_bytes(self, source, offsets):
+        """encode byte string, first transposing source using offset list"""
+        if not isinstance(source, bytes):
+            raise TypeError("source must be bytes, not %s" % (type(source),))
+        tmp = join_byte_elems(source[off] for off in offsets)
+        return self.encode_bytes(tmp)
+
+    def decode_transposed_bytes(self, source, offsets):
+        """decode byte string, then reverse transposition described by offset list"""
+        # NOTE: if transposition does not use all bytes of source,
+        # the original can't be recovered... and join_byte_elems() will throw
+        # an error because 1+ values in <buf> will be None.
+        tmp = self.decode_bytes(source)
+        buf = [None] * len(offsets)
+        for off, char in zip(offsets, tmp):
+            buf[off] = char
+        return join_byte_elems(buf)
+
+    #===================================================================
+    # integer decoding helpers - mainly used by des_crypt family
+    #===================================================================
+    def _decode_int(self, source, bits):
+        """decode base64 string -> integer
+
+        :arg source: base64 string to decode.
+        :arg bits: number of bits in resulting integer.
+
+        :raises ValueError:
+            * if the string contains invalid base64 characters.
+            * if the string is not long enough - it must be at least
+              ``int(ceil(bits/6))`` in length.
+
+        :returns:
+            a integer in the range ``0 <= n < 2**bits``
+        """
+        if not isinstance(source, bytes):
+            raise TypeError("source must be bytes, not %s" % (type(source),))
+        big = self.big
+        pad = -bits % 6
+        chars = (bits+pad)/6
+        if len(source) != chars:
+            raise ValueError("source must be %d chars" % (chars,))
+        decode = self._decode64
+        out = 0
+        try:
+            for c in source if big else reversed(source):
+                out = (out<<6) + decode(c)
+        except KeyError:
+            raise ValueError("invalid character in string: %r" % (c,))
+        if pad:
+            # strip padding bits
+            if big:
+                out >>= pad
+            else:
+                out &= (1<<bits)-1
+        return out
+
+    #---------------------------------------------------------------
+    # optimized versions for common integer sizes
+    #---------------------------------------------------------------
+
+    def decode_int6(self, source):
+        """decode single character -> 6 bit integer"""
+        if not isinstance(source, bytes):
+            raise TypeError("source must be bytes, not %s" % (type(source),))
+        if len(source) != 1:
+            raise ValueError("source must be exactly 1 byte")
+        if PY3:
+            # convert to 8bit int before doing lookup
+            source = source[0]
+        try:
+            return self._decode64(source)
+        except KeyError:
+            raise ValueError("invalid character")
+
+    def decode_int12(self, source):
+        """decodes 2 char string -> 12-bit integer"""
+        if not isinstance(source, bytes):
+            raise TypeError("source must be bytes, not %s" % (type(source),))
+        if len(source) != 2:
+            raise ValueError("source must be exactly 2 bytes")
+        decode = self._decode64
+        try:
+            if self.big:
+                return decode(source[1]) + (decode(source[0])<<6)
+            else:
+                return decode(source[0]) + (decode(source[1])<<6)
+        except KeyError:
+            raise ValueError("invalid character")
+
+    def decode_int24(self, source):
+        """decodes 4 char string -> 24-bit integer"""
+        if not isinstance(source, bytes):
+            raise TypeError("source must be bytes, not %s" % (type(source),))
+        if len(source) != 4:
+            raise ValueError("source must be exactly 4 bytes")
+        decode = self._decode64
+        try:
+            if self.big:
+                return decode(source[3]) + (decode(source[2])<<6)+ \
+                       (decode(source[1])<<12) + (decode(source[0])<<18)
+            else:
+                return decode(source[0]) + (decode(source[1])<<6)+ \
+                       (decode(source[2])<<12) + (decode(source[3])<<18)
+        except KeyError:
+            raise ValueError("invalid character")
+
+    def decode_int30(self, source):
+        """decode 5 char string -> 30 bit integer"""
+        return self._decode_int(source, 30)
+
+    def decode_int64(self, source):
+        """decode 11 char base64 string -> 64-bit integer
+
+        this format is used primarily by des-crypt & variants to encode
+        the DES output value used as a checksum.
+        """
+        return self._decode_int(source, 64)
+
+    #===================================================================
+    # integer encoding helpers - mainly used by des_crypt family
+    #===================================================================
+    def _encode_int(self, value, bits):
+        """encode integer into base64 format
+
+        :arg value: non-negative integer to encode
+        :arg bits: number of bits to encode
+
+        :returns:
+            a string of length ``int(ceil(bits/6.0))``.
+        """
+        assert value >= 0, "caller did not sanitize input"
+        pad = -bits % 6
+        bits += pad
+        if self.big:
+            itr = irange(bits-6, -6, -6)
+            # shift to add lsb padding.
+            value <<= pad
+        else:
+            itr = irange(0, bits, 6)
+            # padding is msb, so no change needed.
+        return join_byte_elems(imap(self._encode64,
+                                ((value>>off) & 0x3f for off in itr)))
+
+    #---------------------------------------------------------------
+    # optimized versions for common integer sizes
+    #---------------------------------------------------------------
+
+    def encode_int6(self, value):
+        """encodes 6-bit integer -> single hash64 character"""
+        if value < 0 or value > 63:
+            raise ValueError("value out of range")
+        if PY3:
+            return self.bytemap[value:value+1]
+        else:
+            return self._encode64(value)
+
+    def encode_int12(self, value):
+        """encodes 12-bit integer -> 2 char string"""
+        if value < 0 or value > 0xFFF:
+            raise ValueError("value out of range")
+        raw = [value & 0x3f, (value>>6) & 0x3f]
+        if self.big:
+            raw = reversed(raw)
+        return join_byte_elems(imap(self._encode64, raw))
+
+    def encode_int24(self, value):
+        """encodes 24-bit integer -> 4 char string"""
+        if value < 0 or value > 0xFFFFFF:
+            raise ValueError("value out of range")
+        raw = [value & 0x3f, (value>>6) & 0x3f,
+               (value>>12) & 0x3f, (value>>18) & 0x3f]
+        if self.big:
+            raw = reversed(raw)
+        return join_byte_elems(imap(self._encode64, raw))
+
+    def encode_int30(self, value):
+        """decode 5 char string -> 30 bit integer"""
+        if value < 0 or value > 0x3fffffff:
+            raise ValueError("value out of range")
+        return self._encode_int(value, 30)
+
+    def encode_int64(self, value):
+        """encode 64-bit integer -> 11 char hash64 string
+
+        this format is used primarily by des-crypt & variants to encode
+        the DES output value used as a checksum.
+        """
+        if value < 0 or value > 0xffffffffffffffff:
+            raise ValueError("value out of range")
+        return self._encode_int(value, 64)
+
+    #===================================================================
+    # eof
+    #===================================================================
+
+class LazyBase64Engine(Base64Engine):
+    """Base64Engine which delays initialization until it's accessed"""
+    _lazy_opts = None
+
+    def __init__(self, *args, **kwds):
+        self._lazy_opts = (args, kwds)
+
+    def _lazy_init(self):
+        args, kwds = self._lazy_opts
+        super(LazyBase64Engine, self).__init__(*args, **kwds)
+        del self._lazy_opts
+        self.__class__ = Base64Engine
+
+    def __getattribute__(self, attr):
+        if not attr.startswith("_"):
+            self._lazy_init()
+        return object.__getattribute__(self, attr)
+
+#-------------------------------------------------------------
+# common variants
+#-------------------------------------------------------------
+
+h64 = LazyBase64Engine(HASH64_CHARS)
+h64big = LazyBase64Engine(HASH64_CHARS, big=True)
+bcrypt64 = LazyBase64Engine(BCRYPT_CHARS, big=True)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/utils/compat/__init__.py b/myenv/lib/python3.9/site-packages/passlib/utils/compat/__init__.py
new file mode 100644
index 0000000..f6ead24
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/utils/compat/__init__.py
@@ -0,0 +1,474 @@
+"""passlib.utils.compat - python 2/3 compatibility helpers"""
+#=============================================================================
+# figure out what we're running
+#=============================================================================
+
+#------------------------------------------------------------------------
+# python version
+#------------------------------------------------------------------------
+import sys
+PY2 = sys.version_info < (3,0)
+PY3 = sys.version_info >= (3,0)
+
+# make sure it's not an unsupported version, even if we somehow got this far
+if sys.version_info < (2,6) or (3,0) <= sys.version_info < (3,2):
+    raise RuntimeError("Passlib requires Python 2.6, 2.7, or >= 3.2 (as of passlib 1.7)")
+
+PY26 = sys.version_info < (2,7)
+
+#------------------------------------------------------------------------
+# python implementation
+#------------------------------------------------------------------------
+JYTHON = sys.platform.startswith('java')
+
+PYPY = hasattr(sys, "pypy_version_info")
+
+if PYPY and sys.pypy_version_info < (2,0):
+    raise RuntimeError("passlib requires pypy >= 2.0 (as of passlib 1.7)")
+
+# e.g. '2.7.7\n[Pyston 0.5.1]'
+# NOTE: deprecated support 2019-11
+PYSTON = "Pyston" in sys.version
+
+#=============================================================================
+# common imports
+#=============================================================================
+import logging; log = logging.getLogger(__name__)
+if PY3:
+    import builtins
+else:
+    import __builtin__ as builtins
+
+def add_doc(obj, doc):
+    """add docstring to an object"""
+    obj.__doc__ = doc
+
+#=============================================================================
+# the default exported vars
+#=============================================================================
+__all__ = [
+    # python versions
+    'PY2', 'PY3', 'PY26',
+
+    # io
+    'BytesIO', 'StringIO', 'NativeStringIO', 'SafeConfigParser',
+    'print_',
+
+    # type detection
+##    'is_mapping',
+    'int_types',
+    'num_types',
+    'unicode_or_bytes_types',
+    'native_string_types',
+
+    # unicode/bytes types & helpers
+    'u',
+    'unicode',
+    'uascii_to_str', 'bascii_to_str',
+    'str_to_uascii', 'str_to_bascii',
+    'join_unicode', 'join_bytes',
+    'join_byte_values', 'join_byte_elems',
+    'byte_elem_value',
+    'iter_byte_values',
+
+    # iteration helpers
+    'irange', #'lrange',
+    'imap', 'lmap',
+    'iteritems', 'itervalues',
+    'next',
+
+    # collections
+    'OrderedDict',
+
+    # context helpers
+    'nullcontext',
+
+    # introspection
+    'get_method_function', 'add_doc',
+]
+
+# begin accumulating mapping of lazy-loaded attrs,
+# 'merged' into module at bottom
+_lazy_attrs = dict()
+
+#=============================================================================
+# unicode & bytes types
+#=============================================================================
+if PY3:
+    unicode = str
+
+    # TODO: once we drop python 3.2 support, can use u'' again!
+    def u(s):
+        assert isinstance(s, str)
+        return s
+
+    unicode_or_bytes_types = (str, bytes)
+    native_string_types = (unicode,)
+
+else:
+    unicode = builtins.unicode
+
+    def u(s):
+        assert isinstance(s, str)
+        return s.decode("unicode_escape")
+
+    unicode_or_bytes_types = (basestring,)
+    native_string_types = (basestring,)
+
+# shorter preferred aliases
+unicode_or_bytes = unicode_or_bytes_types
+unicode_or_str = native_string_types
+
+# unicode -- unicode type, regardless of python version
+# bytes -- bytes type, regardless of python version
+# unicode_or_bytes_types -- types that text can occur in, whether encoded or not
+# native_string_types -- types that native python strings (dict keys etc) can occur in.
+
+#=============================================================================
+# unicode & bytes helpers
+#=============================================================================
+# function to join list of unicode strings
+join_unicode = u('').join
+
+# function to join list of byte strings
+join_bytes = b''.join
+
+if PY3:
+    def uascii_to_str(s):
+        assert isinstance(s, unicode)
+        return s
+
+    def bascii_to_str(s):
+        assert isinstance(s, bytes)
+        return s.decode("ascii")
+
+    def str_to_uascii(s):
+        assert isinstance(s, str)
+        return s
+
+    def str_to_bascii(s):
+        assert isinstance(s, str)
+        return s.encode("ascii")
+
+    join_byte_values = join_byte_elems = bytes
+
+    def byte_elem_value(elem):
+        assert isinstance(elem, int)
+        return elem
+
+    def iter_byte_values(s):
+        assert isinstance(s, bytes)
+        return s
+
+    def iter_byte_chars(s):
+        assert isinstance(s, bytes)
+        # FIXME: there has to be a better way to do this
+        return (bytes([c]) for c in s)
+
+else:
+    def uascii_to_str(s):
+        assert isinstance(s, unicode)
+        return s.encode("ascii")
+
+    def bascii_to_str(s):
+        assert isinstance(s, bytes)
+        return s
+
+    def str_to_uascii(s):
+        assert isinstance(s, str)
+        return s.decode("ascii")
+
+    def str_to_bascii(s):
+        assert isinstance(s, str)
+        return s
+
+    def join_byte_values(values):
+        return join_bytes(chr(v) for v in values)
+
+    join_byte_elems = join_bytes
+
+    byte_elem_value = ord
+
+    def iter_byte_values(s):
+        assert isinstance(s, bytes)
+        return (ord(c) for c in s)
+
+    def iter_byte_chars(s):
+        assert isinstance(s, bytes)
+        return s
+
+add_doc(uascii_to_str, "helper to convert ascii unicode -> native str")
+add_doc(bascii_to_str, "helper to convert ascii bytes -> native str")
+add_doc(str_to_uascii, "helper to convert ascii native str -> unicode")
+add_doc(str_to_bascii, "helper to convert ascii native str -> bytes")
+
+# join_byte_values -- function to convert list of ordinal integers to byte string.
+
+# join_byte_elems --  function to convert list of byte elements to byte string;
+#                 i.e. what's returned by ``b('a')[0]``...
+#                 this is b('a') under PY2, but 97 under PY3.
+
+# byte_elem_value -- function to convert byte element to integer -- a noop under PY3
+
+add_doc(iter_byte_values, "iterate over byte string as sequence of ints 0-255")
+add_doc(iter_byte_chars, "iterate over byte string as sequence of 1-byte strings")
+
+#=============================================================================
+# numeric
+#=============================================================================
+if PY3:
+    int_types = (int,)
+    num_types = (int, float)
+else:
+    int_types = (int, long)
+    num_types = (int, long, float)
+
+#=============================================================================
+# iteration helpers
+#
+# irange - range iterable / view (xrange under py2, range under py3)
+# lrange - range list (range under py2, list(range()) under py3)
+#
+# imap - map to iterator
+# lmap - map to list
+#=============================================================================
+if PY3:
+    irange = range
+    ##def lrange(*a,**k):
+    ##    return list(range(*a,**k))
+
+    def lmap(*a, **k):
+        return list(map(*a,**k))
+    imap = map
+
+    def iteritems(d):
+        return d.items()
+    def itervalues(d):
+        return d.values()
+
+    def nextgetter(obj):
+        return obj.__next__
+
+    izip = zip
+
+else:
+    irange = xrange
+    ##lrange = range
+
+    lmap = map
+    from itertools import imap, izip
+
+    def iteritems(d):
+        return d.iteritems()
+    def itervalues(d):
+        return d.itervalues()
+
+    def nextgetter(obj):
+        return obj.next
+
+add_doc(nextgetter, "return function that yields successive values from iterable")
+
+#=============================================================================
+# typing
+#=============================================================================
+##def is_mapping(obj):
+##    # non-exhaustive check, enough to distinguish from lists, etc
+##    return hasattr(obj, "items")
+
+#=============================================================================
+# introspection
+#=============================================================================
+if PY3:
+    method_function_attr = "__func__"
+else:
+    method_function_attr = "im_func"
+
+def get_method_function(func):
+    """given (potential) method, return underlying function"""
+    return getattr(func, method_function_attr, func)
+
+def get_unbound_method_function(func):
+    """given unbound method, return underlying function"""
+    return func if PY3 else func.__func__
+
+def error_from(exc,  # *,
+               cause=None):
+    """
+    backward compat hack to suppress exception cause in python3.3+
+
+    one python < 3.3 support is dropped, can replace all uses with "raise exc from None"
+    """
+    exc.__cause__ = cause
+    exc.__suppress_context__ = True
+    return exc
+
+# legacy alias
+suppress_cause = error_from
+
+#=============================================================================
+# input/output
+#=============================================================================
+if PY3:
+    _lazy_attrs = dict(
+        BytesIO="io.BytesIO",
+        UnicodeIO="io.StringIO",
+        NativeStringIO="io.StringIO",
+        SafeConfigParser="configparser.ConfigParser",
+    )
+
+    print_ = getattr(builtins, "print")
+
+else:
+    _lazy_attrs = dict(
+        BytesIO="cStringIO.StringIO",
+        UnicodeIO="StringIO.StringIO",
+        NativeStringIO="cStringIO.StringIO",
+        SafeConfigParser="ConfigParser.SafeConfigParser",
+    )
+
+    def print_(*args, **kwds):
+        """The new-style print function."""
+        # extract kwd args
+        fp = kwds.pop("file", sys.stdout)
+        sep = kwds.pop("sep", None)
+        end = kwds.pop("end", None)
+        if kwds:
+            raise TypeError("invalid keyword arguments")
+
+        # short-circuit if no target
+        if fp is None:
+            return
+
+        # use unicode or bytes ?
+        want_unicode = isinstance(sep, unicode) or isinstance(end, unicode) or \
+                       any(isinstance(arg, unicode) for arg in args)
+
+        # pick default end sequence
+        if end is None:
+            end = u("\n") if want_unicode else "\n"
+        elif not isinstance(end, unicode_or_bytes_types):
+            raise TypeError("end must be None or a string")
+
+        # pick default separator
+        if sep is None:
+            sep = u(" ") if want_unicode else " "
+        elif not isinstance(sep, unicode_or_bytes_types):
+            raise TypeError("sep must be None or a string")
+
+        # write to buffer
+        first = True
+        write = fp.write
+        for arg in args:
+            if first:
+                first = False
+            else:
+                write(sep)
+            if not isinstance(arg, basestring):
+                arg = str(arg)
+            write(arg)
+        write(end)
+
+#=============================================================================
+# collections
+#=============================================================================
+if PY26:
+    _lazy_attrs['OrderedDict'] = 'passlib.utils.compat._ordered_dict.OrderedDict'
+else:
+    _lazy_attrs['OrderedDict'] = 'collections.OrderedDict'
+
+#=============================================================================
+# context managers
+#=============================================================================
+
+try:
+    # new in py37
+    from contextlib import nullcontext
+except ImportError:
+
+    class nullcontext(object):
+        """
+        Context manager that does no additional processing.
+        """
+        def __init__(self, enter_result=None):
+            self.enter_result = enter_result
+
+        def __enter__(self):
+            return self.enter_result
+
+        def __exit__(self, *exc_info):
+            pass
+
+#=============================================================================
+# lazy overlay module
+#=============================================================================
+from types import ModuleType
+
+def _import_object(source):
+    """helper to import object from module; accept format `path.to.object`"""
+    modname, modattr = source.rsplit(".",1)
+    mod = __import__(modname, fromlist=[modattr], level=0)
+    return getattr(mod, modattr)
+
+class _LazyOverlayModule(ModuleType):
+    """proxy module which overlays original module,
+    and lazily imports specified attributes.
+
+    this is mainly used to prevent importing of resources
+    that are only needed by certain password hashes,
+    yet allow them to be imported from a single location.
+
+    used by :mod:`passlib.utils`, :mod:`passlib.crypto`,
+    and :mod:`passlib.utils.compat`.
+    """
+
+    @classmethod
+    def replace_module(cls, name, attrmap):
+        orig = sys.modules[name]
+        self = cls(name, attrmap, orig)
+        sys.modules[name] = self
+        return self
+
+    def __init__(self, name, attrmap, proxy=None):
+        ModuleType.__init__(self, name)
+        self.__attrmap = attrmap
+        self.__proxy = proxy
+        self.__log = logging.getLogger(name)
+
+    def __getattr__(self, attr):
+        proxy = self.__proxy
+        if proxy and hasattr(proxy, attr):
+            return getattr(proxy, attr)
+        attrmap = self.__attrmap
+        if attr in attrmap:
+            source = attrmap[attr]
+            if callable(source):
+                value = source()
+            else:
+                value = _import_object(source)
+            setattr(self, attr, value)
+            self.__log.debug("loaded lazy attr %r: %r", attr, value)
+            return value
+        raise AttributeError("'module' object has no attribute '%s'" % (attr,))
+
+    def __repr__(self):
+        proxy = self.__proxy
+        if proxy:
+            return repr(proxy)
+        else:
+            return ModuleType.__repr__(self)
+
+    def __dir__(self):
+        attrs = set(dir(self.__class__))
+        attrs.update(self.__dict__)
+        attrs.update(self.__attrmap)
+        proxy = self.__proxy
+        if proxy is not None:
+            attrs.update(dir(proxy))
+        return list(attrs)
+
+# replace this module with overlay that will lazily import attributes.
+_LazyOverlayModule.replace_module(__name__, _lazy_attrs)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/utils/compat/_ordered_dict.py b/myenv/lib/python3.9/site-packages/passlib/utils/compat/_ordered_dict.py
new file mode 100644
index 0000000..cfd766d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/utils/compat/_ordered_dict.py
@@ -0,0 +1,242 @@
+"""passlib.utils.compat._ordered_dict -- backport of collections.OrderedDict for py26
+
+taken from stdlib-suggested recipe at http://code.activestate.com/recipes/576693/
+
+this should be imported from passlib.utils.compat.OrderedDict, not here.
+"""
+
+try:
+    from thread import get_ident as _get_ident
+except ImportError:
+    from dummy_thread import get_ident as _get_ident
+
+class OrderedDict(dict):
+    """Dictionary that remembers insertion order"""
+    # An inherited dict maps keys to values.
+    # The inherited dict provides __getitem__, __len__, __contains__, and get.
+    # The remaining methods are order-aware.
+    # Big-O running times for all methods are the same as for regular dictionaries.
+
+    # The internal self.__map dictionary maps keys to links in a doubly linked list.
+    # The circular doubly linked list starts and ends with a sentinel element.
+    # The sentinel element never gets deleted (this simplifies the algorithm).
+    # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
+
+    def __init__(self, *args, **kwds):
+        '''Initialize an ordered dictionary.  Signature is the same as for
+        regular dictionaries, but keyword arguments are not recommended
+        because their insertion order is arbitrary.
+
+        '''
+        if len(args) > 1:
+            raise TypeError('expected at most 1 arguments, got %d' % len(args))
+        try:
+            self.__root
+        except AttributeError:
+            self.__root = root = []                     # sentinel node
+            root[:] = [root, root, None]
+            self.__map = {}
+        self.__update(*args, **kwds)
+
+    def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
+        'od.__setitem__(i, y) <==> od[i]=y'
+        # Setting a new item creates a new link which goes at the end of the linked
+        # list, and the inherited dictionary is updated with the new key/value pair.
+        if key not in self:
+            root = self.__root
+            last = root[0]
+            last[1] = root[0] = self.__map[key] = [last, root, key]
+        dict_setitem(self, key, value)
+
+    def __delitem__(self, key, dict_delitem=dict.__delitem__):
+        'od.__delitem__(y) <==> del od[y]'
+        # Deleting an existing item uses self.__map to find the link which is
+        # then removed by updating the links in the predecessor and successor nodes.
+        dict_delitem(self, key)
+        link_prev, link_next, key = self.__map.pop(key)
+        link_prev[1] = link_next
+        link_next[0] = link_prev
+
+    def __iter__(self):
+        'od.__iter__() <==> iter(od)'
+        root = self.__root
+        curr = root[1]
+        while curr is not root:
+            yield curr[2]
+            curr = curr[1]
+
+    def __reversed__(self):
+        'od.__reversed__() <==> reversed(od)'
+        root = self.__root
+        curr = root[0]
+        while curr is not root:
+            yield curr[2]
+            curr = curr[0]
+
+    def clear(self):
+        'od.clear() -> None.  Remove all items from od.'
+        try:
+            for node in self.__map.itervalues():
+                del node[:]
+            root = self.__root
+            root[:] = [root, root, None]
+            self.__map.clear()
+        except AttributeError:
+            pass
+        dict.clear(self)
+
+    def popitem(self, last=True):
+        '''od.popitem() -> (k, v), return and remove a (key, value) pair.
+        Pairs are returned in LIFO order if last is true or FIFO order if false.
+
+        '''
+        if not self:
+            raise KeyError('dictionary is empty')
+        root = self.__root
+        if last:
+            link = root[0]
+            link_prev = link[0]
+            link_prev[1] = root
+            root[0] = link_prev
+        else:
+            link = root[1]
+            link_next = link[1]
+            root[1] = link_next
+            link_next[0] = root
+        key = link[2]
+        del self.__map[key]
+        value = dict.pop(self, key)
+        return key, value
+
+    # -- the following methods do not depend on the internal structure --
+
+    def keys(self):
+        'od.keys() -> list of keys in od'
+        return list(self)
+
+    def values(self):
+        'od.values() -> list of values in od'
+        return [self[key] for key in self]
+
+    def items(self):
+        'od.items() -> list of (key, value) pairs in od'
+        return [(key, self[key]) for key in self]
+
+    def iterkeys(self):
+        'od.iterkeys() -> an iterator over the keys in od'
+        return iter(self)
+
+    def itervalues(self):
+        'od.itervalues -> an iterator over the values in od'
+        for k in self:
+            yield self[k]
+
+    def iteritems(self):
+        'od.iteritems -> an iterator over the (key, value) items in od'
+        for k in self:
+            yield (k, self[k])
+
+    def update(*args, **kwds):
+        '''od.update(E, **F) -> None.  Update od from dict/iterable E and F.
+
+        If E is a dict instance, does:           for k in E: od[k] = E[k]
+        If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
+        Or if E is an iterable of items, does:   for k, v in E: od[k] = v
+        In either case, this is followed by:     for k, v in F.items(): od[k] = v
+
+        '''
+        if len(args) > 2:
+            raise TypeError('update() takes at most 2 positional '
+                            'arguments (%d given)' % (len(args),))
+        elif not args:
+            raise TypeError('update() takes at least 1 argument (0 given)')
+        self = args[0]
+        # Make progressively weaker assumptions about "other"
+        other = ()
+        if len(args) == 2:
+            other = args[1]
+        if isinstance(other, dict):
+            for key in other:
+                self[key] = other[key]
+        elif hasattr(other, 'keys'):
+            for key in other.keys():
+                self[key] = other[key]
+        else:
+            for key, value in other:
+                self[key] = value
+        for key, value in kwds.items():
+            self[key] = value
+
+    __update = update  # let subclasses override update without breaking __init__
+
+    __marker = object()
+
+    def pop(self, key, default=__marker):
+        '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+        If key is not found, d is returned if given, otherwise KeyError is raised.
+
+        '''
+        if key in self:
+            result = self[key]
+            del self[key]
+            return result
+        if default is self.__marker:
+            raise KeyError(key)
+        return default
+
+    def setdefault(self, key, default=None):
+        'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
+        if key in self:
+            return self[key]
+        self[key] = default
+        return default
+
+    def __repr__(self, _repr_running={}):
+        'od.__repr__() <==> repr(od)'
+        call_key = id(self), _get_ident()
+        if call_key in _repr_running:
+            return '...'
+        _repr_running[call_key] = 1
+        try:
+            if not self:
+                return '%s()' % (self.__class__.__name__,)
+            return '%s(%r)' % (self.__class__.__name__, self.items())
+        finally:
+            del _repr_running[call_key]
+
+    def __reduce__(self):
+        'Return state information for pickling'
+        items = [[k, self[k]] for k in self]
+        inst_dict = vars(self).copy()
+        for k in vars(OrderedDict()):
+            inst_dict.pop(k, None)
+        if inst_dict:
+            return (self.__class__, (items,), inst_dict)
+        return self.__class__, (items,)
+
+    def copy(self):
+        'od.copy() -> a shallow copy of od'
+        return self.__class__(self)
+
+    @classmethod
+    def fromkeys(cls, iterable, value=None):
+        '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
+        and values equal to v (which defaults to None).
+
+        '''
+        d = cls()
+        for key in iterable:
+            d[key] = value
+        return d
+
+    def __eq__(self, other):
+        '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
+        while comparison to a regular mapping is order-insensitive.
+
+        '''
+        if isinstance(other, OrderedDict):
+            return len(self)==len(other) and self.items() == other.items()
+        return dict.__eq__(self, other)
+
+    def __ne__(self, other):
+        return not self == other
diff --git a/myenv/lib/python3.9/site-packages/passlib/utils/decor.py b/myenv/lib/python3.9/site-packages/passlib/utils/decor.py
new file mode 100644
index 0000000..9041d5d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/utils/decor.py
@@ -0,0 +1,233 @@
+"""
+passlib.utils.decor -- helper decorators & properties
+"""
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from __future__ import absolute_import, division, print_function
+import logging
+log = logging.getLogger(__name__)
+from functools import wraps, update_wrapper
+import types
+from warnings import warn
+# site
+# pkg
+from passlib.utils.compat import PY3
+# local
+__all__ = [
+    "classproperty",
+    "hybrid_method",
+
+    "memoize_single_value",
+    "memoized_property",
+
+    "deprecated_function",
+    "deprecated_method",
+]
+
+#=============================================================================
+# class-level decorators
+#=============================================================================
+class classproperty(object):
+    """Function decorator which acts like a combination of classmethod+property (limited to read-only properties)"""
+
+    def __init__(self, func):
+        self.im_func = func
+
+    def __get__(self, obj, cls):
+        return self.im_func(cls)
+
+    @property
+    def __func__(self):
+        """py3 compatible alias"""
+        return self.im_func
+
+class hybrid_method(object):
+    """
+    decorator which invokes function with class if called as class method,
+    and with object if called at instance level.
+    """
+
+    def __init__(self, func):
+        self.func = func
+        update_wrapper(self, func)
+
+    def __get__(self, obj, cls):
+        if obj is None:
+            obj = cls
+        if PY3:
+            return types.MethodType(self.func, obj)
+        else:
+            return types.MethodType(self.func, obj, cls)
+
+#=============================================================================
+# memoization
+#=============================================================================
+
+def memoize_single_value(func):
+    """
+    decorator for function which takes no args,
+    and memoizes result.  exposes a ``.clear_cache`` method
+    to clear the cached value.
+    """
+    cache = {}
+
+    @wraps(func)
+    def wrapper():
+        try:
+            return cache[True]
+        except KeyError:
+            pass
+        value = cache[True] = func()
+        return value
+
+    def clear_cache():
+        cache.pop(True, None)
+    wrapper.clear_cache = clear_cache
+
+    return wrapper
+
+class memoized_property(object):
+    """
+    decorator which invokes method once, then replaces attr with result
+    """
+    def __init__(self, func):
+        self.__func__ = func
+        self.__name__ = func.__name__
+        self.__doc__ = func.__doc__
+
+    def __get__(self, obj, cls):
+        if obj is None:
+            return self
+        value = self.__func__(obj)
+        setattr(obj, self.__name__, value)
+        return value
+
+    if not PY3:
+
+        @property
+        def im_func(self):
+            """py2 alias"""
+            return self.__func__
+
+    def clear_cache(self, obj):
+        """
+        class-level helper to clear stored value (if any).
+
+        usage: :samp:`type(self).{attr}.clear_cache(self)`
+        """
+        obj.__dict__.pop(self.__name__, None)
+
+    def peek_cache(self, obj, default=None):
+        """
+        class-level helper to peek at stored value
+
+        usage: :samp:`value = type(self).{attr}.clear_cache(self)`
+        """
+        return obj.__dict__.get(self.__name__, default)
+
+# works but not used
+##class memoized_class_property(object):
+##    """function decorator which calls function as classmethod,
+##    and replaces itself with result for current and all future invocations.
+##    """
+##    def __init__(self, func):
+##        self.im_func = func
+##
+##    def __get__(self, obj, cls):
+##        func = self.im_func
+##        value = func(cls)
+##        setattr(cls, func.__name__, value)
+##        return value
+##
+##    @property
+##    def __func__(self):
+##        "py3 compatible alias"
+
+#=============================================================================
+# deprecation
+#=============================================================================
+def deprecated_function(msg=None, deprecated=None, removed=None, updoc=True,
+                        replacement=None, _is_method=False,
+                        func_module=None):
+    """decorator to deprecate a function.
+
+    :arg msg: optional msg, default chosen if omitted
+    :kwd deprecated: version when function was first deprecated
+    :kwd removed: version when function will be removed
+    :kwd replacement: alternate name / instructions for replacing this function.
+    :kwd updoc: add notice to docstring (default ``True``)
+    """
+    if msg is None:
+        if _is_method:
+            msg = "the method %(mod)s.%(klass)s.%(name)s() is deprecated"
+        else:
+            msg = "the function %(mod)s.%(name)s() is deprecated"
+        if deprecated:
+            msg += " as of Passlib %(deprecated)s"
+        if removed:
+            msg += ", and will be removed in Passlib %(removed)s"
+        if replacement:
+            msg += ", use %s instead" % replacement
+        msg += "."
+    def build(func):
+        is_classmethod = _is_method and isinstance(func, classmethod)
+        if is_classmethod:
+            # NOTE: PY26 doesn't support "classmethod().__func__" directly...
+            func = func.__get__(None, type).__func__
+        opts = dict(
+            mod=func_module or func.__module__,
+            name=func.__name__,
+            deprecated=deprecated,
+            removed=removed,
+            )
+        if _is_method:
+            def wrapper(*args, **kwds):
+                tmp = opts.copy()
+                klass = args[0] if is_classmethod else args[0].__class__
+                tmp.update(klass=klass.__name__, mod=klass.__module__)
+                warn(msg % tmp, DeprecationWarning, stacklevel=2)
+                return func(*args, **kwds)
+        else:
+            text = msg % opts
+            def wrapper(*args, **kwds):
+                warn(text, DeprecationWarning, stacklevel=2)
+                return func(*args, **kwds)
+        update_wrapper(wrapper, func)
+        if updoc and (deprecated or removed) and \
+                   wrapper.__doc__ and ".. deprecated::" not in wrapper.__doc__:
+            txt = deprecated or ''
+            if removed or replacement:
+                txt += "\n    "
+                if removed:
+                    txt += "and will be removed in version %s" % (removed,)
+                if replacement:
+                    if removed:
+                        txt += ", "
+                    txt += "use %s instead" % replacement
+                txt += "."
+            if not wrapper.__doc__.strip(" ").endswith("\n"):
+                wrapper.__doc__ += "\n"
+            wrapper.__doc__ += "\n.. deprecated:: %s\n" % (txt,)
+        if is_classmethod:
+            wrapper = classmethod(wrapper)
+        return wrapper
+    return build
+
+def deprecated_method(msg=None, deprecated=None, removed=None, updoc=True,
+                      replacement=None):
+    """decorator to deprecate a method.
+
+    :arg msg: optional msg, default chosen if omitted
+    :kwd deprecated: version when method was first deprecated
+    :kwd removed: version when method will be removed
+    :kwd replacement: alternate name / instructions for replacing this method.
+    :kwd updoc: add notice to docstring (default ``True``)
+    """
+    return deprecated_function(msg, deprecated, removed, updoc, replacement,
+                               _is_method=True)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/utils/des.py b/myenv/lib/python3.9/site-packages/passlib/utils/des.py
new file mode 100644
index 0000000..034bfc4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/utils/des.py
@@ -0,0 +1,46 @@
+"""
+passlib.utils.des - DEPRECATED LOCATION, WILL BE REMOVED IN 2.0
+
+This has been moved to :mod:`passlib.crypto.des`.
+"""
+#=============================================================================
+# import from new location
+#=============================================================================
+from warnings import warn
+warn("the 'passlib.utils.des' module has been relocated to 'passlib.crypto.des' "
+     "as of passlib 1.7, and the old location will be removed in passlib 2.0",
+     DeprecationWarning)
+
+#=============================================================================
+# relocated functions
+#=============================================================================
+from passlib.utils.decor import deprecated_function
+from passlib.crypto.des import expand_des_key, des_encrypt_block, des_encrypt_int_block
+
+expand_des_key = deprecated_function(deprecated="1.7", removed="1.8",
+    replacement="passlib.crypto.des.expand_des_key")(expand_des_key)
+
+des_encrypt_block = deprecated_function(deprecated="1.7", removed="1.8",
+    replacement="passlib.crypto.des.des_encrypt_block")(des_encrypt_block)
+
+des_encrypt_int_block = deprecated_function(deprecated="1.7", removed="1.8",
+    replacement="passlib.crypto.des.des_encrypt_int_block")(des_encrypt_int_block)
+
+#=============================================================================
+# deprecated functions -- not carried over to passlib.crypto.des
+#=============================================================================
+import struct
+_unpack_uint64 = struct.Struct(">Q").unpack
+
+@deprecated_function(deprecated="1.6", removed="1.8",
+                     replacement="passlib.crypto.des.des_encrypt_int_block()")
+def mdes_encrypt_int_block(key, input, salt=0, rounds=1): # pragma: no cover -- deprecated & unused
+    if isinstance(key, bytes):
+        if len(key) == 7:
+            key = expand_des_key(key)
+        key = _unpack_uint64(key)[0]
+    return des_encrypt_int_block(key, input, salt, rounds)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/utils/handlers.py b/myenv/lib/python3.9/site-packages/passlib/utils/handlers.py
new file mode 100644
index 0000000..f8681fa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/utils/handlers.py
@@ -0,0 +1,2711 @@
+"""passlib.handler - code for implementing handlers, and global registry for handlers"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import with_statement
+# core
+import inspect
+import logging; log = logging.getLogger(__name__)
+import math
+import threading
+from warnings import warn
+# site
+# pkg
+import passlib.exc as exc, passlib.ifc as ifc
+from passlib.exc import MissingBackendError, PasslibConfigWarning, \
+                        PasslibHashWarning
+from passlib.ifc import PasswordHash
+from passlib.registry import get_crypt_handler
+from passlib.utils import (
+    consteq, getrandstr, getrandbytes,
+    rng, to_native_str,
+    is_crypt_handler, to_unicode,
+    MAX_PASSWORD_SIZE, accepts_keyword, as_bool,
+    update_mixin_classes)
+from passlib.utils.binary import (
+    BASE64_CHARS, HASH64_CHARS, PADDED_BASE64_CHARS,
+    HEX_CHARS, UPPER_HEX_CHARS, LOWER_HEX_CHARS,
+    ALL_BYTE_VALUES,
+)
+from passlib.utils.compat import join_byte_values, irange, u, native_string_types, \
+                                 uascii_to_str, join_unicode, unicode, str_to_uascii, \
+                                 join_unicode, unicode_or_bytes_types, PY2, int_types
+from passlib.utils.decor import classproperty, deprecated_method
+# local
+__all__ = [
+    # helpers for implementing MCF handlers
+    'parse_mc2',
+    'parse_mc3',
+    'render_mc2',
+    'render_mc3',
+
+    # framework for implementing handlers
+    'GenericHandler',
+        'StaticHandler',
+        'HasUserContext',
+        'HasRawChecksum',
+        'HasManyIdents',
+        'HasSalt',
+        'HasRawSalt',
+        'HasRounds',
+        'HasManyBackends',
+
+    # other helpers
+    'PrefixWrapper',
+
+    # TODO: a bunch of other things are commonly assumed in this namespace
+    #       (e.g. HEX_CHARS etc); need to audit uses and update this list.
+]
+
+#=============================================================================
+# constants
+#=============================================================================
+
+# deprecated aliases - will be removed after passlib 1.8
+H64_CHARS = HASH64_CHARS
+B64_CHARS = BASE64_CHARS
+PADDED_B64_CHARS = PADDED_BASE64_CHARS
+UC_HEX_CHARS = UPPER_HEX_CHARS
+LC_HEX_CHARS = LOWER_HEX_CHARS
+
+#=============================================================================
+# support functions
+#=============================================================================
+def _bitsize(count, chars):
+    """helper for bitsize() methods"""
+    if chars and count:
+        import math
+        return int(count * math.log(len(chars), 2))
+    else:
+        return 0
+
+def guess_app_stacklevel(start=1):
+    """
+    try to guess stacklevel for application warning.
+    looks for first frame not part of passlib.
+    """
+    frame = inspect.currentframe()
+    count = -start
+    try:
+        while frame:
+            name = frame.f_globals.get('__name__', "")
+            if name.startswith("passlib.tests.") or not name.startswith("passlib."):
+                return max(1, count)
+            count += 1
+            frame = frame.f_back
+        return start
+    finally:
+        del frame
+
+def warn_hash_settings_deprecation(handler, kwds):
+    warn("passing settings to %(handler)s.hash() is deprecated, and won't be supported in Passlib 2.0; "
+         "use '%(handler)s.using(**settings).hash(secret)' instead" % dict(handler=handler.name),
+         DeprecationWarning, stacklevel=guess_app_stacklevel(2))
+
+def extract_settings_kwds(handler, kwds):
+    """
+    helper to extract settings kwds from mix of context & settings kwds.
+    pops settings keys from kwds, returns them as a dict.
+    """
+    context_keys = set(handler.context_kwds)
+    return dict((key, kwds.pop(key)) for key in list(kwds) if key not in context_keys)
+
+#=============================================================================
+# parsing helpers
+#=============================================================================
+_UDOLLAR = u("$")
+_UZERO = u("0")
+
+def validate_secret(secret):
+    """ensure secret has correct type & size"""
+    if not isinstance(secret, unicode_or_bytes_types):
+        raise exc.ExpectedStringError(secret, "secret")
+    if len(secret) > MAX_PASSWORD_SIZE:
+        raise exc.PasswordSizeError(MAX_PASSWORD_SIZE)
+
+def to_unicode_for_identify(hash):
+    """convert hash to unicode for identify method"""
+    if isinstance(hash, unicode):
+        return hash
+    elif isinstance(hash, bytes):
+        # try as utf-8, but if it fails, use foolproof latin-1,
+        # since we don't really care about non-ascii chars
+        # when running identify.
+        try:
+            return hash.decode("utf-8")
+        except UnicodeDecodeError:
+            return hash.decode("latin-1")
+    else:
+        raise exc.ExpectedStringError(hash, "hash")
+
+def parse_mc2(hash, prefix, sep=_UDOLLAR, handler=None):
+    """parse hash using 2-part modular crypt format.
+
+    this expects a hash of the format :samp:`{prefix}{salt}[${checksum}]`,
+    such as md5_crypt, and parses it into salt / checksum portions.
+
+    :arg hash: the hash to parse (bytes or unicode)
+    :arg prefix: the identifying prefix (unicode)
+    :param sep: field separator (unicode, defaults to ``$``).
+    :param handler: handler class to pass to error constructors.
+
+    :returns:
+        a ``(salt, chk | None)`` tuple.
+    """
+    # detect prefix
+    hash = to_unicode(hash, "ascii", "hash")
+    assert isinstance(prefix, unicode)
+    if not hash.startswith(prefix):
+        raise exc.InvalidHashError(handler)
+
+    # parse 2-part hash or 1-part config string
+    assert isinstance(sep, unicode)
+    parts = hash[len(prefix):].split(sep)
+    if len(parts) == 2:
+        salt, chk = parts
+        return salt, chk or None
+    elif len(parts) == 1:
+        return parts[0], None
+    else:
+        raise exc.MalformedHashError(handler)
+
+def parse_mc3(hash, prefix, sep=_UDOLLAR, rounds_base=10,
+              default_rounds=None, handler=None):
+    """parse hash using 3-part modular crypt format.
+
+    this expects a hash of the format :samp:`{prefix}[{rounds}]${salt}[${checksum}]`,
+    such as sha1_crypt, and parses it into rounds / salt / checksum portions.
+    tries to convert the rounds to an integer,
+    and throws error if it has zero-padding.
+
+    :arg hash: the hash to parse (bytes or unicode)
+    :arg prefix: the identifying prefix (unicode)
+    :param sep: field separator (unicode, defaults to ``$``).
+    :param rounds_base:
+        the numeric base the rounds are encoded in (defaults to base 10).
+    :param default_rounds:
+        the default rounds value to return if the rounds field was omitted.
+        if this is ``None`` (the default), the rounds field is *required*.
+    :param handler: handler class to pass to error constructors.
+
+    :returns:
+        a ``(rounds : int, salt, chk | None)`` tuple.
+    """
+    # detect prefix
+    hash = to_unicode(hash, "ascii", "hash")
+    assert isinstance(prefix, unicode)
+    if not hash.startswith(prefix):
+        raise exc.InvalidHashError(handler)
+
+    # parse 3-part hash or 2-part config string
+    assert isinstance(sep, unicode)
+    parts = hash[len(prefix):].split(sep)
+    if len(parts) == 3:
+        rounds, salt, chk = parts
+    elif len(parts) == 2:
+        rounds, salt = parts
+        chk = None
+    else:
+        raise exc.MalformedHashError(handler)
+
+    # validate & parse rounds portion
+    if rounds.startswith(_UZERO) and rounds != _UZERO:
+        raise exc.ZeroPaddedRoundsError(handler)
+    elif rounds:
+        rounds = int(rounds, rounds_base)
+    elif default_rounds is None:
+        raise exc.MalformedHashError(handler, "empty rounds field")
+    else:
+        rounds = default_rounds
+
+    # return result
+    return rounds, salt, chk or None
+
+# def parse_mc3_long(hash, prefix, sep=_UDOLLAR, handler=None):
+#     """
+#     parse hash using 3-part modular crypt format,
+#     with complex settings string instead of simple rounds.
+#     otherwise works same as :func:`parse_mc3`
+#     """
+#     # detect prefix
+#     hash = to_unicode(hash, "ascii", "hash")
+#     assert isinstance(prefix, unicode)
+#     if not hash.startswith(prefix):
+#         raise exc.InvalidHashError(handler)
+#
+#     # parse 3-part hash or 2-part config string
+#     assert isinstance(sep, unicode)
+#     parts = hash[len(prefix):].split(sep)
+#     if len(parts) == 3:
+#         return parts
+#     elif len(parts) == 2:
+#         settings, salt = parts
+#         return settings, salt, None
+#     else:
+#         raise exc.MalformedHashError(handler)
+
+def parse_int(source, base=10, default=None, param="value", handler=None):
+    """
+    helper to parse an integer config field
+
+    :arg source: unicode source string
+    :param base: numeric base
+    :param default: optional default if source is empty
+    :param param: name of variable, for error msgs
+    :param handler: handler class, for error msgs
+    """
+    if source.startswith(_UZERO) and source != _UZERO:
+        raise exc.MalformedHashError(handler, "zero-padded %s field" % param)
+    elif source:
+        return int(source, base)
+    elif default is None:
+        raise exc.MalformedHashError(handler, "empty %s field" % param)
+    else:
+        return default
+
+#=============================================================================
+# formatting helpers
+#=============================================================================
+def render_mc2(ident, salt, checksum, sep=u("$")):
+    """format hash using 2-part modular crypt format; inverse of parse_mc2()
+
+    returns native string with format :samp:`{ident}{salt}[${checksum}]`,
+    such as used by md5_crypt.
+
+    :arg ident: identifier prefix (unicode)
+    :arg salt: encoded salt (unicode)
+    :arg checksum: encoded checksum (unicode or None)
+    :param sep: separator char (unicode, defaults to ``$``)
+
+    :returns:
+        config or hash (native str)
+    """
+    if checksum:
+        parts = [ident, salt, sep, checksum]
+    else:
+        parts = [ident, salt]
+    return uascii_to_str(join_unicode(parts))
+
+def render_mc3(ident, rounds, salt, checksum, sep=u("$"), rounds_base=10):
+    """format hash using 3-part modular crypt format; inverse of parse_mc3()
+
+    returns native string with format :samp:`{ident}[{rounds}$]{salt}[${checksum}]`,
+    such as used by sha1_crypt.
+
+    :arg ident: identifier prefix (unicode)
+    :arg rounds: rounds field (int or None)
+    :arg salt: encoded salt (unicode)
+    :arg checksum: encoded checksum (unicode or None)
+    :param sep: separator char (unicode, defaults to ``$``)
+    :param rounds_base: base to encode rounds value (defaults to base 10)
+
+    :returns:
+        config or hash (native str)
+    """
+    if rounds is None:
+        rounds = u('')
+    elif rounds_base == 16:
+        rounds = u("%x") % rounds
+    else:
+        assert rounds_base == 10
+        rounds = unicode(rounds)
+    if checksum:
+        parts = [ident, rounds, sep, salt, sep, checksum]
+    else:
+        parts = [ident, rounds, sep, salt]
+    return uascii_to_str(join_unicode(parts))
+
+
+def mask_value(value, show=4, pct=0.125, char=u"*"):
+    """
+    helper to mask contents of sensitive field.
+
+    :param value:
+        raw value (str, bytes, etc)
+
+    :param show:
+        max # of characters to remain visible
+
+    :param pct:
+        don't show more than this % of input.
+
+    :param char:
+        character to use for masking
+
+    :rtype: str | None
+    """
+    if value is None:
+        return None
+    if not isinstance(value, unicode):
+        if isinstance(value, bytes):
+            from passlib.utils.binary import ab64_encode
+            value = ab64_encode(value).decode("ascii")
+        else:
+            value = unicode(value)
+    size = len(value)
+    show = min(show, int(size * pct))
+    return value[:show] + char * (size - show)
+
+#=============================================================================
+# parameter helpers
+#=============================================================================
+
+def validate_default_value(handler, default, norm, param="value"):
+    """
+    assert helper that quickly validates default value.
+    designed to get out of the way and reduce overhead when asserts are stripped.
+    """
+    assert default is not None, "%s lacks default %s" % (handler.name, param)
+    assert norm(default) == default, "%s: invalid default %s: %r" % (handler.name, param, default)
+    return True
+
+def norm_integer(handler, value, min=1, max=None, # *
+                 param="value", relaxed=False):
+    """
+    helper to normalize and validate an integer value (e.g. rounds, salt_size)
+
+    :arg value: value provided to constructor
+    :arg default: default value if none provided. if set to ``None``, value is required.
+    :arg param: name of parameter (xxx: move to first arg?)
+    :param min: minimum value (defaults to 1)
+    :param max: maximum value (default ``None`` means no maximum)
+    :returns: validated value
+    """
+    # check type
+    if not isinstance(value, int_types):
+        raise exc.ExpectedTypeError(value, "integer", param)
+
+    # check minimum
+    if value < min:
+        msg = "%s: %s (%d) is too low, must be at least %d" % (handler.name, param, value, min)
+        if relaxed:
+            warn(msg, exc.PasslibHashWarning)
+            value = min
+        else:
+            raise ValueError(msg)
+
+    # check maximum
+    if max and value > max:
+        msg = "%s: %s (%d) is too large, cannot be more than %d" % (handler.name, param, value, max)
+        if relaxed:
+            warn(msg, exc.PasslibHashWarning)
+            value = max
+        else:
+            raise ValueError(msg)
+
+    return value
+
+#=============================================================================
+# MinimalHandler
+#=============================================================================
+class MinimalHandler(PasswordHash):
+    """
+    helper class for implementing hash handlers.
+    provides nothing besides a base implementation of the .using() subclass constructor.
+    """
+    #===================================================================
+    # class attr
+    #===================================================================
+
+    #: private flag used by using() constructor to detect if this is already a subclass.
+    _configured = False
+
+    #===================================================================
+    # configuration interface
+    #===================================================================
+
+    @classmethod
+    def using(cls, relaxed=False):
+        # NOTE: this provides the base implementation, which takes care of
+        #       creating the newly configured class. Mixins and subclasses
+        #       should wrap this, and modify the returned class to suit their options.
+        # NOTE: 'relaxed' keyword is ignored here, but parsed so that subclasses
+        #       can check for it as argument, and modify their parsing behavior accordingly.
+        name = cls.__name__
+        if not cls._configured:
+            # TODO: straighten out class naming, repr, and .name attr
+            name = "<customized %s hasher>" % name
+        return type(name, (cls,), dict(__module__=cls.__module__, _configured=True))
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class TruncateMixin(MinimalHandler):
+    """
+    PasswordHash mixin which provides a method
+    that will check if secret would be truncated,
+    and can be configured to throw an error.
+
+    .. warning::
+
+        Hashers using this mixin will generally need to override
+        the default PasswordHash.truncate_error policy of "True",
+        and will similarly want to override .truncate_verify_reject as well.
+
+        TODO: This should be done explicitly, but for now this mixin sets
+        these flags implicitly.
+    """
+
+    truncate_error = False
+    truncate_verify_reject = False
+
+    @classmethod
+    def using(cls, truncate_error=None, **kwds):
+        subcls = super(TruncateMixin, cls).using(**kwds)
+        if truncate_error is not None:
+            truncate_error = as_bool(truncate_error, param="truncate_error")
+            if truncate_error is not None:
+                subcls.truncate_error = truncate_error
+        return subcls
+
+    @classmethod
+    def _check_truncate_policy(cls, secret):
+        """
+        make sure secret won't be truncated.
+        NOTE: this should only be called for .hash(), not for .verify(),
+        which should honor the .truncate_verify_reject policy.
+        """
+        assert cls.truncate_size is not None, "truncate_size must be set by subclass"
+        if cls.truncate_error and len(secret) > cls.truncate_size:
+            raise exc.PasswordTruncateError(cls)
+
+#=============================================================================
+# GenericHandler
+#=============================================================================
+class GenericHandler(MinimalHandler):
+    """helper class for implementing hash handlers.
+
+    GenericHandler-derived classes will have (at least) the following
+    constructor options, though others may be added by mixins
+    and by the class itself:
+
+    :param checksum:
+        this should contain the digest portion of a
+        parsed hash (mainly provided when the constructor is called
+        by :meth:`from_string()`).
+        defaults to ``None``.
+
+    :param use_defaults:
+        If ``False`` (the default), a :exc:`TypeError` should be thrown
+        if any settings required by the handler were not explicitly provided.
+
+        If ``True``, the handler should attempt to provide a default for any
+        missing values. This means generate missing salts, fill in default
+        cost parameters, etc.
+
+        This is typically only set to ``True`` when the constructor
+        is called by :meth:`hash`, allowing user-provided values
+        to be handled in a more permissive manner.
+
+    :param relaxed:
+        If ``False`` (the default), a :exc:`ValueError` should be thrown
+        if any settings are out of bounds or otherwise invalid.
+
+        If ``True``, they should be corrected if possible, and a warning
+        issue. If not possible, only then should an error be raised.
+        (e.g. under ``relaxed=True``, rounds values will be clamped
+        to min/max rounds).
+
+        This is mainly used when parsing the config strings of certain
+        hashes, whose specifications implementations to be tolerant
+        of incorrect values in salt strings.
+
+    Class Attributes
+    ================
+
+    .. attribute:: ident
+
+        [optional]
+        If this attribute is filled in, the default :meth:`identify` method will use
+        it as a identifying prefix that can be used to recognize instances of this handler's
+        hash. Filling this out is recommended for speed.
+
+        This should be a unicode str.
+
+    .. attribute:: _hash_regex
+
+        [optional]
+        If this attribute is filled in, the default :meth:`identify` method
+        will use it to recognize instances of the hash. If :attr:`ident`
+        is specified, this will be ignored.
+
+        This should be a unique regex object.
+
+    .. attribute:: checksum_size
+
+        [optional]
+        Specifies the number of characters that should be expected in the checksum string.
+        If omitted, no check will be performed.
+
+    .. attribute:: checksum_chars
+
+        [optional]
+        A string listing all the characters allowed in the checksum string.
+        If omitted, no check will be performed.
+
+        This should be a unicode str.
+
+    .. attribute:: _stub_checksum
+
+        Placeholder checksum that will be used by genconfig()
+        in lieu of actually generating a hash for the empty string.
+        This should be a string of the same datatype as :attr:`checksum`.
+
+    Instance Attributes
+    ===================
+    .. attribute:: checksum
+
+        The checksum string provided to the constructor (after passing it
+        through :meth:`_norm_checksum`).
+
+    Required Subclass Methods
+    =========================
+    The following methods must be provided by handler subclass:
+
+    .. automethod:: from_string
+    .. automethod:: to_string
+    .. automethod:: _calc_checksum
+
+    Default Methods
+    ===============
+    The following methods have default implementations that should work for
+    most cases, though they may be overridden if the hash subclass needs to:
+
+    .. automethod:: _norm_checksum
+
+    .. automethod:: genconfig
+    .. automethod:: genhash
+    .. automethod:: identify
+    .. automethod:: hash
+    .. automethod:: verify
+    """
+
+    #===================================================================
+    # class attr
+    #===================================================================
+    # this must be provided by the actual class.
+    setting_kwds = None
+
+    # providing default since most classes don't use this at all.
+    context_kwds = ()
+
+    # optional prefix that uniquely identifies hash
+    ident = None
+
+    # optional regexp for recognizing hashes,
+    # used by default identify() if .ident isn't specified.
+    _hash_regex = None
+
+    # if specified, _norm_checksum will require this length
+    checksum_size = None
+
+    # if specified, _norm_checksum() will validate this
+    checksum_chars = None
+
+    # private flag used by HasRawChecksum
+    _checksum_is_bytes = False
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+    checksum = None # stores checksum
+#    use_defaults = False # whether _norm_xxx() funcs should fill in defaults.
+#    relaxed = False # when _norm_xxx() funcs should be strict about inputs
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, checksum=None, use_defaults=False, **kwds):
+        self.use_defaults = use_defaults
+        super(GenericHandler, self).__init__(**kwds)
+        if checksum is not None:
+            # XXX: do we need to set .relaxed for checksum coercion?
+            self.checksum = self._norm_checksum(checksum)
+
+    # NOTE: would like to make this classmethod, but fshp checksum size
+    #       is dependant on .variant, so leaving this as instance method.
+    def _norm_checksum(self, checksum, relaxed=False):
+        """validates checksum keyword against class requirements,
+        returns normalized version of checksum.
+        """
+        # NOTE: by default this code assumes checksum should be unicode.
+        # For classes where the checksum is raw bytes, the HasRawChecksum sets
+        # the _checksum_is_bytes flag which alters various code paths below.
+
+        # normalize to bytes / unicode
+        raw = self._checksum_is_bytes
+        if raw:
+            # NOTE: no clear route to reasonably convert unicode -> raw bytes,
+            #       so 'relaxed' does nothing here
+            if not isinstance(checksum, bytes):
+                raise exc.ExpectedTypeError(checksum, "bytes", "checksum")
+
+        elif not isinstance(checksum, unicode):
+            if isinstance(checksum, bytes) and relaxed:
+                warn("checksum should be unicode, not bytes", PasslibHashWarning)
+                checksum = checksum.decode("ascii")
+            else:
+                raise exc.ExpectedTypeError(checksum, "unicode", "checksum")
+
+        # check size
+        cc = self.checksum_size
+        if cc and len(checksum) != cc:
+            raise exc.ChecksumSizeError(self, raw=raw)
+
+        # check charset
+        if not raw:
+            cs = self.checksum_chars
+            if cs and any(c not in cs for c in checksum):
+                raise ValueError("invalid characters in %s checksum" % (self.name,))
+
+        return checksum
+
+    #===================================================================
+    # password hash api - formatting interface
+    #===================================================================
+    @classmethod
+    def identify(cls, hash):
+        # NOTE: subclasses may wish to use faster / simpler identify,
+        # and raise value errors only when an invalid (but identifiable)
+        # string is parsed
+        hash = to_unicode_for_identify(hash)
+        if not hash:
+            return False
+
+        # does class specify a known unique prefix to look for?
+        ident = cls.ident
+        if ident is not None:
+            return hash.startswith(ident)
+
+        # does class provide a regexp to use?
+        pat = cls._hash_regex
+        if pat is not None:
+            return pat.match(hash) is not None
+
+        # as fallback, try to parse hash, and see if we succeed.
+        # inefficient, but works for most cases.
+        try:
+            cls.from_string(hash)
+            return True
+        except ValueError:
+            return False
+
+    @classmethod
+    def from_string(cls, hash, **context): # pragma: no cover
+        r"""
+        return parsed instance from hash/configuration string
+
+        :param \\*\\*context:
+            context keywords to pass to constructor (if applicable).
+
+        :raises ValueError: if hash is incorrectly formatted
+
+        :returns:
+            hash parsed into components,
+            for formatting / calculating checksum.
+        """
+        raise NotImplementedError("%s must implement from_string()" % (cls,))
+
+    def to_string(self): # pragma: no cover
+        """render instance to hash or configuration string
+
+        :returns:
+            hash string with salt & digest included.
+
+            should return native string type (ascii-bytes under python 2,
+            unicode under python 3)
+        """
+        raise NotImplementedError("%s must implement from_string()" % (self.__class__,))
+
+    #===================================================================
+    # checksum generation
+    #===================================================================
+
+    # NOTE: this is only used by genconfig(), and will be removed in passlib 2.0
+    @property
+    def _stub_checksum(self):
+        """
+        placeholder used by default .genconfig() so it can avoid expense of calculating digest.
+        """
+        # used fixed string if available
+        if self.checksum_size:
+            if self._checksum_is_bytes:
+                return b'\x00' * self.checksum_size
+            if self.checksum_chars:
+                return self.checksum_chars[0] * self.checksum_size
+
+        # hack to minimize cost of calculating real checksum
+        if isinstance(self, HasRounds):
+            orig = self.rounds
+            self.rounds = self.min_rounds or 1
+            try:
+                return self._calc_checksum("")
+            finally:
+                self.rounds = orig
+
+        # final fallback, generate a real checksum
+        return self._calc_checksum("")
+
+    def _calc_checksum(self, secret): # pragma: no cover
+        """given secret; calcuate and return encoded checksum portion of hash
+        string, taking config from object state
+
+        calc checksum implementations may assume secret is always
+        either unicode or bytes, checks are performed by verify/etc.
+        """
+        raise NotImplementedError("%s must implement _calc_checksum()" %
+                                  (self.__class__,))
+
+    #===================================================================
+    #'application' interface (default implementation)
+    #===================================================================
+
+    @classmethod
+    def hash(cls, secret, **kwds):
+        if kwds:
+            # Deprecating passing any settings keywords via .hash() as of passlib 1.7; everything
+            # should use .using().hash() instead.  If any keywords are specified, presume they're
+            # context keywords by default (the common case), and extract out any settings kwds.
+            # Support for passing settings via .hash() will be removed in Passlib 2.0, along with
+            # this block of code.
+            settings = extract_settings_kwds(cls, kwds)
+            if settings:
+                warn_hash_settings_deprecation(cls, settings)
+                return cls.using(**settings).hash(secret, **kwds)
+        # NOTE: at this point, 'kwds' should just contain context_kwds subset
+        validate_secret(secret)
+        self = cls(use_defaults=True, **kwds)
+        self.checksum = self._calc_checksum(secret)
+        return self.to_string()
+
+    @classmethod
+    def verify(cls, secret, hash, **context):
+        # NOTE: classes with multiple checksum encodings should either
+        # override this method, or ensure that from_string() / _norm_checksum()
+        # ensures .checksum always uses a single canonical representation.
+        validate_secret(secret)
+        self = cls.from_string(hash, **context)
+        chk = self.checksum
+        if chk is None:
+            raise exc.MissingDigestError(cls)
+        return consteq(self._calc_checksum(secret), chk)
+
+    #===================================================================
+    # legacy crypt interface
+    #===================================================================
+
+    @deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genconfig(cls, **kwds):
+        # NOTE: 'kwds' should generally always be settings, so after this completes, *should* be empty.
+        settings = extract_settings_kwds(cls, kwds)
+        if settings:
+            return cls.using(**settings).genconfig(**kwds)
+        # NOTE: this uses optional stub checksum to bypass potentially expensive digest generation,
+        #       when caller just wants the config string.
+        self = cls(use_defaults=True, **kwds)
+        self.checksum = self._stub_checksum
+        return self.to_string()
+
+    @deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genhash(cls, secret, config, **context):
+        if config is None:
+            raise TypeError("config must be string")
+        validate_secret(secret)
+        self = cls.from_string(config, **context)
+        self.checksum = self._calc_checksum(secret)
+        return self.to_string()
+
+    #===================================================================
+    # migration interface (basde implementation)
+    #===================================================================
+
+    @classmethod
+    def needs_update(cls, hash, secret=None, **kwds):
+        # NOTE: subclasses should generally just wrap _calc_needs_update()
+        #       to check their particular keywords.
+        self = cls.from_string(hash)
+        assert isinstance(self, cls)
+        return self._calc_needs_update(secret=secret, **kwds)
+
+    def _calc_needs_update(self, secret=None):
+        """
+        internal helper for :meth:`needs_update`.
+        """
+        # NOTE: this just provides a stub, subclasses & mixins
+        #       should override this with their own tests.
+        return False
+
+    #===================================================================
+    # experimental - the following methods are not finished or tested,
+    # but way work correctly for some hashes
+    #===================================================================
+
+    #: internal helper for forcing settings to be included, even if default matches
+    _always_parse_settings = ()
+
+    #: internal helper for excluding certain setting_kwds from parsehash() result
+    _unparsed_settings = ("salt_size", "relaxed")
+
+    #: parsehash() keys that need to be sanitized
+    _unsafe_settings = ("salt", "checksum")
+
+    @classproperty
+    def _parsed_settings(cls):
+        """
+        helper for :meth:`parsehash` --
+        returns list of attributes which should be extracted by parse_hash() from hasher object.
+
+        default implementation just takes setting_kwds, and excludes _unparsed_settings
+        """
+        return tuple(key for key in cls.setting_kwds if key not in cls._unparsed_settings)
+
+    @classmethod
+    def parsehash(cls, hash, checksum=True, sanitize=False):
+        """[experimental method] parse hash into dictionary of settings.
+
+        this essentially acts as the inverse of :meth:`hash`: for most
+        cases, if ``hash = cls.hash(secret, **opts)``, then
+        ``cls.parsehash(hash)`` will return a dict matching the original options
+        (with the extra keyword *checksum*).
+
+        this method may not work correctly for all hashes,
+        and may not be available on some few. its interface may
+        change in future releases, if it's kept around at all.
+
+        :arg hash: hash to parse
+        :param checksum: include checksum keyword? (defaults to True)
+        :param sanitize: mask data for sensitive fields? (defaults to False)
+        """
+        # FIXME: this may not work for hashes with non-standard settings.
+        # XXX: how should this handle checksum/salt encoding?
+        # need to work that out for hash() anyways.
+        self = cls.from_string(hash)
+        # XXX: could split next few lines out as self._parsehash() for subclassing
+        # XXX: could try to resolve ident/variant to publically suitable alias.
+        # XXX: for v1.8, consider making "always" the default policy, and compare to class default
+        #      only for whitelisted attrs? or make this whole method obsolete by reworking
+        #      so "hasher" object & it's attrs are public?
+        UNSET = object()
+        always = self._always_parse_settings
+        kwds = dict((key, getattr(self, key)) for key in self._parsed_settings
+                    if key in always or getattr(self, key) != getattr(cls, key, UNSET))
+        if checksum and self.checksum is not None:
+            kwds['checksum'] = self.checksum
+        if sanitize:
+            if sanitize is True:
+                sanitize = mask_value
+            for key in cls._unsafe_settings:
+                if key in kwds:
+                    kwds[key] = sanitize(kwds[key])
+        return kwds
+
+    @classmethod
+    def bitsize(cls, **kwds):
+        """[experimental method] return info about bitsizes of hash"""
+        try:
+            info = super(GenericHandler, cls).bitsize(**kwds)
+        except AttributeError:
+            info = {}
+        cc = ALL_BYTE_VALUES if cls._checksum_is_bytes else cls.checksum_chars
+        if cls.checksum_size and cc:
+            # FIXME: this may overestimate size due to padding bits (e.g. bcrypt)
+            # FIXME: this will be off by 1 for case-insensitive hashes.
+            info['checksum'] = _bitsize(cls.checksum_size, cc)
+        return info
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class StaticHandler(GenericHandler):
+    """GenericHandler mixin for classes which have no settings.
+
+    This mixin assumes the entirety of the hash ise stored in the
+    :attr:`checksum` attribute; that the hash has no rounds, salt,
+    etc. This class provides the following:
+
+    * a default :meth:`genconfig` that always returns None.
+    * a default :meth:`from_string` and :meth:`to_string`
+      that store the entire hash within :attr:`checksum`,
+      after optionally stripping a constant prefix.
+
+    All that is required by subclasses is an implementation of
+    the :meth:`_calc_checksum` method.
+    """
+    # TODO: document _norm_hash()
+
+    setting_kwds = ()
+
+    # optional constant prefix subclasses can specify
+    _hash_prefix = u("")
+
+    @classmethod
+    def from_string(cls, hash, **context):
+        # default from_string() which strips optional prefix,
+        # and passes rest unchanged as checksum value.
+        hash = to_unicode(hash, "ascii", "hash")
+        hash = cls._norm_hash(hash)
+        # could enable this for extra strictness
+        ##pat = cls._hash_regex
+        ##if pat and pat.match(hash) is None:
+        ##    raise ValueError("not a valid %s hash" % (cls.name,))
+        prefix = cls._hash_prefix
+        if prefix:
+            if hash.startswith(prefix):
+                hash = hash[len(prefix):]
+            else:
+                raise exc.InvalidHashError(cls)
+        return cls(checksum=hash, **context)
+
+    @classmethod
+    def _norm_hash(cls, hash):
+        """helper for subclasses to normalize case if needed"""
+        return hash
+
+    def to_string(self):
+        return uascii_to_str(self._hash_prefix + self.checksum)
+
+    # per-subclass: stores dynamically created subclass used by _calc_checksum() stub
+    __cc_compat_hack = None
+
+    def _calc_checksum(self, secret):
+        """given secret; calcuate and return encoded checksum portion of hash
+        string, taking config from object state
+        """
+        # NOTE: prior to 1.6, StaticHandler required classes implement genhash
+        # instead of this method. so if we reach here, we try calling genhash.
+        # if that succeeds, we issue deprecation warning. if it fails,
+        # we'll just recurse back to here, but in a different instance.
+        # so before we call genhash, we create a subclass which handles
+        # throwing the NotImplementedError.
+        cls = self.__class__
+        assert cls.__module__ != __name__
+        wrapper_cls = cls.__cc_compat_hack
+        if wrapper_cls is None:
+            def inner(self, secret):
+                raise NotImplementedError("%s must implement _calc_checksum()" %
+                                          (cls,))
+            wrapper_cls = cls.__cc_compat_hack = type(cls.__name__ + "_wrapper",
+                  (cls,), dict(_calc_checksum=inner, __module__=cls.__module__))
+        context = dict((k,getattr(self,k)) for k in self.context_kwds)
+        # NOTE: passing 'config=None' here even though not currently allowed by ifc,
+        #       since it *is* allowed under the old 1.5 ifc we're checking for here.
+        try:
+            hash = wrapper_cls.genhash(secret, None, **context)
+        except TypeError as err:
+            if str(err) == "config must be string":
+                raise NotImplementedError("%s must implement _calc_checksum()" %
+                                          (cls,))
+            else:
+                raise
+        warn("%r should be updated to implement StaticHandler._calc_checksum() "
+             "instead of StaticHandler.genhash(), support for the latter "
+             "style will be removed in Passlib 1.8" % cls,
+             DeprecationWarning)
+        return str_to_uascii(hash)
+
+#=============================================================================
+# GenericHandler mixin classes
+#=============================================================================
+class HasEncodingContext(GenericHandler):
+    """helper for classes which require knowledge of the encoding used"""
+    context_kwds = ("encoding",)
+    default_encoding = "utf-8"
+
+    def __init__(self, encoding=None, **kwds):
+        super(HasEncodingContext, self).__init__(**kwds)
+        self.encoding = encoding or self.default_encoding
+
+class HasUserContext(GenericHandler):
+    """helper for classes which require a user context keyword"""
+    context_kwds = ("user",)
+
+    def __init__(self, user=None, **kwds):
+        super(HasUserContext, self).__init__(**kwds)
+        self.user = user
+
+    # XXX: would like to validate user input here, but calls to from_string()
+    # which lack context keywords would then fail; so leaving code per-handler.
+
+    # wrap funcs to accept 'user' as positional arg for ease of use.
+    @classmethod
+    def hash(cls, secret, user=None, **context):
+        return super(HasUserContext, cls).hash(secret, user=user, **context)
+
+    @classmethod
+    def verify(cls, secret, hash, user=None, **context):
+        return super(HasUserContext, cls).verify(secret, hash, user=user, **context)
+
+    @deprecated_method(deprecated="1.7", removed="2.0")
+    @classmethod
+    def genhash(cls, secret, config, user=None, **context):
+        return super(HasUserContext, cls).genhash(secret, config, user=user, **context)
+
+    # XXX: how to guess the entropy of a username?
+    #      most of these hashes are for a system (e.g. Oracle)
+    #      which has a few *very common* names and thus really low entropy;
+    #      while the rest are slightly less predictable.
+    #      need to find good reference about this.
+    ##@classmethod
+    ##def bitsize(cls, **kwds):
+    ##    info = super(HasUserContext, cls).bitsize(**kwds)
+    ##    info['user'] = xxx
+    ##    return info
+
+#------------------------------------------------------------------------
+# checksum mixins
+#------------------------------------------------------------------------
+class HasRawChecksum(GenericHandler):
+    """mixin for classes which work with decoded checksum bytes
+
+    .. todo::
+
+        document this class's usage
+    """
+    # NOTE: GenericHandler.checksum_chars is ignored by this implementation.
+
+    # NOTE: all HasRawChecksum code is currently part of GenericHandler,
+    # using private '_checksum_is_bytes' flag.
+    # this arrangement may be changed in the future.
+    _checksum_is_bytes = True
+
+#------------------------------------------------------------------------
+# ident mixins
+#------------------------------------------------------------------------
+class HasManyIdents(GenericHandler):
+    """mixin for hashes which use multiple prefix identifiers
+
+    For the hashes which may use multiple identifier prefixes,
+    this mixin adds an ``ident`` keyword to constructor.
+    Any value provided is passed through the :meth:`norm_idents` method,
+    which takes care of validating the identifier,
+    as well as allowing aliases for easier specification
+    of the identifiers by the user.
+
+    .. todo::
+
+        document this class's usage
+
+    Class Methods
+    =============
+    .. todo:: document using() and needs_update() options
+    """
+
+    #===================================================================
+    # class attrs
+    #===================================================================
+    default_ident = None # should be unicode
+    ident_values = None # should be list of unicode strings
+    ident_aliases = None # should be dict of unicode -> unicode
+        # NOTE: any aliases provided to norm_ident() as bytes
+        #       will have been converted to unicode before
+        #       comparing against this dictionary.
+
+        # NOTE: relying on test_06_HasManyIdents() to verify
+        #       these are configured correctly.
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+    ident = None
+
+    #===================================================================
+    # variant constructor
+    #===================================================================
+    @classmethod
+    def using(cls,  # keyword only...
+              default_ident=None, ident=None, **kwds):
+        """
+        This mixin adds support for the following :meth:`~passlib.ifc.PasswordHash.using` keywords:
+
+        :param default_ident:
+            default identifier that will be used by resulting customized hasher.
+
+        :param ident:
+            supported as alternate alias for **default_ident**.
+        """
+        # resolve aliases
+        if ident is not None:
+            if default_ident is not None:
+                raise TypeError("'default_ident' and 'ident' are mutually exclusive")
+            default_ident = ident
+
+        # create subclass
+        subcls = super(HasManyIdents, cls).using(**kwds)
+
+        # add custom default ident
+        # (NOTE: creates instance to run value through _norm_ident())
+        if default_ident is not None:
+            subcls.default_ident = cls(ident=default_ident, use_defaults=True).ident
+        return subcls
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, ident=None, **kwds):
+        super(HasManyIdents, self).__init__(**kwds)
+
+        # init ident
+        if ident is not None:
+            ident = self._norm_ident(ident)
+        elif self.use_defaults:
+            ident = self.default_ident
+            assert validate_default_value(self, ident, self._norm_ident, param="default_ident")
+        else:
+            raise TypeError("no ident specified")
+        self.ident = ident
+
+    @classmethod
+    def _norm_ident(cls, ident):
+        """
+        helper which normalizes & validates 'ident' value.
+        """
+        # handle bytes
+        assert ident is not None
+        if isinstance(ident, bytes):
+            ident = ident.decode('ascii')
+
+        # check if identifier is valid
+        iv = cls.ident_values
+        if ident in iv:
+            return ident
+
+        # resolve aliases, and recheck against ident_values
+        ia = cls.ident_aliases
+        if ia:
+            try:
+                value = ia[ident]
+            except KeyError:
+                pass
+            else:
+                if value in iv:
+                    return value
+
+        # failure!
+        # XXX: give this it's own error type?
+        raise ValueError("invalid ident: %r" % (ident,))
+
+    #===================================================================
+    # password hash api
+    #===================================================================
+    @classmethod
+    def identify(cls, hash):
+        hash = to_unicode_for_identify(hash)
+        return hash.startswith(cls.ident_values)
+
+    @classmethod
+    def _parse_ident(cls, hash):
+        """extract ident prefix from hash, helper for subclasses' from_string()"""
+        hash = to_unicode(hash, "ascii", "hash")
+        for ident in cls.ident_values:
+            if hash.startswith(ident):
+                return ident, hash[len(ident):]
+        raise exc.InvalidHashError(cls)
+
+    # XXX: implement a needs_update() helper that marks everything but default_ident as deprecated?
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#------------------------------------------------------------------------
+# salt mixins
+#------------------------------------------------------------------------
+class HasSalt(GenericHandler):
+    """mixin for validating salts.
+
+    This :class:`GenericHandler` mixin adds a ``salt`` keyword to the class constuctor;
+    any value provided is passed through the :meth:`_norm_salt` method,
+    which takes care of validating salt length and content,
+    as well as generating new salts if one it not provided.
+
+    :param salt:
+        optional salt string
+
+    :param salt_size:
+        optional size of salt (only used if no salt provided);
+        defaults to :attr:`default_salt_size`.
+
+    Class Attributes
+    ================
+    In order for :meth:`!_norm_salt` to do its job, the following
+    attributes should be provided by the handler subclass:
+
+    .. attribute:: min_salt_size
+
+        The minimum number of characters allowed in a salt string.
+        An :exc:`ValueError` will be throw if the provided salt is too small.
+        Defaults to ``0``.
+
+    .. attribute:: max_salt_size
+
+        The maximum number of characters allowed in a salt string.
+        By default an :exc:`ValueError` will be throw if the provided salt is
+        too large; but if ``relaxed=True``, it will be clipped and a warning
+        issued instead. Defaults to ``None``, for no maximum.
+
+    .. attribute:: default_salt_size
+
+        [required]
+        If no salt is provided, this should specify the size of the salt
+        that will be generated by :meth:`_generate_salt`. By default
+        this will fall back to :attr:`max_salt_size`.
+
+    .. attribute:: salt_chars
+
+        A string containing all the characters which are allowed in the salt
+        string. An :exc:`ValueError` will be throw if any other characters
+        are encountered. May be set to ``None`` to skip this check (but see
+        in :attr:`default_salt_chars`).
+
+    .. attribute:: default_salt_chars
+
+        [required]
+        This attribute controls the set of characters use to generate
+        *new* salt strings. By default, it mirrors :attr:`salt_chars`.
+        If :attr:`!salt_chars` is ``None``, this attribute must be specified
+        in order to generate new salts. Aside from that purpose,
+        the main use of this attribute is for hashes which wish to generate
+        salts from a restricted subset of :attr:`!salt_chars`; such as
+        accepting all characters, but only using a-z.
+
+    Instance Attributes
+    ===================
+    .. attribute:: salt
+
+        This instance attribute will be filled in with the salt provided
+        to the constructor (as adapted by :meth:`_norm_salt`)
+
+    Subclassable Methods
+    ====================
+    .. automethod:: _norm_salt
+    .. automethod:: _generate_salt
+    """
+    # TODO: document _truncate_salt()
+    # XXX: allow providing raw salt to this class, and encoding it?
+
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    min_salt_size = 0
+    max_salt_size = None
+    salt_chars = None
+
+    @classproperty
+    def default_salt_size(cls):
+        """default salt size (defaults to *max_salt_size*)"""
+        return cls.max_salt_size
+
+    @classproperty
+    def default_salt_chars(cls):
+        """charset used to generate new salt strings (defaults to *salt_chars*)"""
+        return cls.salt_chars
+
+    # private helpers for HasRawSalt, shouldn't be used by subclasses
+    _salt_is_bytes = False
+    _salt_unit = "chars"
+
+    # TODO: could support using(min/max_desired_salt_size) via using() and needs_update()
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+    salt = None
+
+    #===================================================================
+    # variant constructor
+    #===================================================================
+    @classmethod
+    def using(cls, # keyword only...
+              default_salt_size=None,
+              salt_size=None, # aliases used by CryptContext
+              salt=None,
+              **kwds):
+
+        # check for aliases used by CryptContext
+        if salt_size is not None:
+            if default_salt_size is not None:
+                raise TypeError("'salt_size' and 'default_salt_size' aliases are mutually exclusive")
+            default_salt_size = salt_size
+
+        # generate new subclass
+        subcls = super(HasSalt, cls).using(**kwds)
+
+        # replace default_rounds
+        relaxed = kwds.get("relaxed")
+        if default_salt_size is not None:
+            if isinstance(default_salt_size, native_string_types):
+                default_salt_size = int(default_salt_size)
+            subcls.default_salt_size = subcls._clip_to_valid_salt_size(default_salt_size,
+                                                                       param="salt_size",
+                                                                       relaxed=relaxed)
+
+        # if salt specified, replace _generate_salt() with fixed output.
+        # NOTE: this is mainly useful for testing / debugging.
+        if salt is not None:
+            salt = subcls._norm_salt(salt, relaxed=relaxed)
+            subcls._generate_salt = staticmethod(lambda: salt)
+
+        return subcls
+
+    # XXX: would like to combine w/ _norm_salt() code below, but doesn't quite fit.
+    @classmethod
+    def _clip_to_valid_salt_size(cls, salt_size, param="salt_size", relaxed=True):
+        """
+        internal helper --
+        clip salt size value to handler's absolute limits (min_salt_size / max_salt_size)
+
+        :param relaxed:
+            if ``True`` (the default), issues PasslibHashWarning is rounds are outside allowed range.
+            if ``False``, raises a ValueError instead.
+
+        :param param:
+            optional name of parameter to insert into error/warning messages.
+
+        :returns:
+            clipped rounds value
+        """
+        mn = cls.min_salt_size
+        mx = cls.max_salt_size
+
+        # check if salt size is fixed
+        if mn == mx:
+            if salt_size != mn:
+                msg = "%s: %s (%d) must be exactly %d" % (cls.name, param, salt_size, mn)
+                if relaxed:
+                    warn(msg, PasslibHashWarning)
+                else:
+                    raise ValueError(msg)
+            return mn
+
+        # check min size
+        if salt_size < mn:
+            msg = "%s: %s (%r) below min_salt_size (%d)" % (cls.name, param, salt_size, mn)
+            if relaxed:
+                warn(msg, PasslibHashWarning)
+                salt_size = mn
+            else:
+                raise ValueError(msg)
+
+        # check max size
+        if mx and salt_size > mx:
+            msg = "%s: %s (%r) above max_salt_size (%d)" % (cls.name, param, salt_size, mx)
+            if relaxed:
+                warn(msg, PasslibHashWarning)
+                salt_size = mx
+            else:
+                raise ValueError(msg)
+
+        return salt_size
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, salt=None, **kwds):
+        super(HasSalt, self).__init__(**kwds)
+        if salt is not None:
+            salt = self._parse_salt(salt)
+        elif self.use_defaults:
+            salt = self._generate_salt()
+            assert self._norm_salt(salt) == salt, "generated invalid salt: %r" % (salt,)
+        else:
+            raise TypeError("no salt specified")
+        self.salt = salt
+
+    # NOTE: split out mainly so sha256_crypt can subclass this
+    def _parse_salt(self, salt):
+        return self._norm_salt(salt)
+
+    @classmethod
+    def _norm_salt(cls, salt, relaxed=False):
+        """helper to normalize & validate user-provided salt string
+
+        :arg salt:
+            salt string
+
+        :raises TypeError:
+            If salt not correct type.
+
+        :raises ValueError:
+
+            * if salt contains chars that aren't in :attr:`salt_chars`.
+            * if salt contains less than :attr:`min_salt_size` characters.
+            * if ``relaxed=False`` and salt has more than :attr:`max_salt_size`
+              characters (if ``relaxed=True``, the salt is truncated
+              and a warning is issued instead).
+
+        :returns:
+            normalized salt
+        """
+        # check type
+        if cls._salt_is_bytes:
+            if not isinstance(salt, bytes):
+                raise exc.ExpectedTypeError(salt, "bytes", "salt")
+        else:
+            if not isinstance(salt, unicode):
+                # NOTE: allowing bytes under py2 so salt can be native str.
+                if isinstance(salt, bytes) and (PY2 or relaxed):
+                    salt = salt.decode("ascii")
+                else:
+                    raise exc.ExpectedTypeError(salt, "unicode", "salt")
+
+            # check charset
+            sc = cls.salt_chars
+            if sc is not None and any(c not in sc for c in salt):
+                raise ValueError("invalid characters in %s salt" % cls.name)
+
+        # check min size
+        mn = cls.min_salt_size
+        if mn and len(salt) < mn:
+            msg = "salt too small (%s requires %s %d %s)" % (cls.name,
+                        "exactly" if mn == cls.max_salt_size else ">=", mn, cls._salt_unit)
+            raise ValueError(msg)
+
+        # check max size
+        mx = cls.max_salt_size
+        if mx and len(salt) > mx:
+            msg = "salt too large (%s requires %s %d %s)" % (cls.name,
+                        "exactly" if mx == mn else "<=", mx, cls._salt_unit)
+            if relaxed:
+                warn(msg, PasslibHashWarning)
+                salt = cls._truncate_salt(salt, mx)
+            else:
+                raise ValueError(msg)
+
+        return salt
+
+    @staticmethod
+    def _truncate_salt(salt, mx):
+        # NOTE: some hashes (e.g. bcrypt) has structure within their
+        # salt string. this provides a method to override to perform
+        # the truncation properly
+        return salt[:mx]
+
+    @classmethod
+    def _generate_salt(cls):
+        """
+        helper method for _init_salt(); generates a new random salt string.
+        """
+        return getrandstr(rng, cls.default_salt_chars, cls.default_salt_size)
+
+    @classmethod
+    def bitsize(cls, salt_size=None, **kwds):
+        """[experimental method] return info about bitsizes of hash"""
+        info = super(HasSalt, cls).bitsize(**kwds)
+        if salt_size is None:
+            salt_size = cls.default_salt_size
+        # FIXME: this may overestimate size due to padding bits
+        # FIXME: this will be off by 1 for case-insensitive hashes.
+        info['salt'] = _bitsize(salt_size, cls.default_salt_chars)
+        return info
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class HasRawSalt(HasSalt):
+    """mixin for classes which use decoded salt parameter
+
+    A variant of :class:`!HasSalt` which takes in decoded bytes instead of an encoded string.
+
+    .. todo::
+
+        document this class's usage
+    """
+
+    salt_chars = ALL_BYTE_VALUES
+
+    # NOTE: all HasRawSalt code is currently part of HasSalt, using private
+    # '_salt_is_bytes' flag. this arrangement may be changed in the future.
+    _salt_is_bytes = True
+    _salt_unit = "bytes"
+
+    @classmethod
+    def _generate_salt(cls):
+        assert cls.salt_chars in [None, ALL_BYTE_VALUES]
+        return getrandbytes(rng, cls.default_salt_size)
+
+#------------------------------------------------------------------------
+# rounds mixin
+#------------------------------------------------------------------------
+class HasRounds(GenericHandler):
+    """mixin for validating rounds parameter
+
+    This :class:`GenericHandler` mixin adds a ``rounds`` keyword to the class
+    constuctor; any value provided is passed through the :meth:`_norm_rounds`
+    method, which takes care of validating the number of rounds.
+
+    :param rounds: optional number of rounds hash should use
+
+    Class Attributes
+    ================
+    In order for :meth:`!_norm_rounds` to do its job, the following
+    attributes must be provided by the handler subclass:
+
+    .. attribute:: min_rounds
+
+        The minimum number of rounds allowed. A :exc:`ValueError` will be
+        thrown if the rounds value is too small. Defaults to ``0``.
+
+    .. attribute:: max_rounds
+
+        The maximum number of rounds allowed. A :exc:`ValueError` will be
+        thrown if the rounds value is larger than this. Defaults to ``None``
+        which indicates no limit to the rounds value.
+
+    .. attribute:: default_rounds
+
+        If no rounds value is provided to constructor, this value will be used.
+        If this is not specified, a rounds value *must* be specified by the
+        application.
+
+    .. attribute:: rounds_cost
+
+        [required]
+        The ``rounds`` parameter typically encodes a cpu-time cost
+        for calculating a hash. This should be set to ``"linear"``
+        (the default) or ``"log2"``, depending on how the rounds value relates
+        to the actual amount of time that will be required.
+
+    Class Methods
+    =============
+    .. todo:: document using() and needs_update() options
+
+    Instance Attributes
+    ===================
+    .. attribute:: rounds
+
+        This instance attribute will be filled in with the rounds value provided
+        to the constructor (as adapted by :meth:`_norm_rounds`)
+
+    Subclassable Methods
+    ====================
+    .. automethod:: _norm_rounds
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #-----------------
+    # algorithm options -- not application configurable
+    #-----------------
+    # XXX: rename to min_valid_rounds / max_valid_rounds,
+    #      to clarify role compared to min_desired_rounds / max_desired_rounds?
+    min_rounds = 0
+    max_rounds = None
+    rounds_cost = "linear" # default to the common case
+
+    # hack to pass info to _CryptRecord (will be removed in passlib 2.0)
+    using_rounds_kwds = ("min_desired_rounds", "max_desired_rounds",
+                         "min_rounds", "max_rounds",
+                         "default_rounds", "vary_rounds")
+
+    #-----------------
+    # desired & default rounds -- configurable via .using() classmethod
+    #-----------------
+    min_desired_rounds = None
+    max_desired_rounds = None
+    default_rounds = None
+    vary_rounds = None
+
+    #===================================================================
+    # instance attrs
+    #===================================================================
+    rounds = None
+
+    #===================================================================
+    # variant constructor
+    #===================================================================
+    @classmethod
+    def using(cls, # keyword only...
+              min_desired_rounds=None, max_desired_rounds=None,
+              default_rounds=None, vary_rounds=None,
+              min_rounds=None, max_rounds=None, rounds=None,  # aliases used by CryptContext
+              **kwds):
+
+        # check for aliases used by CryptContext
+        if min_rounds is not None:
+            if min_desired_rounds is not None:
+                raise TypeError("'min_rounds' and 'min_desired_rounds' aliases are mutually exclusive")
+            min_desired_rounds = min_rounds
+
+        if max_rounds is not None:
+            if max_desired_rounds is not None:
+                raise TypeError("'max_rounds' and 'max_desired_rounds' aliases are mutually exclusive")
+            max_desired_rounds = max_rounds
+
+        # use 'rounds' as fallback for min, max, AND default
+        # XXX: would it be better to make 'default_rounds' and 'rounds'
+        #      aliases, and have a separate 'require_rounds' parameter for this behavior?
+        if rounds is not None:
+            if min_desired_rounds is None:
+                min_desired_rounds = rounds
+            if max_desired_rounds is None:
+                max_desired_rounds = rounds
+            if default_rounds is None:
+                default_rounds = rounds
+
+        # generate new subclass
+        subcls = super(HasRounds, cls).using(**kwds)
+
+        # replace min_desired_rounds
+        relaxed = kwds.get("relaxed")
+        if min_desired_rounds is None:
+            explicit_min_rounds = False
+            min_desired_rounds = cls.min_desired_rounds
+        else:
+            explicit_min_rounds = True
+            if isinstance(min_desired_rounds, native_string_types):
+                min_desired_rounds = int(min_desired_rounds)
+            subcls.min_desired_rounds = subcls._norm_rounds(min_desired_rounds,
+                                                            param="min_desired_rounds",
+                                                            relaxed=relaxed)
+
+        # replace max_desired_rounds
+        if max_desired_rounds is None:
+            max_desired_rounds = cls.max_desired_rounds
+        else:
+            if isinstance(max_desired_rounds, native_string_types):
+                max_desired_rounds = int(max_desired_rounds)
+            if min_desired_rounds and max_desired_rounds < min_desired_rounds:
+                msg = "%s: max_desired_rounds (%r) below min_desired_rounds (%r)" % \
+                      (subcls.name, max_desired_rounds, min_desired_rounds)
+                if explicit_min_rounds:
+                    raise ValueError(msg)
+                else:
+                    warn(msg, PasslibConfigWarning)
+                    max_desired_rounds = min_desired_rounds
+            subcls.max_desired_rounds = subcls._norm_rounds(max_desired_rounds,
+                                                            param="max_desired_rounds",
+                                                            relaxed=relaxed)
+
+        # replace default_rounds
+        if default_rounds is not None:
+            if isinstance(default_rounds, native_string_types):
+                default_rounds = int(default_rounds)
+            if min_desired_rounds and default_rounds < min_desired_rounds:
+                raise ValueError("%s: default_rounds (%r) below min_desired_rounds (%r)" %
+                                 (subcls.name, default_rounds, min_desired_rounds))
+            elif max_desired_rounds and default_rounds > max_desired_rounds:
+                raise ValueError("%s: default_rounds (%r) above max_desired_rounds (%r)" %
+                                 (subcls.name, default_rounds, max_desired_rounds))
+            subcls.default_rounds = subcls._norm_rounds(default_rounds,
+                                                        param="default_rounds",
+                                                        relaxed=relaxed)
+
+        # clip default rounds to new limits.
+        if subcls.default_rounds is not None:
+            subcls.default_rounds = subcls._clip_to_desired_rounds(subcls.default_rounds)
+
+        # replace / set vary_rounds
+        if vary_rounds is not None:
+            if isinstance(vary_rounds, native_string_types):
+                if vary_rounds.endswith("%"):
+                    vary_rounds = float(vary_rounds[:-1]) * 0.01
+                elif "." in vary_rounds:
+                    vary_rounds = float(vary_rounds)
+                else:
+                    vary_rounds = int(vary_rounds)
+            if vary_rounds < 0:
+                raise ValueError("%s: vary_rounds (%r) below 0" %
+                                 (subcls.name, vary_rounds))
+            elif isinstance(vary_rounds, float):
+                # TODO: deprecate / disallow vary_rounds=1.0
+                if vary_rounds > 1:
+                    raise ValueError("%s: vary_rounds (%r) above 1.0" %
+                                     (subcls.name, vary_rounds))
+            elif not isinstance(vary_rounds, int):
+                raise TypeError("vary_rounds must be int or float")
+            if vary_rounds:
+                warn("The 'vary_rounds' option is deprecated as of Passlib 1.7, "
+                     "and will be removed in Passlib 2.0", PasslibConfigWarning)
+            subcls.vary_rounds = vary_rounds
+            # XXX: could cache _calc_vary_rounds_range() here if needed,
+            #      but would need to handle user manually changing .default_rounds
+        return subcls
+
+    @classmethod
+    def _clip_to_desired_rounds(cls, rounds):
+        """
+        helper for :meth:`_generate_rounds` --
+        clips rounds value to desired min/max set by class (if any)
+        """
+        # NOTE: min/max_desired_rounds are None if unset.
+        # check minimum
+        mnd = cls.min_desired_rounds or 0
+        if rounds < mnd:
+            return mnd
+
+        # check maximum
+        mxd = cls.max_desired_rounds
+        if mxd and rounds > mxd:
+            return mxd
+
+        return rounds
+
+    @classmethod
+    def _calc_vary_rounds_range(cls, default_rounds):
+        """
+        helper for :meth:`_generate_rounds` --
+        returns range for vary rounds generation.
+
+        :returns:
+            (lower, upper) limits suitable for random.randint()
+        """
+        # XXX: could precalculate output of this in using() method, and save per-hash cost.
+        #      but then users patching cls.vary_rounds / cls.default_rounds would get wrong value.
+        assert default_rounds
+        vary_rounds = cls.vary_rounds
+
+        # if vary_rounds specified as % of default, convert it to actual rounds
+        def linear_to_native(value, upper):
+            return value
+        if isinstance(vary_rounds, float):
+            assert 0 <= vary_rounds <= 1 # TODO: deprecate vary_rounds==1
+            if cls.rounds_cost == "log2":
+                # special case -- have to convert default_rounds to linear scale,
+                # apply +/- vary_rounds to that, and convert back to log scale again.
+                # linear_to_native() takes care of the "convert back" step.
+                default_rounds = 1 << default_rounds
+                def linear_to_native(value, upper):
+                    if value <= 0: # log() undefined for <= 0
+                        return 0
+                    elif upper: # use smallest upper bound for start of range
+                        return int(math.log(value, 2))
+                    else: # use greatest lower bound for end of range
+                        return int(math.ceil(math.log(value, 2)))
+            # calculate integer vary rounds based on current default_rounds
+            vary_rounds = int(default_rounds * vary_rounds)
+
+        # calculate bounds based on default_rounds +/- vary_rounds
+        assert vary_rounds >= 0 and isinstance(vary_rounds, int_types)
+        lower = linear_to_native(default_rounds - vary_rounds, False)
+        upper = linear_to_native(default_rounds + vary_rounds, True)
+        return cls._clip_to_desired_rounds(lower), cls._clip_to_desired_rounds(upper)
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, rounds=None, **kwds):
+        super(HasRounds, self).__init__(**kwds)
+        if rounds is not None:
+            rounds = self._parse_rounds(rounds)
+        elif self.use_defaults:
+            rounds = self._generate_rounds()
+            assert self._norm_rounds(rounds) == rounds, "generated invalid rounds: %r" % (rounds,)
+        else:
+            raise TypeError("no rounds specified")
+        self.rounds = rounds
+
+    # NOTE: split out mainly so sha256_crypt & bsdi_crypt can subclass this
+    def _parse_rounds(self, rounds):
+        return self._norm_rounds(rounds)
+
+    @classmethod
+    def _norm_rounds(cls, rounds, relaxed=False, param="rounds"):
+        """
+        helper for normalizing rounds value.
+
+        :arg rounds:
+            an integer cost parameter.
+
+        :param relaxed:
+            if ``True`` (the default), issues PasslibHashWarning is rounds are outside allowed range.
+            if ``False``, raises a ValueError instead.
+
+        :param param:
+            optional name of parameter to insert into error/warning messages.
+
+        :raises TypeError:
+            * if ``use_defaults=False`` and no rounds is specified
+            * if rounds is not an integer.
+
+        :raises ValueError:
+
+            * if rounds is ``None`` and class does not specify a value for
+              :attr:`default_rounds`.
+            * if ``relaxed=False`` and rounds is outside bounds of
+              :attr:`min_rounds` and :attr:`max_rounds` (if ``relaxed=True``,
+              the rounds value will be clamped, and a warning issued).
+
+        :returns:
+            normalized rounds value
+        """
+        return norm_integer(cls, rounds, cls.min_rounds, cls.max_rounds,
+                            param=param, relaxed=relaxed)
+
+    @classmethod
+    def _generate_rounds(cls):
+        """
+        internal helper for :meth:`_norm_rounds` --
+        returns default rounds value, incorporating vary_rounds,
+        and any other limitations hash may place on rounds parameter.
+        """
+        # load default rounds
+        rounds = cls.default_rounds
+        if rounds is None:
+            raise TypeError("%s rounds value must be specified explicitly" % (cls.name,))
+
+        # randomly vary the rounds slightly basic on vary_rounds parameter.
+        # reads default_rounds internally.
+        if cls.vary_rounds:
+            lower, upper = cls._calc_vary_rounds_range(rounds)
+            assert lower <= rounds <= upper
+            if lower < upper:
+                rounds = rng.randint(lower, upper)
+
+        return rounds
+
+    #===================================================================
+    # migration interface
+    #===================================================================
+    def _calc_needs_update(self, **kwds):
+        """
+        mark hash as needing update if rounds is outside desired bounds.
+        """
+        min_desired_rounds = self.min_desired_rounds
+        if min_desired_rounds and self.rounds < min_desired_rounds:
+            return True
+        max_desired_rounds = self.max_desired_rounds
+        if max_desired_rounds and self.rounds > max_desired_rounds:
+            return True
+        return super(HasRounds, self)._calc_needs_update(**kwds)
+
+    #===================================================================
+    # experimental methods
+    #===================================================================
+    @classmethod
+    def bitsize(cls, rounds=None, vary_rounds=.1, **kwds):
+        """[experimental method] return info about bitsizes of hash"""
+        info = super(HasRounds, cls).bitsize(**kwds)
+        # NOTE: this essentially estimates how many bits of "salt"
+        # can be added by varying the rounds value just a little bit.
+        if cls.rounds_cost != "log2":
+            # assume rounds can be randomized within the range
+            #     rounds*(1-vary_rounds) ... rounds*(1+vary_rounds)
+            # then this can be used to encode
+            #     log2(rounds*(1+vary_rounds)-rounds*(1-vary_rounds))
+            # worth of salt-like bits. this works out to
+            #     1+log2(rounds*vary_rounds)
+            import math
+            if rounds is None:
+                rounds = cls.default_rounds
+            info['rounds'] = max(0, int(1+math.log(rounds*vary_rounds,2)))
+        ## else: # log2 rounds
+            # all bits of the rounds value are critical to choosing
+            # the time-cost, and can't be randomized.
+        return info
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#------------------------------------------------------------------------
+# other common parameters
+#------------------------------------------------------------------------
+class ParallelismMixin(GenericHandler):
+    """
+    mixin which provides common behavior for 'parallelism' setting
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+    
+    # NOTE: subclasses should add "parallelism" to their settings_kwds
+    
+    #===================================================================
+    # instance attrs
+    #===================================================================
+    
+    #: parallelism setting (class-level value used as default)
+    parallelism = 1
+    
+    #===================================================================
+    # variant constructor
+    #===================================================================
+
+    @classmethod
+    def using(cls, parallelism=None, **kwds):
+        subcls = super(ParallelismMixin, cls).using(**kwds)
+        if parallelism is not None:
+            if isinstance(parallelism, native_string_types):
+                parallelism = int(parallelism)
+            subcls.parallelism = subcls._norm_parallelism(parallelism, relaxed=kwds.get("relaxed"))
+        return subcls
+
+    #===================================================================
+    # init
+    #===================================================================
+    def __init__(self, parallelism=None, **kwds):
+        super(ParallelismMixin, self).__init__(**kwds)
+
+        # init parallelism
+        if parallelism is None:
+            assert validate_default_value(self, self.parallelism, self._norm_parallelism,
+                                          param="parallelism")
+        else:
+            self.parallelism = self._norm_parallelism(parallelism)
+
+    @classmethod
+    def _norm_parallelism(cls, parallelism, relaxed=False):
+        return norm_integer(cls, parallelism, min=1, param="parallelism", relaxed=relaxed)
+
+    #===================================================================
+    # hash migration
+    #===================================================================
+
+    def _calc_needs_update(self, **kwds):
+        """
+        mark hash as needing update if rounds is outside desired bounds.
+        """
+        # XXX: for now, marking all hashes which don't have matching parallelism setting
+        if self.parallelism != type(self).parallelism:
+            return True
+        return super(ParallelismMixin, self)._calc_needs_update(**kwds)
+
+    #===================================================================
+    # eoc
+    #===================================================================
+    
+#------------------------------------------------------------------------
+# backend mixin & helpers
+#------------------------------------------------------------------------
+
+#: global lock that must be held when changing backends.
+#: not bothering to make this more granular, as backend switching
+#: isn't a speed-critical path.  lock is needed since there is some
+#: class-level state that may be modified during a "dry run"
+_backend_lock = threading.RLock()
+
+class BackendMixin(PasswordHash):
+    """
+    PasswordHash mixin which provides generic framework for supporting multiple backends
+    within the class.
+
+    Public API
+    ----------
+
+    .. attribute:: backends
+
+        This attribute should be a tuple containing the names of the backends
+        which are supported. Two common names are ``"os_crypt"`` (if backend
+        uses :mod:`crypt`), and ``"builtin"`` (if the backend is a pure-python
+        fallback).
+
+    .. automethod:: get_backend
+    .. automethod:: set_backend
+    .. automethod:: has_backend
+
+    .. warning::
+
+        :meth:`set_backend` is intended to be called during application startup --
+        it affects global state, and switching backends is not guaranteed threadsafe.
+
+    Private API (Subclass Hooks)
+    ----------------------------
+    Subclasses should set the :attr:`!backends` attribute to a tuple of the backends
+    they wish to support.  They should also define one method:
+
+    .. classmethod:: _load_backend_{name}(dryrun=False)
+
+        One copy of this method should be defined for each :samp:`name` within :attr:`!backends`.
+
+        It will be called in order to load the backend, and should take care of whatever
+        is needed to enable the backend.  This may include importing modules, running tests,
+        issuing warnings, etc.
+
+        :param name:
+            [Optional] name of backend.
+
+        :param dryrun:
+            [Optional] True/False if currently performing a "dry run".
+
+            if True, the method should perform all setup actions *except*
+            switching the class over to the new backend.
+
+        :raises passlib.exc.PasslibSecurityError:
+            if the backend is available, but cannot be loaded due to a security issue.
+
+        :returns:
+            False if backend not available, True if backend loaded.
+
+        .. warning::
+
+            Due to the way passlib's internals are arranged,
+            backends should generally store stateful data at the class level
+            (not the module level), and be prepared to be called on subclasses
+            which may be set to a different backend from their parent.
+
+            (Idempotent module-level data such as lazy imports are fine).
+
+    .. automethod:: _finalize_backend
+
+    .. versionadded:: 1.7
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    #: list of backend names, provided by subclass.
+    backends = None
+
+    #: private attr mixin uses to hold currently loaded backend (or ``None``)
+    __backend = None
+
+    #: optional class-specific text containing suggestion about what to do
+    #: when no backends are available.
+    _no_backend_suggestion = None
+
+    #: shared attr used by set_backend() to indicate what backend it's loaded;
+    #: meaningless while not in set_backend().
+    _pending_backend = None
+
+    #: shared attr used by set_backend() to indicate if it's in "dry run" mode;
+    #: meaningless while not in set_backend().
+    _pending_dry_run = False
+
+    #===================================================================
+    # public api
+    #===================================================================
+
+    @classmethod
+    def get_backend(cls):
+        """
+        Return name of currently active backend.
+        if no backend has been loaded, loads and returns name of default backend.
+
+        :raises passlib.exc.MissingBackendError:
+            if no backends are available.
+
+        :returns:
+            name of active backend
+        """
+        if not cls.__backend:
+            cls.set_backend()
+            assert cls.__backend, "set_backend() failed to load a default backend"
+        return cls.__backend
+
+    @classmethod
+    def has_backend(cls, name="any"):
+        """
+        Check if support is currently available for specified backend.
+
+        :arg name:
+            name of backend to check for.
+            can be any string accepted by :meth:`set_backend`.
+
+        :raises ValueError:
+            if backend name is unknown
+
+        :returns:
+            * ``True`` if backend is available.
+            * ``False`` if it's available / can't be loaded.
+            * ``None`` if it's present, but won't load due to a security issue.
+        """
+        try:
+            cls.set_backend(name, dryrun=True)
+            return True
+        except (exc.MissingBackendError, exc.PasslibSecurityError):
+            return False
+
+    @classmethod
+    def set_backend(cls, name="any", dryrun=False):
+        """
+        Load specified backend.
+
+        :arg name:
+            name of backend to load, can be any of the following:
+
+            * ``"any"`` -- use current backend if one is loaded,
+              otherwise load the first available backend.
+
+            * ``"default"`` -- use the first available backend.
+
+            * any string in :attr:`backends`, loads specified backend.
+
+        :param dryrun:
+            If True, this perform all setup actions *except* switching over to the new backend.
+            (this flag is used to implement :meth:`has_backend`).
+
+            .. versionadded:: 1.7
+
+        :raises ValueError:
+            If backend name is unknown.
+
+        :raises passlib.exc.MissingBackendError:
+            If specific backend is missing;
+            or in the case of ``"any"`` / ``"default"``, if *no* backends are available.
+
+        :raises passlib.exc.PasslibSecurityError:
+
+            If ``"any"`` or ``"default"`` was specified,
+            but the only backend available has a PasslibSecurityError.
+        """
+        # check if active backend is acceptable
+        if (name == "any" and cls.__backend) or (name and name == cls.__backend):
+            return cls.__backend
+
+        # if this isn't the final subclass, whose bases we can modify,
+        # find that class, and recursively call this method for the proper class.
+        owner = cls._get_backend_owner()
+        if owner is not cls:
+            return owner.set_backend(name, dryrun=dryrun)
+
+        # pick first available backend
+        if name == "any" or name == "default":
+            default_error = None
+            for name in cls.backends:
+                try:
+                    return cls.set_backend(name, dryrun=dryrun)
+                except exc.MissingBackendError:
+                    continue
+                except exc.PasslibSecurityError as err:
+                    # backend is available, but refuses to load due to security issue.
+                    if default_error is None:
+                        default_error = err
+                    continue
+            if default_error is None:
+                msg = "%s: no backends available" % cls.name
+                if cls._no_backend_suggestion:
+                    msg += cls._no_backend_suggestion
+                default_error = exc.MissingBackendError(msg)
+            raise default_error
+
+        # validate name
+        if name not in cls.backends:
+            raise exc.UnknownBackendError(cls, name)
+
+        # hand off to _set_backend()
+        with _backend_lock:
+            orig = cls._pending_backend, cls._pending_dry_run
+            try:
+                cls._pending_backend = name
+                cls._pending_dry_run = dryrun
+                cls._set_backend(name, dryrun)
+            finally:
+                cls._pending_backend, cls._pending_dry_run = orig
+            if not dryrun:
+                cls.__backend = name
+            return name
+
+    #===================================================================
+    # subclass hooks
+    #===================================================================
+
+    @classmethod
+    def _get_backend_owner(cls):
+        """
+        return class that set_backend() should actually be modifying.
+        for SubclassBackendMixin, this may not always be the class that was invoked.
+        """
+        return cls
+
+    @classmethod
+    def _set_backend(cls, name, dryrun):
+        """
+        Internal method invoked by :meth:`set_backend`.
+        handles actual loading of specified backend.
+
+        global _backend_lock will be held for duration of this method,
+        and _pending_dry_run & _pending_backend will also be set.
+
+        should return True / False.
+        """
+        loader = cls._get_backend_loader(name)
+        kwds = {}
+        if accepts_keyword(loader, "name"):
+            kwds['name'] = name
+        if accepts_keyword(loader, "dryrun"):
+            kwds['dryrun'] = dryrun
+        ok = loader(**kwds)
+        if ok is False:
+            raise exc.MissingBackendError("%s: backend not available: %s" %
+                                          (cls.name, name))
+        elif ok is not True:
+            raise AssertionError("backend loaders must return True or False"
+                                 ": %r" % (ok,))
+
+    @classmethod
+    def _get_backend_loader(cls, name):
+        """
+        Hook called to get the specified backend's loader.
+        Should return callable which optionally takes ``"name"`` and/or
+        ``"dryrun"`` keywords.
+
+        Callable should return True if backend initialized successfully.
+
+        If backend can't be loaded, callable should return False
+        OR raise MissingBackendError directly.
+        """
+        raise NotImplementedError("implement in subclass")
+
+    @classmethod
+    def _stub_requires_backend(cls):
+        """
+        helper for subclasses to create stub methods which auto-load backend.
+        """
+        if cls.__backend:
+            raise AssertionError("%s: _finalize_backend(%r) failed to replace lazy loader" %
+                                 (cls.name, cls.__backend))
+        cls.set_backend()
+        if not cls.__backend:
+            raise AssertionError("%s: set_backend() failed to load a default backend" %
+                                 (cls.name))
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+class SubclassBackendMixin(BackendMixin):
+    """
+    variant of BackendMixin which allows backends to be implemented
+    as separate mixin classes, and dynamically switches them out.
+
+    backend classes should implement a _load_backend() classmethod,
+    which will be invoked with an optional 'dryrun' keyword,
+    and should return True or False.
+
+    _load_backend() will be invoked with ``cls`` equal to the mixin,
+    *not* the overall class.
+
+    .. versionadded:: 1.7
+    """
+    #===================================================================
+    # class attrs
+    #===================================================================
+
+    # 'backends' required by BackendMixin
+
+    #: NON-INHERITED flag that this class's bases should be modified by SubclassBackendMixin.
+    #: should only be set to True in *one* subclass in hierarchy.
+    _backend_mixin_target = False
+
+    #: map of backend name -> mixin class
+    _backend_mixin_map = None
+
+    #===================================================================
+    # backend loading
+    #===================================================================
+
+    @classmethod
+    def _get_backend_owner(cls):
+        """
+        return base class that we're actually switching backends on
+        (needed in since backends frequently modify class attrs,
+        and .set_backend may be called from a subclass).
+        """
+        if not cls._backend_mixin_target:
+            raise AssertionError("_backend_mixin_target not set")
+        for base in cls.__mro__:
+            if base.__dict__.get("_backend_mixin_target"):
+                return base
+        raise AssertionError("expected to find class w/ '_backend_mixin_target' set")
+
+    @classmethod
+    def _set_backend(cls, name, dryrun):
+        # invoke backend loader (will throw error if fails)
+        super(SubclassBackendMixin, cls)._set_backend(name, dryrun)
+
+        # sanity check call args (should trust .set_backend, but will really
+        # foul things up if this isn't the owner)
+        assert cls is cls._get_backend_owner(), "_finalize_backend() not invoked on owner"
+
+        # pick mixin class
+        mixin_map = cls._backend_mixin_map
+        assert mixin_map, "_backend_mixin_map not specified"
+        mixin_cls = mixin_map[name]
+        assert issubclass(mixin_cls, SubclassBackendMixin), "invalid mixin class"
+
+        # modify <cls> to remove existing backend mixins, and insert the new one
+        update_mixin_classes(cls,
+            add=mixin_cls,
+            remove=mixin_map.values(),
+            append=True, before=SubclassBackendMixin,
+            dryrun=dryrun,
+        )
+
+    @classmethod
+    def _get_backend_loader(cls, name):
+        assert cls._backend_mixin_map, "_backend_mixin_map not specified"
+        return cls._backend_mixin_map[name]._load_backend_mixin
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+# XXX: rename to ChecksumBackendMixin?
+class HasManyBackends(BackendMixin, GenericHandler):
+    """
+    GenericHandler mixin which provides selecting from multiple backends.
+
+    .. todo::
+
+        finish documenting this class's usage
+
+    For hashes which need to select from multiple backends,
+    depending on the host environment, this class
+    offers a way to specify alternate :meth:`_calc_checksum` methods,
+    and will dynamically chose the best one at runtime.
+
+    .. versionchanged:: 1.7
+
+        This class now derives from :class:`BackendMixin`, which abstracts
+        out a more generic framework for supporting multiple backends.
+        The public api (:meth:`!get_backend`, :meth:`!has_backend`, :meth:`!set_backend`)
+        is roughly the same.
+
+    Private API (Subclass Hooks)
+    ----------------------------
+    As of version 1.7, classes should implement :meth:`!_load_backend_{name}`, per
+    :class:`BackendMixin`.  This hook should invoke :meth:`!_set_calc_checksum_backcend`
+    to install it's backend method.
+
+    .. deprecated:: 1.7
+
+        The following api is deprecated, and will be removed in Passlib 2.0:
+
+    .. attribute:: _has_backend_{name}
+
+        private class attribute checked by :meth:`has_backend` to see if a
+        specific backend is available, it should be either ``True``
+        or ``False``. One of these should be provided by
+        the subclass for each backend listed in :attr:`backends`.
+
+    .. classmethod:: _calc_checksum_{name}
+
+        private class method that should implement :meth:`_calc_checksum`
+        for a given backend. it will only be called if the backend has
+        been selected by :meth:`set_backend`. One of these should be provided
+        by the subclass for each backend listed in :attr:`backends`.
+    """
+    #===================================================================
+    # digest calculation
+    #===================================================================
+
+    def _calc_checksum(self, secret):
+        "wrapper for backend, for common code"""
+        # NOTE: not overwriting _calc_checksum() directly, so that classes can provide
+        #       common behavior in that method,
+        #       and then invoke _calc_checksum_backend() to do the work.
+        return self._calc_checksum_backend(secret)
+
+    def _calc_checksum_backend(self, secret):
+        """
+        stub for _calc_checksum_backend() --
+        should load backend if one hasn't been loaded;
+        if one has been loaded, this method should have been monkeypatched by _finalize_backend().
+        """
+        self._stub_requires_backend()
+        return self._calc_checksum_backend(secret)
+
+    #===================================================================
+    # BackendMixin hooks
+    #===================================================================
+    @classmethod
+    def _get_backend_loader(cls, name):
+        """
+        subclassed to support legacy 1.6 HasManyBackends api.
+        (will be removed in passlib 2.0)
+        """
+        # check for 1.7 loader
+        loader = getattr(cls, "_load_backend_" + name, None)
+        if loader is None:
+            # fallback to pre-1.7 _has_backend_xxx + _calc_checksum_xxx() api
+            def loader():
+                return cls.__load_legacy_backend(name)
+        else:
+            # make sure 1.6 api isn't defined at same time
+            assert not hasattr(cls, "_has_backend_" + name), (
+                "%s: can't specify both ._load_backend_%s() "
+                "and ._has_backend_%s" % (cls.name, name, name)
+                )
+        return loader
+
+    @classmethod
+    def __load_legacy_backend(cls, name):
+        value = getattr(cls, "_has_backend_" + name)
+        warn("%s: support for ._has_backend_%s is deprecated as of Passlib 1.7, "
+             "and will be removed in Passlib 1.9/2.0, please implement "
+             "._load_backend_%s() instead" % (cls.name, name, name),
+             DeprecationWarning,
+             )
+        if value:
+            func = getattr(cls, "_calc_checksum_" + name)
+            cls._set_calc_checksum_backend(func)
+            return True
+        else:
+            return False
+
+    @classmethod
+    def _set_calc_checksum_backend(cls, func):
+        """
+        helper used by subclasses to validate & set backend-specific
+        calc checksum helper.
+        """
+        backend = cls._pending_backend
+        assert backend, "should only be called during set_backend()"
+        if not callable(func):
+            raise RuntimeError("%s: backend %r returned invalid callable: %r" %
+                               (cls.name, backend, func))
+        if not cls._pending_dry_run:
+            cls._calc_checksum_backend = func
+
+    #===================================================================
+    # eoc
+    #===================================================================
+
+#=============================================================================
+# wrappers
+#=============================================================================
+# XXX: should this inherit from PasswordHash?
+class PrefixWrapper(object):
+    """wraps another handler, adding a constant prefix.
+
+    instances of this class wrap another password hash handler,
+    altering the constant prefix that's prepended to the wrapped
+    handlers' hashes.
+
+    this is used mainly by the :doc:`ldap crypt <passlib.hash.ldap_crypt>` handlers;
+    such as :class:`~passlib.hash.ldap_md5_crypt` which wraps :class:`~passlib.hash.md5_crypt` and adds a ``{CRYPT}`` prefix.
+
+    usage::
+
+        myhandler = PrefixWrapper("myhandler", "md5_crypt", prefix="$mh$", orig_prefix="$1$")
+
+    :param name: name to assign to handler
+    :param wrapped: handler object or name of registered handler
+    :param prefix: identifying prefix to prepend to all hashes
+    :param orig_prefix: prefix to strip (defaults to '').
+    :param lazy: if True and wrapped handler is specified by name, don't look it up until needed.
+    """
+
+    #: list of attributes which should be cloned by .using()
+    _using_clone_attrs = ()
+
+    def __init__(self, name, wrapped, prefix=u(''), orig_prefix=u(''), lazy=False,
+                 doc=None, ident=None):
+        self.name = name
+        if isinstance(prefix, bytes):
+            prefix = prefix.decode("ascii")
+        self.prefix = prefix
+        if isinstance(orig_prefix, bytes):
+            orig_prefix = orig_prefix.decode("ascii")
+        self.orig_prefix = orig_prefix
+        if doc:
+            self.__doc__ = doc
+        if hasattr(wrapped, "name"):
+            self._set_wrapped(wrapped)
+        else:
+            self._wrapped_name = wrapped
+            if not lazy:
+                self._get_wrapped()
+
+        if ident is not None:
+            if ident is True:
+                # signal that prefix is identifiable in itself.
+                if prefix:
+                    ident = prefix
+                else:
+                    raise ValueError("no prefix specified")
+            if isinstance(ident, bytes):
+                ident = ident.decode("ascii")
+            # XXX: what if ident includes parts of wrapped hash's ident?
+            if ident[:len(prefix)] != prefix[:len(ident)]:
+                raise ValueError("ident must agree with prefix")
+            self._ident = ident
+
+    _wrapped_name = None
+    _wrapped_handler = None
+
+    def _set_wrapped(self, handler):
+        # check this is a valid handler
+        if 'ident' in handler.setting_kwds and self.orig_prefix:
+            # TODO: look into way to fix the issues.
+            warn("PrefixWrapper: 'orig_prefix' option may not work correctly "
+                 "for handlers which have multiple identifiers: %r" %
+                 (handler.name,), exc.PasslibRuntimeWarning)
+
+        # store reference
+        self._wrapped_handler = handler
+
+    def _get_wrapped(self):
+        handler = self._wrapped_handler
+        if handler is None:
+            handler = get_crypt_handler(self._wrapped_name)
+            self._set_wrapped(handler)
+        return handler
+
+    wrapped = property(_get_wrapped)
+
+    _ident = False
+
+    @property
+    def ident(self):
+        value = self._ident
+        if value is False:
+            value = None
+            # XXX: how will this interact with orig_prefix ?
+            #      not exposing attrs for now if orig_prefix is set.
+            if not self.orig_prefix:
+                wrapped = self.wrapped
+                ident = getattr(wrapped, "ident", None)
+                if ident is not None:
+                    value = self._wrap_hash(ident)
+            self._ident = value
+        return value
+
+    _ident_values = False
+
+    @property
+    def ident_values(self):
+        value = self._ident_values
+        if value is False:
+            value = None
+            # XXX: how will this interact with orig_prefix ?
+            #      not exposing attrs for now if orig_prefix is set.
+            if not self.orig_prefix:
+                wrapped = self.wrapped
+                idents = getattr(wrapped, "ident_values", None)
+                if idents:
+                    value = tuple(self._wrap_hash(ident) for ident in idents)
+                ##else:
+                ##    ident = self.ident
+                ##    if ident is not None:
+                ##        value = [ident]
+            self._ident_values = value
+        return value
+
+    # attrs that should be proxied
+    # XXX: change this to proxy everything that doesn't start with "_"?
+    _proxy_attrs = (
+                    "setting_kwds", "context_kwds",
+                    "default_rounds", "min_rounds", "max_rounds", "rounds_cost",
+                    "min_desired_rounds", "max_desired_rounds", "vary_rounds",
+                    "default_salt_size", "min_salt_size", "max_salt_size",
+                    "salt_chars", "default_salt_chars",
+                    "backends", "has_backend", "get_backend", "set_backend",
+                    "is_disabled", "truncate_size", "truncate_error",
+                    "truncate_verify_reject",
+
+                    # internal info attrs needed for test inspection
+                    "_salt_is_bytes",
+                    )
+
+    def __repr__(self):
+        args = [ repr(self._wrapped_name or self._wrapped_handler) ]
+        if self.prefix:
+            args.append("prefix=%r" % self.prefix)
+        if self.orig_prefix:
+            args.append("orig_prefix=%r" % self.orig_prefix)
+        args = ", ".join(args)
+        return 'PrefixWrapper(%r, %s)' % (self.name, args)
+
+    def __dir__(self):
+        attrs = set(dir(self.__class__))
+        attrs.update(self.__dict__)
+        wrapped = self.wrapped
+        attrs.update(
+            attr for attr in self._proxy_attrs
+            if hasattr(wrapped, attr)
+        )
+        return list(attrs)
+
+    def __getattr__(self, attr):
+        """proxy most attributes from wrapped class (e.g. rounds, salt size, etc)"""
+        if attr in self._proxy_attrs:
+            return getattr(self.wrapped, attr)
+        raise AttributeError("missing attribute: %r" % (attr,))
+
+    def __setattr__(self, attr, value):
+        # if proxy attr present on wrapped object,
+        # and we own it, modify *it* instead.
+        # TODO: needs UTs
+        # TODO: any other cases where wrapped is "owned"?
+        #       currently just if created via .using()
+        if attr in self._proxy_attrs and self._derived_from:
+            wrapped = self.wrapped
+            if hasattr(wrapped, attr):
+                setattr(wrapped, attr, value)
+                return
+        return object.__setattr__(self, attr, value)
+
+    def _unwrap_hash(self, hash):
+        """given hash belonging to wrapper, return orig version"""
+        # NOTE: assumes hash has been validated as unicode already
+        prefix = self.prefix
+        if not hash.startswith(prefix):
+            raise exc.InvalidHashError(self)
+        # NOTE: always passing to handler as unicode, to save reconversion
+        return self.orig_prefix + hash[len(prefix):]
+
+    def _wrap_hash(self, hash):
+        """given orig hash; return one belonging to wrapper"""
+        # NOTE: should usually be native string.
+        # (which does mean extra work under py2, but not py3)
+        if isinstance(hash, bytes):
+            hash = hash.decode("ascii")
+        orig_prefix = self.orig_prefix
+        if not hash.startswith(orig_prefix):
+            raise exc.InvalidHashError(self.wrapped)
+        wrapped = self.prefix + hash[len(orig_prefix):]
+        return uascii_to_str(wrapped)
+
+    #: set by _using(), helper for test harness' handler_derived_from()
+    _derived_from = None
+
+    def using(self, **kwds):
+        # generate subclass of wrapped handler
+        subcls = self.wrapped.using(**kwds)
+        assert subcls is not self.wrapped
+        # then create identical wrapper which wraps the new subclass.
+        wrapper = PrefixWrapper(self.name, subcls, prefix=self.prefix, orig_prefix=self.orig_prefix)
+        wrapper._derived_from = self
+        for attr in self._using_clone_attrs:
+            setattr(wrapper, attr, getattr(self, attr))
+        return wrapper
+
+    def needs_update(self, hash, **kwds):
+        hash = self._unwrap_hash(hash)
+        return self.wrapped.needs_update(hash, **kwds)
+
+    def identify(self, hash):
+        hash = to_unicode_for_identify(hash)
+        if not hash.startswith(self.prefix):
+            return False
+        hash = self._unwrap_hash(hash)
+        return self.wrapped.identify(hash)
+
+    @deprecated_method(deprecated="1.7", removed="2.0")
+    def genconfig(self, **kwds):
+        config = self.wrapped.genconfig(**kwds)
+        if config is None:
+            raise RuntimeError(".genconfig() must return a string, not None")
+        return self._wrap_hash(config)
+
+    @deprecated_method(deprecated="1.7", removed="2.0")
+    def genhash(self, secret, config, **kwds):
+        # TODO: under 2.0, throw TypeError if config is None, rather than passing it through
+        if config is not None:
+            config = to_unicode(config, "ascii", "config/hash")
+            config = self._unwrap_hash(config)
+        return self._wrap_hash(self.wrapped.genhash(secret, config, **kwds))
+
+    @deprecated_method(deprecated="1.7", removed="2.0", replacement=".hash()")
+    def encrypt(self, secret, **kwds):
+        return self.hash(secret, **kwds)
+
+    def hash(self, secret, **kwds):
+        return self._wrap_hash(self.wrapped.hash(secret, **kwds))
+
+    def verify(self, secret, hash, **kwds):
+        hash = to_unicode(hash, "ascii", "hash")
+        hash = self._unwrap_hash(hash)
+        return self.wrapped.verify(secret, hash, **kwds)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/utils/md4.py b/myenv/lib/python3.9/site-packages/passlib/utils/md4.py
new file mode 100644
index 0000000..ef3f7a5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/utils/md4.py
@@ -0,0 +1,29 @@
+"""
+passlib.utils.md4 - DEPRECATED MODULE, WILL BE REMOVED IN 2.0
+
+MD4 should now be looked up through ``passlib.crypto.digest.lookup_hash("md4").const``,
+which provides unified handling stdlib implementation (if present).
+"""
+#=============================================================================
+# issue deprecation warning for module
+#=============================================================================
+from warnings import warn
+warn("the module 'passlib.utils.md4' is deprecated as of Passlib 1.7, "
+     "and will be removed in Passlib 2.0, please use "
+     "'lookup_hash(\"md4\").const()' from 'passlib.crypto' instead",
+     DeprecationWarning)
+
+#=============================================================================
+# backwards compat exports
+#=============================================================================
+__all__ = ["md4"]
+
+# this should use hashlib version if available,
+# and fall back to builtin version.
+from passlib.crypto.digest import lookup_hash
+md4 = lookup_hash("md4").const
+del lookup_hash
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/utils/pbkdf2.py b/myenv/lib/python3.9/site-packages/passlib/utils/pbkdf2.py
new file mode 100644
index 0000000..273143b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/utils/pbkdf2.py
@@ -0,0 +1,193 @@
+"""passlib.pbkdf2 - PBKDF2 support
+
+this module is getting increasingly poorly named.
+maybe rename to "kdf" since it's getting more key derivation functions added.
+"""
+#=============================================================================
+# imports
+#=============================================================================
+from __future__ import division
+# core
+import logging; log = logging.getLogger(__name__)
+# site
+# pkg
+from passlib.exc import ExpectedTypeError
+from passlib.utils.decor import deprecated_function
+from passlib.utils.compat import native_string_types
+from passlib.crypto.digest import norm_hash_name, lookup_hash, pbkdf1 as _pbkdf1, pbkdf2_hmac, compile_hmac
+# local
+__all__ = [
+    # hash utils
+    "norm_hash_name",
+
+    # prf utils
+    "get_prf",
+
+    # kdfs
+    "pbkdf1",
+    "pbkdf2",
+]
+
+#=============================================================================
+# issue deprecation warning for module
+#=============================================================================
+from warnings import warn
+
+warn("the module 'passlib.utils.pbkdf2' is deprecated as of Passlib 1.7, "
+     "and will be removed in Passlib 2.0, please use 'passlib.crypto' instead",
+     DeprecationWarning)
+
+#=============================================================================
+# hash helpers
+#=============================================================================
+
+norm_hash_name = deprecated_function(deprecated="1.7", removed="1.8", func_module=__name__,
+    replacement="passlib.crypto.digest.norm_hash_name")(norm_hash_name)
+
+#=============================================================================
+# prf lookup
+#=============================================================================
+
+#: cache mapping prf name/func -> (func, digest_size)
+_prf_cache = {}
+
+#: list of accepted prefixes
+_HMAC_PREFIXES = ("hmac_", "hmac-")
+
+def get_prf(name):
+    """Lookup pseudo-random family (PRF) by name.
+
+    :arg name:
+        This must be the name of a recognized prf.
+        Currently this only recognizes names with the format
+        :samp:`hmac-{digest}`, where :samp:`{digest}`
+        is the name of a hash function such as
+        ``md5``, ``sha256``, etc.
+
+        todo: restore text about callables.
+
+    :raises ValueError: if the name is not known
+    :raises TypeError: if the name is not a callable or string
+
+    :returns:
+        a tuple of :samp:`({prf_func}, {digest_size})`, where:
+
+        * :samp:`{prf_func}` is a function implementing
+          the specified PRF, and has the signature
+          ``prf_func(secret, message) -> digest``.
+
+        * :samp:`{digest_size}` is an integer indicating
+          the number of bytes the function returns.
+
+    Usage example::
+
+        >>> from passlib.utils.pbkdf2 import get_prf
+        >>> hmac_sha256, dsize = get_prf("hmac-sha256")
+        >>> hmac_sha256
+        <function hmac_sha256 at 0x1e37c80>
+        >>> dsize
+        32
+        >>> digest = hmac_sha256('password', 'message')
+
+    .. deprecated:: 1.7
+
+        This function is deprecated, and will be removed in Passlib 2.0.
+        This only related replacement is :func:`passlib.crypto.digest.compile_hmac`.
+    """
+    global _prf_cache
+    if name in _prf_cache:
+        return _prf_cache[name]
+    if isinstance(name, native_string_types):
+        if not name.startswith(_HMAC_PREFIXES):
+            raise ValueError("unknown prf algorithm: %r" % (name,))
+        digest = lookup_hash(name[5:]).name
+        def hmac(key, msg):
+            return compile_hmac(digest, key)(msg)
+        record = (hmac, hmac.digest_info.digest_size)
+    elif callable(name):
+        # assume it's a callable, use it directly
+        digest_size = len(name(b'x', b'y'))
+        record = (name, digest_size)
+    else:
+        raise ExpectedTypeError(name, "str or callable", "prf name")
+    _prf_cache[name] = record
+    return record
+
+#=============================================================================
+# pbkdf1 support
+#=============================================================================
+def pbkdf1(secret, salt, rounds, keylen=None, hash="sha1"):
+    """pkcs#5 password-based key derivation v1.5
+
+    :arg secret: passphrase to use to generate key
+    :arg salt: salt string to use when generating key
+    :param rounds: number of rounds to use to generate key
+    :arg keylen: number of bytes to generate (if ``None``, uses digest's native size)
+    :param hash:
+        hash function to use. must be name of a hash recognized by hashlib.
+
+    :returns:
+        raw bytes of generated key
+
+    .. note::
+
+        This algorithm has been deprecated, new code should use PBKDF2.
+        Among other limitations, ``keylen`` cannot be larger
+        than the digest size of the specified hash.
+
+    .. deprecated:: 1.7
+
+        This has been relocated to :func:`passlib.crypto.digest.pbkdf1`,
+        and this version will be removed in Passlib 2.0.
+        *Note the call signature has changed.*
+    """
+    return _pbkdf1(hash, secret, salt, rounds, keylen)
+
+#=============================================================================
+# pbkdf2
+#=============================================================================
+def pbkdf2(secret, salt, rounds, keylen=None, prf="hmac-sha1"):
+    """pkcs#5 password-based key derivation v2.0
+
+    :arg secret:
+        passphrase to use to generate key
+
+    :arg salt:
+        salt string to use when generating key
+
+    :param rounds:
+        number of rounds to use to generate key
+
+    :arg keylen:
+        number of bytes to generate.
+        if set to ``None``, will use digest size of selected prf.
+
+    :param prf:
+        psuedo-random family to use for key strengthening.
+        this must be a string starting with ``"hmac-"``, followed by the name of a known digest.
+        this defaults to ``"hmac-sha1"`` (the only prf explicitly listed in
+        the PBKDF2 specification)
+
+        .. rst-class:: warning
+
+        .. versionchanged 1.7:
+
+            This argument no longer supports arbitrary PRF callables --
+            These were rarely / never used, and created too many unwanted codepaths.
+
+    :returns:
+        raw bytes of generated key
+
+    .. deprecated:: 1.7
+
+        This has been deprecated in favor of :func:`passlib.crypto.digest.pbkdf2_hmac`,
+        and will be removed in Passlib 2.0.  *Note the call signature has changed.*
+    """
+    if callable(prf) or (isinstance(prf, native_string_types) and not prf.startswith(_HMAC_PREFIXES)):
+        raise NotImplementedError("non-HMAC prfs are not supported as of Passlib 1.7")
+    digest = prf[5:]
+    return pbkdf2_hmac(digest, secret, salt, rounds, keylen)
+
+#=============================================================================
+# eof
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/passlib/win32.py b/myenv/lib/python3.9/site-packages/passlib/win32.py
new file mode 100644
index 0000000..223dd6c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/passlib/win32.py
@@ -0,0 +1,68 @@
+"""passlib.win32 - MS Windows support - DEPRECATED, WILL BE REMOVED IN 1.8
+
+the LMHASH and NTHASH algorithms are used in various windows related contexts,
+but generally not in a manner compatible with how passlib is structured.
+
+in particular, they have no identifying marks, both being
+32 bytes of binary data. thus, they can't be easily identified
+in a context with other hashes, so a CryptHandler hasn't been defined for them.
+
+this module provided two functions to aid in any use-cases which exist.
+
+.. warning::
+
+    these functions should not be used for new code unless an existing
+    system requires them, they are both known broken,
+    and are beyond insecure on their own.
+
+.. autofunction:: raw_lmhash
+.. autofunction:: raw_nthash
+
+See also :mod:`passlib.hash.nthash`.
+"""
+
+from warnings import warn
+warn("the 'passlib.win32' module is deprecated, and will be removed in "
+     "passlib 1.8; please use the 'passlib.hash.nthash' and "
+     "'passlib.hash.lmhash' classes instead.",
+     DeprecationWarning)
+
+#=============================================================================
+# imports
+#=============================================================================
+# core
+from binascii import hexlify
+# site
+# pkg
+from passlib.utils.compat import unicode
+from passlib.crypto.des import des_encrypt_block
+from passlib.hash import nthash
+# local
+__all__ = [
+    "nthash",
+    "raw_lmhash",
+    "raw_nthash",
+]
+#=============================================================================
+# helpers
+#=============================================================================
+LM_MAGIC = b"KGS!@#$%"
+
+raw_nthash = nthash.raw_nthash
+
+def raw_lmhash(secret, encoding="ascii", hex=False):
+    """encode password using des-based LMHASH algorithm; returns string of raw bytes, or unicode hex"""
+    # NOTE: various references say LMHASH uses the OEM codepage of the host
+    #       for its encoding. until a clear reference is found,
+    #       as well as a path for getting the encoding,
+    #       letting this default to "ascii" to prevent incorrect hashes
+    #       from being made w/o user explicitly choosing an encoding.
+    if isinstance(secret, unicode):
+        secret = secret.encode(encoding)
+    ns = secret.upper()[:14] + b"\x00" * (14-len(secret))
+    out = des_encrypt_block(ns[:7], LM_MAGIC) + des_encrypt_block(ns[7:], LM_MAGIC)
+    return hexlify(out).decode("ascii") if hex else out
+
+#=============================================================================
+# eoc
+#=============================================================================
diff --git a/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/LICENSE
new file mode 100644
index 0000000..14e2f77
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/LICENSE
@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in 
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.
diff --git a/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/METADATA
new file mode 100644
index 0000000..2d38736
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/METADATA
@@ -0,0 +1,411 @@
+Metadata-Version: 2.1
+Name: pathspec
+Version: 0.9.0
+Summary: Utility library for gitignore style pattern matching of file paths.
+Home-page: https://github.com/cpburnz/python-path-specification
+Author: Caleb P. Burns
+Author-email: cpburnz@gmail.com
+License: MPL 2.0
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7
+Description-Content-Type: text/x-rst
+
+
+*pathspec*: Path Specification
+==============================
+
+*pathspec* is a utility library for pattern matching of file paths. So
+far this only includes Git's wildmatch pattern matching which itself is
+derived from Rsync's wildmatch. Git uses wildmatch for its `gitignore`_
+files.
+
+.. _`gitignore`: http://git-scm.com/docs/gitignore
+
+
+Tutorial
+--------
+
+Say you have a "Projects" directory and you want to back it up, but only
+certain files, and ignore others depending on certain conditions::
+
+	>>> import pathspec
+	>>> # The gitignore-style patterns for files to select, but we're including
+	>>> # instead of ignoring.
+	>>> spec = """
+	...
+	... # This is a comment because the line begins with a hash: "#"
+	...
+	... # Include several project directories (and all descendants) relative to
+	... # the current directory. To reference a directory you must end with a
+	... # slash: "/"
+	... /project-a/
+	... /project-b/
+	... /project-c/
+	...
+	... # Patterns can be negated by prefixing with exclamation mark: "!"
+	...
+	... # Ignore temporary files beginning or ending with "~" and ending with
+	... # ".swp".
+	... !~*
+	... !*~
+	... !*.swp
+	...
+	... # These are python projects so ignore compiled python files from
+	... # testing.
+	... !*.pyc
+	...
+	... # Ignore the build directories but only directly under the project
+	... # directories.
+	... !/*/build/
+	...
+	... """
+
+We want to use the ``GitWildMatchPattern`` class to compile our patterns. The
+``PathSpec`` class provides an interface around pattern implementations::
+
+	>>> spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, spec.splitlines())
+
+That may be a mouthful but it allows for additional patterns to be implemented
+in the future without them having to deal with anything but matching the paths
+sent to them. ``GitWildMatchPattern`` is the implementation of the actual
+pattern which internally gets converted into a regular expression.
+``PathSpec`` is a simple wrapper around a list of compiled patterns.
+
+To make things simpler, we can use the registered name for a pattern class
+instead of always having to provide a reference to the class itself. The
+``GitWildMatchPattern`` class is registered as **gitwildmatch**::
+
+	>>> spec = pathspec.PathSpec.from_lines('gitwildmatch', spec.splitlines())
+
+If we wanted to manually compile the patterns we can just do the following::
+
+	>>> patterns = map(pathspec.patterns.GitWildMatchPattern, spec.splitlines())
+	>>> spec = PathSpec(patterns)
+
+``PathSpec.from_lines()`` is simply a class method which does just that.
+
+If you want to load the patterns from file, you can pass the file instance
+directly as well::
+
+	>>> with open('patterns.list', 'r') as fh:
+	>>>     spec = pathspec.PathSpec.from_lines('gitwildmatch', fh)
+
+You can perform matching on a whole directory tree with::
+
+	>>> matches = spec.match_tree('path/to/directory')
+
+Or you can perform matching on a specific set of file paths with::
+
+	>>> matches = spec.match_files(file_paths)
+
+Or check to see if an individual file matches::
+
+	>>> is_matched = spec.match_file(file_path)
+
+
+License
+-------
+
+*pathspec* is licensed under the `Mozilla Public License Version 2.0`_. See
+`LICENSE`_ or the `FAQ`_ for more information.
+
+In summary, you may use *pathspec* with any closed or open source project
+without affecting the license of the larger work so long as you:
+
+- give credit where credit is due,
+
+- and release any custom changes made to *pathspec*.
+
+.. _`Mozilla Public License Version 2.0`: http://www.mozilla.org/MPL/2.0
+.. _`LICENSE`: LICENSE
+.. _`FAQ`: http://www.mozilla.org/MPL/2.0/FAQ.html
+
+
+Source
+------
+
+The source code for *pathspec* is available from the GitHub repo
+`cpburnz/python-path-specification`_.
+
+.. _`cpburnz/python-path-specification`: https://github.com/cpburnz/python-path-specification
+
+
+Installation
+------------
+
+*pathspec* requires the following packages:
+
+- `setuptools`_
+
+*pathspec* can be installed from source with::
+
+	python setup.py install
+
+*pathspec* is also available for install through `PyPI`_::
+
+	pip install pathspec
+
+.. _`setuptools`: https://pypi.python.org/pypi/setuptools
+.. _`PyPI`: http://pypi.python.org/pypi/pathspec
+
+
+Documentation
+-------------
+
+Documentation for *pathspec* is available on `Read the Docs`_.
+
+.. _`Read the Docs`: http://python-path-specification.readthedocs.io
+
+
+Other Languages
+---------------
+
+*pathspec* is also available as a `Ruby gem`_.
+
+.. _`Ruby gem`: https://github.com/highb/pathspec-ruby
+
+
+Change History
+==============
+
+0.9.0 (2021-07-17)
+------------------
+
+- `Issue #44`_/`Issue #50`_: Raise `GitWildMatchPatternError` for invalid git patterns.
+- `Issue #45`_: Fix for duplicate leading double-asterisk, and edge cases.
+- `Issue #46`_: Fix matching absolute paths.
+- API change: `util.normalize_files()` now returns a `Dict[str, List[pathlike]]` instead of a `Dict[str, pathlike]`.
+- Added type hinting.
+
+.. _`Issue #44`: https://github.com/cpburnz/python-path-specification/issues/44
+.. _`Issue #45`: https://github.com/cpburnz/python-path-specification/pull/45
+.. _`Issue #46`: https://github.com/cpburnz/python-path-specification/issues/46
+.. _`Issue #50`: https://github.com/cpburnz/python-path-specification/pull/50
+
+
+0.8.1 (2020-11-07)
+------------------
+
+- `Issue #43`_: Add support for addition operator.
+
+.. _`Issue #43`: https://github.com/cpburnz/python-path-specification/pull/43
+
+
+0.8.0 (2020-04-09)
+------------------
+
+- `Issue #30`_: Expose what patterns matched paths. Added `util.detailed_match_files()`.
+- `Issue #31`_: `match_tree()` doesn't return symlinks.
+- `Issue #34`_: Support `pathlib.Path`\ s.
+- Add `PathSpec.match_tree_entries` and `util.iter_tree_entries()` to support directories and symlinks.
+- API change: `match_tree()` has been renamed to `match_tree_files()`. The old name `match_tree()` is still available as an alias.
+- API change: `match_tree_files()` now returns symlinks. This is a bug fix but it will change the returned results.
+
+.. _`Issue #30`: https://github.com/cpburnz/python-path-specification/issues/30
+.. _`Issue #31`: https://github.com/cpburnz/python-path-specification/issues/31
+.. _`Issue #34`: https://github.com/cpburnz/python-path-specification/issues/34
+
+
+0.7.0 (2019-12-27)
+------------------
+
+- `Issue #28`_: Add support for Python 3.8, and drop Python 3.4.
+- `Issue #29`_: Publish bdist wheel.
+
+.. _`Issue #28`: https://github.com/cpburnz/python-path-specification/pull/28
+.. _`Issue #29`: https://github.com/cpburnz/python-path-specification/pull/29
+
+
+0.6.0 (2019-10-03)
+------------------
+
+- `Issue #24`_: Drop support for Python 2.6, 3.2, and 3.3.
+- `Issue #25`_: Update README.rst.
+- `Issue #26`_: Method to escape gitwildmatch.
+
+.. _`Issue #24`: https://github.com/cpburnz/python-path-specification/pull/24
+.. _`Issue #25`: https://github.com/cpburnz/python-path-specification/pull/25
+.. _`Issue #26`: https://github.com/cpburnz/python-path-specification/pull/26
+
+
+0.5.9 (2018-09-15)
+------------------
+
+- Fixed file system error handling.
+
+
+0.5.8 (2018-09-15)
+------------------
+
+- Improved type checking.
+- Created scripts to test Python 2.6 because Tox removed support for it.
+- Improved byte string handling in Python 3.
+- `Issue #22`_: Handle dangling symlinks.
+
+.. _`Issue #22`: https://github.com/cpburnz/python-path-specification/issues/22
+
+
+0.5.7 (2018-08-14)
+------------------
+
+- `Issue #21`_: Fix collections deprecation warning.
+
+.. _`Issue #21`: https://github.com/cpburnz/python-path-specification/issues/21
+
+
+0.5.6 (2018-04-06)
+------------------
+
+- Improved unit tests.
+- Improved type checking.
+- `Issue #20`_: Support current directory prefix.
+
+.. _`Issue #20`: https://github.com/cpburnz/python-path-specification/issues/20
+
+
+0.5.5 (2017-09-09)
+------------------
+
+- Add documentation link to README.
+
+
+0.5.4 (2017-09-09)
+------------------
+
+- `Issue #17`_: Add link to Ruby implementation of *pathspec*.
+- Add sphinx documentation.
+
+.. _`Issue #17`: https://github.com/cpburnz/python-path-specification/pull/17
+
+
+0.5.3 (2017-07-01)
+------------------
+
+- `Issue #14`_: Fix byte strings for Python 3.
+- `Issue #15`_: Include "LICENSE" in source package.
+- `Issue #16`_: Support Python 2.6.
+
+.. _`Issue #14`: https://github.com/cpburnz/python-path-specification/issues/14
+.. _`Issue #15`: https://github.com/cpburnz/python-path-specification/pull/15
+.. _`Issue #16`: https://github.com/cpburnz/python-path-specification/issues/16
+
+
+0.5.2 (2017-04-04)
+------------------
+
+- Fixed change log.
+
+
+0.5.1 (2017-04-04)
+------------------
+
+- `Issue #13`_: Add equality methods to `PathSpec` and `RegexPattern`.
+
+.. _`Issue #13`: https://github.com/cpburnz/python-path-specification/pull/13
+
+
+0.5.0 (2016-08-22)
+------------------
+
+- `Issue #12`_: Add `PathSpec.match_file()`.
+- Renamed `gitignore.GitIgnorePattern` to `patterns.gitwildmatch.GitWildMatchPattern`.
+- Deprecated `gitignore.GitIgnorePattern`.
+
+.. _`Issue #12`: https://github.com/cpburnz/python-path-specification/issues/12
+
+
+0.4.0 (2016-07-15)
+------------------
+
+- `Issue #11`_: Support converting patterns into regular expressions without compiling them.
+- API change: Subclasses of `RegexPattern` should implement `pattern_to_regex()`.
+
+.. _`Issue #11`: https://github.com/cpburnz/python-path-specification/issues/11
+
+
+0.3.4 (2015-08-24)
+------------------
+
+- `Issue #7`_: Fixed non-recursive links.
+- `Issue #8`_: Fixed edge cases in gitignore patterns.
+- `Issue #9`_: Fixed minor usage documentation.
+- Fixed recursion detection.
+- Fixed trivial incompatibility with Python 3.2.
+
+.. _`Issue #7`: https://github.com/cpburnz/python-path-specification/pull/7
+.. _`Issue #8`: https://github.com/cpburnz/python-path-specification/pull/8
+.. _`Issue #9`: https://github.com/cpburnz/python-path-specification/pull/9
+
+
+0.3.3 (2014-11-21)
+------------------
+
+- Improved documentation.
+
+
+0.3.2 (2014-11-08)
+------------------
+
+- `Issue #5`_: Use tox for testing.
+- `Issue #6`_: Fixed matching Windows paths.
+- Improved documentation.
+- API change: `spec.match_tree()` and `spec.match_files()` now return iterators instead of sets.
+
+.. _`Issue #5`: https://github.com/cpburnz/python-path-specification/pull/5
+.. _`Issue #6`: https://github.com/cpburnz/python-path-specification/issues/6
+
+
+0.3.1 (2014-09-17)
+------------------
+
+- Updated README.
+
+
+0.3.0 (2014-09-17)
+------------------
+
+- `Issue #3`_: Fixed trailing slash in gitignore patterns.
+- `Issue #4`_: Fixed test for trailing slash in gitignore patterns.
+- Added registered patterns.
+
+.. _`Issue #3`: https://github.com/cpburnz/python-path-specification/pull/3
+.. _`Issue #4`: https://github.com/cpburnz/python-path-specification/pull/4
+
+
+0.2.2 (2013-12-17)
+------------------
+
+- Fixed setup.py.
+
+
+0.2.1 (2013-12-17)
+------------------
+
+- Added tests.
+- Fixed comment gitignore patterns.
+- Fixed relative path gitignore patterns.
+
+
+0.2.0 (2013-12-07)
+------------------
+
+- Initial release.
+
+
diff --git a/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/RECORD
new file mode 100644
index 0000000..adf0f8c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/RECORD
@@ -0,0 +1,18 @@
+pathspec/__init__.py,sha256=72Wc9H_-xRaisgbnz3pNf8bJJlFu6ZP3MMEYVvlIowk,1085
+pathspec/_meta.py,sha256=MyOTCY28N1FOIxhPQBNxXei9oiQEvzVISrwnyCIAb-0,1617
+pathspec/compat.py,sha256=G0_QT3NRlFTcrV1bhx9G1qIvBdmnaWh-f4VrcpXzfhc,830
+pathspec/pathspec.py,sha256=J2lrhvT1iqkZ5rSrTvMEOjuLBkdzl2QVZkJYWIoMVmw,8048
+pathspec/pattern.py,sha256=sWBuHJNnDKa6tqpKU50ZeCUYXSkKz2dWPLtSHpIyP5U,4811
+pathspec/util.py,sha256=XayuxOvE0LaTZDyffhpel-1ew1_MP_FTCeqXj0M3C8I,19889
+pathspec/patterns/__init__.py,sha256=Falv9rzI0S-Sjc-t-vCS9nUPcKwBptmdNderY9Kok50,184
+pathspec/patterns/gitwildmatch.py,sha256=NzrN7IqFvJJT3x7jcXIMZBmeWF6n0nDjUMoPWpGmvZs,11899
+pathspec/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pathspec/tests/test_gitwildmatch.py,sha256=m9a5-dJ1-MXZ-SVzci3JqtHShfEP3ty-kaYMkVGWS9U,15160
+pathspec/tests/test_pathspec.py,sha256=UB_aETIpTxpuei79zI2_kbjI2XnM2tF_xTQOFD4IYL8,4845
+pathspec/tests/test_util.py,sha256=IjvDbKYyEnQOaa07ebx-qD4bb-YFSm3qm0PE-VhKUa0,7906
+pathspec-0.9.0.dist-info/LICENSE,sha256=-rPda9qyJvHAhjCx3ZF-Efy07F4eAg4sFvg6ChOGPoU,16726
+pathspec-0.9.0.dist-info/METADATA,sha256=nmGOFs7gDO9imfQOjDP2Mhu-NX1xK2DoDv4B7D37D80,12141
+pathspec-0.9.0.dist-info/WHEEL,sha256=8zNYZbwQSXoB9IfXOjPfeNwvAsALAjffgk27FqvCWbo,110
+pathspec-0.9.0.dist-info/top_level.txt,sha256=0NA6IbW6iCUZ4p402IRSyZpvx4yqoltHzMoAxVQHI1M,9
+pathspec-0.9.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+pathspec-0.9.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/WHEEL
new file mode 100644
index 0000000..8b701e9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.33.6)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/top_level.txt
new file mode 100644
index 0000000..6486958
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec-0.9.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+pathspec
diff --git a/myenv/lib/python3.9/site-packages/pathspec/__init__.py b/myenv/lib/python3.9/site-packages/pathspec/__init__.py
new file mode 100644
index 0000000..790d0a3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec/__init__.py
@@ -0,0 +1,43 @@
+# encoding: utf-8
+"""
+The *pathspec* package provides pattern matching for file paths. So far
+this only includes Git's wildmatch pattern matching (the style used for
+".gitignore" files).
+
+The following classes are imported and made available from the root of
+the `pathspec` package:
+
+- :class:`pathspec.pathspec.PathSpec`
+
+- :class:`pathspec.pattern.Pattern`
+
+- :class:`pathspec.pattern.RegexPattern`
+
+- :class:`pathspec.util.RecursionError`
+
+The following functions are also imported:
+
+- :func:`pathspec.util.iter_tree`
+- :func:`pathspec.util.lookup_pattern`
+- :func:`pathspec.util.match_files`
+"""
+from __future__ import unicode_literals
+
+from .pathspec import PathSpec
+from .pattern import Pattern, RegexPattern
+from .util import iter_tree, lookup_pattern, match_files, RecursionError
+
+from ._meta import (
+	__author__,
+	__copyright__,
+	__credits__,
+	__license__,
+	__version__,
+)
+
+# Load pattern implementations.
+from . import patterns
+
+# Expose `GitIgnorePattern` class in the root module for backward
+# compatibility with v0.4.
+from .patterns.gitwildmatch import GitIgnorePattern
diff --git a/myenv/lib/python3.9/site-packages/pathspec/_meta.py b/myenv/lib/python3.9/site-packages/pathspec/_meta.py
new file mode 100644
index 0000000..ff4c323
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec/_meta.py
@@ -0,0 +1,43 @@
+# encoding: utf-8
+"""
+This module contains the project meta-data.
+"""
+
+__author__ = "Caleb P. Burns"
+__copyright__ = "Copyright © 2013-2021 Caleb P. Burns"
+__credits__ = [
+	"dahlia <https://github.com/dahlia>",
+	"highb <https://github.com/highb>",
+	"029xue <https://github.com/029xue>",
+	"mikexstudios <https://github.com/mikexstudios>",
+	"nhumrich <https://github.com/nhumrich>",
+	"davidfraser <https://github.com/davidfraser>",
+	"demurgos <https://github.com/demurgos>",
+	"ghickman <https://github.com/ghickman>",
+	"nvie <https://github.com/nvie>",
+	"adrienverge <https://github.com/adrienverge>",
+	"AndersBlomdell <https://github.com/AndersBlomdell>",
+	"highb <https://github.com/highb>",
+	"thmxv <https://github.com/thmxv>",
+	"wimglenn <https://github.com/wimglenn>",
+	"hugovk <https://github.com/hugovk>",
+	"dcecile <https://github.com/dcecile>",
+	"mroutis <https://github.com/mroutis>",
+	"jdufresne <https://github.com/jdufresne>",
+	"groodt <https://github.com/groodt>",
+	"ftrofin <https://github.com/ftrofin>",
+	"pykong <https://github.com/pykong>",
+	"nhhollander <https://github.com/nhhollander>",
+	"KOLANICH <https://github.com/KOLANICH>",
+	"JonjonHays <https://github.com/JonjonHays>",
+	"Isaac0616 <https://github.com/Isaac0616>",
+	"SebastiaanZ <https://github.com/SebastiaanZ>",
+	"RoelAdriaans <https://github.com/RoelAdriaans>",
+	"raviselker <https://github.com/raviselker>",
+	"johanvergeer <https://github.com/johanvergeer>",
+	"danjer <https://github.com/danjer>",
+	"jhbuhrman <https://github.com/jhbuhrman>",
+	"WPDOrdina <https://github.com/WPDOrdina>",
+]
+__license__ = "MPL 2.0"
+__version__ = "0.9.0"
diff --git a/myenv/lib/python3.9/site-packages/pathspec/compat.py b/myenv/lib/python3.9/site-packages/pathspec/compat.py
new file mode 100644
index 0000000..f5d17bf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec/compat.py
@@ -0,0 +1,41 @@
+# encoding: utf-8
+"""
+This module provides compatibility between Python 2 and 3. Hardly
+anything is used by this project to constitute including `six`_.
+
+.. _`six`: http://pythonhosted.org/six
+"""
+
+import sys
+
+if sys.version_info[0] < 3:
+	# Python 2.
+	unicode = unicode
+	string_types = (basestring,)
+
+	from collections import Iterable
+	from itertools import izip_longest
+
+	def iterkeys(mapping):
+		return mapping.iterkeys()
+
+else:
+	# Python 3.
+	unicode = str
+	string_types = (unicode,)
+
+	from collections.abc import Iterable
+	from itertools import zip_longest as izip_longest
+
+	def iterkeys(mapping):
+		return mapping.keys()
+
+try:
+	# Python 3.6+.
+	from collections.abc import Collection
+except ImportError:
+	# Python 2.7 - 3.5.
+	from collections import Container as Collection
+
+CollectionType = Collection
+IterableType = Iterable
diff --git a/myenv/lib/python3.9/site-packages/pathspec/pathspec.py b/myenv/lib/python3.9/site-packages/pathspec/pathspec.py
new file mode 100644
index 0000000..ff40089
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec/pathspec.py
@@ -0,0 +1,243 @@
+# encoding: utf-8
+"""
+This module provides an object oriented interface for pattern matching
+of files.
+"""
+
+try:
+	from typing import (
+		Any,
+		AnyStr,
+		Callable,
+		Iterable,
+		Iterator,
+		Optional,
+		Text,
+		Union)
+except ImportError:
+	pass
+
+try:
+	# Python 3.6+ type hints.
+	from os import PathLike
+	from typing import Collection
+except ImportError:
+	pass
+
+from . import util
+from .compat import (
+	CollectionType,
+	iterkeys,
+	izip_longest,
+	string_types)
+from .pattern import Pattern
+from .util import TreeEntry
+
+
+class PathSpec(object):
+	"""
+	The :class:`PathSpec` class is a wrapper around a list of compiled
+	:class:`.Pattern` instances.
+	"""
+
+	def __init__(self, patterns):
+		# type: (Iterable[Pattern]) -> None
+		"""
+		Initializes the :class:`PathSpec` instance.
+
+		*patterns* (:class:`~collections.abc.Collection` or :class:`~collections.abc.Iterable`)
+		yields each compiled pattern (:class:`.Pattern`).
+		"""
+
+		self.patterns = patterns if isinstance(patterns, CollectionType) else list(patterns)
+		"""
+		*patterns* (:class:`~collections.abc.Collection` of :class:`.Pattern`)
+		contains the compiled patterns.
+		"""
+
+	def __eq__(self, other):
+		# type: (PathSpec) -> bool
+		"""
+		Tests the equality of this path-spec with *other* (:class:`PathSpec`)
+		by comparing their :attr:`~PathSpec.patterns` attributes.
+		"""
+		if isinstance(other, PathSpec):
+			paired_patterns = izip_longest(self.patterns, other.patterns)
+			return all(a == b for a, b in paired_patterns)
+		else:
+			return NotImplemented
+
+	def __len__(self):
+		"""
+		Returns the number of compiled patterns this path-spec contains
+		(:class:`int`).
+		"""
+		return len(self.patterns)
+
+	def __add__(self, other):
+		# type: (PathSpec) -> PathSpec
+		"""
+		Combines the :attr:`Pathspec.patterns` patterns from two
+		:class:`PathSpec` instances.
+		"""
+		if isinstance(other, PathSpec):
+			return PathSpec(self.patterns + other.patterns)
+		else:
+			return NotImplemented
+
+	def __iadd__(self, other):
+		# type: (PathSpec) -> PathSpec
+		"""
+		Adds the :attr:`Pathspec.patterns` patterns from one :class:`PathSpec`
+		instance to this instance.
+		"""
+		if isinstance(other, PathSpec):
+			self.patterns += other.patterns
+			return self
+		else:
+			return NotImplemented
+
+	@classmethod
+	def from_lines(cls, pattern_factory, lines):
+		# type: (Union[Text, Callable[[AnyStr], Pattern]], Iterable[AnyStr]) -> PathSpec
+		"""
+		Compiles the pattern lines.
+
+		*pattern_factory* can be either the name of a registered pattern
+		factory (:class:`str`), or a :class:`~collections.abc.Callable` used
+		to compile patterns. It must accept an uncompiled pattern (:class:`str`)
+		and return the compiled pattern (:class:`.Pattern`).
+
+		*lines* (:class:`~collections.abc.Iterable`) yields each uncompiled
+		pattern (:class:`str`). This simply has to yield each line so it can
+		be a :class:`file` (e.g., from :func:`open` or :class:`io.StringIO`)
+		or the result from :meth:`str.splitlines`.
+
+		Returns the :class:`PathSpec` instance.
+		"""
+		if isinstance(pattern_factory, string_types):
+			pattern_factory = util.lookup_pattern(pattern_factory)
+		if not callable(pattern_factory):
+			raise TypeError("pattern_factory:{!r} is not callable.".format(pattern_factory))
+
+		if not util._is_iterable(lines):
+			raise TypeError("lines:{!r} is not an iterable.".format(lines))
+
+		patterns = [pattern_factory(line) for line in lines if line]
+		return cls(patterns)
+
+	def match_file(self, file, separators=None):
+		# type: (Union[Text, PathLike], Optional[Collection[Text]]) -> bool
+		"""
+		Matches the file to this path-spec.
+
+		*file* (:class:`str` or :class:`~pathlib.PurePath`) is the file path
+		to be matched against :attr:`self.patterns <PathSpec.patterns>`.
+
+		*separators* (:class:`~collections.abc.Collection` of :class:`str`)
+		optionally contains the path separators to normalize. See
+		:func:`~pathspec.util.normalize_file` for more information.
+
+		Returns :data:`True` if *file* matched; otherwise, :data:`False`.
+		"""
+		norm_file = util.normalize_file(file, separators=separators)
+		return util.match_file(self.patterns, norm_file)
+
+	def match_entries(self, entries, separators=None):
+		# type: (Iterable[TreeEntry], Optional[Collection[Text]]) -> Iterator[TreeEntry]
+		"""
+		Matches the entries to this path-spec.
+
+		*entries* (:class:`~collections.abc.Iterable` of :class:`~util.TreeEntry`)
+		contains the entries to be matched against :attr:`self.patterns <PathSpec.patterns>`.
+
+		*separators* (:class:`~collections.abc.Collection` of :class:`str`;
+		or :data:`None`) optionally contains the path separators to
+		normalize. See :func:`~pathspec.util.normalize_file` for more
+		information.
+
+		Returns the matched entries (:class:`~collections.abc.Iterator` of
+		:class:`~util.TreeEntry`).
+		"""
+		if not util._is_iterable(entries):
+			raise TypeError("entries:{!r} is not an iterable.".format(entries))
+
+		entry_map = util._normalize_entries(entries, separators=separators)
+		match_paths = util.match_files(self.patterns, iterkeys(entry_map))
+		for path in match_paths:
+			yield entry_map[path]
+
+	def match_files(self, files, separators=None):
+		# type: (Iterable[Union[Text, PathLike]], Optional[Collection[Text]]) -> Iterator[Union[Text, PathLike]]
+		"""
+		Matches the files to this path-spec.
+
+		*files* (:class:`~collections.abc.Iterable` of :class:`str; or
+		:class:`pathlib.PurePath`) contains the file paths to be matched
+		against :attr:`self.patterns <PathSpec.patterns>`.
+
+		*separators* (:class:`~collections.abc.Collection` of :class:`str`;
+		or :data:`None`) optionally contains the path separators to
+		normalize. See :func:`~pathspec.util.normalize_file` for more
+		information.
+
+		Returns the matched files (:class:`~collections.abc.Iterator` of
+		:class:`str` or :class:`pathlib.PurePath`).
+		"""
+		if not util._is_iterable(files):
+			raise TypeError("files:{!r} is not an iterable.".format(files))
+
+		file_map = util.normalize_files(files, separators=separators)
+		matched_files = util.match_files(self.patterns, iterkeys(file_map))
+		for norm_file in matched_files:
+			for orig_file in file_map[norm_file]:
+				yield orig_file
+
+	def match_tree_entries(self, root, on_error=None, follow_links=None):
+		# type: (Text, Optional[Callable], Optional[bool]) -> Iterator[TreeEntry]
+		"""
+		Walks the specified root path for all files and matches them to this
+		path-spec.
+
+		*root* (:class:`str`; or :class:`pathlib.PurePath`) is the root
+		directory to search.
+
+		*on_error* (:class:`~collections.abc.Callable` or :data:`None`)
+		optionally is the error handler for file-system exceptions. See
+		:func:`~pathspec.util.iter_tree_entries` for more information.
+
+		*follow_links* (:class:`bool` or :data:`None`) optionally is whether
+		to walk symbolic links that resolve to directories. See
+		:func:`~pathspec.util.iter_tree_files` for more information.
+
+		Returns the matched files (:class:`~collections.abc.Iterator` of
+		:class:`.TreeEntry`).
+		"""
+		entries = util.iter_tree_entries(root, on_error=on_error, follow_links=follow_links)
+		return self.match_entries(entries)
+
+	def match_tree_files(self, root, on_error=None, follow_links=None):
+		# type: (Text, Optional[Callable], Optional[bool]) -> Iterator[Text]
+		"""
+		Walks the specified root path for all files and matches them to this
+		path-spec.
+
+		*root* (:class:`str`; or :class:`pathlib.PurePath`) is the root
+		directory to search for files.
+
+		*on_error* (:class:`~collections.abc.Callable` or :data:`None`)
+		optionally is the error handler for file-system exceptions. See
+		:func:`~pathspec.util.iter_tree_files` for more information.
+
+		*follow_links* (:class:`bool` or :data:`None`) optionally is whether
+		to walk symbolic links that resolve to directories. See
+		:func:`~pathspec.util.iter_tree_files` for more information.
+
+		Returns the matched files (:class:`~collections.abc.Iterable` of
+		:class:`str`).
+		"""
+		files = util.iter_tree_files(root, on_error=on_error, follow_links=follow_links)
+		return self.match_files(files)
+
+	# Alias `match_tree_files()` as `match_tree()`.
+	match_tree = match_tree_files
diff --git a/myenv/lib/python3.9/site-packages/pathspec/pattern.py b/myenv/lib/python3.9/site-packages/pathspec/pattern.py
new file mode 100644
index 0000000..c354c26
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec/pattern.py
@@ -0,0 +1,164 @@
+# encoding: utf-8
+"""
+This module provides the base definition for patterns.
+"""
+
+import re
+try:
+	from typing import (
+		AnyStr,
+		Iterable,
+		Iterator,
+		Optional,
+		Pattern as RegexHint,
+		Text,
+		Tuple,
+		Union)
+except ImportError:
+	pass
+
+from .compat import unicode
+
+
+class Pattern(object):
+	"""
+	The :class:`Pattern` class is the abstract definition of a pattern.
+	"""
+
+	# Make the class dict-less.
+	__slots__ = ('include',)
+
+	def __init__(self, include):
+		# type: (Optional[bool]) -> None
+		"""
+		Initializes the :class:`Pattern` instance.
+
+		*include* (:class:`bool` or :data:`None`) is whether the matched
+		files should be included (:data:`True`), excluded (:data:`False`),
+		or is a null-operation (:data:`None`).
+		"""
+
+		self.include = include
+		"""
+		*include* (:class:`bool` or :data:`None`) is whether the matched
+		files should be included (:data:`True`), excluded (:data:`False`),
+		or is a null-operation (:data:`None`).
+		"""
+
+	def match(self, files):
+		# type: (Iterable[Text]) -> Iterator[Text]
+		"""
+		Matches this pattern against the specified files.
+
+		*files* (:class:`~collections.abc.Iterable` of :class:`str`) contains
+		each file relative to the root directory (e.g., ``"relative/path/to/file"``).
+
+		Returns an :class:`~collections.abc.Iterable` yielding each matched
+		file path (:class:`str`).
+		"""
+		raise NotImplementedError("{}.{} must override match().".format(self.__class__.__module__, self.__class__.__name__))
+
+
+class RegexPattern(Pattern):
+	"""
+	The :class:`RegexPattern` class is an implementation of a pattern
+	using regular expressions.
+	"""
+
+	# Make the class dict-less.
+	__slots__ = ('regex',)
+
+	def __init__(self, pattern, include=None):
+		# type: (Union[AnyStr, RegexHint], Optional[bool]) -> None
+		"""
+		Initializes the :class:`RegexPattern` instance.
+
+		*pattern* (:class:`unicode`, :class:`bytes`, :class:`re.RegexObject`,
+		or :data:`None`) is the pattern to compile into a regular
+		expression.
+
+		*include* (:class:`bool` or :data:`None`) must be :data:`None`
+		unless *pattern* is a precompiled regular expression (:class:`re.RegexObject`)
+		in which case it is whether matched files should be included
+		(:data:`True`), excluded (:data:`False`), or is a null operation
+		(:data:`None`).
+
+			.. NOTE:: Subclasses do not need to support the *include*
+			   parameter.
+		"""
+
+		self.regex = None
+		"""
+		*regex* (:class:`re.RegexObject`) is the regular expression for the
+		pattern.
+		"""
+
+		if isinstance(pattern, (unicode, bytes)):
+			assert include is None, "include:{!r} must be null when pattern:{!r} is a string.".format(include, pattern)
+			regex, include = self.pattern_to_regex(pattern)
+			# NOTE: Make sure to allow a null regular expression to be
+			# returned for a null-operation.
+			if include is not None:
+				regex = re.compile(regex)
+
+		elif pattern is not None and hasattr(pattern, 'match'):
+			# Assume pattern is a precompiled regular expression.
+			# - NOTE: Used specified *include*.
+			regex = pattern
+
+		elif pattern is None:
+			# NOTE: Make sure to allow a null pattern to be passed for a
+			# null-operation.
+			assert include is None, "include:{!r} must be null when pattern:{!r} is null.".format(include, pattern)
+
+		else:
+			raise TypeError("pattern:{!r} is not a string, RegexObject, or None.".format(pattern))
+
+		super(RegexPattern, self).__init__(include)
+		self.regex = regex
+
+	def __eq__(self, other):
+		# type: (RegexPattern) -> bool
+		"""
+		Tests the equality of this regex pattern with *other* (:class:`RegexPattern`)
+		by comparing their :attr:`~Pattern.include` and :attr:`~RegexPattern.regex`
+		attributes.
+		"""
+		if isinstance(other, RegexPattern):
+			return self.include == other.include and self.regex == other.regex
+		else:
+			return NotImplemented
+
+	def match(self, files):
+		# type: (Iterable[Text]) -> Iterable[Text]
+		"""
+		Matches this pattern against the specified files.
+
+		*files* (:class:`~collections.abc.Iterable` of :class:`str`)
+		contains each file relative to the root directory (e.g., "relative/path/to/file").
+
+		Returns an :class:`~collections.abc.Iterable` yielding each matched
+		file path (:class:`str`).
+		"""
+		if self.include is not None:
+			for path in files:
+				if self.regex.match(path) is not None:
+					yield path
+
+	@classmethod
+	def pattern_to_regex(cls, pattern):
+		# type: (Text) -> Tuple[Text, bool]
+		"""
+		Convert the pattern into an uncompiled regular expression.
+
+		*pattern* (:class:`str`) is the pattern to convert into a regular
+		expression.
+
+		Returns the uncompiled regular expression (:class:`str` or :data:`None`),
+		and whether matched files should be included (:data:`True`),
+		excluded (:data:`False`), or is a null-operation (:data:`None`).
+
+			.. NOTE:: The default implementation simply returns *pattern* and
+			   :data:`True`.
+		"""
+		return pattern, True
diff --git a/myenv/lib/python3.9/site-packages/pathspec/patterns/__init__.py b/myenv/lib/python3.9/site-packages/pathspec/patterns/__init__.py
new file mode 100644
index 0000000..1a0d55e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec/patterns/__init__.py
@@ -0,0 +1,8 @@
+# encoding: utf-8
+"""
+The *pathspec.patterns* package contains the pattern matching
+implementations.
+"""
+
+# Load pattern implementations.
+from .gitwildmatch import GitWildMatchPattern
diff --git a/myenv/lib/python3.9/site-packages/pathspec/patterns/gitwildmatch.py b/myenv/lib/python3.9/site-packages/pathspec/patterns/gitwildmatch.py
new file mode 100644
index 0000000..afd8f6b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec/patterns/gitwildmatch.py
@@ -0,0 +1,400 @@
+# encoding: utf-8
+"""
+This module implements Git's wildmatch pattern matching which itself is
+derived from Rsync's wildmatch. Git uses wildmatch for its ".gitignore"
+files.
+"""
+from __future__ import unicode_literals
+
+import re
+import warnings
+try:
+	from typing import (
+		AnyStr,
+		Optional,
+		Text,
+		Tuple)
+except ImportError:
+	pass
+
+from .. import util
+from ..compat import unicode
+from ..pattern import RegexPattern
+
+#: The encoding to use when parsing a byte string pattern.
+_BYTES_ENCODING = 'latin1'
+
+
+class GitWildMatchPatternError(ValueError):
+	"""
+	The :class:`GitWildMatchPatternError` indicates an invalid git wild match
+	pattern.
+	"""
+	pass
+
+
+class GitWildMatchPattern(RegexPattern):
+	"""
+	The :class:`GitWildMatchPattern` class represents a compiled Git
+	wildmatch pattern.
+	"""
+
+	# Keep the dict-less class hierarchy.
+	__slots__ = ()
+
+	@classmethod
+	def pattern_to_regex(cls, pattern):
+		# type: (AnyStr) -> Tuple[Optional[AnyStr], Optional[bool]]
+		"""
+		Convert the pattern into a regular expression.
+
+		*pattern* (:class:`unicode` or :class:`bytes`) is the pattern to
+		convert into a regular expression.
+
+		Returns the uncompiled regular expression (:class:`unicode`, :class:`bytes`,
+		or :data:`None`), and whether matched files should be included
+		(:data:`True`), excluded (:data:`False`), or if it is a
+		null-operation (:data:`None`).
+		"""
+		if isinstance(pattern, unicode):
+			return_type = unicode
+		elif isinstance(pattern, bytes):
+			return_type = bytes
+			pattern = pattern.decode(_BYTES_ENCODING)
+		else:
+			raise TypeError("pattern:{!r} is not a unicode or byte string.".format(pattern))
+
+		original_pattern = pattern
+		pattern = pattern.strip()
+
+		if pattern.startswith('#'):
+			# A pattern starting with a hash ('#') serves as a comment
+			# (neither includes nor excludes files). Escape the hash with a
+			# back-slash to match a literal hash (i.e., '\#').
+			regex = None
+			include = None
+
+		elif pattern == '/':
+			# EDGE CASE: According to `git check-ignore` (v2.4.1), a single
+			# '/' does not match any file.
+			regex = None
+			include = None
+
+		elif pattern:
+			if pattern.startswith('!'):
+				# A pattern starting with an exclamation mark ('!') negates the
+				# pattern (exclude instead of include). Escape the exclamation
+				# mark with a back-slash to match a literal exclamation mark
+				# (i.e., '\!').
+				include = False
+				# Remove leading exclamation mark.
+				pattern = pattern[1:]
+			else:
+				include = True
+
+			if pattern.startswith('\\'):
+				# Remove leading back-slash escape for escaped hash ('#') or
+				# exclamation mark ('!').
+				pattern = pattern[1:]
+
+			# Allow a regex override for edge cases that cannot be handled
+			# through normalization.
+			override_regex = None
+
+			# Split pattern into segments.
+			pattern_segs = pattern.split('/')
+
+			# Normalize pattern to make processing easier.
+
+			# EDGE CASE: Deal with duplicate double-asterisk sequences.
+			# Collapse each sequence down to one double-asterisk. Iterate over
+			# the segments in reverse and remove the duplicate double
+			# asterisks as we go.
+			for i in range(len(pattern_segs) - 1, 0, -1):
+				prev = pattern_segs[i-1]
+				seg = pattern_segs[i]
+				if prev == '**' and seg == '**':
+					del pattern_segs[i]
+
+			if len(pattern_segs) == 2 and pattern_segs[0] == '**' and not pattern_segs[1]:
+				# EDGE CASE: The '**/' pattern should match everything except
+				# individual files in the root directory. This case cannot be
+				# adequately handled through normalization. Use the override.
+				override_regex = '^.+/.*$'
+
+			if not pattern_segs[0]:
+				# A pattern beginning with a slash ('/') will only match paths
+				# directly on the root directory instead of any descendant
+				# paths. So, remove empty first segment to make pattern relative
+				# to root.
+				del pattern_segs[0]
+
+			elif len(pattern_segs) == 1 or (len(pattern_segs) == 2 and not pattern_segs[1]):
+				# A single pattern without a beginning slash ('/') will match
+				# any descendant path. This is equivalent to "**/{pattern}". So,
+				# prepend with double-asterisks to make pattern relative to
+				# root.
+				# EDGE CASE: This also holds for a single pattern with a
+				# trailing slash (e.g. dir/).
+				if pattern_segs[0] != '**':
+					pattern_segs.insert(0, '**')
+
+			else:
+				# EDGE CASE: A pattern without a beginning slash ('/') but
+				# contains at least one prepended directory (e.g.
+				# "dir/{pattern}") should not match "**/dir/{pattern}",
+				# according to `git check-ignore` (v2.4.1).
+				pass
+
+			if not pattern_segs:
+				# After resolving the edge cases, we end up with no
+				# pattern at all. This must be because the pattern is
+				# invalid.
+				raise GitWildMatchPatternError("Invalid git pattern: %r" % (original_pattern,))
+
+			if not pattern_segs[-1] and len(pattern_segs) > 1:
+				# A pattern ending with a slash ('/') will match all
+				# descendant paths if it is a directory but not if it is a
+				# regular file. This is equivalent to "{pattern}/**". So, set
+				# last segment to a double-asterisk to include all
+				# descendants.
+				pattern_segs[-1] = '**'
+
+			if override_regex is None:
+				# Build regular expression from pattern.
+				output = ['^']
+				need_slash = False
+				end = len(pattern_segs) - 1
+				for i, seg in enumerate(pattern_segs):
+					if seg == '**':
+						if i == 0 and i == end:
+							# A pattern consisting solely of double-asterisks ('**')
+							# will match every path.
+							output.append('.+')
+						elif i == 0:
+							# A normalized pattern beginning with double-asterisks
+							# ('**') will match any leading path segments.
+							output.append('(?:.+/)?')
+							need_slash = False
+						elif i == end:
+							# A normalized pattern ending with double-asterisks ('**')
+							# will match any trailing path segments.
+							output.append('/.*')
+						else:
+							# A pattern with inner double-asterisks ('**') will match
+							# multiple (or zero) inner path segments.
+							output.append('(?:/.+)?')
+							need_slash = True
+
+					elif seg == '*':
+						# Match single path segment.
+						if need_slash:
+							output.append('/')
+						output.append('[^/]+')
+						need_slash = True
+
+					else:
+						# Match segment glob pattern.
+						if need_slash:
+							output.append('/')
+
+						output.append(cls._translate_segment_glob(seg))
+						if i == end and include is True:
+							# A pattern ending without a slash ('/') will match a file
+							# or a directory (with paths underneath it). E.g., "foo"
+							# matches "foo", "foo/bar", "foo/bar/baz", etc.
+							# EDGE CASE: However, this does not hold for exclusion cases
+							# according to `git check-ignore` (v2.4.1).
+							output.append('(?:/.*)?')
+
+						need_slash = True
+
+				output.append('$')
+				regex = ''.join(output)
+
+			else:
+				# Use regex override.
+				regex = override_regex
+
+		else:
+			# A blank pattern is a null-operation (neither includes nor
+			# excludes files).
+			regex = None
+			include = None
+
+		if regex is not None and return_type is bytes:
+			regex = regex.encode(_BYTES_ENCODING)
+
+		return regex, include
+
+	@staticmethod
+	def _translate_segment_glob(pattern):
+		# type: (Text) -> Text
+		"""
+		Translates the glob pattern to a regular expression. This is used in
+		the constructor to translate a path segment glob pattern to its
+		corresponding regular expression.
+
+		*pattern* (:class:`str`) is the glob pattern.
+
+		Returns the regular expression (:class:`str`).
+		"""
+		# NOTE: This is derived from `fnmatch.translate()` and is similar to
+		# the POSIX function `fnmatch()` with the `FNM_PATHNAME` flag set.
+
+		escape = False
+		regex = ''
+		i, end = 0, len(pattern)
+		while i < end:
+			# Get next character.
+			char = pattern[i]
+			i += 1
+
+			if escape:
+				# Escape the character.
+				escape = False
+				regex += re.escape(char)
+
+			elif char == '\\':
+				# Escape character, escape next character.
+				escape = True
+
+			elif char == '*':
+				# Multi-character wildcard. Match any string (except slashes),
+				# including an empty string.
+				regex += '[^/]*'
+
+			elif char == '?':
+				# Single-character wildcard. Match any single character (except
+				# a slash).
+				regex += '[^/]'
+
+			elif char == '[':
+				# Bracket expression wildcard. Except for the beginning
+				# exclamation mark, the whole bracket expression can be used
+				# directly as regex but we have to find where the expression
+				# ends.
+				# - "[][!]" matches ']', '[' and '!'.
+				# - "[]-]" matches ']' and '-'.
+				# - "[!]a-]" matches any character except ']', 'a' and '-'.
+				j = i
+				# Pass brack expression negation.
+				if j < end and pattern[j] == '!':
+					j += 1
+				# Pass first closing bracket if it is at the beginning of the
+				# expression.
+				if j < end and pattern[j] == ']':
+					j += 1
+				# Find closing bracket. Stop once we reach the end or find it.
+				while j < end and pattern[j] != ']':
+					j += 1
+
+				if j < end:
+					# Found end of bracket expression. Increment j to be one past
+					# the closing bracket:
+					#
+					#  [...]
+					#   ^   ^
+					#   i   j
+					#
+					j += 1
+					expr = '['
+
+					if pattern[i] == '!':
+						# Braket expression needs to be negated.
+						expr += '^'
+						i += 1
+					elif pattern[i] == '^':
+						# POSIX declares that the regex bracket expression negation
+						# "[^...]" is undefined in a glob pattern. Python's
+						# `fnmatch.translate()` escapes the caret ('^') as a
+						# literal. To maintain consistency with undefined behavior,
+						# I am escaping the '^' as well.
+						expr += '\\^'
+						i += 1
+
+					# Build regex bracket expression. Escape slashes so they are
+					# treated as literal slashes by regex as defined by POSIX.
+					expr += pattern[i:j].replace('\\', '\\\\')
+
+					# Add regex bracket expression to regex result.
+					regex += expr
+
+					# Set i to one past the closing bracket.
+					i = j
+
+				else:
+					# Failed to find closing bracket, treat opening bracket as a
+					# bracket literal instead of as an expression.
+					regex += '\\['
+
+			else:
+				# Regular character, escape it for regex.
+				regex += re.escape(char)
+
+		return regex
+
+	@staticmethod
+	def escape(s):
+		# type: (AnyStr) -> AnyStr
+		"""
+		Escape special characters in the given string.
+
+		*s* (:class:`unicode` or :class:`bytes`) a filename or a string
+		that you want to escape, usually before adding it to a `.gitignore`
+
+		Returns the escaped string (:class:`unicode` or :class:`bytes`)
+		"""
+		if isinstance(s, unicode):
+			return_type = unicode
+			string = s
+		elif isinstance(s, bytes):
+			return_type = bytes
+			string = s.decode(_BYTES_ENCODING)
+		else:
+			raise TypeError("s:{!r} is not a unicode or byte string.".format(s))
+
+		# Reference: https://git-scm.com/docs/gitignore#_pattern_format
+		meta_characters = r"[]!*#?"
+
+		out_string = "".join("\\" + x if x in meta_characters else x for x in string)
+
+		if return_type is bytes:
+			return out_string.encode(_BYTES_ENCODING)
+		else:
+			return out_string
+
+util.register_pattern('gitwildmatch', GitWildMatchPattern)
+
+
+class GitIgnorePattern(GitWildMatchPattern):
+	"""
+	The :class:`GitIgnorePattern` class is deprecated by :class:`GitWildMatchPattern`.
+	This class only exists to maintain compatibility with v0.4.
+	"""
+
+	def __init__(self, *args, **kw):
+		"""
+		Warn about deprecation.
+		"""
+		self._deprecated()
+		super(GitIgnorePattern, self).__init__(*args, **kw)
+
+	@staticmethod
+	def _deprecated():
+		"""
+		Warn about deprecation.
+		"""
+		warnings.warn("GitIgnorePattern ('gitignore') is deprecated. Use GitWildMatchPattern ('gitwildmatch') instead.", DeprecationWarning, stacklevel=3)
+
+	@classmethod
+	def pattern_to_regex(cls, *args, **kw):
+		"""
+		Warn about deprecation.
+		"""
+		cls._deprecated()
+		return super(GitIgnorePattern, cls).pattern_to_regex(*args, **kw)
+
+# Register `GitIgnorePattern` as "gitignore" for backward compatibility
+# with v0.4.
+util.register_pattern('gitignore', GitIgnorePattern)
diff --git a/myenv/lib/python3.9/site-packages/pathspec/tests/__init__.py b/myenv/lib/python3.9/site-packages/pathspec/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pathspec/tests/test_gitwildmatch.py b/myenv/lib/python3.9/site-packages/pathspec/tests/test_gitwildmatch.py
new file mode 100644
index 0000000..9868381
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec/tests/test_gitwildmatch.py
@@ -0,0 +1,548 @@
+# encoding: utf-8
+"""
+This script tests ``GitWildMatchPattern``.
+"""
+from __future__ import unicode_literals
+
+import re
+import sys
+import unittest
+
+import pathspec.patterns.gitwildmatch
+import pathspec.util
+from pathspec.patterns.gitwildmatch import GitWildMatchPattern, GitWildMatchPatternError
+
+if sys.version_info[0] >= 3:
+	unichr = chr
+
+
+class GitWildMatchTest(unittest.TestCase):
+	"""
+	The ``GitWildMatchTest`` class tests the ``GitWildMatchPattern``
+	implementation.
+	"""
+
+	def test_00_empty(self):
+		"""
+		Tests an empty pattern.
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('')
+		self.assertIsNone(include)
+		self.assertIsNone(regex)
+
+	def test_01_absolute(self):
+		"""
+		Tests an absolute path pattern.
+
+		This should match:
+
+			an/absolute/file/path
+			an/absolute/file/path/foo
+
+		This should NOT match:
+
+			foo/an/absolute/file/path
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('/an/absolute/file/path')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^an/absolute/file/path(?:/.*)?$')
+
+		pattern = GitWildMatchPattern(re.compile(regex), include)
+		results = set(pattern.match([
+			'an/absolute/file/path',
+			'an/absolute/file/path/foo',
+			'foo/an/absolute/file/path',
+		]))
+		self.assertEqual(results, {
+			'an/absolute/file/path',
+			'an/absolute/file/path/foo',
+		})
+
+	def test_01_absolute_root(self):
+		"""
+		Tests a single root absolute path pattern.
+
+		This should NOT match any file (according to git check-ignore
+		(v2.4.1)).
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('/')
+		self.assertIsNone(include)
+		self.assertIsNone(regex)
+
+	def test_01_relative(self):
+		"""
+		Tests a relative path pattern.
+
+		This should match:
+
+			spam
+			spam/
+			foo/spam
+			spam/foo
+			foo/spam/bar
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('spam')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^(?:.+/)?spam(?:/.*)?$')
+
+		pattern = GitWildMatchPattern(re.compile(regex), include)
+		results = set(pattern.match([
+			'spam',
+			'spam/',
+			'foo/spam',
+			'spam/foo',
+			'foo/spam/bar',
+		]))
+		self.assertEqual(results, {
+			'spam',
+			'spam/',
+			'foo/spam',
+			'spam/foo',
+			'foo/spam/bar',
+		})
+
+	def test_01_relative_nested(self):
+		"""
+		Tests a relative nested path pattern.
+
+		This should match:
+
+			foo/spam
+			foo/spam/bar
+
+		This should **not** match (according to git check-ignore (v2.4.1)):
+
+			bar/foo/spam
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('foo/spam')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^foo/spam(?:/.*)?$')
+
+		pattern = GitWildMatchPattern(re.compile(regex), include)
+		results = set(pattern.match([
+			'foo/spam',
+			'foo/spam/bar',
+			'bar/foo/spam',
+		]))
+		self.assertEqual(results, {
+			'foo/spam',
+			'foo/spam/bar',
+		})
+
+	def test_02_comment(self):
+		"""
+		Tests a comment pattern.
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('# Cork soakers.')
+		self.assertIsNone(include)
+		self.assertIsNone(regex)
+
+	def test_02_ignore(self):
+		"""
+		Tests an exclude pattern.
+
+		This should NOT match (according to git check-ignore (v2.4.1)):
+
+			temp/foo
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('!temp')
+		self.assertIsNotNone(include)
+		self.assertFalse(include)
+		self.assertEqual(regex, '^(?:.+/)?temp$')
+
+		pattern = GitWildMatchPattern(re.compile(regex), include)
+		results = set(pattern.match(['temp/foo']))
+		self.assertEqual(results, set())
+
+	def test_03_child_double_asterisk(self):
+		"""
+		Tests a directory name with a double-asterisk child
+		directory.
+
+		This should match:
+
+			spam/bar
+
+		This should **not** match (according to git check-ignore (v2.4.1)):
+
+			foo/spam/bar
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('spam/**')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^spam/.*$')
+
+		pattern = GitWildMatchPattern(re.compile(regex), include)
+		results = set(pattern.match([
+			'spam/bar',
+			'foo/spam/bar',
+		]))
+		self.assertEqual(results, {'spam/bar'})
+
+	def test_03_inner_double_asterisk(self):
+		"""
+		Tests a path with an inner double-asterisk directory.
+
+		This should match:
+
+			left/right
+			left/bar/right
+			left/foo/bar/right
+			left/bar/right/foo
+
+		This should **not** match (according to git check-ignore (v2.4.1)):
+
+			foo/left/bar/right
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('left/**/right')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^left(?:/.+)?/right(?:/.*)?$')
+
+		pattern = GitWildMatchPattern(re.compile(regex), include)
+		results = set(pattern.match([
+			'left/right',
+			'left/bar/right',
+			'left/foo/bar/right',
+			'left/bar/right/foo',
+			'foo/left/bar/right',
+		]))
+		self.assertEqual(results, {
+			'left/right',
+			'left/bar/right',
+			'left/foo/bar/right',
+			'left/bar/right/foo',
+		})
+
+	def test_03_only_double_asterisk(self):
+		"""
+		Tests a double-asterisk pattern which matches everything.
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('**')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^.+$')
+
+	def test_03_parent_double_asterisk(self):
+		"""
+		Tests a file name with a double-asterisk parent directory.
+
+		This should match:
+
+			spam
+			foo/spam
+			foo/spam/bar
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('**/spam')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^(?:.+/)?spam(?:/.*)?$')
+
+		pattern = GitWildMatchPattern(re.compile(regex), include)
+		results = set(pattern.match([
+			'spam',
+			'foo/spam',
+			'foo/spam/bar',
+		]))
+		self.assertEqual(results, {
+			'spam',
+			'foo/spam',
+			'foo/spam/bar',
+		})
+
+	def test_03_duplicate_leading_double_asterisk_edge_case(self):
+		"""
+		Regression test for duplicate leading **/ bug.
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('**')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^.+$')
+
+		equivalent_regex, include = GitWildMatchPattern.pattern_to_regex('**/**')
+		self.assertTrue(include)
+		self.assertEqual(equivalent_regex, regex)
+
+		equivalent_regex, include = GitWildMatchPattern.pattern_to_regex('**/**/**')
+		self.assertTrue(include)
+		self.assertEqual(equivalent_regex, regex)
+
+		regex, include = GitWildMatchPattern.pattern_to_regex('**/api')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^(?:.+/)?api(?:/.*)?$')
+
+		equivalent_regex, include = GitWildMatchPattern.pattern_to_regex('**/**/api')
+		self.assertTrue(include)
+		self.assertEqual(equivalent_regex, regex)
+
+		regex, include = GitWildMatchPattern.pattern_to_regex('**/api/')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^(?:.+/)?api/.*$')
+
+		equivalent_regex, include = GitWildMatchPattern.pattern_to_regex('**/api/**')
+		self.assertTrue(include)
+		self.assertEqual(equivalent_regex, regex)
+
+		equivalent_regex, include = GitWildMatchPattern.pattern_to_regex('**/**/api/**/**')
+		self.assertTrue(include)
+		self.assertEqual(equivalent_regex, regex)
+
+	def test_03_double_asterisk_trailing_slash_edge_case(self):
+		"""
+		Tests the edge-case **/ pattern.
+
+		This should match everything except individual files in the root directory.
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('**/')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^.+/.*$')
+
+		equivalent_regex, include = GitWildMatchPattern.pattern_to_regex('**/**/')
+		self.assertTrue(include)
+		self.assertEqual(equivalent_regex, regex)
+
+	def test_04_infix_wildcard(self):
+		"""
+		Tests a pattern with an infix wildcard.
+
+		This should match:
+
+			foo--bar
+			foo-hello-bar
+			a/foo-hello-bar
+			foo-hello-bar/b
+			a/foo-hello-bar/b
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('foo-*-bar')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^(?:.+/)?foo\\-[^/]*\\-bar(?:/.*)?$')
+
+		pattern = GitWildMatchPattern(re.compile(regex), include)
+		results = set(pattern.match([
+			'foo--bar',
+			'foo-hello-bar',
+			'a/foo-hello-bar',
+			'foo-hello-bar/b',
+			'a/foo-hello-bar/b',
+		]))
+		self.assertEqual(results, {
+			'foo--bar',
+			'foo-hello-bar',
+			'a/foo-hello-bar',
+			'foo-hello-bar/b',
+			'a/foo-hello-bar/b',
+		})
+
+	def test_04_postfix_wildcard(self):
+		"""
+		Tests a pattern with a postfix wildcard.
+
+		This should match:
+
+			~temp-
+			~temp-foo
+			~temp-foo/bar
+			foo/~temp-bar
+			foo/~temp-bar/baz
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('~temp-*')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^(?:.+/)?\\~temp\\-[^/]*(?:/.*)?$')
+
+		pattern = GitWildMatchPattern(re.compile(regex), include)
+		results = set(pattern.match([
+			'~temp-',
+			'~temp-foo',
+			'~temp-foo/bar',
+			'foo/~temp-bar',
+			'foo/~temp-bar/baz',
+		]))
+		self.assertEqual(results, {
+			'~temp-',
+			'~temp-foo',
+			'~temp-foo/bar',
+			'foo/~temp-bar',
+			'foo/~temp-bar/baz',
+		})
+
+	def test_04_prefix_wildcard(self):
+		"""
+		Tests a pattern with a prefix wildcard.
+
+		This should match:
+
+			bar.py
+			bar.py/
+			foo/bar.py
+			foo/bar.py/baz
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('*.py')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^(?:.+/)?[^/]*\\.py(?:/.*)?$')
+
+		pattern = GitWildMatchPattern(re.compile(regex), include)
+		results = set(pattern.match([
+			'bar.py',
+			'bar.py/',
+			'foo/bar.py',
+			'foo/bar.py/baz',
+		]))
+		self.assertEqual(results, {
+			'bar.py',
+			'bar.py/',
+			'foo/bar.py',
+			'foo/bar.py/baz',
+		})
+
+	def test_05_directory(self):
+		"""
+		Tests a directory pattern.
+
+		This should match:
+
+			dir/
+			foo/dir/
+			foo/dir/bar
+
+		This should **not** match:
+
+			dir
+		"""
+		regex, include = GitWildMatchPattern.pattern_to_regex('dir/')
+		self.assertTrue(include)
+		self.assertEqual(regex, '^(?:.+/)?dir/.*$')
+
+		pattern = GitWildMatchPattern(re.compile(regex), include)
+		results = set(pattern.match([
+			'dir/',
+			'foo/dir/',
+			'foo/dir/bar',
+			'dir',
+		]))
+		self.assertEqual(results, {
+			'dir/',
+			'foo/dir/',
+			'foo/dir/bar',
+		})
+
+	def test_06_registered(self):
+		"""
+		Tests that the pattern is registered.
+		"""
+		self.assertIs(pathspec.util.lookup_pattern('gitwildmatch'), GitWildMatchPattern)
+
+	def test_06_access_deprecated(self):
+		"""
+		Tests that the pattern is accessible from the root module using the
+		deprecated alias.
+		"""
+		self.assertTrue(hasattr(pathspec, 'GitIgnorePattern'))
+		self.assertTrue(issubclass(pathspec.GitIgnorePattern, GitWildMatchPattern))
+
+	def test_06_registered_deprecated(self):
+		"""
+		Tests that the pattern is registered under the deprecated alias.
+		"""
+		self.assertIs(pathspec.util.lookup_pattern('gitignore'), pathspec.GitIgnorePattern)
+
+	def test_07_encode_bytes(self):
+		"""
+		Test encoding bytes.
+		"""
+		encoded = "".join(map(unichr, range(0,256))).encode(pathspec.patterns.gitwildmatch._BYTES_ENCODING)
+		expected = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
+		self.assertEqual(encoded, expected)
+
+	def test_07_decode_bytes(self):
+		"""
+		Test decoding bytes.
+		"""
+		decoded = bytes(bytearray(range(0,256))).decode(pathspec.patterns.gitwildmatch._BYTES_ENCODING)
+		expected = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
+		self.assertEqual(decoded, expected)
+
+	def test_07_match_bytes_and_bytes(self):
+		"""
+		Test byte string patterns matching byte string paths.
+		"""
+		pattern = GitWildMatchPattern(b'*.py')
+		results = set(pattern.match([b'a.py']))
+		self.assertEqual(results, {b'a.py'})
+
+	def test_07_match_bytes_and_bytes_complete(self):
+		"""
+		Test byte string patterns matching byte string paths.
+		"""
+		encoded = bytes(bytearray(range(0,256)))
+		escaped = b"".join(b"\\" + encoded[i:i+1] for i in range(len(encoded)))
+		pattern = GitWildMatchPattern(escaped)
+		results = set(pattern.match([encoded]))
+		self.assertEqual(results, {encoded})
+
+	@unittest.skipIf(sys.version_info[0] >= 3, "Python 3 is strict")
+	def test_07_match_bytes_and_unicode(self):
+		"""
+		Test byte string patterns matching byte string paths.
+		"""
+		pattern = GitWildMatchPattern(b'*.py')
+		results = set(pattern.match(['a.py']))
+		self.assertEqual(results, {'a.py'})
+
+	@unittest.skipIf(sys.version_info[0] == 2, "Python 2 is lenient")
+	def test_07_match_bytes_and_unicode_fail(self):
+		"""
+		Test byte string patterns matching byte string paths.
+		"""
+		pattern = GitWildMatchPattern(b'*.py')
+		with self.assertRaises(TypeError):
+			for _ in pattern.match(['a.py']):
+				pass
+
+	@unittest.skipIf(sys.version_info[0] >= 3, "Python 3 is strict")
+	def test_07_match_unicode_and_bytes(self):
+		"""
+		Test unicode patterns with byte paths.
+		"""
+		pattern = GitWildMatchPattern('*.py')
+		results = set(pattern.match([b'a.py']))
+		self.assertEqual(results, {b'a.py'})
+
+	@unittest.skipIf(sys.version_info[0] == 2, "Python 2 is lenient")
+	def test_07_match_unicode_and_bytes_fail(self):
+		"""
+		Test unicode patterns with byte paths.
+		"""
+		pattern = GitWildMatchPattern('*.py')
+		with self.assertRaises(TypeError):
+			for _ in pattern.match([b'a.py']):
+				pass
+
+	def test_07_match_unicode_and_unicode(self):
+		"""
+		Test unicode patterns with unicode paths.
+		"""
+		pattern = GitWildMatchPattern('*.py')
+		results = set(pattern.match(['a.py']))
+		self.assertEqual(results, {'a.py'})
+
+	def test_08_escape(self):
+		"""
+		Test escaping a string with meta-characters
+		"""
+		fname = "file!with*weird#naming_[1].t?t"
+		escaped = r"file\!with\*weird\#naming_\[1\].t\?t"
+		result = GitWildMatchPattern.escape(fname)
+		self.assertEqual(result, escaped)
+
+	def test_09_single_escape_fail(self):
+		"""
+		Test an escape on a line by itself.
+		"""
+		self._check_invalid_pattern("\\")
+
+	def test_09_single_exclamation_mark_fail(self):
+		"""
+		Test an escape on a line by itself.
+		"""
+		self._check_invalid_pattern("!")
+
+	def _check_invalid_pattern(self, git_ignore_pattern):
+		expected_message_pattern = re.escape(repr(git_ignore_pattern))
+		with self.assertRaisesRegexp(GitWildMatchPatternError, expected_message_pattern):
+			GitWildMatchPattern(git_ignore_pattern)
+
diff --git a/myenv/lib/python3.9/site-packages/pathspec/tests/test_pathspec.py b/myenv/lib/python3.9/site-packages/pathspec/tests/test_pathspec.py
new file mode 100644
index 0000000..3ce52d7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec/tests/test_pathspec.py
@@ -0,0 +1,226 @@
+# encoding: utf-8
+"""
+This script tests ``PathSpec``.
+"""
+
+import unittest
+
+import pathspec
+
+
+class PathSpecTest(unittest.TestCase):
+	"""
+	The ``PathSpecTest`` class tests the ``PathSpec`` class.
+	"""
+
+	def test_01_absolute_dir_paths_1(self):
+		"""
+		Tests that absolute paths will be properly normalized and matched.
+		"""
+		spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'foo',
+		])
+		results = set(spec.match_files([
+			'/a.py',
+			'/foo/a.py',
+			'/x/a.py',
+			'/x/foo/a.py',
+			'a.py',
+			'foo/a.py',
+			'x/a.py',
+			'x/foo/a.py',
+		]))
+		self.assertEqual(results, {
+			'/foo/a.py',
+			'/x/foo/a.py',
+			'foo/a.py',
+			'x/foo/a.py',
+		})
+
+	def test_01_absolute_dir_paths_2(self):
+		"""
+		Tests that absolute paths will be properly normalized and matched.
+		"""
+		spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'/foo',
+		])
+		results = set(spec.match_files([
+			'/a.py',
+			'/foo/a.py',
+			'/x/a.py',
+			'/x/foo/a.py',
+			'a.py',
+			'foo/a.py',
+			'x/a.py',
+			'x/foo/a.py',
+		]))
+		self.assertEqual(results, {
+			'/foo/a.py',
+			'foo/a.py',
+		})
+
+	def test_01_current_dir_paths(self):
+		"""
+		Tests that paths referencing the current directory will be properly
+		normalized and matched.
+		"""
+		spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'*.txt',
+			'!test1/',
+		])
+		results = set(spec.match_files([
+			'./src/test1/a.txt',
+			'./src/test1/b.txt',
+			'./src/test1/c/c.txt',
+			'./src/test2/a.txt',
+			'./src/test2/b.txt',
+			'./src/test2/c/c.txt',
+		]))
+		self.assertEqual(results, {
+			'./src/test2/a.txt',
+			'./src/test2/b.txt',
+			'./src/test2/c/c.txt',
+		})
+
+	def test_01_match_files(self):
+		"""
+		Tests that matching files one at a time yields the same results as
+		matching multiples files at once.
+		"""
+		spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'*.txt',
+			'!test1/',
+		])
+		test_files = [
+			'src/test1/a.txt',
+			'src/test1/b.txt',
+			'src/test1/c/c.txt',
+			'src/test2/a.txt',
+			'src/test2/b.txt',
+			'src/test2/c/c.txt',
+		]
+		single_results = set(filter(spec.match_file, test_files))
+		multi_results = set(spec.match_files(test_files))
+		self.assertEqual(single_results, multi_results)
+
+	def test_01_windows_current_dir_paths(self):
+		"""
+		Tests that paths referencing the current directory will be properly
+		normalized and matched.
+		"""
+		spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'*.txt',
+			'!test1/',
+		])
+		results = set(spec.match_files([
+			'.\\src\\test1\\a.txt',
+			'.\\src\\test1\\b.txt',
+			'.\\src\\test1\\c\\c.txt',
+			'.\\src\\test2\\a.txt',
+			'.\\src\\test2\\b.txt',
+			'.\\src\\test2\\c\\c.txt',
+		], separators=('\\',)))
+		self.assertEqual(results, {
+			'.\\src\\test2\\a.txt',
+			'.\\src\\test2\\b.txt',
+			'.\\src\\test2\\c\\c.txt',
+		})
+
+	def test_01_windows_paths(self):
+		"""
+		Tests that Windows paths will be properly normalized and matched.
+		"""
+		spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'*.txt',
+			'!test1/',
+		])
+		results = set(spec.match_files([
+			'src\\test1\\a.txt',
+			'src\\test1\\b.txt',
+			'src\\test1\\c\\c.txt',
+			'src\\test2\\a.txt',
+			'src\\test2\\b.txt',
+			'src\\test2\\c\\c.txt',
+		], separators=('\\',)))
+		self.assertEqual(results, {
+			'src\\test2\\a.txt',
+			'src\\test2\\b.txt',
+			'src\\test2\\c\\c.txt',
+		})
+
+	def test_02_eq(self):
+		"""
+		Tests equality.
+		"""
+		first_spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'*.txt',
+			'!test1/',
+		])
+		second_spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'*.txt',
+			'!test1/',
+		])
+		self.assertEqual(first_spec, second_spec)
+
+	def test_02_ne(self):
+		"""
+		Tests equality.
+		"""
+		first_spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'*.txt',
+		])
+		second_spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'!*.txt',
+		])
+		self.assertNotEqual(first_spec, second_spec)
+
+	def test_01_addition(self):
+		"""
+		Test pattern addition using + operator
+		"""
+		first_spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'test.txt',
+			'test.png'
+		])
+		second_spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'test.html',
+			'test.jpg'
+		])
+		combined_spec = first_spec + second_spec
+		results = set(combined_spec.match_files([
+			'test.txt',
+			'test.png',
+			'test.html',
+			'test.jpg'
+		], separators=('\\',)))
+		self.assertEqual(results, {
+			'test.txt',
+			'test.png',
+			'test.html',
+			'test.jpg'
+		})
+
+	def test_02_addition(self):
+		"""
+		Test pattern addition using += operator
+		"""
+		spec = pathspec.PathSpec.from_lines('gitwildmatch', [
+			'test.txt',
+			'test.png'
+		])
+		spec += pathspec.PathSpec.from_lines('gitwildmatch', [
+			'test.html',
+			'test.jpg'
+		])
+		results = set(spec.match_files([
+			'test.txt',
+			'test.png',
+			'test.html',
+			'test.jpg'
+		], separators=('\\',)))
+		self.assertEqual(results, {
+			'test.txt',
+			'test.png',
+			'test.html',
+			'test.jpg'
+		})
diff --git a/myenv/lib/python3.9/site-packages/pathspec/tests/test_util.py b/myenv/lib/python3.9/site-packages/pathspec/tests/test_util.py
new file mode 100644
index 0000000..943bde2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec/tests/test_util.py
@@ -0,0 +1,380 @@
+# encoding: utf-8
+"""
+This script tests utility functions.
+"""
+
+import errno
+import os
+import os.path
+import shutil
+import sys
+import tempfile
+import unittest
+
+from pathspec.util import iter_tree_entries, iter_tree_files, RecursionError, normalize_file
+
+
+class IterTreeTest(unittest.TestCase):
+	"""
+	The ``IterTreeTest`` class tests `pathspec.util.iter_tree_files()`.
+	"""
+
+	def make_dirs(self, dirs):
+		"""
+		Create the specified directories.
+		"""
+		for dir in dirs:
+			os.mkdir(os.path.join(self.temp_dir, self.ospath(dir)))
+
+	def make_files(self, files):
+		"""
+		Create the specified files.
+		"""
+		for file in files:
+			self.mkfile(os.path.join(self.temp_dir, self.ospath(file)))
+
+	def make_links(self, links):
+		"""
+		Create the specified links.
+		"""
+		for link, node in links:
+			os.symlink(os.path.join(self.temp_dir, self.ospath(node)), os.path.join(self.temp_dir, self.ospath(link)))
+
+	@staticmethod
+	def mkfile(file):
+		"""
+		Creates an empty file.
+		"""
+		with open(file, 'wb'):
+			pass
+
+	@staticmethod
+	def ospath(path):
+		"""
+		Convert the POSIX path to a native OS path.
+		"""
+		return os.path.join(*path.split('/'))
+
+	def require_realpath(self):
+		"""
+		Skips the test if `os.path.realpath` does not properly support
+		symlinks.
+		"""
+		if self.broken_realpath:
+			raise unittest.SkipTest("`os.path.realpath` is broken.")
+
+	def require_symlink(self):
+		"""
+		Skips the test if `os.symlink` is not supported.
+		"""
+		if self.no_symlink:
+			raise unittest.SkipTest("`os.symlink` is not supported.")
+
+	def setUp(self):
+		"""
+		Called before each test.
+		"""
+		self.temp_dir = tempfile.mkdtemp()
+
+	def tearDown(self):
+		"""
+		Called after each test.
+		"""
+		shutil.rmtree(self.temp_dir)
+
+	def test_1_files(self):
+		"""
+		Tests to make sure all files are found.
+		"""
+		self.make_dirs([
+			'Empty',
+			'Dir',
+			'Dir/Inner',
+		])
+		self.make_files([
+			'a',
+			'b',
+			'Dir/c',
+			'Dir/d',
+			'Dir/Inner/e',
+			'Dir/Inner/f',
+		])
+		results = set(iter_tree_files(self.temp_dir))
+		self.assertEqual(results, set(map(self.ospath, [
+			'a',
+			'b',
+			'Dir/c',
+			'Dir/d',
+			'Dir/Inner/e',
+			'Dir/Inner/f',
+		])))
+
+	def test_2_0_check_symlink(self):
+		"""
+		Tests whether links can be created.
+		"""
+		# NOTE: Windows does not support `os.symlink` for Python 2. Windows
+		# Vista and greater supports `os.symlink` for Python 3.2+.
+		no_symlink = None
+		try:
+			file = os.path.join(self.temp_dir, 'file')
+			link = os.path.join(self.temp_dir, 'link')
+			self.mkfile(file)
+
+			try:
+				os.symlink(file, link)
+			except (AttributeError, NotImplementedError):
+				no_symlink = True
+				raise
+			no_symlink = False
+
+		finally:
+			self.__class__.no_symlink = no_symlink
+
+	def test_2_1_check_realpath(self):
+		"""
+		Tests whether `os.path.realpath` works properly with symlinks.
+		"""
+		# NOTE: Windows does not follow symlinks with `os.path.realpath`
+		# which is what we use to detect recursion. See <https://bugs.python.org/issue9949>
+		# for details.
+		broken_realpath = None
+		try:
+			self.require_symlink()
+			file = os.path.join(self.temp_dir, 'file')
+			link = os.path.join(self.temp_dir, 'link')
+			self.mkfile(file)
+			os.symlink(file, link)
+
+			try:
+				self.assertEqual(os.path.realpath(file), os.path.realpath(link))
+			except AssertionError:
+				broken_realpath = True
+				raise
+			broken_realpath = False
+
+		finally:
+			self.__class__.broken_realpath = broken_realpath
+
+	def test_2_2_links(self):
+		"""
+		Tests to make sure links to directories and files work.
+		"""
+		self.require_symlink()
+		self.make_dirs([
+			'Dir',
+		])
+		self.make_files([
+			'a',
+			'b',
+			'Dir/c',
+			'Dir/d',
+		])
+		self.make_links([
+			('ax', 'a'),
+			('bx', 'b'),
+			('Dir/cx', 'Dir/c'),
+			('Dir/dx', 'Dir/d'),
+			('DirX', 'Dir'),
+		])
+		results = set(iter_tree_files(self.temp_dir))
+		self.assertEqual(results, set(map(self.ospath, [
+			'a',
+			'ax',
+			'b',
+			'bx',
+			'Dir/c',
+			'Dir/cx',
+			'Dir/d',
+			'Dir/dx',
+			'DirX/c',
+			'DirX/cx',
+			'DirX/d',
+			'DirX/dx',
+		])))
+
+	def test_2_3_sideways_links(self):
+		"""
+		Tests to make sure the same directory can be encountered multiple
+		times via links.
+		"""
+		self.require_symlink()
+		self.make_dirs([
+			'Dir',
+			'Dir/Target',
+		])
+		self.make_files([
+			'Dir/Target/file',
+		])
+		self.make_links([
+			('Ax', 'Dir'),
+			('Bx', 'Dir'),
+			('Cx', 'Dir/Target'),
+			('Dx', 'Dir/Target'),
+			('Dir/Ex', 'Dir/Target'),
+			('Dir/Fx', 'Dir/Target'),
+		])
+		results = set(iter_tree_files(self.temp_dir))
+		self.assertEqual(results, set(map(self.ospath, [
+			'Ax/Ex/file',
+			'Ax/Fx/file',
+			'Ax/Target/file',
+			'Bx/Ex/file',
+			'Bx/Fx/file',
+			'Bx/Target/file',
+			'Cx/file',
+			'Dx/file',
+			'Dir/Ex/file',
+			'Dir/Fx/file',
+			'Dir/Target/file',
+		])))
+
+	def test_2_4_recursive_links(self):
+		"""
+		Tests detection of recursive links.
+		"""
+		self.require_symlink()
+		self.require_realpath()
+		self.make_dirs([
+			'Dir',
+		])
+		self.make_files([
+			'Dir/file',
+		])
+		self.make_links([
+			('Dir/Self', 'Dir'),
+		])
+		with self.assertRaises(RecursionError) as context:
+			set(iter_tree_files(self.temp_dir))
+		self.assertEqual(context.exception.first_path, 'Dir')
+		self.assertEqual(context.exception.second_path, self.ospath('Dir/Self'))
+
+	def test_2_5_recursive_circular_links(self):
+		"""
+		Tests detection of recursion through circular links.
+		"""
+		self.require_symlink()
+		self.require_realpath()
+		self.make_dirs([
+			'A',
+			'B',
+			'C',
+		])
+		self.make_files([
+			'A/d',
+			'B/e',
+			'C/f',
+		])
+		self.make_links([
+			('A/Bx', 'B'),
+			('B/Cx', 'C'),
+			('C/Ax', 'A'),
+		])
+		with self.assertRaises(RecursionError) as context:
+			set(iter_tree_files(self.temp_dir))
+		self.assertIn(context.exception.first_path, ('A', 'B', 'C'))
+		self.assertEqual(context.exception.second_path, {
+			'A': self.ospath('A/Bx/Cx/Ax'),
+			'B': self.ospath('B/Cx/Ax/Bx'),
+			'C': self.ospath('C/Ax/Bx/Cx'),
+		}[context.exception.first_path])
+
+	def test_2_6_detect_broken_links(self):
+		"""
+		Tests that broken links are detected.
+		"""
+		def reraise(e):
+			raise e
+
+		self.require_symlink()
+		self.make_links([
+			('A', 'DOES_NOT_EXIST'),
+		])
+		with self.assertRaises(OSError) as context:
+			set(iter_tree_files(self.temp_dir, on_error=reraise))
+		self.assertEqual(context.exception.errno, errno.ENOENT)
+
+	def test_2_7_ignore_broken_links(self):
+		"""
+		Tests that broken links are ignored.
+		"""
+		self.require_symlink()
+		self.make_links([
+			('A', 'DOES_NOT_EXIST'),
+		])
+		results = set(iter_tree_files(self.temp_dir))
+		self.assertEqual(results, set())
+
+	def test_2_8_no_follow_links(self):
+		"""
+		Tests to make sure directory links can be ignored.
+		"""
+		self.require_symlink()
+		self.make_dirs([
+			'Dir',
+		])
+		self.make_files([
+			'A',
+			'B',
+			'Dir/C',
+			'Dir/D',
+		])
+		self.make_links([
+			('Ax', 'A'),
+			('Bx', 'B'),
+			('Dir/Cx', 'Dir/C'),
+			('Dir/Dx', 'Dir/D'),
+			('DirX', 'Dir'),
+		])
+		results = set(iter_tree_files(self.temp_dir, follow_links=False))
+		self.assertEqual(results, set(map(self.ospath, [
+			'A',
+			'Ax',
+			'B',
+			'Bx',
+			'Dir/C',
+			'Dir/Cx',
+			'Dir/D',
+			'Dir/Dx',
+			'DirX',
+		])))
+
+	def test_3_entries(self):
+		"""
+		Tests to make sure all files are found.
+		"""
+		self.make_dirs([
+			'Empty',
+			'Dir',
+			'Dir/Inner',
+		])
+		self.make_files([
+			'a',
+			'b',
+			'Dir/c',
+			'Dir/d',
+			'Dir/Inner/e',
+			'Dir/Inner/f',
+		])
+		results = {entry.path for entry in iter_tree_entries(self.temp_dir)}
+		self.assertEqual(results, set(map(self.ospath, [
+			'a',
+			'b',
+			'Dir',
+			'Dir/c',
+			'Dir/d',
+			'Dir/Inner',
+			'Dir/Inner/e',
+			'Dir/Inner/f',
+			'Empty',
+		])))
+
+	@unittest.skipIf(sys.version_info < (3, 4), "pathlib entered stdlib in Python 3.4")
+	def test_4_normalizing_pathlib_path(self):
+		"""
+		Tests passing pathlib.Path as argument.
+		"""
+		from pathlib import Path
+		first_spec = normalize_file(Path('a.txt'))
+		second_spec = normalize_file('a.txt')
+		self.assertEqual(first_spec, second_spec)
diff --git a/myenv/lib/python3.9/site-packages/pathspec/util.py b/myenv/lib/python3.9/site-packages/pathspec/util.py
new file mode 100644
index 0000000..64a5dea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pathspec/util.py
@@ -0,0 +1,665 @@
+# encoding: utf-8
+"""
+This module provides utility methods for dealing with path-specs.
+"""
+
+import os
+import os.path
+import posixpath
+import stat
+try:
+	from typing import (
+		Any,
+		AnyStr,
+		Callable,
+		Dict,
+		Iterable,
+		Iterator,
+		List,
+		Optional,
+		Sequence,
+		Set,
+		Text,
+		Union)
+except ImportError:
+	pass
+try:
+	# Python 3.6+ type hints.
+	from os import PathLike
+	from typing import Collection
+except ImportError:
+	pass
+
+from .compat import (
+	CollectionType,
+	IterableType,
+	string_types,
+	unicode)
+from .pattern import Pattern
+
+NORMALIZE_PATH_SEPS = [sep for sep in [os.sep, os.altsep] if sep and sep != posixpath.sep]
+"""
+*NORMALIZE_PATH_SEPS* (:class:`list` of :class:`str`) contains the path
+separators that need to be normalized to the POSIX separator for the
+current operating system. The separators are determined by examining
+:data:`os.sep` and :data:`os.altsep`.
+"""
+
+_registered_patterns = {}
+"""
+*_registered_patterns* (:class:`dict`) maps a name (:class:`str`) to the
+registered pattern factory (:class:`~collections.abc.Callable`).
+"""
+
+
+def detailed_match_files(patterns, files, all_matches=None):
+	# type: (Iterable[Pattern], Iterable[Text], Optional[bool]) -> Dict[Text, 'MatchDetail']
+	"""
+	Matches the files to the patterns, and returns which patterns matched
+	the files.
+
+	*patterns* (:class:`~collections.abc.Iterable` of :class:`~pathspec.pattern.Pattern`)
+	contains the patterns to use.
+
+	*files* (:class:`~collections.abc.Iterable` of :class:`str`) contains
+	the normalized file paths to be matched against *patterns*.
+
+	*all_matches* (:class:`boot` or :data:`None`) is whether to return all
+	matches patterns (:data:`True`), or only the last matched pattern
+	(:data:`False`). Default is :data:`None` for :data:`False`.
+
+	Returns the matched files (:class:`dict`) which maps each matched file
+	(:class:`str`) to the patterns that matched in order (:class:`.MatchDetail`).
+	"""
+	all_files = files if isinstance(files, CollectionType) else list(files)
+	return_files = {}
+	for pattern in patterns:
+		if pattern.include is not None:
+			result_files = pattern.match(all_files)
+			if pattern.include:
+				# Add files and record pattern.
+				for result_file in result_files:
+					if result_file in return_files:
+						if all_matches:
+							return_files[result_file].patterns.append(pattern)
+						else:
+							return_files[result_file].patterns[0] = pattern
+					else:
+						return_files[result_file] = MatchDetail([pattern])
+
+			else:
+				# Remove files.
+				for file in result_files:
+					del return_files[file]
+
+	return return_files
+
+
+def _is_iterable(value):
+	# type: (Any) -> bool
+	"""
+	Check whether the value is an iterable (excludes strings).
+
+	*value* is the value to check,
+
+	Returns whether *value* is a iterable (:class:`bool`).
+	"""
+	return isinstance(value, IterableType) and not isinstance(value, (unicode, bytes))
+
+
+def iter_tree_entries(root, on_error=None, follow_links=None):
+	# type: (Text, Optional[Callable], Optional[bool]) -> Iterator['TreeEntry']
+	"""
+	Walks the specified directory for all files and directories.
+
+	*root* (:class:`str`) is the root directory to search.
+
+	*on_error* (:class:`~collections.abc.Callable` or :data:`None`)
+	optionally is the error handler for file-system exceptions. It will be
+	called with the exception (:exc:`OSError`). Reraise the exception to
+	abort the walk. Default is :data:`None` to ignore file-system
+	exceptions.
+
+	*follow_links* (:class:`bool` or :data:`None`) optionally is whether
+	to walk symbolic links that resolve to directories. Default is
+	:data:`None` for :data:`True`.
+
+	Raises :exc:`RecursionError` if recursion is detected.
+
+	Returns an :class:`~collections.abc.Iterator` yielding each file or
+	directory entry (:class:`.TreeEntry`) relative to *root*.
+	"""
+	if on_error is not None and not callable(on_error):
+		raise TypeError("on_error:{!r} is not callable.".format(on_error))
+
+	if follow_links is None:
+		follow_links = True
+
+	for entry in _iter_tree_entries_next(os.path.abspath(root), '', {}, on_error, follow_links):
+		yield entry
+
+
+def iter_tree_files(root, on_error=None, follow_links=None):
+	# type: (Text, Optional[Callable], Optional[bool]) -> Iterator[Text]
+	"""
+	Walks the specified directory for all files.
+
+	*root* (:class:`str`) is the root directory to search for files.
+
+	*on_error* (:class:`~collections.abc.Callable` or :data:`None`)
+	optionally is the error handler for file-system exceptions. It will be
+	called with the exception (:exc:`OSError`). Reraise the exception to
+	abort the walk. Default is :data:`None` to ignore file-system
+	exceptions.
+
+	*follow_links* (:class:`bool` or :data:`None`) optionally is whether
+	to walk symbolic links that resolve to directories. Default is
+	:data:`None` for :data:`True`.
+
+	Raises :exc:`RecursionError` if recursion is detected.
+
+	Returns an :class:`~collections.abc.Iterator` yielding the path to
+	each file (:class:`str`) relative to *root*.
+	"""
+	if on_error is not None and not callable(on_error):
+		raise TypeError("on_error:{!r} is not callable.".format(on_error))
+
+	if follow_links is None:
+		follow_links = True
+
+	for entry in _iter_tree_entries_next(os.path.abspath(root), '', {}, on_error, follow_links):
+		if not entry.is_dir(follow_links):
+			yield entry.path
+
+
+# Alias `iter_tree_files()` as `iter_tree()`.
+iter_tree = iter_tree_files
+
+
+def _iter_tree_entries_next(root_full, dir_rel, memo, on_error, follow_links):
+	# type: (Text, Text, Dict[Text, Text], Callable, bool) -> Iterator['TreeEntry']
+	"""
+	Scan the directory for all descendant files.
+
+	*root_full* (:class:`str`) the absolute path to the root directory.
+
+	*dir_rel* (:class:`str`) the path to the directory to scan relative to
+	*root_full*.
+
+	*memo* (:class:`dict`) keeps track of ancestor directories
+	encountered. Maps each ancestor real path (:class:`str`) to relative
+	path (:class:`str`).
+
+	*on_error* (:class:`~collections.abc.Callable` or :data:`None`)
+	optionally is the error handler for file-system exceptions.
+
+	*follow_links* (:class:`bool`) is whether to walk symbolic links that
+	resolve to directories.
+
+	Yields each entry (:class:`.TreeEntry`).
+	"""
+	dir_full = os.path.join(root_full, dir_rel)
+	dir_real = os.path.realpath(dir_full)
+
+	# Remember each encountered ancestor directory and its canonical
+	# (real) path. If a canonical path is encountered more than once,
+	# recursion has occurred.
+	if dir_real not in memo:
+		memo[dir_real] = dir_rel
+	else:
+		raise RecursionError(real_path=dir_real, first_path=memo[dir_real], second_path=dir_rel)
+
+	for node_name in os.listdir(dir_full):
+		node_rel = os.path.join(dir_rel, node_name)
+		node_full = os.path.join(root_full, node_rel)
+
+		# Inspect child node.
+		try:
+			node_lstat = os.lstat(node_full)
+		except OSError as e:
+			if on_error is not None:
+				on_error(e)
+			continue
+
+		if stat.S_ISLNK(node_lstat.st_mode):
+			# Child node is a link, inspect the target node.
+			is_link = True
+			try:
+				node_stat = os.stat(node_full)
+			except OSError as e:
+				if on_error is not None:
+					on_error(e)
+				continue
+		else:
+			is_link = False
+			node_stat = node_lstat
+
+		if stat.S_ISDIR(node_stat.st_mode) and (follow_links or not is_link):
+			# Child node is a directory, recurse into it and yield its
+			# descendant files.
+			yield TreeEntry(node_name, node_rel, node_lstat, node_stat)
+
+			for entry in _iter_tree_entries_next(root_full, node_rel, memo, on_error, follow_links):
+				yield entry
+
+		elif stat.S_ISREG(node_stat.st_mode) or is_link:
+			# Child node is either a file or an unfollowed link, yield it.
+			yield TreeEntry(node_name, node_rel, node_lstat, node_stat)
+
+	# NOTE: Make sure to remove the canonical (real) path of the directory
+	# from the ancestors memo once we are done with it. This allows the
+	# same directory to appear multiple times. If this is not done, the
+	# second occurrence of the directory will be incorrectly interpreted
+	# as a recursion. See <https://github.com/cpburnz/python-path-specification/pull/7>.
+	del memo[dir_real]
+
+
+def lookup_pattern(name):
+	# type: (Text) -> Callable[[AnyStr], Pattern]
+	"""
+	Lookups a registered pattern factory by name.
+
+	*name* (:class:`str`) is the name of the pattern factory.
+
+	Returns the registered pattern factory (:class:`~collections.abc.Callable`).
+	If no pattern factory is registered, raises :exc:`KeyError`.
+	"""
+	return _registered_patterns[name]
+
+
+def match_file(patterns, file):
+	# type: (Iterable[Pattern], Text) -> bool
+	"""
+	Matches the file to the patterns.
+
+	*patterns* (:class:`~collections.abc.Iterable` of :class:`~pathspec.pattern.Pattern`)
+	contains the patterns to use.
+
+	*file* (:class:`str`) is the normalized file path to be matched
+	against *patterns*.
+
+	Returns :data:`True` if *file* matched; otherwise, :data:`False`.
+	"""
+	matched = False
+	for pattern in patterns:
+		if pattern.include is not None:
+			if file in pattern.match((file,)):
+				matched = pattern.include
+	return matched
+
+
+def match_files(patterns, files):
+	# type: (Iterable[Pattern], Iterable[Text]) -> Set[Text]
+	"""
+	Matches the files to the patterns.
+
+	*patterns* (:class:`~collections.abc.Iterable` of :class:`~pathspec.pattern.Pattern`)
+	contains the patterns to use.
+
+	*files* (:class:`~collections.abc.Iterable` of :class:`str`) contains
+	the normalized file paths to be matched against *patterns*.
+
+	Returns the matched files (:class:`set` of :class:`str`).
+	"""
+	all_files = files if isinstance(files, CollectionType) else list(files)
+	return_files = set()
+	for pattern in patterns:
+		if pattern.include is not None:
+			result_files = pattern.match(all_files)
+			if pattern.include:
+				return_files.update(result_files)
+			else:
+				return_files.difference_update(result_files)
+	return return_files
+
+
+def _normalize_entries(entries, separators=None):
+	# type: (Iterable['TreeEntry'], Optional[Collection[Text]]) -> Dict[Text, 'TreeEntry']
+	"""
+	Normalizes the entry paths to use the POSIX path separator.
+
+	*entries* (:class:`~collections.abc.Iterable` of :class:`.TreeEntry`)
+	contains the entries to be normalized.
+
+	*separators* (:class:`~collections.abc.Collection` of :class:`str`; or
+	:data:`None`) optionally contains the path separators to normalize.
+	See :func:`normalize_file` for more information.
+
+	Returns a :class:`dict` mapping the each normalized file path (:class:`str`)
+	to the entry (:class:`.TreeEntry`)
+	"""
+	norm_files = {}
+	for entry in entries:
+		norm_files[normalize_file(entry.path, separators=separators)] = entry
+	return norm_files
+
+
+def normalize_file(file, separators=None):
+	# type: (Union[Text, PathLike], Optional[Collection[Text]]) -> Text
+	"""
+	Normalizes the file path to use the POSIX path separator (i.e.,
+	``'/'``), and make the paths relative (remove leading ``'/'``).
+
+	*file* (:class:`str` or :class:`pathlib.PurePath`) is the file path.
+
+	*separators* (:class:`~collections.abc.Collection` of :class:`str`; or
+	:data:`None`) optionally contains the path separators to normalize.
+	This does not need to include the POSIX path separator (``'/'``), but
+	including it will not affect the results. Default is :data:`None` for
+	:data:`NORMALIZE_PATH_SEPS`. To prevent normalization, pass an empty
+	container (e.g., an empty tuple ``()``).
+
+	Returns the normalized file path (:class:`str`).
+	"""
+	# Normalize path separators.
+	if separators is None:
+		separators = NORMALIZE_PATH_SEPS
+
+	# Convert path object to string.
+	norm_file = str(file)
+
+	for sep in separators:
+		norm_file = norm_file.replace(sep, posixpath.sep)
+
+	if norm_file.startswith('/'):
+		# Make path relative.
+		norm_file = norm_file[1:]
+
+	elif norm_file.startswith('./'):
+		# Remove current directory prefix.
+		norm_file = norm_file[2:]
+
+	return norm_file
+
+
+def normalize_files(files, separators=None):
+	# type: (Iterable[Union[str, PathLike]], Optional[Collection[Text]]) -> Dict[Text, List[Union[str, PathLike]]]
+	"""
+	Normalizes the file paths to use the POSIX path separator.
+
+	*files* (:class:`~collections.abc.Iterable` of :class:`str` or
+	:class:`pathlib.PurePath`) contains the file paths to be normalized.
+
+	*separators* (:class:`~collections.abc.Collection` of :class:`str`; or
+	:data:`None`) optionally contains the path separators to normalize.
+	See :func:`normalize_file` for more information.
+
+	Returns a :class:`dict` mapping the each normalized file path
+	(:class:`str`) to the original file paths (:class:`list` of
+	:class:`str` or :class:`pathlib.PurePath`).
+	"""
+	norm_files = {}
+	for path in files:
+		norm_file = normalize_file(path, separators=separators)
+		if norm_file in norm_files:
+			norm_files[norm_file].append(path)
+		else:
+			norm_files[norm_file] = [path]
+
+	return norm_files
+
+
+def register_pattern(name, pattern_factory, override=None):
+	# type: (Text, Callable[[AnyStr], Pattern], Optional[bool]) -> None
+	"""
+	Registers the specified pattern factory.
+
+	*name* (:class:`str`) is the name to register the pattern factory
+	under.
+
+	*pattern_factory* (:class:`~collections.abc.Callable`) is used to
+	compile patterns. It must accept an uncompiled pattern (:class:`str`)
+	and return the compiled pattern (:class:`.Pattern`).
+
+	*override* (:class:`bool` or :data:`None`) optionally is whether to
+	allow overriding an already registered pattern under the same name
+	(:data:`True`), instead of raising an :exc:`AlreadyRegisteredError`
+	(:data:`False`). Default is :data:`None` for :data:`False`.
+	"""
+	if not isinstance(name, string_types):
+		raise TypeError("name:{!r} is not a string.".format(name))
+	if not callable(pattern_factory):
+		raise TypeError("pattern_factory:{!r} is not callable.".format(pattern_factory))
+	if name in _registered_patterns and not override:
+		raise AlreadyRegisteredError(name, _registered_patterns[name])
+	_registered_patterns[name] = pattern_factory
+
+
+class AlreadyRegisteredError(Exception):
+	"""
+	The :exc:`AlreadyRegisteredError` exception is raised when a pattern
+	factory is registered under a name already in use.
+	"""
+
+	def __init__(self, name, pattern_factory):
+		# type: (Text, Callable[[AnyStr], Pattern]) -> None
+		"""
+		Initializes the :exc:`AlreadyRegisteredError` instance.
+
+		*name* (:class:`str`) is the name of the registered pattern.
+
+		*pattern_factory* (:class:`~collections.abc.Callable`) is the
+		registered pattern factory.
+		"""
+		super(AlreadyRegisteredError, self).__init__(name, pattern_factory)
+
+	@property
+	def message(self):
+		# type: () -> Text
+		"""
+		*message* (:class:`str`) is the error message.
+		"""
+		return "{name!r} is already registered for pattern factory:{pattern_factory!r}.".format(
+			name=self.name,
+			pattern_factory=self.pattern_factory,
+		)
+
+	@property
+	def name(self):
+		# type: () -> Text
+		"""
+		*name* (:class:`str`) is the name of the registered pattern.
+		"""
+		return self.args[0]
+
+	@property
+	def pattern_factory(self):
+		# type: () -> Callable[[AnyStr], Pattern]
+		"""
+		*pattern_factory* (:class:`~collections.abc.Callable`) is the
+		registered pattern factory.
+		"""
+		return self.args[1]
+
+
+class RecursionError(Exception):
+	"""
+	The :exc:`RecursionError` exception is raised when recursion is
+	detected.
+	"""
+
+	def __init__(self, real_path, first_path, second_path):
+		# type: (Text, Text, Text) -> None
+		"""
+		Initializes the :exc:`RecursionError` instance.
+
+		*real_path* (:class:`str`) is the real path that recursion was
+		encountered on.
+
+		*first_path* (:class:`str`) is the first path encountered for
+		*real_path*.
+
+		*second_path* (:class:`str`) is the second path encountered for
+		*real_path*.
+		"""
+		super(RecursionError, self).__init__(real_path, first_path, second_path)
+
+	@property
+	def first_path(self):
+		# type: () -> Text
+		"""
+		*first_path* (:class:`str`) is the first path encountered for
+		:attr:`self.real_path <RecursionError.real_path>`.
+		"""
+		return self.args[1]
+
+	@property
+	def message(self):
+		# type: () -> Text
+		"""
+		*message* (:class:`str`) is the error message.
+		"""
+		return "Real path {real!r} was encountered at {first!r} and then {second!r}.".format(
+			real=self.real_path,
+			first=self.first_path,
+			second=self.second_path,
+		)
+
+	@property
+	def real_path(self):
+		# type: () -> Text
+		"""
+		*real_path* (:class:`str`) is the real path that recursion was
+		encountered on.
+		"""
+		return self.args[0]
+
+	@property
+	def second_path(self):
+		# type: () -> Text
+		"""
+		*second_path* (:class:`str`) is the second path encountered for
+		:attr:`self.real_path <RecursionError.real_path>`.
+		"""
+		return self.args[2]
+
+
+class MatchDetail(object):
+	"""
+	The :class:`.MatchDetail` class contains information about
+	"""
+
+	#: Make the class dict-less.
+	__slots__ = ('patterns',)
+
+	def __init__(self, patterns):
+		# type: (Sequence[Pattern]) -> None
+		"""
+		Initialize the :class:`.MatchDetail` instance.
+
+		*patterns* (:class:`~collections.abc.Sequence` of :class:`~pathspec.pattern.Pattern`)
+		contains the patterns that matched the file in the order they were
+		encountered.
+		"""
+
+		self.patterns = patterns
+		"""
+		*patterns* (:class:`~collections.abc.Sequence` of :class:`~pathspec.pattern.Pattern`)
+		contains the patterns that matched the file in the order they were
+		encountered.
+		"""
+
+
+class TreeEntry(object):
+	"""
+	The :class:`.TreeEntry` class contains information about a file-system
+	entry.
+	"""
+
+	#: Make the class dict-less.
+	__slots__ = ('_lstat', 'name', 'path', '_stat')
+
+	def __init__(self, name, path, lstat, stat):
+		# type: (Text, Text, os.stat_result, os.stat_result) -> None
+		"""
+		Initialize the :class:`.TreeEntry` instance.
+
+		*name* (:class:`str`) is the base name of the entry.
+
+		*path* (:class:`str`) is the relative path of the entry.
+
+		*lstat* (:class:`~os.stat_result`) is the stat result of the direct
+		entry.
+
+		*stat* (:class:`~os.stat_result`) is the stat result of the entry,
+		potentially linked.
+		"""
+
+		self._lstat = lstat
+		"""
+		*_lstat* (:class:`~os.stat_result`) is the stat result of the direct
+		entry.
+		"""
+
+		self.name = name
+		"""
+		*name* (:class:`str`) is the base name of the entry.
+		"""
+
+		self.path = path
+		"""
+		*path* (:class:`str`) is the path of the entry.
+		"""
+
+		self._stat = stat
+		"""
+		*_stat* (:class:`~os.stat_result`) is the stat result of the linked
+		entry.
+		"""
+
+	def is_dir(self, follow_links=None):
+		# type: (Optional[bool]) -> bool
+		"""
+		Get whether the entry is a directory.
+
+		*follow_links* (:class:`bool` or :data:`None`) is whether to follow
+		symbolic links. If this is :data:`True`, a symlink to a directory
+		will result in :data:`True`. Default is :data:`None` for :data:`True`.
+
+		Returns whether the entry is a directory (:class:`bool`).
+		"""
+		if follow_links is None:
+			follow_links = True
+
+		node_stat = self._stat if follow_links else self._lstat
+		return stat.S_ISDIR(node_stat.st_mode)
+
+	def is_file(self, follow_links=None):
+		# type: (Optional[bool]) -> bool
+		"""
+		Get whether the entry is a regular file.
+
+		*follow_links* (:class:`bool` or :data:`None`) is whether to follow
+		symbolic links. If this is :data:`True`, a symlink to a regular file
+		will result in :data:`True`. Default is :data:`None` for :data:`True`.
+
+		Returns whether the entry is a regular file (:class:`bool`).
+		"""
+		if follow_links is None:
+			follow_links = True
+
+		node_stat = self._stat if follow_links else self._lstat
+		return stat.S_ISREG(node_stat.st_mode)
+
+	def is_symlink(self):
+		# type: () -> bool
+		"""
+		Returns whether the entry is a symbolic link (:class:`bool`).
+		"""
+		return stat.S_ISLNK(self._lstat.st_mode)
+
+	def stat(self, follow_links=None):
+		# type: (Optional[bool]) -> os.stat_result
+		"""
+		Get the cached stat result for the entry.
+
+		*follow_links* (:class:`bool` or :data:`None`) is whether to follow
+		symbolic links. If this is :data:`True`, the stat result of the
+		linked file will be returned. Default is :data:`None` for :data:`True`.
+
+		Returns that stat result (:class:`~os.stat_result`).
+		"""
+		if follow_links is None:
+			follow_links = True
+
+		return self._stat if follow_links else self._lstat
diff --git a/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/INSTALLER
new file mode 100644
index 0000000..a1b589e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/LICENSE.txt b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/LICENSE.txt
new file mode 100644
index 0000000..737fec5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/LICENSE.txt
@@ -0,0 +1,20 @@
+Copyright (c) 2008-2019 The pip developers (see AUTHORS.txt file)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/METADATA b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/METADATA
new file mode 100644
index 0000000..7fdd705
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/METADATA
@@ -0,0 +1,88 @@
+Metadata-Version: 2.1
+Name: pip
+Version: 20.2.3
+Summary: The PyPA recommended tool for installing Python packages.
+Home-page: https://pip.pypa.io/
+Author: The pip developers
+Author-email: distutils-sig@python.org
+License: MIT
+Project-URL: Documentation, https://pip.pypa.io
+Project-URL: Source, https://github.com/pypa/pip
+Project-URL: Changelog, https://pip.pypa.io/en/stable/news/
+Keywords: distutils easy_install egg setuptools wheel virtualenv
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*
+
+pip - The Python Package Installer
+==================================
+
+.. image:: https://img.shields.io/pypi/v/pip.svg
+   :target: https://pypi.org/project/pip/
+
+.. image:: https://readthedocs.org/projects/pip/badge/?version=latest
+   :target: https://pip.pypa.io/en/latest
+
+pip is the `package installer`_ for Python. You can use pip to install packages from the `Python Package Index`_ and other indexes.
+
+Please take a look at our documentation for how to install and use pip:
+
+* `Installation`_
+* `Usage`_
+
+We release updates regularly, with a new version every 3 months. Find more details in our documentation:
+
+* `Release notes`_
+* `Release process`_
+
+In 2020, we're working on improvements to the heart of pip. Please `learn more and take our survey`_ to help us do it right.
+
+If you find bugs, need help, or want to talk to the developers, please use our mailing lists or chat rooms:
+
+* `Issue tracking`_
+* `Discourse channel`_
+* `User IRC`_
+
+If you want to get involved head over to GitHub to get the source code, look at our development documentation and feel free to jump on the developer mailing lists and chat rooms:
+
+* `GitHub page`_
+* `Development documentation`_
+* `Development mailing list`_
+* `Development IRC`_
+
+Code of Conduct
+---------------
+
+Everyone interacting in the pip project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PyPA Code of Conduct`_.
+
+.. _package installer: https://packaging.python.org/guides/tool-recommendations/
+.. _Python Package Index: https://pypi.org
+.. _Installation: https://pip.pypa.io/en/stable/installing.html
+.. _Usage: https://pip.pypa.io/en/stable/
+.. _Release notes: https://pip.pypa.io/en/stable/news.html
+.. _Release process: https://pip.pypa.io/en/latest/development/release-process/
+.. _GitHub page: https://github.com/pypa/pip
+.. _Development documentation: https://pip.pypa.io/en/latest/development
+.. _learn more and take our survey: https://pyfound.blogspot.com/2020/03/new-pip-resolver-to-roll-out-this-year.html
+.. _Issue tracking: https://github.com/pypa/pip/issues
+.. _Discourse channel: https://discuss.python.org/c/packaging
+.. _Development mailing list: https://mail.python.org/mailman3/lists/distutils-sig.python.org/
+.. _User IRC: https://webchat.freenode.net/?channels=%23pypa
+.. _Development IRC: https://webchat.freenode.net/?channels=%23pypa-dev
+.. _PyPA Code of Conduct: https://www.pypa.io/en/latest/code-of-conduct/
+
+
diff --git a/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/RECORD b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/RECORD
new file mode 100644
index 0000000..3fddef8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/RECORD
@@ -0,0 +1,752 @@
+../../../bin/pip,sha256=lxARWf3c6OsWIj0iZQ5BfXNHyzypg4K0og3Z4jcNKW0,265
+../../../bin/pip3,sha256=lxARWf3c6OsWIj0iZQ5BfXNHyzypg4K0og3Z4jcNKW0,265
+../../../bin/pip3.9,sha256=lxARWf3c6OsWIj0iZQ5BfXNHyzypg4K0og3Z4jcNKW0,265
+pip-20.2.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pip-20.2.3.dist-info/LICENSE.txt,sha256=W6Ifuwlk-TatfRU2LR7W1JMcyMj5_y1NkRkOEJvnRDE,1090
+pip-20.2.3.dist-info/METADATA,sha256=9mmHP3BezeQwiPj12NdLFspqcxqrf7xqW6OX9PwZSr4,3708
+pip-20.2.3.dist-info/RECORD,,
+pip-20.2.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip-20.2.3.dist-info/WHEEL,sha256=ADKeyaGyKF5DwBNE0sRE5pvW-bSkFMJfBuhzZ3rceP4,110
+pip-20.2.3.dist-info/entry_points.txt,sha256=HtfDOwpUlr9s73jqLQ6wF9V0_0qvUXJwCBz7Vwx0Ue0,125
+pip-20.2.3.dist-info/top_level.txt,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pip/__init__.py,sha256=NkPibWV383InU5x7DgeQLdL2zhlXTKjJRBMQTSKNYjI,455
+pip/__main__.py,sha256=bqCAM1cj1HwHCDx3WJa-LJxOBXimGxE8OjBqAvnhVg0,911
+pip/__pycache__/__init__.cpython-39.pyc,,
+pip/__pycache__/__main__.cpython-39.pyc,,
+pip/_internal/__init__.py,sha256=2si23JBW1erg19xIJ8CD6tfGknz0ijtXmzuXjGfGMGE,495
+pip/_internal/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/__pycache__/build_env.cpython-39.pyc,,
+pip/_internal/__pycache__/cache.cpython-39.pyc,,
+pip/_internal/__pycache__/configuration.cpython-39.pyc,,
+pip/_internal/__pycache__/exceptions.cpython-39.pyc,,
+pip/_internal/__pycache__/locations.cpython-39.pyc,,
+pip/_internal/__pycache__/main.cpython-39.pyc,,
+pip/_internal/__pycache__/pyproject.cpython-39.pyc,,
+pip/_internal/__pycache__/self_outdated_check.cpython-39.pyc,,
+pip/_internal/__pycache__/wheel_builder.cpython-39.pyc,,
+pip/_internal/build_env.py,sha256=9_UaQ2fpsBvpKAji27f7bPAi2v3mb0cBvDYcejwFKNM,8088
+pip/_internal/cache.py,sha256=pT17VVxgzZK32aqY5FRS8GyAI73LKzNMF8ZelQ7Ojm0,12249
+pip/_internal/cli/__init__.py,sha256=FkHBgpxxb-_gd6r1FjnNhfMOzAUYyXoXKJ6abijfcFU,132
+pip/_internal/cli/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/cli/__pycache__/autocompletion.cpython-39.pyc,,
+pip/_internal/cli/__pycache__/base_command.cpython-39.pyc,,
+pip/_internal/cli/__pycache__/cmdoptions.cpython-39.pyc,,
+pip/_internal/cli/__pycache__/command_context.cpython-39.pyc,,
+pip/_internal/cli/__pycache__/main.cpython-39.pyc,,
+pip/_internal/cli/__pycache__/main_parser.cpython-39.pyc,,
+pip/_internal/cli/__pycache__/parser.cpython-39.pyc,,
+pip/_internal/cli/__pycache__/progress_bars.cpython-39.pyc,,
+pip/_internal/cli/__pycache__/req_command.cpython-39.pyc,,
+pip/_internal/cli/__pycache__/spinners.cpython-39.pyc,,
+pip/_internal/cli/__pycache__/status_codes.cpython-39.pyc,,
+pip/_internal/cli/autocompletion.py,sha256=ekGNtcDI0p7rFVc-7s4T9Tbss4Jgb7vsB649XJIblRg,6547
+pip/_internal/cli/base_command.py,sha256=bf058xM1HE9QJCNEHExbuTjL0peKg9kSxCNxDtwAh88,9302
+pip/_internal/cli/cmdoptions.py,sha256=M_BtuqeyRpZAUUYytts3pguBCF2RaGukVpDPE0niroI,28782
+pip/_internal/cli/command_context.py,sha256=ygMVoTy2jpNilKT-6416gFSQpaBtrKRBbVbi2fy__EU,975
+pip/_internal/cli/main.py,sha256=Hxc9dZyW3xiDsYZX-_J2cGXT5DWNLNn_Y7o9oUme-Ec,2616
+pip/_internal/cli/main_parser.py,sha256=voAtjo4WVPIYeu7Fqabva9SXaB3BjG0gH93GBfe6jHQ,2843
+pip/_internal/cli/parser.py,sha256=4FfwW8xB84CrkLs35ud90ZkhCcWyVkx17XD6j3XCW7c,9480
+pip/_internal/cli/progress_bars.py,sha256=J1zykt2LI4gbBeXorfYRmYV5FgXhcW4x3r6xE_a7Z7c,9121
+pip/_internal/cli/req_command.py,sha256=Eiz8TVzeqzG-40t7qLC1vO-vzjCRvX9C-qXMyfw9D1I,15132
+pip/_internal/cli/spinners.py,sha256=PS9s53LB5aDPelIn8FhKerK3bOdgeefFH5wSWJ2PCzI,5509
+pip/_internal/cli/status_codes.py,sha256=F6uDG6Gj7RNKQJUDnd87QKqI16Us-t-B0wPF_4QMpWc,156
+pip/_internal/commands/__init__.py,sha256=yoLAnmEXjoQgYfDuwsuWG3RzzD19oeHobGEhmpIYsB4,4100
+pip/_internal/commands/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/cache.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/check.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/completion.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/configuration.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/debug.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/download.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/freeze.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/hash.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/help.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/install.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/list.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/search.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/show.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/uninstall.cpython-39.pyc,,
+pip/_internal/commands/__pycache__/wheel.cpython-39.pyc,,
+pip/_internal/commands/cache.py,sha256=U3rLjls0AMMO8PxnhXVwIp7Biyvns8-gBThKTH3tX7Y,5676
+pip/_internal/commands/check.py,sha256=fqRrz2uKPC8Qsx2rgLygAD2Rbr-qxp1Q55zUoyZzB9Q,1677
+pip/_internal/commands/completion.py,sha256=ObssM77quf61qvbuSE6XLwUBdm_WcWIvXFI-Hy1RBsI,3081
+pip/_internal/commands/configuration.py,sha256=IN2QBF653sRiRU7-pHTpnZ6_gyiXNKUQkLiLaNRLKNw,9344
+pip/_internal/commands/debug.py,sha256=otBZnpnostX2kmYyOl6g6CeCLmk6H00Tsj2CDsCtFXw,7314
+pip/_internal/commands/download.py,sha256=EKFlj_ceGUEJj6yCDw7P6w7yUoB16IcNHhT2qnCFDNQ,4918
+pip/_internal/commands/freeze.py,sha256=vLBBP1d8wgEXrmlh06hbz_x_Q1mWHUdiWDa9NP2eKLE,3452
+pip/_internal/commands/hash.py,sha256=v2nYCiEsEI9nEam1p6GwdG8xyj5gFv-4WrqvNexKmeY,1843
+pip/_internal/commands/help.py,sha256=ryuMDt2tc7ic3NJYMjjoNRH5r6LrB2yQVZvehAm8bLs,1270
+pip/_internal/commands/install.py,sha256=OXjZCNSioJRfP7YMkJyAWLl7X7-8f6DkhWlhPhG6fXk,27995
+pip/_internal/commands/list.py,sha256=2o3rYw37ECrhe4-Bu5s_2C0bwhYgghh4833MxcWAEug,11312
+pip/_internal/commands/search.py,sha256=1HPAFU-tmgKrHhr4xNuk3xMoPeSzD_oDvDDiUFZZ15E,5756
+pip/_internal/commands/show.py,sha256=r69-G8HIepDKm4SeyeHj0Ez1P9xoihrpVUyXm6NmXYY,6996
+pip/_internal/commands/uninstall.py,sha256=Ys8hwFsg0kvvGtLGYG3ibL5BKvURhlSlCX50ZQ-hsHk,3311
+pip/_internal/commands/wheel.py,sha256=-HSISE5AV29I752Aqw4DdmulrGd8rB_ZTOdpbJ6T8iM,6419
+pip/_internal/configuration.py,sha256=-Gxz2J-KuvxiqWIJ9F-XnYVZ5lKhNk7VO6ondEbH4EM,14115
+pip/_internal/distributions/__init__.py,sha256=ECBUW5Gtu9TjJwyFLvim-i6kUMYVuikNh9I5asL6tbA,959
+pip/_internal/distributions/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/distributions/__pycache__/base.cpython-39.pyc,,
+pip/_internal/distributions/__pycache__/installed.cpython-39.pyc,,
+pip/_internal/distributions/__pycache__/sdist.cpython-39.pyc,,
+pip/_internal/distributions/__pycache__/wheel.cpython-39.pyc,,
+pip/_internal/distributions/base.py,sha256=ruprpM_L2T2HNi3KLUHlbHimZ1sWVw-3Q0Lb8O7TDAI,1425
+pip/_internal/distributions/installed.py,sha256=YqlkBKr6TVP1MAYS6SG8ojud21wVOYLMZ8jMLJe9MSU,760
+pip/_internal/distributions/sdist.py,sha256=D4XTMlCwgPlK69l62GLYkNSVTVe99fR5iAcVt2EbGok,4086
+pip/_internal/distributions/wheel.py,sha256=95uD-TfaYoq3KiKBdzk9YMN4RRqJ28LNoSTS2K46gek,1294
+pip/_internal/exceptions.py,sha256=ZVpArxQrSlm4qAMtHaY3nHvG_t5eSi3WCnMowdm_m8I,12637
+pip/_internal/index/__init__.py,sha256=vpt-JeTZefh8a-FC22ZeBSXFVbuBcXSGiILhQZJaNpQ,30
+pip/_internal/index/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/index/__pycache__/collector.cpython-39.pyc,,
+pip/_internal/index/__pycache__/package_finder.cpython-39.pyc,,
+pip/_internal/index/collector.py,sha256=rMdGdAABOrvIl0DYlCMWXr7mIoqrU2VGeQpCuWiPu1Q,22838
+pip/_internal/index/package_finder.py,sha256=ISieDd20dOSndMNybafCu3pO2JR3BKOfHv92Bes0j0Q,37364
+pip/_internal/locations.py,sha256=7YjzJy2CroQD8GBMemnHWRl9448BSIt0lfH98B-Dkd8,6732
+pip/_internal/main.py,sha256=IVBnUQ-FG7DK6617uEXRB5_QJqspAsBFmTmTesYkbdQ,437
+pip/_internal/models/__init__.py,sha256=3DHUd_qxpPozfzouoqa9g9ts1Czr5qaHfFxbnxriepM,63
+pip/_internal/models/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/models/__pycache__/candidate.cpython-39.pyc,,
+pip/_internal/models/__pycache__/direct_url.cpython-39.pyc,,
+pip/_internal/models/__pycache__/format_control.cpython-39.pyc,,
+pip/_internal/models/__pycache__/index.cpython-39.pyc,,
+pip/_internal/models/__pycache__/link.cpython-39.pyc,,
+pip/_internal/models/__pycache__/scheme.cpython-39.pyc,,
+pip/_internal/models/__pycache__/search_scope.cpython-39.pyc,,
+pip/_internal/models/__pycache__/selection_prefs.cpython-39.pyc,,
+pip/_internal/models/__pycache__/target_python.cpython-39.pyc,,
+pip/_internal/models/__pycache__/wheel.cpython-39.pyc,,
+pip/_internal/models/candidate.py,sha256=gACeCSHTIaWuB6RAeLmGJnbFFbKfp_47UERDoC_ldOU,1195
+pip/_internal/models/direct_url.py,sha256=MnBLPci1hE9Ndh6d3m0LAqB7hX3ci80CCJTE5eerFaQ,6900
+pip/_internal/models/format_control.py,sha256=RdnnmXxVJppCZWzWEmFTr-zD_m3G0izPLqJi6Iop75M,2823
+pip/_internal/models/index.py,sha256=carvxxaT7mJyoEkptaECHUZiNaA6R5NrsGF55zawNn8,1161
+pip/_internal/models/link.py,sha256=FMlxvqKmLoj7xTQSgKqfO2ehE1WcgD4C5DmEBuC_Qos,7470
+pip/_internal/models/scheme.py,sha256=EhPkT_6G0Md84JTLSVopYsp5H_K6BREYmFvU8H6wMK8,778
+pip/_internal/models/search_scope.py,sha256=Lum0mY4_pdR9DDBy6HV5xHGIMPp_kU8vMsqYKFHZip4,4751
+pip/_internal/models/selection_prefs.py,sha256=pgNjTfgePPiX1R5S2S8Yc6odOfU9NzG7YP_m_gnS0kw,2044
+pip/_internal/models/target_python.py,sha256=R7tAXI15B_cgw7Fgnq5cI9F-44goUZncH9JMtE8pXRw,4034
+pip/_internal/models/wheel.py,sha256=FTfzVb4WIbfIehxhdlAVvCil_MQ0-W44oyN56cE6NHc,2772
+pip/_internal/network/__init__.py,sha256=jf6Tt5nV_7zkARBrKojIXItgejvoegVJVKUbhAa5Ioc,50
+pip/_internal/network/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/network/__pycache__/auth.cpython-39.pyc,,
+pip/_internal/network/__pycache__/cache.cpython-39.pyc,,
+pip/_internal/network/__pycache__/download.cpython-39.pyc,,
+pip/_internal/network/__pycache__/lazy_wheel.cpython-39.pyc,,
+pip/_internal/network/__pycache__/session.cpython-39.pyc,,
+pip/_internal/network/__pycache__/utils.cpython-39.pyc,,
+pip/_internal/network/__pycache__/xmlrpc.cpython-39.pyc,,
+pip/_internal/network/auth.py,sha256=dt3NvTRJ8182S3VpdYFEZMPT0JhOKHyFtR-O-JMlJII,11652
+pip/_internal/network/cache.py,sha256=6cCD7XNrqh1d1lOSY5U-0ZXOG1YwEgMYs-VhRZVyzMA,2329
+pip/_internal/network/download.py,sha256=VTGDO01_nX-5MCdatd4Icv0F88_M8N3WnW6BevA6a0o,5151
+pip/_internal/network/lazy_wheel.py,sha256=RXcQILT5v5UO6kxgv76CSncLTqRL29o-OXbaW2aK7t4,8138
+pip/_internal/network/session.py,sha256=Zs0uiyPxTpfpgSv-ZI9hK9TjasmTplBuBivOTcUiJME,15208
+pip/_internal/network/utils.py,sha256=ZPHg7u6DEcg2EvILIdPECnvPLp21OPHxNVmeXfMy-n0,4172
+pip/_internal/network/xmlrpc.py,sha256=PFCiX_nnwYxC8SFIf7J3trP40ECGjA6fl2-IVNhbkPM,1882
+pip/_internal/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/operations/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/operations/__pycache__/check.cpython-39.pyc,,
+pip/_internal/operations/__pycache__/freeze.cpython-39.pyc,,
+pip/_internal/operations/__pycache__/prepare.cpython-39.pyc,,
+pip/_internal/operations/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/operations/build/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/operations/build/__pycache__/metadata.cpython-39.pyc,,
+pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-39.pyc,,
+pip/_internal/operations/build/__pycache__/wheel.cpython-39.pyc,,
+pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-39.pyc,,
+pip/_internal/operations/build/metadata.py,sha256=2aILgWCQTF1aIhWuCH8TTSjv_kYmA3x1262fT2FQ6pQ,1254
+pip/_internal/operations/build/metadata_legacy.py,sha256=VgzBTk8naIO8-8N_ifEYF7ZAxWUDhphWVIaVlZ2FqYM,2011
+pip/_internal/operations/build/wheel.py,sha256=33vdkxTO-gNqrtWH1eNL_uZo4Irax85moDx2o9zae3M,1465
+pip/_internal/operations/build/wheel_legacy.py,sha256=N1aqNZyGURBX0Bj6wPmB0t4866oMbxoHUpC9pz6FyT0,3356
+pip/_internal/operations/check.py,sha256=JYDsVLvpFyJuJq0ttStgg8TRKbc0myYFAMnfnnQOREM,5215
+pip/_internal/operations/freeze.py,sha256=_vJSZwHBNzBV0GpRUSXhUJz3BrGFdcT2aTcWxH1L4P0,10373
+pip/_internal/operations/install/__init__.py,sha256=mX7hyD2GNBO2mFGokDQ30r_GXv7Y_PLdtxcUv144e-s,51
+pip/_internal/operations/install/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/operations/install/__pycache__/editable_legacy.cpython-39.pyc,,
+pip/_internal/operations/install/__pycache__/legacy.cpython-39.pyc,,
+pip/_internal/operations/install/__pycache__/wheel.cpython-39.pyc,,
+pip/_internal/operations/install/editable_legacy.py,sha256=rJ_xs2qtDUjpY2-n6eYlVyZiNoKbOtZXZrYrcnIELt4,1488
+pip/_internal/operations/install/legacy.py,sha256=zu3Gw54dgHtluyW5n8j5qKcAScidQXJvqB8fb0oLB-4,4281
+pip/_internal/operations/install/wheel.py,sha256=nJmOSOYY3keksXd_3GFuhAWeeoKvGOyoSGbjXABjZ40,31310
+pip/_internal/operations/prepare.py,sha256=Rt7Yh7w10_Q-vI3b7R1wkt2R6XPX8YVUdODk-TaGI9c,19903
+pip/_internal/pyproject.py,sha256=VJKsrXORGiGoDPVKCQhuu4tWlQSTOhoiRlVLRNu4rx4,7400
+pip/_internal/req/__init__.py,sha256=s-E5Vxxqqpcs7xfY5gY69oHogsWJ4sLbnUiDoWmkHOU,3133
+pip/_internal/req/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/req/__pycache__/constructors.cpython-39.pyc,,
+pip/_internal/req/__pycache__/req_file.cpython-39.pyc,,
+pip/_internal/req/__pycache__/req_install.cpython-39.pyc,,
+pip/_internal/req/__pycache__/req_set.cpython-39.pyc,,
+pip/_internal/req/__pycache__/req_tracker.cpython-39.pyc,,
+pip/_internal/req/__pycache__/req_uninstall.cpython-39.pyc,,
+pip/_internal/req/constructors.py,sha256=LrSHbRHu52-h6HM1qJKG68o1Jw5q8MvJGfr4As6j2uU,16387
+pip/_internal/req/req_file.py,sha256=p7n3Y0q275Eisqfxd0vtfnxYvlT6TCCY0tj75p-yiOY,19448
+pip/_internal/req/req_install.py,sha256=5IYle0AaLivlkZo6mhU9sj30CbzPqLe92csBnAfJq8U,33610
+pip/_internal/req/req_set.py,sha256=dxcfbieWYfYkTJNE07U8xaO40zLxl8BhWOcIHVFTmoo,7886
+pip/_internal/req/req_tracker.py,sha256=qWaiejNK6o6cqeyTOIGKIU1CoyrXCcqgMHYi3cqelOA,4690
+pip/_internal/req/req_uninstall.py,sha256=opMGDGb7ZaFippRbaarJaljtzl2CNZmBGEUSnTubE-A,23706
+pip/_internal/resolution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/resolution/__pycache__/base.cpython-39.pyc,,
+pip/_internal/resolution/base.py,sha256=xi72YmIS-lEjyK13PN_3qkGGthA4yGoK0C6qWynyHrE,682
+pip/_internal/resolution/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/legacy/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/resolution/legacy/__pycache__/resolver.cpython-39.pyc,,
+pip/_internal/resolution/legacy/resolver.py,sha256=d-qW6UUxbZqKyXmX2bqnW5C8UtnO0ZcsQuKw_QXualc,18755
+pip/_internal/resolution/resolvelib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/base.cpython-39.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-39.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-39.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-39.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-39.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-39.pyc,,
+pip/_internal/resolution/resolvelib/base.py,sha256=n8Rilea9jCzhlbtFiJKwCwIQSPW0ATjEKsCc0Vpm894,2342
+pip/_internal/resolution/resolvelib/candidates.py,sha256=RHo9r9g25FWzufKv93Ti9nS4hvAPUrhAjSDL7GCZFNQ,20339
+pip/_internal/resolution/resolvelib/factory.py,sha256=--ahYsr-r9zIhdyJJ1ZuETgaQrWiPIqwILWiMDn1IIU,17169
+pip/_internal/resolution/resolvelib/provider.py,sha256=BP8nh07Z1FlcT-Iaw4FblRM-DjUeUkiItKdKARYeM6M,6134
+pip/_internal/resolution/resolvelib/requirements.py,sha256=lGvoHRhkusRfaz4cFxYBoQNqxS6TeuO3K68qlui6g-0,4511
+pip/_internal/resolution/resolvelib/resolver.py,sha256=kI8g0NVlYIsDMRmDplWQdox6WO-0H7CI2wN-1ixnaew,10149
+pip/_internal/self_outdated_check.py,sha256=q6_nqUHPpt-DScwD97h7FCSqd4nI1s-xkpOI4I5Za3Y,6779
+pip/_internal/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/utils/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/appdirs.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/compat.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/compatibility_tags.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/datetime.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/deprecation.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/direct_url_helpers.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/distutils_args.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/encoding.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/entrypoints.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/filesystem.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/filetypes.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/glibc.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/hashes.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/inject_securetransport.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/logging.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/misc.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/models.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/packaging.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/parallel.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/pkg_resources.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/setuptools_build.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/subprocess.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/temp_dir.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/typing.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/unpacking.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/urls.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/virtualenv.cpython-39.pyc,,
+pip/_internal/utils/__pycache__/wheel.cpython-39.pyc,,
+pip/_internal/utils/appdirs.py,sha256=RZzUG-Bkh2b-miX0DSZ3v703_-bgK-v0PfWCCjwVE9g,1349
+pip/_internal/utils/compat.py,sha256=GoCSUMoUmTGeg5irQGLDZ7v12As87yHrMzBXEke-njg,8865
+pip/_internal/utils/compatibility_tags.py,sha256=EtBJj-pstj_U0STUZ8FjlG7YDTjuRZUy6GY1cM86yv8,5439
+pip/_internal/utils/datetime.py,sha256=KL-vIdGU9JIpGB5NYkmwXWkH-G_2mvvABlmRtoSZsao,295
+pip/_internal/utils/deprecation.py,sha256=pBnNogoA4UGTxa_JDnPXBRRYpKMbExAhXpBwAwklOBs,3318
+pip/_internal/utils/direct_url_helpers.py,sha256=bZCBNwPQVyZpYGjX_VcomvVvRHvKw-9JzEV-Ft09LQc,4359
+pip/_internal/utils/distutils_args.py,sha256=a56mblNxk9BGifbpEETG61mmBrqhjtjRkJ4HYn-oOEE,1350
+pip/_internal/utils/encoding.py,sha256=wHDJ25yCT_T4ySscCL3P978OpLrfDCpitg8D64IEXMY,1284
+pip/_internal/utils/entrypoints.py,sha256=vHcNpnksCv6mllihU6hfifdsKPEjwcaJ1aLIXEaynaU,1152
+pip/_internal/utils/filesystem.py,sha256=-fU3XteCAIJwf_9FvCZU7vhywvt3nuf_cqkCdwgy1Y8,6943
+pip/_internal/utils/filetypes.py,sha256=R2FwzoeX7b-rZALOXx5cuO8VPPMhUQ4ne7wm3n3IcWA,571
+pip/_internal/utils/glibc.py,sha256=LOeNGgawCKS-4ke9fii78fwXD73dtNav3uxz1Bf-Ab8,3297
+pip/_internal/utils/hashes.py,sha256=xHmrqNwC1eBN0oY0R_RXLJLXGvFdo5gwmbz_pas94k8,4358
+pip/_internal/utils/inject_securetransport.py,sha256=M17ZlFVY66ApgeASVjKKLKNz0LAfk-SyU0HZ4ZB6MmI,810
+pip/_internal/utils/logging.py,sha256=YIfuDUEkmdn9cIRQ_Ec8rgXs1m5nOwDECtZqM4CBH5U,13093
+pip/_internal/utils/misc.py,sha256=QQZWMJkKKADPSWQYmrwlasc8b03eCcghn0yDNprYgrI,28001
+pip/_internal/utils/models.py,sha256=HqiBVtTbW_b_Umvj2fjhDWOHo2RKhPwSz4iAYkQZ688,1201
+pip/_internal/utils/packaging.py,sha256=VtiwcAAL7LBi7tGL2je7LeW4bE11KMHGCsJ1NZY5XtM,3035
+pip/_internal/utils/parallel.py,sha256=7az3aaTMCkqpaLFbpYYOvk0rj7Hu5YH1NPXXomqjgf4,3404
+pip/_internal/utils/pkg_resources.py,sha256=ZX-k7V5q_aNWyDse92nN7orN1aCpRLsaxzpkBZ1XKzU,1254
+pip/_internal/utils/setuptools_build.py,sha256=E1KswI7wfNnCDE5R6G8c9ZbByENpu7NqocjY26PCQDw,5058
+pip/_internal/utils/subprocess.py,sha256=UkPe89gcjxBMx73uutoeJXgD3kwdlL6YO16BkjDdVSI,9924
+pip/_internal/utils/temp_dir.py,sha256=blmG0jEvEgdxbYUt_V15bgcTIJIrxZwAw8QZlCTJYDE,8378
+pip/_internal/utils/typing.py,sha256=xkYwOeHlf4zsHXBDC4310HtEqwhQcYXFPq2h35Tcrl0,1401
+pip/_internal/utils/unpacking.py,sha256=YFAckhqqvmehA8Kan5vd3b1kN_9TafqmOk4b-yz4fho,9488
+pip/_internal/utils/urls.py,sha256=q2rw1kMiiig_XZcoyJSsWMJQqYw-2wUmrMoST4mCW_I,1527
+pip/_internal/utils/virtualenv.py,sha256=fNGrRp-8QmNL5OzXajBd-z7PbwOsx1XY6G-AVMAhfso,3706
+pip/_internal/utils/wheel.py,sha256=wFzn3h8GqYvgsyWPZtUyn0Rb3MJzmtyP3owMOhKnmL0,7303
+pip/_internal/vcs/__init__.py,sha256=viJxJRqRE_mVScum85bgQIXAd6o0ozFt18VpC-qIJrM,617
+pip/_internal/vcs/__pycache__/__init__.cpython-39.pyc,,
+pip/_internal/vcs/__pycache__/bazaar.cpython-39.pyc,,
+pip/_internal/vcs/__pycache__/git.cpython-39.pyc,,
+pip/_internal/vcs/__pycache__/mercurial.cpython-39.pyc,,
+pip/_internal/vcs/__pycache__/subversion.cpython-39.pyc,,
+pip/_internal/vcs/__pycache__/versioncontrol.cpython-39.pyc,,
+pip/_internal/vcs/bazaar.py,sha256=5rRR02uDZTLaxQT-R5Obd8FZDOMlShqYds-pwVSJJs8,3887
+pip/_internal/vcs/git.py,sha256=kvB729wrKY0OWMSgOS1pUly4LosZp8utrd3kOQsWalA,13985
+pip/_internal/vcs/mercurial.py,sha256=FzCGmYzVZvB-vyM73fKcQk2B4jMNXGnXlQ2bJ7nmglM,5162
+pip/_internal/vcs/subversion.py,sha256=rldcn9ZDt5twjNPzFn_FKRn4qdfkjlxHMJEsR2MFfoA,12399
+pip/_internal/vcs/versioncontrol.py,sha256=WpxeTRC0NoGB2uXJdmfq4pPxY-p7sk1rV_WkxMxgzQA,25966
+pip/_internal/wheel_builder.py,sha256=6w1VPXrpUvCCPlV0cI1wNaCqNz4laF6B6whvaxl9cns,9522
+pip/_vendor/__init__.py,sha256=CsxnpYPbi_2agrDI79iQrCmQeZRcwwIF0C6cm_1RynU,4588
+pip/_vendor/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/__pycache__/appdirs.cpython-39.pyc,,
+pip/_vendor/__pycache__/contextlib2.cpython-39.pyc,,
+pip/_vendor/__pycache__/distro.cpython-39.pyc,,
+pip/_vendor/__pycache__/ipaddress.cpython-39.pyc,,
+pip/_vendor/__pycache__/pyparsing.cpython-39.pyc,,
+pip/_vendor/__pycache__/retrying.cpython-39.pyc,,
+pip/_vendor/__pycache__/six.cpython-39.pyc,,
+pip/_vendor/appdirs.py,sha256=M6IYRJtdZgmSPCXCSMBRB0VT3P8MdFbWCDbSLrB2Ebg,25907
+pip/_vendor/cachecontrol/__init__.py,sha256=pJtAaUxOsMPnytI1A3juAJkXYDr8krdSnsg4Yg3OBEg,302
+pip/_vendor/cachecontrol/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-39.pyc,,
+pip/_vendor/cachecontrol/__pycache__/adapter.cpython-39.pyc,,
+pip/_vendor/cachecontrol/__pycache__/cache.cpython-39.pyc,,
+pip/_vendor/cachecontrol/__pycache__/compat.cpython-39.pyc,,
+pip/_vendor/cachecontrol/__pycache__/controller.cpython-39.pyc,,
+pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-39.pyc,,
+pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-39.pyc,,
+pip/_vendor/cachecontrol/__pycache__/serialize.cpython-39.pyc,,
+pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-39.pyc,,
+pip/_vendor/cachecontrol/_cmd.py,sha256=URGE0KrA87QekCG3SGPatlSPT571dZTDjNa-ZXX3pDc,1295
+pip/_vendor/cachecontrol/adapter.py,sha256=sSwaSYd93IIfCFU4tOMgSo6b2LCt_gBSaQUj8ktJFOA,4882
+pip/_vendor/cachecontrol/cache.py,sha256=1fc4wJP8HYt1ycnJXeEw5pCpeBL2Cqxx6g9Fb0AYDWQ,805
+pip/_vendor/cachecontrol/caches/__init__.py,sha256=-gHNKYvaeD0kOk5M74eOrsSgIKUtC6i6GfbmugGweEo,86
+pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-39.pyc,,
+pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-39.pyc,,
+pip/_vendor/cachecontrol/caches/file_cache.py,sha256=nYVKsJtXh6gJXvdn1iWyrhxvkwpQrK-eKoMRzuiwkKk,4153
+pip/_vendor/cachecontrol/caches/redis_cache.py,sha256=HxelMpNCo-dYr2fiJDwM3hhhRmxUYtB5tXm1GpAAT4Y,856
+pip/_vendor/cachecontrol/compat.py,sha256=kHNvMRdt6s_Xwqq_9qJmr9ou3wYMOMUMxPPcwNxT8Mc,695
+pip/_vendor/cachecontrol/controller.py,sha256=CWEX3pedIM9s60suf4zZPtm_JvVgnvogMGK_OiBG5F8,14149
+pip/_vendor/cachecontrol/filewrapper.py,sha256=vACKO8Llzu_ZWyjV1Fxn1MA4TGU60N5N3GSrAFdAY2Q,2533
+pip/_vendor/cachecontrol/heuristics.py,sha256=BFGHJ3yQcxvZizfo90LLZ04T_Z5XSCXvFotrp7Us0sc,4070
+pip/_vendor/cachecontrol/serialize.py,sha256=vIa4jvq4x_KSOLdEIedoknX2aXYHQujLDFV4-F21Dno,7091
+pip/_vendor/cachecontrol/wrapper.py,sha256=5LX0uJwkNQUtYSEw3aGmGu9WY8wGipd81mJ8lG0d0M4,690
+pip/_vendor/certifi/__init__.py,sha256=u1E_DrSGj_nnEkK5VglvEqP8D80KpghLVWL0A_pq41A,62
+pip/_vendor/certifi/__main__.py,sha256=1k3Cr95vCxxGRGDljrW3wMdpZdL3Nhf0u1n-k2qdsCY,255
+pip/_vendor/certifi/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/certifi/__pycache__/__main__.cpython-39.pyc,,
+pip/_vendor/certifi/__pycache__/core.cpython-39.pyc,,
+pip/_vendor/certifi/cacert.pem,sha256=GhT24f0R7_9y4YY_hkXwkO7BthZhRGDCEMO348E9S14,282394
+pip/_vendor/certifi/core.py,sha256=jBrwKEWpG0IKcuozK0BQ2HHGp8adXAOyBPC7ddgR6vM,2315
+pip/_vendor/chardet/__init__.py,sha256=YsP5wQlsHJ2auF1RZJfypiSrCA7_bQiRm3ES_NI76-Y,1559
+pip/_vendor/chardet/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/big5freq.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/big5prober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/chardistribution.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/charsetgroupprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/charsetprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/codingstatemachine.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/compat.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/cp949prober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/enums.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/escprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/escsm.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/eucjpprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/euckrfreq.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/euckrprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/euctwfreq.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/euctwprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/gb2312freq.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/gb2312prober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/hebrewprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/jisfreq.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/jpcntx.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/langbulgarianmodel.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/langcyrillicmodel.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/langgreekmodel.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/langhebrewmodel.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/langhungarianmodel.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/langthaimodel.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/langturkishmodel.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/latin1prober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/mbcharsetprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/mbcsgroupprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/mbcssm.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/sbcharsetprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/sbcsgroupprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/sjisprober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/universaldetector.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/utf8prober.cpython-39.pyc,,
+pip/_vendor/chardet/__pycache__/version.cpython-39.pyc,,
+pip/_vendor/chardet/big5freq.py,sha256=D_zK5GyzoVsRes0HkLJziltFQX0bKCLOrFe9_xDvO_8,31254
+pip/_vendor/chardet/big5prober.py,sha256=kBxHbdetBpPe7xrlb-e990iot64g_eGSLd32lB7_h3M,1757
+pip/_vendor/chardet/chardistribution.py,sha256=3woWS62KrGooKyqz4zQSnjFbJpa6V7g02daAibTwcl8,9411
+pip/_vendor/chardet/charsetgroupprober.py,sha256=6bDu8YIiRuScX4ca9Igb0U69TA2PGXXDej6Cc4_9kO4,3787
+pip/_vendor/chardet/charsetprober.py,sha256=KSmwJErjypyj0bRZmC5F5eM7c8YQgLYIjZXintZNstg,5110
+pip/_vendor/chardet/cli/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pip/_vendor/chardet/cli/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/chardet/cli/__pycache__/chardetect.cpython-39.pyc,,
+pip/_vendor/chardet/cli/chardetect.py,sha256=DI8dlV3FBD0c0XA_y3sQ78z754DUv1J8n34RtDjOXNw,2774
+pip/_vendor/chardet/codingstatemachine.py,sha256=VYp_6cyyki5sHgXDSZnXW4q1oelHc3cu9AyQTX7uug8,3590
+pip/_vendor/chardet/compat.py,sha256=PKTzHkSbtbHDqS9PyujMbX74q1a8mMpeQTDVsQhZMRw,1134
+pip/_vendor/chardet/cp949prober.py,sha256=TZ434QX8zzBsnUvL_8wm4AQVTZ2ZkqEEQL_lNw9f9ow,1855
+pip/_vendor/chardet/enums.py,sha256=Aimwdb9as1dJKZaFNUH2OhWIVBVd6ZkJJ_WK5sNY8cU,1661
+pip/_vendor/chardet/escprober.py,sha256=kkyqVg1Yw3DIOAMJ2bdlyQgUFQhuHAW8dUGskToNWSc,3950
+pip/_vendor/chardet/escsm.py,sha256=RuXlgNvTIDarndvllNCk5WZBIpdCxQ0kcd9EAuxUh84,10510
+pip/_vendor/chardet/eucjpprober.py,sha256=iD8Jdp0ISRjgjiVN7f0e8xGeQJ5GM2oeZ1dA8nbSeUw,3749
+pip/_vendor/chardet/euckrfreq.py,sha256=-7GdmvgWez4-eO4SuXpa7tBiDi5vRXQ8WvdFAzVaSfo,13546
+pip/_vendor/chardet/euckrprober.py,sha256=MqFMTQXxW4HbzIpZ9lKDHB3GN8SP4yiHenTmf8g_PxY,1748
+pip/_vendor/chardet/euctwfreq.py,sha256=No1WyduFOgB5VITUA7PLyC5oJRNzRyMbBxaKI1l16MA,31621
+pip/_vendor/chardet/euctwprober.py,sha256=13p6EP4yRaxqnP4iHtxHOJ6R2zxHq1_m8hTRjzVZ95c,1747
+pip/_vendor/chardet/gb2312freq.py,sha256=JX8lsweKLmnCwmk8UHEQsLgkr_rP_kEbvivC4qPOrlc,20715
+pip/_vendor/chardet/gb2312prober.py,sha256=gGvIWi9WhDjE-xQXHvNIyrnLvEbMAYgyUSZ65HUfylw,1754
+pip/_vendor/chardet/hebrewprober.py,sha256=c3SZ-K7hvyzGY6JRAZxJgwJ_sUS9k0WYkvMY00YBYFo,13838
+pip/_vendor/chardet/jisfreq.py,sha256=vpmJv2Bu0J8gnMVRPHMFefTRvo_ha1mryLig8CBwgOg,25777
+pip/_vendor/chardet/jpcntx.py,sha256=PYlNqRUQT8LM3cT5FmHGP0iiscFlTWED92MALvBungo,19643
+pip/_vendor/chardet/langbulgarianmodel.py,sha256=1HqQS9Pbtnj1xQgxitJMvw8X6kKr5OockNCZWfEQrPE,12839
+pip/_vendor/chardet/langcyrillicmodel.py,sha256=LODajvsetH87yYDDQKA2CULXUH87tI223dhfjh9Zx9c,17948
+pip/_vendor/chardet/langgreekmodel.py,sha256=8YAW7bU8YwSJap0kIJSbPMw1BEqzGjWzqcqf0WgUKAA,12688
+pip/_vendor/chardet/langhebrewmodel.py,sha256=JSnqmE5E62tDLTPTvLpQsg5gOMO4PbdWRvV7Avkc0HA,11345
+pip/_vendor/chardet/langhungarianmodel.py,sha256=RhapYSG5l0ZaO-VV4Fan5sW0WRGQqhwBM61yx3yxyOA,12592
+pip/_vendor/chardet/langthaimodel.py,sha256=8l0173Gu_W6G8mxmQOTEF4ls2YdE7FxWf3QkSxEGXJQ,11290
+pip/_vendor/chardet/langturkishmodel.py,sha256=W22eRNJsqI6uWAfwXSKVWWnCerYqrI8dZQTm_M0lRFk,11102
+pip/_vendor/chardet/latin1prober.py,sha256=S2IoORhFk39FEFOlSFWtgVybRiP6h7BlLldHVclNkU8,5370
+pip/_vendor/chardet/mbcharsetprober.py,sha256=AR95eFH9vuqSfvLQZN-L5ijea25NOBCoXqw8s5O9xLQ,3413
+pip/_vendor/chardet/mbcsgroupprober.py,sha256=h6TRnnYq2OxG1WdD5JOyxcdVpn7dG0q-vB8nWr5mbh4,2012
+pip/_vendor/chardet/mbcssm.py,sha256=SY32wVIF3HzcjY3BaEspy9metbNSKxIIB0RKPn7tjpI,25481
+pip/_vendor/chardet/sbcharsetprober.py,sha256=LDSpCldDCFlYwUkGkwD2oFxLlPWIWXT09akH_2PiY74,5657
+pip/_vendor/chardet/sbcsgroupprober.py,sha256=1IprcCB_k1qfmnxGC6MBbxELlKqD3scW6S8YIwdeyXA,3546
+pip/_vendor/chardet/sjisprober.py,sha256=IIt-lZj0WJqK4rmUZzKZP4GJlE8KUEtFYVuY96ek5MQ,3774
+pip/_vendor/chardet/universaldetector.py,sha256=qL0174lSZE442eB21nnktT9_VcAye07laFWUeUrjttY,12485
+pip/_vendor/chardet/utf8prober.py,sha256=IdD8v3zWOsB8OLiyPi-y_fqwipRFxV9Nc1eKBLSuIEw,2766
+pip/_vendor/chardet/version.py,sha256=sp3B08mrDXB-pf3K9fqJ_zeDHOCLC8RrngQyDFap_7g,242
+pip/_vendor/colorama/__init__.py,sha256=DqjXH9URVP3IJwmMt7peYw50ns1RNAymIB9-XdPEFV8,239
+pip/_vendor/colorama/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/colorama/__pycache__/ansi.cpython-39.pyc,,
+pip/_vendor/colorama/__pycache__/ansitowin32.cpython-39.pyc,,
+pip/_vendor/colorama/__pycache__/initialise.cpython-39.pyc,,
+pip/_vendor/colorama/__pycache__/win32.cpython-39.pyc,,
+pip/_vendor/colorama/__pycache__/winterm.cpython-39.pyc,,
+pip/_vendor/colorama/ansi.py,sha256=Fi0un-QLqRm-v7o_nKiOqyC8PapBJK7DLV_q9LKtTO0,2524
+pip/_vendor/colorama/ansitowin32.py,sha256=u8QaqdqS_xYSfNkPM1eRJLHz6JMWPodaJaP0mxgHCDc,10462
+pip/_vendor/colorama/initialise.py,sha256=PprovDNxMTrvoNHFcL2NZjpH2XzDc8BLxLxiErfUl4k,1915
+pip/_vendor/colorama/win32.py,sha256=bJ8Il9jwaBN5BJ8bmN6FoYZ1QYuMKv2j8fGrXh7TJjw,5404
+pip/_vendor/colorama/winterm.py,sha256=2y_2b7Zsv34feAsP67mLOVc-Bgq51mdYGo571VprlrM,6438
+pip/_vendor/contextlib2.py,sha256=5HjGflUzwWAUfcILhSmC2GqvoYdZZzFzVfIDztHigUs,16915
+pip/_vendor/distlib/__init__.py,sha256=3veAk2rPznOB2gsK6tjbbh0TQMmGE5P82eE9wXq6NIk,581
+pip/_vendor/distlib/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/compat.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/database.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/index.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/locators.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/manifest.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/markers.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/metadata.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/resources.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/scripts.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/util.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/version.cpython-39.pyc,,
+pip/_vendor/distlib/__pycache__/wheel.cpython-39.pyc,,
+pip/_vendor/distlib/_backport/__init__.py,sha256=bqS_dTOH6uW9iGgd0uzfpPjo6vZ4xpPZ7kyfZJ2vNaw,274
+pip/_vendor/distlib/_backport/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/distlib/_backport/__pycache__/misc.cpython-39.pyc,,
+pip/_vendor/distlib/_backport/__pycache__/shutil.cpython-39.pyc,,
+pip/_vendor/distlib/_backport/__pycache__/sysconfig.cpython-39.pyc,,
+pip/_vendor/distlib/_backport/__pycache__/tarfile.cpython-39.pyc,,
+pip/_vendor/distlib/_backport/misc.py,sha256=KWecINdbFNOxSOP1fGF680CJnaC6S4fBRgEtaYTw0ig,971
+pip/_vendor/distlib/_backport/shutil.py,sha256=IX_G2NPqwecJibkIDje04bqu0xpHkfSQ2GaGdEVqM5Y,25707
+pip/_vendor/distlib/_backport/sysconfig.cfg,sha256=swZKxq9RY5e9r3PXCrlvQPMsvOdiWZBTHLEbqS8LJLU,2617
+pip/_vendor/distlib/_backport/sysconfig.py,sha256=BQHFlb6pubCl_dvT1NjtzIthylofjKisox239stDg0U,26854
+pip/_vendor/distlib/_backport/tarfile.py,sha256=Ihp7rXRcjbIKw8COm9wSePV9ARGXbSF9gGXAMn2Q-KU,92628
+pip/_vendor/distlib/compat.py,sha256=ADA56xiAxar3mU6qemlBhNbsrFPosXRhO44RzsbJPqk,41408
+pip/_vendor/distlib/database.py,sha256=Kl0YvPQKc4OcpVi7k5cFziydM1xOK8iqdxLGXgbZHV4,51059
+pip/_vendor/distlib/index.py,sha256=SXKzpQCERctxYDMp_OLee2f0J0e19ZhGdCIoMlUfUQM,21066
+pip/_vendor/distlib/locators.py,sha256=c9E4cDEacJ_uKbuE5BqAVocoWp6rsuBGTkiNDQq3zV4,52100
+pip/_vendor/distlib/manifest.py,sha256=nQEhYmgoreaBZzyFzwYsXxJARu3fo4EkunU163U16iE,14811
+pip/_vendor/distlib/markers.py,sha256=6Ac3cCfFBERexiESWIOXmg-apIP8l2esafNSX3KMy-8,4387
+pip/_vendor/distlib/metadata.py,sha256=z2KPy3h3tcDnb9Xs7nAqQ5Oz0bqjWAUFmKWcFKRoodg,38962
+pip/_vendor/distlib/resources.py,sha256=2FGv0ZHF14KXjLIlL0R991lyQQGcewOS4mJ-5n-JVnc,10766
+pip/_vendor/distlib/scripts.py,sha256=_MAj3sMuv56kuM8FsiIWXqbT0gmumPGaOR_atOzn4a4,17180
+pip/_vendor/distlib/t32.exe,sha256=NS3xBCVAld35JVFNmb-1QRyVtThukMrwZVeXn4LhaEQ,96768
+pip/_vendor/distlib/t64.exe,sha256=oAqHes78rUWVM0OtVqIhUvequl_PKhAhXYQWnUf7zR0,105984
+pip/_vendor/distlib/util.py,sha256=f2jZCPrcLCt6LcnC0gUy-Fur60tXD8reA7k4rDpHMDw,59845
+pip/_vendor/distlib/version.py,sha256=_n7F6juvQGAcn769E_SHa7fOcf5ERlEVymJ_EjPRwGw,23391
+pip/_vendor/distlib/w32.exe,sha256=lJtnZdeUxTZWya_EW5DZos_K5rswRECGspIl8ZJCIXs,90112
+pip/_vendor/distlib/w64.exe,sha256=0aRzoN2BO9NWW4ENy4_4vHkHR4qZTFZNVSAJJYlODTI,99840
+pip/_vendor/distlib/wheel.py,sha256=v6DnwTqhNHwrEVFr8_YeiTW6G4ftP_evsywNgrmdb2o,41144
+pip/_vendor/distro.py,sha256=xxMIh2a3KmippeWEHzynTdHT3_jZM0o-pos0dAWJROM,43628
+pip/_vendor/html5lib/__init__.py,sha256=BYzcKCqeEii52xDrqBFruhnmtmkiuHXFyFh-cglQ8mk,1160
+pip/_vendor/html5lib/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/html5lib/__pycache__/_ihatexml.cpython-39.pyc,,
+pip/_vendor/html5lib/__pycache__/_inputstream.cpython-39.pyc,,
+pip/_vendor/html5lib/__pycache__/_tokenizer.cpython-39.pyc,,
+pip/_vendor/html5lib/__pycache__/_utils.cpython-39.pyc,,
+pip/_vendor/html5lib/__pycache__/constants.cpython-39.pyc,,
+pip/_vendor/html5lib/__pycache__/html5parser.cpython-39.pyc,,
+pip/_vendor/html5lib/__pycache__/serializer.cpython-39.pyc,,
+pip/_vendor/html5lib/_ihatexml.py,sha256=ifOwF7pXqmyThIXc3boWc96s4MDezqRrRVp7FwDYUFs,16728
+pip/_vendor/html5lib/_inputstream.py,sha256=jErNASMlkgs7MpOM9Ve_VdLDJyFFweAjLuhVutZz33U,32353
+pip/_vendor/html5lib/_tokenizer.py,sha256=04mgA2sNTniutl2fxFv-ei5bns4iRaPxVXXHh_HrV_4,77040
+pip/_vendor/html5lib/_trie/__init__.py,sha256=nqfgO910329BEVJ5T4psVwQtjd2iJyEXQ2-X8c1YxwU,109
+pip/_vendor/html5lib/_trie/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/html5lib/_trie/__pycache__/_base.cpython-39.pyc,,
+pip/_vendor/html5lib/_trie/__pycache__/py.cpython-39.pyc,,
+pip/_vendor/html5lib/_trie/_base.py,sha256=CaybYyMro8uERQYjby2tTeSUatnWDfWroUN9N7ety5w,1013
+pip/_vendor/html5lib/_trie/py.py,sha256=wXmQLrZRf4MyWNyg0m3h81m9InhLR7GJ002mIIZh-8o,1775
+pip/_vendor/html5lib/_utils.py,sha256=Dx9AKntksRjFT1veBj7I362pf5OgIaT0zglwq43RnfU,4931
+pip/_vendor/html5lib/constants.py,sha256=Ll-yzLU_jcjyAI_h57zkqZ7aQWE5t5xA4y_jQgoUUhw,83464
+pip/_vendor/html5lib/filters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/html5lib/filters/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/alphabeticalattributes.cpython-39.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/base.cpython-39.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/inject_meta_charset.cpython-39.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/lint.cpython-39.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/optionaltags.cpython-39.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/sanitizer.cpython-39.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/whitespace.cpython-39.pyc,,
+pip/_vendor/html5lib/filters/alphabeticalattributes.py,sha256=lViZc2JMCclXi_5gduvmdzrRxtO5Xo9ONnbHBVCsykU,919
+pip/_vendor/html5lib/filters/base.py,sha256=z-IU9ZAYjpsVsqmVt7kuWC63jR11hDMr6CVrvuao8W0,286
+pip/_vendor/html5lib/filters/inject_meta_charset.py,sha256=egDXUEHXmAG9504xz0K6ALDgYkvUrC2q15YUVeNlVQg,2945
+pip/_vendor/html5lib/filters/lint.py,sha256=jk6q56xY0ojiYfvpdP-OZSm9eTqcAdRqhCoPItemPYA,3643
+pip/_vendor/html5lib/filters/optionaltags.py,sha256=8lWT75J0aBOHmPgfmqTHSfPpPMp01T84NKu0CRedxcE,10588
+pip/_vendor/html5lib/filters/sanitizer.py,sha256=m6oGmkBhkGAnn2nV6D4hE78SCZ6WEnK9rKdZB3uXBIc,26897
+pip/_vendor/html5lib/filters/whitespace.py,sha256=8eWqZxd4UC4zlFGW6iyY6f-2uuT8pOCSALc3IZt7_t4,1214
+pip/_vendor/html5lib/html5parser.py,sha256=anr-aXre_ImfrkQ35c_rftKXxC80vJCREKe06Tq15HA,117186
+pip/_vendor/html5lib/serializer.py,sha256=_PpvcZF07cwE7xr9uKkZqh5f4UEaI8ltCU2xPJzaTpk,15759
+pip/_vendor/html5lib/treeadapters/__init__.py,sha256=A0rY5gXIe4bJOiSGRO_j_tFhngRBO8QZPzPtPw5dFzo,679
+pip/_vendor/html5lib/treeadapters/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/html5lib/treeadapters/__pycache__/genshi.cpython-39.pyc,,
+pip/_vendor/html5lib/treeadapters/__pycache__/sax.cpython-39.pyc,,
+pip/_vendor/html5lib/treeadapters/genshi.py,sha256=CH27pAsDKmu4ZGkAUrwty7u0KauGLCZRLPMzaO3M5vo,1715
+pip/_vendor/html5lib/treeadapters/sax.py,sha256=BKS8woQTnKiqeffHsxChUqL4q2ZR_wb5fc9MJ3zQC8s,1776
+pip/_vendor/html5lib/treebuilders/__init__.py,sha256=AysSJyvPfikCMMsTVvaxwkgDieELD5dfR8FJIAuq7hY,3592
+pip/_vendor/html5lib/treebuilders/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/html5lib/treebuilders/__pycache__/base.cpython-39.pyc,,
+pip/_vendor/html5lib/treebuilders/__pycache__/dom.cpython-39.pyc,,
+pip/_vendor/html5lib/treebuilders/__pycache__/etree.cpython-39.pyc,,
+pip/_vendor/html5lib/treebuilders/__pycache__/etree_lxml.cpython-39.pyc,,
+pip/_vendor/html5lib/treebuilders/base.py,sha256=z-o51vt9r_l2IDG5IioTOKGzZne4Fy3_Fc-7ztrOh4I,14565
+pip/_vendor/html5lib/treebuilders/dom.py,sha256=22whb0C71zXIsai5mamg6qzBEiigcBIvaDy4Asw3at0,8925
+pip/_vendor/html5lib/treebuilders/etree.py,sha256=w5ZFpKk6bAxnrwD2_BrF5EVC7vzz0L3LMi9Sxrbc_8w,12836
+pip/_vendor/html5lib/treebuilders/etree_lxml.py,sha256=9gqDjs-IxsPhBYa5cpvv2FZ1KZlG83Giusy2lFmvIkE,14766
+pip/_vendor/html5lib/treewalkers/__init__.py,sha256=OBPtc1TU5mGyy18QDMxKEyYEz0wxFUUNj5v0-XgmYhY,5719
+pip/_vendor/html5lib/treewalkers/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/html5lib/treewalkers/__pycache__/base.cpython-39.pyc,,
+pip/_vendor/html5lib/treewalkers/__pycache__/dom.cpython-39.pyc,,
+pip/_vendor/html5lib/treewalkers/__pycache__/etree.cpython-39.pyc,,
+pip/_vendor/html5lib/treewalkers/__pycache__/etree_lxml.cpython-39.pyc,,
+pip/_vendor/html5lib/treewalkers/__pycache__/genshi.cpython-39.pyc,,
+pip/_vendor/html5lib/treewalkers/base.py,sha256=ouiOsuSzvI0KgzdWP8PlxIaSNs9falhbiinAEc_UIJY,7476
+pip/_vendor/html5lib/treewalkers/dom.py,sha256=EHyFR8D8lYNnyDU9lx_IKigVJRyecUGua0mOi7HBukc,1413
+pip/_vendor/html5lib/treewalkers/etree.py,sha256=xo1L5m9VtkfpFJK0pFmkLVajhqYYVisVZn3k9kYpPkI,4551
+pip/_vendor/html5lib/treewalkers/etree_lxml.py,sha256=_b0LAVWLcVu9WaU_-w3D8f0IRSpCbjf667V-3NRdhTw,6357
+pip/_vendor/html5lib/treewalkers/genshi.py,sha256=4D2PECZ5n3ZN3qu3jMl9yY7B81jnQApBQSVlfaIuYbA,2309
+pip/_vendor/idna/__init__.py,sha256=9Nt7xpyet3DmOrPUGooDdAwmHZZu1qUAy2EaJ93kGiQ,58
+pip/_vendor/idna/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/idna/__pycache__/codec.cpython-39.pyc,,
+pip/_vendor/idna/__pycache__/compat.cpython-39.pyc,,
+pip/_vendor/idna/__pycache__/core.cpython-39.pyc,,
+pip/_vendor/idna/__pycache__/idnadata.cpython-39.pyc,,
+pip/_vendor/idna/__pycache__/intranges.cpython-39.pyc,,
+pip/_vendor/idna/__pycache__/package_data.cpython-39.pyc,,
+pip/_vendor/idna/__pycache__/uts46data.cpython-39.pyc,,
+pip/_vendor/idna/codec.py,sha256=lvYb7yu7PhAqFaAIAdWcwgaWI2UmgseUua-1c0AsG0A,3299
+pip/_vendor/idna/compat.py,sha256=R-h29D-6mrnJzbXxymrWUW7iZUvy-26TQwZ0ij57i4U,232
+pip/_vendor/idna/core.py,sha256=jCoaLb3bA2tS_DDx9PpGuNTEZZN2jAzB369aP-IHYRE,11951
+pip/_vendor/idna/idnadata.py,sha256=gmzFwZWjdms3kKZ_M_vwz7-LP_SCgYfSeE03B21Qpsk,42350
+pip/_vendor/idna/intranges.py,sha256=TY1lpxZIQWEP6tNqjZkFA5hgoMWOj1OBmnUG8ihT87E,1749
+pip/_vendor/idna/package_data.py,sha256=bxBjpLnE06_1jSYKEy5svOMu1zM3OMztXVUb1tPlcp0,22
+pip/_vendor/idna/uts46data.py,sha256=lMdw2zdjkH1JUWXPPEfFUSYT3Fyj60bBmfLvvy5m7ko,202084
+pip/_vendor/ipaddress.py,sha256=-0RmurI31XgAaN20WCi0zrcuoat90nNA70_6yGlx2PU,79875
+pip/_vendor/msgpack/__init__.py,sha256=2gJwcsTIaAtCM0GMi2rU-_Y6kILeeQuqRkrQ22jSANc,1118
+pip/_vendor/msgpack/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/msgpack/__pycache__/_version.cpython-39.pyc,,
+pip/_vendor/msgpack/__pycache__/exceptions.cpython-39.pyc,,
+pip/_vendor/msgpack/__pycache__/ext.cpython-39.pyc,,
+pip/_vendor/msgpack/__pycache__/fallback.cpython-39.pyc,,
+pip/_vendor/msgpack/_version.py,sha256=hu7lzmZ_ClOaOOmRsWb4xomhzQ4UIsLsvv8KY6UysHE,20
+pip/_vendor/msgpack/exceptions.py,sha256=dCTWei8dpkrMsQDcjQk74ATl9HsIBH0ybt8zOPNqMYc,1081
+pip/_vendor/msgpack/ext.py,sha256=nV19BzE9Be8SJHrxxYJHFbvEHJaXcP3avRkHVp5wovM,6034
+pip/_vendor/msgpack/fallback.py,sha256=Z8V3iYUUPqKVy4WWTk64Vq3G0PylQIOmlWvgnMhmkdU,37133
+pip/_vendor/packaging/__about__.py,sha256=PNMsaZn4UcCHyubgROH1bl6CluduPjI5kFrSp_Zgklo,736
+pip/_vendor/packaging/__init__.py,sha256=6enbp5XgRfjBjsI9-bn00HjHf5TH21PDMOKkJW8xw-w,562
+pip/_vendor/packaging/__pycache__/__about__.cpython-39.pyc,,
+pip/_vendor/packaging/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/packaging/__pycache__/_compat.cpython-39.pyc,,
+pip/_vendor/packaging/__pycache__/_structures.cpython-39.pyc,,
+pip/_vendor/packaging/__pycache__/_typing.cpython-39.pyc,,
+pip/_vendor/packaging/__pycache__/markers.cpython-39.pyc,,
+pip/_vendor/packaging/__pycache__/requirements.cpython-39.pyc,,
+pip/_vendor/packaging/__pycache__/specifiers.cpython-39.pyc,,
+pip/_vendor/packaging/__pycache__/tags.cpython-39.pyc,,
+pip/_vendor/packaging/__pycache__/utils.cpython-39.pyc,,
+pip/_vendor/packaging/__pycache__/version.cpython-39.pyc,,
+pip/_vendor/packaging/_compat.py,sha256=MXdsGpSE_W-ZrHoC87andI4LV2FAwU7HLL-eHe_CjhU,1128
+pip/_vendor/packaging/_structures.py,sha256=ozkCX8Q8f2qE1Eic3YiQ4buDVfgz2iYevY9e7R2y3iY,2022
+pip/_vendor/packaging/_typing.py,sha256=VgA0AAvsc97KB5nF89zoudOyCMEsV7FlaXzZbYqEkzA,1824
+pip/_vendor/packaging/markers.py,sha256=V_RdoQqOUbSfy7y9o2vRk7BkzAh3yneC82cuWpKrqOg,9491
+pip/_vendor/packaging/requirements.py,sha256=F93hkn7i8NKRZP-FtdTIlhz1PUsRjhe6eRbsBXX0Uh4,4903
+pip/_vendor/packaging/specifiers.py,sha256=uYp9l13F0LcknS6d4N60ytiBgFmIhKideOq9AnsxTco,31944
+pip/_vendor/packaging/tags.py,sha256=NKMS37Zo_nWrZxgsD6zbXsXgc9edn9m160cBiLmHJdE,24067
+pip/_vendor/packaging/utils.py,sha256=RShlvnjO2CtYSD8uri32frMMFMTmB-3ihsq1-ghzLEw,1811
+pip/_vendor/packaging/version.py,sha256=Cnbm-OO9D_qd8ZTFxzFcjSavexSYFZmyeaoPvMsjgPc,15470
+pip/_vendor/pep517/__init__.py,sha256=r5uA106NGJa3slspaD2m32aFpFUiZX-mZ9vIlzAEOp4,84
+pip/_vendor/pep517/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/pep517/__pycache__/_in_process.cpython-39.pyc,,
+pip/_vendor/pep517/__pycache__/build.cpython-39.pyc,,
+pip/_vendor/pep517/__pycache__/check.cpython-39.pyc,,
+pip/_vendor/pep517/__pycache__/colorlog.cpython-39.pyc,,
+pip/_vendor/pep517/__pycache__/compat.cpython-39.pyc,,
+pip/_vendor/pep517/__pycache__/dirtools.cpython-39.pyc,,
+pip/_vendor/pep517/__pycache__/envbuild.cpython-39.pyc,,
+pip/_vendor/pep517/__pycache__/meta.cpython-39.pyc,,
+pip/_vendor/pep517/__pycache__/wrappers.cpython-39.pyc,,
+pip/_vendor/pep517/_in_process.py,sha256=XrKOTURJdia5R7i3i_OQmS89LASFXE3HQXfX63qZBIE,8438
+pip/_vendor/pep517/build.py,sha256=DN4ouyj_bd00knOKqv0KHRtN0-JezJoNNZQmcDi4juk,3335
+pip/_vendor/pep517/check.py,sha256=YoaNE3poJGpz96biVCYwtcDshwEGE2HRU5KKya9yfpY,5961
+pip/_vendor/pep517/colorlog.py,sha256=Tk9AuYm_cLF3BKTBoSTJt9bRryn0aFojIQOwbfVUTxQ,4098
+pip/_vendor/pep517/compat.py,sha256=M-5s4VNp8rjyT76ZZ_ibnPD44DYVzSQlyCEHayjtDPw,780
+pip/_vendor/pep517/dirtools.py,sha256=2mkAkAL0mRz_elYFjRKuekTJVipH1zTn4tbf1EDev84,1129
+pip/_vendor/pep517/envbuild.py,sha256=szKUFlO50X1ahQfXwz4hD9V2VE_bz9MLVPIeidsFo4w,6041
+pip/_vendor/pep517/meta.py,sha256=8mnM5lDnT4zXQpBTliJbRGfesH7iioHwozbDxALPS9Y,2463
+pip/_vendor/pep517/wrappers.py,sha256=yFU4Lp7TIYbmuVOTY-pXnlyGZ3F_grIi-JlLkpGN8Gk,10783
+pip/_vendor/pkg_resources/__init__.py,sha256=XpGBfvS9fafA6bm5rx7vnxdxs7yqyoc_NnpzKApkJ64,108277
+pip/_vendor/pkg_resources/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/pkg_resources/__pycache__/py31compat.cpython-39.pyc,,
+pip/_vendor/pkg_resources/py31compat.py,sha256=CRk8fkiPRDLsbi5pZcKsHI__Pbmh_94L8mr9Qy9Ab2U,562
+pip/_vendor/progress/__init__.py,sha256=fcbQQXo5np2CoQyhSH5XprkicwLZNLePR3uIahznSO0,4857
+pip/_vendor/progress/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/progress/__pycache__/bar.cpython-39.pyc,,
+pip/_vendor/progress/__pycache__/counter.cpython-39.pyc,,
+pip/_vendor/progress/__pycache__/spinner.cpython-39.pyc,,
+pip/_vendor/progress/bar.py,sha256=QuDuVNcmXgpxtNtxO0Fq72xKigxABaVmxYGBw4J3Z_E,2854
+pip/_vendor/progress/counter.py,sha256=MznyBrvPWrOlGe4MZAlGUb9q3aODe6_aNYeAE_VNoYA,1372
+pip/_vendor/progress/spinner.py,sha256=k8JbDW94T0-WXuXfxZIFhdoNPYp3jfnpXqBnfRv5fGs,1380
+pip/_vendor/pyparsing.py,sha256=J1b4z3S_KwyJW7hKGnoN-hXW9pgMIzIP6QThyY5yJq4,273394
+pip/_vendor/requests/__init__.py,sha256=orzv4-1uejMDc2v3LnTVneINGXiwqXSfrASoFBsYblE,4465
+pip/_vendor/requests/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/__version__.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/_internal_utils.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/adapters.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/api.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/auth.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/certs.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/compat.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/cookies.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/exceptions.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/help.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/hooks.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/models.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/packages.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/sessions.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/status_codes.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/structures.cpython-39.pyc,,
+pip/_vendor/requests/__pycache__/utils.cpython-39.pyc,,
+pip/_vendor/requests/__version__.py,sha256=Xwky1FMlMkJJGidBM50JC7FKcosWzkjIW-WhQGrBdFM,441
+pip/_vendor/requests/_internal_utils.py,sha256=Zx3PnEUccyfsB-ie11nZVAW8qClJy0gx1qNME7rgT18,1096
+pip/_vendor/requests/adapters.py,sha256=e-bmKEApNVqFdylxuMJJfiaHdlmS_zhWhIMEzlHvGuc,21548
+pip/_vendor/requests/api.py,sha256=PlHM-HT3PQ5lyufoeGmV-nJxRi7UnUyGVh7OV7B9XV4,6496
+pip/_vendor/requests/auth.py,sha256=OMoJIVKyRLy9THr91y8rxysZuclwPB-K1Xg1zBomUhQ,10207
+pip/_vendor/requests/certs.py,sha256=nXRVq9DtGmv_1AYbwjTu9UrgAcdJv05ZvkNeaoLOZxY,465
+pip/_vendor/requests/compat.py,sha256=LQWuCR4qXk6w7-qQopXyz0WNHUdAD40k0mKnaAEf1-g,2045
+pip/_vendor/requests/cookies.py,sha256=Y-bKX6TvW3FnYlE6Au0SXtVVWcaNdFvuAwQxw-G0iTI,18430
+pip/_vendor/requests/exceptions.py,sha256=d9fJJw8YFBB9VzG9qhvxLuOx6be3c_Dwbck-dVUEAcs,3173
+pip/_vendor/requests/help.py,sha256=SJPVcoXeo7KfK4AxJN5eFVQCjr0im87tU2n7ubLsksU,3578
+pip/_vendor/requests/hooks.py,sha256=QReGyy0bRcr5rkwCuObNakbYsc7EkiKeBwG4qHekr2Q,757
+pip/_vendor/requests/models.py,sha256=_tKIbrscbGvaTdX1UHCwRaiYmPF9VBIuBeydr4Qx1Tg,34287
+pip/_vendor/requests/packages.py,sha256=njJmVifY4aSctuW3PP5EFRCxjEwMRDO6J_feG2dKWsI,695
+pip/_vendor/requests/sessions.py,sha256=OBtwQs1vjkB1xamFdi_p5y8BVeX16BJoQcwSwx_Y3fI,29316
+pip/_vendor/requests/status_codes.py,sha256=gT79Pbs_cQjBgp-fvrUgg1dn2DQO32bDj4TInjnMPSc,4188
+pip/_vendor/requests/structures.py,sha256=msAtr9mq1JxHd-JRyiILfdFlpbJwvvFuP3rfUQT_QxE,3005
+pip/_vendor/requests/utils.py,sha256=VBs99cvV8Z29WGXeWZqHzZ80_nu1AwwjYzJfe0wQIvs,30176
+pip/_vendor/resolvelib/__init__.py,sha256=sqMOy4CbVJQiaG9bCPj0oAntGAVy-RWdPfVaC9XDIEQ,537
+pip/_vendor/resolvelib/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/resolvelib/__pycache__/providers.cpython-39.pyc,,
+pip/_vendor/resolvelib/__pycache__/reporters.cpython-39.pyc,,
+pip/_vendor/resolvelib/__pycache__/resolvers.cpython-39.pyc,,
+pip/_vendor/resolvelib/__pycache__/structs.cpython-39.pyc,,
+pip/_vendor/resolvelib/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/resolvelib/compat/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/resolvelib/compat/__pycache__/collections_abc.cpython-39.pyc,,
+pip/_vendor/resolvelib/compat/collections_abc.py,sha256=mtTkpr3Gf3OGvU1PD8YuvrJRhVbioxV82T-niFPoX3o,127
+pip/_vendor/resolvelib/providers.py,sha256=TZDCmL-Ic-R5JRIZY8G4FLG5xB2343B0DfuK7aw2Yqw,4547
+pip/_vendor/resolvelib/reporters.py,sha256=ZPSJnVfK8WvXTbX8jE0Nren0-_Hg9ym4epCUPtU8Y0U,1405
+pip/_vendor/resolvelib/resolvers.py,sha256=lQTGcc-2fgHbmdiLzeNDUxVmGc5ZFjkAL6JrVqnqJIw,15018
+pip/_vendor/resolvelib/structs.py,sha256=yrdhd-n7DercimPGclXe20rgqhlxw8PnxC0wmcXO19Y,2016
+pip/_vendor/retrying.py,sha256=k3fflf5_Mm0XcIJYhB7Tj34bqCCPhUDkYbx1NvW2FPE,9972
+pip/_vendor/six.py,sha256=U4Z_yv534W5CNyjY9i8V1OXY2SjAny8y2L5vDLhhThM,34159
+pip/_vendor/toml/__init__.py,sha256=rJ1pu933HgUtyeeNiusoPd5jJOPNhaKHhSSld3o8AQo,747
+pip/_vendor/toml/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/toml/__pycache__/common.cpython-39.pyc,,
+pip/_vendor/toml/__pycache__/decoder.cpython-39.pyc,,
+pip/_vendor/toml/__pycache__/encoder.cpython-39.pyc,,
+pip/_vendor/toml/__pycache__/ordered.cpython-39.pyc,,
+pip/_vendor/toml/__pycache__/tz.cpython-39.pyc,,
+pip/_vendor/toml/common.py,sha256=ViBccAduP6eZNJAb1POhRhjOAi56TDsNgWJ1TjgXAug,242
+pip/_vendor/toml/decoder.py,sha256=atpXmyFCzNGiqhkcYLySBuJQkPeSHDzBz47sEaX1amw,38696
+pip/_vendor/toml/encoder.py,sha256=fPqLyFdPAam17X9SELz2TMp9affkfHCmgWZxRKcmzhY,9955
+pip/_vendor/toml/ordered.py,sha256=UWt5Eka90IWVBYdvLgY5PXnkBcVYpHjnw9T67rM85T8,378
+pip/_vendor/toml/tz.py,sha256=DrAgI3wZxZiGcLuV_l8ueA_nPrYoxQ3hZA9tJSjWRsQ,618
+pip/_vendor/urllib3/__init__.py,sha256=rdFZCO1L7e8861ZTvo8AiSKwxCe9SnWQUQwJ599YV9c,2683
+pip/_vendor/urllib3/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/urllib3/__pycache__/_collections.cpython-39.pyc,,
+pip/_vendor/urllib3/__pycache__/connection.cpython-39.pyc,,
+pip/_vendor/urllib3/__pycache__/connectionpool.cpython-39.pyc,,
+pip/_vendor/urllib3/__pycache__/exceptions.cpython-39.pyc,,
+pip/_vendor/urllib3/__pycache__/fields.cpython-39.pyc,,
+pip/_vendor/urllib3/__pycache__/filepost.cpython-39.pyc,,
+pip/_vendor/urllib3/__pycache__/poolmanager.cpython-39.pyc,,
+pip/_vendor/urllib3/__pycache__/request.cpython-39.pyc,,
+pip/_vendor/urllib3/__pycache__/response.cpython-39.pyc,,
+pip/_vendor/urllib3/_collections.py,sha256=GouVsNzwg6jADZTmimMI6oqmwKSswnMo9dh5tGNVWO4,10792
+pip/_vendor/urllib3/connection.py,sha256=Fln8a_bkegdNMkFoSOwyI0PJvL1OqzVUO6ifihKOTpc,14461
+pip/_vendor/urllib3/connectionpool.py,sha256=egdaX-Db_LVXifDxv3JY0dHIpQqDv0wC0_9Eeh8FkPM,35725
+pip/_vendor/urllib3/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-39.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-39.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-39.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-39.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-39.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-39.pyc,,
+pip/_vendor/urllib3/contrib/_appengine_environ.py,sha256=bDbyOEhW2CKLJcQqAKAyrEHN-aklsyHFKq6vF8ZFsmk,957
+pip/_vendor/urllib3/contrib/_securetransport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-39.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-39.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/bindings.py,sha256=mullWYFaghBdRWla6HYU-TBgFRTPLBEfxj3jplbeJmQ,16886
+pip/_vendor/urllib3/contrib/_securetransport/low_level.py,sha256=V7GnujxnWZh2N2sMsV5N4d9Imymokkm3zBwgt77_bSE,11956
+pip/_vendor/urllib3/contrib/appengine.py,sha256=gfdK4T7CRin7v9HRhHDbDh-Hbk66hHDWeoz7nV3PJo8,11034
+pip/_vendor/urllib3/contrib/ntlmpool.py,sha256=a402AwGN_Ll3N-4ur_AS6UrU-ycUtlnYqoBF76lORg8,4160
+pip/_vendor/urllib3/contrib/pyopenssl.py,sha256=9gm5kpC0ScbDCWobeCrh5LDqS8HgU8FNhmk5v8qQ5Bs,16582
+pip/_vendor/urllib3/contrib/securetransport.py,sha256=vBDFjSnH2gWa-ztMKVaiwW46K1mlDZKqvo_VAonfdcY,32401
+pip/_vendor/urllib3/contrib/socks.py,sha256=nzDMgDIFJWVubKHqvIn2-SKCO91hhJInP92WgHChGzA,7036
+pip/_vendor/urllib3/exceptions.py,sha256=D2Jvab7M7m_n0rnmBmq481paoVT32VvVeB6VeQM0y-w,7172
+pip/_vendor/urllib3/fields.py,sha256=kroD76QK-GdHHW7f_AUN4XxDC3OQPI2FFrS9eSL4BCs,8553
+pip/_vendor/urllib3/filepost.py,sha256=vj0qbrpT1AFzvvW4SuC8M5kJiw7wftHcSr-7b8UpPpw,2440
+pip/_vendor/urllib3/packages/__init__.py,sha256=h4BLhD4tLaBx1adaDtKXfupsgqY0wWLXb_f1_yVlV6A,108
+pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/urllib3/packages/__pycache__/six.cpython-39.pyc,,
+pip/_vendor/urllib3/packages/backports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-39.pyc,,
+pip/_vendor/urllib3/packages/backports/makefile.py,sha256=005wrvH-_pWSnTFqQ2sdzzh4zVCtQUUQ4mR2Yyxwc0A,1418
+pip/_vendor/urllib3/packages/six.py,sha256=adx4z-eM_D0Vvu0IIqVzFACQ_ux9l64y7DkSEfbxCDs,32536
+pip/_vendor/urllib3/packages/ssl_match_hostname/__init__.py,sha256=ywgKMtfHi1-DrXlzPfVAhzsLzzqcK7GT6eLgdode1Fg,688
+pip/_vendor/urllib3/packages/ssl_match_hostname/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/urllib3/packages/ssl_match_hostname/__pycache__/_implementation.cpython-39.pyc,,
+pip/_vendor/urllib3/packages/ssl_match_hostname/_implementation.py,sha256=rvQDQviqQLtPJB6MfEgABnBFj3nXft7ZJ3Dx-BC0AQY,5696
+pip/_vendor/urllib3/poolmanager.py,sha256=iWEAIGrVNGoOmQyfiFwCqG-IyYy6GIQ-jJ9QCsX9li4,17861
+pip/_vendor/urllib3/request.py,sha256=hhoHvEEatyd9Tn5EbGjQ0emn-ENMCyY591yNWTneINA,6018
+pip/_vendor/urllib3/response.py,sha256=eo1Sfkn2x44FtjgP3qwwDsG9ak84spQAxEGy7Ovd4Pc,28221
+pip/_vendor/urllib3/util/__init__.py,sha256=bWNaav_OT-1L7-sxm59cGb59rDORlbhb_4noduM5m0U,1038
+pip/_vendor/urllib3/util/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/urllib3/util/__pycache__/connection.cpython-39.pyc,,
+pip/_vendor/urllib3/util/__pycache__/queue.cpython-39.pyc,,
+pip/_vendor/urllib3/util/__pycache__/request.cpython-39.pyc,,
+pip/_vendor/urllib3/util/__pycache__/response.cpython-39.pyc,,
+pip/_vendor/urllib3/util/__pycache__/retry.cpython-39.pyc,,
+pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-39.pyc,,
+pip/_vendor/urllib3/util/__pycache__/timeout.cpython-39.pyc,,
+pip/_vendor/urllib3/util/__pycache__/url.cpython-39.pyc,,
+pip/_vendor/urllib3/util/__pycache__/wait.cpython-39.pyc,,
+pip/_vendor/urllib3/util/connection.py,sha256=NsxUAKQ98GKywta--zg57CdVpeTCI6N-GElCq78Dl8U,4637
+pip/_vendor/urllib3/util/queue.py,sha256=myTX3JDHntglKQNBf3b6dasHH-uF-W59vzGSQiFdAfI,497
+pip/_vendor/urllib3/util/request.py,sha256=C-6-AWffxZG03AdRGoY59uqsn4CVItKU6gjxz7Hc3Mc,3815
+pip/_vendor/urllib3/util/response.py,sha256=_WbTQr8xRQuJuY2rTIZxVdJD6mnEOtQupjaK_bF_Vj8,2573
+pip/_vendor/urllib3/util/retry.py,sha256=3wbv7SdzYNOxPcBiFkPCubTbK1_6vWSepznOXirhUfA,15543
+pip/_vendor/urllib3/util/ssl_.py,sha256=N7gqt2iqzKBsWGmc61YeKNSPri6Ns2iZ_MD5hV2y8tU,14523
+pip/_vendor/urllib3/util/timeout.py,sha256=3qawUo-TZq4q7tyeRToMIOdNGEOBjOOQVq7nHnLryP4,9947
+pip/_vendor/urllib3/util/url.py,sha256=S4YyAwWKJPjFFECC7l9Vp9EKqRH1XAb-uQFANn1Tak0,13981
+pip/_vendor/urllib3/util/wait.py,sha256=k46KzqIYu3Vnzla5YW3EvtInNlU_QycFqQAghIOxoAg,5406
+pip/_vendor/vendor.txt,sha256=bWUiaRjMJhuUsqFZHEJkBH_6lJ_Avl9cOyszcI74IHs,437
+pip/_vendor/webencodings/__init__.py,sha256=qOBJIuPy_4ByYH6W_bNgJF-qYQ2DoU-dKsDu5yRWCXg,10579
+pip/_vendor/webencodings/__pycache__/__init__.cpython-39.pyc,,
+pip/_vendor/webencodings/__pycache__/labels.cpython-39.pyc,,
+pip/_vendor/webencodings/__pycache__/mklabels.cpython-39.pyc,,
+pip/_vendor/webencodings/__pycache__/tests.cpython-39.pyc,,
+pip/_vendor/webencodings/__pycache__/x_user_defined.cpython-39.pyc,,
+pip/_vendor/webencodings/labels.py,sha256=4AO_KxTddqGtrL9ns7kAPjb0CcN6xsCIxbK37HY9r3E,8979
+pip/_vendor/webencodings/mklabels.py,sha256=GYIeywnpaLnP0GSic8LFWgd0UVvO_l1Nc6YoF-87R_4,1305
+pip/_vendor/webencodings/tests.py,sha256=OtGLyjhNY1fvkW1GvLJ_FV9ZoqC9Anyjr7q3kxTbzNs,6563
+pip/_vendor/webencodings/x_user_defined.py,sha256=yOqWSdmpytGfUgh_Z6JYgDNhoc-BAHyyeeT15Fr42tM,4307
diff --git a/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/REQUESTED b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/REQUESTED
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/WHEEL
new file mode 100644
index 0000000..6d38aa0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.35.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/entry_points.txt
new file mode 100644
index 0000000..d48bd8a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/entry_points.txt
@@ -0,0 +1,5 @@
+[console_scripts]
+pip = pip._internal.cli.main:main
+pip3 = pip._internal.cli.main:main
+pip3.8 = pip._internal.cli.main:main
+
diff --git a/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/top_level.txt
new file mode 100644
index 0000000..a1b589e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip-20.2.3.dist-info/top_level.txt
@@ -0,0 +1 @@
+pip
diff --git a/myenv/lib/python3.9/site-packages/pip/__init__.py b/myenv/lib/python3.9/site-packages/pip/__init__.py
new file mode 100644
index 0000000..9fb68d4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/__init__.py
@@ -0,0 +1,18 @@
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Optional
+
+
+__version__ = "20.2.3"
+
+
+def main(args=None):
+    # type: (Optional[List[str]]) -> int
+    """This is an internal API only meant for use by pip's own console scripts.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)
diff --git a/myenv/lib/python3.9/site-packages/pip/__main__.py b/myenv/lib/python3.9/site-packages/pip/__main__.py
new file mode 100644
index 0000000..7c2505f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/__main__.py
@@ -0,0 +1,26 @@
+from __future__ import absolute_import
+
+import os
+import sys
+
+# Remove '' and current working directory from the first entry
+# of sys.path, if present to avoid using current directory
+# in pip commands check, freeze, install, list and show,
+# when invoked as python -m pip <command>
+if sys.path[0] in ('', os.getcwd()):
+    sys.path.pop(0)
+
+# If we are running from a wheel, add the wheel to sys.path
+# This allows the usage python pip-*.whl/pip install pip-*.whl
+if __package__ == '':
+    # __file__ is pip-*.whl/pip/__main__.py
+    # first dirname call strips of '/__main__.py', second strips off '/pip'
+    # Resulting path is the name of the wheel itself
+    # Add that to sys.path so we can import pip
+    path = os.path.dirname(os.path.dirname(__file__))
+    sys.path.insert(0, path)
+
+from pip._internal.cli.main import main as _main  # isort:skip # noqa
+
+if __name__ == '__main__':
+    sys.exit(_main())
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/__init__.py
new file mode 100644
index 0000000..264c2ca
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/__init__.py
@@ -0,0 +1,17 @@
+import pip._internal.utils.inject_securetransport  # noqa
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, List
+
+
+def main(args=None):
+    # type: (Optional[List[str]]) -> int
+    """This is preserved for old console scripts that may still be referencing
+    it.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/build_env.py b/myenv/lib/python3.9/site-packages/pip/_internal/build_env.py
new file mode 100644
index 0000000..28d1ad6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/build_env.py
@@ -0,0 +1,241 @@
+"""Build Environment used for isolation during sdist building
+"""
+
+import logging
+import os
+import sys
+import textwrap
+from collections import OrderedDict
+from distutils.sysconfig import get_python_lib
+from sysconfig import get_paths
+
+from pip._vendor.pkg_resources import Requirement, VersionConflict, WorkingSet
+
+from pip import __file__ as pip_location
+from pip._internal.cli.spinners import open_spinner
+from pip._internal.utils.subprocess import call_subprocess
+from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from types import TracebackType
+    from typing import Tuple, Set, Iterable, Optional, List, Type
+    from pip._internal.index.package_finder import PackageFinder
+
+logger = logging.getLogger(__name__)
+
+
+class _Prefix:
+
+    def __init__(self, path):
+        # type: (str) -> None
+        self.path = path
+        self.setup = False
+        self.bin_dir = get_paths(
+            'nt' if os.name == 'nt' else 'posix_prefix',
+            vars={'base': path, 'platbase': path}
+        )['scripts']
+        # Note: prefer distutils' sysconfig to get the
+        # library paths so PyPy is correctly supported.
+        purelib = get_python_lib(plat_specific=False, prefix=path)
+        platlib = get_python_lib(plat_specific=True, prefix=path)
+        if purelib == platlib:
+            self.lib_dirs = [purelib]
+        else:
+            self.lib_dirs = [purelib, platlib]
+
+
+class BuildEnvironment(object):
+    """Creates and manages an isolated environment to install build deps
+    """
+
+    def __init__(self):
+        # type: () -> None
+        temp_dir = TempDirectory(
+            kind=tempdir_kinds.BUILD_ENV, globally_managed=True
+        )
+
+        self._prefixes = OrderedDict((
+            (name, _Prefix(os.path.join(temp_dir.path, name)))
+            for name in ('normal', 'overlay')
+        ))
+
+        self._bin_dirs = []  # type: List[str]
+        self._lib_dirs = []  # type: List[str]
+        for prefix in reversed(list(self._prefixes.values())):
+            self._bin_dirs.append(prefix.bin_dir)
+            self._lib_dirs.extend(prefix.lib_dirs)
+
+        # Customize site to:
+        # - ensure .pth files are honored
+        # - prevent access to system site packages
+        system_sites = {
+            os.path.normcase(site) for site in (
+                get_python_lib(plat_specific=False),
+                get_python_lib(plat_specific=True),
+            )
+        }
+        self._site_dir = os.path.join(temp_dir.path, 'site')
+        if not os.path.exists(self._site_dir):
+            os.mkdir(self._site_dir)
+        with open(os.path.join(self._site_dir, 'sitecustomize.py'), 'w') as fp:
+            fp.write(textwrap.dedent(
+                '''
+                import os, site, sys
+
+                # First, drop system-sites related paths.
+                original_sys_path = sys.path[:]
+                known_paths = set()
+                for path in {system_sites!r}:
+                    site.addsitedir(path, known_paths=known_paths)
+                system_paths = set(
+                    os.path.normcase(path)
+                    for path in sys.path[len(original_sys_path):]
+                )
+                original_sys_path = [
+                    path for path in original_sys_path
+                    if os.path.normcase(path) not in system_paths
+                ]
+                sys.path = original_sys_path
+
+                # Second, add lib directories.
+                # ensuring .pth file are processed.
+                for path in {lib_dirs!r}:
+                    assert not path in sys.path
+                    site.addsitedir(path)
+                '''
+            ).format(system_sites=system_sites, lib_dirs=self._lib_dirs))
+
+    def __enter__(self):
+        # type: () -> None
+        self._save_env = {
+            name: os.environ.get(name, None)
+            for name in ('PATH', 'PYTHONNOUSERSITE', 'PYTHONPATH')
+        }
+
+        path = self._bin_dirs[:]
+        old_path = self._save_env['PATH']
+        if old_path:
+            path.extend(old_path.split(os.pathsep))
+
+        pythonpath = [self._site_dir]
+
+        os.environ.update({
+            'PATH': os.pathsep.join(path),
+            'PYTHONNOUSERSITE': '1',
+            'PYTHONPATH': os.pathsep.join(pythonpath),
+        })
+
+    def __exit__(
+        self,
+        exc_type,  # type: Optional[Type[BaseException]]
+        exc_val,  # type: Optional[BaseException]
+        exc_tb  # type: Optional[TracebackType]
+    ):
+        # type: (...) -> None
+        for varname, old_value in self._save_env.items():
+            if old_value is None:
+                os.environ.pop(varname, None)
+            else:
+                os.environ[varname] = old_value
+
+    def check_requirements(self, reqs):
+        # type: (Iterable[str]) -> Tuple[Set[Tuple[str, str]], Set[str]]
+        """Return 2 sets:
+            - conflicting requirements: set of (installed, wanted) reqs tuples
+            - missing requirements: set of reqs
+        """
+        missing = set()
+        conflicting = set()
+        if reqs:
+            ws = WorkingSet(self._lib_dirs)
+            for req in reqs:
+                try:
+                    if ws.find(Requirement.parse(req)) is None:
+                        missing.add(req)
+                except VersionConflict as e:
+                    conflicting.add((str(e.args[0].as_requirement()),
+                                     str(e.args[1])))
+        return conflicting, missing
+
+    def install_requirements(
+        self,
+        finder,  # type: PackageFinder
+        requirements,  # type: Iterable[str]
+        prefix_as_string,  # type: str
+        message  # type: str
+    ):
+        # type: (...) -> None
+        prefix = self._prefixes[prefix_as_string]
+        assert not prefix.setup
+        prefix.setup = True
+        if not requirements:
+            return
+        args = [
+            sys.executable, os.path.dirname(pip_location), 'install',
+            '--ignore-installed', '--no-user', '--prefix', prefix.path,
+            '--no-warn-script-location',
+        ]  # type: List[str]
+        if logger.getEffectiveLevel() <= logging.DEBUG:
+            args.append('-v')
+        for format_control in ('no_binary', 'only_binary'):
+            formats = getattr(finder.format_control, format_control)
+            args.extend(('--' + format_control.replace('_', '-'),
+                         ','.join(sorted(formats or {':none:'}))))
+
+        index_urls = finder.index_urls
+        if index_urls:
+            args.extend(['-i', index_urls[0]])
+            for extra_index in index_urls[1:]:
+                args.extend(['--extra-index-url', extra_index])
+        else:
+            args.append('--no-index')
+        for link in finder.find_links:
+            args.extend(['--find-links', link])
+
+        for host in finder.trusted_hosts:
+            args.extend(['--trusted-host', host])
+        if finder.allow_all_prereleases:
+            args.append('--pre')
+        if finder.prefer_binary:
+            args.append('--prefer-binary')
+        args.append('--')
+        args.extend(requirements)
+        with open_spinner(message) as spinner:
+            call_subprocess(args, spinner=spinner)
+
+
+class NoOpBuildEnvironment(BuildEnvironment):
+    """A no-op drop-in replacement for BuildEnvironment
+    """
+
+    def __init__(self):
+        # type: () -> None
+        pass
+
+    def __enter__(self):
+        # type: () -> None
+        pass
+
+    def __exit__(
+        self,
+        exc_type,  # type: Optional[Type[BaseException]]
+        exc_val,  # type: Optional[BaseException]
+        exc_tb  # type: Optional[TracebackType]
+    ):
+        # type: (...) -> None
+        pass
+
+    def cleanup(self):
+        # type: () -> None
+        pass
+
+    def install_requirements(
+        self,
+        finder,  # type: PackageFinder
+        requirements,  # type: Iterable[str]
+        prefix_as_string,  # type: str
+        message  # type: str
+    ):
+        # type: (...) -> None
+        raise NotImplementedError()
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cache.py b/myenv/lib/python3.9/site-packages/pip/_internal/cache.py
new file mode 100644
index 0000000..07db948
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cache.py
@@ -0,0 +1,346 @@
+"""Cache Management
+"""
+
+import hashlib
+import json
+import logging
+import os
+
+from pip._vendor.packaging.tags import interpreter_name, interpreter_version
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.exceptions import InvalidWheelFilename
+from pip._internal.models.link import Link
+from pip._internal.models.wheel import Wheel
+from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.urls import path_to_url
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, Set, List, Any, Dict
+
+    from pip._vendor.packaging.tags import Tag
+
+    from pip._internal.models.format_control import FormatControl
+
+logger = logging.getLogger(__name__)
+
+
+def _hash_dict(d):
+    # type: (Dict[str, str]) -> str
+    """Return a stable sha224 of a dictionary."""
+    s = json.dumps(d, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
+    return hashlib.sha224(s.encode("ascii")).hexdigest()
+
+
+class Cache(object):
+    """An abstract class - provides cache directories for data from links
+
+
+        :param cache_dir: The root of the cache.
+        :param format_control: An object of FormatControl class to limit
+            binaries being read from the cache.
+        :param allowed_formats: which formats of files the cache should store.
+            ('binary' and 'source' are the only allowed values)
+    """
+
+    def __init__(self, cache_dir, format_control, allowed_formats):
+        # type: (str, FormatControl, Set[str]) -> None
+        super(Cache, self).__init__()
+        assert not cache_dir or os.path.isabs(cache_dir)
+        self.cache_dir = cache_dir or None
+        self.format_control = format_control
+        self.allowed_formats = allowed_formats
+
+        _valid_formats = {"source", "binary"}
+        assert self.allowed_formats.union(_valid_formats) == _valid_formats
+
+    def _get_cache_path_parts_legacy(self, link):
+        # type: (Link) -> List[str]
+        """Get parts of part that must be os.path.joined with cache_dir
+
+        Legacy cache key (pip < 20) for compatibility with older caches.
+        """
+
+        # We want to generate an url to use as our cache key, we don't want to
+        # just re-use the URL because it might have other items in the fragment
+        # and we don't care about those.
+        key_parts = [link.url_without_fragment]
+        if link.hash_name is not None and link.hash is not None:
+            key_parts.append("=".join([link.hash_name, link.hash]))
+        key_url = "#".join(key_parts)
+
+        # Encode our key url with sha224, we'll use this because it has similar
+        # security properties to sha256, but with a shorter total output (and
+        # thus less secure). However the differences don't make a lot of
+        # difference for our use case here.
+        hashed = hashlib.sha224(key_url.encode()).hexdigest()
+
+        # We want to nest the directories some to prevent having a ton of top
+        # level directories where we might run out of sub directories on some
+        # FS.
+        parts = [hashed[:2], hashed[2:4], hashed[4:6], hashed[6:]]
+
+        return parts
+
+    def _get_cache_path_parts(self, link):
+        # type: (Link) -> List[str]
+        """Get parts of part that must be os.path.joined with cache_dir
+        """
+
+        # We want to generate an url to use as our cache key, we don't want to
+        # just re-use the URL because it might have other items in the fragment
+        # and we don't care about those.
+        key_parts = {"url": link.url_without_fragment}
+        if link.hash_name is not None and link.hash is not None:
+            key_parts[link.hash_name] = link.hash
+        if link.subdirectory_fragment:
+            key_parts["subdirectory"] = link.subdirectory_fragment
+
+        # Include interpreter name, major and minor version in cache key
+        # to cope with ill-behaved sdists that build a different wheel
+        # depending on the python version their setup.py is being run on,
+        # and don't encode the difference in compatibility tags.
+        # https://github.com/pypa/pip/issues/7296
+        key_parts["interpreter_name"] = interpreter_name()
+        key_parts["interpreter_version"] = interpreter_version()
+
+        # Encode our key url with sha224, we'll use this because it has similar
+        # security properties to sha256, but with a shorter total output (and
+        # thus less secure). However the differences don't make a lot of
+        # difference for our use case here.
+        hashed = _hash_dict(key_parts)
+
+        # We want to nest the directories some to prevent having a ton of top
+        # level directories where we might run out of sub directories on some
+        # FS.
+        parts = [hashed[:2], hashed[2:4], hashed[4:6], hashed[6:]]
+
+        return parts
+
+    def _get_candidates(self, link, canonical_package_name):
+        # type: (Link, str) -> List[Any]
+        can_not_cache = (
+            not self.cache_dir or
+            not canonical_package_name or
+            not link
+        )
+        if can_not_cache:
+            return []
+
+        formats = self.format_control.get_allowed_formats(
+            canonical_package_name
+        )
+        if not self.allowed_formats.intersection(formats):
+            return []
+
+        candidates = []
+        path = self.get_path_for_link(link)
+        if os.path.isdir(path):
+            for candidate in os.listdir(path):
+                candidates.append((candidate, path))
+        # TODO remove legacy path lookup in pip>=21
+        legacy_path = self.get_path_for_link_legacy(link)
+        if os.path.isdir(legacy_path):
+            for candidate in os.listdir(legacy_path):
+                candidates.append((candidate, legacy_path))
+        return candidates
+
+    def get_path_for_link_legacy(self, link):
+        # type: (Link) -> str
+        raise NotImplementedError()
+
+    def get_path_for_link(self, link):
+        # type: (Link) -> str
+        """Return a directory to store cached items in for link.
+        """
+        raise NotImplementedError()
+
+    def get(
+        self,
+        link,            # type: Link
+        package_name,    # type: Optional[str]
+        supported_tags,  # type: List[Tag]
+    ):
+        # type: (...) -> Link
+        """Returns a link to a cached item if it exists, otherwise returns the
+        passed link.
+        """
+        raise NotImplementedError()
+
+
+class SimpleWheelCache(Cache):
+    """A cache of wheels for future installs.
+    """
+
+    def __init__(self, cache_dir, format_control):
+        # type: (str, FormatControl) -> None
+        super(SimpleWheelCache, self).__init__(
+            cache_dir, format_control, {"binary"}
+        )
+
+    def get_path_for_link_legacy(self, link):
+        # type: (Link) -> str
+        parts = self._get_cache_path_parts_legacy(link)
+        assert self.cache_dir
+        return os.path.join(self.cache_dir, "wheels", *parts)
+
+    def get_path_for_link(self, link):
+        # type: (Link) -> str
+        """Return a directory to store cached wheels for link
+
+        Because there are M wheels for any one sdist, we provide a directory
+        to cache them in, and then consult that directory when looking up
+        cache hits.
+
+        We only insert things into the cache if they have plausible version
+        numbers, so that we don't contaminate the cache with things that were
+        not unique. E.g. ./package might have dozens of installs done for it
+        and build a version of 0.0...and if we built and cached a wheel, we'd
+        end up using the same wheel even if the source has been edited.
+
+        :param link: The link of the sdist for which this will cache wheels.
+        """
+        parts = self._get_cache_path_parts(link)
+        assert self.cache_dir
+        # Store wheels within the root cache_dir
+        return os.path.join(self.cache_dir, "wheels", *parts)
+
+    def get(
+        self,
+        link,            # type: Link
+        package_name,    # type: Optional[str]
+        supported_tags,  # type: List[Tag]
+    ):
+        # type: (...) -> Link
+        candidates = []
+
+        if not package_name:
+            return link
+
+        canonical_package_name = canonicalize_name(package_name)
+        for wheel_name, wheel_dir in self._get_candidates(
+            link, canonical_package_name
+        ):
+            try:
+                wheel = Wheel(wheel_name)
+            except InvalidWheelFilename:
+                continue
+            if canonicalize_name(wheel.name) != canonical_package_name:
+                logger.debug(
+                    "Ignoring cached wheel %s for %s as it "
+                    "does not match the expected distribution name %s.",
+                    wheel_name, link, package_name,
+                )
+                continue
+            if not wheel.supported(supported_tags):
+                # Built for a different python/arch/etc
+                continue
+            candidates.append(
+                (
+                    wheel.support_index_min(supported_tags),
+                    wheel_name,
+                    wheel_dir,
+                )
+            )
+
+        if not candidates:
+            return link
+
+        _, wheel_name, wheel_dir = min(candidates)
+        return Link(path_to_url(os.path.join(wheel_dir, wheel_name)))
+
+
+class EphemWheelCache(SimpleWheelCache):
+    """A SimpleWheelCache that creates it's own temporary cache directory
+    """
+
+    def __init__(self, format_control):
+        # type: (FormatControl) -> None
+        self._temp_dir = TempDirectory(
+            kind=tempdir_kinds.EPHEM_WHEEL_CACHE,
+            globally_managed=True,
+        )
+
+        super(EphemWheelCache, self).__init__(
+            self._temp_dir.path, format_control
+        )
+
+
+class CacheEntry(object):
+    def __init__(
+        self,
+        link,  # type: Link
+        persistent,  # type: bool
+    ):
+        self.link = link
+        self.persistent = persistent
+
+
+class WheelCache(Cache):
+    """Wraps EphemWheelCache and SimpleWheelCache into a single Cache
+
+    This Cache allows for gracefully degradation, using the ephem wheel cache
+    when a certain link is not found in the simple wheel cache first.
+    """
+
+    def __init__(self, cache_dir, format_control):
+        # type: (str, FormatControl) -> None
+        super(WheelCache, self).__init__(
+            cache_dir, format_control, {'binary'}
+        )
+        self._wheel_cache = SimpleWheelCache(cache_dir, format_control)
+        self._ephem_cache = EphemWheelCache(format_control)
+
+    def get_path_for_link_legacy(self, link):
+        # type: (Link) -> str
+        return self._wheel_cache.get_path_for_link_legacy(link)
+
+    def get_path_for_link(self, link):
+        # type: (Link) -> str
+        return self._wheel_cache.get_path_for_link(link)
+
+    def get_ephem_path_for_link(self, link):
+        # type: (Link) -> str
+        return self._ephem_cache.get_path_for_link(link)
+
+    def get(
+        self,
+        link,            # type: Link
+        package_name,    # type: Optional[str]
+        supported_tags,  # type: List[Tag]
+    ):
+        # type: (...) -> Link
+        cache_entry = self.get_cache_entry(link, package_name, supported_tags)
+        if cache_entry is None:
+            return link
+        return cache_entry.link
+
+    def get_cache_entry(
+        self,
+        link,            # type: Link
+        package_name,    # type: Optional[str]
+        supported_tags,  # type: List[Tag]
+    ):
+        # type: (...) -> Optional[CacheEntry]
+        """Returns a CacheEntry with a link to a cached item if it exists or
+        None. The cache entry indicates if the item was found in the persistent
+        or ephemeral cache.
+        """
+        retval = self._wheel_cache.get(
+            link=link,
+            package_name=package_name,
+            supported_tags=supported_tags,
+        )
+        if retval is not link:
+            return CacheEntry(retval, persistent=True)
+
+        retval = self._ephem_cache.get(
+            link=link,
+            package_name=package_name,
+            supported_tags=supported_tags,
+        )
+        if retval is not link:
+            return CacheEntry(retval, persistent=False)
+
+        return None
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/__init__.py
new file mode 100644
index 0000000..e589bb9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/__init__.py
@@ -0,0 +1,4 @@
+"""Subpackage containing all of pip's command line interface related code
+"""
+
+# This file intentionally does not import submodules
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/autocompletion.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/autocompletion.py
new file mode 100644
index 0000000..329de60
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/autocompletion.py
@@ -0,0 +1,164 @@
+"""Logic that powers autocompletion installed by ``pip completion``.
+"""
+
+import optparse
+import os
+import sys
+from itertools import chain
+
+from pip._internal.cli.main_parser import create_main_parser
+from pip._internal.commands import commands_dict, create_command
+from pip._internal.utils.misc import get_installed_distributions
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any, Iterable, List, Optional
+
+
+def autocomplete():
+    # type: () -> None
+    """Entry Point for completion of main and subcommand options.
+    """
+    # Don't complete if user hasn't sourced bash_completion file.
+    if 'PIP_AUTO_COMPLETE' not in os.environ:
+        return
+    cwords = os.environ['COMP_WORDS'].split()[1:]
+    cword = int(os.environ['COMP_CWORD'])
+    try:
+        current = cwords[cword - 1]
+    except IndexError:
+        current = ''
+
+    parser = create_main_parser()
+    subcommands = list(commands_dict)
+    options = []
+
+    # subcommand
+    subcommand_name = None  # type: Optional[str]
+    for word in cwords:
+        if word in subcommands:
+            subcommand_name = word
+            break
+    # subcommand options
+    if subcommand_name is not None:
+        # special case: 'help' subcommand has no options
+        if subcommand_name == 'help':
+            sys.exit(1)
+        # special case: list locally installed dists for show and uninstall
+        should_list_installed = (
+            subcommand_name in ['show', 'uninstall'] and
+            not current.startswith('-')
+        )
+        if should_list_installed:
+            installed = []
+            lc = current.lower()
+            for dist in get_installed_distributions(local_only=True):
+                if dist.key.startswith(lc) and dist.key not in cwords[1:]:
+                    installed.append(dist.key)
+            # if there are no dists installed, fall back to option completion
+            if installed:
+                for dist in installed:
+                    print(dist)
+                sys.exit(1)
+
+        subcommand = create_command(subcommand_name)
+
+        for opt in subcommand.parser.option_list_all:
+            if opt.help != optparse.SUPPRESS_HELP:
+                for opt_str in opt._long_opts + opt._short_opts:
+                    options.append((opt_str, opt.nargs))
+
+        # filter out previously specified options from available options
+        prev_opts = [x.split('=')[0] for x in cwords[1:cword - 1]]
+        options = [(x, v) for (x, v) in options if x not in prev_opts]
+        # filter options by current input
+        options = [(k, v) for k, v in options if k.startswith(current)]
+        # get completion type given cwords and available subcommand options
+        completion_type = get_path_completion_type(
+            cwords, cword, subcommand.parser.option_list_all,
+        )
+        # get completion files and directories if ``completion_type`` is
+        # ``<file>``, ``<dir>`` or ``<path>``
+        if completion_type:
+            paths = auto_complete_paths(current, completion_type)
+            options = [(path, 0) for path in paths]
+        for option in options:
+            opt_label = option[0]
+            # append '=' to options which require args
+            if option[1] and option[0][:2] == "--":
+                opt_label += '='
+            print(opt_label)
+    else:
+        # show main parser options only when necessary
+
+        opts = [i.option_list for i in parser.option_groups]
+        opts.append(parser.option_list)
+        flattened_opts = chain.from_iterable(opts)
+        if current.startswith('-'):
+            for opt in flattened_opts:
+                if opt.help != optparse.SUPPRESS_HELP:
+                    subcommands += opt._long_opts + opt._short_opts
+        else:
+            # get completion type given cwords and all available options
+            completion_type = get_path_completion_type(cwords, cword,
+                                                       flattened_opts)
+            if completion_type:
+                subcommands = list(auto_complete_paths(current,
+                                                       completion_type))
+
+        print(' '.join([x for x in subcommands if x.startswith(current)]))
+    sys.exit(1)
+
+
+def get_path_completion_type(cwords, cword, opts):
+    # type: (List[str], int, Iterable[Any]) -> Optional[str]
+    """Get the type of path completion (``file``, ``dir``, ``path`` or None)
+
+    :param cwords: same as the environmental variable ``COMP_WORDS``
+    :param cword: same as the environmental variable ``COMP_CWORD``
+    :param opts: The available options to check
+    :return: path completion type (``file``, ``dir``, ``path`` or None)
+    """
+    if cword < 2 or not cwords[cword - 2].startswith('-'):
+        return None
+    for opt in opts:
+        if opt.help == optparse.SUPPRESS_HELP:
+            continue
+        for o in str(opt).split('/'):
+            if cwords[cword - 2].split('=')[0] == o:
+                if not opt.metavar or any(
+                        x in ('path', 'file', 'dir')
+                        for x in opt.metavar.split('/')):
+                    return opt.metavar
+    return None
+
+
+def auto_complete_paths(current, completion_type):
+    # type: (str, str) -> Iterable[str]
+    """If ``completion_type`` is ``file`` or ``path``, list all regular files
+    and directories starting with ``current``; otherwise only list directories
+    starting with ``current``.
+
+    :param current: The word to be completed
+    :param completion_type: path completion type(`file`, `path` or `dir`)i
+    :return: A generator of regular files and/or directories
+    """
+    directory, filename = os.path.split(current)
+    current_path = os.path.abspath(directory)
+    # Don't complete paths if they can't be accessed
+    if not os.access(current_path, os.R_OK):
+        return
+    filename = os.path.normcase(filename)
+    # list all files that start with ``filename``
+    file_list = (x for x in os.listdir(current_path)
+                 if os.path.normcase(x).startswith(filename))
+    for f in file_list:
+        opt = os.path.join(current_path, f)
+        comp_file = os.path.normcase(os.path.join(directory, f))
+        # complete regular files when there is not ``<dir>`` after option
+        # complete directories when there is ``<file>``, ``<path>`` or
+        # ``<dir>``after option
+        if completion_type != 'dir' and os.path.isfile(opt):
+            yield comp_file
+        elif os.path.isdir(opt):
+            yield os.path.join(comp_file, '')
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/base_command.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/base_command.py
new file mode 100644
index 0000000..197400a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/base_command.py
@@ -0,0 +1,265 @@
+"""Base Command class, and related routines"""
+
+from __future__ import absolute_import, print_function
+
+import logging
+import logging.config
+import optparse
+import os
+import platform
+import sys
+import traceback
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.command_context import CommandContextMixIn
+from pip._internal.cli.parser import (
+    ConfigOptionParser,
+    UpdatingDefaultsHelpFormatter,
+)
+from pip._internal.cli.status_codes import (
+    ERROR,
+    PREVIOUS_BUILD_DIR_ERROR,
+    UNKNOWN_ERROR,
+    VIRTUALENV_NOT_FOUND,
+)
+from pip._internal.exceptions import (
+    BadCommand,
+    CommandError,
+    InstallationError,
+    NetworkConnectionError,
+    PreviousBuildDirError,
+    SubProcessError,
+    UninstallationError,
+)
+from pip._internal.utils.deprecation import deprecated
+from pip._internal.utils.filesystem import check_path_owner
+from pip._internal.utils.logging import BrokenStdoutLoggingError, setup_logging
+from pip._internal.utils.misc import get_prog, normalize_path
+from pip._internal.utils.temp_dir import (
+    global_tempdir_manager,
+    tempdir_registry,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Optional, Tuple, Any
+    from optparse import Values
+
+    from pip._internal.utils.temp_dir import (
+        TempDirectoryTypeRegistry as TempDirRegistry
+    )
+
+__all__ = ['Command']
+
+logger = logging.getLogger(__name__)
+
+
+class Command(CommandContextMixIn):
+    usage = None  # type: str
+    ignore_require_venv = False  # type: bool
+
+    def __init__(self, name, summary, isolated=False):
+        # type: (str, str, bool) -> None
+        super(Command, self).__init__()
+        parser_kw = {
+            'usage': self.usage,
+            'prog': '{} {}'.format(get_prog(), name),
+            'formatter': UpdatingDefaultsHelpFormatter(),
+            'add_help_option': False,
+            'name': name,
+            'description': self.__doc__,
+            'isolated': isolated,
+        }
+
+        self.name = name
+        self.summary = summary
+        self.parser = ConfigOptionParser(**parser_kw)
+
+        self.tempdir_registry = None  # type: Optional[TempDirRegistry]
+
+        # Commands should add options to this option group
+        optgroup_name = '{} Options'.format(self.name.capitalize())
+        self.cmd_opts = optparse.OptionGroup(self.parser, optgroup_name)
+
+        # Add the general options
+        gen_opts = cmdoptions.make_option_group(
+            cmdoptions.general_group,
+            self.parser,
+        )
+        self.parser.add_option_group(gen_opts)
+
+        self.add_options()
+
+    def add_options(self):
+        # type: () -> None
+        pass
+
+    def handle_pip_version_check(self, options):
+        # type: (Values) -> None
+        """
+        This is a no-op so that commands by default do not do the pip version
+        check.
+        """
+        # Make sure we do the pip version check if the index_group options
+        # are present.
+        assert not hasattr(options, 'no_index')
+
+    def run(self, options, args):
+        # type: (Values, List[Any]) -> int
+        raise NotImplementedError
+
+    def parse_args(self, args):
+        # type: (List[str]) -> Tuple[Any, Any]
+        # factored out for testability
+        return self.parser.parse_args(args)
+
+    def main(self, args):
+        # type: (List[str]) -> int
+        try:
+            with self.main_context():
+                return self._main(args)
+        finally:
+            logging.shutdown()
+
+    def _main(self, args):
+        # type: (List[str]) -> int
+        # We must initialize this before the tempdir manager, otherwise the
+        # configuration would not be accessible by the time we clean up the
+        # tempdir manager.
+        self.tempdir_registry = self.enter_context(tempdir_registry())
+        # Intentionally set as early as possible so globally-managed temporary
+        # directories are available to the rest of the code.
+        self.enter_context(global_tempdir_manager())
+
+        options, args = self.parse_args(args)
+
+        # Set verbosity so that it can be used elsewhere.
+        self.verbosity = options.verbose - options.quiet
+
+        level_number = setup_logging(
+            verbosity=self.verbosity,
+            no_color=options.no_color,
+            user_log_file=options.log,
+        )
+
+        if (
+            sys.version_info[:2] == (2, 7) and
+            not options.no_python_version_warning
+        ):
+            message = (
+                "pip 21.0 will drop support for Python 2.7 in January 2021. "
+                "More details about Python 2 support in pip can be found at "
+                "https://pip.pypa.io/en/latest/development/release-process/#python-2-support"  # noqa
+            )
+            if platform.python_implementation() == "CPython":
+                message = (
+                    "Python 2.7 reached the end of its life on January "
+                    "1st, 2020. Please upgrade your Python as Python 2.7 "
+                    "is no longer maintained. "
+                ) + message
+            deprecated(message, replacement=None, gone_in="21.0")
+
+        if (
+            sys.version_info[:2] == (3, 5) and
+            not options.no_python_version_warning
+        ):
+            message = (
+                "Python 3.5 reached the end of its life on September "
+                "13th, 2020. Please upgrade your Python as Python 3.5 "
+                "is no longer maintained. pip 21.0 will drop support "
+                "for Python 3.5 in January 2021."
+            )
+            deprecated(message, replacement=None, gone_in="21.0")
+
+        # TODO: Try to get these passing down from the command?
+        #       without resorting to os.environ to hold these.
+        #       This also affects isolated builds and it should.
+
+        if options.no_input:
+            os.environ['PIP_NO_INPUT'] = '1'
+
+        if options.exists_action:
+            os.environ['PIP_EXISTS_ACTION'] = ' '.join(options.exists_action)
+
+        if options.require_venv and not self.ignore_require_venv:
+            # If a venv is required check if it can really be found
+            if not running_under_virtualenv():
+                logger.critical(
+                    'Could not find an activated virtualenv (required).'
+                )
+                sys.exit(VIRTUALENV_NOT_FOUND)
+
+        if options.cache_dir:
+            options.cache_dir = normalize_path(options.cache_dir)
+            if not check_path_owner(options.cache_dir):
+                logger.warning(
+                    "The directory '%s' or its parent directory is not owned "
+                    "or is not writable by the current user. The cache "
+                    "has been disabled. Check the permissions and owner of "
+                    "that directory. If executing pip with sudo, you may want "
+                    "sudo's -H flag.",
+                    options.cache_dir,
+                )
+                options.cache_dir = None
+
+        if getattr(options, "build_dir", None):
+            deprecated(
+                reason=(
+                    "The -b/--build/--build-dir/--build-directory "
+                    "option is deprecated."
+                ),
+                replacement=(
+                    "use the TMPDIR/TEMP/TMP environment variable, "
+                    "possibly combined with --no-clean"
+                ),
+                gone_in="20.3",
+                issue=8333,
+            )
+
+        if 'resolver' in options.unstable_features:
+            logger.critical(
+                "--unstable-feature=resolver is no longer supported, and "
+                "has been replaced with --use-feature=2020-resolver instead."
+            )
+            sys.exit(ERROR)
+
+        try:
+            status = self.run(options, args)
+            assert isinstance(status, int)
+            return status
+        except PreviousBuildDirError as exc:
+            logger.critical(str(exc))
+            logger.debug('Exception information:', exc_info=True)
+
+            return PREVIOUS_BUILD_DIR_ERROR
+        except (InstallationError, UninstallationError, BadCommand,
+                SubProcessError, NetworkConnectionError) as exc:
+            logger.critical(str(exc))
+            logger.debug('Exception information:', exc_info=True)
+
+            return ERROR
+        except CommandError as exc:
+            logger.critical('%s', exc)
+            logger.debug('Exception information:', exc_info=True)
+
+            return ERROR
+        except BrokenStdoutLoggingError:
+            # Bypass our logger and write any remaining messages to stderr
+            # because stdout no longer works.
+            print('ERROR: Pipe to stdout was broken', file=sys.stderr)
+            if level_number <= logging.DEBUG:
+                traceback.print_exc(file=sys.stderr)
+
+            return ERROR
+        except KeyboardInterrupt:
+            logger.critical('Operation cancelled by user')
+            logger.debug('Exception information:', exc_info=True)
+
+            return ERROR
+        except BaseException:
+            logger.critical('Exception:', exc_info=True)
+
+            return UNKNOWN_ERROR
+        finally:
+            self.handle_pip_version_check(options)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/cmdoptions.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/cmdoptions.py
new file mode 100644
index 0000000..ed42c5f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/cmdoptions.py
@@ -0,0 +1,975 @@
+"""
+shared options and groups
+
+The principle here is to define options once, but *not* instantiate them
+globally. One reason being that options with action='append' can carry state
+between parses. pip parses general options twice internally, and shouldn't
+pass on state. To be consistent, all options will follow this design.
+"""
+
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
+
+from __future__ import absolute_import
+
+import os
+import textwrap
+import warnings
+from distutils.util import strtobool
+from functools import partial
+from optparse import SUPPRESS_HELP, Option, OptionGroup
+from textwrap import dedent
+
+from pip._internal.cli.progress_bars import BAR_TYPES
+from pip._internal.exceptions import CommandError
+from pip._internal.locations import USER_CACHE_DIR, get_src_prefix
+from pip._internal.models.format_control import FormatControl
+from pip._internal.models.index import PyPI
+from pip._internal.models.target_python import TargetPython
+from pip._internal.utils.hashes import STRONG_HASHES
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any, Callable, Dict, Optional, Tuple
+    from optparse import OptionParser, Values
+    from pip._internal.cli.parser import ConfigOptionParser
+
+
+def raise_option_error(parser, option, msg):
+    # type: (OptionParser, Option, str) -> None
+    """
+    Raise an option parsing error using parser.error().
+
+    Args:
+      parser: an OptionParser instance.
+      option: an Option instance.
+      msg: the error text.
+    """
+    msg = '{} error: {}'.format(option, msg)
+    msg = textwrap.fill(' '.join(msg.split()))
+    parser.error(msg)
+
+
+def make_option_group(group, parser):
+    # type: (Dict[str, Any], ConfigOptionParser) -> OptionGroup
+    """
+    Return an OptionGroup object
+    group  -- assumed to be dict with 'name' and 'options' keys
+    parser -- an optparse Parser
+    """
+    option_group = OptionGroup(parser, group['name'])
+    for option in group['options']:
+        option_group.add_option(option())
+    return option_group
+
+
+def check_install_build_global(options, check_options=None):
+    # type: (Values, Optional[Values]) -> None
+    """Disable wheels if per-setup.py call options are set.
+
+    :param options: The OptionParser options to update.
+    :param check_options: The options to check, if not supplied defaults to
+        options.
+    """
+    if check_options is None:
+        check_options = options
+
+    def getname(n):
+        # type: (str) -> Optional[Any]
+        return getattr(check_options, n, None)
+    names = ["build_options", "global_options", "install_options"]
+    if any(map(getname, names)):
+        control = options.format_control
+        control.disallow_binaries()
+        warnings.warn(
+            'Disabling all use of wheels due to the use of --build-option '
+            '/ --global-option / --install-option.', stacklevel=2,
+        )
+
+
+def check_dist_restriction(options, check_target=False):
+    # type: (Values, bool) -> None
+    """Function for determining if custom platform options are allowed.
+
+    :param options: The OptionParser options.
+    :param check_target: Whether or not to check if --target is being used.
+    """
+    dist_restriction_set = any([
+        options.python_version,
+        options.platform,
+        options.abi,
+        options.implementation,
+    ])
+
+    binary_only = FormatControl(set(), {':all:'})
+    sdist_dependencies_allowed = (
+        options.format_control != binary_only and
+        not options.ignore_dependencies
+    )
+
+    # Installations or downloads using dist restrictions must not combine
+    # source distributions and dist-specific wheels, as they are not
+    # guaranteed to be locally compatible.
+    if dist_restriction_set and sdist_dependencies_allowed:
+        raise CommandError(
+            "When restricting platform and interpreter constraints using "
+            "--python-version, --platform, --abi, or --implementation, "
+            "either --no-deps must be set, or --only-binary=:all: must be "
+            "set and --no-binary must not be set (or must be set to "
+            ":none:)."
+        )
+
+    if check_target:
+        if dist_restriction_set and not options.target_dir:
+            raise CommandError(
+                "Can not use any platform or abi specific options unless "
+                "installing via '--target'"
+            )
+
+
+def _path_option_check(option, opt, value):
+    # type: (Option, str, str) -> str
+    return os.path.expanduser(value)
+
+
+class PipOption(Option):
+    TYPES = Option.TYPES + ("path",)
+    TYPE_CHECKER = Option.TYPE_CHECKER.copy()
+    TYPE_CHECKER["path"] = _path_option_check
+
+
+###########
+# options #
+###########
+
+help_ = partial(
+    Option,
+    '-h', '--help',
+    dest='help',
+    action='help',
+    help='Show help.',
+)  # type: Callable[..., Option]
+
+isolated_mode = partial(
+    Option,
+    "--isolated",
+    dest="isolated_mode",
+    action="store_true",
+    default=False,
+    help=(
+        "Run pip in an isolated mode, ignoring environment variables and user "
+        "configuration."
+    ),
+)  # type: Callable[..., Option]
+
+require_virtualenv = partial(
+    Option,
+    # Run only if inside a virtualenv, bail if not.
+    '--require-virtualenv', '--require-venv',
+    dest='require_venv',
+    action='store_true',
+    default=False,
+    help=SUPPRESS_HELP
+)  # type: Callable[..., Option]
+
+verbose = partial(
+    Option,
+    '-v', '--verbose',
+    dest='verbose',
+    action='count',
+    default=0,
+    help='Give more output. Option is additive, and can be used up to 3 times.'
+)  # type: Callable[..., Option]
+
+no_color = partial(
+    Option,
+    '--no-color',
+    dest='no_color',
+    action='store_true',
+    default=False,
+    help="Suppress colored output",
+)  # type: Callable[..., Option]
+
+version = partial(
+    Option,
+    '-V', '--version',
+    dest='version',
+    action='store_true',
+    help='Show version and exit.',
+)  # type: Callable[..., Option]
+
+quiet = partial(
+    Option,
+    '-q', '--quiet',
+    dest='quiet',
+    action='count',
+    default=0,
+    help=(
+        'Give less output. Option is additive, and can be used up to 3'
+        ' times (corresponding to WARNING, ERROR, and CRITICAL logging'
+        ' levels).'
+    ),
+)  # type: Callable[..., Option]
+
+progress_bar = partial(
+    Option,
+    '--progress-bar',
+    dest='progress_bar',
+    type='choice',
+    choices=list(BAR_TYPES.keys()),
+    default='on',
+    help=(
+        'Specify type of progress to be displayed [' +
+        '|'.join(BAR_TYPES.keys()) + '] (default: %default)'
+    ),
+)  # type: Callable[..., Option]
+
+log = partial(
+    PipOption,
+    "--log", "--log-file", "--local-log",
+    dest="log",
+    metavar="path",
+    type="path",
+    help="Path to a verbose appending log."
+)  # type: Callable[..., Option]
+
+no_input = partial(
+    Option,
+    # Don't ask for input
+    '--no-input',
+    dest='no_input',
+    action='store_true',
+    default=False,
+    help="Disable prompting for input."
+)  # type: Callable[..., Option]
+
+proxy = partial(
+    Option,
+    '--proxy',
+    dest='proxy',
+    type='str',
+    default='',
+    help="Specify a proxy in the form [user:passwd@]proxy.server:port."
+)  # type: Callable[..., Option]
+
+retries = partial(
+    Option,
+    '--retries',
+    dest='retries',
+    type='int',
+    default=5,
+    help="Maximum number of retries each connection should attempt "
+         "(default %default times).",
+)  # type: Callable[..., Option]
+
+timeout = partial(
+    Option,
+    '--timeout', '--default-timeout',
+    metavar='sec',
+    dest='timeout',
+    type='float',
+    default=15,
+    help='Set the socket timeout (default %default seconds).',
+)  # type: Callable[..., Option]
+
+
+def exists_action():
+    # type: () -> Option
+    return Option(
+        # Option when path already exist
+        '--exists-action',
+        dest='exists_action',
+        type='choice',
+        choices=['s', 'i', 'w', 'b', 'a'],
+        default=[],
+        action='append',
+        metavar='action',
+        help="Default action when a path already exists: "
+             "(s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort.",
+    )
+
+
+cert = partial(
+    PipOption,
+    '--cert',
+    dest='cert',
+    type='path',
+    metavar='path',
+    help="Path to alternate CA bundle.",
+)  # type: Callable[..., Option]
+
+client_cert = partial(
+    PipOption,
+    '--client-cert',
+    dest='client_cert',
+    type='path',
+    default=None,
+    metavar='path',
+    help="Path to SSL client certificate, a single file containing the "
+         "private key and the certificate in PEM format.",
+)  # type: Callable[..., Option]
+
+index_url = partial(
+    Option,
+    '-i', '--index-url', '--pypi-url',
+    dest='index_url',
+    metavar='URL',
+    default=PyPI.simple_url,
+    help="Base URL of the Python Package Index (default %default). "
+         "This should point to a repository compliant with PEP 503 "
+         "(the simple repository API) or a local directory laid out "
+         "in the same format.",
+)  # type: Callable[..., Option]
+
+
+def extra_index_url():
+    # type: () -> Option
+    return Option(
+        '--extra-index-url',
+        dest='extra_index_urls',
+        metavar='URL',
+        action='append',
+        default=[],
+        help="Extra URLs of package indexes to use in addition to "
+             "--index-url. Should follow the same rules as "
+             "--index-url.",
+    )
+
+
+no_index = partial(
+    Option,
+    '--no-index',
+    dest='no_index',
+    action='store_true',
+    default=False,
+    help='Ignore package index (only looking at --find-links URLs instead).',
+)  # type: Callable[..., Option]
+
+
+def find_links():
+    # type: () -> Option
+    return Option(
+        '-f', '--find-links',
+        dest='find_links',
+        action='append',
+        default=[],
+        metavar='url',
+        help="If a URL or path to an html file, then parse for links to "
+             "archives such as sdist (.tar.gz) or wheel (.whl) files. "
+             "If a local path or file:// URL that's a directory,  "
+             "then look for archives in the directory listing. "
+             "Links to VCS project URLs are not supported.",
+    )
+
+
+def trusted_host():
+    # type: () -> Option
+    return Option(
+        "--trusted-host",
+        dest="trusted_hosts",
+        action="append",
+        metavar="HOSTNAME",
+        default=[],
+        help="Mark this host or host:port pair as trusted, even though it "
+             "does not have valid or any HTTPS.",
+    )
+
+
+def constraints():
+    # type: () -> Option
+    return Option(
+        '-c', '--constraint',
+        dest='constraints',
+        action='append',
+        default=[],
+        metavar='file',
+        help='Constrain versions using the given constraints file. '
+        'This option can be used multiple times.'
+    )
+
+
+def requirements():
+    # type: () -> Option
+    return Option(
+        '-r', '--requirement',
+        dest='requirements',
+        action='append',
+        default=[],
+        metavar='file',
+        help='Install from the given requirements file. '
+        'This option can be used multiple times.'
+    )
+
+
+def editable():
+    # type: () -> Option
+    return Option(
+        '-e', '--editable',
+        dest='editables',
+        action='append',
+        default=[],
+        metavar='path/url',
+        help=('Install a project in editable mode (i.e. setuptools '
+              '"develop mode") from a local project path or a VCS url.'),
+    )
+
+
+def _handle_src(option, opt_str, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    value = os.path.abspath(value)
+    setattr(parser.values, option.dest, value)
+
+
+src = partial(
+    PipOption,
+    '--src', '--source', '--source-dir', '--source-directory',
+    dest='src_dir',
+    type='path',
+    metavar='dir',
+    default=get_src_prefix(),
+    action='callback',
+    callback=_handle_src,
+    help='Directory to check out editable projects into. '
+    'The default in a virtualenv is "<venv path>/src". '
+    'The default for global installs is "<current dir>/src".'
+)  # type: Callable[..., Option]
+
+
+def _get_format_control(values, option):
+    # type: (Values, Option) -> Any
+    """Get a format_control object."""
+    return getattr(values, option.dest)
+
+
+def _handle_no_binary(option, opt_str, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    existing = _get_format_control(parser.values, option)
+    FormatControl.handle_mutual_excludes(
+        value, existing.no_binary, existing.only_binary,
+    )
+
+
+def _handle_only_binary(option, opt_str, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    existing = _get_format_control(parser.values, option)
+    FormatControl.handle_mutual_excludes(
+        value, existing.only_binary, existing.no_binary,
+    )
+
+
+def no_binary():
+    # type: () -> Option
+    format_control = FormatControl(set(), set())
+    return Option(
+        "--no-binary", dest="format_control", action="callback",
+        callback=_handle_no_binary, type="str",
+        default=format_control,
+        help='Do not use binary packages. Can be supplied multiple times, and '
+             'each time adds to the existing value. Accepts either ":all:" to '
+             'disable all binary packages, ":none:" to empty the set (notice '
+             'the colons), or one or more package names with commas between '
+             'them (no colons). Note that some packages are tricky to compile '
+             'and may fail to install when this option is used on them.',
+    )
+
+
+def only_binary():
+    # type: () -> Option
+    format_control = FormatControl(set(), set())
+    return Option(
+        "--only-binary", dest="format_control", action="callback",
+        callback=_handle_only_binary, type="str",
+        default=format_control,
+        help='Do not use source packages. Can be supplied multiple times, and '
+             'each time adds to the existing value. Accepts either ":all:" to '
+             'disable all source packages, ":none:" to empty the set, or one '
+             'or more package names with commas between them. Packages '
+             'without binary distributions will fail to install when this '
+             'option is used on them.',
+    )
+
+
+platform = partial(
+    Option,
+    '--platform',
+    dest='platform',
+    metavar='platform',
+    default=None,
+    help=("Only use wheels compatible with <platform>. "
+          "Defaults to the platform of the running system."),
+)  # type: Callable[..., Option]
+
+
+# This was made a separate function for unit-testing purposes.
+def _convert_python_version(value):
+    # type: (str) -> Tuple[Tuple[int, ...], Optional[str]]
+    """
+    Convert a version string like "3", "37", or "3.7.3" into a tuple of ints.
+
+    :return: A 2-tuple (version_info, error_msg), where `error_msg` is
+        non-None if and only if there was a parsing error.
+    """
+    if not value:
+        # The empty string is the same as not providing a value.
+        return (None, None)
+
+    parts = value.split('.')
+    if len(parts) > 3:
+        return ((), 'at most three version parts are allowed')
+
+    if len(parts) == 1:
+        # Then we are in the case of "3" or "37".
+        value = parts[0]
+        if len(value) > 1:
+            parts = [value[0], value[1:]]
+
+    try:
+        version_info = tuple(int(part) for part in parts)
+    except ValueError:
+        return ((), 'each version part must be an integer')
+
+    return (version_info, None)
+
+
+def _handle_python_version(option, opt_str, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    """
+    Handle a provided --python-version value.
+    """
+    version_info, error_msg = _convert_python_version(value)
+    if error_msg is not None:
+        msg = (
+            'invalid --python-version value: {!r}: {}'.format(
+                value, error_msg,
+            )
+        )
+        raise_option_error(parser, option=option, msg=msg)
+
+    parser.values.python_version = version_info
+
+
+python_version = partial(
+    Option,
+    '--python-version',
+    dest='python_version',
+    metavar='python_version',
+    action='callback',
+    callback=_handle_python_version, type='str',
+    default=None,
+    help=dedent("""\
+    The Python interpreter version to use for wheel and "Requires-Python"
+    compatibility checks. Defaults to a version derived from the running
+    interpreter. The version can be specified using up to three dot-separated
+    integers (e.g. "3" for 3.0.0, "3.7" for 3.7.0, or "3.7.3"). A major-minor
+    version can also be given as a string without dots (e.g. "37" for 3.7.0).
+    """),
+)  # type: Callable[..., Option]
+
+
+implementation = partial(
+    Option,
+    '--implementation',
+    dest='implementation',
+    metavar='implementation',
+    default=None,
+    help=("Only use wheels compatible with Python "
+          "implementation <implementation>, e.g. 'pp', 'jy', 'cp', "
+          " or 'ip'. If not specified, then the current "
+          "interpreter implementation is used.  Use 'py' to force "
+          "implementation-agnostic wheels."),
+)  # type: Callable[..., Option]
+
+
+abi = partial(
+    Option,
+    '--abi',
+    dest='abi',
+    metavar='abi',
+    default=None,
+    help=("Only use wheels compatible with Python "
+          "abi <abi>, e.g. 'pypy_41'.  If not specified, then the "
+          "current interpreter abi tag is used.  Generally "
+          "you will need to specify --implementation, "
+          "--platform, and --python-version when using "
+          "this option."),
+)  # type: Callable[..., Option]
+
+
+def add_target_python_options(cmd_opts):
+    # type: (OptionGroup) -> None
+    cmd_opts.add_option(platform())
+    cmd_opts.add_option(python_version())
+    cmd_opts.add_option(implementation())
+    cmd_opts.add_option(abi())
+
+
+def make_target_python(options):
+    # type: (Values) -> TargetPython
+    target_python = TargetPython(
+        platform=options.platform,
+        py_version_info=options.python_version,
+        abi=options.abi,
+        implementation=options.implementation,
+    )
+
+    return target_python
+
+
+def prefer_binary():
+    # type: () -> Option
+    return Option(
+        "--prefer-binary",
+        dest="prefer_binary",
+        action="store_true",
+        default=False,
+        help="Prefer older binary packages over newer source packages."
+    )
+
+
+cache_dir = partial(
+    PipOption,
+    "--cache-dir",
+    dest="cache_dir",
+    default=USER_CACHE_DIR,
+    metavar="dir",
+    type='path',
+    help="Store the cache data in <dir>."
+)  # type: Callable[..., Option]
+
+
+def _handle_no_cache_dir(option, opt, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    """
+    Process a value provided for the --no-cache-dir option.
+
+    This is an optparse.Option callback for the --no-cache-dir option.
+    """
+    # The value argument will be None if --no-cache-dir is passed via the
+    # command-line, since the option doesn't accept arguments.  However,
+    # the value can be non-None if the option is triggered e.g. by an
+    # environment variable, like PIP_NO_CACHE_DIR=true.
+    if value is not None:
+        # Then parse the string value to get argument error-checking.
+        try:
+            strtobool(value)
+        except ValueError as exc:
+            raise_option_error(parser, option=option, msg=str(exc))
+
+    # Originally, setting PIP_NO_CACHE_DIR to a value that strtobool()
+    # converted to 0 (like "false" or "no") caused cache_dir to be disabled
+    # rather than enabled (logic would say the latter).  Thus, we disable
+    # the cache directory not just on values that parse to True, but (for
+    # backwards compatibility reasons) also on values that parse to False.
+    # In other words, always set it to False if the option is provided in
+    # some (valid) form.
+    parser.values.cache_dir = False
+
+
+no_cache = partial(
+    Option,
+    "--no-cache-dir",
+    dest="cache_dir",
+    action="callback",
+    callback=_handle_no_cache_dir,
+    help="Disable the cache.",
+)  # type: Callable[..., Option]
+
+no_deps = partial(
+    Option,
+    '--no-deps', '--no-dependencies',
+    dest='ignore_dependencies',
+    action='store_true',
+    default=False,
+    help="Don't install package dependencies.",
+)  # type: Callable[..., Option]
+
+
+def _handle_build_dir(option, opt, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    if value:
+        value = os.path.abspath(value)
+    setattr(parser.values, option.dest, value)
+
+
+build_dir = partial(
+    PipOption,
+    '-b', '--build', '--build-dir', '--build-directory',
+    dest='build_dir',
+    type='path',
+    metavar='dir',
+    action='callback',
+    callback=_handle_build_dir,
+    help='(DEPRECATED) '
+         'Directory to unpack packages into and build in. Note that '
+         'an initial build still takes place in a temporary directory. '
+         'The location of temporary directories can be controlled by setting '
+         'the TMPDIR environment variable (TEMP on Windows) appropriately. '
+         'When passed, build directories are not cleaned in case of failures.'
+)  # type: Callable[..., Option]
+
+ignore_requires_python = partial(
+    Option,
+    '--ignore-requires-python',
+    dest='ignore_requires_python',
+    action='store_true',
+    help='Ignore the Requires-Python information.'
+)  # type: Callable[..., Option]
+
+no_build_isolation = partial(
+    Option,
+    '--no-build-isolation',
+    dest='build_isolation',
+    action='store_false',
+    default=True,
+    help='Disable isolation when building a modern source distribution. '
+         'Build dependencies specified by PEP 518 must be already installed '
+         'if this option is used.'
+)  # type: Callable[..., Option]
+
+
+def _handle_no_use_pep517(option, opt, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    """
+    Process a value provided for the --no-use-pep517 option.
+
+    This is an optparse.Option callback for the no_use_pep517 option.
+    """
+    # Since --no-use-pep517 doesn't accept arguments, the value argument
+    # will be None if --no-use-pep517 is passed via the command-line.
+    # However, the value can be non-None if the option is triggered e.g.
+    # by an environment variable, for example "PIP_NO_USE_PEP517=true".
+    if value is not None:
+        msg = """A value was passed for --no-use-pep517,
+        probably using either the PIP_NO_USE_PEP517 environment variable
+        or the "no-use-pep517" config file option. Use an appropriate value
+        of the PIP_USE_PEP517 environment variable or the "use-pep517"
+        config file option instead.
+        """
+        raise_option_error(parser, option=option, msg=msg)
+
+    # Otherwise, --no-use-pep517 was passed via the command-line.
+    parser.values.use_pep517 = False
+
+
+use_pep517 = partial(
+    Option,
+    '--use-pep517',
+    dest='use_pep517',
+    action='store_true',
+    default=None,
+    help='Use PEP 517 for building source distributions '
+         '(use --no-use-pep517 to force legacy behaviour).'
+)  # type: Any
+
+no_use_pep517 = partial(
+    Option,
+    '--no-use-pep517',
+    dest='use_pep517',
+    action='callback',
+    callback=_handle_no_use_pep517,
+    default=None,
+    help=SUPPRESS_HELP
+)  # type: Any
+
+install_options = partial(
+    Option,
+    '--install-option',
+    dest='install_options',
+    action='append',
+    metavar='options',
+    help="Extra arguments to be supplied to the setup.py install "
+         "command (use like --install-option=\"--install-scripts=/usr/local/"
+         "bin\"). Use multiple --install-option options to pass multiple "
+         "options to setup.py install. If you are using an option with a "
+         "directory path, be sure to use absolute path.",
+)  # type: Callable[..., Option]
+
+global_options = partial(
+    Option,
+    '--global-option',
+    dest='global_options',
+    action='append',
+    metavar='options',
+    help="Extra global options to be supplied to the setup.py "
+         "call before the install command.",
+)  # type: Callable[..., Option]
+
+no_clean = partial(
+    Option,
+    '--no-clean',
+    action='store_true',
+    default=False,
+    help="Don't clean up build directories."
+)  # type: Callable[..., Option]
+
+pre = partial(
+    Option,
+    '--pre',
+    action='store_true',
+    default=False,
+    help="Include pre-release and development versions. By default, "
+         "pip only finds stable versions.",
+)  # type: Callable[..., Option]
+
+disable_pip_version_check = partial(
+    Option,
+    "--disable-pip-version-check",
+    dest="disable_pip_version_check",
+    action="store_true",
+    default=False,
+    help="Don't periodically check PyPI to determine whether a new version "
+         "of pip is available for download. Implied with --no-index.",
+)  # type: Callable[..., Option]
+
+
+def _handle_merge_hash(option, opt_str, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    """Given a value spelled "algo:digest", append the digest to a list
+    pointed to in a dict by the algo name."""
+    if not parser.values.hashes:
+        parser.values.hashes = {}
+    try:
+        algo, digest = value.split(':', 1)
+    except ValueError:
+        parser.error('Arguments to {} must be a hash name '  # noqa
+                     'followed by a value, like --hash=sha256:'
+                     'abcde...'.format(opt_str))
+    if algo not in STRONG_HASHES:
+        parser.error('Allowed hash algorithms for {} are {}.'.format(  # noqa
+                     opt_str, ', '.join(STRONG_HASHES)))
+    parser.values.hashes.setdefault(algo, []).append(digest)
+
+
+hash = partial(
+    Option,
+    '--hash',
+    # Hash values eventually end up in InstallRequirement.hashes due to
+    # __dict__ copying in process_line().
+    dest='hashes',
+    action='callback',
+    callback=_handle_merge_hash,
+    type='string',
+    help="Verify that the package's archive matches this "
+         'hash before installing. Example: --hash=sha256:abcdef...',
+)  # type: Callable[..., Option]
+
+
+require_hashes = partial(
+    Option,
+    '--require-hashes',
+    dest='require_hashes',
+    action='store_true',
+    default=False,
+    help='Require a hash to check each requirement against, for '
+         'repeatable installs. This option is implied when any package in a '
+         'requirements file has a --hash option.',
+)  # type: Callable[..., Option]
+
+
+list_path = partial(
+    PipOption,
+    '--path',
+    dest='path',
+    type='path',
+    action='append',
+    help='Restrict to the specified installation path for listing '
+         'packages (can be used multiple times).'
+)  # type: Callable[..., Option]
+
+
+def check_list_path_option(options):
+    # type: (Values) -> None
+    if options.path and (options.user or options.local):
+        raise CommandError(
+            "Cannot combine '--path' with '--user' or '--local'"
+        )
+
+
+no_python_version_warning = partial(
+    Option,
+    '--no-python-version-warning',
+    dest='no_python_version_warning',
+    action='store_true',
+    default=False,
+    help='Silence deprecation warnings for upcoming unsupported Pythons.',
+)  # type: Callable[..., Option]
+
+
+unstable_feature = partial(
+    Option,
+    '--unstable-feature',
+    dest='unstable_features',
+    metavar='feature',
+    action='append',
+    default=[],
+    choices=['resolver'],
+    help=SUPPRESS_HELP,  # TODO: drop this in pip 20.3
+)  # type: Callable[..., Option]
+
+use_new_feature = partial(
+    Option,
+    '--use-feature',
+    dest='features_enabled',
+    metavar='feature',
+    action='append',
+    default=[],
+    choices=['2020-resolver', 'fast-deps'],
+    help='Enable new functionality, that may be backward incompatible.',
+)  # type: Callable[..., Option]
+
+use_deprecated_feature = partial(
+    Option,
+    '--use-deprecated',
+    dest='deprecated_features_enabled',
+    metavar='feature',
+    action='append',
+    default=[],
+    choices=[],
+    help=(
+        'Enable deprecated functionality, that will be removed in the future.'
+    ),
+)  # type: Callable[..., Option]
+
+
+##########
+# groups #
+##########
+
+general_group = {
+    'name': 'General Options',
+    'options': [
+        help_,
+        isolated_mode,
+        require_virtualenv,
+        verbose,
+        version,
+        quiet,
+        log,
+        no_input,
+        proxy,
+        retries,
+        timeout,
+        exists_action,
+        trusted_host,
+        cert,
+        client_cert,
+        cache_dir,
+        no_cache,
+        disable_pip_version_check,
+        no_color,
+        no_python_version_warning,
+        unstable_feature,
+        use_new_feature,
+        use_deprecated_feature,
+    ]
+}  # type: Dict[str, Any]
+
+index_group = {
+    'name': 'Package Index Options',
+    'options': [
+        index_url,
+        extra_index_url,
+        no_index,
+        find_links,
+    ]
+}  # type: Dict[str, Any]
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/command_context.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/command_context.py
new file mode 100644
index 0000000..d1a64a7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/command_context.py
@@ -0,0 +1,36 @@
+from contextlib import contextmanager
+
+from pip._vendor.contextlib2 import ExitStack
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Iterator, ContextManager, TypeVar
+
+    _T = TypeVar('_T', covariant=True)
+
+
+class CommandContextMixIn(object):
+    def __init__(self):
+        # type: () -> None
+        super(CommandContextMixIn, self).__init__()
+        self._in_main_context = False
+        self._main_context = ExitStack()
+
+    @contextmanager
+    def main_context(self):
+        # type: () -> Iterator[None]
+        assert not self._in_main_context
+
+        self._in_main_context = True
+        try:
+            with self._main_context:
+                yield
+        finally:
+            self._in_main_context = False
+
+    def enter_context(self, context_provider):
+        # type: (ContextManager[_T]) -> _T
+        assert self._in_main_context
+
+        return self._main_context.enter_context(context_provider)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/main.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/main.py
new file mode 100644
index 0000000..172f30d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/main.py
@@ -0,0 +1,75 @@
+"""Primary application entrypoint.
+"""
+from __future__ import absolute_import
+
+import locale
+import logging
+import os
+import sys
+
+from pip._internal.cli.autocompletion import autocomplete
+from pip._internal.cli.main_parser import parse_command
+from pip._internal.commands import create_command
+from pip._internal.exceptions import PipError
+from pip._internal.utils import deprecation
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+# Do not import and use main() directly! Using it directly is actively
+# discouraged by pip's maintainers. The name, location and behavior of
+# this function is subject to change, so calling it directly is not
+# portable across different pip versions.
+
+# In addition, running pip in-process is unsupported and unsafe. This is
+# elaborated in detail at
+# https://pip.pypa.io/en/stable/user_guide/#using-pip-from-your-program.
+# That document also provides suggestions that should work for nearly
+# all users that are considering importing and using main() directly.
+
+# However, we know that certain users will still want to invoke pip
+# in-process. If you understand and accept the implications of using pip
+# in an unsupported manner, the best approach is to use runpy to avoid
+# depending on the exact location of this entry point.
+
+# The following example shows how to use runpy to invoke pip in that
+# case:
+#
+#     sys.argv = ["pip", your, args, here]
+#     runpy.run_module("pip", run_name="__main__")
+#
+# Note that this will exit the process after running, unlike a direct
+# call to main. As it is not safe to do any processing after calling
+# main, this should not be an issue in practice.
+
+def main(args=None):
+    # type: (Optional[List[str]]) -> int
+    if args is None:
+        args = sys.argv[1:]
+
+    # Configure our deprecation warnings to be sent through loggers
+    deprecation.install_warning_logger()
+
+    autocomplete()
+
+    try:
+        cmd_name, cmd_args = parse_command(args)
+    except PipError as exc:
+        sys.stderr.write("ERROR: {}".format(exc))
+        sys.stderr.write(os.linesep)
+        sys.exit(1)
+
+    # Needed for locale.getpreferredencoding(False) to work
+    # in pip._internal.utils.encoding.auto_decode
+    try:
+        locale.setlocale(locale.LC_ALL, '')
+    except locale.Error as e:
+        # setlocale can apparently crash if locale are uninitialized
+        logger.debug("Ignoring error %s when setting locale", e)
+    command = create_command(cmd_name, isolated=("--isolated" in cmd_args))
+
+    return command.main(cmd_args)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/main_parser.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/main_parser.py
new file mode 100644
index 0000000..08c82c1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/main_parser.py
@@ -0,0 +1,99 @@
+"""A single place for constructing and exposing the main parser
+"""
+
+import os
+import sys
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.parser import (
+    ConfigOptionParser,
+    UpdatingDefaultsHelpFormatter,
+)
+from pip._internal.commands import commands_dict, get_similar_commands
+from pip._internal.exceptions import CommandError
+from pip._internal.utils.misc import get_pip_version, get_prog
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Tuple, List
+
+
+__all__ = ["create_main_parser", "parse_command"]
+
+
+def create_main_parser():
+    # type: () -> ConfigOptionParser
+    """Creates and returns the main parser for pip's CLI
+    """
+
+    parser_kw = {
+        'usage': '\n%prog <command> [options]',
+        'add_help_option': False,
+        'formatter': UpdatingDefaultsHelpFormatter(),
+        'name': 'global',
+        'prog': get_prog(),
+    }
+
+    parser = ConfigOptionParser(**parser_kw)
+    parser.disable_interspersed_args()
+
+    parser.version = get_pip_version()
+
+    # add the general options
+    gen_opts = cmdoptions.make_option_group(cmdoptions.general_group, parser)
+    parser.add_option_group(gen_opts)
+
+    # so the help formatter knows
+    parser.main = True  # type: ignore
+
+    # create command listing for description
+    description = [''] + [
+        '{name:27} {command_info.summary}'.format(**locals())
+        for name, command_info in commands_dict.items()
+    ]
+    parser.description = '\n'.join(description)
+
+    return parser
+
+
+def parse_command(args):
+    # type: (List[str]) -> Tuple[str, List[str]]
+    parser = create_main_parser()
+
+    # Note: parser calls disable_interspersed_args(), so the result of this
+    # call is to split the initial args into the general options before the
+    # subcommand and everything else.
+    # For example:
+    #  args: ['--timeout=5', 'install', '--user', 'INITools']
+    #  general_options: ['--timeout==5']
+    #  args_else: ['install', '--user', 'INITools']
+    general_options, args_else = parser.parse_args(args)
+
+    # --version
+    if general_options.version:
+        sys.stdout.write(parser.version)  # type: ignore
+        sys.stdout.write(os.linesep)
+        sys.exit()
+
+    # pip || pip help -> print_help()
+    if not args_else or (args_else[0] == 'help' and len(args_else) == 1):
+        parser.print_help()
+        sys.exit()
+
+    # the subcommand name
+    cmd_name = args_else[0]
+
+    if cmd_name not in commands_dict:
+        guess = get_similar_commands(cmd_name)
+
+        msg = ['unknown command "{}"'.format(cmd_name)]
+        if guess:
+            msg.append('maybe you meant "{}"'.format(guess))
+
+        raise CommandError(' - '.join(msg))
+
+    # all the args without the subcommand
+    cmd_args = args[:]
+    cmd_args.remove(cmd_name)
+
+    return cmd_name, cmd_args
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/parser.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/parser.py
new file mode 100644
index 0000000..04e00b7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/parser.py
@@ -0,0 +1,266 @@
+"""Base option parser setup"""
+
+# The following comment should be removed at some point in the future.
+# mypy: disallow-untyped-defs=False
+
+from __future__ import absolute_import
+
+import logging
+import optparse
+import sys
+import textwrap
+from distutils.util import strtobool
+
+from pip._vendor.six import string_types
+
+from pip._internal.cli.status_codes import UNKNOWN_ERROR
+from pip._internal.configuration import Configuration, ConfigurationError
+from pip._internal.utils.compat import get_terminal_size
+
+logger = logging.getLogger(__name__)
+
+
+class PrettyHelpFormatter(optparse.IndentedHelpFormatter):
+    """A prettier/less verbose help formatter for optparse."""
+
+    def __init__(self, *args, **kwargs):
+        # help position must be aligned with __init__.parseopts.description
+        kwargs['max_help_position'] = 30
+        kwargs['indent_increment'] = 1
+        kwargs['width'] = get_terminal_size()[0] - 2
+        optparse.IndentedHelpFormatter.__init__(self, *args, **kwargs)
+
+    def format_option_strings(self, option):
+        return self._format_option_strings(option)
+
+    def _format_option_strings(self, option, mvarfmt=' <{}>', optsep=', '):
+        """
+        Return a comma-separated list of option strings and metavars.
+
+        :param option:  tuple of (short opt, long opt), e.g: ('-f', '--format')
+        :param mvarfmt: metavar format string
+        :param optsep:  separator
+        """
+        opts = []
+
+        if option._short_opts:
+            opts.append(option._short_opts[0])
+        if option._long_opts:
+            opts.append(option._long_opts[0])
+        if len(opts) > 1:
+            opts.insert(1, optsep)
+
+        if option.takes_value():
+            metavar = option.metavar or option.dest.lower()
+            opts.append(mvarfmt.format(metavar.lower()))
+
+        return ''.join(opts)
+
+    def format_heading(self, heading):
+        if heading == 'Options':
+            return ''
+        return heading + ':\n'
+
+    def format_usage(self, usage):
+        """
+        Ensure there is only one newline between usage and the first heading
+        if there is no description.
+        """
+        msg = '\nUsage: {}\n'.format(
+            self.indent_lines(textwrap.dedent(usage), "  "))
+        return msg
+
+    def format_description(self, description):
+        # leave full control over description to us
+        if description:
+            if hasattr(self.parser, 'main'):
+                label = 'Commands'
+            else:
+                label = 'Description'
+            # some doc strings have initial newlines, some don't
+            description = description.lstrip('\n')
+            # some doc strings have final newlines and spaces, some don't
+            description = description.rstrip()
+            # dedent, then reindent
+            description = self.indent_lines(textwrap.dedent(description), "  ")
+            description = '{}:\n{}\n'.format(label, description)
+            return description
+        else:
+            return ''
+
+    def format_epilog(self, epilog):
+        # leave full control over epilog to us
+        if epilog:
+            return epilog
+        else:
+            return ''
+
+    def indent_lines(self, text, indent):
+        new_lines = [indent + line for line in text.split('\n')]
+        return "\n".join(new_lines)
+
+
+class UpdatingDefaultsHelpFormatter(PrettyHelpFormatter):
+    """Custom help formatter for use in ConfigOptionParser.
+
+    This is updates the defaults before expanding them, allowing
+    them to show up correctly in the help listing.
+    """
+
+    def expand_default(self, option):
+        if self.parser is not None:
+            self.parser._update_defaults(self.parser.defaults)
+        return optparse.IndentedHelpFormatter.expand_default(self, option)
+
+
+class CustomOptionParser(optparse.OptionParser):
+
+    def insert_option_group(self, idx, *args, **kwargs):
+        """Insert an OptionGroup at a given position."""
+        group = self.add_option_group(*args, **kwargs)
+
+        self.option_groups.pop()
+        self.option_groups.insert(idx, group)
+
+        return group
+
+    @property
+    def option_list_all(self):
+        """Get a list of all options, including those in option groups."""
+        res = self.option_list[:]
+        for i in self.option_groups:
+            res.extend(i.option_list)
+
+        return res
+
+
+class ConfigOptionParser(CustomOptionParser):
+    """Custom option parser which updates its defaults by checking the
+    configuration files and environmental variables"""
+
+    def __init__(self, *args, **kwargs):
+        self.name = kwargs.pop('name')
+
+        isolated = kwargs.pop("isolated", False)
+        self.config = Configuration(isolated)
+
+        assert self.name
+        optparse.OptionParser.__init__(self, *args, **kwargs)
+
+    def check_default(self, option, key, val):
+        try:
+            return option.check_value(key, val)
+        except optparse.OptionValueError as exc:
+            print("An error occurred during configuration: {}".format(exc))
+            sys.exit(3)
+
+    def _get_ordered_configuration_items(self):
+        # Configuration gives keys in an unordered manner. Order them.
+        override_order = ["global", self.name, ":env:"]
+
+        # Pool the options into different groups
+        section_items = {name: [] for name in override_order}
+        for section_key, val in self.config.items():
+            # ignore empty values
+            if not val:
+                logger.debug(
+                    "Ignoring configuration key '%s' as it's value is empty.",
+                    section_key
+                )
+                continue
+
+            section, key = section_key.split(".", 1)
+            if section in override_order:
+                section_items[section].append((key, val))
+
+        # Yield each group in their override order
+        for section in override_order:
+            for key, val in section_items[section]:
+                yield key, val
+
+    def _update_defaults(self, defaults):
+        """Updates the given defaults with values from the config files and
+        the environ. Does a little special handling for certain types of
+        options (lists)."""
+
+        # Accumulate complex default state.
+        self.values = optparse.Values(self.defaults)
+        late_eval = set()
+        # Then set the options with those values
+        for key, val in self._get_ordered_configuration_items():
+            # '--' because configuration supports only long names
+            option = self.get_option('--' + key)
+
+            # Ignore options not present in this parser. E.g. non-globals put
+            # in [global] by users that want them to apply to all applicable
+            # commands.
+            if option is None:
+                continue
+
+            if option.action in ('store_true', 'store_false', 'count'):
+                try:
+                    val = strtobool(val)
+                except ValueError:
+                    error_msg = invalid_config_error_message(
+                        option.action, key, val
+                    )
+                    self.error(error_msg)
+
+            elif option.action == 'append':
+                val = val.split()
+                val = [self.check_default(option, key, v) for v in val]
+            elif option.action == 'callback':
+                late_eval.add(option.dest)
+                opt_str = option.get_opt_string()
+                val = option.convert_value(opt_str, val)
+                # From take_action
+                args = option.callback_args or ()
+                kwargs = option.callback_kwargs or {}
+                option.callback(option, opt_str, val, self, *args, **kwargs)
+            else:
+                val = self.check_default(option, key, val)
+
+            defaults[option.dest] = val
+
+        for key in late_eval:
+            defaults[key] = getattr(self.values, key)
+        self.values = None
+        return defaults
+
+    def get_default_values(self):
+        """Overriding to make updating the defaults after instantiation of
+        the option parser possible, _update_defaults() does the dirty work."""
+        if not self.process_default_values:
+            # Old, pre-Optik 1.5 behaviour.
+            return optparse.Values(self.defaults)
+
+        # Load the configuration, or error out in case of an error
+        try:
+            self.config.load()
+        except ConfigurationError as err:
+            self.exit(UNKNOWN_ERROR, str(err))
+
+        defaults = self._update_defaults(self.defaults.copy())  # ours
+        for option in self._get_all_options():
+            default = defaults.get(option.dest)
+            if isinstance(default, string_types):
+                opt_str = option.get_opt_string()
+                defaults[option.dest] = option.check_value(opt_str, default)
+        return optparse.Values(defaults)
+
+    def error(self, msg):
+        self.print_usage(sys.stderr)
+        self.exit(UNKNOWN_ERROR, "{}\n".format(msg))
+
+
+def invalid_config_error_message(action, key, val):
+    """Returns a better error message when invalid configuration option
+    is provided."""
+    if action in ('store_true', 'store_false'):
+        return ("{0} is not a valid value for {1} option, "
+                "please specify a boolean value like yes/no, "
+                "true/false or 1/0 instead.").format(val, key)
+
+    return ("{0} is not a valid value for {1} option, "
+            "please specify a numerical value like 1/0 "
+            "instead.").format(val, key)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/progress_bars.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/progress_bars.py
new file mode 100644
index 0000000..6933855
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/progress_bars.py
@@ -0,0 +1,280 @@
+from __future__ import division
+
+import itertools
+import sys
+from signal import SIGINT, default_int_handler, signal
+
+from pip._vendor import six
+from pip._vendor.progress.bar import Bar, FillingCirclesBar, IncrementalBar
+from pip._vendor.progress.spinner import Spinner
+
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.logging import get_indentation
+from pip._internal.utils.misc import format_size
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any, Dict, List
+
+try:
+    from pip._vendor import colorama
+# Lots of different errors can come from this, including SystemError and
+# ImportError.
+except Exception:
+    colorama = None
+
+
+def _select_progress_class(preferred, fallback):
+    # type: (Bar, Bar) -> Bar
+    encoding = getattr(preferred.file, "encoding", None)
+
+    # If we don't know what encoding this file is in, then we'll just assume
+    # that it doesn't support unicode and use the ASCII bar.
+    if not encoding:
+        return fallback
+
+    # Collect all of the possible characters we want to use with the preferred
+    # bar.
+    characters = [
+        getattr(preferred, "empty_fill", six.text_type()),
+        getattr(preferred, "fill", six.text_type()),
+    ]
+    characters += list(getattr(preferred, "phases", []))
+
+    # Try to decode the characters we're using for the bar using the encoding
+    # of the given file, if this works then we'll assume that we can use the
+    # fancier bar and if not we'll fall back to the plaintext bar.
+    try:
+        six.text_type().join(characters).encode(encoding)
+    except UnicodeEncodeError:
+        return fallback
+    else:
+        return preferred
+
+
+_BaseBar = _select_progress_class(IncrementalBar, Bar)  # type: Any
+
+
+class InterruptibleMixin(object):
+    """
+    Helper to ensure that self.finish() gets called on keyboard interrupt.
+
+    This allows downloads to be interrupted without leaving temporary state
+    (like hidden cursors) behind.
+
+    This class is similar to the progress library's existing SigIntMixin
+    helper, but as of version 1.2, that helper has the following problems:
+
+    1. It calls sys.exit().
+    2. It discards the existing SIGINT handler completely.
+    3. It leaves its own handler in place even after an uninterrupted finish,
+       which will have unexpected delayed effects if the user triggers an
+       unrelated keyboard interrupt some time after a progress-displaying
+       download has already completed, for example.
+    """
+
+    def __init__(self, *args, **kwargs):
+        # type: (List[Any], Dict[Any, Any]) -> None
+        """
+        Save the original SIGINT handler for later.
+        """
+        # https://github.com/python/mypy/issues/5887
+        super(InterruptibleMixin, self).__init__(  # type: ignore
+            *args,
+            **kwargs
+        )
+
+        self.original_handler = signal(SIGINT, self.handle_sigint)
+
+        # If signal() returns None, the previous handler was not installed from
+        # Python, and we cannot restore it. This probably should not happen,
+        # but if it does, we must restore something sensible instead, at least.
+        # The least bad option should be Python's default SIGINT handler, which
+        # just raises KeyboardInterrupt.
+        if self.original_handler is None:
+            self.original_handler = default_int_handler
+
+    def finish(self):
+        # type: () -> None
+        """
+        Restore the original SIGINT handler after finishing.
+
+        This should happen regardless of whether the progress display finishes
+        normally, or gets interrupted.
+        """
+        super(InterruptibleMixin, self).finish()  # type: ignore
+        signal(SIGINT, self.original_handler)
+
+    def handle_sigint(self, signum, frame):  # type: ignore
+        """
+        Call self.finish() before delegating to the original SIGINT handler.
+
+        This handler should only be in place while the progress display is
+        active.
+        """
+        self.finish()
+        self.original_handler(signum, frame)
+
+
+class SilentBar(Bar):
+
+    def update(self):
+        # type: () -> None
+        pass
+
+
+class BlueEmojiBar(IncrementalBar):
+
+    suffix = "%(percent)d%%"
+    bar_prefix = " "
+    bar_suffix = " "
+    phases = (u"\U0001F539", u"\U0001F537", u"\U0001F535")  # type: Any
+
+
+class DownloadProgressMixin(object):
+
+    def __init__(self, *args, **kwargs):
+        # type: (List[Any], Dict[Any, Any]) -> None
+        # https://github.com/python/mypy/issues/5887
+        super(DownloadProgressMixin, self).__init__(  # type: ignore
+            *args,
+            **kwargs
+        )
+        self.message = (" " * (
+            get_indentation() + 2
+        )) + self.message  # type: str
+
+    @property
+    def downloaded(self):
+        # type: () -> str
+        return format_size(self.index)  # type: ignore
+
+    @property
+    def download_speed(self):
+        # type: () -> str
+        # Avoid zero division errors...
+        if self.avg == 0.0:  # type: ignore
+            return "..."
+        return format_size(1 / self.avg) + "/s"  # type: ignore
+
+    @property
+    def pretty_eta(self):
+        # type: () -> str
+        if self.eta:  # type: ignore
+            return "eta {}".format(self.eta_td)  # type: ignore
+        return ""
+
+    def iter(self, it):  # type: ignore
+        for x in it:
+            yield x
+            # B305 is incorrectly raised here
+            # https://github.com/PyCQA/flake8-bugbear/issues/59
+            self.next(len(x))  # noqa: B305
+        self.finish()
+
+
+class WindowsMixin(object):
+
+    def __init__(self, *args, **kwargs):
+        # type: (List[Any], Dict[Any, Any]) -> None
+        # The Windows terminal does not support the hide/show cursor ANSI codes
+        # even with colorama. So we'll ensure that hide_cursor is False on
+        # Windows.
+        # This call needs to go before the super() call, so that hide_cursor
+        # is set in time. The base progress bar class writes the "hide cursor"
+        # code to the terminal in its init, so if we don't set this soon
+        # enough, we get a "hide" with no corresponding "show"...
+        if WINDOWS and self.hide_cursor:  # type: ignore
+            self.hide_cursor = False
+
+        # https://github.com/python/mypy/issues/5887
+        super(WindowsMixin, self).__init__(*args, **kwargs)  # type: ignore
+
+        # Check if we are running on Windows and we have the colorama module,
+        # if we do then wrap our file with it.
+        if WINDOWS and colorama:
+            self.file = colorama.AnsiToWin32(self.file)  # type: ignore
+            # The progress code expects to be able to call self.file.isatty()
+            # but the colorama.AnsiToWin32() object doesn't have that, so we'll
+            # add it.
+            self.file.isatty = lambda: self.file.wrapped.isatty()
+            # The progress code expects to be able to call self.file.flush()
+            # but the colorama.AnsiToWin32() object doesn't have that, so we'll
+            # add it.
+            self.file.flush = lambda: self.file.wrapped.flush()
+
+
+class BaseDownloadProgressBar(WindowsMixin, InterruptibleMixin,
+                              DownloadProgressMixin):
+
+    file = sys.stdout
+    message = "%(percent)d%%"
+    suffix = "%(downloaded)s %(download_speed)s %(pretty_eta)s"
+
+
+class DefaultDownloadProgressBar(BaseDownloadProgressBar,
+                                 _BaseBar):
+    pass
+
+
+class DownloadSilentBar(BaseDownloadProgressBar, SilentBar):
+    pass
+
+
+class DownloadBar(BaseDownloadProgressBar,
+                  Bar):
+    pass
+
+
+class DownloadFillingCirclesBar(BaseDownloadProgressBar,
+                                FillingCirclesBar):
+    pass
+
+
+class DownloadBlueEmojiProgressBar(BaseDownloadProgressBar,
+                                   BlueEmojiBar):
+    pass
+
+
+class DownloadProgressSpinner(WindowsMixin, InterruptibleMixin,
+                              DownloadProgressMixin, Spinner):
+
+    file = sys.stdout
+    suffix = "%(downloaded)s %(download_speed)s"
+
+    def next_phase(self):
+        # type: () -> str
+        if not hasattr(self, "_phaser"):
+            self._phaser = itertools.cycle(self.phases)
+        return next(self._phaser)
+
+    def update(self):
+        # type: () -> None
+        message = self.message % self
+        phase = self.next_phase()
+        suffix = self.suffix % self
+        line = ''.join([
+            message,
+            " " if message else "",
+            phase,
+            " " if suffix else "",
+            suffix,
+        ])
+
+        self.writeln(line)
+
+
+BAR_TYPES = {
+    "off": (DownloadSilentBar, DownloadSilentBar),
+    "on": (DefaultDownloadProgressBar, DownloadProgressSpinner),
+    "ascii": (DownloadBar, DownloadProgressSpinner),
+    "pretty": (DownloadFillingCirclesBar, DownloadProgressSpinner),
+    "emoji": (DownloadBlueEmojiProgressBar, DownloadProgressSpinner)
+}
+
+
+def DownloadProgressProvider(progress_bar, max=None):  # type: ignore
+    if max is None or max == 0:
+        return BAR_TYPES[progress_bar][1]().iter
+    else:
+        return BAR_TYPES[progress_bar][0](max=max).iter
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/req_command.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/req_command.py
new file mode 100644
index 0000000..78b5ce6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/req_command.py
@@ -0,0 +1,402 @@
+"""Contains the Command base classes that depend on PipSession.
+
+The classes in this module are in a separate module so the commands not
+needing download / PackageFinder capability don't unnecessarily import the
+PackageFinder machinery and all its vendored dependencies, etc.
+"""
+
+import logging
+import os
+from functools import partial
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.command_context import CommandContextMixIn
+from pip._internal.exceptions import CommandError, PreviousBuildDirError
+from pip._internal.index.collector import LinkCollector
+from pip._internal.index.package_finder import PackageFinder
+from pip._internal.models.selection_prefs import SelectionPreferences
+from pip._internal.network.download import Downloader
+from pip._internal.network.session import PipSession
+from pip._internal.operations.prepare import RequirementPreparer
+from pip._internal.req.constructors import (
+    install_req_from_editable,
+    install_req_from_line,
+    install_req_from_parsed_requirement,
+    install_req_from_req_string,
+)
+from pip._internal.req.req_file import parse_requirements
+from pip._internal.self_outdated_check import pip_self_version_check
+from pip._internal.utils.temp_dir import tempdir_kinds
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import Any, List, Optional, Tuple
+
+    from pip._internal.cache import WheelCache
+    from pip._internal.models.target_python import TargetPython
+    from pip._internal.req.req_install import InstallRequirement
+    from pip._internal.req.req_tracker import RequirementTracker
+    from pip._internal.resolution.base import BaseResolver
+    from pip._internal.utils.temp_dir import (
+        TempDirectory,
+        TempDirectoryTypeRegistry,
+    )
+
+
+logger = logging.getLogger(__name__)
+
+
+class SessionCommandMixin(CommandContextMixIn):
+
+    """
+    A class mixin for command classes needing _build_session().
+    """
+    def __init__(self):
+        # type: () -> None
+        super(SessionCommandMixin, self).__init__()
+        self._session = None  # Optional[PipSession]
+
+    @classmethod
+    def _get_index_urls(cls, options):
+        # type: (Values) -> Optional[List[str]]
+        """Return a list of index urls from user-provided options."""
+        index_urls = []
+        if not getattr(options, "no_index", False):
+            url = getattr(options, "index_url", None)
+            if url:
+                index_urls.append(url)
+        urls = getattr(options, "extra_index_urls", None)
+        if urls:
+            index_urls.extend(urls)
+        # Return None rather than an empty list
+        return index_urls or None
+
+    def get_default_session(self, options):
+        # type: (Values) -> PipSession
+        """Get a default-managed session."""
+        if self._session is None:
+            self._session = self.enter_context(self._build_session(options))
+            # there's no type annotation on requests.Session, so it's
+            # automatically ContextManager[Any] and self._session becomes Any,
+            # then https://github.com/python/mypy/issues/7696 kicks in
+            assert self._session is not None
+        return self._session
+
+    def _build_session(self, options, retries=None, timeout=None):
+        # type: (Values, Optional[int], Optional[int]) -> PipSession
+        assert not options.cache_dir or os.path.isabs(options.cache_dir)
+        session = PipSession(
+            cache=(
+                os.path.join(options.cache_dir, "http")
+                if options.cache_dir else None
+            ),
+            retries=retries if retries is not None else options.retries,
+            trusted_hosts=options.trusted_hosts,
+            index_urls=self._get_index_urls(options),
+        )
+
+        # Handle custom ca-bundles from the user
+        if options.cert:
+            session.verify = options.cert
+
+        # Handle SSL client certificate
+        if options.client_cert:
+            session.cert = options.client_cert
+
+        # Handle timeouts
+        if options.timeout or timeout:
+            session.timeout = (
+                timeout if timeout is not None else options.timeout
+            )
+
+        # Handle configured proxies
+        if options.proxy:
+            session.proxies = {
+                "http": options.proxy,
+                "https": options.proxy,
+            }
+
+        # Determine if we can prompt the user for authentication or not
+        session.auth.prompting = not options.no_input
+
+        return session
+
+
+class IndexGroupCommand(Command, SessionCommandMixin):
+
+    """
+    Abstract base class for commands with the index_group options.
+
+    This also corresponds to the commands that permit the pip version check.
+    """
+
+    def handle_pip_version_check(self, options):
+        # type: (Values) -> None
+        """
+        Do the pip version check if not disabled.
+
+        This overrides the default behavior of not doing the check.
+        """
+        # Make sure the index_group options are present.
+        assert hasattr(options, 'no_index')
+
+        if options.disable_pip_version_check or options.no_index:
+            return
+
+        # Otherwise, check if we're using the latest version of pip available.
+        session = self._build_session(
+            options,
+            retries=0,
+            timeout=min(5, options.timeout)
+        )
+        with session:
+            pip_self_version_check(session, options)
+
+
+KEEPABLE_TEMPDIR_TYPES = [
+    tempdir_kinds.BUILD_ENV,
+    tempdir_kinds.EPHEM_WHEEL_CACHE,
+    tempdir_kinds.REQ_BUILD,
+]
+
+
+def with_cleanup(func):
+    # type: (Any) -> Any
+    """Decorator for common logic related to managing temporary
+    directories.
+    """
+    def configure_tempdir_registry(registry):
+        # type: (TempDirectoryTypeRegistry) -> None
+        for t in KEEPABLE_TEMPDIR_TYPES:
+            registry.set_delete(t, False)
+
+    def wrapper(self, options, args):
+        # type: (RequirementCommand, Values, List[Any]) -> Optional[int]
+        assert self.tempdir_registry is not None
+        if options.no_clean:
+            configure_tempdir_registry(self.tempdir_registry)
+
+        try:
+            return func(self, options, args)
+        except PreviousBuildDirError:
+            # This kind of conflict can occur when the user passes an explicit
+            # build directory with a pre-existing folder. In that case we do
+            # not want to accidentally remove it.
+            configure_tempdir_registry(self.tempdir_registry)
+            raise
+
+    return wrapper
+
+
+class RequirementCommand(IndexGroupCommand):
+
+    def __init__(self, *args, **kw):
+        # type: (Any, Any) -> None
+        super(RequirementCommand, self).__init__(*args, **kw)
+
+        self.cmd_opts.add_option(cmdoptions.no_clean())
+
+    @staticmethod
+    def make_requirement_preparer(
+        temp_build_dir,           # type: TempDirectory
+        options,                  # type: Values
+        req_tracker,              # type: RequirementTracker
+        session,                  # type: PipSession
+        finder,                   # type: PackageFinder
+        use_user_site,            # type: bool
+        download_dir=None,        # type: str
+        wheel_download_dir=None,  # type: str
+    ):
+        # type: (...) -> RequirementPreparer
+        """
+        Create a RequirementPreparer instance for the given parameters.
+        """
+        downloader = Downloader(session, progress_bar=options.progress_bar)
+
+        temp_build_dir_path = temp_build_dir.path
+        assert temp_build_dir_path is not None
+
+        return RequirementPreparer(
+            build_dir=temp_build_dir_path,
+            src_dir=options.src_dir,
+            download_dir=download_dir,
+            wheel_download_dir=wheel_download_dir,
+            build_isolation=options.build_isolation,
+            req_tracker=req_tracker,
+            downloader=downloader,
+            finder=finder,
+            require_hashes=options.require_hashes,
+            use_user_site=use_user_site,
+        )
+
+    @staticmethod
+    def make_resolver(
+        preparer,                            # type: RequirementPreparer
+        finder,                              # type: PackageFinder
+        options,                             # type: Values
+        wheel_cache=None,                    # type: Optional[WheelCache]
+        use_user_site=False,                 # type: bool
+        ignore_installed=True,               # type: bool
+        ignore_requires_python=False,        # type: bool
+        force_reinstall=False,               # type: bool
+        upgrade_strategy="to-satisfy-only",  # type: str
+        use_pep517=None,                     # type: Optional[bool]
+        py_version_info=None            # type: Optional[Tuple[int, ...]]
+    ):
+        # type: (...) -> BaseResolver
+        """
+        Create a Resolver instance for the given parameters.
+        """
+        make_install_req = partial(
+            install_req_from_req_string,
+            isolated=options.isolated_mode,
+            use_pep517=use_pep517,
+        )
+        # The long import name and duplicated invocation is needed to convince
+        # Mypy into correctly typechecking. Otherwise it would complain the
+        # "Resolver" class being redefined.
+        if '2020-resolver' in options.features_enabled:
+            import pip._internal.resolution.resolvelib.resolver
+            return pip._internal.resolution.resolvelib.resolver.Resolver(
+                preparer=preparer,
+                finder=finder,
+                wheel_cache=wheel_cache,
+                make_install_req=make_install_req,
+                use_user_site=use_user_site,
+                ignore_dependencies=options.ignore_dependencies,
+                ignore_installed=ignore_installed,
+                ignore_requires_python=ignore_requires_python,
+                force_reinstall=force_reinstall,
+                upgrade_strategy=upgrade_strategy,
+                py_version_info=py_version_info,
+                lazy_wheel='fast-deps' in options.features_enabled,
+            )
+        import pip._internal.resolution.legacy.resolver
+        return pip._internal.resolution.legacy.resolver.Resolver(
+            preparer=preparer,
+            finder=finder,
+            wheel_cache=wheel_cache,
+            make_install_req=make_install_req,
+            use_user_site=use_user_site,
+            ignore_dependencies=options.ignore_dependencies,
+            ignore_installed=ignore_installed,
+            ignore_requires_python=ignore_requires_python,
+            force_reinstall=force_reinstall,
+            upgrade_strategy=upgrade_strategy,
+            py_version_info=py_version_info,
+        )
+
+    def get_requirements(
+        self,
+        args,             # type: List[str]
+        options,          # type: Values
+        finder,           # type: PackageFinder
+        session,          # type: PipSession
+    ):
+        # type: (...) -> List[InstallRequirement]
+        """
+        Parse command-line arguments into the corresponding requirements.
+        """
+        requirements = []  # type: List[InstallRequirement]
+        for filename in options.constraints:
+            for parsed_req in parse_requirements(
+                    filename,
+                    constraint=True, finder=finder, options=options,
+                    session=session):
+                req_to_add = install_req_from_parsed_requirement(
+                    parsed_req,
+                    isolated=options.isolated_mode,
+                    user_supplied=False,
+                )
+                requirements.append(req_to_add)
+
+        for req in args:
+            req_to_add = install_req_from_line(
+                req, None, isolated=options.isolated_mode,
+                use_pep517=options.use_pep517,
+                user_supplied=True,
+            )
+            requirements.append(req_to_add)
+
+        for req in options.editables:
+            req_to_add = install_req_from_editable(
+                req,
+                user_supplied=True,
+                isolated=options.isolated_mode,
+                use_pep517=options.use_pep517,
+            )
+            requirements.append(req_to_add)
+
+        # NOTE: options.require_hashes may be set if --require-hashes is True
+        for filename in options.requirements:
+            for parsed_req in parse_requirements(
+                    filename,
+                    finder=finder, options=options, session=session):
+                req_to_add = install_req_from_parsed_requirement(
+                    parsed_req,
+                    isolated=options.isolated_mode,
+                    use_pep517=options.use_pep517,
+                    user_supplied=True,
+                )
+                requirements.append(req_to_add)
+
+        # If any requirement has hash options, enable hash checking.
+        if any(req.has_hash_options for req in requirements):
+            options.require_hashes = True
+
+        if not (args or options.editables or options.requirements):
+            opts = {'name': self.name}
+            if options.find_links:
+                raise CommandError(
+                    'You must give at least one requirement to {name} '
+                    '(maybe you meant "pip {name} {links}"?)'.format(
+                        **dict(opts, links=' '.join(options.find_links))))
+            else:
+                raise CommandError(
+                    'You must give at least one requirement to {name} '
+                    '(see "pip help {name}")'.format(**opts))
+
+        return requirements
+
+    @staticmethod
+    def trace_basic_info(finder):
+        # type: (PackageFinder) -> None
+        """
+        Trace basic information about the provided objects.
+        """
+        # Display where finder is looking for packages
+        search_scope = finder.search_scope
+        locations = search_scope.get_formatted_locations()
+        if locations:
+            logger.info(locations)
+
+    def _build_package_finder(
+        self,
+        options,               # type: Values
+        session,               # type: PipSession
+        target_python=None,    # type: Optional[TargetPython]
+        ignore_requires_python=None,  # type: Optional[bool]
+    ):
+        # type: (...) -> PackageFinder
+        """
+        Create a package finder appropriate to this requirement command.
+
+        :param ignore_requires_python: Whether to ignore incompatible
+            "Requires-Python" values in links. Defaults to False.
+        """
+        link_collector = LinkCollector.create(session, options=options)
+        selection_prefs = SelectionPreferences(
+            allow_yanked=True,
+            format_control=options.format_control,
+            allow_all_prereleases=options.pre,
+            prefer_binary=options.prefer_binary,
+            ignore_requires_python=ignore_requires_python,
+        )
+
+        return PackageFinder.create(
+            link_collector=link_collector,
+            selection_prefs=selection_prefs,
+            target_python=target_python,
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/spinners.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/spinners.py
new file mode 100644
index 0000000..c6c4c5c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/spinners.py
@@ -0,0 +1,173 @@
+from __future__ import absolute_import, division
+
+import contextlib
+import itertools
+import logging
+import sys
+import time
+
+from pip._vendor.progress import HIDE_CURSOR, SHOW_CURSOR
+
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.logging import get_indentation
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Iterator, IO
+
+logger = logging.getLogger(__name__)
+
+
+class SpinnerInterface(object):
+    def spin(self):
+        # type: () -> None
+        raise NotImplementedError()
+
+    def finish(self, final_status):
+        # type: (str) -> None
+        raise NotImplementedError()
+
+
+class InteractiveSpinner(SpinnerInterface):
+    def __init__(self, message, file=None, spin_chars="-\\|/",
+                 # Empirically, 8 updates/second looks nice
+                 min_update_interval_seconds=0.125):
+        # type: (str, IO[str], str, float) -> None
+        self._message = message
+        if file is None:
+            file = sys.stdout
+        self._file = file
+        self._rate_limiter = RateLimiter(min_update_interval_seconds)
+        self._finished = False
+
+        self._spin_cycle = itertools.cycle(spin_chars)
+
+        self._file.write(" " * get_indentation() + self._message + " ... ")
+        self._width = 0
+
+    def _write(self, status):
+        # type: (str) -> None
+        assert not self._finished
+        # Erase what we wrote before by backspacing to the beginning, writing
+        # spaces to overwrite the old text, and then backspacing again
+        backup = "\b" * self._width
+        self._file.write(backup + " " * self._width + backup)
+        # Now we have a blank slate to add our status
+        self._file.write(status)
+        self._width = len(status)
+        self._file.flush()
+        self._rate_limiter.reset()
+
+    def spin(self):
+        # type: () -> None
+        if self._finished:
+            return
+        if not self._rate_limiter.ready():
+            return
+        self._write(next(self._spin_cycle))
+
+    def finish(self, final_status):
+        # type: (str) -> None
+        if self._finished:
+            return
+        self._write(final_status)
+        self._file.write("\n")
+        self._file.flush()
+        self._finished = True
+
+
+# Used for dumb terminals, non-interactive installs (no tty), etc.
+# We still print updates occasionally (once every 60 seconds by default) to
+# act as a keep-alive for systems like Travis-CI that take lack-of-output as
+# an indication that a task has frozen.
+class NonInteractiveSpinner(SpinnerInterface):
+    def __init__(self, message, min_update_interval_seconds=60):
+        # type: (str, float) -> None
+        self._message = message
+        self._finished = False
+        self._rate_limiter = RateLimiter(min_update_interval_seconds)
+        self._update("started")
+
+    def _update(self, status):
+        # type: (str) -> None
+        assert not self._finished
+        self._rate_limiter.reset()
+        logger.info("%s: %s", self._message, status)
+
+    def spin(self):
+        # type: () -> None
+        if self._finished:
+            return
+        if not self._rate_limiter.ready():
+            return
+        self._update("still running...")
+
+    def finish(self, final_status):
+        # type: (str) -> None
+        if self._finished:
+            return
+        self._update(
+            "finished with status '{final_status}'".format(**locals()))
+        self._finished = True
+
+
+class RateLimiter(object):
+    def __init__(self, min_update_interval_seconds):
+        # type: (float) -> None
+        self._min_update_interval_seconds = min_update_interval_seconds
+        self._last_update = 0  # type: float
+
+    def ready(self):
+        # type: () -> bool
+        now = time.time()
+        delta = now - self._last_update
+        return delta >= self._min_update_interval_seconds
+
+    def reset(self):
+        # type: () -> None
+        self._last_update = time.time()
+
+
+@contextlib.contextmanager
+def open_spinner(message):
+    # type: (str) -> Iterator[SpinnerInterface]
+    # Interactive spinner goes directly to sys.stdout rather than being routed
+    # through the logging system, but it acts like it has level INFO,
+    # i.e. it's only displayed if we're at level INFO or better.
+    # Non-interactive spinner goes through the logging system, so it is always
+    # in sync with logging configuration.
+    if sys.stdout.isatty() and logger.getEffectiveLevel() <= logging.INFO:
+        spinner = InteractiveSpinner(message)  # type: SpinnerInterface
+    else:
+        spinner = NonInteractiveSpinner(message)
+    try:
+        with hidden_cursor(sys.stdout):
+            yield spinner
+    except KeyboardInterrupt:
+        spinner.finish("canceled")
+        raise
+    except Exception:
+        spinner.finish("error")
+        raise
+    else:
+        spinner.finish("done")
+
+
+@contextlib.contextmanager
+def hidden_cursor(file):
+    # type: (IO[str]) -> Iterator[None]
+    # The Windows terminal does not support the hide/show cursor ANSI codes,
+    # even via colorama. So don't even try.
+    if WINDOWS:
+        yield
+    # We don't want to clutter the output with control characters if we're
+    # writing to a file, or if the user is running with --quiet.
+    # See https://github.com/pypa/pip/issues/3418
+    elif not file.isatty() or logger.getEffectiveLevel() > logging.INFO:
+        yield
+    else:
+        file.write(HIDE_CURSOR)
+        try:
+            yield
+        finally:
+            file.write(SHOW_CURSOR)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/cli/status_codes.py b/myenv/lib/python3.9/site-packages/pip/_internal/cli/status_codes.py
new file mode 100644
index 0000000..275360a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/cli/status_codes.py
@@ -0,0 +1,8 @@
+from __future__ import absolute_import
+
+SUCCESS = 0
+ERROR = 1
+UNKNOWN_ERROR = 2
+VIRTUALENV_NOT_FOUND = 3
+PREVIOUS_BUILD_DIR_ERROR = 4
+NO_MATCHES_FOUND = 23
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/__init__.py
new file mode 100644
index 0000000..6825fa6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/__init__.py
@@ -0,0 +1,122 @@
+"""
+Package containing all pip commands
+"""
+
+# The following comment should be removed at some point in the future.
+# mypy: disallow-untyped-defs=False
+# There is currently a bug in python/typeshed mentioned at
+# https://github.com/python/typeshed/issues/3906 which causes the
+# return type of difflib.get_close_matches to be reported
+# as List[Sequence[str]] whereas it should have been List[str]
+
+from __future__ import absolute_import
+
+import importlib
+from collections import OrderedDict, namedtuple
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any
+    from pip._internal.cli.base_command import Command
+
+
+CommandInfo = namedtuple('CommandInfo', 'module_path, class_name, summary')
+
+# The ordering matters for help display.
+#    Also, even though the module path starts with the same
+# "pip._internal.commands" prefix in each case, we include the full path
+# because it makes testing easier (specifically when modifying commands_dict
+# in test setup / teardown by adding info for a FakeCommand class defined
+# in a test-related module).
+#    Finally, we need to pass an iterable of pairs here rather than a dict
+# so that the ordering won't be lost when using Python 2.7.
+commands_dict = OrderedDict([
+    ('install', CommandInfo(
+        'pip._internal.commands.install', 'InstallCommand',
+        'Install packages.',
+    )),
+    ('download', CommandInfo(
+        'pip._internal.commands.download', 'DownloadCommand',
+        'Download packages.',
+    )),
+    ('uninstall', CommandInfo(
+        'pip._internal.commands.uninstall', 'UninstallCommand',
+        'Uninstall packages.',
+    )),
+    ('freeze', CommandInfo(
+        'pip._internal.commands.freeze', 'FreezeCommand',
+        'Output installed packages in requirements format.',
+    )),
+    ('list', CommandInfo(
+        'pip._internal.commands.list', 'ListCommand',
+        'List installed packages.',
+    )),
+    ('show', CommandInfo(
+        'pip._internal.commands.show', 'ShowCommand',
+        'Show information about installed packages.',
+    )),
+    ('check', CommandInfo(
+        'pip._internal.commands.check', 'CheckCommand',
+        'Verify installed packages have compatible dependencies.',
+    )),
+    ('config', CommandInfo(
+        'pip._internal.commands.configuration', 'ConfigurationCommand',
+        'Manage local and global configuration.',
+    )),
+    ('search', CommandInfo(
+        'pip._internal.commands.search', 'SearchCommand',
+        'Search PyPI for packages.',
+    )),
+    ('cache', CommandInfo(
+        'pip._internal.commands.cache', 'CacheCommand',
+        "Inspect and manage pip's wheel cache.",
+    )),
+    ('wheel', CommandInfo(
+        'pip._internal.commands.wheel', 'WheelCommand',
+        'Build wheels from your requirements.',
+    )),
+    ('hash', CommandInfo(
+        'pip._internal.commands.hash', 'HashCommand',
+        'Compute hashes of package archives.',
+    )),
+    ('completion', CommandInfo(
+        'pip._internal.commands.completion', 'CompletionCommand',
+        'A helper command used for command completion.',
+    )),
+    ('debug', CommandInfo(
+        'pip._internal.commands.debug', 'DebugCommand',
+        'Show information useful for debugging.',
+    )),
+    ('help', CommandInfo(
+        'pip._internal.commands.help', 'HelpCommand',
+        'Show help for commands.',
+    )),
+])  # type: OrderedDict[str, CommandInfo]
+
+
+def create_command(name, **kwargs):
+    # type: (str, **Any) -> Command
+    """
+    Create an instance of the Command class with the given name.
+    """
+    module_path, class_name, summary = commands_dict[name]
+    module = importlib.import_module(module_path)
+    command_class = getattr(module, class_name)
+    command = command_class(name=name, summary=summary, **kwargs)
+
+    return command
+
+
+def get_similar_commands(name):
+    """Command name auto-correct."""
+    from difflib import get_close_matches
+
+    name = name.lower()
+
+    close_commands = get_close_matches(name, commands_dict.keys())
+
+    if close_commands:
+        return close_commands[0]
+    else:
+        return False
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/cache.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/cache.py
new file mode 100644
index 0000000..747277f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/cache.py
@@ -0,0 +1,182 @@
+from __future__ import absolute_import
+
+import logging
+import os
+import textwrap
+
+import pip._internal.utils.filesystem as filesystem
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.exceptions import CommandError, PipError
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import Any, List
+
+
+logger = logging.getLogger(__name__)
+
+
+class CacheCommand(Command):
+    """
+    Inspect and manage pip's wheel cache.
+
+    Subcommands:
+
+    - dir: Show the cache directory.
+    - info: Show information about the cache.
+    - list: List filenames of packages stored in the cache.
+    - remove: Remove one or more package from the cache.
+    - purge: Remove all items from the cache.
+
+    ``<pattern>`` can be a glob expression or a package name.
+    """
+
+    ignore_require_venv = True
+    usage = """
+        %prog dir
+        %prog info
+        %prog list [<pattern>]
+        %prog remove <pattern>
+        %prog purge
+    """
+
+    def run(self, options, args):
+        # type: (Values, List[Any]) -> int
+        handlers = {
+            "dir": self.get_cache_dir,
+            "info": self.get_cache_info,
+            "list": self.list_cache_items,
+            "remove": self.remove_cache_items,
+            "purge": self.purge_cache,
+        }
+
+        if not options.cache_dir:
+            logger.error("pip cache commands can not "
+                         "function since cache is disabled.")
+            return ERROR
+
+        # Determine action
+        if not args or args[0] not in handlers:
+            logger.error(
+                "Need an action (%s) to perform.",
+                ", ".join(sorted(handlers)),
+            )
+            return ERROR
+
+        action = args[0]
+
+        # Error handling happens here, not in the action-handlers.
+        try:
+            handlers[action](options, args[1:])
+        except PipError as e:
+            logger.error(e.args[0])
+            return ERROR
+
+        return SUCCESS
+
+    def get_cache_dir(self, options, args):
+        # type: (Values, List[Any]) -> None
+        if args:
+            raise CommandError('Too many arguments')
+
+        logger.info(options.cache_dir)
+
+    def get_cache_info(self, options, args):
+        # type: (Values, List[Any]) -> None
+        if args:
+            raise CommandError('Too many arguments')
+
+        num_packages = len(self._find_wheels(options, '*'))
+
+        cache_location = self._wheels_cache_dir(options)
+        cache_size = filesystem.format_directory_size(cache_location)
+
+        message = textwrap.dedent("""
+            Location: {location}
+            Size: {size}
+            Number of wheels: {package_count}
+        """).format(
+            location=cache_location,
+            package_count=num_packages,
+            size=cache_size,
+        ).strip()
+
+        logger.info(message)
+
+    def list_cache_items(self, options, args):
+        # type: (Values, List[Any]) -> None
+        if len(args) > 1:
+            raise CommandError('Too many arguments')
+
+        if args:
+            pattern = args[0]
+        else:
+            pattern = '*'
+
+        files = self._find_wheels(options, pattern)
+
+        if not files:
+            logger.info('Nothing cached.')
+            return
+
+        results = []
+        for filename in files:
+            wheel = os.path.basename(filename)
+            size = filesystem.format_file_size(filename)
+            results.append(' - {} ({})'.format(wheel, size))
+        logger.info('Cache contents:\n')
+        logger.info('\n'.join(sorted(results)))
+
+    def remove_cache_items(self, options, args):
+        # type: (Values, List[Any]) -> None
+        if len(args) > 1:
+            raise CommandError('Too many arguments')
+
+        if not args:
+            raise CommandError('Please provide a pattern')
+
+        files = self._find_wheels(options, args[0])
+        if not files:
+            raise CommandError('No matching packages')
+
+        for filename in files:
+            os.unlink(filename)
+            logger.debug('Removed %s', filename)
+        logger.info('Files removed: %s', len(files))
+
+    def purge_cache(self, options, args):
+        # type: (Values, List[Any]) -> None
+        if args:
+            raise CommandError('Too many arguments')
+
+        return self.remove_cache_items(options, ['*'])
+
+    def _wheels_cache_dir(self, options):
+        # type: (Values) -> str
+        return os.path.join(options.cache_dir, 'wheels')
+
+    def _find_wheels(self, options, pattern):
+        # type: (Values, str) -> List[str]
+        wheel_dir = self._wheels_cache_dir(options)
+
+        # The wheel filename format, as specified in PEP 427, is:
+        #     {distribution}-{version}(-{build})?-{python}-{abi}-{platform}.whl
+        #
+        # Additionally, non-alphanumeric values in the distribution are
+        # normalized to underscores (_), meaning hyphens can never occur
+        # before `-{version}`.
+        #
+        # Given that information:
+        # - If the pattern we're given contains a hyphen (-), the user is
+        #   providing at least the version. Thus, we can just append `*.whl`
+        #   to match the rest of it.
+        # - If the pattern we're given doesn't contain a hyphen (-), the
+        #   user is only providing the name. Thus, we append `-*.whl` to
+        #   match the hyphen before the version, followed by anything else.
+        #
+        # PEP 427: https://www.python.org/dev/peps/pep-0427/
+        pattern = pattern + ("*.whl" if "-" in pattern else "-*.whl")
+
+        return filesystem.find_files(wheel_dir, pattern)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/check.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/check.py
new file mode 100644
index 0000000..b557ca6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/check.py
@@ -0,0 +1,51 @@
+import logging
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.operations.check import (
+    check_package_set,
+    create_package_set_from_installed,
+)
+from pip._internal.utils.misc import write_output
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+logger = logging.getLogger(__name__)
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Any
+    from optparse import Values
+
+
+class CheckCommand(Command):
+    """Verify installed packages have compatible dependencies."""
+
+    usage = """
+      %prog [options]"""
+
+    def run(self, options, args):
+        # type: (Values, List[Any]) -> int
+
+        package_set, parsing_probs = create_package_set_from_installed()
+        missing, conflicting = check_package_set(package_set)
+
+        for project_name in missing:
+            version = package_set[project_name].version
+            for dependency in missing[project_name]:
+                write_output(
+                    "%s %s requires %s, which is not installed.",
+                    project_name, version, dependency[0],
+                )
+
+        for project_name in conflicting:
+            version = package_set[project_name].version
+            for dep_name, dep_version, req in conflicting[project_name]:
+                write_output(
+                    "%s %s has requirement %s, but you have %s %s.",
+                    project_name, version, req, dep_name, dep_version,
+                )
+
+        if missing or conflicting or parsing_probs:
+            return ERROR
+        else:
+            write_output("No broken requirements found.")
+            return SUCCESS
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/completion.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/completion.py
new file mode 100644
index 0000000..9b99f51
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/completion.py
@@ -0,0 +1,98 @@
+from __future__ import absolute_import
+
+import sys
+import textwrap
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.utils.misc import get_prog
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List
+    from optparse import Values
+
+BASE_COMPLETION = """
+# pip {shell} completion start{script}# pip {shell} completion end
+"""
+
+COMPLETION_SCRIPTS = {
+    'bash': """
+        _pip_completion()
+        {{
+            COMPREPLY=( $( COMP_WORDS="${{COMP_WORDS[*]}}" \\
+                           COMP_CWORD=$COMP_CWORD \\
+                           PIP_AUTO_COMPLETE=1 $1 2>/dev/null ) )
+        }}
+        complete -o default -F _pip_completion {prog}
+    """,
+    'zsh': """
+        function _pip_completion {{
+          local words cword
+          read -Ac words
+          read -cn cword
+          reply=( $( COMP_WORDS="$words[*]" \\
+                     COMP_CWORD=$(( cword-1 )) \\
+                     PIP_AUTO_COMPLETE=1 $words[1] 2>/dev/null ))
+        }}
+        compctl -K _pip_completion {prog}
+    """,
+    'fish': """
+        function __fish_complete_pip
+            set -lx COMP_WORDS (commandline -o) ""
+            set -lx COMP_CWORD ( \\
+                math (contains -i -- (commandline -t) $COMP_WORDS)-1 \\
+            )
+            set -lx PIP_AUTO_COMPLETE 1
+            string split \\  -- (eval $COMP_WORDS[1])
+        end
+        complete -fa "(__fish_complete_pip)" -c {prog}
+    """,
+}
+
+
+class CompletionCommand(Command):
+    """A helper command to be used for command completion."""
+
+    ignore_require_venv = True
+
+    def add_options(self):
+        # type: () -> None
+        self.cmd_opts.add_option(
+            '--bash', '-b',
+            action='store_const',
+            const='bash',
+            dest='shell',
+            help='Emit completion code for bash')
+        self.cmd_opts.add_option(
+            '--zsh', '-z',
+            action='store_const',
+            const='zsh',
+            dest='shell',
+            help='Emit completion code for zsh')
+        self.cmd_opts.add_option(
+            '--fish', '-f',
+            action='store_const',
+            const='fish',
+            dest='shell',
+            help='Emit completion code for fish')
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options, args):
+        #  type: (Values, List[str]) -> int
+        """Prints the completion code of the given shell"""
+        shells = COMPLETION_SCRIPTS.keys()
+        shell_options = ['--' + shell for shell in sorted(shells)]
+        if options.shell in shells:
+            script = textwrap.dedent(
+                COMPLETION_SCRIPTS.get(options.shell, '').format(
+                    prog=get_prog())
+            )
+            print(BASE_COMPLETION.format(script=script, shell=options.shell))
+            return SUCCESS
+        else:
+            sys.stderr.write(
+                'ERROR: You must pass {}\n' .format(' or '.join(shell_options))
+            )
+            return SUCCESS
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/configuration.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/configuration.py
new file mode 100644
index 0000000..f9b3ab7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/configuration.py
@@ -0,0 +1,284 @@
+import logging
+import os
+import subprocess
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.configuration import (
+    Configuration,
+    get_configuration_files,
+    kinds,
+)
+from pip._internal.exceptions import PipError
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import get_prog, write_output
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Any, Optional
+    from optparse import Values
+
+    from pip._internal.configuration import Kind
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigurationCommand(Command):
+    """
+    Manage local and global configuration.
+
+    Subcommands:
+
+    - list: List the active configuration (or from the file specified)
+    - edit: Edit the configuration file in an editor
+    - get: Get the value associated with name
+    - set: Set the name=value
+    - unset: Unset the value associated with name
+    - debug: List the configuration files and values defined under them
+
+    If none of --user, --global and --site are passed, a virtual
+    environment configuration file is used if one is active and the file
+    exists. Otherwise, all modifications happen on the to the user file by
+    default.
+    """
+
+    ignore_require_venv = True
+    usage = """
+        %prog [<file-option>] list
+        %prog [<file-option>] [--editor <editor-path>] edit
+
+        %prog [<file-option>] get name
+        %prog [<file-option>] set name value
+        %prog [<file-option>] unset name
+        %prog [<file-option>] debug
+    """
+
+    def add_options(self):
+        # type: () -> None
+        self.cmd_opts.add_option(
+            '--editor',
+            dest='editor',
+            action='store',
+            default=None,
+            help=(
+                'Editor to use to edit the file. Uses VISUAL or EDITOR '
+                'environment variables if not provided.'
+            )
+        )
+
+        self.cmd_opts.add_option(
+            '--global',
+            dest='global_file',
+            action='store_true',
+            default=False,
+            help='Use the system-wide configuration file only'
+        )
+
+        self.cmd_opts.add_option(
+            '--user',
+            dest='user_file',
+            action='store_true',
+            default=False,
+            help='Use the user configuration file only'
+        )
+
+        self.cmd_opts.add_option(
+            '--site',
+            dest='site_file',
+            action='store_true',
+            default=False,
+            help='Use the current environment configuration file only'
+        )
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+        handlers = {
+            "list": self.list_values,
+            "edit": self.open_in_editor,
+            "get": self.get_name,
+            "set": self.set_name_value,
+            "unset": self.unset_name,
+            "debug": self.list_config_values,
+        }
+
+        # Determine action
+        if not args or args[0] not in handlers:
+            logger.error(
+                "Need an action (%s) to perform.",
+                ", ".join(sorted(handlers)),
+            )
+            return ERROR
+
+        action = args[0]
+
+        # Determine which configuration files are to be loaded
+        #    Depends on whether the command is modifying.
+        try:
+            load_only = self._determine_file(
+                options, need_value=(action in ["get", "set", "unset", "edit"])
+            )
+        except PipError as e:
+            logger.error(e.args[0])
+            return ERROR
+
+        # Load a new configuration
+        self.configuration = Configuration(
+            isolated=options.isolated_mode, load_only=load_only
+        )
+        self.configuration.load()
+
+        # Error handling happens here, not in the action-handlers.
+        try:
+            handlers[action](options, args[1:])
+        except PipError as e:
+            logger.error(e.args[0])
+            return ERROR
+
+        return SUCCESS
+
+    def _determine_file(self, options, need_value):
+        # type: (Values, bool) -> Optional[Kind]
+        file_options = [key for key, value in (
+            (kinds.USER, options.user_file),
+            (kinds.GLOBAL, options.global_file),
+            (kinds.SITE, options.site_file),
+        ) if value]
+
+        if not file_options:
+            if not need_value:
+                return None
+            # Default to user, unless there's a site file.
+            elif any(
+                os.path.exists(site_config_file)
+                for site_config_file in get_configuration_files()[kinds.SITE]
+            ):
+                return kinds.SITE
+            else:
+                return kinds.USER
+        elif len(file_options) == 1:
+            return file_options[0]
+
+        raise PipError(
+            "Need exactly one file to operate upon "
+            "(--user, --site, --global) to perform."
+        )
+
+    def list_values(self, options, args):
+        # type: (Values, List[str]) -> None
+        self._get_n_args(args, "list", n=0)
+
+        for key, value in sorted(self.configuration.items()):
+            write_output("%s=%r", key, value)
+
+    def get_name(self, options, args):
+        # type: (Values, List[str]) -> None
+        key = self._get_n_args(args, "get [name]", n=1)
+        value = self.configuration.get_value(key)
+
+        write_output("%s", value)
+
+    def set_name_value(self, options, args):
+        # type: (Values, List[str]) -> None
+        key, value = self._get_n_args(args, "set [name] [value]", n=2)
+        self.configuration.set_value(key, value)
+
+        self._save_configuration()
+
+    def unset_name(self, options, args):
+        # type: (Values, List[str]) -> None
+        key = self._get_n_args(args, "unset [name]", n=1)
+        self.configuration.unset_value(key)
+
+        self._save_configuration()
+
+    def list_config_values(self, options, args):
+        # type: (Values, List[str]) -> None
+        """List config key-value pairs across different config files"""
+        self._get_n_args(args, "debug", n=0)
+
+        self.print_env_var_values()
+        # Iterate over config files and print if they exist, and the
+        # key-value pairs present in them if they do
+        for variant, files in sorted(self.configuration.iter_config_files()):
+            write_output("%s:", variant)
+            for fname in files:
+                with indent_log():
+                    file_exists = os.path.exists(fname)
+                    write_output("%s, exists: %r",
+                                 fname, file_exists)
+                    if file_exists:
+                        self.print_config_file_values(variant)
+
+    def print_config_file_values(self, variant):
+        # type: (Kind) -> None
+        """Get key-value pairs from the file of a variant"""
+        for name, value in self.configuration.\
+                get_values_in_config(variant).items():
+            with indent_log():
+                write_output("%s: %s", name, value)
+
+    def print_env_var_values(self):
+        # type: () -> None
+        """Get key-values pairs present as environment variables"""
+        write_output("%s:", 'env_var')
+        with indent_log():
+            for key, value in sorted(self.configuration.get_environ_vars()):
+                env_var = 'PIP_{}'.format(key.upper())
+                write_output("%s=%r", env_var, value)
+
+    def open_in_editor(self, options, args):
+        # type: (Values, List[str]) -> None
+        editor = self._determine_editor(options)
+
+        fname = self.configuration.get_file_to_edit()
+        if fname is None:
+            raise PipError("Could not determine appropriate file.")
+
+        try:
+            subprocess.check_call([editor, fname])
+        except subprocess.CalledProcessError as e:
+            raise PipError(
+                "Editor Subprocess exited with exit code {}"
+                .format(e.returncode)
+            )
+
+    def _get_n_args(self, args, example, n):
+        # type: (List[str], str, int) -> Any
+        """Helper to make sure the command got the right number of arguments
+        """
+        if len(args) != n:
+            msg = (
+                'Got unexpected number of arguments, expected {}. '
+                '(example: "{} config {}")'
+            ).format(n, get_prog(), example)
+            raise PipError(msg)
+
+        if n == 1:
+            return args[0]
+        else:
+            return args
+
+    def _save_configuration(self):
+        # type: () -> None
+        # We successfully ran a modifying command. Need to save the
+        # configuration.
+        try:
+            self.configuration.save()
+        except Exception:
+            logger.exception(
+                "Unable to save configuration. Please report this as a bug."
+            )
+            raise PipError("Internal Error.")
+
+    def _determine_editor(self, options):
+        # type: (Values) -> str
+        if options.editor is not None:
+            return options.editor
+        elif "VISUAL" in os.environ:
+            return os.environ["VISUAL"]
+        elif "EDITOR" in os.environ:
+            return os.environ["EDITOR"]
+        else:
+            raise PipError("Could not determine editor to use.")
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/debug.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/debug.py
new file mode 100644
index 0000000..ff369d7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/debug.py
@@ -0,0 +1,229 @@
+from __future__ import absolute_import
+
+import locale
+import logging
+import os
+import sys
+
+import pip._vendor
+from pip._vendor import pkg_resources
+from pip._vendor.certifi import where
+
+from pip import __file__ as pip_location
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.cmdoptions import make_target_python
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import get_pip_version
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from types import ModuleType
+    from typing import List, Optional, Dict
+    from optparse import Values
+    from pip._internal.configuration import Configuration
+
+logger = logging.getLogger(__name__)
+
+
+def show_value(name, value):
+    # type: (str, Optional[str]) -> None
+    logger.info('%s: %s', name, value)
+
+
+def show_sys_implementation():
+    # type: () -> None
+    logger.info('sys.implementation:')
+    if hasattr(sys, 'implementation'):
+        implementation = sys.implementation  # type: ignore
+        implementation_name = implementation.name
+    else:
+        implementation_name = ''
+
+    with indent_log():
+        show_value('name', implementation_name)
+
+
+def create_vendor_txt_map():
+    # type: () -> Dict[str, str]
+    vendor_txt_path = os.path.join(
+        os.path.dirname(pip_location),
+        '_vendor',
+        'vendor.txt'
+    )
+
+    with open(vendor_txt_path) as f:
+        # Purge non version specifying lines.
+        # Also, remove any space prefix or suffixes (including comments).
+        lines = [line.strip().split(' ', 1)[0]
+                 for line in f.readlines() if '==' in line]
+
+    # Transform into "module" -> version dict.
+    return dict(line.split('==', 1) for line in lines)  # type: ignore
+
+
+def get_module_from_module_name(module_name):
+    # type: (str) -> ModuleType
+    # Module name can be uppercase in vendor.txt for some reason...
+    module_name = module_name.lower()
+    # PATCH: setuptools is actually only pkg_resources.
+    if module_name == 'setuptools':
+        module_name = 'pkg_resources'
+
+    __import__(
+        'pip._vendor.{}'.format(module_name),
+        globals(),
+        locals(),
+        level=0
+    )
+    return getattr(pip._vendor, module_name)
+
+
+def get_vendor_version_from_module(module_name):
+    # type: (str) -> Optional[str]
+    module = get_module_from_module_name(module_name)
+    version = getattr(module, '__version__', None)
+
+    if not version:
+        # Try to find version in debundled module info
+        # The type for module.__file__ is Optional[str] in
+        # Python 2, and str in Python 3. The type: ignore is
+        # added to account for Python 2, instead of a cast
+        # and should be removed once we drop Python 2 support
+        pkg_set = pkg_resources.WorkingSet(
+            [os.path.dirname(module.__file__)]  # type: ignore
+        )
+        package = pkg_set.find(pkg_resources.Requirement.parse(module_name))
+        version = getattr(package, 'version', None)
+
+    return version
+
+
+def show_actual_vendor_versions(vendor_txt_versions):
+    # type: (Dict[str, str]) -> None
+    """Log the actual version and print extra info if there is
+    a conflict or if the actual version could not be imported.
+    """
+    for module_name, expected_version in vendor_txt_versions.items():
+        extra_message = ''
+        actual_version = get_vendor_version_from_module(module_name)
+        if not actual_version:
+            extra_message = ' (Unable to locate actual module version, using'\
+                            ' vendor.txt specified version)'
+            actual_version = expected_version
+        elif actual_version != expected_version:
+            extra_message = ' (CONFLICT: vendor.txt suggests version should'\
+                            ' be {})'.format(expected_version)
+        logger.info('%s==%s%s', module_name, actual_version, extra_message)
+
+
+def show_vendor_versions():
+    # type: () -> None
+    logger.info('vendored library versions:')
+
+    vendor_txt_versions = create_vendor_txt_map()
+    with indent_log():
+        show_actual_vendor_versions(vendor_txt_versions)
+
+
+def show_tags(options):
+    # type: (Values) -> None
+    tag_limit = 10
+
+    target_python = make_target_python(options)
+    tags = target_python.get_tags()
+
+    # Display the target options that were explicitly provided.
+    formatted_target = target_python.format_given()
+    suffix = ''
+    if formatted_target:
+        suffix = ' (target: {})'.format(formatted_target)
+
+    msg = 'Compatible tags: {}{}'.format(len(tags), suffix)
+    logger.info(msg)
+
+    if options.verbose < 1 and len(tags) > tag_limit:
+        tags_limited = True
+        tags = tags[:tag_limit]
+    else:
+        tags_limited = False
+
+    with indent_log():
+        for tag in tags:
+            logger.info(str(tag))
+
+        if tags_limited:
+            msg = (
+                '...\n'
+                '[First {tag_limit} tags shown. Pass --verbose to show all.]'
+            ).format(tag_limit=tag_limit)
+            logger.info(msg)
+
+
+def ca_bundle_info(config):
+    # type: (Configuration) -> str
+    levels = set()
+    for key, _ in config.items():
+        levels.add(key.split('.')[0])
+
+    if not levels:
+        return "Not specified"
+
+    levels_that_override_global = ['install', 'wheel', 'download']
+    global_overriding_level = [
+        level for level in levels if level in levels_that_override_global
+    ]
+    if not global_overriding_level:
+        return 'global'
+
+    if 'global' in levels:
+        levels.remove('global')
+    return ", ".join(levels)
+
+
+class DebugCommand(Command):
+    """
+    Display debug information.
+    """
+
+    usage = """
+      %prog <options>"""
+    ignore_require_venv = True
+
+    def add_options(self):
+        # type: () -> None
+        cmdoptions.add_target_python_options(self.cmd_opts)
+        self.parser.insert_option_group(0, self.cmd_opts)
+        self.parser.config.load()
+
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+        logger.warning(
+            "This command is only meant for debugging. "
+            "Do not use this with automation for parsing and getting these "
+            "details, since the output and options of this command may "
+            "change without notice."
+        )
+        show_value('pip version', get_pip_version())
+        show_value('sys.version', sys.version)
+        show_value('sys.executable', sys.executable)
+        show_value('sys.getdefaultencoding', sys.getdefaultencoding())
+        show_value('sys.getfilesystemencoding', sys.getfilesystemencoding())
+        show_value(
+            'locale.getpreferredencoding', locale.getpreferredencoding(),
+        )
+        show_value('sys.platform', sys.platform)
+        show_sys_implementation()
+
+        show_value("'cert' config value", ca_bundle_info(self.parser.config))
+        show_value("REQUESTS_CA_BUNDLE", os.environ.get('REQUESTS_CA_BUNDLE'))
+        show_value("CURL_CA_BUNDLE", os.environ.get('CURL_CA_BUNDLE'))
+        show_value("pip._vendor.certifi.where()", where())
+        show_value("pip._vendor.DEBUNDLED", pip._vendor.DEBUNDLED)
+
+        show_vendor_versions()
+
+        show_tags(options)
+
+        return SUCCESS
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/download.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/download.py
new file mode 100644
index 0000000..46e8371
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/download.py
@@ -0,0 +1,143 @@
+from __future__ import absolute_import
+
+import logging
+import os
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.cmdoptions import make_target_python
+from pip._internal.cli.req_command import RequirementCommand, with_cleanup
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.req.req_tracker import get_requirement_tracker
+from pip._internal.utils.misc import ensure_dir, normalize_path, write_output
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import List
+
+logger = logging.getLogger(__name__)
+
+
+class DownloadCommand(RequirementCommand):
+    """
+    Download packages from:
+
+    - PyPI (and other indexes) using requirement specifiers.
+    - VCS project urls.
+    - Local project directories.
+    - Local or remote source archives.
+
+    pip also supports downloading from "requirements files", which provide
+    an easy way to specify a whole environment to be downloaded.
+    """
+
+    usage = """
+      %prog [options] <requirement specifier> [package-index-options] ...
+      %prog [options] -r <requirements file> [package-index-options] ...
+      %prog [options] <vcs project url> ...
+      %prog [options] <local project path> ...
+      %prog [options] <archive url/path> ..."""
+
+    def add_options(self):
+        # type: () -> None
+        self.cmd_opts.add_option(cmdoptions.constraints())
+        self.cmd_opts.add_option(cmdoptions.requirements())
+        self.cmd_opts.add_option(cmdoptions.build_dir())
+        self.cmd_opts.add_option(cmdoptions.no_deps())
+        self.cmd_opts.add_option(cmdoptions.global_options())
+        self.cmd_opts.add_option(cmdoptions.no_binary())
+        self.cmd_opts.add_option(cmdoptions.only_binary())
+        self.cmd_opts.add_option(cmdoptions.prefer_binary())
+        self.cmd_opts.add_option(cmdoptions.src())
+        self.cmd_opts.add_option(cmdoptions.pre())
+        self.cmd_opts.add_option(cmdoptions.require_hashes())
+        self.cmd_opts.add_option(cmdoptions.progress_bar())
+        self.cmd_opts.add_option(cmdoptions.no_build_isolation())
+        self.cmd_opts.add_option(cmdoptions.use_pep517())
+        self.cmd_opts.add_option(cmdoptions.no_use_pep517())
+
+        self.cmd_opts.add_option(
+            '-d', '--dest', '--destination-dir', '--destination-directory',
+            dest='download_dir',
+            metavar='dir',
+            default=os.curdir,
+            help=("Download packages into <dir>."),
+        )
+
+        cmdoptions.add_target_python_options(self.cmd_opts)
+
+        index_opts = cmdoptions.make_option_group(
+            cmdoptions.index_group,
+            self.parser,
+        )
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    @with_cleanup
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+
+        options.ignore_installed = True
+        # editable doesn't really make sense for `pip download`, but the bowels
+        # of the RequirementSet code require that property.
+        options.editables = []
+
+        cmdoptions.check_dist_restriction(options)
+
+        options.download_dir = normalize_path(options.download_dir)
+
+        ensure_dir(options.download_dir)
+
+        session = self.get_default_session(options)
+
+        target_python = make_target_python(options)
+        finder = self._build_package_finder(
+            options=options,
+            session=session,
+            target_python=target_python,
+        )
+        build_delete = (not (options.no_clean or options.build_dir))
+
+        req_tracker = self.enter_context(get_requirement_tracker())
+
+        directory = TempDirectory(
+            options.build_dir,
+            delete=build_delete,
+            kind="download",
+            globally_managed=True,
+        )
+
+        reqs = self.get_requirements(args, options, finder, session)
+
+        preparer = self.make_requirement_preparer(
+            temp_build_dir=directory,
+            options=options,
+            req_tracker=req_tracker,
+            session=session,
+            finder=finder,
+            download_dir=options.download_dir,
+            use_user_site=False,
+        )
+
+        resolver = self.make_resolver(
+            preparer=preparer,
+            finder=finder,
+            options=options,
+            py_version_info=options.python_version,
+        )
+
+        self.trace_basic_info(finder)
+
+        requirement_set = resolver.resolve(
+            reqs, check_supported_wheels=True
+        )
+
+        downloaded = ' '.join([req.name  # type: ignore
+                               for req in requirement_set.requirements.values()
+                               if req.successfully_downloaded])
+        if downloaded:
+            write_output('Successfully downloaded %s', downloaded)
+
+        return SUCCESS
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/freeze.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/freeze.py
new file mode 100644
index 0000000..2071fba
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/freeze.py
@@ -0,0 +1,103 @@
+from __future__ import absolute_import
+
+import sys
+
+from pip._internal.cache import WheelCache
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.models.format_control import FormatControl
+from pip._internal.operations.freeze import freeze
+from pip._internal.utils.compat import stdlib_pkgs
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+DEV_PKGS = {'pip', 'setuptools', 'distribute', 'wheel'}
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import List
+
+
+class FreezeCommand(Command):
+    """
+    Output installed packages in requirements format.
+
+    packages are listed in a case-insensitive sorted order.
+    """
+
+    usage = """
+      %prog [options]"""
+    log_streams = ("ext://sys.stderr", "ext://sys.stderr")
+
+    def add_options(self):
+        # type: () -> None
+        self.cmd_opts.add_option(
+            '-r', '--requirement',
+            dest='requirements',
+            action='append',
+            default=[],
+            metavar='file',
+            help="Use the order in the given requirements file and its "
+                 "comments when generating output. This option can be "
+                 "used multiple times.")
+        self.cmd_opts.add_option(
+            '-f', '--find-links',
+            dest='find_links',
+            action='append',
+            default=[],
+            metavar='URL',
+            help='URL for finding packages, which will be added to the '
+                 'output.')
+        self.cmd_opts.add_option(
+            '-l', '--local',
+            dest='local',
+            action='store_true',
+            default=False,
+            help='If in a virtualenv that has global access, do not output '
+                 'globally-installed packages.')
+        self.cmd_opts.add_option(
+            '--user',
+            dest='user',
+            action='store_true',
+            default=False,
+            help='Only output packages installed in user-site.')
+        self.cmd_opts.add_option(cmdoptions.list_path())
+        self.cmd_opts.add_option(
+            '--all',
+            dest='freeze_all',
+            action='store_true',
+            help='Do not skip these packages in the output:'
+                 ' {}'.format(', '.join(DEV_PKGS)))
+        self.cmd_opts.add_option(
+            '--exclude-editable',
+            dest='exclude_editable',
+            action='store_true',
+            help='Exclude editable package from output.')
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+        format_control = FormatControl(set(), set())
+        wheel_cache = WheelCache(options.cache_dir, format_control)
+        skip = set(stdlib_pkgs)
+        if not options.freeze_all:
+            skip.update(DEV_PKGS)
+
+        cmdoptions.check_list_path_option(options)
+
+        freeze_kwargs = dict(
+            requirement=options.requirements,
+            find_links=options.find_links,
+            local_only=options.local,
+            user_only=options.user,
+            paths=options.path,
+            isolated=options.isolated_mode,
+            wheel_cache=wheel_cache,
+            skip=skip,
+            exclude_editable=options.exclude_editable,
+        )
+
+        for line in freeze(**freeze_kwargs):
+            sys.stdout.write(line + '\n')
+        return SUCCESS
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/hash.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/hash.py
new file mode 100644
index 0000000..37831c3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/hash.py
@@ -0,0 +1,63 @@
+from __future__ import absolute_import
+
+import hashlib
+import logging
+import sys
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.utils.hashes import FAVORITE_HASH, STRONG_HASHES
+from pip._internal.utils.misc import read_chunks, write_output
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import List
+
+logger = logging.getLogger(__name__)
+
+
+class HashCommand(Command):
+    """
+    Compute a hash of a local package archive.
+
+    These can be used with --hash in a requirements file to do repeatable
+    installs.
+    """
+
+    usage = '%prog [options] <file> ...'
+    ignore_require_venv = True
+
+    def add_options(self):
+        # type: () -> None
+        self.cmd_opts.add_option(
+            '-a', '--algorithm',
+            dest='algorithm',
+            choices=STRONG_HASHES,
+            action='store',
+            default=FAVORITE_HASH,
+            help='The hash algorithm to use: one of {}'.format(
+                 ', '.join(STRONG_HASHES)))
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+        if not args:
+            self.parser.print_usage(sys.stderr)
+            return ERROR
+
+        algorithm = options.algorithm
+        for path in args:
+            write_output('%s:\n--hash=%s:%s',
+                         path, algorithm, _hash_of_file(path, algorithm))
+        return SUCCESS
+
+
+def _hash_of_file(path, algorithm):
+    # type: (str, str) -> str
+    """Return the hash digest of a file."""
+    with open(path, 'rb') as archive:
+        hash = hashlib.new(algorithm)
+        for chunk in read_chunks(archive):
+            hash.update(chunk)
+    return hash.hexdigest()
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/help.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/help.py
new file mode 100644
index 0000000..a2edc29
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/help.py
@@ -0,0 +1,44 @@
+from __future__ import absolute_import
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.exceptions import CommandError
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List
+    from optparse import Values
+
+
+class HelpCommand(Command):
+    """Show help for commands"""
+
+    usage = """
+      %prog <command>"""
+    ignore_require_venv = True
+
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+        from pip._internal.commands import (
+            commands_dict, create_command, get_similar_commands,
+        )
+
+        try:
+            # 'pip help' with no args is handled by pip.__init__.parseopt()
+            cmd_name = args[0]  # the command we need help for
+        except IndexError:
+            return SUCCESS
+
+        if cmd_name not in commands_dict:
+            guess = get_similar_commands(cmd_name)
+
+            msg = ['unknown command "{}"'.format(cmd_name)]
+            if guess:
+                msg.append('maybe you meant "{}"'.format(guess))
+
+            raise CommandError(' - '.join(msg))
+
+        command = create_command(cmd_name)
+        command.parser.print_help()
+
+        return SUCCESS
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/install.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/install.py
new file mode 100644
index 0000000..704e2d6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/install.py
@@ -0,0 +1,749 @@
+from __future__ import absolute_import
+
+import errno
+import logging
+import operator
+import os
+import shutil
+import site
+from optparse import SUPPRESS_HELP
+
+from pip._vendor import pkg_resources
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.cache import WheelCache
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.cmdoptions import make_target_python
+from pip._internal.cli.req_command import RequirementCommand, with_cleanup
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.exceptions import CommandError, InstallationError
+from pip._internal.locations import distutils_scheme
+from pip._internal.operations.check import check_install_conflicts
+from pip._internal.req import install_given_reqs
+from pip._internal.req.req_tracker import get_requirement_tracker
+from pip._internal.utils.datetime import today_is_later_than
+from pip._internal.utils.distutils_args import parse_distutils_args
+from pip._internal.utils.filesystem import test_writable_dir
+from pip._internal.utils.misc import (
+    ensure_dir,
+    get_installed_version,
+    get_pip_version,
+    protect_pip_from_modification_on_windows,
+    write_output,
+)
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.virtualenv import virtualenv_no_global
+from pip._internal.wheel_builder import build, should_build_for_install_command
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import Iterable, List, Optional
+
+    from pip._internal.models.format_control import FormatControl
+    from pip._internal.operations.check import ConflictDetails
+    from pip._internal.req.req_install import InstallRequirement
+    from pip._internal.wheel_builder import BinaryAllowedPredicate
+
+
+logger = logging.getLogger(__name__)
+
+
+def get_check_binary_allowed(format_control):
+    # type: (FormatControl) -> BinaryAllowedPredicate
+    def check_binary_allowed(req):
+        # type: (InstallRequirement) -> bool
+        if req.use_pep517:
+            return True
+        canonical_name = canonicalize_name(req.name)
+        allowed_formats = format_control.get_allowed_formats(canonical_name)
+        return "binary" in allowed_formats
+
+    return check_binary_allowed
+
+
+class InstallCommand(RequirementCommand):
+    """
+    Install packages from:
+
+    - PyPI (and other indexes) using requirement specifiers.
+    - VCS project urls.
+    - Local project directories.
+    - Local or remote source archives.
+
+    pip also supports installing from "requirements files", which provide
+    an easy way to specify a whole environment to be installed.
+    """
+
+    usage = """
+      %prog [options] <requirement specifier> [package-index-options] ...
+      %prog [options] -r <requirements file> [package-index-options] ...
+      %prog [options] [-e] <vcs project url> ...
+      %prog [options] [-e] <local project path> ...
+      %prog [options] <archive url/path> ..."""
+
+    def add_options(self):
+        # type: () -> None
+        self.cmd_opts.add_option(cmdoptions.requirements())
+        self.cmd_opts.add_option(cmdoptions.constraints())
+        self.cmd_opts.add_option(cmdoptions.no_deps())
+        self.cmd_opts.add_option(cmdoptions.pre())
+
+        self.cmd_opts.add_option(cmdoptions.editable())
+        self.cmd_opts.add_option(
+            '-t', '--target',
+            dest='target_dir',
+            metavar='dir',
+            default=None,
+            help='Install packages into <dir>. '
+                 'By default this will not replace existing files/folders in '
+                 '<dir>. Use --upgrade to replace existing packages in <dir> '
+                 'with new versions.'
+        )
+        cmdoptions.add_target_python_options(self.cmd_opts)
+
+        self.cmd_opts.add_option(
+            '--user',
+            dest='use_user_site',
+            action='store_true',
+            help="Install to the Python user install directory for your "
+                 "platform. Typically ~/.local/, or %APPDATA%\\Python on "
+                 "Windows. (See the Python documentation for site.USER_BASE "
+                 "for full details.)")
+        self.cmd_opts.add_option(
+            '--no-user',
+            dest='use_user_site',
+            action='store_false',
+            help=SUPPRESS_HELP)
+        self.cmd_opts.add_option(
+            '--root',
+            dest='root_path',
+            metavar='dir',
+            default=None,
+            help="Install everything relative to this alternate root "
+                 "directory.")
+        self.cmd_opts.add_option(
+            '--prefix',
+            dest='prefix_path',
+            metavar='dir',
+            default=None,
+            help="Installation prefix where lib, bin and other top-level "
+                 "folders are placed")
+
+        self.cmd_opts.add_option(cmdoptions.build_dir())
+
+        self.cmd_opts.add_option(cmdoptions.src())
+
+        self.cmd_opts.add_option(
+            '-U', '--upgrade',
+            dest='upgrade',
+            action='store_true',
+            help='Upgrade all specified packages to the newest available '
+                 'version. The handling of dependencies depends on the '
+                 'upgrade-strategy used.'
+        )
+
+        self.cmd_opts.add_option(
+            '--upgrade-strategy',
+            dest='upgrade_strategy',
+            default='only-if-needed',
+            choices=['only-if-needed', 'eager'],
+            help='Determines how dependency upgrading should be handled '
+                 '[default: %default]. '
+                 '"eager" - dependencies are upgraded regardless of '
+                 'whether the currently installed version satisfies the '
+                 'requirements of the upgraded package(s). '
+                 '"only-if-needed" -  are upgraded only when they do not '
+                 'satisfy the requirements of the upgraded package(s).'
+        )
+
+        self.cmd_opts.add_option(
+            '--force-reinstall',
+            dest='force_reinstall',
+            action='store_true',
+            help='Reinstall all packages even if they are already '
+                 'up-to-date.')
+
+        self.cmd_opts.add_option(
+            '-I', '--ignore-installed',
+            dest='ignore_installed',
+            action='store_true',
+            help='Ignore the installed packages, overwriting them. '
+                 'This can break your system if the existing package '
+                 'is of a different version or was installed '
+                 'with a different package manager!'
+        )
+
+        self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
+        self.cmd_opts.add_option(cmdoptions.no_build_isolation())
+        self.cmd_opts.add_option(cmdoptions.use_pep517())
+        self.cmd_opts.add_option(cmdoptions.no_use_pep517())
+
+        self.cmd_opts.add_option(cmdoptions.install_options())
+        self.cmd_opts.add_option(cmdoptions.global_options())
+
+        self.cmd_opts.add_option(
+            "--compile",
+            action="store_true",
+            dest="compile",
+            default=True,
+            help="Compile Python source files to bytecode",
+        )
+
+        self.cmd_opts.add_option(
+            "--no-compile",
+            action="store_false",
+            dest="compile",
+            help="Do not compile Python source files to bytecode",
+        )
+
+        self.cmd_opts.add_option(
+            "--no-warn-script-location",
+            action="store_false",
+            dest="warn_script_location",
+            default=True,
+            help="Do not warn when installing scripts outside PATH",
+        )
+        self.cmd_opts.add_option(
+            "--no-warn-conflicts",
+            action="store_false",
+            dest="warn_about_conflicts",
+            default=True,
+            help="Do not warn about broken dependencies",
+        )
+
+        self.cmd_opts.add_option(cmdoptions.no_binary())
+        self.cmd_opts.add_option(cmdoptions.only_binary())
+        self.cmd_opts.add_option(cmdoptions.prefer_binary())
+        self.cmd_opts.add_option(cmdoptions.require_hashes())
+        self.cmd_opts.add_option(cmdoptions.progress_bar())
+
+        index_opts = cmdoptions.make_option_group(
+            cmdoptions.index_group,
+            self.parser,
+        )
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    @with_cleanup
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+        if options.use_user_site and options.target_dir is not None:
+            raise CommandError("Can not combine '--user' and '--target'")
+
+        cmdoptions.check_install_build_global(options)
+        upgrade_strategy = "to-satisfy-only"
+        if options.upgrade:
+            upgrade_strategy = options.upgrade_strategy
+
+        cmdoptions.check_dist_restriction(options, check_target=True)
+
+        install_options = options.install_options or []
+
+        logger.debug("Using %s", get_pip_version())
+        options.use_user_site = decide_user_install(
+            options.use_user_site,
+            prefix_path=options.prefix_path,
+            target_dir=options.target_dir,
+            root_path=options.root_path,
+            isolated_mode=options.isolated_mode,
+        )
+
+        target_temp_dir = None  # type: Optional[TempDirectory]
+        target_temp_dir_path = None  # type: Optional[str]
+        if options.target_dir:
+            options.ignore_installed = True
+            options.target_dir = os.path.abspath(options.target_dir)
+            if (os.path.exists(options.target_dir) and not
+                    os.path.isdir(options.target_dir)):
+                raise CommandError(
+                    "Target path exists but is not a directory, will not "
+                    "continue."
+                )
+
+            # Create a target directory for using with the target option
+            target_temp_dir = TempDirectory(kind="target")
+            target_temp_dir_path = target_temp_dir.path
+            self.enter_context(target_temp_dir)
+
+        global_options = options.global_options or []
+
+        session = self.get_default_session(options)
+
+        target_python = make_target_python(options)
+        finder = self._build_package_finder(
+            options=options,
+            session=session,
+            target_python=target_python,
+            ignore_requires_python=options.ignore_requires_python,
+        )
+        build_delete = (not (options.no_clean or options.build_dir))
+        wheel_cache = WheelCache(options.cache_dir, options.format_control)
+
+        req_tracker = self.enter_context(get_requirement_tracker())
+
+        directory = TempDirectory(
+            options.build_dir,
+            delete=build_delete,
+            kind="install",
+            globally_managed=True,
+        )
+
+        try:
+            reqs = self.get_requirements(args, options, finder, session)
+
+            reject_location_related_install_options(
+                reqs, options.install_options
+            )
+
+            preparer = self.make_requirement_preparer(
+                temp_build_dir=directory,
+                options=options,
+                req_tracker=req_tracker,
+                session=session,
+                finder=finder,
+                use_user_site=options.use_user_site,
+            )
+            resolver = self.make_resolver(
+                preparer=preparer,
+                finder=finder,
+                options=options,
+                wheel_cache=wheel_cache,
+                use_user_site=options.use_user_site,
+                ignore_installed=options.ignore_installed,
+                ignore_requires_python=options.ignore_requires_python,
+                force_reinstall=options.force_reinstall,
+                upgrade_strategy=upgrade_strategy,
+                use_pep517=options.use_pep517,
+            )
+
+            self.trace_basic_info(finder)
+
+            requirement_set = resolver.resolve(
+                reqs, check_supported_wheels=not options.target_dir
+            )
+
+            try:
+                pip_req = requirement_set.get_requirement("pip")
+            except KeyError:
+                modifying_pip = False
+            else:
+                # If we're not replacing an already installed pip,
+                # we're not modifying it.
+                modifying_pip = pip_req.satisfied_by is None
+            protect_pip_from_modification_on_windows(
+                modifying_pip=modifying_pip
+            )
+
+            check_binary_allowed = get_check_binary_allowed(
+                finder.format_control
+            )
+
+            reqs_to_build = [
+                r for r in requirement_set.requirements.values()
+                if should_build_for_install_command(
+                    r, check_binary_allowed
+                )
+            ]
+
+            _, build_failures = build(
+                reqs_to_build,
+                wheel_cache=wheel_cache,
+                build_options=[],
+                global_options=[],
+            )
+
+            # If we're using PEP 517, we cannot do a direct install
+            # so we fail here.
+            pep517_build_failure_names = [
+                r.name   # type: ignore
+                for r in build_failures if r.use_pep517
+            ]  # type: List[str]
+            if pep517_build_failure_names:
+                raise InstallationError(
+                    "Could not build wheels for {} which use"
+                    " PEP 517 and cannot be installed directly".format(
+                        ", ".join(pep517_build_failure_names)
+                    )
+                )
+
+            # For now, we just warn about failures building legacy
+            # requirements, as we'll fall through to a direct
+            # install for those.
+            for r in build_failures:
+                if not r.use_pep517:
+                    r.legacy_install_reason = 8368
+
+            to_install = resolver.get_installation_order(
+                requirement_set
+            )
+
+            # Check for conflicts in the package set we're installing.
+            conflicts = None  # type: Optional[ConflictDetails]
+            should_warn_about_conflicts = (
+                not options.ignore_dependencies and
+                options.warn_about_conflicts
+            )
+            if should_warn_about_conflicts:
+                conflicts = self._determine_conflicts(to_install)
+
+            # Don't warn about script install locations if
+            # --target has been specified
+            warn_script_location = options.warn_script_location
+            if options.target_dir:
+                warn_script_location = False
+
+            installed = install_given_reqs(
+                to_install,
+                install_options,
+                global_options,
+                root=options.root_path,
+                home=target_temp_dir_path,
+                prefix=options.prefix_path,
+                warn_script_location=warn_script_location,
+                use_user_site=options.use_user_site,
+                pycompile=options.compile,
+            )
+
+            lib_locations = get_lib_location_guesses(
+                user=options.use_user_site,
+                home=target_temp_dir_path,
+                root=options.root_path,
+                prefix=options.prefix_path,
+                isolated=options.isolated_mode,
+            )
+            working_set = pkg_resources.WorkingSet(lib_locations)
+
+            installed.sort(key=operator.attrgetter('name'))
+            items = []
+            for result in installed:
+                item = result.name
+                try:
+                    installed_version = get_installed_version(
+                        result.name, working_set=working_set
+                    )
+                    if installed_version:
+                        item += '-' + installed_version
+                except Exception:
+                    pass
+                items.append(item)
+
+            if conflicts is not None:
+                self._warn_about_conflicts(
+                    conflicts,
+                    new_resolver='2020-resolver' in options.features_enabled,
+                )
+
+            installed_desc = ' '.join(items)
+            if installed_desc:
+                write_output(
+                    'Successfully installed %s', installed_desc,
+                )
+        except EnvironmentError as error:
+            show_traceback = (self.verbosity >= 1)
+
+            message = create_env_error_message(
+                error, show_traceback, options.use_user_site,
+            )
+            logger.error(message, exc_info=show_traceback)  # noqa
+
+            return ERROR
+
+        if options.target_dir:
+            assert target_temp_dir
+            self._handle_target_dir(
+                options.target_dir, target_temp_dir, options.upgrade
+            )
+
+        return SUCCESS
+
+    def _handle_target_dir(self, target_dir, target_temp_dir, upgrade):
+        # type: (str, TempDirectory, bool) -> None
+        ensure_dir(target_dir)
+
+        # Checking both purelib and platlib directories for installed
+        # packages to be moved to target directory
+        lib_dir_list = []
+
+        # Checking both purelib and platlib directories for installed
+        # packages to be moved to target directory
+        scheme = distutils_scheme('', home=target_temp_dir.path)
+        purelib_dir = scheme['purelib']
+        platlib_dir = scheme['platlib']
+        data_dir = scheme['data']
+
+        if os.path.exists(purelib_dir):
+            lib_dir_list.append(purelib_dir)
+        if os.path.exists(platlib_dir) and platlib_dir != purelib_dir:
+            lib_dir_list.append(platlib_dir)
+        if os.path.exists(data_dir):
+            lib_dir_list.append(data_dir)
+
+        for lib_dir in lib_dir_list:
+            for item in os.listdir(lib_dir):
+                if lib_dir == data_dir:
+                    ddir = os.path.join(data_dir, item)
+                    if any(s.startswith(ddir) for s in lib_dir_list[:-1]):
+                        continue
+                target_item_dir = os.path.join(target_dir, item)
+                if os.path.exists(target_item_dir):
+                    if not upgrade:
+                        logger.warning(
+                            'Target directory %s already exists. Specify '
+                            '--upgrade to force replacement.',
+                            target_item_dir
+                        )
+                        continue
+                    if os.path.islink(target_item_dir):
+                        logger.warning(
+                            'Target directory %s already exists and is '
+                            'a link. pip will not automatically replace '
+                            'links, please remove if replacement is '
+                            'desired.',
+                            target_item_dir
+                        )
+                        continue
+                    if os.path.isdir(target_item_dir):
+                        shutil.rmtree(target_item_dir)
+                    else:
+                        os.remove(target_item_dir)
+
+                shutil.move(
+                    os.path.join(lib_dir, item),
+                    target_item_dir
+                )
+
+    def _determine_conflicts(self, to_install):
+        # type: (List[InstallRequirement]) -> Optional[ConflictDetails]
+        try:
+            return check_install_conflicts(to_install)
+        except Exception:
+            logger.exception(
+                "Error while checking for conflicts. Please file an issue on "
+                "pip's issue tracker: https://github.com/pypa/pip/issues/new"
+            )
+            return None
+
+    def _warn_about_conflicts(self, conflict_details, new_resolver):
+        # type: (ConflictDetails, bool) -> None
+        package_set, (missing, conflicting) = conflict_details
+        if not missing and not conflicting:
+            return
+
+        parts = []  # type: List[str]
+        if not new_resolver:
+            parts.append(
+                "After October 2020 you may experience errors when installing "
+                "or updating packages. This is because pip will change the "
+                "way that it resolves dependency conflicts.\n"
+            )
+            parts.append(
+                "We recommend you use --use-feature=2020-resolver to test "
+                "your packages with the new resolver before it becomes the "
+                "default.\n"
+            )
+        elif not today_is_later_than(year=2020, month=7, day=31):
+            # NOTE: trailing newlines here are intentional
+            parts.append(
+                "Pip will install or upgrade your package(s) and its "
+                "dependencies without taking into account other packages you "
+                "already have installed. This may cause an uncaught "
+                "dependency conflict.\n"
+            )
+            form_link = "https://forms.gle/cWKMoDs8sUVE29hz9"
+            parts.append(
+                "If you would like pip to take your other packages into "
+                "account, please tell us here: {}\n".format(form_link)
+            )
+
+        # NOTE: There is some duplication here, with commands/check.py
+        for project_name in missing:
+            version = package_set[project_name][0]
+            for dependency in missing[project_name]:
+                message = (
+                    "{name} {version} requires {requirement}, "
+                    "which is not installed."
+                ).format(
+                    name=project_name,
+                    version=version,
+                    requirement=dependency[1],
+                )
+                parts.append(message)
+
+        for project_name in conflicting:
+            version = package_set[project_name][0]
+            for dep_name, dep_version, req in conflicting[project_name]:
+                message = (
+                    "{name} {version} requires {requirement}, but you'll have "
+                    "{dep_name} {dep_version} which is incompatible."
+                ).format(
+                    name=project_name,
+                    version=version,
+                    requirement=req,
+                    dep_name=dep_name,
+                    dep_version=dep_version,
+                )
+                parts.append(message)
+
+        logger.critical("\n".join(parts))
+
+
+def get_lib_location_guesses(
+        user=False,  # type: bool
+        home=None,  # type: Optional[str]
+        root=None,  # type: Optional[str]
+        isolated=False,  # type: bool
+        prefix=None  # type: Optional[str]
+):
+    # type:(...) -> List[str]
+    scheme = distutils_scheme('', user=user, home=home, root=root,
+                              isolated=isolated, prefix=prefix)
+    return [scheme['purelib'], scheme['platlib']]
+
+
+def site_packages_writable(root, isolated):
+    # type: (Optional[str], bool) -> bool
+    return all(
+        test_writable_dir(d) for d in set(
+            get_lib_location_guesses(root=root, isolated=isolated))
+    )
+
+
+def decide_user_install(
+    use_user_site,  # type: Optional[bool]
+    prefix_path=None,  # type: Optional[str]
+    target_dir=None,  # type: Optional[str]
+    root_path=None,  # type: Optional[str]
+    isolated_mode=False,  # type: bool
+):
+    # type: (...) -> bool
+    """Determine whether to do a user install based on the input options.
+
+    If use_user_site is False, no additional checks are done.
+    If use_user_site is True, it is checked for compatibility with other
+    options.
+    If use_user_site is None, the default behaviour depends on the environment,
+    which is provided by the other arguments.
+    """
+    # In some cases (config from tox), use_user_site can be set to an integer
+    # rather than a bool, which 'use_user_site is False' wouldn't catch.
+    if (use_user_site is not None) and (not use_user_site):
+        logger.debug("Non-user install by explicit request")
+        return False
+
+    if use_user_site:
+        if prefix_path:
+            raise CommandError(
+                "Can not combine '--user' and '--prefix' as they imply "
+                "different installation locations"
+            )
+        if virtualenv_no_global():
+            raise InstallationError(
+                "Can not perform a '--user' install. User site-packages "
+                "are not visible in this virtualenv."
+            )
+        logger.debug("User install by explicit request")
+        return True
+
+    # If we are here, user installs have not been explicitly requested/avoided
+    assert use_user_site is None
+
+    # user install incompatible with --prefix/--target
+    if prefix_path or target_dir:
+        logger.debug("Non-user install due to --prefix or --target option")
+        return False
+
+    # If user installs are not enabled, choose a non-user install
+    if not site.ENABLE_USER_SITE:
+        logger.debug("Non-user install because user site-packages disabled")
+        return False
+
+    # If we have permission for a non-user install, do that,
+    # otherwise do a user install.
+    if site_packages_writable(root=root_path, isolated=isolated_mode):
+        logger.debug("Non-user install because site-packages writeable")
+        return False
+
+    logger.info("Defaulting to user installation because normal site-packages "
+                "is not writeable")
+    return True
+
+
+def reject_location_related_install_options(requirements, options):
+    # type: (List[InstallRequirement], Optional[List[str]]) -> None
+    """If any location-changing --install-option arguments were passed for
+    requirements or on the command-line, then show a deprecation warning.
+    """
+    def format_options(option_names):
+        # type: (Iterable[str]) -> List[str]
+        return ["--{}".format(name.replace("_", "-")) for name in option_names]
+
+    offenders = []
+
+    for requirement in requirements:
+        install_options = requirement.install_options
+        location_options = parse_distutils_args(install_options)
+        if location_options:
+            offenders.append(
+                "{!r} from {}".format(
+                    format_options(location_options.keys()), requirement
+                )
+            )
+
+    if options:
+        location_options = parse_distutils_args(options)
+        if location_options:
+            offenders.append(
+                "{!r} from command line".format(
+                    format_options(location_options.keys())
+                )
+            )
+
+    if not offenders:
+        return
+
+    raise CommandError(
+        "Location-changing options found in --install-option: {}."
+        " This is unsupported, use pip-level options like --user,"
+        " --prefix, --root, and --target instead.".format(
+            "; ".join(offenders)
+        )
+    )
+
+
+def create_env_error_message(error, show_traceback, using_user_site):
+    # type: (EnvironmentError, bool, bool) -> str
+    """Format an error message for an EnvironmentError
+
+    It may occur anytime during the execution of the install command.
+    """
+    parts = []
+
+    # Mention the error if we are not going to show a traceback
+    parts.append("Could not install packages due to an EnvironmentError")
+    if not show_traceback:
+        parts.append(": ")
+        parts.append(str(error))
+    else:
+        parts.append(".")
+
+    # Spilt the error indication from a helper message (if any)
+    parts[-1] += "\n"
+
+    # Suggest useful actions to the user:
+    #  (1) using user site-packages or (2) verifying the permissions
+    if error.errno == errno.EACCES:
+        user_option_part = "Consider using the `--user` option"
+        permissions_part = "Check the permissions"
+
+        if not using_user_site:
+            parts.extend([
+                user_option_part, " or ",
+                permissions_part.lower(),
+            ])
+        else:
+            parts.append(permissions_part)
+        parts.append(".\n")
+
+    return "".join(parts).strip() + "\n"
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/list.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/list.py
new file mode 100644
index 0000000..20e9bff
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/list.py
@@ -0,0 +1,320 @@
+from __future__ import absolute_import
+
+import json
+import logging
+
+from pip._vendor import six
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.req_command import IndexGroupCommand
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.exceptions import CommandError
+from pip._internal.index.collector import LinkCollector
+from pip._internal.index.package_finder import PackageFinder
+from pip._internal.models.selection_prefs import SelectionPreferences
+from pip._internal.utils.misc import (
+    dist_is_editable,
+    get_installed_distributions,
+    tabulate,
+    write_output,
+)
+from pip._internal.utils.packaging import get_installer
+from pip._internal.utils.parallel import map_multithread
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import List, Set, Tuple, Iterator
+
+    from pip._internal.network.session import PipSession
+    from pip._vendor.pkg_resources import Distribution
+
+logger = logging.getLogger(__name__)
+
+
+class ListCommand(IndexGroupCommand):
+    """
+    List installed packages, including editables.
+
+    Packages are listed in a case-insensitive sorted order.
+    """
+
+    ignore_require_venv = True
+    usage = """
+      %prog [options]"""
+
+    def add_options(self):
+        # type: () -> None
+        self.cmd_opts.add_option(
+            '-o', '--outdated',
+            action='store_true',
+            default=False,
+            help='List outdated packages')
+        self.cmd_opts.add_option(
+            '-u', '--uptodate',
+            action='store_true',
+            default=False,
+            help='List uptodate packages')
+        self.cmd_opts.add_option(
+            '-e', '--editable',
+            action='store_true',
+            default=False,
+            help='List editable projects.')
+        self.cmd_opts.add_option(
+            '-l', '--local',
+            action='store_true',
+            default=False,
+            help=('If in a virtualenv that has global access, do not list '
+                  'globally-installed packages.'),
+        )
+        self.cmd_opts.add_option(
+            '--user',
+            dest='user',
+            action='store_true',
+            default=False,
+            help='Only output packages installed in user-site.')
+        self.cmd_opts.add_option(cmdoptions.list_path())
+        self.cmd_opts.add_option(
+            '--pre',
+            action='store_true',
+            default=False,
+            help=("Include pre-release and development versions. By default, "
+                  "pip only finds stable versions."),
+        )
+
+        self.cmd_opts.add_option(
+            '--format',
+            action='store',
+            dest='list_format',
+            default="columns",
+            choices=('columns', 'freeze', 'json'),
+            help="Select the output format among: columns (default), freeze, "
+                 "or json",
+        )
+
+        self.cmd_opts.add_option(
+            '--not-required',
+            action='store_true',
+            dest='not_required',
+            help="List packages that are not dependencies of "
+                 "installed packages.",
+        )
+
+        self.cmd_opts.add_option(
+            '--exclude-editable',
+            action='store_false',
+            dest='include_editable',
+            help='Exclude editable package from output.',
+        )
+        self.cmd_opts.add_option(
+            '--include-editable',
+            action='store_true',
+            dest='include_editable',
+            help='Include editable package from output.',
+            default=True,
+        )
+        index_opts = cmdoptions.make_option_group(
+            cmdoptions.index_group, self.parser
+        )
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def _build_package_finder(self, options, session):
+        # type: (Values, PipSession) -> PackageFinder
+        """
+        Create a package finder appropriate to this list command.
+        """
+        link_collector = LinkCollector.create(session, options=options)
+
+        # Pass allow_yanked=False to ignore yanked versions.
+        selection_prefs = SelectionPreferences(
+            allow_yanked=False,
+            allow_all_prereleases=options.pre,
+        )
+
+        return PackageFinder.create(
+            link_collector=link_collector,
+            selection_prefs=selection_prefs,
+        )
+
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+        if options.outdated and options.uptodate:
+            raise CommandError(
+                "Options --outdated and --uptodate cannot be combined.")
+
+        cmdoptions.check_list_path_option(options)
+
+        packages = get_installed_distributions(
+            local_only=options.local,
+            user_only=options.user,
+            editables_only=options.editable,
+            include_editables=options.include_editable,
+            paths=options.path,
+        )
+
+        # get_not_required must be called firstly in order to find and
+        # filter out all dependencies correctly. Otherwise a package
+        # can't be identified as requirement because some parent packages
+        # could be filtered out before.
+        if options.not_required:
+            packages = self.get_not_required(packages, options)
+
+        if options.outdated:
+            packages = self.get_outdated(packages, options)
+        elif options.uptodate:
+            packages = self.get_uptodate(packages, options)
+
+        self.output_package_listing(packages, options)
+        return SUCCESS
+
+    def get_outdated(self, packages, options):
+        # type: (List[Distribution], Values) -> List[Distribution]
+        return [
+            dist for dist in self.iter_packages_latest_infos(packages, options)
+            if dist.latest_version > dist.parsed_version
+        ]
+
+    def get_uptodate(self, packages, options):
+        # type: (List[Distribution], Values) -> List[Distribution]
+        return [
+            dist for dist in self.iter_packages_latest_infos(packages, options)
+            if dist.latest_version == dist.parsed_version
+        ]
+
+    def get_not_required(self, packages, options):
+        # type: (List[Distribution], Values) -> List[Distribution]
+        dep_keys = set()  # type: Set[Distribution]
+        for dist in packages:
+            dep_keys.update(requirement.key for requirement in dist.requires())
+
+        # Create a set to remove duplicate packages, and cast it to a list
+        # to keep the return type consistent with get_outdated and
+        # get_uptodate
+        return list({pkg for pkg in packages if pkg.key not in dep_keys})
+
+    def iter_packages_latest_infos(self, packages, options):
+        # type: (List[Distribution], Values) -> Iterator[Distribution]
+        with self._build_session(options) as session:
+            finder = self._build_package_finder(options, session)
+
+            def latest_info(dist):
+                # type: (Distribution) -> Distribution
+                typ = 'unknown'
+                all_candidates = finder.find_all_candidates(dist.key)
+                if not options.pre:
+                    # Remove prereleases
+                    all_candidates = [candidate for candidate in all_candidates
+                                      if not candidate.version.is_prerelease]
+
+                evaluator = finder.make_candidate_evaluator(
+                    project_name=dist.project_name,
+                )
+                best_candidate = evaluator.sort_best_candidate(all_candidates)
+                if best_candidate is None:
+                    return None
+
+                remote_version = best_candidate.version
+                if best_candidate.link.is_wheel:
+                    typ = 'wheel'
+                else:
+                    typ = 'sdist'
+                # This is dirty but makes the rest of the code much cleaner
+                dist.latest_version = remote_version
+                dist.latest_filetype = typ
+                return dist
+
+            for dist in map_multithread(latest_info, packages):
+                if dist is not None:
+                    yield dist
+
+    def output_package_listing(self, packages, options):
+        # type: (List[Distribution], Values) -> None
+        packages = sorted(
+            packages,
+            key=lambda dist: dist.project_name.lower(),
+        )
+        if options.list_format == 'columns' and packages:
+            data, header = format_for_columns(packages, options)
+            self.output_package_listing_columns(data, header)
+        elif options.list_format == 'freeze':
+            for dist in packages:
+                if options.verbose >= 1:
+                    write_output("%s==%s (%s)", dist.project_name,
+                                 dist.version, dist.location)
+                else:
+                    write_output("%s==%s", dist.project_name, dist.version)
+        elif options.list_format == 'json':
+            write_output(format_for_json(packages, options))
+
+    def output_package_listing_columns(self, data, header):
+        # type: (List[List[str]], List[str]) -> None
+        # insert the header first: we need to know the size of column names
+        if len(data) > 0:
+            data.insert(0, header)
+
+        pkg_strings, sizes = tabulate(data)
+
+        # Create and add a separator.
+        if len(data) > 0:
+            pkg_strings.insert(1, " ".join(map(lambda x: '-' * x, sizes)))
+
+        for val in pkg_strings:
+            write_output(val)
+
+
+def format_for_columns(pkgs, options):
+    # type: (List[Distribution], Values) -> Tuple[List[List[str]], List[str]]
+    """
+    Convert the package data into something usable
+    by output_package_listing_columns.
+    """
+    running_outdated = options.outdated
+    # Adjust the header for the `pip list --outdated` case.
+    if running_outdated:
+        header = ["Package", "Version", "Latest", "Type"]
+    else:
+        header = ["Package", "Version"]
+
+    data = []
+    if options.verbose >= 1 or any(dist_is_editable(x) for x in pkgs):
+        header.append("Location")
+    if options.verbose >= 1:
+        header.append("Installer")
+
+    for proj in pkgs:
+        # if we're working on the 'outdated' list, separate out the
+        # latest_version and type
+        row = [proj.project_name, proj.version]
+
+        if running_outdated:
+            row.append(proj.latest_version)
+            row.append(proj.latest_filetype)
+
+        if options.verbose >= 1 or dist_is_editable(proj):
+            row.append(proj.location)
+        if options.verbose >= 1:
+            row.append(get_installer(proj))
+
+        data.append(row)
+
+    return data, header
+
+
+def format_for_json(packages, options):
+    # type: (List[Distribution], Values) -> str
+    data = []
+    for dist in packages:
+        info = {
+            'name': dist.project_name,
+            'version': six.text_type(dist.version),
+        }
+        if options.verbose >= 1:
+            info['location'] = dist.location
+            info['installer'] = get_installer(dist)
+        if options.outdated:
+            info['latest_version'] = six.text_type(dist.latest_version)
+            info['latest_filetype'] = dist.latest_filetype
+        data.append(info)
+    return json.dumps(data)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/search.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/search.py
new file mode 100644
index 0000000..ff09472
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/search.py
@@ -0,0 +1,160 @@
+from __future__ import absolute_import
+
+import logging
+import sys
+import textwrap
+from collections import OrderedDict
+
+from pip._vendor import pkg_resources
+from pip._vendor.packaging.version import parse as parse_version
+# NOTE: XMLRPC Client is not annotated in typeshed as on 2017-07-17, which is
+#       why we ignore the type on this import
+from pip._vendor.six.moves import xmlrpc_client  # type: ignore
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.req_command import SessionCommandMixin
+from pip._internal.cli.status_codes import NO_MATCHES_FOUND, SUCCESS
+from pip._internal.exceptions import CommandError
+from pip._internal.models.index import PyPI
+from pip._internal.network.xmlrpc import PipXmlrpcTransport
+from pip._internal.utils.compat import get_terminal_size
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import get_distribution, write_output
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import List, Dict, Optional
+    from typing_extensions import TypedDict
+    TransformedHit = TypedDict(
+        'TransformedHit',
+        {'name': str, 'summary': str, 'versions': List[str]},
+    )
+
+logger = logging.getLogger(__name__)
+
+
+class SearchCommand(Command, SessionCommandMixin):
+    """Search for PyPI packages whose name or summary contains <query>."""
+
+    usage = """
+      %prog [options] <query>"""
+    ignore_require_venv = True
+
+    def add_options(self):
+        # type: () -> None
+        self.cmd_opts.add_option(
+            '-i', '--index',
+            dest='index',
+            metavar='URL',
+            default=PyPI.pypi_url,
+            help='Base URL of Python Package Index (default %default)')
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+        if not args:
+            raise CommandError('Missing required argument (search query).')
+        query = args
+        pypi_hits = self.search(query, options)
+        hits = transform_hits(pypi_hits)
+
+        terminal_width = None
+        if sys.stdout.isatty():
+            terminal_width = get_terminal_size()[0]
+
+        print_results(hits, terminal_width=terminal_width)
+        if pypi_hits:
+            return SUCCESS
+        return NO_MATCHES_FOUND
+
+    def search(self, query, options):
+        # type: (List[str], Values) -> List[Dict[str, str]]
+        index_url = options.index
+
+        session = self.get_default_session(options)
+
+        transport = PipXmlrpcTransport(index_url, session)
+        pypi = xmlrpc_client.ServerProxy(index_url, transport)
+        hits = pypi.search({'name': query, 'summary': query}, 'or')
+        return hits
+
+
+def transform_hits(hits):
+    # type: (List[Dict[str, str]]) -> List[TransformedHit]
+    """
+    The list from pypi is really a list of versions. We want a list of
+    packages with the list of versions stored inline. This converts the
+    list from pypi into one we can use.
+    """
+    packages = OrderedDict()  # type: OrderedDict[str, TransformedHit]
+    for hit in hits:
+        name = hit['name']
+        summary = hit['summary']
+        version = hit['version']
+
+        if name not in packages.keys():
+            packages[name] = {
+                'name': name,
+                'summary': summary,
+                'versions': [version],
+            }
+        else:
+            packages[name]['versions'].append(version)
+
+            # if this is the highest version, replace summary and score
+            if version == highest_version(packages[name]['versions']):
+                packages[name]['summary'] = summary
+
+    return list(packages.values())
+
+
+def print_results(hits, name_column_width=None, terminal_width=None):
+    # type: (List[TransformedHit], Optional[int], Optional[int]) -> None
+    if not hits:
+        return
+    if name_column_width is None:
+        name_column_width = max([
+            len(hit['name']) + len(highest_version(hit.get('versions', ['-'])))
+            for hit in hits
+        ]) + 4
+
+    installed_packages = [p.project_name for p in pkg_resources.working_set]
+    for hit in hits:
+        name = hit['name']
+        summary = hit['summary'] or ''
+        latest = highest_version(hit.get('versions', ['-']))
+        if terminal_width is not None:
+            target_width = terminal_width - name_column_width - 5
+            if target_width > 10:
+                # wrap and indent summary to fit terminal
+                summary_lines = textwrap.wrap(summary, target_width)
+                summary = ('\n' + ' ' * (name_column_width + 3)).join(
+                    summary_lines)
+
+        line = '{name_latest:{name_column_width}} - {summary}'.format(
+            name_latest='{name} ({latest})'.format(**locals()),
+            **locals())
+        try:
+            write_output(line)
+            if name in installed_packages:
+                dist = get_distribution(name)
+                assert dist is not None
+                with indent_log():
+                    if dist.version == latest:
+                        write_output('INSTALLED: %s (latest)', dist.version)
+                    else:
+                        write_output('INSTALLED: %s', dist.version)
+                        if parse_version(latest).pre:
+                            write_output('LATEST:    %s (pre-release; install'
+                                         ' with "pip install --pre")', latest)
+                        else:
+                            write_output('LATEST:    %s', latest)
+        except UnicodeEncodeError:
+            pass
+
+
+def highest_version(versions):
+    # type: (List[str]) -> str
+    return max(versions, key=parse_version)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/show.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/show.py
new file mode 100644
index 0000000..3892c59
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/show.py
@@ -0,0 +1,186 @@
+from __future__ import absolute_import
+
+import logging
+import os
+from email.parser import FeedParser
+
+from pip._vendor import pkg_resources
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.utils.misc import write_output
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import List, Dict, Iterator
+
+logger = logging.getLogger(__name__)
+
+
+class ShowCommand(Command):
+    """
+    Show information about one or more installed packages.
+
+    The output is in RFC-compliant mail header format.
+    """
+
+    usage = """
+      %prog [options] <package> ..."""
+    ignore_require_venv = True
+
+    def add_options(self):
+        # type: () -> None
+        self.cmd_opts.add_option(
+            '-f', '--files',
+            dest='files',
+            action='store_true',
+            default=False,
+            help='Show the full list of installed files for each package.')
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+        if not args:
+            logger.warning('ERROR: Please provide a package name or names.')
+            return ERROR
+        query = args
+
+        results = search_packages_info(query)
+        if not print_results(
+                results, list_files=options.files, verbose=options.verbose):
+            return ERROR
+        return SUCCESS
+
+
+def search_packages_info(query):
+    # type: (List[str]) -> Iterator[Dict[str, str]]
+    """
+    Gather details from installed distributions. Print distribution name,
+    version, location, and installed files. Installed files requires a
+    pip generated 'installed-files.txt' in the distributions '.egg-info'
+    directory.
+    """
+    installed = {}
+    for p in pkg_resources.working_set:
+        installed[canonicalize_name(p.project_name)] = p
+
+    query_names = [canonicalize_name(name) for name in query]
+    missing = sorted(
+        [name for name, pkg in zip(query, query_names) if pkg not in installed]
+    )
+    if missing:
+        logger.warning('Package(s) not found: %s', ', '.join(missing))
+
+    def get_requiring_packages(package_name):
+        # type: (str) -> List[str]
+        canonical_name = canonicalize_name(package_name)
+        return [
+            pkg.project_name for pkg in pkg_resources.working_set
+            if canonical_name in
+               [canonicalize_name(required.name) for required in
+                pkg.requires()]
+        ]
+
+    for dist in [installed[pkg] for pkg in query_names if pkg in installed]:
+        package = {
+            'name': dist.project_name,
+            'version': dist.version,
+            'location': dist.location,
+            'requires': [dep.project_name for dep in dist.requires()],
+            'required_by': get_requiring_packages(dist.project_name)
+        }
+        file_list = None
+        metadata = ''
+        if isinstance(dist, pkg_resources.DistInfoDistribution):
+            # RECORDs should be part of .dist-info metadatas
+            if dist.has_metadata('RECORD'):
+                lines = dist.get_metadata_lines('RECORD')
+                paths = [line.split(',')[0] for line in lines]
+                paths = [os.path.join(dist.location, p) for p in paths]
+                file_list = [os.path.relpath(p, dist.location) for p in paths]
+
+            if dist.has_metadata('METADATA'):
+                metadata = dist.get_metadata('METADATA')
+        else:
+            # Otherwise use pip's log for .egg-info's
+            if dist.has_metadata('installed-files.txt'):
+                paths = dist.get_metadata_lines('installed-files.txt')
+                paths = [os.path.join(dist.egg_info, p) for p in paths]
+                file_list = [os.path.relpath(p, dist.location) for p in paths]
+
+            if dist.has_metadata('PKG-INFO'):
+                metadata = dist.get_metadata('PKG-INFO')
+
+        if dist.has_metadata('entry_points.txt'):
+            entry_points = dist.get_metadata_lines('entry_points.txt')
+            package['entry_points'] = entry_points
+
+        if dist.has_metadata('INSTALLER'):
+            for line in dist.get_metadata_lines('INSTALLER'):
+                if line.strip():
+                    package['installer'] = line.strip()
+                    break
+
+        # @todo: Should pkg_resources.Distribution have a
+        # `get_pkg_info` method?
+        feed_parser = FeedParser()
+        feed_parser.feed(metadata)
+        pkg_info_dict = feed_parser.close()
+        for key in ('metadata-version', 'summary',
+                    'home-page', 'author', 'author-email', 'license'):
+            package[key] = pkg_info_dict.get(key)
+
+        # It looks like FeedParser cannot deal with repeated headers
+        classifiers = []
+        for line in metadata.splitlines():
+            if line.startswith('Classifier: '):
+                classifiers.append(line[len('Classifier: '):])
+        package['classifiers'] = classifiers
+
+        if file_list:
+            package['files'] = sorted(file_list)
+        yield package
+
+
+def print_results(distributions, list_files=False, verbose=False):
+    # type: (Iterator[Dict[str, str]], bool, bool) -> bool
+    """
+    Print the information from installed distributions found.
+    """
+    results_printed = False
+    for i, dist in enumerate(distributions):
+        results_printed = True
+        if i > 0:
+            write_output("---")
+
+        write_output("Name: %s", dist.get('name', ''))
+        write_output("Version: %s", dist.get('version', ''))
+        write_output("Summary: %s", dist.get('summary', ''))
+        write_output("Home-page: %s", dist.get('home-page', ''))
+        write_output("Author: %s", dist.get('author', ''))
+        write_output("Author-email: %s", dist.get('author-email', ''))
+        write_output("License: %s", dist.get('license', ''))
+        write_output("Location: %s", dist.get('location', ''))
+        write_output("Requires: %s", ', '.join(dist.get('requires', [])))
+        write_output("Required-by: %s", ', '.join(dist.get('required_by', [])))
+
+        if verbose:
+            write_output("Metadata-Version: %s",
+                         dist.get('metadata-version', ''))
+            write_output("Installer: %s", dist.get('installer', ''))
+            write_output("Classifiers:")
+            for classifier in dist.get('classifiers', []):
+                write_output("  %s", classifier)
+            write_output("Entry-points:")
+            for entry in dist.get('entry_points', []):
+                write_output("  %s", entry.strip())
+        if list_files:
+            write_output("Files:")
+            for line in dist.get('files', []):
+                write_output("  %s", line.strip())
+            if "files" not in dist:
+                write_output("Cannot locate installed-files.txt")
+    return results_printed
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/uninstall.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/uninstall.py
new file mode 100644
index 0000000..3371fe4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/uninstall.py
@@ -0,0 +1,95 @@
+from __future__ import absolute_import
+
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.req_command import SessionCommandMixin
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.exceptions import InstallationError
+from pip._internal.req import parse_requirements
+from pip._internal.req.constructors import (
+    install_req_from_line,
+    install_req_from_parsed_requirement,
+)
+from pip._internal.utils.misc import protect_pip_from_modification_on_windows
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import List
+
+
+class UninstallCommand(Command, SessionCommandMixin):
+    """
+    Uninstall packages.
+
+    pip is able to uninstall most installed packages. Known exceptions are:
+
+    - Pure distutils packages installed with ``python setup.py install``, which
+      leave behind no metadata to determine what files were installed.
+    - Script wrappers installed by ``python setup.py develop``.
+    """
+
+    usage = """
+      %prog [options] <package> ...
+      %prog [options] -r <requirements file> ..."""
+
+    def add_options(self):
+        # type: () -> None
+        self.cmd_opts.add_option(
+            '-r', '--requirement',
+            dest='requirements',
+            action='append',
+            default=[],
+            metavar='file',
+            help='Uninstall all the packages listed in the given requirements '
+                 'file.  This option can be used multiple times.',
+        )
+        self.cmd_opts.add_option(
+            '-y', '--yes',
+            dest='yes',
+            action='store_true',
+            help="Don't ask for confirmation of uninstall deletions.")
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+        session = self.get_default_session(options)
+
+        reqs_to_uninstall = {}
+        for name in args:
+            req = install_req_from_line(
+                name, isolated=options.isolated_mode,
+            )
+            if req.name:
+                reqs_to_uninstall[canonicalize_name(req.name)] = req
+        for filename in options.requirements:
+            for parsed_req in parse_requirements(
+                    filename,
+                    options=options,
+                    session=session):
+                req = install_req_from_parsed_requirement(
+                    parsed_req,
+                    isolated=options.isolated_mode
+                )
+                if req.name:
+                    reqs_to_uninstall[canonicalize_name(req.name)] = req
+        if not reqs_to_uninstall:
+            raise InstallationError(
+                'You must give at least one requirement to {self.name} (see '
+                '"pip help {self.name}")'.format(**locals())
+            )
+
+        protect_pip_from_modification_on_windows(
+            modifying_pip="pip" in reqs_to_uninstall
+        )
+
+        for req in reqs_to_uninstall.values():
+            uninstall_pathset = req.uninstall(
+                auto_confirm=options.yes, verbose=self.verbosity > 0,
+            )
+            if uninstall_pathset:
+                uninstall_pathset.commit()
+
+        return SUCCESS
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/commands/wheel.py b/myenv/lib/python3.9/site-packages/pip/_internal/commands/wheel.py
new file mode 100644
index 0000000..0f71856
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/commands/wheel.py
@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+
+import logging
+import os
+import shutil
+
+from pip._internal.cache import WheelCache
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.req_command import RequirementCommand, with_cleanup
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.exceptions import CommandError
+from pip._internal.req.req_tracker import get_requirement_tracker
+from pip._internal.utils.misc import ensure_dir, normalize_path
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.wheel_builder import build, should_build_for_wheel_command
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import List
+
+
+logger = logging.getLogger(__name__)
+
+
+class WheelCommand(RequirementCommand):
+    """
+    Build Wheel archives for your requirements and dependencies.
+
+    Wheel is a built-package format, and offers the advantage of not
+    recompiling your software during every install. For more details, see the
+    wheel docs: https://wheel.readthedocs.io/en/latest/
+
+    Requirements: setuptools>=0.8, and wheel.
+
+    'pip wheel' uses the bdist_wheel setuptools extension from the wheel
+    package to build individual wheels.
+
+    """
+
+    usage = """
+      %prog [options] <requirement specifier> ...
+      %prog [options] -r <requirements file> ...
+      %prog [options] [-e] <vcs project url> ...
+      %prog [options] [-e] <local project path> ...
+      %prog [options] <archive url/path> ..."""
+
+    def add_options(self):
+        # type: () -> None
+
+        self.cmd_opts.add_option(
+            '-w', '--wheel-dir',
+            dest='wheel_dir',
+            metavar='dir',
+            default=os.curdir,
+            help=("Build wheels into <dir>, where the default is the "
+                  "current working directory."),
+        )
+        self.cmd_opts.add_option(cmdoptions.no_binary())
+        self.cmd_opts.add_option(cmdoptions.only_binary())
+        self.cmd_opts.add_option(cmdoptions.prefer_binary())
+        self.cmd_opts.add_option(
+            '--build-option',
+            dest='build_options',
+            metavar='options',
+            action='append',
+            help="Extra arguments to be supplied to 'setup.py bdist_wheel'.",
+        )
+        self.cmd_opts.add_option(cmdoptions.no_build_isolation())
+        self.cmd_opts.add_option(cmdoptions.use_pep517())
+        self.cmd_opts.add_option(cmdoptions.no_use_pep517())
+        self.cmd_opts.add_option(cmdoptions.constraints())
+        self.cmd_opts.add_option(cmdoptions.editable())
+        self.cmd_opts.add_option(cmdoptions.requirements())
+        self.cmd_opts.add_option(cmdoptions.src())
+        self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
+        self.cmd_opts.add_option(cmdoptions.no_deps())
+        self.cmd_opts.add_option(cmdoptions.build_dir())
+        self.cmd_opts.add_option(cmdoptions.progress_bar())
+
+        self.cmd_opts.add_option(
+            '--global-option',
+            dest='global_options',
+            action='append',
+            metavar='options',
+            help="Extra global options to be supplied to the setup.py "
+            "call before the 'bdist_wheel' command.")
+
+        self.cmd_opts.add_option(
+            '--pre',
+            action='store_true',
+            default=False,
+            help=("Include pre-release and development versions. By default, "
+                  "pip only finds stable versions."),
+        )
+
+        self.cmd_opts.add_option(cmdoptions.require_hashes())
+
+        index_opts = cmdoptions.make_option_group(
+            cmdoptions.index_group,
+            self.parser,
+        )
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    @with_cleanup
+    def run(self, options, args):
+        # type: (Values, List[str]) -> int
+        cmdoptions.check_install_build_global(options)
+
+        session = self.get_default_session(options)
+
+        finder = self._build_package_finder(options, session)
+        build_delete = (not (options.no_clean or options.build_dir))
+        wheel_cache = WheelCache(options.cache_dir, options.format_control)
+
+        options.wheel_dir = normalize_path(options.wheel_dir)
+        ensure_dir(options.wheel_dir)
+
+        req_tracker = self.enter_context(get_requirement_tracker())
+
+        directory = TempDirectory(
+            options.build_dir,
+            delete=build_delete,
+            kind="wheel",
+            globally_managed=True,
+        )
+
+        reqs = self.get_requirements(args, options, finder, session)
+
+        preparer = self.make_requirement_preparer(
+            temp_build_dir=directory,
+            options=options,
+            req_tracker=req_tracker,
+            session=session,
+            finder=finder,
+            wheel_download_dir=options.wheel_dir,
+            use_user_site=False,
+        )
+
+        resolver = self.make_resolver(
+            preparer=preparer,
+            finder=finder,
+            options=options,
+            wheel_cache=wheel_cache,
+            ignore_requires_python=options.ignore_requires_python,
+            use_pep517=options.use_pep517,
+        )
+
+        self.trace_basic_info(finder)
+
+        requirement_set = resolver.resolve(
+            reqs, check_supported_wheels=True
+        )
+
+        reqs_to_build = [
+            r for r in requirement_set.requirements.values()
+            if should_build_for_wheel_command(r)
+        ]
+
+        # build wheels
+        build_successes, build_failures = build(
+            reqs_to_build,
+            wheel_cache=wheel_cache,
+            build_options=options.build_options or [],
+            global_options=options.global_options or [],
+        )
+        for req in build_successes:
+            assert req.link and req.link.is_wheel
+            assert req.local_file_path
+            # copy from cache to target directory
+            try:
+                shutil.copy(req.local_file_path, options.wheel_dir)
+            except OSError as e:
+                logger.warning(
+                    "Building wheel for %s failed: %s",
+                    req.name, e,
+                )
+                build_failures.append(req)
+        if len(build_failures) != 0:
+            raise CommandError(
+                "Failed to build one or more wheels"
+            )
+
+        return SUCCESS
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/configuration.py b/myenv/lib/python3.9/site-packages/pip/_internal/configuration.py
new file mode 100644
index 0000000..e49a5f4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/configuration.py
@@ -0,0 +1,418 @@
+"""Configuration management setup
+
+Some terminology:
+- name
+  As written in config files.
+- value
+  Value associated with a name
+- key
+  Name combined with it's section (section.name)
+- variant
+  A single word describing where the configuration key-value pair came from
+"""
+
+import locale
+import logging
+import os
+import sys
+
+from pip._vendor.six.moves import configparser
+
+from pip._internal.exceptions import (
+    ConfigurationError,
+    ConfigurationFileCouldNotBeLoaded,
+)
+from pip._internal.utils import appdirs
+from pip._internal.utils.compat import WINDOWS, expanduser
+from pip._internal.utils.misc import ensure_dir, enum
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Any, Dict, Iterable, List, NewType, Optional, Tuple
+    )
+
+    RawConfigParser = configparser.RawConfigParser  # Shorthand
+    Kind = NewType("Kind", str)
+
+logger = logging.getLogger(__name__)
+
+
+# NOTE: Maybe use the optionx attribute to normalize keynames.
+def _normalize_name(name):
+    # type: (str) -> str
+    """Make a name consistent regardless of source (environment or file)
+    """
+    name = name.lower().replace('_', '-')
+    if name.startswith('--'):
+        name = name[2:]  # only prefer long opts
+    return name
+
+
+def _disassemble_key(name):
+    # type: (str) -> List[str]
+    if "." not in name:
+        error_message = (
+            "Key does not contain dot separated section and key. "
+            "Perhaps you wanted to use 'global.{}' instead?"
+        ).format(name)
+        raise ConfigurationError(error_message)
+    return name.split(".", 1)
+
+
+# The kinds of configurations there are.
+kinds = enum(
+    USER="user",        # User Specific
+    GLOBAL="global",    # System Wide
+    SITE="site",        # [Virtual] Environment Specific
+    ENV="env",          # from PIP_CONFIG_FILE
+    ENV_VAR="env-var",  # from Environment Variables
+)
+
+
+CONFIG_BASENAME = 'pip.ini' if WINDOWS else 'pip.conf'
+
+
+def get_configuration_files():
+    # type: () -> Dict[Kind, List[str]]
+    global_config_files = [
+        os.path.join(path, CONFIG_BASENAME)
+        for path in appdirs.site_config_dirs('pip')
+    ]
+
+    site_config_file = os.path.join(sys.prefix, CONFIG_BASENAME)
+    legacy_config_file = os.path.join(
+        expanduser('~'),
+        'pip' if WINDOWS else '.pip',
+        CONFIG_BASENAME,
+    )
+    new_config_file = os.path.join(
+        appdirs.user_config_dir("pip"), CONFIG_BASENAME
+    )
+    return {
+        kinds.GLOBAL: global_config_files,
+        kinds.SITE: [site_config_file],
+        kinds.USER: [legacy_config_file, new_config_file],
+    }
+
+
+class Configuration(object):
+    """Handles management of configuration.
+
+    Provides an interface to accessing and managing configuration files.
+
+    This class converts provides an API that takes "section.key-name" style
+    keys and stores the value associated with it as "key-name" under the
+    section "section".
+
+    This allows for a clean interface wherein the both the section and the
+    key-name are preserved in an easy to manage form in the configuration files
+    and the data stored is also nice.
+    """
+
+    def __init__(self, isolated, load_only=None):
+        # type: (bool, Optional[Kind]) -> None
+        super(Configuration, self).__init__()
+
+        _valid_load_only = [kinds.USER, kinds.GLOBAL, kinds.SITE, None]
+        if load_only not in _valid_load_only:
+            raise ConfigurationError(
+                "Got invalid value for load_only - should be one of {}".format(
+                    ", ".join(map(repr, _valid_load_only[:-1]))
+                )
+            )
+        self.isolated = isolated
+        self.load_only = load_only
+
+        # The order here determines the override order.
+        self._override_order = [
+            kinds.GLOBAL, kinds.USER, kinds.SITE, kinds.ENV, kinds.ENV_VAR
+        ]
+
+        self._ignore_env_names = ["version", "help"]
+
+        # Because we keep track of where we got the data from
+        self._parsers = {
+            variant: [] for variant in self._override_order
+        }  # type: Dict[Kind, List[Tuple[str, RawConfigParser]]]
+        self._config = {
+            variant: {} for variant in self._override_order
+        }  # type: Dict[Kind, Dict[str, Any]]
+        self._modified_parsers = []  # type: List[Tuple[str, RawConfigParser]]
+
+    def load(self):
+        # type: () -> None
+        """Loads configuration from configuration files and environment
+        """
+        self._load_config_files()
+        if not self.isolated:
+            self._load_environment_vars()
+
+    def get_file_to_edit(self):
+        # type: () -> Optional[str]
+        """Returns the file with highest priority in configuration
+        """
+        assert self.load_only is not None, \
+            "Need to be specified a file to be editing"
+
+        try:
+            return self._get_parser_to_modify()[0]
+        except IndexError:
+            return None
+
+    def items(self):
+        # type: () -> Iterable[Tuple[str, Any]]
+        """Returns key-value pairs like dict.items() representing the loaded
+        configuration
+        """
+        return self._dictionary.items()
+
+    def get_value(self, key):
+        # type: (str) -> Any
+        """Get a value from the configuration.
+        """
+        try:
+            return self._dictionary[key]
+        except KeyError:
+            raise ConfigurationError("No such key - {}".format(key))
+
+    def set_value(self, key, value):
+        # type: (str, Any) -> None
+        """Modify a value in the configuration.
+        """
+        self._ensure_have_load_only()
+
+        assert self.load_only
+        fname, parser = self._get_parser_to_modify()
+
+        if parser is not None:
+            section, name = _disassemble_key(key)
+
+            # Modify the parser and the configuration
+            if not parser.has_section(section):
+                parser.add_section(section)
+            parser.set(section, name, value)
+
+        self._config[self.load_only][key] = value
+        self._mark_as_modified(fname, parser)
+
+    def unset_value(self, key):
+        # type: (str) -> None
+        """Unset a value in the configuration."""
+        self._ensure_have_load_only()
+
+        assert self.load_only
+        if key not in self._config[self.load_only]:
+            raise ConfigurationError("No such key - {}".format(key))
+
+        fname, parser = self._get_parser_to_modify()
+
+        if parser is not None:
+            section, name = _disassemble_key(key)
+            if not (parser.has_section(section)
+                    and parser.remove_option(section, name)):
+                # The option was not removed.
+                raise ConfigurationError(
+                    "Fatal Internal error [id=1]. Please report as a bug."
+                )
+
+            # The section may be empty after the option was removed.
+            if not parser.items(section):
+                parser.remove_section(section)
+            self._mark_as_modified(fname, parser)
+
+        del self._config[self.load_only][key]
+
+    def save(self):
+        # type: () -> None
+        """Save the current in-memory state.
+        """
+        self._ensure_have_load_only()
+
+        for fname, parser in self._modified_parsers:
+            logger.info("Writing to %s", fname)
+
+            # Ensure directory exists.
+            ensure_dir(os.path.dirname(fname))
+
+            with open(fname, "w") as f:
+                parser.write(f)
+
+    #
+    # Private routines
+    #
+
+    def _ensure_have_load_only(self):
+        # type: () -> None
+        if self.load_only is None:
+            raise ConfigurationError("Needed a specific file to be modifying.")
+        logger.debug("Will be working with %s variant only", self.load_only)
+
+    @property
+    def _dictionary(self):
+        # type: () -> Dict[str, Any]
+        """A dictionary representing the loaded configuration.
+        """
+        # NOTE: Dictionaries are not populated if not loaded. So, conditionals
+        #       are not needed here.
+        retval = {}
+
+        for variant in self._override_order:
+            retval.update(self._config[variant])
+
+        return retval
+
+    def _load_config_files(self):
+        # type: () -> None
+        """Loads configuration from configuration files
+        """
+        config_files = dict(self.iter_config_files())
+        if config_files[kinds.ENV][0:1] == [os.devnull]:
+            logger.debug(
+                "Skipping loading configuration files due to "
+                "environment's PIP_CONFIG_FILE being os.devnull"
+            )
+            return
+
+        for variant, files in config_files.items():
+            for fname in files:
+                # If there's specific variant set in `load_only`, load only
+                # that variant, not the others.
+                if self.load_only is not None and variant != self.load_only:
+                    logger.debug(
+                        "Skipping file '%s' (variant: %s)", fname, variant
+                    )
+                    continue
+
+                parser = self._load_file(variant, fname)
+
+                # Keeping track of the parsers used
+                self._parsers[variant].append((fname, parser))
+
+    def _load_file(self, variant, fname):
+        # type: (Kind, str) -> RawConfigParser
+        logger.debug("For variant '%s', will try loading '%s'", variant, fname)
+        parser = self._construct_parser(fname)
+
+        for section in parser.sections():
+            items = parser.items(section)
+            self._config[variant].update(self._normalized_keys(section, items))
+
+        return parser
+
+    def _construct_parser(self, fname):
+        # type: (str) -> RawConfigParser
+        parser = configparser.RawConfigParser()
+        # If there is no such file, don't bother reading it but create the
+        # parser anyway, to hold the data.
+        # Doing this is useful when modifying and saving files, where we don't
+        # need to construct a parser.
+        if os.path.exists(fname):
+            try:
+                parser.read(fname)
+            except UnicodeDecodeError:
+                # See https://github.com/pypa/pip/issues/4963
+                raise ConfigurationFileCouldNotBeLoaded(
+                    reason="contains invalid {} characters".format(
+                        locale.getpreferredencoding(False)
+                    ),
+                    fname=fname,
+                )
+            except configparser.Error as error:
+                # See https://github.com/pypa/pip/issues/4893
+                raise ConfigurationFileCouldNotBeLoaded(error=error)
+        return parser
+
+    def _load_environment_vars(self):
+        # type: () -> None
+        """Loads configuration from environment variables
+        """
+        self._config[kinds.ENV_VAR].update(
+            self._normalized_keys(":env:", self.get_environ_vars())
+        )
+
+    def _normalized_keys(self, section, items):
+        # type: (str, Iterable[Tuple[str, Any]]) -> Dict[str, Any]
+        """Normalizes items to construct a dictionary with normalized keys.
+
+        This routine is where the names become keys and are made the same
+        regardless of source - configuration files or environment.
+        """
+        normalized = {}
+        for name, val in items:
+            key = section + "." + _normalize_name(name)
+            normalized[key] = val
+        return normalized
+
+    def get_environ_vars(self):
+        # type: () -> Iterable[Tuple[str, str]]
+        """Returns a generator with all environmental vars with prefix PIP_"""
+        for key, val in os.environ.items():
+            should_be_yielded = (
+                key.startswith("PIP_") and
+                key[4:].lower() not in self._ignore_env_names
+            )
+            if should_be_yielded:
+                yield key[4:].lower(), val
+
+    # XXX: This is patched in the tests.
+    def iter_config_files(self):
+        # type: () -> Iterable[Tuple[Kind, List[str]]]
+        """Yields variant and configuration files associated with it.
+
+        This should be treated like items of a dictionary.
+        """
+        # SMELL: Move the conditions out of this function
+
+        # environment variables have the lowest priority
+        config_file = os.environ.get('PIP_CONFIG_FILE', None)
+        if config_file is not None:
+            yield kinds.ENV, [config_file]
+        else:
+            yield kinds.ENV, []
+
+        config_files = get_configuration_files()
+
+        # at the base we have any global configuration
+        yield kinds.GLOBAL, config_files[kinds.GLOBAL]
+
+        # per-user configuration next
+        should_load_user_config = not self.isolated and not (
+            config_file and os.path.exists(config_file)
+        )
+        if should_load_user_config:
+            # The legacy config file is overridden by the new config file
+            yield kinds.USER, config_files[kinds.USER]
+
+        # finally virtualenv configuration first trumping others
+        yield kinds.SITE, config_files[kinds.SITE]
+
+    def get_values_in_config(self, variant):
+        # type: (Kind) -> Dict[str, Any]
+        """Get values present in a config file"""
+        return self._config[variant]
+
+    def _get_parser_to_modify(self):
+        # type: () -> Tuple[str, RawConfigParser]
+        # Determine which parser to modify
+        assert self.load_only
+        parsers = self._parsers[self.load_only]
+        if not parsers:
+            # This should not happen if everything works correctly.
+            raise ConfigurationError(
+                "Fatal Internal error [id=2]. Please report as a bug."
+            )
+
+        # Use the highest priority parser.
+        return parsers[-1]
+
+    # XXX: This is patched in the tests.
+    def _mark_as_modified(self, fname, parser):
+        # type: (str, RawConfigParser) -> None
+        file_parser_tuple = (fname, parser)
+        if file_parser_tuple not in self._modified_parsers:
+            self._modified_parsers.append(file_parser_tuple)
+
+    def __repr__(self):
+        # type: () -> str
+        return "{}({!r})".format(self.__class__.__name__, self._dictionary)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/distributions/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/distributions/__init__.py
new file mode 100644
index 0000000..d5c1afc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/distributions/__init__.py
@@ -0,0 +1,24 @@
+from pip._internal.distributions.sdist import SourceDistribution
+from pip._internal.distributions.wheel import WheelDistribution
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from pip._internal.distributions.base import AbstractDistribution
+    from pip._internal.req.req_install import InstallRequirement
+
+
+def make_distribution_for_install_requirement(install_req):
+    # type: (InstallRequirement) -> AbstractDistribution
+    """Returns a Distribution for the given InstallRequirement
+    """
+    # Editable requirements will always be source distributions. They use the
+    # legacy logic until we create a modern standard for them.
+    if install_req.editable:
+        return SourceDistribution(install_req)
+
+    # If it's a wheel, it's a WheelDistribution
+    if install_req.is_wheel:
+        return WheelDistribution(install_req)
+
+    # Otherwise, a SourceDistribution
+    return SourceDistribution(install_req)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/distributions/base.py b/myenv/lib/python3.9/site-packages/pip/_internal/distributions/base.py
new file mode 100644
index 0000000..b836b98
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/distributions/base.py
@@ -0,0 +1,45 @@
+import abc
+
+from pip._vendor.six import add_metaclass
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional
+
+    from pip._vendor.pkg_resources import Distribution
+    from pip._internal.req import InstallRequirement
+    from pip._internal.index.package_finder import PackageFinder
+
+
+@add_metaclass(abc.ABCMeta)
+class AbstractDistribution(object):
+    """A base class for handling installable artifacts.
+
+    The requirements for anything installable are as follows:
+
+     - we must be able to determine the requirement name
+       (or we can't correctly handle the non-upgrade case).
+
+     - for packages with setup requirements, we must also be able
+       to determine their requirements without installing additional
+       packages (for the same reason as run-time dependencies)
+
+     - we must be able to create a Distribution object exposing the
+       above metadata.
+    """
+
+    def __init__(self, req):
+        # type: (InstallRequirement) -> None
+        super(AbstractDistribution, self).__init__()
+        self.req = req
+
+    @abc.abstractmethod
+    def get_pkg_resources_distribution(self):
+        # type: () -> Optional[Distribution]
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def prepare_distribution_metadata(self, finder, build_isolation):
+        # type: (PackageFinder, bool) -> None
+        raise NotImplementedError()
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/distributions/installed.py b/myenv/lib/python3.9/site-packages/pip/_internal/distributions/installed.py
new file mode 100644
index 0000000..0d15bf4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/distributions/installed.py
@@ -0,0 +1,24 @@
+from pip._internal.distributions.base import AbstractDistribution
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional
+
+    from pip._vendor.pkg_resources import Distribution
+    from pip._internal.index.package_finder import PackageFinder
+
+
+class InstalledDistribution(AbstractDistribution):
+    """Represents an installed package.
+
+    This does not need any preparation as the required information has already
+    been computed.
+    """
+
+    def get_pkg_resources_distribution(self):
+        # type: () -> Optional[Distribution]
+        return self.req.satisfied_by
+
+    def prepare_distribution_metadata(self, finder, build_isolation):
+        # type: (PackageFinder, bool) -> None
+        pass
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/distributions/sdist.py b/myenv/lib/python3.9/site-packages/pip/_internal/distributions/sdist.py
new file mode 100644
index 0000000..be3d7d9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/distributions/sdist.py
@@ -0,0 +1,104 @@
+import logging
+
+from pip._internal.build_env import BuildEnvironment
+from pip._internal.distributions.base import AbstractDistribution
+from pip._internal.exceptions import InstallationError
+from pip._internal.utils.subprocess import runner_with_spinner_message
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Set, Tuple
+
+    from pip._vendor.pkg_resources import Distribution
+    from pip._internal.index.package_finder import PackageFinder
+
+
+logger = logging.getLogger(__name__)
+
+
+class SourceDistribution(AbstractDistribution):
+    """Represents a source distribution.
+
+    The preparation step for these needs metadata for the packages to be
+    generated, either using PEP 517 or using the legacy `setup.py egg_info`.
+    """
+
+    def get_pkg_resources_distribution(self):
+        # type: () -> Distribution
+        return self.req.get_dist()
+
+    def prepare_distribution_metadata(self, finder, build_isolation):
+        # type: (PackageFinder, bool) -> None
+        # Load pyproject.toml, to determine whether PEP 517 is to be used
+        self.req.load_pyproject_toml()
+
+        # Set up the build isolation, if this requirement should be isolated
+        should_isolate = self.req.use_pep517 and build_isolation
+        if should_isolate:
+            self._setup_isolation(finder)
+
+        self.req.prepare_metadata()
+
+    def _setup_isolation(self, finder):
+        # type: (PackageFinder) -> None
+        def _raise_conflicts(conflicting_with, conflicting_reqs):
+            # type: (str, Set[Tuple[str, str]]) -> None
+            format_string = (
+                "Some build dependencies for {requirement} "
+                "conflict with {conflicting_with}: {description}."
+            )
+            error_message = format_string.format(
+                requirement=self.req,
+                conflicting_with=conflicting_with,
+                description=', '.join(
+                    '{} is incompatible with {}'.format(installed, wanted)
+                    for installed, wanted in sorted(conflicting)
+                )
+            )
+            raise InstallationError(error_message)
+
+        # Isolate in a BuildEnvironment and install the build-time
+        # requirements.
+        pyproject_requires = self.req.pyproject_requires
+        assert pyproject_requires is not None
+
+        self.req.build_env = BuildEnvironment()
+        self.req.build_env.install_requirements(
+            finder, pyproject_requires, 'overlay',
+            "Installing build dependencies"
+        )
+        conflicting, missing = self.req.build_env.check_requirements(
+            self.req.requirements_to_check
+        )
+        if conflicting:
+            _raise_conflicts("PEP 517/518 supported requirements",
+                             conflicting)
+        if missing:
+            logger.warning(
+                "Missing build requirements in pyproject.toml for %s.",
+                self.req,
+            )
+            logger.warning(
+                "The project does not specify a build backend, and "
+                "pip cannot fall back to setuptools without %s.",
+                " and ".join(map(repr, sorted(missing)))
+            )
+        # Install any extra build dependencies that the backend requests.
+        # This must be done in a second pass, as the pyproject.toml
+        # dependencies must be installed before we can call the backend.
+        with self.req.build_env:
+            runner = runner_with_spinner_message(
+                "Getting requirements to build wheel"
+            )
+            backend = self.req.pep517_backend
+            assert backend is not None
+            with backend.subprocess_runner(runner):
+                reqs = backend.get_requires_for_build_wheel()
+
+        conflicting, missing = self.req.build_env.check_requirements(reqs)
+        if conflicting:
+            _raise_conflicts("the backend dependencies", conflicting)
+        self.req.build_env.install_requirements(
+            finder, missing, 'normal',
+            "Installing backend dependencies"
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/distributions/wheel.py b/myenv/lib/python3.9/site-packages/pip/_internal/distributions/wheel.py
new file mode 100644
index 0000000..bf3482b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/distributions/wheel.py
@@ -0,0 +1,36 @@
+from zipfile import ZipFile
+
+from pip._internal.distributions.base import AbstractDistribution
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.wheel import pkg_resources_distribution_for_wheel
+
+if MYPY_CHECK_RUNNING:
+    from pip._vendor.pkg_resources import Distribution
+    from pip._internal.index.package_finder import PackageFinder
+
+
+class WheelDistribution(AbstractDistribution):
+    """Represents a wheel distribution.
+
+    This does not need any preparation as wheels can be directly unpacked.
+    """
+
+    def get_pkg_resources_distribution(self):
+        # type: () -> Distribution
+        """Loads the metadata from the wheel file into memory and returns a
+        Distribution that uses it, not relying on the wheel file or
+        requirement.
+        """
+        # Set as part of preparation during download.
+        assert self.req.local_file_path
+        # Wheels are never unnamed.
+        assert self.req.name
+
+        with ZipFile(self.req.local_file_path, allowZip64=True) as z:
+            return pkg_resources_distribution_for_wheel(
+                z, self.req.name, self.req.local_file_path
+            )
+
+    def prepare_distribution_metadata(self, finder, build_isolation):
+        # type: (PackageFinder, bool) -> None
+        pass
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/exceptions.py b/myenv/lib/python3.9/site-packages/pip/_internal/exceptions.py
new file mode 100644
index 0000000..3f26215
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/exceptions.py
@@ -0,0 +1,381 @@
+"""Exceptions used throughout package"""
+
+from __future__ import absolute_import
+
+from itertools import chain, groupby, repeat
+
+from pip._vendor.six import iteritems
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any, Optional, List, Dict, Text
+
+    from pip._vendor.pkg_resources import Distribution
+    from pip._vendor.requests.models import Response, Request
+    from pip._vendor.six import PY3
+    from pip._vendor.six.moves import configparser
+
+    from pip._internal.req.req_install import InstallRequirement
+
+    if PY3:
+        from hashlib import _Hash
+    else:
+        from hashlib import _hash as _Hash
+
+
+class PipError(Exception):
+    """Base pip exception"""
+
+
+class ConfigurationError(PipError):
+    """General exception in configuration"""
+
+
+class InstallationError(PipError):
+    """General exception during installation"""
+
+
+class UninstallationError(PipError):
+    """General exception during uninstallation"""
+
+
+class NoneMetadataError(PipError):
+    """
+    Raised when accessing "METADATA" or "PKG-INFO" metadata for a
+    pip._vendor.pkg_resources.Distribution object and
+    `dist.has_metadata('METADATA')` returns True but
+    `dist.get_metadata('METADATA')` returns None (and similarly for
+    "PKG-INFO").
+    """
+
+    def __init__(self, dist, metadata_name):
+        # type: (Distribution, str) -> None
+        """
+        :param dist: A Distribution object.
+        :param metadata_name: The name of the metadata being accessed
+            (can be "METADATA" or "PKG-INFO").
+        """
+        self.dist = dist
+        self.metadata_name = metadata_name
+
+    def __str__(self):
+        # type: () -> str
+        # Use `dist` in the error message because its stringification
+        # includes more information, like the version and location.
+        return (
+            'None {} metadata found for distribution: {}'.format(
+                self.metadata_name, self.dist,
+            )
+        )
+
+
+class DistributionNotFound(InstallationError):
+    """Raised when a distribution cannot be found to satisfy a requirement"""
+
+
+class RequirementsFileParseError(InstallationError):
+    """Raised when a general error occurs parsing a requirements file line."""
+
+
+class BestVersionAlreadyInstalled(PipError):
+    """Raised when the most up-to-date version of a package is already
+    installed."""
+
+
+class BadCommand(PipError):
+    """Raised when virtualenv or a command is not found"""
+
+
+class CommandError(PipError):
+    """Raised when there is an error in command-line arguments"""
+
+
+class SubProcessError(PipError):
+    """Raised when there is an error raised while executing a
+    command in subprocess"""
+
+
+class PreviousBuildDirError(PipError):
+    """Raised when there's a previous conflicting build directory"""
+
+
+class NetworkConnectionError(PipError):
+    """HTTP connection error"""
+
+    def __init__(self, error_msg, response=None, request=None):
+        # type: (Text, Response, Request) -> None
+        """
+        Initialize NetworkConnectionError with  `request` and `response`
+        objects.
+        """
+        self.response = response
+        self.request = request
+        self.error_msg = error_msg
+        if (self.response is not None and not self.request and
+                hasattr(response, 'request')):
+            self.request = self.response.request
+        super(NetworkConnectionError, self).__init__(
+            error_msg, response, request)
+
+    def __str__(self):
+        # type: () -> str
+        return str(self.error_msg)
+
+
+class InvalidWheelFilename(InstallationError):
+    """Invalid wheel filename."""
+
+
+class UnsupportedWheel(InstallationError):
+    """Unsupported wheel."""
+
+
+class MetadataInconsistent(InstallationError):
+    """Built metadata contains inconsistent information.
+
+    This is raised when the metadata contains values (e.g. name and version)
+    that do not match the information previously obtained from sdist filename
+    or user-supplied ``#egg=`` value.
+    """
+    def __init__(self, ireq, field, built):
+        # type: (InstallRequirement, str, Any) -> None
+        self.ireq = ireq
+        self.field = field
+        self.built = built
+
+    def __str__(self):
+        # type: () -> str
+        return "Requested {} has different {} in metadata: {!r}".format(
+            self.ireq, self.field, self.built,
+        )
+
+
+class HashErrors(InstallationError):
+    """Multiple HashError instances rolled into one for reporting"""
+
+    def __init__(self):
+        # type: () -> None
+        self.errors = []  # type: List[HashError]
+
+    def append(self, error):
+        # type: (HashError) -> None
+        self.errors.append(error)
+
+    def __str__(self):
+        # type: () -> str
+        lines = []
+        self.errors.sort(key=lambda e: e.order)
+        for cls, errors_of_cls in groupby(self.errors, lambda e: e.__class__):
+            lines.append(cls.head)
+            lines.extend(e.body() for e in errors_of_cls)
+        if lines:
+            return '\n'.join(lines)
+        return ''
+
+    def __nonzero__(self):
+        # type: () -> bool
+        return bool(self.errors)
+
+    def __bool__(self):
+        # type: () -> bool
+        return self.__nonzero__()
+
+
+class HashError(InstallationError):
+    """
+    A failure to verify a package against known-good hashes
+
+    :cvar order: An int sorting hash exception classes by difficulty of
+        recovery (lower being harder), so the user doesn't bother fretting
+        about unpinned packages when he has deeper issues, like VCS
+        dependencies, to deal with. Also keeps error reports in a
+        deterministic order.
+    :cvar head: A section heading for display above potentially many
+        exceptions of this kind
+    :ivar req: The InstallRequirement that triggered this error. This is
+        pasted on after the exception is instantiated, because it's not
+        typically available earlier.
+
+    """
+    req = None  # type: Optional[InstallRequirement]
+    head = ''
+    order = None  # type: Optional[int]
+
+    def body(self):
+        # type: () -> str
+        """Return a summary of me for display under the heading.
+
+        This default implementation simply prints a description of the
+        triggering requirement.
+
+        :param req: The InstallRequirement that provoked this error, with
+            its link already populated by the resolver's _populate_link().
+
+        """
+        return '    {}'.format(self._requirement_name())
+
+    def __str__(self):
+        # type: () -> str
+        return '{}\n{}'.format(self.head, self.body())
+
+    def _requirement_name(self):
+        # type: () -> str
+        """Return a description of the requirement that triggered me.
+
+        This default implementation returns long description of the req, with
+        line numbers
+
+        """
+        return str(self.req) if self.req else 'unknown package'
+
+
+class VcsHashUnsupported(HashError):
+    """A hash was provided for a version-control-system-based requirement, but
+    we don't have a method for hashing those."""
+
+    order = 0
+    head = ("Can't verify hashes for these requirements because we don't "
+            "have a way to hash version control repositories:")
+
+
+class DirectoryUrlHashUnsupported(HashError):
+    """A hash was provided for a version-control-system-based requirement, but
+    we don't have a method for hashing those."""
+
+    order = 1
+    head = ("Can't verify hashes for these file:// requirements because they "
+            "point to directories:")
+
+
+class HashMissing(HashError):
+    """A hash was needed for a requirement but is absent."""
+
+    order = 2
+    head = ('Hashes are required in --require-hashes mode, but they are '
+            'missing from some requirements. Here is a list of those '
+            'requirements along with the hashes their downloaded archives '
+            'actually had. Add lines like these to your requirements files to '
+            'prevent tampering. (If you did not enable --require-hashes '
+            'manually, note that it turns on automatically when any package '
+            'has a hash.)')
+
+    def __init__(self, gotten_hash):
+        # type: (str) -> None
+        """
+        :param gotten_hash: The hash of the (possibly malicious) archive we
+            just downloaded
+        """
+        self.gotten_hash = gotten_hash
+
+    def body(self):
+        # type: () -> str
+        # Dodge circular import.
+        from pip._internal.utils.hashes import FAVORITE_HASH
+
+        package = None
+        if self.req:
+            # In the case of URL-based requirements, display the original URL
+            # seen in the requirements file rather than the package name,
+            # so the output can be directly copied into the requirements file.
+            package = (self.req.original_link if self.req.original_link
+                       # In case someone feeds something downright stupid
+                       # to InstallRequirement's constructor.
+                       else getattr(self.req, 'req', None))
+        return '    {} --hash={}:{}'.format(package or 'unknown package',
+                                            FAVORITE_HASH,
+                                            self.gotten_hash)
+
+
+class HashUnpinned(HashError):
+    """A requirement had a hash specified but was not pinned to a specific
+    version."""
+
+    order = 3
+    head = ('In --require-hashes mode, all requirements must have their '
+            'versions pinned with ==. These do not:')
+
+
+class HashMismatch(HashError):
+    """
+    Distribution file hash values don't match.
+
+    :ivar package_name: The name of the package that triggered the hash
+        mismatch. Feel free to write to this after the exception is raise to
+        improve its error message.
+
+    """
+    order = 4
+    head = ('THESE PACKAGES DO NOT MATCH THE HASHES FROM THE REQUIREMENTS '
+            'FILE. If you have updated the package versions, please update '
+            'the hashes. Otherwise, examine the package contents carefully; '
+            'someone may have tampered with them.')
+
+    def __init__(self, allowed, gots):
+        # type: (Dict[str, List[str]], Dict[str, _Hash]) -> None
+        """
+        :param allowed: A dict of algorithm names pointing to lists of allowed
+            hex digests
+        :param gots: A dict of algorithm names pointing to hashes we
+            actually got from the files under suspicion
+        """
+        self.allowed = allowed
+        self.gots = gots
+
+    def body(self):
+        # type: () -> str
+        return '    {}:\n{}'.format(self._requirement_name(),
+                                    self._hash_comparison())
+
+    def _hash_comparison(self):
+        # type: () -> str
+        """
+        Return a comparison of actual and expected hash values.
+
+        Example::
+
+               Expected sha256 abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde
+                            or 123451234512345123451234512345123451234512345
+                    Got        bcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdef
+
+        """
+        def hash_then_or(hash_name):
+            # type: (str) -> chain[str]
+            # For now, all the decent hashes have 6-char names, so we can get
+            # away with hard-coding space literals.
+            return chain([hash_name], repeat('    or'))
+
+        lines = []  # type: List[str]
+        for hash_name, expecteds in iteritems(self.allowed):
+            prefix = hash_then_or(hash_name)
+            lines.extend(('        Expected {} {}'.format(next(prefix), e))
+                         for e in expecteds)
+            lines.append('             Got        {}\n'.format(
+                         self.gots[hash_name].hexdigest()))
+        return '\n'.join(lines)
+
+
+class UnsupportedPythonVersion(InstallationError):
+    """Unsupported python version according to Requires-Python package
+    metadata."""
+
+
+class ConfigurationFileCouldNotBeLoaded(ConfigurationError):
+    """When there are errors while loading a configuration file
+    """
+
+    def __init__(self, reason="could not be loaded", fname=None, error=None):
+        # type: (str, Optional[str], Optional[configparser.Error]) -> None
+        super(ConfigurationFileCouldNotBeLoaded, self).__init__(error)
+        self.reason = reason
+        self.fname = fname
+        self.error = error
+
+    def __str__(self):
+        # type: () -> str
+        if self.fname is not None:
+            message_part = " in {}.".format(self.fname)
+        else:
+            assert self.error is not None
+            message_part = ".\n{}\n".format(self.error)
+        return "Configuration file {}{}".format(self.reason, message_part)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/index/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/index/__init__.py
new file mode 100644
index 0000000..7a17b7b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/index/__init__.py
@@ -0,0 +1,2 @@
+"""Index interaction code
+"""
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/index/collector.py b/myenv/lib/python3.9/site-packages/pip/_internal/index/collector.py
new file mode 100644
index 0000000..6c35fc6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/index/collector.py
@@ -0,0 +1,692 @@
+"""
+The main purpose of this module is to expose LinkCollector.collect_links().
+"""
+
+import cgi
+import functools
+import itertools
+import logging
+import mimetypes
+import os
+import re
+from collections import OrderedDict
+
+from pip._vendor import html5lib, requests
+from pip._vendor.distlib.compat import unescape
+from pip._vendor.requests.exceptions import RetryError, SSLError
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+from pip._vendor.six.moves.urllib import request as urllib_request
+
+from pip._internal.exceptions import NetworkConnectionError
+from pip._internal.models.link import Link
+from pip._internal.models.search_scope import SearchScope
+from pip._internal.network.utils import raise_for_status
+from pip._internal.utils.filetypes import ARCHIVE_EXTENSIONS
+from pip._internal.utils.misc import pairwise, redact_auth_from_url
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.urls import path_to_url, url_to_path
+from pip._internal.vcs import is_url, vcs
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import (
+        Callable, Iterable, List, MutableMapping, Optional,
+        Protocol, Sequence, Tuple, TypeVar, Union,
+    )
+    import xml.etree.ElementTree
+
+    from pip._vendor.requests import Response
+
+    from pip._internal.network.session import PipSession
+
+    HTMLElement = xml.etree.ElementTree.Element
+    ResponseHeaders = MutableMapping[str, str]
+
+    # Used in the @lru_cache polyfill.
+    F = TypeVar('F')
+
+    class LruCache(Protocol):
+        def __call__(self, maxsize=None):
+            # type: (Optional[int]) -> Callable[[F], F]
+            raise NotImplementedError
+
+
+logger = logging.getLogger(__name__)
+
+
+# Fallback to noop_lru_cache in Python 2
+# TODO: this can be removed when python 2 support is dropped!
+def noop_lru_cache(maxsize=None):
+    # type: (Optional[int]) -> Callable[[F], F]
+    def _wrapper(f):
+        # type: (F) -> F
+        return f
+    return _wrapper
+
+
+_lru_cache = getattr(functools, "lru_cache", noop_lru_cache)  # type: LruCache
+
+
+def _match_vcs_scheme(url):
+    # type: (str) -> Optional[str]
+    """Look for VCS schemes in the URL.
+
+    Returns the matched VCS scheme, or None if there's no match.
+    """
+    for scheme in vcs.schemes:
+        if url.lower().startswith(scheme) and url[len(scheme)] in '+:':
+            return scheme
+    return None
+
+
+def _is_url_like_archive(url):
+    # type: (str) -> bool
+    """Return whether the URL looks like an archive.
+    """
+    filename = Link(url).filename
+    for bad_ext in ARCHIVE_EXTENSIONS:
+        if filename.endswith(bad_ext):
+            return True
+    return False
+
+
+class _NotHTML(Exception):
+    def __init__(self, content_type, request_desc):
+        # type: (str, str) -> None
+        super(_NotHTML, self).__init__(content_type, request_desc)
+        self.content_type = content_type
+        self.request_desc = request_desc
+
+
+def _ensure_html_header(response):
+    # type: (Response) -> None
+    """Check the Content-Type header to ensure the response contains HTML.
+
+    Raises `_NotHTML` if the content type is not text/html.
+    """
+    content_type = response.headers.get("Content-Type", "")
+    if not content_type.lower().startswith("text/html"):
+        raise _NotHTML(content_type, response.request.method)
+
+
+class _NotHTTP(Exception):
+    pass
+
+
+def _ensure_html_response(url, session):
+    # type: (str, PipSession) -> None
+    """Send a HEAD request to the URL, and ensure the response contains HTML.
+
+    Raises `_NotHTTP` if the URL is not available for a HEAD request, or
+    `_NotHTML` if the content type is not text/html.
+    """
+    scheme, netloc, path, query, fragment = urllib_parse.urlsplit(url)
+    if scheme not in {'http', 'https'}:
+        raise _NotHTTP()
+
+    resp = session.head(url, allow_redirects=True)
+    raise_for_status(resp)
+
+    _ensure_html_header(resp)
+
+
+def _get_html_response(url, session):
+    # type: (str, PipSession) -> Response
+    """Access an HTML page with GET, and return the response.
+
+    This consists of three parts:
+
+    1. If the URL looks suspiciously like an archive, send a HEAD first to
+       check the Content-Type is HTML, to avoid downloading a large file.
+       Raise `_NotHTTP` if the content type cannot be determined, or
+       `_NotHTML` if it is not HTML.
+    2. Actually perform the request. Raise HTTP exceptions on network failures.
+    3. Check the Content-Type header to make sure we got HTML, and raise
+       `_NotHTML` otherwise.
+    """
+    if _is_url_like_archive(url):
+        _ensure_html_response(url, session=session)
+
+    logger.debug('Getting page %s', redact_auth_from_url(url))
+
+    resp = session.get(
+        url,
+        headers={
+            "Accept": "text/html",
+            # We don't want to blindly returned cached data for
+            # /simple/, because authors generally expecting that
+            # twine upload && pip install will function, but if
+            # they've done a pip install in the last ~10 minutes
+            # it won't. Thus by setting this to zero we will not
+            # blindly use any cached data, however the benefit of
+            # using max-age=0 instead of no-cache, is that we will
+            # still support conditional requests, so we will still
+            # minimize traffic sent in cases where the page hasn't
+            # changed at all, we will just always incur the round
+            # trip for the conditional GET now instead of only
+            # once per 10 minutes.
+            # For more information, please see pypa/pip#5670.
+            "Cache-Control": "max-age=0",
+        },
+    )
+    raise_for_status(resp)
+
+    # The check for archives above only works if the url ends with
+    # something that looks like an archive. However that is not a
+    # requirement of an url. Unless we issue a HEAD request on every
+    # url we cannot know ahead of time for sure if something is HTML
+    # or not. However we can check after we've downloaded it.
+    _ensure_html_header(resp)
+
+    return resp
+
+
+def _get_encoding_from_headers(headers):
+    # type: (ResponseHeaders) -> Optional[str]
+    """Determine if we have any encoding information in our headers.
+    """
+    if headers and "Content-Type" in headers:
+        content_type, params = cgi.parse_header(headers["Content-Type"])
+        if "charset" in params:
+            return params['charset']
+    return None
+
+
+def _determine_base_url(document, page_url):
+    # type: (HTMLElement, str) -> str
+    """Determine the HTML document's base URL.
+
+    This looks for a ``<base>`` tag in the HTML document. If present, its href
+    attribute denotes the base URL of anchor tags in the document. If there is
+    no such tag (or if it does not have a valid href attribute), the HTML
+    file's URL is used as the base URL.
+
+    :param document: An HTML document representation. The current
+        implementation expects the result of ``html5lib.parse()``.
+    :param page_url: The URL of the HTML document.
+    """
+    for base in document.findall(".//base"):
+        href = base.get("href")
+        if href is not None:
+            return href
+    return page_url
+
+
+def _clean_url_path_part(part):
+    # type: (str) -> str
+    """
+    Clean a "part" of a URL path (i.e. after splitting on "@" characters).
+    """
+    # We unquote prior to quoting to make sure nothing is double quoted.
+    return urllib_parse.quote(urllib_parse.unquote(part))
+
+
+def _clean_file_url_path(part):
+    # type: (str) -> str
+    """
+    Clean the first part of a URL path that corresponds to a local
+    filesystem path (i.e. the first part after splitting on "@" characters).
+    """
+    # We unquote prior to quoting to make sure nothing is double quoted.
+    # Also, on Windows the path part might contain a drive letter which
+    # should not be quoted. On Linux where drive letters do not
+    # exist, the colon should be quoted. We rely on urllib.request
+    # to do the right thing here.
+    return urllib_request.pathname2url(urllib_request.url2pathname(part))
+
+
+# percent-encoded:                   /
+_reserved_chars_re = re.compile('(@|%2F)', re.IGNORECASE)
+
+
+def _clean_url_path(path, is_local_path):
+    # type: (str, bool) -> str
+    """
+    Clean the path portion of a URL.
+    """
+    if is_local_path:
+        clean_func = _clean_file_url_path
+    else:
+        clean_func = _clean_url_path_part
+
+    # Split on the reserved characters prior to cleaning so that
+    # revision strings in VCS URLs are properly preserved.
+    parts = _reserved_chars_re.split(path)
+
+    cleaned_parts = []
+    for to_clean, reserved in pairwise(itertools.chain(parts, [''])):
+        cleaned_parts.append(clean_func(to_clean))
+        # Normalize %xx escapes (e.g. %2f -> %2F)
+        cleaned_parts.append(reserved.upper())
+
+    return ''.join(cleaned_parts)
+
+
+def _clean_link(url):
+    # type: (str) -> str
+    """
+    Make sure a link is fully quoted.
+    For example, if ' ' occurs in the URL, it will be replaced with "%20",
+    and without double-quoting other characters.
+    """
+    # Split the URL into parts according to the general structure
+    # `scheme://netloc/path;parameters?query#fragment`.
+    result = urllib_parse.urlparse(url)
+    # If the netloc is empty, then the URL refers to a local filesystem path.
+    is_local_path = not result.netloc
+    path = _clean_url_path(result.path, is_local_path=is_local_path)
+    return urllib_parse.urlunparse(result._replace(path=path))
+
+
+def _create_link_from_element(
+    anchor,    # type: HTMLElement
+    page_url,  # type: str
+    base_url,  # type: str
+):
+    # type: (...) -> Optional[Link]
+    """
+    Convert an anchor element in a simple repository page to a Link.
+    """
+    href = anchor.get("href")
+    if not href:
+        return None
+
+    url = _clean_link(urllib_parse.urljoin(base_url, href))
+    pyrequire = anchor.get('data-requires-python')
+    pyrequire = unescape(pyrequire) if pyrequire else None
+
+    yanked_reason = anchor.get('data-yanked')
+    if yanked_reason:
+        # This is a unicode string in Python 2 (and 3).
+        yanked_reason = unescape(yanked_reason)
+
+    link = Link(
+        url,
+        comes_from=page_url,
+        requires_python=pyrequire,
+        yanked_reason=yanked_reason,
+    )
+
+    return link
+
+
+class CacheablePageContent(object):
+    def __init__(self, page):
+        # type: (HTMLPage) -> None
+        assert page.cache_link_parsing
+        self.page = page
+
+    def __eq__(self, other):
+        # type: (object) -> bool
+        return (isinstance(other, type(self)) and
+                self.page.url == other.page.url)
+
+    def __hash__(self):
+        # type: () -> int
+        return hash(self.page.url)
+
+
+def with_cached_html_pages(
+    fn,    # type: Callable[[HTMLPage], Iterable[Link]]
+):
+    # type: (...) -> Callable[[HTMLPage], List[Link]]
+    """
+    Given a function that parses an Iterable[Link] from an HTMLPage, cache the
+    function's result (keyed by CacheablePageContent), unless the HTMLPage
+    `page` has `page.cache_link_parsing == False`.
+    """
+
+    @_lru_cache(maxsize=None)
+    def wrapper(cacheable_page):
+        # type: (CacheablePageContent) -> List[Link]
+        return list(fn(cacheable_page.page))
+
+    @functools.wraps(fn)
+    def wrapper_wrapper(page):
+        # type: (HTMLPage) -> List[Link]
+        if page.cache_link_parsing:
+            return wrapper(CacheablePageContent(page))
+        return list(fn(page))
+
+    return wrapper_wrapper
+
+
+@with_cached_html_pages
+def parse_links(page):
+    # type: (HTMLPage) -> Iterable[Link]
+    """
+    Parse an HTML document, and yield its anchor elements as Link objects.
+    """
+    document = html5lib.parse(
+        page.content,
+        transport_encoding=page.encoding,
+        namespaceHTMLElements=False,
+    )
+
+    url = page.url
+    base_url = _determine_base_url(document, url)
+    for anchor in document.findall(".//a"):
+        link = _create_link_from_element(
+            anchor,
+            page_url=url,
+            base_url=base_url,
+        )
+        if link is None:
+            continue
+        yield link
+
+
+class HTMLPage(object):
+    """Represents one page, along with its URL"""
+
+    def __init__(
+        self,
+        content,                  # type: bytes
+        encoding,                 # type: Optional[str]
+        url,                      # type: str
+        cache_link_parsing=True,  # type: bool
+    ):
+        # type: (...) -> None
+        """
+        :param encoding: the encoding to decode the given content.
+        :param url: the URL from which the HTML was downloaded.
+        :param cache_link_parsing: whether links parsed from this page's url
+                                   should be cached. PyPI index urls should
+                                   have this set to False, for example.
+        """
+        self.content = content
+        self.encoding = encoding
+        self.url = url
+        self.cache_link_parsing = cache_link_parsing
+
+    def __str__(self):
+        # type: () -> str
+        return redact_auth_from_url(self.url)
+
+
+def _handle_get_page_fail(
+    link,  # type: Link
+    reason,  # type: Union[str, Exception]
+    meth=None  # type: Optional[Callable[..., None]]
+):
+    # type: (...) -> None
+    if meth is None:
+        meth = logger.debug
+    meth("Could not fetch URL %s: %s - skipping", link, reason)
+
+
+def _make_html_page(response, cache_link_parsing=True):
+    # type: (Response, bool) -> HTMLPage
+    encoding = _get_encoding_from_headers(response.headers)
+    return HTMLPage(
+        response.content,
+        encoding=encoding,
+        url=response.url,
+        cache_link_parsing=cache_link_parsing)
+
+
+def _get_html_page(link, session=None):
+    # type: (Link, Optional[PipSession]) -> Optional[HTMLPage]
+    if session is None:
+        raise TypeError(
+            "_get_html_page() missing 1 required keyword argument: 'session'"
+        )
+
+    url = link.url.split('#', 1)[0]
+
+    # Check for VCS schemes that do not support lookup as web pages.
+    vcs_scheme = _match_vcs_scheme(url)
+    if vcs_scheme:
+        logger.warning('Cannot look at %s URL %s because it does not support '
+                       'lookup as web pages.', vcs_scheme, link)
+        return None
+
+    # Tack index.html onto file:// URLs that point to directories
+    scheme, _, path, _, _, _ = urllib_parse.urlparse(url)
+    if (scheme == 'file' and os.path.isdir(urllib_request.url2pathname(path))):
+        # add trailing slash if not present so urljoin doesn't trim
+        # final segment
+        if not url.endswith('/'):
+            url += '/'
+        url = urllib_parse.urljoin(url, 'index.html')
+        logger.debug(' file: URL is directory, getting %s', url)
+
+    try:
+        resp = _get_html_response(url, session=session)
+    except _NotHTTP:
+        logger.warning(
+            'Skipping page %s because it looks like an archive, and cannot '
+            'be checked by a HTTP HEAD request.', link,
+        )
+    except _NotHTML as exc:
+        logger.warning(
+            'Skipping page %s because the %s request got Content-Type: %s.'
+            'The only supported Content-Type is text/html',
+            link, exc.request_desc, exc.content_type,
+        )
+    except NetworkConnectionError as exc:
+        _handle_get_page_fail(link, exc)
+    except RetryError as exc:
+        _handle_get_page_fail(link, exc)
+    except SSLError as exc:
+        reason = "There was a problem confirming the ssl certificate: "
+        reason += str(exc)
+        _handle_get_page_fail(link, reason, meth=logger.info)
+    except requests.ConnectionError as exc:
+        _handle_get_page_fail(link, "connection error: {}".format(exc))
+    except requests.Timeout:
+        _handle_get_page_fail(link, "timed out")
+    else:
+        return _make_html_page(resp,
+                               cache_link_parsing=link.cache_link_parsing)
+    return None
+
+
+def _remove_duplicate_links(links):
+    # type: (Iterable[Link]) -> List[Link]
+    """
+    Return a list of links, with duplicates removed and ordering preserved.
+    """
+    # We preserve the ordering when removing duplicates because we can.
+    return list(OrderedDict.fromkeys(links))
+
+
+def group_locations(locations, expand_dir=False):
+    # type: (Sequence[str], bool) -> Tuple[List[str], List[str]]
+    """
+    Divide a list of locations into two groups: "files" (archives) and "urls."
+
+    :return: A pair of lists (files, urls).
+    """
+    files = []
+    urls = []
+
+    # puts the url for the given file path into the appropriate list
+    def sort_path(path):
+        # type: (str) -> None
+        url = path_to_url(path)
+        if mimetypes.guess_type(url, strict=False)[0] == 'text/html':
+            urls.append(url)
+        else:
+            files.append(url)
+
+    for url in locations:
+
+        is_local_path = os.path.exists(url)
+        is_file_url = url.startswith('file:')
+
+        if is_local_path or is_file_url:
+            if is_local_path:
+                path = url
+            else:
+                path = url_to_path(url)
+            if os.path.isdir(path):
+                if expand_dir:
+                    path = os.path.realpath(path)
+                    for item in os.listdir(path):
+                        sort_path(os.path.join(path, item))
+                elif is_file_url:
+                    urls.append(url)
+                else:
+                    logger.warning(
+                        "Path '%s' is ignored: it is a directory.", path,
+                    )
+            elif os.path.isfile(path):
+                sort_path(path)
+            else:
+                logger.warning(
+                    "Url '%s' is ignored: it is neither a file "
+                    "nor a directory.", url,
+                )
+        elif is_url(url):
+            # Only add url with clear scheme
+            urls.append(url)
+        else:
+            logger.warning(
+                "Url '%s' is ignored. It is either a non-existing "
+                "path or lacks a specific scheme.", url,
+            )
+
+    return files, urls
+
+
+class CollectedLinks(object):
+
+    """
+    Encapsulates the return value of a call to LinkCollector.collect_links().
+
+    The return value includes both URLs to project pages containing package
+    links, as well as individual package Link objects collected from other
+    sources.
+
+    This info is stored separately as:
+
+    (1) links from the configured file locations,
+    (2) links from the configured find_links, and
+    (3) urls to HTML project pages, as described by the PEP 503 simple
+        repository API.
+    """
+
+    def __init__(
+        self,
+        files,         # type: List[Link]
+        find_links,    # type: List[Link]
+        project_urls,  # type: List[Link]
+    ):
+        # type: (...) -> None
+        """
+        :param files: Links from file locations.
+        :param find_links: Links from find_links.
+        :param project_urls: URLs to HTML project pages, as described by
+            the PEP 503 simple repository API.
+        """
+        self.files = files
+        self.find_links = find_links
+        self.project_urls = project_urls
+
+
+class LinkCollector(object):
+
+    """
+    Responsible for collecting Link objects from all configured locations,
+    making network requests as needed.
+
+    The class's main method is its collect_links() method.
+    """
+
+    def __init__(
+        self,
+        session,       # type: PipSession
+        search_scope,  # type: SearchScope
+    ):
+        # type: (...) -> None
+        self.search_scope = search_scope
+        self.session = session
+
+    @classmethod
+    def create(cls, session, options, suppress_no_index=False):
+        # type: (PipSession, Values, bool) -> LinkCollector
+        """
+        :param session: The Session to use to make requests.
+        :param suppress_no_index: Whether to ignore the --no-index option
+            when constructing the SearchScope object.
+        """
+        index_urls = [options.index_url] + options.extra_index_urls
+        if options.no_index and not suppress_no_index:
+            logger.debug(
+                'Ignoring indexes: %s',
+                ','.join(redact_auth_from_url(url) for url in index_urls),
+            )
+            index_urls = []
+
+        # Make sure find_links is a list before passing to create().
+        find_links = options.find_links or []
+
+        search_scope = SearchScope.create(
+            find_links=find_links, index_urls=index_urls,
+        )
+        link_collector = LinkCollector(
+            session=session, search_scope=search_scope,
+        )
+        return link_collector
+
+    @property
+    def find_links(self):
+        # type: () -> List[str]
+        return self.search_scope.find_links
+
+    def fetch_page(self, location):
+        # type: (Link) -> Optional[HTMLPage]
+        """
+        Fetch an HTML page containing package links.
+        """
+        return _get_html_page(location, session=self.session)
+
+    def collect_links(self, project_name):
+        # type: (str) -> CollectedLinks
+        """Find all available links for the given project name.
+
+        :return: All the Link objects (unfiltered), as a CollectedLinks object.
+        """
+        search_scope = self.search_scope
+        index_locations = search_scope.get_index_urls_locations(project_name)
+        index_file_loc, index_url_loc = group_locations(index_locations)
+        fl_file_loc, fl_url_loc = group_locations(
+            self.find_links, expand_dir=True,
+        )
+
+        file_links = [
+            Link(url) for url in itertools.chain(index_file_loc, fl_file_loc)
+        ]
+
+        # We trust every directly linked archive in find_links
+        find_link_links = [Link(url, '-f') for url in self.find_links]
+
+        # We trust every url that the user has given us whether it was given
+        # via --index-url or --find-links.
+        # We want to filter out anything that does not have a secure origin.
+        url_locations = [
+            link for link in itertools.chain(
+                # Mark PyPI indices as "cache_link_parsing == False" -- this
+                # will avoid caching the result of parsing the page for links.
+                (Link(url, cache_link_parsing=False) for url in index_url_loc),
+                (Link(url) for url in fl_url_loc),
+            )
+            if self.session.is_secure_origin(link)
+        ]
+
+        url_locations = _remove_duplicate_links(url_locations)
+        lines = [
+            '{} location(s) to search for versions of {}:'.format(
+                len(url_locations), project_name,
+            ),
+        ]
+        for link in url_locations:
+            lines.append('* {}'.format(link))
+        logger.debug('\n'.join(lines))
+
+        return CollectedLinks(
+            files=file_links,
+            find_links=find_link_links,
+            project_urls=url_locations,
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/index/package_finder.py b/myenv/lib/python3.9/site-packages/pip/_internal/index/package_finder.py
new file mode 100644
index 0000000..8411578
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/index/package_finder.py
@@ -0,0 +1,1014 @@
+"""Routines related to PyPI, indexes"""
+
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
+
+from __future__ import absolute_import
+
+import logging
+import re
+
+from pip._vendor.packaging import specifiers
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.packaging.version import parse as parse_version
+
+from pip._internal.exceptions import (
+    BestVersionAlreadyInstalled,
+    DistributionNotFound,
+    InvalidWheelFilename,
+    UnsupportedWheel,
+)
+from pip._internal.index.collector import parse_links
+from pip._internal.models.candidate import InstallationCandidate
+from pip._internal.models.format_control import FormatControl
+from pip._internal.models.link import Link
+from pip._internal.models.selection_prefs import SelectionPreferences
+from pip._internal.models.target_python import TargetPython
+from pip._internal.models.wheel import Wheel
+from pip._internal.utils.filetypes import WHEEL_EXTENSION
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import build_netloc
+from pip._internal.utils.packaging import check_requires_python
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.unpacking import SUPPORTED_EXTENSIONS
+from pip._internal.utils.urls import url_to_path
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        FrozenSet, Iterable, List, Optional, Set, Text, Tuple, Union,
+    )
+
+    from pip._vendor.packaging.tags import Tag
+    from pip._vendor.packaging.version import _BaseVersion
+
+    from pip._internal.index.collector import LinkCollector
+    from pip._internal.models.search_scope import SearchScope
+    from pip._internal.req import InstallRequirement
+    from pip._internal.utils.hashes import Hashes
+
+    BuildTag = Union[Tuple[()], Tuple[int, str]]
+    CandidateSortingKey = (
+        Tuple[int, int, int, _BaseVersion, BuildTag, Optional[int]]
+    )
+
+
+__all__ = ['FormatControl', 'BestCandidateResult', 'PackageFinder']
+
+
+logger = logging.getLogger(__name__)
+
+
+def _check_link_requires_python(
+    link,  # type: Link
+    version_info,  # type: Tuple[int, int, int]
+    ignore_requires_python=False,  # type: bool
+):
+    # type: (...) -> bool
+    """
+    Return whether the given Python version is compatible with a link's
+    "Requires-Python" value.
+
+    :param version_info: A 3-tuple of ints representing the Python
+        major-minor-micro version to check.
+    :param ignore_requires_python: Whether to ignore the "Requires-Python"
+        value if the given Python version isn't compatible.
+    """
+    try:
+        is_compatible = check_requires_python(
+            link.requires_python, version_info=version_info,
+        )
+    except specifiers.InvalidSpecifier:
+        logger.debug(
+            "Ignoring invalid Requires-Python (%r) for link: %s",
+            link.requires_python, link,
+        )
+    else:
+        if not is_compatible:
+            version = '.'.join(map(str, version_info))
+            if not ignore_requires_python:
+                logger.debug(
+                    'Link requires a different Python (%s not in: %r): %s',
+                    version, link.requires_python, link,
+                )
+                return False
+
+            logger.debug(
+                'Ignoring failed Requires-Python check (%s not in: %r) '
+                'for link: %s',
+                version, link.requires_python, link,
+            )
+
+    return True
+
+
+class LinkEvaluator(object):
+
+    """
+    Responsible for evaluating links for a particular project.
+    """
+
+    _py_version_re = re.compile(r'-py([123]\.?[0-9]?)$')
+
+    # Don't include an allow_yanked default value to make sure each call
+    # site considers whether yanked releases are allowed. This also causes
+    # that decision to be made explicit in the calling code, which helps
+    # people when reading the code.
+    def __init__(
+        self,
+        project_name,    # type: str
+        canonical_name,  # type: str
+        formats,         # type: FrozenSet[str]
+        target_python,   # type: TargetPython
+        allow_yanked,    # type: bool
+        ignore_requires_python=None,  # type: Optional[bool]
+    ):
+        # type: (...) -> None
+        """
+        :param project_name: The user supplied package name.
+        :param canonical_name: The canonical package name.
+        :param formats: The formats allowed for this package. Should be a set
+            with 'binary' or 'source' or both in it.
+        :param target_python: The target Python interpreter to use when
+            evaluating link compatibility. This is used, for example, to
+            check wheel compatibility, as well as when checking the Python
+            version, e.g. the Python version embedded in a link filename
+            (or egg fragment) and against an HTML link's optional PEP 503
+            "data-requires-python" attribute.
+        :param allow_yanked: Whether files marked as yanked (in the sense
+            of PEP 592) are permitted to be candidates for install.
+        :param ignore_requires_python: Whether to ignore incompatible
+            PEP 503 "data-requires-python" values in HTML links. Defaults
+            to False.
+        """
+        if ignore_requires_python is None:
+            ignore_requires_python = False
+
+        self._allow_yanked = allow_yanked
+        self._canonical_name = canonical_name
+        self._ignore_requires_python = ignore_requires_python
+        self._formats = formats
+        self._target_python = target_python
+
+        self.project_name = project_name
+
+    def evaluate_link(self, link):
+        # type: (Link) -> Tuple[bool, Optional[Text]]
+        """
+        Determine whether a link is a candidate for installation.
+
+        :return: A tuple (is_candidate, result), where `result` is (1) a
+            version string if `is_candidate` is True, and (2) if
+            `is_candidate` is False, an optional string to log the reason
+            the link fails to qualify.
+        """
+        version = None
+        if link.is_yanked and not self._allow_yanked:
+            reason = link.yanked_reason or '<none given>'
+            # Mark this as a unicode string to prevent "UnicodeEncodeError:
+            # 'ascii' codec can't encode character" in Python 2 when
+            # the reason contains non-ascii characters.
+            return (False, u'yanked for reason: {}'.format(reason))
+
+        if link.egg_fragment:
+            egg_info = link.egg_fragment
+            ext = link.ext
+        else:
+            egg_info, ext = link.splitext()
+            if not ext:
+                return (False, 'not a file')
+            if ext not in SUPPORTED_EXTENSIONS:
+                return (False, 'unsupported archive format: {}'.format(ext))
+            if "binary" not in self._formats and ext == WHEEL_EXTENSION:
+                reason = 'No binaries permitted for {}'.format(
+                    self.project_name)
+                return (False, reason)
+            if "macosx10" in link.path and ext == '.zip':
+                return (False, 'macosx10 one')
+            if ext == WHEEL_EXTENSION:
+                try:
+                    wheel = Wheel(link.filename)
+                except InvalidWheelFilename:
+                    return (False, 'invalid wheel filename')
+                if canonicalize_name(wheel.name) != self._canonical_name:
+                    reason = 'wrong project name (not {})'.format(
+                        self.project_name)
+                    return (False, reason)
+
+                supported_tags = self._target_python.get_tags()
+                if not wheel.supported(supported_tags):
+                    # Include the wheel's tags in the reason string to
+                    # simplify troubleshooting compatibility issues.
+                    file_tags = wheel.get_formatted_file_tags()
+                    reason = (
+                        "none of the wheel's tags match: {}".format(
+                            ', '.join(file_tags)
+                        )
+                    )
+                    return (False, reason)
+
+                version = wheel.version
+
+        # This should be up by the self.ok_binary check, but see issue 2700.
+        if "source" not in self._formats and ext != WHEEL_EXTENSION:
+            reason = 'No sources permitted for {}'.format(self.project_name)
+            return (False, reason)
+
+        if not version:
+            version = _extract_version_from_fragment(
+                egg_info, self._canonical_name,
+            )
+        if not version:
+            reason = 'Missing project version for {}'.format(self.project_name)
+            return (False, reason)
+
+        match = self._py_version_re.search(version)
+        if match:
+            version = version[:match.start()]
+            py_version = match.group(1)
+            if py_version != self._target_python.py_version:
+                return (False, 'Python version is incorrect')
+
+        supports_python = _check_link_requires_python(
+            link, version_info=self._target_python.py_version_info,
+            ignore_requires_python=self._ignore_requires_python,
+        )
+        if not supports_python:
+            # Return None for the reason text to suppress calling
+            # _log_skipped_link().
+            return (False, None)
+
+        logger.debug('Found link %s, version: %s', link, version)
+
+        return (True, version)
+
+
+def filter_unallowed_hashes(
+    candidates,    # type: List[InstallationCandidate]
+    hashes,        # type: Hashes
+    project_name,  # type: str
+):
+    # type: (...) -> List[InstallationCandidate]
+    """
+    Filter out candidates whose hashes aren't allowed, and return a new
+    list of candidates.
+
+    If at least one candidate has an allowed hash, then all candidates with
+    either an allowed hash or no hash specified are returned.  Otherwise,
+    the given candidates are returned.
+
+    Including the candidates with no hash specified when there is a match
+    allows a warning to be logged if there is a more preferred candidate
+    with no hash specified.  Returning all candidates in the case of no
+    matches lets pip report the hash of the candidate that would otherwise
+    have been installed (e.g. permitting the user to more easily update
+    their requirements file with the desired hash).
+    """
+    if not hashes:
+        logger.debug(
+            'Given no hashes to check %s links for project %r: '
+            'discarding no candidates',
+            len(candidates),
+            project_name,
+        )
+        # Make sure we're not returning back the given value.
+        return list(candidates)
+
+    matches_or_no_digest = []
+    # Collect the non-matches for logging purposes.
+    non_matches = []
+    match_count = 0
+    for candidate in candidates:
+        link = candidate.link
+        if not link.has_hash:
+            pass
+        elif link.is_hash_allowed(hashes=hashes):
+            match_count += 1
+        else:
+            non_matches.append(candidate)
+            continue
+
+        matches_or_no_digest.append(candidate)
+
+    if match_count:
+        filtered = matches_or_no_digest
+    else:
+        # Make sure we're not returning back the given value.
+        filtered = list(candidates)
+
+    if len(filtered) == len(candidates):
+        discard_message = 'discarding no candidates'
+    else:
+        discard_message = 'discarding {} non-matches:\n  {}'.format(
+            len(non_matches),
+            '\n  '.join(str(candidate.link) for candidate in non_matches)
+        )
+
+    logger.debug(
+        'Checked %s links for project %r against %s hashes '
+        '(%s matches, %s no digest): %s',
+        len(candidates),
+        project_name,
+        hashes.digest_count,
+        match_count,
+        len(matches_or_no_digest) - match_count,
+        discard_message
+    )
+
+    return filtered
+
+
+class CandidatePreferences(object):
+
+    """
+    Encapsulates some of the preferences for filtering and sorting
+    InstallationCandidate objects.
+    """
+
+    def __init__(
+        self,
+        prefer_binary=False,  # type: bool
+        allow_all_prereleases=False,  # type: bool
+    ):
+        # type: (...) -> None
+        """
+        :param allow_all_prereleases: Whether to allow all pre-releases.
+        """
+        self.allow_all_prereleases = allow_all_prereleases
+        self.prefer_binary = prefer_binary
+
+
+class BestCandidateResult(object):
+    """A collection of candidates, returned by `PackageFinder.find_best_candidate`.
+
+    This class is only intended to be instantiated by CandidateEvaluator's
+    `compute_best_candidate()` method.
+    """
+
+    def __init__(
+        self,
+        candidates,             # type: List[InstallationCandidate]
+        applicable_candidates,  # type: List[InstallationCandidate]
+        best_candidate,         # type: Optional[InstallationCandidate]
+    ):
+        # type: (...) -> None
+        """
+        :param candidates: A sequence of all available candidates found.
+        :param applicable_candidates: The applicable candidates.
+        :param best_candidate: The most preferred candidate found, or None
+            if no applicable candidates were found.
+        """
+        assert set(applicable_candidates) <= set(candidates)
+
+        if best_candidate is None:
+            assert not applicable_candidates
+        else:
+            assert best_candidate in applicable_candidates
+
+        self._applicable_candidates = applicable_candidates
+        self._candidates = candidates
+
+        self.best_candidate = best_candidate
+
+    def iter_all(self):
+        # type: () -> Iterable[InstallationCandidate]
+        """Iterate through all candidates.
+        """
+        return iter(self._candidates)
+
+    def iter_applicable(self):
+        # type: () -> Iterable[InstallationCandidate]
+        """Iterate through the applicable candidates.
+        """
+        return iter(self._applicable_candidates)
+
+
+class CandidateEvaluator(object):
+
+    """
+    Responsible for filtering and sorting candidates for installation based
+    on what tags are valid.
+    """
+
+    @classmethod
+    def create(
+        cls,
+        project_name,         # type: str
+        target_python=None,   # type: Optional[TargetPython]
+        prefer_binary=False,  # type: bool
+        allow_all_prereleases=False,  # type: bool
+        specifier=None,       # type: Optional[specifiers.BaseSpecifier]
+        hashes=None,          # type: Optional[Hashes]
+    ):
+        # type: (...) -> CandidateEvaluator
+        """Create a CandidateEvaluator object.
+
+        :param target_python: The target Python interpreter to use when
+            checking compatibility. If None (the default), a TargetPython
+            object will be constructed from the running Python.
+        :param specifier: An optional object implementing `filter`
+            (e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
+            versions.
+        :param hashes: An optional collection of allowed hashes.
+        """
+        if target_python is None:
+            target_python = TargetPython()
+        if specifier is None:
+            specifier = specifiers.SpecifierSet()
+
+        supported_tags = target_python.get_tags()
+
+        return cls(
+            project_name=project_name,
+            supported_tags=supported_tags,
+            specifier=specifier,
+            prefer_binary=prefer_binary,
+            allow_all_prereleases=allow_all_prereleases,
+            hashes=hashes,
+        )
+
+    def __init__(
+        self,
+        project_name,         # type: str
+        supported_tags,       # type: List[Tag]
+        specifier,            # type: specifiers.BaseSpecifier
+        prefer_binary=False,  # type: bool
+        allow_all_prereleases=False,  # type: bool
+        hashes=None,                  # type: Optional[Hashes]
+    ):
+        # type: (...) -> None
+        """
+        :param supported_tags: The PEP 425 tags supported by the target
+            Python in order of preference (most preferred first).
+        """
+        self._allow_all_prereleases = allow_all_prereleases
+        self._hashes = hashes
+        self._prefer_binary = prefer_binary
+        self._project_name = project_name
+        self._specifier = specifier
+        self._supported_tags = supported_tags
+
+    def get_applicable_candidates(
+        self,
+        candidates,  # type: List[InstallationCandidate]
+    ):
+        # type: (...) -> List[InstallationCandidate]
+        """
+        Return the applicable candidates from a list of candidates.
+        """
+        # Using None infers from the specifier instead.
+        allow_prereleases = self._allow_all_prereleases or None
+        specifier = self._specifier
+        versions = {
+            str(v) for v in specifier.filter(
+                # We turn the version object into a str here because otherwise
+                # when we're debundled but setuptools isn't, Python will see
+                # packaging.version.Version and
+                # pkg_resources._vendor.packaging.version.Version as different
+                # types. This way we'll use a str as a common data interchange
+                # format. If we stop using the pkg_resources provided specifier
+                # and start using our own, we can drop the cast to str().
+                (str(c.version) for c in candidates),
+                prereleases=allow_prereleases,
+            )
+        }
+
+        # Again, converting version to str to deal with debundling.
+        applicable_candidates = [
+            c for c in candidates if str(c.version) in versions
+        ]
+
+        filtered_applicable_candidates = filter_unallowed_hashes(
+            candidates=applicable_candidates,
+            hashes=self._hashes,
+            project_name=self._project_name,
+        )
+
+        return sorted(filtered_applicable_candidates, key=self._sort_key)
+
+    def _sort_key(self, candidate):
+        # type: (InstallationCandidate) -> CandidateSortingKey
+        """
+        Function to pass as the `key` argument to a call to sorted() to sort
+        InstallationCandidates by preference.
+
+        Returns a tuple such that tuples sorting as greater using Python's
+        default comparison operator are more preferred.
+
+        The preference is as follows:
+
+        First and foremost, candidates with allowed (matching) hashes are
+        always preferred over candidates without matching hashes. This is
+        because e.g. if the only candidate with an allowed hash is yanked,
+        we still want to use that candidate.
+
+        Second, excepting hash considerations, candidates that have been
+        yanked (in the sense of PEP 592) are always less preferred than
+        candidates that haven't been yanked. Then:
+
+        If not finding wheels, they are sorted by version only.
+        If finding wheels, then the sort order is by version, then:
+          1. existing installs
+          2. wheels ordered via Wheel.support_index_min(self._supported_tags)
+          3. source archives
+        If prefer_binary was set, then all wheels are sorted above sources.
+
+        Note: it was considered to embed this logic into the Link
+              comparison operators, but then different sdist links
+              with the same version, would have to be considered equal
+        """
+        valid_tags = self._supported_tags
+        support_num = len(valid_tags)
+        build_tag = ()  # type: BuildTag
+        binary_preference = 0
+        link = candidate.link
+        if link.is_wheel:
+            # can raise InvalidWheelFilename
+            wheel = Wheel(link.filename)
+            if not wheel.supported(valid_tags):
+                raise UnsupportedWheel(
+                    "{} is not a supported wheel for this platform. It "
+                    "can't be sorted.".format(wheel.filename)
+                )
+            if self._prefer_binary:
+                binary_preference = 1
+            pri = -(wheel.support_index_min(valid_tags))
+            if wheel.build_tag is not None:
+                match = re.match(r'^(\d+)(.*)$', wheel.build_tag)
+                build_tag_groups = match.groups()
+                build_tag = (int(build_tag_groups[0]), build_tag_groups[1])
+        else:  # sdist
+            pri = -(support_num)
+        has_allowed_hash = int(link.is_hash_allowed(self._hashes))
+        yank_value = -1 * int(link.is_yanked)  # -1 for yanked.
+        return (
+            has_allowed_hash, yank_value, binary_preference, candidate.version,
+            build_tag, pri,
+        )
+
+    def sort_best_candidate(
+        self,
+        candidates,    # type: List[InstallationCandidate]
+    ):
+        # type: (...) -> Optional[InstallationCandidate]
+        """
+        Return the best candidate per the instance's sort order, or None if
+        no candidate is acceptable.
+        """
+        if not candidates:
+            return None
+        best_candidate = max(candidates, key=self._sort_key)
+        return best_candidate
+
+    def compute_best_candidate(
+        self,
+        candidates,      # type: List[InstallationCandidate]
+    ):
+        # type: (...) -> BestCandidateResult
+        """
+        Compute and return a `BestCandidateResult` instance.
+        """
+        applicable_candidates = self.get_applicable_candidates(candidates)
+
+        best_candidate = self.sort_best_candidate(applicable_candidates)
+
+        return BestCandidateResult(
+            candidates,
+            applicable_candidates=applicable_candidates,
+            best_candidate=best_candidate,
+        )
+
+
+class PackageFinder(object):
+    """This finds packages.
+
+    This is meant to match easy_install's technique for looking for
+    packages, by reading pages and looking for appropriate links.
+    """
+
+    def __init__(
+        self,
+        link_collector,       # type: LinkCollector
+        target_python,        # type: TargetPython
+        allow_yanked,         # type: bool
+        format_control=None,  # type: Optional[FormatControl]
+        candidate_prefs=None,         # type: CandidatePreferences
+        ignore_requires_python=None,  # type: Optional[bool]
+    ):
+        # type: (...) -> None
+        """
+        This constructor is primarily meant to be used by the create() class
+        method and from tests.
+
+        :param format_control: A FormatControl object, used to control
+            the selection of source packages / binary packages when consulting
+            the index and links.
+        :param candidate_prefs: Options to use when creating a
+            CandidateEvaluator object.
+        """
+        if candidate_prefs is None:
+            candidate_prefs = CandidatePreferences()
+
+        format_control = format_control or FormatControl(set(), set())
+
+        self._allow_yanked = allow_yanked
+        self._candidate_prefs = candidate_prefs
+        self._ignore_requires_python = ignore_requires_python
+        self._link_collector = link_collector
+        self._target_python = target_python
+
+        self.format_control = format_control
+
+        # These are boring links that have already been logged somehow.
+        self._logged_links = set()  # type: Set[Link]
+
+    # Don't include an allow_yanked default value to make sure each call
+    # site considers whether yanked releases are allowed. This also causes
+    # that decision to be made explicit in the calling code, which helps
+    # people when reading the code.
+    @classmethod
+    def create(
+        cls,
+        link_collector,      # type: LinkCollector
+        selection_prefs,     # type: SelectionPreferences
+        target_python=None,  # type: Optional[TargetPython]
+    ):
+        # type: (...) -> PackageFinder
+        """Create a PackageFinder.
+
+        :param selection_prefs: The candidate selection preferences, as a
+            SelectionPreferences object.
+        :param target_python: The target Python interpreter to use when
+            checking compatibility. If None (the default), a TargetPython
+            object will be constructed from the running Python.
+        """
+        if target_python is None:
+            target_python = TargetPython()
+
+        candidate_prefs = CandidatePreferences(
+            prefer_binary=selection_prefs.prefer_binary,
+            allow_all_prereleases=selection_prefs.allow_all_prereleases,
+        )
+
+        return cls(
+            candidate_prefs=candidate_prefs,
+            link_collector=link_collector,
+            target_python=target_python,
+            allow_yanked=selection_prefs.allow_yanked,
+            format_control=selection_prefs.format_control,
+            ignore_requires_python=selection_prefs.ignore_requires_python,
+        )
+
+    @property
+    def target_python(self):
+        # type: () -> TargetPython
+        return self._target_python
+
+    @property
+    def search_scope(self):
+        # type: () -> SearchScope
+        return self._link_collector.search_scope
+
+    @search_scope.setter
+    def search_scope(self, search_scope):
+        # type: (SearchScope) -> None
+        self._link_collector.search_scope = search_scope
+
+    @property
+    def find_links(self):
+        # type: () -> List[str]
+        return self._link_collector.find_links
+
+    @property
+    def index_urls(self):
+        # type: () -> List[str]
+        return self.search_scope.index_urls
+
+    @property
+    def trusted_hosts(self):
+        # type: () -> Iterable[str]
+        for host_port in self._link_collector.session.pip_trusted_origins:
+            yield build_netloc(*host_port)
+
+    @property
+    def allow_all_prereleases(self):
+        # type: () -> bool
+        return self._candidate_prefs.allow_all_prereleases
+
+    def set_allow_all_prereleases(self):
+        # type: () -> None
+        self._candidate_prefs.allow_all_prereleases = True
+
+    @property
+    def prefer_binary(self):
+        # type: () -> bool
+        return self._candidate_prefs.prefer_binary
+
+    def set_prefer_binary(self):
+        # type: () -> None
+        self._candidate_prefs.prefer_binary = True
+
+    def make_link_evaluator(self, project_name):
+        # type: (str) -> LinkEvaluator
+        canonical_name = canonicalize_name(project_name)
+        formats = self.format_control.get_allowed_formats(canonical_name)
+
+        return LinkEvaluator(
+            project_name=project_name,
+            canonical_name=canonical_name,
+            formats=formats,
+            target_python=self._target_python,
+            allow_yanked=self._allow_yanked,
+            ignore_requires_python=self._ignore_requires_python,
+        )
+
+    def _sort_links(self, links):
+        # type: (Iterable[Link]) -> List[Link]
+        """
+        Returns elements of links in order, non-egg links first, egg links
+        second, while eliminating duplicates
+        """
+        eggs, no_eggs = [], []
+        seen = set()  # type: Set[Link]
+        for link in links:
+            if link not in seen:
+                seen.add(link)
+                if link.egg_fragment:
+                    eggs.append(link)
+                else:
+                    no_eggs.append(link)
+        return no_eggs + eggs
+
+    def _log_skipped_link(self, link, reason):
+        # type: (Link, Text) -> None
+        if link not in self._logged_links:
+            # Mark this as a unicode string to prevent "UnicodeEncodeError:
+            # 'ascii' codec can't encode character" in Python 2 when
+            # the reason contains non-ascii characters.
+            #   Also, put the link at the end so the reason is more visible
+            # and because the link string is usually very long.
+            logger.debug(u'Skipping link: %s: %s', reason, link)
+            self._logged_links.add(link)
+
+    def get_install_candidate(self, link_evaluator, link):
+        # type: (LinkEvaluator, Link) -> Optional[InstallationCandidate]
+        """
+        If the link is a candidate for install, convert it to an
+        InstallationCandidate and return it. Otherwise, return None.
+        """
+        is_candidate, result = link_evaluator.evaluate_link(link)
+        if not is_candidate:
+            if result:
+                self._log_skipped_link(link, reason=result)
+            return None
+
+        return InstallationCandidate(
+            name=link_evaluator.project_name,
+            link=link,
+            # Convert the Text result to str since InstallationCandidate
+            # accepts str.
+            version=str(result),
+        )
+
+    def evaluate_links(self, link_evaluator, links):
+        # type: (LinkEvaluator, Iterable[Link]) -> List[InstallationCandidate]
+        """
+        Convert links that are candidates to InstallationCandidate objects.
+        """
+        candidates = []
+        for link in self._sort_links(links):
+            candidate = self.get_install_candidate(link_evaluator, link)
+            if candidate is not None:
+                candidates.append(candidate)
+
+        return candidates
+
+    def process_project_url(self, project_url, link_evaluator):
+        # type: (Link, LinkEvaluator) -> List[InstallationCandidate]
+        logger.debug(
+            'Fetching project page and analyzing links: %s', project_url,
+        )
+        html_page = self._link_collector.fetch_page(project_url)
+        if html_page is None:
+            return []
+
+        page_links = list(parse_links(html_page))
+
+        with indent_log():
+            package_links = self.evaluate_links(
+                link_evaluator,
+                links=page_links,
+            )
+
+        return package_links
+
+    def find_all_candidates(self, project_name):
+        # type: (str) -> List[InstallationCandidate]
+        """Find all available InstallationCandidate for project_name
+
+        This checks index_urls and find_links.
+        All versions found are returned as an InstallationCandidate list.
+
+        See LinkEvaluator.evaluate_link() for details on which files
+        are accepted.
+        """
+        collected_links = self._link_collector.collect_links(project_name)
+
+        link_evaluator = self.make_link_evaluator(project_name)
+
+        find_links_versions = self.evaluate_links(
+            link_evaluator,
+            links=collected_links.find_links,
+        )
+
+        page_versions = []
+        for project_url in collected_links.project_urls:
+            package_links = self.process_project_url(
+                project_url, link_evaluator=link_evaluator,
+            )
+            page_versions.extend(package_links)
+
+        file_versions = self.evaluate_links(
+            link_evaluator,
+            links=collected_links.files,
+        )
+        if file_versions:
+            file_versions.sort(reverse=True)
+            logger.debug(
+                'Local files found: %s',
+                ', '.join([
+                    url_to_path(candidate.link.url)
+                    for candidate in file_versions
+                ])
+            )
+
+        # This is an intentional priority ordering
+        return file_versions + find_links_versions + page_versions
+
+    def make_candidate_evaluator(
+        self,
+        project_name,    # type: str
+        specifier=None,  # type: Optional[specifiers.BaseSpecifier]
+        hashes=None,     # type: Optional[Hashes]
+    ):
+        # type: (...) -> CandidateEvaluator
+        """Create a CandidateEvaluator object to use.
+        """
+        candidate_prefs = self._candidate_prefs
+        return CandidateEvaluator.create(
+            project_name=project_name,
+            target_python=self._target_python,
+            prefer_binary=candidate_prefs.prefer_binary,
+            allow_all_prereleases=candidate_prefs.allow_all_prereleases,
+            specifier=specifier,
+            hashes=hashes,
+        )
+
+    def find_best_candidate(
+        self,
+        project_name,       # type: str
+        specifier=None,     # type: Optional[specifiers.BaseSpecifier]
+        hashes=None,        # type: Optional[Hashes]
+    ):
+        # type: (...) -> BestCandidateResult
+        """Find matches for the given project and specifier.
+
+        :param specifier: An optional object implementing `filter`
+            (e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
+            versions.
+
+        :return: A `BestCandidateResult` instance.
+        """
+        candidates = self.find_all_candidates(project_name)
+        candidate_evaluator = self.make_candidate_evaluator(
+            project_name=project_name,
+            specifier=specifier,
+            hashes=hashes,
+        )
+        return candidate_evaluator.compute_best_candidate(candidates)
+
+    def find_requirement(self, req, upgrade):
+        # type: (InstallRequirement, bool) -> Optional[InstallationCandidate]
+        """Try to find a Link matching req
+
+        Expects req, an InstallRequirement and upgrade, a boolean
+        Returns a InstallationCandidate if found,
+        Raises DistributionNotFound or BestVersionAlreadyInstalled otherwise
+        """
+        hashes = req.hashes(trust_internet=False)
+        best_candidate_result = self.find_best_candidate(
+            req.name, specifier=req.specifier, hashes=hashes,
+        )
+        best_candidate = best_candidate_result.best_candidate
+
+        installed_version = None    # type: Optional[_BaseVersion]
+        if req.satisfied_by is not None:
+            installed_version = parse_version(req.satisfied_by.version)
+
+        def _format_versions(cand_iter):
+            # type: (Iterable[InstallationCandidate]) -> str
+            # This repeated parse_version and str() conversion is needed to
+            # handle different vendoring sources from pip and pkg_resources.
+            # If we stop using the pkg_resources provided specifier and start
+            # using our own, we can drop the cast to str().
+            return ", ".join(sorted(
+                {str(c.version) for c in cand_iter},
+                key=parse_version,
+            )) or "none"
+
+        if installed_version is None and best_candidate is None:
+            logger.critical(
+                'Could not find a version that satisfies the requirement %s '
+                '(from versions: %s)',
+                req,
+                _format_versions(best_candidate_result.iter_all()),
+            )
+
+            raise DistributionNotFound(
+                'No matching distribution found for {}'.format(
+                    req)
+            )
+
+        best_installed = False
+        if installed_version and (
+                best_candidate is None or
+                best_candidate.version <= installed_version):
+            best_installed = True
+
+        if not upgrade and installed_version is not None:
+            if best_installed:
+                logger.debug(
+                    'Existing installed version (%s) is most up-to-date and '
+                    'satisfies requirement',
+                    installed_version,
+                )
+            else:
+                logger.debug(
+                    'Existing installed version (%s) satisfies requirement '
+                    '(most up-to-date version is %s)',
+                    installed_version,
+                    best_candidate.version,
+                )
+            return None
+
+        if best_installed:
+            # We have an existing version, and its the best version
+            logger.debug(
+                'Installed version (%s) is most up-to-date (past versions: '
+                '%s)',
+                installed_version,
+                _format_versions(best_candidate_result.iter_applicable()),
+            )
+            raise BestVersionAlreadyInstalled
+
+        logger.debug(
+            'Using version %s (newest of versions: %s)',
+            best_candidate.version,
+            _format_versions(best_candidate_result.iter_applicable()),
+        )
+        return best_candidate
+
+
+def _find_name_version_sep(fragment, canonical_name):
+    # type: (str, str) -> int
+    """Find the separator's index based on the package's canonical name.
+
+    :param fragment: A <package>+<version> filename "fragment" (stem) or
+        egg fragment.
+    :param canonical_name: The package's canonical name.
+
+    This function is needed since the canonicalized name does not necessarily
+    have the same length as the egg info's name part. An example::
+
+    >>> fragment = 'foo__bar-1.0'
+    >>> canonical_name = 'foo-bar'
+    >>> _find_name_version_sep(fragment, canonical_name)
+    8
+    """
+    # Project name and version must be separated by one single dash. Find all
+    # occurrences of dashes; if the string in front of it matches the canonical
+    # name, this is the one separating the name and version parts.
+    for i, c in enumerate(fragment):
+        if c != "-":
+            continue
+        if canonicalize_name(fragment[:i]) == canonical_name:
+            return i
+    raise ValueError("{} does not match {}".format(fragment, canonical_name))
+
+
+def _extract_version_from_fragment(fragment, canonical_name):
+    # type: (str, str) -> Optional[str]
+    """Parse the version string from a <package>+<version> filename
+    "fragment" (stem) or egg fragment.
+
+    :param fragment: The string to parse. E.g. foo-2.1
+    :param canonical_name: The canonicalized name of the package this
+        belongs to.
+    """
+    try:
+        version_start = _find_name_version_sep(fragment, canonical_name) + 1
+    except ValueError:
+        return None
+    version = fragment[version_start:]
+    if not version:
+        return None
+    return version
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/locations.py b/myenv/lib/python3.9/site-packages/pip/_internal/locations.py
new file mode 100644
index 0000000..0c12354
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/locations.py
@@ -0,0 +1,194 @@
+"""Locations where we look for configs, install stuff, etc"""
+
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
+
+from __future__ import absolute_import
+
+import os
+import os.path
+import platform
+import site
+import sys
+import sysconfig
+from distutils import sysconfig as distutils_sysconfig
+from distutils.command.install import SCHEME_KEYS  # type: ignore
+from distutils.command.install import install as distutils_install_command
+
+from pip._internal.models.scheme import Scheme
+from pip._internal.utils import appdirs
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING, cast
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+if MYPY_CHECK_RUNNING:
+    from typing import Dict, List, Optional, Union
+
+    from distutils.cmd import Command as DistutilsCommand
+
+
+# Application Directories
+USER_CACHE_DIR = appdirs.user_cache_dir("pip")
+
+
+def get_major_minor_version():
+    # type: () -> str
+    """
+    Return the major-minor version of the current Python as a string, e.g.
+    "3.7" or "3.10".
+    """
+    return '{}.{}'.format(*sys.version_info)
+
+
+def get_src_prefix():
+    # type: () -> str
+    if running_under_virtualenv():
+        src_prefix = os.path.join(sys.prefix, 'src')
+    else:
+        # FIXME: keep src in cwd for now (it is not a temporary folder)
+        try:
+            src_prefix = os.path.join(os.getcwd(), 'src')
+        except OSError:
+            # In case the current working directory has been renamed or deleted
+            sys.exit(
+                "The folder you are executing pip from can no longer be found."
+            )
+
+    # under macOS + virtualenv sys.prefix is not properly resolved
+    # it is something like /path/to/python/bin/..
+    return os.path.abspath(src_prefix)
+
+
+# FIXME doesn't account for venv linked to global site-packages
+
+site_packages = sysconfig.get_path("purelib")  # type: Optional[str]
+
+# This is because of a bug in PyPy's sysconfig module, see
+# https://bitbucket.org/pypy/pypy/issues/2506/sysconfig-returns-incorrect-paths
+# for more information.
+if platform.python_implementation().lower() == "pypy":
+    site_packages = distutils_sysconfig.get_python_lib()
+try:
+    # Use getusersitepackages if this is present, as it ensures that the
+    # value is initialised properly.
+    user_site = site.getusersitepackages()
+except AttributeError:
+    user_site = site.USER_SITE
+
+if WINDOWS:
+    bin_py = os.path.join(sys.prefix, 'Scripts')
+    bin_user = os.path.join(user_site, 'Scripts')
+    # buildout uses 'bin' on Windows too?
+    if not os.path.exists(bin_py):
+        bin_py = os.path.join(sys.prefix, 'bin')
+        bin_user = os.path.join(user_site, 'bin')
+else:
+    bin_py = os.path.join(sys.prefix, 'bin')
+    bin_user = os.path.join(user_site, 'bin')
+
+    # Forcing to use /usr/local/bin for standard macOS framework installs
+    # Also log to ~/Library/Logs/ for use with the Console.app log viewer
+    if sys.platform[:6] == 'darwin' and sys.prefix[:16] == '/System/Library/':
+        bin_py = '/usr/local/bin'
+
+
+def distutils_scheme(
+    dist_name, user=False, home=None, root=None, isolated=False, prefix=None
+):
+    # type:(str, bool, str, str, bool, str) -> Dict[str, str]
+    """
+    Return a distutils install scheme
+    """
+    from distutils.dist import Distribution
+
+    dist_args = {'name': dist_name}  # type: Dict[str, Union[str, List[str]]]
+    if isolated:
+        dist_args["script_args"] = ["--no-user-cfg"]
+
+    d = Distribution(dist_args)
+    d.parse_config_files()
+    obj = None  # type: Optional[DistutilsCommand]
+    obj = d.get_command_obj('install', create=True)
+    assert obj is not None
+    i = cast(distutils_install_command, obj)
+    # NOTE: setting user or home has the side-effect of creating the home dir
+    # or user base for installations during finalize_options()
+    # ideally, we'd prefer a scheme class that has no side-effects.
+    assert not (user and prefix), "user={} prefix={}".format(user, prefix)
+    assert not (home and prefix), "home={} prefix={}".format(home, prefix)
+    i.user = user or i.user
+    if user or home:
+        i.prefix = ""
+    i.prefix = prefix or i.prefix
+    i.home = home or i.home
+    i.root = root or i.root
+    i.finalize_options()
+
+    scheme = {}
+    for key in SCHEME_KEYS:
+        scheme[key] = getattr(i, 'install_' + key)
+
+    # install_lib specified in setup.cfg should install *everything*
+    # into there (i.e. it takes precedence over both purelib and
+    # platlib).  Note, i.install_lib is *always* set after
+    # finalize_options(); we only want to override here if the user
+    # has explicitly requested it hence going back to the config
+    if 'install_lib' in d.get_option_dict('install'):
+        scheme.update(dict(purelib=i.install_lib, platlib=i.install_lib))
+
+    if running_under_virtualenv():
+        scheme['headers'] = os.path.join(
+            i.prefix,
+            'include',
+            'site',
+            'python{}'.format(get_major_minor_version()),
+            dist_name,
+        )
+
+        if root is not None:
+            path_no_drive = os.path.splitdrive(
+                os.path.abspath(scheme["headers"]))[1]
+            scheme["headers"] = os.path.join(
+                root,
+                path_no_drive[1:],
+            )
+
+    return scheme
+
+
+def get_scheme(
+    dist_name,  # type: str
+    user=False,  # type: bool
+    home=None,  # type: Optional[str]
+    root=None,  # type: Optional[str]
+    isolated=False,  # type: bool
+    prefix=None,  # type: Optional[str]
+):
+    # type: (...) -> Scheme
+    """
+    Get the "scheme" corresponding to the input parameters. The distutils
+    documentation provides the context for the available schemes:
+    https://docs.python.org/3/install/index.html#alternate-installation
+
+    :param dist_name: the name of the package to retrieve the scheme for, used
+        in the headers scheme path
+    :param user: indicates to use the "user" scheme
+    :param home: indicates to use the "home" scheme and provides the base
+        directory for the same
+    :param root: root under which other directories are re-based
+    :param isolated: equivalent to --no-user-cfg, i.e. do not consider
+        ~/.pydistutils.cfg (posix) or ~/pydistutils.cfg (non-posix) for
+        scheme paths
+    :param prefix: indicates to use the "prefix" scheme and provides the
+        base directory for the same
+    """
+    scheme = distutils_scheme(
+        dist_name, user, home, root, isolated, prefix
+    )
+    return Scheme(
+        platlib=scheme["platlib"],
+        purelib=scheme["purelib"],
+        headers=scheme["headers"],
+        scripts=scheme["scripts"],
+        data=scheme["data"],
+    )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/main.py b/myenv/lib/python3.9/site-packages/pip/_internal/main.py
new file mode 100644
index 0000000..3208d5b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/main.py
@@ -0,0 +1,16 @@
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, List
+
+
+def main(args=None):
+    # type: (Optional[List[str]]) -> int
+    """This is preserved for old console scripts that may still be referencing
+    it.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/models/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/models/__init__.py
new file mode 100644
index 0000000..7855226
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/models/__init__.py
@@ -0,0 +1,2 @@
+"""A package that contains models that represent entities.
+"""
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/models/candidate.py b/myenv/lib/python3.9/site-packages/pip/_internal/models/candidate.py
new file mode 100644
index 0000000..9149e0f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/models/candidate.py
@@ -0,0 +1,38 @@
+from pip._vendor.packaging.version import parse as parse_version
+
+from pip._internal.utils.models import KeyBasedCompareMixin
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from pip._vendor.packaging.version import _BaseVersion
+    from pip._internal.models.link import Link
+
+
+class InstallationCandidate(KeyBasedCompareMixin):
+    """Represents a potential "candidate" for installation.
+    """
+
+    __slots__ = ["name", "version", "link"]
+
+    def __init__(self, name, version, link):
+        # type: (str, str, Link) -> None
+        self.name = name
+        self.version = parse_version(version)  # type: _BaseVersion
+        self.link = link
+
+        super(InstallationCandidate, self).__init__(
+            key=(self.name, self.version, self.link),
+            defining_class=InstallationCandidate
+        )
+
+    def __repr__(self):
+        # type: () -> str
+        return "<InstallationCandidate({!r}, {!r}, {!r})>".format(
+            self.name, self.version, self.link,
+        )
+
+    def __str__(self):
+        # type: () -> str
+        return '{!r} candidate (version {} at {})'.format(
+            self.name, self.version, self.link,
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/models/direct_url.py b/myenv/lib/python3.9/site-packages/pip/_internal/models/direct_url.py
new file mode 100644
index 0000000..87bd9fe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/models/direct_url.py
@@ -0,0 +1,245 @@
+""" PEP 610 """
+import json
+import re
+
+from pip._vendor import six
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Any, Dict, Iterable, Optional, Type, TypeVar, Union
+    )
+
+    T = TypeVar("T")
+
+
+DIRECT_URL_METADATA_NAME = "direct_url.json"
+ENV_VAR_RE = re.compile(r"^\$\{[A-Za-z0-9-_]+\}(:\$\{[A-Za-z0-9-_]+\})?$")
+
+__all__ = [
+    "DirectUrl",
+    "DirectUrlValidationError",
+    "DirInfo",
+    "ArchiveInfo",
+    "VcsInfo",
+]
+
+
+class DirectUrlValidationError(Exception):
+    pass
+
+
+def _get(d, expected_type, key, default=None):
+    # type: (Dict[str, Any], Type[T], str, Optional[T]) -> Optional[T]
+    """Get value from dictionary and verify expected type."""
+    if key not in d:
+        return default
+    value = d[key]
+    if six.PY2 and expected_type is str:
+        expected_type = six.string_types  # type: ignore
+    if not isinstance(value, expected_type):
+        raise DirectUrlValidationError(
+            "{!r} has unexpected type for {} (expected {})".format(
+                value, key, expected_type
+            )
+        )
+    return value
+
+
+def _get_required(d, expected_type, key, default=None):
+    # type: (Dict[str, Any], Type[T], str, Optional[T]) -> T
+    value = _get(d, expected_type, key, default)
+    if value is None:
+        raise DirectUrlValidationError("{} must have a value".format(key))
+    return value
+
+
+def _exactly_one_of(infos):
+    # type: (Iterable[Optional[InfoType]]) -> InfoType
+    infos = [info for info in infos if info is not None]
+    if not infos:
+        raise DirectUrlValidationError(
+            "missing one of archive_info, dir_info, vcs_info"
+        )
+    if len(infos) > 1:
+        raise DirectUrlValidationError(
+            "more than one of archive_info, dir_info, vcs_info"
+        )
+    assert infos[0] is not None
+    return infos[0]
+
+
+def _filter_none(**kwargs):
+    # type: (Any) -> Dict[str, Any]
+    """Make dict excluding None values."""
+    return {k: v for k, v in kwargs.items() if v is not None}
+
+
+class VcsInfo(object):
+    name = "vcs_info"
+
+    def __init__(
+        self,
+        vcs,  # type: str
+        commit_id,  # type: str
+        requested_revision=None,  # type: Optional[str]
+        resolved_revision=None,  # type: Optional[str]
+        resolved_revision_type=None,  # type: Optional[str]
+    ):
+        self.vcs = vcs
+        self.requested_revision = requested_revision
+        self.commit_id = commit_id
+        self.resolved_revision = resolved_revision
+        self.resolved_revision_type = resolved_revision_type
+
+    @classmethod
+    def _from_dict(cls, d):
+        # type: (Optional[Dict[str, Any]]) -> Optional[VcsInfo]
+        if d is None:
+            return None
+        return cls(
+            vcs=_get_required(d, str, "vcs"),
+            commit_id=_get_required(d, str, "commit_id"),
+            requested_revision=_get(d, str, "requested_revision"),
+            resolved_revision=_get(d, str, "resolved_revision"),
+            resolved_revision_type=_get(d, str, "resolved_revision_type"),
+        )
+
+    def _to_dict(self):
+        # type: () -> Dict[str, Any]
+        return _filter_none(
+            vcs=self.vcs,
+            requested_revision=self.requested_revision,
+            commit_id=self.commit_id,
+            resolved_revision=self.resolved_revision,
+            resolved_revision_type=self.resolved_revision_type,
+        )
+
+
+class ArchiveInfo(object):
+    name = "archive_info"
+
+    def __init__(
+        self,
+        hash=None,  # type: Optional[str]
+    ):
+        self.hash = hash
+
+    @classmethod
+    def _from_dict(cls, d):
+        # type: (Optional[Dict[str, Any]]) -> Optional[ArchiveInfo]
+        if d is None:
+            return None
+        return cls(hash=_get(d, str, "hash"))
+
+    def _to_dict(self):
+        # type: () -> Dict[str, Any]
+        return _filter_none(hash=self.hash)
+
+
+class DirInfo(object):
+    name = "dir_info"
+
+    def __init__(
+        self,
+        editable=False,  # type: bool
+    ):
+        self.editable = editable
+
+    @classmethod
+    def _from_dict(cls, d):
+        # type: (Optional[Dict[str, Any]]) -> Optional[DirInfo]
+        if d is None:
+            return None
+        return cls(
+            editable=_get_required(d, bool, "editable", default=False)
+        )
+
+    def _to_dict(self):
+        # type: () -> Dict[str, Any]
+        return _filter_none(editable=self.editable or None)
+
+
+if MYPY_CHECK_RUNNING:
+    InfoType = Union[ArchiveInfo, DirInfo, VcsInfo]
+
+
+class DirectUrl(object):
+
+    def __init__(
+        self,
+        url,  # type: str
+        info,  # type: InfoType
+        subdirectory=None,  # type: Optional[str]
+    ):
+        self.url = url
+        self.info = info
+        self.subdirectory = subdirectory
+
+    def _remove_auth_from_netloc(self, netloc):
+        # type: (str) -> str
+        if "@" not in netloc:
+            return netloc
+        user_pass, netloc_no_user_pass = netloc.split("@", 1)
+        if (
+            isinstance(self.info, VcsInfo) and
+            self.info.vcs == "git" and
+            user_pass == "git"
+        ):
+            return netloc
+        if ENV_VAR_RE.match(user_pass):
+            return netloc
+        return netloc_no_user_pass
+
+    @property
+    def redacted_url(self):
+        # type: () -> str
+        """url with user:password part removed unless it is formed with
+        environment variables as specified in PEP 610, or it is ``git``
+        in the case of a git URL.
+        """
+        purl = urllib_parse.urlsplit(self.url)
+        netloc = self._remove_auth_from_netloc(purl.netloc)
+        surl = urllib_parse.urlunsplit(
+            (purl.scheme, netloc, purl.path, purl.query, purl.fragment)
+        )
+        return surl
+
+    def validate(self):
+        # type: () -> None
+        self.from_dict(self.to_dict())
+
+    @classmethod
+    def from_dict(cls, d):
+        # type: (Dict[str, Any]) -> DirectUrl
+        return DirectUrl(
+            url=_get_required(d, str, "url"),
+            subdirectory=_get(d, str, "subdirectory"),
+            info=_exactly_one_of(
+                [
+                    ArchiveInfo._from_dict(_get(d, dict, "archive_info")),
+                    DirInfo._from_dict(_get(d, dict, "dir_info")),
+                    VcsInfo._from_dict(_get(d, dict, "vcs_info")),
+                ]
+            ),
+        )
+
+    def to_dict(self):
+        # type: () -> Dict[str, Any]
+        res = _filter_none(
+            url=self.redacted_url,
+            subdirectory=self.subdirectory,
+        )
+        res[self.info.name] = self.info._to_dict()
+        return res
+
+    @classmethod
+    def from_json(cls, s):
+        # type: (str) -> DirectUrl
+        return cls.from_dict(json.loads(s))
+
+    def to_json(self):
+        # type: () -> str
+        return json.dumps(self.to_dict(), sort_keys=True)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/models/format_control.py b/myenv/lib/python3.9/site-packages/pip/_internal/models/format_control.py
new file mode 100644
index 0000000..c6275e7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/models/format_control.py
@@ -0,0 +1,92 @@
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.exceptions import CommandError
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, Set, FrozenSet
+
+
+class FormatControl(object):
+    """Helper for managing formats from which a package can be installed.
+    """
+
+    __slots__ = ["no_binary", "only_binary"]
+
+    def __init__(self, no_binary=None, only_binary=None):
+        # type: (Optional[Set[str]], Optional[Set[str]]) -> None
+        if no_binary is None:
+            no_binary = set()
+        if only_binary is None:
+            only_binary = set()
+
+        self.no_binary = no_binary
+        self.only_binary = only_binary
+
+    def __eq__(self, other):
+        # type: (object) -> bool
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+
+        if self.__slots__ != other.__slots__:
+            return False
+
+        return all(
+            getattr(self, k) == getattr(other, k)
+            for k in self.__slots__
+        )
+
+    def __ne__(self, other):
+        # type: (object) -> bool
+        return not self.__eq__(other)
+
+    def __repr__(self):
+        # type: () -> str
+        return "{}({}, {})".format(
+            self.__class__.__name__,
+            self.no_binary,
+            self.only_binary
+        )
+
+    @staticmethod
+    def handle_mutual_excludes(value, target, other):
+        # type: (str, Set[str], Set[str]) -> None
+        if value.startswith('-'):
+            raise CommandError(
+                "--no-binary / --only-binary option requires 1 argument."
+            )
+        new = value.split(',')
+        while ':all:' in new:
+            other.clear()
+            target.clear()
+            target.add(':all:')
+            del new[:new.index(':all:') + 1]
+            # Without a none, we want to discard everything as :all: covers it
+            if ':none:' not in new:
+                return
+        for name in new:
+            if name == ':none:':
+                target.clear()
+                continue
+            name = canonicalize_name(name)
+            other.discard(name)
+            target.add(name)
+
+    def get_allowed_formats(self, canonical_name):
+        # type: (str) -> FrozenSet[str]
+        result = {"binary", "source"}
+        if canonical_name in self.only_binary:
+            result.discard('source')
+        elif canonical_name in self.no_binary:
+            result.discard('binary')
+        elif ':all:' in self.only_binary:
+            result.discard('source')
+        elif ':all:' in self.no_binary:
+            result.discard('binary')
+        return frozenset(result)
+
+    def disallow_binaries(self):
+        # type: () -> None
+        self.handle_mutual_excludes(
+            ':all:', self.no_binary, self.only_binary,
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/models/index.py b/myenv/lib/python3.9/site-packages/pip/_internal/models/index.py
new file mode 100644
index 0000000..5b4a1fe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/models/index.py
@@ -0,0 +1,34 @@
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+
+
+class PackageIndex(object):
+    """Represents a Package Index and provides easier access to endpoints
+    """
+
+    __slots__ = ['url', 'netloc', 'simple_url', 'pypi_url',
+                 'file_storage_domain']
+
+    def __init__(self, url, file_storage_domain):
+        # type: (str, str) -> None
+        super(PackageIndex, self).__init__()
+        self.url = url
+        self.netloc = urllib_parse.urlsplit(url).netloc
+        self.simple_url = self._url_for_path('simple')
+        self.pypi_url = self._url_for_path('pypi')
+
+        # This is part of a temporary hack used to block installs of PyPI
+        # packages which depend on external urls only necessary until PyPI can
+        # block such packages themselves
+        self.file_storage_domain = file_storage_domain
+
+    def _url_for_path(self, path):
+        # type: (str) -> str
+        return urllib_parse.urljoin(self.url, path)
+
+
+PyPI = PackageIndex(
+    'https://pypi.org/', file_storage_domain='files.pythonhosted.org'
+)
+TestPyPI = PackageIndex(
+    'https://test.pypi.org/', file_storage_domain='test-files.pythonhosted.org'
+)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/models/link.py b/myenv/lib/python3.9/site-packages/pip/_internal/models/link.py
new file mode 100644
index 0000000..c0d278a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/models/link.py
@@ -0,0 +1,245 @@
+import os
+import posixpath
+import re
+
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+
+from pip._internal.utils.filetypes import WHEEL_EXTENSION
+from pip._internal.utils.misc import (
+    redact_auth_from_url,
+    split_auth_from_netloc,
+    splitext,
+)
+from pip._internal.utils.models import KeyBasedCompareMixin
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.urls import path_to_url, url_to_path
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, Text, Tuple, Union
+    from pip._internal.index.collector import HTMLPage
+    from pip._internal.utils.hashes import Hashes
+
+
+class Link(KeyBasedCompareMixin):
+    """Represents a parsed link from a Package Index's simple URL
+    """
+
+    __slots__ = [
+        "_parsed_url",
+        "_url",
+        "comes_from",
+        "requires_python",
+        "yanked_reason",
+        "cache_link_parsing",
+    ]
+
+    def __init__(
+        self,
+        url,                   # type: str
+        comes_from=None,       # type: Optional[Union[str, HTMLPage]]
+        requires_python=None,  # type: Optional[str]
+        yanked_reason=None,    # type: Optional[Text]
+        cache_link_parsing=True,  # type: bool
+    ):
+        # type: (...) -> None
+        """
+        :param url: url of the resource pointed to (href of the link)
+        :param comes_from: instance of HTMLPage where the link was found,
+            or string.
+        :param requires_python: String containing the `Requires-Python`
+            metadata field, specified in PEP 345. This may be specified by
+            a data-requires-python attribute in the HTML link tag, as
+            described in PEP 503.
+        :param yanked_reason: the reason the file has been yanked, if the
+            file has been yanked, or None if the file hasn't been yanked.
+            This is the value of the "data-yanked" attribute, if present, in
+            a simple repository HTML link. If the file has been yanked but
+            no reason was provided, this should be the empty string. See
+            PEP 592 for more information and the specification.
+        :param cache_link_parsing: A flag that is used elsewhere to determine
+                                   whether resources retrieved from this link
+                                   should be cached. PyPI index urls should
+                                   generally have this set to False, for
+                                   example.
+        """
+
+        # url can be a UNC windows share
+        if url.startswith('\\\\'):
+            url = path_to_url(url)
+
+        self._parsed_url = urllib_parse.urlsplit(url)
+        # Store the url as a private attribute to prevent accidentally
+        # trying to set a new value.
+        self._url = url
+
+        self.comes_from = comes_from
+        self.requires_python = requires_python if requires_python else None
+        self.yanked_reason = yanked_reason
+
+        super(Link, self).__init__(key=url, defining_class=Link)
+
+        self.cache_link_parsing = cache_link_parsing
+
+    def __str__(self):
+        # type: () -> str
+        if self.requires_python:
+            rp = ' (requires-python:{})'.format(self.requires_python)
+        else:
+            rp = ''
+        if self.comes_from:
+            return '{} (from {}){}'.format(
+                redact_auth_from_url(self._url), self.comes_from, rp)
+        else:
+            return redact_auth_from_url(str(self._url))
+
+    def __repr__(self):
+        # type: () -> str
+        return '<Link {}>'.format(self)
+
+    @property
+    def url(self):
+        # type: () -> str
+        return self._url
+
+    @property
+    def filename(self):
+        # type: () -> str
+        path = self.path.rstrip('/')
+        name = posixpath.basename(path)
+        if not name:
+            # Make sure we don't leak auth information if the netloc
+            # includes a username and password.
+            netloc, user_pass = split_auth_from_netloc(self.netloc)
+            return netloc
+
+        name = urllib_parse.unquote(name)
+        assert name, (
+            'URL {self._url!r} produced no filename'.format(**locals()))
+        return name
+
+    @property
+    def file_path(self):
+        # type: () -> str
+        return url_to_path(self.url)
+
+    @property
+    def scheme(self):
+        # type: () -> str
+        return self._parsed_url.scheme
+
+    @property
+    def netloc(self):
+        # type: () -> str
+        """
+        This can contain auth information.
+        """
+        return self._parsed_url.netloc
+
+    @property
+    def path(self):
+        # type: () -> str
+        return urllib_parse.unquote(self._parsed_url.path)
+
+    def splitext(self):
+        # type: () -> Tuple[str, str]
+        return splitext(posixpath.basename(self.path.rstrip('/')))
+
+    @property
+    def ext(self):
+        # type: () -> str
+        return self.splitext()[1]
+
+    @property
+    def url_without_fragment(self):
+        # type: () -> str
+        scheme, netloc, path, query, fragment = self._parsed_url
+        return urllib_parse.urlunsplit((scheme, netloc, path, query, None))
+
+    _egg_fragment_re = re.compile(r'[#&]egg=([^&]*)')
+
+    @property
+    def egg_fragment(self):
+        # type: () -> Optional[str]
+        match = self._egg_fragment_re.search(self._url)
+        if not match:
+            return None
+        return match.group(1)
+
+    _subdirectory_fragment_re = re.compile(r'[#&]subdirectory=([^&]*)')
+
+    @property
+    def subdirectory_fragment(self):
+        # type: () -> Optional[str]
+        match = self._subdirectory_fragment_re.search(self._url)
+        if not match:
+            return None
+        return match.group(1)
+
+    _hash_re = re.compile(
+        r'(sha1|sha224|sha384|sha256|sha512|md5)=([a-f0-9]+)'
+    )
+
+    @property
+    def hash(self):
+        # type: () -> Optional[str]
+        match = self._hash_re.search(self._url)
+        if match:
+            return match.group(2)
+        return None
+
+    @property
+    def hash_name(self):
+        # type: () -> Optional[str]
+        match = self._hash_re.search(self._url)
+        if match:
+            return match.group(1)
+        return None
+
+    @property
+    def show_url(self):
+        # type: () -> str
+        return posixpath.basename(self._url.split('#', 1)[0].split('?', 1)[0])
+
+    @property
+    def is_file(self):
+        # type: () -> bool
+        return self.scheme == 'file'
+
+    def is_existing_dir(self):
+        # type: () -> bool
+        return self.is_file and os.path.isdir(self.file_path)
+
+    @property
+    def is_wheel(self):
+        # type: () -> bool
+        return self.ext == WHEEL_EXTENSION
+
+    @property
+    def is_vcs(self):
+        # type: () -> bool
+        from pip._internal.vcs import vcs
+
+        return self.scheme in vcs.all_schemes
+
+    @property
+    def is_yanked(self):
+        # type: () -> bool
+        return self.yanked_reason is not None
+
+    @property
+    def has_hash(self):
+        # type: () -> bool
+        return self.hash_name is not None
+
+    def is_hash_allowed(self, hashes):
+        # type: (Optional[Hashes]) -> bool
+        """
+        Return True if the link has a hash and it is allowed.
+        """
+        if hashes is None or not self.has_hash:
+            return False
+        # Assert non-None so mypy knows self.hash_name and self.hash are str.
+        assert self.hash_name is not None
+        assert self.hash is not None
+
+        return hashes.is_hash_allowed(self.hash_name, hex_digest=self.hash)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/models/scheme.py b/myenv/lib/python3.9/site-packages/pip/_internal/models/scheme.py
new file mode 100644
index 0000000..5040551
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/models/scheme.py
@@ -0,0 +1,31 @@
+"""
+For types associated with installation schemes.
+
+For a general overview of available schemes and their context, see
+https://docs.python.org/3/install/index.html#alternate-installation.
+"""
+
+
+SCHEME_KEYS = ['platlib', 'purelib', 'headers', 'scripts', 'data']
+
+
+class Scheme(object):
+    """A Scheme holds paths which are used as the base directories for
+    artifacts associated with a Python package.
+    """
+
+    __slots__ = SCHEME_KEYS
+
+    def __init__(
+        self,
+        platlib,  # type: str
+        purelib,  # type: str
+        headers,  # type: str
+        scripts,  # type: str
+        data,  # type: str
+    ):
+        self.platlib = platlib
+        self.purelib = purelib
+        self.headers = headers
+        self.scripts = scripts
+        self.data = data
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/models/search_scope.py b/myenv/lib/python3.9/site-packages/pip/_internal/models/search_scope.py
new file mode 100644
index 0000000..d732504
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/models/search_scope.py
@@ -0,0 +1,135 @@
+import itertools
+import logging
+import os
+import posixpath
+
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+
+from pip._internal.models.index import PyPI
+from pip._internal.utils.compat import has_tls
+from pip._internal.utils.misc import normalize_path, redact_auth_from_url
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List
+
+
+logger = logging.getLogger(__name__)
+
+
+class SearchScope(object):
+
+    """
+    Encapsulates the locations that pip is configured to search.
+    """
+
+    __slots__ = ["find_links", "index_urls"]
+
+    @classmethod
+    def create(
+        cls,
+        find_links,  # type: List[str]
+        index_urls,  # type: List[str]
+    ):
+        # type: (...) -> SearchScope
+        """
+        Create a SearchScope object after normalizing the `find_links`.
+        """
+        # Build find_links. If an argument starts with ~, it may be
+        # a local file relative to a home directory. So try normalizing
+        # it and if it exists, use the normalized version.
+        # This is deliberately conservative - it might be fine just to
+        # blindly normalize anything starting with a ~...
+        built_find_links = []  # type: List[str]
+        for link in find_links:
+            if link.startswith('~'):
+                new_link = normalize_path(link)
+                if os.path.exists(new_link):
+                    link = new_link
+            built_find_links.append(link)
+
+        # If we don't have TLS enabled, then WARN if anyplace we're looking
+        # relies on TLS.
+        if not has_tls():
+            for link in itertools.chain(index_urls, built_find_links):
+                parsed = urllib_parse.urlparse(link)
+                if parsed.scheme == 'https':
+                    logger.warning(
+                        'pip is configured with locations that require '
+                        'TLS/SSL, however the ssl module in Python is not '
+                        'available.'
+                    )
+                    break
+
+        return cls(
+            find_links=built_find_links,
+            index_urls=index_urls,
+        )
+
+    def __init__(
+        self,
+        find_links,  # type: List[str]
+        index_urls,  # type: List[str]
+    ):
+        # type: (...) -> None
+        self.find_links = find_links
+        self.index_urls = index_urls
+
+    def get_formatted_locations(self):
+        # type: () -> str
+        lines = []
+        redacted_index_urls = []
+        if self.index_urls and self.index_urls != [PyPI.simple_url]:
+            for url in self.index_urls:
+
+                redacted_index_url = redact_auth_from_url(url)
+
+                # Parse the URL
+                purl = urllib_parse.urlsplit(redacted_index_url)
+
+                # URL is generally invalid if scheme and netloc is missing
+                # there are issues with Python and URL parsing, so this test
+                # is a bit crude. See bpo-20271, bpo-23505. Python doesn't
+                # always parse invalid URLs correctly - it should raise
+                # exceptions for malformed URLs
+                if not purl.scheme and not purl.netloc:
+                    logger.warning(
+                        'The index url "%s" seems invalid, '
+                        'please provide a scheme.', redacted_index_url)
+
+                redacted_index_urls.append(redacted_index_url)
+
+            lines.append('Looking in indexes: {}'.format(
+                ', '.join(redacted_index_urls)))
+
+        if self.find_links:
+            lines.append(
+                'Looking in links: {}'.format(', '.join(
+                    redact_auth_from_url(url) for url in self.find_links))
+            )
+        return '\n'.join(lines)
+
+    def get_index_urls_locations(self, project_name):
+        # type: (str) -> List[str]
+        """Returns the locations found via self.index_urls
+
+        Checks the url_name on the main (first in the list) index and
+        use this url_name to produce all locations
+        """
+
+        def mkurl_pypi_url(url):
+            # type: (str) -> str
+            loc = posixpath.join(
+                url,
+                urllib_parse.quote(canonicalize_name(project_name)))
+            # For maximum compatibility with easy_install, ensure the path
+            # ends in a trailing slash.  Although this isn't in the spec
+            # (and PyPI can handle it without the slash) some other index
+            # implementations might break if they relied on easy_install's
+            # behavior.
+            if not loc.endswith('/'):
+                loc = loc + '/'
+            return loc
+
+        return [mkurl_pypi_url(url) for url in self.index_urls]
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/models/selection_prefs.py b/myenv/lib/python3.9/site-packages/pip/_internal/models/selection_prefs.py
new file mode 100644
index 0000000..5db3ca9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/models/selection_prefs.py
@@ -0,0 +1,49 @@
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional
+    from pip._internal.models.format_control import FormatControl
+
+
+class SelectionPreferences(object):
+    """
+    Encapsulates the candidate selection preferences for downloading
+    and installing files.
+    """
+
+    __slots__ = ['allow_yanked', 'allow_all_prereleases', 'format_control',
+                 'prefer_binary', 'ignore_requires_python']
+
+    # Don't include an allow_yanked default value to make sure each call
+    # site considers whether yanked releases are allowed. This also causes
+    # that decision to be made explicit in the calling code, which helps
+    # people when reading the code.
+    def __init__(
+        self,
+        allow_yanked,  # type: bool
+        allow_all_prereleases=False,  # type: bool
+        format_control=None,          # type: Optional[FormatControl]
+        prefer_binary=False,          # type: bool
+        ignore_requires_python=None,  # type: Optional[bool]
+    ):
+        # type: (...) -> None
+        """Create a SelectionPreferences object.
+
+        :param allow_yanked: Whether files marked as yanked (in the sense
+            of PEP 592) are permitted to be candidates for install.
+        :param format_control: A FormatControl object or None. Used to control
+            the selection of source packages / binary packages when consulting
+            the index and links.
+        :param prefer_binary: Whether to prefer an old, but valid, binary
+            dist over a new source dist.
+        :param ignore_requires_python: Whether to ignore incompatible
+            "Requires-Python" values in links. Defaults to False.
+        """
+        if ignore_requires_python is None:
+            ignore_requires_python = False
+
+        self.allow_yanked = allow_yanked
+        self.allow_all_prereleases = allow_all_prereleases
+        self.format_control = format_control
+        self.prefer_binary = prefer_binary
+        self.ignore_requires_python = ignore_requires_python
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/models/target_python.py b/myenv/lib/python3.9/site-packages/pip/_internal/models/target_python.py
new file mode 100644
index 0000000..6d1ca79
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/models/target_python.py
@@ -0,0 +1,120 @@
+import sys
+
+from pip._internal.utils.compatibility_tags import (
+    get_supported,
+    version_info_to_nodot,
+)
+from pip._internal.utils.misc import normalize_version_info
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Optional, Tuple
+
+    from pip._vendor.packaging.tags import Tag
+
+
+class TargetPython(object):
+
+    """
+    Encapsulates the properties of a Python interpreter one is targeting
+    for a package install, download, etc.
+    """
+
+    __slots__ = [
+        "_given_py_version_info",
+        "abi",
+        "implementation",
+        "platform",
+        "py_version",
+        "py_version_info",
+        "_valid_tags",
+    ]
+
+    def __init__(
+        self,
+        platform=None,  # type: Optional[str]
+        py_version_info=None,  # type: Optional[Tuple[int, ...]]
+        abi=None,  # type: Optional[str]
+        implementation=None,  # type: Optional[str]
+    ):
+        # type: (...) -> None
+        """
+        :param platform: A string or None. If None, searches for packages
+            that are supported by the current system. Otherwise, will find
+            packages that can be built on the platform passed in. These
+            packages will only be downloaded for distribution: they will
+            not be built locally.
+        :param py_version_info: An optional tuple of ints representing the
+            Python version information to use (e.g. `sys.version_info[:3]`).
+            This can have length 1, 2, or 3 when provided.
+        :param abi: A string or None. This is passed to compatibility_tags.py's
+            get_supported() function as is.
+        :param implementation: A string or None. This is passed to
+            compatibility_tags.py's get_supported() function as is.
+        """
+        # Store the given py_version_info for when we call get_supported().
+        self._given_py_version_info = py_version_info
+
+        if py_version_info is None:
+            py_version_info = sys.version_info[:3]
+        else:
+            py_version_info = normalize_version_info(py_version_info)
+
+        py_version = '.'.join(map(str, py_version_info[:2]))
+
+        self.abi = abi
+        self.implementation = implementation
+        self.platform = platform
+        self.py_version = py_version
+        self.py_version_info = py_version_info
+
+        # This is used to cache the return value of get_tags().
+        self._valid_tags = None  # type: Optional[List[Tag]]
+
+    def format_given(self):
+        # type: () -> str
+        """
+        Format the given, non-None attributes for display.
+        """
+        display_version = None
+        if self._given_py_version_info is not None:
+            display_version = '.'.join(
+                str(part) for part in self._given_py_version_info
+            )
+
+        key_values = [
+            ('platform', self.platform),
+            ('version_info', display_version),
+            ('abi', self.abi),
+            ('implementation', self.implementation),
+        ]
+        return ' '.join(
+            '{}={!r}'.format(key, value) for key, value in key_values
+            if value is not None
+        )
+
+    def get_tags(self):
+        # type: () -> List[Tag]
+        """
+        Return the supported PEP 425 tags to check wheel candidates against.
+
+        The tags are returned in order of preference (most preferred first).
+        """
+        if self._valid_tags is None:
+            # Pass versions=None if no py_version_info was given since
+            # versions=None uses special default logic.
+            py_version_info = self._given_py_version_info
+            if py_version_info is None:
+                version = None
+            else:
+                version = version_info_to_nodot(py_version_info)
+
+            tags = get_supported(
+                version=version,
+                platform=self.platform,
+                abi=self.abi,
+                impl=self.implementation,
+            )
+            self._valid_tags = tags
+
+        return self._valid_tags
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/models/wheel.py b/myenv/lib/python3.9/site-packages/pip/_internal/models/wheel.py
new file mode 100644
index 0000000..4d4068f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/models/wheel.py
@@ -0,0 +1,78 @@
+"""Represents a wheel file and provides access to the various parts of the
+name that have meaning.
+"""
+import re
+
+from pip._vendor.packaging.tags import Tag
+
+from pip._internal.exceptions import InvalidWheelFilename
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List
+
+
+class Wheel(object):
+    """A wheel file"""
+
+    wheel_file_re = re.compile(
+        r"""^(?P<namever>(?P<name>.+?)-(?P<ver>.*?))
+        ((-(?P<build>\d[^-]*?))?-(?P<pyver>.+?)-(?P<abi>.+?)-(?P<plat>.+?)
+        \.whl|\.dist-info)$""",
+        re.VERBOSE
+    )
+
+    def __init__(self, filename):
+        # type: (str) -> None
+        """
+        :raises InvalidWheelFilename: when the filename is invalid for a wheel
+        """
+        wheel_info = self.wheel_file_re.match(filename)
+        if not wheel_info:
+            raise InvalidWheelFilename(
+                "{} is not a valid wheel filename.".format(filename)
+            )
+        self.filename = filename
+        self.name = wheel_info.group('name').replace('_', '-')
+        # we'll assume "_" means "-" due to wheel naming scheme
+        # (https://github.com/pypa/pip/issues/1150)
+        self.version = wheel_info.group('ver').replace('_', '-')
+        self.build_tag = wheel_info.group('build')
+        self.pyversions = wheel_info.group('pyver').split('.')
+        self.abis = wheel_info.group('abi').split('.')
+        self.plats = wheel_info.group('plat').split('.')
+
+        # All the tag combinations from this file
+        self.file_tags = {
+            Tag(x, y, z) for x in self.pyversions
+            for y in self.abis for z in self.plats
+        }
+
+    def get_formatted_file_tags(self):
+        # type: () -> List[str]
+        """Return the wheel's tags as a sorted list of strings."""
+        return sorted(str(tag) for tag in self.file_tags)
+
+    def support_index_min(self, tags):
+        # type: (List[Tag]) -> int
+        """Return the lowest index that one of the wheel's file_tag combinations
+        achieves in the given list of supported tags.
+
+        For example, if there are 8 supported tags and one of the file tags
+        is first in the list, then return 0.
+
+        :param tags: the PEP 425 tags to check the wheel against, in order
+            with most preferred first.
+
+        :raises ValueError: If none of the wheel's file tags match one of
+            the supported tags.
+        """
+        return min(tags.index(tag) for tag in self.file_tags if tag in tags)
+
+    def supported(self, tags):
+        # type: (List[Tag]) -> bool
+        """Return whether the wheel is compatible with one of the given tags.
+
+        :param tags: the PEP 425 tags to check the wheel against.
+        """
+        return not self.file_tags.isdisjoint(tags)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/network/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/network/__init__.py
new file mode 100644
index 0000000..b51bde9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/network/__init__.py
@@ -0,0 +1,2 @@
+"""Contains purely network-related utilities.
+"""
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/network/auth.py b/myenv/lib/python3.9/site-packages/pip/_internal/network/auth.py
new file mode 100644
index 0000000..c49deaa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/network/auth.py
@@ -0,0 +1,310 @@
+"""Network Authentication Helpers
+
+Contains interface (MultiDomainBasicAuth) and associated glue code for
+providing credentials in the context of network requests.
+"""
+
+import logging
+
+from pip._vendor.requests.auth import AuthBase, HTTPBasicAuth
+from pip._vendor.requests.utils import get_netrc_auth
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+
+from pip._internal.utils.misc import (
+    ask,
+    ask_input,
+    ask_password,
+    remove_auth_from_url,
+    split_auth_netloc_from_url,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Dict, Optional, Tuple, List, Any
+
+    from pip._internal.vcs.versioncontrol import AuthInfo
+
+    from pip._vendor.requests.models import Response, Request
+
+    Credentials = Tuple[str, str, str]
+
+logger = logging.getLogger(__name__)
+
+try:
+    import keyring  # noqa
+except ImportError:
+    keyring = None
+except Exception as exc:
+    logger.warning(
+        "Keyring is skipped due to an exception: %s", str(exc),
+    )
+    keyring = None
+
+
+def get_keyring_auth(url, username):
+    # type: (str, str) -> Optional[AuthInfo]
+    """Return the tuple auth for a given url from keyring."""
+    global keyring
+    if not url or not keyring:
+        return None
+
+    try:
+        try:
+            get_credential = keyring.get_credential
+        except AttributeError:
+            pass
+        else:
+            logger.debug("Getting credentials from keyring for %s", url)
+            cred = get_credential(url, username)
+            if cred is not None:
+                return cred.username, cred.password
+            return None
+
+        if username:
+            logger.debug("Getting password from keyring for %s", url)
+            password = keyring.get_password(url, username)
+            if password:
+                return username, password
+
+    except Exception as exc:
+        logger.warning(
+            "Keyring is skipped due to an exception: %s", str(exc),
+        )
+        keyring = None
+    return None
+
+
+class MultiDomainBasicAuth(AuthBase):
+
+    def __init__(self, prompting=True, index_urls=None):
+        # type: (bool, Optional[List[str]]) -> None
+        self.prompting = prompting
+        self.index_urls = index_urls
+        self.passwords = {}  # type: Dict[str, AuthInfo]
+        # When the user is prompted to enter credentials and keyring is
+        # available, we will offer to save them. If the user accepts,
+        # this value is set to the credentials they entered. After the
+        # request authenticates, the caller should call
+        # ``save_credentials`` to save these.
+        self._credentials_to_save = None  # type: Optional[Credentials]
+
+    def _get_index_url(self, url):
+        # type: (str) -> Optional[str]
+        """Return the original index URL matching the requested URL.
+
+        Cached or dynamically generated credentials may work against
+        the original index URL rather than just the netloc.
+
+        The provided url should have had its username and password
+        removed already. If the original index url had credentials then
+        they will be included in the return value.
+
+        Returns None if no matching index was found, or if --no-index
+        was specified by the user.
+        """
+        if not url or not self.index_urls:
+            return None
+
+        for u in self.index_urls:
+            prefix = remove_auth_from_url(u).rstrip("/") + "/"
+            if url.startswith(prefix):
+                return u
+        return None
+
+    def _get_new_credentials(self, original_url, allow_netrc=True,
+                             allow_keyring=True):
+        # type: (str, bool, bool) -> AuthInfo
+        """Find and return credentials for the specified URL."""
+        # Split the credentials and netloc from the url.
+        url, netloc, url_user_password = split_auth_netloc_from_url(
+            original_url,
+        )
+
+        # Start with the credentials embedded in the url
+        username, password = url_user_password
+        if username is not None and password is not None:
+            logger.debug("Found credentials in url for %s", netloc)
+            return url_user_password
+
+        # Find a matching index url for this request
+        index_url = self._get_index_url(url)
+        if index_url:
+            # Split the credentials from the url.
+            index_info = split_auth_netloc_from_url(index_url)
+            if index_info:
+                index_url, _, index_url_user_password = index_info
+                logger.debug("Found index url %s", index_url)
+
+        # If an index URL was found, try its embedded credentials
+        if index_url and index_url_user_password[0] is not None:
+            username, password = index_url_user_password
+            if username is not None and password is not None:
+                logger.debug("Found credentials in index url for %s", netloc)
+                return index_url_user_password
+
+        # Get creds from netrc if we still don't have them
+        if allow_netrc:
+            netrc_auth = get_netrc_auth(original_url)
+            if netrc_auth:
+                logger.debug("Found credentials in netrc for %s", netloc)
+                return netrc_auth
+
+        # If we don't have a password and keyring is available, use it.
+        if allow_keyring:
+            # The index url is more specific than the netloc, so try it first
+            kr_auth = (
+                get_keyring_auth(index_url, username) or
+                get_keyring_auth(netloc, username)
+            )
+            if kr_auth:
+                logger.debug("Found credentials in keyring for %s", netloc)
+                return kr_auth
+
+        return username, password
+
+    def _get_url_and_credentials(self, original_url):
+        # type: (str) -> Tuple[str, Optional[str], Optional[str]]
+        """Return the credentials to use for the provided URL.
+
+        If allowed, netrc and keyring may be used to obtain the
+        correct credentials.
+
+        Returns (url_without_credentials, username, password). Note
+        that even if the original URL contains credentials, this
+        function may return a different username and password.
+        """
+        url, netloc, _ = split_auth_netloc_from_url(original_url)
+
+        # Use any stored credentials that we have for this netloc
+        username, password = self.passwords.get(netloc, (None, None))
+
+        if username is None and password is None:
+            # No stored credentials. Acquire new credentials without prompting
+            # the user. (e.g. from netrc, keyring, or the URL itself)
+            username, password = self._get_new_credentials(original_url)
+
+        if username is not None or password is not None:
+            # Convert the username and password if they're None, so that
+            # this netloc will show up as "cached" in the conditional above.
+            # Further, HTTPBasicAuth doesn't accept None, so it makes sense to
+            # cache the value that is going to be used.
+            username = username or ""
+            password = password or ""
+
+            # Store any acquired credentials.
+            self.passwords[netloc] = (username, password)
+
+        assert (
+            # Credentials were found
+            (username is not None and password is not None) or
+            # Credentials were not found
+            (username is None and password is None)
+        ), "Could not load credentials from url: {}".format(original_url)
+
+        return url, username, password
+
+    def __call__(self, req):
+        # type: (Request) -> Request
+        # Get credentials for this request
+        url, username, password = self._get_url_and_credentials(req.url)
+
+        # Set the url of the request to the url without any credentials
+        req.url = url
+
+        if username is not None and password is not None:
+            # Send the basic auth with this request
+            req = HTTPBasicAuth(username, password)(req)
+
+        # Attach a hook to handle 401 responses
+        req.register_hook("response", self.handle_401)
+
+        return req
+
+    # Factored out to allow for easy patching in tests
+    def _prompt_for_password(self, netloc):
+        # type: (str) -> Tuple[Optional[str], Optional[str], bool]
+        username = ask_input("User for {}: ".format(netloc))
+        if not username:
+            return None, None, False
+        auth = get_keyring_auth(netloc, username)
+        if auth and auth[0] is not None and auth[1] is not None:
+            return auth[0], auth[1], False
+        password = ask_password("Password: ")
+        return username, password, True
+
+    # Factored out to allow for easy patching in tests
+    def _should_save_password_to_keyring(self):
+        # type: () -> bool
+        if not keyring:
+            return False
+        return ask("Save credentials to keyring [y/N]: ", ["y", "n"]) == "y"
+
+    def handle_401(self, resp, **kwargs):
+        # type: (Response, **Any) -> Response
+        # We only care about 401 responses, anything else we want to just
+        #   pass through the actual response
+        if resp.status_code != 401:
+            return resp
+
+        # We are not able to prompt the user so simply return the response
+        if not self.prompting:
+            return resp
+
+        parsed = urllib_parse.urlparse(resp.url)
+
+        # Prompt the user for a new username and password
+        username, password, save = self._prompt_for_password(parsed.netloc)
+
+        # Store the new username and password to use for future requests
+        self._credentials_to_save = None
+        if username is not None and password is not None:
+            self.passwords[parsed.netloc] = (username, password)
+
+            # Prompt to save the password to keyring
+            if save and self._should_save_password_to_keyring():
+                self._credentials_to_save = (parsed.netloc, username, password)
+
+        # Consume content and release the original connection to allow our new
+        #   request to reuse the same one.
+        resp.content
+        resp.raw.release_conn()
+
+        # Add our new username and password to the request
+        req = HTTPBasicAuth(username or "", password or "")(resp.request)
+        req.register_hook("response", self.warn_on_401)
+
+        # On successful request, save the credentials that were used to
+        # keyring. (Note that if the user responded "no" above, this member
+        # is not set and nothing will be saved.)
+        if self._credentials_to_save:
+            req.register_hook("response", self.save_credentials)
+
+        # Send our new request
+        new_resp = resp.connection.send(req, **kwargs)
+        new_resp.history.append(resp)
+
+        return new_resp
+
+    def warn_on_401(self, resp, **kwargs):
+        # type: (Response, **Any) -> None
+        """Response callback to warn about incorrect credentials."""
+        if resp.status_code == 401:
+            logger.warning(
+                '401 Error, Credentials not correct for %s', resp.request.url,
+            )
+
+    def save_credentials(self, resp, **kwargs):
+        # type: (Response, **Any) -> None
+        """Response callback to save credentials on success."""
+        assert keyring is not None, "should never reach here without keyring"
+        if not keyring:
+            return
+
+        creds = self._credentials_to_save
+        self._credentials_to_save = None
+        if creds and resp.status_code < 400:
+            try:
+                logger.info('Saving credentials to keyring')
+                keyring.set_password(*creds)
+            except Exception:
+                logger.exception('Failed to save credentials')
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/network/cache.py b/myenv/lib/python3.9/site-packages/pip/_internal/network/cache.py
new file mode 100644
index 0000000..a0d55b5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/network/cache.py
@@ -0,0 +1,79 @@
+"""HTTP cache implementation.
+"""
+
+import os
+from contextlib import contextmanager
+
+from pip._vendor.cachecontrol.cache import BaseCache
+from pip._vendor.cachecontrol.caches import FileCache
+from pip._vendor.requests.models import Response
+
+from pip._internal.utils.filesystem import adjacent_tmp_file, replace
+from pip._internal.utils.misc import ensure_dir
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, Iterator
+
+
+def is_from_cache(response):
+    # type: (Response) -> bool
+    return getattr(response, "from_cache", False)
+
+
+@contextmanager
+def suppressed_cache_errors():
+    # type: () -> Iterator[None]
+    """If we can't access the cache then we can just skip caching and process
+    requests as if caching wasn't enabled.
+    """
+    try:
+        yield
+    except (OSError, IOError):
+        pass
+
+
+class SafeFileCache(BaseCache):
+    """
+    A file based cache which is safe to use even when the target directory may
+    not be accessible or writable.
+    """
+
+    def __init__(self, directory):
+        # type: (str) -> None
+        assert directory is not None, "Cache directory must not be None."
+        super(SafeFileCache, self).__init__()
+        self.directory = directory
+
+    def _get_cache_path(self, name):
+        # type: (str) -> str
+        # From cachecontrol.caches.file_cache.FileCache._fn, brought into our
+        # class for backwards-compatibility and to avoid using a non-public
+        # method.
+        hashed = FileCache.encode(name)
+        parts = list(hashed[:5]) + [hashed]
+        return os.path.join(self.directory, *parts)
+
+    def get(self, key):
+        # type: (str) -> Optional[bytes]
+        path = self._get_cache_path(key)
+        with suppressed_cache_errors():
+            with open(path, 'rb') as f:
+                return f.read()
+
+    def set(self, key, value):
+        # type: (str, bytes) -> None
+        path = self._get_cache_path(key)
+        with suppressed_cache_errors():
+            ensure_dir(os.path.dirname(path))
+
+            with adjacent_tmp_file(path) as f:
+                f.write(value)
+
+            replace(f.name, path)
+
+    def delete(self, key):
+        # type: (str) -> None
+        path = self._get_cache_path(key)
+        with suppressed_cache_errors():
+            os.remove(path)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/network/download.py b/myenv/lib/python3.9/site-packages/pip/_internal/network/download.py
new file mode 100644
index 0000000..44f9985
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/network/download.py
@@ -0,0 +1,182 @@
+"""Download files with progress indicators.
+"""
+import cgi
+import logging
+import mimetypes
+import os
+
+from pip._vendor.requests.models import CONTENT_CHUNK_SIZE
+
+from pip._internal.cli.progress_bars import DownloadProgressProvider
+from pip._internal.exceptions import NetworkConnectionError
+from pip._internal.models.index import PyPI
+from pip._internal.network.cache import is_from_cache
+from pip._internal.network.utils import (
+    HEADERS,
+    raise_for_status,
+    response_chunks,
+)
+from pip._internal.utils.misc import (
+    format_size,
+    redact_auth_from_url,
+    splitext,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Iterable, Optional
+
+    from pip._vendor.requests.models import Response
+
+    from pip._internal.models.link import Link
+    from pip._internal.network.session import PipSession
+
+logger = logging.getLogger(__name__)
+
+
+def _get_http_response_size(resp):
+    # type: (Response) -> Optional[int]
+    try:
+        return int(resp.headers['content-length'])
+    except (ValueError, KeyError, TypeError):
+        return None
+
+
+def _prepare_download(
+    resp,  # type: Response
+    link,  # type: Link
+    progress_bar  # type: str
+):
+    # type: (...) -> Iterable[bytes]
+    total_length = _get_http_response_size(resp)
+
+    if link.netloc == PyPI.file_storage_domain:
+        url = link.show_url
+    else:
+        url = link.url_without_fragment
+
+    logged_url = redact_auth_from_url(url)
+
+    if total_length:
+        logged_url = '{} ({})'.format(logged_url, format_size(total_length))
+
+    if is_from_cache(resp):
+        logger.info("Using cached %s", logged_url)
+    else:
+        logger.info("Downloading %s", logged_url)
+
+    if logger.getEffectiveLevel() > logging.INFO:
+        show_progress = False
+    elif is_from_cache(resp):
+        show_progress = False
+    elif not total_length:
+        show_progress = True
+    elif total_length > (40 * 1000):
+        show_progress = True
+    else:
+        show_progress = False
+
+    chunks = response_chunks(resp, CONTENT_CHUNK_SIZE)
+
+    if not show_progress:
+        return chunks
+
+    return DownloadProgressProvider(
+        progress_bar, max=total_length
+    )(chunks)
+
+
+def sanitize_content_filename(filename):
+    # type: (str) -> str
+    """
+    Sanitize the "filename" value from a Content-Disposition header.
+    """
+    return os.path.basename(filename)
+
+
+def parse_content_disposition(content_disposition, default_filename):
+    # type: (str, str) -> str
+    """
+    Parse the "filename" value from a Content-Disposition header, and
+    return the default filename if the result is empty.
+    """
+    _type, params = cgi.parse_header(content_disposition)
+    filename = params.get('filename')
+    if filename:
+        # We need to sanitize the filename to prevent directory traversal
+        # in case the filename contains ".." path parts.
+        filename = sanitize_content_filename(filename)
+    return filename or default_filename
+
+
+def _get_http_response_filename(resp, link):
+    # type: (Response, Link) -> str
+    """Get an ideal filename from the given HTTP response, falling back to
+    the link filename if not provided.
+    """
+    filename = link.filename  # fallback
+    # Have a look at the Content-Disposition header for a better guess
+    content_disposition = resp.headers.get('content-disposition')
+    if content_disposition:
+        filename = parse_content_disposition(content_disposition, filename)
+    ext = splitext(filename)[1]  # type: Optional[str]
+    if not ext:
+        ext = mimetypes.guess_extension(
+            resp.headers.get('content-type', '')
+        )
+        if ext:
+            filename += ext
+    if not ext and link.url != resp.url:
+        ext = os.path.splitext(resp.url)[1]
+        if ext:
+            filename += ext
+    return filename
+
+
+def _http_get_download(session, link):
+    # type: (PipSession, Link) -> Response
+    target_url = link.url.split('#', 1)[0]
+    resp = session.get(target_url, headers=HEADERS, stream=True)
+    raise_for_status(resp)
+    return resp
+
+
+class Download(object):
+    def __init__(
+        self,
+        response,  # type: Response
+        filename,  # type: str
+        chunks,  # type: Iterable[bytes]
+    ):
+        # type: (...) -> None
+        self.response = response
+        self.filename = filename
+        self.chunks = chunks
+
+
+class Downloader(object):
+    def __init__(
+        self,
+        session,  # type: PipSession
+        progress_bar,  # type: str
+    ):
+        # type: (...) -> None
+        self._session = session
+        self._progress_bar = progress_bar
+
+    def __call__(self, link):
+        # type: (Link) -> Download
+        try:
+            resp = _http_get_download(self._session, link)
+        except NetworkConnectionError as e:
+            assert e.response is not None
+            logger.critical(
+                "HTTP error %s while getting %s", e.response.status_code, link
+            )
+            raise
+
+        return Download(
+            resp,
+            _get_http_response_filename(resp, link),
+            _prepare_download(resp, link, self._progress_bar),
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/network/lazy_wheel.py b/myenv/lib/python3.9/site-packages/pip/_internal/network/lazy_wheel.py
new file mode 100644
index 0000000..a0f9e15
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/network/lazy_wheel.py
@@ -0,0 +1,235 @@
+"""Lazy ZIP over HTTP"""
+
+__all__ = ['HTTPRangeRequestUnsupported', 'dist_from_wheel_url']
+
+from bisect import bisect_left, bisect_right
+from contextlib import contextmanager
+from tempfile import NamedTemporaryFile
+from zipfile import BadZipfile, ZipFile
+
+from pip._vendor.requests.models import CONTENT_CHUNK_SIZE
+from pip._vendor.six.moves import range
+
+from pip._internal.network.utils import (
+    HEADERS,
+    raise_for_status,
+    response_chunks,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.wheel import pkg_resources_distribution_for_wheel
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any, Dict, Iterator, List, Optional, Tuple
+
+    from pip._vendor.pkg_resources import Distribution
+    from pip._vendor.requests.models import Response
+
+    from pip._internal.network.session import PipSession
+
+
+class HTTPRangeRequestUnsupported(Exception):
+    pass
+
+
+def dist_from_wheel_url(name, url, session):
+    # type: (str, str, PipSession) -> Distribution
+    """Return a pkg_resources.Distribution from the given wheel URL.
+
+    This uses HTTP range requests to only fetch the potion of the wheel
+    containing metadata, just enough for the object to be constructed.
+    If such requests are not supported, HTTPRangeRequestUnsupported
+    is raised.
+    """
+    with LazyZipOverHTTP(url, session) as wheel:
+        # For read-only ZIP files, ZipFile only needs methods read,
+        # seek, seekable and tell, not the whole IO protocol.
+        zip_file = ZipFile(wheel)  # type: ignore
+        # After context manager exit, wheel.name
+        # is an invalid file by intention.
+        return pkg_resources_distribution_for_wheel(zip_file, name, wheel.name)
+
+
+class LazyZipOverHTTP(object):
+    """File-like object mapped to a ZIP file over HTTP.
+
+    This uses HTTP range requests to lazily fetch the file's content,
+    which is supposed to be fed to ZipFile.  If such requests are not
+    supported by the server, raise HTTPRangeRequestUnsupported
+    during initialization.
+    """
+
+    def __init__(self, url, session, chunk_size=CONTENT_CHUNK_SIZE):
+        # type: (str, PipSession, int) -> None
+        head = session.head(url, headers=HEADERS)
+        raise_for_status(head)
+        assert head.status_code == 200
+        self._session, self._url, self._chunk_size = session, url, chunk_size
+        self._length = int(head.headers['Content-Length'])
+        self._file = NamedTemporaryFile()
+        self.truncate(self._length)
+        self._left = []  # type: List[int]
+        self._right = []  # type: List[int]
+        if 'bytes' not in head.headers.get('Accept-Ranges', 'none'):
+            raise HTTPRangeRequestUnsupported('range request is not supported')
+        self._check_zip()
+
+    @property
+    def mode(self):
+        # type: () -> str
+        """Opening mode, which is always rb."""
+        return 'rb'
+
+    @property
+    def name(self):
+        # type: () -> str
+        """Path to the underlying file."""
+        return self._file.name
+
+    def seekable(self):
+        # type: () -> bool
+        """Return whether random access is supported, which is True."""
+        return True
+
+    def close(self):
+        # type: () -> None
+        """Close the file."""
+        self._file.close()
+
+    @property
+    def closed(self):
+        # type: () -> bool
+        """Whether the file is closed."""
+        return self._file.closed
+
+    def read(self, size=-1):
+        # type: (int) -> bytes
+        """Read up to size bytes from the object and return them.
+
+        As a convenience, if size is unspecified or -1,
+        all bytes until EOF are returned.  Fewer than
+        size bytes may be returned if EOF is reached.
+        """
+        download_size = max(size, self._chunk_size)
+        start, length = self.tell(), self._length
+        stop = length if size < 0 else min(start+download_size, length)
+        start = max(0, stop-download_size)
+        self._download(start, stop-1)
+        return self._file.read(size)
+
+    def readable(self):
+        # type: () -> bool
+        """Return whether the file is readable, which is True."""
+        return True
+
+    def seek(self, offset, whence=0):
+        # type: (int, int) -> int
+        """Change stream position and return the new absolute position.
+
+        Seek to offset relative position indicated by whence:
+        * 0: Start of stream (the default).  pos should be >= 0;
+        * 1: Current position - pos may be negative;
+        * 2: End of stream - pos usually negative.
+        """
+        return self._file.seek(offset, whence)
+
+    def tell(self):
+        # type: () -> int
+        """Return the current possition."""
+        return self._file.tell()
+
+    def truncate(self, size=None):
+        # type: (Optional[int]) -> int
+        """Resize the stream to the given size in bytes.
+
+        If size is unspecified resize to the current position.
+        The current stream position isn't changed.
+
+        Return the new file size.
+        """
+        return self._file.truncate(size)
+
+    def writable(self):
+        # type: () -> bool
+        """Return False."""
+        return False
+
+    def __enter__(self):
+        # type: () -> LazyZipOverHTTP
+        self._file.__enter__()
+        return self
+
+    def __exit__(self, *exc):
+        # type: (*Any) -> Optional[bool]
+        return self._file.__exit__(*exc)
+
+    @contextmanager
+    def _stay(self):
+        # type: ()-> Iterator[None]
+        """Return a context manager keeping the position.
+
+        At the end of the block, seek back to original position.
+        """
+        pos = self.tell()
+        try:
+            yield
+        finally:
+            self.seek(pos)
+
+    def _check_zip(self):
+        # type: () -> None
+        """Check and download until the file is a valid ZIP."""
+        end = self._length - 1
+        for start in reversed(range(0, end, self._chunk_size)):
+            self._download(start, end)
+            with self._stay():
+                try:
+                    # For read-only ZIP files, ZipFile only needs
+                    # methods read, seek, seekable and tell.
+                    ZipFile(self)  # type: ignore
+                except BadZipfile:
+                    pass
+                else:
+                    break
+
+    def _stream_response(self, start, end, base_headers=HEADERS):
+        # type: (int, int, Dict[str, str]) -> Response
+        """Return HTTP response to a range request from start to end."""
+        headers = base_headers.copy()
+        headers['Range'] = 'bytes={}-{}'.format(start, end)
+        # TODO: Get range requests to be correctly cached
+        headers['Cache-Control'] = 'no-cache'
+        return self._session.get(self._url, headers=headers, stream=True)
+
+    def _merge(self, start, end, left, right):
+        # type: (int, int, int, int) -> Iterator[Tuple[int, int]]
+        """Return an iterator of intervals to be fetched.
+
+        Args:
+            start (int): Start of needed interval
+            end (int): End of needed interval
+            left (int): Index of first overlapping downloaded data
+            right (int): Index after last overlapping downloaded data
+        """
+        lslice, rslice = self._left[left:right], self._right[left:right]
+        i = start = min([start]+lslice[:1])
+        end = max([end]+rslice[-1:])
+        for j, k in zip(lslice, rslice):
+            if j > i:
+                yield i, j-1
+            i = k + 1
+        if i <= end:
+            yield i, end
+        self._left[left:right], self._right[left:right] = [start], [end]
+
+    def _download(self, start, end):
+        # type: (int, int) -> None
+        """Download bytes from start to end inclusively."""
+        with self._stay():
+            left = bisect_left(self._right, start)
+            right = bisect_right(self._left, end)
+            for start, end in self._merge(start, end, left, right):
+                response = self._stream_response(start, end)
+                response.raise_for_status()
+                self.seek(start)
+                for chunk in response_chunks(response, self._chunk_size):
+                    self._file.write(chunk)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/network/session.py b/myenv/lib/python3.9/site-packages/pip/_internal/network/session.py
new file mode 100644
index 0000000..39a4a54
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/network/session.py
@@ -0,0 +1,421 @@
+"""PipSession and supporting code, containing all pip-specific
+network request configuration and behavior.
+"""
+
+# The following comment should be removed at some point in the future.
+# mypy: disallow-untyped-defs=False
+
+import email.utils
+import json
+import logging
+import mimetypes
+import os
+import platform
+import sys
+import warnings
+
+from pip._vendor import requests, six, urllib3
+from pip._vendor.cachecontrol import CacheControlAdapter
+from pip._vendor.requests.adapters import BaseAdapter, HTTPAdapter
+from pip._vendor.requests.models import Response
+from pip._vendor.requests.structures import CaseInsensitiveDict
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+from pip._vendor.urllib3.exceptions import InsecureRequestWarning
+
+from pip import __version__
+from pip._internal.network.auth import MultiDomainBasicAuth
+from pip._internal.network.cache import SafeFileCache
+# Import ssl from compat so the initial import occurs in only one place.
+from pip._internal.utils.compat import has_tls, ipaddress
+from pip._internal.utils.glibc import libc_ver
+from pip._internal.utils.misc import (
+    build_url_from_netloc,
+    get_installed_version,
+    parse_netloc,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.urls import url_to_path
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Iterator, List, Optional, Tuple, Union,
+    )
+
+    from pip._internal.models.link import Link
+
+    SecureOrigin = Tuple[str, str, Optional[Union[int, str]]]
+
+
+logger = logging.getLogger(__name__)
+
+
+# Ignore warning raised when using --trusted-host.
+warnings.filterwarnings("ignore", category=InsecureRequestWarning)
+
+
+SECURE_ORIGINS = [
+    # protocol, hostname, port
+    # Taken from Chrome's list of secure origins (See: http://bit.ly/1qrySKC)
+    ("https", "*", "*"),
+    ("*", "localhost", "*"),
+    ("*", "127.0.0.0/8", "*"),
+    ("*", "::1/128", "*"),
+    ("file", "*", None),
+    # ssh is always secure.
+    ("ssh", "*", "*"),
+]  # type: List[SecureOrigin]
+
+
+# These are environment variables present when running under various
+# CI systems.  For each variable, some CI systems that use the variable
+# are indicated.  The collection was chosen so that for each of a number
+# of popular systems, at least one of the environment variables is used.
+# This list is used to provide some indication of and lower bound for
+# CI traffic to PyPI.  Thus, it is okay if the list is not comprehensive.
+# For more background, see: https://github.com/pypa/pip/issues/5499
+CI_ENVIRONMENT_VARIABLES = (
+    # Azure Pipelines
+    'BUILD_BUILDID',
+    # Jenkins
+    'BUILD_ID',
+    # AppVeyor, CircleCI, Codeship, Gitlab CI, Shippable, Travis CI
+    'CI',
+    # Explicit environment variable.
+    'PIP_IS_CI',
+)
+
+
+def looks_like_ci():
+    # type: () -> bool
+    """
+    Return whether it looks like pip is running under CI.
+    """
+    # We don't use the method of checking for a tty (e.g. using isatty())
+    # because some CI systems mimic a tty (e.g. Travis CI).  Thus that
+    # method doesn't provide definitive information in either direction.
+    return any(name in os.environ for name in CI_ENVIRONMENT_VARIABLES)
+
+
+def user_agent():
+    """
+    Return a string representing the user agent.
+    """
+    data = {
+        "installer": {"name": "pip", "version": __version__},
+        "python": platform.python_version(),
+        "implementation": {
+            "name": platform.python_implementation(),
+        },
+    }
+
+    if data["implementation"]["name"] == 'CPython':
+        data["implementation"]["version"] = platform.python_version()
+    elif data["implementation"]["name"] == 'PyPy':
+        if sys.pypy_version_info.releaselevel == 'final':
+            pypy_version_info = sys.pypy_version_info[:3]
+        else:
+            pypy_version_info = sys.pypy_version_info
+        data["implementation"]["version"] = ".".join(
+            [str(x) for x in pypy_version_info]
+        )
+    elif data["implementation"]["name"] == 'Jython':
+        # Complete Guess
+        data["implementation"]["version"] = platform.python_version()
+    elif data["implementation"]["name"] == 'IronPython':
+        # Complete Guess
+        data["implementation"]["version"] = platform.python_version()
+
+    if sys.platform.startswith("linux"):
+        from pip._vendor import distro
+        distro_infos = dict(filter(
+            lambda x: x[1],
+            zip(["name", "version", "id"], distro.linux_distribution()),
+        ))
+        libc = dict(filter(
+            lambda x: x[1],
+            zip(["lib", "version"], libc_ver()),
+        ))
+        if libc:
+            distro_infos["libc"] = libc
+        if distro_infos:
+            data["distro"] = distro_infos
+
+    if sys.platform.startswith("darwin") and platform.mac_ver()[0]:
+        data["distro"] = {"name": "macOS", "version": platform.mac_ver()[0]}
+
+    if platform.system():
+        data.setdefault("system", {})["name"] = platform.system()
+
+    if platform.release():
+        data.setdefault("system", {})["release"] = platform.release()
+
+    if platform.machine():
+        data["cpu"] = platform.machine()
+
+    if has_tls():
+        import _ssl as ssl
+        data["openssl_version"] = ssl.OPENSSL_VERSION
+
+    setuptools_version = get_installed_version("setuptools")
+    if setuptools_version is not None:
+        data["setuptools_version"] = setuptools_version
+
+    # Use None rather than False so as not to give the impression that
+    # pip knows it is not being run under CI.  Rather, it is a null or
+    # inconclusive result.  Also, we include some value rather than no
+    # value to make it easier to know that the check has been run.
+    data["ci"] = True if looks_like_ci() else None
+
+    user_data = os.environ.get("PIP_USER_AGENT_USER_DATA")
+    if user_data is not None:
+        data["user_data"] = user_data
+
+    return "{data[installer][name]}/{data[installer][version]} {json}".format(
+        data=data,
+        json=json.dumps(data, separators=(",", ":"), sort_keys=True),
+    )
+
+
+class LocalFSAdapter(BaseAdapter):
+
+    def send(self, request, stream=None, timeout=None, verify=None, cert=None,
+             proxies=None):
+        pathname = url_to_path(request.url)
+
+        resp = Response()
+        resp.status_code = 200
+        resp.url = request.url
+
+        try:
+            stats = os.stat(pathname)
+        except OSError as exc:
+            resp.status_code = 404
+            resp.raw = exc
+        else:
+            modified = email.utils.formatdate(stats.st_mtime, usegmt=True)
+            content_type = mimetypes.guess_type(pathname)[0] or "text/plain"
+            resp.headers = CaseInsensitiveDict({
+                "Content-Type": content_type,
+                "Content-Length": stats.st_size,
+                "Last-Modified": modified,
+            })
+
+            resp.raw = open(pathname, "rb")
+            resp.close = resp.raw.close
+
+        return resp
+
+    def close(self):
+        pass
+
+
+class InsecureHTTPAdapter(HTTPAdapter):
+
+    def cert_verify(self, conn, url, verify, cert):
+        super(InsecureHTTPAdapter, self).cert_verify(
+            conn=conn, url=url, verify=False, cert=cert
+        )
+
+
+class InsecureCacheControlAdapter(CacheControlAdapter):
+
+    def cert_verify(self, conn, url, verify, cert):
+        super(InsecureCacheControlAdapter, self).cert_verify(
+            conn=conn, url=url, verify=False, cert=cert
+        )
+
+
+class PipSession(requests.Session):
+
+    timeout = None  # type: Optional[int]
+
+    def __init__(self, *args, **kwargs):
+        """
+        :param trusted_hosts: Domains not to emit warnings for when not using
+            HTTPS.
+        """
+        retries = kwargs.pop("retries", 0)
+        cache = kwargs.pop("cache", None)
+        trusted_hosts = kwargs.pop("trusted_hosts", [])  # type: List[str]
+        index_urls = kwargs.pop("index_urls", None)
+
+        super(PipSession, self).__init__(*args, **kwargs)
+
+        # Namespace the attribute with "pip_" just in case to prevent
+        # possible conflicts with the base class.
+        self.pip_trusted_origins = []  # type: List[Tuple[str, Optional[int]]]
+
+        # Attach our User Agent to the request
+        self.headers["User-Agent"] = user_agent()
+
+        # Attach our Authentication handler to the session
+        self.auth = MultiDomainBasicAuth(index_urls=index_urls)
+
+        # Create our urllib3.Retry instance which will allow us to customize
+        # how we handle retries.
+        retries = urllib3.Retry(
+            # Set the total number of retries that a particular request can
+            # have.
+            total=retries,
+
+            # A 503 error from PyPI typically means that the Fastly -> Origin
+            # connection got interrupted in some way. A 503 error in general
+            # is typically considered a transient error so we'll go ahead and
+            # retry it.
+            # A 500 may indicate transient error in Amazon S3
+            # A 520 or 527 - may indicate transient error in CloudFlare
+            status_forcelist=[500, 503, 520, 527],
+
+            # Add a small amount of back off between failed requests in
+            # order to prevent hammering the service.
+            backoff_factor=0.25,
+        )
+
+        # Our Insecure HTTPAdapter disables HTTPS validation. It does not
+        # support caching so we'll use it for all http:// URLs.
+        # If caching is disabled, we will also use it for
+        # https:// hosts that we've marked as ignoring
+        # TLS errors for (trusted-hosts).
+        insecure_adapter = InsecureHTTPAdapter(max_retries=retries)
+
+        # We want to _only_ cache responses on securely fetched origins or when
+        # the host is specified as trusted. We do this because
+        # we can't validate the response of an insecurely/untrusted fetched
+        # origin, and we don't want someone to be able to poison the cache and
+        # require manual eviction from the cache to fix it.
+        if cache:
+            secure_adapter = CacheControlAdapter(
+                cache=SafeFileCache(cache),
+                max_retries=retries,
+            )
+            self._trusted_host_adapter = InsecureCacheControlAdapter(
+                cache=SafeFileCache(cache),
+                max_retries=retries,
+            )
+        else:
+            secure_adapter = HTTPAdapter(max_retries=retries)
+            self._trusted_host_adapter = insecure_adapter
+
+        self.mount("https://", secure_adapter)
+        self.mount("http://", insecure_adapter)
+
+        # Enable file:// urls
+        self.mount("file://", LocalFSAdapter())
+
+        for host in trusted_hosts:
+            self.add_trusted_host(host, suppress_logging=True)
+
+    def add_trusted_host(self, host, source=None, suppress_logging=False):
+        # type: (str, Optional[str], bool) -> None
+        """
+        :param host: It is okay to provide a host that has previously been
+            added.
+        :param source: An optional source string, for logging where the host
+            string came from.
+        """
+        if not suppress_logging:
+            msg = 'adding trusted host: {!r}'.format(host)
+            if source is not None:
+                msg += ' (from {})'.format(source)
+            logger.info(msg)
+
+        host_port = parse_netloc(host)
+        if host_port not in self.pip_trusted_origins:
+            self.pip_trusted_origins.append(host_port)
+
+        self.mount(
+            build_url_from_netloc(host) + '/',
+            self._trusted_host_adapter
+        )
+        if not host_port[1]:
+            # Mount wildcard ports for the same host.
+            self.mount(
+                build_url_from_netloc(host) + ':',
+                self._trusted_host_adapter
+            )
+
+    def iter_secure_origins(self):
+        # type: () -> Iterator[SecureOrigin]
+        for secure_origin in SECURE_ORIGINS:
+            yield secure_origin
+        for host, port in self.pip_trusted_origins:
+            yield ('*', host, '*' if port is None else port)
+
+    def is_secure_origin(self, location):
+        # type: (Link) -> bool
+        # Determine if this url used a secure transport mechanism
+        parsed = urllib_parse.urlparse(str(location))
+        origin_protocol, origin_host, origin_port = (
+            parsed.scheme, parsed.hostname, parsed.port,
+        )
+
+        # The protocol to use to see if the protocol matches.
+        # Don't count the repository type as part of the protocol: in
+        # cases such as "git+ssh", only use "ssh". (I.e., Only verify against
+        # the last scheme.)
+        origin_protocol = origin_protocol.rsplit('+', 1)[-1]
+
+        # Determine if our origin is a secure origin by looking through our
+        # hardcoded list of secure origins, as well as any additional ones
+        # configured on this PackageFinder instance.
+        for secure_origin in self.iter_secure_origins():
+            secure_protocol, secure_host, secure_port = secure_origin
+            if origin_protocol != secure_protocol and secure_protocol != "*":
+                continue
+
+            try:
+                addr = ipaddress.ip_address(
+                    None
+                    if origin_host is None
+                    else six.ensure_text(origin_host)
+                )
+                network = ipaddress.ip_network(
+                    six.ensure_text(secure_host)
+                )
+            except ValueError:
+                # We don't have both a valid address or a valid network, so
+                # we'll check this origin against hostnames.
+                if (
+                    origin_host and
+                    origin_host.lower() != secure_host.lower() and
+                    secure_host != "*"
+                ):
+                    continue
+            else:
+                # We have a valid address and network, so see if the address
+                # is contained within the network.
+                if addr not in network:
+                    continue
+
+            # Check to see if the port matches.
+            if (
+                origin_port != secure_port and
+                secure_port != "*" and
+                secure_port is not None
+            ):
+                continue
+
+            # If we've gotten here, then this origin matches the current
+            # secure origin and we should return True
+            return True
+
+        # If we've gotten to this point, then the origin isn't secure and we
+        # will not accept it as a valid location to search. We will however
+        # log a warning that we are ignoring it.
+        logger.warning(
+            "The repository located at %s is not a trusted or secure host and "
+            "is being ignored. If this repository is available via HTTPS we "
+            "recommend you use HTTPS instead, otherwise you may silence "
+            "this warning and allow it anyway with '--trusted-host %s'.",
+            origin_host,
+            origin_host,
+        )
+
+        return False
+
+    def request(self, method, url, *args, **kwargs):
+        # Allow setting a default timeout on a session
+        kwargs.setdefault("timeout", self.timeout)
+
+        # Dispatch the actual request
+        return super(PipSession, self).request(method, url, *args, **kwargs)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/network/utils.py b/myenv/lib/python3.9/site-packages/pip/_internal/network/utils.py
new file mode 100644
index 0000000..907b3fe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/network/utils.py
@@ -0,0 +1,97 @@
+from pip._vendor.requests.models import CONTENT_CHUNK_SIZE, Response
+
+from pip._internal.exceptions import NetworkConnectionError
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Dict, Iterator
+
+# The following comments and HTTP headers were originally added by
+# Donald Stufft in git commit 22c562429a61bb77172039e480873fb239dd8c03.
+#
+# We use Accept-Encoding: identity here because requests defaults to
+# accepting compressed responses. This breaks in a variety of ways
+# depending on how the server is configured.
+# - Some servers will notice that the file isn't a compressible file
+#   and will leave the file alone and with an empty Content-Encoding
+# - Some servers will notice that the file is already compressed and
+#   will leave the file alone, adding a Content-Encoding: gzip header
+# - Some servers won't notice anything at all and will take a file
+#   that's already been compressed and compress it again, and set
+#   the Content-Encoding: gzip header
+# By setting this to request only the identity encoding we're hoping
+# to eliminate the third case.  Hopefully there does not exist a server
+# which when given a file will notice it is already compressed and that
+# you're not asking for a compressed file and will then decompress it
+# before sending because if that's the case I don't think it'll ever be
+# possible to make this work.
+HEADERS = {'Accept-Encoding': 'identity'}  # type: Dict[str, str]
+
+
+def raise_for_status(resp):
+    # type: (Response) -> None
+    http_error_msg = u''
+    if isinstance(resp.reason, bytes):
+        # We attempt to decode utf-8 first because some servers
+        # choose to localize their reason strings. If the string
+        # isn't utf-8, we fall back to iso-8859-1 for all other
+        # encodings.
+        try:
+            reason = resp.reason.decode('utf-8')
+        except UnicodeDecodeError:
+            reason = resp.reason.decode('iso-8859-1')
+    else:
+        reason = resp.reason
+
+    if 400 <= resp.status_code < 500:
+        http_error_msg = u'%s Client Error: %s for url: %s' % (
+            resp.status_code, reason, resp.url)
+
+    elif 500 <= resp.status_code < 600:
+        http_error_msg = u'%s Server Error: %s for url: %s' % (
+            resp.status_code, reason, resp.url)
+
+    if http_error_msg:
+        raise NetworkConnectionError(http_error_msg, response=resp)
+
+
+def response_chunks(response, chunk_size=CONTENT_CHUNK_SIZE):
+    # type: (Response, int) -> Iterator[bytes]
+    """Given a requests Response, provide the data chunks.
+    """
+    try:
+        # Special case for urllib3.
+        for chunk in response.raw.stream(
+            chunk_size,
+            # We use decode_content=False here because we don't
+            # want urllib3 to mess with the raw bytes we get
+            # from the server. If we decompress inside of
+            # urllib3 then we cannot verify the checksum
+            # because the checksum will be of the compressed
+            # file. This breakage will only occur if the
+            # server adds a Content-Encoding header, which
+            # depends on how the server was configured:
+            # - Some servers will notice that the file isn't a
+            #   compressible file and will leave the file alone
+            #   and with an empty Content-Encoding
+            # - Some servers will notice that the file is
+            #   already compressed and will leave the file
+            #   alone and will add a Content-Encoding: gzip
+            #   header
+            # - Some servers won't notice anything at all and
+            #   will take a file that's already been compressed
+            #   and compress it again and set the
+            #   Content-Encoding: gzip header
+            #
+            # By setting this not to decode automatically we
+            # hope to eliminate problems with the second case.
+            decode_content=False,
+        ):
+            yield chunk
+    except AttributeError:
+        # Standard file-like object.
+        while True:
+            chunk = response.raw.read(chunk_size)
+            if not chunk:
+                break
+            yield chunk
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/network/xmlrpc.py b/myenv/lib/python3.9/site-packages/pip/_internal/network/xmlrpc.py
new file mode 100644
index 0000000..e611262
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/network/xmlrpc.py
@@ -0,0 +1,52 @@
+"""xmlrpclib.Transport implementation
+"""
+
+import logging
+
+# NOTE: XMLRPC Client is not annotated in typeshed as on 2017-07-17, which is
+#       why we ignore the type on this import
+from pip._vendor.six.moves import xmlrpc_client  # type: ignore
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+
+from pip._internal.exceptions import NetworkConnectionError
+from pip._internal.network.utils import raise_for_status
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Dict
+    from pip._internal.network.session import PipSession
+
+
+logger = logging.getLogger(__name__)
+
+
+class PipXmlrpcTransport(xmlrpc_client.Transport):
+    """Provide a `xmlrpclib.Transport` implementation via a `PipSession`
+    object.
+    """
+
+    def __init__(self, index_url, session, use_datetime=False):
+        # type: (str, PipSession, bool) -> None
+        xmlrpc_client.Transport.__init__(self, use_datetime)
+        index_parts = urllib_parse.urlparse(index_url)
+        self._scheme = index_parts.scheme
+        self._session = session
+
+    def request(self, host, handler, request_body, verbose=False):
+        # type: (str, str, Dict[str, str], bool) -> None
+        parts = (self._scheme, host, handler, None, None, None)
+        url = urllib_parse.urlunparse(parts)
+        try:
+            headers = {'Content-Type': 'text/xml'}
+            response = self._session.post(url, data=request_body,
+                                          headers=headers, stream=True)
+            raise_for_status(response)
+            self.verbose = verbose
+            return self.parse_response(response.raw)
+        except NetworkConnectionError as exc:
+            assert exc.response
+            logger.critical(
+                "HTTP error %s while getting %s",
+                exc.response.status_code, url,
+            )
+            raise
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/metadata.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/metadata.py
new file mode 100644
index 0000000..cf52f8d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/metadata.py
@@ -0,0 +1,37 @@
+"""Metadata generation logic for source distributions.
+"""
+
+import os
+
+from pip._internal.utils.subprocess import runner_with_spinner_message
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from pip._internal.build_env import BuildEnvironment
+    from pip._vendor.pep517.wrappers import Pep517HookCaller
+
+
+def generate_metadata(build_env, backend):
+    # type: (BuildEnvironment, Pep517HookCaller) -> str
+    """Generate metadata using mechanisms described in PEP 517.
+
+    Returns the generated metadata directory.
+    """
+    metadata_tmpdir = TempDirectory(
+        kind="modern-metadata", globally_managed=True
+    )
+
+    metadata_dir = metadata_tmpdir.path
+
+    with build_env:
+        # Note that Pep517HookCaller implements a fallback for
+        # prepare_metadata_for_build_wheel, so we don't have to
+        # consider the possibility that this hook doesn't exist.
+        runner = runner_with_spinner_message("Preparing wheel metadata")
+        with backend.subprocess_runner(runner):
+            distinfo_dir = backend.prepare_metadata_for_build_wheel(
+                metadata_dir
+            )
+
+    return os.path.join(metadata_dir, distinfo_dir)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/metadata_legacy.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/metadata_legacy.py
new file mode 100644
index 0000000..14762ae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/metadata_legacy.py
@@ -0,0 +1,77 @@
+"""Metadata generation logic for legacy source distributions.
+"""
+
+import logging
+import os
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.utils.setuptools_build import make_setuptools_egg_info_args
+from pip._internal.utils.subprocess import call_subprocess
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from pip._internal.build_env import BuildEnvironment
+
+logger = logging.getLogger(__name__)
+
+
+def _find_egg_info(directory):
+    # type: (str) -> str
+    """Find an .egg-info subdirectory in `directory`.
+    """
+    filenames = [
+        f for f in os.listdir(directory) if f.endswith(".egg-info")
+    ]
+
+    if not filenames:
+        raise InstallationError(
+            "No .egg-info directory found in {}".format(directory)
+        )
+
+    if len(filenames) > 1:
+        raise InstallationError(
+            "More than one .egg-info directory found in {}".format(
+                directory
+            )
+        )
+
+    return os.path.join(directory, filenames[0])
+
+
+def generate_metadata(
+    build_env,  # type: BuildEnvironment
+    setup_py_path,  # type: str
+    source_dir,  # type: str
+    isolated,  # type: bool
+    details,  # type: str
+):
+    # type: (...) -> str
+    """Generate metadata using setup.py-based defacto mechanisms.
+
+    Returns the generated metadata directory.
+    """
+    logger.debug(
+        'Running setup.py (path:%s) egg_info for package %s',
+        setup_py_path, details,
+    )
+
+    egg_info_dir = TempDirectory(
+        kind="pip-egg-info", globally_managed=True
+    ).path
+
+    args = make_setuptools_egg_info_args(
+        setup_py_path,
+        egg_info_dir=egg_info_dir,
+        no_user_config=isolated,
+    )
+
+    with build_env:
+        call_subprocess(
+            args,
+            cwd=source_dir,
+            command_desc='python setup.py egg_info',
+        )
+
+    # Return the .egg-info directory.
+    return _find_egg_info(egg_info_dir)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/wheel.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/wheel.py
new file mode 100644
index 0000000..0c28c49
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/wheel.py
@@ -0,0 +1,46 @@
+import logging
+import os
+
+from pip._internal.utils.subprocess import runner_with_spinner_message
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Optional
+    from pip._vendor.pep517.wrappers import Pep517HookCaller
+
+logger = logging.getLogger(__name__)
+
+
+def build_wheel_pep517(
+    name,  # type: str
+    backend,  # type: Pep517HookCaller
+    metadata_directory,  # type: str
+    build_options,  # type: List[str]
+    tempd,  # type: str
+):
+    # type: (...) -> Optional[str]
+    """Build one InstallRequirement using the PEP 517 build process.
+
+    Returns path to wheel if successfully built. Otherwise, returns None.
+    """
+    assert metadata_directory is not None
+    if build_options:
+        # PEP 517 does not support --build-options
+        logger.error('Cannot build wheel for %s using PEP 517 when '
+                     '--build-option is present', name)
+        return None
+    try:
+        logger.debug('Destination directory: %s', tempd)
+
+        runner = runner_with_spinner_message(
+            'Building wheel for {} (PEP 517)'.format(name)
+        )
+        with backend.subprocess_runner(runner):
+            wheel_name = backend.build_wheel(
+                tempd,
+                metadata_directory=metadata_directory,
+            )
+    except Exception:
+        logger.error('Failed building wheel for %s', name)
+        return None
+    return os.path.join(tempd, wheel_name)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/wheel_legacy.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/wheel_legacy.py
new file mode 100644
index 0000000..37dc876
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/operations/build/wheel_legacy.py
@@ -0,0 +1,115 @@
+import logging
+import os.path
+
+from pip._internal.cli.spinners import open_spinner
+from pip._internal.utils.setuptools_build import (
+    make_setuptools_bdist_wheel_args,
+)
+from pip._internal.utils.subprocess import (
+    LOG_DIVIDER,
+    call_subprocess,
+    format_command_args,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Optional, Text
+
+logger = logging.getLogger(__name__)
+
+
+def format_command_result(
+    command_args,  # type: List[str]
+    command_output,  # type: Text
+):
+    # type: (...) -> str
+    """Format command information for logging."""
+    command_desc = format_command_args(command_args)
+    text = 'Command arguments: {}\n'.format(command_desc)
+
+    if not command_output:
+        text += 'Command output: None'
+    elif logger.getEffectiveLevel() > logging.DEBUG:
+        text += 'Command output: [use --verbose to show]'
+    else:
+        if not command_output.endswith('\n'):
+            command_output += '\n'
+        text += 'Command output:\n{}{}'.format(command_output, LOG_DIVIDER)
+
+    return text
+
+
+def get_legacy_build_wheel_path(
+    names,  # type: List[str]
+    temp_dir,  # type: str
+    name,  # type: str
+    command_args,  # type: List[str]
+    command_output,  # type: Text
+):
+    # type: (...) -> Optional[str]
+    """Return the path to the wheel in the temporary build directory."""
+    # Sort for determinism.
+    names = sorted(names)
+    if not names:
+        msg = (
+            'Legacy build of wheel for {!r} created no files.\n'
+        ).format(name)
+        msg += format_command_result(command_args, command_output)
+        logger.warning(msg)
+        return None
+
+    if len(names) > 1:
+        msg = (
+            'Legacy build of wheel for {!r} created more than one file.\n'
+            'Filenames (choosing first): {}\n'
+        ).format(name, names)
+        msg += format_command_result(command_args, command_output)
+        logger.warning(msg)
+
+    return os.path.join(temp_dir, names[0])
+
+
+def build_wheel_legacy(
+    name,  # type: str
+    setup_py_path,  # type: str
+    source_dir,  # type: str
+    global_options,  # type: List[str]
+    build_options,  # type: List[str]
+    tempd,  # type: str
+):
+    # type: (...) -> Optional[str]
+    """Build one unpacked package using the "legacy" build process.
+
+    Returns path to wheel if successfully built. Otherwise, returns None.
+    """
+    wheel_args = make_setuptools_bdist_wheel_args(
+        setup_py_path,
+        global_options=global_options,
+        build_options=build_options,
+        destination_dir=tempd,
+    )
+
+    spin_message = 'Building wheel for {} (setup.py)'.format(name)
+    with open_spinner(spin_message) as spinner:
+        logger.debug('Destination directory: %s', tempd)
+
+        try:
+            output = call_subprocess(
+                wheel_args,
+                cwd=source_dir,
+                spinner=spinner,
+            )
+        except Exception:
+            spinner.finish("error")
+            logger.error('Failed building wheel for %s', name)
+            return None
+
+        names = os.listdir(tempd)
+        wheel_path = get_legacy_build_wheel_path(
+            names=names,
+            temp_dir=tempd,
+            name=name,
+            command_args=wheel_args,
+            command_output=output,
+        )
+        return wheel_path
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/check.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/check.py
new file mode 100644
index 0000000..5714915
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/operations/check.py
@@ -0,0 +1,158 @@
+"""Validation of dependencies of packages
+"""
+
+import logging
+from collections import namedtuple
+
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.pkg_resources import RequirementParseError
+
+from pip._internal.distributions import (
+    make_distribution_for_install_requirement,
+)
+from pip._internal.utils.misc import get_installed_distributions
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+logger = logging.getLogger(__name__)
+
+if MYPY_CHECK_RUNNING:
+    from pip._internal.req.req_install import InstallRequirement
+    from typing import (
+        Any, Callable, Dict, Optional, Set, Tuple, List
+    )
+
+    # Shorthands
+    PackageSet = Dict[str, 'PackageDetails']
+    Missing = Tuple[str, Any]
+    Conflicting = Tuple[str, str, Any]
+
+    MissingDict = Dict[str, List[Missing]]
+    ConflictingDict = Dict[str, List[Conflicting]]
+    CheckResult = Tuple[MissingDict, ConflictingDict]
+    ConflictDetails = Tuple[PackageSet, CheckResult]
+
+PackageDetails = namedtuple('PackageDetails', ['version', 'requires'])
+
+
+def create_package_set_from_installed(**kwargs):
+    # type: (**Any) -> Tuple[PackageSet, bool]
+    """Converts a list of distributions into a PackageSet.
+    """
+    # Default to using all packages installed on the system
+    if kwargs == {}:
+        kwargs = {"local_only": False, "skip": ()}
+
+    package_set = {}
+    problems = False
+    for dist in get_installed_distributions(**kwargs):
+        name = canonicalize_name(dist.project_name)
+        try:
+            package_set[name] = PackageDetails(dist.version, dist.requires())
+        except RequirementParseError as e:
+            # Don't crash on broken metadata
+            logger.warning("Error parsing requirements for %s: %s", name, e)
+            problems = True
+    return package_set, problems
+
+
+def check_package_set(package_set, should_ignore=None):
+    # type: (PackageSet, Optional[Callable[[str], bool]]) -> CheckResult
+    """Check if a package set is consistent
+
+    If should_ignore is passed, it should be a callable that takes a
+    package name and returns a boolean.
+    """
+
+    missing = {}
+    conflicting = {}
+
+    for package_name in package_set:
+        # Info about dependencies of package_name
+        missing_deps = set()  # type: Set[Missing]
+        conflicting_deps = set()  # type: Set[Conflicting]
+
+        if should_ignore and should_ignore(package_name):
+            continue
+
+        for req in package_set[package_name].requires:
+            name = canonicalize_name(req.project_name)  # type: str
+
+            # Check if it's missing
+            if name not in package_set:
+                missed = True
+                if req.marker is not None:
+                    missed = req.marker.evaluate()
+                if missed:
+                    missing_deps.add((name, req))
+                continue
+
+            # Check if there's a conflict
+            version = package_set[name].version  # type: str
+            if not req.specifier.contains(version, prereleases=True):
+                conflicting_deps.add((name, version, req))
+
+        if missing_deps:
+            missing[package_name] = sorted(missing_deps, key=str)
+        if conflicting_deps:
+            conflicting[package_name] = sorted(conflicting_deps, key=str)
+
+    return missing, conflicting
+
+
+def check_install_conflicts(to_install):
+    # type: (List[InstallRequirement]) -> ConflictDetails
+    """For checking if the dependency graph would be consistent after \
+    installing given requirements
+    """
+    # Start from the current state
+    package_set, _ = create_package_set_from_installed()
+    # Install packages
+    would_be_installed = _simulate_installation_of(to_install, package_set)
+
+    # Only warn about directly-dependent packages; create a whitelist of them
+    whitelist = _create_whitelist(would_be_installed, package_set)
+
+    return (
+        package_set,
+        check_package_set(
+            package_set, should_ignore=lambda name: name not in whitelist
+        )
+    )
+
+
+def _simulate_installation_of(to_install, package_set):
+    # type: (List[InstallRequirement], PackageSet) -> Set[str]
+    """Computes the version of packages after installing to_install.
+    """
+
+    # Keep track of packages that were installed
+    installed = set()
+
+    # Modify it as installing requirement_set would (assuming no errors)
+    for inst_req in to_install:
+        abstract_dist = make_distribution_for_install_requirement(inst_req)
+        dist = abstract_dist.get_pkg_resources_distribution()
+
+        assert dist is not None
+        name = canonicalize_name(dist.key)
+        package_set[name] = PackageDetails(dist.version, dist.requires())
+
+        installed.add(name)
+
+    return installed
+
+
+def _create_whitelist(would_be_installed, package_set):
+    # type: (Set[str], PackageSet) -> Set[str]
+    packages_affected = set(would_be_installed)
+
+    for package_name in package_set:
+        if package_name in packages_affected:
+            continue
+
+        for req in package_set[package_name].requires:
+            if canonicalize_name(req.name) in packages_affected:
+                packages_affected.add(package_name)
+                break
+
+    return packages_affected
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/freeze.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/freeze.py
new file mode 100644
index 0000000..ddb9cb2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/operations/freeze.py
@@ -0,0 +1,272 @@
+from __future__ import absolute_import
+
+import collections
+import logging
+import os
+
+from pip._vendor import six
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.pkg_resources import RequirementParseError
+
+from pip._internal.exceptions import BadCommand, InstallationError
+from pip._internal.req.constructors import (
+    install_req_from_editable,
+    install_req_from_line,
+)
+from pip._internal.req.req_file import COMMENT_RE
+from pip._internal.utils.direct_url_helpers import (
+    direct_url_as_pep440_direct_reference,
+    dist_get_direct_url,
+)
+from pip._internal.utils.misc import (
+    dist_is_editable,
+    get_installed_distributions,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Iterator, Optional, List, Container, Set, Dict, Tuple, Iterable, Union
+    )
+    from pip._internal.cache import WheelCache
+    from pip._vendor.pkg_resources import (
+        Distribution, Requirement
+    )
+
+    RequirementInfo = Tuple[Optional[Union[str, Requirement]], bool, List[str]]
+
+
+logger = logging.getLogger(__name__)
+
+
+def freeze(
+    requirement=None,  # type: Optional[List[str]]
+    find_links=None,  # type: Optional[List[str]]
+    local_only=False,  # type: bool
+    user_only=False,  # type: bool
+    paths=None,  # type: Optional[List[str]]
+    isolated=False,  # type: bool
+    wheel_cache=None,  # type: Optional[WheelCache]
+    exclude_editable=False,  # type: bool
+    skip=()  # type: Container[str]
+):
+    # type: (...) -> Iterator[str]
+    find_links = find_links or []
+
+    for link in find_links:
+        yield '-f {}'.format(link)
+    installations = {}  # type: Dict[str, FrozenRequirement]
+
+    for dist in get_installed_distributions(
+            local_only=local_only,
+            skip=(),
+            user_only=user_only,
+            paths=paths
+    ):
+        try:
+            req = FrozenRequirement.from_dist(dist)
+        except RequirementParseError as exc:
+            # We include dist rather than dist.project_name because the
+            # dist string includes more information, like the version and
+            # location. We also include the exception message to aid
+            # troubleshooting.
+            logger.warning(
+                'Could not generate requirement for distribution %r: %s',
+                dist, exc
+            )
+            continue
+        if exclude_editable and req.editable:
+            continue
+        installations[req.canonical_name] = req
+
+    if requirement:
+        # the options that don't get turned into an InstallRequirement
+        # should only be emitted once, even if the same option is in multiple
+        # requirements files, so we need to keep track of what has been emitted
+        # so that we don't emit it again if it's seen again
+        emitted_options = set()  # type: Set[str]
+        # keep track of which files a requirement is in so that we can
+        # give an accurate warning if a requirement appears multiple times.
+        req_files = collections.defaultdict(list)  # type: Dict[str, List[str]]
+        for req_file_path in requirement:
+            with open(req_file_path) as req_file:
+                for line in req_file:
+                    if (not line.strip() or
+                            line.strip().startswith('#') or
+                            line.startswith((
+                                '-r', '--requirement',
+                                '-f', '--find-links',
+                                '-i', '--index-url',
+                                '--pre',
+                                '--trusted-host',
+                                '--process-dependency-links',
+                                '--extra-index-url',
+                                '--use-feature'))):
+                        line = line.rstrip()
+                        if line not in emitted_options:
+                            emitted_options.add(line)
+                            yield line
+                        continue
+
+                    if line.startswith('-e') or line.startswith('--editable'):
+                        if line.startswith('-e'):
+                            line = line[2:].strip()
+                        else:
+                            line = line[len('--editable'):].strip().lstrip('=')
+                        line_req = install_req_from_editable(
+                            line,
+                            isolated=isolated,
+                        )
+                    else:
+                        line_req = install_req_from_line(
+                            COMMENT_RE.sub('', line).strip(),
+                            isolated=isolated,
+                        )
+
+                    if not line_req.name:
+                        logger.info(
+                            "Skipping line in requirement file [%s] because "
+                            "it's not clear what it would install: %s",
+                            req_file_path, line.strip(),
+                        )
+                        logger.info(
+                            "  (add #egg=PackageName to the URL to avoid"
+                            " this warning)"
+                        )
+                    else:
+                        line_req_canonical_name = canonicalize_name(
+                            line_req.name)
+                        if line_req_canonical_name not in installations:
+                            # either it's not installed, or it is installed
+                            # but has been processed already
+                            if not req_files[line_req.name]:
+                                logger.warning(
+                                    "Requirement file [%s] contains %s, but "
+                                    "package %r is not installed",
+                                    req_file_path,
+                                    COMMENT_RE.sub('', line).strip(),
+                                    line_req.name
+                                )
+                            else:
+                                req_files[line_req.name].append(req_file_path)
+                        else:
+                            yield str(installations[
+                                line_req_canonical_name]).rstrip()
+                            del installations[line_req_canonical_name]
+                            req_files[line_req.name].append(req_file_path)
+
+        # Warn about requirements that were included multiple times (in a
+        # single requirements file or in different requirements files).
+        for name, files in six.iteritems(req_files):
+            if len(files) > 1:
+                logger.warning("Requirement %s included multiple times [%s]",
+                               name, ', '.join(sorted(set(files))))
+
+        yield(
+            '## The following requirements were added by '
+            'pip freeze:'
+        )
+    for installation in sorted(
+            installations.values(), key=lambda x: x.name.lower()):
+        if installation.canonical_name not in skip:
+            yield str(installation).rstrip()
+
+
+def get_requirement_info(dist):
+    # type: (Distribution) -> RequirementInfo
+    """
+    Compute and return values (req, editable, comments) for use in
+    FrozenRequirement.from_dist().
+    """
+    if not dist_is_editable(dist):
+        return (None, False, [])
+
+    location = os.path.normcase(os.path.abspath(dist.location))
+
+    from pip._internal.vcs import vcs, RemoteNotFoundError
+    vcs_backend = vcs.get_backend_for_dir(location)
+
+    if vcs_backend is None:
+        req = dist.as_requirement()
+        logger.debug(
+            'No VCS found for editable requirement "%s" in: %r', req,
+            location,
+        )
+        comments = [
+            '# Editable install with no version control ({})'.format(req)
+        ]
+        return (location, True, comments)
+
+    try:
+        req = vcs_backend.get_src_requirement(location, dist.project_name)
+    except RemoteNotFoundError:
+        req = dist.as_requirement()
+        comments = [
+            '# Editable {} install with no remote ({})'.format(
+                type(vcs_backend).__name__, req,
+            )
+        ]
+        return (location, True, comments)
+
+    except BadCommand:
+        logger.warning(
+            'cannot determine version of editable source in %s '
+            '(%s command not found in path)',
+            location,
+            vcs_backend.name,
+        )
+        return (None, True, [])
+
+    except InstallationError as exc:
+        logger.warning(
+            "Error when trying to get requirement for VCS system %s, "
+            "falling back to uneditable format", exc
+        )
+    else:
+        if req is not None:
+            return (req, True, [])
+
+    logger.warning(
+        'Could not determine repository location of %s', location
+    )
+    comments = ['## !! Could not determine repository location']
+
+    return (None, False, comments)
+
+
+class FrozenRequirement(object):
+    def __init__(self, name, req, editable, comments=()):
+        # type: (str, Union[str, Requirement], bool, Iterable[str]) -> None
+        self.name = name
+        self.canonical_name = canonicalize_name(name)
+        self.req = req
+        self.editable = editable
+        self.comments = comments
+
+    @classmethod
+    def from_dist(cls, dist):
+        # type: (Distribution) -> FrozenRequirement
+        # TODO `get_requirement_info` is taking care of editable requirements.
+        # TODO This should be refactored when we will add detection of
+        #      editable that provide .dist-info metadata.
+        req, editable, comments = get_requirement_info(dist)
+        if req is None and not editable:
+            # if PEP 610 metadata is present, attempt to use it
+            direct_url = dist_get_direct_url(dist)
+            if direct_url:
+                req = direct_url_as_pep440_direct_reference(
+                    direct_url, dist.project_name
+                )
+                comments = []
+        if req is None:
+            # name==version requirement
+            req = dist.as_requirement()
+
+        return cls(dist.project_name, req, editable, comments=comments)
+
+    def __str__(self):
+        # type: () -> str
+        req = self.req
+        if self.editable:
+            req = '-e {}'.format(req)
+        return '\n'.join(list(self.comments) + [str(req)]) + '\n'
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/__init__.py
new file mode 100644
index 0000000..24d6a5d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/__init__.py
@@ -0,0 +1,2 @@
+"""For modules related to installing packages.
+"""
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/editable_legacy.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/editable_legacy.py
new file mode 100644
index 0000000..a668a61
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/editable_legacy.py
@@ -0,0 +1,52 @@
+"""Legacy editable installation process, i.e. `setup.py develop`.
+"""
+import logging
+
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.setuptools_build import make_setuptools_develop_args
+from pip._internal.utils.subprocess import call_subprocess
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Optional, Sequence
+
+    from pip._internal.build_env import BuildEnvironment
+
+
+logger = logging.getLogger(__name__)
+
+
+def install_editable(
+    install_options,  # type: List[str]
+    global_options,  # type: Sequence[str]
+    prefix,  # type: Optional[str]
+    home,  # type: Optional[str]
+    use_user_site,  # type: bool
+    name,  # type: str
+    setup_py_path,  # type: str
+    isolated,  # type: bool
+    build_env,  # type: BuildEnvironment
+    unpacked_source_directory,  # type: str
+):
+    # type: (...) -> None
+    """Install a package in editable mode. Most arguments are pass-through
+    to setuptools.
+    """
+    logger.info('Running setup.py develop for %s', name)
+
+    args = make_setuptools_develop_args(
+        setup_py_path,
+        global_options=global_options,
+        install_options=install_options,
+        no_user_config=isolated,
+        prefix=prefix,
+        home=home,
+        use_user_site=use_user_site,
+    )
+
+    with indent_log():
+        with build_env:
+            call_subprocess(
+                args,
+                cwd=unpacked_source_directory,
+            )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/legacy.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/legacy.py
new file mode 100644
index 0000000..87227d5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/legacy.py
@@ -0,0 +1,130 @@
+"""Legacy installation process, i.e. `setup.py install`.
+"""
+
+import logging
+import os
+import sys
+from distutils.util import change_root
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import ensure_dir
+from pip._internal.utils.setuptools_build import make_setuptools_install_args
+from pip._internal.utils.subprocess import runner_with_spinner_message
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Optional, Sequence
+
+    from pip._internal.build_env import BuildEnvironment
+    from pip._internal.models.scheme import Scheme
+
+
+logger = logging.getLogger(__name__)
+
+
+class LegacyInstallFailure(Exception):
+    def __init__(self):
+        # type: () -> None
+        self.parent = sys.exc_info()
+
+
+def install(
+    install_options,  # type: List[str]
+    global_options,  # type: Sequence[str]
+    root,  # type: Optional[str]
+    home,  # type: Optional[str]
+    prefix,  # type: Optional[str]
+    use_user_site,  # type: bool
+    pycompile,  # type: bool
+    scheme,  # type: Scheme
+    setup_py_path,  # type: str
+    isolated,  # type: bool
+    req_name,  # type: str
+    build_env,  # type: BuildEnvironment
+    unpacked_source_directory,  # type: str
+    req_description,  # type: str
+):
+    # type: (...) -> bool
+
+    header_dir = scheme.headers
+
+    with TempDirectory(kind="record") as temp_dir:
+        try:
+            record_filename = os.path.join(temp_dir.path, 'install-record.txt')
+            install_args = make_setuptools_install_args(
+                setup_py_path,
+                global_options=global_options,
+                install_options=install_options,
+                record_filename=record_filename,
+                root=root,
+                prefix=prefix,
+                header_dir=header_dir,
+                home=home,
+                use_user_site=use_user_site,
+                no_user_config=isolated,
+                pycompile=pycompile,
+            )
+
+            runner = runner_with_spinner_message(
+                "Running setup.py install for {}".format(req_name)
+            )
+            with indent_log(), build_env:
+                runner(
+                    cmd=install_args,
+                    cwd=unpacked_source_directory,
+                )
+
+            if not os.path.exists(record_filename):
+                logger.debug('Record file %s not found', record_filename)
+                # Signal to the caller that we didn't install the new package
+                return False
+
+        except Exception:
+            # Signal to the caller that we didn't install the new package
+            raise LegacyInstallFailure
+
+        # At this point, we have successfully installed the requirement.
+
+        # We intentionally do not use any encoding to read the file because
+        # setuptools writes the file using distutils.file_util.write_file,
+        # which does not specify an encoding.
+        with open(record_filename) as f:
+            record_lines = f.read().splitlines()
+
+    def prepend_root(path):
+        # type: (str) -> str
+        if root is None or not os.path.isabs(path):
+            return path
+        else:
+            return change_root(root, path)
+
+    for line in record_lines:
+        directory = os.path.dirname(line)
+        if directory.endswith('.egg-info'):
+            egg_info_dir = prepend_root(directory)
+            break
+    else:
+        message = (
+            "{} did not indicate that it installed an "
+            ".egg-info directory. Only setup.py projects "
+            "generating .egg-info directories are supported."
+        ).format(req_description)
+        raise InstallationError(message)
+
+    new_lines = []
+    for line in record_lines:
+        filename = line.strip()
+        if os.path.isdir(filename):
+            filename += os.path.sep
+        new_lines.append(
+            os.path.relpath(prepend_root(filename), egg_info_dir)
+        )
+    new_lines.sort()
+    ensure_dir(egg_info_dir)
+    inst_files_path = os.path.join(egg_info_dir, 'installed-files.txt')
+    with open(inst_files_path, 'w') as f:
+        f.write('\n'.join(new_lines) + '\n')
+
+    return True
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/wheel.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/wheel.py
new file mode 100644
index 0000000..e91b1b8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/operations/install/wheel.py
@@ -0,0 +1,861 @@
+"""Support for installing and building the "wheel" binary package format.
+"""
+
+from __future__ import absolute_import
+
+import collections
+import compileall
+import contextlib
+import csv
+import importlib
+import logging
+import os.path
+import re
+import shutil
+import sys
+import warnings
+from base64 import urlsafe_b64encode
+from itertools import chain, starmap
+from zipfile import ZipFile
+
+from pip._vendor import pkg_resources
+from pip._vendor.distlib.scripts import ScriptMaker
+from pip._vendor.distlib.util import get_export_entry
+from pip._vendor.six import (
+    PY2,
+    ensure_str,
+    ensure_text,
+    itervalues,
+    reraise,
+    text_type,
+)
+from pip._vendor.six.moves import filterfalse, map
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.locations import get_major_minor_version
+from pip._internal.models.direct_url import DIRECT_URL_METADATA_NAME, DirectUrl
+from pip._internal.models.scheme import SCHEME_KEYS
+from pip._internal.utils.filesystem import adjacent_tmp_file, replace
+from pip._internal.utils.misc import (
+    captured_stdout,
+    ensure_dir,
+    hash_file,
+    partition,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.unpacking import (
+    current_umask,
+    is_within_directory,
+    set_extracted_file_to_default_mode_plus_executable,
+    zip_item_is_executable,
+)
+from pip._internal.utils.wheel import (
+    parse_wheel,
+    pkg_resources_distribution_for_wheel,
+)
+
+# Use the custom cast function at runtime to make cast work,
+# and import typing.cast when performing pre-commit and type
+# checks
+if not MYPY_CHECK_RUNNING:
+    from pip._internal.utils.typing import cast
+else:
+    from email.message import Message
+    from typing import (
+        Any,
+        Callable,
+        Dict,
+        IO,
+        Iterable,
+        Iterator,
+        List,
+        NewType,
+        Optional,
+        Protocol,
+        Sequence,
+        Set,
+        Tuple,
+        Union,
+        cast,
+    )
+    from zipfile import ZipInfo
+
+    from pip._vendor.pkg_resources import Distribution
+
+    from pip._internal.models.scheme import Scheme
+    from pip._internal.utils.filesystem import NamedTemporaryFileResult
+
+    RecordPath = NewType('RecordPath', text_type)
+    InstalledCSVRow = Tuple[RecordPath, str, Union[int, str]]
+
+    class File(Protocol):
+        src_record_path = None  # type: RecordPath
+        dest_path = None  # type: text_type
+        changed = None  # type: bool
+
+        def save(self):
+            # type: () -> None
+            pass
+
+
+logger = logging.getLogger(__name__)
+
+
+def rehash(path, blocksize=1 << 20):
+    # type: (text_type, int) -> Tuple[str, str]
+    """Return (encoded_digest, length) for path using hashlib.sha256()"""
+    h, length = hash_file(path, blocksize)
+    digest = 'sha256=' + urlsafe_b64encode(
+        h.digest()
+    ).decode('latin1').rstrip('=')
+    # unicode/str python2 issues
+    return (digest, str(length))  # type: ignore
+
+
+def csv_io_kwargs(mode):
+    # type: (str) -> Dict[str, Any]
+    """Return keyword arguments to properly open a CSV file
+    in the given mode.
+    """
+    if PY2:
+        return {'mode': '{}b'.format(mode)}
+    else:
+        return {'mode': mode, 'newline': '', 'encoding': 'utf-8'}
+
+
+def fix_script(path):
+    # type: (text_type) -> bool
+    """Replace #!python with #!/path/to/python
+    Return True if file was changed.
+    """
+    # XXX RECORD hashes will need to be updated
+    assert os.path.isfile(path)
+
+    with open(path, 'rb') as script:
+        firstline = script.readline()
+        if not firstline.startswith(b'#!python'):
+            return False
+        exename = sys.executable.encode(sys.getfilesystemencoding())
+        firstline = b'#!' + exename + os.linesep.encode("ascii")
+        rest = script.read()
+    with open(path, 'wb') as script:
+        script.write(firstline)
+        script.write(rest)
+    return True
+
+
+def wheel_root_is_purelib(metadata):
+    # type: (Message) -> bool
+    return metadata.get("Root-Is-Purelib", "").lower() == "true"
+
+
+def get_entrypoints(distribution):
+    # type: (Distribution) -> Tuple[Dict[str, str], Dict[str, str]]
+    # get the entry points and then the script names
+    try:
+        console = distribution.get_entry_map('console_scripts')
+        gui = distribution.get_entry_map('gui_scripts')
+    except KeyError:
+        # Our dict-based Distribution raises KeyError if entry_points.txt
+        # doesn't exist.
+        return {}, {}
+
+    def _split_ep(s):
+        # type: (pkg_resources.EntryPoint) -> Tuple[str, str]
+        """get the string representation of EntryPoint,
+        remove space and split on '='
+        """
+        split_parts = str(s).replace(" ", "").split("=")
+        return split_parts[0], split_parts[1]
+
+    # convert the EntryPoint objects into strings with module:function
+    console = dict(_split_ep(v) for v in console.values())
+    gui = dict(_split_ep(v) for v in gui.values())
+    return console, gui
+
+
+def message_about_scripts_not_on_PATH(scripts):
+    # type: (Sequence[str]) -> Optional[str]
+    """Determine if any scripts are not on PATH and format a warning.
+    Returns a warning message if one or more scripts are not on PATH,
+    otherwise None.
+    """
+    if not scripts:
+        return None
+
+    # Group scripts by the path they were installed in
+    grouped_by_dir = collections.defaultdict(set)  # type: Dict[str, Set[str]]
+    for destfile in scripts:
+        parent_dir = os.path.dirname(destfile)
+        script_name = os.path.basename(destfile)
+        grouped_by_dir[parent_dir].add(script_name)
+
+    # We don't want to warn for directories that are on PATH.
+    not_warn_dirs = [
+        os.path.normcase(i).rstrip(os.sep) for i in
+        os.environ.get("PATH", "").split(os.pathsep)
+    ]
+    # If an executable sits with sys.executable, we don't warn for it.
+    #     This covers the case of venv invocations without activating the venv.
+    not_warn_dirs.append(os.path.normcase(os.path.dirname(sys.executable)))
+    warn_for = {
+        parent_dir: scripts for parent_dir, scripts in grouped_by_dir.items()
+        if os.path.normcase(parent_dir) not in not_warn_dirs
+    }  # type: Dict[str, Set[str]]
+    if not warn_for:
+        return None
+
+    # Format a message
+    msg_lines = []
+    for parent_dir, dir_scripts in warn_for.items():
+        sorted_scripts = sorted(dir_scripts)  # type: List[str]
+        if len(sorted_scripts) == 1:
+            start_text = "script {} is".format(sorted_scripts[0])
+        else:
+            start_text = "scripts {} are".format(
+                ", ".join(sorted_scripts[:-1]) + " and " + sorted_scripts[-1]
+            )
+
+        msg_lines.append(
+            "The {} installed in '{}' which is not on PATH."
+            .format(start_text, parent_dir)
+        )
+
+    last_line_fmt = (
+        "Consider adding {} to PATH or, if you prefer "
+        "to suppress this warning, use --no-warn-script-location."
+    )
+    if len(msg_lines) == 1:
+        msg_lines.append(last_line_fmt.format("this directory"))
+    else:
+        msg_lines.append(last_line_fmt.format("these directories"))
+
+    # Add a note if any directory starts with ~
+    warn_for_tilde = any(
+        i[0] == "~" for i in os.environ.get("PATH", "").split(os.pathsep) if i
+    )
+    if warn_for_tilde:
+        tilde_warning_msg = (
+            "NOTE: The current PATH contains path(s) starting with `~`, "
+            "which may not be expanded by all applications."
+        )
+        msg_lines.append(tilde_warning_msg)
+
+    # Returns the formatted multiline message
+    return "\n".join(msg_lines)
+
+
+def _normalized_outrows(outrows):
+    # type: (Iterable[InstalledCSVRow]) -> List[Tuple[str, str, str]]
+    """Normalize the given rows of a RECORD file.
+
+    Items in each row are converted into str. Rows are then sorted to make
+    the value more predictable for tests.
+
+    Each row is a 3-tuple (path, hash, size) and corresponds to a record of
+    a RECORD file (see PEP 376 and PEP 427 for details).  For the rows
+    passed to this function, the size can be an integer as an int or string,
+    or the empty string.
+    """
+    # Normally, there should only be one row per path, in which case the
+    # second and third elements don't come into play when sorting.
+    # However, in cases in the wild where a path might happen to occur twice,
+    # we don't want the sort operation to trigger an error (but still want
+    # determinism).  Since the third element can be an int or string, we
+    # coerce each element to a string to avoid a TypeError in this case.
+    # For additional background, see--
+    # https://github.com/pypa/pip/issues/5868
+    return sorted(
+        (ensure_str(record_path, encoding='utf-8'), hash_, str(size))
+        for record_path, hash_, size in outrows
+    )
+
+
+def _record_to_fs_path(record_path):
+    # type: (RecordPath) -> text_type
+    return record_path
+
+
+def _fs_to_record_path(path, relative_to=None):
+    # type: (text_type, Optional[text_type]) -> RecordPath
+    if relative_to is not None:
+        # On Windows, do not handle relative paths if they belong to different
+        # logical disks
+        if os.path.splitdrive(path)[0].lower() == \
+                os.path.splitdrive(relative_to)[0].lower():
+            path = os.path.relpath(path, relative_to)
+    path = path.replace(os.path.sep, '/')
+    return cast('RecordPath', path)
+
+
+def _parse_record_path(record_column):
+    # type: (str) -> RecordPath
+    p = ensure_text(record_column, encoding='utf-8')
+    return cast('RecordPath', p)
+
+
+def get_csv_rows_for_installed(
+    old_csv_rows,  # type: List[List[str]]
+    installed,  # type: Dict[RecordPath, RecordPath]
+    changed,  # type: Set[RecordPath]
+    generated,  # type: List[str]
+    lib_dir,  # type: str
+):
+    # type: (...) -> List[InstalledCSVRow]
+    """
+    :param installed: A map from archive RECORD path to installation RECORD
+        path.
+    """
+    installed_rows = []  # type: List[InstalledCSVRow]
+    for row in old_csv_rows:
+        if len(row) > 3:
+            logger.warning('RECORD line has more than three elements: %s', row)
+        old_record_path = _parse_record_path(row[0])
+        new_record_path = installed.pop(old_record_path, old_record_path)
+        if new_record_path in changed:
+            digest, length = rehash(_record_to_fs_path(new_record_path))
+        else:
+            digest = row[1] if len(row) > 1 else ''
+            length = row[2] if len(row) > 2 else ''
+        installed_rows.append((new_record_path, digest, length))
+    for f in generated:
+        path = _fs_to_record_path(f, lib_dir)
+        digest, length = rehash(f)
+        installed_rows.append((path, digest, length))
+    for installed_record_path in itervalues(installed):
+        installed_rows.append((installed_record_path, '', ''))
+    return installed_rows
+
+
+def get_console_script_specs(console):
+    # type: (Dict[str, str]) -> List[str]
+    """
+    Given the mapping from entrypoint name to callable, return the relevant
+    console script specs.
+    """
+    # Don't mutate caller's version
+    console = console.copy()
+
+    scripts_to_generate = []
+
+    # Special case pip and setuptools to generate versioned wrappers
+    #
+    # The issue is that some projects (specifically, pip and setuptools) use
+    # code in setup.py to create "versioned" entry points - pip2.7 on Python
+    # 2.7, pip3.3 on Python 3.3, etc. But these entry points are baked into
+    # the wheel metadata at build time, and so if the wheel is installed with
+    # a *different* version of Python the entry points will be wrong. The
+    # correct fix for this is to enhance the metadata to be able to describe
+    # such versioned entry points, but that won't happen till Metadata 2.0 is
+    # available.
+    # In the meantime, projects using versioned entry points will either have
+    # incorrect versioned entry points, or they will not be able to distribute
+    # "universal" wheels (i.e., they will need a wheel per Python version).
+    #
+    # Because setuptools and pip are bundled with _ensurepip and virtualenv,
+    # we need to use universal wheels. So, as a stopgap until Metadata 2.0, we
+    # override the versioned entry points in the wheel and generate the
+    # correct ones. This code is purely a short-term measure until Metadata 2.0
+    # is available.
+    #
+    # To add the level of hack in this section of code, in order to support
+    # ensurepip this code will look for an ``ENSUREPIP_OPTIONS`` environment
+    # variable which will control which version scripts get installed.
+    #
+    # ENSUREPIP_OPTIONS=altinstall
+    #   - Only pipX.Y and easy_install-X.Y will be generated and installed
+    # ENSUREPIP_OPTIONS=install
+    #   - pipX.Y, pipX, easy_install-X.Y will be generated and installed. Note
+    #     that this option is technically if ENSUREPIP_OPTIONS is set and is
+    #     not altinstall
+    # DEFAULT
+    #   - The default behavior is to install pip, pipX, pipX.Y, easy_install
+    #     and easy_install-X.Y.
+    pip_script = console.pop('pip', None)
+    if pip_script:
+        if "ENSUREPIP_OPTIONS" not in os.environ:
+            scripts_to_generate.append('pip = ' + pip_script)
+
+        if os.environ.get("ENSUREPIP_OPTIONS", "") != "altinstall":
+            scripts_to_generate.append(
+                'pip{} = {}'.format(sys.version_info[0], pip_script)
+            )
+
+        scripts_to_generate.append(
+            'pip{} = {}'.format(get_major_minor_version(), pip_script)
+        )
+        # Delete any other versioned pip entry points
+        pip_ep = [k for k in console if re.match(r'pip(\d(\.\d)?)?$', k)]
+        for k in pip_ep:
+            del console[k]
+    easy_install_script = console.pop('easy_install', None)
+    if easy_install_script:
+        if "ENSUREPIP_OPTIONS" not in os.environ:
+            scripts_to_generate.append(
+                'easy_install = ' + easy_install_script
+            )
+
+        scripts_to_generate.append(
+            'easy_install-{} = {}'.format(
+                get_major_minor_version(), easy_install_script
+            )
+        )
+        # Delete any other versioned easy_install entry points
+        easy_install_ep = [
+            k for k in console if re.match(r'easy_install(-\d\.\d)?$', k)
+        ]
+        for k in easy_install_ep:
+            del console[k]
+
+    # Generate the console entry points specified in the wheel
+    scripts_to_generate.extend(starmap('{} = {}'.format, console.items()))
+
+    return scripts_to_generate
+
+
+class ZipBackedFile(object):
+    def __init__(self, src_record_path, dest_path, zip_file):
+        # type: (RecordPath, text_type, ZipFile) -> None
+        self.src_record_path = src_record_path
+        self.dest_path = dest_path
+        self._zip_file = zip_file
+        self.changed = False
+
+    def _getinfo(self):
+        # type: () -> ZipInfo
+        if not PY2:
+            return self._zip_file.getinfo(self.src_record_path)
+        # Python 2 does not expose a way to detect a ZIP's encoding, but the
+        # wheel specification (PEP 427) explicitly mandates that paths should
+        # use UTF-8, so we assume it is true.
+        return self._zip_file.getinfo(self.src_record_path.encode("utf-8"))
+
+    def save(self):
+        # type: () -> None
+        # directory creation is lazy and after file filtering
+        # to ensure we don't install empty dirs; empty dirs can't be
+        # uninstalled.
+        parent_dir = os.path.dirname(self.dest_path)
+        ensure_dir(parent_dir)
+
+        # When we open the output file below, any existing file is truncated
+        # before we start writing the new contents. This is fine in most
+        # cases, but can cause a segfault if pip has loaded a shared
+        # object (e.g. from pyopenssl through its vendored urllib3)
+        # Since the shared object is mmap'd an attempt to call a
+        # symbol in it will then cause a segfault. Unlinking the file
+        # allows writing of new contents while allowing the process to
+        # continue to use the old copy.
+        if os.path.exists(self.dest_path):
+            os.unlink(self.dest_path)
+
+        zipinfo = self._getinfo()
+
+        with self._zip_file.open(zipinfo) as f:
+            with open(self.dest_path, "wb") as dest:
+                shutil.copyfileobj(f, dest)
+
+        if zip_item_is_executable(zipinfo):
+            set_extracted_file_to_default_mode_plus_executable(self.dest_path)
+
+
+class ScriptFile(object):
+    def __init__(self, file):
+        # type: (File) -> None
+        self._file = file
+        self.src_record_path = self._file.src_record_path
+        self.dest_path = self._file.dest_path
+        self.changed = False
+
+    def save(self):
+        # type: () -> None
+        self._file.save()
+        self.changed = fix_script(self.dest_path)
+
+
+class MissingCallableSuffix(InstallationError):
+    def __init__(self, entry_point):
+        # type: (str) -> None
+        super(MissingCallableSuffix, self).__init__(
+            "Invalid script entry point: {} - A callable "
+            "suffix is required. Cf https://packaging.python.org/"
+            "specifications/entry-points/#use-for-scripts for more "
+            "information.".format(entry_point)
+        )
+
+
+def _raise_for_invalid_entrypoint(specification):
+    # type: (str) -> None
+    entry = get_export_entry(specification)
+    if entry is not None and entry.suffix is None:
+        raise MissingCallableSuffix(str(entry))
+
+
+class PipScriptMaker(ScriptMaker):
+    def make(self, specification, options=None):
+        # type: (str, Dict[str, Any]) -> List[str]
+        _raise_for_invalid_entrypoint(specification)
+        return super(PipScriptMaker, self).make(specification, options)
+
+
+def _install_wheel(
+    name,  # type: str
+    wheel_zip,  # type: ZipFile
+    wheel_path,  # type: str
+    scheme,  # type: Scheme
+    pycompile=True,  # type: bool
+    warn_script_location=True,  # type: bool
+    direct_url=None,  # type: Optional[DirectUrl]
+    requested=False,  # type: bool
+):
+    # type: (...) -> None
+    """Install a wheel.
+
+    :param name: Name of the project to install
+    :param wheel_zip: open ZipFile for wheel being installed
+    :param scheme: Distutils scheme dictating the install directories
+    :param req_description: String used in place of the requirement, for
+        logging
+    :param pycompile: Whether to byte-compile installed Python files
+    :param warn_script_location: Whether to check that scripts are installed
+        into a directory on PATH
+    :raises UnsupportedWheel:
+        * when the directory holds an unpacked wheel with incompatible
+          Wheel-Version
+        * when the .dist-info dir does not match the wheel
+    """
+    info_dir, metadata = parse_wheel(wheel_zip, name)
+
+    if wheel_root_is_purelib(metadata):
+        lib_dir = scheme.purelib
+    else:
+        lib_dir = scheme.platlib
+
+    # Record details of the files moved
+    #   installed = files copied from the wheel to the destination
+    #   changed = files changed while installing (scripts #! line typically)
+    #   generated = files newly generated during the install (script wrappers)
+    installed = {}  # type: Dict[RecordPath, RecordPath]
+    changed = set()  # type: Set[RecordPath]
+    generated = []  # type: List[str]
+
+    def record_installed(srcfile, destfile, modified=False):
+        # type: (RecordPath, text_type, bool) -> None
+        """Map archive RECORD paths to installation RECORD paths."""
+        newpath = _fs_to_record_path(destfile, lib_dir)
+        installed[srcfile] = newpath
+        if modified:
+            changed.add(_fs_to_record_path(destfile))
+
+    def all_paths():
+        # type: () -> Iterable[RecordPath]
+        names = wheel_zip.namelist()
+        # If a flag is set, names may be unicode in Python 2. We convert to
+        # text explicitly so these are valid for lookup in RECORD.
+        decoded_names = map(ensure_text, names)
+        for name in decoded_names:
+            yield cast("RecordPath", name)
+
+    def is_dir_path(path):
+        # type: (RecordPath) -> bool
+        return path.endswith("/")
+
+    def assert_no_path_traversal(dest_dir_path, target_path):
+        # type: (text_type, text_type) -> None
+        if not is_within_directory(dest_dir_path, target_path):
+            message = (
+                "The wheel {!r} has a file {!r} trying to install"
+                " outside the target directory {!r}"
+            )
+            raise InstallationError(
+                message.format(wheel_path, target_path, dest_dir_path)
+            )
+
+    def root_scheme_file_maker(zip_file, dest):
+        # type: (ZipFile, text_type) -> Callable[[RecordPath], File]
+        def make_root_scheme_file(record_path):
+            # type: (RecordPath) -> File
+            normed_path = os.path.normpath(record_path)
+            dest_path = os.path.join(dest, normed_path)
+            assert_no_path_traversal(dest, dest_path)
+            return ZipBackedFile(record_path, dest_path, zip_file)
+
+        return make_root_scheme_file
+
+    def data_scheme_file_maker(zip_file, scheme):
+        # type: (ZipFile, Scheme) -> Callable[[RecordPath], File]
+        scheme_paths = {}
+        for key in SCHEME_KEYS:
+            encoded_key = ensure_text(key)
+            scheme_paths[encoded_key] = ensure_text(
+                getattr(scheme, key), encoding=sys.getfilesystemencoding()
+            )
+
+        def make_data_scheme_file(record_path):
+            # type: (RecordPath) -> File
+            normed_path = os.path.normpath(record_path)
+            try:
+                _, scheme_key, dest_subpath = normed_path.split(os.path.sep, 2)
+            except ValueError:
+                message = (
+                    "Unexpected file in {}: {!r}. .data directory contents"
+                    " should be named like: '<scheme key>/<path>'."
+                ).format(wheel_path, record_path)
+                raise InstallationError(message)
+
+            try:
+                scheme_path = scheme_paths[scheme_key]
+            except KeyError:
+                valid_scheme_keys = ", ".join(sorted(scheme_paths))
+                message = (
+                    "Unknown scheme key used in {}: {} (for file {!r}). .data"
+                    " directory contents should be in subdirectories named"
+                    " with a valid scheme key ({})"
+                ).format(
+                    wheel_path, scheme_key, record_path, valid_scheme_keys
+                )
+                raise InstallationError(message)
+
+            dest_path = os.path.join(scheme_path, dest_subpath)
+            assert_no_path_traversal(scheme_path, dest_path)
+            return ZipBackedFile(record_path, dest_path, zip_file)
+
+        return make_data_scheme_file
+
+    def is_data_scheme_path(path):
+        # type: (RecordPath) -> bool
+        return path.split("/", 1)[0].endswith(".data")
+
+    paths = all_paths()
+    file_paths = filterfalse(is_dir_path, paths)
+    root_scheme_paths, data_scheme_paths = partition(
+        is_data_scheme_path, file_paths
+    )
+
+    make_root_scheme_file = root_scheme_file_maker(
+        wheel_zip,
+        ensure_text(lib_dir, encoding=sys.getfilesystemencoding()),
+    )
+    files = map(make_root_scheme_file, root_scheme_paths)
+
+    def is_script_scheme_path(path):
+        # type: (RecordPath) -> bool
+        parts = path.split("/", 2)
+        return (
+            len(parts) > 2 and
+            parts[0].endswith(".data") and
+            parts[1] == "scripts"
+        )
+
+    other_scheme_paths, script_scheme_paths = partition(
+        is_script_scheme_path, data_scheme_paths
+    )
+
+    make_data_scheme_file = data_scheme_file_maker(wheel_zip, scheme)
+    other_scheme_files = map(make_data_scheme_file, other_scheme_paths)
+    files = chain(files, other_scheme_files)
+
+    # Get the defined entry points
+    distribution = pkg_resources_distribution_for_wheel(
+        wheel_zip, name, wheel_path
+    )
+    console, gui = get_entrypoints(distribution)
+
+    def is_entrypoint_wrapper(file):
+        # type: (File) -> bool
+        # EP, EP.exe and EP-script.py are scripts generated for
+        # entry point EP by setuptools
+        path = file.dest_path
+        name = os.path.basename(path)
+        if name.lower().endswith('.exe'):
+            matchname = name[:-4]
+        elif name.lower().endswith('-script.py'):
+            matchname = name[:-10]
+        elif name.lower().endswith(".pya"):
+            matchname = name[:-4]
+        else:
+            matchname = name
+        # Ignore setuptools-generated scripts
+        return (matchname in console or matchname in gui)
+
+    script_scheme_files = map(make_data_scheme_file, script_scheme_paths)
+    script_scheme_files = filterfalse(
+        is_entrypoint_wrapper, script_scheme_files
+    )
+    script_scheme_files = map(ScriptFile, script_scheme_files)
+    files = chain(files, script_scheme_files)
+
+    for file in files:
+        file.save()
+        record_installed(file.src_record_path, file.dest_path, file.changed)
+
+    def pyc_source_file_paths():
+        # type: () -> Iterator[text_type]
+        # We de-duplicate installation paths, since there can be overlap (e.g.
+        # file in .data maps to same location as file in wheel root).
+        # Sorting installation paths makes it easier to reproduce and debug
+        # issues related to permissions on existing files.
+        for installed_path in sorted(set(installed.values())):
+            full_installed_path = os.path.join(lib_dir, installed_path)
+            if not os.path.isfile(full_installed_path):
+                continue
+            if not full_installed_path.endswith('.py'):
+                continue
+            yield full_installed_path
+
+    def pyc_output_path(path):
+        # type: (text_type) -> text_type
+        """Return the path the pyc file would have been written to.
+        """
+        if PY2:
+            if sys.flags.optimize:
+                return path + 'o'
+            else:
+                return path + 'c'
+        else:
+            return importlib.util.cache_from_source(path)
+
+    # Compile all of the pyc files for the installed files
+    if pycompile:
+        with captured_stdout() as stdout:
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore')
+                for path in pyc_source_file_paths():
+                    # Python 2's `compileall.compile_file` requires a str in
+                    # error cases, so we must convert to the native type.
+                    path_arg = ensure_str(
+                        path, encoding=sys.getfilesystemencoding()
+                    )
+                    success = compileall.compile_file(
+                        path_arg, force=True, quiet=True
+                    )
+                    if success:
+                        pyc_path = pyc_output_path(path)
+                        assert os.path.exists(pyc_path)
+                        pyc_record_path = cast(
+                            "RecordPath", pyc_path.replace(os.path.sep, "/")
+                        )
+                        record_installed(pyc_record_path, pyc_path)
+        logger.debug(stdout.getvalue())
+
+    maker = PipScriptMaker(None, scheme.scripts)
+
+    # Ensure old scripts are overwritten.
+    # See https://github.com/pypa/pip/issues/1800
+    maker.clobber = True
+
+    # Ensure we don't generate any variants for scripts because this is almost
+    # never what somebody wants.
+    # See https://bitbucket.org/pypa/distlib/issue/35/
+    maker.variants = {''}
+
+    # This is required because otherwise distlib creates scripts that are not
+    # executable.
+    # See https://bitbucket.org/pypa/distlib/issue/32/
+    maker.set_mode = True
+
+    # Generate the console and GUI entry points specified in the wheel
+    scripts_to_generate = get_console_script_specs(console)
+
+    gui_scripts_to_generate = list(starmap('{} = {}'.format, gui.items()))
+
+    generated_console_scripts = maker.make_multiple(scripts_to_generate)
+    generated.extend(generated_console_scripts)
+
+    generated.extend(
+        maker.make_multiple(gui_scripts_to_generate, {'gui': True})
+    )
+
+    if warn_script_location:
+        msg = message_about_scripts_not_on_PATH(generated_console_scripts)
+        if msg is not None:
+            logger.warning(msg)
+
+    generated_file_mode = 0o666 & ~current_umask()
+
+    @contextlib.contextmanager
+    def _generate_file(path, **kwargs):
+        # type: (str, **Any) -> Iterator[NamedTemporaryFileResult]
+        with adjacent_tmp_file(path, **kwargs) as f:
+            yield f
+        os.chmod(f.name, generated_file_mode)
+        replace(f.name, path)
+
+    dest_info_dir = os.path.join(lib_dir, info_dir)
+
+    # Record pip as the installer
+    installer_path = os.path.join(dest_info_dir, 'INSTALLER')
+    with _generate_file(installer_path) as installer_file:
+        installer_file.write(b'pip\n')
+    generated.append(installer_path)
+
+    # Record the PEP 610 direct URL reference
+    if direct_url is not None:
+        direct_url_path = os.path.join(dest_info_dir, DIRECT_URL_METADATA_NAME)
+        with _generate_file(direct_url_path) as direct_url_file:
+            direct_url_file.write(direct_url.to_json().encode("utf-8"))
+        generated.append(direct_url_path)
+
+    # Record the REQUESTED file
+    if requested:
+        requested_path = os.path.join(dest_info_dir, 'REQUESTED')
+        with open(requested_path, "w"):
+            pass
+        generated.append(requested_path)
+
+    record_text = distribution.get_metadata('RECORD')
+    record_rows = list(csv.reader(record_text.splitlines()))
+
+    rows = get_csv_rows_for_installed(
+        record_rows,
+        installed=installed,
+        changed=changed,
+        generated=generated,
+        lib_dir=lib_dir)
+
+    # Record details of all files installed
+    record_path = os.path.join(dest_info_dir, 'RECORD')
+
+    with _generate_file(record_path, **csv_io_kwargs('w')) as record_file:
+        # The type mypy infers for record_file is different for Python 3
+        # (typing.IO[Any]) and Python 2 (typing.BinaryIO). We explicitly
+        # cast to typing.IO[str] as a workaround.
+        writer = csv.writer(cast('IO[str]', record_file))
+        writer.writerows(_normalized_outrows(rows))
+
+
+@contextlib.contextmanager
+def req_error_context(req_description):
+    # type: (str) -> Iterator[None]
+    try:
+        yield
+    except InstallationError as e:
+        message = "For req: {}. {}".format(req_description, e.args[0])
+        reraise(
+            InstallationError, InstallationError(message), sys.exc_info()[2]
+        )
+
+
+def install_wheel(
+    name,  # type: str
+    wheel_path,  # type: str
+    scheme,  # type: Scheme
+    req_description,  # type: str
+    pycompile=True,  # type: bool
+    warn_script_location=True,  # type: bool
+    direct_url=None,  # type: Optional[DirectUrl]
+    requested=False,  # type: bool
+):
+    # type: (...) -> None
+    with ZipFile(wheel_path, allowZip64=True) as z:
+        with req_error_context(req_description):
+            _install_wheel(
+                name=name,
+                wheel_zip=z,
+                wheel_path=wheel_path,
+                scheme=scheme,
+                pycompile=pycompile,
+                warn_script_location=warn_script_location,
+                direct_url=direct_url,
+                requested=requested,
+            )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/operations/prepare.py b/myenv/lib/python3.9/site-packages/pip/_internal/operations/prepare.py
new file mode 100644
index 0000000..a5455fc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/operations/prepare.py
@@ -0,0 +1,562 @@
+"""Prepares a distribution for installation
+"""
+
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
+
+import logging
+import mimetypes
+import os
+import shutil
+
+from pip._vendor.six import PY2
+
+from pip._internal.distributions import (
+    make_distribution_for_install_requirement,
+)
+from pip._internal.distributions.installed import InstalledDistribution
+from pip._internal.exceptions import (
+    DirectoryUrlHashUnsupported,
+    HashMismatch,
+    HashUnpinned,
+    InstallationError,
+    NetworkConnectionError,
+    PreviousBuildDirError,
+    VcsHashUnsupported,
+)
+from pip._internal.utils.filesystem import copy2_fixed
+from pip._internal.utils.hashes import MissingHashes
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import (
+    display_path,
+    hide_url,
+    path_to_display,
+    rmtree,
+)
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.unpacking import unpack_file
+from pip._internal.vcs import vcs
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Callable, List, Optional, Tuple,
+    )
+
+    from mypy_extensions import TypedDict
+
+    from pip._internal.distributions import AbstractDistribution
+    from pip._internal.index.package_finder import PackageFinder
+    from pip._internal.models.link import Link
+    from pip._internal.network.download import Downloader
+    from pip._internal.req.req_install import InstallRequirement
+    from pip._internal.req.req_tracker import RequirementTracker
+    from pip._internal.utils.hashes import Hashes
+
+    if PY2:
+        CopytreeKwargs = TypedDict(
+            'CopytreeKwargs',
+            {
+                'ignore': Callable[[str, List[str]], List[str]],
+                'symlinks': bool,
+            },
+            total=False,
+        )
+    else:
+        CopytreeKwargs = TypedDict(
+            'CopytreeKwargs',
+            {
+                'copy_function': Callable[[str, str], None],
+                'ignore': Callable[[str, List[str]], List[str]],
+                'ignore_dangling_symlinks': bool,
+                'symlinks': bool,
+            },
+            total=False,
+        )
+
+logger = logging.getLogger(__name__)
+
+
+def _get_prepared_distribution(
+        req,  # type: InstallRequirement
+        req_tracker,  # type: RequirementTracker
+        finder,  # type: PackageFinder
+        build_isolation  # type: bool
+):
+    # type: (...) -> AbstractDistribution
+    """Prepare a distribution for installation.
+    """
+    abstract_dist = make_distribution_for_install_requirement(req)
+    with req_tracker.track(req):
+        abstract_dist.prepare_distribution_metadata(finder, build_isolation)
+    return abstract_dist
+
+
+def unpack_vcs_link(link, location):
+    # type: (Link, str) -> None
+    vcs_backend = vcs.get_backend_for_scheme(link.scheme)
+    assert vcs_backend is not None
+    vcs_backend.unpack(location, url=hide_url(link.url))
+
+
+class File(object):
+    def __init__(self, path, content_type):
+        # type: (str, str) -> None
+        self.path = path
+        self.content_type = content_type
+
+
+def get_http_url(
+    link,  # type: Link
+    downloader,  # type: Downloader
+    download_dir=None,  # type: Optional[str]
+    hashes=None,  # type: Optional[Hashes]
+):
+    # type: (...) -> File
+    temp_dir = TempDirectory(kind="unpack", globally_managed=True)
+    # If a download dir is specified, is the file already downloaded there?
+    already_downloaded_path = None
+    if download_dir:
+        already_downloaded_path = _check_download_dir(
+            link, download_dir, hashes
+        )
+
+    if already_downloaded_path:
+        from_path = already_downloaded_path
+        content_type = mimetypes.guess_type(from_path)[0]
+    else:
+        # let's download to a tmp dir
+        from_path, content_type = _download_http_url(
+            link, downloader, temp_dir.path, hashes
+        )
+
+    return File(from_path, content_type)
+
+
+def _copy2_ignoring_special_files(src, dest):
+    # type: (str, str) -> None
+    """Copying special files is not supported, but as a convenience to users
+    we skip errors copying them. This supports tools that may create e.g.
+    socket files in the project source directory.
+    """
+    try:
+        copy2_fixed(src, dest)
+    except shutil.SpecialFileError as e:
+        # SpecialFileError may be raised due to either the source or
+        # destination. If the destination was the cause then we would actually
+        # care, but since the destination directory is deleted prior to
+        # copy we ignore all of them assuming it is caused by the source.
+        logger.warning(
+            "Ignoring special file error '%s' encountered copying %s to %s.",
+            str(e),
+            path_to_display(src),
+            path_to_display(dest),
+        )
+
+
+def _copy_source_tree(source, target):
+    # type: (str, str) -> None
+    target_abspath = os.path.abspath(target)
+    target_basename = os.path.basename(target_abspath)
+    target_dirname = os.path.dirname(target_abspath)
+
+    def ignore(d, names):
+        # type: (str, List[str]) -> List[str]
+        skipped = []  # type: List[str]
+        if d == source:
+            # Pulling in those directories can potentially be very slow,
+            # exclude the following directories if they appear in the top
+            # level dir (and only it).
+            # See discussion at https://github.com/pypa/pip/pull/6770
+            skipped += ['.tox', '.nox']
+        if os.path.abspath(d) == target_dirname:
+            # Prevent an infinite recursion if the target is in source.
+            # This can happen when TMPDIR is set to ${PWD}/...
+            # and we copy PWD to TMPDIR.
+            skipped += [target_basename]
+        return skipped
+
+    kwargs = dict(ignore=ignore, symlinks=True)  # type: CopytreeKwargs
+
+    if not PY2:
+        # Python 2 does not support copy_function, so we only ignore
+        # errors on special file copy in Python 3.
+        kwargs['copy_function'] = _copy2_ignoring_special_files
+
+    shutil.copytree(source, target, **kwargs)
+
+
+def get_file_url(
+    link,  # type: Link
+    download_dir=None,  # type: Optional[str]
+    hashes=None  # type: Optional[Hashes]
+):
+    # type: (...) -> File
+    """Get file and optionally check its hash.
+    """
+    # If a download dir is specified, is the file already there and valid?
+    already_downloaded_path = None
+    if download_dir:
+        already_downloaded_path = _check_download_dir(
+            link, download_dir, hashes
+        )
+
+    if already_downloaded_path:
+        from_path = already_downloaded_path
+    else:
+        from_path = link.file_path
+
+    # If --require-hashes is off, `hashes` is either empty, the
+    # link's embedded hash, or MissingHashes; it is required to
+    # match. If --require-hashes is on, we are satisfied by any
+    # hash in `hashes` matching: a URL-based or an option-based
+    # one; no internet-sourced hash will be in `hashes`.
+    if hashes:
+        hashes.check_against_path(from_path)
+
+    content_type = mimetypes.guess_type(from_path)[0]
+
+    return File(from_path, content_type)
+
+
+def unpack_url(
+    link,  # type: Link
+    location,  # type: str
+    downloader,  # type: Downloader
+    download_dir=None,  # type: Optional[str]
+    hashes=None,  # type: Optional[Hashes]
+):
+    # type: (...) -> Optional[File]
+    """Unpack link into location, downloading if required.
+
+    :param hashes: A Hashes object, one of whose embedded hashes must match,
+        or HashMismatch will be raised. If the Hashes is empty, no matches are
+        required, and unhashable types of requirements (like VCS ones, which
+        would ordinarily raise HashUnsupported) are allowed.
+    """
+    # non-editable vcs urls
+    if link.is_vcs:
+        unpack_vcs_link(link, location)
+        return None
+
+    # If it's a url to a local directory
+    if link.is_existing_dir():
+        if os.path.isdir(location):
+            rmtree(location)
+        _copy_source_tree(link.file_path, location)
+        return None
+
+    # file urls
+    if link.is_file:
+        file = get_file_url(link, download_dir, hashes=hashes)
+
+    # http urls
+    else:
+        file = get_http_url(
+            link,
+            downloader,
+            download_dir,
+            hashes=hashes,
+        )
+
+    # unpack the archive to the build dir location. even when only downloading
+    # archives, they have to be unpacked to parse dependencies, except wheels
+    if not link.is_wheel:
+        unpack_file(file.path, location, file.content_type)
+
+    return file
+
+
+def _download_http_url(
+    link,  # type: Link
+    downloader,  # type: Downloader
+    temp_dir,  # type: str
+    hashes,  # type: Optional[Hashes]
+):
+    # type: (...) -> Tuple[str, str]
+    """Download link url into temp_dir using provided session"""
+    download = downloader(link)
+
+    file_path = os.path.join(temp_dir, download.filename)
+    with open(file_path, 'wb') as content_file:
+        for chunk in download.chunks:
+            content_file.write(chunk)
+
+    if hashes:
+        hashes.check_against_path(file_path)
+
+    return file_path, download.response.headers.get('content-type', '')
+
+
+def _check_download_dir(link, download_dir, hashes):
+    # type: (Link, str, Optional[Hashes]) -> Optional[str]
+    """ Check download_dir for previously downloaded file with correct hash
+        If a correct file is found return its path else None
+    """
+    download_path = os.path.join(download_dir, link.filename)
+
+    if not os.path.exists(download_path):
+        return None
+
+    # If already downloaded, does its hash match?
+    logger.info('File was already downloaded %s', download_path)
+    if hashes:
+        try:
+            hashes.check_against_path(download_path)
+        except HashMismatch:
+            logger.warning(
+                'Previously-downloaded file %s has bad hash. '
+                'Re-downloading.',
+                download_path
+            )
+            os.unlink(download_path)
+            return None
+    return download_path
+
+
+class RequirementPreparer(object):
+    """Prepares a Requirement
+    """
+
+    def __init__(
+        self,
+        build_dir,  # type: str
+        download_dir,  # type: Optional[str]
+        src_dir,  # type: str
+        wheel_download_dir,  # type: Optional[str]
+        build_isolation,  # type: bool
+        req_tracker,  # type: RequirementTracker
+        downloader,  # type: Downloader
+        finder,  # type: PackageFinder
+        require_hashes,  # type: bool
+        use_user_site,  # type: bool
+    ):
+        # type: (...) -> None
+        super(RequirementPreparer, self).__init__()
+
+        self.src_dir = src_dir
+        self.build_dir = build_dir
+        self.req_tracker = req_tracker
+        self.downloader = downloader
+        self.finder = finder
+
+        # Where still-packed archives should be written to. If None, they are
+        # not saved, and are deleted immediately after unpacking.
+        self.download_dir = download_dir
+
+        # Where still-packed .whl files should be written to. If None, they are
+        # written to the download_dir parameter. Separate to download_dir to
+        # permit only keeping wheel archives for pip wheel.
+        self.wheel_download_dir = wheel_download_dir
+
+        # NOTE
+        # download_dir and wheel_download_dir overlap semantically and may
+        # be combined if we're willing to have non-wheel archives present in
+        # the wheelhouse output by 'pip wheel'.
+
+        # Is build isolation allowed?
+        self.build_isolation = build_isolation
+
+        # Should hash-checking be required?
+        self.require_hashes = require_hashes
+
+        # Should install in user site-packages?
+        self.use_user_site = use_user_site
+
+    @property
+    def _download_should_save(self):
+        # type: () -> bool
+        if not self.download_dir:
+            return False
+
+        if os.path.exists(self.download_dir):
+            return True
+
+        logger.critical('Could not find download directory')
+        raise InstallationError(
+            "Could not find or access download directory '{}'"
+            .format(self.download_dir))
+
+    def _log_preparing_link(self, req):
+        # type: (InstallRequirement) -> None
+        """Log the way the link prepared."""
+        if req.link.is_file:
+            path = req.link.file_path
+            logger.info('Processing %s', display_path(path))
+        else:
+            logger.info('Collecting %s', req.req or req)
+
+    def _ensure_link_req_src_dir(self, req, download_dir, parallel_builds):
+        # type: (InstallRequirement, Optional[str], bool) -> None
+        """Ensure source_dir of a linked InstallRequirement."""
+        # Since source_dir is only set for editable requirements.
+        if req.link.is_wheel:
+            # We don't need to unpack wheels, so no need for a source
+            # directory.
+            return
+        assert req.source_dir is None
+        # We always delete unpacked sdists after pip runs.
+        req.ensure_has_source_dir(
+            self.build_dir,
+            autodelete=True,
+            parallel_builds=parallel_builds,
+        )
+
+        # If a checkout exists, it's unwise to keep going.  version
+        # inconsistencies are logged later, but do not fail the
+        # installation.
+        # FIXME: this won't upgrade when there's an existing
+        # package unpacked in `req.source_dir`
+        if os.path.exists(os.path.join(req.source_dir, 'setup.py')):
+            raise PreviousBuildDirError(
+                "pip can't proceed with requirements '{}' due to a"
+                "pre-existing build directory ({}). This is likely "
+                "due to a previous installation that failed . pip is "
+                "being responsible and not assuming it can delete this. "
+                "Please delete it and try again.".format(req, req.source_dir)
+            )
+
+    def _get_linked_req_hashes(self, req):
+        # type: (InstallRequirement) -> Hashes
+        # By the time this is called, the requirement's link should have
+        # been checked so we can tell what kind of requirements req is
+        # and raise some more informative errors than otherwise.
+        # (For example, we can raise VcsHashUnsupported for a VCS URL
+        # rather than HashMissing.)
+        if not self.require_hashes:
+            return req.hashes(trust_internet=True)
+
+        # We could check these first 2 conditions inside unpack_url
+        # and save repetition of conditions, but then we would
+        # report less-useful error messages for unhashable
+        # requirements, complaining that there's no hash provided.
+        if req.link.is_vcs:
+            raise VcsHashUnsupported()
+        if req.link.is_existing_dir():
+            raise DirectoryUrlHashUnsupported()
+
+        # Unpinned packages are asking for trouble when a new version
+        # is uploaded.  This isn't a security check, but it saves users
+        # a surprising hash mismatch in the future.
+        # file:/// URLs aren't pinnable, so don't complain about them
+        # not being pinned.
+        if req.original_link is None and not req.is_pinned:
+            raise HashUnpinned()
+
+        # If known-good hashes are missing for this requirement,
+        # shim it with a facade object that will provoke hash
+        # computation and then raise a HashMissing exception
+        # showing the user what the hash should be.
+        return req.hashes(trust_internet=False) or MissingHashes()
+
+    def prepare_linked_requirement(self, req, parallel_builds=False):
+        # type: (InstallRequirement, bool) -> AbstractDistribution
+        """Prepare a requirement to be obtained from req.link."""
+        assert req.link
+        link = req.link
+        self._log_preparing_link(req)
+        if link.is_wheel and self.wheel_download_dir:
+            # Download wheels to a dedicated dir when doing `pip wheel`.
+            download_dir = self.wheel_download_dir
+        else:
+            download_dir = self.download_dir
+
+        with indent_log():
+            self._ensure_link_req_src_dir(req, download_dir, parallel_builds)
+            try:
+                local_file = unpack_url(
+                    link, req.source_dir, self.downloader, download_dir,
+                    hashes=self._get_linked_req_hashes(req)
+                )
+            except NetworkConnectionError as exc:
+                raise InstallationError(
+                    'Could not install requirement {} because of HTTP '
+                    'error {} for URL {}'.format(req, exc, link)
+                )
+
+            # For use in later processing, preserve the file path on the
+            # requirement.
+            if local_file:
+                req.local_file_path = local_file.path
+
+            abstract_dist = _get_prepared_distribution(
+                req, self.req_tracker, self.finder, self.build_isolation,
+            )
+
+            if download_dir:
+                if link.is_existing_dir():
+                    logger.info('Link is a directory, ignoring download_dir')
+                elif local_file:
+                    download_location = os.path.join(
+                        download_dir, link.filename
+                    )
+                    if not os.path.exists(download_location):
+                        shutil.copy(local_file.path, download_location)
+                        download_path = display_path(download_location)
+                        logger.info('Saved %s', download_path)
+
+            if self._download_should_save:
+                # Make a .zip of the source_dir we already created.
+                if link.is_vcs:
+                    req.archive(self.download_dir)
+        return abstract_dist
+
+    def prepare_editable_requirement(
+        self,
+        req,  # type: InstallRequirement
+    ):
+        # type: (...) -> AbstractDistribution
+        """Prepare an editable requirement
+        """
+        assert req.editable, "cannot prepare a non-editable req as editable"
+
+        logger.info('Obtaining %s', req)
+
+        with indent_log():
+            if self.require_hashes:
+                raise InstallationError(
+                    'The editable requirement {} cannot be installed when '
+                    'requiring hashes, because there is no single file to '
+                    'hash.'.format(req)
+                )
+            req.ensure_has_source_dir(self.src_dir)
+            req.update_editable(not self._download_should_save)
+
+            abstract_dist = _get_prepared_distribution(
+                req, self.req_tracker, self.finder, self.build_isolation,
+            )
+
+            if self._download_should_save:
+                req.archive(self.download_dir)
+            req.check_if_exists(self.use_user_site)
+
+        return abstract_dist
+
+    def prepare_installed_requirement(
+        self,
+        req,  # type: InstallRequirement
+        skip_reason  # type: str
+    ):
+        # type: (...) -> AbstractDistribution
+        """Prepare an already-installed requirement
+        """
+        assert req.satisfied_by, "req should have been satisfied but isn't"
+        assert skip_reason is not None, (
+            "did not get skip reason skipped but req.satisfied_by "
+            "is set to {}".format(req.satisfied_by)
+        )
+        logger.info(
+            'Requirement %s: %s (%s)',
+            skip_reason, req, req.satisfied_by.version
+        )
+        with indent_log():
+            if self.require_hashes:
+                logger.debug(
+                    'Since it is already installed, we are trusting this '
+                    'package without checking its hash. To ensure a '
+                    'completely repeatable environment, install into an '
+                    'empty virtualenv.'
+                )
+            abstract_dist = InstalledDistribution(req)
+
+        return abstract_dist
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/pyproject.py b/myenv/lib/python3.9/site-packages/pip/_internal/pyproject.py
new file mode 100644
index 0000000..6b4faf7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/pyproject.py
@@ -0,0 +1,196 @@
+from __future__ import absolute_import
+
+import io
+import os
+import sys
+from collections import namedtuple
+
+from pip._vendor import six, toml
+from pip._vendor.packaging.requirements import InvalidRequirement, Requirement
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any, Optional, List
+
+
+def _is_list_of_str(obj):
+    # type: (Any) -> bool
+    return (
+        isinstance(obj, list) and
+        all(isinstance(item, six.string_types) for item in obj)
+    )
+
+
+def make_pyproject_path(unpacked_source_directory):
+    # type: (str) -> str
+    path = os.path.join(unpacked_source_directory, 'pyproject.toml')
+
+    # Python2 __file__ should not be unicode
+    if six.PY2 and isinstance(path, six.text_type):
+        path = path.encode(sys.getfilesystemencoding())
+
+    return path
+
+
+BuildSystemDetails = namedtuple('BuildSystemDetails', [
+    'requires', 'backend', 'check', 'backend_path'
+])
+
+
+def load_pyproject_toml(
+    use_pep517,  # type: Optional[bool]
+    pyproject_toml,  # type: str
+    setup_py,  # type: str
+    req_name  # type: str
+):
+    # type: (...) -> Optional[BuildSystemDetails]
+    """Load the pyproject.toml file.
+
+    Parameters:
+        use_pep517 - Has the user requested PEP 517 processing? None
+                     means the user hasn't explicitly specified.
+        pyproject_toml - Location of the project's pyproject.toml file
+        setup_py - Location of the project's setup.py file
+        req_name - The name of the requirement we're processing (for
+                   error reporting)
+
+    Returns:
+        None if we should use the legacy code path, otherwise a tuple
+        (
+            requirements from pyproject.toml,
+            name of PEP 517 backend,
+            requirements we should check are installed after setting
+                up the build environment
+            directory paths to import the backend from (backend-path),
+                relative to the project root.
+        )
+    """
+    has_pyproject = os.path.isfile(pyproject_toml)
+    has_setup = os.path.isfile(setup_py)
+
+    if has_pyproject:
+        with io.open(pyproject_toml, encoding="utf-8") as f:
+            pp_toml = toml.load(f)
+        build_system = pp_toml.get("build-system")
+    else:
+        build_system = None
+
+    # The following cases must use PEP 517
+    # We check for use_pep517 being non-None and falsey because that means
+    # the user explicitly requested --no-use-pep517.  The value 0 as
+    # opposed to False can occur when the value is provided via an
+    # environment variable or config file option (due to the quirk of
+    # strtobool() returning an integer in pip's configuration code).
+    if has_pyproject and not has_setup:
+        if use_pep517 is not None and not use_pep517:
+            raise InstallationError(
+                "Disabling PEP 517 processing is invalid: "
+                "project does not have a setup.py"
+            )
+        use_pep517 = True
+    elif build_system and "build-backend" in build_system:
+        if use_pep517 is not None and not use_pep517:
+            raise InstallationError(
+                "Disabling PEP 517 processing is invalid: "
+                "project specifies a build backend of {} "
+                "in pyproject.toml".format(
+                    build_system["build-backend"]
+                )
+            )
+        use_pep517 = True
+
+    # If we haven't worked out whether to use PEP 517 yet,
+    # and the user hasn't explicitly stated a preference,
+    # we do so if the project has a pyproject.toml file.
+    elif use_pep517 is None:
+        use_pep517 = has_pyproject
+
+    # At this point, we know whether we're going to use PEP 517.
+    assert use_pep517 is not None
+
+    # If we're using the legacy code path, there is nothing further
+    # for us to do here.
+    if not use_pep517:
+        return None
+
+    if build_system is None:
+        # Either the user has a pyproject.toml with no build-system
+        # section, or the user has no pyproject.toml, but has opted in
+        # explicitly via --use-pep517.
+        # In the absence of any explicit backend specification, we
+        # assume the setuptools backend that most closely emulates the
+        # traditional direct setup.py execution, and require wheel and
+        # a version of setuptools that supports that backend.
+
+        build_system = {
+            "requires": ["setuptools>=40.8.0", "wheel"],
+            "build-backend": "setuptools.build_meta:__legacy__",
+        }
+
+    # If we're using PEP 517, we have build system information (either
+    # from pyproject.toml, or defaulted by the code above).
+    # Note that at this point, we do not know if the user has actually
+    # specified a backend, though.
+    assert build_system is not None
+
+    # Ensure that the build-system section in pyproject.toml conforms
+    # to PEP 518.
+    error_template = (
+        "{package} has a pyproject.toml file that does not comply "
+        "with PEP 518: {reason}"
+    )
+
+    # Specifying the build-system table but not the requires key is invalid
+    if "requires" not in build_system:
+        raise InstallationError(
+            error_template.format(package=req_name, reason=(
+                "it has a 'build-system' table but not "
+                "'build-system.requires' which is mandatory in the table"
+            ))
+        )
+
+    # Error out if requires is not a list of strings
+    requires = build_system["requires"]
+    if not _is_list_of_str(requires):
+        raise InstallationError(error_template.format(
+            package=req_name,
+            reason="'build-system.requires' is not a list of strings.",
+        ))
+
+    # Each requirement must be valid as per PEP 508
+    for requirement in requires:
+        try:
+            Requirement(requirement)
+        except InvalidRequirement:
+            raise InstallationError(
+                error_template.format(
+                    package=req_name,
+                    reason=(
+                        "'build-system.requires' contains an invalid "
+                        "requirement: {!r}".format(requirement)
+                    ),
+                )
+            )
+
+    backend = build_system.get("build-backend")
+    backend_path = build_system.get("backend-path", [])
+    check = []  # type: List[str]
+    if backend is None:
+        # If the user didn't specify a backend, we assume they want to use
+        # the setuptools backend. But we can't be sure they have included
+        # a version of setuptools which supplies the backend, or wheel
+        # (which is needed by the backend) in their requirements. So we
+        # make a note to check that those requirements are present once
+        # we have set up the environment.
+        # This is quite a lot of work to check for a very specific case. But
+        # the problem is, that case is potentially quite common - projects that
+        # adopted PEP 518 early for the ability to specify requirements to
+        # execute setup.py, but never considered needing to mention the build
+        # tools themselves. The original PEP 518 code had a similar check (but
+        # implemented in a different way).
+        backend = "setuptools.build_meta:__legacy__"
+        check = ["setuptools>=40.8.0", "wheel"]
+
+    return BuildSystemDetails(requires, backend, check, backend_path)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/req/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/req/__init__.py
new file mode 100644
index 0000000..8568d3f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/req/__init__.py
@@ -0,0 +1,103 @@
+from __future__ import absolute_import
+
+import collections
+import logging
+
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+from .req_file import parse_requirements
+from .req_install import InstallRequirement
+from .req_set import RequirementSet
+
+if MYPY_CHECK_RUNNING:
+    from typing import Iterator, List, Optional, Sequence, Tuple
+
+__all__ = [
+    "RequirementSet", "InstallRequirement",
+    "parse_requirements", "install_given_reqs",
+]
+
+logger = logging.getLogger(__name__)
+
+
+class InstallationResult(object):
+    def __init__(self, name):
+        # type: (str) -> None
+        self.name = name
+
+    def __repr__(self):
+        # type: () -> str
+        return "InstallationResult(name={!r})".format(self.name)
+
+
+def _validate_requirements(
+    requirements,  # type: List[InstallRequirement]
+):
+    # type: (...) -> Iterator[Tuple[str, InstallRequirement]]
+    for req in requirements:
+        assert req.name, "invalid to-be-installed requirement: {}".format(req)
+        yield req.name, req
+
+
+def install_given_reqs(
+    requirements,  # type: List[InstallRequirement]
+    install_options,  # type: List[str]
+    global_options,  # type: Sequence[str]
+    root,  # type: Optional[str]
+    home,  # type: Optional[str]
+    prefix,  # type: Optional[str]
+    warn_script_location,  # type: bool
+    use_user_site,  # type: bool
+    pycompile,  # type: bool
+):
+    # type: (...) -> List[InstallationResult]
+    """
+    Install everything in the given list.
+
+    (to be called after having downloaded and unpacked the packages)
+    """
+    to_install = collections.OrderedDict(_validate_requirements(requirements))
+
+    if to_install:
+        logger.info(
+            'Installing collected packages: %s',
+            ', '.join(to_install.keys()),
+        )
+
+    installed = []
+
+    with indent_log():
+        for req_name, requirement in to_install.items():
+            if requirement.should_reinstall:
+                logger.info('Attempting uninstall: %s', req_name)
+                with indent_log():
+                    uninstalled_pathset = requirement.uninstall(
+                        auto_confirm=True
+                    )
+            else:
+                uninstalled_pathset = None
+
+            try:
+                requirement.install(
+                    install_options,
+                    global_options,
+                    root=root,
+                    home=home,
+                    prefix=prefix,
+                    warn_script_location=warn_script_location,
+                    use_user_site=use_user_site,
+                    pycompile=pycompile,
+                )
+            except Exception:
+                # if install did not succeed, rollback previous uninstall
+                if uninstalled_pathset and not requirement.install_succeeded:
+                    uninstalled_pathset.rollback()
+                raise
+            else:
+                if uninstalled_pathset and requirement.install_succeeded:
+                    uninstalled_pathset.commit()
+
+            installed.append(InstallationResult(req_name))
+
+    return installed
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/req/constructors.py b/myenv/lib/python3.9/site-packages/pip/_internal/req/constructors.py
new file mode 100644
index 0000000..7a4641e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/req/constructors.py
@@ -0,0 +1,486 @@
+"""Backing implementation for InstallRequirement's various constructors
+
+The idea here is that these formed a major chunk of InstallRequirement's size
+so, moving them and support code dedicated to them outside of that class
+helps creates for better understandability for the rest of the code.
+
+These are meant to be used elsewhere within pip to create instances of
+InstallRequirement.
+"""
+
+import logging
+import os
+import re
+
+from pip._vendor.packaging.markers import Marker
+from pip._vendor.packaging.requirements import InvalidRequirement, Requirement
+from pip._vendor.packaging.specifiers import Specifier
+from pip._vendor.pkg_resources import RequirementParseError, parse_requirements
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.models.index import PyPI, TestPyPI
+from pip._internal.models.link import Link
+from pip._internal.models.wheel import Wheel
+from pip._internal.pyproject import make_pyproject_path
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.utils.deprecation import deprecated
+from pip._internal.utils.filetypes import ARCHIVE_EXTENSIONS
+from pip._internal.utils.misc import is_installable_dir, splitext
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.urls import path_to_url
+from pip._internal.vcs import is_url, vcs
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Any, Dict, Optional, Set, Tuple, Union,
+    )
+    from pip._internal.req.req_file import ParsedRequirement
+
+
+__all__ = [
+    "install_req_from_editable", "install_req_from_line",
+    "parse_editable"
+]
+
+logger = logging.getLogger(__name__)
+operators = Specifier._operators.keys()
+
+
+def is_archive_file(name):
+    # type: (str) -> bool
+    """Return True if `name` is a considered as an archive file."""
+    ext = splitext(name)[1].lower()
+    if ext in ARCHIVE_EXTENSIONS:
+        return True
+    return False
+
+
+def _strip_extras(path):
+    # type: (str) -> Tuple[str, Optional[str]]
+    m = re.match(r'^(.+)(\[[^\]]+\])$', path)
+    extras = None
+    if m:
+        path_no_extras = m.group(1)
+        extras = m.group(2)
+    else:
+        path_no_extras = path
+
+    return path_no_extras, extras
+
+
+def convert_extras(extras):
+    # type: (Optional[str]) -> Set[str]
+    if not extras:
+        return set()
+    return Requirement("placeholder" + extras.lower()).extras
+
+
+def parse_editable(editable_req):
+    # type: (str) -> Tuple[Optional[str], str, Set[str]]
+    """Parses an editable requirement into:
+        - a requirement name
+        - an URL
+        - extras
+        - editable options
+    Accepted requirements:
+        svn+http://blahblah@rev#egg=Foobar[baz]&subdirectory=version_subdir
+        .[some_extra]
+    """
+
+    url = editable_req
+
+    # If a file path is specified with extras, strip off the extras.
+    url_no_extras, extras = _strip_extras(url)
+
+    if os.path.isdir(url_no_extras):
+        if not os.path.exists(os.path.join(url_no_extras, 'setup.py')):
+            msg = (
+                'File "setup.py" not found. Directory cannot be installed '
+                'in editable mode: {}'.format(os.path.abspath(url_no_extras))
+            )
+            pyproject_path = make_pyproject_path(url_no_extras)
+            if os.path.isfile(pyproject_path):
+                msg += (
+                    '\n(A "pyproject.toml" file was found, but editable '
+                    'mode currently requires a setup.py based build.)'
+                )
+            raise InstallationError(msg)
+
+        # Treating it as code that has already been checked out
+        url_no_extras = path_to_url(url_no_extras)
+
+    if url_no_extras.lower().startswith('file:'):
+        package_name = Link(url_no_extras).egg_fragment
+        if extras:
+            return (
+                package_name,
+                url_no_extras,
+                Requirement("placeholder" + extras.lower()).extras,
+            )
+        else:
+            return package_name, url_no_extras, set()
+
+    for version_control in vcs:
+        if url.lower().startswith('{}:'.format(version_control)):
+            url = '{}+{}'.format(version_control, url)
+            break
+
+    if '+' not in url:
+        raise InstallationError(
+            '{} is not a valid editable requirement. '
+            'It should either be a path to a local project or a VCS URL '
+            '(beginning with svn+, git+, hg+, or bzr+).'.format(editable_req)
+        )
+
+    vc_type = url.split('+', 1)[0].lower()
+
+    if not vcs.get_backend(vc_type):
+        backends = ", ".join([bends.name + '+URL' for bends in vcs.backends])
+        error_message = "For --editable={}, " \
+                        "only {} are currently supported".format(
+                            editable_req, backends)
+        raise InstallationError(error_message)
+
+    package_name = Link(url).egg_fragment
+    if not package_name:
+        raise InstallationError(
+            "Could not detect requirement name for '{}', please specify one "
+            "with #egg=your_package_name".format(editable_req)
+        )
+    return package_name, url, set()
+
+
+def deduce_helpful_msg(req):
+    # type: (str) -> str
+    """Returns helpful msg in case requirements file does not exist,
+    or cannot be parsed.
+
+    :params req: Requirements file path
+    """
+    msg = ""
+    if os.path.exists(req):
+        msg = " It does exist."
+        # Try to parse and check if it is a requirements file.
+        try:
+            with open(req, 'r') as fp:
+                # parse first line only
+                next(parse_requirements(fp.read()))
+                msg += (
+                    "The argument you provided "
+                    "({}) appears to be a"
+                    " requirements file. If that is the"
+                    " case, use the '-r' flag to install"
+                    " the packages specified within it."
+                ).format(req)
+        except RequirementParseError:
+            logger.debug(
+                "Cannot parse '%s' as requirements file", req, exc_info=True
+            )
+    else:
+        msg += " File '{}' does not exist.".format(req)
+    return msg
+
+
+class RequirementParts(object):
+    def __init__(
+            self,
+            requirement,  # type: Optional[Requirement]
+            link,         # type: Optional[Link]
+            markers,      # type: Optional[Marker]
+            extras,       # type: Set[str]
+    ):
+        self.requirement = requirement
+        self.link = link
+        self.markers = markers
+        self.extras = extras
+
+
+def parse_req_from_editable(editable_req):
+    # type: (str) -> RequirementParts
+    name, url, extras_override = parse_editable(editable_req)
+
+    if name is not None:
+        try:
+            req = Requirement(name)
+        except InvalidRequirement:
+            raise InstallationError("Invalid requirement: '{}'".format(name))
+    else:
+        req = None
+
+    link = Link(url)
+
+    return RequirementParts(req, link, None, extras_override)
+
+
+# ---- The actual constructors follow ----
+
+
+def install_req_from_editable(
+    editable_req,  # type: str
+    comes_from=None,  # type: Optional[Union[InstallRequirement, str]]
+    use_pep517=None,  # type: Optional[bool]
+    isolated=False,  # type: bool
+    options=None,  # type: Optional[Dict[str, Any]]
+    constraint=False,  # type: bool
+    user_supplied=False,  # type: bool
+):
+    # type: (...) -> InstallRequirement
+
+    parts = parse_req_from_editable(editable_req)
+
+    return InstallRequirement(
+        parts.requirement,
+        comes_from=comes_from,
+        user_supplied=user_supplied,
+        editable=True,
+        link=parts.link,
+        constraint=constraint,
+        use_pep517=use_pep517,
+        isolated=isolated,
+        install_options=options.get("install_options", []) if options else [],
+        global_options=options.get("global_options", []) if options else [],
+        hash_options=options.get("hashes", {}) if options else {},
+        extras=parts.extras,
+    )
+
+
+def _looks_like_path(name):
+    # type: (str) -> bool
+    """Checks whether the string "looks like" a path on the filesystem.
+
+    This does not check whether the target actually exists, only judge from the
+    appearance.
+
+    Returns true if any of the following conditions is true:
+    * a path separator is found (either os.path.sep or os.path.altsep);
+    * a dot is found (which represents the current directory).
+    """
+    if os.path.sep in name:
+        return True
+    if os.path.altsep is not None and os.path.altsep in name:
+        return True
+    if name.startswith("."):
+        return True
+    return False
+
+
+def _get_url_from_path(path, name):
+    # type: (str, str) -> Optional[str]
+    """
+    First, it checks whether a provided path is an installable directory
+    (e.g. it has a setup.py). If it is, returns the path.
+
+    If false, check if the path is an archive file (such as a .whl).
+    The function checks if the path is a file. If false, if the path has
+    an @, it will treat it as a PEP 440 URL requirement and return the path.
+    """
+    if _looks_like_path(name) and os.path.isdir(path):
+        if is_installable_dir(path):
+            return path_to_url(path)
+        raise InstallationError(
+            "Directory {name!r} is not installable. Neither 'setup.py' "
+            "nor 'pyproject.toml' found.".format(**locals())
+        )
+    if not is_archive_file(path):
+        return None
+    if os.path.isfile(path):
+        return path_to_url(path)
+    urlreq_parts = name.split('@', 1)
+    if len(urlreq_parts) >= 2 and not _looks_like_path(urlreq_parts[0]):
+        # If the path contains '@' and the part before it does not look
+        # like a path, try to treat it as a PEP 440 URL req instead.
+        return None
+    logger.warning(
+        'Requirement %r looks like a filename, but the '
+        'file does not exist',
+        name
+    )
+    return path_to_url(path)
+
+
+def parse_req_from_line(name, line_source):
+    # type: (str, Optional[str]) -> RequirementParts
+    if is_url(name):
+        marker_sep = '; '
+    else:
+        marker_sep = ';'
+    if marker_sep in name:
+        name, markers_as_string = name.split(marker_sep, 1)
+        markers_as_string = markers_as_string.strip()
+        if not markers_as_string:
+            markers = None
+        else:
+            markers = Marker(markers_as_string)
+    else:
+        markers = None
+    name = name.strip()
+    req_as_string = None
+    path = os.path.normpath(os.path.abspath(name))
+    link = None
+    extras_as_string = None
+
+    if is_url(name):
+        link = Link(name)
+    else:
+        p, extras_as_string = _strip_extras(path)
+        url = _get_url_from_path(p, name)
+        if url is not None:
+            link = Link(url)
+
+    # it's a local file, dir, or url
+    if link:
+        # Handle relative file URLs
+        if link.scheme == 'file' and re.search(r'\.\./', link.url):
+            link = Link(
+                path_to_url(os.path.normpath(os.path.abspath(link.path))))
+        # wheel file
+        if link.is_wheel:
+            wheel = Wheel(link.filename)  # can raise InvalidWheelFilename
+            req_as_string = "{wheel.name}=={wheel.version}".format(**locals())
+        else:
+            # set the req to the egg fragment.  when it's not there, this
+            # will become an 'unnamed' requirement
+            req_as_string = link.egg_fragment
+
+    # a requirement specifier
+    else:
+        req_as_string = name
+
+    extras = convert_extras(extras_as_string)
+
+    def with_source(text):
+        # type: (str) -> str
+        if not line_source:
+            return text
+        return '{} (from {})'.format(text, line_source)
+
+    if req_as_string is not None:
+        try:
+            req = Requirement(req_as_string)
+        except InvalidRequirement:
+            if os.path.sep in req_as_string:
+                add_msg = "It looks like a path."
+                add_msg += deduce_helpful_msg(req_as_string)
+            elif ('=' in req_as_string and
+                  not any(op in req_as_string for op in operators)):
+                add_msg = "= is not a valid operator. Did you mean == ?"
+            else:
+                add_msg = ''
+            msg = with_source(
+                'Invalid requirement: {!r}'.format(req_as_string)
+            )
+            if add_msg:
+                msg += '\nHint: {}'.format(add_msg)
+            raise InstallationError(msg)
+        else:
+            # Deprecate extras after specifiers: "name>=1.0[extras]"
+            # This currently works by accident because _strip_extras() parses
+            # any extras in the end of the string and those are saved in
+            # RequirementParts
+            for spec in req.specifier:
+                spec_str = str(spec)
+                if spec_str.endswith(']'):
+                    msg = "Extras after version '{}'.".format(spec_str)
+                    replace = "moving the extras before version specifiers"
+                    deprecated(msg, replacement=replace, gone_in="21.0")
+    else:
+        req = None
+
+    return RequirementParts(req, link, markers, extras)
+
+
+def install_req_from_line(
+    name,  # type: str
+    comes_from=None,  # type: Optional[Union[str, InstallRequirement]]
+    use_pep517=None,  # type: Optional[bool]
+    isolated=False,  # type: bool
+    options=None,  # type: Optional[Dict[str, Any]]
+    constraint=False,  # type: bool
+    line_source=None,  # type: Optional[str]
+    user_supplied=False,  # type: bool
+):
+    # type: (...) -> InstallRequirement
+    """Creates an InstallRequirement from a name, which might be a
+    requirement, directory containing 'setup.py', filename, or URL.
+
+    :param line_source: An optional string describing where the line is from,
+        for logging purposes in case of an error.
+    """
+    parts = parse_req_from_line(name, line_source)
+
+    return InstallRequirement(
+        parts.requirement, comes_from, link=parts.link, markers=parts.markers,
+        use_pep517=use_pep517, isolated=isolated,
+        install_options=options.get("install_options", []) if options else [],
+        global_options=options.get("global_options", []) if options else [],
+        hash_options=options.get("hashes", {}) if options else {},
+        constraint=constraint,
+        extras=parts.extras,
+        user_supplied=user_supplied,
+    )
+
+
+def install_req_from_req_string(
+    req_string,  # type: str
+    comes_from=None,  # type: Optional[InstallRequirement]
+    isolated=False,  # type: bool
+    use_pep517=None,  # type: Optional[bool]
+    user_supplied=False,  # type: bool
+):
+    # type: (...) -> InstallRequirement
+    try:
+        req = Requirement(req_string)
+    except InvalidRequirement:
+        raise InstallationError("Invalid requirement: '{}'".format(req_string))
+
+    domains_not_allowed = [
+        PyPI.file_storage_domain,
+        TestPyPI.file_storage_domain,
+    ]
+    if (req.url and comes_from and comes_from.link and
+            comes_from.link.netloc in domains_not_allowed):
+        # Explicitly disallow pypi packages that depend on external urls
+        raise InstallationError(
+            "Packages installed from PyPI cannot depend on packages "
+            "which are not also hosted on PyPI.\n"
+            "{} depends on {} ".format(comes_from.name, req)
+        )
+
+    return InstallRequirement(
+        req,
+        comes_from,
+        isolated=isolated,
+        use_pep517=use_pep517,
+        user_supplied=user_supplied,
+    )
+
+
+def install_req_from_parsed_requirement(
+    parsed_req,  # type: ParsedRequirement
+    isolated=False,  # type: bool
+    use_pep517=None,  # type: Optional[bool]
+    user_supplied=False,  # type: bool
+):
+    # type: (...) -> InstallRequirement
+    if parsed_req.is_editable:
+        req = install_req_from_editable(
+            parsed_req.requirement,
+            comes_from=parsed_req.comes_from,
+            use_pep517=use_pep517,
+            constraint=parsed_req.constraint,
+            isolated=isolated,
+            user_supplied=user_supplied,
+        )
+
+    else:
+        req = install_req_from_line(
+            parsed_req.requirement,
+            comes_from=parsed_req.comes_from,
+            use_pep517=use_pep517,
+            isolated=isolated,
+            options=parsed_req.options,
+            constraint=parsed_req.constraint,
+            line_source=parsed_req.line_source,
+            user_supplied=user_supplied,
+        )
+    return req
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/req/req_file.py b/myenv/lib/python3.9/site-packages/pip/_internal/req/req_file.py
new file mode 100644
index 0000000..1050582
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/req/req_file.py
@@ -0,0 +1,592 @@
+"""
+Requirements file parsing
+"""
+
+from __future__ import absolute_import
+
+import optparse
+import os
+import re
+import shlex
+import sys
+
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+
+from pip._internal.cli import cmdoptions
+from pip._internal.exceptions import (
+    InstallationError,
+    RequirementsFileParseError,
+)
+from pip._internal.models.search_scope import SearchScope
+from pip._internal.network.utils import raise_for_status
+from pip._internal.utils.encoding import auto_decode
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.urls import get_url_scheme
+
+if MYPY_CHECK_RUNNING:
+    from optparse import Values
+    from typing import (
+        Any, Callable, Dict, Iterator, List, NoReturn, Optional, Text, Tuple,
+    )
+
+    from pip._internal.index.package_finder import PackageFinder
+    from pip._internal.network.session import PipSession
+
+    ReqFileLines = Iterator[Tuple[int, Text]]
+
+    LineParser = Callable[[Text], Tuple[str, Values]]
+
+
+__all__ = ['parse_requirements']
+
+SCHEME_RE = re.compile(r'^(http|https|file):', re.I)
+COMMENT_RE = re.compile(r'(^|\s+)#.*$')
+
+# Matches environment variable-style values in '${MY_VARIABLE_1}' with the
+# variable name consisting of only uppercase letters, digits or the '_'
+# (underscore). This follows the POSIX standard defined in IEEE Std 1003.1,
+# 2013 Edition.
+ENV_VAR_RE = re.compile(r'(?P<var>\$\{(?P<name>[A-Z0-9_]+)\})')
+
+SUPPORTED_OPTIONS = [
+    cmdoptions.index_url,
+    cmdoptions.extra_index_url,
+    cmdoptions.no_index,
+    cmdoptions.constraints,
+    cmdoptions.requirements,
+    cmdoptions.editable,
+    cmdoptions.find_links,
+    cmdoptions.no_binary,
+    cmdoptions.only_binary,
+    cmdoptions.prefer_binary,
+    cmdoptions.require_hashes,
+    cmdoptions.pre,
+    cmdoptions.trusted_host,
+    cmdoptions.use_new_feature,
+]  # type: List[Callable[..., optparse.Option]]
+
+# options to be passed to requirements
+SUPPORTED_OPTIONS_REQ = [
+    cmdoptions.install_options,
+    cmdoptions.global_options,
+    cmdoptions.hash,
+]  # type: List[Callable[..., optparse.Option]]
+
+# the 'dest' string values
+SUPPORTED_OPTIONS_REQ_DEST = [str(o().dest) for o in SUPPORTED_OPTIONS_REQ]
+
+
+class ParsedRequirement(object):
+    def __init__(
+        self,
+        requirement,  # type:str
+        is_editable,  # type: bool
+        comes_from,  # type: str
+        constraint,  # type: bool
+        options=None,  # type: Optional[Dict[str, Any]]
+        line_source=None,  # type: Optional[str]
+    ):
+        # type: (...) -> None
+        self.requirement = requirement
+        self.is_editable = is_editable
+        self.comes_from = comes_from
+        self.options = options
+        self.constraint = constraint
+        self.line_source = line_source
+
+
+class ParsedLine(object):
+    def __init__(
+        self,
+        filename,  # type: str
+        lineno,  # type: int
+        comes_from,  # type: Optional[str]
+        args,  # type: str
+        opts,  # type: Values
+        constraint,  # type: bool
+    ):
+        # type: (...) -> None
+        self.filename = filename
+        self.lineno = lineno
+        self.comes_from = comes_from
+        self.opts = opts
+        self.constraint = constraint
+
+        if args:
+            self.is_requirement = True
+            self.is_editable = False
+            self.requirement = args
+        elif opts.editables:
+            self.is_requirement = True
+            self.is_editable = True
+            # We don't support multiple -e on one line
+            self.requirement = opts.editables[0]
+        else:
+            self.is_requirement = False
+
+
+def parse_requirements(
+    filename,  # type: str
+    session,  # type: PipSession
+    finder=None,  # type: Optional[PackageFinder]
+    comes_from=None,  # type: Optional[str]
+    options=None,  # type: Optional[optparse.Values]
+    constraint=False,  # type: bool
+):
+    # type: (...) -> Iterator[ParsedRequirement]
+    """Parse a requirements file and yield ParsedRequirement instances.
+
+    :param filename:    Path or url of requirements file.
+    :param session:     PipSession instance.
+    :param finder:      Instance of pip.index.PackageFinder.
+    :param comes_from:  Origin description of requirements.
+    :param options:     cli options.
+    :param constraint:  If true, parsing a constraint file rather than
+        requirements file.
+    """
+    line_parser = get_line_parser(finder)
+    parser = RequirementsFileParser(session, line_parser, comes_from)
+
+    for parsed_line in parser.parse(filename, constraint):
+        parsed_req = handle_line(
+            parsed_line,
+            options=options,
+            finder=finder,
+            session=session
+        )
+        if parsed_req is not None:
+            yield parsed_req
+
+
+def preprocess(content):
+    # type: (Text) -> ReqFileLines
+    """Split, filter, and join lines, and return a line iterator
+
+    :param content: the content of the requirements file
+    """
+    lines_enum = enumerate(content.splitlines(), start=1)  # type: ReqFileLines
+    lines_enum = join_lines(lines_enum)
+    lines_enum = ignore_comments(lines_enum)
+    lines_enum = expand_env_variables(lines_enum)
+    return lines_enum
+
+
+def handle_requirement_line(
+    line,  # type: ParsedLine
+    options=None,  # type: Optional[optparse.Values]
+):
+    # type: (...) -> ParsedRequirement
+
+    # preserve for the nested code path
+    line_comes_from = '{} {} (line {})'.format(
+        '-c' if line.constraint else '-r', line.filename, line.lineno,
+    )
+
+    assert line.is_requirement
+
+    if line.is_editable:
+        # For editable requirements, we don't support per-requirement
+        # options, so just return the parsed requirement.
+        return ParsedRequirement(
+            requirement=line.requirement,
+            is_editable=line.is_editable,
+            comes_from=line_comes_from,
+            constraint=line.constraint,
+        )
+    else:
+        if options:
+            # Disable wheels if the user has specified build options
+            cmdoptions.check_install_build_global(options, line.opts)
+
+        # get the options that apply to requirements
+        req_options = {}
+        for dest in SUPPORTED_OPTIONS_REQ_DEST:
+            if dest in line.opts.__dict__ and line.opts.__dict__[dest]:
+                req_options[dest] = line.opts.__dict__[dest]
+
+        line_source = 'line {} of {}'.format(line.lineno, line.filename)
+        return ParsedRequirement(
+            requirement=line.requirement,
+            is_editable=line.is_editable,
+            comes_from=line_comes_from,
+            constraint=line.constraint,
+            options=req_options,
+            line_source=line_source,
+        )
+
+
+def handle_option_line(
+    opts,  # type: Values
+    filename,  # type: str
+    lineno,  # type: int
+    finder=None,  # type: Optional[PackageFinder]
+    options=None,  # type: Optional[optparse.Values]
+    session=None,  # type: Optional[PipSession]
+):
+    # type:  (...) -> None
+
+    if options:
+        # percolate options upward
+        if opts.require_hashes:
+            options.require_hashes = opts.require_hashes
+        if opts.features_enabled:
+            options.features_enabled.extend(
+                f for f in opts.features_enabled
+                if f not in options.features_enabled
+            )
+
+    # set finder options
+    if finder:
+        find_links = finder.find_links
+        index_urls = finder.index_urls
+        if opts.index_url:
+            index_urls = [opts.index_url]
+        if opts.no_index is True:
+            index_urls = []
+        if opts.extra_index_urls:
+            index_urls.extend(opts.extra_index_urls)
+        if opts.find_links:
+            # FIXME: it would be nice to keep track of the source
+            # of the find_links: support a find-links local path
+            # relative to a requirements file.
+            value = opts.find_links[0]
+            req_dir = os.path.dirname(os.path.abspath(filename))
+            relative_to_reqs_file = os.path.join(req_dir, value)
+            if os.path.exists(relative_to_reqs_file):
+                value = relative_to_reqs_file
+            find_links.append(value)
+
+        search_scope = SearchScope(
+            find_links=find_links,
+            index_urls=index_urls,
+        )
+        finder.search_scope = search_scope
+
+        if opts.pre:
+            finder.set_allow_all_prereleases()
+
+        if opts.prefer_binary:
+            finder.set_prefer_binary()
+
+        if session:
+            for host in opts.trusted_hosts or []:
+                source = 'line {} of {}'.format(lineno, filename)
+                session.add_trusted_host(host, source=source)
+
+
+def handle_line(
+    line,  # type: ParsedLine
+    options=None,  # type: Optional[optparse.Values]
+    finder=None,  # type: Optional[PackageFinder]
+    session=None,  # type: Optional[PipSession]
+):
+    # type: (...) -> Optional[ParsedRequirement]
+    """Handle a single parsed requirements line; This can result in
+    creating/yielding requirements, or updating the finder.
+
+    :param line:        The parsed line to be processed.
+    :param options:     CLI options.
+    :param finder:      The finder - updated by non-requirement lines.
+    :param session:     The session - updated by non-requirement lines.
+
+    Returns a ParsedRequirement object if the line is a requirement line,
+    otherwise returns None.
+
+    For lines that contain requirements, the only options that have an effect
+    are from SUPPORTED_OPTIONS_REQ, and they are scoped to the
+    requirement. Other options from SUPPORTED_OPTIONS may be present, but are
+    ignored.
+
+    For lines that do not contain requirements, the only options that have an
+    effect are from SUPPORTED_OPTIONS. Options from SUPPORTED_OPTIONS_REQ may
+    be present, but are ignored. These lines may contain multiple options
+    (although our docs imply only one is supported), and all our parsed and
+    affect the finder.
+    """
+
+    if line.is_requirement:
+        parsed_req = handle_requirement_line(line, options)
+        return parsed_req
+    else:
+        handle_option_line(
+            line.opts,
+            line.filename,
+            line.lineno,
+            finder,
+            options,
+            session,
+        )
+        return None
+
+
+class RequirementsFileParser(object):
+    def __init__(
+        self,
+        session,  # type: PipSession
+        line_parser,  # type: LineParser
+        comes_from,  # type: Optional[str]
+    ):
+        # type: (...) -> None
+        self._session = session
+        self._line_parser = line_parser
+        self._comes_from = comes_from
+
+    def parse(self, filename, constraint):
+        # type: (str, bool) -> Iterator[ParsedLine]
+        """Parse a given file, yielding parsed lines.
+        """
+        for line in self._parse_and_recurse(filename, constraint):
+            yield line
+
+    def _parse_and_recurse(self, filename, constraint):
+        # type: (str, bool) -> Iterator[ParsedLine]
+        for line in self._parse_file(filename, constraint):
+            if (
+                not line.is_requirement and
+                (line.opts.requirements or line.opts.constraints)
+            ):
+                # parse a nested requirements file
+                if line.opts.requirements:
+                    req_path = line.opts.requirements[0]
+                    nested_constraint = False
+                else:
+                    req_path = line.opts.constraints[0]
+                    nested_constraint = True
+
+                # original file is over http
+                if SCHEME_RE.search(filename):
+                    # do a url join so relative paths work
+                    req_path = urllib_parse.urljoin(filename, req_path)
+                # original file and nested file are paths
+                elif not SCHEME_RE.search(req_path):
+                    # do a join so relative paths work
+                    req_path = os.path.join(
+                        os.path.dirname(filename), req_path,
+                    )
+
+                for inner_line in self._parse_and_recurse(
+                    req_path, nested_constraint,
+                ):
+                    yield inner_line
+            else:
+                yield line
+
+    def _parse_file(self, filename, constraint):
+        # type: (str, bool) -> Iterator[ParsedLine]
+        _, content = get_file_content(
+            filename, self._session, comes_from=self._comes_from
+        )
+
+        lines_enum = preprocess(content)
+
+        for line_number, line in lines_enum:
+            try:
+                args_str, opts = self._line_parser(line)
+            except OptionParsingError as e:
+                # add offending line
+                msg = 'Invalid requirement: {}\n{}'.format(line, e.msg)
+                raise RequirementsFileParseError(msg)
+
+            yield ParsedLine(
+                filename,
+                line_number,
+                self._comes_from,
+                args_str,
+                opts,
+                constraint,
+            )
+
+
+def get_line_parser(finder):
+    # type: (Optional[PackageFinder]) -> LineParser
+    def parse_line(line):
+        # type: (Text) -> Tuple[str, Values]
+        # Build new parser for each line since it accumulates appendable
+        # options.
+        parser = build_parser()
+        defaults = parser.get_default_values()
+        defaults.index_url = None
+        if finder:
+            defaults.format_control = finder.format_control
+
+        args_str, options_str = break_args_options(line)
+        # Prior to 2.7.3, shlex cannot deal with unicode entries
+        if sys.version_info < (2, 7, 3):
+            # https://github.com/python/mypy/issues/1174
+            options_str = options_str.encode('utf8')  # type: ignore
+
+        # https://github.com/python/mypy/issues/1174
+        opts, _ = parser.parse_args(
+            shlex.split(options_str), defaults)  # type: ignore
+
+        return args_str, opts
+
+    return parse_line
+
+
+def break_args_options(line):
+    # type: (Text) -> Tuple[str, Text]
+    """Break up the line into an args and options string.  We only want to shlex
+    (and then optparse) the options, not the args.  args can contain markers
+    which are corrupted by shlex.
+    """
+    tokens = line.split(' ')
+    args = []
+    options = tokens[:]
+    for token in tokens:
+        if token.startswith('-') or token.startswith('--'):
+            break
+        else:
+            args.append(token)
+            options.pop(0)
+    return ' '.join(args), ' '.join(options)  # type: ignore
+
+
+class OptionParsingError(Exception):
+    def __init__(self, msg):
+        # type: (str) -> None
+        self.msg = msg
+
+
+def build_parser():
+    # type: () -> optparse.OptionParser
+    """
+    Return a parser for parsing requirement lines
+    """
+    parser = optparse.OptionParser(add_help_option=False)
+
+    option_factories = SUPPORTED_OPTIONS + SUPPORTED_OPTIONS_REQ
+    for option_factory in option_factories:
+        option = option_factory()
+        parser.add_option(option)
+
+    # By default optparse sys.exits on parsing errors. We want to wrap
+    # that in our own exception.
+    def parser_exit(self, msg):
+        # type: (Any, str) -> NoReturn
+        raise OptionParsingError(msg)
+    # NOTE: mypy disallows assigning to a method
+    #       https://github.com/python/mypy/issues/2427
+    parser.exit = parser_exit  # type: ignore
+
+    return parser
+
+
+def join_lines(lines_enum):
+    # type: (ReqFileLines) -> ReqFileLines
+    """Joins a line ending in '\' with the previous line (except when following
+    comments).  The joined line takes on the index of the first line.
+    """
+    primary_line_number = None
+    new_line = []  # type: List[Text]
+    for line_number, line in lines_enum:
+        if not line.endswith('\\') or COMMENT_RE.match(line):
+            if COMMENT_RE.match(line):
+                # this ensures comments are always matched later
+                line = ' ' + line
+            if new_line:
+                new_line.append(line)
+                assert primary_line_number is not None
+                yield primary_line_number, ''.join(new_line)
+                new_line = []
+            else:
+                yield line_number, line
+        else:
+            if not new_line:
+                primary_line_number = line_number
+            new_line.append(line.strip('\\'))
+
+    # last line contains \
+    if new_line:
+        assert primary_line_number is not None
+        yield primary_line_number, ''.join(new_line)
+
+    # TODO: handle space after '\'.
+
+
+def ignore_comments(lines_enum):
+    # type: (ReqFileLines) -> ReqFileLines
+    """
+    Strips comments and filter empty lines.
+    """
+    for line_number, line in lines_enum:
+        line = COMMENT_RE.sub('', line)
+        line = line.strip()
+        if line:
+            yield line_number, line
+
+
+def expand_env_variables(lines_enum):
+    # type: (ReqFileLines) -> ReqFileLines
+    """Replace all environment variables that can be retrieved via `os.getenv`.
+
+    The only allowed format for environment variables defined in the
+    requirement file is `${MY_VARIABLE_1}` to ensure two things:
+
+    1. Strings that contain a `$` aren't accidentally (partially) expanded.
+    2. Ensure consistency across platforms for requirement files.
+
+    These points are the result of a discussion on the `github pull
+    request #3514 <https://github.com/pypa/pip/pull/3514>`_.
+
+    Valid characters in variable names follow the `POSIX standard
+    <http://pubs.opengroup.org/onlinepubs/9699919799/>`_ and are limited
+    to uppercase letter, digits and the `_` (underscore).
+    """
+    for line_number, line in lines_enum:
+        for env_var, var_name in ENV_VAR_RE.findall(line):
+            value = os.getenv(var_name)
+            if not value:
+                continue
+
+            line = line.replace(env_var, value)
+
+        yield line_number, line
+
+
+def get_file_content(url, session, comes_from=None):
+    # type: (str, PipSession, Optional[str]) -> Tuple[str, Text]
+    """Gets the content of a file; it may be a filename, file: URL, or
+    http: URL.  Returns (location, content).  Content is unicode.
+    Respects # -*- coding: declarations on the retrieved files.
+
+    :param url:         File path or url.
+    :param session:     PipSession instance.
+    :param comes_from:  Origin description of requirements.
+    """
+    scheme = get_url_scheme(url)
+
+    if scheme in ['http', 'https']:
+        # FIXME: catch some errors
+        resp = session.get(url)
+        raise_for_status(resp)
+        return resp.url, resp.text
+
+    elif scheme == 'file':
+        if comes_from and comes_from.startswith('http'):
+            raise InstallationError(
+                'Requirements file {} references URL {}, '
+                'which is local'.format(comes_from, url)
+            )
+
+        path = url.split(':', 1)[1]
+        path = path.replace('\\', '/')
+        match = _url_slash_drive_re.match(path)
+        if match:
+            path = match.group(1) + ':' + path.split('|', 1)[1]
+        path = urllib_parse.unquote(path)
+        if path.startswith('/'):
+            path = '/' + path.lstrip('/')
+        url = path
+
+    try:
+        with open(url, 'rb') as f:
+            content = auto_decode(f.read())
+    except IOError as exc:
+        raise InstallationError(
+            'Could not open requirements file: {}'.format(exc)
+        )
+    return url, content
+
+
+_url_slash_drive_re = re.compile(r'/*([a-z])\|', re.I)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/req/req_install.py b/myenv/lib/python3.9/site-packages/pip/_internal/req/req_install.py
new file mode 100644
index 0000000..f25cec9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/req/req_install.py
@@ -0,0 +1,905 @@
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
+
+from __future__ import absolute_import
+
+import logging
+import os
+import shutil
+import sys
+import uuid
+import zipfile
+
+from pip._vendor import pkg_resources, six
+from pip._vendor.packaging.requirements import Requirement
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.packaging.version import Version
+from pip._vendor.packaging.version import parse as parse_version
+from pip._vendor.pep517.wrappers import Pep517HookCaller
+
+from pip._internal.build_env import NoOpBuildEnvironment
+from pip._internal.exceptions import InstallationError
+from pip._internal.locations import get_scheme
+from pip._internal.models.link import Link
+from pip._internal.operations.build.metadata import generate_metadata
+from pip._internal.operations.build.metadata_legacy import \
+    generate_metadata as generate_metadata_legacy
+from pip._internal.operations.install.editable_legacy import \
+    install_editable as install_editable_legacy
+from pip._internal.operations.install.legacy import LegacyInstallFailure
+from pip._internal.operations.install.legacy import install as install_legacy
+from pip._internal.operations.install.wheel import install_wheel
+from pip._internal.pyproject import load_pyproject_toml, make_pyproject_path
+from pip._internal.req.req_uninstall import UninstallPathSet
+from pip._internal.utils.deprecation import deprecated
+from pip._internal.utils.direct_url_helpers import direct_url_from_link
+from pip._internal.utils.hashes import Hashes
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import (
+    ask_path_exists,
+    backup_dir,
+    display_path,
+    dist_in_site_packages,
+    dist_in_usersite,
+    get_distribution,
+    get_installed_version,
+    hide_url,
+    redact_auth_from_url,
+)
+from pip._internal.utils.packaging import get_metadata
+from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.virtualenv import running_under_virtualenv
+from pip._internal.vcs import vcs
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Any, Dict, Iterable, List, Optional, Sequence, Union,
+    )
+    from pip._internal.build_env import BuildEnvironment
+    from pip._vendor.pkg_resources import Distribution
+    from pip._vendor.packaging.specifiers import SpecifierSet
+    from pip._vendor.packaging.markers import Marker
+
+
+logger = logging.getLogger(__name__)
+
+
+def _get_dist(metadata_directory):
+    # type: (str) -> Distribution
+    """Return a pkg_resources.Distribution for the provided
+    metadata directory.
+    """
+    dist_dir = metadata_directory.rstrip(os.sep)
+
+    # Build a PathMetadata object, from path to metadata. :wink:
+    base_dir, dist_dir_name = os.path.split(dist_dir)
+    metadata = pkg_resources.PathMetadata(base_dir, dist_dir)
+
+    # Determine the correct Distribution object type.
+    if dist_dir.endswith(".egg-info"):
+        dist_cls = pkg_resources.Distribution
+        dist_name = os.path.splitext(dist_dir_name)[0]
+    else:
+        assert dist_dir.endswith(".dist-info")
+        dist_cls = pkg_resources.DistInfoDistribution
+        dist_name = os.path.splitext(dist_dir_name)[0].split("-")[0]
+
+    return dist_cls(
+        base_dir,
+        project_name=dist_name,
+        metadata=metadata,
+    )
+
+
+class InstallRequirement(object):
+    """
+    Represents something that may be installed later on, may have information
+    about where to fetch the relevant requirement and also contains logic for
+    installing the said requirement.
+    """
+
+    def __init__(
+        self,
+        req,  # type: Optional[Requirement]
+        comes_from,  # type: Optional[Union[str, InstallRequirement]]
+        editable=False,  # type: bool
+        link=None,  # type: Optional[Link]
+        markers=None,  # type: Optional[Marker]
+        use_pep517=None,  # type: Optional[bool]
+        isolated=False,  # type: bool
+        install_options=None,  # type: Optional[List[str]]
+        global_options=None,  # type: Optional[List[str]]
+        hash_options=None,  # type: Optional[Dict[str, List[str]]]
+        constraint=False,  # type: bool
+        extras=(),  # type: Iterable[str]
+        user_supplied=False,  # type: bool
+    ):
+        # type: (...) -> None
+        assert req is None or isinstance(req, Requirement), req
+        self.req = req
+        self.comes_from = comes_from
+        self.constraint = constraint
+        self.editable = editable
+        self.legacy_install_reason = None  # type: Optional[int]
+
+        # source_dir is the local directory where the linked requirement is
+        # located, or unpacked. In case unpacking is needed, creating and
+        # populating source_dir is done by the RequirementPreparer. Note this
+        # is not necessarily the directory where pyproject.toml or setup.py is
+        # located - that one is obtained via unpacked_source_directory.
+        self.source_dir = None  # type: Optional[str]
+        if self.editable:
+            assert link
+            if link.is_file:
+                self.source_dir = os.path.normpath(
+                    os.path.abspath(link.file_path)
+                )
+
+        if link is None and req and req.url:
+            # PEP 508 URL requirement
+            link = Link(req.url)
+        self.link = self.original_link = link
+        self.original_link_is_in_wheel_cache = False
+
+        # Path to any downloaded or already-existing package.
+        self.local_file_path = None  # type: Optional[str]
+        if self.link and self.link.is_file:
+            self.local_file_path = self.link.file_path
+
+        if extras:
+            self.extras = extras
+        elif req:
+            self.extras = {
+                pkg_resources.safe_extra(extra) for extra in req.extras
+            }
+        else:
+            self.extras = set()
+        if markers is None and req:
+            markers = req.marker
+        self.markers = markers
+
+        # This holds the pkg_resources.Distribution object if this requirement
+        # is already available:
+        self.satisfied_by = None  # type: Optional[Distribution]
+        # Whether the installation process should try to uninstall an existing
+        # distribution before installing this requirement.
+        self.should_reinstall = False
+        # Temporary build location
+        self._temp_build_dir = None  # type: Optional[TempDirectory]
+        # Set to True after successful installation
+        self.install_succeeded = None  # type: Optional[bool]
+        # Supplied options
+        self.install_options = install_options if install_options else []
+        self.global_options = global_options if global_options else []
+        self.hash_options = hash_options if hash_options else {}
+        # Set to True after successful preparation of this requirement
+        self.prepared = False
+        # User supplied requirement are explicitly requested for installation
+        # by the user via CLI arguments or requirements files, as opposed to,
+        # e.g. dependencies, extras or constraints.
+        self.user_supplied = user_supplied
+
+        # Set by the legacy resolver when the requirement has been downloaded
+        # TODO: This introduces a strong coupling between the resolver and the
+        #       requirement (the coupling was previously between the resolver
+        #       and the requirement set). This should be refactored to allow
+        #       the requirement to decide for itself when it has been
+        #       successfully downloaded - but that is more tricky to get right,
+        #       se we are making the change in stages.
+        self.successfully_downloaded = False
+
+        self.isolated = isolated
+        self.build_env = NoOpBuildEnvironment()  # type: BuildEnvironment
+
+        # For PEP 517, the directory where we request the project metadata
+        # gets stored. We need this to pass to build_wheel, so the backend
+        # can ensure that the wheel matches the metadata (see the PEP for
+        # details).
+        self.metadata_directory = None  # type: Optional[str]
+
+        # The static build requirements (from pyproject.toml)
+        self.pyproject_requires = None  # type: Optional[List[str]]
+
+        # Build requirements that we will check are available
+        self.requirements_to_check = []  # type: List[str]
+
+        # The PEP 517 backend we should use to build the project
+        self.pep517_backend = None  # type: Optional[Pep517HookCaller]
+
+        # Are we using PEP 517 for this requirement?
+        # After pyproject.toml has been loaded, the only valid values are True
+        # and False. Before loading, None is valid (meaning "use the default").
+        # Setting an explicit value before loading pyproject.toml is supported,
+        # but after loading this flag should be treated as read only.
+        self.use_pep517 = use_pep517
+
+    def __str__(self):
+        # type: () -> str
+        if self.req:
+            s = str(self.req)
+            if self.link:
+                s += ' from {}'.format(redact_auth_from_url(self.link.url))
+        elif self.link:
+            s = redact_auth_from_url(self.link.url)
+        else:
+            s = '<InstallRequirement>'
+        if self.satisfied_by is not None:
+            s += ' in {}'.format(display_path(self.satisfied_by.location))
+        if self.comes_from:
+            if isinstance(self.comes_from, six.string_types):
+                comes_from = self.comes_from  # type: Optional[str]
+            else:
+                comes_from = self.comes_from.from_path()
+            if comes_from:
+                s += ' (from {})'.format(comes_from)
+        return s
+
+    def __repr__(self):
+        # type: () -> str
+        return '<{} object: {} editable={!r}>'.format(
+            self.__class__.__name__, str(self), self.editable)
+
+    def format_debug(self):
+        # type: () -> str
+        """An un-tested helper for getting state, for debugging.
+        """
+        attributes = vars(self)
+        names = sorted(attributes)
+
+        state = (
+            "{}={!r}".format(attr, attributes[attr]) for attr in sorted(names)
+        )
+        return '<{name} object: {{{state}}}>'.format(
+            name=self.__class__.__name__,
+            state=", ".join(state),
+        )
+
+    # Things that are valid for all kinds of requirements?
+    @property
+    def name(self):
+        # type: () -> Optional[str]
+        if self.req is None:
+            return None
+        return six.ensure_str(pkg_resources.safe_name(self.req.name))
+
+    @property
+    def specifier(self):
+        # type: () -> SpecifierSet
+        return self.req.specifier
+
+    @property
+    def is_pinned(self):
+        # type: () -> bool
+        """Return whether I am pinned to an exact version.
+
+        For example, some-package==1.2 is pinned; some-package>1.2 is not.
+        """
+        specifiers = self.specifier
+        return (len(specifiers) == 1 and
+                next(iter(specifiers)).operator in {'==', '==='})
+
+    @property
+    def installed_version(self):
+        # type: () -> Optional[str]
+        return get_installed_version(self.name)
+
+    def match_markers(self, extras_requested=None):
+        # type: (Optional[Iterable[str]]) -> bool
+        if not extras_requested:
+            # Provide an extra to safely evaluate the markers
+            # without matching any extra
+            extras_requested = ('',)
+        if self.markers is not None:
+            return any(
+                self.markers.evaluate({'extra': extra})
+                for extra in extras_requested)
+        else:
+            return True
+
+    @property
+    def has_hash_options(self):
+        # type: () -> bool
+        """Return whether any known-good hashes are specified as options.
+
+        These activate --require-hashes mode; hashes specified as part of a
+        URL do not.
+
+        """
+        return bool(self.hash_options)
+
+    def hashes(self, trust_internet=True):
+        # type: (bool) -> Hashes
+        """Return a hash-comparer that considers my option- and URL-based
+        hashes to be known-good.
+
+        Hashes in URLs--ones embedded in the requirements file, not ones
+        downloaded from an index server--are almost peers with ones from
+        flags. They satisfy --require-hashes (whether it was implicitly or
+        explicitly activated) but do not activate it. md5 and sha224 are not
+        allowed in flags, which should nudge people toward good algos. We
+        always OR all hashes together, even ones from URLs.
+
+        :param trust_internet: Whether to trust URL-based (#md5=...) hashes
+            downloaded from the internet, as by populate_link()
+
+        """
+        good_hashes = self.hash_options.copy()
+        link = self.link if trust_internet else self.original_link
+        if link and link.hash:
+            good_hashes.setdefault(link.hash_name, []).append(link.hash)
+        return Hashes(good_hashes)
+
+    def from_path(self):
+        # type: () -> Optional[str]
+        """Format a nice indicator to show where this "comes from"
+        """
+        if self.req is None:
+            return None
+        s = str(self.req)
+        if self.comes_from:
+            if isinstance(self.comes_from, six.string_types):
+                comes_from = self.comes_from
+            else:
+                comes_from = self.comes_from.from_path()
+            if comes_from:
+                s += '->' + comes_from
+        return s
+
+    def ensure_build_location(self, build_dir, autodelete, parallel_builds):
+        # type: (str, bool, bool) -> str
+        assert build_dir is not None
+        if self._temp_build_dir is not None:
+            assert self._temp_build_dir.path
+            return self._temp_build_dir.path
+        if self.req is None:
+            # Some systems have /tmp as a symlink which confuses custom
+            # builds (such as numpy). Thus, we ensure that the real path
+            # is returned.
+            self._temp_build_dir = TempDirectory(
+                kind=tempdir_kinds.REQ_BUILD, globally_managed=True
+            )
+
+            return self._temp_build_dir.path
+
+        # When parallel builds are enabled, add a UUID to the build directory
+        # name so multiple builds do not interfere with each other.
+        dir_name = canonicalize_name(self.name)
+        if parallel_builds:
+            dir_name = "{}_{}".format(dir_name, uuid.uuid4().hex)
+
+        # FIXME: Is there a better place to create the build_dir? (hg and bzr
+        # need this)
+        if not os.path.exists(build_dir):
+            logger.debug('Creating directory %s', build_dir)
+            os.makedirs(build_dir)
+        actual_build_dir = os.path.join(build_dir, dir_name)
+        # `None` indicates that we respect the globally-configured deletion
+        # settings, which is what we actually want when auto-deleting.
+        delete_arg = None if autodelete else False
+        return TempDirectory(
+            path=actual_build_dir,
+            delete=delete_arg,
+            kind=tempdir_kinds.REQ_BUILD,
+            globally_managed=True,
+        ).path
+
+    def _set_requirement(self):
+        # type: () -> None
+        """Set requirement after generating metadata.
+        """
+        assert self.req is None
+        assert self.metadata is not None
+        assert self.source_dir is not None
+
+        # Construct a Requirement object from the generated metadata
+        if isinstance(parse_version(self.metadata["Version"]), Version):
+            op = "=="
+        else:
+            op = "==="
+
+        self.req = Requirement(
+            "".join([
+                self.metadata["Name"],
+                op,
+                self.metadata["Version"],
+            ])
+        )
+
+    def warn_on_mismatching_name(self):
+        # type: () -> None
+        metadata_name = canonicalize_name(self.metadata["Name"])
+        if canonicalize_name(self.req.name) == metadata_name:
+            # Everything is fine.
+            return
+
+        # If we're here, there's a mismatch. Log a warning about it.
+        logger.warning(
+            'Generating metadata for package %s '
+            'produced metadata for project name %s. Fix your '
+            '#egg=%s fragments.',
+            self.name, metadata_name, self.name
+        )
+        self.req = Requirement(metadata_name)
+
+    def check_if_exists(self, use_user_site):
+        # type: (bool) -> None
+        """Find an installed distribution that satisfies or conflicts
+        with this requirement, and set self.satisfied_by or
+        self.should_reinstall appropriately.
+        """
+        if self.req is None:
+            return
+        existing_dist = get_distribution(self.req.name)
+        if not existing_dist:
+            return
+
+        existing_version = existing_dist.parsed_version
+        if not self.req.specifier.contains(existing_version, prereleases=True):
+            self.satisfied_by = None
+            if use_user_site:
+                if dist_in_usersite(existing_dist):
+                    self.should_reinstall = True
+                elif (running_under_virtualenv() and
+                        dist_in_site_packages(existing_dist)):
+                    raise InstallationError(
+                        "Will not install to the user site because it will "
+                        "lack sys.path precedence to {} in {}".format(
+                            existing_dist.project_name, existing_dist.location)
+                    )
+            else:
+                self.should_reinstall = True
+        else:
+            if self.editable:
+                self.should_reinstall = True
+                # when installing editables, nothing pre-existing should ever
+                # satisfy
+                self.satisfied_by = None
+            else:
+                self.satisfied_by = existing_dist
+
+    # Things valid for wheels
+    @property
+    def is_wheel(self):
+        # type: () -> bool
+        if not self.link:
+            return False
+        return self.link.is_wheel
+
+    # Things valid for sdists
+    @property
+    def unpacked_source_directory(self):
+        # type: () -> str
+        return os.path.join(
+            self.source_dir,
+            self.link and self.link.subdirectory_fragment or '')
+
+    @property
+    def setup_py_path(self):
+        # type: () -> str
+        assert self.source_dir, "No source dir for {}".format(self)
+        setup_py = os.path.join(self.unpacked_source_directory, 'setup.py')
+
+        # Python2 __file__ should not be unicode
+        if six.PY2 and isinstance(setup_py, six.text_type):
+            setup_py = setup_py.encode(sys.getfilesystemencoding())
+
+        return setup_py
+
+    @property
+    def pyproject_toml_path(self):
+        # type: () -> str
+        assert self.source_dir, "No source dir for {}".format(self)
+        return make_pyproject_path(self.unpacked_source_directory)
+
+    def load_pyproject_toml(self):
+        # type: () -> None
+        """Load the pyproject.toml file.
+
+        After calling this routine, all of the attributes related to PEP 517
+        processing for this requirement have been set. In particular, the
+        use_pep517 attribute can be used to determine whether we should
+        follow the PEP 517 or legacy (setup.py) code path.
+        """
+        pyproject_toml_data = load_pyproject_toml(
+            self.use_pep517,
+            self.pyproject_toml_path,
+            self.setup_py_path,
+            str(self)
+        )
+
+        if pyproject_toml_data is None:
+            self.use_pep517 = False
+            return
+
+        self.use_pep517 = True
+        requires, backend, check, backend_path = pyproject_toml_data
+        self.requirements_to_check = check
+        self.pyproject_requires = requires
+        self.pep517_backend = Pep517HookCaller(
+            self.unpacked_source_directory, backend, backend_path=backend_path,
+        )
+
+    def _generate_metadata(self):
+        # type: () -> str
+        """Invokes metadata generator functions, with the required arguments.
+        """
+        if not self.use_pep517:
+            assert self.unpacked_source_directory
+
+            return generate_metadata_legacy(
+                build_env=self.build_env,
+                setup_py_path=self.setup_py_path,
+                source_dir=self.unpacked_source_directory,
+                isolated=self.isolated,
+                details=self.name or "from {}".format(self.link)
+            )
+
+        assert self.pep517_backend is not None
+
+        return generate_metadata(
+            build_env=self.build_env,
+            backend=self.pep517_backend,
+        )
+
+    def prepare_metadata(self):
+        # type: () -> None
+        """Ensure that project metadata is available.
+
+        Under PEP 517, call the backend hook to prepare the metadata.
+        Under legacy processing, call setup.py egg-info.
+        """
+        assert self.source_dir
+
+        with indent_log():
+            self.metadata_directory = self._generate_metadata()
+
+        # Act on the newly generated metadata, based on the name and version.
+        if not self.name:
+            self._set_requirement()
+        else:
+            self.warn_on_mismatching_name()
+
+        self.assert_source_matches_version()
+
+    @property
+    def metadata(self):
+        # type: () -> Any
+        if not hasattr(self, '_metadata'):
+            self._metadata = get_metadata(self.get_dist())
+
+        return self._metadata
+
+    def get_dist(self):
+        # type: () -> Distribution
+        return _get_dist(self.metadata_directory)
+
+    def assert_source_matches_version(self):
+        # type: () -> None
+        assert self.source_dir
+        version = self.metadata['version']
+        if self.req.specifier and version not in self.req.specifier:
+            logger.warning(
+                'Requested %s, but installing version %s',
+                self,
+                version,
+            )
+        else:
+            logger.debug(
+                'Source in %s has version %s, which satisfies requirement %s',
+                display_path(self.source_dir),
+                version,
+                self,
+            )
+
+    # For both source distributions and editables
+    def ensure_has_source_dir(
+        self,
+        parent_dir,
+        autodelete=False,
+        parallel_builds=False,
+    ):
+        # type: (str, bool, bool) -> None
+        """Ensure that a source_dir is set.
+
+        This will create a temporary build dir if the name of the requirement
+        isn't known yet.
+
+        :param parent_dir: The ideal pip parent_dir for the source_dir.
+            Generally src_dir for editables and build_dir for sdists.
+        :return: self.source_dir
+        """
+        if self.source_dir is None:
+            self.source_dir = self.ensure_build_location(
+                parent_dir,
+                autodelete=autodelete,
+                parallel_builds=parallel_builds,
+            )
+
+    # For editable installations
+    def update_editable(self, obtain=True):
+        # type: (bool) -> None
+        if not self.link:
+            logger.debug(
+                "Cannot update repository at %s; repository location is "
+                "unknown",
+                self.source_dir,
+            )
+            return
+        assert self.editable
+        assert self.source_dir
+        if self.link.scheme == 'file':
+            # Static paths don't get updated
+            return
+        assert '+' in self.link.url, \
+            "bad url: {self.link.url!r}".format(**locals())
+        vc_type, url = self.link.url.split('+', 1)
+        vcs_backend = vcs.get_backend(vc_type)
+        if vcs_backend:
+            if not self.link.is_vcs:
+                reason = (
+                    "This form of VCS requirement is being deprecated: {}."
+                ).format(
+                    self.link.url
+                )
+                replacement = None
+                if self.link.url.startswith("git+git@"):
+                    replacement = (
+                        "git+https://git@example.com/..., "
+                        "git+ssh://git@example.com/..., "
+                        "or the insecure git+git://git@example.com/..."
+                    )
+                deprecated(reason, replacement, gone_in="21.0", issue=7554)
+            hidden_url = hide_url(self.link.url)
+            if obtain:
+                vcs_backend.obtain(self.source_dir, url=hidden_url)
+            else:
+                vcs_backend.export(self.source_dir, url=hidden_url)
+        else:
+            assert 0, (
+                'Unexpected version control type (in {}): {}'.format(
+                    self.link, vc_type))
+
+    # Top-level Actions
+    def uninstall(self, auto_confirm=False, verbose=False):
+        # type: (bool, bool) -> Optional[UninstallPathSet]
+        """
+        Uninstall the distribution currently satisfying this requirement.
+
+        Prompts before removing or modifying files unless
+        ``auto_confirm`` is True.
+
+        Refuses to delete or modify files outside of ``sys.prefix`` -
+        thus uninstallation within a virtual environment can only
+        modify that virtual environment, even if the virtualenv is
+        linked to global site-packages.
+
+        """
+        assert self.req
+        dist = get_distribution(self.req.name)
+        if not dist:
+            logger.warning("Skipping %s as it is not installed.", self.name)
+            return None
+        logger.info('Found existing installation: %s', dist)
+
+        uninstalled_pathset = UninstallPathSet.from_dist(dist)
+        uninstalled_pathset.remove(auto_confirm, verbose)
+        return uninstalled_pathset
+
+    def _get_archive_name(self, path, parentdir, rootdir):
+        # type: (str, str, str) -> str
+
+        def _clean_zip_name(name, prefix):
+            # type: (str, str) -> str
+            assert name.startswith(prefix + os.path.sep), (
+                "name {name!r} doesn't start with prefix {prefix!r}"
+                .format(**locals())
+            )
+            name = name[len(prefix) + 1:]
+            name = name.replace(os.path.sep, '/')
+            return name
+
+        path = os.path.join(parentdir, path)
+        name = _clean_zip_name(path, rootdir)
+        return self.name + '/' + name
+
+    def archive(self, build_dir):
+        # type: (str) -> None
+        """Saves archive to provided build_dir.
+
+        Used for saving downloaded VCS requirements as part of `pip download`.
+        """
+        assert self.source_dir
+
+        create_archive = True
+        archive_name = '{}-{}.zip'.format(self.name, self.metadata["version"])
+        archive_path = os.path.join(build_dir, archive_name)
+
+        if os.path.exists(archive_path):
+            response = ask_path_exists(
+                'The file {} exists. (i)gnore, (w)ipe, '
+                '(b)ackup, (a)bort '.format(
+                    display_path(archive_path)),
+                ('i', 'w', 'b', 'a'))
+            if response == 'i':
+                create_archive = False
+            elif response == 'w':
+                logger.warning('Deleting %s', display_path(archive_path))
+                os.remove(archive_path)
+            elif response == 'b':
+                dest_file = backup_dir(archive_path)
+                logger.warning(
+                    'Backing up %s to %s',
+                    display_path(archive_path),
+                    display_path(dest_file),
+                )
+                shutil.move(archive_path, dest_file)
+            elif response == 'a':
+                sys.exit(-1)
+
+        if not create_archive:
+            return
+
+        zip_output = zipfile.ZipFile(
+            archive_path, 'w', zipfile.ZIP_DEFLATED, allowZip64=True,
+        )
+        with zip_output:
+            dir = os.path.normcase(
+                os.path.abspath(self.unpacked_source_directory)
+            )
+            for dirpath, dirnames, filenames in os.walk(dir):
+                for dirname in dirnames:
+                    dir_arcname = self._get_archive_name(
+                        dirname, parentdir=dirpath, rootdir=dir,
+                    )
+                    zipdir = zipfile.ZipInfo(dir_arcname + '/')
+                    zipdir.external_attr = 0x1ED << 16  # 0o755
+                    zip_output.writestr(zipdir, '')
+                for filename in filenames:
+                    file_arcname = self._get_archive_name(
+                        filename, parentdir=dirpath, rootdir=dir,
+                    )
+                    filename = os.path.join(dirpath, filename)
+                    zip_output.write(filename, file_arcname)
+
+        logger.info('Saved %s', display_path(archive_path))
+
+    def install(
+        self,
+        install_options,  # type: List[str]
+        global_options=None,  # type: Optional[Sequence[str]]
+        root=None,  # type: Optional[str]
+        home=None,  # type: Optional[str]
+        prefix=None,  # type: Optional[str]
+        warn_script_location=True,  # type: bool
+        use_user_site=False,  # type: bool
+        pycompile=True  # type: bool
+    ):
+        # type: (...) -> None
+        scheme = get_scheme(
+            self.name,
+            user=use_user_site,
+            home=home,
+            root=root,
+            isolated=self.isolated,
+            prefix=prefix,
+        )
+
+        global_options = global_options if global_options is not None else []
+        if self.editable:
+            install_editable_legacy(
+                install_options,
+                global_options,
+                prefix=prefix,
+                home=home,
+                use_user_site=use_user_site,
+                name=self.name,
+                setup_py_path=self.setup_py_path,
+                isolated=self.isolated,
+                build_env=self.build_env,
+                unpacked_source_directory=self.unpacked_source_directory,
+            )
+            self.install_succeeded = True
+            return
+
+        if self.is_wheel:
+            assert self.local_file_path
+            direct_url = None
+            if self.original_link:
+                direct_url = direct_url_from_link(
+                    self.original_link,
+                    self.source_dir,
+                    self.original_link_is_in_wheel_cache,
+                )
+            install_wheel(
+                self.name,
+                self.local_file_path,
+                scheme=scheme,
+                req_description=str(self.req),
+                pycompile=pycompile,
+                warn_script_location=warn_script_location,
+                direct_url=direct_url,
+                requested=self.user_supplied,
+            )
+            self.install_succeeded = True
+            return
+
+        # TODO: Why don't we do this for editable installs?
+
+        # Extend the list of global and install options passed on to
+        # the setup.py call with the ones from the requirements file.
+        # Options specified in requirements file override those
+        # specified on the command line, since the last option given
+        # to setup.py is the one that is used.
+        global_options = list(global_options) + self.global_options
+        install_options = list(install_options) + self.install_options
+
+        try:
+            success = install_legacy(
+                install_options=install_options,
+                global_options=global_options,
+                root=root,
+                home=home,
+                prefix=prefix,
+                use_user_site=use_user_site,
+                pycompile=pycompile,
+                scheme=scheme,
+                setup_py_path=self.setup_py_path,
+                isolated=self.isolated,
+                req_name=self.name,
+                build_env=self.build_env,
+                unpacked_source_directory=self.unpacked_source_directory,
+                req_description=str(self.req),
+            )
+        except LegacyInstallFailure as exc:
+            self.install_succeeded = False
+            six.reraise(*exc.parent)
+        except Exception:
+            self.install_succeeded = True
+            raise
+
+        self.install_succeeded = success
+
+        if success and self.legacy_install_reason == 8368:
+            deprecated(
+                reason=(
+                    "{} was installed using the legacy 'setup.py install' "
+                    "method, because a wheel could not be built for it.".
+                    format(self.name)
+                ),
+                replacement="to fix the wheel build issue reported above",
+                gone_in="21.0",
+                issue=8368,
+            )
+
+
+def check_invalid_constraint_type(req):
+    # type: (InstallRequirement) -> str
+
+    # Check for unsupported forms
+    problem = ""
+    if not req.name:
+        problem = "Unnamed requirements are not allowed as constraints"
+    elif req.link:
+        problem = "Links are not allowed as constraints"
+    elif req.extras:
+        problem = "Constraints cannot have extras"
+
+    if problem:
+        deprecated(
+            reason=(
+                "Constraints are only allowed to take the form of a package "
+                "name and a version specifier. Other forms were originally "
+                "permitted as an accident of the implementation, but were "
+                "undocumented. The new implementation of the resolver no "
+                "longer supports these forms."
+            ),
+            replacement=(
+                "replacing the constraint with a requirement."
+            ),
+            # No plan yet for when the new resolver becomes default
+            gone_in=None,
+            issue=8210
+        )
+
+    return problem
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/req/req_set.py b/myenv/lib/python3.9/site-packages/pip/_internal/req/req_set.py
new file mode 100644
index 0000000..ab4b6f8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/req/req_set.py
@@ -0,0 +1,203 @@
+from __future__ import absolute_import
+
+import logging
+from collections import OrderedDict
+
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.models.wheel import Wheel
+from pip._internal.utils import compatibility_tags
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Dict, Iterable, List, Optional, Tuple
+    from pip._internal.req.req_install import InstallRequirement
+
+
+logger = logging.getLogger(__name__)
+
+
+class RequirementSet(object):
+
+    def __init__(self, check_supported_wheels=True):
+        # type: (bool) -> None
+        """Create a RequirementSet.
+        """
+
+        self.requirements = OrderedDict()  # type: Dict[str, InstallRequirement]  # noqa: E501
+        self.check_supported_wheels = check_supported_wheels
+
+        self.unnamed_requirements = []  # type: List[InstallRequirement]
+
+    def __str__(self):
+        # type: () -> str
+        requirements = sorted(
+            (req for req in self.requirements.values() if not req.comes_from),
+            key=lambda req: canonicalize_name(req.name),
+        )
+        return ' '.join(str(req.req) for req in requirements)
+
+    def __repr__(self):
+        # type: () -> str
+        requirements = sorted(
+            self.requirements.values(),
+            key=lambda req: canonicalize_name(req.name),
+        )
+
+        format_string = '<{classname} object; {count} requirement(s): {reqs}>'
+        return format_string.format(
+            classname=self.__class__.__name__,
+            count=len(requirements),
+            reqs=', '.join(str(req.req) for req in requirements),
+        )
+
+    def add_unnamed_requirement(self, install_req):
+        # type: (InstallRequirement) -> None
+        assert not install_req.name
+        self.unnamed_requirements.append(install_req)
+
+    def add_named_requirement(self, install_req):
+        # type: (InstallRequirement) -> None
+        assert install_req.name
+
+        project_name = canonicalize_name(install_req.name)
+        self.requirements[project_name] = install_req
+
+    def add_requirement(
+        self,
+        install_req,  # type: InstallRequirement
+        parent_req_name=None,  # type: Optional[str]
+        extras_requested=None  # type: Optional[Iterable[str]]
+    ):
+        # type: (...) -> Tuple[List[InstallRequirement], Optional[InstallRequirement]]  # noqa: E501
+        """Add install_req as a requirement to install.
+
+        :param parent_req_name: The name of the requirement that needed this
+            added. The name is used because when multiple unnamed requirements
+            resolve to the same name, we could otherwise end up with dependency
+            links that point outside the Requirements set. parent_req must
+            already be added. Note that None implies that this is a user
+            supplied requirement, vs an inferred one.
+        :param extras_requested: an iterable of extras used to evaluate the
+            environment markers.
+        :return: Additional requirements to scan. That is either [] if
+            the requirement is not applicable, or [install_req] if the
+            requirement is applicable and has just been added.
+        """
+        # If the markers do not match, ignore this requirement.
+        if not install_req.match_markers(extras_requested):
+            logger.info(
+                "Ignoring %s: markers '%s' don't match your environment",
+                install_req.name, install_req.markers,
+            )
+            return [], None
+
+        # If the wheel is not supported, raise an error.
+        # Should check this after filtering out based on environment markers to
+        # allow specifying different wheels based on the environment/OS, in a
+        # single requirements file.
+        if install_req.link and install_req.link.is_wheel:
+            wheel = Wheel(install_req.link.filename)
+            tags = compatibility_tags.get_supported()
+            if (self.check_supported_wheels and not wheel.supported(tags)):
+                raise InstallationError(
+                    "{} is not a supported wheel on this platform.".format(
+                        wheel.filename)
+                )
+
+        # This next bit is really a sanity check.
+        assert not install_req.user_supplied or parent_req_name is None, (
+            "a user supplied req shouldn't have a parent"
+        )
+
+        # Unnamed requirements are scanned again and the requirement won't be
+        # added as a dependency until after scanning.
+        if not install_req.name:
+            self.add_unnamed_requirement(install_req)
+            return [install_req], None
+
+        try:
+            existing_req = self.get_requirement(
+                install_req.name)  # type: Optional[InstallRequirement]
+        except KeyError:
+            existing_req = None
+
+        has_conflicting_requirement = (
+            parent_req_name is None and
+            existing_req and
+            not existing_req.constraint and
+            existing_req.extras == install_req.extras and
+            existing_req.req.specifier != install_req.req.specifier
+        )
+        if has_conflicting_requirement:
+            raise InstallationError(
+                "Double requirement given: {} (already in {}, name={!r})"
+                .format(install_req, existing_req, install_req.name)
+            )
+
+        # When no existing requirement exists, add the requirement as a
+        # dependency and it will be scanned again after.
+        if not existing_req:
+            self.add_named_requirement(install_req)
+            # We'd want to rescan this requirement later
+            return [install_req], install_req
+
+        # Assume there's no need to scan, and that we've already
+        # encountered this for scanning.
+        if install_req.constraint or not existing_req.constraint:
+            return [], existing_req
+
+        does_not_satisfy_constraint = (
+            install_req.link and
+            not (
+                existing_req.link and
+                install_req.link.path == existing_req.link.path
+            )
+        )
+        if does_not_satisfy_constraint:
+            raise InstallationError(
+                "Could not satisfy constraints for '{}': "
+                "installation from path or url cannot be "
+                "constrained to a version".format(install_req.name)
+            )
+        # If we're now installing a constraint, mark the existing
+        # object for real installation.
+        existing_req.constraint = False
+        # If we're now installing a user supplied requirement,
+        # mark the existing object as such.
+        if install_req.user_supplied:
+            existing_req.user_supplied = True
+        existing_req.extras = tuple(sorted(
+            set(existing_req.extras) | set(install_req.extras)
+        ))
+        logger.debug(
+            "Setting %s extras to: %s",
+            existing_req, existing_req.extras,
+        )
+        # Return the existing requirement for addition to the parent and
+        # scanning again.
+        return [existing_req], existing_req
+
+    def has_requirement(self, name):
+        # type: (str) -> bool
+        project_name = canonicalize_name(name)
+
+        return (
+            project_name in self.requirements and
+            not self.requirements[project_name].constraint
+        )
+
+    def get_requirement(self, name):
+        # type: (str) -> InstallRequirement
+        project_name = canonicalize_name(name)
+
+        if project_name in self.requirements:
+            return self.requirements[project_name]
+
+        raise KeyError("No project with the name {name!r}".format(**locals()))
+
+    @property
+    def all_requirements(self):
+        # type: () -> List[InstallRequirement]
+        return self.unnamed_requirements + list(self.requirements.values())
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/req/req_tracker.py b/myenv/lib/python3.9/site-packages/pip/_internal/req/req_tracker.py
new file mode 100644
index 0000000..13fb245
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/req/req_tracker.py
@@ -0,0 +1,150 @@
+from __future__ import absolute_import
+
+import contextlib
+import errno
+import hashlib
+import logging
+import os
+
+from pip._vendor import contextlib2
+
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from types import TracebackType
+    from typing import Dict, Iterator, Optional, Set, Type, Union
+    from pip._internal.req.req_install import InstallRequirement
+    from pip._internal.models.link import Link
+
+logger = logging.getLogger(__name__)
+
+
+@contextlib.contextmanager
+def update_env_context_manager(**changes):
+    # type: (str) -> Iterator[None]
+    target = os.environ
+
+    # Save values from the target and change them.
+    non_existent_marker = object()
+    saved_values = {}  # type: Dict[str, Union[object, str]]
+    for name, new_value in changes.items():
+        try:
+            saved_values[name] = target[name]
+        except KeyError:
+            saved_values[name] = non_existent_marker
+        target[name] = new_value
+
+    try:
+        yield
+    finally:
+        # Restore original values in the target.
+        for name, original_value in saved_values.items():
+            if original_value is non_existent_marker:
+                del target[name]
+            else:
+                assert isinstance(original_value, str)  # for mypy
+                target[name] = original_value
+
+
+@contextlib.contextmanager
+def get_requirement_tracker():
+    # type: () -> Iterator[RequirementTracker]
+    root = os.environ.get('PIP_REQ_TRACKER')
+    with contextlib2.ExitStack() as ctx:
+        if root is None:
+            root = ctx.enter_context(
+                TempDirectory(kind='req-tracker')
+            ).path
+            ctx.enter_context(update_env_context_manager(PIP_REQ_TRACKER=root))
+            logger.debug("Initialized build tracking at %s", root)
+
+        with RequirementTracker(root) as tracker:
+            yield tracker
+
+
+class RequirementTracker(object):
+
+    def __init__(self, root):
+        # type: (str) -> None
+        self._root = root
+        self._entries = set()  # type: Set[InstallRequirement]
+        logger.debug("Created build tracker: %s", self._root)
+
+    def __enter__(self):
+        # type: () -> RequirementTracker
+        logger.debug("Entered build tracker: %s", self._root)
+        return self
+
+    def __exit__(
+        self,
+        exc_type,  # type: Optional[Type[BaseException]]
+        exc_val,  # type: Optional[BaseException]
+        exc_tb  # type: Optional[TracebackType]
+    ):
+        # type: (...) -> None
+        self.cleanup()
+
+    def _entry_path(self, link):
+        # type: (Link) -> str
+        hashed = hashlib.sha224(link.url_without_fragment.encode()).hexdigest()
+        return os.path.join(self._root, hashed)
+
+    def add(self, req):
+        # type: (InstallRequirement) -> None
+        """Add an InstallRequirement to build tracking.
+        """
+
+        assert req.link
+        # Get the file to write information about this requirement.
+        entry_path = self._entry_path(req.link)
+
+        # Try reading from the file. If it exists and can be read from, a build
+        # is already in progress, so a LookupError is raised.
+        try:
+            with open(entry_path) as fp:
+                contents = fp.read()
+        except IOError as e:
+            # if the error is anything other than "file does not exist", raise.
+            if e.errno != errno.ENOENT:
+                raise
+        else:
+            message = '{} is already being built: {}'.format(
+                req.link, contents)
+            raise LookupError(message)
+
+        # If we're here, req should really not be building already.
+        assert req not in self._entries
+
+        # Start tracking this requirement.
+        with open(entry_path, 'w') as fp:
+            fp.write(str(req))
+        self._entries.add(req)
+
+        logger.debug('Added %s to build tracker %r', req, self._root)
+
+    def remove(self, req):
+        # type: (InstallRequirement) -> None
+        """Remove an InstallRequirement from build tracking.
+        """
+
+        assert req.link
+        # Delete the created file and the corresponding entries.
+        os.unlink(self._entry_path(req.link))
+        self._entries.remove(req)
+
+        logger.debug('Removed %s from build tracker %r', req, self._root)
+
+    def cleanup(self):
+        # type: () -> None
+        for req in set(self._entries):
+            self.remove(req)
+
+        logger.debug("Removed build tracker: %r", self._root)
+
+    @contextlib.contextmanager
+    def track(self, req):
+        # type: (InstallRequirement) -> Iterator[None]
+        self.add(req)
+        yield
+        self.remove(req)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/req/req_uninstall.py b/myenv/lib/python3.9/site-packages/pip/_internal/req/req_uninstall.py
new file mode 100644
index 0000000..69719d3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/req/req_uninstall.py
@@ -0,0 +1,648 @@
+from __future__ import absolute_import
+
+import csv
+import functools
+import logging
+import os
+import sys
+import sysconfig
+
+from pip._vendor import pkg_resources
+
+from pip._internal.exceptions import UninstallationError
+from pip._internal.locations import bin_py, bin_user
+from pip._internal.utils.compat import WINDOWS, cache_from_source, uses_pycache
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import (
+    FakeFile,
+    ask,
+    dist_in_usersite,
+    dist_is_local,
+    egg_link_path,
+    is_local,
+    normalize_path,
+    renames,
+    rmtree,
+)
+from pip._internal.utils.temp_dir import AdjacentTempDirectory, TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Any, Callable, Dict, Iterable, Iterator, List, Optional, Set, Tuple,
+    )
+    from pip._vendor.pkg_resources import Distribution
+
+logger = logging.getLogger(__name__)
+
+
+def _script_names(dist, script_name, is_gui):
+    # type: (Distribution, str, bool) -> List[str]
+    """Create the fully qualified name of the files created by
+    {console,gui}_scripts for the given ``dist``.
+    Returns the list of file names
+    """
+    if dist_in_usersite(dist):
+        bin_dir = bin_user
+    else:
+        bin_dir = bin_py
+    exe_name = os.path.join(bin_dir, script_name)
+    paths_to_remove = [exe_name]
+    if WINDOWS:
+        paths_to_remove.append(exe_name + '.exe')
+        paths_to_remove.append(exe_name + '.exe.manifest')
+        if is_gui:
+            paths_to_remove.append(exe_name + '-script.pyw')
+        else:
+            paths_to_remove.append(exe_name + '-script.py')
+    return paths_to_remove
+
+
+def _unique(fn):
+    # type: (Callable[..., Iterator[Any]]) -> Callable[..., Iterator[Any]]
+    @functools.wraps(fn)
+    def unique(*args, **kw):
+        # type: (Any, Any) -> Iterator[Any]
+        seen = set()  # type: Set[Any]
+        for item in fn(*args, **kw):
+            if item not in seen:
+                seen.add(item)
+                yield item
+    return unique
+
+
+@_unique
+def uninstallation_paths(dist):
+    # type: (Distribution) -> Iterator[str]
+    """
+    Yield all the uninstallation paths for dist based on RECORD-without-.py[co]
+
+    Yield paths to all the files in RECORD. For each .py file in RECORD, add
+    the .pyc and .pyo in the same directory.
+
+    UninstallPathSet.add() takes care of the __pycache__ .py[co].
+    """
+    r = csv.reader(FakeFile(dist.get_metadata_lines('RECORD')))
+    for row in r:
+        path = os.path.join(dist.location, row[0])
+        yield path
+        if path.endswith('.py'):
+            dn, fn = os.path.split(path)
+            base = fn[:-3]
+            path = os.path.join(dn, base + '.pyc')
+            yield path
+            path = os.path.join(dn, base + '.pyo')
+            yield path
+
+
+def compact(paths):
+    # type: (Iterable[str]) -> Set[str]
+    """Compact a path set to contain the minimal number of paths
+    necessary to contain all paths in the set. If /a/path/ and
+    /a/path/to/a/file.txt are both in the set, leave only the
+    shorter path."""
+
+    sep = os.path.sep
+    short_paths = set()  # type: Set[str]
+    for path in sorted(paths, key=len):
+        should_skip = any(
+            path.startswith(shortpath.rstrip("*")) and
+            path[len(shortpath.rstrip("*").rstrip(sep))] == sep
+            for shortpath in short_paths
+        )
+        if not should_skip:
+            short_paths.add(path)
+    return short_paths
+
+
+def compress_for_rename(paths):
+    # type: (Iterable[str]) -> Set[str]
+    """Returns a set containing the paths that need to be renamed.
+
+    This set may include directories when the original sequence of paths
+    included every file on disk.
+    """
+    case_map = dict((os.path.normcase(p), p) for p in paths)
+    remaining = set(case_map)
+    unchecked = sorted(set(os.path.split(p)[0]
+                           for p in case_map.values()), key=len)
+    wildcards = set()  # type: Set[str]
+
+    def norm_join(*a):
+        # type: (str) -> str
+        return os.path.normcase(os.path.join(*a))
+
+    for root in unchecked:
+        if any(os.path.normcase(root).startswith(w)
+               for w in wildcards):
+            # This directory has already been handled.
+            continue
+
+        all_files = set()  # type: Set[str]
+        all_subdirs = set()  # type: Set[str]
+        for dirname, subdirs, files in os.walk(root):
+            all_subdirs.update(norm_join(root, dirname, d)
+                               for d in subdirs)
+            all_files.update(norm_join(root, dirname, f)
+                             for f in files)
+        # If all the files we found are in our remaining set of files to
+        # remove, then remove them from the latter set and add a wildcard
+        # for the directory.
+        if not (all_files - remaining):
+            remaining.difference_update(all_files)
+            wildcards.add(root + os.sep)
+
+    return set(map(case_map.__getitem__, remaining)) | wildcards
+
+
+def compress_for_output_listing(paths):
+    # type: (Iterable[str]) -> Tuple[Set[str], Set[str]]
+    """Returns a tuple of 2 sets of which paths to display to user
+
+    The first set contains paths that would be deleted. Files of a package
+    are not added and the top-level directory of the package has a '*' added
+    at the end - to signify that all it's contents are removed.
+
+    The second set contains files that would have been skipped in the above
+    folders.
+    """
+
+    will_remove = set(paths)
+    will_skip = set()
+
+    # Determine folders and files
+    folders = set()
+    files = set()
+    for path in will_remove:
+        if path.endswith(".pyc"):
+            continue
+        if path.endswith("__init__.py") or ".dist-info" in path:
+            folders.add(os.path.dirname(path))
+        files.add(path)
+
+    # probably this one https://github.com/python/mypy/issues/390
+    _normcased_files = set(map(os.path.normcase, files))  # type: ignore
+
+    folders = compact(folders)
+
+    # This walks the tree using os.walk to not miss extra folders
+    # that might get added.
+    for folder in folders:
+        for dirpath, _, dirfiles in os.walk(folder):
+            for fname in dirfiles:
+                if fname.endswith(".pyc"):
+                    continue
+
+                file_ = os.path.join(dirpath, fname)
+                if (os.path.isfile(file_) and
+                        os.path.normcase(file_) not in _normcased_files):
+                    # We are skipping this file. Add it to the set.
+                    will_skip.add(file_)
+
+    will_remove = files | {
+        os.path.join(folder, "*") for folder in folders
+    }
+
+    return will_remove, will_skip
+
+
+class StashedUninstallPathSet(object):
+    """A set of file rename operations to stash files while
+    tentatively uninstalling them."""
+    def __init__(self):
+        # type: () -> None
+        # Mapping from source file root to [Adjacent]TempDirectory
+        # for files under that directory.
+        self._save_dirs = {}  # type: Dict[str, TempDirectory]
+        # (old path, new path) tuples for each move that may need
+        # to be undone.
+        self._moves = []  # type: List[Tuple[str, str]]
+
+    def _get_directory_stash(self, path):
+        # type: (str) -> str
+        """Stashes a directory.
+
+        Directories are stashed adjacent to their original location if
+        possible, or else moved/copied into the user's temp dir."""
+
+        try:
+            save_dir = AdjacentTempDirectory(path)  # type: TempDirectory
+        except OSError:
+            save_dir = TempDirectory(kind="uninstall")
+        self._save_dirs[os.path.normcase(path)] = save_dir
+
+        return save_dir.path
+
+    def _get_file_stash(self, path):
+        # type: (str) -> str
+        """Stashes a file.
+
+        If no root has been provided, one will be created for the directory
+        in the user's temp directory."""
+        path = os.path.normcase(path)
+        head, old_head = os.path.dirname(path), None
+        save_dir = None
+
+        while head != old_head:
+            try:
+                save_dir = self._save_dirs[head]
+                break
+            except KeyError:
+                pass
+            head, old_head = os.path.dirname(head), head
+        else:
+            # Did not find any suitable root
+            head = os.path.dirname(path)
+            save_dir = TempDirectory(kind='uninstall')
+            self._save_dirs[head] = save_dir
+
+        relpath = os.path.relpath(path, head)
+        if relpath and relpath != os.path.curdir:
+            return os.path.join(save_dir.path, relpath)
+        return save_dir.path
+
+    def stash(self, path):
+        # type: (str) -> str
+        """Stashes the directory or file and returns its new location.
+        Handle symlinks as files to avoid modifying the symlink targets.
+        """
+        path_is_dir = os.path.isdir(path) and not os.path.islink(path)
+        if path_is_dir:
+            new_path = self._get_directory_stash(path)
+        else:
+            new_path = self._get_file_stash(path)
+
+        self._moves.append((path, new_path))
+        if (path_is_dir and os.path.isdir(new_path)):
+            # If we're moving a directory, we need to
+            # remove the destination first or else it will be
+            # moved to inside the existing directory.
+            # We just created new_path ourselves, so it will
+            # be removable.
+            os.rmdir(new_path)
+        renames(path, new_path)
+        return new_path
+
+    def commit(self):
+        # type: () -> None
+        """Commits the uninstall by removing stashed files."""
+        for _, save_dir in self._save_dirs.items():
+            save_dir.cleanup()
+        self._moves = []
+        self._save_dirs = {}
+
+    def rollback(self):
+        # type: () -> None
+        """Undoes the uninstall by moving stashed files back."""
+        for p in self._moves:
+            logger.info("Moving to %s\n from %s", *p)
+
+        for new_path, path in self._moves:
+            try:
+                logger.debug('Replacing %s from %s', new_path, path)
+                if os.path.isfile(new_path) or os.path.islink(new_path):
+                    os.unlink(new_path)
+                elif os.path.isdir(new_path):
+                    rmtree(new_path)
+                renames(path, new_path)
+            except OSError as ex:
+                logger.error("Failed to restore %s", new_path)
+                logger.debug("Exception: %s", ex)
+
+        self.commit()
+
+    @property
+    def can_rollback(self):
+        # type: () -> bool
+        return bool(self._moves)
+
+
+class UninstallPathSet(object):
+    """A set of file paths to be removed in the uninstallation of a
+    requirement."""
+    def __init__(self, dist):
+        # type: (Distribution) -> None
+        self.paths = set()  # type: Set[str]
+        self._refuse = set()  # type: Set[str]
+        self.pth = {}  # type: Dict[str, UninstallPthEntries]
+        self.dist = dist
+        self._moved_paths = StashedUninstallPathSet()
+
+    def _permitted(self, path):
+        # type: (str) -> bool
+        """
+        Return True if the given path is one we are permitted to
+        remove/modify, False otherwise.
+
+        """
+        return is_local(path)
+
+    def add(self, path):
+        # type: (str) -> None
+        head, tail = os.path.split(path)
+
+        # we normalize the head to resolve parent directory symlinks, but not
+        # the tail, since we only want to uninstall symlinks, not their targets
+        path = os.path.join(normalize_path(head), os.path.normcase(tail))
+
+        if not os.path.exists(path):
+            return
+        if self._permitted(path):
+            self.paths.add(path)
+        else:
+            self._refuse.add(path)
+
+        # __pycache__ files can show up after 'installed-files.txt' is created,
+        # due to imports
+        if os.path.splitext(path)[1] == '.py' and uses_pycache:
+            self.add(cache_from_source(path))
+
+    def add_pth(self, pth_file, entry):
+        # type: (str, str) -> None
+        pth_file = normalize_path(pth_file)
+        if self._permitted(pth_file):
+            if pth_file not in self.pth:
+                self.pth[pth_file] = UninstallPthEntries(pth_file)
+            self.pth[pth_file].add(entry)
+        else:
+            self._refuse.add(pth_file)
+
+    def remove(self, auto_confirm=False, verbose=False):
+        # type: (bool, bool) -> None
+        """Remove paths in ``self.paths`` with confirmation (unless
+        ``auto_confirm`` is True)."""
+
+        if not self.paths:
+            logger.info(
+                "Can't uninstall '%s'. No files were found to uninstall.",
+                self.dist.project_name,
+            )
+            return
+
+        dist_name_version = (
+            self.dist.project_name + "-" + self.dist.version
+        )
+        logger.info('Uninstalling %s:', dist_name_version)
+
+        with indent_log():
+            if auto_confirm or self._allowed_to_proceed(verbose):
+                moved = self._moved_paths
+
+                for_rename = compress_for_rename(self.paths)
+
+                for path in sorted(compact(for_rename)):
+                    moved.stash(path)
+                    logger.debug('Removing file or directory %s', path)
+
+                for pth in self.pth.values():
+                    pth.remove()
+
+                logger.info('Successfully uninstalled %s', dist_name_version)
+
+    def _allowed_to_proceed(self, verbose):
+        # type: (bool) -> bool
+        """Display which files would be deleted and prompt for confirmation
+        """
+
+        def _display(msg, paths):
+            # type: (str, Iterable[str]) -> None
+            if not paths:
+                return
+
+            logger.info(msg)
+            with indent_log():
+                for path in sorted(compact(paths)):
+                    logger.info(path)
+
+        if not verbose:
+            will_remove, will_skip = compress_for_output_listing(self.paths)
+        else:
+            # In verbose mode, display all the files that are going to be
+            # deleted.
+            will_remove = set(self.paths)
+            will_skip = set()
+
+        _display('Would remove:', will_remove)
+        _display('Would not remove (might be manually added):', will_skip)
+        _display('Would not remove (outside of prefix):', self._refuse)
+        if verbose:
+            _display('Will actually move:', compress_for_rename(self.paths))
+
+        return ask('Proceed (y/n)? ', ('y', 'n')) == 'y'
+
+    def rollback(self):
+        # type: () -> None
+        """Rollback the changes previously made by remove()."""
+        if not self._moved_paths.can_rollback:
+            logger.error(
+                "Can't roll back %s; was not uninstalled",
+                self.dist.project_name,
+            )
+            return
+        logger.info('Rolling back uninstall of %s', self.dist.project_name)
+        self._moved_paths.rollback()
+        for pth in self.pth.values():
+            pth.rollback()
+
+    def commit(self):
+        # type: () -> None
+        """Remove temporary save dir: rollback will no longer be possible."""
+        self._moved_paths.commit()
+
+    @classmethod
+    def from_dist(cls, dist):
+        # type: (Distribution) -> UninstallPathSet
+        dist_path = normalize_path(dist.location)
+        if not dist_is_local(dist):
+            logger.info(
+                "Not uninstalling %s at %s, outside environment %s",
+                dist.key,
+                dist_path,
+                sys.prefix,
+            )
+            return cls(dist)
+
+        if dist_path in {p for p in {sysconfig.get_path("stdlib"),
+                                     sysconfig.get_path("platstdlib")}
+                         if p}:
+            logger.info(
+                "Not uninstalling %s at %s, as it is in the standard library.",
+                dist.key,
+                dist_path,
+            )
+            return cls(dist)
+
+        paths_to_remove = cls(dist)
+        develop_egg_link = egg_link_path(dist)
+        develop_egg_link_egg_info = '{}.egg-info'.format(
+            pkg_resources.to_filename(dist.project_name))
+        egg_info_exists = dist.egg_info and os.path.exists(dist.egg_info)
+        # Special case for distutils installed package
+        distutils_egg_info = getattr(dist._provider, 'path', None)
+
+        # Uninstall cases order do matter as in the case of 2 installs of the
+        # same package, pip needs to uninstall the currently detected version
+        if (egg_info_exists and dist.egg_info.endswith('.egg-info') and
+                not dist.egg_info.endswith(develop_egg_link_egg_info)):
+            # if dist.egg_info.endswith(develop_egg_link_egg_info), we
+            # are in fact in the develop_egg_link case
+            paths_to_remove.add(dist.egg_info)
+            if dist.has_metadata('installed-files.txt'):
+                for installed_file in dist.get_metadata(
+                        'installed-files.txt').splitlines():
+                    path = os.path.normpath(
+                        os.path.join(dist.egg_info, installed_file)
+                    )
+                    paths_to_remove.add(path)
+            # FIXME: need a test for this elif block
+            # occurs with --single-version-externally-managed/--record outside
+            # of pip
+            elif dist.has_metadata('top_level.txt'):
+                if dist.has_metadata('namespace_packages.txt'):
+                    namespaces = dist.get_metadata('namespace_packages.txt')
+                else:
+                    namespaces = []
+                for top_level_pkg in [
+                        p for p
+                        in dist.get_metadata('top_level.txt').splitlines()
+                        if p and p not in namespaces]:
+                    path = os.path.join(dist.location, top_level_pkg)
+                    paths_to_remove.add(path)
+                    paths_to_remove.add(path + '.py')
+                    paths_to_remove.add(path + '.pyc')
+                    paths_to_remove.add(path + '.pyo')
+
+        elif distutils_egg_info:
+            raise UninstallationError(
+                "Cannot uninstall {!r}. It is a distutils installed project "
+                "and thus we cannot accurately determine which files belong "
+                "to it which would lead to only a partial uninstall.".format(
+                    dist.project_name,
+                )
+            )
+
+        elif dist.location.endswith('.egg'):
+            # package installed by easy_install
+            # We cannot match on dist.egg_name because it can slightly vary
+            # i.e. setuptools-0.6c11-py2.6.egg vs setuptools-0.6rc11-py2.6.egg
+            paths_to_remove.add(dist.location)
+            easy_install_egg = os.path.split(dist.location)[1]
+            easy_install_pth = os.path.join(os.path.dirname(dist.location),
+                                            'easy-install.pth')
+            paths_to_remove.add_pth(easy_install_pth, './' + easy_install_egg)
+
+        elif egg_info_exists and dist.egg_info.endswith('.dist-info'):
+            for path in uninstallation_paths(dist):
+                paths_to_remove.add(path)
+
+        elif develop_egg_link:
+            # develop egg
+            with open(develop_egg_link, 'r') as fh:
+                link_pointer = os.path.normcase(fh.readline().strip())
+            assert (link_pointer == dist.location), (
+                'Egg-link {} does not match installed location of {} '
+                '(at {})'.format(
+                    link_pointer, dist.project_name, dist.location)
+            )
+            paths_to_remove.add(develop_egg_link)
+            easy_install_pth = os.path.join(os.path.dirname(develop_egg_link),
+                                            'easy-install.pth')
+            paths_to_remove.add_pth(easy_install_pth, dist.location)
+
+        else:
+            logger.debug(
+                'Not sure how to uninstall: %s - Check: %s',
+                dist, dist.location,
+            )
+
+        # find distutils scripts= scripts
+        if dist.has_metadata('scripts') and dist.metadata_isdir('scripts'):
+            for script in dist.metadata_listdir('scripts'):
+                if dist_in_usersite(dist):
+                    bin_dir = bin_user
+                else:
+                    bin_dir = bin_py
+                paths_to_remove.add(os.path.join(bin_dir, script))
+                if WINDOWS:
+                    paths_to_remove.add(os.path.join(bin_dir, script) + '.bat')
+
+        # find console_scripts
+        _scripts_to_remove = []
+        console_scripts = dist.get_entry_map(group='console_scripts')
+        for name in console_scripts.keys():
+            _scripts_to_remove.extend(_script_names(dist, name, False))
+        # find gui_scripts
+        gui_scripts = dist.get_entry_map(group='gui_scripts')
+        for name in gui_scripts.keys():
+            _scripts_to_remove.extend(_script_names(dist, name, True))
+
+        for s in _scripts_to_remove:
+            paths_to_remove.add(s)
+
+        return paths_to_remove
+
+
+class UninstallPthEntries(object):
+    def __init__(self, pth_file):
+        # type: (str) -> None
+        self.file = pth_file
+        self.entries = set()  # type: Set[str]
+        self._saved_lines = None  # type: Optional[List[bytes]]
+
+    def add(self, entry):
+        # type: (str) -> None
+        entry = os.path.normcase(entry)
+        # On Windows, os.path.normcase converts the entry to use
+        # backslashes.  This is correct for entries that describe absolute
+        # paths outside of site-packages, but all the others use forward
+        # slashes.
+        # os.path.splitdrive is used instead of os.path.isabs because isabs
+        # treats non-absolute paths with drive letter markings like c:foo\bar
+        # as absolute paths. It also does not recognize UNC paths if they don't
+        # have more than "\\sever\share". Valid examples: "\\server\share\" or
+        # "\\server\share\folder". Python 2.7.8+ support UNC in splitdrive.
+        if WINDOWS and not os.path.splitdrive(entry)[0]:
+            entry = entry.replace('\\', '/')
+        self.entries.add(entry)
+
+    def remove(self):
+        # type: () -> None
+        logger.debug('Removing pth entries from %s:', self.file)
+
+        # If the file doesn't exist, log a warning and return
+        if not os.path.isfile(self.file):
+            logger.warning(
+                "Cannot remove entries from nonexistent file %s", self.file
+            )
+            return
+        with open(self.file, 'rb') as fh:
+            # windows uses '\r\n' with py3k, but uses '\n' with py2.x
+            lines = fh.readlines()
+            self._saved_lines = lines
+        if any(b'\r\n' in line for line in lines):
+            endline = '\r\n'
+        else:
+            endline = '\n'
+        # handle missing trailing newline
+        if lines and not lines[-1].endswith(endline.encode("utf-8")):
+            lines[-1] = lines[-1] + endline.encode("utf-8")
+        for entry in self.entries:
+            try:
+                logger.debug('Removing entry: %s', entry)
+                lines.remove((entry + endline).encode("utf-8"))
+            except ValueError:
+                pass
+        with open(self.file, 'wb') as fh:
+            fh.writelines(lines)
+
+    def rollback(self):
+        # type: () -> bool
+        if self._saved_lines is None:
+            logger.error(
+                'Cannot roll back changes to %s, none were made', self.file
+            )
+            return False
+        logger.debug('Rolling %s back to previous state', self.file)
+        with open(self.file, 'wb') as fh:
+            fh.writelines(self._saved_lines)
+        return True
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/resolution/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/resolution/base.py b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/base.py
new file mode 100644
index 0000000..2fa118b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/base.py
@@ -0,0 +1,20 @@
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Callable, List
+    from pip._internal.req.req_install import InstallRequirement
+    from pip._internal.req.req_set import RequirementSet
+
+    InstallRequirementProvider = Callable[
+        [str, InstallRequirement], InstallRequirement
+    ]
+
+
+class BaseResolver(object):
+    def resolve(self, root_reqs, check_supported_wheels):
+        # type: (List[InstallRequirement], bool) -> RequirementSet
+        raise NotImplementedError()
+
+    def get_installation_order(self, req_set):
+        # type: (RequirementSet) -> List[InstallRequirement]
+        raise NotImplementedError()
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/resolution/legacy/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/legacy/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/resolution/legacy/resolver.py b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/legacy/resolver.py
new file mode 100644
index 0000000..c9b4c66
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/legacy/resolver.py
@@ -0,0 +1,485 @@
+"""Dependency Resolution
+
+The dependency resolution in pip is performed as follows:
+
+for top-level requirements:
+    a. only one spec allowed per project, regardless of conflicts or not.
+       otherwise a "double requirement" exception is raised
+    b. they override sub-dependency requirements.
+for sub-dependencies
+    a. "first found, wins" (where the order is breadth first)
+"""
+
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
+# mypy: disallow-untyped-defs=False
+
+import logging
+import sys
+from collections import defaultdict
+from itertools import chain
+
+from pip._vendor.packaging import specifiers
+
+from pip._internal.exceptions import (
+    BestVersionAlreadyInstalled,
+    DistributionNotFound,
+    HashError,
+    HashErrors,
+    UnsupportedPythonVersion,
+)
+from pip._internal.req.req_install import check_invalid_constraint_type
+from pip._internal.req.req_set import RequirementSet
+from pip._internal.resolution.base import BaseResolver
+from pip._internal.utils.compatibility_tags import get_supported
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import dist_in_usersite, normalize_version_info
+from pip._internal.utils.packaging import (
+    check_requires_python,
+    get_requires_python,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import DefaultDict, List, Optional, Set, Tuple
+    from pip._vendor import pkg_resources
+
+    from pip._internal.cache import WheelCache
+    from pip._internal.distributions import AbstractDistribution
+    from pip._internal.index.package_finder import PackageFinder
+    from pip._internal.models.link import Link
+    from pip._internal.operations.prepare import RequirementPreparer
+    from pip._internal.req.req_install import InstallRequirement
+    from pip._internal.resolution.base import InstallRequirementProvider
+
+    DiscoveredDependencies = DefaultDict[str, List[InstallRequirement]]
+
+logger = logging.getLogger(__name__)
+
+
+def _check_dist_requires_python(
+    dist,  # type: pkg_resources.Distribution
+    version_info,  # type: Tuple[int, int, int]
+    ignore_requires_python=False,  # type: bool
+):
+    # type: (...) -> None
+    """
+    Check whether the given Python version is compatible with a distribution's
+    "Requires-Python" value.
+
+    :param version_info: A 3-tuple of ints representing the Python
+        major-minor-micro version to check.
+    :param ignore_requires_python: Whether to ignore the "Requires-Python"
+        value if the given Python version isn't compatible.
+
+    :raises UnsupportedPythonVersion: When the given Python version isn't
+        compatible.
+    """
+    requires_python = get_requires_python(dist)
+    try:
+        is_compatible = check_requires_python(
+            requires_python, version_info=version_info,
+        )
+    except specifiers.InvalidSpecifier as exc:
+        logger.warning(
+            "Package %r has an invalid Requires-Python: %s",
+            dist.project_name, exc,
+        )
+        return
+
+    if is_compatible:
+        return
+
+    version = '.'.join(map(str, version_info))
+    if ignore_requires_python:
+        logger.debug(
+            'Ignoring failed Requires-Python check for package %r: '
+            '%s not in %r',
+            dist.project_name, version, requires_python,
+        )
+        return
+
+    raise UnsupportedPythonVersion(
+        'Package {!r} requires a different Python: {} not in {!r}'.format(
+            dist.project_name, version, requires_python,
+        ))
+
+
+class Resolver(BaseResolver):
+    """Resolves which packages need to be installed/uninstalled to perform \
+    the requested operation without breaking the requirements of any package.
+    """
+
+    _allowed_strategies = {"eager", "only-if-needed", "to-satisfy-only"}
+
+    def __init__(
+        self,
+        preparer,  # type: RequirementPreparer
+        finder,  # type: PackageFinder
+        wheel_cache,  # type: Optional[WheelCache]
+        make_install_req,  # type: InstallRequirementProvider
+        use_user_site,  # type: bool
+        ignore_dependencies,  # type: bool
+        ignore_installed,  # type: bool
+        ignore_requires_python,  # type: bool
+        force_reinstall,  # type: bool
+        upgrade_strategy,  # type: str
+        py_version_info=None,  # type: Optional[Tuple[int, ...]]
+    ):
+        # type: (...) -> None
+        super(Resolver, self).__init__()
+        assert upgrade_strategy in self._allowed_strategies
+
+        if py_version_info is None:
+            py_version_info = sys.version_info[:3]
+        else:
+            py_version_info = normalize_version_info(py_version_info)
+
+        self._py_version_info = py_version_info
+
+        self.preparer = preparer
+        self.finder = finder
+        self.wheel_cache = wheel_cache
+
+        self.upgrade_strategy = upgrade_strategy
+        self.force_reinstall = force_reinstall
+        self.ignore_dependencies = ignore_dependencies
+        self.ignore_installed = ignore_installed
+        self.ignore_requires_python = ignore_requires_python
+        self.use_user_site = use_user_site
+        self._make_install_req = make_install_req
+
+        self._discovered_dependencies = \
+            defaultdict(list)  # type: DiscoveredDependencies
+
+    def resolve(self, root_reqs, check_supported_wheels):
+        # type: (List[InstallRequirement], bool) -> RequirementSet
+        """Resolve what operations need to be done
+
+        As a side-effect of this method, the packages (and their dependencies)
+        are downloaded, unpacked and prepared for installation. This
+        preparation is done by ``pip.operations.prepare``.
+
+        Once PyPI has static dependency metadata available, it would be
+        possible to move the preparation to become a step separated from
+        dependency resolution.
+        """
+        requirement_set = RequirementSet(
+            check_supported_wheels=check_supported_wheels
+        )
+        for req in root_reqs:
+            if req.constraint:
+                check_invalid_constraint_type(req)
+            requirement_set.add_requirement(req)
+
+        # Actually prepare the files, and collect any exceptions. Most hash
+        # exceptions cannot be checked ahead of time, because
+        # _populate_link() needs to be called before we can make decisions
+        # based on link type.
+        discovered_reqs = []  # type: List[InstallRequirement]
+        hash_errors = HashErrors()
+        for req in chain(requirement_set.all_requirements, discovered_reqs):
+            try:
+                discovered_reqs.extend(self._resolve_one(requirement_set, req))
+            except HashError as exc:
+                exc.req = req
+                hash_errors.append(exc)
+
+        if hash_errors:
+            raise hash_errors
+
+        return requirement_set
+
+    def _is_upgrade_allowed(self, req):
+        # type: (InstallRequirement) -> bool
+        if self.upgrade_strategy == "to-satisfy-only":
+            return False
+        elif self.upgrade_strategy == "eager":
+            return True
+        else:
+            assert self.upgrade_strategy == "only-if-needed"
+            return req.user_supplied or req.constraint
+
+    def _set_req_to_reinstall(self, req):
+        # type: (InstallRequirement) -> None
+        """
+        Set a requirement to be installed.
+        """
+        # Don't uninstall the conflict if doing a user install and the
+        # conflict is not a user install.
+        if not self.use_user_site or dist_in_usersite(req.satisfied_by):
+            req.should_reinstall = True
+        req.satisfied_by = None
+
+    def _check_skip_installed(self, req_to_install):
+        # type: (InstallRequirement) -> Optional[str]
+        """Check if req_to_install should be skipped.
+
+        This will check if the req is installed, and whether we should upgrade
+        or reinstall it, taking into account all the relevant user options.
+
+        After calling this req_to_install will only have satisfied_by set to
+        None if the req_to_install is to be upgraded/reinstalled etc. Any
+        other value will be a dist recording the current thing installed that
+        satisfies the requirement.
+
+        Note that for vcs urls and the like we can't assess skipping in this
+        routine - we simply identify that we need to pull the thing down,
+        then later on it is pulled down and introspected to assess upgrade/
+        reinstalls etc.
+
+        :return: A text reason for why it was skipped, or None.
+        """
+        if self.ignore_installed:
+            return None
+
+        req_to_install.check_if_exists(self.use_user_site)
+        if not req_to_install.satisfied_by:
+            return None
+
+        if self.force_reinstall:
+            self._set_req_to_reinstall(req_to_install)
+            return None
+
+        if not self._is_upgrade_allowed(req_to_install):
+            if self.upgrade_strategy == "only-if-needed":
+                return 'already satisfied, skipping upgrade'
+            return 'already satisfied'
+
+        # Check for the possibility of an upgrade.  For link-based
+        # requirements we have to pull the tree down and inspect to assess
+        # the version #, so it's handled way down.
+        if not req_to_install.link:
+            try:
+                self.finder.find_requirement(req_to_install, upgrade=True)
+            except BestVersionAlreadyInstalled:
+                # Then the best version is installed.
+                return 'already up-to-date'
+            except DistributionNotFound:
+                # No distribution found, so we squash the error.  It will
+                # be raised later when we re-try later to do the install.
+                # Why don't we just raise here?
+                pass
+
+        self._set_req_to_reinstall(req_to_install)
+        return None
+
+    def _find_requirement_link(self, req):
+        # type: (InstallRequirement) -> Optional[Link]
+        upgrade = self._is_upgrade_allowed(req)
+        best_candidate = self.finder.find_requirement(req, upgrade)
+        if not best_candidate:
+            return None
+
+        # Log a warning per PEP 592 if necessary before returning.
+        link = best_candidate.link
+        if link.is_yanked:
+            reason = link.yanked_reason or '<none given>'
+            msg = (
+                # Mark this as a unicode string to prevent
+                # "UnicodeEncodeError: 'ascii' codec can't encode character"
+                # in Python 2 when the reason contains non-ascii characters.
+                u'The candidate selected for download or install is a '
+                'yanked version: {candidate}\n'
+                'Reason for being yanked: {reason}'
+            ).format(candidate=best_candidate, reason=reason)
+            logger.warning(msg)
+
+        return link
+
+    def _populate_link(self, req):
+        # type: (InstallRequirement) -> None
+        """Ensure that if a link can be found for this, that it is found.
+
+        Note that req.link may still be None - if the requirement is already
+        installed and not needed to be upgraded based on the return value of
+        _is_upgrade_allowed().
+
+        If preparer.require_hashes is True, don't use the wheel cache, because
+        cached wheels, always built locally, have different hashes than the
+        files downloaded from the index server and thus throw false hash
+        mismatches. Furthermore, cached wheels at present have undeterministic
+        contents due to file modification times.
+        """
+        if req.link is None:
+            req.link = self._find_requirement_link(req)
+
+        if self.wheel_cache is None or self.preparer.require_hashes:
+            return
+        cache_entry = self.wheel_cache.get_cache_entry(
+            link=req.link,
+            package_name=req.name,
+            supported_tags=get_supported(),
+        )
+        if cache_entry is not None:
+            logger.debug('Using cached wheel link: %s', cache_entry.link)
+            if req.link is req.original_link and cache_entry.persistent:
+                req.original_link_is_in_wheel_cache = True
+            req.link = cache_entry.link
+
+    def _get_abstract_dist_for(self, req):
+        # type: (InstallRequirement) -> AbstractDistribution
+        """Takes a InstallRequirement and returns a single AbstractDist \
+        representing a prepared variant of the same.
+        """
+        if req.editable:
+            return self.preparer.prepare_editable_requirement(req)
+
+        # satisfied_by is only evaluated by calling _check_skip_installed,
+        # so it must be None here.
+        assert req.satisfied_by is None
+        skip_reason = self._check_skip_installed(req)
+
+        if req.satisfied_by:
+            return self.preparer.prepare_installed_requirement(
+                req, skip_reason
+            )
+
+        # We eagerly populate the link, since that's our "legacy" behavior.
+        self._populate_link(req)
+        abstract_dist = self.preparer.prepare_linked_requirement(req)
+
+        # NOTE
+        # The following portion is for determining if a certain package is
+        # going to be re-installed/upgraded or not and reporting to the user.
+        # This should probably get cleaned up in a future refactor.
+
+        # req.req is only avail after unpack for URL
+        # pkgs repeat check_if_exists to uninstall-on-upgrade
+        # (#14)
+        if not self.ignore_installed:
+            req.check_if_exists(self.use_user_site)
+
+        if req.satisfied_by:
+            should_modify = (
+                self.upgrade_strategy != "to-satisfy-only" or
+                self.force_reinstall or
+                self.ignore_installed or
+                req.link.scheme == 'file'
+            )
+            if should_modify:
+                self._set_req_to_reinstall(req)
+            else:
+                logger.info(
+                    'Requirement already satisfied (use --upgrade to upgrade):'
+                    ' %s', req,
+                )
+
+        return abstract_dist
+
+    def _resolve_one(
+        self,
+        requirement_set,  # type: RequirementSet
+        req_to_install,  # type: InstallRequirement
+    ):
+        # type: (...) -> List[InstallRequirement]
+        """Prepare a single requirements file.
+
+        :return: A list of additional InstallRequirements to also install.
+        """
+        # Tell user what we are doing for this requirement:
+        # obtain (editable), skipping, processing (local url), collecting
+        # (remote url or package name)
+        if req_to_install.constraint or req_to_install.prepared:
+            return []
+
+        req_to_install.prepared = True
+
+        abstract_dist = self._get_abstract_dist_for(req_to_install)
+
+        # Parse and return dependencies
+        dist = abstract_dist.get_pkg_resources_distribution()
+        # This will raise UnsupportedPythonVersion if the given Python
+        # version isn't compatible with the distribution's Requires-Python.
+        _check_dist_requires_python(
+            dist, version_info=self._py_version_info,
+            ignore_requires_python=self.ignore_requires_python,
+        )
+
+        more_reqs = []  # type: List[InstallRequirement]
+
+        def add_req(subreq, extras_requested):
+            sub_install_req = self._make_install_req(
+                str(subreq),
+                req_to_install,
+            )
+            parent_req_name = req_to_install.name
+            to_scan_again, add_to_parent = requirement_set.add_requirement(
+                sub_install_req,
+                parent_req_name=parent_req_name,
+                extras_requested=extras_requested,
+            )
+            if parent_req_name and add_to_parent:
+                self._discovered_dependencies[parent_req_name].append(
+                    add_to_parent
+                )
+            more_reqs.extend(to_scan_again)
+
+        with indent_log():
+            # We add req_to_install before its dependencies, so that we
+            # can refer to it when adding dependencies.
+            if not requirement_set.has_requirement(req_to_install.name):
+                # 'unnamed' requirements will get added here
+                # 'unnamed' requirements can only come from being directly
+                # provided by the user.
+                assert req_to_install.user_supplied
+                requirement_set.add_requirement(
+                    req_to_install, parent_req_name=None,
+                )
+
+            if not self.ignore_dependencies:
+                if req_to_install.extras:
+                    logger.debug(
+                        "Installing extra requirements: %r",
+                        ','.join(req_to_install.extras),
+                    )
+                missing_requested = sorted(
+                    set(req_to_install.extras) - set(dist.extras)
+                )
+                for missing in missing_requested:
+                    logger.warning(
+                        "%s does not provide the extra '%s'",
+                        dist, missing
+                    )
+
+                available_requested = sorted(
+                    set(dist.extras) & set(req_to_install.extras)
+                )
+                for subreq in dist.requires(available_requested):
+                    add_req(subreq, extras_requested=available_requested)
+
+            if not req_to_install.editable and not req_to_install.satisfied_by:
+                # XXX: --no-install leads this to report 'Successfully
+                # downloaded' for only non-editable reqs, even though we took
+                # action on them.
+                req_to_install.successfully_downloaded = True
+
+        return more_reqs
+
+    def get_installation_order(self, req_set):
+        # type: (RequirementSet) -> List[InstallRequirement]
+        """Create the installation order.
+
+        The installation order is topological - requirements are installed
+        before the requiring thing. We break cycles at an arbitrary point,
+        and make no other guarantees.
+        """
+        # The current implementation, which we may change at any point
+        # installs the user specified things in the order given, except when
+        # dependencies must come earlier to achieve topological order.
+        order = []
+        ordered_reqs = set()  # type: Set[InstallRequirement]
+
+        def schedule(req):
+            if req.satisfied_by or req in ordered_reqs:
+                return
+            if req.constraint:
+                return
+            ordered_reqs.add(req)
+            for dep in self._discovered_dependencies[req.name]:
+                schedule(dep)
+            order.append(req)
+
+        for install_req in req_set.requirements.values():
+            schedule(install_req)
+        return order
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/base.py b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/base.py
new file mode 100644
index 0000000..9245747
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/base.py
@@ -0,0 +1,82 @@
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import FrozenSet, Iterable, Optional, Tuple
+
+    from pip._vendor.packaging.version import _BaseVersion
+
+    from pip._internal.models.link import Link
+    from pip._internal.req.req_install import InstallRequirement
+
+    CandidateLookup = Tuple[
+        Optional["Candidate"],
+        Optional[InstallRequirement],
+    ]
+
+
+def format_name(project, extras):
+    # type: (str, FrozenSet[str]) -> str
+    if not extras:
+        return project
+    canonical_extras = sorted(canonicalize_name(e) for e in extras)
+    return "{}[{}]".format(project, ",".join(canonical_extras))
+
+
+class Requirement(object):
+    @property
+    def name(self):
+        # type: () -> str
+        raise NotImplementedError("Subclass should override")
+
+    def is_satisfied_by(self, candidate):
+        # type: (Candidate) -> bool
+        return False
+
+    def get_candidate_lookup(self):
+        # type: () -> CandidateLookup
+        raise NotImplementedError("Subclass should override")
+
+    def format_for_error(self):
+        # type: () -> str
+        raise NotImplementedError("Subclass should override")
+
+
+class Candidate(object):
+    @property
+    def name(self):
+        # type: () -> str
+        raise NotImplementedError("Override in subclass")
+
+    @property
+    def version(self):
+        # type: () -> _BaseVersion
+        raise NotImplementedError("Override in subclass")
+
+    @property
+    def is_installed(self):
+        # type: () -> bool
+        raise NotImplementedError("Override in subclass")
+
+    @property
+    def is_editable(self):
+        # type: () -> bool
+        raise NotImplementedError("Override in subclass")
+
+    @property
+    def source_link(self):
+        # type: () -> Optional[Link]
+        raise NotImplementedError("Override in subclass")
+
+    def iter_dependencies(self, with_requires):
+        # type: (bool) -> Iterable[Optional[Requirement]]
+        raise NotImplementedError("Override in subclass")
+
+    def get_install_requirement(self):
+        # type: () -> Optional[InstallRequirement]
+        raise NotImplementedError("Override in subclass")
+
+    def format_for_error(self):
+        # type: () -> str
+        raise NotImplementedError("Subclass should override")
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/candidates.py b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/candidates.py
new file mode 100644
index 0000000..46cc7e7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/candidates.py
@@ -0,0 +1,600 @@
+import logging
+import sys
+
+from pip._vendor.contextlib2 import suppress
+from pip._vendor.packaging.specifiers import InvalidSpecifier, SpecifierSet
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.packaging.version import Version
+
+from pip._internal.exceptions import HashError, MetadataInconsistent
+from pip._internal.network.lazy_wheel import (
+    HTTPRangeRequestUnsupported,
+    dist_from_wheel_url,
+)
+from pip._internal.req.constructors import (
+    install_req_from_editable,
+    install_req_from_line,
+)
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import dist_is_editable, normalize_version_info
+from pip._internal.utils.packaging import get_requires_python
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+from .base import Candidate, format_name
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any, FrozenSet, Iterable, Optional, Tuple, Union
+
+    from pip._vendor.packaging.version import _BaseVersion
+    from pip._vendor.pkg_resources import Distribution
+
+    from pip._internal.distributions import AbstractDistribution
+    from pip._internal.models.link import Link
+
+    from .base import Requirement
+    from .factory import Factory
+
+    BaseCandidate = Union[
+        "AlreadyInstalledCandidate",
+        "EditableCandidate",
+        "LinkCandidate",
+    ]
+
+
+logger = logging.getLogger(__name__)
+
+
+def make_install_req_from_link(link, template):
+    # type: (Link, InstallRequirement) -> InstallRequirement
+    assert not template.editable, "template is editable"
+    if template.req:
+        line = str(template.req)
+    else:
+        line = link.url
+    ireq = install_req_from_line(
+        line,
+        user_supplied=template.user_supplied,
+        comes_from=template.comes_from,
+        use_pep517=template.use_pep517,
+        isolated=template.isolated,
+        constraint=template.constraint,
+        options=dict(
+            install_options=template.install_options,
+            global_options=template.global_options,
+            hashes=template.hash_options
+        ),
+    )
+    ireq.original_link = template.original_link
+    ireq.link = link
+    return ireq
+
+
+def make_install_req_from_editable(link, template):
+    # type: (Link, InstallRequirement) -> InstallRequirement
+    assert template.editable, "template not editable"
+    return install_req_from_editable(
+        link.url,
+        user_supplied=template.user_supplied,
+        comes_from=template.comes_from,
+        use_pep517=template.use_pep517,
+        isolated=template.isolated,
+        constraint=template.constraint,
+        options=dict(
+            install_options=template.install_options,
+            global_options=template.global_options,
+            hashes=template.hash_options
+        ),
+    )
+
+
+def make_install_req_from_dist(dist, template):
+    # type: (Distribution, InstallRequirement) -> InstallRequirement
+    project_name = canonicalize_name(dist.project_name)
+    if template.req:
+        line = str(template.req)
+    elif template.link:
+        line = "{} @ {}".format(project_name, template.link.url)
+    else:
+        line = "{}=={}".format(project_name, dist.parsed_version)
+    ireq = install_req_from_line(
+        line,
+        user_supplied=template.user_supplied,
+        comes_from=template.comes_from,
+        use_pep517=template.use_pep517,
+        isolated=template.isolated,
+        constraint=template.constraint,
+        options=dict(
+            install_options=template.install_options,
+            global_options=template.global_options,
+            hashes=template.hash_options
+        ),
+    )
+    ireq.satisfied_by = dist
+    return ireq
+
+
+class _InstallRequirementBackedCandidate(Candidate):
+    """A candidate backed by an ``InstallRequirement``.
+
+    This represents a package request with the target not being already
+    in the environment, and needs to be fetched and installed. The backing
+    ``InstallRequirement`` is responsible for most of the leg work; this
+    class exposes appropriate information to the resolver.
+
+    :param link: The link passed to the ``InstallRequirement``. The backing
+        ``InstallRequirement`` will use this link to fetch the distribution.
+    :param source_link: The link this candidate "originates" from. This is
+        different from ``link`` when the link is found in the wheel cache.
+        ``link`` would point to the wheel cache, while this points to the
+        found remote link (e.g. from pypi.org).
+    """
+    is_installed = False
+
+    def __init__(
+        self,
+        link,          # type: Link
+        source_link,   # type: Link
+        ireq,          # type: InstallRequirement
+        factory,       # type: Factory
+        name=None,     # type: Optional[str]
+        version=None,  # type: Optional[_BaseVersion]
+    ):
+        # type: (...) -> None
+        self._link = link
+        self._source_link = source_link
+        self._factory = factory
+        self._ireq = ireq
+        self._name = name
+        self._version = version
+        self._dist = None  # type: Optional[Distribution]
+        self._prepared = False
+
+    def __repr__(self):
+        # type: () -> str
+        return "{class_name}({link!r})".format(
+            class_name=self.__class__.__name__,
+            link=str(self._link),
+        )
+
+    def __hash__(self):
+        # type: () -> int
+        return hash((self.__class__, self._link))
+
+    def __eq__(self, other):
+        # type: (Any) -> bool
+        if isinstance(other, self.__class__):
+            return self._link == other._link
+        return False
+
+    # Needed for Python 2, which does not implement this by default
+    def __ne__(self, other):
+        # type: (Any) -> bool
+        return not self.__eq__(other)
+
+    @property
+    def source_link(self):
+        # type: () -> Optional[Link]
+        return self._source_link
+
+    @property
+    def name(self):
+        # type: () -> str
+        """The normalised name of the project the candidate refers to"""
+        if self._name is None:
+            self._name = canonicalize_name(self.dist.project_name)
+        return self._name
+
+    @property
+    def version(self):
+        # type: () -> _BaseVersion
+        if self._version is None:
+            self._version = self.dist.parsed_version
+        return self._version
+
+    def format_for_error(self):
+        # type: () -> str
+        return "{} {} (from {})".format(
+            self.name,
+            self.version,
+            self._link.file_path if self._link.is_file else self._link
+        )
+
+    def _prepare_abstract_distribution(self):
+        # type: () -> AbstractDistribution
+        raise NotImplementedError("Override in subclass")
+
+    def _check_metadata_consistency(self):
+        # type: () -> None
+        """Check for consistency of project name and version of dist."""
+        # TODO: (Longer term) Rather than abort, reject this candidate
+        #       and backtrack. This would need resolvelib support.
+        dist = self._dist  # type: Distribution
+        name = canonicalize_name(dist.project_name)
+        if self._name is not None and self._name != name:
+            raise MetadataInconsistent(self._ireq, "name", dist.project_name)
+        version = dist.parsed_version
+        if self._version is not None and self._version != version:
+            raise MetadataInconsistent(self._ireq, "version", dist.version)
+
+    def _prepare(self):
+        # type: () -> None
+        if self._prepared:
+            return
+        try:
+            abstract_dist = self._prepare_abstract_distribution()
+        except HashError as e:
+            e.req = self._ireq
+            raise
+
+        self._dist = abstract_dist.get_pkg_resources_distribution()
+        assert self._dist is not None, "Distribution already installed"
+        self._check_metadata_consistency()
+        self._prepared = True
+
+    def _fetch_metadata(self):
+        # type: () -> None
+        """Fetch metadata, using lazy wheel if possible."""
+        preparer = self._factory.preparer
+        use_lazy_wheel = self._factory.use_lazy_wheel
+        remote_wheel = self._link.is_wheel and not self._link.is_file
+        if use_lazy_wheel and remote_wheel and not preparer.require_hashes:
+            assert self._name is not None
+            logger.info('Collecting %s', self._ireq.req or self._ireq)
+            # If HTTPRangeRequestUnsupported is raised, fallback silently.
+            with indent_log(), suppress(HTTPRangeRequestUnsupported):
+                logger.info(
+                    'Obtaining dependency information from %s %s',
+                    self._name, self._version,
+                )
+                url = self._link.url.split('#', 1)[0]
+                session = preparer.downloader._session
+                self._dist = dist_from_wheel_url(self._name, url, session)
+                self._check_metadata_consistency()
+        if self._dist is None:
+            self._prepare()
+
+    @property
+    def dist(self):
+        # type: () -> Distribution
+        if self._dist is None:
+            self._fetch_metadata()
+        return self._dist
+
+    def _get_requires_python_specifier(self):
+        # type: () -> Optional[SpecifierSet]
+        requires_python = get_requires_python(self.dist)
+        if requires_python is None:
+            return None
+        try:
+            spec = SpecifierSet(requires_python)
+        except InvalidSpecifier as e:
+            logger.warning(
+                "Package %r has an invalid Requires-Python: %s", self.name, e,
+            )
+            return None
+        return spec
+
+    def iter_dependencies(self, with_requires):
+        # type: (bool) -> Iterable[Optional[Requirement]]
+        if not with_requires:
+            return
+        for r in self.dist.requires():
+            yield self._factory.make_requirement_from_spec(str(r), self._ireq)
+        python_dep = self._factory.make_requires_python_requirement(
+            self._get_requires_python_specifier(),
+        )
+        if python_dep:
+            yield python_dep
+
+    def get_install_requirement(self):
+        # type: () -> Optional[InstallRequirement]
+        self._prepare()
+        return self._ireq
+
+
+class LinkCandidate(_InstallRequirementBackedCandidate):
+    is_editable = False
+
+    def __init__(
+        self,
+        link,          # type: Link
+        template,        # type: InstallRequirement
+        factory,       # type: Factory
+        name=None,     # type: Optional[str]
+        version=None,  # type: Optional[_BaseVersion]
+    ):
+        # type: (...) -> None
+        source_link = link
+        cache_entry = factory.get_wheel_cache_entry(link, name)
+        if cache_entry is not None:
+            logger.debug("Using cached wheel link: %s", cache_entry.link)
+            link = cache_entry.link
+        ireq = make_install_req_from_link(link, template)
+
+        if (cache_entry is not None and
+                cache_entry.persistent and
+                template.link is template.original_link):
+            ireq.original_link_is_in_wheel_cache = True
+
+        super(LinkCandidate, self).__init__(
+            link=link,
+            source_link=source_link,
+            ireq=ireq,
+            factory=factory,
+            name=name,
+            version=version,
+        )
+
+    def _prepare_abstract_distribution(self):
+        # type: () -> AbstractDistribution
+        return self._factory.preparer.prepare_linked_requirement(
+            self._ireq, parallel_builds=True,
+        )
+
+
+class EditableCandidate(_InstallRequirementBackedCandidate):
+    is_editable = True
+
+    def __init__(
+        self,
+        link,          # type: Link
+        template,        # type: InstallRequirement
+        factory,       # type: Factory
+        name=None,     # type: Optional[str]
+        version=None,  # type: Optional[_BaseVersion]
+    ):
+        # type: (...) -> None
+        super(EditableCandidate, self).__init__(
+            link=link,
+            source_link=link,
+            ireq=make_install_req_from_editable(link, template),
+            factory=factory,
+            name=name,
+            version=version,
+        )
+
+    def _prepare_abstract_distribution(self):
+        # type: () -> AbstractDistribution
+        return self._factory.preparer.prepare_editable_requirement(self._ireq)
+
+
+class AlreadyInstalledCandidate(Candidate):
+    is_installed = True
+    source_link = None
+
+    def __init__(
+        self,
+        dist,  # type: Distribution
+        template,  # type: InstallRequirement
+        factory,  # type: Factory
+    ):
+        # type: (...) -> None
+        self.dist = dist
+        self._ireq = make_install_req_from_dist(dist, template)
+        self._factory = factory
+
+        # This is just logging some messages, so we can do it eagerly.
+        # The returned dist would be exactly the same as self.dist because we
+        # set satisfied_by in make_install_req_from_dist.
+        # TODO: Supply reason based on force_reinstall and upgrade_strategy.
+        skip_reason = "already satisfied"
+        factory.preparer.prepare_installed_requirement(self._ireq, skip_reason)
+
+    def __repr__(self):
+        # type: () -> str
+        return "{class_name}({distribution!r})".format(
+            class_name=self.__class__.__name__,
+            distribution=self.dist,
+        )
+
+    def __hash__(self):
+        # type: () -> int
+        return hash((self.__class__, self.name, self.version))
+
+    def __eq__(self, other):
+        # type: (Any) -> bool
+        if isinstance(other, self.__class__):
+            return self.name == other.name and self.version == other.version
+        return False
+
+    # Needed for Python 2, which does not implement this by default
+    def __ne__(self, other):
+        # type: (Any) -> bool
+        return not self.__eq__(other)
+
+    @property
+    def name(self):
+        # type: () -> str
+        return canonicalize_name(self.dist.project_name)
+
+    @property
+    def version(self):
+        # type: () -> _BaseVersion
+        return self.dist.parsed_version
+
+    @property
+    def is_editable(self):
+        # type: () -> bool
+        return dist_is_editable(self.dist)
+
+    def format_for_error(self):
+        # type: () -> str
+        return "{} {} (Installed)".format(self.name, self.version)
+
+    def iter_dependencies(self, with_requires):
+        # type: (bool) -> Iterable[Optional[Requirement]]
+        if not with_requires:
+            return
+        for r in self.dist.requires():
+            yield self._factory.make_requirement_from_spec(str(r), self._ireq)
+
+    def get_install_requirement(self):
+        # type: () -> Optional[InstallRequirement]
+        return None
+
+
+class ExtrasCandidate(Candidate):
+    """A candidate that has 'extras', indicating additional dependencies.
+
+    Requirements can be for a project with dependencies, something like
+    foo[extra].  The extras don't affect the project/version being installed
+    directly, but indicate that we need additional dependencies. We model that
+    by having an artificial ExtrasCandidate that wraps the "base" candidate.
+
+    The ExtrasCandidate differs from the base in the following ways:
+
+    1. It has a unique name, of the form foo[extra]. This causes the resolver
+       to treat it as a separate node in the dependency graph.
+    2. When we're getting the candidate's dependencies,
+       a) We specify that we want the extra dependencies as well.
+       b) We add a dependency on the base candidate.
+          See below for why this is needed.
+    3. We return None for the underlying InstallRequirement, as the base
+       candidate will provide it, and we don't want to end up with duplicates.
+
+    The dependency on the base candidate is needed so that the resolver can't
+    decide that it should recommend foo[extra1] version 1.0 and foo[extra2]
+    version 2.0. Having those candidates depend on foo=1.0 and foo=2.0
+    respectively forces the resolver to recognise that this is a conflict.
+    """
+    def __init__(
+        self,
+        base,  # type: BaseCandidate
+        extras,  # type: FrozenSet[str]
+    ):
+        # type: (...) -> None
+        self.base = base
+        self.extras = extras
+
+    def __repr__(self):
+        # type: () -> str
+        return "{class_name}(base={base!r}, extras={extras!r})".format(
+            class_name=self.__class__.__name__,
+            base=self.base,
+            extras=self.extras,
+        )
+
+    def __hash__(self):
+        # type: () -> int
+        return hash((self.base, self.extras))
+
+    def __eq__(self, other):
+        # type: (Any) -> bool
+        if isinstance(other, self.__class__):
+            return self.base == other.base and self.extras == other.extras
+        return False
+
+    # Needed for Python 2, which does not implement this by default
+    def __ne__(self, other):
+        # type: (Any) -> bool
+        return not self.__eq__(other)
+
+    @property
+    def name(self):
+        # type: () -> str
+        """The normalised name of the project the candidate refers to"""
+        return format_name(self.base.name, self.extras)
+
+    @property
+    def version(self):
+        # type: () -> _BaseVersion
+        return self.base.version
+
+    def format_for_error(self):
+        # type: () -> str
+        return "{} [{}]".format(
+            self.base.format_for_error(),
+            ", ".join(sorted(self.extras))
+        )
+
+    @property
+    def is_installed(self):
+        # type: () -> bool
+        return self.base.is_installed
+
+    @property
+    def is_editable(self):
+        # type: () -> bool
+        return self.base.is_editable
+
+    @property
+    def source_link(self):
+        # type: () -> Optional[Link]
+        return self.base.source_link
+
+    def iter_dependencies(self, with_requires):
+        # type: (bool) -> Iterable[Optional[Requirement]]
+        factory = self.base._factory
+
+        # Add a dependency on the exact base
+        # (See note 2b in the class docstring)
+        yield factory.make_requirement_from_candidate(self.base)
+        if not with_requires:
+            return
+
+        # The user may have specified extras that the candidate doesn't
+        # support. We ignore any unsupported extras here.
+        valid_extras = self.extras.intersection(self.base.dist.extras)
+        invalid_extras = self.extras.difference(self.base.dist.extras)
+        for extra in sorted(invalid_extras):
+            logger.warning(
+                "%s %s does not provide the extra '%s'",
+                self.base.name,
+                self.version,
+                extra
+            )
+
+        for r in self.base.dist.requires(valid_extras):
+            requirement = factory.make_requirement_from_spec(
+                str(r), self.base._ireq, valid_extras,
+            )
+            if requirement:
+                yield requirement
+
+    def get_install_requirement(self):
+        # type: () -> Optional[InstallRequirement]
+        # We don't return anything here, because we always
+        # depend on the base candidate, and we'll get the
+        # install requirement from that.
+        return None
+
+
+class RequiresPythonCandidate(Candidate):
+    is_installed = False
+    source_link = None
+
+    def __init__(self, py_version_info):
+        # type: (Optional[Tuple[int, ...]]) -> None
+        if py_version_info is not None:
+            version_info = normalize_version_info(py_version_info)
+        else:
+            version_info = sys.version_info[:3]
+        self._version = Version(".".join(str(c) for c in version_info))
+
+    # We don't need to implement __eq__() and __ne__() since there is always
+    # only one RequiresPythonCandidate in a resolution, i.e. the host Python.
+    # The built-in object.__eq__() and object.__ne__() do exactly what we want.
+
+    @property
+    def name(self):
+        # type: () -> str
+        # Avoid conflicting with the PyPI package "Python".
+        return "<Python from Requires-Python>"
+
+    @property
+    def version(self):
+        # type: () -> _BaseVersion
+        return self._version
+
+    def format_for_error(self):
+        # type: () -> str
+        return "Python {}".format(self.version)
+
+    def iter_dependencies(self, with_requires):
+        # type: (bool) -> Iterable[Optional[Requirement]]
+        return ()
+
+    def get_install_requirement(self):
+        # type: () -> Optional[InstallRequirement]
+        return None
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/factory.py b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/factory.py
new file mode 100644
index 0000000..dab23aa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/factory.py
@@ -0,0 +1,459 @@
+import collections
+import logging
+
+from pip._vendor import six
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.exceptions import (
+    DistributionNotFound,
+    InstallationError,
+    UnsupportedPythonVersion,
+    UnsupportedWheel,
+)
+from pip._internal.models.wheel import Wheel
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.utils.compatibility_tags import get_supported
+from pip._internal.utils.hashes import Hashes
+from pip._internal.utils.misc import (
+    dist_in_site_packages,
+    dist_in_usersite,
+    get_installed_distributions,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+from .candidates import (
+    AlreadyInstalledCandidate,
+    EditableCandidate,
+    ExtrasCandidate,
+    LinkCandidate,
+    RequiresPythonCandidate,
+)
+from .requirements import (
+    ExplicitRequirement,
+    RequiresPythonRequirement,
+    SpecifierRequirement,
+)
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        FrozenSet,
+        Dict,
+        Iterable,
+        List,
+        Optional,
+        Sequence,
+        Set,
+        Tuple,
+        TypeVar,
+    )
+
+    from pip._vendor.packaging.specifiers import SpecifierSet
+    from pip._vendor.packaging.version import _BaseVersion
+    from pip._vendor.pkg_resources import Distribution
+    from pip._vendor.resolvelib import ResolutionImpossible
+
+    from pip._internal.cache import CacheEntry, WheelCache
+    from pip._internal.index.package_finder import PackageFinder
+    from pip._internal.models.link import Link
+    from pip._internal.operations.prepare import RequirementPreparer
+    from pip._internal.resolution.base import InstallRequirementProvider
+
+    from .base import Candidate, Requirement
+    from .candidates import BaseCandidate
+
+    C = TypeVar("C")
+    Cache = Dict[Link, C]
+    VersionCandidates = Dict[_BaseVersion, Candidate]
+
+
+logger = logging.getLogger(__name__)
+
+
+class Factory(object):
+    def __init__(
+        self,
+        finder,  # type: PackageFinder
+        preparer,  # type: RequirementPreparer
+        make_install_req,  # type: InstallRequirementProvider
+        wheel_cache,  # type: Optional[WheelCache]
+        use_user_site,  # type: bool
+        force_reinstall,  # type: bool
+        ignore_installed,  # type: bool
+        ignore_requires_python,  # type: bool
+        py_version_info=None,  # type: Optional[Tuple[int, ...]]
+        lazy_wheel=False,  # type: bool
+    ):
+        # type: (...) -> None
+        self._finder = finder
+        self.preparer = preparer
+        self._wheel_cache = wheel_cache
+        self._python_candidate = RequiresPythonCandidate(py_version_info)
+        self._make_install_req_from_spec = make_install_req
+        self._use_user_site = use_user_site
+        self._force_reinstall = force_reinstall
+        self._ignore_requires_python = ignore_requires_python
+        self.use_lazy_wheel = lazy_wheel
+
+        self._link_candidate_cache = {}  # type: Cache[LinkCandidate]
+        self._editable_candidate_cache = {}  # type: Cache[EditableCandidate]
+
+        if not ignore_installed:
+            self._installed_dists = {
+                canonicalize_name(dist.project_name): dist
+                for dist in get_installed_distributions()
+            }
+        else:
+            self._installed_dists = {}
+
+    @property
+    def force_reinstall(self):
+        # type: () -> bool
+        return self._force_reinstall
+
+    def _make_candidate_from_dist(
+        self,
+        dist,  # type: Distribution
+        extras,  # type: FrozenSet[str]
+        template,  # type: InstallRequirement
+    ):
+        # type: (...) -> Candidate
+        base = AlreadyInstalledCandidate(dist, template, factory=self)
+        if extras:
+            return ExtrasCandidate(base, extras)
+        return base
+
+    def _make_candidate_from_link(
+        self,
+        link,  # type: Link
+        extras,  # type: FrozenSet[str]
+        template,  # type: InstallRequirement
+        name,  # type: Optional[str]
+        version,  # type: Optional[_BaseVersion]
+    ):
+        # type: (...) -> Candidate
+        # TODO: Check already installed candidate, and use it if the link and
+        # editable flag match.
+        if template.editable:
+            if link not in self._editable_candidate_cache:
+                self._editable_candidate_cache[link] = EditableCandidate(
+                    link, template, factory=self, name=name, version=version,
+                )
+            base = self._editable_candidate_cache[link]  # type: BaseCandidate
+        else:
+            if link not in self._link_candidate_cache:
+                self._link_candidate_cache[link] = LinkCandidate(
+                    link, template, factory=self, name=name, version=version,
+                )
+            base = self._link_candidate_cache[link]
+        if extras:
+            return ExtrasCandidate(base, extras)
+        return base
+
+    def _iter_found_candidates(
+        self,
+        ireqs,  # type: Sequence[InstallRequirement]
+        specifier,  # type: SpecifierSet
+    ):
+        # type: (...) -> Iterable[Candidate]
+        if not ireqs:
+            return ()
+
+        # The InstallRequirement implementation requires us to give it a
+        # "template". Here we just choose the first requirement to represent
+        # all of them.
+        # Hopefully the Project model can correct this mismatch in the future.
+        template = ireqs[0]
+        name = canonicalize_name(template.req.name)
+
+        hashes = Hashes()
+        extras = frozenset()  # type: FrozenSet[str]
+        for ireq in ireqs:
+            specifier &= ireq.req.specifier
+            hashes |= ireq.hashes(trust_internet=False)
+            extras |= frozenset(ireq.extras)
+
+        # We use this to ensure that we only yield a single candidate for
+        # each version (the finder's preferred one for that version). The
+        # requirement needs to return only one candidate per version, so we
+        # implement that logic here so that requirements using this helper
+        # don't all have to do the same thing later.
+        candidates = collections.OrderedDict()  # type: VersionCandidates
+
+        # Get the installed version, if it matches, unless the user
+        # specified `--force-reinstall`, when we want the version from
+        # the index instead.
+        installed_version = None
+        installed_candidate = None
+        if not self._force_reinstall and name in self._installed_dists:
+            installed_dist = self._installed_dists[name]
+            installed_version = installed_dist.parsed_version
+            if specifier.contains(installed_version, prereleases=True):
+                installed_candidate = self._make_candidate_from_dist(
+                    dist=installed_dist,
+                    extras=extras,
+                    template=template,
+                )
+
+        found = self._finder.find_best_candidate(
+            project_name=name,
+            specifier=specifier,
+            hashes=hashes,
+        )
+        for ican in found.iter_applicable():
+            if ican.version == installed_version and installed_candidate:
+                candidate = installed_candidate
+            else:
+                candidate = self._make_candidate_from_link(
+                    link=ican.link,
+                    extras=extras,
+                    template=template,
+                    name=name,
+                    version=ican.version,
+                )
+            candidates[ican.version] = candidate
+
+        # Yield the installed version even if it is not found on the index.
+        if installed_version and installed_candidate:
+            candidates[installed_version] = installed_candidate
+
+        return six.itervalues(candidates)
+
+    def find_candidates(self, requirements, constraint):
+        # type: (Sequence[Requirement], SpecifierSet) -> Iterable[Candidate]
+        explicit_candidates = set()  # type: Set[Candidate]
+        ireqs = []  # type: List[InstallRequirement]
+        for req in requirements:
+            cand, ireq = req.get_candidate_lookup()
+            if cand is not None:
+                explicit_candidates.add(cand)
+            if ireq is not None:
+                ireqs.append(ireq)
+
+        # If none of the requirements want an explicit candidate, we can ask
+        # the finder for candidates.
+        if not explicit_candidates:
+            return self._iter_found_candidates(ireqs, constraint)
+
+        if constraint:
+            name = explicit_candidates.pop().name
+            raise InstallationError(
+                "Could not satisfy constraints for {!r}: installation from "
+                "path or url cannot be constrained to a version".format(name)
+            )
+
+        return (
+            c for c in explicit_candidates
+            if all(req.is_satisfied_by(c) for req in requirements)
+        )
+
+    def make_requirement_from_install_req(self, ireq, requested_extras):
+        # type: (InstallRequirement, Iterable[str]) -> Optional[Requirement]
+        if not ireq.match_markers(requested_extras):
+            logger.info(
+                "Ignoring %s: markers '%s' don't match your environment",
+                ireq.name, ireq.markers,
+            )
+            return None
+        if not ireq.link:
+            return SpecifierRequirement(ireq)
+        if ireq.link.is_wheel:
+            wheel = Wheel(ireq.link.filename)
+            if not wheel.supported(self._finder.target_python.get_tags()):
+                msg = "{} is not a supported wheel on this platform.".format(
+                    wheel.filename,
+                )
+                raise UnsupportedWheel(msg)
+        cand = self._make_candidate_from_link(
+            ireq.link,
+            extras=frozenset(ireq.extras),
+            template=ireq,
+            name=canonicalize_name(ireq.name) if ireq.name else None,
+            version=None,
+        )
+        return self.make_requirement_from_candidate(cand)
+
+    def make_requirement_from_candidate(self, candidate):
+        # type: (Candidate) -> ExplicitRequirement
+        return ExplicitRequirement(candidate)
+
+    def make_requirement_from_spec(
+        self,
+        specifier,  # type: str
+        comes_from,  # type: InstallRequirement
+        requested_extras=(),  # type: Iterable[str]
+    ):
+        # type: (...) -> Optional[Requirement]
+        ireq = self._make_install_req_from_spec(specifier, comes_from)
+        return self.make_requirement_from_install_req(ireq, requested_extras)
+
+    def make_requires_python_requirement(self, specifier):
+        # type: (Optional[SpecifierSet]) -> Optional[Requirement]
+        if self._ignore_requires_python or specifier is None:
+            return None
+        return RequiresPythonRequirement(specifier, self._python_candidate)
+
+    def get_wheel_cache_entry(self, link, name):
+        # type: (Link, Optional[str]) -> Optional[CacheEntry]
+        """Look up the link in the wheel cache.
+
+        If ``preparer.require_hashes`` is True, don't use the wheel cache,
+        because cached wheels, always built locally, have different hashes
+        than the files downloaded from the index server and thus throw false
+        hash mismatches. Furthermore, cached wheels at present have
+        nondeterministic contents due to file modification times.
+        """
+        if self._wheel_cache is None or self.preparer.require_hashes:
+            return None
+        return self._wheel_cache.get_cache_entry(
+            link=link,
+            package_name=name,
+            supported_tags=get_supported(),
+        )
+
+    def get_dist_to_uninstall(self, candidate):
+        # type: (Candidate) -> Optional[Distribution]
+        # TODO: Are there more cases this needs to return True? Editable?
+        dist = self._installed_dists.get(candidate.name)
+        if dist is None:  # Not installed, no uninstallation required.
+            return None
+
+        # We're installing into global site. The current installation must
+        # be uninstalled, no matter it's in global or user site, because the
+        # user site installation has precedence over global.
+        if not self._use_user_site:
+            return dist
+
+        # We're installing into user site. Remove the user site installation.
+        if dist_in_usersite(dist):
+            return dist
+
+        # We're installing into user site, but the installed incompatible
+        # package is in global site. We can't uninstall that, and would let
+        # the new user installation to "shadow" it. But shadowing won't work
+        # in virtual environments, so we error out.
+        if running_under_virtualenv() and dist_in_site_packages(dist):
+            raise InstallationError(
+                "Will not install to the user site because it will "
+                "lack sys.path precedence to {} in {}".format(
+                    dist.project_name, dist.location,
+                )
+            )
+        return None
+
+    def _report_requires_python_error(
+        self,
+        requirement,  # type: RequiresPythonRequirement
+        template,  # type: Candidate
+    ):
+        # type: (...) -> UnsupportedPythonVersion
+        message_format = (
+            "Package {package!r} requires a different Python: "
+            "{version} not in {specifier!r}"
+        )
+        message = message_format.format(
+            package=template.name,
+            version=self._python_candidate.version,
+            specifier=str(requirement.specifier),
+        )
+        return UnsupportedPythonVersion(message)
+
+    def get_installation_error(self, e):
+        # type: (ResolutionImpossible) -> InstallationError
+
+        assert e.causes, "Installation error reported with no cause"
+
+        # If one of the things we can't solve is "we need Python X.Y",
+        # that is what we report.
+        for cause in e.causes:
+            if isinstance(cause.requirement, RequiresPythonRequirement):
+                return self._report_requires_python_error(
+                    cause.requirement,
+                    cause.parent,
+                )
+
+        # Otherwise, we have a set of causes which can't all be satisfied
+        # at once.
+
+        # The simplest case is when we have *one* cause that can't be
+        # satisfied. We just report that case.
+        if len(e.causes) == 1:
+            req, parent = e.causes[0]
+            if parent is None:
+                req_disp = str(req)
+            else:
+                req_disp = '{} (from {})'.format(req, parent.name)
+            logger.critical(
+                "Could not find a version that satisfies the requirement %s",
+                req_disp,
+            )
+            return DistributionNotFound(
+                'No matching distribution found for {}'.format(req)
+            )
+
+        # OK, we now have a list of requirements that can't all be
+        # satisfied at once.
+
+        # A couple of formatting helpers
+        def text_join(parts):
+            # type: (List[str]) -> str
+            if len(parts) == 1:
+                return parts[0]
+
+            return ", ".join(parts[:-1]) + " and " + parts[-1]
+
+        def readable_form(cand):
+            # type: (Candidate) -> str
+            return "{} {}".format(cand.name, cand.version)
+
+        def describe_trigger(parent):
+            # type: (Candidate) -> str
+            ireq = parent.get_install_requirement()
+            if not ireq or not ireq.comes_from:
+                return "{} {}".format(parent.name, parent.version)
+            if isinstance(ireq.comes_from, InstallRequirement):
+                return str(ireq.comes_from.name)
+            return str(ireq.comes_from)
+
+        triggers = []
+        for req, parent in e.causes:
+            if parent is None:
+                # This is a root requirement, so we can report it directly
+                trigger = req.format_for_error()
+            else:
+                trigger = describe_trigger(parent)
+            triggers.append(trigger)
+
+        if triggers:
+            info = text_join(triggers)
+        else:
+            info = "the requested packages"
+
+        msg = "Cannot install {} because these package versions " \
+            "have conflicting dependencies.".format(info)
+        logger.critical(msg)
+        msg = "\nThe conflict is caused by:"
+        for req, parent in e.causes:
+            msg = msg + "\n    "
+            if parent:
+                msg = msg + "{} {} depends on ".format(
+                    parent.name,
+                    parent.version
+                )
+            else:
+                msg = msg + "The user requested "
+            msg = msg + req.format_for_error()
+
+        msg = msg + "\n\n" + \
+            "To fix this you could try to:\n" + \
+            "1. loosen the range of package versions you've specified\n" + \
+            "2. remove package versions to allow pip attempt to solve " + \
+            "the dependency conflict\n"
+
+        logger.info(msg)
+
+        return DistributionNotFound(
+            "ResolutionImpossible: for help visit "
+            "https://pip.pypa.io/en/latest/user_guide/"
+            "#fixing-conflicting-dependencies"
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/provider.py b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/provider.py
new file mode 100644
index 0000000..b2eb9d0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/provider.py
@@ -0,0 +1,153 @@
+from pip._vendor.packaging.specifiers import SpecifierSet
+from pip._vendor.resolvelib.providers import AbstractProvider
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Any,
+        Dict,
+        Iterable,
+        Optional,
+        Sequence,
+        Set,
+        Tuple,
+        Union,
+    )
+
+    from .base import Requirement, Candidate
+    from .factory import Factory
+
+# Notes on the relationship between the provider, the factory, and the
+# candidate and requirement classes.
+#
+# The provider is a direct implementation of the resolvelib class. Its role
+# is to deliver the API that resolvelib expects.
+#
+# Rather than work with completely abstract "requirement" and "candidate"
+# concepts as resolvelib does, pip has concrete classes implementing these two
+# ideas. The API of Requirement and Candidate objects are defined in the base
+# classes, but essentially map fairly directly to the equivalent provider
+# methods. In particular, `find_matches` and `is_satisfied_by` are
+# requirement methods, and `get_dependencies` is a candidate method.
+#
+# The factory is the interface to pip's internal mechanisms. It is stateless,
+# and is created by the resolver and held as a property of the provider. It is
+# responsible for creating Requirement and Candidate objects, and provides
+# services to those objects (access to pip's finder and preparer).
+
+
+class PipProvider(AbstractProvider):
+    def __init__(
+        self,
+        factory,  # type: Factory
+        constraints,  # type: Dict[str, SpecifierSet]
+        ignore_dependencies,  # type: bool
+        upgrade_strategy,  # type: str
+        user_requested,  # type: Set[str]
+    ):
+        # type: (...) -> None
+        self._factory = factory
+        self._constraints = constraints
+        self._ignore_dependencies = ignore_dependencies
+        self._upgrade_strategy = upgrade_strategy
+        self.user_requested = user_requested
+
+    def _sort_matches(self, matches):
+        # type: (Iterable[Candidate]) -> Sequence[Candidate]
+
+        # The requirement is responsible for returning a sequence of potential
+        # candidates, one per version. The provider handles the logic of
+        # deciding the order in which these candidates should be passed to
+        # the resolver.
+
+        # The `matches` argument is a sequence of candidates, one per version,
+        # which are potential options to be installed. The requirement will
+        # have already sorted out whether to give us an already-installed
+        # candidate or a version from PyPI (i.e., it will deal with options
+        # like --force-reinstall and --ignore-installed).
+
+        # We now work out the correct order.
+        #
+        # 1. If no other considerations apply, later versions take priority.
+        # 2. An already installed distribution is preferred over any other,
+        #    unless the user has requested an upgrade.
+        #    Upgrades are allowed when:
+        #    * The --upgrade flag is set, and
+        #      - The project was specified on the command line, or
+        #      - The project is a dependency and the "eager" upgrade strategy
+        #        was requested.
+        def _eligible_for_upgrade(name):
+            # type: (str) -> bool
+            """Are upgrades allowed for this project?
+
+            This checks the upgrade strategy, and whether the project was one
+            that the user specified in the command line, in order to decide
+            whether we should upgrade if there's a newer version available.
+
+            (Note that we don't need access to the `--upgrade` flag, because
+            an upgrade strategy of "to-satisfy-only" means that `--upgrade`
+            was not specified).
+            """
+            if self._upgrade_strategy == "eager":
+                return True
+            elif self._upgrade_strategy == "only-if-needed":
+                return (name in self.user_requested)
+            return False
+
+        def sort_key(c):
+            # type: (Candidate) -> int
+            """Return a sort key for the matches.
+
+            The highest priority should be given to installed candidates that
+            are not eligible for upgrade. We use the integer value in the first
+            part of the key to sort these before other candidates.
+
+            We only pull the installed candidate to the bottom (i.e. most
+            preferred), but otherwise keep the ordering returned by the
+            requirement. The requirement is responsible for returning a list
+            otherwise sorted for the resolver, taking account for versions
+            and binary preferences as specified by the user.
+            """
+            if c.is_installed and not _eligible_for_upgrade(c.name):
+                return 1
+            return 0
+
+        return sorted(matches, key=sort_key)
+
+    def identify(self, dependency):
+        # type: (Union[Requirement, Candidate]) -> str
+        return dependency.name
+
+    def get_preference(
+        self,
+        resolution,  # type: Optional[Candidate]
+        candidates,  # type: Sequence[Candidate]
+        information  # type: Sequence[Tuple[Requirement, Candidate]]
+    ):
+        # type: (...) -> Any
+        # Use the "usual" value for now
+        return len(candidates)
+
+    def find_matches(self, requirements):
+        # type: (Sequence[Requirement]) -> Iterable[Candidate]
+        if not requirements:
+            return []
+        constraint = self._constraints.get(
+            requirements[0].name, SpecifierSet(),
+        )
+        candidates = self._factory.find_candidates(requirements, constraint)
+        return reversed(self._sort_matches(candidates))
+
+    def is_satisfied_by(self, requirement, candidate):
+        # type: (Requirement, Candidate) -> bool
+        return requirement.is_satisfied_by(candidate)
+
+    def get_dependencies(self, candidate):
+        # type: (Candidate) -> Sequence[Requirement]
+        with_requires = not self._ignore_dependencies
+        return [
+            r
+            for r in candidate.iter_dependencies(with_requires)
+            if r is not None
+        ]
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/requirements.py b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/requirements.py
new file mode 100644
index 0000000..bc1061f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/requirements.py
@@ -0,0 +1,137 @@
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+from .base import Requirement, format_name
+
+if MYPY_CHECK_RUNNING:
+    from pip._vendor.packaging.specifiers import SpecifierSet
+
+    from pip._internal.req.req_install import InstallRequirement
+
+    from .base import Candidate, CandidateLookup
+
+
+class ExplicitRequirement(Requirement):
+    def __init__(self, candidate):
+        # type: (Candidate) -> None
+        self.candidate = candidate
+
+    def __repr__(self):
+        # type: () -> str
+        return "{class_name}({candidate!r})".format(
+            class_name=self.__class__.__name__,
+            candidate=self.candidate,
+        )
+
+    @property
+    def name(self):
+        # type: () -> str
+        # No need to canonicalise - the candidate did this
+        return self.candidate.name
+
+    def format_for_error(self):
+        # type: () -> str
+        return self.candidate.format_for_error()
+
+    def get_candidate_lookup(self):
+        # type: () -> CandidateLookup
+        return self.candidate, None
+
+    def is_satisfied_by(self, candidate):
+        # type: (Candidate) -> bool
+        return candidate == self.candidate
+
+
+class SpecifierRequirement(Requirement):
+    def __init__(self, ireq):
+        # type: (InstallRequirement) -> None
+        assert ireq.link is None, "This is a link, not a specifier"
+        self._ireq = ireq
+        self._extras = frozenset(ireq.extras)
+
+    def __str__(self):
+        # type: () -> str
+        return str(self._ireq.req)
+
+    def __repr__(self):
+        # type: () -> str
+        return "{class_name}({requirement!r})".format(
+            class_name=self.__class__.__name__,
+            requirement=str(self._ireq.req),
+        )
+
+    @property
+    def name(self):
+        # type: () -> str
+        canonical_name = canonicalize_name(self._ireq.req.name)
+        return format_name(canonical_name, self._extras)
+
+    def format_for_error(self):
+        # type: () -> str
+
+        # Convert comma-separated specifiers into "A, B, ..., F and G"
+        # This makes the specifier a bit more "human readable", without
+        # risking a change in meaning. (Hopefully! Not all edge cases have
+        # been checked)
+        parts = [s.strip() for s in str(self).split(",")]
+        if len(parts) == 0:
+            return ""
+        elif len(parts) == 1:
+            return parts[0]
+
+        return ", ".join(parts[:-1]) + " and " + parts[-1]
+
+    def get_candidate_lookup(self):
+        # type: () -> CandidateLookup
+        return None, self._ireq
+
+    def is_satisfied_by(self, candidate):
+        # type: (Candidate) -> bool
+        assert candidate.name == self.name, \
+            "Internal issue: Candidate is not for this requirement " \
+            " {} vs {}".format(candidate.name, self.name)
+        # We can safely always allow prereleases here since PackageFinder
+        # already implements the prerelease logic, and would have filtered out
+        # prerelease candidates if the user does not expect them.
+        spec = self._ireq.req.specifier
+        return spec.contains(candidate.version, prereleases=True)
+
+
+class RequiresPythonRequirement(Requirement):
+    """A requirement representing Requires-Python metadata.
+    """
+    def __init__(self, specifier, match):
+        # type: (SpecifierSet, Candidate) -> None
+        self.specifier = specifier
+        self._candidate = match
+
+    def __repr__(self):
+        # type: () -> str
+        return "{class_name}({specifier!r})".format(
+            class_name=self.__class__.__name__,
+            specifier=str(self.specifier),
+        )
+
+    @property
+    def name(self):
+        # type: () -> str
+        return self._candidate.name
+
+    def format_for_error(self):
+        # type: () -> str
+        return "Python " + str(self.specifier)
+
+    def get_candidate_lookup(self):
+        # type: () -> CandidateLookup
+        if self.specifier.contains(self._candidate.version, prereleases=True):
+            return self._candidate, None
+        return None, None
+
+    def is_satisfied_by(self, candidate):
+        # type: (Candidate) -> bool
+        assert candidate.name == self._candidate.name, "Not Python candidate"
+        # We can safely always allow prereleases here since PackageFinder
+        # already implements the prerelease logic, and would have filtered out
+        # prerelease candidates if the user does not expect them.
+        return self.specifier.contains(candidate.version, prereleases=True)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/resolver.py b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/resolver.py
new file mode 100644
index 0000000..aecddb1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/resolver.py
@@ -0,0 +1,259 @@
+import functools
+import logging
+
+from pip._vendor import six
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.resolvelib import BaseReporter, ResolutionImpossible
+from pip._vendor.resolvelib import Resolver as RLResolver
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.req.req_install import check_invalid_constraint_type
+from pip._internal.req.req_set import RequirementSet
+from pip._internal.resolution.base import BaseResolver
+from pip._internal.resolution.resolvelib.provider import PipProvider
+from pip._internal.utils.misc import dist_is_editable
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+from .factory import Factory
+
+if MYPY_CHECK_RUNNING:
+    from typing import Dict, List, Optional, Set, Tuple
+
+    from pip._vendor.packaging.specifiers import SpecifierSet
+    from pip._vendor.resolvelib.resolvers import Result
+    from pip._vendor.resolvelib.structs import Graph
+
+    from pip._internal.cache import WheelCache
+    from pip._internal.index.package_finder import PackageFinder
+    from pip._internal.operations.prepare import RequirementPreparer
+    from pip._internal.req.req_install import InstallRequirement
+    from pip._internal.resolution.base import InstallRequirementProvider
+
+
+logger = logging.getLogger(__name__)
+
+
+class Resolver(BaseResolver):
+    _allowed_strategies = {"eager", "only-if-needed", "to-satisfy-only"}
+
+    def __init__(
+        self,
+        preparer,  # type: RequirementPreparer
+        finder,  # type: PackageFinder
+        wheel_cache,  # type: Optional[WheelCache]
+        make_install_req,  # type: InstallRequirementProvider
+        use_user_site,  # type: bool
+        ignore_dependencies,  # type: bool
+        ignore_installed,  # type: bool
+        ignore_requires_python,  # type: bool
+        force_reinstall,  # type: bool
+        upgrade_strategy,  # type: str
+        py_version_info=None,  # type: Optional[Tuple[int, ...]]
+        lazy_wheel=False,  # type: bool
+    ):
+        super(Resolver, self).__init__()
+        if lazy_wheel:
+            logger.warning(
+                'pip is using lazily downloaded wheels using HTTP '
+                'range requests to obtain dependency information. '
+                'This experimental feature is enabled through '
+                '--use-feature=fast-deps and it is not ready for production.'
+            )
+
+        assert upgrade_strategy in self._allowed_strategies
+
+        self.factory = Factory(
+            finder=finder,
+            preparer=preparer,
+            make_install_req=make_install_req,
+            wheel_cache=wheel_cache,
+            use_user_site=use_user_site,
+            force_reinstall=force_reinstall,
+            ignore_installed=ignore_installed,
+            ignore_requires_python=ignore_requires_python,
+            py_version_info=py_version_info,
+            lazy_wheel=lazy_wheel,
+        )
+        self.ignore_dependencies = ignore_dependencies
+        self.upgrade_strategy = upgrade_strategy
+        self._result = None  # type: Optional[Result]
+
+    def resolve(self, root_reqs, check_supported_wheels):
+        # type: (List[InstallRequirement], bool) -> RequirementSet
+
+        constraints = {}  # type: Dict[str, SpecifierSet]
+        user_requested = set()  # type: Set[str]
+        requirements = []
+        for req in root_reqs:
+            if req.constraint:
+                # Ensure we only accept valid constraints
+                problem = check_invalid_constraint_type(req)
+                if problem:
+                    raise InstallationError(problem)
+                if not req.match_markers():
+                    continue
+                name = canonicalize_name(req.name)
+                if name in constraints:
+                    constraints[name] = constraints[name] & req.specifier
+                else:
+                    constraints[name] = req.specifier
+            else:
+                if req.user_supplied and req.name:
+                    user_requested.add(canonicalize_name(req.name))
+                r = self.factory.make_requirement_from_install_req(
+                    req, requested_extras=(),
+                )
+                if r is not None:
+                    requirements.append(r)
+
+        provider = PipProvider(
+            factory=self.factory,
+            constraints=constraints,
+            ignore_dependencies=self.ignore_dependencies,
+            upgrade_strategy=self.upgrade_strategy,
+            user_requested=user_requested,
+        )
+        reporter = BaseReporter()
+        resolver = RLResolver(provider, reporter)
+
+        try:
+            try_to_avoid_resolution_too_deep = 2000000
+            self._result = resolver.resolve(
+                requirements, max_rounds=try_to_avoid_resolution_too_deep,
+            )
+
+        except ResolutionImpossible as e:
+            error = self.factory.get_installation_error(e)
+            six.raise_from(error, e)
+
+        req_set = RequirementSet(check_supported_wheels=check_supported_wheels)
+        for candidate in self._result.mapping.values():
+            ireq = candidate.get_install_requirement()
+            if ireq is None:
+                continue
+
+            # Check if there is already an installation under the same name,
+            # and set a flag for later stages to uninstall it, if needed.
+            # * There isn't, good -- no uninstalltion needed.
+            # * The --force-reinstall flag is set. Always reinstall.
+            # * The installation is different in version or editable-ness, so
+            #   we need to uninstall it to install the new distribution.
+            # * The installed version is the same as the pending distribution.
+            #   Skip this distrubiton altogether to save work.
+            installed_dist = self.factory.get_dist_to_uninstall(candidate)
+            if installed_dist is None:
+                ireq.should_reinstall = False
+            elif self.factory.force_reinstall:
+                ireq.should_reinstall = True
+            elif installed_dist.parsed_version != candidate.version:
+                ireq.should_reinstall = True
+            elif dist_is_editable(installed_dist) != candidate.is_editable:
+                ireq.should_reinstall = True
+            else:
+                continue
+
+            link = candidate.source_link
+            if link and link.is_yanked:
+                # The reason can contain non-ASCII characters, Unicode
+                # is required for Python 2.
+                msg = (
+                    u'The candidate selected for download or install is a '
+                    u'yanked version: {name!r} candidate (version {version} '
+                    u'at {link})\nReason for being yanked: {reason}'
+                ).format(
+                    name=candidate.name,
+                    version=candidate.version,
+                    link=link,
+                    reason=link.yanked_reason or u'<none given>',
+                )
+                logger.warning(msg)
+
+            req_set.add_named_requirement(ireq)
+
+        return req_set
+
+    def get_installation_order(self, req_set):
+        # type: (RequirementSet) -> List[InstallRequirement]
+        """Get order for installation of requirements in RequirementSet.
+
+        The returned list contains a requirement before another that depends on
+        it. This helps ensure that the environment is kept consistent as they
+        get installed one-by-one.
+
+        The current implementation creates a topological ordering of the
+        dependency graph, while breaking any cycles in the graph at arbitrary
+        points. We make no guarantees about where the cycle would be broken,
+        other than they would be broken.
+        """
+        assert self._result is not None, "must call resolve() first"
+
+        graph = self._result.graph
+        weights = get_topological_weights(graph)
+
+        sorted_items = sorted(
+            req_set.requirements.items(),
+            key=functools.partial(_req_set_item_sorter, weights=weights),
+            reverse=True,
+        )
+        return [ireq for _, ireq in sorted_items]
+
+
+def get_topological_weights(graph):
+    # type: (Graph) -> Dict[Optional[str], int]
+    """Assign weights to each node based on how "deep" they are.
+
+    This implementation may change at any point in the future without prior
+    notice.
+
+    We take the length for the longest path to any node from root, ignoring any
+    paths that contain a single node twice (i.e. cycles). This is done through
+    a depth-first search through the graph, while keeping track of the path to
+    the node.
+
+    Cycles in the graph result would result in node being revisited while also
+    being it's own path. In this case, take no action. This helps ensure we
+    don't get stuck in a cycle.
+
+    When assigning weight, the longer path (i.e. larger length) is preferred.
+    """
+    path = set()  # type: Set[Optional[str]]
+    weights = {}  # type: Dict[Optional[str], int]
+
+    def visit(node):
+        # type: (Optional[str]) -> None
+        if node in path:
+            # We hit a cycle, so we'll break it here.
+            return
+
+        # Time to visit the children!
+        path.add(node)
+        for child in graph.iter_children(node):
+            visit(child)
+        path.remove(node)
+
+        last_known_parent_count = weights.get(node, 0)
+        weights[node] = max(last_known_parent_count, len(path))
+
+    # `None` is guaranteed to be the root node by resolvelib.
+    visit(None)
+
+    # Sanity checks
+    assert weights[None] == 0
+    assert len(weights) == len(graph)
+
+    return weights
+
+
+def _req_set_item_sorter(
+    item,     # type: Tuple[str, InstallRequirement]
+    weights,  # type: Dict[Optional[str], int]
+):
+    # type: (...) -> Tuple[int, str]
+    """Key function used to sort install requirements for installation.
+
+    Based on the "weight" mapping calculated in ``get_installation_order()``.
+    The canonical package name is returned as the second member as a tie-
+    breaker to ensure the result is predictable, which is useful in tests.
+    """
+    name = canonicalize_name(item[0])
+    return weights[name], name
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/self_outdated_check.py b/myenv/lib/python3.9/site-packages/pip/_internal/self_outdated_check.py
new file mode 100644
index 0000000..fbd9dfd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/self_outdated_check.py
@@ -0,0 +1,205 @@
+from __future__ import absolute_import
+
+import datetime
+import hashlib
+import json
+import logging
+import os.path
+import sys
+
+from pip._vendor.packaging import version as packaging_version
+from pip._vendor.six import ensure_binary
+
+from pip._internal.index.collector import LinkCollector
+from pip._internal.index.package_finder import PackageFinder
+from pip._internal.models.selection_prefs import SelectionPreferences
+from pip._internal.utils.filesystem import (
+    adjacent_tmp_file,
+    check_path_owner,
+    replace,
+)
+from pip._internal.utils.misc import (
+    ensure_dir,
+    get_distribution,
+    get_installed_version,
+)
+from pip._internal.utils.packaging import get_installer
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    import optparse
+    from typing import Any, Dict, Text, Union
+
+    from pip._internal.network.session import PipSession
+
+
+SELFCHECK_DATE_FMT = "%Y-%m-%dT%H:%M:%SZ"
+
+
+logger = logging.getLogger(__name__)
+
+
+def _get_statefile_name(key):
+    # type: (Union[str, Text]) -> str
+    key_bytes = ensure_binary(key)
+    name = hashlib.sha224(key_bytes).hexdigest()
+    return name
+
+
+class SelfCheckState(object):
+    def __init__(self, cache_dir):
+        # type: (str) -> None
+        self.state = {}  # type: Dict[str, Any]
+        self.statefile_path = None
+
+        # Try to load the existing state
+        if cache_dir:
+            self.statefile_path = os.path.join(
+                cache_dir, "selfcheck", _get_statefile_name(self.key)
+            )
+            try:
+                with open(self.statefile_path) as statefile:
+                    self.state = json.load(statefile)
+            except (IOError, ValueError, KeyError):
+                # Explicitly suppressing exceptions, since we don't want to
+                # error out if the cache file is invalid.
+                pass
+
+    @property
+    def key(self):
+        # type: () -> str
+        return sys.prefix
+
+    def save(self, pypi_version, current_time):
+        # type: (str, datetime.datetime) -> None
+        # If we do not have a path to cache in, don't bother saving.
+        if not self.statefile_path:
+            return
+
+        # Check to make sure that we own the directory
+        if not check_path_owner(os.path.dirname(self.statefile_path)):
+            return
+
+        # Now that we've ensured the directory is owned by this user, we'll go
+        # ahead and make sure that all our directories are created.
+        ensure_dir(os.path.dirname(self.statefile_path))
+
+        state = {
+            # Include the key so it's easy to tell which pip wrote the
+            # file.
+            "key": self.key,
+            "last_check": current_time.strftime(SELFCHECK_DATE_FMT),
+            "pypi_version": pypi_version,
+        }
+
+        text = json.dumps(state, sort_keys=True, separators=(",", ":"))
+
+        with adjacent_tmp_file(self.statefile_path) as f:
+            f.write(ensure_binary(text))
+
+        try:
+            # Since we have a prefix-specific state file, we can just
+            # overwrite whatever is there, no need to check.
+            replace(f.name, self.statefile_path)
+        except OSError:
+            # Best effort.
+            pass
+
+
+def was_installed_by_pip(pkg):
+    # type: (str) -> bool
+    """Checks whether pkg was installed by pip
+
+    This is used not to display the upgrade message when pip is in fact
+    installed by system package manager, such as dnf on Fedora.
+    """
+    dist = get_distribution(pkg)
+    if not dist:
+        return False
+    return "pip" == get_installer(dist)
+
+
+def pip_self_version_check(session, options):
+    # type: (PipSession, optparse.Values) -> None
+    """Check for an update for pip.
+
+    Limit the frequency of checks to once per week. State is stored either in
+    the active virtualenv or in the user's USER_CACHE_DIR keyed off the prefix
+    of the pip script path.
+    """
+    installed_version = get_installed_version("pip")
+    if not installed_version:
+        return
+
+    pip_version = packaging_version.parse(installed_version)
+    pypi_version = None
+
+    try:
+        state = SelfCheckState(cache_dir=options.cache_dir)
+
+        current_time = datetime.datetime.utcnow()
+        # Determine if we need to refresh the state
+        if "last_check" in state.state and "pypi_version" in state.state:
+            last_check = datetime.datetime.strptime(
+                state.state["last_check"],
+                SELFCHECK_DATE_FMT
+            )
+            if (current_time - last_check).total_seconds() < 7 * 24 * 60 * 60:
+                pypi_version = state.state["pypi_version"]
+
+        # Refresh the version if we need to or just see if we need to warn
+        if pypi_version is None:
+            # Lets use PackageFinder to see what the latest pip version is
+            link_collector = LinkCollector.create(
+                session,
+                options=options,
+                suppress_no_index=True,
+            )
+
+            # Pass allow_yanked=False so we don't suggest upgrading to a
+            # yanked version.
+            selection_prefs = SelectionPreferences(
+                allow_yanked=False,
+                allow_all_prereleases=False,  # Explicitly set to False
+            )
+
+            finder = PackageFinder.create(
+                link_collector=link_collector,
+                selection_prefs=selection_prefs,
+            )
+            best_candidate = finder.find_best_candidate("pip").best_candidate
+            if best_candidate is None:
+                return
+            pypi_version = str(best_candidate.version)
+
+            # save that we've performed a check
+            state.save(pypi_version, current_time)
+
+        remote_version = packaging_version.parse(pypi_version)
+
+        local_version_is_older = (
+            pip_version < remote_version and
+            pip_version.base_version != remote_version.base_version and
+            was_installed_by_pip('pip')
+        )
+
+        # Determine if our pypi_version is older
+        if not local_version_is_older:
+            return
+
+        # We cannot tell how the current pip is available in the current
+        # command context, so be pragmatic here and suggest the command
+        # that's always available. This does not accommodate spaces in
+        # `sys.executable`.
+        pip_cmd = "{} -m pip".format(sys.executable)
+        logger.warning(
+            "You are using pip version %s; however, version %s is "
+            "available.\nYou should consider upgrading via the "
+            "'%s install --upgrade pip' command.",
+            pip_version, pypi_version, pip_cmd
+        )
+    except Exception:
+        logger.debug(
+            "There was an error checking the latest version of pip",
+            exc_info=True,
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/appdirs.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/appdirs.py
new file mode 100644
index 0000000..3989ed3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/appdirs.py
@@ -0,0 +1,44 @@
+"""
+This code wraps the vendored appdirs module to so the return values are
+compatible for the current pip code base.
+
+The intention is to rewrite current usages gradually, keeping the tests pass,
+and eventually drop this after all usages are changed.
+"""
+
+from __future__ import absolute_import
+
+import os
+
+from pip._vendor import appdirs as _appdirs
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List
+
+
+def user_cache_dir(appname):
+    # type: (str) -> str
+    return _appdirs.user_cache_dir(appname, appauthor=False)
+
+
+def user_config_dir(appname, roaming=True):
+    # type: (str, bool) -> str
+    path = _appdirs.user_config_dir(appname, appauthor=False, roaming=roaming)
+    if _appdirs.system == "darwin" and not os.path.isdir(path):
+        path = os.path.expanduser('~/.config/')
+        if appname:
+            path = os.path.join(path, appname)
+    return path
+
+
+# for the discussion regarding site_config_dir locations
+# see <https://github.com/pypa/pip/issues/1733>
+def site_config_dirs(appname):
+    # type: (str) -> List[str]
+    dirval = _appdirs.site_config_dir(appname, appauthor=False, multipath=True)
+    if _appdirs.system not in ["win32", "darwin"]:
+        # always look in /etc directly as well
+        return dirval.split(os.pathsep) + ['/etc']
+    return [dirval]
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/compat.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/compat.py
new file mode 100644
index 0000000..89c5169
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/compat.py
@@ -0,0 +1,271 @@
+"""Stuff that differs in different Python versions and platform
+distributions."""
+
+# The following comment should be removed at some point in the future.
+# mypy: disallow-untyped-defs=False
+
+from __future__ import absolute_import, division
+
+import codecs
+import locale
+import logging
+import os
+import shutil
+import sys
+
+from pip._vendor.six import PY2, text_type
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, Text, Tuple, Union
+
+try:
+    import ipaddress
+except ImportError:
+    try:
+        from pip._vendor import ipaddress  # type: ignore
+    except ImportError:
+        import ipaddr as ipaddress  # type: ignore
+        ipaddress.ip_address = ipaddress.IPAddress  # type: ignore
+        ipaddress.ip_network = ipaddress.IPNetwork  # type: ignore
+
+
+__all__ = [
+    "ipaddress", "uses_pycache", "console_to_str",
+    "get_path_uid", "stdlib_pkgs", "WINDOWS", "samefile", "get_terminal_size",
+]
+
+
+logger = logging.getLogger(__name__)
+
+if PY2:
+    import imp
+
+    try:
+        cache_from_source = imp.cache_from_source  # type: ignore
+    except AttributeError:
+        # does not use __pycache__
+        cache_from_source = None
+
+    uses_pycache = cache_from_source is not None
+else:
+    uses_pycache = True
+    from importlib.util import cache_from_source
+
+
+if PY2:
+    # In Python 2.7, backslashreplace exists
+    # but does not support use for decoding.
+    # We implement our own replace handler for this
+    # situation, so that we can consistently use
+    # backslash replacement for all versions.
+    def backslashreplace_decode_fn(err):
+        raw_bytes = (err.object[i] for i in range(err.start, err.end))
+        # Python 2 gave us characters - convert to numeric bytes
+        raw_bytes = (ord(b) for b in raw_bytes)
+        return u"".join(map(u"\\x{:x}".format, raw_bytes)), err.end
+    codecs.register_error(
+        "backslashreplace_decode",
+        backslashreplace_decode_fn,
+    )
+    backslashreplace_decode = "backslashreplace_decode"
+else:
+    backslashreplace_decode = "backslashreplace"
+
+
+def has_tls():
+    # type: () -> bool
+    try:
+        import _ssl  # noqa: F401  # ignore unused
+        return True
+    except ImportError:
+        pass
+
+    from pip._vendor.urllib3.util import IS_PYOPENSSL
+    return IS_PYOPENSSL
+
+
+def str_to_display(data, desc=None):
+    # type: (Union[bytes, Text], Optional[str]) -> Text
+    """
+    For display or logging purposes, convert a bytes object (or text) to
+    text (e.g. unicode in Python 2) safe for output.
+
+    :param desc: An optional phrase describing the input data, for use in
+        the log message if a warning is logged. Defaults to "Bytes object".
+
+    This function should never error out and so can take a best effort
+    approach. It is okay to be lossy if needed since the return value is
+    just for display.
+
+    We assume the data is in the locale preferred encoding. If it won't
+    decode properly, we warn the user but decode as best we can.
+
+    We also ensure that the output can be safely written to standard output
+    without encoding errors.
+    """
+    if isinstance(data, text_type):
+        return data
+
+    # Otherwise, data is a bytes object (str in Python 2).
+    # First, get the encoding we assume. This is the preferred
+    # encoding for the locale, unless that is not found, or
+    # it is ASCII, in which case assume UTF-8
+    encoding = locale.getpreferredencoding()
+    if (not encoding) or codecs.lookup(encoding).name == "ascii":
+        encoding = "utf-8"
+
+    # Now try to decode the data - if we fail, warn the user and
+    # decode with replacement.
+    try:
+        decoded_data = data.decode(encoding)
+    except UnicodeDecodeError:
+        logger.warning(
+            '%s does not appear to be encoded as %s',
+            desc or 'Bytes object',
+            encoding,
+        )
+        decoded_data = data.decode(encoding, errors=backslashreplace_decode)
+
+    # Make sure we can print the output, by encoding it to the output
+    # encoding with replacement of unencodable characters, and then
+    # decoding again.
+    # We use stderr's encoding because it's less likely to be
+    # redirected and if we don't find an encoding we skip this
+    # step (on the assumption that output is wrapped by something
+    # that won't fail).
+    # The double getattr is to deal with the possibility that we're
+    # being called in a situation where sys.__stderr__ doesn't exist,
+    # or doesn't have an encoding attribute. Neither of these cases
+    # should occur in normal pip use, but there's no harm in checking
+    # in case people use pip in (unsupported) unusual situations.
+    output_encoding = getattr(getattr(sys, "__stderr__", None),
+                              "encoding", None)
+
+    if output_encoding:
+        output_encoded = decoded_data.encode(
+            output_encoding,
+            errors="backslashreplace"
+        )
+        decoded_data = output_encoded.decode(output_encoding)
+
+    return decoded_data
+
+
+def console_to_str(data):
+    # type: (bytes) -> Text
+    """Return a string, safe for output, of subprocess output.
+    """
+    return str_to_display(data, desc='Subprocess output')
+
+
+def get_path_uid(path):
+    # type: (str) -> int
+    """
+    Return path's uid.
+
+    Does not follow symlinks:
+        https://github.com/pypa/pip/pull/935#discussion_r5307003
+
+    Placed this function in compat due to differences on AIX and
+    Jython, that should eventually go away.
+
+    :raises OSError: When path is a symlink or can't be read.
+    """
+    if hasattr(os, 'O_NOFOLLOW'):
+        fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW)
+        file_uid = os.fstat(fd).st_uid
+        os.close(fd)
+    else:  # AIX and Jython
+        # WARNING: time of check vulnerability, but best we can do w/o NOFOLLOW
+        if not os.path.islink(path):
+            # older versions of Jython don't have `os.fstat`
+            file_uid = os.stat(path).st_uid
+        else:
+            # raise OSError for parity with os.O_NOFOLLOW above
+            raise OSError(
+                "{} is a symlink; Will not return uid for symlinks".format(
+                    path)
+            )
+    return file_uid
+
+
+def expanduser(path):
+    # type: (str) -> str
+    """
+    Expand ~ and ~user constructions.
+
+    Includes a workaround for https://bugs.python.org/issue14768
+    """
+    expanded = os.path.expanduser(path)
+    if path.startswith('~/') and expanded.startswith('//'):
+        expanded = expanded[1:]
+    return expanded
+
+
+# packages in the stdlib that may have installation metadata, but should not be
+# considered 'installed'.  this theoretically could be determined based on
+# dist.location (py27:`sysconfig.get_paths()['stdlib']`,
+# py26:sysconfig.get_config_vars('LIBDEST')), but fear platform variation may
+# make this ineffective, so hard-coding
+stdlib_pkgs = {"python", "wsgiref", "argparse"}
+
+
+# windows detection, covers cpython and ironpython
+WINDOWS = (sys.platform.startswith("win") or
+           (sys.platform == 'cli' and os.name == 'nt'))
+
+
+def samefile(file1, file2):
+    # type: (str, str) -> bool
+    """Provide an alternative for os.path.samefile on Windows/Python2"""
+    if hasattr(os.path, 'samefile'):
+        return os.path.samefile(file1, file2)
+    else:
+        path1 = os.path.normcase(os.path.abspath(file1))
+        path2 = os.path.normcase(os.path.abspath(file2))
+        return path1 == path2
+
+
+if hasattr(shutil, 'get_terminal_size'):
+    def get_terminal_size():
+        # type: () -> Tuple[int, int]
+        """
+        Returns a tuple (x, y) representing the width(x) and the height(y)
+        in characters of the terminal window.
+        """
+        return tuple(shutil.get_terminal_size())  # type: ignore
+else:
+    def get_terminal_size():
+        # type: () -> Tuple[int, int]
+        """
+        Returns a tuple (x, y) representing the width(x) and the height(y)
+        in characters of the terminal window.
+        """
+        def ioctl_GWINSZ(fd):
+            try:
+                import fcntl
+                import termios
+                import struct
+                cr = struct.unpack_from(
+                    'hh',
+                    fcntl.ioctl(fd, termios.TIOCGWINSZ, '12345678')
+                )
+            except Exception:
+                return None
+            if cr == (0, 0):
+                return None
+            return cr
+        cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
+        if not cr:
+            if sys.platform != "win32":
+                try:
+                    fd = os.open(os.ctermid(), os.O_RDONLY)
+                    cr = ioctl_GWINSZ(fd)
+                    os.close(fd)
+                except Exception:
+                    pass
+        if not cr:
+            cr = (os.environ.get('LINES', 25), os.environ.get('COLUMNS', 80))
+        return int(cr[1]), int(cr[0])
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/compatibility_tags.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/compatibility_tags.py
new file mode 100644
index 0000000..4f21874
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/compatibility_tags.py
@@ -0,0 +1,166 @@
+"""Generate and work with PEP 425 Compatibility Tags.
+"""
+
+from __future__ import absolute_import
+
+import re
+
+from pip._vendor.packaging.tags import (
+    Tag,
+    compatible_tags,
+    cpython_tags,
+    generic_tags,
+    interpreter_name,
+    interpreter_version,
+    mac_platforms,
+)
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Optional, Tuple
+
+    from pip._vendor.packaging.tags import PythonVersion
+
+_osx_arch_pat = re.compile(r'(.+)_(\d+)_(\d+)_(.+)')
+
+
+def version_info_to_nodot(version_info):
+    # type: (Tuple[int, ...]) -> str
+    # Only use up to the first two numbers.
+    return ''.join(map(str, version_info[:2]))
+
+
+def _mac_platforms(arch):
+    # type: (str) -> List[str]
+    match = _osx_arch_pat.match(arch)
+    if match:
+        name, major, minor, actual_arch = match.groups()
+        mac_version = (int(major), int(minor))
+        arches = [
+            # Since we have always only checked that the platform starts
+            # with "macosx", for backwards-compatibility we extract the
+            # actual prefix provided by the user in case they provided
+            # something like "macosxcustom_". It may be good to remove
+            # this as undocumented or deprecate it in the future.
+            '{}_{}'.format(name, arch[len('macosx_'):])
+            for arch in mac_platforms(mac_version, actual_arch)
+        ]
+    else:
+        # arch pattern didn't match (?!)
+        arches = [arch]
+    return arches
+
+
+def _custom_manylinux_platforms(arch):
+    # type: (str) -> List[str]
+    arches = [arch]
+    arch_prefix, arch_sep, arch_suffix = arch.partition('_')
+    if arch_prefix == 'manylinux2014':
+        # manylinux1/manylinux2010 wheels run on most manylinux2014 systems
+        # with the exception of wheels depending on ncurses. PEP 599 states
+        # manylinux1/manylinux2010 wheels should be considered
+        # manylinux2014 wheels:
+        # https://www.python.org/dev/peps/pep-0599/#backwards-compatibility-with-manylinux2010-wheels
+        if arch_suffix in {'i686', 'x86_64'}:
+            arches.append('manylinux2010' + arch_sep + arch_suffix)
+            arches.append('manylinux1' + arch_sep + arch_suffix)
+    elif arch_prefix == 'manylinux2010':
+        # manylinux1 wheels run on most manylinux2010 systems with the
+        # exception of wheels depending on ncurses. PEP 571 states
+        # manylinux1 wheels should be considered manylinux2010 wheels:
+        # https://www.python.org/dev/peps/pep-0571/#backwards-compatibility-with-manylinux1-wheels
+        arches.append('manylinux1' + arch_sep + arch_suffix)
+    return arches
+
+
+def _get_custom_platforms(arch):
+    # type: (str) -> List[str]
+    arch_prefix, arch_sep, arch_suffix = arch.partition('_')
+    if arch.startswith('macosx'):
+        arches = _mac_platforms(arch)
+    elif arch_prefix in ['manylinux2014', 'manylinux2010']:
+        arches = _custom_manylinux_platforms(arch)
+    else:
+        arches = [arch]
+    return arches
+
+
+def _get_python_version(version):
+    # type: (str) -> PythonVersion
+    if len(version) > 1:
+        return int(version[0]), int(version[1:])
+    else:
+        return (int(version[0]),)
+
+
+def _get_custom_interpreter(implementation=None, version=None):
+    # type: (Optional[str], Optional[str]) -> str
+    if implementation is None:
+        implementation = interpreter_name()
+    if version is None:
+        version = interpreter_version()
+    return "{}{}".format(implementation, version)
+
+
+def get_supported(
+    version=None,  # type: Optional[str]
+    platform=None,  # type: Optional[str]
+    impl=None,  # type: Optional[str]
+    abi=None  # type: Optional[str]
+):
+    # type: (...) -> List[Tag]
+    """Return a list of supported tags for each version specified in
+    `versions`.
+
+    :param version: a string version, of the form "33" or "32",
+        or None. The version will be assumed to support our ABI.
+    :param platform: specify the exact platform you want valid
+        tags for, or None. If None, use the local system platform.
+    :param impl: specify the exact implementation you want valid
+        tags for, or None. If None, use the local interpreter impl.
+    :param abi: specify the exact abi you want valid
+        tags for, or None. If None, use the local interpreter abi.
+    """
+    supported = []  # type: List[Tag]
+
+    python_version = None  # type: Optional[PythonVersion]
+    if version is not None:
+        python_version = _get_python_version(version)
+
+    interpreter = _get_custom_interpreter(impl, version)
+
+    abis = None  # type: Optional[List[str]]
+    if abi is not None:
+        abis = [abi]
+
+    platforms = None  # type: Optional[List[str]]
+    if platform is not None:
+        platforms = _get_custom_platforms(platform)
+
+    is_cpython = (impl or interpreter_name()) == "cp"
+    if is_cpython:
+        supported.extend(
+            cpython_tags(
+                python_version=python_version,
+                abis=abis,
+                platforms=platforms,
+            )
+        )
+    else:
+        supported.extend(
+            generic_tags(
+                interpreter=interpreter,
+                abis=abis,
+                platforms=platforms,
+            )
+        )
+    supported.extend(
+        compatible_tags(
+            python_version=python_version,
+            interpreter=interpreter,
+            platforms=platforms,
+        )
+    )
+
+    return supported
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/datetime.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/datetime.py
new file mode 100644
index 0000000..4d0503c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/datetime.py
@@ -0,0 +1,14 @@
+"""For when pip wants to check the date or time.
+"""
+
+from __future__ import absolute_import
+
+import datetime
+
+
+def today_is_later_than(year, month, day):
+    # type: (int, int, int) -> bool
+    today = datetime.date.today()
+    given = datetime.date(year, month, day)
+
+    return today > given
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/deprecation.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/deprecation.py
new file mode 100644
index 0000000..2f20cfd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/deprecation.py
@@ -0,0 +1,104 @@
+"""
+A module that implements tooling to enable easy warnings about deprecations.
+"""
+
+# The following comment should be removed at some point in the future.
+# mypy: disallow-untyped-defs=False
+
+from __future__ import absolute_import
+
+import logging
+import warnings
+
+from pip._vendor.packaging.version import parse
+
+from pip import __version__ as current_version
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any, Optional
+
+
+DEPRECATION_MSG_PREFIX = "DEPRECATION: "
+
+
+class PipDeprecationWarning(Warning):
+    pass
+
+
+_original_showwarning = None  # type: Any
+
+
+# Warnings <-> Logging Integration
+def _showwarning(message, category, filename, lineno, file=None, line=None):
+    if file is not None:
+        if _original_showwarning is not None:
+            _original_showwarning(
+                message, category, filename, lineno, file, line,
+            )
+    elif issubclass(category, PipDeprecationWarning):
+        # We use a specially named logger which will handle all of the
+        # deprecation messages for pip.
+        logger = logging.getLogger("pip._internal.deprecations")
+        logger.warning(message)
+    else:
+        _original_showwarning(
+            message, category, filename, lineno, file, line,
+        )
+
+
+def install_warning_logger():
+    # type: () -> None
+    # Enable our Deprecation Warnings
+    warnings.simplefilter("default", PipDeprecationWarning, append=True)
+
+    global _original_showwarning
+
+    if _original_showwarning is None:
+        _original_showwarning = warnings.showwarning
+        warnings.showwarning = _showwarning
+
+
+def deprecated(reason, replacement, gone_in, issue=None):
+    # type: (str, Optional[str], Optional[str], Optional[int]) -> None
+    """Helper to deprecate existing functionality.
+
+    reason:
+        Textual reason shown to the user about why this functionality has
+        been deprecated.
+    replacement:
+        Textual suggestion shown to the user about what alternative
+        functionality they can use.
+    gone_in:
+        The version of pip does this functionality should get removed in.
+        Raises errors if pip's current version is greater than or equal to
+        this.
+    issue:
+        Issue number on the tracker that would serve as a useful place for
+        users to find related discussion and provide feedback.
+
+    Always pass replacement, gone_in and issue as keyword arguments for clarity
+    at the call site.
+    """
+
+    # Construct a nice message.
+    #   This is eagerly formatted as we want it to get logged as if someone
+    #   typed this entire message out.
+    sentences = [
+        (reason, DEPRECATION_MSG_PREFIX + "{}"),
+        (gone_in, "pip {} will remove support for this functionality."),
+        (replacement, "A possible replacement is {}."),
+        (issue, (
+            "You can find discussion regarding this at "
+            "https://github.com/pypa/pip/issues/{}."
+        )),
+    ]
+    message = " ".join(
+        template.format(val) for val, template in sentences if val is not None
+    )
+
+    # Raise as an error if it has to be removed.
+    if gone_in is not None and parse(current_version) >= parse(gone_in):
+        raise PipDeprecationWarning(message)
+
+    warnings.warn(message, category=PipDeprecationWarning, stacklevel=2)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/direct_url_helpers.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/direct_url_helpers.py
new file mode 100644
index 0000000..f1fe209
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/direct_url_helpers.py
@@ -0,0 +1,130 @@
+import logging
+
+from pip._internal.models.direct_url import (
+    DIRECT_URL_METADATA_NAME,
+    ArchiveInfo,
+    DirectUrl,
+    DirectUrlValidationError,
+    DirInfo,
+    VcsInfo,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.vcs import vcs
+
+try:
+    from json import JSONDecodeError
+except ImportError:
+    # PY2
+    JSONDecodeError = ValueError  # type: ignore
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional
+
+    from pip._internal.models.link import Link
+
+    from pip._vendor.pkg_resources import Distribution
+
+logger = logging.getLogger(__name__)
+
+
+def direct_url_as_pep440_direct_reference(direct_url, name):
+    # type: (DirectUrl, str) -> str
+    """Convert a DirectUrl to a pip requirement string."""
+    direct_url.validate()  # if invalid, this is a pip bug
+    requirement = name + " @ "
+    fragments = []
+    if isinstance(direct_url.info, VcsInfo):
+        requirement += "{}+{}@{}".format(
+            direct_url.info.vcs, direct_url.url, direct_url.info.commit_id
+        )
+    elif isinstance(direct_url.info, ArchiveInfo):
+        requirement += direct_url.url
+        if direct_url.info.hash:
+            fragments.append(direct_url.info.hash)
+    else:
+        assert isinstance(direct_url.info, DirInfo)
+        # pip should never reach this point for editables, since
+        # pip freeze inspects the editable project location to produce
+        # the requirement string
+        assert not direct_url.info.editable
+        requirement += direct_url.url
+    if direct_url.subdirectory:
+        fragments.append("subdirectory=" + direct_url.subdirectory)
+    if fragments:
+        requirement += "#" + "&".join(fragments)
+    return requirement
+
+
+def direct_url_from_link(link, source_dir=None, link_is_in_wheel_cache=False):
+    # type: (Link, Optional[str], bool) -> DirectUrl
+    if link.is_vcs:
+        vcs_backend = vcs.get_backend_for_scheme(link.scheme)
+        assert vcs_backend
+        url, requested_revision, _ = (
+            vcs_backend.get_url_rev_and_auth(link.url_without_fragment)
+        )
+        # For VCS links, we need to find out and add commit_id.
+        if link_is_in_wheel_cache:
+            # If the requested VCS link corresponds to a cached
+            # wheel, it means the requested revision was an
+            # immutable commit hash, otherwise it would not have
+            # been cached. In that case we don't have a source_dir
+            # with the VCS checkout.
+            assert requested_revision
+            commit_id = requested_revision
+        else:
+            # If the wheel was not in cache, it means we have
+            # had to checkout from VCS to build and we have a source_dir
+            # which we can inspect to find out the commit id.
+            assert source_dir
+            commit_id = vcs_backend.get_revision(source_dir)
+        return DirectUrl(
+            url=url,
+            info=VcsInfo(
+                vcs=vcs_backend.name,
+                commit_id=commit_id,
+                requested_revision=requested_revision,
+            ),
+            subdirectory=link.subdirectory_fragment,
+        )
+    elif link.is_existing_dir():
+        return DirectUrl(
+            url=link.url_without_fragment,
+            info=DirInfo(),
+            subdirectory=link.subdirectory_fragment,
+        )
+    else:
+        hash = None
+        hash_name = link.hash_name
+        if hash_name:
+            hash = "{}={}".format(hash_name, link.hash)
+        return DirectUrl(
+            url=link.url_without_fragment,
+            info=ArchiveInfo(hash=hash),
+            subdirectory=link.subdirectory_fragment,
+        )
+
+
+def dist_get_direct_url(dist):
+    # type: (Distribution) -> Optional[DirectUrl]
+    """Obtain a DirectUrl from a pkg_resource.Distribution.
+
+    Returns None if the distribution has no `direct_url.json` metadata,
+    or if `direct_url.json` is invalid.
+    """
+    if not dist.has_metadata(DIRECT_URL_METADATA_NAME):
+        return None
+    try:
+        return DirectUrl.from_json(dist.get_metadata(DIRECT_URL_METADATA_NAME))
+    except (
+        DirectUrlValidationError,
+        JSONDecodeError,
+        UnicodeDecodeError
+    ) as e:
+        logger.warning(
+            "Error parsing %s for %s: %s",
+            DIRECT_URL_METADATA_NAME,
+            dist.project_name,
+            e,
+        )
+        return None
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/distutils_args.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/distutils_args.py
new file mode 100644
index 0000000..e38e402
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/distutils_args.py
@@ -0,0 +1,48 @@
+from distutils.errors import DistutilsArgError
+from distutils.fancy_getopt import FancyGetopt
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Dict, List
+
+
+_options = [
+    ("exec-prefix=", None, ""),
+    ("home=", None, ""),
+    ("install-base=", None, ""),
+    ("install-data=", None, ""),
+    ("install-headers=", None, ""),
+    ("install-lib=", None, ""),
+    ("install-platlib=", None, ""),
+    ("install-purelib=", None, ""),
+    ("install-scripts=", None, ""),
+    ("prefix=", None, ""),
+    ("root=", None, ""),
+    ("user", None, ""),
+]
+
+
+# typeshed doesn't permit Tuple[str, None, str], see python/typeshed#3469.
+_distutils_getopt = FancyGetopt(_options)  # type: ignore
+
+
+def parse_distutils_args(args):
+    # type: (List[str]) -> Dict[str, str]
+    """Parse provided arguments, returning an object that has the
+    matched arguments.
+
+    Any unknown arguments are ignored.
+    """
+    result = {}
+    for arg in args:
+        try:
+            _, match = _distutils_getopt.getopt(args=[arg])
+        except DistutilsArgError:
+            # We don't care about any other options, which here may be
+            # considered unrecognized since our option list is not
+            # exhaustive.
+            pass
+        else:
+            result.update(match.__dict__)
+    return result
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/encoding.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/encoding.py
new file mode 100644
index 0000000..5b83d61
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/encoding.py
@@ -0,0 +1,41 @@
+import codecs
+import locale
+import re
+import sys
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Tuple, Text
+
+BOMS = [
+    (codecs.BOM_UTF8, 'utf-8'),
+    (codecs.BOM_UTF16, 'utf-16'),
+    (codecs.BOM_UTF16_BE, 'utf-16-be'),
+    (codecs.BOM_UTF16_LE, 'utf-16-le'),
+    (codecs.BOM_UTF32, 'utf-32'),
+    (codecs.BOM_UTF32_BE, 'utf-32-be'),
+    (codecs.BOM_UTF32_LE, 'utf-32-le'),
+]  # type: List[Tuple[bytes, Text]]
+
+ENCODING_RE = re.compile(br'coding[:=]\s*([-\w.]+)')
+
+
+def auto_decode(data):
+    # type: (bytes) -> Text
+    """Check a bytes string for a BOM to correctly detect the encoding
+
+    Fallback to locale.getpreferredencoding(False) like open() on Python3"""
+    for bom, encoding in BOMS:
+        if data.startswith(bom):
+            return data[len(bom):].decode(encoding)
+    # Lets check the first two lines as in PEP263
+    for line in data.split(b'\n')[:2]:
+        if line[0:1] == b'#' and ENCODING_RE.search(line):
+            result = ENCODING_RE.search(line)
+            assert result is not None
+            encoding = result.groups()[0].decode('ascii')
+            return data.decode(encoding)
+    return data.decode(
+        locale.getpreferredencoding(False) or sys.getdefaultencoding(),
+    )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/entrypoints.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/entrypoints.py
new file mode 100644
index 0000000..befd01c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/entrypoints.py
@@ -0,0 +1,31 @@
+import sys
+
+from pip._internal.cli.main import main
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, List
+
+
+def _wrapper(args=None):
+    # type: (Optional[List[str]]) -> int
+    """Central wrapper for all old entrypoints.
+
+    Historically pip has had several entrypoints defined. Because of issues
+    arising from PATH, sys.path, multiple Pythons, their interactions, and most
+    of them having a pip installed, users suffer every time an entrypoint gets
+    moved.
+
+    To alleviate this pain, and provide a mechanism for warning users and
+    directing them to an appropriate place for help, we now define all of
+    our old entrypoints as wrappers for the current one.
+    """
+    sys.stderr.write(
+        "WARNING: pip is being invoked by an old script wrapper. This will "
+        "fail in a future version of pip.\n"
+        "Please see https://github.com/pypa/pip/issues/5599 for advice on "
+        "fixing the underlying issue.\n"
+        "To avoid this problem you can invoke Python with '-m pip' instead of "
+        "running pip directly.\n"
+    )
+    return main(args)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/filesystem.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/filesystem.py
new file mode 100644
index 0000000..303243f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/filesystem.py
@@ -0,0 +1,224 @@
+import errno
+import fnmatch
+import os
+import os.path
+import random
+import shutil
+import stat
+import sys
+from contextlib import contextmanager
+from tempfile import NamedTemporaryFile
+
+# NOTE: retrying is not annotated in typeshed as on 2017-07-17, which is
+#       why we ignore the type on this import.
+from pip._vendor.retrying import retry  # type: ignore
+from pip._vendor.six import PY2
+
+from pip._internal.utils.compat import get_path_uid
+from pip._internal.utils.misc import format_size
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING, cast
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any, BinaryIO, Iterator, List, Union
+
+    class NamedTemporaryFileResult(BinaryIO):
+        @property
+        def file(self):
+            # type: () -> BinaryIO
+            pass
+
+
+def check_path_owner(path):
+    # type: (str) -> bool
+    # If we don't have a way to check the effective uid of this process, then
+    # we'll just assume that we own the directory.
+    if sys.platform == "win32" or not hasattr(os, "geteuid"):
+        return True
+
+    assert os.path.isabs(path)
+
+    previous = None
+    while path != previous:
+        if os.path.lexists(path):
+            # Check if path is writable by current user.
+            if os.geteuid() == 0:
+                # Special handling for root user in order to handle properly
+                # cases where users use sudo without -H flag.
+                try:
+                    path_uid = get_path_uid(path)
+                except OSError:
+                    return False
+                return path_uid == 0
+            else:
+                return os.access(path, os.W_OK)
+        else:
+            previous, path = path, os.path.dirname(path)
+    return False  # assume we don't own the path
+
+
+def copy2_fixed(src, dest):
+    # type: (str, str) -> None
+    """Wrap shutil.copy2() but map errors copying socket files to
+    SpecialFileError as expected.
+
+    See also https://bugs.python.org/issue37700.
+    """
+    try:
+        shutil.copy2(src, dest)
+    except (OSError, IOError):
+        for f in [src, dest]:
+            try:
+                is_socket_file = is_socket(f)
+            except OSError:
+                # An error has already occurred. Another error here is not
+                # a problem and we can ignore it.
+                pass
+            else:
+                if is_socket_file:
+                    raise shutil.SpecialFileError(
+                        "`{f}` is a socket".format(**locals()))
+
+        raise
+
+
+def is_socket(path):
+    # type: (str) -> bool
+    return stat.S_ISSOCK(os.lstat(path).st_mode)
+
+
+@contextmanager
+def adjacent_tmp_file(path, **kwargs):
+    # type: (str, **Any) -> Iterator[NamedTemporaryFileResult]
+    """Return a file-like object pointing to a tmp file next to path.
+
+    The file is created securely and is ensured to be written to disk
+    after the context reaches its end.
+
+    kwargs will be passed to tempfile.NamedTemporaryFile to control
+    the way the temporary file will be opened.
+    """
+    with NamedTemporaryFile(
+        delete=False,
+        dir=os.path.dirname(path),
+        prefix=os.path.basename(path),
+        suffix='.tmp',
+        **kwargs
+    ) as f:
+        result = cast('NamedTemporaryFileResult', f)
+        try:
+            yield result
+        finally:
+            result.file.flush()
+            os.fsync(result.file.fileno())
+
+
+_replace_retry = retry(stop_max_delay=1000, wait_fixed=250)
+
+if PY2:
+    @_replace_retry
+    def replace(src, dest):
+        # type: (str, str) -> None
+        try:
+            os.rename(src, dest)
+        except OSError:
+            os.remove(dest)
+            os.rename(src, dest)
+
+else:
+    replace = _replace_retry(os.replace)
+
+
+# test_writable_dir and _test_writable_dir_win are copied from Flit,
+# with the author's agreement to also place them under pip's license.
+def test_writable_dir(path):
+    # type: (str) -> bool
+    """Check if a directory is writable.
+
+    Uses os.access() on POSIX, tries creating files on Windows.
+    """
+    # If the directory doesn't exist, find the closest parent that does.
+    while not os.path.isdir(path):
+        parent = os.path.dirname(path)
+        if parent == path:
+            break  # Should never get here, but infinite loops are bad
+        path = parent
+
+    if os.name == 'posix':
+        return os.access(path, os.W_OK)
+
+    return _test_writable_dir_win(path)
+
+
+def _test_writable_dir_win(path):
+    # type: (str) -> bool
+    # os.access doesn't work on Windows: http://bugs.python.org/issue2528
+    # and we can't use tempfile: http://bugs.python.org/issue22107
+    basename = 'accesstest_deleteme_fishfingers_custard_'
+    alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789'
+    for _ in range(10):
+        name = basename + ''.join(random.choice(alphabet) for _ in range(6))
+        file = os.path.join(path, name)
+        try:
+            fd = os.open(file, os.O_RDWR | os.O_CREAT | os.O_EXCL)
+        # Python 2 doesn't support FileExistsError and PermissionError.
+        except OSError as e:
+            # exception FileExistsError
+            if e.errno == errno.EEXIST:
+                continue
+            # exception PermissionError
+            if e.errno == errno.EPERM or e.errno == errno.EACCES:
+                # This could be because there's a directory with the same name.
+                # But it's highly unlikely there's a directory called that,
+                # so we'll assume it's because the parent dir is not writable.
+                # This could as well be because the parent dir is not readable,
+                # due to non-privileged user access.
+                return False
+            raise
+        else:
+            os.close(fd)
+            os.unlink(file)
+            return True
+
+    # This should never be reached
+    raise EnvironmentError(
+        'Unexpected condition testing for writable directory'
+    )
+
+
+def find_files(path, pattern):
+    # type: (str, str) -> List[str]
+    """Returns a list of absolute paths of files beneath path, recursively,
+    with filenames which match the UNIX-style shell glob pattern."""
+    result = []  # type: List[str]
+    for root, _, files in os.walk(path):
+        matches = fnmatch.filter(files, pattern)
+        result.extend(os.path.join(root, f) for f in matches)
+    return result
+
+
+def file_size(path):
+    # type: (str) -> Union[int, float]
+    # If it's a symlink, return 0.
+    if os.path.islink(path):
+        return 0
+    return os.path.getsize(path)
+
+
+def format_file_size(path):
+    # type: (str) -> str
+    return format_size(file_size(path))
+
+
+def directory_size(path):
+    # type: (str) -> Union[int, float]
+    size = 0.0
+    for root, _dirs, files in os.walk(path):
+        for filename in files:
+            file_path = os.path.join(root, filename)
+            size += file_size(file_path)
+    return size
+
+
+def format_directory_size(path):
+    # type: (str) -> str
+    return format_size(directory_size(path))
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/filetypes.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/filetypes.py
new file mode 100644
index 0000000..daa0ca7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/filetypes.py
@@ -0,0 +1,16 @@
+"""Filetype information.
+"""
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Tuple
+
+WHEEL_EXTENSION = '.whl'
+BZ2_EXTENSIONS = ('.tar.bz2', '.tbz')  # type: Tuple[str, ...]
+XZ_EXTENSIONS = ('.tar.xz', '.txz', '.tlz',
+                 '.tar.lz', '.tar.lzma')  # type: Tuple[str, ...]
+ZIP_EXTENSIONS = ('.zip', WHEEL_EXTENSION)  # type: Tuple[str, ...]
+TAR_EXTENSIONS = ('.tar.gz', '.tgz', '.tar')  # type: Tuple[str, ...]
+ARCHIVE_EXTENSIONS = (
+    ZIP_EXTENSIONS + BZ2_EXTENSIONS + TAR_EXTENSIONS + XZ_EXTENSIONS
+)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/glibc.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/glibc.py
new file mode 100644
index 0000000..3610424
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/glibc.py
@@ -0,0 +1,98 @@
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
+
+from __future__ import absolute_import
+
+import os
+import sys
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, Tuple
+
+
+def glibc_version_string():
+    # type: () -> Optional[str]
+    "Returns glibc version string, or None if not using glibc."
+    return glibc_version_string_confstr() or glibc_version_string_ctypes()
+
+
+def glibc_version_string_confstr():
+    # type: () -> Optional[str]
+    "Primary implementation of glibc_version_string using os.confstr."
+    # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely
+    # to be broken or missing. This strategy is used in the standard library
+    # platform module:
+    # https://github.com/python/cpython/blob/fcf1d003bf4f0100c9d0921ff3d70e1127ca1b71/Lib/platform.py#L175-L183
+    if sys.platform == "win32":
+        return None
+    try:
+        # os.confstr("CS_GNU_LIBC_VERSION") returns a string like "glibc 2.17":
+        _, version = os.confstr("CS_GNU_LIBC_VERSION").split()
+    except (AttributeError, OSError, ValueError):
+        # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)...
+        return None
+    return version
+
+
+def glibc_version_string_ctypes():
+    # type: () -> Optional[str]
+    "Fallback implementation of glibc_version_string using ctypes."
+
+    try:
+        import ctypes
+    except ImportError:
+        return None
+
+    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
+    # manpage says, "If filename is NULL, then the returned handle is for the
+    # main program". This way we can let the linker do the work to figure out
+    # which libc our process is actually using.
+    process_namespace = ctypes.CDLL(None)
+    try:
+        gnu_get_libc_version = process_namespace.gnu_get_libc_version
+    except AttributeError:
+        # Symbol doesn't exist -> therefore, we are not linked to
+        # glibc.
+        return None
+
+    # Call gnu_get_libc_version, which returns a string like "2.5"
+    gnu_get_libc_version.restype = ctypes.c_char_p
+    version_str = gnu_get_libc_version()
+    # py2 / py3 compatibility:
+    if not isinstance(version_str, str):
+        version_str = version_str.decode("ascii")
+
+    return version_str
+
+
+# platform.libc_ver regularly returns completely nonsensical glibc
+# versions. E.g. on my computer, platform says:
+#
+#   ~$ python2.7 -c 'import platform; print(platform.libc_ver())'
+#   ('glibc', '2.7')
+#   ~$ python3.5 -c 'import platform; print(platform.libc_ver())'
+#   ('glibc', '2.9')
+#
+# But the truth is:
+#
+#   ~$ ldd --version
+#   ldd (Debian GLIBC 2.22-11) 2.22
+#
+# This is unfortunate, because it means that the linehaul data on libc
+# versions that was generated by pip 8.1.2 and earlier is useless and
+# misleading. Solution: instead of using platform, use our code that actually
+# works.
+def libc_ver():
+    # type: () -> Tuple[str, str]
+    """Try to determine the glibc version
+
+    Returns a tuple of strings (lib, version) which default to empty strings
+    in case the lookup fails.
+    """
+    glibc_version = glibc_version_string()
+    if glibc_version is None:
+        return ("", "")
+    else:
+        return ("glibc", glibc_version)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/hashes.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/hashes.py
new file mode 100644
index 0000000..d1b062f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/hashes.py
@@ -0,0 +1,145 @@
+from __future__ import absolute_import
+
+import hashlib
+
+from pip._vendor.six import iteritems, iterkeys, itervalues
+
+from pip._internal.exceptions import (
+    HashMismatch,
+    HashMissing,
+    InstallationError,
+)
+from pip._internal.utils.misc import read_chunks
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Dict, List, BinaryIO, NoReturn, Iterator
+    )
+    from pip._vendor.six import PY3
+    if PY3:
+        from hashlib import _Hash
+    else:
+        from hashlib import _hash as _Hash
+
+
+# The recommended hash algo of the moment. Change this whenever the state of
+# the art changes; it won't hurt backward compatibility.
+FAVORITE_HASH = 'sha256'
+
+
+# Names of hashlib algorithms allowed by the --hash option and ``pip hash``
+# Currently, those are the ones at least as collision-resistant as sha256.
+STRONG_HASHES = ['sha256', 'sha384', 'sha512']
+
+
+class Hashes(object):
+    """A wrapper that builds multiple hashes at once and checks them against
+    known-good values
+
+    """
+    def __init__(self, hashes=None):
+        # type: (Dict[str, List[str]]) -> None
+        """
+        :param hashes: A dict of algorithm names pointing to lists of allowed
+            hex digests
+        """
+        self._allowed = {} if hashes is None else hashes
+
+    def __or__(self, other):
+        # type: (Hashes) -> Hashes
+        if not isinstance(other, Hashes):
+            return NotImplemented
+        new = self._allowed.copy()
+        for alg, values in iteritems(other._allowed):
+            try:
+                new[alg] += values
+            except KeyError:
+                new[alg] = values
+        return Hashes(new)
+
+    @property
+    def digest_count(self):
+        # type: () -> int
+        return sum(len(digests) for digests in self._allowed.values())
+
+    def is_hash_allowed(
+        self,
+        hash_name,   # type: str
+        hex_digest,  # type: str
+    ):
+        # type: (...) -> bool
+        """Return whether the given hex digest is allowed."""
+        return hex_digest in self._allowed.get(hash_name, [])
+
+    def check_against_chunks(self, chunks):
+        # type: (Iterator[bytes]) -> None
+        """Check good hashes against ones built from iterable of chunks of
+        data.
+
+        Raise HashMismatch if none match.
+
+        """
+        gots = {}
+        for hash_name in iterkeys(self._allowed):
+            try:
+                gots[hash_name] = hashlib.new(hash_name)
+            except (ValueError, TypeError):
+                raise InstallationError(
+                    'Unknown hash name: {}'.format(hash_name)
+                )
+
+        for chunk in chunks:
+            for hash in itervalues(gots):
+                hash.update(chunk)
+
+        for hash_name, got in iteritems(gots):
+            if got.hexdigest() in self._allowed[hash_name]:
+                return
+        self._raise(gots)
+
+    def _raise(self, gots):
+        # type: (Dict[str, _Hash]) -> NoReturn
+        raise HashMismatch(self._allowed, gots)
+
+    def check_against_file(self, file):
+        # type: (BinaryIO) -> None
+        """Check good hashes against a file-like object
+
+        Raise HashMismatch if none match.
+
+        """
+        return self.check_against_chunks(read_chunks(file))
+
+    def check_against_path(self, path):
+        # type: (str) -> None
+        with open(path, 'rb') as file:
+            return self.check_against_file(file)
+
+    def __nonzero__(self):
+        # type: () -> bool
+        """Return whether I know any known-good hashes."""
+        return bool(self._allowed)
+
+    def __bool__(self):
+        # type: () -> bool
+        return self.__nonzero__()
+
+
+class MissingHashes(Hashes):
+    """A workalike for Hashes used when we're missing a hash for a requirement
+
+    It computes the actual hash of the requirement and raises a HashMissing
+    exception showing it to the user.
+
+    """
+    def __init__(self):
+        # type: () -> None
+        """Don't offer the ``hashes`` kwarg."""
+        # Pass our favorite hash in to generate a "gotten hash". With the
+        # empty list, it will never match, so an error will always raise.
+        super(MissingHashes, self).__init__(hashes={FAVORITE_HASH: []})
+
+    def _raise(self, gots):
+        # type: (Dict[str, _Hash]) -> NoReturn
+        raise HashMissing(gots[FAVORITE_HASH].hexdigest())
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/inject_securetransport.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/inject_securetransport.py
new file mode 100644
index 0000000..5b93b1d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/inject_securetransport.py
@@ -0,0 +1,36 @@
+"""A helper module that injects SecureTransport, on import.
+
+The import should be done as early as possible, to ensure all requests and
+sessions (or whatever) are created after injecting SecureTransport.
+
+Note that we only do the injection on macOS, when the linked OpenSSL is too
+old to handle TLSv1.2.
+"""
+
+import sys
+
+
+def inject_securetransport():
+    # type: () -> None
+    # Only relevant on macOS
+    if sys.platform != "darwin":
+        return
+
+    try:
+        import ssl
+    except ImportError:
+        return
+
+    # Checks for OpenSSL 1.0.1
+    if ssl.OPENSSL_VERSION_NUMBER >= 0x1000100f:
+        return
+
+    try:
+        from pip._vendor.urllib3.contrib import securetransport
+    except (ImportError, OSError):
+        return
+
+    securetransport.inject_into_urllib3()
+
+
+inject_securetransport()
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/logging.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/logging.py
new file mode 100644
index 0000000..9a017cf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/logging.py
@@ -0,0 +1,399 @@
+# The following comment should be removed at some point in the future.
+# mypy: disallow-untyped-defs=False
+
+from __future__ import absolute_import
+
+import contextlib
+import errno
+import logging
+import logging.handlers
+import os
+import sys
+from logging import Filter, getLogger
+
+from pip._vendor.six import PY2
+
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.deprecation import DEPRECATION_MSG_PREFIX
+from pip._internal.utils.misc import ensure_dir
+
+try:
+    import threading
+except ImportError:
+    import dummy_threading as threading  # type: ignore
+
+
+try:
+    # Use "import as" and set colorama in the else clause to avoid mypy
+    # errors and get the following correct revealed type for colorama:
+    # `Union[_importlib_modulespec.ModuleType, None]`
+    # Otherwise, we get an error like the following in the except block:
+    #  > Incompatible types in assignment (expression has type "None",
+    #   variable has type Module)
+    # TODO: eliminate the need to use "import as" once mypy addresses some
+    #  of its issues with conditional imports. Here is an umbrella issue:
+    #  https://github.com/python/mypy/issues/1297
+    from pip._vendor import colorama as _colorama
+# Lots of different errors can come from this, including SystemError and
+# ImportError.
+except Exception:
+    colorama = None
+else:
+    # Import Fore explicitly rather than accessing below as colorama.Fore
+    # to avoid the following error running mypy:
+    # > Module has no attribute "Fore"
+    # TODO: eliminate the need to import Fore once mypy addresses some of its
+    #  issues with conditional imports. This particular case could be an
+    #  instance of the following issue (but also see the umbrella issue above):
+    #  https://github.com/python/mypy/issues/3500
+    from pip._vendor.colorama import Fore
+
+    colorama = _colorama
+
+
+_log_state = threading.local()
+subprocess_logger = getLogger('pip.subprocessor')
+
+
+class BrokenStdoutLoggingError(Exception):
+    """
+    Raised if BrokenPipeError occurs for the stdout stream while logging.
+    """
+    pass
+
+
+# BrokenPipeError does not exist in Python 2 and, in addition, manifests
+# differently in Windows and non-Windows.
+if WINDOWS:
+    # In Windows, a broken pipe can show up as EINVAL rather than EPIPE:
+    # https://bugs.python.org/issue19612
+    # https://bugs.python.org/issue30418
+    if PY2:
+        def _is_broken_pipe_error(exc_class, exc):
+            """See the docstring for non-Windows Python 3 below."""
+            return (exc_class is IOError and
+                    exc.errno in (errno.EINVAL, errno.EPIPE))
+    else:
+        # In Windows, a broken pipe IOError became OSError in Python 3.
+        def _is_broken_pipe_error(exc_class, exc):
+            """See the docstring for non-Windows Python 3 below."""
+            return ((exc_class is BrokenPipeError) or  # noqa: F821
+                    (exc_class is OSError and
+                     exc.errno in (errno.EINVAL, errno.EPIPE)))
+elif PY2:
+    def _is_broken_pipe_error(exc_class, exc):
+        """See the docstring for non-Windows Python 3 below."""
+        return (exc_class is IOError and exc.errno == errno.EPIPE)
+else:
+    # Then we are in the non-Windows Python 3 case.
+    def _is_broken_pipe_error(exc_class, exc):
+        """
+        Return whether an exception is a broken pipe error.
+
+        Args:
+          exc_class: an exception class.
+          exc: an exception instance.
+        """
+        return (exc_class is BrokenPipeError)  # noqa: F821
+
+
+@contextlib.contextmanager
+def indent_log(num=2):
+    """
+    A context manager which will cause the log output to be indented for any
+    log messages emitted inside it.
+    """
+    # For thread-safety
+    _log_state.indentation = get_indentation()
+    _log_state.indentation += num
+    try:
+        yield
+    finally:
+        _log_state.indentation -= num
+
+
+def get_indentation():
+    return getattr(_log_state, 'indentation', 0)
+
+
+class IndentingFormatter(logging.Formatter):
+
+    def __init__(self, *args, **kwargs):
+        """
+        A logging.Formatter that obeys the indent_log() context manager.
+
+        :param add_timestamp: A bool indicating output lines should be prefixed
+            with their record's timestamp.
+        """
+        self.add_timestamp = kwargs.pop("add_timestamp", False)
+        super(IndentingFormatter, self).__init__(*args, **kwargs)
+
+    def get_message_start(self, formatted, levelno):
+        """
+        Return the start of the formatted log message (not counting the
+        prefix to add to each line).
+        """
+        if levelno < logging.WARNING:
+            return ''
+        if formatted.startswith(DEPRECATION_MSG_PREFIX):
+            # Then the message already has a prefix.  We don't want it to
+            # look like "WARNING: DEPRECATION: ...."
+            return ''
+        if levelno < logging.ERROR:
+            return 'WARNING: '
+
+        return 'ERROR: '
+
+    def format(self, record):
+        """
+        Calls the standard formatter, but will indent all of the log message
+        lines by our current indentation level.
+        """
+        formatted = super(IndentingFormatter, self).format(record)
+        message_start = self.get_message_start(formatted, record.levelno)
+        formatted = message_start + formatted
+
+        prefix = ''
+        if self.add_timestamp:
+            # TODO: Use Formatter.default_time_format after dropping PY2.
+            t = self.formatTime(record, "%Y-%m-%dT%H:%M:%S")
+            prefix = '{t},{record.msecs:03.0f} '.format(**locals())
+        prefix += " " * get_indentation()
+        formatted = "".join([
+            prefix + line
+            for line in formatted.splitlines(True)
+        ])
+        return formatted
+
+
+def _color_wrap(*colors):
+    def wrapped(inp):
+        return "".join(list(colors) + [inp, colorama.Style.RESET_ALL])
+    return wrapped
+
+
+class ColorizedStreamHandler(logging.StreamHandler):
+
+    # Don't build up a list of colors if we don't have colorama
+    if colorama:
+        COLORS = [
+            # This needs to be in order from highest logging level to lowest.
+            (logging.ERROR, _color_wrap(Fore.RED)),
+            (logging.WARNING, _color_wrap(Fore.YELLOW)),
+        ]
+    else:
+        COLORS = []
+
+    def __init__(self, stream=None, no_color=None):
+        logging.StreamHandler.__init__(self, stream)
+        self._no_color = no_color
+
+        if WINDOWS and colorama:
+            self.stream = colorama.AnsiToWin32(self.stream)
+
+    def _using_stdout(self):
+        """
+        Return whether the handler is using sys.stdout.
+        """
+        if WINDOWS and colorama:
+            # Then self.stream is an AnsiToWin32 object.
+            return self.stream.wrapped is sys.stdout
+
+        return self.stream is sys.stdout
+
+    def should_color(self):
+        # Don't colorize things if we do not have colorama or if told not to
+        if not colorama or self._no_color:
+            return False
+
+        real_stream = (
+            self.stream if not isinstance(self.stream, colorama.AnsiToWin32)
+            else self.stream.wrapped
+        )
+
+        # If the stream is a tty we should color it
+        if hasattr(real_stream, "isatty") and real_stream.isatty():
+            return True
+
+        # If we have an ANSI term we should color it
+        if os.environ.get("TERM") == "ANSI":
+            return True
+
+        # If anything else we should not color it
+        return False
+
+    def format(self, record):
+        msg = logging.StreamHandler.format(self, record)
+
+        if self.should_color():
+            for level, color in self.COLORS:
+                if record.levelno >= level:
+                    msg = color(msg)
+                    break
+
+        return msg
+
+    # The logging module says handleError() can be customized.
+    def handleError(self, record):
+        exc_class, exc = sys.exc_info()[:2]
+        # If a broken pipe occurred while calling write() or flush() on the
+        # stdout stream in logging's Handler.emit(), then raise our special
+        # exception so we can handle it in main() instead of logging the
+        # broken pipe error and continuing.
+        if (exc_class and self._using_stdout() and
+                _is_broken_pipe_error(exc_class, exc)):
+            raise BrokenStdoutLoggingError()
+
+        return super(ColorizedStreamHandler, self).handleError(record)
+
+
+class BetterRotatingFileHandler(logging.handlers.RotatingFileHandler):
+
+    def _open(self):
+        ensure_dir(os.path.dirname(self.baseFilename))
+        return logging.handlers.RotatingFileHandler._open(self)
+
+
+class MaxLevelFilter(Filter):
+
+    def __init__(self, level):
+        self.level = level
+
+    def filter(self, record):
+        return record.levelno < self.level
+
+
+class ExcludeLoggerFilter(Filter):
+
+    """
+    A logging Filter that excludes records from a logger (or its children).
+    """
+
+    def filter(self, record):
+        # The base Filter class allows only records from a logger (or its
+        # children).
+        return not super(ExcludeLoggerFilter, self).filter(record)
+
+
+def setup_logging(verbosity, no_color, user_log_file):
+    """Configures and sets up all of the logging
+
+    Returns the requested logging level, as its integer value.
+    """
+
+    # Determine the level to be logging at.
+    if verbosity >= 1:
+        level = "DEBUG"
+    elif verbosity == -1:
+        level = "WARNING"
+    elif verbosity == -2:
+        level = "ERROR"
+    elif verbosity <= -3:
+        level = "CRITICAL"
+    else:
+        level = "INFO"
+
+    level_number = getattr(logging, level)
+
+    # The "root" logger should match the "console" level *unless* we also need
+    # to log to a user log file.
+    include_user_log = user_log_file is not None
+    if include_user_log:
+        additional_log_file = user_log_file
+        root_level = "DEBUG"
+    else:
+        additional_log_file = "/dev/null"
+        root_level = level
+
+    # Disable any logging besides WARNING unless we have DEBUG level logging
+    # enabled for vendored libraries.
+    vendored_log_level = "WARNING" if level in ["INFO", "ERROR"] else "DEBUG"
+
+    # Shorthands for clarity
+    log_streams = {
+        "stdout": "ext://sys.stdout",
+        "stderr": "ext://sys.stderr",
+    }
+    handler_classes = {
+        "stream": "pip._internal.utils.logging.ColorizedStreamHandler",
+        "file": "pip._internal.utils.logging.BetterRotatingFileHandler",
+    }
+    handlers = ["console", "console_errors", "console_subprocess"] + (
+        ["user_log"] if include_user_log else []
+    )
+
+    logging.config.dictConfig({
+        "version": 1,
+        "disable_existing_loggers": False,
+        "filters": {
+            "exclude_warnings": {
+                "()": "pip._internal.utils.logging.MaxLevelFilter",
+                "level": logging.WARNING,
+            },
+            "restrict_to_subprocess": {
+                "()": "logging.Filter",
+                "name": subprocess_logger.name,
+            },
+            "exclude_subprocess": {
+                "()": "pip._internal.utils.logging.ExcludeLoggerFilter",
+                "name": subprocess_logger.name,
+            },
+        },
+        "formatters": {
+            "indent": {
+                "()": IndentingFormatter,
+                "format": "%(message)s",
+            },
+            "indent_with_timestamp": {
+                "()": IndentingFormatter,
+                "format": "%(message)s",
+                "add_timestamp": True,
+            },
+        },
+        "handlers": {
+            "console": {
+                "level": level,
+                "class": handler_classes["stream"],
+                "no_color": no_color,
+                "stream": log_streams["stdout"],
+                "filters": ["exclude_subprocess", "exclude_warnings"],
+                "formatter": "indent",
+            },
+            "console_errors": {
+                "level": "WARNING",
+                "class": handler_classes["stream"],
+                "no_color": no_color,
+                "stream": log_streams["stderr"],
+                "filters": ["exclude_subprocess"],
+                "formatter": "indent",
+            },
+            # A handler responsible for logging to the console messages
+            # from the "subprocessor" logger.
+            "console_subprocess": {
+                "level": level,
+                "class": handler_classes["stream"],
+                "no_color": no_color,
+                "stream": log_streams["stderr"],
+                "filters": ["restrict_to_subprocess"],
+                "formatter": "indent",
+            },
+            "user_log": {
+                "level": "DEBUG",
+                "class": handler_classes["file"],
+                "filename": additional_log_file,
+                "delay": True,
+                "formatter": "indent_with_timestamp",
+            },
+        },
+        "root": {
+            "level": root_level,
+            "handlers": handlers,
+        },
+        "loggers": {
+            "pip._vendor": {
+                "level": vendored_log_level
+            }
+        },
+    })
+
+    return level_number
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/misc.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/misc.py
new file mode 100644
index 0000000..5629c60
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/misc.py
@@ -0,0 +1,959 @@
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
+# mypy: disallow-untyped-defs=False
+
+from __future__ import absolute_import
+
+import contextlib
+import errno
+import getpass
+import hashlib
+import io
+import logging
+import os
+import posixpath
+import shutil
+import stat
+import sys
+from collections import deque
+from itertools import tee
+
+from pip._vendor import pkg_resources
+from pip._vendor.packaging.utils import canonicalize_name
+# NOTE: retrying is not annotated in typeshed as on 2017-07-17, which is
+#       why we ignore the type on this import.
+from pip._vendor.retrying import retry  # type: ignore
+from pip._vendor.six import PY2, text_type
+from pip._vendor.six.moves import filter, filterfalse, input, map, zip_longest
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+from pip._vendor.six.moves.urllib.parse import unquote as urllib_unquote
+
+from pip import __version__
+from pip._internal.exceptions import CommandError
+from pip._internal.locations import (
+    get_major_minor_version,
+    site_packages,
+    user_site,
+)
+from pip._internal.utils.compat import (
+    WINDOWS,
+    expanduser,
+    stdlib_pkgs,
+    str_to_display,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING, cast
+from pip._internal.utils.virtualenv import (
+    running_under_virtualenv,
+    virtualenv_no_global,
+)
+
+if PY2:
+    from io import BytesIO as StringIO
+else:
+    from io import StringIO
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Any, AnyStr, Callable, Container, Iterable, Iterator, List, Optional,
+        Text, Tuple, TypeVar, Union,
+    )
+    from pip._vendor.pkg_resources import Distribution
+
+    VersionInfo = Tuple[int, int, int]
+    T = TypeVar("T")
+
+
+__all__ = ['rmtree', 'display_path', 'backup_dir',
+           'ask', 'splitext',
+           'format_size', 'is_installable_dir',
+           'normalize_path',
+           'renames', 'get_prog',
+           'captured_stdout', 'ensure_dir',
+           'get_installed_version', 'remove_auth_from_url']
+
+
+logger = logging.getLogger(__name__)
+
+
+def get_pip_version():
+    # type: () -> str
+    pip_pkg_dir = os.path.join(os.path.dirname(__file__), "..", "..")
+    pip_pkg_dir = os.path.abspath(pip_pkg_dir)
+
+    return (
+        'pip {} from {} (python {})'.format(
+            __version__, pip_pkg_dir, get_major_minor_version(),
+        )
+    )
+
+
+def normalize_version_info(py_version_info):
+    # type: (Tuple[int, ...]) -> Tuple[int, int, int]
+    """
+    Convert a tuple of ints representing a Python version to one of length
+    three.
+
+    :param py_version_info: a tuple of ints representing a Python version,
+        or None to specify no version. The tuple can have any length.
+
+    :return: a tuple of length three if `py_version_info` is non-None.
+        Otherwise, return `py_version_info` unchanged (i.e. None).
+    """
+    if len(py_version_info) < 3:
+        py_version_info += (3 - len(py_version_info)) * (0,)
+    elif len(py_version_info) > 3:
+        py_version_info = py_version_info[:3]
+
+    return cast('VersionInfo', py_version_info)
+
+
+def ensure_dir(path):
+    # type: (AnyStr) -> None
+    """os.path.makedirs without EEXIST."""
+    try:
+        os.makedirs(path)
+    except OSError as e:
+        # Windows can raise spurious ENOTEMPTY errors. See #6426.
+        if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
+            raise
+
+
+def get_prog():
+    # type: () -> str
+    try:
+        prog = os.path.basename(sys.argv[0])
+        if prog in ('__main__.py', '-c'):
+            return "{} -m pip".format(sys.executable)
+        else:
+            return prog
+    except (AttributeError, TypeError, IndexError):
+        pass
+    return 'pip'
+
+
+# Retry every half second for up to 3 seconds
+@retry(stop_max_delay=3000, wait_fixed=500)
+def rmtree(dir, ignore_errors=False):
+    # type: (Text, bool) -> None
+    shutil.rmtree(dir, ignore_errors=ignore_errors,
+                  onerror=rmtree_errorhandler)
+
+
+def rmtree_errorhandler(func, path, exc_info):
+    """On Windows, the files in .svn are read-only, so when rmtree() tries to
+    remove them, an exception is thrown.  We catch that here, remove the
+    read-only attribute, and hopefully continue without problems."""
+    try:
+        has_attr_readonly = not (os.stat(path).st_mode & stat.S_IWRITE)
+    except (IOError, OSError):
+        # it's equivalent to os.path.exists
+        return
+
+    if has_attr_readonly:
+        # convert to read/write
+        os.chmod(path, stat.S_IWRITE)
+        # use the original function to repeat the operation
+        func(path)
+        return
+    else:
+        raise
+
+
+def path_to_display(path):
+    # type: (Optional[Union[str, Text]]) -> Optional[Text]
+    """
+    Convert a bytes (or text) path to text (unicode in Python 2) for display
+    and logging purposes.
+
+    This function should never error out. Also, this function is mainly needed
+    for Python 2 since in Python 3 str paths are already text.
+    """
+    if path is None:
+        return None
+    if isinstance(path, text_type):
+        return path
+    # Otherwise, path is a bytes object (str in Python 2).
+    try:
+        display_path = path.decode(sys.getfilesystemencoding(), 'strict')
+    except UnicodeDecodeError:
+        # Include the full bytes to make troubleshooting easier, even though
+        # it may not be very human readable.
+        if PY2:
+            # Convert the bytes to a readable str representation using
+            # repr(), and then convert the str to unicode.
+            #   Also, we add the prefix "b" to the repr() return value both
+            # to make the Python 2 output look like the Python 3 output, and
+            # to signal to the user that this is a bytes representation.
+            display_path = str_to_display('b{!r}'.format(path))
+        else:
+            # Silence the "F821 undefined name 'ascii'" flake8 error since
+            # in Python 3 ascii() is a built-in.
+            display_path = ascii(path)  # noqa: F821
+
+    return display_path
+
+
+def display_path(path):
+    # type: (Union[str, Text]) -> str
+    """Gives the display value for a given path, making it relative to cwd
+    if possible."""
+    path = os.path.normcase(os.path.abspath(path))
+    if sys.version_info[0] == 2:
+        path = path.decode(sys.getfilesystemencoding(), 'replace')
+        path = path.encode(sys.getdefaultencoding(), 'replace')
+    if path.startswith(os.getcwd() + os.path.sep):
+        path = '.' + path[len(os.getcwd()):]
+    return path
+
+
+def backup_dir(dir, ext='.bak'):
+    # type: (str, str) -> str
+    """Figure out the name of a directory to back up the given dir to
+    (adding .bak, .bak2, etc)"""
+    n = 1
+    extension = ext
+    while os.path.exists(dir + extension):
+        n += 1
+        extension = ext + str(n)
+    return dir + extension
+
+
+def ask_path_exists(message, options):
+    # type: (str, Iterable[str]) -> str
+    for action in os.environ.get('PIP_EXISTS_ACTION', '').split():
+        if action in options:
+            return action
+    return ask(message, options)
+
+
+def _check_no_input(message):
+    # type: (str) -> None
+    """Raise an error if no input is allowed."""
+    if os.environ.get('PIP_NO_INPUT'):
+        raise Exception(
+            'No input was expected ($PIP_NO_INPUT set); question: {}'.format(
+                message)
+        )
+
+
+def ask(message, options):
+    # type: (str, Iterable[str]) -> str
+    """Ask the message interactively, with the given possible responses"""
+    while 1:
+        _check_no_input(message)
+        response = input(message)
+        response = response.strip().lower()
+        if response not in options:
+            print(
+                'Your response ({!r}) was not one of the expected responses: '
+                '{}'.format(response, ', '.join(options))
+            )
+        else:
+            return response
+
+
+def ask_input(message):
+    # type: (str) -> str
+    """Ask for input interactively."""
+    _check_no_input(message)
+    return input(message)
+
+
+def ask_password(message):
+    # type: (str) -> str
+    """Ask for a password interactively."""
+    _check_no_input(message)
+    return getpass.getpass(message)
+
+
+def format_size(bytes):
+    # type: (float) -> str
+    if bytes > 1000 * 1000:
+        return '{:.1f} MB'.format(bytes / 1000.0 / 1000)
+    elif bytes > 10 * 1000:
+        return '{} kB'.format(int(bytes / 1000))
+    elif bytes > 1000:
+        return '{:.1f} kB'.format(bytes / 1000.0)
+    else:
+        return '{} bytes'.format(int(bytes))
+
+
+def tabulate(rows):
+    # type: (Iterable[Iterable[Any]]) -> Tuple[List[str], List[int]]
+    """Return a list of formatted rows and a list of column sizes.
+
+    For example::
+
+    >>> tabulate([['foobar', 2000], [0xdeadbeef]])
+    (['foobar     2000', '3735928559'], [10, 4])
+    """
+    rows = [tuple(map(str, row)) for row in rows]
+    sizes = [max(map(len, col)) for col in zip_longest(*rows, fillvalue='')]
+    table = [" ".join(map(str.ljust, row, sizes)).rstrip() for row in rows]
+    return table, sizes
+
+
+def is_installable_dir(path):
+    # type: (str) -> bool
+    """Is path is a directory containing setup.py or pyproject.toml?
+    """
+    if not os.path.isdir(path):
+        return False
+    setup_py = os.path.join(path, 'setup.py')
+    if os.path.isfile(setup_py):
+        return True
+    pyproject_toml = os.path.join(path, 'pyproject.toml')
+    if os.path.isfile(pyproject_toml):
+        return True
+    return False
+
+
+def read_chunks(file, size=io.DEFAULT_BUFFER_SIZE):
+    """Yield pieces of data from a file-like object until EOF."""
+    while True:
+        chunk = file.read(size)
+        if not chunk:
+            break
+        yield chunk
+
+
+def normalize_path(path, resolve_symlinks=True):
+    # type: (str, bool) -> str
+    """
+    Convert a path to its canonical, case-normalized, absolute version.
+
+    """
+    path = expanduser(path)
+    if resolve_symlinks:
+        path = os.path.realpath(path)
+    else:
+        path = os.path.abspath(path)
+    return os.path.normcase(path)
+
+
+def splitext(path):
+    # type: (str) -> Tuple[str, str]
+    """Like os.path.splitext, but take off .tar too"""
+    base, ext = posixpath.splitext(path)
+    if base.lower().endswith('.tar'):
+        ext = base[-4:] + ext
+        base = base[:-4]
+    return base, ext
+
+
+def renames(old, new):
+    # type: (str, str) -> None
+    """Like os.renames(), but handles renaming across devices."""
+    # Implementation borrowed from os.renames().
+    head, tail = os.path.split(new)
+    if head and tail and not os.path.exists(head):
+        os.makedirs(head)
+
+    shutil.move(old, new)
+
+    head, tail = os.path.split(old)
+    if head and tail:
+        try:
+            os.removedirs(head)
+        except OSError:
+            pass
+
+
+def is_local(path):
+    # type: (str) -> bool
+    """
+    Return True if path is within sys.prefix, if we're running in a virtualenv.
+
+    If we're not in a virtualenv, all paths are considered "local."
+
+    Caution: this function assumes the head of path has been normalized
+    with normalize_path.
+    """
+    if not running_under_virtualenv():
+        return True
+    return path.startswith(normalize_path(sys.prefix))
+
+
+def dist_is_local(dist):
+    # type: (Distribution) -> bool
+    """
+    Return True if given Distribution object is installed locally
+    (i.e. within current virtualenv).
+
+    Always True if we're not in a virtualenv.
+
+    """
+    return is_local(dist_location(dist))
+
+
+def dist_in_usersite(dist):
+    # type: (Distribution) -> bool
+    """
+    Return True if given Distribution is installed in user site.
+    """
+    return dist_location(dist).startswith(normalize_path(user_site))
+
+
+def dist_in_site_packages(dist):
+    # type: (Distribution) -> bool
+    """
+    Return True if given Distribution is installed in
+    sysconfig.get_python_lib().
+    """
+    return dist_location(dist).startswith(normalize_path(site_packages))
+
+
+def dist_is_editable(dist):
+    # type: (Distribution) -> bool
+    """
+    Return True if given Distribution is an editable install.
+    """
+    for path_item in sys.path:
+        egg_link = os.path.join(path_item, dist.project_name + '.egg-link')
+        if os.path.isfile(egg_link):
+            return True
+    return False
+
+
+def get_installed_distributions(
+        local_only=True,  # type: bool
+        skip=stdlib_pkgs,  # type: Container[str]
+        include_editables=True,  # type: bool
+        editables_only=False,  # type: bool
+        user_only=False,  # type: bool
+        paths=None  # type: Optional[List[str]]
+):
+    # type: (...) -> List[Distribution]
+    """
+    Return a list of installed Distribution objects.
+
+    If ``local_only`` is True (default), only return installations
+    local to the current virtualenv, if in a virtualenv.
+
+    ``skip`` argument is an iterable of lower-case project names to
+    ignore; defaults to stdlib_pkgs
+
+    If ``include_editables`` is False, don't report editables.
+
+    If ``editables_only`` is True , only report editables.
+
+    If ``user_only`` is True , only report installations in the user
+    site directory.
+
+    If ``paths`` is set, only report the distributions present at the
+    specified list of locations.
+    """
+    if paths:
+        working_set = pkg_resources.WorkingSet(paths)
+    else:
+        working_set = pkg_resources.working_set
+
+    if local_only:
+        local_test = dist_is_local
+    else:
+        def local_test(d):
+            return True
+
+    if include_editables:
+        def editable_test(d):
+            return True
+    else:
+        def editable_test(d):
+            return not dist_is_editable(d)
+
+    if editables_only:
+        def editables_only_test(d):
+            return dist_is_editable(d)
+    else:
+        def editables_only_test(d):
+            return True
+
+    if user_only:
+        user_test = dist_in_usersite
+    else:
+        def user_test(d):
+            return True
+
+    return [d for d in working_set
+            if local_test(d) and
+            d.key not in skip and
+            editable_test(d) and
+            editables_only_test(d) and
+            user_test(d)
+            ]
+
+
+def _search_distribution(req_name):
+    # type: (str) -> Optional[Distribution]
+    """Find a distribution matching the ``req_name`` in the environment.
+
+    This searches from *all* distributions available in the environment, to
+    match the behavior of ``pkg_resources.get_distribution()``.
+    """
+    # Canonicalize the name before searching in the list of
+    # installed distributions and also while creating the package
+    # dictionary to get the Distribution object
+    req_name = canonicalize_name(req_name)
+    packages = get_installed_distributions(
+        local_only=False,
+        skip=(),
+        include_editables=True,
+        editables_only=False,
+        user_only=False,
+        paths=None,
+    )
+    pkg_dict = {canonicalize_name(p.key): p for p in packages}
+    return pkg_dict.get(req_name)
+
+
+def get_distribution(req_name):
+    # type: (str) -> Optional[Distribution]
+    """Given a requirement name, return the installed Distribution object.
+
+    This searches from *all* distributions available in the environment, to
+    match the behavior of ``pkg_resources.get_distribution()``.
+    """
+
+    # Search the distribution by looking through the working set
+    dist = _search_distribution(req_name)
+
+    # If distribution could not be found, call working_set.require
+    # to update the working set, and try to find the distribution
+    # again.
+    # This might happen for e.g. when you install a package
+    # twice, once using setup.py develop and again using setup.py install.
+    # Now when run pip uninstall twice, the package gets removed
+    # from the working set in the first uninstall, so we have to populate
+    # the working set again so that pip knows about it and the packages
+    # gets picked up and is successfully uninstalled the second time too.
+    if not dist:
+        try:
+            pkg_resources.working_set.require(req_name)
+        except pkg_resources.DistributionNotFound:
+            return None
+    return _search_distribution(req_name)
+
+
+def egg_link_path(dist):
+    # type: (Distribution) -> Optional[str]
+    """
+    Return the path for the .egg-link file if it exists, otherwise, None.
+
+    There's 3 scenarios:
+    1) not in a virtualenv
+       try to find in site.USER_SITE, then site_packages
+    2) in a no-global virtualenv
+       try to find in site_packages
+    3) in a yes-global virtualenv
+       try to find in site_packages, then site.USER_SITE
+       (don't look in global location)
+
+    For #1 and #3, there could be odd cases, where there's an egg-link in 2
+    locations.
+
+    This method will just return the first one found.
+    """
+    sites = []
+    if running_under_virtualenv():
+        sites.append(site_packages)
+        if not virtualenv_no_global() and user_site:
+            sites.append(user_site)
+    else:
+        if user_site:
+            sites.append(user_site)
+        sites.append(site_packages)
+
+    for site in sites:
+        egglink = os.path.join(site, dist.project_name) + '.egg-link'
+        if os.path.isfile(egglink):
+            return egglink
+    return None
+
+
+def dist_location(dist):
+    # type: (Distribution) -> str
+    """
+    Get the site-packages location of this distribution. Generally
+    this is dist.location, except in the case of develop-installed
+    packages, where dist.location is the source code location, and we
+    want to know where the egg-link file is.
+
+    The returned location is normalized (in particular, with symlinks removed).
+    """
+    egg_link = egg_link_path(dist)
+    if egg_link:
+        return normalize_path(egg_link)
+    return normalize_path(dist.location)
+
+
+def write_output(msg, *args):
+    # type: (Any, Any) -> None
+    logger.info(msg, *args)
+
+
+class FakeFile(object):
+    """Wrap a list of lines in an object with readline() to make
+    ConfigParser happy."""
+    def __init__(self, lines):
+        self._gen = iter(lines)
+
+    def readline(self):
+        try:
+            return next(self._gen)
+        except StopIteration:
+            return ''
+
+    def __iter__(self):
+        return self._gen
+
+
+class StreamWrapper(StringIO):
+
+    @classmethod
+    def from_stream(cls, orig_stream):
+        cls.orig_stream = orig_stream
+        return cls()
+
+    # compileall.compile_dir() needs stdout.encoding to print to stdout
+    @property
+    def encoding(self):
+        return self.orig_stream.encoding
+
+
+@contextlib.contextmanager
+def captured_output(stream_name):
+    """Return a context manager used by captured_stdout/stdin/stderr
+    that temporarily replaces the sys stream *stream_name* with a StringIO.
+
+    Taken from Lib/support/__init__.py in the CPython repo.
+    """
+    orig_stdout = getattr(sys, stream_name)
+    setattr(sys, stream_name, StreamWrapper.from_stream(orig_stdout))
+    try:
+        yield getattr(sys, stream_name)
+    finally:
+        setattr(sys, stream_name, orig_stdout)
+
+
+def captured_stdout():
+    """Capture the output of sys.stdout:
+
+       with captured_stdout() as stdout:
+           print('hello')
+       self.assertEqual(stdout.getvalue(), 'hello\n')
+
+    Taken from Lib/support/__init__.py in the CPython repo.
+    """
+    return captured_output('stdout')
+
+
+def captured_stderr():
+    """
+    See captured_stdout().
+    """
+    return captured_output('stderr')
+
+
+def get_installed_version(dist_name, working_set=None):
+    """Get the installed version of dist_name avoiding pkg_resources cache"""
+    # Create a requirement that we'll look for inside of setuptools.
+    req = pkg_resources.Requirement.parse(dist_name)
+
+    if working_set is None:
+        # We want to avoid having this cached, so we need to construct a new
+        # working set each time.
+        working_set = pkg_resources.WorkingSet()
+
+    # Get the installed distribution from our working set
+    dist = working_set.find(req)
+
+    # Check to see if we got an installed distribution or not, if we did
+    # we want to return it's version.
+    return dist.version if dist else None
+
+
+def consume(iterator):
+    """Consume an iterable at C speed."""
+    deque(iterator, maxlen=0)
+
+
+# Simulates an enum
+def enum(*sequential, **named):
+    enums = dict(zip(sequential, range(len(sequential))), **named)
+    reverse = {value: key for key, value in enums.items()}
+    enums['reverse_mapping'] = reverse
+    return type('Enum', (), enums)
+
+
+def build_netloc(host, port):
+    # type: (str, Optional[int]) -> str
+    """
+    Build a netloc from a host-port pair
+    """
+    if port is None:
+        return host
+    if ':' in host:
+        # Only wrap host with square brackets when it is IPv6
+        host = '[{}]'.format(host)
+    return '{}:{}'.format(host, port)
+
+
+def build_url_from_netloc(netloc, scheme='https'):
+    # type: (str, str) -> str
+    """
+    Build a full URL from a netloc.
+    """
+    if netloc.count(':') >= 2 and '@' not in netloc and '[' not in netloc:
+        # It must be a bare IPv6 address, so wrap it with brackets.
+        netloc = '[{}]'.format(netloc)
+    return '{}://{}'.format(scheme, netloc)
+
+
+def parse_netloc(netloc):
+    # type: (str) -> Tuple[str, Optional[int]]
+    """
+    Return the host-port pair from a netloc.
+    """
+    url = build_url_from_netloc(netloc)
+    parsed = urllib_parse.urlparse(url)
+    return parsed.hostname, parsed.port
+
+
+def split_auth_from_netloc(netloc):
+    """
+    Parse out and remove the auth information from a netloc.
+
+    Returns: (netloc, (username, password)).
+    """
+    if '@' not in netloc:
+        return netloc, (None, None)
+
+    # Split from the right because that's how urllib.parse.urlsplit()
+    # behaves if more than one @ is present (which can be checked using
+    # the password attribute of urlsplit()'s return value).
+    auth, netloc = netloc.rsplit('@', 1)
+    if ':' in auth:
+        # Split from the left because that's how urllib.parse.urlsplit()
+        # behaves if more than one : is present (which again can be checked
+        # using the password attribute of the return value)
+        user_pass = auth.split(':', 1)
+    else:
+        user_pass = auth, None
+
+    user_pass = tuple(
+        None if x is None else urllib_unquote(x) for x in user_pass
+    )
+
+    return netloc, user_pass
+
+
+def redact_netloc(netloc):
+    # type: (str) -> str
+    """
+    Replace the sensitive data in a netloc with "****", if it exists.
+
+    For example:
+        - "user:pass@example.com" returns "user:****@example.com"
+        - "accesstoken@example.com" returns "****@example.com"
+    """
+    netloc, (user, password) = split_auth_from_netloc(netloc)
+    if user is None:
+        return netloc
+    if password is None:
+        user = '****'
+        password = ''
+    else:
+        user = urllib_parse.quote(user)
+        password = ':****'
+    return '{user}{password}@{netloc}'.format(user=user,
+                                              password=password,
+                                              netloc=netloc)
+
+
+def _transform_url(url, transform_netloc):
+    """Transform and replace netloc in a url.
+
+    transform_netloc is a function taking the netloc and returning a
+    tuple. The first element of this tuple is the new netloc. The
+    entire tuple is returned.
+
+    Returns a tuple containing the transformed url as item 0 and the
+    original tuple returned by transform_netloc as item 1.
+    """
+    purl = urllib_parse.urlsplit(url)
+    netloc_tuple = transform_netloc(purl.netloc)
+    # stripped url
+    url_pieces = (
+        purl.scheme, netloc_tuple[0], purl.path, purl.query, purl.fragment
+    )
+    surl = urllib_parse.urlunsplit(url_pieces)
+    return surl, netloc_tuple
+
+
+def _get_netloc(netloc):
+    return split_auth_from_netloc(netloc)
+
+
+def _redact_netloc(netloc):
+    return (redact_netloc(netloc),)
+
+
+def split_auth_netloc_from_url(url):
+    # type: (str) -> Tuple[str, str, Tuple[str, str]]
+    """
+    Parse a url into separate netloc, auth, and url with no auth.
+
+    Returns: (url_without_auth, netloc, (username, password))
+    """
+    url_without_auth, (netloc, auth) = _transform_url(url, _get_netloc)
+    return url_without_auth, netloc, auth
+
+
+def remove_auth_from_url(url):
+    # type: (str) -> str
+    """Return a copy of url with 'username:password@' removed."""
+    # username/pass params are passed to subversion through flags
+    # and are not recognized in the url.
+    return _transform_url(url, _get_netloc)[0]
+
+
+def redact_auth_from_url(url):
+    # type: (str) -> str
+    """Replace the password in a given url with ****."""
+    return _transform_url(url, _redact_netloc)[0]
+
+
+class HiddenText(object):
+    def __init__(
+        self,
+        secret,    # type: str
+        redacted,  # type: str
+    ):
+        # type: (...) -> None
+        self.secret = secret
+        self.redacted = redacted
+
+    def __repr__(self):
+        # type: (...) -> str
+        return '<HiddenText {!r}>'.format(str(self))
+
+    def __str__(self):
+        # type: (...) -> str
+        return self.redacted
+
+    # This is useful for testing.
+    def __eq__(self, other):
+        # type: (Any) -> bool
+        if type(self) != type(other):
+            return False
+
+        # The string being used for redaction doesn't also have to match,
+        # just the raw, original string.
+        return (self.secret == other.secret)
+
+    # We need to provide an explicit __ne__ implementation for Python 2.
+    # TODO: remove this when we drop PY2 support.
+    def __ne__(self, other):
+        # type: (Any) -> bool
+        return not self == other
+
+
+def hide_value(value):
+    # type: (str) -> HiddenText
+    return HiddenText(value, redacted='****')
+
+
+def hide_url(url):
+    # type: (str) -> HiddenText
+    redacted = redact_auth_from_url(url)
+    return HiddenText(url, redacted=redacted)
+
+
+def protect_pip_from_modification_on_windows(modifying_pip):
+    # type: (bool) -> None
+    """Protection of pip.exe from modification on Windows
+
+    On Windows, any operation modifying pip should be run as:
+        python -m pip ...
+    """
+    pip_names = [
+        "pip.exe",
+        "pip{}.exe".format(sys.version_info[0]),
+        "pip{}.{}.exe".format(*sys.version_info[:2])
+    ]
+
+    # See https://github.com/pypa/pip/issues/1299 for more discussion
+    should_show_use_python_msg = (
+        modifying_pip and
+        WINDOWS and
+        os.path.basename(sys.argv[0]) in pip_names
+    )
+
+    if should_show_use_python_msg:
+        new_command = [
+            sys.executable, "-m", "pip"
+        ] + sys.argv[1:]
+        raise CommandError(
+            'To modify pip, please run the following command:\n{}'
+            .format(" ".join(new_command))
+        )
+
+
+def is_console_interactive():
+    # type: () -> bool
+    """Is this console interactive?
+    """
+    return sys.stdin is not None and sys.stdin.isatty()
+
+
+def hash_file(path, blocksize=1 << 20):
+    # type: (Text, int) -> Tuple[Any, int]
+    """Return (hash, length) for path using hashlib.sha256()
+    """
+
+    h = hashlib.sha256()
+    length = 0
+    with open(path, 'rb') as f:
+        for block in read_chunks(f, size=blocksize):
+            length += len(block)
+            h.update(block)
+    return h, length
+
+
+def is_wheel_installed():
+    """
+    Return whether the wheel package is installed.
+    """
+    try:
+        import wheel  # noqa: F401
+    except ImportError:
+        return False
+
+    return True
+
+
+def pairwise(iterable):
+    # type: (Iterable[Any]) -> Iterator[Tuple[Any, Any]]
+    """
+    Return paired elements.
+
+    For example:
+        s -> (s0, s1), (s2, s3), (s4, s5), ...
+    """
+    iterable = iter(iterable)
+    return zip_longest(iterable, iterable)
+
+
+def partition(
+    pred,  # type: Callable[[T], bool]
+    iterable,  # type: Iterable[T]
+):
+    # type: (...) -> Tuple[Iterable[T], Iterable[T]]
+    """
+    Use a predicate to partition entries into false entries and true entries,
+    like
+
+        partition(is_odd, range(10)) --> 0 2 4 6 8   and  1 3 5 7 9
+    """
+    t1, t2 = tee(iterable)
+    return filterfalse(pred, t1), filter(pred, t2)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/models.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/models.py
new file mode 100644
index 0000000..d1c2f22
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/models.py
@@ -0,0 +1,44 @@
+"""Utilities for defining models
+"""
+# The following comment should be removed at some point in the future.
+# mypy: disallow-untyped-defs=False
+
+import operator
+
+
+class KeyBasedCompareMixin(object):
+    """Provides comparison capabilities that is based on a key
+    """
+
+    __slots__ = ['_compare_key', '_defining_class']
+
+    def __init__(self, key, defining_class):
+        self._compare_key = key
+        self._defining_class = defining_class
+
+    def __hash__(self):
+        return hash(self._compare_key)
+
+    def __lt__(self, other):
+        return self._compare(other, operator.__lt__)
+
+    def __le__(self, other):
+        return self._compare(other, operator.__le__)
+
+    def __gt__(self, other):
+        return self._compare(other, operator.__gt__)
+
+    def __ge__(self, other):
+        return self._compare(other, operator.__ge__)
+
+    def __eq__(self, other):
+        return self._compare(other, operator.__eq__)
+
+    def __ne__(self, other):
+        return self._compare(other, operator.__ne__)
+
+    def _compare(self, other, method):
+        if not isinstance(other, self._defining_class):
+            return NotImplemented
+
+        return method(self._compare_key, other._compare_key)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/packaging.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/packaging.py
new file mode 100644
index 0000000..68aa86e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/packaging.py
@@ -0,0 +1,94 @@
+from __future__ import absolute_import
+
+import logging
+from email.parser import FeedParser
+
+from pip._vendor import pkg_resources
+from pip._vendor.packaging import specifiers, version
+
+from pip._internal.exceptions import NoneMetadataError
+from pip._internal.utils.misc import display_path
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, Tuple
+    from email.message import Message
+    from pip._vendor.pkg_resources import Distribution
+
+
+logger = logging.getLogger(__name__)
+
+
+def check_requires_python(requires_python, version_info):
+    # type: (Optional[str], Tuple[int, ...]) -> bool
+    """
+    Check if the given Python version matches a "Requires-Python" specifier.
+
+    :param version_info: A 3-tuple of ints representing a Python
+        major-minor-micro version to check (e.g. `sys.version_info[:3]`).
+
+    :return: `True` if the given Python version satisfies the requirement.
+        Otherwise, return `False`.
+
+    :raises InvalidSpecifier: If `requires_python` has an invalid format.
+    """
+    if requires_python is None:
+        # The package provides no information
+        return True
+    requires_python_specifier = specifiers.SpecifierSet(requires_python)
+
+    python_version = version.parse('.'.join(map(str, version_info)))
+    return python_version in requires_python_specifier
+
+
+def get_metadata(dist):
+    # type: (Distribution) -> Message
+    """
+    :raises NoneMetadataError: if the distribution reports `has_metadata()`
+        True but `get_metadata()` returns None.
+    """
+    metadata_name = 'METADATA'
+    if (isinstance(dist, pkg_resources.DistInfoDistribution) and
+            dist.has_metadata(metadata_name)):
+        metadata = dist.get_metadata(metadata_name)
+    elif dist.has_metadata('PKG-INFO'):
+        metadata_name = 'PKG-INFO'
+        metadata = dist.get_metadata(metadata_name)
+    else:
+        logger.warning("No metadata found in %s", display_path(dist.location))
+        metadata = ''
+
+    if metadata is None:
+        raise NoneMetadataError(dist, metadata_name)
+
+    feed_parser = FeedParser()
+    # The following line errors out if with a "NoneType" TypeError if
+    # passed metadata=None.
+    feed_parser.feed(metadata)
+    return feed_parser.close()
+
+
+def get_requires_python(dist):
+    # type: (pkg_resources.Distribution) -> Optional[str]
+    """
+    Return the "Requires-Python" metadata for a distribution, or None
+    if not present.
+    """
+    pkg_info_dict = get_metadata(dist)
+    requires_python = pkg_info_dict.get('Requires-Python')
+
+    if requires_python is not None:
+        # Convert to a str to satisfy the type checker, since requires_python
+        # can be a Header object.
+        requires_python = str(requires_python)
+
+    return requires_python
+
+
+def get_installer(dist):
+    # type: (Distribution) -> str
+    if dist.has_metadata('INSTALLER'):
+        for line in dist.get_metadata_lines('INSTALLER'):
+            if line.strip():
+                return line.strip()
+    return ''
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/parallel.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/parallel.py
new file mode 100644
index 0000000..9fe1fe8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/parallel.py
@@ -0,0 +1,107 @@
+"""Convenient parallelization of higher order functions.
+
+This module provides two helper functions, with appropriate fallbacks on
+Python 2 and on systems lacking support for synchronization mechanisms:
+
+- map_multiprocess
+- map_multithread
+
+These helpers work like Python 3's map, with two differences:
+
+- They don't guarantee the order of processing of
+  the elements of the iterable.
+- The underlying process/thread pools chop the iterable into
+  a number of chunks, so that for very long iterables using
+  a large value for chunksize can make the job complete much faster
+  than using the default value of 1.
+"""
+
+__all__ = ['map_multiprocess', 'map_multithread']
+
+from contextlib import contextmanager
+from multiprocessing import Pool as ProcessPool
+from multiprocessing.dummy import Pool as ThreadPool
+
+from pip._vendor.requests.adapters import DEFAULT_POOLSIZE
+from pip._vendor.six import PY2
+from pip._vendor.six.moves import map
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Callable, Iterable, Iterator, Union, TypeVar
+    from multiprocessing import pool
+
+    Pool = Union[pool.Pool, pool.ThreadPool]
+    S = TypeVar('S')
+    T = TypeVar('T')
+
+# On platforms without sem_open, multiprocessing[.dummy] Pool
+# cannot be created.
+try:
+    import multiprocessing.synchronize  # noqa
+except ImportError:
+    LACK_SEM_OPEN = True
+else:
+    LACK_SEM_OPEN = False
+
+# Incredibly large timeout to work around bpo-8296 on Python 2.
+TIMEOUT = 2000000
+
+
+@contextmanager
+def closing(pool):
+    # type: (Pool) -> Iterator[Pool]
+    """Return a context manager making sure the pool closes properly."""
+    try:
+        yield pool
+    finally:
+        # For Pool.imap*, close and join are needed
+        # for the returned iterator to begin yielding.
+        pool.close()
+        pool.join()
+        pool.terminate()
+
+
+def _map_fallback(func, iterable, chunksize=1):
+    # type: (Callable[[S], T], Iterable[S], int) -> Iterator[T]
+    """Make an iterator applying func to each element in iterable.
+
+    This function is the sequential fallback either on Python 2
+    where Pool.imap* doesn't react to KeyboardInterrupt
+    or when sem_open is unavailable.
+    """
+    return map(func, iterable)
+
+
+def _map_multiprocess(func, iterable, chunksize=1):
+    # type: (Callable[[S], T], Iterable[S], int) -> Iterator[T]
+    """Chop iterable into chunks and submit them to a process pool.
+
+    For very long iterables using a large value for chunksize can make
+    the job complete much faster than using the default value of 1.
+
+    Return an unordered iterator of the results.
+    """
+    with closing(ProcessPool()) as pool:
+        return pool.imap_unordered(func, iterable, chunksize)
+
+
+def _map_multithread(func, iterable, chunksize=1):
+    # type: (Callable[[S], T], Iterable[S], int) -> Iterator[T]
+    """Chop iterable into chunks and submit them to a thread pool.
+
+    For very long iterables using a large value for chunksize can make
+    the job complete much faster than using the default value of 1.
+
+    Return an unordered iterator of the results.
+    """
+    with closing(ThreadPool(DEFAULT_POOLSIZE)) as pool:
+        return pool.imap_unordered(func, iterable, chunksize)
+
+
+if LACK_SEM_OPEN or PY2:
+    map_multiprocess = map_multithread = _map_fallback
+else:
+    map_multiprocess = _map_multiprocess
+    map_multithread = _map_multithread
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/pkg_resources.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/pkg_resources.py
new file mode 100644
index 0000000..0bc129a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/pkg_resources.py
@@ -0,0 +1,44 @@
+from pip._vendor.pkg_resources import yield_lines
+from pip._vendor.six import ensure_str
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Dict, Iterable, List
+
+
+class DictMetadata(object):
+    """IMetadataProvider that reads metadata files from a dictionary.
+    """
+    def __init__(self, metadata):
+        # type: (Dict[str, bytes]) -> None
+        self._metadata = metadata
+
+    def has_metadata(self, name):
+        # type: (str) -> bool
+        return name in self._metadata
+
+    def get_metadata(self, name):
+        # type: (str) -> str
+        try:
+            return ensure_str(self._metadata[name])
+        except UnicodeDecodeError as e:
+            # Mirrors handling done in pkg_resources.NullProvider.
+            e.reason += " in {} file".format(name)
+            raise
+
+    def get_metadata_lines(self, name):
+        # type: (str) -> Iterable[str]
+        return yield_lines(self.get_metadata(name))
+
+    def metadata_isdir(self, name):
+        # type: (str) -> bool
+        return False
+
+    def metadata_listdir(self, name):
+        # type: (str) -> List[str]
+        return []
+
+    def run_script(self, script_name, namespace):
+        # type: (str, str) -> None
+        pass
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/setuptools_build.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/setuptools_build.py
new file mode 100644
index 0000000..2a664b0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/setuptools_build.py
@@ -0,0 +1,181 @@
+import sys
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Optional, Sequence
+
+# Shim to wrap setup.py invocation with setuptools
+#
+# We set sys.argv[0] to the path to the underlying setup.py file so
+# setuptools / distutils don't take the path to the setup.py to be "-c" when
+# invoking via the shim.  This avoids e.g. the following manifest_maker
+# warning: "warning: manifest_maker: standard file '-c' not found".
+_SETUPTOOLS_SHIM = (
+    "import sys, setuptools, tokenize; sys.argv[0] = {0!r}; __file__={0!r};"
+    "f=getattr(tokenize, 'open', open)(__file__);"
+    "code=f.read().replace('\\r\\n', '\\n');"
+    "f.close();"
+    "exec(compile(code, __file__, 'exec'))"
+)
+
+
+def make_setuptools_shim_args(
+    setup_py_path,  # type: str
+    global_options=None,  # type: Sequence[str]
+    no_user_config=False,  # type: bool
+    unbuffered_output=False  # type: bool
+):
+    # type: (...) -> List[str]
+    """
+    Get setuptools command arguments with shim wrapped setup file invocation.
+
+    :param setup_py_path: The path to setup.py to be wrapped.
+    :param global_options: Additional global options.
+    :param no_user_config: If True, disables personal user configuration.
+    :param unbuffered_output: If True, adds the unbuffered switch to the
+     argument list.
+    """
+    args = [sys.executable]
+    if unbuffered_output:
+        args += ["-u"]
+    args += ["-c", _SETUPTOOLS_SHIM.format(setup_py_path)]
+    if global_options:
+        args += global_options
+    if no_user_config:
+        args += ["--no-user-cfg"]
+    return args
+
+
+def make_setuptools_bdist_wheel_args(
+    setup_py_path,  # type: str
+    global_options,  # type: Sequence[str]
+    build_options,  # type: Sequence[str]
+    destination_dir,  # type: str
+):
+    # type: (...) -> List[str]
+    # NOTE: Eventually, we'd want to also -S to the flags here, when we're
+    # isolating. Currently, it breaks Python in virtualenvs, because it
+    # relies on site.py to find parts of the standard library outside the
+    # virtualenv.
+    args = make_setuptools_shim_args(
+        setup_py_path,
+        global_options=global_options,
+        unbuffered_output=True
+    )
+    args += ["bdist_wheel", "-d", destination_dir]
+    args += build_options
+    return args
+
+
+def make_setuptools_clean_args(
+    setup_py_path,  # type: str
+    global_options,  # type: Sequence[str]
+):
+    # type: (...) -> List[str]
+    args = make_setuptools_shim_args(
+        setup_py_path,
+        global_options=global_options,
+        unbuffered_output=True
+    )
+    args += ["clean", "--all"]
+    return args
+
+
+def make_setuptools_develop_args(
+    setup_py_path,  # type: str
+    global_options,  # type: Sequence[str]
+    install_options,  # type: Sequence[str]
+    no_user_config,  # type: bool
+    prefix,  # type: Optional[str]
+    home,  # type: Optional[str]
+    use_user_site,  # type: bool
+):
+    # type: (...) -> List[str]
+    assert not (use_user_site and prefix)
+
+    args = make_setuptools_shim_args(
+        setup_py_path,
+        global_options=global_options,
+        no_user_config=no_user_config,
+    )
+
+    args += ["develop", "--no-deps"]
+
+    args += install_options
+
+    if prefix:
+        args += ["--prefix", prefix]
+    if home is not None:
+        args += ["--home", home]
+
+    if use_user_site:
+        args += ["--user", "--prefix="]
+
+    return args
+
+
+def make_setuptools_egg_info_args(
+    setup_py_path,  # type: str
+    egg_info_dir,  # type: Optional[str]
+    no_user_config,  # type: bool
+):
+    # type: (...) -> List[str]
+    args = make_setuptools_shim_args(
+        setup_py_path, no_user_config=no_user_config
+    )
+
+    args += ["egg_info"]
+
+    if egg_info_dir:
+        args += ["--egg-base", egg_info_dir]
+
+    return args
+
+
+def make_setuptools_install_args(
+    setup_py_path,  # type: str
+    global_options,  # type: Sequence[str]
+    install_options,  # type: Sequence[str]
+    record_filename,  # type: str
+    root,  # type: Optional[str]
+    prefix,  # type: Optional[str]
+    header_dir,  # type: Optional[str]
+    home,  # type: Optional[str]
+    use_user_site,  # type: bool
+    no_user_config,  # type: bool
+    pycompile  # type: bool
+):
+    # type: (...) -> List[str]
+    assert not (use_user_site and prefix)
+    assert not (use_user_site and root)
+
+    args = make_setuptools_shim_args(
+        setup_py_path,
+        global_options=global_options,
+        no_user_config=no_user_config,
+        unbuffered_output=True
+    )
+    args += ["install", "--record", record_filename]
+    args += ["--single-version-externally-managed"]
+
+    if root is not None:
+        args += ["--root", root]
+    if prefix is not None:
+        args += ["--prefix", prefix]
+    if home is not None:
+        args += ["--home", home]
+    if use_user_site:
+        args += ["--user", "--prefix="]
+
+    if pycompile:
+        args += ["--compile"]
+    else:
+        args += ["--no-compile"]
+
+    if header_dir:
+        args += ["--install-headers", header_dir]
+
+    args += install_options
+
+    return args
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/subprocess.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/subprocess.py
new file mode 100644
index 0000000..d398e68
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/subprocess.py
@@ -0,0 +1,280 @@
+from __future__ import absolute_import
+
+import logging
+import os
+import subprocess
+
+from pip._vendor.six.moves import shlex_quote
+
+from pip._internal.cli.spinners import SpinnerInterface, open_spinner
+from pip._internal.exceptions import InstallationError
+from pip._internal.utils.compat import console_to_str, str_to_display
+from pip._internal.utils.logging import subprocess_logger
+from pip._internal.utils.misc import HiddenText, path_to_display
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Any, Callable, Iterable, List, Mapping, Optional, Text, Union,
+    )
+
+    CommandArgs = List[Union[str, HiddenText]]
+
+
+LOG_DIVIDER = '----------------------------------------'
+
+
+def make_command(*args):
+    # type: (Union[str, HiddenText, CommandArgs]) -> CommandArgs
+    """
+    Create a CommandArgs object.
+    """
+    command_args = []  # type: CommandArgs
+    for arg in args:
+        # Check for list instead of CommandArgs since CommandArgs is
+        # only known during type-checking.
+        if isinstance(arg, list):
+            command_args.extend(arg)
+        else:
+            # Otherwise, arg is str or HiddenText.
+            command_args.append(arg)
+
+    return command_args
+
+
+def format_command_args(args):
+    # type: (Union[List[str], CommandArgs]) -> str
+    """
+    Format command arguments for display.
+    """
+    # For HiddenText arguments, display the redacted form by calling str().
+    # Also, we don't apply str() to arguments that aren't HiddenText since
+    # this can trigger a UnicodeDecodeError in Python 2 if the argument
+    # has type unicode and includes a non-ascii character.  (The type
+    # checker doesn't ensure the annotations are correct in all cases.)
+    return ' '.join(
+        shlex_quote(str(arg)) if isinstance(arg, HiddenText)
+        else shlex_quote(arg) for arg in args
+    )
+
+
+def reveal_command_args(args):
+    # type: (Union[List[str], CommandArgs]) -> List[str]
+    """
+    Return the arguments in their raw, unredacted form.
+    """
+    return [
+        arg.secret if isinstance(arg, HiddenText) else arg for arg in args
+    ]
+
+
+def make_subprocess_output_error(
+    cmd_args,     # type: Union[List[str], CommandArgs]
+    cwd,          # type: Optional[str]
+    lines,        # type: List[Text]
+    exit_status,  # type: int
+):
+    # type: (...) -> Text
+    """
+    Create and return the error message to use to log a subprocess error
+    with command output.
+
+    :param lines: A list of lines, each ending with a newline.
+    """
+    command = format_command_args(cmd_args)
+    # Convert `command` and `cwd` to text (unicode in Python 2) so we can use
+    # them as arguments in the unicode format string below. This avoids
+    # "UnicodeDecodeError: 'ascii' codec can't decode byte ..." in Python 2
+    # if either contains a non-ascii character.
+    command_display = str_to_display(command, desc='command bytes')
+    cwd_display = path_to_display(cwd)
+
+    # We know the joined output value ends in a newline.
+    output = ''.join(lines)
+    msg = (
+        # Use a unicode string to avoid "UnicodeEncodeError: 'ascii'
+        # codec can't encode character ..." in Python 2 when a format
+        # argument (e.g. `output`) has a non-ascii character.
+        u'Command errored out with exit status {exit_status}:\n'
+        ' command: {command_display}\n'
+        '     cwd: {cwd_display}\n'
+        'Complete output ({line_count} lines):\n{output}{divider}'
+    ).format(
+        exit_status=exit_status,
+        command_display=command_display,
+        cwd_display=cwd_display,
+        line_count=len(lines),
+        output=output,
+        divider=LOG_DIVIDER,
+    )
+    return msg
+
+
+def call_subprocess(
+    cmd,  # type: Union[List[str], CommandArgs]
+    show_stdout=False,  # type: bool
+    cwd=None,  # type: Optional[str]
+    on_returncode='raise',  # type: str
+    extra_ok_returncodes=None,  # type: Optional[Iterable[int]]
+    command_desc=None,  # type: Optional[str]
+    extra_environ=None,  # type: Optional[Mapping[str, Any]]
+    unset_environ=None,  # type: Optional[Iterable[str]]
+    spinner=None,  # type: Optional[SpinnerInterface]
+    log_failed_cmd=True  # type: Optional[bool]
+):
+    # type: (...) -> Text
+    """
+    Args:
+      show_stdout: if true, use INFO to log the subprocess's stderr and
+        stdout streams.  Otherwise, use DEBUG.  Defaults to False.
+      extra_ok_returncodes: an iterable of integer return codes that are
+        acceptable, in addition to 0. Defaults to None, which means [].
+      unset_environ: an iterable of environment variable names to unset
+        prior to calling subprocess.Popen().
+      log_failed_cmd: if false, failed commands are not logged, only raised.
+    """
+    if extra_ok_returncodes is None:
+        extra_ok_returncodes = []
+    if unset_environ is None:
+        unset_environ = []
+    # Most places in pip use show_stdout=False. What this means is--
+    #
+    # - We connect the child's output (combined stderr and stdout) to a
+    #   single pipe, which we read.
+    # - We log this output to stderr at DEBUG level as it is received.
+    # - If DEBUG logging isn't enabled (e.g. if --verbose logging wasn't
+    #   requested), then we show a spinner so the user can still see the
+    #   subprocess is in progress.
+    # - If the subprocess exits with an error, we log the output to stderr
+    #   at ERROR level if it hasn't already been displayed to the console
+    #   (e.g. if --verbose logging wasn't enabled).  This way we don't log
+    #   the output to the console twice.
+    #
+    # If show_stdout=True, then the above is still done, but with DEBUG
+    # replaced by INFO.
+    if show_stdout:
+        # Then log the subprocess output at INFO level.
+        log_subprocess = subprocess_logger.info
+        used_level = logging.INFO
+    else:
+        # Then log the subprocess output using DEBUG.  This also ensures
+        # it will be logged to the log file (aka user_log), if enabled.
+        log_subprocess = subprocess_logger.debug
+        used_level = logging.DEBUG
+
+    # Whether the subprocess will be visible in the console.
+    showing_subprocess = subprocess_logger.getEffectiveLevel() <= used_level
+
+    # Only use the spinner if we're not showing the subprocess output
+    # and we have a spinner.
+    use_spinner = not showing_subprocess and spinner is not None
+
+    if command_desc is None:
+        command_desc = format_command_args(cmd)
+
+    log_subprocess("Running command %s", command_desc)
+    env = os.environ.copy()
+    if extra_environ:
+        env.update(extra_environ)
+    for name in unset_environ:
+        env.pop(name, None)
+    try:
+        proc = subprocess.Popen(
+            # Convert HiddenText objects to the underlying str.
+            reveal_command_args(cmd),
+            stderr=subprocess.STDOUT, stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE, cwd=cwd, env=env,
+        )
+        assert proc.stdin
+        assert proc.stdout
+        proc.stdin.close()
+    except Exception as exc:
+        if log_failed_cmd:
+            subprocess_logger.critical(
+                "Error %s while executing command %s", exc, command_desc,
+            )
+        raise
+    all_output = []
+    while True:
+        # The "line" value is a unicode string in Python 2.
+        line = console_to_str(proc.stdout.readline())
+        if not line:
+            break
+        line = line.rstrip()
+        all_output.append(line + '\n')
+
+        # Show the line immediately.
+        log_subprocess(line)
+        # Update the spinner.
+        if use_spinner:
+            assert spinner
+            spinner.spin()
+    try:
+        proc.wait()
+    finally:
+        if proc.stdout:
+            proc.stdout.close()
+    proc_had_error = (
+        proc.returncode and proc.returncode not in extra_ok_returncodes
+    )
+    if use_spinner:
+        assert spinner
+        if proc_had_error:
+            spinner.finish("error")
+        else:
+            spinner.finish("done")
+    if proc_had_error:
+        if on_returncode == 'raise':
+            if not showing_subprocess and log_failed_cmd:
+                # Then the subprocess streams haven't been logged to the
+                # console yet.
+                msg = make_subprocess_output_error(
+                    cmd_args=cmd,
+                    cwd=cwd,
+                    lines=all_output,
+                    exit_status=proc.returncode,
+                )
+                subprocess_logger.error(msg)
+            exc_msg = (
+                'Command errored out with exit status {}: {} '
+                'Check the logs for full command output.'
+            ).format(proc.returncode, command_desc)
+            raise InstallationError(exc_msg)
+        elif on_returncode == 'warn':
+            subprocess_logger.warning(
+                'Command "%s" had error code %s in %s',
+                command_desc,
+                proc.returncode,
+                cwd,
+            )
+        elif on_returncode == 'ignore':
+            pass
+        else:
+            raise ValueError('Invalid value: on_returncode={!r}'.format(
+                             on_returncode))
+    return ''.join(all_output)
+
+
+def runner_with_spinner_message(message):
+    # type: (str) -> Callable[..., None]
+    """Provide a subprocess_runner that shows a spinner message.
+
+    Intended for use with for pep517's Pep517HookCaller. Thus, the runner has
+    an API that matches what's expected by Pep517HookCaller.subprocess_runner.
+    """
+
+    def runner(
+        cmd,  # type: List[str]
+        cwd=None,  # type: Optional[str]
+        extra_environ=None  # type: Optional[Mapping[str, Any]]
+    ):
+        # type: (...) -> None
+        with open_spinner(message) as spinner:
+            call_subprocess(
+                cmd,
+                cwd=cwd,
+                extra_environ=extra_environ,
+                spinner=spinner,
+            )
+
+    return runner
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/temp_dir.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/temp_dir.py
new file mode 100644
index 0000000..03aa828
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/temp_dir.py
@@ -0,0 +1,274 @@
+from __future__ import absolute_import
+
+import errno
+import itertools
+import logging
+import os.path
+import tempfile
+from contextlib import contextmanager
+
+from pip._vendor.contextlib2 import ExitStack
+from pip._vendor.six import ensure_text
+
+from pip._internal.utils.misc import enum, rmtree
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any, Dict, Iterator, Optional, TypeVar, Union
+
+    _T = TypeVar('_T', bound='TempDirectory')
+
+
+logger = logging.getLogger(__name__)
+
+
+# Kinds of temporary directories. Only needed for ones that are
+# globally-managed.
+tempdir_kinds = enum(
+    BUILD_ENV="build-env",
+    EPHEM_WHEEL_CACHE="ephem-wheel-cache",
+    REQ_BUILD="req-build",
+)
+
+
+_tempdir_manager = None  # type: Optional[ExitStack]
+
+
+@contextmanager
+def global_tempdir_manager():
+    # type: () -> Iterator[None]
+    global _tempdir_manager
+    with ExitStack() as stack:
+        old_tempdir_manager, _tempdir_manager = _tempdir_manager, stack
+        try:
+            yield
+        finally:
+            _tempdir_manager = old_tempdir_manager
+
+
+class TempDirectoryTypeRegistry(object):
+    """Manages temp directory behavior
+    """
+
+    def __init__(self):
+        # type: () -> None
+        self._should_delete = {}  # type: Dict[str, bool]
+
+    def set_delete(self, kind, value):
+        # type: (str, bool) -> None
+        """Indicate whether a TempDirectory of the given kind should be
+        auto-deleted.
+        """
+        self._should_delete[kind] = value
+
+    def get_delete(self, kind):
+        # type: (str) -> bool
+        """Get configured auto-delete flag for a given TempDirectory type,
+        default True.
+        """
+        return self._should_delete.get(kind, True)
+
+
+_tempdir_registry = None  # type: Optional[TempDirectoryTypeRegistry]
+
+
+@contextmanager
+def tempdir_registry():
+    # type: () -> Iterator[TempDirectoryTypeRegistry]
+    """Provides a scoped global tempdir registry that can be used to dictate
+    whether directories should be deleted.
+    """
+    global _tempdir_registry
+    old_tempdir_registry = _tempdir_registry
+    _tempdir_registry = TempDirectoryTypeRegistry()
+    try:
+        yield _tempdir_registry
+    finally:
+        _tempdir_registry = old_tempdir_registry
+
+
+class _Default(object):
+    pass
+
+
+_default = _Default()
+
+
+class TempDirectory(object):
+    """Helper class that owns and cleans up a temporary directory.
+
+    This class can be used as a context manager or as an OO representation of a
+    temporary directory.
+
+    Attributes:
+        path
+            Location to the created temporary directory
+        delete
+            Whether the directory should be deleted when exiting
+            (when used as a contextmanager)
+
+    Methods:
+        cleanup()
+            Deletes the temporary directory
+
+    When used as a context manager, if the delete attribute is True, on
+    exiting the context the temporary directory is deleted.
+    """
+
+    def __init__(
+        self,
+        path=None,    # type: Optional[str]
+        delete=_default,  # type: Union[bool, None, _Default]
+        kind="temp",  # type: str
+        globally_managed=False,  # type: bool
+    ):
+        super(TempDirectory, self).__init__()
+
+        if delete is _default:
+            if path is not None:
+                # If we were given an explicit directory, resolve delete option
+                # now.
+                delete = False
+            else:
+                # Otherwise, we wait until cleanup and see what
+                # tempdir_registry says.
+                delete = None
+
+        if path is None:
+            path = self._create(kind)
+
+        self._path = path
+        self._deleted = False
+        self.delete = delete
+        self.kind = kind
+
+        if globally_managed:
+            assert _tempdir_manager is not None
+            _tempdir_manager.enter_context(self)
+
+    @property
+    def path(self):
+        # type: () -> str
+        assert not self._deleted, (
+            "Attempted to access deleted path: {}".format(self._path)
+        )
+        return self._path
+
+    def __repr__(self):
+        # type: () -> str
+        return "<{} {!r}>".format(self.__class__.__name__, self.path)
+
+    def __enter__(self):
+        # type: (_T) -> _T
+        return self
+
+    def __exit__(self, exc, value, tb):
+        # type: (Any, Any, Any) -> None
+        if self.delete is not None:
+            delete = self.delete
+        elif _tempdir_registry:
+            delete = _tempdir_registry.get_delete(self.kind)
+        else:
+            delete = True
+
+        if delete:
+            self.cleanup()
+
+    def _create(self, kind):
+        # type: (str) -> str
+        """Create a temporary directory and store its path in self.path
+        """
+        # We realpath here because some systems have their default tmpdir
+        # symlinked to another directory.  This tends to confuse build
+        # scripts, so we canonicalize the path by traversing potential
+        # symlinks here.
+        path = os.path.realpath(
+            tempfile.mkdtemp(prefix="pip-{}-".format(kind))
+        )
+        logger.debug("Created temporary directory: %s", path)
+        return path
+
+    def cleanup(self):
+        # type: () -> None
+        """Remove the temporary directory created and reset state
+        """
+        self._deleted = True
+        if os.path.exists(self._path):
+            # Make sure to pass unicode on Python 2 to make the contents also
+            # use unicode, ensuring non-ASCII names and can be represented.
+            rmtree(ensure_text(self._path))
+
+
+class AdjacentTempDirectory(TempDirectory):
+    """Helper class that creates a temporary directory adjacent to a real one.
+
+    Attributes:
+        original
+            The original directory to create a temp directory for.
+        path
+            After calling create() or entering, contains the full
+            path to the temporary directory.
+        delete
+            Whether the directory should be deleted when exiting
+            (when used as a contextmanager)
+
+    """
+    # The characters that may be used to name the temp directory
+    # We always prepend a ~ and then rotate through these until
+    # a usable name is found.
+    # pkg_resources raises a different error for .dist-info folder
+    # with leading '-' and invalid metadata
+    LEADING_CHARS = "-~.=%0123456789"
+
+    def __init__(self, original, delete=None):
+        # type: (str, Optional[bool]) -> None
+        self.original = original.rstrip('/\\')
+        super(AdjacentTempDirectory, self).__init__(delete=delete)
+
+    @classmethod
+    def _generate_names(cls, name):
+        # type: (str) -> Iterator[str]
+        """Generates a series of temporary names.
+
+        The algorithm replaces the leading characters in the name
+        with ones that are valid filesystem characters, but are not
+        valid package names (for both Python and pip definitions of
+        package).
+        """
+        for i in range(1, len(name)):
+            for candidate in itertools.combinations_with_replacement(
+                    cls.LEADING_CHARS, i - 1):
+                new_name = '~' + ''.join(candidate) + name[i:]
+                if new_name != name:
+                    yield new_name
+
+        # If we make it this far, we will have to make a longer name
+        for i in range(len(cls.LEADING_CHARS)):
+            for candidate in itertools.combinations_with_replacement(
+                    cls.LEADING_CHARS, i):
+                new_name = '~' + ''.join(candidate) + name
+                if new_name != name:
+                    yield new_name
+
+    def _create(self, kind):
+        # type: (str) -> str
+        root, name = os.path.split(self.original)
+        for candidate in self._generate_names(name):
+            path = os.path.join(root, candidate)
+            try:
+                os.mkdir(path)
+            except OSError as ex:
+                # Continue if the name exists already
+                if ex.errno != errno.EEXIST:
+                    raise
+            else:
+                path = os.path.realpath(path)
+                break
+        else:
+            # Final fallback on the default behavior.
+            path = os.path.realpath(
+                tempfile.mkdtemp(prefix="pip-{}-".format(kind))
+            )
+
+        logger.debug("Created temporary directory: %s", path)
+        return path
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/typing.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/typing.py
new file mode 100644
index 0000000..8505a29
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/typing.py
@@ -0,0 +1,38 @@
+"""For neatly implementing static typing in pip.
+
+`mypy` - the static type analysis tool we use - uses the `typing` module, which
+provides core functionality fundamental to mypy's functioning.
+
+Generally, `typing` would be imported at runtime and used in that fashion -
+it acts as a no-op at runtime and does not have any run-time overhead by
+design.
+
+As it turns out, `typing` is not vendorable - it uses separate sources for
+Python 2/Python 3. Thus, this codebase can not expect it to be present.
+To work around this, mypy allows the typing import to be behind a False-y
+optional to prevent it from running at runtime and type-comments can be used
+to remove the need for the types to be accessible directly during runtime.
+
+This module provides the False-y guard in a nicely named fashion so that a
+curious maintainer can reach here to read this.
+
+In pip, all static-typing related imports should be guarded as follows:
+
+    from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+    if MYPY_CHECK_RUNNING:
+        from typing import ...
+
+Ref: https://github.com/python/mypy/issues/3216
+"""
+
+MYPY_CHECK_RUNNING = False
+
+
+if MYPY_CHECK_RUNNING:
+    from typing import cast
+else:
+    # typing's cast() is needed at runtime, but we don't want to import typing.
+    # Thus, we use a dummy no-op version, which we tell mypy to ignore.
+    def cast(type_, value):  # type: ignore
+        return value
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/unpacking.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/unpacking.py
new file mode 100644
index 0000000..620f31e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/unpacking.py
@@ -0,0 +1,281 @@
+"""Utilities related archives.
+"""
+
+from __future__ import absolute_import
+
+import logging
+import os
+import shutil
+import stat
+import tarfile
+import zipfile
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.utils.filetypes import (
+    BZ2_EXTENSIONS,
+    TAR_EXTENSIONS,
+    XZ_EXTENSIONS,
+    ZIP_EXTENSIONS,
+)
+from pip._internal.utils.misc import ensure_dir
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Iterable, List, Optional, Text, Union
+    from zipfile import ZipInfo
+
+
+logger = logging.getLogger(__name__)
+
+
+SUPPORTED_EXTENSIONS = ZIP_EXTENSIONS + TAR_EXTENSIONS
+
+try:
+    import bz2  # noqa
+    SUPPORTED_EXTENSIONS += BZ2_EXTENSIONS
+except ImportError:
+    logger.debug('bz2 module is not available')
+
+try:
+    # Only for Python 3.3+
+    import lzma  # noqa
+    SUPPORTED_EXTENSIONS += XZ_EXTENSIONS
+except ImportError:
+    logger.debug('lzma module is not available')
+
+
+def current_umask():
+    # type: () -> int
+    """Get the current umask which involves having to set it temporarily."""
+    mask = os.umask(0)
+    os.umask(mask)
+    return mask
+
+
+def split_leading_dir(path):
+    # type: (Union[str, Text]) -> List[Union[str, Text]]
+    path = path.lstrip('/').lstrip('\\')
+    if (
+        '/' in path and (
+            ('\\' in path and path.find('/') < path.find('\\')) or
+            '\\' not in path
+        )
+    ):
+        return path.split('/', 1)
+    elif '\\' in path:
+        return path.split('\\', 1)
+    else:
+        return [path, '']
+
+
+def has_leading_dir(paths):
+    # type: (Iterable[Union[str, Text]]) -> bool
+    """Returns true if all the paths have the same leading path name
+    (i.e., everything is in one subdirectory in an archive)"""
+    common_prefix = None
+    for path in paths:
+        prefix, rest = split_leading_dir(path)
+        if not prefix:
+            return False
+        elif common_prefix is None:
+            common_prefix = prefix
+        elif prefix != common_prefix:
+            return False
+    return True
+
+
+def is_within_directory(directory, target):
+    # type: ((Union[str, Text]), (Union[str, Text])) -> bool
+    """
+    Return true if the absolute path of target is within the directory
+    """
+    abs_directory = os.path.abspath(directory)
+    abs_target = os.path.abspath(target)
+
+    prefix = os.path.commonprefix([abs_directory, abs_target])
+    return prefix == abs_directory
+
+
+def set_extracted_file_to_default_mode_plus_executable(path):
+    # type: (Union[str, Text]) -> None
+    """
+    Make file present at path have execute for user/group/world
+    (chmod +x) is no-op on windows per python docs
+    """
+    os.chmod(path, (0o777 & ~current_umask() | 0o111))
+
+
+def zip_item_is_executable(info):
+    # type: (ZipInfo) -> bool
+    mode = info.external_attr >> 16
+    # if mode and regular file and any execute permissions for
+    # user/group/world?
+    return bool(mode and stat.S_ISREG(mode) and mode & 0o111)
+
+
+def unzip_file(filename, location, flatten=True):
+    # type: (str, str, bool) -> None
+    """
+    Unzip the file (with path `filename`) to the destination `location`.  All
+    files are written based on system defaults and umask (i.e. permissions are
+    not preserved), except that regular file members with any execute
+    permissions (user, group, or world) have "chmod +x" applied after being
+    written. Note that for windows, any execute changes using os.chmod are
+    no-ops per the python docs.
+    """
+    ensure_dir(location)
+    zipfp = open(filename, 'rb')
+    try:
+        zip = zipfile.ZipFile(zipfp, allowZip64=True)
+        leading = has_leading_dir(zip.namelist()) and flatten
+        for info in zip.infolist():
+            name = info.filename
+            fn = name
+            if leading:
+                fn = split_leading_dir(name)[1]
+            fn = os.path.join(location, fn)
+            dir = os.path.dirname(fn)
+            if not is_within_directory(location, fn):
+                message = (
+                    'The zip file ({}) has a file ({}) trying to install '
+                    'outside target directory ({})'
+                )
+                raise InstallationError(message.format(filename, fn, location))
+            if fn.endswith('/') or fn.endswith('\\'):
+                # A directory
+                ensure_dir(fn)
+            else:
+                ensure_dir(dir)
+                # Don't use read() to avoid allocating an arbitrarily large
+                # chunk of memory for the file's content
+                fp = zip.open(name)
+                try:
+                    with open(fn, 'wb') as destfp:
+                        shutil.copyfileobj(fp, destfp)
+                finally:
+                    fp.close()
+                    if zip_item_is_executable(info):
+                        set_extracted_file_to_default_mode_plus_executable(fn)
+    finally:
+        zipfp.close()
+
+
+def untar_file(filename, location):
+    # type: (str, str) -> None
+    """
+    Untar the file (with path `filename`) to the destination `location`.
+    All files are written based on system defaults and umask (i.e. permissions
+    are not preserved), except that regular file members with any execute
+    permissions (user, group, or world) have "chmod +x" applied after being
+    written.  Note that for windows, any execute changes using os.chmod are
+    no-ops per the python docs.
+    """
+    ensure_dir(location)
+    if filename.lower().endswith('.gz') or filename.lower().endswith('.tgz'):
+        mode = 'r:gz'
+    elif filename.lower().endswith(BZ2_EXTENSIONS):
+        mode = 'r:bz2'
+    elif filename.lower().endswith(XZ_EXTENSIONS):
+        mode = 'r:xz'
+    elif filename.lower().endswith('.tar'):
+        mode = 'r'
+    else:
+        logger.warning(
+            'Cannot determine compression type for file %s', filename,
+        )
+        mode = 'r:*'
+    tar = tarfile.open(filename, mode)
+    try:
+        leading = has_leading_dir([
+            member.name for member in tar.getmembers()
+        ])
+        for member in tar.getmembers():
+            fn = member.name
+            if leading:
+                # https://github.com/python/mypy/issues/1174
+                fn = split_leading_dir(fn)[1]  # type: ignore
+            path = os.path.join(location, fn)
+            if not is_within_directory(location, path):
+                message = (
+                    'The tar file ({}) has a file ({}) trying to install '
+                    'outside target directory ({})'
+                )
+                raise InstallationError(
+                    message.format(filename, path, location)
+                )
+            if member.isdir():
+                ensure_dir(path)
+            elif member.issym():
+                try:
+                    # https://github.com/python/typeshed/issues/2673
+                    tar._extract_member(member, path)  # type: ignore
+                except Exception as exc:
+                    # Some corrupt tar files seem to produce this
+                    # (specifically bad symlinks)
+                    logger.warning(
+                        'In the tar file %s the member %s is invalid: %s',
+                        filename, member.name, exc,
+                    )
+                    continue
+            else:
+                try:
+                    fp = tar.extractfile(member)
+                except (KeyError, AttributeError) as exc:
+                    # Some corrupt tar files seem to produce this
+                    # (specifically bad symlinks)
+                    logger.warning(
+                        'In the tar file %s the member %s is invalid: %s',
+                        filename, member.name, exc,
+                    )
+                    continue
+                ensure_dir(os.path.dirname(path))
+                assert fp is not None
+                with open(path, 'wb') as destfp:
+                    shutil.copyfileobj(fp, destfp)
+                fp.close()
+                # Update the timestamp (useful for cython compiled files)
+                # https://github.com/python/typeshed/issues/2673
+                tar.utime(member, path)  # type: ignore
+                # member have any execute permissions for user/group/world?
+                if member.mode & 0o111:
+                    set_extracted_file_to_default_mode_plus_executable(path)
+    finally:
+        tar.close()
+
+
+def unpack_file(
+        filename,  # type: str
+        location,  # type: str
+        content_type=None,  # type: Optional[str]
+):
+    # type: (...) -> None
+    filename = os.path.realpath(filename)
+    if (
+        content_type == 'application/zip' or
+        filename.lower().endswith(ZIP_EXTENSIONS) or
+        zipfile.is_zipfile(filename)
+    ):
+        unzip_file(
+            filename,
+            location,
+            flatten=not filename.endswith('.whl')
+        )
+    elif (
+        content_type == 'application/x-gzip' or
+        tarfile.is_tarfile(filename) or
+        filename.lower().endswith(
+            TAR_EXTENSIONS + BZ2_EXTENSIONS + XZ_EXTENSIONS
+        )
+    ):
+        untar_file(filename, location)
+    else:
+        # FIXME: handle?
+        # FIXME: magic signatures?
+        logger.critical(
+            'Cannot unpack file %s (downloaded from %s, content-type: %s); '
+            'cannot detect archive format',
+            filename, location, content_type,
+        )
+        raise InstallationError(
+            'Cannot determine archive format of {}'.format(location)
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/urls.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/urls.py
new file mode 100644
index 0000000..f37bc8f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/urls.py
@@ -0,0 +1,55 @@
+import os
+import sys
+
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+from pip._vendor.six.moves.urllib import request as urllib_request
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, Text, Union
+
+
+def get_url_scheme(url):
+    # type: (Union[str, Text]) -> Optional[Text]
+    if ':' not in url:
+        return None
+    return url.split(':', 1)[0].lower()
+
+
+def path_to_url(path):
+    # type: (Union[str, Text]) -> str
+    """
+    Convert a path to a file: URL.  The path will be made absolute and have
+    quoted path parts.
+    """
+    path = os.path.normpath(os.path.abspath(path))
+    url = urllib_parse.urljoin('file:', urllib_request.pathname2url(path))
+    return url
+
+
+def url_to_path(url):
+    # type: (str) -> str
+    """
+    Convert a file: URL to a path.
+    """
+    assert url.startswith('file:'), (
+        "You can only turn file: urls into filenames (not {url!r})"
+        .format(**locals()))
+
+    _, netloc, path, _, _ = urllib_parse.urlsplit(url)
+
+    if not netloc or netloc == 'localhost':
+        # According to RFC 8089, same as empty authority.
+        netloc = ''
+    elif sys.platform == 'win32':
+        # If we have a UNC path, prepend UNC share notation.
+        netloc = '\\\\' + netloc
+    else:
+        raise ValueError(
+            'non-local file URIs are not supported on this platform: {url!r}'
+            .format(**locals())
+        )
+
+    path = urllib_request.url2pathname(netloc + path)
+    return path
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/virtualenv.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/virtualenv.py
new file mode 100644
index 0000000..4a78128
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/virtualenv.py
@@ -0,0 +1,119 @@
+from __future__ import absolute_import
+
+import io
+import logging
+import os
+import re
+import site
+import sys
+
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+_INCLUDE_SYSTEM_SITE_PACKAGES_REGEX = re.compile(
+    r"include-system-site-packages\s*=\s*(?P<value>true|false)"
+)
+
+
+def _running_under_venv():
+    # type: () -> bool
+    """Checks if sys.base_prefix and sys.prefix match.
+
+    This handles PEP 405 compliant virtual environments.
+    """
+    return sys.prefix != getattr(sys, "base_prefix", sys.prefix)
+
+
+def _running_under_regular_virtualenv():
+    # type: () -> bool
+    """Checks if sys.real_prefix is set.
+
+    This handles virtual environments created with pypa's virtualenv.
+    """
+    # pypa/virtualenv case
+    return hasattr(sys, 'real_prefix')
+
+
+def running_under_virtualenv():
+    # type: () -> bool
+    """Return True if we're running inside a virtualenv, False otherwise.
+    """
+    return _running_under_venv() or _running_under_regular_virtualenv()
+
+
+def _get_pyvenv_cfg_lines():
+    # type: () -> Optional[List[str]]
+    """Reads {sys.prefix}/pyvenv.cfg and returns its contents as list of lines
+
+    Returns None, if it could not read/access the file.
+    """
+    pyvenv_cfg_file = os.path.join(sys.prefix, 'pyvenv.cfg')
+    try:
+        # Although PEP 405 does not specify, the built-in venv module always
+        # writes with UTF-8. (pypa/pip#8717)
+        with io.open(pyvenv_cfg_file, encoding='utf-8') as f:
+            return f.read().splitlines()  # avoids trailing newlines
+    except IOError:
+        return None
+
+
+def _no_global_under_venv():
+    # type: () -> bool
+    """Check `{sys.prefix}/pyvenv.cfg` for system site-packages inclusion
+
+    PEP 405 specifies that when system site-packages are not supposed to be
+    visible from a virtual environment, `pyvenv.cfg` must contain the following
+    line:
+
+        include-system-site-packages = false
+
+    Additionally, log a warning if accessing the file fails.
+    """
+    cfg_lines = _get_pyvenv_cfg_lines()
+    if cfg_lines is None:
+        # We're not in a "sane" venv, so assume there is no system
+        # site-packages access (since that's PEP 405's default state).
+        logger.warning(
+            "Could not access 'pyvenv.cfg' despite a virtual environment "
+            "being active. Assuming global site-packages is not accessible "
+            "in this environment."
+        )
+        return True
+
+    for line in cfg_lines:
+        match = _INCLUDE_SYSTEM_SITE_PACKAGES_REGEX.match(line)
+        if match is not None and match.group('value') == 'false':
+            return True
+    return False
+
+
+def _no_global_under_regular_virtualenv():
+    # type: () -> bool
+    """Check if "no-global-site-packages.txt" exists beside site.py
+
+    This mirrors logic in pypa/virtualenv for determining whether system
+    site-packages are visible in the virtual environment.
+    """
+    site_mod_dir = os.path.dirname(os.path.abspath(site.__file__))
+    no_global_site_packages_file = os.path.join(
+        site_mod_dir, 'no-global-site-packages.txt',
+    )
+    return os.path.exists(no_global_site_packages_file)
+
+
+def virtualenv_no_global():
+    # type: () -> bool
+    """Returns a boolean, whether running in venv with no system site-packages.
+    """
+    # PEP 405 compliance needs to be checked first since virtualenv >=20 would
+    # return True for both checks, but is only able to use the PEP 405 config.
+    if _running_under_venv():
+        return _no_global_under_venv()
+
+    if _running_under_regular_virtualenv():
+        return _no_global_under_regular_virtualenv()
+
+    return False
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/utils/wheel.py b/myenv/lib/python3.9/site-packages/pip/_internal/utils/wheel.py
new file mode 100644
index 0000000..9ce371c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/utils/wheel.py
@@ -0,0 +1,225 @@
+"""Support functions for working with wheel files.
+"""
+
+from __future__ import absolute_import
+
+import logging
+from email.parser import Parser
+from zipfile import ZipFile
+
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.pkg_resources import DistInfoDistribution
+from pip._vendor.six import PY2, ensure_str
+
+from pip._internal.exceptions import UnsupportedWheel
+from pip._internal.utils.pkg_resources import DictMetadata
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from email.message import Message
+    from typing import Dict, Tuple
+
+    from pip._vendor.pkg_resources import Distribution
+
+if PY2:
+    from zipfile import BadZipfile as BadZipFile
+else:
+    from zipfile import BadZipFile
+
+
+VERSION_COMPATIBLE = (1, 0)
+
+
+logger = logging.getLogger(__name__)
+
+
+class WheelMetadata(DictMetadata):
+    """Metadata provider that maps metadata decoding exceptions to our
+    internal exception type.
+    """
+    def __init__(self, metadata, wheel_name):
+        # type: (Dict[str, bytes], str) -> None
+        super(WheelMetadata, self).__init__(metadata)
+        self._wheel_name = wheel_name
+
+    def get_metadata(self, name):
+        # type: (str) -> str
+        try:
+            return super(WheelMetadata, self).get_metadata(name)
+        except UnicodeDecodeError as e:
+            # Augment the default error with the origin of the file.
+            raise UnsupportedWheel(
+                "Error decoding metadata for {}: {}".format(
+                    self._wheel_name, e
+                )
+            )
+
+
+def pkg_resources_distribution_for_wheel(wheel_zip, name, location):
+    # type: (ZipFile, str, str) -> Distribution
+    """Get a pkg_resources distribution given a wheel.
+
+    :raises UnsupportedWheel: on any errors
+    """
+    info_dir, _ = parse_wheel(wheel_zip, name)
+
+    metadata_files = [
+        p for p in wheel_zip.namelist() if p.startswith("{}/".format(info_dir))
+    ]
+
+    metadata_text = {}  # type: Dict[str, bytes]
+    for path in metadata_files:
+        # If a flag is set, namelist entries may be unicode in Python 2.
+        # We coerce them to native str type to match the types used in the rest
+        # of the code. This cannot fail because unicode can always be encoded
+        # with UTF-8.
+        full_path = ensure_str(path)
+        _, metadata_name = full_path.split("/", 1)
+
+        try:
+            metadata_text[metadata_name] = read_wheel_metadata_file(
+                wheel_zip, full_path
+            )
+        except UnsupportedWheel as e:
+            raise UnsupportedWheel(
+                "{} has an invalid wheel, {}".format(name, str(e))
+            )
+
+    metadata = WheelMetadata(metadata_text, location)
+
+    return DistInfoDistribution(
+        location=location, metadata=metadata, project_name=name
+    )
+
+
+def parse_wheel(wheel_zip, name):
+    # type: (ZipFile, str) -> Tuple[str, Message]
+    """Extract information from the provided wheel, ensuring it meets basic
+    standards.
+
+    Returns the name of the .dist-info directory and the parsed WHEEL metadata.
+    """
+    try:
+        info_dir = wheel_dist_info_dir(wheel_zip, name)
+        metadata = wheel_metadata(wheel_zip, info_dir)
+        version = wheel_version(metadata)
+    except UnsupportedWheel as e:
+        raise UnsupportedWheel(
+            "{} has an invalid wheel, {}".format(name, str(e))
+        )
+
+    check_compatibility(version, name)
+
+    return info_dir, metadata
+
+
+def wheel_dist_info_dir(source, name):
+    # type: (ZipFile, str) -> str
+    """Returns the name of the contained .dist-info directory.
+
+    Raises AssertionError or UnsupportedWheel if not found, >1 found, or
+    it doesn't match the provided name.
+    """
+    # Zip file path separators must be /
+    subdirs = set(p.split("/", 1)[0] for p in source.namelist())
+
+    info_dirs = [s for s in subdirs if s.endswith('.dist-info')]
+
+    if not info_dirs:
+        raise UnsupportedWheel(".dist-info directory not found")
+
+    if len(info_dirs) > 1:
+        raise UnsupportedWheel(
+            "multiple .dist-info directories found: {}".format(
+                ", ".join(info_dirs)
+            )
+        )
+
+    info_dir = info_dirs[0]
+
+    info_dir_name = canonicalize_name(info_dir)
+    canonical_name = canonicalize_name(name)
+    if not info_dir_name.startswith(canonical_name):
+        raise UnsupportedWheel(
+            ".dist-info directory {!r} does not start with {!r}".format(
+                info_dir, canonical_name
+            )
+        )
+
+    # Zip file paths can be unicode or str depending on the zip entry flags,
+    # so normalize it.
+    return ensure_str(info_dir)
+
+
+def read_wheel_metadata_file(source, path):
+    # type: (ZipFile, str) -> bytes
+    try:
+        return source.read(path)
+        # BadZipFile for general corruption, KeyError for missing entry,
+        # and RuntimeError for password-protected files
+    except (BadZipFile, KeyError, RuntimeError) as e:
+        raise UnsupportedWheel(
+            "could not read {!r} file: {!r}".format(path, e)
+        )
+
+
+def wheel_metadata(source, dist_info_dir):
+    # type: (ZipFile, str) -> Message
+    """Return the WHEEL metadata of an extracted wheel, if possible.
+    Otherwise, raise UnsupportedWheel.
+    """
+    path = "{}/WHEEL".format(dist_info_dir)
+    # Zip file path separators must be /
+    wheel_contents = read_wheel_metadata_file(source, path)
+
+    try:
+        wheel_text = ensure_str(wheel_contents)
+    except UnicodeDecodeError as e:
+        raise UnsupportedWheel("error decoding {!r}: {!r}".format(path, e))
+
+    # FeedParser (used by Parser) does not raise any exceptions. The returned
+    # message may have .defects populated, but for backwards-compatibility we
+    # currently ignore them.
+    return Parser().parsestr(wheel_text)
+
+
+def wheel_version(wheel_data):
+    # type: (Message) -> Tuple[int, ...]
+    """Given WHEEL metadata, return the parsed Wheel-Version.
+    Otherwise, raise UnsupportedWheel.
+    """
+    version_text = wheel_data["Wheel-Version"]
+    if version_text is None:
+        raise UnsupportedWheel("WHEEL is missing Wheel-Version")
+
+    version = version_text.strip()
+
+    try:
+        return tuple(map(int, version.split('.')))
+    except ValueError:
+        raise UnsupportedWheel("invalid Wheel-Version: {!r}".format(version))
+
+
+def check_compatibility(version, name):
+    # type: (Tuple[int, ...], str) -> None
+    """Raises errors or warns if called with an incompatible Wheel-Version.
+
+    pip should refuse to install a Wheel-Version that's a major series
+    ahead of what it's compatible with (e.g 2.0 > 1.1); and warn when
+    installing a version only minor version ahead (e.g 1.2 > 1.1).
+
+    version: a 2-tuple representing a Wheel-Version (Major, Minor)
+    name: name of wheel or package to raise exception about
+
+    :raises UnsupportedWheel: when an incompatible Wheel-Version is given
+    """
+    if version[0] > VERSION_COMPATIBLE[0]:
+        raise UnsupportedWheel(
+            "{}'s Wheel-Version ({}) is not compatible with this version "
+            "of pip".format(name, '.'.join(map(str, version)))
+        )
+    elif version > VERSION_COMPATIBLE:
+        logger.warning(
+            'Installing from a newer Wheel-Version (%s)',
+            '.'.join(map(str, version)),
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/vcs/__init__.py b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/__init__.py
new file mode 100644
index 0000000..2a4eb13
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/__init__.py
@@ -0,0 +1,15 @@
+# Expose a limited set of classes and functions so callers outside of
+# the vcs package don't need to import deeper than `pip._internal.vcs`.
+# (The test directory and imports protected by MYPY_CHECK_RUNNING may
+# still need to import from a vcs sub-package.)
+# Import all vcs modules to register each VCS in the VcsSupport object.
+import pip._internal.vcs.bazaar
+import pip._internal.vcs.git
+import pip._internal.vcs.mercurial
+import pip._internal.vcs.subversion  # noqa: F401
+from pip._internal.vcs.versioncontrol import (  # noqa: F401
+    RemoteNotFoundError,
+    is_url,
+    make_vcs_requirement_url,
+    vcs,
+)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/vcs/bazaar.py b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/bazaar.py
new file mode 100644
index 0000000..94408c5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/bazaar.py
@@ -0,0 +1,119 @@
+# The following comment should be removed at some point in the future.
+# mypy: disallow-untyped-defs=False
+
+from __future__ import absolute_import
+
+import logging
+import os
+
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+
+from pip._internal.utils.misc import display_path, rmtree
+from pip._internal.utils.subprocess import make_command
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.urls import path_to_url
+from pip._internal.vcs.versioncontrol import VersionControl, vcs
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, Tuple
+    from pip._internal.utils.misc import HiddenText
+    from pip._internal.vcs.versioncontrol import AuthInfo, RevOptions
+
+
+logger = logging.getLogger(__name__)
+
+
+class Bazaar(VersionControl):
+    name = 'bzr'
+    dirname = '.bzr'
+    repo_name = 'branch'
+    schemes = (
+        'bzr', 'bzr+http', 'bzr+https', 'bzr+ssh', 'bzr+sftp', 'bzr+ftp',
+        'bzr+lp',
+    )
+
+    def __init__(self, *args, **kwargs):
+        super(Bazaar, self).__init__(*args, **kwargs)
+        # This is only needed for python <2.7.5
+        # Register lp but do not expose as a scheme to support bzr+lp.
+        if getattr(urllib_parse, 'uses_fragment', None):
+            urllib_parse.uses_fragment.extend(['lp'])
+
+    @staticmethod
+    def get_base_rev_args(rev):
+        return ['-r', rev]
+
+    def export(self, location, url):
+        # type: (str, HiddenText) -> None
+        """
+        Export the Bazaar repository at the url to the destination location
+        """
+        # Remove the location to make sure Bazaar can export it correctly
+        if os.path.exists(location):
+            rmtree(location)
+
+        url, rev_options = self.get_url_rev_options(url)
+        self.run_command(
+            make_command('export', location, url, rev_options.to_args())
+        )
+
+    def fetch_new(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        rev_display = rev_options.to_display()
+        logger.info(
+            'Checking out %s%s to %s',
+            url,
+            rev_display,
+            display_path(dest),
+        )
+        cmd_args = (
+            make_command('branch', '-q', rev_options.to_args(), url, dest)
+        )
+        self.run_command(cmd_args)
+
+    def switch(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        self.run_command(make_command('switch', url), cwd=dest)
+
+    def update(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        cmd_args = make_command('pull', '-q', rev_options.to_args())
+        self.run_command(cmd_args, cwd=dest)
+
+    @classmethod
+    def get_url_rev_and_auth(cls, url):
+        # type: (str) -> Tuple[str, Optional[str], AuthInfo]
+        # hotfix the URL scheme after removing bzr+ from bzr+ssh:// readd it
+        url, rev, user_pass = super(Bazaar, cls).get_url_rev_and_auth(url)
+        if url.startswith('ssh://'):
+            url = 'bzr+' + url
+        return url, rev, user_pass
+
+    @classmethod
+    def get_remote_url(cls, location):
+        urls = cls.run_command(['info'], cwd=location)
+        for line in urls.splitlines():
+            line = line.strip()
+            for x in ('checkout of branch: ',
+                      'parent branch: '):
+                if line.startswith(x):
+                    repo = line.split(x)[1]
+                    if cls._is_local_repository(repo):
+                        return path_to_url(repo)
+                    return repo
+        return None
+
+    @classmethod
+    def get_revision(cls, location):
+        revision = cls.run_command(
+            ['revno'], cwd=location,
+        )
+        return revision.splitlines()[-1]
+
+    @classmethod
+    def is_commit_id_equal(cls, dest, name):
+        """Always assume the versions don't match"""
+        return False
+
+
+vcs.register(Bazaar)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/vcs/git.py b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/git.py
new file mode 100644
index 0000000..a9c7fb6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/git.py
@@ -0,0 +1,397 @@
+# The following comment should be removed at some point in the future.
+# mypy: disallow-untyped-defs=False
+
+from __future__ import absolute_import
+
+import logging
+import os.path
+import re
+
+from pip._vendor.packaging.version import parse as parse_version
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+from pip._vendor.six.moves.urllib import request as urllib_request
+
+from pip._internal.exceptions import BadCommand, SubProcessError
+from pip._internal.utils.misc import display_path, hide_url
+from pip._internal.utils.subprocess import make_command
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.vcs.versioncontrol import (
+    RemoteNotFoundError,
+    VersionControl,
+    find_path_to_setup_from_repo_root,
+    vcs,
+)
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, Tuple
+    from pip._internal.utils.misc import HiddenText
+    from pip._internal.vcs.versioncontrol import AuthInfo, RevOptions
+
+
+urlsplit = urllib_parse.urlsplit
+urlunsplit = urllib_parse.urlunsplit
+
+
+logger = logging.getLogger(__name__)
+
+
+HASH_REGEX = re.compile('^[a-fA-F0-9]{40}$')
+
+
+def looks_like_hash(sha):
+    return bool(HASH_REGEX.match(sha))
+
+
+class Git(VersionControl):
+    name = 'git'
+    dirname = '.git'
+    repo_name = 'clone'
+    schemes = (
+        'git', 'git+http', 'git+https', 'git+ssh', 'git+git', 'git+file',
+    )
+    # Prevent the user's environment variables from interfering with pip:
+    # https://github.com/pypa/pip/issues/1130
+    unset_environ = ('GIT_DIR', 'GIT_WORK_TREE')
+    default_arg_rev = 'HEAD'
+
+    @staticmethod
+    def get_base_rev_args(rev):
+        return [rev]
+
+    def is_immutable_rev_checkout(self, url, dest):
+        # type: (str, str) -> bool
+        _, rev_options = self.get_url_rev_options(hide_url(url))
+        if not rev_options.rev:
+            return False
+        if not self.is_commit_id_equal(dest, rev_options.rev):
+            # the current commit is different from rev,
+            # which means rev was something else than a commit hash
+            return False
+        # return False in the rare case rev is both a commit hash
+        # and a tag or a branch; we don't want to cache in that case
+        # because that branch/tag could point to something else in the future
+        is_tag_or_branch = bool(
+            self.get_revision_sha(dest, rev_options.rev)[0]
+        )
+        return not is_tag_or_branch
+
+    def get_git_version(self):
+        VERSION_PFX = 'git version '
+        version = self.run_command(['version'])
+        if version.startswith(VERSION_PFX):
+            version = version[len(VERSION_PFX):].split()[0]
+        else:
+            version = ''
+        # get first 3 positions of the git version because
+        # on windows it is x.y.z.windows.t, and this parses as
+        # LegacyVersion which always smaller than a Version.
+        version = '.'.join(version.split('.')[:3])
+        return parse_version(version)
+
+    @classmethod
+    def get_current_branch(cls, location):
+        """
+        Return the current branch, or None if HEAD isn't at a branch
+        (e.g. detached HEAD).
+        """
+        # git-symbolic-ref exits with empty stdout if "HEAD" is a detached
+        # HEAD rather than a symbolic ref.  In addition, the -q causes the
+        # command to exit with status code 1 instead of 128 in this case
+        # and to suppress the message to stderr.
+        args = ['symbolic-ref', '-q', 'HEAD']
+        output = cls.run_command(
+            args, extra_ok_returncodes=(1, ), cwd=location,
+        )
+        ref = output.strip()
+
+        if ref.startswith('refs/heads/'):
+            return ref[len('refs/heads/'):]
+
+        return None
+
+    def export(self, location, url):
+        # type: (str, HiddenText) -> None
+        """Export the Git repository at the url to the destination location"""
+        if not location.endswith('/'):
+            location = location + '/'
+
+        with TempDirectory(kind="export") as temp_dir:
+            self.unpack(temp_dir.path, url=url)
+            self.run_command(
+                ['checkout-index', '-a', '-f', '--prefix', location],
+                cwd=temp_dir.path
+            )
+
+    @classmethod
+    def get_revision_sha(cls, dest, rev):
+        """
+        Return (sha_or_none, is_branch), where sha_or_none is a commit hash
+        if the revision names a remote branch or tag, otherwise None.
+
+        Args:
+          dest: the repository directory.
+          rev: the revision name.
+        """
+        # Pass rev to pre-filter the list.
+
+        output = ''
+        try:
+            output = cls.run_command(['show-ref', rev], cwd=dest)
+        except SubProcessError:
+            pass
+
+        refs = {}
+        for line in output.strip().splitlines():
+            try:
+                sha, ref = line.split()
+            except ValueError:
+                # Include the offending line to simplify troubleshooting if
+                # this error ever occurs.
+                raise ValueError('unexpected show-ref line: {!r}'.format(line))
+
+            refs[ref] = sha
+
+        branch_ref = 'refs/remotes/origin/{}'.format(rev)
+        tag_ref = 'refs/tags/{}'.format(rev)
+
+        sha = refs.get(branch_ref)
+        if sha is not None:
+            return (sha, True)
+
+        sha = refs.get(tag_ref)
+
+        return (sha, False)
+
+    @classmethod
+    def resolve_revision(cls, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> RevOptions
+        """
+        Resolve a revision to a new RevOptions object with the SHA1 of the
+        branch, tag, or ref if found.
+
+        Args:
+          rev_options: a RevOptions object.
+        """
+        rev = rev_options.arg_rev
+        # The arg_rev property's implementation for Git ensures that the
+        # rev return value is always non-None.
+        assert rev is not None
+
+        sha, is_branch = cls.get_revision_sha(dest, rev)
+
+        if sha is not None:
+            rev_options = rev_options.make_new(sha)
+            rev_options.branch_name = rev if is_branch else None
+
+            return rev_options
+
+        # Do not show a warning for the common case of something that has
+        # the form of a Git commit hash.
+        if not looks_like_hash(rev):
+            logger.warning(
+                "Did not find branch or tag '%s', assuming revision or ref.",
+                rev,
+            )
+
+        if not rev.startswith('refs/'):
+            return rev_options
+
+        # If it looks like a ref, we have to fetch it explicitly.
+        cls.run_command(
+            make_command('fetch', '-q', url, rev_options.to_args()),
+            cwd=dest,
+        )
+        # Change the revision to the SHA of the ref we fetched
+        sha = cls.get_revision(dest, rev='FETCH_HEAD')
+        rev_options = rev_options.make_new(sha)
+
+        return rev_options
+
+    @classmethod
+    def is_commit_id_equal(cls, dest, name):
+        """
+        Return whether the current commit hash equals the given name.
+
+        Args:
+          dest: the repository directory.
+          name: a string name.
+        """
+        if not name:
+            # Then avoid an unnecessary subprocess call.
+            return False
+
+        return cls.get_revision(dest) == name
+
+    def fetch_new(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        rev_display = rev_options.to_display()
+        logger.info('Cloning %s%s to %s', url, rev_display, display_path(dest))
+        self.run_command(make_command('clone', '-q', url, dest))
+
+        if rev_options.rev:
+            # Then a specific revision was requested.
+            rev_options = self.resolve_revision(dest, url, rev_options)
+            branch_name = getattr(rev_options, 'branch_name', None)
+            if branch_name is None:
+                # Only do a checkout if the current commit id doesn't match
+                # the requested revision.
+                if not self.is_commit_id_equal(dest, rev_options.rev):
+                    cmd_args = make_command(
+                        'checkout', '-q', rev_options.to_args(),
+                    )
+                    self.run_command(cmd_args, cwd=dest)
+            elif self.get_current_branch(dest) != branch_name:
+                # Then a specific branch was requested, and that branch
+                # is not yet checked out.
+                track_branch = 'origin/{}'.format(branch_name)
+                cmd_args = [
+                    'checkout', '-b', branch_name, '--track', track_branch,
+                ]
+                self.run_command(cmd_args, cwd=dest)
+
+        #: repo may contain submodules
+        self.update_submodules(dest)
+
+    def switch(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        self.run_command(
+            make_command('config', 'remote.origin.url', url),
+            cwd=dest,
+        )
+        cmd_args = make_command('checkout', '-q', rev_options.to_args())
+        self.run_command(cmd_args, cwd=dest)
+
+        self.update_submodules(dest)
+
+    def update(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        # First fetch changes from the default remote
+        if self.get_git_version() >= parse_version('1.9.0'):
+            # fetch tags in addition to everything else
+            self.run_command(['fetch', '-q', '--tags'], cwd=dest)
+        else:
+            self.run_command(['fetch', '-q'], cwd=dest)
+        # Then reset to wanted revision (maybe even origin/master)
+        rev_options = self.resolve_revision(dest, url, rev_options)
+        cmd_args = make_command('reset', '--hard', '-q', rev_options.to_args())
+        self.run_command(cmd_args, cwd=dest)
+        #: update submodules
+        self.update_submodules(dest)
+
+    @classmethod
+    def get_remote_url(cls, location):
+        """
+        Return URL of the first remote encountered.
+
+        Raises RemoteNotFoundError if the repository does not have a remote
+        url configured.
+        """
+        # We need to pass 1 for extra_ok_returncodes since the command
+        # exits with return code 1 if there are no matching lines.
+        stdout = cls.run_command(
+            ['config', '--get-regexp', r'remote\..*\.url'],
+            extra_ok_returncodes=(1, ), cwd=location,
+        )
+        remotes = stdout.splitlines()
+        try:
+            found_remote = remotes[0]
+        except IndexError:
+            raise RemoteNotFoundError
+
+        for remote in remotes:
+            if remote.startswith('remote.origin.url '):
+                found_remote = remote
+                break
+        url = found_remote.split(' ')[1]
+        return url.strip()
+
+    @classmethod
+    def get_revision(cls, location, rev=None):
+        if rev is None:
+            rev = 'HEAD'
+        current_rev = cls.run_command(
+            ['rev-parse', rev], cwd=location,
+        )
+        return current_rev.strip()
+
+    @classmethod
+    def get_subdirectory(cls, location):
+        """
+        Return the path to setup.py, relative to the repo root.
+        Return None if setup.py is in the repo root.
+        """
+        # find the repo root
+        git_dir = cls.run_command(
+            ['rev-parse', '--git-dir'],
+            cwd=location).strip()
+        if not os.path.isabs(git_dir):
+            git_dir = os.path.join(location, git_dir)
+        repo_root = os.path.abspath(os.path.join(git_dir, '..'))
+        return find_path_to_setup_from_repo_root(location, repo_root)
+
+    @classmethod
+    def get_url_rev_and_auth(cls, url):
+        # type: (str) -> Tuple[str, Optional[str], AuthInfo]
+        """
+        Prefixes stub URLs like 'user@hostname:user/repo.git' with 'ssh://'.
+        That's required because although they use SSH they sometimes don't
+        work with a ssh:// scheme (e.g. GitHub). But we need a scheme for
+        parsing. Hence we remove it again afterwards and return it as a stub.
+        """
+        # Works around an apparent Git bug
+        # (see https://article.gmane.org/gmane.comp.version-control.git/146500)
+        scheme, netloc, path, query, fragment = urlsplit(url)
+        if scheme.endswith('file'):
+            initial_slashes = path[:-len(path.lstrip('/'))]
+            newpath = (
+                initial_slashes +
+                urllib_request.url2pathname(path)
+                .replace('\\', '/').lstrip('/')
+            )
+            url = urlunsplit((scheme, netloc, newpath, query, fragment))
+            after_plus = scheme.find('+') + 1
+            url = scheme[:after_plus] + urlunsplit(
+                (scheme[after_plus:], netloc, newpath, query, fragment),
+            )
+
+        if '://' not in url:
+            assert 'file:' not in url
+            url = url.replace('git+', 'git+ssh://')
+            url, rev, user_pass = super(Git, cls).get_url_rev_and_auth(url)
+            url = url.replace('ssh://', '')
+        else:
+            url, rev, user_pass = super(Git, cls).get_url_rev_and_auth(url)
+
+        return url, rev, user_pass
+
+    @classmethod
+    def update_submodules(cls, location):
+        if not os.path.exists(os.path.join(location, '.gitmodules')):
+            return
+        cls.run_command(
+            ['submodule', 'update', '--init', '--recursive', '-q'],
+            cwd=location,
+        )
+
+    @classmethod
+    def get_repository_root(cls, location):
+        loc = super(Git, cls).get_repository_root(location)
+        if loc:
+            return loc
+        try:
+            r = cls.run_command(
+                ['rev-parse', '--show-toplevel'],
+                cwd=location,
+                log_failed_cmd=False,
+            )
+        except BadCommand:
+            logger.debug("could not determine if %s is under git control "
+                         "because git is not available", location)
+            return None
+        except SubProcessError:
+            return None
+        return os.path.normpath(r.rstrip('\r\n'))
+
+
+vcs.register(Git)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/vcs/mercurial.py b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/mercurial.py
new file mode 100644
index 0000000..69763fe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/mercurial.py
@@ -0,0 +1,158 @@
+# The following comment should be removed at some point in the future.
+# mypy: disallow-untyped-defs=False
+
+from __future__ import absolute_import
+
+import logging
+import os
+
+from pip._vendor.six.moves import configparser
+
+from pip._internal.exceptions import BadCommand, SubProcessError
+from pip._internal.utils.misc import display_path
+from pip._internal.utils.subprocess import make_command
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.urls import path_to_url
+from pip._internal.vcs.versioncontrol import (
+    VersionControl,
+    find_path_to_setup_from_repo_root,
+    vcs,
+)
+
+if MYPY_CHECK_RUNNING:
+    from pip._internal.utils.misc import HiddenText
+    from pip._internal.vcs.versioncontrol import RevOptions
+
+
+logger = logging.getLogger(__name__)
+
+
+class Mercurial(VersionControl):
+    name = 'hg'
+    dirname = '.hg'
+    repo_name = 'clone'
+    schemes = (
+        'hg', 'hg+file', 'hg+http', 'hg+https', 'hg+ssh', 'hg+static-http',
+    )
+
+    @staticmethod
+    def get_base_rev_args(rev):
+        return [rev]
+
+    def export(self, location, url):
+        # type: (str, HiddenText) -> None
+        """Export the Hg repository at the url to the destination location"""
+        with TempDirectory(kind="export") as temp_dir:
+            self.unpack(temp_dir.path, url=url)
+
+            self.run_command(
+                ['archive', location], cwd=temp_dir.path
+            )
+
+    def fetch_new(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        rev_display = rev_options.to_display()
+        logger.info(
+            'Cloning hg %s%s to %s',
+            url,
+            rev_display,
+            display_path(dest),
+        )
+        self.run_command(make_command('clone', '--noupdate', '-q', url, dest))
+        self.run_command(
+            make_command('update', '-q', rev_options.to_args()),
+            cwd=dest,
+        )
+
+    def switch(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        repo_config = os.path.join(dest, self.dirname, 'hgrc')
+        config = configparser.RawConfigParser()
+        try:
+            config.read(repo_config)
+            config.set('paths', 'default', url.secret)
+            with open(repo_config, 'w') as config_file:
+                config.write(config_file)
+        except (OSError, configparser.NoSectionError) as exc:
+            logger.warning(
+                'Could not switch Mercurial repository to %s: %s', url, exc,
+            )
+        else:
+            cmd_args = make_command('update', '-q', rev_options.to_args())
+            self.run_command(cmd_args, cwd=dest)
+
+    def update(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        self.run_command(['pull', '-q'], cwd=dest)
+        cmd_args = make_command('update', '-q', rev_options.to_args())
+        self.run_command(cmd_args, cwd=dest)
+
+    @classmethod
+    def get_remote_url(cls, location):
+        url = cls.run_command(
+            ['showconfig', 'paths.default'],
+            cwd=location).strip()
+        if cls._is_local_repository(url):
+            url = path_to_url(url)
+        return url.strip()
+
+    @classmethod
+    def get_revision(cls, location):
+        """
+        Return the repository-local changeset revision number, as an integer.
+        """
+        current_revision = cls.run_command(
+            ['parents', '--template={rev}'], cwd=location).strip()
+        return current_revision
+
+    @classmethod
+    def get_requirement_revision(cls, location):
+        """
+        Return the changeset identification hash, as a 40-character
+        hexadecimal string
+        """
+        current_rev_hash = cls.run_command(
+            ['parents', '--template={node}'],
+            cwd=location).strip()
+        return current_rev_hash
+
+    @classmethod
+    def is_commit_id_equal(cls, dest, name):
+        """Always assume the versions don't match"""
+        return False
+
+    @classmethod
+    def get_subdirectory(cls, location):
+        """
+        Return the path to setup.py, relative to the repo root.
+        Return None if setup.py is in the repo root.
+        """
+        # find the repo root
+        repo_root = cls.run_command(
+            ['root'], cwd=location).strip()
+        if not os.path.isabs(repo_root):
+            repo_root = os.path.abspath(os.path.join(location, repo_root))
+        return find_path_to_setup_from_repo_root(location, repo_root)
+
+    @classmethod
+    def get_repository_root(cls, location):
+        loc = super(Mercurial, cls).get_repository_root(location)
+        if loc:
+            return loc
+        try:
+            r = cls.run_command(
+                ['root'],
+                cwd=location,
+                log_failed_cmd=False,
+            )
+        except BadCommand:
+            logger.debug("could not determine if %s is under hg control "
+                         "because hg is not available", location)
+            return None
+        except SubProcessError:
+            return None
+        return os.path.normpath(r.rstrip('\r\n'))
+
+
+vcs.register(Mercurial)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/vcs/subversion.py b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/subversion.py
new file mode 100644
index 0000000..ab13497
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/subversion.py
@@ -0,0 +1,336 @@
+# The following comment should be removed at some point in the future.
+# mypy: disallow-untyped-defs=False
+
+from __future__ import absolute_import
+
+import logging
+import os
+import re
+
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import (
+    display_path,
+    is_console_interactive,
+    rmtree,
+    split_auth_from_netloc,
+)
+from pip._internal.utils.subprocess import make_command
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.vcs.versioncontrol import VersionControl, vcs
+
+_svn_xml_url_re = re.compile('url="([^"]+)"')
+_svn_rev_re = re.compile(r'committed-rev="(\d+)"')
+_svn_info_xml_rev_re = re.compile(r'\s*revision="(\d+)"')
+_svn_info_xml_url_re = re.compile(r'<url>(.*)</url>')
+
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, Tuple
+    from pip._internal.utils.subprocess import CommandArgs
+    from pip._internal.utils.misc import HiddenText
+    from pip._internal.vcs.versioncontrol import AuthInfo, RevOptions
+
+
+logger = logging.getLogger(__name__)
+
+
+class Subversion(VersionControl):
+    name = 'svn'
+    dirname = '.svn'
+    repo_name = 'checkout'
+    schemes = ('svn', 'svn+ssh', 'svn+http', 'svn+https', 'svn+svn')
+
+    @classmethod
+    def should_add_vcs_url_prefix(cls, remote_url):
+        return True
+
+    @staticmethod
+    def get_base_rev_args(rev):
+        return ['-r', rev]
+
+    @classmethod
+    def get_revision(cls, location):
+        """
+        Return the maximum revision for all files under a given location
+        """
+        # Note: taken from setuptools.command.egg_info
+        revision = 0
+
+        for base, dirs, _ in os.walk(location):
+            if cls.dirname not in dirs:
+                dirs[:] = []
+                continue    # no sense walking uncontrolled subdirs
+            dirs.remove(cls.dirname)
+            entries_fn = os.path.join(base, cls.dirname, 'entries')
+            if not os.path.exists(entries_fn):
+                # FIXME: should we warn?
+                continue
+
+            dirurl, localrev = cls._get_svn_url_rev(base)
+
+            if base == location:
+                base = dirurl + '/'   # save the root url
+            elif not dirurl or not dirurl.startswith(base):
+                dirs[:] = []
+                continue    # not part of the same svn tree, skip it
+            revision = max(revision, localrev)
+        return revision
+
+    @classmethod
+    def get_netloc_and_auth(cls, netloc, scheme):
+        """
+        This override allows the auth information to be passed to svn via the
+        --username and --password options instead of via the URL.
+        """
+        if scheme == 'ssh':
+            # The --username and --password options can't be used for
+            # svn+ssh URLs, so keep the auth information in the URL.
+            return super(Subversion, cls).get_netloc_and_auth(netloc, scheme)
+
+        return split_auth_from_netloc(netloc)
+
+    @classmethod
+    def get_url_rev_and_auth(cls, url):
+        # type: (str) -> Tuple[str, Optional[str], AuthInfo]
+        # hotfix the URL scheme after removing svn+ from svn+ssh:// readd it
+        url, rev, user_pass = super(Subversion, cls).get_url_rev_and_auth(url)
+        if url.startswith('ssh://'):
+            url = 'svn+' + url
+        return url, rev, user_pass
+
+    @staticmethod
+    def make_rev_args(username, password):
+        # type: (Optional[str], Optional[HiddenText]) -> CommandArgs
+        extra_args = []  # type: CommandArgs
+        if username:
+            extra_args += ['--username', username]
+        if password:
+            extra_args += ['--password', password]
+
+        return extra_args
+
+    @classmethod
+    def get_remote_url(cls, location):
+        # In cases where the source is in a subdirectory, not alongside
+        # setup.py we have to look up in the location until we find a real
+        # setup.py
+        orig_location = location
+        while not os.path.exists(os.path.join(location, 'setup.py')):
+            last_location = location
+            location = os.path.dirname(location)
+            if location == last_location:
+                # We've traversed up to the root of the filesystem without
+                # finding setup.py
+                logger.warning(
+                    "Could not find setup.py for directory %s (tried all "
+                    "parent directories)",
+                    orig_location,
+                )
+                return None
+
+        return cls._get_svn_url_rev(location)[0]
+
+    @classmethod
+    def _get_svn_url_rev(cls, location):
+        from pip._internal.exceptions import SubProcessError
+
+        entries_path = os.path.join(location, cls.dirname, 'entries')
+        if os.path.exists(entries_path):
+            with open(entries_path) as f:
+                data = f.read()
+        else:  # subversion >= 1.7 does not have the 'entries' file
+            data = ''
+
+        if (data.startswith('8') or
+                data.startswith('9') or
+                data.startswith('10')):
+            data = list(map(str.splitlines, data.split('\n\x0c\n')))
+            del data[0][0]  # get rid of the '8'
+            url = data[0][3]
+            revs = [int(d[9]) for d in data if len(d) > 9 and d[9]] + [0]
+        elif data.startswith('<?xml'):
+            match = _svn_xml_url_re.search(data)
+            if not match:
+                raise ValueError(
+                    'Badly formatted data: {data!r}'.format(**locals()))
+            url = match.group(1)    # get repository URL
+            revs = [int(m.group(1)) for m in _svn_rev_re.finditer(data)] + [0]
+        else:
+            try:
+                # subversion >= 1.7
+                # Note that using get_remote_call_options is not necessary here
+                # because `svn info` is being run against a local directory.
+                # We don't need to worry about making sure interactive mode
+                # is being used to prompt for passwords, because passwords
+                # are only potentially needed for remote server requests.
+                xml = cls.run_command(
+                    ['info', '--xml', location],
+                )
+                url = _svn_info_xml_url_re.search(xml).group(1)
+                revs = [
+                    int(m.group(1)) for m in _svn_info_xml_rev_re.finditer(xml)
+                ]
+            except SubProcessError:
+                url, revs = None, []
+
+        if revs:
+            rev = max(revs)
+        else:
+            rev = 0
+
+        return url, rev
+
+    @classmethod
+    def is_commit_id_equal(cls, dest, name):
+        """Always assume the versions don't match"""
+        return False
+
+    def __init__(self, use_interactive=None):
+        # type: (bool) -> None
+        if use_interactive is None:
+            use_interactive = is_console_interactive()
+        self.use_interactive = use_interactive
+
+        # This member is used to cache the fetched version of the current
+        # ``svn`` client.
+        # Special value definitions:
+        #   None: Not evaluated yet.
+        #   Empty tuple: Could not parse version.
+        self._vcs_version = None  # type: Optional[Tuple[int, ...]]
+
+        super(Subversion, self).__init__()
+
+    def call_vcs_version(self):
+        # type: () -> Tuple[int, ...]
+        """Query the version of the currently installed Subversion client.
+
+        :return: A tuple containing the parts of the version information or
+            ``()`` if the version returned from ``svn`` could not be parsed.
+        :raises: BadCommand: If ``svn`` is not installed.
+        """
+        # Example versions:
+        #   svn, version 1.10.3 (r1842928)
+        #      compiled Feb 25 2019, 14:20:39 on x86_64-apple-darwin17.0.0
+        #   svn, version 1.7.14 (r1542130)
+        #      compiled Mar 28 2018, 08:49:13 on x86_64-pc-linux-gnu
+        #   svn, version 1.12.0-SlikSvn (SlikSvn/1.12.0)
+        #      compiled May 28 2019, 13:44:56 on x86_64-microsoft-windows6.2
+        version_prefix = 'svn, version '
+        version = self.run_command(['--version'])
+
+        if not version.startswith(version_prefix):
+            return ()
+
+        version = version[len(version_prefix):].split()[0]
+        version_list = version.partition('-')[0].split('.')
+        try:
+            parsed_version = tuple(map(int, version_list))
+        except ValueError:
+            return ()
+
+        return parsed_version
+
+    def get_vcs_version(self):
+        # type: () -> Tuple[int, ...]
+        """Return the version of the currently installed Subversion client.
+
+        If the version of the Subversion client has already been queried,
+        a cached value will be used.
+
+        :return: A tuple containing the parts of the version information or
+            ``()`` if the version returned from ``svn`` could not be parsed.
+        :raises: BadCommand: If ``svn`` is not installed.
+        """
+        if self._vcs_version is not None:
+            # Use cached version, if available.
+            # If parsing the version failed previously (empty tuple),
+            # do not attempt to parse it again.
+            return self._vcs_version
+
+        vcs_version = self.call_vcs_version()
+        self._vcs_version = vcs_version
+        return vcs_version
+
+    def get_remote_call_options(self):
+        # type: () -> CommandArgs
+        """Return options to be used on calls to Subversion that contact the server.
+
+        These options are applicable for the following ``svn`` subcommands used
+        in this class.
+
+            - checkout
+            - export
+            - switch
+            - update
+
+        :return: A list of command line arguments to pass to ``svn``.
+        """
+        if not self.use_interactive:
+            # --non-interactive switch is available since Subversion 0.14.4.
+            # Subversion < 1.8 runs in interactive mode by default.
+            return ['--non-interactive']
+
+        svn_version = self.get_vcs_version()
+        # By default, Subversion >= 1.8 runs in non-interactive mode if
+        # stdin is not a TTY. Since that is how pip invokes SVN, in
+        # call_subprocess(), pip must pass --force-interactive to ensure
+        # the user can be prompted for a password, if required.
+        #   SVN added the --force-interactive option in SVN 1.8. Since
+        # e.g. RHEL/CentOS 7, which is supported until 2024, ships with
+        # SVN 1.7, pip should continue to support SVN 1.7. Therefore, pip
+        # can't safely add the option if the SVN version is < 1.8 (or unknown).
+        if svn_version >= (1, 8):
+            return ['--force-interactive']
+
+        return []
+
+    def export(self, location, url):
+        # type: (str, HiddenText) -> None
+        """Export the svn repository at the url to the destination location"""
+        url, rev_options = self.get_url_rev_options(url)
+
+        logger.info('Exporting svn repository %s to %s', url, location)
+        with indent_log():
+            if os.path.exists(location):
+                # Subversion doesn't like to check out over an existing
+                # directory --force fixes this, but was only added in svn 1.5
+                rmtree(location)
+            cmd_args = make_command(
+                'export', self.get_remote_call_options(),
+                rev_options.to_args(), url, location,
+            )
+            self.run_command(cmd_args)
+
+    def fetch_new(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        rev_display = rev_options.to_display()
+        logger.info(
+            'Checking out %s%s to %s',
+            url,
+            rev_display,
+            display_path(dest),
+        )
+        cmd_args = make_command(
+            'checkout', '-q', self.get_remote_call_options(),
+            rev_options.to_args(), url, dest,
+        )
+        self.run_command(cmd_args)
+
+    def switch(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        cmd_args = make_command(
+            'switch', self.get_remote_call_options(), rev_options.to_args(),
+            url, dest,
+        )
+        self.run_command(cmd_args)
+
+    def update(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        cmd_args = make_command(
+            'update', self.get_remote_call_options(), rev_options.to_args(),
+            dest,
+        )
+        self.run_command(cmd_args)
+
+
+vcs.register(Subversion)
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/vcs/versioncontrol.py b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/versioncontrol.py
new file mode 100644
index 0000000..96f830f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/vcs/versioncontrol.py
@@ -0,0 +1,811 @@
+"""Handles all VCS (version control) support"""
+
+from __future__ import absolute_import
+
+import errno
+import logging
+import os
+import shutil
+import subprocess
+import sys
+
+from pip._vendor import pkg_resources
+from pip._vendor.six.moves.urllib import parse as urllib_parse
+
+from pip._internal.exceptions import (
+    BadCommand,
+    InstallationError,
+    SubProcessError,
+)
+from pip._internal.utils.compat import console_to_str, samefile
+from pip._internal.utils.logging import subprocess_logger
+from pip._internal.utils.misc import (
+    ask_path_exists,
+    backup_dir,
+    display_path,
+    hide_url,
+    hide_value,
+    rmtree,
+)
+from pip._internal.utils.subprocess import (
+    format_command_args,
+    make_command,
+    make_subprocess_output_error,
+    reveal_command_args,
+)
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.urls import get_url_scheme
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Dict, Iterable, Iterator, List, Optional, Text, Tuple,
+        Type, Union, Mapping, Any
+    )
+    from pip._internal.utils.misc import HiddenText
+    from pip._internal.utils.subprocess import CommandArgs
+
+    AuthInfo = Tuple[Optional[str], Optional[str]]
+
+
+__all__ = ['vcs']
+
+
+logger = logging.getLogger(__name__)
+
+
+def is_url(name):
+    # type: (Union[str, Text]) -> bool
+    """
+    Return true if the name looks like a URL.
+    """
+    scheme = get_url_scheme(name)
+    if scheme is None:
+        return False
+    return scheme in ['http', 'https', 'file', 'ftp'] + vcs.all_schemes
+
+
+def make_vcs_requirement_url(repo_url, rev, project_name, subdir=None):
+    # type: (str, str, str, Optional[str]) -> str
+    """
+    Return the URL for a VCS requirement.
+
+    Args:
+      repo_url: the remote VCS url, with any needed VCS prefix (e.g. "git+").
+      project_name: the (unescaped) project name.
+    """
+    egg_project_name = pkg_resources.to_filename(project_name)
+    req = '{}@{}#egg={}'.format(repo_url, rev, egg_project_name)
+    if subdir:
+        req += '&subdirectory={}'.format(subdir)
+
+    return req
+
+
+def call_subprocess(
+    cmd,  # type: Union[List[str], CommandArgs]
+    cwd=None,  # type: Optional[str]
+    extra_environ=None,  # type: Optional[Mapping[str, Any]]
+    extra_ok_returncodes=None,  # type: Optional[Iterable[int]]
+    log_failed_cmd=True  # type: Optional[bool]
+):
+    # type: (...) -> Text
+    """
+    Args:
+      extra_ok_returncodes: an iterable of integer return codes that are
+        acceptable, in addition to 0. Defaults to None, which means [].
+      log_failed_cmd: if false, failed commands are not logged,
+        only raised.
+    """
+    if extra_ok_returncodes is None:
+        extra_ok_returncodes = []
+
+    # log the subprocess output at DEBUG level.
+    log_subprocess = subprocess_logger.debug
+
+    env = os.environ.copy()
+    if extra_environ:
+        env.update(extra_environ)
+
+    # Whether the subprocess will be visible in the console.
+    showing_subprocess = True
+
+    command_desc = format_command_args(cmd)
+    try:
+        proc = subprocess.Popen(
+            # Convert HiddenText objects to the underlying str.
+            reveal_command_args(cmd),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=cwd
+        )
+        if proc.stdin:
+            proc.stdin.close()
+    except Exception as exc:
+        if log_failed_cmd:
+            subprocess_logger.critical(
+                "Error %s while executing command %s", exc, command_desc,
+            )
+        raise
+    all_output = []
+    while True:
+        # The "line" value is a unicode string in Python 2.
+        line = None
+        if proc.stdout:
+            line = console_to_str(proc.stdout.readline())
+        if not line:
+            break
+        line = line.rstrip()
+        all_output.append(line + '\n')
+
+        # Show the line immediately.
+        log_subprocess(line)
+    try:
+        proc.wait()
+    finally:
+        if proc.stdout:
+            proc.stdout.close()
+
+    proc_had_error = (
+        proc.returncode and proc.returncode not in extra_ok_returncodes
+    )
+    if proc_had_error:
+        if not showing_subprocess and log_failed_cmd:
+            # Then the subprocess streams haven't been logged to the
+            # console yet.
+            msg = make_subprocess_output_error(
+                cmd_args=cmd,
+                cwd=cwd,
+                lines=all_output,
+                exit_status=proc.returncode,
+            )
+            subprocess_logger.error(msg)
+        exc_msg = (
+            'Command errored out with exit status {}: {} '
+            'Check the logs for full command output.'
+        ).format(proc.returncode, command_desc)
+        raise SubProcessError(exc_msg)
+    return ''.join(all_output)
+
+
+def find_path_to_setup_from_repo_root(location, repo_root):
+    # type: (str, str) -> Optional[str]
+    """
+    Find the path to `setup.py` by searching up the filesystem from `location`.
+    Return the path to `setup.py` relative to `repo_root`.
+    Return None if `setup.py` is in `repo_root` or cannot be found.
+    """
+    # find setup.py
+    orig_location = location
+    while not os.path.exists(os.path.join(location, 'setup.py')):
+        last_location = location
+        location = os.path.dirname(location)
+        if location == last_location:
+            # We've traversed up to the root of the filesystem without
+            # finding setup.py
+            logger.warning(
+                "Could not find setup.py for directory %s (tried all "
+                "parent directories)",
+                orig_location,
+            )
+            return None
+
+    if samefile(repo_root, location):
+        return None
+
+    return os.path.relpath(location, repo_root)
+
+
+class RemoteNotFoundError(Exception):
+    pass
+
+
+class RevOptions(object):
+
+    """
+    Encapsulates a VCS-specific revision to install, along with any VCS
+    install options.
+
+    Instances of this class should be treated as if immutable.
+    """
+
+    def __init__(
+        self,
+        vc_class,  # type: Type[VersionControl]
+        rev=None,  # type: Optional[str]
+        extra_args=None,  # type: Optional[CommandArgs]
+    ):
+        # type: (...) -> None
+        """
+        Args:
+          vc_class: a VersionControl subclass.
+          rev: the name of the revision to install.
+          extra_args: a list of extra options.
+        """
+        if extra_args is None:
+            extra_args = []
+
+        self.extra_args = extra_args
+        self.rev = rev
+        self.vc_class = vc_class
+        self.branch_name = None  # type: Optional[str]
+
+    def __repr__(self):
+        # type: () -> str
+        return '<RevOptions {}: rev={!r}>'.format(self.vc_class.name, self.rev)
+
+    @property
+    def arg_rev(self):
+        # type: () -> Optional[str]
+        if self.rev is None:
+            return self.vc_class.default_arg_rev
+
+        return self.rev
+
+    def to_args(self):
+        # type: () -> CommandArgs
+        """
+        Return the VCS-specific command arguments.
+        """
+        args = []  # type: CommandArgs
+        rev = self.arg_rev
+        if rev is not None:
+            args += self.vc_class.get_base_rev_args(rev)
+        args += self.extra_args
+
+        return args
+
+    def to_display(self):
+        # type: () -> str
+        if not self.rev:
+            return ''
+
+        return ' (to revision {})'.format(self.rev)
+
+    def make_new(self, rev):
+        # type: (str) -> RevOptions
+        """
+        Make a copy of the current instance, but with a new rev.
+
+        Args:
+          rev: the name of the revision for the new object.
+        """
+        return self.vc_class.make_rev_options(rev, extra_args=self.extra_args)
+
+
+class VcsSupport(object):
+    _registry = {}  # type: Dict[str, VersionControl]
+    schemes = ['ssh', 'git', 'hg', 'bzr', 'sftp', 'svn']
+
+    def __init__(self):
+        # type: () -> None
+        # Register more schemes with urlparse for various version control
+        # systems
+        urllib_parse.uses_netloc.extend(self.schemes)
+        # Python >= 2.7.4, 3.3 doesn't have uses_fragment
+        if getattr(urllib_parse, 'uses_fragment', None):
+            urllib_parse.uses_fragment.extend(self.schemes)
+        super(VcsSupport, self).__init__()
+
+    def __iter__(self):
+        # type: () -> Iterator[str]
+        return self._registry.__iter__()
+
+    @property
+    def backends(self):
+        # type: () -> List[VersionControl]
+        return list(self._registry.values())
+
+    @property
+    def dirnames(self):
+        # type: () -> List[str]
+        return [backend.dirname for backend in self.backends]
+
+    @property
+    def all_schemes(self):
+        # type: () -> List[str]
+        schemes = []  # type: List[str]
+        for backend in self.backends:
+            schemes.extend(backend.schemes)
+        return schemes
+
+    def register(self, cls):
+        # type: (Type[VersionControl]) -> None
+        if not hasattr(cls, 'name'):
+            logger.warning('Cannot register VCS %s', cls.__name__)
+            return
+        if cls.name not in self._registry:
+            self._registry[cls.name] = cls()
+            logger.debug('Registered VCS backend: %s', cls.name)
+
+    def unregister(self, name):
+        # type: (str) -> None
+        if name in self._registry:
+            del self._registry[name]
+
+    def get_backend_for_dir(self, location):
+        # type: (str) -> Optional[VersionControl]
+        """
+        Return a VersionControl object if a repository of that type is found
+        at the given directory.
+        """
+        vcs_backends = {}
+        for vcs_backend in self._registry.values():
+            repo_path = vcs_backend.get_repository_root(location)
+            if not repo_path:
+                continue
+            logger.debug('Determine that %s uses VCS: %s',
+                         location, vcs_backend.name)
+            vcs_backends[repo_path] = vcs_backend
+
+        if not vcs_backends:
+            return None
+
+        # Choose the VCS in the inner-most directory. Since all repository
+        # roots found here would be either `location` or one of its
+        # parents, the longest path should have the most path components,
+        # i.e. the backend representing the inner-most repository.
+        inner_most_repo_path = max(vcs_backends, key=len)
+        return vcs_backends[inner_most_repo_path]
+
+    def get_backend_for_scheme(self, scheme):
+        # type: (str) -> Optional[VersionControl]
+        """
+        Return a VersionControl object or None.
+        """
+        for vcs_backend in self._registry.values():
+            if scheme in vcs_backend.schemes:
+                return vcs_backend
+        return None
+
+    def get_backend(self, name):
+        # type: (str) -> Optional[VersionControl]
+        """
+        Return a VersionControl object or None.
+        """
+        name = name.lower()
+        return self._registry.get(name)
+
+
+vcs = VcsSupport()
+
+
+class VersionControl(object):
+    name = ''
+    dirname = ''
+    repo_name = ''
+    # List of supported schemes for this Version Control
+    schemes = ()  # type: Tuple[str, ...]
+    # Iterable of environment variable names to pass to call_subprocess().
+    unset_environ = ()  # type: Tuple[str, ...]
+    default_arg_rev = None  # type: Optional[str]
+
+    @classmethod
+    def should_add_vcs_url_prefix(cls, remote_url):
+        # type: (str) -> bool
+        """
+        Return whether the vcs prefix (e.g. "git+") should be added to a
+        repository's remote url when used in a requirement.
+        """
+        return not remote_url.lower().startswith('{}:'.format(cls.name))
+
+    @classmethod
+    def get_subdirectory(cls, location):
+        # type: (str) -> Optional[str]
+        """
+        Return the path to setup.py, relative to the repo root.
+        Return None if setup.py is in the repo root.
+        """
+        return None
+
+    @classmethod
+    def get_requirement_revision(cls, repo_dir):
+        # type: (str) -> str
+        """
+        Return the revision string that should be used in a requirement.
+        """
+        return cls.get_revision(repo_dir)
+
+    @classmethod
+    def get_src_requirement(cls, repo_dir, project_name):
+        # type: (str, str) -> Optional[str]
+        """
+        Return the requirement string to use to redownload the files
+        currently at the given repository directory.
+
+        Args:
+          project_name: the (unescaped) project name.
+
+        The return value has a form similar to the following:
+
+            {repository_url}@{revision}#egg={project_name}
+        """
+        repo_url = cls.get_remote_url(repo_dir)
+        if repo_url is None:
+            return None
+
+        if cls.should_add_vcs_url_prefix(repo_url):
+            repo_url = '{}+{}'.format(cls.name, repo_url)
+
+        revision = cls.get_requirement_revision(repo_dir)
+        subdir = cls.get_subdirectory(repo_dir)
+        req = make_vcs_requirement_url(repo_url, revision, project_name,
+                                       subdir=subdir)
+
+        return req
+
+    @staticmethod
+    def get_base_rev_args(rev):
+        # type: (str) -> List[str]
+        """
+        Return the base revision arguments for a vcs command.
+
+        Args:
+          rev: the name of a revision to install.  Cannot be None.
+        """
+        raise NotImplementedError
+
+    def is_immutable_rev_checkout(self, url, dest):
+        # type: (str, str) -> bool
+        """
+        Return true if the commit hash checked out at dest matches
+        the revision in url.
+
+        Always return False, if the VCS does not support immutable commit
+        hashes.
+
+        This method does not check if there are local uncommitted changes
+        in dest after checkout, as pip currently has no use case for that.
+        """
+        return False
+
+    @classmethod
+    def make_rev_options(cls, rev=None, extra_args=None):
+        # type: (Optional[str], Optional[CommandArgs]) -> RevOptions
+        """
+        Return a RevOptions object.
+
+        Args:
+          rev: the name of a revision to install.
+          extra_args: a list of extra options.
+        """
+        return RevOptions(cls, rev, extra_args=extra_args)
+
+    @classmethod
+    def _is_local_repository(cls, repo):
+        # type: (str) -> bool
+        """
+           posix absolute paths start with os.path.sep,
+           win32 ones start with drive (like c:\\folder)
+        """
+        drive, tail = os.path.splitdrive(repo)
+        return repo.startswith(os.path.sep) or bool(drive)
+
+    def export(self, location, url):
+        # type: (str, HiddenText) -> None
+        """
+        Export the repository at the url to the destination location
+        i.e. only download the files, without vcs informations
+
+        :param url: the repository URL starting with a vcs prefix.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def get_netloc_and_auth(cls, netloc, scheme):
+        # type: (str, str) -> Tuple[str, Tuple[Optional[str], Optional[str]]]
+        """
+        Parse the repository URL's netloc, and return the new netloc to use
+        along with auth information.
+
+        Args:
+          netloc: the original repository URL netloc.
+          scheme: the repository URL's scheme without the vcs prefix.
+
+        This is mainly for the Subversion class to override, so that auth
+        information can be provided via the --username and --password options
+        instead of through the URL.  For other subclasses like Git without
+        such an option, auth information must stay in the URL.
+
+        Returns: (netloc, (username, password)).
+        """
+        return netloc, (None, None)
+
+    @classmethod
+    def get_url_rev_and_auth(cls, url):
+        # type: (str) -> Tuple[str, Optional[str], AuthInfo]
+        """
+        Parse the repository URL to use, and return the URL, revision,
+        and auth info to use.
+
+        Returns: (url, rev, (username, password)).
+        """
+        scheme, netloc, path, query, frag = urllib_parse.urlsplit(url)
+        if '+' not in scheme:
+            raise ValueError(
+                "Sorry, {!r} is a malformed VCS url. "
+                "The format is <vcs>+<protocol>://<url>, "
+                "e.g. svn+http://myrepo/svn/MyApp#egg=MyApp".format(url)
+            )
+        # Remove the vcs prefix.
+        scheme = scheme.split('+', 1)[1]
+        netloc, user_pass = cls.get_netloc_and_auth(netloc, scheme)
+        rev = None
+        if '@' in path:
+            path, rev = path.rsplit('@', 1)
+            if not rev:
+                raise InstallationError(
+                    "The URL {!r} has an empty revision (after @) "
+                    "which is not supported. Include a revision after @ "
+                    "or remove @ from the URL.".format(url)
+                )
+        url = urllib_parse.urlunsplit((scheme, netloc, path, query, ''))
+        return url, rev, user_pass
+
+    @staticmethod
+    def make_rev_args(username, password):
+        # type: (Optional[str], Optional[HiddenText]) -> CommandArgs
+        """
+        Return the RevOptions "extra arguments" to use in obtain().
+        """
+        return []
+
+    def get_url_rev_options(self, url):
+        # type: (HiddenText) -> Tuple[HiddenText, RevOptions]
+        """
+        Return the URL and RevOptions object to use in obtain() and in
+        some cases export(), as a tuple (url, rev_options).
+        """
+        secret_url, rev, user_pass = self.get_url_rev_and_auth(url.secret)
+        username, secret_password = user_pass
+        password = None  # type: Optional[HiddenText]
+        if secret_password is not None:
+            password = hide_value(secret_password)
+        extra_args = self.make_rev_args(username, password)
+        rev_options = self.make_rev_options(rev, extra_args=extra_args)
+
+        return hide_url(secret_url), rev_options
+
+    @staticmethod
+    def normalize_url(url):
+        # type: (str) -> str
+        """
+        Normalize a URL for comparison by unquoting it and removing any
+        trailing slash.
+        """
+        return urllib_parse.unquote(url).rstrip('/')
+
+    @classmethod
+    def compare_urls(cls, url1, url2):
+        # type: (str, str) -> bool
+        """
+        Compare two repo URLs for identity, ignoring incidental differences.
+        """
+        return (cls.normalize_url(url1) == cls.normalize_url(url2))
+
+    def fetch_new(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        """
+        Fetch a revision from a repository, in the case that this is the
+        first fetch from the repository.
+
+        Args:
+          dest: the directory to fetch the repository to.
+          rev_options: a RevOptions object.
+        """
+        raise NotImplementedError
+
+    def switch(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        """
+        Switch the repo at ``dest`` to point to ``URL``.
+
+        Args:
+          rev_options: a RevOptions object.
+        """
+        raise NotImplementedError
+
+    def update(self, dest, url, rev_options):
+        # type: (str, HiddenText, RevOptions) -> None
+        """
+        Update an already-existing repo to the given ``rev_options``.
+
+        Args:
+          rev_options: a RevOptions object.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def is_commit_id_equal(cls, dest, name):
+        # type: (str, Optional[str]) -> bool
+        """
+        Return whether the id of the current commit equals the given name.
+
+        Args:
+          dest: the repository directory.
+          name: a string name.
+        """
+        raise NotImplementedError
+
+    def obtain(self, dest, url):
+        # type: (str, HiddenText) -> None
+        """
+        Install or update in editable mode the package represented by this
+        VersionControl object.
+
+        :param dest: the repository directory in which to install or update.
+        :param url: the repository URL starting with a vcs prefix.
+        """
+        url, rev_options = self.get_url_rev_options(url)
+
+        if not os.path.exists(dest):
+            self.fetch_new(dest, url, rev_options)
+            return
+
+        rev_display = rev_options.to_display()
+        if self.is_repository_directory(dest):
+            existing_url = self.get_remote_url(dest)
+            if self.compare_urls(existing_url, url.secret):
+                logger.debug(
+                    '%s in %s exists, and has correct URL (%s)',
+                    self.repo_name.title(),
+                    display_path(dest),
+                    url,
+                )
+                if not self.is_commit_id_equal(dest, rev_options.rev):
+                    logger.info(
+                        'Updating %s %s%s',
+                        display_path(dest),
+                        self.repo_name,
+                        rev_display,
+                    )
+                    self.update(dest, url, rev_options)
+                else:
+                    logger.info('Skipping because already up-to-date.')
+                return
+
+            logger.warning(
+                '%s %s in %s exists with URL %s',
+                self.name,
+                self.repo_name,
+                display_path(dest),
+                existing_url,
+            )
+            prompt = ('(s)witch, (i)gnore, (w)ipe, (b)ackup ',
+                      ('s', 'i', 'w', 'b'))
+        else:
+            logger.warning(
+                'Directory %s already exists, and is not a %s %s.',
+                dest,
+                self.name,
+                self.repo_name,
+            )
+            # https://github.com/python/mypy/issues/1174
+            prompt = ('(i)gnore, (w)ipe, (b)ackup ',  # type: ignore
+                      ('i', 'w', 'b'))
+
+        logger.warning(
+            'The plan is to install the %s repository %s',
+            self.name,
+            url,
+        )
+        response = ask_path_exists('What to do?  {}'.format(
+            prompt[0]), prompt[1])
+
+        if response == 'a':
+            sys.exit(-1)
+
+        if response == 'w':
+            logger.warning('Deleting %s', display_path(dest))
+            rmtree(dest)
+            self.fetch_new(dest, url, rev_options)
+            return
+
+        if response == 'b':
+            dest_dir = backup_dir(dest)
+            logger.warning(
+                'Backing up %s to %s', display_path(dest), dest_dir,
+            )
+            shutil.move(dest, dest_dir)
+            self.fetch_new(dest, url, rev_options)
+            return
+
+        # Do nothing if the response is "i".
+        if response == 's':
+            logger.info(
+                'Switching %s %s to %s%s',
+                self.repo_name,
+                display_path(dest),
+                url,
+                rev_display,
+            )
+            self.switch(dest, url, rev_options)
+
+    def unpack(self, location, url):
+        # type: (str, HiddenText) -> None
+        """
+        Clean up current location and download the url repository
+        (and vcs infos) into location
+
+        :param url: the repository URL starting with a vcs prefix.
+        """
+        if os.path.exists(location):
+            rmtree(location)
+        self.obtain(location, url=url)
+
+    @classmethod
+    def get_remote_url(cls, location):
+        # type: (str) -> str
+        """
+        Return the url used at location
+
+        Raises RemoteNotFoundError if the repository does not have a remote
+        url configured.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def get_revision(cls, location):
+        # type: (str) -> str
+        """
+        Return the current commit id of the files at the given location.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def run_command(
+        cls,
+        cmd,  # type: Union[List[str], CommandArgs]
+        cwd=None,  # type: Optional[str]
+        extra_environ=None,  # type: Optional[Mapping[str, Any]]
+        extra_ok_returncodes=None,  # type: Optional[Iterable[int]]
+        log_failed_cmd=True  # type: bool
+    ):
+        # type: (...) -> Text
+        """
+        Run a VCS subcommand
+        This is simply a wrapper around call_subprocess that adds the VCS
+        command name, and checks that the VCS is available
+        """
+        cmd = make_command(cls.name, *cmd)
+        try:
+            return call_subprocess(cmd, cwd,
+                                   extra_environ=extra_environ,
+                                   extra_ok_returncodes=extra_ok_returncodes,
+                                   log_failed_cmd=log_failed_cmd)
+        except OSError as e:
+            # errno.ENOENT = no such file or directory
+            # In other words, the VCS executable isn't available
+            if e.errno == errno.ENOENT:
+                raise BadCommand(
+                    'Cannot find command {cls.name!r} - do you have '
+                    '{cls.name!r} installed and in your '
+                    'PATH?'.format(**locals()))
+            else:
+                raise  # re-raise exception if a different error occurred
+
+    @classmethod
+    def is_repository_directory(cls, path):
+        # type: (str) -> bool
+        """
+        Return whether a directory path is a repository directory.
+        """
+        logger.debug('Checking in %s for %s (%s)...',
+                     path, cls.dirname, cls.name)
+        return os.path.exists(os.path.join(path, cls.dirname))
+
+    @classmethod
+    def get_repository_root(cls, location):
+        # type: (str) -> Optional[str]
+        """
+        Return the "root" (top-level) directory controlled by the vcs,
+        or `None` if the directory is not in any.
+
+        It is meant to be overridden to implement smarter detection
+        mechanisms for specific vcs.
+
+        This can do more than is_repository_directory() alone. For
+        example, the Git override checks that Git is actually available.
+        """
+        if cls.is_repository_directory(location):
+            return location
+        return None
diff --git a/myenv/lib/python3.9/site-packages/pip/_internal/wheel_builder.py b/myenv/lib/python3.9/site-packages/pip/_internal/wheel_builder.py
new file mode 100644
index 0000000..fa08016
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_internal/wheel_builder.py
@@ -0,0 +1,308 @@
+"""Orchestrator for building wheels from InstallRequirements.
+"""
+
+import logging
+import os.path
+import re
+import shutil
+
+from pip._internal.models.link import Link
+from pip._internal.operations.build.wheel import build_wheel_pep517
+from pip._internal.operations.build.wheel_legacy import build_wheel_legacy
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import ensure_dir, hash_file, is_wheel_installed
+from pip._internal.utils.setuptools_build import make_setuptools_clean_args
+from pip._internal.utils.subprocess import call_subprocess
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.urls import path_to_url
+from pip._internal.vcs import vcs
+
+if MYPY_CHECK_RUNNING:
+    from typing import (
+        Any, Callable, Iterable, List, Optional, Tuple,
+    )
+
+    from pip._internal.cache import WheelCache
+    from pip._internal.req.req_install import InstallRequirement
+
+    BinaryAllowedPredicate = Callable[[InstallRequirement], bool]
+    BuildResult = Tuple[List[InstallRequirement], List[InstallRequirement]]
+
+logger = logging.getLogger(__name__)
+
+_egg_info_re = re.compile(r'([a-z0-9_.]+)-([a-z0-9_.!+-]+)', re.IGNORECASE)
+
+
+def _contains_egg_info(s):
+    # type: (str) -> bool
+    """Determine whether the string looks like an egg_info.
+
+    :param s: The string to parse. E.g. foo-2.1
+    """
+    return bool(_egg_info_re.search(s))
+
+
+def _should_build(
+    req,  # type: InstallRequirement
+    need_wheel,  # type: bool
+    check_binary_allowed,  # type: BinaryAllowedPredicate
+):
+    # type: (...) -> bool
+    """Return whether an InstallRequirement should be built into a wheel."""
+    if req.constraint:
+        # never build requirements that are merely constraints
+        return False
+    if req.is_wheel:
+        if need_wheel:
+            logger.info(
+                'Skipping %s, due to already being wheel.', req.name,
+            )
+        return False
+
+    if need_wheel:
+        # i.e. pip wheel, not pip install
+        return True
+
+    # From this point, this concerns the pip install command only
+    # (need_wheel=False).
+
+    if req.editable or not req.source_dir:
+        return False
+
+    if not check_binary_allowed(req):
+        logger.info(
+            "Skipping wheel build for %s, due to binaries "
+            "being disabled for it.", req.name,
+        )
+        return False
+
+    if not req.use_pep517 and not is_wheel_installed():
+        # we don't build legacy requirements if wheel is not installed
+        logger.info(
+            "Using legacy 'setup.py install' for %s, "
+            "since package 'wheel' is not installed.", req.name,
+        )
+        return False
+
+    return True
+
+
+def should_build_for_wheel_command(
+    req,  # type: InstallRequirement
+):
+    # type: (...) -> bool
+    return _should_build(
+        req, need_wheel=True, check_binary_allowed=_always_true
+    )
+
+
+def should_build_for_install_command(
+    req,  # type: InstallRequirement
+    check_binary_allowed,  # type: BinaryAllowedPredicate
+):
+    # type: (...) -> bool
+    return _should_build(
+        req, need_wheel=False, check_binary_allowed=check_binary_allowed
+    )
+
+
+def _should_cache(
+    req,  # type: InstallRequirement
+):
+    # type: (...) -> Optional[bool]
+    """
+    Return whether a built InstallRequirement can be stored in the persistent
+    wheel cache, assuming the wheel cache is available, and _should_build()
+    has determined a wheel needs to be built.
+    """
+    if req.editable or not req.source_dir:
+        # never cache editable requirements
+        return False
+
+    if req.link and req.link.is_vcs:
+        # VCS checkout. Do not cache
+        # unless it points to an immutable commit hash.
+        assert not req.editable
+        assert req.source_dir
+        vcs_backend = vcs.get_backend_for_scheme(req.link.scheme)
+        assert vcs_backend
+        if vcs_backend.is_immutable_rev_checkout(req.link.url, req.source_dir):
+            return True
+        return False
+
+    assert req.link
+    base, ext = req.link.splitext()
+    if _contains_egg_info(base):
+        return True
+
+    # Otherwise, do not cache.
+    return False
+
+
+def _get_cache_dir(
+    req,  # type: InstallRequirement
+    wheel_cache,  # type: WheelCache
+):
+    # type: (...) -> str
+    """Return the persistent or temporary cache directory where the built
+    wheel need to be stored.
+    """
+    cache_available = bool(wheel_cache.cache_dir)
+    assert req.link
+    if cache_available and _should_cache(req):
+        cache_dir = wheel_cache.get_path_for_link(req.link)
+    else:
+        cache_dir = wheel_cache.get_ephem_path_for_link(req.link)
+    return cache_dir
+
+
+def _always_true(_):
+    # type: (Any) -> bool
+    return True
+
+
+def _build_one(
+    req,  # type: InstallRequirement
+    output_dir,  # type: str
+    build_options,  # type: List[str]
+    global_options,  # type: List[str]
+):
+    # type: (...) -> Optional[str]
+    """Build one wheel.
+
+    :return: The filename of the built wheel, or None if the build failed.
+    """
+    try:
+        ensure_dir(output_dir)
+    except OSError as e:
+        logger.warning(
+            "Building wheel for %s failed: %s",
+            req.name, e,
+        )
+        return None
+
+    # Install build deps into temporary directory (PEP 518)
+    with req.build_env:
+        return _build_one_inside_env(
+            req, output_dir, build_options, global_options
+        )
+
+
+def _build_one_inside_env(
+    req,  # type: InstallRequirement
+    output_dir,  # type: str
+    build_options,  # type: List[str]
+    global_options,  # type: List[str]
+):
+    # type: (...) -> Optional[str]
+    with TempDirectory(kind="wheel") as temp_dir:
+        assert req.name
+        if req.use_pep517:
+            assert req.metadata_directory
+            wheel_path = build_wheel_pep517(
+                name=req.name,
+                backend=req.pep517_backend,
+                metadata_directory=req.metadata_directory,
+                build_options=build_options,
+                tempd=temp_dir.path,
+            )
+        else:
+            wheel_path = build_wheel_legacy(
+                name=req.name,
+                setup_py_path=req.setup_py_path,
+                source_dir=req.unpacked_source_directory,
+                global_options=global_options,
+                build_options=build_options,
+                tempd=temp_dir.path,
+            )
+
+        if wheel_path is not None:
+            wheel_name = os.path.basename(wheel_path)
+            dest_path = os.path.join(output_dir, wheel_name)
+            try:
+                wheel_hash, length = hash_file(wheel_path)
+                shutil.move(wheel_path, dest_path)
+                logger.info('Created wheel for %s: '
+                            'filename=%s size=%d sha256=%s',
+                            req.name, wheel_name, length,
+                            wheel_hash.hexdigest())
+                logger.info('Stored in directory: %s', output_dir)
+                return dest_path
+            except Exception as e:
+                logger.warning(
+                    "Building wheel for %s failed: %s",
+                    req.name, e,
+                )
+        # Ignore return, we can't do anything else useful.
+        if not req.use_pep517:
+            _clean_one_legacy(req, global_options)
+        return None
+
+
+def _clean_one_legacy(req, global_options):
+    # type: (InstallRequirement, List[str]) -> bool
+    clean_args = make_setuptools_clean_args(
+        req.setup_py_path,
+        global_options=global_options,
+    )
+
+    logger.info('Running setup.py clean for %s', req.name)
+    try:
+        call_subprocess(clean_args, cwd=req.source_dir)
+        return True
+    except Exception:
+        logger.error('Failed cleaning build dir for %s', req.name)
+        return False
+
+
+def build(
+    requirements,  # type: Iterable[InstallRequirement]
+    wheel_cache,  # type: WheelCache
+    build_options,  # type: List[str]
+    global_options,  # type: List[str]
+):
+    # type: (...) -> BuildResult
+    """Build wheels.
+
+    :return: The list of InstallRequirement that succeeded to build and
+        the list of InstallRequirement that failed to build.
+    """
+    if not requirements:
+        return [], []
+
+    # Build the wheels.
+    logger.info(
+        'Building wheels for collected packages: %s',
+        ', '.join(req.name for req in requirements),  # type: ignore
+    )
+
+    with indent_log():
+        build_successes, build_failures = [], []
+        for req in requirements:
+            cache_dir = _get_cache_dir(req, wheel_cache)
+            wheel_file = _build_one(
+                req, cache_dir, build_options, global_options
+            )
+            if wheel_file:
+                # Update the link for this.
+                req.link = Link(path_to_url(wheel_file))
+                req.local_file_path = req.link.file_path
+                assert req.link.is_wheel
+                build_successes.append(req)
+            else:
+                build_failures.append(req)
+
+    # notify success/failure
+    if build_successes:
+        logger.info(
+            'Successfully built %s',
+            ' '.join([req.name for req in build_successes]),  # type: ignore
+        )
+    if build_failures:
+        logger.info(
+            'Failed to build %s',
+            ' '.join([req.name for req in build_failures]),  # type: ignore
+        )
+    # Return a list of requirements that failed to build
+    return build_successes, build_failures
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/__init__.py
new file mode 100644
index 0000000..581db54
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/__init__.py
@@ -0,0 +1,110 @@
+"""
+pip._vendor is for vendoring dependencies of pip to prevent needing pip to
+depend on something external.
+
+Files inside of pip._vendor should be considered immutable and should only be
+updated to versions from upstream.
+"""
+from __future__ import absolute_import
+
+import glob
+import os.path
+import sys
+
+# Downstream redistributors which have debundled our dependencies should also
+# patch this value to be true. This will trigger the additional patching
+# to cause things like "six" to be available as pip.
+DEBUNDLED = False
+
+# By default, look in this directory for a bunch of .whl files which we will
+# add to the beginning of sys.path before attempting to import anything. This
+# is done to support downstream re-distributors like Debian and Fedora who
+# wish to create their own Wheels for our dependencies to aid in debundling.
+WHEEL_DIR = os.path.abspath(os.path.dirname(__file__))
+
+
+# Define a small helper function to alias our vendored modules to the real ones
+# if the vendored ones do not exist. This idea of this was taken from
+# https://github.com/kennethreitz/requests/pull/2567.
+def vendored(modulename):
+    vendored_name = "{0}.{1}".format(__name__, modulename)
+
+    try:
+        __import__(modulename, globals(), locals(), level=0)
+    except ImportError:
+        # This error used to be silenced in earlier variants of this file, to instead
+        # raise the error when pip actually tries to use the missing module. 
+        # Based on inputs in #5354, this was changed to explicitly raise the error.
+        # Re-raising the exception without modifying it is an intentional choice. 
+        raise
+    else:
+        sys.modules[vendored_name] = sys.modules[modulename]
+        base, head = vendored_name.rsplit(".", 1)
+        setattr(sys.modules[base], head, sys.modules[modulename])
+
+
+# If we're operating in a debundled setup, then we want to go ahead and trigger
+# the aliasing of our vendored libraries as well as looking for wheels to add
+# to our sys.path. This will cause all of this code to be a no-op typically
+# however downstream redistributors can enable it in a consistent way across
+# all platforms.
+if DEBUNDLED:
+    # Actually look inside of WHEEL_DIR to find .whl files and add them to the
+    # front of our sys.path.
+    sys.path[:] = glob.glob(os.path.join(WHEEL_DIR, "*.whl")) + sys.path
+
+    # Actually alias all of our vendored dependencies.
+    vendored("appdirs")
+    vendored("cachecontrol")
+    vendored("certifi")
+    vendored("colorama")
+    vendored("contextlib2")
+    vendored("distlib")
+    vendored("distro")
+    vendored("html5lib")
+    vendored("six")
+    vendored("six.moves")
+    vendored("six.moves.urllib")
+    vendored("six.moves.urllib.parse")
+    vendored("packaging")
+    vendored("packaging.version")
+    vendored("packaging.specifiers")
+    vendored("pep517")
+    vendored("pkg_resources")
+    vendored("progress")
+    vendored("retrying")
+    vendored("requests")
+    vendored("requests.exceptions")
+    vendored("requests.packages")
+    vendored("requests.packages.urllib3")
+    vendored("requests.packages.urllib3._collections")
+    vendored("requests.packages.urllib3.connection")
+    vendored("requests.packages.urllib3.connectionpool")
+    vendored("requests.packages.urllib3.contrib")
+    vendored("requests.packages.urllib3.contrib.ntlmpool")
+    vendored("requests.packages.urllib3.contrib.pyopenssl")
+    vendored("requests.packages.urllib3.exceptions")
+    vendored("requests.packages.urllib3.fields")
+    vendored("requests.packages.urllib3.filepost")
+    vendored("requests.packages.urllib3.packages")
+    vendored("requests.packages.urllib3.packages.ordered_dict")
+    vendored("requests.packages.urllib3.packages.six")
+    vendored("requests.packages.urllib3.packages.ssl_match_hostname")
+    vendored("requests.packages.urllib3.packages.ssl_match_hostname."
+             "_implementation")
+    vendored("requests.packages.urllib3.poolmanager")
+    vendored("requests.packages.urllib3.request")
+    vendored("requests.packages.urllib3.response")
+    vendored("requests.packages.urllib3.util")
+    vendored("requests.packages.urllib3.util.connection")
+    vendored("requests.packages.urllib3.util.request")
+    vendored("requests.packages.urllib3.util.response")
+    vendored("requests.packages.urllib3.util.retry")
+    vendored("requests.packages.urllib3.util.ssl_")
+    vendored("requests.packages.urllib3.util.timeout")
+    vendored("requests.packages.urllib3.util.url")
+    vendored("resolvelib")
+    vendored("toml")
+    vendored("toml.encoder")
+    vendored("toml.decoder")
+    vendored("urllib3")
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/appdirs.py b/myenv/lib/python3.9/site-packages/pip/_vendor/appdirs.py
new file mode 100644
index 0000000..33a3b77
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/appdirs.py
@@ -0,0 +1,633 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2005-2010 ActiveState Software Inc.
+# Copyright (c) 2013 Eddy Petrișor
+
+"""Utilities for determining application-specific dirs.
+
+See <http://github.com/ActiveState/appdirs> for details and usage.
+"""
+# Dev Notes:
+# - MSDN on where to store app data files:
+#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
+# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
+# - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+__version__ = "1.4.4"
+__version_info__ = tuple(int(segment) for segment in __version__.split("."))
+
+
+import sys
+import os
+
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    unicode = str
+
+if sys.platform.startswith('java'):
+    import platform
+    os_name = platform.java_ver()[3][0]
+    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc.
+        system = 'win32'
+    elif os_name.startswith('Mac'): # "Mac OS X", etc.
+        system = 'darwin'
+    else: # "Linux", "SunOS", "FreeBSD", etc.
+        # Setting this to "linux2" is not ideal, but only Windows or Mac
+        # are actually checked for and the rest of the module expects
+        # *sys.platform* style strings.
+        system = 'linux2'
+elif sys.platform == 'cli' and os.name == 'nt':
+    # Detect Windows in IronPython to match pip._internal.utils.compat.WINDOWS
+    # Discussion: <https://github.com/pypa/pip/pull/7501>
+    system = 'win32'
+else:
+    system = sys.platform
+
+
+
+def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user data directories are:
+        Mac OS X:               ~/Library/Application Support/<AppName>  # or ~/.config/<AppName>, if the other does not exist
+        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined
+        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName>
+        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>
+        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>
+        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName>
+
+    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
+    That means, by default "~/.local/share/<AppName>".
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
+        path = os.path.normpath(_get_win_folder(const))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Application Support/')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of data dirs should be
+            returned. By default, the first item from XDG_DATA_DIRS is
+            returned, or '/usr/local/share/<AppName>',
+            if XDG_DATA_DIRS is not set
+
+    Typical site data directories are:
+        Mac OS X:   /Library/Application Support/<AppName>
+        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName>
+        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName>
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7.
+
+    For Unix, this is using the $XDG_DATA_DIRS[0] default.
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('/Library/Application Support')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        # XDG default for $XDG_DATA_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_DATA_DIRS',
+                         os.pathsep.join(['/usr/local/share', '/usr/share']))
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.path.join(x, appname) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+        return path
+
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific config dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user config directories are:
+        Mac OS X:               same as user_data_dir
+        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined
+        Win *:                  same as user_data_dir
+
+    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
+    That means, by default "~/.config/<AppName>".
+    """
+    if system in ["win32", "darwin"]:
+        path = user_data_dir(appname, appauthor, None, roaming)
+    else:
+        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+# for the discussion regarding site_config_dir locations
+# see <https://github.com/pypa/pip/issues/1733>
+def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of config dirs should be
+            returned. By default, the first item from XDG_CONFIG_DIRS is
+            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set
+
+    Typical site config directories are:
+        Mac OS X:   same as site_data_dir
+        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in
+                    $XDG_CONFIG_DIRS
+        Win *:      same as site_data_dir
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+
+    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system in ["win32", "darwin"]:
+        path = site_data_dir(appname, appauthor)
+        if appname and version:
+            path = os.path.join(path, version)
+    else:
+        # XDG default for $XDG_CONFIG_DIRS (missing or empty)
+        # see <https://github.com/pypa/pip/pull/7501#discussion_r360624829>
+        # only first, if multipath is False
+        path = os.getenv('XDG_CONFIG_DIRS') or '/etc/xdg'
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep) if x]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.path.join(x, appname) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+    return path
+
+
+def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific cache dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Cache" to the base app data dir for Windows. See
+            discussion below.
+
+    Typical user cache directories are:
+        Mac OS X:   ~/Library/Caches/<AppName>
+        Unix:       ~/.cache/<AppName> (XDG default)
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache
+
+    On Windows the only suggestion in the MSDN docs is that local settings go in
+    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
+    app data dir (the default returned by `user_data_dir` above). Apps typically
+    put cache data somewhere *under* the given dir here. Some examples:
+        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
+        ...\Acme\SuperApp\Cache\1.0
+    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
+        # When using Python 2, return paths as bytes on Windows like we do on
+        # other operating systems. See helper function docs for more details.
+        if not PY3 and isinstance(path, unicode):
+            path = _win_path_to_bytes(path)
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+            if opinion:
+                path = os.path.join(path, "Cache")
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Caches')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_state_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific state dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user state directories are:
+        Mac OS X:  same as user_data_dir
+        Unix:      ~/.local/state/<AppName>   # or in $XDG_STATE_HOME, if defined
+        Win *:     same as user_data_dir
+
+    For Unix, we follow this Debian proposal <https://wiki.debian.org/XDGBaseDirectorySpecification#state>
+    to extend the XDG spec and support $XDG_STATE_HOME.
+
+    That means, by default "~/.local/state/<AppName>".
+    """
+    if system in ["win32", "darwin"]:
+        path = user_data_dir(appname, appauthor, None, roaming)
+    else:
+        path = os.getenv('XDG_STATE_HOME', os.path.expanduser("~/.local/state"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific log dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Logs" to the base app data dir for Windows, and "log" to the
+            base cache dir for Unix. See discussion below.
+
+    Typical user log directories are:
+        Mac OS X:   ~/Library/Logs/<AppName>
+        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs
+
+    On Windows the only suggestion in the MSDN docs is that local settings
+    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
+    examples of what some windows apps use for a logs dir.)
+
+    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
+    value for Windows and appends "log" to the user cache dir for Unix.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "darwin":
+        path = os.path.join(
+            os.path.expanduser('~/Library/Logs'),
+            appname)
+    elif system == "win32":
+        path = user_data_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "Logs")
+    else:
+        path = user_cache_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "log")
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+class AppDirs(object):
+    """Convenience wrapper for getting application dirs."""
+    def __init__(self, appname=None, appauthor=None, version=None,
+            roaming=False, multipath=False):
+        self.appname = appname
+        self.appauthor = appauthor
+        self.version = version
+        self.roaming = roaming
+        self.multipath = multipath
+
+    @property
+    def user_data_dir(self):
+        return user_data_dir(self.appname, self.appauthor,
+                             version=self.version, roaming=self.roaming)
+
+    @property
+    def site_data_dir(self):
+        return site_data_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_config_dir(self):
+        return user_config_dir(self.appname, self.appauthor,
+                               version=self.version, roaming=self.roaming)
+
+    @property
+    def site_config_dir(self):
+        return site_config_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_cache_dir(self):
+        return user_cache_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_state_dir(self):
+        return user_state_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_log_dir(self):
+        return user_log_dir(self.appname, self.appauthor,
+                            version=self.version)
+
+
+#---- internal support stuff
+
+def _get_win_folder_from_registry(csidl_name):
+    """This is a fallback technique at best. I'm not sure if using the
+    registry for this guarantees us the correct answer for all CSIDL_*
+    names.
+    """
+    if PY3:
+      import winreg as _winreg
+    else:
+      import _winreg
+
+    shell_folder_name = {
+        "CSIDL_APPDATA": "AppData",
+        "CSIDL_COMMON_APPDATA": "Common AppData",
+        "CSIDL_LOCAL_APPDATA": "Local AppData",
+    }[csidl_name]
+
+    key = _winreg.OpenKey(
+        _winreg.HKEY_CURRENT_USER,
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
+    )
+    dir, type = _winreg.QueryValueEx(key, shell_folder_name)
+    return dir
+
+
+def _get_win_folder_with_pywin32(csidl_name):
+    from win32com.shell import shellcon, shell
+    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
+    # Try to make this a unicode path because SHGetFolderPath does
+    # not return unicode strings when there is unicode data in the
+    # path.
+    try:
+        dir = unicode(dir)
+
+        # Downgrade to short path name if have highbit chars. See
+        # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+        has_high_char = False
+        for c in dir:
+            if ord(c) > 255:
+                has_high_char = True
+                break
+        if has_high_char:
+            try:
+                import win32api
+                dir = win32api.GetShortPathName(dir)
+            except ImportError:
+                pass
+    except UnicodeError:
+        pass
+    return dir
+
+
+def _get_win_folder_with_ctypes(csidl_name):
+    import ctypes
+
+    csidl_const = {
+        "CSIDL_APPDATA": 26,
+        "CSIDL_COMMON_APPDATA": 35,
+        "CSIDL_LOCAL_APPDATA": 28,
+    }[csidl_name]
+
+    buf = ctypes.create_unicode_buffer(1024)
+    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in buf:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf2 = ctypes.create_unicode_buffer(1024)
+        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+            buf = buf2
+
+    return buf.value
+
+def _get_win_folder_with_jna(csidl_name):
+    import array
+    from com.sun import jna
+    from com.sun.jna.platform import win32
+
+    buf_size = win32.WinDef.MAX_PATH * 2
+    buf = array.zeros('c', buf_size)
+    shell = win32.Shell32.INSTANCE
+    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf)
+    dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in dir:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf = array.zeros('c', buf_size)
+        kernel = win32.Kernel32.INSTANCE
+        if kernel.GetShortPathName(dir, buf, buf_size):
+            dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    return dir
+
+if system == "win32":
+    try:
+        from ctypes import windll
+        _get_win_folder = _get_win_folder_with_ctypes
+    except ImportError:
+        try:
+            import com.sun.jna
+            _get_win_folder = _get_win_folder_with_jna
+        except ImportError:
+            _get_win_folder = _get_win_folder_from_registry
+
+
+def _win_path_to_bytes(path):
+    """Encode Windows paths to bytes. Only used on Python 2.
+
+    Motivation is to be consistent with other operating systems where paths
+    are also returned as bytes. This avoids problems mixing bytes and Unicode
+    elsewhere in the codebase. For more details and discussion see
+    <https://github.com/pypa/pip/issues/3463>.
+
+    If encoding using ASCII and MBCS fails, return the original Unicode path.
+    """
+    for encoding in ('ASCII', 'MBCS'):
+        try:
+            return path.encode(encoding)
+        except (UnicodeEncodeError, LookupError):
+            pass
+    return path
+
+
+#---- self test code
+
+if __name__ == "__main__":
+    appname = "MyApp"
+    appauthor = "MyCompany"
+
+    props = ("user_data_dir",
+             "user_config_dir",
+             "user_cache_dir",
+             "user_state_dir",
+             "user_log_dir",
+             "site_data_dir",
+             "site_config_dir")
+
+    print("-- app dirs %s --" % __version__)
+
+    print("-- app dirs (with optional 'version')")
+    dirs = AppDirs(appname, appauthor, version="1.0")
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'version')")
+    dirs = AppDirs(appname, appauthor)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'appauthor')")
+    dirs = AppDirs(appname)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (with disabled 'appauthor')")
+    dirs = AppDirs(appname, appauthor=False)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/__init__.py
new file mode 100644
index 0000000..a1bbbbe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/__init__.py
@@ -0,0 +1,11 @@
+"""CacheControl import Interface.
+
+Make it easy to import from cachecontrol without long namespaces.
+"""
+__author__ = "Eric Larson"
+__email__ = "eric@ionrock.org"
+__version__ = "0.12.6"
+
+from .wrapper import CacheControl
+from .adapter import CacheControlAdapter
+from .controller import CacheController
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/_cmd.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/_cmd.py
new file mode 100644
index 0000000..f1e0ad9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/_cmd.py
@@ -0,0 +1,57 @@
+import logging
+
+from pip._vendor import requests
+
+from pip._vendor.cachecontrol.adapter import CacheControlAdapter
+from pip._vendor.cachecontrol.cache import DictCache
+from pip._vendor.cachecontrol.controller import logger
+
+from argparse import ArgumentParser
+
+
+def setup_logging():
+    logger.setLevel(logging.DEBUG)
+    handler = logging.StreamHandler()
+    logger.addHandler(handler)
+
+
+def get_session():
+    adapter = CacheControlAdapter(
+        DictCache(), cache_etags=True, serializer=None, heuristic=None
+    )
+    sess = requests.Session()
+    sess.mount("http://", adapter)
+    sess.mount("https://", adapter)
+
+    sess.cache_controller = adapter.controller
+    return sess
+
+
+def get_args():
+    parser = ArgumentParser()
+    parser.add_argument("url", help="The URL to try and cache")
+    return parser.parse_args()
+
+
+def main(args=None):
+    args = get_args()
+    sess = get_session()
+
+    # Make a request to get a response
+    resp = sess.get(args.url)
+
+    # Turn on logging
+    setup_logging()
+
+    # try setting the cache
+    sess.cache_controller.cache_response(resp.request, resp.raw)
+
+    # Now try to get it
+    if sess.cache_controller.cached_request(resp.request):
+        print("Cached!")
+    else:
+        print("Not cached :(")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/adapter.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/adapter.py
new file mode 100644
index 0000000..815650e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/adapter.py
@@ -0,0 +1,133 @@
+import types
+import functools
+import zlib
+
+from pip._vendor.requests.adapters import HTTPAdapter
+
+from .controller import CacheController
+from .cache import DictCache
+from .filewrapper import CallbackFileWrapper
+
+
+class CacheControlAdapter(HTTPAdapter):
+    invalidating_methods = {"PUT", "DELETE"}
+
+    def __init__(
+        self,
+        cache=None,
+        cache_etags=True,
+        controller_class=None,
+        serializer=None,
+        heuristic=None,
+        cacheable_methods=None,
+        *args,
+        **kw
+    ):
+        super(CacheControlAdapter, self).__init__(*args, **kw)
+        self.cache = DictCache() if cache is None else cache
+        self.heuristic = heuristic
+        self.cacheable_methods = cacheable_methods or ("GET",)
+
+        controller_factory = controller_class or CacheController
+        self.controller = controller_factory(
+            self.cache, cache_etags=cache_etags, serializer=serializer
+        )
+
+    def send(self, request, cacheable_methods=None, **kw):
+        """
+        Send a request. Use the request information to see if it
+        exists in the cache and cache the response if we need to and can.
+        """
+        cacheable = cacheable_methods or self.cacheable_methods
+        if request.method in cacheable:
+            try:
+                cached_response = self.controller.cached_request(request)
+            except zlib.error:
+                cached_response = None
+            if cached_response:
+                return self.build_response(request, cached_response, from_cache=True)
+
+            # check for etags and add headers if appropriate
+            request.headers.update(self.controller.conditional_headers(request))
+
+        resp = super(CacheControlAdapter, self).send(request, **kw)
+
+        return resp
+
+    def build_response(
+        self, request, response, from_cache=False, cacheable_methods=None
+    ):
+        """
+        Build a response by making a request or using the cache.
+
+        This will end up calling send and returning a potentially
+        cached response
+        """
+        cacheable = cacheable_methods or self.cacheable_methods
+        if not from_cache and request.method in cacheable:
+            # Check for any heuristics that might update headers
+            # before trying to cache.
+            if self.heuristic:
+                response = self.heuristic.apply(response)
+
+            # apply any expiration heuristics
+            if response.status == 304:
+                # We must have sent an ETag request. This could mean
+                # that we've been expired already or that we simply
+                # have an etag. In either case, we want to try and
+                # update the cache if that is the case.
+                cached_response = self.controller.update_cached_response(
+                    request, response
+                )
+
+                if cached_response is not response:
+                    from_cache = True
+
+                # We are done with the server response, read a
+                # possible response body (compliant servers will
+                # not return one, but we cannot be 100% sure) and
+                # release the connection back to the pool.
+                response.read(decode_content=False)
+                response.release_conn()
+
+                response = cached_response
+
+            # We always cache the 301 responses
+            elif response.status == 301:
+                self.controller.cache_response(request, response)
+            else:
+                # Wrap the response file with a wrapper that will cache the
+                #   response when the stream has been consumed.
+                response._fp = CallbackFileWrapper(
+                    response._fp,
+                    functools.partial(
+                        self.controller.cache_response, request, response
+                    ),
+                )
+                if response.chunked:
+                    super_update_chunk_length = response._update_chunk_length
+
+                    def _update_chunk_length(self):
+                        super_update_chunk_length()
+                        if self.chunk_left == 0:
+                            self._fp._close()
+
+                    response._update_chunk_length = types.MethodType(
+                        _update_chunk_length, response
+                    )
+
+        resp = super(CacheControlAdapter, self).build_response(request, response)
+
+        # See if we should invalidate the cache.
+        if request.method in self.invalidating_methods and resp.ok:
+            cache_url = self.controller.cache_url(request.url)
+            self.cache.delete(cache_url)
+
+        # Give the request a from_cache attr to let people use it
+        resp.from_cache = from_cache
+
+        return resp
+
+    def close(self):
+        self.cache.close()
+        super(CacheControlAdapter, self).close()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/cache.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/cache.py
new file mode 100644
index 0000000..94e0773
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/cache.py
@@ -0,0 +1,39 @@
+"""
+The cache object API for implementing caches. The default is a thread
+safe in-memory dictionary.
+"""
+from threading import Lock
+
+
+class BaseCache(object):
+
+    def get(self, key):
+        raise NotImplementedError()
+
+    def set(self, key, value):
+        raise NotImplementedError()
+
+    def delete(self, key):
+        raise NotImplementedError()
+
+    def close(self):
+        pass
+
+
+class DictCache(BaseCache):
+
+    def __init__(self, init_dict=None):
+        self.lock = Lock()
+        self.data = init_dict or {}
+
+    def get(self, key):
+        return self.data.get(key, None)
+
+    def set(self, key, value):
+        with self.lock:
+            self.data.update({key: value})
+
+    def delete(self, key):
+        with self.lock:
+            if key in self.data:
+                self.data.pop(key)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/caches/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/caches/__init__.py
new file mode 100644
index 0000000..0e1658f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/caches/__init__.py
@@ -0,0 +1,2 @@
+from .file_cache import FileCache  # noqa
+from .redis_cache import RedisCache  # noqa
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py
new file mode 100644
index 0000000..607b945
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py
@@ -0,0 +1,146 @@
+import hashlib
+import os
+from textwrap import dedent
+
+from ..cache import BaseCache
+from ..controller import CacheController
+
+try:
+    FileNotFoundError
+except NameError:
+    # py2.X
+    FileNotFoundError = (IOError, OSError)
+
+
+def _secure_open_write(filename, fmode):
+    # We only want to write to this file, so open it in write only mode
+    flags = os.O_WRONLY
+
+    # os.O_CREAT | os.O_EXCL will fail if the file already exists, so we only
+    #  will open *new* files.
+    # We specify this because we want to ensure that the mode we pass is the
+    # mode of the file.
+    flags |= os.O_CREAT | os.O_EXCL
+
+    # Do not follow symlinks to prevent someone from making a symlink that
+    # we follow and insecurely open a cache file.
+    if hasattr(os, "O_NOFOLLOW"):
+        flags |= os.O_NOFOLLOW
+
+    # On Windows we'll mark this file as binary
+    if hasattr(os, "O_BINARY"):
+        flags |= os.O_BINARY
+
+    # Before we open our file, we want to delete any existing file that is
+    # there
+    try:
+        os.remove(filename)
+    except (IOError, OSError):
+        # The file must not exist already, so we can just skip ahead to opening
+        pass
+
+    # Open our file, the use of os.O_CREAT | os.O_EXCL will ensure that if a
+    # race condition happens between the os.remove and this line, that an
+    # error will be raised. Because we utilize a lockfile this should only
+    # happen if someone is attempting to attack us.
+    fd = os.open(filename, flags, fmode)
+    try:
+        return os.fdopen(fd, "wb")
+
+    except:
+        # An error occurred wrapping our FD in a file object
+        os.close(fd)
+        raise
+
+
+class FileCache(BaseCache):
+
+    def __init__(
+        self,
+        directory,
+        forever=False,
+        filemode=0o0600,
+        dirmode=0o0700,
+        use_dir_lock=None,
+        lock_class=None,
+    ):
+
+        if use_dir_lock is not None and lock_class is not None:
+            raise ValueError("Cannot use use_dir_lock and lock_class together")
+
+        try:
+            from lockfile import LockFile
+            from lockfile.mkdirlockfile import MkdirLockFile
+        except ImportError:
+            notice = dedent(
+                """
+            NOTE: In order to use the FileCache you must have
+            lockfile installed. You can install it via pip:
+              pip install lockfile
+            """
+            )
+            raise ImportError(notice)
+
+        else:
+            if use_dir_lock:
+                lock_class = MkdirLockFile
+
+            elif lock_class is None:
+                lock_class = LockFile
+
+        self.directory = directory
+        self.forever = forever
+        self.filemode = filemode
+        self.dirmode = dirmode
+        self.lock_class = lock_class
+
+    @staticmethod
+    def encode(x):
+        return hashlib.sha224(x.encode()).hexdigest()
+
+    def _fn(self, name):
+        # NOTE: This method should not change as some may depend on it.
+        #       See: https://github.com/ionrock/cachecontrol/issues/63
+        hashed = self.encode(name)
+        parts = list(hashed[:5]) + [hashed]
+        return os.path.join(self.directory, *parts)
+
+    def get(self, key):
+        name = self._fn(key)
+        try:
+            with open(name, "rb") as fh:
+                return fh.read()
+
+        except FileNotFoundError:
+            return None
+
+    def set(self, key, value):
+        name = self._fn(key)
+
+        # Make sure the directory exists
+        try:
+            os.makedirs(os.path.dirname(name), self.dirmode)
+        except (IOError, OSError):
+            pass
+
+        with self.lock_class(name) as lock:
+            # Write our actual file
+            with _secure_open_write(lock.path, self.filemode) as fh:
+                fh.write(value)
+
+    def delete(self, key):
+        name = self._fn(key)
+        if not self.forever:
+            try:
+                os.remove(name)
+            except FileNotFoundError:
+                pass
+
+
+def url_to_file_path(url, filecache):
+    """Return the file cache path based on the URL.
+
+    This does not ensure the file exists!
+    """
+    key = CacheController.cache_url(url)
+    return filecache._fn(key)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py
new file mode 100644
index 0000000..ed705ce
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py
@@ -0,0 +1,33 @@
+from __future__ import division
+
+from datetime import datetime
+from pip._vendor.cachecontrol.cache import BaseCache
+
+
+class RedisCache(BaseCache):
+
+    def __init__(self, conn):
+        self.conn = conn
+
+    def get(self, key):
+        return self.conn.get(key)
+
+    def set(self, key, value, expires=None):
+        if not expires:
+            self.conn.set(key, value)
+        else:
+            expires = expires - datetime.utcnow()
+            self.conn.setex(key, int(expires.total_seconds()), value)
+
+    def delete(self, key):
+        self.conn.delete(key)
+
+    def clear(self):
+        """Helper for clearing all the keys in a database. Use with
+        caution!"""
+        for key in self.conn.keys():
+            self.conn.delete(key)
+
+    def close(self):
+        """Redis uses connection pooling, no need to close the connection."""
+        pass
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/compat.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/compat.py
new file mode 100644
index 0000000..33b5aed
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/compat.py
@@ -0,0 +1,29 @@
+try:
+    from urllib.parse import urljoin
+except ImportError:
+    from urlparse import urljoin
+
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+
+# Handle the case where the requests module has been patched to not have
+# urllib3 bundled as part of its source.
+try:
+    from pip._vendor.requests.packages.urllib3.response import HTTPResponse
+except ImportError:
+    from pip._vendor.urllib3.response import HTTPResponse
+
+try:
+    from pip._vendor.requests.packages.urllib3.util import is_fp_closed
+except ImportError:
+    from pip._vendor.urllib3.util import is_fp_closed
+
+# Replicate some six behaviour
+try:
+    text_type = unicode
+except NameError:
+    text_type = str
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/controller.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/controller.py
new file mode 100644
index 0000000..dafe55c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/controller.py
@@ -0,0 +1,376 @@
+"""
+The httplib2 algorithms ported for use with requests.
+"""
+import logging
+import re
+import calendar
+import time
+from email.utils import parsedate_tz
+
+from pip._vendor.requests.structures import CaseInsensitiveDict
+
+from .cache import DictCache
+from .serialize import Serializer
+
+
+logger = logging.getLogger(__name__)
+
+URI = re.compile(r"^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?")
+
+
+def parse_uri(uri):
+    """Parses a URI using the regex given in Appendix B of RFC 3986.
+
+        (scheme, authority, path, query, fragment) = parse_uri(uri)
+    """
+    groups = URI.match(uri).groups()
+    return (groups[1], groups[3], groups[4], groups[6], groups[8])
+
+
+class CacheController(object):
+    """An interface to see if request should cached or not.
+    """
+
+    def __init__(
+        self, cache=None, cache_etags=True, serializer=None, status_codes=None
+    ):
+        self.cache = DictCache() if cache is None else cache
+        self.cache_etags = cache_etags
+        self.serializer = serializer or Serializer()
+        self.cacheable_status_codes = status_codes or (200, 203, 300, 301)
+
+    @classmethod
+    def _urlnorm(cls, uri):
+        """Normalize the URL to create a safe key for the cache"""
+        (scheme, authority, path, query, fragment) = parse_uri(uri)
+        if not scheme or not authority:
+            raise Exception("Only absolute URIs are allowed. uri = %s" % uri)
+
+        scheme = scheme.lower()
+        authority = authority.lower()
+
+        if not path:
+            path = "/"
+
+        # Could do syntax based normalization of the URI before
+        # computing the digest. See Section 6.2.2 of Std 66.
+        request_uri = query and "?".join([path, query]) or path
+        defrag_uri = scheme + "://" + authority + request_uri
+
+        return defrag_uri
+
+    @classmethod
+    def cache_url(cls, uri):
+        return cls._urlnorm(uri)
+
+    def parse_cache_control(self, headers):
+        known_directives = {
+            # https://tools.ietf.org/html/rfc7234#section-5.2
+            "max-age": (int, True),
+            "max-stale": (int, False),
+            "min-fresh": (int, True),
+            "no-cache": (None, False),
+            "no-store": (None, False),
+            "no-transform": (None, False),
+            "only-if-cached": (None, False),
+            "must-revalidate": (None, False),
+            "public": (None, False),
+            "private": (None, False),
+            "proxy-revalidate": (None, False),
+            "s-maxage": (int, True),
+        }
+
+        cc_headers = headers.get("cache-control", headers.get("Cache-Control", ""))
+
+        retval = {}
+
+        for cc_directive in cc_headers.split(","):
+            if not cc_directive.strip():
+                continue
+
+            parts = cc_directive.split("=", 1)
+            directive = parts[0].strip()
+
+            try:
+                typ, required = known_directives[directive]
+            except KeyError:
+                logger.debug("Ignoring unknown cache-control directive: %s", directive)
+                continue
+
+            if not typ or not required:
+                retval[directive] = None
+            if typ:
+                try:
+                    retval[directive] = typ(parts[1].strip())
+                except IndexError:
+                    if required:
+                        logger.debug(
+                            "Missing value for cache-control " "directive: %s",
+                            directive,
+                        )
+                except ValueError:
+                    logger.debug(
+                        "Invalid value for cache-control directive " "%s, must be %s",
+                        directive,
+                        typ.__name__,
+                    )
+
+        return retval
+
+    def cached_request(self, request):
+        """
+        Return a cached response if it exists in the cache, otherwise
+        return False.
+        """
+        cache_url = self.cache_url(request.url)
+        logger.debug('Looking up "%s" in the cache', cache_url)
+        cc = self.parse_cache_control(request.headers)
+
+        # Bail out if the request insists on fresh data
+        if "no-cache" in cc:
+            logger.debug('Request header has "no-cache", cache bypassed')
+            return False
+
+        if "max-age" in cc and cc["max-age"] == 0:
+            logger.debug('Request header has "max_age" as 0, cache bypassed')
+            return False
+
+        # Request allows serving from the cache, let's see if we find something
+        cache_data = self.cache.get(cache_url)
+        if cache_data is None:
+            logger.debug("No cache entry available")
+            return False
+
+        # Check whether it can be deserialized
+        resp = self.serializer.loads(request, cache_data)
+        if not resp:
+            logger.warning("Cache entry deserialization failed, entry ignored")
+            return False
+
+        # If we have a cached 301, return it immediately. We don't
+        # need to test our response for other headers b/c it is
+        # intrinsically "cacheable" as it is Permanent.
+        # See:
+        #   https://tools.ietf.org/html/rfc7231#section-6.4.2
+        #
+        # Client can try to refresh the value by repeating the request
+        # with cache busting headers as usual (ie no-cache).
+        if resp.status == 301:
+            msg = (
+                'Returning cached "301 Moved Permanently" response '
+                "(ignoring date and etag information)"
+            )
+            logger.debug(msg)
+            return resp
+
+        headers = CaseInsensitiveDict(resp.headers)
+        if not headers or "date" not in headers:
+            if "etag" not in headers:
+                # Without date or etag, the cached response can never be used
+                # and should be deleted.
+                logger.debug("Purging cached response: no date or etag")
+                self.cache.delete(cache_url)
+            logger.debug("Ignoring cached response: no date")
+            return False
+
+        now = time.time()
+        date = calendar.timegm(parsedate_tz(headers["date"]))
+        current_age = max(0, now - date)
+        logger.debug("Current age based on date: %i", current_age)
+
+        # TODO: There is an assumption that the result will be a
+        #       urllib3 response object. This may not be best since we
+        #       could probably avoid instantiating or constructing the
+        #       response until we know we need it.
+        resp_cc = self.parse_cache_control(headers)
+
+        # determine freshness
+        freshness_lifetime = 0
+
+        # Check the max-age pragma in the cache control header
+        if "max-age" in resp_cc:
+            freshness_lifetime = resp_cc["max-age"]
+            logger.debug("Freshness lifetime from max-age: %i", freshness_lifetime)
+
+        # If there isn't a max-age, check for an expires header
+        elif "expires" in headers:
+            expires = parsedate_tz(headers["expires"])
+            if expires is not None:
+                expire_time = calendar.timegm(expires) - date
+                freshness_lifetime = max(0, expire_time)
+                logger.debug("Freshness lifetime from expires: %i", freshness_lifetime)
+
+        # Determine if we are setting freshness limit in the
+        # request. Note, this overrides what was in the response.
+        if "max-age" in cc:
+            freshness_lifetime = cc["max-age"]
+            logger.debug(
+                "Freshness lifetime from request max-age: %i", freshness_lifetime
+            )
+
+        if "min-fresh" in cc:
+            min_fresh = cc["min-fresh"]
+            # adjust our current age by our min fresh
+            current_age += min_fresh
+            logger.debug("Adjusted current age from min-fresh: %i", current_age)
+
+        # Return entry if it is fresh enough
+        if freshness_lifetime > current_age:
+            logger.debug('The response is "fresh", returning cached response')
+            logger.debug("%i > %i", freshness_lifetime, current_age)
+            return resp
+
+        # we're not fresh. If we don't have an Etag, clear it out
+        if "etag" not in headers:
+            logger.debug('The cached response is "stale" with no etag, purging')
+            self.cache.delete(cache_url)
+
+        # return the original handler
+        return False
+
+    def conditional_headers(self, request):
+        cache_url = self.cache_url(request.url)
+        resp = self.serializer.loads(request, self.cache.get(cache_url))
+        new_headers = {}
+
+        if resp:
+            headers = CaseInsensitiveDict(resp.headers)
+
+            if "etag" in headers:
+                new_headers["If-None-Match"] = headers["ETag"]
+
+            if "last-modified" in headers:
+                new_headers["If-Modified-Since"] = headers["Last-Modified"]
+
+        return new_headers
+
+    def cache_response(self, request, response, body=None, status_codes=None):
+        """
+        Algorithm for caching requests.
+
+        This assumes a requests Response object.
+        """
+        # From httplib2: Don't cache 206's since we aren't going to
+        #                handle byte range requests
+        cacheable_status_codes = status_codes or self.cacheable_status_codes
+        if response.status not in cacheable_status_codes:
+            logger.debug(
+                "Status code %s not in %s", response.status, cacheable_status_codes
+            )
+            return
+
+        response_headers = CaseInsensitiveDict(response.headers)
+
+        # If we've been given a body, our response has a Content-Length, that
+        # Content-Length is valid then we can check to see if the body we've
+        # been given matches the expected size, and if it doesn't we'll just
+        # skip trying to cache it.
+        if (
+            body is not None
+            and "content-length" in response_headers
+            and response_headers["content-length"].isdigit()
+            and int(response_headers["content-length"]) != len(body)
+        ):
+            return
+
+        cc_req = self.parse_cache_control(request.headers)
+        cc = self.parse_cache_control(response_headers)
+
+        cache_url = self.cache_url(request.url)
+        logger.debug('Updating cache with response from "%s"', cache_url)
+
+        # Delete it from the cache if we happen to have it stored there
+        no_store = False
+        if "no-store" in cc:
+            no_store = True
+            logger.debug('Response header has "no-store"')
+        if "no-store" in cc_req:
+            no_store = True
+            logger.debug('Request header has "no-store"')
+        if no_store and self.cache.get(cache_url):
+            logger.debug('Purging existing cache entry to honor "no-store"')
+            self.cache.delete(cache_url)
+        if no_store:
+            return
+
+        # https://tools.ietf.org/html/rfc7234#section-4.1:
+        # A Vary header field-value of "*" always fails to match.
+        # Storing such a response leads to a deserialization warning
+        # during cache lookup and is not allowed to ever be served,
+        # so storing it can be avoided.
+        if "*" in response_headers.get("vary", ""):
+            logger.debug('Response header has "Vary: *"')
+            return
+
+        # If we've been given an etag, then keep the response
+        if self.cache_etags and "etag" in response_headers:
+            logger.debug("Caching due to etag")
+            self.cache.set(
+                cache_url, self.serializer.dumps(request, response, body=body)
+            )
+
+        # Add to the cache any 301s. We do this before looking that
+        # the Date headers.
+        elif response.status == 301:
+            logger.debug("Caching permanant redirect")
+            self.cache.set(cache_url, self.serializer.dumps(request, response))
+
+        # Add to the cache if the response headers demand it. If there
+        # is no date header then we can't do anything about expiring
+        # the cache.
+        elif "date" in response_headers:
+            # cache when there is a max-age > 0
+            if "max-age" in cc and cc["max-age"] > 0:
+                logger.debug("Caching b/c date exists and max-age > 0")
+                self.cache.set(
+                    cache_url, self.serializer.dumps(request, response, body=body)
+                )
+
+            # If the request can expire, it means we should cache it
+            # in the meantime.
+            elif "expires" in response_headers:
+                if response_headers["expires"]:
+                    logger.debug("Caching b/c of expires header")
+                    self.cache.set(
+                        cache_url, self.serializer.dumps(request, response, body=body)
+                    )
+
+    def update_cached_response(self, request, response):
+        """On a 304 we will get a new set of headers that we want to
+        update our cached value with, assuming we have one.
+
+        This should only ever be called when we've sent an ETag and
+        gotten a 304 as the response.
+        """
+        cache_url = self.cache_url(request.url)
+
+        cached_response = self.serializer.loads(request, self.cache.get(cache_url))
+
+        if not cached_response:
+            # we didn't have a cached response
+            return response
+
+        # Lets update our headers with the headers from the new request:
+        # http://tools.ietf.org/html/draft-ietf-httpbis-p4-conditional-26#section-4.1
+        #
+        # The server isn't supposed to send headers that would make
+        # the cached body invalid. But... just in case, we'll be sure
+        # to strip out ones we know that might be problmatic due to
+        # typical assumptions.
+        excluded_headers = ["content-length"]
+
+        cached_response.headers.update(
+            dict(
+                (k, v)
+                for k, v in response.headers.items()
+                if k.lower() not in excluded_headers
+            )
+        )
+
+        # we want a 200 b/c we have content via the cache
+        cached_response.status = 200
+
+        # update our cache
+        self.cache.set(cache_url, self.serializer.dumps(request, cached_response))
+
+        return cached_response
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/filewrapper.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/filewrapper.py
new file mode 100644
index 0000000..30ed4c5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/filewrapper.py
@@ -0,0 +1,80 @@
+from io import BytesIO
+
+
+class CallbackFileWrapper(object):
+    """
+    Small wrapper around a fp object which will tee everything read into a
+    buffer, and when that file is closed it will execute a callback with the
+    contents of that buffer.
+
+    All attributes are proxied to the underlying file object.
+
+    This class uses members with a double underscore (__) leading prefix so as
+    not to accidentally shadow an attribute.
+    """
+
+    def __init__(self, fp, callback):
+        self.__buf = BytesIO()
+        self.__fp = fp
+        self.__callback = callback
+
+    def __getattr__(self, name):
+        # The vaguaries of garbage collection means that self.__fp is
+        # not always set.  By using __getattribute__ and the private
+        # name[0] allows looking up the attribute value and raising an
+        # AttributeError when it doesn't exist. This stop thigns from
+        # infinitely recursing calls to getattr in the case where
+        # self.__fp hasn't been set.
+        #
+        # [0] https://docs.python.org/2/reference/expressions.html#atom-identifiers
+        fp = self.__getattribute__("_CallbackFileWrapper__fp")
+        return getattr(fp, name)
+
+    def __is_fp_closed(self):
+        try:
+            return self.__fp.fp is None
+
+        except AttributeError:
+            pass
+
+        try:
+            return self.__fp.closed
+
+        except AttributeError:
+            pass
+
+        # We just don't cache it then.
+        # TODO: Add some logging here...
+        return False
+
+    def _close(self):
+        if self.__callback:
+            self.__callback(self.__buf.getvalue())
+
+        # We assign this to None here, because otherwise we can get into
+        # really tricky problems where the CPython interpreter dead locks
+        # because the callback is holding a reference to something which
+        # has a __del__ method. Setting this to None breaks the cycle
+        # and allows the garbage collector to do it's thing normally.
+        self.__callback = None
+
+    def read(self, amt=None):
+        data = self.__fp.read(amt)
+        self.__buf.write(data)
+        if self.__is_fp_closed():
+            self._close()
+
+        return data
+
+    def _safe_read(self, amt):
+        data = self.__fp._safe_read(amt)
+        if amt == 2 and data == b"\r\n":
+            # urllib executes this read to toss the CRLF at the end
+            # of the chunk.
+            return data
+
+        self.__buf.write(data)
+        if self.__is_fp_closed():
+            self._close()
+
+        return data
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/heuristics.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/heuristics.py
new file mode 100644
index 0000000..6c0e979
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/heuristics.py
@@ -0,0 +1,135 @@
+import calendar
+import time
+
+from email.utils import formatdate, parsedate, parsedate_tz
+
+from datetime import datetime, timedelta
+
+TIME_FMT = "%a, %d %b %Y %H:%M:%S GMT"
+
+
+def expire_after(delta, date=None):
+    date = date or datetime.utcnow()
+    return date + delta
+
+
+def datetime_to_header(dt):
+    return formatdate(calendar.timegm(dt.timetuple()))
+
+
+class BaseHeuristic(object):
+
+    def warning(self, response):
+        """
+        Return a valid 1xx warning header value describing the cache
+        adjustments.
+
+        The response is provided too allow warnings like 113
+        http://tools.ietf.org/html/rfc7234#section-5.5.4 where we need
+        to explicitly say response is over 24 hours old.
+        """
+        return '110 - "Response is Stale"'
+
+    def update_headers(self, response):
+        """Update the response headers with any new headers.
+
+        NOTE: This SHOULD always include some Warning header to
+              signify that the response was cached by the client, not
+              by way of the provided headers.
+        """
+        return {}
+
+    def apply(self, response):
+        updated_headers = self.update_headers(response)
+
+        if updated_headers:
+            response.headers.update(updated_headers)
+            warning_header_value = self.warning(response)
+            if warning_header_value is not None:
+                response.headers.update({"Warning": warning_header_value})
+
+        return response
+
+
+class OneDayCache(BaseHeuristic):
+    """
+    Cache the response by providing an expires 1 day in the
+    future.
+    """
+
+    def update_headers(self, response):
+        headers = {}
+
+        if "expires" not in response.headers:
+            date = parsedate(response.headers["date"])
+            expires = expire_after(timedelta(days=1), date=datetime(*date[:6]))
+            headers["expires"] = datetime_to_header(expires)
+            headers["cache-control"] = "public"
+        return headers
+
+
+class ExpiresAfter(BaseHeuristic):
+    """
+    Cache **all** requests for a defined time period.
+    """
+
+    def __init__(self, **kw):
+        self.delta = timedelta(**kw)
+
+    def update_headers(self, response):
+        expires = expire_after(self.delta)
+        return {"expires": datetime_to_header(expires), "cache-control": "public"}
+
+    def warning(self, response):
+        tmpl = "110 - Automatically cached for %s. Response might be stale"
+        return tmpl % self.delta
+
+
+class LastModified(BaseHeuristic):
+    """
+    If there is no Expires header already, fall back on Last-Modified
+    using the heuristic from
+    http://tools.ietf.org/html/rfc7234#section-4.2.2
+    to calculate a reasonable value.
+
+    Firefox also does something like this per
+    https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching_FAQ
+    http://lxr.mozilla.org/mozilla-release/source/netwerk/protocol/http/nsHttpResponseHead.cpp#397
+    Unlike mozilla we limit this to 24-hr.
+    """
+    cacheable_by_default_statuses = {
+        200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501
+    }
+
+    def update_headers(self, resp):
+        headers = resp.headers
+
+        if "expires" in headers:
+            return {}
+
+        if "cache-control" in headers and headers["cache-control"] != "public":
+            return {}
+
+        if resp.status not in self.cacheable_by_default_statuses:
+            return {}
+
+        if "date" not in headers or "last-modified" not in headers:
+            return {}
+
+        date = calendar.timegm(parsedate_tz(headers["date"]))
+        last_modified = parsedate(headers["last-modified"])
+        if date is None or last_modified is None:
+            return {}
+
+        now = time.time()
+        current_age = max(0, now - date)
+        delta = date - calendar.timegm(last_modified)
+        freshness_lifetime = max(0, min(delta / 10, 24 * 3600))
+        if freshness_lifetime <= current_age:
+            return {}
+
+        expires = date + freshness_lifetime
+        return {"expires": time.strftime(TIME_FMT, time.gmtime(expires))}
+
+    def warning(self, resp):
+        return None
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/serialize.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/serialize.py
new file mode 100644
index 0000000..3b6ec2d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/serialize.py
@@ -0,0 +1,188 @@
+import base64
+import io
+import json
+import zlib
+
+from pip._vendor import msgpack
+from pip._vendor.requests.structures import CaseInsensitiveDict
+
+from .compat import HTTPResponse, pickle, text_type
+
+
+def _b64_decode_bytes(b):
+    return base64.b64decode(b.encode("ascii"))
+
+
+def _b64_decode_str(s):
+    return _b64_decode_bytes(s).decode("utf8")
+
+
+class Serializer(object):
+
+    def dumps(self, request, response, body=None):
+        response_headers = CaseInsensitiveDict(response.headers)
+
+        if body is None:
+            body = response.read(decode_content=False)
+
+            # NOTE: 99% sure this is dead code. I'm only leaving it
+            #       here b/c I don't have a test yet to prove
+            #       it. Basically, before using
+            #       `cachecontrol.filewrapper.CallbackFileWrapper`,
+            #       this made an effort to reset the file handle. The
+            #       `CallbackFileWrapper` short circuits this code by
+            #       setting the body as the content is consumed, the
+            #       result being a `body` argument is *always* passed
+            #       into cache_response, and in turn,
+            #       `Serializer.dump`.
+            response._fp = io.BytesIO(body)
+
+        # NOTE: This is all a bit weird, but it's really important that on
+        #       Python 2.x these objects are unicode and not str, even when
+        #       they contain only ascii. The problem here is that msgpack
+        #       understands the difference between unicode and bytes and we
+        #       have it set to differentiate between them, however Python 2
+        #       doesn't know the difference. Forcing these to unicode will be
+        #       enough to have msgpack know the difference.
+        data = {
+            u"response": {
+                u"body": body,
+                u"headers": dict(
+                    (text_type(k), text_type(v)) for k, v in response.headers.items()
+                ),
+                u"status": response.status,
+                u"version": response.version,
+                u"reason": text_type(response.reason),
+                u"strict": response.strict,
+                u"decode_content": response.decode_content,
+            }
+        }
+
+        # Construct our vary headers
+        data[u"vary"] = {}
+        if u"vary" in response_headers:
+            varied_headers = response_headers[u"vary"].split(",")
+            for header in varied_headers:
+                header = text_type(header).strip()
+                header_value = request.headers.get(header, None)
+                if header_value is not None:
+                    header_value = text_type(header_value)
+                data[u"vary"][header] = header_value
+
+        return b",".join([b"cc=4", msgpack.dumps(data, use_bin_type=True)])
+
+    def loads(self, request, data):
+        # Short circuit if we've been given an empty set of data
+        if not data:
+            return
+
+        # Determine what version of the serializer the data was serialized
+        # with
+        try:
+            ver, data = data.split(b",", 1)
+        except ValueError:
+            ver = b"cc=0"
+
+        # Make sure that our "ver" is actually a version and isn't a false
+        # positive from a , being in the data stream.
+        if ver[:3] != b"cc=":
+            data = ver + data
+            ver = b"cc=0"
+
+        # Get the version number out of the cc=N
+        ver = ver.split(b"=", 1)[-1].decode("ascii")
+
+        # Dispatch to the actual load method for the given version
+        try:
+            return getattr(self, "_loads_v{}".format(ver))(request, data)
+
+        except AttributeError:
+            # This is a version we don't have a loads function for, so we'll
+            # just treat it as a miss and return None
+            return
+
+    def prepare_response(self, request, cached):
+        """Verify our vary headers match and construct a real urllib3
+        HTTPResponse object.
+        """
+        # Special case the '*' Vary value as it means we cannot actually
+        # determine if the cached response is suitable for this request.
+        # This case is also handled in the controller code when creating
+        # a cache entry, but is left here for backwards compatibility.
+        if "*" in cached.get("vary", {}):
+            return
+
+        # Ensure that the Vary headers for the cached response match our
+        # request
+        for header, value in cached.get("vary", {}).items():
+            if request.headers.get(header, None) != value:
+                return
+
+        body_raw = cached["response"].pop("body")
+
+        headers = CaseInsensitiveDict(data=cached["response"]["headers"])
+        if headers.get("transfer-encoding", "") == "chunked":
+            headers.pop("transfer-encoding")
+
+        cached["response"]["headers"] = headers
+
+        try:
+            body = io.BytesIO(body_raw)
+        except TypeError:
+            # This can happen if cachecontrol serialized to v1 format (pickle)
+            # using Python 2. A Python 2 str(byte string) will be unpickled as
+            # a Python 3 str (unicode string), which will cause the above to
+            # fail with:
+            #
+            #     TypeError: 'str' does not support the buffer interface
+            body = io.BytesIO(body_raw.encode("utf8"))
+
+        return HTTPResponse(body=body, preload_content=False, **cached["response"])
+
+    def _loads_v0(self, request, data):
+        # The original legacy cache data. This doesn't contain enough
+        # information to construct everything we need, so we'll treat this as
+        # a miss.
+        return
+
+    def _loads_v1(self, request, data):
+        try:
+            cached = pickle.loads(data)
+        except ValueError:
+            return
+
+        return self.prepare_response(request, cached)
+
+    def _loads_v2(self, request, data):
+        try:
+            cached = json.loads(zlib.decompress(data).decode("utf8"))
+        except (ValueError, zlib.error):
+            return
+
+        # We need to decode the items that we've base64 encoded
+        cached["response"]["body"] = _b64_decode_bytes(cached["response"]["body"])
+        cached["response"]["headers"] = dict(
+            (_b64_decode_str(k), _b64_decode_str(v))
+            for k, v in cached["response"]["headers"].items()
+        )
+        cached["response"]["reason"] = _b64_decode_str(cached["response"]["reason"])
+        cached["vary"] = dict(
+            (_b64_decode_str(k), _b64_decode_str(v) if v is not None else v)
+            for k, v in cached["vary"].items()
+        )
+
+        return self.prepare_response(request, cached)
+
+    def _loads_v3(self, request, data):
+        # Due to Python 2 encoding issues, it's impossible to know for sure
+        # exactly how to load v3 entries, thus we'll treat these as a miss so
+        # that they get rewritten out as v4 entries.
+        return
+
+    def _loads_v4(self, request, data):
+        try:
+            cached = msgpack.loads(data, raw=False)
+        except ValueError:
+            return
+
+        return self.prepare_response(request, cached)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/wrapper.py b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/wrapper.py
new file mode 100644
index 0000000..d8e6fc6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/wrapper.py
@@ -0,0 +1,29 @@
+from .adapter import CacheControlAdapter
+from .cache import DictCache
+
+
+def CacheControl(
+    sess,
+    cache=None,
+    cache_etags=True,
+    serializer=None,
+    heuristic=None,
+    controller_class=None,
+    adapter_class=None,
+    cacheable_methods=None,
+):
+
+    cache = DictCache() if cache is None else cache
+    adapter_class = adapter_class or CacheControlAdapter
+    adapter = adapter_class(
+        cache,
+        cache_etags=cache_etags,
+        serializer=serializer,
+        heuristic=heuristic,
+        controller_class=controller_class,
+        cacheable_methods=cacheable_methods,
+    )
+    sess.mount("http://", adapter)
+    sess.mount("https://", adapter)
+
+    return sess
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/__init__.py
new file mode 100644
index 0000000..5d52a62
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/__init__.py
@@ -0,0 +1,3 @@
+from .core import contents, where
+
+__version__ = "2020.06.20"
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/__main__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/__main__.py
new file mode 100644
index 0000000..0037634
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/__main__.py
@@ -0,0 +1,12 @@
+import argparse
+
+from pip._vendor.certifi import contents, where
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-c", "--contents", action="store_true")
+args = parser.parse_args()
+
+if args.contents:
+    print(contents())
+else:
+    print(where())
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/cacert.pem b/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/cacert.pem
new file mode 100644
index 0000000..0fd855f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/cacert.pem
@@ -0,0 +1,4620 @@
+
+# Issuer: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
+# Subject: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
+# Label: "GlobalSign Root CA"
+# Serial: 4835703278459707669005204
+# MD5 Fingerprint: 3e:45:52:15:09:51:92:e1:b7:5d:37:9f:b1:87:29:8a
+# SHA1 Fingerprint: b1:bc:96:8b:d4:f4:9d:62:2a:a8:9a:81:f2:15:01:52:a4:1d:82:9c
+# SHA256 Fingerprint: eb:d4:10:40:e4:bb:3e:c7:42:c9:e3:81:d3:1e:f2:a4:1a:48:b6:68:5c:96:e7:ce:f3:c1:df:6c:d4:33:1c:99
+-----BEGIN CERTIFICATE-----
+MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG
+A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv
+b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw
+MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i
+YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT
+aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ
+jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp
+xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp
+1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG
+snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ
+U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8
+9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B
+AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz
+yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE
+38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP
+AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad
+DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME
+HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R2
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R2
+# Label: "GlobalSign Root CA - R2"
+# Serial: 4835703278459682885658125
+# MD5 Fingerprint: 94:14:77:7e:3e:5e:fd:8f:30:bd:41:b0:cf:e7:d0:30
+# SHA1 Fingerprint: 75:e0:ab:b6:13:85:12:27:1c:04:f8:5f:dd:de:38:e4:b7:24:2e:fe
+# SHA256 Fingerprint: ca:42:dd:41:74:5f:d0:b8:1e:b9:02:36:2c:f9:d8:bf:71:9d:a1:bd:1b:1e:fc:94:6f:5b:4c:99:f4:2c:1b:9e
+-----BEGIN CERTIFICATE-----
+MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEgMB4G
+A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNp
+Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1
+MDgwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEG
+A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBAKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPL
+v4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe+3t+c4isUoh7SqbKSaZeqKeMWhG8
+eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTosvNYSuetZfeLQBoZfXklq
+tTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnTlEnLJGKRILzd
+C9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpRl4pa
+zq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCB
+mTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IH
+V2ccHsBqBt5ZtJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5n
+bG9iYWxzaWduLm5ldC9yb290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG
+3lm0mi3f3BmGLjANBgkqhkiG9w0BAQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4Gs
+J0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbBuOmDAGJFtqkIk7mpM0sYmsL4h4hO
+291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yiPqFbQfXf5WRDLenVOavS
+ot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG79G+dwfCMNYxd
+AfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7
+TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
+# Subject: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
+# Label: "Entrust.net Premium 2048 Secure Server CA"
+# Serial: 946069240
+# MD5 Fingerprint: ee:29:31:bc:32:7e:9a:e6:e8:b5:f7:51:b4:34:71:90
+# SHA1 Fingerprint: 50:30:06:09:1d:97:d4:f5:ae:39:f7:cb:e7:92:7d:7d:65:2d:34:31
+# SHA256 Fingerprint: 6d:c4:71:72:e0:1c:bc:b0:bf:62:58:0d:89:5f:e2:b8:ac:9a:d4:f8:73:80:1e:0c:10:b9:c8:37:d2:1e:b1:77
+-----BEGIN CERTIFICATE-----
+MIIEKjCCAxKgAwIBAgIEOGPe+DANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML
+RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp
+bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5
+IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp
+ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0yOTA3
+MjQxNDE1MTJaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3
+LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp
+YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG
+A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq
+K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe
+sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX
+MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT
+XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/
+HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH
+4QIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQUVeSB0RGAvtiJuQijMfmhJAkWuXAwDQYJKoZIhvcNAQEFBQADggEBADub
+j1abMOdTmXx6eadNl9cZlZD7Bh/KM3xGY4+WZiT6QBshJ8rmcnPyT/4xmf3IDExo
+U8aAghOY+rat2l098c5u9hURlIIM7j+VrxGrD9cv3h8Dj1csHsm7mhpElesYT6Yf
+zX1XEC+bBAlahLVu2B064dae0Wx5XnkcFMXj0EyTO2U87d89vqbllRrDtRnDvV5b
+u/8j72gZyxKTJ1wDLW8w0B62GqzeWvfRqqgnpv55gcR5mTNXuhKwqeBCbJPKVt7+
+bYQLCIt+jerXmCHG8+c8eS9enNFMFY3h7CI3zJpDC5fcgJCNs2ebb0gIFVbPv/Er
+fF6adulZkMV8gzURZVE=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
+# Subject: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
+# Label: "Baltimore CyberTrust Root"
+# Serial: 33554617
+# MD5 Fingerprint: ac:b6:94:a5:9c:17:e0:d7:91:52:9b:b1:97:06:a6:e4
+# SHA1 Fingerprint: d4:de:20:d0:5e:66:fc:53:fe:1a:50:88:2c:78:db:28:52:ca:e4:74
+# SHA256 Fingerprint: 16:af:57:a9:f6:76:b0:ab:12:60:95:aa:5e:ba:de:f2:2a:b3:11:19:d6:44:ac:95:cd:4b:93:db:f3:f2:6a:eb
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ
+RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD
+VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX
+DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y
+ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy
+VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr
+mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr
+IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK
+mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu
+XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy
+dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye
+jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1
+BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3
+DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92
+9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx
+jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0
+Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz
+ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS
+R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
+# Subject: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
+# Label: "Entrust Root Certification Authority"
+# Serial: 1164660820
+# MD5 Fingerprint: d6:a5:c3:ed:5d:dd:3e:00:c1:3d:87:92:1f:1d:3f:e4
+# SHA1 Fingerprint: b3:1e:b1:b7:40:e3:6c:84:02:da:dc:37:d4:4d:f5:d4:67:49:52:f9
+# SHA256 Fingerprint: 73:c1:76:43:4f:1b:c6:d5:ad:f4:5b:0e:76:e7:27:28:7c:8d:e5:76:16:c1:e6:e6:14:1a:2b:2c:bc:7d:8e:4c
+-----BEGIN CERTIFICATE-----
+MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC
+VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0
+Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW
+KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl
+cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw
+NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw
+NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy
+ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV
+BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ
+KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo
+Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4
+4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9
+KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI
+rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi
+94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB
+sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi
+gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo
+kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE
+vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA
+A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t
+O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua
+AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP
+9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/
+eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m
+0vdXcDazv/wor3ElhVsT/h5/WrQ8
+-----END CERTIFICATE-----
+
+# Issuer: CN=GeoTrust Global CA O=GeoTrust Inc.
+# Subject: CN=GeoTrust Global CA O=GeoTrust Inc.
+# Label: "GeoTrust Global CA"
+# Serial: 144470
+# MD5 Fingerprint: f7:75:ab:29:fb:51:4e:b7:77:5e:ff:05:3c:99:8e:f5
+# SHA1 Fingerprint: de:28:f4:a4:ff:e5:b9:2f:a3:c5:03:d1:a3:49:a7:f9:96:2a:82:12
+# SHA256 Fingerprint: ff:85:6a:2d:25:1d:cd:88:d3:66:56:f4:50:12:67:98:cf:ab:aa:de:40:79:9c:72:2d:e4:d2:b5:db:36:a7:3a
+-----BEGIN CERTIFICATE-----
+MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT
+MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i
+YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG
+EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg
+R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9
+9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq
+fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv
+iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU
+1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+
+bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW
+MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA
+ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l
+uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn
+Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS
+tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF
+PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un
+hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV
+5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=GeoTrust Universal CA O=GeoTrust Inc.
+# Subject: CN=GeoTrust Universal CA O=GeoTrust Inc.
+# Label: "GeoTrust Universal CA"
+# Serial: 1
+# MD5 Fingerprint: 92:65:58:8b:a2:1a:31:72:73:68:5c:b4:a5:7a:07:48
+# SHA1 Fingerprint: e6:21:f3:35:43:79:05:9a:4b:68:30:9d:8a:2f:74:22:15:87:ec:79
+# SHA256 Fingerprint: a0:45:9b:9f:63:b2:25:59:f5:fa:5d:4c:6d:b3:f9:f7:2f:f1:93:42:03:35:78:f0:73:bf:1d:1b:46:cb:b9:12
+-----BEGIN CERTIFICATE-----
+MIIFaDCCA1CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMQswCQYDVQQGEwJVUzEW
+MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEeMBwGA1UEAxMVR2VvVHJ1c3QgVW5pdmVy
+c2FsIENBMB4XDTA0MDMwNDA1MDAwMFoXDTI5MDMwNDA1MDAwMFowRTELMAkGA1UE
+BhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xHjAcBgNVBAMTFUdlb1RydXN0
+IFVuaXZlcnNhbCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAKYV
+VaCjxuAfjJ0hUNfBvitbtaSeodlyWL0AG0y/YckUHUWCq8YdgNY96xCcOq9tJPi8
+cQGeBvV8Xx7BDlXKg5pZMK4ZyzBIle0iN430SppyZj6tlcDgFgDgEB8rMQ7XlFTT
+QjOgNB0eRXbdT8oYN+yFFXoZCPzVx5zw8qkuEKmS5j1YPakWaDwvdSEYfyh3peFh
+F7em6fgemdtzbvQKoiFs7tqqhZJmr/Z6a4LauiIINQ/PQvE1+mrufislzDoR5G2v
+c7J2Ha3QsnhnGqQ5HFELZ1aD/ThdDc7d8Lsrlh/eezJS/R27tQahsiFepdaVaH/w
+mZ7cRQg+59IJDTWU3YBOU5fXtQlEIGQWFwMCTFMNaN7VqnJNk22CDtucvc+081xd
+VHppCZbW2xHBjXWotM85yM48vCR85mLK4b19p71XZQvk/iXttmkQ3CgaRr0BHdCX
+teGYO8A3ZNY9lO4L4fUorgtWv3GLIylBjobFS1J72HGrH4oVpjuDWtdYAVHGTEHZ
+f9hBZ3KiKN9gg6meyHv8U3NyWfWTehd2Ds735VzZC1U0oqpbtWpU5xPKV+yXbfRe
+Bi9Fi1jUIxaS5BZuKGNZMN9QAZxjiRqf2xeUgnA3wySemkfWWspOqGmJch+RbNt+
+nhutxx9z3SxPGWX9f5NAEC7S8O08ni4oPmkmM8V7AgMBAAGjYzBhMA8GA1UdEwEB
+/wQFMAMBAf8wHQYDVR0OBBYEFNq7LqqwDLiIJlF0XG0D08DYj3rWMB8GA1UdIwQY
+MBaAFNq7LqqwDLiIJlF0XG0D08DYj3rWMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG
+9w0BAQUFAAOCAgEAMXjmx7XfuJRAyXHEqDXsRh3ChfMoWIawC/yOsjmPRFWrZIRc
+aanQmjg8+uUfNeVE44B5lGiku8SfPeE0zTBGi1QrlaXv9z+ZhP015s8xxtxqv6fX
+IwjhmF7DWgh2qaavdy+3YL1ERmrvl/9zlcGO6JP7/TG37FcREUWbMPEaiDnBTzyn
+ANXH/KttgCJwpQzgXQQpAvvLoJHRfNbDflDVnVi+QTjruXU8FdmbyUqDWcDaU/0z
+uzYYm4UPFd3uLax2k7nZAY1IEKj79TiG8dsKxr2EoyNB3tZ3b4XUhRxQ4K5RirqN
+Pnbiucon8l+f725ZDQbYKxek0nxru18UGkiPGkzns0ccjkxFKyDuSN/n3QmOGKja
+QI2SJhFTYXNd673nxE0pN2HrrDktZy4W1vUAg4WhzH92xH3kt0tm7wNFYGm2DFKW
+koRepqO1pD4r2czYG0eq8kTaT/kD6PAUyz/zg97QwVTjt+gKN02LIFkDMBmhLMi9
+ER/frslKxfMnZmaGrGiR/9nmUxwPi1xpZQomyB40w11Re9epnAahNt3ViZS82eQt
+DF4JbAiXfKM9fJP/P6EUp8+1Xevb2xzEdt+Iub1FBZUbrvxGakyvSOPOrg/Sfuvm
+bJxPgWp6ZKy7PtXny3YuxadIwVyQD8vIP/rmMuGNG2+k5o7Y+SlIis5z/iw=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GeoTrust Universal CA 2 O=GeoTrust Inc.
+# Subject: CN=GeoTrust Universal CA 2 O=GeoTrust Inc.
+# Label: "GeoTrust Universal CA 2"
+# Serial: 1
+# MD5 Fingerprint: 34:fc:b8:d0:36:db:9e:14:b3:c2:f2:db:8f:e4:94:c7
+# SHA1 Fingerprint: 37:9a:19:7b:41:85:45:35:0c:a6:03:69:f3:3c:2e:af:47:4f:20:79
+# SHA256 Fingerprint: a0:23:4f:3b:c8:52:7c:a5:62:8e:ec:81:ad:5d:69:89:5d:a5:68:0d:c9:1d:1c:b8:47:7f:33:f8:78:b9:5b:0b
+-----BEGIN CERTIFICATE-----
+MIIFbDCCA1SgAwIBAgIBATANBgkqhkiG9w0BAQUFADBHMQswCQYDVQQGEwJVUzEW
+MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1c3QgVW5pdmVy
+c2FsIENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMjkwMzA0MDUwMDAwWjBHMQswCQYD
+VQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1
+c3QgVW5pdmVyc2FsIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC
+AQCzVFLByT7y2dyxUxpZKeexw0Uo5dfR7cXFS6GqdHtXr0om/Nj1XqduGdt0DE81
+WzILAePb63p3NeqqWuDW6KFXlPCQo3RWlEQwAx5cTiuFJnSCegx2oG9NzkEtoBUG
+FF+3Qs17j1hhNNwqCPkuwwGmIkQcTAeC5lvO0Ep8BNMZcyfwqph/Lq9O64ceJHdq
+XbboW0W63MOhBW9Wjo8QJqVJwy7XQYci4E+GymC16qFjwAGXEHm9ADwSbSsVsaxL
+se4YuU6W3Nx2/zu+z18DwPw76L5GG//aQMJS9/7jOvdqdzXQ2o3rXhhqMcceujwb
+KNZrVMaqW9eiLBsZzKIC9ptZvTdrhrVtgrrY6slWvKk2WP0+GfPtDCapkzj4T8Fd
+IgbQl+rhrcZV4IErKIM6+vR7IVEAvlI4zs1meaj0gVbi0IMJR1FbUGrP20gaXT73
+y/Zl92zxlfgCOzJWgjl6W70viRu/obTo/3+NjN8D8WBOWBFM66M/ECuDmgFz2ZRt
+hAAnZqzwcEAJQpKtT5MNYQlRJNiS1QuUYbKHsu3/mjX/hVTK7URDrBs8FmtISgoc
+QIgfksILAAX/8sgCSqSqqcyZlpwvWOB94b67B9xfBHJcMTTD7F8t4D1kkCLm0ey4
+Lt1ZrtmhN79UNdxzMk+MBB4zsslG8dhcyFVQyWi9qLo2CQIDAQABo2MwYTAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAfBgNV
+HSMEGDAWgBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAOBgNVHQ8BAf8EBAMCAYYwDQYJ
+KoZIhvcNAQEFBQADggIBAGbBxiPz2eAubl/oz66wsCVNK/g7WJtAJDday6sWSf+z
+dXkzoS9tcBc0kf5nfo/sm+VegqlVHy/c1FEHEv6sFj4sNcZj/NwQ6w2jqtB8zNHQ
+L1EuxBRa3ugZ4T7GzKQp5y6EqgYweHZUcyiYWTjgAA1i00J9IZ+uPTqM1fp3DRgr
+Fg5fNuH8KrUwJM/gYwx7WBr+mbpCErGR9Hxo4sjoryzqyX6uuyo9DRXcNJW2GHSo
+ag/HtPQTxORb7QrSpJdMKu0vbBKJPfEncKpqA1Ihn0CoZ1Dy81of398j9tx4TuaY
+T1U6U+Pv8vSfx3zYWK8pIpe44L2RLrB27FcRz+8pRPPphXpgY+RdM4kX2TGq2tbz
+GDVyz4crL2MjhF2EjD9XoIj8mZEoJmmZ1I+XRL6O1UixpCgp8RW04eWe3fiPpm8m
+1wk8OhwRDqZsN/etRIcsKMfYdIKz0G9KV7s1KSegi+ghp4dkNl3M2Basx7InQJJV
+OCiNUW7dFGdTbHFcJoRNdVq2fmBWqU2t+5sel/MN2dKXVHfaPRK34B7vCAas+YWH
+6aLcr34YEoP9VhdBLtUpgn2Z9DH2canPLAEnpQW5qrJITirvn5NSUZU8UnOOVkwX
+QMAJKOSLakhT2+zNVVXxxvjpoixMptEmX36vWkzaH6byHCx+rgIW0lbQL1dTR+iS
+-----END CERTIFICATE-----
+
+# Issuer: CN=AAA Certificate Services O=Comodo CA Limited
+# Subject: CN=AAA Certificate Services O=Comodo CA Limited
+# Label: "Comodo AAA Services root"
+# Serial: 1
+# MD5 Fingerprint: 49:79:04:b0:eb:87:19:ac:47:b0:bc:11:51:9b:74:d0
+# SHA1 Fingerprint: d1:eb:23:a4:6d:17:d6:8f:d9:25:64:c2:f1:f1:60:17:64:d8:e3:49
+# SHA256 Fingerprint: d7:a7:a0:fb:5d:7e:27:31:d7:71:e9:48:4e:bc:de:f7:1d:5f:0c:3e:0a:29:48:78:2b:c8:3e:e0:ea:69:9e:f4
+-----BEGIN CERTIFICATE-----
+MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb
+MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
+GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj
+YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL
+MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
+BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM
+GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP
+ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua
+BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe
+3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4
+YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR
+rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm
+ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU
+oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF
+MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v
+QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t
+b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF
+AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q
+GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz
+Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2
+G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi
+l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3
+smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root Certification Authority O=QuoVadis Limited OU=Root Certification Authority
+# Subject: CN=QuoVadis Root Certification Authority O=QuoVadis Limited OU=Root Certification Authority
+# Label: "QuoVadis Root CA"
+# Serial: 985026699
+# MD5 Fingerprint: 27:de:36:fe:72:b7:00:03:00:9d:f4:f0:1e:6c:04:24
+# SHA1 Fingerprint: de:3f:40:bd:50:93:d3:9b:6c:60:f6:da:bc:07:62:01:00:89:76:c9
+# SHA256 Fingerprint: a4:5e:de:3b:bb:f0:9c:8a:e1:5c:72:ef:c0:72:68:d6:93:a2:1c:99:6f:d5:1e:67:ca:07:94:60:fd:6d:88:73
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 2 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 2 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 2"
+# Serial: 1289
+# MD5 Fingerprint: 5e:39:7b:dd:f8:ba:ec:82:e9:ac:62:ba:0c:54:00:2b
+# SHA1 Fingerprint: ca:3a:fb:cf:12:40:36:4b:44:b2:16:20:88:80:48:39:19:93:7c:f7
+# SHA256 Fingerprint: 85:a0:dd:7d:d7:20:ad:b7:ff:05:f8:3d:54:2b:20:9d:c7:ff:45:28:f7:d6:77:b1:83:89:fe:a5:e5:c4:9e:86
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 3"
+# Serial: 1478
+# MD5 Fingerprint: 31:85:3c:62:94:97:63:b9:aa:fd:89:4e:af:6f:e0:cf
+# SHA1 Fingerprint: 1f:49:14:f7:d8:74:95:1d:dd:ae:02:c0:be:fd:3a:2d:82:75:51:85
+# SHA256 Fingerprint: 18:f1:fc:7f:20:5d:f8:ad:dd:eb:7f:e0:07:dd:57:e3:af:37:5a:9c:4d:8d:73:54:6b:f4:f1:fe:d1:e1:8d:35
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: O=SECOM Trust.net OU=Security Communication RootCA1
+# Subject: O=SECOM Trust.net OU=Security Communication RootCA1
+# Label: "Security Communication Root CA"
+# Serial: 0
+# MD5 Fingerprint: f1:bc:63:6a:54:e0:b5:27:f5:cd:e7:1a:e3:4d:6e:4a
+# SHA1 Fingerprint: 36:b1:2b:49:f9:81:9e:d7:4c:9e:bc:38:0f:c6:56:8f:5d:ac:b2:f7
+# SHA256 Fingerprint: e7:5e:72:ed:9f:56:0e:ec:6e:b4:80:00:73:a4:3f:c3:ad:19:19:5a:39:22:82:01:78:95:97:4a:99:02:6b:6c
+-----BEGIN CERTIFICATE-----
+MIIDWjCCAkKgAwIBAgIBADANBgkqhkiG9w0BAQUFADBQMQswCQYDVQQGEwJKUDEY
+MBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYDVQQLEx5TZWN1cml0eSBDb21t
+dW5pY2F0aW9uIFJvb3RDQTEwHhcNMDMwOTMwMDQyMDQ5WhcNMjMwOTMwMDQyMDQ5
+WjBQMQswCQYDVQQGEwJKUDEYMBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYD
+VQQLEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTEwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQCzs/5/022x7xZ8V6UMbXaKL0u/ZPtM7orw8yl8
+9f/uKuDp6bpbZCKamm8sOiZpUQWZJtzVHGpxxpp9Hp3dfGzGjGdnSj74cbAZJ6kJ
+DKaVv0uMDPpVmDvY6CKhS3E4eayXkmmziX7qIWgGmBSWh9JhNrxtJ1aeV+7AwFb9
+Ms+k2Y7CI9eNqPPYJayX5HA49LY6tJ07lyZDo6G8SVlyTCMwhwFY9k6+HGhWZq/N
+QV3Is00qVUarH9oe4kA92819uZKAnDfdDJZkndwi92SL32HeFZRSFaB9UslLqCHJ
+xrHty8OVYNEP8Ktw+N/LTX7s1vqr2b1/VPKl6Xn62dZ2JChzAgMBAAGjPzA9MB0G
+A1UdDgQWBBSgc0mZaNyFW2XjmygvV5+9M7wHSDALBgNVHQ8EBAMCAQYwDwYDVR0T
+AQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAaECpqLvkT115swW1F7NgE+vG
+kl3g0dNq/vu+m22/xwVtWSDEHPC32oRYAmP6SBbvT6UL90qY8j+eG61Ha2POCEfr
+Uj94nK9NrvjVT8+amCoQQTlSxN3Zmw7vkwGusi7KaEIkQmywszo+zenaSMQVy+n5
+Bw+SUEmK3TGXX8npN6o7WWWXlDLJs58+OmJYxUmtYg5xpTKqL8aJdkNAExNnPaJU
+JRDL8Try2frbSVa7pv6nQTXD4IhhyYjH3zYQIphZ6rBK+1YWc26sTfcioU+tHXot
+RSflMMFe8toTyyVCUZVHA4xsIcx0Qu1T/zOLjw9XARYvz6buyXAiFL39vmwLAw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Sonera Class2 CA O=Sonera
+# Subject: CN=Sonera Class2 CA O=Sonera
+# Label: "Sonera Class 2 Root CA"
+# Serial: 29
+# MD5 Fingerprint: a3:ec:75:0f:2e:88:df:fa:48:01:4e:0b:5c:48:6f:fb
+# SHA1 Fingerprint: 37:f7:6d:e6:07:7c:90:c5:b1:3e:93:1a:b7:41:10:b4:f2:e4:9a:27
+# SHA256 Fingerprint: 79:08:b4:03:14:c1:38:10:0b:51:8d:07:35:80:7f:fb:fc:f8:51:8a:00:95:33:71:05:ba:38:6b:15:3d:d9:27
+-----BEGIN CERTIFICATE-----
+MIIDIDCCAgigAwIBAgIBHTANBgkqhkiG9w0BAQUFADA5MQswCQYDVQQGEwJGSTEP
+MA0GA1UEChMGU29uZXJhMRkwFwYDVQQDExBTb25lcmEgQ2xhc3MyIENBMB4XDTAx
+MDQwNjA3Mjk0MFoXDTIxMDQwNjA3Mjk0MFowOTELMAkGA1UEBhMCRkkxDzANBgNV
+BAoTBlNvbmVyYTEZMBcGA1UEAxMQU29uZXJhIENsYXNzMiBDQTCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBAJAXSjWdyvANlsdE+hY3/Ei9vX+ALTU74W+o
+Z6m/AxxNjG8yR9VBaKQTBME1DJqEQ/xcHf+Js+gXGM2RX/uJ4+q/Tl18GybTdXnt
+5oTjV+WtKcT0OijnpXuENmmz/V52vaMtmdOQTiMofRhj8VQ7Jp12W5dCsv+u8E7s
+3TmVToMGf+dJQMjFAbJUWmYdPfz56TwKnoG4cPABi+QjVHzIrviQHgCWctRUz2Ej
+vOr7nQKV0ba5cTppCD8PtOFCx4j1P5iop7oc4HFx71hXgVB6XGt0Rg6DA5jDjqhu
+8nYybieDwnPz3BjotJPqdURrBGAgcVeHnfO+oJAjPYok4doh28MCAwEAAaMzMDEw
+DwYDVR0TAQH/BAUwAwEB/zARBgNVHQ4ECgQISqCqWITTXjwwCwYDVR0PBAQDAgEG
+MA0GCSqGSIb3DQEBBQUAA4IBAQBazof5FnIVV0sd2ZvnoiYw7JNn39Yt0jSv9zil
+zqsWuasvfDXLrNAPtEwr/IDva4yRXzZ299uzGxnq9LIR/WFxRL8oszodv7ND6J+/
+3DEIcbCdjdY0RzKQxmUk96BKfARzjzlvF4xytb1LyHr4e4PDKE6cCepnP7JnBBvD
+FNr450kkkdAdavphOe9r5yF1BgfYErQhIHBCcYHaPJo2vqZbDWpsmh+Re/n570K6
+Tk6ezAyNlNzZRZxe7EJQY670XcSxEtzKO6gunRRaBXW37Ndj4ro1tgQIkejanZz2
+ZrUYrAqmVCY0M9IbwdR/GjqOC6oybtv8TyWf2TLHllpwrN9M
+-----END CERTIFICATE-----
+
+# Issuer: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
+# Subject: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
+# Label: "XRamp Global CA Root"
+# Serial: 107108908803651509692980124233745014957
+# MD5 Fingerprint: a1:0b:44:b3:ca:10:d8:00:6e:9d:0f:d8:0f:92:0a:d1
+# SHA1 Fingerprint: b8:01:86:d1:eb:9c:86:a5:41:04:cf:30:54:f3:4c:52:b7:e5:58:c6
+# SHA256 Fingerprint: ce:cd:dc:90:50:99:d8:da:df:c5:b1:d2:09:b7:37:cb:e2:c1:8c:fb:2c:10:c0:ff:0b:cf:0d:32:86:fc:1a:a2
+-----BEGIN CERTIFICATE-----
+MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB
+gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk
+MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY
+UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx
+NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3
+dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy
+dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB
+dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6
+38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP
+KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q
+DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4
+qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa
+JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi
+PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P
+BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs
+jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0
+eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD
+ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR
+vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt
+qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa
+IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy
+i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ
+O+7ETPTsJ3xCwnR8gooJybQDJbw=
+-----END CERTIFICATE-----
+
+# Issuer: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
+# Subject: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
+# Label: "Go Daddy Class 2 CA"
+# Serial: 0
+# MD5 Fingerprint: 91:de:06:25:ab:da:fd:32:17:0c:bb:25:17:2a:84:67
+# SHA1 Fingerprint: 27:96:ba:e6:3f:18:01:e2:77:26:1b:a0:d7:77:70:02:8f:20:ee:e4
+# SHA256 Fingerprint: c3:84:6b:f2:4b:9e:93:ca:64:27:4c:0e:c6:7c:1e:cc:5e:02:4f:fc:ac:d2:d7:40:19:35:0e:81:fe:54:6a:e4
+-----BEGIN CERTIFICATE-----
+MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh
+MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE
+YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3
+MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo
+ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg
+MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN
+ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA
+PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w
+wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi
+EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY
+avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+
+YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE
+sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h
+/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5
+IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj
+YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD
+ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy
+OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P
+TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ
+HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER
+dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf
+ReYNnyicsbkqWletNw+vHX/bvZ8=
+-----END CERTIFICATE-----
+
+# Issuer: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
+# Subject: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
+# Label: "Starfield Class 2 CA"
+# Serial: 0
+# MD5 Fingerprint: 32:4a:4b:bb:c8:63:69:9b:be:74:9a:c6:dd:1d:46:24
+# SHA1 Fingerprint: ad:7e:1c:28:b0:64:ef:8f:60:03:40:20:14:c3:d0:e3:37:0e:b5:8a
+# SHA256 Fingerprint: 14:65:fa:20:53:97:b8:76:fa:a6:f0:a9:95:8e:55:90:e4:0f:cc:7f:aa:4f:b7:c2:c8:67:75:21:fb:5f:b6:58
+-----BEGIN CERTIFICATE-----
+MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl
+MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp
+U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw
+NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE
+ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp
+ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3
+DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf
+8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN
++lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0
+X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa
+K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA
+1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G
+A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR
+zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0
+YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD
+bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w
+DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3
+L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D
+eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl
+xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp
+VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY
+WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q=
+-----END CERTIFICATE-----
+
+# Issuer: O=Government Root Certification Authority
+# Subject: O=Government Root Certification Authority
+# Label: "Taiwan GRCA"
+# Serial: 42023070807708724159991140556527066870
+# MD5 Fingerprint: 37:85:44:53:32:45:1f:20:f0:f3:95:e1:25:c4:43:4e
+# SHA1 Fingerprint: f4:8b:11:bf:de:ab:be:94:54:20:71:e6:41:de:6b:be:88:2b:40:b9
+# SHA256 Fingerprint: 76:00:29:5e:ef:e8:5b:9e:1f:d6:24:db:76:06:2a:aa:ae:59:81:8a:54:d2:77:4c:d4:c0:b2:c0:11:31:e1:b3
+-----BEGIN CERTIFICATE-----
+MIIFcjCCA1qgAwIBAgIQH51ZWtcvwgZEpYAIaeNe9jANBgkqhkiG9w0BAQUFADA/
+MQswCQYDVQQGEwJUVzEwMC4GA1UECgwnR292ZXJubWVudCBSb290IENlcnRpZmlj
+YXRpb24gQXV0aG9yaXR5MB4XDTAyMTIwNTEzMjMzM1oXDTMyMTIwNTEzMjMzM1ow
+PzELMAkGA1UEBhMCVFcxMDAuBgNVBAoMJ0dvdmVybm1lbnQgUm9vdCBDZXJ0aWZp
+Y2F0aW9uIEF1dGhvcml0eTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB
+AJoluOzMonWoe/fOW1mKydGGEghU7Jzy50b2iPN86aXfTEc2pBsBHH8eV4qNw8XR
+IePaJD9IK/ufLqGU5ywck9G/GwGHU5nOp/UKIXZ3/6m3xnOUT0b3EEk3+qhZSV1q
+gQdW8or5BtD3cCJNtLdBuTK4sfCxw5w/cP1T3YGq2GN49thTbqGsaoQkclSGxtKy
+yhwOeYHWtXBiCAEuTk8O1RGvqa/lmr/czIdtJuTJV6L7lvnM4T9TjGxMfptTCAts
+F/tnyMKtsc2AtJfcdgEWFelq16TheEfOhtX7MfP6Mb40qij7cEwdScevLJ1tZqa2
+jWR+tSBqnTuBto9AAGdLiYa4zGX+FVPpBMHWXx1E1wovJ5pGfaENda1UhhXcSTvx
+ls4Pm6Dso3pdvtUqdULle96ltqqvKKyskKw4t9VoNSZ63Pc78/1Fm9G7Q3hub/FC
+VGqY8A2tl+lSXunVanLeavcbYBT0peS2cWeqH+riTcFCQP5nRhc4L0c/cZyu5SHK
+YS1tB6iEfC3uUSXxY5Ce/eFXiGvviiNtsea9P63RPZYLhY3Naye7twWb7LuRqQoH
+EgKXTiCQ8P8NHuJBO9NAOueNXdpm5AKwB1KYXA6OM5zCppX7VRluTI6uSw+9wThN
+Xo+EHWbNxWCWtFJaBYmOlXqYwZE8lSOyDvR5tMl8wUohAgMBAAGjajBoMB0GA1Ud
+DgQWBBTMzO/MKWCkO7GStjz6MmKPrCUVOzAMBgNVHRMEBTADAQH/MDkGBGcqBwAE
+MTAvMC0CAQAwCQYFKw4DAhoFADAHBgVnKgMAAAQUA5vwIhP/lSg209yewDL7MTqK
+UWUwDQYJKoZIhvcNAQEFBQADggIBAECASvomyc5eMN1PhnR2WPWus4MzeKR6dBcZ
+TulStbngCnRiqmjKeKBMmo4sIy7VahIkv9Ro04rQ2JyftB8M3jh+Vzj8jeJPXgyf
+qzvS/3WXy6TjZwj/5cAWtUgBfen5Cv8b5Wppv3ghqMKnI6mGq3ZW6A4M9hPdKmaK
+ZEk9GhiHkASfQlK3T8v+R0F2Ne//AHY2RTKbxkaFXeIksB7jSJaYV0eUVXoPQbFE
+JPPB/hprv4j9wabak2BegUqZIJxIZhm1AHlUD7gsL0u8qV1bYH+Mh6XgUmMqvtg7
+hUAV/h62ZT/FS9p+tXo1KaMuephgIqP0fSdOLeq0dDzpD6QzDxARvBMB1uUO07+1
+EqLhRSPAzAhuYbeJq4PjJB7mXQfnHyA+z2fI56wwbSdLaG5LKlwCCDTb+HbkZ6Mm
+nD+iMsJKxYEYMRBWqoTvLQr/uB930r+lWKBi5NdLkXWNiYCYfm3LU05er/ayl4WX
+udpVBrkk7tfGOB5jGxI7leFYrPLfhNVfmS8NVVvmONsuP3LpSIXLuykTjx44Vbnz
+ssQwmSNOXfJIoRIM3BKQCZBUkQM8R+XVyWXgt0t97EfTsws+rZ7QdAAO671RrcDe
+LMDDav7v3Aun+kbfYNucpllQdSNpc5Oy+fwC00fmcc4QAu4njIT/rEUNE1yDMuAl
+pYYsfPQS
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root CA"
+# Serial: 17154717934120587862167794914071425081
+# MD5 Fingerprint: 87:ce:0b:7b:2a:0e:49:00:e1:58:71:9b:37:a8:93:72
+# SHA1 Fingerprint: 05:63:b8:63:0d:62:d7:5a:bb:c8:ab:1e:4b:df:b5:a8:99:b2:4d:43
+# SHA256 Fingerprint: 3e:90:99:b5:01:5e:8f:48:6c:00:bc:ea:9d:11:1e:e7:21:fa:ba:35:5a:89:bc:f1:df:69:56:1e:3d:c6:32:5c
+-----BEGIN CERTIFICATE-----
+MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
+b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
+cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi
+MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c
+JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP
+mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+
+wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4
+VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/
+AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB
+AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
+BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun
+pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC
+dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf
+fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm
+NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx
+H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe
++o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root CA"
+# Serial: 10944719598952040374951832963794454346
+# MD5 Fingerprint: 79:e4:a9:84:0d:7d:3a:96:d7:c0:4f:e2:43:4c:89:2e
+# SHA1 Fingerprint: a8:98:5d:3a:65:e5:e5:c4:b2:d7:d6:6d:40:c6:dd:2f:b1:9c:54:36
+# SHA256 Fingerprint: 43:48:a0:e9:44:4c:78:cb:26:5e:05:8d:5e:89:44:b4:d8:4f:96:62:bd:26:db:25:7f:89:34:a4:43:c7:01:61
+-----BEGIN CERTIFICATE-----
+MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD
+QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT
+MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
+b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB
+CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97
+nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt
+43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P
+T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4
+gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO
+BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR
+TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw
+DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr
+hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg
+06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF
+PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls
+YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk
+CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert High Assurance EV Root CA"
+# Serial: 3553400076410547919724730734378100087
+# MD5 Fingerprint: d4:74:de:57:5c:39:b2:d3:9c:85:83:c5:c0:65:49:8a
+# SHA1 Fingerprint: 5f:b7:ee:06:33:e2:59:db:ad:0c:4c:9a:e6:d3:8f:1a:61:c7:dc:25
+# SHA256 Fingerprint: 74:31:e5:f4:c3:c1:ce:46:90:77:4f:0b:61:e0:54:40:88:3b:a9:a0:1e:d0:0b:a6:ab:d7:80:6e:d3:b1:18:cf
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j
+ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL
+MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3
+LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug
+RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm
++9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW
+PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM
+xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB
+Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3
+hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg
+EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA
+FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec
+nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z
+eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF
+hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2
+Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe
+vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep
++OkuE6N36B9K
+-----END CERTIFICATE-----
+
+# Issuer: CN=DST Root CA X3 O=Digital Signature Trust Co.
+# Subject: CN=DST Root CA X3 O=Digital Signature Trust Co.
+# Label: "DST Root CA X3"
+# Serial: 91299735575339953335919266965803778155
+# MD5 Fingerprint: 41:03:52:dc:0f:f7:50:1b:16:f0:02:8e:ba:6f:45:c5
+# SHA1 Fingerprint: da:c9:02:4f:54:d8:f6:df:94:93:5f:b1:73:26:38:ca:6a:d7:7c:13
+# SHA256 Fingerprint: 06:87:26:03:31:a7:24:03:d9:09:f1:05:e6:9b:cf:0d:32:e1:bd:24:93:ff:c6:d9:20:6d:11:bc:d6:77:07:39
+-----BEGIN CERTIFICATE-----
+MIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmGLvhAazANBgkqhkiG9w0BAQUFADA/
+MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT
+DkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow
+PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD
+Ew5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+AN+v6ZdQCINXtMxiZfaQguzH0yxrMMpb7NnDfcdAwRgUi+DoM3ZJKuM/IUmTrE4O
+rz5Iy2Xu/NMhD2XSKtkyj4zl93ewEnu1lcCJo6m67XMuegwGMoOifooUMM0RoOEq
+OLl5CjH9UL2AZd+3UWODyOKIYepLYYHsUmu5ouJLGiifSKOeDNoJjj4XLh7dIN9b
+xiqKqy69cK3FCxolkHRyxXtqqzTWMIn/5WgTe1QLyNau7Fqckh49ZLOMxt+/yUFw
+7BZy1SbsOFU5Q9D8/RhcQPGX69Wam40dutolucbY38EVAjqr2m7xPi71XAicPNaD
+aeQQmxkqtilX4+U9m5/wAl0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNV
+HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFMSnsaR7LHH62+FLkHX/xBVghYkQMA0GCSqG
+SIb3DQEBBQUAA4IBAQCjGiybFwBcqR7uKGY3Or+Dxz9LwwmglSBd49lZRNI+DT69
+ikugdB/OEIKcdBodfpga3csTS7MgROSR6cz8faXbauX+5v3gTt23ADq1cEmv8uXr
+AvHRAosZy5Q6XkjEGB5YGV8eAlrwDPGxrancWYaLbumR9YbK+rlmM6pZW87ipxZz
+R8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5
+JDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo
+Ob8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ
+-----END CERTIFICATE-----
+
+# Issuer: CN=SwissSign Gold CA - G2 O=SwissSign AG
+# Subject: CN=SwissSign Gold CA - G2 O=SwissSign AG
+# Label: "SwissSign Gold CA - G2"
+# Serial: 13492815561806991280
+# MD5 Fingerprint: 24:77:d9:a8:91:d1:3b:fa:88:2d:c2:ff:f8:cd:33:93
+# SHA1 Fingerprint: d8:c5:38:8a:b7:30:1b:1b:6e:d4:7a:e6:45:25:3a:6f:9f:1a:27:61
+# SHA256 Fingerprint: 62:dd:0b:e9:b9:f5:0a:16:3e:a0:f8:e7:5c:05:3b:1e:ca:57:ea:55:c8:68:8f:64:7c:68:81:f2:c8:35:7b:95
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SwissSign Silver CA - G2 O=SwissSign AG
+# Subject: CN=SwissSign Silver CA - G2 O=SwissSign AG
+# Label: "SwissSign Silver CA - G2"
+# Serial: 5700383053117599563
+# MD5 Fingerprint: e0:06:a1:c9:7d:cf:c9:fc:0d:c0:56:75:96:d8:62:13
+# SHA1 Fingerprint: 9b:aa:e5:9f:56:ee:21:cb:43:5a:be:25:93:df:a7:f0:40:d1:1d:cb
+# SHA256 Fingerprint: be:6c:4d:a2:bb:b9:ba:59:b6:f3:93:97:68:37:42:46:c3:c0:05:99:3f:a9:8f:02:0d:1d:ed:be:d4:8a:81:d5
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=GeoTrust Primary Certification Authority O=GeoTrust Inc.
+# Subject: CN=GeoTrust Primary Certification Authority O=GeoTrust Inc.
+# Label: "GeoTrust Primary Certification Authority"
+# Serial: 32798226551256963324313806436981982369
+# MD5 Fingerprint: 02:26:c3:01:5e:08:30:37:43:a9:d0:7d:cf:37:e6:bf
+# SHA1 Fingerprint: 32:3c:11:8e:1b:f7:b8:b6:52:54:e2:e2:10:0d:d6:02:90:37:f0:96
+# SHA256 Fingerprint: 37:d5:10:06:c5:12:ea:ab:62:64:21:f1:ec:8c:92:01:3f:c5:f8:2a:e9:8e:e5:33:eb:46:19:b8:de:b4:d0:6c
+-----BEGIN CERTIFICATE-----
+MIIDfDCCAmSgAwIBAgIQGKy1av1pthU6Y2yv2vrEoTANBgkqhkiG9w0BAQUFADBY
+MQswCQYDVQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjExMC8GA1UEAxMo
+R2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEx
+MjcwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMFgxCzAJBgNVBAYTAlVTMRYwFAYDVQQK
+Ew1HZW9UcnVzdCBJbmMuMTEwLwYDVQQDEyhHZW9UcnVzdCBQcmltYXJ5IENlcnRp
+ZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEAvrgVe//UfH1nrYNke8hCUy3f9oQIIGHWAVlqnEQRr+92/ZV+zmEwu3qDXwK9
+AWbK7hWNb6EwnL2hhZ6UOvNWiAAxz9juapYC2e0DjPt1befquFUWBRaa9OBesYjA
+ZIVcFU2Ix7e64HXprQU9nceJSOC7KMgD4TCTZF5SwFlwIjVXiIrxlQqD17wxcwE0
+7e9GceBrAqg1cmuXm2bgyxx5X9gaBGgeRwLmnWDiNpcB3841kt++Z8dtd1k7j53W
+kBWUvEI0EME5+bEnPn7WinXFsq+W06Lem+SYvn3h6YGttm/81w7a4DSwDRp35+MI
+mO9Y+pyEtzavwt+s0vQQBnBxNQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G
+A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQULNVQQZcVi/CPNmFbSvtr2ZnJM5IwDQYJ
+KoZIhvcNAQEFBQADggEBAFpwfyzdtzRP9YZRqSa+S7iq8XEN3GHHoOo0Hnp3DwQ1
+6CePbJC/kRYkRj5KTs4rFtULUh38H2eiAkUxT87z+gOneZ1TatnaYzr4gNfTmeGl
+4b7UVXGYNTq+k+qurUKykG/g/CFNNWMziUnWm07Kx+dOCQD32sfvmWKZd7aVIl6K
+oKv0uHiYyjgZmclynnjNS6yvGaBzEi38wkG6gZHaFloxt/m0cYASSJlyc1pZU8Fj
+UjPtp8nSOQJw+uCxQmYpqptR7TBUIhRf2asdweSU8Pj1K/fqynhG1riR/aYNKxoU
+AT6A8EKglQdebc3MS6RFjasS6LPeWuWgfOgPIh1a6Vk=
+-----END CERTIFICATE-----
+
+# Issuer: CN=thawte Primary Root CA O=thawte, Inc. OU=Certification Services Division/(c) 2006 thawte, Inc. - For authorized use only
+# Subject: CN=thawte Primary Root CA O=thawte, Inc. OU=Certification Services Division/(c) 2006 thawte, Inc. - For authorized use only
+# Label: "thawte Primary Root CA"
+# Serial: 69529181992039203566298953787712940909
+# MD5 Fingerprint: 8c:ca:dc:0b:22:ce:f5:be:72:ac:41:1a:11:a8:d8:12
+# SHA1 Fingerprint: 91:c6:d6:ee:3e:8a:c8:63:84:e5:48:c2:99:29:5c:75:6c:81:7b:81
+# SHA256 Fingerprint: 8d:72:2f:81:a9:c1:13:c0:79:1d:f1:36:a2:96:6d:b2:6c:95:0a:97:1d:b4:6b:41:99:f4:ea:54:b7:8b:fb:9f
+-----BEGIN CERTIFICATE-----
+MIIEIDCCAwigAwIBAgIQNE7VVyDV7exJ9C/ON9srbTANBgkqhkiG9w0BAQUFADCB
+qTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf
+Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw
+MDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxHzAdBgNV
+BAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwHhcNMDYxMTE3MDAwMDAwWhcNMzYw
+NzE2MjM1OTU5WjCBqTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5j
+LjEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYG
+A1UECxMvKGMpIDIwMDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNl
+IG9ubHkxHzAdBgNVBAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCsoPD7gFnUnMekz52hWXMJEEUMDSxuaPFs
+W0hoSVk3/AszGcJ3f8wQLZU0HObrTQmnHNK4yZc2AreJ1CRfBsDMRJSUjQJib+ta
+3RGNKJpchJAQeg29dGYvajig4tVUROsdB58Hum/u6f1OCyn1PoSgAfGcq/gcfomk
+6KHYcWUNo1F77rzSImANuVud37r8UVsLr5iy6S7pBOhih94ryNdOwUxkHt3Ph1i6
+Sk/KaAcdHJ1KxtUvkcx8cXIcxcBn6zL9yZJclNqFwJu/U30rCfSMnZEfl2pSy94J
+NqR32HuHUETVPm4pafs5SSYeCaWAe0At6+gnhcn+Yf1+5nyXHdWdAgMBAAGjQjBA
+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBR7W0XP
+r87Lev0xkhpqtvNG61dIUDANBgkqhkiG9w0BAQUFAAOCAQEAeRHAS7ORtvzw6WfU
+DW5FvlXok9LOAz/t2iWwHVfLHjp2oEzsUHboZHIMpKnxuIvW1oeEuzLlQRHAd9mz
+YJ3rG9XRbkREqaYB7FViHXe4XI5ISXycO1cRrK1zN44veFyQaEfZYGDm/Ac9IiAX
+xPcW6cTYcvnIc3zfFi8VqT79aie2oetaupgf1eNNZAqdE8hhuvU5HIe6uL17In/2
+/qxAeeWsEG89jxt5dovEN7MhGITlNgDrYyCZuen+MwS7QcjBAvlEYyCegc5C09Y/
+LHbTY5xZ3Y+m4Q6gLkH3LpVHz7z9M/P2C2F+fpErgUfCJzDupxBdN49cOSvkBPB7
+jVaMaA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G5 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2006 VeriSign, Inc. - For authorized use only
+# Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G5 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2006 VeriSign, Inc. - For authorized use only
+# Label: "VeriSign Class 3 Public Primary Certification Authority - G5"
+# Serial: 33037644167568058970164719475676101450
+# MD5 Fingerprint: cb:17:e4:31:67:3e:e2:09:fe:45:57:93:f3:0a:fa:1c
+# SHA1 Fingerprint: 4e:b6:d5:78:49:9b:1c:cf:5f:58:1e:ad:56:be:3d:9b:67:44:a5:e5
+# SHA256 Fingerprint: 9a:cf:ab:7e:43:c8:d8:80:d0:6b:26:2a:94:de:ee:e4:b4:65:99:89:c3:d0:ca:f1:9b:af:64:05:e4:1a:b7:df
+-----BEGIN CERTIFICATE-----
+MIIE0zCCA7ugAwIBAgIQGNrRniZ96LtKIVjNzGs7SjANBgkqhkiG9w0BAQUFADCB
+yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL
+ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp
+U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW
+ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0
+aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMzYwNzE2MjM1OTU5WjCByjEL
+MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW
+ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJpU2ln
+biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp
+U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y
+aXR5IC0gRzUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvJAgIKXo1
+nmAMqudLO07cfLw8RRy7K+D+KQL5VwijZIUVJ/XxrcgxiV0i6CqqpkKzj/i5Vbex
+t0uz/o9+B1fs70PbZmIVYc9gDaTY3vjgw2IIPVQT60nKWVSFJuUrjxuf6/WhkcIz
+SdhDY2pSS9KP6HBRTdGJaXvHcPaz3BJ023tdS1bTlr8Vd6Gw9KIl8q8ckmcY5fQG
+BO+QueQA5N06tRn/Arr0PO7gi+s3i+z016zy9vA9r911kTMZHRxAy3QkGSGT2RT+
+rCpSx4/VBEnkjWNHiDxpg8v+R70rfk/Fla4OndTRQ8Bnc+MUCH7lP59zuDMKz10/
+NIeWiu5T6CUVAgMBAAGjgbIwga8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8E
+BAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJaW1hZ2UvZ2lmMCEwHzAH
+BgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYjaHR0cDovL2xvZ28udmVy
+aXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFH/TZafC3ey78DAJ80M5+gKv
+MzEzMA0GCSqGSIb3DQEBBQUAA4IBAQCTJEowX2LP2BqYLz3q3JktvXf2pXkiOOzE
+p6B4Eq1iDkVwZMXnl2YtmAl+X6/WzChl8gGqCBpH3vn5fJJaCGkgDdk+bW48DW7Y
+5gaRQBi5+MHt39tBquCWIMnNZBU4gcmU7qKEKQsTb47bDN0lAtukixlE0kF6BWlK
+WE9gyn6CagsCqiUXObXbf+eEZSqVir2G3l6BFoMtEMze/aiCKm0oHw0LxOXnGiYZ
+4fQRbxC1lfznQgUy286dUV4otp6F01vvpX1FQHKOtw5rDgb7MzVIcbidJ4vEZV8N
+hnacRHr2lVz2XTIIM6RUthg/aFzyQkqFOFSDX9HoLPKsEdao7WNq
+-----END CERTIFICATE-----
+
+# Issuer: CN=SecureTrust CA O=SecureTrust Corporation
+# Subject: CN=SecureTrust CA O=SecureTrust Corporation
+# Label: "SecureTrust CA"
+# Serial: 17199774589125277788362757014266862032
+# MD5 Fingerprint: dc:32:c3:a7:6d:25:57:c7:68:09:9d:ea:2d:a9:a2:d1
+# SHA1 Fingerprint: 87:82:c6:c3:04:35:3b:cf:d2:96:92:d2:59:3e:7d:44:d9:34:ff:11
+# SHA256 Fingerprint: f1:c1:b5:0a:e5:a2:0d:d8:03:0e:c9:f6:bc:24:82:3d:d3:67:b5:25:57:59:b4:e7:1b:61:fc:e9:f7:37:5d:73
+-----BEGIN CERTIFICATE-----
+MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI
+MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
+FzAVBgNVBAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIz
+MTE5NDA1NVowSDELMAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENv
+cnBvcmF0aW9uMRcwFQYDVQQDEw5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcN
+AQEBBQADggEPADCCAQoCggEBAKukgeWVzfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEz
+Zum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6pkjGnx29vo6pQT64lO0pGtSO
+0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgUXPLIXgGZbf2IzIao
+wW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPeZqx2pHGj
+7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS
+8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjAT
+BgkrBgEEAYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQUQjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCeg
+JYYjaHR0cDovL2NybC5zZWN1cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGC
+NxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBADDtT0rhWDpSclu1pqNlGKa7UTt3
+6Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+DCMh/bwQf2AQWnL1mA6s7Ll/
+3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr5Fiiu1cprp6poxkm
+D5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUFdAvnZyPS
+CPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR
+3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jE=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Secure Global CA O=SecureTrust Corporation
+# Subject: CN=Secure Global CA O=SecureTrust Corporation
+# Label: "Secure Global CA"
+# Serial: 9751836167731051554232119481456978597
+# MD5 Fingerprint: cf:f4:27:0d:d4:ed:dc:65:16:49:6d:3d:da:bf:6e:de
+# SHA1 Fingerprint: 3a:44:73:5a:e5:81:90:1f:24:86:61:46:1e:3b:9c:c4:5f:f5:3a:1b
+# SHA256 Fingerprint: 42:00:f5:04:3a:c8:59:0e:bb:52:7d:20:9e:d1:50:30:29:fb:cb:d4:1c:a1:b5:06:ec:27:f1:5a:de:7d:ac:69
+-----BEGIN CERTIFICATE-----
+MIIDvDCCAqSgAwIBAgIQB1YipOjUiolN9BPI8PjqpTANBgkqhkiG9w0BAQUFADBK
+MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
+GTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwHhcNMDYxMTA3MTk0MjI4WhcNMjkx
+MjMxMTk1MjA2WjBKMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3Qg
+Q29ycG9yYXRpb24xGTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvNS7YrGxVaQZx5RNoJLNP2MwhR/jxYDiJ
+iQPpvepeRlMJ3Fz1Wuj3RSoC6zFh1ykzTM7HfAo3fg+6MpjhHZevj8fcyTiW89sa
+/FHtaMbQbqR8JNGuQsiWUGMu4P51/pinX0kuleM5M2SOHqRfkNJnPLLZ/kG5VacJ
+jnIFHovdRIWCQtBJwB1g8NEXLJXr9qXBkqPFwqcIYA1gBBCWeZ4WNOaptvolRTnI
+HmX5k/Wq8VLcmZg9pYYaDDUz+kulBAYVHDGA76oYa8J719rO+TMg1fW9ajMtgQT7
+sFzUnKPiXB3jqUJ1XnvUd+85VLrJChgbEplJL4hL/VBi0XPnj3pDAgMBAAGjgZ0w
+gZowEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFK9EBMJBfkiD2045AuzshHrmzsmkMDQGA1UdHwQtMCsw
+KaAnoCWGI2h0dHA6Ly9jcmwuc2VjdXJldHJ1c3QuY29tL1NHQ0EuY3JsMBAGCSsG
+AQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IBAQBjGghAfaReUw132HquHw0L
+URYD7xh8yOOvaliTFGCRsoTciE6+OYo68+aCiV0BN7OrJKQVDpI1WkpEXk5X+nXO
+H0jOZvQ8QCaSmGwb7iRGDBezUqXbpZGRzzfTb+cnCDpOGR86p1hcF895P4vkp9Mm
+I50mD1hp/Ed+stCNi5O/KU9DaXR2Z0vPB4zmAve14bRDtUstFJ/53CYNv6ZHdAbY
+iNE6KTCEztI5gGIbqMdXSbxqVVFnFUq+NQfk1XWYN3kwFNspnWzFacxHVaIw98xc
+f8LDmBxrThaA63p4ZUWiABqvDA1VZDRIuJK58bRQKfJPIx/abKwfROHdI3hRW8cW
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO Certification Authority O=COMODO CA Limited
+# Label: "COMODO Certification Authority"
+# Serial: 104350513648249232941998508985834464573
+# MD5 Fingerprint: 5c:48:dc:f7:42:72:ec:56:94:6d:1c:cc:71:35:80:75
+# SHA1 Fingerprint: 66:31:bf:9e:f7:4f:9e:b6:c9:d5:a6:0c:ba:6a:be:d1:f7:bd:ef:7b
+# SHA256 Fingerprint: 0c:2c:d6:3d:f7:80:6f:a3:99:ed:e8:09:11:6b:57:5b:f8:79:89:f0:65:18:f9:80:8c:86:05:03:17:8b:af:66
+-----BEGIN CERTIFICATE-----
+MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB
+gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G
+A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV
+BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw
+MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl
+YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P
+RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0
+aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3
+UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI
+2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8
+Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp
++2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+
+DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O
+nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW
+/zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g
+PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u
+QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY
+SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv
+IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/
+RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4
+zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd
+BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB
+ZQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C.
+# Subject: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C.
+# Label: "Network Solutions Certificate Authority"
+# Serial: 116697915152937497490437556386812487904
+# MD5 Fingerprint: d3:f3:a6:16:c0:fa:6b:1d:59:b1:2d:96:4d:0e:11:2e
+# SHA1 Fingerprint: 74:f8:a3:c3:ef:e7:b3:90:06:4b:83:90:3c:21:64:60:20:e5:df:ce
+# SHA256 Fingerprint: 15:f0:ba:00:a3:ac:7a:f3:ac:88:4c:07:2b:10:11:a0:77:bd:77:c0:97:f4:01:64:b2:f8:59:8a:bd:83:86:0c
+-----BEGIN CERTIFICATE-----
+MIID5jCCAs6gAwIBAgIQV8szb8JcFuZHFhfjkDFo4DANBgkqhkiG9w0BAQUFADBi
+MQswCQYDVQQGEwJVUzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMu
+MTAwLgYDVQQDEydOZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3Jp
+dHkwHhcNMDYxMjAxMDAwMDAwWhcNMjkxMjMxMjM1OTU5WjBiMQswCQYDVQQGEwJV
+UzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMuMTAwLgYDVQQDEydO
+ZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDkvH6SMG3G2I4rC7xGzuAnlt7e+foS0zwz
+c7MEL7xxjOWftiJgPl9dzgn/ggwbmlFQGiaJ3dVhXRncEg8tCqJDXRfQNJIg6nPP
+OCwGJgl6cvf6UDL4wpPTaaIjzkGxzOTVHzbRijr4jGPiFFlp7Q3Tf2vouAPlT2rl
+mGNpSAW+Lv8ztumXWWn4Zxmuk2GWRBXTcrA/vGp97Eh/jcOrqnErU2lBUzS1sLnF
+BgrEsEX1QV1uiUV7PTsmjHTC5dLRfbIR1PtYMiKagMnc/Qzpf14Dl847ABSHJ3A4
+qY5usyd2mFHgBeMhqxrVhSI8KbWaFsWAqPS7azCPL0YCorEMIuDTAgMBAAGjgZcw
+gZQwHQYDVR0OBBYEFCEwyfsA106Y2oeqKtCnLrFAMadMMA4GA1UdDwEB/wQEAwIB
+BjAPBgNVHRMBAf8EBTADAQH/MFIGA1UdHwRLMEkwR6BFoEOGQWh0dHA6Ly9jcmwu
+bmV0c29sc3NsLmNvbS9OZXR3b3JrU29sdXRpb25zQ2VydGlmaWNhdGVBdXRob3Jp
+dHkuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQC7rkvnt1frf6ott3NHhWrB5KUd5Oc8
+6fRZZXe1eltajSU24HqXLjjAV2CDmAaDn7l2em5Q4LqILPxFzBiwmZVRDuwduIj/
+h1AcgsLj4DKAv6ALR8jDMe+ZZzKATxcheQxpXN5eNK4CtSbqUN9/GGUsyfJj4akH
+/nxxH2szJGoeBfcFaMBqEssuXmHLrijTfsK0ZpEmXzwuJF/LWA/rKOyvEZbz3Htv
+wKeI8lN3s2Berq4o2jUsbzRF0ybh3uxbTydrFny9RAQYgrOJeRcQcT16ohZO9QHN
+pGxlaKFJdlxDydi8NmdspZS11My5vWo1ViHe2MPr+8ukYEywVaCge1ey
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO ECC Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO ECC Certification Authority O=COMODO CA Limited
+# Label: "COMODO ECC Certification Authority"
+# Serial: 41578283867086692638256921589707938090
+# MD5 Fingerprint: 7c:62:ff:74:9d:31:53:5e:68:4a:d5:78:aa:1e:bf:23
+# SHA1 Fingerprint: 9f:74:4e:9f:2b:4d:ba:ec:0f:31:2c:50:b6:56:3b:8e:2d:93:c3:11
+# SHA256 Fingerprint: 17:93:92:7a:06:14:54:97:89:ad:ce:2f:8f:34:f7:f0:b6:6d:0f:3a:e3:a3:b8:4d:21:ec:15:db:ba:4f:ad:c7
+-----BEGIN CERTIFICATE-----
+MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL
+MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
+BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT
+IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw
+MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy
+ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N
+T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv
+biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR
+FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J
+cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW
+BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
+BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm
+fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv
+GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=OISTE WISeKey Global Root GA CA O=WISeKey OU=Copyright (c) 2005/OISTE Foundation Endorsed
+# Subject: CN=OISTE WISeKey Global Root GA CA O=WISeKey OU=Copyright (c) 2005/OISTE Foundation Endorsed
+# Label: "OISTE WISeKey Global Root GA CA"
+# Serial: 86718877871133159090080555911823548314
+# MD5 Fingerprint: bc:6c:51:33:a7:e9:d3:66:63:54:15:72:1b:21:92:93
+# SHA1 Fingerprint: 59:22:a1:e1:5a:ea:16:35:21:f8:98:39:6a:46:46:b0:44:1b:0f:a9
+# SHA256 Fingerprint: 41:c9:23:86:6a:b4:ca:d6:b7:ad:57:80:81:58:2e:02:07:97:a6:cb:df:4f:ff:78:ce:83:96:b3:89:37:d7:f5
+-----BEGIN CERTIFICATE-----
+MIID8TCCAtmgAwIBAgIQQT1yx/RrH4FDffHSKFTfmjANBgkqhkiG9w0BAQUFADCB
+ijELMAkGA1UEBhMCQ0gxEDAOBgNVBAoTB1dJU2VLZXkxGzAZBgNVBAsTEkNvcHly
+aWdodCAoYykgMjAwNTEiMCAGA1UECxMZT0lTVEUgRm91bmRhdGlvbiBFbmRvcnNl
+ZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwgUm9vdCBHQSBDQTAeFw0w
+NTEyMTExNjAzNDRaFw0zNzEyMTExNjA5NTFaMIGKMQswCQYDVQQGEwJDSDEQMA4G
+A1UEChMHV0lTZUtleTEbMBkGA1UECxMSQ29weXJpZ2h0IChjKSAyMDA1MSIwIAYD
+VQQLExlPSVNURSBGb3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBX
+SVNlS2V5IEdsb2JhbCBSb290IEdBIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
+MIIBCgKCAQEAy0+zAJs9Nt350UlqaxBJH+zYK7LG+DKBKUOVTJoZIyEVRd7jyBxR
+VVuuk+g3/ytr6dTqvirdqFEr12bDYVxgAsj1znJ7O7jyTmUIms2kahnBAbtzptf2
+w93NvKSLtZlhuAGio9RN1AU9ka34tAhxZK9w8RxrfvbDd50kc3vkDIzh2TbhmYsF
+mQvtRTEJysIA2/dyoJaqlYfQjse2YXMNdmaM3Bu0Y6Kff5MTMPGhJ9vZ/yxViJGg
+4E8HsChWjBgbl0SOid3gF27nKu+POQoxhILYQBRJLnpB5Kf+42TMwVlxSywhp1t9
+4B3RLoGbw9ho972WG6xwsRYUC9tguSYBBQIDAQABo1EwTzALBgNVHQ8EBAMCAYYw
+DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUswN+rja8sHnR3JQmthG+IbJphpQw
+EAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBAEuh/wuHbrP5wUOx
+SPMowB0uyQlB+pQAHKSkq0lPjz0e701vvbyk9vImMMkQyh2I+3QZH4VFvbBsUfk2
+ftv1TDI6QU9bR8/oCy22xBmddMVHxjtqD6wU2zz0c5ypBd8A3HR4+vg1YFkCExh8
+vPtNsCBtQ7tgMHpnM1zFmdH4LTlSc/uMqpclXHLZCB6rTjzjgTGfA6b7wP4piFXa
+hNVQA7bihKOmNqoROgHhGEvWRGizPflTdISzRpFGlgC3gCy24eMQ4tui5yiPAZZi
+Fj4A4xylNoEYokxSdsARo27mHbrjWr42U8U+dY+GaSlYU7Wcu2+fXMUY7N0v4ZjJ
+/L7fCg0=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certigna O=Dhimyotis
+# Subject: CN=Certigna O=Dhimyotis
+# Label: "Certigna"
+# Serial: 18364802974209362175
+# MD5 Fingerprint: ab:57:a6:5b:7d:42:82:19:b5:d8:58:26:28:5e:fd:ff
+# SHA1 Fingerprint: b1:2e:13:63:45:86:a4:6f:1a:b2:60:68:37:58:2d:c4:ac:fd:94:97
+# SHA256 Fingerprint: e3:b6:a2:db:2e:d7:ce:48:84:2f:7a:c5:32:41:c7:b7:1d:54:14:4b:fb:40:c1:1f:3f:1d:0b:42:f5:ee:a1:2d
+-----BEGIN CERTIFICATE-----
+MIIDqDCCApCgAwIBAgIJAP7c4wEPyUj/MA0GCSqGSIb3DQEBBQUAMDQxCzAJBgNV
+BAYTAkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hMB4X
+DTA3MDYyOTE1MTMwNVoXDTI3MDYyOTE1MTMwNVowNDELMAkGA1UEBhMCRlIxEjAQ
+BgNVBAoMCURoaW15b3RpczERMA8GA1UEAwwIQ2VydGlnbmEwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQDIaPHJ1tazNHUmgh7stL7qXOEm7RFHYeGifBZ4
+QCHkYJ5ayGPhxLGWkv8YbWkj4Sti993iNi+RB7lIzw7sebYs5zRLcAglozyHGxny
+gQcPOJAZ0xH+hrTy0V4eHpbNgGzOOzGTtvKg0KmVEn2lmsxryIRWijOp5yIVUxbw
+zBfsV1/pogqYCd7jX5xv3EjjhQsVWqa6n6xI4wmy9/Qy3l40vhx4XUJbzg4ij02Q
+130yGLMLLGq/jj8UEYkgDncUtT2UCIf3JR7VsmAA7G8qKCVuKj4YYxclPz5EIBb2
+JsglrgVKtOdjLPOMFlN+XPsRGgjBRmKfIrjxwo1p3Po6WAbfAgMBAAGjgbwwgbkw
+DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGu3+QTmQtCRZvgHyUtVF9lo53BEw
+ZAYDVR0jBF0wW4AUGu3+QTmQtCRZvgHyUtVF9lo53BGhOKQ2MDQxCzAJBgNVBAYT
+AkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hggkA/tzj
+AQ/JSP8wDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIABzANBgkqhkiG
+9w0BAQUFAAOCAQEAhQMeknH2Qq/ho2Ge6/PAD/Kl1NqV5ta+aDY9fm4fTIrv0Q8h
+bV6lUmPOEvjvKtpv6zf+EwLHyzs+ImvaYS5/1HI93TDhHkxAGYwP15zRgzB7mFnc
+fca5DClMoTOi62c6ZYTTluLtdkVwj7Ur3vkj1kluPBS1xp81HlDQwY9qcEQCYsuu
+HWhBp6pX6FOqB9IG9tUUBguRA3UsbHK1YZWaDYu5Def131TN3ubY1gkIl2PlwS6w
+t0QmwCbAr1UwnjvVNioZBPRcHv/PLLf/0P2HQBHVESO7SMAhqaQoLf0V+LBOK/Qw
+WyH8EZE0vkHve52Xdf+XlcCWWC/qu0bXu+TZLg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Cybertrust Global Root O=Cybertrust, Inc
+# Subject: CN=Cybertrust Global Root O=Cybertrust, Inc
+# Label: "Cybertrust Global Root"
+# Serial: 4835703278459682877484360
+# MD5 Fingerprint: 72:e4:4a:87:e3:69:40:80:77:ea:bc:e3:f4:ff:f0:e1
+# SHA1 Fingerprint: 5f:43:e5:b1:bf:f8:78:8c:ac:1c:c7:ca:4a:9a:c6:22:2b:cc:34:c6
+# SHA256 Fingerprint: 96:0a:df:00:63:e9:63:56:75:0c:29:65:dd:0a:08:67:da:0b:9c:bd:6e:77:71:4a:ea:fb:23:49:ab:39:3d:a3
+-----BEGIN CERTIFICATE-----
+MIIDoTCCAomgAwIBAgILBAAAAAABD4WqLUgwDQYJKoZIhvcNAQEFBQAwOzEYMBYG
+A1UEChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2Jh
+bCBSb290MB4XDTA2MTIxNTA4MDAwMFoXDTIxMTIxNTA4MDAwMFowOzEYMBYGA1UE
+ChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2JhbCBS
+b290MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA+Mi8vRRQZhP/8NN5
+7CPytxrHjoXxEnOmGaoQ25yiZXRadz5RfVb23CO21O1fWLE3TdVJDm71aofW0ozS
+J8bi/zafmGWgE07GKmSb1ZASzxQG9Dvj1Ci+6A74q05IlG2OlTEQXO2iLb3VOm2y
+HLtgwEZLAfVJrn5GitB0jaEMAs7u/OePuGtm839EAL9mJRQr3RAwHQeWP032a7iP
+t3sMpTjr3kfb1V05/Iin89cqdPHoWqI7n1C6poxFNcJQZZXcY4Lv3b93TZxiyWNz
+FtApD0mpSPCzqrdsxacwOUBdrsTiXSZT8M4cIwhhqJQZugRiQOwfOHB3EgZxpzAY
+XSUnpQIDAQABo4GlMIGiMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/
+MB0GA1UdDgQWBBS2CHsNesysIEyGVjJez6tuhS1wVzA/BgNVHR8EODA2MDSgMqAw
+hi5odHRwOi8vd3d3Mi5wdWJsaWMtdHJ1c3QuY29tL2NybC9jdC9jdHJvb3QuY3Js
+MB8GA1UdIwQYMBaAFLYIew16zKwgTIZWMl7Pq26FLXBXMA0GCSqGSIb3DQEBBQUA
+A4IBAQBW7wojoFROlZfJ+InaRcHUowAl9B8Tq7ejhVhpwjCt2BWKLePJzYFa+HMj
+Wqd8BfP9IjsO0QbE2zZMcwSO5bAi5MXzLqXZI+O4Tkogp24CJJ8iYGd7ix1yCcUx
+XOl5n4BHPa2hCwcUPUf/A2kaDAtE52Mlp3+yybh2hO0j9n0Hq0V+09+zv+mKts2o
+omcrUtW3ZfA5TGOgkXmTUg9U3YO7n9GPp1Nzw8v/MOx8BLjYRB+TX3EJIrduPuoc
+A06dGiBh+4E37F78CkWr1+cXVdCg6mCbpvbjjFspwgZgFJ0tl0ypkxWdYcQBX0jW
+WL1WMRJOEcgh4LMRkWXbtKaIOM5V
+-----END CERTIFICATE-----
+
+# Issuer: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority
+# Subject: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority
+# Label: "ePKI Root Certification Authority"
+# Serial: 28956088682735189655030529057352760477
+# MD5 Fingerprint: 1b:2e:00:ca:26:06:90:3d:ad:fe:6f:15:68:d3:6b:b3
+# SHA1 Fingerprint: 67:65:0d:f1:7e:8e:7e:5b:82:40:a4:f4:56:4b:cf:e2:3d:69:c6:f0
+# SHA256 Fingerprint: c0:a6:f4:dc:63:a2:4b:fd:cf:54:ef:2a:6a:08:2a:0a:72:de:35:80:3e:2f:f5:ff:52:7a:e5:d8:72:06:df:d5
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: O=certSIGN OU=certSIGN ROOT CA
+# Subject: O=certSIGN OU=certSIGN ROOT CA
+# Label: "certSIGN ROOT CA"
+# Serial: 35210227249154
+# MD5 Fingerprint: 18:98:c0:d6:e9:3a:fc:f9:b0:f5:0c:f7:4b:01:44:17
+# SHA1 Fingerprint: fa:b7:ee:36:97:26:62:fb:2d:b0:2a:f6:bf:03:fd:e8:7c:4b:2f:9b
+# SHA256 Fingerprint: ea:a9:62:c4:fa:4a:6b:af:eb:e4:15:19:6d:35:1c:cd:88:8d:4f:53:f3:fa:8a:e6:d7:c4:66:a9:4e:60:42:bb
+-----BEGIN CERTIFICATE-----
+MIIDODCCAiCgAwIBAgIGIAYFFnACMA0GCSqGSIb3DQEBBQUAMDsxCzAJBgNVBAYT
+AlJPMREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBD
+QTAeFw0wNjA3MDQxNzIwMDRaFw0zMTA3MDQxNzIwMDRaMDsxCzAJBgNVBAYTAlJP
+MREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBDQTCC
+ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALczuX7IJUqOtdu0KBuqV5Do
+0SLTZLrTk+jUrIZhQGpgV2hUhE28alQCBf/fm5oqrl0Hj0rDKH/v+yv6efHHrfAQ
+UySQi2bJqIirr1qjAOm+ukbuW3N7LBeCgV5iLKECZbO9xSsAfsT8AzNXDe3i+s5d
+RdY4zTW2ssHQnIFKquSyAVwdj1+ZxLGt24gh65AIgoDzMKND5pCCrlUoSe1b16kQ
+OA7+j0xbm0bqQfWwCHTD0IgztnzXdN/chNFDDnU5oSVAKOp4yw4sLjmdjItuFhwv
+JoIQ4uNllAoEwF73XVv4EOLQunpL+943AAAaWyjj0pxzPjKHmKHJUS/X3qwzs08C
+AwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0O
+BBYEFOCMm9slSbPxfIbWskKHC9BroNnkMA0GCSqGSIb3DQEBBQUAA4IBAQA+0hyJ
+LjX8+HXd5n9liPRyTMks1zJO890ZeUe9jjtbkw9QSSQTaxQGcu8J06Gh40CEyecY
+MnQ8SG4Pn0vU9x7Tk4ZkVJdjclDVVc/6IJMCopvDI5NOFlV2oHB5bc0hH88vLbwZ
+44gx+FkagQnIl6Z0x2DEW8xXjrJ1/RsCCdtZb3KTafcxQdaIOL+Hsr0Wefmq5L6I
+Jd1hJyMctTEHBDa0GpC9oHRxUIltvBTjD4au8as+x6AJzKNI0eDbZOeStc+vckNw
+i/nDhDwTqn6Sm1dTk/pwwpEOMfmbZ13pljheX7NzTogVZ96edhBiIL5VaZVDADlN
+9u6wWk5JRFRYX0KD
+-----END CERTIFICATE-----
+
+# Issuer: CN=GeoTrust Primary Certification Authority - G3 O=GeoTrust Inc. OU=(c) 2008 GeoTrust Inc. - For authorized use only
+# Subject: CN=GeoTrust Primary Certification Authority - G3 O=GeoTrust Inc. OU=(c) 2008 GeoTrust Inc. - For authorized use only
+# Label: "GeoTrust Primary Certification Authority - G3"
+# Serial: 28809105769928564313984085209975885599
+# MD5 Fingerprint: b5:e8:34:36:c9:10:44:58:48:70:6d:2e:83:d4:b8:05
+# SHA1 Fingerprint: 03:9e:ed:b8:0b:e7:a0:3c:69:53:89:3b:20:d2:d9:32:3a:4c:2a:fd
+# SHA256 Fingerprint: b4:78:b8:12:25:0d:f8:78:63:5c:2a:a7:ec:7d:15:5e:aa:62:5e:e8:29:16:e2:cd:29:43:61:88:6c:d1:fb:d4
+-----BEGIN CERTIFICATE-----
+MIID/jCCAuagAwIBAgIQFaxulBmyeUtB9iepwxgPHzANBgkqhkiG9w0BAQsFADCB
+mDELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsT
+MChjKSAyMDA4IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25s
+eTE2MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhv
+cml0eSAtIEczMB4XDTA4MDQwMjAwMDAwMFoXDTM3MTIwMTIzNTk1OVowgZgxCzAJ
+BgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykg
+MjAwOCBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0
+BgNVBAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg
+LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANziXmJYHTNXOTIz
++uvLh4yn1ErdBojqZI4xmKU4kB6Yzy5jK/BGvESyiaHAKAxJcCGVn2TAppMSAmUm
+hsalifD614SgcK9PGpc/BkTVyetyEH3kMSj7HGHmKAdEc5IiaacDiGydY8hS2pgn
+5whMcD60yRLBxWeDXTPzAxHsatBT4tG6NmCUgLthY2xbF37fQJQeqw3CIShwiP/W
+JmxsYAQlTlV+fe+/lEjetx3dcI0FX4ilm/LC7urRQEFtYjgdVgbFA0dRIBn8exAL
+DmKudlW/X3e+PkkBUz2YJQN2JFodtNuJ6nnltrM7P7pMKEF/BqxqjsHQ9gUdfeZC
+huOl1UcCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw
+HQYDVR0OBBYEFMR5yo6hTgMdHNxr2zFblD4/MH8tMA0GCSqGSIb3DQEBCwUAA4IB
+AQAtxRPPVoB7eni9n64smefv2t+UXglpp+duaIy9cr5HqQ6XErhK8WTTOd8lNNTB
+zU6B8A8ExCSzNJbGpqow32hhc9f5joWJ7w5elShKKiePEI4ufIbEAp7aDHdlDkQN
+kv39sxY2+hENHYwOB4lqKVb3cvTdFZx3NWZXqxNT2I7BQMXXExZacse3aQHEerGD
+AWh9jUGhlBjBJVz88P6DAod8DQ3PLghcSkANPuyBYeYk28rgDi0Hsj5W3I31QYUH
+SJsMC8tJP33st/3LjWeJGqvtux6jAAgIFyqCXDFdRootD4abdNlF+9RAsXqqaC2G
+spki4cErx5z481+oghLrGREt
+-----END CERTIFICATE-----
+
+# Issuer: CN=thawte Primary Root CA - G2 O=thawte, Inc. OU=(c) 2007 thawte, Inc. - For authorized use only
+# Subject: CN=thawte Primary Root CA - G2 O=thawte, Inc. OU=(c) 2007 thawte, Inc. - For authorized use only
+# Label: "thawte Primary Root CA - G2"
+# Serial: 71758320672825410020661621085256472406
+# MD5 Fingerprint: 74:9d:ea:60:24:c4:fd:22:53:3e:cc:3a:72:d9:29:4f
+# SHA1 Fingerprint: aa:db:bc:22:23:8f:c4:01:a1:27:bb:38:dd:f4:1d:db:08:9e:f0:12
+# SHA256 Fingerprint: a4:31:0d:50:af:18:a6:44:71:90:37:2a:86:af:af:8b:95:1f:fb:43:1d:83:7f:1e:56:88:b4:59:71:ed:15:57
+-----BEGIN CERTIFICATE-----
+MIICiDCCAg2gAwIBAgIQNfwmXNmET8k9Jj1Xm67XVjAKBggqhkjOPQQDAzCBhDEL
+MAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjE4MDYGA1UECxMvKGMp
+IDIwMDcgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAi
+BgNVBAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMjAeFw0wNzExMDUwMDAw
+MDBaFw0zODAxMTgyMzU5NTlaMIGEMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhh
+d3RlLCBJbmMuMTgwNgYDVQQLEy8oYykgMjAwNyB0aGF3dGUsIEluYy4gLSBGb3Ig
+YXV0aG9yaXplZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9v
+dCBDQSAtIEcyMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEotWcgnuVnfFSeIf+iha/
+BebfowJPDQfGAFG6DAJSLSKkQjnE/o/qycG+1E3/n3qe4rF8mq2nhglzh9HnmuN6
+papu+7qzcMBniKI11KOasf2twu8x+qi58/sIxpHR+ymVo0IwQDAPBgNVHRMBAf8E
+BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUmtgAMADna3+FGO6Lts6K
+DPgR4bswCgYIKoZIzj0EAwMDaQAwZgIxAN344FdHW6fmCsO99YCKlzUNG4k8VIZ3
+KMqh9HneteY4sPBlcIx/AlTCv//YoT7ZzwIxAMSNlPzcU9LcnXgWHxUzI1NS41ox
+XZ3Krr0TKUQNJ1uo52icEvdYPy5yAlejj6EULg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=thawte Primary Root CA - G3 O=thawte, Inc. OU=Certification Services Division/(c) 2008 thawte, Inc. - For authorized use only
+# Subject: CN=thawte Primary Root CA - G3 O=thawte, Inc. OU=Certification Services Division/(c) 2008 thawte, Inc. - For authorized use only
+# Label: "thawte Primary Root CA - G3"
+# Serial: 127614157056681299805556476275995414779
+# MD5 Fingerprint: fb:1b:5d:43:8a:94:cd:44:c6:76:f2:43:4b:47:e7:31
+# SHA1 Fingerprint: f1:8b:53:8d:1b:e9:03:b6:a6:f0:56:43:5b:17:15:89:ca:f3:6b:f2
+# SHA256 Fingerprint: 4b:03:f4:58:07:ad:70:f2:1b:fc:2c:ae:71:c9:fd:e4:60:4c:06:4c:f5:ff:b6:86:ba:e5:db:aa:d7:fd:d3:4c
+-----BEGIN CERTIFICATE-----
+MIIEKjCCAxKgAwIBAgIQYAGXt0an6rS0mtZLL/eQ+zANBgkqhkiG9w0BAQsFADCB
+rjELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf
+Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw
+MDggdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAiBgNV
+BAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMzAeFw0wODA0MDIwMDAwMDBa
+Fw0zNzEyMDEyMzU5NTlaMIGuMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhhd3Rl
+LCBJbmMuMSgwJgYDVQQLEx9DZXJ0aWZpY2F0aW9uIFNlcnZpY2VzIERpdmlzaW9u
+MTgwNgYDVQQLEy8oYykgMjAwOCB0aGF3dGUsIEluYy4gLSBGb3IgYXV0aG9yaXpl
+ZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9vdCBDQSAtIEcz
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsr8nLPvb2FvdeHsbnndm
+gcs+vHyu86YnmjSjaDFxODNi5PNxZnmxqWWjpYvVj2AtP0LMqmsywCPLLEHd5N/8
+YZzic7IilRFDGF/Eth9XbAoFWCLINkw6fKXRz4aviKdEAhN0cXMKQlkC+BsUa0Lf
+b1+6a4KinVvnSr0eAXLbS3ToO39/fR8EtCab4LRarEc9VbjXsCZSKAExQGbY2SS9
+9irY7CFJXJv2eul/VTV+lmuNk5Mny5K76qxAwJ/C+IDPXfRa3M50hqY+bAtTyr2S
+zhkGcuYMXDhpxwTWvGzOW/b3aJzcJRVIiKHpqfiYnODz1TEoYRFsZ5aNOZnLwkUk
+OQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNV
+HQ4EFgQUrWyqlGCc7eT/+j4KdCtjA/e2Wb8wDQYJKoZIhvcNAQELBQADggEBABpA
+2JVlrAmSicY59BDlqQ5mU1143vokkbvnRFHfxhY0Cu9qRFHqKweKA3rD6z8KLFIW
+oCtDuSWQP3CpMyVtRRooOyfPqsMpQhvfO0zAMzRbQYi/aytlryjvsvXDqmbOe1bu
+t8jLZ8HJnBoYuMTDSQPxYA5QzUbF83d597YV4Djbxy8ooAw/dyZ02SUS2jHaGh7c
+KUGRIjxpp7sC8rZcJwOJ9Abqm+RyguOhCcHpABnTPtRwa7pxpqpYrvS76Wy274fM
+m7v/OeZWYdMKp8RcTGB7BXcmer/YB1IsYvdwY9k5vG8cwnncdimvzsUsZAReiDZu
+MdRAGmI0Nj81Aa6sY6A=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GeoTrust Primary Certification Authority - G2 O=GeoTrust Inc. OU=(c) 2007 GeoTrust Inc. - For authorized use only
+# Subject: CN=GeoTrust Primary Certification Authority - G2 O=GeoTrust Inc. OU=(c) 2007 GeoTrust Inc. - For authorized use only
+# Label: "GeoTrust Primary Certification Authority - G2"
+# Serial: 80682863203381065782177908751794619243
+# MD5 Fingerprint: 01:5e:d8:6b:bd:6f:3d:8e:a1:31:f8:12:e0:98:73:6a
+# SHA1 Fingerprint: 8d:17:84:d5:37:f3:03:7d:ec:70:fe:57:8b:51:9a:99:e6:10:d7:b0
+# SHA256 Fingerprint: 5e:db:7a:c4:3b:82:a0:6a:87:61:e8:d7:be:49:79:eb:f2:61:1f:7d:d7:9b:f9:1c:1c:6b:56:6a:21:9e:d7:66
+-----BEGIN CERTIFICATE-----
+MIICrjCCAjWgAwIBAgIQPLL0SAoA4v7rJDteYD7DazAKBggqhkjOPQQDAzCBmDEL
+MAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsTMChj
+KSAyMDA3IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTE2
+MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0
+eSAtIEcyMB4XDTA3MTEwNTAwMDAwMFoXDTM4MDExODIzNTk1OVowgZgxCzAJBgNV
+BAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykgMjAw
+NyBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0BgNV
+BAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBH
+MjB2MBAGByqGSM49AgEGBSuBBAAiA2IABBWx6P0DFUPlrOuHNxFi79KDNlJ9RVcL
+So17VDs6bl8VAsBQps8lL33KSLjHUGMcKiEIfJo22Av+0SbFWDEwKCXzXV2juLal
+tJLtbCyf691DiaI8S0iRHVDsJt/WYC69IaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO
+BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBVfNVdRVfslsq0DafwBo/q+EVXVMAoG
+CCqGSM49BAMDA2cAMGQCMGSWWaboCd6LuvpaiIjwH5HTRqjySkwCY/tsXzjbLkGT
+qQ7mndwxHLKgpxgceeHHNgIwOlavmnRs9vuD4DPTCF+hnMJbn0bWtsuRBmOiBucz
+rD6ogRLQy7rQkgu2npaqBA+K
+-----END CERTIFICATE-----
+
+# Issuer: CN=VeriSign Universal Root Certification Authority O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2008 VeriSign, Inc. - For authorized use only
+# Subject: CN=VeriSign Universal Root Certification Authority O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2008 VeriSign, Inc. - For authorized use only
+# Label: "VeriSign Universal Root Certification Authority"
+# Serial: 85209574734084581917763752644031726877
+# MD5 Fingerprint: 8e:ad:b5:01:aa:4d:81:e4:8c:1d:d1:e1:14:00:95:19
+# SHA1 Fingerprint: 36:79:ca:35:66:87:72:30:4d:30:a5:fb:87:3b:0f:a7:7b:b7:0d:54
+# SHA256 Fingerprint: 23:99:56:11:27:a5:71:25:de:8c:ef:ea:61:0d:df:2f:a0:78:b5:c8:06:7f:4e:82:82:90:bf:b8:60:e8:4b:3c
+-----BEGIN CERTIFICATE-----
+MIIEuTCCA6GgAwIBAgIQQBrEZCGzEyEDDrvkEhrFHTANBgkqhkiG9w0BAQsFADCB
+vTELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL
+ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwOCBWZXJp
+U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MTgwNgYDVQQDEy9W
+ZXJpU2lnbiBVbml2ZXJzYWwgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe
+Fw0wODA0MDIwMDAwMDBaFw0zNzEyMDEyMzU5NTlaMIG9MQswCQYDVQQGEwJVUzEX
+MBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlTaWduIFRydXN0
+IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA4IFZlcmlTaWduLCBJbmMuIC0gRm9y
+IGF1dGhvcml6ZWQgdXNlIG9ubHkxODA2BgNVBAMTL1ZlcmlTaWduIFVuaXZlcnNh
+bCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEF
+AAOCAQ8AMIIBCgKCAQEAx2E3XrEBNNti1xWb/1hajCMj1mCOkdeQmIN65lgZOIzF
+9uVkhbSicfvtvbnazU0AtMgtc6XHaXGVHzk8skQHnOgO+k1KxCHfKWGPMiJhgsWH
+H26MfF8WIFFE0XBPV+rjHOPMee5Y2A7Cs0WTwCznmhcrewA3ekEzeOEz4vMQGn+H
+LL729fdC4uW/h2KJXwBL38Xd5HVEMkE6HnFuacsLdUYI0crSK5XQz/u5QGtkjFdN
+/BMReYTtXlT2NJ8IAfMQJQYXStrxHXpma5hgZqTZ79IugvHw7wnqRMkVauIDbjPT
+rJ9VAMf2CGqUuV/c4DPxhGD5WycRtPwW8rtWaoAljQIDAQABo4GyMIGvMA8GA1Ud
+EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMG0GCCsGAQUFBwEMBGEwX6FdoFsw
+WTBXMFUWCWltYWdlL2dpZjAhMB8wBwYFKw4DAhoEFI/l0xqGrI2Oa8PPgGrUSBgs
+exkuMCUWI2h0dHA6Ly9sb2dvLnZlcmlzaWduLmNvbS92c2xvZ28uZ2lmMB0GA1Ud
+DgQWBBS2d/ppSEefUxLVwuoHMnYH0ZcHGTANBgkqhkiG9w0BAQsFAAOCAQEASvj4
+sAPmLGd75JR3Y8xuTPl9Dg3cyLk1uXBPY/ok+myDjEedO2Pzmvl2MpWRsXe8rJq+
+seQxIcaBlVZaDrHC1LGmWazxY8u4TB1ZkErvkBYoH1quEPuBUDgMbMzxPcP1Y+Oz
+4yHJJDnp/RVmRvQbEdBNc6N9Rvk97ahfYtTxP/jgdFcrGJ2BtMQo2pSXpXDrrB2+
+BxHw1dvd5Yzw1TKwg+ZX4o+/vqGqvz0dtdQ46tewXDpPaj+PwGZsY6rp2aQW9IHR
+lRQOfc2VNNnSj3BzgXucfr2YYdhFh5iQxeuGMMY1v/D/w1WIg0vvBZIGcfK4mJO3
+7M2CYfE45k+XmCpajQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G4 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2007 VeriSign, Inc. - For authorized use only
+# Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G4 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2007 VeriSign, Inc. - For authorized use only
+# Label: "VeriSign Class 3 Public Primary Certification Authority - G4"
+# Serial: 63143484348153506665311985501458640051
+# MD5 Fingerprint: 3a:52:e1:e7:fd:6f:3a:e3:6f:f3:6f:99:1b:f9:22:41
+# SHA1 Fingerprint: 22:d5:d8:df:8f:02:31:d1:8d:f7:9d:b7:cf:8a:2d:64:c9:3f:6c:3a
+# SHA256 Fingerprint: 69:dd:d7:ea:90:bb:57:c9:3e:13:5d:c8:5e:a6:fc:d5:48:0b:60:32:39:bd:c4:54:fc:75:8b:2a:26:cf:7f:79
+-----BEGIN CERTIFICATE-----
+MIIDhDCCAwqgAwIBAgIQL4D+I4wOIg9IZxIokYesszAKBggqhkjOPQQDAzCByjEL
+MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW
+ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2ln
+biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp
+U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y
+aXR5IC0gRzQwHhcNMDcxMTA1MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCByjELMAkG
+A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZWZXJp
+U2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2lnbiwg
+SW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJpU2ln
+biBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5
+IC0gRzQwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASnVnp8Utpkmw4tXNherJI9/gHm
+GUo9FANL+mAnINmDiWn6VMaaGF5VKmTeBvaNSjutEDxlPZCIBIngMGGzrl0Bp3ve
+fLK+ymVhAIau2o970ImtTR1ZmkGxvEeA3J5iw/mjgbIwga8wDwYDVR0TAQH/BAUw
+AwEB/zAOBgNVHQ8BAf8EBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJ
+aW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYj
+aHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFLMW
+kf3upm7ktS5Jj4d4gYDs5bG1MAoGCCqGSM49BAMDA2gAMGUCMGYhDBgmYFo4e1ZC
+4Kf8NoRRkSAsdk1DPcQdhCPQrNZ8NQbOzWm9kA3bbEhCHQ6qQgIxAJw9SDkjOVga
+FRJZap7v1VmyHVIsmXHNxynfGyphe3HR3vPA5Q06Sqotp9iGKt0uEA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services)
+# Subject: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services)
+# Label: "NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny"
+# Serial: 80544274841616
+# MD5 Fingerprint: c5:a1:b7:ff:73:dd:d6:d7:34:32:18:df:fc:3c:ad:88
+# SHA1 Fingerprint: 06:08:3f:59:3f:15:a1:04:a0:69:a4:6b:a9:03:d0:06:b7:97:09:91
+# SHA256 Fingerprint: 6c:61:da:c3:a2:de:f0:31:50:6b:e0:36:d2:a6:fe:40:19:94:fb:d1:3d:f9:c8:d4:66:59:92:74:c4:46:ec:98
+-----BEGIN CERTIFICATE-----
+MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQG
+EwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3
+MDUGA1UECwwuVGFuw7pzw610dsOhbnlraWFkw7NrIChDZXJ0aWZpY2F0aW9uIFNl
+cnZpY2VzKTE1MDMGA1UEAwwsTmV0TG9jayBBcmFueSAoQ2xhc3MgR29sZCkgRsWR
+dGFuw7pzw610dsOhbnkwHhcNMDgxMjExMTUwODIxWhcNMjgxMjA2MTUwODIxWjCB
+pzELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRUwEwYDVQQKDAxOZXRM
+b2NrIEtmdC4xNzA1BgNVBAsMLlRhbsO6c8OtdHbDoW55a2lhZMOzayAoQ2VydGlm
+aWNhdGlvbiBTZXJ2aWNlcykxNTAzBgNVBAMMLE5ldExvY2sgQXJhbnkgKENsYXNz
+IEdvbGQpIEbFkXRhbsO6c8OtdHbDoW55MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
+MIIBCgKCAQEAxCRec75LbRTDofTjl5Bu0jBFHjzuZ9lk4BqKf8owyoPjIMHj9DrT
+lF8afFttvzBPhCf2nx9JvMaZCpDyD/V/Q4Q3Y1GLeqVw/HpYzY6b7cNGbIRwXdrz
+AZAj/E4wqX7hJ2Pn7WQ8oLjJM2P+FpD/sLj916jAwJRDC7bVWaaeVtAkH3B5r9s5
+VA1lddkVQZQBr17s9o3x/61k/iCa11zr/qYfCGSji3ZVrR47KGAuhyXoqq8fxmRG
+ILdwfzzeSNuWU7c5d+Qa4scWhHaXWy+7GRWF+GmF9ZmnqfI0p6m2pgP8b4Y9VHx2
+BJtr+UBdADTHLpl1neWIA6pN+APSQnbAGwIDAKiLo0UwQzASBgNVHRMBAf8ECDAG
+AQH/AgEEMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUzPpnk/C2uNClwB7zU/2M
+U9+D15YwDQYJKoZIhvcNAQELBQADggEBAKt/7hwWqZw8UQCgwBEIBaeZ5m8BiFRh
+bvG5GK1Krf6BQCOUL/t1fC8oS2IkgYIL9WHxHG64YTjrgfpioTtaYtOUZcTh5m2C
++C8lcLIhJsFyUR+MLMOEkMNaj7rP9KdlpeuY0fsFskZ1FSNqb4VjMIDw1Z4fKRzC
+bLBQWV2QWzuoDTDPv31/zvGdg73JRm4gpvlhUbohL3u+pRVjodSVh/GeufOJ8z2F
+uLjbvrW5KfnaNwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2
+XjG4Kvte9nHfRCaexOYNkbQudZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Hongkong Post Root CA 1 O=Hongkong Post
+# Subject: CN=Hongkong Post Root CA 1 O=Hongkong Post
+# Label: "Hongkong Post Root CA 1"
+# Serial: 1000
+# MD5 Fingerprint: a8:0d:6f:39:78:b9:43:6d:77:42:6d:98:5a:cc:23:ca
+# SHA1 Fingerprint: d6:da:a8:20:8d:09:d2:15:4d:24:b5:2f:cb:34:6e:b2:58:b2:8a:58
+# SHA256 Fingerprint: f9:e6:7d:33:6c:51:00:2a:c0:54:c6:32:02:2d:66:dd:a2:e7:e3:ff:f1:0a:d0:61:ed:31:d8:bb:b4:10:cf:b2
+-----BEGIN CERTIFICATE-----
+MIIDMDCCAhigAwIBAgICA+gwDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UEBhMCSEsx
+FjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdrb25nIFBvc3Qg
+Um9vdCBDQSAxMB4XDTAzMDUxNTA1MTMxNFoXDTIzMDUxNTA0NTIyOVowRzELMAkG
+A1UEBhMCSEsxFjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdr
+b25nIFBvc3QgUm9vdCBDQSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEArP84tulmAknjorThkPlAj3n54r15/gK97iSSHSL22oVyaf7XPwnU3ZG1ApzQ
+jVrhVcNQhrkpJsLj2aDxaQMoIIBFIi1WpztUlVYiWR8o3x8gPW2iNr4joLFutbEn
+PzlTCeqrauh0ssJlXI6/fMN4hM2eFvz1Lk8gKgifd/PFHsSaUmYeSF7jEAaPIpjh
+ZY4bXSNmO7ilMlHIhqqhqZ5/dpTCpmy3QfDVyAY45tQM4vM7TG1QjMSDJ8EThFk9
+nnV0ttgCXjqQesBCNnLsak3c78QA3xMYV18meMjWCnl3v/evt3a5pQuEF10Q6m/h
+q5URX208o1xNg1vysxmKgIsLhwIDAQABoyYwJDASBgNVHRMBAf8ECDAGAQH/AgED
+MA4GA1UdDwEB/wQEAwIBxjANBgkqhkiG9w0BAQUFAAOCAQEADkbVPK7ih9legYsC
+mEEIjEy82tvuJxuC52pF7BaLT4Wg87JwvVqWuspube5Gi27nKi6Wsxkz67SfqLI3
+7piol7Yutmcn1KZJ/RyTZXaeQi/cImyaT/JaFTmxcdcrUehtHJjA2Sr0oYJ71clB
+oiMBdDhViw+5LmeiIAQ32pwL0xch4I+XeTRvhEgCIDMb5jREn5Fw9IBehEPCKdJs
+EhTkYY2sEJCehFC78JZvRZ+K88psT/oROhUVRsPNH4NbLUES7VBnQRM9IauUiqpO
+fMGx+6fWtScvl6tu4B3i0RwsH0Ti/L6RoZz71ilTc4afU9hDDl3WY4JxHYB0yvbi
+AmvZWg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=SecureSign RootCA11 O=Japan Certification Services, Inc.
+# Subject: CN=SecureSign RootCA11 O=Japan Certification Services, Inc.
+# Label: "SecureSign RootCA11"
+# Serial: 1
+# MD5 Fingerprint: b7:52:74:e2:92:b4:80:93:f2:75:e4:cc:d7:f2:ea:26
+# SHA1 Fingerprint: 3b:c4:9f:48:f8:f3:73:a0:9c:1e:bd:f8:5b:b1:c3:65:c7:d8:11:b3
+# SHA256 Fingerprint: bf:0f:ee:fb:9e:3a:58:1a:d5:f9:e9:db:75:89:98:57:43:d2:61:08:5c:4d:31:4f:6f:5d:72:59:aa:42:16:12
+-----BEGIN CERTIFICATE-----
+MIIDbTCCAlWgAwIBAgIBATANBgkqhkiG9w0BAQUFADBYMQswCQYDVQQGEwJKUDEr
+MCkGA1UEChMiSmFwYW4gQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcywgSW5jLjEcMBoG
+A1UEAxMTU2VjdXJlU2lnbiBSb290Q0ExMTAeFw0wOTA0MDgwNDU2NDdaFw0yOTA0
+MDgwNDU2NDdaMFgxCzAJBgNVBAYTAkpQMSswKQYDVQQKEyJKYXBhbiBDZXJ0aWZp
+Y2F0aW9uIFNlcnZpY2VzLCBJbmMuMRwwGgYDVQQDExNTZWN1cmVTaWduIFJvb3RD
+QTExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/XeqpRyQBTvLTJsz
+i1oURaTnkBbR31fSIRCkF/3frNYfp+TbfPfs37gD2pRY/V1yfIw/XwFndBWW4wI8
+h9uuywGOwvNmxoVF9ALGOrVisq/6nL+k5tSAMJjzDbaTj6nU2DbysPyKyiyhFTOV
+MdrAG/LuYpmGYz+/3ZMqg6h2uRMft85OQoWPIucuGvKVCbIFtUROd6EgvanyTgp9
+UK31BQ1FT0Zx/Sg+U/sE2C3XZR1KG/rPO7AxmjVuyIsG0wCR8pQIZUyxNAYAeoni
+8McDWc/V1uinMrPmmECGxc0nEovMe863ETxiYAcjPitAbpSACW22s293bzUIUPsC
+h8U+iQIDAQABo0IwQDAdBgNVHQ4EFgQUW/hNT7KlhtQ60vFjmqC+CfZXt94wDgYD
+VR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEB
+AKChOBZmLqdWHyGcBvod7bkixTgm2E5P7KN/ed5GIaGHd48HCJqypMWvDzKYC3xm
+KbabfSVSSUOrTC4rbnpwrxYO4wJs+0LmGJ1F2FXI6Dvd5+H0LgscNFxsWEr7jIhQ
+X5Ucv+2rIrVls4W6ng+4reV6G4pQOh29Dbx7VFALuUKvVaAYga1lme++5Jy/xIWr
+QbJUb9wlze144o4MjQlJ3WN7WmmWAiGovVJZ6X01y8hSyn+B/tlr0/cR7SXf+Of5
+pPpyl4RTDaXQMhhRdlkUbA/r7F+AjHVDg8OFmP9Mni0N5HeDk061lgeLKBObjBmN
+QSdJQO7e5iNEOdyhIta6A/I=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd.
+# Subject: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd.
+# Label: "Microsec e-Szigno Root CA 2009"
+# Serial: 14014712776195784473
+# MD5 Fingerprint: f8:49:f4:03:bc:44:2d:83:be:48:69:7d:29:64:fc:b1
+# SHA1 Fingerprint: 89:df:74:fe:5c:f4:0f:4a:80:f9:e3:37:7d:54:da:91:e1:01:31:8e
+# SHA256 Fingerprint: 3c:5f:81:fe:a5:fa:b8:2c:64:bf:a2:ea:ec:af:cd:e8:e0:77:fc:86:20:a7:ca:e5:37:16:3d:f3:6e:db:f3:78
+-----BEGIN CERTIFICATE-----
+MIIECjCCAvKgAwIBAgIJAMJ+QwRORz8ZMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD
+VQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFjAUBgNVBAoMDU1pY3Jvc2VjIEx0
+ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EgMjAwOTEfMB0G
+CSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5odTAeFw0wOTA2MTYxMTMwMThaFw0y
+OTEyMzAxMTMwMThaMIGCMQswCQYDVQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3Qx
+FjAUBgNVBAoMDU1pY3Jvc2VjIEx0ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3pp
+Z25vIFJvb3QgQ0EgMjAwOTEfMB0GCSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5o
+dTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOn4j/NjrdqG2KfgQvvP
+kd6mJviZpWNwrZuuyjNAfW2WbqEORO7hE52UQlKavXWFdCyoDh2Tthi3jCyoz/tc
+cbna7P7ofo/kLx2yqHWH2Leh5TvPmUpG0IMZfcChEhyVbUr02MelTTMuhTlAdX4U
+fIASmFDHQWe4oIBhVKZsTh/gnQ4H6cm6M+f+wFUoLAKApxn1ntxVUwOXewdI/5n7
+N4okxFnMUBBjjqqpGrCEGob5X7uxUG6k0QrM1XF+H6cbfPVTbiJfyyvm1HxdrtbC
+xkzlBQHZ7Vf8wSN5/PrIJIOV87VqUQHQd9bpEqH5GoP7ghu5sJf0dgYzQ0mg/wu1
++rUCAwEAAaOBgDB+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G
+A1UdDgQWBBTLD8bfQkPMPcu1SCOhGnqmKrs0aDAfBgNVHSMEGDAWgBTLD8bfQkPM
+Pcu1SCOhGnqmKrs0aDAbBgNVHREEFDASgRBpbmZvQGUtc3ppZ25vLmh1MA0GCSqG
+SIb3DQEBCwUAA4IBAQDJ0Q5eLtXMs3w+y/w9/w0olZMEyL/azXm4Q5DwpL7v8u8h
+mLzU1F0G9u5C7DBsoKqpyvGvivo/C3NqPuouQH4frlRheesuCDfXI/OMn74dseGk
+ddug4lQUsbocKaQY9hK6ohQU4zE1yED/t+AFdlfBHFny+L/k7SViXITwfn4fs775
+tyERzAMBVnCnEJIeGzSBHq2cGsMEPO0CYdYeBvNfOofyK/FFh+U9rNHHV4S9a67c
+2Pm2G2JwCz02yULyMtd6YebS2z3PyKnJm9zbWETXbzivf3jTo60adbocwTZ8jx5t
+HMN1Rq41Bab2XD0h7lbwyYIiLXpUq3DDfSJlgnCW
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
+# Label: "GlobalSign Root CA - R3"
+# Serial: 4835703278459759426209954
+# MD5 Fingerprint: c5:df:b8:49:ca:05:13:55:ee:2d:ba:1a:c3:3e:b0:28
+# SHA1 Fingerprint: d6:9b:56:11:48:f0:1c:77:c5:45:78:c1:09:26:df:5b:85:69:76:ad
+# SHA256 Fingerprint: cb:b5:22:d7:b7:f1:27:ad:6a:01:13:86:5b:df:1c:d4:10:2e:7d:07:59:af:63:5a:7c:f4:72:0d:c9:63:c5:3b
+-----BEGIN CERTIFICATE-----
+MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G
+A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp
+Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4
+MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG
+A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8
+RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT
+gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm
+KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd
+QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ
+XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw
+DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o
+LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU
+RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp
+jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK
+6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX
+mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs
+Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH
+WD9f
+-----END CERTIFICATE-----
+
+# Issuer: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
+# Subject: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
+# Label: "Autoridad de Certificacion Firmaprofesional CIF A62634068"
+# Serial: 6047274297262753887
+# MD5 Fingerprint: 73:3a:74:7a:ec:bb:a3:96:a6:c2:e4:e2:c8:9b:c0:c3
+# SHA1 Fingerprint: ae:c5:fb:3f:c8:e1:bf:c4:e5:4f:03:07:5a:9a:e8:00:b7:f7:b6:fa
+# SHA256 Fingerprint: 04:04:80:28:bf:1f:28:64:d4:8f:9a:d4:d8:32:94:36:6a:82:88:56:55:3f:3b:14:30:3f:90:14:7f:5d:40:ef
+-----BEGIN CERTIFICATE-----
+MIIGFDCCA/ygAwIBAgIIU+w77vuySF8wDQYJKoZIhvcNAQEFBQAwUTELMAkGA1UE
+BhMCRVMxQjBABgNVBAMMOUF1dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIEZpcm1h
+cHJvZmVzaW9uYWwgQ0lGIEE2MjYzNDA2ODAeFw0wOTA1MjAwODM4MTVaFw0zMDEy
+MzEwODM4MTVaMFExCzAJBgNVBAYTAkVTMUIwQAYDVQQDDDlBdXRvcmlkYWQgZGUg
+Q2VydGlmaWNhY2lvbiBGaXJtYXByb2Zlc2lvbmFsIENJRiBBNjI2MzQwNjgwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKlmuO6vj78aI14H9M2uDDUtd9
+thDIAl6zQyrET2qyyhxdKJp4ERppWVevtSBC5IsP5t9bpgOSL/UR5GLXMnE42QQM
+cas9UX4PB99jBVzpv5RvwSmCwLTaUbDBPLutN0pcyvFLNg4kq7/DhHf9qFD0sefG
+L9ItWY16Ck6WaVICqjaY7Pz6FIMMNx/Jkjd/14Et5cS54D40/mf0PmbR0/RAz15i
+NA9wBj4gGFrO93IbJWyTdBSTo3OxDqqHECNZXyAFGUftaI6SEspd/NYrspI8IM/h
+X68gvqB2f3bl7BqGYTM+53u0P6APjqK5am+5hyZvQWyIplD9amML9ZMWGxmPsu2b
+m8mQ9QEM3xk9Dz44I8kvjwzRAv4bVdZO0I08r0+k8/6vKtMFnXkIoctXMbScyJCy
+Z/QYFpM6/EfY0XiWMR+6KwxfXZmtY4laJCB22N/9q06mIqqdXuYnin1oKaPnirja
+EbsXLZmdEyRG98Xi2J+Of8ePdG1asuhy9azuJBCtLxTa/y2aRnFHvkLfuwHb9H/T
+KI8xWVvTyQKmtFLKbpf7Q8UIJm+K9Lv9nyiqDdVF8xM6HdjAeI9BZzwelGSuewvF
+6NkBiDkal4ZkQdU7hwxu+g/GvUgUvzlN1J5Bto+WHWOWk9mVBngxaJ43BjuAiUVh
+OSPHG0SjFeUc+JIwuwIDAQABo4HvMIHsMBIGA1UdEwEB/wQIMAYBAf8CAQEwDgYD
+VR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRlzeurNR4APn7VdMActHNHDhpkLzCBpgYD
+VR0gBIGeMIGbMIGYBgRVHSAAMIGPMC8GCCsGAQUFBwIBFiNodHRwOi8vd3d3LmZp
+cm1hcHJvZmVzaW9uYWwuY29tL2NwczBcBggrBgEFBQcCAjBQHk4AUABhAHMAZQBv
+ACAAZABlACAAbABhACAAQgBvAG4AYQBuAG8AdgBhACAANAA3ACAAQgBhAHIAYwBl
+AGwAbwBuAGEAIAAwADgAMAAxADcwDQYJKoZIhvcNAQEFBQADggIBABd9oPm03cXF
+661LJLWhAqvdpYhKsg9VSytXjDvlMd3+xDLx51tkljYyGOylMnfX40S2wBEqgLk9
+am58m9Ot/MPWo+ZkKXzR4Tgegiv/J2Wv+xYVxC5xhOW1//qkR71kMrv2JYSiJ0L1
+ILDCExARzRAVukKQKtJE4ZYm6zFIEv0q2skGz3QeqUvVhyj5eTSSPi5E6PaPT481
+PyWzOdxjKpBrIF/EUhJOlywqrJ2X3kjyo2bbwtKDlaZmp54lD+kLM5FlClrD2VQS
+3a/DTg4fJl4N3LON7NWBcN7STyQF82xO9UxJZo3R/9ILJUFI/lGExkKvgATP0H5k
+SeTy36LssUzAKh3ntLFlosS88Zj0qnAHY7S42jtM+kAiMFsRpvAFDsYCA0irhpuF
+3dvd6qJ2gHN99ZwExEWN57kci57q13XRcrHedUTnQn3iV2t93Jm8PYMo6oCTjcVM
+ZcFwgbg4/EMxsvYDNEeyrPsiBsse3RdHHF9mudMaotoRsaS8I8nkvof/uZS2+F0g
+StRf571oe2XyFR7SOqkt6dhrJKyXWERHrVkY8SFlcN7ONGCoQPHzPKTDKCOM/icz
+Q0CgFzzr6juwcqajuUpLXhZI9LK8yIySxZ2frHI2vDSANGupi5LAuBft7HZT9SQB
+jLMi6Et8Vcad+qMUu2WFbm5PEn4KPJ2V
+-----END CERTIFICATE-----
+
+# Issuer: CN=Izenpe.com O=IZENPE S.A.
+# Subject: CN=Izenpe.com O=IZENPE S.A.
+# Label: "Izenpe.com"
+# Serial: 917563065490389241595536686991402621
+# MD5 Fingerprint: a6:b0:cd:85:80:da:5c:50:34:a3:39:90:2f:55:67:73
+# SHA1 Fingerprint: 2f:78:3d:25:52:18:a7:4a:65:39:71:b5:2c:a2:9c:45:15:6f:e9:19
+# SHA256 Fingerprint: 25:30:cc:8e:98:32:15:02:ba:d9:6f:9b:1f:ba:1b:09:9e:2d:29:9e:0f:45:48:bb:91:4f:36:3b:c0:d4:53:1f
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Chambers of Commerce Root - 2008 O=AC Camerfirma S.A.
+# Subject: CN=Chambers of Commerce Root - 2008 O=AC Camerfirma S.A.
+# Label: "Chambers of Commerce Root - 2008"
+# Serial: 11806822484801597146
+# MD5 Fingerprint: 5e:80:9e:84:5a:0e:65:0b:17:02:f3:55:18:2a:3e:d7
+# SHA1 Fingerprint: 78:6a:74:ac:76:ab:14:7f:9c:6a:30:50:ba:9e:a8:7e:fe:9a:ce:3c
+# SHA256 Fingerprint: 06:3e:4a:fa:c4:91:df:d3:32:f3:08:9b:85:42:e9:46:17:d8:93:d7:fe:94:4e:10:a7:93:7e:e2:9d:96:93:c0
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Global Chambersign Root - 2008 O=AC Camerfirma S.A.
+# Subject: CN=Global Chambersign Root - 2008 O=AC Camerfirma S.A.
+# Label: "Global Chambersign Root - 2008"
+# Serial: 14541511773111788494
+# MD5 Fingerprint: 9e:80:ff:78:01:0c:2e:c1:36:bd:fe:96:90:6e:08:f3
+# SHA1 Fingerprint: 4a:bd:ee:ec:95:0d:35:9c:89:ae:c7:52:a1:2c:5b:29:f6:d6:aa:0c
+# SHA256 Fingerprint: 13:63:35:43:93:34:a7:69:80:16:a0:d3:24:de:72:28:4e:07:9d:7b:52:20:bb:8f:bd:74:78:16:ee:be:ba:ca
+-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----
+
+# Issuer: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
+# Subject: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
+# Label: "Go Daddy Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: 80:3a:bc:22:c1:e6:fb:8d:9b:3b:27:4a:32:1b:9a:01
+# SHA1 Fingerprint: 47:be:ab:c9:22:ea:e8:0e:78:78:34:62:a7:9f:45:c2:54:fd:e6:8b
+# SHA256 Fingerprint: 45:14:0b:32:47:eb:9c:c8:c5:b4:f0:d7:b5:30:91:f7:32:92:08:9e:6e:5a:63:e2:74:9d:d3:ac:a9:19:8e:da
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT
+EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp
+ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz
+NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH
+EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE
+AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD
+E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH
+/PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy
+DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh
+GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR
+tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA
+AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE
+FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX
+WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu
+9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr
+gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo
+2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO
+LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI
+4uJEvlz36hz1
+-----END CERTIFICATE-----
+
+# Issuer: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Subject: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Label: "Starfield Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: d6:39:81:c6:52:7e:96:69:fc:fc:ca:66:ed:05:f2:96
+# SHA1 Fingerprint: b5:1c:06:7c:ee:2b:0c:3d:f8:55:ab:2d:92:f4:fe:39:d4:e7:0f:0e
+# SHA256 Fingerprint: 2c:e1:cb:0b:f9:d2:f9:e1:02:99:3f:be:21:51:52:c3:b2:dd:0c:ab:de:1c:68:e5:31:9b:83:91:54:db:b7:f5
+-----BEGIN CERTIFICATE-----
+MIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
+HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs
+ZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw
+MFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6
+b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj
+aG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp
+Y2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+ggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg
+nLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1
+HOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N
+Hwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN
+dloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0
+HZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO
+BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G
+CSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU
+sHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3
+4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg
+8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K
+pL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1
+mMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0
+-----END CERTIFICATE-----
+
+# Issuer: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Subject: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Label: "Starfield Services Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: 17:35:74:af:7b:61:1c:eb:f4:f9:3c:e2:ee:40:f9:a2
+# SHA1 Fingerprint: 92:5a:8f:8d:2c:6d:04:e0:66:5f:59:6a:ff:22:d8:63:e8:25:6f:3f
+# SHA256 Fingerprint: 56:8d:69:05:a2:c8:87:08:a4:b3:02:51:90:ed:cf:ed:b1:97:4a:60:6a:13:c6:e5:29:0f:cb:2a:e6:3e:da:b5
+-----BEGIN CERTIFICATE-----
+MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
+HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs
+ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5
+MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD
+VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy
+ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy
+dmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p
+OsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2
+8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K
+Ts9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe
+hRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk
+6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw
+DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q
+AdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI
+bw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB
+ve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z
+qwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd
+iEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn
+0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN
+sSi6
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Commercial O=AffirmTrust
+# Subject: CN=AffirmTrust Commercial O=AffirmTrust
+# Label: "AffirmTrust Commercial"
+# Serial: 8608355977964138876
+# MD5 Fingerprint: 82:92:ba:5b:ef:cd:8a:6f:a6:3d:55:f9:84:f6:d6:b7
+# SHA1 Fingerprint: f9:b5:b6:32:45:5f:9c:be:ec:57:5f:80:dc:e9:6e:2c:c7:b2:78:b7
+# SHA256 Fingerprint: 03:76:ab:1d:54:c5:f9:80:3c:e4:b2:e2:01:a0:ee:7e:ef:7b:57:b6:36:e8:a9:3c:9b:8d:48:60:c9:6f:5f:a7
+-----BEGIN CERTIFICATE-----
+MIIDTDCCAjSgAwIBAgIId3cGJyapsXwwDQYJKoZIhvcNAQELBQAwRDELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
+dCBDb21tZXJjaWFsMB4XDTEwMDEyOTE0MDYwNloXDTMwMTIzMTE0MDYwNlowRDEL
+MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
+cm1UcnVzdCBDb21tZXJjaWFsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEA9htPZwcroRX1BiLLHwGy43NFBkRJLLtJJRTWzsO3qyxPxkEylFf6EqdbDuKP
+Hx6GGaeqtS25Xw2Kwq+FNXkyLbscYjfysVtKPcrNcV/pQr6U6Mje+SJIZMblq8Yr
+ba0F8PrVC8+a5fBQpIs7R6UjW3p6+DM/uO+Zl+MgwdYoic+U+7lF7eNAFxHUdPAL
+MeIrJmqbTFeurCA+ukV6BfO9m2kVrn1OIGPENXY6BwLJN/3HR+7o8XYdcxXyl6S1
+yHp52UKqK39c/s4mT6NmgTWvRLpUHhwwMmWd5jyTXlBOeuM61G7MGvv50jeuJCqr
+VwMiKA1JdX+3KNp1v47j3A55MQIDAQABo0IwQDAdBgNVHQ4EFgQUnZPGU4teyq8/
+nx4P5ZmVvCT2lI8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
+KoZIhvcNAQELBQADggEBAFis9AQOzcAN/wr91LoWXym9e2iZWEnStB03TX8nfUYG
+XUPGhi4+c7ImfU+TqbbEKpqrIZcUsd6M06uJFdhrJNTxFq7YpFzUf1GO7RgBsZNj
+vbz4YYCanrHOQnDiqX0GJX0nof5v7LMeJNrjS1UaADs1tDvZ110w/YETifLCBivt
+Z8SOyUOyXGsViQK8YvxO8rUzqrJv0wqiUOP2O+guRMLbZjipM1ZI8W0bM40NjD9g
+N53Tym1+NH4Nn3J2ixufcv1SNUFFApYvHLKac0khsUlHRUe072o0EclNmsxZt9YC
+nlpOZbWUrhvfKbAW8b8Angc6F2S1BLUjIZkKlTuXfO8=
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Networking O=AffirmTrust
+# Subject: CN=AffirmTrust Networking O=AffirmTrust
+# Label: "AffirmTrust Networking"
+# Serial: 8957382827206547757
+# MD5 Fingerprint: 42:65:ca:be:01:9a:9a:4c:a9:8c:41:49:cd:c0:d5:7f
+# SHA1 Fingerprint: 29:36:21:02:8b:20:ed:02:f5:66:c5:32:d1:d6:ed:90:9f:45:00:2f
+# SHA256 Fingerprint: 0a:81:ec:5a:92:97:77:f1:45:90:4a:f3:8d:5d:50:9f:66:b5:e2:c5:8f:cd:b5:31:05:8b:0e:17:f3:f0:b4:1b
+-----BEGIN CERTIFICATE-----
+MIIDTDCCAjSgAwIBAgIIfE8EORzUmS0wDQYJKoZIhvcNAQEFBQAwRDELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
+dCBOZXR3b3JraW5nMB4XDTEwMDEyOTE0MDgyNFoXDTMwMTIzMTE0MDgyNFowRDEL
+MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
+cm1UcnVzdCBOZXR3b3JraW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEAtITMMxcua5Rsa2FSoOujz3mUTOWUgJnLVWREZY9nZOIG41w3SfYvm4SEHi3y
+YJ0wTsyEheIszx6e/jarM3c1RNg1lho9Nuh6DtjVR6FqaYvZ/Ls6rnla1fTWcbua
+kCNrmreIdIcMHl+5ni36q1Mr3Lt2PpNMCAiMHqIjHNRqrSK6mQEubWXLviRmVSRL
+QESxG9fhwoXA3hA/Pe24/PHxI1Pcv2WXb9n5QHGNfb2V1M6+oF4nI979ptAmDgAp
+6zxG8D1gvz9Q0twmQVGeFDdCBKNwV6gbh+0t+nvujArjqWaJGctB+d1ENmHP4ndG
+yH329JKBNv3bNPFyfvMMFr20FQIDAQABo0IwQDAdBgNVHQ4EFgQUBx/S55zawm6i
+QLSwelAQUHTEyL0wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
+KoZIhvcNAQEFBQADggEBAIlXshZ6qML91tmbmzTCnLQyFE2npN/svqe++EPbkTfO
+tDIuUFUaNU52Q3Eg75N3ThVwLofDwR1t3Mu1J9QsVtFSUzpE0nPIxBsFZVpikpzu
+QY0x2+c06lkh1QF612S4ZDnNye2v7UsDSKegmQGA3GWjNq5lWUhPgkvIZfFXHeVZ
+Lgo/bNjR9eUJtGxUAArgFU2HdW23WJZa3W3SAKD0m0i+wzekujbgfIeFlxoVot4u
+olu9rxj5kFDNcFn4J2dHy8egBzp90SxdbBk6ZrV9/ZFvgrG+CJPbFEfxojfHRZ48
+x3evZKiT3/Zpg4Jg8klCNO1aAFSFHBY2kgxc+qatv9s=
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Premium O=AffirmTrust
+# Subject: CN=AffirmTrust Premium O=AffirmTrust
+# Label: "AffirmTrust Premium"
+# Serial: 7893706540734352110
+# MD5 Fingerprint: c4:5d:0e:48:b6:ac:28:30:4e:0a:bc:f9:38:16:87:57
+# SHA1 Fingerprint: d8:a6:33:2c:e0:03:6f:b1:85:f6:63:4f:7d:6a:06:65:26:32:28:27
+# SHA256 Fingerprint: 70:a7:3f:7f:37:6b:60:07:42:48:90:45:34:b1:14:82:d5:bf:0e:69:8e:cc:49:8d:f5:25:77:eb:f2:e9:3b:9a
+-----BEGIN CERTIFICATE-----
+MIIFRjCCAy6gAwIBAgIIbYwURrGmCu4wDQYJKoZIhvcNAQEMBQAwQTELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1UcnVz
+dCBQcmVtaXVtMB4XDTEwMDEyOTE0MTAzNloXDTQwMTIzMTE0MTAzNlowQTELMAkG
+A1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1U
+cnVzdCBQcmVtaXVtMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBLf
+qV/+Qd3d9Z+K4/as4Tx4mrzY8H96oDMq3I0gW64tb+eT2TZwamjPjlGjhVtnBKAQ
+JG9dKILBl1fYSCkTtuG+kU3fhQxTGJoeJKJPj/CihQvL9Cl/0qRY7iZNyaqoe5rZ
++jjeRFcV5fiMyNlI4g0WJx0eyIOFJbe6qlVBzAMiSy2RjYvmia9mx+n/K+k8rNrS
+s8PhaJyJ+HoAVt70VZVs+7pk3WKL3wt3MutizCaam7uqYoNMtAZ6MMgpv+0GTZe5
+HMQxK9VfvFMSF5yZVylmd2EhMQcuJUmdGPLu8ytxjLW6OQdJd/zvLpKQBY0tL3d7
+70O/Nbua2Plzpyzy0FfuKE4mX4+QaAkvuPjcBukumj5Rp9EixAqnOEhss/n/fauG
+V+O61oV4d7pD6kh/9ti+I20ev9E2bFhc8e6kGVQa9QPSdubhjL08s9NIS+LI+H+S
+qHZGnEJlPqQewQcDWkYtuJfzt9WyVSHvutxMAJf7FJUnM7/oQ0dG0giZFmA7mn7S
+5u046uwBHjxIVkkJx0w3AJ6IDsBz4W9m6XJHMD4Q5QsDyZpCAGzFlH5hxIrff4Ia
+C1nEWTJ3s7xgaVY5/bQGeyzWZDbZvUjthB9+pSKPKrhC9IK31FOQeE4tGv2Bb0TX
+OwF0lkLgAOIua+rF7nKsu7/+6qqo+Nz2snmKtmcCAwEAAaNCMEAwHQYDVR0OBBYE
+FJ3AZ6YMItkm9UWrpmVSESfYRaxjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
+BAQDAgEGMA0GCSqGSIb3DQEBDAUAA4ICAQCzV00QYk465KzquByvMiPIs0laUZx2
+KI15qldGF9X1Uva3ROgIRL8YhNILgM3FEv0AVQVhh0HctSSePMTYyPtwni94loMg
+Nt58D2kTiKV1NpgIpsbfrM7jWNa3Pt668+s0QNiigfV4Py/VpfzZotReBA4Xrf5B
+8OWycvpEgjNC6C1Y91aMYj+6QrCcDFx+LmUmXFNPALJ4fqENmS2NuB2OosSw/WDQ
+MKSOyARiqcTtNd56l+0OOF6SL5Nwpamcb6d9Ex1+xghIsV5n61EIJenmJWtSKZGc
+0jlzCFfemQa0W50QBuHCAKi4HEoCChTQwUHK+4w1IX2COPKpVJEZNZOUbWo6xbLQ
+u4mGk+ibyQ86p3q4ofB4Rvr8Ny/lioTz3/4E2aFooC8k4gmVBtWVyuEklut89pMF
+u+1z6S3RdTnX5yTb2E5fQ4+e0BQ5v1VwSJlXMbSc7kqYA5YwH2AG7hsj/oFgIxpH
+YoWlzBk0gG+zrBrjn/B7SK3VAdlntqlyk+otZrWyuOQ9PLLvTIzq6we/qzWaVYa8
+GKa1qF60g2xraUDTn9zxw2lrueFtCfTxqlB2Cnp9ehehVZZCmTEJ3WARjQUwfuaO
+RtGdFNrHF+QFlozEJLUbzxQHskD4o55BhrwE0GuWyCqANP2/7waj3VjFhT0+j/6e
+KeC2uAloGRwYQw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Premium ECC O=AffirmTrust
+# Subject: CN=AffirmTrust Premium ECC O=AffirmTrust
+# Label: "AffirmTrust Premium ECC"
+# Serial: 8401224907861490260
+# MD5 Fingerprint: 64:b0:09:55:cf:b1:d5:99:e2:be:13:ab:a6:5d:ea:4d
+# SHA1 Fingerprint: b8:23:6b:00:2f:1d:16:86:53:01:55:6c:11:a4:37:ca:eb:ff:c3:bb
+# SHA256 Fingerprint: bd:71:fd:f6:da:97:e4:cf:62:d1:64:7a:dd:25:81:b0:7d:79:ad:f8:39:7e:b4:ec:ba:9c:5e:84:88:82:14:23
+-----BEGIN CERTIFICATE-----
+MIIB/jCCAYWgAwIBAgIIdJclisc/elQwCgYIKoZIzj0EAwMwRTELMAkGA1UEBhMC
+VVMxFDASBgNVBAoMC0FmZmlybVRydXN0MSAwHgYDVQQDDBdBZmZpcm1UcnVzdCBQ
+cmVtaXVtIEVDQzAeFw0xMDAxMjkxNDIwMjRaFw00MDEyMzExNDIwMjRaMEUxCzAJ
+BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJt
+VHJ1c3QgUHJlbWl1bSBFQ0MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQNMF4bFZ0D
+0KF5Nbc6PJJ6yhUczWLznCZcBz3lVPqj1swS6vQUX+iOGasvLkjmrBhDeKzQN8O9
+ss0s5kfiGuZjuD0uL3jET9v0D6RoTFVya5UdThhClXjMNzyR4ptlKymjQjBAMB0G
+A1UdDgQWBBSaryl6wBE1NSZRMADDav5A1a7WPDAPBgNVHRMBAf8EBTADAQH/MA4G
+A1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNnADBkAjAXCfOHiFBar8jAQr9HX/Vs
+aobgxCd05DhT1wV/GzTjxi+zygk8N53X57hG8f2h4nECMEJZh0PUUd+60wkyWs6I
+flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Subject: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Label: "Certum Trusted Network CA"
+# Serial: 279744
+# MD5 Fingerprint: d5:e9:81:40:c5:18:69:fc:46:2c:89:75:62:0f:aa:78
+# SHA1 Fingerprint: 07:e0:32:e0:20:b7:2c:3f:19:2f:06:28:a2:59:3a:19:a7:0f:06:9e
+# SHA256 Fingerprint: 5c:58:46:8d:55:f5:8e:49:7e:74:39:82:d2:b5:00:10:b6:d1:65:37:4a:cf:83:a7:d4:a3:2d:b7:68:c4:40:8e
+-----BEGIN CERTIFICATE-----
+MIIDuzCCAqOgAwIBAgIDBETAMA0GCSqGSIb3DQEBBQUAMH4xCzAJBgNVBAYTAlBM
+MSIwIAYDVQQKExlVbml6ZXRvIFRlY2hub2xvZ2llcyBTLkEuMScwJQYDVQQLEx5D
+ZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxIjAgBgNVBAMTGUNlcnR1bSBU
+cnVzdGVkIE5ldHdvcmsgQ0EwHhcNMDgxMDIyMTIwNzM3WhcNMjkxMjMxMTIwNzM3
+WjB+MQswCQYDVQQGEwJQTDEiMCAGA1UEChMZVW5pemV0byBUZWNobm9sb2dpZXMg
+Uy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MSIw
+IAYDVQQDExlDZXJ0dW0gVHJ1c3RlZCBOZXR3b3JrIENBMIIBIjANBgkqhkiG9w0B
+AQEFAAOCAQ8AMIIBCgKCAQEA4/t9o3K6wvDJFIf1awFO4W5AB7ptJ11/91sts1rH
+UV+rpDKmYYe2bg+G0jACl/jXaVehGDldamR5xgFZrDwxSjh80gTSSyjoIF87B6LM
+TXPb865Px1bVWqeWifrzq2jUI4ZZJ88JJ7ysbnKDHDBy3+Ci6dLhdHUZvSqeexVU
+BBvXQzmtVSjF4hq79MDkrjhJM8x2hZ85RdKknvISjFH4fOQtf/WsX+sWn7Et0brM
+kUJ3TCXJkDhv2/DM+44el1k+1WBO5gUo7Ul5E0u6SNsv+XLTOcr+H9g0cvW0QM8x
+AcPs3hEtF10fuFDRXhmnad4HMyjKUJX5p1TLVIZQRan5SQIDAQABo0IwQDAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBQIds3LB/8k9sXN7buQvOKEN0Z19zAOBgNV
+HQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQEFBQADggEBAKaorSLOAT2mo/9i0Eidi15y
+sHhE49wcrwn9I0j6vSrEuVUEtRCjjSfeC4Jj0O7eDDd5QVsisrCaQVymcODU0HfL
+I9MA4GxWL+FpDQ3Zqr8hgVDZBqWo/5U30Kr+4rP1mS1FhIrlQgnXdAIv94nYmem8
+J9RHjboNRhx3zxSkHLmkMcScKHQDNP8zGSal6Q10tz6XxnboJ5ajZt3hrvJBW8qY
+VoNzcOSGGtIxQbovvi0TWnZvTuhOgQ4/WwMioBK+ZlgRSssDxLQqKi2WF+A5VLxI
+03YnnZotBqbJ7DnSq9ufmgsnAjUpsUCV5/nonFWIGUbWtzT1fs45mtk48VH3Tyw=
+-----END CERTIFICATE-----
+
+# Issuer: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA
+# Subject: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA
+# Label: "TWCA Root Certification Authority"
+# Serial: 1
+# MD5 Fingerprint: aa:08:8f:f6:f9:7b:b7:f2:b1:a7:1e:9b:ea:ea:bd:79
+# SHA1 Fingerprint: cf:9e:87:6d:d3:eb:fc:42:26:97:a3:b5:a3:7a:a0:76:a9:06:23:48
+# SHA256 Fingerprint: bf:d8:8f:e1:10:1c:41:ae:3e:80:1b:f8:be:56:35:0e:e9:ba:d1:a6:b9:bd:51:5e:dc:5c:6d:5b:87:11:ac:44
+-----BEGIN CERTIFICATE-----
+MIIDezCCAmOgAwIBAgIBATANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJUVzES
+MBAGA1UECgwJVEFJV0FOLUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFU
+V0NBIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwODI4MDcyNDMz
+WhcNMzAxMjMxMTU1OTU5WjBfMQswCQYDVQQGEwJUVzESMBAGA1UECgwJVEFJV0FO
+LUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFUV0NBIFJvb3QgQ2VydGlm
+aWNhdGlvbiBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
+AQCwfnK4pAOU5qfeCTiRShFAh6d8WWQUe7UREN3+v9XAu1bihSX0NXIP+FPQQeFE
+AcK0HMMxQhZHhTMidrIKbw/lJVBPhYa+v5guEGcevhEFhgWQxFnQfHgQsIBct+HH
+K3XLfJ+utdGdIzdjp9xCoi2SBBtQwXu4PhvJVgSLL1KbralW6cH/ralYhzC2gfeX
+RfwZVzsrb+RH9JlF/h3x+JejiB03HFyP4HYlmlD4oFT/RJB2I9IyxsOrBr/8+7/z
+rX2SYgJbKdM1o5OaQ2RgXbL6Mv87BK9NQGr5x+PvI/1ry+UPizgN7gr8/g+YnzAx
+3WxSZfmLgb4i4RxYA7qRG4kHAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqOFsmjd6LWvJPelSDGRjjCDWmujANBgkq
+hkiG9w0BAQUFAAOCAQEAPNV3PdrfibqHDAhUaiBQkr6wQT25JmSDCi/oQMCXKCeC
+MErJk/9q56YAf4lCmtYR5VPOL8zy2gXE/uJQxDqGfczafhAJO5I1KlOy/usrBdls
+XebQ79NqZp4VKIV66IIArB6nCWlWQtNoURi+VJq/REG6Sb4gumlc7rh3zc5sH62D
+lhh9DrUUOYTxKOkto557HnpyWoOzeW/vtPzQCqVYT0bf+215WfKEIlKuD8z7fDvn
+aspHYcN6+NOSBB+4IIThNlQWx0DeO4pz3N/GCUzf7Nr/1FNCocnyYh0igzyXxfkZ
+YiesZSLX0zzG5Y6yU8xJzrww/nsOM5D77dIUkR8Hrw==
+-----END CERTIFICATE-----
+
+# Issuer: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2
+# Subject: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2
+# Label: "Security Communication RootCA2"
+# Serial: 0
+# MD5 Fingerprint: 6c:39:7d:a4:0e:55:59:b2:3f:d6:41:b1:12:50:de:43
+# SHA1 Fingerprint: 5f:3b:8c:f2:f8:10:b3:7d:78:b4:ce:ec:19:19:c3:73:34:b9:c7:74
+# SHA256 Fingerprint: 51:3b:2c:ec:b8:10:d4:cd:e5:dd:85:39:1a:df:c6:c2:dd:60:d8:7b:b7:36:d2:b5:21:48:4a:a4:7a:0e:be:f6
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIBADANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJKUDEl
+MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEnMCUGA1UECxMe
+U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBSb290Q0EyMB4XDTA5MDUyOTA1MDAzOVoX
+DTI5MDUyOTA1MDAzOVowXTELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09NIFRy
+dXN0IFN5c3RlbXMgQ08uLExURC4xJzAlBgNVBAsTHlNlY3VyaXR5IENvbW11bmlj
+YXRpb24gUm9vdENBMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANAV
+OVKxUrO6xVmCxF1SrjpDZYBLx/KWvNs2l9amZIyoXvDjChz335c9S672XewhtUGr
+zbl+dp+++T42NKA7wfYxEUV0kz1XgMX5iZnK5atq1LXaQZAQwdbWQonCv/Q4EpVM
+VAX3NuRFg3sUZdbcDE3R3n4MqzvEFb46VqZab3ZpUql6ucjrappdUtAtCms1FgkQ
+hNBqyjoGADdH5H5XTz+L62e4iKrFvlNVspHEfbmwhRkGeC7bYRr6hfVKkaHnFtWO
+ojnflLhwHyg/i/xAXmODPIMqGplrz95Zajv8bxbXH/1KEOtOghY6rCcMU/Gt1SSw
+awNQwS08Ft1ENCcadfsCAwEAAaNCMEAwHQYDVR0OBBYEFAqFqXdlBZh8QIH4D5cs
+OPEK7DzPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3
+DQEBCwUAA4IBAQBMOqNErLlFsceTfsgLCkLfZOoc7llsCLqJX2rKSpWeeo8HxdpF
+coJxDjrSzG+ntKEju/Ykn8sX/oymzsLS28yN/HH8AynBbF0zX2S2ZTuJbxh2ePXc
+okgfGT+Ok+vx+hfuzU7jBBJV1uXk3fs+BXziHV7Gp7yXT2g69ekuCkO2r1dcYmh8
+t/2jioSgrGK+KwmHNPBqAbubKVY8/gA3zyNs8U6qtnRGEmyR7jTV7JqR50S+kDFy
+1UkC9gLl9B/rfNmWVan/7Ir5mUf/NVoCqgTLiluHcSmRvaS0eg29mvVXIwAHIRc/
+SjnRBUkLp7Y3gaVdjKozXoEofKd9J+sAro03
+-----END CERTIFICATE-----
+
+# Issuer: CN=EC-ACC O=Agencia Catalana de Certificacio (NIF Q-0801176-I) OU=Serveis Publics de Certificacio/Vegeu https://www.catcert.net/verarrel (c)03/Jerarquia Entitats de Certificacio Catalanes
+# Subject: CN=EC-ACC O=Agencia Catalana de Certificacio (NIF Q-0801176-I) OU=Serveis Publics de Certificacio/Vegeu https://www.catcert.net/verarrel (c)03/Jerarquia Entitats de Certificacio Catalanes
+# Label: "EC-ACC"
+# Serial: -23701579247955709139626555126524820479
+# MD5 Fingerprint: eb:f5:9d:29:0d:61:f9:42:1f:7c:c2:ba:6d:e3:15:09
+# SHA1 Fingerprint: 28:90:3a:63:5b:52:80:fa:e6:77:4c:0b:6d:a7:d6:ba:a6:4a:f2:e8
+# SHA256 Fingerprint: 88:49:7f:01:60:2f:31:54:24:6a:e2:8c:4d:5a:ef:10:f1:d8:7e:bb:76:62:6f:4a:e0:b7:f9:5b:a7:96:87:99
+-----BEGIN CERTIFICATE-----
+MIIFVjCCBD6gAwIBAgIQ7is969Qh3hSoYqwE893EATANBgkqhkiG9w0BAQUFADCB
+8zELMAkGA1UEBhMCRVMxOzA5BgNVBAoTMkFnZW5jaWEgQ2F0YWxhbmEgZGUgQ2Vy
+dGlmaWNhY2lvIChOSUYgUS0wODAxMTc2LUkpMSgwJgYDVQQLEx9TZXJ2ZWlzIFB1
+YmxpY3MgZGUgQ2VydGlmaWNhY2lvMTUwMwYDVQQLEyxWZWdldSBodHRwczovL3d3
+dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAoYykwMzE1MDMGA1UECxMsSmVyYXJxdWlh
+IEVudGl0YXRzIGRlIENlcnRpZmljYWNpbyBDYXRhbGFuZXMxDzANBgNVBAMTBkVD
+LUFDQzAeFw0wMzAxMDcyMzAwMDBaFw0zMTAxMDcyMjU5NTlaMIHzMQswCQYDVQQG
+EwJFUzE7MDkGA1UEChMyQWdlbmNpYSBDYXRhbGFuYSBkZSBDZXJ0aWZpY2FjaW8g
+KE5JRiBRLTA4MDExNzYtSSkxKDAmBgNVBAsTH1NlcnZlaXMgUHVibGljcyBkZSBD
+ZXJ0aWZpY2FjaW8xNTAzBgNVBAsTLFZlZ2V1IGh0dHBzOi8vd3d3LmNhdGNlcnQu
+bmV0L3ZlcmFycmVsIChjKTAzMTUwMwYDVQQLEyxKZXJhcnF1aWEgRW50aXRhdHMg
+ZGUgQ2VydGlmaWNhY2lvIENhdGFsYW5lczEPMA0GA1UEAxMGRUMtQUNDMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsyLHT+KXQpWIR4NA9h0X84NzJB5R
+85iKw5K4/0CQBXCHYMkAqbWUZRkiFRfCQ2xmRJoNBD45b6VLeqpjt4pEndljkYRm
+4CgPukLjbo73FCeTae6RDqNfDrHrZqJyTxIThmV6PttPB/SnCWDaOkKZx7J/sxaV
+HMf5NLWUhdWZXqBIoH7nF2W4onW4HvPlQn2v7fOKSGRdghST2MDk/7NQcvJ29rNd
+QlB50JQ+awwAvthrDk4q7D7SzIKiGGUzE3eeml0aE9jD2z3Il3rucO2n5nzbcc8t
+lGLfbdb1OL4/pYUKGbio2Al1QnDE6u/LDsg0qBIimAy4E5S2S+zw0JDnJwIDAQAB
+o4HjMIHgMB0GA1UdEQQWMBSBEmVjX2FjY0BjYXRjZXJ0Lm5ldDAPBgNVHRMBAf8E
+BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUoMOLRKo3pUW/l4Ba0fF4
+opvpXY0wfwYDVR0gBHgwdjB0BgsrBgEEAfV4AQMBCjBlMCwGCCsGAQUFBwIBFiBo
+dHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbDA1BggrBgEFBQcCAjApGidW
+ZWdldSBodHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAwDQYJKoZIhvcN
+AQEFBQADggEBAKBIW4IB9k1IuDlVNZyAelOZ1Vr/sXE7zDkJlF7W2u++AVtd0x7Y
+/X1PzaBB4DSTv8vihpw3kpBWHNzrKQXlxJ7HNd+KDM3FIUPpqojlNcAZQmNaAl6k
+SBg6hW/cnbw/nZzBh7h6YQjpdwt/cKt63dmXLGQehb+8dJahw3oS7AwaboMMPOhy
+Rp/7SNVel+axofjk70YllJyJ22k4vuxcDlbHZVHlUIiIv0LVKz3l+bqeLrPK9HOS
+Agu+TGbrIP65y7WZf+a2E/rKS03Z7lNGBjvGTq2TWoF+bCpLagVFjPIhpDGQh2xl
+nJ2lYJU6Un/10asIbvPuW/mIPX64b24D5EI=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Hellenic Academic and Research Institutions RootCA 2011 O=Hellenic Academic and Research Institutions Cert. Authority
+# Subject: CN=Hellenic Academic and Research Institutions RootCA 2011 O=Hellenic Academic and Research Institutions Cert. Authority
+# Label: "Hellenic Academic and Research Institutions RootCA 2011"
+# Serial: 0
+# MD5 Fingerprint: 73:9f:4c:4b:73:5b:79:e9:fa:ba:1c:ef:6e:cb:d5:c9
+# SHA1 Fingerprint: fe:45:65:9b:79:03:5b:98:a1:61:b5:51:2e:ac:da:58:09:48:22:4d
+# SHA256 Fingerprint: bc:10:4f:15:a4:8b:e7:09:dc:a5:42:a7:e1:d4:b9:df:6f:05:45:27:e8:02:ea:a9:2d:59:54:44:25:8a:fe:71
+-----BEGIN CERTIFICATE-----
+MIIEMTCCAxmgAwIBAgIBADANBgkqhkiG9w0BAQUFADCBlTELMAkGA1UEBhMCR1Ix
+RDBCBgNVBAoTO0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1
+dGlvbnMgQ2VydC4gQXV0aG9yaXR5MUAwPgYDVQQDEzdIZWxsZW5pYyBBY2FkZW1p
+YyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIFJvb3RDQSAyMDExMB4XDTExMTIw
+NjEzNDk1MloXDTMxMTIwMTEzNDk1MlowgZUxCzAJBgNVBAYTAkdSMUQwQgYDVQQK
+EztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIENl
+cnQuIEF1dGhvcml0eTFAMD4GA1UEAxM3SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl
+c2VhcmNoIEluc3RpdHV0aW9ucyBSb290Q0EgMjAxMTCCASIwDQYJKoZIhvcNAQEB
+BQADggEPADCCAQoCggEBAKlTAOMupvaO+mDYLZU++CwqVE7NuYRhlFhPjz2L5EPz
+dYmNUeTDN9KKiE15HrcS3UN4SoqS5tdI1Q+kOilENbgH9mgdVc04UfCMJDGFr4PJ
+fel3r+0ae50X+bOdOFAPplp5kYCvN66m0zH7tSYJnTxa71HFK9+WXesyHgLacEns
+bgzImjeN9/E2YEsmLIKe0HjzDQ9jpFEw4fkrJxIH2Oq9GGKYsFk3fb7u8yBRQlqD
+75O6aRXxYp2fmTmCobd0LovUxQt7L/DICto9eQqakxylKHJzkUOap9FNhYS5qXSP
+FEDH3N6sQWRstBmbAmNtJGSPRLIl6s5ddAxjMlyNh+UCAwEAAaOBiTCBhjAPBgNV
+HRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAdBgNVHQ4EFgQUppFC/RNhSiOeCKQp
+5dgTBCPuQSUwRwYDVR0eBEAwPqA8MAWCAy5ncjAFggMuZXUwBoIELmVkdTAGggQu
+b3JnMAWBAy5ncjAFgQMuZXUwBoEELmVkdTAGgQQub3JnMA0GCSqGSIb3DQEBBQUA
+A4IBAQAf73lB4XtuP7KMhjdCSk4cNx6NZrokgclPEg8hwAOXhiVtXdMiKahsog2p
+6z0GW5k6x8zDmjR/qw7IThzh+uTczQ2+vyT+bOdrwg3IBp5OjWEopmr95fZi6hg8
+TqBTnbI6nOulnJEWtk2C4AwFSKls9cz4y51JtPACpf1wA+2KIaWuE4ZJwzNzvoc7
+dIsXRSZMFpGD/md9zU1jZ/rzAxKWeAaNsWftjj++n08C9bMJL/NMh98qy5V8Acys
+Nnq/onN694/BtZqhFLKPM58N7yLcZnuEvUUXBj08yrl3NI/K6s8/MT7jiOOASSXI
+l7WdmplNsDz4SgCbZN2fOUvRJ9e4
+-----END CERTIFICATE-----
+
+# Issuer: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967
+# Subject: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967
+# Label: "Actalis Authentication Root CA"
+# Serial: 6271844772424770508
+# MD5 Fingerprint: 69:c1:0d:4f:07:a3:1b:c3:fe:56:3d:04:bc:11:f6:a6
+# SHA1 Fingerprint: f3:73:b3:87:06:5a:28:84:8a:f2:f3:4a:ce:19:2b:dd:c7:8e:9c:ac
+# SHA256 Fingerprint: 55:92:60:84:ec:96:3a:64:b9:6e:2a:be:01:ce:0b:a8:6a:64:fb:fe:bc:c7:aa:b5:af:c1:55:b3:7f:d7:60:66
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: O=Trustis Limited OU=Trustis FPS Root CA
+# Subject: O=Trustis Limited OU=Trustis FPS Root CA
+# Label: "Trustis FPS Root CA"
+# Serial: 36053640375399034304724988975563710553
+# MD5 Fingerprint: 30:c9:e7:1e:6b:e6:14:eb:65:b2:16:69:20:31:67:4d
+# SHA1 Fingerprint: 3b:c0:38:0b:33:c3:f6:a6:0c:86:15:22:93:d9:df:f5:4b:81:c0:04
+# SHA256 Fingerprint: c1:b4:82:99:ab:a5:20:8f:e9:63:0a:ce:55:ca:68:a0:3e:da:5a:51:9c:88:02:a0:d3:a6:73:be:8f:8e:55:7d
+-----BEGIN CERTIFICATE-----
+MIIDZzCCAk+gAwIBAgIQGx+ttiD5JNM2a/fH8YygWTANBgkqhkiG9w0BAQUFADBF
+MQswCQYDVQQGEwJHQjEYMBYGA1UEChMPVHJ1c3RpcyBMaW1pdGVkMRwwGgYDVQQL
+ExNUcnVzdGlzIEZQUyBSb290IENBMB4XDTAzMTIyMzEyMTQwNloXDTI0MDEyMTEx
+MzY1NFowRTELMAkGA1UEBhMCR0IxGDAWBgNVBAoTD1RydXN0aXMgTGltaXRlZDEc
+MBoGA1UECxMTVHJ1c3RpcyBGUFMgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQAD
+ggEPADCCAQoCggEBAMVQe547NdDfxIzNjpvto8A2mfRC6qc+gIMPpqdZh8mQRUN+
+AOqGeSoDvT03mYlmt+WKVoaTnGhLaASMk5MCPjDSNzoiYYkchU59j9WvezX2fihH
+iTHcDnlkH5nSW7r+f2C/revnPDgpai/lkQtV/+xvWNUtyd5MZnGPDNcE2gfmHhjj
+vSkCqPoc4Vu5g6hBSLwacY3nYuUtsuvffM/bq1rKMfFMIvMFE/eC+XN5DL7XSxzA
+0RU8k0Fk0ea+IxciAIleH2ulrG6nS4zto3Lmr2NNL4XSFDWaLk6M6jKYKIahkQlB
+OrTh4/L68MkKokHdqeMDx4gVOxzUGpTXn2RZEm0CAwEAAaNTMFEwDwYDVR0TAQH/
+BAUwAwEB/zAfBgNVHSMEGDAWgBS6+nEleYtXQSUhhgtx67JkDoshZzAdBgNVHQ4E
+FgQUuvpxJXmLV0ElIYYLceuyZA6LIWcwDQYJKoZIhvcNAQEFBQADggEBAH5Y//01
+GX2cGE+esCu8jowU/yyg2kdbw++BLa8F6nRIW/M+TgfHbcWzk88iNVy2P3UnXwmW
+zaD+vkAMXBJV+JOCyinpXj9WV4s4NvdFGkwozZ5BuO1WTISkQMi4sKUraXAEasP4
+1BIy+Q7DsdwyhEQsb8tGD+pmQQ9P8Vilpg0ND2HepZ5dfWWhPBfnqFVO76DH7cZE
+f1T1o+CP8HxVIo8ptoGj4W1OLBuAZ+ytIJ8MYmHVl/9D7S3B2l0pKoU/rGXuhg8F
+jZBf3+6f9L/uHfuY5H+QK4R4EA5sSVPvFVtlRkpdr7r7OnIdzfYliB6XzCGcKQEN
+ZetX2fNXlrtIzYE=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Buypass Class 2 Root CA O=Buypass AS-983163327
+# Subject: CN=Buypass Class 2 Root CA O=Buypass AS-983163327
+# Label: "Buypass Class 2 Root CA"
+# Serial: 2
+# MD5 Fingerprint: 46:a7:d2:fe:45:fb:64:5a:a8:59:90:9b:78:44:9b:29
+# SHA1 Fingerprint: 49:0a:75:74:de:87:0a:47:fe:58:ee:f6:c7:6b:eb:c6:0b:12:40:99
+# SHA256 Fingerprint: 9a:11:40:25:19:7c:5b:b9:5d:94:e6:3d:55:cd:43:79:08:47:b6:46:b2:3c:df:11:ad:a4:a0:0e:ff:15:fb:48
+-----BEGIN CERTIFICATE-----
+MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd
+MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg
+Q2xhc3MgMiBSb290IENBMB4XDTEwMTAyNjA4MzgwM1oXDTQwMTAyNjA4MzgwM1ow
+TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw
+HgYDVQQDDBdCdXlwYXNzIENsYXNzIDIgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB
+BQADggIPADCCAgoCggIBANfHXvfBB9R3+0Mh9PT1aeTuMgHbo4Yf5FkNuud1g1Lr
+6hxhFUi7HQfKjK6w3Jad6sNgkoaCKHOcVgb/S2TwDCo3SbXlzwx87vFKu3MwZfPV
+L4O2fuPn9Z6rYPnT8Z2SdIrkHJasW4DptfQxh6NR/Md+oW+OU3fUl8FVM5I+GC91
+1K2GScuVr1QGbNgGE41b/+EmGVnAJLqBcXmQRFBoJJRfuLMR8SlBYaNByyM21cHx
+MlAQTn/0hpPshNOOvEu/XAFOBz3cFIqUCqTqc/sLUegTBxj6DvEr0VQVfTzh97QZ
+QmdiXnfgolXsttlpF9U6r0TtSsWe5HonfOV116rLJeffawrbD02TTqigzXsu8lkB
+arcNuAeBfos4GzjmCleZPe4h6KP1DBbdi+w0jpwqHAAVF41og9JwnxgIzRFo1clr
+Us3ERo/ctfPYV3Me6ZQ5BL/T3jjetFPsaRyifsSP5BtwrfKi+fv3FmRmaZ9JUaLi
+FRhnBkp/1Wy1TbMz4GHrXb7pmA8y1x1LPC5aAVKRCfLf6o3YBkBjqhHk/sM3nhRS
+P/TizPJhk9H9Z2vXUq6/aKtAQ6BXNVN48FP4YUIHZMbXb5tMOA1jrGKvNouicwoN
+9SG9dKpN6nIDSdvHXx1iY8f93ZHsM+71bbRuMGjeyNYmsHVee7QHIJihdjK4TWxP
+AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMmAd+BikoL1Rpzz
+uvdMw964o605MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAU18h
+9bqwOlI5LJKwbADJ784g7wbylp7ppHR/ehb8t/W2+xUbP6umwHJdELFx7rxP462s
+A20ucS6vxOOto70MEae0/0qyexAQH6dXQbLArvQsWdZHEIjzIVEpMMpghq9Gqx3t
+OluwlN5E40EIosHsHdb9T7bWR9AUC8rmyrV7d35BH16Dx7aMOZawP5aBQW9gkOLo
++fsicdl9sz1Gv7SEr5AcD48Saq/v7h56rgJKihcrdv6sVIkkLE8/trKnToyokZf7
+KcZ7XC25y2a2t6hbElGFtQl+Ynhw/qlqYLYdDnkM/crqJIByw5c/8nerQyIKx+u2
+DISCLIBrQYoIwOula9+ZEsuK1V6ADJHgJgg2SMX6OBE1/yWDLfJ6v9r9jv6ly0Us
+H8SIU653DtmadsWOLB2jutXsMq7Aqqz30XpN69QH4kj3Io6wpJ9qzo6ysmD0oyLQ
+I+uUWnpp3Q+/QFesa1lQ2aOZ4W7+jQF5JyMV3pKdewlNWudLSDBaGOYKbeaP4NK7
+5t98biGCwWg5TbSYWGZizEqQXsP6JwSxeRV0mcy+rSDeJmAc61ZRpqPq5KM/p/9h
+3PFaTWwyI0PurKju7koSCTxdccK+efrCh2gdC/1cacwG0Jp9VJkqyTkaGa9LKkPz
+Y11aWOIv4x3kqdbQCtCev9eBCfHJxyYNrJgWVqA=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Buypass Class 3 Root CA O=Buypass AS-983163327
+# Subject: CN=Buypass Class 3 Root CA O=Buypass AS-983163327
+# Label: "Buypass Class 3 Root CA"
+# Serial: 2
+# MD5 Fingerprint: 3d:3b:18:9e:2c:64:5a:e8:d5:88:ce:0e:f9:37:c2:ec
+# SHA1 Fingerprint: da:fa:f7:fa:66:84:ec:06:8f:14:50:bd:c7:c2:81:a5:bc:a9:64:57
+# SHA256 Fingerprint: ed:f7:eb:bc:a2:7a:2a:38:4d:38:7b:7d:40:10:c6:66:e2:ed:b4:84:3e:4c:29:b4:ae:1d:5b:93:32:e6:b2:4d
+-----BEGIN CERTIFICATE-----
+MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd
+MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg
+Q2xhc3MgMyBSb290IENBMB4XDTEwMTAyNjA4Mjg1OFoXDTQwMTAyNjA4Mjg1OFow
+TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw
+HgYDVQQDDBdCdXlwYXNzIENsYXNzIDMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB
+BQADggIPADCCAgoCggIBAKXaCpUWUOOV8l6ddjEGMnqb8RB2uACatVI2zSRHsJ8Y
+ZLya9vrVediQYkwiL944PdbgqOkcLNt4EemOaFEVcsfzM4fkoF0LXOBXByow9c3E
+N3coTRiR5r/VUv1xLXA+58bEiuPwKAv0dpihi4dVsjoT/Lc+JzeOIuOoTyrvYLs9
+tznDDgFHmV0ST9tD+leh7fmdvhFHJlsTmKtdFoqwNxxXnUX/iJY2v7vKB3tvh2PX
+0DJq1l1sDPGzbjniazEuOQAnFN44wOwZZoYS6J1yFhNkUsepNxz9gjDthBgd9K5c
+/3ATAOux9TN6S9ZV+AWNS2mw9bMoNlwUxFFzTWsL8TQH2xc519woe2v1n/MuwU8X
+KhDzzMro6/1rqy6any2CbgTUUgGTLT2G/H783+9CHaZr77kgxve9oKeV/afmiSTY
+zIw0bOIjL9kSGiG5VZFvC5F5GQytQIgLcOJ60g7YaEi7ghM5EFjp2CoHxhLbWNvS
+O1UQRwUVZ2J+GGOmRj8JDlQyXr8NYnon74Do29lLBlo3WiXQCBJ31G8JUJc9yB3D
+34xFMFbG02SrZvPAXpacw8Tvw3xrizp5f7NJzz3iiZ+gMEuFuZyUJHmPfWupRWgP
+K9Dx2hzLabjKSWJtyNBjYt1gD1iqj6G8BaVmos8bdrKEZLFMOVLAMLrwjEsCsLa3
+AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEe4zf/lb+74suwv
+Tg75JbCOPGvDMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAACAj
+QTUEkMJAYmDv4jVM1z+s4jSQuKFvdvoWFqRINyzpkMLyPPgKn9iB5btb2iUspKdV
+cSQy9sgL8rxq+JOssgfCX5/bzMiKqr5qb+FJEMwx14C7u8jYog5kV+qi9cKpMRXS
+IGrs/CIBKM+GuIAeqcwRpTzyFrNHnfzSgCHEy9BHcEGhyoMZCCxt8l13nIoUE9Q2
+HJLw5QY33KbmkJs4j1xrG0aGQ0JfPgEHU1RdZX33inOhmlRaHylDFCfChQ+1iHsa
+O5S3HWCntZznKWlXWpuTekMwGwPXYshApqr8ZORK15FTAaggiG6cX0S5y2CBNOxv
+033aSF/rtJC8LakcC6wc1aJoIIAE1vyxjy+7SjENSoYc6+I2KSb12tjE8nVhz36u
+dmNKekBlk4f4HoCMhuWG1o8O/FMsYOgWYRqiPkN7zTlgVGr18okmAWiDSKIz6MkE
+kbIRNBE+6tBDGR8Dk5AM/1E9V/RBbuHLoL7ryWPNbczk+DaqaJ3tvV2XcEQNtg41
+3OEMXbugUZTLfhbrES+jkkXITHHZvMmZUldGL1DPvTVp9D0VzgalLA8+9oG6lLvD
+u79leNKGef9JOxqDDPDeeOzI8k1MGt6CKfjBWtrt7uYnXuhF0J0cUahoq0Tj0Itq
+4/g7u9xN12TyUb7mqqta6THuBrxzvxNiCp/HuZc=
+-----END CERTIFICATE-----
+
+# Issuer: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Subject: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Label: "T-TeleSec GlobalRoot Class 3"
+# Serial: 1
+# MD5 Fingerprint: ca:fb:40:a8:4e:39:92:8a:1d:fe:8e:2f:c4:27:ea:ef
+# SHA1 Fingerprint: 55:a6:72:3e:cb:f2:ec:cd:c3:23:74:70:19:9d:2a:be:11:e3:81:d1
+# SHA256 Fingerprint: fd:73:da:d3:1c:64:4f:f1:b4:3b:ef:0c:cd:da:96:71:0b:9c:d9:87:5e:ca:7e:31:70:7a:f3:e9:6d:52:2b:bd
+-----BEGIN CERTIFICATE-----
+MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
+KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
+BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
+YyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1
+OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
+aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
+ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN
+8ELg63iIVl6bmlQdTQyK9tPPcPRStdiTBONGhnFBSivwKixVA9ZIw+A5OO3yXDw/
+RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuhdfsaa3Ox+M6pCSzyU9XDFES4
+hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Zf3WHHx+xGwpzJFu5
+ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W0eDrXltM
+EnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1
+A/d2O2GCahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOy
+WL6ukK2YJ5f+AbGwUgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ
+1GSFS5mvJQQeyUapl96Cshtwn5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW30
+6gmv7PO15wWeph6KU1HWk4HMdJP2udqmJQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT
+91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMivgkeGj5asuRrDFR6fUNOuIml
+e9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7PHi4b6HQDWSieB4p
+TpPDpFQUWw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=EE Certification Centre Root CA O=AS Sertifitseerimiskeskus
+# Subject: CN=EE Certification Centre Root CA O=AS Sertifitseerimiskeskus
+# Label: "EE Certification Centre Root CA"
+# Serial: 112324828676200291871926431888494945866
+# MD5 Fingerprint: 43:5e:88:d4:7d:1a:4a:7e:fd:84:2e:52:eb:01:d4:6f
+# SHA1 Fingerprint: c9:a8:b9:e7:55:80:5e:58:e3:53:77:a7:25:eb:af:c3:7b:27:cc:d7
+# SHA256 Fingerprint: 3e:84:ba:43:42:90:85:16:e7:75:73:c0:99:2f:09:79:ca:08:4e:46:85:68:1f:f1:95:cc:ba:8a:22:9b:8a:76
+-----BEGIN CERTIFICATE-----
+MIIEAzCCAuugAwIBAgIQVID5oHPtPwBMyonY43HmSjANBgkqhkiG9w0BAQUFADB1
+MQswCQYDVQQGEwJFRTEiMCAGA1UECgwZQVMgU2VydGlmaXRzZWVyaW1pc2tlc2t1
+czEoMCYGA1UEAwwfRUUgQ2VydGlmaWNhdGlvbiBDZW50cmUgUm9vdCBDQTEYMBYG
+CSqGSIb3DQEJARYJcGtpQHNrLmVlMCIYDzIwMTAxMDMwMTAxMDMwWhgPMjAzMDEy
+MTcyMzU5NTlaMHUxCzAJBgNVBAYTAkVFMSIwIAYDVQQKDBlBUyBTZXJ0aWZpdHNl
+ZXJpbWlza2Vza3VzMSgwJgYDVQQDDB9FRSBDZXJ0aWZpY2F0aW9uIENlbnRyZSBS
+b290IENBMRgwFgYJKoZIhvcNAQkBFglwa2lAc2suZWUwggEiMA0GCSqGSIb3DQEB
+AQUAA4IBDwAwggEKAoIBAQDIIMDs4MVLqwd4lfNE7vsLDP90jmG7sWLqI9iroWUy
+euuOF0+W2Ap7kaJjbMeMTC55v6kF/GlclY1i+blw7cNRfdCT5mzrMEvhvH2/UpvO
+bntl8jixwKIy72KyaOBhU8E2lf/slLo2rpwcpzIP5Xy0xm90/XsY6KxX7QYgSzIw
+WFv9zajmofxwvI6Sc9uXp3whrj3B9UiHbCe9nyV0gVWw93X2PaRka9ZP585ArQ/d
+MtO8ihJTmMmJ+xAdTX7Nfh9WDSFwhfYggx/2uh8Ej+p3iDXE/+pOoYtNP2MbRMNE
+1CV2yreN1x5KZmTNXMWcg+HCCIia7E6j8T4cLNlsHaFLAgMBAAGjgYowgYcwDwYD
+VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBLyWj7qVhy/
+zQas8fElyalL1BSZMEUGA1UdJQQ+MDwGCCsGAQUFBwMCBggrBgEFBQcDAQYIKwYB
+BQUHAwMGCCsGAQUFBwMEBggrBgEFBQcDCAYIKwYBBQUHAwkwDQYJKoZIhvcNAQEF
+BQADggEBAHv25MANqhlHt01Xo/6tu7Fq1Q+e2+RjxY6hUFaTlrg4wCQiZrxTFGGV
+v9DHKpY5P30osxBAIWrEr7BSdxjhlthWXePdNl4dp1BUoMUq5KqMlIpPnTX/dqQG
+E5Gion0ARD9V04I8GtVbvFZMIi5GQ4okQC3zErg7cBqklrkar4dBGmoYDQZPxz5u
+uSlNDUmJEYcyW+ZLBMjkXOZ0c5RdFpgTlf7727FE5TpwrDdr5rMzcijJs1eg9gIW
+iAYLtqZLICjU3j2LrTcFU3T+bsy8QxdxXvnFzBqpYe73dgzzcvRyrc9yAjYHR8/v
+GVCJYMzpJJUPwssd8m92kMfMdcGWxZ0=
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH
+# Subject: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH
+# Label: "D-TRUST Root Class 3 CA 2 2009"
+# Serial: 623603
+# MD5 Fingerprint: cd:e0:25:69:8d:47:ac:9c:89:35:90:f7:fd:51:3d:2f
+# SHA1 Fingerprint: 58:e8:ab:b0:36:15:33:fb:80:f7:9b:1b:6d:29:d3:ff:8d:5f:00:f0
+# SHA256 Fingerprint: 49:e7:a4:42:ac:f0:ea:62:87:05:00:54:b5:25:64:b6:50:e4:f4:9e:42:e3:48:d6:aa:38:e0:39:e9:57:b1:c1
+-----BEGIN CERTIFICATE-----
+MIIEMzCCAxugAwIBAgIDCYPzMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNVBAYTAkRF
+MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMMHkQtVFJVU1QgUm9vdCBD
+bGFzcyAzIENBIDIgMjAwOTAeFw0wOTExMDUwODM1NThaFw0yOTExMDUwODM1NTha
+ME0xCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMM
+HkQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgMjAwOTCCASIwDQYJKoZIhvcNAQEB
+BQADggEPADCCAQoCggEBANOySs96R+91myP6Oi/WUEWJNTrGa9v+2wBoqOADER03
+UAifTUpolDWzU9GUY6cgVq/eUXjsKj3zSEhQPgrfRlWLJ23DEE0NkVJD2IfgXU42
+tSHKXzlABF9bfsyjxiupQB7ZNoTWSPOSHjRGICTBpFGOShrvUD9pXRl/RcPHAY9R
+ySPocq60vFYJfxLLHLGvKZAKyVXMD9O0Gu1HNVpK7ZxzBCHQqr0ME7UAyiZsxGsM
+lFqVlNpQmvH/pStmMaTJOKDfHR+4CS7zp+hnUquVH+BGPtikw8paxTGA6Eian5Rp
+/hnd2HN8gcqW3o7tszIFZYQ05ub9VxC1X3a/L7AQDcUCAwEAAaOCARowggEWMA8G
+A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFP3aFMSfMN4hvR5COfyrYyNJ4PGEMA4G
+A1UdDwEB/wQEAwIBBjCB0wYDVR0fBIHLMIHIMIGAoH6gfIZ6bGRhcDovL2RpcmVj
+dG9yeS5kLXRydXN0Lm5ldC9DTj1ELVRSVVNUJTIwUm9vdCUyMENsYXNzJTIwMyUy
+MENBJTIwMiUyMDIwMDksTz1ELVRydXN0JTIwR21iSCxDPURFP2NlcnRpZmljYXRl
+cmV2b2NhdGlvbmxpc3QwQ6BBoD+GPWh0dHA6Ly93d3cuZC10cnVzdC5uZXQvY3Js
+L2QtdHJ1c3Rfcm9vdF9jbGFzc18zX2NhXzJfMjAwOS5jcmwwDQYJKoZIhvcNAQEL
+BQADggEBAH+X2zDI36ScfSF6gHDOFBJpiBSVYEQBrLLpME+bUMJm2H6NMLVwMeni
+acfzcNsgFYbQDfC+rAF1hM5+n02/t2A7nPPKHeJeaNijnZflQGDSNiH+0LS4F9p0
+o3/U37CYAqxva2ssJSRyoWXuJVrl5jLn8t+rSfrzkGkj2wTZ51xY/GXUl77M/C4K
+zCUqNQT4YJEVdT1B/yMfGchs64JTBKbkTCJNjYy6zltz7GRUUG3RnFX7acM2w4y8
+PIWmawomDeCTmGCufsYkl4phX5GOZpIJhzbNi5stPvZR1FDUWSi9g/LMKHtThm3Y
+Johw1+qRzT65ysCQblrGXnRl11z+o+I=
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH
+# Subject: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH
+# Label: "D-TRUST Root Class 3 CA 2 EV 2009"
+# Serial: 623604
+# MD5 Fingerprint: aa:c6:43:2c:5e:2d:cd:c4:34:c0:50:4f:11:02:4f:b6
+# SHA1 Fingerprint: 96:c9:1b:0b:95:b4:10:98:42:fa:d0:d8:22:79:fe:60:fa:b9:16:83
+# SHA256 Fingerprint: ee:c5:49:6b:98:8c:e9:86:25:b9:34:09:2e:ec:29:08:be:d0:b0:f3:16:c2:d4:73:0c:84:ea:f1:f3:d3:48:81
+-----BEGIN CERTIFICATE-----
+MIIEQzCCAyugAwIBAgIDCYP0MA0GCSqGSIb3DQEBCwUAMFAxCzAJBgNVBAYTAkRF
+MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNVBAMMIUQtVFJVU1QgUm9vdCBD
+bGFzcyAzIENBIDIgRVYgMjAwOTAeFw0wOTExMDUwODUwNDZaFw0yOTExMDUwODUw
+NDZaMFAxCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNV
+BAMMIUQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgRVYgMjAwOTCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBAJnxhDRwui+3MKCOvXwEz75ivJn9gpfSegpn
+ljgJ9hBOlSJzmY3aFS3nBfwZcyK3jpgAvDw9rKFs+9Z5JUut8Mxk2og+KbgPCdM0
+3TP1YtHhzRnp7hhPTFiu4h7WDFsVWtg6uMQYZB7jM7K1iXdODL/ZlGsTl28So/6Z
+qQTMFexgaDbtCHu39b+T7WYxg4zGcTSHThfqr4uRjRxWQa4iN1438h3Z0S0NL2lR
+p75mpoo6Kr3HGrHhFPC+Oh25z1uxav60sUYgovseO3Dvk5h9jHOW8sXvhXCtKSb8
+HgQ+HKDYD8tSg2J87otTlZCpV6LqYQXY+U3EJ/pure3511H3a6UCAwEAAaOCASQw
+ggEgMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNOUikxiEyoZLsyvcop9Ntea
+HNxnMA4GA1UdDwEB/wQEAwIBBjCB3QYDVR0fBIHVMIHSMIGHoIGEoIGBhn9sZGFw
+Oi8vZGlyZWN0b3J5LmQtdHJ1c3QubmV0L0NOPUQtVFJVU1QlMjBSb290JTIwQ2xh
+c3MlMjAzJTIwQ0ElMjAyJTIwRVYlMjAyMDA5LE89RC1UcnVzdCUyMEdtYkgsQz1E
+RT9jZXJ0aWZpY2F0ZXJldm9jYXRpb25saXN0MEagRKBChkBodHRwOi8vd3d3LmQt
+dHJ1c3QubmV0L2NybC9kLXRydXN0X3Jvb3RfY2xhc3NfM19jYV8yX2V2XzIwMDku
+Y3JsMA0GCSqGSIb3DQEBCwUAA4IBAQA07XtaPKSUiO8aEXUHL7P+PPoeUSbrh/Yp
+3uDx1MYkCenBz1UbtDDZzhr+BlGmFaQt77JLvyAoJUnRpjZ3NOhk31KxEcdzes05
+nsKtjHEh8lprr988TlWvsoRlFIm5d8sqMb7Po23Pb0iUMkZv53GMoKaEGTcH8gNF
+CSuGdXzfX2lXANtu2KZyIktQ1HWYVt+3GP9DQ1CuekR78HlR10M9p9OB0/DJT7na
+xpeG0ILD5EJt/rDiZE4OJudANCa1CInXCGNjOCd1HjPqbqjdn5lPdE2BiYBL3ZqX
+KVwvvoFBuYz/6n1gBp7N1z3TLqMVvKjmJuVvw9y4AyHqnxbxLFS1
+-----END CERTIFICATE-----
+
+# Issuer: CN=CA Disig Root R2 O=Disig a.s.
+# Subject: CN=CA Disig Root R2 O=Disig a.s.
+# Label: "CA Disig Root R2"
+# Serial: 10572350602393338211
+# MD5 Fingerprint: 26:01:fb:d8:27:a7:17:9a:45:54:38:1a:43:01:3b:03
+# SHA1 Fingerprint: b5:61:eb:ea:a4:de:e4:25:4b:69:1a:98:a5:57:47:c2:34:c7:d9:71
+# SHA256 Fingerprint: e2:3d:4a:03:6d:7b:70:e9:f5:95:b1:42:20:79:d2:b9:1e:df:bb:1f:b6:51:a0:63:3e:aa:8a:9d:c5:f8:07:03
+-----BEGIN CERTIFICATE-----
+MIIFaTCCA1GgAwIBAgIJAJK4iNuwisFjMA0GCSqGSIb3DQEBCwUAMFIxCzAJBgNV
+BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu
+MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIyMB4XDTEyMDcxOTA5MTUzMFoXDTQy
+MDcxOTA5MTUzMFowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx
+EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjIw
+ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCio8QACdaFXS1tFPbCw3Oe
+NcJxVX6B+6tGUODBfEl45qt5WDza/3wcn9iXAng+a0EE6UG9vgMsRfYvZNSrXaNH
+PWSb6WiaxswbP7q+sos0Ai6YVRn8jG+qX9pMzk0DIaPY0jSTVpbLTAwAFjxfGs3I
+x2ymrdMxp7zo5eFm1tL7A7RBZckQrg4FY8aAamkw/dLukO8NJ9+flXP04SXabBbe
+QTg06ov80egEFGEtQX6sx3dOy1FU+16SGBsEWmjGycT6txOgmLcRK7fWV8x8nhfR
+yyX+hk4kLlYMeE2eARKmK6cBZW58Yh2EhN/qwGu1pSqVg8NTEQxzHQuyRpDRQjrO
+QG6Vrf/GlK1ul4SOfW+eioANSW1z4nuSHsPzwfPrLgVv2RvPN3YEyLRa5Beny912
+H9AZdugsBbPWnDTYltxhh5EF5EQIM8HauQhl1K6yNg3ruji6DOWbnuuNZt2Zz9aJ
+QfYEkoopKW1rOhzndX0CcQ7zwOe9yxndnWCywmZgtrEE7snmhrmaZkCo5xHtgUUD
+i/ZnWejBBhG93c+AAk9lQHhcR1DIm+YfgXvkRKhbhZri3lrVx/k6RGZL5DJUfORs
+nLMOPReisjQS1n6yqEm70XooQL6iFh/f5DcfEXP7kAplQ6INfPgGAVUzfbANuPT1
+rqVCV3w2EYx7XsQDnYx5nQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud
+DwEB/wQEAwIBBjAdBgNVHQ4EFgQUtZn4r7CU9eMg1gqtzk5WpC5uQu0wDQYJKoZI
+hvcNAQELBQADggIBACYGXnDnZTPIgm7ZnBc6G3pmsgH2eDtpXi/q/075KMOYKmFM
+tCQSin1tERT3nLXK5ryeJ45MGcipvXrA1zYObYVybqjGom32+nNjf7xueQgcnYqf
+GopTpti72TVVsRHFqQOzVju5hJMiXn7B9hJSi+osZ7z+Nkz1uM/Rs0mSO9MpDpkb
+lvdhuDvEK7Z4bLQjb/D907JedR+Zlais9trhxTF7+9FGs9K8Z7RiVLoJ92Owk6Ka
++elSLotgEqv89WBW7xBci8QaQtyDW2QOy7W81k/BfDxujRNt+3vrMNDcTa/F1bal
+TFtxyegxvug4BkihGuLq0t4SOVga/4AOgnXmt8kHbA7v/zjxmHHEt38OFdAlab0i
+nSvtBfZGR6ztwPDUO+Ls7pZbkBNOHlY667DvlruWIxG68kOGdGSVyCh13x01utI3
+gzhTODY7z2zp+WsO0PsE6E9312UBeIYMej4hYvF/Y3EMyZ9E26gnonW+boE+18Dr
+G5gPcFw0sorMwIUY6256s/daoQe/qUKS82Ail+QUoQebTnbAjn39pCXHR+3/H3Os
+zMOl6W8KjptlwlCFtaOgUxLMVYdh84GuEEZhvUQhuMI9dM9+JDX6HAcOmz0iyu8x
+L4ysEr3vQCj8KWefshNPZiTEUxnpHikV7+ZtsH8tZ/3zbBt1RqPlShfppNcL
+-----END CERTIFICATE-----
+
+# Issuer: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV
+# Subject: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV
+# Label: "ACCVRAIZ1"
+# Serial: 6828503384748696800
+# MD5 Fingerprint: d0:a0:5a:ee:05:b6:09:94:21:a1:7d:f1:b2:29:82:02
+# SHA1 Fingerprint: 93:05:7a:88:15:c6:4f:ce:88:2f:fa:91:16:52:28:78:bc:53:64:17
+# SHA256 Fingerprint: 9a:6e:c0:12:e1:a7:da:9d:be:34:19:4d:47:8a:d7:c0:db:18:22:fb:07:1d:f1:29:81:49:6e:d1:04:38:41:13
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA
+# Subject: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA
+# Label: "TWCA Global Root CA"
+# Serial: 3262
+# MD5 Fingerprint: f9:03:7e:cf:e6:9e:3c:73:7a:2a:90:07:69:ff:2b:96
+# SHA1 Fingerprint: 9c:bb:48:53:f6:a4:f6:d3:52:a4:e8:32:52:55:60:13:f5:ad:af:65
+# SHA256 Fingerprint: 59:76:90:07:f7:68:5d:0f:cd:50:87:2f:9f:95:d5:75:5a:5b:2b:45:7d:81:f3:69:2b:61:0a:98:67:2f:0e:1b
+-----BEGIN CERTIFICATE-----
+MIIFQTCCAymgAwIBAgICDL4wDQYJKoZIhvcNAQELBQAwUTELMAkGA1UEBhMCVFcx
+EjAQBgNVBAoTCVRBSVdBTi1DQTEQMA4GA1UECxMHUm9vdCBDQTEcMBoGA1UEAxMT
+VFdDQSBHbG9iYWwgUm9vdCBDQTAeFw0xMjA2MjcwNjI4MzNaFw0zMDEyMzExNTU5
+NTlaMFExCzAJBgNVBAYTAlRXMRIwEAYDVQQKEwlUQUlXQU4tQ0ExEDAOBgNVBAsT
+B1Jvb3QgQ0ExHDAaBgNVBAMTE1RXQ0EgR2xvYmFsIFJvb3QgQ0EwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCwBdvI64zEbooh745NnHEKH1Jw7W2CnJfF
+10xORUnLQEK1EjRsGcJ0pDFfhQKX7EMzClPSnIyOt7h52yvVavKOZsTuKwEHktSz
+0ALfUPZVr2YOy+BHYC8rMjk1Ujoog/h7FsYYuGLWRyWRzvAZEk2tY/XTP3VfKfCh
+MBwqoJimFb3u/Rk28OKRQ4/6ytYQJ0lM793B8YVwm8rqqFpD/G2Gb3PpN0Wp8DbH
+zIh1HrtsBv+baz4X7GGqcXzGHaL3SekVtTzWoWH1EfcFbx39Eb7QMAfCKbAJTibc
+46KokWofwpFFiFzlmLhxpRUZyXx1EcxwdE8tmx2RRP1WKKD+u4ZqyPpcC1jcxkt2
+yKsi2XMPpfRaAok/T54igu6idFMqPVMnaR1sjjIsZAAmY2E2TqNGtz99sy2sbZCi
+laLOz9qC5wc0GZbpuCGqKX6mOL6OKUohZnkfs8O1CWfe1tQHRvMq2uYiN2DLgbYP
+oA/pyJV/v1WRBXrPPRXAb94JlAGD1zQbzECl8LibZ9WYkTunhHiVJqRaCPgrdLQA
+BDzfuBSO6N+pjWxnkjMdwLfS7JLIvgm/LCkFbwJrnu+8vyq8W8BQj0FwcYeyTbcE
+qYSjMq+u7msXi7Kx/mzhkIyIqJdIzshNy/MGz19qCkKxHh53L46g5pIOBvwFItIm
+4TFRfTLcDwIDAQABoyMwITAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB
+/zANBgkqhkiG9w0BAQsFAAOCAgEAXzSBdu+WHdXltdkCY4QWwa6gcFGn90xHNcgL
+1yg9iXHZqjNB6hQbbCEAwGxCGX6faVsgQt+i0trEfJdLjbDorMjupWkEmQqSpqsn
+LhpNgb+E1HAerUf+/UqdM+DyucRFCCEK2mlpc3INvjT+lIutwx4116KD7+U4x6WF
+H6vPNOw/KP4M8VeGTslV9xzU2KV9Bnpv1d8Q34FOIWWxtuEXeZVFBs5fzNxGiWNo
+RI2T9GRwoD2dKAXDOXC4Ynsg/eTb6QihuJ49CcdP+yz4k3ZB3lLg4VfSnQO8d57+
+nile98FRYB/e2guyLXW3Q0iT5/Z5xoRdgFlglPx4mI88k1HtQJAH32RjJMtOcQWh
+15QaiDLxInQirqWm2BJpTGCjAu4r7NRjkgtevi92a6O2JryPA9gK8kxkRr05YuWW
+6zRjESjMlfGt7+/cgFhI6Uu46mWs6fyAtbXIRfmswZ/ZuepiiI7E8UuDEq3mi4TW
+nsLrgxifarsbJGAzcMzs9zLzXNl5fe+epP7JI8Mk7hWSsT2RTyaGvWZzJBPqpK5j
+wa19hAM8EHiGG3njxPPyBJUgriOCxLM6AGK/5jYk4Ve6xx6QddVfP5VhK8E7zeWz
+aGHQRiapIVJpLesux+t3zqY6tQMzT3bR51xUAV3LePTJDL/PEo4XLSNolOer/qmy
+KwbQBM0=
+-----END CERTIFICATE-----
+
+# Issuer: CN=TeliaSonera Root CA v1 O=TeliaSonera
+# Subject: CN=TeliaSonera Root CA v1 O=TeliaSonera
+# Label: "TeliaSonera Root CA v1"
+# Serial: 199041966741090107964904287217786801558
+# MD5 Fingerprint: 37:41:49:1b:18:56:9a:26:f5:ad:c2:66:fb:40:a5:4c
+# SHA1 Fingerprint: 43:13:bb:96:f1:d5:86:9b:c1:4e:6a:92:f6:cf:f6:34:69:87:82:37
+# SHA256 Fingerprint: dd:69:36:fe:21:f8:f0:77:c1:23:a1:a5:21:c1:22:24:f7:22:55:b7:3e:03:a7:26:06:93:e8:a2:4b:0f:a3:89
+-----BEGIN CERTIFICATE-----
+MIIFODCCAyCgAwIBAgIRAJW+FqD3LkbxezmCcvqLzZYwDQYJKoZIhvcNAQEFBQAw
+NzEUMBIGA1UECgwLVGVsaWFTb25lcmExHzAdBgNVBAMMFlRlbGlhU29uZXJhIFJv
+b3QgQ0EgdjEwHhcNMDcxMDE4MTIwMDUwWhcNMzIxMDE4MTIwMDUwWjA3MRQwEgYD
+VQQKDAtUZWxpYVNvbmVyYTEfMB0GA1UEAwwWVGVsaWFTb25lcmEgUm9vdCBDQSB2
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMK+6yfwIaPzaSZVfp3F
+VRaRXP3vIb9TgHot0pGMYzHw7CTww6XScnwQbfQ3t+XmfHnqjLWCi65ItqwA3GV1
+7CpNX8GH9SBlK4GoRz6JI5UwFpB/6FcHSOcZrr9FZ7E3GwYq/t75rH2D+1665I+X
+Z75Ljo1kB1c4VWk0Nj0TSO9P4tNmHqTPGrdeNjPUtAa9GAH9d4RQAEX1jF3oI7x+
+/jXh7VB7qTCNGdMJjmhnXb88lxhTuylixcpecsHHltTbLaC0H2kD7OriUPEMPPCs
+81Mt8Bz17Ww5OXOAFshSsCPN4D7c3TxHoLs1iuKYaIu+5b9y7tL6pe0S7fyYGKkm
+dtwoSxAgHNN/Fnct7W+A90m7UwW7XWjH1Mh1Fj+JWov3F0fUTPHSiXk+TT2YqGHe
+Oh7S+F4D4MHJHIzTjU3TlTazN19jY5szFPAtJmtTfImMMsJu7D0hADnJoWjiUIMu
+sDor8zagrC/kb2HCUQk5PotTubtn2txTuXZZNp1D5SDgPTJghSJRt8czu90VL6R4
+pgd7gUY2BIbdeTXHlSw7sKMXNeVzH7RcWe/a6hBle3rQf5+ztCo3O3CLm1u5K7fs
+slESl1MpWtTwEhDcTwK7EpIvYtQ/aUN8Ddb8WHUBiJ1YFkveupD/RwGJBmr2X7KQ
+arMCpgKIv7NHfirZ1fpoeDVNAgMBAAGjPzA9MA8GA1UdEwEB/wQFMAMBAf8wCwYD
+VR0PBAQDAgEGMB0GA1UdDgQWBBTwj1k4ALP1j5qWDNXr+nuqF+gTEjANBgkqhkiG
+9w0BAQUFAAOCAgEAvuRcYk4k9AwI//DTDGjkk0kiP0Qnb7tt3oNmzqjMDfz1mgbl
+dxSR651Be5kqhOX//CHBXfDkH1e3damhXwIm/9fH907eT/j3HEbAek9ALCI18Bmx
+0GtnLLCo4MBANzX2hFxc469CeP6nyQ1Q6g2EdvZR74NTxnr/DlZJLo961gzmJ1Tj
+TQpgcmLNkQfWpb/ImWvtxBnmq0wROMVvMeJuScg/doAmAyYp4Db29iBT4xdwNBed
+Y2gea+zDTYa4EzAvXUYNR0PVG6pZDrlcjQZIrXSHX8f8MVRBE+LHIQ6e4B4N4cB7
+Q4WQxYpYxmUKeFfyxiMPAdkgS94P+5KFdSpcc41teyWRyu5FrgZLAMzTsVlQ2jqI
+OylDRl6XK1TOU2+NSueW+r9xDkKLfP0ooNBIytrEgUy7onOTJsjrDNYmiLbAJM+7
+vVvrdX3pCI6GMyx5dwlppYn8s3CQh3aP0yK7Qs69cwsgJirQmz1wHiRszYd2qReW
+t88NkvuOGKmYSdGe/mBEciG5Ge3C9THxOUiIkCR1VBatzvT4aRRkOfujuLpwQMcn
+HL/EVlP6Y2XQ8xwOFvVrhlhNGNTkDY6lnVuR3HYkUD/GKvvZt5y11ubQ2egZixVx
+SK236thZiNSQvxaz2emsWWFUyBy6ysHK4bkgTI86k4mloMy/0/Z1pHWWbVY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=E-Tugra Certification Authority O=E-Tu\u011fra EBG Bili\u015fim Teknolojileri ve Hizmetleri A.\u015e. OU=E-Tugra Sertifikasyon Merkezi
+# Subject: CN=E-Tugra Certification Authority O=E-Tu\u011fra EBG Bili\u015fim Teknolojileri ve Hizmetleri A.\u015e. OU=E-Tugra Sertifikasyon Merkezi
+# Label: "E-Tugra Certification Authority"
+# Serial: 7667447206703254355
+# MD5 Fingerprint: b8:a1:03:63:b0:bd:21:71:70:8a:6f:13:3a:bb:79:49
+# SHA1 Fingerprint: 51:c6:e7:08:49:06:6e:f3:92:d4:5c:a0:0d:6d:a3:62:8f:c3:52:39
+# SHA256 Fingerprint: b0:bf:d5:2b:b0:d7:d9:bd:92:bf:5d:4d:c1:3d:a2:55:c0:2c:54:2f:37:83:65:ea:89:39:11:f5:5e:55:f2:3c
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Subject: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Label: "T-TeleSec GlobalRoot Class 2"
+# Serial: 1
+# MD5 Fingerprint: 2b:9b:9e:e4:7b:6c:1f:00:72:1a:cc:c1:77:79:df:6a
+# SHA1 Fingerprint: 59:0d:2d:7d:88:4f:40:2e:61:7e:a5:62:32:17:65:cf:17:d8:94:e9
+# SHA256 Fingerprint: 91:e2:f5:78:8d:58:10:eb:a7:ba:58:73:7d:e1:54:8a:8e:ca:cd:01:45:98:bc:0b:14:3e:04:1b:17:05:25:52
+-----BEGIN CERTIFICATE-----
+MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
+KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
+BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
+YyBHbG9iYWxSb290IENsYXNzIDIwHhcNMDgxMDAxMTA0MDE0WhcNMzMxMDAxMjM1
+OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
+aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
+ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDIwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqX9obX+hzkeXaXPSi5kfl82hVYAUd
+AqSzm1nzHoqvNK38DcLZSBnuaY/JIPwhqgcZ7bBcrGXHX+0CfHt8LRvWurmAwhiC
+FoT6ZrAIxlQjgeTNuUk/9k9uN0goOA/FvudocP05l03Sx5iRUKrERLMjfTlH6VJi
+1hKTXrcxlkIF+3anHqP1wvzpesVsqXFP6st4vGCvx9702cu+fjOlbpSD8DT6Iavq
+jnKgP6TeMFvvhk1qlVtDRKgQFRzlAVfFmPHmBiiRqiDFt1MmUUOyCxGVWOHAD3bZ
+wI18gfNycJ5v/hqO2V81xrJvNHy+SE/iWjnX2J14np+GPgNeGYtEotXHAgMBAAGj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS/
+WSA2AHmgoCJrjNXyYdK4LMuCSjANBgkqhkiG9w0BAQsFAAOCAQEAMQOiYQsfdOhy
+NsZt+U2e+iKo4YFWz827n+qrkRk4r6p8FU3ztqONpfSO9kSpp+ghla0+AGIWiPAC
+uvxhI+YzmzB6azZie60EI4RYZeLbK4rnJVM3YlNfvNoBYimipidx5joifsFvHZVw
+IEoHNN/q/xWA5brXethbdXwFeilHfkCoMRN3zUA7tFFHei4R40cR3p1m0IvVVGb6
+g1XqfMIpiRvpb7PO4gWEyS8+eIVibslfwXhjdFjASBgMmTnrpMwatXlajRWc2BQN
+9noHV8cigwUtPJslJj0Ys6lDfMjIq2SPDqO/nBudMNva0Bkuqjzx+zOAduTNrRlP
+BSeOE6Fuwg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Atos TrustedRoot 2011 O=Atos
+# Subject: CN=Atos TrustedRoot 2011 O=Atos
+# Label: "Atos TrustedRoot 2011"
+# Serial: 6643877497813316402
+# MD5 Fingerprint: ae:b9:c4:32:4b:ac:7f:5d:66:cc:77:94:bb:2a:77:56
+# SHA1 Fingerprint: 2b:b1:f5:3e:55:0c:1d:c5:f1:d4:e6:b7:6a:46:4b:55:06:02:ac:21
+# SHA256 Fingerprint: f3:56:be:a2:44:b7:a9:1e:b3:5d:53:ca:9a:d7:86:4a:ce:01:8e:2d:35:d5:f8:f9:6d:df:68:a6:f4:1a:a4:74
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIIXDPLYixfszIwDQYJKoZIhvcNAQELBQAwPDEeMBwGA1UE
+AwwVQXRvcyBUcnVzdGVkUm9vdCAyMDExMQ0wCwYDVQQKDARBdG9zMQswCQYDVQQG
+EwJERTAeFw0xMTA3MDcxNDU4MzBaFw0zMDEyMzEyMzU5NTlaMDwxHjAcBgNVBAMM
+FUF0b3MgVHJ1c3RlZFJvb3QgMjAxMTENMAsGA1UECgwEQXRvczELMAkGA1UEBhMC
+REUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCVhTuXbyo7LjvPpvMp
+Nb7PGKw+qtn4TaA+Gke5vJrf8v7MPkfoepbCJI419KkM/IL9bcFyYie96mvr54rM
+VD6QUM+A1JX76LWC1BTFtqlVJVfbsVD2sGBkWXppzwO3bw2+yj5vdHLqqjAqc2K+
+SZFhyBH+DgMq92og3AIVDV4VavzjgsG1xZ1kCWyjWZgHJ8cblithdHFsQ/H3NYkQ
+4J7sVaE3IqKHBAUsR320HLliKWYoyrfhk/WklAOZuXCFteZI6o1Q/NnezG8HDt0L
+cp2AMBYHlT8oDv3FdU9T1nSatCQujgKRz3bFmx5VdJx4IbHwLfELn8LVlhgf8FQi
+eowHAgMBAAGjfTB7MB0GA1UdDgQWBBSnpQaxLKYJYO7Rl+lwrrw7GWzbITAPBgNV
+HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKelBrEspglg7tGX6XCuvDsZbNshMBgG
+A1UdIAQRMA8wDQYLKwYBBAGwLQMEAQEwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3
+DQEBCwUAA4IBAQAmdzTblEiGKkGdLD4GkGDEjKwLVLgfuXvTBznk+j57sj1O7Z8j
+vZfza1zv7v1Apt+hk6EKhqzvINB5Ab149xnYJDE0BAGmuhWawyfc2E8PzBhj/5kP
+DpFrdRbhIfzYJsdHt6bPWHJxfrrhTZVHO8mvbaG0weyJ9rQPOLXiZNwlz6bb65pc
+maHFCN795trV1lpFDMS3wrUU77QR/w4VtfX128a961qn8FYiqTxlVMYVqL2Gns2D
+lmh6cYGJ4Qvh6hEbaAjMaZ7snkGeRDImeuKHCnE96+RapNLbxc3G3mB/ufNPRJLv
+KrcYPqcZ2Qt9sTdBQrC6YB3y/gkRsPCHe6ed
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 1 G3"
+# Serial: 687049649626669250736271037606554624078720034195
+# MD5 Fingerprint: a4:bc:5b:3f:fe:37:9a:fa:64:f0:e2:fa:05:3d:0b:ab
+# SHA1 Fingerprint: 1b:8e:ea:57:96:29:1a:c9:39:ea:b8:0a:81:1a:73:73:c0:93:79:67
+# SHA256 Fingerprint: 8a:86:6f:d1:b2:76:b5:7e:57:8e:92:1c:65:82:8a:2b:ed:58:e9:f2:f2:88:05:41:34:b7:f1:f4:bf:c9:cc:74
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIUeFhfLq0sGUvjNwc1NBMotZbUZZMwDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMSBHMzAeFw0xMjAxMTIxNzI3NDRaFw00
+MjAxMTIxNzI3NDRaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDEgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvlAQjunybEC0BJyFuTHK3C3kEakEPBtV
+wedYMB0ktMPvhd6MLOHBPd+C5k+tR4ds7FtJwUrVu4/sh6x/gpqG7D0DmVIB0jWe
+rNrwU8lmPNSsAgHaJNM7qAJGr6Qc4/hzWHa39g6QDbXwz8z6+cZM5cOGMAqNF341
+68Xfuw6cwI2H44g4hWf6Pser4BOcBRiYz5P1sZK0/CPTz9XEJ0ngnjybCKOLXSoh
+4Pw5qlPafX7PGglTvF0FBM+hSo+LdoINofjSxxR3W5A2B4GbPgb6Ul5jxaYA/qXp
+UhtStZI5cgMJYr2wYBZupt0lwgNm3fME0UDiTouG9G/lg6AnhF4EwfWQvTA9xO+o
+abw4m6SkltFi2mnAAZauy8RRNOoMqv8hjlmPSlzkYZqn0ukqeI1RPToV7qJZjqlc
+3sX5kCLliEVx3ZGZbHqfPT2YfF72vhZooF6uCyP8Wg+qInYtyaEQHeTTRCOQiJ/G
+KubX9ZqzWB4vMIkIG1SitZgj7Ah3HJVdYdHLiZxfokqRmu8hqkkWCKi9YSgxyXSt
+hfbZxbGL0eUQMk1fiyA6PEkfM4VZDdvLCXVDaXP7a3F98N/ETH3Goy7IlXnLc6KO
+Tk0k+17kBL5yG6YnLUlamXrXXAkgt3+UuU/xDRxeiEIbEbfnkduebPRq34wGmAOt
+zCjvpUfzUwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQUo5fW816iEOGrRZ88F2Q87gFwnMwwDQYJKoZIhvcNAQELBQAD
+ggIBABj6W3X8PnrHX3fHyt/PX8MSxEBd1DKquGrX1RUVRpgjpeaQWxiZTOOtQqOC
+MTaIzen7xASWSIsBx40Bz1szBpZGZnQdT+3Btrm0DWHMY37XLneMlhwqI2hrhVd2
+cDMT/uFPpiN3GPoajOi9ZcnPP/TJF9zrx7zABC4tRi9pZsMbj/7sPtPKlL92CiUN
+qXsCHKnQO18LwIE6PWThv6ctTr1NxNgpxiIY0MWscgKCP6o6ojoilzHdCGPDdRS5
+YCgtW2jgFqlmgiNR9etT2DGbe+m3nUvriBbP+V04ikkwj+3x6xn0dxoxGE1nVGwv
+b2X52z3sIexe9PSLymBlVNFxZPT5pqOBMzYzcfCkeF9OrYMh3jRJjehZrJ3ydlo2
+8hP0r+AJx2EqbPfgna67hkooby7utHnNkDPDs3b69fBsnQGQ+p6Q9pxyz0fawx/k
+NSBT8lTR32GDpgLiJTjehTItXnOQUl1CxM49S+H5GYQd1aJQzEH7QRTDvdbJWqNj
+ZgKAvQU6O0ec7AAmTPWIUb+oI38YB7AL7YsmoWTTYUrrXJ/es69nA7Mf3W1daWhp
+q1467HxpvMc7hU6eFbm0FU/DlXpY18ls6Wy58yljXrQs8C097Vpl4KlbQMJImYFt
+nh8GKjwStIsPm6Ik8KaN1nrgS7ZklmOVhMJKzRwuJIczYOXD
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 2 G3"
+# Serial: 390156079458959257446133169266079962026824725800
+# MD5 Fingerprint: af:0c:86:6e:bf:40:2d:7f:0b:3e:12:50:ba:12:3d:06
+# SHA1 Fingerprint: 09:3c:61:f3:8b:8b:dc:7d:55:df:75:38:02:05:00:e1:25:f5:c8:36
+# SHA256 Fingerprint: 8f:e4:fb:0a:f9:3a:4d:0d:67:db:0b:eb:b2:3e:37:c7:1b:f3:25:dc:bc:dd:24:0e:a0:4d:af:58:b4:7e:18:40
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIURFc0JFuBiZs18s64KztbpybwdSgwDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMiBHMzAeFw0xMjAxMTIxODU5MzJaFw00
+MjAxMTIxODU5MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDIgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQChriWyARjcV4g/Ruv5r+LrI3HimtFhZiFf
+qq8nUeVuGxbULX1QsFN3vXg6YOJkApt8hpvWGo6t/x8Vf9WVHhLL5hSEBMHfNrMW
+n4rjyduYNM7YMxcoRvynyfDStNVNCXJJ+fKH46nafaF9a7I6JaltUkSs+L5u+9ym
+c5GQYaYDFCDy54ejiK2toIz/pgslUiXnFgHVy7g1gQyjO/Dh4fxaXc6AcW34Sas+
+O7q414AB+6XrW7PFXmAqMaCvN+ggOp+oMiwMzAkd056OXbxMmO7FGmh77FOm6RQ1
+o9/NgJ8MSPsc9PG/Srj61YxxSscfrf5BmrODXfKEVu+lV0POKa2Mq1W/xPtbAd0j
+IaFYAI7D0GoT7RPjEiuA3GfmlbLNHiJuKvhB1PLKFAeNilUSxmn1uIZoL1NesNKq
+IcGY5jDjZ1XHm26sGahVpkUG0CM62+tlXSoREfA7T8pt9DTEceT/AFr2XK4jYIVz
+8eQQsSWu1ZK7E8EM4DnatDlXtas1qnIhO4M15zHfeiFuuDIIfR0ykRVKYnLP43eh
+vNURG3YBZwjgQQvD6xVu+KQZ2aKrr+InUlYrAoosFCT5v0ICvybIxo/gbjh9Uy3l
+7ZizlWNof/k19N+IxWA1ksB8aRxhlRbQ694Lrz4EEEVlWFA4r0jyWbYW8jwNkALG
+cC4BrTwV1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQU7edvdlq/YOxJW8ald7tyFnGbxD0wDQYJKoZIhvcNAQELBQAD
+ggIBAJHfgD9DCX5xwvfrs4iP4VGyvD11+ShdyLyZm3tdquXK4Qr36LLTn91nMX66
+AarHakE7kNQIXLJgapDwyM4DYvmL7ftuKtwGTTwpD4kWilhMSA/ohGHqPHKmd+RC
+roijQ1h5fq7KpVMNqT1wvSAZYaRsOPxDMuHBR//47PERIjKWnML2W2mWeyAMQ0Ga
+W/ZZGYjeVYg3UQt4XAoeo0L9x52ID8DyeAIkVJOviYeIyUqAHerQbj5hLja7NQ4n
+lv1mNDthcnPxFlxHBlRJAHpYErAK74X9sbgzdWqTHBLmYF5vHX/JHyPLhGGfHoJE
++V+tYlUkmlKY7VHnoX6XOuYvHxHaU4AshZ6rNRDbIl9qxV6XU/IyAgkwo1jwDQHV
+csaxfGl7w/U2Rcxhbl5MlMVerugOXou/983g7aEOGzPuVBj+D77vfoRrQ+NwmNtd
+dbINWQeFFSM51vHfqSYP1kjHs6Yi9TM3WpVHn3u6GBVv/9YUZINJ0gpnIdsPNWNg
+KCLjsZWDzYWm3S8P52dSbrsvhXz1SnPnxT7AvSESBT/8twNJAlvIJebiVDj1eYeM
+HVOyToV7BjjHLPj4sHKNJeV3UvQDHEimUF+IIDBu8oJDqz2XhOdT+yHBTw8imoa4
+WSr2Rz0ZiC3oheGe7IUIarFsNMkd7EgrO3jtZsSOeWmD3n+M
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 3 G3"
+# Serial: 268090761170461462463995952157327242137089239581
+# MD5 Fingerprint: df:7d:b9:ad:54:6f:68:a1:df:89:57:03:97:43:b0:d7
+# SHA1 Fingerprint: 48:12:bd:92:3c:a8:c4:39:06:e7:30:6d:27:96:e6:a4:cf:22:2e:7d
+# SHA256 Fingerprint: 88:ef:81:de:20:2e:b0:18:45:2e:43:f8:64:72:5c:ea:5f:bd:1f:c2:d9:d2:05:73:07:09:c5:d8:b8:69:0f:46
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIULvWbAiin23r/1aOp7r0DoM8Sah0wDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMyBHMzAeFw0xMjAxMTIyMDI2MzJaFw00
+MjAxMTIyMDI2MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDMgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCzyw4QZ47qFJenMioKVjZ/aEzHs286IxSR
+/xl/pcqs7rN2nXrpixurazHb+gtTTK/FpRp5PIpM/6zfJd5O2YIyC0TeytuMrKNu
+FoM7pmRLMon7FhY4futD4tN0SsJiCnMK3UmzV9KwCoWdcTzeo8vAMvMBOSBDGzXR
+U7Ox7sWTaYI+FrUoRqHe6okJ7UO4BUaKhvVZR74bbwEhELn9qdIoyhA5CcoTNs+c
+ra1AdHkrAj80//ogaX3T7mH1urPnMNA3I4ZyYUUpSFlob3emLoG+B01vr87ERROR
+FHAGjx+f+IdpsQ7vw4kZ6+ocYfx6bIrc1gMLnia6Et3UVDmrJqMz6nWB2i3ND0/k
+A9HvFZcba5DFApCTZgIhsUfei5pKgLlVj7WiL8DWM2fafsSntARE60f75li59wzw
+eyuxwHApw0BiLTtIadwjPEjrewl5qW3aqDCYz4ByA4imW0aucnl8CAMhZa634Ryl
+sSqiMd5mBPfAdOhx3v89WcyWJhKLhZVXGqtrdQtEPREoPHtht+KPZ0/l7DxMYIBp
+VzgeAVuNVejH38DMdyM0SXV89pgR6y3e7UEuFAUCf+D+IOs15xGsIs5XPd7JMG0Q
+A4XN8f+MFrXBsj6IbGB/kE+V9/YtrQE5BwT6dYB9v0lQ7e/JxHwc64B+27bQ3RP+
+ydOc17KXqQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQUxhfQvKjqAkPyGwaZXSuQILnXnOQwDQYJKoZIhvcNAQELBQAD
+ggIBADRh2Va1EodVTd2jNTFGu6QHcrxfYWLopfsLN7E8trP6KZ1/AvWkyaiTt3px
+KGmPc+FSkNrVvjrlt3ZqVoAh313m6Tqe5T72omnHKgqwGEfcIHB9UqM+WXzBusnI
+FUBhynLWcKzSt/Ac5IYp8M7vaGPQtSCKFWGafoaYtMnCdvvMujAWzKNhxnQT5Wvv
+oxXqA/4Ti2Tk08HS6IT7SdEQTXlm66r99I0xHnAUrdzeZxNMgRVhvLfZkXdxGYFg
+u/BYpbWcC/ePIlUnwEsBbTuZDdQdm2NnL9DuDcpmvJRPpq3t/O5jrFc/ZSXPsoaP
+0Aj/uHYUbt7lJ+yreLVTubY/6CD50qi+YUbKh4yE8/nxoGibIh6BJpsQBJFxwAYf
+3KDTuVan45gtf4Od34wrnDKOMpTwATwiKp9Dwi7DmDkHOHv8XgBCH/MyJnmDhPbl
+8MFREsALHgQjDFSlTC9JxUrRtm5gDWv8a4uFJGS3iQ6rJUdbPM9+Sb3H6QrG2vd+
+DhcI00iX0HGS8A85PjRqHH3Y8iKuu2n0M7SmSFXRDw4m6Oy2Cy2nhTXN/VnIn9HN
+PlopNLk9hM6xZdRZkZFWdSHBd575euFgndOtBBj0fOtek49TSiIp+EgrPk2GrFt/
+ywaZWWDYWGWVjUTR939+J399roD1B0y2PpxxVJkES/1Y+Zj0
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root G2"
+# Serial: 15385348160840213938643033620894905419
+# MD5 Fingerprint: 92:38:b9:f8:63:24:82:65:2c:57:33:e6:fe:81:8f:9d
+# SHA1 Fingerprint: a1:4b:48:d9:43:ee:0a:0e:40:90:4f:3c:e0:a4:c0:91:93:51:5d:3f
+# SHA256 Fingerprint: 7d:05:eb:b6:82:33:9f:8c:94:51:ee:09:4e:eb:fe:fa:79:53:a1:14:ed:b2:f4:49:49:45:2f:ab:7d:2f:c1:85
+-----BEGIN CERTIFICATE-----
+MIIDljCCAn6gAwIBAgIQC5McOtY5Z+pnI7/Dr5r0SzANBgkqhkiG9w0BAQsFADBl
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
+b3QgRzIwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
+cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzIwggEi
+MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZ5ygvUj82ckmIkzTz+GoeMVSA
+n61UQbVH35ao1K+ALbkKz3X9iaV9JPrjIgwrvJUXCzO/GU1BBpAAvQxNEP4Htecc
+biJVMWWXvdMX0h5i89vqbFCMP4QMls+3ywPgym2hFEwbid3tALBSfK+RbLE4E9Hp
+EgjAALAcKxHad3A2m67OeYfcgnDmCXRwVWmvo2ifv922ebPynXApVfSr/5Vh88lA
+bx3RvpO704gqu52/clpWcTs/1PPRCv4o76Pu2ZmvA9OPYLfykqGxvYmJHzDNw6Yu
+YjOuFgJ3RFrngQo8p0Quebg/BLxcoIfhG69Rjs3sLPr4/m3wOnyqi+RnlTGNAgMB
+AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQW
+BBTOw0q5mVXyuNtgv6l+vVa1lzan1jANBgkqhkiG9w0BAQsFAAOCAQEAyqVVjOPI
+QW5pJ6d1Ee88hjZv0p3GeDgdaZaikmkuOGybfQTUiaWxMTeKySHMq2zNixya1r9I
+0jJmwYrA8y8678Dj1JGG0VDjA9tzd29KOVPt3ibHtX2vK0LRdWLjSisCx1BL4Gni
+lmwORGYQRI+tBev4eaymG+g3NJ1TyWGqolKvSnAWhsI6yLETcDbYz+70CjTVW0z9
+B5yiutkBclzzTcHdDrEcDcRjvq30FPuJ7KJBDkzMyFdA0G4Dqs0MjomZmWzwPDCv
+ON9vvKO+KSAnq3T/EyJ43pdSVR6DtVQgA+6uwE9W3jfMw3+qBCe703e4YtsXfJwo
+IhNzbM8m9Yop5w==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root G3"
+# Serial: 15459312981008553731928384953135426796
+# MD5 Fingerprint: 7c:7f:65:31:0c:81:df:8d:ba:3e:99:e2:5c:ad:6e:fb
+# SHA1 Fingerprint: f5:17:a2:4f:9a:48:c6:c9:f8:a2:00:26:9f:dc:0f:48:2c:ab:30:89
+# SHA256 Fingerprint: 7e:37:cb:8b:4c:47:09:0c:ab:36:55:1b:a6:f4:5d:b8:40:68:0f:ba:16:6a:95:2d:b1:00:71:7f:43:05:3f:c2
+-----BEGIN CERTIFICATE-----
+MIICRjCCAc2gAwIBAgIQC6Fa+h3foLVJRK/NJKBs7DAKBggqhkjOPQQDAzBlMQsw
+CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu
+ZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3Qg
+RzMwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQGEwJV
+UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu
+Y29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzMwdjAQBgcq
+hkjOPQIBBgUrgQQAIgNiAAQZ57ysRGXtzbg/WPuNsVepRC0FFfLvC/8QdJ+1YlJf
+Zn4f5dwbRXkLzMZTCp2NXQLZqVneAlr2lSoOjThKiknGvMYDOAdfVdp+CW7if17Q
+RSAPWXYQ1qAk8C3eNvJsKTmjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
+BAQDAgGGMB0GA1UdDgQWBBTL0L2p4ZgFUaFNN6KDec6NHSrkhDAKBggqhkjOPQQD
+AwNnADBkAjAlpIFFAmsSS3V0T8gj43DydXLefInwz5FyYZ5eEJJZVrmDxxDnOOlY
+JjZ91eQ0hjkCMHw2U/Aw5WJjOpnitqM7mzT6HtoQknFekROn3aRukswy1vUhZscv
+6pZjamVFkpUBtA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root G2"
+# Serial: 4293743540046975378534879503202253541
+# MD5 Fingerprint: e4:a6:8a:c8:54:ac:52:42:46:0a:fd:72:48:1b:2a:44
+# SHA1 Fingerprint: df:3c:24:f9:bf:d6:66:76:1b:26:80:73:fe:06:d1:cc:8d:4f:82:a4
+# SHA256 Fingerprint: cb:3c:cb:b7:60:31:e5:e0:13:8f:8d:d3:9a:23:f9:de:47:ff:c3:5e:43:c1:14:4c:ea:27:d4:6a:5a:b1:cb:5f
+-----BEGIN CERTIFICATE-----
+MIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH
+MjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT
+MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
+b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI
+2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx
+1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ
+q2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz
+tCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ
+vIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP
+BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV
+5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY
+1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4
+NeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG
+Fdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91
+8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe
+pLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl
+MrY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root G3"
+# Serial: 7089244469030293291760083333884364146
+# MD5 Fingerprint: f5:5d:a4:50:a5:fb:28:7e:1e:0f:0d:cc:96:57:56:ca
+# SHA1 Fingerprint: 7e:04:de:89:6a:3e:66:6d:00:e6:87:d3:3f:fa:d9:3b:e8:3d:34:9e
+# SHA256 Fingerprint: 31:ad:66:48:f8:10:41:38:c7:38:f3:9e:a4:32:01:33:39:3e:3a:18:cc:02:29:6e:f9:7c:2a:c9:ef:67:31:d0
+-----BEGIN CERTIFICATE-----
+MIICPzCCAcWgAwIBAgIQBVVWvPJepDU1w6QP1atFcjAKBggqhkjOPQQDAzBhMQsw
+CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu
+ZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe
+Fw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVTMRUw
+EwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x
+IDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYF
+K4EEACIDYgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FG
+fp4tn+6OYwwX7Adw9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPO
+Z9wj/wMco+I+o0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAd
+BgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNpYim8S8YwCgYIKoZIzj0EAwMDaAAwZQIx
+AK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj+Z4y3maTD/HMsQmP3Wyr+mt/
+oAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqpisXRAL34VOKa5Vt8
+sycX
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Trusted Root G4"
+# Serial: 7451500558977370777930084869016614236
+# MD5 Fingerprint: 78:f2:fc:aa:60:1f:2f:b4:eb:c9:37:ba:53:2e:75:49
+# SHA1 Fingerprint: dd:fb:16:cd:49:31:c9:73:a2:03:7d:3f:c8:3a:4d:7d:77:5d:05:e4
+# SHA256 Fingerprint: 55:2f:7b:dc:f1:a7:af:9e:6c:e6:72:01:7f:4f:12:ab:f7:72:40:c7:8e:76:1a:c2:03:d1:d9:d2:0a:c8:99:88
+-----BEGIN CERTIFICATE-----
+MIIFkDCCA3igAwIBAgIQBZsbV56OITLiOQe9p3d1XDANBgkqhkiG9w0BAQwFADBi
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3Qg
+RzQwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBiMQswCQYDVQQGEwJV
+UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu
+Y29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3QgRzQwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1KPDAiMGkz7MKnJS7JIT3y
+ithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2rsnnyyhHS5F/WBTxSD1If
+xp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C8weE5nQ7bXHiLQwb7iDV
+ySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBfsXpm7nfISKhmV1efVFiO
+DCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGYQJB5w3jHtrHEtWoYOAMQ
+jdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8rhsDdV14Ztk6MUSaM0C/
+CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaYdj1ZXUJ2h4mXaXpI8OCi
+EhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+wJS00mFt6zPZxd9LBADM
+fRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw++hkpjPRiQfhvbfmQ6QY
+uKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+NP8m800ERElvlEFDrMcXK
+chYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7FwI+isX4KJpn15GkvmB0t
+9dmpsh3lGwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+hjAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wDQYJKoZIhvcNAQEMBQAD
+ggIBALth2X2pbL4XxJEbw6GiAI3jZGgPVs93rnD5/ZpKmbnJeFwMDF/k5hQpVgs2
+SV1EY+CtnJYYZhsjDT156W1r1lT40jzBQ0CuHVD1UvyQO7uYmWlrx8GnqGikJ9yd
++SeuMIW59mdNOj6PWTkiU0TryF0Dyu1Qen1iIQqAyHNm0aAFYF/opbSnr6j3bTWc
+fFqK1qI4mfN4i/RN0iAL3gTujJtHgXINwBQy7zBZLq7gcfJW5GqXb5JQbZaNaHqa
+sjYUegbyJLkJEVDXCLG4iXqEI2FCKeWjzaIgQdfRnGTZ6iahixTXTBmyUEFxPT9N
+cCOGDErcgdLMMpSEDQgJlxxPwO5rIHQw0uA5NBCFIRUBCOhVMt5xSdkoF1BN5r5N
+0XWs0Mr7QbhDparTwwVETyw2m+L64kW4I1NsBm9nVX9GtUw/bihaeSbSpKhil9Ie
+4u1Ki7wb/UdKDd9nZn6yW0HQO+T0O/QEY+nvwlQAUaCKKsnOeMzV6ocEGLPOr0mI
+r/OSmbaz5mEP0oUA51Aa5BuVnRmhuZyxm7EAHu/QD09CbMkKvO5D+jpxpchNJqU1
+/YldvIViHTLSoCtU7ZpXwdv6EM8Zt4tKG48BtieVU+i2iW1bvGjUI+iLUaJW+fCm
+gKDWHrO8Dw9TdSmq6hN35N6MgSGtBxBHEa2HPQfRdbzP82Z+
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO RSA Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO RSA Certification Authority O=COMODO CA Limited
+# Label: "COMODO RSA Certification Authority"
+# Serial: 101909084537582093308941363524873193117
+# MD5 Fingerprint: 1b:31:b0:71:40:36:cc:14:36:91:ad:c4:3e:fd:ec:18
+# SHA1 Fingerprint: af:e5:d2:44:a8:d1:19:42:30:ff:47:9f:e2:f8:97:bb:cd:7a:8c:b4
+# SHA256 Fingerprint: 52:f0:e1:c4:e5:8e:c6:29:29:1b:60:31:7f:07:46:71:b8:5d:7e:a8:0d:5b:07:27:34:63:53:4b:32:b4:02:34
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=USERTrust RSA Certification Authority O=The USERTRUST Network
+# Subject: CN=USERTrust RSA Certification Authority O=The USERTRUST Network
+# Label: "USERTrust RSA Certification Authority"
+# Serial: 2645093764781058787591871645665788717
+# MD5 Fingerprint: 1b:fe:69:d1:91:b7:19:33:a3:72:a8:0f:e1:55:e5:b5
+# SHA1 Fingerprint: 2b:8f:1b:57:33:0d:bb:a2:d0:7a:6c:51:f7:0e:e9:0d:da:b9:ad:8e
+# SHA256 Fingerprint: e7:93:c9:b0:2f:d8:aa:13:e2:1c:31:22:8a:cc:b0:81:19:64:3b:74:9c:89:89:64:b1:74:6d:46:c3:d4:cb:d2
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=USERTrust ECC Certification Authority O=The USERTRUST Network
+# Subject: CN=USERTrust ECC Certification Authority O=The USERTRUST Network
+# Label: "USERTrust ECC Certification Authority"
+# Serial: 123013823720199481456569720443997572134
+# MD5 Fingerprint: fa:68:bc:d9:b5:7f:ad:fd:c9:1d:06:83:28:cc:24:c1
+# SHA1 Fingerprint: d1:cb:ca:5d:b2:d5:2a:7f:69:3b:67:4d:e5:f0:5a:1d:0c:95:7d:f0
+# SHA256 Fingerprint: 4f:f4:60:d5:4b:9c:86:da:bf:bc:fc:57:12:e0:40:0d:2b:ed:3f:bc:4d:4f:bd:aa:86:e0:6a:dc:d2:a9:ad:7a
+-----BEGIN CERTIFICATE-----
+MIICjzCCAhWgAwIBAgIQXIuZxVqUxdJxVt7NiYDMJjAKBggqhkjOPQQDAzCBiDEL
+MAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNl
+eSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMT
+JVVTRVJUcnVzdCBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMjAx
+MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgT
+Ck5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVUaGUg
+VVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBFQ0MgQ2VydGlm
+aWNhdGlvbiBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQarFRaqflo
+I+d61SRvU8Za2EurxtW20eZzca7dnNYMYf3boIkDuAUU7FfO7l0/4iGzzvfUinng
+o4N+LZfQYcTxmdwlkWOrfzCjtHDix6EznPO/LlxTsV+zfTJ/ijTjeXmjQjBAMB0G
+A1UdDgQWBBQ64QmG1M8ZwpZ2dEl23OA1xmNjmjAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjA2Z6EWCNzklwBBHU6+4WMB
+zzuqQhFkoJ2UOQIReVx7Hfpkue4WQrO/isIJxOzksU0CMQDpKmFHjFJKS04YcPbW
+RNZu9YO6bVi9JNlWSOrvxKJGgYhqOkbRqZtNyWHa0V1Xahg=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4
+# Label: "GlobalSign ECC Root CA - R4"
+# Serial: 14367148294922964480859022125800977897474
+# MD5 Fingerprint: 20:f0:27:68:d1:7e:a0:9d:0e:e6:2a:ca:df:5c:89:8e
+# SHA1 Fingerprint: 69:69:56:2e:40:80:f4:24:a1:e7:19:9f:14:ba:f3:ee:58:ab:6a:bb
+# SHA256 Fingerprint: be:c9:49:11:c2:95:56:76:db:6c:0a:55:09:86:d7:6e:3b:a0:05:66:7c:44:2c:97:62:b4:fb:b7:73:de:22:8c
+-----BEGIN CERTIFICATE-----
+MIIB4TCCAYegAwIBAgIRKjikHJYKBN5CsiilC+g0mAIwCgYIKoZIzj0EAwIwUDEk
+MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI0MRMwEQYDVQQKEwpH
+bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX
+DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD
+QSAtIFI0MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuMZ5049sJQ6fLjkZHAOkrprlOQcJ
+FspjsbmG+IpXwVfOQvpzofdlQv8ewQCybnMO/8ch5RikqtlxP6jUuc6MHaNCMEAw
+DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFFSwe61F
+uOJAf/sKbvu+M8k8o4TVMAoGCCqGSM49BAMCA0gAMEUCIQDckqGgE6bPA7DmxCGX
+kPoUVy0D7O48027KqGx2vKLeuwIgJ6iFJzWbVsaj8kfSt24bAgAXqmemFZHe+pTs
+ewv4n4Q=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5
+# Label: "GlobalSign ECC Root CA - R5"
+# Serial: 32785792099990507226680698011560947931244
+# MD5 Fingerprint: 9f:ad:3b:1c:02:1e:8a:ba:17:74:38:81:0c:a2:bc:08
+# SHA1 Fingerprint: 1f:24:c6:30:cd:a4:18:ef:20:69:ff:ad:4f:dd:5f:46:3a:1b:69:aa
+# SHA256 Fingerprint: 17:9f:bc:14:8a:3d:d0:0f:d2:4e:a1:34:58:cc:43:bf:a7:f5:9c:81:82:d7:83:a5:13:f6:eb:ec:10:0c:89:24
+-----BEGIN CERTIFICATE-----
+MIICHjCCAaSgAwIBAgIRYFlJ4CYuu1X5CneKcflK2GwwCgYIKoZIzj0EAwMwUDEk
+MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI1MRMwEQYDVQQKEwpH
+bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX
+DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD
+QSAtIFI1MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu
+MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAER0UOlvt9Xb/pOdEh+J8LttV7HpI6SFkc
+8GIxLcB6KP4ap1yztsyX50XUWPrRd21DosCHZTQKH3rd6zwzocWdTaRvQZU4f8ke
+hOvRnkmSh5SHDDqFSmafnVmTTZdhBoZKo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPeYpSJvqB8ohREom3m7e0oPQn1kwCgYI
+KoZIzj0EAwMDaAAwZQIxAOVpEslu28YxuglB4Zf4+/2a4n0Sye18ZNPLBSWLVtmg
+515dTguDnFt2KaAJJiFqYgIwcdK1j1zqO+F4CYWodZI7yFz9SO8NdCKoCOJuxUnO
+xwy8p2Fp8fc74SrL+SvzZpA3
+-----END CERTIFICATE-----
+
+# Issuer: CN=Staat der Nederlanden Root CA - G3 O=Staat der Nederlanden
+# Subject: CN=Staat der Nederlanden Root CA - G3 O=Staat der Nederlanden
+# Label: "Staat der Nederlanden Root CA - G3"
+# Serial: 10003001
+# MD5 Fingerprint: 0b:46:67:07:db:10:2f:19:8c:35:50:60:d1:0b:f4:37
+# SHA1 Fingerprint: d8:eb:6b:41:51:92:59:e0:f3:e7:85:00:c0:3d:b6:88:97:c9:ee:fc
+# SHA256 Fingerprint: 3c:4f:b0:b9:5a:b8:b3:00:32:f4:32:b8:6f:53:5f:e1:72:c1:85:d0:fd:39:86:58:37:cf:36:18:7f:a6:f4:28
+-----BEGIN CERTIFICATE-----
+MIIFdDCCA1ygAwIBAgIEAJiiOTANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJO
+TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSswKQYDVQQDDCJTdGFh
+dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQSAtIEczMB4XDTEzMTExNDExMjg0MloX
+DTI4MTExMzIzMDAwMFowWjELMAkGA1UEBhMCTkwxHjAcBgNVBAoMFVN0YWF0IGRl
+ciBOZWRlcmxhbmRlbjErMCkGA1UEAwwiU3RhYXQgZGVyIE5lZGVybGFuZGVuIFJv
+b3QgQ0EgLSBHMzCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAL4yolQP
+cPssXFnrbMSkUeiFKrPMSjTysF/zDsccPVMeiAho2G89rcKezIJnByeHaHE6n3WW
+IkYFsO2tx1ueKt6c/DrGlaf1F2cY5y9JCAxcz+bMNO14+1Cx3Gsy8KL+tjzk7FqX
+xz8ecAgwoNzFs21v0IJyEavSgWhZghe3eJJg+szeP4TrjTgzkApyI/o1zCZxMdFy
+KJLZWyNtZrVtB0LrpjPOktvA9mxjeM3KTj215VKb8b475lRgsGYeCasH/lSJEULR
+9yS6YHgamPfJEf0WwTUaVHXvQ9Plrk7O53vDxk5hUUurmkVLoR9BvUhTFXFkC4az
+5S6+zqQbwSmEorXLCCN2QyIkHxcE1G6cxvx/K2Ya7Irl1s9N9WMJtxU51nus6+N8
+6U78dULI7ViVDAZCopz35HCz33JvWjdAidiFpNfxC95DGdRKWCyMijmev4SH8RY7
+Ngzp07TKbBlBUgmhHbBqv4LvcFEhMtwFdozL92TkA1CvjJFnq8Xy7ljY3r735zHP
+bMk7ccHViLVlvMDoFxcHErVc0qsgk7TmgoNwNsXNo42ti+yjwUOH5kPiNL6VizXt
+BznaqB16nzaeErAMZRKQFWDZJkBE41ZgpRDUajz9QdwOWke275dhdU/Z/seyHdTt
+XUmzqWrLZoQT1Vyg3N9udwbRcXXIV2+vD3dbAgMBAAGjQjBAMA8GA1UdEwEB/wQF
+MAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRUrfrHkleuyjWcLhL75Lpd
+INyUVzANBgkqhkiG9w0BAQsFAAOCAgEAMJmdBTLIXg47mAE6iqTnB/d6+Oea31BD
+U5cqPco8R5gu4RV78ZLzYdqQJRZlwJ9UXQ4DO1t3ApyEtg2YXzTdO2PCwyiBwpwp
+LiniyMMB8jPqKqrMCQj3ZWfGzd/TtiunvczRDnBfuCPRy5FOCvTIeuXZYzbB1N/8
+Ipf3YF3qKS9Ysr1YvY2WTxB1v0h7PVGHoTx0IsL8B3+A3MSs/mrBcDCw6Y5p4ixp
+gZQJut3+TcCDjJRYwEYgr5wfAvg1VUkvRtTA8KCWAg8zxXHzniN9lLf9OtMJgwYh
+/WA9rjLA0u6NpvDntIJ8CsxwyXmA+P5M9zWEGYox+wrZ13+b8KKaa8MFSu1BYBQw
+0aoRQm7TIwIEC8Zl3d1Sd9qBa7Ko+gE4uZbqKmxnl4mUnrzhVNXkanjvSr0rmj1A
+fsbAddJu+2gw7OyLnflJNZoaLNmzlTnVHpL3prllL+U9bTpITAjc5CgSKL59NVzq
+4BZ+Extq1z7XnvwtdbLBFNUjA9tbbws+eC8N3jONFrdI54OagQ97wUNNVQQXOEpR
+1VmiiXTTn74eS9fGbbeIJG9gkaSChVtWQbzQRKtqE77RLFi3EjNYsjdj3BP1lB0/
+QFH1T/U67cjF68IeHRaVesd+QnGTbksVtzDfqu1XhUisHWrdOWnk4Xl4vs4Fv6EM
+94B7IWcnMFk=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Staat der Nederlanden EV Root CA O=Staat der Nederlanden
+# Subject: CN=Staat der Nederlanden EV Root CA O=Staat der Nederlanden
+# Label: "Staat der Nederlanden EV Root CA"
+# Serial: 10000013
+# MD5 Fingerprint: fc:06:af:7b:e8:1a:f1:9a:b4:e8:d2:70:1f:c0:f5:ba
+# SHA1 Fingerprint: 76:e2:7e:c1:4f:db:82:c1:c0:a6:75:b5:05:be:3d:29:b4:ed:db:bb
+# SHA256 Fingerprint: 4d:24:91:41:4c:fe:95:67:46:ec:4c:ef:a6:cf:6f:72:e2:8a:13:29:43:2f:9d:8a:90:7a:c4:cb:5d:ad:c1:5a
+-----BEGIN CERTIFICATE-----
+MIIFcDCCA1igAwIBAgIEAJiWjTANBgkqhkiG9w0BAQsFADBYMQswCQYDVQQGEwJO
+TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSkwJwYDVQQDDCBTdGFh
+dCBkZXIgTmVkZXJsYW5kZW4gRVYgUm9vdCBDQTAeFw0xMDEyMDgxMTE5MjlaFw0y
+MjEyMDgxMTEwMjhaMFgxCzAJBgNVBAYTAk5MMR4wHAYDVQQKDBVTdGFhdCBkZXIg
+TmVkZXJsYW5kZW4xKTAnBgNVBAMMIFN0YWF0IGRlciBOZWRlcmxhbmRlbiBFViBS
+b290IENBMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA48d+ifkkSzrS
+M4M1LGns3Amk41GoJSt5uAg94JG6hIXGhaTK5skuU6TJJB79VWZxXSzFYGgEt9nC
+UiY4iKTWO0Cmws0/zZiTs1QUWJZV1VD+hq2kY39ch/aO5ieSZxeSAgMs3NZmdO3d
+Z//BYY1jTw+bbRcwJu+r0h8QoPnFfxZpgQNH7R5ojXKhTbImxrpsX23Wr9GxE46p
+rfNeaXUmGD5BKyF/7otdBwadQ8QpCiv8Kj6GyzyDOvnJDdrFmeK8eEEzduG/L13l
+pJhQDBXd4Pqcfzho0LKmeqfRMb1+ilgnQ7O6M5HTp5gVXJrm0w912fxBmJc+qiXb
+j5IusHsMX/FjqTf5m3VpTCgmJdrV8hJwRVXj33NeN/UhbJCONVrJ0yPr08C+eKxC
+KFhmpUZtcALXEPlLVPxdhkqHz3/KRawRWrUgUY0viEeXOcDPusBCAUCZSCELa6fS
+/ZbV0b5GnUngC6agIk440ME8MLxwjyx1zNDFjFE7PZQIZCZhfbnDZY8UnCHQqv0X
+cgOPvZuM5l5Tnrmd74K74bzickFbIZTTRTeU0d8JOV3nI6qaHcptqAqGhYqCvkIH
+1vI4gnPah1vlPNOePqc7nvQDs/nxfRN0Av+7oeX6AHkcpmZBiFxgV6YuCcS6/ZrP
+px9Aw7vMWgpVSzs4dlG4Y4uElBbmVvMCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB
+/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFP6rAJCYniT8qcwaivsnuL8wbqg7
+MA0GCSqGSIb3DQEBCwUAA4ICAQDPdyxuVr5Os7aEAJSrR8kN0nbHhp8dB9O2tLsI
+eK9p0gtJ3jPFrK3CiAJ9Brc1AsFgyb/E6JTe1NOpEyVa/m6irn0F3H3zbPB+po3u
+2dfOWBfoqSmuc0iH55vKbimhZF8ZE/euBhD/UcabTVUlT5OZEAFTdfETzsemQUHS
+v4ilf0X8rLiltTMMgsT7B/Zq5SWEXwbKwYY5EdtYzXc7LMJMD16a4/CrPmEbUCTC
+wPTxGfARKbalGAKb12NMcIxHowNDXLldRqANb/9Zjr7dn3LDWyvfjFvO5QxGbJKy
+CqNMVEIYFRIYvdr8unRu/8G2oGTYqV9Vrp9canaW2HNnh/tNf1zuacpzEPuKqf2e
+vTY4SUmH9A4U8OmHuD+nT3pajnnUk+S7aFKErGzp85hwVXIy+TSrK0m1zSBi5Dp6
+Z2Orltxtrpfs/J92VoguZs9btsmksNcFuuEnL5O7Jiqik7Ab846+HUCjuTaPPoIa
+Gl6I6lD4WeKDRikL40Rc4ZW2aZCaFG+XroHPaO+Zmr615+F/+PoTRxZMzG0IQOeL
+eG9QgkRQP2YGiqtDhFZKDyAthg710tvSeopLzaXoTvFeJiUBWSOgftL2fiFX1ye8
+FVdMpEbB4IMeDExNH08GGeL5qPQ6gqGyeUN51q1veieQA6TqJIc/2b3Z6fJfUEkc
+7uzXLg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=IdenTrust Commercial Root CA 1 O=IdenTrust
+# Subject: CN=IdenTrust Commercial Root CA 1 O=IdenTrust
+# Label: "IdenTrust Commercial Root CA 1"
+# Serial: 13298821034946342390520003877796839426
+# MD5 Fingerprint: b3:3e:77:73:75:ee:a0:d3:e3:7e:49:63:49:59:bb:c7
+# SHA1 Fingerprint: df:71:7e:aa:4a:d9:4e:c9:55:84:99:60:2d:48:de:5f:bc:f0:3a:25
+# SHA256 Fingerprint: 5d:56:49:9b:e4:d2:e0:8b:cf:ca:d0:8a:3e:38:72:3d:50:50:3b:de:70:69:48:e4:2f:55:60:30:19:e5:28:ae
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIQCgFCgAAAAUUjyES1AAAAAjANBgkqhkiG9w0BAQsFADBK
+MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScwJQYDVQQDEx5JZGVu
+VHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwHhcNMTQwMTE2MTgxMjIzWhcNMzQw
+MTE2MTgxMjIzWjBKMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScw
+JQYDVQQDEx5JZGVuVHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCnUBneP5k91DNG8W9RYYKyqU+PZ4ldhNlT
+3Qwo2dfw/66VQ3KZ+bVdfIrBQuExUHTRgQ18zZshq0PirK1ehm7zCYofWjK9ouuU
++ehcCuz/mNKvcbO0U59Oh++SvL3sTzIwiEsXXlfEU8L2ApeN2WIrvyQfYo3fw7gp
+S0l4PJNgiCL8mdo2yMKi1CxUAGc1bnO/AljwpN3lsKImesrgNqUZFvX9t++uP0D1
+bVoE/c40yiTcdCMbXTMTEl3EASX2MN0CXZ/g1Ue9tOsbobtJSdifWwLziuQkkORi
+T0/Br4sOdBeo0XKIanoBScy0RnnGF7HamB4HWfp1IYVl3ZBWzvurpWCdxJ35UrCL
+vYf5jysjCiN2O/cz4ckA82n5S6LgTrx+kzmEB/dEcH7+B1rlsazRGMzyNeVJSQjK
+Vsk9+w8YfYs7wRPCTY/JTw436R+hDmrfYi7LNQZReSzIJTj0+kuniVyc0uMNOYZK
+dHzVWYfCP04MXFL0PfdSgvHqo6z9STQaKPNBiDoT7uje/5kdX7rL6B7yuVBgwDHT
+c+XvvqDtMwt0viAgxGds8AgDelWAf0ZOlqf0Hj7h9tgJ4TNkK2PXMl6f+cB7D3hv
+l7yTmvmcEpB4eoCHFddydJxVdHixuuFucAS6T6C6aMN7/zHwcz09lCqxC0EOoP5N
+iGVreTO01wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQU7UQZwNPwBovupHu+QucmVMiONnYwDQYJKoZIhvcNAQELBQAD
+ggIBAA2ukDL2pkt8RHYZYR4nKM1eVO8lvOMIkPkp165oCOGUAFjvLi5+U1KMtlwH
+6oi6mYtQlNeCgN9hCQCTrQ0U5s7B8jeUeLBfnLOic7iPBZM4zY0+sLj7wM+x8uwt
+LRvM7Kqas6pgghstO8OEPVeKlh6cdbjTMM1gCIOQ045U8U1mwF10A0Cj7oV+wh93
+nAbowacYXVKV7cndJZ5t+qntozo00Fl72u1Q8zW/7esUTTHHYPTa8Yec4kjixsU3
++wYQ+nVZZjFHKdp2mhzpgq7vmrlR94gjmmmVYjzlVYA211QC//G5Xc7UI2/YRYRK
+W2XviQzdFKcgyxilJbQN+QHwotL0AMh0jqEqSI5l2xPE4iUXfeu+h1sXIFRRk0pT
+AwvsXcoz7WL9RccvW9xYoIA55vrX/hMUpu09lEpCdNTDd1lzzY9GvlU47/rokTLq
+l1gEIt44w8y8bckzOmoKaT+gyOpyj4xjhiO9bTyWnpXgSUyqorkqG5w2gXjtw+hG
+4iZZRHUe2XWJUc0QhJ1hYMtd+ZciTY6Y5uN/9lu7rs3KSoFrXgvzUeF0K+l+J6fZ
+mUlO+KWA2yUPHGNiiskzZ2s8EIPGrd6ozRaOjfAHN3Gf8qv8QfXBi+wAN10J5U6A
+7/qxXDgGpRtK4dw4LTzcqx+QGtVKnO7RcGzM7vRX+Bi6hG6H
+-----END CERTIFICATE-----
+
+# Issuer: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust
+# Subject: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust
+# Label: "IdenTrust Public Sector Root CA 1"
+# Serial: 13298821034946342390521976156843933698
+# MD5 Fingerprint: 37:06:a5:b0:fc:89:9d:ba:f4:6b:8c:1a:64:cd:d5:ba
+# SHA1 Fingerprint: ba:29:41:60:77:98:3f:f4:f3:ef:f2:31:05:3b:2e:ea:6d:4d:45:fd
+# SHA256 Fingerprint: 30:d0:89:5a:9a:44:8a:26:20:91:63:55:22:d1:f5:20:10:b5:86:7a:ca:e1:2c:78:ef:95:8f:d4:f4:38:9f:2f
+-----BEGIN CERTIFICATE-----
+MIIFZjCCA06gAwIBAgIQCgFCgAAAAUUjz0Z8AAAAAjANBgkqhkiG9w0BAQsFADBN
+MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MSowKAYDVQQDEyFJZGVu
+VHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwHhcNMTQwMTE2MTc1MzMyWhcN
+MzQwMTE2MTc1MzMyWjBNMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0
+MSowKAYDVQQDEyFJZGVuVHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2IpT8pEiv6EdrCvsnduTyP4o7
+ekosMSqMjbCpwzFrqHd2hCa2rIFCDQjrVVi7evi8ZX3yoG2LqEfpYnYeEe4IFNGy
+RBb06tD6Hi9e28tzQa68ALBKK0CyrOE7S8ItneShm+waOh7wCLPQ5CQ1B5+ctMlS
+bdsHyo+1W/CD80/HLaXIrcuVIKQxKFdYWuSNG5qrng0M8gozOSI5Cpcu81N3uURF
+/YTLNiCBWS2ab21ISGHKTN9T0a9SvESfqy9rg3LvdYDaBjMbXcjaY8ZNzaxmMc3R
+3j6HEDbhuaR672BQssvKplbgN6+rNBM5Jeg5ZuSYeqoSmJxZZoY+rfGwyj4GD3vw
+EUs3oERte8uojHH01bWRNszwFcYr3lEXsZdMUD2xlVl8BX0tIdUAvwFnol57plzy
+9yLxkA2T26pEUWbMfXYD62qoKjgZl3YNa4ph+bz27nb9cCvdKTz4Ch5bQhyLVi9V
+GxyhLrXHFub4qjySjmm2AcG1hp2JDws4lFTo6tyePSW8Uybt1as5qsVATFSrsrTZ
+2fjXctscvG29ZV/viDUqZi/u9rNl8DONfJhBaUYPQxxp+pu10GFqzcpL2UyQRqsV
+WaFHVCkugyhfHMKiq3IXAAaOReyL4jM9f9oZRORicsPfIsbyVtTdX5Vy7W1f90gD
+W/3FKqD2cyOEEBsB5wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
+BAUwAwEB/zAdBgNVHQ4EFgQU43HgntinQtnbcZFrlJPrw6PRFKMwDQYJKoZIhvcN
+AQELBQADggIBAEf63QqwEZE4rU1d9+UOl1QZgkiHVIyqZJnYWv6IAcVYpZmxI1Qj
+t2odIFflAWJBF9MJ23XLblSQdf4an4EKwt3X9wnQW3IV5B4Jaj0z8yGa5hV+rVHV
+DRDtfULAj+7AmgjVQdZcDiFpboBhDhXAuM/FSRJSzL46zNQuOAXeNf0fb7iAaJg9
+TaDKQGXSc3z1i9kKlT/YPyNtGtEqJBnZhbMX73huqVjRI9PHE+1yJX9dsXNw0H8G
+lwmEKYBhHfpe/3OsoOOJuBxxFcbeMX8S3OFtm6/n6J91eEyrRjuazr8FGF1NFTwW
+mhlQBJqymm9li1JfPFgEKCXAZmExfrngdbkaqIHWchezxQMxNRF4eKLg6TCMf4Df
+WN88uieW4oA0beOY02QnrEh+KHdcxiVhJfiFDGX6xDIvpZgF5PgLZxYWxoK4Mhn5
++bl53B/N66+rDt0b20XkeucC4pVd/GnwU2lhlXV5C15V5jgclKlZM57IcXR5f1GJ
+tshquDDIajjDbp7hNxbqBWJMWxJH7ae0s1hWx0nzfxJoCTFx8G34Tkf71oXuxVhA
+GaQdp/lLQzfcaFpPz+vCZHTetBXZ9FRUGi8c15dxVJCO2SCdUyt/q4/i6jC8UDfv
+8Ue1fXwsBOxonbRJRBD0ckscZOf85muQ3Wl9af0AVqW3rLatt8o+Ae+c
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - G2"
+# Serial: 1246989352
+# MD5 Fingerprint: 4b:e2:c9:91:96:65:0c:f4:0e:5a:93:92:a0:0a:fe:b2
+# SHA1 Fingerprint: 8c:f4:27:fd:79:0c:3a:d1:66:06:8d:e8:1e:57:ef:bb:93:22:72:d4
+# SHA256 Fingerprint: 43:df:57:74:b0:3e:7f:ef:5f:e4:0d:93:1a:7b:ed:f1:bb:2e:6b:42:73:8c:4e:6d:38:41:10:3d:3a:a7:f3:39
+-----BEGIN CERTIFICATE-----
+MIIEPjCCAyagAwIBAgIESlOMKDANBgkqhkiG9w0BAQsFADCBvjELMAkGA1UEBhMC
+VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50
+cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3Qs
+IEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVz
+dCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzIwHhcNMDkwNzA3MTcy
+NTU0WhcNMzAxMjA3MTc1NTU0WjCBvjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUVu
+dHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50cnVzdC5uZXQvbGVnYWwt
+dGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3QsIEluYy4gLSBmb3IgYXV0
+aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVzdCBSb290IENlcnRpZmlj
+YXRpb24gQXV0aG9yaXR5IC0gRzIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
+AoIBAQC6hLZy254Ma+KZ6TABp3bqMriVQRrJ2mFOWHLP/vaCeb9zYQYKpSfYs1/T
+RU4cctZOMvJyig/3gxnQaoCAAEUesMfnmr8SVycco2gvCoe9amsOXmXzHHfV1IWN
+cCG0szLni6LVhjkCsbjSR87kyUnEO6fe+1R9V77w6G7CebI6C1XiUJgWMhNcL3hW
+wcKUs/Ja5CeanyTXxuzQmyWC48zCxEXFjJd6BmsqEZ+pCm5IO2/b1BEZQvePB7/1
+U1+cPvQXLOZprE4yTGJ36rfo5bs0vBmLrpxR57d+tVOxMyLlbc9wPBr64ptntoP0
+jaWvYkxN4FisZDQSA/i2jZRjJKRxAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAP
+BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqciZ60B7vfec7aVHUbI2fkBJmqzAN
+BgkqhkiG9w0BAQsFAAOCAQEAeZ8dlsa2eT8ijYfThwMEYGprmi5ZiXMRrEPR9RP/
+jTkrwPK9T3CMqS/qF8QLVJ7UG5aYMzyorWKiAHarWWluBh1+xLlEjZivEtRh2woZ
+Rkfz6/djwUAFQKXSt/S1mja/qYh2iARVBCuch38aNzx+LaUa2NSJXsq9rD1s2G2v
+1fN2D807iDginWyTmsQ9v4IbZT+mD12q/OWyFcq1rca8PdCE6OoGcrBNOTJ4vz4R
+nAuknZoh8/CbCzB428Hch0P+vGOaysXCHMnHjf87ElgI5rY97HosTvuDls4MPGmH
+VHOkc8KT/1EQrBVUAdj8BbGJoX90g5pJ19xOe4pIb4tF9g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - EC1"
+# Serial: 51543124481930649114116133369
+# MD5 Fingerprint: b6:7e:1d:f0:58:c5:49:6c:24:3b:3d:ed:98:18:ed:bc
+# SHA1 Fingerprint: 20:d8:06:40:df:9b:25:f5:12:25:3a:11:ea:f7:59:8a:eb:14:b5:47
+# SHA256 Fingerprint: 02:ed:0e:b2:8c:14:da:45:16:5c:56:67:91:70:0d:64:51:d7:fb:56:f0:b2:ab:1d:3b:8e:b0:70:e5:6e:df:f5
+-----BEGIN CERTIFICATE-----
+MIIC+TCCAoCgAwIBAgINAKaLeSkAAAAAUNCR+TAKBggqhkjOPQQDAzCBvzELMAkG
+A1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3
+d3cuZW50cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDEyIEVu
+dHJ1c3QsIEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEzMDEGA1UEAxMq
+RW50cnVzdCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRUMxMB4XDTEy
+MTIxODE1MjUzNloXDTM3MTIxODE1NTUzNlowgb8xCzAJBgNVBAYTAlVTMRYwFAYD
+VQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1c3QubmV0
+L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxMiBFbnRydXN0LCBJbmMuIC0g
+Zm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMzAxBgNVBAMTKkVudHJ1c3QgUm9vdCBD
+ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEVDMTB2MBAGByqGSM49AgEGBSuBBAAi
+A2IABIQTydC6bUF74mzQ61VfZgIaJPRbiWlH47jCffHyAsWfoPZb1YsGGYZPUxBt
+ByQnoaD41UcZYUx9ypMn6nQM72+WCf5j7HBdNq1nd67JnXxVRDqiY1Ef9eNi1KlH
+Bz7MIKNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O
+BBYEFLdj5xrdjekIplWDpOBqUEFlEUJJMAoGCCqGSM49BAMDA2cAMGQCMGF52OVC
+R98crlOZF7ZvHH3hvxGU0QOIdeSNiaSKd0bebWHvAvX7td/M/k7//qnmpwIwW5nX
+hTcGtXsI/esni0qU+eH6p44mCOh8kmhtc9hvJqwhAriZtyZBWyVgrtBIGu4G
+-----END CERTIFICATE-----
+
+# Issuer: CN=CFCA EV ROOT O=China Financial Certification Authority
+# Subject: CN=CFCA EV ROOT O=China Financial Certification Authority
+# Label: "CFCA EV ROOT"
+# Serial: 407555286
+# MD5 Fingerprint: 74:e1:b6:ed:26:7a:7a:44:30:33:94:ab:7b:27:81:30
+# SHA1 Fingerprint: e2:b8:29:4b:55:84:ab:6b:58:c2:90:46:6c:ac:3f:b8:39:8f:84:83
+# SHA256 Fingerprint: 5c:c3:d7:8e:4e:1d:5e:45:54:7a:04:e6:87:3e:64:f9:0c:f9:53:6d:1c:cc:2e:f8:00:f3:55:c4:c5:fd:70:fd
+-----BEGIN CERTIFICATE-----
+MIIFjTCCA3WgAwIBAgIEGErM1jANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJD
+TjEwMC4GA1UECgwnQ2hpbmEgRmluYW5jaWFsIENlcnRpZmljYXRpb24gQXV0aG9y
+aXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJPT1QwHhcNMTIwODA4MDMwNzAxWhcNMjkx
+MjMxMDMwNzAxWjBWMQswCQYDVQQGEwJDTjEwMC4GA1UECgwnQ2hpbmEgRmluYW5j
+aWFsIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJP
+T1QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDXXWvNED8fBVnVBU03
+sQ7smCuOFR36k0sXgiFxEFLXUWRwFsJVaU2OFW2fvwwbwuCjZ9YMrM8irq93VCpL
+TIpTUnrD7i7es3ElweldPe6hL6P3KjzJIx1qqx2hp/Hz7KDVRM8Vz3IvHWOX6Jn5
+/ZOkVIBMUtRSqy5J35DNuF++P96hyk0g1CXohClTt7GIH//62pCfCqktQT+x8Rgp
+7hZZLDRJGqgG16iI0gNyejLi6mhNbiyWZXvKWfry4t3uMCz7zEasxGPrb382KzRz
+EpR/38wmnvFyXVBlWY9ps4deMm/DGIq1lY+wejfeWkU7xzbh72fROdOXW3NiGUgt
+hxwG+3SYIElz8AXSG7Ggo7cbcNOIabla1jj0Ytwli3i/+Oh+uFzJlU9fpy25IGvP
+a931DfSCt/SyZi4QKPaXWnuWFo8BGS1sbn85WAZkgwGDg8NNkt0yxoekN+kWzqot
+aK8KgWU6cMGbrU1tVMoqLUuFG7OA5nBFDWteNfB/O7ic5ARwiRIlk9oKmSJgamNg
+TnYGmE69g60dWIolhdLHZR4tjsbftsbhf4oEIRUpdPA+nJCdDC7xij5aqgwJHsfV
+PKPtl8MeNPo4+QgO48BdK4PRVmrJtqhUUy54Mmc9gn900PvhtgVguXDbjgv5E1hv
+cWAQUhC5wUEJ73IfZzF4/5YFjQIDAQABo2MwYTAfBgNVHSMEGDAWgBTj/i39KNAL
+tbq2osS/BqoFjJP7LzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAd
+BgNVHQ4EFgQU4/4t/SjQC7W6tqLEvwaqBYyT+y8wDQYJKoZIhvcNAQELBQADggIB
+ACXGumvrh8vegjmWPfBEp2uEcwPenStPuiB/vHiyz5ewG5zz13ku9Ui20vsXiObT
+ej/tUxPQ4i9qecsAIyjmHjdXNYmEwnZPNDatZ8POQQaIxffu2Bq41gt/UP+TqhdL
+jOztUmCypAbqTuv0axn96/Ua4CUqmtzHQTb3yHQFhDmVOdYLO6Qn+gjYXB74BGBS
+ESgoA//vU2YApUo0FmZ8/Qmkrp5nGm9BC2sGE5uPhnEFtC+NiWYzKXZUmhH4J/qy
+P5Hgzg0b8zAarb8iXRvTvyUFTeGSGn+ZnzxEk8rUQElsgIfXBDrDMlI1Dlb4pd19
+xIsNER9Tyx6yF7Zod1rg1MvIB671Oi6ON7fQAUtDKXeMOZePglr4UeWJoBjnaH9d
+Ci77o0cOPaYjesYBx4/IXr9tgFa+iiS6M+qf4TIRnvHST4D2G0CvOJ4RUHlzEhLN
+5mydLIhyPDCBBpEi6lmt2hkuIsKNuYyH4Ga8cyNfIWRjgEj1oDwYPZTISEEdQLpe
+/v5WOaHIz16eGWRGENoXkbcFgKyLmZJ956LYBws2J+dIeWCKw9cTXPhyQN9Ky8+Z
+AAoACxGV2lZFA4gKn2fQ1XmxqI1AbQ3CekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ
+5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su
+-----END CERTIFICATE-----
+
+# Issuer: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
+# Subject: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
+# Label: "OISTE WISeKey Global Root GB CA"
+# Serial: 157768595616588414422159278966750757568
+# MD5 Fingerprint: a4:eb:b9:61:28:2e:b7:2f:98:b0:35:26:90:99:51:1d
+# SHA1 Fingerprint: 0f:f9:40:76:18:d3:d7:6a:4b:98:f0:a8:35:9e:0c:fd:27:ac:cc:ed
+# SHA256 Fingerprint: 6b:9c:08:e8:6e:b0:f7:67:cf:ad:65:cd:98:b6:21:49:e5:49:4a:67:f5:84:5e:7b:d1:ed:01:9f:27:b8:6b:d6
+-----BEGIN CERTIFICATE-----
+MIIDtTCCAp2gAwIBAgIQdrEgUnTwhYdGs/gjGvbCwDANBgkqhkiG9w0BAQsFADBt
+MQswCQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUg
+Rm91bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9i
+YWwgUm9vdCBHQiBDQTAeFw0xNDEyMDExNTAwMzJaFw0zOTEyMDExNTEwMzFaMG0x
+CzAJBgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBG
+b3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2Jh
+bCBSb290IEdCIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2Be3
+HEokKtaXscriHvt9OO+Y9bI5mE4nuBFde9IllIiCFSZqGzG7qFshISvYD06fWvGx
+WuR51jIjK+FTzJlFXHtPrby/h0oLS5daqPZI7H17Dc0hBt+eFf1Biki3IPShehtX
+1F1Q/7pn2COZH8g/497/b1t3sWtuuMlk9+HKQUYOKXHQuSP8yYFfTvdv37+ErXNk
+u7dCjmn21HYdfp2nuFeKUWdy19SouJVUQHMD9ur06/4oQnc/nSMbsrY9gBQHTC5P
+99UKFg29ZkM3fiNDecNAhvVMKdqOmq0NpQSHiB6F4+lT1ZvIiwNjeOvgGUpuuy9r
+M2RYk61pv48b74JIxwIDAQABo1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUw
+AwEB/zAdBgNVHQ4EFgQUNQ/INmNe4qPs+TtmFc5RUuORmj0wEAYJKwYBBAGCNxUB
+BAMCAQAwDQYJKoZIhvcNAQELBQADggEBAEBM+4eymYGQfp3FsLAmzYh7KzKNbrgh
+cViXfa43FK8+5/ea4n32cZiZBKpDdHij40lhPnOMTZTg+XHEthYOU3gf1qKHLwI5
+gSk8rxWYITD+KJAAjNHhy/peyP34EEY7onhCkRd0VQreUGdNZtGn//3ZwLWoo4rO
+ZvUPQ82nK1d7Y0Zqqi5S2PTt4W2tKZB4SLrhI6qjiey1q5bAtEuiHZeeevJuQHHf
+aPFlTc58Bd9TZaml8LGXBHAVRgOY1NK/VLSgWH1Sb9pWJmLU2NuJMW8c8CLC02Ic
+Nc1MaRVUGpCY3useX8p3x8uOPUNpnJpY0CQ73xtAln41rYHHTnG6iBM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A.
+# Subject: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A.
+# Label: "SZAFIR ROOT CA2"
+# Serial: 357043034767186914217277344587386743377558296292
+# MD5 Fingerprint: 11:64:c1:89:b0:24:b1:8c:b1:07:7e:89:9e:51:9e:99
+# SHA1 Fingerprint: e2:52:fa:95:3f:ed:db:24:60:bd:6e:28:f3:9c:cc:cf:5e:b3:3f:de
+# SHA256 Fingerprint: a1:33:9d:33:28:1a:0b:56:e5:57:d3:d3:2b:1c:e7:f9:36:7e:b0:94:bd:5f:a7:2a:7e:50:04:c8:de:d7:ca:fe
+-----BEGIN CERTIFICATE-----
+MIIDcjCCAlqgAwIBAgIUPopdB+xV0jLVt+O2XwHrLdzk1uQwDQYJKoZIhvcNAQEL
+BQAwUTELMAkGA1UEBhMCUEwxKDAmBgNVBAoMH0tyYWpvd2EgSXpiYSBSb3psaWN6
+ZW5pb3dhIFMuQS4xGDAWBgNVBAMMD1NaQUZJUiBST09UIENBMjAeFw0xNTEwMTkw
+NzQzMzBaFw0zNTEwMTkwNzQzMzBaMFExCzAJBgNVBAYTAlBMMSgwJgYDVQQKDB9L
+cmFqb3dhIEl6YmEgUm96bGljemVuaW93YSBTLkEuMRgwFgYDVQQDDA9TWkFGSVIg
+Uk9PVCBDQTIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC3vD5QqEvN
+QLXOYeeWyrSh2gwisPq1e3YAd4wLz32ohswmUeQgPYUM1ljj5/QqGJ3a0a4m7utT
+3PSQ1hNKDJA8w/Ta0o4NkjrcsbH/ON7Dui1fgLkCvUqdGw+0w8LBZwPd3BucPbOw
+3gAeqDRHu5rr/gsUvTaE2g0gv/pby6kWIK05YO4vdbbnl5z5Pv1+TW9NL++IDWr6
+3fE9biCloBK0TXC5ztdyO4mTp4CEHCdJckm1/zuVnsHMyAHs6A6KCpbns6aH5db5
+BSsNl0BwPLqsdVqc1U2dAgrSS5tmS0YHF2Wtn2yIANwiieDhZNRnvDF5YTy7ykHN
+XGoAyDw4jlivAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD
+AgEGMB0GA1UdDgQWBBQuFqlKGLXLzPVvUPMjX/hd56zwyDANBgkqhkiG9w0BAQsF
+AAOCAQEAtXP4A9xZWx126aMqe5Aosk3AM0+qmrHUuOQn/6mWmc5G4G18TKI4pAZw
+8PRBEew/R40/cof5O/2kbytTAOD/OblqBw7rHRz2onKQy4I9EYKL0rufKq8h5mOG
+nXkZ7/e7DDWQw4rtTw/1zBLZpD67oPwglV9PJi8RI4NOdQcPv5vRtB3pEAT+ymCP
+oky4rc/hkA/NrgrHXXu3UNLUYfrVFdvXn4dRVOul4+vJhaAlIDf7js4MNIThPIGy
+d05DpYhfhmehPea0XGG2Ptv+tyjFogeutcrKjSoS75ftwjCkySp6+/NNIxuZMzSg
+LvWpCz/UXeHPhJ/iGcJfitYgHuNztw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Subject: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Label: "Certum Trusted Network CA 2"
+# Serial: 44979900017204383099463764357512596969
+# MD5 Fingerprint: 6d:46:9e:d9:25:6d:08:23:5b:5e:74:7d:1e:27:db:f2
+# SHA1 Fingerprint: d3:dd:48:3e:2b:bf:4c:05:e8:af:10:f5:fa:76:26:cf:d3:dc:30:92
+# SHA256 Fingerprint: b6:76:f2:ed:da:e8:77:5c:d3:6c:b0:f6:3c:d1:d4:60:39:61:f4:9e:62:65:ba:01:3a:2f:03:07:b6:d0:b8:04
+-----BEGIN CERTIFICATE-----
+MIIF0jCCA7qgAwIBAgIQIdbQSk8lD8kyN/yqXhKN6TANBgkqhkiG9w0BAQ0FADCB
+gDELMAkGA1UEBhMCUEwxIjAgBgNVBAoTGVVuaXpldG8gVGVjaG5vbG9naWVzIFMu
+QS4xJzAlBgNVBAsTHkNlcnR1bSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEkMCIG
+A1UEAxMbQ2VydHVtIFRydXN0ZWQgTmV0d29yayBDQSAyMCIYDzIwMTExMDA2MDgz
+OTU2WhgPMjA0NjEwMDYwODM5NTZaMIGAMQswCQYDVQQGEwJQTDEiMCAGA1UEChMZ
+VW5pemV0byBUZWNobm9sb2dpZXMgUy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRp
+ZmljYXRpb24gQXV0aG9yaXR5MSQwIgYDVQQDExtDZXJ0dW0gVHJ1c3RlZCBOZXR3
+b3JrIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC9+Xj45tWA
+DGSdhhuWZGc/IjoedQF97/tcZ4zJzFxrqZHmuULlIEub2pt7uZld2ZuAS9eEQCsn
+0+i6MLs+CRqnSZXvK0AkwpfHp+6bJe+oCgCXhVqqndwpyeI1B+twTUrWwbNWuKFB
+OJvR+zF/j+Bf4bE/D44WSWDXBo0Y+aomEKsq09DRZ40bRr5HMNUuctHFY9rnY3lE
+fktjJImGLjQ/KUxSiyqnwOKRKIm5wFv5HdnnJ63/mgKXwcZQkpsCLL2puTRZCr+E
+Sv/f/rOf69me4Jgj7KZrdxYq28ytOxykh9xGc14ZYmhFV+SQgkK7QtbwYeDBoz1m
+o130GO6IyY0XRSmZMnUCMe4pJshrAua1YkV/NxVaI2iJ1D7eTiew8EAMvE0Xy02i
+sx7QBlrd9pPPV3WZ9fqGGmd4s7+W/jTcvedSVuWz5XV710GRBdxdaeOVDUO5/IOW
+OZV7bIBaTxNyxtd9KXpEulKkKtVBRgkg/iKgtlswjbyJDNXXcPiHUv3a76xRLgez
+Tv7QCdpw75j6VuZt27VXS9zlLCUVyJ4ueE742pyehizKV/Ma5ciSixqClnrDvFAS
+adgOWkaLOusm+iPJtrCBvkIApPjW/jAux9JG9uWOdf3yzLnQh1vMBhBgu4M1t15n
+3kfsmUjxpKEV/q2MYo45VU85FrmxY53/twIDAQABo0IwQDAPBgNVHRMBAf8EBTAD
+AQH/MB0GA1UdDgQWBBS2oVQ5AsOgP46KvPrU+Bym0ToO/TAOBgNVHQ8BAf8EBAMC
+AQYwDQYJKoZIhvcNAQENBQADggIBAHGlDs7k6b8/ONWJWsQCYftMxRQXLYtPU2sQ
+F/xlhMcQSZDe28cmk4gmb3DWAl45oPePq5a1pRNcgRRtDoGCERuKTsZPpd1iHkTf
+CVn0W3cLN+mLIMb4Ck4uWBzrM9DPhmDJ2vuAL55MYIR4PSFk1vtBHxgP58l1cb29
+XN40hz5BsA72udY/CROWFC/emh1auVbONTqwX3BNXuMp8SMoclm2q8KMZiYcdywm
+djWLKKdpoPk79SPdhRB0yZADVpHnr7pH1BKXESLjokmUbOe3lEu6LaTaM4tMpkT/
+WjzGHWTYtTHkpjx6qFcL2+1hGsvxznN3Y6SHb0xRONbkX8eftoEq5IVIeVheO/jb
+AoJnwTnbw3RLPTYe+SmTiGhbqEQZIfCn6IENLOiTNrQ3ssqwGyZ6miUfmpqAnksq
+P/ujmv5zMnHCnsZy4YpoJ/HkD7TETKVhk/iXEAcqMCWpuchxuO9ozC1+9eB+D4Ko
+b7a6bINDd82Kkhehnlt4Fj1F4jNy3eFmypnTycUm/Q1oBEauttmbjL4ZvrHG8hnj
+XALKLNhvSgfZyTXaQHXyxKcZb55CEJh15pWLYLztxRLXis7VmFxWlgPF7ncGNf/P
+5O4/E2Hu29othfDNrp2yGAlFw5Khchf8R7agCyzxxN5DaAhqXzvwdmP7zAYspsbi
+DrW5viSP
+-----END CERTIFICATE-----
+
+# Issuer: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Subject: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Label: "Hellenic Academic and Research Institutions RootCA 2015"
+# Serial: 0
+# MD5 Fingerprint: ca:ff:e2:db:03:d9:cb:4b:e9:0f:ad:84:fd:7b:18:ce
+# SHA1 Fingerprint: 01:0c:06:95:a6:98:19:14:ff:bf:5f:c6:b0:b6:95:ea:29:e9:12:a6
+# SHA256 Fingerprint: a0:40:92:9a:02:ce:53:b4:ac:f4:f2:ff:c6:98:1c:e4:49:6f:75:5e:6d:45:fe:0b:2a:69:2b:cd:52:52:3f:36
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Subject: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Label: "Hellenic Academic and Research Institutions ECC RootCA 2015"
+# Serial: 0
+# MD5 Fingerprint: 81:e5:b4:17:eb:c2:f5:e1:4b:0d:41:7b:49:92:fe:ef
+# SHA1 Fingerprint: 9f:f1:71:8d:92:d5:9a:f3:7d:74:97:b4:bc:6f:84:68:0b:ba:b6:66
+# SHA256 Fingerprint: 44:b5:45:aa:8a:25:e6:5a:73:ca:15:dc:27:fc:36:d2:4c:1c:b9:95:3a:06:65:39:b1:15:82:dc:48:7b:48:33
+-----BEGIN CERTIFICATE-----
+MIICwzCCAkqgAwIBAgIBADAKBggqhkjOPQQDAjCBqjELMAkGA1UEBhMCR1IxDzAN
+BgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl
+c2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkxRDBCBgNVBAMTO0hl
+bGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgRUNDIFJv
+b3RDQSAyMDE1MB4XDTE1MDcwNzEwMzcxMloXDTQwMDYzMDEwMzcxMlowgaoxCzAJ
+BgNVBAYTAkdSMQ8wDQYDVQQHEwZBdGhlbnMxRDBCBgNVBAoTO0hlbGxlbmljIEFj
+YWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgQ2VydC4gQXV0aG9yaXR5
+MUQwQgYDVQQDEztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0
+dXRpb25zIEVDQyBSb290Q0EgMjAxNTB2MBAGByqGSM49AgEGBSuBBAAiA2IABJKg
+QehLgoRc4vgxEZmGZE4JJS+dQS8KrjVPdJWyUWRrjWvmP3CV8AVER6ZyOFB2lQJa
+jq4onvktTpnvLEhvTCUp6NFxW98dwXU3tNf6e3pCnGoKVlp8aQuqgAkkbH7BRqNC
+MEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFLQi
+C4KZJAEOnLvkDv2/+5cgk5kqMAoGCCqGSM49BAMCA2cAMGQCMGfOFmI4oqxiRaep
+lSTAGiecMjvAwNW6qef4BENThe5SId6d9SWDPp5YSy/XZxMOIQIwBeF1Ad5o7Sof
+TUwJCA3sS61kFyjndc5FZXIhF8siQQ6ME5g4mlRtm8rifOoCWCKR
+-----END CERTIFICATE-----
+
+# Issuer: CN=ISRG Root X1 O=Internet Security Research Group
+# Subject: CN=ISRG Root X1 O=Internet Security Research Group
+# Label: "ISRG Root X1"
+# Serial: 172886928669790476064670243504169061120
+# MD5 Fingerprint: 0c:d2:f9:e0:da:17:73:e9:ed:86:4d:a5:e3:70:e7:4e
+# SHA1 Fingerprint: ca:bd:2a:79:a1:07:6a:31:f2:1d:25:36:35:cb:03:9d:43:29:a5:e8
+# SHA256 Fingerprint: 96:bc:ec:06:26:49:76:f3:74:60:77:9a:cf:28:c5:a7:cf:e8:a3:c0:aa:e1:1a:8f:fc:ee:05:c0:bd:df:08:c6
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----
+
+# Issuer: O=FNMT-RCM OU=AC RAIZ FNMT-RCM
+# Subject: O=FNMT-RCM OU=AC RAIZ FNMT-RCM
+# Label: "AC RAIZ FNMT-RCM"
+# Serial: 485876308206448804701554682760554759
+# MD5 Fingerprint: e2:09:04:b4:d3:bd:d1:a0:14:fd:1a:d2:47:c4:57:1d
+# SHA1 Fingerprint: ec:50:35:07:b2:15:c4:95:62:19:e2:a8:9a:5b:42:99:2c:4c:2c:20
+# SHA256 Fingerprint: eb:c5:57:0c:29:01:8c:4d:67:b1:aa:12:7b:af:12:f7:03:b4:61:1e:bc:17:b7:da:b5:57:38:94:17:9b:93:fa
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIPXZONMGc2yAYdGsdUhGkHMA0GCSqGSIb3DQEBCwUAMDsx
+CzAJBgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJ
+WiBGTk1ULVJDTTAeFw0wODEwMjkxNTU5NTZaFw0zMDAxMDEwMDAwMDBaMDsxCzAJ
+BgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJWiBG
+Tk1ULVJDTTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBALpxgHpMhm5/
+yBNtwMZ9HACXjywMI7sQmkCpGreHiPibVmr75nuOi5KOpyVdWRHbNi63URcfqQgf
+BBckWKo3Shjf5TnUV/3XwSyRAZHiItQDwFj8d0fsjz50Q7qsNI1NOHZnjrDIbzAz
+WHFctPVrbtQBULgTfmxKo0nRIBnuvMApGGWn3v7v3QqQIecaZ5JCEJhfTzC8PhxF
+tBDXaEAUwED653cXeuYLj2VbPNmaUtu1vZ5Gzz3rkQUCwJaydkxNEJY7kvqcfw+Z
+374jNUUeAlz+taibmSXaXvMiwzn15Cou08YfxGyqxRxqAQVKL9LFwag0Jl1mpdIC
+IfkYtwb1TplvqKtMUejPUBjFd8g5CSxJkjKZqLsXF3mwWsXmo8RZZUc1g16p6DUL
+mbvkzSDGm0oGObVo/CK67lWMK07q87Hj/LaZmtVC+nFNCM+HHmpxffnTtOmlcYF7
+wk5HlqX2doWjKI/pgG6BU6VtX7hI+cL5NqYuSf+4lsKMB7ObiFj86xsc3i1w4peS
+MKGJ47xVqCfWS+2QrYv6YyVZLag13cqXM7zlzced0ezvXg5KkAYmY6252TUtB7p2
+ZSysV4999AeU14ECll2jB0nVetBX+RvnU0Z1qrB5QstocQjpYL05ac70r8NWQMet
+UqIJ5G+GR4of6ygnXYMgrwTJbFaai0b1AgMBAAGjgYMwgYAwDwYDVR0TAQH/BAUw
+AwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFPd9xf3E6Jobd2Sn9R2gzL+H
+YJptMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vd3d3
+LmNlcnQuZm5tdC5lcy9kcGNzLzANBgkqhkiG9w0BAQsFAAOCAgEAB5BK3/MjTvDD
+nFFlm5wioooMhfNzKWtN/gHiqQxjAb8EZ6WdmF/9ARP67Jpi6Yb+tmLSbkyU+8B1
+RXxlDPiyN8+sD8+Nb/kZ94/sHvJwnvDKuO+3/3Y3dlv2bojzr2IyIpMNOmqOFGYM
+LVN0V2Ue1bLdI4E7pWYjJ2cJj+F3qkPNZVEI7VFY/uY5+ctHhKQV8Xa7pO6kO8Rf
+77IzlhEYt8llvhjho6Tc+hj507wTmzl6NLrTQfv6MooqtyuGC2mDOL7Nii4LcK2N
+JpLuHvUBKwrZ1pebbuCoGRw6IYsMHkCtA+fdZn71uSANA+iW+YJF1DngoABd15jm
+fZ5nc8OaKveri6E6FO80vFIOiZiaBECEHX5FaZNXzuvO+FB8TxxuBEOb+dY7Ixjp
+6o7RTUaN8Tvkasq6+yO3m/qZASlaWFot4/nUbQ4mrcFuNLwy+AwF+mWj2zs3gyLp
+1txyM/1d8iC9djwj2ij3+RvrWWTV3F9yfiD8zYm1kGdNYno/Tq0dwzn+evQoFt9B
+9kiABdcPUXmsEKvU7ANm5mqwujGSQkBqvjrTcuFqN1W8rB2Vt2lh8kORdOag0wok
+RqEIr9baRRmW1FMdW4R58MD3R++Lj8UGrp1MYp3/RgT408m2ECVAdf4WqslKYIYv
+uu8wd+RU4riEmViAqhOLUTpPSPaLtrM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 1 O=Amazon
+# Subject: CN=Amazon Root CA 1 O=Amazon
+# Label: "Amazon Root CA 1"
+# Serial: 143266978916655856878034712317230054538369994
+# MD5 Fingerprint: 43:c6:bf:ae:ec:fe:ad:2f:18:c6:88:68:30:fc:c8:e6
+# SHA1 Fingerprint: 8d:a7:f9:65:ec:5e:fc:37:91:0f:1c:6e:59:fd:c1:cc:6a:6e:de:16
+# SHA256 Fingerprint: 8e:cd:e6:88:4f:3d:87:b1:12:5b:a3:1a:c3:fc:b1:3d:70:16:de:7f:57:cc:90:4f:e1:cb:97:c6:ae:98:19:6e
+-----BEGIN CERTIFICATE-----
+MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF
+ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
+b24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
+b3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj
+ca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM
+9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw
+IFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6
+VOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L
+93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm
+jgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
+AYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA
+A4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI
+U5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs
+N+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv
+o/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU
+5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy
+rqXRfboQnoZsG4q5WTP468SQvvG5
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 2 O=Amazon
+# Subject: CN=Amazon Root CA 2 O=Amazon
+# Label: "Amazon Root CA 2"
+# Serial: 143266982885963551818349160658925006970653239
+# MD5 Fingerprint: c8:e5:8d:ce:a8:42:e2:7a:c0:2a:5c:7c:9e:26:bf:66
+# SHA1 Fingerprint: 5a:8c:ef:45:d7:a6:98:59:76:7a:8c:8b:44:96:b5:78:cf:47:4b:1a
+# SHA256 Fingerprint: 1b:a5:b2:aa:8c:65:40:1a:82:96:01:18:f8:0b:ec:4f:62:30:4d:83:ce:c4:71:3a:19:c3:9c:01:1e:a4:6d:b4
+-----BEGIN CERTIFICATE-----
+MIIFQTCCAymgAwIBAgITBmyf0pY1hp8KD+WGePhbJruKNzANBgkqhkiG9w0BAQwF
+ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
+b24gUm9vdCBDQSAyMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
+b3QgQ0EgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK2Wny2cSkxK
+gXlRmeyKy2tgURO8TW0G/LAIjd0ZEGrHJgw12MBvIITplLGbhQPDW9tK6Mj4kHbZ
+W0/jTOgGNk3Mmqw9DJArktQGGWCsN0R5hYGCrVo34A3MnaZMUnbqQ523BNFQ9lXg
+1dKmSYXpN+nKfq5clU1Imj+uIFptiJXZNLhSGkOQsL9sBbm2eLfq0OQ6PBJTYv9K
+8nu+NQWpEjTj82R0Yiw9AElaKP4yRLuH3WUnAnE72kr3H9rN9yFVkE8P7K6C4Z9r
+2UXTu/Bfh+08LDmG2j/e7HJV63mjrdvdfLC6HM783k81ds8P+HgfajZRRidhW+me
+z/CiVX18JYpvL7TFz4QuK/0NURBs+18bvBt+xa47mAExkv8LV/SasrlX6avvDXbR
+8O70zoan4G7ptGmh32n2M8ZpLpcTnqWHsFcQgTfJU7O7f/aS0ZzQGPSSbtqDT6Zj
+mUyl+17vIWR6IF9sZIUVyzfpYgwLKhbcAS4y2j5L9Z469hdAlO+ekQiG+r5jqFoz
+7Mt0Q5X5bGlSNscpb/xVA1wf+5+9R+vnSUeVC06JIglJ4PVhHvG/LopyboBZ/1c6
++XUyo05f7O0oYtlNc/LMgRdg7c3r3NunysV+Ar3yVAhU/bQtCSwXVEqY0VThUWcI
+0u1ufm8/0i2BWSlmy5A5lREedCf+3euvAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMB
+Af8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSwDPBMMPQFWAJI/TPlUq9LhONm
+UjANBgkqhkiG9w0BAQwFAAOCAgEAqqiAjw54o+Ci1M3m9Zh6O+oAA7CXDpO8Wqj2
+LIxyh6mx/H9z/WNxeKWHWc8w4Q0QshNabYL1auaAn6AFC2jkR2vHat+2/XcycuUY
++gn0oJMsXdKMdYV2ZZAMA3m3MSNjrXiDCYZohMr/+c8mmpJ5581LxedhpxfL86kS
+k5Nrp+gvU5LEYFiwzAJRGFuFjWJZY7attN6a+yb3ACfAXVU3dJnJUH/jWS5E4ywl
+7uxMMne0nxrpS10gxdr9HIcWxkPo1LsmmkVwXqkLN1PiRnsn/eBG8om3zEK2yygm
+btmlyTrIQRNg91CMFa6ybRoVGld45pIq2WWQgj9sAq+uEjonljYE1x2igGOpm/Hl
+urR8FLBOybEfdF849lHqm/osohHUqS0nGkWxr7JOcQ3AWEbWaQbLU8uz/mtBzUF+
+fUwPfHJ5elnNXkoOrJupmHN5fLT0zLm4BwyydFy4x2+IoZCn9Kr5v2c69BoVYh63
+n749sSmvZ6ES8lgQGVMDMBu4Gon2nL2XA46jCfMdiyHxtN/kHNGfZQIG6lzWE7OE
+76KlXIx3KadowGuuQNKotOrN8I1LOJwZmhsoVLiJkO/KdYE+HvJkJMcYr07/R54H
+9jVlpNMKVv/1F2Rs76giJUmTtt8AF9pYfl3uxRuw0dFfIRDH+fO6AgonB8Xx1sfT
+4PsJYGw=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 3 O=Amazon
+# Subject: CN=Amazon Root CA 3 O=Amazon
+# Label: "Amazon Root CA 3"
+# Serial: 143266986699090766294700635381230934788665930
+# MD5 Fingerprint: a0:d4:ef:0b:f7:b5:d8:49:95:2a:ec:f5:c4:fc:81:87
+# SHA1 Fingerprint: 0d:44:dd:8c:3c:8c:1a:1a:58:75:64:81:e9:0f:2e:2a:ff:b3:d2:6e
+# SHA256 Fingerprint: 18:ce:6c:fe:7b:f1:4e:60:b2:e3:47:b8:df:e8:68:cb:31:d0:2e:bb:3a:da:27:15:69:f5:03:43:b4:6d:b3:a4
+-----BEGIN CERTIFICATE-----
+MIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5
+MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g
+Um9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG
+A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg
+Q0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl
+ui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr
+ttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr
+BqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM
+YyRIHN8wfdVoOw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 4 O=Amazon
+# Subject: CN=Amazon Root CA 4 O=Amazon
+# Label: "Amazon Root CA 4"
+# Serial: 143266989758080763974105200630763877849284878
+# MD5 Fingerprint: 89:bc:27:d5:eb:17:8d:06:6a:69:d5:fd:89:47:b4:cd
+# SHA1 Fingerprint: f6:10:84:07:d6:f8:bb:67:98:0c:c2:e2:44:c2:eb:ae:1c:ef:63:be
+# SHA256 Fingerprint: e3:5d:28:41:9e:d0:20:25:cf:a6:90:38:cd:62:39:62:45:8d:a5:c6:95:fb:de:a3:c2:2b:0b:fb:25:89:70:92
+-----BEGIN CERTIFICATE-----
+MIIB8jCCAXigAwIBAgITBmyf18G7EEwpQ+Vxe3ssyBrBDjAKBggqhkjOPQQDAzA5
+MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g
+Um9vdCBDQSA0MB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG
+A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg
+Q0EgNDB2MBAGByqGSM49AgEGBSuBBAAiA2IABNKrijdPo1MN/sGKe0uoe0ZLY7Bi
+9i0b2whxIdIA6GO9mif78DluXeo9pcmBqqNbIJhFXRbb/egQbeOc4OO9X4Ri83Bk
+M6DLJC9wuoihKqB1+IGuYgbEgds5bimwHvouXKNCMEAwDwYDVR0TAQH/BAUwAwEB
+/zAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFNPsxzplbszh2naaVvuc84ZtV+WB
+MAoGCCqGSM49BAMDA2gAMGUCMDqLIfG9fhGt0O9Yli/W651+kI0rz2ZVwyzjKKlw
+CkcO8DdZEv8tmZQoTipPNU0zWgIxAOp1AE47xDqUEpHJWEadIRNyp4iciuRMStuW
+1KyLa2tJElMzrdfkviT8tQp21KW8EA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
+# Subject: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
+# Label: "TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1"
+# Serial: 1
+# MD5 Fingerprint: dc:00:81:dc:69:2f:3e:2f:b0:3b:f6:3d:5a:91:8e:49
+# SHA1 Fingerprint: 31:43:64:9b:ec:ce:27:ec:ed:3a:3f:0b:8f:0d:e4:e8:91:dd:ee:ca
+# SHA256 Fingerprint: 46:ed:c3:68:90:46:d5:3a:45:3f:b3:10:4a:b8:0d:ca:ec:65:8b:26:60:ea:16:29:dd:7e:86:79:90:64:87:16
+-----BEGIN CERTIFICATE-----
+MIIEYzCCA0ugAwIBAgIBATANBgkqhkiG9w0BAQsFADCB0jELMAkGA1UEBhMCVFIx
+GDAWBgNVBAcTD0dlYnplIC0gS29jYWVsaTFCMEAGA1UEChM5VHVya2l5ZSBCaWxp
+bXNlbCB2ZSBUZWtub2xvamlrIEFyYXN0aXJtYSBLdXJ1bXUgLSBUVUJJVEFLMS0w
+KwYDVQQLEyRLYW11IFNlcnRpZmlrYXN5b24gTWVya2V6aSAtIEthbXUgU00xNjA0
+BgNVBAMTLVRVQklUQUsgS2FtdSBTTSBTU0wgS29rIFNlcnRpZmlrYXNpIC0gU3Vy
+dW0gMTAeFw0xMzExMjUwODI1NTVaFw00MzEwMjUwODI1NTVaMIHSMQswCQYDVQQG
+EwJUUjEYMBYGA1UEBxMPR2ViemUgLSBLb2NhZWxpMUIwQAYDVQQKEzlUdXJraXll
+IEJpbGltc2VsIHZlIFRla25vbG9qaWsgQXJhc3Rpcm1hIEt1cnVtdSAtIFRVQklU
+QUsxLTArBgNVBAsTJEthbXUgU2VydGlmaWthc3lvbiBNZXJrZXppIC0gS2FtdSBT
+TTE2MDQGA1UEAxMtVFVCSVRBSyBLYW11IFNNIFNTTCBLb2sgU2VydGlmaWthc2kg
+LSBTdXJ1bSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAr3UwM6q7
+a9OZLBI3hNmNe5eA027n/5tQlT6QlVZC1xl8JoSNkvoBHToP4mQ4t4y86Ij5iySr
+LqP1N+RAjhgleYN1Hzv/bKjFxlb4tO2KRKOrbEz8HdDc72i9z+SqzvBV96I01INr
+N3wcwv61A+xXzry0tcXtAA9TNypN9E8Mg/uGz8v+jE69h/mniyFXnHrfA2eJLJ2X
+YacQuFWQfw4tJzh03+f92k4S400VIgLI4OD8D62K18lUUMw7D8oWgITQUVbDjlZ/
+iSIzL+aFCr2lqBs23tPcLG07xxO9WSMs5uWk99gL7eqQQESolbuT1dCANLZGeA4f
+AJNG4e7p+exPFwIDAQABo0IwQDAdBgNVHQ4EFgQUZT/HiobGPN08VFw1+DrtUgxH
+V8gwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
+BQADggEBACo/4fEyjq7hmFxLXs9rHmoJ0iKpEsdeV31zVmSAhHqT5Am5EM2fKifh
+AHe+SMg1qIGf5LgsyX8OsNJLN13qudULXjS99HMpw+0mFZx+CFOKWI3QSyjfwbPf
+IPP54+M638yclNhOT8NrF7f3cuitZjO1JVOr4PhMqZ398g26rrnZqsZr+ZO7rqu4
+lzwDGrpDxpa5RXI4s6ehlj2Re37AIVNMh+3yC1SVUZPVIqUNivGTDj5UDrDYyU7c
+8jEyVupk+eq1nRZmQnLzf9OxMUP8pI4X8W0jq5Rm+K37DwhuJi1/FwcJsoz7UMCf
+lo3Ptv0AnVoUmr8CRPXBwp8iXqIPoeM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD.
+# Subject: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD.
+# Label: "GDCA TrustAUTH R5 ROOT"
+# Serial: 9009899650740120186
+# MD5 Fingerprint: 63:cc:d9:3d:34:35:5c:6f:53:a3:e2:08:70:48:1f:b4
+# SHA1 Fingerprint: 0f:36:38:5b:81:1a:25:c3:9b:31:4e:83:ca:e9:34:66:70:cc:74:b4
+# SHA256 Fingerprint: bf:ff:8f:d0:44:33:48:7d:6a:8a:a6:0c:1a:29:76:7a:9f:c2:bb:b0:5e:42:0f:71:3a:13:b9:92:89:1d:38:93
+-----BEGIN CERTIFICATE-----
+MIIFiDCCA3CgAwIBAgIIfQmX/vBH6nowDQYJKoZIhvcNAQELBQAwYjELMAkGA1UE
+BhMCQ04xMjAwBgNVBAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZ
+IENPLixMVEQuMR8wHQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMB4XDTE0
+MTEyNjA1MTMxNVoXDTQwMTIzMTE1NTk1OVowYjELMAkGA1UEBhMCQ04xMjAwBgNV
+BAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZIENPLixMVEQuMR8w
+HQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMIICIjANBgkqhkiG9w0BAQEF
+AAOCAg8AMIICCgKCAgEA2aMW8Mh0dHeb7zMNOwZ+Vfy1YI92hhJCfVZmPoiC7XJj
+Dp6L3TQsAlFRwxn9WVSEyfFrs0yw6ehGXTjGoqcuEVe6ghWinI9tsJlKCvLriXBj
+TnnEt1u9ol2x8kECK62pOqPseQrsXzrj/e+APK00mxqriCZ7VqKChh/rNYmDf1+u
+KU49tm7srsHwJ5uu4/Ts765/94Y9cnrrpftZTqfrlYwiOXnhLQiPzLyRuEH3FMEj
+qcOtmkVEs7LXLM3GKeJQEK5cy4KOFxg2fZfmiJqwTTQJ9Cy5WmYqsBebnh52nUpm
+MUHfP/vFBu8btn4aRjb3ZGM74zkYI+dndRTVdVeSN72+ahsmUPI2JgaQxXABZG12
+ZuGR224HwGGALrIuL4xwp9E7PLOR5G62xDtw8mySlwnNR30YwPO7ng/Wi64HtloP
+zgsMR6flPri9fcebNaBhlzpBdRfMK5Z3KpIhHtmVdiBnaM8Nvd/WHwlqmuLMc3Gk
+L30SgLdTMEZeS1SZD2fJpcjyIMGC7J0R38IC+xo70e0gmu9lZJIQDSri3nDxGGeC
+jGHeuLzRL5z7D9Ar7Rt2ueQ5Vfj4oR24qoAATILnsn8JuLwwoC8N9VKejveSswoA
+HQBUlwbgsQfZxw9cZX08bVlX5O2ljelAU58VS6Bx9hoh49pwBiFYFIeFd3mqgnkC
+AwEAAaNCMEAwHQYDVR0OBBYEFOLJQJ9NzuiaoXzPDj9lxSmIahlRMA8GA1UdEwEB
+/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQDRSVfg
+p8xoWLoBDysZzY2wYUWsEe1jUGn4H3++Fo/9nesLqjJHdtJnJO29fDMylyrHBYZm
+DRd9FBUb1Ov9H5r2XpdptxolpAqzkT9fNqyL7FeoPueBihhXOYV0GkLH6VsTX4/5
+COmSdI31R9KrO9b7eGZONn356ZLpBN79SWP8bfsUcZNnL0dKt7n/HipzcEYwv1ry
+L3ml4Y0M2fmyYzeMN2WFcGpcWwlyua1jPLHd+PwyvzeG5LuOmCd+uh8W4XAR8gPf
+JWIyJyYYMoSf/wA6E7qaTfRPuBRwIrHKK5DOKcFw9C+df/KQHtZa37dG/OaG+svg
+IHZ6uqbL9XzeYqWxi+7egmaKTjowHz+Ay60nugxe19CxVsp3cbK1daFQqUBDF8Io
+2c9Si1vIY9RCPqAzekYu9wogRlR+ak8x8YF+QnQ4ZXMn7sZ8uI7XpTrXmKGcjBBV
+09tL7ECQ8s1uV9JiDnxXk7Gnbc2dg7sq5+W2O3FYrf3RRbxake5TFW/TRQl1brqQ
+XR4EzzffHqhmsYzmIGrv/EhOdJhCrylvLmrH+33RZjEizIYAfmaDDEL0vTSSwxrq
+T8p+ck0LcIymSLumoRT2+1hEmRSuqguTaaApJUqlyyvdimYHFngVV3Eb7PVHhPOe
+MTd61X8kreS8/f3MboPoDKi3QWwH3b08hpcv0g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=TrustCor RootCert CA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Subject: CN=TrustCor RootCert CA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Label: "TrustCor RootCert CA-1"
+# Serial: 15752444095811006489
+# MD5 Fingerprint: 6e:85:f1:dc:1a:00:d3:22:d5:b2:b2:ac:6b:37:05:45
+# SHA1 Fingerprint: ff:bd:cd:e7:82:c8:43:5e:3c:6f:26:86:5c:ca:a8:3a:45:5b:c3:0a
+# SHA256 Fingerprint: d4:0e:9c:86:cd:8f:e4:68:c1:77:69:59:f4:9e:a7:74:fa:54:86:84:b6:c4:06:f3:90:92:61:f4:dc:e2:57:5c
+-----BEGIN CERTIFICATE-----
+MIIEMDCCAxigAwIBAgIJANqb7HHzA7AZMA0GCSqGSIb3DQEBCwUAMIGkMQswCQYD
+VQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEgQ2l0eTEk
+MCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYDVQQLDB5U
+cnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxHzAdBgNVBAMMFlRydXN0Q29y
+IFJvb3RDZXJ0IENBLTEwHhcNMTYwMjA0MTIzMjE2WhcNMjkxMjMxMTcyMzE2WjCB
+pDELMAkGA1UEBhMCUEExDzANBgNVBAgMBlBhbmFtYTEUMBIGA1UEBwwLUGFuYW1h
+IENpdHkxJDAiBgNVBAoMG1RydXN0Q29yIFN5c3RlbXMgUy4gZGUgUi5MLjEnMCUG
+A1UECwweVHJ1c3RDb3IgQ2VydGlmaWNhdGUgQXV0aG9yaXR5MR8wHQYDVQQDDBZU
+cnVzdENvciBSb290Q2VydCBDQS0xMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEAv463leLCJhJrMxnHQFgKq1mqjQCj/IDHUHuO1CAmujIS2CNUSSUQIpid
+RtLByZ5OGy4sDjjzGiVoHKZaBeYei0i/mJZ0PmnK6bV4pQa81QBeCQryJ3pS/C3V
+seq0iWEk8xoT26nPUu0MJLq5nux+AHT6k61sKZKuUbS701e/s/OojZz0JEsq1pme
+9J7+wH5COucLlVPat2gOkEz7cD+PSiyU8ybdY2mplNgQTsVHCJCZGxdNuWxu72CV
+EY4hgLW9oHPY0LJ3xEXqWib7ZnZ2+AYfYW0PVcWDtxBWcgYHpfOxGgMFZA6dWorW
+hnAbJN7+KIor0Gqw/Hqi3LJ5DotlDwIDAQABo2MwYTAdBgNVHQ4EFgQU7mtJPHo/
+DeOxCbeKyKsZn3MzUOcwHwYDVR0jBBgwFoAU7mtJPHo/DeOxCbeKyKsZn3MzUOcw
+DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD
+ggEBACUY1JGPE+6PHh0RU9otRCkZoB5rMZ5NDp6tPVxBb5UrJKF5mDo4Nvu7Zp5I
+/5CQ7z3UuJu0h3U/IJvOcs+hVcFNZKIZBqEHMwwLKeXx6quj7LUKdJDHfXLy11yf
+ke+Ri7fc7Waiz45mO7yfOgLgJ90WmMCV1Aqk5IGadZQ1nJBfiDcGrVmVCrDRZ9MZ
+yonnMlo2HD6CqFqTvsbQZJG2z9m2GM/bftJlo6bEjhcxwft+dtvTheNYsnd6djts
+L1Ac59v2Z3kf9YKVmgenFK+P3CghZwnS1k1aHBkcjndcw5QkPTJrS37UeJSDvjdN
+zl/HHk484IkzlQsPpTLWPFp5LBk=
+-----END CERTIFICATE-----
+
+# Issuer: CN=TrustCor RootCert CA-2 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Subject: CN=TrustCor RootCert CA-2 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Label: "TrustCor RootCert CA-2"
+# Serial: 2711694510199101698
+# MD5 Fingerprint: a2:e1:f8:18:0b:ba:45:d5:c7:41:2a:bb:37:52:45:64
+# SHA1 Fingerprint: b8:be:6d:cb:56:f1:55:b9:63:d4:12:ca:4e:06:34:c7:94:b2:1c:c0
+# SHA256 Fingerprint: 07:53:e9:40:37:8c:1b:d5:e3:83:6e:39:5d:ae:a5:cb:83:9e:50:46:f1:bd:0e:ae:19:51:cf:10:fe:c7:c9:65
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=TrustCor ECA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Subject: CN=TrustCor ECA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
+# Label: "TrustCor ECA-1"
+# Serial: 9548242946988625984
+# MD5 Fingerprint: 27:92:23:1d:0a:f5:40:7c:e9:e6:6b:9d:d8:f5:e7:6c
+# SHA1 Fingerprint: 58:d1:df:95:95:67:6b:63:c0:f0:5b:1c:17:4d:8b:84:0b:c8:78:bd
+# SHA256 Fingerprint: 5a:88:5d:b1:9c:01:d9:12:c5:75:93:88:93:8c:af:bb:df:03:1a:b2:d4:8e:91:ee:15:58:9b:42:97:1d:03:9c
+-----BEGIN CERTIFICATE-----
+MIIEIDCCAwigAwIBAgIJAISCLF8cYtBAMA0GCSqGSIb3DQEBCwUAMIGcMQswCQYD
+VQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEgQ2l0eTEk
+MCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYDVQQLDB5U
+cnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxFzAVBgNVBAMMDlRydXN0Q29y
+IEVDQS0xMB4XDTE2MDIwNDEyMzIzM1oXDTI5MTIzMTE3MjgwN1owgZwxCzAJBgNV
+BAYTAlBBMQ8wDQYDVQQIDAZQYW5hbWExFDASBgNVBAcMC1BhbmFtYSBDaXR5MSQw
+IgYDVQQKDBtUcnVzdENvciBTeXN0ZW1zIFMuIGRlIFIuTC4xJzAlBgNVBAsMHlRy
+dXN0Q29yIENlcnRpZmljYXRlIEF1dGhvcml0eTEXMBUGA1UEAwwOVHJ1c3RDb3Ig
+RUNBLTEwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDPj+ARtZ+odnbb
+3w9U73NjKYKtR8aja+3+XzP4Q1HpGjORMRegdMTUpwHmspI+ap3tDvl0mEDTPwOA
+BoJA6LHip1GnHYMma6ve+heRK9jGrB6xnhkB1Zem6g23xFUfJ3zSCNV2HykVh0A5
+3ThFEXXQmqc04L/NyFIduUd+Dbi7xgz2c1cWWn5DkR9VOsZtRASqnKmcp0yJF4Ou
+owReUoCLHhIlERnXDH19MURB6tuvsBzvgdAsxZohmz3tQjtQJvLsznFhBmIhVE5/
+wZ0+fyCMgMsq2JdiyIMzkX2woloPV+g7zPIlstR8L+xNxqE6FXrntl019fZISjZF
+ZtS6mFjBAgMBAAGjYzBhMB0GA1UdDgQWBBREnkj1zG1I1KBLf/5ZJC+Dl5mahjAf
+BgNVHSMEGDAWgBREnkj1zG1I1KBLf/5ZJC+Dl5mahjAPBgNVHRMBAf8EBTADAQH/
+MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAQEABT41XBVwm8nHc2Fv
+civUwo/yQ10CzsSUuZQRg2dd4mdsdXa/uwyqNsatR5Nj3B5+1t4u/ukZMjgDfxT2
+AHMsWbEhBuH7rBiVDKP/mZb3Kyeb1STMHd3BOuCYRLDE5D53sXOpZCz2HAF8P11F
+hcCF5yWPldwX8zyfGm6wyuMdKulMY/okYWLW2n62HGz1Ah3UKt1VkOsqEUc8Ll50
+soIipX1TH0XsJ5F95yIW6MBoNtjG8U+ARDL54dHRHareqKucBK+tIA5kmE2la8BI
+WJZpTdwHjFGTot+fDz2LYLSCjaoITmJF4PkL0uDgPFveXHEnJcLmA4GLEFPjx1Wi
+tJ/X5g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com Root Certification Authority RSA O=SSL Corporation
+# Subject: CN=SSL.com Root Certification Authority RSA O=SSL Corporation
+# Label: "SSL.com Root Certification Authority RSA"
+# Serial: 8875640296558310041
+# MD5 Fingerprint: 86:69:12:c0:70:f1:ec:ac:ac:c2:d5:bc:a5:5b:a1:29
+# SHA1 Fingerprint: b7:ab:33:08:d1:ea:44:77:ba:14:80:12:5a:6f:bd:a9:36:49:0c:bb
+# SHA256 Fingerprint: 85:66:6a:56:2e:e0:be:5c:e9:25:c1:d8:89:0a:6f:76:a8:7e:c1:6d:4d:7d:5f:29:ea:74:19:cf:20:12:3b:69
+-----BEGIN CERTIFICATE-----
+MIIF3TCCA8WgAwIBAgIIeyyb0xaAMpkwDQYJKoZIhvcNAQELBQAwfDELMAkGA1UE
+BhMCVVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQK
+DA9TU0wgQ29ycG9yYXRpb24xMTAvBgNVBAMMKFNTTC5jb20gUm9vdCBDZXJ0aWZp
+Y2F0aW9uIEF1dGhvcml0eSBSU0EwHhcNMTYwMjEyMTczOTM5WhcNNDEwMjEyMTcz
+OTM5WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hv
+dXN0b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjExMC8GA1UEAwwoU1NMLmNv
+bSBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IFJTQTCCAiIwDQYJKoZIhvcN
+AQEBBQADggIPADCCAgoCggIBAPkP3aMrfcvQKv7sZ4Wm5y4bunfh4/WvpOz6Sl2R
+xFdHaxh3a3by/ZPkPQ/CFp4LZsNWlJ4Xg4XOVu/yFv0AYvUiCVToZRdOQbngT0aX
+qhvIuG5iXmmxX9sqAn78bMrzQdjt0Oj8P2FI7bADFB0QDksZ4LtO7IZl/zbzXmcC
+C52GVWH9ejjt/uIZALdvoVBidXQ8oPrIJZK0bnoix/geoeOy3ZExqysdBP+lSgQ3
+6YWkMyv94tZVNHwZpEpox7Ko07fKoZOI68GXvIz5HdkihCR0xwQ9aqkpk8zruFvh
+/l8lqjRYyMEjVJ0bmBHDOJx+PYZspQ9AhnwC9FwCTyjLrnGfDzrIM/4RJTXq/LrF
+YD3ZfBjVsqnTdXgDciLKOsMf7yzlLqn6niy2UUb9rwPW6mBo6oUWNmuF6R7As93E
+JNyAKoFBbZQ+yODJgUEAnl6/f8UImKIYLEJAs/lvOCdLToD0PYFH4Ih86hzOtXVc
+US4cK38acijnALXRdMbX5J+tB5O2UzU1/Dfkw/ZdFr4hc96SCvigY2q8lpJqPvi8
+ZVWb3vUNiSYE/CUapiVpy8JtynziWV+XrOvvLsi81xtZPCvM8hnIk2snYxnP/Okm
++Mpxm3+T/jRnhE6Z6/yzeAkzcLpmpnbtG3PrGqUNxCITIJRWCk4sbE6x/c+cCbqi
+M+2HAgMBAAGjYzBhMB0GA1UdDgQWBBTdBAkHovV6fVJTEpKV7jiAJQ2mWTAPBgNV
+HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFN0ECQei9Xp9UlMSkpXuOIAlDaZZMA4G
+A1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAgEAIBgRlCn7Jp0cHh5wYfGV
+cpNxJK1ok1iOMq8bs3AD/CUrdIWQPXhq9LmLpZc7tRiRux6n+UBbkflVma8eEdBc
+Hadm47GUBwwyOabqG7B52B2ccETjit3E+ZUfijhDPwGFpUenPUayvOUiaPd7nNgs
+PgohyC0zrL/FgZkxdMF1ccW+sfAjRfSda/wZY52jvATGGAslu1OJD7OAUN5F7kR/
+q5R4ZJjT9ijdh9hwZXT7DrkT66cPYakylszeu+1jTBi7qUD3oFRuIIhxdRjqerQ0
+cuAjJ3dctpDqhiVAq+8zD8ufgr6iIPv2tS0a5sKFsXQP+8hlAqRSAUfdSSLBv9jr
+a6x+3uxjMxW3IwiPxg+NQVrdjsW5j+VFP3jbutIbQLH+cU0/4IGiul607BXgk90I
+H37hVZkLId6Tngr75qNJvTYw/ud3sqB1l7UtgYgXZSD32pAAn8lSzDLKNXz1PQ/Y
+K9f1JmzJBjSWFupwWRoyeXkLtoh/D1JIPb9s2KJELtFOt3JY04kTlf5Eq/jXixtu
+nLwsoFvVagCvXzfh1foQC5ichucmj87w7G6KVwuA406ywKBjYZC6VWg3dGq2ktuf
+oYYitmUnDuy2n0Jg5GfCtdpBC8TTi2EbvPofkSvXRAdeuims2cXp71NIWuuA8ShY
+Ic2wBlX7Jz9TkHCpBB5XJ7k=
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com Root Certification Authority ECC O=SSL Corporation
+# Subject: CN=SSL.com Root Certification Authority ECC O=SSL Corporation
+# Label: "SSL.com Root Certification Authority ECC"
+# Serial: 8495723813297216424
+# MD5 Fingerprint: 2e:da:e4:39:7f:9c:8f:37:d1:70:9f:26:17:51:3a:8e
+# SHA1 Fingerprint: c3:19:7c:39:24:e6:54:af:1b:c4:ab:20:95:7a:e2:c3:0e:13:02:6a
+# SHA256 Fingerprint: 34:17:bb:06:cc:60:07:da:1b:96:1c:92:0b:8a:b4:ce:3f:ad:82:0e:4a:a3:0b:9a:cb:c4:a7:4e:bd:ce:bc:65
+-----BEGIN CERTIFICATE-----
+MIICjTCCAhSgAwIBAgIIdebfy8FoW6gwCgYIKoZIzj0EAwIwfDELMAkGA1UEBhMC
+VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T
+U0wgQ29ycG9yYXRpb24xMTAvBgNVBAMMKFNTTC5jb20gUm9vdCBDZXJ0aWZpY2F0
+aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNDAzWhcNNDEwMjEyMTgxNDAz
+WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hvdXN0
+b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjExMC8GA1UEAwwoU1NMLmNvbSBS
+b290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABEVuqVDEpiM2nl8ojRfLliJkP9x6jh3MCLOicSS6jkm5BBtHllirLZXI
+7Z4INcgn64mMU1jrYor+8FsPazFSY0E7ic3s7LaNGdM0B9y7xgZ/wkWV7Mt/qCPg
+CemB+vNH06NjMGEwHQYDVR0OBBYEFILRhXMw5zUE044CkvvlpNHEIejNMA8GA1Ud
+EwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUgtGFczDnNQTTjgKS++Wk0cQh6M0wDgYD
+VR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2cAMGQCMG/n61kRpGDPYbCWe+0F+S8T
+kdzt5fxQaxFGRrMcIQBiu77D5+jNB5n5DQtdcj7EqgIwH7y6C+IwJPt8bYBVCpk+
+gA0z5Wajs6O7pdWLjwkspl1+4vAHCGht0nxpbl/f5Wpl
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation
+# Subject: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation
+# Label: "SSL.com EV Root Certification Authority RSA R2"
+# Serial: 6248227494352943350
+# MD5 Fingerprint: e1:1e:31:58:1a:ae:54:53:02:f6:17:6a:11:7b:4d:95
+# SHA1 Fingerprint: 74:3a:f0:52:9b:d0:32:a0:f4:4a:83:cd:d4:ba:a9:7b:7c:2e:c4:9a
+# SHA256 Fingerprint: 2e:7b:f1:6c:c2:24:85:a7:bb:e2:aa:86:96:75:07:61:b0:ae:39:be:3b:2f:e9:d0:cc:6d:4e:f7:34:91:42:5c
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation
+# Subject: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation
+# Label: "SSL.com EV Root Certification Authority ECC"
+# Serial: 3182246526754555285
+# MD5 Fingerprint: 59:53:22:65:83:42:01:54:c0:ce:42:b9:5a:7c:f2:90
+# SHA1 Fingerprint: 4c:dd:51:a3:d1:f5:20:32:14:b0:c6:c5:32:23:03:91:c7:46:42:6d
+# SHA256 Fingerprint: 22:a2:c1:f7:bd:ed:70:4c:c1:e7:01:b5:f4:08:c3:10:88:0f:e9:56:b5:de:2a:4a:44:f9:9c:87:3a:25:a7:c8
+-----BEGIN CERTIFICATE-----
+MIIClDCCAhqgAwIBAgIILCmcWxbtBZUwCgYIKoZIzj0EAwIwfzELMAkGA1UEBhMC
+VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T
+U0wgQ29ycG9yYXRpb24xNDAyBgNVBAMMK1NTTC5jb20gRVYgUm9vdCBDZXJ0aWZp
+Y2F0aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNTIzWhcNNDEwMjEyMTgx
+NTIzWjB/MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hv
+dXN0b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjE0MDIGA1UEAwwrU1NMLmNv
+bSBFViBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49
+AgEGBSuBBAAiA2IABKoSR5CYG/vvw0AHgyBO8TCCogbR8pKGYfL2IWjKAMTH6kMA
+VIbc/R/fALhBYlzccBYy3h+Z1MzFB8gIH2EWB1E9fVwHU+M1OIzfzZ/ZLg1Kthku
+WnBaBu2+8KGwytAJKaNjMGEwHQYDVR0OBBYEFFvKXuXe0oGqzagtZFG22XKbl+ZP
+MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUW8pe5d7SgarNqC1kUbbZcpuX
+5k8wDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2gAMGUCMQCK5kCJN+vp1RPZ
+ytRrJPOwPYdGWBrssd9v+1a6cGvHOMzosYxPD/fxZ3YOg9AeUY8CMD32IygmTMZg
+h5Mmm7I1HrrW9zzRHM76JTymGoEVW/MSD2zuZYrJh6j5B+BimoxcSg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
+# Label: "GlobalSign Root CA - R6"
+# Serial: 1417766617973444989252670301619537
+# MD5 Fingerprint: 4f:dd:07:e4:d4:22:64:39:1e:0c:37:42:ea:d1:c6:ae
+# SHA1 Fingerprint: 80:94:64:0e:b5:a7:a1:ca:11:9c:1f:dd:d5:9f:81:02:63:a7:fb:d1
+# SHA256 Fingerprint: 2c:ab:ea:fe:37:d0:6c:a2:2a:ba:73:91:c0:03:3d:25:98:29:52:c4:53:64:73:49:76:3a:3a:b5:ad:6c:cf:69
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIORea7A4Mzw4VlSOb/RVEwDQYJKoZIhvcNAQEMBQAwTDEg
+MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjYxEzARBgNVBAoTCkdsb2Jh
+bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTQxMjEwMDAwMDAwWhcNMzQx
+MjEwMDAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSNjET
+MBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCAiIwDQYJ
+KoZIhvcNAQEBBQADggIPADCCAgoCggIBAJUH6HPKZvnsFMp7PPcNCPG0RQssgrRI
+xutbPK6DuEGSMxSkb3/pKszGsIhrxbaJ0cay/xTOURQh7ErdG1rG1ofuTToVBu1k
+ZguSgMpE3nOUTvOniX9PeGMIyBJQbUJmL025eShNUhqKGoC3GYEOfsSKvGRMIRxD
+aNc9PIrFsmbVkJq3MQbFvuJtMgamHvm566qjuL++gmNQ0PAYid/kD3n16qIfKtJw
+LnvnvJO7bVPiSHyMEAc4/2ayd2F+4OqMPKq0pPbzlUoSB239jLKJz9CgYXfIWHSw
+1CM69106yqLbnQneXUQtkPGBzVeS+n68UARjNN9rkxi+azayOeSsJDa38O+2HBNX
+k7besvjihbdzorg1qkXy4J02oW9UivFyVm4uiMVRQkQVlO6jxTiWm05OWgtH8wY2
+SXcwvHE35absIQh1/OZhFj931dmRl4QKbNQCTXTAFO39OfuD8l4UoQSwC+n+7o/h
+bguyCLNhZglqsQY6ZZZZwPA1/cnaKI0aEYdwgQqomnUdnjqGBQCe24DWJfncBZ4n
+WUx2OVvq+aWh2IMP0f/fMBH5hc8zSPXKbWQULHpYT9NLCEnFlWQaYw55PfWzjMpY
+rZxCRXluDocZXFSxZba/jJvcE+kNb7gu3GduyYsRtYQUigAZcIN5kZeR1Bonvzce
+MgfYFGM8KEyvAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTAD
+AQH/MB0GA1UdDgQWBBSubAWjkxPioufi1xzWx/B/yGdToDAfBgNVHSMEGDAWgBSu
+bAWjkxPioufi1xzWx/B/yGdToDANBgkqhkiG9w0BAQwFAAOCAgEAgyXt6NH9lVLN
+nsAEoJFp5lzQhN7craJP6Ed41mWYqVuoPId8AorRbrcWc+ZfwFSY1XS+wc3iEZGt
+Ixg93eFyRJa0lV7Ae46ZeBZDE1ZXs6KzO7V33EByrKPrmzU+sQghoefEQzd5Mr61
+55wsTLxDKZmOMNOsIeDjHfrYBzN2VAAiKrlNIC5waNrlU/yDXNOd8v9EDERm8tLj
+vUYAGm0CuiVdjaExUd1URhxN25mW7xocBFymFe944Hn+Xds+qkxV/ZoVqW/hpvvf
+cDDpw+5CRu3CkwWJ+n1jez/QcYF8AOiYrg54NMMl+68KnyBr3TsTjxKM4kEaSHpz
+oHdpx7Zcf4LIHv5YGygrqGytXm3ABdJ7t+uA/iU3/gKbaKxCXcPu9czc8FB10jZp
+nOZ7BN9uBmm23goJSFmH63sUYHpkqmlD75HHTOwY3WzvUy2MmeFe8nI+z1TIvWfs
+pA9MRf/TuTAjB0yPEL+GltmZWrSZVxykzLsViVO6LAUP5MSeGbEYNNVMnbrt9x+v
+JJUEeKgDu+6B5dpffItKoZB0JaezPkvILFa9x8jvOOJckvB595yEunQtYQEgfn7R
+8k8HWV+LLUNS60YMlOH1Zkd5d9VUWx+tJDfLRVpOoERIyNiwmcUVhAn21klJwGW4
+5hpxbqCo8YLoRT5s1gLXCmeDBVrJpBA=
+-----END CERTIFICATE-----
+
+# Issuer: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
+# Subject: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
+# Label: "OISTE WISeKey Global Root GC CA"
+# Serial: 44084345621038548146064804565436152554
+# MD5 Fingerprint: a9:d6:b9:2d:2f:93:64:f8:a5:69:ca:91:e9:68:07:23
+# SHA1 Fingerprint: e0:11:84:5e:34:de:be:88:81:b9:9c:f6:16:26:d1:96:1f:c3:b9:31
+# SHA256 Fingerprint: 85:60:f9:1c:36:24:da:ba:95:70:b5:fe:a0:db:e3:6f:f1:1a:83:23:be:94:86:85:4f:b3:f3:4a:55:71:19:8d
+-----BEGIN CERTIFICATE-----
+MIICaTCCAe+gAwIBAgIQISpWDK7aDKtARb8roi066jAKBggqhkjOPQQDAzBtMQsw
+CQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUgRm91
+bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwg
+Um9vdCBHQyBDQTAeFw0xNzA1MDkwOTQ4MzRaFw00MjA1MDkwOTU4MzNaMG0xCzAJ
+BgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBGb3Vu
+ZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2JhbCBS
+b290IEdDIENBMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAETOlQwMYPchi82PG6s4ni
+eUqjFqdrVCTbUf/q9Akkwwsin8tqJ4KBDdLArzHkdIJuyiXZjHWd8dvQmqJLIX4W
+p2OQ0jnUsYd4XxiWD1AbNTcPasbc2RNNpI6QN+a9WzGRo1QwUjAOBgNVHQ8BAf8E
+BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSIcUrOPDnpBgOtfKie7T
+rYy0UGYwEAYJKwYBBAGCNxUBBAMCAQAwCgYIKoZIzj0EAwMDaAAwZQIwJsdpW9zV
+57LnyAyMjMPdeYwbY9XJUpROTYJKcx6ygISpJcBMWm1JKWB4E+J+SOtkAjEA2zQg
+Mgj/mkkCtojeFK9dbJlxjRo/i9fgojaGHAeCOnZT/cKi7e97sIBPWA9LUzm9
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R1 O=Google Trust Services LLC
+# Subject: CN=GTS Root R1 O=Google Trust Services LLC
+# Label: "GTS Root R1"
+# Serial: 146587175971765017618439757810265552097
+# MD5 Fingerprint: 82:1a:ef:d4:d2:4a:f2:9f:e2:3d:97:06:14:70:72:85
+# SHA1 Fingerprint: e1:c9:50:e6:ef:22:f8:4c:56:45:72:8b:92:20:60:d7:d5:a7:a3:e8
+# SHA256 Fingerprint: 2a:57:54:71:e3:13:40:bc:21:58:1c:bd:2c:f1:3e:15:84:63:20:3e:ce:94:bc:f9:d3:cc:19:6b:f0:9a:54:72
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgIQbkepxUtHDA3sM9CJuRz04TANBgkqhkiG9w0BAQwFADBH
+MQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM
+QzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIy
+MDAwMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNl
+cnZpY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQC2EQKLHuOhd5s73L+UPreVp0A8of2C+X0yBoJx9vaM
+f/vo27xqLpeXo4xL+Sv2sfnOhB2x+cWX3u+58qPpvBKJXqeqUqv4IyfLpLGcY9vX
+mX7wCl7raKb0xlpHDU0QM+NOsROjyBhsS+z8CZDfnWQpJSMHobTSPS5g4M/SCYe7
+zUjwTcLCeoiKu7rPWRnWr4+wB7CeMfGCwcDfLqZtbBkOtdh+JhpFAz2weaSUKK0P
+fyblqAj+lug8aJRT7oM6iCsVlgmy4HqMLnXWnOunVmSPlk9orj2XwoSPwLxAwAtc
+vfaHszVsrBhQf4TgTM2S0yDpM7xSma8ytSmzJSq0SPly4cpk9+aCEI3oncKKiPo4
+Zor8Y/kB+Xj9e1x3+naH+uzfsQ55lVe0vSbv1gHR6xYKu44LtcXFilWr06zqkUsp
+zBmkMiVOKvFlRNACzqrOSbTqn3yDsEB750Orp2yjj32JgfpMpf/VjsPOS+C12LOO
+Rc92wO1AK/1TD7Cn1TsNsYqiA94xrcx36m97PtbfkSIS5r762DL8EGMUUXLeXdYW
+k70paDPvOmbsB4om3xPXV2V4J95eSRQAogB/mqghtqmxlbCluQ0WEdrHbEg8QOB+
+DVrNVjzRlwW5y0vtOUucxD/SVRNuJLDWcfr0wbrM7Rv1/oFB2ACYPTrIrnqYNxgF
+lQIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQU5K8rJnEaK0gnhS9SZizv8IkTcT4wDQYJKoZIhvcNAQEMBQADggIBADiW
+Cu49tJYeX++dnAsznyvgyv3SjgofQXSlfKqE1OXyHuY3UjKcC9FhHb8owbZEKTV1
+d5iyfNm9dKyKaOOpMQkpAWBz40d8U6iQSifvS9efk+eCNs6aaAyC58/UEBZvXw6Z
+XPYfcX3v73svfuo21pdwCxXu11xWajOl40k4DLh9+42FpLFZXvRq4d2h9mREruZR
+gyFmxhE+885H7pwoHyXa/6xmld01D1zvICxi/ZG6qcz8WpyTgYMpl0p8WnK0OdC3
+d8t5/Wk6kjftbjhlRn7pYL15iJdfOBL07q9bgsiG1eGZbYwE8na6SfZu6W0eX6Dv
+J4J2QPim01hcDyxC2kLGe4g0x8HYRZvBPsVhHdljUEn2NIVq4BjFbkerQUIpm/Zg
+DdIx02OYI5NaAIFItO/Nis3Jz5nu2Z6qNuFoS3FJFDYoOj0dzpqPJeaAcWErtXvM
++SUWgeExX6GjfhaknBZqlxi9dnKlC54dNuYvoS++cJEPqOba+MSSQGwlfnuzCdyy
+F62ARPBopY+Udf90WuioAnwMCeKpSwughQtiue+hMZL77/ZRBIls6Kl0obsXs7X9
+SQ98POyDGCBDTtWTurQ0sR8WNh8M5mQ5Fkzc4P4dyKliPUDqysU0ArSuiYgzNdws
+E3PYJ/HQcu51OyLemGhmW/HGY0dVHLqlCFF1pkgl
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R2 O=Google Trust Services LLC
+# Subject: CN=GTS Root R2 O=Google Trust Services LLC
+# Label: "GTS Root R2"
+# Serial: 146587176055767053814479386953112547951
+# MD5 Fingerprint: 44:ed:9a:0e:a4:09:3b:00:f2:ae:4c:a3:c6:61:b0:8b
+# SHA1 Fingerprint: d2:73:96:2a:2a:5e:39:9f:73:3f:e1:c7:1e:64:3f:03:38:34:fc:4d
+# SHA256 Fingerprint: c4:5d:7b:b0:8e:6d:67:e6:2e:42:35:11:0b:56:4e:5f:78:fd:92:ef:05:8c:84:0a:ea:4e:64:55:d7:58:5c:60
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgIQbkepxlqz5yDFMJo/aFLybzANBgkqhkiG9w0BAQwFADBH
+MQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM
+QzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIy
+MDAwMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNl
+cnZpY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQDO3v2m++zsFDQ8BwZabFn3GTXd98GdVarTzTukk3Lv
+CvptnfbwhYBboUhSnznFt+4orO/LdmgUud+tAWyZH8QiHZ/+cnfgLFuv5AS/T3Kg
+GjSY6Dlo7JUle3ah5mm5hRm9iYz+re026nO8/4Piy33B0s5Ks40FnotJk9/BW9Bu
+XvAuMC6C/Pq8tBcKSOWIm8Wba96wyrQD8Nr0kLhlZPdcTK3ofmZemde4wj7I0BOd
+re7kRXuJVfeKH2JShBKzwkCX44ofR5GmdFrS+LFjKBC4swm4VndAoiaYecb+3yXu
+PuWgf9RhD1FLPD+M2uFwdNjCaKH5wQzpoeJ/u1U8dgbuak7MkogwTZq9TwtImoS1
+mKPV+3PBV2HdKFZ1E66HjucMUQkQdYhMvI35ezzUIkgfKtzra7tEscszcTJGr61K
+8YzodDqs5xoic4DSMPclQsciOzsSrZYuxsN2B6ogtzVJV+mSSeh2FnIxZyuWfoqj
+x5RWIr9qS34BIbIjMt/kmkRtWVtd9QCgHJvGeJeNkP+byKq0rxFROV7Z+2et1VsR
+nTKaG73VululycslaVNVJ1zgyjbLiGH7HrfQy+4W+9OmTN6SpdTi3/UGVN4unUu0
+kzCqgc7dGtxRcw1PcOnlthYhGXmy5okLdWTK1au8CcEYof/UVKGFPP0UJAOyh9Ok
+twIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQUu//KjiOfT5nK2+JopqUVJxce2Q4wDQYJKoZIhvcNAQEMBQADggIBALZp
+8KZ3/p7uC4Gt4cCpx/k1HUCCq+YEtN/L9x0Pg/B+E02NjO7jMyLDOfxA325BS0JT
+vhaI8dI4XsRomRyYUpOM52jtG2pzegVATX9lO9ZY8c6DR2Dj/5epnGB3GFW1fgiT
+z9D2PGcDFWEJ+YF59exTpJ/JjwGLc8R3dtyDovUMSRqodt6Sm2T4syzFJ9MHwAiA
+pJiS4wGWAqoC7o87xdFtCjMwc3i5T1QWvwsHoaRc5svJXISPD+AVdyx+Jn7axEvb
+pxZ3B7DNdehyQtaVhJ2Gg/LkkM0JR9SLA3DaWsYDQvTtN6LwG1BUSw7YhN4ZKJmB
+R64JGz9I0cNv4rBgF/XuIwKl2gBbbZCr7qLpGzvpx0QnRY5rn/WkhLx3+WuXrD5R
+RaIRpsyF7gpo8j5QOHokYh4XIDdtak23CZvJ/KRY9bb7nE4Yu5UC56GtmwfuNmsk
+0jmGwZODUNKBRqhfYlcsu2xkiAhu7xNUX90txGdj08+JN7+dIPT7eoOboB6BAFDC
+5AwiWVIQ7UNWhwD4FFKnHYuTjKJNRn8nxnGbJN7k2oaLDX5rIMHAnuFl2GqjpuiF
+izoHCBy69Y9Vmhh1fuXsgWbRIXOhNUQLgD1bnF5vKheW0YMjiGZt5obicDIvUiLn
+yOd/xCxgXS/Dr55FBcOEArf9LAhST4Ldo/DUhgkC
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R3 O=Google Trust Services LLC
+# Subject: CN=GTS Root R3 O=Google Trust Services LLC
+# Label: "GTS Root R3"
+# Serial: 146587176140553309517047991083707763997
+# MD5 Fingerprint: 1a:79:5b:6b:04:52:9c:5d:c7:74:33:1b:25:9a:f9:25
+# SHA1 Fingerprint: 30:d4:24:6f:07:ff:db:91:89:8a:0b:e9:49:66:11:eb:8c:5e:46:e5
+# SHA256 Fingerprint: 15:d5:b8:77:46:19:ea:7d:54:ce:1c:a6:d0:b0:c4:03:e0:37:a9:17:f1:31:e8:a0:4e:1e:6b:7a:71:ba:bc:e5
+-----BEGIN CERTIFICATE-----
+MIICDDCCAZGgAwIBAgIQbkepx2ypcyRAiQ8DVd2NHTAKBggqhkjOPQQDAzBHMQsw
+CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
+MBIGA1UEAxMLR1RTIFJvb3QgUjMwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
+MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
+Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjMwdjAQBgcqhkjOPQIBBgUrgQQA
+IgNiAAQfTzOHMymKoYTey8chWEGJ6ladK0uFxh1MJ7x/JlFyb+Kf1qPKzEUURout
+736GjOyxfi//qXGdGIRFBEFVbivqJn+7kAHjSxm65FSWRQmx1WyRRK2EE46ajA2A
+DDL24CejQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
+DgQWBBTB8Sa6oC2uhYHP0/EqEr24Cmf9vDAKBggqhkjOPQQDAwNpADBmAjEAgFuk
+fCPAlaUs3L6JbyO5o91lAFJekazInXJ0glMLfalAvWhgxeG4VDvBNhcl2MG9AjEA
+njWSdIUlUfUk7GRSJFClH9voy8l27OyCbvWFGFPouOOaKaqW04MjyaR7YbPMAuhd
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R4 O=Google Trust Services LLC
+# Subject: CN=GTS Root R4 O=Google Trust Services LLC
+# Label: "GTS Root R4"
+# Serial: 146587176229350439916519468929765261721
+# MD5 Fingerprint: 5d:b6:6a:c4:60:17:24:6a:1a:99:a8:4b:ee:5e:b4:26
+# SHA1 Fingerprint: 2a:1d:60:27:d9:4a:b1:0a:1c:4d:91:5c:cd:33:a0:cb:3e:2d:54:cb
+# SHA256 Fingerprint: 71:cc:a5:39:1f:9e:79:4b:04:80:25:30:b3:63:e1:21:da:8a:30:43:bb:26:66:2f:ea:4d:ca:7f:c9:51:a4:bd
+-----BEGIN CERTIFICATE-----
+MIICCjCCAZGgAwIBAgIQbkepyIuUtui7OyrYorLBmTAKBggqhkjOPQQDAzBHMQsw
+CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
+MBIGA1UEAxMLR1RTIFJvb3QgUjQwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
+MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
+Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjQwdjAQBgcqhkjOPQIBBgUrgQQA
+IgNiAATzdHOnaItgrkO4NcWBMHtLSZ37wWHO5t5GvWvVYRg1rkDdc/eJkTBa6zzu
+hXyiQHY7qca4R9gq55KRanPpsXI5nymfopjTX15YhmUPoYRlBtHci8nHc8iMai/l
+xKvRHYqjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
+DgQWBBSATNbrdP9JNqPV2Py1PsVq8JQdjDAKBggqhkjOPQQDAwNnADBkAjBqUFJ0
+CMRw3J5QdCHojXohw0+WbhXRIjVhLfoIN+4Zba3bssx9BzT1YBkstTTZbyACMANx
+sbqjYAuG7ZoIapVon+Kz4ZNkfF6Tpt95LY2F45TPI11xzPKwTdb+mciUqXWi4w==
+-----END CERTIFICATE-----
+
+# Issuer: CN=UCA Global G2 Root O=UniTrust
+# Subject: CN=UCA Global G2 Root O=UniTrust
+# Label: "UCA Global G2 Root"
+# Serial: 124779693093741543919145257850076631279
+# MD5 Fingerprint: 80:fe:f0:c4:4a:f0:5c:62:32:9f:1c:ba:78:a9:50:f8
+# SHA1 Fingerprint: 28:f9:78:16:19:7a:ff:18:25:18:aa:44:fe:c1:a0:ce:5c:b6:4c:8a
+# SHA256 Fingerprint: 9b:ea:11:c9:76:fe:01:47:64:c1:be:56:a6:f9:14:b5:a5:60:31:7a:bd:99:88:39:33:82:e5:16:1a:a0:49:3c
+-----BEGIN CERTIFICATE-----
+MIIFRjCCAy6gAwIBAgIQXd+x2lqj7V2+WmUgZQOQ7zANBgkqhkiG9w0BAQsFADA9
+MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxGzAZBgNVBAMMElVDQSBH
+bG9iYWwgRzIgUm9vdDAeFw0xNjAzMTEwMDAwMDBaFw00MDEyMzEwMDAwMDBaMD0x
+CzAJBgNVBAYTAkNOMREwDwYDVQQKDAhVbmlUcnVzdDEbMBkGA1UEAwwSVUNBIEds
+b2JhbCBHMiBSb290MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxeYr
+b3zvJgUno4Ek2m/LAfmZmqkywiKHYUGRO8vDaBsGxUypK8FnFyIdK+35KYmToni9
+kmugow2ifsqTs6bRjDXVdfkX9s9FxeV67HeToI8jrg4aA3++1NDtLnurRiNb/yzm
+VHqUwCoV8MmNsHo7JOHXaOIxPAYzRrZUEaalLyJUKlgNAQLx+hVRZ2zA+te2G3/R
+VogvGjqNO7uCEeBHANBSh6v7hn4PJGtAnTRnvI3HLYZveT6OqTwXS3+wmeOwcWDc
+C/Vkw85DvG1xudLeJ1uK6NjGruFZfc8oLTW4lVYa8bJYS7cSN8h8s+1LgOGN+jIj
+tm+3SJUIsUROhYw6AlQgL9+/V087OpAh18EmNVQg7Mc/R+zvWr9LesGtOxdQXGLY
+D0tK3Cv6brxzks3sx1DoQZbXqX5t2Okdj4q1uViSukqSKwxW/YDrCPBeKW4bHAyv
+j5OJrdu9o54hyokZ7N+1wxrrFv54NkzWbtA+FxyQF2smuvt6L78RHBgOLXMDj6Dl
+NaBa4kx1HXHhOThTeEDMg5PXCp6dW4+K5OXgSORIskfNTip1KnvyIvbJvgmRlld6
+iIis7nCs+dwp4wwcOxJORNanTrAmyPPZGpeRaOrvjUYG0lZFWJo8DA+DuAUlwznP
+O6Q0ibd5Ei9Hxeepl2n8pndntd978XplFeRhVmUCAwEAAaNCMEAwDgYDVR0PAQH/
+BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFIHEjMz15DD/pQwIX4wV
+ZyF0Ad/fMA0GCSqGSIb3DQEBCwUAA4ICAQATZSL1jiutROTL/7lo5sOASD0Ee/oj
+L3rtNtqyzm325p7lX1iPyzcyochltq44PTUbPrw7tgTQvPlJ9Zv3hcU2tsu8+Mg5
+1eRfB70VVJd0ysrtT7q6ZHafgbiERUlMjW+i67HM0cOU2kTC5uLqGOiiHycFutfl
+1qnN3e92mI0ADs0b+gO3joBYDic/UvuUospeZcnWhNq5NXHzJsBPd+aBJ9J3O5oU
+b3n09tDh05S60FdRvScFDcH9yBIw7m+NESsIndTUv4BFFJqIRNow6rSn4+7vW4LV
+PtateJLbXDzz2K36uGt/xDYotgIVilQsnLAXc47QN6MUPJiVAAwpBVueSUmxX8fj
+y88nZY41F7dXyDDZQVu5FLbowg+UMaeUmMxq67XhJ/UQqAHojhJi6IjMtX9Gl8Cb
+EGY4GjZGXyJoPd/JxhMnq1MGrKI8hgZlb7F+sSlEmqO6SWkoaY/X5V+tBIZkbxqg
+DMUIYs6Ao9Dz7GjevjPHF1t/gMRMTLGmhIrDO7gJzRSBuhjjVFc2/tsvfEehOjPI
++Vg7RE+xygKJBJYoaMVLuCaJu9YzL1DV/pqJuhgyklTGW+Cd+V7lDSKb9triyCGy
+YiGqhkCyLmTTX8jjfhFnRR8F/uOi77Oos/N9j/gMHyIfLXC0uAE0djAA5SN4p1bX
+UB+K+wb1whnw0A==
+-----END CERTIFICATE-----
+
+# Issuer: CN=UCA Extended Validation Root O=UniTrust
+# Subject: CN=UCA Extended Validation Root O=UniTrust
+# Label: "UCA Extended Validation Root"
+# Serial: 106100277556486529736699587978573607008
+# MD5 Fingerprint: a1:f3:5f:43:c6:34:9b:da:bf:8c:7e:05:53:ad:96:e2
+# SHA1 Fingerprint: a3:a1:b0:6f:24:61:23:4a:e3:36:a5:c2:37:fc:a6:ff:dd:f0:d7:3a
+# SHA256 Fingerprint: d4:3a:f9:b3:54:73:75:5c:96:84:fc:06:d7:d8:cb:70:ee:5c:28:e7:73:fb:29:4e:b4:1e:e7:17:22:92:4d:24
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgIQT9Irj/VkyDOeTzRYZiNwYDANBgkqhkiG9w0BAQsFADBH
+MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNVBAMMHFVDQSBF
+eHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwHhcNMTUwMzEzMDAwMDAwWhcNMzgxMjMx
+MDAwMDAwWjBHMQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNV
+BAMMHFVDQSBFeHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCpCQcoEwKwmeBkqh5DFnpzsZGgdT6o+uM4AHrsiWog
+D4vFsJszA1qGxliG1cGFu0/GnEBNyr7uaZa4rYEwmnySBesFK5pI0Lh2PpbIILvS
+sPGP2KxFRv+qZ2C0d35qHzwaUnoEPQc8hQ2E0B92CvdqFN9y4zR8V05WAT558aop
+O2z6+I9tTcg1367r3CTueUWnhbYFiN6IXSV8l2RnCdm/WhUFhvMJHuxYMjMR83dk
+sHYf5BA1FxvyDrFspCqjc/wJHx4yGVMR59mzLC52LqGj3n5qiAno8geK+LLNEOfi
+c0CTuwjRP+H8C5SzJe98ptfRr5//lpr1kXuYC3fUfugH0mK1lTnj8/FtDw5lhIpj
+VMWAtuCeS31HJqcBCF3RiJ7XwzJE+oJKCmhUfzhTA8ykADNkUVkLo4KRel7sFsLz
+KuZi2irbWWIQJUoqgQtHB0MGcIfS+pMRKXpITeuUx3BNr2fVUbGAIAEBtHoIppB/
+TuDvB0GHr2qlXov7z1CymlSvw4m6WC31MJixNnI5fkkE/SmnTHnkBVfblLkWU41G
+sx2VYVdWf6/wFlthWG82UBEL2KwrlRYaDh8IzTY0ZRBiZtWAXxQgXy0MoHgKaNYs
+1+lvK9JKBZP8nm9rZ/+I8U6laUpSNwXqxhaN0sSZ0YIrO7o1dfdRUVjzyAfd5LQD
+fwIDAQABo0IwQDAdBgNVHQ4EFgQU2XQ65DA9DfcS3H5aBZ8eNJr34RQwDwYDVR0T
+AQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQADggIBADaN
+l8xCFWQpN5smLNb7rhVpLGsaGvdftvkHTFnq88nIua7Mui563MD1sC3AO6+fcAUR
+ap8lTwEpcOPlDOHqWnzcSbvBHiqB9RZLcpHIojG5qtr8nR/zXUACE/xOHAbKsxSQ
+VBcZEhrxH9cMaVr2cXj0lH2RC47skFSOvG+hTKv8dGT9cZr4QQehzZHkPJrgmzI5
+c6sq1WnIeJEmMX3ixzDx/BR4dxIOE/TdFpS/S2d7cFOFyrC78zhNLJA5wA3CXWvp
+4uXViI3WLL+rG761KIcSF3Ru/H38j9CHJrAb+7lsq+KePRXBOy5nAliRn+/4Qh8s
+t2j1da3Ptfb/EX3C8CSlrdP6oDyp+l3cpaDvRKS+1ujl5BOWF3sGPjLtx7dCvHaj
+2GU4Kzg1USEODm8uNBNA4StnDG1KQTAYI1oyVZnJF+A83vbsea0rWBmirSwiGpWO
+vpaQXUJXxPkUAzUrHC1RVwinOt4/5Mi0A3PCwSaAuwtCH60NryZy2sy+s6ODWA2C
+xR9GUeOcGMyNm43sSet1UNWMKFnKdDTajAshqx7qG+XH/RU+wBeq+yNuJkbL+vmx
+cmtpzyKEC2IPrNkZAJSidjzULZrtBJ4tBmIQN1IchXIbJ+XMxjHsN+xjWZsLHXbM
+fjKaiJUINlK73nZfdklJrX+9ZSCyycErdhh2n1ax
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
+# Subject: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
+# Label: "Certigna Root CA"
+# Serial: 269714418870597844693661054334862075617
+# MD5 Fingerprint: 0e:5c:30:62:27:eb:5b:bc:d7:ae:62:ba:e9:d5:df:77
+# SHA1 Fingerprint: 2d:0d:52:14:ff:9e:ad:99:24:01:74:20:47:6e:6c:85:27:27:f5:43
+# SHA256 Fingerprint: d4:8d:3d:23:ee:db:50:a4:59:e5:51:97:60:1c:27:77:4b:9d:7b:18:c9:4d:5a:05:95:11:a1:02:50:b9:31:68
+-----BEGIN CERTIFICATE-----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=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
+# Subject: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
+# Label: "emSign Root CA - G1"
+# Serial: 235931866688319308814040
+# MD5 Fingerprint: 9c:42:84:57:dd:cb:0b:a7:2e:95:ad:b6:f3:da:bc:ac
+# SHA1 Fingerprint: 8a:c7:ad:8f:73:ac:4e:c1:b5:75:4d:a5:40:f4:fc:cf:7c:b5:8e:8c
+# SHA256 Fingerprint: 40:f6:af:03:46:a9:9a:a1:cd:1d:55:5a:4e:9c:ce:62:c7:f9:63:46:03:ee:40:66:15:83:3d:c8:c8:d0:03:67
+-----BEGIN CERTIFICATE-----
+MIIDlDCCAnygAwIBAgIKMfXkYgxsWO3W2DANBgkqhkiG9w0BAQsFADBnMQswCQYD
+VQQGEwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBU
+ZWNobm9sb2dpZXMgTGltaXRlZDEcMBoGA1UEAxMTZW1TaWduIFJvb3QgQ0EgLSBH
+MTAeFw0xODAyMTgxODMwMDBaFw00MzAyMTgxODMwMDBaMGcxCzAJBgNVBAYTAklO
+MRMwEQYDVQQLEwplbVNpZ24gUEtJMSUwIwYDVQQKExxlTXVkaHJhIFRlY2hub2xv
+Z2llcyBMaW1pdGVkMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEcxMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAk0u76WaK7p1b1TST0Bsew+eeuGQz
+f2N4aLTNLnF115sgxk0pvLZoYIr3IZpWNVrzdr3YzZr/k1ZLpVkGoZM0Kd0WNHVO
+8oG0x5ZOrRkVUkr+PHB1cM2vK6sVmjM8qrOLqs1D/fXqcP/tzxE7lM5OMhbTI0Aq
+d7OvPAEsbO2ZLIvZTmmYsvePQbAyeGHWDV/D+qJAkh1cF+ZwPjXnorfCYuKrpDhM
+tTk1b+oDafo6VGiFbdbyL0NVHpENDtjVaqSW0RM8LHhQ6DqS0hdW5TUaQBw+jSzt
+Od9C4INBdN+jzcKGYEho42kLVACL5HZpIQ15TjQIXhTCzLG3rdd8cIrHhQIDAQAB
+o0IwQDAdBgNVHQ4EFgQU++8Nhp6w492pufEhF38+/PB3KxowDgYDVR0PAQH/BAQD
+AgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAFn/8oz1h31x
+PaOfG1vR2vjTnGs2vZupYeveFix0PZ7mddrXuqe8QhfnPZHr5X3dPpzxz5KsbEjM
+wiI/aTvFthUvozXGaCocV685743QNcMYDHsAVhzNixl03r4PEuDQqqE/AjSxcM6d
+GNYIAwlG7mDgfrbESQRRfXBgvKqy/3lyeqYdPV8q+Mri/Tm3R7nrft8EI6/6nAYH
+6ftjk4BAtcZsCjEozgyfz7MjNYBBjWzEN3uBL4ChQEKF6dk4jeihU80Bv2noWgby
+RQuQ+q7hv53yrlc8pa6yVvSLZUDp/TGBLPQ5Cdjua6e0ph0VpZj3AYHYhX3zUVxx
+iN66zB+Afko=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
+# Subject: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
+# Label: "emSign ECC Root CA - G3"
+# Serial: 287880440101571086945156
+# MD5 Fingerprint: ce:0b:72:d1:9f:88:8e:d0:50:03:e8:e3:b8:8b:67:40
+# SHA1 Fingerprint: 30:43:fa:4f:f2:57:dc:a0:c3:80:ee:2e:58:ea:78:b2:3f:e6:bb:c1
+# SHA256 Fingerprint: 86:a1:ec:ba:08:9c:4a:8d:3b:be:27:34:c6:12:ba:34:1d:81:3e:04:3c:f9:e8:a8:62:cd:5c:57:a3:6b:be:6b
+-----BEGIN CERTIFICATE-----
+MIICTjCCAdOgAwIBAgIKPPYHqWhwDtqLhDAKBggqhkjOPQQDAzBrMQswCQYDVQQG
+EwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNo
+bm9sb2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0g
+RzMwHhcNMTgwMjE4MTgzMDAwWhcNNDMwMjE4MTgzMDAwWjBrMQswCQYDVQQGEwJJ
+TjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNobm9s
+b2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0gRzMw
+djAQBgcqhkjOPQIBBgUrgQQAIgNiAAQjpQy4LRL1KPOxst3iAhKAnjlfSU2fySU0
+WXTsuwYc58Byr+iuL+FBVIcUqEqy6HyC5ltqtdyzdc6LBtCGI79G1Y4PPwT01xyS
+fvalY8L1X44uT6EYGQIrMgqCZH0Wk9GjQjBAMB0GA1UdDgQWBBR8XQKEE9TMipuB
+zhccLikenEhjQjAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAKBggq
+hkjOPQQDAwNpADBmAjEAvvNhzwIQHWSVB7gYboiFBS+DCBeQyh+KTOgNG3qxrdWB
+CUfvO6wIBHxcmbHtRwfSAjEAnbpV/KlK6O3t5nYBQnvI+GDZjVGLVTv7jHvrZQnD
++JbNR6iC8hZVdyR+EhCVBCyj
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
+# Subject: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
+# Label: "emSign Root CA - C1"
+# Serial: 825510296613316004955058
+# MD5 Fingerprint: d8:e3:5d:01:21:fa:78:5a:b0:df:ba:d2:ee:2a:5f:68
+# SHA1 Fingerprint: e7:2e:f1:df:fc:b2:09:28:cf:5d:d4:d5:67:37:b1:51:cb:86:4f:01
+# SHA256 Fingerprint: 12:56:09:aa:30:1d:a0:a2:49:b9:7a:82:39:cb:6a:34:21:6f:44:dc:ac:9f:39:54:b1:42:92:f2:e8:c8:60:8f
+-----BEGIN CERTIFICATE-----
+MIIDczCCAlugAwIBAgILAK7PALrEzzL4Q7IwDQYJKoZIhvcNAQELBQAwVjELMAkG
+A1UEBhMCVVMxEzARBgNVBAsTCmVtU2lnbiBQS0kxFDASBgNVBAoTC2VNdWRocmEg
+SW5jMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEMxMB4XDTE4MDIxODE4MzAw
+MFoXDTQzMDIxODE4MzAwMFowVjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
+biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMRwwGgYDVQQDExNlbVNpZ24gUm9v
+dCBDQSAtIEMxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz+upufGZ
+BczYKCFK83M0UYRWEPWgTywS4/oTmifQz/l5GnRfHXk5/Fv4cI7gklL35CX5VIPZ
+HdPIWoU/Xse2B+4+wM6ar6xWQio5JXDWv7V7Nq2s9nPczdcdioOl+yuQFTdrHCZH
+3DspVpNqs8FqOp099cGXOFgFixwR4+S0uF2FHYP+eF8LRWgYSKVGczQ7/g/IdrvH
+GPMF0Ybzhe3nudkyrVWIzqa2kbBPrH4VI5b2P/AgNBbeCsbEBEV5f6f9vtKppa+c
+xSMq9zwhbL2vj07FOrLzNBL834AaSaTUqZX3noleoomslMuoaJuvimUnzYnu3Yy1
+aylwQ6BpC+S5DwIDAQABo0IwQDAdBgNVHQ4EFgQU/qHgcB4qAzlSWkK+XJGFehiq
+TbUwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
+BQADggEBAMJKVvoVIXsoounlHfv4LcQ5lkFMOycsxGwYFYDGrK9HWS8mC+M2sO87
+/kOXSTKZEhVb3xEp/6tT+LvBeA+snFOvV71ojD1pM/CjoCNjO2RnIkSt1XHLVip4
+kqNPEjE2NuLe/gDEo2APJ62gsIq1NnpSob0n9CAnYuhNlCQT5AoE6TyrLshDCUrG
+YQTlSTR+08TI9Q/Aqum6VF7zYytPT1DU/rl7mYw9wC68AivTxEDkigcxHpvOJpkT
++xHqmiIMERnHXhuBUDDIlhJu58tBf5E7oke3VIAb3ADMmpDqw8NQBmIMMMAVSKeo
+WXzhriKi4gp6D/piq1JM4fHfyr6DDUI=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
+# Subject: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
+# Label: "emSign ECC Root CA - C3"
+# Serial: 582948710642506000014504
+# MD5 Fingerprint: 3e:53:b3:a3:81:ee:d7:10:f8:d3:b0:1d:17:92:f5:d5
+# SHA1 Fingerprint: b6:af:43:c2:9b:81:53:7d:f6:ef:6b:c3:1f:1f:60:15:0c:ee:48:66
+# SHA256 Fingerprint: bc:4d:80:9b:15:18:9d:78:db:3e:1d:8c:f4:f9:72:6a:79:5d:a1:64:3c:a5:f1:35:8e:1d:db:0e:dc:0d:7e:b3
+-----BEGIN CERTIFICATE-----
+MIICKzCCAbGgAwIBAgIKe3G2gla4EnycqDAKBggqhkjOPQQDAzBaMQswCQYDVQQG
+EwJVUzETMBEGA1UECxMKZW1TaWduIFBLSTEUMBIGA1UEChMLZU11ZGhyYSBJbmMx
+IDAeBgNVBAMTF2VtU2lnbiBFQ0MgUm9vdCBDQSAtIEMzMB4XDTE4MDIxODE4MzAw
+MFoXDTQzMDIxODE4MzAwMFowWjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
+biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMSAwHgYDVQQDExdlbVNpZ24gRUND
+IFJvb3QgQ0EgLSBDMzB2MBAGByqGSM49AgEGBSuBBAAiA2IABP2lYa57JhAd6bci
+MK4G9IGzsUJxlTm801Ljr6/58pc1kjZGDoeVjbk5Wum739D+yAdBPLtVb4Ojavti
+sIGJAnB9SMVK4+kiVCJNk7tCDK93nCOmfddhEc5lx/h//vXyqaNCMEAwHQYDVR0O
+BBYEFPtaSNCAIEDyqOkAB2kZd6fmw/TPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMB
+Af8EBTADAQH/MAoGCCqGSM49BAMDA2gAMGUCMQC02C8Cif22TGK6Q04ThHK1rt0c
+3ta13FaPWEBaLd4gTCKDypOofu4SQMfWh0/434UCMBwUZOR8loMRnLDRWmFLpg9J
+0wD8ofzkpf9/rdcw0Md3f76BB1UwUCAU9Vc4CqgxUQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Hongkong Post Root CA 3 O=Hongkong Post
+# Subject: CN=Hongkong Post Root CA 3 O=Hongkong Post
+# Label: "Hongkong Post Root CA 3"
+# Serial: 46170865288971385588281144162979347873371282084
+# MD5 Fingerprint: 11:fc:9f:bd:73:30:02:8a:fd:3f:f3:58:b9:cb:20:f0
+# SHA1 Fingerprint: 58:a2:d0:ec:20:52:81:5b:c1:f3:f8:64:02:24:4e:c2:8e:02:4b:02
+# SHA256 Fingerprint: 5a:2f:c0:3f:0c:83:b0:90:bb:fa:40:60:4b:09:88:44:6c:76:36:18:3d:f9:84:6e:17:10:1a:44:7f:b8:ef:d6
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - G4"
+# Serial: 289383649854506086828220374796556676440
+# MD5 Fingerprint: 89:53:f1:83:23:b7:7c:8e:05:f1:8c:71:38:4e:1f:88
+# SHA1 Fingerprint: 14:88:4e:86:26:37:b0:26:af:59:62:5c:40:77:ec:35:29:ba:96:01
+# SHA256 Fingerprint: db:35:17:d1:f6:73:2a:2d:5a:b9:7c:53:3e:c7:07:79:ee:32:70:a6:2f:b4:ac:42:38:37:24:60:e6:f0:1e:88
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
+# Subject: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
+# Label: "Microsoft ECC Root Certificate Authority 2017"
+# Serial: 136839042543790627607696632466672567020
+# MD5 Fingerprint: dd:a1:03:e6:4a:93:10:d1:bf:f0:19:42:cb:fe:ed:67
+# SHA1 Fingerprint: 99:9a:64:c3:7f:f4:7d:9f:ab:95:f1:47:69:89:14:60:ee:c4:c3:c5
+# SHA256 Fingerprint: 35:8d:f3:9d:76:4a:f9:e1:b7:66:e9:c9:72:df:35:2e:e1:5c:fa:c2:27:af:6a:d1:d7:0e:8e:4a:6e:dc:ba:02
+-----BEGIN CERTIFICATE-----
+MIICWTCCAd+gAwIBAgIQZvI9r4fei7FK6gxXMQHC7DAKBggqhkjOPQQDAzBlMQsw
+CQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYD
+VQQDEy1NaWNyb3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIw
+MTcwHhcNMTkxMjE4MjMwNjQ1WhcNNDIwNzE4MjMxNjA0WjBlMQswCQYDVQQGEwJV
+UzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1NaWNy
+b3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwdjAQBgcq
+hkjOPQIBBgUrgQQAIgNiAATUvD0CQnVBEyPNgASGAlEvaqiBYgtlzPbKnR5vSmZR
+ogPZnZH6thaxjG7efM3beaYvzrvOcS/lpaso7GMEZpn4+vKTEAXhgShC48Zo9OYb
+hGBKia/teQ87zvH2RPUBeMCjVDBSMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBTIy5lycFIM+Oa+sgRXKSrPQhDtNTAQBgkrBgEEAYI3
+FQEEAwIBADAKBggqhkjOPQQDAwNoADBlAjBY8k3qDPlfXu5gKcs68tvWMoQZP3zV
+L8KxzJOuULsJMsbG7X7JNpQS5GiFBqIb0C8CMQCZ6Ra0DvpWSNSkMBaReNtUjGUB
+iudQZsIxtzm6uBoiB078a1QWIP8rtedMDE2mT3M=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
+# Subject: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
+# Label: "Microsoft RSA Root Certificate Authority 2017"
+# Serial: 40975477897264996090493496164228220339
+# MD5 Fingerprint: 10:ff:00:ff:cf:c9:f8:c7:7a:c0:ee:35:8e:c9:0f:47
+# SHA1 Fingerprint: 73:a5:e6:4a:3b:ff:83:16:ff:0e:dc:cc:61:8a:90:6e:4e:ae:4d:74
+# SHA256 Fingerprint: c7:41:f7:0f:4b:2a:8d:88:bf:2e:71:c1:41:22:ef:53:ef:10:eb:a0:cf:a5:e6:4c:fa:20:f4:18:85:30:73:e0
+-----BEGIN CERTIFICATE-----
+MIIFqDCCA5CgAwIBAgIQHtOXCV/YtLNHcB6qvn9FszANBgkqhkiG9w0BAQwFADBl
+MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYw
+NAYDVQQDEy1NaWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5
+IDIwMTcwHhcNMTkxMjE4MjI1MTIyWhcNNDIwNzE4MjMwMDIzWjBlMQswCQYDVQQG
+EwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1N
+aWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKW76UM4wplZEWCpW9R2LBifOZ
+Nt9GkMml7Xhqb0eRaPgnZ1AzHaGm++DlQ6OEAlcBXZxIQIJTELy/xztokLaCLeX0
+ZdDMbRnMlfl7rEqUrQ7eS0MdhweSE5CAg2Q1OQT85elss7YfUJQ4ZVBcF0a5toW1
+HLUX6NZFndiyJrDKxHBKrmCk3bPZ7Pw71VdyvD/IybLeS2v4I2wDwAW9lcfNcztm
+gGTjGqwu+UcF8ga2m3P1eDNbx6H7JyqhtJqRjJHTOoI+dkC0zVJhUXAoP8XFWvLJ
+jEm7FFtNyP9nTUwSlq31/niol4fX/V4ggNyhSyL71Imtus5Hl0dVe49FyGcohJUc
+aDDv70ngNXtk55iwlNpNhTs+VcQor1fznhPbRiefHqJeRIOkpcrVE7NLP8TjwuaG
+YaRSMLl6IE9vDzhTyzMMEyuP1pq9KsgtsRx9S1HKR9FIJ3Jdh+vVReZIZZ2vUpC6
+W6IYZVcSn2i51BVrlMRpIpj0M+Dt+VGOQVDJNE92kKz8OMHY4Xu54+OU4UZpyw4K
+UGsTuqwPN1q3ErWQgR5WrlcihtnJ0tHXUeOrO8ZV/R4O03QK0dqq6mm4lyiPSMQH
++FJDOvTKVTUssKZqwJz58oHhEmrARdlns87/I6KJClTUFLkqqNfs+avNJVgyeY+Q
+W5g5xAgGwax/Dj0ApQIDAQABo1QwUjAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/
+BAUwAwEB/zAdBgNVHQ4EFgQUCctZf4aycI8awznjwNnpv7tNsiMwEAYJKwYBBAGC
+NxUBBAMCAQAwDQYJKoZIhvcNAQEMBQADggIBAKyvPl3CEZaJjqPnktaXFbgToqZC
+LgLNFgVZJ8og6Lq46BrsTaiXVq5lQ7GPAJtSzVXNUzltYkyLDVt8LkS/gxCP81OC
+gMNPOsduET/m4xaRhPtthH80dK2Jp86519efhGSSvpWhrQlTM93uCupKUY5vVau6
+tZRGrox/2KJQJWVggEbbMwSubLWYdFQl3JPk+ONVFT24bcMKpBLBaYVu32TxU5nh
+SnUgnZUP5NbcA/FZGOhHibJXWpS2qdgXKxdJ5XbLwVaZOjex/2kskZGT4d9Mozd2
+TaGf+G0eHdP67Pv0RR0Tbc/3WeUiJ3IrhvNXuzDtJE3cfVa7o7P4NHmJweDyAmH3
+pvwPuxwXC65B2Xy9J6P9LjrRk5Sxcx0ki69bIImtt2dmefU6xqaWM/5TkshGsRGR
+xpl/j8nWZjEgQRCHLQzWwa80mMpkg/sTV9HB8Dx6jKXB/ZUhoHHBk2dxEuqPiApp
+GWSZI1b7rCoucL5mxAyE7+WL85MB+GqQk2dLsmijtWKP6T+MejteD+eMuMZ87zf9
+dOLITzNy4ZQ5bb0Sr74MTnB8G2+NszKTc0QWbej09+CVgI+WXTik9KveCjCHk9hN
+AHFiRSdLOkKEW39lt2c0Ui2cFmuqqNh7o0JMcccMyj6D5KbvtwEwXlGjefVwaaZB
+RA+GsCyRxj3qrg+E
+-----END CERTIFICATE-----
+
+# Issuer: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
+# Subject: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
+# Label: "e-Szigno Root CA 2017"
+# Serial: 411379200276854331539784714
+# MD5 Fingerprint: de:1f:f6:9e:84:ae:a7:b4:21:ce:1e:58:7d:d1:84:98
+# SHA1 Fingerprint: 89:d4:83:03:4f:9e:9a:48:80:5f:72:37:d4:a9:a6:ef:cb:7c:1f:d1
+# SHA256 Fingerprint: be:b0:0b:30:83:9b:9b:c3:2c:32:e4:44:79:05:95:06:41:f2:64:21:b1:5e:d0:89:19:8b:51:8a:e2:ea:1b:99
+-----BEGIN CERTIFICATE-----
+MIICQDCCAeWgAwIBAgIMAVRI7yH9l1kN9QQKMAoGCCqGSM49BAMCMHExCzAJBgNV
+BAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRk
+LjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25vIFJv
+b3QgQ0EgMjAxNzAeFw0xNzA4MjIxMjA3MDZaFw00MjA4MjIxMjA3MDZaMHExCzAJ
+BgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMg
+THRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25v
+IFJvb3QgQ0EgMjAxNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJbcPYrYsHtv
+xie+RJCxs1YVe45DJH0ahFnuY2iyxl6H0BVIHqiQrb1TotreOpCmYF9oMrWGQd+H
+Wyx7xf58etqjYzBhMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G
+A1UdDgQWBBSHERUI0arBeAyxr87GyZDvvzAEwDAfBgNVHSMEGDAWgBSHERUI0arB
+eAyxr87GyZDvvzAEwDAKBggqhkjOPQQDAgNJADBGAiEAtVfd14pVCzbhhkT61Nlo
+jbjcI4qKDdQvfepz7L9NbKgCIQDLpbQS+ue16M9+k/zzNY9vTlp8tLxOsvxyqltZ
++efcMQ==
+-----END CERTIFICATE-----
+
+# Issuer: O=CERTSIGN SA OU=certSIGN ROOT CA G2
+# Subject: O=CERTSIGN SA OU=certSIGN ROOT CA G2
+# Label: "certSIGN Root CA G2"
+# Serial: 313609486401300475190
+# MD5 Fingerprint: 8c:f1:75:8a:c6:19:cf:94:b7:f7:65:20:87:c3:97:c7
+# SHA1 Fingerprint: 26:f9:93:b4:ed:3d:28:27:b0:b9:4b:a7:e9:15:1d:a3:8d:92:e5:32
+# SHA256 Fingerprint: 65:7c:fe:2f:a7:3f:aa:38:46:25:71:f3:32:a2:36:3a:46:fc:e7:02:09:51:71:07:02:cd:fb:b6:ee:da:33:05
+-----BEGIN CERTIFICATE-----
+MIIFRzCCAy+gAwIBAgIJEQA0tk7GNi02MA0GCSqGSIb3DQEBCwUAMEExCzAJBgNV
+BAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJR04g
+Uk9PVCBDQSBHMjAeFw0xNzAyMDYwOTI3MzVaFw00MjAyMDYwOTI3MzVaMEExCzAJ
+BgNVBAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJ
+R04gUk9PVCBDQSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMDF
+dRmRfUR0dIf+DjuW3NgBFszuY5HnC2/OOwppGnzC46+CjobXXo9X69MhWf05N0Iw
+vlDqtg+piNguLWkh59E3GE59kdUWX2tbAMI5Qw02hVK5U2UPHULlj88F0+7cDBrZ
+uIt4ImfkabBoxTzkbFpG583H+u/E7Eu9aqSs/cwoUe+StCmrqzWaTOTECMYmzPhp
+n+Sc8CnTXPnGFiWeI8MgwT0PPzhAsP6CRDiqWhqKa2NYOLQV07YRaXseVO6MGiKs
+cpc/I1mbySKEwQdPzH/iV8oScLumZfNpdWO9lfsbl83kqK/20U6o2YpxJM02PbyW
+xPFsqa7lzw1uKA2wDrXKUXt4FMMgL3/7FFXhEZn91QqhngLjYl/rNUssuHLoPj1P
+rCy7Lobio3aP5ZMqz6WryFyNSwb/EkaseMsUBzXgqd+L6a8VTxaJW732jcZZroiF
+DsGJ6x9nxUWO/203Nit4ZoORUSs9/1F3dmKh7Gc+PoGD4FapUB8fepmrY7+EF3fx
+DTvf95xhszWYijqy7DwaNz9+j5LP2RIUZNoQAhVB/0/E6xyjyfqZ90bp4RjZsbgy
+LcsUDFDYg2WD7rlcz8sFWkz6GZdr1l0T08JcVLwyc6B49fFtHsufpaafItzRUZ6C
+eWRgKRM+o/1Pcmqr4tTluCRVLERLiohEnMqE0yo7AgMBAAGjQjBAMA8GA1UdEwEB
+/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSCIS1mxteg4BXrzkwJ
+d8RgnlRuAzANBgkqhkiG9w0BAQsFAAOCAgEAYN4auOfyYILVAzOBywaK8SJJ6ejq
+kX/GM15oGQOGO0MBzwdw5AgeZYWR5hEit/UCI46uuR59H35s5r0l1ZUa8gWmr4UC
+b6741jH/JclKyMeKqdmfS0mbEVeZkkMR3rYzpMzXjWR91M08KCy0mpbqTfXERMQl
+qiCA2ClV9+BB/AYm/7k29UMUA2Z44RGx2iBfRgB4ACGlHgAoYXhvqAEBj500mv/0
+OJD7uNGzcgbJceaBxXntC6Z58hMLnPddDnskk7RI24Zf3lCGeOdA5jGokHZwYa+c
+NywRtYK3qq4kNFtyDGkNzVmf9nGvnAvRCjj5BiKDUyUM/FHE5r7iOZULJK2v0ZXk
+ltd0ZGtxTgI8qoXzIKNDOXZbbFD+mpwUHmUUihW9o4JFWklWatKcsWMy5WHgUyIO
+pwpJ6st+H6jiYoD2EEVSmAYY3qXNL3+q1Ok+CHLsIwMCPKaq2LxndD0UF/tUSxfj
+03k9bWtJySgOLnRQvwzZRjoQhsmnP+mg7H/rpXdYaXHmgwo38oZJar55CJD2AhZk
+PuXaTH4MNMn5X7azKFGnpyuqSfqNZSlO42sTp5SjLVFteAxEy9/eCG/Oo2Sr05WE
+1LlSVHJ7liXMvGnjSG4N0MedJ5qq+BOS3R7fY581qRY27Iy4g/Q9iY/NtBde17MX
+QRBdJ3NghVdJIgc=
+-----END CERTIFICATE-----
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/core.py b/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/core.py
new file mode 100644
index 0000000..8987449
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/certifi/core.py
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+
+"""
+certifi.py
+~~~~~~~~~~
+
+This module returns the installation location of cacert.pem or its contents.
+"""
+import os
+
+try:
+    from importlib.resources import path as get_path, read_text
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where():
+        # This is slightly terrible, but we want to delay extracting the file
+        # in cases where we're inside of a zipimport situation until someone
+        # actually calls where(), but we don't want to re-extract the file
+        # on every call of where(), so we'll do it once then store it in a
+        # global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you to
+            # manage the cleanup of this file, so it doesn't actually return a
+            # path, it returns a context manager that will give you the path
+            # when you enter it and will do any cleanup when you leave it. In
+            # the common case of not needing a temporary file, it will just
+            # return the file system location and the __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = get_path("pip._vendor.certifi", "cacert.pem")
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+
+        return _CACERT_PATH
+
+
+except ImportError:
+    # This fallback will work for Python versions prior to 3.7 that lack the
+    # importlib.resources module but relies on the existing `where` function
+    # so won't address issues with environments like PyOxidizer that don't set
+    # __file__ on modules.
+    def read_text(_module, _path, encoding="ascii"):
+        with open(where(), "r", encoding=encoding) as data:
+            return data.read()
+
+    # If we don't have importlib.resources, then we will just do the old logic
+    # of assuming we're on the filesystem and munge the path directly.
+    def where():
+        f = os.path.dirname(__file__)
+
+        return os.path.join(f, "cacert.pem")
+
+
+def contents():
+    return read_text("certifi", "cacert.pem", encoding="ascii")
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/__init__.py
new file mode 100644
index 0000000..0f9f820
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/__init__.py
@@ -0,0 +1,39 @@
+######################## BEGIN LICENSE BLOCK ########################
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+
+from .compat import PY2, PY3
+from .universaldetector import UniversalDetector
+from .version import __version__, VERSION
+
+
+def detect(byte_str):
+    """
+    Detect the encoding of the given byte string.
+
+    :param byte_str:     The byte sequence to examine.
+    :type byte_str:      ``bytes`` or ``bytearray``
+    """
+    if not isinstance(byte_str, bytearray):
+        if not isinstance(byte_str, bytes):
+            raise TypeError('Expected object of type bytes or bytearray, got: '
+                            '{0}'.format(type(byte_str)))
+        else:
+            byte_str = bytearray(byte_str)
+    detector = UniversalDetector()
+    detector.feed(byte_str)
+    return detector.close()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/big5freq.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/big5freq.py
new file mode 100644
index 0000000..38f3251
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/big5freq.py
@@ -0,0 +1,386 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# Big5 frequency table
+# by Taiwan's Mandarin Promotion Council
+# <http://www.edu.tw:81/mandr/>
+#
+# 128  --> 0.42261
+# 256  --> 0.57851
+# 512  --> 0.74851
+# 1024 --> 0.89384
+# 2048 --> 0.97583
+#
+# Ideal Distribution Ratio = 0.74851/(1-0.74851) =2.98
+# Random Distribution Ration = 512/(5401-512)=0.105
+#
+# Typical Distribution Ratio about 25% of Ideal one, still much higher than RDR
+
+BIG5_TYPICAL_DISTRIBUTION_RATIO = 0.75
+
+#Char to FreqOrder table
+BIG5_TABLE_SIZE = 5376
+
+BIG5_CHAR_TO_FREQ_ORDER = (
+   1,1801,1506, 255,1431, 198,   9,  82,   6,5008, 177, 202,3681,1256,2821, 110, #   16
+3814,  33,3274, 261,  76,  44,2114,  16,2946,2187,1176, 659,3971,  26,3451,2653, #   32
+1198,3972,3350,4202, 410,2215, 302, 590, 361,1964,   8, 204,  58,4510,5009,1932, #   48
+  63,5010,5011, 317,1614,  75, 222, 159,4203,2417,1480,5012,3555,3091, 224,2822, #   64
+3682,   3,  10,3973,1471,  29,2787,1135,2866,1940, 873, 130,3275,1123, 312,5013, #   80
+4511,2052, 507, 252, 682,5014, 142,1915, 124, 206,2947,  34,3556,3204,  64, 604, #   96
+5015,2501,1977,1978, 155,1991, 645, 641,1606,5016,3452, 337,  72, 406,5017,  80, #  112
+ 630, 238,3205,1509, 263, 939,1092,2654, 756,1440,1094,3453, 449,  69,2987, 591, #  128
+ 179,2096, 471, 115,2035,1844,  60,  50,2988, 134, 806,1869, 734,2036,3454, 180, #  144
+ 995,1607, 156, 537,2907, 688,5018, 319,1305, 779,2145, 514,2379, 298,4512, 359, #  160
+2502,  90,2716,1338, 663,  11, 906,1099,2553,  20,2441, 182, 532,1716,5019, 732, #  176
+1376,4204,1311,1420,3206,  25,2317,1056, 113, 399, 382,1950, 242,3455,2474, 529, #  192
+3276, 475,1447,3683,5020, 117,  21, 656, 810,1297,2300,2334,3557,5021, 126,4205, #  208
+ 706, 456, 150, 613,4513,  71,1118,2037,4206, 145,3092,  85, 835, 486,2115,1246, #  224
+1426, 428, 727,1285,1015, 800, 106, 623, 303,1281,5022,2128,2359, 347,3815, 221, #  240
+3558,3135,5023,1956,1153,4207,  83, 296,1199,3093, 192, 624,  93,5024, 822,1898, #  256
+2823,3136, 795,2065, 991,1554,1542,1592,  27,  43,2867, 859, 139,1456, 860,4514, #  272
+ 437, 712,3974, 164,2397,3137, 695, 211,3037,2097, 195,3975,1608,3559,3560,3684, #  288
+3976, 234, 811,2989,2098,3977,2233,1441,3561,1615,2380, 668,2077,1638, 305, 228, #  304
+1664,4515, 467, 415,5025, 262,2099,1593, 239, 108, 300, 200,1033, 512,1247,2078, #  320
+5026,5027,2176,3207,3685,2682, 593, 845,1062,3277,  88,1723,2038,3978,1951, 212, #  336
+ 266, 152, 149, 468,1899,4208,4516,  77, 187,5028,3038,  37,   5,2990,5029,3979, #  352
+5030,5031,  39,2524,4517,2908,3208,2079,  55, 148,  74,4518, 545, 483,1474,1029, #  368
+1665, 217,1870,1531,3138,1104,2655,4209,  24, 172,3562, 900,3980,3563,3564,4519, #  384
+  32,1408,2824,1312, 329, 487,2360,2251,2717, 784,2683,   4,3039,3351,1427,1789, #  400
+ 188, 109, 499,5032,3686,1717,1790, 888,1217,3040,4520,5033,3565,5034,3352,1520, #  416
+3687,3981, 196,1034, 775,5035,5036, 929,1816, 249, 439,  38,5037,1063,5038, 794, #  432
+3982,1435,2301,  46, 178,3278,2066,5039,2381,5040, 214,1709,4521, 804,  35, 707, #  448
+ 324,3688,1601,2554, 140, 459,4210,5041,5042,1365, 839, 272, 978,2262,2580,3456, #  464
+2129,1363,3689,1423, 697, 100,3094,  48,  70,1231, 495,3139,2196,5043,1294,5044, #  480
+2080, 462, 586,1042,3279, 853, 256, 988, 185,2382,3457,1698, 434,1084,5045,3458, #  496
+ 314,2625,2788,4522,2335,2336, 569,2285, 637,1817,2525, 757,1162,1879,1616,3459, #  512
+ 287,1577,2116, 768,4523,1671,2868,3566,2526,1321,3816, 909,2418,5046,4211, 933, #  528
+3817,4212,2053,2361,1222,4524, 765,2419,1322, 786,4525,5047,1920,1462,1677,2909, #  544
+1699,5048,4526,1424,2442,3140,3690,2600,3353,1775,1941,3460,3983,4213, 309,1369, #  560
+1130,2825, 364,2234,1653,1299,3984,3567,3985,3986,2656, 525,1085,3041, 902,2001, #  576
+1475, 964,4527, 421,1845,1415,1057,2286, 940,1364,3141, 376,4528,4529,1381,   7, #  592
+2527, 983,2383, 336,1710,2684,1846, 321,3461, 559,1131,3042,2752,1809,1132,1313, #  608
+ 265,1481,1858,5049, 352,1203,2826,3280, 167,1089, 420,2827, 776, 792,1724,3568, #  624
+4214,2443,3281,5050,4215,5051, 446, 229, 333,2753, 901,3818,1200,1557,4530,2657, #  640
+1921, 395,2754,2685,3819,4216,1836, 125, 916,3209,2626,4531,5052,5053,3820,5054, #  656
+5055,5056,4532,3142,3691,1133,2555,1757,3462,1510,2318,1409,3569,5057,2146, 438, #  672
+2601,2910,2384,3354,1068, 958,3043, 461, 311,2869,2686,4217,1916,3210,4218,1979, #  688
+ 383, 750,2755,2627,4219, 274, 539, 385,1278,1442,5058,1154,1965, 384, 561, 210, #  704
+  98,1295,2556,3570,5059,1711,2420,1482,3463,3987,2911,1257, 129,5060,3821, 642, #  720
+ 523,2789,2790,2658,5061, 141,2235,1333,  68, 176, 441, 876, 907,4220, 603,2602, #  736
+ 710, 171,3464, 404, 549,  18,3143,2398,1410,3692,1666,5062,3571,4533,2912,4534, #  752
+5063,2991, 368,5064, 146, 366,  99, 871,3693,1543, 748, 807,1586,1185,  22,2263, #  768
+ 379,3822,3211,5065,3212, 505,1942,2628,1992,1382,2319,5066, 380,2362, 218, 702, #  784
+1818,1248,3465,3044,3572,3355,3282,5067,2992,3694, 930,3283,3823,5068,  59,5069, #  800
+ 585, 601,4221, 497,3466,1112,1314,4535,1802,5070,1223,1472,2177,5071, 749,1837, #  816
+ 690,1900,3824,1773,3988,1476, 429,1043,1791,2236,2117, 917,4222, 447,1086,1629, #  832
+5072, 556,5073,5074,2021,1654, 844,1090, 105, 550, 966,1758,2828,1008,1783, 686, #  848
+1095,5075,2287, 793,1602,5076,3573,2603,4536,4223,2948,2302,4537,3825, 980,2503, #  864
+ 544, 353, 527,4538, 908,2687,2913,5077, 381,2629,1943,1348,5078,1341,1252, 560, #  880
+3095,5079,3467,2870,5080,2054, 973, 886,2081, 143,4539,5081,5082, 157,3989, 496, #  896
+4224,  57, 840, 540,2039,4540,4541,3468,2118,1445, 970,2264,1748,1966,2082,4225, #  912
+3144,1234,1776,3284,2829,3695, 773,1206,2130,1066,2040,1326,3990,1738,1725,4226, #  928
+ 279,3145,  51,1544,2604, 423,1578,2131,2067, 173,4542,1880,5083,5084,1583, 264, #  944
+ 610,3696,4543,2444, 280, 154,5085,5086,5087,1739, 338,1282,3096, 693,2871,1411, #  960
+1074,3826,2445,5088,4544,5089,5090,1240, 952,2399,5091,2914,1538,2688, 685,1483, #  976
+4227,2475,1436, 953,4228,2055,4545, 671,2400,  79,4229,2446,3285, 608, 567,2689, #  992
+3469,4230,4231,1691, 393,1261,1792,2401,5092,4546,5093,5094,5095,5096,1383,1672, # 1008
+3827,3213,1464, 522,1119, 661,1150, 216, 675,4547,3991,1432,3574, 609,4548,2690, # 1024
+2402,5097,5098,5099,4232,3045,   0,5100,2476, 315, 231,2447, 301,3356,4549,2385, # 1040
+5101, 233,4233,3697,1819,4550,4551,5102,  96,1777,1315,2083,5103, 257,5104,1810, # 1056
+3698,2718,1139,1820,4234,2022,1124,2164,2791,1778,2659,5105,3097, 363,1655,3214, # 1072
+5106,2993,5107,5108,5109,3992,1567,3993, 718, 103,3215, 849,1443, 341,3357,2949, # 1088
+1484,5110,1712, 127,  67, 339,4235,2403, 679,1412, 821,5111,5112, 834, 738, 351, # 1104
+2994,2147, 846, 235,1497,1881, 418,1993,3828,2719, 186,1100,2148,2756,3575,1545, # 1120
+1355,2950,2872,1377, 583,3994,4236,2581,2995,5113,1298,3699,1078,2557,3700,2363, # 1136
+  78,3829,3830, 267,1289,2100,2002,1594,4237, 348, 369,1274,2197,2178,1838,4552, # 1152
+1821,2830,3701,2757,2288,2003,4553,2951,2758, 144,3358, 882,4554,3995,2759,3470, # 1168
+4555,2915,5114,4238,1726, 320,5115,3996,3046, 788,2996,5116,2831,1774,1327,2873, # 1184
+3997,2832,5117,1306,4556,2004,1700,3831,3576,2364,2660, 787,2023, 506, 824,3702, # 1200
+ 534, 323,4557,1044,3359,2024,1901, 946,3471,5118,1779,1500,1678,5119,1882,4558, # 1216
+ 165, 243,4559,3703,2528, 123, 683,4239, 764,4560,  36,3998,1793, 589,2916, 816, # 1232
+ 626,1667,3047,2237,1639,1555,1622,3832,3999,5120,4000,2874,1370,1228,1933, 891, # 1248
+2084,2917, 304,4240,5121, 292,2997,2720,3577, 691,2101,4241,1115,4561, 118, 662, # 1264
+5122, 611,1156, 854,2386,1316,2875,   2, 386, 515,2918,5123,5124,3286, 868,2238, # 1280
+1486, 855,2661, 785,2216,3048,5125,1040,3216,3578,5126,3146, 448,5127,1525,5128, # 1296
+2165,4562,5129,3833,5130,4242,2833,3579,3147, 503, 818,4001,3148,1568, 814, 676, # 1312
+1444, 306,1749,5131,3834,1416,1030, 197,1428, 805,2834,1501,4563,5132,5133,5134, # 1328
+1994,5135,4564,5136,5137,2198,  13,2792,3704,2998,3149,1229,1917,5138,3835,2132, # 1344
+5139,4243,4565,2404,3580,5140,2217,1511,1727,1120,5141,5142, 646,3836,2448, 307, # 1360
+5143,5144,1595,3217,5145,5146,5147,3705,1113,1356,4002,1465,2529,2530,5148, 519, # 1376
+5149, 128,2133,  92,2289,1980,5150,4003,1512, 342,3150,2199,5151,2793,2218,1981, # 1392
+3360,4244, 290,1656,1317, 789, 827,2365,5152,3837,4566, 562, 581,4004,5153, 401, # 1408
+4567,2252,  94,4568,5154,1399,2794,5155,1463,2025,4569,3218,1944,5156, 828,1105, # 1424
+4245,1262,1394,5157,4246, 605,4570,5158,1784,2876,5159,2835, 819,2102, 578,2200, # 1440
+2952,5160,1502, 436,3287,4247,3288,2836,4005,2919,3472,3473,5161,2721,2320,5162, # 1456
+5163,2337,2068,  23,4571, 193, 826,3838,2103, 699,1630,4248,3098, 390,1794,1064, # 1472
+3581,5164,1579,3099,3100,1400,5165,4249,1839,1640,2877,5166,4572,4573, 137,4250, # 1488
+ 598,3101,1967, 780, 104, 974,2953,5167, 278, 899, 253, 402, 572, 504, 493,1339, # 1504
+5168,4006,1275,4574,2582,2558,5169,3706,3049,3102,2253, 565,1334,2722, 863,  41, # 1520
+5170,5171,4575,5172,1657,2338,  19, 463,2760,4251, 606,5173,2999,3289,1087,2085, # 1536
+1323,2662,3000,5174,1631,1623,1750,4252,2691,5175,2878, 791,2723,2663,2339, 232, # 1552
+2421,5176,3001,1498,5177,2664,2630, 755,1366,3707,3290,3151,2026,1609, 119,1918, # 1568
+3474, 862,1026,4253,5178,4007,3839,4576,4008,4577,2265,1952,2477,5179,1125, 817, # 1584
+4254,4255,4009,1513,1766,2041,1487,4256,3050,3291,2837,3840,3152,5180,5181,1507, # 1600
+5182,2692, 733,  40,1632,1106,2879, 345,4257, 841,2531, 230,4578,3002,1847,3292, # 1616
+3475,5183,1263, 986,3476,5184, 735, 879, 254,1137, 857, 622,1300,1180,1388,1562, # 1632
+4010,4011,2954, 967,2761,2665,1349, 592,2134,1692,3361,3003,1995,4258,1679,4012, # 1648
+1902,2188,5185, 739,3708,2724,1296,1290,5186,4259,2201,2202,1922,1563,2605,2559, # 1664
+1871,2762,3004,5187, 435,5188, 343,1108, 596,  17,1751,4579,2239,3477,3709,5189, # 1680
+4580, 294,3582,2955,1693, 477, 979, 281,2042,3583, 643,2043,3710,2631,2795,2266, # 1696
+1031,2340,2135,2303,3584,4581, 367,1249,2560,5190,3585,5191,4582,1283,3362,2005, # 1712
+ 240,1762,3363,4583,4584, 836,1069,3153, 474,5192,2149,2532, 268,3586,5193,3219, # 1728
+1521,1284,5194,1658,1546,4260,5195,3587,3588,5196,4261,3364,2693,1685,4262, 961, # 1744
+1673,2632, 190,2006,2203,3841,4585,4586,5197, 570,2504,3711,1490,5198,4587,2633, # 1760
+3293,1957,4588, 584,1514, 396,1045,1945,5199,4589,1968,2449,5200,5201,4590,4013, # 1776
+ 619,5202,3154,3294, 215,2007,2796,2561,3220,4591,3221,4592, 763,4263,3842,4593, # 1792
+5203,5204,1958,1767,2956,3365,3712,1174, 452,1477,4594,3366,3155,5205,2838,1253, # 1808
+2387,2189,1091,2290,4264, 492,5206, 638,1169,1825,2136,1752,4014, 648, 926,1021, # 1824
+1324,4595, 520,4596, 997, 847,1007, 892,4597,3843,2267,1872,3713,2405,1785,4598, # 1840
+1953,2957,3103,3222,1728,4265,2044,3714,4599,2008,1701,3156,1551,  30,2268,4266, # 1856
+5207,2027,4600,3589,5208, 501,5209,4267, 594,3478,2166,1822,3590,3479,3591,3223, # 1872
+ 829,2839,4268,5210,1680,3157,1225,4269,5211,3295,4601,4270,3158,2341,5212,4602, # 1888
+4271,5213,4015,4016,5214,1848,2388,2606,3367,5215,4603, 374,4017, 652,4272,4273, # 1904
+ 375,1140, 798,5216,5217,5218,2366,4604,2269, 546,1659, 138,3051,2450,4605,5219, # 1920
+2254, 612,1849, 910, 796,3844,1740,1371, 825,3845,3846,5220,2920,2562,5221, 692, # 1936
+ 444,3052,2634, 801,4606,4274,5222,1491, 244,1053,3053,4275,4276, 340,5223,4018, # 1952
+1041,3005, 293,1168,  87,1357,5224,1539, 959,5225,2240, 721, 694,4277,3847, 219, # 1968
+1478, 644,1417,3368,2666,1413,1401,1335,1389,4019,5226,5227,3006,2367,3159,1826, # 1984
+ 730,1515, 184,2840,  66,4607,5228,1660,2958, 246,3369, 378,1457, 226,3480, 975, # 2000
+4020,2959,1264,3592, 674, 696,5229, 163,5230,1141,2422,2167, 713,3593,3370,4608, # 2016
+4021,5231,5232,1186,  15,5233,1079,1070,5234,1522,3224,3594, 276,1050,2725, 758, # 2032
+1126, 653,2960,3296,5235,2342, 889,3595,4022,3104,3007, 903,1250,4609,4023,3481, # 2048
+3596,1342,1681,1718, 766,3297, 286,  89,2961,3715,5236,1713,5237,2607,3371,3008, # 2064
+5238,2962,2219,3225,2880,5239,4610,2505,2533, 181, 387,1075,4024, 731,2190,3372, # 2080
+5240,3298, 310, 313,3482,2304, 770,4278,  54,3054, 189,4611,3105,3848,4025,5241, # 2096
+1230,1617,1850, 355,3597,4279,4612,3373, 111,4280,3716,1350,3160,3483,3055,4281, # 2112
+2150,3299,3598,5242,2797,4026,4027,3009, 722,2009,5243,1071, 247,1207,2343,2478, # 2128
+1378,4613,2010, 864,1437,1214,4614, 373,3849,1142,2220, 667,4615, 442,2763,2563, # 2144
+3850,4028,1969,4282,3300,1840, 837, 170,1107, 934,1336,1883,5244,5245,2119,4283, # 2160
+2841, 743,1569,5246,4616,4284, 582,2389,1418,3484,5247,1803,5248, 357,1395,1729, # 2176
+3717,3301,2423,1564,2241,5249,3106,3851,1633,4617,1114,2086,4285,1532,5250, 482, # 2192
+2451,4618,5251,5252,1492, 833,1466,5253,2726,3599,1641,2842,5254,1526,1272,3718, # 2208
+4286,1686,1795, 416,2564,1903,1954,1804,5255,3852,2798,3853,1159,2321,5256,2881, # 2224
+4619,1610,1584,3056,2424,2764, 443,3302,1163,3161,5257,5258,4029,5259,4287,2506, # 2240
+3057,4620,4030,3162,2104,1647,3600,2011,1873,4288,5260,4289, 431,3485,5261, 250, # 2256
+  97,  81,4290,5262,1648,1851,1558, 160, 848,5263, 866, 740,1694,5264,2204,2843, # 2272
+3226,4291,4621,3719,1687, 950,2479, 426, 469,3227,3720,3721,4031,5265,5266,1188, # 2288
+ 424,1996, 861,3601,4292,3854,2205,2694, 168,1235,3602,4293,5267,2087,1674,4622, # 2304
+3374,3303, 220,2565,1009,5268,3855, 670,3010, 332,1208, 717,5269,5270,3603,2452, # 2320
+4032,3375,5271, 513,5272,1209,2882,3376,3163,4623,1080,5273,5274,5275,5276,2534, # 2336
+3722,3604, 815,1587,4033,4034,5277,3605,3486,3856,1254,4624,1328,3058,1390,4035, # 2352
+1741,4036,3857,4037,5278, 236,3858,2453,3304,5279,5280,3723,3859,1273,3860,4625, # 2368
+5281, 308,5282,4626, 245,4627,1852,2480,1307,2583, 430, 715,2137,2454,5283, 270, # 2384
+ 199,2883,4038,5284,3606,2727,1753, 761,1754, 725,1661,1841,4628,3487,3724,5285, # 2400
+5286, 587,  14,3305, 227,2608, 326, 480,2270, 943,2765,3607, 291, 650,1884,5287, # 2416
+1702,1226, 102,1547,  62,3488, 904,4629,3489,1164,4294,5288,5289,1224,1548,2766, # 2432
+ 391, 498,1493,5290,1386,1419,5291,2056,1177,4630, 813, 880,1081,2368, 566,1145, # 2448
+4631,2291,1001,1035,2566,2609,2242, 394,1286,5292,5293,2069,5294,  86,1494,1730, # 2464
+4039, 491,1588, 745, 897,2963, 843,3377,4040,2767,2884,3306,1768, 998,2221,2070, # 2480
+ 397,1827,1195,1970,3725,3011,3378, 284,5295,3861,2507,2138,2120,1904,5296,4041, # 2496
+2151,4042,4295,1036,3490,1905, 114,2567,4296, 209,1527,5297,5298,2964,2844,2635, # 2512
+2390,2728,3164, 812,2568,5299,3307,5300,1559, 737,1885,3726,1210, 885,  28,2695, # 2528
+3608,3862,5301,4297,1004,1780,4632,5302, 346,1982,2222,2696,4633,3863,1742, 797, # 2544
+1642,4043,1934,1072,1384,2152, 896,4044,3308,3727,3228,2885,3609,5303,2569,1959, # 2560
+4634,2455,1786,5304,5305,5306,4045,4298,1005,1308,3728,4299,2729,4635,4636,1528, # 2576
+2610, 161,1178,4300,1983, 987,4637,1101,4301, 631,4046,1157,3229,2425,1343,1241, # 2592
+1016,2243,2570, 372, 877,2344,2508,1160, 555,1935, 911,4047,5307, 466,1170, 169, # 2608
+1051,2921,2697,3729,2481,3012,1182,2012,2571,1251,2636,5308, 992,2345,3491,1540, # 2624
+2730,1201,2071,2406,1997,2482,5309,4638, 528,1923,2191,1503,1874,1570,2369,3379, # 2640
+3309,5310, 557,1073,5311,1828,3492,2088,2271,3165,3059,3107, 767,3108,2799,4639, # 2656
+1006,4302,4640,2346,1267,2179,3730,3230, 778,4048,3231,2731,1597,2667,5312,4641, # 2672
+5313,3493,5314,5315,5316,3310,2698,1433,3311, 131,  95,1504,4049, 723,4303,3166, # 2688
+1842,3610,2768,2192,4050,2028,2105,3731,5317,3013,4051,1218,5318,3380,3232,4052, # 2704
+4304,2584, 248,1634,3864, 912,5319,2845,3732,3060,3865, 654,  53,5320,3014,5321, # 2720
+1688,4642, 777,3494,1032,4053,1425,5322, 191, 820,2121,2846, 971,4643, 931,3233, # 2736
+ 135, 664, 783,3866,1998, 772,2922,1936,4054,3867,4644,2923,3234, 282,2732, 640, # 2752
+1372,3495,1127, 922, 325,3381,5323,5324, 711,2045,5325,5326,4055,2223,2800,1937, # 2768
+4056,3382,2224,2255,3868,2305,5327,4645,3869,1258,3312,4057,3235,2139,2965,4058, # 2784
+4059,5328,2225, 258,3236,4646, 101,1227,5329,3313,1755,5330,1391,3314,5331,2924, # 2800
+2057, 893,5332,5333,5334,1402,4305,2347,5335,5336,3237,3611,5337,5338, 878,1325, # 2816
+1781,2801,4647, 259,1385,2585, 744,1183,2272,4648,5339,4060,2509,5340, 684,1024, # 2832
+4306,5341, 472,3612,3496,1165,3315,4061,4062, 322,2153, 881, 455,1695,1152,1340, # 2848
+ 660, 554,2154,4649,1058,4650,4307, 830,1065,3383,4063,4651,1924,5342,1703,1919, # 2864
+5343, 932,2273, 122,5344,4652, 947, 677,5345,3870,2637, 297,1906,1925,2274,4653, # 2880
+2322,3316,5346,5347,4308,5348,4309,  84,4310, 112, 989,5349, 547,1059,4064, 701, # 2896
+3613,1019,5350,4311,5351,3497, 942, 639, 457,2306,2456, 993,2966, 407, 851, 494, # 2912
+4654,3384, 927,5352,1237,5353,2426,3385, 573,4312, 680, 921,2925,1279,1875, 285, # 2928
+ 790,1448,1984, 719,2168,5354,5355,4655,4065,4066,1649,5356,1541, 563,5357,1077, # 2944
+5358,3386,3061,3498, 511,3015,4067,4068,3733,4069,1268,2572,3387,3238,4656,4657, # 2960
+5359, 535,1048,1276,1189,2926,2029,3167,1438,1373,2847,2967,1134,2013,5360,4313, # 2976
+1238,2586,3109,1259,5361, 700,5362,2968,3168,3734,4314,5363,4315,1146,1876,1907, # 2992
+4658,2611,4070, 781,2427, 132,1589, 203, 147, 273,2802,2407, 898,1787,2155,4071, # 3008
+4072,5364,3871,2803,5365,5366,4659,4660,5367,3239,5368,1635,3872, 965,5369,1805, # 3024
+2699,1516,3614,1121,1082,1329,3317,4073,1449,3873,  65,1128,2848,2927,2769,1590, # 3040
+3874,5370,5371,  12,2668,  45, 976,2587,3169,4661, 517,2535,1013,1037,3240,5372, # 3056
+3875,2849,5373,3876,5374,3499,5375,2612, 614,1999,2323,3877,3110,2733,2638,5376, # 3072
+2588,4316, 599,1269,5377,1811,3735,5378,2700,3111, 759,1060, 489,1806,3388,3318, # 3088
+1358,5379,5380,2391,1387,1215,2639,2256, 490,5381,5382,4317,1759,2392,2348,5383, # 3104
+4662,3878,1908,4074,2640,1807,3241,4663,3500,3319,2770,2349, 874,5384,5385,3501, # 3120
+3736,1859,  91,2928,3737,3062,3879,4664,5386,3170,4075,2669,5387,3502,1202,1403, # 3136
+3880,2969,2536,1517,2510,4665,3503,2511,5388,4666,5389,2701,1886,1495,1731,4076, # 3152
+2370,4667,5390,2030,5391,5392,4077,2702,1216, 237,2589,4318,2324,4078,3881,4668, # 3168
+4669,2703,3615,3504, 445,4670,5393,5394,5395,5396,2771,  61,4079,3738,1823,4080, # 3184
+5397, 687,2046, 935, 925, 405,2670, 703,1096,1860,2734,4671,4081,1877,1367,2704, # 3200
+3389, 918,2106,1782,2483, 334,3320,1611,1093,4672, 564,3171,3505,3739,3390, 945, # 3216
+2641,2058,4673,5398,1926, 872,4319,5399,3506,2705,3112, 349,4320,3740,4082,4674, # 3232
+3882,4321,3741,2156,4083,4675,4676,4322,4677,2408,2047, 782,4084, 400, 251,4323, # 3248
+1624,5400,5401, 277,3742, 299,1265, 476,1191,3883,2122,4324,4325,1109, 205,5402, # 3264
+2590,1000,2157,3616,1861,5403,5404,5405,4678,5406,4679,2573, 107,2484,2158,4085, # 3280
+3507,3172,5407,1533, 541,1301, 158, 753,4326,2886,3617,5408,1696, 370,1088,4327, # 3296
+4680,3618, 579, 327, 440, 162,2244, 269,1938,1374,3508, 968,3063,  56,1396,3113, # 3312
+2107,3321,3391,5409,1927,2159,4681,3016,5410,3619,5411,5412,3743,4682,2485,5413, # 3328
+2804,5414,1650,4683,5415,2613,5416,5417,4086,2671,3392,1149,3393,4087,3884,4088, # 3344
+5418,1076,  49,5419, 951,3242,3322,3323, 450,2850, 920,5420,1812,2805,2371,4328, # 3360
+1909,1138,2372,3885,3509,5421,3243,4684,1910,1147,1518,2428,4685,3886,5422,4686, # 3376
+2393,2614, 260,1796,3244,5423,5424,3887,3324, 708,5425,3620,1704,5426,3621,1351, # 3392
+1618,3394,3017,1887, 944,4329,3395,4330,3064,3396,4331,5427,3744, 422, 413,1714, # 3408
+3325, 500,2059,2350,4332,2486,5428,1344,1911, 954,5429,1668,5430,5431,4089,2409, # 3424
+4333,3622,3888,4334,5432,2307,1318,2512,3114, 133,3115,2887,4687, 629,  31,2851, # 3440
+2706,3889,4688, 850, 949,4689,4090,2970,1732,2089,4335,1496,1853,5433,4091, 620, # 3456
+3245, 981,1242,3745,3397,1619,3746,1643,3326,2140,2457,1971,1719,3510,2169,5434, # 3472
+3246,5435,5436,3398,1829,5437,1277,4690,1565,2048,5438,1636,3623,3116,5439, 869, # 3488
+2852, 655,3890,3891,3117,4092,3018,3892,1310,3624,4691,5440,5441,5442,1733, 558, # 3504
+4692,3747, 335,1549,3065,1756,4336,3748,1946,3511,1830,1291,1192, 470,2735,2108, # 3520
+2806, 913,1054,4093,5443,1027,5444,3066,4094,4693, 982,2672,3399,3173,3512,3247, # 3536
+3248,1947,2807,5445, 571,4694,5446,1831,5447,3625,2591,1523,2429,5448,2090, 984, # 3552
+4695,3749,1960,5449,3750, 852, 923,2808,3513,3751, 969,1519, 999,2049,2325,1705, # 3568
+5450,3118, 615,1662, 151, 597,4095,2410,2326,1049, 275,4696,3752,4337, 568,3753, # 3584
+3626,2487,4338,3754,5451,2430,2275, 409,3249,5452,1566,2888,3514,1002, 769,2853, # 3600
+ 194,2091,3174,3755,2226,3327,4339, 628,1505,5453,5454,1763,2180,3019,4096, 521, # 3616
+1161,2592,1788,2206,2411,4697,4097,1625,4340,4341, 412,  42,3119, 464,5455,2642, # 3632
+4698,3400,1760,1571,2889,3515,2537,1219,2207,3893,2643,2141,2373,4699,4700,3328, # 3648
+1651,3401,3627,5456,5457,3628,2488,3516,5458,3756,5459,5460,2276,2092, 460,5461, # 3664
+4701,5462,3020, 962, 588,3629, 289,3250,2644,1116,  52,5463,3067,1797,5464,5465, # 3680
+5466,1467,5467,1598,1143,3757,4342,1985,1734,1067,4702,1280,3402, 465,4703,1572, # 3696
+ 510,5468,1928,2245,1813,1644,3630,5469,4704,3758,5470,5471,2673,1573,1534,5472, # 3712
+5473, 536,1808,1761,3517,3894,3175,2645,5474,5475,5476,4705,3518,2929,1912,2809, # 3728
+5477,3329,1122, 377,3251,5478, 360,5479,5480,4343,1529, 551,5481,2060,3759,1769, # 3744
+2431,5482,2930,4344,3330,3120,2327,2109,2031,4706,1404, 136,1468,1479, 672,1171, # 3760
+3252,2308, 271,3176,5483,2772,5484,2050, 678,2736, 865,1948,4707,5485,2014,4098, # 3776
+2971,5486,2737,2227,1397,3068,3760,4708,4709,1735,2931,3403,3631,5487,3895, 509, # 3792
+2854,2458,2890,3896,5488,5489,3177,3178,4710,4345,2538,4711,2309,1166,1010, 552, # 3808
+ 681,1888,5490,5491,2972,2973,4099,1287,1596,1862,3179, 358, 453, 736, 175, 478, # 3824
+1117, 905,1167,1097,5492,1854,1530,5493,1706,5494,2181,3519,2292,3761,3520,3632, # 3840
+4346,2093,4347,5495,3404,1193,2489,4348,1458,2193,2208,1863,1889,1421,3331,2932, # 3856
+3069,2182,3521, 595,2123,5496,4100,5497,5498,4349,1707,2646, 223,3762,1359, 751, # 3872
+3121, 183,3522,5499,2810,3021, 419,2374, 633, 704,3897,2394, 241,5500,5501,5502, # 3888
+ 838,3022,3763,2277,2773,2459,3898,1939,2051,4101,1309,3122,2246,1181,5503,1136, # 3904
+2209,3899,2375,1446,4350,2310,4712,5504,5505,4351,1055,2615, 484,3764,5506,4102, # 3920
+ 625,4352,2278,3405,1499,4353,4103,5507,4104,4354,3253,2279,2280,3523,5508,5509, # 3936
+2774, 808,2616,3765,3406,4105,4355,3123,2539, 526,3407,3900,4356, 955,5510,1620, # 3952
+4357,2647,2432,5511,1429,3766,1669,1832, 994, 928,5512,3633,1260,5513,5514,5515, # 3968
+1949,2293, 741,2933,1626,4358,2738,2460, 867,1184, 362,3408,1392,5516,5517,4106, # 3984
+4359,1770,1736,3254,2934,4713,4714,1929,2707,1459,1158,5518,3070,3409,2891,1292, # 4000
+1930,2513,2855,3767,1986,1187,2072,2015,2617,4360,5519,2574,2514,2170,3768,2490, # 4016
+3332,5520,3769,4715,5521,5522, 666,1003,3023,1022,3634,4361,5523,4716,1814,2257, # 4032
+ 574,3901,1603, 295,1535, 705,3902,4362, 283, 858, 417,5524,5525,3255,4717,4718, # 4048
+3071,1220,1890,1046,2281,2461,4107,1393,1599, 689,2575, 388,4363,5526,2491, 802, # 4064
+5527,2811,3903,2061,1405,2258,5528,4719,3904,2110,1052,1345,3256,1585,5529, 809, # 4080
+5530,5531,5532, 575,2739,3524, 956,1552,1469,1144,2328,5533,2329,1560,2462,3635, # 4096
+3257,4108, 616,2210,4364,3180,2183,2294,5534,1833,5535,3525,4720,5536,1319,3770, # 4112
+3771,1211,3636,1023,3258,1293,2812,5537,5538,5539,3905, 607,2311,3906, 762,2892, # 4128
+1439,4365,1360,4721,1485,3072,5540,4722,1038,4366,1450,2062,2648,4367,1379,4723, # 4144
+2593,5541,5542,4368,1352,1414,2330,2935,1172,5543,5544,3907,3908,4724,1798,1451, # 4160
+5545,5546,5547,5548,2936,4109,4110,2492,2351, 411,4111,4112,3637,3333,3124,4725, # 4176
+1561,2674,1452,4113,1375,5549,5550,  47,2974, 316,5551,1406,1591,2937,3181,5552, # 4192
+1025,2142,3125,3182, 354,2740, 884,2228,4369,2412, 508,3772, 726,3638, 996,2433, # 4208
+3639, 729,5553, 392,2194,1453,4114,4726,3773,5554,5555,2463,3640,2618,1675,2813, # 4224
+ 919,2352,2975,2353,1270,4727,4115,  73,5556,5557, 647,5558,3259,2856,2259,1550, # 4240
+1346,3024,5559,1332, 883,3526,5560,5561,5562,5563,3334,2775,5564,1212, 831,1347, # 4256
+4370,4728,2331,3909,1864,3073, 720,3910,4729,4730,3911,5565,4371,5566,5567,4731, # 4272
+5568,5569,1799,4732,3774,2619,4733,3641,1645,2376,4734,5570,2938, 669,2211,2675, # 4288
+2434,5571,2893,5572,5573,1028,3260,5574,4372,2413,5575,2260,1353,5576,5577,4735, # 4304
+3183, 518,5578,4116,5579,4373,1961,5580,2143,4374,5581,5582,3025,2354,2355,3912, # 4320
+ 516,1834,1454,4117,2708,4375,4736,2229,2620,1972,1129,3642,5583,2776,5584,2976, # 4336
+1422, 577,1470,3026,1524,3410,5585,5586, 432,4376,3074,3527,5587,2594,1455,2515, # 4352
+2230,1973,1175,5588,1020,2741,4118,3528,4737,5589,2742,5590,1743,1361,3075,3529, # 4368
+2649,4119,4377,4738,2295, 895, 924,4378,2171, 331,2247,3076, 166,1627,3077,1098, # 4384
+5591,1232,2894,2231,3411,4739, 657, 403,1196,2377, 542,3775,3412,1600,4379,3530, # 4400
+5592,4740,2777,3261, 576, 530,1362,4741,4742,2540,2676,3776,4120,5593, 842,3913, # 4416
+5594,2814,2032,1014,4121, 213,2709,3413, 665, 621,4380,5595,3777,2939,2435,5596, # 4432
+2436,3335,3643,3414,4743,4381,2541,4382,4744,3644,1682,4383,3531,1380,5597, 724, # 4448
+2282, 600,1670,5598,1337,1233,4745,3126,2248,5599,1621,4746,5600, 651,4384,5601, # 4464
+1612,4385,2621,5602,2857,5603,2743,2312,3078,5604, 716,2464,3079, 174,1255,2710, # 4480
+4122,3645, 548,1320,1398, 728,4123,1574,5605,1891,1197,3080,4124,5606,3081,3082, # 4496
+3778,3646,3779, 747,5607, 635,4386,4747,5608,5609,5610,4387,5611,5612,4748,5613, # 4512
+3415,4749,2437, 451,5614,3780,2542,2073,4388,2744,4389,4125,5615,1764,4750,5616, # 4528
+4390, 350,4751,2283,2395,2493,5617,4391,4126,2249,1434,4127, 488,4752, 458,4392, # 4544
+4128,3781, 771,1330,2396,3914,2576,3184,2160,2414,1553,2677,3185,4393,5618,2494, # 4560
+2895,2622,1720,2711,4394,3416,4753,5619,2543,4395,5620,3262,4396,2778,5621,2016, # 4576
+2745,5622,1155,1017,3782,3915,5623,3336,2313, 201,1865,4397,1430,5624,4129,5625, # 4592
+5626,5627,5628,5629,4398,1604,5630, 414,1866, 371,2595,4754,4755,3532,2017,3127, # 4608
+4756,1708, 960,4399, 887, 389,2172,1536,1663,1721,5631,2232,4130,2356,2940,1580, # 4624
+5632,5633,1744,4757,2544,4758,4759,5634,4760,5635,2074,5636,4761,3647,3417,2896, # 4640
+4400,5637,4401,2650,3418,2815, 673,2712,2465, 709,3533,4131,3648,4402,5638,1148, # 4656
+ 502, 634,5639,5640,1204,4762,3649,1575,4763,2623,3783,5641,3784,3128, 948,3263, # 4672
+ 121,1745,3916,1110,5642,4403,3083,2516,3027,4132,3785,1151,1771,3917,1488,4133, # 4688
+1987,5643,2438,3534,5644,5645,2094,5646,4404,3918,1213,1407,2816, 531,2746,2545, # 4704
+3264,1011,1537,4764,2779,4405,3129,1061,5647,3786,3787,1867,2897,5648,2018, 120, # 4720
+4406,4407,2063,3650,3265,2314,3919,2678,3419,1955,4765,4134,5649,3535,1047,2713, # 4736
+1266,5650,1368,4766,2858, 649,3420,3920,2546,2747,1102,2859,2679,5651,5652,2000, # 4752
+5653,1111,3651,2977,5654,2495,3921,3652,2817,1855,3421,3788,5655,5656,3422,2415, # 4768
+2898,3337,3266,3653,5657,2577,5658,3654,2818,4135,1460, 856,5659,3655,5660,2899, # 4784
+2978,5661,2900,3922,5662,4408, 632,2517, 875,3923,1697,3924,2296,5663,5664,4767, # 4800
+3028,1239, 580,4768,4409,5665, 914, 936,2075,1190,4136,1039,2124,5666,5667,5668, # 4816
+5669,3423,1473,5670,1354,4410,3925,4769,2173,3084,4137, 915,3338,4411,4412,3339, # 4832
+1605,1835,5671,2748, 398,3656,4413,3926,4138, 328,1913,2860,4139,3927,1331,4414, # 4848
+3029, 937,4415,5672,3657,4140,4141,3424,2161,4770,3425, 524, 742, 538,3085,1012, # 4864
+5673,5674,3928,2466,5675, 658,1103, 225,3929,5676,5677,4771,5678,4772,5679,3267, # 4880
+1243,5680,4142, 963,2250,4773,5681,2714,3658,3186,5682,5683,2596,2332,5684,4774, # 4896
+5685,5686,5687,3536, 957,3426,2547,2033,1931,2941,2467, 870,2019,3659,1746,2780, # 4912
+2781,2439,2468,5688,3930,5689,3789,3130,3790,3537,3427,3791,5690,1179,3086,5691, # 4928
+3187,2378,4416,3792,2548,3188,3131,2749,4143,5692,3428,1556,2549,2297, 977,2901, # 4944
+2034,4144,1205,3429,5693,1765,3430,3189,2125,1271, 714,1689,4775,3538,5694,2333, # 4960
+3931, 533,4417,3660,2184, 617,5695,2469,3340,3539,2315,5696,5697,3190,5698,5699, # 4976
+3932,1988, 618, 427,2651,3540,3431,5700,5701,1244,1690,5702,2819,4418,4776,5703, # 4992
+3541,4777,5704,2284,1576, 473,3661,4419,3432, 972,5705,3662,5706,3087,5707,5708, # 5008
+4778,4779,5709,3793,4145,4146,5710, 153,4780, 356,5711,1892,2902,4420,2144, 408, # 5024
+ 803,2357,5712,3933,5713,4421,1646,2578,2518,4781,4782,3934,5714,3935,4422,5715, # 5040
+2416,3433, 752,5716,5717,1962,3341,2979,5718, 746,3030,2470,4783,4423,3794, 698, # 5056
+4784,1893,4424,3663,2550,4785,3664,3936,5719,3191,3434,5720,1824,1302,4147,2715, # 5072
+3937,1974,4425,5721,4426,3192, 823,1303,1288,1236,2861,3542,4148,3435, 774,3938, # 5088
+5722,1581,4786,1304,2862,3939,4787,5723,2440,2162,1083,3268,4427,4149,4428, 344, # 5104
+1173, 288,2316, 454,1683,5724,5725,1461,4788,4150,2597,5726,5727,4789, 985, 894, # 5120
+5728,3436,3193,5729,1914,2942,3795,1989,5730,2111,1975,5731,4151,5732,2579,1194, # 5136
+ 425,5733,4790,3194,1245,3796,4429,5734,5735,2863,5736, 636,4791,1856,3940, 760, # 5152
+1800,5737,4430,2212,1508,4792,4152,1894,1684,2298,5738,5739,4793,4431,4432,2213, # 5168
+ 479,5740,5741, 832,5742,4153,2496,5743,2980,2497,3797, 990,3132, 627,1815,2652, # 5184
+4433,1582,4434,2126,2112,3543,4794,5744, 799,4435,3195,5745,4795,2113,1737,3031, # 5200
+1018, 543, 754,4436,3342,1676,4796,4797,4154,4798,1489,5746,3544,5747,2624,2903, # 5216
+4155,5748,5749,2981,5750,5751,5752,5753,3196,4799,4800,2185,1722,5754,3269,3270, # 5232
+1843,3665,1715, 481, 365,1976,1857,5755,5756,1963,2498,4801,5757,2127,3666,3271, # 5248
+ 433,1895,2064,2076,5758, 602,2750,5759,5760,5761,5762,5763,3032,1628,3437,5764, # 5264
+3197,4802,4156,2904,4803,2519,5765,2551,2782,5766,5767,5768,3343,4804,2905,5769, # 5280
+4805,5770,2864,4806,4807,1221,2982,4157,2520,5771,5772,5773,1868,1990,5774,5775, # 5296
+5776,1896,5777,5778,4808,1897,4158, 318,5779,2095,4159,4437,5780,5781, 485,5782, # 5312
+ 938,3941, 553,2680, 116,5783,3942,3667,5784,3545,2681,2783,3438,3344,2820,5785, # 5328
+3668,2943,4160,1747,2944,2983,5786,5787, 207,5788,4809,5789,4810,2521,5790,3033, # 5344
+ 890,3669,3943,5791,1878,3798,3439,5792,2186,2358,3440,1652,5793,5794,5795, 941, # 5360
+2299, 208,3546,4161,2020, 330,4438,3944,2906,2499,3799,4439,4811,5796,5797,5798, # 5376
+)
+
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/big5prober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/big5prober.py
new file mode 100644
index 0000000..98f9970
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/big5prober.py
@@ -0,0 +1,47 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .mbcharsetprober import MultiByteCharSetProber
+from .codingstatemachine import CodingStateMachine
+from .chardistribution import Big5DistributionAnalysis
+from .mbcssm import BIG5_SM_MODEL
+
+
+class Big5Prober(MultiByteCharSetProber):
+    def __init__(self):
+        super(Big5Prober, self).__init__()
+        self.coding_sm = CodingStateMachine(BIG5_SM_MODEL)
+        self.distribution_analyzer = Big5DistributionAnalysis()
+        self.reset()
+
+    @property
+    def charset_name(self):
+        return "Big5"
+
+    @property
+    def language(self):
+        return "Chinese"
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/chardistribution.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/chardistribution.py
new file mode 100644
index 0000000..c0395f4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/chardistribution.py
@@ -0,0 +1,233 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .euctwfreq import (EUCTW_CHAR_TO_FREQ_ORDER, EUCTW_TABLE_SIZE,
+                        EUCTW_TYPICAL_DISTRIBUTION_RATIO)
+from .euckrfreq import (EUCKR_CHAR_TO_FREQ_ORDER, EUCKR_TABLE_SIZE,
+                        EUCKR_TYPICAL_DISTRIBUTION_RATIO)
+from .gb2312freq import (GB2312_CHAR_TO_FREQ_ORDER, GB2312_TABLE_SIZE,
+                         GB2312_TYPICAL_DISTRIBUTION_RATIO)
+from .big5freq import (BIG5_CHAR_TO_FREQ_ORDER, BIG5_TABLE_SIZE,
+                       BIG5_TYPICAL_DISTRIBUTION_RATIO)
+from .jisfreq import (JIS_CHAR_TO_FREQ_ORDER, JIS_TABLE_SIZE,
+                      JIS_TYPICAL_DISTRIBUTION_RATIO)
+
+
+class CharDistributionAnalysis(object):
+    ENOUGH_DATA_THRESHOLD = 1024
+    SURE_YES = 0.99
+    SURE_NO = 0.01
+    MINIMUM_DATA_THRESHOLD = 3
+
+    def __init__(self):
+        # Mapping table to get frequency order from char order (get from
+        # GetOrder())
+        self._char_to_freq_order = None
+        self._table_size = None  # Size of above table
+        # This is a constant value which varies from language to language,
+        # used in calculating confidence.  See
+        # http://www.mozilla.org/projects/intl/UniversalCharsetDetection.html
+        # for further detail.
+        self.typical_distribution_ratio = None
+        self._done = None
+        self._total_chars = None
+        self._freq_chars = None
+        self.reset()
+
+    def reset(self):
+        """reset analyser, clear any state"""
+        # If this flag is set to True, detection is done and conclusion has
+        # been made
+        self._done = False
+        self._total_chars = 0  # Total characters encountered
+        # The number of characters whose frequency order is less than 512
+        self._freq_chars = 0
+
+    def feed(self, char, char_len):
+        """feed a character with known length"""
+        if char_len == 2:
+            # we only care about 2-bytes character in our distribution analysis
+            order = self.get_order(char)
+        else:
+            order = -1
+        if order >= 0:
+            self._total_chars += 1
+            # order is valid
+            if order < self._table_size:
+                if 512 > self._char_to_freq_order[order]:
+                    self._freq_chars += 1
+
+    def get_confidence(self):
+        """return confidence based on existing data"""
+        # if we didn't receive any character in our consideration range,
+        # return negative answer
+        if self._total_chars <= 0 or self._freq_chars <= self.MINIMUM_DATA_THRESHOLD:
+            return self.SURE_NO
+
+        if self._total_chars != self._freq_chars:
+            r = (self._freq_chars / ((self._total_chars - self._freq_chars)
+                 * self.typical_distribution_ratio))
+            if r < self.SURE_YES:
+                return r
+
+        # normalize confidence (we don't want to be 100% sure)
+        return self.SURE_YES
+
+    def got_enough_data(self):
+        # It is not necessary to receive all data to draw conclusion.
+        # For charset detection, certain amount of data is enough
+        return self._total_chars > self.ENOUGH_DATA_THRESHOLD
+
+    def get_order(self, byte_str):
+        # We do not handle characters based on the original encoding string,
+        # but convert this encoding string to a number, here called order.
+        # This allows multiple encodings of a language to share one frequency
+        # table.
+        return -1
+
+
+class EUCTWDistributionAnalysis(CharDistributionAnalysis):
+    def __init__(self):
+        super(EUCTWDistributionAnalysis, self).__init__()
+        self._char_to_freq_order = EUCTW_CHAR_TO_FREQ_ORDER
+        self._table_size = EUCTW_TABLE_SIZE
+        self.typical_distribution_ratio = EUCTW_TYPICAL_DISTRIBUTION_RATIO
+
+    def get_order(self, byte_str):
+        # for euc-TW encoding, we are interested
+        #   first  byte range: 0xc4 -- 0xfe
+        #   second byte range: 0xa1 -- 0xfe
+        # no validation needed here. State machine has done that
+        first_char = byte_str[0]
+        if first_char >= 0xC4:
+            return 94 * (first_char - 0xC4) + byte_str[1] - 0xA1
+        else:
+            return -1
+
+
+class EUCKRDistributionAnalysis(CharDistributionAnalysis):
+    def __init__(self):
+        super(EUCKRDistributionAnalysis, self).__init__()
+        self._char_to_freq_order = EUCKR_CHAR_TO_FREQ_ORDER
+        self._table_size = EUCKR_TABLE_SIZE
+        self.typical_distribution_ratio = EUCKR_TYPICAL_DISTRIBUTION_RATIO
+
+    def get_order(self, byte_str):
+        # for euc-KR encoding, we are interested
+        #   first  byte range: 0xb0 -- 0xfe
+        #   second byte range: 0xa1 -- 0xfe
+        # no validation needed here. State machine has done that
+        first_char = byte_str[0]
+        if first_char >= 0xB0:
+            return 94 * (first_char - 0xB0) + byte_str[1] - 0xA1
+        else:
+            return -1
+
+
+class GB2312DistributionAnalysis(CharDistributionAnalysis):
+    def __init__(self):
+        super(GB2312DistributionAnalysis, self).__init__()
+        self._char_to_freq_order = GB2312_CHAR_TO_FREQ_ORDER
+        self._table_size = GB2312_TABLE_SIZE
+        self.typical_distribution_ratio = GB2312_TYPICAL_DISTRIBUTION_RATIO
+
+    def get_order(self, byte_str):
+        # for GB2312 encoding, we are interested
+        #  first  byte range: 0xb0 -- 0xfe
+        #  second byte range: 0xa1 -- 0xfe
+        # no validation needed here. State machine has done that
+        first_char, second_char = byte_str[0], byte_str[1]
+        if (first_char >= 0xB0) and (second_char >= 0xA1):
+            return 94 * (first_char - 0xB0) + second_char - 0xA1
+        else:
+            return -1
+
+
+class Big5DistributionAnalysis(CharDistributionAnalysis):
+    def __init__(self):
+        super(Big5DistributionAnalysis, self).__init__()
+        self._char_to_freq_order = BIG5_CHAR_TO_FREQ_ORDER
+        self._table_size = BIG5_TABLE_SIZE
+        self.typical_distribution_ratio = BIG5_TYPICAL_DISTRIBUTION_RATIO
+
+    def get_order(self, byte_str):
+        # for big5 encoding, we are interested
+        #   first  byte range: 0xa4 -- 0xfe
+        #   second byte range: 0x40 -- 0x7e , 0xa1 -- 0xfe
+        # no validation needed here. State machine has done that
+        first_char, second_char = byte_str[0], byte_str[1]
+        if first_char >= 0xA4:
+            if second_char >= 0xA1:
+                return 157 * (first_char - 0xA4) + second_char - 0xA1 + 63
+            else:
+                return 157 * (first_char - 0xA4) + second_char - 0x40
+        else:
+            return -1
+
+
+class SJISDistributionAnalysis(CharDistributionAnalysis):
+    def __init__(self):
+        super(SJISDistributionAnalysis, self).__init__()
+        self._char_to_freq_order = JIS_CHAR_TO_FREQ_ORDER
+        self._table_size = JIS_TABLE_SIZE
+        self.typical_distribution_ratio = JIS_TYPICAL_DISTRIBUTION_RATIO
+
+    def get_order(self, byte_str):
+        # for sjis encoding, we are interested
+        #   first  byte range: 0x81 -- 0x9f , 0xe0 -- 0xfe
+        #   second byte range: 0x40 -- 0x7e,  0x81 -- oxfe
+        # no validation needed here. State machine has done that
+        first_char, second_char = byte_str[0], byte_str[1]
+        if (first_char >= 0x81) and (first_char <= 0x9F):
+            order = 188 * (first_char - 0x81)
+        elif (first_char >= 0xE0) and (first_char <= 0xEF):
+            order = 188 * (first_char - 0xE0 + 31)
+        else:
+            return -1
+        order = order + second_char - 0x40
+        if second_char > 0x7F:
+            order = -1
+        return order
+
+
+class EUCJPDistributionAnalysis(CharDistributionAnalysis):
+    def __init__(self):
+        super(EUCJPDistributionAnalysis, self).__init__()
+        self._char_to_freq_order = JIS_CHAR_TO_FREQ_ORDER
+        self._table_size = JIS_TABLE_SIZE
+        self.typical_distribution_ratio = JIS_TYPICAL_DISTRIBUTION_RATIO
+
+    def get_order(self, byte_str):
+        # for euc-JP encoding, we are interested
+        #   first  byte range: 0xa0 -- 0xfe
+        #   second byte range: 0xa1 -- 0xfe
+        # no validation needed here. State machine has done that
+        char = byte_str[0]
+        if char >= 0xA0:
+            return 94 * (char - 0xA1) + byte_str[1] - 0xa1
+        else:
+            return -1
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/charsetgroupprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/charsetgroupprober.py
new file mode 100644
index 0000000..8b3738e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/charsetgroupprober.py
@@ -0,0 +1,106 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .enums import ProbingState
+from .charsetprober import CharSetProber
+
+
+class CharSetGroupProber(CharSetProber):
+    def __init__(self, lang_filter=None):
+        super(CharSetGroupProber, self).__init__(lang_filter=lang_filter)
+        self._active_num = 0
+        self.probers = []
+        self._best_guess_prober = None
+
+    def reset(self):
+        super(CharSetGroupProber, self).reset()
+        self._active_num = 0
+        for prober in self.probers:
+            if prober:
+                prober.reset()
+                prober.active = True
+                self._active_num += 1
+        self._best_guess_prober = None
+
+    @property
+    def charset_name(self):
+        if not self._best_guess_prober:
+            self.get_confidence()
+            if not self._best_guess_prober:
+                return None
+        return self._best_guess_prober.charset_name
+
+    @property
+    def language(self):
+        if not self._best_guess_prober:
+            self.get_confidence()
+            if not self._best_guess_prober:
+                return None
+        return self._best_guess_prober.language
+
+    def feed(self, byte_str):
+        for prober in self.probers:
+            if not prober:
+                continue
+            if not prober.active:
+                continue
+            state = prober.feed(byte_str)
+            if not state:
+                continue
+            if state == ProbingState.FOUND_IT:
+                self._best_guess_prober = prober
+                return self.state
+            elif state == ProbingState.NOT_ME:
+                prober.active = False
+                self._active_num -= 1
+                if self._active_num <= 0:
+                    self._state = ProbingState.NOT_ME
+                    return self.state
+        return self.state
+
+    def get_confidence(self):
+        state = self.state
+        if state == ProbingState.FOUND_IT:
+            return 0.99
+        elif state == ProbingState.NOT_ME:
+            return 0.01
+        best_conf = 0.0
+        self._best_guess_prober = None
+        for prober in self.probers:
+            if not prober:
+                continue
+            if not prober.active:
+                self.logger.debug('%s not active', prober.charset_name)
+                continue
+            conf = prober.get_confidence()
+            self.logger.debug('%s %s confidence = %s', prober.charset_name, prober.language, conf)
+            if best_conf < conf:
+                best_conf = conf
+                self._best_guess_prober = prober
+        if not self._best_guess_prober:
+            return 0.0
+        return best_conf
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/charsetprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/charsetprober.py
new file mode 100644
index 0000000..eac4e59
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/charsetprober.py
@@ -0,0 +1,145 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Universal charset detector code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 2001
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#   Shy Shalom - original C code
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+import logging
+import re
+
+from .enums import ProbingState
+
+
+class CharSetProber(object):
+
+    SHORTCUT_THRESHOLD = 0.95
+
+    def __init__(self, lang_filter=None):
+        self._state = None
+        self.lang_filter = lang_filter
+        self.logger = logging.getLogger(__name__)
+
+    def reset(self):
+        self._state = ProbingState.DETECTING
+
+    @property
+    def charset_name(self):
+        return None
+
+    def feed(self, buf):
+        pass
+
+    @property
+    def state(self):
+        return self._state
+
+    def get_confidence(self):
+        return 0.0
+
+    @staticmethod
+    def filter_high_byte_only(buf):
+        buf = re.sub(b'([\x00-\x7F])+', b' ', buf)
+        return buf
+
+    @staticmethod
+    def filter_international_words(buf):
+        """
+        We define three types of bytes:
+        alphabet: english alphabets [a-zA-Z]
+        international: international characters [\x80-\xFF]
+        marker: everything else [^a-zA-Z\x80-\xFF]
+
+        The input buffer can be thought to contain a series of words delimited
+        by markers. This function works to filter all words that contain at
+        least one international character. All contiguous sequences of markers
+        are replaced by a single space ascii character.
+
+        This filter applies to all scripts which do not use English characters.
+        """
+        filtered = bytearray()
+
+        # This regex expression filters out only words that have at-least one
+        # international character. The word may include one marker character at
+        # the end.
+        words = re.findall(b'[a-zA-Z]*[\x80-\xFF]+[a-zA-Z]*[^a-zA-Z\x80-\xFF]?',
+                           buf)
+
+        for word in words:
+            filtered.extend(word[:-1])
+
+            # If the last character in the word is a marker, replace it with a
+            # space as markers shouldn't affect our analysis (they are used
+            # similarly across all languages and may thus have similar
+            # frequencies).
+            last_char = word[-1:]
+            if not last_char.isalpha() and last_char < b'\x80':
+                last_char = b' '
+            filtered.extend(last_char)
+
+        return filtered
+
+    @staticmethod
+    def filter_with_english_letters(buf):
+        """
+        Returns a copy of ``buf`` that retains only the sequences of English
+        alphabet and high byte characters that are not between <> characters.
+        Also retains English alphabet and high byte characters immediately
+        before occurrences of >.
+
+        This filter can be applied to all scripts which contain both English
+        characters and extended ASCII characters, but is currently only used by
+        ``Latin1Prober``.
+        """
+        filtered = bytearray()
+        in_tag = False
+        prev = 0
+
+        for curr in range(len(buf)):
+            # Slice here to get bytes instead of an int with Python 3
+            buf_char = buf[curr:curr + 1]
+            # Check if we're coming out of or entering an HTML tag
+            if buf_char == b'>':
+                in_tag = False
+            elif buf_char == b'<':
+                in_tag = True
+
+            # If current character is not extended-ASCII and not alphabetic...
+            if buf_char < b'\x80' and not buf_char.isalpha():
+                # ...and we're not in a tag
+                if curr > prev and not in_tag:
+                    # Keep everything after last non-extended-ASCII,
+                    # non-alphabetic character
+                    filtered.extend(buf[prev:curr])
+                    # Output a space to delimit stretch we kept
+                    filtered.extend(b' ')
+                prev = curr + 1
+
+        # If we're not in a tag...
+        if not in_tag:
+            # Keep everything after last non-extended-ASCII, non-alphabetic
+            # character
+            filtered.extend(buf[prev:])
+
+        return filtered
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/cli/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/cli/__init__.py
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/cli/__init__.py
@@ -0,0 +1 @@
+
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/cli/chardetect.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/cli/chardetect.py
new file mode 100644
index 0000000..c61136b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/cli/chardetect.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+"""
+Script which takes one or more file paths and reports on their detected
+encodings
+
+Example::
+
+    % chardetect somefile someotherfile
+    somefile: windows-1252 with confidence 0.5
+    someotherfile: ascii with confidence 1.0
+
+If no paths are provided, it takes its input from stdin.
+
+"""
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+import argparse
+import sys
+
+from pip._vendor.chardet import __version__
+from pip._vendor.chardet.compat import PY2
+from pip._vendor.chardet.universaldetector import UniversalDetector
+
+
+def description_of(lines, name='stdin'):
+    """
+    Return a string describing the probable encoding of a file or
+    list of strings.
+
+    :param lines: The lines to get the encoding of.
+    :type lines: Iterable of bytes
+    :param name: Name of file or collection of lines
+    :type name: str
+    """
+    u = UniversalDetector()
+    for line in lines:
+        line = bytearray(line)
+        u.feed(line)
+        # shortcut out of the loop to save reading further - particularly useful if we read a BOM.
+        if u.done:
+            break
+    u.close()
+    result = u.result
+    if PY2:
+        name = name.decode(sys.getfilesystemencoding(), 'ignore')
+    if result['encoding']:
+        return '{0}: {1} with confidence {2}'.format(name, result['encoding'],
+                                                     result['confidence'])
+    else:
+        return '{0}: no result'.format(name)
+
+
+def main(argv=None):
+    """
+    Handles command line arguments and gets things started.
+
+    :param argv: List of arguments, as if specified on the command-line.
+                 If None, ``sys.argv[1:]`` is used instead.
+    :type argv: list of str
+    """
+    # Get command line arguments
+    parser = argparse.ArgumentParser(
+        description="Takes one or more file paths and reports their detected \
+                     encodings")
+    parser.add_argument('input',
+                        help='File whose encoding we would like to determine. \
+                              (default: stdin)',
+                        type=argparse.FileType('rb'), nargs='*',
+                        default=[sys.stdin if PY2 else sys.stdin.buffer])
+    parser.add_argument('--version', action='version',
+                        version='%(prog)s {0}'.format(__version__))
+    args = parser.parse_args(argv)
+
+    for f in args.input:
+        if f.isatty():
+            print("You are running chardetect interactively. Press " +
+                  "CTRL-D twice at the start of a blank line to signal the " +
+                  "end of your input. If you want help, run chardetect " +
+                  "--help\n", file=sys.stderr)
+        print(description_of(f, f.name))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/codingstatemachine.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/codingstatemachine.py
new file mode 100644
index 0000000..68fba44
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/codingstatemachine.py
@@ -0,0 +1,88 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+import logging
+
+from .enums import MachineState
+
+
+class CodingStateMachine(object):
+    """
+    A state machine to verify a byte sequence for a particular encoding. For
+    each byte the detector receives, it will feed that byte to every active
+    state machine available, one byte at a time. The state machine changes its
+    state based on its previous state and the byte it receives. There are 3
+    states in a state machine that are of interest to an auto-detector:
+
+    START state: This is the state to start with, or a legal byte sequence
+                 (i.e. a valid code point) for character has been identified.
+
+    ME state:  This indicates that the state machine identified a byte sequence
+               that is specific to the charset it is designed for and that
+               there is no other possible encoding which can contain this byte
+               sequence. This will to lead to an immediate positive answer for
+               the detector.
+
+    ERROR state: This indicates the state machine identified an illegal byte
+                 sequence for that encoding. This will lead to an immediate
+                 negative answer for this encoding. Detector will exclude this
+                 encoding from consideration from here on.
+    """
+    def __init__(self, sm):
+        self._model = sm
+        self._curr_byte_pos = 0
+        self._curr_char_len = 0
+        self._curr_state = None
+        self.logger = logging.getLogger(__name__)
+        self.reset()
+
+    def reset(self):
+        self._curr_state = MachineState.START
+
+    def next_state(self, c):
+        # for each byte we get its class
+        # if it is first byte, we also get byte length
+        byte_class = self._model['class_table'][c]
+        if self._curr_state == MachineState.START:
+            self._curr_byte_pos = 0
+            self._curr_char_len = self._model['char_len_table'][byte_class]
+        # from byte's class and state_table, we get its next state
+        curr_state = (self._curr_state * self._model['class_factor']
+                      + byte_class)
+        self._curr_state = self._model['state_table'][curr_state]
+        self._curr_byte_pos += 1
+        return self._curr_state
+
+    def get_current_charlen(self):
+        return self._curr_char_len
+
+    def get_coding_state_machine(self):
+        return self._model['name']
+
+    @property
+    def language(self):
+        return self._model['language']
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/compat.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/compat.py
new file mode 100644
index 0000000..ddd7468
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/compat.py
@@ -0,0 +1,34 @@
+######################## BEGIN LICENSE BLOCK ########################
+# Contributor(s):
+#   Dan Blanchard
+#   Ian Cordasco
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+import sys
+
+
+if sys.version_info < (3, 0):
+    PY2 = True
+    PY3 = False
+    base_str = (str, unicode)
+    text_type = unicode
+else:
+    PY2 = False
+    PY3 = True
+    base_str = (bytes, str)
+    text_type = str
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/cp949prober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/cp949prober.py
new file mode 100644
index 0000000..efd793a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/cp949prober.py
@@ -0,0 +1,49 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .chardistribution import EUCKRDistributionAnalysis
+from .codingstatemachine import CodingStateMachine
+from .mbcharsetprober import MultiByteCharSetProber
+from .mbcssm import CP949_SM_MODEL
+
+
+class CP949Prober(MultiByteCharSetProber):
+    def __init__(self):
+        super(CP949Prober, self).__init__()
+        self.coding_sm = CodingStateMachine(CP949_SM_MODEL)
+        # NOTE: CP949 is a superset of EUC-KR, so the distribution should be
+        #       not different.
+        self.distribution_analyzer = EUCKRDistributionAnalysis()
+        self.reset()
+
+    @property
+    def charset_name(self):
+        return "CP949"
+
+    @property
+    def language(self):
+        return "Korean"
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/enums.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/enums.py
new file mode 100644
index 0000000..0451207
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/enums.py
@@ -0,0 +1,76 @@
+"""
+All of the Enums that are used throughout the chardet package.
+
+:author: Dan Blanchard (dan.blanchard@gmail.com)
+"""
+
+
+class InputState(object):
+    """
+    This enum represents the different states a universal detector can be in.
+    """
+    PURE_ASCII = 0
+    ESC_ASCII = 1
+    HIGH_BYTE = 2
+
+
+class LanguageFilter(object):
+    """
+    This enum represents the different language filters we can apply to a
+    ``UniversalDetector``.
+    """
+    CHINESE_SIMPLIFIED = 0x01
+    CHINESE_TRADITIONAL = 0x02
+    JAPANESE = 0x04
+    KOREAN = 0x08
+    NON_CJK = 0x10
+    ALL = 0x1F
+    CHINESE = CHINESE_SIMPLIFIED | CHINESE_TRADITIONAL
+    CJK = CHINESE | JAPANESE | KOREAN
+
+
+class ProbingState(object):
+    """
+    This enum represents the different states a prober can be in.
+    """
+    DETECTING = 0
+    FOUND_IT = 1
+    NOT_ME = 2
+
+
+class MachineState(object):
+    """
+    This enum represents the different states a state machine can be in.
+    """
+    START = 0
+    ERROR = 1
+    ITS_ME = 2
+
+
+class SequenceLikelihood(object):
+    """
+    This enum represents the likelihood of a character following the previous one.
+    """
+    NEGATIVE = 0
+    UNLIKELY = 1
+    LIKELY = 2
+    POSITIVE = 3
+
+    @classmethod
+    def get_num_categories(cls):
+        """:returns: The number of likelihood categories in the enum."""
+        return 4
+
+
+class CharacterCategory(object):
+    """
+    This enum represents the different categories language models for
+    ``SingleByteCharsetProber`` put characters into.
+
+    Anything less than CONTROL is considered a letter.
+    """
+    UNDEFINED = 255
+    LINE_BREAK = 254
+    SYMBOL = 253
+    DIGIT = 252
+    CONTROL = 251
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/escprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/escprober.py
new file mode 100644
index 0000000..c70493f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/escprober.py
@@ -0,0 +1,101 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .charsetprober import CharSetProber
+from .codingstatemachine import CodingStateMachine
+from .enums import LanguageFilter, ProbingState, MachineState
+from .escsm import (HZ_SM_MODEL, ISO2022CN_SM_MODEL, ISO2022JP_SM_MODEL,
+                    ISO2022KR_SM_MODEL)
+
+
+class EscCharSetProber(CharSetProber):
+    """
+    This CharSetProber uses a "code scheme" approach for detecting encodings,
+    whereby easily recognizable escape or shift sequences are relied on to
+    identify these encodings.
+    """
+
+    def __init__(self, lang_filter=None):
+        super(EscCharSetProber, self).__init__(lang_filter=lang_filter)
+        self.coding_sm = []
+        if self.lang_filter & LanguageFilter.CHINESE_SIMPLIFIED:
+            self.coding_sm.append(CodingStateMachine(HZ_SM_MODEL))
+            self.coding_sm.append(CodingStateMachine(ISO2022CN_SM_MODEL))
+        if self.lang_filter & LanguageFilter.JAPANESE:
+            self.coding_sm.append(CodingStateMachine(ISO2022JP_SM_MODEL))
+        if self.lang_filter & LanguageFilter.KOREAN:
+            self.coding_sm.append(CodingStateMachine(ISO2022KR_SM_MODEL))
+        self.active_sm_count = None
+        self._detected_charset = None
+        self._detected_language = None
+        self._state = None
+        self.reset()
+
+    def reset(self):
+        super(EscCharSetProber, self).reset()
+        for coding_sm in self.coding_sm:
+            if not coding_sm:
+                continue
+            coding_sm.active = True
+            coding_sm.reset()
+        self.active_sm_count = len(self.coding_sm)
+        self._detected_charset = None
+        self._detected_language = None
+
+    @property
+    def charset_name(self):
+        return self._detected_charset
+
+    @property
+    def language(self):
+        return self._detected_language
+
+    def get_confidence(self):
+        if self._detected_charset:
+            return 0.99
+        else:
+            return 0.00
+
+    def feed(self, byte_str):
+        for c in byte_str:
+            for coding_sm in self.coding_sm:
+                if not coding_sm or not coding_sm.active:
+                    continue
+                coding_state = coding_sm.next_state(c)
+                if coding_state == MachineState.ERROR:
+                    coding_sm.active = False
+                    self.active_sm_count -= 1
+                    if self.active_sm_count <= 0:
+                        self._state = ProbingState.NOT_ME
+                        return self.state
+                elif coding_state == MachineState.ITS_ME:
+                    self._state = ProbingState.FOUND_IT
+                    self._detected_charset = coding_sm.get_coding_state_machine()
+                    self._detected_language = coding_sm.language
+                    return self.state
+
+        return self.state
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/escsm.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/escsm.py
new file mode 100644
index 0000000..0069523
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/escsm.py
@@ -0,0 +1,246 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .enums import MachineState
+
+HZ_CLS = (
+1,0,0,0,0,0,0,0,  # 00 - 07
+0,0,0,0,0,0,0,0,  # 08 - 0f
+0,0,0,0,0,0,0,0,  # 10 - 17
+0,0,0,1,0,0,0,0,  # 18 - 1f
+0,0,0,0,0,0,0,0,  # 20 - 27
+0,0,0,0,0,0,0,0,  # 28 - 2f
+0,0,0,0,0,0,0,0,  # 30 - 37
+0,0,0,0,0,0,0,0,  # 38 - 3f
+0,0,0,0,0,0,0,0,  # 40 - 47
+0,0,0,0,0,0,0,0,  # 48 - 4f
+0,0,0,0,0,0,0,0,  # 50 - 57
+0,0,0,0,0,0,0,0,  # 58 - 5f
+0,0,0,0,0,0,0,0,  # 60 - 67
+0,0,0,0,0,0,0,0,  # 68 - 6f
+0,0,0,0,0,0,0,0,  # 70 - 77
+0,0,0,4,0,5,2,0,  # 78 - 7f
+1,1,1,1,1,1,1,1,  # 80 - 87
+1,1,1,1,1,1,1,1,  # 88 - 8f
+1,1,1,1,1,1,1,1,  # 90 - 97
+1,1,1,1,1,1,1,1,  # 98 - 9f
+1,1,1,1,1,1,1,1,  # a0 - a7
+1,1,1,1,1,1,1,1,  # a8 - af
+1,1,1,1,1,1,1,1,  # b0 - b7
+1,1,1,1,1,1,1,1,  # b8 - bf
+1,1,1,1,1,1,1,1,  # c0 - c7
+1,1,1,1,1,1,1,1,  # c8 - cf
+1,1,1,1,1,1,1,1,  # d0 - d7
+1,1,1,1,1,1,1,1,  # d8 - df
+1,1,1,1,1,1,1,1,  # e0 - e7
+1,1,1,1,1,1,1,1,  # e8 - ef
+1,1,1,1,1,1,1,1,  # f0 - f7
+1,1,1,1,1,1,1,1,  # f8 - ff
+)
+
+HZ_ST = (
+MachineState.START,MachineState.ERROR,     3,MachineState.START,MachineState.START,MachineState.START,MachineState.ERROR,MachineState.ERROR,# 00-07
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,# 08-0f
+MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START,     4,MachineState.ERROR,# 10-17
+     5,MachineState.ERROR,     6,MachineState.ERROR,     5,     5,     4,MachineState.ERROR,# 18-1f
+     4,MachineState.ERROR,     4,     4,     4,MachineState.ERROR,     4,MachineState.ERROR,# 20-27
+     4,MachineState.ITS_ME,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,# 28-2f
+)
+
+HZ_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0)
+
+HZ_SM_MODEL = {'class_table': HZ_CLS,
+               'class_factor': 6,
+               'state_table': HZ_ST,
+               'char_len_table': HZ_CHAR_LEN_TABLE,
+               'name': "HZ-GB-2312",
+               'language': 'Chinese'}
+
+ISO2022CN_CLS = (
+2,0,0,0,0,0,0,0,  # 00 - 07
+0,0,0,0,0,0,0,0,  # 08 - 0f
+0,0,0,0,0,0,0,0,  # 10 - 17
+0,0,0,1,0,0,0,0,  # 18 - 1f
+0,0,0,0,0,0,0,0,  # 20 - 27
+0,3,0,0,0,0,0,0,  # 28 - 2f
+0,0,0,0,0,0,0,0,  # 30 - 37
+0,0,0,0,0,0,0,0,  # 38 - 3f
+0,0,0,4,0,0,0,0,  # 40 - 47
+0,0,0,0,0,0,0,0,  # 48 - 4f
+0,0,0,0,0,0,0,0,  # 50 - 57
+0,0,0,0,0,0,0,0,  # 58 - 5f
+0,0,0,0,0,0,0,0,  # 60 - 67
+0,0,0,0,0,0,0,0,  # 68 - 6f
+0,0,0,0,0,0,0,0,  # 70 - 77
+0,0,0,0,0,0,0,0,  # 78 - 7f
+2,2,2,2,2,2,2,2,  # 80 - 87
+2,2,2,2,2,2,2,2,  # 88 - 8f
+2,2,2,2,2,2,2,2,  # 90 - 97
+2,2,2,2,2,2,2,2,  # 98 - 9f
+2,2,2,2,2,2,2,2,  # a0 - a7
+2,2,2,2,2,2,2,2,  # a8 - af
+2,2,2,2,2,2,2,2,  # b0 - b7
+2,2,2,2,2,2,2,2,  # b8 - bf
+2,2,2,2,2,2,2,2,  # c0 - c7
+2,2,2,2,2,2,2,2,  # c8 - cf
+2,2,2,2,2,2,2,2,  # d0 - d7
+2,2,2,2,2,2,2,2,  # d8 - df
+2,2,2,2,2,2,2,2,  # e0 - e7
+2,2,2,2,2,2,2,2,  # e8 - ef
+2,2,2,2,2,2,2,2,  # f0 - f7
+2,2,2,2,2,2,2,2,  # f8 - ff
+)
+
+ISO2022CN_ST = (
+MachineState.START,     3,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,# 00-07
+MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 08-0f
+MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,# 10-17
+MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     4,MachineState.ERROR,# 18-1f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 20-27
+     5,     6,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 28-2f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 30-37
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,MachineState.START,# 38-3f
+)
+
+ISO2022CN_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0, 0, 0, 0)
+
+ISO2022CN_SM_MODEL = {'class_table': ISO2022CN_CLS,
+                      'class_factor': 9,
+                      'state_table': ISO2022CN_ST,
+                      'char_len_table': ISO2022CN_CHAR_LEN_TABLE,
+                      'name': "ISO-2022-CN",
+                      'language': 'Chinese'}
+
+ISO2022JP_CLS = (
+2,0,0,0,0,0,0,0,  # 00 - 07
+0,0,0,0,0,0,2,2,  # 08 - 0f
+0,0,0,0,0,0,0,0,  # 10 - 17
+0,0,0,1,0,0,0,0,  # 18 - 1f
+0,0,0,0,7,0,0,0,  # 20 - 27
+3,0,0,0,0,0,0,0,  # 28 - 2f
+0,0,0,0,0,0,0,0,  # 30 - 37
+0,0,0,0,0,0,0,0,  # 38 - 3f
+6,0,4,0,8,0,0,0,  # 40 - 47
+0,9,5,0,0,0,0,0,  # 48 - 4f
+0,0,0,0,0,0,0,0,  # 50 - 57
+0,0,0,0,0,0,0,0,  # 58 - 5f
+0,0,0,0,0,0,0,0,  # 60 - 67
+0,0,0,0,0,0,0,0,  # 68 - 6f
+0,0,0,0,0,0,0,0,  # 70 - 77
+0,0,0,0,0,0,0,0,  # 78 - 7f
+2,2,2,2,2,2,2,2,  # 80 - 87
+2,2,2,2,2,2,2,2,  # 88 - 8f
+2,2,2,2,2,2,2,2,  # 90 - 97
+2,2,2,2,2,2,2,2,  # 98 - 9f
+2,2,2,2,2,2,2,2,  # a0 - a7
+2,2,2,2,2,2,2,2,  # a8 - af
+2,2,2,2,2,2,2,2,  # b0 - b7
+2,2,2,2,2,2,2,2,  # b8 - bf
+2,2,2,2,2,2,2,2,  # c0 - c7
+2,2,2,2,2,2,2,2,  # c8 - cf
+2,2,2,2,2,2,2,2,  # d0 - d7
+2,2,2,2,2,2,2,2,  # d8 - df
+2,2,2,2,2,2,2,2,  # e0 - e7
+2,2,2,2,2,2,2,2,  # e8 - ef
+2,2,2,2,2,2,2,2,  # f0 - f7
+2,2,2,2,2,2,2,2,  # f8 - ff
+)
+
+ISO2022JP_ST = (
+MachineState.START,     3,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,# 00-07
+MachineState.START,MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 08-0f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,# 10-17
+MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,# 18-1f
+MachineState.ERROR,     5,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     4,MachineState.ERROR,MachineState.ERROR,# 20-27
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     6,MachineState.ITS_ME,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,# 28-2f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,# 30-37
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 38-3f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,MachineState.START,MachineState.START,# 40-47
+)
+
+ISO2022JP_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+
+ISO2022JP_SM_MODEL = {'class_table': ISO2022JP_CLS,
+                      'class_factor': 10,
+                      'state_table': ISO2022JP_ST,
+                      'char_len_table': ISO2022JP_CHAR_LEN_TABLE,
+                      'name': "ISO-2022-JP",
+                      'language': 'Japanese'}
+
+ISO2022KR_CLS = (
+2,0,0,0,0,0,0,0,  # 00 - 07
+0,0,0,0,0,0,0,0,  # 08 - 0f
+0,0,0,0,0,0,0,0,  # 10 - 17
+0,0,0,1,0,0,0,0,  # 18 - 1f
+0,0,0,0,3,0,0,0,  # 20 - 27
+0,4,0,0,0,0,0,0,  # 28 - 2f
+0,0,0,0,0,0,0,0,  # 30 - 37
+0,0,0,0,0,0,0,0,  # 38 - 3f
+0,0,0,5,0,0,0,0,  # 40 - 47
+0,0,0,0,0,0,0,0,  # 48 - 4f
+0,0,0,0,0,0,0,0,  # 50 - 57
+0,0,0,0,0,0,0,0,  # 58 - 5f
+0,0,0,0,0,0,0,0,  # 60 - 67
+0,0,0,0,0,0,0,0,  # 68 - 6f
+0,0,0,0,0,0,0,0,  # 70 - 77
+0,0,0,0,0,0,0,0,  # 78 - 7f
+2,2,2,2,2,2,2,2,  # 80 - 87
+2,2,2,2,2,2,2,2,  # 88 - 8f
+2,2,2,2,2,2,2,2,  # 90 - 97
+2,2,2,2,2,2,2,2,  # 98 - 9f
+2,2,2,2,2,2,2,2,  # a0 - a7
+2,2,2,2,2,2,2,2,  # a8 - af
+2,2,2,2,2,2,2,2,  # b0 - b7
+2,2,2,2,2,2,2,2,  # b8 - bf
+2,2,2,2,2,2,2,2,  # c0 - c7
+2,2,2,2,2,2,2,2,  # c8 - cf
+2,2,2,2,2,2,2,2,  # d0 - d7
+2,2,2,2,2,2,2,2,  # d8 - df
+2,2,2,2,2,2,2,2,  # e0 - e7
+2,2,2,2,2,2,2,2,  # e8 - ef
+2,2,2,2,2,2,2,2,  # f0 - f7
+2,2,2,2,2,2,2,2,  # f8 - ff
+)
+
+ISO2022KR_ST = (
+MachineState.START,     3,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.ERROR,MachineState.ERROR,# 00-07
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,# 08-0f
+MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     4,MachineState.ERROR,MachineState.ERROR,# 10-17
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     5,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 18-1f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.START,MachineState.START,MachineState.START,MachineState.START,# 20-27
+)
+
+ISO2022KR_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0)
+
+ISO2022KR_SM_MODEL = {'class_table': ISO2022KR_CLS,
+                      'class_factor': 6,
+                      'state_table': ISO2022KR_ST,
+                      'char_len_table': ISO2022KR_CHAR_LEN_TABLE,
+                      'name': "ISO-2022-KR",
+                      'language': 'Korean'}
+
+
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/eucjpprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/eucjpprober.py
new file mode 100644
index 0000000..20ce8f7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/eucjpprober.py
@@ -0,0 +1,92 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .enums import ProbingState, MachineState
+from .mbcharsetprober import MultiByteCharSetProber
+from .codingstatemachine import CodingStateMachine
+from .chardistribution import EUCJPDistributionAnalysis
+from .jpcntx import EUCJPContextAnalysis
+from .mbcssm import EUCJP_SM_MODEL
+
+
+class EUCJPProber(MultiByteCharSetProber):
+    def __init__(self):
+        super(EUCJPProber, self).__init__()
+        self.coding_sm = CodingStateMachine(EUCJP_SM_MODEL)
+        self.distribution_analyzer = EUCJPDistributionAnalysis()
+        self.context_analyzer = EUCJPContextAnalysis()
+        self.reset()
+
+    def reset(self):
+        super(EUCJPProber, self).reset()
+        self.context_analyzer.reset()
+
+    @property
+    def charset_name(self):
+        return "EUC-JP"
+
+    @property
+    def language(self):
+        return "Japanese"
+
+    def feed(self, byte_str):
+        for i in range(len(byte_str)):
+            # PY3K: byte_str is a byte array, so byte_str[i] is an int, not a byte
+            coding_state = self.coding_sm.next_state(byte_str[i])
+            if coding_state == MachineState.ERROR:
+                self.logger.debug('%s %s prober hit error at byte %s',
+                                  self.charset_name, self.language, i)
+                self._state = ProbingState.NOT_ME
+                break
+            elif coding_state == MachineState.ITS_ME:
+                self._state = ProbingState.FOUND_IT
+                break
+            elif coding_state == MachineState.START:
+                char_len = self.coding_sm.get_current_charlen()
+                if i == 0:
+                    self._last_char[1] = byte_str[0]
+                    self.context_analyzer.feed(self._last_char, char_len)
+                    self.distribution_analyzer.feed(self._last_char, char_len)
+                else:
+                    self.context_analyzer.feed(byte_str[i - 1:i + 1],
+                                                char_len)
+                    self.distribution_analyzer.feed(byte_str[i - 1:i + 1],
+                                                     char_len)
+
+        self._last_char[0] = byte_str[-1]
+
+        if self.state == ProbingState.DETECTING:
+            if (self.context_analyzer.got_enough_data() and
+               (self.get_confidence() > self.SHORTCUT_THRESHOLD)):
+                self._state = ProbingState.FOUND_IT
+
+        return self.state
+
+    def get_confidence(self):
+        context_conf = self.context_analyzer.get_confidence()
+        distrib_conf = self.distribution_analyzer.get_confidence()
+        return max(context_conf, distrib_conf)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euckrfreq.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euckrfreq.py
new file mode 100644
index 0000000..b68078c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euckrfreq.py
@@ -0,0 +1,195 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# Sampling from about 20M text materials include literature and computer technology
+
+# 128  --> 0.79
+# 256  --> 0.92
+# 512  --> 0.986
+# 1024 --> 0.99944
+# 2048 --> 0.99999
+#
+# Idea Distribution Ratio = 0.98653 / (1-0.98653) = 73.24
+# Random Distribution Ration = 512 / (2350-512) = 0.279.
+#
+# Typical Distribution Ratio
+
+EUCKR_TYPICAL_DISTRIBUTION_RATIO = 6.0
+
+EUCKR_TABLE_SIZE = 2352
+
+# Char to FreqOrder table ,
+EUCKR_CHAR_TO_FREQ_ORDER = (
+  13, 130, 120,1396, 481,1719,1720, 328, 609, 212,1721, 707, 400, 299,1722,  87,
+1397,1723, 104, 536,1117,1203,1724,1267, 685,1268, 508,1725,1726,1727,1728,1398,
+1399,1729,1730,1731, 141, 621, 326,1057, 368,1732, 267, 488,  20,1733,1269,1734,
+ 945,1400,1735,  47, 904,1270,1736,1737, 773, 248,1738, 409, 313, 786, 429,1739,
+ 116, 987, 813,1401, 683,  75,1204, 145,1740,1741,1742,1743,  16, 847, 667, 622,
+ 708,1744,1745,1746, 966, 787, 304, 129,1747,  60, 820, 123, 676,1748,1749,1750,
+1751, 617,1752, 626,1753,1754,1755,1756, 653,1757,1758,1759,1760,1761,1762, 856,
+ 344,1763,1764,1765,1766,  89, 401, 418, 806, 905, 848,1767,1768,1769, 946,1205,
+ 709,1770,1118,1771, 241,1772,1773,1774,1271,1775, 569,1776, 999,1777,1778,1779,
+1780, 337, 751,1058,  28, 628, 254,1781, 177, 906, 270, 349, 891,1079,1782,  19,
+1783, 379,1784, 315,1785, 629, 754,1402, 559,1786, 636, 203,1206,1787, 710, 567,
+1788, 935, 814,1789,1790,1207, 766, 528,1791,1792,1208,1793,1794,1795,1796,1797,
+1403,1798,1799, 533,1059,1404,1405,1156,1406, 936, 884,1080,1800, 351,1801,1802,
+1803,1804,1805, 801,1806,1807,1808,1119,1809,1157, 714, 474,1407,1810, 298, 899,
+ 885,1811,1120, 802,1158,1812, 892,1813,1814,1408, 659,1815,1816,1121,1817,1818,
+1819,1820,1821,1822, 319,1823, 594, 545,1824, 815, 937,1209,1825,1826, 573,1409,
+1022,1827,1210,1828,1829,1830,1831,1832,1833, 556, 722, 807,1122,1060,1834, 697,
+1835, 900, 557, 715,1836,1410, 540,1411, 752,1159, 294, 597,1211, 976, 803, 770,
+1412,1837,1838,  39, 794,1413, 358,1839, 371, 925,1840, 453, 661, 788, 531, 723,
+ 544,1023,1081, 869,  91,1841, 392, 430, 790, 602,1414, 677,1082, 457,1415,1416,
+1842,1843, 475, 327,1024,1417, 795, 121,1844, 733, 403,1418,1845,1846,1847, 300,
+ 119, 711,1212, 627,1848,1272, 207,1849,1850, 796,1213, 382,1851, 519,1852,1083,
+ 893,1853,1854,1855, 367, 809, 487, 671,1856, 663,1857,1858, 956, 471, 306, 857,
+1859,1860,1160,1084,1861,1862,1863,1864,1865,1061,1866,1867,1868,1869,1870,1871,
+ 282,  96, 574,1872, 502,1085,1873,1214,1874, 907,1875,1876, 827, 977,1419,1420,
+1421, 268,1877,1422,1878,1879,1880, 308,1881,   2, 537,1882,1883,1215,1884,1885,
+ 127, 791,1886,1273,1423,1887,  34, 336, 404, 643,1888, 571, 654, 894, 840,1889,
+   0, 886,1274, 122, 575, 260, 908, 938,1890,1275, 410, 316,1891,1892, 100,1893,
+1894,1123,  48,1161,1124,1025,1895, 633, 901,1276,1896,1897, 115, 816,1898, 317,
+1899, 694,1900, 909, 734,1424, 572, 866,1425, 691,  85, 524,1010, 543, 394, 841,
+1901,1902,1903,1026,1904,1905,1906,1907,1908,1909,  30, 451, 651, 988, 310,1910,
+1911,1426, 810,1216,  93,1912,1913,1277,1217,1914, 858, 759,  45,  58, 181, 610,
+ 269,1915,1916, 131,1062, 551, 443,1000, 821,1427, 957, 895,1086,1917,1918, 375,
+1919, 359,1920, 687,1921, 822,1922, 293,1923,1924,  40, 662, 118, 692,  29, 939,
+ 887, 640, 482, 174,1925,  69,1162, 728,1428, 910,1926,1278,1218,1279, 386, 870,
+ 217, 854,1163, 823,1927,1928,1929,1930, 834,1931,  78,1932, 859,1933,1063,1934,
+1935,1936,1937, 438,1164, 208, 595,1938,1939,1940,1941,1219,1125,1942, 280, 888,
+1429,1430,1220,1431,1943,1944,1945,1946,1947,1280, 150, 510,1432,1948,1949,1950,
+1951,1952,1953,1954,1011,1087,1955,1433,1043,1956, 881,1957, 614, 958,1064,1065,
+1221,1958, 638,1001, 860, 967, 896,1434, 989, 492, 553,1281,1165,1959,1282,1002,
+1283,1222,1960,1961,1962,1963,  36, 383, 228, 753, 247, 454,1964, 876, 678,1965,
+1966,1284, 126, 464, 490, 835, 136, 672, 529, 940,1088,1435, 473,1967,1968, 467,
+  50, 390, 227, 587, 279, 378, 598, 792, 968, 240, 151, 160, 849, 882,1126,1285,
+ 639,1044, 133, 140, 288, 360, 811, 563,1027, 561, 142, 523,1969,1970,1971,   7,
+ 103, 296, 439, 407, 506, 634, 990,1972,1973,1974,1975, 645,1976,1977,1978,1979,
+1980,1981, 236,1982,1436,1983,1984,1089, 192, 828, 618, 518,1166, 333,1127,1985,
+ 818,1223,1986,1987,1988,1989,1990,1991,1992,1993, 342,1128,1286, 746, 842,1994,
+1995, 560, 223,1287,  98,   8, 189, 650, 978,1288,1996,1437,1997,  17, 345, 250,
+ 423, 277, 234, 512, 226,  97, 289,  42, 167,1998, 201,1999,2000, 843, 836, 824,
+ 532, 338, 783,1090, 182, 576, 436,1438,1439, 527, 500,2001, 947, 889,2002,2003,
+2004,2005, 262, 600, 314, 447,2006, 547,2007, 693, 738,1129,2008,  71,1440, 745,
+ 619, 688,2009, 829,2010,2011, 147,2012,  33, 948,2013,2014,  74, 224,2015,  61,
+ 191, 918, 399, 637,2016,1028,1130, 257, 902,2017,2018,2019,2020,2021,2022,2023,
+2024,2025,2026, 837,2027,2028,2029,2030, 179, 874, 591,  52, 724, 246,2031,2032,
+2033,2034,1167, 969,2035,1289, 630, 605, 911,1091,1168,2036,2037,2038,1441, 912,
+2039, 623,2040,2041, 253,1169,1290,2042,1442, 146, 620, 611, 577, 433,2043,1224,
+ 719,1170, 959, 440, 437, 534,  84, 388, 480,1131, 159, 220, 198, 679,2044,1012,
+ 819,1066,1443, 113,1225, 194, 318,1003,1029,2045,2046,2047,2048,1067,2049,2050,
+2051,2052,2053,  59, 913, 112,2054, 632,2055, 455, 144, 739,1291,2056, 273, 681,
+ 499,2057, 448,2058,2059, 760,2060,2061, 970, 384, 169, 245,1132,2062,2063, 414,
+1444,2064,2065,  41, 235,2066, 157, 252, 877, 568, 919, 789, 580,2067, 725,2068,
+2069,1292,2070,2071,1445,2072,1446,2073,2074,  55, 588,  66,1447, 271,1092,2075,
+1226,2076, 960,1013, 372,2077,2078,2079,2080,2081,1293,2082,2083,2084,2085, 850,
+2086,2087,2088,2089,2090, 186,2091,1068, 180,2092,2093,2094, 109,1227, 522, 606,
+2095, 867,1448,1093, 991,1171, 926, 353,1133,2096, 581,2097,2098,2099,1294,1449,
+1450,2100, 596,1172,1014,1228,2101,1451,1295,1173,1229,2102,2103,1296,1134,1452,
+ 949,1135,2104,2105,1094,1453,1454,1455,2106,1095,2107,2108,2109,2110,2111,2112,
+2113,2114,2115,2116,2117, 804,2118,2119,1230,1231, 805,1456, 405,1136,2120,2121,
+2122,2123,2124, 720, 701,1297, 992,1457, 927,1004,2125,2126,2127,2128,2129,2130,
+  22, 417,2131, 303,2132, 385,2133, 971, 520, 513,2134,1174,  73,1096, 231, 274,
+ 962,1458, 673,2135,1459,2136, 152,1137,2137,2138,2139,2140,1005,1138,1460,1139,
+2141,2142,2143,2144,  11, 374, 844,2145, 154,1232,  46,1461,2146, 838, 830, 721,
+1233, 106,2147,  90, 428, 462, 578, 566,1175, 352,2148,2149, 538,1234, 124,1298,
+2150,1462, 761, 565,2151, 686,2152, 649,2153,  72, 173,2154, 460, 415,2155,1463,
+2156,1235, 305,2157,2158,2159,2160,2161,2162, 579,2163,2164,2165,2166,2167, 747,
+2168,2169,2170,2171,1464, 669,2172,2173,2174,2175,2176,1465,2177,  23, 530, 285,
+2178, 335, 729,2179, 397,2180,2181,2182,1030,2183,2184, 698,2185,2186, 325,2187,
+2188, 369,2189, 799,1097,1015, 348,2190,1069, 680,2191, 851,1466,2192,2193,  10,
+2194, 613, 424,2195, 979, 108, 449, 589,  27, 172,  81,1031,  80, 774, 281, 350,
+1032, 525, 301, 582,1176,2196, 674,1045,2197,2198,1467, 730, 762,2199,2200,2201,
+2202,1468,2203, 993,2204,2205, 266,1070, 963,1140,2206,2207,2208, 664,1098, 972,
+2209,2210,2211,1177,1469,1470, 871,2212,2213,2214,2215,2216,1471,2217,2218,2219,
+2220,2221,2222,2223,2224,2225,2226,2227,1472,1236,2228,2229,2230,2231,2232,2233,
+2234,2235,1299,2236,2237, 200,2238, 477, 373,2239,2240, 731, 825, 777,2241,2242,
+2243, 521, 486, 548,2244,2245,2246,1473,1300,  53, 549, 137, 875,  76, 158,2247,
+1301,1474, 469, 396,1016, 278, 712,2248, 321, 442, 503, 767, 744, 941,1237,1178,
+1475,2249,  82, 178,1141,1179, 973,2250,1302,2251, 297,2252,2253, 570,2254,2255,
+2256,  18, 450, 206,2257, 290, 292,1142,2258, 511, 162,  99, 346, 164, 735,2259,
+1476,1477,   4, 554, 343, 798,1099,2260,1100,2261,  43, 171,1303, 139, 215,2262,
+2263, 717, 775,2264,1033, 322, 216,2265, 831,2266, 149,2267,1304,2268,2269, 702,
+1238, 135, 845, 347, 309,2270, 484,2271, 878, 655, 238,1006,1478,2272,  67,2273,
+ 295,2274,2275, 461,2276, 478, 942, 412,2277,1034,2278,2279,2280, 265,2281, 541,
+2282,2283,2284,2285,2286,  70, 852,1071,2287,2288,2289,2290,  21,  56, 509, 117,
+ 432,2291,2292, 331, 980, 552,1101, 148, 284, 105, 393,1180,1239, 755,2293, 187,
+2294,1046,1479,2295, 340,2296,  63,1047, 230,2297,2298,1305, 763,1306, 101, 800,
+ 808, 494,2299,2300,2301, 903,2302,  37,1072,  14,   5,2303,  79, 675,2304, 312,
+2305,2306,2307,2308,2309,1480,   6,1307,2310,2311,2312,   1, 470,  35,  24, 229,
+2313, 695, 210,  86, 778,  15, 784, 592, 779,  32,  77, 855, 964,2314, 259,2315,
+ 501, 380,2316,2317,  83, 981, 153, 689,1308,1481,1482,1483,2318,2319, 716,1484,
+2320,2321,2322,2323,2324,2325,1485,2326,2327, 128,  57,  68, 261,1048, 211, 170,
+1240,  31,2328,  51, 435, 742,2329,2330,2331, 635,2332, 264, 456,2333,2334,2335,
+ 425,2336,1486, 143, 507, 263, 943,2337, 363, 920,1487, 256,1488,1102, 243, 601,
+1489,2338,2339,2340,2341,2342,2343,2344, 861,2345,2346,2347,2348,2349,2350, 395,
+2351,1490,1491,  62, 535, 166, 225,2352,2353, 668, 419,1241, 138, 604, 928,2354,
+1181,2355,1492,1493,2356,2357,2358,1143,2359, 696,2360, 387, 307,1309, 682, 476,
+2361,2362, 332,  12, 222, 156,2363, 232,2364, 641, 276, 656, 517,1494,1495,1035,
+ 416, 736,1496,2365,1017, 586,2366,2367,2368,1497,2369, 242,2370,2371,2372,1498,
+2373, 965, 713,2374,2375,2376,2377, 740, 982,1499, 944,1500,1007,2378,2379,1310,
+1501,2380,2381,2382, 785, 329,2383,2384,1502,2385,2386,2387, 932,2388,1503,2389,
+2390,2391,2392,1242,2393,2394,2395,2396,2397, 994, 950,2398,2399,2400,2401,1504,
+1311,2402,2403,2404,2405,1049, 749,2406,2407, 853, 718,1144,1312,2408,1182,1505,
+2409,2410, 255, 516, 479, 564, 550, 214,1506,1507,1313, 413, 239, 444, 339,1145,
+1036,1508,1509,1314,1037,1510,1315,2411,1511,2412,2413,2414, 176, 703, 497, 624,
+ 593, 921, 302,2415, 341, 165,1103,1512,2416,1513,2417,2418,2419, 376,2420, 700,
+2421,2422,2423, 258, 768,1316,2424,1183,2425, 995, 608,2426,2427,2428,2429, 221,
+2430,2431,2432,2433,2434,2435,2436,2437, 195, 323, 726, 188, 897, 983,1317, 377,
+ 644,1050, 879,2438, 452,2439,2440,2441,2442,2443,2444, 914,2445,2446,2447,2448,
+ 915, 489,2449,1514,1184,2450,2451, 515,  64, 427, 495,2452, 583,2453, 483, 485,
+1038, 562, 213,1515, 748, 666,2454,2455,2456,2457, 334,2458, 780, 996,1008, 705,
+1243,2459,2460,2461,2462,2463, 114,2464, 493,1146, 366, 163,1516, 961,1104,2465,
+ 291,2466,1318,1105,2467,1517, 365,2468, 355, 951,1244,2469,1319,2470, 631,2471,
+2472, 218,1320, 364, 320, 756,1518,1519,1321,1520,1322,2473,2474,2475,2476, 997,
+2477,2478,2479,2480, 665,1185,2481, 916,1521,2482,2483,2484, 584, 684,2485,2486,
+ 797,2487,1051,1186,2488,2489,2490,1522,2491,2492, 370,2493,1039,1187,  65,2494,
+ 434, 205, 463,1188,2495, 125, 812, 391, 402, 826, 699, 286, 398, 155, 781, 771,
+ 585,2496, 590, 505,1073,2497, 599, 244, 219, 917,1018, 952, 646,1523,2498,1323,
+2499,2500,  49, 984, 354, 741,2501, 625,2502,1324,2503,1019, 190, 357, 757, 491,
+  95, 782, 868,2504,2505,2506,2507,2508,2509, 134,1524,1074, 422,1525, 898,2510,
+ 161,2511,2512,2513,2514, 769,2515,1526,2516,2517, 411,1325,2518, 472,1527,2519,
+2520,2521,2522,2523,2524, 985,2525,2526,2527,2528,2529,2530, 764,2531,1245,2532,
+2533,  25, 204, 311,2534, 496,2535,1052,2536,2537,2538,2539,2540,2541,2542, 199,
+ 704, 504, 468, 758, 657,1528, 196,  44, 839,1246, 272, 750,2543, 765, 862,2544,
+2545,1326,2546, 132, 615, 933,2547, 732,2548,2549,2550,1189,1529,2551, 283,1247,
+1053, 607, 929,2552,2553,2554, 930, 183, 872, 616,1040,1147,2555,1148,1020, 441,
+ 249,1075,2556,2557,2558, 466, 743,2559,2560,2561,  92, 514, 426, 420, 526,2562,
+2563,2564,2565,2566,2567,2568, 185,2569,2570,2571,2572, 776,1530, 658,2573, 362,
+2574, 361, 922,1076, 793,2575,2576,2577,2578,2579,2580,1531, 251,2581,2582,2583,
+2584,1532,  54, 612, 237,1327,2585,2586, 275, 408, 647, 111,2587,1533,1106, 465,
+   3, 458,   9,  38,2588, 107, 110, 890, 209,  26, 737, 498,2589,1534,2590, 431,
+ 202,  88,1535, 356, 287,1107, 660,1149,2591, 381,1536, 986,1150, 445,1248,1151,
+ 974,2592,2593, 846,2594, 446, 953, 184,1249,1250, 727,2595, 923, 193, 883,2596,
+2597,2598, 102, 324, 539, 817,2599, 421,1041,2600, 832,2601,  94, 175, 197, 406,
+2602, 459,2603,2604,2605,2606,2607, 330, 555,2608,2609,2610, 706,1108, 389,2611,
+2612,2613,2614, 233,2615, 833, 558, 931, 954,1251,2616,2617,1537, 546,2618,2619,
+1009,2620,2621,2622,1538, 690,1328,2623, 955,2624,1539,2625,2626, 772,2627,2628,
+2629,2630,2631, 924, 648, 863, 603,2632,2633, 934,1540, 864, 865,2634, 642,1042,
+ 670,1190,2635,2636,2637,2638, 168,2639, 652, 873, 542,1054,1541,2640,2641,2642,  # 512, 256
+)
+
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euckrprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euckrprober.py
new file mode 100644
index 0000000..345a060
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euckrprober.py
@@ -0,0 +1,47 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .mbcharsetprober import MultiByteCharSetProber
+from .codingstatemachine import CodingStateMachine
+from .chardistribution import EUCKRDistributionAnalysis
+from .mbcssm import EUCKR_SM_MODEL
+
+
+class EUCKRProber(MultiByteCharSetProber):
+    def __init__(self):
+        super(EUCKRProber, self).__init__()
+        self.coding_sm = CodingStateMachine(EUCKR_SM_MODEL)
+        self.distribution_analyzer = EUCKRDistributionAnalysis()
+        self.reset()
+
+    @property
+    def charset_name(self):
+        return "EUC-KR"
+
+    @property
+    def language(self):
+        return "Korean"
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euctwfreq.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euctwfreq.py
new file mode 100644
index 0000000..ed7a995
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euctwfreq.py
@@ -0,0 +1,387 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# EUCTW frequency table
+# Converted from big5 work
+# by Taiwan's Mandarin Promotion Council
+# <http:#www.edu.tw:81/mandr/>
+
+# 128  --> 0.42261
+# 256  --> 0.57851
+# 512  --> 0.74851
+# 1024 --> 0.89384
+# 2048 --> 0.97583
+#
+# Idea Distribution Ratio = 0.74851/(1-0.74851) =2.98
+# Random Distribution Ration = 512/(5401-512)=0.105
+#
+# Typical Distribution Ratio about 25% of Ideal one, still much higher than RDR
+
+EUCTW_TYPICAL_DISTRIBUTION_RATIO = 0.75
+
+# Char to FreqOrder table ,
+EUCTW_TABLE_SIZE = 5376
+
+EUCTW_CHAR_TO_FREQ_ORDER = (
+   1,1800,1506, 255,1431, 198,   9,  82,   6,7310, 177, 202,3615,1256,2808, 110,  # 2742
+3735,  33,3241, 261,  76,  44,2113,  16,2931,2184,1176, 659,3868,  26,3404,2643,  # 2758
+1198,3869,3313,4060, 410,2211, 302, 590, 361,1963,   8, 204,  58,4296,7311,1931,  # 2774
+  63,7312,7313, 317,1614,  75, 222, 159,4061,2412,1480,7314,3500,3068, 224,2809,  # 2790
+3616,   3,  10,3870,1471,  29,2774,1135,2852,1939, 873, 130,3242,1123, 312,7315,  # 2806
+4297,2051, 507, 252, 682,7316, 142,1914, 124, 206,2932,  34,3501,3173,  64, 604,  # 2822
+7317,2494,1976,1977, 155,1990, 645, 641,1606,7318,3405, 337,  72, 406,7319,  80,  # 2838
+ 630, 238,3174,1509, 263, 939,1092,2644, 756,1440,1094,3406, 449,  69,2969, 591,  # 2854
+ 179,2095, 471, 115,2034,1843,  60,  50,2970, 134, 806,1868, 734,2035,3407, 180,  # 2870
+ 995,1607, 156, 537,2893, 688,7320, 319,1305, 779,2144, 514,2374, 298,4298, 359,  # 2886
+2495,  90,2707,1338, 663,  11, 906,1099,2545,  20,2436, 182, 532,1716,7321, 732,  # 2902
+1376,4062,1311,1420,3175,  25,2312,1056, 113, 399, 382,1949, 242,3408,2467, 529,  # 2918
+3243, 475,1447,3617,7322, 117,  21, 656, 810,1297,2295,2329,3502,7323, 126,4063,  # 2934
+ 706, 456, 150, 613,4299,  71,1118,2036,4064, 145,3069,  85, 835, 486,2114,1246,  # 2950
+1426, 428, 727,1285,1015, 800, 106, 623, 303,1281,7324,2127,2354, 347,3736, 221,  # 2966
+3503,3110,7325,1955,1153,4065,  83, 296,1199,3070, 192, 624,  93,7326, 822,1897,  # 2982
+2810,3111, 795,2064, 991,1554,1542,1592,  27,  43,2853, 859, 139,1456, 860,4300,  # 2998
+ 437, 712,3871, 164,2392,3112, 695, 211,3017,2096, 195,3872,1608,3504,3505,3618,  # 3014
+3873, 234, 811,2971,2097,3874,2229,1441,3506,1615,2375, 668,2076,1638, 305, 228,  # 3030
+1664,4301, 467, 415,7327, 262,2098,1593, 239, 108, 300, 200,1033, 512,1247,2077,  # 3046
+7328,7329,2173,3176,3619,2673, 593, 845,1062,3244,  88,1723,2037,3875,1950, 212,  # 3062
+ 266, 152, 149, 468,1898,4066,4302,  77, 187,7330,3018,  37,   5,2972,7331,3876,  # 3078
+7332,7333,  39,2517,4303,2894,3177,2078,  55, 148,  74,4304, 545, 483,1474,1029,  # 3094
+1665, 217,1869,1531,3113,1104,2645,4067,  24, 172,3507, 900,3877,3508,3509,4305,  # 3110
+  32,1408,2811,1312, 329, 487,2355,2247,2708, 784,2674,   4,3019,3314,1427,1788,  # 3126
+ 188, 109, 499,7334,3620,1717,1789, 888,1217,3020,4306,7335,3510,7336,3315,1520,  # 3142
+3621,3878, 196,1034, 775,7337,7338, 929,1815, 249, 439,  38,7339,1063,7340, 794,  # 3158
+3879,1435,2296,  46, 178,3245,2065,7341,2376,7342, 214,1709,4307, 804,  35, 707,  # 3174
+ 324,3622,1601,2546, 140, 459,4068,7343,7344,1365, 839, 272, 978,2257,2572,3409,  # 3190
+2128,1363,3623,1423, 697, 100,3071,  48,  70,1231, 495,3114,2193,7345,1294,7346,  # 3206
+2079, 462, 586,1042,3246, 853, 256, 988, 185,2377,3410,1698, 434,1084,7347,3411,  # 3222
+ 314,2615,2775,4308,2330,2331, 569,2280, 637,1816,2518, 757,1162,1878,1616,3412,  # 3238
+ 287,1577,2115, 768,4309,1671,2854,3511,2519,1321,3737, 909,2413,7348,4069, 933,  # 3254
+3738,7349,2052,2356,1222,4310, 765,2414,1322, 786,4311,7350,1919,1462,1677,2895,  # 3270
+1699,7351,4312,1424,2437,3115,3624,2590,3316,1774,1940,3413,3880,4070, 309,1369,  # 3286
+1130,2812, 364,2230,1653,1299,3881,3512,3882,3883,2646, 525,1085,3021, 902,2000,  # 3302
+1475, 964,4313, 421,1844,1415,1057,2281, 940,1364,3116, 376,4314,4315,1381,   7,  # 3318
+2520, 983,2378, 336,1710,2675,1845, 321,3414, 559,1131,3022,2742,1808,1132,1313,  # 3334
+ 265,1481,1857,7352, 352,1203,2813,3247, 167,1089, 420,2814, 776, 792,1724,3513,  # 3350
+4071,2438,3248,7353,4072,7354, 446, 229, 333,2743, 901,3739,1200,1557,4316,2647,  # 3366
+1920, 395,2744,2676,3740,4073,1835, 125, 916,3178,2616,4317,7355,7356,3741,7357,  # 3382
+7358,7359,4318,3117,3625,1133,2547,1757,3415,1510,2313,1409,3514,7360,2145, 438,  # 3398
+2591,2896,2379,3317,1068, 958,3023, 461, 311,2855,2677,4074,1915,3179,4075,1978,  # 3414
+ 383, 750,2745,2617,4076, 274, 539, 385,1278,1442,7361,1154,1964, 384, 561, 210,  # 3430
+  98,1295,2548,3515,7362,1711,2415,1482,3416,3884,2897,1257, 129,7363,3742, 642,  # 3446
+ 523,2776,2777,2648,7364, 141,2231,1333,  68, 176, 441, 876, 907,4077, 603,2592,  # 3462
+ 710, 171,3417, 404, 549,  18,3118,2393,1410,3626,1666,7365,3516,4319,2898,4320,  # 3478
+7366,2973, 368,7367, 146, 366,  99, 871,3627,1543, 748, 807,1586,1185,  22,2258,  # 3494
+ 379,3743,3180,7368,3181, 505,1941,2618,1991,1382,2314,7369, 380,2357, 218, 702,  # 3510
+1817,1248,3418,3024,3517,3318,3249,7370,2974,3628, 930,3250,3744,7371,  59,7372,  # 3526
+ 585, 601,4078, 497,3419,1112,1314,4321,1801,7373,1223,1472,2174,7374, 749,1836,  # 3542
+ 690,1899,3745,1772,3885,1476, 429,1043,1790,2232,2116, 917,4079, 447,1086,1629,  # 3558
+7375, 556,7376,7377,2020,1654, 844,1090, 105, 550, 966,1758,2815,1008,1782, 686,  # 3574
+1095,7378,2282, 793,1602,7379,3518,2593,4322,4080,2933,2297,4323,3746, 980,2496,  # 3590
+ 544, 353, 527,4324, 908,2678,2899,7380, 381,2619,1942,1348,7381,1341,1252, 560,  # 3606
+3072,7382,3420,2856,7383,2053, 973, 886,2080, 143,4325,7384,7385, 157,3886, 496,  # 3622
+4081,  57, 840, 540,2038,4326,4327,3421,2117,1445, 970,2259,1748,1965,2081,4082,  # 3638
+3119,1234,1775,3251,2816,3629, 773,1206,2129,1066,2039,1326,3887,1738,1725,4083,  # 3654
+ 279,3120,  51,1544,2594, 423,1578,2130,2066, 173,4328,1879,7386,7387,1583, 264,  # 3670
+ 610,3630,4329,2439, 280, 154,7388,7389,7390,1739, 338,1282,3073, 693,2857,1411,  # 3686
+1074,3747,2440,7391,4330,7392,7393,1240, 952,2394,7394,2900,1538,2679, 685,1483,  # 3702
+4084,2468,1436, 953,4085,2054,4331, 671,2395,  79,4086,2441,3252, 608, 567,2680,  # 3718
+3422,4087,4088,1691, 393,1261,1791,2396,7395,4332,7396,7397,7398,7399,1383,1672,  # 3734
+3748,3182,1464, 522,1119, 661,1150, 216, 675,4333,3888,1432,3519, 609,4334,2681,  # 3750
+2397,7400,7401,7402,4089,3025,   0,7403,2469, 315, 231,2442, 301,3319,4335,2380,  # 3766
+7404, 233,4090,3631,1818,4336,4337,7405,  96,1776,1315,2082,7406, 257,7407,1809,  # 3782
+3632,2709,1139,1819,4091,2021,1124,2163,2778,1777,2649,7408,3074, 363,1655,3183,  # 3798
+7409,2975,7410,7411,7412,3889,1567,3890, 718, 103,3184, 849,1443, 341,3320,2934,  # 3814
+1484,7413,1712, 127,  67, 339,4092,2398, 679,1412, 821,7414,7415, 834, 738, 351,  # 3830
+2976,2146, 846, 235,1497,1880, 418,1992,3749,2710, 186,1100,2147,2746,3520,1545,  # 3846
+1355,2935,2858,1377, 583,3891,4093,2573,2977,7416,1298,3633,1078,2549,3634,2358,  # 3862
+  78,3750,3751, 267,1289,2099,2001,1594,4094, 348, 369,1274,2194,2175,1837,4338,  # 3878
+1820,2817,3635,2747,2283,2002,4339,2936,2748, 144,3321, 882,4340,3892,2749,3423,  # 3894
+4341,2901,7417,4095,1726, 320,7418,3893,3026, 788,2978,7419,2818,1773,1327,2859,  # 3910
+3894,2819,7420,1306,4342,2003,1700,3752,3521,2359,2650, 787,2022, 506, 824,3636,  # 3926
+ 534, 323,4343,1044,3322,2023,1900, 946,3424,7421,1778,1500,1678,7422,1881,4344,  # 3942
+ 165, 243,4345,3637,2521, 123, 683,4096, 764,4346,  36,3895,1792, 589,2902, 816,  # 3958
+ 626,1667,3027,2233,1639,1555,1622,3753,3896,7423,3897,2860,1370,1228,1932, 891,  # 3974
+2083,2903, 304,4097,7424, 292,2979,2711,3522, 691,2100,4098,1115,4347, 118, 662,  # 3990
+7425, 611,1156, 854,2381,1316,2861,   2, 386, 515,2904,7426,7427,3253, 868,2234,  # 4006
+1486, 855,2651, 785,2212,3028,7428,1040,3185,3523,7429,3121, 448,7430,1525,7431,  # 4022
+2164,4348,7432,3754,7433,4099,2820,3524,3122, 503, 818,3898,3123,1568, 814, 676,  # 4038
+1444, 306,1749,7434,3755,1416,1030, 197,1428, 805,2821,1501,4349,7435,7436,7437,  # 4054
+1993,7438,4350,7439,7440,2195,  13,2779,3638,2980,3124,1229,1916,7441,3756,2131,  # 4070
+7442,4100,4351,2399,3525,7443,2213,1511,1727,1120,7444,7445, 646,3757,2443, 307,  # 4086
+7446,7447,1595,3186,7448,7449,7450,3639,1113,1356,3899,1465,2522,2523,7451, 519,  # 4102
+7452, 128,2132,  92,2284,1979,7453,3900,1512, 342,3125,2196,7454,2780,2214,1980,  # 4118
+3323,7455, 290,1656,1317, 789, 827,2360,7456,3758,4352, 562, 581,3901,7457, 401,  # 4134
+4353,2248,  94,4354,1399,2781,7458,1463,2024,4355,3187,1943,7459, 828,1105,4101,  # 4150
+1262,1394,7460,4102, 605,4356,7461,1783,2862,7462,2822, 819,2101, 578,2197,2937,  # 4166
+7463,1502, 436,3254,4103,3255,2823,3902,2905,3425,3426,7464,2712,2315,7465,7466,  # 4182
+2332,2067,  23,4357, 193, 826,3759,2102, 699,1630,4104,3075, 390,1793,1064,3526,  # 4198
+7467,1579,3076,3077,1400,7468,4105,1838,1640,2863,7469,4358,4359, 137,4106, 598,  # 4214
+3078,1966, 780, 104, 974,2938,7470, 278, 899, 253, 402, 572, 504, 493,1339,7471,  # 4230
+3903,1275,4360,2574,2550,7472,3640,3029,3079,2249, 565,1334,2713, 863,  41,7473,  # 4246
+7474,4361,7475,1657,2333,  19, 463,2750,4107, 606,7476,2981,3256,1087,2084,1323,  # 4262
+2652,2982,7477,1631,1623,1750,4108,2682,7478,2864, 791,2714,2653,2334, 232,2416,  # 4278
+7479,2983,1498,7480,2654,2620, 755,1366,3641,3257,3126,2025,1609, 119,1917,3427,  # 4294
+ 862,1026,4109,7481,3904,3760,4362,3905,4363,2260,1951,2470,7482,1125, 817,4110,  # 4310
+4111,3906,1513,1766,2040,1487,4112,3030,3258,2824,3761,3127,7483,7484,1507,7485,  # 4326
+2683, 733,  40,1632,1106,2865, 345,4113, 841,2524, 230,4364,2984,1846,3259,3428,  # 4342
+7486,1263, 986,3429,7487, 735, 879, 254,1137, 857, 622,1300,1180,1388,1562,3907,  # 4358
+3908,2939, 967,2751,2655,1349, 592,2133,1692,3324,2985,1994,4114,1679,3909,1901,  # 4374
+2185,7488, 739,3642,2715,1296,1290,7489,4115,2198,2199,1921,1563,2595,2551,1870,  # 4390
+2752,2986,7490, 435,7491, 343,1108, 596,  17,1751,4365,2235,3430,3643,7492,4366,  # 4406
+ 294,3527,2940,1693, 477, 979, 281,2041,3528, 643,2042,3644,2621,2782,2261,1031,  # 4422
+2335,2134,2298,3529,4367, 367,1249,2552,7493,3530,7494,4368,1283,3325,2004, 240,  # 4438
+1762,3326,4369,4370, 836,1069,3128, 474,7495,2148,2525, 268,3531,7496,3188,1521,  # 4454
+1284,7497,1658,1546,4116,7498,3532,3533,7499,4117,3327,2684,1685,4118, 961,1673,  # 4470
+2622, 190,2005,2200,3762,4371,4372,7500, 570,2497,3645,1490,7501,4373,2623,3260,  # 4486
+1956,4374, 584,1514, 396,1045,1944,7502,4375,1967,2444,7503,7504,4376,3910, 619,  # 4502
+7505,3129,3261, 215,2006,2783,2553,3189,4377,3190,4378, 763,4119,3763,4379,7506,  # 4518
+7507,1957,1767,2941,3328,3646,1174, 452,1477,4380,3329,3130,7508,2825,1253,2382,  # 4534
+2186,1091,2285,4120, 492,7509, 638,1169,1824,2135,1752,3911, 648, 926,1021,1324,  # 4550
+4381, 520,4382, 997, 847,1007, 892,4383,3764,2262,1871,3647,7510,2400,1784,4384,  # 4566
+1952,2942,3080,3191,1728,4121,2043,3648,4385,2007,1701,3131,1551,  30,2263,4122,  # 4582
+7511,2026,4386,3534,7512, 501,7513,4123, 594,3431,2165,1821,3535,3432,3536,3192,  # 4598
+ 829,2826,4124,7514,1680,3132,1225,4125,7515,3262,4387,4126,3133,2336,7516,4388,  # 4614
+4127,7517,3912,3913,7518,1847,2383,2596,3330,7519,4389, 374,3914, 652,4128,4129,  # 4630
+ 375,1140, 798,7520,7521,7522,2361,4390,2264, 546,1659, 138,3031,2445,4391,7523,  # 4646
+2250, 612,1848, 910, 796,3765,1740,1371, 825,3766,3767,7524,2906,2554,7525, 692,  # 4662
+ 444,3032,2624, 801,4392,4130,7526,1491, 244,1053,3033,4131,4132, 340,7527,3915,  # 4678
+1041,2987, 293,1168,  87,1357,7528,1539, 959,7529,2236, 721, 694,4133,3768, 219,  # 4694
+1478, 644,1417,3331,2656,1413,1401,1335,1389,3916,7530,7531,2988,2362,3134,1825,  # 4710
+ 730,1515, 184,2827,  66,4393,7532,1660,2943, 246,3332, 378,1457, 226,3433, 975,  # 4726
+3917,2944,1264,3537, 674, 696,7533, 163,7534,1141,2417,2166, 713,3538,3333,4394,  # 4742
+3918,7535,7536,1186,  15,7537,1079,1070,7538,1522,3193,3539, 276,1050,2716, 758,  # 4758
+1126, 653,2945,3263,7539,2337, 889,3540,3919,3081,2989, 903,1250,4395,3920,3434,  # 4774
+3541,1342,1681,1718, 766,3264, 286,  89,2946,3649,7540,1713,7541,2597,3334,2990,  # 4790
+7542,2947,2215,3194,2866,7543,4396,2498,2526, 181, 387,1075,3921, 731,2187,3335,  # 4806
+7544,3265, 310, 313,3435,2299, 770,4134,  54,3034, 189,4397,3082,3769,3922,7545,  # 4822
+1230,1617,1849, 355,3542,4135,4398,3336, 111,4136,3650,1350,3135,3436,3035,4137,  # 4838
+2149,3266,3543,7546,2784,3923,3924,2991, 722,2008,7547,1071, 247,1207,2338,2471,  # 4854
+1378,4399,2009, 864,1437,1214,4400, 373,3770,1142,2216, 667,4401, 442,2753,2555,  # 4870
+3771,3925,1968,4138,3267,1839, 837, 170,1107, 934,1336,1882,7548,7549,2118,4139,  # 4886
+2828, 743,1569,7550,4402,4140, 582,2384,1418,3437,7551,1802,7552, 357,1395,1729,  # 4902
+3651,3268,2418,1564,2237,7553,3083,3772,1633,4403,1114,2085,4141,1532,7554, 482,  # 4918
+2446,4404,7555,7556,1492, 833,1466,7557,2717,3544,1641,2829,7558,1526,1272,3652,  # 4934
+4142,1686,1794, 416,2556,1902,1953,1803,7559,3773,2785,3774,1159,2316,7560,2867,  # 4950
+4405,1610,1584,3036,2419,2754, 443,3269,1163,3136,7561,7562,3926,7563,4143,2499,  # 4966
+3037,4406,3927,3137,2103,1647,3545,2010,1872,4144,7564,4145, 431,3438,7565, 250,  # 4982
+  97,  81,4146,7566,1648,1850,1558, 160, 848,7567, 866, 740,1694,7568,2201,2830,  # 4998
+3195,4147,4407,3653,1687, 950,2472, 426, 469,3196,3654,3655,3928,7569,7570,1188,  # 5014
+ 424,1995, 861,3546,4148,3775,2202,2685, 168,1235,3547,4149,7571,2086,1674,4408,  # 5030
+3337,3270, 220,2557,1009,7572,3776, 670,2992, 332,1208, 717,7573,7574,3548,2447,  # 5046
+3929,3338,7575, 513,7576,1209,2868,3339,3138,4409,1080,7577,7578,7579,7580,2527,  # 5062
+3656,3549, 815,1587,3930,3931,7581,3550,3439,3777,1254,4410,1328,3038,1390,3932,  # 5078
+1741,3933,3778,3934,7582, 236,3779,2448,3271,7583,7584,3657,3780,1273,3781,4411,  # 5094
+7585, 308,7586,4412, 245,4413,1851,2473,1307,2575, 430, 715,2136,2449,7587, 270,  # 5110
+ 199,2869,3935,7588,3551,2718,1753, 761,1754, 725,1661,1840,4414,3440,3658,7589,  # 5126
+7590, 587,  14,3272, 227,2598, 326, 480,2265, 943,2755,3552, 291, 650,1883,7591,  # 5142
+1702,1226, 102,1547,  62,3441, 904,4415,3442,1164,4150,7592,7593,1224,1548,2756,  # 5158
+ 391, 498,1493,7594,1386,1419,7595,2055,1177,4416, 813, 880,1081,2363, 566,1145,  # 5174
+4417,2286,1001,1035,2558,2599,2238, 394,1286,7596,7597,2068,7598,  86,1494,1730,  # 5190
+3936, 491,1588, 745, 897,2948, 843,3340,3937,2757,2870,3273,1768, 998,2217,2069,  # 5206
+ 397,1826,1195,1969,3659,2993,3341, 284,7599,3782,2500,2137,2119,1903,7600,3938,  # 5222
+2150,3939,4151,1036,3443,1904, 114,2559,4152, 209,1527,7601,7602,2949,2831,2625,  # 5238
+2385,2719,3139, 812,2560,7603,3274,7604,1559, 737,1884,3660,1210, 885,  28,2686,  # 5254
+3553,3783,7605,4153,1004,1779,4418,7606, 346,1981,2218,2687,4419,3784,1742, 797,  # 5270
+1642,3940,1933,1072,1384,2151, 896,3941,3275,3661,3197,2871,3554,7607,2561,1958,  # 5286
+4420,2450,1785,7608,7609,7610,3942,4154,1005,1308,3662,4155,2720,4421,4422,1528,  # 5302
+2600, 161,1178,4156,1982, 987,4423,1101,4157, 631,3943,1157,3198,2420,1343,1241,  # 5318
+1016,2239,2562, 372, 877,2339,2501,1160, 555,1934, 911,3944,7611, 466,1170, 169,  # 5334
+1051,2907,2688,3663,2474,2994,1182,2011,2563,1251,2626,7612, 992,2340,3444,1540,  # 5350
+2721,1201,2070,2401,1996,2475,7613,4424, 528,1922,2188,1503,1873,1570,2364,3342,  # 5366
+3276,7614, 557,1073,7615,1827,3445,2087,2266,3140,3039,3084, 767,3085,2786,4425,  # 5382
+1006,4158,4426,2341,1267,2176,3664,3199, 778,3945,3200,2722,1597,2657,7616,4427,  # 5398
+7617,3446,7618,7619,7620,3277,2689,1433,3278, 131,  95,1504,3946, 723,4159,3141,  # 5414
+1841,3555,2758,2189,3947,2027,2104,3665,7621,2995,3948,1218,7622,3343,3201,3949,  # 5430
+4160,2576, 248,1634,3785, 912,7623,2832,3666,3040,3786, 654,  53,7624,2996,7625,  # 5446
+1688,4428, 777,3447,1032,3950,1425,7626, 191, 820,2120,2833, 971,4429, 931,3202,  # 5462
+ 135, 664, 783,3787,1997, 772,2908,1935,3951,3788,4430,2909,3203, 282,2723, 640,  # 5478
+1372,3448,1127, 922, 325,3344,7627,7628, 711,2044,7629,7630,3952,2219,2787,1936,  # 5494
+3953,3345,2220,2251,3789,2300,7631,4431,3790,1258,3279,3954,3204,2138,2950,3955,  # 5510
+3956,7632,2221, 258,3205,4432, 101,1227,7633,3280,1755,7634,1391,3281,7635,2910,  # 5526
+2056, 893,7636,7637,7638,1402,4161,2342,7639,7640,3206,3556,7641,7642, 878,1325,  # 5542
+1780,2788,4433, 259,1385,2577, 744,1183,2267,4434,7643,3957,2502,7644, 684,1024,  # 5558
+4162,7645, 472,3557,3449,1165,3282,3958,3959, 322,2152, 881, 455,1695,1152,1340,  # 5574
+ 660, 554,2153,4435,1058,4436,4163, 830,1065,3346,3960,4437,1923,7646,1703,1918,  # 5590
+7647, 932,2268, 122,7648,4438, 947, 677,7649,3791,2627, 297,1905,1924,2269,4439,  # 5606
+2317,3283,7650,7651,4164,7652,4165,  84,4166, 112, 989,7653, 547,1059,3961, 701,  # 5622
+3558,1019,7654,4167,7655,3450, 942, 639, 457,2301,2451, 993,2951, 407, 851, 494,  # 5638
+4440,3347, 927,7656,1237,7657,2421,3348, 573,4168, 680, 921,2911,1279,1874, 285,  # 5654
+ 790,1448,1983, 719,2167,7658,7659,4441,3962,3963,1649,7660,1541, 563,7661,1077,  # 5670
+7662,3349,3041,3451, 511,2997,3964,3965,3667,3966,1268,2564,3350,3207,4442,4443,  # 5686
+7663, 535,1048,1276,1189,2912,2028,3142,1438,1373,2834,2952,1134,2012,7664,4169,  # 5702
+1238,2578,3086,1259,7665, 700,7666,2953,3143,3668,4170,7667,4171,1146,1875,1906,  # 5718
+4444,2601,3967, 781,2422, 132,1589, 203, 147, 273,2789,2402, 898,1786,2154,3968,  # 5734
+3969,7668,3792,2790,7669,7670,4445,4446,7671,3208,7672,1635,3793, 965,7673,1804,  # 5750
+2690,1516,3559,1121,1082,1329,3284,3970,1449,3794,  65,1128,2835,2913,2759,1590,  # 5766
+3795,7674,7675,  12,2658,  45, 976,2579,3144,4447, 517,2528,1013,1037,3209,7676,  # 5782
+3796,2836,7677,3797,7678,3452,7679,2602, 614,1998,2318,3798,3087,2724,2628,7680,  # 5798
+2580,4172, 599,1269,7681,1810,3669,7682,2691,3088, 759,1060, 489,1805,3351,3285,  # 5814
+1358,7683,7684,2386,1387,1215,2629,2252, 490,7685,7686,4173,1759,2387,2343,7687,  # 5830
+4448,3799,1907,3971,2630,1806,3210,4449,3453,3286,2760,2344, 874,7688,7689,3454,  # 5846
+3670,1858,  91,2914,3671,3042,3800,4450,7690,3145,3972,2659,7691,3455,1202,1403,  # 5862
+3801,2954,2529,1517,2503,4451,3456,2504,7692,4452,7693,2692,1885,1495,1731,3973,  # 5878
+2365,4453,7694,2029,7695,7696,3974,2693,1216, 237,2581,4174,2319,3975,3802,4454,  # 5894
+4455,2694,3560,3457, 445,4456,7697,7698,7699,7700,2761,  61,3976,3672,1822,3977,  # 5910
+7701, 687,2045, 935, 925, 405,2660, 703,1096,1859,2725,4457,3978,1876,1367,2695,  # 5926
+3352, 918,2105,1781,2476, 334,3287,1611,1093,4458, 564,3146,3458,3673,3353, 945,  # 5942
+2631,2057,4459,7702,1925, 872,4175,7703,3459,2696,3089, 349,4176,3674,3979,4460,  # 5958
+3803,4177,3675,2155,3980,4461,4462,4178,4463,2403,2046, 782,3981, 400, 251,4179,  # 5974
+1624,7704,7705, 277,3676, 299,1265, 476,1191,3804,2121,4180,4181,1109, 205,7706,  # 5990
+2582,1000,2156,3561,1860,7707,7708,7709,4464,7710,4465,2565, 107,2477,2157,3982,  # 6006
+3460,3147,7711,1533, 541,1301, 158, 753,4182,2872,3562,7712,1696, 370,1088,4183,  # 6022
+4466,3563, 579, 327, 440, 162,2240, 269,1937,1374,3461, 968,3043,  56,1396,3090,  # 6038
+2106,3288,3354,7713,1926,2158,4467,2998,7714,3564,7715,7716,3677,4468,2478,7717,  # 6054
+2791,7718,1650,4469,7719,2603,7720,7721,3983,2661,3355,1149,3356,3984,3805,3985,  # 6070
+7722,1076,  49,7723, 951,3211,3289,3290, 450,2837, 920,7724,1811,2792,2366,4184,  # 6086
+1908,1138,2367,3806,3462,7725,3212,4470,1909,1147,1518,2423,4471,3807,7726,4472,  # 6102
+2388,2604, 260,1795,3213,7727,7728,3808,3291, 708,7729,3565,1704,7730,3566,1351,  # 6118
+1618,3357,2999,1886, 944,4185,3358,4186,3044,3359,4187,7731,3678, 422, 413,1714,  # 6134
+3292, 500,2058,2345,4188,2479,7732,1344,1910, 954,7733,1668,7734,7735,3986,2404,  # 6150
+4189,3567,3809,4190,7736,2302,1318,2505,3091, 133,3092,2873,4473, 629,  31,2838,  # 6166
+2697,3810,4474, 850, 949,4475,3987,2955,1732,2088,4191,1496,1852,7737,3988, 620,  # 6182
+3214, 981,1242,3679,3360,1619,3680,1643,3293,2139,2452,1970,1719,3463,2168,7738,  # 6198
+3215,7739,7740,3361,1828,7741,1277,4476,1565,2047,7742,1636,3568,3093,7743, 869,  # 6214
+2839, 655,3811,3812,3094,3989,3000,3813,1310,3569,4477,7744,7745,7746,1733, 558,  # 6230
+4478,3681, 335,1549,3045,1756,4192,3682,1945,3464,1829,1291,1192, 470,2726,2107,  # 6246
+2793, 913,1054,3990,7747,1027,7748,3046,3991,4479, 982,2662,3362,3148,3465,3216,  # 6262
+3217,1946,2794,7749, 571,4480,7750,1830,7751,3570,2583,1523,2424,7752,2089, 984,  # 6278
+4481,3683,1959,7753,3684, 852, 923,2795,3466,3685, 969,1519, 999,2048,2320,1705,  # 6294
+7754,3095, 615,1662, 151, 597,3992,2405,2321,1049, 275,4482,3686,4193, 568,3687,  # 6310
+3571,2480,4194,3688,7755,2425,2270, 409,3218,7756,1566,2874,3467,1002, 769,2840,  # 6326
+ 194,2090,3149,3689,2222,3294,4195, 628,1505,7757,7758,1763,2177,3001,3993, 521,  # 6342
+1161,2584,1787,2203,2406,4483,3994,1625,4196,4197, 412,  42,3096, 464,7759,2632,  # 6358
+4484,3363,1760,1571,2875,3468,2530,1219,2204,3814,2633,2140,2368,4485,4486,3295,  # 6374
+1651,3364,3572,7760,7761,3573,2481,3469,7762,3690,7763,7764,2271,2091, 460,7765,  # 6390
+4487,7766,3002, 962, 588,3574, 289,3219,2634,1116,  52,7767,3047,1796,7768,7769,  # 6406
+7770,1467,7771,1598,1143,3691,4198,1984,1734,1067,4488,1280,3365, 465,4489,1572,  # 6422
+ 510,7772,1927,2241,1812,1644,3575,7773,4490,3692,7774,7775,2663,1573,1534,7776,  # 6438
+7777,4199, 536,1807,1761,3470,3815,3150,2635,7778,7779,7780,4491,3471,2915,1911,  # 6454
+2796,7781,3296,1122, 377,3220,7782, 360,7783,7784,4200,1529, 551,7785,2059,3693,  # 6470
+1769,2426,7786,2916,4201,3297,3097,2322,2108,2030,4492,1404, 136,1468,1479, 672,  # 6486
+1171,3221,2303, 271,3151,7787,2762,7788,2049, 678,2727, 865,1947,4493,7789,2013,  # 6502
+3995,2956,7790,2728,2223,1397,3048,3694,4494,4495,1735,2917,3366,3576,7791,3816,  # 6518
+ 509,2841,2453,2876,3817,7792,7793,3152,3153,4496,4202,2531,4497,2304,1166,1010,  # 6534
+ 552, 681,1887,7794,7795,2957,2958,3996,1287,1596,1861,3154, 358, 453, 736, 175,  # 6550
+ 478,1117, 905,1167,1097,7796,1853,1530,7797,1706,7798,2178,3472,2287,3695,3473,  # 6566
+3577,4203,2092,4204,7799,3367,1193,2482,4205,1458,2190,2205,1862,1888,1421,3298,  # 6582
+2918,3049,2179,3474, 595,2122,7800,3997,7801,7802,4206,1707,2636, 223,3696,1359,  # 6598
+ 751,3098, 183,3475,7803,2797,3003, 419,2369, 633, 704,3818,2389, 241,7804,7805,  # 6614
+7806, 838,3004,3697,2272,2763,2454,3819,1938,2050,3998,1309,3099,2242,1181,7807,  # 6630
+1136,2206,3820,2370,1446,4207,2305,4498,7808,7809,4208,1055,2605, 484,3698,7810,  # 6646
+3999, 625,4209,2273,3368,1499,4210,4000,7811,4001,4211,3222,2274,2275,3476,7812,  # 6662
+7813,2764, 808,2606,3699,3369,4002,4212,3100,2532, 526,3370,3821,4213, 955,7814,  # 6678
+1620,4214,2637,2427,7815,1429,3700,1669,1831, 994, 928,7816,3578,1260,7817,7818,  # 6694
+7819,1948,2288, 741,2919,1626,4215,2729,2455, 867,1184, 362,3371,1392,7820,7821,  # 6710
+4003,4216,1770,1736,3223,2920,4499,4500,1928,2698,1459,1158,7822,3050,3372,2877,  # 6726
+1292,1929,2506,2842,3701,1985,1187,2071,2014,2607,4217,7823,2566,2507,2169,3702,  # 6742
+2483,3299,7824,3703,4501,7825,7826, 666,1003,3005,1022,3579,4218,7827,4502,1813,  # 6758
+2253, 574,3822,1603, 295,1535, 705,3823,4219, 283, 858, 417,7828,7829,3224,4503,  # 6774
+4504,3051,1220,1889,1046,2276,2456,4004,1393,1599, 689,2567, 388,4220,7830,2484,  # 6790
+ 802,7831,2798,3824,2060,1405,2254,7832,4505,3825,2109,1052,1345,3225,1585,7833,  # 6806
+ 809,7834,7835,7836, 575,2730,3477, 956,1552,1469,1144,2323,7837,2324,1560,2457,  # 6822
+3580,3226,4005, 616,2207,3155,2180,2289,7838,1832,7839,3478,4506,7840,1319,3704,  # 6838
+3705,1211,3581,1023,3227,1293,2799,7841,7842,7843,3826, 607,2306,3827, 762,2878,  # 6854
+1439,4221,1360,7844,1485,3052,7845,4507,1038,4222,1450,2061,2638,4223,1379,4508,  # 6870
+2585,7846,7847,4224,1352,1414,2325,2921,1172,7848,7849,3828,3829,7850,1797,1451,  # 6886
+7851,7852,7853,7854,2922,4006,4007,2485,2346, 411,4008,4009,3582,3300,3101,4509,  # 6902
+1561,2664,1452,4010,1375,7855,7856,  47,2959, 316,7857,1406,1591,2923,3156,7858,  # 6918
+1025,2141,3102,3157, 354,2731, 884,2224,4225,2407, 508,3706, 726,3583, 996,2428,  # 6934
+3584, 729,7859, 392,2191,1453,4011,4510,3707,7860,7861,2458,3585,2608,1675,2800,  # 6950
+ 919,2347,2960,2348,1270,4511,4012,  73,7862,7863, 647,7864,3228,2843,2255,1550,  # 6966
+1346,3006,7865,1332, 883,3479,7866,7867,7868,7869,3301,2765,7870,1212, 831,1347,  # 6982
+4226,4512,2326,3830,1863,3053, 720,3831,4513,4514,3832,7871,4227,7872,7873,4515,  # 6998
+7874,7875,1798,4516,3708,2609,4517,3586,1645,2371,7876,7877,2924, 669,2208,2665,  # 7014
+2429,7878,2879,7879,7880,1028,3229,7881,4228,2408,7882,2256,1353,7883,7884,4518,  # 7030
+3158, 518,7885,4013,7886,4229,1960,7887,2142,4230,7888,7889,3007,2349,2350,3833,  # 7046
+ 516,1833,1454,4014,2699,4231,4519,2225,2610,1971,1129,3587,7890,2766,7891,2961,  # 7062
+1422, 577,1470,3008,1524,3373,7892,7893, 432,4232,3054,3480,7894,2586,1455,2508,  # 7078
+2226,1972,1175,7895,1020,2732,4015,3481,4520,7896,2733,7897,1743,1361,3055,3482,  # 7094
+2639,4016,4233,4521,2290, 895, 924,4234,2170, 331,2243,3056, 166,1627,3057,1098,  # 7110
+7898,1232,2880,2227,3374,4522, 657, 403,1196,2372, 542,3709,3375,1600,4235,3483,  # 7126
+7899,4523,2767,3230, 576, 530,1362,7900,4524,2533,2666,3710,4017,7901, 842,3834,  # 7142
+7902,2801,2031,1014,4018, 213,2700,3376, 665, 621,4236,7903,3711,2925,2430,7904,  # 7158
+2431,3302,3588,3377,7905,4237,2534,4238,4525,3589,1682,4239,3484,1380,7906, 724,  # 7174
+2277, 600,1670,7907,1337,1233,4526,3103,2244,7908,1621,4527,7909, 651,4240,7910,  # 7190
+1612,4241,2611,7911,2844,7912,2734,2307,3058,7913, 716,2459,3059, 174,1255,2701,  # 7206
+4019,3590, 548,1320,1398, 728,4020,1574,7914,1890,1197,3060,4021,7915,3061,3062,  # 7222
+3712,3591,3713, 747,7916, 635,4242,4528,7917,7918,7919,4243,7920,7921,4529,7922,  # 7238
+3378,4530,2432, 451,7923,3714,2535,2072,4244,2735,4245,4022,7924,1764,4531,7925,  # 7254
+4246, 350,7926,2278,2390,2486,7927,4247,4023,2245,1434,4024, 488,4532, 458,4248,  # 7270
+4025,3715, 771,1330,2391,3835,2568,3159,2159,2409,1553,2667,3160,4249,7928,2487,  # 7286
+2881,2612,1720,2702,4250,3379,4533,7929,2536,4251,7930,3231,4252,2768,7931,2015,  # 7302
+2736,7932,1155,1017,3716,3836,7933,3303,2308, 201,1864,4253,1430,7934,4026,7935,  # 7318
+7936,7937,7938,7939,4254,1604,7940, 414,1865, 371,2587,4534,4535,3485,2016,3104,  # 7334
+4536,1708, 960,4255, 887, 389,2171,1536,1663,1721,7941,2228,4027,2351,2926,1580,  # 7350
+7942,7943,7944,1744,7945,2537,4537,4538,7946,4539,7947,2073,7948,7949,3592,3380,  # 7366
+2882,4256,7950,4257,2640,3381,2802, 673,2703,2460, 709,3486,4028,3593,4258,7951,  # 7382
+1148, 502, 634,7952,7953,1204,4540,3594,1575,4541,2613,3717,7954,3718,3105, 948,  # 7398
+3232, 121,1745,3837,1110,7955,4259,3063,2509,3009,4029,3719,1151,1771,3838,1488,  # 7414
+4030,1986,7956,2433,3487,7957,7958,2093,7959,4260,3839,1213,1407,2803, 531,2737,  # 7430
+2538,3233,1011,1537,7960,2769,4261,3106,1061,7961,3720,3721,1866,2883,7962,2017,  # 7446
+ 120,4262,4263,2062,3595,3234,2309,3840,2668,3382,1954,4542,7963,7964,3488,1047,  # 7462
+2704,1266,7965,1368,4543,2845, 649,3383,3841,2539,2738,1102,2846,2669,7966,7967,  # 7478
+1999,7968,1111,3596,2962,7969,2488,3842,3597,2804,1854,3384,3722,7970,7971,3385,  # 7494
+2410,2884,3304,3235,3598,7972,2569,7973,3599,2805,4031,1460, 856,7974,3600,7975,  # 7510
+2885,2963,7976,2886,3843,7977,4264, 632,2510, 875,3844,1697,3845,2291,7978,7979,  # 7526
+4544,3010,1239, 580,4545,4265,7980, 914, 936,2074,1190,4032,1039,2123,7981,7982,  # 7542
+7983,3386,1473,7984,1354,4266,3846,7985,2172,3064,4033, 915,3305,4267,4268,3306,  # 7558
+1605,1834,7986,2739, 398,3601,4269,3847,4034, 328,1912,2847,4035,3848,1331,4270,  # 7574
+3011, 937,4271,7987,3602,4036,4037,3387,2160,4546,3388, 524, 742, 538,3065,1012,  # 7590
+7988,7989,3849,2461,7990, 658,1103, 225,3850,7991,7992,4547,7993,4548,7994,3236,  # 7606
+1243,7995,4038, 963,2246,4549,7996,2705,3603,3161,7997,7998,2588,2327,7999,4550,  # 7622
+8000,8001,8002,3489,3307, 957,3389,2540,2032,1930,2927,2462, 870,2018,3604,1746,  # 7638
+2770,2771,2434,2463,8003,3851,8004,3723,3107,3724,3490,3390,3725,8005,1179,3066,  # 7654
+8006,3162,2373,4272,3726,2541,3163,3108,2740,4039,8007,3391,1556,2542,2292, 977,  # 7670
+2887,2033,4040,1205,3392,8008,1765,3393,3164,2124,1271,1689, 714,4551,3491,8009,  # 7686
+2328,3852, 533,4273,3605,2181, 617,8010,2464,3308,3492,2310,8011,8012,3165,8013,  # 7702
+8014,3853,1987, 618, 427,2641,3493,3394,8015,8016,1244,1690,8017,2806,4274,4552,  # 7718
+8018,3494,8019,8020,2279,1576, 473,3606,4275,3395, 972,8021,3607,8022,3067,8023,  # 7734
+8024,4553,4554,8025,3727,4041,4042,8026, 153,4555, 356,8027,1891,2888,4276,2143,  # 7750
+ 408, 803,2352,8028,3854,8029,4277,1646,2570,2511,4556,4557,3855,8030,3856,4278,  # 7766
+8031,2411,3396, 752,8032,8033,1961,2964,8034, 746,3012,2465,8035,4279,3728, 698,  # 7782
+4558,1892,4280,3608,2543,4559,3609,3857,8036,3166,3397,8037,1823,1302,4043,2706,  # 7798
+3858,1973,4281,8038,4282,3167, 823,1303,1288,1236,2848,3495,4044,3398, 774,3859,  # 7814
+8039,1581,4560,1304,2849,3860,4561,8040,2435,2161,1083,3237,4283,4045,4284, 344,  # 7830
+1173, 288,2311, 454,1683,8041,8042,1461,4562,4046,2589,8043,8044,4563, 985, 894,  # 7846
+8045,3399,3168,8046,1913,2928,3729,1988,8047,2110,1974,8048,4047,8049,2571,1194,  # 7862
+ 425,8050,4564,3169,1245,3730,4285,8051,8052,2850,8053, 636,4565,1855,3861, 760,  # 7878
+1799,8054,4286,2209,1508,4566,4048,1893,1684,2293,8055,8056,8057,4287,4288,2210,  # 7894
+ 479,8058,8059, 832,8060,4049,2489,8061,2965,2490,3731, 990,3109, 627,1814,2642,  # 7910
+4289,1582,4290,2125,2111,3496,4567,8062, 799,4291,3170,8063,4568,2112,1737,3013,  # 7926
+1018, 543, 754,4292,3309,1676,4569,4570,4050,8064,1489,8065,3497,8066,2614,2889,  # 7942
+4051,8067,8068,2966,8069,8070,8071,8072,3171,4571,4572,2182,1722,8073,3238,3239,  # 7958
+1842,3610,1715, 481, 365,1975,1856,8074,8075,1962,2491,4573,8076,2126,3611,3240,  # 7974
+ 433,1894,2063,2075,8077, 602,2741,8078,8079,8080,8081,8082,3014,1628,3400,8083,  # 7990
+3172,4574,4052,2890,4575,2512,8084,2544,2772,8085,8086,8087,3310,4576,2891,8088,  # 8006
+4577,8089,2851,4578,4579,1221,2967,4053,2513,8090,8091,8092,1867,1989,8093,8094,  # 8022
+8095,1895,8096,8097,4580,1896,4054, 318,8098,2094,4055,4293,8099,8100, 485,8101,  # 8038
+ 938,3862, 553,2670, 116,8102,3863,3612,8103,3498,2671,2773,3401,3311,2807,8104,  # 8054
+3613,2929,4056,1747,2930,2968,8105,8106, 207,8107,8108,2672,4581,2514,8109,3015,  # 8070
+ 890,3614,3864,8110,1877,3732,3402,8111,2183,2353,3403,1652,8112,8113,8114, 941,  # 8086
+2294, 208,3499,4057,2019, 330,4294,3865,2892,2492,3733,4295,8115,8116,8117,8118,  # 8102
+)
+
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euctwprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euctwprober.py
new file mode 100644
index 0000000..35669cc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/euctwprober.py
@@ -0,0 +1,46 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .mbcharsetprober import MultiByteCharSetProber
+from .codingstatemachine import CodingStateMachine
+from .chardistribution import EUCTWDistributionAnalysis
+from .mbcssm import EUCTW_SM_MODEL
+
+class EUCTWProber(MultiByteCharSetProber):
+    def __init__(self):
+        super(EUCTWProber, self).__init__()
+        self.coding_sm = CodingStateMachine(EUCTW_SM_MODEL)
+        self.distribution_analyzer = EUCTWDistributionAnalysis()
+        self.reset()
+
+    @property
+    def charset_name(self):
+        return "EUC-TW"
+
+    @property
+    def language(self):
+        return "Taiwan"
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/gb2312freq.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/gb2312freq.py
new file mode 100644
index 0000000..697837b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/gb2312freq.py
@@ -0,0 +1,283 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# GB2312 most frequently used character table
+#
+# Char to FreqOrder table , from hz6763
+
+# 512  --> 0.79  -- 0.79
+# 1024 --> 0.92  -- 0.13
+# 2048 --> 0.98  -- 0.06
+# 6768 --> 1.00  -- 0.02
+#
+# Ideal Distribution Ratio = 0.79135/(1-0.79135) = 3.79
+# Random Distribution Ration = 512 / (3755 - 512) = 0.157
+#
+# Typical Distribution Ratio about 25% of Ideal one, still much higher that RDR
+
+GB2312_TYPICAL_DISTRIBUTION_RATIO = 0.9
+
+GB2312_TABLE_SIZE = 3760
+
+GB2312_CHAR_TO_FREQ_ORDER = (
+1671, 749,1443,2364,3924,3807,2330,3921,1704,3463,2691,1511,1515, 572,3191,2205,
+2361, 224,2558, 479,1711, 963,3162, 440,4060,1905,2966,2947,3580,2647,3961,3842,
+2204, 869,4207, 970,2678,5626,2944,2956,1479,4048, 514,3595, 588,1346,2820,3409,
+ 249,4088,1746,1873,2047,1774, 581,1813, 358,1174,3590,1014,1561,4844,2245, 670,
+1636,3112, 889,1286, 953, 556,2327,3060,1290,3141, 613, 185,3477,1367, 850,3820,
+1715,2428,2642,2303,2732,3041,2562,2648,3566,3946,1349, 388,3098,2091,1360,3585,
+ 152,1687,1539, 738,1559,  59,1232,2925,2267,1388,1249,1741,1679,2960, 151,1566,
+1125,1352,4271, 924,4296, 385,3166,4459, 310,1245,2850,  70,3285,2729,3534,3575,
+2398,3298,3466,1960,2265, 217,3647, 864,1909,2084,4401,2773,1010,3269,5152, 853,
+3051,3121,1244,4251,1895, 364,1499,1540,2313,1180,3655,2268, 562, 715,2417,3061,
+ 544, 336,3768,2380,1752,4075, 950, 280,2425,4382, 183,2759,3272, 333,4297,2155,
+1688,2356,1444,1039,4540, 736,1177,3349,2443,2368,2144,2225, 565, 196,1482,3406,
+ 927,1335,4147, 692, 878,1311,1653,3911,3622,1378,4200,1840,2969,3149,2126,1816,
+2534,1546,2393,2760, 737,2494,  13, 447, 245,2747,  38,2765,2129,2589,1079, 606,
+ 360, 471,3755,2890, 404, 848, 699,1785,1236, 370,2221,1023,3746,2074,2026,2023,
+2388,1581,2119, 812,1141,3091,2536,1519, 804,2053, 406,1596,1090, 784, 548,4414,
+1806,2264,2936,1100, 343,4114,5096, 622,3358, 743,3668,1510,1626,5020,3567,2513,
+3195,4115,5627,2489,2991,  24,2065,2697,1087,2719,  48,1634, 315,  68, 985,2052,
+ 198,2239,1347,1107,1439, 597,2366,2172, 871,3307, 919,2487,2790,1867, 236,2570,
+1413,3794, 906,3365,3381,1701,1982,1818,1524,2924,1205, 616,2586,2072,2004, 575,
+ 253,3099,  32,1365,1182, 197,1714,2454,1201, 554,3388,3224,2748, 756,2587, 250,
+2567,1507,1517,3529,1922,2761,2337,3416,1961,1677,2452,2238,3153, 615, 911,1506,
+1474,2495,1265,1906,2749,3756,3280,2161, 898,2714,1759,3450,2243,2444, 563,  26,
+3286,2266,3769,3344,2707,3677, 611,1402, 531,1028,2871,4548,1375, 261,2948, 835,
+1190,4134, 353, 840,2684,1900,3082,1435,2109,1207,1674, 329,1872,2781,4055,2686,
+2104, 608,3318,2423,2957,2768,1108,3739,3512,3271,3985,2203,1771,3520,1418,2054,
+1681,1153, 225,1627,2929, 162,2050,2511,3687,1954, 124,1859,2431,1684,3032,2894,
+ 585,4805,3969,2869,2704,2088,2032,2095,3656,2635,4362,2209, 256, 518,2042,2105,
+3777,3657, 643,2298,1148,1779, 190, 989,3544, 414,  11,2135,2063,2979,1471, 403,
+3678, 126, 770,1563, 671,2499,3216,2877, 600,1179, 307,2805,4937,1268,1297,2694,
+ 252,4032,1448,1494,1331,1394, 127,2256, 222,1647,1035,1481,3056,1915,1048, 873,
+3651, 210,  33,1608,2516, 200,1520, 415, 102,   0,3389,1287, 817,  91,3299,2940,
+ 836,1814, 549,2197,1396,1669,2987,3582,2297,2848,4528,1070, 687,  20,1819, 121,
+1552,1364,1461,1968,2617,3540,2824,2083, 177, 948,4938,2291, 110,4549,2066, 648,
+3359,1755,2110,2114,4642,4845,1693,3937,3308,1257,1869,2123, 208,1804,3159,2992,
+2531,2549,3361,2418,1350,2347,2800,2568,1291,2036,2680,  72, 842,1990, 212,1233,
+1154,1586,  75,2027,3410,4900,1823,1337,2710,2676, 728,2810,1522,3026,4995, 157,
+ 755,1050,4022, 710, 785,1936,2194,2085,1406,2777,2400, 150,1250,4049,1206, 807,
+1910, 534, 529,3309,1721,1660, 274,  39,2827, 661,2670,1578, 925,3248,3815,1094,
+4278,4901,4252,  41,1150,3747,2572,2227,4501,3658,4902,3813,3357,3617,2884,2258,
+ 887, 538,4187,3199,1294,2439,3042,2329,2343,2497,1255, 107, 543,1527, 521,3478,
+3568, 194,5062,  15, 961,3870,1241,1192,2664,  66,5215,3260,2111,1295,1127,2152,
+3805,4135, 901,1164,1976, 398,1278, 530,1460, 748, 904,1054,1966,1426,  53,2909,
+ 509, 523,2279,1534, 536,1019, 239,1685, 460,2353, 673,1065,2401,3600,4298,2272,
+1272,2363, 284,1753,3679,4064,1695,  81, 815,2677,2757,2731,1386, 859, 500,4221,
+2190,2566, 757,1006,2519,2068,1166,1455, 337,2654,3203,1863,1682,1914,3025,1252,
+1409,1366, 847, 714,2834,2038,3209, 964,2970,1901, 885,2553,1078,1756,3049, 301,
+1572,3326, 688,2130,1996,2429,1805,1648,2930,3421,2750,3652,3088, 262,1158,1254,
+ 389,1641,1812, 526,1719, 923,2073,1073,1902, 468, 489,4625,1140, 857,2375,3070,
+3319,2863, 380, 116,1328,2693,1161,2244, 273,1212,1884,2769,3011,1775,1142, 461,
+3066,1200,2147,2212, 790, 702,2695,4222,1601,1058, 434,2338,5153,3640,  67,2360,
+4099,2502, 618,3472,1329, 416,1132, 830,2782,1807,2653,3211,3510,1662, 192,2124,
+ 296,3979,1739,1611,3684,  23, 118, 324, 446,1239,1225, 293,2520,3814,3795,2535,
+3116,  17,1074, 467,2692,2201, 387,2922,  45,1326,3055,1645,3659,2817, 958, 243,
+1903,2320,1339,2825,1784,3289, 356, 576, 865,2315,2381,3377,3916,1088,3122,1713,
+1655, 935, 628,4689,1034,1327, 441, 800, 720, 894,1979,2183,1528,5289,2702,1071,
+4046,3572,2399,1571,3281,  79, 761,1103, 327, 134, 758,1899,1371,1615, 879, 442,
+ 215,2605,2579, 173,2048,2485,1057,2975,3317,1097,2253,3801,4263,1403,1650,2946,
+ 814,4968,3487,1548,2644,1567,1285,   2, 295,2636,  97, 946,3576, 832, 141,4257,
+3273, 760,3821,3521,3156,2607, 949,1024,1733,1516,1803,1920,2125,2283,2665,3180,
+1501,2064,3560,2171,1592, 803,3518,1416, 732,3897,4258,1363,1362,2458, 119,1427,
+ 602,1525,2608,1605,1639,3175, 694,3064,  10, 465,  76,2000,4846,4208, 444,3781,
+1619,3353,2206,1273,3796, 740,2483, 320,1723,2377,3660,2619,1359,1137,1762,1724,
+2345,2842,1850,1862, 912, 821,1866, 612,2625,1735,2573,3369,1093, 844,  89, 937,
+ 930,1424,3564,2413,2972,1004,3046,3019,2011, 711,3171,1452,4178, 428, 801,1943,
+ 432, 445,2811, 206,4136,1472, 730, 349,  73, 397,2802,2547, 998,1637,1167, 789,
+ 396,3217, 154,1218, 716,1120,1780,2819,4826,1931,3334,3762,2139,1215,2627, 552,
+3664,3628,3232,1405,2383,3111,1356,2652,3577,3320,3101,1703, 640,1045,1370,1246,
+4996, 371,1575,2436,1621,2210, 984,4033,1734,2638,  16,4529, 663,2755,3255,1451,
+3917,2257,1253,1955,2234,1263,2951, 214,1229, 617, 485, 359,1831,1969, 473,2310,
+ 750,2058, 165,  80,2864,2419, 361,4344,2416,2479,1134, 796,3726,1266,2943, 860,
+2715, 938, 390,2734,1313,1384, 248, 202, 877,1064,2854, 522,3907, 279,1602, 297,
+2357, 395,3740, 137,2075, 944,4089,2584,1267,3802,  62,1533,2285, 178, 176, 780,
+2440, 201,3707, 590, 478,1560,4354,2117,1075,  30,  74,4643,4004,1635,1441,2745,
+ 776,2596, 238,1077,1692,1912,2844, 605, 499,1742,3947, 241,3053, 980,1749, 936,
+2640,4511,2582, 515,1543,2162,5322,2892,2993, 890,2148,1924, 665,1827,3581,1032,
+ 968,3163, 339,1044,1896, 270, 583,1791,1720,4367,1194,3488,3669,  43,2523,1657,
+ 163,2167, 290,1209,1622,3378, 550, 634,2508,2510, 695,2634,2384,2512,1476,1414,
+ 220,1469,2341,2138,2852,3183,2900,4939,2865,3502,1211,3680, 854,3227,1299,2976,
+3172, 186,2998,1459, 443,1067,3251,1495, 321,1932,3054, 909, 753,1410,1828, 436,
+2441,1119,1587,3164,2186,1258, 227, 231,1425,1890,3200,3942, 247, 959, 725,5254,
+2741, 577,2158,2079, 929, 120, 174, 838,2813, 591,1115, 417,2024,  40,3240,1536,
+1037, 291,4151,2354, 632,1298,2406,2500,3535,1825,1846,3451, 205,1171, 345,4238,
+  18,1163, 811, 685,2208,1217, 425,1312,1508,1175,4308,2552,1033, 587,1381,3059,
+2984,3482, 340,1316,4023,3972, 792,3176, 519, 777,4690, 918, 933,4130,2981,3741,
+  90,3360,2911,2200,5184,4550, 609,3079,2030, 272,3379,2736, 363,3881,1130,1447,
+ 286, 779, 357,1169,3350,3137,1630,1220,2687,2391, 747,1277,3688,2618,2682,2601,
+1156,3196,5290,4034,3102,1689,3596,3128, 874, 219,2783, 798, 508,1843,2461, 269,
+1658,1776,1392,1913,2983,3287,2866,2159,2372, 829,4076,  46,4253,2873,1889,1894,
+ 915,1834,1631,2181,2318, 298, 664,2818,3555,2735, 954,3228,3117, 527,3511,2173,
+ 681,2712,3033,2247,2346,3467,1652, 155,2164,3382, 113,1994, 450, 899, 494, 994,
+1237,2958,1875,2336,1926,3727, 545,1577,1550, 633,3473, 204,1305,3072,2410,1956,
+2471, 707,2134, 841,2195,2196,2663,3843,1026,4940, 990,3252,4997, 368,1092, 437,
+3212,3258,1933,1829, 675,2977,2893, 412, 943,3723,4644,3294,3283,2230,2373,5154,
+2389,2241,2661,2323,1404,2524, 593, 787, 677,3008,1275,2059, 438,2709,2609,2240,
+2269,2246,1446,  36,1568,1373,3892,1574,2301,1456,3962, 693,2276,5216,2035,1143,
+2720,1919,1797,1811,2763,4137,2597,1830,1699,1488,1198,2090, 424,1694, 312,3634,
+3390,4179,3335,2252,1214, 561,1059,3243,2295,2561, 975,5155,2321,2751,3772, 472,
+1537,3282,3398,1047,2077,2348,2878,1323,3340,3076, 690,2906,  51, 369, 170,3541,
+1060,2187,2688,3670,2541,1083,1683, 928,3918, 459, 109,4427, 599,3744,4286, 143,
+2101,2730,2490,  82,1588,3036,2121, 281,1860, 477,4035,1238,2812,3020,2716,3312,
+1530,2188,2055,1317, 843, 636,1808,1173,3495, 649, 181,1002, 147,3641,1159,2414,
+3750,2289,2795, 813,3123,2610,1136,4368,   5,3391,4541,2174, 420, 429,1728, 754,
+1228,2115,2219, 347,2223,2733, 735,1518,3003,2355,3134,1764,3948,3329,1888,2424,
+1001,1234,1972,3321,3363,1672,1021,1450,1584, 226, 765, 655,2526,3404,3244,2302,
+3665, 731, 594,2184, 319,1576, 621, 658,2656,4299,2099,3864,1279,2071,2598,2739,
+ 795,3086,3699,3908,1707,2352,2402,1382,3136,2475,1465,4847,3496,3865,1085,3004,
+2591,1084, 213,2287,1963,3565,2250, 822, 793,4574,3187,1772,1789,3050, 595,1484,
+1959,2770,1080,2650, 456, 422,2996, 940,3322,4328,4345,3092,2742, 965,2784, 739,
+4124, 952,1358,2498,2949,2565, 332,2698,2378, 660,2260,2473,4194,3856,2919, 535,
+1260,2651,1208,1428,1300,1949,1303,2942, 433,2455,2450,1251,1946, 614,1269, 641,
+1306,1810,2737,3078,2912, 564,2365,1419,1415,1497,4460,2367,2185,1379,3005,1307,
+3218,2175,1897,3063, 682,1157,4040,4005,1712,1160,1941,1399, 394, 402,2952,1573,
+1151,2986,2404, 862, 299,2033,1489,3006, 346, 171,2886,3401,1726,2932, 168,2533,
+  47,2507,1030,3735,1145,3370,1395,1318,1579,3609,4560,2857,4116,1457,2529,1965,
+ 504,1036,2690,2988,2405, 745,5871, 849,2397,2056,3081, 863,2359,3857,2096,  99,
+1397,1769,2300,4428,1643,3455,1978,1757,3718,1440,  35,4879,3742,1296,4228,2280,
+ 160,5063,1599,2013, 166, 520,3479,1646,3345,3012, 490,1937,1545,1264,2182,2505,
+1096,1188,1369,1436,2421,1667,2792,2460,1270,2122, 727,3167,2143, 806,1706,1012,
+1800,3037, 960,2218,1882, 805, 139,2456,1139,1521, 851,1052,3093,3089, 342,2039,
+ 744,5097,1468,1502,1585,2087, 223, 939, 326,2140,2577, 892,2481,1623,4077, 982,
+3708, 135,2131,  87,2503,3114,2326,1106, 876,1616, 547,2997,2831,2093,3441,4530,
+4314,   9,3256,4229,4148, 659,1462,1986,1710,2046,2913,2231,4090,4880,5255,3392,
+3274,1368,3689,4645,1477, 705,3384,3635,1068,1529,2941,1458,3782,1509, 100,1656,
+2548, 718,2339, 408,1590,2780,3548,1838,4117,3719,1345,3530, 717,3442,2778,3220,
+2898,1892,4590,3614,3371,2043,1998,1224,3483, 891, 635, 584,2559,3355, 733,1766,
+1729,1172,3789,1891,2307, 781,2982,2271,1957,1580,5773,2633,2005,4195,3097,1535,
+3213,1189,1934,5693,3262, 586,3118,1324,1598, 517,1564,2217,1868,1893,4445,3728,
+2703,3139,1526,1787,1992,3882,2875,1549,1199,1056,2224,1904,2711,5098,4287, 338,
+1993,3129,3489,2689,1809,2815,1997, 957,1855,3898,2550,3275,3057,1105,1319, 627,
+1505,1911,1883,3526, 698,3629,3456,1833,1431, 746,  77,1261,2017,2296,1977,1885,
+ 125,1334,1600, 525,1798,1109,2222,1470,1945, 559,2236,1186,3443,2476,1929,1411,
+2411,3135,1777,3372,2621,1841,1613,3229, 668,1430,1839,2643,2916, 195,1989,2671,
+2358,1387, 629,3205,2293,5256,4439, 123,1310, 888,1879,4300,3021,3605,1003,1162,
+3192,2910,2010, 140,2395,2859,  55,1082,2012,2901, 662, 419,2081,1438, 680,2774,
+4654,3912,1620,1731,1625,5035,4065,2328, 512,1344, 802,5443,2163,2311,2537, 524,
+3399,  98,1155,2103,1918,2606,3925,2816,1393,2465,1504,3773,2177,3963,1478,4346,
+ 180,1113,4655,3461,2028,1698, 833,2696,1235,1322,1594,4408,3623,3013,3225,2040,
+3022, 541,2881, 607,3632,2029,1665,1219, 639,1385,1686,1099,2803,3231,1938,3188,
+2858, 427, 676,2772,1168,2025, 454,3253,2486,3556, 230,1950, 580, 791,1991,1280,
+1086,1974,2034, 630, 257,3338,2788,4903,1017,  86,4790, 966,2789,1995,1696,1131,
+ 259,3095,4188,1308, 179,1463,5257, 289,4107,1248,  42,3413,1725,2288, 896,1947,
+ 774,4474,4254, 604,3430,4264, 392,2514,2588, 452, 237,1408,3018, 988,4531,1970,
+3034,3310, 540,2370,1562,1288,2990, 502,4765,1147,   4,1853,2708, 207, 294,2814,
+4078,2902,2509, 684,  34,3105,3532,2551, 644, 709,2801,2344, 573,1727,3573,3557,
+2021,1081,3100,4315,2100,3681, 199,2263,1837,2385, 146,3484,1195,2776,3949, 997,
+1939,3973,1008,1091,1202,1962,1847,1149,4209,5444,1076, 493, 117,5400,2521, 972,
+1490,2934,1796,4542,2374,1512,2933,2657, 413,2888,1135,2762,2314,2156,1355,2369,
+ 766,2007,2527,2170,3124,2491,2593,2632,4757,2437, 234,3125,3591,1898,1750,1376,
+1942,3468,3138, 570,2127,2145,3276,4131, 962, 132,1445,4196,  19, 941,3624,3480,
+3366,1973,1374,4461,3431,2629, 283,2415,2275, 808,2887,3620,2112,2563,1353,3610,
+ 955,1089,3103,1053,  96,  88,4097, 823,3808,1583, 399, 292,4091,3313, 421,1128,
+ 642,4006, 903,2539,1877,2082, 596,  29,4066,1790, 722,2157, 130, 995,1569, 769,
+1485, 464, 513,2213, 288,1923,1101,2453,4316, 133, 486,2445,  50, 625, 487,2207,
+  57, 423, 481,2962, 159,3729,1558, 491, 303, 482, 501, 240,2837, 112,3648,2392,
+1783, 362,   8,3433,3422, 610,2793,3277,1390,1284,1654,  21,3823, 734, 367, 623,
+ 193, 287, 374,1009,1483, 816, 476, 313,2255,2340,1262,2150,2899,1146,2581, 782,
+2116,1659,2018,1880, 255,3586,3314,1110,2867,2137,2564, 986,2767,5185,2006, 650,
+ 158, 926, 762, 881,3157,2717,2362,3587, 306,3690,3245,1542,3077,2427,1691,2478,
+2118,2985,3490,2438, 539,2305, 983, 129,1754, 355,4201,2386, 827,2923, 104,1773,
+2838,2771, 411,2905,3919, 376, 767, 122,1114, 828,2422,1817,3506, 266,3460,1007,
+1609,4998, 945,2612,4429,2274, 726,1247,1964,2914,2199,2070,4002,4108, 657,3323,
+1422, 579, 455,2764,4737,1222,2895,1670, 824,1223,1487,2525, 558, 861,3080, 598,
+2659,2515,1967, 752,2583,2376,2214,4180, 977, 704,2464,4999,2622,4109,1210,2961,
+ 819,1541, 142,2284,  44, 418, 457,1126,3730,4347,4626,1644,1876,3671,1864, 302,
+1063,5694, 624, 723,1984,3745,1314,1676,2488,1610,1449,3558,3569,2166,2098, 409,
+1011,2325,3704,2306, 818,1732,1383,1824,1844,3757, 999,2705,3497,1216,1423,2683,
+2426,2954,2501,2726,2229,1475,2554,5064,1971,1794,1666,2014,1343, 783, 724, 191,
+2434,1354,2220,5065,1763,2752,2472,4152, 131, 175,2885,3434,  92,1466,4920,2616,
+3871,3872,3866, 128,1551,1632, 669,1854,3682,4691,4125,1230, 188,2973,3290,1302,
+1213, 560,3266, 917, 763,3909,3249,1760, 868,1958, 764,1782,2097, 145,2277,3774,
+4462,  64,1491,3062, 971,2132,3606,2442, 221,1226,1617, 218, 323,1185,3207,3147,
+ 571, 619,1473,1005,1744,2281, 449,1887,2396,3685, 275, 375,3816,1743,3844,3731,
+ 845,1983,2350,4210,1377, 773, 967,3499,3052,3743,2725,4007,1697,1022,3943,1464,
+3264,2855,2722,1952,1029,2839,2467,  84,4383,2215, 820,1391,2015,2448,3672, 377,
+1948,2168, 797,2545,3536,2578,2645,  94,2874,1678, 405,1259,3071, 771, 546,1315,
+ 470,1243,3083, 895,2468, 981, 969,2037, 846,4181, 653,1276,2928,  14,2594, 557,
+3007,2474, 156, 902,1338,1740,2574, 537,2518, 973,2282,2216,2433,1928, 138,2903,
+1293,2631,1612, 646,3457, 839,2935, 111, 496,2191,2847, 589,3186, 149,3994,2060,
+4031,2641,4067,3145,1870,  37,3597,2136,1025,2051,3009,3383,3549,1121,1016,3261,
+1301, 251,2446,2599,2153, 872,3246, 637, 334,3705, 831, 884, 921,3065,3140,4092,
+2198,1944, 246,2964, 108,2045,1152,1921,2308,1031, 203,3173,4170,1907,3890, 810,
+1401,2003,1690, 506, 647,1242,2828,1761,1649,3208,2249,1589,3709,2931,5156,1708,
+ 498, 666,2613, 834,3817,1231, 184,2851,1124, 883,3197,2261,3710,1765,1553,2658,
+1178,2639,2351,  93,1193, 942,2538,2141,4402, 235,1821, 870,1591,2192,1709,1871,
+3341,1618,4126,2595,2334, 603, 651,  69, 701, 268,2662,3411,2555,1380,1606, 503,
+ 448, 254,2371,2646, 574,1187,2309,1770, 322,2235,1292,1801, 305, 566,1133, 229,
+2067,2057, 706, 167, 483,2002,2672,3295,1820,3561,3067, 316, 378,2746,3452,1112,
+ 136,1981, 507,1651,2917,1117, 285,4591, 182,2580,3522,1304, 335,3303,1835,2504,
+1795,1792,2248, 674,1018,2106,2449,1857,2292,2845, 976,3047,1781,2600,2727,1389,
+1281,  52,3152, 153, 265,3950, 672,3485,3951,4463, 430,1183, 365, 278,2169,  27,
+1407,1336,2304, 209,1340,1730,2202,1852,2403,2883, 979,1737,1062, 631,2829,2542,
+3876,2592, 825,2086,2226,3048,3625, 352,1417,3724, 542, 991, 431,1351,3938,1861,
+2294, 826,1361,2927,3142,3503,1738, 463,2462,2723, 582,1916,1595,2808, 400,3845,
+3891,2868,3621,2254,  58,2492,1123, 910,2160,2614,1372,1603,1196,1072,3385,1700,
+3267,1980, 696, 480,2430, 920, 799,1570,2920,1951,2041,4047,2540,1321,4223,2469,
+3562,2228,1271,2602, 401,2833,3351,2575,5157, 907,2312,1256, 410, 263,3507,1582,
+ 996, 678,1849,2316,1480, 908,3545,2237, 703,2322, 667,1826,2849,1531,2604,2999,
+2407,3146,2151,2630,1786,3711, 469,3542, 497,3899,2409, 858, 837,4446,3393,1274,
+ 786, 620,1845,2001,3311, 484, 308,3367,1204,1815,3691,2332,1532,2557,1842,2020,
+2724,1927,2333,4440, 567,  22,1673,2728,4475,1987,1858,1144,1597, 101,1832,3601,
+  12, 974,3783,4391, 951,1412,   1,3720, 453,4608,4041, 528,1041,1027,3230,2628,
+1129, 875,1051,3291,1203,2262,1069,2860,2799,2149,2615,3278, 144,1758,3040,  31,
+ 475,1680, 366,2685,3184, 311,1642,4008,2466,5036,1593,1493,2809, 216,1420,1668,
+ 233, 304,2128,3284, 232,1429,1768,1040,2008,3407,2740,2967,2543, 242,2133, 778,
+1565,2022,2620, 505,2189,2756,1098,2273, 372,1614, 708, 553,2846,2094,2278, 169,
+3626,2835,4161, 228,2674,3165, 809,1454,1309, 466,1705,1095, 900,3423, 880,2667,
+3751,5258,2317,3109,2571,4317,2766,1503,1342, 866,4447,1118,  63,2076, 314,1881,
+1348,1061, 172, 978,3515,1747, 532, 511,3970,   6, 601, 905,2699,3300,1751, 276,
+1467,3725,2668,  65,4239,2544,2779,2556,1604, 578,2451,1802, 992,2331,2624,1320,
+3446, 713,1513,1013, 103,2786,2447,1661, 886,1702, 916, 654,3574,2031,1556, 751,
+2178,2821,2179,1498,1538,2176, 271, 914,2251,2080,1325, 638,1953,2937,3877,2432,
+2754,  95,3265,1716, 260,1227,4083, 775, 106,1357,3254, 426,1607, 555,2480, 772,
+1985, 244,2546, 474, 495,1046,2611,1851,2061,  71,2089,1675,2590, 742,3758,2843,
+3222,1433, 267,2180,2576,2826,2233,2092,3913,2435, 956,1745,3075, 856,2113,1116,
+ 451,   3,1988,2896,1398, 993,2463,1878,2049,1341,2718,2721,2870,2108, 712,2904,
+4363,2753,2324, 277,2872,2349,2649, 384, 987, 435, 691,3000, 922, 164,3939, 652,
+1500,1184,4153,2482,3373,2165,4848,2335,3775,3508,3154,2806,2830,1554,2102,1664,
+2530,1434,2408, 893,1547,2623,3447,2832,2242,2532,3169,2856,3223,2078,  49,3770,
+3469, 462, 318, 656,2259,3250,3069, 679,1629,2758, 344,1138,1104,3120,1836,1283,
+3115,2154,1437,4448, 934, 759,1999, 794,2862,1038, 533,2560,1722,2342, 855,2626,
+1197,1663,4476,3127,  85,4240,2528,  25,1111,1181,3673, 407,3470,4561,2679,2713,
+ 768,1925,2841,3986,1544,1165, 932, 373,1240,2146,1930,2673, 721,4766, 354,4333,
+ 391,2963, 187,  61,3364,1442,1102, 330,1940,1767, 341,3809,4118, 393,2496,2062,
+2211, 105, 331, 300, 439, 913,1332, 626, 379,3304,1557, 328, 689,3952, 309,1555,
+ 931, 317,2517,3027, 325, 569, 686,2107,3084,  60,1042,1333,2794, 264,3177,4014,
+1628, 258,3712,   7,4464,1176,1043,1778, 683, 114,1975,  78,1492, 383,1886, 510,
+ 386, 645,5291,2891,2069,3305,4138,3867,2939,2603,2493,1935,1066,1848,3588,1015,
+1282,1289,4609, 697,1453,3044,2666,3611,1856,2412,  54, 719,1330, 568,3778,2459,
+1748, 788, 492, 551,1191,1000, 488,3394,3763, 282,1799, 348,2016,1523,3155,2390,
+1049, 382,2019,1788,1170, 729,2968,3523, 897,3926,2785,2938,3292, 350,2319,3238,
+1718,1717,2655,3453,3143,4465, 161,2889,2980,2009,1421,  56,1908,1640,2387,2232,
+1917,1874,2477,4921, 148,  83,3438, 592,4245,2882,1822,1055, 741, 115,1496,1624,
+ 381,1638,4592,1020, 516,3214, 458, 947,4575,1432, 211,1514,2926,1865,2142, 189,
+ 852,1221,1400,1486, 882,2299,4036, 351,  28,1122, 700,6479,6480,6481,6482,6483,  #last 512
+)
+
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/gb2312prober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/gb2312prober.py
new file mode 100644
index 0000000..8446d2d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/gb2312prober.py
@@ -0,0 +1,46 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .mbcharsetprober import MultiByteCharSetProber
+from .codingstatemachine import CodingStateMachine
+from .chardistribution import GB2312DistributionAnalysis
+from .mbcssm import GB2312_SM_MODEL
+
+class GB2312Prober(MultiByteCharSetProber):
+    def __init__(self):
+        super(GB2312Prober, self).__init__()
+        self.coding_sm = CodingStateMachine(GB2312_SM_MODEL)
+        self.distribution_analyzer = GB2312DistributionAnalysis()
+        self.reset()
+
+    @property
+    def charset_name(self):
+        return "GB2312"
+
+    @property
+    def language(self):
+        return "Chinese"
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/hebrewprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/hebrewprober.py
new file mode 100644
index 0000000..b0e1bf4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/hebrewprober.py
@@ -0,0 +1,292 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Universal charset detector code.
+#
+# The Initial Developer of the Original Code is
+#          Shy Shalom
+# Portions created by the Initial Developer are Copyright (C) 2005
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .charsetprober import CharSetProber
+from .enums import ProbingState
+
+# This prober doesn't actually recognize a language or a charset.
+# It is a helper prober for the use of the Hebrew model probers
+
+### General ideas of the Hebrew charset recognition ###
+#
+# Four main charsets exist in Hebrew:
+# "ISO-8859-8" - Visual Hebrew
+# "windows-1255" - Logical Hebrew
+# "ISO-8859-8-I" - Logical Hebrew
+# "x-mac-hebrew" - ?? Logical Hebrew ??
+#
+# Both "ISO" charsets use a completely identical set of code points, whereas
+# "windows-1255" and "x-mac-hebrew" are two different proper supersets of
+# these code points. windows-1255 defines additional characters in the range
+# 0x80-0x9F as some misc punctuation marks as well as some Hebrew-specific
+# diacritics and additional 'Yiddish' ligature letters in the range 0xc0-0xd6.
+# x-mac-hebrew defines similar additional code points but with a different
+# mapping.
+#
+# As far as an average Hebrew text with no diacritics is concerned, all four
+# charsets are identical with respect to code points. Meaning that for the
+# main Hebrew alphabet, all four map the same values to all 27 Hebrew letters
+# (including final letters).
+#
+# The dominant difference between these charsets is their directionality.
+# "Visual" directionality means that the text is ordered as if the renderer is
+# not aware of a BIDI rendering algorithm. The renderer sees the text and
+# draws it from left to right. The text itself when ordered naturally is read
+# backwards. A buffer of Visual Hebrew generally looks like so:
+# "[last word of first line spelled backwards] [whole line ordered backwards
+# and spelled backwards] [first word of first line spelled backwards]
+# [end of line] [last word of second line] ... etc' "
+# adding punctuation marks, numbers and English text to visual text is
+# naturally also "visual" and from left to right.
+#
+# "Logical" directionality means the text is ordered "naturally" according to
+# the order it is read. It is the responsibility of the renderer to display
+# the text from right to left. A BIDI algorithm is used to place general
+# punctuation marks, numbers and English text in the text.
+#
+# Texts in x-mac-hebrew are almost impossible to find on the Internet. From
+# what little evidence I could find, it seems that its general directionality
+# is Logical.
+#
+# To sum up all of the above, the Hebrew probing mechanism knows about two
+# charsets:
+# Visual Hebrew - "ISO-8859-8" - backwards text - Words and sentences are
+#    backwards while line order is natural. For charset recognition purposes
+#    the line order is unimportant (In fact, for this implementation, even
+#    word order is unimportant).
+# Logical Hebrew - "windows-1255" - normal, naturally ordered text.
+#
+# "ISO-8859-8-I" is a subset of windows-1255 and doesn't need to be
+#    specifically identified.
+# "x-mac-hebrew" is also identified as windows-1255. A text in x-mac-hebrew
+#    that contain special punctuation marks or diacritics is displayed with
+#    some unconverted characters showing as question marks. This problem might
+#    be corrected using another model prober for x-mac-hebrew. Due to the fact
+#    that x-mac-hebrew texts are so rare, writing another model prober isn't
+#    worth the effort and performance hit.
+#
+#### The Prober ####
+#
+# The prober is divided between two SBCharSetProbers and a HebrewProber,
+# all of which are managed, created, fed data, inquired and deleted by the
+# SBCSGroupProber. The two SBCharSetProbers identify that the text is in
+# fact some kind of Hebrew, Logical or Visual. The final decision about which
+# one is it is made by the HebrewProber by combining final-letter scores
+# with the scores of the two SBCharSetProbers to produce a final answer.
+#
+# The SBCSGroupProber is responsible for stripping the original text of HTML
+# tags, English characters, numbers, low-ASCII punctuation characters, spaces
+# and new lines. It reduces any sequence of such characters to a single space.
+# The buffer fed to each prober in the SBCS group prober is pure text in
+# high-ASCII.
+# The two SBCharSetProbers (model probers) share the same language model:
+# Win1255Model.
+# The first SBCharSetProber uses the model normally as any other
+# SBCharSetProber does, to recognize windows-1255, upon which this model was
+# built. The second SBCharSetProber is told to make the pair-of-letter
+# lookup in the language model backwards. This in practice exactly simulates
+# a visual Hebrew model using the windows-1255 logical Hebrew model.
+#
+# The HebrewProber is not using any language model. All it does is look for
+# final-letter evidence suggesting the text is either logical Hebrew or visual
+# Hebrew. Disjointed from the model probers, the results of the HebrewProber
+# alone are meaningless. HebrewProber always returns 0.00 as confidence
+# since it never identifies a charset by itself. Instead, the pointer to the
+# HebrewProber is passed to the model probers as a helper "Name Prober".
+# When the Group prober receives a positive identification from any prober,
+# it asks for the name of the charset identified. If the prober queried is a
+# Hebrew model prober, the model prober forwards the call to the
+# HebrewProber to make the final decision. In the HebrewProber, the
+# decision is made according to the final-letters scores maintained and Both
+# model probers scores. The answer is returned in the form of the name of the
+# charset identified, either "windows-1255" or "ISO-8859-8".
+
+class HebrewProber(CharSetProber):
+    # windows-1255 / ISO-8859-8 code points of interest
+    FINAL_KAF = 0xea
+    NORMAL_KAF = 0xeb
+    FINAL_MEM = 0xed
+    NORMAL_MEM = 0xee
+    FINAL_NUN = 0xef
+    NORMAL_NUN = 0xf0
+    FINAL_PE = 0xf3
+    NORMAL_PE = 0xf4
+    FINAL_TSADI = 0xf5
+    NORMAL_TSADI = 0xf6
+
+    # Minimum Visual vs Logical final letter score difference.
+    # If the difference is below this, don't rely solely on the final letter score
+    # distance.
+    MIN_FINAL_CHAR_DISTANCE = 5
+
+    # Minimum Visual vs Logical model score difference.
+    # If the difference is below this, don't rely at all on the model score
+    # distance.
+    MIN_MODEL_DISTANCE = 0.01
+
+    VISUAL_HEBREW_NAME = "ISO-8859-8"
+    LOGICAL_HEBREW_NAME = "windows-1255"
+
+    def __init__(self):
+        super(HebrewProber, self).__init__()
+        self._final_char_logical_score = None
+        self._final_char_visual_score = None
+        self._prev = None
+        self._before_prev = None
+        self._logical_prober = None
+        self._visual_prober = None
+        self.reset()
+
+    def reset(self):
+        self._final_char_logical_score = 0
+        self._final_char_visual_score = 0
+        # The two last characters seen in the previous buffer,
+        # mPrev and mBeforePrev are initialized to space in order to simulate
+        # a word delimiter at the beginning of the data
+        self._prev = ' '
+        self._before_prev = ' '
+        # These probers are owned by the group prober.
+
+    def set_model_probers(self, logicalProber, visualProber):
+        self._logical_prober = logicalProber
+        self._visual_prober = visualProber
+
+    def is_final(self, c):
+        return c in [self.FINAL_KAF, self.FINAL_MEM, self.FINAL_NUN,
+                     self.FINAL_PE, self.FINAL_TSADI]
+
+    def is_non_final(self, c):
+        # The normal Tsadi is not a good Non-Final letter due to words like
+        # 'lechotet' (to chat) containing an apostrophe after the tsadi. This
+        # apostrophe is converted to a space in FilterWithoutEnglishLetters
+        # causing the Non-Final tsadi to appear at an end of a word even
+        # though this is not the case in the original text.
+        # The letters Pe and Kaf rarely display a related behavior of not being
+        # a good Non-Final letter. Words like 'Pop', 'Winamp' and 'Mubarak'
+        # for example legally end with a Non-Final Pe or Kaf. However, the
+        # benefit of these letters as Non-Final letters outweighs the damage
+        # since these words are quite rare.
+        return c in [self.NORMAL_KAF, self.NORMAL_MEM,
+                     self.NORMAL_NUN, self.NORMAL_PE]
+
+    def feed(self, byte_str):
+        # Final letter analysis for logical-visual decision.
+        # Look for evidence that the received buffer is either logical Hebrew
+        # or visual Hebrew.
+        # The following cases are checked:
+        # 1) A word longer than 1 letter, ending with a final letter. This is
+        #    an indication that the text is laid out "naturally" since the
+        #    final letter really appears at the end. +1 for logical score.
+        # 2) A word longer than 1 letter, ending with a Non-Final letter. In
+        #    normal Hebrew, words ending with Kaf, Mem, Nun, Pe or Tsadi,
+        #    should not end with the Non-Final form of that letter. Exceptions
+        #    to this rule are mentioned above in isNonFinal(). This is an
+        #    indication that the text is laid out backwards. +1 for visual
+        #    score
+        # 3) A word longer than 1 letter, starting with a final letter. Final
+        #    letters should not appear at the beginning of a word. This is an
+        #    indication that the text is laid out backwards. +1 for visual
+        #    score.
+        #
+        # The visual score and logical score are accumulated throughout the
+        # text and are finally checked against each other in GetCharSetName().
+        # No checking for final letters in the middle of words is done since
+        # that case is not an indication for either Logical or Visual text.
+        #
+        # We automatically filter out all 7-bit characters (replace them with
+        # spaces) so the word boundary detection works properly. [MAP]
+
+        if self.state == ProbingState.NOT_ME:
+            # Both model probers say it's not them. No reason to continue.
+            return ProbingState.NOT_ME
+
+        byte_str = self.filter_high_byte_only(byte_str)
+
+        for cur in byte_str:
+            if cur == ' ':
+                # We stand on a space - a word just ended
+                if self._before_prev != ' ':
+                    # next-to-last char was not a space so self._prev is not a
+                    # 1 letter word
+                    if self.is_final(self._prev):
+                        # case (1) [-2:not space][-1:final letter][cur:space]
+                        self._final_char_logical_score += 1
+                    elif self.is_non_final(self._prev):
+                        # case (2) [-2:not space][-1:Non-Final letter][
+                        #  cur:space]
+                        self._final_char_visual_score += 1
+            else:
+                # Not standing on a space
+                if ((self._before_prev == ' ') and
+                        (self.is_final(self._prev)) and (cur != ' ')):
+                    # case (3) [-2:space][-1:final letter][cur:not space]
+                    self._final_char_visual_score += 1
+            self._before_prev = self._prev
+            self._prev = cur
+
+        # Forever detecting, till the end or until both model probers return
+        # ProbingState.NOT_ME (handled above)
+        return ProbingState.DETECTING
+
+    @property
+    def charset_name(self):
+        # Make the decision: is it Logical or Visual?
+        # If the final letter score distance is dominant enough, rely on it.
+        finalsub = self._final_char_logical_score - self._final_char_visual_score
+        if finalsub >= self.MIN_FINAL_CHAR_DISTANCE:
+            return self.LOGICAL_HEBREW_NAME
+        if finalsub <= -self.MIN_FINAL_CHAR_DISTANCE:
+            return self.VISUAL_HEBREW_NAME
+
+        # It's not dominant enough, try to rely on the model scores instead.
+        modelsub = (self._logical_prober.get_confidence()
+                    - self._visual_prober.get_confidence())
+        if modelsub > self.MIN_MODEL_DISTANCE:
+            return self.LOGICAL_HEBREW_NAME
+        if modelsub < -self.MIN_MODEL_DISTANCE:
+            return self.VISUAL_HEBREW_NAME
+
+        # Still no good, back to final letter distance, maybe it'll save the
+        # day.
+        if finalsub < 0.0:
+            return self.VISUAL_HEBREW_NAME
+
+        # (finalsub > 0 - Logical) or (don't know what to do) default to
+        # Logical.
+        return self.LOGICAL_HEBREW_NAME
+
+    @property
+    def language(self):
+        return 'Hebrew'
+
+    @property
+    def state(self):
+        # Remain active as long as any of the model probers are active.
+        if (self._logical_prober.state == ProbingState.NOT_ME) and \
+           (self._visual_prober.state == ProbingState.NOT_ME):
+            return ProbingState.NOT_ME
+        return ProbingState.DETECTING
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/jisfreq.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/jisfreq.py
new file mode 100644
index 0000000..83fc082
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/jisfreq.py
@@ -0,0 +1,325 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# Sampling from about 20M text materials include literature and computer technology
+#
+# Japanese frequency table, applied to both S-JIS and EUC-JP
+# They are sorted in order.
+
+# 128  --> 0.77094
+# 256  --> 0.85710
+# 512  --> 0.92635
+# 1024 --> 0.97130
+# 2048 --> 0.99431
+#
+# Ideal Distribution Ratio = 0.92635 / (1-0.92635) = 12.58
+# Random Distribution Ration = 512 / (2965+62+83+86-512) = 0.191
+#
+# Typical Distribution Ratio, 25% of IDR
+
+JIS_TYPICAL_DISTRIBUTION_RATIO = 3.0
+
+# Char to FreqOrder table ,
+JIS_TABLE_SIZE = 4368
+
+JIS_CHAR_TO_FREQ_ORDER = (
+  40,   1,   6, 182, 152, 180, 295,2127, 285, 381,3295,4304,3068,4606,3165,3510, #   16
+3511,1822,2785,4607,1193,2226,5070,4608, 171,2996,1247,  18, 179,5071, 856,1661, #   32
+1262,5072, 619, 127,3431,3512,3230,1899,1700, 232, 228,1294,1298, 284, 283,2041, #   48
+2042,1061,1062,  48,  49,  44,  45, 433, 434,1040,1041, 996, 787,2997,1255,4305, #   64
+2108,4609,1684,1648,5073,5074,5075,5076,5077,5078,3687,5079,4610,5080,3927,3928, #   80
+5081,3296,3432, 290,2285,1471,2187,5082,2580,2825,1303,2140,1739,1445,2691,3375, #   96
+1691,3297,4306,4307,4611, 452,3376,1182,2713,3688,3069,4308,5083,5084,5085,5086, #  112
+5087,5088,5089,5090,5091,5092,5093,5094,5095,5096,5097,5098,5099,5100,5101,5102, #  128
+5103,5104,5105,5106,5107,5108,5109,5110,5111,5112,4097,5113,5114,5115,5116,5117, #  144
+5118,5119,5120,5121,5122,5123,5124,5125,5126,5127,5128,5129,5130,5131,5132,5133, #  160
+5134,5135,5136,5137,5138,5139,5140,5141,5142,5143,5144,5145,5146,5147,5148,5149, #  176
+5150,5151,5152,4612,5153,5154,5155,5156,5157,5158,5159,5160,5161,5162,5163,5164, #  192
+5165,5166,5167,5168,5169,5170,5171,5172,5173,5174,5175,1472, 598, 618, 820,1205, #  208
+1309,1412,1858,1307,1692,5176,5177,5178,5179,5180,5181,5182,1142,1452,1234,1172, #  224
+1875,2043,2149,1793,1382,2973, 925,2404,1067,1241, 960,1377,2935,1491, 919,1217, #  240
+1865,2030,1406,1499,2749,4098,5183,5184,5185,5186,5187,5188,2561,4099,3117,1804, #  256
+2049,3689,4309,3513,1663,5189,3166,3118,3298,1587,1561,3433,5190,3119,1625,2998, #  272
+3299,4613,1766,3690,2786,4614,5191,5192,5193,5194,2161,  26,3377,   2,3929,  20, #  288
+3691,  47,4100,  50,  17,  16,  35, 268,  27, 243,  42, 155,  24, 154,  29, 184, #  304
+   4,  91,  14,  92,  53, 396,  33, 289,   9,  37,  64, 620,  21,  39, 321,   5, #  320
+  12,  11,  52,  13,   3, 208, 138,   0,   7,  60, 526, 141, 151,1069, 181, 275, #  336
+1591,  83, 132,1475, 126, 331, 829,  15,  69, 160,  59,  22, 157,  55,1079, 312, #  352
+ 109,  38,  23,  25,  10,  19,  79,5195,  61, 382,1124,   8,  30,5196,5197,5198, #  368
+5199,5200,5201,5202,5203,5204,5205,5206,  89,  62,  74,  34,2416, 112, 139, 196, #  384
+ 271, 149,  84, 607, 131, 765,  46,  88, 153, 683,  76, 874, 101, 258,  57,  80, #  400
+  32, 364, 121,1508, 169,1547,  68, 235, 145,2999,  41, 360,3027,  70,  63,  31, #  416
+  43, 259, 262,1383,  99, 533, 194,  66,  93, 846, 217, 192,  56, 106,  58, 565, #  432
+ 280, 272, 311, 256, 146,  82, 308,  71, 100, 128, 214, 655, 110, 261, 104,1140, #  448
+  54,  51,  36,  87,  67,3070, 185,2618,2936,2020,  28,1066,2390,2059,5207,5208, #  464
+5209,5210,5211,5212,5213,5214,5215,5216,4615,5217,5218,5219,5220,5221,5222,5223, #  480
+5224,5225,5226,5227,5228,5229,5230,5231,5232,5233,5234,5235,5236,3514,5237,5238, #  496
+5239,5240,5241,5242,5243,5244,2297,2031,4616,4310,3692,5245,3071,5246,3598,5247, #  512
+4617,3231,3515,5248,4101,4311,4618,3808,4312,4102,5249,4103,4104,3599,5250,5251, #  528
+5252,5253,5254,5255,5256,5257,5258,5259,5260,5261,5262,5263,5264,5265,5266,5267, #  544
+5268,5269,5270,5271,5272,5273,5274,5275,5276,5277,5278,5279,5280,5281,5282,5283, #  560
+5284,5285,5286,5287,5288,5289,5290,5291,5292,5293,5294,5295,5296,5297,5298,5299, #  576
+5300,5301,5302,5303,5304,5305,5306,5307,5308,5309,5310,5311,5312,5313,5314,5315, #  592
+5316,5317,5318,5319,5320,5321,5322,5323,5324,5325,5326,5327,5328,5329,5330,5331, #  608
+5332,5333,5334,5335,5336,5337,5338,5339,5340,5341,5342,5343,5344,5345,5346,5347, #  624
+5348,5349,5350,5351,5352,5353,5354,5355,5356,5357,5358,5359,5360,5361,5362,5363, #  640
+5364,5365,5366,5367,5368,5369,5370,5371,5372,5373,5374,5375,5376,5377,5378,5379, #  656
+5380,5381, 363, 642,2787,2878,2788,2789,2316,3232,2317,3434,2011, 165,1942,3930, #  672
+3931,3932,3933,5382,4619,5383,4620,5384,5385,5386,5387,5388,5389,5390,5391,5392, #  688
+5393,5394,5395,5396,5397,5398,5399,5400,5401,5402,5403,5404,5405,5406,5407,5408, #  704
+5409,5410,5411,5412,5413,5414,5415,5416,5417,5418,5419,5420,5421,5422,5423,5424, #  720
+5425,5426,5427,5428,5429,5430,5431,5432,5433,5434,5435,5436,5437,5438,5439,5440, #  736
+5441,5442,5443,5444,5445,5446,5447,5448,5449,5450,5451,5452,5453,5454,5455,5456, #  752
+5457,5458,5459,5460,5461,5462,5463,5464,5465,5466,5467,5468,5469,5470,5471,5472, #  768
+5473,5474,5475,5476,5477,5478,5479,5480,5481,5482,5483,5484,5485,5486,5487,5488, #  784
+5489,5490,5491,5492,5493,5494,5495,5496,5497,5498,5499,5500,5501,5502,5503,5504, #  800
+5505,5506,5507,5508,5509,5510,5511,5512,5513,5514,5515,5516,5517,5518,5519,5520, #  816
+5521,5522,5523,5524,5525,5526,5527,5528,5529,5530,5531,5532,5533,5534,5535,5536, #  832
+5537,5538,5539,5540,5541,5542,5543,5544,5545,5546,5547,5548,5549,5550,5551,5552, #  848
+5553,5554,5555,5556,5557,5558,5559,5560,5561,5562,5563,5564,5565,5566,5567,5568, #  864
+5569,5570,5571,5572,5573,5574,5575,5576,5577,5578,5579,5580,5581,5582,5583,5584, #  880
+5585,5586,5587,5588,5589,5590,5591,5592,5593,5594,5595,5596,5597,5598,5599,5600, #  896
+5601,5602,5603,5604,5605,5606,5607,5608,5609,5610,5611,5612,5613,5614,5615,5616, #  912
+5617,5618,5619,5620,5621,5622,5623,5624,5625,5626,5627,5628,5629,5630,5631,5632, #  928
+5633,5634,5635,5636,5637,5638,5639,5640,5641,5642,5643,5644,5645,5646,5647,5648, #  944
+5649,5650,5651,5652,5653,5654,5655,5656,5657,5658,5659,5660,5661,5662,5663,5664, #  960
+5665,5666,5667,5668,5669,5670,5671,5672,5673,5674,5675,5676,5677,5678,5679,5680, #  976
+5681,5682,5683,5684,5685,5686,5687,5688,5689,5690,5691,5692,5693,5694,5695,5696, #  992
+5697,5698,5699,5700,5701,5702,5703,5704,5705,5706,5707,5708,5709,5710,5711,5712, # 1008
+5713,5714,5715,5716,5717,5718,5719,5720,5721,5722,5723,5724,5725,5726,5727,5728, # 1024
+5729,5730,5731,5732,5733,5734,5735,5736,5737,5738,5739,5740,5741,5742,5743,5744, # 1040
+5745,5746,5747,5748,5749,5750,5751,5752,5753,5754,5755,5756,5757,5758,5759,5760, # 1056
+5761,5762,5763,5764,5765,5766,5767,5768,5769,5770,5771,5772,5773,5774,5775,5776, # 1072
+5777,5778,5779,5780,5781,5782,5783,5784,5785,5786,5787,5788,5789,5790,5791,5792, # 1088
+5793,5794,5795,5796,5797,5798,5799,5800,5801,5802,5803,5804,5805,5806,5807,5808, # 1104
+5809,5810,5811,5812,5813,5814,5815,5816,5817,5818,5819,5820,5821,5822,5823,5824, # 1120
+5825,5826,5827,5828,5829,5830,5831,5832,5833,5834,5835,5836,5837,5838,5839,5840, # 1136
+5841,5842,5843,5844,5845,5846,5847,5848,5849,5850,5851,5852,5853,5854,5855,5856, # 1152
+5857,5858,5859,5860,5861,5862,5863,5864,5865,5866,5867,5868,5869,5870,5871,5872, # 1168
+5873,5874,5875,5876,5877,5878,5879,5880,5881,5882,5883,5884,5885,5886,5887,5888, # 1184
+5889,5890,5891,5892,5893,5894,5895,5896,5897,5898,5899,5900,5901,5902,5903,5904, # 1200
+5905,5906,5907,5908,5909,5910,5911,5912,5913,5914,5915,5916,5917,5918,5919,5920, # 1216
+5921,5922,5923,5924,5925,5926,5927,5928,5929,5930,5931,5932,5933,5934,5935,5936, # 1232
+5937,5938,5939,5940,5941,5942,5943,5944,5945,5946,5947,5948,5949,5950,5951,5952, # 1248
+5953,5954,5955,5956,5957,5958,5959,5960,5961,5962,5963,5964,5965,5966,5967,5968, # 1264
+5969,5970,5971,5972,5973,5974,5975,5976,5977,5978,5979,5980,5981,5982,5983,5984, # 1280
+5985,5986,5987,5988,5989,5990,5991,5992,5993,5994,5995,5996,5997,5998,5999,6000, # 1296
+6001,6002,6003,6004,6005,6006,6007,6008,6009,6010,6011,6012,6013,6014,6015,6016, # 1312
+6017,6018,6019,6020,6021,6022,6023,6024,6025,6026,6027,6028,6029,6030,6031,6032, # 1328
+6033,6034,6035,6036,6037,6038,6039,6040,6041,6042,6043,6044,6045,6046,6047,6048, # 1344
+6049,6050,6051,6052,6053,6054,6055,6056,6057,6058,6059,6060,6061,6062,6063,6064, # 1360
+6065,6066,6067,6068,6069,6070,6071,6072,6073,6074,6075,6076,6077,6078,6079,6080, # 1376
+6081,6082,6083,6084,6085,6086,6087,6088,6089,6090,6091,6092,6093,6094,6095,6096, # 1392
+6097,6098,6099,6100,6101,6102,6103,6104,6105,6106,6107,6108,6109,6110,6111,6112, # 1408
+6113,6114,2044,2060,4621, 997,1235, 473,1186,4622, 920,3378,6115,6116, 379,1108, # 1424
+4313,2657,2735,3934,6117,3809, 636,3233, 573,1026,3693,3435,2974,3300,2298,4105, # 1440
+ 854,2937,2463, 393,2581,2417, 539, 752,1280,2750,2480, 140,1161, 440, 708,1569, # 1456
+ 665,2497,1746,1291,1523,3000, 164,1603, 847,1331, 537,1997, 486, 508,1693,2418, # 1472
+1970,2227, 878,1220, 299,1030, 969, 652,2751, 624,1137,3301,2619,  65,3302,2045, # 1488
+1761,1859,3120,1930,3694,3516, 663,1767, 852, 835,3695, 269, 767,2826,2339,1305, # 1504
+ 896,1150, 770,1616,6118, 506,1502,2075,1012,2519, 775,2520,2975,2340,2938,4314, # 1520
+3028,2086,1224,1943,2286,6119,3072,4315,2240,1273,1987,3935,1557, 175, 597, 985, # 1536
+3517,2419,2521,1416,3029, 585, 938,1931,1007,1052,1932,1685,6120,3379,4316,4623, # 1552
+ 804, 599,3121,1333,2128,2539,1159,1554,2032,3810, 687,2033,2904, 952, 675,1467, # 1568
+3436,6121,2241,1096,1786,2440,1543,1924, 980,1813,2228, 781,2692,1879, 728,1918, # 1584
+3696,4624, 548,1950,4625,1809,1088,1356,3303,2522,1944, 502, 972, 373, 513,2827, # 1600
+ 586,2377,2391,1003,1976,1631,6122,2464,1084, 648,1776,4626,2141, 324, 962,2012, # 1616
+2177,2076,1384, 742,2178,1448,1173,1810, 222, 102, 301, 445, 125,2420, 662,2498, # 1632
+ 277, 200,1476,1165,1068, 224,2562,1378,1446, 450,1880, 659, 791, 582,4627,2939, # 1648
+3936,1516,1274, 555,2099,3697,1020,1389,1526,3380,1762,1723,1787,2229, 412,2114, # 1664
+1900,2392,3518, 512,2597, 427,1925,2341,3122,1653,1686,2465,2499, 697, 330, 273, # 1680
+ 380,2162, 951, 832, 780, 991,1301,3073, 965,2270,3519, 668,2523,2636,1286, 535, # 1696
+1407, 518, 671, 957,2658,2378, 267, 611,2197,3030,6123, 248,2299, 967,1799,2356, # 1712
+ 850,1418,3437,1876,1256,1480,2828,1718,6124,6125,1755,1664,2405,6126,4628,2879, # 1728
+2829, 499,2179, 676,4629, 557,2329,2214,2090, 325,3234, 464, 811,3001, 992,2342, # 1744
+2481,1232,1469, 303,2242, 466,1070,2163, 603,1777,2091,4630,2752,4631,2714, 322, # 1760
+2659,1964,1768, 481,2188,1463,2330,2857,3600,2092,3031,2421,4632,2318,2070,1849, # 1776
+2598,4633,1302,2254,1668,1701,2422,3811,2905,3032,3123,2046,4106,1763,1694,4634, # 1792
+1604, 943,1724,1454, 917, 868,2215,1169,2940, 552,1145,1800,1228,1823,1955, 316, # 1808
+1080,2510, 361,1807,2830,4107,2660,3381,1346,1423,1134,4108,6127, 541,1263,1229, # 1824
+1148,2540, 545, 465,1833,2880,3438,1901,3074,2482, 816,3937, 713,1788,2500, 122, # 1840
+1575, 195,1451,2501,1111,6128, 859, 374,1225,2243,2483,4317, 390,1033,3439,3075, # 1856
+2524,1687, 266, 793,1440,2599, 946, 779, 802, 507, 897,1081, 528,2189,1292, 711, # 1872
+1866,1725,1167,1640, 753, 398,2661,1053, 246, 348,4318, 137,1024,3440,1600,2077, # 1888
+2129, 825,4319, 698, 238, 521, 187,2300,1157,2423,1641,1605,1464,1610,1097,2541, # 1904
+1260,1436, 759,2255,1814,2150, 705,3235, 409,2563,3304, 561,3033,2005,2564, 726, # 1920
+1956,2343,3698,4109, 949,3812,3813,3520,1669, 653,1379,2525, 881,2198, 632,2256, # 1936
+1027, 778,1074, 733,1957, 514,1481,2466, 554,2180, 702,3938,1606,1017,1398,6129, # 1952
+1380,3521, 921, 993,1313, 594, 449,1489,1617,1166, 768,1426,1360, 495,1794,3601, # 1968
+1177,3602,1170,4320,2344, 476, 425,3167,4635,3168,1424, 401,2662,1171,3382,1998, # 1984
+1089,4110, 477,3169, 474,6130,1909, 596,2831,1842, 494, 693,1051,1028,1207,3076, # 2000
+ 606,2115, 727,2790,1473,1115, 743,3522, 630, 805,1532,4321,2021, 366,1057, 838, # 2016
+ 684,1114,2142,4322,2050,1492,1892,1808,2271,3814,2424,1971,1447,1373,3305,1090, # 2032
+1536,3939,3523,3306,1455,2199, 336, 369,2331,1035, 584,2393, 902, 718,2600,6131, # 2048
+2753, 463,2151,1149,1611,2467, 715,1308,3124,1268, 343,1413,3236,1517,1347,2663, # 2064
+2093,3940,2022,1131,1553,2100,2941,1427,3441,2942,1323,2484,6132,1980, 872,2368, # 2080
+2441,2943, 320,2369,2116,1082, 679,1933,3941,2791,3815, 625,1143,2023, 422,2200, # 2096
+3816,6133, 730,1695, 356,2257,1626,2301,2858,2637,1627,1778, 937, 883,2906,2693, # 2112
+3002,1769,1086, 400,1063,1325,3307,2792,4111,3077, 456,2345,1046, 747,6134,1524, # 2128
+ 884,1094,3383,1474,2164,1059, 974,1688,2181,2258,1047, 345,1665,1187, 358, 875, # 2144
+3170, 305, 660,3524,2190,1334,1135,3171,1540,1649,2542,1527, 927, 968,2793, 885, # 2160
+1972,1850, 482, 500,2638,1218,1109,1085,2543,1654,2034, 876,  78,2287,1482,1277, # 2176
+ 861,1675,1083,1779, 724,2754, 454, 397,1132,1612,2332, 893, 672,1237, 257,2259, # 2192
+2370, 135,3384, 337,2244, 547, 352, 340, 709,2485,1400, 788,1138,2511, 540, 772, # 2208
+1682,2260,2272,2544,2013,1843,1902,4636,1999,1562,2288,4637,2201,1403,1533, 407, # 2224
+ 576,3308,1254,2071, 978,3385, 170, 136,1201,3125,2664,3172,2394, 213, 912, 873, # 2240
+3603,1713,2202, 699,3604,3699, 813,3442, 493, 531,1054, 468,2907,1483, 304, 281, # 2256
+4112,1726,1252,2094, 339,2319,2130,2639, 756,1563,2944, 748, 571,2976,1588,2425, # 2272
+2715,1851,1460,2426,1528,1392,1973,3237, 288,3309, 685,3386, 296, 892,2716,2216, # 2288
+1570,2245, 722,1747,2217, 905,3238,1103,6135,1893,1441,1965, 251,1805,2371,3700, # 2304
+2601,1919,1078,  75,2182,1509,1592,1270,2640,4638,2152,6136,3310,3817, 524, 706, # 2320
+1075, 292,3818,1756,2602, 317,  98,3173,3605,3525,1844,2218,3819,2502, 814, 567, # 2336
+ 385,2908,1534,6137, 534,1642,3239, 797,6138,1670,1529, 953,4323, 188,1071, 538, # 2352
+ 178, 729,3240,2109,1226,1374,2000,2357,2977, 731,2468,1116,2014,2051,6139,1261, # 2368
+1593, 803,2859,2736,3443, 556, 682, 823,1541,6140,1369,2289,1706,2794, 845, 462, # 2384
+2603,2665,1361, 387, 162,2358,1740, 739,1770,1720,1304,1401,3241,1049, 627,1571, # 2400
+2427,3526,1877,3942,1852,1500, 431,1910,1503, 677, 297,2795, 286,1433,1038,1198, # 2416
+2290,1133,1596,4113,4639,2469,1510,1484,3943,6141,2442, 108, 712,4640,2372, 866, # 2432
+3701,2755,3242,1348, 834,1945,1408,3527,2395,3243,1811, 824, 994,1179,2110,1548, # 2448
+1453, 790,3003, 690,4324,4325,2832,2909,3820,1860,3821, 225,1748, 310, 346,1780, # 2464
+2470, 821,1993,2717,2796, 828, 877,3528,2860,2471,1702,2165,2910,2486,1789, 453, # 2480
+ 359,2291,1676,  73,1164,1461,1127,3311, 421, 604, 314,1037, 589, 116,2487, 737, # 2496
+ 837,1180, 111, 244, 735,6142,2261,1861,1362, 986, 523, 418, 581,2666,3822, 103, # 2512
+ 855, 503,1414,1867,2488,1091, 657,1597, 979, 605,1316,4641,1021,2443,2078,2001, # 2528
+1209,  96, 587,2166,1032, 260,1072,2153, 173,  94, 226,3244, 819,2006,4642,4114, # 2544
+2203, 231,1744, 782,  97,2667, 786,3387, 887, 391, 442,2219,4326,1425,6143,2694, # 2560
+ 633,1544,1202, 483,2015, 592,2052,1958,2472,1655, 419, 129,4327,3444,3312,1714, # 2576
+1257,3078,4328,1518,1098, 865,1310,1019,1885,1512,1734, 469,2444, 148, 773, 436, # 2592
+1815,1868,1128,1055,4329,1245,2756,3445,2154,1934,1039,4643, 579,1238, 932,2320, # 2608
+ 353, 205, 801, 115,2428, 944,2321,1881, 399,2565,1211, 678, 766,3944, 335,2101, # 2624
+1459,1781,1402,3945,2737,2131,1010, 844, 981,1326,1013, 550,1816,1545,2620,1335, # 2640
+1008, 371,2881, 936,1419,1613,3529,1456,1395,2273,1834,2604,1317,2738,2503, 416, # 2656
+1643,4330, 806,1126, 229, 591,3946,1314,1981,1576,1837,1666, 347,1790, 977,3313, # 2672
+ 764,2861,1853, 688,2429,1920,1462,  77, 595, 415,2002,3034, 798,1192,4115,6144, # 2688
+2978,4331,3035,2695,2582,2072,2566, 430,2430,1727, 842,1396,3947,3702, 613, 377, # 2704
+ 278, 236,1417,3388,3314,3174, 757,1869, 107,3530,6145,1194, 623,2262, 207,1253, # 2720
+2167,3446,3948, 492,1117,1935, 536,1838,2757,1246,4332, 696,2095,2406,1393,1572, # 2736
+3175,1782, 583, 190, 253,1390,2230, 830,3126,3389, 934,3245,1703,1749,2979,1870, # 2752
+2545,1656,2204, 869,2346,4116,3176,1817, 496,1764,4644, 942,1504, 404,1903,1122, # 2768
+1580,3606,2945,1022, 515, 372,1735, 955,2431,3036,6146,2797,1110,2302,2798, 617, # 2784
+6147, 441, 762,1771,3447,3607,3608,1904, 840,3037,  86, 939,1385, 572,1370,2445, # 2800
+1336, 114,3703, 898, 294, 203,3315, 703,1583,2274, 429, 961,4333,1854,1951,3390, # 2816
+2373,3704,4334,1318,1381, 966,1911,2322,1006,1155, 309, 989, 458,2718,1795,1372, # 2832
+1203, 252,1689,1363,3177, 517,1936, 168,1490, 562, 193,3823,1042,4117,1835, 551, # 2848
+ 470,4645, 395, 489,3448,1871,1465,2583,2641, 417,1493, 279,1295, 511,1236,1119, # 2864
+  72,1231,1982,1812,3004, 871,1564, 984,3449,1667,2696,2096,4646,2347,2833,1673, # 2880
+3609, 695,3246,2668, 807,1183,4647, 890, 388,2333,1801,1457,2911,1765,1477,1031, # 2896
+3316,3317,1278,3391,2799,2292,2526, 163,3450,4335,2669,1404,1802,6148,2323,2407, # 2912
+1584,1728,1494,1824,1269, 298, 909,3318,1034,1632, 375, 776,1683,2061, 291, 210, # 2928
+1123, 809,1249,1002,2642,3038, 206,1011,2132, 144, 975, 882,1565, 342, 667, 754, # 2944
+1442,2143,1299,2303,2062, 447, 626,2205,1221,2739,2912,1144,1214,2206,2584, 760, # 2960
+1715, 614, 950,1281,2670,2621, 810, 577,1287,2546,4648, 242,2168, 250,2643, 691, # 2976
+ 123,2644, 647, 313,1029, 689,1357,2946,1650, 216, 771,1339,1306, 808,2063, 549, # 2992
+ 913,1371,2913,2914,6149,1466,1092,1174,1196,1311,2605,2396,1783,1796,3079, 406, # 3008
+2671,2117,3949,4649, 487,1825,2220,6150,2915, 448,2348,1073,6151,2397,1707, 130, # 3024
+ 900,1598, 329, 176,1959,2527,1620,6152,2275,4336,3319,1983,2191,3705,3610,2155, # 3040
+3706,1912,1513,1614,6153,1988, 646, 392,2304,1589,3320,3039,1826,1239,1352,1340, # 3056
+2916, 505,2567,1709,1437,2408,2547, 906,6154,2672, 384,1458,1594,1100,1329, 710, # 3072
+ 423,3531,2064,2231,2622,1989,2673,1087,1882, 333, 841,3005,1296,2882,2379, 580, # 3088
+1937,1827,1293,2585, 601, 574, 249,1772,4118,2079,1120, 645, 901,1176,1690, 795, # 3104
+2207, 478,1434, 516,1190,1530, 761,2080, 930,1264, 355, 435,1552, 644,1791, 987, # 3120
+ 220,1364,1163,1121,1538, 306,2169,1327,1222, 546,2645, 218, 241, 610,1704,3321, # 3136
+1984,1839,1966,2528, 451,6155,2586,3707,2568, 907,3178, 254,2947, 186,1845,4650, # 3152
+ 745, 432,1757, 428,1633, 888,2246,2221,2489,3611,2118,1258,1265, 956,3127,1784, # 3168
+4337,2490, 319, 510, 119, 457,3612, 274,2035,2007,4651,1409,3128, 970,2758, 590, # 3184
+2800, 661,2247,4652,2008,3950,1420,1549,3080,3322,3951,1651,1375,2111, 485,2491, # 3200
+1429,1156,6156,2548,2183,1495, 831,1840,2529,2446, 501,1657, 307,1894,3247,1341, # 3216
+ 666, 899,2156,1539,2549,1559, 886, 349,2208,3081,2305,1736,3824,2170,2759,1014, # 3232
+1913,1386, 542,1397,2948, 490, 368, 716, 362, 159, 282,2569,1129,1658,1288,1750, # 3248
+2674, 276, 649,2016, 751,1496, 658,1818,1284,1862,2209,2087,2512,3451, 622,2834, # 3264
+ 376, 117,1060,2053,1208,1721,1101,1443, 247,1250,3179,1792,3952,2760,2398,3953, # 3280
+6157,2144,3708, 446,2432,1151,2570,3452,2447,2761,2835,1210,2448,3082, 424,2222, # 3296
+1251,2449,2119,2836, 504,1581,4338, 602, 817, 857,3825,2349,2306, 357,3826,1470, # 3312
+1883,2883, 255, 958, 929,2917,3248, 302,4653,1050,1271,1751,2307,1952,1430,2697, # 3328
+2719,2359, 354,3180, 777, 158,2036,4339,1659,4340,4654,2308,2949,2248,1146,2232, # 3344
+3532,2720,1696,2623,3827,6158,3129,1550,2698,1485,1297,1428, 637, 931,2721,2145, # 3360
+ 914,2550,2587,  81,2450, 612, 827,2646,1242,4655,1118,2884, 472,1855,3181,3533, # 3376
+3534, 569,1353,2699,1244,1758,2588,4119,2009,2762,2171,3709,1312,1531,6159,1152, # 3392
+1938, 134,1830, 471,3710,2276,1112,1535,3323,3453,3535, 982,1337,2950, 488, 826, # 3408
+ 674,1058,1628,4120,2017, 522,2399, 211, 568,1367,3454, 350, 293,1872,1139,3249, # 3424
+1399,1946,3006,1300,2360,3324, 588, 736,6160,2606, 744, 669,3536,3828,6161,1358, # 3440
+ 199, 723, 848, 933, 851,1939,1505,1514,1338,1618,1831,4656,1634,3613, 443,2740, # 3456
+3829, 717,1947, 491,1914,6162,2551,1542,4121,1025,6163,1099,1223, 198,3040,2722, # 3472
+ 370, 410,1905,2589, 998,1248,3182,2380, 519,1449,4122,1710, 947, 928,1153,4341, # 3488
+2277, 344,2624,1511, 615, 105, 161,1212,1076,1960,3130,2054,1926,1175,1906,2473, # 3504
+ 414,1873,2801,6164,2309, 315,1319,3325, 318,2018,2146,2157, 963, 631, 223,4342, # 3520
+4343,2675, 479,3711,1197,2625,3712,2676,2361,6165,4344,4123,6166,2451,3183,1886, # 3536
+2184,1674,1330,1711,1635,1506, 799, 219,3250,3083,3954,1677,3713,3326,2081,3614, # 3552
+1652,2073,4657,1147,3041,1752, 643,1961, 147,1974,3955,6167,1716,2037, 918,3007, # 3568
+1994, 120,1537, 118, 609,3184,4345, 740,3455,1219, 332,1615,3830,6168,1621,2980, # 3584
+1582, 783, 212, 553,2350,3714,1349,2433,2082,4124, 889,6169,2310,1275,1410, 973, # 3600
+ 166,1320,3456,1797,1215,3185,2885,1846,2590,2763,4658, 629, 822,3008, 763, 940, # 3616
+1990,2862, 439,2409,1566,1240,1622, 926,1282,1907,2764, 654,2210,1607, 327,1130, # 3632
+3956,1678,1623,6170,2434,2192, 686, 608,3831,3715, 903,3957,3042,6171,2741,1522, # 3648
+1915,1105,1555,2552,1359, 323,3251,4346,3457, 738,1354,2553,2311,2334,1828,2003, # 3664
+3832,1753,2351,1227,6172,1887,4125,1478,6173,2410,1874,1712,1847, 520,1204,2607, # 3680
+ 264,4659, 836,2677,2102, 600,4660,3833,2278,3084,6174,4347,3615,1342, 640, 532, # 3696
+ 543,2608,1888,2400,2591,1009,4348,1497, 341,1737,3616,2723,1394, 529,3252,1321, # 3712
+ 983,4661,1515,2120, 971,2592, 924, 287,1662,3186,4349,2700,4350,1519, 908,1948, # 3728
+2452, 156, 796,1629,1486,2223,2055, 694,4126,1259,1036,3392,1213,2249,2742,1889, # 3744
+1230,3958,1015, 910, 408, 559,3617,4662, 746, 725, 935,4663,3959,3009,1289, 563, # 3760
+ 867,4664,3960,1567,2981,2038,2626, 988,2263,2381,4351, 143,2374, 704,1895,6175, # 3776
+1188,3716,2088, 673,3085,2362,4352, 484,1608,1921,2765,2918, 215, 904,3618,3537, # 3792
+ 894, 509, 976,3043,2701,3961,4353,2837,2982, 498,6176,6177,1102,3538,1332,3393, # 3808
+1487,1636,1637, 233, 245,3962, 383, 650, 995,3044, 460,1520,1206,2352, 749,3327, # 3824
+ 530, 700, 389,1438,1560,1773,3963,2264, 719,2951,2724,3834, 870,1832,1644,1000, # 3840
+ 839,2474,3717, 197,1630,3394, 365,2886,3964,1285,2133, 734, 922, 818,1106, 732, # 3856
+ 480,2083,1774,3458, 923,2279,1350, 221,3086,  85,2233,2234,3835,1585,3010,2147, # 3872
+1387,1705,2382,1619,2475, 133, 239,2802,1991,1016,2084,2383, 411,2838,1113, 651, # 3888
+1985,1160,3328, 990,1863,3087,1048,1276,2647, 265,2627,1599,3253,2056, 150, 638, # 3904
+2019, 656, 853, 326,1479, 680,1439,4354,1001,1759, 413,3459,3395,2492,1431, 459, # 3920
+4355,1125,3329,2265,1953,1450,2065,2863, 849, 351,2678,3131,3254,3255,1104,1577, # 3936
+ 227,1351,1645,2453,2193,1421,2887, 812,2121, 634,  95,2435, 201,2312,4665,1646, # 3952
+1671,2743,1601,2554,2702,2648,2280,1315,1366,2089,3132,1573,3718,3965,1729,1189, # 3968
+ 328,2679,1077,1940,1136, 558,1283, 964,1195, 621,2074,1199,1743,3460,3619,1896, # 3984
+1916,1890,3836,2952,1154,2112,1064, 862, 378,3011,2066,2113,2803,1568,2839,6178, # 4000
+3088,2919,1941,1660,2004,1992,2194, 142, 707,1590,1708,1624,1922,1023,1836,1233, # 4016
+1004,2313, 789, 741,3620,6179,1609,2411,1200,4127,3719,3720,4666,2057,3721, 593, # 4032
+2840, 367,2920,1878,6180,3461,1521, 628,1168, 692,2211,2649, 300, 720,2067,2571, # 4048
+2953,3396, 959,2504,3966,3539,3462,1977, 701,6181, 954,1043, 800, 681, 183,3722, # 4064
+1803,1730,3540,4128,2103, 815,2314, 174, 467, 230,2454,1093,2134, 755,3541,3397, # 4080
+1141,1162,6182,1738,2039, 270,3256,2513,1005,1647,2185,3837, 858,1679,1897,1719, # 4096
+2954,2324,1806, 402, 670, 167,4129,1498,2158,2104, 750,6183, 915, 189,1680,1551, # 4112
+ 455,4356,1501,2455, 405,1095,2955, 338,1586,1266,1819, 570, 641,1324, 237,1556, # 4128
+2650,1388,3723,6184,1368,2384,1343,1978,3089,2436, 879,3724, 792,1191, 758,3012, # 4144
+1411,2135,1322,4357, 240,4667,1848,3725,1574,6185, 420,3045,1546,1391, 714,4358, # 4160
+1967, 941,1864, 863, 664, 426, 560,1731,2680,1785,2864,1949,2363, 403,3330,1415, # 4176
+1279,2136,1697,2335, 204, 721,2097,3838,  90,6186,2085,2505, 191,3967, 124,2148, # 4192
+1376,1798,1178,1107,1898,1405, 860,4359,1243,1272,2375,2983,1558,2456,1638, 113, # 4208
+3621, 578,1923,2609, 880, 386,4130, 784,2186,2266,1422,2956,2172,1722, 497, 263, # 4224
+2514,1267,2412,2610, 177,2703,3542, 774,1927,1344, 616,1432,1595,1018, 172,4360, # 4240
+2325, 911,4361, 438,1468,3622, 794,3968,2024,2173,1681,1829,2957, 945, 895,3090, # 4256
+ 575,2212,2476, 475,2401,2681, 785,2744,1745,2293,2555,1975,3133,2865, 394,4668, # 4272
+3839, 635,4131, 639, 202,1507,2195,2766,1345,1435,2572,3726,1908,1184,1181,2457, # 4288
+3727,3134,4362, 843,2611, 437, 916,4669, 234, 769,1884,3046,3047,3623, 833,6187, # 4304
+1639,2250,2402,1355,1185,2010,2047, 999, 525,1732,1290,1488,2612, 948,1578,3728, # 4320
+2413,2477,1216,2725,2159, 334,3840,1328,3624,2921,1525,4132, 564,1056, 891,4363, # 4336
+1444,1698,2385,2251,3729,1365,2281,2235,1717,6188, 864,3841,2515, 444, 527,2767, # 4352
+2922,3625, 544, 461,6189, 566, 209,2437,3398,2098,1065,2068,3331,3626,3257,2137, # 4368  #last 512
+)
+
+
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/jpcntx.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/jpcntx.py
new file mode 100644
index 0000000..20044e4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/jpcntx.py
@@ -0,0 +1,233 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+
+# This is hiragana 2-char sequence table, the number in each cell represents its frequency category
+jp2CharContext = (
+(0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1),
+(2,4,0,4,0,3,0,4,0,3,4,4,4,2,4,3,3,4,3,2,3,3,4,2,3,3,3,2,4,1,4,3,3,1,5,4,3,4,3,4,3,5,3,0,3,5,4,2,0,3,1,0,3,3,0,3,3,0,1,1,0,4,3,0,3,3,0,4,0,2,0,3,5,5,5,5,4,0,4,1,0,3,4),
+(0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2),
+(0,4,0,5,0,5,0,4,0,4,5,4,4,3,5,3,5,1,5,3,4,3,4,4,3,4,3,3,4,3,5,4,4,3,5,5,3,5,5,5,3,5,5,3,4,5,5,3,1,3,2,0,3,4,0,4,2,0,4,2,1,5,3,2,3,5,0,4,0,2,0,5,4,4,5,4,5,0,4,0,0,4,4),
+(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0),
+(0,3,0,4,0,3,0,3,0,4,5,4,3,3,3,3,4,3,5,4,4,3,5,4,4,3,4,3,4,4,4,4,5,3,4,4,3,4,5,5,4,5,5,1,4,5,4,3,0,3,3,1,3,3,0,4,4,0,3,3,1,5,3,3,3,5,0,4,0,3,0,4,4,3,4,3,3,0,4,1,1,3,4),
+(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0),
+(0,4,0,3,0,3,0,4,0,3,4,4,3,2,2,1,2,1,3,1,3,3,3,3,3,4,3,1,3,3,5,3,3,0,4,3,0,5,4,3,3,5,4,4,3,4,4,5,0,1,2,0,1,2,0,2,2,0,1,0,0,5,2,2,1,4,0,3,0,1,0,4,4,3,5,4,3,0,2,1,0,4,3),
+(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0),
+(0,3,0,5,0,4,0,2,1,4,4,2,4,1,4,2,4,2,4,3,3,3,4,3,3,3,3,1,4,2,3,3,3,1,4,4,1,1,1,4,3,3,2,0,2,4,3,2,0,3,3,0,3,1,1,0,0,0,3,3,0,4,2,2,3,4,0,4,0,3,0,4,4,5,3,4,4,0,3,0,0,1,4),
+(1,4,0,4,0,4,0,4,0,3,5,4,4,3,4,3,5,4,3,3,4,3,5,4,4,4,4,3,4,2,4,3,3,1,5,4,3,2,4,5,4,5,5,4,4,5,4,4,0,3,2,2,3,3,0,4,3,1,3,2,1,4,3,3,4,5,0,3,0,2,0,4,5,5,4,5,4,0,4,0,0,5,4),
+(0,5,0,5,0,4,0,3,0,4,4,3,4,3,3,3,4,0,4,4,4,3,4,3,4,3,3,1,4,2,4,3,4,0,5,4,1,4,5,4,4,5,3,2,4,3,4,3,2,4,1,3,3,3,2,3,2,0,4,3,3,4,3,3,3,4,0,4,0,3,0,4,5,4,4,4,3,0,4,1,0,1,3),
+(0,3,1,4,0,3,0,2,0,3,4,4,3,1,4,2,3,3,4,3,4,3,4,3,4,4,3,2,3,1,5,4,4,1,4,4,3,5,4,4,3,5,5,4,3,4,4,3,1,2,3,1,2,2,0,3,2,0,3,1,0,5,3,3,3,4,3,3,3,3,4,4,4,4,5,4,2,0,3,3,2,4,3),
+(0,2,0,3,0,1,0,1,0,0,3,2,0,0,2,0,1,0,2,1,3,3,3,1,2,3,1,0,1,0,4,2,1,1,3,3,0,4,3,3,1,4,3,3,0,3,3,2,0,0,0,0,1,0,0,2,0,0,0,0,0,4,1,0,2,3,2,2,2,1,3,3,3,4,4,3,2,0,3,1,0,3,3),
+(0,4,0,4,0,3,0,3,0,4,4,4,3,3,3,3,3,3,4,3,4,2,4,3,4,3,3,2,4,3,4,5,4,1,4,5,3,5,4,5,3,5,4,0,3,5,5,3,1,3,3,2,2,3,0,3,4,1,3,3,2,4,3,3,3,4,0,4,0,3,0,4,5,4,4,5,3,0,4,1,0,3,4),
+(0,2,0,3,0,3,0,0,0,2,2,2,1,0,1,0,0,0,3,0,3,0,3,0,1,3,1,0,3,1,3,3,3,1,3,3,3,0,1,3,1,3,4,0,0,3,1,1,0,3,2,0,0,0,0,1,3,0,1,0,0,3,3,2,0,3,0,0,0,0,0,3,4,3,4,3,3,0,3,0,0,2,3),
+(2,3,0,3,0,2,0,1,0,3,3,4,3,1,3,1,1,1,3,1,4,3,4,3,3,3,0,0,3,1,5,4,3,1,4,3,2,5,5,4,4,4,4,3,3,4,4,4,0,2,1,1,3,2,0,1,2,0,0,1,0,4,1,3,3,3,0,3,0,1,0,4,4,4,5,5,3,0,2,0,0,4,4),
+(0,2,0,1,0,3,1,3,0,2,3,3,3,0,3,1,0,0,3,0,3,2,3,1,3,2,1,1,0,0,4,2,1,0,2,3,1,4,3,2,0,4,4,3,1,3,1,3,0,1,0,0,1,0,0,0,1,0,0,0,0,4,1,1,1,2,0,3,0,0,0,3,4,2,4,3,2,0,1,0,0,3,3),
+(0,1,0,4,0,5,0,4,0,2,4,4,2,3,3,2,3,3,5,3,3,3,4,3,4,2,3,0,4,3,3,3,4,1,4,3,2,1,5,5,3,4,5,1,3,5,4,2,0,3,3,0,1,3,0,4,2,0,1,3,1,4,3,3,3,3,0,3,0,1,0,3,4,4,4,5,5,0,3,0,1,4,5),
+(0,2,0,3,0,3,0,0,0,2,3,1,3,0,4,0,1,1,3,0,3,4,3,2,3,1,0,3,3,2,3,1,3,0,2,3,0,2,1,4,1,2,2,0,0,3,3,0,0,2,0,0,0,1,0,0,0,0,2,2,0,3,2,1,3,3,0,2,0,2,0,0,3,3,1,2,4,0,3,0,2,2,3),
+(2,4,0,5,0,4,0,4,0,2,4,4,4,3,4,3,3,3,1,2,4,3,4,3,4,4,5,0,3,3,3,3,2,0,4,3,1,4,3,4,1,4,4,3,3,4,4,3,1,2,3,0,4,2,0,4,1,0,3,3,0,4,3,3,3,4,0,4,0,2,0,3,5,3,4,5,2,0,3,0,0,4,5),
+(0,3,0,4,0,1,0,1,0,1,3,2,2,1,3,0,3,0,2,0,2,0,3,0,2,0,0,0,1,0,1,1,0,0,3,1,0,0,0,4,0,3,1,0,2,1,3,0,0,0,0,0,0,3,0,0,0,0,0,0,0,4,2,2,3,1,0,3,0,0,0,1,4,4,4,3,0,0,4,0,0,1,4),
+(1,4,1,5,0,3,0,3,0,4,5,4,4,3,5,3,3,4,4,3,4,1,3,3,3,3,2,1,4,1,5,4,3,1,4,4,3,5,4,4,3,5,4,3,3,4,4,4,0,3,3,1,2,3,0,3,1,0,3,3,0,5,4,4,4,4,4,4,3,3,5,4,4,3,3,5,4,0,3,2,0,4,4),
+(0,2,0,3,0,1,0,0,0,1,3,3,3,2,4,1,3,0,3,1,3,0,2,2,1,1,0,0,2,0,4,3,1,0,4,3,0,4,4,4,1,4,3,1,1,3,3,1,0,2,0,0,1,3,0,0,0,0,2,0,0,4,3,2,4,3,5,4,3,3,3,4,3,3,4,3,3,0,2,1,0,3,3),
+(0,2,0,4,0,3,0,2,0,2,5,5,3,4,4,4,4,1,4,3,3,0,4,3,4,3,1,3,3,2,4,3,0,3,4,3,0,3,4,4,2,4,4,0,4,5,3,3,2,2,1,1,1,2,0,1,5,0,3,3,2,4,3,3,3,4,0,3,0,2,0,4,4,3,5,5,0,0,3,0,2,3,3),
+(0,3,0,4,0,3,0,1,0,3,4,3,3,1,3,3,3,0,3,1,3,0,4,3,3,1,1,0,3,0,3,3,0,0,4,4,0,1,5,4,3,3,5,0,3,3,4,3,0,2,0,1,1,1,0,1,3,0,1,2,1,3,3,2,3,3,0,3,0,1,0,1,3,3,4,4,1,0,1,2,2,1,3),
+(0,1,0,4,0,4,0,3,0,1,3,3,3,2,3,1,1,0,3,0,3,3,4,3,2,4,2,0,1,0,4,3,2,0,4,3,0,5,3,3,2,4,4,4,3,3,3,4,0,1,3,0,0,1,0,0,1,0,0,0,0,4,2,3,3,3,0,3,0,0,0,4,4,4,5,3,2,0,3,3,0,3,5),
+(0,2,0,3,0,0,0,3,0,1,3,0,2,0,0,0,1,0,3,1,1,3,3,0,0,3,0,0,3,0,2,3,1,0,3,1,0,3,3,2,0,4,2,2,0,2,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,2,1,2,0,1,0,1,0,0,0,1,3,1,2,0,0,0,1,0,0,1,4),
+(0,3,0,3,0,5,0,1,0,2,4,3,1,3,3,2,1,1,5,2,1,0,5,1,2,0,0,0,3,3,2,2,3,2,4,3,0,0,3,3,1,3,3,0,2,5,3,4,0,3,3,0,1,2,0,2,2,0,3,2,0,2,2,3,3,3,0,2,0,1,0,3,4,4,2,5,4,0,3,0,0,3,5),
+(0,3,0,3,0,3,0,1,0,3,3,3,3,0,3,0,2,0,2,1,1,0,2,0,1,0,0,0,2,1,0,0,1,0,3,2,0,0,3,3,1,2,3,1,0,3,3,0,0,1,0,0,0,0,0,2,0,0,0,0,0,2,3,1,2,3,0,3,0,1,0,3,2,1,0,4,3,0,1,1,0,3,3),
+(0,4,0,5,0,3,0,3,0,4,5,5,4,3,5,3,4,3,5,3,3,2,5,3,4,4,4,3,4,3,4,5,5,3,4,4,3,4,4,5,4,4,4,3,4,5,5,4,2,3,4,2,3,4,0,3,3,1,4,3,2,4,3,3,5,5,0,3,0,3,0,5,5,5,5,4,4,0,4,0,1,4,4),
+(0,4,0,4,0,3,0,3,0,3,5,4,4,2,3,2,5,1,3,2,5,1,4,2,3,2,3,3,4,3,3,3,3,2,5,4,1,3,3,5,3,4,4,0,4,4,3,1,1,3,1,0,2,3,0,2,3,0,3,0,0,4,3,1,3,4,0,3,0,2,0,4,4,4,3,4,5,0,4,0,0,3,4),
+(0,3,0,3,0,3,1,2,0,3,4,4,3,3,3,0,2,2,4,3,3,1,3,3,3,1,1,0,3,1,4,3,2,3,4,4,2,4,4,4,3,4,4,3,2,4,4,3,1,3,3,1,3,3,0,4,1,0,2,2,1,4,3,2,3,3,5,4,3,3,5,4,4,3,3,0,4,0,3,2,2,4,4),
+(0,2,0,1,0,0,0,0,0,1,2,1,3,0,0,0,0,0,2,0,1,2,1,0,0,1,0,0,0,0,3,0,0,1,0,1,1,3,1,0,0,0,1,1,0,1,1,0,0,0,0,0,2,0,0,0,0,0,0,0,0,1,1,2,2,0,3,4,0,0,0,1,1,0,0,1,0,0,0,0,0,1,1),
+(0,1,0,0,0,1,0,0,0,0,4,0,4,1,4,0,3,0,4,0,3,0,4,0,3,0,3,0,4,1,5,1,4,0,0,3,0,5,0,5,2,0,1,0,0,0,2,1,4,0,1,3,0,0,3,0,0,3,1,1,4,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0),
+(1,4,0,5,0,3,0,2,0,3,5,4,4,3,4,3,5,3,4,3,3,0,4,3,3,3,3,3,3,2,4,4,3,1,3,4,4,5,4,4,3,4,4,1,3,5,4,3,3,3,1,2,2,3,3,1,3,1,3,3,3,5,3,3,4,5,0,3,0,3,0,3,4,3,4,4,3,0,3,0,2,4,3),
+(0,1,0,4,0,0,0,0,0,1,4,0,4,1,4,2,4,0,3,0,1,0,1,0,0,0,0,0,2,0,3,1,1,1,0,3,0,0,0,1,2,1,0,0,1,1,1,1,0,1,0,0,0,1,0,0,3,0,0,0,0,3,2,0,2,2,0,1,0,0,0,2,3,2,3,3,0,0,0,0,2,1,0),
+(0,5,1,5,0,3,0,3,0,5,4,4,5,1,5,3,3,0,4,3,4,3,5,3,4,3,3,2,4,3,4,3,3,0,3,3,1,4,4,3,4,4,4,3,4,5,5,3,2,3,1,1,3,3,1,3,1,1,3,3,2,4,5,3,3,5,0,4,0,3,0,4,4,3,5,3,3,0,3,4,0,4,3),
+(0,5,0,5,0,3,0,2,0,4,4,3,5,2,4,3,3,3,4,4,4,3,5,3,5,3,3,1,4,0,4,3,3,0,3,3,0,4,4,4,4,5,4,3,3,5,5,3,2,3,1,2,3,2,0,1,0,0,3,2,2,4,4,3,1,5,0,4,0,3,0,4,3,1,3,2,1,0,3,3,0,3,3),
+(0,4,0,5,0,5,0,4,0,4,5,5,5,3,4,3,3,2,5,4,4,3,5,3,5,3,4,0,4,3,4,4,3,2,4,4,3,4,5,4,4,5,5,0,3,5,5,4,1,3,3,2,3,3,1,3,1,0,4,3,1,4,4,3,4,5,0,4,0,2,0,4,3,4,4,3,3,0,4,0,0,5,5),
+(0,4,0,4,0,5,0,1,1,3,3,4,4,3,4,1,3,0,5,1,3,0,3,1,3,1,1,0,3,0,3,3,4,0,4,3,0,4,4,4,3,4,4,0,3,5,4,1,0,3,0,0,2,3,0,3,1,0,3,1,0,3,2,1,3,5,0,3,0,1,0,3,2,3,3,4,4,0,2,2,0,4,4),
+(2,4,0,5,0,4,0,3,0,4,5,5,4,3,5,3,5,3,5,3,5,2,5,3,4,3,3,4,3,4,5,3,2,1,5,4,3,2,3,4,5,3,4,1,2,5,4,3,0,3,3,0,3,2,0,2,3,0,4,1,0,3,4,3,3,5,0,3,0,1,0,4,5,5,5,4,3,0,4,2,0,3,5),
+(0,5,0,4,0,4,0,2,0,5,4,3,4,3,4,3,3,3,4,3,4,2,5,3,5,3,4,1,4,3,4,4,4,0,3,5,0,4,4,4,4,5,3,1,3,4,5,3,3,3,3,3,3,3,0,2,2,0,3,3,2,4,3,3,3,5,3,4,1,3,3,5,3,2,0,0,0,0,4,3,1,3,3),
+(0,1,0,3,0,3,0,1,0,1,3,3,3,2,3,3,3,0,3,0,0,0,3,1,3,0,0,0,2,2,2,3,0,0,3,2,0,1,2,4,1,3,3,0,0,3,3,3,0,1,0,0,2,1,0,0,3,0,3,1,0,3,0,0,1,3,0,2,0,1,0,3,3,1,3,3,0,0,1,1,0,3,3),
+(0,2,0,3,0,2,1,4,0,2,2,3,1,1,3,1,1,0,2,0,3,1,2,3,1,3,0,0,1,0,4,3,2,3,3,3,1,4,2,3,3,3,3,1,0,3,1,4,0,1,1,0,1,2,0,1,1,0,1,1,0,3,1,3,2,2,0,1,0,0,0,2,3,3,3,1,0,0,0,0,0,2,3),
+(0,5,0,4,0,5,0,2,0,4,5,5,3,3,4,3,3,1,5,4,4,2,4,4,4,3,4,2,4,3,5,5,4,3,3,4,3,3,5,5,4,5,5,1,3,4,5,3,1,4,3,1,3,3,0,3,3,1,4,3,1,4,5,3,3,5,0,4,0,3,0,5,3,3,1,4,3,0,4,0,1,5,3),
+(0,5,0,5,0,4,0,2,0,4,4,3,4,3,3,3,3,3,5,4,4,4,4,4,4,5,3,3,5,2,4,4,4,3,4,4,3,3,4,4,5,5,3,3,4,3,4,3,3,4,3,3,3,3,1,2,2,1,4,3,3,5,4,4,3,4,0,4,0,3,0,4,4,4,4,4,1,0,4,2,0,2,4),
+(0,4,0,4,0,3,0,1,0,3,5,2,3,0,3,0,2,1,4,2,3,3,4,1,4,3,3,2,4,1,3,3,3,0,3,3,0,0,3,3,3,5,3,3,3,3,3,2,0,2,0,0,2,0,0,2,0,0,1,0,0,3,1,2,2,3,0,3,0,2,0,4,4,3,3,4,1,0,3,0,0,2,4),
+(0,0,0,4,0,0,0,0,0,0,1,0,1,0,2,0,0,0,0,0,1,0,2,0,1,0,0,0,0,0,3,1,3,0,3,2,0,0,0,1,0,3,2,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,4,0,2,0,0,0,0,0,0,2),
+(0,2,1,3,0,2,0,2,0,3,3,3,3,1,3,1,3,3,3,3,3,3,4,2,2,1,2,1,4,0,4,3,1,3,3,3,2,4,3,5,4,3,3,3,3,3,3,3,0,1,3,0,2,0,0,1,0,0,1,0,0,4,2,0,2,3,0,3,3,0,3,3,4,2,3,1,4,0,1,2,0,2,3),
+(0,3,0,3,0,1,0,3,0,2,3,3,3,0,3,1,2,0,3,3,2,3,3,2,3,2,3,1,3,0,4,3,2,0,3,3,1,4,3,3,2,3,4,3,1,3,3,1,1,0,1,1,0,1,0,1,0,1,0,0,0,4,1,1,0,3,0,3,1,0,2,3,3,3,3,3,1,0,0,2,0,3,3),
+(0,0,0,0,0,0,0,0,0,0,3,0,2,0,3,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,3,0,3,0,3,1,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,2,0,2,3,0,0,0,0,0,0,0,0,3),
+(0,2,0,3,1,3,0,3,0,2,3,3,3,1,3,1,3,1,3,1,3,3,3,1,3,0,2,3,1,1,4,3,3,2,3,3,1,2,2,4,1,3,3,0,1,4,2,3,0,1,3,0,3,0,0,1,3,0,2,0,0,3,3,2,1,3,0,3,0,2,0,3,4,4,4,3,1,0,3,0,0,3,3),
+(0,2,0,1,0,2,0,0,0,1,3,2,2,1,3,0,1,1,3,0,3,2,3,1,2,0,2,0,1,1,3,3,3,0,3,3,1,1,2,3,2,3,3,1,2,3,2,0,0,1,0,0,0,0,0,0,3,0,1,0,0,2,1,2,1,3,0,3,0,0,0,3,4,4,4,3,2,0,2,0,0,2,4),
+(0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,2,2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,3,1,0,0,0,0,0,0,0,3),
+(0,3,0,3,0,2,0,3,0,3,3,3,2,3,2,2,2,0,3,1,3,3,3,2,3,3,0,0,3,0,3,2,2,0,2,3,1,4,3,4,3,3,2,3,1,5,4,4,0,3,1,2,1,3,0,3,1,1,2,0,2,3,1,3,1,3,0,3,0,1,0,3,3,4,4,2,1,0,2,1,0,2,4),
+(0,1,0,3,0,1,0,2,0,1,4,2,5,1,4,0,2,0,2,1,3,1,4,0,2,1,0,0,2,1,4,1,1,0,3,3,0,5,1,3,2,3,3,1,0,3,2,3,0,1,0,0,0,0,0,0,1,0,0,0,0,4,0,1,0,3,0,2,0,1,0,3,3,3,4,3,3,0,0,0,0,2,3),
+(0,0,0,1,0,0,0,0,0,0,2,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,0,0,1,0,0,0,0,0,3),
+(0,1,0,3,0,4,0,3,0,2,4,3,1,0,3,2,2,1,3,1,2,2,3,1,1,1,2,1,3,0,1,2,0,1,3,2,1,3,0,5,5,1,0,0,1,3,2,1,0,3,0,0,1,0,0,0,0,0,3,4,0,1,1,1,3,2,0,2,0,1,0,2,3,3,1,2,3,0,1,0,1,0,4),
+(0,0,0,1,0,3,0,3,0,2,2,1,0,0,4,0,3,0,3,1,3,0,3,0,3,0,1,0,3,0,3,1,3,0,3,3,0,0,1,2,1,1,1,0,1,2,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,2,2,1,2,0,0,2,0,0,0,0,2,3,3,3,3,0,0,0,0,1,4),
+(0,0,0,3,0,3,0,0,0,0,3,1,1,0,3,0,1,0,2,0,1,0,0,0,0,0,0,0,1,0,3,0,2,0,2,3,0,0,2,2,3,1,2,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,2,0,0,0,0,2,3),
+(2,4,0,5,0,5,0,4,0,3,4,3,3,3,4,3,3,3,4,3,4,4,5,4,5,5,5,2,3,0,5,5,4,1,5,4,3,1,5,4,3,4,4,3,3,4,3,3,0,3,2,0,2,3,0,3,0,0,3,3,0,5,3,2,3,3,0,3,0,3,0,3,4,5,4,5,3,0,4,3,0,3,4),
+(0,3,0,3,0,3,0,3,0,3,3,4,3,2,3,2,3,0,4,3,3,3,3,3,3,3,3,0,3,2,4,3,3,1,3,4,3,4,4,4,3,4,4,3,2,4,4,1,0,2,0,0,1,1,0,2,0,0,3,1,0,5,3,2,1,3,0,3,0,1,2,4,3,2,4,3,3,0,3,2,0,4,4),
+(0,3,0,3,0,1,0,0,0,1,4,3,3,2,3,1,3,1,4,2,3,2,4,2,3,4,3,0,2,2,3,3,3,0,3,3,3,0,3,4,1,3,3,0,3,4,3,3,0,1,1,0,1,0,0,0,4,0,3,0,0,3,1,2,1,3,0,4,0,1,0,4,3,3,4,3,3,0,2,0,0,3,3),
+(0,3,0,4,0,1,0,3,0,3,4,3,3,0,3,3,3,1,3,1,3,3,4,3,3,3,0,0,3,1,5,3,3,1,3,3,2,5,4,3,3,4,5,3,2,5,3,4,0,1,0,0,0,0,0,2,0,0,1,1,0,4,2,2,1,3,0,3,0,2,0,4,4,3,5,3,2,0,1,1,0,3,4),
+(0,5,0,4,0,5,0,2,0,4,4,3,3,2,3,3,3,1,4,3,4,1,5,3,4,3,4,0,4,2,4,3,4,1,5,4,0,4,4,4,4,5,4,1,3,5,4,2,1,4,1,1,3,2,0,3,1,0,3,2,1,4,3,3,3,4,0,4,0,3,0,4,4,4,3,3,3,0,4,2,0,3,4),
+(1,4,0,4,0,3,0,1,0,3,3,3,1,1,3,3,2,2,3,3,1,0,3,2,2,1,2,0,3,1,2,1,2,0,3,2,0,2,2,3,3,4,3,0,3,3,1,2,0,1,1,3,1,2,0,0,3,0,1,1,0,3,2,2,3,3,0,3,0,0,0,2,3,3,4,3,3,0,1,0,0,1,4),
+(0,4,0,4,0,4,0,0,0,3,4,4,3,1,4,2,3,2,3,3,3,1,4,3,4,0,3,0,4,2,3,3,2,2,5,4,2,1,3,4,3,4,3,1,3,3,4,2,0,2,1,0,3,3,0,0,2,0,3,1,0,4,4,3,4,3,0,4,0,1,0,2,4,4,4,4,4,0,3,2,0,3,3),
+(0,0,0,1,0,4,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,3,2,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,2),
+(0,2,0,3,0,4,0,4,0,1,3,3,3,0,4,0,2,1,2,1,1,1,2,0,3,1,1,0,1,0,3,1,0,0,3,3,2,0,1,1,0,0,0,0,0,1,0,2,0,2,2,0,3,1,0,0,1,0,1,1,0,1,2,0,3,0,0,0,0,1,0,0,3,3,4,3,1,0,1,0,3,0,2),
+(0,0,0,3,0,5,0,0,0,0,1,0,2,0,3,1,0,1,3,0,0,0,2,0,0,0,1,0,0,0,1,1,0,0,4,0,0,0,2,3,0,1,4,1,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,1,0,0,0,0,0,0,0,2,0,0,3,0,0,0,0,0,3),
+(0,2,0,5,0,5,0,1,0,2,4,3,3,2,5,1,3,2,3,3,3,0,4,1,2,0,3,0,4,0,2,2,1,1,5,3,0,0,1,4,2,3,2,0,3,3,3,2,0,2,4,1,1,2,0,1,1,0,3,1,0,1,3,1,2,3,0,2,0,0,0,1,3,5,4,4,4,0,3,0,0,1,3),
+(0,4,0,5,0,4,0,4,0,4,5,4,3,3,4,3,3,3,4,3,4,4,5,3,4,5,4,2,4,2,3,4,3,1,4,4,1,3,5,4,4,5,5,4,4,5,5,5,2,3,3,1,4,3,1,3,3,0,3,3,1,4,3,4,4,4,0,3,0,4,0,3,3,4,4,5,0,0,4,3,0,4,5),
+(0,4,0,4,0,3,0,3,0,3,4,4,4,3,3,2,4,3,4,3,4,3,5,3,4,3,2,1,4,2,4,4,3,1,3,4,2,4,5,5,3,4,5,4,1,5,4,3,0,3,2,2,3,2,1,3,1,0,3,3,3,5,3,3,3,5,4,4,2,3,3,4,3,3,3,2,1,0,3,2,1,4,3),
+(0,4,0,5,0,4,0,3,0,3,5,5,3,2,4,3,4,0,5,4,4,1,4,4,4,3,3,3,4,3,5,5,2,3,3,4,1,2,5,5,3,5,5,2,3,5,5,4,0,3,2,0,3,3,1,1,5,1,4,1,0,4,3,2,3,5,0,4,0,3,0,5,4,3,4,3,0,0,4,1,0,4,4),
+(1,3,0,4,0,2,0,2,0,2,5,5,3,3,3,3,3,0,4,2,3,4,4,4,3,4,0,0,3,4,5,4,3,3,3,3,2,5,5,4,5,5,5,4,3,5,5,5,1,3,1,0,1,0,0,3,2,0,4,2,0,5,2,3,2,4,1,3,0,3,0,4,5,4,5,4,3,0,4,2,0,5,4),
+(0,3,0,4,0,5,0,3,0,3,4,4,3,2,3,2,3,3,3,3,3,2,4,3,3,2,2,0,3,3,3,3,3,1,3,3,3,0,4,4,3,4,4,1,1,4,4,2,0,3,1,0,1,1,0,4,1,0,2,3,1,3,3,1,3,4,0,3,0,1,0,3,1,3,0,0,1,0,2,0,0,4,4),
+(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0),
+(0,3,0,3,0,2,0,3,0,1,5,4,3,3,3,1,4,2,1,2,3,4,4,2,4,4,5,0,3,1,4,3,4,0,4,3,3,3,2,3,2,5,3,4,3,2,2,3,0,0,3,0,2,1,0,1,2,0,0,0,0,2,1,1,3,1,0,2,0,4,0,3,4,4,4,5,2,0,2,0,0,1,3),
+(0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,1,0,0,1,1,0,0,0,4,2,1,1,0,1,0,3,2,0,0,3,1,1,1,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,1,0,0,0,2,0,0,0,1,4,0,4,2,1,0,0,0,0,0,1),
+(0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,3,1,0,0,0,2,0,2,1,0,0,1,2,1,0,1,1,0,0,3,0,0,0,0,0,0,0,0,0,0,0,1,3,1,0,0,0,0,0,1,0,0,2,1,0,0,0,0,0,0,0,0,2),
+(0,4,0,4,0,4,0,3,0,4,4,3,4,2,4,3,2,0,4,4,4,3,5,3,5,3,3,2,4,2,4,3,4,3,1,4,0,2,3,4,4,4,3,3,3,4,4,4,3,4,1,3,4,3,2,1,2,1,3,3,3,4,4,3,3,5,0,4,0,3,0,4,3,3,3,2,1,0,3,0,0,3,3),
+(0,4,0,3,0,3,0,3,0,3,5,5,3,3,3,3,4,3,4,3,3,3,4,4,4,3,3,3,3,4,3,5,3,3,1,3,2,4,5,5,5,5,4,3,4,5,5,3,2,2,3,3,3,3,2,3,3,1,2,3,2,4,3,3,3,4,0,4,0,2,0,4,3,2,2,1,2,0,3,0,0,4,1),
+)
+
+class JapaneseContextAnalysis(object):
+    NUM_OF_CATEGORY = 6
+    DONT_KNOW = -1
+    ENOUGH_REL_THRESHOLD = 100
+    MAX_REL_THRESHOLD = 1000
+    MINIMUM_DATA_THRESHOLD = 4
+
+    def __init__(self):
+        self._total_rel = None
+        self._rel_sample = None
+        self._need_to_skip_char_num = None
+        self._last_char_order = None
+        self._done = None
+        self.reset()
+
+    def reset(self):
+        self._total_rel = 0  # total sequence received
+        # category counters, each integer counts sequence in its category
+        self._rel_sample = [0] * self.NUM_OF_CATEGORY
+        # if last byte in current buffer is not the last byte of a character,
+        # we need to know how many bytes to skip in next buffer
+        self._need_to_skip_char_num = 0
+        self._last_char_order = -1  # The order of previous char
+        # If this flag is set to True, detection is done and conclusion has
+        # been made
+        self._done = False
+
+    def feed(self, byte_str, num_bytes):
+        if self._done:
+            return
+
+        # The buffer we got is byte oriented, and a character may span in more than one
+        # buffers. In case the last one or two byte in last buffer is not
+        # complete, we record how many byte needed to complete that character
+        # and skip these bytes here.  We can choose to record those bytes as
+        # well and analyse the character once it is complete, but since a
+        # character will not make much difference, by simply skipping
+        # this character will simply our logic and improve performance.
+        i = self._need_to_skip_char_num
+        while i < num_bytes:
+            order, char_len = self.get_order(byte_str[i:i + 2])
+            i += char_len
+            if i > num_bytes:
+                self._need_to_skip_char_num = i - num_bytes
+                self._last_char_order = -1
+            else:
+                if (order != -1) and (self._last_char_order != -1):
+                    self._total_rel += 1
+                    if self._total_rel > self.MAX_REL_THRESHOLD:
+                        self._done = True
+                        break
+                    self._rel_sample[jp2CharContext[self._last_char_order][order]] += 1
+                self._last_char_order = order
+
+    def got_enough_data(self):
+        return self._total_rel > self.ENOUGH_REL_THRESHOLD
+
+    def get_confidence(self):
+        # This is just one way to calculate confidence. It works well for me.
+        if self._total_rel > self.MINIMUM_DATA_THRESHOLD:
+            return (self._total_rel - self._rel_sample[0]) / self._total_rel
+        else:
+            return self.DONT_KNOW
+
+    def get_order(self, byte_str):
+        return -1, 1
+
+class SJISContextAnalysis(JapaneseContextAnalysis):
+    def __init__(self):
+        super(SJISContextAnalysis, self).__init__()
+        self._charset_name = "SHIFT_JIS"
+
+    @property
+    def charset_name(self):
+        return self._charset_name
+
+    def get_order(self, byte_str):
+        if not byte_str:
+            return -1, 1
+        # find out current char's byte length
+        first_char = byte_str[0]
+        if (0x81 <= first_char <= 0x9F) or (0xE0 <= first_char <= 0xFC):
+            char_len = 2
+            if (first_char == 0x87) or (0xFA <= first_char <= 0xFC):
+                self._charset_name = "CP932"
+        else:
+            char_len = 1
+
+        # return its order if it is hiragana
+        if len(byte_str) > 1:
+            second_char = byte_str[1]
+            if (first_char == 202) and (0x9F <= second_char <= 0xF1):
+                return second_char - 0x9F, char_len
+
+        return -1, char_len
+
+class EUCJPContextAnalysis(JapaneseContextAnalysis):
+    def get_order(self, byte_str):
+        if not byte_str:
+            return -1, 1
+        # find out current char's byte length
+        first_char = byte_str[0]
+        if (first_char == 0x8E) or (0xA1 <= first_char <= 0xFE):
+            char_len = 2
+        elif first_char == 0x8F:
+            char_len = 3
+        else:
+            char_len = 1
+
+        # return its order if it is hiragana
+        if len(byte_str) > 1:
+            second_char = byte_str[1]
+            if (first_char == 0xA4) and (0xA1 <= second_char <= 0xF3):
+                return second_char - 0xA1, char_len
+
+        return -1, char_len
+
+
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langbulgarianmodel.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langbulgarianmodel.py
new file mode 100644
index 0000000..2aa4fb2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langbulgarianmodel.py
@@ -0,0 +1,228 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# 255: Control characters that usually does not exist in any text
+# 254: Carriage/Return
+# 253: symbol (punctuation) that does not belong to word
+# 252: 0 - 9
+
+# Character Mapping Table:
+# this table is modified base on win1251BulgarianCharToOrderMap, so
+# only number <64 is sure valid
+
+Latin5_BulgarianCharToOrderMap = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253, 77, 90, 99,100, 72,109,107,101, 79,185, 81,102, 76, 94, 82,  # 40
+110,186,108, 91, 74,119, 84, 96,111,187,115,253,253,253,253,253,  # 50
+253, 65, 69, 70, 66, 63, 68,112,103, 92,194,104, 95, 86, 87, 71,  # 60
+116,195, 85, 93, 97,113,196,197,198,199,200,253,253,253,253,253,  # 70
+194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,  # 80
+210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,  # 90
+ 81,226,227,228,229,230,105,231,232,233,234,235,236, 45,237,238,  # a0
+ 31, 32, 35, 43, 37, 44, 55, 47, 40, 59, 33, 46, 38, 36, 41, 30,  # b0
+ 39, 28, 34, 51, 48, 49, 53, 50, 54, 57, 61,239, 67,240, 60, 56,  # c0
+  1, 18,  9, 20, 11,  3, 23, 15,  2, 26, 12, 10, 14,  6,  4, 13,  # d0
+  7,  8,  5, 19, 29, 25, 22, 21, 27, 24, 17, 75, 52,241, 42, 16,  # e0
+ 62,242,243,244, 58,245, 98,246,247,248,249,250,251, 91,252,253,  # f0
+)
+
+win1251BulgarianCharToOrderMap = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253, 77, 90, 99,100, 72,109,107,101, 79,185, 81,102, 76, 94, 82,  # 40
+110,186,108, 91, 74,119, 84, 96,111,187,115,253,253,253,253,253,  # 50
+253, 65, 69, 70, 66, 63, 68,112,103, 92,194,104, 95, 86, 87, 71,  # 60
+116,195, 85, 93, 97,113,196,197,198,199,200,253,253,253,253,253,  # 70
+206,207,208,209,210,211,212,213,120,214,215,216,217,218,219,220,  # 80
+221, 78, 64, 83,121, 98,117,105,222,223,224,225,226,227,228,229,  # 90
+ 88,230,231,232,233,122, 89,106,234,235,236,237,238, 45,239,240,  # a0
+ 73, 80,118,114,241,242,243,244,245, 62, 58,246,247,248,249,250,  # b0
+ 31, 32, 35, 43, 37, 44, 55, 47, 40, 59, 33, 46, 38, 36, 41, 30,  # c0
+ 39, 28, 34, 51, 48, 49, 53, 50, 54, 57, 61,251, 67,252, 60, 56,  # d0
+  1, 18,  9, 20, 11,  3, 23, 15,  2, 26, 12, 10, 14,  6,  4, 13,  # e0
+  7,  8,  5, 19, 29, 25, 22, 21, 27, 24, 17, 75, 52,253, 42, 16,  # f0
+)
+
+# Model Table:
+# total sequences: 100%
+# first 512 sequences: 96.9392%
+# first 1024 sequences:3.0618%
+# rest  sequences:     0.2992%
+# negative sequences:  0.0020%
+BulgarianLangModel = (
+0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,3,3,3,3,3,3,3,2,3,3,3,3,3,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,3,3,3,2,2,3,2,2,1,2,2,
+3,1,3,3,2,3,3,3,3,3,3,3,3,3,3,3,3,0,3,3,3,3,3,3,3,3,3,3,0,3,0,1,
+0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,2,3,3,3,3,3,3,3,3,0,3,1,0,
+0,1,0,0,0,0,0,0,0,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+3,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,1,3,2,3,3,3,3,3,3,3,3,0,3,0,0,
+0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,2,3,3,2,3,3,3,3,3,3,3,3,3,3,3,3,1,3,2,3,3,3,3,3,3,3,3,0,3,0,0,
+0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,3,2,3,2,2,1,3,3,3,3,2,2,2,1,1,2,0,1,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,3,3,2,3,2,2,3,3,1,1,2,3,3,2,3,3,3,3,2,1,2,0,2,0,3,0,0,
+0,0,0,0,0,0,0,1,0,0,2,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,3,3,1,3,3,3,3,3,2,3,2,3,3,3,3,3,2,3,3,1,3,0,3,0,2,0,0,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,3,3,3,1,3,3,2,3,3,3,1,3,3,2,3,2,2,2,0,0,2,0,2,0,2,0,0,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,3,3,3,3,0,3,3,3,2,2,3,3,3,1,2,2,3,2,1,1,2,0,2,0,0,0,0,
+1,0,0,0,0,0,0,0,0,0,2,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,3,3,2,3,3,1,2,3,2,2,2,3,3,3,3,3,2,2,3,1,2,0,2,1,2,0,0,
+0,0,0,0,0,0,0,0,0,0,3,0,0,1,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,1,3,3,3,3,3,2,3,3,3,2,3,3,2,3,2,2,2,3,1,2,0,1,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,3,3,3,3,3,3,1,1,1,2,2,1,3,1,3,2,2,3,0,0,1,0,1,0,1,0,0,
+0,0,0,1,0,0,0,0,1,0,2,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,2,2,3,2,2,3,1,2,1,1,1,2,3,1,3,1,2,2,0,1,1,1,1,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,1,3,2,2,3,3,1,2,3,1,1,3,3,3,3,1,2,2,1,1,1,0,2,0,2,0,1,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,2,2,3,3,3,2,2,1,1,2,0,2,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,
+3,0,1,2,1,3,3,2,3,3,3,3,3,2,3,2,1,0,3,1,2,1,2,1,2,3,2,1,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,1,1,2,3,3,3,3,3,3,3,3,3,3,3,3,0,0,3,1,3,3,2,3,3,2,2,2,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,3,3,3,3,0,3,3,3,3,3,2,1,1,2,1,3,3,0,3,1,1,1,1,3,2,0,1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,
+3,3,2,2,2,3,3,3,3,3,3,3,3,3,3,3,1,1,3,1,3,3,2,3,2,2,2,3,0,2,0,0,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,2,3,3,2,2,3,2,1,1,1,1,1,3,1,3,1,1,0,0,0,1,0,0,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,2,3,2,0,3,2,0,3,0,2,0,0,2,1,3,1,0,0,1,0,0,0,1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,2,1,1,1,1,2,1,1,2,1,1,1,2,2,1,2,1,1,1,0,1,1,0,1,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,2,1,3,1,1,2,1,3,2,1,1,0,1,2,3,2,1,1,1,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,3,3,3,3,2,2,1,0,1,0,0,1,0,0,0,2,1,0,3,0,0,1,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,2,3,2,3,3,1,3,2,1,1,1,2,1,1,2,1,3,0,1,0,0,0,1,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,1,1,2,2,3,3,2,3,2,2,2,3,1,2,2,1,1,2,1,1,2,2,0,1,1,0,1,0,2,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,2,1,3,1,0,2,2,1,3,2,1,0,0,2,0,2,0,1,0,0,0,0,0,0,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,3,1,2,0,2,3,1,2,3,2,0,1,3,1,2,1,1,1,0,0,1,0,0,2,2,2,3,
+2,2,2,2,1,2,1,1,2,2,1,1,2,0,1,1,1,0,0,1,1,0,0,1,1,0,0,0,1,1,0,1,
+3,3,3,3,3,2,1,2,2,1,2,0,2,0,1,0,1,2,1,2,1,1,0,0,0,1,0,1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,1,
+3,3,2,3,3,1,1,3,1,0,3,2,1,0,0,0,1,2,0,2,0,1,0,0,0,1,0,1,2,1,2,2,
+1,1,1,1,1,1,1,2,2,2,1,1,1,1,1,1,1,0,1,2,1,1,1,0,0,0,0,0,1,1,0,0,
+3,1,0,1,0,2,3,2,2,2,3,2,2,2,2,2,1,0,2,1,2,1,1,1,0,1,2,1,2,2,2,1,
+1,1,2,2,2,2,1,2,1,1,0,1,2,1,2,2,2,1,1,1,0,1,1,1,1,2,0,1,0,0,0,0,
+2,3,2,3,3,0,0,2,1,0,2,1,0,0,0,0,2,3,0,2,0,0,0,0,0,1,0,0,2,0,1,2,
+2,1,2,1,2,2,1,1,1,2,1,1,1,0,1,2,2,1,1,1,1,1,0,1,1,1,0,0,1,2,0,0,
+3,3,2,2,3,0,2,3,1,1,2,0,0,0,1,0,0,2,0,2,0,0,0,1,0,1,0,1,2,0,2,2,
+1,1,1,1,2,1,0,1,2,2,2,1,1,1,1,1,1,1,0,1,1,1,0,0,0,0,0,0,1,1,0,0,
+2,3,2,3,3,0,0,3,0,1,1,0,1,0,0,0,2,2,1,2,0,0,0,0,0,0,0,0,2,0,1,2,
+2,2,1,1,1,1,1,2,2,2,1,0,2,0,1,0,1,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,
+3,3,3,3,2,2,2,2,2,0,2,1,1,1,1,2,1,2,1,1,0,2,0,1,0,1,0,0,2,0,1,2,
+1,1,1,1,1,1,1,2,2,1,1,0,2,0,1,0,2,0,0,1,1,1,0,0,2,0,0,0,1,1,0,0,
+2,3,3,3,3,1,0,0,0,0,0,0,0,0,0,0,2,0,0,1,1,0,0,0,0,0,0,1,2,0,1,2,
+2,2,2,1,1,2,1,1,2,2,2,1,2,0,1,1,1,1,1,1,0,1,1,1,1,0,0,1,1,1,0,0,
+2,3,3,3,3,0,2,2,0,2,1,0,0,0,1,1,1,2,0,2,0,0,0,3,0,0,0,0,2,0,2,2,
+1,1,1,2,1,2,1,1,2,2,2,1,2,0,1,1,1,0,1,1,1,1,0,2,1,0,0,0,1,1,0,0,
+2,3,3,3,3,0,2,1,0,0,2,0,0,0,0,0,1,2,0,2,0,0,0,0,0,0,0,0,2,0,1,2,
+1,1,1,2,1,1,1,1,2,2,2,0,1,0,1,1,1,0,0,1,1,1,0,0,1,0,0,0,0,1,0,0,
+3,3,2,2,3,0,1,0,1,0,0,0,0,0,0,0,1,1,0,3,0,0,0,0,0,0,0,0,1,0,2,2,
+1,1,1,1,1,2,1,1,2,2,1,2,2,1,0,1,1,1,1,1,0,1,0,0,1,0,0,0,1,1,0,0,
+3,1,0,1,0,2,2,2,2,3,2,1,1,1,2,3,0,0,1,0,2,1,1,0,1,1,1,1,2,1,1,1,
+1,2,2,1,2,1,2,2,1,1,0,1,2,1,2,2,1,1,1,0,0,1,1,1,2,1,0,1,0,0,0,0,
+2,1,0,1,0,3,1,2,2,2,2,1,2,2,1,1,1,0,2,1,2,2,1,1,2,1,1,0,2,1,1,1,
+1,2,2,2,2,2,2,2,1,2,0,1,1,0,2,1,1,1,1,1,0,0,1,1,1,1,0,1,0,0,0,0,
+2,1,1,1,1,2,2,2,2,1,2,2,2,1,2,2,1,1,2,1,2,3,2,2,1,1,1,1,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,2,2,3,2,0,1,2,0,1,2,1,1,0,1,0,1,2,1,2,0,0,0,1,1,0,0,0,1,0,0,2,
+1,1,0,0,1,1,0,1,1,1,1,0,2,0,1,1,1,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,
+2,0,0,0,0,1,2,2,2,2,2,2,2,1,2,1,1,1,1,1,1,1,0,1,1,1,1,1,2,1,1,1,
+1,2,2,2,2,1,1,2,1,2,1,1,1,0,2,1,2,1,1,1,0,2,1,1,1,1,0,1,0,0,0,0,
+3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,
+1,1,0,1,0,1,1,1,1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,2,2,3,2,0,0,0,0,1,0,0,0,0,0,0,1,1,0,2,0,0,0,0,0,0,0,0,1,0,1,2,
+1,1,1,1,1,1,0,0,2,2,2,2,2,0,1,1,0,1,1,1,1,1,0,0,1,0,0,0,1,1,0,1,
+2,3,1,2,1,0,1,1,0,2,2,2,0,0,1,0,0,1,1,1,1,0,0,0,0,0,0,0,1,0,1,2,
+1,1,1,1,2,1,1,1,1,1,1,1,1,0,1,1,0,1,0,1,0,1,0,0,1,0,0,0,0,1,0,0,
+2,2,2,2,2,0,0,2,0,0,2,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,2,0,2,2,
+1,1,1,1,1,0,0,1,2,1,1,0,1,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,
+1,2,2,2,2,0,0,2,0,1,1,0,0,0,1,0,0,2,0,2,0,0,0,0,0,0,0,0,0,0,1,1,
+0,0,0,1,1,1,1,1,1,1,1,1,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,
+1,2,2,3,2,0,0,1,0,0,1,0,0,0,0,0,0,1,0,2,0,0,0,1,0,0,0,0,0,0,0,2,
+1,1,0,0,1,0,0,0,1,1,0,0,1,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,
+2,1,2,2,2,1,2,1,2,2,1,1,2,1,1,1,0,1,1,1,1,2,0,1,0,1,1,1,1,0,1,1,
+1,1,2,1,1,1,1,1,1,0,0,1,2,1,1,1,1,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,
+1,0,0,1,3,1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,2,2,2,1,0,0,1,0,2,0,0,0,0,0,1,1,1,0,1,0,0,0,0,0,0,0,0,2,0,0,1,
+0,2,0,1,0,0,1,1,2,0,1,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
+1,2,2,2,2,0,1,1,0,2,1,0,1,1,1,0,0,1,0,2,0,1,0,0,0,0,0,0,0,0,0,1,
+0,1,0,0,1,0,0,0,1,1,0,0,1,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,
+2,2,2,2,2,0,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,
+0,1,0,1,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,
+2,0,1,0,0,1,2,1,1,1,1,1,1,2,2,1,0,0,1,0,1,0,0,0,0,1,1,1,1,0,0,0,
+1,1,2,1,1,1,1,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,2,1,2,1,0,0,1,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,
+0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,0,0,1,2,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,
+0,1,1,0,1,1,1,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,
+1,0,1,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,1,0,2,0,0,2,0,1,0,0,1,0,0,1,
+1,1,0,0,1,1,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,
+1,1,1,1,1,1,1,2,0,0,0,0,0,0,2,1,0,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,0,1,1,1,1,1,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+)
+
+Latin5BulgarianModel = {
+  'char_to_order_map': Latin5_BulgarianCharToOrderMap,
+  'precedence_matrix': BulgarianLangModel,
+  'typical_positive_ratio': 0.969392,
+  'keep_english_letter': False,
+  'charset_name': "ISO-8859-5",
+  'language': 'Bulgairan',
+}
+
+Win1251BulgarianModel = {
+  'char_to_order_map': win1251BulgarianCharToOrderMap,
+  'precedence_matrix': BulgarianLangModel,
+  'typical_positive_ratio': 0.969392,
+  'keep_english_letter': False,
+  'charset_name': "windows-1251",
+  'language': 'Bulgarian',
+}
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langcyrillicmodel.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langcyrillicmodel.py
new file mode 100644
index 0000000..e5f9a1f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langcyrillicmodel.py
@@ -0,0 +1,333 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# KOI8-R language model
+# Character Mapping Table:
+KOI8R_char_to_order_map = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253,142,143,144,145,146,147,148,149,150,151,152, 74,153, 75,154,  # 40
+155,156,157,158,159,160,161,162,163,164,165,253,253,253,253,253,  # 50
+253, 71,172, 66,173, 65,174, 76,175, 64,176,177, 77, 72,178, 69,  # 60
+ 67,179, 78, 73,180,181, 79,182,183,184,185,253,253,253,253,253,  # 70
+191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,  # 80
+207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,  # 90
+223,224,225, 68,226,227,228,229,230,231,232,233,234,235,236,237,  # a0
+238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,  # b0
+ 27,  3, 21, 28, 13,  2, 39, 19, 26,  4, 23, 11,  8, 12,  5,  1,  # c0
+ 15, 16,  9,  7,  6, 14, 24, 10, 17, 18, 20, 25, 30, 29, 22, 54,  # d0
+ 59, 37, 44, 58, 41, 48, 53, 46, 55, 42, 60, 36, 49, 38, 31, 34,  # e0
+ 35, 43, 45, 32, 40, 52, 56, 33, 61, 62, 51, 57, 47, 63, 50, 70,  # f0
+)
+
+win1251_char_to_order_map = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253,142,143,144,145,146,147,148,149,150,151,152, 74,153, 75,154,  # 40
+155,156,157,158,159,160,161,162,163,164,165,253,253,253,253,253,  # 50
+253, 71,172, 66,173, 65,174, 76,175, 64,176,177, 77, 72,178, 69,  # 60
+ 67,179, 78, 73,180,181, 79,182,183,184,185,253,253,253,253,253,  # 70
+191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,
+207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,
+223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,
+239,240,241,242,243,244,245,246, 68,247,248,249,250,251,252,253,
+ 37, 44, 33, 46, 41, 48, 56, 51, 42, 60, 36, 49, 38, 31, 34, 35,
+ 45, 32, 40, 52, 53, 55, 58, 50, 57, 63, 70, 62, 61, 47, 59, 43,
+  3, 21, 10, 19, 13,  2, 24, 20,  4, 23, 11,  8, 12,  5,  1, 15,
+  9,  7,  6, 14, 39, 26, 28, 22, 25, 29, 54, 18, 17, 30, 27, 16,
+)
+
+latin5_char_to_order_map = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253,142,143,144,145,146,147,148,149,150,151,152, 74,153, 75,154,  # 40
+155,156,157,158,159,160,161,162,163,164,165,253,253,253,253,253,  # 50
+253, 71,172, 66,173, 65,174, 76,175, 64,176,177, 77, 72,178, 69,  # 60
+ 67,179, 78, 73,180,181, 79,182,183,184,185,253,253,253,253,253,  # 70
+191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,
+207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,
+223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,
+ 37, 44, 33, 46, 41, 48, 56, 51, 42, 60, 36, 49, 38, 31, 34, 35,
+ 45, 32, 40, 52, 53, 55, 58, 50, 57, 63, 70, 62, 61, 47, 59, 43,
+  3, 21, 10, 19, 13,  2, 24, 20,  4, 23, 11,  8, 12,  5,  1, 15,
+  9,  7,  6, 14, 39, 26, 28, 22, 25, 29, 54, 18, 17, 30, 27, 16,
+239, 68,240,241,242,243,244,245,246,247,248,249,250,251,252,255,
+)
+
+macCyrillic_char_to_order_map = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253,142,143,144,145,146,147,148,149,150,151,152, 74,153, 75,154,  # 40
+155,156,157,158,159,160,161,162,163,164,165,253,253,253,253,253,  # 50
+253, 71,172, 66,173, 65,174, 76,175, 64,176,177, 77, 72,178, 69,  # 60
+ 67,179, 78, 73,180,181, 79,182,183,184,185,253,253,253,253,253,  # 70
+ 37, 44, 33, 46, 41, 48, 56, 51, 42, 60, 36, 49, 38, 31, 34, 35,
+ 45, 32, 40, 52, 53, 55, 58, 50, 57, 63, 70, 62, 61, 47, 59, 43,
+191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,
+207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,
+223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,
+239,240,241,242,243,244,245,246,247,248,249,250,251,252, 68, 16,
+  3, 21, 10, 19, 13,  2, 24, 20,  4, 23, 11,  8, 12,  5,  1, 15,
+  9,  7,  6, 14, 39, 26, 28, 22, 25, 29, 54, 18, 17, 30, 27,255,
+)
+
+IBM855_char_to_order_map = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253,142,143,144,145,146,147,148,149,150,151,152, 74,153, 75,154,  # 40
+155,156,157,158,159,160,161,162,163,164,165,253,253,253,253,253,  # 50
+253, 71,172, 66,173, 65,174, 76,175, 64,176,177, 77, 72,178, 69,  # 60
+ 67,179, 78, 73,180,181, 79,182,183,184,185,253,253,253,253,253,  # 70
+191,192,193,194, 68,195,196,197,198,199,200,201,202,203,204,205,
+206,207,208,209,210,211,212,213,214,215,216,217, 27, 59, 54, 70,
+  3, 37, 21, 44, 28, 58, 13, 41,  2, 48, 39, 53, 19, 46,218,219,
+220,221,222,223,224, 26, 55,  4, 42,225,226,227,228, 23, 60,229,
+230,231,232,233,234,235, 11, 36,236,237,238,239,240,241,242,243,
+  8, 49, 12, 38,  5, 31,  1, 34, 15,244,245,246,247, 35, 16,248,
+ 43,  9, 45,  7, 32,  6, 40, 14, 52, 24, 56, 10, 33, 17, 61,249,
+250, 18, 62, 20, 51, 25, 57, 30, 47, 29, 63, 22, 50,251,252,255,
+)
+
+IBM866_char_to_order_map = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253,142,143,144,145,146,147,148,149,150,151,152, 74,153, 75,154,  # 40
+155,156,157,158,159,160,161,162,163,164,165,253,253,253,253,253,  # 50
+253, 71,172, 66,173, 65,174, 76,175, 64,176,177, 77, 72,178, 69,  # 60
+ 67,179, 78, 73,180,181, 79,182,183,184,185,253,253,253,253,253,  # 70
+ 37, 44, 33, 46, 41, 48, 56, 51, 42, 60, 36, 49, 38, 31, 34, 35,
+ 45, 32, 40, 52, 53, 55, 58, 50, 57, 63, 70, 62, 61, 47, 59, 43,
+  3, 21, 10, 19, 13,  2, 24, 20,  4, 23, 11,  8, 12,  5,  1, 15,
+191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,
+207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,
+223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,
+  9,  7,  6, 14, 39, 26, 28, 22, 25, 29, 54, 18, 17, 30, 27, 16,
+239, 68,240,241,242,243,244,245,246,247,248,249,250,251,252,255,
+)
+
+# Model Table:
+# total sequences: 100%
+# first 512 sequences: 97.6601%
+# first 1024 sequences: 2.3389%
+# rest  sequences:      0.1237%
+# negative sequences:   0.0009%
+RussianLangModel = (
+0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,1,3,3,3,2,3,2,3,3,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,3,2,2,2,2,2,0,0,2,
+3,3,3,2,3,3,3,3,3,3,3,3,3,3,2,3,3,0,0,3,3,3,3,3,3,3,3,3,2,3,2,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,2,2,3,3,3,3,3,3,3,3,3,2,3,3,0,0,3,3,3,3,3,3,3,3,2,3,3,1,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,2,3,2,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,3,3,3,3,3,3,3,3,3,3,3,2,1,
+0,0,0,0,0,0,0,2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,3,0,0,3,3,3,3,3,3,3,3,3,3,3,2,1,
+0,0,0,0,0,1,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,2,2,2,3,1,3,3,1,3,3,3,3,2,2,3,0,2,2,2,3,3,2,1,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,2,3,3,3,3,3,2,2,3,2,3,3,3,2,1,2,2,0,1,2,2,2,2,2,2,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,3,0,2,2,3,3,2,1,2,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,1,0,0,2,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,2,3,3,1,2,3,2,2,3,2,3,3,3,3,2,2,3,0,3,2,2,3,1,1,1,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,2,2,3,3,3,3,3,2,3,3,3,3,2,2,2,0,3,3,3,2,2,2,2,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,2,3,2,3,3,3,3,3,3,2,3,2,2,0,1,3,2,1,2,2,1,0,
+0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,3,2,1,1,3,0,1,1,1,1,2,1,1,0,2,2,2,1,2,0,1,0,
+0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,2,3,3,2,2,2,2,1,3,2,3,2,3,2,1,2,2,0,1,1,2,1,2,1,2,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,3,3,2,2,3,2,3,3,3,2,2,2,2,0,2,2,2,2,3,1,1,0,
+0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,
+3,2,3,2,2,3,3,3,3,3,3,3,3,3,1,3,2,0,0,3,3,3,3,2,3,3,3,3,2,3,2,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,3,3,3,3,3,2,2,3,3,0,2,1,0,3,2,3,2,3,0,0,1,2,0,0,1,0,1,2,1,1,0,
+0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,0,3,0,2,3,3,3,3,2,3,3,3,3,1,2,2,0,0,2,3,2,2,2,3,2,3,2,2,3,0,0,
+0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,2,3,0,2,3,2,3,0,1,2,3,3,2,0,2,3,0,0,2,3,2,2,0,1,3,1,3,2,2,1,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,1,3,0,2,3,3,3,3,3,3,3,3,2,1,3,2,0,0,2,2,3,3,3,2,3,3,0,2,2,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,2,2,3,3,2,2,2,3,3,0,0,1,1,1,1,1,2,0,0,1,1,1,1,0,1,0,
+0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,2,2,3,3,3,3,3,3,3,0,3,2,3,3,2,3,2,0,2,1,0,1,1,0,1,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,2,3,3,3,2,2,2,2,3,1,3,2,3,1,1,2,1,0,2,2,2,2,1,3,1,0,
+0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,
+2,2,3,3,3,3,3,1,2,2,1,3,1,0,3,0,0,3,0,0,0,1,1,0,1,2,1,0,0,0,0,0,
+0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,2,2,1,1,3,3,3,2,2,1,2,2,3,1,1,2,0,0,2,2,1,3,0,0,2,1,1,2,1,1,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,2,3,3,3,3,1,2,2,2,1,2,1,3,3,1,1,2,1,2,1,2,2,0,2,0,0,1,1,0,1,0,
+0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,3,3,3,3,3,2,1,3,2,2,3,2,0,3,2,0,3,0,1,0,1,1,0,0,1,1,1,1,0,1,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,2,3,3,3,2,2,2,3,3,1,2,1,2,1,0,1,0,1,1,0,1,0,0,2,1,1,1,0,1,0,
+0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
+3,1,1,2,1,2,3,3,2,2,1,2,2,3,0,2,1,0,0,2,2,3,2,1,2,2,2,2,2,3,1,0,
+0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,1,1,0,1,1,2,2,1,1,3,0,0,1,3,1,1,1,0,0,0,1,0,1,1,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,1,3,3,3,2,0,0,0,2,1,0,1,0,2,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,0,1,0,0,2,3,2,2,2,1,2,2,2,1,2,1,0,0,1,1,1,0,2,0,1,1,1,0,0,1,1,
+1,0,0,0,0,0,1,2,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
+2,3,3,3,3,0,0,0,0,1,0,0,0,0,3,0,1,2,1,0,0,0,0,0,0,0,1,1,0,0,1,1,
+1,0,1,0,1,2,0,0,1,1,2,1,0,1,1,1,1,0,1,1,1,1,0,1,0,0,1,0,0,1,1,0,
+2,2,3,2,2,2,3,1,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,0,1,0,1,1,1,0,2,1,
+1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,0,1,1,1,0,1,1,0,
+3,3,3,2,2,2,2,3,2,2,1,1,2,2,2,2,1,1,3,1,2,1,2,0,0,1,1,0,1,0,2,1,
+1,1,1,1,1,2,1,0,1,1,1,1,0,1,0,0,1,1,0,0,1,0,1,0,0,1,0,0,0,1,1,0,
+2,0,0,1,0,3,2,2,2,2,1,2,1,2,1,2,0,0,0,2,1,2,2,1,1,2,2,0,1,1,0,2,
+1,1,1,1,1,0,1,1,1,2,1,1,1,2,1,0,1,2,1,1,1,1,0,1,1,1,0,0,1,0,0,1,
+1,3,2,2,2,1,1,1,2,3,0,0,0,0,2,0,2,2,1,0,0,0,0,0,0,1,0,0,0,0,1,1,
+1,0,1,1,0,1,0,1,1,0,1,1,0,2,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,1,1,0,
+2,3,2,3,2,1,2,2,2,2,1,0,0,0,2,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,2,1,
+1,1,2,1,0,2,0,0,1,0,1,0,0,1,0,0,1,1,0,1,1,0,0,0,0,0,1,0,0,0,0,0,
+3,0,0,1,0,2,2,2,3,2,2,2,2,2,2,2,0,0,0,2,1,2,1,1,1,2,2,0,0,0,1,2,
+1,1,1,1,1,0,1,2,1,1,1,1,1,1,1,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0,0,1,
+2,3,2,3,3,2,0,1,1,1,0,0,1,0,2,0,1,1,3,1,0,0,0,0,0,0,0,1,0,0,2,1,
+1,1,1,1,1,1,1,0,1,0,1,1,1,1,0,1,1,1,0,0,1,1,0,1,0,0,0,0,0,0,1,0,
+2,3,3,3,3,1,2,2,2,2,0,1,1,0,2,1,1,1,2,1,0,1,1,0,0,1,0,1,0,0,2,0,
+0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,3,3,3,2,0,0,1,1,2,2,1,0,0,2,0,1,1,3,0,0,1,0,0,0,0,0,1,0,1,2,1,
+1,1,2,0,1,1,1,0,1,0,1,1,0,1,0,1,1,1,1,0,1,0,0,0,0,0,0,1,0,1,1,0,
+1,3,2,3,2,1,0,0,2,2,2,0,1,0,2,0,1,1,1,0,1,0,0,0,3,0,1,1,0,0,2,1,
+1,1,1,0,1,1,0,0,0,0,1,1,0,1,0,0,2,1,1,0,1,0,0,0,1,0,1,0,0,1,1,0,
+3,1,2,1,1,2,2,2,2,2,2,1,2,2,1,1,0,0,0,2,2,2,0,0,0,1,2,1,0,1,0,1,
+2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,2,1,1,1,0,1,0,1,1,0,1,1,1,0,0,1,
+3,0,0,0,0,2,0,1,1,1,1,1,1,1,0,1,0,0,0,1,1,1,0,1,0,1,1,0,0,1,0,1,
+1,1,0,0,1,0,0,0,1,0,1,1,0,0,1,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,
+1,3,3,2,2,0,0,0,2,2,0,0,0,1,2,0,1,1,2,0,0,0,0,0,0,0,0,1,0,0,2,1,
+0,1,1,0,0,1,1,0,0,0,1,1,0,1,1,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,
+2,3,2,3,2,0,0,0,0,1,1,0,0,0,2,0,2,0,2,0,0,0,0,0,1,0,0,1,0,0,1,1,
+1,1,2,0,1,2,1,0,1,1,2,1,1,1,1,1,2,1,1,0,1,0,0,1,1,1,1,1,0,1,1,0,
+1,3,2,2,2,1,0,0,2,2,1,0,1,2,2,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,1,
+0,0,1,1,0,1,1,0,0,1,1,0,1,1,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,
+1,0,0,1,0,2,3,1,2,2,2,2,2,2,1,1,0,0,0,1,0,1,0,2,1,1,1,0,0,0,0,1,
+1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,
+2,0,2,0,0,1,0,3,2,1,2,1,2,2,0,1,0,0,0,2,1,0,0,2,1,1,1,1,0,2,0,2,
+2,1,1,1,1,1,1,1,1,1,1,1,1,2,1,0,1,1,1,1,0,0,0,1,1,1,1,0,1,0,0,1,
+1,2,2,2,2,1,0,0,1,0,0,0,0,0,2,0,1,1,1,1,0,0,0,0,1,0,1,2,0,0,2,0,
+1,0,1,1,1,2,1,0,1,0,1,1,0,0,1,0,1,1,1,0,1,0,0,0,1,0,0,1,0,1,1,0,
+2,1,2,2,2,0,3,0,1,1,0,0,0,0,2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+0,0,0,1,1,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,
+1,2,2,3,2,2,0,0,1,1,2,0,1,2,1,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,
+0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,1,1,0,0,1,0,0,0,0,0,0,0,0,1,1,0,
+2,2,1,1,2,1,2,2,2,2,2,1,2,2,0,1,0,0,0,1,2,2,2,1,2,1,1,1,1,1,2,1,
+1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,1,1,1,0,0,0,0,1,1,1,0,1,1,0,0,1,
+1,2,2,2,2,0,1,0,2,2,0,0,0,0,2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,2,0,
+0,0,1,0,0,1,0,0,0,0,1,0,1,1,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,
+0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,2,2,2,2,0,0,0,2,2,2,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
+0,1,1,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,2,2,2,2,0,0,0,0,1,0,0,1,1,2,0,0,0,0,1,0,1,0,0,1,0,0,2,0,0,0,1,
+0,0,1,0,0,1,0,0,0,1,1,0,0,0,0,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,
+1,2,2,2,1,1,2,0,2,1,1,1,1,0,2,2,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,
+0,0,1,0,1,1,0,0,0,0,1,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,
+1,0,2,1,2,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,
+0,0,1,0,1,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,
+1,0,0,0,0,2,0,1,2,1,0,1,1,1,0,1,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,1,
+0,0,0,0,0,1,0,0,1,1,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,
+2,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+1,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+1,1,1,0,1,0,1,0,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+1,1,0,1,1,0,1,0,1,0,0,0,0,1,1,0,1,1,0,0,0,0,0,1,0,1,1,0,1,0,0,0,
+0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,
+)
+
+Koi8rModel = {
+  'char_to_order_map': KOI8R_char_to_order_map,
+  'precedence_matrix': RussianLangModel,
+  'typical_positive_ratio': 0.976601,
+  'keep_english_letter': False,
+  'charset_name': "KOI8-R",
+  'language': 'Russian',
+}
+
+Win1251CyrillicModel = {
+  'char_to_order_map': win1251_char_to_order_map,
+  'precedence_matrix': RussianLangModel,
+  'typical_positive_ratio': 0.976601,
+  'keep_english_letter': False,
+  'charset_name': "windows-1251",
+  'language': 'Russian',
+}
+
+Latin5CyrillicModel = {
+  'char_to_order_map': latin5_char_to_order_map,
+  'precedence_matrix': RussianLangModel,
+  'typical_positive_ratio': 0.976601,
+  'keep_english_letter': False,
+  'charset_name': "ISO-8859-5",
+  'language': 'Russian',
+}
+
+MacCyrillicModel = {
+  'char_to_order_map': macCyrillic_char_to_order_map,
+  'precedence_matrix': RussianLangModel,
+  'typical_positive_ratio': 0.976601,
+  'keep_english_letter': False,
+  'charset_name': "MacCyrillic",
+  'language': 'Russian',
+}
+
+Ibm866Model = {
+  'char_to_order_map': IBM866_char_to_order_map,
+  'precedence_matrix': RussianLangModel,
+  'typical_positive_ratio': 0.976601,
+  'keep_english_letter': False,
+  'charset_name': "IBM866",
+  'language': 'Russian',
+}
+
+Ibm855Model = {
+  'char_to_order_map': IBM855_char_to_order_map,
+  'precedence_matrix': RussianLangModel,
+  'typical_positive_ratio': 0.976601,
+  'keep_english_letter': False,
+  'charset_name': "IBM855",
+  'language': 'Russian',
+}
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langgreekmodel.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langgreekmodel.py
new file mode 100644
index 0000000..5332221
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langgreekmodel.py
@@ -0,0 +1,225 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# 255: Control characters that usually does not exist in any text
+# 254: Carriage/Return
+# 253: symbol (punctuation) that does not belong to word
+# 252: 0 - 9
+
+# Character Mapping Table:
+Latin7_char_to_order_map = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253, 82,100,104, 94, 98,101,116,102,111,187,117, 92, 88,113, 85,  # 40
+ 79,118,105, 83, 67,114,119, 95, 99,109,188,253,253,253,253,253,  # 50
+253, 72, 70, 80, 81, 60, 96, 93, 89, 68,120, 97, 77, 86, 69, 55,  # 60
+ 78,115, 65, 66, 58, 76,106,103, 87,107,112,253,253,253,253,253,  # 70
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 80
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 90
+253,233, 90,253,253,253,253,253,253,253,253,253,253, 74,253,253,  # a0
+253,253,253,253,247,248, 61, 36, 46, 71, 73,253, 54,253,108,123,  # b0
+110, 31, 51, 43, 41, 34, 91, 40, 52, 47, 44, 53, 38, 49, 59, 39,  # c0
+ 35, 48,250, 37, 33, 45, 56, 50, 84, 57,120,121, 17, 18, 22, 15,  # d0
+124,  1, 29, 20, 21,  3, 32, 13, 25,  5, 11, 16, 10,  6, 30,  4,  # e0
+  9,  8, 14,  7,  2, 12, 28, 23, 42, 24, 64, 75, 19, 26, 27,253,  # f0
+)
+
+win1253_char_to_order_map = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253, 82,100,104, 94, 98,101,116,102,111,187,117, 92, 88,113, 85,  # 40
+ 79,118,105, 83, 67,114,119, 95, 99,109,188,253,253,253,253,253,  # 50
+253, 72, 70, 80, 81, 60, 96, 93, 89, 68,120, 97, 77, 86, 69, 55,  # 60
+ 78,115, 65, 66, 58, 76,106,103, 87,107,112,253,253,253,253,253,  # 70
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 80
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 90
+253,233, 61,253,253,253,253,253,253,253,253,253,253, 74,253,253,  # a0
+253,253,253,253,247,253,253, 36, 46, 71, 73,253, 54,253,108,123,  # b0
+110, 31, 51, 43, 41, 34, 91, 40, 52, 47, 44, 53, 38, 49, 59, 39,  # c0
+ 35, 48,250, 37, 33, 45, 56, 50, 84, 57,120,121, 17, 18, 22, 15,  # d0
+124,  1, 29, 20, 21,  3, 32, 13, 25,  5, 11, 16, 10,  6, 30,  4,  # e0
+  9,  8, 14,  7,  2, 12, 28, 23, 42, 24, 64, 75, 19, 26, 27,253,  # f0
+)
+
+# Model Table:
+# total sequences: 100%
+# first 512 sequences: 98.2851%
+# first 1024 sequences:1.7001%
+# rest  sequences:     0.0359%
+# negative sequences:  0.0148%
+GreekLangModel = (
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,3,2,2,3,3,3,3,3,3,3,3,1,3,3,3,0,2,2,3,3,0,3,0,3,2,0,3,3,3,0,
+3,0,0,0,2,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,3,0,3,3,0,3,2,3,3,0,3,2,3,3,3,0,0,3,0,3,0,3,3,2,0,0,0,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,
+0,2,3,2,2,3,3,3,3,3,3,3,3,0,3,3,3,3,0,2,3,3,0,3,3,3,3,2,3,3,3,0,
+2,0,0,0,2,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,2,3,3,2,3,3,3,3,3,3,3,3,3,3,3,3,0,2,1,3,3,3,3,2,3,3,2,3,3,2,0,
+0,0,0,0,2,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,0,3,3,3,3,3,3,0,3,3,0,3,3,3,3,3,3,3,3,3,3,0,3,2,3,3,0,
+2,0,1,0,2,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
+0,3,3,3,3,3,2,3,0,0,0,0,3,3,0,3,1,3,3,3,0,3,3,0,3,3,3,3,0,0,0,0,
+2,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,3,0,3,0,3,3,3,3,3,0,3,2,2,2,3,0,2,3,3,3,3,3,2,3,3,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,3,3,2,2,2,3,3,3,3,0,3,1,3,3,3,3,2,3,3,3,3,3,3,3,2,2,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,3,2,0,3,0,0,0,3,3,2,3,3,3,3,3,0,0,3,2,3,0,2,3,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,0,3,3,3,3,0,0,3,3,0,2,3,0,3,0,3,3,3,0,0,3,0,3,0,2,2,3,3,0,0,
+0,0,1,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,3,2,0,3,2,3,3,3,3,0,3,3,3,3,3,0,3,3,2,3,2,3,3,2,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,2,3,2,3,3,3,3,3,3,0,2,3,2,3,2,2,2,3,2,3,3,2,3,0,2,2,2,3,0,
+2,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,3,0,0,0,3,3,3,2,3,3,0,0,3,0,3,0,0,0,3,2,0,3,0,3,0,0,2,0,2,0,
+0,0,0,0,2,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,0,3,3,3,3,3,3,0,3,3,0,3,0,0,0,3,3,0,3,3,3,0,0,1,2,3,0,
+3,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,3,2,0,0,3,2,2,3,3,0,3,3,3,3,3,2,1,3,0,3,2,3,3,2,1,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,3,3,0,2,3,3,3,3,3,3,0,0,3,0,3,0,0,0,3,3,0,3,2,3,0,0,3,3,3,0,
+3,0,0,0,2,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,0,3,3,3,3,3,3,0,0,3,0,3,0,0,0,3,2,0,3,2,3,0,0,3,2,3,0,
+2,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,3,1,2,2,3,3,3,3,3,3,0,2,3,0,3,0,0,0,3,3,0,3,0,2,0,0,2,3,1,0,
+2,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,0,3,3,3,3,0,3,0,3,3,2,3,0,3,3,3,3,3,3,0,3,3,3,0,2,3,0,0,3,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,0,3,3,3,0,0,3,0,0,0,3,3,0,3,0,2,3,3,0,0,3,0,3,0,3,3,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,3,0,0,0,3,3,3,3,3,3,0,0,3,0,2,0,0,0,3,3,0,3,0,3,0,0,2,0,2,0,
+0,0,0,0,1,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,3,3,0,3,0,2,0,3,2,0,3,2,3,2,3,0,0,3,2,3,2,3,3,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,3,0,0,2,3,3,3,3,3,0,0,0,3,0,2,1,0,0,3,2,2,2,0,3,0,0,2,2,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,0,3,3,3,2,0,3,0,3,0,3,3,0,2,1,2,3,3,0,0,3,0,3,0,3,3,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,2,3,3,3,0,3,3,3,3,3,3,0,2,3,0,3,0,0,0,2,1,0,2,2,3,0,0,2,2,2,0,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,3,0,0,2,3,3,3,2,3,0,0,1,3,0,2,0,0,0,0,3,0,1,0,2,0,0,1,1,1,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,3,1,0,3,0,0,0,3,2,0,3,2,3,3,3,0,0,3,0,3,2,2,2,1,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,0,3,3,3,0,0,3,0,0,0,0,2,0,2,3,3,2,2,2,2,3,0,2,0,2,2,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,3,3,3,2,0,0,0,0,0,0,2,3,0,2,0,2,3,2,0,0,3,0,3,0,3,1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,3,2,3,3,2,2,3,0,2,0,3,0,0,0,2,0,0,0,0,1,2,0,2,0,2,0,
+0,2,0,2,0,2,2,0,0,1,0,2,2,2,0,2,2,2,0,2,2,2,0,0,2,0,0,1,0,0,0,0,
+0,2,0,3,3,2,0,0,0,0,0,0,1,3,0,2,0,2,2,2,0,0,2,0,3,0,0,2,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,0,2,3,2,0,2,2,0,2,0,2,2,0,2,0,2,2,2,0,0,0,0,0,0,2,3,0,0,0,2,
+0,1,2,0,0,0,0,2,2,0,0,0,2,1,0,2,2,0,0,0,0,0,0,1,0,2,0,0,0,0,0,0,
+0,0,2,1,0,2,3,2,2,3,2,3,2,0,0,3,3,3,0,0,3,2,0,0,0,1,1,0,2,0,2,2,
+0,2,0,2,0,2,2,0,0,2,0,2,2,2,0,2,2,2,2,0,0,2,0,0,0,2,0,1,0,0,0,0,
+0,3,0,3,3,2,2,0,3,0,0,0,2,2,0,2,2,2,1,2,0,0,1,2,2,0,0,3,0,0,0,2,
+0,1,2,0,0,0,1,2,0,0,0,0,0,0,0,2,2,0,1,0,0,2,0,0,0,2,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,2,3,3,2,2,0,0,0,2,0,2,3,3,0,2,0,0,0,0,0,0,2,2,2,0,2,2,0,2,0,2,
+0,2,2,0,0,2,2,2,2,1,0,0,2,2,0,2,0,0,2,0,0,0,0,0,0,2,0,0,0,0,0,0,
+0,2,0,3,2,3,0,0,0,3,0,0,2,2,0,2,0,2,2,2,0,0,2,0,0,0,0,0,0,0,0,2,
+0,0,2,2,0,0,2,2,2,0,0,0,0,0,0,2,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,2,0,0,3,2,0,2,2,2,2,2,0,0,0,2,0,0,0,0,2,0,1,0,0,2,0,1,0,0,0,
+0,2,2,2,0,2,2,0,1,2,0,2,2,2,0,2,2,2,2,1,2,2,0,0,2,0,0,0,0,0,0,0,
+0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
+0,2,0,2,0,2,2,0,0,0,0,1,2,1,0,0,2,2,0,0,2,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,3,2,3,0,0,2,0,0,0,2,2,0,2,0,0,0,1,0,0,2,0,2,0,2,2,0,0,0,0,
+0,0,2,0,0,0,0,2,2,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,
+0,2,2,3,2,2,0,0,0,0,0,0,1,3,0,2,0,2,2,0,0,0,1,0,2,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,2,0,2,0,3,2,0,2,0,0,0,0,0,0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+0,0,2,0,0,0,0,1,1,0,0,2,1,2,0,2,2,0,1,0,0,1,0,0,0,2,0,0,0,0,0,0,
+0,3,0,2,2,2,0,0,2,0,0,0,2,0,0,0,2,3,0,2,0,0,0,0,0,0,2,2,0,0,0,2,
+0,1,2,0,0,0,1,2,2,1,0,0,0,2,0,0,2,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,2,1,2,0,2,2,0,2,0,0,2,0,0,0,0,1,2,1,0,2,1,0,0,0,0,0,0,0,0,0,0,
+0,0,2,0,0,0,3,1,2,2,0,2,0,0,0,0,2,0,0,0,2,0,0,3,0,0,0,0,2,2,2,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,2,1,0,2,0,1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,1,0,0,0,0,0,0,2,
+0,2,2,0,0,2,2,2,2,2,0,1,2,0,0,0,2,2,0,1,0,2,0,0,2,2,0,0,0,0,0,0,
+0,0,0,0,1,0,0,0,0,0,0,0,3,0,0,2,0,0,0,0,0,0,0,0,2,0,2,0,0,0,0,2,
+0,1,2,0,0,0,0,2,2,1,0,1,0,1,0,2,2,2,1,0,0,0,0,0,0,1,0,0,0,0,0,0,
+0,2,0,1,2,0,0,0,0,0,0,0,0,0,0,2,0,0,2,2,0,0,0,0,1,0,0,0,0,0,0,2,
+0,2,2,0,0,0,0,2,2,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,2,0,0,2,0,0,0,
+0,2,2,2,2,0,0,0,3,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,2,0,0,0,0,0,0,1,
+0,0,2,0,0,0,0,1,2,0,0,0,0,0,0,2,2,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,
+0,2,0,2,2,2,0,0,2,0,0,0,0,0,0,0,2,2,2,0,0,0,2,0,0,0,0,0,0,0,0,2,
+0,0,1,0,0,0,0,2,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
+0,3,0,2,0,0,0,0,0,0,0,0,2,0,0,0,0,0,2,0,0,0,0,0,0,0,2,0,0,0,0,2,
+0,0,2,0,0,0,0,2,2,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,2,0,2,2,1,0,0,0,0,0,0,2,0,0,2,0,2,2,2,0,0,0,0,0,0,2,0,0,0,0,2,
+0,0,2,0,0,2,0,2,2,0,0,0,0,2,0,2,0,0,0,0,0,2,0,0,0,2,0,0,0,0,0,0,
+0,0,3,0,0,0,2,2,0,2,2,0,0,0,0,0,2,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,2,0,0,0,0,0,
+0,2,2,2,2,2,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,
+0,0,0,0,0,0,0,2,1,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,2,2,0,0,0,0,0,2,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
+0,2,0,0,0,2,0,0,0,0,0,1,0,0,0,0,2,2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,2,0,0,0,
+0,2,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,2,0,2,0,0,0,
+0,0,0,0,0,0,0,0,2,1,0,0,0,0,0,0,2,0,0,0,1,2,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+)
+
+Latin7GreekModel = {
+  'char_to_order_map': Latin7_char_to_order_map,
+  'precedence_matrix': GreekLangModel,
+  'typical_positive_ratio': 0.982851,
+  'keep_english_letter': False,
+  'charset_name': "ISO-8859-7",
+  'language': 'Greek',
+}
+
+Win1253GreekModel = {
+  'char_to_order_map': win1253_char_to_order_map,
+  'precedence_matrix': GreekLangModel,
+  'typical_positive_ratio': 0.982851,
+  'keep_english_letter': False,
+  'charset_name': "windows-1253",
+  'language': 'Greek',
+}
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langhebrewmodel.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langhebrewmodel.py
new file mode 100644
index 0000000..58f4c87
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langhebrewmodel.py
@@ -0,0 +1,200 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Universal charset detector code.
+#
+# The Initial Developer of the Original Code is
+#          Simon Montagu
+# Portions created by the Initial Developer are Copyright (C) 2005
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#   Shy Shalom - original C code
+#   Shoshannah Forbes - original C code (?)
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# 255: Control characters that usually does not exist in any text
+# 254: Carriage/Return
+# 253: symbol (punctuation) that does not belong to word
+# 252: 0 - 9
+
+# Windows-1255 language model
+# Character Mapping Table:
+WIN1255_CHAR_TO_ORDER_MAP = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253, 69, 91, 79, 80, 92, 89, 97, 90, 68,111,112, 82, 73, 95, 85,  # 40
+ 78,121, 86, 71, 67,102,107, 84,114,103,115,253,253,253,253,253,  # 50
+253, 50, 74, 60, 61, 42, 76, 70, 64, 53,105, 93, 56, 65, 54, 49,  # 60
+ 66,110, 51, 43, 44, 63, 81, 77, 98, 75,108,253,253,253,253,253,  # 70
+124,202,203,204,205, 40, 58,206,207,208,209,210,211,212,213,214,
+215, 83, 52, 47, 46, 72, 32, 94,216,113,217,109,218,219,220,221,
+ 34,116,222,118,100,223,224,117,119,104,125,225,226, 87, 99,227,
+106,122,123,228, 55,229,230,101,231,232,120,233, 48, 39, 57,234,
+ 30, 59, 41, 88, 33, 37, 36, 31, 29, 35,235, 62, 28,236,126,237,
+238, 38, 45,239,240,241,242,243,127,244,245,246,247,248,249,250,
+  9,  8, 20, 16,  3,  2, 24, 14, 22,  1, 25, 15,  4, 11,  6, 23,
+ 12, 19, 13, 26, 18, 27, 21, 17,  7, 10,  5,251,252,128, 96,253,
+)
+
+# Model Table:
+# total sequences: 100%
+# first 512 sequences: 98.4004%
+# first 1024 sequences: 1.5981%
+# rest  sequences:      0.087%
+# negative sequences:   0.0015%
+HEBREW_LANG_MODEL = (
+0,3,3,3,3,3,3,3,3,3,3,2,3,3,3,3,3,3,3,3,3,3,3,2,3,2,1,2,0,1,0,0,
+3,0,3,1,0,0,1,3,2,0,1,1,2,0,2,2,2,1,1,1,1,2,1,1,1,2,0,0,2,2,0,1,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,
+1,2,1,2,1,2,0,0,2,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,
+1,2,1,3,1,1,0,0,2,0,0,0,1,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,0,1,2,2,1,3,
+1,2,1,1,2,2,0,0,2,2,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,1,1,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,3,2,2,2,2,3,2,
+1,2,1,2,2,2,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,3,2,3,2,2,3,2,2,2,1,2,2,2,2,
+1,2,1,1,2,2,0,1,2,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,0,2,2,2,2,2,
+0,2,0,2,2,2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,0,2,2,2,
+0,2,1,2,2,2,0,0,2,1,0,0,0,0,1,0,1,0,0,0,0,0,0,2,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,3,3,3,2,3,3,3,3,3,3,3,3,3,3,3,3,3,2,1,2,3,2,2,2,
+1,2,1,2,2,2,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,
+3,3,3,3,3,3,3,3,3,2,3,3,3,2,3,3,3,3,3,3,3,3,3,3,3,3,3,1,0,2,0,2,
+0,2,1,2,2,2,0,0,1,2,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,2,0,0,1,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,2,3,2,2,3,2,1,2,1,1,1,
+0,1,1,1,1,1,3,0,1,0,0,0,0,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
+3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,0,1,1,0,0,1,0,0,1,0,0,0,0,
+0,0,1,0,0,0,0,0,2,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,
+0,2,0,1,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,3,2,3,3,3,2,1,2,3,3,2,3,3,3,3,2,3,2,1,2,0,2,1,2,
+0,2,0,2,2,2,0,0,1,2,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,
+3,3,3,3,3,3,3,3,3,2,3,3,3,1,2,2,3,3,2,3,2,3,2,2,3,1,2,2,0,2,2,2,
+0,2,1,2,2,2,0,0,1,2,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,3,3,2,3,3,2,2,2,3,3,3,3,1,3,2,2,2,
+0,2,0,1,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,3,3,3,2,3,2,2,2,1,2,2,0,2,2,2,2,
+0,2,0,2,2,2,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,3,3,3,2,3,3,3,1,3,2,3,3,2,3,3,2,2,1,2,2,2,2,2,2,
+0,2,1,2,1,2,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,2,3,2,3,3,2,3,3,3,3,2,3,2,3,3,3,3,3,2,2,2,2,2,2,2,1,
+0,2,0,1,2,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,3,2,1,2,3,3,3,3,3,3,3,2,3,2,3,2,1,2,3,0,2,1,2,2,
+0,2,1,1,2,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,2,0,
+3,3,3,3,3,3,3,3,3,2,3,3,3,3,2,1,3,1,2,2,2,1,2,3,3,1,2,1,2,2,2,2,
+0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,2,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,0,2,3,3,3,1,3,3,3,1,2,2,2,2,1,1,2,2,2,2,2,2,
+0,2,0,1,1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,2,3,3,3,2,2,3,3,3,2,1,2,3,2,3,2,2,2,2,1,2,1,1,1,2,2,
+0,2,1,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
+3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,0,0,1,0,0,0,0,0,
+1,0,1,0,0,0,0,0,2,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,2,3,3,2,3,1,2,2,2,2,3,2,3,1,1,2,2,1,2,2,1,1,0,2,2,2,2,
+0,1,0,1,2,2,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
+3,0,0,1,1,0,1,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,0,
+0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,0,1,0,1,0,1,1,0,1,1,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0,1,0,0,0,0,0,
+0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,0,0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
+3,2,2,1,2,2,2,2,2,2,2,1,2,2,1,2,2,1,1,1,1,1,1,1,1,2,1,1,0,3,3,3,
+0,3,0,2,2,2,2,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
+2,2,2,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,1,2,2,2,1,1,1,2,0,1,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,0,0,0,0,0,0,
+0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,3,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,1,0,2,1,0,
+0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
+0,3,1,1,2,2,2,2,2,1,2,2,2,1,1,2,2,2,2,2,2,2,1,2,2,1,0,1,1,1,1,0,
+0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,2,1,1,1,1,2,1,1,2,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,0,0,0,0,0,0,0,
+0,0,2,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,1,0,0,
+2,1,1,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,1,2,1,2,1,1,1,1,0,0,0,0,
+0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,2,1,2,2,2,2,2,2,2,2,2,2,1,2,1,2,1,1,2,1,1,1,2,1,2,1,2,0,1,0,1,
+0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,3,1,2,2,2,1,2,2,2,2,2,2,2,2,1,2,1,1,1,1,1,1,2,1,2,1,1,0,1,0,1,
+0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,1,2,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,
+0,2,0,1,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
+3,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,1,1,1,1,1,1,1,0,1,1,0,1,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,2,0,1,1,1,0,1,0,0,0,1,1,0,1,1,0,0,0,0,0,1,1,0,0,
+0,1,1,1,2,1,2,2,2,0,2,0,2,0,1,1,2,1,1,1,1,2,1,0,1,1,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,0,1,0,0,0,0,0,1,0,1,2,2,0,1,0,0,1,1,2,2,1,2,0,2,0,0,0,1,2,0,1,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,2,0,2,1,2,0,2,0,0,1,1,1,1,1,1,0,1,0,0,0,1,0,0,1,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,1,0,0,0,0,0,1,0,2,1,1,0,1,0,0,1,1,1,2,2,0,0,1,0,0,0,1,0,0,1,
+1,1,2,1,0,1,1,1,0,1,0,1,1,1,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,2,2,1,
+0,2,0,1,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,1,0,0,1,0,1,1,1,1,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,1,1,1,1,1,1,1,1,2,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,1,1,0,1,0,0,0,1,1,0,1,
+2,0,1,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,1,0,1,1,1,0,1,0,0,1,1,2,1,1,2,0,1,0,0,0,1,1,0,1,
+1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,1,0,1,1,2,0,1,0,0,0,0,2,1,1,2,0,2,0,0,0,1,1,0,1,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,1,0,2,1,1,0,1,0,0,2,2,1,2,1,1,0,1,0,0,0,1,1,0,1,
+2,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,1,2,2,0,0,0,0,0,1,1,0,1,0,0,1,0,0,0,0,1,0,1,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,1,2,2,0,0,0,0,2,1,1,1,0,2,1,1,0,0,0,2,1,0,1,
+1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,1,0,1,1,2,0,1,0,0,1,1,0,2,1,1,0,1,0,0,0,1,1,0,1,
+2,2,1,1,1,0,1,1,0,1,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,1,0,2,1,1,0,1,0,0,1,1,0,1,2,1,0,2,0,0,0,1,1,0,1,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,
+0,1,0,0,2,0,2,1,1,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,1,0,1,1,2,0,1,0,0,1,1,1,0,1,0,0,1,0,0,0,1,0,0,1,
+1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,0,0,0,0,0,0,0,1,0,1,1,0,0,1,0,0,2,1,1,1,1,1,0,1,0,0,0,0,1,0,1,
+0,1,1,1,2,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,1,2,1,0,0,0,0,0,1,1,1,1,1,0,1,0,0,0,1,1,0,0,
+)
+
+Win1255HebrewModel = {
+  'char_to_order_map': WIN1255_CHAR_TO_ORDER_MAP,
+  'precedence_matrix': HEBREW_LANG_MODEL,
+  'typical_positive_ratio': 0.984004,
+  'keep_english_letter': False,
+  'charset_name': "windows-1255",
+  'language': 'Hebrew',
+}
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langhungarianmodel.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langhungarianmodel.py
new file mode 100644
index 0000000..bb7c095
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langhungarianmodel.py
@@ -0,0 +1,225 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# 255: Control characters that usually does not exist in any text
+# 254: Carriage/Return
+# 253: symbol (punctuation) that does not belong to word
+# 252: 0 - 9
+
+# Character Mapping Table:
+Latin2_HungarianCharToOrderMap = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253, 28, 40, 54, 45, 32, 50, 49, 38, 39, 53, 36, 41, 34, 35, 47,
+ 46, 71, 43, 33, 37, 57, 48, 64, 68, 55, 52,253,253,253,253,253,
+253,  2, 18, 26, 17,  1, 27, 12, 20,  9, 22,  7,  6, 13,  4,  8,
+ 23, 67, 10,  5,  3, 21, 19, 65, 62, 16, 11,253,253,253,253,253,
+159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,
+175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,
+191,192,193,194,195,196,197, 75,198,199,200,201,202,203,204,205,
+ 79,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,
+221, 51, 81,222, 78,223,224,225,226, 44,227,228,229, 61,230,231,
+232,233,234, 58,235, 66, 59,236,237,238, 60, 69, 63,239,240,241,
+ 82, 14, 74,242, 70, 80,243, 72,244, 15, 83, 77, 84, 30, 76, 85,
+245,246,247, 25, 73, 42, 24,248,249,250, 31, 56, 29,251,252,253,
+)
+
+win1250HungarianCharToOrderMap = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253, 28, 40, 54, 45, 32, 50, 49, 38, 39, 53, 36, 41, 34, 35, 47,
+ 46, 72, 43, 33, 37, 57, 48, 64, 68, 55, 52,253,253,253,253,253,
+253,  2, 18, 26, 17,  1, 27, 12, 20,  9, 22,  7,  6, 13,  4,  8,
+ 23, 67, 10,  5,  3, 21, 19, 65, 62, 16, 11,253,253,253,253,253,
+161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,
+177,178,179,180, 78,181, 69,182,183,184,185,186,187,188,189,190,
+191,192,193,194,195,196,197, 76,198,199,200,201,202,203,204,205,
+ 81,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,
+221, 51, 83,222, 80,223,224,225,226, 44,227,228,229, 61,230,231,
+232,233,234, 58,235, 66, 59,236,237,238, 60, 70, 63,239,240,241,
+ 84, 14, 75,242, 71, 82,243, 73,244, 15, 85, 79, 86, 30, 77, 87,
+245,246,247, 25, 74, 42, 24,248,249,250, 31, 56, 29,251,252,253,
+)
+
+# Model Table:
+# total sequences: 100%
+# first 512 sequences: 94.7368%
+# first 1024 sequences:5.2623%
+# rest  sequences:     0.8894%
+# negative sequences:  0.0009%
+HungarianLangModel = (
+0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
+3,3,3,3,3,3,3,3,3,3,2,3,3,3,3,3,3,3,3,2,2,3,3,1,1,2,2,2,2,2,1,2,
+3,2,2,3,3,3,3,3,2,3,3,3,3,3,3,1,2,3,3,3,3,2,3,3,1,1,3,3,0,1,1,1,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,
+3,2,1,3,3,3,3,3,2,3,3,3,3,3,1,1,2,3,3,3,3,3,3,3,1,1,3,2,0,1,1,1,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,3,3,3,1,1,2,3,3,3,1,3,3,3,3,3,1,3,3,2,2,0,3,2,3,
+0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,
+3,3,3,3,3,3,2,3,3,3,2,3,3,2,3,3,3,3,3,2,3,3,2,2,3,2,3,2,0,3,2,2,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,
+3,3,3,3,3,3,2,3,3,3,3,3,2,3,3,3,1,2,3,2,2,3,1,2,3,3,2,2,0,3,3,3,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,2,2,3,3,3,3,3,3,2,3,3,3,3,2,3,3,3,3,0,2,3,2,
+0,0,0,1,1,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,3,1,1,1,3,3,2,1,3,2,2,3,2,1,3,2,2,1,0,3,3,1,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+3,2,2,3,3,3,3,3,1,2,3,3,3,3,1,2,1,3,3,3,3,2,2,3,1,1,3,2,0,1,1,1,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,2,2,3,3,3,3,3,2,1,3,3,3,3,3,2,2,1,3,3,3,0,1,1,2,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,3,3,2,3,3,2,3,3,3,2,0,3,2,3,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,1,0,
+3,3,3,3,3,3,2,3,3,3,2,3,2,3,3,3,1,3,2,2,2,3,1,1,3,3,1,1,0,3,3,2,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,2,3,3,3,2,3,2,3,3,3,2,3,3,3,3,3,1,2,3,2,2,0,2,2,2,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+3,3,3,2,2,2,3,1,3,3,2,2,1,3,3,3,1,1,3,1,2,3,2,3,2,2,2,1,0,2,2,2,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,
+3,1,1,3,3,3,3,3,1,2,3,3,3,3,1,2,1,3,3,3,2,2,3,2,1,0,3,2,0,1,1,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,1,1,3,3,3,3,3,1,2,3,3,3,3,1,1,0,3,3,3,3,0,2,3,0,0,2,1,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,2,2,3,3,2,2,2,2,3,3,0,1,2,3,2,3,2,2,3,2,1,2,0,2,2,2,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,
+3,3,3,3,3,3,1,2,3,3,3,2,1,2,3,3,2,2,2,3,2,3,3,1,3,3,1,1,0,2,3,2,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+3,3,3,1,2,2,2,2,3,3,3,1,1,1,3,3,1,1,3,1,1,3,2,1,2,3,1,1,0,2,2,2,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+3,3,3,2,1,2,1,1,3,3,1,1,1,1,3,3,1,1,2,2,1,2,1,1,2,2,1,1,0,2,2,1,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+3,3,3,1,1,2,1,1,3,3,1,0,1,1,3,3,2,0,1,1,2,3,1,0,2,2,1,0,0,1,3,2,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+3,2,1,3,3,3,3,3,1,2,3,2,3,3,2,1,1,3,2,3,2,1,2,2,0,1,2,1,0,0,1,1,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
+3,3,3,3,2,2,2,2,3,1,2,2,1,1,3,3,0,3,2,1,2,3,2,1,3,3,1,1,0,2,1,3,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+3,3,3,2,2,2,3,2,3,3,3,2,1,1,3,3,1,1,1,2,2,3,2,3,2,2,2,1,0,2,2,1,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+1,0,0,3,3,3,3,3,0,0,3,3,2,3,0,0,0,2,3,3,1,0,1,2,0,0,1,1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,1,2,3,3,3,3,3,1,2,3,3,2,2,1,1,0,3,3,2,2,1,2,2,1,0,2,2,0,1,1,1,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,2,2,1,3,1,2,3,3,2,2,1,1,2,2,1,1,1,1,3,2,1,1,1,1,2,1,0,1,2,1,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
+2,3,3,1,1,1,1,1,3,3,3,0,1,1,3,3,1,1,1,1,1,2,2,0,3,1,1,2,0,2,1,1,
+0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+3,1,0,1,2,1,2,2,0,1,2,3,1,2,0,0,0,2,1,1,1,1,1,2,0,0,1,1,0,0,0,0,
+1,2,1,2,2,2,1,2,1,2,0,2,0,2,2,1,1,2,1,1,2,1,1,1,0,1,0,0,0,1,1,0,
+1,1,1,2,3,2,3,3,0,1,2,2,3,1,0,1,0,2,1,2,2,0,1,1,0,0,1,1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,0,0,3,3,2,2,1,0,0,3,2,3,2,0,0,0,1,1,3,0,0,1,1,0,0,2,1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,1,1,2,2,3,3,1,0,1,3,2,3,1,1,1,0,1,1,1,1,1,3,1,0,0,2,2,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,1,1,1,2,2,2,1,0,1,2,3,3,2,0,0,0,2,1,1,1,2,1,1,1,0,1,1,1,0,0,0,
+1,2,2,2,2,2,1,1,1,2,0,2,1,1,1,1,1,2,1,1,1,1,1,1,0,1,1,1,0,0,1,1,
+3,2,2,1,0,0,1,1,2,2,0,3,0,1,2,1,1,0,0,1,1,1,0,1,1,1,1,0,2,1,1,1,
+2,2,1,1,1,2,1,2,1,1,1,1,1,1,1,2,1,1,1,2,3,1,1,1,1,1,1,1,1,1,0,1,
+2,3,3,0,1,0,0,0,3,3,1,0,0,1,2,2,1,0,0,0,0,2,0,0,1,1,1,0,2,1,1,1,
+2,1,1,1,1,1,1,2,1,1,0,1,1,0,1,1,1,0,1,2,1,1,0,1,1,1,1,1,1,1,0,1,
+2,3,3,0,1,0,0,0,2,2,0,0,0,0,1,2,2,0,0,0,0,1,0,0,1,1,0,0,2,0,1,0,
+2,1,1,1,1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,0,1,1,1,1,1,0,1,
+3,2,2,0,1,0,1,0,2,3,2,0,0,1,2,2,1,0,0,1,1,1,0,0,2,1,0,1,2,2,1,1,
+2,1,1,1,1,1,1,2,1,1,1,1,1,1,0,2,1,0,1,1,0,1,1,1,0,1,1,2,1,1,0,1,
+2,2,2,0,0,1,0,0,2,2,1,1,0,0,2,1,1,0,0,0,1,2,0,0,2,1,0,0,2,1,1,1,
+2,1,1,1,1,2,1,2,1,1,1,2,2,1,1,2,1,1,1,2,1,1,1,1,1,1,1,1,1,1,0,1,
+1,2,3,0,0,0,1,0,3,2,1,0,0,1,2,1,1,0,0,0,0,2,1,0,1,1,0,0,2,1,2,1,
+1,1,0,0,0,1,0,1,1,1,1,1,2,0,0,1,0,0,0,2,0,0,1,1,1,1,1,1,1,1,0,1,
+3,0,0,2,1,2,2,1,0,0,2,1,2,2,0,0,0,2,1,1,1,0,1,1,0,0,1,1,2,0,0,0,
+1,2,1,2,2,1,1,2,1,2,0,1,1,1,1,1,1,1,1,1,2,1,1,0,0,1,1,1,1,0,0,1,
+1,3,2,0,0,0,1,0,2,2,2,0,0,0,2,2,1,0,0,0,0,3,1,1,1,1,0,0,2,1,1,1,
+2,1,0,1,1,1,0,1,1,1,1,1,1,1,0,2,1,0,0,1,0,1,1,0,1,1,1,1,1,1,0,1,
+2,3,2,0,0,0,1,0,2,2,0,0,0,0,2,1,1,0,0,0,0,2,1,0,1,1,0,0,2,1,1,0,
+2,1,1,1,1,2,1,2,1,2,0,1,1,1,0,2,1,1,1,2,1,1,1,1,0,1,1,1,1,1,0,1,
+3,1,1,2,2,2,3,2,1,1,2,2,1,1,0,1,0,2,2,1,1,1,1,1,0,0,1,1,0,1,1,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,2,2,0,0,0,0,0,2,2,0,0,0,0,2,2,1,0,0,0,1,1,0,0,1,2,0,0,2,1,1,1,
+2,2,1,1,1,2,1,2,1,1,0,1,1,1,1,2,1,1,1,2,1,1,1,1,0,1,2,1,1,1,0,1,
+1,0,0,1,2,3,2,1,0,0,2,0,1,1,0,0,0,1,1,1,1,0,1,1,0,0,1,0,0,0,0,0,
+1,2,1,2,1,2,1,1,1,2,0,2,1,1,1,0,1,2,0,0,1,1,1,0,0,0,0,0,0,0,0,0,
+2,3,2,0,0,0,0,0,1,1,2,1,0,0,1,1,1,0,0,0,0,2,0,0,1,1,0,0,2,1,1,1,
+2,1,1,1,1,1,1,2,1,0,1,1,1,1,0,2,1,1,1,1,1,1,0,1,0,1,1,1,1,1,0,1,
+1,2,2,0,1,1,1,0,2,2,2,0,0,0,3,2,1,0,0,0,1,1,0,0,1,1,0,1,1,1,0,0,
+1,1,0,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,2,1,1,1,0,0,1,1,1,0,1,0,1,
+2,1,0,2,1,1,2,2,1,1,2,1,1,1,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,0,0,0,
+1,2,2,2,2,2,1,1,1,2,0,2,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,0,0,0,1,0,
+1,2,3,0,0,0,1,0,2,2,0,0,0,0,2,2,0,0,0,0,0,1,0,0,1,0,0,0,2,0,1,0,
+2,1,1,1,1,1,0,2,0,0,0,1,2,1,1,1,1,0,1,2,0,1,0,1,0,1,1,1,0,1,0,1,
+2,2,2,0,0,0,1,0,2,1,2,0,0,0,1,1,2,0,0,0,0,1,0,0,1,1,0,0,2,1,0,1,
+2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,0,1,1,1,1,1,0,1,
+1,2,2,0,0,0,1,0,2,2,2,0,0,0,1,1,0,0,0,0,0,1,1,0,2,0,0,1,1,1,0,1,
+1,0,1,1,1,1,1,1,0,1,1,1,1,0,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,0,0,1,
+1,0,0,1,0,1,2,1,0,0,1,1,1,2,0,0,0,1,1,0,1,0,1,1,0,0,1,0,0,0,0,0,
+0,2,1,2,1,1,1,1,1,2,0,2,0,1,1,0,1,2,1,0,1,1,1,0,0,0,0,0,0,1,0,0,
+2,1,1,0,1,2,0,0,1,1,1,0,0,0,1,1,0,0,0,0,0,1,0,0,1,0,0,0,2,1,0,1,
+2,2,1,1,1,1,1,2,1,1,0,1,1,1,1,2,1,1,1,2,1,1,0,1,0,1,1,1,1,1,0,1,
+1,2,2,0,0,0,0,0,1,1,0,0,0,0,2,1,0,0,0,0,0,2,0,0,2,2,0,0,2,0,0,1,
+2,1,1,1,1,1,1,1,0,1,1,0,1,1,0,1,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0,1,
+1,1,2,0,0,3,1,0,2,1,1,1,0,0,1,1,1,0,0,0,1,1,0,0,0,1,0,0,1,0,1,0,
+1,2,1,0,1,1,1,2,1,1,0,1,1,1,1,1,0,0,0,1,1,1,1,1,0,1,0,0,0,1,0,0,
+2,1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,2,0,0,0,
+2,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,2,1,1,0,0,1,1,1,1,1,0,1,
+2,1,1,1,2,1,1,1,0,1,1,2,1,0,0,0,0,1,1,1,1,0,1,0,0,0,0,1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,1,0,1,1,1,1,1,0,0,1,1,2,1,0,0,0,1,1,0,0,0,1,1,0,0,1,0,1,0,0,0,
+1,2,1,1,1,1,1,1,1,1,0,1,0,1,1,1,1,1,1,0,1,1,1,0,0,0,0,0,0,1,0,0,
+2,0,0,0,1,1,1,1,0,0,1,1,0,0,0,0,0,1,1,1,2,0,0,1,0,0,1,0,1,0,0,0,
+0,1,1,1,1,1,1,1,1,2,0,1,1,1,1,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0,
+1,0,0,1,1,1,1,1,0,0,2,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,
+0,1,1,1,1,1,1,0,1,1,0,1,0,1,1,0,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,
+1,0,0,1,1,1,0,0,0,0,1,0,2,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,
+0,1,1,1,1,1,0,0,1,1,0,1,0,1,0,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0,
+0,0,0,1,0,0,0,0,0,0,1,1,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,1,1,1,0,1,0,0,1,1,0,1,0,1,1,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0,
+2,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,1,0,0,1,0,1,0,1,1,1,0,0,1,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,
+0,1,1,1,1,1,1,0,1,1,0,1,0,1,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,
+)
+
+Latin2HungarianModel = {
+  'char_to_order_map': Latin2_HungarianCharToOrderMap,
+  'precedence_matrix': HungarianLangModel,
+  'typical_positive_ratio': 0.947368,
+  'keep_english_letter': True,
+  'charset_name': "ISO-8859-2",
+  'language': 'Hungarian',
+}
+
+Win1250HungarianModel = {
+  'char_to_order_map': win1250HungarianCharToOrderMap,
+  'precedence_matrix': HungarianLangModel,
+  'typical_positive_ratio': 0.947368,
+  'keep_english_letter': True,
+  'charset_name': "windows-1250",
+  'language': 'Hungarian',
+}
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langthaimodel.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langthaimodel.py
new file mode 100644
index 0000000..15f94c2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langthaimodel.py
@@ -0,0 +1,199 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# 255: Control characters that usually does not exist in any text
+# 254: Carriage/Return
+# 253: symbol (punctuation) that does not belong to word
+# 252: 0 - 9
+
+# The following result for thai was collected from a limited sample (1M).
+
+# Character Mapping Table:
+TIS620CharToOrderMap = (
+255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255,  # 00
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  # 10
+253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,  # 20
+252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253,  # 30
+253,182,106,107,100,183,184,185,101, 94,186,187,108,109,110,111,  # 40
+188,189,190, 89, 95,112,113,191,192,193,194,253,253,253,253,253,  # 50
+253, 64, 72, 73,114, 74,115,116,102, 81,201,117, 90,103, 78, 82,  # 60
+ 96,202, 91, 79, 84,104,105, 97, 98, 92,203,253,253,253,253,253,  # 70
+209,210,211,212,213, 88,214,215,216,217,218,219,220,118,221,222,
+223,224, 99, 85, 83,225,226,227,228,229,230,231,232,233,234,235,
+236,  5, 30,237, 24,238, 75,  8, 26, 52, 34, 51,119, 47, 58, 57,
+ 49, 53, 55, 43, 20, 19, 44, 14, 48,  3, 17, 25, 39, 62, 31, 54,
+ 45,  9, 16,  2, 61, 15,239, 12, 42, 46, 18, 21, 76,  4, 66, 63,
+ 22, 10,  1, 36, 23, 13, 40, 27, 32, 35, 86,240,241,242,243,244,
+ 11, 28, 41, 29, 33,245, 50, 37,  6,  7, 67, 77, 38, 93,246,247,
+ 68, 56, 59, 65, 69, 60, 70, 80, 71, 87,248,249,250,251,252,253,
+)
+
+# Model Table:
+# total sequences: 100%
+# first 512 sequences: 92.6386%
+# first 1024 sequences:7.3177%
+# rest  sequences:     1.0230%
+# negative sequences:  0.0436%
+ThaiLangModel = (
+0,1,3,3,3,3,0,0,3,3,0,3,3,0,3,3,3,3,3,3,3,3,0,0,3,3,3,0,3,3,3,3,
+0,3,3,0,0,0,1,3,0,3,3,2,3,3,0,1,2,3,3,3,3,0,2,0,2,0,0,3,2,1,2,2,
+3,0,3,3,2,3,0,0,3,3,0,3,3,0,3,3,3,3,3,3,3,3,3,0,3,2,3,0,2,2,2,3,
+0,2,3,0,0,0,0,1,0,1,2,3,1,1,3,2,2,0,1,1,0,0,1,0,0,0,0,0,0,0,1,1,
+3,3,3,2,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,3,3,2,3,2,3,3,2,2,2,
+3,1,2,3,0,3,3,2,2,1,2,3,3,1,2,0,1,3,0,1,0,0,1,0,0,0,0,0,0,0,1,1,
+3,3,2,2,3,3,3,3,1,2,3,3,3,3,3,2,2,2,2,3,3,2,2,3,3,2,2,3,2,3,2,2,
+3,3,1,2,3,1,2,2,3,3,1,0,2,1,0,0,3,1,2,1,0,0,1,0,0,0,0,0,0,1,0,1,
+3,3,3,3,3,3,2,2,3,3,3,3,2,3,2,2,3,3,2,2,3,2,2,2,2,1,1,3,1,2,1,1,
+3,2,1,0,2,1,0,1,0,1,1,0,1,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,
+3,3,3,2,3,2,3,3,2,2,3,2,3,3,2,3,1,1,2,3,2,2,2,3,2,2,2,2,2,1,2,1,
+2,2,1,1,3,3,2,1,0,1,2,2,0,1,3,0,0,0,1,1,0,0,0,0,0,2,3,0,0,2,1,1,
+3,3,2,3,3,2,0,0,3,3,0,3,3,0,2,2,3,1,2,2,1,1,1,0,2,2,2,0,2,2,1,1,
+0,2,1,0,2,0,0,2,0,1,0,0,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,
+3,3,2,3,3,2,0,0,3,3,0,2,3,0,2,1,2,2,2,2,1,2,0,0,2,2,2,0,2,2,1,1,
+0,2,1,0,2,0,0,2,0,1,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,
+3,3,2,3,2,3,2,0,2,2,1,3,2,1,3,2,1,2,3,2,2,3,0,2,3,2,2,1,2,2,2,2,
+1,2,2,0,0,0,0,2,0,1,2,0,1,1,1,0,1,0,3,1,1,0,0,0,0,0,0,0,0,0,1,0,
+3,3,2,3,3,2,3,2,2,2,3,2,2,3,2,2,1,2,3,2,2,3,1,3,2,2,2,3,2,2,2,3,
+3,2,1,3,0,1,1,1,0,2,1,1,1,1,1,0,1,0,1,1,0,0,0,0,0,0,0,0,0,2,0,0,
+1,0,0,3,0,3,3,3,3,3,0,0,3,0,2,2,3,3,3,3,3,0,0,0,1,1,3,0,0,0,0,2,
+0,0,1,0,0,0,0,0,0,0,2,3,0,0,0,3,0,2,0,0,0,0,0,3,0,0,0,0,0,0,0,0,
+2,0,3,3,3,3,0,0,2,3,0,0,3,0,3,3,2,3,3,3,3,3,0,0,3,3,3,0,0,0,3,3,
+0,0,3,0,0,0,0,2,0,0,2,1,1,3,0,0,1,0,0,2,3,0,1,0,0,0,0,0,0,0,1,0,
+3,3,3,3,2,3,3,3,3,3,3,3,1,2,1,3,3,2,2,1,2,2,2,3,1,1,2,0,2,1,2,1,
+2,2,1,0,0,0,1,1,0,1,0,1,1,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,
+3,0,2,1,2,3,3,3,0,2,0,2,2,0,2,1,3,2,2,1,2,1,0,0,2,2,1,0,2,1,2,2,
+0,1,1,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,2,1,3,3,1,1,3,0,2,3,1,1,3,2,1,1,2,0,2,2,3,2,1,1,1,1,1,2,
+3,0,0,1,3,1,2,1,2,0,3,0,0,0,1,0,3,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,
+3,3,1,1,3,2,3,3,3,1,3,2,1,3,2,1,3,2,2,2,2,1,3,3,1,2,1,3,1,2,3,0,
+2,1,1,3,2,2,2,1,2,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,
+3,3,2,3,2,3,3,2,3,2,3,2,3,3,2,1,0,3,2,2,2,1,2,2,2,1,2,2,1,2,1,1,
+2,2,2,3,0,1,3,1,1,1,1,0,1,1,0,2,1,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,2,3,2,2,1,1,3,2,3,2,3,2,0,3,2,2,1,2,0,2,2,2,1,2,2,2,2,1,
+3,2,1,2,2,1,0,2,0,1,0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,1,
+3,3,3,3,3,2,3,1,2,3,3,2,2,3,0,1,1,2,0,3,3,2,2,3,0,1,1,3,0,0,0,0,
+3,1,0,3,3,0,2,0,2,1,0,0,3,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,2,3,2,3,3,0,1,3,1,1,2,1,2,1,1,3,1,1,0,2,3,1,1,1,1,1,1,1,1,
+3,1,1,2,2,2,2,1,1,1,0,0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+3,2,2,1,1,2,1,3,3,2,3,2,2,3,2,2,3,1,2,2,1,2,0,3,2,1,2,2,2,2,2,1,
+3,2,1,2,2,2,1,1,1,1,0,0,1,1,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,1,3,3,0,2,1,0,3,2,0,0,3,1,0,1,1,0,1,0,0,0,0,0,1,
+1,0,0,1,0,3,2,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,0,2,2,2,3,0,0,1,3,0,3,2,0,3,2,2,3,3,3,3,3,1,0,2,2,2,0,2,2,1,2,
+0,2,3,0,0,0,0,1,0,1,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+3,0,2,3,1,3,3,2,3,3,0,3,3,0,3,2,2,3,2,3,3,3,0,0,2,2,3,0,1,1,1,3,
+0,0,3,0,0,0,2,2,0,1,3,0,1,2,2,2,3,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,
+3,2,3,3,2,0,3,3,2,2,3,1,3,2,1,3,2,0,1,2,2,0,2,3,2,1,0,3,0,0,0,0,
+3,0,0,2,3,1,3,0,0,3,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,1,3,2,2,2,1,2,0,1,3,1,1,3,1,3,0,0,2,1,1,1,1,2,1,1,1,0,2,1,0,1,
+1,2,0,0,0,3,1,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,3,1,0,0,0,1,0,
+3,3,3,3,2,2,2,2,2,1,3,1,1,1,2,0,1,1,2,1,2,1,3,2,0,0,3,1,1,1,1,1,
+3,1,0,2,3,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,2,3,0,3,3,0,2,0,0,0,0,0,0,0,3,0,0,1,0,0,0,0,0,0,0,0,0,0,0,
+0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,2,3,1,3,0,0,1,2,0,0,2,0,3,3,2,3,3,3,2,3,0,0,2,2,2,0,0,0,2,2,
+0,0,1,0,0,0,0,3,0,0,0,0,2,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,
+0,0,0,3,0,2,0,0,0,0,0,0,0,0,0,0,1,2,3,1,3,3,0,0,1,0,3,0,0,0,0,0,
+0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,1,2,3,1,2,3,1,0,3,0,2,2,1,0,2,1,1,2,0,1,0,0,1,1,1,1,0,1,0,0,
+1,0,0,0,0,1,1,0,3,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,2,1,0,1,1,1,3,1,2,2,2,2,2,2,1,1,1,1,0,3,1,0,1,3,1,1,1,1,
+1,1,0,2,0,1,3,1,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,2,0,1,
+3,0,2,2,1,3,3,2,3,3,0,1,1,0,2,2,1,2,1,3,3,1,0,0,3,2,0,0,0,0,2,1,
+0,1,0,0,0,0,1,2,0,1,1,3,1,1,2,2,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
+0,0,3,0,0,1,0,0,0,3,0,0,3,0,3,1,0,1,1,1,3,2,0,0,0,3,0,0,0,0,2,0,
+0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,2,0,0,0,0,0,0,0,0,0,
+3,3,1,3,2,1,3,3,1,2,2,0,1,2,1,0,1,2,0,0,0,0,0,3,0,0,0,3,0,0,0,0,
+3,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,0,1,2,0,3,3,3,2,2,0,1,1,0,1,3,0,0,0,2,2,0,0,0,0,3,1,0,1,0,0,0,
+0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,0,2,3,1,2,0,0,2,1,0,3,1,0,1,2,0,1,1,1,1,3,0,0,3,1,1,0,2,2,1,1,
+0,2,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,0,0,3,1,2,0,0,2,2,0,1,2,0,1,0,1,3,1,2,1,0,0,0,2,0,3,0,0,0,1,0,
+0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,0,1,1,2,2,0,0,0,2,0,2,1,0,1,1,0,1,1,1,2,1,0,0,1,1,1,0,2,1,1,1,
+0,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,
+0,0,0,2,0,1,3,1,1,1,1,0,0,0,0,3,2,0,1,0,0,0,1,2,0,0,0,1,0,0,0,0,
+0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,3,3,3,3,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,0,2,3,2,2,0,0,0,1,0,0,0,0,2,3,2,1,2,2,3,0,0,0,2,3,1,0,0,0,1,1,
+0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,
+3,3,2,2,0,1,0,0,0,0,2,0,2,0,1,0,0,0,1,1,0,0,0,2,1,0,1,0,1,1,0,0,
+0,1,0,2,0,0,1,0,3,0,1,0,0,0,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,1,0,0,1,0,0,0,0,0,1,1,2,0,0,0,0,1,0,0,1,3,1,0,0,0,0,1,1,0,0,
+0,1,0,0,0,0,3,0,0,0,0,0,0,3,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,
+3,3,1,1,1,1,2,3,0,0,2,1,1,1,1,1,0,2,1,1,0,0,0,2,1,0,1,2,1,1,0,1,
+2,1,0,3,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,3,1,0,0,0,0,0,0,0,3,0,0,0,3,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,
+0,0,0,2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,2,0,0,0,0,0,0,1,2,1,0,1,1,0,2,0,0,1,0,0,2,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,2,0,0,0,1,3,0,1,0,0,0,2,0,0,0,0,0,0,0,1,2,0,0,0,0,0,
+3,3,0,0,1,1,2,0,0,1,2,1,0,1,1,1,0,1,1,0,0,2,1,1,0,1,0,0,1,1,1,0,
+0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,2,2,1,0,0,0,0,1,0,0,0,0,3,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,
+2,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,3,0,0,1,1,0,0,0,2,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,1,0,1,2,0,1,2,0,0,1,1,0,2,0,1,0,0,1,0,0,0,0,1,0,0,0,2,0,0,0,0,
+1,0,0,1,0,1,1,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,1,0,0,0,0,0,0,0,1,1,0,1,1,0,2,1,3,0,0,0,0,1,1,0,0,0,0,0,0,0,3,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,0,1,0,1,0,0,2,0,0,2,0,0,1,1,2,0,0,1,1,0,0,0,1,0,0,0,1,1,0,0,0,
+1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,
+1,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,1,1,0,0,0,
+2,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,0,0,0,0,2,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,3,0,0,0,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,1,0,0,0,0,
+1,0,0,0,0,0,0,0,0,1,0,0,0,0,2,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,1,1,0,0,2,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+)
+
+TIS620ThaiModel = {
+  'char_to_order_map': TIS620CharToOrderMap,
+  'precedence_matrix': ThaiLangModel,
+  'typical_positive_ratio': 0.926386,
+  'keep_english_letter': False,
+  'charset_name': "TIS-620",
+  'language': 'Thai',
+}
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langturkishmodel.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langturkishmodel.py
new file mode 100644
index 0000000..a427a45
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/langturkishmodel.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#   Özgür Baskın - Turkish Language Model
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# 255: Control characters that usually does not exist in any text
+# 254: Carriage/Return
+# 253: symbol (punctuation) that does not belong to word
+# 252: 0 - 9
+
+# Character Mapping Table:
+Latin5_TurkishCharToOrderMap = (
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255, 23, 37, 47, 39, 29, 52, 36, 45, 53, 60, 16, 49, 20, 46, 42,
+ 48, 69, 44, 35, 31, 51, 38, 62, 65, 43, 56,255,255,255,255,255,
+255,  1, 21, 28, 12,  2, 18, 27, 25,  3, 24, 10,  5, 13,  4, 15,
+ 26, 64,  7,  8,  9, 14, 32, 57, 58, 11, 22,255,255,255,255,255,
+180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,
+164,163,162,161,160,159,101,158,157,156,155,154,153,152,151,106,
+150,149,148,147,146,145,144,100,143,142,141,140,139,138,137,136,
+ 94, 80, 93,135,105,134,133, 63,132,131,130,129,128,127,126,125,
+124,104, 73, 99, 79, 85,123, 54,122, 98, 92,121,120, 91,103,119,
+ 68,118,117, 97,116,115, 50, 90,114,113,112,111, 55, 41, 40, 86,
+ 89, 70, 59, 78, 71, 82, 88, 33, 77, 66, 84, 83,110, 75, 61, 96,
+ 30, 67,109, 74, 87,102, 34, 95, 81,108, 76, 72, 17,  6, 19,107,
+)
+
+TurkishLangModel = (
+3,2,3,3,3,1,3,3,3,3,3,3,3,3,2,1,1,3,3,1,3,3,0,3,3,3,3,3,0,3,1,3,
+3,2,1,0,0,1,1,0,0,0,1,0,0,1,1,1,1,0,0,0,0,0,0,0,2,2,0,0,1,0,0,1,
+3,2,2,3,3,0,3,3,3,3,3,3,3,2,3,1,0,3,3,1,3,3,0,3,3,3,3,3,0,3,0,3,
+3,1,1,0,1,0,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,2,2,0,0,0,1,0,1,
+3,3,2,3,3,0,3,3,3,3,3,3,3,2,3,1,1,3,3,0,3,3,1,2,3,3,3,3,0,3,0,3,
+3,1,1,0,0,0,1,0,0,0,0,1,1,0,1,2,1,0,0,0,1,0,0,0,0,2,0,0,0,0,0,1,
+3,3,3,3,3,3,2,3,3,3,3,3,3,3,3,1,3,3,2,0,3,2,1,2,2,1,3,3,0,0,0,2,
+2,2,0,1,0,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,1,0,0,1,
+3,3,3,2,3,3,1,2,3,3,3,3,3,3,3,1,3,2,1,0,3,2,0,1,2,3,3,2,1,0,0,2,
+2,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,2,0,2,0,0,0,
+1,0,1,3,3,1,3,3,3,3,3,3,3,1,2,0,0,2,3,0,2,3,0,0,2,2,2,3,0,3,0,1,
+2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,3,3,3,0,3,2,0,2,3,2,3,3,1,0,0,2,
+3,2,0,0,1,0,0,0,0,0,0,2,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,2,0,0,1,
+3,3,3,2,3,3,2,3,3,3,3,2,3,3,3,0,3,3,0,0,2,1,0,0,2,3,2,2,0,0,0,2,
+2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,2,0,0,1,
+3,3,3,2,3,3,3,3,3,3,3,2,3,3,3,0,3,2,0,1,3,2,1,1,3,2,3,2,1,0,0,2,
+2,2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,
+3,3,3,2,3,3,3,3,3,3,3,2,3,3,3,0,3,2,2,0,2,3,0,0,2,2,2,2,0,0,0,2,
+3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,2,0,1,0,0,0,
+3,3,3,3,3,3,3,2,2,2,2,3,2,3,3,0,3,3,1,1,2,2,0,0,2,2,3,2,0,0,1,3,
+0,3,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,
+3,3,3,2,3,3,3,2,1,2,2,3,2,3,3,0,3,2,0,0,1,1,0,1,1,2,1,2,0,0,0,1,
+0,3,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,
+3,3,3,2,3,3,2,3,2,2,2,3,3,3,3,1,3,1,1,0,3,2,1,1,3,3,2,3,1,0,0,1,
+1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,2,0,0,1,
+3,2,2,3,3,0,3,3,3,3,3,3,3,2,2,1,0,3,3,1,3,3,0,1,3,3,2,3,0,3,0,3,
+2,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
+2,2,2,3,3,0,3,3,3,3,3,3,3,3,3,0,0,3,2,0,3,3,0,3,2,3,3,3,0,3,1,3,
+2,0,0,0,0,0,0,0,0,0,0,1,0,1,2,0,1,0,0,0,0,0,0,0,2,2,0,0,1,0,0,1,
+3,3,3,1,2,3,3,1,0,0,1,0,0,3,3,2,3,0,0,2,0,0,2,0,2,0,0,0,2,0,2,0,
+0,3,1,0,1,0,0,0,2,2,1,0,1,1,2,1,2,2,2,0,2,1,1,0,0,0,2,0,0,0,0,0,
+1,2,1,3,3,0,3,3,3,3,3,2,3,0,0,0,0,2,3,0,2,3,1,0,2,3,1,3,0,3,0,2,
+3,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,1,3,3,2,2,3,2,2,0,1,2,3,0,1,2,1,0,1,0,0,0,1,0,2,2,0,0,0,1,
+1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,0,
+3,3,3,1,3,3,1,1,3,3,1,1,3,3,1,0,2,1,2,0,2,1,0,0,1,1,2,1,0,0,0,2,
+2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,1,0,2,1,3,0,0,2,0,0,3,3,0,3,0,0,1,0,1,2,0,0,1,1,2,2,0,1,0,
+0,1,2,1,1,0,1,0,1,1,1,1,1,0,1,1,1,2,2,1,2,0,1,0,0,0,0,0,0,1,0,0,
+3,3,3,2,3,2,3,3,0,2,2,2,3,3,3,0,3,0,0,0,2,2,0,1,2,1,1,1,0,0,0,1,
+0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,
+3,3,3,3,3,3,2,1,2,2,3,3,3,3,2,0,2,0,0,0,2,2,0,0,2,1,3,3,0,0,1,1,
+1,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,
+1,1,2,3,3,0,3,3,3,3,3,3,2,2,0,2,0,2,3,2,3,2,2,2,2,2,2,2,1,3,2,3,
+2,0,2,1,2,2,2,2,1,1,2,2,1,2,2,1,2,0,0,2,1,1,0,2,1,0,0,1,0,0,0,1,
+2,3,3,1,1,1,0,1,1,1,2,3,2,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,
+0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,2,2,2,3,2,3,2,2,1,3,3,3,0,2,1,2,0,2,1,0,0,1,1,1,1,1,0,0,1,
+2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,2,0,1,0,0,0,
+3,3,3,2,3,3,3,3,3,2,3,1,2,3,3,1,2,0,0,0,0,0,0,0,3,2,1,1,0,0,0,0,
+2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
+3,3,3,2,2,3,3,2,1,1,1,1,1,3,3,0,3,1,0,0,1,1,0,0,3,1,2,1,0,0,0,0,
+0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,
+3,3,3,2,2,3,2,2,2,3,2,1,1,3,3,0,3,0,0,0,0,1,0,0,3,1,1,2,0,0,0,1,
+1,0,0,1,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+1,1,1,3,3,0,3,3,3,3,3,2,2,2,1,2,0,2,1,2,2,1,1,0,1,2,2,2,2,2,2,2,
+0,0,2,1,2,1,2,1,0,1,1,3,1,2,1,1,2,0,0,2,0,1,0,1,0,1,0,0,0,1,0,1,
+3,3,3,1,3,3,3,0,1,1,0,2,2,3,1,0,3,0,0,0,1,0,0,0,1,0,0,1,0,1,0,0,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,2,0,0,2,2,1,0,0,1,0,0,3,3,1,3,0,0,1,1,0,2,0,3,0,0,0,2,0,1,1,
+0,1,2,0,1,2,2,0,2,2,2,2,1,0,2,1,1,0,2,0,2,1,2,0,0,0,0,0,0,0,0,0,
+3,3,3,1,3,2,3,2,0,2,2,2,1,3,2,0,2,1,2,0,1,2,0,0,1,0,2,2,0,0,0,2,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,
+3,3,3,0,3,3,1,1,2,3,1,0,3,2,3,0,3,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,
+1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,3,3,0,3,3,2,3,3,2,2,0,0,0,0,1,2,0,1,3,0,0,0,3,1,1,0,3,0,2,
+2,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,1,2,2,1,0,3,1,1,1,1,3,3,2,3,0,0,1,0,1,2,0,2,2,0,2,2,0,2,1,
+0,2,2,1,1,1,1,0,2,1,1,0,1,1,1,1,2,1,2,1,2,0,1,0,1,0,0,0,0,0,0,0,
+3,3,3,0,1,1,3,0,0,1,1,0,0,2,2,0,3,0,0,1,1,0,1,0,0,0,0,0,2,0,0,0,
+0,3,1,0,1,0,1,0,2,0,0,1,0,1,0,1,1,1,2,1,1,0,2,0,0,0,0,0,0,0,0,0,
+3,3,3,0,2,0,2,0,1,1,1,0,0,3,3,0,2,0,0,1,0,0,2,1,1,0,1,0,1,0,1,0,
+0,2,0,1,2,0,2,0,2,1,1,0,1,0,2,1,1,0,2,1,1,0,1,0,0,0,1,1,0,0,0,0,
+3,2,3,0,1,0,0,0,0,0,0,0,0,1,2,0,1,0,0,1,0,0,1,0,0,0,0,0,2,0,0,0,
+0,0,1,1,0,0,1,0,1,0,0,1,0,0,0,2,1,0,1,0,2,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,0,0,2,3,0,0,1,0,1,0,2,3,2,3,0,0,1,3,0,2,1,0,0,0,0,2,0,1,0,
+0,2,1,0,0,1,1,0,2,1,0,0,1,0,0,1,1,0,1,1,2,0,1,0,0,0,0,1,0,0,0,0,
+3,2,2,0,0,1,1,0,0,0,0,0,0,3,1,1,1,0,0,0,0,0,1,0,0,0,0,0,2,0,1,0,
+0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,
+0,0,0,3,3,0,2,3,2,2,1,2,2,1,1,2,0,1,3,2,2,2,0,0,2,2,0,0,0,1,2,1,
+3,0,2,1,1,0,1,1,1,0,1,2,2,2,1,1,2,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,
+0,1,1,2,3,0,3,3,3,2,2,2,2,1,0,1,0,1,0,1,2,2,0,0,2,2,1,3,1,1,2,1,
+0,0,1,1,2,0,1,1,0,0,1,2,0,2,1,1,2,0,0,1,0,0,0,1,0,1,0,1,0,0,0,0,
+3,3,2,0,0,3,1,0,0,0,0,0,0,3,2,1,2,0,0,1,0,0,2,0,0,0,0,0,2,0,1,0,
+0,2,1,1,0,0,1,0,1,2,0,0,1,1,0,0,2,1,1,1,1,0,2,0,0,0,0,0,0,0,0,0,
+3,3,2,0,0,1,0,0,0,0,1,0,0,3,3,2,2,0,0,1,0,0,2,0,1,0,0,0,2,0,1,0,
+0,0,1,1,0,0,2,0,2,1,0,0,1,1,2,1,2,0,2,1,2,1,1,1,0,0,1,1,0,0,0,0,
+3,3,2,0,0,2,2,0,0,0,1,1,0,2,2,1,3,1,0,1,0,1,2,0,0,0,0,0,1,0,1,0,
+0,1,1,0,0,0,0,0,1,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,2,0,0,0,1,0,0,1,0,0,2,3,1,2,0,0,1,0,0,2,0,0,0,1,0,2,0,2,0,
+0,1,1,2,2,1,2,0,2,1,1,0,0,1,1,0,1,1,1,1,2,1,1,0,0,0,0,0,0,0,0,0,
+3,3,3,0,2,1,2,1,0,0,1,1,0,3,3,1,2,0,0,1,0,0,2,0,2,0,1,1,2,0,0,0,
+0,0,1,1,1,1,2,0,1,1,0,1,1,1,1,0,0,0,1,1,1,0,1,0,0,0,1,0,0,0,0,0,
+3,3,3,0,2,2,3,2,0,0,1,0,0,2,3,1,0,0,0,0,0,0,2,0,2,0,0,0,2,0,0,0,
+0,1,1,0,0,0,1,0,0,1,0,1,1,0,1,0,1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,
+3,2,3,0,0,0,0,0,0,0,1,0,0,2,2,2,2,0,0,1,0,0,2,0,0,0,0,0,2,0,1,0,
+0,0,2,1,1,0,1,0,2,1,1,0,0,1,1,2,1,0,2,0,2,0,1,0,0,0,2,0,0,0,0,0,
+0,0,0,2,2,0,2,1,1,1,1,2,2,0,0,1,0,1,0,0,1,3,0,0,0,0,1,0,0,2,1,0,
+0,0,1,0,1,0,0,0,0,0,2,1,0,1,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,
+2,0,0,2,3,0,2,3,1,2,2,0,2,0,0,2,0,2,1,1,1,2,1,0,0,1,2,1,1,2,1,0,
+1,0,2,0,1,0,1,1,0,0,2,2,1,2,1,1,2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
+3,3,3,0,2,1,2,0,0,0,1,0,0,3,2,0,1,0,0,1,0,0,2,0,0,0,1,2,1,0,1,0,
+0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,1,0,1,1,1,0,1,0,0,0,0,0,0,0,0,0,
+0,0,0,2,2,0,2,2,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,0,1,0,0,0,1,1,1,1,
+0,0,2,1,0,1,1,1,0,1,1,2,1,2,1,1,2,0,1,1,2,1,0,2,0,0,0,0,0,0,0,0,
+3,2,2,0,0,2,0,0,0,0,0,0,0,2,2,0,2,0,0,1,0,0,2,0,0,0,0,0,2,0,0,0,
+0,2,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,
+0,0,0,3,2,0,2,2,0,1,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,
+2,0,1,0,1,0,1,1,0,0,1,2,0,1,0,1,1,0,0,1,0,1,0,2,0,0,0,0,0,0,0,0,
+2,2,2,0,1,1,0,0,0,1,0,0,0,1,2,0,1,0,0,1,0,0,1,0,0,0,0,1,2,0,1,0,
+0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,1,0,2,0,0,0,0,0,0,0,0,0,0,0,
+2,2,2,2,1,0,1,1,1,0,0,0,0,1,2,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,
+1,1,2,0,1,0,0,0,1,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,2,0,0,0,0,0,1,
+0,0,1,2,2,0,2,1,2,1,1,2,2,0,0,0,0,1,0,0,1,1,0,0,2,0,0,0,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,
+2,2,2,0,0,0,1,0,0,0,0,0,0,2,2,1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
+0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,2,2,0,1,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,1,0,0,0,0,0,0,0,0,0,0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+)
+
+Latin5TurkishModel = {
+  'char_to_order_map': Latin5_TurkishCharToOrderMap,
+  'precedence_matrix': TurkishLangModel,
+  'typical_positive_ratio': 0.970290,
+  'keep_english_letter': True,
+  'charset_name': "ISO-8859-9",
+  'language': 'Turkish',
+}
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/latin1prober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/latin1prober.py
new file mode 100644
index 0000000..7d1e8c2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/latin1prober.py
@@ -0,0 +1,145 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Universal charset detector code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 2001
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#   Shy Shalom - original C code
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .charsetprober import CharSetProber
+from .enums import ProbingState
+
+FREQ_CAT_NUM = 4
+
+UDF = 0  # undefined
+OTH = 1  # other
+ASC = 2  # ascii capital letter
+ASS = 3  # ascii small letter
+ACV = 4  # accent capital vowel
+ACO = 5  # accent capital other
+ASV = 6  # accent small vowel
+ASO = 7  # accent small other
+CLASS_NUM = 8  # total classes
+
+Latin1_CharToClass = (
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # 00 - 07
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # 08 - 0F
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # 10 - 17
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # 18 - 1F
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # 20 - 27
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # 28 - 2F
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # 30 - 37
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # 38 - 3F
+    OTH, ASC, ASC, ASC, ASC, ASC, ASC, ASC,   # 40 - 47
+    ASC, ASC, ASC, ASC, ASC, ASC, ASC, ASC,   # 48 - 4F
+    ASC, ASC, ASC, ASC, ASC, ASC, ASC, ASC,   # 50 - 57
+    ASC, ASC, ASC, OTH, OTH, OTH, OTH, OTH,   # 58 - 5F
+    OTH, ASS, ASS, ASS, ASS, ASS, ASS, ASS,   # 60 - 67
+    ASS, ASS, ASS, ASS, ASS, ASS, ASS, ASS,   # 68 - 6F
+    ASS, ASS, ASS, ASS, ASS, ASS, ASS, ASS,   # 70 - 77
+    ASS, ASS, ASS, OTH, OTH, OTH, OTH, OTH,   # 78 - 7F
+    OTH, UDF, OTH, ASO, OTH, OTH, OTH, OTH,   # 80 - 87
+    OTH, OTH, ACO, OTH, ACO, UDF, ACO, UDF,   # 88 - 8F
+    UDF, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # 90 - 97
+    OTH, OTH, ASO, OTH, ASO, UDF, ASO, ACO,   # 98 - 9F
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # A0 - A7
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # A8 - AF
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # B0 - B7
+    OTH, OTH, OTH, OTH, OTH, OTH, OTH, OTH,   # B8 - BF
+    ACV, ACV, ACV, ACV, ACV, ACV, ACO, ACO,   # C0 - C7
+    ACV, ACV, ACV, ACV, ACV, ACV, ACV, ACV,   # C8 - CF
+    ACO, ACO, ACV, ACV, ACV, ACV, ACV, OTH,   # D0 - D7
+    ACV, ACV, ACV, ACV, ACV, ACO, ACO, ACO,   # D8 - DF
+    ASV, ASV, ASV, ASV, ASV, ASV, ASO, ASO,   # E0 - E7
+    ASV, ASV, ASV, ASV, ASV, ASV, ASV, ASV,   # E8 - EF
+    ASO, ASO, ASV, ASV, ASV, ASV, ASV, OTH,   # F0 - F7
+    ASV, ASV, ASV, ASV, ASV, ASO, ASO, ASO,   # F8 - FF
+)
+
+# 0 : illegal
+# 1 : very unlikely
+# 2 : normal
+# 3 : very likely
+Latin1ClassModel = (
+# UDF OTH ASC ASS ACV ACO ASV ASO
+    0,  0,  0,  0,  0,  0,  0,  0,  # UDF
+    0,  3,  3,  3,  3,  3,  3,  3,  # OTH
+    0,  3,  3,  3,  3,  3,  3,  3,  # ASC
+    0,  3,  3,  3,  1,  1,  3,  3,  # ASS
+    0,  3,  3,  3,  1,  2,  1,  2,  # ACV
+    0,  3,  3,  3,  3,  3,  3,  3,  # ACO
+    0,  3,  1,  3,  1,  1,  1,  3,  # ASV
+    0,  3,  1,  3,  1,  1,  3,  3,  # ASO
+)
+
+
+class Latin1Prober(CharSetProber):
+    def __init__(self):
+        super(Latin1Prober, self).__init__()
+        self._last_char_class = None
+        self._freq_counter = None
+        self.reset()
+
+    def reset(self):
+        self._last_char_class = OTH
+        self._freq_counter = [0] * FREQ_CAT_NUM
+        CharSetProber.reset(self)
+
+    @property
+    def charset_name(self):
+        return "ISO-8859-1"
+
+    @property
+    def language(self):
+        return ""
+
+    def feed(self, byte_str):
+        byte_str = self.filter_with_english_letters(byte_str)
+        for c in byte_str:
+            char_class = Latin1_CharToClass[c]
+            freq = Latin1ClassModel[(self._last_char_class * CLASS_NUM)
+                                    + char_class]
+            if freq == 0:
+                self._state = ProbingState.NOT_ME
+                break
+            self._freq_counter[freq] += 1
+            self._last_char_class = char_class
+
+        return self.state
+
+    def get_confidence(self):
+        if self.state == ProbingState.NOT_ME:
+            return 0.01
+
+        total = sum(self._freq_counter)
+        if total < 0.01:
+            confidence = 0.0
+        else:
+            confidence = ((self._freq_counter[3] - self._freq_counter[1] * 20.0)
+                          / total)
+        if confidence < 0.0:
+            confidence = 0.0
+        # lower the confidence of latin1 so that other more accurate
+        # detector can take priority.
+        confidence = confidence * 0.73
+        return confidence
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/mbcharsetprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/mbcharsetprober.py
new file mode 100644
index 0000000..6256ecf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/mbcharsetprober.py
@@ -0,0 +1,91 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Universal charset detector code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 2001
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#   Shy Shalom - original C code
+#   Proofpoint, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .charsetprober import CharSetProber
+from .enums import ProbingState, MachineState
+
+
+class MultiByteCharSetProber(CharSetProber):
+    """
+    MultiByteCharSetProber
+    """
+
+    def __init__(self, lang_filter=None):
+        super(MultiByteCharSetProber, self).__init__(lang_filter=lang_filter)
+        self.distribution_analyzer = None
+        self.coding_sm = None
+        self._last_char = [0, 0]
+
+    def reset(self):
+        super(MultiByteCharSetProber, self).reset()
+        if self.coding_sm:
+            self.coding_sm.reset()
+        if self.distribution_analyzer:
+            self.distribution_analyzer.reset()
+        self._last_char = [0, 0]
+
+    @property
+    def charset_name(self):
+        raise NotImplementedError
+
+    @property
+    def language(self):
+        raise NotImplementedError
+
+    def feed(self, byte_str):
+        for i in range(len(byte_str)):
+            coding_state = self.coding_sm.next_state(byte_str[i])
+            if coding_state == MachineState.ERROR:
+                self.logger.debug('%s %s prober hit error at byte %s',
+                                  self.charset_name, self.language, i)
+                self._state = ProbingState.NOT_ME
+                break
+            elif coding_state == MachineState.ITS_ME:
+                self._state = ProbingState.FOUND_IT
+                break
+            elif coding_state == MachineState.START:
+                char_len = self.coding_sm.get_current_charlen()
+                if i == 0:
+                    self._last_char[1] = byte_str[0]
+                    self.distribution_analyzer.feed(self._last_char, char_len)
+                else:
+                    self.distribution_analyzer.feed(byte_str[i - 1:i + 1],
+                                                    char_len)
+
+        self._last_char[0] = byte_str[-1]
+
+        if self.state == ProbingState.DETECTING:
+            if (self.distribution_analyzer.got_enough_data() and
+                    (self.get_confidence() > self.SHORTCUT_THRESHOLD)):
+                self._state = ProbingState.FOUND_IT
+
+        return self.state
+
+    def get_confidence(self):
+        return self.distribution_analyzer.get_confidence()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/mbcsgroupprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/mbcsgroupprober.py
new file mode 100644
index 0000000..530abe7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/mbcsgroupprober.py
@@ -0,0 +1,54 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Universal charset detector code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 2001
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#   Shy Shalom - original C code
+#   Proofpoint, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .charsetgroupprober import CharSetGroupProber
+from .utf8prober import UTF8Prober
+from .sjisprober import SJISProber
+from .eucjpprober import EUCJPProber
+from .gb2312prober import GB2312Prober
+from .euckrprober import EUCKRProber
+from .cp949prober import CP949Prober
+from .big5prober import Big5Prober
+from .euctwprober import EUCTWProber
+
+
+class MBCSGroupProber(CharSetGroupProber):
+    def __init__(self, lang_filter=None):
+        super(MBCSGroupProber, self).__init__(lang_filter=lang_filter)
+        self.probers = [
+            UTF8Prober(),
+            SJISProber(),
+            EUCJPProber(),
+            GB2312Prober(),
+            EUCKRProber(),
+            CP949Prober(),
+            Big5Prober(),
+            EUCTWProber()
+        ]
+        self.reset()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/mbcssm.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/mbcssm.py
new file mode 100644
index 0000000..8360d0f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/mbcssm.py
@@ -0,0 +1,572 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .enums import MachineState
+
+# BIG5
+
+BIG5_CLS = (
+    1,1,1,1,1,1,1,1,  # 00 - 07    #allow 0x00 as legal value
+    1,1,1,1,1,1,0,0,  # 08 - 0f
+    1,1,1,1,1,1,1,1,  # 10 - 17
+    1,1,1,0,1,1,1,1,  # 18 - 1f
+    1,1,1,1,1,1,1,1,  # 20 - 27
+    1,1,1,1,1,1,1,1,  # 28 - 2f
+    1,1,1,1,1,1,1,1,  # 30 - 37
+    1,1,1,1,1,1,1,1,  # 38 - 3f
+    2,2,2,2,2,2,2,2,  # 40 - 47
+    2,2,2,2,2,2,2,2,  # 48 - 4f
+    2,2,2,2,2,2,2,2,  # 50 - 57
+    2,2,2,2,2,2,2,2,  # 58 - 5f
+    2,2,2,2,2,2,2,2,  # 60 - 67
+    2,2,2,2,2,2,2,2,  # 68 - 6f
+    2,2,2,2,2,2,2,2,  # 70 - 77
+    2,2,2,2,2,2,2,1,  # 78 - 7f
+    4,4,4,4,4,4,4,4,  # 80 - 87
+    4,4,4,4,4,4,4,4,  # 88 - 8f
+    4,4,4,4,4,4,4,4,  # 90 - 97
+    4,4,4,4,4,4,4,4,  # 98 - 9f
+    4,3,3,3,3,3,3,3,  # a0 - a7
+    3,3,3,3,3,3,3,3,  # a8 - af
+    3,3,3,3,3,3,3,3,  # b0 - b7
+    3,3,3,3,3,3,3,3,  # b8 - bf
+    3,3,3,3,3,3,3,3,  # c0 - c7
+    3,3,3,3,3,3,3,3,  # c8 - cf
+    3,3,3,3,3,3,3,3,  # d0 - d7
+    3,3,3,3,3,3,3,3,  # d8 - df
+    3,3,3,3,3,3,3,3,  # e0 - e7
+    3,3,3,3,3,3,3,3,  # e8 - ef
+    3,3,3,3,3,3,3,3,  # f0 - f7
+    3,3,3,3,3,3,3,0  # f8 - ff
+)
+
+BIG5_ST = (
+    MachineState.ERROR,MachineState.START,MachineState.START,     3,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#00-07
+    MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,#08-0f
+    MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START#10-17
+)
+
+BIG5_CHAR_LEN_TABLE = (0, 1, 1, 2, 0)
+
+BIG5_SM_MODEL = {'class_table': BIG5_CLS,
+                 'class_factor': 5,
+                 'state_table': BIG5_ST,
+                 'char_len_table': BIG5_CHAR_LEN_TABLE,
+                 'name': 'Big5'}
+
+# CP949
+
+CP949_CLS  = (
+    1,1,1,1,1,1,1,1, 1,1,1,1,1,1,0,0,  # 00 - 0f
+    1,1,1,1,1,1,1,1, 1,1,1,0,1,1,1,1,  # 10 - 1f
+    1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,  # 20 - 2f
+    1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,  # 30 - 3f
+    1,4,4,4,4,4,4,4, 4,4,4,4,4,4,4,4,  # 40 - 4f
+    4,4,5,5,5,5,5,5, 5,5,5,1,1,1,1,1,  # 50 - 5f
+    1,5,5,5,5,5,5,5, 5,5,5,5,5,5,5,5,  # 60 - 6f
+    5,5,5,5,5,5,5,5, 5,5,5,1,1,1,1,1,  # 70 - 7f
+    0,6,6,6,6,6,6,6, 6,6,6,6,6,6,6,6,  # 80 - 8f
+    6,6,6,6,6,6,6,6, 6,6,6,6,6,6,6,6,  # 90 - 9f
+    6,7,7,7,7,7,7,7, 7,7,7,7,7,8,8,8,  # a0 - af
+    7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,  # b0 - bf
+    7,7,7,7,7,7,9,2, 2,3,2,2,2,2,2,2,  # c0 - cf
+    2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,  # d0 - df
+    2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,  # e0 - ef
+    2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,0,  # f0 - ff
+)
+
+CP949_ST = (
+#cls=    0      1      2      3      4      5      6      7      8      9  # previous state =
+    MachineState.ERROR,MachineState.START,     3,MachineState.ERROR,MachineState.START,MachineState.START,     4,     5,MachineState.ERROR,     6, # MachineState.START
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR, # MachineState.ERROR
+    MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME, # MachineState.ITS_ME
+    MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START, # 3
+    MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START, # 4
+    MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START, # 5
+    MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START, # 6
+)
+
+CP949_CHAR_LEN_TABLE = (0, 1, 2, 0, 1, 1, 2, 2, 0, 2)
+
+CP949_SM_MODEL = {'class_table': CP949_CLS,
+                  'class_factor': 10,
+                  'state_table': CP949_ST,
+                  'char_len_table': CP949_CHAR_LEN_TABLE,
+                  'name': 'CP949'}
+
+# EUC-JP
+
+EUCJP_CLS = (
+    4,4,4,4,4,4,4,4,  # 00 - 07
+    4,4,4,4,4,4,5,5,  # 08 - 0f
+    4,4,4,4,4,4,4,4,  # 10 - 17
+    4,4,4,5,4,4,4,4,  # 18 - 1f
+    4,4,4,4,4,4,4,4,  # 20 - 27
+    4,4,4,4,4,4,4,4,  # 28 - 2f
+    4,4,4,4,4,4,4,4,  # 30 - 37
+    4,4,4,4,4,4,4,4,  # 38 - 3f
+    4,4,4,4,4,4,4,4,  # 40 - 47
+    4,4,4,4,4,4,4,4,  # 48 - 4f
+    4,4,4,4,4,4,4,4,  # 50 - 57
+    4,4,4,4,4,4,4,4,  # 58 - 5f
+    4,4,4,4,4,4,4,4,  # 60 - 67
+    4,4,4,4,4,4,4,4,  # 68 - 6f
+    4,4,4,4,4,4,4,4,  # 70 - 77
+    4,4,4,4,4,4,4,4,  # 78 - 7f
+    5,5,5,5,5,5,5,5,  # 80 - 87
+    5,5,5,5,5,5,1,3,  # 88 - 8f
+    5,5,5,5,5,5,5,5,  # 90 - 97
+    5,5,5,5,5,5,5,5,  # 98 - 9f
+    5,2,2,2,2,2,2,2,  # a0 - a7
+    2,2,2,2,2,2,2,2,  # a8 - af
+    2,2,2,2,2,2,2,2,  # b0 - b7
+    2,2,2,2,2,2,2,2,  # b8 - bf
+    2,2,2,2,2,2,2,2,  # c0 - c7
+    2,2,2,2,2,2,2,2,  # c8 - cf
+    2,2,2,2,2,2,2,2,  # d0 - d7
+    2,2,2,2,2,2,2,2,  # d8 - df
+    0,0,0,0,0,0,0,0,  # e0 - e7
+    0,0,0,0,0,0,0,0,  # e8 - ef
+    0,0,0,0,0,0,0,0,  # f0 - f7
+    0,0,0,0,0,0,0,5  # f8 - ff
+)
+
+EUCJP_ST = (
+          3,     4,     3,     5,MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#00-07
+     MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,#08-0f
+     MachineState.ITS_ME,MachineState.ITS_ME,MachineState.START,MachineState.ERROR,MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#10-17
+     MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     3,MachineState.ERROR,#18-1f
+          3,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START#20-27
+)
+
+EUCJP_CHAR_LEN_TABLE = (2, 2, 2, 3, 1, 0)
+
+EUCJP_SM_MODEL = {'class_table': EUCJP_CLS,
+                  'class_factor': 6,
+                  'state_table': EUCJP_ST,
+                  'char_len_table': EUCJP_CHAR_LEN_TABLE,
+                  'name': 'EUC-JP'}
+
+# EUC-KR
+
+EUCKR_CLS  = (
+    1,1,1,1,1,1,1,1,  # 00 - 07
+    1,1,1,1,1,1,0,0,  # 08 - 0f
+    1,1,1,1,1,1,1,1,  # 10 - 17
+    1,1,1,0,1,1,1,1,  # 18 - 1f
+    1,1,1,1,1,1,1,1,  # 20 - 27
+    1,1,1,1,1,1,1,1,  # 28 - 2f
+    1,1,1,1,1,1,1,1,  # 30 - 37
+    1,1,1,1,1,1,1,1,  # 38 - 3f
+    1,1,1,1,1,1,1,1,  # 40 - 47
+    1,1,1,1,1,1,1,1,  # 48 - 4f
+    1,1,1,1,1,1,1,1,  # 50 - 57
+    1,1,1,1,1,1,1,1,  # 58 - 5f
+    1,1,1,1,1,1,1,1,  # 60 - 67
+    1,1,1,1,1,1,1,1,  # 68 - 6f
+    1,1,1,1,1,1,1,1,  # 70 - 77
+    1,1,1,1,1,1,1,1,  # 78 - 7f
+    0,0,0,0,0,0,0,0,  # 80 - 87
+    0,0,0,0,0,0,0,0,  # 88 - 8f
+    0,0,0,0,0,0,0,0,  # 90 - 97
+    0,0,0,0,0,0,0,0,  # 98 - 9f
+    0,2,2,2,2,2,2,2,  # a0 - a7
+    2,2,2,2,2,3,3,3,  # a8 - af
+    2,2,2,2,2,2,2,2,  # b0 - b7
+    2,2,2,2,2,2,2,2,  # b8 - bf
+    2,2,2,2,2,2,2,2,  # c0 - c7
+    2,3,2,2,2,2,2,2,  # c8 - cf
+    2,2,2,2,2,2,2,2,  # d0 - d7
+    2,2,2,2,2,2,2,2,  # d8 - df
+    2,2,2,2,2,2,2,2,  # e0 - e7
+    2,2,2,2,2,2,2,2,  # e8 - ef
+    2,2,2,2,2,2,2,2,  # f0 - f7
+    2,2,2,2,2,2,2,0   # f8 - ff
+)
+
+EUCKR_ST = (
+    MachineState.ERROR,MachineState.START,     3,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#00-07
+    MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START #08-0f
+)
+
+EUCKR_CHAR_LEN_TABLE = (0, 1, 2, 0)
+
+EUCKR_SM_MODEL = {'class_table': EUCKR_CLS,
+                'class_factor': 4,
+                'state_table': EUCKR_ST,
+                'char_len_table': EUCKR_CHAR_LEN_TABLE,
+                'name': 'EUC-KR'}
+
+# EUC-TW
+
+EUCTW_CLS = (
+    2,2,2,2,2,2,2,2,  # 00 - 07
+    2,2,2,2,2,2,0,0,  # 08 - 0f
+    2,2,2,2,2,2,2,2,  # 10 - 17
+    2,2,2,0,2,2,2,2,  # 18 - 1f
+    2,2,2,2,2,2,2,2,  # 20 - 27
+    2,2,2,2,2,2,2,2,  # 28 - 2f
+    2,2,2,2,2,2,2,2,  # 30 - 37
+    2,2,2,2,2,2,2,2,  # 38 - 3f
+    2,2,2,2,2,2,2,2,  # 40 - 47
+    2,2,2,2,2,2,2,2,  # 48 - 4f
+    2,2,2,2,2,2,2,2,  # 50 - 57
+    2,2,2,2,2,2,2,2,  # 58 - 5f
+    2,2,2,2,2,2,2,2,  # 60 - 67
+    2,2,2,2,2,2,2,2,  # 68 - 6f
+    2,2,2,2,2,2,2,2,  # 70 - 77
+    2,2,2,2,2,2,2,2,  # 78 - 7f
+    0,0,0,0,0,0,0,0,  # 80 - 87
+    0,0,0,0,0,0,6,0,  # 88 - 8f
+    0,0,0,0,0,0,0,0,  # 90 - 97
+    0,0,0,0,0,0,0,0,  # 98 - 9f
+    0,3,4,4,4,4,4,4,  # a0 - a7
+    5,5,1,1,1,1,1,1,  # a8 - af
+    1,1,1,1,1,1,1,1,  # b0 - b7
+    1,1,1,1,1,1,1,1,  # b8 - bf
+    1,1,3,1,3,3,3,3,  # c0 - c7
+    3,3,3,3,3,3,3,3,  # c8 - cf
+    3,3,3,3,3,3,3,3,  # d0 - d7
+    3,3,3,3,3,3,3,3,  # d8 - df
+    3,3,3,3,3,3,3,3,  # e0 - e7
+    3,3,3,3,3,3,3,3,  # e8 - ef
+    3,3,3,3,3,3,3,3,  # f0 - f7
+    3,3,3,3,3,3,3,0   # f8 - ff
+)
+
+EUCTW_ST = (
+    MachineState.ERROR,MachineState.ERROR,MachineState.START,     3,     3,     3,     4,MachineState.ERROR,#00-07
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,#08-0f
+    MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.START,MachineState.ERROR,#10-17
+    MachineState.START,MachineState.START,MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#18-1f
+         5,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.ERROR,MachineState.START,MachineState.START,#20-27
+    MachineState.START,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START #28-2f
+)
+
+EUCTW_CHAR_LEN_TABLE = (0, 0, 1, 2, 2, 2, 3)
+
+EUCTW_SM_MODEL = {'class_table': EUCTW_CLS,
+                'class_factor': 7,
+                'state_table': EUCTW_ST,
+                'char_len_table': EUCTW_CHAR_LEN_TABLE,
+                'name': 'x-euc-tw'}
+
+# GB2312
+
+GB2312_CLS = (
+    1,1,1,1,1,1,1,1,  # 00 - 07
+    1,1,1,1,1,1,0,0,  # 08 - 0f
+    1,1,1,1,1,1,1,1,  # 10 - 17
+    1,1,1,0,1,1,1,1,  # 18 - 1f
+    1,1,1,1,1,1,1,1,  # 20 - 27
+    1,1,1,1,1,1,1,1,  # 28 - 2f
+    3,3,3,3,3,3,3,3,  # 30 - 37
+    3,3,1,1,1,1,1,1,  # 38 - 3f
+    2,2,2,2,2,2,2,2,  # 40 - 47
+    2,2,2,2,2,2,2,2,  # 48 - 4f
+    2,2,2,2,2,2,2,2,  # 50 - 57
+    2,2,2,2,2,2,2,2,  # 58 - 5f
+    2,2,2,2,2,2,2,2,  # 60 - 67
+    2,2,2,2,2,2,2,2,  # 68 - 6f
+    2,2,2,2,2,2,2,2,  # 70 - 77
+    2,2,2,2,2,2,2,4,  # 78 - 7f
+    5,6,6,6,6,6,6,6,  # 80 - 87
+    6,6,6,6,6,6,6,6,  # 88 - 8f
+    6,6,6,6,6,6,6,6,  # 90 - 97
+    6,6,6,6,6,6,6,6,  # 98 - 9f
+    6,6,6,6,6,6,6,6,  # a0 - a7
+    6,6,6,6,6,6,6,6,  # a8 - af
+    6,6,6,6,6,6,6,6,  # b0 - b7
+    6,6,6,6,6,6,6,6,  # b8 - bf
+    6,6,6,6,6,6,6,6,  # c0 - c7
+    6,6,6,6,6,6,6,6,  # c8 - cf
+    6,6,6,6,6,6,6,6,  # d0 - d7
+    6,6,6,6,6,6,6,6,  # d8 - df
+    6,6,6,6,6,6,6,6,  # e0 - e7
+    6,6,6,6,6,6,6,6,  # e8 - ef
+    6,6,6,6,6,6,6,6,  # f0 - f7
+    6,6,6,6,6,6,6,0   # f8 - ff
+)
+
+GB2312_ST = (
+    MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,     3,MachineState.ERROR,#00-07
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,#08-0f
+    MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.START,#10-17
+         4,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#18-1f
+    MachineState.ERROR,MachineState.ERROR,     5,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,#20-27
+    MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START #28-2f
+)
+
+# To be accurate, the length of class 6 can be either 2 or 4.
+# But it is not necessary to discriminate between the two since
+# it is used for frequency analysis only, and we are validating
+# each code range there as well. So it is safe to set it to be
+# 2 here.
+GB2312_CHAR_LEN_TABLE = (0, 1, 1, 1, 1, 1, 2)
+
+GB2312_SM_MODEL = {'class_table': GB2312_CLS,
+                   'class_factor': 7,
+                   'state_table': GB2312_ST,
+                   'char_len_table': GB2312_CHAR_LEN_TABLE,
+                   'name': 'GB2312'}
+
+# Shift_JIS
+
+SJIS_CLS = (
+    1,1,1,1,1,1,1,1,  # 00 - 07
+    1,1,1,1,1,1,0,0,  # 08 - 0f
+    1,1,1,1,1,1,1,1,  # 10 - 17
+    1,1,1,0,1,1,1,1,  # 18 - 1f
+    1,1,1,1,1,1,1,1,  # 20 - 27
+    1,1,1,1,1,1,1,1,  # 28 - 2f
+    1,1,1,1,1,1,1,1,  # 30 - 37
+    1,1,1,1,1,1,1,1,  # 38 - 3f
+    2,2,2,2,2,2,2,2,  # 40 - 47
+    2,2,2,2,2,2,2,2,  # 48 - 4f
+    2,2,2,2,2,2,2,2,  # 50 - 57
+    2,2,2,2,2,2,2,2,  # 58 - 5f
+    2,2,2,2,2,2,2,2,  # 60 - 67
+    2,2,2,2,2,2,2,2,  # 68 - 6f
+    2,2,2,2,2,2,2,2,  # 70 - 77
+    2,2,2,2,2,2,2,1,  # 78 - 7f
+    3,3,3,3,3,2,2,3,  # 80 - 87
+    3,3,3,3,3,3,3,3,  # 88 - 8f
+    3,3,3,3,3,3,3,3,  # 90 - 97
+    3,3,3,3,3,3,3,3,  # 98 - 9f
+    #0xa0 is illegal in sjis encoding, but some pages does
+    #contain such byte. We need to be more error forgiven.
+    2,2,2,2,2,2,2,2,  # a0 - a7
+    2,2,2,2,2,2,2,2,  # a8 - af
+    2,2,2,2,2,2,2,2,  # b0 - b7
+    2,2,2,2,2,2,2,2,  # b8 - bf
+    2,2,2,2,2,2,2,2,  # c0 - c7
+    2,2,2,2,2,2,2,2,  # c8 - cf
+    2,2,2,2,2,2,2,2,  # d0 - d7
+    2,2,2,2,2,2,2,2,  # d8 - df
+    3,3,3,3,3,3,3,3,  # e0 - e7
+    3,3,3,3,3,4,4,4,  # e8 - ef
+    3,3,3,3,3,3,3,3,  # f0 - f7
+    3,3,3,3,3,0,0,0)  # f8 - ff
+
+
+SJIS_ST = (
+    MachineState.ERROR,MachineState.START,MachineState.START,     3,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#00-07
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,#08-0f
+    MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START #10-17
+)
+
+SJIS_CHAR_LEN_TABLE = (0, 1, 1, 2, 0, 0)
+
+SJIS_SM_MODEL = {'class_table': SJIS_CLS,
+               'class_factor': 6,
+               'state_table': SJIS_ST,
+               'char_len_table': SJIS_CHAR_LEN_TABLE,
+               'name': 'Shift_JIS'}
+
+# UCS2-BE
+
+UCS2BE_CLS = (
+    0,0,0,0,0,0,0,0,  # 00 - 07
+    0,0,1,0,0,2,0,0,  # 08 - 0f
+    0,0,0,0,0,0,0,0,  # 10 - 17
+    0,0,0,3,0,0,0,0,  # 18 - 1f
+    0,0,0,0,0,0,0,0,  # 20 - 27
+    0,3,3,3,3,3,0,0,  # 28 - 2f
+    0,0,0,0,0,0,0,0,  # 30 - 37
+    0,0,0,0,0,0,0,0,  # 38 - 3f
+    0,0,0,0,0,0,0,0,  # 40 - 47
+    0,0,0,0,0,0,0,0,  # 48 - 4f
+    0,0,0,0,0,0,0,0,  # 50 - 57
+    0,0,0,0,0,0,0,0,  # 58 - 5f
+    0,0,0,0,0,0,0,0,  # 60 - 67
+    0,0,0,0,0,0,0,0,  # 68 - 6f
+    0,0,0,0,0,0,0,0,  # 70 - 77
+    0,0,0,0,0,0,0,0,  # 78 - 7f
+    0,0,0,0,0,0,0,0,  # 80 - 87
+    0,0,0,0,0,0,0,0,  # 88 - 8f
+    0,0,0,0,0,0,0,0,  # 90 - 97
+    0,0,0,0,0,0,0,0,  # 98 - 9f
+    0,0,0,0,0,0,0,0,  # a0 - a7
+    0,0,0,0,0,0,0,0,  # a8 - af
+    0,0,0,0,0,0,0,0,  # b0 - b7
+    0,0,0,0,0,0,0,0,  # b8 - bf
+    0,0,0,0,0,0,0,0,  # c0 - c7
+    0,0,0,0,0,0,0,0,  # c8 - cf
+    0,0,0,0,0,0,0,0,  # d0 - d7
+    0,0,0,0,0,0,0,0,  # d8 - df
+    0,0,0,0,0,0,0,0,  # e0 - e7
+    0,0,0,0,0,0,0,0,  # e8 - ef
+    0,0,0,0,0,0,0,0,  # f0 - f7
+    0,0,0,0,0,0,4,5   # f8 - ff
+)
+
+UCS2BE_ST  = (
+          5,     7,     7,MachineState.ERROR,     4,     3,MachineState.ERROR,MachineState.ERROR,#00-07
+     MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,#08-0f
+     MachineState.ITS_ME,MachineState.ITS_ME,     6,     6,     6,     6,MachineState.ERROR,MachineState.ERROR,#10-17
+          6,     6,     6,     6,     6,MachineState.ITS_ME,     6,     6,#18-1f
+          6,     6,     6,     6,     5,     7,     7,MachineState.ERROR,#20-27
+          5,     8,     6,     6,MachineState.ERROR,     6,     6,     6,#28-2f
+          6,     6,     6,     6,MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START #30-37
+)
+
+UCS2BE_CHAR_LEN_TABLE = (2, 2, 2, 0, 2, 2)
+
+UCS2BE_SM_MODEL = {'class_table': UCS2BE_CLS,
+                   'class_factor': 6,
+                   'state_table': UCS2BE_ST,
+                   'char_len_table': UCS2BE_CHAR_LEN_TABLE,
+                   'name': 'UTF-16BE'}
+
+# UCS2-LE
+
+UCS2LE_CLS = (
+    0,0,0,0,0,0,0,0,  # 00 - 07
+    0,0,1,0,0,2,0,0,  # 08 - 0f
+    0,0,0,0,0,0,0,0,  # 10 - 17
+    0,0,0,3,0,0,0,0,  # 18 - 1f
+    0,0,0,0,0,0,0,0,  # 20 - 27
+    0,3,3,3,3,3,0,0,  # 28 - 2f
+    0,0,0,0,0,0,0,0,  # 30 - 37
+    0,0,0,0,0,0,0,0,  # 38 - 3f
+    0,0,0,0,0,0,0,0,  # 40 - 47
+    0,0,0,0,0,0,0,0,  # 48 - 4f
+    0,0,0,0,0,0,0,0,  # 50 - 57
+    0,0,0,0,0,0,0,0,  # 58 - 5f
+    0,0,0,0,0,0,0,0,  # 60 - 67
+    0,0,0,0,0,0,0,0,  # 68 - 6f
+    0,0,0,0,0,0,0,0,  # 70 - 77
+    0,0,0,0,0,0,0,0,  # 78 - 7f
+    0,0,0,0,0,0,0,0,  # 80 - 87
+    0,0,0,0,0,0,0,0,  # 88 - 8f
+    0,0,0,0,0,0,0,0,  # 90 - 97
+    0,0,0,0,0,0,0,0,  # 98 - 9f
+    0,0,0,0,0,0,0,0,  # a0 - a7
+    0,0,0,0,0,0,0,0,  # a8 - af
+    0,0,0,0,0,0,0,0,  # b0 - b7
+    0,0,0,0,0,0,0,0,  # b8 - bf
+    0,0,0,0,0,0,0,0,  # c0 - c7
+    0,0,0,0,0,0,0,0,  # c8 - cf
+    0,0,0,0,0,0,0,0,  # d0 - d7
+    0,0,0,0,0,0,0,0,  # d8 - df
+    0,0,0,0,0,0,0,0,  # e0 - e7
+    0,0,0,0,0,0,0,0,  # e8 - ef
+    0,0,0,0,0,0,0,0,  # f0 - f7
+    0,0,0,0,0,0,4,5   # f8 - ff
+)
+
+UCS2LE_ST = (
+          6,     6,     7,     6,     4,     3,MachineState.ERROR,MachineState.ERROR,#00-07
+     MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,#08-0f
+     MachineState.ITS_ME,MachineState.ITS_ME,     5,     5,     5,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,#10-17
+          5,     5,     5,MachineState.ERROR,     5,MachineState.ERROR,     6,     6,#18-1f
+          7,     6,     8,     8,     5,     5,     5,MachineState.ERROR,#20-27
+          5,     5,     5,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     5,     5,#28-2f
+          5,     5,     5,MachineState.ERROR,     5,MachineState.ERROR,MachineState.START,MachineState.START #30-37
+)
+
+UCS2LE_CHAR_LEN_TABLE = (2, 2, 2, 2, 2, 2)
+
+UCS2LE_SM_MODEL = {'class_table': UCS2LE_CLS,
+                 'class_factor': 6,
+                 'state_table': UCS2LE_ST,
+                 'char_len_table': UCS2LE_CHAR_LEN_TABLE,
+                 'name': 'UTF-16LE'}
+
+# UTF-8
+
+UTF8_CLS = (
+    1,1,1,1,1,1,1,1,  # 00 - 07  #allow 0x00 as a legal value
+    1,1,1,1,1,1,0,0,  # 08 - 0f
+    1,1,1,1,1,1,1,1,  # 10 - 17
+    1,1,1,0,1,1,1,1,  # 18 - 1f
+    1,1,1,1,1,1,1,1,  # 20 - 27
+    1,1,1,1,1,1,1,1,  # 28 - 2f
+    1,1,1,1,1,1,1,1,  # 30 - 37
+    1,1,1,1,1,1,1,1,  # 38 - 3f
+    1,1,1,1,1,1,1,1,  # 40 - 47
+    1,1,1,1,1,1,1,1,  # 48 - 4f
+    1,1,1,1,1,1,1,1,  # 50 - 57
+    1,1,1,1,1,1,1,1,  # 58 - 5f
+    1,1,1,1,1,1,1,1,  # 60 - 67
+    1,1,1,1,1,1,1,1,  # 68 - 6f
+    1,1,1,1,1,1,1,1,  # 70 - 77
+    1,1,1,1,1,1,1,1,  # 78 - 7f
+    2,2,2,2,3,3,3,3,  # 80 - 87
+    4,4,4,4,4,4,4,4,  # 88 - 8f
+    4,4,4,4,4,4,4,4,  # 90 - 97
+    4,4,4,4,4,4,4,4,  # 98 - 9f
+    5,5,5,5,5,5,5,5,  # a0 - a7
+    5,5,5,5,5,5,5,5,  # a8 - af
+    5,5,5,5,5,5,5,5,  # b0 - b7
+    5,5,5,5,5,5,5,5,  # b8 - bf
+    0,0,6,6,6,6,6,6,  # c0 - c7
+    6,6,6,6,6,6,6,6,  # c8 - cf
+    6,6,6,6,6,6,6,6,  # d0 - d7
+    6,6,6,6,6,6,6,6,  # d8 - df
+    7,8,8,8,8,8,8,8,  # e0 - e7
+    8,8,8,8,8,9,8,8,  # e8 - ef
+    10,11,11,11,11,11,11,11,  # f0 - f7
+    12,13,13,13,14,15,0,0    # f8 - ff
+)
+
+UTF8_ST = (
+    MachineState.ERROR,MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     12,   10,#00-07
+         9,     11,     8,     7,     6,     5,     4,    3,#08-0f
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#10-17
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#18-1f
+    MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,#20-27
+    MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,#28-2f
+    MachineState.ERROR,MachineState.ERROR,     5,     5,     5,     5,MachineState.ERROR,MachineState.ERROR,#30-37
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#38-3f
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     5,     5,     5,MachineState.ERROR,MachineState.ERROR,#40-47
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#48-4f
+    MachineState.ERROR,MachineState.ERROR,     7,     7,     7,     7,MachineState.ERROR,MachineState.ERROR,#50-57
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#58-5f
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     7,     7,MachineState.ERROR,MachineState.ERROR,#60-67
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#68-6f
+    MachineState.ERROR,MachineState.ERROR,     9,     9,     9,     9,MachineState.ERROR,MachineState.ERROR,#70-77
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#78-7f
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     9,MachineState.ERROR,MachineState.ERROR,#80-87
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#88-8f
+    MachineState.ERROR,MachineState.ERROR,    12,    12,    12,    12,MachineState.ERROR,MachineState.ERROR,#90-97
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#98-9f
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,    12,MachineState.ERROR,MachineState.ERROR,#a0-a7
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#a8-af
+    MachineState.ERROR,MachineState.ERROR,    12,    12,    12,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#b0-b7
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,#b8-bf
+    MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.ERROR,MachineState.ERROR,#c0-c7
+    MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR #c8-cf
+)
+
+UTF8_CHAR_LEN_TABLE = (0, 1, 0, 0, 0, 0, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6)
+
+UTF8_SM_MODEL = {'class_table': UTF8_CLS,
+                 'class_factor': 16,
+                 'state_table': UTF8_ST,
+                 'char_len_table': UTF8_CHAR_LEN_TABLE,
+                 'name': 'UTF-8'}
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/sbcharsetprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/sbcharsetprober.py
new file mode 100644
index 0000000..0adb51d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/sbcharsetprober.py
@@ -0,0 +1,132 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Universal charset detector code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 2001
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#   Shy Shalom - original C code
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .charsetprober import CharSetProber
+from .enums import CharacterCategory, ProbingState, SequenceLikelihood
+
+
+class SingleByteCharSetProber(CharSetProber):
+    SAMPLE_SIZE = 64
+    SB_ENOUGH_REL_THRESHOLD = 1024  #  0.25 * SAMPLE_SIZE^2
+    POSITIVE_SHORTCUT_THRESHOLD = 0.95
+    NEGATIVE_SHORTCUT_THRESHOLD = 0.05
+
+    def __init__(self, model, reversed=False, name_prober=None):
+        super(SingleByteCharSetProber, self).__init__()
+        self._model = model
+        # TRUE if we need to reverse every pair in the model lookup
+        self._reversed = reversed
+        # Optional auxiliary prober for name decision
+        self._name_prober = name_prober
+        self._last_order = None
+        self._seq_counters = None
+        self._total_seqs = None
+        self._total_char = None
+        self._freq_char = None
+        self.reset()
+
+    def reset(self):
+        super(SingleByteCharSetProber, self).reset()
+        # char order of last character
+        self._last_order = 255
+        self._seq_counters = [0] * SequenceLikelihood.get_num_categories()
+        self._total_seqs = 0
+        self._total_char = 0
+        # characters that fall in our sampling range
+        self._freq_char = 0
+
+    @property
+    def charset_name(self):
+        if self._name_prober:
+            return self._name_prober.charset_name
+        else:
+            return self._model['charset_name']
+
+    @property
+    def language(self):
+        if self._name_prober:
+            return self._name_prober.language
+        else:
+            return self._model.get('language')
+
+    def feed(self, byte_str):
+        if not self._model['keep_english_letter']:
+            byte_str = self.filter_international_words(byte_str)
+        if not byte_str:
+            return self.state
+        char_to_order_map = self._model['char_to_order_map']
+        for i, c in enumerate(byte_str):
+            # XXX: Order is in range 1-64, so one would think we want 0-63 here,
+            #      but that leads to 27 more test failures than before.
+            order = char_to_order_map[c]
+            # XXX: This was SYMBOL_CAT_ORDER before, with a value of 250, but
+            #      CharacterCategory.SYMBOL is actually 253, so we use CONTROL
+            #      to make it closer to the original intent. The only difference
+            #      is whether or not we count digits and control characters for
+            #      _total_char purposes.
+            if order < CharacterCategory.CONTROL:
+                self._total_char += 1
+            if order < self.SAMPLE_SIZE:
+                self._freq_char += 1
+                if self._last_order < self.SAMPLE_SIZE:
+                    self._total_seqs += 1
+                    if not self._reversed:
+                        i = (self._last_order * self.SAMPLE_SIZE) + order
+                        model = self._model['precedence_matrix'][i]
+                    else:  # reverse the order of the letters in the lookup
+                        i = (order * self.SAMPLE_SIZE) + self._last_order
+                        model = self._model['precedence_matrix'][i]
+                    self._seq_counters[model] += 1
+            self._last_order = order
+
+        charset_name = self._model['charset_name']
+        if self.state == ProbingState.DETECTING:
+            if self._total_seqs > self.SB_ENOUGH_REL_THRESHOLD:
+                confidence = self.get_confidence()
+                if confidence > self.POSITIVE_SHORTCUT_THRESHOLD:
+                    self.logger.debug('%s confidence = %s, we have a winner',
+                                      charset_name, confidence)
+                    self._state = ProbingState.FOUND_IT
+                elif confidence < self.NEGATIVE_SHORTCUT_THRESHOLD:
+                    self.logger.debug('%s confidence = %s, below negative '
+                                      'shortcut threshhold %s', charset_name,
+                                      confidence,
+                                      self.NEGATIVE_SHORTCUT_THRESHOLD)
+                    self._state = ProbingState.NOT_ME
+
+        return self.state
+
+    def get_confidence(self):
+        r = 0.01
+        if self._total_seqs > 0:
+            r = ((1.0 * self._seq_counters[SequenceLikelihood.POSITIVE]) /
+                 self._total_seqs / self._model['typical_positive_ratio'])
+            r = r * self._freq_char / self._total_char
+            if r >= 1.0:
+                r = 0.99
+        return r
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/sbcsgroupprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/sbcsgroupprober.py
new file mode 100644
index 0000000..98e95dc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/sbcsgroupprober.py
@@ -0,0 +1,73 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Universal charset detector code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 2001
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#   Shy Shalom - original C code
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .charsetgroupprober import CharSetGroupProber
+from .sbcharsetprober import SingleByteCharSetProber
+from .langcyrillicmodel import (Win1251CyrillicModel, Koi8rModel,
+                                Latin5CyrillicModel, MacCyrillicModel,
+                                Ibm866Model, Ibm855Model)
+from .langgreekmodel import Latin7GreekModel, Win1253GreekModel
+from .langbulgarianmodel import Latin5BulgarianModel, Win1251BulgarianModel
+# from .langhungarianmodel import Latin2HungarianModel, Win1250HungarianModel
+from .langthaimodel import TIS620ThaiModel
+from .langhebrewmodel import Win1255HebrewModel
+from .hebrewprober import HebrewProber
+from .langturkishmodel import Latin5TurkishModel
+
+
+class SBCSGroupProber(CharSetGroupProber):
+    def __init__(self):
+        super(SBCSGroupProber, self).__init__()
+        self.probers = [
+            SingleByteCharSetProber(Win1251CyrillicModel),
+            SingleByteCharSetProber(Koi8rModel),
+            SingleByteCharSetProber(Latin5CyrillicModel),
+            SingleByteCharSetProber(MacCyrillicModel),
+            SingleByteCharSetProber(Ibm866Model),
+            SingleByteCharSetProber(Ibm855Model),
+            SingleByteCharSetProber(Latin7GreekModel),
+            SingleByteCharSetProber(Win1253GreekModel),
+            SingleByteCharSetProber(Latin5BulgarianModel),
+            SingleByteCharSetProber(Win1251BulgarianModel),
+            # TODO: Restore Hungarian encodings (iso-8859-2 and windows-1250)
+            #       after we retrain model.
+            # SingleByteCharSetProber(Latin2HungarianModel),
+            # SingleByteCharSetProber(Win1250HungarianModel),
+            SingleByteCharSetProber(TIS620ThaiModel),
+            SingleByteCharSetProber(Latin5TurkishModel),
+        ]
+        hebrew_prober = HebrewProber()
+        logical_hebrew_prober = SingleByteCharSetProber(Win1255HebrewModel,
+                                                        False, hebrew_prober)
+        visual_hebrew_prober = SingleByteCharSetProber(Win1255HebrewModel, True,
+                                                       hebrew_prober)
+        hebrew_prober.set_model_probers(logical_hebrew_prober, visual_hebrew_prober)
+        self.probers.extend([hebrew_prober, logical_hebrew_prober,
+                             visual_hebrew_prober])
+
+        self.reset()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/sjisprober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/sjisprober.py
new file mode 100644
index 0000000..9e29623
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/sjisprober.py
@@ -0,0 +1,92 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .mbcharsetprober import MultiByteCharSetProber
+from .codingstatemachine import CodingStateMachine
+from .chardistribution import SJISDistributionAnalysis
+from .jpcntx import SJISContextAnalysis
+from .mbcssm import SJIS_SM_MODEL
+from .enums import ProbingState, MachineState
+
+
+class SJISProber(MultiByteCharSetProber):
+    def __init__(self):
+        super(SJISProber, self).__init__()
+        self.coding_sm = CodingStateMachine(SJIS_SM_MODEL)
+        self.distribution_analyzer = SJISDistributionAnalysis()
+        self.context_analyzer = SJISContextAnalysis()
+        self.reset()
+
+    def reset(self):
+        super(SJISProber, self).reset()
+        self.context_analyzer.reset()
+
+    @property
+    def charset_name(self):
+        return self.context_analyzer.charset_name
+
+    @property
+    def language(self):
+        return "Japanese"
+
+    def feed(self, byte_str):
+        for i in range(len(byte_str)):
+            coding_state = self.coding_sm.next_state(byte_str[i])
+            if coding_state == MachineState.ERROR:
+                self.logger.debug('%s %s prober hit error at byte %s',
+                                  self.charset_name, self.language, i)
+                self._state = ProbingState.NOT_ME
+                break
+            elif coding_state == MachineState.ITS_ME:
+                self._state = ProbingState.FOUND_IT
+                break
+            elif coding_state == MachineState.START:
+                char_len = self.coding_sm.get_current_charlen()
+                if i == 0:
+                    self._last_char[1] = byte_str[0]
+                    self.context_analyzer.feed(self._last_char[2 - char_len:],
+                                               char_len)
+                    self.distribution_analyzer.feed(self._last_char, char_len)
+                else:
+                    self.context_analyzer.feed(byte_str[i + 1 - char_len:i + 3
+                                                        - char_len], char_len)
+                    self.distribution_analyzer.feed(byte_str[i - 1:i + 1],
+                                                    char_len)
+
+        self._last_char[0] = byte_str[-1]
+
+        if self.state == ProbingState.DETECTING:
+            if (self.context_analyzer.got_enough_data() and
+               (self.get_confidence() > self.SHORTCUT_THRESHOLD)):
+                self._state = ProbingState.FOUND_IT
+
+        return self.state
+
+    def get_confidence(self):
+        context_conf = self.context_analyzer.get_confidence()
+        distrib_conf = self.distribution_analyzer.get_confidence()
+        return max(context_conf, distrib_conf)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/universaldetector.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/universaldetector.py
new file mode 100644
index 0000000..7b4e92d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/universaldetector.py
@@ -0,0 +1,286 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Universal charset detector code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 2001
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#   Shy Shalom - original C code
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+"""
+Module containing the UniversalDetector detector class, which is the primary
+class a user of ``chardet`` should use.
+
+:author: Mark Pilgrim (initial port to Python)
+:author: Shy Shalom (original C code)
+:author: Dan Blanchard (major refactoring for 3.0)
+:author: Ian Cordasco
+"""
+
+
+import codecs
+import logging
+import re
+
+from .charsetgroupprober import CharSetGroupProber
+from .enums import InputState, LanguageFilter, ProbingState
+from .escprober import EscCharSetProber
+from .latin1prober import Latin1Prober
+from .mbcsgroupprober import MBCSGroupProber
+from .sbcsgroupprober import SBCSGroupProber
+
+
+class UniversalDetector(object):
+    """
+    The ``UniversalDetector`` class underlies the ``chardet.detect`` function
+    and coordinates all of the different charset probers.
+
+    To get a ``dict`` containing an encoding and its confidence, you can simply
+    run:
+
+    .. code::
+
+            u = UniversalDetector()
+            u.feed(some_bytes)
+            u.close()
+            detected = u.result
+
+    """
+
+    MINIMUM_THRESHOLD = 0.20
+    HIGH_BYTE_DETECTOR = re.compile(b'[\x80-\xFF]')
+    ESC_DETECTOR = re.compile(b'(\033|~{)')
+    WIN_BYTE_DETECTOR = re.compile(b'[\x80-\x9F]')
+    ISO_WIN_MAP = {'iso-8859-1': 'Windows-1252',
+                   'iso-8859-2': 'Windows-1250',
+                   'iso-8859-5': 'Windows-1251',
+                   'iso-8859-6': 'Windows-1256',
+                   'iso-8859-7': 'Windows-1253',
+                   'iso-8859-8': 'Windows-1255',
+                   'iso-8859-9': 'Windows-1254',
+                   'iso-8859-13': 'Windows-1257'}
+
+    def __init__(self, lang_filter=LanguageFilter.ALL):
+        self._esc_charset_prober = None
+        self._charset_probers = []
+        self.result = None
+        self.done = None
+        self._got_data = None
+        self._input_state = None
+        self._last_char = None
+        self.lang_filter = lang_filter
+        self.logger = logging.getLogger(__name__)
+        self._has_win_bytes = None
+        self.reset()
+
+    def reset(self):
+        """
+        Reset the UniversalDetector and all of its probers back to their
+        initial states.  This is called by ``__init__``, so you only need to
+        call this directly in between analyses of different documents.
+        """
+        self.result = {'encoding': None, 'confidence': 0.0, 'language': None}
+        self.done = False
+        self._got_data = False
+        self._has_win_bytes = False
+        self._input_state = InputState.PURE_ASCII
+        self._last_char = b''
+        if self._esc_charset_prober:
+            self._esc_charset_prober.reset()
+        for prober in self._charset_probers:
+            prober.reset()
+
+    def feed(self, byte_str):
+        """
+        Takes a chunk of a document and feeds it through all of the relevant
+        charset probers.
+
+        After calling ``feed``, you can check the value of the ``done``
+        attribute to see if you need to continue feeding the
+        ``UniversalDetector`` more data, or if it has made a prediction
+        (in the ``result`` attribute).
+
+        .. note::
+           You should always call ``close`` when you're done feeding in your
+           document if ``done`` is not already ``True``.
+        """
+        if self.done:
+            return
+
+        if not len(byte_str):
+            return
+
+        if not isinstance(byte_str, bytearray):
+            byte_str = bytearray(byte_str)
+
+        # First check for known BOMs, since these are guaranteed to be correct
+        if not self._got_data:
+            # If the data starts with BOM, we know it is UTF
+            if byte_str.startswith(codecs.BOM_UTF8):
+                # EF BB BF  UTF-8 with BOM
+                self.result = {'encoding': "UTF-8-SIG",
+                               'confidence': 1.0,
+                               'language': ''}
+            elif byte_str.startswith((codecs.BOM_UTF32_LE,
+                                      codecs.BOM_UTF32_BE)):
+                # FF FE 00 00  UTF-32, little-endian BOM
+                # 00 00 FE FF  UTF-32, big-endian BOM
+                self.result = {'encoding': "UTF-32",
+                               'confidence': 1.0,
+                               'language': ''}
+            elif byte_str.startswith(b'\xFE\xFF\x00\x00'):
+                # FE FF 00 00  UCS-4, unusual octet order BOM (3412)
+                self.result = {'encoding': "X-ISO-10646-UCS-4-3412",
+                               'confidence': 1.0,
+                               'language': ''}
+            elif byte_str.startswith(b'\x00\x00\xFF\xFE'):
+                # 00 00 FF FE  UCS-4, unusual octet order BOM (2143)
+                self.result = {'encoding': "X-ISO-10646-UCS-4-2143",
+                               'confidence': 1.0,
+                               'language': ''}
+            elif byte_str.startswith((codecs.BOM_LE, codecs.BOM_BE)):
+                # FF FE  UTF-16, little endian BOM
+                # FE FF  UTF-16, big endian BOM
+                self.result = {'encoding': "UTF-16",
+                               'confidence': 1.0,
+                               'language': ''}
+
+            self._got_data = True
+            if self.result['encoding'] is not None:
+                self.done = True
+                return
+
+        # If none of those matched and we've only see ASCII so far, check
+        # for high bytes and escape sequences
+        if self._input_state == InputState.PURE_ASCII:
+            if self.HIGH_BYTE_DETECTOR.search(byte_str):
+                self._input_state = InputState.HIGH_BYTE
+            elif self._input_state == InputState.PURE_ASCII and \
+                    self.ESC_DETECTOR.search(self._last_char + byte_str):
+                self._input_state = InputState.ESC_ASCII
+
+        self._last_char = byte_str[-1:]
+
+        # If we've seen escape sequences, use the EscCharSetProber, which
+        # uses a simple state machine to check for known escape sequences in
+        # HZ and ISO-2022 encodings, since those are the only encodings that
+        # use such sequences.
+        if self._input_state == InputState.ESC_ASCII:
+            if not self._esc_charset_prober:
+                self._esc_charset_prober = EscCharSetProber(self.lang_filter)
+            if self._esc_charset_prober.feed(byte_str) == ProbingState.FOUND_IT:
+                self.result = {'encoding':
+                               self._esc_charset_prober.charset_name,
+                               'confidence':
+                               self._esc_charset_prober.get_confidence(),
+                               'language':
+                               self._esc_charset_prober.language}
+                self.done = True
+        # If we've seen high bytes (i.e., those with values greater than 127),
+        # we need to do more complicated checks using all our multi-byte and
+        # single-byte probers that are left.  The single-byte probers
+        # use character bigram distributions to determine the encoding, whereas
+        # the multi-byte probers use a combination of character unigram and
+        # bigram distributions.
+        elif self._input_state == InputState.HIGH_BYTE:
+            if not self._charset_probers:
+                self._charset_probers = [MBCSGroupProber(self.lang_filter)]
+                # If we're checking non-CJK encodings, use single-byte prober
+                if self.lang_filter & LanguageFilter.NON_CJK:
+                    self._charset_probers.append(SBCSGroupProber())
+                self._charset_probers.append(Latin1Prober())
+            for prober in self._charset_probers:
+                if prober.feed(byte_str) == ProbingState.FOUND_IT:
+                    self.result = {'encoding': prober.charset_name,
+                                   'confidence': prober.get_confidence(),
+                                   'language': prober.language}
+                    self.done = True
+                    break
+            if self.WIN_BYTE_DETECTOR.search(byte_str):
+                self._has_win_bytes = True
+
+    def close(self):
+        """
+        Stop analyzing the current document and come up with a final
+        prediction.
+
+        :returns:  The ``result`` attribute, a ``dict`` with the keys
+                   `encoding`, `confidence`, and `language`.
+        """
+        # Don't bother with checks if we're already done
+        if self.done:
+            return self.result
+        self.done = True
+
+        if not self._got_data:
+            self.logger.debug('no data received!')
+
+        # Default to ASCII if it is all we've seen so far
+        elif self._input_state == InputState.PURE_ASCII:
+            self.result = {'encoding': 'ascii',
+                           'confidence': 1.0,
+                           'language': ''}
+
+        # If we have seen non-ASCII, return the best that met MINIMUM_THRESHOLD
+        elif self._input_state == InputState.HIGH_BYTE:
+            prober_confidence = None
+            max_prober_confidence = 0.0
+            max_prober = None
+            for prober in self._charset_probers:
+                if not prober:
+                    continue
+                prober_confidence = prober.get_confidence()
+                if prober_confidence > max_prober_confidence:
+                    max_prober_confidence = prober_confidence
+                    max_prober = prober
+            if max_prober and (max_prober_confidence > self.MINIMUM_THRESHOLD):
+                charset_name = max_prober.charset_name
+                lower_charset_name = max_prober.charset_name.lower()
+                confidence = max_prober.get_confidence()
+                # Use Windows encoding name instead of ISO-8859 if we saw any
+                # extra Windows-specific bytes
+                if lower_charset_name.startswith('iso-8859'):
+                    if self._has_win_bytes:
+                        charset_name = self.ISO_WIN_MAP.get(lower_charset_name,
+                                                            charset_name)
+                self.result = {'encoding': charset_name,
+                               'confidence': confidence,
+                               'language': max_prober.language}
+
+        # Log all prober confidences if none met MINIMUM_THRESHOLD
+        if self.logger.getEffectiveLevel() == logging.DEBUG:
+            if self.result['encoding'] is None:
+                self.logger.debug('no probers hit minimum threshold')
+                for group_prober in self._charset_probers:
+                    if not group_prober:
+                        continue
+                    if isinstance(group_prober, CharSetGroupProber):
+                        for prober in group_prober.probers:
+                            self.logger.debug('%s %s confidence = %s',
+                                              prober.charset_name,
+                                              prober.language,
+                                              prober.get_confidence())
+                    else:
+                        self.logger.debug('%s %s confidence = %s',
+                                          prober.charset_name,
+                                          prober.language,
+                                          prober.get_confidence())
+        return self.result
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/utf8prober.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/utf8prober.py
new file mode 100644
index 0000000..6c3196c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/utf8prober.py
@@ -0,0 +1,82 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# 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 St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .charsetprober import CharSetProber
+from .enums import ProbingState, MachineState
+from .codingstatemachine import CodingStateMachine
+from .mbcssm import UTF8_SM_MODEL
+
+
+
+class UTF8Prober(CharSetProber):
+    ONE_CHAR_PROB = 0.5
+
+    def __init__(self):
+        super(UTF8Prober, self).__init__()
+        self.coding_sm = CodingStateMachine(UTF8_SM_MODEL)
+        self._num_mb_chars = None
+        self.reset()
+
+    def reset(self):
+        super(UTF8Prober, self).reset()
+        self.coding_sm.reset()
+        self._num_mb_chars = 0
+
+    @property
+    def charset_name(self):
+        return "utf-8"
+
+    @property
+    def language(self):
+        return ""
+
+    def feed(self, byte_str):
+        for c in byte_str:
+            coding_state = self.coding_sm.next_state(c)
+            if coding_state == MachineState.ERROR:
+                self._state = ProbingState.NOT_ME
+                break
+            elif coding_state == MachineState.ITS_ME:
+                self._state = ProbingState.FOUND_IT
+                break
+            elif coding_state == MachineState.START:
+                if self.coding_sm.get_current_charlen() >= 2:
+                    self._num_mb_chars += 1
+
+        if self.state == ProbingState.DETECTING:
+            if self.get_confidence() > self.SHORTCUT_THRESHOLD:
+                self._state = ProbingState.FOUND_IT
+
+        return self.state
+
+    def get_confidence(self):
+        unlike = 0.99
+        if self._num_mb_chars < 6:
+            unlike *= self.ONE_CHAR_PROB ** self._num_mb_chars
+            return 1.0 - unlike
+        else:
+            return unlike
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/version.py b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/version.py
new file mode 100644
index 0000000..bb2a34a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/chardet/version.py
@@ -0,0 +1,9 @@
+"""
+This module exists only to simplify retrieving the version number of chardet
+from within setup.py and from chardet subpackages.
+
+:author: Dan Blanchard (dan.blanchard@gmail.com)
+"""
+
+__version__ = "3.0.4"
+VERSION = __version__.split('.')
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/__init__.py
new file mode 100644
index 0000000..34c263c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/__init__.py
@@ -0,0 +1,6 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+from .initialise import init, deinit, reinit, colorama_text
+from .ansi import Fore, Back, Style, Cursor
+from .ansitowin32 import AnsiToWin32
+
+__version__ = '0.4.3'
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/ansi.py b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/ansi.py
new file mode 100644
index 0000000..7877658
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/ansi.py
@@ -0,0 +1,102 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+'''
+This module generates ANSI character codes to printing colors to terminals.
+See: http://en.wikipedia.org/wiki/ANSI_escape_code
+'''
+
+CSI = '\033['
+OSC = '\033]'
+BEL = '\007'
+
+
+def code_to_chars(code):
+    return CSI + str(code) + 'm'
+
+def set_title(title):
+    return OSC + '2;' + title + BEL
+
+def clear_screen(mode=2):
+    return CSI + str(mode) + 'J'
+
+def clear_line(mode=2):
+    return CSI + str(mode) + 'K'
+
+
+class AnsiCodes(object):
+    def __init__(self):
+        # the subclasses declare class attributes which are numbers.
+        # Upon instantiation we define instance attributes, which are the same
+        # as the class attributes but wrapped with the ANSI escape sequence
+        for name in dir(self):
+            if not name.startswith('_'):
+                value = getattr(self, name)
+                setattr(self, name, code_to_chars(value))
+
+
+class AnsiCursor(object):
+    def UP(self, n=1):
+        return CSI + str(n) + 'A'
+    def DOWN(self, n=1):
+        return CSI + str(n) + 'B'
+    def FORWARD(self, n=1):
+        return CSI + str(n) + 'C'
+    def BACK(self, n=1):
+        return CSI + str(n) + 'D'
+    def POS(self, x=1, y=1):
+        return CSI + str(y) + ';' + str(x) + 'H'
+
+
+class AnsiFore(AnsiCodes):
+    BLACK           = 30
+    RED             = 31
+    GREEN           = 32
+    YELLOW          = 33
+    BLUE            = 34
+    MAGENTA         = 35
+    CYAN            = 36
+    WHITE           = 37
+    RESET           = 39
+
+    # These are fairly well supported, but not part of the standard.
+    LIGHTBLACK_EX   = 90
+    LIGHTRED_EX     = 91
+    LIGHTGREEN_EX   = 92
+    LIGHTYELLOW_EX  = 93
+    LIGHTBLUE_EX    = 94
+    LIGHTMAGENTA_EX = 95
+    LIGHTCYAN_EX    = 96
+    LIGHTWHITE_EX   = 97
+
+
+class AnsiBack(AnsiCodes):
+    BLACK           = 40
+    RED             = 41
+    GREEN           = 42
+    YELLOW          = 43
+    BLUE            = 44
+    MAGENTA         = 45
+    CYAN            = 46
+    WHITE           = 47
+    RESET           = 49
+
+    # These are fairly well supported, but not part of the standard.
+    LIGHTBLACK_EX   = 100
+    LIGHTRED_EX     = 101
+    LIGHTGREEN_EX   = 102
+    LIGHTYELLOW_EX  = 103
+    LIGHTBLUE_EX    = 104
+    LIGHTMAGENTA_EX = 105
+    LIGHTCYAN_EX    = 106
+    LIGHTWHITE_EX   = 107
+
+
+class AnsiStyle(AnsiCodes):
+    BRIGHT    = 1
+    DIM       = 2
+    NORMAL    = 22
+    RESET_ALL = 0
+
+Fore   = AnsiFore()
+Back   = AnsiBack()
+Style  = AnsiStyle()
+Cursor = AnsiCursor()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/ansitowin32.py b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/ansitowin32.py
new file mode 100644
index 0000000..359c92b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/ansitowin32.py
@@ -0,0 +1,257 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import re
+import sys
+import os
+
+from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style
+from .winterm import WinTerm, WinColor, WinStyle
+from .win32 import windll, winapi_test
+
+
+winterm = None
+if windll is not None:
+    winterm = WinTerm()
+
+
+class StreamWrapper(object):
+    '''
+    Wraps a stream (such as stdout), acting as a transparent proxy for all
+    attribute access apart from method 'write()', which is delegated to our
+    Converter instance.
+    '''
+    def __init__(self, wrapped, converter):
+        # double-underscore everything to prevent clashes with names of
+        # attributes on the wrapped stream object.
+        self.__wrapped = wrapped
+        self.__convertor = converter
+
+    def __getattr__(self, name):
+        return getattr(self.__wrapped, name)
+
+    def __enter__(self, *args, **kwargs):
+        # special method lookup bypasses __getattr__/__getattribute__, see
+        # https://stackoverflow.com/questions/12632894/why-doesnt-getattr-work-with-exit
+        # thus, contextlib magic methods are not proxied via __getattr__
+        return self.__wrapped.__enter__(*args, **kwargs)
+
+    def __exit__(self, *args, **kwargs):
+        return self.__wrapped.__exit__(*args, **kwargs)
+
+    def write(self, text):
+        self.__convertor.write(text)
+
+    def isatty(self):
+        stream = self.__wrapped
+        if 'PYCHARM_HOSTED' in os.environ:
+            if stream is not None and (stream is sys.__stdout__ or stream is sys.__stderr__):
+                return True
+        try:
+            stream_isatty = stream.isatty
+        except AttributeError:
+            return False
+        else:
+            return stream_isatty()
+
+    @property
+    def closed(self):
+        stream = self.__wrapped
+        try:
+            return stream.closed
+        except AttributeError:
+            return True
+
+
+class AnsiToWin32(object):
+    '''
+    Implements a 'write()' method which, on Windows, will strip ANSI character
+    sequences from the text, and if outputting to a tty, will convert them into
+    win32 function calls.
+    '''
+    ANSI_CSI_RE = re.compile('\001?\033\\[((?:\\d|;)*)([a-zA-Z])\002?')   # Control Sequence Introducer
+    ANSI_OSC_RE = re.compile('\001?\033\\]((?:.|;)*?)(\x07)\002?')        # Operating System Command
+
+    def __init__(self, wrapped, convert=None, strip=None, autoreset=False):
+        # The wrapped stream (normally sys.stdout or sys.stderr)
+        self.wrapped = wrapped
+
+        # should we reset colors to defaults after every .write()
+        self.autoreset = autoreset
+
+        # create the proxy wrapping our output stream
+        self.stream = StreamWrapper(wrapped, self)
+
+        on_windows = os.name == 'nt'
+        # We test if the WinAPI works, because even if we are on Windows
+        # we may be using a terminal that doesn't support the WinAPI
+        # (e.g. Cygwin Terminal). In this case it's up to the terminal
+        # to support the ANSI codes.
+        conversion_supported = on_windows and winapi_test()
+
+        # should we strip ANSI sequences from our output?
+        if strip is None:
+            strip = conversion_supported or (not self.stream.closed and not self.stream.isatty())
+        self.strip = strip
+
+        # should we should convert ANSI sequences into win32 calls?
+        if convert is None:
+            convert = conversion_supported and not self.stream.closed and self.stream.isatty()
+        self.convert = convert
+
+        # dict of ansi codes to win32 functions and parameters
+        self.win32_calls = self.get_win32_calls()
+
+        # are we wrapping stderr?
+        self.on_stderr = self.wrapped is sys.stderr
+
+    def should_wrap(self):
+        '''
+        True if this class is actually needed. If false, then the output
+        stream will not be affected, nor will win32 calls be issued, so
+        wrapping stdout is not actually required. This will generally be
+        False on non-Windows platforms, unless optional functionality like
+        autoreset has been requested using kwargs to init()
+        '''
+        return self.convert or self.strip or self.autoreset
+
+    def get_win32_calls(self):
+        if self.convert and winterm:
+            return {
+                AnsiStyle.RESET_ALL: (winterm.reset_all, ),
+                AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT),
+                AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL),
+                AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL),
+                AnsiFore.BLACK: (winterm.fore, WinColor.BLACK),
+                AnsiFore.RED: (winterm.fore, WinColor.RED),
+                AnsiFore.GREEN: (winterm.fore, WinColor.GREEN),
+                AnsiFore.YELLOW: (winterm.fore, WinColor.YELLOW),
+                AnsiFore.BLUE: (winterm.fore, WinColor.BLUE),
+                AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA),
+                AnsiFore.CYAN: (winterm.fore, WinColor.CYAN),
+                AnsiFore.WHITE: (winterm.fore, WinColor.GREY),
+                AnsiFore.RESET: (winterm.fore, ),
+                AnsiFore.LIGHTBLACK_EX: (winterm.fore, WinColor.BLACK, True),
+                AnsiFore.LIGHTRED_EX: (winterm.fore, WinColor.RED, True),
+                AnsiFore.LIGHTGREEN_EX: (winterm.fore, WinColor.GREEN, True),
+                AnsiFore.LIGHTYELLOW_EX: (winterm.fore, WinColor.YELLOW, True),
+                AnsiFore.LIGHTBLUE_EX: (winterm.fore, WinColor.BLUE, True),
+                AnsiFore.LIGHTMAGENTA_EX: (winterm.fore, WinColor.MAGENTA, True),
+                AnsiFore.LIGHTCYAN_EX: (winterm.fore, WinColor.CYAN, True),
+                AnsiFore.LIGHTWHITE_EX: (winterm.fore, WinColor.GREY, True),
+                AnsiBack.BLACK: (winterm.back, WinColor.BLACK),
+                AnsiBack.RED: (winterm.back, WinColor.RED),
+                AnsiBack.GREEN: (winterm.back, WinColor.GREEN),
+                AnsiBack.YELLOW: (winterm.back, WinColor.YELLOW),
+                AnsiBack.BLUE: (winterm.back, WinColor.BLUE),
+                AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA),
+                AnsiBack.CYAN: (winterm.back, WinColor.CYAN),
+                AnsiBack.WHITE: (winterm.back, WinColor.GREY),
+                AnsiBack.RESET: (winterm.back, ),
+                AnsiBack.LIGHTBLACK_EX: (winterm.back, WinColor.BLACK, True),
+                AnsiBack.LIGHTRED_EX: (winterm.back, WinColor.RED, True),
+                AnsiBack.LIGHTGREEN_EX: (winterm.back, WinColor.GREEN, True),
+                AnsiBack.LIGHTYELLOW_EX: (winterm.back, WinColor.YELLOW, True),
+                AnsiBack.LIGHTBLUE_EX: (winterm.back, WinColor.BLUE, True),
+                AnsiBack.LIGHTMAGENTA_EX: (winterm.back, WinColor.MAGENTA, True),
+                AnsiBack.LIGHTCYAN_EX: (winterm.back, WinColor.CYAN, True),
+                AnsiBack.LIGHTWHITE_EX: (winterm.back, WinColor.GREY, True),
+            }
+        return dict()
+
+    def write(self, text):
+        if self.strip or self.convert:
+            self.write_and_convert(text)
+        else:
+            self.wrapped.write(text)
+            self.wrapped.flush()
+        if self.autoreset:
+            self.reset_all()
+
+
+    def reset_all(self):
+        if self.convert:
+            self.call_win32('m', (0,))
+        elif not self.strip and not self.stream.closed:
+            self.wrapped.write(Style.RESET_ALL)
+
+
+    def write_and_convert(self, text):
+        '''
+        Write the given text to our wrapped stream, stripping any ANSI
+        sequences from the text, and optionally converting them into win32
+        calls.
+        '''
+        cursor = 0
+        text = self.convert_osc(text)
+        for match in self.ANSI_CSI_RE.finditer(text):
+            start, end = match.span()
+            self.write_plain_text(text, cursor, start)
+            self.convert_ansi(*match.groups())
+            cursor = end
+        self.write_plain_text(text, cursor, len(text))
+
+
+    def write_plain_text(self, text, start, end):
+        if start < end:
+            self.wrapped.write(text[start:end])
+            self.wrapped.flush()
+
+
+    def convert_ansi(self, paramstring, command):
+        if self.convert:
+            params = self.extract_params(command, paramstring)
+            self.call_win32(command, params)
+
+
+    def extract_params(self, command, paramstring):
+        if command in 'Hf':
+            params = tuple(int(p) if len(p) != 0 else 1 for p in paramstring.split(';'))
+            while len(params) < 2:
+                # defaults:
+                params = params + (1,)
+        else:
+            params = tuple(int(p) for p in paramstring.split(';') if len(p) != 0)
+            if len(params) == 0:
+                # defaults:
+                if command in 'JKm':
+                    params = (0,)
+                elif command in 'ABCD':
+                    params = (1,)
+
+        return params
+
+
+    def call_win32(self, command, params):
+        if command == 'm':
+            for param in params:
+                if param in self.win32_calls:
+                    func_args = self.win32_calls[param]
+                    func = func_args[0]
+                    args = func_args[1:]
+                    kwargs = dict(on_stderr=self.on_stderr)
+                    func(*args, **kwargs)
+        elif command in 'J':
+            winterm.erase_screen(params[0], on_stderr=self.on_stderr)
+        elif command in 'K':
+            winterm.erase_line(params[0], on_stderr=self.on_stderr)
+        elif command in 'Hf':     # cursor position - absolute
+            winterm.set_cursor_position(params, on_stderr=self.on_stderr)
+        elif command in 'ABCD':   # cursor position - relative
+            n = params[0]
+            # A - up, B - down, C - forward, D - back
+            x, y = {'A': (0, -n), 'B': (0, n), 'C': (n, 0), 'D': (-n, 0)}[command]
+            winterm.cursor_adjust(x, y, on_stderr=self.on_stderr)
+
+
+    def convert_osc(self, text):
+        for match in self.ANSI_OSC_RE.finditer(text):
+            start, end = match.span()
+            text = text[:start] + text[end:]
+            paramstring, command = match.groups()
+            if command in '\x07':       # \x07 = BEL
+                params = paramstring.split(";")
+                # 0 - change title and icon (we will only change title)
+                # 1 - change icon (we don't support this)
+                # 2 - change title
+                if params[0] in '02':
+                    winterm.set_title(params[1])
+        return text
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/initialise.py b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/initialise.py
new file mode 100644
index 0000000..430d066
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/initialise.py
@@ -0,0 +1,80 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import atexit
+import contextlib
+import sys
+
+from .ansitowin32 import AnsiToWin32
+
+
+orig_stdout = None
+orig_stderr = None
+
+wrapped_stdout = None
+wrapped_stderr = None
+
+atexit_done = False
+
+
+def reset_all():
+    if AnsiToWin32 is not None:    # Issue #74: objects might become None at exit
+        AnsiToWin32(orig_stdout).reset_all()
+
+
+def init(autoreset=False, convert=None, strip=None, wrap=True):
+
+    if not wrap and any([autoreset, convert, strip]):
+        raise ValueError('wrap=False conflicts with any other arg=True')
+
+    global wrapped_stdout, wrapped_stderr
+    global orig_stdout, orig_stderr
+
+    orig_stdout = sys.stdout
+    orig_stderr = sys.stderr
+
+    if sys.stdout is None:
+        wrapped_stdout = None
+    else:
+        sys.stdout = wrapped_stdout = \
+            wrap_stream(orig_stdout, convert, strip, autoreset, wrap)
+    if sys.stderr is None:
+        wrapped_stderr = None
+    else:
+        sys.stderr = wrapped_stderr = \
+            wrap_stream(orig_stderr, convert, strip, autoreset, wrap)
+
+    global atexit_done
+    if not atexit_done:
+        atexit.register(reset_all)
+        atexit_done = True
+
+
+def deinit():
+    if orig_stdout is not None:
+        sys.stdout = orig_stdout
+    if orig_stderr is not None:
+        sys.stderr = orig_stderr
+
+
+@contextlib.contextmanager
+def colorama_text(*args, **kwargs):
+    init(*args, **kwargs)
+    try:
+        yield
+    finally:
+        deinit()
+
+
+def reinit():
+    if wrapped_stdout is not None:
+        sys.stdout = wrapped_stdout
+    if wrapped_stderr is not None:
+        sys.stderr = wrapped_stderr
+
+
+def wrap_stream(stream, convert, strip, autoreset, wrap):
+    if wrap:
+        wrapper = AnsiToWin32(stream,
+            convert=convert, strip=strip, autoreset=autoreset)
+        if wrapper.should_wrap():
+            stream = wrapper.stream
+    return stream
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/win32.py b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/win32.py
new file mode 100644
index 0000000..c2d8360
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/win32.py
@@ -0,0 +1,152 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+
+# from winbase.h
+STDOUT = -11
+STDERR = -12
+
+try:
+    import ctypes
+    from ctypes import LibraryLoader
+    windll = LibraryLoader(ctypes.WinDLL)
+    from ctypes import wintypes
+except (AttributeError, ImportError):
+    windll = None
+    SetConsoleTextAttribute = lambda *_: None
+    winapi_test = lambda *_: None
+else:
+    from ctypes import byref, Structure, c_char, POINTER
+
+    COORD = wintypes._COORD
+
+    class CONSOLE_SCREEN_BUFFER_INFO(Structure):
+        """struct in wincon.h."""
+        _fields_ = [
+            ("dwSize", COORD),
+            ("dwCursorPosition", COORD),
+            ("wAttributes", wintypes.WORD),
+            ("srWindow", wintypes.SMALL_RECT),
+            ("dwMaximumWindowSize", COORD),
+        ]
+        def __str__(self):
+            return '(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)' % (
+                self.dwSize.Y, self.dwSize.X
+                , self.dwCursorPosition.Y, self.dwCursorPosition.X
+                , self.wAttributes
+                , self.srWindow.Top, self.srWindow.Left, self.srWindow.Bottom, self.srWindow.Right
+                , self.dwMaximumWindowSize.Y, self.dwMaximumWindowSize.X
+            )
+
+    _GetStdHandle = windll.kernel32.GetStdHandle
+    _GetStdHandle.argtypes = [
+        wintypes.DWORD,
+    ]
+    _GetStdHandle.restype = wintypes.HANDLE
+
+    _GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo
+    _GetConsoleScreenBufferInfo.argtypes = [
+        wintypes.HANDLE,
+        POINTER(CONSOLE_SCREEN_BUFFER_INFO),
+    ]
+    _GetConsoleScreenBufferInfo.restype = wintypes.BOOL
+
+    _SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute
+    _SetConsoleTextAttribute.argtypes = [
+        wintypes.HANDLE,
+        wintypes.WORD,
+    ]
+    _SetConsoleTextAttribute.restype = wintypes.BOOL
+
+    _SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition
+    _SetConsoleCursorPosition.argtypes = [
+        wintypes.HANDLE,
+        COORD,
+    ]
+    _SetConsoleCursorPosition.restype = wintypes.BOOL
+
+    _FillConsoleOutputCharacterA = windll.kernel32.FillConsoleOutputCharacterA
+    _FillConsoleOutputCharacterA.argtypes = [
+        wintypes.HANDLE,
+        c_char,
+        wintypes.DWORD,
+        COORD,
+        POINTER(wintypes.DWORD),
+    ]
+    _FillConsoleOutputCharacterA.restype = wintypes.BOOL
+
+    _FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute
+    _FillConsoleOutputAttribute.argtypes = [
+        wintypes.HANDLE,
+        wintypes.WORD,
+        wintypes.DWORD,
+        COORD,
+        POINTER(wintypes.DWORD),
+    ]
+    _FillConsoleOutputAttribute.restype = wintypes.BOOL
+
+    _SetConsoleTitleW = windll.kernel32.SetConsoleTitleW
+    _SetConsoleTitleW.argtypes = [
+        wintypes.LPCWSTR
+    ]
+    _SetConsoleTitleW.restype = wintypes.BOOL
+
+    def _winapi_test(handle):
+        csbi = CONSOLE_SCREEN_BUFFER_INFO()
+        success = _GetConsoleScreenBufferInfo(
+            handle, byref(csbi))
+        return bool(success)
+
+    def winapi_test():
+        return any(_winapi_test(h) for h in
+                   (_GetStdHandle(STDOUT), _GetStdHandle(STDERR)))
+
+    def GetConsoleScreenBufferInfo(stream_id=STDOUT):
+        handle = _GetStdHandle(stream_id)
+        csbi = CONSOLE_SCREEN_BUFFER_INFO()
+        success = _GetConsoleScreenBufferInfo(
+            handle, byref(csbi))
+        return csbi
+
+    def SetConsoleTextAttribute(stream_id, attrs):
+        handle = _GetStdHandle(stream_id)
+        return _SetConsoleTextAttribute(handle, attrs)
+
+    def SetConsoleCursorPosition(stream_id, position, adjust=True):
+        position = COORD(*position)
+        # If the position is out of range, do nothing.
+        if position.Y <= 0 or position.X <= 0:
+            return
+        # Adjust for Windows' SetConsoleCursorPosition:
+        #    1. being 0-based, while ANSI is 1-based.
+        #    2. expecting (x,y), while ANSI uses (y,x).
+        adjusted_position = COORD(position.Y - 1, position.X - 1)
+        if adjust:
+            # Adjust for viewport's scroll position
+            sr = GetConsoleScreenBufferInfo(STDOUT).srWindow
+            adjusted_position.Y += sr.Top
+            adjusted_position.X += sr.Left
+        # Resume normal processing
+        handle = _GetStdHandle(stream_id)
+        return _SetConsoleCursorPosition(handle, adjusted_position)
+
+    def FillConsoleOutputCharacter(stream_id, char, length, start):
+        handle = _GetStdHandle(stream_id)
+        char = c_char(char.encode())
+        length = wintypes.DWORD(length)
+        num_written = wintypes.DWORD(0)
+        # Note that this is hard-coded for ANSI (vs wide) bytes.
+        success = _FillConsoleOutputCharacterA(
+            handle, char, length, start, byref(num_written))
+        return num_written.value
+
+    def FillConsoleOutputAttribute(stream_id, attr, length, start):
+        ''' FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )'''
+        handle = _GetStdHandle(stream_id)
+        attribute = wintypes.WORD(attr)
+        length = wintypes.DWORD(length)
+        num_written = wintypes.DWORD(0)
+        # Note that this is hard-coded for ANSI (vs wide) bytes.
+        return _FillConsoleOutputAttribute(
+            handle, attribute, length, start, byref(num_written))
+
+    def SetConsoleTitle(title):
+        return _SetConsoleTitleW(title)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/winterm.py b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/winterm.py
new file mode 100644
index 0000000..0fdb4ec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/colorama/winterm.py
@@ -0,0 +1,169 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+from . import win32
+
+
+# from wincon.h
+class WinColor(object):
+    BLACK   = 0
+    BLUE    = 1
+    GREEN   = 2
+    CYAN    = 3
+    RED     = 4
+    MAGENTA = 5
+    YELLOW  = 6
+    GREY    = 7
+
+# from wincon.h
+class WinStyle(object):
+    NORMAL              = 0x00 # dim text, dim background
+    BRIGHT              = 0x08 # bright text, dim background
+    BRIGHT_BACKGROUND   = 0x80 # dim text, bright background
+
+class WinTerm(object):
+
+    def __init__(self):
+        self._default = win32.GetConsoleScreenBufferInfo(win32.STDOUT).wAttributes
+        self.set_attrs(self._default)
+        self._default_fore = self._fore
+        self._default_back = self._back
+        self._default_style = self._style
+        # In order to emulate LIGHT_EX in windows, we borrow the BRIGHT style.
+        # So that LIGHT_EX colors and BRIGHT style do not clobber each other,
+        # we track them separately, since LIGHT_EX is overwritten by Fore/Back
+        # and BRIGHT is overwritten by Style codes.
+        self._light = 0
+
+    def get_attrs(self):
+        return self._fore + self._back * 16 + (self._style | self._light)
+
+    def set_attrs(self, value):
+        self._fore = value & 7
+        self._back = (value >> 4) & 7
+        self._style = value & (WinStyle.BRIGHT | WinStyle.BRIGHT_BACKGROUND)
+
+    def reset_all(self, on_stderr=None):
+        self.set_attrs(self._default)
+        self.set_console(attrs=self._default)
+        self._light = 0
+
+    def fore(self, fore=None, light=False, on_stderr=False):
+        if fore is None:
+            fore = self._default_fore
+        self._fore = fore
+        # Emulate LIGHT_EX with BRIGHT Style
+        if light:
+            self._light |= WinStyle.BRIGHT
+        else:
+            self._light &= ~WinStyle.BRIGHT
+        self.set_console(on_stderr=on_stderr)
+
+    def back(self, back=None, light=False, on_stderr=False):
+        if back is None:
+            back = self._default_back
+        self._back = back
+        # Emulate LIGHT_EX with BRIGHT_BACKGROUND Style
+        if light:
+            self._light |= WinStyle.BRIGHT_BACKGROUND
+        else:
+            self._light &= ~WinStyle.BRIGHT_BACKGROUND
+        self.set_console(on_stderr=on_stderr)
+
+    def style(self, style=None, on_stderr=False):
+        if style is None:
+            style = self._default_style
+        self._style = style
+        self.set_console(on_stderr=on_stderr)
+
+    def set_console(self, attrs=None, on_stderr=False):
+        if attrs is None:
+            attrs = self.get_attrs()
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        win32.SetConsoleTextAttribute(handle, attrs)
+
+    def get_position(self, handle):
+        position = win32.GetConsoleScreenBufferInfo(handle).dwCursorPosition
+        # Because Windows coordinates are 0-based,
+        # and win32.SetConsoleCursorPosition expects 1-based.
+        position.X += 1
+        position.Y += 1
+        return position
+
+    def set_cursor_position(self, position=None, on_stderr=False):
+        if position is None:
+            # I'm not currently tracking the position, so there is no default.
+            # position = self.get_position()
+            return
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        win32.SetConsoleCursorPosition(handle, position)
+
+    def cursor_adjust(self, x, y, on_stderr=False):
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        position = self.get_position(handle)
+        adjusted_position = (position.Y + y, position.X + x)
+        win32.SetConsoleCursorPosition(handle, adjusted_position, adjust=False)
+
+    def erase_screen(self, mode=0, on_stderr=False):
+        # 0 should clear from the cursor to the end of the screen.
+        # 1 should clear from the cursor to the beginning of the screen.
+        # 2 should clear the entire screen, and move cursor to (1,1)
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        csbi = win32.GetConsoleScreenBufferInfo(handle)
+        # get the number of character cells in the current buffer
+        cells_in_screen = csbi.dwSize.X * csbi.dwSize.Y
+        # get number of character cells before current cursor position
+        cells_before_cursor = csbi.dwSize.X * csbi.dwCursorPosition.Y + csbi.dwCursorPosition.X
+        if mode == 0:
+            from_coord = csbi.dwCursorPosition
+            cells_to_erase = cells_in_screen - cells_before_cursor
+        elif mode == 1:
+            from_coord = win32.COORD(0, 0)
+            cells_to_erase = cells_before_cursor
+        elif mode == 2:
+            from_coord = win32.COORD(0, 0)
+            cells_to_erase = cells_in_screen
+        else:
+            # invalid mode
+            return
+        # fill the entire screen with blanks
+        win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord)
+        # now set the buffer's attributes accordingly
+        win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord)
+        if mode == 2:
+            # put the cursor where needed
+            win32.SetConsoleCursorPosition(handle, (1, 1))
+
+    def erase_line(self, mode=0, on_stderr=False):
+        # 0 should clear from the cursor to the end of the line.
+        # 1 should clear from the cursor to the beginning of the line.
+        # 2 should clear the entire line.
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        csbi = win32.GetConsoleScreenBufferInfo(handle)
+        if mode == 0:
+            from_coord = csbi.dwCursorPosition
+            cells_to_erase = csbi.dwSize.X - csbi.dwCursorPosition.X
+        elif mode == 1:
+            from_coord = win32.COORD(0, csbi.dwCursorPosition.Y)
+            cells_to_erase = csbi.dwCursorPosition.X
+        elif mode == 2:
+            from_coord = win32.COORD(0, csbi.dwCursorPosition.Y)
+            cells_to_erase = csbi.dwSize.X
+        else:
+            # invalid mode
+            return
+        # fill the entire screen with blanks
+        win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord)
+        # now set the buffer's attributes accordingly
+        win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord)
+
+    def set_title(self, title):
+        win32.SetConsoleTitle(title)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/contextlib2.py b/myenv/lib/python3.9/site-packages/pip/_vendor/contextlib2.py
new file mode 100644
index 0000000..3aae8f4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/contextlib2.py
@@ -0,0 +1,518 @@
+"""contextlib2 - backports and enhancements to the contextlib module"""
+
+import abc
+import sys
+import warnings
+from collections import deque
+from functools import wraps
+
+__all__ = ["contextmanager", "closing", "nullcontext",
+           "AbstractContextManager",
+           "ContextDecorator", "ExitStack",
+           "redirect_stdout", "redirect_stderr", "suppress"]
+
+# Backwards compatibility
+__all__ += ["ContextStack"]
+
+
+# Backport abc.ABC
+if sys.version_info[:2] >= (3, 4):
+    _abc_ABC = abc.ABC
+else:
+    _abc_ABC = abc.ABCMeta('ABC', (object,), {'__slots__': ()})
+
+
+# Backport classic class MRO
+def _classic_mro(C, result):
+    if C in result:
+        return
+    result.append(C)
+    for B in C.__bases__:
+        _classic_mro(B, result)
+    return result
+
+
+# Backport _collections_abc._check_methods
+def _check_methods(C, *methods):
+    try:
+        mro = C.__mro__
+    except AttributeError:
+        mro = tuple(_classic_mro(C, []))
+
+    for method in methods:
+        for B in mro:
+            if method in B.__dict__:
+                if B.__dict__[method] is None:
+                    return NotImplemented
+                break
+        else:
+            return NotImplemented
+    return True
+
+
+class AbstractContextManager(_abc_ABC):
+    """An abstract base class for context managers."""
+
+    def __enter__(self):
+        """Return `self` upon entering the runtime context."""
+        return self
+
+    @abc.abstractmethod
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Raise any exception triggered within the runtime context."""
+        return None
+
+    @classmethod
+    def __subclasshook__(cls, C):
+        """Check whether subclass is considered a subclass of this ABC."""
+        if cls is AbstractContextManager:
+            return _check_methods(C, "__enter__", "__exit__")
+        return NotImplemented
+
+
+class ContextDecorator(object):
+    """A base class or mixin that enables context managers to work as decorators."""
+
+    def refresh_cm(self):
+        """Returns the context manager used to actually wrap the call to the
+        decorated function.
+
+        The default implementation just returns *self*.
+
+        Overriding this method allows otherwise one-shot context managers
+        like _GeneratorContextManager to support use as decorators via
+        implicit recreation.
+
+        DEPRECATED: refresh_cm was never added to the standard library's
+                    ContextDecorator API
+        """
+        warnings.warn("refresh_cm was never added to the standard library",
+                      DeprecationWarning)
+        return self._recreate_cm()
+
+    def _recreate_cm(self):
+        """Return a recreated instance of self.
+
+        Allows an otherwise one-shot context manager like
+        _GeneratorContextManager to support use as
+        a decorator via implicit recreation.
+
+        This is a private interface just for _GeneratorContextManager.
+        See issue #11647 for details.
+        """
+        return self
+
+    def __call__(self, func):
+        @wraps(func)
+        def inner(*args, **kwds):
+            with self._recreate_cm():
+                return func(*args, **kwds)
+        return inner
+
+
+class _GeneratorContextManager(ContextDecorator):
+    """Helper for @contextmanager decorator."""
+
+    def __init__(self, func, args, kwds):
+        self.gen = func(*args, **kwds)
+        self.func, self.args, self.kwds = func, args, kwds
+        # Issue 19330: ensure context manager instances have good docstrings
+        doc = getattr(func, "__doc__", None)
+        if doc is None:
+            doc = type(self).__doc__
+        self.__doc__ = doc
+        # Unfortunately, this still doesn't provide good help output when
+        # inspecting the created context manager instances, since pydoc
+        # currently bypasses the instance docstring and shows the docstring
+        # for the class instead.
+        # See http://bugs.python.org/issue19404 for more details.
+
+    def _recreate_cm(self):
+        # _GCM instances are one-shot context managers, so the
+        # CM must be recreated each time a decorated function is
+        # called
+        return self.__class__(self.func, self.args, self.kwds)
+
+    def __enter__(self):
+        try:
+            return next(self.gen)
+        except StopIteration:
+            raise RuntimeError("generator didn't yield")
+
+    def __exit__(self, type, value, traceback):
+        if type is None:
+            try:
+                next(self.gen)
+            except StopIteration:
+                return
+            else:
+                raise RuntimeError("generator didn't stop")
+        else:
+            if value is None:
+                # Need to force instantiation so we can reliably
+                # tell if we get the same exception back
+                value = type()
+            try:
+                self.gen.throw(type, value, traceback)
+                raise RuntimeError("generator didn't stop after throw()")
+            except StopIteration as exc:
+                # Suppress StopIteration *unless* it's the same exception that
+                # was passed to throw().  This prevents a StopIteration
+                # raised inside the "with" statement from being suppressed.
+                return exc is not value
+            except RuntimeError as exc:
+                # Don't re-raise the passed in exception
+                if exc is value:
+                    return False
+                # Likewise, avoid suppressing if a StopIteration exception
+                # was passed to throw() and later wrapped into a RuntimeError
+                # (see PEP 479).
+                if _HAVE_EXCEPTION_CHAINING and exc.__cause__ is value:
+                    return False
+                raise
+            except:
+                # only re-raise if it's *not* the exception that was
+                # passed to throw(), because __exit__() must not raise
+                # an exception unless __exit__() itself failed.  But throw()
+                # has to raise the exception to signal propagation, so this
+                # fixes the impedance mismatch between the throw() protocol
+                # and the __exit__() protocol.
+                #
+                if sys.exc_info()[1] is not value:
+                    raise
+
+
+def contextmanager(func):
+    """@contextmanager decorator.
+
+    Typical usage:
+
+        @contextmanager
+        def some_generator(<arguments>):
+            <setup>
+            try:
+                yield <value>
+            finally:
+                <cleanup>
+
+    This makes this:
+
+        with some_generator(<arguments>) as <variable>:
+            <body>
+
+    equivalent to this:
+
+        <setup>
+        try:
+            <variable> = <value>
+            <body>
+        finally:
+            <cleanup>
+
+    """
+    @wraps(func)
+    def helper(*args, **kwds):
+        return _GeneratorContextManager(func, args, kwds)
+    return helper
+
+
+class closing(object):
+    """Context to automatically close something at the end of a block.
+
+    Code like this:
+
+        with closing(<module>.open(<arguments>)) as f:
+            <block>
+
+    is equivalent to this:
+
+        f = <module>.open(<arguments>)
+        try:
+            <block>
+        finally:
+            f.close()
+
+    """
+    def __init__(self, thing):
+        self.thing = thing
+
+    def __enter__(self):
+        return self.thing
+
+    def __exit__(self, *exc_info):
+        self.thing.close()
+
+
+class _RedirectStream(object):
+
+    _stream = None
+
+    def __init__(self, new_target):
+        self._new_target = new_target
+        # We use a list of old targets to make this CM re-entrant
+        self._old_targets = []
+
+    def __enter__(self):
+        self._old_targets.append(getattr(sys, self._stream))
+        setattr(sys, self._stream, self._new_target)
+        return self._new_target
+
+    def __exit__(self, exctype, excinst, exctb):
+        setattr(sys, self._stream, self._old_targets.pop())
+
+
+class redirect_stdout(_RedirectStream):
+    """Context manager for temporarily redirecting stdout to another file.
+
+        # How to send help() to stderr
+        with redirect_stdout(sys.stderr):
+            help(dir)
+
+        # How to write help() to a file
+        with open('help.txt', 'w') as f:
+            with redirect_stdout(f):
+                help(pow)
+    """
+
+    _stream = "stdout"
+
+
+class redirect_stderr(_RedirectStream):
+    """Context manager for temporarily redirecting stderr to another file."""
+
+    _stream = "stderr"
+
+
+class suppress(object):
+    """Context manager to suppress specified exceptions
+
+    After the exception is suppressed, execution proceeds with the next
+    statement following the with statement.
+
+         with suppress(FileNotFoundError):
+             os.remove(somefile)
+         # Execution still resumes here if the file was already removed
+    """
+
+    def __init__(self, *exceptions):
+        self._exceptions = exceptions
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exctype, excinst, exctb):
+        # Unlike isinstance and issubclass, CPython exception handling
+        # currently only looks at the concrete type hierarchy (ignoring
+        # the instance and subclass checking hooks). While Guido considers
+        # that a bug rather than a feature, it's a fairly hard one to fix
+        # due to various internal implementation details. suppress provides
+        # the simpler issubclass based semantics, rather than trying to
+        # exactly reproduce the limitations of the CPython interpreter.
+        #
+        # See http://bugs.python.org/issue12029 for more details
+        return exctype is not None and issubclass(exctype, self._exceptions)
+
+
+# Context manipulation is Python 3 only
+_HAVE_EXCEPTION_CHAINING = sys.version_info[0] >= 3
+if _HAVE_EXCEPTION_CHAINING:
+    def _make_context_fixer(frame_exc):
+        def _fix_exception_context(new_exc, old_exc):
+            # Context may not be correct, so find the end of the chain
+            while 1:
+                exc_context = new_exc.__context__
+                if exc_context is old_exc:
+                    # Context is already set correctly (see issue 20317)
+                    return
+                if exc_context is None or exc_context is frame_exc:
+                    break
+                new_exc = exc_context
+            # Change the end of the chain to point to the exception
+            # we expect it to reference
+            new_exc.__context__ = old_exc
+        return _fix_exception_context
+
+    def _reraise_with_existing_context(exc_details):
+        try:
+            # bare "raise exc_details[1]" replaces our carefully
+            # set-up context
+            fixed_ctx = exc_details[1].__context__
+            raise exc_details[1]
+        except BaseException:
+            exc_details[1].__context__ = fixed_ctx
+            raise
+else:
+    # No exception context in Python 2
+    def _make_context_fixer(frame_exc):
+        return lambda new_exc, old_exc: None
+
+    # Use 3 argument raise in Python 2,
+    # but use exec to avoid SyntaxError in Python 3
+    def _reraise_with_existing_context(exc_details):
+        exc_type, exc_value, exc_tb = exc_details
+        exec("raise exc_type, exc_value, exc_tb")
+
+# Handle old-style classes if they exist
+try:
+    from types import InstanceType
+except ImportError:
+    # Python 3 doesn't have old-style classes
+    _get_type = type
+else:
+    # Need to handle old-style context managers on Python 2
+    def _get_type(obj):
+        obj_type = type(obj)
+        if obj_type is InstanceType:
+            return obj.__class__  # Old-style class
+        return obj_type  # New-style class
+
+
+# Inspired by discussions on http://bugs.python.org/issue13585
+class ExitStack(object):
+    """Context manager for dynamic management of a stack of exit callbacks
+
+    For example:
+
+        with ExitStack() as stack:
+            files = [stack.enter_context(open(fname)) for fname in filenames]
+            # All opened files will automatically be closed at the end of
+            # the with statement, even if attempts to open files later
+            # in the list raise an exception
+
+    """
+    def __init__(self):
+        self._exit_callbacks = deque()
+
+    def pop_all(self):
+        """Preserve the context stack by transferring it to a new instance"""
+        new_stack = type(self)()
+        new_stack._exit_callbacks = self._exit_callbacks
+        self._exit_callbacks = deque()
+        return new_stack
+
+    def _push_cm_exit(self, cm, cm_exit):
+        """Helper to correctly register callbacks to __exit__ methods"""
+        def _exit_wrapper(*exc_details):
+            return cm_exit(cm, *exc_details)
+        _exit_wrapper.__self__ = cm
+        self.push(_exit_wrapper)
+
+    def push(self, exit):
+        """Registers a callback with the standard __exit__ method signature
+
+        Can suppress exceptions the same way __exit__ methods can.
+
+        Also accepts any object with an __exit__ method (registering a call
+        to the method instead of the object itself)
+        """
+        # We use an unbound method rather than a bound method to follow
+        # the standard lookup behaviour for special methods
+        _cb_type = _get_type(exit)
+        try:
+            exit_method = _cb_type.__exit__
+        except AttributeError:
+            # Not a context manager, so assume its a callable
+            self._exit_callbacks.append(exit)
+        else:
+            self._push_cm_exit(exit, exit_method)
+        return exit # Allow use as a decorator
+
+    def callback(self, callback, *args, **kwds):
+        """Registers an arbitrary callback and arguments.
+
+        Cannot suppress exceptions.
+        """
+        def _exit_wrapper(exc_type, exc, tb):
+            callback(*args, **kwds)
+        # We changed the signature, so using @wraps is not appropriate, but
+        # setting __wrapped__ may still help with introspection
+        _exit_wrapper.__wrapped__ = callback
+        self.push(_exit_wrapper)
+        return callback # Allow use as a decorator
+
+    def enter_context(self, cm):
+        """Enters the supplied context manager
+
+        If successful, also pushes its __exit__ method as a callback and
+        returns the result of the __enter__ method.
+        """
+        # We look up the special methods on the type to match the with statement
+        _cm_type = _get_type(cm)
+        _exit = _cm_type.__exit__
+        result = _cm_type.__enter__(cm)
+        self._push_cm_exit(cm, _exit)
+        return result
+
+    def close(self):
+        """Immediately unwind the context stack"""
+        self.__exit__(None, None, None)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_details):
+        received_exc = exc_details[0] is not None
+
+        # We manipulate the exception state so it behaves as though
+        # we were actually nesting multiple with statements
+        frame_exc = sys.exc_info()[1]
+        _fix_exception_context = _make_context_fixer(frame_exc)
+
+        # Callbacks are invoked in LIFO order to match the behaviour of
+        # nested context managers
+        suppressed_exc = False
+        pending_raise = False
+        while self._exit_callbacks:
+            cb = self._exit_callbacks.pop()
+            try:
+                if cb(*exc_details):
+                    suppressed_exc = True
+                    pending_raise = False
+                    exc_details = (None, None, None)
+            except:
+                new_exc_details = sys.exc_info()
+                # simulate the stack of exceptions by setting the context
+                _fix_exception_context(new_exc_details[1], exc_details[1])
+                pending_raise = True
+                exc_details = new_exc_details
+        if pending_raise:
+            _reraise_with_existing_context(exc_details)
+        return received_exc and suppressed_exc
+
+
+# Preserve backwards compatibility
+class ContextStack(ExitStack):
+    """Backwards compatibility alias for ExitStack"""
+
+    def __init__(self):
+        warnings.warn("ContextStack has been renamed to ExitStack",
+                      DeprecationWarning)
+        super(ContextStack, self).__init__()
+
+    def register_exit(self, callback):
+        return self.push(callback)
+
+    def register(self, callback, *args, **kwds):
+        return self.callback(callback, *args, **kwds)
+
+    def preserve(self):
+        return self.pop_all()
+
+
+class nullcontext(AbstractContextManager):
+    """Context manager that does no additional processing.
+    Used as a stand-in for a normal context manager, when a particular
+    block of code is only sometimes used with a normal context manager:
+    cm = optional_cm if condition else nullcontext()
+    with cm:
+        # Perform operation, using optional_cm if condition is True
+    """
+
+    def __init__(self, enter_result=None):
+        self.enter_result = enter_result
+
+    def __enter__(self):
+        return self.enter_result
+
+    def __exit__(self, *excinfo):
+        pass
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/__init__.py
new file mode 100644
index 0000000..63d916e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/__init__.py
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2019 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+import logging
+
+__version__ = '0.3.1'
+
+class DistlibException(Exception):
+    pass
+
+try:
+    from logging import NullHandler
+except ImportError: # pragma: no cover
+    class NullHandler(logging.Handler):
+        def handle(self, record): pass
+        def emit(self, record): pass
+        def createLock(self): self.lock = None
+
+logger = logging.getLogger(__name__)
+logger.addHandler(NullHandler())
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/__init__.py
new file mode 100644
index 0000000..f7dbf4c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/__init__.py
@@ -0,0 +1,6 @@
+"""Modules copied from Python 3 standard libraries, for internal use only.
+
+Individual classes and functions are found in d2._backport.misc.  Intended
+usage is to always import things missing from 3.1 from that module: the
+built-in/stdlib objects will be used if found.
+"""
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/misc.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/misc.py
new file mode 100644
index 0000000..cfb318d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/misc.py
@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""Backports for individual classes and functions."""
+
+import os
+import sys
+
+__all__ = ['cache_from_source', 'callable', 'fsencode']
+
+
+try:
+    from imp import cache_from_source
+except ImportError:
+    def cache_from_source(py_file, debug=__debug__):
+        ext = debug and 'c' or 'o'
+        return py_file + ext
+
+
+try:
+    callable = callable
+except NameError:
+    from collections import Callable
+
+    def callable(obj):
+        return isinstance(obj, Callable)
+
+
+try:
+    fsencode = os.fsencode
+except AttributeError:
+    def fsencode(filename):
+        if isinstance(filename, bytes):
+            return filename
+        elif isinstance(filename, str):
+            return filename.encode(sys.getfilesystemencoding())
+        else:
+            raise TypeError("expect bytes or str, not %s" %
+                            type(filename).__name__)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/shutil.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/shutil.py
new file mode 100644
index 0000000..10ed362
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/shutil.py
@@ -0,0 +1,764 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""Utility functions for copying and archiving files and directory trees.
+
+XXX The functions here don't copy the resource fork or other metadata on Mac.
+
+"""
+
+import os
+import sys
+import stat
+from os.path import abspath
+import fnmatch
+try:
+    from collections.abc import Callable
+except ImportError:
+    from collections import Callable
+import errno
+from . import tarfile
+
+try:
+    import bz2
+    _BZ2_SUPPORTED = True
+except ImportError:
+    _BZ2_SUPPORTED = False
+
+try:
+    from pwd import getpwnam
+except ImportError:
+    getpwnam = None
+
+try:
+    from grp import getgrnam
+except ImportError:
+    getgrnam = None
+
+__all__ = ["copyfileobj", "copyfile", "copymode", "copystat", "copy", "copy2",
+           "copytree", "move", "rmtree", "Error", "SpecialFileError",
+           "ExecError", "make_archive", "get_archive_formats",
+           "register_archive_format", "unregister_archive_format",
+           "get_unpack_formats", "register_unpack_format",
+           "unregister_unpack_format", "unpack_archive", "ignore_patterns"]
+
+class Error(EnvironmentError):
+    pass
+
+class SpecialFileError(EnvironmentError):
+    """Raised when trying to do a kind of operation (e.g. copying) which is
+    not supported on a special file (e.g. a named pipe)"""
+
+class ExecError(EnvironmentError):
+    """Raised when a command could not be executed"""
+
+class ReadError(EnvironmentError):
+    """Raised when an archive cannot be read"""
+
+class RegistryError(Exception):
+    """Raised when a registry operation with the archiving
+    and unpacking registries fails"""
+
+
+try:
+    WindowsError
+except NameError:
+    WindowsError = None
+
+def copyfileobj(fsrc, fdst, length=16*1024):
+    """copy data from file-like object fsrc to file-like object fdst"""
+    while 1:
+        buf = fsrc.read(length)
+        if not buf:
+            break
+        fdst.write(buf)
+
+def _samefile(src, dst):
+    # Macintosh, Unix.
+    if hasattr(os.path, 'samefile'):
+        try:
+            return os.path.samefile(src, dst)
+        except OSError:
+            return False
+
+    # All other platforms: check for same pathname.
+    return (os.path.normcase(os.path.abspath(src)) ==
+            os.path.normcase(os.path.abspath(dst)))
+
+def copyfile(src, dst):
+    """Copy data from src to dst"""
+    if _samefile(src, dst):
+        raise Error("`%s` and `%s` are the same file" % (src, dst))
+
+    for fn in [src, dst]:
+        try:
+            st = os.stat(fn)
+        except OSError:
+            # File most likely does not exist
+            pass
+        else:
+            # XXX What about other special files? (sockets, devices...)
+            if stat.S_ISFIFO(st.st_mode):
+                raise SpecialFileError("`%s` is a named pipe" % fn)
+
+    with open(src, 'rb') as fsrc:
+        with open(dst, 'wb') as fdst:
+            copyfileobj(fsrc, fdst)
+
+def copymode(src, dst):
+    """Copy mode bits from src to dst"""
+    if hasattr(os, 'chmod'):
+        st = os.stat(src)
+        mode = stat.S_IMODE(st.st_mode)
+        os.chmod(dst, mode)
+
+def copystat(src, dst):
+    """Copy all stat info (mode bits, atime, mtime, flags) from src to dst"""
+    st = os.stat(src)
+    mode = stat.S_IMODE(st.st_mode)
+    if hasattr(os, 'utime'):
+        os.utime(dst, (st.st_atime, st.st_mtime))
+    if hasattr(os, 'chmod'):
+        os.chmod(dst, mode)
+    if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):
+        try:
+            os.chflags(dst, st.st_flags)
+        except OSError as why:
+            if (not hasattr(errno, 'EOPNOTSUPP') or
+                why.errno != errno.EOPNOTSUPP):
+                raise
+
+def copy(src, dst):
+    """Copy data and mode bits ("cp src dst").
+
+    The destination may be a directory.
+
+    """
+    if os.path.isdir(dst):
+        dst = os.path.join(dst, os.path.basename(src))
+    copyfile(src, dst)
+    copymode(src, dst)
+
+def copy2(src, dst):
+    """Copy data and all stat info ("cp -p src dst").
+
+    The destination may be a directory.
+
+    """
+    if os.path.isdir(dst):
+        dst = os.path.join(dst, os.path.basename(src))
+    copyfile(src, dst)
+    copystat(src, dst)
+
+def ignore_patterns(*patterns):
+    """Function that can be used as copytree() ignore parameter.
+
+    Patterns is a sequence of glob-style patterns
+    that are used to exclude files"""
+    def _ignore_patterns(path, names):
+        ignored_names = []
+        for pattern in patterns:
+            ignored_names.extend(fnmatch.filter(names, pattern))
+        return set(ignored_names)
+    return _ignore_patterns
+
+def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2,
+             ignore_dangling_symlinks=False):
+    """Recursively copy a directory tree.
+
+    The destination directory must not already exist.
+    If exception(s) occur, an Error is raised with a list of reasons.
+
+    If the optional symlinks flag is true, symbolic links in the
+    source tree result in symbolic links in the destination tree; if
+    it is false, the contents of the files pointed to by symbolic
+    links are copied. If the file pointed by the symlink doesn't
+    exist, an exception will be added in the list of errors raised in
+    an Error exception at the end of the copy process.
+
+    You can set the optional ignore_dangling_symlinks flag to true if you
+    want to silence this exception. Notice that this has no effect on
+    platforms that don't support os.symlink.
+
+    The optional ignore argument is a callable. If given, it
+    is called with the `src` parameter, which is the directory
+    being visited by copytree(), and `names` which is the list of
+    `src` contents, as returned by os.listdir():
+
+        callable(src, names) -> ignored_names
+
+    Since copytree() is called recursively, the callable will be
+    called once for each directory that is copied. It returns a
+    list of names relative to the `src` directory that should
+    not be copied.
+
+    The optional copy_function argument is a callable that will be used
+    to copy each file. It will be called with the source path and the
+    destination path as arguments. By default, copy2() is used, but any
+    function that supports the same signature (like copy()) can be used.
+
+    """
+    names = os.listdir(src)
+    if ignore is not None:
+        ignored_names = ignore(src, names)
+    else:
+        ignored_names = set()
+
+    os.makedirs(dst)
+    errors = []
+    for name in names:
+        if name in ignored_names:
+            continue
+        srcname = os.path.join(src, name)
+        dstname = os.path.join(dst, name)
+        try:
+            if os.path.islink(srcname):
+                linkto = os.readlink(srcname)
+                if symlinks:
+                    os.symlink(linkto, dstname)
+                else:
+                    # ignore dangling symlink if the flag is on
+                    if not os.path.exists(linkto) and ignore_dangling_symlinks:
+                        continue
+                    # otherwise let the copy occurs. copy2 will raise an error
+                    copy_function(srcname, dstname)
+            elif os.path.isdir(srcname):
+                copytree(srcname, dstname, symlinks, ignore, copy_function)
+            else:
+                # Will raise a SpecialFileError for unsupported file types
+                copy_function(srcname, dstname)
+        # catch the Error from the recursive copytree so that we can
+        # continue with other files
+        except Error as err:
+            errors.extend(err.args[0])
+        except EnvironmentError as why:
+            errors.append((srcname, dstname, str(why)))
+    try:
+        copystat(src, dst)
+    except OSError as why:
+        if WindowsError is not None and isinstance(why, WindowsError):
+            # Copying file access times may fail on Windows
+            pass
+        else:
+            errors.extend((src, dst, str(why)))
+    if errors:
+        raise Error(errors)
+
+def rmtree(path, ignore_errors=False, onerror=None):
+    """Recursively delete a directory tree.
+
+    If ignore_errors is set, errors are ignored; otherwise, if onerror
+    is set, it is called to handle the error with arguments (func,
+    path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
+    path is the argument to that function that caused it to fail; and
+    exc_info is a tuple returned by sys.exc_info().  If ignore_errors
+    is false and onerror is None, an exception is raised.
+
+    """
+    if ignore_errors:
+        def onerror(*args):
+            pass
+    elif onerror is None:
+        def onerror(*args):
+            raise
+    try:
+        if os.path.islink(path):
+            # symlinks to directories are forbidden, see bug #1669
+            raise OSError("Cannot call rmtree on a symbolic link")
+    except OSError:
+        onerror(os.path.islink, path, sys.exc_info())
+        # can't continue even if onerror hook returns
+        return
+    names = []
+    try:
+        names = os.listdir(path)
+    except os.error:
+        onerror(os.listdir, path, sys.exc_info())
+    for name in names:
+        fullname = os.path.join(path, name)
+        try:
+            mode = os.lstat(fullname).st_mode
+        except os.error:
+            mode = 0
+        if stat.S_ISDIR(mode):
+            rmtree(fullname, ignore_errors, onerror)
+        else:
+            try:
+                os.remove(fullname)
+            except os.error:
+                onerror(os.remove, fullname, sys.exc_info())
+    try:
+        os.rmdir(path)
+    except os.error:
+        onerror(os.rmdir, path, sys.exc_info())
+
+
+def _basename(path):
+    # A basename() variant which first strips the trailing slash, if present.
+    # Thus we always get the last component of the path, even for directories.
+    return os.path.basename(path.rstrip(os.path.sep))
+
+def move(src, dst):
+    """Recursively move a file or directory to another location. This is
+    similar to the Unix "mv" command.
+
+    If the destination is a directory or a symlink to a directory, the source
+    is moved inside the directory. The destination path must not already
+    exist.
+
+    If the destination already exists but is not a directory, it may be
+    overwritten depending on os.rename() semantics.
+
+    If the destination is on our current filesystem, then rename() is used.
+    Otherwise, src is copied to the destination and then removed.
+    A lot more could be done here...  A look at a mv.c shows a lot of
+    the issues this implementation glosses over.
+
+    """
+    real_dst = dst
+    if os.path.isdir(dst):
+        if _samefile(src, dst):
+            # We might be on a case insensitive filesystem,
+            # perform the rename anyway.
+            os.rename(src, dst)
+            return
+
+        real_dst = os.path.join(dst, _basename(src))
+        if os.path.exists(real_dst):
+            raise Error("Destination path '%s' already exists" % real_dst)
+    try:
+        os.rename(src, real_dst)
+    except OSError:
+        if os.path.isdir(src):
+            if _destinsrc(src, dst):
+                raise Error("Cannot move a directory '%s' into itself '%s'." % (src, dst))
+            copytree(src, real_dst, symlinks=True)
+            rmtree(src)
+        else:
+            copy2(src, real_dst)
+            os.unlink(src)
+
+def _destinsrc(src, dst):
+    src = abspath(src)
+    dst = abspath(dst)
+    if not src.endswith(os.path.sep):
+        src += os.path.sep
+    if not dst.endswith(os.path.sep):
+        dst += os.path.sep
+    return dst.startswith(src)
+
+def _get_gid(name):
+    """Returns a gid, given a group name."""
+    if getgrnam is None or name is None:
+        return None
+    try:
+        result = getgrnam(name)
+    except KeyError:
+        result = None
+    if result is not None:
+        return result[2]
+    return None
+
+def _get_uid(name):
+    """Returns an uid, given a user name."""
+    if getpwnam is None or name is None:
+        return None
+    try:
+        result = getpwnam(name)
+    except KeyError:
+        result = None
+    if result is not None:
+        return result[2]
+    return None
+
+def _make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0,
+                  owner=None, group=None, logger=None):
+    """Create a (possibly compressed) tar file from all the files under
+    'base_dir'.
+
+    'compress' must be "gzip" (the default), "bzip2", or None.
+
+    'owner' and 'group' can be used to define an owner and a group for the
+    archive that is being built. If not provided, the current owner and group
+    will be used.
+
+    The output tar file will be named 'base_name' +  ".tar", possibly plus
+    the appropriate compression extension (".gz", or ".bz2").
+
+    Returns the output filename.
+    """
+    tar_compression = {'gzip': 'gz', None: ''}
+    compress_ext = {'gzip': '.gz'}
+
+    if _BZ2_SUPPORTED:
+        tar_compression['bzip2'] = 'bz2'
+        compress_ext['bzip2'] = '.bz2'
+
+    # flags for compression program, each element of list will be an argument
+    if compress is not None and compress not in compress_ext:
+        raise ValueError("bad value for 'compress', or compression format not "
+                         "supported : {0}".format(compress))
+
+    archive_name = base_name + '.tar' + compress_ext.get(compress, '')
+    archive_dir = os.path.dirname(archive_name)
+
+    if not os.path.exists(archive_dir):
+        if logger is not None:
+            logger.info("creating %s", archive_dir)
+        if not dry_run:
+            os.makedirs(archive_dir)
+
+    # creating the tarball
+    if logger is not None:
+        logger.info('Creating tar archive')
+
+    uid = _get_uid(owner)
+    gid = _get_gid(group)
+
+    def _set_uid_gid(tarinfo):
+        if gid is not None:
+            tarinfo.gid = gid
+            tarinfo.gname = group
+        if uid is not None:
+            tarinfo.uid = uid
+            tarinfo.uname = owner
+        return tarinfo
+
+    if not dry_run:
+        tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
+        try:
+            tar.add(base_dir, filter=_set_uid_gid)
+        finally:
+            tar.close()
+
+    return archive_name
+
+def _call_external_zip(base_dir, zip_filename, verbose=False, dry_run=False):
+    # XXX see if we want to keep an external call here
+    if verbose:
+        zipoptions = "-r"
+    else:
+        zipoptions = "-rq"
+    from distutils.errors import DistutilsExecError
+    from distutils.spawn import spawn
+    try:
+        spawn(["zip", zipoptions, zip_filename, base_dir], dry_run=dry_run)
+    except DistutilsExecError:
+        # XXX really should distinguish between "couldn't find
+        # external 'zip' command" and "zip failed".
+        raise ExecError("unable to create zip file '%s': "
+            "could neither import the 'zipfile' module nor "
+            "find a standalone zip utility") % zip_filename
+
+def _make_zipfile(base_name, base_dir, verbose=0, dry_run=0, logger=None):
+    """Create a zip file from all the files under 'base_dir'.
+
+    The output zip file will be named 'base_name' + ".zip".  Uses either the
+    "zipfile" Python module (if available) or the InfoZIP "zip" utility
+    (if installed and found on the default search path).  If neither tool is
+    available, raises ExecError.  Returns the name of the output zip
+    file.
+    """
+    zip_filename = base_name + ".zip"
+    archive_dir = os.path.dirname(base_name)
+
+    if not os.path.exists(archive_dir):
+        if logger is not None:
+            logger.info("creating %s", archive_dir)
+        if not dry_run:
+            os.makedirs(archive_dir)
+
+    # If zipfile module is not available, try spawning an external 'zip'
+    # command.
+    try:
+        import zipfile
+    except ImportError:
+        zipfile = None
+
+    if zipfile is None:
+        _call_external_zip(base_dir, zip_filename, verbose, dry_run)
+    else:
+        if logger is not None:
+            logger.info("creating '%s' and adding '%s' to it",
+                        zip_filename, base_dir)
+
+        if not dry_run:
+            zip = zipfile.ZipFile(zip_filename, "w",
+                                  compression=zipfile.ZIP_DEFLATED)
+
+            for dirpath, dirnames, filenames in os.walk(base_dir):
+                for name in filenames:
+                    path = os.path.normpath(os.path.join(dirpath, name))
+                    if os.path.isfile(path):
+                        zip.write(path, path)
+                        if logger is not None:
+                            logger.info("adding '%s'", path)
+            zip.close()
+
+    return zip_filename
+
+_ARCHIVE_FORMATS = {
+    'gztar': (_make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
+    'bztar': (_make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"),
+    'tar':   (_make_tarball, [('compress', None)], "uncompressed tar file"),
+    'zip':   (_make_zipfile, [], "ZIP file"),
+    }
+
+if _BZ2_SUPPORTED:
+    _ARCHIVE_FORMATS['bztar'] = (_make_tarball, [('compress', 'bzip2')],
+                                "bzip2'ed tar-file")
+
+def get_archive_formats():
+    """Returns a list of supported formats for archiving and unarchiving.
+
+    Each element of the returned sequence is a tuple (name, description)
+    """
+    formats = [(name, registry[2]) for name, registry in
+               _ARCHIVE_FORMATS.items()]
+    formats.sort()
+    return formats
+
+def register_archive_format(name, function, extra_args=None, description=''):
+    """Registers an archive format.
+
+    name is the name of the format. function is the callable that will be
+    used to create archives. If provided, extra_args is a sequence of
+    (name, value) tuples that will be passed as arguments to the callable.
+    description can be provided to describe the format, and will be returned
+    by the get_archive_formats() function.
+    """
+    if extra_args is None:
+        extra_args = []
+    if not isinstance(function, Callable):
+        raise TypeError('The %s object is not callable' % function)
+    if not isinstance(extra_args, (tuple, list)):
+        raise TypeError('extra_args needs to be a sequence')
+    for element in extra_args:
+        if not isinstance(element, (tuple, list)) or len(element) !=2:
+            raise TypeError('extra_args elements are : (arg_name, value)')
+
+    _ARCHIVE_FORMATS[name] = (function, extra_args, description)
+
+def unregister_archive_format(name):
+    del _ARCHIVE_FORMATS[name]
+
+def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
+                 dry_run=0, owner=None, group=None, logger=None):
+    """Create an archive file (eg. zip or tar).
+
+    'base_name' is the name of the file to create, minus any format-specific
+    extension; 'format' is the archive format: one of "zip", "tar", "bztar"
+    or "gztar".
+
+    'root_dir' is a directory that will be the root directory of the
+    archive; ie. we typically chdir into 'root_dir' before creating the
+    archive.  'base_dir' is the directory where we start archiving from;
+    ie. 'base_dir' will be the common prefix of all files and
+    directories in the archive.  'root_dir' and 'base_dir' both default
+    to the current directory.  Returns the name of the archive file.
+
+    'owner' and 'group' are used when creating a tar archive. By default,
+    uses the current owner and group.
+    """
+    save_cwd = os.getcwd()
+    if root_dir is not None:
+        if logger is not None:
+            logger.debug("changing into '%s'", root_dir)
+        base_name = os.path.abspath(base_name)
+        if not dry_run:
+            os.chdir(root_dir)
+
+    if base_dir is None:
+        base_dir = os.curdir
+
+    kwargs = {'dry_run': dry_run, 'logger': logger}
+
+    try:
+        format_info = _ARCHIVE_FORMATS[format]
+    except KeyError:
+        raise ValueError("unknown archive format '%s'" % format)
+
+    func = format_info[0]
+    for arg, val in format_info[1]:
+        kwargs[arg] = val
+
+    if format != 'zip':
+        kwargs['owner'] = owner
+        kwargs['group'] = group
+
+    try:
+        filename = func(base_name, base_dir, **kwargs)
+    finally:
+        if root_dir is not None:
+            if logger is not None:
+                logger.debug("changing back to '%s'", save_cwd)
+            os.chdir(save_cwd)
+
+    return filename
+
+
+def get_unpack_formats():
+    """Returns a list of supported formats for unpacking.
+
+    Each element of the returned sequence is a tuple
+    (name, extensions, description)
+    """
+    formats = [(name, info[0], info[3]) for name, info in
+               _UNPACK_FORMATS.items()]
+    formats.sort()
+    return formats
+
+def _check_unpack_options(extensions, function, extra_args):
+    """Checks what gets registered as an unpacker."""
+    # first make sure no other unpacker is registered for this extension
+    existing_extensions = {}
+    for name, info in _UNPACK_FORMATS.items():
+        for ext in info[0]:
+            existing_extensions[ext] = name
+
+    for extension in extensions:
+        if extension in existing_extensions:
+            msg = '%s is already registered for "%s"'
+            raise RegistryError(msg % (extension,
+                                       existing_extensions[extension]))
+
+    if not isinstance(function, Callable):
+        raise TypeError('The registered function must be a callable')
+
+
+def register_unpack_format(name, extensions, function, extra_args=None,
+                           description=''):
+    """Registers an unpack format.
+
+    `name` is the name of the format. `extensions` is a list of extensions
+    corresponding to the format.
+
+    `function` is the callable that will be
+    used to unpack archives. The callable will receive archives to unpack.
+    If it's unable to handle an archive, it needs to raise a ReadError
+    exception.
+
+    If provided, `extra_args` is a sequence of
+    (name, value) tuples that will be passed as arguments to the callable.
+    description can be provided to describe the format, and will be returned
+    by the get_unpack_formats() function.
+    """
+    if extra_args is None:
+        extra_args = []
+    _check_unpack_options(extensions, function, extra_args)
+    _UNPACK_FORMATS[name] = extensions, function, extra_args, description
+
+def unregister_unpack_format(name):
+    """Removes the pack format from the registry."""
+    del _UNPACK_FORMATS[name]
+
+def _ensure_directory(path):
+    """Ensure that the parent directory of `path` exists"""
+    dirname = os.path.dirname(path)
+    if not os.path.isdir(dirname):
+        os.makedirs(dirname)
+
+def _unpack_zipfile(filename, extract_dir):
+    """Unpack zip `filename` to `extract_dir`
+    """
+    try:
+        import zipfile
+    except ImportError:
+        raise ReadError('zlib not supported, cannot unpack this archive.')
+
+    if not zipfile.is_zipfile(filename):
+        raise ReadError("%s is not a zip file" % filename)
+
+    zip = zipfile.ZipFile(filename)
+    try:
+        for info in zip.infolist():
+            name = info.filename
+
+            # don't extract absolute paths or ones with .. in them
+            if name.startswith('/') or '..' in name:
+                continue
+
+            target = os.path.join(extract_dir, *name.split('/'))
+            if not target:
+                continue
+
+            _ensure_directory(target)
+            if not name.endswith('/'):
+                # file
+                data = zip.read(info.filename)
+                f = open(target, 'wb')
+                try:
+                    f.write(data)
+                finally:
+                    f.close()
+                    del data
+    finally:
+        zip.close()
+
+def _unpack_tarfile(filename, extract_dir):
+    """Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`
+    """
+    try:
+        tarobj = tarfile.open(filename)
+    except tarfile.TarError:
+        raise ReadError(
+            "%s is not a compressed or uncompressed tar file" % filename)
+    try:
+        tarobj.extractall(extract_dir)
+    finally:
+        tarobj.close()
+
+_UNPACK_FORMATS = {
+    'gztar': (['.tar.gz', '.tgz'], _unpack_tarfile, [], "gzip'ed tar-file"),
+    'tar':   (['.tar'], _unpack_tarfile, [], "uncompressed tar file"),
+    'zip':   (['.zip'], _unpack_zipfile, [], "ZIP file")
+    }
+
+if _BZ2_SUPPORTED:
+    _UNPACK_FORMATS['bztar'] = (['.bz2'], _unpack_tarfile, [],
+                                "bzip2'ed tar-file")
+
+def _find_unpack_format(filename):
+    for name, info in _UNPACK_FORMATS.items():
+        for extension in info[0]:
+            if filename.endswith(extension):
+                return name
+    return None
+
+def unpack_archive(filename, extract_dir=None, format=None):
+    """Unpack an archive.
+
+    `filename` is the name of the archive.
+
+    `extract_dir` is the name of the target directory, where the archive
+    is unpacked. If not provided, the current working directory is used.
+
+    `format` is the archive format: one of "zip", "tar", or "gztar". Or any
+    other registered format. If not provided, unpack_archive will use the
+    filename extension and see if an unpacker was registered for that
+    extension.
+
+    In case none is found, a ValueError is raised.
+    """
+    if extract_dir is None:
+        extract_dir = os.getcwd()
+
+    if format is not None:
+        try:
+            format_info = _UNPACK_FORMATS[format]
+        except KeyError:
+            raise ValueError("Unknown unpack format '{0}'".format(format))
+
+        func = format_info[1]
+        func(filename, extract_dir, **dict(format_info[2]))
+    else:
+        # we need to look at the registered unpackers supported extensions
+        format = _find_unpack_format(filename)
+        if format is None:
+            raise ReadError("Unknown archive format '{0}'".format(filename))
+
+        func = _UNPACK_FORMATS[format][1]
+        kwargs = dict(_UNPACK_FORMATS[format][2])
+        func(filename, extract_dir, **kwargs)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/sysconfig.cfg b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/sysconfig.cfg
new file mode 100644
index 0000000..1746bd0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/sysconfig.cfg
@@ -0,0 +1,84 @@
+[posix_prefix]
+# Configuration directories.  Some of these come straight out of the
+# configure script.  They are for implementing the other variables, not to
+# be used directly in [resource_locations].
+confdir = /etc
+datadir = /usr/share
+libdir = /usr/lib
+statedir = /var
+# User resource directory
+local = ~/.local/{distribution.name}
+
+stdlib = {base}/lib/python{py_version_short}
+platstdlib = {platbase}/lib/python{py_version_short}
+purelib = {base}/lib/python{py_version_short}/site-packages
+platlib = {platbase}/lib/python{py_version_short}/site-packages
+include = {base}/include/python{py_version_short}{abiflags}
+platinclude = {platbase}/include/python{py_version_short}{abiflags}
+data = {base}
+
+[posix_home]
+stdlib = {base}/lib/python
+platstdlib = {base}/lib/python
+purelib = {base}/lib/python
+platlib = {base}/lib/python
+include = {base}/include/python
+platinclude = {base}/include/python
+scripts = {base}/bin
+data = {base}
+
+[nt]
+stdlib = {base}/Lib
+platstdlib = {base}/Lib
+purelib = {base}/Lib/site-packages
+platlib = {base}/Lib/site-packages
+include = {base}/Include
+platinclude = {base}/Include
+scripts = {base}/Scripts
+data = {base}
+
+[os2]
+stdlib = {base}/Lib
+platstdlib = {base}/Lib
+purelib = {base}/Lib/site-packages
+platlib = {base}/Lib/site-packages
+include = {base}/Include
+platinclude = {base}/Include
+scripts = {base}/Scripts
+data = {base}
+
+[os2_home]
+stdlib = {userbase}/lib/python{py_version_short}
+platstdlib = {userbase}/lib/python{py_version_short}
+purelib = {userbase}/lib/python{py_version_short}/site-packages
+platlib = {userbase}/lib/python{py_version_short}/site-packages
+include = {userbase}/include/python{py_version_short}
+scripts = {userbase}/bin
+data = {userbase}
+
+[nt_user]
+stdlib = {userbase}/Python{py_version_nodot}
+platstdlib = {userbase}/Python{py_version_nodot}
+purelib = {userbase}/Python{py_version_nodot}/site-packages
+platlib = {userbase}/Python{py_version_nodot}/site-packages
+include = {userbase}/Python{py_version_nodot}/Include
+scripts = {userbase}/Scripts
+data = {userbase}
+
+[posix_user]
+stdlib = {userbase}/lib/python{py_version_short}
+platstdlib = {userbase}/lib/python{py_version_short}
+purelib = {userbase}/lib/python{py_version_short}/site-packages
+platlib = {userbase}/lib/python{py_version_short}/site-packages
+include = {userbase}/include/python{py_version_short}
+scripts = {userbase}/bin
+data = {userbase}
+
+[osx_framework_user]
+stdlib = {userbase}/lib/python
+platstdlib = {userbase}/lib/python
+purelib = {userbase}/lib/python/site-packages
+platlib = {userbase}/lib/python/site-packages
+include = {userbase}/include
+scripts = {userbase}/bin
+data = {userbase}
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/sysconfig.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/sysconfig.py
new file mode 100644
index 0000000..b470a37
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/sysconfig.py
@@ -0,0 +1,786 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""Access to Python's configuration information."""
+
+import codecs
+import os
+import re
+import sys
+from os.path import pardir, realpath
+try:
+    import configparser
+except ImportError:
+    import ConfigParser as configparser
+
+
+__all__ = [
+    'get_config_h_filename',
+    'get_config_var',
+    'get_config_vars',
+    'get_makefile_filename',
+    'get_path',
+    'get_path_names',
+    'get_paths',
+    'get_platform',
+    'get_python_version',
+    'get_scheme_names',
+    'parse_config_h',
+]
+
+
+def _safe_realpath(path):
+    try:
+        return realpath(path)
+    except OSError:
+        return path
+
+
+if sys.executable:
+    _PROJECT_BASE = os.path.dirname(_safe_realpath(sys.executable))
+else:
+    # sys.executable can be empty if argv[0] has been changed and Python is
+    # unable to retrieve the real program name
+    _PROJECT_BASE = _safe_realpath(os.getcwd())
+
+if os.name == "nt" and "pcbuild" in _PROJECT_BASE[-8:].lower():
+    _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir))
+# PC/VS7.1
+if os.name == "nt" and "\\pc\\v" in _PROJECT_BASE[-10:].lower():
+    _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
+# PC/AMD64
+if os.name == "nt" and "\\pcbuild\\amd64" in _PROJECT_BASE[-14:].lower():
+    _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
+
+
+def is_python_build():
+    for fn in ("Setup.dist", "Setup.local"):
+        if os.path.isfile(os.path.join(_PROJECT_BASE, "Modules", fn)):
+            return True
+    return False
+
+_PYTHON_BUILD = is_python_build()
+
+_cfg_read = False
+
+def _ensure_cfg_read():
+    global _cfg_read
+    if not _cfg_read:
+        from ..resources import finder
+        backport_package = __name__.rsplit('.', 1)[0]
+        _finder = finder(backport_package)
+        _cfgfile = _finder.find('sysconfig.cfg')
+        assert _cfgfile, 'sysconfig.cfg exists'
+        with _cfgfile.as_stream() as s:
+            _SCHEMES.readfp(s)
+        if _PYTHON_BUILD:
+            for scheme in ('posix_prefix', 'posix_home'):
+                _SCHEMES.set(scheme, 'include', '{srcdir}/Include')
+                _SCHEMES.set(scheme, 'platinclude', '{projectbase}/.')
+
+        _cfg_read = True
+
+
+_SCHEMES = configparser.RawConfigParser()
+_VAR_REPL = re.compile(r'\{([^{]*?)\}')
+
+def _expand_globals(config):
+    _ensure_cfg_read()
+    if config.has_section('globals'):
+        globals = config.items('globals')
+    else:
+        globals = tuple()
+
+    sections = config.sections()
+    for section in sections:
+        if section == 'globals':
+            continue
+        for option, value in globals:
+            if config.has_option(section, option):
+                continue
+            config.set(section, option, value)
+    config.remove_section('globals')
+
+    # now expanding local variables defined in the cfg file
+    #
+    for section in config.sections():
+        variables = dict(config.items(section))
+
+        def _replacer(matchobj):
+            name = matchobj.group(1)
+            if name in variables:
+                return variables[name]
+            return matchobj.group(0)
+
+        for option, value in config.items(section):
+            config.set(section, option, _VAR_REPL.sub(_replacer, value))
+
+#_expand_globals(_SCHEMES)
+
+_PY_VERSION = '%s.%s.%s' % sys.version_info[:3]
+_PY_VERSION_SHORT = '%s.%s' % sys.version_info[:2]
+_PY_VERSION_SHORT_NO_DOT = '%s%s' % sys.version_info[:2]
+_PREFIX = os.path.normpath(sys.prefix)
+_EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
+_CONFIG_VARS = None
+_USER_BASE = None
+
+
+def _subst_vars(path, local_vars):
+    """In the string `path`, replace tokens like {some.thing} with the
+    corresponding value from the map `local_vars`.
+
+    If there is no corresponding value, leave the token unchanged.
+    """
+    def _replacer(matchobj):
+        name = matchobj.group(1)
+        if name in local_vars:
+            return local_vars[name]
+        elif name in os.environ:
+            return os.environ[name]
+        return matchobj.group(0)
+    return _VAR_REPL.sub(_replacer, path)
+
+
+def _extend_dict(target_dict, other_dict):
+    target_keys = target_dict.keys()
+    for key, value in other_dict.items():
+        if key in target_keys:
+            continue
+        target_dict[key] = value
+
+
+def _expand_vars(scheme, vars):
+    res = {}
+    if vars is None:
+        vars = {}
+    _extend_dict(vars, get_config_vars())
+
+    for key, value in _SCHEMES.items(scheme):
+        if os.name in ('posix', 'nt'):
+            value = os.path.expanduser(value)
+        res[key] = os.path.normpath(_subst_vars(value, vars))
+    return res
+
+
+def format_value(value, vars):
+    def _replacer(matchobj):
+        name = matchobj.group(1)
+        if name in vars:
+            return vars[name]
+        return matchobj.group(0)
+    return _VAR_REPL.sub(_replacer, value)
+
+
+def _get_default_scheme():
+    if os.name == 'posix':
+        # the default scheme for posix is posix_prefix
+        return 'posix_prefix'
+    return os.name
+
+
+def _getuserbase():
+    env_base = os.environ.get("PYTHONUSERBASE", None)
+
+    def joinuser(*args):
+        return os.path.expanduser(os.path.join(*args))
+
+    # what about 'os2emx', 'riscos' ?
+    if os.name == "nt":
+        base = os.environ.get("APPDATA") or "~"
+        if env_base:
+            return env_base
+        else:
+            return joinuser(base, "Python")
+
+    if sys.platform == "darwin":
+        framework = get_config_var("PYTHONFRAMEWORK")
+        if framework:
+            if env_base:
+                return env_base
+            else:
+                return joinuser("~", "Library", framework, "%d.%d" %
+                                sys.version_info[:2])
+
+    if env_base:
+        return env_base
+    else:
+        return joinuser("~", ".local")
+
+
+def _parse_makefile(filename, vars=None):
+    """Parse a Makefile-style file.
+
+    A dictionary containing name/value pairs is returned.  If an
+    optional dictionary is passed in as the second argument, it is
+    used instead of a new dictionary.
+    """
+    # Regexes needed for parsing Makefile (and similar syntaxes,
+    # like old-style Setup files).
+    _variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
+    _findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
+    _findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
+
+    if vars is None:
+        vars = {}
+    done = {}
+    notdone = {}
+
+    with codecs.open(filename, encoding='utf-8', errors="surrogateescape") as f:
+        lines = f.readlines()
+
+    for line in lines:
+        if line.startswith('#') or line.strip() == '':
+            continue
+        m = _variable_rx.match(line)
+        if m:
+            n, v = m.group(1, 2)
+            v = v.strip()
+            # `$$' is a literal `$' in make
+            tmpv = v.replace('$$', '')
+
+            if "$" in tmpv:
+                notdone[n] = v
+            else:
+                try:
+                    v = int(v)
+                except ValueError:
+                    # insert literal `$'
+                    done[n] = v.replace('$$', '$')
+                else:
+                    done[n] = v
+
+    # do variable interpolation here
+    variables = list(notdone.keys())
+
+    # Variables with a 'PY_' prefix in the makefile. These need to
+    # be made available without that prefix through sysconfig.
+    # Special care is needed to ensure that variable expansion works, even
+    # if the expansion uses the name without a prefix.
+    renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')
+
+    while len(variables) > 0:
+        for name in tuple(variables):
+            value = notdone[name]
+            m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
+            if m is not None:
+                n = m.group(1)
+                found = True
+                if n in done:
+                    item = str(done[n])
+                elif n in notdone:
+                    # get it on a subsequent round
+                    found = False
+                elif n in os.environ:
+                    # do it like make: fall back to environment
+                    item = os.environ[n]
+
+                elif n in renamed_variables:
+                    if (name.startswith('PY_') and
+                        name[3:] in renamed_variables):
+                        item = ""
+
+                    elif 'PY_' + n in notdone:
+                        found = False
+
+                    else:
+                        item = str(done['PY_' + n])
+
+                else:
+                    done[n] = item = ""
+
+                if found:
+                    after = value[m.end():]
+                    value = value[:m.start()] + item + after
+                    if "$" in after:
+                        notdone[name] = value
+                    else:
+                        try:
+                            value = int(value)
+                        except ValueError:
+                            done[name] = value.strip()
+                        else:
+                            done[name] = value
+                        variables.remove(name)
+
+                        if (name.startswith('PY_') and
+                            name[3:] in renamed_variables):
+
+                            name = name[3:]
+                            if name not in done:
+                                done[name] = value
+
+            else:
+                # bogus variable reference (e.g. "prefix=$/opt/python");
+                # just drop it since we can't deal
+                done[name] = value
+                variables.remove(name)
+
+    # strip spurious spaces
+    for k, v in done.items():
+        if isinstance(v, str):
+            done[k] = v.strip()
+
+    # save the results in the global dictionary
+    vars.update(done)
+    return vars
+
+
+def get_makefile_filename():
+    """Return the path of the Makefile."""
+    if _PYTHON_BUILD:
+        return os.path.join(_PROJECT_BASE, "Makefile")
+    if hasattr(sys, 'abiflags'):
+        config_dir_name = 'config-%s%s' % (_PY_VERSION_SHORT, sys.abiflags)
+    else:
+        config_dir_name = 'config'
+    return os.path.join(get_path('stdlib'), config_dir_name, 'Makefile')
+
+
+def _init_posix(vars):
+    """Initialize the module as appropriate for POSIX systems."""
+    # load the installed Makefile:
+    makefile = get_makefile_filename()
+    try:
+        _parse_makefile(makefile, vars)
+    except IOError as e:
+        msg = "invalid Python installation: unable to open %s" % makefile
+        if hasattr(e, "strerror"):
+            msg = msg + " (%s)" % e.strerror
+        raise IOError(msg)
+    # load the installed pyconfig.h:
+    config_h = get_config_h_filename()
+    try:
+        with open(config_h) as f:
+            parse_config_h(f, vars)
+    except IOError as e:
+        msg = "invalid Python installation: unable to open %s" % config_h
+        if hasattr(e, "strerror"):
+            msg = msg + " (%s)" % e.strerror
+        raise IOError(msg)
+    # On AIX, there are wrong paths to the linker scripts in the Makefile
+    # -- these paths are relative to the Python source, but when installed
+    # the scripts are in another directory.
+    if _PYTHON_BUILD:
+        vars['LDSHARED'] = vars['BLDSHARED']
+
+
+def _init_non_posix(vars):
+    """Initialize the module as appropriate for NT"""
+    # set basic install directories
+    vars['LIBDEST'] = get_path('stdlib')
+    vars['BINLIBDEST'] = get_path('platstdlib')
+    vars['INCLUDEPY'] = get_path('include')
+    vars['SO'] = '.pyd'
+    vars['EXE'] = '.exe'
+    vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT
+    vars['BINDIR'] = os.path.dirname(_safe_realpath(sys.executable))
+
+#
+# public APIs
+#
+
+
+def parse_config_h(fp, vars=None):
+    """Parse a config.h-style file.
+
+    A dictionary containing name/value pairs is returned.  If an
+    optional dictionary is passed in as the second argument, it is
+    used instead of a new dictionary.
+    """
+    if vars is None:
+        vars = {}
+    define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
+    undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
+
+    while True:
+        line = fp.readline()
+        if not line:
+            break
+        m = define_rx.match(line)
+        if m:
+            n, v = m.group(1, 2)
+            try:
+                v = int(v)
+            except ValueError:
+                pass
+            vars[n] = v
+        else:
+            m = undef_rx.match(line)
+            if m:
+                vars[m.group(1)] = 0
+    return vars
+
+
+def get_config_h_filename():
+    """Return the path of pyconfig.h."""
+    if _PYTHON_BUILD:
+        if os.name == "nt":
+            inc_dir = os.path.join(_PROJECT_BASE, "PC")
+        else:
+            inc_dir = _PROJECT_BASE
+    else:
+        inc_dir = get_path('platinclude')
+    return os.path.join(inc_dir, 'pyconfig.h')
+
+
+def get_scheme_names():
+    """Return a tuple containing the schemes names."""
+    return tuple(sorted(_SCHEMES.sections()))
+
+
+def get_path_names():
+    """Return a tuple containing the paths names."""
+    # xxx see if we want a static list
+    return _SCHEMES.options('posix_prefix')
+
+
+def get_paths(scheme=_get_default_scheme(), vars=None, expand=True):
+    """Return a mapping containing an install scheme.
+
+    ``scheme`` is the install scheme name. If not provided, it will
+    return the default scheme for the current platform.
+    """
+    _ensure_cfg_read()
+    if expand:
+        return _expand_vars(scheme, vars)
+    else:
+        return dict(_SCHEMES.items(scheme))
+
+
+def get_path(name, scheme=_get_default_scheme(), vars=None, expand=True):
+    """Return a path corresponding to the scheme.
+
+    ``scheme`` is the install scheme name.
+    """
+    return get_paths(scheme, vars, expand)[name]
+
+
+def get_config_vars(*args):
+    """With no arguments, return a dictionary of all configuration
+    variables relevant for the current platform.
+
+    On Unix, this means every variable defined in Python's installed Makefile;
+    On Windows and Mac OS it's a much smaller set.
+
+    With arguments, return a list of values that result from looking up
+    each argument in the configuration variable dictionary.
+    """
+    global _CONFIG_VARS
+    if _CONFIG_VARS is None:
+        _CONFIG_VARS = {}
+        # Normalized versions of prefix and exec_prefix are handy to have;
+        # in fact, these are the standard versions used most places in the
+        # distutils2 module.
+        _CONFIG_VARS['prefix'] = _PREFIX
+        _CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX
+        _CONFIG_VARS['py_version'] = _PY_VERSION
+        _CONFIG_VARS['py_version_short'] = _PY_VERSION_SHORT
+        _CONFIG_VARS['py_version_nodot'] = _PY_VERSION[0] + _PY_VERSION[2]
+        _CONFIG_VARS['base'] = _PREFIX
+        _CONFIG_VARS['platbase'] = _EXEC_PREFIX
+        _CONFIG_VARS['projectbase'] = _PROJECT_BASE
+        try:
+            _CONFIG_VARS['abiflags'] = sys.abiflags
+        except AttributeError:
+            # sys.abiflags may not be defined on all platforms.
+            _CONFIG_VARS['abiflags'] = ''
+
+        if os.name in ('nt', 'os2'):
+            _init_non_posix(_CONFIG_VARS)
+        if os.name == 'posix':
+            _init_posix(_CONFIG_VARS)
+        # Setting 'userbase' is done below the call to the
+        # init function to enable using 'get_config_var' in
+        # the init-function.
+        if sys.version >= '2.6':
+            _CONFIG_VARS['userbase'] = _getuserbase()
+
+        if 'srcdir' not in _CONFIG_VARS:
+            _CONFIG_VARS['srcdir'] = _PROJECT_BASE
+        else:
+            _CONFIG_VARS['srcdir'] = _safe_realpath(_CONFIG_VARS['srcdir'])
+
+        # Convert srcdir into an absolute path if it appears necessary.
+        # Normally it is relative to the build directory.  However, during
+        # testing, for example, we might be running a non-installed python
+        # from a different directory.
+        if _PYTHON_BUILD and os.name == "posix":
+            base = _PROJECT_BASE
+            try:
+                cwd = os.getcwd()
+            except OSError:
+                cwd = None
+            if (not os.path.isabs(_CONFIG_VARS['srcdir']) and
+                base != cwd):
+                # srcdir is relative and we are not in the same directory
+                # as the executable. Assume executable is in the build
+                # directory and make srcdir absolute.
+                srcdir = os.path.join(base, _CONFIG_VARS['srcdir'])
+                _CONFIG_VARS['srcdir'] = os.path.normpath(srcdir)
+
+        if sys.platform == 'darwin':
+            kernel_version = os.uname()[2]  # Kernel version (8.4.3)
+            major_version = int(kernel_version.split('.')[0])
+
+            if major_version < 8:
+                # On Mac OS X before 10.4, check if -arch and -isysroot
+                # are in CFLAGS or LDFLAGS and remove them if they are.
+                # This is needed when building extensions on a 10.3 system
+                # using a universal build of python.
+                for key in ('LDFLAGS', 'BASECFLAGS',
+                        # a number of derived variables. These need to be
+                        # patched up as well.
+                        'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
+                    flags = _CONFIG_VARS[key]
+                    flags = re.sub(r'-arch\s+\w+\s', ' ', flags)
+                    flags = re.sub('-isysroot [^ \t]*', ' ', flags)
+                    _CONFIG_VARS[key] = flags
+            else:
+                # Allow the user to override the architecture flags using
+                # an environment variable.
+                # NOTE: This name was introduced by Apple in OSX 10.5 and
+                # is used by several scripting languages distributed with
+                # that OS release.
+                if 'ARCHFLAGS' in os.environ:
+                    arch = os.environ['ARCHFLAGS']
+                    for key in ('LDFLAGS', 'BASECFLAGS',
+                        # a number of derived variables. These need to be
+                        # patched up as well.
+                        'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
+
+                        flags = _CONFIG_VARS[key]
+                        flags = re.sub(r'-arch\s+\w+\s', ' ', flags)
+                        flags = flags + ' ' + arch
+                        _CONFIG_VARS[key] = flags
+
+                # If we're on OSX 10.5 or later and the user tries to
+                # compiles an extension using an SDK that is not present
+                # on the current machine it is better to not use an SDK
+                # than to fail.
+                #
+                # The major usecase for this is users using a Python.org
+                # binary installer  on OSX 10.6: that installer uses
+                # the 10.4u SDK, but that SDK is not installed by default
+                # when you install Xcode.
+                #
+                CFLAGS = _CONFIG_VARS.get('CFLAGS', '')
+                m = re.search(r'-isysroot\s+(\S+)', CFLAGS)
+                if m is not None:
+                    sdk = m.group(1)
+                    if not os.path.exists(sdk):
+                        for key in ('LDFLAGS', 'BASECFLAGS',
+                             # a number of derived variables. These need to be
+                             # patched up as well.
+                            'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
+
+                            flags = _CONFIG_VARS[key]
+                            flags = re.sub(r'-isysroot\s+\S+(\s|$)', ' ', flags)
+                            _CONFIG_VARS[key] = flags
+
+    if args:
+        vals = []
+        for name in args:
+            vals.append(_CONFIG_VARS.get(name))
+        return vals
+    else:
+        return _CONFIG_VARS
+
+
+def get_config_var(name):
+    """Return the value of a single variable using the dictionary returned by
+    'get_config_vars()'.
+
+    Equivalent to get_config_vars().get(name)
+    """
+    return get_config_vars().get(name)
+
+
+def get_platform():
+    """Return a string that identifies the current platform.
+
+    This is used mainly to distinguish platform-specific build directories and
+    platform-specific built distributions.  Typically includes the OS name
+    and version and the architecture (as supplied by 'os.uname()'),
+    although the exact information included depends on the OS; eg. for IRIX
+    the architecture isn't particularly important (IRIX only runs on SGI
+    hardware), but for Linux the kernel version isn't particularly
+    important.
+
+    Examples of returned values:
+       linux-i586
+       linux-alpha (?)
+       solaris-2.6-sun4u
+       irix-5.3
+       irix64-6.2
+
+    Windows will return one of:
+       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
+       win-ia64 (64bit Windows on Itanium)
+       win32 (all others - specifically, sys.platform is returned)
+
+    For other non-POSIX platforms, currently just returns 'sys.platform'.
+    """
+    if os.name == 'nt':
+        # sniff sys.version for architecture.
+        prefix = " bit ("
+        i = sys.version.find(prefix)
+        if i == -1:
+            return sys.platform
+        j = sys.version.find(")", i)
+        look = sys.version[i+len(prefix):j].lower()
+        if look == 'amd64':
+            return 'win-amd64'
+        if look == 'itanium':
+            return 'win-ia64'
+        return sys.platform
+
+    if os.name != "posix" or not hasattr(os, 'uname'):
+        # XXX what about the architecture? NT is Intel or Alpha,
+        # Mac OS is M68k or PPC, etc.
+        return sys.platform
+
+    # Try to distinguish various flavours of Unix
+    osname, host, release, version, machine = os.uname()
+
+    # Convert the OS name to lowercase, remove '/' characters
+    # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
+    osname = osname.lower().replace('/', '')
+    machine = machine.replace(' ', '_')
+    machine = machine.replace('/', '-')
+
+    if osname[:5] == "linux":
+        # At least on Linux/Intel, 'machine' is the processor --
+        # i386, etc.
+        # XXX what about Alpha, SPARC, etc?
+        return  "%s-%s" % (osname, machine)
+    elif osname[:5] == "sunos":
+        if release[0] >= "5":           # SunOS 5 == Solaris 2
+            osname = "solaris"
+            release = "%d.%s" % (int(release[0]) - 3, release[2:])
+        # fall through to standard osname-release-machine representation
+    elif osname[:4] == "irix":              # could be "irix64"!
+        return "%s-%s" % (osname, release)
+    elif osname[:3] == "aix":
+        return "%s-%s.%s" % (osname, version, release)
+    elif osname[:6] == "cygwin":
+        osname = "cygwin"
+        rel_re = re.compile(r'[\d.]+')
+        m = rel_re.match(release)
+        if m:
+            release = m.group()
+    elif osname[:6] == "darwin":
+        #
+        # For our purposes, we'll assume that the system version from
+        # distutils' perspective is what MACOSX_DEPLOYMENT_TARGET is set
+        # to. This makes the compatibility story a bit more sane because the
+        # machine is going to compile and link as if it were
+        # MACOSX_DEPLOYMENT_TARGET.
+        cfgvars = get_config_vars()
+        macver = cfgvars.get('MACOSX_DEPLOYMENT_TARGET')
+
+        if True:
+            # Always calculate the release of the running machine,
+            # needed to determine if we can build fat binaries or not.
+
+            macrelease = macver
+            # Get the system version. Reading this plist is a documented
+            # way to get the system version (see the documentation for
+            # the Gestalt Manager)
+            try:
+                f = open('/System/Library/CoreServices/SystemVersion.plist')
+            except IOError:
+                # We're on a plain darwin box, fall back to the default
+                # behaviour.
+                pass
+            else:
+                try:
+                    m = re.search(r'<key>ProductUserVisibleVersion</key>\s*'
+                                  r'<string>(.*?)</string>', f.read())
+                finally:
+                    f.close()
+                if m is not None:
+                    macrelease = '.'.join(m.group(1).split('.')[:2])
+                # else: fall back to the default behaviour
+
+        if not macver:
+            macver = macrelease
+
+        if macver:
+            release = macver
+            osname = "macosx"
+
+            if ((macrelease + '.') >= '10.4.' and
+                '-arch' in get_config_vars().get('CFLAGS', '').strip()):
+                # The universal build will build fat binaries, but not on
+                # systems before 10.4
+                #
+                # Try to detect 4-way universal builds, those have machine-type
+                # 'universal' instead of 'fat'.
+
+                machine = 'fat'
+                cflags = get_config_vars().get('CFLAGS')
+
+                archs = re.findall(r'-arch\s+(\S+)', cflags)
+                archs = tuple(sorted(set(archs)))
+
+                if len(archs) == 1:
+                    machine = archs[0]
+                elif archs == ('i386', 'ppc'):
+                    machine = 'fat'
+                elif archs == ('i386', 'x86_64'):
+                    machine = 'intel'
+                elif archs == ('i386', 'ppc', 'x86_64'):
+                    machine = 'fat3'
+                elif archs == ('ppc64', 'x86_64'):
+                    machine = 'fat64'
+                elif archs == ('i386', 'ppc', 'ppc64', 'x86_64'):
+                    machine = 'universal'
+                else:
+                    raise ValueError(
+                       "Don't know machine value for archs=%r" % (archs,))
+
+            elif machine == 'i386':
+                # On OSX the machine type returned by uname is always the
+                # 32-bit variant, even if the executable architecture is
+                # the 64-bit variant
+                if sys.maxsize >= 2**32:
+                    machine = 'x86_64'
+
+            elif machine in ('PowerPC', 'Power_Macintosh'):
+                # Pick a sane name for the PPC architecture.
+                # See 'i386' case
+                if sys.maxsize >= 2**32:
+                    machine = 'ppc64'
+                else:
+                    machine = 'ppc'
+
+    return "%s-%s-%s" % (osname, release, machine)
+
+
+def get_python_version():
+    return _PY_VERSION_SHORT
+
+
+def _print_dict(title, data):
+    for index, (key, value) in enumerate(sorted(data.items())):
+        if index == 0:
+            print('%s: ' % (title))
+        print('\t%s = "%s"' % (key, value))
+
+
+def _main():
+    """Display all information sysconfig detains."""
+    print('Platform: "%s"' % get_platform())
+    print('Python version: "%s"' % get_python_version())
+    print('Current installation scheme: "%s"' % _get_default_scheme())
+    print()
+    _print_dict('Paths', get_paths())
+    print()
+    _print_dict('Variables', get_config_vars())
+
+
+if __name__ == '__main__':
+    _main()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/tarfile.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/tarfile.py
new file mode 100644
index 0000000..d66d856
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/_backport/tarfile.py
@@ -0,0 +1,2607 @@
+#-------------------------------------------------------------------
+# tarfile.py
+#-------------------------------------------------------------------
+# Copyright (C) 2002 Lars Gustaebel <lars@gustaebel.de>
+# All rights reserved.
+#
+# Permission  is  hereby granted,  free  of charge,  to  any person
+# obtaining a  copy of  this software  and associated documentation
+# files  (the  "Software"),  to   deal  in  the  Software   without
+# restriction,  including  without limitation  the  rights to  use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies  of  the  Software,  and to  permit  persons  to  whom the
+# Software  is  furnished  to  do  so,  subject  to  the  following
+# conditions:
+#
+# The above copyright  notice and this  permission notice shall  be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS  IS", WITHOUT WARRANTY OF ANY  KIND,
+# EXPRESS OR IMPLIED, INCLUDING  BUT NOT LIMITED TO  THE WARRANTIES
+# OF  MERCHANTABILITY,  FITNESS   FOR  A  PARTICULAR   PURPOSE  AND
+# NONINFRINGEMENT.  IN  NO  EVENT SHALL  THE  AUTHORS  OR COPYRIGHT
+# HOLDERS  BE LIABLE  FOR ANY  CLAIM, DAMAGES  OR OTHER  LIABILITY,
+# WHETHER  IN AN  ACTION OF  CONTRACT, TORT  OR OTHERWISE,  ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+from __future__ import print_function
+
+"""Read from and write to tar format archives.
+"""
+
+__version__ = "$Revision$"
+
+version     = "0.9.0"
+__author__  = "Lars Gust\u00e4bel (lars@gustaebel.de)"
+__date__    = "$Date: 2011-02-25 17:42:01 +0200 (Fri, 25 Feb 2011) $"
+__cvsid__   = "$Id: tarfile.py 88586 2011-02-25 15:42:01Z marc-andre.lemburg $"
+__credits__ = "Gustavo Niemeyer, Niels Gust\u00e4bel, Richard Townsend."
+
+#---------
+# Imports
+#---------
+import sys
+import os
+import stat
+import errno
+import time
+import struct
+import copy
+import re
+
+try:
+    import grp, pwd
+except ImportError:
+    grp = pwd = None
+
+# os.symlink on Windows prior to 6.0 raises NotImplementedError
+symlink_exception = (AttributeError, NotImplementedError)
+try:
+    # WindowsError (1314) will be raised if the caller does not hold the
+    # SeCreateSymbolicLinkPrivilege privilege
+    symlink_exception += (WindowsError,)
+except NameError:
+    pass
+
+# from tarfile import *
+__all__ = ["TarFile", "TarInfo", "is_tarfile", "TarError"]
+
+if sys.version_info[0] < 3:
+    import __builtin__ as builtins
+else:
+    import builtins
+
+_open = builtins.open   # Since 'open' is TarFile.open
+
+#---------------------------------------------------------
+# tar constants
+#---------------------------------------------------------
+NUL = b"\0"                     # the null character
+BLOCKSIZE = 512                 # length of processing blocks
+RECORDSIZE = BLOCKSIZE * 20     # length of records
+GNU_MAGIC = b"ustar  \0"        # magic gnu tar string
+POSIX_MAGIC = b"ustar\x0000"    # magic posix tar string
+
+LENGTH_NAME = 100               # maximum length of a filename
+LENGTH_LINK = 100               # maximum length of a linkname
+LENGTH_PREFIX = 155             # maximum length of the prefix field
+
+REGTYPE = b"0"                  # regular file
+AREGTYPE = b"\0"                # regular file
+LNKTYPE = b"1"                  # link (inside tarfile)
+SYMTYPE = b"2"                  # symbolic link
+CHRTYPE = b"3"                  # character special device
+BLKTYPE = b"4"                  # block special device
+DIRTYPE = b"5"                  # directory
+FIFOTYPE = b"6"                 # fifo special device
+CONTTYPE = b"7"                 # contiguous file
+
+GNUTYPE_LONGNAME = b"L"         # GNU tar longname
+GNUTYPE_LONGLINK = b"K"         # GNU tar longlink
+GNUTYPE_SPARSE = b"S"           # GNU tar sparse file
+
+XHDTYPE = b"x"                  # POSIX.1-2001 extended header
+XGLTYPE = b"g"                  # POSIX.1-2001 global header
+SOLARIS_XHDTYPE = b"X"          # Solaris extended header
+
+USTAR_FORMAT = 0                # POSIX.1-1988 (ustar) format
+GNU_FORMAT = 1                  # GNU tar format
+PAX_FORMAT = 2                  # POSIX.1-2001 (pax) format
+DEFAULT_FORMAT = GNU_FORMAT
+
+#---------------------------------------------------------
+# tarfile constants
+#---------------------------------------------------------
+# File types that tarfile supports:
+SUPPORTED_TYPES = (REGTYPE, AREGTYPE, LNKTYPE,
+                   SYMTYPE, DIRTYPE, FIFOTYPE,
+                   CONTTYPE, CHRTYPE, BLKTYPE,
+                   GNUTYPE_LONGNAME, GNUTYPE_LONGLINK,
+                   GNUTYPE_SPARSE)
+
+# File types that will be treated as a regular file.
+REGULAR_TYPES = (REGTYPE, AREGTYPE,
+                 CONTTYPE, GNUTYPE_SPARSE)
+
+# File types that are part of the GNU tar format.
+GNU_TYPES = (GNUTYPE_LONGNAME, GNUTYPE_LONGLINK,
+             GNUTYPE_SPARSE)
+
+# Fields from a pax header that override a TarInfo attribute.
+PAX_FIELDS = ("path", "linkpath", "size", "mtime",
+              "uid", "gid", "uname", "gname")
+
+# Fields from a pax header that are affected by hdrcharset.
+PAX_NAME_FIELDS = set(("path", "linkpath", "uname", "gname"))
+
+# Fields in a pax header that are numbers, all other fields
+# are treated as strings.
+PAX_NUMBER_FIELDS = {
+    "atime": float,
+    "ctime": float,
+    "mtime": float,
+    "uid": int,
+    "gid": int,
+    "size": int
+}
+
+#---------------------------------------------------------
+# Bits used in the mode field, values in octal.
+#---------------------------------------------------------
+S_IFLNK = 0o120000        # symbolic link
+S_IFREG = 0o100000        # regular file
+S_IFBLK = 0o060000        # block device
+S_IFDIR = 0o040000        # directory
+S_IFCHR = 0o020000        # character device
+S_IFIFO = 0o010000        # fifo
+
+TSUID   = 0o4000          # set UID on execution
+TSGID   = 0o2000          # set GID on execution
+TSVTX   = 0o1000          # reserved
+
+TUREAD  = 0o400           # read by owner
+TUWRITE = 0o200           # write by owner
+TUEXEC  = 0o100           # execute/search by owner
+TGREAD  = 0o040           # read by group
+TGWRITE = 0o020           # write by group
+TGEXEC  = 0o010           # execute/search by group
+TOREAD  = 0o004           # read by other
+TOWRITE = 0o002           # write by other
+TOEXEC  = 0o001           # execute/search by other
+
+#---------------------------------------------------------
+# initialization
+#---------------------------------------------------------
+if os.name in ("nt", "ce"):
+    ENCODING = "utf-8"
+else:
+    ENCODING = sys.getfilesystemencoding()
+
+#---------------------------------------------------------
+# Some useful functions
+#---------------------------------------------------------
+
+def stn(s, length, encoding, errors):
+    """Convert a string to a null-terminated bytes object.
+    """
+    s = s.encode(encoding, errors)
+    return s[:length] + (length - len(s)) * NUL
+
+def nts(s, encoding, errors):
+    """Convert a null-terminated bytes object to a string.
+    """
+    p = s.find(b"\0")
+    if p != -1:
+        s = s[:p]
+    return s.decode(encoding, errors)
+
+def nti(s):
+    """Convert a number field to a python number.
+    """
+    # There are two possible encodings for a number field, see
+    # itn() below.
+    if s[0] != chr(0o200):
+        try:
+            n = int(nts(s, "ascii", "strict") or "0", 8)
+        except ValueError:
+            raise InvalidHeaderError("invalid header")
+    else:
+        n = 0
+        for i in range(len(s) - 1):
+            n <<= 8
+            n += ord(s[i + 1])
+    return n
+
+def itn(n, digits=8, format=DEFAULT_FORMAT):
+    """Convert a python number to a number field.
+    """
+    # POSIX 1003.1-1988 requires numbers to be encoded as a string of
+    # octal digits followed by a null-byte, this allows values up to
+    # (8**(digits-1))-1. GNU tar allows storing numbers greater than
+    # that if necessary. A leading 0o200 byte indicates this particular
+    # encoding, the following digits-1 bytes are a big-endian
+    # representation. This allows values up to (256**(digits-1))-1.
+    if 0 <= n < 8 ** (digits - 1):
+        s = ("%0*o" % (digits - 1, n)).encode("ascii") + NUL
+    else:
+        if format != GNU_FORMAT or n >= 256 ** (digits - 1):
+            raise ValueError("overflow in number field")
+
+        if n < 0:
+            # XXX We mimic GNU tar's behaviour with negative numbers,
+            # this could raise OverflowError.
+            n = struct.unpack("L", struct.pack("l", n))[0]
+
+        s = bytearray()
+        for i in range(digits - 1):
+            s.insert(0, n & 0o377)
+            n >>= 8
+        s.insert(0, 0o200)
+    return s
+
+def calc_chksums(buf):
+    """Calculate the checksum for a member's header by summing up all
+       characters except for the chksum field which is treated as if
+       it was filled with spaces. According to the GNU tar sources,
+       some tars (Sun and NeXT) calculate chksum with signed char,
+       which will be different if there are chars in the buffer with
+       the high bit set. So we calculate two checksums, unsigned and
+       signed.
+    """
+    unsigned_chksum = 256 + sum(struct.unpack("148B", buf[:148]) + struct.unpack("356B", buf[156:512]))
+    signed_chksum = 256 + sum(struct.unpack("148b", buf[:148]) + struct.unpack("356b", buf[156:512]))
+    return unsigned_chksum, signed_chksum
+
+def copyfileobj(src, dst, length=None):
+    """Copy length bytes from fileobj src to fileobj dst.
+       If length is None, copy the entire content.
+    """
+    if length == 0:
+        return
+    if length is None:
+        while True:
+            buf = src.read(16*1024)
+            if not buf:
+                break
+            dst.write(buf)
+        return
+
+    BUFSIZE = 16 * 1024
+    blocks, remainder = divmod(length, BUFSIZE)
+    for b in range(blocks):
+        buf = src.read(BUFSIZE)
+        if len(buf) < BUFSIZE:
+            raise IOError("end of file reached")
+        dst.write(buf)
+
+    if remainder != 0:
+        buf = src.read(remainder)
+        if len(buf) < remainder:
+            raise IOError("end of file reached")
+        dst.write(buf)
+    return
+
+filemode_table = (
+    ((S_IFLNK,      "l"),
+     (S_IFREG,      "-"),
+     (S_IFBLK,      "b"),
+     (S_IFDIR,      "d"),
+     (S_IFCHR,      "c"),
+     (S_IFIFO,      "p")),
+
+    ((TUREAD,       "r"),),
+    ((TUWRITE,      "w"),),
+    ((TUEXEC|TSUID, "s"),
+     (TSUID,        "S"),
+     (TUEXEC,       "x")),
+
+    ((TGREAD,       "r"),),
+    ((TGWRITE,      "w"),),
+    ((TGEXEC|TSGID, "s"),
+     (TSGID,        "S"),
+     (TGEXEC,       "x")),
+
+    ((TOREAD,       "r"),),
+    ((TOWRITE,      "w"),),
+    ((TOEXEC|TSVTX, "t"),
+     (TSVTX,        "T"),
+     (TOEXEC,       "x"))
+)
+
+def filemode(mode):
+    """Convert a file's mode to a string of the form
+       -rwxrwxrwx.
+       Used by TarFile.list()
+    """
+    perm = []
+    for table in filemode_table:
+        for bit, char in table:
+            if mode & bit == bit:
+                perm.append(char)
+                break
+        else:
+            perm.append("-")
+    return "".join(perm)
+
+class TarError(Exception):
+    """Base exception."""
+    pass
+class ExtractError(TarError):
+    """General exception for extract errors."""
+    pass
+class ReadError(TarError):
+    """Exception for unreadable tar archives."""
+    pass
+class CompressionError(TarError):
+    """Exception for unavailable compression methods."""
+    pass
+class StreamError(TarError):
+    """Exception for unsupported operations on stream-like TarFiles."""
+    pass
+class HeaderError(TarError):
+    """Base exception for header errors."""
+    pass
+class EmptyHeaderError(HeaderError):
+    """Exception for empty headers."""
+    pass
+class TruncatedHeaderError(HeaderError):
+    """Exception for truncated headers."""
+    pass
+class EOFHeaderError(HeaderError):
+    """Exception for end of file headers."""
+    pass
+class InvalidHeaderError(HeaderError):
+    """Exception for invalid headers."""
+    pass
+class SubsequentHeaderError(HeaderError):
+    """Exception for missing and invalid extended headers."""
+    pass
+
+#---------------------------
+# internal stream interface
+#---------------------------
+class _LowLevelFile(object):
+    """Low-level file object. Supports reading and writing.
+       It is used instead of a regular file object for streaming
+       access.
+    """
+
+    def __init__(self, name, mode):
+        mode = {
+            "r": os.O_RDONLY,
+            "w": os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+        }[mode]
+        if hasattr(os, "O_BINARY"):
+            mode |= os.O_BINARY
+        self.fd = os.open(name, mode, 0o666)
+
+    def close(self):
+        os.close(self.fd)
+
+    def read(self, size):
+        return os.read(self.fd, size)
+
+    def write(self, s):
+        os.write(self.fd, s)
+
+class _Stream(object):
+    """Class that serves as an adapter between TarFile and
+       a stream-like object.  The stream-like object only
+       needs to have a read() or write() method and is accessed
+       blockwise.  Use of gzip or bzip2 compression is possible.
+       A stream-like object could be for example: sys.stdin,
+       sys.stdout, a socket, a tape device etc.
+
+       _Stream is intended to be used only internally.
+    """
+
+    def __init__(self, name, mode, comptype, fileobj, bufsize):
+        """Construct a _Stream object.
+        """
+        self._extfileobj = True
+        if fileobj is None:
+            fileobj = _LowLevelFile(name, mode)
+            self._extfileobj = False
+
+        if comptype == '*':
+            # Enable transparent compression detection for the
+            # stream interface
+            fileobj = _StreamProxy(fileobj)
+            comptype = fileobj.getcomptype()
+
+        self.name     = name or ""
+        self.mode     = mode
+        self.comptype = comptype
+        self.fileobj  = fileobj
+        self.bufsize  = bufsize
+        self.buf      = b""
+        self.pos      = 0
+        self.closed   = False
+
+        try:
+            if comptype == "gz":
+                try:
+                    import zlib
+                except ImportError:
+                    raise CompressionError("zlib module is not available")
+                self.zlib = zlib
+                self.crc = zlib.crc32(b"")
+                if mode == "r":
+                    self._init_read_gz()
+                else:
+                    self._init_write_gz()
+
+            if comptype == "bz2":
+                try:
+                    import bz2
+                except ImportError:
+                    raise CompressionError("bz2 module is not available")
+                if mode == "r":
+                    self.dbuf = b""
+                    self.cmp = bz2.BZ2Decompressor()
+                else:
+                    self.cmp = bz2.BZ2Compressor()
+        except:
+            if not self._extfileobj:
+                self.fileobj.close()
+            self.closed = True
+            raise
+
+    def __del__(self):
+        if hasattr(self, "closed") and not self.closed:
+            self.close()
+
+    def _init_write_gz(self):
+        """Initialize for writing with gzip compression.
+        """
+        self.cmp = self.zlib.compressobj(9, self.zlib.DEFLATED,
+                                            -self.zlib.MAX_WBITS,
+                                            self.zlib.DEF_MEM_LEVEL,
+                                            0)
+        timestamp = struct.pack("<L", int(time.time()))
+        self.__write(b"\037\213\010\010" + timestamp + b"\002\377")
+        if self.name.endswith(".gz"):
+            self.name = self.name[:-3]
+        # RFC1952 says we must use ISO-8859-1 for the FNAME field.
+        self.__write(self.name.encode("iso-8859-1", "replace") + NUL)
+
+    def write(self, s):
+        """Write string s to the stream.
+        """
+        if self.comptype == "gz":
+            self.crc = self.zlib.crc32(s, self.crc)
+        self.pos += len(s)
+        if self.comptype != "tar":
+            s = self.cmp.compress(s)
+        self.__write(s)
+
+    def __write(self, s):
+        """Write string s to the stream if a whole new block
+           is ready to be written.
+        """
+        self.buf += s
+        while len(self.buf) > self.bufsize:
+            self.fileobj.write(self.buf[:self.bufsize])
+            self.buf = self.buf[self.bufsize:]
+
+    def close(self):
+        """Close the _Stream object. No operation should be
+           done on it afterwards.
+        """
+        if self.closed:
+            return
+
+        if self.mode == "w" and self.comptype != "tar":
+            self.buf += self.cmp.flush()
+
+        if self.mode == "w" and self.buf:
+            self.fileobj.write(self.buf)
+            self.buf = b""
+            if self.comptype == "gz":
+                # The native zlib crc is an unsigned 32-bit integer, but
+                # the Python wrapper implicitly casts that to a signed C
+                # long.  So, on a 32-bit box self.crc may "look negative",
+                # while the same crc on a 64-bit box may "look positive".
+                # To avoid irksome warnings from the `struct` module, force
+                # it to look positive on all boxes.
+                self.fileobj.write(struct.pack("<L", self.crc & 0xffffffff))
+                self.fileobj.write(struct.pack("<L", self.pos & 0xffffFFFF))
+
+        if not self._extfileobj:
+            self.fileobj.close()
+
+        self.closed = True
+
+    def _init_read_gz(self):
+        """Initialize for reading a gzip compressed fileobj.
+        """
+        self.cmp = self.zlib.decompressobj(-self.zlib.MAX_WBITS)
+        self.dbuf = b""
+
+        # taken from gzip.GzipFile with some alterations
+        if self.__read(2) != b"\037\213":
+            raise ReadError("not a gzip file")
+        if self.__read(1) != b"\010":
+            raise CompressionError("unsupported compression method")
+
+        flag = ord(self.__read(1))
+        self.__read(6)
+
+        if flag & 4:
+            xlen = ord(self.__read(1)) + 256 * ord(self.__read(1))
+            self.read(xlen)
+        if flag & 8:
+            while True:
+                s = self.__read(1)
+                if not s or s == NUL:
+                    break
+        if flag & 16:
+            while True:
+                s = self.__read(1)
+                if not s or s == NUL:
+                    break
+        if flag & 2:
+            self.__read(2)
+
+    def tell(self):
+        """Return the stream's file pointer position.
+        """
+        return self.pos
+
+    def seek(self, pos=0):
+        """Set the stream's file pointer to pos. Negative seeking
+           is forbidden.
+        """
+        if pos - self.pos >= 0:
+            blocks, remainder = divmod(pos - self.pos, self.bufsize)
+            for i in range(blocks):
+                self.read(self.bufsize)
+            self.read(remainder)
+        else:
+            raise StreamError("seeking backwards is not allowed")
+        return self.pos
+
+    def read(self, size=None):
+        """Return the next size number of bytes from the stream.
+           If size is not defined, return all bytes of the stream
+           up to EOF.
+        """
+        if size is None:
+            t = []
+            while True:
+                buf = self._read(self.bufsize)
+                if not buf:
+                    break
+                t.append(buf)
+            buf = "".join(t)
+        else:
+            buf = self._read(size)
+        self.pos += len(buf)
+        return buf
+
+    def _read(self, size):
+        """Return size bytes from the stream.
+        """
+        if self.comptype == "tar":
+            return self.__read(size)
+
+        c = len(self.dbuf)
+        while c < size:
+            buf = self.__read(self.bufsize)
+            if not buf:
+                break
+            try:
+                buf = self.cmp.decompress(buf)
+            except IOError:
+                raise ReadError("invalid compressed data")
+            self.dbuf += buf
+            c += len(buf)
+        buf = self.dbuf[:size]
+        self.dbuf = self.dbuf[size:]
+        return buf
+
+    def __read(self, size):
+        """Return size bytes from stream. If internal buffer is empty,
+           read another block from the stream.
+        """
+        c = len(self.buf)
+        while c < size:
+            buf = self.fileobj.read(self.bufsize)
+            if not buf:
+                break
+            self.buf += buf
+            c += len(buf)
+        buf = self.buf[:size]
+        self.buf = self.buf[size:]
+        return buf
+# class _Stream
+
+class _StreamProxy(object):
+    """Small proxy class that enables transparent compression
+       detection for the Stream interface (mode 'r|*').
+    """
+
+    def __init__(self, fileobj):
+        self.fileobj = fileobj
+        self.buf = self.fileobj.read(BLOCKSIZE)
+
+    def read(self, size):
+        self.read = self.fileobj.read
+        return self.buf
+
+    def getcomptype(self):
+        if self.buf.startswith(b"\037\213\010"):
+            return "gz"
+        if self.buf.startswith(b"BZh91"):
+            return "bz2"
+        return "tar"
+
+    def close(self):
+        self.fileobj.close()
+# class StreamProxy
+
+class _BZ2Proxy(object):
+    """Small proxy class that enables external file object
+       support for "r:bz2" and "w:bz2" modes. This is actually
+       a workaround for a limitation in bz2 module's BZ2File
+       class which (unlike gzip.GzipFile) has no support for
+       a file object argument.
+    """
+
+    blocksize = 16 * 1024
+
+    def __init__(self, fileobj, mode):
+        self.fileobj = fileobj
+        self.mode = mode
+        self.name = getattr(self.fileobj, "name", None)
+        self.init()
+
+    def init(self):
+        import bz2
+        self.pos = 0
+        if self.mode == "r":
+            self.bz2obj = bz2.BZ2Decompressor()
+            self.fileobj.seek(0)
+            self.buf = b""
+        else:
+            self.bz2obj = bz2.BZ2Compressor()
+
+    def read(self, size):
+        x = len(self.buf)
+        while x < size:
+            raw = self.fileobj.read(self.blocksize)
+            if not raw:
+                break
+            data = self.bz2obj.decompress(raw)
+            self.buf += data
+            x += len(data)
+
+        buf = self.buf[:size]
+        self.buf = self.buf[size:]
+        self.pos += len(buf)
+        return buf
+
+    def seek(self, pos):
+        if pos < self.pos:
+            self.init()
+        self.read(pos - self.pos)
+
+    def tell(self):
+        return self.pos
+
+    def write(self, data):
+        self.pos += len(data)
+        raw = self.bz2obj.compress(data)
+        self.fileobj.write(raw)
+
+    def close(self):
+        if self.mode == "w":
+            raw = self.bz2obj.flush()
+            self.fileobj.write(raw)
+# class _BZ2Proxy
+
+#------------------------
+# Extraction file object
+#------------------------
+class _FileInFile(object):
+    """A thin wrapper around an existing file object that
+       provides a part of its data as an individual file
+       object.
+    """
+
+    def __init__(self, fileobj, offset, size, blockinfo=None):
+        self.fileobj = fileobj
+        self.offset = offset
+        self.size = size
+        self.position = 0
+
+        if blockinfo is None:
+            blockinfo = [(0, size)]
+
+        # Construct a map with data and zero blocks.
+        self.map_index = 0
+        self.map = []
+        lastpos = 0
+        realpos = self.offset
+        for offset, size in blockinfo:
+            if offset > lastpos:
+                self.map.append((False, lastpos, offset, None))
+            self.map.append((True, offset, offset + size, realpos))
+            realpos += size
+            lastpos = offset + size
+        if lastpos < self.size:
+            self.map.append((False, lastpos, self.size, None))
+
+    def seekable(self):
+        if not hasattr(self.fileobj, "seekable"):
+            # XXX gzip.GzipFile and bz2.BZ2File
+            return True
+        return self.fileobj.seekable()
+
+    def tell(self):
+        """Return the current file position.
+        """
+        return self.position
+
+    def seek(self, position):
+        """Seek to a position in the file.
+        """
+        self.position = position
+
+    def read(self, size=None):
+        """Read data from the file.
+        """
+        if size is None:
+            size = self.size - self.position
+        else:
+            size = min(size, self.size - self.position)
+
+        buf = b""
+        while size > 0:
+            while True:
+                data, start, stop, offset = self.map[self.map_index]
+                if start <= self.position < stop:
+                    break
+                else:
+                    self.map_index += 1
+                    if self.map_index == len(self.map):
+                        self.map_index = 0
+            length = min(size, stop - self.position)
+            if data:
+                self.fileobj.seek(offset + (self.position - start))
+                buf += self.fileobj.read(length)
+            else:
+                buf += NUL * length
+            size -= length
+            self.position += length
+        return buf
+#class _FileInFile
+
+
+class ExFileObject(object):
+    """File-like object for reading an archive member.
+       Is returned by TarFile.extractfile().
+    """
+    blocksize = 1024
+
+    def __init__(self, tarfile, tarinfo):
+        self.fileobj = _FileInFile(tarfile.fileobj,
+                                   tarinfo.offset_data,
+                                   tarinfo.size,
+                                   tarinfo.sparse)
+        self.name = tarinfo.name
+        self.mode = "r"
+        self.closed = False
+        self.size = tarinfo.size
+
+        self.position = 0
+        self.buffer = b""
+
+    def readable(self):
+        return True
+
+    def writable(self):
+        return False
+
+    def seekable(self):
+        return self.fileobj.seekable()
+
+    def read(self, size=None):
+        """Read at most size bytes from the file. If size is not
+           present or None, read all data until EOF is reached.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed file")
+
+        buf = b""
+        if self.buffer:
+            if size is None:
+                buf = self.buffer
+                self.buffer = b""
+            else:
+                buf = self.buffer[:size]
+                self.buffer = self.buffer[size:]
+
+        if size is None:
+            buf += self.fileobj.read()
+        else:
+            buf += self.fileobj.read(size - len(buf))
+
+        self.position += len(buf)
+        return buf
+
+    # XXX TextIOWrapper uses the read1() method.
+    read1 = read
+
+    def readline(self, size=-1):
+        """Read one entire line from the file. If size is present
+           and non-negative, return a string with at most that
+           size, which may be an incomplete line.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed file")
+
+        pos = self.buffer.find(b"\n") + 1
+        if pos == 0:
+            # no newline found.
+            while True:
+                buf = self.fileobj.read(self.blocksize)
+                self.buffer += buf
+                if not buf or b"\n" in buf:
+                    pos = self.buffer.find(b"\n") + 1
+                    if pos == 0:
+                        # no newline found.
+                        pos = len(self.buffer)
+                    break
+
+        if size != -1:
+            pos = min(size, pos)
+
+        buf = self.buffer[:pos]
+        self.buffer = self.buffer[pos:]
+        self.position += len(buf)
+        return buf
+
+    def readlines(self):
+        """Return a list with all remaining lines.
+        """
+        result = []
+        while True:
+            line = self.readline()
+            if not line: break
+            result.append(line)
+        return result
+
+    def tell(self):
+        """Return the current file position.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed file")
+
+        return self.position
+
+    def seek(self, pos, whence=os.SEEK_SET):
+        """Seek to a position in the file.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed file")
+
+        if whence == os.SEEK_SET:
+            self.position = min(max(pos, 0), self.size)
+        elif whence == os.SEEK_CUR:
+            if pos < 0:
+                self.position = max(self.position + pos, 0)
+            else:
+                self.position = min(self.position + pos, self.size)
+        elif whence == os.SEEK_END:
+            self.position = max(min(self.size + pos, self.size), 0)
+        else:
+            raise ValueError("Invalid argument")
+
+        self.buffer = b""
+        self.fileobj.seek(self.position)
+
+    def close(self):
+        """Close the file object.
+        """
+        self.closed = True
+
+    def __iter__(self):
+        """Get an iterator over the file's lines.
+        """
+        while True:
+            line = self.readline()
+            if not line:
+                break
+            yield line
+#class ExFileObject
+
+#------------------
+# Exported Classes
+#------------------
+class TarInfo(object):
+    """Informational class which holds the details about an
+       archive member given by a tar header block.
+       TarInfo objects are returned by TarFile.getmember(),
+       TarFile.getmembers() and TarFile.gettarinfo() and are
+       usually created internally.
+    """
+
+    __slots__ = ("name", "mode", "uid", "gid", "size", "mtime",
+                 "chksum", "type", "linkname", "uname", "gname",
+                 "devmajor", "devminor",
+                 "offset", "offset_data", "pax_headers", "sparse",
+                 "tarfile", "_sparse_structs", "_link_target")
+
+    def __init__(self, name=""):
+        """Construct a TarInfo object. name is the optional name
+           of the member.
+        """
+        self.name = name        # member name
+        self.mode = 0o644       # file permissions
+        self.uid = 0            # user id
+        self.gid = 0            # group id
+        self.size = 0           # file size
+        self.mtime = 0          # modification time
+        self.chksum = 0         # header checksum
+        self.type = REGTYPE     # member type
+        self.linkname = ""      # link name
+        self.uname = ""         # user name
+        self.gname = ""         # group name
+        self.devmajor = 0       # device major number
+        self.devminor = 0       # device minor number
+
+        self.offset = 0         # the tar header starts here
+        self.offset_data = 0    # the file's data starts here
+
+        self.sparse = None      # sparse member information
+        self.pax_headers = {}   # pax header information
+
+    # In pax headers the "name" and "linkname" field are called
+    # "path" and "linkpath".
+    def _getpath(self):
+        return self.name
+    def _setpath(self, name):
+        self.name = name
+    path = property(_getpath, _setpath)
+
+    def _getlinkpath(self):
+        return self.linkname
+    def _setlinkpath(self, linkname):
+        self.linkname = linkname
+    linkpath = property(_getlinkpath, _setlinkpath)
+
+    def __repr__(self):
+        return "<%s %r at %#x>" % (self.__class__.__name__,self.name,id(self))
+
+    def get_info(self):
+        """Return the TarInfo's attributes as a dictionary.
+        """
+        info = {
+            "name":     self.name,
+            "mode":     self.mode & 0o7777,
+            "uid":      self.uid,
+            "gid":      self.gid,
+            "size":     self.size,
+            "mtime":    self.mtime,
+            "chksum":   self.chksum,
+            "type":     self.type,
+            "linkname": self.linkname,
+            "uname":    self.uname,
+            "gname":    self.gname,
+            "devmajor": self.devmajor,
+            "devminor": self.devminor
+        }
+
+        if info["type"] == DIRTYPE and not info["name"].endswith("/"):
+            info["name"] += "/"
+
+        return info
+
+    def tobuf(self, format=DEFAULT_FORMAT, encoding=ENCODING, errors="surrogateescape"):
+        """Return a tar header as a string of 512 byte blocks.
+        """
+        info = self.get_info()
+
+        if format == USTAR_FORMAT:
+            return self.create_ustar_header(info, encoding, errors)
+        elif format == GNU_FORMAT:
+            return self.create_gnu_header(info, encoding, errors)
+        elif format == PAX_FORMAT:
+            return self.create_pax_header(info, encoding)
+        else:
+            raise ValueError("invalid format")
+
+    def create_ustar_header(self, info, encoding, errors):
+        """Return the object as a ustar header block.
+        """
+        info["magic"] = POSIX_MAGIC
+
+        if len(info["linkname"]) > LENGTH_LINK:
+            raise ValueError("linkname is too long")
+
+        if len(info["name"]) > LENGTH_NAME:
+            info["prefix"], info["name"] = self._posix_split_name(info["name"])
+
+        return self._create_header(info, USTAR_FORMAT, encoding, errors)
+
+    def create_gnu_header(self, info, encoding, errors):
+        """Return the object as a GNU header block sequence.
+        """
+        info["magic"] = GNU_MAGIC
+
+        buf = b""
+        if len(info["linkname"]) > LENGTH_LINK:
+            buf += self._create_gnu_long_header(info["linkname"], GNUTYPE_LONGLINK, encoding, errors)
+
+        if len(info["name"]) > LENGTH_NAME:
+            buf += self._create_gnu_long_header(info["name"], GNUTYPE_LONGNAME, encoding, errors)
+
+        return buf + self._create_header(info, GNU_FORMAT, encoding, errors)
+
+    def create_pax_header(self, info, encoding):
+        """Return the object as a ustar header block. If it cannot be
+           represented this way, prepend a pax extended header sequence
+           with supplement information.
+        """
+        info["magic"] = POSIX_MAGIC
+        pax_headers = self.pax_headers.copy()
+
+        # Test string fields for values that exceed the field length or cannot
+        # be represented in ASCII encoding.
+        for name, hname, length in (
+                ("name", "path", LENGTH_NAME), ("linkname", "linkpath", LENGTH_LINK),
+                ("uname", "uname", 32), ("gname", "gname", 32)):
+
+            if hname in pax_headers:
+                # The pax header has priority.
+                continue
+
+            # Try to encode the string as ASCII.
+            try:
+                info[name].encode("ascii", "strict")
+            except UnicodeEncodeError:
+                pax_headers[hname] = info[name]
+                continue
+
+            if len(info[name]) > length:
+                pax_headers[hname] = info[name]
+
+        # Test number fields for values that exceed the field limit or values
+        # that like to be stored as float.
+        for name, digits in (("uid", 8), ("gid", 8), ("size", 12), ("mtime", 12)):
+            if name in pax_headers:
+                # The pax header has priority. Avoid overflow.
+                info[name] = 0
+                continue
+
+            val = info[name]
+            if not 0 <= val < 8 ** (digits - 1) or isinstance(val, float):
+                pax_headers[name] = str(val)
+                info[name] = 0
+
+        # Create a pax extended header if necessary.
+        if pax_headers:
+            buf = self._create_pax_generic_header(pax_headers, XHDTYPE, encoding)
+        else:
+            buf = b""
+
+        return buf + self._create_header(info, USTAR_FORMAT, "ascii", "replace")
+
+    @classmethod
+    def create_pax_global_header(cls, pax_headers):
+        """Return the object as a pax global header block sequence.
+        """
+        return cls._create_pax_generic_header(pax_headers, XGLTYPE, "utf8")
+
+    def _posix_split_name(self, name):
+        """Split a name longer than 100 chars into a prefix
+           and a name part.
+        """
+        prefix = name[:LENGTH_PREFIX + 1]
+        while prefix and prefix[-1] != "/":
+            prefix = prefix[:-1]
+
+        name = name[len(prefix):]
+        prefix = prefix[:-1]
+
+        if not prefix or len(name) > LENGTH_NAME:
+            raise ValueError("name is too long")
+        return prefix, name
+
+    @staticmethod
+    def _create_header(info, format, encoding, errors):
+        """Return a header block. info is a dictionary with file
+           information, format must be one of the *_FORMAT constants.
+        """
+        parts = [
+            stn(info.get("name", ""), 100, encoding, errors),
+            itn(info.get("mode", 0) & 0o7777, 8, format),
+            itn(info.get("uid", 0), 8, format),
+            itn(info.get("gid", 0), 8, format),
+            itn(info.get("size", 0), 12, format),
+            itn(info.get("mtime", 0), 12, format),
+            b"        ", # checksum field
+            info.get("type", REGTYPE),
+            stn(info.get("linkname", ""), 100, encoding, errors),
+            info.get("magic", POSIX_MAGIC),
+            stn(info.get("uname", ""), 32, encoding, errors),
+            stn(info.get("gname", ""), 32, encoding, errors),
+            itn(info.get("devmajor", 0), 8, format),
+            itn(info.get("devminor", 0), 8, format),
+            stn(info.get("prefix", ""), 155, encoding, errors)
+        ]
+
+        buf = struct.pack("%ds" % BLOCKSIZE, b"".join(parts))
+        chksum = calc_chksums(buf[-BLOCKSIZE:])[0]
+        buf = buf[:-364] + ("%06o\0" % chksum).encode("ascii") + buf[-357:]
+        return buf
+
+    @staticmethod
+    def _create_payload(payload):
+        """Return the string payload filled with zero bytes
+           up to the next 512 byte border.
+        """
+        blocks, remainder = divmod(len(payload), BLOCKSIZE)
+        if remainder > 0:
+            payload += (BLOCKSIZE - remainder) * NUL
+        return payload
+
+    @classmethod
+    def _create_gnu_long_header(cls, name, type, encoding, errors):
+        """Return a GNUTYPE_LONGNAME or GNUTYPE_LONGLINK sequence
+           for name.
+        """
+        name = name.encode(encoding, errors) + NUL
+
+        info = {}
+        info["name"] = "././@LongLink"
+        info["type"] = type
+        info["size"] = len(name)
+        info["magic"] = GNU_MAGIC
+
+        # create extended header + name blocks.
+        return cls._create_header(info, USTAR_FORMAT, encoding, errors) + \
+                cls._create_payload(name)
+
+    @classmethod
+    def _create_pax_generic_header(cls, pax_headers, type, encoding):
+        """Return a POSIX.1-2008 extended or global header sequence
+           that contains a list of keyword, value pairs. The values
+           must be strings.
+        """
+        # Check if one of the fields contains surrogate characters and thereby
+        # forces hdrcharset=BINARY, see _proc_pax() for more information.
+        binary = False
+        for keyword, value in pax_headers.items():
+            try:
+                value.encode("utf8", "strict")
+            except UnicodeEncodeError:
+                binary = True
+                break
+
+        records = b""
+        if binary:
+            # Put the hdrcharset field at the beginning of the header.
+            records += b"21 hdrcharset=BINARY\n"
+
+        for keyword, value in pax_headers.items():
+            keyword = keyword.encode("utf8")
+            if binary:
+                # Try to restore the original byte representation of `value'.
+                # Needless to say, that the encoding must match the string.
+                value = value.encode(encoding, "surrogateescape")
+            else:
+                value = value.encode("utf8")
+
+            l = len(keyword) + len(value) + 3   # ' ' + '=' + '\n'
+            n = p = 0
+            while True:
+                n = l + len(str(p))
+                if n == p:
+                    break
+                p = n
+            records += bytes(str(p), "ascii") + b" " + keyword + b"=" + value + b"\n"
+
+        # We use a hardcoded "././@PaxHeader" name like star does
+        # instead of the one that POSIX recommends.
+        info = {}
+        info["name"] = "././@PaxHeader"
+        info["type"] = type
+        info["size"] = len(records)
+        info["magic"] = POSIX_MAGIC
+
+        # Create pax header + record blocks.
+        return cls._create_header(info, USTAR_FORMAT, "ascii", "replace") + \
+                cls._create_payload(records)
+
+    @classmethod
+    def frombuf(cls, buf, encoding, errors):
+        """Construct a TarInfo object from a 512 byte bytes object.
+        """
+        if len(buf) == 0:
+            raise EmptyHeaderError("empty header")
+        if len(buf) != BLOCKSIZE:
+            raise TruncatedHeaderError("truncated header")
+        if buf.count(NUL) == BLOCKSIZE:
+            raise EOFHeaderError("end of file header")
+
+        chksum = nti(buf[148:156])
+        if chksum not in calc_chksums(buf):
+            raise InvalidHeaderError("bad checksum")
+
+        obj = cls()
+        obj.name = nts(buf[0:100], encoding, errors)
+        obj.mode = nti(buf[100:108])
+        obj.uid = nti(buf[108:116])
+        obj.gid = nti(buf[116:124])
+        obj.size = nti(buf[124:136])
+        obj.mtime = nti(buf[136:148])
+        obj.chksum = chksum
+        obj.type = buf[156:157]
+        obj.linkname = nts(buf[157:257], encoding, errors)
+        obj.uname = nts(buf[265:297], encoding, errors)
+        obj.gname = nts(buf[297:329], encoding, errors)
+        obj.devmajor = nti(buf[329:337])
+        obj.devminor = nti(buf[337:345])
+        prefix = nts(buf[345:500], encoding, errors)
+
+        # Old V7 tar format represents a directory as a regular
+        # file with a trailing slash.
+        if obj.type == AREGTYPE and obj.name.endswith("/"):
+            obj.type = DIRTYPE
+
+        # The old GNU sparse format occupies some of the unused
+        # space in the buffer for up to 4 sparse structures.
+        # Save the them for later processing in _proc_sparse().
+        if obj.type == GNUTYPE_SPARSE:
+            pos = 386
+            structs = []
+            for i in range(4):
+                try:
+                    offset = nti(buf[pos:pos + 12])
+                    numbytes = nti(buf[pos + 12:pos + 24])
+                except ValueError:
+                    break
+                structs.append((offset, numbytes))
+                pos += 24
+            isextended = bool(buf[482])
+            origsize = nti(buf[483:495])
+            obj._sparse_structs = (structs, isextended, origsize)
+
+        # Remove redundant slashes from directories.
+        if obj.isdir():
+            obj.name = obj.name.rstrip("/")
+
+        # Reconstruct a ustar longname.
+        if prefix and obj.type not in GNU_TYPES:
+            obj.name = prefix + "/" + obj.name
+        return obj
+
+    @classmethod
+    def fromtarfile(cls, tarfile):
+        """Return the next TarInfo object from TarFile object
+           tarfile.
+        """
+        buf = tarfile.fileobj.read(BLOCKSIZE)
+        obj = cls.frombuf(buf, tarfile.encoding, tarfile.errors)
+        obj.offset = tarfile.fileobj.tell() - BLOCKSIZE
+        return obj._proc_member(tarfile)
+
+    #--------------------------------------------------------------------------
+    # The following are methods that are called depending on the type of a
+    # member. The entry point is _proc_member() which can be overridden in a
+    # subclass to add custom _proc_*() methods. A _proc_*() method MUST
+    # implement the following
+    # operations:
+    # 1. Set self.offset_data to the position where the data blocks begin,
+    #    if there is data that follows.
+    # 2. Set tarfile.offset to the position where the next member's header will
+    #    begin.
+    # 3. Return self or another valid TarInfo object.
+    def _proc_member(self, tarfile):
+        """Choose the right processing method depending on
+           the type and call it.
+        """
+        if self.type in (GNUTYPE_LONGNAME, GNUTYPE_LONGLINK):
+            return self._proc_gnulong(tarfile)
+        elif self.type == GNUTYPE_SPARSE:
+            return self._proc_sparse(tarfile)
+        elif self.type in (XHDTYPE, XGLTYPE, SOLARIS_XHDTYPE):
+            return self._proc_pax(tarfile)
+        else:
+            return self._proc_builtin(tarfile)
+
+    def _proc_builtin(self, tarfile):
+        """Process a builtin type or an unknown type which
+           will be treated as a regular file.
+        """
+        self.offset_data = tarfile.fileobj.tell()
+        offset = self.offset_data
+        if self.isreg() or self.type not in SUPPORTED_TYPES:
+            # Skip the following data blocks.
+            offset += self._block(self.size)
+        tarfile.offset = offset
+
+        # Patch the TarInfo object with saved global
+        # header information.
+        self._apply_pax_info(tarfile.pax_headers, tarfile.encoding, tarfile.errors)
+
+        return self
+
+    def _proc_gnulong(self, tarfile):
+        """Process the blocks that hold a GNU longname
+           or longlink member.
+        """
+        buf = tarfile.fileobj.read(self._block(self.size))
+
+        # Fetch the next header and process it.
+        try:
+            next = self.fromtarfile(tarfile)
+        except HeaderError:
+            raise SubsequentHeaderError("missing or bad subsequent header")
+
+        # Patch the TarInfo object from the next header with
+        # the longname information.
+        next.offset = self.offset
+        if self.type == GNUTYPE_LONGNAME:
+            next.name = nts(buf, tarfile.encoding, tarfile.errors)
+        elif self.type == GNUTYPE_LONGLINK:
+            next.linkname = nts(buf, tarfile.encoding, tarfile.errors)
+
+        return next
+
+    def _proc_sparse(self, tarfile):
+        """Process a GNU sparse header plus extra headers.
+        """
+        # We already collected some sparse structures in frombuf().
+        structs, isextended, origsize = self._sparse_structs
+        del self._sparse_structs
+
+        # Collect sparse structures from extended header blocks.
+        while isextended:
+            buf = tarfile.fileobj.read(BLOCKSIZE)
+            pos = 0
+            for i in range(21):
+                try:
+                    offset = nti(buf[pos:pos + 12])
+                    numbytes = nti(buf[pos + 12:pos + 24])
+                except ValueError:
+                    break
+                if offset and numbytes:
+                    structs.append((offset, numbytes))
+                pos += 24
+            isextended = bool(buf[504])
+        self.sparse = structs
+
+        self.offset_data = tarfile.fileobj.tell()
+        tarfile.offset = self.offset_data + self._block(self.size)
+        self.size = origsize
+        return self
+
+    def _proc_pax(self, tarfile):
+        """Process an extended or global header as described in
+           POSIX.1-2008.
+        """
+        # Read the header information.
+        buf = tarfile.fileobj.read(self._block(self.size))
+
+        # A pax header stores supplemental information for either
+        # the following file (extended) or all following files
+        # (global).
+        if self.type == XGLTYPE:
+            pax_headers = tarfile.pax_headers
+        else:
+            pax_headers = tarfile.pax_headers.copy()
+
+        # Check if the pax header contains a hdrcharset field. This tells us
+        # the encoding of the path, linkpath, uname and gname fields. Normally,
+        # these fields are UTF-8 encoded but since POSIX.1-2008 tar
+        # implementations are allowed to store them as raw binary strings if
+        # the translation to UTF-8 fails.
+        match = re.search(br"\d+ hdrcharset=([^\n]+)\n", buf)
+        if match is not None:
+            pax_headers["hdrcharset"] = match.group(1).decode("utf8")
+
+        # For the time being, we don't care about anything other than "BINARY".
+        # The only other value that is currently allowed by the standard is
+        # "ISO-IR 10646 2000 UTF-8" in other words UTF-8.
+        hdrcharset = pax_headers.get("hdrcharset")
+        if hdrcharset == "BINARY":
+            encoding = tarfile.encoding
+        else:
+            encoding = "utf8"
+
+        # Parse pax header information. A record looks like that:
+        # "%d %s=%s\n" % (length, keyword, value). length is the size
+        # of the complete record including the length field itself and
+        # the newline. keyword and value are both UTF-8 encoded strings.
+        regex = re.compile(br"(\d+) ([^=]+)=")
+        pos = 0
+        while True:
+            match = regex.match(buf, pos)
+            if not match:
+                break
+
+            length, keyword = match.groups()
+            length = int(length)
+            value = buf[match.end(2) + 1:match.start(1) + length - 1]
+
+            # Normally, we could just use "utf8" as the encoding and "strict"
+            # as the error handler, but we better not take the risk. For
+            # example, GNU tar <= 1.23 is known to store filenames it cannot
+            # translate to UTF-8 as raw strings (unfortunately without a
+            # hdrcharset=BINARY header).
+            # We first try the strict standard encoding, and if that fails we
+            # fall back on the user's encoding and error handler.
+            keyword = self._decode_pax_field(keyword, "utf8", "utf8",
+                    tarfile.errors)
+            if keyword in PAX_NAME_FIELDS:
+                value = self._decode_pax_field(value, encoding, tarfile.encoding,
+                        tarfile.errors)
+            else:
+                value = self._decode_pax_field(value, "utf8", "utf8",
+                        tarfile.errors)
+
+            pax_headers[keyword] = value
+            pos += length
+
+        # Fetch the next header.
+        try:
+            next = self.fromtarfile(tarfile)
+        except HeaderError:
+            raise SubsequentHeaderError("missing or bad subsequent header")
+
+        # Process GNU sparse information.
+        if "GNU.sparse.map" in pax_headers:
+            # GNU extended sparse format version 0.1.
+            self._proc_gnusparse_01(next, pax_headers)
+
+        elif "GNU.sparse.size" in pax_headers:
+            # GNU extended sparse format version 0.0.
+            self._proc_gnusparse_00(next, pax_headers, buf)
+
+        elif pax_headers.get("GNU.sparse.major") == "1" and pax_headers.get("GNU.sparse.minor") == "0":
+            # GNU extended sparse format version 1.0.
+            self._proc_gnusparse_10(next, pax_headers, tarfile)
+
+        if self.type in (XHDTYPE, SOLARIS_XHDTYPE):
+            # Patch the TarInfo object with the extended header info.
+            next._apply_pax_info(pax_headers, tarfile.encoding, tarfile.errors)
+            next.offset = self.offset
+
+            if "size" in pax_headers:
+                # If the extended header replaces the size field,
+                # we need to recalculate the offset where the next
+                # header starts.
+                offset = next.offset_data
+                if next.isreg() or next.type not in SUPPORTED_TYPES:
+                    offset += next._block(next.size)
+                tarfile.offset = offset
+
+        return next
+
+    def _proc_gnusparse_00(self, next, pax_headers, buf):
+        """Process a GNU tar extended sparse header, version 0.0.
+        """
+        offsets = []
+        for match in re.finditer(br"\d+ GNU.sparse.offset=(\d+)\n", buf):
+            offsets.append(int(match.group(1)))
+        numbytes = []
+        for match in re.finditer(br"\d+ GNU.sparse.numbytes=(\d+)\n", buf):
+            numbytes.append(int(match.group(1)))
+        next.sparse = list(zip(offsets, numbytes))
+
+    def _proc_gnusparse_01(self, next, pax_headers):
+        """Process a GNU tar extended sparse header, version 0.1.
+        """
+        sparse = [int(x) for x in pax_headers["GNU.sparse.map"].split(",")]
+        next.sparse = list(zip(sparse[::2], sparse[1::2]))
+
+    def _proc_gnusparse_10(self, next, pax_headers, tarfile):
+        """Process a GNU tar extended sparse header, version 1.0.
+        """
+        fields = None
+        sparse = []
+        buf = tarfile.fileobj.read(BLOCKSIZE)
+        fields, buf = buf.split(b"\n", 1)
+        fields = int(fields)
+        while len(sparse) < fields * 2:
+            if b"\n" not in buf:
+                buf += tarfile.fileobj.read(BLOCKSIZE)
+            number, buf = buf.split(b"\n", 1)
+            sparse.append(int(number))
+        next.offset_data = tarfile.fileobj.tell()
+        next.sparse = list(zip(sparse[::2], sparse[1::2]))
+
+    def _apply_pax_info(self, pax_headers, encoding, errors):
+        """Replace fields with supplemental information from a previous
+           pax extended or global header.
+        """
+        for keyword, value in pax_headers.items():
+            if keyword == "GNU.sparse.name":
+                setattr(self, "path", value)
+            elif keyword == "GNU.sparse.size":
+                setattr(self, "size", int(value))
+            elif keyword == "GNU.sparse.realsize":
+                setattr(self, "size", int(value))
+            elif keyword in PAX_FIELDS:
+                if keyword in PAX_NUMBER_FIELDS:
+                    try:
+                        value = PAX_NUMBER_FIELDS[keyword](value)
+                    except ValueError:
+                        value = 0
+                if keyword == "path":
+                    value = value.rstrip("/")
+                setattr(self, keyword, value)
+
+        self.pax_headers = pax_headers.copy()
+
+    def _decode_pax_field(self, value, encoding, fallback_encoding, fallback_errors):
+        """Decode a single field from a pax record.
+        """
+        try:
+            return value.decode(encoding, "strict")
+        except UnicodeDecodeError:
+            return value.decode(fallback_encoding, fallback_errors)
+
+    def _block(self, count):
+        """Round up a byte count by BLOCKSIZE and return it,
+           e.g. _block(834) => 1024.
+        """
+        blocks, remainder = divmod(count, BLOCKSIZE)
+        if remainder:
+            blocks += 1
+        return blocks * BLOCKSIZE
+
+    def isreg(self):
+        return self.type in REGULAR_TYPES
+    def isfile(self):
+        return self.isreg()
+    def isdir(self):
+        return self.type == DIRTYPE
+    def issym(self):
+        return self.type == SYMTYPE
+    def islnk(self):
+        return self.type == LNKTYPE
+    def ischr(self):
+        return self.type == CHRTYPE
+    def isblk(self):
+        return self.type == BLKTYPE
+    def isfifo(self):
+        return self.type == FIFOTYPE
+    def issparse(self):
+        return self.sparse is not None
+    def isdev(self):
+        return self.type in (CHRTYPE, BLKTYPE, FIFOTYPE)
+# class TarInfo
+
+class TarFile(object):
+    """The TarFile Class provides an interface to tar archives.
+    """
+
+    debug = 0                   # May be set from 0 (no msgs) to 3 (all msgs)
+
+    dereference = False         # If true, add content of linked file to the
+                                # tar file, else the link.
+
+    ignore_zeros = False        # If true, skips empty or invalid blocks and
+                                # continues processing.
+
+    errorlevel = 1              # If 0, fatal errors only appear in debug
+                                # messages (if debug >= 0). If > 0, errors
+                                # are passed to the caller as exceptions.
+
+    format = DEFAULT_FORMAT     # The format to use when creating an archive.
+
+    encoding = ENCODING         # Encoding for 8-bit character strings.
+
+    errors = None               # Error handler for unicode conversion.
+
+    tarinfo = TarInfo           # The default TarInfo class to use.
+
+    fileobject = ExFileObject   # The default ExFileObject class to use.
+
+    def __init__(self, name=None, mode="r", fileobj=None, format=None,
+            tarinfo=None, dereference=None, ignore_zeros=None, encoding=None,
+            errors="surrogateescape", pax_headers=None, debug=None, errorlevel=None):
+        """Open an (uncompressed) tar archive `name'. `mode' is either 'r' to
+           read from an existing archive, 'a' to append data to an existing
+           file or 'w' to create a new file overwriting an existing one. `mode'
+           defaults to 'r'.
+           If `fileobj' is given, it is used for reading or writing data. If it
+           can be determined, `mode' is overridden by `fileobj's mode.
+           `fileobj' is not closed, when TarFile is closed.
+        """
+        if len(mode) > 1 or mode not in "raw":
+            raise ValueError("mode must be 'r', 'a' or 'w'")
+        self.mode = mode
+        self._mode = {"r": "rb", "a": "r+b", "w": "wb"}[mode]
+
+        if not fileobj:
+            if self.mode == "a" and not os.path.exists(name):
+                # Create nonexistent files in append mode.
+                self.mode = "w"
+                self._mode = "wb"
+            fileobj = bltn_open(name, self._mode)
+            self._extfileobj = False
+        else:
+            if name is None and hasattr(fileobj, "name"):
+                name = fileobj.name
+            if hasattr(fileobj, "mode"):
+                self._mode = fileobj.mode
+            self._extfileobj = True
+        self.name = os.path.abspath(name) if name else None
+        self.fileobj = fileobj
+
+        # Init attributes.
+        if format is not None:
+            self.format = format
+        if tarinfo is not None:
+            self.tarinfo = tarinfo
+        if dereference is not None:
+            self.dereference = dereference
+        if ignore_zeros is not None:
+            self.ignore_zeros = ignore_zeros
+        if encoding is not None:
+            self.encoding = encoding
+        self.errors = errors
+
+        if pax_headers is not None and self.format == PAX_FORMAT:
+            self.pax_headers = pax_headers
+        else:
+            self.pax_headers = {}
+
+        if debug is not None:
+            self.debug = debug
+        if errorlevel is not None:
+            self.errorlevel = errorlevel
+
+        # Init datastructures.
+        self.closed = False
+        self.members = []       # list of members as TarInfo objects
+        self._loaded = False    # flag if all members have been read
+        self.offset = self.fileobj.tell()
+                                # current position in the archive file
+        self.inodes = {}        # dictionary caching the inodes of
+                                # archive members already added
+
+        try:
+            if self.mode == "r":
+                self.firstmember = None
+                self.firstmember = self.next()
+
+            if self.mode == "a":
+                # Move to the end of the archive,
+                # before the first empty block.
+                while True:
+                    self.fileobj.seek(self.offset)
+                    try:
+                        tarinfo = self.tarinfo.fromtarfile(self)
+                        self.members.append(tarinfo)
+                    except EOFHeaderError:
+                        self.fileobj.seek(self.offset)
+                        break
+                    except HeaderError as e:
+                        raise ReadError(str(e))
+
+            if self.mode in "aw":
+                self._loaded = True
+
+                if self.pax_headers:
+                    buf = self.tarinfo.create_pax_global_header(self.pax_headers.copy())
+                    self.fileobj.write(buf)
+                    self.offset += len(buf)
+        except:
+            if not self._extfileobj:
+                self.fileobj.close()
+            self.closed = True
+            raise
+
+    #--------------------------------------------------------------------------
+    # Below are the classmethods which act as alternate constructors to the
+    # TarFile class. The open() method is the only one that is needed for
+    # public use; it is the "super"-constructor and is able to select an
+    # adequate "sub"-constructor for a particular compression using the mapping
+    # from OPEN_METH.
+    #
+    # This concept allows one to subclass TarFile without losing the comfort of
+    # the super-constructor. A sub-constructor is registered and made available
+    # by adding it to the mapping in OPEN_METH.
+
+    @classmethod
+    def open(cls, name=None, mode="r", fileobj=None, bufsize=RECORDSIZE, **kwargs):
+        """Open a tar archive for reading, writing or appending. Return
+           an appropriate TarFile class.
+
+           mode:
+           'r' or 'r:*' open for reading with transparent compression
+           'r:'         open for reading exclusively uncompressed
+           'r:gz'       open for reading with gzip compression
+           'r:bz2'      open for reading with bzip2 compression
+           'a' or 'a:'  open for appending, creating the file if necessary
+           'w' or 'w:'  open for writing without compression
+           'w:gz'       open for writing with gzip compression
+           'w:bz2'      open for writing with bzip2 compression
+
+           'r|*'        open a stream of tar blocks with transparent compression
+           'r|'         open an uncompressed stream of tar blocks for reading
+           'r|gz'       open a gzip compressed stream of tar blocks
+           'r|bz2'      open a bzip2 compressed stream of tar blocks
+           'w|'         open an uncompressed stream for writing
+           'w|gz'       open a gzip compressed stream for writing
+           'w|bz2'      open a bzip2 compressed stream for writing
+        """
+
+        if not name and not fileobj:
+            raise ValueError("nothing to open")
+
+        if mode in ("r", "r:*"):
+            # Find out which *open() is appropriate for opening the file.
+            for comptype in cls.OPEN_METH:
+                func = getattr(cls, cls.OPEN_METH[comptype])
+                if fileobj is not None:
+                    saved_pos = fileobj.tell()
+                try:
+                    return func(name, "r", fileobj, **kwargs)
+                except (ReadError, CompressionError) as e:
+                    if fileobj is not None:
+                        fileobj.seek(saved_pos)
+                    continue
+            raise ReadError("file could not be opened successfully")
+
+        elif ":" in mode:
+            filemode, comptype = mode.split(":", 1)
+            filemode = filemode or "r"
+            comptype = comptype or "tar"
+
+            # Select the *open() function according to
+            # given compression.
+            if comptype in cls.OPEN_METH:
+                func = getattr(cls, cls.OPEN_METH[comptype])
+            else:
+                raise CompressionError("unknown compression type %r" % comptype)
+            return func(name, filemode, fileobj, **kwargs)
+
+        elif "|" in mode:
+            filemode, comptype = mode.split("|", 1)
+            filemode = filemode or "r"
+            comptype = comptype or "tar"
+
+            if filemode not in "rw":
+                raise ValueError("mode must be 'r' or 'w'")
+
+            stream = _Stream(name, filemode, comptype, fileobj, bufsize)
+            try:
+                t = cls(name, filemode, stream, **kwargs)
+            except:
+                stream.close()
+                raise
+            t._extfileobj = False
+            return t
+
+        elif mode in "aw":
+            return cls.taropen(name, mode, fileobj, **kwargs)
+
+        raise ValueError("undiscernible mode")
+
+    @classmethod
+    def taropen(cls, name, mode="r", fileobj=None, **kwargs):
+        """Open uncompressed tar archive name for reading or writing.
+        """
+        if len(mode) > 1 or mode not in "raw":
+            raise ValueError("mode must be 'r', 'a' or 'w'")
+        return cls(name, mode, fileobj, **kwargs)
+
+    @classmethod
+    def gzopen(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs):
+        """Open gzip compressed tar archive name for reading or writing.
+           Appending is not allowed.
+        """
+        if len(mode) > 1 or mode not in "rw":
+            raise ValueError("mode must be 'r' or 'w'")
+
+        try:
+            import gzip
+            gzip.GzipFile
+        except (ImportError, AttributeError):
+            raise CompressionError("gzip module is not available")
+
+        extfileobj = fileobj is not None
+        try:
+            fileobj = gzip.GzipFile(name, mode + "b", compresslevel, fileobj)
+            t = cls.taropen(name, mode, fileobj, **kwargs)
+        except IOError:
+            if not extfileobj and fileobj is not None:
+                fileobj.close()
+            if fileobj is None:
+                raise
+            raise ReadError("not a gzip file")
+        except:
+            if not extfileobj and fileobj is not None:
+                fileobj.close()
+            raise
+        t._extfileobj = extfileobj
+        return t
+
+    @classmethod
+    def bz2open(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs):
+        """Open bzip2 compressed tar archive name for reading or writing.
+           Appending is not allowed.
+        """
+        if len(mode) > 1 or mode not in "rw":
+            raise ValueError("mode must be 'r' or 'w'.")
+
+        try:
+            import bz2
+        except ImportError:
+            raise CompressionError("bz2 module is not available")
+
+        if fileobj is not None:
+            fileobj = _BZ2Proxy(fileobj, mode)
+        else:
+            fileobj = bz2.BZ2File(name, mode, compresslevel=compresslevel)
+
+        try:
+            t = cls.taropen(name, mode, fileobj, **kwargs)
+        except (IOError, EOFError):
+            fileobj.close()
+            raise ReadError("not a bzip2 file")
+        t._extfileobj = False
+        return t
+
+    # All *open() methods are registered here.
+    OPEN_METH = {
+        "tar": "taropen",   # uncompressed tar
+        "gz":  "gzopen",    # gzip compressed tar
+        "bz2": "bz2open"    # bzip2 compressed tar
+    }
+
+    #--------------------------------------------------------------------------
+    # The public methods which TarFile provides:
+
+    def close(self):
+        """Close the TarFile. In write-mode, two finishing zero blocks are
+           appended to the archive.
+        """
+        if self.closed:
+            return
+
+        if self.mode in "aw":
+            self.fileobj.write(NUL * (BLOCKSIZE * 2))
+            self.offset += (BLOCKSIZE * 2)
+            # fill up the end with zero-blocks
+            # (like option -b20 for tar does)
+            blocks, remainder = divmod(self.offset, RECORDSIZE)
+            if remainder > 0:
+                self.fileobj.write(NUL * (RECORDSIZE - remainder))
+
+        if not self._extfileobj:
+            self.fileobj.close()
+        self.closed = True
+
+    def getmember(self, name):
+        """Return a TarInfo object for member `name'. If `name' can not be
+           found in the archive, KeyError is raised. If a member occurs more
+           than once in the archive, its last occurrence is assumed to be the
+           most up-to-date version.
+        """
+        tarinfo = self._getmember(name)
+        if tarinfo is None:
+            raise KeyError("filename %r not found" % name)
+        return tarinfo
+
+    def getmembers(self):
+        """Return the members of the archive as a list of TarInfo objects. The
+           list has the same order as the members in the archive.
+        """
+        self._check()
+        if not self._loaded:    # if we want to obtain a list of
+            self._load()        # all members, we first have to
+                                # scan the whole archive.
+        return self.members
+
+    def getnames(self):
+        """Return the members of the archive as a list of their names. It has
+           the same order as the list returned by getmembers().
+        """
+        return [tarinfo.name for tarinfo in self.getmembers()]
+
+    def gettarinfo(self, name=None, arcname=None, fileobj=None):
+        """Create a TarInfo object for either the file `name' or the file
+           object `fileobj' (using os.fstat on its file descriptor). You can
+           modify some of the TarInfo's attributes before you add it using
+           addfile(). If given, `arcname' specifies an alternative name for the
+           file in the archive.
+        """
+        self._check("aw")
+
+        # When fileobj is given, replace name by
+        # fileobj's real name.
+        if fileobj is not None:
+            name = fileobj.name
+
+        # Building the name of the member in the archive.
+        # Backward slashes are converted to forward slashes,
+        # Absolute paths are turned to relative paths.
+        if arcname is None:
+            arcname = name
+        drv, arcname = os.path.splitdrive(arcname)
+        arcname = arcname.replace(os.sep, "/")
+        arcname = arcname.lstrip("/")
+
+        # Now, fill the TarInfo object with
+        # information specific for the file.
+        tarinfo = self.tarinfo()
+        tarinfo.tarfile = self
+
+        # Use os.stat or os.lstat, depending on platform
+        # and if symlinks shall be resolved.
+        if fileobj is None:
+            if hasattr(os, "lstat") and not self.dereference:
+                statres = os.lstat(name)
+            else:
+                statres = os.stat(name)
+        else:
+            statres = os.fstat(fileobj.fileno())
+        linkname = ""
+
+        stmd = statres.st_mode
+        if stat.S_ISREG(stmd):
+            inode = (statres.st_ino, statres.st_dev)
+            if not self.dereference and statres.st_nlink > 1 and \
+                    inode in self.inodes and arcname != self.inodes[inode]:
+                # Is it a hardlink to an already
+                # archived file?
+                type = LNKTYPE
+                linkname = self.inodes[inode]
+            else:
+                # The inode is added only if its valid.
+                # For win32 it is always 0.
+                type = REGTYPE
+                if inode[0]:
+                    self.inodes[inode] = arcname
+        elif stat.S_ISDIR(stmd):
+            type = DIRTYPE
+        elif stat.S_ISFIFO(stmd):
+            type = FIFOTYPE
+        elif stat.S_ISLNK(stmd):
+            type = SYMTYPE
+            linkname = os.readlink(name)
+        elif stat.S_ISCHR(stmd):
+            type = CHRTYPE
+        elif stat.S_ISBLK(stmd):
+            type = BLKTYPE
+        else:
+            return None
+
+        # Fill the TarInfo object with all
+        # information we can get.
+        tarinfo.name = arcname
+        tarinfo.mode = stmd
+        tarinfo.uid = statres.st_uid
+        tarinfo.gid = statres.st_gid
+        if type == REGTYPE:
+            tarinfo.size = statres.st_size
+        else:
+            tarinfo.size = 0
+        tarinfo.mtime = statres.st_mtime
+        tarinfo.type = type
+        tarinfo.linkname = linkname
+        if pwd:
+            try:
+                tarinfo.uname = pwd.getpwuid(tarinfo.uid)[0]
+            except KeyError:
+                pass
+        if grp:
+            try:
+                tarinfo.gname = grp.getgrgid(tarinfo.gid)[0]
+            except KeyError:
+                pass
+
+        if type in (CHRTYPE, BLKTYPE):
+            if hasattr(os, "major") and hasattr(os, "minor"):
+                tarinfo.devmajor = os.major(statres.st_rdev)
+                tarinfo.devminor = os.minor(statres.st_rdev)
+        return tarinfo
+
+    def list(self, verbose=True):
+        """Print a table of contents to sys.stdout. If `verbose' is False, only
+           the names of the members are printed. If it is True, an `ls -l'-like
+           output is produced.
+        """
+        self._check()
+
+        for tarinfo in self:
+            if verbose:
+                print(filemode(tarinfo.mode), end=' ')
+                print("%s/%s" % (tarinfo.uname or tarinfo.uid,
+                                 tarinfo.gname or tarinfo.gid), end=' ')
+                if tarinfo.ischr() or tarinfo.isblk():
+                    print("%10s" % ("%d,%d" \
+                                    % (tarinfo.devmajor, tarinfo.devminor)), end=' ')
+                else:
+                    print("%10d" % tarinfo.size, end=' ')
+                print("%d-%02d-%02d %02d:%02d:%02d" \
+                      % time.localtime(tarinfo.mtime)[:6], end=' ')
+
+            print(tarinfo.name + ("/" if tarinfo.isdir() else ""), end=' ')
+
+            if verbose:
+                if tarinfo.issym():
+                    print("->", tarinfo.linkname, end=' ')
+                if tarinfo.islnk():
+                    print("link to", tarinfo.linkname, end=' ')
+            print()
+
+    def add(self, name, arcname=None, recursive=True, exclude=None, filter=None):
+        """Add the file `name' to the archive. `name' may be any type of file
+           (directory, fifo, symbolic link, etc.). If given, `arcname'
+           specifies an alternative name for the file in the archive.
+           Directories are added recursively by default. This can be avoided by
+           setting `recursive' to False. `exclude' is a function that should
+           return True for each filename to be excluded. `filter' is a function
+           that expects a TarInfo object argument and returns the changed
+           TarInfo object, if it returns None the TarInfo object will be
+           excluded from the archive.
+        """
+        self._check("aw")
+
+        if arcname is None:
+            arcname = name
+
+        # Exclude pathnames.
+        if exclude is not None:
+            import warnings
+            warnings.warn("use the filter argument instead",
+                    DeprecationWarning, 2)
+            if exclude(name):
+                self._dbg(2, "tarfile: Excluded %r" % name)
+                return
+
+        # Skip if somebody tries to archive the archive...
+        if self.name is not None and os.path.abspath(name) == self.name:
+            self._dbg(2, "tarfile: Skipped %r" % name)
+            return
+
+        self._dbg(1, name)
+
+        # Create a TarInfo object from the file.
+        tarinfo = self.gettarinfo(name, arcname)
+
+        if tarinfo is None:
+            self._dbg(1, "tarfile: Unsupported type %r" % name)
+            return
+
+        # Change or exclude the TarInfo object.
+        if filter is not None:
+            tarinfo = filter(tarinfo)
+            if tarinfo is None:
+                self._dbg(2, "tarfile: Excluded %r" % name)
+                return
+
+        # Append the tar header and data to the archive.
+        if tarinfo.isreg():
+            f = bltn_open(name, "rb")
+            self.addfile(tarinfo, f)
+            f.close()
+
+        elif tarinfo.isdir():
+            self.addfile(tarinfo)
+            if recursive:
+                for f in os.listdir(name):
+                    self.add(os.path.join(name, f), os.path.join(arcname, f),
+                            recursive, exclude, filter=filter)
+
+        else:
+            self.addfile(tarinfo)
+
+    def addfile(self, tarinfo, fileobj=None):
+        """Add the TarInfo object `tarinfo' to the archive. If `fileobj' is
+           given, tarinfo.size bytes are read from it and added to the archive.
+           You can create TarInfo objects using gettarinfo().
+           On Windows platforms, `fileobj' should always be opened with mode
+           'rb' to avoid irritation about the file size.
+        """
+        self._check("aw")
+
+        tarinfo = copy.copy(tarinfo)
+
+        buf = tarinfo.tobuf(self.format, self.encoding, self.errors)
+        self.fileobj.write(buf)
+        self.offset += len(buf)
+
+        # If there's data to follow, append it.
+        if fileobj is not None:
+            copyfileobj(fileobj, self.fileobj, tarinfo.size)
+            blocks, remainder = divmod(tarinfo.size, BLOCKSIZE)
+            if remainder > 0:
+                self.fileobj.write(NUL * (BLOCKSIZE - remainder))
+                blocks += 1
+            self.offset += blocks * BLOCKSIZE
+
+        self.members.append(tarinfo)
+
+    def extractall(self, path=".", members=None):
+        """Extract all members from the archive to the current working
+           directory and set owner, modification time and permissions on
+           directories afterwards. `path' specifies a different directory
+           to extract to. `members' is optional and must be a subset of the
+           list returned by getmembers().
+        """
+        directories = []
+
+        if members is None:
+            members = self
+
+        for tarinfo in members:
+            if tarinfo.isdir():
+                # Extract directories with a safe mode.
+                directories.append(tarinfo)
+                tarinfo = copy.copy(tarinfo)
+                tarinfo.mode = 0o700
+            # Do not set_attrs directories, as we will do that further down
+            self.extract(tarinfo, path, set_attrs=not tarinfo.isdir())
+
+        # Reverse sort directories.
+        directories.sort(key=lambda a: a.name)
+        directories.reverse()
+
+        # Set correct owner, mtime and filemode on directories.
+        for tarinfo in directories:
+            dirpath = os.path.join(path, tarinfo.name)
+            try:
+                self.chown(tarinfo, dirpath)
+                self.utime(tarinfo, dirpath)
+                self.chmod(tarinfo, dirpath)
+            except ExtractError as e:
+                if self.errorlevel > 1:
+                    raise
+                else:
+                    self._dbg(1, "tarfile: %s" % e)
+
+    def extract(self, member, path="", set_attrs=True):
+        """Extract a member from the archive to the current working directory,
+           using its full name. Its file information is extracted as accurately
+           as possible. `member' may be a filename or a TarInfo object. You can
+           specify a different directory using `path'. File attributes (owner,
+           mtime, mode) are set unless `set_attrs' is False.
+        """
+        self._check("r")
+
+        if isinstance(member, str):
+            tarinfo = self.getmember(member)
+        else:
+            tarinfo = member
+
+        # Prepare the link target for makelink().
+        if tarinfo.islnk():
+            tarinfo._link_target = os.path.join(path, tarinfo.linkname)
+
+        try:
+            self._extract_member(tarinfo, os.path.join(path, tarinfo.name),
+                                 set_attrs=set_attrs)
+        except EnvironmentError as e:
+            if self.errorlevel > 0:
+                raise
+            else:
+                if e.filename is None:
+                    self._dbg(1, "tarfile: %s" % e.strerror)
+                else:
+                    self._dbg(1, "tarfile: %s %r" % (e.strerror, e.filename))
+        except ExtractError as e:
+            if self.errorlevel > 1:
+                raise
+            else:
+                self._dbg(1, "tarfile: %s" % e)
+
+    def extractfile(self, member):
+        """Extract a member from the archive as a file object. `member' may be
+           a filename or a TarInfo object. If `member' is a regular file, a
+           file-like object is returned. If `member' is a link, a file-like
+           object is constructed from the link's target. If `member' is none of
+           the above, None is returned.
+           The file-like object is read-only and provides the following
+           methods: read(), readline(), readlines(), seek() and tell()
+        """
+        self._check("r")
+
+        if isinstance(member, str):
+            tarinfo = self.getmember(member)
+        else:
+            tarinfo = member
+
+        if tarinfo.isreg():
+            return self.fileobject(self, tarinfo)
+
+        elif tarinfo.type not in SUPPORTED_TYPES:
+            # If a member's type is unknown, it is treated as a
+            # regular file.
+            return self.fileobject(self, tarinfo)
+
+        elif tarinfo.islnk() or tarinfo.issym():
+            if isinstance(self.fileobj, _Stream):
+                # A small but ugly workaround for the case that someone tries
+                # to extract a (sym)link as a file-object from a non-seekable
+                # stream of tar blocks.
+                raise StreamError("cannot extract (sym)link as file object")
+            else:
+                # A (sym)link's file object is its target's file object.
+                return self.extractfile(self._find_link_target(tarinfo))
+        else:
+            # If there's no data associated with the member (directory, chrdev,
+            # blkdev, etc.), return None instead of a file object.
+            return None
+
+    def _extract_member(self, tarinfo, targetpath, set_attrs=True):
+        """Extract the TarInfo object tarinfo to a physical
+           file called targetpath.
+        """
+        # Fetch the TarInfo object for the given name
+        # and build the destination pathname, replacing
+        # forward slashes to platform specific separators.
+        targetpath = targetpath.rstrip("/")
+        targetpath = targetpath.replace("/", os.sep)
+
+        # Create all upper directories.
+        upperdirs = os.path.dirname(targetpath)
+        if upperdirs and not os.path.exists(upperdirs):
+            # Create directories that are not part of the archive with
+            # default permissions.
+            os.makedirs(upperdirs)
+
+        if tarinfo.islnk() or tarinfo.issym():
+            self._dbg(1, "%s -> %s" % (tarinfo.name, tarinfo.linkname))
+        else:
+            self._dbg(1, tarinfo.name)
+
+        if tarinfo.isreg():
+            self.makefile(tarinfo, targetpath)
+        elif tarinfo.isdir():
+            self.makedir(tarinfo, targetpath)
+        elif tarinfo.isfifo():
+            self.makefifo(tarinfo, targetpath)
+        elif tarinfo.ischr() or tarinfo.isblk():
+            self.makedev(tarinfo, targetpath)
+        elif tarinfo.islnk() or tarinfo.issym():
+            self.makelink(tarinfo, targetpath)
+        elif tarinfo.type not in SUPPORTED_TYPES:
+            self.makeunknown(tarinfo, targetpath)
+        else:
+            self.makefile(tarinfo, targetpath)
+
+        if set_attrs:
+            self.chown(tarinfo, targetpath)
+            if not tarinfo.issym():
+                self.chmod(tarinfo, targetpath)
+                self.utime(tarinfo, targetpath)
+
+    #--------------------------------------------------------------------------
+    # Below are the different file methods. They are called via
+    # _extract_member() when extract() is called. They can be replaced in a
+    # subclass to implement other functionality.
+
+    def makedir(self, tarinfo, targetpath):
+        """Make a directory called targetpath.
+        """
+        try:
+            # Use a safe mode for the directory, the real mode is set
+            # later in _extract_member().
+            os.mkdir(targetpath, 0o700)
+        except EnvironmentError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+    def makefile(self, tarinfo, targetpath):
+        """Make a file called targetpath.
+        """
+        source = self.fileobj
+        source.seek(tarinfo.offset_data)
+        target = bltn_open(targetpath, "wb")
+        if tarinfo.sparse is not None:
+            for offset, size in tarinfo.sparse:
+                target.seek(offset)
+                copyfileobj(source, target, size)
+        else:
+            copyfileobj(source, target, tarinfo.size)
+        target.seek(tarinfo.size)
+        target.truncate()
+        target.close()
+
+    def makeunknown(self, tarinfo, targetpath):
+        """Make a file from a TarInfo object with an unknown type
+           at targetpath.
+        """
+        self.makefile(tarinfo, targetpath)
+        self._dbg(1, "tarfile: Unknown file type %r, " \
+                     "extracted as regular file." % tarinfo.type)
+
+    def makefifo(self, tarinfo, targetpath):
+        """Make a fifo called targetpath.
+        """
+        if hasattr(os, "mkfifo"):
+            os.mkfifo(targetpath)
+        else:
+            raise ExtractError("fifo not supported by system")
+
+    def makedev(self, tarinfo, targetpath):
+        """Make a character or block device called targetpath.
+        """
+        if not hasattr(os, "mknod") or not hasattr(os, "makedev"):
+            raise ExtractError("special devices not supported by system")
+
+        mode = tarinfo.mode
+        if tarinfo.isblk():
+            mode |= stat.S_IFBLK
+        else:
+            mode |= stat.S_IFCHR
+
+        os.mknod(targetpath, mode,
+                 os.makedev(tarinfo.devmajor, tarinfo.devminor))
+
+    def makelink(self, tarinfo, targetpath):
+        """Make a (symbolic) link called targetpath. If it cannot be created
+          (platform limitation), we try to make a copy of the referenced file
+          instead of a link.
+        """
+        try:
+            # For systems that support symbolic and hard links.
+            if tarinfo.issym():
+                os.symlink(tarinfo.linkname, targetpath)
+            else:
+                # See extract().
+                if os.path.exists(tarinfo._link_target):
+                    os.link(tarinfo._link_target, targetpath)
+                else:
+                    self._extract_member(self._find_link_target(tarinfo),
+                                         targetpath)
+        except symlink_exception:
+            if tarinfo.issym():
+                linkpath = os.path.join(os.path.dirname(tarinfo.name),
+                                        tarinfo.linkname)
+            else:
+                linkpath = tarinfo.linkname
+        else:
+            try:
+                self._extract_member(self._find_link_target(tarinfo),
+                                     targetpath)
+            except KeyError:
+                raise ExtractError("unable to resolve link inside archive")
+
+    def chown(self, tarinfo, targetpath):
+        """Set owner of targetpath according to tarinfo.
+        """
+        if pwd and hasattr(os, "geteuid") and os.geteuid() == 0:
+            # We have to be root to do so.
+            try:
+                g = grp.getgrnam(tarinfo.gname)[2]
+            except KeyError:
+                g = tarinfo.gid
+            try:
+                u = pwd.getpwnam(tarinfo.uname)[2]
+            except KeyError:
+                u = tarinfo.uid
+            try:
+                if tarinfo.issym() and hasattr(os, "lchown"):
+                    os.lchown(targetpath, u, g)
+                else:
+                    if sys.platform != "os2emx":
+                        os.chown(targetpath, u, g)
+            except EnvironmentError as e:
+                raise ExtractError("could not change owner")
+
+    def chmod(self, tarinfo, targetpath):
+        """Set file permissions of targetpath according to tarinfo.
+        """
+        if hasattr(os, 'chmod'):
+            try:
+                os.chmod(targetpath, tarinfo.mode)
+            except EnvironmentError as e:
+                raise ExtractError("could not change mode")
+
+    def utime(self, tarinfo, targetpath):
+        """Set modification time of targetpath according to tarinfo.
+        """
+        if not hasattr(os, 'utime'):
+            return
+        try:
+            os.utime(targetpath, (tarinfo.mtime, tarinfo.mtime))
+        except EnvironmentError as e:
+            raise ExtractError("could not change modification time")
+
+    #--------------------------------------------------------------------------
+    def next(self):
+        """Return the next member of the archive as a TarInfo object, when
+           TarFile is opened for reading. Return None if there is no more
+           available.
+        """
+        self._check("ra")
+        if self.firstmember is not None:
+            m = self.firstmember
+            self.firstmember = None
+            return m
+
+        # Read the next block.
+        self.fileobj.seek(self.offset)
+        tarinfo = None
+        while True:
+            try:
+                tarinfo = self.tarinfo.fromtarfile(self)
+            except EOFHeaderError as e:
+                if self.ignore_zeros:
+                    self._dbg(2, "0x%X: %s" % (self.offset, e))
+                    self.offset += BLOCKSIZE
+                    continue
+            except InvalidHeaderError as e:
+                if self.ignore_zeros:
+                    self._dbg(2, "0x%X: %s" % (self.offset, e))
+                    self.offset += BLOCKSIZE
+                    continue
+                elif self.offset == 0:
+                    raise ReadError(str(e))
+            except EmptyHeaderError:
+                if self.offset == 0:
+                    raise ReadError("empty file")
+            except TruncatedHeaderError as e:
+                if self.offset == 0:
+                    raise ReadError(str(e))
+            except SubsequentHeaderError as e:
+                raise ReadError(str(e))
+            break
+
+        if tarinfo is not None:
+            self.members.append(tarinfo)
+        else:
+            self._loaded = True
+
+        return tarinfo
+
+    #--------------------------------------------------------------------------
+    # Little helper methods:
+
+    def _getmember(self, name, tarinfo=None, normalize=False):
+        """Find an archive member by name from bottom to top.
+           If tarinfo is given, it is used as the starting point.
+        """
+        # Ensure that all members have been loaded.
+        members = self.getmembers()
+
+        # Limit the member search list up to tarinfo.
+        if tarinfo is not None:
+            members = members[:members.index(tarinfo)]
+
+        if normalize:
+            name = os.path.normpath(name)
+
+        for member in reversed(members):
+            if normalize:
+                member_name = os.path.normpath(member.name)
+            else:
+                member_name = member.name
+
+            if name == member_name:
+                return member
+
+    def _load(self):
+        """Read through the entire archive file and look for readable
+           members.
+        """
+        while True:
+            tarinfo = self.next()
+            if tarinfo is None:
+                break
+        self._loaded = True
+
+    def _check(self, mode=None):
+        """Check if TarFile is still open, and if the operation's mode
+           corresponds to TarFile's mode.
+        """
+        if self.closed:
+            raise IOError("%s is closed" % self.__class__.__name__)
+        if mode is not None and self.mode not in mode:
+            raise IOError("bad operation for mode %r" % self.mode)
+
+    def _find_link_target(self, tarinfo):
+        """Find the target member of a symlink or hardlink member in the
+           archive.
+        """
+        if tarinfo.issym():
+            # Always search the entire archive.
+            linkname = os.path.dirname(tarinfo.name) + "/" + tarinfo.linkname
+            limit = None
+        else:
+            # Search the archive before the link, because a hard link is
+            # just a reference to an already archived file.
+            linkname = tarinfo.linkname
+            limit = tarinfo
+
+        member = self._getmember(linkname, tarinfo=limit, normalize=True)
+        if member is None:
+            raise KeyError("linkname %r not found" % linkname)
+        return member
+
+    def __iter__(self):
+        """Provide an iterator object.
+        """
+        if self._loaded:
+            return iter(self.members)
+        else:
+            return TarIter(self)
+
+    def _dbg(self, level, msg):
+        """Write debugging output to sys.stderr.
+        """
+        if level <= self.debug:
+            print(msg, file=sys.stderr)
+
+    def __enter__(self):
+        self._check()
+        return self
+
+    def __exit__(self, type, value, traceback):
+        if type is None:
+            self.close()
+        else:
+            # An exception occurred. We must not call close() because
+            # it would try to write end-of-archive blocks and padding.
+            if not self._extfileobj:
+                self.fileobj.close()
+            self.closed = True
+# class TarFile
+
+class TarIter(object):
+    """Iterator Class.
+
+       for tarinfo in TarFile(...):
+           suite...
+    """
+
+    def __init__(self, tarfile):
+        """Construct a TarIter object.
+        """
+        self.tarfile = tarfile
+        self.index = 0
+    def __iter__(self):
+        """Return iterator object.
+        """
+        return self
+
+    def __next__(self):
+        """Return the next item using TarFile's next() method.
+           When all members have been read, set TarFile as _loaded.
+        """
+        # Fix for SF #1100429: Under rare circumstances it can
+        # happen that getmembers() is called during iteration,
+        # which will cause TarIter to stop prematurely.
+        if not self.tarfile._loaded:
+            tarinfo = self.tarfile.next()
+            if not tarinfo:
+                self.tarfile._loaded = True
+                raise StopIteration
+        else:
+            try:
+                tarinfo = self.tarfile.members[self.index]
+            except IndexError:
+                raise StopIteration
+        self.index += 1
+        return tarinfo
+
+    next = __next__ # for Python 2.x
+
+#--------------------
+# exported functions
+#--------------------
+def is_tarfile(name):
+    """Return True if name points to a tar archive that we
+       are able to handle, else return False.
+    """
+    try:
+        t = open(name)
+        t.close()
+        return True
+    except TarError:
+        return False
+
+bltn_open = open
+open = TarFile.open
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/compat.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/compat.py
new file mode 100644
index 0000000..c316fd9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/compat.py
@@ -0,0 +1,1120 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013-2017 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+from __future__ import absolute_import
+
+import os
+import re
+import sys
+
+try:
+    import ssl
+except ImportError:  # pragma: no cover
+    ssl = None
+
+if sys.version_info[0] < 3:  # pragma: no cover
+    from StringIO import StringIO
+    string_types = basestring,
+    text_type = unicode
+    from types import FileType as file_type
+    import __builtin__ as builtins
+    import ConfigParser as configparser
+    from ._backport import shutil
+    from urlparse import urlparse, urlunparse, urljoin, urlsplit, urlunsplit
+    from urllib import (urlretrieve, quote as _quote, unquote, url2pathname,
+                        pathname2url, ContentTooShortError, splittype)
+
+    def quote(s):
+        if isinstance(s, unicode):
+            s = s.encode('utf-8')
+        return _quote(s)
+
+    import urllib2
+    from urllib2 import (Request, urlopen, URLError, HTTPError,
+                         HTTPBasicAuthHandler, HTTPPasswordMgr,
+                         HTTPHandler, HTTPRedirectHandler,
+                         build_opener)
+    if ssl:
+        from urllib2 import HTTPSHandler
+    import httplib
+    import xmlrpclib
+    import Queue as queue
+    from HTMLParser import HTMLParser
+    import htmlentitydefs
+    raw_input = raw_input
+    from itertools import ifilter as filter
+    from itertools import ifilterfalse as filterfalse
+
+    _userprog = None
+    def splituser(host):
+        """splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'."""
+        global _userprog
+        if _userprog is None:
+            import re
+            _userprog = re.compile('^(.*)@(.*)$')
+
+        match = _userprog.match(host)
+        if match: return match.group(1, 2)
+        return None, host
+
+else:  # pragma: no cover
+    from io import StringIO
+    string_types = str,
+    text_type = str
+    from io import TextIOWrapper as file_type
+    import builtins
+    import configparser
+    import shutil
+    from urllib.parse import (urlparse, urlunparse, urljoin, splituser, quote,
+                              unquote, urlsplit, urlunsplit, splittype)
+    from urllib.request import (urlopen, urlretrieve, Request, url2pathname,
+                                pathname2url,
+                                HTTPBasicAuthHandler, HTTPPasswordMgr,
+                                HTTPHandler, HTTPRedirectHandler,
+                                build_opener)
+    if ssl:
+        from urllib.request import HTTPSHandler
+    from urllib.error import HTTPError, URLError, ContentTooShortError
+    import http.client as httplib
+    import urllib.request as urllib2
+    import xmlrpc.client as xmlrpclib
+    import queue
+    from html.parser import HTMLParser
+    import html.entities as htmlentitydefs
+    raw_input = input
+    from itertools import filterfalse
+    filter = filter
+
+try:
+    from ssl import match_hostname, CertificateError
+except ImportError: # pragma: no cover
+    class CertificateError(ValueError):
+        pass
+
+
+    def _dnsname_match(dn, hostname, max_wildcards=1):
+        """Matching according to RFC 6125, section 6.4.3
+
+        http://tools.ietf.org/html/rfc6125#section-6.4.3
+        """
+        pats = []
+        if not dn:
+            return False
+
+        parts = dn.split('.')
+        leftmost, remainder = parts[0], parts[1:]
+
+        wildcards = leftmost.count('*')
+        if wildcards > max_wildcards:
+            # Issue #17980: avoid denials of service by refusing more
+            # than one wildcard per fragment.  A survey of established
+            # policy among SSL implementations showed it to be a
+            # reasonable choice.
+            raise CertificateError(
+                "too many wildcards in certificate DNS name: " + repr(dn))
+
+        # speed up common case w/o wildcards
+        if not wildcards:
+            return dn.lower() == hostname.lower()
+
+        # RFC 6125, section 6.4.3, subitem 1.
+        # The client SHOULD NOT attempt to match a presented identifier in which
+        # the wildcard character comprises a label other than the left-most label.
+        if leftmost == '*':
+            # When '*' is a fragment by itself, it matches a non-empty dotless
+            # fragment.
+            pats.append('[^.]+')
+        elif leftmost.startswith('xn--') or hostname.startswith('xn--'):
+            # RFC 6125, section 6.4.3, subitem 3.
+            # The client SHOULD NOT attempt to match a presented identifier
+            # where the wildcard character is embedded within an A-label or
+            # U-label of an internationalized domain name.
+            pats.append(re.escape(leftmost))
+        else:
+            # Otherwise, '*' matches any dotless string, e.g. www*
+            pats.append(re.escape(leftmost).replace(r'\*', '[^.]*'))
+
+        # add the remaining fragments, ignore any wildcards
+        for frag in remainder:
+            pats.append(re.escape(frag))
+
+        pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE)
+        return pat.match(hostname)
+
+
+    def match_hostname(cert, hostname):
+        """Verify that *cert* (in decoded format as returned by
+        SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
+        rules are followed, but IP addresses are not accepted for *hostname*.
+
+        CertificateError is raised on failure. On success, the function
+        returns nothing.
+        """
+        if not cert:
+            raise ValueError("empty or no certificate, match_hostname needs a "
+                             "SSL socket or SSL context with either "
+                             "CERT_OPTIONAL or CERT_REQUIRED")
+        dnsnames = []
+        san = cert.get('subjectAltName', ())
+        for key, value in san:
+            if key == 'DNS':
+                if _dnsname_match(value, hostname):
+                    return
+                dnsnames.append(value)
+        if not dnsnames:
+            # The subject is only checked when there is no dNSName entry
+            # in subjectAltName
+            for sub in cert.get('subject', ()):
+                for key, value in sub:
+                    # XXX according to RFC 2818, the most specific Common Name
+                    # must be used.
+                    if key == 'commonName':
+                        if _dnsname_match(value, hostname):
+                            return
+                        dnsnames.append(value)
+        if len(dnsnames) > 1:
+            raise CertificateError("hostname %r "
+                "doesn't match either of %s"
+                % (hostname, ', '.join(map(repr, dnsnames))))
+        elif len(dnsnames) == 1:
+            raise CertificateError("hostname %r "
+                "doesn't match %r"
+                % (hostname, dnsnames[0]))
+        else:
+            raise CertificateError("no appropriate commonName or "
+                "subjectAltName fields were found")
+
+
+try:
+    from types import SimpleNamespace as Container
+except ImportError:  # pragma: no cover
+    class Container(object):
+        """
+        A generic container for when multiple values need to be returned
+        """
+        def __init__(self, **kwargs):
+            self.__dict__.update(kwargs)
+
+
+try:
+    from shutil import which
+except ImportError:  # pragma: no cover
+    # Implementation from Python 3.3
+    def which(cmd, mode=os.F_OK | os.X_OK, path=None):
+        """Given a command, mode, and a PATH string, return the path which
+        conforms to the given mode on the PATH, or None if there is no such
+        file.
+
+        `mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
+        of os.environ.get("PATH"), or can be overridden with a custom search
+        path.
+
+        """
+        # Check that a given file can be accessed with the correct mode.
+        # Additionally check that `file` is not a directory, as on Windows
+        # directories pass the os.access check.
+        def _access_check(fn, mode):
+            return (os.path.exists(fn) and os.access(fn, mode)
+                    and not os.path.isdir(fn))
+
+        # If we're given a path with a directory part, look it up directly rather
+        # than referring to PATH directories. This includes checking relative to the
+        # current directory, e.g. ./script
+        if os.path.dirname(cmd):
+            if _access_check(cmd, mode):
+                return cmd
+            return None
+
+        if path is None:
+            path = os.environ.get("PATH", os.defpath)
+        if not path:
+            return None
+        path = path.split(os.pathsep)
+
+        if sys.platform == "win32":
+            # The current directory takes precedence on Windows.
+            if not os.curdir in path:
+                path.insert(0, os.curdir)
+
+            # PATHEXT is necessary to check on Windows.
+            pathext = os.environ.get("PATHEXT", "").split(os.pathsep)
+            # See if the given file matches any of the expected path extensions.
+            # This will allow us to short circuit when given "python.exe".
+            # If it does match, only test that one, otherwise we have to try
+            # others.
+            if any(cmd.lower().endswith(ext.lower()) for ext in pathext):
+                files = [cmd]
+            else:
+                files = [cmd + ext for ext in pathext]
+        else:
+            # On other platforms you don't have things like PATHEXT to tell you
+            # what file suffixes are executable, so just pass on cmd as-is.
+            files = [cmd]
+
+        seen = set()
+        for dir in path:
+            normdir = os.path.normcase(dir)
+            if not normdir in seen:
+                seen.add(normdir)
+                for thefile in files:
+                    name = os.path.join(dir, thefile)
+                    if _access_check(name, mode):
+                        return name
+        return None
+
+
+# ZipFile is a context manager in 2.7, but not in 2.6
+
+from zipfile import ZipFile as BaseZipFile
+
+if hasattr(BaseZipFile, '__enter__'):  # pragma: no cover
+    ZipFile = BaseZipFile
+else:  # pragma: no cover
+    from zipfile import ZipExtFile as BaseZipExtFile
+
+    class ZipExtFile(BaseZipExtFile):
+        def __init__(self, base):
+            self.__dict__.update(base.__dict__)
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc_info):
+            self.close()
+            # return None, so if an exception occurred, it will propagate
+
+    class ZipFile(BaseZipFile):
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc_info):
+            self.close()
+            # return None, so if an exception occurred, it will propagate
+
+        def open(self, *args, **kwargs):
+            base = BaseZipFile.open(self, *args, **kwargs)
+            return ZipExtFile(base)
+
+try:
+    from platform import python_implementation
+except ImportError: # pragma: no cover
+    def python_implementation():
+        """Return a string identifying the Python implementation."""
+        if 'PyPy' in sys.version:
+            return 'PyPy'
+        if os.name == 'java':
+            return 'Jython'
+        if sys.version.startswith('IronPython'):
+            return 'IronPython'
+        return 'CPython'
+
+try:
+    import sysconfig
+except ImportError: # pragma: no cover
+    from ._backport import sysconfig
+
+try:
+    callable = callable
+except NameError:   # pragma: no cover
+    from collections.abc import Callable
+
+    def callable(obj):
+        return isinstance(obj, Callable)
+
+
+try:
+    fsencode = os.fsencode
+    fsdecode = os.fsdecode
+except AttributeError:  # pragma: no cover
+    # Issue #99: on some systems (e.g. containerised),
+    # sys.getfilesystemencoding() returns None, and we need a real value,
+    # so fall back to utf-8. From the CPython 2.7 docs relating to Unix and
+    # sys.getfilesystemencoding(): the return value is "the user’s preference
+    # according to the result of nl_langinfo(CODESET), or None if the
+    # nl_langinfo(CODESET) failed."
+    _fsencoding = sys.getfilesystemencoding() or 'utf-8'
+    if _fsencoding == 'mbcs':
+        _fserrors = 'strict'
+    else:
+        _fserrors = 'surrogateescape'
+
+    def fsencode(filename):
+        if isinstance(filename, bytes):
+            return filename
+        elif isinstance(filename, text_type):
+            return filename.encode(_fsencoding, _fserrors)
+        else:
+            raise TypeError("expect bytes or str, not %s" %
+                            type(filename).__name__)
+
+    def fsdecode(filename):
+        if isinstance(filename, text_type):
+            return filename
+        elif isinstance(filename, bytes):
+            return filename.decode(_fsencoding, _fserrors)
+        else:
+            raise TypeError("expect bytes or str, not %s" %
+                            type(filename).__name__)
+
+try:
+    from tokenize import detect_encoding
+except ImportError: # pragma: no cover
+    from codecs import BOM_UTF8, lookup
+    import re
+
+    cookie_re = re.compile(r"coding[:=]\s*([-\w.]+)")
+
+    def _get_normal_name(orig_enc):
+        """Imitates get_normal_name in tokenizer.c."""
+        # Only care about the first 12 characters.
+        enc = orig_enc[:12].lower().replace("_", "-")
+        if enc == "utf-8" or enc.startswith("utf-8-"):
+            return "utf-8"
+        if enc in ("latin-1", "iso-8859-1", "iso-latin-1") or \
+           enc.startswith(("latin-1-", "iso-8859-1-", "iso-latin-1-")):
+            return "iso-8859-1"
+        return orig_enc
+
+    def detect_encoding(readline):
+        """
+        The detect_encoding() function is used to detect the encoding that should
+        be used to decode a Python source file.  It requires one argument, readline,
+        in the same way as the tokenize() generator.
+
+        It will call readline a maximum of twice, and return the encoding used
+        (as a string) and a list of any lines (left as bytes) it has read in.
+
+        It detects the encoding from the presence of a utf-8 bom or an encoding
+        cookie as specified in pep-0263.  If both a bom and a cookie are present,
+        but disagree, a SyntaxError will be raised.  If the encoding cookie is an
+        invalid charset, raise a SyntaxError.  Note that if a utf-8 bom is found,
+        'utf-8-sig' is returned.
+
+        If no encoding is specified, then the default of 'utf-8' will be returned.
+        """
+        try:
+            filename = readline.__self__.name
+        except AttributeError:
+            filename = None
+        bom_found = False
+        encoding = None
+        default = 'utf-8'
+        def read_or_stop():
+            try:
+                return readline()
+            except StopIteration:
+                return b''
+
+        def find_cookie(line):
+            try:
+                # Decode as UTF-8. Either the line is an encoding declaration,
+                # in which case it should be pure ASCII, or it must be UTF-8
+                # per default encoding.
+                line_string = line.decode('utf-8')
+            except UnicodeDecodeError:
+                msg = "invalid or missing encoding declaration"
+                if filename is not None:
+                    msg = '{} for {!r}'.format(msg, filename)
+                raise SyntaxError(msg)
+
+            matches = cookie_re.findall(line_string)
+            if not matches:
+                return None
+            encoding = _get_normal_name(matches[0])
+            try:
+                codec = lookup(encoding)
+            except LookupError:
+                # This behaviour mimics the Python interpreter
+                if filename is None:
+                    msg = "unknown encoding: " + encoding
+                else:
+                    msg = "unknown encoding for {!r}: {}".format(filename,
+                            encoding)
+                raise SyntaxError(msg)
+
+            if bom_found:
+                if codec.name != 'utf-8':
+                    # This behaviour mimics the Python interpreter
+                    if filename is None:
+                        msg = 'encoding problem: utf-8'
+                    else:
+                        msg = 'encoding problem for {!r}: utf-8'.format(filename)
+                    raise SyntaxError(msg)
+                encoding += '-sig'
+            return encoding
+
+        first = read_or_stop()
+        if first.startswith(BOM_UTF8):
+            bom_found = True
+            first = first[3:]
+            default = 'utf-8-sig'
+        if not first:
+            return default, []
+
+        encoding = find_cookie(first)
+        if encoding:
+            return encoding, [first]
+
+        second = read_or_stop()
+        if not second:
+            return default, [first]
+
+        encoding = find_cookie(second)
+        if encoding:
+            return encoding, [first, second]
+
+        return default, [first, second]
+
+# For converting & <-> &amp; etc.
+try:
+    from html import escape
+except ImportError:
+    from cgi import escape
+if sys.version_info[:2] < (3, 4):
+    unescape = HTMLParser().unescape
+else:
+    from html import unescape
+
+try:
+    from collections import ChainMap
+except ImportError: # pragma: no cover
+    from collections import MutableMapping
+
+    try:
+        from reprlib import recursive_repr as _recursive_repr
+    except ImportError:
+        def _recursive_repr(fillvalue='...'):
+            '''
+            Decorator to make a repr function return fillvalue for a recursive
+            call
+            '''
+
+            def decorating_function(user_function):
+                repr_running = set()
+
+                def wrapper(self):
+                    key = id(self), get_ident()
+                    if key in repr_running:
+                        return fillvalue
+                    repr_running.add(key)
+                    try:
+                        result = user_function(self)
+                    finally:
+                        repr_running.discard(key)
+                    return result
+
+                # Can't use functools.wraps() here because of bootstrap issues
+                wrapper.__module__ = getattr(user_function, '__module__')
+                wrapper.__doc__ = getattr(user_function, '__doc__')
+                wrapper.__name__ = getattr(user_function, '__name__')
+                wrapper.__annotations__ = getattr(user_function, '__annotations__', {})
+                return wrapper
+
+            return decorating_function
+
+    class ChainMap(MutableMapping):
+        ''' A ChainMap groups multiple dicts (or other mappings) together
+        to create a single, updateable view.
+
+        The underlying mappings are stored in a list.  That list is public and can
+        accessed or updated using the *maps* attribute.  There is no other state.
+
+        Lookups search the underlying mappings successively until a key is found.
+        In contrast, writes, updates, and deletions only operate on the first
+        mapping.
+
+        '''
+
+        def __init__(self, *maps):
+            '''Initialize a ChainMap by setting *maps* to the given mappings.
+            If no mappings are provided, a single empty dictionary is used.
+
+            '''
+            self.maps = list(maps) or [{}]          # always at least one map
+
+        def __missing__(self, key):
+            raise KeyError(key)
+
+        def __getitem__(self, key):
+            for mapping in self.maps:
+                try:
+                    return mapping[key]             # can't use 'key in mapping' with defaultdict
+                except KeyError:
+                    pass
+            return self.__missing__(key)            # support subclasses that define __missing__
+
+        def get(self, key, default=None):
+            return self[key] if key in self else default
+
+        def __len__(self):
+            return len(set().union(*self.maps))     # reuses stored hash values if possible
+
+        def __iter__(self):
+            return iter(set().union(*self.maps))
+
+        def __contains__(self, key):
+            return any(key in m for m in self.maps)
+
+        def __bool__(self):
+            return any(self.maps)
+
+        @_recursive_repr()
+        def __repr__(self):
+            return '{0.__class__.__name__}({1})'.format(
+                self, ', '.join(map(repr, self.maps)))
+
+        @classmethod
+        def fromkeys(cls, iterable, *args):
+            'Create a ChainMap with a single dict created from the iterable.'
+            return cls(dict.fromkeys(iterable, *args))
+
+        def copy(self):
+            'New ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]'
+            return self.__class__(self.maps[0].copy(), *self.maps[1:])
+
+        __copy__ = copy
+
+        def new_child(self):                        # like Django's Context.push()
+            'New ChainMap with a new dict followed by all previous maps.'
+            return self.__class__({}, *self.maps)
+
+        @property
+        def parents(self):                          # like Django's Context.pop()
+            'New ChainMap from maps[1:].'
+            return self.__class__(*self.maps[1:])
+
+        def __setitem__(self, key, value):
+            self.maps[0][key] = value
+
+        def __delitem__(self, key):
+            try:
+                del self.maps[0][key]
+            except KeyError:
+                raise KeyError('Key not found in the first mapping: {!r}'.format(key))
+
+        def popitem(self):
+            'Remove and return an item pair from maps[0]. Raise KeyError is maps[0] is empty.'
+            try:
+                return self.maps[0].popitem()
+            except KeyError:
+                raise KeyError('No keys found in the first mapping.')
+
+        def pop(self, key, *args):
+            'Remove *key* from maps[0] and return its value. Raise KeyError if *key* not in maps[0].'
+            try:
+                return self.maps[0].pop(key, *args)
+            except KeyError:
+                raise KeyError('Key not found in the first mapping: {!r}'.format(key))
+
+        def clear(self):
+            'Clear maps[0], leaving maps[1:] intact.'
+            self.maps[0].clear()
+
+try:
+    from importlib.util import cache_from_source  # Python >= 3.4
+except ImportError:  # pragma: no cover
+    try:
+        from imp import cache_from_source
+    except ImportError:  # pragma: no cover
+        def cache_from_source(path, debug_override=None):
+            assert path.endswith('.py')
+            if debug_override is None:
+                debug_override = __debug__
+            if debug_override:
+                suffix = 'c'
+            else:
+                suffix = 'o'
+            return path + suffix
+
+try:
+    from collections import OrderedDict
+except ImportError: # pragma: no cover
+## {{{ http://code.activestate.com/recipes/576693/ (r9)
+# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.
+# Passes Python2.7's test suite and incorporates all the latest updates.
+    try:
+        from thread import get_ident as _get_ident
+    except ImportError:
+        from dummy_thread import get_ident as _get_ident
+
+    try:
+        from _abcoll import KeysView, ValuesView, ItemsView
+    except ImportError:
+        pass
+
+
+    class OrderedDict(dict):
+        'Dictionary that remembers insertion order'
+        # An inherited dict maps keys to values.
+        # The inherited dict provides __getitem__, __len__, __contains__, and get.
+        # The remaining methods are order-aware.
+        # Big-O running times for all methods are the same as for regular dictionaries.
+
+        # The internal self.__map dictionary maps keys to links in a doubly linked list.
+        # The circular doubly linked list starts and ends with a sentinel element.
+        # The sentinel element never gets deleted (this simplifies the algorithm).
+        # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
+
+        def __init__(self, *args, **kwds):
+            '''Initialize an ordered dictionary.  Signature is the same as for
+            regular dictionaries, but keyword arguments are not recommended
+            because their insertion order is arbitrary.
+
+            '''
+            if len(args) > 1:
+                raise TypeError('expected at most 1 arguments, got %d' % len(args))
+            try:
+                self.__root
+            except AttributeError:
+                self.__root = root = []                     # sentinel node
+                root[:] = [root, root, None]
+                self.__map = {}
+            self.__update(*args, **kwds)
+
+        def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
+            'od.__setitem__(i, y) <==> od[i]=y'
+            # Setting a new item creates a new link which goes at the end of the linked
+            # list, and the inherited dictionary is updated with the new key/value pair.
+            if key not in self:
+                root = self.__root
+                last = root[0]
+                last[1] = root[0] = self.__map[key] = [last, root, key]
+            dict_setitem(self, key, value)
+
+        def __delitem__(self, key, dict_delitem=dict.__delitem__):
+            'od.__delitem__(y) <==> del od[y]'
+            # Deleting an existing item uses self.__map to find the link which is
+            # then removed by updating the links in the predecessor and successor nodes.
+            dict_delitem(self, key)
+            link_prev, link_next, key = self.__map.pop(key)
+            link_prev[1] = link_next
+            link_next[0] = link_prev
+
+        def __iter__(self):
+            'od.__iter__() <==> iter(od)'
+            root = self.__root
+            curr = root[1]
+            while curr is not root:
+                yield curr[2]
+                curr = curr[1]
+
+        def __reversed__(self):
+            'od.__reversed__() <==> reversed(od)'
+            root = self.__root
+            curr = root[0]
+            while curr is not root:
+                yield curr[2]
+                curr = curr[0]
+
+        def clear(self):
+            'od.clear() -> None.  Remove all items from od.'
+            try:
+                for node in self.__map.itervalues():
+                    del node[:]
+                root = self.__root
+                root[:] = [root, root, None]
+                self.__map.clear()
+            except AttributeError:
+                pass
+            dict.clear(self)
+
+        def popitem(self, last=True):
+            '''od.popitem() -> (k, v), return and remove a (key, value) pair.
+            Pairs are returned in LIFO order if last is true or FIFO order if false.
+
+            '''
+            if not self:
+                raise KeyError('dictionary is empty')
+            root = self.__root
+            if last:
+                link = root[0]
+                link_prev = link[0]
+                link_prev[1] = root
+                root[0] = link_prev
+            else:
+                link = root[1]
+                link_next = link[1]
+                root[1] = link_next
+                link_next[0] = root
+            key = link[2]
+            del self.__map[key]
+            value = dict.pop(self, key)
+            return key, value
+
+        # -- the following methods do not depend on the internal structure --
+
+        def keys(self):
+            'od.keys() -> list of keys in od'
+            return list(self)
+
+        def values(self):
+            'od.values() -> list of values in od'
+            return [self[key] for key in self]
+
+        def items(self):
+            'od.items() -> list of (key, value) pairs in od'
+            return [(key, self[key]) for key in self]
+
+        def iterkeys(self):
+            'od.iterkeys() -> an iterator over the keys in od'
+            return iter(self)
+
+        def itervalues(self):
+            'od.itervalues -> an iterator over the values in od'
+            for k in self:
+                yield self[k]
+
+        def iteritems(self):
+            'od.iteritems -> an iterator over the (key, value) items in od'
+            for k in self:
+                yield (k, self[k])
+
+        def update(*args, **kwds):
+            '''od.update(E, **F) -> None.  Update od from dict/iterable E and F.
+
+            If E is a dict instance, does:           for k in E: od[k] = E[k]
+            If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
+            Or if E is an iterable of items, does:   for k, v in E: od[k] = v
+            In either case, this is followed by:     for k, v in F.items(): od[k] = v
+
+            '''
+            if len(args) > 2:
+                raise TypeError('update() takes at most 2 positional '
+                                'arguments (%d given)' % (len(args),))
+            elif not args:
+                raise TypeError('update() takes at least 1 argument (0 given)')
+            self = args[0]
+            # Make progressively weaker assumptions about "other"
+            other = ()
+            if len(args) == 2:
+                other = args[1]
+            if isinstance(other, dict):
+                for key in other:
+                    self[key] = other[key]
+            elif hasattr(other, 'keys'):
+                for key in other.keys():
+                    self[key] = other[key]
+            else:
+                for key, value in other:
+                    self[key] = value
+            for key, value in kwds.items():
+                self[key] = value
+
+        __update = update  # let subclasses override update without breaking __init__
+
+        __marker = object()
+
+        def pop(self, key, default=__marker):
+            '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+            If key is not found, d is returned if given, otherwise KeyError is raised.
+
+            '''
+            if key in self:
+                result = self[key]
+                del self[key]
+                return result
+            if default is self.__marker:
+                raise KeyError(key)
+            return default
+
+        def setdefault(self, key, default=None):
+            'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
+            if key in self:
+                return self[key]
+            self[key] = default
+            return default
+
+        def __repr__(self, _repr_running=None):
+            'od.__repr__() <==> repr(od)'
+            if not _repr_running: _repr_running = {}
+            call_key = id(self), _get_ident()
+            if call_key in _repr_running:
+                return '...'
+            _repr_running[call_key] = 1
+            try:
+                if not self:
+                    return '%s()' % (self.__class__.__name__,)
+                return '%s(%r)' % (self.__class__.__name__, self.items())
+            finally:
+                del _repr_running[call_key]
+
+        def __reduce__(self):
+            'Return state information for pickling'
+            items = [[k, self[k]] for k in self]
+            inst_dict = vars(self).copy()
+            for k in vars(OrderedDict()):
+                inst_dict.pop(k, None)
+            if inst_dict:
+                return (self.__class__, (items,), inst_dict)
+            return self.__class__, (items,)
+
+        def copy(self):
+            'od.copy() -> a shallow copy of od'
+            return self.__class__(self)
+
+        @classmethod
+        def fromkeys(cls, iterable, value=None):
+            '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
+            and values equal to v (which defaults to None).
+
+            '''
+            d = cls()
+            for key in iterable:
+                d[key] = value
+            return d
+
+        def __eq__(self, other):
+            '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
+            while comparison to a regular mapping is order-insensitive.
+
+            '''
+            if isinstance(other, OrderedDict):
+                return len(self)==len(other) and self.items() == other.items()
+            return dict.__eq__(self, other)
+
+        def __ne__(self, other):
+            return not self == other
+
+        # -- the following methods are only used in Python 2.7 --
+
+        def viewkeys(self):
+            "od.viewkeys() -> a set-like object providing a view on od's keys"
+            return KeysView(self)
+
+        def viewvalues(self):
+            "od.viewvalues() -> an object providing a view on od's values"
+            return ValuesView(self)
+
+        def viewitems(self):
+            "od.viewitems() -> a set-like object providing a view on od's items"
+            return ItemsView(self)
+
+try:
+    from logging.config import BaseConfigurator, valid_ident
+except ImportError: # pragma: no cover
+    IDENTIFIER = re.compile('^[a-z_][a-z0-9_]*$', re.I)
+
+
+    def valid_ident(s):
+        m = IDENTIFIER.match(s)
+        if not m:
+            raise ValueError('Not a valid Python identifier: %r' % s)
+        return True
+
+
+    # The ConvertingXXX classes are wrappers around standard Python containers,
+    # and they serve to convert any suitable values in the container. The
+    # conversion converts base dicts, lists and tuples to their wrapped
+    # equivalents, whereas strings which match a conversion format are converted
+    # appropriately.
+    #
+    # Each wrapper should have a configurator attribute holding the actual
+    # configurator to use for conversion.
+
+    class ConvertingDict(dict):
+        """A converting dictionary wrapper."""
+
+        def __getitem__(self, key):
+            value = dict.__getitem__(self, key)
+            result = self.configurator.convert(value)
+            #If the converted value is different, save for next time
+            if value is not result:
+                self[key] = result
+                if type(result) in (ConvertingDict, ConvertingList,
+                                    ConvertingTuple):
+                    result.parent = self
+                    result.key = key
+            return result
+
+        def get(self, key, default=None):
+            value = dict.get(self, key, default)
+            result = self.configurator.convert(value)
+            #If the converted value is different, save for next time
+            if value is not result:
+                self[key] = result
+                if type(result) in (ConvertingDict, ConvertingList,
+                                    ConvertingTuple):
+                    result.parent = self
+                    result.key = key
+            return result
+
+    def pop(self, key, default=None):
+        value = dict.pop(self, key, default)
+        result = self.configurator.convert(value)
+        if value is not result:
+            if type(result) in (ConvertingDict, ConvertingList,
+                                ConvertingTuple):
+                result.parent = self
+                result.key = key
+        return result
+
+    class ConvertingList(list):
+        """A converting list wrapper."""
+        def __getitem__(self, key):
+            value = list.__getitem__(self, key)
+            result = self.configurator.convert(value)
+            #If the converted value is different, save for next time
+            if value is not result:
+                self[key] = result
+                if type(result) in (ConvertingDict, ConvertingList,
+                                    ConvertingTuple):
+                    result.parent = self
+                    result.key = key
+            return result
+
+        def pop(self, idx=-1):
+            value = list.pop(self, idx)
+            result = self.configurator.convert(value)
+            if value is not result:
+                if type(result) in (ConvertingDict, ConvertingList,
+                                    ConvertingTuple):
+                    result.parent = self
+            return result
+
+    class ConvertingTuple(tuple):
+        """A converting tuple wrapper."""
+        def __getitem__(self, key):
+            value = tuple.__getitem__(self, key)
+            result = self.configurator.convert(value)
+            if value is not result:
+                if type(result) in (ConvertingDict, ConvertingList,
+                                    ConvertingTuple):
+                    result.parent = self
+                    result.key = key
+            return result
+
+    class BaseConfigurator(object):
+        """
+        The configurator base class which defines some useful defaults.
+        """
+
+        CONVERT_PATTERN = re.compile(r'^(?P<prefix>[a-z]+)://(?P<suffix>.*)$')
+
+        WORD_PATTERN = re.compile(r'^\s*(\w+)\s*')
+        DOT_PATTERN = re.compile(r'^\.\s*(\w+)\s*')
+        INDEX_PATTERN = re.compile(r'^\[\s*(\w+)\s*\]\s*')
+        DIGIT_PATTERN = re.compile(r'^\d+$')
+
+        value_converters = {
+            'ext' : 'ext_convert',
+            'cfg' : 'cfg_convert',
+        }
+
+        # We might want to use a different one, e.g. importlib
+        importer = staticmethod(__import__)
+
+        def __init__(self, config):
+            self.config = ConvertingDict(config)
+            self.config.configurator = self
+
+        def resolve(self, s):
+            """
+            Resolve strings to objects using standard import and attribute
+            syntax.
+            """
+            name = s.split('.')
+            used = name.pop(0)
+            try:
+                found = self.importer(used)
+                for frag in name:
+                    used += '.' + frag
+                    try:
+                        found = getattr(found, frag)
+                    except AttributeError:
+                        self.importer(used)
+                        found = getattr(found, frag)
+                return found
+            except ImportError:
+                e, tb = sys.exc_info()[1:]
+                v = ValueError('Cannot resolve %r: %s' % (s, e))
+                v.__cause__, v.__traceback__ = e, tb
+                raise v
+
+        def ext_convert(self, value):
+            """Default converter for the ext:// protocol."""
+            return self.resolve(value)
+
+        def cfg_convert(self, value):
+            """Default converter for the cfg:// protocol."""
+            rest = value
+            m = self.WORD_PATTERN.match(rest)
+            if m is None:
+                raise ValueError("Unable to convert %r" % value)
+            else:
+                rest = rest[m.end():]
+                d = self.config[m.groups()[0]]
+                #print d, rest
+                while rest:
+                    m = self.DOT_PATTERN.match(rest)
+                    if m:
+                        d = d[m.groups()[0]]
+                    else:
+                        m = self.INDEX_PATTERN.match(rest)
+                        if m:
+                            idx = m.groups()[0]
+                            if not self.DIGIT_PATTERN.match(idx):
+                                d = d[idx]
+                            else:
+                                try:
+                                    n = int(idx) # try as number first (most likely)
+                                    d = d[n]
+                                except TypeError:
+                                    d = d[idx]
+                    if m:
+                        rest = rest[m.end():]
+                    else:
+                        raise ValueError('Unable to convert '
+                                         '%r at %r' % (value, rest))
+            #rest should be empty
+            return d
+
+        def convert(self, value):
+            """
+            Convert values to an appropriate type. dicts, lists and tuples are
+            replaced by their converting alternatives. Strings are checked to
+            see if they have a conversion format and are converted if they do.
+            """
+            if not isinstance(value, ConvertingDict) and isinstance(value, dict):
+                value = ConvertingDict(value)
+                value.configurator = self
+            elif not isinstance(value, ConvertingList) and isinstance(value, list):
+                value = ConvertingList(value)
+                value.configurator = self
+            elif not isinstance(value, ConvertingTuple) and\
+                     isinstance(value, tuple):
+                value = ConvertingTuple(value)
+                value.configurator = self
+            elif isinstance(value, string_types):
+                m = self.CONVERT_PATTERN.match(value)
+                if m:
+                    d = m.groupdict()
+                    prefix = d['prefix']
+                    converter = self.value_converters.get(prefix, None)
+                    if converter:
+                        suffix = d['suffix']
+                        converter = getattr(self, converter)
+                        value = converter(suffix)
+            return value
+
+        def configure_custom(self, config):
+            """Configure an object with a user-supplied factory."""
+            c = config.pop('()')
+            if not callable(c):
+                c = self.resolve(c)
+            props = config.pop('.', None)
+            # Check for valid identifiers
+            kwargs = dict([(k, config[k]) for k in config if valid_ident(k)])
+            result = c(**kwargs)
+            if props:
+                for name, value in props.items():
+                    setattr(result, name, value)
+            return result
+
+        def as_tuple(self, value):
+            """Utility function which converts lists to tuples."""
+            if isinstance(value, list):
+                value = tuple(value)
+            return value
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/database.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/database.py
new file mode 100644
index 0000000..0a90c30
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/database.py
@@ -0,0 +1,1339 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2017 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""PEP 376 implementation."""
+
+from __future__ import unicode_literals
+
+import base64
+import codecs
+import contextlib
+import hashlib
+import logging
+import os
+import posixpath
+import sys
+import zipimport
+
+from . import DistlibException, resources
+from .compat import StringIO
+from .version import get_scheme, UnsupportedVersionError
+from .metadata import (Metadata, METADATA_FILENAME, WHEEL_METADATA_FILENAME,
+                       LEGACY_METADATA_FILENAME)
+from .util import (parse_requirement, cached_property, parse_name_and_version,
+                   read_exports, write_exports, CSVReader, CSVWriter)
+
+
+__all__ = ['Distribution', 'BaseInstalledDistribution',
+           'InstalledDistribution', 'EggInfoDistribution',
+           'DistributionPath']
+
+
+logger = logging.getLogger(__name__)
+
+EXPORTS_FILENAME = 'pydist-exports.json'
+COMMANDS_FILENAME = 'pydist-commands.json'
+
+DIST_FILES = ('INSTALLER', METADATA_FILENAME, 'RECORD', 'REQUESTED',
+              'RESOURCES', EXPORTS_FILENAME, 'SHARED')
+
+DISTINFO_EXT = '.dist-info'
+
+
+class _Cache(object):
+    """
+    A simple cache mapping names and .dist-info paths to distributions
+    """
+    def __init__(self):
+        """
+        Initialise an instance. There is normally one for each DistributionPath.
+        """
+        self.name = {}
+        self.path = {}
+        self.generated = False
+
+    def clear(self):
+        """
+        Clear the cache, setting it to its initial state.
+        """
+        self.name.clear()
+        self.path.clear()
+        self.generated = False
+
+    def add(self, dist):
+        """
+        Add a distribution to the cache.
+        :param dist: The distribution to add.
+        """
+        if dist.path not in self.path:
+            self.path[dist.path] = dist
+            self.name.setdefault(dist.key, []).append(dist)
+
+
+class DistributionPath(object):
+    """
+    Represents a set of distributions installed on a path (typically sys.path).
+    """
+    def __init__(self, path=None, include_egg=False):
+        """
+        Create an instance from a path, optionally including legacy (distutils/
+        setuptools/distribute) distributions.
+        :param path: The path to use, as a list of directories. If not specified,
+                     sys.path is used.
+        :param include_egg: If True, this instance will look for and return legacy
+                            distributions as well as those based on PEP 376.
+        """
+        if path is None:
+            path = sys.path
+        self.path = path
+        self._include_dist = True
+        self._include_egg = include_egg
+
+        self._cache = _Cache()
+        self._cache_egg = _Cache()
+        self._cache_enabled = True
+        self._scheme = get_scheme('default')
+
+    def _get_cache_enabled(self):
+        return self._cache_enabled
+
+    def _set_cache_enabled(self, value):
+        self._cache_enabled = value
+
+    cache_enabled = property(_get_cache_enabled, _set_cache_enabled)
+
+    def clear_cache(self):
+        """
+        Clears the internal cache.
+        """
+        self._cache.clear()
+        self._cache_egg.clear()
+
+
+    def _yield_distributions(self):
+        """
+        Yield .dist-info and/or .egg(-info) distributions.
+        """
+        # We need to check if we've seen some resources already, because on
+        # some Linux systems (e.g. some Debian/Ubuntu variants) there are
+        # symlinks which alias other files in the environment.
+        seen = set()
+        for path in self.path:
+            finder = resources.finder_for_path(path)
+            if finder is None:
+                continue
+            r = finder.find('')
+            if not r or not r.is_container:
+                continue
+            rset = sorted(r.resources)
+            for entry in rset:
+                r = finder.find(entry)
+                if not r or r.path in seen:
+                    continue
+                if self._include_dist and entry.endswith(DISTINFO_EXT):
+                    possible_filenames = [METADATA_FILENAME,
+                                          WHEEL_METADATA_FILENAME,
+                                          LEGACY_METADATA_FILENAME]
+                    for metadata_filename in possible_filenames:
+                        metadata_path = posixpath.join(entry, metadata_filename)
+                        pydist = finder.find(metadata_path)
+                        if pydist:
+                            break
+                    else:
+                        continue
+
+                    with contextlib.closing(pydist.as_stream()) as stream:
+                        metadata = Metadata(fileobj=stream, scheme='legacy')
+                    logger.debug('Found %s', r.path)
+                    seen.add(r.path)
+                    yield new_dist_class(r.path, metadata=metadata,
+                                         env=self)
+                elif self._include_egg and entry.endswith(('.egg-info',
+                                                          '.egg')):
+                    logger.debug('Found %s', r.path)
+                    seen.add(r.path)
+                    yield old_dist_class(r.path, self)
+
+    def _generate_cache(self):
+        """
+        Scan the path for distributions and populate the cache with
+        those that are found.
+        """
+        gen_dist = not self._cache.generated
+        gen_egg = self._include_egg and not self._cache_egg.generated
+        if gen_dist or gen_egg:
+            for dist in self._yield_distributions():
+                if isinstance(dist, InstalledDistribution):
+                    self._cache.add(dist)
+                else:
+                    self._cache_egg.add(dist)
+
+            if gen_dist:
+                self._cache.generated = True
+            if gen_egg:
+                self._cache_egg.generated = True
+
+    @classmethod
+    def distinfo_dirname(cls, name, version):
+        """
+        The *name* and *version* parameters are converted into their
+        filename-escaped form, i.e. any ``'-'`` characters are replaced
+        with ``'_'`` other than the one in ``'dist-info'`` and the one
+        separating the name from the version number.
+
+        :parameter name: is converted to a standard distribution name by replacing
+                         any runs of non- alphanumeric characters with a single
+                         ``'-'``.
+        :type name: string
+        :parameter version: is converted to a standard version string. Spaces
+                            become dots, and all other non-alphanumeric characters
+                            (except dots) become dashes, with runs of multiple
+                            dashes condensed to a single dash.
+        :type version: string
+        :returns: directory name
+        :rtype: string"""
+        name = name.replace('-', '_')
+        return '-'.join([name, version]) + DISTINFO_EXT
+
+    def get_distributions(self):
+        """
+        Provides an iterator that looks for distributions and returns
+        :class:`InstalledDistribution` or
+        :class:`EggInfoDistribution` instances for each one of them.
+
+        :rtype: iterator of :class:`InstalledDistribution` and
+                :class:`EggInfoDistribution` instances
+        """
+        if not self._cache_enabled:
+            for dist in self._yield_distributions():
+                yield dist
+        else:
+            self._generate_cache()
+
+            for dist in self._cache.path.values():
+                yield dist
+
+            if self._include_egg:
+                for dist in self._cache_egg.path.values():
+                    yield dist
+
+    def get_distribution(self, name):
+        """
+        Looks for a named distribution on the path.
+
+        This function only returns the first result found, as no more than one
+        value is expected. If nothing is found, ``None`` is returned.
+
+        :rtype: :class:`InstalledDistribution`, :class:`EggInfoDistribution`
+                or ``None``
+        """
+        result = None
+        name = name.lower()
+        if not self._cache_enabled:
+            for dist in self._yield_distributions():
+                if dist.key == name:
+                    result = dist
+                    break
+        else:
+            self._generate_cache()
+
+            if name in self._cache.name:
+                result = self._cache.name[name][0]
+            elif self._include_egg and name in self._cache_egg.name:
+                result = self._cache_egg.name[name][0]
+        return result
+
+    def provides_distribution(self, name, version=None):
+        """
+        Iterates over all distributions to find which distributions provide *name*.
+        If a *version* is provided, it will be used to filter the results.
+
+        This function only returns the first result found, since no more than
+        one values are expected. If the directory is not found, returns ``None``.
+
+        :parameter version: a version specifier that indicates the version
+                            required, conforming to the format in ``PEP-345``
+
+        :type name: string
+        :type version: string
+        """
+        matcher = None
+        if version is not None:
+            try:
+                matcher = self._scheme.matcher('%s (%s)' % (name, version))
+            except ValueError:
+                raise DistlibException('invalid name or version: %r, %r' %
+                                      (name, version))
+
+        for dist in self.get_distributions():
+            # We hit a problem on Travis where enum34 was installed and doesn't
+            # have a provides attribute ...
+            if not hasattr(dist, 'provides'):
+                logger.debug('No "provides": %s', dist)
+            else:
+                provided = dist.provides
+
+                for p in provided:
+                    p_name, p_ver = parse_name_and_version(p)
+                    if matcher is None:
+                        if p_name == name:
+                            yield dist
+                            break
+                    else:
+                        if p_name == name and matcher.match(p_ver):
+                            yield dist
+                            break
+
+    def get_file_path(self, name, relative_path):
+        """
+        Return the path to a resource file.
+        """
+        dist = self.get_distribution(name)
+        if dist is None:
+            raise LookupError('no distribution named %r found' % name)
+        return dist.get_resource_path(relative_path)
+
+    def get_exported_entries(self, category, name=None):
+        """
+        Return all of the exported entries in a particular category.
+
+        :param category: The category to search for entries.
+        :param name: If specified, only entries with that name are returned.
+        """
+        for dist in self.get_distributions():
+            r = dist.exports
+            if category in r:
+                d = r[category]
+                if name is not None:
+                    if name in d:
+                        yield d[name]
+                else:
+                    for v in d.values():
+                        yield v
+
+
+class Distribution(object):
+    """
+    A base class for distributions, whether installed or from indexes.
+    Either way, it must have some metadata, so that's all that's needed
+    for construction.
+    """
+
+    build_time_dependency = False
+    """
+    Set to True if it's known to be only a build-time dependency (i.e.
+    not needed after installation).
+    """
+
+    requested = False
+    """A boolean that indicates whether the ``REQUESTED`` metadata file is
+    present (in other words, whether the package was installed by user
+    request or it was installed as a dependency)."""
+
+    def __init__(self, metadata):
+        """
+        Initialise an instance.
+        :param metadata: The instance of :class:`Metadata` describing this
+        distribution.
+        """
+        self.metadata = metadata
+        self.name = metadata.name
+        self.key = self.name.lower()    # for case-insensitive comparisons
+        self.version = metadata.version
+        self.locator = None
+        self.digest = None
+        self.extras = None      # additional features requested
+        self.context = None     # environment marker overrides
+        self.download_urls = set()
+        self.digests = {}
+
+    @property
+    def source_url(self):
+        """
+        The source archive download URL for this distribution.
+        """
+        return self.metadata.source_url
+
+    download_url = source_url   # Backward compatibility
+
+    @property
+    def name_and_version(self):
+        """
+        A utility property which displays the name and version in parentheses.
+        """
+        return '%s (%s)' % (self.name, self.version)
+
+    @property
+    def provides(self):
+        """
+        A set of distribution names and versions provided by this distribution.
+        :return: A set of "name (version)" strings.
+        """
+        plist = self.metadata.provides
+        s = '%s (%s)' % (self.name, self.version)
+        if s not in plist:
+            plist.append(s)
+        return plist
+
+    def _get_requirements(self, req_attr):
+        md = self.metadata
+        logger.debug('Getting requirements from metadata %r', md.todict())
+        reqts = getattr(md, req_attr)
+        return set(md.get_requirements(reqts, extras=self.extras,
+                                       env=self.context))
+
+    @property
+    def run_requires(self):
+        return self._get_requirements('run_requires')
+
+    @property
+    def meta_requires(self):
+        return self._get_requirements('meta_requires')
+
+    @property
+    def build_requires(self):
+        return self._get_requirements('build_requires')
+
+    @property
+    def test_requires(self):
+        return self._get_requirements('test_requires')
+
+    @property
+    def dev_requires(self):
+        return self._get_requirements('dev_requires')
+
+    def matches_requirement(self, req):
+        """
+        Say if this instance matches (fulfills) a requirement.
+        :param req: The requirement to match.
+        :rtype req: str
+        :return: True if it matches, else False.
+        """
+        # Requirement may contain extras - parse to lose those
+        # from what's passed to the matcher
+        r = parse_requirement(req)
+        scheme = get_scheme(self.metadata.scheme)
+        try:
+            matcher = scheme.matcher(r.requirement)
+        except UnsupportedVersionError:
+            # XXX compat-mode if cannot read the version
+            logger.warning('could not read version %r - using name only',
+                           req)
+            name = req.split()[0]
+            matcher = scheme.matcher(name)
+
+        name = matcher.key   # case-insensitive
+
+        result = False
+        for p in self.provides:
+            p_name, p_ver = parse_name_and_version(p)
+            if p_name != name:
+                continue
+            try:
+                result = matcher.match(p_ver)
+                break
+            except UnsupportedVersionError:
+                pass
+        return result
+
+    def __repr__(self):
+        """
+        Return a textual representation of this instance,
+        """
+        if self.source_url:
+            suffix = ' [%s]' % self.source_url
+        else:
+            suffix = ''
+        return '<Distribution %s (%s)%s>' % (self.name, self.version, suffix)
+
+    def __eq__(self, other):
+        """
+        See if this distribution is the same as another.
+        :param other: The distribution to compare with. To be equal to one
+                      another. distributions must have the same type, name,
+                      version and source_url.
+        :return: True if it is the same, else False.
+        """
+        if type(other) is not type(self):
+            result = False
+        else:
+            result = (self.name == other.name and
+                      self.version == other.version and
+                      self.source_url == other.source_url)
+        return result
+
+    def __hash__(self):
+        """
+        Compute hash in a way which matches the equality test.
+        """
+        return hash(self.name) + hash(self.version) + hash(self.source_url)
+
+
+class BaseInstalledDistribution(Distribution):
+    """
+    This is the base class for installed distributions (whether PEP 376 or
+    legacy).
+    """
+
+    hasher = None
+
+    def __init__(self, metadata, path, env=None):
+        """
+        Initialise an instance.
+        :param metadata: An instance of :class:`Metadata` which describes the
+                         distribution. This will normally have been initialised
+                         from a metadata file in the ``path``.
+        :param path:     The path of the ``.dist-info`` or ``.egg-info``
+                         directory for the distribution.
+        :param env:      This is normally the :class:`DistributionPath`
+                         instance where this distribution was found.
+        """
+        super(BaseInstalledDistribution, self).__init__(metadata)
+        self.path = path
+        self.dist_path = env
+
+    def get_hash(self, data, hasher=None):
+        """
+        Get the hash of some data, using a particular hash algorithm, if
+        specified.
+
+        :param data: The data to be hashed.
+        :type data: bytes
+        :param hasher: The name of a hash implementation, supported by hashlib,
+                       or ``None``. Examples of valid values are ``'sha1'``,
+                       ``'sha224'``, ``'sha384'``, '``sha256'``, ``'md5'`` and
+                       ``'sha512'``. If no hasher is specified, the ``hasher``
+                       attribute of the :class:`InstalledDistribution` instance
+                       is used. If the hasher is determined to be ``None``, MD5
+                       is used as the hashing algorithm.
+        :returns: The hash of the data. If a hasher was explicitly specified,
+                  the returned hash will be prefixed with the specified hasher
+                  followed by '='.
+        :rtype: str
+        """
+        if hasher is None:
+            hasher = self.hasher
+        if hasher is None:
+            hasher = hashlib.md5
+            prefix = ''
+        else:
+            hasher = getattr(hashlib, hasher)
+            prefix = '%s=' % self.hasher
+        digest = hasher(data).digest()
+        digest = base64.urlsafe_b64encode(digest).rstrip(b'=').decode('ascii')
+        return '%s%s' % (prefix, digest)
+
+
+class InstalledDistribution(BaseInstalledDistribution):
+    """
+    Created with the *path* of the ``.dist-info`` directory provided to the
+    constructor. It reads the metadata contained in ``pydist.json`` when it is
+    instantiated., or uses a passed in Metadata instance (useful for when
+    dry-run mode is being used).
+    """
+
+    hasher = 'sha256'
+
+    def __init__(self, path, metadata=None, env=None):
+        self.modules = []
+        self.finder = finder = resources.finder_for_path(path)
+        if finder is None:
+            raise ValueError('finder unavailable for %s' % path)
+        if env and env._cache_enabled and path in env._cache.path:
+            metadata = env._cache.path[path].metadata
+        elif metadata is None:
+            r = finder.find(METADATA_FILENAME)
+            # Temporary - for Wheel 0.23 support
+            if r is None:
+                r = finder.find(WHEEL_METADATA_FILENAME)
+            # Temporary - for legacy support
+            if r is None:
+                r = finder.find(LEGACY_METADATA_FILENAME)
+            if r is None:
+                raise ValueError('no %s found in %s' % (METADATA_FILENAME,
+                                                        path))
+            with contextlib.closing(r.as_stream()) as stream:
+                metadata = Metadata(fileobj=stream, scheme='legacy')
+
+        super(InstalledDistribution, self).__init__(metadata, path, env)
+
+        if env and env._cache_enabled:
+            env._cache.add(self)
+
+        r = finder.find('REQUESTED')
+        self.requested = r is not None
+        p  = os.path.join(path, 'top_level.txt')
+        if os.path.exists(p):
+            with open(p, 'rb') as f:
+                data = f.read().decode('utf-8')
+            self.modules = data.splitlines()
+
+    def __repr__(self):
+        return '<InstalledDistribution %r %s at %r>' % (
+            self.name, self.version, self.path)
+
+    def __str__(self):
+        return "%s %s" % (self.name, self.version)
+
+    def _get_records(self):
+        """
+        Get the list of installed files for the distribution
+        :return: A list of tuples of path, hash and size. Note that hash and
+                 size might be ``None`` for some entries. The path is exactly
+                 as stored in the file (which is as in PEP 376).
+        """
+        results = []
+        r = self.get_distinfo_resource('RECORD')
+        with contextlib.closing(r.as_stream()) as stream:
+            with CSVReader(stream=stream) as record_reader:
+                # Base location is parent dir of .dist-info dir
+                #base_location = os.path.dirname(self.path)
+                #base_location = os.path.abspath(base_location)
+                for row in record_reader:
+                    missing = [None for i in range(len(row), 3)]
+                    path, checksum, size = row + missing
+                    #if not os.path.isabs(path):
+                    #    path = path.replace('/', os.sep)
+                    #    path = os.path.join(base_location, path)
+                    results.append((path, checksum, size))
+        return results
+
+    @cached_property
+    def exports(self):
+        """
+        Return the information exported by this distribution.
+        :return: A dictionary of exports, mapping an export category to a dict
+                 of :class:`ExportEntry` instances describing the individual
+                 export entries, and keyed by name.
+        """
+        result = {}
+        r = self.get_distinfo_resource(EXPORTS_FILENAME)
+        if r:
+            result = self.read_exports()
+        return result
+
+    def read_exports(self):
+        """
+        Read exports data from a file in .ini format.
+
+        :return: A dictionary of exports, mapping an export category to a list
+                 of :class:`ExportEntry` instances describing the individual
+                 export entries.
+        """
+        result = {}
+        r = self.get_distinfo_resource(EXPORTS_FILENAME)
+        if r:
+            with contextlib.closing(r.as_stream()) as stream:
+                result = read_exports(stream)
+        return result
+
+    def write_exports(self, exports):
+        """
+        Write a dictionary of exports to a file in .ini format.
+        :param exports: A dictionary of exports, mapping an export category to
+                        a list of :class:`ExportEntry` instances describing the
+                        individual export entries.
+        """
+        rf = self.get_distinfo_file(EXPORTS_FILENAME)
+        with open(rf, 'w') as f:
+            write_exports(exports, f)
+
+    def get_resource_path(self, relative_path):
+        """
+        NOTE: This API may change in the future.
+
+        Return the absolute path to a resource file with the given relative
+        path.
+
+        :param relative_path: The path, relative to .dist-info, of the resource
+                              of interest.
+        :return: The absolute path where the resource is to be found.
+        """
+        r = self.get_distinfo_resource('RESOURCES')
+        with contextlib.closing(r.as_stream()) as stream:
+            with CSVReader(stream=stream) as resources_reader:
+                for relative, destination in resources_reader:
+                    if relative == relative_path:
+                        return destination
+        raise KeyError('no resource file with relative path %r '
+                       'is installed' % relative_path)
+
+    def list_installed_files(self):
+        """
+        Iterates over the ``RECORD`` entries and returns a tuple
+        ``(path, hash, size)`` for each line.
+
+        :returns: iterator of (path, hash, size)
+        """
+        for result in self._get_records():
+            yield result
+
+    def write_installed_files(self, paths, prefix, dry_run=False):
+        """
+        Writes the ``RECORD`` file, using the ``paths`` iterable passed in. Any
+        existing ``RECORD`` file is silently overwritten.
+
+        prefix is used to determine when to write absolute paths.
+        """
+        prefix = os.path.join(prefix, '')
+        base = os.path.dirname(self.path)
+        base_under_prefix = base.startswith(prefix)
+        base = os.path.join(base, '')
+        record_path = self.get_distinfo_file('RECORD')
+        logger.info('creating %s', record_path)
+        if dry_run:
+            return None
+        with CSVWriter(record_path) as writer:
+            for path in paths:
+                if os.path.isdir(path) or path.endswith(('.pyc', '.pyo')):
+                    # do not put size and hash, as in PEP-376
+                    hash_value = size = ''
+                else:
+                    size = '%d' % os.path.getsize(path)
+                    with open(path, 'rb') as fp:
+                        hash_value = self.get_hash(fp.read())
+                if path.startswith(base) or (base_under_prefix and
+                                             path.startswith(prefix)):
+                    path = os.path.relpath(path, base)
+                writer.writerow((path, hash_value, size))
+
+            # add the RECORD file itself
+            if record_path.startswith(base):
+                record_path = os.path.relpath(record_path, base)
+            writer.writerow((record_path, '', ''))
+        return record_path
+
+    def check_installed_files(self):
+        """
+        Checks that the hashes and sizes of the files in ``RECORD`` are
+        matched by the files themselves. Returns a (possibly empty) list of
+        mismatches. Each entry in the mismatch list will be a tuple consisting
+        of the path, 'exists', 'size' or 'hash' according to what didn't match
+        (existence is checked first, then size, then hash), the expected
+        value and the actual value.
+        """
+        mismatches = []
+        base = os.path.dirname(self.path)
+        record_path = self.get_distinfo_file('RECORD')
+        for path, hash_value, size in self.list_installed_files():
+            if not os.path.isabs(path):
+                path = os.path.join(base, path)
+            if path == record_path:
+                continue
+            if not os.path.exists(path):
+                mismatches.append((path, 'exists', True, False))
+            elif os.path.isfile(path):
+                actual_size = str(os.path.getsize(path))
+                if size and actual_size != size:
+                    mismatches.append((path, 'size', size, actual_size))
+                elif hash_value:
+                    if '=' in hash_value:
+                        hasher = hash_value.split('=', 1)[0]
+                    else:
+                        hasher = None
+
+                    with open(path, 'rb') as f:
+                        actual_hash = self.get_hash(f.read(), hasher)
+                        if actual_hash != hash_value:
+                            mismatches.append((path, 'hash', hash_value, actual_hash))
+        return mismatches
+
+    @cached_property
+    def shared_locations(self):
+        """
+        A dictionary of shared locations whose keys are in the set 'prefix',
+        'purelib', 'platlib', 'scripts', 'headers', 'data' and 'namespace'.
+        The corresponding value is the absolute path of that category for
+        this distribution, and takes into account any paths selected by the
+        user at installation time (e.g. via command-line arguments). In the
+        case of the 'namespace' key, this would be a list of absolute paths
+        for the roots of namespace packages in this distribution.
+
+        The first time this property is accessed, the relevant information is
+        read from the SHARED file in the .dist-info directory.
+        """
+        result = {}
+        shared_path = os.path.join(self.path, 'SHARED')
+        if os.path.isfile(shared_path):
+            with codecs.open(shared_path, 'r', encoding='utf-8') as f:
+                lines = f.read().splitlines()
+            for line in lines:
+                key, value = line.split('=', 1)
+                if key == 'namespace':
+                    result.setdefault(key, []).append(value)
+                else:
+                    result[key] = value
+        return result
+
+    def write_shared_locations(self, paths, dry_run=False):
+        """
+        Write shared location information to the SHARED file in .dist-info.
+        :param paths: A dictionary as described in the documentation for
+        :meth:`shared_locations`.
+        :param dry_run: If True, the action is logged but no file is actually
+                        written.
+        :return: The path of the file written to.
+        """
+        shared_path = os.path.join(self.path, 'SHARED')
+        logger.info('creating %s', shared_path)
+        if dry_run:
+            return None
+        lines = []
+        for key in ('prefix', 'lib', 'headers', 'scripts', 'data'):
+            path = paths[key]
+            if os.path.isdir(paths[key]):
+                lines.append('%s=%s' % (key,  path))
+        for ns in paths.get('namespace', ()):
+            lines.append('namespace=%s' % ns)
+
+        with codecs.open(shared_path, 'w', encoding='utf-8') as f:
+            f.write('\n'.join(lines))
+        return shared_path
+
+    def get_distinfo_resource(self, path):
+        if path not in DIST_FILES:
+            raise DistlibException('invalid path for a dist-info file: '
+                                   '%r at %r' % (path, self.path))
+        finder = resources.finder_for_path(self.path)
+        if finder is None:
+            raise DistlibException('Unable to get a finder for %s' % self.path)
+        return finder.find(path)
+
+    def get_distinfo_file(self, path):
+        """
+        Returns a path located under the ``.dist-info`` directory. Returns a
+        string representing the path.
+
+        :parameter path: a ``'/'``-separated path relative to the
+                         ``.dist-info`` directory or an absolute path;
+                         If *path* is an absolute path and doesn't start
+                         with the ``.dist-info`` directory path,
+                         a :class:`DistlibException` is raised
+        :type path: str
+        :rtype: str
+        """
+        # Check if it is an absolute path  # XXX use relpath, add tests
+        if path.find(os.sep) >= 0:
+            # it's an absolute path?
+            distinfo_dirname, path = path.split(os.sep)[-2:]
+            if distinfo_dirname != self.path.split(os.sep)[-1]:
+                raise DistlibException(
+                    'dist-info file %r does not belong to the %r %s '
+                    'distribution' % (path, self.name, self.version))
+
+        # The file must be relative
+        if path not in DIST_FILES:
+            raise DistlibException('invalid path for a dist-info file: '
+                                   '%r at %r' % (path, self.path))
+
+        return os.path.join(self.path, path)
+
+    def list_distinfo_files(self):
+        """
+        Iterates over the ``RECORD`` entries and returns paths for each line if
+        the path is pointing to a file located in the ``.dist-info`` directory
+        or one of its subdirectories.
+
+        :returns: iterator of paths
+        """
+        base = os.path.dirname(self.path)
+        for path, checksum, size in self._get_records():
+            # XXX add separator or use real relpath algo
+            if not os.path.isabs(path):
+                path = os.path.join(base, path)
+            if path.startswith(self.path):
+                yield path
+
+    def __eq__(self, other):
+        return (isinstance(other, InstalledDistribution) and
+                self.path == other.path)
+
+    # See http://docs.python.org/reference/datamodel#object.__hash__
+    __hash__ = object.__hash__
+
+
+class EggInfoDistribution(BaseInstalledDistribution):
+    """Created with the *path* of the ``.egg-info`` directory or file provided
+    to the constructor. It reads the metadata contained in the file itself, or
+    if the given path happens to be a directory, the metadata is read from the
+    file ``PKG-INFO`` under that directory."""
+
+    requested = True    # as we have no way of knowing, assume it was
+    shared_locations = {}
+
+    def __init__(self, path, env=None):
+        def set_name_and_version(s, n, v):
+            s.name = n
+            s.key = n.lower()   # for case-insensitive comparisons
+            s.version = v
+
+        self.path = path
+        self.dist_path = env
+        if env and env._cache_enabled and path in env._cache_egg.path:
+            metadata = env._cache_egg.path[path].metadata
+            set_name_and_version(self, metadata.name, metadata.version)
+        else:
+            metadata = self._get_metadata(path)
+
+            # Need to be set before caching
+            set_name_and_version(self, metadata.name, metadata.version)
+
+            if env and env._cache_enabled:
+                env._cache_egg.add(self)
+        super(EggInfoDistribution, self).__init__(metadata, path, env)
+
+    def _get_metadata(self, path):
+        requires = None
+
+        def parse_requires_data(data):
+            """Create a list of dependencies from a requires.txt file.
+
+            *data*: the contents of a setuptools-produced requires.txt file.
+            """
+            reqs = []
+            lines = data.splitlines()
+            for line in lines:
+                line = line.strip()
+                if line.startswith('['):
+                    logger.warning('Unexpected line: quitting requirement scan: %r',
+                                   line)
+                    break
+                r = parse_requirement(line)
+                if not r:
+                    logger.warning('Not recognised as a requirement: %r', line)
+                    continue
+                if r.extras:
+                    logger.warning('extra requirements in requires.txt are '
+                                   'not supported')
+                if not r.constraints:
+                    reqs.append(r.name)
+                else:
+                    cons = ', '.join('%s%s' % c for c in r.constraints)
+                    reqs.append('%s (%s)' % (r.name, cons))
+            return reqs
+
+        def parse_requires_path(req_path):
+            """Create a list of dependencies from a requires.txt file.
+
+            *req_path*: the path to a setuptools-produced requires.txt file.
+            """
+
+            reqs = []
+            try:
+                with codecs.open(req_path, 'r', 'utf-8') as fp:
+                    reqs = parse_requires_data(fp.read())
+            except IOError:
+                pass
+            return reqs
+
+        tl_path = tl_data = None
+        if path.endswith('.egg'):
+            if os.path.isdir(path):
+                p = os.path.join(path, 'EGG-INFO')
+                meta_path = os.path.join(p, 'PKG-INFO')
+                metadata = Metadata(path=meta_path, scheme='legacy')
+                req_path = os.path.join(p, 'requires.txt')
+                tl_path = os.path.join(p, 'top_level.txt')
+                requires = parse_requires_path(req_path)
+            else:
+                # FIXME handle the case where zipfile is not available
+                zipf = zipimport.zipimporter(path)
+                fileobj = StringIO(
+                    zipf.get_data('EGG-INFO/PKG-INFO').decode('utf8'))
+                metadata = Metadata(fileobj=fileobj, scheme='legacy')
+                try:
+                    data = zipf.get_data('EGG-INFO/requires.txt')
+                    tl_data = zipf.get_data('EGG-INFO/top_level.txt').decode('utf-8')
+                    requires = parse_requires_data(data.decode('utf-8'))
+                except IOError:
+                    requires = None
+        elif path.endswith('.egg-info'):
+            if os.path.isdir(path):
+                req_path = os.path.join(path, 'requires.txt')
+                requires = parse_requires_path(req_path)
+                path = os.path.join(path, 'PKG-INFO')
+                tl_path = os.path.join(path, 'top_level.txt')
+            metadata = Metadata(path=path, scheme='legacy')
+        else:
+            raise DistlibException('path must end with .egg-info or .egg, '
+                                   'got %r' % path)
+
+        if requires:
+            metadata.add_requirements(requires)
+        # look for top-level modules in top_level.txt, if present
+        if tl_data is None:
+            if tl_path is not None and os.path.exists(tl_path):
+                with open(tl_path, 'rb') as f:
+                    tl_data = f.read().decode('utf-8')
+        if not tl_data:
+            tl_data = []
+        else:
+            tl_data = tl_data.splitlines()
+        self.modules = tl_data
+        return metadata
+
+    def __repr__(self):
+        return '<EggInfoDistribution %r %s at %r>' % (
+            self.name, self.version, self.path)
+
+    def __str__(self):
+        return "%s %s" % (self.name, self.version)
+
+    def check_installed_files(self):
+        """
+        Checks that the hashes and sizes of the files in ``RECORD`` are
+        matched by the files themselves. Returns a (possibly empty) list of
+        mismatches. Each entry in the mismatch list will be a tuple consisting
+        of the path, 'exists', 'size' or 'hash' according to what didn't match
+        (existence is checked first, then size, then hash), the expected
+        value and the actual value.
+        """
+        mismatches = []
+        record_path = os.path.join(self.path, 'installed-files.txt')
+        if os.path.exists(record_path):
+            for path, _, _ in self.list_installed_files():
+                if path == record_path:
+                    continue
+                if not os.path.exists(path):
+                    mismatches.append((path, 'exists', True, False))
+        return mismatches
+
+    def list_installed_files(self):
+        """
+        Iterates over the ``installed-files.txt`` entries and returns a tuple
+        ``(path, hash, size)`` for each line.
+
+        :returns: a list of (path, hash, size)
+        """
+
+        def _md5(path):
+            f = open(path, 'rb')
+            try:
+                content = f.read()
+            finally:
+                f.close()
+            return hashlib.md5(content).hexdigest()
+
+        def _size(path):
+            return os.stat(path).st_size
+
+        record_path = os.path.join(self.path, 'installed-files.txt')
+        result = []
+        if os.path.exists(record_path):
+            with codecs.open(record_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    p = os.path.normpath(os.path.join(self.path, line))
+                    # "./" is present as a marker between installed files
+                    # and installation metadata files
+                    if not os.path.exists(p):
+                        logger.warning('Non-existent file: %s', p)
+                        if p.endswith(('.pyc', '.pyo')):
+                            continue
+                        #otherwise fall through and fail
+                    if not os.path.isdir(p):
+                        result.append((p, _md5(p), _size(p)))
+            result.append((record_path, None, None))
+        return result
+
+    def list_distinfo_files(self, absolute=False):
+        """
+        Iterates over the ``installed-files.txt`` entries and returns paths for
+        each line if the path is pointing to a file located in the
+        ``.egg-info`` directory or one of its subdirectories.
+
+        :parameter absolute: If *absolute* is ``True``, each returned path is
+                          transformed into a local absolute path. Otherwise the
+                          raw value from ``installed-files.txt`` is returned.
+        :type absolute: boolean
+        :returns: iterator of paths
+        """
+        record_path = os.path.join(self.path, 'installed-files.txt')
+        if os.path.exists(record_path):
+            skip = True
+            with codecs.open(record_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line == './':
+                        skip = False
+                        continue
+                    if not skip:
+                        p = os.path.normpath(os.path.join(self.path, line))
+                        if p.startswith(self.path):
+                            if absolute:
+                                yield p
+                            else:
+                                yield line
+
+    def __eq__(self, other):
+        return (isinstance(other, EggInfoDistribution) and
+                self.path == other.path)
+
+    # See http://docs.python.org/reference/datamodel#object.__hash__
+    __hash__ = object.__hash__
+
+new_dist_class = InstalledDistribution
+old_dist_class = EggInfoDistribution
+
+
+class DependencyGraph(object):
+    """
+    Represents a dependency graph between distributions.
+
+    The dependency relationships are stored in an ``adjacency_list`` that maps
+    distributions to a list of ``(other, label)`` tuples where  ``other``
+    is a distribution and the edge is labeled with ``label`` (i.e. the version
+    specifier, if such was provided). Also, for more efficient traversal, for
+    every distribution ``x``, a list of predecessors is kept in
+    ``reverse_list[x]``. An edge from distribution ``a`` to
+    distribution ``b`` means that ``a`` depends on ``b``. If any missing
+    dependencies are found, they are stored in ``missing``, which is a
+    dictionary that maps distributions to a list of requirements that were not
+    provided by any other distributions.
+    """
+
+    def __init__(self):
+        self.adjacency_list = {}
+        self.reverse_list = {}
+        self.missing = {}
+
+    def add_distribution(self, distribution):
+        """Add the *distribution* to the graph.
+
+        :type distribution: :class:`distutils2.database.InstalledDistribution`
+                            or :class:`distutils2.database.EggInfoDistribution`
+        """
+        self.adjacency_list[distribution] = []
+        self.reverse_list[distribution] = []
+        #self.missing[distribution] = []
+
+    def add_edge(self, x, y, label=None):
+        """Add an edge from distribution *x* to distribution *y* with the given
+        *label*.
+
+        :type x: :class:`distutils2.database.InstalledDistribution` or
+                 :class:`distutils2.database.EggInfoDistribution`
+        :type y: :class:`distutils2.database.InstalledDistribution` or
+                 :class:`distutils2.database.EggInfoDistribution`
+        :type label: ``str`` or ``None``
+        """
+        self.adjacency_list[x].append((y, label))
+        # multiple edges are allowed, so be careful
+        if x not in self.reverse_list[y]:
+            self.reverse_list[y].append(x)
+
+    def add_missing(self, distribution, requirement):
+        """
+        Add a missing *requirement* for the given *distribution*.
+
+        :type distribution: :class:`distutils2.database.InstalledDistribution`
+                            or :class:`distutils2.database.EggInfoDistribution`
+        :type requirement: ``str``
+        """
+        logger.debug('%s missing %r', distribution, requirement)
+        self.missing.setdefault(distribution, []).append(requirement)
+
+    def _repr_dist(self, dist):
+        return '%s %s' % (dist.name, dist.version)
+
+    def repr_node(self, dist, level=1):
+        """Prints only a subgraph"""
+        output = [self._repr_dist(dist)]
+        for other, label in self.adjacency_list[dist]:
+            dist = self._repr_dist(other)
+            if label is not None:
+                dist = '%s [%s]' % (dist, label)
+            output.append('    ' * level + str(dist))
+            suboutput = self.repr_node(other, level + 1)
+            subs = suboutput.split('\n')
+            output.extend(subs[1:])
+        return '\n'.join(output)
+
+    def to_dot(self, f, skip_disconnected=True):
+        """Writes a DOT output for the graph to the provided file *f*.
+
+        If *skip_disconnected* is set to ``True``, then all distributions
+        that are not dependent on any other distribution are skipped.
+
+        :type f: has to support ``file``-like operations
+        :type skip_disconnected: ``bool``
+        """
+        disconnected = []
+
+        f.write("digraph dependencies {\n")
+        for dist, adjs in self.adjacency_list.items():
+            if len(adjs) == 0 and not skip_disconnected:
+                disconnected.append(dist)
+            for other, label in adjs:
+                if not label is None:
+                    f.write('"%s" -> "%s" [label="%s"]\n' %
+                            (dist.name, other.name, label))
+                else:
+                    f.write('"%s" -> "%s"\n' % (dist.name, other.name))
+        if not skip_disconnected and len(disconnected) > 0:
+            f.write('subgraph disconnected {\n')
+            f.write('label = "Disconnected"\n')
+            f.write('bgcolor = red\n')
+
+            for dist in disconnected:
+                f.write('"%s"' % dist.name)
+                f.write('\n')
+            f.write('}\n')
+        f.write('}\n')
+
+    def topological_sort(self):
+        """
+        Perform a topological sort of the graph.
+        :return: A tuple, the first element of which is a topologically sorted
+                 list of distributions, and the second element of which is a
+                 list of distributions that cannot be sorted because they have
+                 circular dependencies and so form a cycle.
+        """
+        result = []
+        # Make a shallow copy of the adjacency list
+        alist = {}
+        for k, v in self.adjacency_list.items():
+            alist[k] = v[:]
+        while True:
+            # See what we can remove in this run
+            to_remove = []
+            for k, v in list(alist.items())[:]:
+                if not v:
+                    to_remove.append(k)
+                    del alist[k]
+            if not to_remove:
+                # What's left in alist (if anything) is a cycle.
+                break
+            # Remove from the adjacency list of others
+            for k, v in alist.items():
+                alist[k] = [(d, r) for d, r in v if d not in to_remove]
+            logger.debug('Moving to result: %s',
+                         ['%s (%s)' % (d.name, d.version) for d in to_remove])
+            result.extend(to_remove)
+        return result, list(alist.keys())
+
+    def __repr__(self):
+        """Representation of the graph"""
+        output = []
+        for dist, adjs in self.adjacency_list.items():
+            output.append(self.repr_node(dist))
+        return '\n'.join(output)
+
+
+def make_graph(dists, scheme='default'):
+    """Makes a dependency graph from the given distributions.
+
+    :parameter dists: a list of distributions
+    :type dists: list of :class:`distutils2.database.InstalledDistribution` and
+                 :class:`distutils2.database.EggInfoDistribution` instances
+    :rtype: a :class:`DependencyGraph` instance
+    """
+    scheme = get_scheme(scheme)
+    graph = DependencyGraph()
+    provided = {}  # maps names to lists of (version, dist) tuples
+
+    # first, build the graph and find out what's provided
+    for dist in dists:
+        graph.add_distribution(dist)
+
+        for p in dist.provides:
+            name, version = parse_name_and_version(p)
+            logger.debug('Add to provided: %s, %s, %s', name, version, dist)
+            provided.setdefault(name, []).append((version, dist))
+
+    # now make the edges
+    for dist in dists:
+        requires = (dist.run_requires | dist.meta_requires |
+                    dist.build_requires | dist.dev_requires)
+        for req in requires:
+            try:
+                matcher = scheme.matcher(req)
+            except UnsupportedVersionError:
+                # XXX compat-mode if cannot read the version
+                logger.warning('could not read version %r - using name only',
+                               req)
+                name = req.split()[0]
+                matcher = scheme.matcher(name)
+
+            name = matcher.key   # case-insensitive
+
+            matched = False
+            if name in provided:
+                for version, provider in provided[name]:
+                    try:
+                        match = matcher.match(version)
+                    except UnsupportedVersionError:
+                        match = False
+
+                    if match:
+                        graph.add_edge(dist, provider, req)
+                        matched = True
+                        break
+            if not matched:
+                graph.add_missing(dist, req)
+    return graph
+
+
+def get_dependent_dists(dists, dist):
+    """Recursively generate a list of distributions from *dists* that are
+    dependent on *dist*.
+
+    :param dists: a list of distributions
+    :param dist: a distribution, member of *dists* for which we are interested
+    """
+    if dist not in dists:
+        raise DistlibException('given distribution %r is not a member '
+                               'of the list' % dist.name)
+    graph = make_graph(dists)
+
+    dep = [dist]  # dependent distributions
+    todo = graph.reverse_list[dist]  # list of nodes we should inspect
+
+    while todo:
+        d = todo.pop()
+        dep.append(d)
+        for succ in graph.reverse_list[d]:
+            if succ not in dep:
+                todo.append(succ)
+
+    dep.pop(0)  # remove dist from dep, was there to prevent infinite loops
+    return dep
+
+
+def get_required_dists(dists, dist):
+    """Recursively generate a list of distributions from *dists* that are
+    required by *dist*.
+
+    :param dists: a list of distributions
+    :param dist: a distribution, member of *dists* for which we are interested
+    """
+    if dist not in dists:
+        raise DistlibException('given distribution %r is not a member '
+                               'of the list' % dist.name)
+    graph = make_graph(dists)
+
+    req = []  # required distributions
+    todo = graph.adjacency_list[dist]  # list of nodes we should inspect
+
+    while todo:
+        d = todo.pop()[0]
+        req.append(d)
+        for pred in graph.adjacency_list[d]:
+            if pred not in req:
+                todo.append(pred)
+
+    return req
+
+
+def make_dist(name, version, **kwargs):
+    """
+    A convenience method for making a dist given just a name and version.
+    """
+    summary = kwargs.pop('summary', 'Placeholder for summary')
+    md = Metadata(**kwargs)
+    md.name = name
+    md.version = version
+    md.summary = summary or 'Placeholder for summary'
+    return Distribution(md)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/index.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/index.py
new file mode 100644
index 0000000..7a87cdc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/index.py
@@ -0,0 +1,516 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+import hashlib
+import logging
+import os
+import shutil
+import subprocess
+import tempfile
+try:
+    from threading import Thread
+except ImportError:
+    from dummy_threading import Thread
+
+from . import DistlibException
+from .compat import (HTTPBasicAuthHandler, Request, HTTPPasswordMgr,
+                     urlparse, build_opener, string_types)
+from .util import cached_property, zip_dir, ServerProxy
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_INDEX = 'https://pypi.org/pypi'
+DEFAULT_REALM = 'pypi'
+
+class PackageIndex(object):
+    """
+    This class represents a package index compatible with PyPI, the Python
+    Package Index.
+    """
+
+    boundary = b'----------ThIs_Is_tHe_distlib_index_bouNdaRY_$'
+
+    def __init__(self, url=None):
+        """
+        Initialise an instance.
+
+        :param url: The URL of the index. If not specified, the URL for PyPI is
+                    used.
+        """
+        self.url = url or DEFAULT_INDEX
+        self.read_configuration()
+        scheme, netloc, path, params, query, frag = urlparse(self.url)
+        if params or query or frag or scheme not in ('http', 'https'):
+            raise DistlibException('invalid repository: %s' % self.url)
+        self.password_handler = None
+        self.ssl_verifier = None
+        self.gpg = None
+        self.gpg_home = None
+        with open(os.devnull, 'w') as sink:
+            # Use gpg by default rather than gpg2, as gpg2 insists on
+            # prompting for passwords
+            for s in ('gpg', 'gpg2'):
+                try:
+                    rc = subprocess.check_call([s, '--version'], stdout=sink,
+                                               stderr=sink)
+                    if rc == 0:
+                        self.gpg = s
+                        break
+                except OSError:
+                    pass
+
+    def _get_pypirc_command(self):
+        """
+        Get the distutils command for interacting with PyPI configurations.
+        :return: the command.
+        """
+        from distutils.core import Distribution
+        from distutils.config import PyPIRCCommand
+        d = Distribution()
+        return PyPIRCCommand(d)
+
+    def read_configuration(self):
+        """
+        Read the PyPI access configuration as supported by distutils, getting
+        PyPI to do the actual work. This populates ``username``, ``password``,
+        ``realm`` and ``url`` attributes from the configuration.
+        """
+        # get distutils to do the work
+        c = self._get_pypirc_command()
+        c.repository = self.url
+        cfg = c._read_pypirc()
+        self.username = cfg.get('username')
+        self.password = cfg.get('password')
+        self.realm = cfg.get('realm', 'pypi')
+        self.url = cfg.get('repository', self.url)
+
+    def save_configuration(self):
+        """
+        Save the PyPI access configuration. You must have set ``username`` and
+        ``password`` attributes before calling this method.
+
+        Again, distutils is used to do the actual work.
+        """
+        self.check_credentials()
+        # get distutils to do the work
+        c = self._get_pypirc_command()
+        c._store_pypirc(self.username, self.password)
+
+    def check_credentials(self):
+        """
+        Check that ``username`` and ``password`` have been set, and raise an
+        exception if not.
+        """
+        if self.username is None or self.password is None:
+            raise DistlibException('username and password must be set')
+        pm = HTTPPasswordMgr()
+        _, netloc, _, _, _, _ = urlparse(self.url)
+        pm.add_password(self.realm, netloc, self.username, self.password)
+        self.password_handler = HTTPBasicAuthHandler(pm)
+
+    def register(self, metadata):
+        """
+        Register a distribution on PyPI, using the provided metadata.
+
+        :param metadata: A :class:`Metadata` instance defining at least a name
+                         and version number for the distribution to be
+                         registered.
+        :return: The HTTP response received from PyPI upon submission of the
+                request.
+        """
+        self.check_credentials()
+        metadata.validate()
+        d = metadata.todict()
+        d[':action'] = 'verify'
+        request = self.encode_request(d.items(), [])
+        response = self.send_request(request)
+        d[':action'] = 'submit'
+        request = self.encode_request(d.items(), [])
+        return self.send_request(request)
+
+    def _reader(self, name, stream, outbuf):
+        """
+        Thread runner for reading lines of from a subprocess into a buffer.
+
+        :param name: The logical name of the stream (used for logging only).
+        :param stream: The stream to read from. This will typically a pipe
+                       connected to the output stream of a subprocess.
+        :param outbuf: The list to append the read lines to.
+        """
+        while True:
+            s = stream.readline()
+            if not s:
+                break
+            s = s.decode('utf-8').rstrip()
+            outbuf.append(s)
+            logger.debug('%s: %s' % (name, s))
+        stream.close()
+
+    def get_sign_command(self, filename, signer, sign_password,
+                         keystore=None):
+        """
+        Return a suitable command for signing a file.
+
+        :param filename: The pathname to the file to be signed.
+        :param signer: The identifier of the signer of the file.
+        :param sign_password: The passphrase for the signer's
+                              private key used for signing.
+        :param keystore: The path to a directory which contains the keys
+                         used in verification. If not specified, the
+                         instance's ``gpg_home`` attribute is used instead.
+        :return: The signing command as a list suitable to be
+                 passed to :class:`subprocess.Popen`.
+        """
+        cmd = [self.gpg, '--status-fd', '2', '--no-tty']
+        if keystore is None:
+            keystore = self.gpg_home
+        if keystore:
+            cmd.extend(['--homedir', keystore])
+        if sign_password is not None:
+            cmd.extend(['--batch', '--passphrase-fd', '0'])
+        td = tempfile.mkdtemp()
+        sf = os.path.join(td, os.path.basename(filename) + '.asc')
+        cmd.extend(['--detach-sign', '--armor', '--local-user',
+                    signer, '--output', sf, filename])
+        logger.debug('invoking: %s', ' '.join(cmd))
+        return cmd, sf
+
+    def run_command(self, cmd, input_data=None):
+        """
+        Run a command in a child process , passing it any input data specified.
+
+        :param cmd: The command to run.
+        :param input_data: If specified, this must be a byte string containing
+                           data to be sent to the child process.
+        :return: A tuple consisting of the subprocess' exit code, a list of
+                 lines read from the subprocess' ``stdout``, and a list of
+                 lines read from the subprocess' ``stderr``.
+        """
+        kwargs = {
+            'stdout': subprocess.PIPE,
+            'stderr': subprocess.PIPE,
+        }
+        if input_data is not None:
+            kwargs['stdin'] = subprocess.PIPE
+        stdout = []
+        stderr = []
+        p = subprocess.Popen(cmd, **kwargs)
+        # We don't use communicate() here because we may need to
+        # get clever with interacting with the command
+        t1 = Thread(target=self._reader, args=('stdout', p.stdout, stdout))
+        t1.start()
+        t2 = Thread(target=self._reader, args=('stderr', p.stderr, stderr))
+        t2.start()
+        if input_data is not None:
+            p.stdin.write(input_data)
+            p.stdin.close()
+
+        p.wait()
+        t1.join()
+        t2.join()
+        return p.returncode, stdout, stderr
+
+    def sign_file(self, filename, signer, sign_password, keystore=None):
+        """
+        Sign a file.
+
+        :param filename: The pathname to the file to be signed.
+        :param signer: The identifier of the signer of the file.
+        :param sign_password: The passphrase for the signer's
+                              private key used for signing.
+        :param keystore: The path to a directory which contains the keys
+                         used in signing. If not specified, the instance's
+                         ``gpg_home`` attribute is used instead.
+        :return: The absolute pathname of the file where the signature is
+                 stored.
+        """
+        cmd, sig_file = self.get_sign_command(filename, signer, sign_password,
+                                              keystore)
+        rc, stdout, stderr = self.run_command(cmd,
+                                              sign_password.encode('utf-8'))
+        if rc != 0:
+            raise DistlibException('sign command failed with error '
+                                   'code %s' % rc)
+        return sig_file
+
+    def upload_file(self, metadata, filename, signer=None, sign_password=None,
+                    filetype='sdist', pyversion='source', keystore=None):
+        """
+        Upload a release file to the index.
+
+        :param metadata: A :class:`Metadata` instance defining at least a name
+                         and version number for the file to be uploaded.
+        :param filename: The pathname of the file to be uploaded.
+        :param signer: The identifier of the signer of the file.
+        :param sign_password: The passphrase for the signer's
+                              private key used for signing.
+        :param filetype: The type of the file being uploaded. This is the
+                        distutils command which produced that file, e.g.
+                        ``sdist`` or ``bdist_wheel``.
+        :param pyversion: The version of Python which the release relates
+                          to. For code compatible with any Python, this would
+                          be ``source``, otherwise it would be e.g. ``3.2``.
+        :param keystore: The path to a directory which contains the keys
+                         used in signing. If not specified, the instance's
+                         ``gpg_home`` attribute is used instead.
+        :return: The HTTP response received from PyPI upon submission of the
+                request.
+        """
+        self.check_credentials()
+        if not os.path.exists(filename):
+            raise DistlibException('not found: %s' % filename)
+        metadata.validate()
+        d = metadata.todict()
+        sig_file = None
+        if signer:
+            if not self.gpg:
+                logger.warning('no signing program available - not signed')
+            else:
+                sig_file = self.sign_file(filename, signer, sign_password,
+                                          keystore)
+        with open(filename, 'rb') as f:
+            file_data = f.read()
+        md5_digest = hashlib.md5(file_data).hexdigest()
+        sha256_digest = hashlib.sha256(file_data).hexdigest()
+        d.update({
+            ':action': 'file_upload',
+            'protocol_version': '1',
+            'filetype': filetype,
+            'pyversion': pyversion,
+            'md5_digest': md5_digest,
+            'sha256_digest': sha256_digest,
+        })
+        files = [('content', os.path.basename(filename), file_data)]
+        if sig_file:
+            with open(sig_file, 'rb') as f:
+                sig_data = f.read()
+            files.append(('gpg_signature', os.path.basename(sig_file),
+                         sig_data))
+            shutil.rmtree(os.path.dirname(sig_file))
+        request = self.encode_request(d.items(), files)
+        return self.send_request(request)
+
+    def upload_documentation(self, metadata, doc_dir):
+        """
+        Upload documentation to the index.
+
+        :param metadata: A :class:`Metadata` instance defining at least a name
+                         and version number for the documentation to be
+                         uploaded.
+        :param doc_dir: The pathname of the directory which contains the
+                        documentation. This should be the directory that
+                        contains the ``index.html`` for the documentation.
+        :return: The HTTP response received from PyPI upon submission of the
+                request.
+        """
+        self.check_credentials()
+        if not os.path.isdir(doc_dir):
+            raise DistlibException('not a directory: %r' % doc_dir)
+        fn = os.path.join(doc_dir, 'index.html')
+        if not os.path.exists(fn):
+            raise DistlibException('not found: %r' % fn)
+        metadata.validate()
+        name, version = metadata.name, metadata.version
+        zip_data = zip_dir(doc_dir).getvalue()
+        fields = [(':action', 'doc_upload'),
+                  ('name', name), ('version', version)]
+        files = [('content', name, zip_data)]
+        request = self.encode_request(fields, files)
+        return self.send_request(request)
+
+    def get_verify_command(self, signature_filename, data_filename,
+                           keystore=None):
+        """
+        Return a suitable command for verifying a file.
+
+        :param signature_filename: The pathname to the file containing the
+                                   signature.
+        :param data_filename: The pathname to the file containing the
+                              signed data.
+        :param keystore: The path to a directory which contains the keys
+                         used in verification. If not specified, the
+                         instance's ``gpg_home`` attribute is used instead.
+        :return: The verifying command as a list suitable to be
+                 passed to :class:`subprocess.Popen`.
+        """
+        cmd = [self.gpg, '--status-fd', '2', '--no-tty']
+        if keystore is None:
+            keystore = self.gpg_home
+        if keystore:
+            cmd.extend(['--homedir', keystore])
+        cmd.extend(['--verify', signature_filename, data_filename])
+        logger.debug('invoking: %s', ' '.join(cmd))
+        return cmd
+
+    def verify_signature(self, signature_filename, data_filename,
+                         keystore=None):
+        """
+        Verify a signature for a file.
+
+        :param signature_filename: The pathname to the file containing the
+                                   signature.
+        :param data_filename: The pathname to the file containing the
+                              signed data.
+        :param keystore: The path to a directory which contains the keys
+                         used in verification. If not specified, the
+                         instance's ``gpg_home`` attribute is used instead.
+        :return: True if the signature was verified, else False.
+        """
+        if not self.gpg:
+            raise DistlibException('verification unavailable because gpg '
+                                   'unavailable')
+        cmd = self.get_verify_command(signature_filename, data_filename,
+                                      keystore)
+        rc, stdout, stderr = self.run_command(cmd)
+        if rc not in (0, 1):
+            raise DistlibException('verify command failed with error '
+                             'code %s' % rc)
+        return rc == 0
+
+    def download_file(self, url, destfile, digest=None, reporthook=None):
+        """
+        This is a convenience method for downloading a file from an URL.
+        Normally, this will be a file from the index, though currently
+        no check is made for this (i.e. a file can be downloaded from
+        anywhere).
+
+        The method is just like the :func:`urlretrieve` function in the
+        standard library, except that it allows digest computation to be
+        done during download and checking that the downloaded data
+        matched any expected value.
+
+        :param url: The URL of the file to be downloaded (assumed to be
+                    available via an HTTP GET request).
+        :param destfile: The pathname where the downloaded file is to be
+                         saved.
+        :param digest: If specified, this must be a (hasher, value)
+                       tuple, where hasher is the algorithm used (e.g.
+                       ``'md5'``) and ``value`` is the expected value.
+        :param reporthook: The same as for :func:`urlretrieve` in the
+                           standard library.
+        """
+        if digest is None:
+            digester = None
+            logger.debug('No digest specified')
+        else:
+            if isinstance(digest, (list, tuple)):
+                hasher, digest = digest
+            else:
+                hasher = 'md5'
+            digester = getattr(hashlib, hasher)()
+            logger.debug('Digest specified: %s' % digest)
+        # The following code is equivalent to urlretrieve.
+        # We need to do it this way so that we can compute the
+        # digest of the file as we go.
+        with open(destfile, 'wb') as dfp:
+            # addinfourl is not a context manager on 2.x
+            # so we have to use try/finally
+            sfp = self.send_request(Request(url))
+            try:
+                headers = sfp.info()
+                blocksize = 8192
+                size = -1
+                read = 0
+                blocknum = 0
+                if "content-length" in headers:
+                    size = int(headers["Content-Length"])
+                if reporthook:
+                    reporthook(blocknum, blocksize, size)
+                while True:
+                    block = sfp.read(blocksize)
+                    if not block:
+                        break
+                    read += len(block)
+                    dfp.write(block)
+                    if digester:
+                        digester.update(block)
+                    blocknum += 1
+                    if reporthook:
+                        reporthook(blocknum, blocksize, size)
+            finally:
+                sfp.close()
+
+        # check that we got the whole file, if we can
+        if size >= 0 and read < size:
+            raise DistlibException(
+                'retrieval incomplete: got only %d out of %d bytes'
+                % (read, size))
+        # if we have a digest, it must match.
+        if digester:
+            actual = digester.hexdigest()
+            if digest != actual:
+                raise DistlibException('%s digest mismatch for %s: expected '
+                                       '%s, got %s' % (hasher, destfile,
+                                                       digest, actual))
+            logger.debug('Digest verified: %s', digest)
+
+    def send_request(self, req):
+        """
+        Send a standard library :class:`Request` to PyPI and return its
+        response.
+
+        :param req: The request to send.
+        :return: The HTTP response from PyPI (a standard library HTTPResponse).
+        """
+        handlers = []
+        if self.password_handler:
+            handlers.append(self.password_handler)
+        if self.ssl_verifier:
+            handlers.append(self.ssl_verifier)
+        opener = build_opener(*handlers)
+        return opener.open(req)
+
+    def encode_request(self, fields, files):
+        """
+        Encode fields and files for posting to an HTTP server.
+
+        :param fields: The fields to send as a list of (fieldname, value)
+                       tuples.
+        :param files: The files to send as a list of (fieldname, filename,
+                      file_bytes) tuple.
+        """
+        # Adapted from packaging, which in turn was adapted from
+        # http://code.activestate.com/recipes/146306
+
+        parts = []
+        boundary = self.boundary
+        for k, values in fields:
+            if not isinstance(values, (list, tuple)):
+                values = [values]
+
+            for v in values:
+                parts.extend((
+                    b'--' + boundary,
+                    ('Content-Disposition: form-data; name="%s"' %
+                     k).encode('utf-8'),
+                    b'',
+                    v.encode('utf-8')))
+        for key, filename, value in files:
+            parts.extend((
+                b'--' + boundary,
+                ('Content-Disposition: form-data; name="%s"; filename="%s"' %
+                 (key, filename)).encode('utf-8'),
+                b'',
+                value))
+
+        parts.extend((b'--' + boundary + b'--', b''))
+
+        body = b'\r\n'.join(parts)
+        ct = b'multipart/form-data; boundary=' + boundary
+        headers = {
+            'Content-type': ct,
+            'Content-length': str(len(body))
+        }
+        return Request(self.url, body, headers)
+
+    def search(self, terms, operator=None):
+        if isinstance(terms, string_types):
+            terms = {'name': terms}
+        rpc_proxy = ServerProxy(self.url, timeout=3.0)
+        try:
+            return rpc_proxy.search(terms, operator or 'and')
+        finally:
+            rpc_proxy('close')()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/locators.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/locators.py
new file mode 100644
index 0000000..12a1d06
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/locators.py
@@ -0,0 +1,1302 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2015 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+
+import gzip
+from io import BytesIO
+import json
+import logging
+import os
+import posixpath
+import re
+try:
+    import threading
+except ImportError:  # pragma: no cover
+    import dummy_threading as threading
+import zlib
+
+from . import DistlibException
+from .compat import (urljoin, urlparse, urlunparse, url2pathname, pathname2url,
+                     queue, quote, unescape, string_types, build_opener,
+                     HTTPRedirectHandler as BaseRedirectHandler, text_type,
+                     Request, HTTPError, URLError)
+from .database import Distribution, DistributionPath, make_dist
+from .metadata import Metadata, MetadataInvalidError
+from .util import (cached_property, parse_credentials, ensure_slash,
+                   split_filename, get_project_data, parse_requirement,
+                   parse_name_and_version, ServerProxy, normalize_name)
+from .version import get_scheme, UnsupportedVersionError
+from .wheel import Wheel, is_compatible
+
+logger = logging.getLogger(__name__)
+
+HASHER_HASH = re.compile(r'^(\w+)=([a-f0-9]+)')
+CHARSET = re.compile(r';\s*charset\s*=\s*(.*)\s*$', re.I)
+HTML_CONTENT_TYPE = re.compile('text/html|application/x(ht)?ml')
+DEFAULT_INDEX = 'https://pypi.org/pypi'
+
+def get_all_distribution_names(url=None):
+    """
+    Return all distribution names known by an index.
+    :param url: The URL of the index.
+    :return: A list of all known distribution names.
+    """
+    if url is None:
+        url = DEFAULT_INDEX
+    client = ServerProxy(url, timeout=3.0)
+    try:
+        return client.list_packages()
+    finally:
+        client('close')()
+
+class RedirectHandler(BaseRedirectHandler):
+    """
+    A class to work around a bug in some Python 3.2.x releases.
+    """
+    # There's a bug in the base version for some 3.2.x
+    # (e.g. 3.2.2 on Ubuntu Oneiric). If a Location header
+    # returns e.g. /abc, it bails because it says the scheme ''
+    # is bogus, when actually it should use the request's
+    # URL for the scheme. See Python issue #13696.
+    def http_error_302(self, req, fp, code, msg, headers):
+        # Some servers (incorrectly) return multiple Location headers
+        # (so probably same goes for URI).  Use first header.
+        newurl = None
+        for key in ('location', 'uri'):
+            if key in headers:
+                newurl = headers[key]
+                break
+        if newurl is None:  # pragma: no cover
+            return
+        urlparts = urlparse(newurl)
+        if urlparts.scheme == '':
+            newurl = urljoin(req.get_full_url(), newurl)
+            if hasattr(headers, 'replace_header'):
+                headers.replace_header(key, newurl)
+            else:
+                headers[key] = newurl
+        return BaseRedirectHandler.http_error_302(self, req, fp, code, msg,
+                                                  headers)
+
+    http_error_301 = http_error_303 = http_error_307 = http_error_302
+
+class Locator(object):
+    """
+    A base class for locators - things that locate distributions.
+    """
+    source_extensions = ('.tar.gz', '.tar.bz2', '.tar', '.zip', '.tgz', '.tbz')
+    binary_extensions = ('.egg', '.exe', '.whl')
+    excluded_extensions = ('.pdf',)
+
+    # A list of tags indicating which wheels you want to match. The default
+    # value of None matches against the tags compatible with the running
+    # Python. If you want to match other values, set wheel_tags on a locator
+    # instance to a list of tuples (pyver, abi, arch) which you want to match.
+    wheel_tags = None
+
+    downloadable_extensions = source_extensions + ('.whl',)
+
+    def __init__(self, scheme='default'):
+        """
+        Initialise an instance.
+        :param scheme: Because locators look for most recent versions, they
+                       need to know the version scheme to use. This specifies
+                       the current PEP-recommended scheme - use ``'legacy'``
+                       if you need to support existing distributions on PyPI.
+        """
+        self._cache = {}
+        self.scheme = scheme
+        # Because of bugs in some of the handlers on some of the platforms,
+        # we use our own opener rather than just using urlopen.
+        self.opener = build_opener(RedirectHandler())
+        # If get_project() is called from locate(), the matcher instance
+        # is set from the requirement passed to locate(). See issue #18 for
+        # why this can be useful to know.
+        self.matcher = None
+        self.errors = queue.Queue()
+
+    def get_errors(self):
+        """
+        Return any errors which have occurred.
+        """
+        result = []
+        while not self.errors.empty():  # pragma: no cover
+            try:
+                e = self.errors.get(False)
+                result.append(e)
+            except self.errors.Empty:
+                continue
+            self.errors.task_done()
+        return result
+
+    def clear_errors(self):
+        """
+        Clear any errors which may have been logged.
+        """
+        # Just get the errors and throw them away
+        self.get_errors()
+
+    def clear_cache(self):
+        self._cache.clear()
+
+    def _get_scheme(self):
+        return self._scheme
+
+    def _set_scheme(self, value):
+        self._scheme = value
+
+    scheme = property(_get_scheme, _set_scheme)
+
+    def _get_project(self, name):
+        """
+        For a given project, get a dictionary mapping available versions to Distribution
+        instances.
+
+        This should be implemented in subclasses.
+
+        If called from a locate() request, self.matcher will be set to a
+        matcher for the requirement to satisfy, otherwise it will be None.
+        """
+        raise NotImplementedError('Please implement in the subclass')
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        raise NotImplementedError('Please implement in the subclass')
+
+    def get_project(self, name):
+        """
+        For a given project, get a dictionary mapping available versions to Distribution
+        instances.
+
+        This calls _get_project to do all the work, and just implements a caching layer on top.
+        """
+        if self._cache is None:  # pragma: no cover
+            result = self._get_project(name)
+        elif name in self._cache:
+            result = self._cache[name]
+        else:
+            self.clear_errors()
+            result = self._get_project(name)
+            self._cache[name] = result
+        return result
+
+    def score_url(self, url):
+        """
+        Give an url a score which can be used to choose preferred URLs
+        for a given project release.
+        """
+        t = urlparse(url)
+        basename = posixpath.basename(t.path)
+        compatible = True
+        is_wheel = basename.endswith('.whl')
+        is_downloadable = basename.endswith(self.downloadable_extensions)
+        if is_wheel:
+            compatible = is_compatible(Wheel(basename), self.wheel_tags)
+        return (t.scheme == 'https', 'pypi.org' in t.netloc,
+                is_downloadable, is_wheel, compatible, basename)
+
+    def prefer_url(self, url1, url2):
+        """
+        Choose one of two URLs where both are candidates for distribution
+        archives for the same version of a distribution (for example,
+        .tar.gz vs. zip).
+
+        The current implementation favours https:// URLs over http://, archives
+        from PyPI over those from other locations, wheel compatibility (if a
+        wheel) and then the archive name.
+        """
+        result = url2
+        if url1:
+            s1 = self.score_url(url1)
+            s2 = self.score_url(url2)
+            if s1 > s2:
+                result = url1
+            if result != url2:
+                logger.debug('Not replacing %r with %r', url1, url2)
+            else:
+                logger.debug('Replacing %r with %r', url1, url2)
+        return result
+
+    def split_filename(self, filename, project_name):
+        """
+        Attempt to split a filename in project name, version and Python version.
+        """
+        return split_filename(filename, project_name)
+
+    def convert_url_to_download_info(self, url, project_name):
+        """
+        See if a URL is a candidate for a download URL for a project (the URL
+        has typically been scraped from an HTML page).
+
+        If it is, a dictionary is returned with keys "name", "version",
+        "filename" and "url"; otherwise, None is returned.
+        """
+        def same_project(name1, name2):
+            return normalize_name(name1) == normalize_name(name2)
+
+        result = None
+        scheme, netloc, path, params, query, frag = urlparse(url)
+        if frag.lower().startswith('egg='):  # pragma: no cover
+            logger.debug('%s: version hint in fragment: %r',
+                         project_name, frag)
+        m = HASHER_HASH.match(frag)
+        if m:
+            algo, digest = m.groups()
+        else:
+            algo, digest = None, None
+        origpath = path
+        if path and path[-1] == '/':  # pragma: no cover
+            path = path[:-1]
+        if path.endswith('.whl'):
+            try:
+                wheel = Wheel(path)
+                if not is_compatible(wheel, self.wheel_tags):
+                    logger.debug('Wheel not compatible: %s', path)
+                else:
+                    if project_name is None:
+                        include = True
+                    else:
+                        include = same_project(wheel.name, project_name)
+                    if include:
+                        result = {
+                            'name': wheel.name,
+                            'version': wheel.version,
+                            'filename': wheel.filename,
+                            'url': urlunparse((scheme, netloc, origpath,
+                                               params, query, '')),
+                            'python-version': ', '.join(
+                                ['.'.join(list(v[2:])) for v in wheel.pyver]),
+                        }
+            except Exception as e:  # pragma: no cover
+                logger.warning('invalid path for wheel: %s', path)
+        elif not path.endswith(self.downloadable_extensions):  # pragma: no cover
+            logger.debug('Not downloadable: %s', path)
+        else:  # downloadable extension
+            path = filename = posixpath.basename(path)
+            for ext in self.downloadable_extensions:
+                if path.endswith(ext):
+                    path = path[:-len(ext)]
+                    t = self.split_filename(path, project_name)
+                    if not t:  # pragma: no cover
+                        logger.debug('No match for project/version: %s', path)
+                    else:
+                        name, version, pyver = t
+                        if not project_name or same_project(project_name, name):
+                            result = {
+                                'name': name,
+                                'version': version,
+                                'filename': filename,
+                                'url': urlunparse((scheme, netloc, origpath,
+                                                   params, query, '')),
+                                #'packagetype': 'sdist',
+                            }
+                            if pyver:  # pragma: no cover
+                                result['python-version'] = pyver
+                    break
+        if result and algo:
+            result['%s_digest' % algo] = digest
+        return result
+
+    def _get_digest(self, info):
+        """
+        Get a digest from a dictionary by looking at a "digests" dictionary
+        or keys of the form 'algo_digest'.
+
+        Returns a 2-tuple (algo, digest) if found, else None. Currently
+        looks only for SHA256, then MD5.
+        """
+        result = None
+        if 'digests' in info:
+            digests = info['digests']
+            for algo in ('sha256', 'md5'):
+                if algo in digests:
+                    result = (algo, digests[algo])
+                    break
+        if not result:
+            for algo in ('sha256', 'md5'):
+                key = '%s_digest' % algo
+                if key in info:
+                    result = (algo, info[key])
+                    break
+        return result
+
+    def _update_version_data(self, result, info):
+        """
+        Update a result dictionary (the final result from _get_project) with a
+        dictionary for a specific version, which typically holds information
+        gleaned from a filename or URL for an archive for the distribution.
+        """
+        name = info.pop('name')
+        version = info.pop('version')
+        if version in result:
+            dist = result[version]
+            md = dist.metadata
+        else:
+            dist = make_dist(name, version, scheme=self.scheme)
+            md = dist.metadata
+        dist.digest = digest = self._get_digest(info)
+        url = info['url']
+        result['digests'][url] = digest
+        if md.source_url != info['url']:
+            md.source_url = self.prefer_url(md.source_url, url)
+            result['urls'].setdefault(version, set()).add(url)
+        dist.locator = self
+        result[version] = dist
+
+    def locate(self, requirement, prereleases=False):
+        """
+        Find the most recent distribution which matches the given
+        requirement.
+
+        :param requirement: A requirement of the form 'foo (1.0)' or perhaps
+                            'foo (>= 1.0, < 2.0, != 1.3)'
+        :param prereleases: If ``True``, allow pre-release versions
+                            to be located. Otherwise, pre-release versions
+                            are not returned.
+        :return: A :class:`Distribution` instance, or ``None`` if no such
+                 distribution could be located.
+        """
+        result = None
+        r = parse_requirement(requirement)
+        if r is None:  # pragma: no cover
+            raise DistlibException('Not a valid requirement: %r' % requirement)
+        scheme = get_scheme(self.scheme)
+        self.matcher = matcher = scheme.matcher(r.requirement)
+        logger.debug('matcher: %s (%s)', matcher, type(matcher).__name__)
+        versions = self.get_project(r.name)
+        if len(versions) > 2:   # urls and digests keys are present
+            # sometimes, versions are invalid
+            slist = []
+            vcls = matcher.version_class
+            for k in versions:
+                if k in ('urls', 'digests'):
+                    continue
+                try:
+                    if not matcher.match(k):
+                        logger.debug('%s did not match %r', matcher, k)
+                    else:
+                        if prereleases or not vcls(k).is_prerelease:
+                            slist.append(k)
+                        else:
+                            logger.debug('skipping pre-release '
+                                         'version %s of %s', k, matcher.name)
+                except Exception:  # pragma: no cover
+                    logger.warning('error matching %s with %r', matcher, k)
+                    pass # slist.append(k)
+            if len(slist) > 1:
+                slist = sorted(slist, key=scheme.key)
+            if slist:
+                logger.debug('sorted list: %s', slist)
+                version = slist[-1]
+                result = versions[version]
+        if result:
+            if r.extras:
+                result.extras = r.extras
+            result.download_urls = versions.get('urls', {}).get(version, set())
+            d = {}
+            sd = versions.get('digests', {})
+            for url in result.download_urls:
+                if url in sd:  # pragma: no cover
+                    d[url] = sd[url]
+            result.digests = d
+        self.matcher = None
+        return result
+
+
+class PyPIRPCLocator(Locator):
+    """
+    This locator uses XML-RPC to locate distributions. It therefore
+    cannot be used with simple mirrors (that only mirror file content).
+    """
+    def __init__(self, url, **kwargs):
+        """
+        Initialise an instance.
+
+        :param url: The URL to use for XML-RPC.
+        :param kwargs: Passed to the superclass constructor.
+        """
+        super(PyPIRPCLocator, self).__init__(**kwargs)
+        self.base_url = url
+        self.client = ServerProxy(url, timeout=3.0)
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        return set(self.client.list_packages())
+
+    def _get_project(self, name):
+        result = {'urls': {}, 'digests': {}}
+        versions = self.client.package_releases(name, True)
+        for v in versions:
+            urls = self.client.release_urls(name, v)
+            data = self.client.release_data(name, v)
+            metadata = Metadata(scheme=self.scheme)
+            metadata.name = data['name']
+            metadata.version = data['version']
+            metadata.license = data.get('license')
+            metadata.keywords = data.get('keywords', [])
+            metadata.summary = data.get('summary')
+            dist = Distribution(metadata)
+            if urls:
+                info = urls[0]
+                metadata.source_url = info['url']
+                dist.digest = self._get_digest(info)
+                dist.locator = self
+                result[v] = dist
+                for info in urls:
+                    url = info['url']
+                    digest = self._get_digest(info)
+                    result['urls'].setdefault(v, set()).add(url)
+                    result['digests'][url] = digest
+        return result
+
+class PyPIJSONLocator(Locator):
+    """
+    This locator uses PyPI's JSON interface. It's very limited in functionality
+    and probably not worth using.
+    """
+    def __init__(self, url, **kwargs):
+        super(PyPIJSONLocator, self).__init__(**kwargs)
+        self.base_url = ensure_slash(url)
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        raise NotImplementedError('Not available from this locator')
+
+    def _get_project(self, name):
+        result = {'urls': {}, 'digests': {}}
+        url = urljoin(self.base_url, '%s/json' % quote(name))
+        try:
+            resp = self.opener.open(url)
+            data = resp.read().decode() # for now
+            d = json.loads(data)
+            md = Metadata(scheme=self.scheme)
+            data = d['info']
+            md.name = data['name']
+            md.version = data['version']
+            md.license = data.get('license')
+            md.keywords = data.get('keywords', [])
+            md.summary = data.get('summary')
+            dist = Distribution(md)
+            dist.locator = self
+            urls = d['urls']
+            result[md.version] = dist
+            for info in d['urls']:
+                url = info['url']
+                dist.download_urls.add(url)
+                dist.digests[url] = self._get_digest(info)
+                result['urls'].setdefault(md.version, set()).add(url)
+                result['digests'][url] = self._get_digest(info)
+            # Now get other releases
+            for version, infos in d['releases'].items():
+                if version == md.version:
+                    continue    # already done
+                omd = Metadata(scheme=self.scheme)
+                omd.name = md.name
+                omd.version = version
+                odist = Distribution(omd)
+                odist.locator = self
+                result[version] = odist
+                for info in infos:
+                    url = info['url']
+                    odist.download_urls.add(url)
+                    odist.digests[url] = self._get_digest(info)
+                    result['urls'].setdefault(version, set()).add(url)
+                    result['digests'][url] = self._get_digest(info)
+#            for info in urls:
+#                md.source_url = info['url']
+#                dist.digest = self._get_digest(info)
+#                dist.locator = self
+#                for info in urls:
+#                    url = info['url']
+#                    result['urls'].setdefault(md.version, set()).add(url)
+#                    result['digests'][url] = self._get_digest(info)
+        except Exception as e:
+            self.errors.put(text_type(e))
+            logger.exception('JSON fetch failed: %s', e)
+        return result
+
+
+class Page(object):
+    """
+    This class represents a scraped HTML page.
+    """
+    # The following slightly hairy-looking regex just looks for the contents of
+    # an anchor link, which has an attribute "href" either immediately preceded
+    # or immediately followed by a "rel" attribute. The attribute values can be
+    # declared with double quotes, single quotes or no quotes - which leads to
+    # the length of the expression.
+    _href = re.compile("""
+(rel\\s*=\\s*(?:"(?P<rel1>[^"]*)"|'(?P<rel2>[^']*)'|(?P<rel3>[^>\\s\n]*))\\s+)?
+href\\s*=\\s*(?:"(?P<url1>[^"]*)"|'(?P<url2>[^']*)'|(?P<url3>[^>\\s\n]*))
+(\\s+rel\\s*=\\s*(?:"(?P<rel4>[^"]*)"|'(?P<rel5>[^']*)'|(?P<rel6>[^>\\s\n]*)))?
+""", re.I | re.S | re.X)
+    _base = re.compile(r"""<base\s+href\s*=\s*['"]?([^'">]+)""", re.I | re.S)
+
+    def __init__(self, data, url):
+        """
+        Initialise an instance with the Unicode page contents and the URL they
+        came from.
+        """
+        self.data = data
+        self.base_url = self.url = url
+        m = self._base.search(self.data)
+        if m:
+            self.base_url = m.group(1)
+
+    _clean_re = re.compile(r'[^a-z0-9$&+,/:;=?@.#%_\\|-]', re.I)
+
+    @cached_property
+    def links(self):
+        """
+        Return the URLs of all the links on a page together with information
+        about their "rel" attribute, for determining which ones to treat as
+        downloads and which ones to queue for further scraping.
+        """
+        def clean(url):
+            "Tidy up an URL."
+            scheme, netloc, path, params, query, frag = urlparse(url)
+            return urlunparse((scheme, netloc, quote(path),
+                               params, query, frag))
+
+        result = set()
+        for match in self._href.finditer(self.data):
+            d = match.groupdict('')
+            rel = (d['rel1'] or d['rel2'] or d['rel3'] or
+                   d['rel4'] or d['rel5'] or d['rel6'])
+            url = d['url1'] or d['url2'] or d['url3']
+            url = urljoin(self.base_url, url)
+            url = unescape(url)
+            url = self._clean_re.sub(lambda m: '%%%2x' % ord(m.group(0)), url)
+            result.add((url, rel))
+        # We sort the result, hoping to bring the most recent versions
+        # to the front
+        result = sorted(result, key=lambda t: t[0], reverse=True)
+        return result
+
+
+class SimpleScrapingLocator(Locator):
+    """
+    A locator which scrapes HTML pages to locate downloads for a distribution.
+    This runs multiple threads to do the I/O; performance is at least as good
+    as pip's PackageFinder, which works in an analogous fashion.
+    """
+
+    # These are used to deal with various Content-Encoding schemes.
+    decoders = {
+        'deflate': zlib.decompress,
+        'gzip': lambda b: gzip.GzipFile(fileobj=BytesIO(d)).read(),
+        'none': lambda b: b,
+    }
+
+    def __init__(self, url, timeout=None, num_workers=10, **kwargs):
+        """
+        Initialise an instance.
+        :param url: The root URL to use for scraping.
+        :param timeout: The timeout, in seconds, to be applied to requests.
+                        This defaults to ``None`` (no timeout specified).
+        :param num_workers: The number of worker threads you want to do I/O,
+                            This defaults to 10.
+        :param kwargs: Passed to the superclass.
+        """
+        super(SimpleScrapingLocator, self).__init__(**kwargs)
+        self.base_url = ensure_slash(url)
+        self.timeout = timeout
+        self._page_cache = {}
+        self._seen = set()
+        self._to_fetch = queue.Queue()
+        self._bad_hosts = set()
+        self.skip_externals = False
+        self.num_workers = num_workers
+        self._lock = threading.RLock()
+        # See issue #45: we need to be resilient when the locator is used
+        # in a thread, e.g. with concurrent.futures. We can't use self._lock
+        # as it is for coordinating our internal threads - the ones created
+        # in _prepare_threads.
+        self._gplock = threading.RLock()
+        self.platform_check = False  # See issue #112
+
+    def _prepare_threads(self):
+        """
+        Threads are created only when get_project is called, and terminate
+        before it returns. They are there primarily to parallelise I/O (i.e.
+        fetching web pages).
+        """
+        self._threads = []
+        for i in range(self.num_workers):
+            t = threading.Thread(target=self._fetch)
+            t.setDaemon(True)
+            t.start()
+            self._threads.append(t)
+
+    def _wait_threads(self):
+        """
+        Tell all the threads to terminate (by sending a sentinel value) and
+        wait for them to do so.
+        """
+        # Note that you need two loops, since you can't say which
+        # thread will get each sentinel
+        for t in self._threads:
+            self._to_fetch.put(None)    # sentinel
+        for t in self._threads:
+            t.join()
+        self._threads = []
+
+    def _get_project(self, name):
+        result = {'urls': {}, 'digests': {}}
+        with self._gplock:
+            self.result = result
+            self.project_name = name
+            url = urljoin(self.base_url, '%s/' % quote(name))
+            self._seen.clear()
+            self._page_cache.clear()
+            self._prepare_threads()
+            try:
+                logger.debug('Queueing %s', url)
+                self._to_fetch.put(url)
+                self._to_fetch.join()
+            finally:
+                self._wait_threads()
+            del self.result
+        return result
+
+    platform_dependent = re.compile(r'\b(linux_(i\d86|x86_64|arm\w+)|'
+                                    r'win(32|_amd64)|macosx_?\d+)\b', re.I)
+
+    def _is_platform_dependent(self, url):
+        """
+        Does an URL refer to a platform-specific download?
+        """
+        return self.platform_dependent.search(url)
+
+    def _process_download(self, url):
+        """
+        See if an URL is a suitable download for a project.
+
+        If it is, register information in the result dictionary (for
+        _get_project) about the specific version it's for.
+
+        Note that the return value isn't actually used other than as a boolean
+        value.
+        """
+        if self.platform_check and self._is_platform_dependent(url):
+            info = None
+        else:
+            info = self.convert_url_to_download_info(url, self.project_name)
+        logger.debug('process_download: %s -> %s', url, info)
+        if info:
+            with self._lock:    # needed because self.result is shared
+                self._update_version_data(self.result, info)
+        return info
+
+    def _should_queue(self, link, referrer, rel):
+        """
+        Determine whether a link URL from a referring page and with a
+        particular "rel" attribute should be queued for scraping.
+        """
+        scheme, netloc, path, _, _, _ = urlparse(link)
+        if path.endswith(self.source_extensions + self.binary_extensions +
+                         self.excluded_extensions):
+            result = False
+        elif self.skip_externals and not link.startswith(self.base_url):
+            result = False
+        elif not referrer.startswith(self.base_url):
+            result = False
+        elif rel not in ('homepage', 'download'):
+            result = False
+        elif scheme not in ('http', 'https', 'ftp'):
+            result = False
+        elif self._is_platform_dependent(link):
+            result = False
+        else:
+            host = netloc.split(':', 1)[0]
+            if host.lower() == 'localhost':
+                result = False
+            else:
+                result = True
+        logger.debug('should_queue: %s (%s) from %s -> %s', link, rel,
+                     referrer, result)
+        return result
+
+    def _fetch(self):
+        """
+        Get a URL to fetch from the work queue, get the HTML page, examine its
+        links for download candidates and candidates for further scraping.
+
+        This is a handy method to run in a thread.
+        """
+        while True:
+            url = self._to_fetch.get()
+            try:
+                if url:
+                    page = self.get_page(url)
+                    if page is None:    # e.g. after an error
+                        continue
+                    for link, rel in page.links:
+                        if link not in self._seen:
+                            try:
+                                self._seen.add(link)
+                                if (not self._process_download(link) and
+                                    self._should_queue(link, url, rel)):
+                                    logger.debug('Queueing %s from %s', link, url)
+                                    self._to_fetch.put(link)
+                            except MetadataInvalidError:  # e.g. invalid versions
+                                pass
+            except Exception as e:  # pragma: no cover
+                self.errors.put(text_type(e))
+            finally:
+                # always do this, to avoid hangs :-)
+                self._to_fetch.task_done()
+            if not url:
+                #logger.debug('Sentinel seen, quitting.')
+                break
+
+    def get_page(self, url):
+        """
+        Get the HTML for an URL, possibly from an in-memory cache.
+
+        XXX TODO Note: this cache is never actually cleared. It's assumed that
+        the data won't get stale over the lifetime of a locator instance (not
+        necessarily true for the default_locator).
+        """
+        # http://peak.telecommunity.com/DevCenter/EasyInstall#package-index-api
+        scheme, netloc, path, _, _, _ = urlparse(url)
+        if scheme == 'file' and os.path.isdir(url2pathname(path)):
+            url = urljoin(ensure_slash(url), 'index.html')
+
+        if url in self._page_cache:
+            result = self._page_cache[url]
+            logger.debug('Returning %s from cache: %s', url, result)
+        else:
+            host = netloc.split(':', 1)[0]
+            result = None
+            if host in self._bad_hosts:
+                logger.debug('Skipping %s due to bad host %s', url, host)
+            else:
+                req = Request(url, headers={'Accept-encoding': 'identity'})
+                try:
+                    logger.debug('Fetching %s', url)
+                    resp = self.opener.open(req, timeout=self.timeout)
+                    logger.debug('Fetched %s', url)
+                    headers = resp.info()
+                    content_type = headers.get('Content-Type', '')
+                    if HTML_CONTENT_TYPE.match(content_type):
+                        final_url = resp.geturl()
+                        data = resp.read()
+                        encoding = headers.get('Content-Encoding')
+                        if encoding:
+                            decoder = self.decoders[encoding]   # fail if not found
+                            data = decoder(data)
+                        encoding = 'utf-8'
+                        m = CHARSET.search(content_type)
+                        if m:
+                            encoding = m.group(1)
+                        try:
+                            data = data.decode(encoding)
+                        except UnicodeError:  # pragma: no cover
+                            data = data.decode('latin-1')    # fallback
+                        result = Page(data, final_url)
+                        self._page_cache[final_url] = result
+                except HTTPError as e:
+                    if e.code != 404:
+                        logger.exception('Fetch failed: %s: %s', url, e)
+                except URLError as e:  # pragma: no cover
+                    logger.exception('Fetch failed: %s: %s', url, e)
+                    with self._lock:
+                        self._bad_hosts.add(host)
+                except Exception as e:  # pragma: no cover
+                    logger.exception('Fetch failed: %s: %s', url, e)
+                finally:
+                    self._page_cache[url] = result   # even if None (failure)
+        return result
+
+    _distname_re = re.compile('<a href=[^>]*>([^<]+)<')
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        result = set()
+        page = self.get_page(self.base_url)
+        if not page:
+            raise DistlibException('Unable to get %s' % self.base_url)
+        for match in self._distname_re.finditer(page.data):
+            result.add(match.group(1))
+        return result
+
+class DirectoryLocator(Locator):
+    """
+    This class locates distributions in a directory tree.
+    """
+
+    def __init__(self, path, **kwargs):
+        """
+        Initialise an instance.
+        :param path: The root of the directory tree to search.
+        :param kwargs: Passed to the superclass constructor,
+                       except for:
+                       * recursive - if True (the default), subdirectories are
+                         recursed into. If False, only the top-level directory
+                         is searched,
+        """
+        self.recursive = kwargs.pop('recursive', True)
+        super(DirectoryLocator, self).__init__(**kwargs)
+        path = os.path.abspath(path)
+        if not os.path.isdir(path):  # pragma: no cover
+            raise DistlibException('Not a directory: %r' % path)
+        self.base_dir = path
+
+    def should_include(self, filename, parent):
+        """
+        Should a filename be considered as a candidate for a distribution
+        archive? As well as the filename, the directory which contains it
+        is provided, though not used by the current implementation.
+        """
+        return filename.endswith(self.downloadable_extensions)
+
+    def _get_project(self, name):
+        result = {'urls': {}, 'digests': {}}
+        for root, dirs, files in os.walk(self.base_dir):
+            for fn in files:
+                if self.should_include(fn, root):
+                    fn = os.path.join(root, fn)
+                    url = urlunparse(('file', '',
+                                      pathname2url(os.path.abspath(fn)),
+                                      '', '', ''))
+                    info = self.convert_url_to_download_info(url, name)
+                    if info:
+                        self._update_version_data(result, info)
+            if not self.recursive:
+                break
+        return result
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        result = set()
+        for root, dirs, files in os.walk(self.base_dir):
+            for fn in files:
+                if self.should_include(fn, root):
+                    fn = os.path.join(root, fn)
+                    url = urlunparse(('file', '',
+                                      pathname2url(os.path.abspath(fn)),
+                                      '', '', ''))
+                    info = self.convert_url_to_download_info(url, None)
+                    if info:
+                        result.add(info['name'])
+            if not self.recursive:
+                break
+        return result
+
+class JSONLocator(Locator):
+    """
+    This locator uses special extended metadata (not available on PyPI) and is
+    the basis of performant dependency resolution in distlib. Other locators
+    require archive downloads before dependencies can be determined! As you
+    might imagine, that can be slow.
+    """
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        raise NotImplementedError('Not available from this locator')
+
+    def _get_project(self, name):
+        result = {'urls': {}, 'digests': {}}
+        data = get_project_data(name)
+        if data:
+            for info in data.get('files', []):
+                if info['ptype'] != 'sdist' or info['pyversion'] != 'source':
+                    continue
+                # We don't store summary in project metadata as it makes
+                # the data bigger for no benefit during dependency
+                # resolution
+                dist = make_dist(data['name'], info['version'],
+                                 summary=data.get('summary',
+                                                  'Placeholder for summary'),
+                                 scheme=self.scheme)
+                md = dist.metadata
+                md.source_url = info['url']
+                # TODO SHA256 digest
+                if 'digest' in info and info['digest']:
+                    dist.digest = ('md5', info['digest'])
+                md.dependencies = info.get('requirements', {})
+                dist.exports = info.get('exports', {})
+                result[dist.version] = dist
+                result['urls'].setdefault(dist.version, set()).add(info['url'])
+        return result
+
+class DistPathLocator(Locator):
+    """
+    This locator finds installed distributions in a path. It can be useful for
+    adding to an :class:`AggregatingLocator`.
+    """
+    def __init__(self, distpath, **kwargs):
+        """
+        Initialise an instance.
+
+        :param distpath: A :class:`DistributionPath` instance to search.
+        """
+        super(DistPathLocator, self).__init__(**kwargs)
+        assert isinstance(distpath, DistributionPath)
+        self.distpath = distpath
+
+    def _get_project(self, name):
+        dist = self.distpath.get_distribution(name)
+        if dist is None:
+            result = {'urls': {}, 'digests': {}}
+        else:
+            result = {
+                dist.version: dist,
+                'urls': {dist.version: set([dist.source_url])},
+                'digests': {dist.version: set([None])}
+            }
+        return result
+
+
+class AggregatingLocator(Locator):
+    """
+    This class allows you to chain and/or merge a list of locators.
+    """
+    def __init__(self, *locators, **kwargs):
+        """
+        Initialise an instance.
+
+        :param locators: The list of locators to search.
+        :param kwargs: Passed to the superclass constructor,
+                       except for:
+                       * merge - if False (the default), the first successful
+                         search from any of the locators is returned. If True,
+                         the results from all locators are merged (this can be
+                         slow).
+        """
+        self.merge = kwargs.pop('merge', False)
+        self.locators = locators
+        super(AggregatingLocator, self).__init__(**kwargs)
+
+    def clear_cache(self):
+        super(AggregatingLocator, self).clear_cache()
+        for locator in self.locators:
+            locator.clear_cache()
+
+    def _set_scheme(self, value):
+        self._scheme = value
+        for locator in self.locators:
+            locator.scheme = value
+
+    scheme = property(Locator.scheme.fget, _set_scheme)
+
+    def _get_project(self, name):
+        result = {}
+        for locator in self.locators:
+            d = locator.get_project(name)
+            if d:
+                if self.merge:
+                    files = result.get('urls', {})
+                    digests = result.get('digests', {})
+                    # next line could overwrite result['urls'], result['digests']
+                    result.update(d)
+                    df = result.get('urls')
+                    if files and df:
+                        for k, v in files.items():
+                            if k in df:
+                                df[k] |= v
+                            else:
+                                df[k] = v
+                    dd = result.get('digests')
+                    if digests and dd:
+                        dd.update(digests)
+                else:
+                    # See issue #18. If any dists are found and we're looking
+                    # for specific constraints, we only return something if
+                    # a match is found. For example, if a DirectoryLocator
+                    # returns just foo (1.0) while we're looking for
+                    # foo (>= 2.0), we'll pretend there was nothing there so
+                    # that subsequent locators can be queried. Otherwise we
+                    # would just return foo (1.0) which would then lead to a
+                    # failure to find foo (>= 2.0), because other locators
+                    # weren't searched. Note that this only matters when
+                    # merge=False.
+                    if self.matcher is None:
+                        found = True
+                    else:
+                        found = False
+                        for k in d:
+                            if self.matcher.match(k):
+                                found = True
+                                break
+                    if found:
+                        result = d
+                        break
+        return result
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        result = set()
+        for locator in self.locators:
+            try:
+                result |= locator.get_distribution_names()
+            except NotImplementedError:
+                pass
+        return result
+
+
+# We use a legacy scheme simply because most of the dists on PyPI use legacy
+# versions which don't conform to PEP 426 / PEP 440.
+default_locator = AggregatingLocator(
+                    JSONLocator(),
+                    SimpleScrapingLocator('https://pypi.org/simple/',
+                                          timeout=3.0),
+                    scheme='legacy')
+
+locate = default_locator.locate
+
+NAME_VERSION_RE = re.compile(r'(?P<name>[\w-]+)\s*'
+                             r'\(\s*(==\s*)?(?P<ver>[^)]+)\)$')
+
+class DependencyFinder(object):
+    """
+    Locate dependencies for distributions.
+    """
+
+    def __init__(self, locator=None):
+        """
+        Initialise an instance, using the specified locator
+        to locate distributions.
+        """
+        self.locator = locator or default_locator
+        self.scheme = get_scheme(self.locator.scheme)
+
+    def add_distribution(self, dist):
+        """
+        Add a distribution to the finder. This will update internal information
+        about who provides what.
+        :param dist: The distribution to add.
+        """
+        logger.debug('adding distribution %s', dist)
+        name = dist.key
+        self.dists_by_name[name] = dist
+        self.dists[(name, dist.version)] = dist
+        for p in dist.provides:
+            name, version = parse_name_and_version(p)
+            logger.debug('Add to provided: %s, %s, %s', name, version, dist)
+            self.provided.setdefault(name, set()).add((version, dist))
+
+    def remove_distribution(self, dist):
+        """
+        Remove a distribution from the finder. This will update internal
+        information about who provides what.
+        :param dist: The distribution to remove.
+        """
+        logger.debug('removing distribution %s', dist)
+        name = dist.key
+        del self.dists_by_name[name]
+        del self.dists[(name, dist.version)]
+        for p in dist.provides:
+            name, version = parse_name_and_version(p)
+            logger.debug('Remove from provided: %s, %s, %s', name, version, dist)
+            s = self.provided[name]
+            s.remove((version, dist))
+            if not s:
+                del self.provided[name]
+
+    def get_matcher(self, reqt):
+        """
+        Get a version matcher for a requirement.
+        :param reqt: The requirement
+        :type reqt: str
+        :return: A version matcher (an instance of
+                 :class:`distlib.version.Matcher`).
+        """
+        try:
+            matcher = self.scheme.matcher(reqt)
+        except UnsupportedVersionError:  # pragma: no cover
+            # XXX compat-mode if cannot read the version
+            name = reqt.split()[0]
+            matcher = self.scheme.matcher(name)
+        return matcher
+
+    def find_providers(self, reqt):
+        """
+        Find the distributions which can fulfill a requirement.
+
+        :param reqt: The requirement.
+         :type reqt: str
+        :return: A set of distribution which can fulfill the requirement.
+        """
+        matcher = self.get_matcher(reqt)
+        name = matcher.key   # case-insensitive
+        result = set()
+        provided = self.provided
+        if name in provided:
+            for version, provider in provided[name]:
+                try:
+                    match = matcher.match(version)
+                except UnsupportedVersionError:
+                    match = False
+
+                if match:
+                    result.add(provider)
+                    break
+        return result
+
+    def try_to_replace(self, provider, other, problems):
+        """
+        Attempt to replace one provider with another. This is typically used
+        when resolving dependencies from multiple sources, e.g. A requires
+        (B >= 1.0) while C requires (B >= 1.1).
+
+        For successful replacement, ``provider`` must meet all the requirements
+        which ``other`` fulfills.
+
+        :param provider: The provider we are trying to replace with.
+        :param other: The provider we're trying to replace.
+        :param problems: If False is returned, this will contain what
+                         problems prevented replacement. This is currently
+                         a tuple of the literal string 'cantreplace',
+                         ``provider``, ``other``  and the set of requirements
+                         that ``provider`` couldn't fulfill.
+        :return: True if we can replace ``other`` with ``provider``, else
+                 False.
+        """
+        rlist = self.reqts[other]
+        unmatched = set()
+        for s in rlist:
+            matcher = self.get_matcher(s)
+            if not matcher.match(provider.version):
+                unmatched.add(s)
+        if unmatched:
+            # can't replace other with provider
+            problems.add(('cantreplace', provider, other,
+                          frozenset(unmatched)))
+            result = False
+        else:
+            # can replace other with provider
+            self.remove_distribution(other)
+            del self.reqts[other]
+            for s in rlist:
+                self.reqts.setdefault(provider, set()).add(s)
+            self.add_distribution(provider)
+            result = True
+        return result
+
+    def find(self, requirement, meta_extras=None, prereleases=False):
+        """
+        Find a distribution and all distributions it depends on.
+
+        :param requirement: The requirement specifying the distribution to
+                            find, or a Distribution instance.
+        :param meta_extras: A list of meta extras such as :test:, :build: and
+                            so on.
+        :param prereleases: If ``True``, allow pre-release versions to be
+                            returned - otherwise, don't return prereleases
+                            unless they're all that's available.
+
+        Return a set of :class:`Distribution` instances and a set of
+        problems.
+
+        The distributions returned should be such that they have the
+        :attr:`required` attribute set to ``True`` if they were
+        from the ``requirement`` passed to ``find()``, and they have the
+        :attr:`build_time_dependency` attribute set to ``True`` unless they
+        are post-installation dependencies of the ``requirement``.
+
+        The problems should be a tuple consisting of the string
+        ``'unsatisfied'`` and the requirement which couldn't be satisfied
+        by any distribution known to the locator.
+        """
+
+        self.provided = {}
+        self.dists = {}
+        self.dists_by_name = {}
+        self.reqts = {}
+
+        meta_extras = set(meta_extras or [])
+        if ':*:' in meta_extras:
+            meta_extras.remove(':*:')
+            # :meta: and :run: are implicitly included
+            meta_extras |= set([':test:', ':build:', ':dev:'])
+
+        if isinstance(requirement, Distribution):
+            dist = odist = requirement
+            logger.debug('passed %s as requirement', odist)
+        else:
+            dist = odist = self.locator.locate(requirement,
+                                               prereleases=prereleases)
+            if dist is None:
+                raise DistlibException('Unable to locate %r' % requirement)
+            logger.debug('located %s', odist)
+        dist.requested = True
+        problems = set()
+        todo = set([dist])
+        install_dists = set([odist])
+        while todo:
+            dist = todo.pop()
+            name = dist.key     # case-insensitive
+            if name not in self.dists_by_name:
+                self.add_distribution(dist)
+            else:
+                #import pdb; pdb.set_trace()
+                other = self.dists_by_name[name]
+                if other != dist:
+                    self.try_to_replace(dist, other, problems)
+
+            ireqts = dist.run_requires | dist.meta_requires
+            sreqts = dist.build_requires
+            ereqts = set()
+            if meta_extras and dist in install_dists:
+                for key in ('test', 'build', 'dev'):
+                    e = ':%s:' % key
+                    if e in meta_extras:
+                        ereqts |= getattr(dist, '%s_requires' % key)
+            all_reqts = ireqts | sreqts | ereqts
+            for r in all_reqts:
+                providers = self.find_providers(r)
+                if not providers:
+                    logger.debug('No providers found for %r', r)
+                    provider = self.locator.locate(r, prereleases=prereleases)
+                    # If no provider is found and we didn't consider
+                    # prereleases, consider them now.
+                    if provider is None and not prereleases:
+                        provider = self.locator.locate(r, prereleases=True)
+                    if provider is None:
+                        logger.debug('Cannot satisfy %r', r)
+                        problems.add(('unsatisfied', r))
+                    else:
+                        n, v = provider.key, provider.version
+                        if (n, v) not in self.dists:
+                            todo.add(provider)
+                        providers.add(provider)
+                        if r in ireqts and dist in install_dists:
+                            install_dists.add(provider)
+                            logger.debug('Adding %s to install_dists',
+                                         provider.name_and_version)
+                for p in providers:
+                    name = p.key
+                    if name not in self.dists_by_name:
+                        self.reqts.setdefault(p, set()).add(r)
+                    else:
+                        other = self.dists_by_name[name]
+                        if other != p:
+                            # see if other can be replaced by p
+                            self.try_to_replace(p, other, problems)
+
+        dists = set(self.dists.values())
+        for dist in dists:
+            dist.build_time_dependency = dist not in install_dists
+            if dist.build_time_dependency:
+                logger.debug('%s is a build-time dependency only.',
+                             dist.name_and_version)
+        logger.debug('find done for %s', odist)
+        return dists, problems
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/manifest.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/manifest.py
new file mode 100644
index 0000000..ca0fe44
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/manifest.py
@@ -0,0 +1,393 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""
+Class representing the list of files in a distribution.
+
+Equivalent to distutils.filelist, but fixes some problems.
+"""
+import fnmatch
+import logging
+import os
+import re
+import sys
+
+from . import DistlibException
+from .compat import fsdecode
+from .util import convert_path
+
+
+__all__ = ['Manifest']
+
+logger = logging.getLogger(__name__)
+
+# a \ followed by some spaces + EOL
+_COLLAPSE_PATTERN = re.compile('\\\\w*\n', re.M)
+_COMMENTED_LINE = re.compile('#.*?(?=\n)|\n(?=$)', re.M | re.S)
+
+#
+# Due to the different results returned by fnmatch.translate, we need
+# to do slightly different processing for Python 2.7 and 3.2 ... this needed
+# to be brought in for Python 3.6 onwards.
+#
+_PYTHON_VERSION = sys.version_info[:2]
+
+class Manifest(object):
+    """A list of files built by on exploring the filesystem and filtered by
+    applying various patterns to what we find there.
+    """
+
+    def __init__(self, base=None):
+        """
+        Initialise an instance.
+
+        :param base: The base directory to explore under.
+        """
+        self.base = os.path.abspath(os.path.normpath(base or os.getcwd()))
+        self.prefix = self.base + os.sep
+        self.allfiles = None
+        self.files = set()
+
+    #
+    # Public API
+    #
+
+    def findall(self):
+        """Find all files under the base and set ``allfiles`` to the absolute
+        pathnames of files found.
+        """
+        from stat import S_ISREG, S_ISDIR, S_ISLNK
+
+        self.allfiles = allfiles = []
+        root = self.base
+        stack = [root]
+        pop = stack.pop
+        push = stack.append
+
+        while stack:
+            root = pop()
+            names = os.listdir(root)
+
+            for name in names:
+                fullname = os.path.join(root, name)
+
+                # Avoid excess stat calls -- just one will do, thank you!
+                stat = os.stat(fullname)
+                mode = stat.st_mode
+                if S_ISREG(mode):
+                    allfiles.append(fsdecode(fullname))
+                elif S_ISDIR(mode) and not S_ISLNK(mode):
+                    push(fullname)
+
+    def add(self, item):
+        """
+        Add a file to the manifest.
+
+        :param item: The pathname to add. This can be relative to the base.
+        """
+        if not item.startswith(self.prefix):
+            item = os.path.join(self.base, item)
+        self.files.add(os.path.normpath(item))
+
+    def add_many(self, items):
+        """
+        Add a list of files to the manifest.
+
+        :param items: The pathnames to add. These can be relative to the base.
+        """
+        for item in items:
+            self.add(item)
+
+    def sorted(self, wantdirs=False):
+        """
+        Return sorted files in directory order
+        """
+
+        def add_dir(dirs, d):
+            dirs.add(d)
+            logger.debug('add_dir added %s', d)
+            if d != self.base:
+                parent, _ = os.path.split(d)
+                assert parent not in ('', '/')
+                add_dir(dirs, parent)
+
+        result = set(self.files)    # make a copy!
+        if wantdirs:
+            dirs = set()
+            for f in result:
+                add_dir(dirs, os.path.dirname(f))
+            result |= dirs
+        return [os.path.join(*path_tuple) for path_tuple in
+                sorted(os.path.split(path) for path in result)]
+
+    def clear(self):
+        """Clear all collected files."""
+        self.files = set()
+        self.allfiles = []
+
+    def process_directive(self, directive):
+        """
+        Process a directive which either adds some files from ``allfiles`` to
+        ``files``, or removes some files from ``files``.
+
+        :param directive: The directive to process. This should be in a format
+                     compatible with distutils ``MANIFEST.in`` files:
+
+                     http://docs.python.org/distutils/sourcedist.html#commands
+        """
+        # Parse the line: split it up, make sure the right number of words
+        # is there, and return the relevant words.  'action' is always
+        # defined: it's the first word of the line.  Which of the other
+        # three are defined depends on the action; it'll be either
+        # patterns, (dir and patterns), or (dirpattern).
+        action, patterns, thedir, dirpattern = self._parse_directive(directive)
+
+        # OK, now we know that the action is valid and we have the
+        # right number of words on the line for that action -- so we
+        # can proceed with minimal error-checking.
+        if action == 'include':
+            for pattern in patterns:
+                if not self._include_pattern(pattern, anchor=True):
+                    logger.warning('no files found matching %r', pattern)
+
+        elif action == 'exclude':
+            for pattern in patterns:
+                found = self._exclude_pattern(pattern, anchor=True)
+                #if not found:
+                #    logger.warning('no previously-included files '
+                #                   'found matching %r', pattern)
+
+        elif action == 'global-include':
+            for pattern in patterns:
+                if not self._include_pattern(pattern, anchor=False):
+                    logger.warning('no files found matching %r '
+                                   'anywhere in distribution', pattern)
+
+        elif action == 'global-exclude':
+            for pattern in patterns:
+                found = self._exclude_pattern(pattern, anchor=False)
+                #if not found:
+                #    logger.warning('no previously-included files '
+                #                   'matching %r found anywhere in '
+                #                   'distribution', pattern)
+
+        elif action == 'recursive-include':
+            for pattern in patterns:
+                if not self._include_pattern(pattern, prefix=thedir):
+                    logger.warning('no files found matching %r '
+                                   'under directory %r', pattern, thedir)
+
+        elif action == 'recursive-exclude':
+            for pattern in patterns:
+                found = self._exclude_pattern(pattern, prefix=thedir)
+                #if not found:
+                #    logger.warning('no previously-included files '
+                #                   'matching %r found under directory %r',
+                #                   pattern, thedir)
+
+        elif action == 'graft':
+            if not self._include_pattern(None, prefix=dirpattern):
+                logger.warning('no directories found matching %r',
+                               dirpattern)
+
+        elif action == 'prune':
+            if not self._exclude_pattern(None, prefix=dirpattern):
+                logger.warning('no previously-included directories found '
+                               'matching %r', dirpattern)
+        else:   # pragma: no cover
+            # This should never happen, as it should be caught in
+            # _parse_template_line
+            raise DistlibException(
+                'invalid action %r' % action)
+
+    #
+    # Private API
+    #
+
+    def _parse_directive(self, directive):
+        """
+        Validate a directive.
+        :param directive: The directive to validate.
+        :return: A tuple of action, patterns, thedir, dir_patterns
+        """
+        words = directive.split()
+        if len(words) == 1 and words[0] not in ('include', 'exclude',
+                                                'global-include',
+                                                'global-exclude',
+                                                'recursive-include',
+                                                'recursive-exclude',
+                                                'graft', 'prune'):
+            # no action given, let's use the default 'include'
+            words.insert(0, 'include')
+
+        action = words[0]
+        patterns = thedir = dir_pattern = None
+
+        if action in ('include', 'exclude',
+                      'global-include', 'global-exclude'):
+            if len(words) < 2:
+                raise DistlibException(
+                    '%r expects <pattern1> <pattern2> ...' % action)
+
+            patterns = [convert_path(word) for word in words[1:]]
+
+        elif action in ('recursive-include', 'recursive-exclude'):
+            if len(words) < 3:
+                raise DistlibException(
+                    '%r expects <dir> <pattern1> <pattern2> ...' % action)
+
+            thedir = convert_path(words[1])
+            patterns = [convert_path(word) for word in words[2:]]
+
+        elif action in ('graft', 'prune'):
+            if len(words) != 2:
+                raise DistlibException(
+                    '%r expects a single <dir_pattern>' % action)
+
+            dir_pattern = convert_path(words[1])
+
+        else:
+            raise DistlibException('unknown action %r' % action)
+
+        return action, patterns, thedir, dir_pattern
+
+    def _include_pattern(self, pattern, anchor=True, prefix=None,
+                         is_regex=False):
+        """Select strings (presumably filenames) from 'self.files' that
+        match 'pattern', a Unix-style wildcard (glob) pattern.
+
+        Patterns are not quite the same as implemented by the 'fnmatch'
+        module: '*' and '?'  match non-special characters, where "special"
+        is platform-dependent: slash on Unix; colon, slash, and backslash on
+        DOS/Windows; and colon on Mac OS.
+
+        If 'anchor' is true (the default), then the pattern match is more
+        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
+        'anchor' is false, both of these will match.
+
+        If 'prefix' is supplied, then only filenames starting with 'prefix'
+        (itself a pattern) and ending with 'pattern', with anything in between
+        them, will match.  'anchor' is ignored in this case.
+
+        If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
+        'pattern' is assumed to be either a string containing a regex or a
+        regex object -- no translation is done, the regex is just compiled
+        and used as-is.
+
+        Selected strings will be added to self.files.
+
+        Return True if files are found.
+        """
+        # XXX docstring lying about what the special chars are?
+        found = False
+        pattern_re = self._translate_pattern(pattern, anchor, prefix, is_regex)
+
+        # delayed loading of allfiles list
+        if self.allfiles is None:
+            self.findall()
+
+        for name in self.allfiles:
+            if pattern_re.search(name):
+                self.files.add(name)
+                found = True
+        return found
+
+    def _exclude_pattern(self, pattern, anchor=True, prefix=None,
+                         is_regex=False):
+        """Remove strings (presumably filenames) from 'files' that match
+        'pattern'.
+
+        Other parameters are the same as for 'include_pattern()', above.
+        The list 'self.files' is modified in place. Return True if files are
+        found.
+
+        This API is public to allow e.g. exclusion of SCM subdirs, e.g. when
+        packaging source distributions
+        """
+        found = False
+        pattern_re = self._translate_pattern(pattern, anchor, prefix, is_regex)
+        for f in list(self.files):
+            if pattern_re.search(f):
+                self.files.remove(f)
+                found = True
+        return found
+
+    def _translate_pattern(self, pattern, anchor=True, prefix=None,
+                           is_regex=False):
+        """Translate a shell-like wildcard pattern to a compiled regular
+        expression.
+
+        Return the compiled regex.  If 'is_regex' true,
+        then 'pattern' is directly compiled to a regex (if it's a string)
+        or just returned as-is (assumes it's a regex object).
+        """
+        if is_regex:
+            if isinstance(pattern, str):
+                return re.compile(pattern)
+            else:
+                return pattern
+
+        if _PYTHON_VERSION > (3, 2):
+            # ditch start and end characters
+            start, _, end = self._glob_to_re('_').partition('_')
+
+        if pattern:
+            pattern_re = self._glob_to_re(pattern)
+            if _PYTHON_VERSION > (3, 2):
+                assert pattern_re.startswith(start) and pattern_re.endswith(end)
+        else:
+            pattern_re = ''
+
+        base = re.escape(os.path.join(self.base, ''))
+        if prefix is not None:
+            # ditch end of pattern character
+            if _PYTHON_VERSION <= (3, 2):
+                empty_pattern = self._glob_to_re('')
+                prefix_re = self._glob_to_re(prefix)[:-len(empty_pattern)]
+            else:
+                prefix_re = self._glob_to_re(prefix)
+                assert prefix_re.startswith(start) and prefix_re.endswith(end)
+                prefix_re = prefix_re[len(start): len(prefix_re) - len(end)]
+            sep = os.sep
+            if os.sep == '\\':
+                sep = r'\\'
+            if _PYTHON_VERSION <= (3, 2):
+                pattern_re = '^' + base + sep.join((prefix_re,
+                                                    '.*' + pattern_re))
+            else:
+                pattern_re = pattern_re[len(start): len(pattern_re) - len(end)]
+                pattern_re = r'%s%s%s%s.*%s%s' % (start, base, prefix_re, sep,
+                                                  pattern_re, end)
+        else:  # no prefix -- respect anchor flag
+            if anchor:
+                if _PYTHON_VERSION <= (3, 2):
+                    pattern_re = '^' + base + pattern_re
+                else:
+                    pattern_re = r'%s%s%s' % (start, base, pattern_re[len(start):])
+
+        return re.compile(pattern_re)
+
+    def _glob_to_re(self, pattern):
+        """Translate a shell-like glob pattern to a regular expression.
+
+        Return a string containing the regex.  Differs from
+        'fnmatch.translate()' in that '*' does not match "special characters"
+        (which are platform-specific).
+        """
+        pattern_re = fnmatch.translate(pattern)
+
+        # '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
+        # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
+        # and by extension they shouldn't match such "special characters" under
+        # any OS.  So change all non-escaped dots in the RE to match any
+        # character except the special characters (currently: just os.sep).
+        sep = os.sep
+        if os.sep == '\\':
+            # we're using a regex to manipulate a regex, so we need
+            # to escape the backslash twice
+            sep = r'\\\\'
+        escaped = r'\1[^%s]' % sep
+        pattern_re = re.sub(r'((?<!\\)(\\\\)*)\.', escaped, pattern_re)
+        return pattern_re
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/markers.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/markers.py
new file mode 100644
index 0000000..ee1f3e2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/markers.py
@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2017 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""
+Parser for the environment markers micro-language defined in PEP 508.
+"""
+
+# Note: In PEP 345, the micro-language was Python compatible, so the ast
+# module could be used to parse it. However, PEP 508 introduced operators such
+# as ~= and === which aren't in Python, necessitating a different approach.
+
+import os
+import sys
+import platform
+import re
+
+from .compat import python_implementation, urlparse, string_types
+from .util import in_venv, parse_marker
+
+__all__ = ['interpret']
+
+def _is_literal(o):
+    if not isinstance(o, string_types) or not o:
+        return False
+    return o[0] in '\'"'
+
+class Evaluator(object):
+    """
+    This class is used to evaluate marker expessions.
+    """
+
+    operations = {
+        '==': lambda x, y: x == y,
+        '===': lambda x, y: x == y,
+        '~=': lambda x, y: x == y or x > y,
+        '!=': lambda x, y: x != y,
+        '<':  lambda x, y: x < y,
+        '<=':  lambda x, y: x == y or x < y,
+        '>':  lambda x, y: x > y,
+        '>=':  lambda x, y: x == y or x > y,
+        'and': lambda x, y: x and y,
+        'or': lambda x, y: x or y,
+        'in': lambda x, y: x in y,
+        'not in': lambda x, y: x not in y,
+    }
+
+    def evaluate(self, expr, context):
+        """
+        Evaluate a marker expression returned by the :func:`parse_requirement`
+        function in the specified context.
+        """
+        if isinstance(expr, string_types):
+            if expr[0] in '\'"':
+                result = expr[1:-1]
+            else:
+                if expr not in context:
+                    raise SyntaxError('unknown variable: %s' % expr)
+                result = context[expr]
+        else:
+            assert isinstance(expr, dict)
+            op = expr['op']
+            if op not in self.operations:
+                raise NotImplementedError('op not implemented: %s' % op)
+            elhs = expr['lhs']
+            erhs = expr['rhs']
+            if _is_literal(expr['lhs']) and _is_literal(expr['rhs']):
+                raise SyntaxError('invalid comparison: %s %s %s' % (elhs, op, erhs))
+
+            lhs = self.evaluate(elhs, context)
+            rhs = self.evaluate(erhs, context)
+            result = self.operations[op](lhs, rhs)
+        return result
+
+def default_context():
+    def format_full_version(info):
+        version = '%s.%s.%s' % (info.major, info.minor, info.micro)
+        kind = info.releaselevel
+        if kind != 'final':
+            version += kind[0] + str(info.serial)
+        return version
+
+    if hasattr(sys, 'implementation'):
+        implementation_version = format_full_version(sys.implementation.version)
+        implementation_name = sys.implementation.name
+    else:
+        implementation_version = '0'
+        implementation_name = ''
+
+    result = {
+        'implementation_name': implementation_name,
+        'implementation_version': implementation_version,
+        'os_name': os.name,
+        'platform_machine': platform.machine(),
+        'platform_python_implementation': platform.python_implementation(),
+        'platform_release': platform.release(),
+        'platform_system': platform.system(),
+        'platform_version': platform.version(),
+        'platform_in_venv': str(in_venv()),
+        'python_full_version': platform.python_version(),
+        'python_version': platform.python_version()[:3],
+        'sys_platform': sys.platform,
+    }
+    return result
+
+DEFAULT_CONTEXT = default_context()
+del default_context
+
+evaluator = Evaluator()
+
+def interpret(marker, execution_context=None):
+    """
+    Interpret a marker and return a result depending on environment.
+
+    :param marker: The marker to interpret.
+    :type marker: str
+    :param execution_context: The context used for name lookup.
+    :type execution_context: mapping
+    """
+    try:
+        expr, rest = parse_marker(marker)
+    except Exception as e:
+        raise SyntaxError('Unable to interpret marker syntax: %s: %s' % (marker, e))
+    if rest and rest[0] != '#':
+        raise SyntaxError('unexpected trailing data in marker: %s: %s' % (marker, rest))
+    context = dict(DEFAULT_CONTEXT)
+    if execution_context:
+        context.update(execution_context)
+    return evaluator.evaluate(expr, context)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/metadata.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/metadata.py
new file mode 100644
index 0000000..6d5e236
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/metadata.py
@@ -0,0 +1,1056 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""Implementation of the Metadata for Python packages PEPs.
+
+Supports all metadata formats (1.0, 1.1, 1.2, 1.3/2.1 and withdrawn 2.0).
+"""
+from __future__ import unicode_literals
+
+import codecs
+from email import message_from_file
+import json
+import logging
+import re
+
+
+from . import DistlibException, __version__
+from .compat import StringIO, string_types, text_type
+from .markers import interpret
+from .util import extract_by_key, get_extras
+from .version import get_scheme, PEP440_VERSION_RE
+
+logger = logging.getLogger(__name__)
+
+
+class MetadataMissingError(DistlibException):
+    """A required metadata is missing"""
+
+
+class MetadataConflictError(DistlibException):
+    """Attempt to read or write metadata fields that are conflictual."""
+
+
+class MetadataUnrecognizedVersionError(DistlibException):
+    """Unknown metadata version number."""
+
+
+class MetadataInvalidError(DistlibException):
+    """A metadata value is invalid"""
+
+# public API of this module
+__all__ = ['Metadata', 'PKG_INFO_ENCODING', 'PKG_INFO_PREFERRED_VERSION']
+
+# Encoding used for the PKG-INFO files
+PKG_INFO_ENCODING = 'utf-8'
+
+# preferred version. Hopefully will be changed
+# to 1.2 once PEP 345 is supported everywhere
+PKG_INFO_PREFERRED_VERSION = '1.1'
+
+_LINE_PREFIX_1_2 = re.compile('\n       \\|')
+_LINE_PREFIX_PRE_1_2 = re.compile('\n        ')
+_241_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform',
+               'Summary', 'Description',
+               'Keywords', 'Home-page', 'Author', 'Author-email',
+               'License')
+
+_314_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform',
+               'Supported-Platform', 'Summary', 'Description',
+               'Keywords', 'Home-page', 'Author', 'Author-email',
+               'License', 'Classifier', 'Download-URL', 'Obsoletes',
+               'Provides', 'Requires')
+
+_314_MARKERS = ('Obsoletes', 'Provides', 'Requires', 'Classifier',
+                'Download-URL')
+
+_345_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform',
+               'Supported-Platform', 'Summary', 'Description',
+               'Keywords', 'Home-page', 'Author', 'Author-email',
+               'Maintainer', 'Maintainer-email', 'License',
+               'Classifier', 'Download-URL', 'Obsoletes-Dist',
+               'Project-URL', 'Provides-Dist', 'Requires-Dist',
+               'Requires-Python', 'Requires-External')
+
+_345_MARKERS = ('Provides-Dist', 'Requires-Dist', 'Requires-Python',
+                'Obsoletes-Dist', 'Requires-External', 'Maintainer',
+                'Maintainer-email', 'Project-URL')
+
+_426_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform',
+               'Supported-Platform', 'Summary', 'Description',
+               'Keywords', 'Home-page', 'Author', 'Author-email',
+               'Maintainer', 'Maintainer-email', 'License',
+               'Classifier', 'Download-URL', 'Obsoletes-Dist',
+               'Project-URL', 'Provides-Dist', 'Requires-Dist',
+               'Requires-Python', 'Requires-External', 'Private-Version',
+               'Obsoleted-By', 'Setup-Requires-Dist', 'Extension',
+               'Provides-Extra')
+
+_426_MARKERS = ('Private-Version', 'Provides-Extra', 'Obsoleted-By',
+                'Setup-Requires-Dist', 'Extension')
+
+# See issue #106: Sometimes 'Requires' and 'Provides' occur wrongly in
+# the metadata. Include them in the tuple literal below to allow them
+# (for now).
+_566_FIELDS = _426_FIELDS + ('Description-Content-Type',
+                             'Requires', 'Provides')
+
+_566_MARKERS = ('Description-Content-Type',)
+
+_ALL_FIELDS = set()
+_ALL_FIELDS.update(_241_FIELDS)
+_ALL_FIELDS.update(_314_FIELDS)
+_ALL_FIELDS.update(_345_FIELDS)
+_ALL_FIELDS.update(_426_FIELDS)
+_ALL_FIELDS.update(_566_FIELDS)
+
+EXTRA_RE = re.compile(r'''extra\s*==\s*("([^"]+)"|'([^']+)')''')
+
+
+def _version2fieldlist(version):
+    if version == '1.0':
+        return _241_FIELDS
+    elif version == '1.1':
+        return _314_FIELDS
+    elif version == '1.2':
+        return _345_FIELDS
+    elif version in ('1.3', '2.1'):
+        return _345_FIELDS + _566_FIELDS
+    elif version == '2.0':
+        return _426_FIELDS
+    raise MetadataUnrecognizedVersionError(version)
+
+
+def _best_version(fields):
+    """Detect the best version depending on the fields used."""
+    def _has_marker(keys, markers):
+        for marker in markers:
+            if marker in keys:
+                return True
+        return False
+
+    keys = []
+    for key, value in fields.items():
+        if value in ([], 'UNKNOWN', None):
+            continue
+        keys.append(key)
+
+    possible_versions = ['1.0', '1.1', '1.2', '1.3', '2.0', '2.1']
+
+    # first let's try to see if a field is not part of one of the version
+    for key in keys:
+        if key not in _241_FIELDS and '1.0' in possible_versions:
+            possible_versions.remove('1.0')
+            logger.debug('Removed 1.0 due to %s', key)
+        if key not in _314_FIELDS and '1.1' in possible_versions:
+            possible_versions.remove('1.1')
+            logger.debug('Removed 1.1 due to %s', key)
+        if key not in _345_FIELDS and '1.2' in possible_versions:
+            possible_versions.remove('1.2')
+            logger.debug('Removed 1.2 due to %s', key)
+        if key not in _566_FIELDS and '1.3' in possible_versions:
+            possible_versions.remove('1.3')
+            logger.debug('Removed 1.3 due to %s', key)
+        if key not in _566_FIELDS and '2.1' in possible_versions:
+            if key != 'Description':  # In 2.1, description allowed after headers
+                possible_versions.remove('2.1')
+                logger.debug('Removed 2.1 due to %s', key)
+        if key not in _426_FIELDS and '2.0' in possible_versions:
+            possible_versions.remove('2.0')
+            logger.debug('Removed 2.0 due to %s', key)
+
+    # possible_version contains qualified versions
+    if len(possible_versions) == 1:
+        return possible_versions[0]   # found !
+    elif len(possible_versions) == 0:
+        logger.debug('Out of options - unknown metadata set: %s', fields)
+        raise MetadataConflictError('Unknown metadata set')
+
+    # let's see if one unique marker is found
+    is_1_1 = '1.1' in possible_versions and _has_marker(keys, _314_MARKERS)
+    is_1_2 = '1.2' in possible_versions and _has_marker(keys, _345_MARKERS)
+    is_2_1 = '2.1' in possible_versions and _has_marker(keys, _566_MARKERS)
+    is_2_0 = '2.0' in possible_versions and _has_marker(keys, _426_MARKERS)
+    if int(is_1_1) + int(is_1_2) + int(is_2_1) + int(is_2_0) > 1:
+        raise MetadataConflictError('You used incompatible 1.1/1.2/2.0/2.1 fields')
+
+    # we have the choice, 1.0, or 1.2, or 2.0
+    #   - 1.0 has a broken Summary field but works with all tools
+    #   - 1.1 is to avoid
+    #   - 1.2 fixes Summary but has little adoption
+    #   - 2.0 adds more features and is very new
+    if not is_1_1 and not is_1_2 and not is_2_1 and not is_2_0:
+        # we couldn't find any specific marker
+        if PKG_INFO_PREFERRED_VERSION in possible_versions:
+            return PKG_INFO_PREFERRED_VERSION
+    if is_1_1:
+        return '1.1'
+    if is_1_2:
+        return '1.2'
+    if is_2_1:
+        return '2.1'
+
+    return '2.0'
+
+# This follows the rules about transforming keys as described in
+# https://www.python.org/dev/peps/pep-0566/#id17
+_ATTR2FIELD = {
+    name.lower().replace("-", "_"): name for name in _ALL_FIELDS
+}
+_FIELD2ATTR = {field: attr for attr, field in _ATTR2FIELD.items()}
+
+_PREDICATE_FIELDS = ('Requires-Dist', 'Obsoletes-Dist', 'Provides-Dist')
+_VERSIONS_FIELDS = ('Requires-Python',)
+_VERSION_FIELDS = ('Version',)
+_LISTFIELDS = ('Platform', 'Classifier', 'Obsoletes',
+               'Requires', 'Provides', 'Obsoletes-Dist',
+               'Provides-Dist', 'Requires-Dist', 'Requires-External',
+               'Project-URL', 'Supported-Platform', 'Setup-Requires-Dist',
+               'Provides-Extra', 'Extension')
+_LISTTUPLEFIELDS = ('Project-URL',)
+
+_ELEMENTSFIELD = ('Keywords',)
+
+_UNICODEFIELDS = ('Author', 'Maintainer', 'Summary', 'Description')
+
+_MISSING = object()
+
+_FILESAFE = re.compile('[^A-Za-z0-9.]+')
+
+
+def _get_name_and_version(name, version, for_filename=False):
+    """Return the distribution name with version.
+
+    If for_filename is true, return a filename-escaped form."""
+    if for_filename:
+        # For both name and version any runs of non-alphanumeric or '.'
+        # characters are replaced with a single '-'.  Additionally any
+        # spaces in the version string become '.'
+        name = _FILESAFE.sub('-', name)
+        version = _FILESAFE.sub('-', version.replace(' ', '.'))
+    return '%s-%s' % (name, version)
+
+
+class LegacyMetadata(object):
+    """The legacy metadata of a release.
+
+    Supports versions 1.0, 1.1, 1.2, 2.0 and 1.3/2.1 (auto-detected). You can
+    instantiate the class with one of these arguments (or none):
+    - *path*, the path to a metadata file
+    - *fileobj* give a file-like object with metadata as content
+    - *mapping* is a dict-like object
+    - *scheme* is a version scheme name
+    """
+    # TODO document the mapping API and UNKNOWN default key
+
+    def __init__(self, path=None, fileobj=None, mapping=None,
+                 scheme='default'):
+        if [path, fileobj, mapping].count(None) < 2:
+            raise TypeError('path, fileobj and mapping are exclusive')
+        self._fields = {}
+        self.requires_files = []
+        self._dependencies = None
+        self.scheme = scheme
+        if path is not None:
+            self.read(path)
+        elif fileobj is not None:
+            self.read_file(fileobj)
+        elif mapping is not None:
+            self.update(mapping)
+            self.set_metadata_version()
+
+    def set_metadata_version(self):
+        self._fields['Metadata-Version'] = _best_version(self._fields)
+
+    def _write_field(self, fileobj, name, value):
+        fileobj.write('%s: %s\n' % (name, value))
+
+    def __getitem__(self, name):
+        return self.get(name)
+
+    def __setitem__(self, name, value):
+        return self.set(name, value)
+
+    def __delitem__(self, name):
+        field_name = self._convert_name(name)
+        try:
+            del self._fields[field_name]
+        except KeyError:
+            raise KeyError(name)
+
+    def __contains__(self, name):
+        return (name in self._fields or
+                self._convert_name(name) in self._fields)
+
+    def _convert_name(self, name):
+        if name in _ALL_FIELDS:
+            return name
+        name = name.replace('-', '_').lower()
+        return _ATTR2FIELD.get(name, name)
+
+    def _default_value(self, name):
+        if name in _LISTFIELDS or name in _ELEMENTSFIELD:
+            return []
+        return 'UNKNOWN'
+
+    def _remove_line_prefix(self, value):
+        if self.metadata_version in ('1.0', '1.1'):
+            return _LINE_PREFIX_PRE_1_2.sub('\n', value)
+        else:
+            return _LINE_PREFIX_1_2.sub('\n', value)
+
+    def __getattr__(self, name):
+        if name in _ATTR2FIELD:
+            return self[name]
+        raise AttributeError(name)
+
+    #
+    # Public API
+    #
+
+#    dependencies = property(_get_dependencies, _set_dependencies)
+
+    def get_fullname(self, filesafe=False):
+        """Return the distribution name with version.
+
+        If filesafe is true, return a filename-escaped form."""
+        return _get_name_and_version(self['Name'], self['Version'], filesafe)
+
+    def is_field(self, name):
+        """return True if name is a valid metadata key"""
+        name = self._convert_name(name)
+        return name in _ALL_FIELDS
+
+    def is_multi_field(self, name):
+        name = self._convert_name(name)
+        return name in _LISTFIELDS
+
+    def read(self, filepath):
+        """Read the metadata values from a file path."""
+        fp = codecs.open(filepath, 'r', encoding='utf-8')
+        try:
+            self.read_file(fp)
+        finally:
+            fp.close()
+
+    def read_file(self, fileob):
+        """Read the metadata values from a file object."""
+        msg = message_from_file(fileob)
+        self._fields['Metadata-Version'] = msg['metadata-version']
+
+        # When reading, get all the fields we can
+        for field in _ALL_FIELDS:
+            if field not in msg:
+                continue
+            if field in _LISTFIELDS:
+                # we can have multiple lines
+                values = msg.get_all(field)
+                if field in _LISTTUPLEFIELDS and values is not None:
+                    values = [tuple(value.split(',')) for value in values]
+                self.set(field, values)
+            else:
+                # single line
+                value = msg[field]
+                if value is not None and value != 'UNKNOWN':
+                    self.set(field, value)
+
+        # PEP 566 specifies that the body be used for the description, if
+        # available
+        body = msg.get_payload()
+        self["Description"] = body if body else self["Description"]
+        # logger.debug('Attempting to set metadata for %s', self)
+        # self.set_metadata_version()
+
+    def write(self, filepath, skip_unknown=False):
+        """Write the metadata fields to filepath."""
+        fp = codecs.open(filepath, 'w', encoding='utf-8')
+        try:
+            self.write_file(fp, skip_unknown)
+        finally:
+            fp.close()
+
+    def write_file(self, fileobject, skip_unknown=False):
+        """Write the PKG-INFO format data to a file object."""
+        self.set_metadata_version()
+
+        for field in _version2fieldlist(self['Metadata-Version']):
+            values = self.get(field)
+            if skip_unknown and values in ('UNKNOWN', [], ['UNKNOWN']):
+                continue
+            if field in _ELEMENTSFIELD:
+                self._write_field(fileobject, field, ','.join(values))
+                continue
+            if field not in _LISTFIELDS:
+                if field == 'Description':
+                    if self.metadata_version in ('1.0', '1.1'):
+                        values = values.replace('\n', '\n        ')
+                    else:
+                        values = values.replace('\n', '\n       |')
+                values = [values]
+
+            if field in _LISTTUPLEFIELDS:
+                values = [','.join(value) for value in values]
+
+            for value in values:
+                self._write_field(fileobject, field, value)
+
+    def update(self, other=None, **kwargs):
+        """Set metadata values from the given iterable `other` and kwargs.
+
+        Behavior is like `dict.update`: If `other` has a ``keys`` method,
+        they are looped over and ``self[key]`` is assigned ``other[key]``.
+        Else, ``other`` is an iterable of ``(key, value)`` iterables.
+
+        Keys that don't match a metadata field or that have an empty value are
+        dropped.
+        """
+        def _set(key, value):
+            if key in _ATTR2FIELD and value:
+                self.set(self._convert_name(key), value)
+
+        if not other:
+            # other is None or empty container
+            pass
+        elif hasattr(other, 'keys'):
+            for k in other.keys():
+                _set(k, other[k])
+        else:
+            for k, v in other:
+                _set(k, v)
+
+        if kwargs:
+            for k, v in kwargs.items():
+                _set(k, v)
+
+    def set(self, name, value):
+        """Control then set a metadata field."""
+        name = self._convert_name(name)
+
+        if ((name in _ELEMENTSFIELD or name == 'Platform') and
+            not isinstance(value, (list, tuple))):
+            if isinstance(value, string_types):
+                value = [v.strip() for v in value.split(',')]
+            else:
+                value = []
+        elif (name in _LISTFIELDS and
+              not isinstance(value, (list, tuple))):
+            if isinstance(value, string_types):
+                value = [value]
+            else:
+                value = []
+
+        if logger.isEnabledFor(logging.WARNING):
+            project_name = self['Name']
+
+            scheme = get_scheme(self.scheme)
+            if name in _PREDICATE_FIELDS and value is not None:
+                for v in value:
+                    # check that the values are valid
+                    if not scheme.is_valid_matcher(v.split(';')[0]):
+                        logger.warning(
+                            "'%s': '%s' is not valid (field '%s')",
+                            project_name, v, name)
+            # FIXME this rejects UNKNOWN, is that right?
+            elif name in _VERSIONS_FIELDS and value is not None:
+                if not scheme.is_valid_constraint_list(value):
+                    logger.warning("'%s': '%s' is not a valid version (field '%s')",
+                                   project_name, value, name)
+            elif name in _VERSION_FIELDS and value is not None:
+                if not scheme.is_valid_version(value):
+                    logger.warning("'%s': '%s' is not a valid version (field '%s')",
+                                   project_name, value, name)
+
+        if name in _UNICODEFIELDS:
+            if name == 'Description':
+                value = self._remove_line_prefix(value)
+
+        self._fields[name] = value
+
+    def get(self, name, default=_MISSING):
+        """Get a metadata field."""
+        name = self._convert_name(name)
+        if name not in self._fields:
+            if default is _MISSING:
+                default = self._default_value(name)
+            return default
+        if name in _UNICODEFIELDS:
+            value = self._fields[name]
+            return value
+        elif name in _LISTFIELDS:
+            value = self._fields[name]
+            if value is None:
+                return []
+            res = []
+            for val in value:
+                if name not in _LISTTUPLEFIELDS:
+                    res.append(val)
+                else:
+                    # That's for Project-URL
+                    res.append((val[0], val[1]))
+            return res
+
+        elif name in _ELEMENTSFIELD:
+            value = self._fields[name]
+            if isinstance(value, string_types):
+                return value.split(',')
+        return self._fields[name]
+
+    def check(self, strict=False):
+        """Check if the metadata is compliant. If strict is True then raise if
+        no Name or Version are provided"""
+        self.set_metadata_version()
+
+        # XXX should check the versions (if the file was loaded)
+        missing, warnings = [], []
+
+        for attr in ('Name', 'Version'):  # required by PEP 345
+            if attr not in self:
+                missing.append(attr)
+
+        if strict and missing != []:
+            msg = 'missing required metadata: %s' % ', '.join(missing)
+            raise MetadataMissingError(msg)
+
+        for attr in ('Home-page', 'Author'):
+            if attr not in self:
+                missing.append(attr)
+
+        # checking metadata 1.2 (XXX needs to check 1.1, 1.0)
+        if self['Metadata-Version'] != '1.2':
+            return missing, warnings
+
+        scheme = get_scheme(self.scheme)
+
+        def are_valid_constraints(value):
+            for v in value:
+                if not scheme.is_valid_matcher(v.split(';')[0]):
+                    return False
+            return True
+
+        for fields, controller in ((_PREDICATE_FIELDS, are_valid_constraints),
+                                   (_VERSIONS_FIELDS,
+                                    scheme.is_valid_constraint_list),
+                                   (_VERSION_FIELDS,
+                                    scheme.is_valid_version)):
+            for field in fields:
+                value = self.get(field, None)
+                if value is not None and not controller(value):
+                    warnings.append("Wrong value for '%s': %s" % (field, value))
+
+        return missing, warnings
+
+    def todict(self, skip_missing=False):
+        """Return fields as a dict.
+
+        Field names will be converted to use the underscore-lowercase style
+        instead of hyphen-mixed case (i.e. home_page instead of Home-page).
+        This is as per https://www.python.org/dev/peps/pep-0566/#id17.
+        """
+        self.set_metadata_version()
+
+        fields = _version2fieldlist(self['Metadata-Version'])
+
+        data = {}
+
+        for field_name in fields:
+            if not skip_missing or field_name in self._fields:
+                key = _FIELD2ATTR[field_name]
+                if key != 'project_url':
+                    data[key] = self[field_name]
+                else:
+                    data[key] = [','.join(u) for u in self[field_name]]
+
+        return data
+
+    def add_requirements(self, requirements):
+        if self['Metadata-Version'] == '1.1':
+            # we can't have 1.1 metadata *and* Setuptools requires
+            for field in ('Obsoletes', 'Requires', 'Provides'):
+                if field in self:
+                    del self[field]
+        self['Requires-Dist'] += requirements
+
+    # Mapping API
+    # TODO could add iter* variants
+
+    def keys(self):
+        return list(_version2fieldlist(self['Metadata-Version']))
+
+    def __iter__(self):
+        for key in self.keys():
+            yield key
+
+    def values(self):
+        return [self[key] for key in self.keys()]
+
+    def items(self):
+        return [(key, self[key]) for key in self.keys()]
+
+    def __repr__(self):
+        return '<%s %s %s>' % (self.__class__.__name__, self.name,
+                               self.version)
+
+
+METADATA_FILENAME = 'pydist.json'
+WHEEL_METADATA_FILENAME = 'metadata.json'
+LEGACY_METADATA_FILENAME = 'METADATA'
+
+
+class Metadata(object):
+    """
+    The metadata of a release. This implementation uses 2.0 (JSON)
+    metadata where possible. If not possible, it wraps a LegacyMetadata
+    instance which handles the key-value metadata format.
+    """
+
+    METADATA_VERSION_MATCHER = re.compile(r'^\d+(\.\d+)*$')
+
+    NAME_MATCHER = re.compile('^[0-9A-Z]([0-9A-Z_.-]*[0-9A-Z])?$', re.I)
+
+    VERSION_MATCHER = PEP440_VERSION_RE
+
+    SUMMARY_MATCHER = re.compile('.{1,2047}')
+
+    METADATA_VERSION = '2.0'
+
+    GENERATOR = 'distlib (%s)' % __version__
+
+    MANDATORY_KEYS = {
+        'name': (),
+        'version': (),
+        'summary': ('legacy',),
+    }
+
+    INDEX_KEYS = ('name version license summary description author '
+                  'author_email keywords platform home_page classifiers '
+                  'download_url')
+
+    DEPENDENCY_KEYS = ('extras run_requires test_requires build_requires '
+                       'dev_requires provides meta_requires obsoleted_by '
+                       'supports_environments')
+
+    SYNTAX_VALIDATORS = {
+        'metadata_version': (METADATA_VERSION_MATCHER, ()),
+        'name': (NAME_MATCHER, ('legacy',)),
+        'version': (VERSION_MATCHER, ('legacy',)),
+        'summary': (SUMMARY_MATCHER, ('legacy',)),
+    }
+
+    __slots__ = ('_legacy', '_data', 'scheme')
+
+    def __init__(self, path=None, fileobj=None, mapping=None,
+                 scheme='default'):
+        if [path, fileobj, mapping].count(None) < 2:
+            raise TypeError('path, fileobj and mapping are exclusive')
+        self._legacy = None
+        self._data = None
+        self.scheme = scheme
+        #import pdb; pdb.set_trace()
+        if mapping is not None:
+            try:
+                self._validate_mapping(mapping, scheme)
+                self._data = mapping
+            except MetadataUnrecognizedVersionError:
+                self._legacy = LegacyMetadata(mapping=mapping, scheme=scheme)
+                self.validate()
+        else:
+            data = None
+            if path:
+                with open(path, 'rb') as f:
+                    data = f.read()
+            elif fileobj:
+                data = fileobj.read()
+            if data is None:
+                # Initialised with no args - to be added
+                self._data = {
+                    'metadata_version': self.METADATA_VERSION,
+                    'generator': self.GENERATOR,
+                }
+            else:
+                if not isinstance(data, text_type):
+                    data = data.decode('utf-8')
+                try:
+                    self._data = json.loads(data)
+                    self._validate_mapping(self._data, scheme)
+                except ValueError:
+                    # Note: MetadataUnrecognizedVersionError does not
+                    # inherit from ValueError (it's a DistlibException,
+                    # which should not inherit from ValueError).
+                    # The ValueError comes from the json.load - if that
+                    # succeeds and we get a validation error, we want
+                    # that to propagate
+                    self._legacy = LegacyMetadata(fileobj=StringIO(data),
+                                                  scheme=scheme)
+                    self.validate()
+
+    common_keys = set(('name', 'version', 'license', 'keywords', 'summary'))
+
+    none_list = (None, list)
+    none_dict = (None, dict)
+
+    mapped_keys = {
+        'run_requires': ('Requires-Dist', list),
+        'build_requires': ('Setup-Requires-Dist', list),
+        'dev_requires': none_list,
+        'test_requires': none_list,
+        'meta_requires': none_list,
+        'extras': ('Provides-Extra', list),
+        'modules': none_list,
+        'namespaces': none_list,
+        'exports': none_dict,
+        'commands': none_dict,
+        'classifiers': ('Classifier', list),
+        'source_url': ('Download-URL', None),
+        'metadata_version': ('Metadata-Version', None),
+    }
+
+    del none_list, none_dict
+
+    def __getattribute__(self, key):
+        common = object.__getattribute__(self, 'common_keys')
+        mapped = object.__getattribute__(self, 'mapped_keys')
+        if key in mapped:
+            lk, maker = mapped[key]
+            if self._legacy:
+                if lk is None:
+                    result = None if maker is None else maker()
+                else:
+                    result = self._legacy.get(lk)
+            else:
+                value = None if maker is None else maker()
+                if key not in ('commands', 'exports', 'modules', 'namespaces',
+                               'classifiers'):
+                    result = self._data.get(key, value)
+                else:
+                    # special cases for PEP 459
+                    sentinel = object()
+                    result = sentinel
+                    d = self._data.get('extensions')
+                    if d:
+                        if key == 'commands':
+                            result = d.get('python.commands', value)
+                        elif key == 'classifiers':
+                            d = d.get('python.details')
+                            if d:
+                                result = d.get(key, value)
+                        else:
+                            d = d.get('python.exports')
+                            if not d:
+                                d = self._data.get('python.exports')
+                            if d:
+                                result = d.get(key, value)
+                    if result is sentinel:
+                        result = value
+        elif key not in common:
+            result = object.__getattribute__(self, key)
+        elif self._legacy:
+            result = self._legacy.get(key)
+        else:
+            result = self._data.get(key)
+        return result
+
+    def _validate_value(self, key, value, scheme=None):
+        if key in self.SYNTAX_VALIDATORS:
+            pattern, exclusions = self.SYNTAX_VALIDATORS[key]
+            if (scheme or self.scheme) not in exclusions:
+                m = pattern.match(value)
+                if not m:
+                    raise MetadataInvalidError("'%s' is an invalid value for "
+                                               "the '%s' property" % (value,
+                                                                    key))
+
+    def __setattr__(self, key, value):
+        self._validate_value(key, value)
+        common = object.__getattribute__(self, 'common_keys')
+        mapped = object.__getattribute__(self, 'mapped_keys')
+        if key in mapped:
+            lk, _ = mapped[key]
+            if self._legacy:
+                if lk is None:
+                    raise NotImplementedError
+                self._legacy[lk] = value
+            elif key not in ('commands', 'exports', 'modules', 'namespaces',
+                             'classifiers'):
+                self._data[key] = value
+            else:
+                # special cases for PEP 459
+                d = self._data.setdefault('extensions', {})
+                if key == 'commands':
+                    d['python.commands'] = value
+                elif key == 'classifiers':
+                    d = d.setdefault('python.details', {})
+                    d[key] = value
+                else:
+                    d = d.setdefault('python.exports', {})
+                    d[key] = value
+        elif key not in common:
+            object.__setattr__(self, key, value)
+        else:
+            if key == 'keywords':
+                if isinstance(value, string_types):
+                    value = value.strip()
+                    if value:
+                        value = value.split()
+                    else:
+                        value = []
+            if self._legacy:
+                self._legacy[key] = value
+            else:
+                self._data[key] = value
+
+    @property
+    def name_and_version(self):
+        return _get_name_and_version(self.name, self.version, True)
+
+    @property
+    def provides(self):
+        if self._legacy:
+            result = self._legacy['Provides-Dist']
+        else:
+            result = self._data.setdefault('provides', [])
+        s = '%s (%s)' % (self.name, self.version)
+        if s not in result:
+            result.append(s)
+        return result
+
+    @provides.setter
+    def provides(self, value):
+        if self._legacy:
+            self._legacy['Provides-Dist'] = value
+        else:
+            self._data['provides'] = value
+
+    def get_requirements(self, reqts, extras=None, env=None):
+        """
+        Base method to get dependencies, given a set of extras
+        to satisfy and an optional environment context.
+        :param reqts: A list of sometimes-wanted dependencies,
+                      perhaps dependent on extras and environment.
+        :param extras: A list of optional components being requested.
+        :param env: An optional environment for marker evaluation.
+        """
+        if self._legacy:
+            result = reqts
+        else:
+            result = []
+            extras = get_extras(extras or [], self.extras)
+            for d in reqts:
+                if 'extra' not in d and 'environment' not in d:
+                    # unconditional
+                    include = True
+                else:
+                    if 'extra' not in d:
+                        # Not extra-dependent - only environment-dependent
+                        include = True
+                    else:
+                        include = d.get('extra') in extras
+                    if include:
+                        # Not excluded because of extras, check environment
+                        marker = d.get('environment')
+                        if marker:
+                            include = interpret(marker, env)
+                if include:
+                    result.extend(d['requires'])
+            for key in ('build', 'dev', 'test'):
+                e = ':%s:' % key
+                if e in extras:
+                    extras.remove(e)
+                    # A recursive call, but it should terminate since 'test'
+                    # has been removed from the extras
+                    reqts = self._data.get('%s_requires' % key, [])
+                    result.extend(self.get_requirements(reqts, extras=extras,
+                                                        env=env))
+        return result
+
+    @property
+    def dictionary(self):
+        if self._legacy:
+            return self._from_legacy()
+        return self._data
+
+    @property
+    def dependencies(self):
+        if self._legacy:
+            raise NotImplementedError
+        else:
+            return extract_by_key(self._data, self.DEPENDENCY_KEYS)
+
+    @dependencies.setter
+    def dependencies(self, value):
+        if self._legacy:
+            raise NotImplementedError
+        else:
+            self._data.update(value)
+
+    def _validate_mapping(self, mapping, scheme):
+        if mapping.get('metadata_version') != self.METADATA_VERSION:
+            raise MetadataUnrecognizedVersionError()
+        missing = []
+        for key, exclusions in self.MANDATORY_KEYS.items():
+            if key not in mapping:
+                if scheme not in exclusions:
+                    missing.append(key)
+        if missing:
+            msg = 'Missing metadata items: %s' % ', '.join(missing)
+            raise MetadataMissingError(msg)
+        for k, v in mapping.items():
+            self._validate_value(k, v, scheme)
+
+    def validate(self):
+        if self._legacy:
+            missing, warnings = self._legacy.check(True)
+            if missing or warnings:
+                logger.warning('Metadata: missing: %s, warnings: %s',
+                               missing, warnings)
+        else:
+            self._validate_mapping(self._data, self.scheme)
+
+    def todict(self):
+        if self._legacy:
+            return self._legacy.todict(True)
+        else:
+            result = extract_by_key(self._data, self.INDEX_KEYS)
+            return result
+
+    def _from_legacy(self):
+        assert self._legacy and not self._data
+        result = {
+            'metadata_version': self.METADATA_VERSION,
+            'generator': self.GENERATOR,
+        }
+        lmd = self._legacy.todict(True)     # skip missing ones
+        for k in ('name', 'version', 'license', 'summary', 'description',
+                  'classifier'):
+            if k in lmd:
+                if k == 'classifier':
+                    nk = 'classifiers'
+                else:
+                    nk = k
+                result[nk] = lmd[k]
+        kw = lmd.get('Keywords', [])
+        if kw == ['']:
+            kw = []
+        result['keywords'] = kw
+        keys = (('requires_dist', 'run_requires'),
+                ('setup_requires_dist', 'build_requires'))
+        for ok, nk in keys:
+            if ok in lmd and lmd[ok]:
+                result[nk] = [{'requires': lmd[ok]}]
+        result['provides'] = self.provides
+        author = {}
+        maintainer = {}
+        return result
+
+    LEGACY_MAPPING = {
+        'name': 'Name',
+        'version': 'Version',
+        ('extensions', 'python.details', 'license'): 'License',
+        'summary': 'Summary',
+        'description': 'Description',
+        ('extensions', 'python.project', 'project_urls', 'Home'): 'Home-page',
+        ('extensions', 'python.project', 'contacts', 0, 'name'): 'Author',
+        ('extensions', 'python.project', 'contacts', 0, 'email'): 'Author-email',
+        'source_url': 'Download-URL',
+        ('extensions', 'python.details', 'classifiers'): 'Classifier',
+    }
+
+    def _to_legacy(self):
+        def process_entries(entries):
+            reqts = set()
+            for e in entries:
+                extra = e.get('extra')
+                env = e.get('environment')
+                rlist = e['requires']
+                for r in rlist:
+                    if not env and not extra:
+                        reqts.add(r)
+                    else:
+                        marker = ''
+                        if extra:
+                            marker = 'extra == "%s"' % extra
+                        if env:
+                            if marker:
+                                marker = '(%s) and %s' % (env, marker)
+                            else:
+                                marker = env
+                        reqts.add(';'.join((r, marker)))
+            return reqts
+
+        assert self._data and not self._legacy
+        result = LegacyMetadata()
+        nmd = self._data
+        # import pdb; pdb.set_trace()
+        for nk, ok in self.LEGACY_MAPPING.items():
+            if not isinstance(nk, tuple):
+                if nk in nmd:
+                    result[ok] = nmd[nk]
+            else:
+                d = nmd
+                found = True
+                for k in nk:
+                    try:
+                        d = d[k]
+                    except (KeyError, IndexError):
+                        found = False
+                        break
+                if found:
+                    result[ok] = d
+        r1 = process_entries(self.run_requires + self.meta_requires)
+        r2 = process_entries(self.build_requires + self.dev_requires)
+        if self.extras:
+            result['Provides-Extra'] = sorted(self.extras)
+        result['Requires-Dist'] = sorted(r1)
+        result['Setup-Requires-Dist'] = sorted(r2)
+        # TODO: any other fields wanted
+        return result
+
+    def write(self, path=None, fileobj=None, legacy=False, skip_unknown=True):
+        if [path, fileobj].count(None) != 1:
+            raise ValueError('Exactly one of path and fileobj is needed')
+        self.validate()
+        if legacy:
+            if self._legacy:
+                legacy_md = self._legacy
+            else:
+                legacy_md = self._to_legacy()
+            if path:
+                legacy_md.write(path, skip_unknown=skip_unknown)
+            else:
+                legacy_md.write_file(fileobj, skip_unknown=skip_unknown)
+        else:
+            if self._legacy:
+                d = self._from_legacy()
+            else:
+                d = self._data
+            if fileobj:
+                json.dump(d, fileobj, ensure_ascii=True, indent=2,
+                          sort_keys=True)
+            else:
+                with codecs.open(path, 'w', 'utf-8') as f:
+                    json.dump(d, f, ensure_ascii=True, indent=2,
+                              sort_keys=True)
+
+    def add_requirements(self, requirements):
+        if self._legacy:
+            self._legacy.add_requirements(requirements)
+        else:
+            run_requires = self._data.setdefault('run_requires', [])
+            always = None
+            for entry in run_requires:
+                if 'environment' not in entry and 'extra' not in entry:
+                    always = entry
+                    break
+            if always is None:
+                always = { 'requires': requirements }
+                run_requires.insert(0, always)
+            else:
+                rset = set(always['requires']) | set(requirements)
+                always['requires'] = sorted(rset)
+
+    def __repr__(self):
+        name = self.name or '(no name)'
+        version = self.version or 'no version'
+        return '<%s %s %s (%s)>' % (self.__class__.__name__,
+                                    self.metadata_version, name, version)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/resources.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/resources.py
new file mode 100644
index 0000000..1884016
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/resources.py
@@ -0,0 +1,355 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013-2017 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+from __future__ import unicode_literals
+
+import bisect
+import io
+import logging
+import os
+import pkgutil
+import shutil
+import sys
+import types
+import zipimport
+
+from . import DistlibException
+from .util import cached_property, get_cache_base, path_to_cache_dir, Cache
+
+logger = logging.getLogger(__name__)
+
+
+cache = None    # created when needed
+
+
+class ResourceCache(Cache):
+    def __init__(self, base=None):
+        if base is None:
+            # Use native string to avoid issues on 2.x: see Python #20140.
+            base = os.path.join(get_cache_base(), str('resource-cache'))
+        super(ResourceCache, self).__init__(base)
+
+    def is_stale(self, resource, path):
+        """
+        Is the cache stale for the given resource?
+
+        :param resource: The :class:`Resource` being cached.
+        :param path: The path of the resource in the cache.
+        :return: True if the cache is stale.
+        """
+        # Cache invalidation is a hard problem :-)
+        return True
+
+    def get(self, resource):
+        """
+        Get a resource into the cache,
+
+        :param resource: A :class:`Resource` instance.
+        :return: The pathname of the resource in the cache.
+        """
+        prefix, path = resource.finder.get_cache_info(resource)
+        if prefix is None:
+            result = path
+        else:
+            result = os.path.join(self.base, self.prefix_to_dir(prefix), path)
+            dirname = os.path.dirname(result)
+            if not os.path.isdir(dirname):
+                os.makedirs(dirname)
+            if not os.path.exists(result):
+                stale = True
+            else:
+                stale = self.is_stale(resource, path)
+            if stale:
+                # write the bytes of the resource to the cache location
+                with open(result, 'wb') as f:
+                    f.write(resource.bytes)
+        return result
+
+
+class ResourceBase(object):
+    def __init__(self, finder, name):
+        self.finder = finder
+        self.name = name
+
+
+class Resource(ResourceBase):
+    """
+    A class representing an in-package resource, such as a data file. This is
+    not normally instantiated by user code, but rather by a
+    :class:`ResourceFinder` which manages the resource.
+    """
+    is_container = False        # Backwards compatibility
+
+    def as_stream(self):
+        """
+        Get the resource as a stream.
+
+        This is not a property to make it obvious that it returns a new stream
+        each time.
+        """
+        return self.finder.get_stream(self)
+
+    @cached_property
+    def file_path(self):
+        global cache
+        if cache is None:
+            cache = ResourceCache()
+        return cache.get(self)
+
+    @cached_property
+    def bytes(self):
+        return self.finder.get_bytes(self)
+
+    @cached_property
+    def size(self):
+        return self.finder.get_size(self)
+
+
+class ResourceContainer(ResourceBase):
+    is_container = True     # Backwards compatibility
+
+    @cached_property
+    def resources(self):
+        return self.finder.get_resources(self)
+
+
+class ResourceFinder(object):
+    """
+    Resource finder for file system resources.
+    """
+
+    if sys.platform.startswith('java'):
+        skipped_extensions = ('.pyc', '.pyo', '.class')
+    else:
+        skipped_extensions = ('.pyc', '.pyo')
+
+    def __init__(self, module):
+        self.module = module
+        self.loader = getattr(module, '__loader__', None)
+        self.base = os.path.dirname(getattr(module, '__file__', ''))
+
+    def _adjust_path(self, path):
+        return os.path.realpath(path)
+
+    def _make_path(self, resource_name):
+        # Issue #50: need to preserve type of path on Python 2.x
+        # like os.path._get_sep
+        if isinstance(resource_name, bytes):    # should only happen on 2.x
+            sep = b'/'
+        else:
+            sep = '/'
+        parts = resource_name.split(sep)
+        parts.insert(0, self.base)
+        result = os.path.join(*parts)
+        return self._adjust_path(result)
+
+    def _find(self, path):
+        return os.path.exists(path)
+
+    def get_cache_info(self, resource):
+        return None, resource.path
+
+    def find(self, resource_name):
+        path = self._make_path(resource_name)
+        if not self._find(path):
+            result = None
+        else:
+            if self._is_directory(path):
+                result = ResourceContainer(self, resource_name)
+            else:
+                result = Resource(self, resource_name)
+            result.path = path
+        return result
+
+    def get_stream(self, resource):
+        return open(resource.path, 'rb')
+
+    def get_bytes(self, resource):
+        with open(resource.path, 'rb') as f:
+            return f.read()
+
+    def get_size(self, resource):
+        return os.path.getsize(resource.path)
+
+    def get_resources(self, resource):
+        def allowed(f):
+            return (f != '__pycache__' and not
+                    f.endswith(self.skipped_extensions))
+        return set([f for f in os.listdir(resource.path) if allowed(f)])
+
+    def is_container(self, resource):
+        return self._is_directory(resource.path)
+
+    _is_directory = staticmethod(os.path.isdir)
+
+    def iterator(self, resource_name):
+        resource = self.find(resource_name)
+        if resource is not None:
+            todo = [resource]
+            while todo:
+                resource = todo.pop(0)
+                yield resource
+                if resource.is_container:
+                    rname = resource.name
+                    for name in resource.resources:
+                        if not rname:
+                            new_name = name
+                        else:
+                            new_name = '/'.join([rname, name])
+                        child = self.find(new_name)
+                        if child.is_container:
+                            todo.append(child)
+                        else:
+                            yield child
+
+
+class ZipResourceFinder(ResourceFinder):
+    """
+    Resource finder for resources in .zip files.
+    """
+    def __init__(self, module):
+        super(ZipResourceFinder, self).__init__(module)
+        archive = self.loader.archive
+        self.prefix_len = 1 + len(archive)
+        # PyPy doesn't have a _files attr on zipimporter, and you can't set one
+        if hasattr(self.loader, '_files'):
+            self._files = self.loader._files
+        else:
+            self._files = zipimport._zip_directory_cache[archive]
+        self.index = sorted(self._files)
+
+    def _adjust_path(self, path):
+        return path
+
+    def _find(self, path):
+        path = path[self.prefix_len:]
+        if path in self._files:
+            result = True
+        else:
+            if path and path[-1] != os.sep:
+                path = path + os.sep
+            i = bisect.bisect(self.index, path)
+            try:
+                result = self.index[i].startswith(path)
+            except IndexError:
+                result = False
+        if not result:
+            logger.debug('_find failed: %r %r', path, self.loader.prefix)
+        else:
+            logger.debug('_find worked: %r %r', path, self.loader.prefix)
+        return result
+
+    def get_cache_info(self, resource):
+        prefix = self.loader.archive
+        path = resource.path[1 + len(prefix):]
+        return prefix, path
+
+    def get_bytes(self, resource):
+        return self.loader.get_data(resource.path)
+
+    def get_stream(self, resource):
+        return io.BytesIO(self.get_bytes(resource))
+
+    def get_size(self, resource):
+        path = resource.path[self.prefix_len:]
+        return self._files[path][3]
+
+    def get_resources(self, resource):
+        path = resource.path[self.prefix_len:]
+        if path and path[-1] != os.sep:
+            path += os.sep
+        plen = len(path)
+        result = set()
+        i = bisect.bisect(self.index, path)
+        while i < len(self.index):
+            if not self.index[i].startswith(path):
+                break
+            s = self.index[i][plen:]
+            result.add(s.split(os.sep, 1)[0])   # only immediate children
+            i += 1
+        return result
+
+    def _is_directory(self, path):
+        path = path[self.prefix_len:]
+        if path and path[-1] != os.sep:
+            path += os.sep
+        i = bisect.bisect(self.index, path)
+        try:
+            result = self.index[i].startswith(path)
+        except IndexError:
+            result = False
+        return result
+
+_finder_registry = {
+    type(None): ResourceFinder,
+    zipimport.zipimporter: ZipResourceFinder
+}
+
+try:
+    # In Python 3.6, _frozen_importlib -> _frozen_importlib_external
+    try:
+        import _frozen_importlib_external as _fi
+    except ImportError:
+        import _frozen_importlib as _fi
+    _finder_registry[_fi.SourceFileLoader] = ResourceFinder
+    _finder_registry[_fi.FileFinder] = ResourceFinder
+    del _fi
+except (ImportError, AttributeError):
+    pass
+
+
+def register_finder(loader, finder_maker):
+    _finder_registry[type(loader)] = finder_maker
+
+_finder_cache = {}
+
+
+def finder(package):
+    """
+    Return a resource finder for a package.
+    :param package: The name of the package.
+    :return: A :class:`ResourceFinder` instance for the package.
+    """
+    if package in _finder_cache:
+        result = _finder_cache[package]
+    else:
+        if package not in sys.modules:
+            __import__(package)
+        module = sys.modules[package]
+        path = getattr(module, '__path__', None)
+        if path is None:
+            raise DistlibException('You cannot get a finder for a module, '
+                                   'only for a package')
+        loader = getattr(module, '__loader__', None)
+        finder_maker = _finder_registry.get(type(loader))
+        if finder_maker is None:
+            raise DistlibException('Unable to locate finder for %r' % package)
+        result = finder_maker(module)
+        _finder_cache[package] = result
+    return result
+
+
+_dummy_module = types.ModuleType(str('__dummy__'))
+
+
+def finder_for_path(path):
+    """
+    Return a resource finder for a path, which should represent a container.
+
+    :param path: The path.
+    :return: A :class:`ResourceFinder` instance for the path.
+    """
+    result = None
+    # calls any path hooks, gets importer into cache
+    pkgutil.get_importer(path)
+    loader = sys.path_importer_cache.get(path)
+    finder = _finder_registry.get(type(loader))
+    if finder:
+        module = _dummy_module
+        module.__file__ = os.path.join(path, '')
+        module.__loader__ = loader
+        result = finder(module)
+    return result
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/scripts.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/scripts.py
new file mode 100644
index 0000000..03f8f21
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/scripts.py
@@ -0,0 +1,419 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013-2015 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+from io import BytesIO
+import logging
+import os
+import re
+import struct
+import sys
+
+from .compat import sysconfig, detect_encoding, ZipFile
+from .resources import finder
+from .util import (FileOperator, get_export_entry, convert_path,
+                   get_executable, in_venv)
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_MANIFEST = '''
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+ <assemblyIdentity version="1.0.0.0"
+ processorArchitecture="X86"
+ name="%s"
+ type="win32"/>
+
+ <!-- Identify the application security requirements. -->
+ <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+ <security>
+ <requestedPrivileges>
+ <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
+ </requestedPrivileges>
+ </security>
+ </trustInfo>
+</assembly>'''.strip()
+
+# check if Python is called on the first line with this expression
+FIRST_LINE_RE = re.compile(b'^#!.*pythonw?[0-9.]*([ \t].*)?$')
+SCRIPT_TEMPLATE = r'''# -*- coding: utf-8 -*-
+import re
+import sys
+from %(module)s import %(import_name)s
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(%(func)s())
+'''
+
+
+def enquote_executable(executable):
+    if ' ' in executable:
+        # make sure we quote only the executable in case of env
+        # for example /usr/bin/env "/dir with spaces/bin/jython"
+        # instead of "/usr/bin/env /dir with spaces/bin/jython"
+        # otherwise whole
+        if executable.startswith('/usr/bin/env '):
+            env, _executable = executable.split(' ', 1)
+            if ' ' in _executable and not _executable.startswith('"'):
+                executable = '%s "%s"' % (env, _executable)
+        else:
+            if not executable.startswith('"'):
+                executable = '"%s"' % executable
+    return executable
+
+# Keep the old name around (for now), as there is at least one project using it!
+_enquote_executable = enquote_executable
+
+class ScriptMaker(object):
+    """
+    A class to copy or create scripts from source scripts or callable
+    specifications.
+    """
+    script_template = SCRIPT_TEMPLATE
+
+    executable = None  # for shebangs
+
+    def __init__(self, source_dir, target_dir, add_launchers=True,
+                 dry_run=False, fileop=None):
+        self.source_dir = source_dir
+        self.target_dir = target_dir
+        self.add_launchers = add_launchers
+        self.force = False
+        self.clobber = False
+        # It only makes sense to set mode bits on POSIX.
+        self.set_mode = (os.name == 'posix') or (os.name == 'java' and
+                                                 os._name == 'posix')
+        self.variants = set(('', 'X.Y'))
+        self._fileop = fileop or FileOperator(dry_run)
+
+        self._is_nt = os.name == 'nt' or (
+            os.name == 'java' and os._name == 'nt')
+        self.version_info = sys.version_info
+
+    def _get_alternate_executable(self, executable, options):
+        if options.get('gui', False) and self._is_nt:  # pragma: no cover
+            dn, fn = os.path.split(executable)
+            fn = fn.replace('python', 'pythonw')
+            executable = os.path.join(dn, fn)
+        return executable
+
+    if sys.platform.startswith('java'):  # pragma: no cover
+        def _is_shell(self, executable):
+            """
+            Determine if the specified executable is a script
+            (contains a #! line)
+            """
+            try:
+                with open(executable) as fp:
+                    return fp.read(2) == '#!'
+            except (OSError, IOError):
+                logger.warning('Failed to open %s', executable)
+                return False
+
+        def _fix_jython_executable(self, executable):
+            if self._is_shell(executable):
+                # Workaround for Jython is not needed on Linux systems.
+                import java
+
+                if java.lang.System.getProperty('os.name') == 'Linux':
+                    return executable
+            elif executable.lower().endswith('jython.exe'):
+                # Use wrapper exe for Jython on Windows
+                return executable
+            return '/usr/bin/env %s' % executable
+
+    def _build_shebang(self, executable, post_interp):
+        """
+        Build a shebang line. In the simple case (on Windows, or a shebang line
+        which is not too long or contains spaces) use a simple formulation for
+        the shebang. Otherwise, use /bin/sh as the executable, with a contrived
+        shebang which allows the script to run either under Python or sh, using
+        suitable quoting. Thanks to Harald Nordgren for his input.
+
+        See also: http://www.in-ulm.de/~mascheck/various/shebang/#length
+                  https://hg.mozilla.org/mozilla-central/file/tip/mach
+        """
+        if os.name != 'posix':
+            simple_shebang = True
+        else:
+            # Add 3 for '#!' prefix and newline suffix.
+            shebang_length = len(executable) + len(post_interp) + 3
+            if sys.platform == 'darwin':
+                max_shebang_length = 512
+            else:
+                max_shebang_length = 127
+            simple_shebang = ((b' ' not in executable) and
+                              (shebang_length <= max_shebang_length))
+
+        if simple_shebang:
+            result = b'#!' + executable + post_interp + b'\n'
+        else:
+            result = b'#!/bin/sh\n'
+            result += b"'''exec' " + executable + post_interp + b' "$0" "$@"\n'
+            result += b"' '''"
+        return result
+
+    def _get_shebang(self, encoding, post_interp=b'', options=None):
+        enquote = True
+        if self.executable:
+            executable = self.executable
+            enquote = False     # assume this will be taken care of
+        elif not sysconfig.is_python_build():
+            executable = get_executable()
+        elif in_venv():  # pragma: no cover
+            executable = os.path.join(sysconfig.get_path('scripts'),
+                            'python%s' % sysconfig.get_config_var('EXE'))
+        else:  # pragma: no cover
+            executable = os.path.join(
+                sysconfig.get_config_var('BINDIR'),
+               'python%s%s' % (sysconfig.get_config_var('VERSION'),
+                               sysconfig.get_config_var('EXE')))
+        if options:
+            executable = self._get_alternate_executable(executable, options)
+
+        if sys.platform.startswith('java'):  # pragma: no cover
+            executable = self._fix_jython_executable(executable)
+
+        # Normalise case for Windows - COMMENTED OUT
+        # executable = os.path.normcase(executable)
+        # N.B. The normalising operation above has been commented out: See
+        # issue #124. Although paths in Windows are generally case-insensitive,
+        # they aren't always. For example, a path containing a ẞ (which is a
+        # LATIN CAPITAL LETTER SHARP S - U+1E9E) is normcased to ß (which is a
+        # LATIN SMALL LETTER SHARP S' - U+00DF). The two are not considered by
+        # Windows as equivalent in path names.
+
+        # If the user didn't specify an executable, it may be necessary to
+        # cater for executable paths with spaces (not uncommon on Windows)
+        if enquote:
+            executable = enquote_executable(executable)
+        # Issue #51: don't use fsencode, since we later try to
+        # check that the shebang is decodable using utf-8.
+        executable = executable.encode('utf-8')
+        # in case of IronPython, play safe and enable frames support
+        if (sys.platform == 'cli' and '-X:Frames' not in post_interp
+            and '-X:FullFrames' not in post_interp):  # pragma: no cover
+            post_interp += b' -X:Frames'
+        shebang = self._build_shebang(executable, post_interp)
+        # Python parser starts to read a script using UTF-8 until
+        # it gets a #coding:xxx cookie. The shebang has to be the
+        # first line of a file, the #coding:xxx cookie cannot be
+        # written before. So the shebang has to be decodable from
+        # UTF-8.
+        try:
+            shebang.decode('utf-8')
+        except UnicodeDecodeError:  # pragma: no cover
+            raise ValueError(
+                'The shebang (%r) is not decodable from utf-8' % shebang)
+        # If the script is encoded to a custom encoding (use a
+        # #coding:xxx cookie), the shebang has to be decodable from
+        # the script encoding too.
+        if encoding != 'utf-8':
+            try:
+                shebang.decode(encoding)
+            except UnicodeDecodeError:  # pragma: no cover
+                raise ValueError(
+                    'The shebang (%r) is not decodable '
+                    'from the script encoding (%r)' % (shebang, encoding))
+        return shebang
+
+    def _get_script_text(self, entry):
+        return self.script_template % dict(module=entry.prefix,
+                                           import_name=entry.suffix.split('.')[0],
+                                           func=entry.suffix)
+
+    manifest = _DEFAULT_MANIFEST
+
+    def get_manifest(self, exename):
+        base = os.path.basename(exename)
+        return self.manifest % base
+
+    def _write_script(self, names, shebang, script_bytes, filenames, ext):
+        use_launcher = self.add_launchers and self._is_nt
+        linesep = os.linesep.encode('utf-8')
+        if not shebang.endswith(linesep):
+            shebang += linesep
+        if not use_launcher:
+            script_bytes = shebang + script_bytes
+        else:  # pragma: no cover
+            if ext == 'py':
+                launcher = self._get_launcher('t')
+            else:
+                launcher = self._get_launcher('w')
+            stream = BytesIO()
+            with ZipFile(stream, 'w') as zf:
+                zf.writestr('__main__.py', script_bytes)
+            zip_data = stream.getvalue()
+            script_bytes = launcher + shebang + zip_data
+        for name in names:
+            outname = os.path.join(self.target_dir, name)
+            if use_launcher:  # pragma: no cover
+                n, e = os.path.splitext(outname)
+                if e.startswith('.py'):
+                    outname = n
+                outname = '%s.exe' % outname
+                try:
+                    self._fileop.write_binary_file(outname, script_bytes)
+                except Exception:
+                    # Failed writing an executable - it might be in use.
+                    logger.warning('Failed to write executable - trying to '
+                                   'use .deleteme logic')
+                    dfname = '%s.deleteme' % outname
+                    if os.path.exists(dfname):
+                        os.remove(dfname)       # Not allowed to fail here
+                    os.rename(outname, dfname)  # nor here
+                    self._fileop.write_binary_file(outname, script_bytes)
+                    logger.debug('Able to replace executable using '
+                                 '.deleteme logic')
+                    try:
+                        os.remove(dfname)
+                    except Exception:
+                        pass    # still in use - ignore error
+            else:
+                if self._is_nt and not outname.endswith('.' + ext):  # pragma: no cover
+                    outname = '%s.%s' % (outname, ext)
+                if os.path.exists(outname) and not self.clobber:
+                    logger.warning('Skipping existing file %s', outname)
+                    continue
+                self._fileop.write_binary_file(outname, script_bytes)
+                if self.set_mode:
+                    self._fileop.set_executable_mode([outname])
+            filenames.append(outname)
+
+    def _make_script(self, entry, filenames, options=None):
+        post_interp = b''
+        if options:
+            args = options.get('interpreter_args', [])
+            if args:
+                args = ' %s' % ' '.join(args)
+                post_interp = args.encode('utf-8')
+        shebang = self._get_shebang('utf-8', post_interp, options=options)
+        script = self._get_script_text(entry).encode('utf-8')
+        name = entry.name
+        scriptnames = set()
+        if '' in self.variants:
+            scriptnames.add(name)
+        if 'X' in self.variants:
+            scriptnames.add('%s%s' % (name, self.version_info[0]))
+        if 'X.Y' in self.variants:
+            scriptnames.add('%s-%s.%s' % (name, self.version_info[0],
+                                          self.version_info[1]))
+        if options and options.get('gui', False):
+            ext = 'pyw'
+        else:
+            ext = 'py'
+        self._write_script(scriptnames, shebang, script, filenames, ext)
+
+    def _copy_script(self, script, filenames):
+        adjust = False
+        script = os.path.join(self.source_dir, convert_path(script))
+        outname = os.path.join(self.target_dir, os.path.basename(script))
+        if not self.force and not self._fileop.newer(script, outname):
+            logger.debug('not copying %s (up-to-date)', script)
+            return
+
+        # Always open the file, but ignore failures in dry-run mode --
+        # that way, we'll get accurate feedback if we can read the
+        # script.
+        try:
+            f = open(script, 'rb')
+        except IOError:  # pragma: no cover
+            if not self.dry_run:
+                raise
+            f = None
+        else:
+            first_line = f.readline()
+            if not first_line:  # pragma: no cover
+                logger.warning('%s: %s is an empty file (skipping)',
+                               self.get_command_name(),  script)
+                return
+
+            match = FIRST_LINE_RE.match(first_line.replace(b'\r\n', b'\n'))
+            if match:
+                adjust = True
+                post_interp = match.group(1) or b''
+
+        if not adjust:
+            if f:
+                f.close()
+            self._fileop.copy_file(script, outname)
+            if self.set_mode:
+                self._fileop.set_executable_mode([outname])
+            filenames.append(outname)
+        else:
+            logger.info('copying and adjusting %s -> %s', script,
+                        self.target_dir)
+            if not self._fileop.dry_run:
+                encoding, lines = detect_encoding(f.readline)
+                f.seek(0)
+                shebang = self._get_shebang(encoding, post_interp)
+                if b'pythonw' in first_line:  # pragma: no cover
+                    ext = 'pyw'
+                else:
+                    ext = 'py'
+                n = os.path.basename(outname)
+                self._write_script([n], shebang, f.read(), filenames, ext)
+            if f:
+                f.close()
+
+    @property
+    def dry_run(self):
+        return self._fileop.dry_run
+
+    @dry_run.setter
+    def dry_run(self, value):
+        self._fileop.dry_run = value
+
+    if os.name == 'nt' or (os.name == 'java' and os._name == 'nt'):  # pragma: no cover
+        # Executable launcher support.
+        # Launchers are from https://bitbucket.org/vinay.sajip/simple_launcher/
+
+        def _get_launcher(self, kind):
+            if struct.calcsize('P') == 8:   # 64-bit
+                bits = '64'
+            else:
+                bits = '32'
+            name = '%s%s.exe' % (kind, bits)
+            # Issue 31: don't hardcode an absolute package name, but
+            # determine it relative to the current package
+            distlib_package = __name__.rsplit('.', 1)[0]
+            resource = finder(distlib_package).find(name)
+            if not resource:
+                msg = ('Unable to find resource %s in package %s' % (name,
+                       distlib_package))
+                raise ValueError(msg)
+            return resource.bytes
+
+    # Public API follows
+
+    def make(self, specification, options=None):
+        """
+        Make a script.
+
+        :param specification: The specification, which is either a valid export
+                              entry specification (to make a script from a
+                              callable) or a filename (to make a script by
+                              copying from a source location).
+        :param options: A dictionary of options controlling script generation.
+        :return: A list of all absolute pathnames written to.
+        """
+        filenames = []
+        entry = get_export_entry(specification)
+        if entry is None:
+            self._copy_script(specification, filenames)
+        else:
+            self._make_script(entry, filenames, options=options)
+        return filenames
+
+    def make_multiple(self, specifications, options=None):
+        """
+        Take a list of specifications and make scripts from them,
+        :param specifications: A list of specifications.
+        :return: A list of all absolute pathnames written to,
+        """
+        filenames = []
+        for specification in specifications:
+            filenames.extend(self.make(specification, options))
+        return filenames
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/t32.exe b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/t32.exe
new file mode 100644
index 0000000..8932a18
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/t32.exe differ
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/t64.exe b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/t64.exe
new file mode 100644
index 0000000..325b805
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/t64.exe differ
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/util.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/util.py
new file mode 100644
index 0000000..01324ea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/util.py
@@ -0,0 +1,1761 @@
+#
+# Copyright (C) 2012-2017 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+import codecs
+from collections import deque
+import contextlib
+import csv
+from glob import iglob as std_iglob
+import io
+import json
+import logging
+import os
+import py_compile
+import re
+import socket
+try:
+    import ssl
+except ImportError:  # pragma: no cover
+    ssl = None
+import subprocess
+import sys
+import tarfile
+import tempfile
+import textwrap
+
+try:
+    import threading
+except ImportError:  # pragma: no cover
+    import dummy_threading as threading
+import time
+
+from . import DistlibException
+from .compat import (string_types, text_type, shutil, raw_input, StringIO,
+                     cache_from_source, urlopen, urljoin, httplib, xmlrpclib,
+                     splittype, HTTPHandler, BaseConfigurator, valid_ident,
+                     Container, configparser, URLError, ZipFile, fsdecode,
+                     unquote, urlparse)
+
+logger = logging.getLogger(__name__)
+
+#
+# Requirement parsing code as per PEP 508
+#
+
+IDENTIFIER = re.compile(r'^([\w\.-]+)\s*')
+VERSION_IDENTIFIER = re.compile(r'^([\w\.*+-]+)\s*')
+COMPARE_OP = re.compile(r'^(<=?|>=?|={2,3}|[~!]=)\s*')
+MARKER_OP = re.compile(r'^((<=?)|(>=?)|={2,3}|[~!]=|in|not\s+in)\s*')
+OR = re.compile(r'^or\b\s*')
+AND = re.compile(r'^and\b\s*')
+NON_SPACE = re.compile(r'(\S+)\s*')
+STRING_CHUNK = re.compile(r'([\s\w\.{}()*+#:;,/?!~`@$%^&=|<>\[\]-]+)')
+
+
+def parse_marker(marker_string):
+    """
+    Parse a marker string and return a dictionary containing a marker expression.
+
+    The dictionary will contain keys "op", "lhs" and "rhs" for non-terminals in
+    the expression grammar, or strings. A string contained in quotes is to be
+    interpreted as a literal string, and a string not contained in quotes is a
+    variable (such as os_name).
+    """
+    def marker_var(remaining):
+        # either identifier, or literal string
+        m = IDENTIFIER.match(remaining)
+        if m:
+            result = m.groups()[0]
+            remaining = remaining[m.end():]
+        elif not remaining:
+            raise SyntaxError('unexpected end of input')
+        else:
+            q = remaining[0]
+            if q not in '\'"':
+                raise SyntaxError('invalid expression: %s' % remaining)
+            oq = '\'"'.replace(q, '')
+            remaining = remaining[1:]
+            parts = [q]
+            while remaining:
+                # either a string chunk, or oq, or q to terminate
+                if remaining[0] == q:
+                    break
+                elif remaining[0] == oq:
+                    parts.append(oq)
+                    remaining = remaining[1:]
+                else:
+                    m = STRING_CHUNK.match(remaining)
+                    if not m:
+                        raise SyntaxError('error in string literal: %s' % remaining)
+                    parts.append(m.groups()[0])
+                    remaining = remaining[m.end():]
+            else:
+                s = ''.join(parts)
+                raise SyntaxError('unterminated string: %s' % s)
+            parts.append(q)
+            result = ''.join(parts)
+            remaining = remaining[1:].lstrip() # skip past closing quote
+        return result, remaining
+
+    def marker_expr(remaining):
+        if remaining and remaining[0] == '(':
+            result, remaining = marker(remaining[1:].lstrip())
+            if remaining[0] != ')':
+                raise SyntaxError('unterminated parenthesis: %s' % remaining)
+            remaining = remaining[1:].lstrip()
+        else:
+            lhs, remaining = marker_var(remaining)
+            while remaining:
+                m = MARKER_OP.match(remaining)
+                if not m:
+                    break
+                op = m.groups()[0]
+                remaining = remaining[m.end():]
+                rhs, remaining = marker_var(remaining)
+                lhs = {'op': op, 'lhs': lhs, 'rhs': rhs}
+            result = lhs
+        return result, remaining
+
+    def marker_and(remaining):
+        lhs, remaining = marker_expr(remaining)
+        while remaining:
+            m = AND.match(remaining)
+            if not m:
+                break
+            remaining = remaining[m.end():]
+            rhs, remaining = marker_expr(remaining)
+            lhs = {'op': 'and', 'lhs': lhs, 'rhs': rhs}
+        return lhs, remaining
+
+    def marker(remaining):
+        lhs, remaining = marker_and(remaining)
+        while remaining:
+            m = OR.match(remaining)
+            if not m:
+                break
+            remaining = remaining[m.end():]
+            rhs, remaining = marker_and(remaining)
+            lhs = {'op': 'or', 'lhs': lhs, 'rhs': rhs}
+        return lhs, remaining
+
+    return marker(marker_string)
+
+
+def parse_requirement(req):
+    """
+    Parse a requirement passed in as a string. Return a Container
+    whose attributes contain the various parts of the requirement.
+    """
+    remaining = req.strip()
+    if not remaining or remaining.startswith('#'):
+        return None
+    m = IDENTIFIER.match(remaining)
+    if not m:
+        raise SyntaxError('name expected: %s' % remaining)
+    distname = m.groups()[0]
+    remaining = remaining[m.end():]
+    extras = mark_expr = versions = uri = None
+    if remaining and remaining[0] == '[':
+        i = remaining.find(']', 1)
+        if i < 0:
+            raise SyntaxError('unterminated extra: %s' % remaining)
+        s = remaining[1:i]
+        remaining = remaining[i + 1:].lstrip()
+        extras = []
+        while s:
+            m = IDENTIFIER.match(s)
+            if not m:
+                raise SyntaxError('malformed extra: %s' % s)
+            extras.append(m.groups()[0])
+            s = s[m.end():]
+            if not s:
+                break
+            if s[0] != ',':
+                raise SyntaxError('comma expected in extras: %s' % s)
+            s = s[1:].lstrip()
+        if not extras:
+            extras = None
+    if remaining:
+        if remaining[0] == '@':
+            # it's a URI
+            remaining = remaining[1:].lstrip()
+            m = NON_SPACE.match(remaining)
+            if not m:
+                raise SyntaxError('invalid URI: %s' % remaining)
+            uri = m.groups()[0]
+            t = urlparse(uri)
+            # there are issues with Python and URL parsing, so this test
+            # is a bit crude. See bpo-20271, bpo-23505. Python doesn't
+            # always parse invalid URLs correctly - it should raise
+            # exceptions for malformed URLs
+            if not (t.scheme and t.netloc):
+                raise SyntaxError('Invalid URL: %s' % uri)
+            remaining = remaining[m.end():].lstrip()
+        else:
+
+            def get_versions(ver_remaining):
+                """
+                Return a list of operator, version tuples if any are
+                specified, else None.
+                """
+                m = COMPARE_OP.match(ver_remaining)
+                versions = None
+                if m:
+                    versions = []
+                    while True:
+                        op = m.groups()[0]
+                        ver_remaining = ver_remaining[m.end():]
+                        m = VERSION_IDENTIFIER.match(ver_remaining)
+                        if not m:
+                            raise SyntaxError('invalid version: %s' % ver_remaining)
+                        v = m.groups()[0]
+                        versions.append((op, v))
+                        ver_remaining = ver_remaining[m.end():]
+                        if not ver_remaining or ver_remaining[0] != ',':
+                            break
+                        ver_remaining = ver_remaining[1:].lstrip()
+                        m = COMPARE_OP.match(ver_remaining)
+                        if not m:
+                            raise SyntaxError('invalid constraint: %s' % ver_remaining)
+                    if not versions:
+                        versions = None
+                return versions, ver_remaining
+
+            if remaining[0] != '(':
+                versions, remaining = get_versions(remaining)
+            else:
+                i = remaining.find(')', 1)
+                if i < 0:
+                    raise SyntaxError('unterminated parenthesis: %s' % remaining)
+                s = remaining[1:i]
+                remaining = remaining[i + 1:].lstrip()
+                # As a special diversion from PEP 508, allow a version number
+                # a.b.c in parentheses as a synonym for ~= a.b.c (because this
+                # is allowed in earlier PEPs)
+                if COMPARE_OP.match(s):
+                    versions, _ = get_versions(s)
+                else:
+                    m = VERSION_IDENTIFIER.match(s)
+                    if not m:
+                        raise SyntaxError('invalid constraint: %s' % s)
+                    v = m.groups()[0]
+                    s = s[m.end():].lstrip()
+                    if s:
+                        raise SyntaxError('invalid constraint: %s' % s)
+                    versions = [('~=', v)]
+
+    if remaining:
+        if remaining[0] != ';':
+            raise SyntaxError('invalid requirement: %s' % remaining)
+        remaining = remaining[1:].lstrip()
+
+        mark_expr, remaining = parse_marker(remaining)
+
+    if remaining and remaining[0] != '#':
+        raise SyntaxError('unexpected trailing data: %s' % remaining)
+
+    if not versions:
+        rs = distname
+    else:
+        rs = '%s %s' % (distname, ', '.join(['%s %s' % con for con in versions]))
+    return Container(name=distname, extras=extras, constraints=versions,
+                     marker=mark_expr, url=uri, requirement=rs)
+
+
+def get_resources_dests(resources_root, rules):
+    """Find destinations for resources files"""
+
+    def get_rel_path(root, path):
+        # normalizes and returns a lstripped-/-separated path
+        root = root.replace(os.path.sep, '/')
+        path = path.replace(os.path.sep, '/')
+        assert path.startswith(root)
+        return path[len(root):].lstrip('/')
+
+    destinations = {}
+    for base, suffix, dest in rules:
+        prefix = os.path.join(resources_root, base)
+        for abs_base in iglob(prefix):
+            abs_glob = os.path.join(abs_base, suffix)
+            for abs_path in iglob(abs_glob):
+                resource_file = get_rel_path(resources_root, abs_path)
+                if dest is None:  # remove the entry if it was here
+                    destinations.pop(resource_file, None)
+                else:
+                    rel_path = get_rel_path(abs_base, abs_path)
+                    rel_dest = dest.replace(os.path.sep, '/').rstrip('/')
+                    destinations[resource_file] = rel_dest + '/' + rel_path
+    return destinations
+
+
+def in_venv():
+    if hasattr(sys, 'real_prefix'):
+        # virtualenv venvs
+        result = True
+    else:
+        # PEP 405 venvs
+        result = sys.prefix != getattr(sys, 'base_prefix', sys.prefix)
+    return result
+
+
+def get_executable():
+# The __PYVENV_LAUNCHER__ dance is apparently no longer needed, as
+# changes to the stub launcher mean that sys.executable always points
+# to the stub on OS X
+#    if sys.platform == 'darwin' and ('__PYVENV_LAUNCHER__'
+#                                     in os.environ):
+#        result =  os.environ['__PYVENV_LAUNCHER__']
+#    else:
+#        result = sys.executable
+#    return result
+    result = os.path.normcase(sys.executable)
+    if not isinstance(result, text_type):
+        result = fsdecode(result)
+    return result
+
+
+def proceed(prompt, allowed_chars, error_prompt=None, default=None):
+    p = prompt
+    while True:
+        s = raw_input(p)
+        p = prompt
+        if not s and default:
+            s = default
+        if s:
+            c = s[0].lower()
+            if c in allowed_chars:
+                break
+            if error_prompt:
+                p = '%c: %s\n%s' % (c, error_prompt, prompt)
+    return c
+
+
+def extract_by_key(d, keys):
+    if isinstance(keys, string_types):
+        keys = keys.split()
+    result = {}
+    for key in keys:
+        if key in d:
+            result[key] = d[key]
+    return result
+
+def read_exports(stream):
+    if sys.version_info[0] >= 3:
+        # needs to be a text stream
+        stream = codecs.getreader('utf-8')(stream)
+    # Try to load as JSON, falling back on legacy format
+    data = stream.read()
+    stream = StringIO(data)
+    try:
+        jdata = json.load(stream)
+        result = jdata['extensions']['python.exports']['exports']
+        for group, entries in result.items():
+            for k, v in entries.items():
+                s = '%s = %s' % (k, v)
+                entry = get_export_entry(s)
+                assert entry is not None
+                entries[k] = entry
+        return result
+    except Exception:
+        stream.seek(0, 0)
+
+    def read_stream(cp, stream):
+        if hasattr(cp, 'read_file'):
+            cp.read_file(stream)
+        else:
+            cp.readfp(stream)
+
+    cp = configparser.ConfigParser()
+    try:
+        read_stream(cp, stream)
+    except configparser.MissingSectionHeaderError:
+        stream.close()
+        data = textwrap.dedent(data)
+        stream = StringIO(data)
+        read_stream(cp, stream)
+
+    result = {}
+    for key in cp.sections():
+        result[key] = entries = {}
+        for name, value in cp.items(key):
+            s = '%s = %s' % (name, value)
+            entry = get_export_entry(s)
+            assert entry is not None
+            #entry.dist = self
+            entries[name] = entry
+    return result
+
+
+def write_exports(exports, stream):
+    if sys.version_info[0] >= 3:
+        # needs to be a text stream
+        stream = codecs.getwriter('utf-8')(stream)
+    cp = configparser.ConfigParser()
+    for k, v in exports.items():
+        # TODO check k, v for valid values
+        cp.add_section(k)
+        for entry in v.values():
+            if entry.suffix is None:
+                s = entry.prefix
+            else:
+                s = '%s:%s' % (entry.prefix, entry.suffix)
+            if entry.flags:
+                s = '%s [%s]' % (s, ', '.join(entry.flags))
+            cp.set(k, entry.name, s)
+    cp.write(stream)
+
+
+@contextlib.contextmanager
+def tempdir():
+    td = tempfile.mkdtemp()
+    try:
+        yield td
+    finally:
+        shutil.rmtree(td)
+
+@contextlib.contextmanager
+def chdir(d):
+    cwd = os.getcwd()
+    try:
+        os.chdir(d)
+        yield
+    finally:
+        os.chdir(cwd)
+
+
+@contextlib.contextmanager
+def socket_timeout(seconds=15):
+    cto = socket.getdefaulttimeout()
+    try:
+        socket.setdefaulttimeout(seconds)
+        yield
+    finally:
+        socket.setdefaulttimeout(cto)
+
+
+class cached_property(object):
+    def __init__(self, func):
+        self.func = func
+        #for attr in ('__name__', '__module__', '__doc__'):
+        #    setattr(self, attr, getattr(func, attr, None))
+
+    def __get__(self, obj, cls=None):
+        if obj is None:
+            return self
+        value = self.func(obj)
+        object.__setattr__(obj, self.func.__name__, value)
+        #obj.__dict__[self.func.__name__] = value = self.func(obj)
+        return value
+
+def convert_path(pathname):
+    """Return 'pathname' as a name that will work on the native filesystem.
+
+    The path is split on '/' and put back together again using the current
+    directory separator.  Needed because filenames in the setup script are
+    always supplied in Unix style, and have to be converted to the local
+    convention before we can actually use them in the filesystem.  Raises
+    ValueError on non-Unix-ish systems if 'pathname' either starts or
+    ends with a slash.
+    """
+    if os.sep == '/':
+        return pathname
+    if not pathname:
+        return pathname
+    if pathname[0] == '/':
+        raise ValueError("path '%s' cannot be absolute" % pathname)
+    if pathname[-1] == '/':
+        raise ValueError("path '%s' cannot end with '/'" % pathname)
+
+    paths = pathname.split('/')
+    while os.curdir in paths:
+        paths.remove(os.curdir)
+    if not paths:
+        return os.curdir
+    return os.path.join(*paths)
+
+
+class FileOperator(object):
+    def __init__(self, dry_run=False):
+        self.dry_run = dry_run
+        self.ensured = set()
+        self._init_record()
+
+    def _init_record(self):
+        self.record = False
+        self.files_written = set()
+        self.dirs_created = set()
+
+    def record_as_written(self, path):
+        if self.record:
+            self.files_written.add(path)
+
+    def newer(self, source, target):
+        """Tell if the target is newer than the source.
+
+        Returns true if 'source' exists and is more recently modified than
+        'target', or if 'source' exists and 'target' doesn't.
+
+        Returns false if both exist and 'target' is the same age or younger
+        than 'source'. Raise PackagingFileError if 'source' does not exist.
+
+        Note that this test is not very accurate: files created in the same
+        second will have the same "age".
+        """
+        if not os.path.exists(source):
+            raise DistlibException("file '%r' does not exist" %
+                                   os.path.abspath(source))
+        if not os.path.exists(target):
+            return True
+
+        return os.stat(source).st_mtime > os.stat(target).st_mtime
+
+    def copy_file(self, infile, outfile, check=True):
+        """Copy a file respecting dry-run and force flags.
+        """
+        self.ensure_dir(os.path.dirname(outfile))
+        logger.info('Copying %s to %s', infile, outfile)
+        if not self.dry_run:
+            msg = None
+            if check:
+                if os.path.islink(outfile):
+                    msg = '%s is a symlink' % outfile
+                elif os.path.exists(outfile) and not os.path.isfile(outfile):
+                    msg = '%s is a non-regular file' % outfile
+            if msg:
+                raise ValueError(msg + ' which would be overwritten')
+            shutil.copyfile(infile, outfile)
+        self.record_as_written(outfile)
+
+    def copy_stream(self, instream, outfile, encoding=None):
+        assert not os.path.isdir(outfile)
+        self.ensure_dir(os.path.dirname(outfile))
+        logger.info('Copying stream %s to %s', instream, outfile)
+        if not self.dry_run:
+            if encoding is None:
+                outstream = open(outfile, 'wb')
+            else:
+                outstream = codecs.open(outfile, 'w', encoding=encoding)
+            try:
+                shutil.copyfileobj(instream, outstream)
+            finally:
+                outstream.close()
+        self.record_as_written(outfile)
+
+    def write_binary_file(self, path, data):
+        self.ensure_dir(os.path.dirname(path))
+        if not self.dry_run:
+            if os.path.exists(path):
+                os.remove(path)
+            with open(path, 'wb') as f:
+                f.write(data)
+        self.record_as_written(path)
+
+    def write_text_file(self, path, data, encoding):
+        self.write_binary_file(path, data.encode(encoding))
+
+    def set_mode(self, bits, mask, files):
+        if os.name == 'posix' or (os.name == 'java' and os._name == 'posix'):
+            # Set the executable bits (owner, group, and world) on
+            # all the files specified.
+            for f in files:
+                if self.dry_run:
+                    logger.info("changing mode of %s", f)
+                else:
+                    mode = (os.stat(f).st_mode | bits) & mask
+                    logger.info("changing mode of %s to %o", f, mode)
+                    os.chmod(f, mode)
+
+    set_executable_mode = lambda s, f: s.set_mode(0o555, 0o7777, f)
+
+    def ensure_dir(self, path):
+        path = os.path.abspath(path)
+        if path not in self.ensured and not os.path.exists(path):
+            self.ensured.add(path)
+            d, f = os.path.split(path)
+            self.ensure_dir(d)
+            logger.info('Creating %s' % path)
+            if not self.dry_run:
+                os.mkdir(path)
+            if self.record:
+                self.dirs_created.add(path)
+
+    def byte_compile(self, path, optimize=False, force=False, prefix=None, hashed_invalidation=False):
+        dpath = cache_from_source(path, not optimize)
+        logger.info('Byte-compiling %s to %s', path, dpath)
+        if not self.dry_run:
+            if force or self.newer(path, dpath):
+                if not prefix:
+                    diagpath = None
+                else:
+                    assert path.startswith(prefix)
+                    diagpath = path[len(prefix):]
+            compile_kwargs = {}
+            if hashed_invalidation and hasattr(py_compile, 'PycInvalidationMode'):
+                compile_kwargs['invalidation_mode'] = py_compile.PycInvalidationMode.CHECKED_HASH
+            py_compile.compile(path, dpath, diagpath, True, **compile_kwargs)     # raise error
+        self.record_as_written(dpath)
+        return dpath
+
+    def ensure_removed(self, path):
+        if os.path.exists(path):
+            if os.path.isdir(path) and not os.path.islink(path):
+                logger.debug('Removing directory tree at %s', path)
+                if not self.dry_run:
+                    shutil.rmtree(path)
+                if self.record:
+                    if path in self.dirs_created:
+                        self.dirs_created.remove(path)
+            else:
+                if os.path.islink(path):
+                    s = 'link'
+                else:
+                    s = 'file'
+                logger.debug('Removing %s %s', s, path)
+                if not self.dry_run:
+                    os.remove(path)
+                if self.record:
+                    if path in self.files_written:
+                        self.files_written.remove(path)
+
+    def is_writable(self, path):
+        result = False
+        while not result:
+            if os.path.exists(path):
+                result = os.access(path, os.W_OK)
+                break
+            parent = os.path.dirname(path)
+            if parent == path:
+                break
+            path = parent
+        return result
+
+    def commit(self):
+        """
+        Commit recorded changes, turn off recording, return
+        changes.
+        """
+        assert self.record
+        result = self.files_written, self.dirs_created
+        self._init_record()
+        return result
+
+    def rollback(self):
+        if not self.dry_run:
+            for f in list(self.files_written):
+                if os.path.exists(f):
+                    os.remove(f)
+            # dirs should all be empty now, except perhaps for
+            # __pycache__ subdirs
+            # reverse so that subdirs appear before their parents
+            dirs = sorted(self.dirs_created, reverse=True)
+            for d in dirs:
+                flist = os.listdir(d)
+                if flist:
+                    assert flist == ['__pycache__']
+                    sd = os.path.join(d, flist[0])
+                    os.rmdir(sd)
+                os.rmdir(d)     # should fail if non-empty
+        self._init_record()
+
+def resolve(module_name, dotted_path):
+    if module_name in sys.modules:
+        mod = sys.modules[module_name]
+    else:
+        mod = __import__(module_name)
+    if dotted_path is None:
+        result = mod
+    else:
+        parts = dotted_path.split('.')
+        result = getattr(mod, parts.pop(0))
+        for p in parts:
+            result = getattr(result, p)
+    return result
+
+
+class ExportEntry(object):
+    def __init__(self, name, prefix, suffix, flags):
+        self.name = name
+        self.prefix = prefix
+        self.suffix = suffix
+        self.flags = flags
+
+    @cached_property
+    def value(self):
+        return resolve(self.prefix, self.suffix)
+
+    def __repr__(self):  # pragma: no cover
+        return '<ExportEntry %s = %s:%s %s>' % (self.name, self.prefix,
+                                                self.suffix, self.flags)
+
+    def __eq__(self, other):
+        if not isinstance(other, ExportEntry):
+            result = False
+        else:
+            result = (self.name == other.name and
+                      self.prefix == other.prefix and
+                      self.suffix == other.suffix and
+                      self.flags == other.flags)
+        return result
+
+    __hash__ = object.__hash__
+
+
+ENTRY_RE = re.compile(r'''(?P<name>(\w|[-.+])+)
+                      \s*=\s*(?P<callable>(\w+)([:\.]\w+)*)
+                      \s*(\[\s*(?P<flags>[\w-]+(=\w+)?(,\s*\w+(=\w+)?)*)\s*\])?
+                      ''', re.VERBOSE)
+
+def get_export_entry(specification):
+    m = ENTRY_RE.search(specification)
+    if not m:
+        result = None
+        if '[' in specification or ']' in specification:
+            raise DistlibException("Invalid specification "
+                                   "'%s'" % specification)
+    else:
+        d = m.groupdict()
+        name = d['name']
+        path = d['callable']
+        colons = path.count(':')
+        if colons == 0:
+            prefix, suffix = path, None
+        else:
+            if colons != 1:
+                raise DistlibException("Invalid specification "
+                                       "'%s'" % specification)
+            prefix, suffix = path.split(':')
+        flags = d['flags']
+        if flags is None:
+            if '[' in specification or ']' in specification:
+                raise DistlibException("Invalid specification "
+                                       "'%s'" % specification)
+            flags = []
+        else:
+            flags = [f.strip() for f in flags.split(',')]
+        result = ExportEntry(name, prefix, suffix, flags)
+    return result
+
+
+def get_cache_base(suffix=None):
+    """
+    Return the default base location for distlib caches. If the directory does
+    not exist, it is created. Use the suffix provided for the base directory,
+    and default to '.distlib' if it isn't provided.
+
+    On Windows, if LOCALAPPDATA is defined in the environment, then it is
+    assumed to be a directory, and will be the parent directory of the result.
+    On POSIX, and on Windows if LOCALAPPDATA is not defined, the user's home
+    directory - using os.expanduser('~') - will be the parent directory of
+    the result.
+
+    The result is just the directory '.distlib' in the parent directory as
+    determined above, or with the name specified with ``suffix``.
+    """
+    if suffix is None:
+        suffix = '.distlib'
+    if os.name == 'nt' and 'LOCALAPPDATA' in os.environ:
+        result = os.path.expandvars('$localappdata')
+    else:
+        # Assume posix, or old Windows
+        result = os.path.expanduser('~')
+    # we use 'isdir' instead of 'exists', because we want to
+    # fail if there's a file with that name
+    if os.path.isdir(result):
+        usable = os.access(result, os.W_OK)
+        if not usable:
+            logger.warning('Directory exists but is not writable: %s', result)
+    else:
+        try:
+            os.makedirs(result)
+            usable = True
+        except OSError:
+            logger.warning('Unable to create %s', result, exc_info=True)
+            usable = False
+    if not usable:
+        result = tempfile.mkdtemp()
+        logger.warning('Default location unusable, using %s', result)
+    return os.path.join(result, suffix)
+
+
+def path_to_cache_dir(path):
+    """
+    Convert an absolute path to a directory name for use in a cache.
+
+    The algorithm used is:
+
+    #. On Windows, any ``':'`` in the drive is replaced with ``'---'``.
+    #. Any occurrence of ``os.sep`` is replaced with ``'--'``.
+    #. ``'.cache'`` is appended.
+    """
+    d, p = os.path.splitdrive(os.path.abspath(path))
+    if d:
+        d = d.replace(':', '---')
+    p = p.replace(os.sep, '--')
+    return d + p + '.cache'
+
+
+def ensure_slash(s):
+    if not s.endswith('/'):
+        return s + '/'
+    return s
+
+
+def parse_credentials(netloc):
+    username = password = None
+    if '@' in netloc:
+        prefix, netloc = netloc.rsplit('@', 1)
+        if ':' not in prefix:
+            username = prefix
+        else:
+            username, password = prefix.split(':', 1)
+    if username:
+        username = unquote(username)
+    if password:
+        password = unquote(password)
+    return username, password, netloc
+
+
+def get_process_umask():
+    result = os.umask(0o22)
+    os.umask(result)
+    return result
+
+def is_string_sequence(seq):
+    result = True
+    i = None
+    for i, s in enumerate(seq):
+        if not isinstance(s, string_types):
+            result = False
+            break
+    assert i is not None
+    return result
+
+PROJECT_NAME_AND_VERSION = re.compile('([a-z0-9_]+([.-][a-z_][a-z0-9_]*)*)-'
+                                      '([a-z0-9_.+-]+)', re.I)
+PYTHON_VERSION = re.compile(r'-py(\d\.?\d?)')
+
+
+def split_filename(filename, project_name=None):
+    """
+    Extract name, version, python version from a filename (no extension)
+
+    Return name, version, pyver or None
+    """
+    result = None
+    pyver = None
+    filename = unquote(filename).replace(' ', '-')
+    m = PYTHON_VERSION.search(filename)
+    if m:
+        pyver = m.group(1)
+        filename = filename[:m.start()]
+    if project_name and len(filename) > len(project_name) + 1:
+        m = re.match(re.escape(project_name) + r'\b', filename)
+        if m:
+            n = m.end()
+            result = filename[:n], filename[n + 1:], pyver
+    if result is None:
+        m = PROJECT_NAME_AND_VERSION.match(filename)
+        if m:
+            result = m.group(1), m.group(3), pyver
+    return result
+
+# Allow spaces in name because of legacy dists like "Twisted Core"
+NAME_VERSION_RE = re.compile(r'(?P<name>[\w .-]+)\s*'
+                             r'\(\s*(?P<ver>[^\s)]+)\)$')
+
+def parse_name_and_version(p):
+    """
+    A utility method used to get name and version from a string.
+
+    From e.g. a Provides-Dist value.
+
+    :param p: A value in a form 'foo (1.0)'
+    :return: The name and version as a tuple.
+    """
+    m = NAME_VERSION_RE.match(p)
+    if not m:
+        raise DistlibException('Ill-formed name/version string: \'%s\'' % p)
+    d = m.groupdict()
+    return d['name'].strip().lower(), d['ver']
+
+def get_extras(requested, available):
+    result = set()
+    requested = set(requested or [])
+    available = set(available or [])
+    if '*' in requested:
+        requested.remove('*')
+        result |= available
+    for r in requested:
+        if r == '-':
+            result.add(r)
+        elif r.startswith('-'):
+            unwanted = r[1:]
+            if unwanted not in available:
+                logger.warning('undeclared extra: %s' % unwanted)
+            if unwanted in result:
+                result.remove(unwanted)
+        else:
+            if r not in available:
+                logger.warning('undeclared extra: %s' % r)
+            result.add(r)
+    return result
+#
+# Extended metadata functionality
+#
+
+def _get_external_data(url):
+    result = {}
+    try:
+        # urlopen might fail if it runs into redirections,
+        # because of Python issue #13696. Fixed in locators
+        # using a custom redirect handler.
+        resp = urlopen(url)
+        headers = resp.info()
+        ct = headers.get('Content-Type')
+        if not ct.startswith('application/json'):
+            logger.debug('Unexpected response for JSON request: %s', ct)
+        else:
+            reader = codecs.getreader('utf-8')(resp)
+            #data = reader.read().decode('utf-8')
+            #result = json.loads(data)
+            result = json.load(reader)
+    except Exception as e:
+        logger.exception('Failed to get external data for %s: %s', url, e)
+    return result
+
+_external_data_base_url = 'https://www.red-dove.com/pypi/projects/'
+
+def get_project_data(name):
+    url = '%s/%s/project.json' % (name[0].upper(), name)
+    url = urljoin(_external_data_base_url, url)
+    result = _get_external_data(url)
+    return result
+
+def get_package_data(name, version):
+    url = '%s/%s/package-%s.json' % (name[0].upper(), name, version)
+    url = urljoin(_external_data_base_url, url)
+    return _get_external_data(url)
+
+
+class Cache(object):
+    """
+    A class implementing a cache for resources that need to live in the file system
+    e.g. shared libraries. This class was moved from resources to here because it
+    could be used by other modules, e.g. the wheel module.
+    """
+
+    def __init__(self, base):
+        """
+        Initialise an instance.
+
+        :param base: The base directory where the cache should be located.
+        """
+        # we use 'isdir' instead of 'exists', because we want to
+        # fail if there's a file with that name
+        if not os.path.isdir(base):  # pragma: no cover
+            os.makedirs(base)
+        if (os.stat(base).st_mode & 0o77) != 0:
+            logger.warning('Directory \'%s\' is not private', base)
+        self.base = os.path.abspath(os.path.normpath(base))
+
+    def prefix_to_dir(self, prefix):
+        """
+        Converts a resource prefix to a directory name in the cache.
+        """
+        return path_to_cache_dir(prefix)
+
+    def clear(self):
+        """
+        Clear the cache.
+        """
+        not_removed = []
+        for fn in os.listdir(self.base):
+            fn = os.path.join(self.base, fn)
+            try:
+                if os.path.islink(fn) or os.path.isfile(fn):
+                    os.remove(fn)
+                elif os.path.isdir(fn):
+                    shutil.rmtree(fn)
+            except Exception:
+                not_removed.append(fn)
+        return not_removed
+
+
+class EventMixin(object):
+    """
+    A very simple publish/subscribe system.
+    """
+    def __init__(self):
+        self._subscribers = {}
+
+    def add(self, event, subscriber, append=True):
+        """
+        Add a subscriber for an event.
+
+        :param event: The name of an event.
+        :param subscriber: The subscriber to be added (and called when the
+                           event is published).
+        :param append: Whether to append or prepend the subscriber to an
+                       existing subscriber list for the event.
+        """
+        subs = self._subscribers
+        if event not in subs:
+            subs[event] = deque([subscriber])
+        else:
+            sq = subs[event]
+            if append:
+                sq.append(subscriber)
+            else:
+                sq.appendleft(subscriber)
+
+    def remove(self, event, subscriber):
+        """
+        Remove a subscriber for an event.
+
+        :param event: The name of an event.
+        :param subscriber: The subscriber to be removed.
+        """
+        subs = self._subscribers
+        if event not in subs:
+            raise ValueError('No subscribers: %r' % event)
+        subs[event].remove(subscriber)
+
+    def get_subscribers(self, event):
+        """
+        Return an iterator for the subscribers for an event.
+        :param event: The event to return subscribers for.
+        """
+        return iter(self._subscribers.get(event, ()))
+
+    def publish(self, event, *args, **kwargs):
+        """
+        Publish a event and return a list of values returned by its
+        subscribers.
+
+        :param event: The event to publish.
+        :param args: The positional arguments to pass to the event's
+                     subscribers.
+        :param kwargs: The keyword arguments to pass to the event's
+                       subscribers.
+        """
+        result = []
+        for subscriber in self.get_subscribers(event):
+            try:
+                value = subscriber(event, *args, **kwargs)
+            except Exception:
+                logger.exception('Exception during event publication')
+                value = None
+            result.append(value)
+        logger.debug('publish %s: args = %s, kwargs = %s, result = %s',
+                     event, args, kwargs, result)
+        return result
+
+#
+# Simple sequencing
+#
+class Sequencer(object):
+    def __init__(self):
+        self._preds = {}
+        self._succs = {}
+        self._nodes = set()     # nodes with no preds/succs
+
+    def add_node(self, node):
+        self._nodes.add(node)
+
+    def remove_node(self, node, edges=False):
+        if node in self._nodes:
+            self._nodes.remove(node)
+        if edges:
+            for p in set(self._preds.get(node, ())):
+                self.remove(p, node)
+            for s in set(self._succs.get(node, ())):
+                self.remove(node, s)
+            # Remove empties
+            for k, v in list(self._preds.items()):
+                if not v:
+                    del self._preds[k]
+            for k, v in list(self._succs.items()):
+                if not v:
+                    del self._succs[k]
+
+    def add(self, pred, succ):
+        assert pred != succ
+        self._preds.setdefault(succ, set()).add(pred)
+        self._succs.setdefault(pred, set()).add(succ)
+
+    def remove(self, pred, succ):
+        assert pred != succ
+        try:
+            preds = self._preds[succ]
+            succs = self._succs[pred]
+        except KeyError:  # pragma: no cover
+            raise ValueError('%r not a successor of anything' % succ)
+        try:
+            preds.remove(pred)
+            succs.remove(succ)
+        except KeyError:  # pragma: no cover
+            raise ValueError('%r not a successor of %r' % (succ, pred))
+
+    def is_step(self, step):
+        return (step in self._preds or step in self._succs or
+                step in self._nodes)
+
+    def get_steps(self, final):
+        if not self.is_step(final):
+            raise ValueError('Unknown: %r' % final)
+        result = []
+        todo = []
+        seen = set()
+        todo.append(final)
+        while todo:
+            step = todo.pop(0)
+            if step in seen:
+                # if a step was already seen,
+                # move it to the end (so it will appear earlier
+                # when reversed on return) ... but not for the
+                # final step, as that would be confusing for
+                # users
+                if step != final:
+                    result.remove(step)
+                    result.append(step)
+            else:
+                seen.add(step)
+                result.append(step)
+                preds = self._preds.get(step, ())
+                todo.extend(preds)
+        return reversed(result)
+
+    @property
+    def strong_connections(self):
+        #http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+        index_counter = [0]
+        stack = []
+        lowlinks = {}
+        index = {}
+        result = []
+
+        graph = self._succs
+
+        def strongconnect(node):
+            # set the depth index for this node to the smallest unused index
+            index[node] = index_counter[0]
+            lowlinks[node] = index_counter[0]
+            index_counter[0] += 1
+            stack.append(node)
+
+            # Consider successors
+            try:
+                successors = graph[node]
+            except Exception:
+                successors = []
+            for successor in successors:
+                if successor not in lowlinks:
+                    # Successor has not yet been visited
+                    strongconnect(successor)
+                    lowlinks[node] = min(lowlinks[node],lowlinks[successor])
+                elif successor in stack:
+                    # the successor is in the stack and hence in the current
+                    # strongly connected component (SCC)
+                    lowlinks[node] = min(lowlinks[node],index[successor])
+
+            # If `node` is a root node, pop the stack and generate an SCC
+            if lowlinks[node] == index[node]:
+                connected_component = []
+
+                while True:
+                    successor = stack.pop()
+                    connected_component.append(successor)
+                    if successor == node: break
+                component = tuple(connected_component)
+                # storing the result
+                result.append(component)
+
+        for node in graph:
+            if node not in lowlinks:
+                strongconnect(node)
+
+        return result
+
+    @property
+    def dot(self):
+        result = ['digraph G {']
+        for succ in self._preds:
+            preds = self._preds[succ]
+            for pred in preds:
+                result.append('  %s -> %s;' % (pred, succ))
+        for node in self._nodes:
+            result.append('  %s;' % node)
+        result.append('}')
+        return '\n'.join(result)
+
+#
+# Unarchiving functionality for zip, tar, tgz, tbz, whl
+#
+
+ARCHIVE_EXTENSIONS = ('.tar.gz', '.tar.bz2', '.tar', '.zip',
+                      '.tgz', '.tbz', '.whl')
+
+def unarchive(archive_filename, dest_dir, format=None, check=True):
+
+    def check_path(path):
+        if not isinstance(path, text_type):
+            path = path.decode('utf-8')
+        p = os.path.abspath(os.path.join(dest_dir, path))
+        if not p.startswith(dest_dir) or p[plen] != os.sep:
+            raise ValueError('path outside destination: %r' % p)
+
+    dest_dir = os.path.abspath(dest_dir)
+    plen = len(dest_dir)
+    archive = None
+    if format is None:
+        if archive_filename.endswith(('.zip', '.whl')):
+            format = 'zip'
+        elif archive_filename.endswith(('.tar.gz', '.tgz')):
+            format = 'tgz'
+            mode = 'r:gz'
+        elif archive_filename.endswith(('.tar.bz2', '.tbz')):
+            format = 'tbz'
+            mode = 'r:bz2'
+        elif archive_filename.endswith('.tar'):
+            format = 'tar'
+            mode = 'r'
+        else:  # pragma: no cover
+            raise ValueError('Unknown format for %r' % archive_filename)
+    try:
+        if format == 'zip':
+            archive = ZipFile(archive_filename, 'r')
+            if check:
+                names = archive.namelist()
+                for name in names:
+                    check_path(name)
+        else:
+            archive = tarfile.open(archive_filename, mode)
+            if check:
+                names = archive.getnames()
+                for name in names:
+                    check_path(name)
+        if format != 'zip' and sys.version_info[0] < 3:
+            # See Python issue 17153. If the dest path contains Unicode,
+            # tarfile extraction fails on Python 2.x if a member path name
+            # contains non-ASCII characters - it leads to an implicit
+            # bytes -> unicode conversion using ASCII to decode.
+            for tarinfo in archive.getmembers():
+                if not isinstance(tarinfo.name, text_type):
+                    tarinfo.name = tarinfo.name.decode('utf-8')
+        archive.extractall(dest_dir)
+
+    finally:
+        if archive:
+            archive.close()
+
+
+def zip_dir(directory):
+    """zip a directory tree into a BytesIO object"""
+    result = io.BytesIO()
+    dlen = len(directory)
+    with ZipFile(result, "w") as zf:
+        for root, dirs, files in os.walk(directory):
+            for name in files:
+                full = os.path.join(root, name)
+                rel = root[dlen:]
+                dest = os.path.join(rel, name)
+                zf.write(full, dest)
+    return result
+
+#
+# Simple progress bar
+#
+
+UNITS = ('', 'K', 'M', 'G','T','P')
+
+
+class Progress(object):
+    unknown = 'UNKNOWN'
+
+    def __init__(self, minval=0, maxval=100):
+        assert maxval is None or maxval >= minval
+        self.min = self.cur = minval
+        self.max = maxval
+        self.started = None
+        self.elapsed = 0
+        self.done = False
+
+    def update(self, curval):
+        assert self.min <= curval
+        assert self.max is None or curval <= self.max
+        self.cur = curval
+        now = time.time()
+        if self.started is None:
+            self.started = now
+        else:
+            self.elapsed = now - self.started
+
+    def increment(self, incr):
+        assert incr >= 0
+        self.update(self.cur + incr)
+
+    def start(self):
+        self.update(self.min)
+        return self
+
+    def stop(self):
+        if self.max is not None:
+            self.update(self.max)
+        self.done = True
+
+    @property
+    def maximum(self):
+        return self.unknown if self.max is None else self.max
+
+    @property
+    def percentage(self):
+        if self.done:
+            result = '100 %'
+        elif self.max is None:
+            result = ' ?? %'
+        else:
+            v = 100.0 * (self.cur - self.min) / (self.max - self.min)
+            result = '%3d %%' % v
+        return result
+
+    def format_duration(self, duration):
+        if (duration <= 0) and self.max is None or self.cur == self.min:
+            result = '??:??:??'
+        #elif duration < 1:
+        #    result = '--:--:--'
+        else:
+            result = time.strftime('%H:%M:%S', time.gmtime(duration))
+        return result
+
+    @property
+    def ETA(self):
+        if self.done:
+            prefix = 'Done'
+            t = self.elapsed
+            #import pdb; pdb.set_trace()
+        else:
+            prefix = 'ETA '
+            if self.max is None:
+                t = -1
+            elif self.elapsed == 0 or (self.cur == self.min):
+                t = 0
+            else:
+                #import pdb; pdb.set_trace()
+                t = float(self.max - self.min)
+                t /= self.cur - self.min
+                t = (t - 1) * self.elapsed
+        return '%s: %s' % (prefix, self.format_duration(t))
+
+    @property
+    def speed(self):
+        if self.elapsed == 0:
+            result = 0.0
+        else:
+            result = (self.cur - self.min) / self.elapsed
+        for unit in UNITS:
+            if result < 1000:
+                break
+            result /= 1000.0
+        return '%d %sB/s' % (result, unit)
+
+#
+# Glob functionality
+#
+
+RICH_GLOB = re.compile(r'\{([^}]*)\}')
+_CHECK_RECURSIVE_GLOB = re.compile(r'[^/\\,{]\*\*|\*\*[^/\\,}]')
+_CHECK_MISMATCH_SET = re.compile(r'^[^{]*\}|\{[^}]*$')
+
+
+def iglob(path_glob):
+    """Extended globbing function that supports ** and {opt1,opt2,opt3}."""
+    if _CHECK_RECURSIVE_GLOB.search(path_glob):
+        msg = """invalid glob %r: recursive glob "**" must be used alone"""
+        raise ValueError(msg % path_glob)
+    if _CHECK_MISMATCH_SET.search(path_glob):
+        msg = """invalid glob %r: mismatching set marker '{' or '}'"""
+        raise ValueError(msg % path_glob)
+    return _iglob(path_glob)
+
+
+def _iglob(path_glob):
+    rich_path_glob = RICH_GLOB.split(path_glob, 1)
+    if len(rich_path_glob) > 1:
+        assert len(rich_path_glob) == 3, rich_path_glob
+        prefix, set, suffix = rich_path_glob
+        for item in set.split(','):
+            for path in _iglob(''.join((prefix, item, suffix))):
+                yield path
+    else:
+        if '**' not in path_glob:
+            for item in std_iglob(path_glob):
+                yield item
+        else:
+            prefix, radical = path_glob.split('**', 1)
+            if prefix == '':
+                prefix = '.'
+            if radical == '':
+                radical = '*'
+            else:
+                # we support both
+                radical = radical.lstrip('/')
+                radical = radical.lstrip('\\')
+            for path, dir, files in os.walk(prefix):
+                path = os.path.normpath(path)
+                for fn in _iglob(os.path.join(path, radical)):
+                    yield fn
+
+if ssl:
+    from .compat import (HTTPSHandler as BaseHTTPSHandler, match_hostname,
+                         CertificateError)
+
+
+#
+# HTTPSConnection which verifies certificates/matches domains
+#
+
+    class HTTPSConnection(httplib.HTTPSConnection):
+        ca_certs = None # set this to the path to the certs file (.pem)
+        check_domain = True # only used if ca_certs is not None
+
+        # noinspection PyPropertyAccess
+        def connect(self):
+            sock = socket.create_connection((self.host, self.port), self.timeout)
+            if getattr(self, '_tunnel_host', False):
+                self.sock = sock
+                self._tunnel()
+
+            if not hasattr(ssl, 'SSLContext'):
+                # For 2.x
+                if self.ca_certs:
+                    cert_reqs = ssl.CERT_REQUIRED
+                else:
+                    cert_reqs = ssl.CERT_NONE
+                self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file,
+                                            cert_reqs=cert_reqs,
+                                            ssl_version=ssl.PROTOCOL_SSLv23,
+                                            ca_certs=self.ca_certs)
+            else:  # pragma: no cover
+                context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+                if hasattr(ssl, 'OP_NO_SSLv2'):
+                    context.options |= ssl.OP_NO_SSLv2
+                if self.cert_file:
+                    context.load_cert_chain(self.cert_file, self.key_file)
+                kwargs = {}
+                if self.ca_certs:
+                    context.verify_mode = ssl.CERT_REQUIRED
+                    context.load_verify_locations(cafile=self.ca_certs)
+                    if getattr(ssl, 'HAS_SNI', False):
+                        kwargs['server_hostname'] = self.host
+                self.sock = context.wrap_socket(sock, **kwargs)
+            if self.ca_certs and self.check_domain:
+                try:
+                    match_hostname(self.sock.getpeercert(), self.host)
+                    logger.debug('Host verified: %s', self.host)
+                except CertificateError:  # pragma: no cover
+                    self.sock.shutdown(socket.SHUT_RDWR)
+                    self.sock.close()
+                    raise
+
+    class HTTPSHandler(BaseHTTPSHandler):
+        def __init__(self, ca_certs, check_domain=True):
+            BaseHTTPSHandler.__init__(self)
+            self.ca_certs = ca_certs
+            self.check_domain = check_domain
+
+        def _conn_maker(self, *args, **kwargs):
+            """
+            This is called to create a connection instance. Normally you'd
+            pass a connection class to do_open, but it doesn't actually check for
+            a class, and just expects a callable. As long as we behave just as a
+            constructor would have, we should be OK. If it ever changes so that
+            we *must* pass a class, we'll create an UnsafeHTTPSConnection class
+            which just sets check_domain to False in the class definition, and
+            choose which one to pass to do_open.
+            """
+            result = HTTPSConnection(*args, **kwargs)
+            if self.ca_certs:
+                result.ca_certs = self.ca_certs
+                result.check_domain = self.check_domain
+            return result
+
+        def https_open(self, req):
+            try:
+                return self.do_open(self._conn_maker, req)
+            except URLError as e:
+                if 'certificate verify failed' in str(e.reason):
+                    raise CertificateError('Unable to verify server certificate '
+                                           'for %s' % req.host)
+                else:
+                    raise
+
+    #
+    # To prevent against mixing HTTP traffic with HTTPS (examples: A Man-In-The-
+    # Middle proxy using HTTP listens on port 443, or an index mistakenly serves
+    # HTML containing a http://xyz link when it should be https://xyz),
+    # you can use the following handler class, which does not allow HTTP traffic.
+    #
+    # It works by inheriting from HTTPHandler - so build_opener won't add a
+    # handler for HTTP itself.
+    #
+    class HTTPSOnlyHandler(HTTPSHandler, HTTPHandler):
+        def http_open(self, req):
+            raise URLError('Unexpected HTTP request on what should be a secure '
+                           'connection: %s' % req)
+
+#
+# XML-RPC with timeouts
+#
+
+_ver_info = sys.version_info[:2]
+
+if _ver_info == (2, 6):
+    class HTTP(httplib.HTTP):
+        def __init__(self, host='', port=None, **kwargs):
+            if port == 0:   # 0 means use port 0, not the default port
+                port = None
+            self._setup(self._connection_class(host, port, **kwargs))
+
+
+    if ssl:
+        class HTTPS(httplib.HTTPS):
+            def __init__(self, host='', port=None, **kwargs):
+                if port == 0:   # 0 means use port 0, not the default port
+                    port = None
+                self._setup(self._connection_class(host, port, **kwargs))
+
+
+class Transport(xmlrpclib.Transport):
+    def __init__(self, timeout, use_datetime=0):
+        self.timeout = timeout
+        xmlrpclib.Transport.__init__(self, use_datetime)
+
+    def make_connection(self, host):
+        h, eh, x509 = self.get_host_info(host)
+        if _ver_info == (2, 6):
+            result = HTTP(h, timeout=self.timeout)
+        else:
+            if not self._connection or host != self._connection[0]:
+                self._extra_headers = eh
+                self._connection = host, httplib.HTTPConnection(h)
+            result = self._connection[1]
+        return result
+
+if ssl:
+    class SafeTransport(xmlrpclib.SafeTransport):
+        def __init__(self, timeout, use_datetime=0):
+            self.timeout = timeout
+            xmlrpclib.SafeTransport.__init__(self, use_datetime)
+
+        def make_connection(self, host):
+            h, eh, kwargs = self.get_host_info(host)
+            if not kwargs:
+                kwargs = {}
+            kwargs['timeout'] = self.timeout
+            if _ver_info == (2, 6):
+                result = HTTPS(host, None, **kwargs)
+            else:
+                if not self._connection or host != self._connection[0]:
+                    self._extra_headers = eh
+                    self._connection = host, httplib.HTTPSConnection(h, None,
+                                                                     **kwargs)
+                result = self._connection[1]
+            return result
+
+
+class ServerProxy(xmlrpclib.ServerProxy):
+    def __init__(self, uri, **kwargs):
+        self.timeout = timeout = kwargs.pop('timeout', None)
+        # The above classes only come into play if a timeout
+        # is specified
+        if timeout is not None:
+            scheme, _ = splittype(uri)
+            use_datetime = kwargs.get('use_datetime', 0)
+            if scheme == 'https':
+                tcls = SafeTransport
+            else:
+                tcls = Transport
+            kwargs['transport'] = t = tcls(timeout, use_datetime=use_datetime)
+            self.transport = t
+        xmlrpclib.ServerProxy.__init__(self, uri, **kwargs)
+
+#
+# CSV functionality. This is provided because on 2.x, the csv module can't
+# handle Unicode. However, we need to deal with Unicode in e.g. RECORD files.
+#
+
+def _csv_open(fn, mode, **kwargs):
+    if sys.version_info[0] < 3:
+        mode += 'b'
+    else:
+        kwargs['newline'] = ''
+        # Python 3 determines encoding from locale. Force 'utf-8'
+        # file encoding to match other forced utf-8 encoding
+        kwargs['encoding'] = 'utf-8'
+    return open(fn, mode, **kwargs)
+
+
+class CSVBase(object):
+    defaults = {
+        'delimiter': str(','),      # The strs are used because we need native
+        'quotechar': str('"'),      # str in the csv API (2.x won't take
+        'lineterminator': str('\n') # Unicode)
+    }
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        self.stream.close()
+
+
+class CSVReader(CSVBase):
+    def __init__(self, **kwargs):
+        if 'stream' in kwargs:
+            stream = kwargs['stream']
+            if sys.version_info[0] >= 3:
+                # needs to be a text stream
+                stream = codecs.getreader('utf-8')(stream)
+            self.stream = stream
+        else:
+            self.stream = _csv_open(kwargs['path'], 'r')
+        self.reader = csv.reader(self.stream, **self.defaults)
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        result = next(self.reader)
+        if sys.version_info[0] < 3:
+            for i, item in enumerate(result):
+                if not isinstance(item, text_type):
+                    result[i] = item.decode('utf-8')
+        return result
+
+    __next__ = next
+
+class CSVWriter(CSVBase):
+    def __init__(self, fn, **kwargs):
+        self.stream = _csv_open(fn, 'w')
+        self.writer = csv.writer(self.stream, **self.defaults)
+
+    def writerow(self, row):
+        if sys.version_info[0] < 3:
+            r = []
+            for item in row:
+                if isinstance(item, text_type):
+                    item = item.encode('utf-8')
+                r.append(item)
+            row = r
+        self.writer.writerow(row)
+
+#
+#   Configurator functionality
+#
+
+class Configurator(BaseConfigurator):
+
+    value_converters = dict(BaseConfigurator.value_converters)
+    value_converters['inc'] = 'inc_convert'
+
+    def __init__(self, config, base=None):
+        super(Configurator, self).__init__(config)
+        self.base = base or os.getcwd()
+
+    def configure_custom(self, config):
+        def convert(o):
+            if isinstance(o, (list, tuple)):
+                result = type(o)([convert(i) for i in o])
+            elif isinstance(o, dict):
+                if '()' in o:
+                    result = self.configure_custom(o)
+                else:
+                    result = {}
+                    for k in o:
+                        result[k] = convert(o[k])
+            else:
+                result = self.convert(o)
+            return result
+
+        c = config.pop('()')
+        if not callable(c):
+            c = self.resolve(c)
+        props = config.pop('.', None)
+        # Check for valid identifiers
+        args = config.pop('[]', ())
+        if args:
+            args = tuple([convert(o) for o in args])
+        items = [(k, convert(config[k])) for k in config if valid_ident(k)]
+        kwargs = dict(items)
+        result = c(*args, **kwargs)
+        if props:
+            for n, v in props.items():
+                setattr(result, n, convert(v))
+        return result
+
+    def __getitem__(self, key):
+        result = self.config[key]
+        if isinstance(result, dict) and '()' in result:
+            self.config[key] = result = self.configure_custom(result)
+        return result
+
+    def inc_convert(self, value):
+        """Default converter for the inc:// protocol."""
+        if not os.path.isabs(value):
+            value = os.path.join(self.base, value)
+        with codecs.open(value, 'r', encoding='utf-8') as f:
+            result = json.load(f)
+        return result
+
+
+class SubprocessMixin(object):
+    """
+    Mixin for running subprocesses and capturing their output
+    """
+    def __init__(self, verbose=False, progress=None):
+        self.verbose = verbose
+        self.progress = progress
+
+    def reader(self, stream, context):
+        """
+        Read lines from a subprocess' output stream and either pass to a progress
+        callable (if specified) or write progress information to sys.stderr.
+        """
+        progress = self.progress
+        verbose = self.verbose
+        while True:
+            s = stream.readline()
+            if not s:
+                break
+            if progress is not None:
+                progress(s, context)
+            else:
+                if not verbose:
+                    sys.stderr.write('.')
+                else:
+                    sys.stderr.write(s.decode('utf-8'))
+                sys.stderr.flush()
+        stream.close()
+
+    def run_command(self, cmd, **kwargs):
+        p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE, **kwargs)
+        t1 = threading.Thread(target=self.reader, args=(p.stdout, 'stdout'))
+        t1.start()
+        t2 = threading.Thread(target=self.reader, args=(p.stderr, 'stderr'))
+        t2.start()
+        p.wait()
+        t1.join()
+        t2.join()
+        if self.progress is not None:
+            self.progress('done.', 'main')
+        elif self.verbose:
+            sys.stderr.write('done.\n')
+        return p
+
+
+def normalize_name(name):
+    """Normalize a python package name a la PEP 503"""
+    # https://www.python.org/dev/peps/pep-0503/#normalized-names
+    return re.sub('[-_.]+', '-', name).lower()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/version.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/version.py
new file mode 100644
index 0000000..3eebe18
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/version.py
@@ -0,0 +1,736 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2017 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""
+Implementation of a flexible versioning scheme providing support for PEP-440,
+setuptools-compatible and semantic versioning.
+"""
+
+import logging
+import re
+
+from .compat import string_types
+from .util import parse_requirement
+
+__all__ = ['NormalizedVersion', 'NormalizedMatcher',
+           'LegacyVersion', 'LegacyMatcher',
+           'SemanticVersion', 'SemanticMatcher',
+           'UnsupportedVersionError', 'get_scheme']
+
+logger = logging.getLogger(__name__)
+
+
+class UnsupportedVersionError(ValueError):
+    """This is an unsupported version."""
+    pass
+
+
+class Version(object):
+    def __init__(self, s):
+        self._string = s = s.strip()
+        self._parts = parts = self.parse(s)
+        assert isinstance(parts, tuple)
+        assert len(parts) > 0
+
+    def parse(self, s):
+        raise NotImplementedError('please implement in a subclass')
+
+    def _check_compatible(self, other):
+        if type(self) != type(other):
+            raise TypeError('cannot compare %r and %r' % (self, other))
+
+    def __eq__(self, other):
+        self._check_compatible(other)
+        return self._parts == other._parts
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __lt__(self, other):
+        self._check_compatible(other)
+        return self._parts < other._parts
+
+    def __gt__(self, other):
+        return not (self.__lt__(other) or self.__eq__(other))
+
+    def __le__(self, other):
+        return self.__lt__(other) or self.__eq__(other)
+
+    def __ge__(self, other):
+        return self.__gt__(other) or self.__eq__(other)
+
+    # See http://docs.python.org/reference/datamodel#object.__hash__
+    def __hash__(self):
+        return hash(self._parts)
+
+    def __repr__(self):
+        return "%s('%s')" % (self.__class__.__name__, self._string)
+
+    def __str__(self):
+        return self._string
+
+    @property
+    def is_prerelease(self):
+        raise NotImplementedError('Please implement in subclasses.')
+
+
+class Matcher(object):
+    version_class = None
+
+    # value is either a callable or the name of a method
+    _operators = {
+        '<': lambda v, c, p: v < c,
+        '>': lambda v, c, p: v > c,
+        '<=': lambda v, c, p: v == c or v < c,
+        '>=': lambda v, c, p: v == c or v > c,
+        '==': lambda v, c, p: v == c,
+        '===': lambda v, c, p: v == c,
+        # by default, compatible => >=.
+        '~=': lambda v, c, p: v == c or v > c,
+        '!=': lambda v, c, p: v != c,
+    }
+
+    # this is a method only to support alternative implementations
+    # via overriding
+    def parse_requirement(self, s):
+        return parse_requirement(s)
+
+    def __init__(self, s):
+        if self.version_class is None:
+            raise ValueError('Please specify a version class')
+        self._string = s = s.strip()
+        r = self.parse_requirement(s)
+        if not r:
+            raise ValueError('Not valid: %r' % s)
+        self.name = r.name
+        self.key = self.name.lower()    # for case-insensitive comparisons
+        clist = []
+        if r.constraints:
+            # import pdb; pdb.set_trace()
+            for op, s in r.constraints:
+                if s.endswith('.*'):
+                    if op not in ('==', '!='):
+                        raise ValueError('\'.*\' not allowed for '
+                                         '%r constraints' % op)
+                    # Could be a partial version (e.g. for '2.*') which
+                    # won't parse as a version, so keep it as a string
+                    vn, prefix = s[:-2], True
+                    # Just to check that vn is a valid version
+                    self.version_class(vn)
+                else:
+                    # Should parse as a version, so we can create an
+                    # instance for the comparison
+                    vn, prefix = self.version_class(s), False
+                clist.append((op, vn, prefix))
+        self._parts = tuple(clist)
+
+    def match(self, version):
+        """
+        Check if the provided version matches the constraints.
+
+        :param version: The version to match against this instance.
+        :type version: String or :class:`Version` instance.
+        """
+        if isinstance(version, string_types):
+            version = self.version_class(version)
+        for operator, constraint, prefix in self._parts:
+            f = self._operators.get(operator)
+            if isinstance(f, string_types):
+                f = getattr(self, f)
+            if not f:
+                msg = ('%r not implemented '
+                       'for %s' % (operator, self.__class__.__name__))
+                raise NotImplementedError(msg)
+            if not f(version, constraint, prefix):
+                return False
+        return True
+
+    @property
+    def exact_version(self):
+        result = None
+        if len(self._parts) == 1 and self._parts[0][0] in ('==', '==='):
+            result = self._parts[0][1]
+        return result
+
+    def _check_compatible(self, other):
+        if type(self) != type(other) or self.name != other.name:
+            raise TypeError('cannot compare %s and %s' % (self, other))
+
+    def __eq__(self, other):
+        self._check_compatible(other)
+        return self.key == other.key and self._parts == other._parts
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    # See http://docs.python.org/reference/datamodel#object.__hash__
+    def __hash__(self):
+        return hash(self.key) + hash(self._parts)
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self._string)
+
+    def __str__(self):
+        return self._string
+
+
+PEP440_VERSION_RE = re.compile(r'^v?(\d+!)?(\d+(\.\d+)*)((a|b|c|rc)(\d+))?'
+                               r'(\.(post)(\d+))?(\.(dev)(\d+))?'
+                               r'(\+([a-zA-Z\d]+(\.[a-zA-Z\d]+)?))?$')
+
+
+def _pep_440_key(s):
+    s = s.strip()
+    m = PEP440_VERSION_RE.match(s)
+    if not m:
+        raise UnsupportedVersionError('Not a valid version: %s' % s)
+    groups = m.groups()
+    nums = tuple(int(v) for v in groups[1].split('.'))
+    while len(nums) > 1 and nums[-1] == 0:
+        nums = nums[:-1]
+
+    if not groups[0]:
+        epoch = 0
+    else:
+        epoch = int(groups[0])
+    pre = groups[4:6]
+    post = groups[7:9]
+    dev = groups[10:12]
+    local = groups[13]
+    if pre == (None, None):
+        pre = ()
+    else:
+        pre = pre[0], int(pre[1])
+    if post == (None, None):
+        post = ()
+    else:
+        post = post[0], int(post[1])
+    if dev == (None, None):
+        dev = ()
+    else:
+        dev = dev[0], int(dev[1])
+    if local is None:
+        local = ()
+    else:
+        parts = []
+        for part in local.split('.'):
+            # to ensure that numeric compares as > lexicographic, avoid
+            # comparing them directly, but encode a tuple which ensures
+            # correct sorting
+            if part.isdigit():
+                part = (1, int(part))
+            else:
+                part = (0, part)
+            parts.append(part)
+        local = tuple(parts)
+    if not pre:
+        # either before pre-release, or final release and after
+        if not post and dev:
+            # before pre-release
+            pre = ('a', -1)     # to sort before a0
+        else:
+            pre = ('z',)        # to sort after all pre-releases
+    # now look at the state of post and dev.
+    if not post:
+        post = ('_',)   # sort before 'a'
+    if not dev:
+        dev = ('final',)
+
+    #print('%s -> %s' % (s, m.groups()))
+    return epoch, nums, pre, post, dev, local
+
+
+_normalized_key = _pep_440_key
+
+
+class NormalizedVersion(Version):
+    """A rational version.
+
+    Good:
+        1.2         # equivalent to "1.2.0"
+        1.2.0
+        1.2a1
+        1.2.3a2
+        1.2.3b1
+        1.2.3c1
+        1.2.3.4
+        TODO: fill this out
+
+    Bad:
+        1           # minimum two numbers
+        1.2a        # release level must have a release serial
+        1.2.3b
+    """
+    def parse(self, s):
+        result = _normalized_key(s)
+        # _normalized_key loses trailing zeroes in the release
+        # clause, since that's needed to ensure that X.Y == X.Y.0 == X.Y.0.0
+        # However, PEP 440 prefix matching needs it: for example,
+        # (~= 1.4.5.0) matches differently to (~= 1.4.5.0.0).
+        m = PEP440_VERSION_RE.match(s)      # must succeed
+        groups = m.groups()
+        self._release_clause = tuple(int(v) for v in groups[1].split('.'))
+        return result
+
+    PREREL_TAGS = set(['a', 'b', 'c', 'rc', 'dev'])
+
+    @property
+    def is_prerelease(self):
+        return any(t[0] in self.PREREL_TAGS for t in self._parts if t)
+
+
+def _match_prefix(x, y):
+    x = str(x)
+    y = str(y)
+    if x == y:
+        return True
+    if not x.startswith(y):
+        return False
+    n = len(y)
+    return x[n] == '.'
+
+
+class NormalizedMatcher(Matcher):
+    version_class = NormalizedVersion
+
+    # value is either a callable or the name of a method
+    _operators = {
+        '~=': '_match_compatible',
+        '<': '_match_lt',
+        '>': '_match_gt',
+        '<=': '_match_le',
+        '>=': '_match_ge',
+        '==': '_match_eq',
+        '===': '_match_arbitrary',
+        '!=': '_match_ne',
+    }
+
+    def _adjust_local(self, version, constraint, prefix):
+        if prefix:
+            strip_local = '+' not in constraint and version._parts[-1]
+        else:
+            # both constraint and version are
+            # NormalizedVersion instances.
+            # If constraint does not have a local component,
+            # ensure the version doesn't, either.
+            strip_local = not constraint._parts[-1] and version._parts[-1]
+        if strip_local:
+            s = version._string.split('+', 1)[0]
+            version = self.version_class(s)
+        return version, constraint
+
+    def _match_lt(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if version >= constraint:
+            return False
+        release_clause = constraint._release_clause
+        pfx = '.'.join([str(i) for i in release_clause])
+        return not _match_prefix(version, pfx)
+
+    def _match_gt(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if version <= constraint:
+            return False
+        release_clause = constraint._release_clause
+        pfx = '.'.join([str(i) for i in release_clause])
+        return not _match_prefix(version, pfx)
+
+    def _match_le(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        return version <= constraint
+
+    def _match_ge(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        return version >= constraint
+
+    def _match_eq(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if not prefix:
+            result = (version == constraint)
+        else:
+            result = _match_prefix(version, constraint)
+        return result
+
+    def _match_arbitrary(self, version, constraint, prefix):
+        return str(version) == str(constraint)
+
+    def _match_ne(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if not prefix:
+            result = (version != constraint)
+        else:
+            result = not _match_prefix(version, constraint)
+        return result
+
+    def _match_compatible(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if version == constraint:
+            return True
+        if version < constraint:
+            return False
+#        if not prefix:
+#            return True
+        release_clause = constraint._release_clause
+        if len(release_clause) > 1:
+            release_clause = release_clause[:-1]
+        pfx = '.'.join([str(i) for i in release_clause])
+        return _match_prefix(version, pfx)
+
+_REPLACEMENTS = (
+    (re.compile('[.+-]$'), ''),                     # remove trailing puncts
+    (re.compile(r'^[.](\d)'), r'0.\1'),             # .N -> 0.N at start
+    (re.compile('^[.-]'), ''),                      # remove leading puncts
+    (re.compile(r'^\((.*)\)$'), r'\1'),             # remove parentheses
+    (re.compile(r'^v(ersion)?\s*(\d+)'), r'\2'),    # remove leading v(ersion)
+    (re.compile(r'^r(ev)?\s*(\d+)'), r'\2'),        # remove leading v(ersion)
+    (re.compile('[.]{2,}'), '.'),                   # multiple runs of '.'
+    (re.compile(r'\b(alfa|apha)\b'), 'alpha'),      # misspelt alpha
+    (re.compile(r'\b(pre-alpha|prealpha)\b'),
+                'pre.alpha'),                       # standardise
+    (re.compile(r'\(beta\)$'), 'beta'),             # remove parentheses
+)
+
+_SUFFIX_REPLACEMENTS = (
+    (re.compile('^[:~._+-]+'), ''),                   # remove leading puncts
+    (re.compile('[,*")([\\]]'), ''),                  # remove unwanted chars
+    (re.compile('[~:+_ -]'), '.'),                    # replace illegal chars
+    (re.compile('[.]{2,}'), '.'),                   # multiple runs of '.'
+    (re.compile(r'\.$'), ''),                       # trailing '.'
+)
+
+_NUMERIC_PREFIX = re.compile(r'(\d+(\.\d+)*)')
+
+
+def _suggest_semantic_version(s):
+    """
+    Try to suggest a semantic form for a version for which
+    _suggest_normalized_version couldn't come up with anything.
+    """
+    result = s.strip().lower()
+    for pat, repl in _REPLACEMENTS:
+        result = pat.sub(repl, result)
+    if not result:
+        result = '0.0.0'
+
+    # Now look for numeric prefix, and separate it out from
+    # the rest.
+    #import pdb; pdb.set_trace()
+    m = _NUMERIC_PREFIX.match(result)
+    if not m:
+        prefix = '0.0.0'
+        suffix = result
+    else:
+        prefix = m.groups()[0].split('.')
+        prefix = [int(i) for i in prefix]
+        while len(prefix) < 3:
+            prefix.append(0)
+        if len(prefix) == 3:
+            suffix = result[m.end():]
+        else:
+            suffix = '.'.join([str(i) for i in prefix[3:]]) + result[m.end():]
+            prefix = prefix[:3]
+        prefix = '.'.join([str(i) for i in prefix])
+        suffix = suffix.strip()
+    if suffix:
+        #import pdb; pdb.set_trace()
+        # massage the suffix.
+        for pat, repl in _SUFFIX_REPLACEMENTS:
+            suffix = pat.sub(repl, suffix)
+
+    if not suffix:
+        result = prefix
+    else:
+        sep = '-' if 'dev' in suffix else '+'
+        result = prefix + sep + suffix
+    if not is_semver(result):
+        result = None
+    return result
+
+
+def _suggest_normalized_version(s):
+    """Suggest a normalized version close to the given version string.
+
+    If you have a version string that isn't rational (i.e. NormalizedVersion
+    doesn't like it) then you might be able to get an equivalent (or close)
+    rational version from this function.
+
+    This does a number of simple normalizations to the given string, based
+    on observation of versions currently in use on PyPI. Given a dump of
+    those version during PyCon 2009, 4287 of them:
+    - 2312 (53.93%) match NormalizedVersion without change
+      with the automatic suggestion
+    - 3474 (81.04%) match when using this suggestion method
+
+    @param s {str} An irrational version string.
+    @returns A rational version string, or None, if couldn't determine one.
+    """
+    try:
+        _normalized_key(s)
+        return s   # already rational
+    except UnsupportedVersionError:
+        pass
+
+    rs = s.lower()
+
+    # part of this could use maketrans
+    for orig, repl in (('-alpha', 'a'), ('-beta', 'b'), ('alpha', 'a'),
+                       ('beta', 'b'), ('rc', 'c'), ('-final', ''),
+                       ('-pre', 'c'),
+                       ('-release', ''), ('.release', ''), ('-stable', ''),
+                       ('+', '.'), ('_', '.'), (' ', ''), ('.final', ''),
+                       ('final', '')):
+        rs = rs.replace(orig, repl)
+
+    # if something ends with dev or pre, we add a 0
+    rs = re.sub(r"pre$", r"pre0", rs)
+    rs = re.sub(r"dev$", r"dev0", rs)
+
+    # if we have something like "b-2" or "a.2" at the end of the
+    # version, that is probably beta, alpha, etc
+    # let's remove the dash or dot
+    rs = re.sub(r"([abc]|rc)[\-\.](\d+)$", r"\1\2", rs)
+
+    # 1.0-dev-r371 -> 1.0.dev371
+    # 0.1-dev-r79 -> 0.1.dev79
+    rs = re.sub(r"[\-\.](dev)[\-\.]?r?(\d+)$", r".\1\2", rs)
+
+    # Clean: 2.0.a.3, 2.0.b1, 0.9.0~c1
+    rs = re.sub(r"[.~]?([abc])\.?", r"\1", rs)
+
+    # Clean: v0.3, v1.0
+    if rs.startswith('v'):
+        rs = rs[1:]
+
+    # Clean leading '0's on numbers.
+    #TODO: unintended side-effect on, e.g., "2003.05.09"
+    # PyPI stats: 77 (~2%) better
+    rs = re.sub(r"\b0+(\d+)(?!\d)", r"\1", rs)
+
+    # Clean a/b/c with no version. E.g. "1.0a" -> "1.0a0". Setuptools infers
+    # zero.
+    # PyPI stats: 245 (7.56%) better
+    rs = re.sub(r"(\d+[abc])$", r"\g<1>0", rs)
+
+    # the 'dev-rNNN' tag is a dev tag
+    rs = re.sub(r"\.?(dev-r|dev\.r)\.?(\d+)$", r".dev\2", rs)
+
+    # clean the - when used as a pre delimiter
+    rs = re.sub(r"-(a|b|c)(\d+)$", r"\1\2", rs)
+
+    # a terminal "dev" or "devel" can be changed into ".dev0"
+    rs = re.sub(r"[\.\-](dev|devel)$", r".dev0", rs)
+
+    # a terminal "dev" can be changed into ".dev0"
+    rs = re.sub(r"(?![\.\-])dev$", r".dev0", rs)
+
+    # a terminal "final" or "stable" can be removed
+    rs = re.sub(r"(final|stable)$", "", rs)
+
+    # The 'r' and the '-' tags are post release tags
+    #   0.4a1.r10       ->  0.4a1.post10
+    #   0.9.33-17222    ->  0.9.33.post17222
+    #   0.9.33-r17222   ->  0.9.33.post17222
+    rs = re.sub(r"\.?(r|-|-r)\.?(\d+)$", r".post\2", rs)
+
+    # Clean 'r' instead of 'dev' usage:
+    #   0.9.33+r17222   ->  0.9.33.dev17222
+    #   1.0dev123       ->  1.0.dev123
+    #   1.0.git123      ->  1.0.dev123
+    #   1.0.bzr123      ->  1.0.dev123
+    #   0.1a0dev.123    ->  0.1a0.dev123
+    # PyPI stats:  ~150 (~4%) better
+    rs = re.sub(r"\.?(dev|git|bzr)\.?(\d+)$", r".dev\2", rs)
+
+    # Clean '.pre' (normalized from '-pre' above) instead of 'c' usage:
+    #   0.2.pre1        ->  0.2c1
+    #   0.2-c1         ->  0.2c1
+    #   1.0preview123   ->  1.0c123
+    # PyPI stats: ~21 (0.62%) better
+    rs = re.sub(r"\.?(pre|preview|-c)(\d+)$", r"c\g<2>", rs)
+
+    # Tcl/Tk uses "px" for their post release markers
+    rs = re.sub(r"p(\d+)$", r".post\1", rs)
+
+    try:
+        _normalized_key(rs)
+    except UnsupportedVersionError:
+        rs = None
+    return rs
+
+#
+#   Legacy version processing (distribute-compatible)
+#
+
+_VERSION_PART = re.compile(r'([a-z]+|\d+|[\.-])', re.I)
+_VERSION_REPLACE = {
+    'pre': 'c',
+    'preview': 'c',
+    '-': 'final-',
+    'rc': 'c',
+    'dev': '@',
+    '': None,
+    '.': None,
+}
+
+
+def _legacy_key(s):
+    def get_parts(s):
+        result = []
+        for p in _VERSION_PART.split(s.lower()):
+            p = _VERSION_REPLACE.get(p, p)
+            if p:
+                if '0' <= p[:1] <= '9':
+                    p = p.zfill(8)
+                else:
+                    p = '*' + p
+                result.append(p)
+        result.append('*final')
+        return result
+
+    result = []
+    for p in get_parts(s):
+        if p.startswith('*'):
+            if p < '*final':
+                while result and result[-1] == '*final-':
+                    result.pop()
+            while result and result[-1] == '00000000':
+                result.pop()
+        result.append(p)
+    return tuple(result)
+
+
+class LegacyVersion(Version):
+    def parse(self, s):
+        return _legacy_key(s)
+
+    @property
+    def is_prerelease(self):
+        result = False
+        for x in self._parts:
+            if (isinstance(x, string_types) and x.startswith('*') and
+                x < '*final'):
+                result = True
+                break
+        return result
+
+
+class LegacyMatcher(Matcher):
+    version_class = LegacyVersion
+
+    _operators = dict(Matcher._operators)
+    _operators['~='] = '_match_compatible'
+
+    numeric_re = re.compile(r'^(\d+(\.\d+)*)')
+
+    def _match_compatible(self, version, constraint, prefix):
+        if version < constraint:
+            return False
+        m = self.numeric_re.match(str(constraint))
+        if not m:
+            logger.warning('Cannot compute compatible match for version %s '
+                           ' and constraint %s', version, constraint)
+            return True
+        s = m.groups()[0]
+        if '.' in s:
+            s = s.rsplit('.', 1)[0]
+        return _match_prefix(version, s)
+
+#
+#   Semantic versioning
+#
+
+_SEMVER_RE = re.compile(r'^(\d+)\.(\d+)\.(\d+)'
+                        r'(-[a-z0-9]+(\.[a-z0-9-]+)*)?'
+                        r'(\+[a-z0-9]+(\.[a-z0-9-]+)*)?$', re.I)
+
+
+def is_semver(s):
+    return _SEMVER_RE.match(s)
+
+
+def _semantic_key(s):
+    def make_tuple(s, absent):
+        if s is None:
+            result = (absent,)
+        else:
+            parts = s[1:].split('.')
+            # We can't compare ints and strings on Python 3, so fudge it
+            # by zero-filling numeric values so simulate a numeric comparison
+            result = tuple([p.zfill(8) if p.isdigit() else p for p in parts])
+        return result
+
+    m = is_semver(s)
+    if not m:
+        raise UnsupportedVersionError(s)
+    groups = m.groups()
+    major, minor, patch = [int(i) for i in groups[:3]]
+    # choose the '|' and '*' so that versions sort correctly
+    pre, build = make_tuple(groups[3], '|'), make_tuple(groups[5], '*')
+    return (major, minor, patch), pre, build
+
+
+class SemanticVersion(Version):
+    def parse(self, s):
+        return _semantic_key(s)
+
+    @property
+    def is_prerelease(self):
+        return self._parts[1][0] != '|'
+
+
+class SemanticMatcher(Matcher):
+    version_class = SemanticVersion
+
+
+class VersionScheme(object):
+    def __init__(self, key, matcher, suggester=None):
+        self.key = key
+        self.matcher = matcher
+        self.suggester = suggester
+
+    def is_valid_version(self, s):
+        try:
+            self.matcher.version_class(s)
+            result = True
+        except UnsupportedVersionError:
+            result = False
+        return result
+
+    def is_valid_matcher(self, s):
+        try:
+            self.matcher(s)
+            result = True
+        except UnsupportedVersionError:
+            result = False
+        return result
+
+    def is_valid_constraint_list(self, s):
+        """
+        Used for processing some metadata fields
+        """
+        return self.is_valid_matcher('dummy_name (%s)' % s)
+
+    def suggest(self, s):
+        if self.suggester is None:
+            result = None
+        else:
+            result = self.suggester(s)
+        return result
+
+_SCHEMES = {
+    'normalized': VersionScheme(_normalized_key, NormalizedMatcher,
+                                _suggest_normalized_version),
+    'legacy': VersionScheme(_legacy_key, LegacyMatcher, lambda self, s: s),
+    'semantic': VersionScheme(_semantic_key, SemanticMatcher,
+                              _suggest_semantic_version),
+}
+
+_SCHEMES['default'] = _SCHEMES['normalized']
+
+
+def get_scheme(name):
+    if name not in _SCHEMES:
+        raise ValueError('unknown scheme name: %r' % name)
+    return _SCHEMES[name]
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/w32.exe b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/w32.exe
new file mode 100644
index 0000000..e6439e9
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/w32.exe differ
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/w64.exe b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/w64.exe
new file mode 100644
index 0000000..46139db
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/w64.exe differ
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/wheel.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/wheel.py
new file mode 100644
index 0000000..1e2c7a0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distlib/wheel.py
@@ -0,0 +1,1018 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013-2017 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+from __future__ import unicode_literals
+
+import base64
+import codecs
+import datetime
+import distutils.util
+from email import message_from_file
+import hashlib
+import imp
+import json
+import logging
+import os
+import posixpath
+import re
+import shutil
+import sys
+import tempfile
+import zipfile
+
+from . import __version__, DistlibException
+from .compat import sysconfig, ZipFile, fsdecode, text_type, filter
+from .database import InstalledDistribution
+from .metadata import (Metadata, METADATA_FILENAME, WHEEL_METADATA_FILENAME,
+                       LEGACY_METADATA_FILENAME)
+from .util import (FileOperator, convert_path, CSVReader, CSVWriter, Cache,
+                   cached_property, get_cache_base, read_exports, tempdir)
+from .version import NormalizedVersion, UnsupportedVersionError
+
+logger = logging.getLogger(__name__)
+
+cache = None    # created when needed
+
+if hasattr(sys, 'pypy_version_info'):  # pragma: no cover
+    IMP_PREFIX = 'pp'
+elif sys.platform.startswith('java'):  # pragma: no cover
+    IMP_PREFIX = 'jy'
+elif sys.platform == 'cli':  # pragma: no cover
+    IMP_PREFIX = 'ip'
+else:
+    IMP_PREFIX = 'cp'
+
+VER_SUFFIX = sysconfig.get_config_var('py_version_nodot')
+if not VER_SUFFIX:   # pragma: no cover
+    VER_SUFFIX = '%s%s' % sys.version_info[:2]
+PYVER = 'py' + VER_SUFFIX
+IMPVER = IMP_PREFIX + VER_SUFFIX
+
+ARCH = distutils.util.get_platform().replace('-', '_').replace('.', '_')
+
+ABI = sysconfig.get_config_var('SOABI')
+if ABI and ABI.startswith('cpython-'):
+    ABI = ABI.replace('cpython-', 'cp')
+else:
+    def _derive_abi():
+        parts = ['cp', VER_SUFFIX]
+        if sysconfig.get_config_var('Py_DEBUG'):
+            parts.append('d')
+        if sysconfig.get_config_var('WITH_PYMALLOC'):
+            parts.append('m')
+        if sysconfig.get_config_var('Py_UNICODE_SIZE') == 4:
+            parts.append('u')
+        return ''.join(parts)
+    ABI = _derive_abi()
+    del _derive_abi
+
+FILENAME_RE = re.compile(r'''
+(?P<nm>[^-]+)
+-(?P<vn>\d+[^-]*)
+(-(?P<bn>\d+[^-]*))?
+-(?P<py>\w+\d+(\.\w+\d+)*)
+-(?P<bi>\w+)
+-(?P<ar>\w+(\.\w+)*)
+\.whl$
+''', re.IGNORECASE | re.VERBOSE)
+
+NAME_VERSION_RE = re.compile(r'''
+(?P<nm>[^-]+)
+-(?P<vn>\d+[^-]*)
+(-(?P<bn>\d+[^-]*))?$
+''', re.IGNORECASE | re.VERBOSE)
+
+SHEBANG_RE = re.compile(br'\s*#![^\r\n]*')
+SHEBANG_DETAIL_RE = re.compile(br'^(\s*#!("[^"]+"|\S+))\s+(.*)$')
+SHEBANG_PYTHON = b'#!python'
+SHEBANG_PYTHONW = b'#!pythonw'
+
+if os.sep == '/':
+    to_posix = lambda o: o
+else:
+    to_posix = lambda o: o.replace(os.sep, '/')
+
+
+class Mounter(object):
+    def __init__(self):
+        self.impure_wheels = {}
+        self.libs = {}
+
+    def add(self, pathname, extensions):
+        self.impure_wheels[pathname] = extensions
+        self.libs.update(extensions)
+
+    def remove(self, pathname):
+        extensions = self.impure_wheels.pop(pathname)
+        for k, v in extensions:
+            if k in self.libs:
+                del self.libs[k]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.libs:
+            result = self
+        else:
+            result = None
+        return result
+
+    def load_module(self, fullname):
+        if fullname in sys.modules:
+            result = sys.modules[fullname]
+        else:
+            if fullname not in self.libs:
+                raise ImportError('unable to find extension for %s' % fullname)
+            result = imp.load_dynamic(fullname, self.libs[fullname])
+            result.__loader__ = self
+            parts = fullname.rsplit('.', 1)
+            if len(parts) > 1:
+                result.__package__ = parts[0]
+        return result
+
+_hook = Mounter()
+
+
+class Wheel(object):
+    """
+    Class to build and install from Wheel files (PEP 427).
+    """
+
+    wheel_version = (1, 1)
+    hash_kind = 'sha256'
+
+    def __init__(self, filename=None, sign=False, verify=False):
+        """
+        Initialise an instance using a (valid) filename.
+        """
+        self.sign = sign
+        self.should_verify = verify
+        self.buildver = ''
+        self.pyver = [PYVER]
+        self.abi = ['none']
+        self.arch = ['any']
+        self.dirname = os.getcwd()
+        if filename is None:
+            self.name = 'dummy'
+            self.version = '0.1'
+            self._filename = self.filename
+        else:
+            m = NAME_VERSION_RE.match(filename)
+            if m:
+                info = m.groupdict('')
+                self.name = info['nm']
+                # Reinstate the local version separator
+                self.version = info['vn'].replace('_', '-')
+                self.buildver = info['bn']
+                self._filename = self.filename
+            else:
+                dirname, filename = os.path.split(filename)
+                m = FILENAME_RE.match(filename)
+                if not m:
+                    raise DistlibException('Invalid name or '
+                                           'filename: %r' % filename)
+                if dirname:
+                    self.dirname = os.path.abspath(dirname)
+                self._filename = filename
+                info = m.groupdict('')
+                self.name = info['nm']
+                self.version = info['vn']
+                self.buildver = info['bn']
+                self.pyver = info['py'].split('.')
+                self.abi = info['bi'].split('.')
+                self.arch = info['ar'].split('.')
+
+    @property
+    def filename(self):
+        """
+        Build and return a filename from the various components.
+        """
+        if self.buildver:
+            buildver = '-' + self.buildver
+        else:
+            buildver = ''
+        pyver = '.'.join(self.pyver)
+        abi = '.'.join(self.abi)
+        arch = '.'.join(self.arch)
+        # replace - with _ as a local version separator
+        version = self.version.replace('-', '_')
+        return '%s-%s%s-%s-%s-%s.whl' % (self.name, version, buildver,
+                                         pyver, abi, arch)
+
+    @property
+    def exists(self):
+        path = os.path.join(self.dirname, self.filename)
+        return os.path.isfile(path)
+
+    @property
+    def tags(self):
+        for pyver in self.pyver:
+            for abi in self.abi:
+                for arch in self.arch:
+                    yield pyver, abi, arch
+
+    @cached_property
+    def metadata(self):
+        pathname = os.path.join(self.dirname, self.filename)
+        name_ver = '%s-%s' % (self.name, self.version)
+        info_dir = '%s.dist-info' % name_ver
+        wrapper = codecs.getreader('utf-8')
+        with ZipFile(pathname, 'r') as zf:
+            wheel_metadata = self.get_wheel_metadata(zf)
+            wv = wheel_metadata['Wheel-Version'].split('.', 1)
+            file_version = tuple([int(i) for i in wv])
+            # if file_version < (1, 1):
+                # fns = [WHEEL_METADATA_FILENAME, METADATA_FILENAME,
+                       # LEGACY_METADATA_FILENAME]
+            # else:
+                # fns = [WHEEL_METADATA_FILENAME, METADATA_FILENAME]
+            fns = [WHEEL_METADATA_FILENAME, LEGACY_METADATA_FILENAME]
+            result = None
+            for fn in fns:
+                try:
+                    metadata_filename = posixpath.join(info_dir, fn)
+                    with zf.open(metadata_filename) as bf:
+                        wf = wrapper(bf)
+                        result = Metadata(fileobj=wf)
+                        if result:
+                            break
+                except KeyError:
+                    pass
+            if not result:
+                raise ValueError('Invalid wheel, because metadata is '
+                                 'missing: looked in %s' % ', '.join(fns))
+        return result
+
+    def get_wheel_metadata(self, zf):
+        name_ver = '%s-%s' % (self.name, self.version)
+        info_dir = '%s.dist-info' % name_ver
+        metadata_filename = posixpath.join(info_dir, 'WHEEL')
+        with zf.open(metadata_filename) as bf:
+            wf = codecs.getreader('utf-8')(bf)
+            message = message_from_file(wf)
+        return dict(message)
+
+    @cached_property
+    def info(self):
+        pathname = os.path.join(self.dirname, self.filename)
+        with ZipFile(pathname, 'r') as zf:
+            result = self.get_wheel_metadata(zf)
+        return result
+
+    def process_shebang(self, data):
+        m = SHEBANG_RE.match(data)
+        if m:
+            end = m.end()
+            shebang, data_after_shebang = data[:end], data[end:]
+            # Preserve any arguments after the interpreter
+            if b'pythonw' in shebang.lower():
+                shebang_python = SHEBANG_PYTHONW
+            else:
+                shebang_python = SHEBANG_PYTHON
+            m = SHEBANG_DETAIL_RE.match(shebang)
+            if m:
+                args = b' ' + m.groups()[-1]
+            else:
+                args = b''
+            shebang = shebang_python + args
+            data = shebang + data_after_shebang
+        else:
+            cr = data.find(b'\r')
+            lf = data.find(b'\n')
+            if cr < 0 or cr > lf:
+                term = b'\n'
+            else:
+                if data[cr:cr + 2] == b'\r\n':
+                    term = b'\r\n'
+                else:
+                    term = b'\r'
+            data = SHEBANG_PYTHON + term + data
+        return data
+
+    def get_hash(self, data, hash_kind=None):
+        if hash_kind is None:
+            hash_kind = self.hash_kind
+        try:
+            hasher = getattr(hashlib, hash_kind)
+        except AttributeError:
+            raise DistlibException('Unsupported hash algorithm: %r' % hash_kind)
+        result = hasher(data).digest()
+        result = base64.urlsafe_b64encode(result).rstrip(b'=').decode('ascii')
+        return hash_kind, result
+
+    def write_record(self, records, record_path, base):
+        records = list(records) # make a copy, as mutated
+        p = to_posix(os.path.relpath(record_path, base))
+        records.append((p, '', ''))
+        with CSVWriter(record_path) as writer:
+            for row in records:
+                writer.writerow(row)
+
+    def write_records(self, info, libdir, archive_paths):
+        records = []
+        distinfo, info_dir = info
+        hasher = getattr(hashlib, self.hash_kind)
+        for ap, p in archive_paths:
+            with open(p, 'rb') as f:
+                data = f.read()
+            digest = '%s=%s' % self.get_hash(data)
+            size = os.path.getsize(p)
+            records.append((ap, digest, size))
+
+        p = os.path.join(distinfo, 'RECORD')
+        self.write_record(records, p, libdir)
+        ap = to_posix(os.path.join(info_dir, 'RECORD'))
+        archive_paths.append((ap, p))
+
+    def build_zip(self, pathname, archive_paths):
+        with ZipFile(pathname, 'w', zipfile.ZIP_DEFLATED) as zf:
+            for ap, p in archive_paths:
+                logger.debug('Wrote %s to %s in wheel', p, ap)
+                zf.write(p, ap)
+
+    def build(self, paths, tags=None, wheel_version=None):
+        """
+        Build a wheel from files in specified paths, and use any specified tags
+        when determining the name of the wheel.
+        """
+        if tags is None:
+            tags = {}
+
+        libkey = list(filter(lambda o: o in paths, ('purelib', 'platlib')))[0]
+        if libkey == 'platlib':
+            is_pure = 'false'
+            default_pyver = [IMPVER]
+            default_abi = [ABI]
+            default_arch = [ARCH]
+        else:
+            is_pure = 'true'
+            default_pyver = [PYVER]
+            default_abi = ['none']
+            default_arch = ['any']
+
+        self.pyver = tags.get('pyver', default_pyver)
+        self.abi = tags.get('abi', default_abi)
+        self.arch = tags.get('arch', default_arch)
+
+        libdir = paths[libkey]
+
+        name_ver = '%s-%s' % (self.name, self.version)
+        data_dir = '%s.data' % name_ver
+        info_dir = '%s.dist-info' % name_ver
+
+        archive_paths = []
+
+        # First, stuff which is not in site-packages
+        for key in ('data', 'headers', 'scripts'):
+            if key not in paths:
+                continue
+            path = paths[key]
+            if os.path.isdir(path):
+                for root, dirs, files in os.walk(path):
+                    for fn in files:
+                        p = fsdecode(os.path.join(root, fn))
+                        rp = os.path.relpath(p, path)
+                        ap = to_posix(os.path.join(data_dir, key, rp))
+                        archive_paths.append((ap, p))
+                        if key == 'scripts' and not p.endswith('.exe'):
+                            with open(p, 'rb') as f:
+                                data = f.read()
+                            data = self.process_shebang(data)
+                            with open(p, 'wb') as f:
+                                f.write(data)
+
+        # Now, stuff which is in site-packages, other than the
+        # distinfo stuff.
+        path = libdir
+        distinfo = None
+        for root, dirs, files in os.walk(path):
+            if root == path:
+                # At the top level only, save distinfo for later
+                # and skip it for now
+                for i, dn in enumerate(dirs):
+                    dn = fsdecode(dn)
+                    if dn.endswith('.dist-info'):
+                        distinfo = os.path.join(root, dn)
+                        del dirs[i]
+                        break
+                assert distinfo, '.dist-info directory expected, not found'
+
+            for fn in files:
+                # comment out next suite to leave .pyc files in
+                if fsdecode(fn).endswith(('.pyc', '.pyo')):
+                    continue
+                p = os.path.join(root, fn)
+                rp = to_posix(os.path.relpath(p, path))
+                archive_paths.append((rp, p))
+
+        # Now distinfo. Assumed to be flat, i.e. os.listdir is enough.
+        files = os.listdir(distinfo)
+        for fn in files:
+            if fn not in ('RECORD', 'INSTALLER', 'SHARED', 'WHEEL'):
+                p = fsdecode(os.path.join(distinfo, fn))
+                ap = to_posix(os.path.join(info_dir, fn))
+                archive_paths.append((ap, p))
+
+        wheel_metadata = [
+            'Wheel-Version: %d.%d' % (wheel_version or self.wheel_version),
+            'Generator: distlib %s' % __version__,
+            'Root-Is-Purelib: %s' % is_pure,
+        ]
+        for pyver, abi, arch in self.tags:
+            wheel_metadata.append('Tag: %s-%s-%s' % (pyver, abi, arch))
+        p = os.path.join(distinfo, 'WHEEL')
+        with open(p, 'w') as f:
+            f.write('\n'.join(wheel_metadata))
+        ap = to_posix(os.path.join(info_dir, 'WHEEL'))
+        archive_paths.append((ap, p))
+
+        # sort the entries by archive path. Not needed by any spec, but it
+        # keeps the archive listing and RECORD tidier than they would otherwise
+        # be. Use the number of path segments to keep directory entries together,
+        # and keep the dist-info stuff at the end.
+        def sorter(t):
+            ap = t[0]
+            n = ap.count('/')
+            if '.dist-info' in ap:
+                n += 10000
+            return (n, ap)
+        archive_paths = sorted(archive_paths, key=sorter)
+
+        # Now, at last, RECORD.
+        # Paths in here are archive paths - nothing else makes sense.
+        self.write_records((distinfo, info_dir), libdir, archive_paths)
+        # Now, ready to build the zip file
+        pathname = os.path.join(self.dirname, self.filename)
+        self.build_zip(pathname, archive_paths)
+        return pathname
+
+    def skip_entry(self, arcname):
+        """
+        Determine whether an archive entry should be skipped when verifying
+        or installing.
+        """
+        # The signature file won't be in RECORD,
+        # and we  don't currently don't do anything with it
+        # We also skip directories, as they won't be in RECORD
+        # either. See:
+        #
+        # https://github.com/pypa/wheel/issues/294
+        # https://github.com/pypa/wheel/issues/287
+        # https://github.com/pypa/wheel/pull/289
+        #
+        return arcname.endswith(('/', '/RECORD.jws'))
+
+    def install(self, paths, maker, **kwargs):
+        """
+        Install a wheel to the specified paths. If kwarg ``warner`` is
+        specified, it should be a callable, which will be called with two
+        tuples indicating the wheel version of this software and the wheel
+        version in the file, if there is a discrepancy in the versions.
+        This can be used to issue any warnings to raise any exceptions.
+        If kwarg ``lib_only`` is True, only the purelib/platlib files are
+        installed, and the headers, scripts, data and dist-info metadata are
+        not written. If kwarg ``bytecode_hashed_invalidation`` is True, written
+        bytecode will try to use file-hash based invalidation (PEP-552) on
+        supported interpreter versions (CPython 2.7+).
+
+        The return value is a :class:`InstalledDistribution` instance unless
+        ``options.lib_only`` is True, in which case the return value is ``None``.
+        """
+
+        dry_run = maker.dry_run
+        warner = kwargs.get('warner')
+        lib_only = kwargs.get('lib_only', False)
+        bc_hashed_invalidation = kwargs.get('bytecode_hashed_invalidation', False)
+
+        pathname = os.path.join(self.dirname, self.filename)
+        name_ver = '%s-%s' % (self.name, self.version)
+        data_dir = '%s.data' % name_ver
+        info_dir = '%s.dist-info' % name_ver
+
+        metadata_name = posixpath.join(info_dir, LEGACY_METADATA_FILENAME)
+        wheel_metadata_name = posixpath.join(info_dir, 'WHEEL')
+        record_name = posixpath.join(info_dir, 'RECORD')
+
+        wrapper = codecs.getreader('utf-8')
+
+        with ZipFile(pathname, 'r') as zf:
+            with zf.open(wheel_metadata_name) as bwf:
+                wf = wrapper(bwf)
+                message = message_from_file(wf)
+            wv = message['Wheel-Version'].split('.', 1)
+            file_version = tuple([int(i) for i in wv])
+            if (file_version != self.wheel_version) and warner:
+                warner(self.wheel_version, file_version)
+
+            if message['Root-Is-Purelib'] == 'true':
+                libdir = paths['purelib']
+            else:
+                libdir = paths['platlib']
+
+            records = {}
+            with zf.open(record_name) as bf:
+                with CSVReader(stream=bf) as reader:
+                    for row in reader:
+                        p = row[0]
+                        records[p] = row
+
+            data_pfx = posixpath.join(data_dir, '')
+            info_pfx = posixpath.join(info_dir, '')
+            script_pfx = posixpath.join(data_dir, 'scripts', '')
+
+            # make a new instance rather than a copy of maker's,
+            # as we mutate it
+            fileop = FileOperator(dry_run=dry_run)
+            fileop.record = True    # so we can rollback if needed
+
+            bc = not sys.dont_write_bytecode    # Double negatives. Lovely!
+
+            outfiles = []   # for RECORD writing
+
+            # for script copying/shebang processing
+            workdir = tempfile.mkdtemp()
+            # set target dir later
+            # we default add_launchers to False, as the
+            # Python Launcher should be used instead
+            maker.source_dir = workdir
+            maker.target_dir = None
+            try:
+                for zinfo in zf.infolist():
+                    arcname = zinfo.filename
+                    if isinstance(arcname, text_type):
+                        u_arcname = arcname
+                    else:
+                        u_arcname = arcname.decode('utf-8')
+                    if self.skip_entry(u_arcname):
+                        continue
+                    row = records[u_arcname]
+                    if row[2] and str(zinfo.file_size) != row[2]:
+                        raise DistlibException('size mismatch for '
+                                               '%s' % u_arcname)
+                    if row[1]:
+                        kind, value = row[1].split('=', 1)
+                        with zf.open(arcname) as bf:
+                            data = bf.read()
+                        _, digest = self.get_hash(data, kind)
+                        if digest != value:
+                            raise DistlibException('digest mismatch for '
+                                                   '%s' % arcname)
+
+                    if lib_only and u_arcname.startswith((info_pfx, data_pfx)):
+                        logger.debug('lib_only: skipping %s', u_arcname)
+                        continue
+                    is_script = (u_arcname.startswith(script_pfx)
+                                 and not u_arcname.endswith('.exe'))
+
+                    if u_arcname.startswith(data_pfx):
+                        _, where, rp = u_arcname.split('/', 2)
+                        outfile = os.path.join(paths[where], convert_path(rp))
+                    else:
+                        # meant for site-packages.
+                        if u_arcname in (wheel_metadata_name, record_name):
+                            continue
+                        outfile = os.path.join(libdir, convert_path(u_arcname))
+                    if not is_script:
+                        with zf.open(arcname) as bf:
+                            fileop.copy_stream(bf, outfile)
+                        outfiles.append(outfile)
+                        # Double check the digest of the written file
+                        if not dry_run and row[1]:
+                            with open(outfile, 'rb') as bf:
+                                data = bf.read()
+                                _, newdigest = self.get_hash(data, kind)
+                                if newdigest != digest:
+                                    raise DistlibException('digest mismatch '
+                                                           'on write for '
+                                                           '%s' % outfile)
+                        if bc and outfile.endswith('.py'):
+                            try:
+                                pyc = fileop.byte_compile(outfile,
+                                                          hashed_invalidation=bc_hashed_invalidation)
+                                outfiles.append(pyc)
+                            except Exception:
+                                # Don't give up if byte-compilation fails,
+                                # but log it and perhaps warn the user
+                                logger.warning('Byte-compilation failed',
+                                               exc_info=True)
+                    else:
+                        fn = os.path.basename(convert_path(arcname))
+                        workname = os.path.join(workdir, fn)
+                        with zf.open(arcname) as bf:
+                            fileop.copy_stream(bf, workname)
+
+                        dn, fn = os.path.split(outfile)
+                        maker.target_dir = dn
+                        filenames = maker.make(fn)
+                        fileop.set_executable_mode(filenames)
+                        outfiles.extend(filenames)
+
+                if lib_only:
+                    logger.debug('lib_only: returning None')
+                    dist = None
+                else:
+                    # Generate scripts
+
+                    # Try to get pydist.json so we can see if there are
+                    # any commands to generate. If this fails (e.g. because
+                    # of a legacy wheel), log a warning but don't give up.
+                    commands = None
+                    file_version = self.info['Wheel-Version']
+                    if file_version == '1.0':
+                        # Use legacy info
+                        ep = posixpath.join(info_dir, 'entry_points.txt')
+                        try:
+                            with zf.open(ep) as bwf:
+                                epdata = read_exports(bwf)
+                            commands = {}
+                            for key in ('console', 'gui'):
+                                k = '%s_scripts' % key
+                                if k in epdata:
+                                    commands['wrap_%s' % key] = d = {}
+                                    for v in epdata[k].values():
+                                        s = '%s:%s' % (v.prefix, v.suffix)
+                                        if v.flags:
+                                            s += ' [%s]' % ','.join(v.flags)
+                                        d[v.name] = s
+                        except Exception:
+                            logger.warning('Unable to read legacy script '
+                                           'metadata, so cannot generate '
+                                           'scripts')
+                    else:
+                        try:
+                            with zf.open(metadata_name) as bwf:
+                                wf = wrapper(bwf)
+                                commands = json.load(wf).get('extensions')
+                                if commands:
+                                    commands = commands.get('python.commands')
+                        except Exception:
+                            logger.warning('Unable to read JSON metadata, so '
+                                           'cannot generate scripts')
+                    if commands:
+                        console_scripts = commands.get('wrap_console', {})
+                        gui_scripts = commands.get('wrap_gui', {})
+                        if console_scripts or gui_scripts:
+                            script_dir = paths.get('scripts', '')
+                            if not os.path.isdir(script_dir):
+                                raise ValueError('Valid script path not '
+                                                 'specified')
+                            maker.target_dir = script_dir
+                            for k, v in console_scripts.items():
+                                script = '%s = %s' % (k, v)
+                                filenames = maker.make(script)
+                                fileop.set_executable_mode(filenames)
+
+                            if gui_scripts:
+                                options = {'gui': True }
+                                for k, v in gui_scripts.items():
+                                    script = '%s = %s' % (k, v)
+                                    filenames = maker.make(script, options)
+                                    fileop.set_executable_mode(filenames)
+
+                    p = os.path.join(libdir, info_dir)
+                    dist = InstalledDistribution(p)
+
+                    # Write SHARED
+                    paths = dict(paths)     # don't change passed in dict
+                    del paths['purelib']
+                    del paths['platlib']
+                    paths['lib'] = libdir
+                    p = dist.write_shared_locations(paths, dry_run)
+                    if p:
+                        outfiles.append(p)
+
+                    # Write RECORD
+                    dist.write_installed_files(outfiles, paths['prefix'],
+                                               dry_run)
+                return dist
+            except Exception:  # pragma: no cover
+                logger.exception('installation failed.')
+                fileop.rollback()
+                raise
+            finally:
+                shutil.rmtree(workdir)
+
+    def _get_dylib_cache(self):
+        global cache
+        if cache is None:
+            # Use native string to avoid issues on 2.x: see Python #20140.
+            base = os.path.join(get_cache_base(), str('dylib-cache'),
+                                '%s.%s' % sys.version_info[:2])
+            cache = Cache(base)
+        return cache
+
+    def _get_extensions(self):
+        pathname = os.path.join(self.dirname, self.filename)
+        name_ver = '%s-%s' % (self.name, self.version)
+        info_dir = '%s.dist-info' % name_ver
+        arcname = posixpath.join(info_dir, 'EXTENSIONS')
+        wrapper = codecs.getreader('utf-8')
+        result = []
+        with ZipFile(pathname, 'r') as zf:
+            try:
+                with zf.open(arcname) as bf:
+                    wf = wrapper(bf)
+                    extensions = json.load(wf)
+                    cache = self._get_dylib_cache()
+                    prefix = cache.prefix_to_dir(pathname)
+                    cache_base = os.path.join(cache.base, prefix)
+                    if not os.path.isdir(cache_base):
+                        os.makedirs(cache_base)
+                    for name, relpath in extensions.items():
+                        dest = os.path.join(cache_base, convert_path(relpath))
+                        if not os.path.exists(dest):
+                            extract = True
+                        else:
+                            file_time = os.stat(dest).st_mtime
+                            file_time = datetime.datetime.fromtimestamp(file_time)
+                            info = zf.getinfo(relpath)
+                            wheel_time = datetime.datetime(*info.date_time)
+                            extract = wheel_time > file_time
+                        if extract:
+                            zf.extract(relpath, cache_base)
+                        result.append((name, dest))
+            except KeyError:
+                pass
+        return result
+
+    def is_compatible(self):
+        """
+        Determine if a wheel is compatible with the running system.
+        """
+        return is_compatible(self)
+
+    def is_mountable(self):
+        """
+        Determine if a wheel is asserted as mountable by its metadata.
+        """
+        return True # for now - metadata details TBD
+
+    def mount(self, append=False):
+        pathname = os.path.abspath(os.path.join(self.dirname, self.filename))
+        if not self.is_compatible():
+            msg = 'Wheel %s not compatible with this Python.' % pathname
+            raise DistlibException(msg)
+        if not self.is_mountable():
+            msg = 'Wheel %s is marked as not mountable.' % pathname
+            raise DistlibException(msg)
+        if pathname in sys.path:
+            logger.debug('%s already in path', pathname)
+        else:
+            if append:
+                sys.path.append(pathname)
+            else:
+                sys.path.insert(0, pathname)
+            extensions = self._get_extensions()
+            if extensions:
+                if _hook not in sys.meta_path:
+                    sys.meta_path.append(_hook)
+                _hook.add(pathname, extensions)
+
+    def unmount(self):
+        pathname = os.path.abspath(os.path.join(self.dirname, self.filename))
+        if pathname not in sys.path:
+            logger.debug('%s not in path', pathname)
+        else:
+            sys.path.remove(pathname)
+            if pathname in _hook.impure_wheels:
+                _hook.remove(pathname)
+            if not _hook.impure_wheels:
+                if _hook in sys.meta_path:
+                    sys.meta_path.remove(_hook)
+
+    def verify(self):
+        pathname = os.path.join(self.dirname, self.filename)
+        name_ver = '%s-%s' % (self.name, self.version)
+        data_dir = '%s.data' % name_ver
+        info_dir = '%s.dist-info' % name_ver
+
+        metadata_name = posixpath.join(info_dir, LEGACY_METADATA_FILENAME)
+        wheel_metadata_name = posixpath.join(info_dir, 'WHEEL')
+        record_name = posixpath.join(info_dir, 'RECORD')
+
+        wrapper = codecs.getreader('utf-8')
+
+        with ZipFile(pathname, 'r') as zf:
+            with zf.open(wheel_metadata_name) as bwf:
+                wf = wrapper(bwf)
+                message = message_from_file(wf)
+            wv = message['Wheel-Version'].split('.', 1)
+            file_version = tuple([int(i) for i in wv])
+            # TODO version verification
+
+            records = {}
+            with zf.open(record_name) as bf:
+                with CSVReader(stream=bf) as reader:
+                    for row in reader:
+                        p = row[0]
+                        records[p] = row
+
+            for zinfo in zf.infolist():
+                arcname = zinfo.filename
+                if isinstance(arcname, text_type):
+                    u_arcname = arcname
+                else:
+                    u_arcname = arcname.decode('utf-8')
+                # See issue #115: some wheels have .. in their entries, but
+                # in the filename ... e.g. __main__..py ! So the check is
+                # updated to look for .. in the directory portions
+                p = u_arcname.split('/')
+                if '..' in p:
+                    raise DistlibException('invalid entry in '
+                                           'wheel: %r' % u_arcname)
+
+                if self.skip_entry(u_arcname):
+                    continue
+                row = records[u_arcname]
+                if row[2] and str(zinfo.file_size) != row[2]:
+                    raise DistlibException('size mismatch for '
+                                           '%s' % u_arcname)
+                if row[1]:
+                    kind, value = row[1].split('=', 1)
+                    with zf.open(arcname) as bf:
+                        data = bf.read()
+                    _, digest = self.get_hash(data, kind)
+                    if digest != value:
+                        raise DistlibException('digest mismatch for '
+                                               '%s' % arcname)
+
+    def update(self, modifier, dest_dir=None, **kwargs):
+        """
+        Update the contents of a wheel in a generic way. The modifier should
+        be a callable which expects a dictionary argument: its keys are
+        archive-entry paths, and its values are absolute filesystem paths
+        where the contents the corresponding archive entries can be found. The
+        modifier is free to change the contents of the files pointed to, add
+        new entries and remove entries, before returning. This method will
+        extract the entire contents of the wheel to a temporary location, call
+        the modifier, and then use the passed (and possibly updated)
+        dictionary to write a new wheel. If ``dest_dir`` is specified, the new
+        wheel is written there -- otherwise, the original wheel is overwritten.
+
+        The modifier should return True if it updated the wheel, else False.
+        This method returns the same value the modifier returns.
+        """
+
+        def get_version(path_map, info_dir):
+            version = path = None
+            key = '%s/%s' % (info_dir, LEGACY_METADATA_FILENAME)
+            if key not in path_map:
+                key = '%s/PKG-INFO' % info_dir
+            if key in path_map:
+                path = path_map[key]
+                version = Metadata(path=path).version
+            return version, path
+
+        def update_version(version, path):
+            updated = None
+            try:
+                v = NormalizedVersion(version)
+                i = version.find('-')
+                if i < 0:
+                    updated = '%s+1' % version
+                else:
+                    parts = [int(s) for s in version[i + 1:].split('.')]
+                    parts[-1] += 1
+                    updated = '%s+%s' % (version[:i],
+                                         '.'.join(str(i) for i in parts))
+            except UnsupportedVersionError:
+                logger.debug('Cannot update non-compliant (PEP-440) '
+                             'version %r', version)
+            if updated:
+                md = Metadata(path=path)
+                md.version = updated
+                legacy = path.endswith(LEGACY_METADATA_FILENAME)
+                md.write(path=path, legacy=legacy)
+                logger.debug('Version updated from %r to %r', version,
+                             updated)
+
+        pathname = os.path.join(self.dirname, self.filename)
+        name_ver = '%s-%s' % (self.name, self.version)
+        info_dir = '%s.dist-info' % name_ver
+        record_name = posixpath.join(info_dir, 'RECORD')
+        with tempdir() as workdir:
+            with ZipFile(pathname, 'r') as zf:
+                path_map = {}
+                for zinfo in zf.infolist():
+                    arcname = zinfo.filename
+                    if isinstance(arcname, text_type):
+                        u_arcname = arcname
+                    else:
+                        u_arcname = arcname.decode('utf-8')
+                    if u_arcname == record_name:
+                        continue
+                    if '..' in u_arcname:
+                        raise DistlibException('invalid entry in '
+                                               'wheel: %r' % u_arcname)
+                    zf.extract(zinfo, workdir)
+                    path = os.path.join(workdir, convert_path(u_arcname))
+                    path_map[u_arcname] = path
+
+            # Remember the version.
+            original_version, _ = get_version(path_map, info_dir)
+            # Files extracted. Call the modifier.
+            modified = modifier(path_map, **kwargs)
+            if modified:
+                # Something changed - need to build a new wheel.
+                current_version, path = get_version(path_map, info_dir)
+                if current_version and (current_version == original_version):
+                    # Add or update local version to signify changes.
+                    update_version(current_version, path)
+                # Decide where the new wheel goes.
+                if dest_dir is None:
+                    fd, newpath = tempfile.mkstemp(suffix='.whl',
+                                                   prefix='wheel-update-',
+                                                   dir=workdir)
+                    os.close(fd)
+                else:
+                    if not os.path.isdir(dest_dir):
+                        raise DistlibException('Not a directory: %r' % dest_dir)
+                    newpath = os.path.join(dest_dir, self.filename)
+                archive_paths = list(path_map.items())
+                distinfo = os.path.join(workdir, info_dir)
+                info = distinfo, info_dir
+                self.write_records(info, workdir, archive_paths)
+                self.build_zip(newpath, archive_paths)
+                if dest_dir is None:
+                    shutil.copyfile(newpath, pathname)
+        return modified
+
+def compatible_tags():
+    """
+    Return (pyver, abi, arch) tuples compatible with this Python.
+    """
+    versions = [VER_SUFFIX]
+    major = VER_SUFFIX[0]
+    for minor in range(sys.version_info[1] - 1, - 1, -1):
+        versions.append(''.join([major, str(minor)]))
+
+    abis = []
+    for suffix, _, _ in imp.get_suffixes():
+        if suffix.startswith('.abi'):
+            abis.append(suffix.split('.', 2)[1])
+    abis.sort()
+    if ABI != 'none':
+        abis.insert(0, ABI)
+    abis.append('none')
+    result = []
+
+    arches = [ARCH]
+    if sys.platform == 'darwin':
+        m = re.match(r'(\w+)_(\d+)_(\d+)_(\w+)$', ARCH)
+        if m:
+            name, major, minor, arch = m.groups()
+            minor = int(minor)
+            matches = [arch]
+            if arch in ('i386', 'ppc'):
+                matches.append('fat')
+            if arch in ('i386', 'ppc', 'x86_64'):
+                matches.append('fat3')
+            if arch in ('ppc64', 'x86_64'):
+                matches.append('fat64')
+            if arch in ('i386', 'x86_64'):
+                matches.append('intel')
+            if arch in ('i386', 'x86_64', 'intel', 'ppc', 'ppc64'):
+                matches.append('universal')
+            while minor >= 0:
+                for match in matches:
+                    s = '%s_%s_%s_%s' % (name, major, minor, match)
+                    if s != ARCH:   # already there
+                        arches.append(s)
+                minor -= 1
+
+    # Most specific - our Python version, ABI and arch
+    for abi in abis:
+        for arch in arches:
+            result.append((''.join((IMP_PREFIX, versions[0])), abi, arch))
+
+    # where no ABI / arch dependency, but IMP_PREFIX dependency
+    for i, version in enumerate(versions):
+        result.append((''.join((IMP_PREFIX, version)), 'none', 'any'))
+        if i == 0:
+            result.append((''.join((IMP_PREFIX, version[0])), 'none', 'any'))
+
+    # no IMP_PREFIX, ABI or arch dependency
+    for i, version in enumerate(versions):
+        result.append((''.join(('py', version)), 'none', 'any'))
+        if i == 0:
+            result.append((''.join(('py', version[0])), 'none', 'any'))
+    return set(result)
+
+
+COMPATIBLE_TAGS = compatible_tags()
+
+del compatible_tags
+
+
+def is_compatible(wheel, tags=None):
+    if not isinstance(wheel, Wheel):
+        wheel = Wheel(wheel)    # assume it's a filename
+    result = False
+    if tags is None:
+        tags = COMPATIBLE_TAGS
+    for ver, abi, arch in tags:
+        if ver in wheel.pyver and abi in wheel.abi and arch in wheel.arch:
+            result = True
+            break
+    return result
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/distro.py b/myenv/lib/python3.9/site-packages/pip/_vendor/distro.py
new file mode 100644
index 0000000..0611b62
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/distro.py
@@ -0,0 +1,1230 @@
+# Copyright 2015,2016,2017 Nir Cohen
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+The ``distro`` package (``distro`` stands for Linux Distribution) provides
+information about the Linux distribution it runs on, such as a reliable
+machine-readable distro ID, or version information.
+
+It is the recommended replacement for Python's original
+:py:func:`platform.linux_distribution` function, but it provides much more
+functionality. An alternative implementation became necessary because Python
+3.5 deprecated this function, and Python 3.8 will remove it altogether.
+Its predecessor function :py:func:`platform.dist` was already
+deprecated since Python 2.6 and will also be removed in Python 3.8.
+Still, there are many cases in which access to OS distribution information
+is needed. See `Python issue 1322 <https://bugs.python.org/issue1322>`_ for
+more information.
+"""
+
+import os
+import re
+import sys
+import json
+import shlex
+import logging
+import argparse
+import subprocess
+
+
+_UNIXCONFDIR = os.environ.get('UNIXCONFDIR', '/etc')
+_OS_RELEASE_BASENAME = 'os-release'
+
+#: Translation table for normalizing the "ID" attribute defined in os-release
+#: files, for use by the :func:`distro.id` method.
+#:
+#: * Key: Value as defined in the os-release file, translated to lower case,
+#:   with blanks translated to underscores.
+#:
+#: * Value: Normalized value.
+NORMALIZED_OS_ID = {
+    'ol': 'oracle',  # Oracle Linux
+}
+
+#: Translation table for normalizing the "Distributor ID" attribute returned by
+#: the lsb_release command, for use by the :func:`distro.id` method.
+#:
+#: * Key: Value as returned by the lsb_release command, translated to lower
+#:   case, with blanks translated to underscores.
+#:
+#: * Value: Normalized value.
+NORMALIZED_LSB_ID = {
+    'enterpriseenterpriseas': 'oracle',  # Oracle Enterprise Linux 4
+    'enterpriseenterpriseserver': 'oracle',  # Oracle Linux 5
+    'redhatenterpriseworkstation': 'rhel',  # RHEL 6, 7 Workstation
+    'redhatenterpriseserver': 'rhel',  # RHEL 6, 7 Server
+    'redhatenterprisecomputenode': 'rhel',  # RHEL 6 ComputeNode
+}
+
+#: Translation table for normalizing the distro ID derived from the file name
+#: of distro release files, for use by the :func:`distro.id` method.
+#:
+#: * Key: Value as derived from the file name of a distro release file,
+#:   translated to lower case, with blanks translated to underscores.
+#:
+#: * Value: Normalized value.
+NORMALIZED_DISTRO_ID = {
+    'redhat': 'rhel',  # RHEL 6.x, 7.x
+}
+
+# Pattern for content of distro release file (reversed)
+_DISTRO_RELEASE_CONTENT_REVERSED_PATTERN = re.compile(
+    r'(?:[^)]*\)(.*)\()? *(?:STL )?([\d.+\-a-z]*\d) *(?:esaeler *)?(.+)')
+
+# Pattern for base file name of distro release file
+_DISTRO_RELEASE_BASENAME_PATTERN = re.compile(
+    r'(\w+)[-_](release|version)$')
+
+# Base file names to be ignored when searching for distro release file
+_DISTRO_RELEASE_IGNORE_BASENAMES = (
+    'debian_version',
+    'lsb-release',
+    'oem-release',
+    _OS_RELEASE_BASENAME,
+    'system-release',
+    'plesk-release',
+)
+
+
+def linux_distribution(full_distribution_name=True):
+    """
+    Return information about the current OS distribution as a tuple
+    ``(id_name, version, codename)`` with items as follows:
+
+    * ``id_name``:  If *full_distribution_name* is false, the result of
+      :func:`distro.id`. Otherwise, the result of :func:`distro.name`.
+
+    * ``version``:  The result of :func:`distro.version`.
+
+    * ``codename``:  The result of :func:`distro.codename`.
+
+    The interface of this function is compatible with the original
+    :py:func:`platform.linux_distribution` function, supporting a subset of
+    its parameters.
+
+    The data it returns may not exactly be the same, because it uses more data
+    sources than the original function, and that may lead to different data if
+    the OS distribution is not consistent across multiple data sources it
+    provides (there are indeed such distributions ...).
+
+    Another reason for differences is the fact that the :func:`distro.id`
+    method normalizes the distro ID string to a reliable machine-readable value
+    for a number of popular OS distributions.
+    """
+    return _distro.linux_distribution(full_distribution_name)
+
+
+def id():
+    """
+    Return the distro ID of the current distribution, as a
+    machine-readable string.
+
+    For a number of OS distributions, the returned distro ID value is
+    *reliable*, in the sense that it is documented and that it does not change
+    across releases of the distribution.
+
+    This package maintains the following reliable distro ID values:
+
+    ==============  =========================================
+    Distro ID       Distribution
+    ==============  =========================================
+    "ubuntu"        Ubuntu
+    "debian"        Debian
+    "rhel"          RedHat Enterprise Linux
+    "centos"        CentOS
+    "fedora"        Fedora
+    "sles"          SUSE Linux Enterprise Server
+    "opensuse"      openSUSE
+    "amazon"        Amazon Linux
+    "arch"          Arch Linux
+    "cloudlinux"    CloudLinux OS
+    "exherbo"       Exherbo Linux
+    "gentoo"        GenToo Linux
+    "ibm_powerkvm"  IBM PowerKVM
+    "kvmibm"        KVM for IBM z Systems
+    "linuxmint"     Linux Mint
+    "mageia"        Mageia
+    "mandriva"      Mandriva Linux
+    "parallels"     Parallels
+    "pidora"        Pidora
+    "raspbian"      Raspbian
+    "oracle"        Oracle Linux (and Oracle Enterprise Linux)
+    "scientific"    Scientific Linux
+    "slackware"     Slackware
+    "xenserver"     XenServer
+    "openbsd"       OpenBSD
+    "netbsd"        NetBSD
+    "freebsd"       FreeBSD
+    "midnightbsd"   MidnightBSD
+    ==============  =========================================
+
+    If you have a need to get distros for reliable IDs added into this set,
+    or if you find that the :func:`distro.id` function returns a different
+    distro ID for one of the listed distros, please create an issue in the
+    `distro issue tracker`_.
+
+    **Lookup hierarchy and transformations:**
+
+    First, the ID is obtained from the following sources, in the specified
+    order. The first available and non-empty value is used:
+
+    * the value of the "ID" attribute of the os-release file,
+
+    * the value of the "Distributor ID" attribute returned by the lsb_release
+      command,
+
+    * the first part of the file name of the distro release file,
+
+    The so determined ID value then passes the following transformations,
+    before it is returned by this method:
+
+    * it is translated to lower case,
+
+    * blanks (which should not be there anyway) are translated to underscores,
+
+    * a normalization of the ID is performed, based upon
+      `normalization tables`_. The purpose of this normalization is to ensure
+      that the ID is as reliable as possible, even across incompatible changes
+      in the OS distributions. A common reason for an incompatible change is
+      the addition of an os-release file, or the addition of the lsb_release
+      command, with ID values that differ from what was previously determined
+      from the distro release file name.
+    """
+    return _distro.id()
+
+
+def name(pretty=False):
+    """
+    Return the name of the current OS distribution, as a human-readable
+    string.
+
+    If *pretty* is false, the name is returned without version or codename.
+    (e.g. "CentOS Linux")
+
+    If *pretty* is true, the version and codename are appended.
+    (e.g. "CentOS Linux 7.1.1503 (Core)")
+
+    **Lookup hierarchy:**
+
+    The name is obtained from the following sources, in the specified order.
+    The first available and non-empty value is used:
+
+    * If *pretty* is false:
+
+      - the value of the "NAME" attribute of the os-release file,
+
+      - the value of the "Distributor ID" attribute returned by the lsb_release
+        command,
+
+      - the value of the "<name>" field of the distro release file.
+
+    * If *pretty* is true:
+
+      - the value of the "PRETTY_NAME" attribute of the os-release file,
+
+      - the value of the "Description" attribute returned by the lsb_release
+        command,
+
+      - the value of the "<name>" field of the distro release file, appended
+        with the value of the pretty version ("<version_id>" and "<codename>"
+        fields) of the distro release file, if available.
+    """
+    return _distro.name(pretty)
+
+
+def version(pretty=False, best=False):
+    """
+    Return the version of the current OS distribution, as a human-readable
+    string.
+
+    If *pretty* is false, the version is returned without codename (e.g.
+    "7.0").
+
+    If *pretty* is true, the codename in parenthesis is appended, if the
+    codename is non-empty (e.g. "7.0 (Maipo)").
+
+    Some distributions provide version numbers with different precisions in
+    the different sources of distribution information. Examining the different
+    sources in a fixed priority order does not always yield the most precise
+    version (e.g. for Debian 8.2, or CentOS 7.1).
+
+    The *best* parameter can be used to control the approach for the returned
+    version:
+
+    If *best* is false, the first non-empty version number in priority order of
+    the examined sources is returned.
+
+    If *best* is true, the most precise version number out of all examined
+    sources is returned.
+
+    **Lookup hierarchy:**
+
+    In all cases, the version number is obtained from the following sources.
+    If *best* is false, this order represents the priority order:
+
+    * the value of the "VERSION_ID" attribute of the os-release file,
+    * the value of the "Release" attribute returned by the lsb_release
+      command,
+    * the version number parsed from the "<version_id>" field of the first line
+      of the distro release file,
+    * the version number parsed from the "PRETTY_NAME" attribute of the
+      os-release file, if it follows the format of the distro release files.
+    * the version number parsed from the "Description" attribute returned by
+      the lsb_release command, if it follows the format of the distro release
+      files.
+    """
+    return _distro.version(pretty, best)
+
+
+def version_parts(best=False):
+    """
+    Return the version of the current OS distribution as a tuple
+    ``(major, minor, build_number)`` with items as follows:
+
+    * ``major``:  The result of :func:`distro.major_version`.
+
+    * ``minor``:  The result of :func:`distro.minor_version`.
+
+    * ``build_number``:  The result of :func:`distro.build_number`.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.version_parts(best)
+
+
+def major_version(best=False):
+    """
+    Return the major version of the current OS distribution, as a string,
+    if provided.
+    Otherwise, the empty string is returned. The major version is the first
+    part of the dot-separated version string.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.major_version(best)
+
+
+def minor_version(best=False):
+    """
+    Return the minor version of the current OS distribution, as a string,
+    if provided.
+    Otherwise, the empty string is returned. The minor version is the second
+    part of the dot-separated version string.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.minor_version(best)
+
+
+def build_number(best=False):
+    """
+    Return the build number of the current OS distribution, as a string,
+    if provided.
+    Otherwise, the empty string is returned. The build number is the third part
+    of the dot-separated version string.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.build_number(best)
+
+
+def like():
+    """
+    Return a space-separated list of distro IDs of distributions that are
+    closely related to the current OS distribution in regards to packaging
+    and programming interfaces, for example distributions the current
+    distribution is a derivative from.
+
+    **Lookup hierarchy:**
+
+    This information item is only provided by the os-release file.
+    For details, see the description of the "ID_LIKE" attribute in the
+    `os-release man page
+    <http://www.freedesktop.org/software/systemd/man/os-release.html>`_.
+    """
+    return _distro.like()
+
+
+def codename():
+    """
+    Return the codename for the release of the current OS distribution,
+    as a string.
+
+    If the distribution does not have a codename, an empty string is returned.
+
+    Note that the returned codename is not always really a codename. For
+    example, openSUSE returns "x86_64". This function does not handle such
+    cases in any special way and just returns the string it finds, if any.
+
+    **Lookup hierarchy:**
+
+    * the codename within the "VERSION" attribute of the os-release file, if
+      provided,
+
+    * the value of the "Codename" attribute returned by the lsb_release
+      command,
+
+    * the value of the "<codename>" field of the distro release file.
+    """
+    return _distro.codename()
+
+
+def info(pretty=False, best=False):
+    """
+    Return certain machine-readable information items about the current OS
+    distribution in a dictionary, as shown in the following example:
+
+    .. sourcecode:: python
+
+        {
+            'id': 'rhel',
+            'version': '7.0',
+            'version_parts': {
+                'major': '7',
+                'minor': '0',
+                'build_number': ''
+            },
+            'like': 'fedora',
+            'codename': 'Maipo'
+        }
+
+    The dictionary structure and keys are always the same, regardless of which
+    information items are available in the underlying data sources. The values
+    for the various keys are as follows:
+
+    * ``id``:  The result of :func:`distro.id`.
+
+    * ``version``:  The result of :func:`distro.version`.
+
+    * ``version_parts -> major``:  The result of :func:`distro.major_version`.
+
+    * ``version_parts -> minor``:  The result of :func:`distro.minor_version`.
+
+    * ``version_parts -> build_number``:  The result of
+      :func:`distro.build_number`.
+
+    * ``like``:  The result of :func:`distro.like`.
+
+    * ``codename``:  The result of :func:`distro.codename`.
+
+    For a description of the *pretty* and *best* parameters, see the
+    :func:`distro.version` method.
+    """
+    return _distro.info(pretty, best)
+
+
+def os_release_info():
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the os-release file data source of the current OS distribution.
+
+    See `os-release file`_ for details about these information items.
+    """
+    return _distro.os_release_info()
+
+
+def lsb_release_info():
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the lsb_release command data source of the current OS distribution.
+
+    See `lsb_release command output`_ for details about these information
+    items.
+    """
+    return _distro.lsb_release_info()
+
+
+def distro_release_info():
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the distro release file data source of the current OS distribution.
+
+    See `distro release file`_ for details about these information items.
+    """
+    return _distro.distro_release_info()
+
+
+def uname_info():
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the distro release file data source of the current OS distribution.
+    """
+    return _distro.uname_info()
+
+
+def os_release_attr(attribute):
+    """
+    Return a single named information item from the os-release file data source
+    of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+      The empty string, if the item does not exist.
+
+    See `os-release file`_ for details about these information items.
+    """
+    return _distro.os_release_attr(attribute)
+
+
+def lsb_release_attr(attribute):
+    """
+    Return a single named information item from the lsb_release command output
+    data source of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+      The empty string, if the item does not exist.
+
+    See `lsb_release command output`_ for details about these information
+    items.
+    """
+    return _distro.lsb_release_attr(attribute)
+
+
+def distro_release_attr(attribute):
+    """
+    Return a single named information item from the distro release file
+    data source of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+      The empty string, if the item does not exist.
+
+    See `distro release file`_ for details about these information items.
+    """
+    return _distro.distro_release_attr(attribute)
+
+
+def uname_attr(attribute):
+    """
+    Return a single named information item from the distro release file
+    data source of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+                The empty string, if the item does not exist.
+    """
+    return _distro.uname_attr(attribute)
+
+
+class cached_property(object):
+    """A version of @property which caches the value.  On access, it calls the
+    underlying function and sets the value in `__dict__` so future accesses
+    will not re-call the property.
+    """
+    def __init__(self, f):
+        self._fname = f.__name__
+        self._f = f
+
+    def __get__(self, obj, owner):
+        assert obj is not None, 'call {} on an instance'.format(self._fname)
+        ret = obj.__dict__[self._fname] = self._f(obj)
+        return ret
+
+
+class LinuxDistribution(object):
+    """
+    Provides information about a OS distribution.
+
+    This package creates a private module-global instance of this class with
+    default initialization arguments, that is used by the
+    `consolidated accessor functions`_ and `single source accessor functions`_.
+    By using default initialization arguments, that module-global instance
+    returns data about the current OS distribution (i.e. the distro this
+    package runs on).
+
+    Normally, it is not necessary to create additional instances of this class.
+    However, in situations where control is needed over the exact data sources
+    that are used, instances of this class can be created with a specific
+    distro release file, or a specific os-release file, or without invoking the
+    lsb_release command.
+    """
+
+    def __init__(self,
+                 include_lsb=True,
+                 os_release_file='',
+                 distro_release_file='',
+                 include_uname=True):
+        """
+        The initialization method of this class gathers information from the
+        available data sources, and stores that in private instance attributes.
+        Subsequent access to the information items uses these private instance
+        attributes, so that the data sources are read only once.
+
+        Parameters:
+
+        * ``include_lsb`` (bool): Controls whether the
+          `lsb_release command output`_ is included as a data source.
+
+          If the lsb_release command is not available in the program execution
+          path, the data source for the lsb_release command will be empty.
+
+        * ``os_release_file`` (string): The path name of the
+          `os-release file`_ that is to be used as a data source.
+
+          An empty string (the default) will cause the default path name to
+          be used (see `os-release file`_ for details).
+
+          If the specified or defaulted os-release file does not exist, the
+          data source for the os-release file will be empty.
+
+        * ``distro_release_file`` (string): The path name of the
+          `distro release file`_ that is to be used as a data source.
+
+          An empty string (the default) will cause a default search algorithm
+          to be used (see `distro release file`_ for details).
+
+          If the specified distro release file does not exist, or if no default
+          distro release file can be found, the data source for the distro
+          release file will be empty.
+
+        * ``include_uname`` (bool): Controls whether uname command output is
+          included as a data source. If the uname command is not available in
+          the program execution path the data source for the uname command will
+          be empty.
+
+        Public instance attributes:
+
+        * ``os_release_file`` (string): The path name of the
+          `os-release file`_ that is actually used as a data source. The
+          empty string if no distro release file is used as a data source.
+
+        * ``distro_release_file`` (string): The path name of the
+          `distro release file`_ that is actually used as a data source. The
+          empty string if no distro release file is used as a data source.
+
+        * ``include_lsb`` (bool): The result of the ``include_lsb`` parameter.
+          This controls whether the lsb information will be loaded.
+
+        * ``include_uname`` (bool): The result of the ``include_uname``
+          parameter. This controls whether the uname information will
+          be loaded.
+
+        Raises:
+
+        * :py:exc:`IOError`: Some I/O issue with an os-release file or distro
+          release file.
+
+        * :py:exc:`subprocess.CalledProcessError`: The lsb_release command had
+          some issue (other than not being available in the program execution
+          path).
+
+        * :py:exc:`UnicodeError`: A data source has unexpected characters or
+          uses an unexpected encoding.
+        """
+        self.os_release_file = os_release_file or \
+            os.path.join(_UNIXCONFDIR, _OS_RELEASE_BASENAME)
+        self.distro_release_file = distro_release_file or ''  # updated later
+        self.include_lsb = include_lsb
+        self.include_uname = include_uname
+
+    def __repr__(self):
+        """Return repr of all info
+        """
+        return \
+            "LinuxDistribution(" \
+            "os_release_file={self.os_release_file!r}, " \
+            "distro_release_file={self.distro_release_file!r}, " \
+            "include_lsb={self.include_lsb!r}, " \
+            "include_uname={self.include_uname!r}, " \
+            "_os_release_info={self._os_release_info!r}, " \
+            "_lsb_release_info={self._lsb_release_info!r}, " \
+            "_distro_release_info={self._distro_release_info!r}, " \
+            "_uname_info={self._uname_info!r})".format(
+                self=self)
+
+    def linux_distribution(self, full_distribution_name=True):
+        """
+        Return information about the OS distribution that is compatible
+        with Python's :func:`platform.linux_distribution`, supporting a subset
+        of its parameters.
+
+        For details, see :func:`distro.linux_distribution`.
+        """
+        return (
+            self.name() if full_distribution_name else self.id(),
+            self.version(),
+            self.codename()
+        )
+
+    def id(self):
+        """Return the distro ID of the OS distribution, as a string.
+
+        For details, see :func:`distro.id`.
+        """
+        def normalize(distro_id, table):
+            distro_id = distro_id.lower().replace(' ', '_')
+            return table.get(distro_id, distro_id)
+
+        distro_id = self.os_release_attr('id')
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_OS_ID)
+
+        distro_id = self.lsb_release_attr('distributor_id')
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_LSB_ID)
+
+        distro_id = self.distro_release_attr('id')
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_DISTRO_ID)
+
+        distro_id = self.uname_attr('id')
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_DISTRO_ID)
+
+        return ''
+
+    def name(self, pretty=False):
+        """
+        Return the name of the OS distribution, as a string.
+
+        For details, see :func:`distro.name`.
+        """
+        name = self.os_release_attr('name') \
+            or self.lsb_release_attr('distributor_id') \
+            or self.distro_release_attr('name') \
+            or self.uname_attr('name')
+        if pretty:
+            name = self.os_release_attr('pretty_name') \
+                or self.lsb_release_attr('description')
+            if not name:
+                name = self.distro_release_attr('name') \
+                       or self.uname_attr('name')
+                version = self.version(pretty=True)
+                if version:
+                    name = name + ' ' + version
+        return name or ''
+
+    def version(self, pretty=False, best=False):
+        """
+        Return the version of the OS distribution, as a string.
+
+        For details, see :func:`distro.version`.
+        """
+        versions = [
+            self.os_release_attr('version_id'),
+            self.lsb_release_attr('release'),
+            self.distro_release_attr('version_id'),
+            self._parse_distro_release_content(
+                self.os_release_attr('pretty_name')).get('version_id', ''),
+            self._parse_distro_release_content(
+                self.lsb_release_attr('description')).get('version_id', ''),
+            self.uname_attr('release')
+        ]
+        version = ''
+        if best:
+            # This algorithm uses the last version in priority order that has
+            # the best precision. If the versions are not in conflict, that
+            # does not matter; otherwise, using the last one instead of the
+            # first one might be considered a surprise.
+            for v in versions:
+                if v.count(".") > version.count(".") or version == '':
+                    version = v
+        else:
+            for v in versions:
+                if v != '':
+                    version = v
+                    break
+        if pretty and version and self.codename():
+            version = '{0} ({1})'.format(version, self.codename())
+        return version
+
+    def version_parts(self, best=False):
+        """
+        Return the version of the OS distribution, as a tuple of version
+        numbers.
+
+        For details, see :func:`distro.version_parts`.
+        """
+        version_str = self.version(best=best)
+        if version_str:
+            version_regex = re.compile(r'(\d+)\.?(\d+)?\.?(\d+)?')
+            matches = version_regex.match(version_str)
+            if matches:
+                major, minor, build_number = matches.groups()
+                return major, minor or '', build_number or ''
+        return '', '', ''
+
+    def major_version(self, best=False):
+        """
+        Return the major version number of the current distribution.
+
+        For details, see :func:`distro.major_version`.
+        """
+        return self.version_parts(best)[0]
+
+    def minor_version(self, best=False):
+        """
+        Return the minor version number of the current distribution.
+
+        For details, see :func:`distro.minor_version`.
+        """
+        return self.version_parts(best)[1]
+
+    def build_number(self, best=False):
+        """
+        Return the build number of the current distribution.
+
+        For details, see :func:`distro.build_number`.
+        """
+        return self.version_parts(best)[2]
+
+    def like(self):
+        """
+        Return the IDs of distributions that are like the OS distribution.
+
+        For details, see :func:`distro.like`.
+        """
+        return self.os_release_attr('id_like') or ''
+
+    def codename(self):
+        """
+        Return the codename of the OS distribution.
+
+        For details, see :func:`distro.codename`.
+        """
+        try:
+            # Handle os_release specially since distros might purposefully set
+            # this to empty string to have no codename
+            return self._os_release_info['codename']
+        except KeyError:
+            return self.lsb_release_attr('codename') \
+                or self.distro_release_attr('codename') \
+                or ''
+
+    def info(self, pretty=False, best=False):
+        """
+        Return certain machine-readable information about the OS
+        distribution.
+
+        For details, see :func:`distro.info`.
+        """
+        return dict(
+            id=self.id(),
+            version=self.version(pretty, best),
+            version_parts=dict(
+                major=self.major_version(best),
+                minor=self.minor_version(best),
+                build_number=self.build_number(best)
+            ),
+            like=self.like(),
+            codename=self.codename(),
+        )
+
+    def os_release_info(self):
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the os-release file data source of the OS distribution.
+
+        For details, see :func:`distro.os_release_info`.
+        """
+        return self._os_release_info
+
+    def lsb_release_info(self):
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the lsb_release command data source of the OS
+        distribution.
+
+        For details, see :func:`distro.lsb_release_info`.
+        """
+        return self._lsb_release_info
+
+    def distro_release_info(self):
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the distro release file data source of the OS
+        distribution.
+
+        For details, see :func:`distro.distro_release_info`.
+        """
+        return self._distro_release_info
+
+    def uname_info(self):
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the uname command data source of the OS distribution.
+
+        For details, see :func:`distro.uname_info`.
+        """
+        return self._uname_info
+
+    def os_release_attr(self, attribute):
+        """
+        Return a single named information item from the os-release file data
+        source of the OS distribution.
+
+        For details, see :func:`distro.os_release_attr`.
+        """
+        return self._os_release_info.get(attribute, '')
+
+    def lsb_release_attr(self, attribute):
+        """
+        Return a single named information item from the lsb_release command
+        output data source of the OS distribution.
+
+        For details, see :func:`distro.lsb_release_attr`.
+        """
+        return self._lsb_release_info.get(attribute, '')
+
+    def distro_release_attr(self, attribute):
+        """
+        Return a single named information item from the distro release file
+        data source of the OS distribution.
+
+        For details, see :func:`distro.distro_release_attr`.
+        """
+        return self._distro_release_info.get(attribute, '')
+
+    def uname_attr(self, attribute):
+        """
+        Return a single named information item from the uname command
+        output data source of the OS distribution.
+
+        For details, see :func:`distro.uname_release_attr`.
+        """
+        return self._uname_info.get(attribute, '')
+
+    @cached_property
+    def _os_release_info(self):
+        """
+        Get the information items from the specified os-release file.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        if os.path.isfile(self.os_release_file):
+            with open(self.os_release_file) as release_file:
+                return self._parse_os_release_content(release_file)
+        return {}
+
+    @staticmethod
+    def _parse_os_release_content(lines):
+        """
+        Parse the lines of an os-release file.
+
+        Parameters:
+
+        * lines: Iterable through the lines in the os-release file.
+                 Each line must be a unicode string or a UTF-8 encoded byte
+                 string.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        props = {}
+        lexer = shlex.shlex(lines, posix=True)
+        lexer.whitespace_split = True
+
+        # The shlex module defines its `wordchars` variable using literals,
+        # making it dependent on the encoding of the Python source file.
+        # In Python 2.6 and 2.7, the shlex source file is encoded in
+        # 'iso-8859-1', and the `wordchars` variable is defined as a byte
+        # string. This causes a UnicodeDecodeError to be raised when the
+        # parsed content is a unicode object. The following fix resolves that
+        # (... but it should be fixed in shlex...):
+        if sys.version_info[0] == 2 and isinstance(lexer.wordchars, bytes):
+            lexer.wordchars = lexer.wordchars.decode('iso-8859-1')
+
+        tokens = list(lexer)
+        for token in tokens:
+            # At this point, all shell-like parsing has been done (i.e.
+            # comments processed, quotes and backslash escape sequences
+            # processed, multi-line values assembled, trailing newlines
+            # stripped, etc.), so the tokens are now either:
+            # * variable assignments: var=value
+            # * commands or their arguments (not allowed in os-release)
+            if '=' in token:
+                k, v = token.split('=', 1)
+                props[k.lower()] = v
+            else:
+                # Ignore any tokens that are not variable assignments
+                pass
+
+        if 'version_codename' in props:
+            # os-release added a version_codename field.  Use that in
+            # preference to anything else Note that some distros purposefully
+            # do not have code names.  They should be setting
+            # version_codename=""
+            props['codename'] = props['version_codename']
+        elif 'ubuntu_codename' in props:
+            # Same as above but a non-standard field name used on older Ubuntus
+            props['codename'] = props['ubuntu_codename']
+        elif 'version' in props:
+            # If there is no version_codename, parse it from the version
+            codename = re.search(r'(\(\D+\))|,(\s+)?\D+', props['version'])
+            if codename:
+                codename = codename.group()
+                codename = codename.strip('()')
+                codename = codename.strip(',')
+                codename = codename.strip()
+                # codename appears within paranthese.
+                props['codename'] = codename
+
+        return props
+
+    @cached_property
+    def _lsb_release_info(self):
+        """
+        Get the information items from the lsb_release command output.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        if not self.include_lsb:
+            return {}
+        with open(os.devnull, 'w') as devnull:
+            try:
+                cmd = ('lsb_release', '-a')
+                stdout = subprocess.check_output(cmd, stderr=devnull)
+            except OSError:  # Command not found
+                return {}
+        content = self._to_str(stdout).splitlines()
+        return self._parse_lsb_release_content(content)
+
+    @staticmethod
+    def _parse_lsb_release_content(lines):
+        """
+        Parse the output of the lsb_release command.
+
+        Parameters:
+
+        * lines: Iterable through the lines of the lsb_release output.
+                 Each line must be a unicode string or a UTF-8 encoded byte
+                 string.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        props = {}
+        for line in lines:
+            kv = line.strip('\n').split(':', 1)
+            if len(kv) != 2:
+                # Ignore lines without colon.
+                continue
+            k, v = kv
+            props.update({k.replace(' ', '_').lower(): v.strip()})
+        return props
+
+    @cached_property
+    def _uname_info(self):
+        with open(os.devnull, 'w') as devnull:
+            try:
+                cmd = ('uname', '-rs')
+                stdout = subprocess.check_output(cmd, stderr=devnull)
+            except OSError:
+                return {}
+        content = self._to_str(stdout).splitlines()
+        return self._parse_uname_content(content)
+
+    @staticmethod
+    def _parse_uname_content(lines):
+        props = {}
+        match = re.search(r'^([^\s]+)\s+([\d\.]+)', lines[0].strip())
+        if match:
+            name, version = match.groups()
+
+            # This is to prevent the Linux kernel version from
+            # appearing as the 'best' version on otherwise
+            # identifiable distributions.
+            if name == 'Linux':
+                return {}
+            props['id'] = name.lower()
+            props['name'] = name
+            props['release'] = version
+        return props
+
+    @staticmethod
+    def _to_str(text):
+        encoding = sys.getfilesystemencoding()
+        encoding = 'utf-8' if encoding == 'ascii' else encoding
+
+        if sys.version_info[0] >= 3:
+            if isinstance(text, bytes):
+                return text.decode(encoding)
+        else:
+            if isinstance(text, unicode):  # noqa
+                return text.encode(encoding)
+
+        return text
+
+    @cached_property
+    def _distro_release_info(self):
+        """
+        Get the information items from the specified distro release file.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        if self.distro_release_file:
+            # If it was specified, we use it and parse what we can, even if
+            # its file name or content does not match the expected pattern.
+            distro_info = self._parse_distro_release_file(
+                self.distro_release_file)
+            basename = os.path.basename(self.distro_release_file)
+            # The file name pattern for user-specified distro release files
+            # is somewhat more tolerant (compared to when searching for the
+            # file), because we want to use what was specified as best as
+            # possible.
+            match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
+            if 'name' in distro_info \
+               and 'cloudlinux' in distro_info['name'].lower():
+                distro_info['id'] = 'cloudlinux'
+            elif match:
+                distro_info['id'] = match.group(1)
+            return distro_info
+        else:
+            try:
+                basenames = os.listdir(_UNIXCONFDIR)
+                # We sort for repeatability in cases where there are multiple
+                # distro specific files; e.g. CentOS, Oracle, Enterprise all
+                # containing `redhat-release` on top of their own.
+                basenames.sort()
+            except OSError:
+                # This may occur when /etc is not readable but we can't be
+                # sure about the *-release files. Check common entries of
+                # /etc for information. If they turn out to not be there the
+                # error is handled in `_parse_distro_release_file()`.
+                basenames = ['SuSE-release',
+                             'arch-release',
+                             'base-release',
+                             'centos-release',
+                             'fedora-release',
+                             'gentoo-release',
+                             'mageia-release',
+                             'mandrake-release',
+                             'mandriva-release',
+                             'mandrivalinux-release',
+                             'manjaro-release',
+                             'oracle-release',
+                             'redhat-release',
+                             'sl-release',
+                             'slackware-version']
+            for basename in basenames:
+                if basename in _DISTRO_RELEASE_IGNORE_BASENAMES:
+                    continue
+                match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
+                if match:
+                    filepath = os.path.join(_UNIXCONFDIR, basename)
+                    distro_info = self._parse_distro_release_file(filepath)
+                    if 'name' in distro_info:
+                        # The name is always present if the pattern matches
+                        self.distro_release_file = filepath
+                        distro_info['id'] = match.group(1)
+                        if 'cloudlinux' in distro_info['name'].lower():
+                            distro_info['id'] = 'cloudlinux'
+                        return distro_info
+            return {}
+
+    def _parse_distro_release_file(self, filepath):
+        """
+        Parse a distro release file.
+
+        Parameters:
+
+        * filepath: Path name of the distro release file.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        try:
+            with open(filepath) as fp:
+                # Only parse the first line. For instance, on SLES there
+                # are multiple lines. We don't want them...
+                return self._parse_distro_release_content(fp.readline())
+        except (OSError, IOError):
+            # Ignore not being able to read a specific, seemingly version
+            # related file.
+            # See https://github.com/nir0s/distro/issues/162
+            return {}
+
+    @staticmethod
+    def _parse_distro_release_content(line):
+        """
+        Parse a line from a distro release file.
+
+        Parameters:
+        * line: Line from the distro release file. Must be a unicode string
+                or a UTF-8 encoded byte string.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        matches = _DISTRO_RELEASE_CONTENT_REVERSED_PATTERN.match(
+            line.strip()[::-1])
+        distro_info = {}
+        if matches:
+            # regexp ensures non-None
+            distro_info['name'] = matches.group(3)[::-1]
+            if matches.group(2):
+                distro_info['version_id'] = matches.group(2)[::-1]
+            if matches.group(1):
+                distro_info['codename'] = matches.group(1)[::-1]
+        elif line:
+            distro_info['name'] = line.strip()
+        return distro_info
+
+
+_distro = LinuxDistribution()
+
+
+def main():
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.DEBUG)
+    logger.addHandler(logging.StreamHandler(sys.stdout))
+
+    parser = argparse.ArgumentParser(description="OS distro info tool")
+    parser.add_argument(
+        '--json',
+        '-j',
+        help="Output in machine readable format",
+        action="store_true")
+    args = parser.parse_args()
+
+    if args.json:
+        logger.info(json.dumps(info(), indent=4, sort_keys=True))
+    else:
+        logger.info('Name: %s', name(pretty=True))
+        distribution_version = version(pretty=True)
+        logger.info('Version: %s', distribution_version)
+        distribution_codename = codename()
+        logger.info('Codename: %s', distribution_codename)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/__init__.py
new file mode 100644
index 0000000..d1d82f1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/__init__.py
@@ -0,0 +1,35 @@
+"""
+HTML parsing library based on the `WHATWG HTML specification
+<https://whatwg.org/html>`_. The parser is designed to be compatible with
+existing HTML found in the wild and implements well-defined error recovery that
+is largely compatible with modern desktop web browsers.
+
+Example usage::
+
+    from pip._vendor import html5lib
+    with open("my_document.html", "rb") as f:
+        tree = html5lib.parse(f)
+
+For convenience, this module re-exports the following names:
+
+* :func:`~.html5parser.parse`
+* :func:`~.html5parser.parseFragment`
+* :class:`~.html5parser.HTMLParser`
+* :func:`~.treebuilders.getTreeBuilder`
+* :func:`~.treewalkers.getTreeWalker`
+* :func:`~.serializer.serialize`
+"""
+
+from __future__ import absolute_import, division, unicode_literals
+
+from .html5parser import HTMLParser, parse, parseFragment
+from .treebuilders import getTreeBuilder
+from .treewalkers import getTreeWalker
+from .serializer import serialize
+
+__all__ = ["HTMLParser", "parse", "parseFragment", "getTreeBuilder",
+           "getTreeWalker", "serialize"]
+
+# this has to be at the top level, see how setup.py parses this
+#: Distribution version number.
+__version__ = "1.1"
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_ihatexml.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_ihatexml.py
new file mode 100644
index 0000000..3ff803c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_ihatexml.py
@@ -0,0 +1,289 @@
+from __future__ import absolute_import, division, unicode_literals
+
+import re
+import warnings
+
+from .constants import DataLossWarning
+
+baseChar = """
+[#x0041-#x005A] | [#x0061-#x007A] | [#x00C0-#x00D6] | [#x00D8-#x00F6] |
+[#x00F8-#x00FF] | [#x0100-#x0131] | [#x0134-#x013E] | [#x0141-#x0148] |
+[#x014A-#x017E] | [#x0180-#x01C3] | [#x01CD-#x01F0] | [#x01F4-#x01F5] |
+[#x01FA-#x0217] | [#x0250-#x02A8] | [#x02BB-#x02C1] | #x0386 |
+[#x0388-#x038A] | #x038C | [#x038E-#x03A1] | [#x03A3-#x03CE] |
+[#x03D0-#x03D6] | #x03DA | #x03DC | #x03DE | #x03E0 | [#x03E2-#x03F3] |
+[#x0401-#x040C] | [#x040E-#x044F] | [#x0451-#x045C] | [#x045E-#x0481] |
+[#x0490-#x04C4] | [#x04C7-#x04C8] | [#x04CB-#x04CC] | [#x04D0-#x04EB] |
+[#x04EE-#x04F5] | [#x04F8-#x04F9] | [#x0531-#x0556] | #x0559 |
+[#x0561-#x0586] | [#x05D0-#x05EA] | [#x05F0-#x05F2] | [#x0621-#x063A] |
+[#x0641-#x064A] | [#x0671-#x06B7] | [#x06BA-#x06BE] | [#x06C0-#x06CE] |
+[#x06D0-#x06D3] | #x06D5 | [#x06E5-#x06E6] | [#x0905-#x0939] | #x093D |
+[#x0958-#x0961] | [#x0985-#x098C] | [#x098F-#x0990] | [#x0993-#x09A8] |
+[#x09AA-#x09B0] | #x09B2 | [#x09B6-#x09B9] | [#x09DC-#x09DD] |
+[#x09DF-#x09E1] | [#x09F0-#x09F1] | [#x0A05-#x0A0A] | [#x0A0F-#x0A10] |
+[#x0A13-#x0A28] | [#x0A2A-#x0A30] | [#x0A32-#x0A33] | [#x0A35-#x0A36] |
+[#x0A38-#x0A39] | [#x0A59-#x0A5C] | #x0A5E | [#x0A72-#x0A74] |
+[#x0A85-#x0A8B] | #x0A8D | [#x0A8F-#x0A91] | [#x0A93-#x0AA8] |
+[#x0AAA-#x0AB0] | [#x0AB2-#x0AB3] | [#x0AB5-#x0AB9] | #x0ABD | #x0AE0 |
+[#x0B05-#x0B0C] | [#x0B0F-#x0B10] | [#x0B13-#x0B28] | [#x0B2A-#x0B30] |
+[#x0B32-#x0B33] | [#x0B36-#x0B39] | #x0B3D | [#x0B5C-#x0B5D] |
+[#x0B5F-#x0B61] | [#x0B85-#x0B8A] | [#x0B8E-#x0B90] | [#x0B92-#x0B95] |
+[#x0B99-#x0B9A] | #x0B9C | [#x0B9E-#x0B9F] | [#x0BA3-#x0BA4] |
+[#x0BA8-#x0BAA] | [#x0BAE-#x0BB5] | [#x0BB7-#x0BB9] | [#x0C05-#x0C0C] |
+[#x0C0E-#x0C10] | [#x0C12-#x0C28] | [#x0C2A-#x0C33] | [#x0C35-#x0C39] |
+[#x0C60-#x0C61] | [#x0C85-#x0C8C] | [#x0C8E-#x0C90] | [#x0C92-#x0CA8] |
+[#x0CAA-#x0CB3] | [#x0CB5-#x0CB9] | #x0CDE | [#x0CE0-#x0CE1] |
+[#x0D05-#x0D0C] | [#x0D0E-#x0D10] | [#x0D12-#x0D28] | [#x0D2A-#x0D39] |
+[#x0D60-#x0D61] | [#x0E01-#x0E2E] | #x0E30 | [#x0E32-#x0E33] |
+[#x0E40-#x0E45] | [#x0E81-#x0E82] | #x0E84 | [#x0E87-#x0E88] | #x0E8A |
+#x0E8D | [#x0E94-#x0E97] | [#x0E99-#x0E9F] | [#x0EA1-#x0EA3] | #x0EA5 |
+#x0EA7 | [#x0EAA-#x0EAB] | [#x0EAD-#x0EAE] | #x0EB0 | [#x0EB2-#x0EB3] |
+#x0EBD | [#x0EC0-#x0EC4] | [#x0F40-#x0F47] | [#x0F49-#x0F69] |
+[#x10A0-#x10C5] | [#x10D0-#x10F6] | #x1100 | [#x1102-#x1103] |
+[#x1105-#x1107] | #x1109 | [#x110B-#x110C] | [#x110E-#x1112] | #x113C |
+#x113E | #x1140 | #x114C | #x114E | #x1150 | [#x1154-#x1155] | #x1159 |
+[#x115F-#x1161] | #x1163 | #x1165 | #x1167 | #x1169 | [#x116D-#x116E] |
+[#x1172-#x1173] | #x1175 | #x119E | #x11A8 | #x11AB | [#x11AE-#x11AF] |
+[#x11B7-#x11B8] | #x11BA | [#x11BC-#x11C2] | #x11EB | #x11F0 | #x11F9 |
+[#x1E00-#x1E9B] | [#x1EA0-#x1EF9] | [#x1F00-#x1F15] | [#x1F18-#x1F1D] |
+[#x1F20-#x1F45] | [#x1F48-#x1F4D] | [#x1F50-#x1F57] | #x1F59 | #x1F5B |
+#x1F5D | [#x1F5F-#x1F7D] | [#x1F80-#x1FB4] | [#x1FB6-#x1FBC] | #x1FBE |
+[#x1FC2-#x1FC4] | [#x1FC6-#x1FCC] | [#x1FD0-#x1FD3] | [#x1FD6-#x1FDB] |
+[#x1FE0-#x1FEC] | [#x1FF2-#x1FF4] | [#x1FF6-#x1FFC] | #x2126 |
+[#x212A-#x212B] | #x212E | [#x2180-#x2182] | [#x3041-#x3094] |
+[#x30A1-#x30FA] | [#x3105-#x312C] | [#xAC00-#xD7A3]"""
+
+ideographic = """[#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029]"""
+
+combiningCharacter = """
+[#x0300-#x0345] | [#x0360-#x0361] | [#x0483-#x0486] | [#x0591-#x05A1] |
+[#x05A3-#x05B9] | [#x05BB-#x05BD] | #x05BF | [#x05C1-#x05C2] | #x05C4 |
+[#x064B-#x0652] | #x0670 | [#x06D6-#x06DC] | [#x06DD-#x06DF] |
+[#x06E0-#x06E4] | [#x06E7-#x06E8] | [#x06EA-#x06ED] | [#x0901-#x0903] |
+#x093C | [#x093E-#x094C] | #x094D | [#x0951-#x0954] | [#x0962-#x0963] |
+[#x0981-#x0983] | #x09BC | #x09BE | #x09BF | [#x09C0-#x09C4] |
+[#x09C7-#x09C8] | [#x09CB-#x09CD] | #x09D7 | [#x09E2-#x09E3] | #x0A02 |
+#x0A3C | #x0A3E | #x0A3F | [#x0A40-#x0A42] | [#x0A47-#x0A48] |
+[#x0A4B-#x0A4D] | [#x0A70-#x0A71] | [#x0A81-#x0A83] | #x0ABC |
+[#x0ABE-#x0AC5] | [#x0AC7-#x0AC9] | [#x0ACB-#x0ACD] | [#x0B01-#x0B03] |
+#x0B3C | [#x0B3E-#x0B43] | [#x0B47-#x0B48] | [#x0B4B-#x0B4D] |
+[#x0B56-#x0B57] | [#x0B82-#x0B83] | [#x0BBE-#x0BC2] | [#x0BC6-#x0BC8] |
+[#x0BCA-#x0BCD] | #x0BD7 | [#x0C01-#x0C03] | [#x0C3E-#x0C44] |
+[#x0C46-#x0C48] | [#x0C4A-#x0C4D] | [#x0C55-#x0C56] | [#x0C82-#x0C83] |
+[#x0CBE-#x0CC4] | [#x0CC6-#x0CC8] | [#x0CCA-#x0CCD] | [#x0CD5-#x0CD6] |
+[#x0D02-#x0D03] | [#x0D3E-#x0D43] | [#x0D46-#x0D48] | [#x0D4A-#x0D4D] |
+#x0D57 | #x0E31 | [#x0E34-#x0E3A] | [#x0E47-#x0E4E] | #x0EB1 |
+[#x0EB4-#x0EB9] | [#x0EBB-#x0EBC] | [#x0EC8-#x0ECD] | [#x0F18-#x0F19] |
+#x0F35 | #x0F37 | #x0F39 | #x0F3E | #x0F3F | [#x0F71-#x0F84] |
+[#x0F86-#x0F8B] | [#x0F90-#x0F95] | #x0F97 | [#x0F99-#x0FAD] |
+[#x0FB1-#x0FB7] | #x0FB9 | [#x20D0-#x20DC] | #x20E1 | [#x302A-#x302F] |
+#x3099 | #x309A"""
+
+digit = """
+[#x0030-#x0039] | [#x0660-#x0669] | [#x06F0-#x06F9] | [#x0966-#x096F] |
+[#x09E6-#x09EF] | [#x0A66-#x0A6F] | [#x0AE6-#x0AEF] | [#x0B66-#x0B6F] |
+[#x0BE7-#x0BEF] | [#x0C66-#x0C6F] | [#x0CE6-#x0CEF] | [#x0D66-#x0D6F] |
+[#x0E50-#x0E59] | [#x0ED0-#x0ED9] | [#x0F20-#x0F29]"""
+
+extender = """
+#x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 | #x0E46 | #x0EC6 | #x3005 |
+#[#x3031-#x3035] | [#x309D-#x309E] | [#x30FC-#x30FE]"""
+
+letter = " | ".join([baseChar, ideographic])
+
+# Without the
+name = " | ".join([letter, digit, ".", "-", "_", combiningCharacter,
+                   extender])
+nameFirst = " | ".join([letter, "_"])
+
+reChar = re.compile(r"#x([\d|A-F]{4,4})")
+reCharRange = re.compile(r"\[#x([\d|A-F]{4,4})-#x([\d|A-F]{4,4})\]")
+
+
+def charStringToList(chars):
+    charRanges = [item.strip() for item in chars.split(" | ")]
+    rv = []
+    for item in charRanges:
+        foundMatch = False
+        for regexp in (reChar, reCharRange):
+            match = regexp.match(item)
+            if match is not None:
+                rv.append([hexToInt(item) for item in match.groups()])
+                if len(rv[-1]) == 1:
+                    rv[-1] = rv[-1] * 2
+                foundMatch = True
+                break
+        if not foundMatch:
+            assert len(item) == 1
+
+            rv.append([ord(item)] * 2)
+    rv = normaliseCharList(rv)
+    return rv
+
+
+def normaliseCharList(charList):
+    charList = sorted(charList)
+    for item in charList:
+        assert item[1] >= item[0]
+    rv = []
+    i = 0
+    while i < len(charList):
+        j = 1
+        rv.append(charList[i])
+        while i + j < len(charList) and charList[i + j][0] <= rv[-1][1] + 1:
+            rv[-1][1] = charList[i + j][1]
+            j += 1
+        i += j
+    return rv
+
+
+# We don't really support characters above the BMP :(
+max_unicode = int("FFFF", 16)
+
+
+def missingRanges(charList):
+    rv = []
+    if charList[0] != 0:
+        rv.append([0, charList[0][0] - 1])
+    for i, item in enumerate(charList[:-1]):
+        rv.append([item[1] + 1, charList[i + 1][0] - 1])
+    if charList[-1][1] != max_unicode:
+        rv.append([charList[-1][1] + 1, max_unicode])
+    return rv
+
+
+def listToRegexpStr(charList):
+    rv = []
+    for item in charList:
+        if item[0] == item[1]:
+            rv.append(escapeRegexp(chr(item[0])))
+        else:
+            rv.append(escapeRegexp(chr(item[0])) + "-" +
+                      escapeRegexp(chr(item[1])))
+    return "[%s]" % "".join(rv)
+
+
+def hexToInt(hex_str):
+    return int(hex_str, 16)
+
+
+def escapeRegexp(string):
+    specialCharacters = (".", "^", "$", "*", "+", "?", "{", "}",
+                         "[", "]", "|", "(", ")", "-")
+    for char in specialCharacters:
+        string = string.replace(char, "\\" + char)
+
+    return string
+
+# output from the above
+nonXmlNameBMPRegexp = re.compile('[\x00-,/:-@\\[-\\^`\\{-\xb6\xb8-\xbf\xd7\xf7\u0132-\u0133\u013f-\u0140\u0149\u017f\u01c4-\u01cc\u01f1-\u01f3\u01f6-\u01f9\u0218-\u024f\u02a9-\u02ba\u02c2-\u02cf\u02d2-\u02ff\u0346-\u035f\u0362-\u0385\u038b\u038d\u03a2\u03cf\u03d7-\u03d9\u03db\u03dd\u03df\u03e1\u03f4-\u0400\u040d\u0450\u045d\u0482\u0487-\u048f\u04c5-\u04c6\u04c9-\u04ca\u04cd-\u04cf\u04ec-\u04ed\u04f6-\u04f7\u04fa-\u0530\u0557-\u0558\u055a-\u0560\u0587-\u0590\u05a2\u05ba\u05be\u05c0\u05c3\u05c5-\u05cf\u05eb-\u05ef\u05f3-\u0620\u063b-\u063f\u0653-\u065f\u066a-\u066f\u06b8-\u06b9\u06bf\u06cf\u06d4\u06e9\u06ee-\u06ef\u06fa-\u0900\u0904\u093a-\u093b\u094e-\u0950\u0955-\u0957\u0964-\u0965\u0970-\u0980\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09bd\u09c5-\u09c6\u09c9-\u09ca\u09ce-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09f2-\u0a01\u0a03-\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a58\u0a5d\u0a5f-\u0a65\u0a75-\u0a80\u0a84\u0a8c\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0adf\u0ae1-\u0ae5\u0af0-\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34-\u0b35\u0b3a-\u0b3b\u0b44-\u0b46\u0b49-\u0b4a\u0b4e-\u0b55\u0b58-\u0b5b\u0b5e\u0b62-\u0b65\u0b70-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bb6\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bd6\u0bd8-\u0be6\u0bf0-\u0c00\u0c04\u0c0d\u0c11\u0c29\u0c34\u0c3a-\u0c3d\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c5f\u0c62-\u0c65\u0c70-\u0c81\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbd\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdd\u0cdf\u0ce2-\u0ce5\u0cf0-\u0d01\u0d04\u0d0d\u0d11\u0d29\u0d3a-\u0d3d\u0d44-\u0d45\u0d49\u0d4e-\u0d56\u0d58-\u0d5f\u0d62-\u0d65\u0d70-\u0e00\u0e2f\u0e3b-\u0e3f\u0e4f\u0e5a-\u0e80\u0e83\u0e85-\u0e86\u0e89\u0e8b-\u0e8c\u0e8e-\u0e93\u0e98\u0ea0\u0ea4\u0ea6\u0ea8-\u0ea9\u0eac\u0eaf\u0eba\u0ebe-\u0ebf\u0ec5\u0ec7\u0ece-\u0ecf\u0eda-\u0f17\u0f1a-\u0f1f\u0f2a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f48\u0f6a-\u0f70\u0f85\u0f8c-\u0f8f\u0f96\u0f98\u0fae-\u0fb0\u0fb8\u0fba-\u109f\u10c6-\u10cf\u10f7-\u10ff\u1101\u1104\u1108\u110a\u110d\u1113-\u113b\u113d\u113f\u1141-\u114b\u114d\u114f\u1151-\u1153\u1156-\u1158\u115a-\u115e\u1162\u1164\u1166\u1168\u116a-\u116c\u116f-\u1171\u1174\u1176-\u119d\u119f-\u11a7\u11a9-\u11aa\u11ac-\u11ad\u11b0-\u11b6\u11b9\u11bb\u11c3-\u11ea\u11ec-\u11ef\u11f1-\u11f8\u11fa-\u1dff\u1e9c-\u1e9f\u1efa-\u1eff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u20cf\u20dd-\u20e0\u20e2-\u2125\u2127-\u2129\u212c-\u212d\u212f-\u217f\u2183-\u3004\u3006\u3008-\u3020\u3030\u3036-\u3040\u3095-\u3098\u309b-\u309c\u309f-\u30a0\u30fb\u30ff-\u3104\u312d-\u4dff\u9fa6-\uabff\ud7a4-\uffff]')  # noqa
+
+nonXmlNameFirstBMPRegexp = re.compile('[\x00-@\\[-\\^`\\{-\xbf\xd7\xf7\u0132-\u0133\u013f-\u0140\u0149\u017f\u01c4-\u01cc\u01f1-\u01f3\u01f6-\u01f9\u0218-\u024f\u02a9-\u02ba\u02c2-\u0385\u0387\u038b\u038d\u03a2\u03cf\u03d7-\u03d9\u03db\u03dd\u03df\u03e1\u03f4-\u0400\u040d\u0450\u045d\u0482-\u048f\u04c5-\u04c6\u04c9-\u04ca\u04cd-\u04cf\u04ec-\u04ed\u04f6-\u04f7\u04fa-\u0530\u0557-\u0558\u055a-\u0560\u0587-\u05cf\u05eb-\u05ef\u05f3-\u0620\u063b-\u0640\u064b-\u0670\u06b8-\u06b9\u06bf\u06cf\u06d4\u06d6-\u06e4\u06e7-\u0904\u093a-\u093c\u093e-\u0957\u0962-\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09db\u09de\u09e2-\u09ef\u09f2-\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a58\u0a5d\u0a5f-\u0a71\u0a75-\u0a84\u0a8c\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0abe-\u0adf\u0ae1-\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34-\u0b35\u0b3a-\u0b3c\u0b3e-\u0b5b\u0b5e\u0b62-\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bb6\u0bba-\u0c04\u0c0d\u0c11\u0c29\u0c34\u0c3a-\u0c5f\u0c62-\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cdd\u0cdf\u0ce2-\u0d04\u0d0d\u0d11\u0d29\u0d3a-\u0d5f\u0d62-\u0e00\u0e2f\u0e31\u0e34-\u0e3f\u0e46-\u0e80\u0e83\u0e85-\u0e86\u0e89\u0e8b-\u0e8c\u0e8e-\u0e93\u0e98\u0ea0\u0ea4\u0ea6\u0ea8-\u0ea9\u0eac\u0eaf\u0eb1\u0eb4-\u0ebc\u0ebe-\u0ebf\u0ec5-\u0f3f\u0f48\u0f6a-\u109f\u10c6-\u10cf\u10f7-\u10ff\u1101\u1104\u1108\u110a\u110d\u1113-\u113b\u113d\u113f\u1141-\u114b\u114d\u114f\u1151-\u1153\u1156-\u1158\u115a-\u115e\u1162\u1164\u1166\u1168\u116a-\u116c\u116f-\u1171\u1174\u1176-\u119d\u119f-\u11a7\u11a9-\u11aa\u11ac-\u11ad\u11b0-\u11b6\u11b9\u11bb\u11c3-\u11ea\u11ec-\u11ef\u11f1-\u11f8\u11fa-\u1dff\u1e9c-\u1e9f\u1efa-\u1eff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u2125\u2127-\u2129\u212c-\u212d\u212f-\u217f\u2183-\u3006\u3008-\u3020\u302a-\u3040\u3095-\u30a0\u30fb-\u3104\u312d-\u4dff\u9fa6-\uabff\ud7a4-\uffff]')  # noqa
+
+# Simpler things
+nonPubidCharRegexp = re.compile("[^\x20\x0D\x0Aa-zA-Z0-9\\-'()+,./:=?;!*#@$_%]")
+
+
+class InfosetFilter(object):
+    replacementRegexp = re.compile(r"U[\dA-F]{5,5}")
+
+    def __init__(self,
+                 dropXmlnsLocalName=False,
+                 dropXmlnsAttrNs=False,
+                 preventDoubleDashComments=False,
+                 preventDashAtCommentEnd=False,
+                 replaceFormFeedCharacters=True,
+                 preventSingleQuotePubid=False):
+
+        self.dropXmlnsLocalName = dropXmlnsLocalName
+        self.dropXmlnsAttrNs = dropXmlnsAttrNs
+
+        self.preventDoubleDashComments = preventDoubleDashComments
+        self.preventDashAtCommentEnd = preventDashAtCommentEnd
+
+        self.replaceFormFeedCharacters = replaceFormFeedCharacters
+
+        self.preventSingleQuotePubid = preventSingleQuotePubid
+
+        self.replaceCache = {}
+
+    def coerceAttribute(self, name, namespace=None):
+        if self.dropXmlnsLocalName and name.startswith("xmlns:"):
+            warnings.warn("Attributes cannot begin with xmlns", DataLossWarning)
+            return None
+        elif (self.dropXmlnsAttrNs and
+              namespace == "http://www.w3.org/2000/xmlns/"):
+            warnings.warn("Attributes cannot be in the xml namespace", DataLossWarning)
+            return None
+        else:
+            return self.toXmlName(name)
+
+    def coerceElement(self, name):
+        return self.toXmlName(name)
+
+    def coerceComment(self, data):
+        if self.preventDoubleDashComments:
+            while "--" in data:
+                warnings.warn("Comments cannot contain adjacent dashes", DataLossWarning)
+                data = data.replace("--", "- -")
+            if data.endswith("-"):
+                warnings.warn("Comments cannot end in a dash", DataLossWarning)
+                data += " "
+        return data
+
+    def coerceCharacters(self, data):
+        if self.replaceFormFeedCharacters:
+            for _ in range(data.count("\x0C")):
+                warnings.warn("Text cannot contain U+000C", DataLossWarning)
+            data = data.replace("\x0C", " ")
+        # Other non-xml characters
+        return data
+
+    def coercePubid(self, data):
+        dataOutput = data
+        for char in nonPubidCharRegexp.findall(data):
+            warnings.warn("Coercing non-XML pubid", DataLossWarning)
+            replacement = self.getReplacementCharacter(char)
+            dataOutput = dataOutput.replace(char, replacement)
+        if self.preventSingleQuotePubid and dataOutput.find("'") >= 0:
+            warnings.warn("Pubid cannot contain single quote", DataLossWarning)
+            dataOutput = dataOutput.replace("'", self.getReplacementCharacter("'"))
+        return dataOutput
+
+    def toXmlName(self, name):
+        nameFirst = name[0]
+        nameRest = name[1:]
+        m = nonXmlNameFirstBMPRegexp.match(nameFirst)
+        if m:
+            warnings.warn("Coercing non-XML name: %s" % name, DataLossWarning)
+            nameFirstOutput = self.getReplacementCharacter(nameFirst)
+        else:
+            nameFirstOutput = nameFirst
+
+        nameRestOutput = nameRest
+        replaceChars = set(nonXmlNameBMPRegexp.findall(nameRest))
+        for char in replaceChars:
+            warnings.warn("Coercing non-XML name: %s" % name, DataLossWarning)
+            replacement = self.getReplacementCharacter(char)
+            nameRestOutput = nameRestOutput.replace(char, replacement)
+        return nameFirstOutput + nameRestOutput
+
+    def getReplacementCharacter(self, char):
+        if char in self.replaceCache:
+            replacement = self.replaceCache[char]
+        else:
+            replacement = self.escapeChar(char)
+        return replacement
+
+    def fromXmlName(self, name):
+        for item in set(self.replacementRegexp.findall(name)):
+            name = name.replace(item, self.unescapeChar(item))
+        return name
+
+    def escapeChar(self, char):
+        replacement = "U%05X" % ord(char)
+        self.replaceCache[char] = replacement
+        return replacement
+
+    def unescapeChar(self, charcode):
+        return chr(int(charcode[1:], 16))
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_inputstream.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_inputstream.py
new file mode 100644
index 0000000..e0bb376
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_inputstream.py
@@ -0,0 +1,918 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from pip._vendor.six import text_type
+from pip._vendor.six.moves import http_client, urllib
+
+import codecs
+import re
+from io import BytesIO, StringIO
+
+from pip._vendor import webencodings
+
+from .constants import EOF, spaceCharacters, asciiLetters, asciiUppercase
+from .constants import _ReparseException
+from . import _utils
+
+# Non-unicode versions of constants for use in the pre-parser
+spaceCharactersBytes = frozenset([item.encode("ascii") for item in spaceCharacters])
+asciiLettersBytes = frozenset([item.encode("ascii") for item in asciiLetters])
+asciiUppercaseBytes = frozenset([item.encode("ascii") for item in asciiUppercase])
+spacesAngleBrackets = spaceCharactersBytes | frozenset([b">", b"<"])
+
+
+invalid_unicode_no_surrogate = "[\u0001-\u0008\u000B\u000E-\u001F\u007F-\u009F\uFDD0-\uFDEF\uFFFE\uFFFF\U0001FFFE\U0001FFFF\U0002FFFE\U0002FFFF\U0003FFFE\U0003FFFF\U0004FFFE\U0004FFFF\U0005FFFE\U0005FFFF\U0006FFFE\U0006FFFF\U0007FFFE\U0007FFFF\U0008FFFE\U0008FFFF\U0009FFFE\U0009FFFF\U000AFFFE\U000AFFFF\U000BFFFE\U000BFFFF\U000CFFFE\U000CFFFF\U000DFFFE\U000DFFFF\U000EFFFE\U000EFFFF\U000FFFFE\U000FFFFF\U0010FFFE\U0010FFFF]"  # noqa
+
+if _utils.supports_lone_surrogates:
+    # Use one extra step of indirection and create surrogates with
+    # eval. Not using this indirection would introduce an illegal
+    # unicode literal on platforms not supporting such lone
+    # surrogates.
+    assert invalid_unicode_no_surrogate[-1] == "]" and invalid_unicode_no_surrogate.count("]") == 1
+    invalid_unicode_re = re.compile(invalid_unicode_no_surrogate[:-1] +
+                                    eval('"\\uD800-\\uDFFF"') +  # pylint:disable=eval-used
+                                    "]")
+else:
+    invalid_unicode_re = re.compile(invalid_unicode_no_surrogate)
+
+non_bmp_invalid_codepoints = {0x1FFFE, 0x1FFFF, 0x2FFFE, 0x2FFFF, 0x3FFFE,
+                              0x3FFFF, 0x4FFFE, 0x4FFFF, 0x5FFFE, 0x5FFFF,
+                              0x6FFFE, 0x6FFFF, 0x7FFFE, 0x7FFFF, 0x8FFFE,
+                              0x8FFFF, 0x9FFFE, 0x9FFFF, 0xAFFFE, 0xAFFFF,
+                              0xBFFFE, 0xBFFFF, 0xCFFFE, 0xCFFFF, 0xDFFFE,
+                              0xDFFFF, 0xEFFFE, 0xEFFFF, 0xFFFFE, 0xFFFFF,
+                              0x10FFFE, 0x10FFFF}
+
+ascii_punctuation_re = re.compile("[\u0009-\u000D\u0020-\u002F\u003A-\u0040\u005C\u005B-\u0060\u007B-\u007E]")
+
+# Cache for charsUntil()
+charsUntilRegEx = {}
+
+
+class BufferedStream(object):
+    """Buffering for streams that do not have buffering of their own
+
+    The buffer is implemented as a list of chunks on the assumption that
+    joining many strings will be slow since it is O(n**2)
+    """
+
+    def __init__(self, stream):
+        self.stream = stream
+        self.buffer = []
+        self.position = [-1, 0]  # chunk number, offset
+
+    def tell(self):
+        pos = 0
+        for chunk in self.buffer[:self.position[0]]:
+            pos += len(chunk)
+        pos += self.position[1]
+        return pos
+
+    def seek(self, pos):
+        assert pos <= self._bufferedBytes()
+        offset = pos
+        i = 0
+        while len(self.buffer[i]) < offset:
+            offset -= len(self.buffer[i])
+            i += 1
+        self.position = [i, offset]
+
+    def read(self, bytes):
+        if not self.buffer:
+            return self._readStream(bytes)
+        elif (self.position[0] == len(self.buffer) and
+              self.position[1] == len(self.buffer[-1])):
+            return self._readStream(bytes)
+        else:
+            return self._readFromBuffer(bytes)
+
+    def _bufferedBytes(self):
+        return sum([len(item) for item in self.buffer])
+
+    def _readStream(self, bytes):
+        data = self.stream.read(bytes)
+        self.buffer.append(data)
+        self.position[0] += 1
+        self.position[1] = len(data)
+        return data
+
+    def _readFromBuffer(self, bytes):
+        remainingBytes = bytes
+        rv = []
+        bufferIndex = self.position[0]
+        bufferOffset = self.position[1]
+        while bufferIndex < len(self.buffer) and remainingBytes != 0:
+            assert remainingBytes > 0
+            bufferedData = self.buffer[bufferIndex]
+
+            if remainingBytes <= len(bufferedData) - bufferOffset:
+                bytesToRead = remainingBytes
+                self.position = [bufferIndex, bufferOffset + bytesToRead]
+            else:
+                bytesToRead = len(bufferedData) - bufferOffset
+                self.position = [bufferIndex, len(bufferedData)]
+                bufferIndex += 1
+            rv.append(bufferedData[bufferOffset:bufferOffset + bytesToRead])
+            remainingBytes -= bytesToRead
+
+            bufferOffset = 0
+
+        if remainingBytes:
+            rv.append(self._readStream(remainingBytes))
+
+        return b"".join(rv)
+
+
+def HTMLInputStream(source, **kwargs):
+    # Work around Python bug #20007: read(0) closes the connection.
+    # http://bugs.python.org/issue20007
+    if (isinstance(source, http_client.HTTPResponse) or
+        # Also check for addinfourl wrapping HTTPResponse
+        (isinstance(source, urllib.response.addbase) and
+         isinstance(source.fp, http_client.HTTPResponse))):
+        isUnicode = False
+    elif hasattr(source, "read"):
+        isUnicode = isinstance(source.read(0), text_type)
+    else:
+        isUnicode = isinstance(source, text_type)
+
+    if isUnicode:
+        encodings = [x for x in kwargs if x.endswith("_encoding")]
+        if encodings:
+            raise TypeError("Cannot set an encoding with a unicode input, set %r" % encodings)
+
+        return HTMLUnicodeInputStream(source, **kwargs)
+    else:
+        return HTMLBinaryInputStream(source, **kwargs)
+
+
+class HTMLUnicodeInputStream(object):
+    """Provides a unicode stream of characters to the HTMLTokenizer.
+
+    This class takes care of character encoding and removing or replacing
+    incorrect byte-sequences and also provides column and line tracking.
+
+    """
+
+    _defaultChunkSize = 10240
+
+    def __init__(self, source):
+        """Initialises the HTMLInputStream.
+
+        HTMLInputStream(source, [encoding]) -> Normalized stream from source
+        for use by html5lib.
+
+        source can be either a file-object, local filename or a string.
+
+        The optional encoding parameter must be a string that indicates
+        the encoding.  If specified, that encoding will be used,
+        regardless of any BOM or later declaration (such as in a meta
+        element)
+
+        """
+
+        if not _utils.supports_lone_surrogates:
+            # Such platforms will have already checked for such
+            # surrogate errors, so no need to do this checking.
+            self.reportCharacterErrors = None
+        elif len("\U0010FFFF") == 1:
+            self.reportCharacterErrors = self.characterErrorsUCS4
+        else:
+            self.reportCharacterErrors = self.characterErrorsUCS2
+
+        # List of where new lines occur
+        self.newLines = [0]
+
+        self.charEncoding = (lookupEncoding("utf-8"), "certain")
+        self.dataStream = self.openStream(source)
+
+        self.reset()
+
+    def reset(self):
+        self.chunk = ""
+        self.chunkSize = 0
+        self.chunkOffset = 0
+        self.errors = []
+
+        # number of (complete) lines in previous chunks
+        self.prevNumLines = 0
+        # number of columns in the last line of the previous chunk
+        self.prevNumCols = 0
+
+        # Deal with CR LF and surrogates split over chunk boundaries
+        self._bufferedCharacter = None
+
+    def openStream(self, source):
+        """Produces a file object from source.
+
+        source can be either a file object, local filename or a string.
+
+        """
+        # Already a file object
+        if hasattr(source, 'read'):
+            stream = source
+        else:
+            stream = StringIO(source)
+
+        return stream
+
+    def _position(self, offset):
+        chunk = self.chunk
+        nLines = chunk.count('\n', 0, offset)
+        positionLine = self.prevNumLines + nLines
+        lastLinePos = chunk.rfind('\n', 0, offset)
+        if lastLinePos == -1:
+            positionColumn = self.prevNumCols + offset
+        else:
+            positionColumn = offset - (lastLinePos + 1)
+        return (positionLine, positionColumn)
+
+    def position(self):
+        """Returns (line, col) of the current position in the stream."""
+        line, col = self._position(self.chunkOffset)
+        return (line + 1, col)
+
+    def char(self):
+        """ Read one character from the stream or queue if available. Return
+            EOF when EOF is reached.
+        """
+        # Read a new chunk from the input stream if necessary
+        if self.chunkOffset >= self.chunkSize:
+            if not self.readChunk():
+                return EOF
+
+        chunkOffset = self.chunkOffset
+        char = self.chunk[chunkOffset]
+        self.chunkOffset = chunkOffset + 1
+
+        return char
+
+    def readChunk(self, chunkSize=None):
+        if chunkSize is None:
+            chunkSize = self._defaultChunkSize
+
+        self.prevNumLines, self.prevNumCols = self._position(self.chunkSize)
+
+        self.chunk = ""
+        self.chunkSize = 0
+        self.chunkOffset = 0
+
+        data = self.dataStream.read(chunkSize)
+
+        # Deal with CR LF and surrogates broken across chunks
+        if self._bufferedCharacter:
+            data = self._bufferedCharacter + data
+            self._bufferedCharacter = None
+        elif not data:
+            # We have no more data, bye-bye stream
+            return False
+
+        if len(data) > 1:
+            lastv = ord(data[-1])
+            if lastv == 0x0D or 0xD800 <= lastv <= 0xDBFF:
+                self._bufferedCharacter = data[-1]
+                data = data[:-1]
+
+        if self.reportCharacterErrors:
+            self.reportCharacterErrors(data)
+
+        # Replace invalid characters
+        data = data.replace("\r\n", "\n")
+        data = data.replace("\r", "\n")
+
+        self.chunk = data
+        self.chunkSize = len(data)
+
+        return True
+
+    def characterErrorsUCS4(self, data):
+        for _ in range(len(invalid_unicode_re.findall(data))):
+            self.errors.append("invalid-codepoint")
+
+    def characterErrorsUCS2(self, data):
+        # Someone picked the wrong compile option
+        # You lose
+        skip = False
+        for match in invalid_unicode_re.finditer(data):
+            if skip:
+                continue
+            codepoint = ord(match.group())
+            pos = match.start()
+            # Pretty sure there should be endianness issues here
+            if _utils.isSurrogatePair(data[pos:pos + 2]):
+                # We have a surrogate pair!
+                char_val = _utils.surrogatePairToCodepoint(data[pos:pos + 2])
+                if char_val in non_bmp_invalid_codepoints:
+                    self.errors.append("invalid-codepoint")
+                skip = True
+            elif (codepoint >= 0xD800 and codepoint <= 0xDFFF and
+                  pos == len(data) - 1):
+                self.errors.append("invalid-codepoint")
+            else:
+                skip = False
+                self.errors.append("invalid-codepoint")
+
+    def charsUntil(self, characters, opposite=False):
+        """ Returns a string of characters from the stream up to but not
+        including any character in 'characters' or EOF. 'characters' must be
+        a container that supports the 'in' method and iteration over its
+        characters.
+        """
+
+        # Use a cache of regexps to find the required characters
+        try:
+            chars = charsUntilRegEx[(characters, opposite)]
+        except KeyError:
+            if __debug__:
+                for c in characters:
+                    assert(ord(c) < 128)
+            regex = "".join(["\\x%02x" % ord(c) for c in characters])
+            if not opposite:
+                regex = "^%s" % regex
+            chars = charsUntilRegEx[(characters, opposite)] = re.compile("[%s]+" % regex)
+
+        rv = []
+
+        while True:
+            # Find the longest matching prefix
+            m = chars.match(self.chunk, self.chunkOffset)
+            if m is None:
+                # If nothing matched, and it wasn't because we ran out of chunk,
+                # then stop
+                if self.chunkOffset != self.chunkSize:
+                    break
+            else:
+                end = m.end()
+                # If not the whole chunk matched, return everything
+                # up to the part that didn't match
+                if end != self.chunkSize:
+                    rv.append(self.chunk[self.chunkOffset:end])
+                    self.chunkOffset = end
+                    break
+            # If the whole remainder of the chunk matched,
+            # use it all and read the next chunk
+            rv.append(self.chunk[self.chunkOffset:])
+            if not self.readChunk():
+                # Reached EOF
+                break
+
+        r = "".join(rv)
+        return r
+
+    def unget(self, char):
+        # Only one character is allowed to be ungotten at once - it must
+        # be consumed again before any further call to unget
+        if char is not EOF:
+            if self.chunkOffset == 0:
+                # unget is called quite rarely, so it's a good idea to do
+                # more work here if it saves a bit of work in the frequently
+                # called char and charsUntil.
+                # So, just prepend the ungotten character onto the current
+                # chunk:
+                self.chunk = char + self.chunk
+                self.chunkSize += 1
+            else:
+                self.chunkOffset -= 1
+                assert self.chunk[self.chunkOffset] == char
+
+
+class HTMLBinaryInputStream(HTMLUnicodeInputStream):
+    """Provides a unicode stream of characters to the HTMLTokenizer.
+
+    This class takes care of character encoding and removing or replacing
+    incorrect byte-sequences and also provides column and line tracking.
+
+    """
+
+    def __init__(self, source, override_encoding=None, transport_encoding=None,
+                 same_origin_parent_encoding=None, likely_encoding=None,
+                 default_encoding="windows-1252", useChardet=True):
+        """Initialises the HTMLInputStream.
+
+        HTMLInputStream(source, [encoding]) -> Normalized stream from source
+        for use by html5lib.
+
+        source can be either a file-object, local filename or a string.
+
+        The optional encoding parameter must be a string that indicates
+        the encoding.  If specified, that encoding will be used,
+        regardless of any BOM or later declaration (such as in a meta
+        element)
+
+        """
+        # Raw Stream - for unicode objects this will encode to utf-8 and set
+        #              self.charEncoding as appropriate
+        self.rawStream = self.openStream(source)
+
+        HTMLUnicodeInputStream.__init__(self, self.rawStream)
+
+        # Encoding Information
+        # Number of bytes to use when looking for a meta element with
+        # encoding information
+        self.numBytesMeta = 1024
+        # Number of bytes to use when using detecting encoding using chardet
+        self.numBytesChardet = 100
+        # Things from args
+        self.override_encoding = override_encoding
+        self.transport_encoding = transport_encoding
+        self.same_origin_parent_encoding = same_origin_parent_encoding
+        self.likely_encoding = likely_encoding
+        self.default_encoding = default_encoding
+
+        # Determine encoding
+        self.charEncoding = self.determineEncoding(useChardet)
+        assert self.charEncoding[0] is not None
+
+        # Call superclass
+        self.reset()
+
+    def reset(self):
+        self.dataStream = self.charEncoding[0].codec_info.streamreader(self.rawStream, 'replace')
+        HTMLUnicodeInputStream.reset(self)
+
+    def openStream(self, source):
+        """Produces a file object from source.
+
+        source can be either a file object, local filename or a string.
+
+        """
+        # Already a file object
+        if hasattr(source, 'read'):
+            stream = source
+        else:
+            stream = BytesIO(source)
+
+        try:
+            stream.seek(stream.tell())
+        except Exception:
+            stream = BufferedStream(stream)
+
+        return stream
+
+    def determineEncoding(self, chardet=True):
+        # BOMs take precedence over everything
+        # This will also read past the BOM if present
+        charEncoding = self.detectBOM(), "certain"
+        if charEncoding[0] is not None:
+            return charEncoding
+
+        # If we've been overridden, we've been overridden
+        charEncoding = lookupEncoding(self.override_encoding), "certain"
+        if charEncoding[0] is not None:
+            return charEncoding
+
+        # Now check the transport layer
+        charEncoding = lookupEncoding(self.transport_encoding), "certain"
+        if charEncoding[0] is not None:
+            return charEncoding
+
+        # Look for meta elements with encoding information
+        charEncoding = self.detectEncodingMeta(), "tentative"
+        if charEncoding[0] is not None:
+            return charEncoding
+
+        # Parent document encoding
+        charEncoding = lookupEncoding(self.same_origin_parent_encoding), "tentative"
+        if charEncoding[0] is not None and not charEncoding[0].name.startswith("utf-16"):
+            return charEncoding
+
+        # "likely" encoding
+        charEncoding = lookupEncoding(self.likely_encoding), "tentative"
+        if charEncoding[0] is not None:
+            return charEncoding
+
+        # Guess with chardet, if available
+        if chardet:
+            try:
+                from pip._vendor.chardet.universaldetector import UniversalDetector
+            except ImportError:
+                pass
+            else:
+                buffers = []
+                detector = UniversalDetector()
+                while not detector.done:
+                    buffer = self.rawStream.read(self.numBytesChardet)
+                    assert isinstance(buffer, bytes)
+                    if not buffer:
+                        break
+                    buffers.append(buffer)
+                    detector.feed(buffer)
+                detector.close()
+                encoding = lookupEncoding(detector.result['encoding'])
+                self.rawStream.seek(0)
+                if encoding is not None:
+                    return encoding, "tentative"
+
+        # Try the default encoding
+        charEncoding = lookupEncoding(self.default_encoding), "tentative"
+        if charEncoding[0] is not None:
+            return charEncoding
+
+        # Fallback to html5lib's default if even that hasn't worked
+        return lookupEncoding("windows-1252"), "tentative"
+
+    def changeEncoding(self, newEncoding):
+        assert self.charEncoding[1] != "certain"
+        newEncoding = lookupEncoding(newEncoding)
+        if newEncoding is None:
+            return
+        if newEncoding.name in ("utf-16be", "utf-16le"):
+            newEncoding = lookupEncoding("utf-8")
+            assert newEncoding is not None
+        elif newEncoding == self.charEncoding[0]:
+            self.charEncoding = (self.charEncoding[0], "certain")
+        else:
+            self.rawStream.seek(0)
+            self.charEncoding = (newEncoding, "certain")
+            self.reset()
+            raise _ReparseException("Encoding changed from %s to %s" % (self.charEncoding[0], newEncoding))
+
+    def detectBOM(self):
+        """Attempts to detect at BOM at the start of the stream. If
+        an encoding can be determined from the BOM return the name of the
+        encoding otherwise return None"""
+        bomDict = {
+            codecs.BOM_UTF8: 'utf-8',
+            codecs.BOM_UTF16_LE: 'utf-16le', codecs.BOM_UTF16_BE: 'utf-16be',
+            codecs.BOM_UTF32_LE: 'utf-32le', codecs.BOM_UTF32_BE: 'utf-32be'
+        }
+
+        # Go to beginning of file and read in 4 bytes
+        string = self.rawStream.read(4)
+        assert isinstance(string, bytes)
+
+        # Try detecting the BOM using bytes from the string
+        encoding = bomDict.get(string[:3])         # UTF-8
+        seek = 3
+        if not encoding:
+            # Need to detect UTF-32 before UTF-16
+            encoding = bomDict.get(string)         # UTF-32
+            seek = 4
+            if not encoding:
+                encoding = bomDict.get(string[:2])  # UTF-16
+                seek = 2
+
+        # Set the read position past the BOM if one was found, otherwise
+        # set it to the start of the stream
+        if encoding:
+            self.rawStream.seek(seek)
+            return lookupEncoding(encoding)
+        else:
+            self.rawStream.seek(0)
+            return None
+
+    def detectEncodingMeta(self):
+        """Report the encoding declared by the meta element
+        """
+        buffer = self.rawStream.read(self.numBytesMeta)
+        assert isinstance(buffer, bytes)
+        parser = EncodingParser(buffer)
+        self.rawStream.seek(0)
+        encoding = parser.getEncoding()
+
+        if encoding is not None and encoding.name in ("utf-16be", "utf-16le"):
+            encoding = lookupEncoding("utf-8")
+
+        return encoding
+
+
+class EncodingBytes(bytes):
+    """String-like object with an associated position and various extra methods
+    If the position is ever greater than the string length then an exception is
+    raised"""
+    def __new__(self, value):
+        assert isinstance(value, bytes)
+        return bytes.__new__(self, value.lower())
+
+    def __init__(self, value):
+        # pylint:disable=unused-argument
+        self._position = -1
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        p = self._position = self._position + 1
+        if p >= len(self):
+            raise StopIteration
+        elif p < 0:
+            raise TypeError
+        return self[p:p + 1]
+
+    def next(self):
+        # Py2 compat
+        return self.__next__()
+
+    def previous(self):
+        p = self._position
+        if p >= len(self):
+            raise StopIteration
+        elif p < 0:
+            raise TypeError
+        self._position = p = p - 1
+        return self[p:p + 1]
+
+    def setPosition(self, position):
+        if self._position >= len(self):
+            raise StopIteration
+        self._position = position
+
+    def getPosition(self):
+        if self._position >= len(self):
+            raise StopIteration
+        if self._position >= 0:
+            return self._position
+        else:
+            return None
+
+    position = property(getPosition, setPosition)
+
+    def getCurrentByte(self):
+        return self[self.position:self.position + 1]
+
+    currentByte = property(getCurrentByte)
+
+    def skip(self, chars=spaceCharactersBytes):
+        """Skip past a list of characters"""
+        p = self.position               # use property for the error-checking
+        while p < len(self):
+            c = self[p:p + 1]
+            if c not in chars:
+                self._position = p
+                return c
+            p += 1
+        self._position = p
+        return None
+
+    def skipUntil(self, chars):
+        p = self.position
+        while p < len(self):
+            c = self[p:p + 1]
+            if c in chars:
+                self._position = p
+                return c
+            p += 1
+        self._position = p
+        return None
+
+    def matchBytes(self, bytes):
+        """Look for a sequence of bytes at the start of a string. If the bytes
+        are found return True and advance the position to the byte after the
+        match. Otherwise return False and leave the position alone"""
+        rv = self.startswith(bytes, self.position)
+        if rv:
+            self.position += len(bytes)
+        return rv
+
+    def jumpTo(self, bytes):
+        """Look for the next sequence of bytes matching a given sequence. If
+        a match is found advance the position to the last byte of the match"""
+        try:
+            self._position = self.index(bytes, self.position) + len(bytes) - 1
+        except ValueError:
+            raise StopIteration
+        return True
+
+
+class EncodingParser(object):
+    """Mini parser for detecting character encoding from meta elements"""
+
+    def __init__(self, data):
+        """string - the data to work on for encoding detection"""
+        self.data = EncodingBytes(data)
+        self.encoding = None
+
+    def getEncoding(self):
+        if b"<meta" not in self.data:
+            return None
+
+        methodDispatch = (
+            (b"<!--", self.handleComment),
+            (b"<meta", self.handleMeta),
+            (b"</", self.handlePossibleEndTag),
+            (b"<!", self.handleOther),
+            (b"<?", self.handleOther),
+            (b"<", self.handlePossibleStartTag))
+        for _ in self.data:
+            keepParsing = True
+            try:
+                self.data.jumpTo(b"<")
+            except StopIteration:
+                break
+            for key, method in methodDispatch:
+                if self.data.matchBytes(key):
+                    try:
+                        keepParsing = method()
+                        break
+                    except StopIteration:
+                        keepParsing = False
+                        break
+            if not keepParsing:
+                break
+
+        return self.encoding
+
+    def handleComment(self):
+        """Skip over comments"""
+        return self.data.jumpTo(b"-->")
+
+    def handleMeta(self):
+        if self.data.currentByte not in spaceCharactersBytes:
+            # if we have <meta not followed by a space so just keep going
+            return True
+        # We have a valid meta element we want to search for attributes
+        hasPragma = False
+        pendingEncoding = None
+        while True:
+            # Try to find the next attribute after the current position
+            attr = self.getAttribute()
+            if attr is None:
+                return True
+            else:
+                if attr[0] == b"http-equiv":
+                    hasPragma = attr[1] == b"content-type"
+                    if hasPragma and pendingEncoding is not None:
+                        self.encoding = pendingEncoding
+                        return False
+                elif attr[0] == b"charset":
+                    tentativeEncoding = attr[1]
+                    codec = lookupEncoding(tentativeEncoding)
+                    if codec is not None:
+                        self.encoding = codec
+                        return False
+                elif attr[0] == b"content":
+                    contentParser = ContentAttrParser(EncodingBytes(attr[1]))
+                    tentativeEncoding = contentParser.parse()
+                    if tentativeEncoding is not None:
+                        codec = lookupEncoding(tentativeEncoding)
+                        if codec is not None:
+                            if hasPragma:
+                                self.encoding = codec
+                                return False
+                            else:
+                                pendingEncoding = codec
+
+    def handlePossibleStartTag(self):
+        return self.handlePossibleTag(False)
+
+    def handlePossibleEndTag(self):
+        next(self.data)
+        return self.handlePossibleTag(True)
+
+    def handlePossibleTag(self, endTag):
+        data = self.data
+        if data.currentByte not in asciiLettersBytes:
+            # If the next byte is not an ascii letter either ignore this
+            # fragment (possible start tag case) or treat it according to
+            # handleOther
+            if endTag:
+                data.previous()
+                self.handleOther()
+            return True
+
+        c = data.skipUntil(spacesAngleBrackets)
+        if c == b"<":
+            # return to the first step in the overall "two step" algorithm
+            # reprocessing the < byte
+            data.previous()
+        else:
+            # Read all attributes
+            attr = self.getAttribute()
+            while attr is not None:
+                attr = self.getAttribute()
+        return True
+
+    def handleOther(self):
+        return self.data.jumpTo(b">")
+
+    def getAttribute(self):
+        """Return a name,value pair for the next attribute in the stream,
+        if one is found, or None"""
+        data = self.data
+        # Step 1 (skip chars)
+        c = data.skip(spaceCharactersBytes | frozenset([b"/"]))
+        assert c is None or len(c) == 1
+        # Step 2
+        if c in (b">", None):
+            return None
+        # Step 3
+        attrName = []
+        attrValue = []
+        # Step 4 attribute name
+        while True:
+            if c == b"=" and attrName:
+                break
+            elif c in spaceCharactersBytes:
+                # Step 6!
+                c = data.skip()
+                break
+            elif c in (b"/", b">"):
+                return b"".join(attrName), b""
+            elif c in asciiUppercaseBytes:
+                attrName.append(c.lower())
+            elif c is None:
+                return None
+            else:
+                attrName.append(c)
+            # Step 5
+            c = next(data)
+        # Step 7
+        if c != b"=":
+            data.previous()
+            return b"".join(attrName), b""
+        # Step 8
+        next(data)
+        # Step 9
+        c = data.skip()
+        # Step 10
+        if c in (b"'", b'"'):
+            # 10.1
+            quoteChar = c
+            while True:
+                # 10.2
+                c = next(data)
+                # 10.3
+                if c == quoteChar:
+                    next(data)
+                    return b"".join(attrName), b"".join(attrValue)
+                # 10.4
+                elif c in asciiUppercaseBytes:
+                    attrValue.append(c.lower())
+                # 10.5
+                else:
+                    attrValue.append(c)
+        elif c == b">":
+            return b"".join(attrName), b""
+        elif c in asciiUppercaseBytes:
+            attrValue.append(c.lower())
+        elif c is None:
+            return None
+        else:
+            attrValue.append(c)
+        # Step 11
+        while True:
+            c = next(data)
+            if c in spacesAngleBrackets:
+                return b"".join(attrName), b"".join(attrValue)
+            elif c in asciiUppercaseBytes:
+                attrValue.append(c.lower())
+            elif c is None:
+                return None
+            else:
+                attrValue.append(c)
+
+
+class ContentAttrParser(object):
+    def __init__(self, data):
+        assert isinstance(data, bytes)
+        self.data = data
+
+    def parse(self):
+        try:
+            # Check if the attr name is charset
+            # otherwise return
+            self.data.jumpTo(b"charset")
+            self.data.position += 1
+            self.data.skip()
+            if not self.data.currentByte == b"=":
+                # If there is no = sign keep looking for attrs
+                return None
+            self.data.position += 1
+            self.data.skip()
+            # Look for an encoding between matching quote marks
+            if self.data.currentByte in (b'"', b"'"):
+                quoteMark = self.data.currentByte
+                self.data.position += 1
+                oldPosition = self.data.position
+                if self.data.jumpTo(quoteMark):
+                    return self.data[oldPosition:self.data.position]
+                else:
+                    return None
+            else:
+                # Unquoted value
+                oldPosition = self.data.position
+                try:
+                    self.data.skipUntil(spaceCharactersBytes)
+                    return self.data[oldPosition:self.data.position]
+                except StopIteration:
+                    # Return the whole remaining value
+                    return self.data[oldPosition:]
+        except StopIteration:
+            return None
+
+
+def lookupEncoding(encoding):
+    """Return the python codec name corresponding to an encoding or None if the
+    string doesn't correspond to a valid encoding."""
+    if isinstance(encoding, bytes):
+        try:
+            encoding = encoding.decode("ascii")
+        except UnicodeDecodeError:
+            return None
+
+    if encoding is not None:
+        try:
+            return webencodings.lookup(encoding)
+        except AttributeError:
+            return None
+    else:
+        return None
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_tokenizer.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_tokenizer.py
new file mode 100644
index 0000000..5f00253
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_tokenizer.py
@@ -0,0 +1,1735 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from pip._vendor.six import unichr as chr
+
+from collections import deque, OrderedDict
+from sys import version_info
+
+from .constants import spaceCharacters
+from .constants import entities
+from .constants import asciiLetters, asciiUpper2Lower
+from .constants import digits, hexDigits, EOF
+from .constants import tokenTypes, tagTokenTypes
+from .constants import replacementCharacters
+
+from ._inputstream import HTMLInputStream
+
+from ._trie import Trie
+
+entitiesTrie = Trie(entities)
+
+if version_info >= (3, 7):
+    attributeMap = dict
+else:
+    attributeMap = OrderedDict
+
+
+class HTMLTokenizer(object):
+    """ This class takes care of tokenizing HTML.
+
+    * self.currentToken
+      Holds the token that is currently being processed.
+
+    * self.state
+      Holds a reference to the method to be invoked... XXX
+
+    * self.stream
+      Points to HTMLInputStream object.
+    """
+
+    def __init__(self, stream, parser=None, **kwargs):
+
+        self.stream = HTMLInputStream(stream, **kwargs)
+        self.parser = parser
+
+        # Setup the initial tokenizer state
+        self.escapeFlag = False
+        self.lastFourChars = []
+        self.state = self.dataState
+        self.escape = False
+
+        # The current token being created
+        self.currentToken = None
+        super(HTMLTokenizer, self).__init__()
+
+    def __iter__(self):
+        """ This is where the magic happens.
+
+        We do our usually processing through the states and when we have a token
+        to return we yield the token which pauses processing until the next token
+        is requested.
+        """
+        self.tokenQueue = deque([])
+        # Start processing. When EOF is reached self.state will return False
+        # instead of True and the loop will terminate.
+        while self.state():
+            while self.stream.errors:
+                yield {"type": tokenTypes["ParseError"], "data": self.stream.errors.pop(0)}
+            while self.tokenQueue:
+                yield self.tokenQueue.popleft()
+
+    def consumeNumberEntity(self, isHex):
+        """This function returns either U+FFFD or the character based on the
+        decimal or hexadecimal representation. It also discards ";" if present.
+        If not present self.tokenQueue.append({"type": tokenTypes["ParseError"]}) is invoked.
+        """
+
+        allowed = digits
+        radix = 10
+        if isHex:
+            allowed = hexDigits
+            radix = 16
+
+        charStack = []
+
+        # Consume all the characters that are in range while making sure we
+        # don't hit an EOF.
+        c = self.stream.char()
+        while c in allowed and c is not EOF:
+            charStack.append(c)
+            c = self.stream.char()
+
+        # Convert the set of characters consumed to an int.
+        charAsInt = int("".join(charStack), radix)
+
+        # Certain characters get replaced with others
+        if charAsInt in replacementCharacters:
+            char = replacementCharacters[charAsInt]
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "illegal-codepoint-for-numeric-entity",
+                                    "datavars": {"charAsInt": charAsInt}})
+        elif ((0xD800 <= charAsInt <= 0xDFFF) or
+              (charAsInt > 0x10FFFF)):
+            char = "\uFFFD"
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "illegal-codepoint-for-numeric-entity",
+                                    "datavars": {"charAsInt": charAsInt}})
+        else:
+            # Should speed up this check somehow (e.g. move the set to a constant)
+            if ((0x0001 <= charAsInt <= 0x0008) or
+                (0x000E <= charAsInt <= 0x001F) or
+                (0x007F <= charAsInt <= 0x009F) or
+                (0xFDD0 <= charAsInt <= 0xFDEF) or
+                charAsInt in frozenset([0x000B, 0xFFFE, 0xFFFF, 0x1FFFE,
+                                        0x1FFFF, 0x2FFFE, 0x2FFFF, 0x3FFFE,
+                                        0x3FFFF, 0x4FFFE, 0x4FFFF, 0x5FFFE,
+                                        0x5FFFF, 0x6FFFE, 0x6FFFF, 0x7FFFE,
+                                        0x7FFFF, 0x8FFFE, 0x8FFFF, 0x9FFFE,
+                                        0x9FFFF, 0xAFFFE, 0xAFFFF, 0xBFFFE,
+                                        0xBFFFF, 0xCFFFE, 0xCFFFF, 0xDFFFE,
+                                        0xDFFFF, 0xEFFFE, 0xEFFFF, 0xFFFFE,
+                                        0xFFFFF, 0x10FFFE, 0x10FFFF])):
+                self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                        "data":
+                                        "illegal-codepoint-for-numeric-entity",
+                                        "datavars": {"charAsInt": charAsInt}})
+            try:
+                # Try/except needed as UCS-2 Python builds' unichar only works
+                # within the BMP.
+                char = chr(charAsInt)
+            except ValueError:
+                v = charAsInt - 0x10000
+                char = chr(0xD800 | (v >> 10)) + chr(0xDC00 | (v & 0x3FF))
+
+        # Discard the ; if present. Otherwise, put it back on the queue and
+        # invoke parseError on parser.
+        if c != ";":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "numeric-entity-without-semicolon"})
+            self.stream.unget(c)
+
+        return char
+
+    def consumeEntity(self, allowedChar=None, fromAttribute=False):
+        # Initialise to the default output for when no entity is matched
+        output = "&"
+
+        charStack = [self.stream.char()]
+        if (charStack[0] in spaceCharacters or charStack[0] in (EOF, "<", "&") or
+                (allowedChar is not None and allowedChar == charStack[0])):
+            self.stream.unget(charStack[0])
+
+        elif charStack[0] == "#":
+            # Read the next character to see if it's hex or decimal
+            hex = False
+            charStack.append(self.stream.char())
+            if charStack[-1] in ("x", "X"):
+                hex = True
+                charStack.append(self.stream.char())
+
+            # charStack[-1] should be the first digit
+            if (hex and charStack[-1] in hexDigits) \
+                    or (not hex and charStack[-1] in digits):
+                # At least one digit found, so consume the whole number
+                self.stream.unget(charStack[-1])
+                output = self.consumeNumberEntity(hex)
+            else:
+                # No digits found
+                self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                        "data": "expected-numeric-entity"})
+                self.stream.unget(charStack.pop())
+                output = "&" + "".join(charStack)
+
+        else:
+            # At this point in the process might have named entity. Entities
+            # are stored in the global variable "entities".
+            #
+            # Consume characters and compare to these to a substring of the
+            # entity names in the list until the substring no longer matches.
+            while (charStack[-1] is not EOF):
+                if not entitiesTrie.has_keys_with_prefix("".join(charStack)):
+                    break
+                charStack.append(self.stream.char())
+
+            # At this point we have a string that starts with some characters
+            # that may match an entity
+            # Try to find the longest entity the string will match to take care
+            # of &noti for instance.
+            try:
+                entityName = entitiesTrie.longest_prefix("".join(charStack[:-1]))
+                entityLength = len(entityName)
+            except KeyError:
+                entityName = None
+
+            if entityName is not None:
+                if entityName[-1] != ";":
+                    self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                            "named-entity-without-semicolon"})
+                if (entityName[-1] != ";" and fromAttribute and
+                    (charStack[entityLength] in asciiLetters or
+                     charStack[entityLength] in digits or
+                     charStack[entityLength] == "=")):
+                    self.stream.unget(charStack.pop())
+                    output = "&" + "".join(charStack)
+                else:
+                    output = entities[entityName]
+                    self.stream.unget(charStack.pop())
+                    output += "".join(charStack[entityLength:])
+            else:
+                self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                        "expected-named-entity"})
+                self.stream.unget(charStack.pop())
+                output = "&" + "".join(charStack)
+
+        if fromAttribute:
+            self.currentToken["data"][-1][1] += output
+        else:
+            if output in spaceCharacters:
+                tokenType = "SpaceCharacters"
+            else:
+                tokenType = "Characters"
+            self.tokenQueue.append({"type": tokenTypes[tokenType], "data": output})
+
+    def processEntityInAttribute(self, allowedChar):
+        """This method replaces the need for "entityInAttributeValueState".
+        """
+        self.consumeEntity(allowedChar=allowedChar, fromAttribute=True)
+
+    def emitCurrentToken(self):
+        """This method is a generic handler for emitting the tags. It also sets
+        the state to "data" because that's what's needed after a token has been
+        emitted.
+        """
+        token = self.currentToken
+        # Add token to the queue to be yielded
+        if (token["type"] in tagTokenTypes):
+            token["name"] = token["name"].translate(asciiUpper2Lower)
+            if token["type"] == tokenTypes["StartTag"]:
+                raw = token["data"]
+                data = attributeMap(raw)
+                if len(raw) > len(data):
+                    # we had some duplicated attribute, fix so first wins
+                    data.update(raw[::-1])
+                token["data"] = data
+
+            if token["type"] == tokenTypes["EndTag"]:
+                if token["data"]:
+                    self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                            "data": "attributes-in-end-tag"})
+                if token["selfClosing"]:
+                    self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                            "data": "self-closing-flag-on-end-tag"})
+        self.tokenQueue.append(token)
+        self.state = self.dataState
+
+    # Below are the various tokenizer states worked out.
+    def dataState(self):
+        data = self.stream.char()
+        if data == "&":
+            self.state = self.entityDataState
+        elif data == "<":
+            self.state = self.tagOpenState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "\u0000"})
+        elif data is EOF:
+            # Tokenization ends.
+            return False
+        elif data in spaceCharacters:
+            # Directly after emitting a token you switch back to the "data
+            # state". At that point spaceCharacters are important so they are
+            # emitted separately.
+            self.tokenQueue.append({"type": tokenTypes["SpaceCharacters"], "data":
+                                    data + self.stream.charsUntil(spaceCharacters, True)})
+            # No need to update lastFourChars here, since the first space will
+            # have already been appended to lastFourChars and will have broken
+            # any <!-- or --> sequences
+        else:
+            chars = self.stream.charsUntil(("&", "<", "\u0000"))
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data":
+                                    data + chars})
+        return True
+
+    def entityDataState(self):
+        self.consumeEntity()
+        self.state = self.dataState
+        return True
+
+    def rcdataState(self):
+        data = self.stream.char()
+        if data == "&":
+            self.state = self.characterReferenceInRcdata
+        elif data == "<":
+            self.state = self.rcdataLessThanSignState
+        elif data == EOF:
+            # Tokenization ends.
+            return False
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "\uFFFD"})
+        elif data in spaceCharacters:
+            # Directly after emitting a token you switch back to the "data
+            # state". At that point spaceCharacters are important so they are
+            # emitted separately.
+            self.tokenQueue.append({"type": tokenTypes["SpaceCharacters"], "data":
+                                    data + self.stream.charsUntil(spaceCharacters, True)})
+            # No need to update lastFourChars here, since the first space will
+            # have already been appended to lastFourChars and will have broken
+            # any <!-- or --> sequences
+        else:
+            chars = self.stream.charsUntil(("&", "<", "\u0000"))
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data":
+                                    data + chars})
+        return True
+
+    def characterReferenceInRcdata(self):
+        self.consumeEntity()
+        self.state = self.rcdataState
+        return True
+
+    def rawtextState(self):
+        data = self.stream.char()
+        if data == "<":
+            self.state = self.rawtextLessThanSignState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "\uFFFD"})
+        elif data == EOF:
+            # Tokenization ends.
+            return False
+        else:
+            chars = self.stream.charsUntil(("<", "\u0000"))
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data":
+                                    data + chars})
+        return True
+
+    def scriptDataState(self):
+        data = self.stream.char()
+        if data == "<":
+            self.state = self.scriptDataLessThanSignState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "\uFFFD"})
+        elif data == EOF:
+            # Tokenization ends.
+            return False
+        else:
+            chars = self.stream.charsUntil(("<", "\u0000"))
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data":
+                                    data + chars})
+        return True
+
+    def plaintextState(self):
+        data = self.stream.char()
+        if data == EOF:
+            # Tokenization ends.
+            return False
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "\uFFFD"})
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data":
+                                    data + self.stream.charsUntil("\u0000")})
+        return True
+
+    def tagOpenState(self):
+        data = self.stream.char()
+        if data == "!":
+            self.state = self.markupDeclarationOpenState
+        elif data == "/":
+            self.state = self.closeTagOpenState
+        elif data in asciiLetters:
+            self.currentToken = {"type": tokenTypes["StartTag"],
+                                 "name": data, "data": [],
+                                 "selfClosing": False,
+                                 "selfClosingAcknowledged": False}
+            self.state = self.tagNameState
+        elif data == ">":
+            # XXX In theory it could be something besides a tag name. But
+            # do we really care?
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-tag-name-but-got-right-bracket"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<>"})
+            self.state = self.dataState
+        elif data == "?":
+            # XXX In theory it could be something besides a tag name. But
+            # do we really care?
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-tag-name-but-got-question-mark"})
+            self.stream.unget(data)
+            self.state = self.bogusCommentState
+        else:
+            # XXX
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-tag-name"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"})
+            self.stream.unget(data)
+            self.state = self.dataState
+        return True
+
+    def closeTagOpenState(self):
+        data = self.stream.char()
+        if data in asciiLetters:
+            self.currentToken = {"type": tokenTypes["EndTag"], "name": data,
+                                 "data": [], "selfClosing": False}
+            self.state = self.tagNameState
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-closing-tag-but-got-right-bracket"})
+            self.state = self.dataState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-closing-tag-but-got-eof"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "</"})
+            self.state = self.dataState
+        else:
+            # XXX data can be _'_...
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-closing-tag-but-got-char",
+                                    "datavars": {"data": data}})
+            self.stream.unget(data)
+            self.state = self.bogusCommentState
+        return True
+
+    def tagNameState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            self.state = self.beforeAttributeNameState
+        elif data == ">":
+            self.emitCurrentToken()
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-tag-name"})
+            self.state = self.dataState
+        elif data == "/":
+            self.state = self.selfClosingStartTagState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["name"] += "\uFFFD"
+        else:
+            self.currentToken["name"] += data
+            # (Don't use charsUntil here, because tag names are
+            # very short and it's faster to not do anything fancy)
+        return True
+
+    def rcdataLessThanSignState(self):
+        data = self.stream.char()
+        if data == "/":
+            self.temporaryBuffer = ""
+            self.state = self.rcdataEndTagOpenState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"})
+            self.stream.unget(data)
+            self.state = self.rcdataState
+        return True
+
+    def rcdataEndTagOpenState(self):
+        data = self.stream.char()
+        if data in asciiLetters:
+            self.temporaryBuffer += data
+            self.state = self.rcdataEndTagNameState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "</"})
+            self.stream.unget(data)
+            self.state = self.rcdataState
+        return True
+
+    def rcdataEndTagNameState(self):
+        appropriate = self.currentToken and self.currentToken["name"].lower() == self.temporaryBuffer.lower()
+        data = self.stream.char()
+        if data in spaceCharacters and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.state = self.beforeAttributeNameState
+        elif data == "/" and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.state = self.selfClosingStartTagState
+        elif data == ">" and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.emitCurrentToken()
+            self.state = self.dataState
+        elif data in asciiLetters:
+            self.temporaryBuffer += data
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "</" + self.temporaryBuffer})
+            self.stream.unget(data)
+            self.state = self.rcdataState
+        return True
+
+    def rawtextLessThanSignState(self):
+        data = self.stream.char()
+        if data == "/":
+            self.temporaryBuffer = ""
+            self.state = self.rawtextEndTagOpenState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"})
+            self.stream.unget(data)
+            self.state = self.rawtextState
+        return True
+
+    def rawtextEndTagOpenState(self):
+        data = self.stream.char()
+        if data in asciiLetters:
+            self.temporaryBuffer += data
+            self.state = self.rawtextEndTagNameState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "</"})
+            self.stream.unget(data)
+            self.state = self.rawtextState
+        return True
+
+    def rawtextEndTagNameState(self):
+        appropriate = self.currentToken and self.currentToken["name"].lower() == self.temporaryBuffer.lower()
+        data = self.stream.char()
+        if data in spaceCharacters and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.state = self.beforeAttributeNameState
+        elif data == "/" and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.state = self.selfClosingStartTagState
+        elif data == ">" and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.emitCurrentToken()
+            self.state = self.dataState
+        elif data in asciiLetters:
+            self.temporaryBuffer += data
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "</" + self.temporaryBuffer})
+            self.stream.unget(data)
+            self.state = self.rawtextState
+        return True
+
+    def scriptDataLessThanSignState(self):
+        data = self.stream.char()
+        if data == "/":
+            self.temporaryBuffer = ""
+            self.state = self.scriptDataEndTagOpenState
+        elif data == "!":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<!"})
+            self.state = self.scriptDataEscapeStartState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"})
+            self.stream.unget(data)
+            self.state = self.scriptDataState
+        return True
+
+    def scriptDataEndTagOpenState(self):
+        data = self.stream.char()
+        if data in asciiLetters:
+            self.temporaryBuffer += data
+            self.state = self.scriptDataEndTagNameState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "</"})
+            self.stream.unget(data)
+            self.state = self.scriptDataState
+        return True
+
+    def scriptDataEndTagNameState(self):
+        appropriate = self.currentToken and self.currentToken["name"].lower() == self.temporaryBuffer.lower()
+        data = self.stream.char()
+        if data in spaceCharacters and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.state = self.beforeAttributeNameState
+        elif data == "/" and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.state = self.selfClosingStartTagState
+        elif data == ">" and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.emitCurrentToken()
+            self.state = self.dataState
+        elif data in asciiLetters:
+            self.temporaryBuffer += data
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "</" + self.temporaryBuffer})
+            self.stream.unget(data)
+            self.state = self.scriptDataState
+        return True
+
+    def scriptDataEscapeStartState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "-"})
+            self.state = self.scriptDataEscapeStartDashState
+        else:
+            self.stream.unget(data)
+            self.state = self.scriptDataState
+        return True
+
+    def scriptDataEscapeStartDashState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "-"})
+            self.state = self.scriptDataEscapedDashDashState
+        else:
+            self.stream.unget(data)
+            self.state = self.scriptDataState
+        return True
+
+    def scriptDataEscapedState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "-"})
+            self.state = self.scriptDataEscapedDashState
+        elif data == "<":
+            self.state = self.scriptDataEscapedLessThanSignState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "\uFFFD"})
+        elif data == EOF:
+            self.state = self.dataState
+        else:
+            chars = self.stream.charsUntil(("<", "-", "\u0000"))
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data":
+                                    data + chars})
+        return True
+
+    def scriptDataEscapedDashState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "-"})
+            self.state = self.scriptDataEscapedDashDashState
+        elif data == "<":
+            self.state = self.scriptDataEscapedLessThanSignState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "\uFFFD"})
+            self.state = self.scriptDataEscapedState
+        elif data == EOF:
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data})
+            self.state = self.scriptDataEscapedState
+        return True
+
+    def scriptDataEscapedDashDashState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "-"})
+        elif data == "<":
+            self.state = self.scriptDataEscapedLessThanSignState
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": ">"})
+            self.state = self.scriptDataState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "\uFFFD"})
+            self.state = self.scriptDataEscapedState
+        elif data == EOF:
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data})
+            self.state = self.scriptDataEscapedState
+        return True
+
+    def scriptDataEscapedLessThanSignState(self):
+        data = self.stream.char()
+        if data == "/":
+            self.temporaryBuffer = ""
+            self.state = self.scriptDataEscapedEndTagOpenState
+        elif data in asciiLetters:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<" + data})
+            self.temporaryBuffer = data
+            self.state = self.scriptDataDoubleEscapeStartState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"})
+            self.stream.unget(data)
+            self.state = self.scriptDataEscapedState
+        return True
+
+    def scriptDataEscapedEndTagOpenState(self):
+        data = self.stream.char()
+        if data in asciiLetters:
+            self.temporaryBuffer = data
+            self.state = self.scriptDataEscapedEndTagNameState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "</"})
+            self.stream.unget(data)
+            self.state = self.scriptDataEscapedState
+        return True
+
+    def scriptDataEscapedEndTagNameState(self):
+        appropriate = self.currentToken and self.currentToken["name"].lower() == self.temporaryBuffer.lower()
+        data = self.stream.char()
+        if data in spaceCharacters and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.state = self.beforeAttributeNameState
+        elif data == "/" and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.state = self.selfClosingStartTagState
+        elif data == ">" and appropriate:
+            self.currentToken = {"type": tokenTypes["EndTag"],
+                                 "name": self.temporaryBuffer,
+                                 "data": [], "selfClosing": False}
+            self.emitCurrentToken()
+            self.state = self.dataState
+        elif data in asciiLetters:
+            self.temporaryBuffer += data
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "</" + self.temporaryBuffer})
+            self.stream.unget(data)
+            self.state = self.scriptDataEscapedState
+        return True
+
+    def scriptDataDoubleEscapeStartState(self):
+        data = self.stream.char()
+        if data in (spaceCharacters | frozenset(("/", ">"))):
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data})
+            if self.temporaryBuffer.lower() == "script":
+                self.state = self.scriptDataDoubleEscapedState
+            else:
+                self.state = self.scriptDataEscapedState
+        elif data in asciiLetters:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data})
+            self.temporaryBuffer += data
+        else:
+            self.stream.unget(data)
+            self.state = self.scriptDataEscapedState
+        return True
+
+    def scriptDataDoubleEscapedState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "-"})
+            self.state = self.scriptDataDoubleEscapedDashState
+        elif data == "<":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"})
+            self.state = self.scriptDataDoubleEscapedLessThanSignState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "\uFFFD"})
+        elif data == EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-script-in-script"})
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data})
+        return True
+
+    def scriptDataDoubleEscapedDashState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "-"})
+            self.state = self.scriptDataDoubleEscapedDashDashState
+        elif data == "<":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"})
+            self.state = self.scriptDataDoubleEscapedLessThanSignState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "\uFFFD"})
+            self.state = self.scriptDataDoubleEscapedState
+        elif data == EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-script-in-script"})
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data})
+            self.state = self.scriptDataDoubleEscapedState
+        return True
+
+    def scriptDataDoubleEscapedDashDashState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "-"})
+        elif data == "<":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"})
+            self.state = self.scriptDataDoubleEscapedLessThanSignState
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": ">"})
+            self.state = self.scriptDataState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": "\uFFFD"})
+            self.state = self.scriptDataDoubleEscapedState
+        elif data == EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-script-in-script"})
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data})
+            self.state = self.scriptDataDoubleEscapedState
+        return True
+
+    def scriptDataDoubleEscapedLessThanSignState(self):
+        data = self.stream.char()
+        if data == "/":
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "/"})
+            self.temporaryBuffer = ""
+            self.state = self.scriptDataDoubleEscapeEndState
+        else:
+            self.stream.unget(data)
+            self.state = self.scriptDataDoubleEscapedState
+        return True
+
+    def scriptDataDoubleEscapeEndState(self):
+        data = self.stream.char()
+        if data in (spaceCharacters | frozenset(("/", ">"))):
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data})
+            if self.temporaryBuffer.lower() == "script":
+                self.state = self.scriptDataEscapedState
+            else:
+                self.state = self.scriptDataDoubleEscapedState
+        elif data in asciiLetters:
+            self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data})
+            self.temporaryBuffer += data
+        else:
+            self.stream.unget(data)
+            self.state = self.scriptDataDoubleEscapedState
+        return True
+
+    def beforeAttributeNameState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            self.stream.charsUntil(spaceCharacters, True)
+        elif data in asciiLetters:
+            self.currentToken["data"].append([data, ""])
+            self.state = self.attributeNameState
+        elif data == ">":
+            self.emitCurrentToken()
+        elif data == "/":
+            self.state = self.selfClosingStartTagState
+        elif data in ("'", '"', "=", "<"):
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "invalid-character-in-attribute-name"})
+            self.currentToken["data"].append([data, ""])
+            self.state = self.attributeNameState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"].append(["\uFFFD", ""])
+            self.state = self.attributeNameState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-attribute-name-but-got-eof"})
+            self.state = self.dataState
+        else:
+            self.currentToken["data"].append([data, ""])
+            self.state = self.attributeNameState
+        return True
+
+    def attributeNameState(self):
+        data = self.stream.char()
+        leavingThisState = True
+        emitToken = False
+        if data == "=":
+            self.state = self.beforeAttributeValueState
+        elif data in asciiLetters:
+            self.currentToken["data"][-1][0] += data +\
+                self.stream.charsUntil(asciiLetters, True)
+            leavingThisState = False
+        elif data == ">":
+            # XXX If we emit here the attributes are converted to a dict
+            # without being checked and when the code below runs we error
+            # because data is a dict not a list
+            emitToken = True
+        elif data in spaceCharacters:
+            self.state = self.afterAttributeNameState
+        elif data == "/":
+            self.state = self.selfClosingStartTagState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"][-1][0] += "\uFFFD"
+            leavingThisState = False
+        elif data in ("'", '"', "<"):
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data":
+                                    "invalid-character-in-attribute-name"})
+            self.currentToken["data"][-1][0] += data
+            leavingThisState = False
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "eof-in-attribute-name"})
+            self.state = self.dataState
+        else:
+            self.currentToken["data"][-1][0] += data
+            leavingThisState = False
+
+        if leavingThisState:
+            # Attributes are not dropped at this stage. That happens when the
+            # start tag token is emitted so values can still be safely appended
+            # to attributes, but we do want to report the parse error in time.
+            self.currentToken["data"][-1][0] = (
+                self.currentToken["data"][-1][0].translate(asciiUpper2Lower))
+            for name, _ in self.currentToken["data"][:-1]:
+                if self.currentToken["data"][-1][0] == name:
+                    self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                            "duplicate-attribute"})
+                    break
+            # XXX Fix for above XXX
+            if emitToken:
+                self.emitCurrentToken()
+        return True
+
+    def afterAttributeNameState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            self.stream.charsUntil(spaceCharacters, True)
+        elif data == "=":
+            self.state = self.beforeAttributeValueState
+        elif data == ">":
+            self.emitCurrentToken()
+        elif data in asciiLetters:
+            self.currentToken["data"].append([data, ""])
+            self.state = self.attributeNameState
+        elif data == "/":
+            self.state = self.selfClosingStartTagState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"].append(["\uFFFD", ""])
+            self.state = self.attributeNameState
+        elif data in ("'", '"', "<"):
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "invalid-character-after-attribute-name"})
+            self.currentToken["data"].append([data, ""])
+            self.state = self.attributeNameState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-end-of-tag-but-got-eof"})
+            self.state = self.dataState
+        else:
+            self.currentToken["data"].append([data, ""])
+            self.state = self.attributeNameState
+        return True
+
+    def beforeAttributeValueState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            self.stream.charsUntil(spaceCharacters, True)
+        elif data == "\"":
+            self.state = self.attributeValueDoubleQuotedState
+        elif data == "&":
+            self.state = self.attributeValueUnQuotedState
+            self.stream.unget(data)
+        elif data == "'":
+            self.state = self.attributeValueSingleQuotedState
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-attribute-value-but-got-right-bracket"})
+            self.emitCurrentToken()
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"][-1][1] += "\uFFFD"
+            self.state = self.attributeValueUnQuotedState
+        elif data in ("=", "<", "`"):
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "equals-in-unquoted-attribute-value"})
+            self.currentToken["data"][-1][1] += data
+            self.state = self.attributeValueUnQuotedState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-attribute-value-but-got-eof"})
+            self.state = self.dataState
+        else:
+            self.currentToken["data"][-1][1] += data
+            self.state = self.attributeValueUnQuotedState
+        return True
+
+    def attributeValueDoubleQuotedState(self):
+        data = self.stream.char()
+        if data == "\"":
+            self.state = self.afterAttributeValueState
+        elif data == "&":
+            self.processEntityInAttribute('"')
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"][-1][1] += "\uFFFD"
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-attribute-value-double-quote"})
+            self.state = self.dataState
+        else:
+            self.currentToken["data"][-1][1] += data +\
+                self.stream.charsUntil(("\"", "&", "\u0000"))
+        return True
+
+    def attributeValueSingleQuotedState(self):
+        data = self.stream.char()
+        if data == "'":
+            self.state = self.afterAttributeValueState
+        elif data == "&":
+            self.processEntityInAttribute("'")
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"][-1][1] += "\uFFFD"
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-attribute-value-single-quote"})
+            self.state = self.dataState
+        else:
+            self.currentToken["data"][-1][1] += data +\
+                self.stream.charsUntil(("'", "&", "\u0000"))
+        return True
+
+    def attributeValueUnQuotedState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            self.state = self.beforeAttributeNameState
+        elif data == "&":
+            self.processEntityInAttribute(">")
+        elif data == ">":
+            self.emitCurrentToken()
+        elif data in ('"', "'", "=", "<", "`"):
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-character-in-unquoted-attribute-value"})
+            self.currentToken["data"][-1][1] += data
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"][-1][1] += "\uFFFD"
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-attribute-value-no-quotes"})
+            self.state = self.dataState
+        else:
+            self.currentToken["data"][-1][1] += data + self.stream.charsUntil(
+                frozenset(("&", ">", '"', "'", "=", "<", "`", "\u0000")) | spaceCharacters)
+        return True
+
+    def afterAttributeValueState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            self.state = self.beforeAttributeNameState
+        elif data == ">":
+            self.emitCurrentToken()
+        elif data == "/":
+            self.state = self.selfClosingStartTagState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-EOF-after-attribute-value"})
+            self.stream.unget(data)
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-character-after-attribute-value"})
+            self.stream.unget(data)
+            self.state = self.beforeAttributeNameState
+        return True
+
+    def selfClosingStartTagState(self):
+        data = self.stream.char()
+        if data == ">":
+            self.currentToken["selfClosing"] = True
+            self.emitCurrentToken()
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data":
+                                    "unexpected-EOF-after-solidus-in-tag"})
+            self.stream.unget(data)
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-character-after-solidus-in-tag"})
+            self.stream.unget(data)
+            self.state = self.beforeAttributeNameState
+        return True
+
+    def bogusCommentState(self):
+        # Make a new comment token and give it as value all the characters
+        # until the first > or EOF (charsUntil checks for EOF automatically)
+        # and emit it.
+        data = self.stream.charsUntil(">")
+        data = data.replace("\u0000", "\uFFFD")
+        self.tokenQueue.append(
+            {"type": tokenTypes["Comment"], "data": data})
+
+        # Eat the character directly after the bogus comment which is either a
+        # ">" or an EOF.
+        self.stream.char()
+        self.state = self.dataState
+        return True
+
+    def markupDeclarationOpenState(self):
+        charStack = [self.stream.char()]
+        if charStack[-1] == "-":
+            charStack.append(self.stream.char())
+            if charStack[-1] == "-":
+                self.currentToken = {"type": tokenTypes["Comment"], "data": ""}
+                self.state = self.commentStartState
+                return True
+        elif charStack[-1] in ('d', 'D'):
+            matched = True
+            for expected in (('o', 'O'), ('c', 'C'), ('t', 'T'),
+                             ('y', 'Y'), ('p', 'P'), ('e', 'E')):
+                charStack.append(self.stream.char())
+                if charStack[-1] not in expected:
+                    matched = False
+                    break
+            if matched:
+                self.currentToken = {"type": tokenTypes["Doctype"],
+                                     "name": "",
+                                     "publicId": None, "systemId": None,
+                                     "correct": True}
+                self.state = self.doctypeState
+                return True
+        elif (charStack[-1] == "[" and
+              self.parser is not None and
+              self.parser.tree.openElements and
+              self.parser.tree.openElements[-1].namespace != self.parser.tree.defaultNamespace):
+            matched = True
+            for expected in ["C", "D", "A", "T", "A", "["]:
+                charStack.append(self.stream.char())
+                if charStack[-1] != expected:
+                    matched = False
+                    break
+            if matched:
+                self.state = self.cdataSectionState
+                return True
+
+        self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                "expected-dashes-or-doctype"})
+
+        while charStack:
+            self.stream.unget(charStack.pop())
+        self.state = self.bogusCommentState
+        return True
+
+    def commentStartState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.state = self.commentStartDashState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"] += "\uFFFD"
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "incorrect-comment"})
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-comment"})
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.currentToken["data"] += data
+            self.state = self.commentState
+        return True
+
+    def commentStartDashState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.state = self.commentEndState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"] += "-\uFFFD"
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "incorrect-comment"})
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-comment"})
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.currentToken["data"] += "-" + data
+            self.state = self.commentState
+        return True
+
+    def commentState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.state = self.commentEndDashState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"] += "\uFFFD"
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "eof-in-comment"})
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.currentToken["data"] += data + \
+                self.stream.charsUntil(("-", "\u0000"))
+        return True
+
+    def commentEndDashState(self):
+        data = self.stream.char()
+        if data == "-":
+            self.state = self.commentEndState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"] += "-\uFFFD"
+            self.state = self.commentState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-comment-end-dash"})
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.currentToken["data"] += "-" + data
+            self.state = self.commentState
+        return True
+
+    def commentEndState(self):
+        data = self.stream.char()
+        if data == ">":
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"] += "--\uFFFD"
+            self.state = self.commentState
+        elif data == "!":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-bang-after-double-dash-in-comment"})
+            self.state = self.commentEndBangState
+        elif data == "-":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-dash-after-double-dash-in-comment"})
+            self.currentToken["data"] += data
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-comment-double-dash"})
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            # XXX
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-char-in-comment"})
+            self.currentToken["data"] += "--" + data
+            self.state = self.commentState
+        return True
+
+    def commentEndBangState(self):
+        data = self.stream.char()
+        if data == ">":
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data == "-":
+            self.currentToken["data"] += "--!"
+            self.state = self.commentEndDashState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["data"] += "--!\uFFFD"
+            self.state = self.commentState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-comment-end-bang-state"})
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.currentToken["data"] += "--!" + data
+            self.state = self.commentState
+        return True
+
+    def doctypeState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            self.state = self.beforeDoctypeNameState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-doctype-name-but-got-eof"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "need-space-after-doctype"})
+            self.stream.unget(data)
+            self.state = self.beforeDoctypeNameState
+        return True
+
+    def beforeDoctypeNameState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            pass
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-doctype-name-but-got-right-bracket"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["name"] = "\uFFFD"
+            self.state = self.doctypeNameState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-doctype-name-but-got-eof"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.currentToken["name"] = data
+            self.state = self.doctypeNameState
+        return True
+
+    def doctypeNameState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            self.currentToken["name"] = self.currentToken["name"].translate(asciiUpper2Lower)
+            self.state = self.afterDoctypeNameState
+        elif data == ">":
+            self.currentToken["name"] = self.currentToken["name"].translate(asciiUpper2Lower)
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["name"] += "\uFFFD"
+            self.state = self.doctypeNameState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype-name"})
+            self.currentToken["correct"] = False
+            self.currentToken["name"] = self.currentToken["name"].translate(asciiUpper2Lower)
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.currentToken["name"] += data
+        return True
+
+    def afterDoctypeNameState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            pass
+        elif data == ">":
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data is EOF:
+            self.currentToken["correct"] = False
+            self.stream.unget(data)
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            if data in ("p", "P"):
+                matched = True
+                for expected in (("u", "U"), ("b", "B"), ("l", "L"),
+                                 ("i", "I"), ("c", "C")):
+                    data = self.stream.char()
+                    if data not in expected:
+                        matched = False
+                        break
+                if matched:
+                    self.state = self.afterDoctypePublicKeywordState
+                    return True
+            elif data in ("s", "S"):
+                matched = True
+                for expected in (("y", "Y"), ("s", "S"), ("t", "T"),
+                                 ("e", "E"), ("m", "M")):
+                    data = self.stream.char()
+                    if data not in expected:
+                        matched = False
+                        break
+                if matched:
+                    self.state = self.afterDoctypeSystemKeywordState
+                    return True
+
+            # All the characters read before the current 'data' will be
+            # [a-zA-Z], so they're garbage in the bogus doctype and can be
+            # discarded; only the latest character might be '>' or EOF
+            # and needs to be ungetted
+            self.stream.unget(data)
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "expected-space-or-right-bracket-in-doctype", "datavars":
+                                    {"data": data}})
+            self.currentToken["correct"] = False
+            self.state = self.bogusDoctypeState
+
+        return True
+
+    def afterDoctypePublicKeywordState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            self.state = self.beforeDoctypePublicIdentifierState
+        elif data in ("'", '"'):
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-char-in-doctype"})
+            self.stream.unget(data)
+            self.state = self.beforeDoctypePublicIdentifierState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.stream.unget(data)
+            self.state = self.beforeDoctypePublicIdentifierState
+        return True
+
+    def beforeDoctypePublicIdentifierState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            pass
+        elif data == "\"":
+            self.currentToken["publicId"] = ""
+            self.state = self.doctypePublicIdentifierDoubleQuotedState
+        elif data == "'":
+            self.currentToken["publicId"] = ""
+            self.state = self.doctypePublicIdentifierSingleQuotedState
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-end-of-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-char-in-doctype"})
+            self.currentToken["correct"] = False
+            self.state = self.bogusDoctypeState
+        return True
+
+    def doctypePublicIdentifierDoubleQuotedState(self):
+        data = self.stream.char()
+        if data == "\"":
+            self.state = self.afterDoctypePublicIdentifierState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["publicId"] += "\uFFFD"
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-end-of-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.currentToken["publicId"] += data
+        return True
+
+    def doctypePublicIdentifierSingleQuotedState(self):
+        data = self.stream.char()
+        if data == "'":
+            self.state = self.afterDoctypePublicIdentifierState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["publicId"] += "\uFFFD"
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-end-of-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.currentToken["publicId"] += data
+        return True
+
+    def afterDoctypePublicIdentifierState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            self.state = self.betweenDoctypePublicAndSystemIdentifiersState
+        elif data == ">":
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data == '"':
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-char-in-doctype"})
+            self.currentToken["systemId"] = ""
+            self.state = self.doctypeSystemIdentifierDoubleQuotedState
+        elif data == "'":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-char-in-doctype"})
+            self.currentToken["systemId"] = ""
+            self.state = self.doctypeSystemIdentifierSingleQuotedState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-char-in-doctype"})
+            self.currentToken["correct"] = False
+            self.state = self.bogusDoctypeState
+        return True
+
+    def betweenDoctypePublicAndSystemIdentifiersState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            pass
+        elif data == ">":
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data == '"':
+            self.currentToken["systemId"] = ""
+            self.state = self.doctypeSystemIdentifierDoubleQuotedState
+        elif data == "'":
+            self.currentToken["systemId"] = ""
+            self.state = self.doctypeSystemIdentifierSingleQuotedState
+        elif data == EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-char-in-doctype"})
+            self.currentToken["correct"] = False
+            self.state = self.bogusDoctypeState
+        return True
+
+    def afterDoctypeSystemKeywordState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            self.state = self.beforeDoctypeSystemIdentifierState
+        elif data in ("'", '"'):
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-char-in-doctype"})
+            self.stream.unget(data)
+            self.state = self.beforeDoctypeSystemIdentifierState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.stream.unget(data)
+            self.state = self.beforeDoctypeSystemIdentifierState
+        return True
+
+    def beforeDoctypeSystemIdentifierState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            pass
+        elif data == "\"":
+            self.currentToken["systemId"] = ""
+            self.state = self.doctypeSystemIdentifierDoubleQuotedState
+        elif data == "'":
+            self.currentToken["systemId"] = ""
+            self.state = self.doctypeSystemIdentifierSingleQuotedState
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-char-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-char-in-doctype"})
+            self.currentToken["correct"] = False
+            self.state = self.bogusDoctypeState
+        return True
+
+    def doctypeSystemIdentifierDoubleQuotedState(self):
+        data = self.stream.char()
+        if data == "\"":
+            self.state = self.afterDoctypeSystemIdentifierState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["systemId"] += "\uFFFD"
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-end-of-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.currentToken["systemId"] += data
+        return True
+
+    def doctypeSystemIdentifierSingleQuotedState(self):
+        data = self.stream.char()
+        if data == "'":
+            self.state = self.afterDoctypeSystemIdentifierState
+        elif data == "\u0000":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                    "data": "invalid-codepoint"})
+            self.currentToken["systemId"] += "\uFFFD"
+        elif data == ">":
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-end-of-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.currentToken["systemId"] += data
+        return True
+
+    def afterDoctypeSystemIdentifierState(self):
+        data = self.stream.char()
+        if data in spaceCharacters:
+            pass
+        elif data == ">":
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data is EOF:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "eof-in-doctype"})
+            self.currentToken["correct"] = False
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            self.tokenQueue.append({"type": tokenTypes["ParseError"], "data":
+                                    "unexpected-char-in-doctype"})
+            self.state = self.bogusDoctypeState
+        return True
+
+    def bogusDoctypeState(self):
+        data = self.stream.char()
+        if data == ">":
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        elif data is EOF:
+            # XXX EMIT
+            self.stream.unget(data)
+            self.tokenQueue.append(self.currentToken)
+            self.state = self.dataState
+        else:
+            pass
+        return True
+
+    def cdataSectionState(self):
+        data = []
+        while True:
+            data.append(self.stream.charsUntil("]"))
+            data.append(self.stream.charsUntil(">"))
+            char = self.stream.char()
+            if char == EOF:
+                break
+            else:
+                assert char == ">"
+                if data[-1][-2:] == "]]":
+                    data[-1] = data[-1][:-2]
+                    break
+                else:
+                    data.append(char)
+
+        data = "".join(data)  # pylint:disable=redefined-variable-type
+        # Deal with null here rather than in the parser
+        nullCount = data.count("\u0000")
+        if nullCount > 0:
+            for _ in range(nullCount):
+                self.tokenQueue.append({"type": tokenTypes["ParseError"],
+                                        "data": "invalid-codepoint"})
+            data = data.replace("\u0000", "\uFFFD")
+        if data:
+            self.tokenQueue.append({"type": tokenTypes["Characters"],
+                                    "data": data})
+        self.state = self.dataState
+        return True
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_trie/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_trie/__init__.py
new file mode 100644
index 0000000..07bad5d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_trie/__init__.py
@@ -0,0 +1,5 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from .py import Trie
+
+__all__ = ["Trie"]
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_trie/_base.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_trie/_base.py
new file mode 100644
index 0000000..6b71975
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_trie/_base.py
@@ -0,0 +1,40 @@
+from __future__ import absolute_import, division, unicode_literals
+
+try:
+    from collections.abc import Mapping
+except ImportError:  # Python 2.7
+    from collections import Mapping
+
+
+class Trie(Mapping):
+    """Abstract base class for tries"""
+
+    def keys(self, prefix=None):
+        # pylint:disable=arguments-differ
+        keys = super(Trie, self).keys()
+
+        if prefix is None:
+            return set(keys)
+
+        return {x for x in keys if x.startswith(prefix)}
+
+    def has_keys_with_prefix(self, prefix):
+        for key in self.keys():
+            if key.startswith(prefix):
+                return True
+
+        return False
+
+    def longest_prefix(self, prefix):
+        if prefix in self:
+            return prefix
+
+        for i in range(1, len(prefix) + 1):
+            if prefix[:-i] in self:
+                return prefix[:-i]
+
+        raise KeyError(prefix)
+
+    def longest_prefix_item(self, prefix):
+        lprefix = self.longest_prefix(prefix)
+        return (lprefix, self[lprefix])
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_trie/py.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_trie/py.py
new file mode 100644
index 0000000..c178b21
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_trie/py.py
@@ -0,0 +1,67 @@
+from __future__ import absolute_import, division, unicode_literals
+from pip._vendor.six import text_type
+
+from bisect import bisect_left
+
+from ._base import Trie as ABCTrie
+
+
+class Trie(ABCTrie):
+    def __init__(self, data):
+        if not all(isinstance(x, text_type) for x in data.keys()):
+            raise TypeError("All keys must be strings")
+
+        self._data = data
+        self._keys = sorted(data.keys())
+        self._cachestr = ""
+        self._cachepoints = (0, len(data))
+
+    def __contains__(self, key):
+        return key in self._data
+
+    def __len__(self):
+        return len(self._data)
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def keys(self, prefix=None):
+        if prefix is None or prefix == "" or not self._keys:
+            return set(self._keys)
+
+        if prefix.startswith(self._cachestr):
+            lo, hi = self._cachepoints
+            start = i = bisect_left(self._keys, prefix, lo, hi)
+        else:
+            start = i = bisect_left(self._keys, prefix)
+
+        keys = set()
+        if start == len(self._keys):
+            return keys
+
+        while self._keys[i].startswith(prefix):
+            keys.add(self._keys[i])
+            i += 1
+
+        self._cachestr = prefix
+        self._cachepoints = (start, i)
+
+        return keys
+
+    def has_keys_with_prefix(self, prefix):
+        if prefix in self._data:
+            return True
+
+        if prefix.startswith(self._cachestr):
+            lo, hi = self._cachepoints
+            i = bisect_left(self._keys, prefix, lo, hi)
+        else:
+            i = bisect_left(self._keys, prefix)
+
+        if i == len(self._keys):
+            return False
+
+        return self._keys[i].startswith(prefix)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_utils.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_utils.py
new file mode 100644
index 0000000..d7c4926
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/_utils.py
@@ -0,0 +1,159 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from types import ModuleType
+
+try:
+    from collections.abc import Mapping
+except ImportError:
+    from collections import Mapping
+
+from pip._vendor.six import text_type, PY3
+
+if PY3:
+    import xml.etree.ElementTree as default_etree
+else:
+    try:
+        import xml.etree.cElementTree as default_etree
+    except ImportError:
+        import xml.etree.ElementTree as default_etree
+
+
+__all__ = ["default_etree", "MethodDispatcher", "isSurrogatePair",
+           "surrogatePairToCodepoint", "moduleFactoryFactory",
+           "supports_lone_surrogates"]
+
+
+# Platforms not supporting lone surrogates (\uD800-\uDFFF) should be
+# caught by the below test. In general this would be any platform
+# using UTF-16 as its encoding of unicode strings, such as
+# Jython. This is because UTF-16 itself is based on the use of such
+# surrogates, and there is no mechanism to further escape such
+# escapes.
+try:
+    _x = eval('"\\uD800"')  # pylint:disable=eval-used
+    if not isinstance(_x, text_type):
+        # We need this with u"" because of http://bugs.jython.org/issue2039
+        _x = eval('u"\\uD800"')  # pylint:disable=eval-used
+        assert isinstance(_x, text_type)
+except Exception:
+    supports_lone_surrogates = False
+else:
+    supports_lone_surrogates = True
+
+
+class MethodDispatcher(dict):
+    """Dict with 2 special properties:
+
+    On initiation, keys that are lists, sets or tuples are converted to
+    multiple keys so accessing any one of the items in the original
+    list-like object returns the matching value
+
+    md = MethodDispatcher({("foo", "bar"):"baz"})
+    md["foo"] == "baz"
+
+    A default value which can be set through the default attribute.
+    """
+
+    def __init__(self, items=()):
+        _dictEntries = []
+        for name, value in items:
+            if isinstance(name, (list, tuple, frozenset, set)):
+                for item in name:
+                    _dictEntries.append((item, value))
+            else:
+                _dictEntries.append((name, value))
+        dict.__init__(self, _dictEntries)
+        assert len(self) == len(_dictEntries)
+        self.default = None
+
+    def __getitem__(self, key):
+        return dict.get(self, key, self.default)
+
+    def __get__(self, instance, owner=None):
+        return BoundMethodDispatcher(instance, self)
+
+
+class BoundMethodDispatcher(Mapping):
+    """Wraps a MethodDispatcher, binding its return values to `instance`"""
+    def __init__(self, instance, dispatcher):
+        self.instance = instance
+        self.dispatcher = dispatcher
+
+    def __getitem__(self, key):
+        # see https://docs.python.org/3/reference/datamodel.html#object.__get__
+        # on a function, __get__ is used to bind a function to an instance as a bound method
+        return self.dispatcher[key].__get__(self.instance)
+
+    def get(self, key, default):
+        if key in self.dispatcher:
+            return self[key]
+        else:
+            return default
+
+    def __iter__(self):
+        return iter(self.dispatcher)
+
+    def __len__(self):
+        return len(self.dispatcher)
+
+    def __contains__(self, key):
+        return key in self.dispatcher
+
+
+# Some utility functions to deal with weirdness around UCS2 vs UCS4
+# python builds
+
+def isSurrogatePair(data):
+    return (len(data) == 2 and
+            ord(data[0]) >= 0xD800 and ord(data[0]) <= 0xDBFF and
+            ord(data[1]) >= 0xDC00 and ord(data[1]) <= 0xDFFF)
+
+
+def surrogatePairToCodepoint(data):
+    char_val = (0x10000 + (ord(data[0]) - 0xD800) * 0x400 +
+                (ord(data[1]) - 0xDC00))
+    return char_val
+
+# Module Factory Factory (no, this isn't Java, I know)
+# Here to stop this being duplicated all over the place.
+
+
+def moduleFactoryFactory(factory):
+    moduleCache = {}
+
+    def moduleFactory(baseModule, *args, **kwargs):
+        if isinstance(ModuleType.__name__, type("")):
+            name = "_%s_factory" % baseModule.__name__
+        else:
+            name = b"_%s_factory" % baseModule.__name__
+
+        kwargs_tuple = tuple(kwargs.items())
+
+        try:
+            return moduleCache[name][args][kwargs_tuple]
+        except KeyError:
+            mod = ModuleType(name)
+            objs = factory(baseModule, *args, **kwargs)
+            mod.__dict__.update(objs)
+            if "name" not in moduleCache:
+                moduleCache[name] = {}
+            if "args" not in moduleCache[name]:
+                moduleCache[name][args] = {}
+            if "kwargs" not in moduleCache[name][args]:
+                moduleCache[name][args][kwargs_tuple] = {}
+            moduleCache[name][args][kwargs_tuple] = mod
+            return mod
+
+    return moduleFactory
+
+
+def memoize(func):
+    cache = {}
+
+    def wrapped(*args, **kwargs):
+        key = (tuple(args), tuple(kwargs.items()))
+        if key not in cache:
+            cache[key] = func(*args, **kwargs)
+        return cache[key]
+
+    return wrapped
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/constants.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/constants.py
new file mode 100644
index 0000000..fe3e237
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/constants.py
@@ -0,0 +1,2946 @@
+from __future__ import absolute_import, division, unicode_literals
+
+import string
+
+EOF = None
+
+E = {
+    "null-character":
+        "Null character in input stream, replaced with U+FFFD.",
+    "invalid-codepoint":
+        "Invalid codepoint in stream.",
+    "incorrectly-placed-solidus":
+        "Solidus (/) incorrectly placed in tag.",
+    "incorrect-cr-newline-entity":
+        "Incorrect CR newline entity, replaced with LF.",
+    "illegal-windows-1252-entity":
+        "Entity used with illegal number (windows-1252 reference).",
+    "cant-convert-numeric-entity":
+        "Numeric entity couldn't be converted to character "
+        "(codepoint U+%(charAsInt)08x).",
+    "illegal-codepoint-for-numeric-entity":
+        "Numeric entity represents an illegal codepoint: "
+        "U+%(charAsInt)08x.",
+    "numeric-entity-without-semicolon":
+        "Numeric entity didn't end with ';'.",
+    "expected-numeric-entity-but-got-eof":
+        "Numeric entity expected. Got end of file instead.",
+    "expected-numeric-entity":
+        "Numeric entity expected but none found.",
+    "named-entity-without-semicolon":
+        "Named entity didn't end with ';'.",
+    "expected-named-entity":
+        "Named entity expected. Got none.",
+    "attributes-in-end-tag":
+        "End tag contains unexpected attributes.",
+    'self-closing-flag-on-end-tag':
+        "End tag contains unexpected self-closing flag.",
+    "expected-tag-name-but-got-right-bracket":
+        "Expected tag name. Got '>' instead.",
+    "expected-tag-name-but-got-question-mark":
+        "Expected tag name. Got '?' instead. (HTML doesn't "
+        "support processing instructions.)",
+    "expected-tag-name":
+        "Expected tag name. Got something else instead",
+    "expected-closing-tag-but-got-right-bracket":
+        "Expected closing tag. Got '>' instead. Ignoring '</>'.",
+    "expected-closing-tag-but-got-eof":
+        "Expected closing tag. Unexpected end of file.",
+    "expected-closing-tag-but-got-char":
+        "Expected closing tag. Unexpected character '%(data)s' found.",
+    "eof-in-tag-name":
+        "Unexpected end of file in the tag name.",
+    "expected-attribute-name-but-got-eof":
+        "Unexpected end of file. Expected attribute name instead.",
+    "eof-in-attribute-name":
+        "Unexpected end of file in attribute name.",
+    "invalid-character-in-attribute-name":
+        "Invalid character in attribute name",
+    "duplicate-attribute":
+        "Dropped duplicate attribute on tag.",
+    "expected-end-of-tag-name-but-got-eof":
+        "Unexpected end of file. Expected = or end of tag.",
+    "expected-attribute-value-but-got-eof":
+        "Unexpected end of file. Expected attribute value.",
+    "expected-attribute-value-but-got-right-bracket":
+        "Expected attribute value. Got '>' instead.",
+    'equals-in-unquoted-attribute-value':
+        "Unexpected = in unquoted attribute",
+    'unexpected-character-in-unquoted-attribute-value':
+        "Unexpected character in unquoted attribute",
+    "invalid-character-after-attribute-name":
+        "Unexpected character after attribute name.",
+    "unexpected-character-after-attribute-value":
+        "Unexpected character after attribute value.",
+    "eof-in-attribute-value-double-quote":
+        "Unexpected end of file in attribute value (\").",
+    "eof-in-attribute-value-single-quote":
+        "Unexpected end of file in attribute value (').",
+    "eof-in-attribute-value-no-quotes":
+        "Unexpected end of file in attribute value.",
+    "unexpected-EOF-after-solidus-in-tag":
+        "Unexpected end of file in tag. Expected >",
+    "unexpected-character-after-solidus-in-tag":
+        "Unexpected character after / in tag. Expected >",
+    "expected-dashes-or-doctype":
+        "Expected '--' or 'DOCTYPE'. Not found.",
+    "unexpected-bang-after-double-dash-in-comment":
+        "Unexpected ! after -- in comment",
+    "unexpected-space-after-double-dash-in-comment":
+        "Unexpected space after -- in comment",
+    "incorrect-comment":
+        "Incorrect comment.",
+    "eof-in-comment":
+        "Unexpected end of file in comment.",
+    "eof-in-comment-end-dash":
+        "Unexpected end of file in comment (-)",
+    "unexpected-dash-after-double-dash-in-comment":
+        "Unexpected '-' after '--' found in comment.",
+    "eof-in-comment-double-dash":
+        "Unexpected end of file in comment (--).",
+    "eof-in-comment-end-space-state":
+        "Unexpected end of file in comment.",
+    "eof-in-comment-end-bang-state":
+        "Unexpected end of file in comment.",
+    "unexpected-char-in-comment":
+        "Unexpected character in comment found.",
+    "need-space-after-doctype":
+        "No space after literal string 'DOCTYPE'.",
+    "expected-doctype-name-but-got-right-bracket":
+        "Unexpected > character. Expected DOCTYPE name.",
+    "expected-doctype-name-but-got-eof":
+        "Unexpected end of file. Expected DOCTYPE name.",
+    "eof-in-doctype-name":
+        "Unexpected end of file in DOCTYPE name.",
+    "eof-in-doctype":
+        "Unexpected end of file in DOCTYPE.",
+    "expected-space-or-right-bracket-in-doctype":
+        "Expected space or '>'. Got '%(data)s'",
+    "unexpected-end-of-doctype":
+        "Unexpected end of DOCTYPE.",
+    "unexpected-char-in-doctype":
+        "Unexpected character in DOCTYPE.",
+    "eof-in-innerhtml":
+        "XXX innerHTML EOF",
+    "unexpected-doctype":
+        "Unexpected DOCTYPE. Ignored.",
+    "non-html-root":
+        "html needs to be the first start tag.",
+    "expected-doctype-but-got-eof":
+        "Unexpected End of file. Expected DOCTYPE.",
+    "unknown-doctype":
+        "Erroneous DOCTYPE.",
+    "expected-doctype-but-got-chars":
+        "Unexpected non-space characters. Expected DOCTYPE.",
+    "expected-doctype-but-got-start-tag":
+        "Unexpected start tag (%(name)s). Expected DOCTYPE.",
+    "expected-doctype-but-got-end-tag":
+        "Unexpected end tag (%(name)s). Expected DOCTYPE.",
+    "end-tag-after-implied-root":
+        "Unexpected end tag (%(name)s) after the (implied) root element.",
+    "expected-named-closing-tag-but-got-eof":
+        "Unexpected end of file. Expected end tag (%(name)s).",
+    "two-heads-are-not-better-than-one":
+        "Unexpected start tag head in existing head. Ignored.",
+    "unexpected-end-tag":
+        "Unexpected end tag (%(name)s). Ignored.",
+    "unexpected-start-tag-out-of-my-head":
+        "Unexpected start tag (%(name)s) that can be in head. Moved.",
+    "unexpected-start-tag":
+        "Unexpected start tag (%(name)s).",
+    "missing-end-tag":
+        "Missing end tag (%(name)s).",
+    "missing-end-tags":
+        "Missing end tags (%(name)s).",
+    "unexpected-start-tag-implies-end-tag":
+        "Unexpected start tag (%(startName)s) "
+        "implies end tag (%(endName)s).",
+    "unexpected-start-tag-treated-as":
+        "Unexpected start tag (%(originalName)s). Treated as %(newName)s.",
+    "deprecated-tag":
+        "Unexpected start tag %(name)s. Don't use it!",
+    "unexpected-start-tag-ignored":
+        "Unexpected start tag %(name)s. Ignored.",
+    "expected-one-end-tag-but-got-another":
+        "Unexpected end tag (%(gotName)s). "
+        "Missing end tag (%(expectedName)s).",
+    "end-tag-too-early":
+        "End tag (%(name)s) seen too early. Expected other end tag.",
+    "end-tag-too-early-named":
+        "Unexpected end tag (%(gotName)s). Expected end tag (%(expectedName)s).",
+    "end-tag-too-early-ignored":
+        "End tag (%(name)s) seen too early. Ignored.",
+    "adoption-agency-1.1":
+        "End tag (%(name)s) violates step 1, "
+        "paragraph 1 of the adoption agency algorithm.",
+    "adoption-agency-1.2":
+        "End tag (%(name)s) violates step 1, "
+        "paragraph 2 of the adoption agency algorithm.",
+    "adoption-agency-1.3":
+        "End tag (%(name)s) violates step 1, "
+        "paragraph 3 of the adoption agency algorithm.",
+    "adoption-agency-4.4":
+        "End tag (%(name)s) violates step 4, "
+        "paragraph 4 of the adoption agency algorithm.",
+    "unexpected-end-tag-treated-as":
+        "Unexpected end tag (%(originalName)s). Treated as %(newName)s.",
+    "no-end-tag":
+        "This element (%(name)s) has no end tag.",
+    "unexpected-implied-end-tag-in-table":
+        "Unexpected implied end tag (%(name)s) in the table phase.",
+    "unexpected-implied-end-tag-in-table-body":
+        "Unexpected implied end tag (%(name)s) in the table body phase.",
+    "unexpected-char-implies-table-voodoo":
+        "Unexpected non-space characters in "
+        "table context caused voodoo mode.",
+    "unexpected-hidden-input-in-table":
+        "Unexpected input with type hidden in table context.",
+    "unexpected-form-in-table":
+        "Unexpected form in table context.",
+    "unexpected-start-tag-implies-table-voodoo":
+        "Unexpected start tag (%(name)s) in "
+        "table context caused voodoo mode.",
+    "unexpected-end-tag-implies-table-voodoo":
+        "Unexpected end tag (%(name)s) in "
+        "table context caused voodoo mode.",
+    "unexpected-cell-in-table-body":
+        "Unexpected table cell start tag (%(name)s) "
+        "in the table body phase.",
+    "unexpected-cell-end-tag":
+        "Got table cell end tag (%(name)s) "
+        "while required end tags are missing.",
+    "unexpected-end-tag-in-table-body":
+        "Unexpected end tag (%(name)s) in the table body phase. Ignored.",
+    "unexpected-implied-end-tag-in-table-row":
+        "Unexpected implied end tag (%(name)s) in the table row phase.",
+    "unexpected-end-tag-in-table-row":
+        "Unexpected end tag (%(name)s) in the table row phase. Ignored.",
+    "unexpected-select-in-select":
+        "Unexpected select start tag in the select phase "
+        "treated as select end tag.",
+    "unexpected-input-in-select":
+        "Unexpected input start tag in the select phase.",
+    "unexpected-start-tag-in-select":
+        "Unexpected start tag token (%(name)s in the select phase. "
+        "Ignored.",
+    "unexpected-end-tag-in-select":
+        "Unexpected end tag (%(name)s) in the select phase. Ignored.",
+    "unexpected-table-element-start-tag-in-select-in-table":
+        "Unexpected table element start tag (%(name)s) in the select in table phase.",
+    "unexpected-table-element-end-tag-in-select-in-table":
+        "Unexpected table element end tag (%(name)s) in the select in table phase.",
+    "unexpected-char-after-body":
+        "Unexpected non-space characters in the after body phase.",
+    "unexpected-start-tag-after-body":
+        "Unexpected start tag token (%(name)s)"
+        " in the after body phase.",
+    "unexpected-end-tag-after-body":
+        "Unexpected end tag token (%(name)s)"
+        " in the after body phase.",
+    "unexpected-char-in-frameset":
+        "Unexpected characters in the frameset phase. Characters ignored.",
+    "unexpected-start-tag-in-frameset":
+        "Unexpected start tag token (%(name)s)"
+        " in the frameset phase. Ignored.",
+    "unexpected-frameset-in-frameset-innerhtml":
+        "Unexpected end tag token (frameset) "
+        "in the frameset phase (innerHTML).",
+    "unexpected-end-tag-in-frameset":
+        "Unexpected end tag token (%(name)s)"
+        " in the frameset phase. Ignored.",
+    "unexpected-char-after-frameset":
+        "Unexpected non-space characters in the "
+        "after frameset phase. Ignored.",
+    "unexpected-start-tag-after-frameset":
+        "Unexpected start tag (%(name)s)"
+        " in the after frameset phase. Ignored.",
+    "unexpected-end-tag-after-frameset":
+        "Unexpected end tag (%(name)s)"
+        " in the after frameset phase. Ignored.",
+    "unexpected-end-tag-after-body-innerhtml":
+        "Unexpected end tag after body(innerHtml)",
+    "expected-eof-but-got-char":
+        "Unexpected non-space characters. Expected end of file.",
+    "expected-eof-but-got-start-tag":
+        "Unexpected start tag (%(name)s)"
+        ". Expected end of file.",
+    "expected-eof-but-got-end-tag":
+        "Unexpected end tag (%(name)s)"
+        ". Expected end of file.",
+    "eof-in-table":
+        "Unexpected end of file. Expected table content.",
+    "eof-in-select":
+        "Unexpected end of file. Expected select content.",
+    "eof-in-frameset":
+        "Unexpected end of file. Expected frameset content.",
+    "eof-in-script-in-script":
+        "Unexpected end of file. Expected script content.",
+    "eof-in-foreign-lands":
+        "Unexpected end of file. Expected foreign content",
+    "non-void-element-with-trailing-solidus":
+        "Trailing solidus not allowed on element %(name)s",
+    "unexpected-html-element-in-foreign-content":
+        "Element %(name)s not allowed in a non-html context",
+    "unexpected-end-tag-before-html":
+        "Unexpected end tag (%(name)s) before html.",
+    "unexpected-inhead-noscript-tag":
+        "Element %(name)s not allowed in a inhead-noscript context",
+    "eof-in-head-noscript":
+        "Unexpected end of file. Expected inhead-noscript content",
+    "char-in-head-noscript":
+        "Unexpected non-space character. Expected inhead-noscript content",
+    "XXX-undefined-error":
+        "Undefined error (this sucks and should be fixed)",
+}
+
+namespaces = {
+    "html": "http://www.w3.org/1999/xhtml",
+    "mathml": "http://www.w3.org/1998/Math/MathML",
+    "svg": "http://www.w3.org/2000/svg",
+    "xlink": "http://www.w3.org/1999/xlink",
+    "xml": "http://www.w3.org/XML/1998/namespace",
+    "xmlns": "http://www.w3.org/2000/xmlns/"
+}
+
+scopingElements = frozenset([
+    (namespaces["html"], "applet"),
+    (namespaces["html"], "caption"),
+    (namespaces["html"], "html"),
+    (namespaces["html"], "marquee"),
+    (namespaces["html"], "object"),
+    (namespaces["html"], "table"),
+    (namespaces["html"], "td"),
+    (namespaces["html"], "th"),
+    (namespaces["mathml"], "mi"),
+    (namespaces["mathml"], "mo"),
+    (namespaces["mathml"], "mn"),
+    (namespaces["mathml"], "ms"),
+    (namespaces["mathml"], "mtext"),
+    (namespaces["mathml"], "annotation-xml"),
+    (namespaces["svg"], "foreignObject"),
+    (namespaces["svg"], "desc"),
+    (namespaces["svg"], "title"),
+])
+
+formattingElements = frozenset([
+    (namespaces["html"], "a"),
+    (namespaces["html"], "b"),
+    (namespaces["html"], "big"),
+    (namespaces["html"], "code"),
+    (namespaces["html"], "em"),
+    (namespaces["html"], "font"),
+    (namespaces["html"], "i"),
+    (namespaces["html"], "nobr"),
+    (namespaces["html"], "s"),
+    (namespaces["html"], "small"),
+    (namespaces["html"], "strike"),
+    (namespaces["html"], "strong"),
+    (namespaces["html"], "tt"),
+    (namespaces["html"], "u")
+])
+
+specialElements = frozenset([
+    (namespaces["html"], "address"),
+    (namespaces["html"], "applet"),
+    (namespaces["html"], "area"),
+    (namespaces["html"], "article"),
+    (namespaces["html"], "aside"),
+    (namespaces["html"], "base"),
+    (namespaces["html"], "basefont"),
+    (namespaces["html"], "bgsound"),
+    (namespaces["html"], "blockquote"),
+    (namespaces["html"], "body"),
+    (namespaces["html"], "br"),
+    (namespaces["html"], "button"),
+    (namespaces["html"], "caption"),
+    (namespaces["html"], "center"),
+    (namespaces["html"], "col"),
+    (namespaces["html"], "colgroup"),
+    (namespaces["html"], "command"),
+    (namespaces["html"], "dd"),
+    (namespaces["html"], "details"),
+    (namespaces["html"], "dir"),
+    (namespaces["html"], "div"),
+    (namespaces["html"], "dl"),
+    (namespaces["html"], "dt"),
+    (namespaces["html"], "embed"),
+    (namespaces["html"], "fieldset"),
+    (namespaces["html"], "figure"),
+    (namespaces["html"], "footer"),
+    (namespaces["html"], "form"),
+    (namespaces["html"], "frame"),
+    (namespaces["html"], "frameset"),
+    (namespaces["html"], "h1"),
+    (namespaces["html"], "h2"),
+    (namespaces["html"], "h3"),
+    (namespaces["html"], "h4"),
+    (namespaces["html"], "h5"),
+    (namespaces["html"], "h6"),
+    (namespaces["html"], "head"),
+    (namespaces["html"], "header"),
+    (namespaces["html"], "hr"),
+    (namespaces["html"], "html"),
+    (namespaces["html"], "iframe"),
+    # Note that image is commented out in the spec as "this isn't an
+    # element that can end up on the stack, so it doesn't matter,"
+    (namespaces["html"], "image"),
+    (namespaces["html"], "img"),
+    (namespaces["html"], "input"),
+    (namespaces["html"], "isindex"),
+    (namespaces["html"], "li"),
+    (namespaces["html"], "link"),
+    (namespaces["html"], "listing"),
+    (namespaces["html"], "marquee"),
+    (namespaces["html"], "menu"),
+    (namespaces["html"], "meta"),
+    (namespaces["html"], "nav"),
+    (namespaces["html"], "noembed"),
+    (namespaces["html"], "noframes"),
+    (namespaces["html"], "noscript"),
+    (namespaces["html"], "object"),
+    (namespaces["html"], "ol"),
+    (namespaces["html"], "p"),
+    (namespaces["html"], "param"),
+    (namespaces["html"], "plaintext"),
+    (namespaces["html"], "pre"),
+    (namespaces["html"], "script"),
+    (namespaces["html"], "section"),
+    (namespaces["html"], "select"),
+    (namespaces["html"], "style"),
+    (namespaces["html"], "table"),
+    (namespaces["html"], "tbody"),
+    (namespaces["html"], "td"),
+    (namespaces["html"], "textarea"),
+    (namespaces["html"], "tfoot"),
+    (namespaces["html"], "th"),
+    (namespaces["html"], "thead"),
+    (namespaces["html"], "title"),
+    (namespaces["html"], "tr"),
+    (namespaces["html"], "ul"),
+    (namespaces["html"], "wbr"),
+    (namespaces["html"], "xmp"),
+    (namespaces["svg"], "foreignObject")
+])
+
+htmlIntegrationPointElements = frozenset([
+    (namespaces["mathml"], "annotation-xml"),
+    (namespaces["svg"], "foreignObject"),
+    (namespaces["svg"], "desc"),
+    (namespaces["svg"], "title")
+])
+
+mathmlTextIntegrationPointElements = frozenset([
+    (namespaces["mathml"], "mi"),
+    (namespaces["mathml"], "mo"),
+    (namespaces["mathml"], "mn"),
+    (namespaces["mathml"], "ms"),
+    (namespaces["mathml"], "mtext")
+])
+
+adjustSVGAttributes = {
+    "attributename": "attributeName",
+    "attributetype": "attributeType",
+    "basefrequency": "baseFrequency",
+    "baseprofile": "baseProfile",
+    "calcmode": "calcMode",
+    "clippathunits": "clipPathUnits",
+    "contentscripttype": "contentScriptType",
+    "contentstyletype": "contentStyleType",
+    "diffuseconstant": "diffuseConstant",
+    "edgemode": "edgeMode",
+    "externalresourcesrequired": "externalResourcesRequired",
+    "filterres": "filterRes",
+    "filterunits": "filterUnits",
+    "glyphref": "glyphRef",
+    "gradienttransform": "gradientTransform",
+    "gradientunits": "gradientUnits",
+    "kernelmatrix": "kernelMatrix",
+    "kernelunitlength": "kernelUnitLength",
+    "keypoints": "keyPoints",
+    "keysplines": "keySplines",
+    "keytimes": "keyTimes",
+    "lengthadjust": "lengthAdjust",
+    "limitingconeangle": "limitingConeAngle",
+    "markerheight": "markerHeight",
+    "markerunits": "markerUnits",
+    "markerwidth": "markerWidth",
+    "maskcontentunits": "maskContentUnits",
+    "maskunits": "maskUnits",
+    "numoctaves": "numOctaves",
+    "pathlength": "pathLength",
+    "patterncontentunits": "patternContentUnits",
+    "patterntransform": "patternTransform",
+    "patternunits": "patternUnits",
+    "pointsatx": "pointsAtX",
+    "pointsaty": "pointsAtY",
+    "pointsatz": "pointsAtZ",
+    "preservealpha": "preserveAlpha",
+    "preserveaspectratio": "preserveAspectRatio",
+    "primitiveunits": "primitiveUnits",
+    "refx": "refX",
+    "refy": "refY",
+    "repeatcount": "repeatCount",
+    "repeatdur": "repeatDur",
+    "requiredextensions": "requiredExtensions",
+    "requiredfeatures": "requiredFeatures",
+    "specularconstant": "specularConstant",
+    "specularexponent": "specularExponent",
+    "spreadmethod": "spreadMethod",
+    "startoffset": "startOffset",
+    "stddeviation": "stdDeviation",
+    "stitchtiles": "stitchTiles",
+    "surfacescale": "surfaceScale",
+    "systemlanguage": "systemLanguage",
+    "tablevalues": "tableValues",
+    "targetx": "targetX",
+    "targety": "targetY",
+    "textlength": "textLength",
+    "viewbox": "viewBox",
+    "viewtarget": "viewTarget",
+    "xchannelselector": "xChannelSelector",
+    "ychannelselector": "yChannelSelector",
+    "zoomandpan": "zoomAndPan"
+}
+
+adjustMathMLAttributes = {"definitionurl": "definitionURL"}
+
+adjustForeignAttributes = {
+    "xlink:actuate": ("xlink", "actuate", namespaces["xlink"]),
+    "xlink:arcrole": ("xlink", "arcrole", namespaces["xlink"]),
+    "xlink:href": ("xlink", "href", namespaces["xlink"]),
+    "xlink:role": ("xlink", "role", namespaces["xlink"]),
+    "xlink:show": ("xlink", "show", namespaces["xlink"]),
+    "xlink:title": ("xlink", "title", namespaces["xlink"]),
+    "xlink:type": ("xlink", "type", namespaces["xlink"]),
+    "xml:base": ("xml", "base", namespaces["xml"]),
+    "xml:lang": ("xml", "lang", namespaces["xml"]),
+    "xml:space": ("xml", "space", namespaces["xml"]),
+    "xmlns": (None, "xmlns", namespaces["xmlns"]),
+    "xmlns:xlink": ("xmlns", "xlink", namespaces["xmlns"])
+}
+
+unadjustForeignAttributes = {(ns, local): qname for qname, (prefix, local, ns) in
+                             adjustForeignAttributes.items()}
+
+spaceCharacters = frozenset([
+    "\t",
+    "\n",
+    "\u000C",
+    " ",
+    "\r"
+])
+
+tableInsertModeElements = frozenset([
+    "table",
+    "tbody",
+    "tfoot",
+    "thead",
+    "tr"
+])
+
+asciiLowercase = frozenset(string.ascii_lowercase)
+asciiUppercase = frozenset(string.ascii_uppercase)
+asciiLetters = frozenset(string.ascii_letters)
+digits = frozenset(string.digits)
+hexDigits = frozenset(string.hexdigits)
+
+asciiUpper2Lower = {ord(c): ord(c.lower()) for c in string.ascii_uppercase}
+
+# Heading elements need to be ordered
+headingElements = (
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6"
+)
+
+voidElements = frozenset([
+    "base",
+    "command",
+    "event-source",
+    "link",
+    "meta",
+    "hr",
+    "br",
+    "img",
+    "embed",
+    "param",
+    "area",
+    "col",
+    "input",
+    "source",
+    "track"
+])
+
+cdataElements = frozenset(['title', 'textarea'])
+
+rcdataElements = frozenset([
+    'style',
+    'script',
+    'xmp',
+    'iframe',
+    'noembed',
+    'noframes',
+    'noscript'
+])
+
+booleanAttributes = {
+    "": frozenset(["irrelevant", "itemscope"]),
+    "style": frozenset(["scoped"]),
+    "img": frozenset(["ismap"]),
+    "audio": frozenset(["autoplay", "controls"]),
+    "video": frozenset(["autoplay", "controls"]),
+    "script": frozenset(["defer", "async"]),
+    "details": frozenset(["open"]),
+    "datagrid": frozenset(["multiple", "disabled"]),
+    "command": frozenset(["hidden", "disabled", "checked", "default"]),
+    "hr": frozenset(["noshade"]),
+    "menu": frozenset(["autosubmit"]),
+    "fieldset": frozenset(["disabled", "readonly"]),
+    "option": frozenset(["disabled", "readonly", "selected"]),
+    "optgroup": frozenset(["disabled", "readonly"]),
+    "button": frozenset(["disabled", "autofocus"]),
+    "input": frozenset(["disabled", "readonly", "required", "autofocus", "checked", "ismap"]),
+    "select": frozenset(["disabled", "readonly", "autofocus", "multiple"]),
+    "output": frozenset(["disabled", "readonly"]),
+    "iframe": frozenset(["seamless"]),
+}
+
+# entitiesWindows1252 has to be _ordered_ and needs to have an index. It
+# therefore can't be a frozenset.
+entitiesWindows1252 = (
+    8364,   # 0x80  0x20AC  EURO SIGN
+    65533,  # 0x81          UNDEFINED
+    8218,   # 0x82  0x201A  SINGLE LOW-9 QUOTATION MARK
+    402,    # 0x83  0x0192  LATIN SMALL LETTER F WITH HOOK
+    8222,   # 0x84  0x201E  DOUBLE LOW-9 QUOTATION MARK
+    8230,   # 0x85  0x2026  HORIZONTAL ELLIPSIS
+    8224,   # 0x86  0x2020  DAGGER
+    8225,   # 0x87  0x2021  DOUBLE DAGGER
+    710,    # 0x88  0x02C6  MODIFIER LETTER CIRCUMFLEX ACCENT
+    8240,   # 0x89  0x2030  PER MILLE SIGN
+    352,    # 0x8A  0x0160  LATIN CAPITAL LETTER S WITH CARON
+    8249,   # 0x8B  0x2039  SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+    338,    # 0x8C  0x0152  LATIN CAPITAL LIGATURE OE
+    65533,  # 0x8D          UNDEFINED
+    381,    # 0x8E  0x017D  LATIN CAPITAL LETTER Z WITH CARON
+    65533,  # 0x8F          UNDEFINED
+    65533,  # 0x90          UNDEFINED
+    8216,   # 0x91  0x2018  LEFT SINGLE QUOTATION MARK
+    8217,   # 0x92  0x2019  RIGHT SINGLE QUOTATION MARK
+    8220,   # 0x93  0x201C  LEFT DOUBLE QUOTATION MARK
+    8221,   # 0x94  0x201D  RIGHT DOUBLE QUOTATION MARK
+    8226,   # 0x95  0x2022  BULLET
+    8211,   # 0x96  0x2013  EN DASH
+    8212,   # 0x97  0x2014  EM DASH
+    732,    # 0x98  0x02DC  SMALL TILDE
+    8482,   # 0x99  0x2122  TRADE MARK SIGN
+    353,    # 0x9A  0x0161  LATIN SMALL LETTER S WITH CARON
+    8250,   # 0x9B  0x203A  SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+    339,    # 0x9C  0x0153  LATIN SMALL LIGATURE OE
+    65533,  # 0x9D          UNDEFINED
+    382,    # 0x9E  0x017E  LATIN SMALL LETTER Z WITH CARON
+    376     # 0x9F  0x0178  LATIN CAPITAL LETTER Y WITH DIAERESIS
+)
+
+xmlEntities = frozenset(['lt;', 'gt;', 'amp;', 'apos;', 'quot;'])
+
+entities = {
+    "AElig": "\xc6",
+    "AElig;": "\xc6",
+    "AMP": "&",
+    "AMP;": "&",
+    "Aacute": "\xc1",
+    "Aacute;": "\xc1",
+    "Abreve;": "\u0102",
+    "Acirc": "\xc2",
+    "Acirc;": "\xc2",
+    "Acy;": "\u0410",
+    "Afr;": "\U0001d504",
+    "Agrave": "\xc0",
+    "Agrave;": "\xc0",
+    "Alpha;": "\u0391",
+    "Amacr;": "\u0100",
+    "And;": "\u2a53",
+    "Aogon;": "\u0104",
+    "Aopf;": "\U0001d538",
+    "ApplyFunction;": "\u2061",
+    "Aring": "\xc5",
+    "Aring;": "\xc5",
+    "Ascr;": "\U0001d49c",
+    "Assign;": "\u2254",
+    "Atilde": "\xc3",
+    "Atilde;": "\xc3",
+    "Auml": "\xc4",
+    "Auml;": "\xc4",
+    "Backslash;": "\u2216",
+    "Barv;": "\u2ae7",
+    "Barwed;": "\u2306",
+    "Bcy;": "\u0411",
+    "Because;": "\u2235",
+    "Bernoullis;": "\u212c",
+    "Beta;": "\u0392",
+    "Bfr;": "\U0001d505",
+    "Bopf;": "\U0001d539",
+    "Breve;": "\u02d8",
+    "Bscr;": "\u212c",
+    "Bumpeq;": "\u224e",
+    "CHcy;": "\u0427",
+    "COPY": "\xa9",
+    "COPY;": "\xa9",
+    "Cacute;": "\u0106",
+    "Cap;": "\u22d2",
+    "CapitalDifferentialD;": "\u2145",
+    "Cayleys;": "\u212d",
+    "Ccaron;": "\u010c",
+    "Ccedil": "\xc7",
+    "Ccedil;": "\xc7",
+    "Ccirc;": "\u0108",
+    "Cconint;": "\u2230",
+    "Cdot;": "\u010a",
+    "Cedilla;": "\xb8",
+    "CenterDot;": "\xb7",
+    "Cfr;": "\u212d",
+    "Chi;": "\u03a7",
+    "CircleDot;": "\u2299",
+    "CircleMinus;": "\u2296",
+    "CirclePlus;": "\u2295",
+    "CircleTimes;": "\u2297",
+    "ClockwiseContourIntegral;": "\u2232",
+    "CloseCurlyDoubleQuote;": "\u201d",
+    "CloseCurlyQuote;": "\u2019",
+    "Colon;": "\u2237",
+    "Colone;": "\u2a74",
+    "Congruent;": "\u2261",
+    "Conint;": "\u222f",
+    "ContourIntegral;": "\u222e",
+    "Copf;": "\u2102",
+    "Coproduct;": "\u2210",
+    "CounterClockwiseContourIntegral;": "\u2233",
+    "Cross;": "\u2a2f",
+    "Cscr;": "\U0001d49e",
+    "Cup;": "\u22d3",
+    "CupCap;": "\u224d",
+    "DD;": "\u2145",
+    "DDotrahd;": "\u2911",
+    "DJcy;": "\u0402",
+    "DScy;": "\u0405",
+    "DZcy;": "\u040f",
+    "Dagger;": "\u2021",
+    "Darr;": "\u21a1",
+    "Dashv;": "\u2ae4",
+    "Dcaron;": "\u010e",
+    "Dcy;": "\u0414",
+    "Del;": "\u2207",
+    "Delta;": "\u0394",
+    "Dfr;": "\U0001d507",
+    "DiacriticalAcute;": "\xb4",
+    "DiacriticalDot;": "\u02d9",
+    "DiacriticalDoubleAcute;": "\u02dd",
+    "DiacriticalGrave;": "`",
+    "DiacriticalTilde;": "\u02dc",
+    "Diamond;": "\u22c4",
+    "DifferentialD;": "\u2146",
+    "Dopf;": "\U0001d53b",
+    "Dot;": "\xa8",
+    "DotDot;": "\u20dc",
+    "DotEqual;": "\u2250",
+    "DoubleContourIntegral;": "\u222f",
+    "DoubleDot;": "\xa8",
+    "DoubleDownArrow;": "\u21d3",
+    "DoubleLeftArrow;": "\u21d0",
+    "DoubleLeftRightArrow;": "\u21d4",
+    "DoubleLeftTee;": "\u2ae4",
+    "DoubleLongLeftArrow;": "\u27f8",
+    "DoubleLongLeftRightArrow;": "\u27fa",
+    "DoubleLongRightArrow;": "\u27f9",
+    "DoubleRightArrow;": "\u21d2",
+    "DoubleRightTee;": "\u22a8",
+    "DoubleUpArrow;": "\u21d1",
+    "DoubleUpDownArrow;": "\u21d5",
+    "DoubleVerticalBar;": "\u2225",
+    "DownArrow;": "\u2193",
+    "DownArrowBar;": "\u2913",
+    "DownArrowUpArrow;": "\u21f5",
+    "DownBreve;": "\u0311",
+    "DownLeftRightVector;": "\u2950",
+    "DownLeftTeeVector;": "\u295e",
+    "DownLeftVector;": "\u21bd",
+    "DownLeftVectorBar;": "\u2956",
+    "DownRightTeeVector;": "\u295f",
+    "DownRightVector;": "\u21c1",
+    "DownRightVectorBar;": "\u2957",
+    "DownTee;": "\u22a4",
+    "DownTeeArrow;": "\u21a7",
+    "Downarrow;": "\u21d3",
+    "Dscr;": "\U0001d49f",
+    "Dstrok;": "\u0110",
+    "ENG;": "\u014a",
+    "ETH": "\xd0",
+    "ETH;": "\xd0",
+    "Eacute": "\xc9",
+    "Eacute;": "\xc9",
+    "Ecaron;": "\u011a",
+    "Ecirc": "\xca",
+    "Ecirc;": "\xca",
+    "Ecy;": "\u042d",
+    "Edot;": "\u0116",
+    "Efr;": "\U0001d508",
+    "Egrave": "\xc8",
+    "Egrave;": "\xc8",
+    "Element;": "\u2208",
+    "Emacr;": "\u0112",
+    "EmptySmallSquare;": "\u25fb",
+    "EmptyVerySmallSquare;": "\u25ab",
+    "Eogon;": "\u0118",
+    "Eopf;": "\U0001d53c",
+    "Epsilon;": "\u0395",
+    "Equal;": "\u2a75",
+    "EqualTilde;": "\u2242",
+    "Equilibrium;": "\u21cc",
+    "Escr;": "\u2130",
+    "Esim;": "\u2a73",
+    "Eta;": "\u0397",
+    "Euml": "\xcb",
+    "Euml;": "\xcb",
+    "Exists;": "\u2203",
+    "ExponentialE;": "\u2147",
+    "Fcy;": "\u0424",
+    "Ffr;": "\U0001d509",
+    "FilledSmallSquare;": "\u25fc",
+    "FilledVerySmallSquare;": "\u25aa",
+    "Fopf;": "\U0001d53d",
+    "ForAll;": "\u2200",
+    "Fouriertrf;": "\u2131",
+    "Fscr;": "\u2131",
+    "GJcy;": "\u0403",
+    "GT": ">",
+    "GT;": ">",
+    "Gamma;": "\u0393",
+    "Gammad;": "\u03dc",
+    "Gbreve;": "\u011e",
+    "Gcedil;": "\u0122",
+    "Gcirc;": "\u011c",
+    "Gcy;": "\u0413",
+    "Gdot;": "\u0120",
+    "Gfr;": "\U0001d50a",
+    "Gg;": "\u22d9",
+    "Gopf;": "\U0001d53e",
+    "GreaterEqual;": "\u2265",
+    "GreaterEqualLess;": "\u22db",
+    "GreaterFullEqual;": "\u2267",
+    "GreaterGreater;": "\u2aa2",
+    "GreaterLess;": "\u2277",
+    "GreaterSlantEqual;": "\u2a7e",
+    "GreaterTilde;": "\u2273",
+    "Gscr;": "\U0001d4a2",
+    "Gt;": "\u226b",
+    "HARDcy;": "\u042a",
+    "Hacek;": "\u02c7",
+    "Hat;": "^",
+    "Hcirc;": "\u0124",
+    "Hfr;": "\u210c",
+    "HilbertSpace;": "\u210b",
+    "Hopf;": "\u210d",
+    "HorizontalLine;": "\u2500",
+    "Hscr;": "\u210b",
+    "Hstrok;": "\u0126",
+    "HumpDownHump;": "\u224e",
+    "HumpEqual;": "\u224f",
+    "IEcy;": "\u0415",
+    "IJlig;": "\u0132",
+    "IOcy;": "\u0401",
+    "Iacute": "\xcd",
+    "Iacute;": "\xcd",
+    "Icirc": "\xce",
+    "Icirc;": "\xce",
+    "Icy;": "\u0418",
+    "Idot;": "\u0130",
+    "Ifr;": "\u2111",
+    "Igrave": "\xcc",
+    "Igrave;": "\xcc",
+    "Im;": "\u2111",
+    "Imacr;": "\u012a",
+    "ImaginaryI;": "\u2148",
+    "Implies;": "\u21d2",
+    "Int;": "\u222c",
+    "Integral;": "\u222b",
+    "Intersection;": "\u22c2",
+    "InvisibleComma;": "\u2063",
+    "InvisibleTimes;": "\u2062",
+    "Iogon;": "\u012e",
+    "Iopf;": "\U0001d540",
+    "Iota;": "\u0399",
+    "Iscr;": "\u2110",
+    "Itilde;": "\u0128",
+    "Iukcy;": "\u0406",
+    "Iuml": "\xcf",
+    "Iuml;": "\xcf",
+    "Jcirc;": "\u0134",
+    "Jcy;": "\u0419",
+    "Jfr;": "\U0001d50d",
+    "Jopf;": "\U0001d541",
+    "Jscr;": "\U0001d4a5",
+    "Jsercy;": "\u0408",
+    "Jukcy;": "\u0404",
+    "KHcy;": "\u0425",
+    "KJcy;": "\u040c",
+    "Kappa;": "\u039a",
+    "Kcedil;": "\u0136",
+    "Kcy;": "\u041a",
+    "Kfr;": "\U0001d50e",
+    "Kopf;": "\U0001d542",
+    "Kscr;": "\U0001d4a6",
+    "LJcy;": "\u0409",
+    "LT": "<",
+    "LT;": "<",
+    "Lacute;": "\u0139",
+    "Lambda;": "\u039b",
+    "Lang;": "\u27ea",
+    "Laplacetrf;": "\u2112",
+    "Larr;": "\u219e",
+    "Lcaron;": "\u013d",
+    "Lcedil;": "\u013b",
+    "Lcy;": "\u041b",
+    "LeftAngleBracket;": "\u27e8",
+    "LeftArrow;": "\u2190",
+    "LeftArrowBar;": "\u21e4",
+    "LeftArrowRightArrow;": "\u21c6",
+    "LeftCeiling;": "\u2308",
+    "LeftDoubleBracket;": "\u27e6",
+    "LeftDownTeeVector;": "\u2961",
+    "LeftDownVector;": "\u21c3",
+    "LeftDownVectorBar;": "\u2959",
+    "LeftFloor;": "\u230a",
+    "LeftRightArrow;": "\u2194",
+    "LeftRightVector;": "\u294e",
+    "LeftTee;": "\u22a3",
+    "LeftTeeArrow;": "\u21a4",
+    "LeftTeeVector;": "\u295a",
+    "LeftTriangle;": "\u22b2",
+    "LeftTriangleBar;": "\u29cf",
+    "LeftTriangleEqual;": "\u22b4",
+    "LeftUpDownVector;": "\u2951",
+    "LeftUpTeeVector;": "\u2960",
+    "LeftUpVector;": "\u21bf",
+    "LeftUpVectorBar;": "\u2958",
+    "LeftVector;": "\u21bc",
+    "LeftVectorBar;": "\u2952",
+    "Leftarrow;": "\u21d0",
+    "Leftrightarrow;": "\u21d4",
+    "LessEqualGreater;": "\u22da",
+    "LessFullEqual;": "\u2266",
+    "LessGreater;": "\u2276",
+    "LessLess;": "\u2aa1",
+    "LessSlantEqual;": "\u2a7d",
+    "LessTilde;": "\u2272",
+    "Lfr;": "\U0001d50f",
+    "Ll;": "\u22d8",
+    "Lleftarrow;": "\u21da",
+    "Lmidot;": "\u013f",
+    "LongLeftArrow;": "\u27f5",
+    "LongLeftRightArrow;": "\u27f7",
+    "LongRightArrow;": "\u27f6",
+    "Longleftarrow;": "\u27f8",
+    "Longleftrightarrow;": "\u27fa",
+    "Longrightarrow;": "\u27f9",
+    "Lopf;": "\U0001d543",
+    "LowerLeftArrow;": "\u2199",
+    "LowerRightArrow;": "\u2198",
+    "Lscr;": "\u2112",
+    "Lsh;": "\u21b0",
+    "Lstrok;": "\u0141",
+    "Lt;": "\u226a",
+    "Map;": "\u2905",
+    "Mcy;": "\u041c",
+    "MediumSpace;": "\u205f",
+    "Mellintrf;": "\u2133",
+    "Mfr;": "\U0001d510",
+    "MinusPlus;": "\u2213",
+    "Mopf;": "\U0001d544",
+    "Mscr;": "\u2133",
+    "Mu;": "\u039c",
+    "NJcy;": "\u040a",
+    "Nacute;": "\u0143",
+    "Ncaron;": "\u0147",
+    "Ncedil;": "\u0145",
+    "Ncy;": "\u041d",
+    "NegativeMediumSpace;": "\u200b",
+    "NegativeThickSpace;": "\u200b",
+    "NegativeThinSpace;": "\u200b",
+    "NegativeVeryThinSpace;": "\u200b",
+    "NestedGreaterGreater;": "\u226b",
+    "NestedLessLess;": "\u226a",
+    "NewLine;": "\n",
+    "Nfr;": "\U0001d511",
+    "NoBreak;": "\u2060",
+    "NonBreakingSpace;": "\xa0",
+    "Nopf;": "\u2115",
+    "Not;": "\u2aec",
+    "NotCongruent;": "\u2262",
+    "NotCupCap;": "\u226d",
+    "NotDoubleVerticalBar;": "\u2226",
+    "NotElement;": "\u2209",
+    "NotEqual;": "\u2260",
+    "NotEqualTilde;": "\u2242\u0338",
+    "NotExists;": "\u2204",
+    "NotGreater;": "\u226f",
+    "NotGreaterEqual;": "\u2271",
+    "NotGreaterFullEqual;": "\u2267\u0338",
+    "NotGreaterGreater;": "\u226b\u0338",
+    "NotGreaterLess;": "\u2279",
+    "NotGreaterSlantEqual;": "\u2a7e\u0338",
+    "NotGreaterTilde;": "\u2275",
+    "NotHumpDownHump;": "\u224e\u0338",
+    "NotHumpEqual;": "\u224f\u0338",
+    "NotLeftTriangle;": "\u22ea",
+    "NotLeftTriangleBar;": "\u29cf\u0338",
+    "NotLeftTriangleEqual;": "\u22ec",
+    "NotLess;": "\u226e",
+    "NotLessEqual;": "\u2270",
+    "NotLessGreater;": "\u2278",
+    "NotLessLess;": "\u226a\u0338",
+    "NotLessSlantEqual;": "\u2a7d\u0338",
+    "NotLessTilde;": "\u2274",
+    "NotNestedGreaterGreater;": "\u2aa2\u0338",
+    "NotNestedLessLess;": "\u2aa1\u0338",
+    "NotPrecedes;": "\u2280",
+    "NotPrecedesEqual;": "\u2aaf\u0338",
+    "NotPrecedesSlantEqual;": "\u22e0",
+    "NotReverseElement;": "\u220c",
+    "NotRightTriangle;": "\u22eb",
+    "NotRightTriangleBar;": "\u29d0\u0338",
+    "NotRightTriangleEqual;": "\u22ed",
+    "NotSquareSubset;": "\u228f\u0338",
+    "NotSquareSubsetEqual;": "\u22e2",
+    "NotSquareSuperset;": "\u2290\u0338",
+    "NotSquareSupersetEqual;": "\u22e3",
+    "NotSubset;": "\u2282\u20d2",
+    "NotSubsetEqual;": "\u2288",
+    "NotSucceeds;": "\u2281",
+    "NotSucceedsEqual;": "\u2ab0\u0338",
+    "NotSucceedsSlantEqual;": "\u22e1",
+    "NotSucceedsTilde;": "\u227f\u0338",
+    "NotSuperset;": "\u2283\u20d2",
+    "NotSupersetEqual;": "\u2289",
+    "NotTilde;": "\u2241",
+    "NotTildeEqual;": "\u2244",
+    "NotTildeFullEqual;": "\u2247",
+    "NotTildeTilde;": "\u2249",
+    "NotVerticalBar;": "\u2224",
+    "Nscr;": "\U0001d4a9",
+    "Ntilde": "\xd1",
+    "Ntilde;": "\xd1",
+    "Nu;": "\u039d",
+    "OElig;": "\u0152",
+    "Oacute": "\xd3",
+    "Oacute;": "\xd3",
+    "Ocirc": "\xd4",
+    "Ocirc;": "\xd4",
+    "Ocy;": "\u041e",
+    "Odblac;": "\u0150",
+    "Ofr;": "\U0001d512",
+    "Ograve": "\xd2",
+    "Ograve;": "\xd2",
+    "Omacr;": "\u014c",
+    "Omega;": "\u03a9",
+    "Omicron;": "\u039f",
+    "Oopf;": "\U0001d546",
+    "OpenCurlyDoubleQuote;": "\u201c",
+    "OpenCurlyQuote;": "\u2018",
+    "Or;": "\u2a54",
+    "Oscr;": "\U0001d4aa",
+    "Oslash": "\xd8",
+    "Oslash;": "\xd8",
+    "Otilde": "\xd5",
+    "Otilde;": "\xd5",
+    "Otimes;": "\u2a37",
+    "Ouml": "\xd6",
+    "Ouml;": "\xd6",
+    "OverBar;": "\u203e",
+    "OverBrace;": "\u23de",
+    "OverBracket;": "\u23b4",
+    "OverParenthesis;": "\u23dc",
+    "PartialD;": "\u2202",
+    "Pcy;": "\u041f",
+    "Pfr;": "\U0001d513",
+    "Phi;": "\u03a6",
+    "Pi;": "\u03a0",
+    "PlusMinus;": "\xb1",
+    "Poincareplane;": "\u210c",
+    "Popf;": "\u2119",
+    "Pr;": "\u2abb",
+    "Precedes;": "\u227a",
+    "PrecedesEqual;": "\u2aaf",
+    "PrecedesSlantEqual;": "\u227c",
+    "PrecedesTilde;": "\u227e",
+    "Prime;": "\u2033",
+    "Product;": "\u220f",
+    "Proportion;": "\u2237",
+    "Proportional;": "\u221d",
+    "Pscr;": "\U0001d4ab",
+    "Psi;": "\u03a8",
+    "QUOT": "\"",
+    "QUOT;": "\"",
+    "Qfr;": "\U0001d514",
+    "Qopf;": "\u211a",
+    "Qscr;": "\U0001d4ac",
+    "RBarr;": "\u2910",
+    "REG": "\xae",
+    "REG;": "\xae",
+    "Racute;": "\u0154",
+    "Rang;": "\u27eb",
+    "Rarr;": "\u21a0",
+    "Rarrtl;": "\u2916",
+    "Rcaron;": "\u0158",
+    "Rcedil;": "\u0156",
+    "Rcy;": "\u0420",
+    "Re;": "\u211c",
+    "ReverseElement;": "\u220b",
+    "ReverseEquilibrium;": "\u21cb",
+    "ReverseUpEquilibrium;": "\u296f",
+    "Rfr;": "\u211c",
+    "Rho;": "\u03a1",
+    "RightAngleBracket;": "\u27e9",
+    "RightArrow;": "\u2192",
+    "RightArrowBar;": "\u21e5",
+    "RightArrowLeftArrow;": "\u21c4",
+    "RightCeiling;": "\u2309",
+    "RightDoubleBracket;": "\u27e7",
+    "RightDownTeeVector;": "\u295d",
+    "RightDownVector;": "\u21c2",
+    "RightDownVectorBar;": "\u2955",
+    "RightFloor;": "\u230b",
+    "RightTee;": "\u22a2",
+    "RightTeeArrow;": "\u21a6",
+    "RightTeeVector;": "\u295b",
+    "RightTriangle;": "\u22b3",
+    "RightTriangleBar;": "\u29d0",
+    "RightTriangleEqual;": "\u22b5",
+    "RightUpDownVector;": "\u294f",
+    "RightUpTeeVector;": "\u295c",
+    "RightUpVector;": "\u21be",
+    "RightUpVectorBar;": "\u2954",
+    "RightVector;": "\u21c0",
+    "RightVectorBar;": "\u2953",
+    "Rightarrow;": "\u21d2",
+    "Ropf;": "\u211d",
+    "RoundImplies;": "\u2970",
+    "Rrightarrow;": "\u21db",
+    "Rscr;": "\u211b",
+    "Rsh;": "\u21b1",
+    "RuleDelayed;": "\u29f4",
+    "SHCHcy;": "\u0429",
+    "SHcy;": "\u0428",
+    "SOFTcy;": "\u042c",
+    "Sacute;": "\u015a",
+    "Sc;": "\u2abc",
+    "Scaron;": "\u0160",
+    "Scedil;": "\u015e",
+    "Scirc;": "\u015c",
+    "Scy;": "\u0421",
+    "Sfr;": "\U0001d516",
+    "ShortDownArrow;": "\u2193",
+    "ShortLeftArrow;": "\u2190",
+    "ShortRightArrow;": "\u2192",
+    "ShortUpArrow;": "\u2191",
+    "Sigma;": "\u03a3",
+    "SmallCircle;": "\u2218",
+    "Sopf;": "\U0001d54a",
+    "Sqrt;": "\u221a",
+    "Square;": "\u25a1",
+    "SquareIntersection;": "\u2293",
+    "SquareSubset;": "\u228f",
+    "SquareSubsetEqual;": "\u2291",
+    "SquareSuperset;": "\u2290",
+    "SquareSupersetEqual;": "\u2292",
+    "SquareUnion;": "\u2294",
+    "Sscr;": "\U0001d4ae",
+    "Star;": "\u22c6",
+    "Sub;": "\u22d0",
+    "Subset;": "\u22d0",
+    "SubsetEqual;": "\u2286",
+    "Succeeds;": "\u227b",
+    "SucceedsEqual;": "\u2ab0",
+    "SucceedsSlantEqual;": "\u227d",
+    "SucceedsTilde;": "\u227f",
+    "SuchThat;": "\u220b",
+    "Sum;": "\u2211",
+    "Sup;": "\u22d1",
+    "Superset;": "\u2283",
+    "SupersetEqual;": "\u2287",
+    "Supset;": "\u22d1",
+    "THORN": "\xde",
+    "THORN;": "\xde",
+    "TRADE;": "\u2122",
+    "TSHcy;": "\u040b",
+    "TScy;": "\u0426",
+    "Tab;": "\t",
+    "Tau;": "\u03a4",
+    "Tcaron;": "\u0164",
+    "Tcedil;": "\u0162",
+    "Tcy;": "\u0422",
+    "Tfr;": "\U0001d517",
+    "Therefore;": "\u2234",
+    "Theta;": "\u0398",
+    "ThickSpace;": "\u205f\u200a",
+    "ThinSpace;": "\u2009",
+    "Tilde;": "\u223c",
+    "TildeEqual;": "\u2243",
+    "TildeFullEqual;": "\u2245",
+    "TildeTilde;": "\u2248",
+    "Topf;": "\U0001d54b",
+    "TripleDot;": "\u20db",
+    "Tscr;": "\U0001d4af",
+    "Tstrok;": "\u0166",
+    "Uacute": "\xda",
+    "Uacute;": "\xda",
+    "Uarr;": "\u219f",
+    "Uarrocir;": "\u2949",
+    "Ubrcy;": "\u040e",
+    "Ubreve;": "\u016c",
+    "Ucirc": "\xdb",
+    "Ucirc;": "\xdb",
+    "Ucy;": "\u0423",
+    "Udblac;": "\u0170",
+    "Ufr;": "\U0001d518",
+    "Ugrave": "\xd9",
+    "Ugrave;": "\xd9",
+    "Umacr;": "\u016a",
+    "UnderBar;": "_",
+    "UnderBrace;": "\u23df",
+    "UnderBracket;": "\u23b5",
+    "UnderParenthesis;": "\u23dd",
+    "Union;": "\u22c3",
+    "UnionPlus;": "\u228e",
+    "Uogon;": "\u0172",
+    "Uopf;": "\U0001d54c",
+    "UpArrow;": "\u2191",
+    "UpArrowBar;": "\u2912",
+    "UpArrowDownArrow;": "\u21c5",
+    "UpDownArrow;": "\u2195",
+    "UpEquilibrium;": "\u296e",
+    "UpTee;": "\u22a5",
+    "UpTeeArrow;": "\u21a5",
+    "Uparrow;": "\u21d1",
+    "Updownarrow;": "\u21d5",
+    "UpperLeftArrow;": "\u2196",
+    "UpperRightArrow;": "\u2197",
+    "Upsi;": "\u03d2",
+    "Upsilon;": "\u03a5",
+    "Uring;": "\u016e",
+    "Uscr;": "\U0001d4b0",
+    "Utilde;": "\u0168",
+    "Uuml": "\xdc",
+    "Uuml;": "\xdc",
+    "VDash;": "\u22ab",
+    "Vbar;": "\u2aeb",
+    "Vcy;": "\u0412",
+    "Vdash;": "\u22a9",
+    "Vdashl;": "\u2ae6",
+    "Vee;": "\u22c1",
+    "Verbar;": "\u2016",
+    "Vert;": "\u2016",
+    "VerticalBar;": "\u2223",
+    "VerticalLine;": "|",
+    "VerticalSeparator;": "\u2758",
+    "VerticalTilde;": "\u2240",
+    "VeryThinSpace;": "\u200a",
+    "Vfr;": "\U0001d519",
+    "Vopf;": "\U0001d54d",
+    "Vscr;": "\U0001d4b1",
+    "Vvdash;": "\u22aa",
+    "Wcirc;": "\u0174",
+    "Wedge;": "\u22c0",
+    "Wfr;": "\U0001d51a",
+    "Wopf;": "\U0001d54e",
+    "Wscr;": "\U0001d4b2",
+    "Xfr;": "\U0001d51b",
+    "Xi;": "\u039e",
+    "Xopf;": "\U0001d54f",
+    "Xscr;": "\U0001d4b3",
+    "YAcy;": "\u042f",
+    "YIcy;": "\u0407",
+    "YUcy;": "\u042e",
+    "Yacute": "\xdd",
+    "Yacute;": "\xdd",
+    "Ycirc;": "\u0176",
+    "Ycy;": "\u042b",
+    "Yfr;": "\U0001d51c",
+    "Yopf;": "\U0001d550",
+    "Yscr;": "\U0001d4b4",
+    "Yuml;": "\u0178",
+    "ZHcy;": "\u0416",
+    "Zacute;": "\u0179",
+    "Zcaron;": "\u017d",
+    "Zcy;": "\u0417",
+    "Zdot;": "\u017b",
+    "ZeroWidthSpace;": "\u200b",
+    "Zeta;": "\u0396",
+    "Zfr;": "\u2128",
+    "Zopf;": "\u2124",
+    "Zscr;": "\U0001d4b5",
+    "aacute": "\xe1",
+    "aacute;": "\xe1",
+    "abreve;": "\u0103",
+    "ac;": "\u223e",
+    "acE;": "\u223e\u0333",
+    "acd;": "\u223f",
+    "acirc": "\xe2",
+    "acirc;": "\xe2",
+    "acute": "\xb4",
+    "acute;": "\xb4",
+    "acy;": "\u0430",
+    "aelig": "\xe6",
+    "aelig;": "\xe6",
+    "af;": "\u2061",
+    "afr;": "\U0001d51e",
+    "agrave": "\xe0",
+    "agrave;": "\xe0",
+    "alefsym;": "\u2135",
+    "aleph;": "\u2135",
+    "alpha;": "\u03b1",
+    "amacr;": "\u0101",
+    "amalg;": "\u2a3f",
+    "amp": "&",
+    "amp;": "&",
+    "and;": "\u2227",
+    "andand;": "\u2a55",
+    "andd;": "\u2a5c",
+    "andslope;": "\u2a58",
+    "andv;": "\u2a5a",
+    "ang;": "\u2220",
+    "ange;": "\u29a4",
+    "angle;": "\u2220",
+    "angmsd;": "\u2221",
+    "angmsdaa;": "\u29a8",
+    "angmsdab;": "\u29a9",
+    "angmsdac;": "\u29aa",
+    "angmsdad;": "\u29ab",
+    "angmsdae;": "\u29ac",
+    "angmsdaf;": "\u29ad",
+    "angmsdag;": "\u29ae",
+    "angmsdah;": "\u29af",
+    "angrt;": "\u221f",
+    "angrtvb;": "\u22be",
+    "angrtvbd;": "\u299d",
+    "angsph;": "\u2222",
+    "angst;": "\xc5",
+    "angzarr;": "\u237c",
+    "aogon;": "\u0105",
+    "aopf;": "\U0001d552",
+    "ap;": "\u2248",
+    "apE;": "\u2a70",
+    "apacir;": "\u2a6f",
+    "ape;": "\u224a",
+    "apid;": "\u224b",
+    "apos;": "'",
+    "approx;": "\u2248",
+    "approxeq;": "\u224a",
+    "aring": "\xe5",
+    "aring;": "\xe5",
+    "ascr;": "\U0001d4b6",
+    "ast;": "*",
+    "asymp;": "\u2248",
+    "asympeq;": "\u224d",
+    "atilde": "\xe3",
+    "atilde;": "\xe3",
+    "auml": "\xe4",
+    "auml;": "\xe4",
+    "awconint;": "\u2233",
+    "awint;": "\u2a11",
+    "bNot;": "\u2aed",
+    "backcong;": "\u224c",
+    "backepsilon;": "\u03f6",
+    "backprime;": "\u2035",
+    "backsim;": "\u223d",
+    "backsimeq;": "\u22cd",
+    "barvee;": "\u22bd",
+    "barwed;": "\u2305",
+    "barwedge;": "\u2305",
+    "bbrk;": "\u23b5",
+    "bbrktbrk;": "\u23b6",
+    "bcong;": "\u224c",
+    "bcy;": "\u0431",
+    "bdquo;": "\u201e",
+    "becaus;": "\u2235",
+    "because;": "\u2235",
+    "bemptyv;": "\u29b0",
+    "bepsi;": "\u03f6",
+    "bernou;": "\u212c",
+    "beta;": "\u03b2",
+    "beth;": "\u2136",
+    "between;": "\u226c",
+    "bfr;": "\U0001d51f",
+    "bigcap;": "\u22c2",
+    "bigcirc;": "\u25ef",
+    "bigcup;": "\u22c3",
+    "bigodot;": "\u2a00",
+    "bigoplus;": "\u2a01",
+    "bigotimes;": "\u2a02",
+    "bigsqcup;": "\u2a06",
+    "bigstar;": "\u2605",
+    "bigtriangledown;": "\u25bd",
+    "bigtriangleup;": "\u25b3",
+    "biguplus;": "\u2a04",
+    "bigvee;": "\u22c1",
+    "bigwedge;": "\u22c0",
+    "bkarow;": "\u290d",
+    "blacklozenge;": "\u29eb",
+    "blacksquare;": "\u25aa",
+    "blacktriangle;": "\u25b4",
+    "blacktriangledown;": "\u25be",
+    "blacktriangleleft;": "\u25c2",
+    "blacktriangleright;": "\u25b8",
+    "blank;": "\u2423",
+    "blk12;": "\u2592",
+    "blk14;": "\u2591",
+    "blk34;": "\u2593",
+    "block;": "\u2588",
+    "bne;": "=\u20e5",
+    "bnequiv;": "\u2261\u20e5",
+    "bnot;": "\u2310",
+    "bopf;": "\U0001d553",
+    "bot;": "\u22a5",
+    "bottom;": "\u22a5",
+    "bowtie;": "\u22c8",
+    "boxDL;": "\u2557",
+    "boxDR;": "\u2554",
+    "boxDl;": "\u2556",
+    "boxDr;": "\u2553",
+    "boxH;": "\u2550",
+    "boxHD;": "\u2566",
+    "boxHU;": "\u2569",
+    "boxHd;": "\u2564",
+    "boxHu;": "\u2567",
+    "boxUL;": "\u255d",
+    "boxUR;": "\u255a",
+    "boxUl;": "\u255c",
+    "boxUr;": "\u2559",
+    "boxV;": "\u2551",
+    "boxVH;": "\u256c",
+    "boxVL;": "\u2563",
+    "boxVR;": "\u2560",
+    "boxVh;": "\u256b",
+    "boxVl;": "\u2562",
+    "boxVr;": "\u255f",
+    "boxbox;": "\u29c9",
+    "boxdL;": "\u2555",
+    "boxdR;": "\u2552",
+    "boxdl;": "\u2510",
+    "boxdr;": "\u250c",
+    "boxh;": "\u2500",
+    "boxhD;": "\u2565",
+    "boxhU;": "\u2568",
+    "boxhd;": "\u252c",
+    "boxhu;": "\u2534",
+    "boxminus;": "\u229f",
+    "boxplus;": "\u229e",
+    "boxtimes;": "\u22a0",
+    "boxuL;": "\u255b",
+    "boxuR;": "\u2558",
+    "boxul;": "\u2518",
+    "boxur;": "\u2514",
+    "boxv;": "\u2502",
+    "boxvH;": "\u256a",
+    "boxvL;": "\u2561",
+    "boxvR;": "\u255e",
+    "boxvh;": "\u253c",
+    "boxvl;": "\u2524",
+    "boxvr;": "\u251c",
+    "bprime;": "\u2035",
+    "breve;": "\u02d8",
+    "brvbar": "\xa6",
+    "brvbar;": "\xa6",
+    "bscr;": "\U0001d4b7",
+    "bsemi;": "\u204f",
+    "bsim;": "\u223d",
+    "bsime;": "\u22cd",
+    "bsol;": "\\",
+    "bsolb;": "\u29c5",
+    "bsolhsub;": "\u27c8",
+    "bull;": "\u2022",
+    "bullet;": "\u2022",
+    "bump;": "\u224e",
+    "bumpE;": "\u2aae",
+    "bumpe;": "\u224f",
+    "bumpeq;": "\u224f",
+    "cacute;": "\u0107",
+    "cap;": "\u2229",
+    "capand;": "\u2a44",
+    "capbrcup;": "\u2a49",
+    "capcap;": "\u2a4b",
+    "capcup;": "\u2a47",
+    "capdot;": "\u2a40",
+    "caps;": "\u2229\ufe00",
+    "caret;": "\u2041",
+    "caron;": "\u02c7",
+    "ccaps;": "\u2a4d",
+    "ccaron;": "\u010d",
+    "ccedil": "\xe7",
+    "ccedil;": "\xe7",
+    "ccirc;": "\u0109",
+    "ccups;": "\u2a4c",
+    "ccupssm;": "\u2a50",
+    "cdot;": "\u010b",
+    "cedil": "\xb8",
+    "cedil;": "\xb8",
+    "cemptyv;": "\u29b2",
+    "cent": "\xa2",
+    "cent;": "\xa2",
+    "centerdot;": "\xb7",
+    "cfr;": "\U0001d520",
+    "chcy;": "\u0447",
+    "check;": "\u2713",
+    "checkmark;": "\u2713",
+    "chi;": "\u03c7",
+    "cir;": "\u25cb",
+    "cirE;": "\u29c3",
+    "circ;": "\u02c6",
+    "circeq;": "\u2257",
+    "circlearrowleft;": "\u21ba",
+    "circlearrowright;": "\u21bb",
+    "circledR;": "\xae",
+    "circledS;": "\u24c8",
+    "circledast;": "\u229b",
+    "circledcirc;": "\u229a",
+    "circleddash;": "\u229d",
+    "cire;": "\u2257",
+    "cirfnint;": "\u2a10",
+    "cirmid;": "\u2aef",
+    "cirscir;": "\u29c2",
+    "clubs;": "\u2663",
+    "clubsuit;": "\u2663",
+    "colon;": ":",
+    "colone;": "\u2254",
+    "coloneq;": "\u2254",
+    "comma;": ",",
+    "commat;": "@",
+    "comp;": "\u2201",
+    "compfn;": "\u2218",
+    "complement;": "\u2201",
+    "complexes;": "\u2102",
+    "cong;": "\u2245",
+    "congdot;": "\u2a6d",
+    "conint;": "\u222e",
+    "copf;": "\U0001d554",
+    "coprod;": "\u2210",
+    "copy": "\xa9",
+    "copy;": "\xa9",
+    "copysr;": "\u2117",
+    "crarr;": "\u21b5",
+    "cross;": "\u2717",
+    "cscr;": "\U0001d4b8",
+    "csub;": "\u2acf",
+    "csube;": "\u2ad1",
+    "csup;": "\u2ad0",
+    "csupe;": "\u2ad2",
+    "ctdot;": "\u22ef",
+    "cudarrl;": "\u2938",
+    "cudarrr;": "\u2935",
+    "cuepr;": "\u22de",
+    "cuesc;": "\u22df",
+    "cularr;": "\u21b6",
+    "cularrp;": "\u293d",
+    "cup;": "\u222a",
+    "cupbrcap;": "\u2a48",
+    "cupcap;": "\u2a46",
+    "cupcup;": "\u2a4a",
+    "cupdot;": "\u228d",
+    "cupor;": "\u2a45",
+    "cups;": "\u222a\ufe00",
+    "curarr;": "\u21b7",
+    "curarrm;": "\u293c",
+    "curlyeqprec;": "\u22de",
+    "curlyeqsucc;": "\u22df",
+    "curlyvee;": "\u22ce",
+    "curlywedge;": "\u22cf",
+    "curren": "\xa4",
+    "curren;": "\xa4",
+    "curvearrowleft;": "\u21b6",
+    "curvearrowright;": "\u21b7",
+    "cuvee;": "\u22ce",
+    "cuwed;": "\u22cf",
+    "cwconint;": "\u2232",
+    "cwint;": "\u2231",
+    "cylcty;": "\u232d",
+    "dArr;": "\u21d3",
+    "dHar;": "\u2965",
+    "dagger;": "\u2020",
+    "daleth;": "\u2138",
+    "darr;": "\u2193",
+    "dash;": "\u2010",
+    "dashv;": "\u22a3",
+    "dbkarow;": "\u290f",
+    "dblac;": "\u02dd",
+    "dcaron;": "\u010f",
+    "dcy;": "\u0434",
+    "dd;": "\u2146",
+    "ddagger;": "\u2021",
+    "ddarr;": "\u21ca",
+    "ddotseq;": "\u2a77",
+    "deg": "\xb0",
+    "deg;": "\xb0",
+    "delta;": "\u03b4",
+    "demptyv;": "\u29b1",
+    "dfisht;": "\u297f",
+    "dfr;": "\U0001d521",
+    "dharl;": "\u21c3",
+    "dharr;": "\u21c2",
+    "diam;": "\u22c4",
+    "diamond;": "\u22c4",
+    "diamondsuit;": "\u2666",
+    "diams;": "\u2666",
+    "die;": "\xa8",
+    "digamma;": "\u03dd",
+    "disin;": "\u22f2",
+    "div;": "\xf7",
+    "divide": "\xf7",
+    "divide;": "\xf7",
+    "divideontimes;": "\u22c7",
+    "divonx;": "\u22c7",
+    "djcy;": "\u0452",
+    "dlcorn;": "\u231e",
+    "dlcrop;": "\u230d",
+    "dollar;": "$",
+    "dopf;": "\U0001d555",
+    "dot;": "\u02d9",
+    "doteq;": "\u2250",
+    "doteqdot;": "\u2251",
+    "dotminus;": "\u2238",
+    "dotplus;": "\u2214",
+    "dotsquare;": "\u22a1",
+    "doublebarwedge;": "\u2306",
+    "downarrow;": "\u2193",
+    "downdownarrows;": "\u21ca",
+    "downharpoonleft;": "\u21c3",
+    "downharpoonright;": "\u21c2",
+    "drbkarow;": "\u2910",
+    "drcorn;": "\u231f",
+    "drcrop;": "\u230c",
+    "dscr;": "\U0001d4b9",
+    "dscy;": "\u0455",
+    "dsol;": "\u29f6",
+    "dstrok;": "\u0111",
+    "dtdot;": "\u22f1",
+    "dtri;": "\u25bf",
+    "dtrif;": "\u25be",
+    "duarr;": "\u21f5",
+    "duhar;": "\u296f",
+    "dwangle;": "\u29a6",
+    "dzcy;": "\u045f",
+    "dzigrarr;": "\u27ff",
+    "eDDot;": "\u2a77",
+    "eDot;": "\u2251",
+    "eacute": "\xe9",
+    "eacute;": "\xe9",
+    "easter;": "\u2a6e",
+    "ecaron;": "\u011b",
+    "ecir;": "\u2256",
+    "ecirc": "\xea",
+    "ecirc;": "\xea",
+    "ecolon;": "\u2255",
+    "ecy;": "\u044d",
+    "edot;": "\u0117",
+    "ee;": "\u2147",
+    "efDot;": "\u2252",
+    "efr;": "\U0001d522",
+    "eg;": "\u2a9a",
+    "egrave": "\xe8",
+    "egrave;": "\xe8",
+    "egs;": "\u2a96",
+    "egsdot;": "\u2a98",
+    "el;": "\u2a99",
+    "elinters;": "\u23e7",
+    "ell;": "\u2113",
+    "els;": "\u2a95",
+    "elsdot;": "\u2a97",
+    "emacr;": "\u0113",
+    "empty;": "\u2205",
+    "emptyset;": "\u2205",
+    "emptyv;": "\u2205",
+    "emsp13;": "\u2004",
+    "emsp14;": "\u2005",
+    "emsp;": "\u2003",
+    "eng;": "\u014b",
+    "ensp;": "\u2002",
+    "eogon;": "\u0119",
+    "eopf;": "\U0001d556",
+    "epar;": "\u22d5",
+    "eparsl;": "\u29e3",
+    "eplus;": "\u2a71",
+    "epsi;": "\u03b5",
+    "epsilon;": "\u03b5",
+    "epsiv;": "\u03f5",
+    "eqcirc;": "\u2256",
+    "eqcolon;": "\u2255",
+    "eqsim;": "\u2242",
+    "eqslantgtr;": "\u2a96",
+    "eqslantless;": "\u2a95",
+    "equals;": "=",
+    "equest;": "\u225f",
+    "equiv;": "\u2261",
+    "equivDD;": "\u2a78",
+    "eqvparsl;": "\u29e5",
+    "erDot;": "\u2253",
+    "erarr;": "\u2971",
+    "escr;": "\u212f",
+    "esdot;": "\u2250",
+    "esim;": "\u2242",
+    "eta;": "\u03b7",
+    "eth": "\xf0",
+    "eth;": "\xf0",
+    "euml": "\xeb",
+    "euml;": "\xeb",
+    "euro;": "\u20ac",
+    "excl;": "!",
+    "exist;": "\u2203",
+    "expectation;": "\u2130",
+    "exponentiale;": "\u2147",
+    "fallingdotseq;": "\u2252",
+    "fcy;": "\u0444",
+    "female;": "\u2640",
+    "ffilig;": "\ufb03",
+    "fflig;": "\ufb00",
+    "ffllig;": "\ufb04",
+    "ffr;": "\U0001d523",
+    "filig;": "\ufb01",
+    "fjlig;": "fj",
+    "flat;": "\u266d",
+    "fllig;": "\ufb02",
+    "fltns;": "\u25b1",
+    "fnof;": "\u0192",
+    "fopf;": "\U0001d557",
+    "forall;": "\u2200",
+    "fork;": "\u22d4",
+    "forkv;": "\u2ad9",
+    "fpartint;": "\u2a0d",
+    "frac12": "\xbd",
+    "frac12;": "\xbd",
+    "frac13;": "\u2153",
+    "frac14": "\xbc",
+    "frac14;": "\xbc",
+    "frac15;": "\u2155",
+    "frac16;": "\u2159",
+    "frac18;": "\u215b",
+    "frac23;": "\u2154",
+    "frac25;": "\u2156",
+    "frac34": "\xbe",
+    "frac34;": "\xbe",
+    "frac35;": "\u2157",
+    "frac38;": "\u215c",
+    "frac45;": "\u2158",
+    "frac56;": "\u215a",
+    "frac58;": "\u215d",
+    "frac78;": "\u215e",
+    "frasl;": "\u2044",
+    "frown;": "\u2322",
+    "fscr;": "\U0001d4bb",
+    "gE;": "\u2267",
+    "gEl;": "\u2a8c",
+    "gacute;": "\u01f5",
+    "gamma;": "\u03b3",
+    "gammad;": "\u03dd",
+    "gap;": "\u2a86",
+    "gbreve;": "\u011f",
+    "gcirc;": "\u011d",
+    "gcy;": "\u0433",
+    "gdot;": "\u0121",
+    "ge;": "\u2265",
+    "gel;": "\u22db",
+    "geq;": "\u2265",
+    "geqq;": "\u2267",
+    "geqslant;": "\u2a7e",
+    "ges;": "\u2a7e",
+    "gescc;": "\u2aa9",
+    "gesdot;": "\u2a80",
+    "gesdoto;": "\u2a82",
+    "gesdotol;": "\u2a84",
+    "gesl;": "\u22db\ufe00",
+    "gesles;": "\u2a94",
+    "gfr;": "\U0001d524",
+    "gg;": "\u226b",
+    "ggg;": "\u22d9",
+    "gimel;": "\u2137",
+    "gjcy;": "\u0453",
+    "gl;": "\u2277",
+    "glE;": "\u2a92",
+    "gla;": "\u2aa5",
+    "glj;": "\u2aa4",
+    "gnE;": "\u2269",
+    "gnap;": "\u2a8a",
+    "gnapprox;": "\u2a8a",
+    "gne;": "\u2a88",
+    "gneq;": "\u2a88",
+    "gneqq;": "\u2269",
+    "gnsim;": "\u22e7",
+    "gopf;": "\U0001d558",
+    "grave;": "`",
+    "gscr;": "\u210a",
+    "gsim;": "\u2273",
+    "gsime;": "\u2a8e",
+    "gsiml;": "\u2a90",
+    "gt": ">",
+    "gt;": ">",
+    "gtcc;": "\u2aa7",
+    "gtcir;": "\u2a7a",
+    "gtdot;": "\u22d7",
+    "gtlPar;": "\u2995",
+    "gtquest;": "\u2a7c",
+    "gtrapprox;": "\u2a86",
+    "gtrarr;": "\u2978",
+    "gtrdot;": "\u22d7",
+    "gtreqless;": "\u22db",
+    "gtreqqless;": "\u2a8c",
+    "gtrless;": "\u2277",
+    "gtrsim;": "\u2273",
+    "gvertneqq;": "\u2269\ufe00",
+    "gvnE;": "\u2269\ufe00",
+    "hArr;": "\u21d4",
+    "hairsp;": "\u200a",
+    "half;": "\xbd",
+    "hamilt;": "\u210b",
+    "hardcy;": "\u044a",
+    "harr;": "\u2194",
+    "harrcir;": "\u2948",
+    "harrw;": "\u21ad",
+    "hbar;": "\u210f",
+    "hcirc;": "\u0125",
+    "hearts;": "\u2665",
+    "heartsuit;": "\u2665",
+    "hellip;": "\u2026",
+    "hercon;": "\u22b9",
+    "hfr;": "\U0001d525",
+    "hksearow;": "\u2925",
+    "hkswarow;": "\u2926",
+    "hoarr;": "\u21ff",
+    "homtht;": "\u223b",
+    "hookleftarrow;": "\u21a9",
+    "hookrightarrow;": "\u21aa",
+    "hopf;": "\U0001d559",
+    "horbar;": "\u2015",
+    "hscr;": "\U0001d4bd",
+    "hslash;": "\u210f",
+    "hstrok;": "\u0127",
+    "hybull;": "\u2043",
+    "hyphen;": "\u2010",
+    "iacute": "\xed",
+    "iacute;": "\xed",
+    "ic;": "\u2063",
+    "icirc": "\xee",
+    "icirc;": "\xee",
+    "icy;": "\u0438",
+    "iecy;": "\u0435",
+    "iexcl": "\xa1",
+    "iexcl;": "\xa1",
+    "iff;": "\u21d4",
+    "ifr;": "\U0001d526",
+    "igrave": "\xec",
+    "igrave;": "\xec",
+    "ii;": "\u2148",
+    "iiiint;": "\u2a0c",
+    "iiint;": "\u222d",
+    "iinfin;": "\u29dc",
+    "iiota;": "\u2129",
+    "ijlig;": "\u0133",
+    "imacr;": "\u012b",
+    "image;": "\u2111",
+    "imagline;": "\u2110",
+    "imagpart;": "\u2111",
+    "imath;": "\u0131",
+    "imof;": "\u22b7",
+    "imped;": "\u01b5",
+    "in;": "\u2208",
+    "incare;": "\u2105",
+    "infin;": "\u221e",
+    "infintie;": "\u29dd",
+    "inodot;": "\u0131",
+    "int;": "\u222b",
+    "intcal;": "\u22ba",
+    "integers;": "\u2124",
+    "intercal;": "\u22ba",
+    "intlarhk;": "\u2a17",
+    "intprod;": "\u2a3c",
+    "iocy;": "\u0451",
+    "iogon;": "\u012f",
+    "iopf;": "\U0001d55a",
+    "iota;": "\u03b9",
+    "iprod;": "\u2a3c",
+    "iquest": "\xbf",
+    "iquest;": "\xbf",
+    "iscr;": "\U0001d4be",
+    "isin;": "\u2208",
+    "isinE;": "\u22f9",
+    "isindot;": "\u22f5",
+    "isins;": "\u22f4",
+    "isinsv;": "\u22f3",
+    "isinv;": "\u2208",
+    "it;": "\u2062",
+    "itilde;": "\u0129",
+    "iukcy;": "\u0456",
+    "iuml": "\xef",
+    "iuml;": "\xef",
+    "jcirc;": "\u0135",
+    "jcy;": "\u0439",
+    "jfr;": "\U0001d527",
+    "jmath;": "\u0237",
+    "jopf;": "\U0001d55b",
+    "jscr;": "\U0001d4bf",
+    "jsercy;": "\u0458",
+    "jukcy;": "\u0454",
+    "kappa;": "\u03ba",
+    "kappav;": "\u03f0",
+    "kcedil;": "\u0137",
+    "kcy;": "\u043a",
+    "kfr;": "\U0001d528",
+    "kgreen;": "\u0138",
+    "khcy;": "\u0445",
+    "kjcy;": "\u045c",
+    "kopf;": "\U0001d55c",
+    "kscr;": "\U0001d4c0",
+    "lAarr;": "\u21da",
+    "lArr;": "\u21d0",
+    "lAtail;": "\u291b",
+    "lBarr;": "\u290e",
+    "lE;": "\u2266",
+    "lEg;": "\u2a8b",
+    "lHar;": "\u2962",
+    "lacute;": "\u013a",
+    "laemptyv;": "\u29b4",
+    "lagran;": "\u2112",
+    "lambda;": "\u03bb",
+    "lang;": "\u27e8",
+    "langd;": "\u2991",
+    "langle;": "\u27e8",
+    "lap;": "\u2a85",
+    "laquo": "\xab",
+    "laquo;": "\xab",
+    "larr;": "\u2190",
+    "larrb;": "\u21e4",
+    "larrbfs;": "\u291f",
+    "larrfs;": "\u291d",
+    "larrhk;": "\u21a9",
+    "larrlp;": "\u21ab",
+    "larrpl;": "\u2939",
+    "larrsim;": "\u2973",
+    "larrtl;": "\u21a2",
+    "lat;": "\u2aab",
+    "latail;": "\u2919",
+    "late;": "\u2aad",
+    "lates;": "\u2aad\ufe00",
+    "lbarr;": "\u290c",
+    "lbbrk;": "\u2772",
+    "lbrace;": "{",
+    "lbrack;": "[",
+    "lbrke;": "\u298b",
+    "lbrksld;": "\u298f",
+    "lbrkslu;": "\u298d",
+    "lcaron;": "\u013e",
+    "lcedil;": "\u013c",
+    "lceil;": "\u2308",
+    "lcub;": "{",
+    "lcy;": "\u043b",
+    "ldca;": "\u2936",
+    "ldquo;": "\u201c",
+    "ldquor;": "\u201e",
+    "ldrdhar;": "\u2967",
+    "ldrushar;": "\u294b",
+    "ldsh;": "\u21b2",
+    "le;": "\u2264",
+    "leftarrow;": "\u2190",
+    "leftarrowtail;": "\u21a2",
+    "leftharpoondown;": "\u21bd",
+    "leftharpoonup;": "\u21bc",
+    "leftleftarrows;": "\u21c7",
+    "leftrightarrow;": "\u2194",
+    "leftrightarrows;": "\u21c6",
+    "leftrightharpoons;": "\u21cb",
+    "leftrightsquigarrow;": "\u21ad",
+    "leftthreetimes;": "\u22cb",
+    "leg;": "\u22da",
+    "leq;": "\u2264",
+    "leqq;": "\u2266",
+    "leqslant;": "\u2a7d",
+    "les;": "\u2a7d",
+    "lescc;": "\u2aa8",
+    "lesdot;": "\u2a7f",
+    "lesdoto;": "\u2a81",
+    "lesdotor;": "\u2a83",
+    "lesg;": "\u22da\ufe00",
+    "lesges;": "\u2a93",
+    "lessapprox;": "\u2a85",
+    "lessdot;": "\u22d6",
+    "lesseqgtr;": "\u22da",
+    "lesseqqgtr;": "\u2a8b",
+    "lessgtr;": "\u2276",
+    "lesssim;": "\u2272",
+    "lfisht;": "\u297c",
+    "lfloor;": "\u230a",
+    "lfr;": "\U0001d529",
+    "lg;": "\u2276",
+    "lgE;": "\u2a91",
+    "lhard;": "\u21bd",
+    "lharu;": "\u21bc",
+    "lharul;": "\u296a",
+    "lhblk;": "\u2584",
+    "ljcy;": "\u0459",
+    "ll;": "\u226a",
+    "llarr;": "\u21c7",
+    "llcorner;": "\u231e",
+    "llhard;": "\u296b",
+    "lltri;": "\u25fa",
+    "lmidot;": "\u0140",
+    "lmoust;": "\u23b0",
+    "lmoustache;": "\u23b0",
+    "lnE;": "\u2268",
+    "lnap;": "\u2a89",
+    "lnapprox;": "\u2a89",
+    "lne;": "\u2a87",
+    "lneq;": "\u2a87",
+    "lneqq;": "\u2268",
+    "lnsim;": "\u22e6",
+    "loang;": "\u27ec",
+    "loarr;": "\u21fd",
+    "lobrk;": "\u27e6",
+    "longleftarrow;": "\u27f5",
+    "longleftrightarrow;": "\u27f7",
+    "longmapsto;": "\u27fc",
+    "longrightarrow;": "\u27f6",
+    "looparrowleft;": "\u21ab",
+    "looparrowright;": "\u21ac",
+    "lopar;": "\u2985",
+    "lopf;": "\U0001d55d",
+    "loplus;": "\u2a2d",
+    "lotimes;": "\u2a34",
+    "lowast;": "\u2217",
+    "lowbar;": "_",
+    "loz;": "\u25ca",
+    "lozenge;": "\u25ca",
+    "lozf;": "\u29eb",
+    "lpar;": "(",
+    "lparlt;": "\u2993",
+    "lrarr;": "\u21c6",
+    "lrcorner;": "\u231f",
+    "lrhar;": "\u21cb",
+    "lrhard;": "\u296d",
+    "lrm;": "\u200e",
+    "lrtri;": "\u22bf",
+    "lsaquo;": "\u2039",
+    "lscr;": "\U0001d4c1",
+    "lsh;": "\u21b0",
+    "lsim;": "\u2272",
+    "lsime;": "\u2a8d",
+    "lsimg;": "\u2a8f",
+    "lsqb;": "[",
+    "lsquo;": "\u2018",
+    "lsquor;": "\u201a",
+    "lstrok;": "\u0142",
+    "lt": "<",
+    "lt;": "<",
+    "ltcc;": "\u2aa6",
+    "ltcir;": "\u2a79",
+    "ltdot;": "\u22d6",
+    "lthree;": "\u22cb",
+    "ltimes;": "\u22c9",
+    "ltlarr;": "\u2976",
+    "ltquest;": "\u2a7b",
+    "ltrPar;": "\u2996",
+    "ltri;": "\u25c3",
+    "ltrie;": "\u22b4",
+    "ltrif;": "\u25c2",
+    "lurdshar;": "\u294a",
+    "luruhar;": "\u2966",
+    "lvertneqq;": "\u2268\ufe00",
+    "lvnE;": "\u2268\ufe00",
+    "mDDot;": "\u223a",
+    "macr": "\xaf",
+    "macr;": "\xaf",
+    "male;": "\u2642",
+    "malt;": "\u2720",
+    "maltese;": "\u2720",
+    "map;": "\u21a6",
+    "mapsto;": "\u21a6",
+    "mapstodown;": "\u21a7",
+    "mapstoleft;": "\u21a4",
+    "mapstoup;": "\u21a5",
+    "marker;": "\u25ae",
+    "mcomma;": "\u2a29",
+    "mcy;": "\u043c",
+    "mdash;": "\u2014",
+    "measuredangle;": "\u2221",
+    "mfr;": "\U0001d52a",
+    "mho;": "\u2127",
+    "micro": "\xb5",
+    "micro;": "\xb5",
+    "mid;": "\u2223",
+    "midast;": "*",
+    "midcir;": "\u2af0",
+    "middot": "\xb7",
+    "middot;": "\xb7",
+    "minus;": "\u2212",
+    "minusb;": "\u229f",
+    "minusd;": "\u2238",
+    "minusdu;": "\u2a2a",
+    "mlcp;": "\u2adb",
+    "mldr;": "\u2026",
+    "mnplus;": "\u2213",
+    "models;": "\u22a7",
+    "mopf;": "\U0001d55e",
+    "mp;": "\u2213",
+    "mscr;": "\U0001d4c2",
+    "mstpos;": "\u223e",
+    "mu;": "\u03bc",
+    "multimap;": "\u22b8",
+    "mumap;": "\u22b8",
+    "nGg;": "\u22d9\u0338",
+    "nGt;": "\u226b\u20d2",
+    "nGtv;": "\u226b\u0338",
+    "nLeftarrow;": "\u21cd",
+    "nLeftrightarrow;": "\u21ce",
+    "nLl;": "\u22d8\u0338",
+    "nLt;": "\u226a\u20d2",
+    "nLtv;": "\u226a\u0338",
+    "nRightarrow;": "\u21cf",
+    "nVDash;": "\u22af",
+    "nVdash;": "\u22ae",
+    "nabla;": "\u2207",
+    "nacute;": "\u0144",
+    "nang;": "\u2220\u20d2",
+    "nap;": "\u2249",
+    "napE;": "\u2a70\u0338",
+    "napid;": "\u224b\u0338",
+    "napos;": "\u0149",
+    "napprox;": "\u2249",
+    "natur;": "\u266e",
+    "natural;": "\u266e",
+    "naturals;": "\u2115",
+    "nbsp": "\xa0",
+    "nbsp;": "\xa0",
+    "nbump;": "\u224e\u0338",
+    "nbumpe;": "\u224f\u0338",
+    "ncap;": "\u2a43",
+    "ncaron;": "\u0148",
+    "ncedil;": "\u0146",
+    "ncong;": "\u2247",
+    "ncongdot;": "\u2a6d\u0338",
+    "ncup;": "\u2a42",
+    "ncy;": "\u043d",
+    "ndash;": "\u2013",
+    "ne;": "\u2260",
+    "neArr;": "\u21d7",
+    "nearhk;": "\u2924",
+    "nearr;": "\u2197",
+    "nearrow;": "\u2197",
+    "nedot;": "\u2250\u0338",
+    "nequiv;": "\u2262",
+    "nesear;": "\u2928",
+    "nesim;": "\u2242\u0338",
+    "nexist;": "\u2204",
+    "nexists;": "\u2204",
+    "nfr;": "\U0001d52b",
+    "ngE;": "\u2267\u0338",
+    "nge;": "\u2271",
+    "ngeq;": "\u2271",
+    "ngeqq;": "\u2267\u0338",
+    "ngeqslant;": "\u2a7e\u0338",
+    "nges;": "\u2a7e\u0338",
+    "ngsim;": "\u2275",
+    "ngt;": "\u226f",
+    "ngtr;": "\u226f",
+    "nhArr;": "\u21ce",
+    "nharr;": "\u21ae",
+    "nhpar;": "\u2af2",
+    "ni;": "\u220b",
+    "nis;": "\u22fc",
+    "nisd;": "\u22fa",
+    "niv;": "\u220b",
+    "njcy;": "\u045a",
+    "nlArr;": "\u21cd",
+    "nlE;": "\u2266\u0338",
+    "nlarr;": "\u219a",
+    "nldr;": "\u2025",
+    "nle;": "\u2270",
+    "nleftarrow;": "\u219a",
+    "nleftrightarrow;": "\u21ae",
+    "nleq;": "\u2270",
+    "nleqq;": "\u2266\u0338",
+    "nleqslant;": "\u2a7d\u0338",
+    "nles;": "\u2a7d\u0338",
+    "nless;": "\u226e",
+    "nlsim;": "\u2274",
+    "nlt;": "\u226e",
+    "nltri;": "\u22ea",
+    "nltrie;": "\u22ec",
+    "nmid;": "\u2224",
+    "nopf;": "\U0001d55f",
+    "not": "\xac",
+    "not;": "\xac",
+    "notin;": "\u2209",
+    "notinE;": "\u22f9\u0338",
+    "notindot;": "\u22f5\u0338",
+    "notinva;": "\u2209",
+    "notinvb;": "\u22f7",
+    "notinvc;": "\u22f6",
+    "notni;": "\u220c",
+    "notniva;": "\u220c",
+    "notnivb;": "\u22fe",
+    "notnivc;": "\u22fd",
+    "npar;": "\u2226",
+    "nparallel;": "\u2226",
+    "nparsl;": "\u2afd\u20e5",
+    "npart;": "\u2202\u0338",
+    "npolint;": "\u2a14",
+    "npr;": "\u2280",
+    "nprcue;": "\u22e0",
+    "npre;": "\u2aaf\u0338",
+    "nprec;": "\u2280",
+    "npreceq;": "\u2aaf\u0338",
+    "nrArr;": "\u21cf",
+    "nrarr;": "\u219b",
+    "nrarrc;": "\u2933\u0338",
+    "nrarrw;": "\u219d\u0338",
+    "nrightarrow;": "\u219b",
+    "nrtri;": "\u22eb",
+    "nrtrie;": "\u22ed",
+    "nsc;": "\u2281",
+    "nsccue;": "\u22e1",
+    "nsce;": "\u2ab0\u0338",
+    "nscr;": "\U0001d4c3",
+    "nshortmid;": "\u2224",
+    "nshortparallel;": "\u2226",
+    "nsim;": "\u2241",
+    "nsime;": "\u2244",
+    "nsimeq;": "\u2244",
+    "nsmid;": "\u2224",
+    "nspar;": "\u2226",
+    "nsqsube;": "\u22e2",
+    "nsqsupe;": "\u22e3",
+    "nsub;": "\u2284",
+    "nsubE;": "\u2ac5\u0338",
+    "nsube;": "\u2288",
+    "nsubset;": "\u2282\u20d2",
+    "nsubseteq;": "\u2288",
+    "nsubseteqq;": "\u2ac5\u0338",
+    "nsucc;": "\u2281",
+    "nsucceq;": "\u2ab0\u0338",
+    "nsup;": "\u2285",
+    "nsupE;": "\u2ac6\u0338",
+    "nsupe;": "\u2289",
+    "nsupset;": "\u2283\u20d2",
+    "nsupseteq;": "\u2289",
+    "nsupseteqq;": "\u2ac6\u0338",
+    "ntgl;": "\u2279",
+    "ntilde": "\xf1",
+    "ntilde;": "\xf1",
+    "ntlg;": "\u2278",
+    "ntriangleleft;": "\u22ea",
+    "ntrianglelefteq;": "\u22ec",
+    "ntriangleright;": "\u22eb",
+    "ntrianglerighteq;": "\u22ed",
+    "nu;": "\u03bd",
+    "num;": "#",
+    "numero;": "\u2116",
+    "numsp;": "\u2007",
+    "nvDash;": "\u22ad",
+    "nvHarr;": "\u2904",
+    "nvap;": "\u224d\u20d2",
+    "nvdash;": "\u22ac",
+    "nvge;": "\u2265\u20d2",
+    "nvgt;": ">\u20d2",
+    "nvinfin;": "\u29de",
+    "nvlArr;": "\u2902",
+    "nvle;": "\u2264\u20d2",
+    "nvlt;": "<\u20d2",
+    "nvltrie;": "\u22b4\u20d2",
+    "nvrArr;": "\u2903",
+    "nvrtrie;": "\u22b5\u20d2",
+    "nvsim;": "\u223c\u20d2",
+    "nwArr;": "\u21d6",
+    "nwarhk;": "\u2923",
+    "nwarr;": "\u2196",
+    "nwarrow;": "\u2196",
+    "nwnear;": "\u2927",
+    "oS;": "\u24c8",
+    "oacute": "\xf3",
+    "oacute;": "\xf3",
+    "oast;": "\u229b",
+    "ocir;": "\u229a",
+    "ocirc": "\xf4",
+    "ocirc;": "\xf4",
+    "ocy;": "\u043e",
+    "odash;": "\u229d",
+    "odblac;": "\u0151",
+    "odiv;": "\u2a38",
+    "odot;": "\u2299",
+    "odsold;": "\u29bc",
+    "oelig;": "\u0153",
+    "ofcir;": "\u29bf",
+    "ofr;": "\U0001d52c",
+    "ogon;": "\u02db",
+    "ograve": "\xf2",
+    "ograve;": "\xf2",
+    "ogt;": "\u29c1",
+    "ohbar;": "\u29b5",
+    "ohm;": "\u03a9",
+    "oint;": "\u222e",
+    "olarr;": "\u21ba",
+    "olcir;": "\u29be",
+    "olcross;": "\u29bb",
+    "oline;": "\u203e",
+    "olt;": "\u29c0",
+    "omacr;": "\u014d",
+    "omega;": "\u03c9",
+    "omicron;": "\u03bf",
+    "omid;": "\u29b6",
+    "ominus;": "\u2296",
+    "oopf;": "\U0001d560",
+    "opar;": "\u29b7",
+    "operp;": "\u29b9",
+    "oplus;": "\u2295",
+    "or;": "\u2228",
+    "orarr;": "\u21bb",
+    "ord;": "\u2a5d",
+    "order;": "\u2134",
+    "orderof;": "\u2134",
+    "ordf": "\xaa",
+    "ordf;": "\xaa",
+    "ordm": "\xba",
+    "ordm;": "\xba",
+    "origof;": "\u22b6",
+    "oror;": "\u2a56",
+    "orslope;": "\u2a57",
+    "orv;": "\u2a5b",
+    "oscr;": "\u2134",
+    "oslash": "\xf8",
+    "oslash;": "\xf8",
+    "osol;": "\u2298",
+    "otilde": "\xf5",
+    "otilde;": "\xf5",
+    "otimes;": "\u2297",
+    "otimesas;": "\u2a36",
+    "ouml": "\xf6",
+    "ouml;": "\xf6",
+    "ovbar;": "\u233d",
+    "par;": "\u2225",
+    "para": "\xb6",
+    "para;": "\xb6",
+    "parallel;": "\u2225",
+    "parsim;": "\u2af3",
+    "parsl;": "\u2afd",
+    "part;": "\u2202",
+    "pcy;": "\u043f",
+    "percnt;": "%",
+    "period;": ".",
+    "permil;": "\u2030",
+    "perp;": "\u22a5",
+    "pertenk;": "\u2031",
+    "pfr;": "\U0001d52d",
+    "phi;": "\u03c6",
+    "phiv;": "\u03d5",
+    "phmmat;": "\u2133",
+    "phone;": "\u260e",
+    "pi;": "\u03c0",
+    "pitchfork;": "\u22d4",
+    "piv;": "\u03d6",
+    "planck;": "\u210f",
+    "planckh;": "\u210e",
+    "plankv;": "\u210f",
+    "plus;": "+",
+    "plusacir;": "\u2a23",
+    "plusb;": "\u229e",
+    "pluscir;": "\u2a22",
+    "plusdo;": "\u2214",
+    "plusdu;": "\u2a25",
+    "pluse;": "\u2a72",
+    "plusmn": "\xb1",
+    "plusmn;": "\xb1",
+    "plussim;": "\u2a26",
+    "plustwo;": "\u2a27",
+    "pm;": "\xb1",
+    "pointint;": "\u2a15",
+    "popf;": "\U0001d561",
+    "pound": "\xa3",
+    "pound;": "\xa3",
+    "pr;": "\u227a",
+    "prE;": "\u2ab3",
+    "prap;": "\u2ab7",
+    "prcue;": "\u227c",
+    "pre;": "\u2aaf",
+    "prec;": "\u227a",
+    "precapprox;": "\u2ab7",
+    "preccurlyeq;": "\u227c",
+    "preceq;": "\u2aaf",
+    "precnapprox;": "\u2ab9",
+    "precneqq;": "\u2ab5",
+    "precnsim;": "\u22e8",
+    "precsim;": "\u227e",
+    "prime;": "\u2032",
+    "primes;": "\u2119",
+    "prnE;": "\u2ab5",
+    "prnap;": "\u2ab9",
+    "prnsim;": "\u22e8",
+    "prod;": "\u220f",
+    "profalar;": "\u232e",
+    "profline;": "\u2312",
+    "profsurf;": "\u2313",
+    "prop;": "\u221d",
+    "propto;": "\u221d",
+    "prsim;": "\u227e",
+    "prurel;": "\u22b0",
+    "pscr;": "\U0001d4c5",
+    "psi;": "\u03c8",
+    "puncsp;": "\u2008",
+    "qfr;": "\U0001d52e",
+    "qint;": "\u2a0c",
+    "qopf;": "\U0001d562",
+    "qprime;": "\u2057",
+    "qscr;": "\U0001d4c6",
+    "quaternions;": "\u210d",
+    "quatint;": "\u2a16",
+    "quest;": "?",
+    "questeq;": "\u225f",
+    "quot": "\"",
+    "quot;": "\"",
+    "rAarr;": "\u21db",
+    "rArr;": "\u21d2",
+    "rAtail;": "\u291c",
+    "rBarr;": "\u290f",
+    "rHar;": "\u2964",
+    "race;": "\u223d\u0331",
+    "racute;": "\u0155",
+    "radic;": "\u221a",
+    "raemptyv;": "\u29b3",
+    "rang;": "\u27e9",
+    "rangd;": "\u2992",
+    "range;": "\u29a5",
+    "rangle;": "\u27e9",
+    "raquo": "\xbb",
+    "raquo;": "\xbb",
+    "rarr;": "\u2192",
+    "rarrap;": "\u2975",
+    "rarrb;": "\u21e5",
+    "rarrbfs;": "\u2920",
+    "rarrc;": "\u2933",
+    "rarrfs;": "\u291e",
+    "rarrhk;": "\u21aa",
+    "rarrlp;": "\u21ac",
+    "rarrpl;": "\u2945",
+    "rarrsim;": "\u2974",
+    "rarrtl;": "\u21a3",
+    "rarrw;": "\u219d",
+    "ratail;": "\u291a",
+    "ratio;": "\u2236",
+    "rationals;": "\u211a",
+    "rbarr;": "\u290d",
+    "rbbrk;": "\u2773",
+    "rbrace;": "}",
+    "rbrack;": "]",
+    "rbrke;": "\u298c",
+    "rbrksld;": "\u298e",
+    "rbrkslu;": "\u2990",
+    "rcaron;": "\u0159",
+    "rcedil;": "\u0157",
+    "rceil;": "\u2309",
+    "rcub;": "}",
+    "rcy;": "\u0440",
+    "rdca;": "\u2937",
+    "rdldhar;": "\u2969",
+    "rdquo;": "\u201d",
+    "rdquor;": "\u201d",
+    "rdsh;": "\u21b3",
+    "real;": "\u211c",
+    "realine;": "\u211b",
+    "realpart;": "\u211c",
+    "reals;": "\u211d",
+    "rect;": "\u25ad",
+    "reg": "\xae",
+    "reg;": "\xae",
+    "rfisht;": "\u297d",
+    "rfloor;": "\u230b",
+    "rfr;": "\U0001d52f",
+    "rhard;": "\u21c1",
+    "rharu;": "\u21c0",
+    "rharul;": "\u296c",
+    "rho;": "\u03c1",
+    "rhov;": "\u03f1",
+    "rightarrow;": "\u2192",
+    "rightarrowtail;": "\u21a3",
+    "rightharpoondown;": "\u21c1",
+    "rightharpoonup;": "\u21c0",
+    "rightleftarrows;": "\u21c4",
+    "rightleftharpoons;": "\u21cc",
+    "rightrightarrows;": "\u21c9",
+    "rightsquigarrow;": "\u219d",
+    "rightthreetimes;": "\u22cc",
+    "ring;": "\u02da",
+    "risingdotseq;": "\u2253",
+    "rlarr;": "\u21c4",
+    "rlhar;": "\u21cc",
+    "rlm;": "\u200f",
+    "rmoust;": "\u23b1",
+    "rmoustache;": "\u23b1",
+    "rnmid;": "\u2aee",
+    "roang;": "\u27ed",
+    "roarr;": "\u21fe",
+    "robrk;": "\u27e7",
+    "ropar;": "\u2986",
+    "ropf;": "\U0001d563",
+    "roplus;": "\u2a2e",
+    "rotimes;": "\u2a35",
+    "rpar;": ")",
+    "rpargt;": "\u2994",
+    "rppolint;": "\u2a12",
+    "rrarr;": "\u21c9",
+    "rsaquo;": "\u203a",
+    "rscr;": "\U0001d4c7",
+    "rsh;": "\u21b1",
+    "rsqb;": "]",
+    "rsquo;": "\u2019",
+    "rsquor;": "\u2019",
+    "rthree;": "\u22cc",
+    "rtimes;": "\u22ca",
+    "rtri;": "\u25b9",
+    "rtrie;": "\u22b5",
+    "rtrif;": "\u25b8",
+    "rtriltri;": "\u29ce",
+    "ruluhar;": "\u2968",
+    "rx;": "\u211e",
+    "sacute;": "\u015b",
+    "sbquo;": "\u201a",
+    "sc;": "\u227b",
+    "scE;": "\u2ab4",
+    "scap;": "\u2ab8",
+    "scaron;": "\u0161",
+    "sccue;": "\u227d",
+    "sce;": "\u2ab0",
+    "scedil;": "\u015f",
+    "scirc;": "\u015d",
+    "scnE;": "\u2ab6",
+    "scnap;": "\u2aba",
+    "scnsim;": "\u22e9",
+    "scpolint;": "\u2a13",
+    "scsim;": "\u227f",
+    "scy;": "\u0441",
+    "sdot;": "\u22c5",
+    "sdotb;": "\u22a1",
+    "sdote;": "\u2a66",
+    "seArr;": "\u21d8",
+    "searhk;": "\u2925",
+    "searr;": "\u2198",
+    "searrow;": "\u2198",
+    "sect": "\xa7",
+    "sect;": "\xa7",
+    "semi;": ";",
+    "seswar;": "\u2929",
+    "setminus;": "\u2216",
+    "setmn;": "\u2216",
+    "sext;": "\u2736",
+    "sfr;": "\U0001d530",
+    "sfrown;": "\u2322",
+    "sharp;": "\u266f",
+    "shchcy;": "\u0449",
+    "shcy;": "\u0448",
+    "shortmid;": "\u2223",
+    "shortparallel;": "\u2225",
+    "shy": "\xad",
+    "shy;": "\xad",
+    "sigma;": "\u03c3",
+    "sigmaf;": "\u03c2",
+    "sigmav;": "\u03c2",
+    "sim;": "\u223c",
+    "simdot;": "\u2a6a",
+    "sime;": "\u2243",
+    "simeq;": "\u2243",
+    "simg;": "\u2a9e",
+    "simgE;": "\u2aa0",
+    "siml;": "\u2a9d",
+    "simlE;": "\u2a9f",
+    "simne;": "\u2246",
+    "simplus;": "\u2a24",
+    "simrarr;": "\u2972",
+    "slarr;": "\u2190",
+    "smallsetminus;": "\u2216",
+    "smashp;": "\u2a33",
+    "smeparsl;": "\u29e4",
+    "smid;": "\u2223",
+    "smile;": "\u2323",
+    "smt;": "\u2aaa",
+    "smte;": "\u2aac",
+    "smtes;": "\u2aac\ufe00",
+    "softcy;": "\u044c",
+    "sol;": "/",
+    "solb;": "\u29c4",
+    "solbar;": "\u233f",
+    "sopf;": "\U0001d564",
+    "spades;": "\u2660",
+    "spadesuit;": "\u2660",
+    "spar;": "\u2225",
+    "sqcap;": "\u2293",
+    "sqcaps;": "\u2293\ufe00",
+    "sqcup;": "\u2294",
+    "sqcups;": "\u2294\ufe00",
+    "sqsub;": "\u228f",
+    "sqsube;": "\u2291",
+    "sqsubset;": "\u228f",
+    "sqsubseteq;": "\u2291",
+    "sqsup;": "\u2290",
+    "sqsupe;": "\u2292",
+    "sqsupset;": "\u2290",
+    "sqsupseteq;": "\u2292",
+    "squ;": "\u25a1",
+    "square;": "\u25a1",
+    "squarf;": "\u25aa",
+    "squf;": "\u25aa",
+    "srarr;": "\u2192",
+    "sscr;": "\U0001d4c8",
+    "ssetmn;": "\u2216",
+    "ssmile;": "\u2323",
+    "sstarf;": "\u22c6",
+    "star;": "\u2606",
+    "starf;": "\u2605",
+    "straightepsilon;": "\u03f5",
+    "straightphi;": "\u03d5",
+    "strns;": "\xaf",
+    "sub;": "\u2282",
+    "subE;": "\u2ac5",
+    "subdot;": "\u2abd",
+    "sube;": "\u2286",
+    "subedot;": "\u2ac3",
+    "submult;": "\u2ac1",
+    "subnE;": "\u2acb",
+    "subne;": "\u228a",
+    "subplus;": "\u2abf",
+    "subrarr;": "\u2979",
+    "subset;": "\u2282",
+    "subseteq;": "\u2286",
+    "subseteqq;": "\u2ac5",
+    "subsetneq;": "\u228a",
+    "subsetneqq;": "\u2acb",
+    "subsim;": "\u2ac7",
+    "subsub;": "\u2ad5",
+    "subsup;": "\u2ad3",
+    "succ;": "\u227b",
+    "succapprox;": "\u2ab8",
+    "succcurlyeq;": "\u227d",
+    "succeq;": "\u2ab0",
+    "succnapprox;": "\u2aba",
+    "succneqq;": "\u2ab6",
+    "succnsim;": "\u22e9",
+    "succsim;": "\u227f",
+    "sum;": "\u2211",
+    "sung;": "\u266a",
+    "sup1": "\xb9",
+    "sup1;": "\xb9",
+    "sup2": "\xb2",
+    "sup2;": "\xb2",
+    "sup3": "\xb3",
+    "sup3;": "\xb3",
+    "sup;": "\u2283",
+    "supE;": "\u2ac6",
+    "supdot;": "\u2abe",
+    "supdsub;": "\u2ad8",
+    "supe;": "\u2287",
+    "supedot;": "\u2ac4",
+    "suphsol;": "\u27c9",
+    "suphsub;": "\u2ad7",
+    "suplarr;": "\u297b",
+    "supmult;": "\u2ac2",
+    "supnE;": "\u2acc",
+    "supne;": "\u228b",
+    "supplus;": "\u2ac0",
+    "supset;": "\u2283",
+    "supseteq;": "\u2287",
+    "supseteqq;": "\u2ac6",
+    "supsetneq;": "\u228b",
+    "supsetneqq;": "\u2acc",
+    "supsim;": "\u2ac8",
+    "supsub;": "\u2ad4",
+    "supsup;": "\u2ad6",
+    "swArr;": "\u21d9",
+    "swarhk;": "\u2926",
+    "swarr;": "\u2199",
+    "swarrow;": "\u2199",
+    "swnwar;": "\u292a",
+    "szlig": "\xdf",
+    "szlig;": "\xdf",
+    "target;": "\u2316",
+    "tau;": "\u03c4",
+    "tbrk;": "\u23b4",
+    "tcaron;": "\u0165",
+    "tcedil;": "\u0163",
+    "tcy;": "\u0442",
+    "tdot;": "\u20db",
+    "telrec;": "\u2315",
+    "tfr;": "\U0001d531",
+    "there4;": "\u2234",
+    "therefore;": "\u2234",
+    "theta;": "\u03b8",
+    "thetasym;": "\u03d1",
+    "thetav;": "\u03d1",
+    "thickapprox;": "\u2248",
+    "thicksim;": "\u223c",
+    "thinsp;": "\u2009",
+    "thkap;": "\u2248",
+    "thksim;": "\u223c",
+    "thorn": "\xfe",
+    "thorn;": "\xfe",
+    "tilde;": "\u02dc",
+    "times": "\xd7",
+    "times;": "\xd7",
+    "timesb;": "\u22a0",
+    "timesbar;": "\u2a31",
+    "timesd;": "\u2a30",
+    "tint;": "\u222d",
+    "toea;": "\u2928",
+    "top;": "\u22a4",
+    "topbot;": "\u2336",
+    "topcir;": "\u2af1",
+    "topf;": "\U0001d565",
+    "topfork;": "\u2ada",
+    "tosa;": "\u2929",
+    "tprime;": "\u2034",
+    "trade;": "\u2122",
+    "triangle;": "\u25b5",
+    "triangledown;": "\u25bf",
+    "triangleleft;": "\u25c3",
+    "trianglelefteq;": "\u22b4",
+    "triangleq;": "\u225c",
+    "triangleright;": "\u25b9",
+    "trianglerighteq;": "\u22b5",
+    "tridot;": "\u25ec",
+    "trie;": "\u225c",
+    "triminus;": "\u2a3a",
+    "triplus;": "\u2a39",
+    "trisb;": "\u29cd",
+    "tritime;": "\u2a3b",
+    "trpezium;": "\u23e2",
+    "tscr;": "\U0001d4c9",
+    "tscy;": "\u0446",
+    "tshcy;": "\u045b",
+    "tstrok;": "\u0167",
+    "twixt;": "\u226c",
+    "twoheadleftarrow;": "\u219e",
+    "twoheadrightarrow;": "\u21a0",
+    "uArr;": "\u21d1",
+    "uHar;": "\u2963",
+    "uacute": "\xfa",
+    "uacute;": "\xfa",
+    "uarr;": "\u2191",
+    "ubrcy;": "\u045e",
+    "ubreve;": "\u016d",
+    "ucirc": "\xfb",
+    "ucirc;": "\xfb",
+    "ucy;": "\u0443",
+    "udarr;": "\u21c5",
+    "udblac;": "\u0171",
+    "udhar;": "\u296e",
+    "ufisht;": "\u297e",
+    "ufr;": "\U0001d532",
+    "ugrave": "\xf9",
+    "ugrave;": "\xf9",
+    "uharl;": "\u21bf",
+    "uharr;": "\u21be",
+    "uhblk;": "\u2580",
+    "ulcorn;": "\u231c",
+    "ulcorner;": "\u231c",
+    "ulcrop;": "\u230f",
+    "ultri;": "\u25f8",
+    "umacr;": "\u016b",
+    "uml": "\xa8",
+    "uml;": "\xa8",
+    "uogon;": "\u0173",
+    "uopf;": "\U0001d566",
+    "uparrow;": "\u2191",
+    "updownarrow;": "\u2195",
+    "upharpoonleft;": "\u21bf",
+    "upharpoonright;": "\u21be",
+    "uplus;": "\u228e",
+    "upsi;": "\u03c5",
+    "upsih;": "\u03d2",
+    "upsilon;": "\u03c5",
+    "upuparrows;": "\u21c8",
+    "urcorn;": "\u231d",
+    "urcorner;": "\u231d",
+    "urcrop;": "\u230e",
+    "uring;": "\u016f",
+    "urtri;": "\u25f9",
+    "uscr;": "\U0001d4ca",
+    "utdot;": "\u22f0",
+    "utilde;": "\u0169",
+    "utri;": "\u25b5",
+    "utrif;": "\u25b4",
+    "uuarr;": "\u21c8",
+    "uuml": "\xfc",
+    "uuml;": "\xfc",
+    "uwangle;": "\u29a7",
+    "vArr;": "\u21d5",
+    "vBar;": "\u2ae8",
+    "vBarv;": "\u2ae9",
+    "vDash;": "\u22a8",
+    "vangrt;": "\u299c",
+    "varepsilon;": "\u03f5",
+    "varkappa;": "\u03f0",
+    "varnothing;": "\u2205",
+    "varphi;": "\u03d5",
+    "varpi;": "\u03d6",
+    "varpropto;": "\u221d",
+    "varr;": "\u2195",
+    "varrho;": "\u03f1",
+    "varsigma;": "\u03c2",
+    "varsubsetneq;": "\u228a\ufe00",
+    "varsubsetneqq;": "\u2acb\ufe00",
+    "varsupsetneq;": "\u228b\ufe00",
+    "varsupsetneqq;": "\u2acc\ufe00",
+    "vartheta;": "\u03d1",
+    "vartriangleleft;": "\u22b2",
+    "vartriangleright;": "\u22b3",
+    "vcy;": "\u0432",
+    "vdash;": "\u22a2",
+    "vee;": "\u2228",
+    "veebar;": "\u22bb",
+    "veeeq;": "\u225a",
+    "vellip;": "\u22ee",
+    "verbar;": "|",
+    "vert;": "|",
+    "vfr;": "\U0001d533",
+    "vltri;": "\u22b2",
+    "vnsub;": "\u2282\u20d2",
+    "vnsup;": "\u2283\u20d2",
+    "vopf;": "\U0001d567",
+    "vprop;": "\u221d",
+    "vrtri;": "\u22b3",
+    "vscr;": "\U0001d4cb",
+    "vsubnE;": "\u2acb\ufe00",
+    "vsubne;": "\u228a\ufe00",
+    "vsupnE;": "\u2acc\ufe00",
+    "vsupne;": "\u228b\ufe00",
+    "vzigzag;": "\u299a",
+    "wcirc;": "\u0175",
+    "wedbar;": "\u2a5f",
+    "wedge;": "\u2227",
+    "wedgeq;": "\u2259",
+    "weierp;": "\u2118",
+    "wfr;": "\U0001d534",
+    "wopf;": "\U0001d568",
+    "wp;": "\u2118",
+    "wr;": "\u2240",
+    "wreath;": "\u2240",
+    "wscr;": "\U0001d4cc",
+    "xcap;": "\u22c2",
+    "xcirc;": "\u25ef",
+    "xcup;": "\u22c3",
+    "xdtri;": "\u25bd",
+    "xfr;": "\U0001d535",
+    "xhArr;": "\u27fa",
+    "xharr;": "\u27f7",
+    "xi;": "\u03be",
+    "xlArr;": "\u27f8",
+    "xlarr;": "\u27f5",
+    "xmap;": "\u27fc",
+    "xnis;": "\u22fb",
+    "xodot;": "\u2a00",
+    "xopf;": "\U0001d569",
+    "xoplus;": "\u2a01",
+    "xotime;": "\u2a02",
+    "xrArr;": "\u27f9",
+    "xrarr;": "\u27f6",
+    "xscr;": "\U0001d4cd",
+    "xsqcup;": "\u2a06",
+    "xuplus;": "\u2a04",
+    "xutri;": "\u25b3",
+    "xvee;": "\u22c1",
+    "xwedge;": "\u22c0",
+    "yacute": "\xfd",
+    "yacute;": "\xfd",
+    "yacy;": "\u044f",
+    "ycirc;": "\u0177",
+    "ycy;": "\u044b",
+    "yen": "\xa5",
+    "yen;": "\xa5",
+    "yfr;": "\U0001d536",
+    "yicy;": "\u0457",
+    "yopf;": "\U0001d56a",
+    "yscr;": "\U0001d4ce",
+    "yucy;": "\u044e",
+    "yuml": "\xff",
+    "yuml;": "\xff",
+    "zacute;": "\u017a",
+    "zcaron;": "\u017e",
+    "zcy;": "\u0437",
+    "zdot;": "\u017c",
+    "zeetrf;": "\u2128",
+    "zeta;": "\u03b6",
+    "zfr;": "\U0001d537",
+    "zhcy;": "\u0436",
+    "zigrarr;": "\u21dd",
+    "zopf;": "\U0001d56b",
+    "zscr;": "\U0001d4cf",
+    "zwj;": "\u200d",
+    "zwnj;": "\u200c",
+}
+
+replacementCharacters = {
+    0x0: "\uFFFD",
+    0x0d: "\u000D",
+    0x80: "\u20AC",
+    0x81: "\u0081",
+    0x82: "\u201A",
+    0x83: "\u0192",
+    0x84: "\u201E",
+    0x85: "\u2026",
+    0x86: "\u2020",
+    0x87: "\u2021",
+    0x88: "\u02C6",
+    0x89: "\u2030",
+    0x8A: "\u0160",
+    0x8B: "\u2039",
+    0x8C: "\u0152",
+    0x8D: "\u008D",
+    0x8E: "\u017D",
+    0x8F: "\u008F",
+    0x90: "\u0090",
+    0x91: "\u2018",
+    0x92: "\u2019",
+    0x93: "\u201C",
+    0x94: "\u201D",
+    0x95: "\u2022",
+    0x96: "\u2013",
+    0x97: "\u2014",
+    0x98: "\u02DC",
+    0x99: "\u2122",
+    0x9A: "\u0161",
+    0x9B: "\u203A",
+    0x9C: "\u0153",
+    0x9D: "\u009D",
+    0x9E: "\u017E",
+    0x9F: "\u0178",
+}
+
+tokenTypes = {
+    "Doctype": 0,
+    "Characters": 1,
+    "SpaceCharacters": 2,
+    "StartTag": 3,
+    "EndTag": 4,
+    "EmptyTag": 5,
+    "Comment": 6,
+    "ParseError": 7
+}
+
+tagTokenTypes = frozenset([tokenTypes["StartTag"], tokenTypes["EndTag"],
+                           tokenTypes["EmptyTag"]])
+
+
+prefixes = {v: k for k, v in namespaces.items()}
+prefixes["http://www.w3.org/1998/Math/MathML"] = "math"
+
+
+class DataLossWarning(UserWarning):
+    """Raised when the current tree is unable to represent the input data"""
+    pass
+
+
+class _ReparseException(Exception):
+    pass
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/alphabeticalattributes.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/alphabeticalattributes.py
new file mode 100644
index 0000000..5ba926e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/alphabeticalattributes.py
@@ -0,0 +1,29 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from . import base
+
+from collections import OrderedDict
+
+
+def _attr_key(attr):
+    """Return an appropriate key for an attribute for sorting
+
+    Attributes have a namespace that can be either ``None`` or a string. We
+    can't compare the two because they're different types, so we convert
+    ``None`` to an empty string first.
+
+    """
+    return (attr[0][0] or ''), attr[0][1]
+
+
+class Filter(base.Filter):
+    """Alphabetizes attributes for elements"""
+    def __iter__(self):
+        for token in base.Filter.__iter__(self):
+            if token["type"] in ("StartTag", "EmptyTag"):
+                attrs = OrderedDict()
+                for name, value in sorted(token["data"].items(),
+                                          key=_attr_key):
+                    attrs[name] = value
+                token["data"] = attrs
+            yield token
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/base.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/base.py
new file mode 100644
index 0000000..c7dbaed
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/base.py
@@ -0,0 +1,12 @@
+from __future__ import absolute_import, division, unicode_literals
+
+
+class Filter(object):
+    def __init__(self, source):
+        self.source = source
+
+    def __iter__(self):
+        return iter(self.source)
+
+    def __getattr__(self, name):
+        return getattr(self.source, name)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/inject_meta_charset.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/inject_meta_charset.py
new file mode 100644
index 0000000..aefb5c8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/inject_meta_charset.py
@@ -0,0 +1,73 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from . import base
+
+
+class Filter(base.Filter):
+    """Injects ``<meta charset=ENCODING>`` tag into head of document"""
+    def __init__(self, source, encoding):
+        """Creates a Filter
+
+        :arg source: the source token stream
+
+        :arg encoding: the encoding to set
+
+        """
+        base.Filter.__init__(self, source)
+        self.encoding = encoding
+
+    def __iter__(self):
+        state = "pre_head"
+        meta_found = (self.encoding is None)
+        pending = []
+
+        for token in base.Filter.__iter__(self):
+            type = token["type"]
+            if type == "StartTag":
+                if token["name"].lower() == "head":
+                    state = "in_head"
+
+            elif type == "EmptyTag":
+                if token["name"].lower() == "meta":
+                    # replace charset with actual encoding
+                    has_http_equiv_content_type = False
+                    for (namespace, name), value in token["data"].items():
+                        if namespace is not None:
+                            continue
+                        elif name.lower() == 'charset':
+                            token["data"][(namespace, name)] = self.encoding
+                            meta_found = True
+                            break
+                        elif name == 'http-equiv' and value.lower() == 'content-type':
+                            has_http_equiv_content_type = True
+                    else:
+                        if has_http_equiv_content_type and (None, "content") in token["data"]:
+                            token["data"][(None, "content")] = 'text/html; charset=%s' % self.encoding
+                            meta_found = True
+
+                elif token["name"].lower() == "head" and not meta_found:
+                    # insert meta into empty head
+                    yield {"type": "StartTag", "name": "head",
+                           "data": token["data"]}
+                    yield {"type": "EmptyTag", "name": "meta",
+                           "data": {(None, "charset"): self.encoding}}
+                    yield {"type": "EndTag", "name": "head"}
+                    meta_found = True
+                    continue
+
+            elif type == "EndTag":
+                if token["name"].lower() == "head" and pending:
+                    # insert meta into head (if necessary) and flush pending queue
+                    yield pending.pop(0)
+                    if not meta_found:
+                        yield {"type": "EmptyTag", "name": "meta",
+                               "data": {(None, "charset"): self.encoding}}
+                    while pending:
+                        yield pending.pop(0)
+                    meta_found = True
+                    state = "post_head"
+
+            if state == "in_head":
+                pending.append(token)
+            else:
+                yield token
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/lint.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/lint.py
new file mode 100644
index 0000000..fcc07ee
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/lint.py
@@ -0,0 +1,93 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from pip._vendor.six import text_type
+
+from . import base
+from ..constants import namespaces, voidElements
+
+from ..constants import spaceCharacters
+spaceCharacters = "".join(spaceCharacters)
+
+
+class Filter(base.Filter):
+    """Lints the token stream for errors
+
+    If it finds any errors, it'll raise an ``AssertionError``.
+
+    """
+    def __init__(self, source, require_matching_tags=True):
+        """Creates a Filter
+
+        :arg source: the source token stream
+
+        :arg require_matching_tags: whether or not to require matching tags
+
+        """
+        super(Filter, self).__init__(source)
+        self.require_matching_tags = require_matching_tags
+
+    def __iter__(self):
+        open_elements = []
+        for token in base.Filter.__iter__(self):
+            type = token["type"]
+            if type in ("StartTag", "EmptyTag"):
+                namespace = token["namespace"]
+                name = token["name"]
+                assert namespace is None or isinstance(namespace, text_type)
+                assert namespace != ""
+                assert isinstance(name, text_type)
+                assert name != ""
+                assert isinstance(token["data"], dict)
+                if (not namespace or namespace == namespaces["html"]) and name in voidElements:
+                    assert type == "EmptyTag"
+                else:
+                    assert type == "StartTag"
+                if type == "StartTag" and self.require_matching_tags:
+                    open_elements.append((namespace, name))
+                for (namespace, name), value in token["data"].items():
+                    assert namespace is None or isinstance(namespace, text_type)
+                    assert namespace != ""
+                    assert isinstance(name, text_type)
+                    assert name != ""
+                    assert isinstance(value, text_type)
+
+            elif type == "EndTag":
+                namespace = token["namespace"]
+                name = token["name"]
+                assert namespace is None or isinstance(namespace, text_type)
+                assert namespace != ""
+                assert isinstance(name, text_type)
+                assert name != ""
+                if (not namespace or namespace == namespaces["html"]) and name in voidElements:
+                    assert False, "Void element reported as EndTag token: %(tag)s" % {"tag": name}
+                elif self.require_matching_tags:
+                    start = open_elements.pop()
+                    assert start == (namespace, name)
+
+            elif type == "Comment":
+                data = token["data"]
+                assert isinstance(data, text_type)
+
+            elif type in ("Characters", "SpaceCharacters"):
+                data = token["data"]
+                assert isinstance(data, text_type)
+                assert data != ""
+                if type == "SpaceCharacters":
+                    assert data.strip(spaceCharacters) == ""
+
+            elif type == "Doctype":
+                name = token["name"]
+                assert name is None or isinstance(name, text_type)
+                assert token["publicId"] is None or isinstance(name, text_type)
+                assert token["systemId"] is None or isinstance(name, text_type)
+
+            elif type == "Entity":
+                assert isinstance(token["name"], text_type)
+
+            elif type == "SerializerError":
+                assert isinstance(token["data"], text_type)
+
+            else:
+                assert False, "Unknown token type: %(type)s" % {"type": type}
+
+            yield token
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/optionaltags.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/optionaltags.py
new file mode 100644
index 0000000..4a86501
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/optionaltags.py
@@ -0,0 +1,207 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from . import base
+
+
+class Filter(base.Filter):
+    """Removes optional tags from the token stream"""
+    def slider(self):
+        previous1 = previous2 = None
+        for token in self.source:
+            if previous1 is not None:
+                yield previous2, previous1, token
+            previous2 = previous1
+            previous1 = token
+        if previous1 is not None:
+            yield previous2, previous1, None
+
+    def __iter__(self):
+        for previous, token, next in self.slider():
+            type = token["type"]
+            if type == "StartTag":
+                if (token["data"] or
+                        not self.is_optional_start(token["name"], previous, next)):
+                    yield token
+            elif type == "EndTag":
+                if not self.is_optional_end(token["name"], next):
+                    yield token
+            else:
+                yield token
+
+    def is_optional_start(self, tagname, previous, next):
+        type = next and next["type"] or None
+        if tagname in 'html':
+            # An html element's start tag may be omitted if the first thing
+            # inside the html element is not a space character or a comment.
+            return type not in ("Comment", "SpaceCharacters")
+        elif tagname == 'head':
+            # A head element's start tag may be omitted if the first thing
+            # inside the head element is an element.
+            # XXX: we also omit the start tag if the head element is empty
+            if type in ("StartTag", "EmptyTag"):
+                return True
+            elif type == "EndTag":
+                return next["name"] == "head"
+        elif tagname == 'body':
+            # A body element's start tag may be omitted if the first thing
+            # inside the body element is not a space character or a comment,
+            # except if the first thing inside the body element is a script
+            # or style element and the node immediately preceding the body
+            # element is a head element whose end tag has been omitted.
+            if type in ("Comment", "SpaceCharacters"):
+                return False
+            elif type == "StartTag":
+                # XXX: we do not look at the preceding event, so we never omit
+                # the body element's start tag if it's followed by a script or
+                # a style element.
+                return next["name"] not in ('script', 'style')
+            else:
+                return True
+        elif tagname == 'colgroup':
+            # A colgroup element's start tag may be omitted if the first thing
+            # inside the colgroup element is a col element, and if the element
+            # is not immediately preceded by another colgroup element whose
+            # end tag has been omitted.
+            if type in ("StartTag", "EmptyTag"):
+                # XXX: we do not look at the preceding event, so instead we never
+                # omit the colgroup element's end tag when it is immediately
+                # followed by another colgroup element. See is_optional_end.
+                return next["name"] == "col"
+            else:
+                return False
+        elif tagname == 'tbody':
+            # A tbody element's start tag may be omitted if the first thing
+            # inside the tbody element is a tr element, and if the element is
+            # not immediately preceded by a tbody, thead, or tfoot element
+            # whose end tag has been omitted.
+            if type == "StartTag":
+                # omit the thead and tfoot elements' end tag when they are
+                # immediately followed by a tbody element. See is_optional_end.
+                if previous and previous['type'] == 'EndTag' and \
+                        previous['name'] in ('tbody', 'thead', 'tfoot'):
+                    return False
+                return next["name"] == 'tr'
+            else:
+                return False
+        return False
+
+    def is_optional_end(self, tagname, next):
+        type = next and next["type"] or None
+        if tagname in ('html', 'head', 'body'):
+            # An html element's end tag may be omitted if the html element
+            # is not immediately followed by a space character or a comment.
+            return type not in ("Comment", "SpaceCharacters")
+        elif tagname in ('li', 'optgroup', 'tr'):
+            # A li element's end tag may be omitted if the li element is
+            # immediately followed by another li element or if there is
+            # no more content in the parent element.
+            # An optgroup element's end tag may be omitted if the optgroup
+            # element is immediately followed by another optgroup element,
+            # or if there is no more content in the parent element.
+            # A tr element's end tag may be omitted if the tr element is
+            # immediately followed by another tr element, or if there is
+            # no more content in the parent element.
+            if type == "StartTag":
+                return next["name"] == tagname
+            else:
+                return type == "EndTag" or type is None
+        elif tagname in ('dt', 'dd'):
+            # A dt element's end tag may be omitted if the dt element is
+            # immediately followed by another dt element or a dd element.
+            # A dd element's end tag may be omitted if the dd element is
+            # immediately followed by another dd element or a dt element,
+            # or if there is no more content in the parent element.
+            if type == "StartTag":
+                return next["name"] in ('dt', 'dd')
+            elif tagname == 'dd':
+                return type == "EndTag" or type is None
+            else:
+                return False
+        elif tagname == 'p':
+            # A p element's end tag may be omitted if the p element is
+            # immediately followed by an address, article, aside,
+            # blockquote, datagrid, dialog, dir, div, dl, fieldset,
+            # footer, form, h1, h2, h3, h4, h5, h6, header, hr, menu,
+            # nav, ol, p, pre, section, table, or ul, element, or if
+            # there is no more content in the parent element.
+            if type in ("StartTag", "EmptyTag"):
+                return next["name"] in ('address', 'article', 'aside',
+                                        'blockquote', 'datagrid', 'dialog',
+                                        'dir', 'div', 'dl', 'fieldset', 'footer',
+                                        'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+                                        'header', 'hr', 'menu', 'nav', 'ol',
+                                        'p', 'pre', 'section', 'table', 'ul')
+            else:
+                return type == "EndTag" or type is None
+        elif tagname == 'option':
+            # An option element's end tag may be omitted if the option
+            # element is immediately followed by another option element,
+            # or if it is immediately followed by an <code>optgroup</code>
+            # element, or if there is no more content in the parent
+            # element.
+            if type == "StartTag":
+                return next["name"] in ('option', 'optgroup')
+            else:
+                return type == "EndTag" or type is None
+        elif tagname in ('rt', 'rp'):
+            # An rt element's end tag may be omitted if the rt element is
+            # immediately followed by an rt or rp element, or if there is
+            # no more content in the parent element.
+            # An rp element's end tag may be omitted if the rp element is
+            # immediately followed by an rt or rp element, or if there is
+            # no more content in the parent element.
+            if type == "StartTag":
+                return next["name"] in ('rt', 'rp')
+            else:
+                return type == "EndTag" or type is None
+        elif tagname == 'colgroup':
+            # A colgroup element's end tag may be omitted if the colgroup
+            # element is not immediately followed by a space character or
+            # a comment.
+            if type in ("Comment", "SpaceCharacters"):
+                return False
+            elif type == "StartTag":
+                # XXX: we also look for an immediately following colgroup
+                # element. See is_optional_start.
+                return next["name"] != 'colgroup'
+            else:
+                return True
+        elif tagname in ('thead', 'tbody'):
+            # A thead element's end tag may be omitted if the thead element
+            # is immediately followed by a tbody or tfoot element.
+            # A tbody element's end tag may be omitted if the tbody element
+            # is immediately followed by a tbody or tfoot element, or if
+            # there is no more content in the parent element.
+            # A tfoot element's end tag may be omitted if the tfoot element
+            # is immediately followed by a tbody element, or if there is no
+            # more content in the parent element.
+            # XXX: we never omit the end tag when the following element is
+            # a tbody. See is_optional_start.
+            if type == "StartTag":
+                return next["name"] in ['tbody', 'tfoot']
+            elif tagname == 'tbody':
+                return type == "EndTag" or type is None
+            else:
+                return False
+        elif tagname == 'tfoot':
+            # A tfoot element's end tag may be omitted if the tfoot element
+            # is immediately followed by a tbody element, or if there is no
+            # more content in the parent element.
+            # XXX: we never omit the end tag when the following element is
+            # a tbody. See is_optional_start.
+            if type == "StartTag":
+                return next["name"] == 'tbody'
+            else:
+                return type == "EndTag" or type is None
+        elif tagname in ('td', 'th'):
+            # A td element's end tag may be omitted if the td element is
+            # immediately followed by a td or th element, or if there is
+            # no more content in the parent element.
+            # A th element's end tag may be omitted if the th element is
+            # immediately followed by a td or th element, or if there is
+            # no more content in the parent element.
+            if type == "StartTag":
+                return next["name"] in ('td', 'th')
+            else:
+                return type == "EndTag" or type is None
+        return False
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/sanitizer.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/sanitizer.py
new file mode 100644
index 0000000..aa7431d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/sanitizer.py
@@ -0,0 +1,916 @@
+"""Deprecated from html5lib 1.1.
+
+See `here <https://github.com/html5lib/html5lib-python/issues/443>`_ for
+information about its deprecation; `Bleach <https://github.com/mozilla/bleach>`_
+is recommended as a replacement. Please let us know in the aforementioned issue
+if Bleach is unsuitable for your needs.
+
+"""
+from __future__ import absolute_import, division, unicode_literals
+
+import re
+import warnings
+from xml.sax.saxutils import escape, unescape
+
+from pip._vendor.six.moves import urllib_parse as urlparse
+
+from . import base
+from ..constants import namespaces, prefixes
+
+__all__ = ["Filter"]
+
+
+_deprecation_msg = (
+    "html5lib's sanitizer is deprecated; see " +
+    "https://github.com/html5lib/html5lib-python/issues/443 and please let " +
+    "us know if Bleach is unsuitable for your needs"
+)
+
+warnings.warn(_deprecation_msg, DeprecationWarning)
+
+allowed_elements = frozenset((
+    (namespaces['html'], 'a'),
+    (namespaces['html'], 'abbr'),
+    (namespaces['html'], 'acronym'),
+    (namespaces['html'], 'address'),
+    (namespaces['html'], 'area'),
+    (namespaces['html'], 'article'),
+    (namespaces['html'], 'aside'),
+    (namespaces['html'], 'audio'),
+    (namespaces['html'], 'b'),
+    (namespaces['html'], 'big'),
+    (namespaces['html'], 'blockquote'),
+    (namespaces['html'], 'br'),
+    (namespaces['html'], 'button'),
+    (namespaces['html'], 'canvas'),
+    (namespaces['html'], 'caption'),
+    (namespaces['html'], 'center'),
+    (namespaces['html'], 'cite'),
+    (namespaces['html'], 'code'),
+    (namespaces['html'], 'col'),
+    (namespaces['html'], 'colgroup'),
+    (namespaces['html'], 'command'),
+    (namespaces['html'], 'datagrid'),
+    (namespaces['html'], 'datalist'),
+    (namespaces['html'], 'dd'),
+    (namespaces['html'], 'del'),
+    (namespaces['html'], 'details'),
+    (namespaces['html'], 'dfn'),
+    (namespaces['html'], 'dialog'),
+    (namespaces['html'], 'dir'),
+    (namespaces['html'], 'div'),
+    (namespaces['html'], 'dl'),
+    (namespaces['html'], 'dt'),
+    (namespaces['html'], 'em'),
+    (namespaces['html'], 'event-source'),
+    (namespaces['html'], 'fieldset'),
+    (namespaces['html'], 'figcaption'),
+    (namespaces['html'], 'figure'),
+    (namespaces['html'], 'footer'),
+    (namespaces['html'], 'font'),
+    (namespaces['html'], 'form'),
+    (namespaces['html'], 'header'),
+    (namespaces['html'], 'h1'),
+    (namespaces['html'], 'h2'),
+    (namespaces['html'], 'h3'),
+    (namespaces['html'], 'h4'),
+    (namespaces['html'], 'h5'),
+    (namespaces['html'], 'h6'),
+    (namespaces['html'], 'hr'),
+    (namespaces['html'], 'i'),
+    (namespaces['html'], 'img'),
+    (namespaces['html'], 'input'),
+    (namespaces['html'], 'ins'),
+    (namespaces['html'], 'keygen'),
+    (namespaces['html'], 'kbd'),
+    (namespaces['html'], 'label'),
+    (namespaces['html'], 'legend'),
+    (namespaces['html'], 'li'),
+    (namespaces['html'], 'm'),
+    (namespaces['html'], 'map'),
+    (namespaces['html'], 'menu'),
+    (namespaces['html'], 'meter'),
+    (namespaces['html'], 'multicol'),
+    (namespaces['html'], 'nav'),
+    (namespaces['html'], 'nextid'),
+    (namespaces['html'], 'ol'),
+    (namespaces['html'], 'output'),
+    (namespaces['html'], 'optgroup'),
+    (namespaces['html'], 'option'),
+    (namespaces['html'], 'p'),
+    (namespaces['html'], 'pre'),
+    (namespaces['html'], 'progress'),
+    (namespaces['html'], 'q'),
+    (namespaces['html'], 's'),
+    (namespaces['html'], 'samp'),
+    (namespaces['html'], 'section'),
+    (namespaces['html'], 'select'),
+    (namespaces['html'], 'small'),
+    (namespaces['html'], 'sound'),
+    (namespaces['html'], 'source'),
+    (namespaces['html'], 'spacer'),
+    (namespaces['html'], 'span'),
+    (namespaces['html'], 'strike'),
+    (namespaces['html'], 'strong'),
+    (namespaces['html'], 'sub'),
+    (namespaces['html'], 'sup'),
+    (namespaces['html'], 'table'),
+    (namespaces['html'], 'tbody'),
+    (namespaces['html'], 'td'),
+    (namespaces['html'], 'textarea'),
+    (namespaces['html'], 'time'),
+    (namespaces['html'], 'tfoot'),
+    (namespaces['html'], 'th'),
+    (namespaces['html'], 'thead'),
+    (namespaces['html'], 'tr'),
+    (namespaces['html'], 'tt'),
+    (namespaces['html'], 'u'),
+    (namespaces['html'], 'ul'),
+    (namespaces['html'], 'var'),
+    (namespaces['html'], 'video'),
+    (namespaces['mathml'], 'maction'),
+    (namespaces['mathml'], 'math'),
+    (namespaces['mathml'], 'merror'),
+    (namespaces['mathml'], 'mfrac'),
+    (namespaces['mathml'], 'mi'),
+    (namespaces['mathml'], 'mmultiscripts'),
+    (namespaces['mathml'], 'mn'),
+    (namespaces['mathml'], 'mo'),
+    (namespaces['mathml'], 'mover'),
+    (namespaces['mathml'], 'mpadded'),
+    (namespaces['mathml'], 'mphantom'),
+    (namespaces['mathml'], 'mprescripts'),
+    (namespaces['mathml'], 'mroot'),
+    (namespaces['mathml'], 'mrow'),
+    (namespaces['mathml'], 'mspace'),
+    (namespaces['mathml'], 'msqrt'),
+    (namespaces['mathml'], 'mstyle'),
+    (namespaces['mathml'], 'msub'),
+    (namespaces['mathml'], 'msubsup'),
+    (namespaces['mathml'], 'msup'),
+    (namespaces['mathml'], 'mtable'),
+    (namespaces['mathml'], 'mtd'),
+    (namespaces['mathml'], 'mtext'),
+    (namespaces['mathml'], 'mtr'),
+    (namespaces['mathml'], 'munder'),
+    (namespaces['mathml'], 'munderover'),
+    (namespaces['mathml'], 'none'),
+    (namespaces['svg'], 'a'),
+    (namespaces['svg'], 'animate'),
+    (namespaces['svg'], 'animateColor'),
+    (namespaces['svg'], 'animateMotion'),
+    (namespaces['svg'], 'animateTransform'),
+    (namespaces['svg'], 'clipPath'),
+    (namespaces['svg'], 'circle'),
+    (namespaces['svg'], 'defs'),
+    (namespaces['svg'], 'desc'),
+    (namespaces['svg'], 'ellipse'),
+    (namespaces['svg'], 'font-face'),
+    (namespaces['svg'], 'font-face-name'),
+    (namespaces['svg'], 'font-face-src'),
+    (namespaces['svg'], 'g'),
+    (namespaces['svg'], 'glyph'),
+    (namespaces['svg'], 'hkern'),
+    (namespaces['svg'], 'linearGradient'),
+    (namespaces['svg'], 'line'),
+    (namespaces['svg'], 'marker'),
+    (namespaces['svg'], 'metadata'),
+    (namespaces['svg'], 'missing-glyph'),
+    (namespaces['svg'], 'mpath'),
+    (namespaces['svg'], 'path'),
+    (namespaces['svg'], 'polygon'),
+    (namespaces['svg'], 'polyline'),
+    (namespaces['svg'], 'radialGradient'),
+    (namespaces['svg'], 'rect'),
+    (namespaces['svg'], 'set'),
+    (namespaces['svg'], 'stop'),
+    (namespaces['svg'], 'svg'),
+    (namespaces['svg'], 'switch'),
+    (namespaces['svg'], 'text'),
+    (namespaces['svg'], 'title'),
+    (namespaces['svg'], 'tspan'),
+    (namespaces['svg'], 'use'),
+))
+
+allowed_attributes = frozenset((
+    # HTML attributes
+    (None, 'abbr'),
+    (None, 'accept'),
+    (None, 'accept-charset'),
+    (None, 'accesskey'),
+    (None, 'action'),
+    (None, 'align'),
+    (None, 'alt'),
+    (None, 'autocomplete'),
+    (None, 'autofocus'),
+    (None, 'axis'),
+    (None, 'background'),
+    (None, 'balance'),
+    (None, 'bgcolor'),
+    (None, 'bgproperties'),
+    (None, 'border'),
+    (None, 'bordercolor'),
+    (None, 'bordercolordark'),
+    (None, 'bordercolorlight'),
+    (None, 'bottompadding'),
+    (None, 'cellpadding'),
+    (None, 'cellspacing'),
+    (None, 'ch'),
+    (None, 'challenge'),
+    (None, 'char'),
+    (None, 'charoff'),
+    (None, 'choff'),
+    (None, 'charset'),
+    (None, 'checked'),
+    (None, 'cite'),
+    (None, 'class'),
+    (None, 'clear'),
+    (None, 'color'),
+    (None, 'cols'),
+    (None, 'colspan'),
+    (None, 'compact'),
+    (None, 'contenteditable'),
+    (None, 'controls'),
+    (None, 'coords'),
+    (None, 'data'),
+    (None, 'datafld'),
+    (None, 'datapagesize'),
+    (None, 'datasrc'),
+    (None, 'datetime'),
+    (None, 'default'),
+    (None, 'delay'),
+    (None, 'dir'),
+    (None, 'disabled'),
+    (None, 'draggable'),
+    (None, 'dynsrc'),
+    (None, 'enctype'),
+    (None, 'end'),
+    (None, 'face'),
+    (None, 'for'),
+    (None, 'form'),
+    (None, 'frame'),
+    (None, 'galleryimg'),
+    (None, 'gutter'),
+    (None, 'headers'),
+    (None, 'height'),
+    (None, 'hidefocus'),
+    (None, 'hidden'),
+    (None, 'high'),
+    (None, 'href'),
+    (None, 'hreflang'),
+    (None, 'hspace'),
+    (None, 'icon'),
+    (None, 'id'),
+    (None, 'inputmode'),
+    (None, 'ismap'),
+    (None, 'keytype'),
+    (None, 'label'),
+    (None, 'leftspacing'),
+    (None, 'lang'),
+    (None, 'list'),
+    (None, 'longdesc'),
+    (None, 'loop'),
+    (None, 'loopcount'),
+    (None, 'loopend'),
+    (None, 'loopstart'),
+    (None, 'low'),
+    (None, 'lowsrc'),
+    (None, 'max'),
+    (None, 'maxlength'),
+    (None, 'media'),
+    (None, 'method'),
+    (None, 'min'),
+    (None, 'multiple'),
+    (None, 'name'),
+    (None, 'nohref'),
+    (None, 'noshade'),
+    (None, 'nowrap'),
+    (None, 'open'),
+    (None, 'optimum'),
+    (None, 'pattern'),
+    (None, 'ping'),
+    (None, 'point-size'),
+    (None, 'poster'),
+    (None, 'pqg'),
+    (None, 'preload'),
+    (None, 'prompt'),
+    (None, 'radiogroup'),
+    (None, 'readonly'),
+    (None, 'rel'),
+    (None, 'repeat-max'),
+    (None, 'repeat-min'),
+    (None, 'replace'),
+    (None, 'required'),
+    (None, 'rev'),
+    (None, 'rightspacing'),
+    (None, 'rows'),
+    (None, 'rowspan'),
+    (None, 'rules'),
+    (None, 'scope'),
+    (None, 'selected'),
+    (None, 'shape'),
+    (None, 'size'),
+    (None, 'span'),
+    (None, 'src'),
+    (None, 'start'),
+    (None, 'step'),
+    (None, 'style'),
+    (None, 'summary'),
+    (None, 'suppress'),
+    (None, 'tabindex'),
+    (None, 'target'),
+    (None, 'template'),
+    (None, 'title'),
+    (None, 'toppadding'),
+    (None, 'type'),
+    (None, 'unselectable'),
+    (None, 'usemap'),
+    (None, 'urn'),
+    (None, 'valign'),
+    (None, 'value'),
+    (None, 'variable'),
+    (None, 'volume'),
+    (None, 'vspace'),
+    (None, 'vrml'),
+    (None, 'width'),
+    (None, 'wrap'),
+    (namespaces['xml'], 'lang'),
+    # MathML attributes
+    (None, 'actiontype'),
+    (None, 'align'),
+    (None, 'columnalign'),
+    (None, 'columnalign'),
+    (None, 'columnalign'),
+    (None, 'columnlines'),
+    (None, 'columnspacing'),
+    (None, 'columnspan'),
+    (None, 'depth'),
+    (None, 'display'),
+    (None, 'displaystyle'),
+    (None, 'equalcolumns'),
+    (None, 'equalrows'),
+    (None, 'fence'),
+    (None, 'fontstyle'),
+    (None, 'fontweight'),
+    (None, 'frame'),
+    (None, 'height'),
+    (None, 'linethickness'),
+    (None, 'lspace'),
+    (None, 'mathbackground'),
+    (None, 'mathcolor'),
+    (None, 'mathvariant'),
+    (None, 'mathvariant'),
+    (None, 'maxsize'),
+    (None, 'minsize'),
+    (None, 'other'),
+    (None, 'rowalign'),
+    (None, 'rowalign'),
+    (None, 'rowalign'),
+    (None, 'rowlines'),
+    (None, 'rowspacing'),
+    (None, 'rowspan'),
+    (None, 'rspace'),
+    (None, 'scriptlevel'),
+    (None, 'selection'),
+    (None, 'separator'),
+    (None, 'stretchy'),
+    (None, 'width'),
+    (None, 'width'),
+    (namespaces['xlink'], 'href'),
+    (namespaces['xlink'], 'show'),
+    (namespaces['xlink'], 'type'),
+    # SVG attributes
+    (None, 'accent-height'),
+    (None, 'accumulate'),
+    (None, 'additive'),
+    (None, 'alphabetic'),
+    (None, 'arabic-form'),
+    (None, 'ascent'),
+    (None, 'attributeName'),
+    (None, 'attributeType'),
+    (None, 'baseProfile'),
+    (None, 'bbox'),
+    (None, 'begin'),
+    (None, 'by'),
+    (None, 'calcMode'),
+    (None, 'cap-height'),
+    (None, 'class'),
+    (None, 'clip-path'),
+    (None, 'color'),
+    (None, 'color-rendering'),
+    (None, 'content'),
+    (None, 'cx'),
+    (None, 'cy'),
+    (None, 'd'),
+    (None, 'dx'),
+    (None, 'dy'),
+    (None, 'descent'),
+    (None, 'display'),
+    (None, 'dur'),
+    (None, 'end'),
+    (None, 'fill'),
+    (None, 'fill-opacity'),
+    (None, 'fill-rule'),
+    (None, 'font-family'),
+    (None, 'font-size'),
+    (None, 'font-stretch'),
+    (None, 'font-style'),
+    (None, 'font-variant'),
+    (None, 'font-weight'),
+    (None, 'from'),
+    (None, 'fx'),
+    (None, 'fy'),
+    (None, 'g1'),
+    (None, 'g2'),
+    (None, 'glyph-name'),
+    (None, 'gradientUnits'),
+    (None, 'hanging'),
+    (None, 'height'),
+    (None, 'horiz-adv-x'),
+    (None, 'horiz-origin-x'),
+    (None, 'id'),
+    (None, 'ideographic'),
+    (None, 'k'),
+    (None, 'keyPoints'),
+    (None, 'keySplines'),
+    (None, 'keyTimes'),
+    (None, 'lang'),
+    (None, 'marker-end'),
+    (None, 'marker-mid'),
+    (None, 'marker-start'),
+    (None, 'markerHeight'),
+    (None, 'markerUnits'),
+    (None, 'markerWidth'),
+    (None, 'mathematical'),
+    (None, 'max'),
+    (None, 'min'),
+    (None, 'name'),
+    (None, 'offset'),
+    (None, 'opacity'),
+    (None, 'orient'),
+    (None, 'origin'),
+    (None, 'overline-position'),
+    (None, 'overline-thickness'),
+    (None, 'panose-1'),
+    (None, 'path'),
+    (None, 'pathLength'),
+    (None, 'points'),
+    (None, 'preserveAspectRatio'),
+    (None, 'r'),
+    (None, 'refX'),
+    (None, 'refY'),
+    (None, 'repeatCount'),
+    (None, 'repeatDur'),
+    (None, 'requiredExtensions'),
+    (None, 'requiredFeatures'),
+    (None, 'restart'),
+    (None, 'rotate'),
+    (None, 'rx'),
+    (None, 'ry'),
+    (None, 'slope'),
+    (None, 'stemh'),
+    (None, 'stemv'),
+    (None, 'stop-color'),
+    (None, 'stop-opacity'),
+    (None, 'strikethrough-position'),
+    (None, 'strikethrough-thickness'),
+    (None, 'stroke'),
+    (None, 'stroke-dasharray'),
+    (None, 'stroke-dashoffset'),
+    (None, 'stroke-linecap'),
+    (None, 'stroke-linejoin'),
+    (None, 'stroke-miterlimit'),
+    (None, 'stroke-opacity'),
+    (None, 'stroke-width'),
+    (None, 'systemLanguage'),
+    (None, 'target'),
+    (None, 'text-anchor'),
+    (None, 'to'),
+    (None, 'transform'),
+    (None, 'type'),
+    (None, 'u1'),
+    (None, 'u2'),
+    (None, 'underline-position'),
+    (None, 'underline-thickness'),
+    (None, 'unicode'),
+    (None, 'unicode-range'),
+    (None, 'units-per-em'),
+    (None, 'values'),
+    (None, 'version'),
+    (None, 'viewBox'),
+    (None, 'visibility'),
+    (None, 'width'),
+    (None, 'widths'),
+    (None, 'x'),
+    (None, 'x-height'),
+    (None, 'x1'),
+    (None, 'x2'),
+    (namespaces['xlink'], 'actuate'),
+    (namespaces['xlink'], 'arcrole'),
+    (namespaces['xlink'], 'href'),
+    (namespaces['xlink'], 'role'),
+    (namespaces['xlink'], 'show'),
+    (namespaces['xlink'], 'title'),
+    (namespaces['xlink'], 'type'),
+    (namespaces['xml'], 'base'),
+    (namespaces['xml'], 'lang'),
+    (namespaces['xml'], 'space'),
+    (None, 'y'),
+    (None, 'y1'),
+    (None, 'y2'),
+    (None, 'zoomAndPan'),
+))
+
+attr_val_is_uri = frozenset((
+    (None, 'href'),
+    (None, 'src'),
+    (None, 'cite'),
+    (None, 'action'),
+    (None, 'longdesc'),
+    (None, 'poster'),
+    (None, 'background'),
+    (None, 'datasrc'),
+    (None, 'dynsrc'),
+    (None, 'lowsrc'),
+    (None, 'ping'),
+    (namespaces['xlink'], 'href'),
+    (namespaces['xml'], 'base'),
+))
+
+svg_attr_val_allows_ref = frozenset((
+    (None, 'clip-path'),
+    (None, 'color-profile'),
+    (None, 'cursor'),
+    (None, 'fill'),
+    (None, 'filter'),
+    (None, 'marker'),
+    (None, 'marker-start'),
+    (None, 'marker-mid'),
+    (None, 'marker-end'),
+    (None, 'mask'),
+    (None, 'stroke'),
+))
+
+svg_allow_local_href = frozenset((
+    (None, 'altGlyph'),
+    (None, 'animate'),
+    (None, 'animateColor'),
+    (None, 'animateMotion'),
+    (None, 'animateTransform'),
+    (None, 'cursor'),
+    (None, 'feImage'),
+    (None, 'filter'),
+    (None, 'linearGradient'),
+    (None, 'pattern'),
+    (None, 'radialGradient'),
+    (None, 'textpath'),
+    (None, 'tref'),
+    (None, 'set'),
+    (None, 'use')
+))
+
+allowed_css_properties = frozenset((
+    'azimuth',
+    'background-color',
+    'border-bottom-color',
+    'border-collapse',
+    'border-color',
+    'border-left-color',
+    'border-right-color',
+    'border-top-color',
+    'clear',
+    'color',
+    'cursor',
+    'direction',
+    'display',
+    'elevation',
+    'float',
+    'font',
+    'font-family',
+    'font-size',
+    'font-style',
+    'font-variant',
+    'font-weight',
+    'height',
+    'letter-spacing',
+    'line-height',
+    'overflow',
+    'pause',
+    'pause-after',
+    'pause-before',
+    'pitch',
+    'pitch-range',
+    'richness',
+    'speak',
+    'speak-header',
+    'speak-numeral',
+    'speak-punctuation',
+    'speech-rate',
+    'stress',
+    'text-align',
+    'text-decoration',
+    'text-indent',
+    'unicode-bidi',
+    'vertical-align',
+    'voice-family',
+    'volume',
+    'white-space',
+    'width',
+))
+
+allowed_css_keywords = frozenset((
+    'auto',
+    'aqua',
+    'black',
+    'block',
+    'blue',
+    'bold',
+    'both',
+    'bottom',
+    'brown',
+    'center',
+    'collapse',
+    'dashed',
+    'dotted',
+    'fuchsia',
+    'gray',
+    'green',
+    '!important',
+    'italic',
+    'left',
+    'lime',
+    'maroon',
+    'medium',
+    'none',
+    'navy',
+    'normal',
+    'nowrap',
+    'olive',
+    'pointer',
+    'purple',
+    'red',
+    'right',
+    'solid',
+    'silver',
+    'teal',
+    'top',
+    'transparent',
+    'underline',
+    'white',
+    'yellow',
+))
+
+allowed_svg_properties = frozenset((
+    'fill',
+    'fill-opacity',
+    'fill-rule',
+    'stroke',
+    'stroke-width',
+    'stroke-linecap',
+    'stroke-linejoin',
+    'stroke-opacity',
+))
+
+allowed_protocols = frozenset((
+    'ed2k',
+    'ftp',
+    'http',
+    'https',
+    'irc',
+    'mailto',
+    'news',
+    'gopher',
+    'nntp',
+    'telnet',
+    'webcal',
+    'xmpp',
+    'callto',
+    'feed',
+    'urn',
+    'aim',
+    'rsync',
+    'tag',
+    'ssh',
+    'sftp',
+    'rtsp',
+    'afs',
+    'data',
+))
+
+allowed_content_types = frozenset((
+    'image/png',
+    'image/jpeg',
+    'image/gif',
+    'image/webp',
+    'image/bmp',
+    'text/plain',
+))
+
+
+data_content_type = re.compile(r'''
+                                ^
+                                # Match a content type <application>/<type>
+                                (?P<content_type>[-a-zA-Z0-9.]+/[-a-zA-Z0-9.]+)
+                                # Match any character set and encoding
+                                (?:(?:;charset=(?:[-a-zA-Z0-9]+)(?:;(?:base64))?)
+                                  |(?:;(?:base64))?(?:;charset=(?:[-a-zA-Z0-9]+))?)
+                                # Assume the rest is data
+                                ,.*
+                                $
+                                ''',
+                               re.VERBOSE)
+
+
+class Filter(base.Filter):
+    """Sanitizes token stream of XHTML+MathML+SVG and of inline style attributes"""
+    def __init__(self,
+                 source,
+                 allowed_elements=allowed_elements,
+                 allowed_attributes=allowed_attributes,
+                 allowed_css_properties=allowed_css_properties,
+                 allowed_css_keywords=allowed_css_keywords,
+                 allowed_svg_properties=allowed_svg_properties,
+                 allowed_protocols=allowed_protocols,
+                 allowed_content_types=allowed_content_types,
+                 attr_val_is_uri=attr_val_is_uri,
+                 svg_attr_val_allows_ref=svg_attr_val_allows_ref,
+                 svg_allow_local_href=svg_allow_local_href):
+        """Creates a Filter
+
+        :arg allowed_elements: set of elements to allow--everything else will
+            be escaped
+
+        :arg allowed_attributes: set of attributes to allow in
+            elements--everything else will be stripped
+
+        :arg allowed_css_properties: set of CSS properties to allow--everything
+            else will be stripped
+
+        :arg allowed_css_keywords: set of CSS keywords to allow--everything
+            else will be stripped
+
+        :arg allowed_svg_properties: set of SVG properties to allow--everything
+            else will be removed
+
+        :arg allowed_protocols: set of allowed protocols for URIs
+
+        :arg allowed_content_types: set of allowed content types for ``data`` URIs.
+
+        :arg attr_val_is_uri: set of attributes that have URI values--values
+            that have a scheme not listed in ``allowed_protocols`` are removed
+
+        :arg svg_attr_val_allows_ref: set of SVG attributes that can have
+            references
+
+        :arg svg_allow_local_href: set of SVG elements that can have local
+            hrefs--these are removed
+
+        """
+        super(Filter, self).__init__(source)
+
+        warnings.warn(_deprecation_msg, DeprecationWarning)
+
+        self.allowed_elements = allowed_elements
+        self.allowed_attributes = allowed_attributes
+        self.allowed_css_properties = allowed_css_properties
+        self.allowed_css_keywords = allowed_css_keywords
+        self.allowed_svg_properties = allowed_svg_properties
+        self.allowed_protocols = allowed_protocols
+        self.allowed_content_types = allowed_content_types
+        self.attr_val_is_uri = attr_val_is_uri
+        self.svg_attr_val_allows_ref = svg_attr_val_allows_ref
+        self.svg_allow_local_href = svg_allow_local_href
+
+    def __iter__(self):
+        for token in base.Filter.__iter__(self):
+            token = self.sanitize_token(token)
+            if token:
+                yield token
+
+    # Sanitize the +html+, escaping all elements not in ALLOWED_ELEMENTS, and
+    # stripping out all attributes not in ALLOWED_ATTRIBUTES. Style attributes
+    # are parsed, and a restricted set, specified by ALLOWED_CSS_PROPERTIES and
+    # ALLOWED_CSS_KEYWORDS, are allowed through. attributes in ATTR_VAL_IS_URI
+    # are scanned, and only URI schemes specified in ALLOWED_PROTOCOLS are
+    # allowed.
+    #
+    #   sanitize_html('<script> do_nasty_stuff() </script>')
+    #    => &lt;script> do_nasty_stuff() &lt;/script>
+    #   sanitize_html('<a href="javascript: sucker();">Click here for $100</a>')
+    #    => <a>Click here for $100</a>
+    def sanitize_token(self, token):
+
+        # accommodate filters which use token_type differently
+        token_type = token["type"]
+        if token_type in ("StartTag", "EndTag", "EmptyTag"):
+            name = token["name"]
+            namespace = token["namespace"]
+            if ((namespace, name) in self.allowed_elements or
+                (namespace is None and
+                 (namespaces["html"], name) in self.allowed_elements)):
+                return self.allowed_token(token)
+            else:
+                return self.disallowed_token(token)
+        elif token_type == "Comment":
+            pass
+        else:
+            return token
+
+    def allowed_token(self, token):
+        if "data" in token:
+            attrs = token["data"]
+            attr_names = set(attrs.keys())
+
+            # Remove forbidden attributes
+            for to_remove in (attr_names - self.allowed_attributes):
+                del token["data"][to_remove]
+                attr_names.remove(to_remove)
+
+            # Remove attributes with disallowed URL values
+            for attr in (attr_names & self.attr_val_is_uri):
+                assert attr in attrs
+                # I don't have a clue where this regexp comes from or why it matches those
+                # characters, nor why we call unescape. I just know it's always been here.
+                # Should you be worried by this comment in a sanitizer? Yes. On the other hand, all
+                # this will do is remove *more* than it otherwise would.
+                val_unescaped = re.sub("[`\x00-\x20\x7f-\xa0\\s]+", '',
+                                       unescape(attrs[attr])).lower()
+                # remove replacement characters from unescaped characters
+                val_unescaped = val_unescaped.replace("\ufffd", "")
+                try:
+                    uri = urlparse.urlparse(val_unescaped)
+                except ValueError:
+                    uri = None
+                    del attrs[attr]
+                if uri and uri.scheme:
+                    if uri.scheme not in self.allowed_protocols:
+                        del attrs[attr]
+                    if uri.scheme == 'data':
+                        m = data_content_type.match(uri.path)
+                        if not m:
+                            del attrs[attr]
+                        elif m.group('content_type') not in self.allowed_content_types:
+                            del attrs[attr]
+
+            for attr in self.svg_attr_val_allows_ref:
+                if attr in attrs:
+                    attrs[attr] = re.sub(r'url\s*\(\s*[^#\s][^)]+?\)',
+                                         ' ',
+                                         unescape(attrs[attr]))
+            if (token["name"] in self.svg_allow_local_href and
+                (namespaces['xlink'], 'href') in attrs and re.search(r'^\s*[^#\s].*',
+                                                                     attrs[(namespaces['xlink'], 'href')])):
+                del attrs[(namespaces['xlink'], 'href')]
+            if (None, 'style') in attrs:
+                attrs[(None, 'style')] = self.sanitize_css(attrs[(None, 'style')])
+            token["data"] = attrs
+        return token
+
+    def disallowed_token(self, token):
+        token_type = token["type"]
+        if token_type == "EndTag":
+            token["data"] = "</%s>" % token["name"]
+        elif token["data"]:
+            assert token_type in ("StartTag", "EmptyTag")
+            attrs = []
+            for (ns, name), v in token["data"].items():
+                attrs.append(' %s="%s"' % (name if ns is None else "%s:%s" % (prefixes[ns], name), escape(v)))
+            token["data"] = "<%s%s>" % (token["name"], ''.join(attrs))
+        else:
+            token["data"] = "<%s>" % token["name"]
+        if token.get("selfClosing"):
+            token["data"] = token["data"][:-1] + "/>"
+
+        token["type"] = "Characters"
+
+        del token["name"]
+        return token
+
+    def sanitize_css(self, style):
+        # disallow urls
+        style = re.compile(r'url\s*\(\s*[^\s)]+?\s*\)\s*').sub(' ', style)
+
+        # gauntlet
+        if not re.match(r"""^([:,;#%.\sa-zA-Z0-9!]|\w-\w|'[\s\w]+'|"[\s\w]+"|\([\d,\s]+\))*$""", style):
+            return ''
+        if not re.match(r"^\s*([-\w]+\s*:[^:;]*(;\s*|$))*$", style):
+            return ''
+
+        clean = []
+        for prop, value in re.findall(r"([-\w]+)\s*:\s*([^:;]*)", style):
+            if not value:
+                continue
+            if prop.lower() in self.allowed_css_properties:
+                clean.append(prop + ': ' + value + ';')
+            elif prop.split('-')[0].lower() in ['background', 'border', 'margin',
+                                                'padding']:
+                for keyword in value.split():
+                    if keyword not in self.allowed_css_keywords and \
+                            not re.match(r"^(#[0-9a-fA-F]+|rgb\(\d+%?,\d*%?,?\d*%?\)?|\d{0,2}\.?\d{0,2}(cm|em|ex|in|mm|pc|pt|px|%|,|\))?)$", keyword):  # noqa
+                        break
+                else:
+                    clean.append(prop + ': ' + value + ';')
+            elif prop.lower() in self.allowed_svg_properties:
+                clean.append(prop + ': ' + value + ';')
+
+        return ' '.join(clean)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/whitespace.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/whitespace.py
new file mode 100644
index 0000000..0d12584
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/filters/whitespace.py
@@ -0,0 +1,38 @@
+from __future__ import absolute_import, division, unicode_literals
+
+import re
+
+from . import base
+from ..constants import rcdataElements, spaceCharacters
+spaceCharacters = "".join(spaceCharacters)
+
+SPACES_REGEX = re.compile("[%s]+" % spaceCharacters)
+
+
+class Filter(base.Filter):
+    """Collapses whitespace except in pre, textarea, and script elements"""
+    spacePreserveElements = frozenset(["pre", "textarea"] + list(rcdataElements))
+
+    def __iter__(self):
+        preserve = 0
+        for token in base.Filter.__iter__(self):
+            type = token["type"]
+            if type == "StartTag" \
+                    and (preserve or token["name"] in self.spacePreserveElements):
+                preserve += 1
+
+            elif type == "EndTag" and preserve:
+                preserve -= 1
+
+            elif not preserve and type == "SpaceCharacters" and token["data"]:
+                # Test on token["data"] above to not introduce spaces where there were not
+                token["data"] = " "
+
+            elif not preserve and type == "Characters":
+                token["data"] = collapse_spaces(token["data"])
+
+            yield token
+
+
+def collapse_spaces(text):
+    return SPACES_REGEX.sub(' ', text)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/html5parser.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/html5parser.py
new file mode 100644
index 0000000..d06784f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/html5parser.py
@@ -0,0 +1,2795 @@
+from __future__ import absolute_import, division, unicode_literals
+from pip._vendor.six import with_metaclass, viewkeys
+
+import types
+
+from . import _inputstream
+from . import _tokenizer
+
+from . import treebuilders
+from .treebuilders.base import Marker
+
+from . import _utils
+from .constants import (
+    spaceCharacters, asciiUpper2Lower,
+    specialElements, headingElements, cdataElements, rcdataElements,
+    tokenTypes, tagTokenTypes,
+    namespaces,
+    htmlIntegrationPointElements, mathmlTextIntegrationPointElements,
+    adjustForeignAttributes as adjustForeignAttributesMap,
+    adjustMathMLAttributes, adjustSVGAttributes,
+    E,
+    _ReparseException
+)
+
+
+def parse(doc, treebuilder="etree", namespaceHTMLElements=True, **kwargs):
+    """Parse an HTML document as a string or file-like object into a tree
+
+    :arg doc: the document to parse as a string or file-like object
+
+    :arg treebuilder: the treebuilder to use when parsing
+
+    :arg namespaceHTMLElements: whether or not to namespace HTML elements
+
+    :returns: parsed tree
+
+    Example:
+
+    >>> from html5lib.html5parser import parse
+    >>> parse('<html><body><p>This is a doc</p></body></html>')
+    <Element u'{http://www.w3.org/1999/xhtml}html' at 0x7feac4909db0>
+
+    """
+    tb = treebuilders.getTreeBuilder(treebuilder)
+    p = HTMLParser(tb, namespaceHTMLElements=namespaceHTMLElements)
+    return p.parse(doc, **kwargs)
+
+
+def parseFragment(doc, container="div", treebuilder="etree", namespaceHTMLElements=True, **kwargs):
+    """Parse an HTML fragment as a string or file-like object into a tree
+
+    :arg doc: the fragment to parse as a string or file-like object
+
+    :arg container: the container context to parse the fragment in
+
+    :arg treebuilder: the treebuilder to use when parsing
+
+    :arg namespaceHTMLElements: whether or not to namespace HTML elements
+
+    :returns: parsed tree
+
+    Example:
+
+    >>> from html5lib.html5libparser import parseFragment
+    >>> parseFragment('<b>this is a fragment</b>')
+    <Element u'DOCUMENT_FRAGMENT' at 0x7feac484b090>
+
+    """
+    tb = treebuilders.getTreeBuilder(treebuilder)
+    p = HTMLParser(tb, namespaceHTMLElements=namespaceHTMLElements)
+    return p.parseFragment(doc, container=container, **kwargs)
+
+
+def method_decorator_metaclass(function):
+    class Decorated(type):
+        def __new__(meta, classname, bases, classDict):
+            for attributeName, attribute in classDict.items():
+                if isinstance(attribute, types.FunctionType):
+                    attribute = function(attribute)
+
+                classDict[attributeName] = attribute
+            return type.__new__(meta, classname, bases, classDict)
+    return Decorated
+
+
+class HTMLParser(object):
+    """HTML parser
+
+    Generates a tree structure from a stream of (possibly malformed) HTML.
+
+    """
+
+    def __init__(self, tree=None, strict=False, namespaceHTMLElements=True, debug=False):
+        """
+        :arg tree: a treebuilder class controlling the type of tree that will be
+            returned. Built in treebuilders can be accessed through
+            html5lib.treebuilders.getTreeBuilder(treeType)
+
+        :arg strict: raise an exception when a parse error is encountered
+
+        :arg namespaceHTMLElements: whether or not to namespace HTML elements
+
+        :arg debug: whether or not to enable debug mode which logs things
+
+        Example:
+
+        >>> from html5lib.html5parser import HTMLParser
+        >>> parser = HTMLParser()                     # generates parser with etree builder
+        >>> parser = HTMLParser('lxml', strict=True)  # generates parser with lxml builder which is strict
+
+        """
+
+        # Raise an exception on the first error encountered
+        self.strict = strict
+
+        if tree is None:
+            tree = treebuilders.getTreeBuilder("etree")
+        self.tree = tree(namespaceHTMLElements)
+        self.errors = []
+
+        self.phases = {name: cls(self, self.tree) for name, cls in
+                       getPhases(debug).items()}
+
+    def _parse(self, stream, innerHTML=False, container="div", scripting=False, **kwargs):
+
+        self.innerHTMLMode = innerHTML
+        self.container = container
+        self.scripting = scripting
+        self.tokenizer = _tokenizer.HTMLTokenizer(stream, parser=self, **kwargs)
+        self.reset()
+
+        try:
+            self.mainLoop()
+        except _ReparseException:
+            self.reset()
+            self.mainLoop()
+
+    def reset(self):
+        self.tree.reset()
+        self.firstStartTag = False
+        self.errors = []
+        self.log = []  # only used with debug mode
+        # "quirks" / "limited quirks" / "no quirks"
+        self.compatMode = "no quirks"
+
+        if self.innerHTMLMode:
+            self.innerHTML = self.container.lower()
+
+            if self.innerHTML in cdataElements:
+                self.tokenizer.state = self.tokenizer.rcdataState
+            elif self.innerHTML in rcdataElements:
+                self.tokenizer.state = self.tokenizer.rawtextState
+            elif self.innerHTML == 'plaintext':
+                self.tokenizer.state = self.tokenizer.plaintextState
+            else:
+                # state already is data state
+                # self.tokenizer.state = self.tokenizer.dataState
+                pass
+            self.phase = self.phases["beforeHtml"]
+            self.phase.insertHtmlElement()
+            self.resetInsertionMode()
+        else:
+            self.innerHTML = False  # pylint:disable=redefined-variable-type
+            self.phase = self.phases["initial"]
+
+        self.lastPhase = None
+
+        self.beforeRCDataPhase = None
+
+        self.framesetOK = True
+
+    @property
+    def documentEncoding(self):
+        """Name of the character encoding that was used to decode the input stream, or
+        :obj:`None` if that is not determined yet
+
+        """
+        if not hasattr(self, 'tokenizer'):
+            return None
+        return self.tokenizer.stream.charEncoding[0].name
+
+    def isHTMLIntegrationPoint(self, element):
+        if (element.name == "annotation-xml" and
+                element.namespace == namespaces["mathml"]):
+            return ("encoding" in element.attributes and
+                    element.attributes["encoding"].translate(
+                        asciiUpper2Lower) in
+                    ("text/html", "application/xhtml+xml"))
+        else:
+            return (element.namespace, element.name) in htmlIntegrationPointElements
+
+    def isMathMLTextIntegrationPoint(self, element):
+        return (element.namespace, element.name) in mathmlTextIntegrationPointElements
+
+    def mainLoop(self):
+        CharactersToken = tokenTypes["Characters"]
+        SpaceCharactersToken = tokenTypes["SpaceCharacters"]
+        StartTagToken = tokenTypes["StartTag"]
+        EndTagToken = tokenTypes["EndTag"]
+        CommentToken = tokenTypes["Comment"]
+        DoctypeToken = tokenTypes["Doctype"]
+        ParseErrorToken = tokenTypes["ParseError"]
+
+        for token in self.tokenizer:
+            prev_token = None
+            new_token = token
+            while new_token is not None:
+                prev_token = new_token
+                currentNode = self.tree.openElements[-1] if self.tree.openElements else None
+                currentNodeNamespace = currentNode.namespace if currentNode else None
+                currentNodeName = currentNode.name if currentNode else None
+
+                type = new_token["type"]
+
+                if type == ParseErrorToken:
+                    self.parseError(new_token["data"], new_token.get("datavars", {}))
+                    new_token = None
+                else:
+                    if (len(self.tree.openElements) == 0 or
+                        currentNodeNamespace == self.tree.defaultNamespace or
+                        (self.isMathMLTextIntegrationPoint(currentNode) and
+                         ((type == StartTagToken and
+                           token["name"] not in frozenset(["mglyph", "malignmark"])) or
+                          type in (CharactersToken, SpaceCharactersToken))) or
+                        (currentNodeNamespace == namespaces["mathml"] and
+                         currentNodeName == "annotation-xml" and
+                         type == StartTagToken and
+                         token["name"] == "svg") or
+                        (self.isHTMLIntegrationPoint(currentNode) and
+                         type in (StartTagToken, CharactersToken, SpaceCharactersToken))):
+                        phase = self.phase
+                    else:
+                        phase = self.phases["inForeignContent"]
+
+                    if type == CharactersToken:
+                        new_token = phase.processCharacters(new_token)
+                    elif type == SpaceCharactersToken:
+                        new_token = phase.processSpaceCharacters(new_token)
+                    elif type == StartTagToken:
+                        new_token = phase.processStartTag(new_token)
+                    elif type == EndTagToken:
+                        new_token = phase.processEndTag(new_token)
+                    elif type == CommentToken:
+                        new_token = phase.processComment(new_token)
+                    elif type == DoctypeToken:
+                        new_token = phase.processDoctype(new_token)
+
+            if (type == StartTagToken and prev_token["selfClosing"] and
+                    not prev_token["selfClosingAcknowledged"]):
+                self.parseError("non-void-element-with-trailing-solidus",
+                                {"name": prev_token["name"]})
+
+        # When the loop finishes it's EOF
+        reprocess = True
+        phases = []
+        while reprocess:
+            phases.append(self.phase)
+            reprocess = self.phase.processEOF()
+            if reprocess:
+                assert self.phase not in phases
+
+    def parse(self, stream, *args, **kwargs):
+        """Parse a HTML document into a well-formed tree
+
+        :arg stream: a file-like object or string containing the HTML to be parsed
+
+            The optional encoding parameter must be a string that indicates
+            the encoding.  If specified, that encoding will be used,
+            regardless of any BOM or later declaration (such as in a meta
+            element).
+
+        :arg scripting: treat noscript elements as if JavaScript was turned on
+
+        :returns: parsed tree
+
+        Example:
+
+        >>> from html5lib.html5parser import HTMLParser
+        >>> parser = HTMLParser()
+        >>> parser.parse('<html><body><p>This is a doc</p></body></html>')
+        <Element u'{http://www.w3.org/1999/xhtml}html' at 0x7feac4909db0>
+
+        """
+        self._parse(stream, False, None, *args, **kwargs)
+        return self.tree.getDocument()
+
+    def parseFragment(self, stream, *args, **kwargs):
+        """Parse a HTML fragment into a well-formed tree fragment
+
+        :arg container: name of the element we're setting the innerHTML
+            property if set to None, default to 'div'
+
+        :arg stream: a file-like object or string containing the HTML to be parsed
+
+            The optional encoding parameter must be a string that indicates
+            the encoding.  If specified, that encoding will be used,
+            regardless of any BOM or later declaration (such as in a meta
+            element)
+
+        :arg scripting: treat noscript elements as if JavaScript was turned on
+
+        :returns: parsed tree
+
+        Example:
+
+        >>> from html5lib.html5libparser import HTMLParser
+        >>> parser = HTMLParser()
+        >>> parser.parseFragment('<b>this is a fragment</b>')
+        <Element u'DOCUMENT_FRAGMENT' at 0x7feac484b090>
+
+        """
+        self._parse(stream, True, *args, **kwargs)
+        return self.tree.getFragment()
+
+    def parseError(self, errorcode="XXX-undefined-error", datavars=None):
+        # XXX The idea is to make errorcode mandatory.
+        if datavars is None:
+            datavars = {}
+        self.errors.append((self.tokenizer.stream.position(), errorcode, datavars))
+        if self.strict:
+            raise ParseError(E[errorcode] % datavars)
+
+    def adjustMathMLAttributes(self, token):
+        adjust_attributes(token, adjustMathMLAttributes)
+
+    def adjustSVGAttributes(self, token):
+        adjust_attributes(token, adjustSVGAttributes)
+
+    def adjustForeignAttributes(self, token):
+        adjust_attributes(token, adjustForeignAttributesMap)
+
+    def reparseTokenNormal(self, token):
+        # pylint:disable=unused-argument
+        self.parser.phase()
+
+    def resetInsertionMode(self):
+        # The name of this method is mostly historical. (It's also used in the
+        # specification.)
+        last = False
+        newModes = {
+            "select": "inSelect",
+            "td": "inCell",
+            "th": "inCell",
+            "tr": "inRow",
+            "tbody": "inTableBody",
+            "thead": "inTableBody",
+            "tfoot": "inTableBody",
+            "caption": "inCaption",
+            "colgroup": "inColumnGroup",
+            "table": "inTable",
+            "head": "inBody",
+            "body": "inBody",
+            "frameset": "inFrameset",
+            "html": "beforeHead"
+        }
+        for node in self.tree.openElements[::-1]:
+            nodeName = node.name
+            new_phase = None
+            if node == self.tree.openElements[0]:
+                assert self.innerHTML
+                last = True
+                nodeName = self.innerHTML
+            # Check for conditions that should only happen in the innerHTML
+            # case
+            if nodeName in ("select", "colgroup", "head", "html"):
+                assert self.innerHTML
+
+            if not last and node.namespace != self.tree.defaultNamespace:
+                continue
+
+            if nodeName in newModes:
+                new_phase = self.phases[newModes[nodeName]]
+                break
+            elif last:
+                new_phase = self.phases["inBody"]
+                break
+
+        self.phase = new_phase
+
+    def parseRCDataRawtext(self, token, contentType):
+        # Generic RCDATA/RAWTEXT Parsing algorithm
+        assert contentType in ("RAWTEXT", "RCDATA")
+
+        self.tree.insertElement(token)
+
+        if contentType == "RAWTEXT":
+            self.tokenizer.state = self.tokenizer.rawtextState
+        else:
+            self.tokenizer.state = self.tokenizer.rcdataState
+
+        self.originalPhase = self.phase
+
+        self.phase = self.phases["text"]
+
+
+@_utils.memoize
+def getPhases(debug):
+    def log(function):
+        """Logger that records which phase processes each token"""
+        type_names = {value: key for key, value in tokenTypes.items()}
+
+        def wrapped(self, *args, **kwargs):
+            if function.__name__.startswith("process") and len(args) > 0:
+                token = args[0]
+                info = {"type": type_names[token['type']]}
+                if token['type'] in tagTokenTypes:
+                    info["name"] = token['name']
+
+                self.parser.log.append((self.parser.tokenizer.state.__name__,
+                                        self.parser.phase.__class__.__name__,
+                                        self.__class__.__name__,
+                                        function.__name__,
+                                        info))
+                return function(self, *args, **kwargs)
+            else:
+                return function(self, *args, **kwargs)
+        return wrapped
+
+    def getMetaclass(use_metaclass, metaclass_func):
+        if use_metaclass:
+            return method_decorator_metaclass(metaclass_func)
+        else:
+            return type
+
+    # pylint:disable=unused-argument
+    class Phase(with_metaclass(getMetaclass(debug, log))):
+        """Base class for helper object that implements each phase of processing
+        """
+        __slots__ = ("parser", "tree", "__startTagCache", "__endTagCache")
+
+        def __init__(self, parser, tree):
+            self.parser = parser
+            self.tree = tree
+            self.__startTagCache = {}
+            self.__endTagCache = {}
+
+        def processEOF(self):
+            raise NotImplementedError
+
+        def processComment(self, token):
+            # For most phases the following is correct. Where it's not it will be
+            # overridden.
+            self.tree.insertComment(token, self.tree.openElements[-1])
+
+        def processDoctype(self, token):
+            self.parser.parseError("unexpected-doctype")
+
+        def processCharacters(self, token):
+            self.tree.insertText(token["data"])
+
+        def processSpaceCharacters(self, token):
+            self.tree.insertText(token["data"])
+
+        def processStartTag(self, token):
+            # Note the caching is done here rather than BoundMethodDispatcher as doing it there
+            # requires a circular reference to the Phase, and this ends up with a significant
+            # (CPython 2.7, 3.8) GC cost when parsing many short inputs
+            name = token["name"]
+            # In Py2, using `in` is quicker in general than try/except KeyError
+            # In Py3, `in` is quicker when there are few cache hits (typically short inputs)
+            if name in self.__startTagCache:
+                func = self.__startTagCache[name]
+            else:
+                func = self.__startTagCache[name] = self.startTagHandler[name]
+                # bound the cache size in case we get loads of unknown tags
+                while len(self.__startTagCache) > len(self.startTagHandler) * 1.1:
+                    # this makes the eviction policy random on Py < 3.7 and FIFO >= 3.7
+                    self.__startTagCache.pop(next(iter(self.__startTagCache)))
+            return func(token)
+
+        def startTagHtml(self, token):
+            if not self.parser.firstStartTag and token["name"] == "html":
+                self.parser.parseError("non-html-root")
+            # XXX Need a check here to see if the first start tag token emitted is
+            # this token... If it's not, invoke self.parser.parseError().
+            for attr, value in token["data"].items():
+                if attr not in self.tree.openElements[0].attributes:
+                    self.tree.openElements[0].attributes[attr] = value
+            self.parser.firstStartTag = False
+
+        def processEndTag(self, token):
+            # Note the caching is done here rather than BoundMethodDispatcher as doing it there
+            # requires a circular reference to the Phase, and this ends up with a significant
+            # (CPython 2.7, 3.8) GC cost when parsing many short inputs
+            name = token["name"]
+            # In Py2, using `in` is quicker in general than try/except KeyError
+            # In Py3, `in` is quicker when there are few cache hits (typically short inputs)
+            if name in self.__endTagCache:
+                func = self.__endTagCache[name]
+            else:
+                func = self.__endTagCache[name] = self.endTagHandler[name]
+                # bound the cache size in case we get loads of unknown tags
+                while len(self.__endTagCache) > len(self.endTagHandler) * 1.1:
+                    # this makes the eviction policy random on Py < 3.7 and FIFO >= 3.7
+                    self.__endTagCache.pop(next(iter(self.__endTagCache)))
+            return func(token)
+
+    class InitialPhase(Phase):
+        __slots__ = tuple()
+
+        def processSpaceCharacters(self, token):
+            pass
+
+        def processComment(self, token):
+            self.tree.insertComment(token, self.tree.document)
+
+        def processDoctype(self, token):
+            name = token["name"]
+            publicId = token["publicId"]
+            systemId = token["systemId"]
+            correct = token["correct"]
+
+            if (name != "html" or publicId is not None or
+                    systemId is not None and systemId != "about:legacy-compat"):
+                self.parser.parseError("unknown-doctype")
+
+            if publicId is None:
+                publicId = ""
+
+            self.tree.insertDoctype(token)
+
+            if publicId != "":
+                publicId = publicId.translate(asciiUpper2Lower)
+
+            if (not correct or token["name"] != "html" or
+                    publicId.startswith(
+                        ("+//silmaril//dtd html pro v0r11 19970101//",
+                         "-//advasoft ltd//dtd html 3.0 aswedit + extensions//",
+                         "-//as//dtd html 3.0 aswedit + extensions//",
+                         "-//ietf//dtd html 2.0 level 1//",
+                         "-//ietf//dtd html 2.0 level 2//",
+                         "-//ietf//dtd html 2.0 strict level 1//",
+                         "-//ietf//dtd html 2.0 strict level 2//",
+                         "-//ietf//dtd html 2.0 strict//",
+                         "-//ietf//dtd html 2.0//",
+                         "-//ietf//dtd html 2.1e//",
+                         "-//ietf//dtd html 3.0//",
+                         "-//ietf//dtd html 3.2 final//",
+                         "-//ietf//dtd html 3.2//",
+                         "-//ietf//dtd html 3//",
+                         "-//ietf//dtd html level 0//",
+                         "-//ietf//dtd html level 1//",
+                         "-//ietf//dtd html level 2//",
+                         "-//ietf//dtd html level 3//",
+                         "-//ietf//dtd html strict level 0//",
+                         "-//ietf//dtd html strict level 1//",
+                         "-//ietf//dtd html strict level 2//",
+                         "-//ietf//dtd html strict level 3//",
+                         "-//ietf//dtd html strict//",
+                         "-//ietf//dtd html//",
+                         "-//metrius//dtd metrius presentational//",
+                         "-//microsoft//dtd internet explorer 2.0 html strict//",
+                         "-//microsoft//dtd internet explorer 2.0 html//",
+                         "-//microsoft//dtd internet explorer 2.0 tables//",
+                         "-//microsoft//dtd internet explorer 3.0 html strict//",
+                         "-//microsoft//dtd internet explorer 3.0 html//",
+                         "-//microsoft//dtd internet explorer 3.0 tables//",
+                         "-//netscape comm. corp.//dtd html//",
+                         "-//netscape comm. corp.//dtd strict html//",
+                         "-//o'reilly and associates//dtd html 2.0//",
+                         "-//o'reilly and associates//dtd html extended 1.0//",
+                         "-//o'reilly and associates//dtd html extended relaxed 1.0//",
+                         "-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html 4.0//",
+                         "-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//",
+                         "-//spyglass//dtd html 2.0 extended//",
+                         "-//sq//dtd html 2.0 hotmetal + extensions//",
+                         "-//sun microsystems corp.//dtd hotjava html//",
+                         "-//sun microsystems corp.//dtd hotjava strict html//",
+                         "-//w3c//dtd html 3 1995-03-24//",
+                         "-//w3c//dtd html 3.2 draft//",
+                         "-//w3c//dtd html 3.2 final//",
+                         "-//w3c//dtd html 3.2//",
+                         "-//w3c//dtd html 3.2s draft//",
+                         "-//w3c//dtd html 4.0 frameset//",
+                         "-//w3c//dtd html 4.0 transitional//",
+                         "-//w3c//dtd html experimental 19960712//",
+                         "-//w3c//dtd html experimental 970421//",
+                         "-//w3c//dtd w3 html//",
+                         "-//w3o//dtd w3 html 3.0//",
+                         "-//webtechs//dtd mozilla html 2.0//",
+                         "-//webtechs//dtd mozilla html//")) or
+                    publicId in ("-//w3o//dtd w3 html strict 3.0//en//",
+                                 "-/w3c/dtd html 4.0 transitional/en",
+                                 "html") or
+                    publicId.startswith(
+                        ("-//w3c//dtd html 4.01 frameset//",
+                         "-//w3c//dtd html 4.01 transitional//")) and
+                    systemId is None or
+                    systemId and systemId.lower() == "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd"):
+                self.parser.compatMode = "quirks"
+            elif (publicId.startswith(
+                    ("-//w3c//dtd xhtml 1.0 frameset//",
+                     "-//w3c//dtd xhtml 1.0 transitional//")) or
+                  publicId.startswith(
+                      ("-//w3c//dtd html 4.01 frameset//",
+                       "-//w3c//dtd html 4.01 transitional//")) and
+                  systemId is not None):
+                self.parser.compatMode = "limited quirks"
+
+            self.parser.phase = self.parser.phases["beforeHtml"]
+
+        def anythingElse(self):
+            self.parser.compatMode = "quirks"
+            self.parser.phase = self.parser.phases["beforeHtml"]
+
+        def processCharacters(self, token):
+            self.parser.parseError("expected-doctype-but-got-chars")
+            self.anythingElse()
+            return token
+
+        def processStartTag(self, token):
+            self.parser.parseError("expected-doctype-but-got-start-tag",
+                                   {"name": token["name"]})
+            self.anythingElse()
+            return token
+
+        def processEndTag(self, token):
+            self.parser.parseError("expected-doctype-but-got-end-tag",
+                                   {"name": token["name"]})
+            self.anythingElse()
+            return token
+
+        def processEOF(self):
+            self.parser.parseError("expected-doctype-but-got-eof")
+            self.anythingElse()
+            return True
+
+    class BeforeHtmlPhase(Phase):
+        __slots__ = tuple()
+
+        # helper methods
+        def insertHtmlElement(self):
+            self.tree.insertRoot(impliedTagToken("html", "StartTag"))
+            self.parser.phase = self.parser.phases["beforeHead"]
+
+        # other
+        def processEOF(self):
+            self.insertHtmlElement()
+            return True
+
+        def processComment(self, token):
+            self.tree.insertComment(token, self.tree.document)
+
+        def processSpaceCharacters(self, token):
+            pass
+
+        def processCharacters(self, token):
+            self.insertHtmlElement()
+            return token
+
+        def processStartTag(self, token):
+            if token["name"] == "html":
+                self.parser.firstStartTag = True
+            self.insertHtmlElement()
+            return token
+
+        def processEndTag(self, token):
+            if token["name"] not in ("head", "body", "html", "br"):
+                self.parser.parseError("unexpected-end-tag-before-html",
+                                       {"name": token["name"]})
+            else:
+                self.insertHtmlElement()
+                return token
+
+    class BeforeHeadPhase(Phase):
+        __slots__ = tuple()
+
+        def processEOF(self):
+            self.startTagHead(impliedTagToken("head", "StartTag"))
+            return True
+
+        def processSpaceCharacters(self, token):
+            pass
+
+        def processCharacters(self, token):
+            self.startTagHead(impliedTagToken("head", "StartTag"))
+            return token
+
+        def startTagHtml(self, token):
+            return self.parser.phases["inBody"].processStartTag(token)
+
+        def startTagHead(self, token):
+            self.tree.insertElement(token)
+            self.tree.headPointer = self.tree.openElements[-1]
+            self.parser.phase = self.parser.phases["inHead"]
+
+        def startTagOther(self, token):
+            self.startTagHead(impliedTagToken("head", "StartTag"))
+            return token
+
+        def endTagImplyHead(self, token):
+            self.startTagHead(impliedTagToken("head", "StartTag"))
+            return token
+
+        def endTagOther(self, token):
+            self.parser.parseError("end-tag-after-implied-root",
+                                   {"name": token["name"]})
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", startTagHtml),
+            ("head", startTagHead)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            (("head", "body", "html", "br"), endTagImplyHead)
+        ])
+        endTagHandler.default = endTagOther
+
+    class InHeadPhase(Phase):
+        __slots__ = tuple()
+
+        # the real thing
+        def processEOF(self):
+            self.anythingElse()
+            return True
+
+        def processCharacters(self, token):
+            self.anythingElse()
+            return token
+
+        def startTagHtml(self, token):
+            return self.parser.phases["inBody"].processStartTag(token)
+
+        def startTagHead(self, token):
+            self.parser.parseError("two-heads-are-not-better-than-one")
+
+        def startTagBaseLinkCommand(self, token):
+            self.tree.insertElement(token)
+            self.tree.openElements.pop()
+            token["selfClosingAcknowledged"] = True
+
+        def startTagMeta(self, token):
+            self.tree.insertElement(token)
+            self.tree.openElements.pop()
+            token["selfClosingAcknowledged"] = True
+
+            attributes = token["data"]
+            if self.parser.tokenizer.stream.charEncoding[1] == "tentative":
+                if "charset" in attributes:
+                    self.parser.tokenizer.stream.changeEncoding(attributes["charset"])
+                elif ("content" in attributes and
+                      "http-equiv" in attributes and
+                      attributes["http-equiv"].lower() == "content-type"):
+                    # Encoding it as UTF-8 here is a hack, as really we should pass
+                    # the abstract Unicode string, and just use the
+                    # ContentAttrParser on that, but using UTF-8 allows all chars
+                    # to be encoded and as a ASCII-superset works.
+                    data = _inputstream.EncodingBytes(attributes["content"].encode("utf-8"))
+                    parser = _inputstream.ContentAttrParser(data)
+                    codec = parser.parse()
+                    self.parser.tokenizer.stream.changeEncoding(codec)
+
+        def startTagTitle(self, token):
+            self.parser.parseRCDataRawtext(token, "RCDATA")
+
+        def startTagNoFramesStyle(self, token):
+            # Need to decide whether to implement the scripting-disabled case
+            self.parser.parseRCDataRawtext(token, "RAWTEXT")
+
+        def startTagNoscript(self, token):
+            if self.parser.scripting:
+                self.parser.parseRCDataRawtext(token, "RAWTEXT")
+            else:
+                self.tree.insertElement(token)
+                self.parser.phase = self.parser.phases["inHeadNoscript"]
+
+        def startTagScript(self, token):
+            self.tree.insertElement(token)
+            self.parser.tokenizer.state = self.parser.tokenizer.scriptDataState
+            self.parser.originalPhase = self.parser.phase
+            self.parser.phase = self.parser.phases["text"]
+
+        def startTagOther(self, token):
+            self.anythingElse()
+            return token
+
+        def endTagHead(self, token):
+            node = self.parser.tree.openElements.pop()
+            assert node.name == "head", "Expected head got %s" % node.name
+            self.parser.phase = self.parser.phases["afterHead"]
+
+        def endTagHtmlBodyBr(self, token):
+            self.anythingElse()
+            return token
+
+        def endTagOther(self, token):
+            self.parser.parseError("unexpected-end-tag", {"name": token["name"]})
+
+        def anythingElse(self):
+            self.endTagHead(impliedTagToken("head"))
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", startTagHtml),
+            ("title", startTagTitle),
+            (("noframes", "style"), startTagNoFramesStyle),
+            ("noscript", startTagNoscript),
+            ("script", startTagScript),
+            (("base", "basefont", "bgsound", "command", "link"),
+             startTagBaseLinkCommand),
+            ("meta", startTagMeta),
+            ("head", startTagHead)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            ("head", endTagHead),
+            (("br", "html", "body"), endTagHtmlBodyBr)
+        ])
+        endTagHandler.default = endTagOther
+
+    class InHeadNoscriptPhase(Phase):
+        __slots__ = tuple()
+
+        def processEOF(self):
+            self.parser.parseError("eof-in-head-noscript")
+            self.anythingElse()
+            return True
+
+        def processComment(self, token):
+            return self.parser.phases["inHead"].processComment(token)
+
+        def processCharacters(self, token):
+            self.parser.parseError("char-in-head-noscript")
+            self.anythingElse()
+            return token
+
+        def processSpaceCharacters(self, token):
+            return self.parser.phases["inHead"].processSpaceCharacters(token)
+
+        def startTagHtml(self, token):
+            return self.parser.phases["inBody"].processStartTag(token)
+
+        def startTagBaseLinkCommand(self, token):
+            return self.parser.phases["inHead"].processStartTag(token)
+
+        def startTagHeadNoscript(self, token):
+            self.parser.parseError("unexpected-start-tag", {"name": token["name"]})
+
+        def startTagOther(self, token):
+            self.parser.parseError("unexpected-inhead-noscript-tag", {"name": token["name"]})
+            self.anythingElse()
+            return token
+
+        def endTagNoscript(self, token):
+            node = self.parser.tree.openElements.pop()
+            assert node.name == "noscript", "Expected noscript got %s" % node.name
+            self.parser.phase = self.parser.phases["inHead"]
+
+        def endTagBr(self, token):
+            self.parser.parseError("unexpected-inhead-noscript-tag", {"name": token["name"]})
+            self.anythingElse()
+            return token
+
+        def endTagOther(self, token):
+            self.parser.parseError("unexpected-end-tag", {"name": token["name"]})
+
+        def anythingElse(self):
+            # Caller must raise parse error first!
+            self.endTagNoscript(impliedTagToken("noscript"))
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", startTagHtml),
+            (("basefont", "bgsound", "link", "meta", "noframes", "style"), startTagBaseLinkCommand),
+            (("head", "noscript"), startTagHeadNoscript),
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            ("noscript", endTagNoscript),
+            ("br", endTagBr),
+        ])
+        endTagHandler.default = endTagOther
+
+    class AfterHeadPhase(Phase):
+        __slots__ = tuple()
+
+        def processEOF(self):
+            self.anythingElse()
+            return True
+
+        def processCharacters(self, token):
+            self.anythingElse()
+            return token
+
+        def startTagHtml(self, token):
+            return self.parser.phases["inBody"].processStartTag(token)
+
+        def startTagBody(self, token):
+            self.parser.framesetOK = False
+            self.tree.insertElement(token)
+            self.parser.phase = self.parser.phases["inBody"]
+
+        def startTagFrameset(self, token):
+            self.tree.insertElement(token)
+            self.parser.phase = self.parser.phases["inFrameset"]
+
+        def startTagFromHead(self, token):
+            self.parser.parseError("unexpected-start-tag-out-of-my-head",
+                                   {"name": token["name"]})
+            self.tree.openElements.append(self.tree.headPointer)
+            self.parser.phases["inHead"].processStartTag(token)
+            for node in self.tree.openElements[::-1]:
+                if node.name == "head":
+                    self.tree.openElements.remove(node)
+                    break
+
+        def startTagHead(self, token):
+            self.parser.parseError("unexpected-start-tag", {"name": token["name"]})
+
+        def startTagOther(self, token):
+            self.anythingElse()
+            return token
+
+        def endTagHtmlBodyBr(self, token):
+            self.anythingElse()
+            return token
+
+        def endTagOther(self, token):
+            self.parser.parseError("unexpected-end-tag", {"name": token["name"]})
+
+        def anythingElse(self):
+            self.tree.insertElement(impliedTagToken("body", "StartTag"))
+            self.parser.phase = self.parser.phases["inBody"]
+            self.parser.framesetOK = True
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", startTagHtml),
+            ("body", startTagBody),
+            ("frameset", startTagFrameset),
+            (("base", "basefont", "bgsound", "link", "meta", "noframes", "script",
+              "style", "title"),
+             startTagFromHead),
+            ("head", startTagHead)
+        ])
+        startTagHandler.default = startTagOther
+        endTagHandler = _utils.MethodDispatcher([(("body", "html", "br"),
+                                                  endTagHtmlBodyBr)])
+        endTagHandler.default = endTagOther
+
+    class InBodyPhase(Phase):
+        # http://www.whatwg.org/specs/web-apps/current-work/#parsing-main-inbody
+        # the really-really-really-very crazy mode
+        __slots__ = ("processSpaceCharacters",)
+
+        def __init__(self, *args, **kwargs):
+            super(InBodyPhase, self).__init__(*args, **kwargs)
+            # Set this to the default handler
+            self.processSpaceCharacters = self.processSpaceCharactersNonPre
+
+        def isMatchingFormattingElement(self, node1, node2):
+            return (node1.name == node2.name and
+                    node1.namespace == node2.namespace and
+                    node1.attributes == node2.attributes)
+
+        # helper
+        def addFormattingElement(self, token):
+            self.tree.insertElement(token)
+            element = self.tree.openElements[-1]
+
+            matchingElements = []
+            for node in self.tree.activeFormattingElements[::-1]:
+                if node is Marker:
+                    break
+                elif self.isMatchingFormattingElement(node, element):
+                    matchingElements.append(node)
+
+            assert len(matchingElements) <= 3
+            if len(matchingElements) == 3:
+                self.tree.activeFormattingElements.remove(matchingElements[-1])
+            self.tree.activeFormattingElements.append(element)
+
+        # the real deal
+        def processEOF(self):
+            allowed_elements = frozenset(("dd", "dt", "li", "p", "tbody", "td",
+                                          "tfoot", "th", "thead", "tr", "body",
+                                          "html"))
+            for node in self.tree.openElements[::-1]:
+                if node.name not in allowed_elements:
+                    self.parser.parseError("expected-closing-tag-but-got-eof")
+                    break
+            # Stop parsing
+
+        def processSpaceCharactersDropNewline(self, token):
+            # Sometimes (start of <pre>, <listing>, and <textarea> blocks) we
+            # want to drop leading newlines
+            data = token["data"]
+            self.processSpaceCharacters = self.processSpaceCharactersNonPre
+            if (data.startswith("\n") and
+                self.tree.openElements[-1].name in ("pre", "listing", "textarea") and
+                    not self.tree.openElements[-1].hasContent()):
+                data = data[1:]
+            if data:
+                self.tree.reconstructActiveFormattingElements()
+                self.tree.insertText(data)
+
+        def processCharacters(self, token):
+            if token["data"] == "\u0000":
+                # The tokenizer should always emit null on its own
+                return
+            self.tree.reconstructActiveFormattingElements()
+            self.tree.insertText(token["data"])
+            # This must be bad for performance
+            if (self.parser.framesetOK and
+                any([char not in spaceCharacters
+                     for char in token["data"]])):
+                self.parser.framesetOK = False
+
+        def processSpaceCharactersNonPre(self, token):
+            self.tree.reconstructActiveFormattingElements()
+            self.tree.insertText(token["data"])
+
+        def startTagProcessInHead(self, token):
+            return self.parser.phases["inHead"].processStartTag(token)
+
+        def startTagBody(self, token):
+            self.parser.parseError("unexpected-start-tag", {"name": "body"})
+            if (len(self.tree.openElements) == 1 or
+                    self.tree.openElements[1].name != "body"):
+                assert self.parser.innerHTML
+            else:
+                self.parser.framesetOK = False
+                for attr, value in token["data"].items():
+                    if attr not in self.tree.openElements[1].attributes:
+                        self.tree.openElements[1].attributes[attr] = value
+
+        def startTagFrameset(self, token):
+            self.parser.parseError("unexpected-start-tag", {"name": "frameset"})
+            if (len(self.tree.openElements) == 1 or self.tree.openElements[1].name != "body"):
+                assert self.parser.innerHTML
+            elif not self.parser.framesetOK:
+                pass
+            else:
+                if self.tree.openElements[1].parent:
+                    self.tree.openElements[1].parent.removeChild(self.tree.openElements[1])
+                while self.tree.openElements[-1].name != "html":
+                    self.tree.openElements.pop()
+                self.tree.insertElement(token)
+                self.parser.phase = self.parser.phases["inFrameset"]
+
+        def startTagCloseP(self, token):
+            if self.tree.elementInScope("p", variant="button"):
+                self.endTagP(impliedTagToken("p"))
+            self.tree.insertElement(token)
+
+        def startTagPreListing(self, token):
+            if self.tree.elementInScope("p", variant="button"):
+                self.endTagP(impliedTagToken("p"))
+            self.tree.insertElement(token)
+            self.parser.framesetOK = False
+            self.processSpaceCharacters = self.processSpaceCharactersDropNewline
+
+        def startTagForm(self, token):
+            if self.tree.formPointer:
+                self.parser.parseError("unexpected-start-tag", {"name": "form"})
+            else:
+                if self.tree.elementInScope("p", variant="button"):
+                    self.endTagP(impliedTagToken("p"))
+                self.tree.insertElement(token)
+                self.tree.formPointer = self.tree.openElements[-1]
+
+        def startTagListItem(self, token):
+            self.parser.framesetOK = False
+
+            stopNamesMap = {"li": ["li"],
+                            "dt": ["dt", "dd"],
+                            "dd": ["dt", "dd"]}
+            stopNames = stopNamesMap[token["name"]]
+            for node in reversed(self.tree.openElements):
+                if node.name in stopNames:
+                    self.parser.phase.processEndTag(
+                        impliedTagToken(node.name, "EndTag"))
+                    break
+                if (node.nameTuple in specialElements and
+                        node.name not in ("address", "div", "p")):
+                    break
+
+            if self.tree.elementInScope("p", variant="button"):
+                self.parser.phase.processEndTag(
+                    impliedTagToken("p", "EndTag"))
+
+            self.tree.insertElement(token)
+
+        def startTagPlaintext(self, token):
+            if self.tree.elementInScope("p", variant="button"):
+                self.endTagP(impliedTagToken("p"))
+            self.tree.insertElement(token)
+            self.parser.tokenizer.state = self.parser.tokenizer.plaintextState
+
+        def startTagHeading(self, token):
+            if self.tree.elementInScope("p", variant="button"):
+                self.endTagP(impliedTagToken("p"))
+            if self.tree.openElements[-1].name in headingElements:
+                self.parser.parseError("unexpected-start-tag", {"name": token["name"]})
+                self.tree.openElements.pop()
+            self.tree.insertElement(token)
+
+        def startTagA(self, token):
+            afeAElement = self.tree.elementInActiveFormattingElements("a")
+            if afeAElement:
+                self.parser.parseError("unexpected-start-tag-implies-end-tag",
+                                       {"startName": "a", "endName": "a"})
+                self.endTagFormatting(impliedTagToken("a"))
+                if afeAElement in self.tree.openElements:
+                    self.tree.openElements.remove(afeAElement)
+                if afeAElement in self.tree.activeFormattingElements:
+                    self.tree.activeFormattingElements.remove(afeAElement)
+            self.tree.reconstructActiveFormattingElements()
+            self.addFormattingElement(token)
+
+        def startTagFormatting(self, token):
+            self.tree.reconstructActiveFormattingElements()
+            self.addFormattingElement(token)
+
+        def startTagNobr(self, token):
+            self.tree.reconstructActiveFormattingElements()
+            if self.tree.elementInScope("nobr"):
+                self.parser.parseError("unexpected-start-tag-implies-end-tag",
+                                       {"startName": "nobr", "endName": "nobr"})
+                self.processEndTag(impliedTagToken("nobr"))
+                # XXX Need tests that trigger the following
+                self.tree.reconstructActiveFormattingElements()
+            self.addFormattingElement(token)
+
+        def startTagButton(self, token):
+            if self.tree.elementInScope("button"):
+                self.parser.parseError("unexpected-start-tag-implies-end-tag",
+                                       {"startName": "button", "endName": "button"})
+                self.processEndTag(impliedTagToken("button"))
+                return token
+            else:
+                self.tree.reconstructActiveFormattingElements()
+                self.tree.insertElement(token)
+                self.parser.framesetOK = False
+
+        def startTagAppletMarqueeObject(self, token):
+            self.tree.reconstructActiveFormattingElements()
+            self.tree.insertElement(token)
+            self.tree.activeFormattingElements.append(Marker)
+            self.parser.framesetOK = False
+
+        def startTagXmp(self, token):
+            if self.tree.elementInScope("p", variant="button"):
+                self.endTagP(impliedTagToken("p"))
+            self.tree.reconstructActiveFormattingElements()
+            self.parser.framesetOK = False
+            self.parser.parseRCDataRawtext(token, "RAWTEXT")
+
+        def startTagTable(self, token):
+            if self.parser.compatMode != "quirks":
+                if self.tree.elementInScope("p", variant="button"):
+                    self.processEndTag(impliedTagToken("p"))
+            self.tree.insertElement(token)
+            self.parser.framesetOK = False
+            self.parser.phase = self.parser.phases["inTable"]
+
+        def startTagVoidFormatting(self, token):
+            self.tree.reconstructActiveFormattingElements()
+            self.tree.insertElement(token)
+            self.tree.openElements.pop()
+            token["selfClosingAcknowledged"] = True
+            self.parser.framesetOK = False
+
+        def startTagInput(self, token):
+            framesetOK = self.parser.framesetOK
+            self.startTagVoidFormatting(token)
+            if ("type" in token["data"] and
+                    token["data"]["type"].translate(asciiUpper2Lower) == "hidden"):
+                # input type=hidden doesn't change framesetOK
+                self.parser.framesetOK = framesetOK
+
+        def startTagParamSource(self, token):
+            self.tree.insertElement(token)
+            self.tree.openElements.pop()
+            token["selfClosingAcknowledged"] = True
+
+        def startTagHr(self, token):
+            if self.tree.elementInScope("p", variant="button"):
+                self.endTagP(impliedTagToken("p"))
+            self.tree.insertElement(token)
+            self.tree.openElements.pop()
+            token["selfClosingAcknowledged"] = True
+            self.parser.framesetOK = False
+
+        def startTagImage(self, token):
+            # No really...
+            self.parser.parseError("unexpected-start-tag-treated-as",
+                                   {"originalName": "image", "newName": "img"})
+            self.processStartTag(impliedTagToken("img", "StartTag",
+                                                 attributes=token["data"],
+                                                 selfClosing=token["selfClosing"]))
+
+        def startTagIsIndex(self, token):
+            self.parser.parseError("deprecated-tag", {"name": "isindex"})
+            if self.tree.formPointer:
+                return
+            form_attrs = {}
+            if "action" in token["data"]:
+                form_attrs["action"] = token["data"]["action"]
+            self.processStartTag(impliedTagToken("form", "StartTag",
+                                                 attributes=form_attrs))
+            self.processStartTag(impliedTagToken("hr", "StartTag"))
+            self.processStartTag(impliedTagToken("label", "StartTag"))
+            # XXX Localization ...
+            if "prompt" in token["data"]:
+                prompt = token["data"]["prompt"]
+            else:
+                prompt = "This is a searchable index. Enter search keywords: "
+            self.processCharacters(
+                {"type": tokenTypes["Characters"], "data": prompt})
+            attributes = token["data"].copy()
+            if "action" in attributes:
+                del attributes["action"]
+            if "prompt" in attributes:
+                del attributes["prompt"]
+            attributes["name"] = "isindex"
+            self.processStartTag(impliedTagToken("input", "StartTag",
+                                                 attributes=attributes,
+                                                 selfClosing=token["selfClosing"]))
+            self.processEndTag(impliedTagToken("label"))
+            self.processStartTag(impliedTagToken("hr", "StartTag"))
+            self.processEndTag(impliedTagToken("form"))
+
+        def startTagTextarea(self, token):
+            self.tree.insertElement(token)
+            self.parser.tokenizer.state = self.parser.tokenizer.rcdataState
+            self.processSpaceCharacters = self.processSpaceCharactersDropNewline
+            self.parser.framesetOK = False
+
+        def startTagIFrame(self, token):
+            self.parser.framesetOK = False
+            self.startTagRawtext(token)
+
+        def startTagNoscript(self, token):
+            if self.parser.scripting:
+                self.startTagRawtext(token)
+            else:
+                self.startTagOther(token)
+
+        def startTagRawtext(self, token):
+            """iframe, noembed noframes, noscript(if scripting enabled)"""
+            self.parser.parseRCDataRawtext(token, "RAWTEXT")
+
+        def startTagOpt(self, token):
+            if self.tree.openElements[-1].name == "option":
+                self.parser.phase.processEndTag(impliedTagToken("option"))
+            self.tree.reconstructActiveFormattingElements()
+            self.parser.tree.insertElement(token)
+
+        def startTagSelect(self, token):
+            self.tree.reconstructActiveFormattingElements()
+            self.tree.insertElement(token)
+            self.parser.framesetOK = False
+            if self.parser.phase in (self.parser.phases["inTable"],
+                                     self.parser.phases["inCaption"],
+                                     self.parser.phases["inColumnGroup"],
+                                     self.parser.phases["inTableBody"],
+                                     self.parser.phases["inRow"],
+                                     self.parser.phases["inCell"]):
+                self.parser.phase = self.parser.phases["inSelectInTable"]
+            else:
+                self.parser.phase = self.parser.phases["inSelect"]
+
+        def startTagRpRt(self, token):
+            if self.tree.elementInScope("ruby"):
+                self.tree.generateImpliedEndTags()
+                if self.tree.openElements[-1].name != "ruby":
+                    self.parser.parseError()
+            self.tree.insertElement(token)
+
+        def startTagMath(self, token):
+            self.tree.reconstructActiveFormattingElements()
+            self.parser.adjustMathMLAttributes(token)
+            self.parser.adjustForeignAttributes(token)
+            token["namespace"] = namespaces["mathml"]
+            self.tree.insertElement(token)
+            # Need to get the parse error right for the case where the token
+            # has a namespace not equal to the xmlns attribute
+            if token["selfClosing"]:
+                self.tree.openElements.pop()
+                token["selfClosingAcknowledged"] = True
+
+        def startTagSvg(self, token):
+            self.tree.reconstructActiveFormattingElements()
+            self.parser.adjustSVGAttributes(token)
+            self.parser.adjustForeignAttributes(token)
+            token["namespace"] = namespaces["svg"]
+            self.tree.insertElement(token)
+            # Need to get the parse error right for the case where the token
+            # has a namespace not equal to the xmlns attribute
+            if token["selfClosing"]:
+                self.tree.openElements.pop()
+                token["selfClosingAcknowledged"] = True
+
+        def startTagMisplaced(self, token):
+            """ Elements that should be children of other elements that have a
+            different insertion mode; here they are ignored
+            "caption", "col", "colgroup", "frame", "frameset", "head",
+            "option", "optgroup", "tbody", "td", "tfoot", "th", "thead",
+            "tr", "noscript"
+            """
+            self.parser.parseError("unexpected-start-tag-ignored", {"name": token["name"]})
+
+        def startTagOther(self, token):
+            self.tree.reconstructActiveFormattingElements()
+            self.tree.insertElement(token)
+
+        def endTagP(self, token):
+            if not self.tree.elementInScope("p", variant="button"):
+                self.startTagCloseP(impliedTagToken("p", "StartTag"))
+                self.parser.parseError("unexpected-end-tag", {"name": "p"})
+                self.endTagP(impliedTagToken("p", "EndTag"))
+            else:
+                self.tree.generateImpliedEndTags("p")
+                if self.tree.openElements[-1].name != "p":
+                    self.parser.parseError("unexpected-end-tag", {"name": "p"})
+                node = self.tree.openElements.pop()
+                while node.name != "p":
+                    node = self.tree.openElements.pop()
+
+        def endTagBody(self, token):
+            if not self.tree.elementInScope("body"):
+                self.parser.parseError()
+                return
+            elif self.tree.openElements[-1].name != "body":
+                for node in self.tree.openElements[2:]:
+                    if node.name not in frozenset(("dd", "dt", "li", "optgroup",
+                                                   "option", "p", "rp", "rt",
+                                                   "tbody", "td", "tfoot",
+                                                   "th", "thead", "tr", "body",
+                                                   "html")):
+                        # Not sure this is the correct name for the parse error
+                        self.parser.parseError(
+                            "expected-one-end-tag-but-got-another",
+                            {"gotName": "body", "expectedName": node.name})
+                        break
+            self.parser.phase = self.parser.phases["afterBody"]
+
+        def endTagHtml(self, token):
+            # We repeat the test for the body end tag token being ignored here
+            if self.tree.elementInScope("body"):
+                self.endTagBody(impliedTagToken("body"))
+                return token
+
+        def endTagBlock(self, token):
+            # Put us back in the right whitespace handling mode
+            if token["name"] == "pre":
+                self.processSpaceCharacters = self.processSpaceCharactersNonPre
+            inScope = self.tree.elementInScope(token["name"])
+            if inScope:
+                self.tree.generateImpliedEndTags()
+            if self.tree.openElements[-1].name != token["name"]:
+                self.parser.parseError("end-tag-too-early", {"name": token["name"]})
+            if inScope:
+                node = self.tree.openElements.pop()
+                while node.name != token["name"]:
+                    node = self.tree.openElements.pop()
+
+        def endTagForm(self, token):
+            node = self.tree.formPointer
+            self.tree.formPointer = None
+            if node is None or not self.tree.elementInScope(node):
+                self.parser.parseError("unexpected-end-tag",
+                                       {"name": "form"})
+            else:
+                self.tree.generateImpliedEndTags()
+                if self.tree.openElements[-1] != node:
+                    self.parser.parseError("end-tag-too-early-ignored",
+                                           {"name": "form"})
+                self.tree.openElements.remove(node)
+
+        def endTagListItem(self, token):
+            if token["name"] == "li":
+                variant = "list"
+            else:
+                variant = None
+            if not self.tree.elementInScope(token["name"], variant=variant):
+                self.parser.parseError("unexpected-end-tag", {"name": token["name"]})
+            else:
+                self.tree.generateImpliedEndTags(exclude=token["name"])
+                if self.tree.openElements[-1].name != token["name"]:
+                    self.parser.parseError(
+                        "end-tag-too-early",
+                        {"name": token["name"]})
+                node = self.tree.openElements.pop()
+                while node.name != token["name"]:
+                    node = self.tree.openElements.pop()
+
+        def endTagHeading(self, token):
+            for item in headingElements:
+                if self.tree.elementInScope(item):
+                    self.tree.generateImpliedEndTags()
+                    break
+            if self.tree.openElements[-1].name != token["name"]:
+                self.parser.parseError("end-tag-too-early", {"name": token["name"]})
+
+            for item in headingElements:
+                if self.tree.elementInScope(item):
+                    item = self.tree.openElements.pop()
+                    while item.name not in headingElements:
+                        item = self.tree.openElements.pop()
+                    break
+
+        def endTagFormatting(self, token):
+            """The much-feared adoption agency algorithm"""
+            # http://svn.whatwg.org/webapps/complete.html#adoptionAgency revision 7867
+            # XXX Better parseError messages appreciated.
+
+            # Step 1
+            outerLoopCounter = 0
+
+            # Step 2
+            while outerLoopCounter < 8:
+
+                # Step 3
+                outerLoopCounter += 1
+
+                # Step 4:
+
+                # Let the formatting element be the last element in
+                # the list of active formatting elements that:
+                # - is between the end of the list and the last scope
+                # marker in the list, if any, or the start of the list
+                # otherwise, and
+                # - has the same tag name as the token.
+                formattingElement = self.tree.elementInActiveFormattingElements(
+                    token["name"])
+                if (not formattingElement or
+                    (formattingElement in self.tree.openElements and
+                     not self.tree.elementInScope(formattingElement.name))):
+                    # If there is no such node, then abort these steps
+                    # and instead act as described in the "any other
+                    # end tag" entry below.
+                    self.endTagOther(token)
+                    return
+
+                # Otherwise, if there is such a node, but that node is
+                # not in the stack of open elements, then this is a
+                # parse error; remove the element from the list, and
+                # abort these steps.
+                elif formattingElement not in self.tree.openElements:
+                    self.parser.parseError("adoption-agency-1.2", {"name": token["name"]})
+                    self.tree.activeFormattingElements.remove(formattingElement)
+                    return
+
+                # Otherwise, if there is such a node, and that node is
+                # also in the stack of open elements, but the element
+                # is not in scope, then this is a parse error; ignore
+                # the token, and abort these steps.
+                elif not self.tree.elementInScope(formattingElement.name):
+                    self.parser.parseError("adoption-agency-4.4", {"name": token["name"]})
+                    return
+
+                # Otherwise, there is a formatting element and that
+                # element is in the stack and is in scope. If the
+                # element is not the current node, this is a parse
+                # error. In any case, proceed with the algorithm as
+                # written in the following steps.
+                else:
+                    if formattingElement != self.tree.openElements[-1]:
+                        self.parser.parseError("adoption-agency-1.3", {"name": token["name"]})
+
+                # Step 5:
+
+                # Let the furthest block be the topmost node in the
+                # stack of open elements that is lower in the stack
+                # than the formatting element, and is an element in
+                # the special category. There might not be one.
+                afeIndex = self.tree.openElements.index(formattingElement)
+                furthestBlock = None
+                for element in self.tree.openElements[afeIndex:]:
+                    if element.nameTuple in specialElements:
+                        furthestBlock = element
+                        break
+
+                # Step 6:
+
+                # If there is no furthest block, then the UA must
+                # first pop all the nodes from the bottom of the stack
+                # of open elements, from the current node up to and
+                # including the formatting element, then remove the
+                # formatting element from the list of active
+                # formatting elements, and finally abort these steps.
+                if furthestBlock is None:
+                    element = self.tree.openElements.pop()
+                    while element != formattingElement:
+                        element = self.tree.openElements.pop()
+                    self.tree.activeFormattingElements.remove(element)
+                    return
+
+                # Step 7
+                commonAncestor = self.tree.openElements[afeIndex - 1]
+
+                # Step 8:
+                # The bookmark is supposed to help us identify where to reinsert
+                # nodes in step 15. We have to ensure that we reinsert nodes after
+                # the node before the active formatting element. Note the bookmark
+                # can move in step 9.7
+                bookmark = self.tree.activeFormattingElements.index(formattingElement)
+
+                # Step 9
+                lastNode = node = furthestBlock
+                innerLoopCounter = 0
+
+                index = self.tree.openElements.index(node)
+                while innerLoopCounter < 3:
+                    innerLoopCounter += 1
+                    # Node is element before node in open elements
+                    index -= 1
+                    node = self.tree.openElements[index]
+                    if node not in self.tree.activeFormattingElements:
+                        self.tree.openElements.remove(node)
+                        continue
+                    # Step 9.6
+                    if node == formattingElement:
+                        break
+                    # Step 9.7
+                    if lastNode == furthestBlock:
+                        bookmark = self.tree.activeFormattingElements.index(node) + 1
+                    # Step 9.8
+                    clone = node.cloneNode()
+                    # Replace node with clone
+                    self.tree.activeFormattingElements[
+                        self.tree.activeFormattingElements.index(node)] = clone
+                    self.tree.openElements[
+                        self.tree.openElements.index(node)] = clone
+                    node = clone
+                    # Step 9.9
+                    # Remove lastNode from its parents, if any
+                    if lastNode.parent:
+                        lastNode.parent.removeChild(lastNode)
+                    node.appendChild(lastNode)
+                    # Step 9.10
+                    lastNode = node
+
+                # Step 10
+                # Foster parent lastNode if commonAncestor is a
+                # table, tbody, tfoot, thead, or tr we need to foster
+                # parent the lastNode
+                if lastNode.parent:
+                    lastNode.parent.removeChild(lastNode)
+
+                if commonAncestor.name in frozenset(("table", "tbody", "tfoot", "thead", "tr")):
+                    parent, insertBefore = self.tree.getTableMisnestedNodePosition()
+                    parent.insertBefore(lastNode, insertBefore)
+                else:
+                    commonAncestor.appendChild(lastNode)
+
+                # Step 11
+                clone = formattingElement.cloneNode()
+
+                # Step 12
+                furthestBlock.reparentChildren(clone)
+
+                # Step 13
+                furthestBlock.appendChild(clone)
+
+                # Step 14
+                self.tree.activeFormattingElements.remove(formattingElement)
+                self.tree.activeFormattingElements.insert(bookmark, clone)
+
+                # Step 15
+                self.tree.openElements.remove(formattingElement)
+                self.tree.openElements.insert(
+                    self.tree.openElements.index(furthestBlock) + 1, clone)
+
+        def endTagAppletMarqueeObject(self, token):
+            if self.tree.elementInScope(token["name"]):
+                self.tree.generateImpliedEndTags()
+            if self.tree.openElements[-1].name != token["name"]:
+                self.parser.parseError("end-tag-too-early", {"name": token["name"]})
+
+            if self.tree.elementInScope(token["name"]):
+                element = self.tree.openElements.pop()
+                while element.name != token["name"]:
+                    element = self.tree.openElements.pop()
+                self.tree.clearActiveFormattingElements()
+
+        def endTagBr(self, token):
+            self.parser.parseError("unexpected-end-tag-treated-as",
+                                   {"originalName": "br", "newName": "br element"})
+            self.tree.reconstructActiveFormattingElements()
+            self.tree.insertElement(impliedTagToken("br", "StartTag"))
+            self.tree.openElements.pop()
+
+        def endTagOther(self, token):
+            for node in self.tree.openElements[::-1]:
+                if node.name == token["name"]:
+                    self.tree.generateImpliedEndTags(exclude=token["name"])
+                    if self.tree.openElements[-1].name != token["name"]:
+                        self.parser.parseError("unexpected-end-tag", {"name": token["name"]})
+                    while self.tree.openElements.pop() != node:
+                        pass
+                    break
+                else:
+                    if node.nameTuple in specialElements:
+                        self.parser.parseError("unexpected-end-tag", {"name": token["name"]})
+                        break
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", Phase.startTagHtml),
+            (("base", "basefont", "bgsound", "command", "link", "meta",
+              "script", "style", "title"),
+             startTagProcessInHead),
+            ("body", startTagBody),
+            ("frameset", startTagFrameset),
+            (("address", "article", "aside", "blockquote", "center", "details",
+              "dir", "div", "dl", "fieldset", "figcaption", "figure",
+              "footer", "header", "hgroup", "main", "menu", "nav", "ol", "p",
+              "section", "summary", "ul"),
+             startTagCloseP),
+            (headingElements, startTagHeading),
+            (("pre", "listing"), startTagPreListing),
+            ("form", startTagForm),
+            (("li", "dd", "dt"), startTagListItem),
+            ("plaintext", startTagPlaintext),
+            ("a", startTagA),
+            (("b", "big", "code", "em", "font", "i", "s", "small", "strike",
+              "strong", "tt", "u"), startTagFormatting),
+            ("nobr", startTagNobr),
+            ("button", startTagButton),
+            (("applet", "marquee", "object"), startTagAppletMarqueeObject),
+            ("xmp", startTagXmp),
+            ("table", startTagTable),
+            (("area", "br", "embed", "img", "keygen", "wbr"),
+             startTagVoidFormatting),
+            (("param", "source", "track"), startTagParamSource),
+            ("input", startTagInput),
+            ("hr", startTagHr),
+            ("image", startTagImage),
+            ("isindex", startTagIsIndex),
+            ("textarea", startTagTextarea),
+            ("iframe", startTagIFrame),
+            ("noscript", startTagNoscript),
+            (("noembed", "noframes"), startTagRawtext),
+            ("select", startTagSelect),
+            (("rp", "rt"), startTagRpRt),
+            (("option", "optgroup"), startTagOpt),
+            (("math"), startTagMath),
+            (("svg"), startTagSvg),
+            (("caption", "col", "colgroup", "frame", "head",
+              "tbody", "td", "tfoot", "th", "thead",
+              "tr"), startTagMisplaced)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            ("body", endTagBody),
+            ("html", endTagHtml),
+            (("address", "article", "aside", "blockquote", "button", "center",
+              "details", "dialog", "dir", "div", "dl", "fieldset", "figcaption", "figure",
+              "footer", "header", "hgroup", "listing", "main", "menu", "nav", "ol", "pre",
+              "section", "summary", "ul"), endTagBlock),
+            ("form", endTagForm),
+            ("p", endTagP),
+            (("dd", "dt", "li"), endTagListItem),
+            (headingElements, endTagHeading),
+            (("a", "b", "big", "code", "em", "font", "i", "nobr", "s", "small",
+              "strike", "strong", "tt", "u"), endTagFormatting),
+            (("applet", "marquee", "object"), endTagAppletMarqueeObject),
+            ("br", endTagBr),
+        ])
+        endTagHandler.default = endTagOther
+
+    class TextPhase(Phase):
+        __slots__ = tuple()
+
+        def processCharacters(self, token):
+            self.tree.insertText(token["data"])
+
+        def processEOF(self):
+            self.parser.parseError("expected-named-closing-tag-but-got-eof",
+                                   {"name": self.tree.openElements[-1].name})
+            self.tree.openElements.pop()
+            self.parser.phase = self.parser.originalPhase
+            return True
+
+        def startTagOther(self, token):
+            assert False, "Tried to process start tag %s in RCDATA/RAWTEXT mode" % token['name']
+
+        def endTagScript(self, token):
+            node = self.tree.openElements.pop()
+            assert node.name == "script"
+            self.parser.phase = self.parser.originalPhase
+            # The rest of this method is all stuff that only happens if
+            # document.write works
+
+        def endTagOther(self, token):
+            self.tree.openElements.pop()
+            self.parser.phase = self.parser.originalPhase
+
+        startTagHandler = _utils.MethodDispatcher([])
+        startTagHandler.default = startTagOther
+        endTagHandler = _utils.MethodDispatcher([
+            ("script", endTagScript)])
+        endTagHandler.default = endTagOther
+
+    class InTablePhase(Phase):
+        # http://www.whatwg.org/specs/web-apps/current-work/#in-table
+        __slots__ = tuple()
+
+        # helper methods
+        def clearStackToTableContext(self):
+            # "clear the stack back to a table context"
+            while self.tree.openElements[-1].name not in ("table", "html"):
+                # self.parser.parseError("unexpected-implied-end-tag-in-table",
+                #  {"name":  self.tree.openElements[-1].name})
+                self.tree.openElements.pop()
+            # When the current node is <html> it's an innerHTML case
+
+        # processing methods
+        def processEOF(self):
+            if self.tree.openElements[-1].name != "html":
+                self.parser.parseError("eof-in-table")
+            else:
+                assert self.parser.innerHTML
+            # Stop parsing
+
+        def processSpaceCharacters(self, token):
+            originalPhase = self.parser.phase
+            self.parser.phase = self.parser.phases["inTableText"]
+            self.parser.phase.originalPhase = originalPhase
+            self.parser.phase.processSpaceCharacters(token)
+
+        def processCharacters(self, token):
+            originalPhase = self.parser.phase
+            self.parser.phase = self.parser.phases["inTableText"]
+            self.parser.phase.originalPhase = originalPhase
+            self.parser.phase.processCharacters(token)
+
+        def insertText(self, token):
+            # If we get here there must be at least one non-whitespace character
+            # Do the table magic!
+            self.tree.insertFromTable = True
+            self.parser.phases["inBody"].processCharacters(token)
+            self.tree.insertFromTable = False
+
+        def startTagCaption(self, token):
+            self.clearStackToTableContext()
+            self.tree.activeFormattingElements.append(Marker)
+            self.tree.insertElement(token)
+            self.parser.phase = self.parser.phases["inCaption"]
+
+        def startTagColgroup(self, token):
+            self.clearStackToTableContext()
+            self.tree.insertElement(token)
+            self.parser.phase = self.parser.phases["inColumnGroup"]
+
+        def startTagCol(self, token):
+            self.startTagColgroup(impliedTagToken("colgroup", "StartTag"))
+            return token
+
+        def startTagRowGroup(self, token):
+            self.clearStackToTableContext()
+            self.tree.insertElement(token)
+            self.parser.phase = self.parser.phases["inTableBody"]
+
+        def startTagImplyTbody(self, token):
+            self.startTagRowGroup(impliedTagToken("tbody", "StartTag"))
+            return token
+
+        def startTagTable(self, token):
+            self.parser.parseError("unexpected-start-tag-implies-end-tag",
+                                   {"startName": "table", "endName": "table"})
+            self.parser.phase.processEndTag(impliedTagToken("table"))
+            if not self.parser.innerHTML:
+                return token
+
+        def startTagStyleScript(self, token):
+            return self.parser.phases["inHead"].processStartTag(token)
+
+        def startTagInput(self, token):
+            if ("type" in token["data"] and
+                    token["data"]["type"].translate(asciiUpper2Lower) == "hidden"):
+                self.parser.parseError("unexpected-hidden-input-in-table")
+                self.tree.insertElement(token)
+                # XXX associate with form
+                self.tree.openElements.pop()
+            else:
+                self.startTagOther(token)
+
+        def startTagForm(self, token):
+            self.parser.parseError("unexpected-form-in-table")
+            if self.tree.formPointer is None:
+                self.tree.insertElement(token)
+                self.tree.formPointer = self.tree.openElements[-1]
+                self.tree.openElements.pop()
+
+        def startTagOther(self, token):
+            self.parser.parseError("unexpected-start-tag-implies-table-voodoo", {"name": token["name"]})
+            # Do the table magic!
+            self.tree.insertFromTable = True
+            self.parser.phases["inBody"].processStartTag(token)
+            self.tree.insertFromTable = False
+
+        def endTagTable(self, token):
+            if self.tree.elementInScope("table", variant="table"):
+                self.tree.generateImpliedEndTags()
+                if self.tree.openElements[-1].name != "table":
+                    self.parser.parseError("end-tag-too-early-named",
+                                           {"gotName": "table",
+                                            "expectedName": self.tree.openElements[-1].name})
+                while self.tree.openElements[-1].name != "table":
+                    self.tree.openElements.pop()
+                self.tree.openElements.pop()
+                self.parser.resetInsertionMode()
+            else:
+                # innerHTML case
+                assert self.parser.innerHTML
+                self.parser.parseError()
+
+        def endTagIgnore(self, token):
+            self.parser.parseError("unexpected-end-tag", {"name": token["name"]})
+
+        def endTagOther(self, token):
+            self.parser.parseError("unexpected-end-tag-implies-table-voodoo", {"name": token["name"]})
+            # Do the table magic!
+            self.tree.insertFromTable = True
+            self.parser.phases["inBody"].processEndTag(token)
+            self.tree.insertFromTable = False
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", Phase.startTagHtml),
+            ("caption", startTagCaption),
+            ("colgroup", startTagColgroup),
+            ("col", startTagCol),
+            (("tbody", "tfoot", "thead"), startTagRowGroup),
+            (("td", "th", "tr"), startTagImplyTbody),
+            ("table", startTagTable),
+            (("style", "script"), startTagStyleScript),
+            ("input", startTagInput),
+            ("form", startTagForm)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            ("table", endTagTable),
+            (("body", "caption", "col", "colgroup", "html", "tbody", "td",
+              "tfoot", "th", "thead", "tr"), endTagIgnore)
+        ])
+        endTagHandler.default = endTagOther
+
+    class InTableTextPhase(Phase):
+        __slots__ = ("originalPhase", "characterTokens")
+
+        def __init__(self, *args, **kwargs):
+            super(InTableTextPhase, self).__init__(*args, **kwargs)
+            self.originalPhase = None
+            self.characterTokens = []
+
+        def flushCharacters(self):
+            data = "".join([item["data"] for item in self.characterTokens])
+            if any([item not in spaceCharacters for item in data]):
+                token = {"type": tokenTypes["Characters"], "data": data}
+                self.parser.phases["inTable"].insertText(token)
+            elif data:
+                self.tree.insertText(data)
+            self.characterTokens = []
+
+        def processComment(self, token):
+            self.flushCharacters()
+            self.parser.phase = self.originalPhase
+            return token
+
+        def processEOF(self):
+            self.flushCharacters()
+            self.parser.phase = self.originalPhase
+            return True
+
+        def processCharacters(self, token):
+            if token["data"] == "\u0000":
+                return
+            self.characterTokens.append(token)
+
+        def processSpaceCharacters(self, token):
+            # pretty sure we should never reach here
+            self.characterTokens.append(token)
+    #        assert False
+
+        def processStartTag(self, token):
+            self.flushCharacters()
+            self.parser.phase = self.originalPhase
+            return token
+
+        def processEndTag(self, token):
+            self.flushCharacters()
+            self.parser.phase = self.originalPhase
+            return token
+
+    class InCaptionPhase(Phase):
+        # http://www.whatwg.org/specs/web-apps/current-work/#in-caption
+        __slots__ = tuple()
+
+        def ignoreEndTagCaption(self):
+            return not self.tree.elementInScope("caption", variant="table")
+
+        def processEOF(self):
+            self.parser.phases["inBody"].processEOF()
+
+        def processCharacters(self, token):
+            return self.parser.phases["inBody"].processCharacters(token)
+
+        def startTagTableElement(self, token):
+            self.parser.parseError()
+            # XXX Have to duplicate logic here to find out if the tag is ignored
+            ignoreEndTag = self.ignoreEndTagCaption()
+            self.parser.phase.processEndTag(impliedTagToken("caption"))
+            if not ignoreEndTag:
+                return token
+
+        def startTagOther(self, token):
+            return self.parser.phases["inBody"].processStartTag(token)
+
+        def endTagCaption(self, token):
+            if not self.ignoreEndTagCaption():
+                # AT this code is quite similar to endTagTable in "InTable"
+                self.tree.generateImpliedEndTags()
+                if self.tree.openElements[-1].name != "caption":
+                    self.parser.parseError("expected-one-end-tag-but-got-another",
+                                           {"gotName": "caption",
+                                            "expectedName": self.tree.openElements[-1].name})
+                while self.tree.openElements[-1].name != "caption":
+                    self.tree.openElements.pop()
+                self.tree.openElements.pop()
+                self.tree.clearActiveFormattingElements()
+                self.parser.phase = self.parser.phases["inTable"]
+            else:
+                # innerHTML case
+                assert self.parser.innerHTML
+                self.parser.parseError()
+
+        def endTagTable(self, token):
+            self.parser.parseError()
+            ignoreEndTag = self.ignoreEndTagCaption()
+            self.parser.phase.processEndTag(impliedTagToken("caption"))
+            if not ignoreEndTag:
+                return token
+
+        def endTagIgnore(self, token):
+            self.parser.parseError("unexpected-end-tag", {"name": token["name"]})
+
+        def endTagOther(self, token):
+            return self.parser.phases["inBody"].processEndTag(token)
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", Phase.startTagHtml),
+            (("caption", "col", "colgroup", "tbody", "td", "tfoot", "th",
+              "thead", "tr"), startTagTableElement)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            ("caption", endTagCaption),
+            ("table", endTagTable),
+            (("body", "col", "colgroup", "html", "tbody", "td", "tfoot", "th",
+              "thead", "tr"), endTagIgnore)
+        ])
+        endTagHandler.default = endTagOther
+
+    class InColumnGroupPhase(Phase):
+        # http://www.whatwg.org/specs/web-apps/current-work/#in-column
+        __slots__ = tuple()
+
+        def ignoreEndTagColgroup(self):
+            return self.tree.openElements[-1].name == "html"
+
+        def processEOF(self):
+            if self.tree.openElements[-1].name == "html":
+                assert self.parser.innerHTML
+                return
+            else:
+                ignoreEndTag = self.ignoreEndTagColgroup()
+                self.endTagColgroup(impliedTagToken("colgroup"))
+                if not ignoreEndTag:
+                    return True
+
+        def processCharacters(self, token):
+            ignoreEndTag = self.ignoreEndTagColgroup()
+            self.endTagColgroup(impliedTagToken("colgroup"))
+            if not ignoreEndTag:
+                return token
+
+        def startTagCol(self, token):
+            self.tree.insertElement(token)
+            self.tree.openElements.pop()
+            token["selfClosingAcknowledged"] = True
+
+        def startTagOther(self, token):
+            ignoreEndTag = self.ignoreEndTagColgroup()
+            self.endTagColgroup(impliedTagToken("colgroup"))
+            if not ignoreEndTag:
+                return token
+
+        def endTagColgroup(self, token):
+            if self.ignoreEndTagColgroup():
+                # innerHTML case
+                assert self.parser.innerHTML
+                self.parser.parseError()
+            else:
+                self.tree.openElements.pop()
+                self.parser.phase = self.parser.phases["inTable"]
+
+        def endTagCol(self, token):
+            self.parser.parseError("no-end-tag", {"name": "col"})
+
+        def endTagOther(self, token):
+            ignoreEndTag = self.ignoreEndTagColgroup()
+            self.endTagColgroup(impliedTagToken("colgroup"))
+            if not ignoreEndTag:
+                return token
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", Phase.startTagHtml),
+            ("col", startTagCol)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            ("colgroup", endTagColgroup),
+            ("col", endTagCol)
+        ])
+        endTagHandler.default = endTagOther
+
+    class InTableBodyPhase(Phase):
+        # http://www.whatwg.org/specs/web-apps/current-work/#in-table0
+        __slots__ = tuple()
+
+        # helper methods
+        def clearStackToTableBodyContext(self):
+            while self.tree.openElements[-1].name not in ("tbody", "tfoot",
+                                                          "thead", "html"):
+                # self.parser.parseError("unexpected-implied-end-tag-in-table",
+                #  {"name": self.tree.openElements[-1].name})
+                self.tree.openElements.pop()
+            if self.tree.openElements[-1].name == "html":
+                assert self.parser.innerHTML
+
+        # the rest
+        def processEOF(self):
+            self.parser.phases["inTable"].processEOF()
+
+        def processSpaceCharacters(self, token):
+            return self.parser.phases["inTable"].processSpaceCharacters(token)
+
+        def processCharacters(self, token):
+            return self.parser.phases["inTable"].processCharacters(token)
+
+        def startTagTr(self, token):
+            self.clearStackToTableBodyContext()
+            self.tree.insertElement(token)
+            self.parser.phase = self.parser.phases["inRow"]
+
+        def startTagTableCell(self, token):
+            self.parser.parseError("unexpected-cell-in-table-body",
+                                   {"name": token["name"]})
+            self.startTagTr(impliedTagToken("tr", "StartTag"))
+            return token
+
+        def startTagTableOther(self, token):
+            # XXX AT Any ideas on how to share this with endTagTable?
+            if (self.tree.elementInScope("tbody", variant="table") or
+                self.tree.elementInScope("thead", variant="table") or
+                    self.tree.elementInScope("tfoot", variant="table")):
+                self.clearStackToTableBodyContext()
+                self.endTagTableRowGroup(
+                    impliedTagToken(self.tree.openElements[-1].name))
+                return token
+            else:
+                # innerHTML case
+                assert self.parser.innerHTML
+                self.parser.parseError()
+
+        def startTagOther(self, token):
+            return self.parser.phases["inTable"].processStartTag(token)
+
+        def endTagTableRowGroup(self, token):
+            if self.tree.elementInScope(token["name"], variant="table"):
+                self.clearStackToTableBodyContext()
+                self.tree.openElements.pop()
+                self.parser.phase = self.parser.phases["inTable"]
+            else:
+                self.parser.parseError("unexpected-end-tag-in-table-body",
+                                       {"name": token["name"]})
+
+        def endTagTable(self, token):
+            if (self.tree.elementInScope("tbody", variant="table") or
+                self.tree.elementInScope("thead", variant="table") or
+                    self.tree.elementInScope("tfoot", variant="table")):
+                self.clearStackToTableBodyContext()
+                self.endTagTableRowGroup(
+                    impliedTagToken(self.tree.openElements[-1].name))
+                return token
+            else:
+                # innerHTML case
+                assert self.parser.innerHTML
+                self.parser.parseError()
+
+        def endTagIgnore(self, token):
+            self.parser.parseError("unexpected-end-tag-in-table-body",
+                                   {"name": token["name"]})
+
+        def endTagOther(self, token):
+            return self.parser.phases["inTable"].processEndTag(token)
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", Phase.startTagHtml),
+            ("tr", startTagTr),
+            (("td", "th"), startTagTableCell),
+            (("caption", "col", "colgroup", "tbody", "tfoot", "thead"),
+             startTagTableOther)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            (("tbody", "tfoot", "thead"), endTagTableRowGroup),
+            ("table", endTagTable),
+            (("body", "caption", "col", "colgroup", "html", "td", "th",
+              "tr"), endTagIgnore)
+        ])
+        endTagHandler.default = endTagOther
+
+    class InRowPhase(Phase):
+        # http://www.whatwg.org/specs/web-apps/current-work/#in-row
+        __slots__ = tuple()
+
+        # helper methods (XXX unify this with other table helper methods)
+        def clearStackToTableRowContext(self):
+            while self.tree.openElements[-1].name not in ("tr", "html"):
+                self.parser.parseError("unexpected-implied-end-tag-in-table-row",
+                                       {"name": self.tree.openElements[-1].name})
+                self.tree.openElements.pop()
+
+        def ignoreEndTagTr(self):
+            return not self.tree.elementInScope("tr", variant="table")
+
+        # the rest
+        def processEOF(self):
+            self.parser.phases["inTable"].processEOF()
+
+        def processSpaceCharacters(self, token):
+            return self.parser.phases["inTable"].processSpaceCharacters(token)
+
+        def processCharacters(self, token):
+            return self.parser.phases["inTable"].processCharacters(token)
+
+        def startTagTableCell(self, token):
+            self.clearStackToTableRowContext()
+            self.tree.insertElement(token)
+            self.parser.phase = self.parser.phases["inCell"]
+            self.tree.activeFormattingElements.append(Marker)
+
+        def startTagTableOther(self, token):
+            ignoreEndTag = self.ignoreEndTagTr()
+            self.endTagTr(impliedTagToken("tr"))
+            # XXX how are we sure it's always ignored in the innerHTML case?
+            if not ignoreEndTag:
+                return token
+
+        def startTagOther(self, token):
+            return self.parser.phases["inTable"].processStartTag(token)
+
+        def endTagTr(self, token):
+            if not self.ignoreEndTagTr():
+                self.clearStackToTableRowContext()
+                self.tree.openElements.pop()
+                self.parser.phase = self.parser.phases["inTableBody"]
+            else:
+                # innerHTML case
+                assert self.parser.innerHTML
+                self.parser.parseError()
+
+        def endTagTable(self, token):
+            ignoreEndTag = self.ignoreEndTagTr()
+            self.endTagTr(impliedTagToken("tr"))
+            # Reprocess the current tag if the tr end tag was not ignored
+            # XXX how are we sure it's always ignored in the innerHTML case?
+            if not ignoreEndTag:
+                return token
+
+        def endTagTableRowGroup(self, token):
+            if self.tree.elementInScope(token["name"], variant="table"):
+                self.endTagTr(impliedTagToken("tr"))
+                return token
+            else:
+                self.parser.parseError()
+
+        def endTagIgnore(self, token):
+            self.parser.parseError("unexpected-end-tag-in-table-row",
+                                   {"name": token["name"]})
+
+        def endTagOther(self, token):
+            return self.parser.phases["inTable"].processEndTag(token)
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", Phase.startTagHtml),
+            (("td", "th"), startTagTableCell),
+            (("caption", "col", "colgroup", "tbody", "tfoot", "thead",
+              "tr"), startTagTableOther)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            ("tr", endTagTr),
+            ("table", endTagTable),
+            (("tbody", "tfoot", "thead"), endTagTableRowGroup),
+            (("body", "caption", "col", "colgroup", "html", "td", "th"),
+             endTagIgnore)
+        ])
+        endTagHandler.default = endTagOther
+
+    class InCellPhase(Phase):
+        # http://www.whatwg.org/specs/web-apps/current-work/#in-cell
+        __slots__ = tuple()
+
+        # helper
+        def closeCell(self):
+            if self.tree.elementInScope("td", variant="table"):
+                self.endTagTableCell(impliedTagToken("td"))
+            elif self.tree.elementInScope("th", variant="table"):
+                self.endTagTableCell(impliedTagToken("th"))
+
+        # the rest
+        def processEOF(self):
+            self.parser.phases["inBody"].processEOF()
+
+        def processCharacters(self, token):
+            return self.parser.phases["inBody"].processCharacters(token)
+
+        def startTagTableOther(self, token):
+            if (self.tree.elementInScope("td", variant="table") or
+                    self.tree.elementInScope("th", variant="table")):
+                self.closeCell()
+                return token
+            else:
+                # innerHTML case
+                assert self.parser.innerHTML
+                self.parser.parseError()
+
+        def startTagOther(self, token):
+            return self.parser.phases["inBody"].processStartTag(token)
+
+        def endTagTableCell(self, token):
+            if self.tree.elementInScope(token["name"], variant="table"):
+                self.tree.generateImpliedEndTags(token["name"])
+                if self.tree.openElements[-1].name != token["name"]:
+                    self.parser.parseError("unexpected-cell-end-tag",
+                                           {"name": token["name"]})
+                    while True:
+                        node = self.tree.openElements.pop()
+                        if node.name == token["name"]:
+                            break
+                else:
+                    self.tree.openElements.pop()
+                self.tree.clearActiveFormattingElements()
+                self.parser.phase = self.parser.phases["inRow"]
+            else:
+                self.parser.parseError("unexpected-end-tag", {"name": token["name"]})
+
+        def endTagIgnore(self, token):
+            self.parser.parseError("unexpected-end-tag", {"name": token["name"]})
+
+        def endTagImply(self, token):
+            if self.tree.elementInScope(token["name"], variant="table"):
+                self.closeCell()
+                return token
+            else:
+                # sometimes innerHTML case
+                self.parser.parseError()
+
+        def endTagOther(self, token):
+            return self.parser.phases["inBody"].processEndTag(token)
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", Phase.startTagHtml),
+            (("caption", "col", "colgroup", "tbody", "td", "tfoot", "th",
+              "thead", "tr"), startTagTableOther)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            (("td", "th"), endTagTableCell),
+            (("body", "caption", "col", "colgroup", "html"), endTagIgnore),
+            (("table", "tbody", "tfoot", "thead", "tr"), endTagImply)
+        ])
+        endTagHandler.default = endTagOther
+
+    class InSelectPhase(Phase):
+        __slots__ = tuple()
+
+        # http://www.whatwg.org/specs/web-apps/current-work/#in-select
+        def processEOF(self):
+            if self.tree.openElements[-1].name != "html":
+                self.parser.parseError("eof-in-select")
+            else:
+                assert self.parser.innerHTML
+
+        def processCharacters(self, token):
+            if token["data"] == "\u0000":
+                return
+            self.tree.insertText(token["data"])
+
+        def startTagOption(self, token):
+            # We need to imply </option> if <option> is the current node.
+            if self.tree.openElements[-1].name == "option":
+                self.tree.openElements.pop()
+            self.tree.insertElement(token)
+
+        def startTagOptgroup(self, token):
+            if self.tree.openElements[-1].name == "option":
+                self.tree.openElements.pop()
+            if self.tree.openElements[-1].name == "optgroup":
+                self.tree.openElements.pop()
+            self.tree.insertElement(token)
+
+        def startTagSelect(self, token):
+            self.parser.parseError("unexpected-select-in-select")
+            self.endTagSelect(impliedTagToken("select"))
+
+        def startTagInput(self, token):
+            self.parser.parseError("unexpected-input-in-select")
+            if self.tree.elementInScope("select", variant="select"):
+                self.endTagSelect(impliedTagToken("select"))
+                return token
+            else:
+                assert self.parser.innerHTML
+
+        def startTagScript(self, token):
+            return self.parser.phases["inHead"].processStartTag(token)
+
+        def startTagOther(self, token):
+            self.parser.parseError("unexpected-start-tag-in-select",
+                                   {"name": token["name"]})
+
+        def endTagOption(self, token):
+            if self.tree.openElements[-1].name == "option":
+                self.tree.openElements.pop()
+            else:
+                self.parser.parseError("unexpected-end-tag-in-select",
+                                       {"name": "option"})
+
+        def endTagOptgroup(self, token):
+            # </optgroup> implicitly closes <option>
+            if (self.tree.openElements[-1].name == "option" and
+                    self.tree.openElements[-2].name == "optgroup"):
+                self.tree.openElements.pop()
+            # It also closes </optgroup>
+            if self.tree.openElements[-1].name == "optgroup":
+                self.tree.openElements.pop()
+            # But nothing else
+            else:
+                self.parser.parseError("unexpected-end-tag-in-select",
+                                       {"name": "optgroup"})
+
+        def endTagSelect(self, token):
+            if self.tree.elementInScope("select", variant="select"):
+                node = self.tree.openElements.pop()
+                while node.name != "select":
+                    node = self.tree.openElements.pop()
+                self.parser.resetInsertionMode()
+            else:
+                # innerHTML case
+                assert self.parser.innerHTML
+                self.parser.parseError()
+
+        def endTagOther(self, token):
+            self.parser.parseError("unexpected-end-tag-in-select",
+                                   {"name": token["name"]})
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", Phase.startTagHtml),
+            ("option", startTagOption),
+            ("optgroup", startTagOptgroup),
+            ("select", startTagSelect),
+            (("input", "keygen", "textarea"), startTagInput),
+            ("script", startTagScript)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            ("option", endTagOption),
+            ("optgroup", endTagOptgroup),
+            ("select", endTagSelect)
+        ])
+        endTagHandler.default = endTagOther
+
+    class InSelectInTablePhase(Phase):
+        __slots__ = tuple()
+
+        def processEOF(self):
+            self.parser.phases["inSelect"].processEOF()
+
+        def processCharacters(self, token):
+            return self.parser.phases["inSelect"].processCharacters(token)
+
+        def startTagTable(self, token):
+            self.parser.parseError("unexpected-table-element-start-tag-in-select-in-table", {"name": token["name"]})
+            self.endTagOther(impliedTagToken("select"))
+            return token
+
+        def startTagOther(self, token):
+            return self.parser.phases["inSelect"].processStartTag(token)
+
+        def endTagTable(self, token):
+            self.parser.parseError("unexpected-table-element-end-tag-in-select-in-table", {"name": token["name"]})
+            if self.tree.elementInScope(token["name"], variant="table"):
+                self.endTagOther(impliedTagToken("select"))
+                return token
+
+        def endTagOther(self, token):
+            return self.parser.phases["inSelect"].processEndTag(token)
+
+        startTagHandler = _utils.MethodDispatcher([
+            (("caption", "table", "tbody", "tfoot", "thead", "tr", "td", "th"),
+             startTagTable)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            (("caption", "table", "tbody", "tfoot", "thead", "tr", "td", "th"),
+             endTagTable)
+        ])
+        endTagHandler.default = endTagOther
+
+    class InForeignContentPhase(Phase):
+        __slots__ = tuple()
+
+        breakoutElements = frozenset(["b", "big", "blockquote", "body", "br",
+                                      "center", "code", "dd", "div", "dl", "dt",
+                                      "em", "embed", "h1", "h2", "h3",
+                                      "h4", "h5", "h6", "head", "hr", "i", "img",
+                                      "li", "listing", "menu", "meta", "nobr",
+                                      "ol", "p", "pre", "ruby", "s", "small",
+                                      "span", "strong", "strike", "sub", "sup",
+                                      "table", "tt", "u", "ul", "var"])
+
+        def adjustSVGTagNames(self, token):
+            replacements = {"altglyph": "altGlyph",
+                            "altglyphdef": "altGlyphDef",
+                            "altglyphitem": "altGlyphItem",
+                            "animatecolor": "animateColor",
+                            "animatemotion": "animateMotion",
+                            "animatetransform": "animateTransform",
+                            "clippath": "clipPath",
+                            "feblend": "feBlend",
+                            "fecolormatrix": "feColorMatrix",
+                            "fecomponenttransfer": "feComponentTransfer",
+                            "fecomposite": "feComposite",
+                            "feconvolvematrix": "feConvolveMatrix",
+                            "fediffuselighting": "feDiffuseLighting",
+                            "fedisplacementmap": "feDisplacementMap",
+                            "fedistantlight": "feDistantLight",
+                            "feflood": "feFlood",
+                            "fefunca": "feFuncA",
+                            "fefuncb": "feFuncB",
+                            "fefuncg": "feFuncG",
+                            "fefuncr": "feFuncR",
+                            "fegaussianblur": "feGaussianBlur",
+                            "feimage": "feImage",
+                            "femerge": "feMerge",
+                            "femergenode": "feMergeNode",
+                            "femorphology": "feMorphology",
+                            "feoffset": "feOffset",
+                            "fepointlight": "fePointLight",
+                            "fespecularlighting": "feSpecularLighting",
+                            "fespotlight": "feSpotLight",
+                            "fetile": "feTile",
+                            "feturbulence": "feTurbulence",
+                            "foreignobject": "foreignObject",
+                            "glyphref": "glyphRef",
+                            "lineargradient": "linearGradient",
+                            "radialgradient": "radialGradient",
+                            "textpath": "textPath"}
+
+            if token["name"] in replacements:
+                token["name"] = replacements[token["name"]]
+
+        def processCharacters(self, token):
+            if token["data"] == "\u0000":
+                token["data"] = "\uFFFD"
+            elif (self.parser.framesetOK and
+                  any(char not in spaceCharacters for char in token["data"])):
+                self.parser.framesetOK = False
+            Phase.processCharacters(self, token)
+
+        def processStartTag(self, token):
+            currentNode = self.tree.openElements[-1]
+            if (token["name"] in self.breakoutElements or
+                (token["name"] == "font" and
+                 set(token["data"].keys()) & {"color", "face", "size"})):
+                self.parser.parseError("unexpected-html-element-in-foreign-content",
+                                       {"name": token["name"]})
+                while (self.tree.openElements[-1].namespace !=
+                       self.tree.defaultNamespace and
+                       not self.parser.isHTMLIntegrationPoint(self.tree.openElements[-1]) and
+                       not self.parser.isMathMLTextIntegrationPoint(self.tree.openElements[-1])):
+                    self.tree.openElements.pop()
+                return token
+
+            else:
+                if currentNode.namespace == namespaces["mathml"]:
+                    self.parser.adjustMathMLAttributes(token)
+                elif currentNode.namespace == namespaces["svg"]:
+                    self.adjustSVGTagNames(token)
+                    self.parser.adjustSVGAttributes(token)
+                self.parser.adjustForeignAttributes(token)
+                token["namespace"] = currentNode.namespace
+                self.tree.insertElement(token)
+                if token["selfClosing"]:
+                    self.tree.openElements.pop()
+                    token["selfClosingAcknowledged"] = True
+
+        def processEndTag(self, token):
+            nodeIndex = len(self.tree.openElements) - 1
+            node = self.tree.openElements[-1]
+            if node.name.translate(asciiUpper2Lower) != token["name"]:
+                self.parser.parseError("unexpected-end-tag", {"name": token["name"]})
+
+            while True:
+                if node.name.translate(asciiUpper2Lower) == token["name"]:
+                    # XXX this isn't in the spec but it seems necessary
+                    if self.parser.phase == self.parser.phases["inTableText"]:
+                        self.parser.phase.flushCharacters()
+                        self.parser.phase = self.parser.phase.originalPhase
+                    while self.tree.openElements.pop() != node:
+                        assert self.tree.openElements
+                    new_token = None
+                    break
+                nodeIndex -= 1
+
+                node = self.tree.openElements[nodeIndex]
+                if node.namespace != self.tree.defaultNamespace:
+                    continue
+                else:
+                    new_token = self.parser.phase.processEndTag(token)
+                    break
+            return new_token
+
+    class AfterBodyPhase(Phase):
+        __slots__ = tuple()
+
+        def processEOF(self):
+            # Stop parsing
+            pass
+
+        def processComment(self, token):
+            # This is needed because data is to be appended to the <html> element
+            # here and not to whatever is currently open.
+            self.tree.insertComment(token, self.tree.openElements[0])
+
+        def processCharacters(self, token):
+            self.parser.parseError("unexpected-char-after-body")
+            self.parser.phase = self.parser.phases["inBody"]
+            return token
+
+        def startTagHtml(self, token):
+            return self.parser.phases["inBody"].processStartTag(token)
+
+        def startTagOther(self, token):
+            self.parser.parseError("unexpected-start-tag-after-body",
+                                   {"name": token["name"]})
+            self.parser.phase = self.parser.phases["inBody"]
+            return token
+
+        def endTagHtml(self, name):
+            if self.parser.innerHTML:
+                self.parser.parseError("unexpected-end-tag-after-body-innerhtml")
+            else:
+                self.parser.phase = self.parser.phases["afterAfterBody"]
+
+        def endTagOther(self, token):
+            self.parser.parseError("unexpected-end-tag-after-body",
+                                   {"name": token["name"]})
+            self.parser.phase = self.parser.phases["inBody"]
+            return token
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", startTagHtml)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([("html", endTagHtml)])
+        endTagHandler.default = endTagOther
+
+    class InFramesetPhase(Phase):
+        # http://www.whatwg.org/specs/web-apps/current-work/#in-frameset
+        __slots__ = tuple()
+
+        def processEOF(self):
+            if self.tree.openElements[-1].name != "html":
+                self.parser.parseError("eof-in-frameset")
+            else:
+                assert self.parser.innerHTML
+
+        def processCharacters(self, token):
+            self.parser.parseError("unexpected-char-in-frameset")
+
+        def startTagFrameset(self, token):
+            self.tree.insertElement(token)
+
+        def startTagFrame(self, token):
+            self.tree.insertElement(token)
+            self.tree.openElements.pop()
+
+        def startTagNoframes(self, token):
+            return self.parser.phases["inBody"].processStartTag(token)
+
+        def startTagOther(self, token):
+            self.parser.parseError("unexpected-start-tag-in-frameset",
+                                   {"name": token["name"]})
+
+        def endTagFrameset(self, token):
+            if self.tree.openElements[-1].name == "html":
+                # innerHTML case
+                self.parser.parseError("unexpected-frameset-in-frameset-innerhtml")
+            else:
+                self.tree.openElements.pop()
+            if (not self.parser.innerHTML and
+                    self.tree.openElements[-1].name != "frameset"):
+                # If we're not in innerHTML mode and the current node is not a
+                # "frameset" element (anymore) then switch.
+                self.parser.phase = self.parser.phases["afterFrameset"]
+
+        def endTagOther(self, token):
+            self.parser.parseError("unexpected-end-tag-in-frameset",
+                                   {"name": token["name"]})
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", Phase.startTagHtml),
+            ("frameset", startTagFrameset),
+            ("frame", startTagFrame),
+            ("noframes", startTagNoframes)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            ("frameset", endTagFrameset)
+        ])
+        endTagHandler.default = endTagOther
+
+    class AfterFramesetPhase(Phase):
+        # http://www.whatwg.org/specs/web-apps/current-work/#after3
+        __slots__ = tuple()
+
+        def processEOF(self):
+            # Stop parsing
+            pass
+
+        def processCharacters(self, token):
+            self.parser.parseError("unexpected-char-after-frameset")
+
+        def startTagNoframes(self, token):
+            return self.parser.phases["inHead"].processStartTag(token)
+
+        def startTagOther(self, token):
+            self.parser.parseError("unexpected-start-tag-after-frameset",
+                                   {"name": token["name"]})
+
+        def endTagHtml(self, token):
+            self.parser.phase = self.parser.phases["afterAfterFrameset"]
+
+        def endTagOther(self, token):
+            self.parser.parseError("unexpected-end-tag-after-frameset",
+                                   {"name": token["name"]})
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", Phase.startTagHtml),
+            ("noframes", startTagNoframes)
+        ])
+        startTagHandler.default = startTagOther
+
+        endTagHandler = _utils.MethodDispatcher([
+            ("html", endTagHtml)
+        ])
+        endTagHandler.default = endTagOther
+
+    class AfterAfterBodyPhase(Phase):
+        __slots__ = tuple()
+
+        def processEOF(self):
+            pass
+
+        def processComment(self, token):
+            self.tree.insertComment(token, self.tree.document)
+
+        def processSpaceCharacters(self, token):
+            return self.parser.phases["inBody"].processSpaceCharacters(token)
+
+        def processCharacters(self, token):
+            self.parser.parseError("expected-eof-but-got-char")
+            self.parser.phase = self.parser.phases["inBody"]
+            return token
+
+        def startTagHtml(self, token):
+            return self.parser.phases["inBody"].processStartTag(token)
+
+        def startTagOther(self, token):
+            self.parser.parseError("expected-eof-but-got-start-tag",
+                                   {"name": token["name"]})
+            self.parser.phase = self.parser.phases["inBody"]
+            return token
+
+        def processEndTag(self, token):
+            self.parser.parseError("expected-eof-but-got-end-tag",
+                                   {"name": token["name"]})
+            self.parser.phase = self.parser.phases["inBody"]
+            return token
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", startTagHtml)
+        ])
+        startTagHandler.default = startTagOther
+
+    class AfterAfterFramesetPhase(Phase):
+        __slots__ = tuple()
+
+        def processEOF(self):
+            pass
+
+        def processComment(self, token):
+            self.tree.insertComment(token, self.tree.document)
+
+        def processSpaceCharacters(self, token):
+            return self.parser.phases["inBody"].processSpaceCharacters(token)
+
+        def processCharacters(self, token):
+            self.parser.parseError("expected-eof-but-got-char")
+
+        def startTagHtml(self, token):
+            return self.parser.phases["inBody"].processStartTag(token)
+
+        def startTagNoFrames(self, token):
+            return self.parser.phases["inHead"].processStartTag(token)
+
+        def startTagOther(self, token):
+            self.parser.parseError("expected-eof-but-got-start-tag",
+                                   {"name": token["name"]})
+
+        def processEndTag(self, token):
+            self.parser.parseError("expected-eof-but-got-end-tag",
+                                   {"name": token["name"]})
+
+        startTagHandler = _utils.MethodDispatcher([
+            ("html", startTagHtml),
+            ("noframes", startTagNoFrames)
+        ])
+        startTagHandler.default = startTagOther
+
+    # pylint:enable=unused-argument
+
+    return {
+        "initial": InitialPhase,
+        "beforeHtml": BeforeHtmlPhase,
+        "beforeHead": BeforeHeadPhase,
+        "inHead": InHeadPhase,
+        "inHeadNoscript": InHeadNoscriptPhase,
+        "afterHead": AfterHeadPhase,
+        "inBody": InBodyPhase,
+        "text": TextPhase,
+        "inTable": InTablePhase,
+        "inTableText": InTableTextPhase,
+        "inCaption": InCaptionPhase,
+        "inColumnGroup": InColumnGroupPhase,
+        "inTableBody": InTableBodyPhase,
+        "inRow": InRowPhase,
+        "inCell": InCellPhase,
+        "inSelect": InSelectPhase,
+        "inSelectInTable": InSelectInTablePhase,
+        "inForeignContent": InForeignContentPhase,
+        "afterBody": AfterBodyPhase,
+        "inFrameset": InFramesetPhase,
+        "afterFrameset": AfterFramesetPhase,
+        "afterAfterBody": AfterAfterBodyPhase,
+        "afterAfterFrameset": AfterAfterFramesetPhase,
+        # XXX after after frameset
+    }
+
+
+def adjust_attributes(token, replacements):
+    needs_adjustment = viewkeys(token['data']) & viewkeys(replacements)
+    if needs_adjustment:
+        token['data'] = type(token['data'])((replacements.get(k, k), v)
+                                            for k, v in token['data'].items())
+
+
+def impliedTagToken(name, type="EndTag", attributes=None,
+                    selfClosing=False):
+    if attributes is None:
+        attributes = {}
+    return {"type": tokenTypes[type], "name": name, "data": attributes,
+            "selfClosing": selfClosing}
+
+
+class ParseError(Exception):
+    """Error in parsed document"""
+    pass
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/serializer.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/serializer.py
new file mode 100644
index 0000000..d5669d8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/serializer.py
@@ -0,0 +1,409 @@
+from __future__ import absolute_import, division, unicode_literals
+from pip._vendor.six import text_type
+
+import re
+
+from codecs import register_error, xmlcharrefreplace_errors
+
+from .constants import voidElements, booleanAttributes, spaceCharacters
+from .constants import rcdataElements, entities, xmlEntities
+from . import treewalkers, _utils
+from xml.sax.saxutils import escape
+
+_quoteAttributeSpecChars = "".join(spaceCharacters) + "\"'=<>`"
+_quoteAttributeSpec = re.compile("[" + _quoteAttributeSpecChars + "]")
+_quoteAttributeLegacy = re.compile("[" + _quoteAttributeSpecChars +
+                                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n"
+                                   "\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15"
+                                   "\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
+                                   "\x20\x2f\x60\xa0\u1680\u180e\u180f\u2000"
+                                   "\u2001\u2002\u2003\u2004\u2005\u2006\u2007"
+                                   "\u2008\u2009\u200a\u2028\u2029\u202f\u205f"
+                                   "\u3000]")
+
+
+_encode_entity_map = {}
+_is_ucs4 = len("\U0010FFFF") == 1
+for k, v in list(entities.items()):
+    # skip multi-character entities
+    if ((_is_ucs4 and len(v) > 1) or
+            (not _is_ucs4 and len(v) > 2)):
+        continue
+    if v != "&":
+        if len(v) == 2:
+            v = _utils.surrogatePairToCodepoint(v)
+        else:
+            v = ord(v)
+        if v not in _encode_entity_map or k.islower():
+            # prefer &lt; over &LT; and similarly for &amp;, &gt;, etc.
+            _encode_entity_map[v] = k
+
+
+def htmlentityreplace_errors(exc):
+    if isinstance(exc, (UnicodeEncodeError, UnicodeTranslateError)):
+        res = []
+        codepoints = []
+        skip = False
+        for i, c in enumerate(exc.object[exc.start:exc.end]):
+            if skip:
+                skip = False
+                continue
+            index = i + exc.start
+            if _utils.isSurrogatePair(exc.object[index:min([exc.end, index + 2])]):
+                codepoint = _utils.surrogatePairToCodepoint(exc.object[index:index + 2])
+                skip = True
+            else:
+                codepoint = ord(c)
+            codepoints.append(codepoint)
+        for cp in codepoints:
+            e = _encode_entity_map.get(cp)
+            if e:
+                res.append("&")
+                res.append(e)
+                if not e.endswith(";"):
+                    res.append(";")
+            else:
+                res.append("&#x%s;" % (hex(cp)[2:]))
+        return ("".join(res), exc.end)
+    else:
+        return xmlcharrefreplace_errors(exc)
+
+
+register_error("htmlentityreplace", htmlentityreplace_errors)
+
+
+def serialize(input, tree="etree", encoding=None, **serializer_opts):
+    """Serializes the input token stream using the specified treewalker
+
+    :arg input: the token stream to serialize
+
+    :arg tree: the treewalker to use
+
+    :arg encoding: the encoding to use
+
+    :arg serializer_opts: any options to pass to the
+        :py:class:`html5lib.serializer.HTMLSerializer` that gets created
+
+    :returns: the tree serialized as a string
+
+    Example:
+
+    >>> from html5lib.html5parser import parse
+    >>> from html5lib.serializer import serialize
+    >>> token_stream = parse('<html><body><p>Hi!</p></body></html>')
+    >>> serialize(token_stream, omit_optional_tags=False)
+    '<html><head></head><body><p>Hi!</p></body></html>'
+
+    """
+    # XXX: Should we cache this?
+    walker = treewalkers.getTreeWalker(tree)
+    s = HTMLSerializer(**serializer_opts)
+    return s.render(walker(input), encoding)
+
+
+class HTMLSerializer(object):
+
+    # attribute quoting options
+    quote_attr_values = "legacy"  # be secure by default
+    quote_char = '"'
+    use_best_quote_char = True
+
+    # tag syntax options
+    omit_optional_tags = True
+    minimize_boolean_attributes = True
+    use_trailing_solidus = False
+    space_before_trailing_solidus = True
+
+    # escaping options
+    escape_lt_in_attrs = False
+    escape_rcdata = False
+    resolve_entities = True
+
+    # miscellaneous options
+    alphabetical_attributes = False
+    inject_meta_charset = True
+    strip_whitespace = False
+    sanitize = False
+
+    options = ("quote_attr_values", "quote_char", "use_best_quote_char",
+               "omit_optional_tags", "minimize_boolean_attributes",
+               "use_trailing_solidus", "space_before_trailing_solidus",
+               "escape_lt_in_attrs", "escape_rcdata", "resolve_entities",
+               "alphabetical_attributes", "inject_meta_charset",
+               "strip_whitespace", "sanitize")
+
+    def __init__(self, **kwargs):
+        """Initialize HTMLSerializer
+
+        :arg inject_meta_charset: Whether or not to inject the meta charset.
+
+            Defaults to ``True``.
+
+        :arg quote_attr_values: Whether to quote attribute values that don't
+            require quoting per legacy browser behavior (``"legacy"``), when
+            required by the standard (``"spec"``), or always (``"always"``).
+
+            Defaults to ``"legacy"``.
+
+        :arg quote_char: Use given quote character for attribute quoting.
+
+            Defaults to ``"`` which will use double quotes unless attribute
+            value contains a double quote, in which case single quotes are
+            used.
+
+        :arg escape_lt_in_attrs: Whether or not to escape ``<`` in attribute
+            values.
+
+            Defaults to ``False``.
+
+        :arg escape_rcdata: Whether to escape characters that need to be
+            escaped within normal elements within rcdata elements such as
+            style.
+
+            Defaults to ``False``.
+
+        :arg resolve_entities: Whether to resolve named character entities that
+            appear in the source tree. The XML predefined entities &lt; &gt;
+            &amp; &quot; &apos; are unaffected by this setting.
+
+            Defaults to ``True``.
+
+        :arg strip_whitespace: Whether to remove semantically meaningless
+            whitespace. (This compresses all whitespace to a single space
+            except within ``pre``.)
+
+            Defaults to ``False``.
+
+        :arg minimize_boolean_attributes: Shortens boolean attributes to give
+            just the attribute value, for example::
+
+              <input disabled="disabled">
+
+            becomes::
+
+              <input disabled>
+
+            Defaults to ``True``.
+
+        :arg use_trailing_solidus: Includes a close-tag slash at the end of the
+            start tag of void elements (empty elements whose end tag is
+            forbidden). E.g. ``<hr/>``.
+
+            Defaults to ``False``.
+
+        :arg space_before_trailing_solidus: Places a space immediately before
+            the closing slash in a tag using a trailing solidus. E.g.
+            ``<hr />``. Requires ``use_trailing_solidus=True``.
+
+            Defaults to ``True``.
+
+        :arg sanitize: Strip all unsafe or unknown constructs from output.
+            See :py:class:`html5lib.filters.sanitizer.Filter`.
+
+            Defaults to ``False``.
+
+        :arg omit_optional_tags: Omit start/end tags that are optional.
+
+            Defaults to ``True``.
+
+        :arg alphabetical_attributes: Reorder attributes to be in alphabetical order.
+
+            Defaults to ``False``.
+
+        """
+        unexpected_args = frozenset(kwargs) - frozenset(self.options)
+        if len(unexpected_args) > 0:
+            raise TypeError("__init__() got an unexpected keyword argument '%s'" % next(iter(unexpected_args)))
+        if 'quote_char' in kwargs:
+            self.use_best_quote_char = False
+        for attr in self.options:
+            setattr(self, attr, kwargs.get(attr, getattr(self, attr)))
+        self.errors = []
+        self.strict = False
+
+    def encode(self, string):
+        assert(isinstance(string, text_type))
+        if self.encoding:
+            return string.encode(self.encoding, "htmlentityreplace")
+        else:
+            return string
+
+    def encodeStrict(self, string):
+        assert(isinstance(string, text_type))
+        if self.encoding:
+            return string.encode(self.encoding, "strict")
+        else:
+            return string
+
+    def serialize(self, treewalker, encoding=None):
+        # pylint:disable=too-many-nested-blocks
+        self.encoding = encoding
+        in_cdata = False
+        self.errors = []
+
+        if encoding and self.inject_meta_charset:
+            from .filters.inject_meta_charset import Filter
+            treewalker = Filter(treewalker, encoding)
+        # Alphabetical attributes is here under the assumption that none of
+        # the later filters add or change order of attributes; it needs to be
+        # before the sanitizer so escaped elements come out correctly
+        if self.alphabetical_attributes:
+            from .filters.alphabeticalattributes import Filter
+            treewalker = Filter(treewalker)
+        # WhitespaceFilter should be used before OptionalTagFilter
+        # for maximum efficiently of this latter filter
+        if self.strip_whitespace:
+            from .filters.whitespace import Filter
+            treewalker = Filter(treewalker)
+        if self.sanitize:
+            from .filters.sanitizer import Filter
+            treewalker = Filter(treewalker)
+        if self.omit_optional_tags:
+            from .filters.optionaltags import Filter
+            treewalker = Filter(treewalker)
+
+        for token in treewalker:
+            type = token["type"]
+            if type == "Doctype":
+                doctype = "<!DOCTYPE %s" % token["name"]
+
+                if token["publicId"]:
+                    doctype += ' PUBLIC "%s"' % token["publicId"]
+                elif token["systemId"]:
+                    doctype += " SYSTEM"
+                if token["systemId"]:
+                    if token["systemId"].find('"') >= 0:
+                        if token["systemId"].find("'") >= 0:
+                            self.serializeError("System identifier contains both single and double quote characters")
+                        quote_char = "'"
+                    else:
+                        quote_char = '"'
+                    doctype += " %s%s%s" % (quote_char, token["systemId"], quote_char)
+
+                doctype += ">"
+                yield self.encodeStrict(doctype)
+
+            elif type in ("Characters", "SpaceCharacters"):
+                if type == "SpaceCharacters" or in_cdata:
+                    if in_cdata and token["data"].find("</") >= 0:
+                        self.serializeError("Unexpected </ in CDATA")
+                    yield self.encode(token["data"])
+                else:
+                    yield self.encode(escape(token["data"]))
+
+            elif type in ("StartTag", "EmptyTag"):
+                name = token["name"]
+                yield self.encodeStrict("<%s" % name)
+                if name in rcdataElements and not self.escape_rcdata:
+                    in_cdata = True
+                elif in_cdata:
+                    self.serializeError("Unexpected child element of a CDATA element")
+                for (_, attr_name), attr_value in token["data"].items():
+                    # TODO: Add namespace support here
+                    k = attr_name
+                    v = attr_value
+                    yield self.encodeStrict(' ')
+
+                    yield self.encodeStrict(k)
+                    if not self.minimize_boolean_attributes or \
+                        (k not in booleanAttributes.get(name, tuple()) and
+                         k not in booleanAttributes.get("", tuple())):
+                        yield self.encodeStrict("=")
+                        if self.quote_attr_values == "always" or len(v) == 0:
+                            quote_attr = True
+                        elif self.quote_attr_values == "spec":
+                            quote_attr = _quoteAttributeSpec.search(v) is not None
+                        elif self.quote_attr_values == "legacy":
+                            quote_attr = _quoteAttributeLegacy.search(v) is not None
+                        else:
+                            raise ValueError("quote_attr_values must be one of: "
+                                             "'always', 'spec', or 'legacy'")
+                        v = v.replace("&", "&amp;")
+                        if self.escape_lt_in_attrs:
+                            v = v.replace("<", "&lt;")
+                        if quote_attr:
+                            quote_char = self.quote_char
+                            if self.use_best_quote_char:
+                                if "'" in v and '"' not in v:
+                                    quote_char = '"'
+                                elif '"' in v and "'" not in v:
+                                    quote_char = "'"
+                            if quote_char == "'":
+                                v = v.replace("'", "&#39;")
+                            else:
+                                v = v.replace('"', "&quot;")
+                            yield self.encodeStrict(quote_char)
+                            yield self.encode(v)
+                            yield self.encodeStrict(quote_char)
+                        else:
+                            yield self.encode(v)
+                if name in voidElements and self.use_trailing_solidus:
+                    if self.space_before_trailing_solidus:
+                        yield self.encodeStrict(" /")
+                    else:
+                        yield self.encodeStrict("/")
+                yield self.encode(">")
+
+            elif type == "EndTag":
+                name = token["name"]
+                if name in rcdataElements:
+                    in_cdata = False
+                elif in_cdata:
+                    self.serializeError("Unexpected child element of a CDATA element")
+                yield self.encodeStrict("</%s>" % name)
+
+            elif type == "Comment":
+                data = token["data"]
+                if data.find("--") >= 0:
+                    self.serializeError("Comment contains --")
+                yield self.encodeStrict("<!--%s-->" % token["data"])
+
+            elif type == "Entity":
+                name = token["name"]
+                key = name + ";"
+                if key not in entities:
+                    self.serializeError("Entity %s not recognized" % name)
+                if self.resolve_entities and key not in xmlEntities:
+                    data = entities[key]
+                else:
+                    data = "&%s;" % name
+                yield self.encodeStrict(data)
+
+            else:
+                self.serializeError(token["data"])
+
+    def render(self, treewalker, encoding=None):
+        """Serializes the stream from the treewalker into a string
+
+        :arg treewalker: the treewalker to serialize
+
+        :arg encoding: the string encoding to use
+
+        :returns: the serialized tree
+
+        Example:
+
+        >>> from html5lib import parse, getTreeWalker
+        >>> from html5lib.serializer import HTMLSerializer
+        >>> token_stream = parse('<html><body>Hi!</body></html>')
+        >>> walker = getTreeWalker('etree')
+        >>> serializer = HTMLSerializer(omit_optional_tags=False)
+        >>> serializer.render(walker(token_stream))
+        '<html><head></head><body>Hi!</body></html>'
+
+        """
+        if encoding:
+            return b"".join(list(self.serialize(treewalker, encoding)))
+        else:
+            return "".join(list(self.serialize(treewalker)))
+
+    def serializeError(self, data="XXX ERROR MESSAGE NEEDED"):
+        # XXX The idea is to make data mandatory.
+        self.errors.append(data)
+        if self.strict:
+            raise SerializeError
+
+
+class SerializeError(Exception):
+    """Error in serialized tree"""
+    pass
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treeadapters/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treeadapters/__init__.py
new file mode 100644
index 0000000..7ef5959
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treeadapters/__init__.py
@@ -0,0 +1,30 @@
+"""Tree adapters let you convert from one tree structure to another
+
+Example:
+
+.. code-block:: python
+
+   from pip._vendor import html5lib
+   from pip._vendor.html5lib.treeadapters import genshi
+
+   doc = '<html><body>Hi!</body></html>'
+   treebuilder = html5lib.getTreeBuilder('etree')
+   parser = html5lib.HTMLParser(tree=treebuilder)
+   tree = parser.parse(doc)
+   TreeWalker = html5lib.getTreeWalker('etree')
+
+   genshi_tree = genshi.to_genshi(TreeWalker(tree))
+
+"""
+from __future__ import absolute_import, division, unicode_literals
+
+from . import sax
+
+__all__ = ["sax"]
+
+try:
+    from . import genshi  # noqa
+except ImportError:
+    pass
+else:
+    __all__.append("genshi")
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treeadapters/genshi.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treeadapters/genshi.py
new file mode 100644
index 0000000..61d5fb6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treeadapters/genshi.py
@@ -0,0 +1,54 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from genshi.core import QName, Attrs
+from genshi.core import START, END, TEXT, COMMENT, DOCTYPE
+
+
+def to_genshi(walker):
+    """Convert a tree to a genshi tree
+
+    :arg walker: the treewalker to use to walk the tree to convert it
+
+    :returns: generator of genshi nodes
+
+    """
+    text = []
+    for token in walker:
+        type = token["type"]
+        if type in ("Characters", "SpaceCharacters"):
+            text.append(token["data"])
+        elif text:
+            yield TEXT, "".join(text), (None, -1, -1)
+            text = []
+
+        if type in ("StartTag", "EmptyTag"):
+            if token["namespace"]:
+                name = "{%s}%s" % (token["namespace"], token["name"])
+            else:
+                name = token["name"]
+            attrs = Attrs([(QName("{%s}%s" % attr if attr[0] is not None else attr[1]), value)
+                           for attr, value in token["data"].items()])
+            yield (START, (QName(name), attrs), (None, -1, -1))
+            if type == "EmptyTag":
+                type = "EndTag"
+
+        if type == "EndTag":
+            if token["namespace"]:
+                name = "{%s}%s" % (token["namespace"], token["name"])
+            else:
+                name = token["name"]
+
+            yield END, QName(name), (None, -1, -1)
+
+        elif type == "Comment":
+            yield COMMENT, token["data"], (None, -1, -1)
+
+        elif type == "Doctype":
+            yield DOCTYPE, (token["name"], token["publicId"],
+                            token["systemId"]), (None, -1, -1)
+
+        else:
+            pass  # FIXME: What to do?
+
+    if text:
+        yield TEXT, "".join(text), (None, -1, -1)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treeadapters/sax.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treeadapters/sax.py
new file mode 100644
index 0000000..f4ccea5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treeadapters/sax.py
@@ -0,0 +1,50 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from xml.sax.xmlreader import AttributesNSImpl
+
+from ..constants import adjustForeignAttributes, unadjustForeignAttributes
+
+prefix_mapping = {}
+for prefix, localName, namespace in adjustForeignAttributes.values():
+    if prefix is not None:
+        prefix_mapping[prefix] = namespace
+
+
+def to_sax(walker, handler):
+    """Call SAX-like content handler based on treewalker walker
+
+    :arg walker: the treewalker to use to walk the tree to convert it
+
+    :arg handler: SAX handler to use
+
+    """
+    handler.startDocument()
+    for prefix, namespace in prefix_mapping.items():
+        handler.startPrefixMapping(prefix, namespace)
+
+    for token in walker:
+        type = token["type"]
+        if type == "Doctype":
+            continue
+        elif type in ("StartTag", "EmptyTag"):
+            attrs = AttributesNSImpl(token["data"],
+                                     unadjustForeignAttributes)
+            handler.startElementNS((token["namespace"], token["name"]),
+                                   token["name"],
+                                   attrs)
+            if type == "EmptyTag":
+                handler.endElementNS((token["namespace"], token["name"]),
+                                     token["name"])
+        elif type == "EndTag":
+            handler.endElementNS((token["namespace"], token["name"]),
+                                 token["name"])
+        elif type in ("Characters", "SpaceCharacters"):
+            handler.characters(token["data"])
+        elif type == "Comment":
+            pass
+        else:
+            assert False, "Unknown token type"
+
+    for prefix, namespace in prefix_mapping.items():
+        handler.endPrefixMapping(prefix)
+    handler.endDocument()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/__init__.py
new file mode 100644
index 0000000..d44447e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/__init__.py
@@ -0,0 +1,88 @@
+"""A collection of modules for building different kinds of trees from HTML
+documents.
+
+To create a treebuilder for a new type of tree, you need to do
+implement several things:
+
+1. A set of classes for various types of elements: Document, Doctype, Comment,
+   Element. These must implement the interface of ``base.treebuilders.Node``
+   (although comment nodes have a different signature for their constructor,
+   see ``treebuilders.etree.Comment``) Textual content may also be implemented
+   as another node type, or not, as your tree implementation requires.
+
+2. A treebuilder object (called ``TreeBuilder`` by convention) that inherits
+   from ``treebuilders.base.TreeBuilder``. This has 4 required attributes:
+
+   * ``documentClass`` - the class to use for the bottommost node of a document
+   * ``elementClass`` - the class to use for HTML Elements
+   * ``commentClass`` - the class to use for comments
+   * ``doctypeClass`` - the class to use for doctypes
+
+   It also has one required method:
+
+   * ``getDocument`` - Returns the root node of the complete document tree
+
+3. If you wish to run the unit tests, you must also create a ``testSerializer``
+   method on your treebuilder which accepts a node and returns a string
+   containing Node and its children serialized according to the format used in
+   the unittests
+
+"""
+
+from __future__ import absolute_import, division, unicode_literals
+
+from .._utils import default_etree
+
+treeBuilderCache = {}
+
+
+def getTreeBuilder(treeType, implementation=None, **kwargs):
+    """Get a TreeBuilder class for various types of trees with built-in support
+
+    :arg treeType: the name of the tree type required (case-insensitive). Supported
+        values are:
+
+        * "dom" - A generic builder for DOM implementations, defaulting to a
+          xml.dom.minidom based implementation.
+        * "etree" - A generic builder for tree implementations exposing an
+          ElementTree-like interface, defaulting to xml.etree.cElementTree if
+          available and xml.etree.ElementTree if not.
+        * "lxml" - A etree-based builder for lxml.etree, handling limitations
+          of lxml's implementation.
+
+    :arg implementation: (Currently applies to the "etree" and "dom" tree
+        types). A module implementing the tree type e.g. xml.etree.ElementTree
+        or xml.etree.cElementTree.
+
+    :arg kwargs: Any additional options to pass to the TreeBuilder when
+        creating it.
+
+    Example:
+
+    >>> from html5lib.treebuilders import getTreeBuilder
+    >>> builder = getTreeBuilder('etree')
+
+    """
+
+    treeType = treeType.lower()
+    if treeType not in treeBuilderCache:
+        if treeType == "dom":
+            from . import dom
+            # Come up with a sane default (pref. from the stdlib)
+            if implementation is None:
+                from xml.dom import minidom
+                implementation = minidom
+            # NEVER cache here, caching is done in the dom submodule
+            return dom.getDomModule(implementation, **kwargs).TreeBuilder
+        elif treeType == "lxml":
+            from . import etree_lxml
+            treeBuilderCache[treeType] = etree_lxml.TreeBuilder
+        elif treeType == "etree":
+            from . import etree
+            if implementation is None:
+                implementation = default_etree
+            # NEVER cache here, caching is done in the etree submodule
+            return etree.getETreeModule(implementation, **kwargs).TreeBuilder
+        else:
+            raise ValueError("""Unrecognised treebuilder "%s" """ % treeType)
+    return treeBuilderCache.get(treeType)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/base.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/base.py
new file mode 100644
index 0000000..965fce2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/base.py
@@ -0,0 +1,417 @@
+from __future__ import absolute_import, division, unicode_literals
+from pip._vendor.six import text_type
+
+from ..constants import scopingElements, tableInsertModeElements, namespaces
+
+# The scope markers are inserted when entering object elements,
+# marquees, table cells, and table captions, and are used to prevent formatting
+# from "leaking" into tables, object elements, and marquees.
+Marker = None
+
+listElementsMap = {
+    None: (frozenset(scopingElements), False),
+    "button": (frozenset(scopingElements | {(namespaces["html"], "button")}), False),
+    "list": (frozenset(scopingElements | {(namespaces["html"], "ol"),
+                                          (namespaces["html"], "ul")}), False),
+    "table": (frozenset([(namespaces["html"], "html"),
+                         (namespaces["html"], "table")]), False),
+    "select": (frozenset([(namespaces["html"], "optgroup"),
+                          (namespaces["html"], "option")]), True)
+}
+
+
+class Node(object):
+    """Represents an item in the tree"""
+    def __init__(self, name):
+        """Creates a Node
+
+        :arg name: The tag name associated with the node
+
+        """
+        # The tag name associated with the node
+        self.name = name
+        # The parent of the current node (or None for the document node)
+        self.parent = None
+        # The value of the current node (applies to text nodes and comments)
+        self.value = None
+        # A dict holding name -> value pairs for attributes of the node
+        self.attributes = {}
+        # A list of child nodes of the current node. This must include all
+        # elements but not necessarily other node types.
+        self.childNodes = []
+        # A list of miscellaneous flags that can be set on the node.
+        self._flags = []
+
+    def __str__(self):
+        attributesStr = " ".join(["%s=\"%s\"" % (name, value)
+                                  for name, value in
+                                  self.attributes.items()])
+        if attributesStr:
+            return "<%s %s>" % (self.name, attributesStr)
+        else:
+            return "<%s>" % (self.name)
+
+    def __repr__(self):
+        return "<%s>" % (self.name)
+
+    def appendChild(self, node):
+        """Insert node as a child of the current node
+
+        :arg node: the node to insert
+
+        """
+        raise NotImplementedError
+
+    def insertText(self, data, insertBefore=None):
+        """Insert data as text in the current node, positioned before the
+        start of node insertBefore or to the end of the node's text.
+
+        :arg data: the data to insert
+
+        :arg insertBefore: True if you want to insert the text before the node
+            and False if you want to insert it after the node
+
+        """
+        raise NotImplementedError
+
+    def insertBefore(self, node, refNode):
+        """Insert node as a child of the current node, before refNode in the
+        list of child nodes. Raises ValueError if refNode is not a child of
+        the current node
+
+        :arg node: the node to insert
+
+        :arg refNode: the child node to insert the node before
+
+        """
+        raise NotImplementedError
+
+    def removeChild(self, node):
+        """Remove node from the children of the current node
+
+        :arg node: the child node to remove
+
+        """
+        raise NotImplementedError
+
+    def reparentChildren(self, newParent):
+        """Move all the children of the current node to newParent.
+        This is needed so that trees that don't store text as nodes move the
+        text in the correct way
+
+        :arg newParent: the node to move all this node's children to
+
+        """
+        # XXX - should this method be made more general?
+        for child in self.childNodes:
+            newParent.appendChild(child)
+        self.childNodes = []
+
+    def cloneNode(self):
+        """Return a shallow copy of the current node i.e. a node with the same
+        name and attributes but with no parent or child nodes
+        """
+        raise NotImplementedError
+
+    def hasContent(self):
+        """Return true if the node has children or text, false otherwise
+        """
+        raise NotImplementedError
+
+
+class ActiveFormattingElements(list):
+    def append(self, node):
+        equalCount = 0
+        if node != Marker:
+            for element in self[::-1]:
+                if element == Marker:
+                    break
+                if self.nodesEqual(element, node):
+                    equalCount += 1
+                if equalCount == 3:
+                    self.remove(element)
+                    break
+        list.append(self, node)
+
+    def nodesEqual(self, node1, node2):
+        if not node1.nameTuple == node2.nameTuple:
+            return False
+
+        if not node1.attributes == node2.attributes:
+            return False
+
+        return True
+
+
+class TreeBuilder(object):
+    """Base treebuilder implementation
+
+    * documentClass - the class to use for the bottommost node of a document
+    * elementClass - the class to use for HTML Elements
+    * commentClass - the class to use for comments
+    * doctypeClass - the class to use for doctypes
+
+    """
+    # pylint:disable=not-callable
+
+    # Document class
+    documentClass = None
+
+    # The class to use for creating a node
+    elementClass = None
+
+    # The class to use for creating comments
+    commentClass = None
+
+    # The class to use for creating doctypes
+    doctypeClass = None
+
+    # Fragment class
+    fragmentClass = None
+
+    def __init__(self, namespaceHTMLElements):
+        """Create a TreeBuilder
+
+        :arg namespaceHTMLElements: whether or not to namespace HTML elements
+
+        """
+        if namespaceHTMLElements:
+            self.defaultNamespace = "http://www.w3.org/1999/xhtml"
+        else:
+            self.defaultNamespace = None
+        self.reset()
+
+    def reset(self):
+        self.openElements = []
+        self.activeFormattingElements = ActiveFormattingElements()
+
+        # XXX - rename these to headElement, formElement
+        self.headPointer = None
+        self.formPointer = None
+
+        self.insertFromTable = False
+
+        self.document = self.documentClass()
+
+    def elementInScope(self, target, variant=None):
+
+        # If we pass a node in we match that. if we pass a string
+        # match any node with that name
+        exactNode = hasattr(target, "nameTuple")
+        if not exactNode:
+            if isinstance(target, text_type):
+                target = (namespaces["html"], target)
+            assert isinstance(target, tuple)
+
+        listElements, invert = listElementsMap[variant]
+
+        for node in reversed(self.openElements):
+            if exactNode and node == target:
+                return True
+            elif not exactNode and node.nameTuple == target:
+                return True
+            elif (invert ^ (node.nameTuple in listElements)):
+                return False
+
+        assert False  # We should never reach this point
+
+    def reconstructActiveFormattingElements(self):
+        # Within this algorithm the order of steps described in the
+        # specification is not quite the same as the order of steps in the
+        # code. It should still do the same though.
+
+        # Step 1: stop the algorithm when there's nothing to do.
+        if not self.activeFormattingElements:
+            return
+
+        # Step 2 and step 3: we start with the last element. So i is -1.
+        i = len(self.activeFormattingElements) - 1
+        entry = self.activeFormattingElements[i]
+        if entry == Marker or entry in self.openElements:
+            return
+
+        # Step 6
+        while entry != Marker and entry not in self.openElements:
+            if i == 0:
+                # This will be reset to 0 below
+                i = -1
+                break
+            i -= 1
+            # Step 5: let entry be one earlier in the list.
+            entry = self.activeFormattingElements[i]
+
+        while True:
+            # Step 7
+            i += 1
+
+            # Step 8
+            entry = self.activeFormattingElements[i]
+            clone = entry.cloneNode()  # Mainly to get a new copy of the attributes
+
+            # Step 9
+            element = self.insertElement({"type": "StartTag",
+                                          "name": clone.name,
+                                          "namespace": clone.namespace,
+                                          "data": clone.attributes})
+
+            # Step 10
+            self.activeFormattingElements[i] = element
+
+            # Step 11
+            if element == self.activeFormattingElements[-1]:
+                break
+
+    def clearActiveFormattingElements(self):
+        entry = self.activeFormattingElements.pop()
+        while self.activeFormattingElements and entry != Marker:
+            entry = self.activeFormattingElements.pop()
+
+    def elementInActiveFormattingElements(self, name):
+        """Check if an element exists between the end of the active
+        formatting elements and the last marker. If it does, return it, else
+        return false"""
+
+        for item in self.activeFormattingElements[::-1]:
+            # Check for Marker first because if it's a Marker it doesn't have a
+            # name attribute.
+            if item == Marker:
+                break
+            elif item.name == name:
+                return item
+        return False
+
+    def insertRoot(self, token):
+        element = self.createElement(token)
+        self.openElements.append(element)
+        self.document.appendChild(element)
+
+    def insertDoctype(self, token):
+        name = token["name"]
+        publicId = token["publicId"]
+        systemId = token["systemId"]
+
+        doctype = self.doctypeClass(name, publicId, systemId)
+        self.document.appendChild(doctype)
+
+    def insertComment(self, token, parent=None):
+        if parent is None:
+            parent = self.openElements[-1]
+        parent.appendChild(self.commentClass(token["data"]))
+
+    def createElement(self, token):
+        """Create an element but don't insert it anywhere"""
+        name = token["name"]
+        namespace = token.get("namespace", self.defaultNamespace)
+        element = self.elementClass(name, namespace)
+        element.attributes = token["data"]
+        return element
+
+    def _getInsertFromTable(self):
+        return self._insertFromTable
+
+    def _setInsertFromTable(self, value):
+        """Switch the function used to insert an element from the
+        normal one to the misnested table one and back again"""
+        self._insertFromTable = value
+        if value:
+            self.insertElement = self.insertElementTable
+        else:
+            self.insertElement = self.insertElementNormal
+
+    insertFromTable = property(_getInsertFromTable, _setInsertFromTable)
+
+    def insertElementNormal(self, token):
+        name = token["name"]
+        assert isinstance(name, text_type), "Element %s not unicode" % name
+        namespace = token.get("namespace", self.defaultNamespace)
+        element = self.elementClass(name, namespace)
+        element.attributes = token["data"]
+        self.openElements[-1].appendChild(element)
+        self.openElements.append(element)
+        return element
+
+    def insertElementTable(self, token):
+        """Create an element and insert it into the tree"""
+        element = self.createElement(token)
+        if self.openElements[-1].name not in tableInsertModeElements:
+            return self.insertElementNormal(token)
+        else:
+            # We should be in the InTable mode. This means we want to do
+            # special magic element rearranging
+            parent, insertBefore = self.getTableMisnestedNodePosition()
+            if insertBefore is None:
+                parent.appendChild(element)
+            else:
+                parent.insertBefore(element, insertBefore)
+            self.openElements.append(element)
+        return element
+
+    def insertText(self, data, parent=None):
+        """Insert text data."""
+        if parent is None:
+            parent = self.openElements[-1]
+
+        if (not self.insertFromTable or (self.insertFromTable and
+                                         self.openElements[-1].name
+                                         not in tableInsertModeElements)):
+            parent.insertText(data)
+        else:
+            # We should be in the InTable mode. This means we want to do
+            # special magic element rearranging
+            parent, insertBefore = self.getTableMisnestedNodePosition()
+            parent.insertText(data, insertBefore)
+
+    def getTableMisnestedNodePosition(self):
+        """Get the foster parent element, and sibling to insert before
+        (or None) when inserting a misnested table node"""
+        # The foster parent element is the one which comes before the most
+        # recently opened table element
+        # XXX - this is really inelegant
+        lastTable = None
+        fosterParent = None
+        insertBefore = None
+        for elm in self.openElements[::-1]:
+            if elm.name == "table":
+                lastTable = elm
+                break
+        if lastTable:
+            # XXX - we should really check that this parent is actually a
+            # node here
+            if lastTable.parent:
+                fosterParent = lastTable.parent
+                insertBefore = lastTable
+            else:
+                fosterParent = self.openElements[
+                    self.openElements.index(lastTable) - 1]
+        else:
+            fosterParent = self.openElements[0]
+        return fosterParent, insertBefore
+
+    def generateImpliedEndTags(self, exclude=None):
+        name = self.openElements[-1].name
+        # XXX td, th and tr are not actually needed
+        if (name in frozenset(("dd", "dt", "li", "option", "optgroup", "p", "rp", "rt")) and
+                name != exclude):
+            self.openElements.pop()
+            # XXX This is not entirely what the specification says. We should
+            # investigate it more closely.
+            self.generateImpliedEndTags(exclude)
+
+    def getDocument(self):
+        """Return the final tree"""
+        return self.document
+
+    def getFragment(self):
+        """Return the final fragment"""
+        # assert self.innerHTML
+        fragment = self.fragmentClass()
+        self.openElements[0].reparentChildren(fragment)
+        return fragment
+
+    def testSerializer(self, node):
+        """Serialize the subtree of node in the format required by unit tests
+
+        :arg node: the node from which to start serializing
+
+        """
+        raise NotImplementedError
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/dom.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/dom.py
new file mode 100644
index 0000000..d8b5300
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/dom.py
@@ -0,0 +1,239 @@
+from __future__ import absolute_import, division, unicode_literals
+
+
+try:
+    from collections.abc import MutableMapping
+except ImportError:  # Python 2.7
+    from collections import MutableMapping
+from xml.dom import minidom, Node
+import weakref
+
+from . import base
+from .. import constants
+from ..constants import namespaces
+from .._utils import moduleFactoryFactory
+
+
+def getDomBuilder(DomImplementation):
+    Dom = DomImplementation
+
+    class AttrList(MutableMapping):
+        def __init__(self, element):
+            self.element = element
+
+        def __iter__(self):
+            return iter(self.element.attributes.keys())
+
+        def __setitem__(self, name, value):
+            if isinstance(name, tuple):
+                raise NotImplementedError
+            else:
+                attr = self.element.ownerDocument.createAttribute(name)
+                attr.value = value
+                self.element.attributes[name] = attr
+
+        def __len__(self):
+            return len(self.element.attributes)
+
+        def items(self):
+            return list(self.element.attributes.items())
+
+        def values(self):
+            return list(self.element.attributes.values())
+
+        def __getitem__(self, name):
+            if isinstance(name, tuple):
+                raise NotImplementedError
+            else:
+                return self.element.attributes[name].value
+
+        def __delitem__(self, name):
+            if isinstance(name, tuple):
+                raise NotImplementedError
+            else:
+                del self.element.attributes[name]
+
+    class NodeBuilder(base.Node):
+        def __init__(self, element):
+            base.Node.__init__(self, element.nodeName)
+            self.element = element
+
+        namespace = property(lambda self: hasattr(self.element, "namespaceURI") and
+                             self.element.namespaceURI or None)
+
+        def appendChild(self, node):
+            node.parent = self
+            self.element.appendChild(node.element)
+
+        def insertText(self, data, insertBefore=None):
+            text = self.element.ownerDocument.createTextNode(data)
+            if insertBefore:
+                self.element.insertBefore(text, insertBefore.element)
+            else:
+                self.element.appendChild(text)
+
+        def insertBefore(self, node, refNode):
+            self.element.insertBefore(node.element, refNode.element)
+            node.parent = self
+
+        def removeChild(self, node):
+            if node.element.parentNode == self.element:
+                self.element.removeChild(node.element)
+            node.parent = None
+
+        def reparentChildren(self, newParent):
+            while self.element.hasChildNodes():
+                child = self.element.firstChild
+                self.element.removeChild(child)
+                newParent.element.appendChild(child)
+            self.childNodes = []
+
+        def getAttributes(self):
+            return AttrList(self.element)
+
+        def setAttributes(self, attributes):
+            if attributes:
+                for name, value in list(attributes.items()):
+                    if isinstance(name, tuple):
+                        if name[0] is not None:
+                            qualifiedName = (name[0] + ":" + name[1])
+                        else:
+                            qualifiedName = name[1]
+                        self.element.setAttributeNS(name[2], qualifiedName,
+                                                    value)
+                    else:
+                        self.element.setAttribute(
+                            name, value)
+        attributes = property(getAttributes, setAttributes)
+
+        def cloneNode(self):
+            return NodeBuilder(self.element.cloneNode(False))
+
+        def hasContent(self):
+            return self.element.hasChildNodes()
+
+        def getNameTuple(self):
+            if self.namespace is None:
+                return namespaces["html"], self.name
+            else:
+                return self.namespace, self.name
+
+        nameTuple = property(getNameTuple)
+
+    class TreeBuilder(base.TreeBuilder):  # pylint:disable=unused-variable
+        def documentClass(self):
+            self.dom = Dom.getDOMImplementation().createDocument(None, None, None)
+            return weakref.proxy(self)
+
+        def insertDoctype(self, token):
+            name = token["name"]
+            publicId = token["publicId"]
+            systemId = token["systemId"]
+
+            domimpl = Dom.getDOMImplementation()
+            doctype = domimpl.createDocumentType(name, publicId, systemId)
+            self.document.appendChild(NodeBuilder(doctype))
+            if Dom == minidom:
+                doctype.ownerDocument = self.dom
+
+        def elementClass(self, name, namespace=None):
+            if namespace is None and self.defaultNamespace is None:
+                node = self.dom.createElement(name)
+            else:
+                node = self.dom.createElementNS(namespace, name)
+
+            return NodeBuilder(node)
+
+        def commentClass(self, data):
+            return NodeBuilder(self.dom.createComment(data))
+
+        def fragmentClass(self):
+            return NodeBuilder(self.dom.createDocumentFragment())
+
+        def appendChild(self, node):
+            self.dom.appendChild(node.element)
+
+        def testSerializer(self, element):
+            return testSerializer(element)
+
+        def getDocument(self):
+            return self.dom
+
+        def getFragment(self):
+            return base.TreeBuilder.getFragment(self).element
+
+        def insertText(self, data, parent=None):
+            data = data
+            if parent != self:
+                base.TreeBuilder.insertText(self, data, parent)
+            else:
+                # HACK: allow text nodes as children of the document node
+                if hasattr(self.dom, '_child_node_types'):
+                    # pylint:disable=protected-access
+                    if Node.TEXT_NODE not in self.dom._child_node_types:
+                        self.dom._child_node_types = list(self.dom._child_node_types)
+                        self.dom._child_node_types.append(Node.TEXT_NODE)
+                self.dom.appendChild(self.dom.createTextNode(data))
+
+        implementation = DomImplementation
+        name = None
+
+    def testSerializer(element):
+        element.normalize()
+        rv = []
+
+        def serializeElement(element, indent=0):
+            if element.nodeType == Node.DOCUMENT_TYPE_NODE:
+                if element.name:
+                    if element.publicId or element.systemId:
+                        publicId = element.publicId or ""
+                        systemId = element.systemId or ""
+                        rv.append("""|%s<!DOCTYPE %s "%s" "%s">""" %
+                                  (' ' * indent, element.name, publicId, systemId))
+                    else:
+                        rv.append("|%s<!DOCTYPE %s>" % (' ' * indent, element.name))
+                else:
+                    rv.append("|%s<!DOCTYPE >" % (' ' * indent,))
+            elif element.nodeType == Node.DOCUMENT_NODE:
+                rv.append("#document")
+            elif element.nodeType == Node.DOCUMENT_FRAGMENT_NODE:
+                rv.append("#document-fragment")
+            elif element.nodeType == Node.COMMENT_NODE:
+                rv.append("|%s<!-- %s -->" % (' ' * indent, element.nodeValue))
+            elif element.nodeType == Node.TEXT_NODE:
+                rv.append("|%s\"%s\"" % (' ' * indent, element.nodeValue))
+            else:
+                if (hasattr(element, "namespaceURI") and
+                        element.namespaceURI is not None):
+                    name = "%s %s" % (constants.prefixes[element.namespaceURI],
+                                      element.nodeName)
+                else:
+                    name = element.nodeName
+                rv.append("|%s<%s>" % (' ' * indent, name))
+                if element.hasAttributes():
+                    attributes = []
+                    for i in range(len(element.attributes)):
+                        attr = element.attributes.item(i)
+                        name = attr.nodeName
+                        value = attr.value
+                        ns = attr.namespaceURI
+                        if ns:
+                            name = "%s %s" % (constants.prefixes[ns], attr.localName)
+                        else:
+                            name = attr.nodeName
+                        attributes.append((name, value))
+
+                    for name, value in sorted(attributes):
+                        rv.append('|%s%s="%s"' % (' ' * (indent + 2), name, value))
+            indent += 2
+            for child in element.childNodes:
+                serializeElement(child, indent)
+        serializeElement(element, 0)
+
+        return "\n".join(rv)
+
+    return locals()
+
+
+# The actual means to get a module!
+getDomModule = moduleFactoryFactory(getDomBuilder)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/etree.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/etree.py
new file mode 100644
index 0000000..ea92dc3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/etree.py
@@ -0,0 +1,343 @@
+from __future__ import absolute_import, division, unicode_literals
+# pylint:disable=protected-access
+
+from pip._vendor.six import text_type
+
+import re
+
+from copy import copy
+
+from . import base
+from .. import _ihatexml
+from .. import constants
+from ..constants import namespaces
+from .._utils import moduleFactoryFactory
+
+tag_regexp = re.compile("{([^}]*)}(.*)")
+
+
+def getETreeBuilder(ElementTreeImplementation, fullTree=False):
+    ElementTree = ElementTreeImplementation
+    ElementTreeCommentType = ElementTree.Comment("asd").tag
+
+    class Element(base.Node):
+        def __init__(self, name, namespace=None):
+            self._name = name
+            self._namespace = namespace
+            self._element = ElementTree.Element(self._getETreeTag(name,
+                                                                  namespace))
+            if namespace is None:
+                self.nameTuple = namespaces["html"], self._name
+            else:
+                self.nameTuple = self._namespace, self._name
+            self.parent = None
+            self._childNodes = []
+            self._flags = []
+
+        def _getETreeTag(self, name, namespace):
+            if namespace is None:
+                etree_tag = name
+            else:
+                etree_tag = "{%s}%s" % (namespace, name)
+            return etree_tag
+
+        def _setName(self, name):
+            self._name = name
+            self._element.tag = self._getETreeTag(self._name, self._namespace)
+
+        def _getName(self):
+            return self._name
+
+        name = property(_getName, _setName)
+
+        def _setNamespace(self, namespace):
+            self._namespace = namespace
+            self._element.tag = self._getETreeTag(self._name, self._namespace)
+
+        def _getNamespace(self):
+            return self._namespace
+
+        namespace = property(_getNamespace, _setNamespace)
+
+        def _getAttributes(self):
+            return self._element.attrib
+
+        def _setAttributes(self, attributes):
+            el_attrib = self._element.attrib
+            el_attrib.clear()
+            if attributes:
+                # calling .items _always_ allocates, and the above truthy check is cheaper than the
+                # allocation on average
+                for key, value in attributes.items():
+                    if isinstance(key, tuple):
+                        name = "{%s}%s" % (key[2], key[1])
+                    else:
+                        name = key
+                    el_attrib[name] = value
+
+        attributes = property(_getAttributes, _setAttributes)
+
+        def _getChildNodes(self):
+            return self._childNodes
+
+        def _setChildNodes(self, value):
+            del self._element[:]
+            self._childNodes = []
+            for element in value:
+                self.insertChild(element)
+
+        childNodes = property(_getChildNodes, _setChildNodes)
+
+        def hasContent(self):
+            """Return true if the node has children or text"""
+            return bool(self._element.text or len(self._element))
+
+        def appendChild(self, node):
+            self._childNodes.append(node)
+            self._element.append(node._element)
+            node.parent = self
+
+        def insertBefore(self, node, refNode):
+            index = list(self._element).index(refNode._element)
+            self._element.insert(index, node._element)
+            node.parent = self
+
+        def removeChild(self, node):
+            self._childNodes.remove(node)
+            self._element.remove(node._element)
+            node.parent = None
+
+        def insertText(self, data, insertBefore=None):
+            if not(len(self._element)):
+                if not self._element.text:
+                    self._element.text = ""
+                self._element.text += data
+            elif insertBefore is None:
+                # Insert the text as the tail of the last child element
+                if not self._element[-1].tail:
+                    self._element[-1].tail = ""
+                self._element[-1].tail += data
+            else:
+                # Insert the text before the specified node
+                children = list(self._element)
+                index = children.index(insertBefore._element)
+                if index > 0:
+                    if not self._element[index - 1].tail:
+                        self._element[index - 1].tail = ""
+                    self._element[index - 1].tail += data
+                else:
+                    if not self._element.text:
+                        self._element.text = ""
+                    self._element.text += data
+
+        def cloneNode(self):
+            element = type(self)(self.name, self.namespace)
+            if self._element.attrib:
+                element._element.attrib = copy(self._element.attrib)
+            return element
+
+        def reparentChildren(self, newParent):
+            if newParent.childNodes:
+                newParent.childNodes[-1]._element.tail += self._element.text
+            else:
+                if not newParent._element.text:
+                    newParent._element.text = ""
+                if self._element.text is not None:
+                    newParent._element.text += self._element.text
+            self._element.text = ""
+            base.Node.reparentChildren(self, newParent)
+
+    class Comment(Element):
+        def __init__(self, data):
+            # Use the superclass constructor to set all properties on the
+            # wrapper element
+            self._element = ElementTree.Comment(data)
+            self.parent = None
+            self._childNodes = []
+            self._flags = []
+
+        def _getData(self):
+            return self._element.text
+
+        def _setData(self, value):
+            self._element.text = value
+
+        data = property(_getData, _setData)
+
+    class DocumentType(Element):
+        def __init__(self, name, publicId, systemId):
+            Element.__init__(self, "<!DOCTYPE>")
+            self._element.text = name
+            self.publicId = publicId
+            self.systemId = systemId
+
+        def _getPublicId(self):
+            return self._element.get("publicId", "")
+
+        def _setPublicId(self, value):
+            if value is not None:
+                self._element.set("publicId", value)
+
+        publicId = property(_getPublicId, _setPublicId)
+
+        def _getSystemId(self):
+            return self._element.get("systemId", "")
+
+        def _setSystemId(self, value):
+            if value is not None:
+                self._element.set("systemId", value)
+
+        systemId = property(_getSystemId, _setSystemId)
+
+    class Document(Element):
+        def __init__(self):
+            Element.__init__(self, "DOCUMENT_ROOT")
+
+    class DocumentFragment(Element):
+        def __init__(self):
+            Element.__init__(self, "DOCUMENT_FRAGMENT")
+
+    def testSerializer(element):
+        rv = []
+
+        def serializeElement(element, indent=0):
+            if not(hasattr(element, "tag")):
+                element = element.getroot()
+            if element.tag == "<!DOCTYPE>":
+                if element.get("publicId") or element.get("systemId"):
+                    publicId = element.get("publicId") or ""
+                    systemId = element.get("systemId") or ""
+                    rv.append("""<!DOCTYPE %s "%s" "%s">""" %
+                              (element.text, publicId, systemId))
+                else:
+                    rv.append("<!DOCTYPE %s>" % (element.text,))
+            elif element.tag == "DOCUMENT_ROOT":
+                rv.append("#document")
+                if element.text is not None:
+                    rv.append("|%s\"%s\"" % (' ' * (indent + 2), element.text))
+                if element.tail is not None:
+                    raise TypeError("Document node cannot have tail")
+                if hasattr(element, "attrib") and len(element.attrib):
+                    raise TypeError("Document node cannot have attributes")
+            elif element.tag == ElementTreeCommentType:
+                rv.append("|%s<!-- %s -->" % (' ' * indent, element.text))
+            else:
+                assert isinstance(element.tag, text_type), \
+                    "Expected unicode, got %s, %s" % (type(element.tag), element.tag)
+                nsmatch = tag_regexp.match(element.tag)
+
+                if nsmatch is None:
+                    name = element.tag
+                else:
+                    ns, name = nsmatch.groups()
+                    prefix = constants.prefixes[ns]
+                    name = "%s %s" % (prefix, name)
+                rv.append("|%s<%s>" % (' ' * indent, name))
+
+                if hasattr(element, "attrib"):
+                    attributes = []
+                    for name, value in element.attrib.items():
+                        nsmatch = tag_regexp.match(name)
+                        if nsmatch is not None:
+                            ns, name = nsmatch.groups()
+                            prefix = constants.prefixes[ns]
+                            attr_string = "%s %s" % (prefix, name)
+                        else:
+                            attr_string = name
+                        attributes.append((attr_string, value))
+
+                    for name, value in sorted(attributes):
+                        rv.append('|%s%s="%s"' % (' ' * (indent + 2), name, value))
+                if element.text:
+                    rv.append("|%s\"%s\"" % (' ' * (indent + 2), element.text))
+            indent += 2
+            for child in element:
+                serializeElement(child, indent)
+            if element.tail:
+                rv.append("|%s\"%s\"" % (' ' * (indent - 2), element.tail))
+        serializeElement(element, 0)
+
+        return "\n".join(rv)
+
+    def tostring(element):  # pylint:disable=unused-variable
+        """Serialize an element and its child nodes to a string"""
+        rv = []
+        filter = _ihatexml.InfosetFilter()
+
+        def serializeElement(element):
+            if isinstance(element, ElementTree.ElementTree):
+                element = element.getroot()
+
+            if element.tag == "<!DOCTYPE>":
+                if element.get("publicId") or element.get("systemId"):
+                    publicId = element.get("publicId") or ""
+                    systemId = element.get("systemId") or ""
+                    rv.append("""<!DOCTYPE %s PUBLIC "%s" "%s">""" %
+                              (element.text, publicId, systemId))
+                else:
+                    rv.append("<!DOCTYPE %s>" % (element.text,))
+            elif element.tag == "DOCUMENT_ROOT":
+                if element.text is not None:
+                    rv.append(element.text)
+                if element.tail is not None:
+                    raise TypeError("Document node cannot have tail")
+                if hasattr(element, "attrib") and len(element.attrib):
+                    raise TypeError("Document node cannot have attributes")
+
+                for child in element:
+                    serializeElement(child)
+
+            elif element.tag == ElementTreeCommentType:
+                rv.append("<!--%s-->" % (element.text,))
+            else:
+                # This is assumed to be an ordinary element
+                if not element.attrib:
+                    rv.append("<%s>" % (filter.fromXmlName(element.tag),))
+                else:
+                    attr = " ".join(["%s=\"%s\"" % (
+                        filter.fromXmlName(name), value)
+                        for name, value in element.attrib.items()])
+                    rv.append("<%s %s>" % (element.tag, attr))
+                if element.text:
+                    rv.append(element.text)
+
+                for child in element:
+                    serializeElement(child)
+
+                rv.append("</%s>" % (element.tag,))
+
+            if element.tail:
+                rv.append(element.tail)
+
+        serializeElement(element)
+
+        return "".join(rv)
+
+    class TreeBuilder(base.TreeBuilder):  # pylint:disable=unused-variable
+        documentClass = Document
+        doctypeClass = DocumentType
+        elementClass = Element
+        commentClass = Comment
+        fragmentClass = DocumentFragment
+        implementation = ElementTreeImplementation
+
+        def testSerializer(self, element):
+            return testSerializer(element)
+
+        def getDocument(self):
+            if fullTree:
+                return self.document._element
+            else:
+                if self.defaultNamespace is not None:
+                    return self.document._element.find(
+                        "{%s}html" % self.defaultNamespace)
+                else:
+                    return self.document._element.find("html")
+
+        def getFragment(self):
+            return base.TreeBuilder.getFragment(self)._element
+
+    return locals()
+
+
+getETreeModule = moduleFactoryFactory(getETreeBuilder)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/etree_lxml.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/etree_lxml.py
new file mode 100644
index 0000000..f037759
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treebuilders/etree_lxml.py
@@ -0,0 +1,392 @@
+"""Module for supporting the lxml.etree library. The idea here is to use as much
+of the native library as possible, without using fragile hacks like custom element
+names that break between releases. The downside of this is that we cannot represent
+all possible trees; specifically the following are known to cause problems:
+
+Text or comments as siblings of the root element
+Docypes with no name
+
+When any of these things occur, we emit a DataLossWarning
+"""
+
+from __future__ import absolute_import, division, unicode_literals
+# pylint:disable=protected-access
+
+import warnings
+import re
+import sys
+
+try:
+    from collections.abc import MutableMapping
+except ImportError:
+    from collections import MutableMapping
+
+from . import base
+from ..constants import DataLossWarning
+from .. import constants
+from . import etree as etree_builders
+from .. import _ihatexml
+
+import lxml.etree as etree
+from pip._vendor.six import PY3, binary_type
+
+
+fullTree = True
+tag_regexp = re.compile("{([^}]*)}(.*)")
+
+comment_type = etree.Comment("asd").tag
+
+
+class DocumentType(object):
+    def __init__(self, name, publicId, systemId):
+        self.name = name
+        self.publicId = publicId
+        self.systemId = systemId
+
+
+class Document(object):
+    def __init__(self):
+        self._elementTree = None
+        self._childNodes = []
+
+    def appendChild(self, element):
+        last = self._elementTree.getroot()
+        for last in self._elementTree.getroot().itersiblings():
+            pass
+
+        last.addnext(element._element)
+
+    def _getChildNodes(self):
+        return self._childNodes
+
+    childNodes = property(_getChildNodes)
+
+
+def testSerializer(element):
+    rv = []
+    infosetFilter = _ihatexml.InfosetFilter(preventDoubleDashComments=True)
+
+    def serializeElement(element, indent=0):
+        if not hasattr(element, "tag"):
+            if hasattr(element, "getroot"):
+                # Full tree case
+                rv.append("#document")
+                if element.docinfo.internalDTD:
+                    if not (element.docinfo.public_id or
+                            element.docinfo.system_url):
+                        dtd_str = "<!DOCTYPE %s>" % element.docinfo.root_name
+                    else:
+                        dtd_str = """<!DOCTYPE %s "%s" "%s">""" % (
+                            element.docinfo.root_name,
+                            element.docinfo.public_id,
+                            element.docinfo.system_url)
+                    rv.append("|%s%s" % (' ' * (indent + 2), dtd_str))
+                next_element = element.getroot()
+                while next_element.getprevious() is not None:
+                    next_element = next_element.getprevious()
+                while next_element is not None:
+                    serializeElement(next_element, indent + 2)
+                    next_element = next_element.getnext()
+            elif isinstance(element, str) or isinstance(element, bytes):
+                # Text in a fragment
+                assert isinstance(element, str) or sys.version_info[0] == 2
+                rv.append("|%s\"%s\"" % (' ' * indent, element))
+            else:
+                # Fragment case
+                rv.append("#document-fragment")
+                for next_element in element:
+                    serializeElement(next_element, indent + 2)
+        elif element.tag == comment_type:
+            rv.append("|%s<!-- %s -->" % (' ' * indent, element.text))
+            if hasattr(element, "tail") and element.tail:
+                rv.append("|%s\"%s\"" % (' ' * indent, element.tail))
+        else:
+            assert isinstance(element, etree._Element)
+            nsmatch = etree_builders.tag_regexp.match(element.tag)
+            if nsmatch is not None:
+                ns = nsmatch.group(1)
+                tag = nsmatch.group(2)
+                prefix = constants.prefixes[ns]
+                rv.append("|%s<%s %s>" % (' ' * indent, prefix,
+                                          infosetFilter.fromXmlName(tag)))
+            else:
+                rv.append("|%s<%s>" % (' ' * indent,
+                                       infosetFilter.fromXmlName(element.tag)))
+
+            if hasattr(element, "attrib"):
+                attributes = []
+                for name, value in element.attrib.items():
+                    nsmatch = tag_regexp.match(name)
+                    if nsmatch is not None:
+                        ns, name = nsmatch.groups()
+                        name = infosetFilter.fromXmlName(name)
+                        prefix = constants.prefixes[ns]
+                        attr_string = "%s %s" % (prefix, name)
+                    else:
+                        attr_string = infosetFilter.fromXmlName(name)
+                    attributes.append((attr_string, value))
+
+                for name, value in sorted(attributes):
+                    rv.append('|%s%s="%s"' % (' ' * (indent + 2), name, value))
+
+            if element.text:
+                rv.append("|%s\"%s\"" % (' ' * (indent + 2), element.text))
+            indent += 2
+            for child in element:
+                serializeElement(child, indent)
+            if hasattr(element, "tail") and element.tail:
+                rv.append("|%s\"%s\"" % (' ' * (indent - 2), element.tail))
+    serializeElement(element, 0)
+
+    return "\n".join(rv)
+
+
+def tostring(element):
+    """Serialize an element and its child nodes to a string"""
+    rv = []
+
+    def serializeElement(element):
+        if not hasattr(element, "tag"):
+            if element.docinfo.internalDTD:
+                if element.docinfo.doctype:
+                    dtd_str = element.docinfo.doctype
+                else:
+                    dtd_str = "<!DOCTYPE %s>" % element.docinfo.root_name
+                rv.append(dtd_str)
+            serializeElement(element.getroot())
+
+        elif element.tag == comment_type:
+            rv.append("<!--%s-->" % (element.text,))
+
+        else:
+            # This is assumed to be an ordinary element
+            if not element.attrib:
+                rv.append("<%s>" % (element.tag,))
+            else:
+                attr = " ".join(["%s=\"%s\"" % (name, value)
+                                 for name, value in element.attrib.items()])
+                rv.append("<%s %s>" % (element.tag, attr))
+            if element.text:
+                rv.append(element.text)
+
+            for child in element:
+                serializeElement(child)
+
+            rv.append("</%s>" % (element.tag,))
+
+        if hasattr(element, "tail") and element.tail:
+            rv.append(element.tail)
+
+    serializeElement(element)
+
+    return "".join(rv)
+
+
+class TreeBuilder(base.TreeBuilder):
+    documentClass = Document
+    doctypeClass = DocumentType
+    elementClass = None
+    commentClass = None
+    fragmentClass = Document
+    implementation = etree
+
+    def __init__(self, namespaceHTMLElements, fullTree=False):
+        builder = etree_builders.getETreeModule(etree, fullTree=fullTree)
+        infosetFilter = self.infosetFilter = _ihatexml.InfosetFilter(preventDoubleDashComments=True)
+        self.namespaceHTMLElements = namespaceHTMLElements
+
+        class Attributes(MutableMapping):
+            def __init__(self, element):
+                self._element = element
+
+            def _coerceKey(self, key):
+                if isinstance(key, tuple):
+                    name = "{%s}%s" % (key[2], infosetFilter.coerceAttribute(key[1]))
+                else:
+                    name = infosetFilter.coerceAttribute(key)
+                return name
+
+            def __getitem__(self, key):
+                value = self._element._element.attrib[self._coerceKey(key)]
+                if not PY3 and isinstance(value, binary_type):
+                    value = value.decode("ascii")
+                return value
+
+            def __setitem__(self, key, value):
+                self._element._element.attrib[self._coerceKey(key)] = value
+
+            def __delitem__(self, key):
+                del self._element._element.attrib[self._coerceKey(key)]
+
+            def __iter__(self):
+                return iter(self._element._element.attrib)
+
+            def __len__(self):
+                return len(self._element._element.attrib)
+
+            def clear(self):
+                return self._element._element.attrib.clear()
+
+        class Element(builder.Element):
+            def __init__(self, name, namespace):
+                name = infosetFilter.coerceElement(name)
+                builder.Element.__init__(self, name, namespace=namespace)
+                self._attributes = Attributes(self)
+
+            def _setName(self, name):
+                self._name = infosetFilter.coerceElement(name)
+                self._element.tag = self._getETreeTag(
+                    self._name, self._namespace)
+
+            def _getName(self):
+                return infosetFilter.fromXmlName(self._name)
+
+            name = property(_getName, _setName)
+
+            def _getAttributes(self):
+                return self._attributes
+
+            def _setAttributes(self, value):
+                attributes = self.attributes
+                attributes.clear()
+                attributes.update(value)
+
+            attributes = property(_getAttributes, _setAttributes)
+
+            def insertText(self, data, insertBefore=None):
+                data = infosetFilter.coerceCharacters(data)
+                builder.Element.insertText(self, data, insertBefore)
+
+            def cloneNode(self):
+                element = type(self)(self.name, self.namespace)
+                if self._element.attrib:
+                    element._element.attrib.update(self._element.attrib)
+                return element
+
+        class Comment(builder.Comment):
+            def __init__(self, data):
+                data = infosetFilter.coerceComment(data)
+                builder.Comment.__init__(self, data)
+
+            def _setData(self, data):
+                data = infosetFilter.coerceComment(data)
+                self._element.text = data
+
+            def _getData(self):
+                return self._element.text
+
+            data = property(_getData, _setData)
+
+        self.elementClass = Element
+        self.commentClass = Comment
+        # self.fragmentClass = builder.DocumentFragment
+        base.TreeBuilder.__init__(self, namespaceHTMLElements)
+
+    def reset(self):
+        base.TreeBuilder.reset(self)
+        self.insertComment = self.insertCommentInitial
+        self.initial_comments = []
+        self.doctype = None
+
+    def testSerializer(self, element):
+        return testSerializer(element)
+
+    def getDocument(self):
+        if fullTree:
+            return self.document._elementTree
+        else:
+            return self.document._elementTree.getroot()
+
+    def getFragment(self):
+        fragment = []
+        element = self.openElements[0]._element
+        if element.text:
+            fragment.append(element.text)
+        fragment.extend(list(element))
+        if element.tail:
+            fragment.append(element.tail)
+        return fragment
+
+    def insertDoctype(self, token):
+        name = token["name"]
+        publicId = token["publicId"]
+        systemId = token["systemId"]
+
+        if not name:
+            warnings.warn("lxml cannot represent empty doctype", DataLossWarning)
+            self.doctype = None
+        else:
+            coercedName = self.infosetFilter.coerceElement(name)
+            if coercedName != name:
+                warnings.warn("lxml cannot represent non-xml doctype", DataLossWarning)
+
+            doctype = self.doctypeClass(coercedName, publicId, systemId)
+            self.doctype = doctype
+
+    def insertCommentInitial(self, data, parent=None):
+        assert parent is None or parent is self.document
+        assert self.document._elementTree is None
+        self.initial_comments.append(data)
+
+    def insertCommentMain(self, data, parent=None):
+        if (parent == self.document and
+                self.document._elementTree.getroot()[-1].tag == comment_type):
+            warnings.warn("lxml cannot represent adjacent comments beyond the root elements", DataLossWarning)
+        super(TreeBuilder, self).insertComment(data, parent)
+
+    def insertRoot(self, token):
+        # Because of the way libxml2 works, it doesn't seem to be possible to
+        # alter information like the doctype after the tree has been parsed.
+        # Therefore we need to use the built-in parser to create our initial
+        # tree, after which we can add elements like normal
+        docStr = ""
+        if self.doctype:
+            assert self.doctype.name
+            docStr += "<!DOCTYPE %s" % self.doctype.name
+            if (self.doctype.publicId is not None or
+                    self.doctype.systemId is not None):
+                docStr += (' PUBLIC "%s" ' %
+                           (self.infosetFilter.coercePubid(self.doctype.publicId or "")))
+                if self.doctype.systemId:
+                    sysid = self.doctype.systemId
+                    if sysid.find("'") >= 0 and sysid.find('"') >= 0:
+                        warnings.warn("DOCTYPE system cannot contain single and double quotes", DataLossWarning)
+                        sysid = sysid.replace("'", 'U00027')
+                    if sysid.find("'") >= 0:
+                        docStr += '"%s"' % sysid
+                    else:
+                        docStr += "'%s'" % sysid
+                else:
+                    docStr += "''"
+            docStr += ">"
+            if self.doctype.name != token["name"]:
+                warnings.warn("lxml cannot represent doctype with a different name to the root element", DataLossWarning)
+        docStr += "<THIS_SHOULD_NEVER_APPEAR_PUBLICLY/>"
+        root = etree.fromstring(docStr)
+
+        # Append the initial comments:
+        for comment_token in self.initial_comments:
+            comment = self.commentClass(comment_token["data"])
+            root.addprevious(comment._element)
+
+        # Create the root document and add the ElementTree to it
+        self.document = self.documentClass()
+        self.document._elementTree = root.getroottree()
+
+        # Give the root element the right name
+        name = token["name"]
+        namespace = token.get("namespace", self.defaultNamespace)
+        if namespace is None:
+            etree_tag = name
+        else:
+            etree_tag = "{%s}%s" % (namespace, name)
+        root.tag = etree_tag
+
+        # Add the root element to the internal child/open data structures
+        root_element = self.elementClass(name, namespace)
+        root_element._element = root
+        self.document._childNodes.append(root_element)
+        self.openElements.append(root_element)
+
+        # Reset to the default insert comment function
+        self.insertComment = self.insertCommentMain
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/__init__.py
new file mode 100644
index 0000000..b2d3aac
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/__init__.py
@@ -0,0 +1,154 @@
+"""A collection of modules for iterating through different kinds of
+tree, generating tokens identical to those produced by the tokenizer
+module.
+
+To create a tree walker for a new type of tree, you need to
+implement a tree walker object (called TreeWalker by convention) that
+implements a 'serialize' method which takes a tree as sole argument and
+returns an iterator which generates tokens.
+"""
+
+from __future__ import absolute_import, division, unicode_literals
+
+from .. import constants
+from .._utils import default_etree
+
+__all__ = ["getTreeWalker", "pprint"]
+
+treeWalkerCache = {}
+
+
+def getTreeWalker(treeType, implementation=None, **kwargs):
+    """Get a TreeWalker class for various types of tree with built-in support
+
+    :arg str treeType: the name of the tree type required (case-insensitive).
+        Supported values are:
+
+        * "dom": The xml.dom.minidom DOM implementation
+        * "etree": A generic walker for tree implementations exposing an
+          elementtree-like interface (known to work with ElementTree,
+          cElementTree and lxml.etree).
+        * "lxml": Optimized walker for lxml.etree
+        * "genshi": a Genshi stream
+
+    :arg implementation: A module implementing the tree type e.g.
+        xml.etree.ElementTree or cElementTree (Currently applies to the "etree"
+        tree type only).
+
+    :arg kwargs: keyword arguments passed to the etree walker--for other
+        walkers, this has no effect
+
+    :returns: a TreeWalker class
+
+    """
+
+    treeType = treeType.lower()
+    if treeType not in treeWalkerCache:
+        if treeType == "dom":
+            from . import dom
+            treeWalkerCache[treeType] = dom.TreeWalker
+        elif treeType == "genshi":
+            from . import genshi
+            treeWalkerCache[treeType] = genshi.TreeWalker
+        elif treeType == "lxml":
+            from . import etree_lxml
+            treeWalkerCache[treeType] = etree_lxml.TreeWalker
+        elif treeType == "etree":
+            from . import etree
+            if implementation is None:
+                implementation = default_etree
+            # XXX: NEVER cache here, caching is done in the etree submodule
+            return etree.getETreeModule(implementation, **kwargs).TreeWalker
+    return treeWalkerCache.get(treeType)
+
+
+def concatenateCharacterTokens(tokens):
+    pendingCharacters = []
+    for token in tokens:
+        type = token["type"]
+        if type in ("Characters", "SpaceCharacters"):
+            pendingCharacters.append(token["data"])
+        else:
+            if pendingCharacters:
+                yield {"type": "Characters", "data": "".join(pendingCharacters)}
+                pendingCharacters = []
+            yield token
+    if pendingCharacters:
+        yield {"type": "Characters", "data": "".join(pendingCharacters)}
+
+
+def pprint(walker):
+    """Pretty printer for tree walkers
+
+    Takes a TreeWalker instance and pretty prints the output of walking the tree.
+
+    :arg walker: a TreeWalker instance
+
+    """
+    output = []
+    indent = 0
+    for token in concatenateCharacterTokens(walker):
+        type = token["type"]
+        if type in ("StartTag", "EmptyTag"):
+            # tag name
+            if token["namespace"] and token["namespace"] != constants.namespaces["html"]:
+                if token["namespace"] in constants.prefixes:
+                    ns = constants.prefixes[token["namespace"]]
+                else:
+                    ns = token["namespace"]
+                name = "%s %s" % (ns, token["name"])
+            else:
+                name = token["name"]
+            output.append("%s<%s>" % (" " * indent, name))
+            indent += 2
+            # attributes (sorted for consistent ordering)
+            attrs = token["data"]
+            for (namespace, localname), value in sorted(attrs.items()):
+                if namespace:
+                    if namespace in constants.prefixes:
+                        ns = constants.prefixes[namespace]
+                    else:
+                        ns = namespace
+                    name = "%s %s" % (ns, localname)
+                else:
+                    name = localname
+                output.append("%s%s=\"%s\"" % (" " * indent, name, value))
+            # self-closing
+            if type == "EmptyTag":
+                indent -= 2
+
+        elif type == "EndTag":
+            indent -= 2
+
+        elif type == "Comment":
+            output.append("%s<!-- %s -->" % (" " * indent, token["data"]))
+
+        elif type == "Doctype":
+            if token["name"]:
+                if token["publicId"]:
+                    output.append("""%s<!DOCTYPE %s "%s" "%s">""" %
+                                  (" " * indent,
+                                   token["name"],
+                                   token["publicId"],
+                                   token["systemId"] if token["systemId"] else ""))
+                elif token["systemId"]:
+                    output.append("""%s<!DOCTYPE %s "" "%s">""" %
+                                  (" " * indent,
+                                   token["name"],
+                                   token["systemId"]))
+                else:
+                    output.append("%s<!DOCTYPE %s>" % (" " * indent,
+                                                       token["name"]))
+            else:
+                output.append("%s<!DOCTYPE >" % (" " * indent,))
+
+        elif type == "Characters":
+            output.append("%s\"%s\"" % (" " * indent, token["data"]))
+
+        elif type == "SpaceCharacters":
+            assert False, "concatenateCharacterTokens should have got rid of all Space tokens"
+
+        else:
+            raise ValueError("Unknown token type, %s" % type)
+
+    return "\n".join(output)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/base.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/base.py
new file mode 100644
index 0000000..80c474c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/base.py
@@ -0,0 +1,252 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from xml.dom import Node
+from ..constants import namespaces, voidElements, spaceCharacters
+
+__all__ = ["DOCUMENT", "DOCTYPE", "TEXT", "ELEMENT", "COMMENT", "ENTITY", "UNKNOWN",
+           "TreeWalker", "NonRecursiveTreeWalker"]
+
+DOCUMENT = Node.DOCUMENT_NODE
+DOCTYPE = Node.DOCUMENT_TYPE_NODE
+TEXT = Node.TEXT_NODE
+ELEMENT = Node.ELEMENT_NODE
+COMMENT = Node.COMMENT_NODE
+ENTITY = Node.ENTITY_NODE
+UNKNOWN = "<#UNKNOWN#>"
+
+spaceCharacters = "".join(spaceCharacters)
+
+
+class TreeWalker(object):
+    """Walks a tree yielding tokens
+
+    Tokens are dicts that all have a ``type`` field specifying the type of the
+    token.
+
+    """
+    def __init__(self, tree):
+        """Creates a TreeWalker
+
+        :arg tree: the tree to walk
+
+        """
+        self.tree = tree
+
+    def __iter__(self):
+        raise NotImplementedError
+
+    def error(self, msg):
+        """Generates an error token with the given message
+
+        :arg msg: the error message
+
+        :returns: SerializeError token
+
+        """
+        return {"type": "SerializeError", "data": msg}
+
+    def emptyTag(self, namespace, name, attrs, hasChildren=False):
+        """Generates an EmptyTag token
+
+        :arg namespace: the namespace of the token--can be ``None``
+
+        :arg name: the name of the element
+
+        :arg attrs: the attributes of the element as a dict
+
+        :arg hasChildren: whether or not to yield a SerializationError because
+            this tag shouldn't have children
+
+        :returns: EmptyTag token
+
+        """
+        yield {"type": "EmptyTag", "name": name,
+               "namespace": namespace,
+               "data": attrs}
+        if hasChildren:
+            yield self.error("Void element has children")
+
+    def startTag(self, namespace, name, attrs):
+        """Generates a StartTag token
+
+        :arg namespace: the namespace of the token--can be ``None``
+
+        :arg name: the name of the element
+
+        :arg attrs: the attributes of the element as a dict
+
+        :returns: StartTag token
+
+        """
+        return {"type": "StartTag",
+                "name": name,
+                "namespace": namespace,
+                "data": attrs}
+
+    def endTag(self, namespace, name):
+        """Generates an EndTag token
+
+        :arg namespace: the namespace of the token--can be ``None``
+
+        :arg name: the name of the element
+
+        :returns: EndTag token
+
+        """
+        return {"type": "EndTag",
+                "name": name,
+                "namespace": namespace}
+
+    def text(self, data):
+        """Generates SpaceCharacters and Characters tokens
+
+        Depending on what's in the data, this generates one or more
+        ``SpaceCharacters`` and ``Characters`` tokens.
+
+        For example:
+
+            >>> from html5lib.treewalkers.base import TreeWalker
+            >>> # Give it an empty tree just so it instantiates
+            >>> walker = TreeWalker([])
+            >>> list(walker.text(''))
+            []
+            >>> list(walker.text('  '))
+            [{u'data': '  ', u'type': u'SpaceCharacters'}]
+            >>> list(walker.text(' abc '))  # doctest: +NORMALIZE_WHITESPACE
+            [{u'data': ' ', u'type': u'SpaceCharacters'},
+            {u'data': u'abc', u'type': u'Characters'},
+            {u'data': u' ', u'type': u'SpaceCharacters'}]
+
+        :arg data: the text data
+
+        :returns: one or more ``SpaceCharacters`` and ``Characters`` tokens
+
+        """
+        data = data
+        middle = data.lstrip(spaceCharacters)
+        left = data[:len(data) - len(middle)]
+        if left:
+            yield {"type": "SpaceCharacters", "data": left}
+        data = middle
+        middle = data.rstrip(spaceCharacters)
+        right = data[len(middle):]
+        if middle:
+            yield {"type": "Characters", "data": middle}
+        if right:
+            yield {"type": "SpaceCharacters", "data": right}
+
+    def comment(self, data):
+        """Generates a Comment token
+
+        :arg data: the comment
+
+        :returns: Comment token
+
+        """
+        return {"type": "Comment", "data": data}
+
+    def doctype(self, name, publicId=None, systemId=None):
+        """Generates a Doctype token
+
+        :arg name:
+
+        :arg publicId:
+
+        :arg systemId:
+
+        :returns: the Doctype token
+
+        """
+        return {"type": "Doctype",
+                "name": name,
+                "publicId": publicId,
+                "systemId": systemId}
+
+    def entity(self, name):
+        """Generates an Entity token
+
+        :arg name: the entity name
+
+        :returns: an Entity token
+
+        """
+        return {"type": "Entity", "name": name}
+
+    def unknown(self, nodeType):
+        """Handles unknown node types"""
+        return self.error("Unknown node type: " + nodeType)
+
+
+class NonRecursiveTreeWalker(TreeWalker):
+    def getNodeDetails(self, node):
+        raise NotImplementedError
+
+    def getFirstChild(self, node):
+        raise NotImplementedError
+
+    def getNextSibling(self, node):
+        raise NotImplementedError
+
+    def getParentNode(self, node):
+        raise NotImplementedError
+
+    def __iter__(self):
+        currentNode = self.tree
+        while currentNode is not None:
+            details = self.getNodeDetails(currentNode)
+            type, details = details[0], details[1:]
+            hasChildren = False
+
+            if type == DOCTYPE:
+                yield self.doctype(*details)
+
+            elif type == TEXT:
+                for token in self.text(*details):
+                    yield token
+
+            elif type == ELEMENT:
+                namespace, name, attributes, hasChildren = details
+                if (not namespace or namespace == namespaces["html"]) and name in voidElements:
+                    for token in self.emptyTag(namespace, name, attributes,
+                                               hasChildren):
+                        yield token
+                    hasChildren = False
+                else:
+                    yield self.startTag(namespace, name, attributes)
+
+            elif type == COMMENT:
+                yield self.comment(details[0])
+
+            elif type == ENTITY:
+                yield self.entity(details[0])
+
+            elif type == DOCUMENT:
+                hasChildren = True
+
+            else:
+                yield self.unknown(details[0])
+
+            if hasChildren:
+                firstChild = self.getFirstChild(currentNode)
+            else:
+                firstChild = None
+
+            if firstChild is not None:
+                currentNode = firstChild
+            else:
+                while currentNode is not None:
+                    details = self.getNodeDetails(currentNode)
+                    type, details = details[0], details[1:]
+                    if type == ELEMENT:
+                        namespace, name, attributes, hasChildren = details
+                        if (namespace and namespace != namespaces["html"]) or name not in voidElements:
+                            yield self.endTag(namespace, name)
+                    if self.tree is currentNode:
+                        currentNode = None
+                        break
+                    nextSibling = self.getNextSibling(currentNode)
+                    if nextSibling is not None:
+                        currentNode = nextSibling
+                        break
+                    else:
+                        currentNode = self.getParentNode(currentNode)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/dom.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/dom.py
new file mode 100644
index 0000000..b0c89b0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/dom.py
@@ -0,0 +1,43 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from xml.dom import Node
+
+from . import base
+
+
+class TreeWalker(base.NonRecursiveTreeWalker):
+    def getNodeDetails(self, node):
+        if node.nodeType == Node.DOCUMENT_TYPE_NODE:
+            return base.DOCTYPE, node.name, node.publicId, node.systemId
+
+        elif node.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
+            return base.TEXT, node.nodeValue
+
+        elif node.nodeType == Node.ELEMENT_NODE:
+            attrs = {}
+            for attr in list(node.attributes.keys()):
+                attr = node.getAttributeNode(attr)
+                if attr.namespaceURI:
+                    attrs[(attr.namespaceURI, attr.localName)] = attr.value
+                else:
+                    attrs[(None, attr.name)] = attr.value
+            return (base.ELEMENT, node.namespaceURI, node.nodeName,
+                    attrs, node.hasChildNodes())
+
+        elif node.nodeType == Node.COMMENT_NODE:
+            return base.COMMENT, node.nodeValue
+
+        elif node.nodeType in (Node.DOCUMENT_NODE, Node.DOCUMENT_FRAGMENT_NODE):
+            return (base.DOCUMENT,)
+
+        else:
+            return base.UNKNOWN, node.nodeType
+
+    def getFirstChild(self, node):
+        return node.firstChild
+
+    def getNextSibling(self, node):
+        return node.nextSibling
+
+    def getParentNode(self, node):
+        return node.parentNode
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/etree.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/etree.py
new file mode 100644
index 0000000..837b27e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/etree.py
@@ -0,0 +1,131 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from collections import OrderedDict
+import re
+
+from pip._vendor.six import string_types
+
+from . import base
+from .._utils import moduleFactoryFactory
+
+tag_regexp = re.compile("{([^}]*)}(.*)")
+
+
+def getETreeBuilder(ElementTreeImplementation):
+    ElementTree = ElementTreeImplementation
+    ElementTreeCommentType = ElementTree.Comment("asd").tag
+
+    class TreeWalker(base.NonRecursiveTreeWalker):  # pylint:disable=unused-variable
+        """Given the particular ElementTree representation, this implementation,
+        to avoid using recursion, returns "nodes" as tuples with the following
+        content:
+
+        1. The current element
+
+        2. The index of the element relative to its parent
+
+        3. A stack of ancestor elements
+
+        4. A flag "text", "tail" or None to indicate if the current node is a
+           text node; either the text or tail of the current element (1)
+        """
+        def getNodeDetails(self, node):
+            if isinstance(node, tuple):  # It might be the root Element
+                elt, _, _, flag = node
+                if flag in ("text", "tail"):
+                    return base.TEXT, getattr(elt, flag)
+                else:
+                    node = elt
+
+            if not(hasattr(node, "tag")):
+                node = node.getroot()
+
+            if node.tag in ("DOCUMENT_ROOT", "DOCUMENT_FRAGMENT"):
+                return (base.DOCUMENT,)
+
+            elif node.tag == "<!DOCTYPE>":
+                return (base.DOCTYPE, node.text,
+                        node.get("publicId"), node.get("systemId"))
+
+            elif node.tag == ElementTreeCommentType:
+                return base.COMMENT, node.text
+
+            else:
+                assert isinstance(node.tag, string_types), type(node.tag)
+                # This is assumed to be an ordinary element
+                match = tag_regexp.match(node.tag)
+                if match:
+                    namespace, tag = match.groups()
+                else:
+                    namespace = None
+                    tag = node.tag
+                attrs = OrderedDict()
+                for name, value in list(node.attrib.items()):
+                    match = tag_regexp.match(name)
+                    if match:
+                        attrs[(match.group(1), match.group(2))] = value
+                    else:
+                        attrs[(None, name)] = value
+                return (base.ELEMENT, namespace, tag,
+                        attrs, len(node) or node.text)
+
+        def getFirstChild(self, node):
+            if isinstance(node, tuple):
+                element, key, parents, flag = node
+            else:
+                element, key, parents, flag = node, None, [], None
+
+            if flag in ("text", "tail"):
+                return None
+            else:
+                if element.text:
+                    return element, key, parents, "text"
+                elif len(element):
+                    parents.append(element)
+                    return element[0], 0, parents, None
+                else:
+                    return None
+
+        def getNextSibling(self, node):
+            if isinstance(node, tuple):
+                element, key, parents, flag = node
+            else:
+                return None
+
+            if flag == "text":
+                if len(element):
+                    parents.append(element)
+                    return element[0], 0, parents, None
+                else:
+                    return None
+            else:
+                if element.tail and flag != "tail":
+                    return element, key, parents, "tail"
+                elif key < len(parents[-1]) - 1:
+                    return parents[-1][key + 1], key + 1, parents, None
+                else:
+                    return None
+
+        def getParentNode(self, node):
+            if isinstance(node, tuple):
+                element, key, parents, flag = node
+            else:
+                return None
+
+            if flag == "text":
+                if not parents:
+                    return element
+                else:
+                    return element, key, parents, None
+            else:
+                parent = parents.pop()
+                if not parents:
+                    return parent
+                else:
+                    assert list(parents[-1]).count(parent) == 1
+                    return parent, list(parents[-1]).index(parent), parents, None
+
+    return locals()
+
+
+getETreeModule = moduleFactoryFactory(getETreeBuilder)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/etree_lxml.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/etree_lxml.py
new file mode 100644
index 0000000..c56af39
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/etree_lxml.py
@@ -0,0 +1,215 @@
+from __future__ import absolute_import, division, unicode_literals
+from pip._vendor.six import text_type
+
+from collections import OrderedDict
+
+from lxml import etree
+from ..treebuilders.etree import tag_regexp
+
+from . import base
+
+from .. import _ihatexml
+
+
+def ensure_str(s):
+    if s is None:
+        return None
+    elif isinstance(s, text_type):
+        return s
+    else:
+        return s.decode("ascii", "strict")
+
+
+class Root(object):
+    def __init__(self, et):
+        self.elementtree = et
+        self.children = []
+
+        try:
+            if et.docinfo.internalDTD:
+                self.children.append(Doctype(self,
+                                             ensure_str(et.docinfo.root_name),
+                                             ensure_str(et.docinfo.public_id),
+                                             ensure_str(et.docinfo.system_url)))
+        except AttributeError:
+            pass
+
+        try:
+            node = et.getroot()
+        except AttributeError:
+            node = et
+
+        while node.getprevious() is not None:
+            node = node.getprevious()
+        while node is not None:
+            self.children.append(node)
+            node = node.getnext()
+
+        self.text = None
+        self.tail = None
+
+    def __getitem__(self, key):
+        return self.children[key]
+
+    def getnext(self):
+        return None
+
+    def __len__(self):
+        return 1
+
+
+class Doctype(object):
+    def __init__(self, root_node, name, public_id, system_id):
+        self.root_node = root_node
+        self.name = name
+        self.public_id = public_id
+        self.system_id = system_id
+
+        self.text = None
+        self.tail = None
+
+    def getnext(self):
+        return self.root_node.children[1]
+
+
+class FragmentRoot(Root):
+    def __init__(self, children):
+        self.children = [FragmentWrapper(self, child) for child in children]
+        self.text = self.tail = None
+
+    def getnext(self):
+        return None
+
+
+class FragmentWrapper(object):
+    def __init__(self, fragment_root, obj):
+        self.root_node = fragment_root
+        self.obj = obj
+        if hasattr(self.obj, 'text'):
+            self.text = ensure_str(self.obj.text)
+        else:
+            self.text = None
+        if hasattr(self.obj, 'tail'):
+            self.tail = ensure_str(self.obj.tail)
+        else:
+            self.tail = None
+
+    def __getattr__(self, name):
+        return getattr(self.obj, name)
+
+    def getnext(self):
+        siblings = self.root_node.children
+        idx = siblings.index(self)
+        if idx < len(siblings) - 1:
+            return siblings[idx + 1]
+        else:
+            return None
+
+    def __getitem__(self, key):
+        return self.obj[key]
+
+    def __bool__(self):
+        return bool(self.obj)
+
+    def getparent(self):
+        return None
+
+    def __str__(self):
+        return str(self.obj)
+
+    def __unicode__(self):
+        return str(self.obj)
+
+    def __len__(self):
+        return len(self.obj)
+
+
+class TreeWalker(base.NonRecursiveTreeWalker):
+    def __init__(self, tree):
+        # pylint:disable=redefined-variable-type
+        if isinstance(tree, list):
+            self.fragmentChildren = set(tree)
+            tree = FragmentRoot(tree)
+        else:
+            self.fragmentChildren = set()
+            tree = Root(tree)
+        base.NonRecursiveTreeWalker.__init__(self, tree)
+        self.filter = _ihatexml.InfosetFilter()
+
+    def getNodeDetails(self, node):
+        if isinstance(node, tuple):  # Text node
+            node, key = node
+            assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key
+            return base.TEXT, ensure_str(getattr(node, key))
+
+        elif isinstance(node, Root):
+            return (base.DOCUMENT,)
+
+        elif isinstance(node, Doctype):
+            return base.DOCTYPE, node.name, node.public_id, node.system_id
+
+        elif isinstance(node, FragmentWrapper) and not hasattr(node, "tag"):
+            return base.TEXT, ensure_str(node.obj)
+
+        elif node.tag == etree.Comment:
+            return base.COMMENT, ensure_str(node.text)
+
+        elif node.tag == etree.Entity:
+            return base.ENTITY, ensure_str(node.text)[1:-1]  # strip &;
+
+        else:
+            # This is assumed to be an ordinary element
+            match = tag_regexp.match(ensure_str(node.tag))
+            if match:
+                namespace, tag = match.groups()
+            else:
+                namespace = None
+                tag = ensure_str(node.tag)
+            attrs = OrderedDict()
+            for name, value in list(node.attrib.items()):
+                name = ensure_str(name)
+                value = ensure_str(value)
+                match = tag_regexp.match(name)
+                if match:
+                    attrs[(match.group(1), match.group(2))] = value
+                else:
+                    attrs[(None, name)] = value
+            return (base.ELEMENT, namespace, self.filter.fromXmlName(tag),
+                    attrs, len(node) > 0 or node.text)
+
+    def getFirstChild(self, node):
+        assert not isinstance(node, tuple), "Text nodes have no children"
+
+        assert len(node) or node.text, "Node has no children"
+        if node.text:
+            return (node, "text")
+        else:
+            return node[0]
+
+    def getNextSibling(self, node):
+        if isinstance(node, tuple):  # Text node
+            node, key = node
+            assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key
+            if key == "text":
+                # XXX: we cannot use a "bool(node) and node[0] or None" construct here
+                # because node[0] might evaluate to False if it has no child element
+                if len(node):
+                    return node[0]
+                else:
+                    return None
+            else:  # tail
+                return node.getnext()
+
+        return (node, "tail") if node.tail else node.getnext()
+
+    def getParentNode(self, node):
+        if isinstance(node, tuple):  # Text node
+            node, key = node
+            assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key
+            if key == "text":
+                return node
+            # else: fallback to "normal" processing
+        elif node in self.fragmentChildren:
+            return None
+
+        return node.getparent()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/genshi.py b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/genshi.py
new file mode 100644
index 0000000..7483be2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/html5lib/treewalkers/genshi.py
@@ -0,0 +1,69 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from genshi.core import QName
+from genshi.core import START, END, XML_NAMESPACE, DOCTYPE, TEXT
+from genshi.core import START_NS, END_NS, START_CDATA, END_CDATA, PI, COMMENT
+
+from . import base
+
+from ..constants import voidElements, namespaces
+
+
+class TreeWalker(base.TreeWalker):
+    def __iter__(self):
+        # Buffer the events so we can pass in the following one
+        previous = None
+        for event in self.tree:
+            if previous is not None:
+                for token in self.tokens(previous, event):
+                    yield token
+            previous = event
+
+        # Don't forget the final event!
+        if previous is not None:
+            for token in self.tokens(previous, None):
+                yield token
+
+    def tokens(self, event, next):
+        kind, data, _ = event
+        if kind == START:
+            tag, attribs = data
+            name = tag.localname
+            namespace = tag.namespace
+            converted_attribs = {}
+            for k, v in attribs:
+                if isinstance(k, QName):
+                    converted_attribs[(k.namespace, k.localname)] = v
+                else:
+                    converted_attribs[(None, k)] = v
+
+            if namespace == namespaces["html"] and name in voidElements:
+                for token in self.emptyTag(namespace, name, converted_attribs,
+                                           not next or next[0] != END or
+                                           next[1] != tag):
+                    yield token
+            else:
+                yield self.startTag(namespace, name, converted_attribs)
+
+        elif kind == END:
+            name = data.localname
+            namespace = data.namespace
+            if namespace != namespaces["html"] or name not in voidElements:
+                yield self.endTag(namespace, name)
+
+        elif kind == COMMENT:
+            yield self.comment(data)
+
+        elif kind == TEXT:
+            for token in self.text(data):
+                yield token
+
+        elif kind == DOCTYPE:
+            yield self.doctype(*data)
+
+        elif kind in (XML_NAMESPACE, DOCTYPE, START_NS, END_NS,
+                      START_CDATA, END_CDATA, PI):
+            pass
+
+        else:
+            yield self.unknown(kind)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/idna/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/__init__.py
new file mode 100644
index 0000000..847bf93
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/__init__.py
@@ -0,0 +1,2 @@
+from .package_data import __version__
+from .core import *
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/idna/codec.py b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/codec.py
new file mode 100644
index 0000000..98c65ea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/codec.py
@@ -0,0 +1,118 @@
+from .core import encode, decode, alabel, ulabel, IDNAError
+import codecs
+import re
+
+_unicode_dots_re = re.compile(u'[\u002e\u3002\uff0e\uff61]')
+
+class Codec(codecs.Codec):
+
+    def encode(self, data, errors='strict'):
+
+        if errors != 'strict':
+            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+
+        if not data:
+            return "", 0
+
+        return encode(data), len(data)
+
+    def decode(self, data, errors='strict'):
+
+        if errors != 'strict':
+            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+
+        if not data:
+            return u"", 0
+
+        return decode(data), len(data)
+
+class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
+    def _buffer_encode(self, data, errors, final):
+        if errors != 'strict':
+            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+
+        if not data:
+            return ("", 0)
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = u''
+        if labels:
+            if not labels[-1]:
+                trailing_dot = '.'
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = '.'
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(alabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        # Join with U+002E
+        result = ".".join(result) + trailing_dot
+        size += len(trailing_dot)
+        return (result, size)
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, data, errors, final):
+        if errors != 'strict':
+            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+
+        if not data:
+            return (u"", 0)
+
+        # IDNA allows decoding to operate on Unicode strings, too.
+        if isinstance(data, unicode):
+            labels = _unicode_dots_re.split(data)
+        else:
+            # Must be ASCII string
+            data = str(data)
+            unicode(data, "ascii")
+            labels = data.split(".")
+
+        trailing_dot = u''
+        if labels:
+            if not labels[-1]:
+                trailing_dot = u'.'
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = u'.'
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(ulabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        result = u".".join(result) + trailing_dot
+        size += len(trailing_dot)
+        return (result, size)
+
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    pass
+
+class StreamReader(Codec, codecs.StreamReader):
+    pass
+
+def getregentry():
+    return codecs.CodecInfo(
+        name='idna',
+        encode=Codec().encode,
+        decode=Codec().decode,
+        incrementalencoder=IncrementalEncoder,
+        incrementaldecoder=IncrementalDecoder,
+        streamwriter=StreamWriter,
+        streamreader=StreamReader,
+    )
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/idna/compat.py b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/compat.py
new file mode 100644
index 0000000..4d47f33
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/compat.py
@@ -0,0 +1,12 @@
+from .core import *
+from .codec import *
+
+def ToASCII(label):
+    return encode(label)
+
+def ToUnicode(label):
+    return decode(label)
+
+def nameprep(s):
+    raise NotImplementedError("IDNA 2008 does not utilise nameprep protocol")
+
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/idna/core.py b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/core.py
new file mode 100644
index 0000000..41ec5c7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/core.py
@@ -0,0 +1,400 @@
+from . import idnadata
+import bisect
+import unicodedata
+import re
+import sys
+from .intranges import intranges_contain
+
+_virama_combining_class = 9
+_alabel_prefix = b'xn--'
+_unicode_dots_re = re.compile(u'[\u002e\u3002\uff0e\uff61]')
+
+if sys.version_info[0] >= 3:
+    unicode = str
+    unichr = chr
+
+class IDNAError(UnicodeError):
+    """ Base exception for all IDNA-encoding related problems """
+    pass
+
+
+class IDNABidiError(IDNAError):
+    """ Exception when bidirectional requirements are not satisfied """
+    pass
+
+
+class InvalidCodepoint(IDNAError):
+    """ Exception when a disallowed or unallocated codepoint is used """
+    pass
+
+
+class InvalidCodepointContext(IDNAError):
+    """ Exception when the codepoint is not valid in the context it is used """
+    pass
+
+
+def _combining_class(cp):
+    v = unicodedata.combining(unichr(cp))
+    if v == 0:
+        if not unicodedata.name(unichr(cp)):
+            raise ValueError("Unknown character in unicodedata")
+    return v
+
+def _is_script(cp, script):
+    return intranges_contain(ord(cp), idnadata.scripts[script])
+
+def _punycode(s):
+    return s.encode('punycode')
+
+def _unot(s):
+    return 'U+{0:04X}'.format(s)
+
+
+def valid_label_length(label):
+
+    if len(label) > 63:
+        return False
+    return True
+
+
+def valid_string_length(label, trailing_dot):
+
+    if len(label) > (254 if trailing_dot else 253):
+        return False
+    return True
+
+
+def check_bidi(label, check_ltr=False):
+
+    # Bidi rules should only be applied if string contains RTL characters
+    bidi_label = False
+    for (idx, cp) in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+        if direction == '':
+            # String likely comes from a newer version of Unicode
+            raise IDNABidiError('Unknown directionality in label {0} at position {1}'.format(repr(label), idx))
+        if direction in ['R', 'AL', 'AN']:
+            bidi_label = True
+    if not bidi_label and not check_ltr:
+        return True
+
+    # Bidi rule 1
+    direction = unicodedata.bidirectional(label[0])
+    if direction in ['R', 'AL']:
+        rtl = True
+    elif direction == 'L':
+        rtl = False
+    else:
+        raise IDNABidiError('First codepoint in label {0} must be directionality L, R or AL'.format(repr(label)))
+
+    valid_ending = False
+    number_type = False
+    for (idx, cp) in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+
+        if rtl:
+            # Bidi rule 2
+            if not direction in ['R', 'AL', 'AN', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']:
+                raise IDNABidiError('Invalid direction for codepoint at position {0} in a right-to-left label'.format(idx))
+            # Bidi rule 3
+            if direction in ['R', 'AL', 'EN', 'AN']:
+                valid_ending = True
+            elif direction != 'NSM':
+                valid_ending = False
+            # Bidi rule 4
+            if direction in ['AN', 'EN']:
+                if not number_type:
+                    number_type = direction
+                else:
+                    if number_type != direction:
+                        raise IDNABidiError('Can not mix numeral types in a right-to-left label')
+        else:
+            # Bidi rule 5
+            if not direction in ['L', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']:
+                raise IDNABidiError('Invalid direction for codepoint at position {0} in a left-to-right label'.format(idx))
+            # Bidi rule 6
+            if direction in ['L', 'EN']:
+                valid_ending = True
+            elif direction != 'NSM':
+                valid_ending = False
+
+    if not valid_ending:
+        raise IDNABidiError('Label ends with illegal codepoint directionality')
+
+    return True
+
+
+def check_initial_combiner(label):
+
+    if unicodedata.category(label[0])[0] == 'M':
+        raise IDNAError('Label begins with an illegal combining character')
+    return True
+
+
+def check_hyphen_ok(label):
+
+    if label[2:4] == '--':
+        raise IDNAError('Label has disallowed hyphens in 3rd and 4th position')
+    if label[0] == '-' or label[-1] == '-':
+        raise IDNAError('Label must not start or end with a hyphen')
+    return True
+
+
+def check_nfc(label):
+
+    if unicodedata.normalize('NFC', label) != label:
+        raise IDNAError('Label must be in Normalization Form C')
+
+
+def valid_contextj(label, pos):
+
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x200c:
+
+        if pos > 0:
+            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
+                return True
+
+        ok = False
+        for i in range(pos-1, -1, -1):
+            joining_type = idnadata.joining_types.get(ord(label[i]))
+            if joining_type == ord('T'):
+                continue
+            if joining_type in [ord('L'), ord('D')]:
+                ok = True
+                break
+
+        if not ok:
+            return False
+
+        ok = False
+        for i in range(pos+1, len(label)):
+            joining_type = idnadata.joining_types.get(ord(label[i]))
+            if joining_type == ord('T'):
+                continue
+            if joining_type in [ord('R'), ord('D')]:
+                ok = True
+                break
+        return ok
+
+    if cp_value == 0x200d:
+
+        if pos > 0:
+            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
+                return True
+        return False
+
+    else:
+
+        return False
+
+
+def valid_contexto(label, pos, exception=False):
+
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x00b7:
+        if 0 < pos < len(label)-1:
+            if ord(label[pos - 1]) == 0x006c and ord(label[pos + 1]) == 0x006c:
+                return True
+        return False
+
+    elif cp_value == 0x0375:
+        if pos < len(label)-1 and len(label) > 1:
+            return _is_script(label[pos + 1], 'Greek')
+        return False
+
+    elif cp_value == 0x05f3 or cp_value == 0x05f4:
+        if pos > 0:
+            return _is_script(label[pos - 1], 'Hebrew')
+        return False
+
+    elif cp_value == 0x30fb:
+        for cp in label:
+            if cp == u'\u30fb':
+                continue
+            if _is_script(cp, 'Hiragana') or _is_script(cp, 'Katakana') or _is_script(cp, 'Han'):
+                return True
+        return False
+
+    elif 0x660 <= cp_value <= 0x669:
+        for cp in label:
+            if 0x6f0 <= ord(cp) <= 0x06f9:
+                return False
+        return True
+
+    elif 0x6f0 <= cp_value <= 0x6f9:
+        for cp in label:
+            if 0x660 <= ord(cp) <= 0x0669:
+                return False
+        return True
+
+
+def check_label(label):
+
+    if isinstance(label, (bytes, bytearray)):
+        label = label.decode('utf-8')
+    if len(label) == 0:
+        raise IDNAError('Empty Label')
+
+    check_nfc(label)
+    check_hyphen_ok(label)
+    check_initial_combiner(label)
+
+    for (pos, cp) in enumerate(label):
+        cp_value = ord(cp)
+        if intranges_contain(cp_value, idnadata.codepoint_classes['PVALID']):
+            continue
+        elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTJ']):
+            try:
+                if not valid_contextj(label, pos):
+                    raise InvalidCodepointContext('Joiner {0} not allowed at position {1} in {2}'.format(
+                        _unot(cp_value), pos+1, repr(label)))
+            except ValueError:
+                raise IDNAError('Unknown codepoint adjacent to joiner {0} at position {1} in {2}'.format(
+                    _unot(cp_value), pos+1, repr(label)))
+        elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTO']):
+            if not valid_contexto(label, pos):
+                raise InvalidCodepointContext('Codepoint {0} not allowed at position {1} in {2}'.format(_unot(cp_value), pos+1, repr(label)))
+        else:
+            raise InvalidCodepoint('Codepoint {0} at position {1} of {2} not allowed'.format(_unot(cp_value), pos+1, repr(label)))
+
+    check_bidi(label)
+
+
+def alabel(label):
+
+    try:
+        label = label.encode('ascii')
+        ulabel(label)
+        if not valid_label_length(label):
+            raise IDNAError('Label too long')
+        return label
+    except UnicodeEncodeError:
+        pass
+
+    if not label:
+        raise IDNAError('No Input')
+
+    label = unicode(label)
+    check_label(label)
+    label = _punycode(label)
+    label = _alabel_prefix + label
+
+    if not valid_label_length(label):
+        raise IDNAError('Label too long')
+
+    return label
+
+
+def ulabel(label):
+
+    if not isinstance(label, (bytes, bytearray)):
+        try:
+            label = label.encode('ascii')
+        except UnicodeEncodeError:
+            check_label(label)
+            return label
+
+    label = label.lower()
+    if label.startswith(_alabel_prefix):
+        label = label[len(_alabel_prefix):]
+        if not label:
+            raise IDNAError('Malformed A-label, no Punycode eligible content found')
+        if label.decode('ascii')[-1] == '-':
+            raise IDNAError('A-label must not end with a hyphen')
+    else:
+        check_label(label)
+        return label.decode('ascii')
+
+    label = label.decode('punycode')
+    check_label(label)
+    return label
+
+
+def uts46_remap(domain, std3_rules=True, transitional=False):
+    """Re-map the characters in the string according to UTS46 processing."""
+    from .uts46data import uts46data
+    output = u""
+    try:
+        for pos, char in enumerate(domain):
+            code_point = ord(char)
+            uts46row = uts46data[code_point if code_point < 256 else
+                bisect.bisect_left(uts46data, (code_point, "Z")) - 1]
+            status = uts46row[1]
+            replacement = uts46row[2] if len(uts46row) == 3 else None
+            if (status == "V" or
+                    (status == "D" and not transitional) or
+                    (status == "3" and not std3_rules and replacement is None)):
+                output += char
+            elif replacement is not None and (status == "M" or
+                    (status == "3" and not std3_rules) or
+                    (status == "D" and transitional)):
+                output += replacement
+            elif status != "I":
+                raise IndexError()
+        return unicodedata.normalize("NFC", output)
+    except IndexError:
+        raise InvalidCodepoint(
+            "Codepoint {0} not allowed at position {1} in {2}".format(
+            _unot(code_point), pos + 1, repr(domain)))
+
+
+def encode(s, strict=False, uts46=False, std3_rules=False, transitional=False):
+
+    if isinstance(s, (bytes, bytearray)):
+        s = s.decode("ascii")
+    if uts46:
+        s = uts46_remap(s, std3_rules, transitional)
+    trailing_dot = False
+    result = []
+    if strict:
+        labels = s.split('.')
+    else:
+        labels = _unicode_dots_re.split(s)
+    if not labels or labels == ['']:
+        raise IDNAError('Empty domain')
+    if labels[-1] == '':
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        s = alabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError('Empty label')
+    if trailing_dot:
+        result.append(b'')
+    s = b'.'.join(result)
+    if not valid_string_length(s, trailing_dot):
+        raise IDNAError('Domain too long')
+    return s
+
+
+def decode(s, strict=False, uts46=False, std3_rules=False):
+
+    if isinstance(s, (bytes, bytearray)):
+        s = s.decode("ascii")
+    if uts46:
+        s = uts46_remap(s, std3_rules, False)
+    trailing_dot = False
+    result = []
+    if not strict:
+        labels = _unicode_dots_re.split(s)
+    else:
+        labels = s.split(u'.')
+    if not labels or labels == ['']:
+        raise IDNAError('Empty domain')
+    if not labels[-1]:
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        s = ulabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError('Empty label')
+    if trailing_dot:
+        result.append(u'')
+    return u'.'.join(result)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/idna/idnadata.py b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/idnadata.py
new file mode 100644
index 0000000..a284e4c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/idnadata.py
@@ -0,0 +1,2050 @@
+# This file is automatically generated by tools/idna-data
+
+__version__ = "13.0.0"
+scripts = {
+    'Greek': (
+        0x37000000374,
+        0x37500000378,
+        0x37a0000037e,
+        0x37f00000380,
+        0x38400000385,
+        0x38600000387,
+        0x3880000038b,
+        0x38c0000038d,
+        0x38e000003a2,
+        0x3a3000003e2,
+        0x3f000000400,
+        0x1d2600001d2b,
+        0x1d5d00001d62,
+        0x1d6600001d6b,
+        0x1dbf00001dc0,
+        0x1f0000001f16,
+        0x1f1800001f1e,
+        0x1f2000001f46,
+        0x1f4800001f4e,
+        0x1f5000001f58,
+        0x1f5900001f5a,
+        0x1f5b00001f5c,
+        0x1f5d00001f5e,
+        0x1f5f00001f7e,
+        0x1f8000001fb5,
+        0x1fb600001fc5,
+        0x1fc600001fd4,
+        0x1fd600001fdc,
+        0x1fdd00001ff0,
+        0x1ff200001ff5,
+        0x1ff600001fff,
+        0x212600002127,
+        0xab650000ab66,
+        0x101400001018f,
+        0x101a0000101a1,
+        0x1d2000001d246,
+    ),
+    'Han': (
+        0x2e8000002e9a,
+        0x2e9b00002ef4,
+        0x2f0000002fd6,
+        0x300500003006,
+        0x300700003008,
+        0x30210000302a,
+        0x30380000303c,
+        0x340000004dc0,
+        0x4e0000009ffd,
+        0xf9000000fa6e,
+        0xfa700000fada,
+        0x16ff000016ff2,
+        0x200000002a6de,
+        0x2a7000002b735,
+        0x2b7400002b81e,
+        0x2b8200002cea2,
+        0x2ceb00002ebe1,
+        0x2f8000002fa1e,
+        0x300000003134b,
+    ),
+    'Hebrew': (
+        0x591000005c8,
+        0x5d0000005eb,
+        0x5ef000005f5,
+        0xfb1d0000fb37,
+        0xfb380000fb3d,
+        0xfb3e0000fb3f,
+        0xfb400000fb42,
+        0xfb430000fb45,
+        0xfb460000fb50,
+    ),
+    'Hiragana': (
+        0x304100003097,
+        0x309d000030a0,
+        0x1b0010001b11f,
+        0x1b1500001b153,
+        0x1f2000001f201,
+    ),
+    'Katakana': (
+        0x30a1000030fb,
+        0x30fd00003100,
+        0x31f000003200,
+        0x32d0000032ff,
+        0x330000003358,
+        0xff660000ff70,
+        0xff710000ff9e,
+        0x1b0000001b001,
+        0x1b1640001b168,
+    ),
+}
+joining_types = {
+    0x600: 85,
+    0x601: 85,
+    0x602: 85,
+    0x603: 85,
+    0x604: 85,
+    0x605: 85,
+    0x608: 85,
+    0x60b: 85,
+    0x620: 68,
+    0x621: 85,
+    0x622: 82,
+    0x623: 82,
+    0x624: 82,
+    0x625: 82,
+    0x626: 68,
+    0x627: 82,
+    0x628: 68,
+    0x629: 82,
+    0x62a: 68,
+    0x62b: 68,
+    0x62c: 68,
+    0x62d: 68,
+    0x62e: 68,
+    0x62f: 82,
+    0x630: 82,
+    0x631: 82,
+    0x632: 82,
+    0x633: 68,
+    0x634: 68,
+    0x635: 68,
+    0x636: 68,
+    0x637: 68,
+    0x638: 68,
+    0x639: 68,
+    0x63a: 68,
+    0x63b: 68,
+    0x63c: 68,
+    0x63d: 68,
+    0x63e: 68,
+    0x63f: 68,
+    0x640: 67,
+    0x641: 68,
+    0x642: 68,
+    0x643: 68,
+    0x644: 68,
+    0x645: 68,
+    0x646: 68,
+    0x647: 68,
+    0x648: 82,
+    0x649: 68,
+    0x64a: 68,
+    0x66e: 68,
+    0x66f: 68,
+    0x671: 82,
+    0x672: 82,
+    0x673: 82,
+    0x674: 85,
+    0x675: 82,
+    0x676: 82,
+    0x677: 82,
+    0x678: 68,
+    0x679: 68,
+    0x67a: 68,
+    0x67b: 68,
+    0x67c: 68,
+    0x67d: 68,
+    0x67e: 68,
+    0x67f: 68,
+    0x680: 68,
+    0x681: 68,
+    0x682: 68,
+    0x683: 68,
+    0x684: 68,
+    0x685: 68,
+    0x686: 68,
+    0x687: 68,
+    0x688: 82,
+    0x689: 82,
+    0x68a: 82,
+    0x68b: 82,
+    0x68c: 82,
+    0x68d: 82,
+    0x68e: 82,
+    0x68f: 82,
+    0x690: 82,
+    0x691: 82,
+    0x692: 82,
+    0x693: 82,
+    0x694: 82,
+    0x695: 82,
+    0x696: 82,
+    0x697: 82,
+    0x698: 82,
+    0x699: 82,
+    0x69a: 68,
+    0x69b: 68,
+    0x69c: 68,
+    0x69d: 68,
+    0x69e: 68,
+    0x69f: 68,
+    0x6a0: 68,
+    0x6a1: 68,
+    0x6a2: 68,
+    0x6a3: 68,
+    0x6a4: 68,
+    0x6a5: 68,
+    0x6a6: 68,
+    0x6a7: 68,
+    0x6a8: 68,
+    0x6a9: 68,
+    0x6aa: 68,
+    0x6ab: 68,
+    0x6ac: 68,
+    0x6ad: 68,
+    0x6ae: 68,
+    0x6af: 68,
+    0x6b0: 68,
+    0x6b1: 68,
+    0x6b2: 68,
+    0x6b3: 68,
+    0x6b4: 68,
+    0x6b5: 68,
+    0x6b6: 68,
+    0x6b7: 68,
+    0x6b8: 68,
+    0x6b9: 68,
+    0x6ba: 68,
+    0x6bb: 68,
+    0x6bc: 68,
+    0x6bd: 68,
+    0x6be: 68,
+    0x6bf: 68,
+    0x6c0: 82,
+    0x6c1: 68,
+    0x6c2: 68,
+    0x6c3: 82,
+    0x6c4: 82,
+    0x6c5: 82,
+    0x6c6: 82,
+    0x6c7: 82,
+    0x6c8: 82,
+    0x6c9: 82,
+    0x6ca: 82,
+    0x6cb: 82,
+    0x6cc: 68,
+    0x6cd: 82,
+    0x6ce: 68,
+    0x6cf: 82,
+    0x6d0: 68,
+    0x6d1: 68,
+    0x6d2: 82,
+    0x6d3: 82,
+    0x6d5: 82,
+    0x6dd: 85,
+    0x6ee: 82,
+    0x6ef: 82,
+    0x6fa: 68,
+    0x6fb: 68,
+    0x6fc: 68,
+    0x6ff: 68,
+    0x70f: 84,
+    0x710: 82,
+    0x712: 68,
+    0x713: 68,
+    0x714: 68,
+    0x715: 82,
+    0x716: 82,
+    0x717: 82,
+    0x718: 82,
+    0x719: 82,
+    0x71a: 68,
+    0x71b: 68,
+    0x71c: 68,
+    0x71d: 68,
+    0x71e: 82,
+    0x71f: 68,
+    0x720: 68,
+    0x721: 68,
+    0x722: 68,
+    0x723: 68,
+    0x724: 68,
+    0x725: 68,
+    0x726: 68,
+    0x727: 68,
+    0x728: 82,
+    0x729: 68,
+    0x72a: 82,
+    0x72b: 68,
+    0x72c: 82,
+    0x72d: 68,
+    0x72e: 68,
+    0x72f: 82,
+    0x74d: 82,
+    0x74e: 68,
+    0x74f: 68,
+    0x750: 68,
+    0x751: 68,
+    0x752: 68,
+    0x753: 68,
+    0x754: 68,
+    0x755: 68,
+    0x756: 68,
+    0x757: 68,
+    0x758: 68,
+    0x759: 82,
+    0x75a: 82,
+    0x75b: 82,
+    0x75c: 68,
+    0x75d: 68,
+    0x75e: 68,
+    0x75f: 68,
+    0x760: 68,
+    0x761: 68,
+    0x762: 68,
+    0x763: 68,
+    0x764: 68,
+    0x765: 68,
+    0x766: 68,
+    0x767: 68,
+    0x768: 68,
+    0x769: 68,
+    0x76a: 68,
+    0x76b: 82,
+    0x76c: 82,
+    0x76d: 68,
+    0x76e: 68,
+    0x76f: 68,
+    0x770: 68,
+    0x771: 82,
+    0x772: 68,
+    0x773: 82,
+    0x774: 82,
+    0x775: 68,
+    0x776: 68,
+    0x777: 68,
+    0x778: 82,
+    0x779: 82,
+    0x77a: 68,
+    0x77b: 68,
+    0x77c: 68,
+    0x77d: 68,
+    0x77e: 68,
+    0x77f: 68,
+    0x7ca: 68,
+    0x7cb: 68,
+    0x7cc: 68,
+    0x7cd: 68,
+    0x7ce: 68,
+    0x7cf: 68,
+    0x7d0: 68,
+    0x7d1: 68,
+    0x7d2: 68,
+    0x7d3: 68,
+    0x7d4: 68,
+    0x7d5: 68,
+    0x7d6: 68,
+    0x7d7: 68,
+    0x7d8: 68,
+    0x7d9: 68,
+    0x7da: 68,
+    0x7db: 68,
+    0x7dc: 68,
+    0x7dd: 68,
+    0x7de: 68,
+    0x7df: 68,
+    0x7e0: 68,
+    0x7e1: 68,
+    0x7e2: 68,
+    0x7e3: 68,
+    0x7e4: 68,
+    0x7e5: 68,
+    0x7e6: 68,
+    0x7e7: 68,
+    0x7e8: 68,
+    0x7e9: 68,
+    0x7ea: 68,
+    0x7fa: 67,
+    0x840: 82,
+    0x841: 68,
+    0x842: 68,
+    0x843: 68,
+    0x844: 68,
+    0x845: 68,
+    0x846: 82,
+    0x847: 82,
+    0x848: 68,
+    0x849: 82,
+    0x84a: 68,
+    0x84b: 68,
+    0x84c: 68,
+    0x84d: 68,
+    0x84e: 68,
+    0x84f: 68,
+    0x850: 68,
+    0x851: 68,
+    0x852: 68,
+    0x853: 68,
+    0x854: 82,
+    0x855: 68,
+    0x856: 82,
+    0x857: 82,
+    0x858: 82,
+    0x860: 68,
+    0x861: 85,
+    0x862: 68,
+    0x863: 68,
+    0x864: 68,
+    0x865: 68,
+    0x866: 85,
+    0x867: 82,
+    0x868: 68,
+    0x869: 82,
+    0x86a: 82,
+    0x8a0: 68,
+    0x8a1: 68,
+    0x8a2: 68,
+    0x8a3: 68,
+    0x8a4: 68,
+    0x8a5: 68,
+    0x8a6: 68,
+    0x8a7: 68,
+    0x8a8: 68,
+    0x8a9: 68,
+    0x8aa: 82,
+    0x8ab: 82,
+    0x8ac: 82,
+    0x8ad: 85,
+    0x8ae: 82,
+    0x8af: 68,
+    0x8b0: 68,
+    0x8b1: 82,
+    0x8b2: 82,
+    0x8b3: 68,
+    0x8b4: 68,
+    0x8b6: 68,
+    0x8b7: 68,
+    0x8b8: 68,
+    0x8b9: 82,
+    0x8ba: 68,
+    0x8bb: 68,
+    0x8bc: 68,
+    0x8bd: 68,
+    0x8be: 68,
+    0x8bf: 68,
+    0x8c0: 68,
+    0x8c1: 68,
+    0x8c2: 68,
+    0x8c3: 68,
+    0x8c4: 68,
+    0x8c5: 68,
+    0x8c6: 68,
+    0x8c7: 68,
+    0x8e2: 85,
+    0x1806: 85,
+    0x1807: 68,
+    0x180a: 67,
+    0x180e: 85,
+    0x1820: 68,
+    0x1821: 68,
+    0x1822: 68,
+    0x1823: 68,
+    0x1824: 68,
+    0x1825: 68,
+    0x1826: 68,
+    0x1827: 68,
+    0x1828: 68,
+    0x1829: 68,
+    0x182a: 68,
+    0x182b: 68,
+    0x182c: 68,
+    0x182d: 68,
+    0x182e: 68,
+    0x182f: 68,
+    0x1830: 68,
+    0x1831: 68,
+    0x1832: 68,
+    0x1833: 68,
+    0x1834: 68,
+    0x1835: 68,
+    0x1836: 68,
+    0x1837: 68,
+    0x1838: 68,
+    0x1839: 68,
+    0x183a: 68,
+    0x183b: 68,
+    0x183c: 68,
+    0x183d: 68,
+    0x183e: 68,
+    0x183f: 68,
+    0x1840: 68,
+    0x1841: 68,
+    0x1842: 68,
+    0x1843: 68,
+    0x1844: 68,
+    0x1845: 68,
+    0x1846: 68,
+    0x1847: 68,
+    0x1848: 68,
+    0x1849: 68,
+    0x184a: 68,
+    0x184b: 68,
+    0x184c: 68,
+    0x184d: 68,
+    0x184e: 68,
+    0x184f: 68,
+    0x1850: 68,
+    0x1851: 68,
+    0x1852: 68,
+    0x1853: 68,
+    0x1854: 68,
+    0x1855: 68,
+    0x1856: 68,
+    0x1857: 68,
+    0x1858: 68,
+    0x1859: 68,
+    0x185a: 68,
+    0x185b: 68,
+    0x185c: 68,
+    0x185d: 68,
+    0x185e: 68,
+    0x185f: 68,
+    0x1860: 68,
+    0x1861: 68,
+    0x1862: 68,
+    0x1863: 68,
+    0x1864: 68,
+    0x1865: 68,
+    0x1866: 68,
+    0x1867: 68,
+    0x1868: 68,
+    0x1869: 68,
+    0x186a: 68,
+    0x186b: 68,
+    0x186c: 68,
+    0x186d: 68,
+    0x186e: 68,
+    0x186f: 68,
+    0x1870: 68,
+    0x1871: 68,
+    0x1872: 68,
+    0x1873: 68,
+    0x1874: 68,
+    0x1875: 68,
+    0x1876: 68,
+    0x1877: 68,
+    0x1878: 68,
+    0x1880: 85,
+    0x1881: 85,
+    0x1882: 85,
+    0x1883: 85,
+    0x1884: 85,
+    0x1885: 84,
+    0x1886: 84,
+    0x1887: 68,
+    0x1888: 68,
+    0x1889: 68,
+    0x188a: 68,
+    0x188b: 68,
+    0x188c: 68,
+    0x188d: 68,
+    0x188e: 68,
+    0x188f: 68,
+    0x1890: 68,
+    0x1891: 68,
+    0x1892: 68,
+    0x1893: 68,
+    0x1894: 68,
+    0x1895: 68,
+    0x1896: 68,
+    0x1897: 68,
+    0x1898: 68,
+    0x1899: 68,
+    0x189a: 68,
+    0x189b: 68,
+    0x189c: 68,
+    0x189d: 68,
+    0x189e: 68,
+    0x189f: 68,
+    0x18a0: 68,
+    0x18a1: 68,
+    0x18a2: 68,
+    0x18a3: 68,
+    0x18a4: 68,
+    0x18a5: 68,
+    0x18a6: 68,
+    0x18a7: 68,
+    0x18a8: 68,
+    0x18aa: 68,
+    0x200c: 85,
+    0x200d: 67,
+    0x202f: 85,
+    0x2066: 85,
+    0x2067: 85,
+    0x2068: 85,
+    0x2069: 85,
+    0xa840: 68,
+    0xa841: 68,
+    0xa842: 68,
+    0xa843: 68,
+    0xa844: 68,
+    0xa845: 68,
+    0xa846: 68,
+    0xa847: 68,
+    0xa848: 68,
+    0xa849: 68,
+    0xa84a: 68,
+    0xa84b: 68,
+    0xa84c: 68,
+    0xa84d: 68,
+    0xa84e: 68,
+    0xa84f: 68,
+    0xa850: 68,
+    0xa851: 68,
+    0xa852: 68,
+    0xa853: 68,
+    0xa854: 68,
+    0xa855: 68,
+    0xa856: 68,
+    0xa857: 68,
+    0xa858: 68,
+    0xa859: 68,
+    0xa85a: 68,
+    0xa85b: 68,
+    0xa85c: 68,
+    0xa85d: 68,
+    0xa85e: 68,
+    0xa85f: 68,
+    0xa860: 68,
+    0xa861: 68,
+    0xa862: 68,
+    0xa863: 68,
+    0xa864: 68,
+    0xa865: 68,
+    0xa866: 68,
+    0xa867: 68,
+    0xa868: 68,
+    0xa869: 68,
+    0xa86a: 68,
+    0xa86b: 68,
+    0xa86c: 68,
+    0xa86d: 68,
+    0xa86e: 68,
+    0xa86f: 68,
+    0xa870: 68,
+    0xa871: 68,
+    0xa872: 76,
+    0xa873: 85,
+    0x10ac0: 68,
+    0x10ac1: 68,
+    0x10ac2: 68,
+    0x10ac3: 68,
+    0x10ac4: 68,
+    0x10ac5: 82,
+    0x10ac6: 85,
+    0x10ac7: 82,
+    0x10ac8: 85,
+    0x10ac9: 82,
+    0x10aca: 82,
+    0x10acb: 85,
+    0x10acc: 85,
+    0x10acd: 76,
+    0x10ace: 82,
+    0x10acf: 82,
+    0x10ad0: 82,
+    0x10ad1: 82,
+    0x10ad2: 82,
+    0x10ad3: 68,
+    0x10ad4: 68,
+    0x10ad5: 68,
+    0x10ad6: 68,
+    0x10ad7: 76,
+    0x10ad8: 68,
+    0x10ad9: 68,
+    0x10ada: 68,
+    0x10adb: 68,
+    0x10adc: 68,
+    0x10add: 82,
+    0x10ade: 68,
+    0x10adf: 68,
+    0x10ae0: 68,
+    0x10ae1: 82,
+    0x10ae2: 85,
+    0x10ae3: 85,
+    0x10ae4: 82,
+    0x10aeb: 68,
+    0x10aec: 68,
+    0x10aed: 68,
+    0x10aee: 68,
+    0x10aef: 82,
+    0x10b80: 68,
+    0x10b81: 82,
+    0x10b82: 68,
+    0x10b83: 82,
+    0x10b84: 82,
+    0x10b85: 82,
+    0x10b86: 68,
+    0x10b87: 68,
+    0x10b88: 68,
+    0x10b89: 82,
+    0x10b8a: 68,
+    0x10b8b: 68,
+    0x10b8c: 82,
+    0x10b8d: 68,
+    0x10b8e: 82,
+    0x10b8f: 82,
+    0x10b90: 68,
+    0x10b91: 82,
+    0x10ba9: 82,
+    0x10baa: 82,
+    0x10bab: 82,
+    0x10bac: 82,
+    0x10bad: 68,
+    0x10bae: 68,
+    0x10baf: 85,
+    0x10d00: 76,
+    0x10d01: 68,
+    0x10d02: 68,
+    0x10d03: 68,
+    0x10d04: 68,
+    0x10d05: 68,
+    0x10d06: 68,
+    0x10d07: 68,
+    0x10d08: 68,
+    0x10d09: 68,
+    0x10d0a: 68,
+    0x10d0b: 68,
+    0x10d0c: 68,
+    0x10d0d: 68,
+    0x10d0e: 68,
+    0x10d0f: 68,
+    0x10d10: 68,
+    0x10d11: 68,
+    0x10d12: 68,
+    0x10d13: 68,
+    0x10d14: 68,
+    0x10d15: 68,
+    0x10d16: 68,
+    0x10d17: 68,
+    0x10d18: 68,
+    0x10d19: 68,
+    0x10d1a: 68,
+    0x10d1b: 68,
+    0x10d1c: 68,
+    0x10d1d: 68,
+    0x10d1e: 68,
+    0x10d1f: 68,
+    0x10d20: 68,
+    0x10d21: 68,
+    0x10d22: 82,
+    0x10d23: 68,
+    0x10f30: 68,
+    0x10f31: 68,
+    0x10f32: 68,
+    0x10f33: 82,
+    0x10f34: 68,
+    0x10f35: 68,
+    0x10f36: 68,
+    0x10f37: 68,
+    0x10f38: 68,
+    0x10f39: 68,
+    0x10f3a: 68,
+    0x10f3b: 68,
+    0x10f3c: 68,
+    0x10f3d: 68,
+    0x10f3e: 68,
+    0x10f3f: 68,
+    0x10f40: 68,
+    0x10f41: 68,
+    0x10f42: 68,
+    0x10f43: 68,
+    0x10f44: 68,
+    0x10f45: 85,
+    0x10f51: 68,
+    0x10f52: 68,
+    0x10f53: 68,
+    0x10f54: 82,
+    0x10fb0: 68,
+    0x10fb1: 85,
+    0x10fb2: 68,
+    0x10fb3: 68,
+    0x10fb4: 82,
+    0x10fb5: 82,
+    0x10fb6: 82,
+    0x10fb7: 85,
+    0x10fb8: 68,
+    0x10fb9: 82,
+    0x10fba: 82,
+    0x10fbb: 68,
+    0x10fbc: 68,
+    0x10fbd: 82,
+    0x10fbe: 68,
+    0x10fbf: 68,
+    0x10fc0: 85,
+    0x10fc1: 68,
+    0x10fc2: 82,
+    0x10fc3: 82,
+    0x10fc4: 68,
+    0x10fc5: 85,
+    0x10fc6: 85,
+    0x10fc7: 85,
+    0x10fc8: 85,
+    0x10fc9: 82,
+    0x10fca: 68,
+    0x10fcb: 76,
+    0x110bd: 85,
+    0x110cd: 85,
+    0x1e900: 68,
+    0x1e901: 68,
+    0x1e902: 68,
+    0x1e903: 68,
+    0x1e904: 68,
+    0x1e905: 68,
+    0x1e906: 68,
+    0x1e907: 68,
+    0x1e908: 68,
+    0x1e909: 68,
+    0x1e90a: 68,
+    0x1e90b: 68,
+    0x1e90c: 68,
+    0x1e90d: 68,
+    0x1e90e: 68,
+    0x1e90f: 68,
+    0x1e910: 68,
+    0x1e911: 68,
+    0x1e912: 68,
+    0x1e913: 68,
+    0x1e914: 68,
+    0x1e915: 68,
+    0x1e916: 68,
+    0x1e917: 68,
+    0x1e918: 68,
+    0x1e919: 68,
+    0x1e91a: 68,
+    0x1e91b: 68,
+    0x1e91c: 68,
+    0x1e91d: 68,
+    0x1e91e: 68,
+    0x1e91f: 68,
+    0x1e920: 68,
+    0x1e921: 68,
+    0x1e922: 68,
+    0x1e923: 68,
+    0x1e924: 68,
+    0x1e925: 68,
+    0x1e926: 68,
+    0x1e927: 68,
+    0x1e928: 68,
+    0x1e929: 68,
+    0x1e92a: 68,
+    0x1e92b: 68,
+    0x1e92c: 68,
+    0x1e92d: 68,
+    0x1e92e: 68,
+    0x1e92f: 68,
+    0x1e930: 68,
+    0x1e931: 68,
+    0x1e932: 68,
+    0x1e933: 68,
+    0x1e934: 68,
+    0x1e935: 68,
+    0x1e936: 68,
+    0x1e937: 68,
+    0x1e938: 68,
+    0x1e939: 68,
+    0x1e93a: 68,
+    0x1e93b: 68,
+    0x1e93c: 68,
+    0x1e93d: 68,
+    0x1e93e: 68,
+    0x1e93f: 68,
+    0x1e940: 68,
+    0x1e941: 68,
+    0x1e942: 68,
+    0x1e943: 68,
+    0x1e94b: 84,
+}
+codepoint_classes = {
+    'PVALID': (
+        0x2d0000002e,
+        0x300000003a,
+        0x610000007b,
+        0xdf000000f7,
+        0xf800000100,
+        0x10100000102,
+        0x10300000104,
+        0x10500000106,
+        0x10700000108,
+        0x1090000010a,
+        0x10b0000010c,
+        0x10d0000010e,
+        0x10f00000110,
+        0x11100000112,
+        0x11300000114,
+        0x11500000116,
+        0x11700000118,
+        0x1190000011a,
+        0x11b0000011c,
+        0x11d0000011e,
+        0x11f00000120,
+        0x12100000122,
+        0x12300000124,
+        0x12500000126,
+        0x12700000128,
+        0x1290000012a,
+        0x12b0000012c,
+        0x12d0000012e,
+        0x12f00000130,
+        0x13100000132,
+        0x13500000136,
+        0x13700000139,
+        0x13a0000013b,
+        0x13c0000013d,
+        0x13e0000013f,
+        0x14200000143,
+        0x14400000145,
+        0x14600000147,
+        0x14800000149,
+        0x14b0000014c,
+        0x14d0000014e,
+        0x14f00000150,
+        0x15100000152,
+        0x15300000154,
+        0x15500000156,
+        0x15700000158,
+        0x1590000015a,
+        0x15b0000015c,
+        0x15d0000015e,
+        0x15f00000160,
+        0x16100000162,
+        0x16300000164,
+        0x16500000166,
+        0x16700000168,
+        0x1690000016a,
+        0x16b0000016c,
+        0x16d0000016e,
+        0x16f00000170,
+        0x17100000172,
+        0x17300000174,
+        0x17500000176,
+        0x17700000178,
+        0x17a0000017b,
+        0x17c0000017d,
+        0x17e0000017f,
+        0x18000000181,
+        0x18300000184,
+        0x18500000186,
+        0x18800000189,
+        0x18c0000018e,
+        0x19200000193,
+        0x19500000196,
+        0x1990000019c,
+        0x19e0000019f,
+        0x1a1000001a2,
+        0x1a3000001a4,
+        0x1a5000001a6,
+        0x1a8000001a9,
+        0x1aa000001ac,
+        0x1ad000001ae,
+        0x1b0000001b1,
+        0x1b4000001b5,
+        0x1b6000001b7,
+        0x1b9000001bc,
+        0x1bd000001c4,
+        0x1ce000001cf,
+        0x1d0000001d1,
+        0x1d2000001d3,
+        0x1d4000001d5,
+        0x1d6000001d7,
+        0x1d8000001d9,
+        0x1da000001db,
+        0x1dc000001de,
+        0x1df000001e0,
+        0x1e1000001e2,
+        0x1e3000001e4,
+        0x1e5000001e6,
+        0x1e7000001e8,
+        0x1e9000001ea,
+        0x1eb000001ec,
+        0x1ed000001ee,
+        0x1ef000001f1,
+        0x1f5000001f6,
+        0x1f9000001fa,
+        0x1fb000001fc,
+        0x1fd000001fe,
+        0x1ff00000200,
+        0x20100000202,
+        0x20300000204,
+        0x20500000206,
+        0x20700000208,
+        0x2090000020a,
+        0x20b0000020c,
+        0x20d0000020e,
+        0x20f00000210,
+        0x21100000212,
+        0x21300000214,
+        0x21500000216,
+        0x21700000218,
+        0x2190000021a,
+        0x21b0000021c,
+        0x21d0000021e,
+        0x21f00000220,
+        0x22100000222,
+        0x22300000224,
+        0x22500000226,
+        0x22700000228,
+        0x2290000022a,
+        0x22b0000022c,
+        0x22d0000022e,
+        0x22f00000230,
+        0x23100000232,
+        0x2330000023a,
+        0x23c0000023d,
+        0x23f00000241,
+        0x24200000243,
+        0x24700000248,
+        0x2490000024a,
+        0x24b0000024c,
+        0x24d0000024e,
+        0x24f000002b0,
+        0x2b9000002c2,
+        0x2c6000002d2,
+        0x2ec000002ed,
+        0x2ee000002ef,
+        0x30000000340,
+        0x34200000343,
+        0x3460000034f,
+        0x35000000370,
+        0x37100000372,
+        0x37300000374,
+        0x37700000378,
+        0x37b0000037e,
+        0x39000000391,
+        0x3ac000003cf,
+        0x3d7000003d8,
+        0x3d9000003da,
+        0x3db000003dc,
+        0x3dd000003de,
+        0x3df000003e0,
+        0x3e1000003e2,
+        0x3e3000003e4,
+        0x3e5000003e6,
+        0x3e7000003e8,
+        0x3e9000003ea,
+        0x3eb000003ec,
+        0x3ed000003ee,
+        0x3ef000003f0,
+        0x3f3000003f4,
+        0x3f8000003f9,
+        0x3fb000003fd,
+        0x43000000460,
+        0x46100000462,
+        0x46300000464,
+        0x46500000466,
+        0x46700000468,
+        0x4690000046a,
+        0x46b0000046c,
+        0x46d0000046e,
+        0x46f00000470,
+        0x47100000472,
+        0x47300000474,
+        0x47500000476,
+        0x47700000478,
+        0x4790000047a,
+        0x47b0000047c,
+        0x47d0000047e,
+        0x47f00000480,
+        0x48100000482,
+        0x48300000488,
+        0x48b0000048c,
+        0x48d0000048e,
+        0x48f00000490,
+        0x49100000492,
+        0x49300000494,
+        0x49500000496,
+        0x49700000498,
+        0x4990000049a,
+        0x49b0000049c,
+        0x49d0000049e,
+        0x49f000004a0,
+        0x4a1000004a2,
+        0x4a3000004a4,
+        0x4a5000004a6,
+        0x4a7000004a8,
+        0x4a9000004aa,
+        0x4ab000004ac,
+        0x4ad000004ae,
+        0x4af000004b0,
+        0x4b1000004b2,
+        0x4b3000004b4,
+        0x4b5000004b6,
+        0x4b7000004b8,
+        0x4b9000004ba,
+        0x4bb000004bc,
+        0x4bd000004be,
+        0x4bf000004c0,
+        0x4c2000004c3,
+        0x4c4000004c5,
+        0x4c6000004c7,
+        0x4c8000004c9,
+        0x4ca000004cb,
+        0x4cc000004cd,
+        0x4ce000004d0,
+        0x4d1000004d2,
+        0x4d3000004d4,
+        0x4d5000004d6,
+        0x4d7000004d8,
+        0x4d9000004da,
+        0x4db000004dc,
+        0x4dd000004de,
+        0x4df000004e0,
+        0x4e1000004e2,
+        0x4e3000004e4,
+        0x4e5000004e6,
+        0x4e7000004e8,
+        0x4e9000004ea,
+        0x4eb000004ec,
+        0x4ed000004ee,
+        0x4ef000004f0,
+        0x4f1000004f2,
+        0x4f3000004f4,
+        0x4f5000004f6,
+        0x4f7000004f8,
+        0x4f9000004fa,
+        0x4fb000004fc,
+        0x4fd000004fe,
+        0x4ff00000500,
+        0x50100000502,
+        0x50300000504,
+        0x50500000506,
+        0x50700000508,
+        0x5090000050a,
+        0x50b0000050c,
+        0x50d0000050e,
+        0x50f00000510,
+        0x51100000512,
+        0x51300000514,
+        0x51500000516,
+        0x51700000518,
+        0x5190000051a,
+        0x51b0000051c,
+        0x51d0000051e,
+        0x51f00000520,
+        0x52100000522,
+        0x52300000524,
+        0x52500000526,
+        0x52700000528,
+        0x5290000052a,
+        0x52b0000052c,
+        0x52d0000052e,
+        0x52f00000530,
+        0x5590000055a,
+        0x56000000587,
+        0x58800000589,
+        0x591000005be,
+        0x5bf000005c0,
+        0x5c1000005c3,
+        0x5c4000005c6,
+        0x5c7000005c8,
+        0x5d0000005eb,
+        0x5ef000005f3,
+        0x6100000061b,
+        0x62000000640,
+        0x64100000660,
+        0x66e00000675,
+        0x679000006d4,
+        0x6d5000006dd,
+        0x6df000006e9,
+        0x6ea000006f0,
+        0x6fa00000700,
+        0x7100000074b,
+        0x74d000007b2,
+        0x7c0000007f6,
+        0x7fd000007fe,
+        0x8000000082e,
+        0x8400000085c,
+        0x8600000086b,
+        0x8a0000008b5,
+        0x8b6000008c8,
+        0x8d3000008e2,
+        0x8e300000958,
+        0x96000000964,
+        0x96600000970,
+        0x97100000984,
+        0x9850000098d,
+        0x98f00000991,
+        0x993000009a9,
+        0x9aa000009b1,
+        0x9b2000009b3,
+        0x9b6000009ba,
+        0x9bc000009c5,
+        0x9c7000009c9,
+        0x9cb000009cf,
+        0x9d7000009d8,
+        0x9e0000009e4,
+        0x9e6000009f2,
+        0x9fc000009fd,
+        0x9fe000009ff,
+        0xa0100000a04,
+        0xa0500000a0b,
+        0xa0f00000a11,
+        0xa1300000a29,
+        0xa2a00000a31,
+        0xa3200000a33,
+        0xa3500000a36,
+        0xa3800000a3a,
+        0xa3c00000a3d,
+        0xa3e00000a43,
+        0xa4700000a49,
+        0xa4b00000a4e,
+        0xa5100000a52,
+        0xa5c00000a5d,
+        0xa6600000a76,
+        0xa8100000a84,
+        0xa8500000a8e,
+        0xa8f00000a92,
+        0xa9300000aa9,
+        0xaaa00000ab1,
+        0xab200000ab4,
+        0xab500000aba,
+        0xabc00000ac6,
+        0xac700000aca,
+        0xacb00000ace,
+        0xad000000ad1,
+        0xae000000ae4,
+        0xae600000af0,
+        0xaf900000b00,
+        0xb0100000b04,
+        0xb0500000b0d,
+        0xb0f00000b11,
+        0xb1300000b29,
+        0xb2a00000b31,
+        0xb3200000b34,
+        0xb3500000b3a,
+        0xb3c00000b45,
+        0xb4700000b49,
+        0xb4b00000b4e,
+        0xb5500000b58,
+        0xb5f00000b64,
+        0xb6600000b70,
+        0xb7100000b72,
+        0xb8200000b84,
+        0xb8500000b8b,
+        0xb8e00000b91,
+        0xb9200000b96,
+        0xb9900000b9b,
+        0xb9c00000b9d,
+        0xb9e00000ba0,
+        0xba300000ba5,
+        0xba800000bab,
+        0xbae00000bba,
+        0xbbe00000bc3,
+        0xbc600000bc9,
+        0xbca00000bce,
+        0xbd000000bd1,
+        0xbd700000bd8,
+        0xbe600000bf0,
+        0xc0000000c0d,
+        0xc0e00000c11,
+        0xc1200000c29,
+        0xc2a00000c3a,
+        0xc3d00000c45,
+        0xc4600000c49,
+        0xc4a00000c4e,
+        0xc5500000c57,
+        0xc5800000c5b,
+        0xc6000000c64,
+        0xc6600000c70,
+        0xc8000000c84,
+        0xc8500000c8d,
+        0xc8e00000c91,
+        0xc9200000ca9,
+        0xcaa00000cb4,
+        0xcb500000cba,
+        0xcbc00000cc5,
+        0xcc600000cc9,
+        0xcca00000cce,
+        0xcd500000cd7,
+        0xcde00000cdf,
+        0xce000000ce4,
+        0xce600000cf0,
+        0xcf100000cf3,
+        0xd0000000d0d,
+        0xd0e00000d11,
+        0xd1200000d45,
+        0xd4600000d49,
+        0xd4a00000d4f,
+        0xd5400000d58,
+        0xd5f00000d64,
+        0xd6600000d70,
+        0xd7a00000d80,
+        0xd8100000d84,
+        0xd8500000d97,
+        0xd9a00000db2,
+        0xdb300000dbc,
+        0xdbd00000dbe,
+        0xdc000000dc7,
+        0xdca00000dcb,
+        0xdcf00000dd5,
+        0xdd600000dd7,
+        0xdd800000de0,
+        0xde600000df0,
+        0xdf200000df4,
+        0xe0100000e33,
+        0xe3400000e3b,
+        0xe4000000e4f,
+        0xe5000000e5a,
+        0xe8100000e83,
+        0xe8400000e85,
+        0xe8600000e8b,
+        0xe8c00000ea4,
+        0xea500000ea6,
+        0xea700000eb3,
+        0xeb400000ebe,
+        0xec000000ec5,
+        0xec600000ec7,
+        0xec800000ece,
+        0xed000000eda,
+        0xede00000ee0,
+        0xf0000000f01,
+        0xf0b00000f0c,
+        0xf1800000f1a,
+        0xf2000000f2a,
+        0xf3500000f36,
+        0xf3700000f38,
+        0xf3900000f3a,
+        0xf3e00000f43,
+        0xf4400000f48,
+        0xf4900000f4d,
+        0xf4e00000f52,
+        0xf5300000f57,
+        0xf5800000f5c,
+        0xf5d00000f69,
+        0xf6a00000f6d,
+        0xf7100000f73,
+        0xf7400000f75,
+        0xf7a00000f81,
+        0xf8200000f85,
+        0xf8600000f93,
+        0xf9400000f98,
+        0xf9900000f9d,
+        0xf9e00000fa2,
+        0xfa300000fa7,
+        0xfa800000fac,
+        0xfad00000fb9,
+        0xfba00000fbd,
+        0xfc600000fc7,
+        0x10000000104a,
+        0x10500000109e,
+        0x10d0000010fb,
+        0x10fd00001100,
+        0x120000001249,
+        0x124a0000124e,
+        0x125000001257,
+        0x125800001259,
+        0x125a0000125e,
+        0x126000001289,
+        0x128a0000128e,
+        0x1290000012b1,
+        0x12b2000012b6,
+        0x12b8000012bf,
+        0x12c0000012c1,
+        0x12c2000012c6,
+        0x12c8000012d7,
+        0x12d800001311,
+        0x131200001316,
+        0x13180000135b,
+        0x135d00001360,
+        0x138000001390,
+        0x13a0000013f6,
+        0x14010000166d,
+        0x166f00001680,
+        0x16810000169b,
+        0x16a0000016eb,
+        0x16f1000016f9,
+        0x17000000170d,
+        0x170e00001715,
+        0x172000001735,
+        0x174000001754,
+        0x17600000176d,
+        0x176e00001771,
+        0x177200001774,
+        0x1780000017b4,
+        0x17b6000017d4,
+        0x17d7000017d8,
+        0x17dc000017de,
+        0x17e0000017ea,
+        0x18100000181a,
+        0x182000001879,
+        0x1880000018ab,
+        0x18b0000018f6,
+        0x19000000191f,
+        0x19200000192c,
+        0x19300000193c,
+        0x19460000196e,
+        0x197000001975,
+        0x1980000019ac,
+        0x19b0000019ca,
+        0x19d0000019da,
+        0x1a0000001a1c,
+        0x1a2000001a5f,
+        0x1a6000001a7d,
+        0x1a7f00001a8a,
+        0x1a9000001a9a,
+        0x1aa700001aa8,
+        0x1ab000001abe,
+        0x1abf00001ac1,
+        0x1b0000001b4c,
+        0x1b5000001b5a,
+        0x1b6b00001b74,
+        0x1b8000001bf4,
+        0x1c0000001c38,
+        0x1c4000001c4a,
+        0x1c4d00001c7e,
+        0x1cd000001cd3,
+        0x1cd400001cfb,
+        0x1d0000001d2c,
+        0x1d2f00001d30,
+        0x1d3b00001d3c,
+        0x1d4e00001d4f,
+        0x1d6b00001d78,
+        0x1d7900001d9b,
+        0x1dc000001dfa,
+        0x1dfb00001e00,
+        0x1e0100001e02,
+        0x1e0300001e04,
+        0x1e0500001e06,
+        0x1e0700001e08,
+        0x1e0900001e0a,
+        0x1e0b00001e0c,
+        0x1e0d00001e0e,
+        0x1e0f00001e10,
+        0x1e1100001e12,
+        0x1e1300001e14,
+        0x1e1500001e16,
+        0x1e1700001e18,
+        0x1e1900001e1a,
+        0x1e1b00001e1c,
+        0x1e1d00001e1e,
+        0x1e1f00001e20,
+        0x1e2100001e22,
+        0x1e2300001e24,
+        0x1e2500001e26,
+        0x1e2700001e28,
+        0x1e2900001e2a,
+        0x1e2b00001e2c,
+        0x1e2d00001e2e,
+        0x1e2f00001e30,
+        0x1e3100001e32,
+        0x1e3300001e34,
+        0x1e3500001e36,
+        0x1e3700001e38,
+        0x1e3900001e3a,
+        0x1e3b00001e3c,
+        0x1e3d00001e3e,
+        0x1e3f00001e40,
+        0x1e4100001e42,
+        0x1e4300001e44,
+        0x1e4500001e46,
+        0x1e4700001e48,
+        0x1e4900001e4a,
+        0x1e4b00001e4c,
+        0x1e4d00001e4e,
+        0x1e4f00001e50,
+        0x1e5100001e52,
+        0x1e5300001e54,
+        0x1e5500001e56,
+        0x1e5700001e58,
+        0x1e5900001e5a,
+        0x1e5b00001e5c,
+        0x1e5d00001e5e,
+        0x1e5f00001e60,
+        0x1e6100001e62,
+        0x1e6300001e64,
+        0x1e6500001e66,
+        0x1e6700001e68,
+        0x1e6900001e6a,
+        0x1e6b00001e6c,
+        0x1e6d00001e6e,
+        0x1e6f00001e70,
+        0x1e7100001e72,
+        0x1e7300001e74,
+        0x1e7500001e76,
+        0x1e7700001e78,
+        0x1e7900001e7a,
+        0x1e7b00001e7c,
+        0x1e7d00001e7e,
+        0x1e7f00001e80,
+        0x1e8100001e82,
+        0x1e8300001e84,
+        0x1e8500001e86,
+        0x1e8700001e88,
+        0x1e8900001e8a,
+        0x1e8b00001e8c,
+        0x1e8d00001e8e,
+        0x1e8f00001e90,
+        0x1e9100001e92,
+        0x1e9300001e94,
+        0x1e9500001e9a,
+        0x1e9c00001e9e,
+        0x1e9f00001ea0,
+        0x1ea100001ea2,
+        0x1ea300001ea4,
+        0x1ea500001ea6,
+        0x1ea700001ea8,
+        0x1ea900001eaa,
+        0x1eab00001eac,
+        0x1ead00001eae,
+        0x1eaf00001eb0,
+        0x1eb100001eb2,
+        0x1eb300001eb4,
+        0x1eb500001eb6,
+        0x1eb700001eb8,
+        0x1eb900001eba,
+        0x1ebb00001ebc,
+        0x1ebd00001ebe,
+        0x1ebf00001ec0,
+        0x1ec100001ec2,
+        0x1ec300001ec4,
+        0x1ec500001ec6,
+        0x1ec700001ec8,
+        0x1ec900001eca,
+        0x1ecb00001ecc,
+        0x1ecd00001ece,
+        0x1ecf00001ed0,
+        0x1ed100001ed2,
+        0x1ed300001ed4,
+        0x1ed500001ed6,
+        0x1ed700001ed8,
+        0x1ed900001eda,
+        0x1edb00001edc,
+        0x1edd00001ede,
+        0x1edf00001ee0,
+        0x1ee100001ee2,
+        0x1ee300001ee4,
+        0x1ee500001ee6,
+        0x1ee700001ee8,
+        0x1ee900001eea,
+        0x1eeb00001eec,
+        0x1eed00001eee,
+        0x1eef00001ef0,
+        0x1ef100001ef2,
+        0x1ef300001ef4,
+        0x1ef500001ef6,
+        0x1ef700001ef8,
+        0x1ef900001efa,
+        0x1efb00001efc,
+        0x1efd00001efe,
+        0x1eff00001f08,
+        0x1f1000001f16,
+        0x1f2000001f28,
+        0x1f3000001f38,
+        0x1f4000001f46,
+        0x1f5000001f58,
+        0x1f6000001f68,
+        0x1f7000001f71,
+        0x1f7200001f73,
+        0x1f7400001f75,
+        0x1f7600001f77,
+        0x1f7800001f79,
+        0x1f7a00001f7b,
+        0x1f7c00001f7d,
+        0x1fb000001fb2,
+        0x1fb600001fb7,
+        0x1fc600001fc7,
+        0x1fd000001fd3,
+        0x1fd600001fd8,
+        0x1fe000001fe3,
+        0x1fe400001fe8,
+        0x1ff600001ff7,
+        0x214e0000214f,
+        0x218400002185,
+        0x2c3000002c5f,
+        0x2c6100002c62,
+        0x2c6500002c67,
+        0x2c6800002c69,
+        0x2c6a00002c6b,
+        0x2c6c00002c6d,
+        0x2c7100002c72,
+        0x2c7300002c75,
+        0x2c7600002c7c,
+        0x2c8100002c82,
+        0x2c8300002c84,
+        0x2c8500002c86,
+        0x2c8700002c88,
+        0x2c8900002c8a,
+        0x2c8b00002c8c,
+        0x2c8d00002c8e,
+        0x2c8f00002c90,
+        0x2c9100002c92,
+        0x2c9300002c94,
+        0x2c9500002c96,
+        0x2c9700002c98,
+        0x2c9900002c9a,
+        0x2c9b00002c9c,
+        0x2c9d00002c9e,
+        0x2c9f00002ca0,
+        0x2ca100002ca2,
+        0x2ca300002ca4,
+        0x2ca500002ca6,
+        0x2ca700002ca8,
+        0x2ca900002caa,
+        0x2cab00002cac,
+        0x2cad00002cae,
+        0x2caf00002cb0,
+        0x2cb100002cb2,
+        0x2cb300002cb4,
+        0x2cb500002cb6,
+        0x2cb700002cb8,
+        0x2cb900002cba,
+        0x2cbb00002cbc,
+        0x2cbd00002cbe,
+        0x2cbf00002cc0,
+        0x2cc100002cc2,
+        0x2cc300002cc4,
+        0x2cc500002cc6,
+        0x2cc700002cc8,
+        0x2cc900002cca,
+        0x2ccb00002ccc,
+        0x2ccd00002cce,
+        0x2ccf00002cd0,
+        0x2cd100002cd2,
+        0x2cd300002cd4,
+        0x2cd500002cd6,
+        0x2cd700002cd8,
+        0x2cd900002cda,
+        0x2cdb00002cdc,
+        0x2cdd00002cde,
+        0x2cdf00002ce0,
+        0x2ce100002ce2,
+        0x2ce300002ce5,
+        0x2cec00002ced,
+        0x2cee00002cf2,
+        0x2cf300002cf4,
+        0x2d0000002d26,
+        0x2d2700002d28,
+        0x2d2d00002d2e,
+        0x2d3000002d68,
+        0x2d7f00002d97,
+        0x2da000002da7,
+        0x2da800002daf,
+        0x2db000002db7,
+        0x2db800002dbf,
+        0x2dc000002dc7,
+        0x2dc800002dcf,
+        0x2dd000002dd7,
+        0x2dd800002ddf,
+        0x2de000002e00,
+        0x2e2f00002e30,
+        0x300500003008,
+        0x302a0000302e,
+        0x303c0000303d,
+        0x304100003097,
+        0x30990000309b,
+        0x309d0000309f,
+        0x30a1000030fb,
+        0x30fc000030ff,
+        0x310500003130,
+        0x31a0000031c0,
+        0x31f000003200,
+        0x340000004dc0,
+        0x4e0000009ffd,
+        0xa0000000a48d,
+        0xa4d00000a4fe,
+        0xa5000000a60d,
+        0xa6100000a62c,
+        0xa6410000a642,
+        0xa6430000a644,
+        0xa6450000a646,
+        0xa6470000a648,
+        0xa6490000a64a,
+        0xa64b0000a64c,
+        0xa64d0000a64e,
+        0xa64f0000a650,
+        0xa6510000a652,
+        0xa6530000a654,
+        0xa6550000a656,
+        0xa6570000a658,
+        0xa6590000a65a,
+        0xa65b0000a65c,
+        0xa65d0000a65e,
+        0xa65f0000a660,
+        0xa6610000a662,
+        0xa6630000a664,
+        0xa6650000a666,
+        0xa6670000a668,
+        0xa6690000a66a,
+        0xa66b0000a66c,
+        0xa66d0000a670,
+        0xa6740000a67e,
+        0xa67f0000a680,
+        0xa6810000a682,
+        0xa6830000a684,
+        0xa6850000a686,
+        0xa6870000a688,
+        0xa6890000a68a,
+        0xa68b0000a68c,
+        0xa68d0000a68e,
+        0xa68f0000a690,
+        0xa6910000a692,
+        0xa6930000a694,
+        0xa6950000a696,
+        0xa6970000a698,
+        0xa6990000a69a,
+        0xa69b0000a69c,
+        0xa69e0000a6e6,
+        0xa6f00000a6f2,
+        0xa7170000a720,
+        0xa7230000a724,
+        0xa7250000a726,
+        0xa7270000a728,
+        0xa7290000a72a,
+        0xa72b0000a72c,
+        0xa72d0000a72e,
+        0xa72f0000a732,
+        0xa7330000a734,
+        0xa7350000a736,
+        0xa7370000a738,
+        0xa7390000a73a,
+        0xa73b0000a73c,
+        0xa73d0000a73e,
+        0xa73f0000a740,
+        0xa7410000a742,
+        0xa7430000a744,
+        0xa7450000a746,
+        0xa7470000a748,
+        0xa7490000a74a,
+        0xa74b0000a74c,
+        0xa74d0000a74e,
+        0xa74f0000a750,
+        0xa7510000a752,
+        0xa7530000a754,
+        0xa7550000a756,
+        0xa7570000a758,
+        0xa7590000a75a,
+        0xa75b0000a75c,
+        0xa75d0000a75e,
+        0xa75f0000a760,
+        0xa7610000a762,
+        0xa7630000a764,
+        0xa7650000a766,
+        0xa7670000a768,
+        0xa7690000a76a,
+        0xa76b0000a76c,
+        0xa76d0000a76e,
+        0xa76f0000a770,
+        0xa7710000a779,
+        0xa77a0000a77b,
+        0xa77c0000a77d,
+        0xa77f0000a780,
+        0xa7810000a782,
+        0xa7830000a784,
+        0xa7850000a786,
+        0xa7870000a789,
+        0xa78c0000a78d,
+        0xa78e0000a790,
+        0xa7910000a792,
+        0xa7930000a796,
+        0xa7970000a798,
+        0xa7990000a79a,
+        0xa79b0000a79c,
+        0xa79d0000a79e,
+        0xa79f0000a7a0,
+        0xa7a10000a7a2,
+        0xa7a30000a7a4,
+        0xa7a50000a7a6,
+        0xa7a70000a7a8,
+        0xa7a90000a7aa,
+        0xa7af0000a7b0,
+        0xa7b50000a7b6,
+        0xa7b70000a7b8,
+        0xa7b90000a7ba,
+        0xa7bb0000a7bc,
+        0xa7bd0000a7be,
+        0xa7bf0000a7c0,
+        0xa7c30000a7c4,
+        0xa7c80000a7c9,
+        0xa7ca0000a7cb,
+        0xa7f60000a7f8,
+        0xa7fa0000a828,
+        0xa82c0000a82d,
+        0xa8400000a874,
+        0xa8800000a8c6,
+        0xa8d00000a8da,
+        0xa8e00000a8f8,
+        0xa8fb0000a8fc,
+        0xa8fd0000a92e,
+        0xa9300000a954,
+        0xa9800000a9c1,
+        0xa9cf0000a9da,
+        0xa9e00000a9ff,
+        0xaa000000aa37,
+        0xaa400000aa4e,
+        0xaa500000aa5a,
+        0xaa600000aa77,
+        0xaa7a0000aac3,
+        0xaadb0000aade,
+        0xaae00000aaf0,
+        0xaaf20000aaf7,
+        0xab010000ab07,
+        0xab090000ab0f,
+        0xab110000ab17,
+        0xab200000ab27,
+        0xab280000ab2f,
+        0xab300000ab5b,
+        0xab600000ab6a,
+        0xabc00000abeb,
+        0xabec0000abee,
+        0xabf00000abfa,
+        0xac000000d7a4,
+        0xfa0e0000fa10,
+        0xfa110000fa12,
+        0xfa130000fa15,
+        0xfa1f0000fa20,
+        0xfa210000fa22,
+        0xfa230000fa25,
+        0xfa270000fa2a,
+        0xfb1e0000fb1f,
+        0xfe200000fe30,
+        0xfe730000fe74,
+        0x100000001000c,
+        0x1000d00010027,
+        0x100280001003b,
+        0x1003c0001003e,
+        0x1003f0001004e,
+        0x100500001005e,
+        0x10080000100fb,
+        0x101fd000101fe,
+        0x102800001029d,
+        0x102a0000102d1,
+        0x102e0000102e1,
+        0x1030000010320,
+        0x1032d00010341,
+        0x103420001034a,
+        0x103500001037b,
+        0x103800001039e,
+        0x103a0000103c4,
+        0x103c8000103d0,
+        0x104280001049e,
+        0x104a0000104aa,
+        0x104d8000104fc,
+        0x1050000010528,
+        0x1053000010564,
+        0x1060000010737,
+        0x1074000010756,
+        0x1076000010768,
+        0x1080000010806,
+        0x1080800010809,
+        0x1080a00010836,
+        0x1083700010839,
+        0x1083c0001083d,
+        0x1083f00010856,
+        0x1086000010877,
+        0x108800001089f,
+        0x108e0000108f3,
+        0x108f4000108f6,
+        0x1090000010916,
+        0x109200001093a,
+        0x10980000109b8,
+        0x109be000109c0,
+        0x10a0000010a04,
+        0x10a0500010a07,
+        0x10a0c00010a14,
+        0x10a1500010a18,
+        0x10a1900010a36,
+        0x10a3800010a3b,
+        0x10a3f00010a40,
+        0x10a6000010a7d,
+        0x10a8000010a9d,
+        0x10ac000010ac8,
+        0x10ac900010ae7,
+        0x10b0000010b36,
+        0x10b4000010b56,
+        0x10b6000010b73,
+        0x10b8000010b92,
+        0x10c0000010c49,
+        0x10cc000010cf3,
+        0x10d0000010d28,
+        0x10d3000010d3a,
+        0x10e8000010eaa,
+        0x10eab00010ead,
+        0x10eb000010eb2,
+        0x10f0000010f1d,
+        0x10f2700010f28,
+        0x10f3000010f51,
+        0x10fb000010fc5,
+        0x10fe000010ff7,
+        0x1100000011047,
+        0x1106600011070,
+        0x1107f000110bb,
+        0x110d0000110e9,
+        0x110f0000110fa,
+        0x1110000011135,
+        0x1113600011140,
+        0x1114400011148,
+        0x1115000011174,
+        0x1117600011177,
+        0x11180000111c5,
+        0x111c9000111cd,
+        0x111ce000111db,
+        0x111dc000111dd,
+        0x1120000011212,
+        0x1121300011238,
+        0x1123e0001123f,
+        0x1128000011287,
+        0x1128800011289,
+        0x1128a0001128e,
+        0x1128f0001129e,
+        0x1129f000112a9,
+        0x112b0000112eb,
+        0x112f0000112fa,
+        0x1130000011304,
+        0x113050001130d,
+        0x1130f00011311,
+        0x1131300011329,
+        0x1132a00011331,
+        0x1133200011334,
+        0x113350001133a,
+        0x1133b00011345,
+        0x1134700011349,
+        0x1134b0001134e,
+        0x1135000011351,
+        0x1135700011358,
+        0x1135d00011364,
+        0x113660001136d,
+        0x1137000011375,
+        0x114000001144b,
+        0x114500001145a,
+        0x1145e00011462,
+        0x11480000114c6,
+        0x114c7000114c8,
+        0x114d0000114da,
+        0x11580000115b6,
+        0x115b8000115c1,
+        0x115d8000115de,
+        0x1160000011641,
+        0x1164400011645,
+        0x116500001165a,
+        0x11680000116b9,
+        0x116c0000116ca,
+        0x117000001171b,
+        0x1171d0001172c,
+        0x117300001173a,
+        0x118000001183b,
+        0x118c0000118ea,
+        0x118ff00011907,
+        0x119090001190a,
+        0x1190c00011914,
+        0x1191500011917,
+        0x1191800011936,
+        0x1193700011939,
+        0x1193b00011944,
+        0x119500001195a,
+        0x119a0000119a8,
+        0x119aa000119d8,
+        0x119da000119e2,
+        0x119e3000119e5,
+        0x11a0000011a3f,
+        0x11a4700011a48,
+        0x11a5000011a9a,
+        0x11a9d00011a9e,
+        0x11ac000011af9,
+        0x11c0000011c09,
+        0x11c0a00011c37,
+        0x11c3800011c41,
+        0x11c5000011c5a,
+        0x11c7200011c90,
+        0x11c9200011ca8,
+        0x11ca900011cb7,
+        0x11d0000011d07,
+        0x11d0800011d0a,
+        0x11d0b00011d37,
+        0x11d3a00011d3b,
+        0x11d3c00011d3e,
+        0x11d3f00011d48,
+        0x11d5000011d5a,
+        0x11d6000011d66,
+        0x11d6700011d69,
+        0x11d6a00011d8f,
+        0x11d9000011d92,
+        0x11d9300011d99,
+        0x11da000011daa,
+        0x11ee000011ef7,
+        0x11fb000011fb1,
+        0x120000001239a,
+        0x1248000012544,
+        0x130000001342f,
+        0x1440000014647,
+        0x1680000016a39,
+        0x16a4000016a5f,
+        0x16a6000016a6a,
+        0x16ad000016aee,
+        0x16af000016af5,
+        0x16b0000016b37,
+        0x16b4000016b44,
+        0x16b5000016b5a,
+        0x16b6300016b78,
+        0x16b7d00016b90,
+        0x16e6000016e80,
+        0x16f0000016f4b,
+        0x16f4f00016f88,
+        0x16f8f00016fa0,
+        0x16fe000016fe2,
+        0x16fe300016fe5,
+        0x16ff000016ff2,
+        0x17000000187f8,
+        0x1880000018cd6,
+        0x18d0000018d09,
+        0x1b0000001b11f,
+        0x1b1500001b153,
+        0x1b1640001b168,
+        0x1b1700001b2fc,
+        0x1bc000001bc6b,
+        0x1bc700001bc7d,
+        0x1bc800001bc89,
+        0x1bc900001bc9a,
+        0x1bc9d0001bc9f,
+        0x1da000001da37,
+        0x1da3b0001da6d,
+        0x1da750001da76,
+        0x1da840001da85,
+        0x1da9b0001daa0,
+        0x1daa10001dab0,
+        0x1e0000001e007,
+        0x1e0080001e019,
+        0x1e01b0001e022,
+        0x1e0230001e025,
+        0x1e0260001e02b,
+        0x1e1000001e12d,
+        0x1e1300001e13e,
+        0x1e1400001e14a,
+        0x1e14e0001e14f,
+        0x1e2c00001e2fa,
+        0x1e8000001e8c5,
+        0x1e8d00001e8d7,
+        0x1e9220001e94c,
+        0x1e9500001e95a,
+        0x1fbf00001fbfa,
+        0x200000002a6de,
+        0x2a7000002b735,
+        0x2b7400002b81e,
+        0x2b8200002cea2,
+        0x2ceb00002ebe1,
+        0x300000003134b,
+    ),
+    'CONTEXTJ': (
+        0x200c0000200e,
+    ),
+    'CONTEXTO': (
+        0xb7000000b8,
+        0x37500000376,
+        0x5f3000005f5,
+        0x6600000066a,
+        0x6f0000006fa,
+        0x30fb000030fc,
+    ),
+}
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/idna/intranges.py b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/intranges.py
new file mode 100644
index 0000000..fa8a735
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/intranges.py
@@ -0,0 +1,53 @@
+"""
+Given a list of integers, made up of (hopefully) a small number of long runs
+of consecutive integers, compute a representation of the form
+((start1, end1), (start2, end2) ...). Then answer the question "was x present
+in the original list?" in time O(log(# runs)).
+"""
+
+import bisect
+
+def intranges_from_list(list_):
+    """Represent a list of integers as a sequence of ranges:
+    ((start_0, end_0), (start_1, end_1), ...), such that the original
+    integers are exactly those x such that start_i <= x < end_i for some i.
+
+    Ranges are encoded as single integers (start << 32 | end), not as tuples.
+    """
+
+    sorted_list = sorted(list_)
+    ranges = []
+    last_write = -1
+    for i in range(len(sorted_list)):
+        if i+1 < len(sorted_list):
+            if sorted_list[i] == sorted_list[i+1]-1:
+                continue
+        current_range = sorted_list[last_write+1:i+1]
+        ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
+        last_write = i
+
+    return tuple(ranges)
+
+def _encode_range(start, end):
+    return (start << 32) | end
+
+def _decode_range(r):
+    return (r >> 32), (r & ((1 << 32) - 1))
+
+
+def intranges_contain(int_, ranges):
+    """Determine if `int_` falls into one of the ranges in `ranges`."""
+    tuple_ = _encode_range(int_, 0)
+    pos = bisect.bisect_left(ranges, tuple_)
+    # we could be immediately ahead of a tuple (start, end)
+    # with start < int_ <= end
+    if pos > 0:
+        left, right = _decode_range(ranges[pos-1])
+        if left <= int_ < right:
+            return True
+    # or we could be immediately behind a tuple (int_, end)
+    if pos < len(ranges):
+        left, _ = _decode_range(ranges[pos])
+        if left == int_:
+            return True
+    return False
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/idna/package_data.py b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/package_data.py
new file mode 100644
index 0000000..ce1c521
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/package_data.py
@@ -0,0 +1,2 @@
+__version__ = '2.10'
+
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/idna/uts46data.py b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/uts46data.py
new file mode 100644
index 0000000..3766dd4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/idna/uts46data.py
@@ -0,0 +1,8357 @@
+# This file is automatically generated by tools/idna-data
+# vim: set fileencoding=utf-8 :
+
+"""IDNA Mapping Table from UTS46."""
+
+
+__version__ = "13.0.0"
+def _seg_0():
+    return [
+    (0x0, '3'),
+    (0x1, '3'),
+    (0x2, '3'),
+    (0x3, '3'),
+    (0x4, '3'),
+    (0x5, '3'),
+    (0x6, '3'),
+    (0x7, '3'),
+    (0x8, '3'),
+    (0x9, '3'),
+    (0xA, '3'),
+    (0xB, '3'),
+    (0xC, '3'),
+    (0xD, '3'),
+    (0xE, '3'),
+    (0xF, '3'),
+    (0x10, '3'),
+    (0x11, '3'),
+    (0x12, '3'),
+    (0x13, '3'),
+    (0x14, '3'),
+    (0x15, '3'),
+    (0x16, '3'),
+    (0x17, '3'),
+    (0x18, '3'),
+    (0x19, '3'),
+    (0x1A, '3'),
+    (0x1B, '3'),
+    (0x1C, '3'),
+    (0x1D, '3'),
+    (0x1E, '3'),
+    (0x1F, '3'),
+    (0x20, '3'),
+    (0x21, '3'),
+    (0x22, '3'),
+    (0x23, '3'),
+    (0x24, '3'),
+    (0x25, '3'),
+    (0x26, '3'),
+    (0x27, '3'),
+    (0x28, '3'),
+    (0x29, '3'),
+    (0x2A, '3'),
+    (0x2B, '3'),
+    (0x2C, '3'),
+    (0x2D, 'V'),
+    (0x2E, 'V'),
+    (0x2F, '3'),
+    (0x30, 'V'),
+    (0x31, 'V'),
+    (0x32, 'V'),
+    (0x33, 'V'),
+    (0x34, 'V'),
+    (0x35, 'V'),
+    (0x36, 'V'),
+    (0x37, 'V'),
+    (0x38, 'V'),
+    (0x39, 'V'),
+    (0x3A, '3'),
+    (0x3B, '3'),
+    (0x3C, '3'),
+    (0x3D, '3'),
+    (0x3E, '3'),
+    (0x3F, '3'),
+    (0x40, '3'),
+    (0x41, 'M', u'a'),
+    (0x42, 'M', u'b'),
+    (0x43, 'M', u'c'),
+    (0x44, 'M', u'd'),
+    (0x45, 'M', u'e'),
+    (0x46, 'M', u'f'),
+    (0x47, 'M', u'g'),
+    (0x48, 'M', u'h'),
+    (0x49, 'M', u'i'),
+    (0x4A, 'M', u'j'),
+    (0x4B, 'M', u'k'),
+    (0x4C, 'M', u'l'),
+    (0x4D, 'M', u'm'),
+    (0x4E, 'M', u'n'),
+    (0x4F, 'M', u'o'),
+    (0x50, 'M', u'p'),
+    (0x51, 'M', u'q'),
+    (0x52, 'M', u'r'),
+    (0x53, 'M', u's'),
+    (0x54, 'M', u't'),
+    (0x55, 'M', u'u'),
+    (0x56, 'M', u'v'),
+    (0x57, 'M', u'w'),
+    (0x58, 'M', u'x'),
+    (0x59, 'M', u'y'),
+    (0x5A, 'M', u'z'),
+    (0x5B, '3'),
+    (0x5C, '3'),
+    (0x5D, '3'),
+    (0x5E, '3'),
+    (0x5F, '3'),
+    (0x60, '3'),
+    (0x61, 'V'),
+    (0x62, 'V'),
+    (0x63, 'V'),
+    ]
+
+def _seg_1():
+    return [
+    (0x64, 'V'),
+    (0x65, 'V'),
+    (0x66, 'V'),
+    (0x67, 'V'),
+    (0x68, 'V'),
+    (0x69, 'V'),
+    (0x6A, 'V'),
+    (0x6B, 'V'),
+    (0x6C, 'V'),
+    (0x6D, 'V'),
+    (0x6E, 'V'),
+    (0x6F, 'V'),
+    (0x70, 'V'),
+    (0x71, 'V'),
+    (0x72, 'V'),
+    (0x73, 'V'),
+    (0x74, 'V'),
+    (0x75, 'V'),
+    (0x76, 'V'),
+    (0x77, 'V'),
+    (0x78, 'V'),
+    (0x79, 'V'),
+    (0x7A, 'V'),
+    (0x7B, '3'),
+    (0x7C, '3'),
+    (0x7D, '3'),
+    (0x7E, '3'),
+    (0x7F, '3'),
+    (0x80, 'X'),
+    (0x81, 'X'),
+    (0x82, 'X'),
+    (0x83, 'X'),
+    (0x84, 'X'),
+    (0x85, 'X'),
+    (0x86, 'X'),
+    (0x87, 'X'),
+    (0x88, 'X'),
+    (0x89, 'X'),
+    (0x8A, 'X'),
+    (0x8B, 'X'),
+    (0x8C, 'X'),
+    (0x8D, 'X'),
+    (0x8E, 'X'),
+    (0x8F, 'X'),
+    (0x90, 'X'),
+    (0x91, 'X'),
+    (0x92, 'X'),
+    (0x93, 'X'),
+    (0x94, 'X'),
+    (0x95, 'X'),
+    (0x96, 'X'),
+    (0x97, 'X'),
+    (0x98, 'X'),
+    (0x99, 'X'),
+    (0x9A, 'X'),
+    (0x9B, 'X'),
+    (0x9C, 'X'),
+    (0x9D, 'X'),
+    (0x9E, 'X'),
+    (0x9F, 'X'),
+    (0xA0, '3', u' '),
+    (0xA1, 'V'),
+    (0xA2, 'V'),
+    (0xA3, 'V'),
+    (0xA4, 'V'),
+    (0xA5, 'V'),
+    (0xA6, 'V'),
+    (0xA7, 'V'),
+    (0xA8, '3', u' ̈'),
+    (0xA9, 'V'),
+    (0xAA, 'M', u'a'),
+    (0xAB, 'V'),
+    (0xAC, 'V'),
+    (0xAD, 'I'),
+    (0xAE, 'V'),
+    (0xAF, '3', u' ̄'),
+    (0xB0, 'V'),
+    (0xB1, 'V'),
+    (0xB2, 'M', u'2'),
+    (0xB3, 'M', u'3'),
+    (0xB4, '3', u' ́'),
+    (0xB5, 'M', u'μ'),
+    (0xB6, 'V'),
+    (0xB7, 'V'),
+    (0xB8, '3', u' ̧'),
+    (0xB9, 'M', u'1'),
+    (0xBA, 'M', u'o'),
+    (0xBB, 'V'),
+    (0xBC, 'M', u'1⁄4'),
+    (0xBD, 'M', u'1⁄2'),
+    (0xBE, 'M', u'3⁄4'),
+    (0xBF, 'V'),
+    (0xC0, 'M', u'à'),
+    (0xC1, 'M', u'á'),
+    (0xC2, 'M', u'â'),
+    (0xC3, 'M', u'ã'),
+    (0xC4, 'M', u'ä'),
+    (0xC5, 'M', u'å'),
+    (0xC6, 'M', u'æ'),
+    (0xC7, 'M', u'ç'),
+    ]
+
+def _seg_2():
+    return [
+    (0xC8, 'M', u'è'),
+    (0xC9, 'M', u'é'),
+    (0xCA, 'M', u'ê'),
+    (0xCB, 'M', u'ë'),
+    (0xCC, 'M', u'ì'),
+    (0xCD, 'M', u'í'),
+    (0xCE, 'M', u'î'),
+    (0xCF, 'M', u'ï'),
+    (0xD0, 'M', u'ð'),
+    (0xD1, 'M', u'ñ'),
+    (0xD2, 'M', u'ò'),
+    (0xD3, 'M', u'ó'),
+    (0xD4, 'M', u'ô'),
+    (0xD5, 'M', u'õ'),
+    (0xD6, 'M', u'ö'),
+    (0xD7, 'V'),
+    (0xD8, 'M', u'ø'),
+    (0xD9, 'M', u'ù'),
+    (0xDA, 'M', u'ú'),
+    (0xDB, 'M', u'û'),
+    (0xDC, 'M', u'ü'),
+    (0xDD, 'M', u'ý'),
+    (0xDE, 'M', u'þ'),
+    (0xDF, 'D', u'ss'),
+    (0xE0, 'V'),
+    (0xE1, 'V'),
+    (0xE2, 'V'),
+    (0xE3, 'V'),
+    (0xE4, 'V'),
+    (0xE5, 'V'),
+    (0xE6, 'V'),
+    (0xE7, 'V'),
+    (0xE8, 'V'),
+    (0xE9, 'V'),
+    (0xEA, 'V'),
+    (0xEB, 'V'),
+    (0xEC, 'V'),
+    (0xED, 'V'),
+    (0xEE, 'V'),
+    (0xEF, 'V'),
+    (0xF0, 'V'),
+    (0xF1, 'V'),
+    (0xF2, 'V'),
+    (0xF3, 'V'),
+    (0xF4, 'V'),
+    (0xF5, 'V'),
+    (0xF6, 'V'),
+    (0xF7, 'V'),
+    (0xF8, 'V'),
+    (0xF9, 'V'),
+    (0xFA, 'V'),
+    (0xFB, 'V'),
+    (0xFC, 'V'),
+    (0xFD, 'V'),
+    (0xFE, 'V'),
+    (0xFF, 'V'),
+    (0x100, 'M', u'ā'),
+    (0x101, 'V'),
+    (0x102, 'M', u'ă'),
+    (0x103, 'V'),
+    (0x104, 'M', u'ą'),
+    (0x105, 'V'),
+    (0x106, 'M', u'ć'),
+    (0x107, 'V'),
+    (0x108, 'M', u'ĉ'),
+    (0x109, 'V'),
+    (0x10A, 'M', u'ċ'),
+    (0x10B, 'V'),
+    (0x10C, 'M', u'č'),
+    (0x10D, 'V'),
+    (0x10E, 'M', u'ď'),
+    (0x10F, 'V'),
+    (0x110, 'M', u'đ'),
+    (0x111, 'V'),
+    (0x112, 'M', u'ē'),
+    (0x113, 'V'),
+    (0x114, 'M', u'ĕ'),
+    (0x115, 'V'),
+    (0x116, 'M', u'ė'),
+    (0x117, 'V'),
+    (0x118, 'M', u'ę'),
+    (0x119, 'V'),
+    (0x11A, 'M', u'ě'),
+    (0x11B, 'V'),
+    (0x11C, 'M', u'ĝ'),
+    (0x11D, 'V'),
+    (0x11E, 'M', u'ğ'),
+    (0x11F, 'V'),
+    (0x120, 'M', u'ġ'),
+    (0x121, 'V'),
+    (0x122, 'M', u'ģ'),
+    (0x123, 'V'),
+    (0x124, 'M', u'ĥ'),
+    (0x125, 'V'),
+    (0x126, 'M', u'ħ'),
+    (0x127, 'V'),
+    (0x128, 'M', u'ĩ'),
+    (0x129, 'V'),
+    (0x12A, 'M', u'ī'),
+    (0x12B, 'V'),
+    ]
+
+def _seg_3():
+    return [
+    (0x12C, 'M', u'ĭ'),
+    (0x12D, 'V'),
+    (0x12E, 'M', u'į'),
+    (0x12F, 'V'),
+    (0x130, 'M', u'i̇'),
+    (0x131, 'V'),
+    (0x132, 'M', u'ij'),
+    (0x134, 'M', u'ĵ'),
+    (0x135, 'V'),
+    (0x136, 'M', u'ķ'),
+    (0x137, 'V'),
+    (0x139, 'M', u'ĺ'),
+    (0x13A, 'V'),
+    (0x13B, 'M', u'ļ'),
+    (0x13C, 'V'),
+    (0x13D, 'M', u'ľ'),
+    (0x13E, 'V'),
+    (0x13F, 'M', u'l·'),
+    (0x141, 'M', u'ł'),
+    (0x142, 'V'),
+    (0x143, 'M', u'ń'),
+    (0x144, 'V'),
+    (0x145, 'M', u'ņ'),
+    (0x146, 'V'),
+    (0x147, 'M', u'ň'),
+    (0x148, 'V'),
+    (0x149, 'M', u'ʼn'),
+    (0x14A, 'M', u'ŋ'),
+    (0x14B, 'V'),
+    (0x14C, 'M', u'ō'),
+    (0x14D, 'V'),
+    (0x14E, 'M', u'ŏ'),
+    (0x14F, 'V'),
+    (0x150, 'M', u'ő'),
+    (0x151, 'V'),
+    (0x152, 'M', u'œ'),
+    (0x153, 'V'),
+    (0x154, 'M', u'ŕ'),
+    (0x155, 'V'),
+    (0x156, 'M', u'ŗ'),
+    (0x157, 'V'),
+    (0x158, 'M', u'ř'),
+    (0x159, 'V'),
+    (0x15A, 'M', u'ś'),
+    (0x15B, 'V'),
+    (0x15C, 'M', u'ŝ'),
+    (0x15D, 'V'),
+    (0x15E, 'M', u'ş'),
+    (0x15F, 'V'),
+    (0x160, 'M', u'š'),
+    (0x161, 'V'),
+    (0x162, 'M', u'ţ'),
+    (0x163, 'V'),
+    (0x164, 'M', u'ť'),
+    (0x165, 'V'),
+    (0x166, 'M', u'ŧ'),
+    (0x167, 'V'),
+    (0x168, 'M', u'ũ'),
+    (0x169, 'V'),
+    (0x16A, 'M', u'ū'),
+    (0x16B, 'V'),
+    (0x16C, 'M', u'ŭ'),
+    (0x16D, 'V'),
+    (0x16E, 'M', u'ů'),
+    (0x16F, 'V'),
+    (0x170, 'M', u'ű'),
+    (0x171, 'V'),
+    (0x172, 'M', u'ų'),
+    (0x173, 'V'),
+    (0x174, 'M', u'ŵ'),
+    (0x175, 'V'),
+    (0x176, 'M', u'ŷ'),
+    (0x177, 'V'),
+    (0x178, 'M', u'ÿ'),
+    (0x179, 'M', u'ź'),
+    (0x17A, 'V'),
+    (0x17B, 'M', u'ż'),
+    (0x17C, 'V'),
+    (0x17D, 'M', u'ž'),
+    (0x17E, 'V'),
+    (0x17F, 'M', u's'),
+    (0x180, 'V'),
+    (0x181, 'M', u'ɓ'),
+    (0x182, 'M', u'ƃ'),
+    (0x183, 'V'),
+    (0x184, 'M', u'ƅ'),
+    (0x185, 'V'),
+    (0x186, 'M', u'ɔ'),
+    (0x187, 'M', u'ƈ'),
+    (0x188, 'V'),
+    (0x189, 'M', u'ɖ'),
+    (0x18A, 'M', u'ɗ'),
+    (0x18B, 'M', u'ƌ'),
+    (0x18C, 'V'),
+    (0x18E, 'M', u'ǝ'),
+    (0x18F, 'M', u'ə'),
+    (0x190, 'M', u'ɛ'),
+    (0x191, 'M', u'ƒ'),
+    (0x192, 'V'),
+    (0x193, 'M', u'ɠ'),
+    ]
+
+def _seg_4():
+    return [
+    (0x194, 'M', u'ɣ'),
+    (0x195, 'V'),
+    (0x196, 'M', u'ɩ'),
+    (0x197, 'M', u'ɨ'),
+    (0x198, 'M', u'ƙ'),
+    (0x199, 'V'),
+    (0x19C, 'M', u'ɯ'),
+    (0x19D, 'M', u'ɲ'),
+    (0x19E, 'V'),
+    (0x19F, 'M', u'ɵ'),
+    (0x1A0, 'M', u'ơ'),
+    (0x1A1, 'V'),
+    (0x1A2, 'M', u'ƣ'),
+    (0x1A3, 'V'),
+    (0x1A4, 'M', u'ƥ'),
+    (0x1A5, 'V'),
+    (0x1A6, 'M', u'ʀ'),
+    (0x1A7, 'M', u'ƨ'),
+    (0x1A8, 'V'),
+    (0x1A9, 'M', u'ʃ'),
+    (0x1AA, 'V'),
+    (0x1AC, 'M', u'ƭ'),
+    (0x1AD, 'V'),
+    (0x1AE, 'M', u'ʈ'),
+    (0x1AF, 'M', u'ư'),
+    (0x1B0, 'V'),
+    (0x1B1, 'M', u'ʊ'),
+    (0x1B2, 'M', u'ʋ'),
+    (0x1B3, 'M', u'ƴ'),
+    (0x1B4, 'V'),
+    (0x1B5, 'M', u'ƶ'),
+    (0x1B6, 'V'),
+    (0x1B7, 'M', u'ʒ'),
+    (0x1B8, 'M', u'ƹ'),
+    (0x1B9, 'V'),
+    (0x1BC, 'M', u'ƽ'),
+    (0x1BD, 'V'),
+    (0x1C4, 'M', u'dž'),
+    (0x1C7, 'M', u'lj'),
+    (0x1CA, 'M', u'nj'),
+    (0x1CD, 'M', u'ǎ'),
+    (0x1CE, 'V'),
+    (0x1CF, 'M', u'ǐ'),
+    (0x1D0, 'V'),
+    (0x1D1, 'M', u'ǒ'),
+    (0x1D2, 'V'),
+    (0x1D3, 'M', u'ǔ'),
+    (0x1D4, 'V'),
+    (0x1D5, 'M', u'ǖ'),
+    (0x1D6, 'V'),
+    (0x1D7, 'M', u'ǘ'),
+    (0x1D8, 'V'),
+    (0x1D9, 'M', u'ǚ'),
+    (0x1DA, 'V'),
+    (0x1DB, 'M', u'ǜ'),
+    (0x1DC, 'V'),
+    (0x1DE, 'M', u'ǟ'),
+    (0x1DF, 'V'),
+    (0x1E0, 'M', u'ǡ'),
+    (0x1E1, 'V'),
+    (0x1E2, 'M', u'ǣ'),
+    (0x1E3, 'V'),
+    (0x1E4, 'M', u'ǥ'),
+    (0x1E5, 'V'),
+    (0x1E6, 'M', u'ǧ'),
+    (0x1E7, 'V'),
+    (0x1E8, 'M', u'ǩ'),
+    (0x1E9, 'V'),
+    (0x1EA, 'M', u'ǫ'),
+    (0x1EB, 'V'),
+    (0x1EC, 'M', u'ǭ'),
+    (0x1ED, 'V'),
+    (0x1EE, 'M', u'ǯ'),
+    (0x1EF, 'V'),
+    (0x1F1, 'M', u'dz'),
+    (0x1F4, 'M', u'ǵ'),
+    (0x1F5, 'V'),
+    (0x1F6, 'M', u'ƕ'),
+    (0x1F7, 'M', u'ƿ'),
+    (0x1F8, 'M', u'ǹ'),
+    (0x1F9, 'V'),
+    (0x1FA, 'M', u'ǻ'),
+    (0x1FB, 'V'),
+    (0x1FC, 'M', u'ǽ'),
+    (0x1FD, 'V'),
+    (0x1FE, 'M', u'ǿ'),
+    (0x1FF, 'V'),
+    (0x200, 'M', u'ȁ'),
+    (0x201, 'V'),
+    (0x202, 'M', u'ȃ'),
+    (0x203, 'V'),
+    (0x204, 'M', u'ȅ'),
+    (0x205, 'V'),
+    (0x206, 'M', u'ȇ'),
+    (0x207, 'V'),
+    (0x208, 'M', u'ȉ'),
+    (0x209, 'V'),
+    (0x20A, 'M', u'ȋ'),
+    (0x20B, 'V'),
+    (0x20C, 'M', u'ȍ'),
+    ]
+
+def _seg_5():
+    return [
+    (0x20D, 'V'),
+    (0x20E, 'M', u'ȏ'),
+    (0x20F, 'V'),
+    (0x210, 'M', u'ȑ'),
+    (0x211, 'V'),
+    (0x212, 'M', u'ȓ'),
+    (0x213, 'V'),
+    (0x214, 'M', u'ȕ'),
+    (0x215, 'V'),
+    (0x216, 'M', u'ȗ'),
+    (0x217, 'V'),
+    (0x218, 'M', u'ș'),
+    (0x219, 'V'),
+    (0x21A, 'M', u'ț'),
+    (0x21B, 'V'),
+    (0x21C, 'M', u'ȝ'),
+    (0x21D, 'V'),
+    (0x21E, 'M', u'ȟ'),
+    (0x21F, 'V'),
+    (0x220, 'M', u'ƞ'),
+    (0x221, 'V'),
+    (0x222, 'M', u'ȣ'),
+    (0x223, 'V'),
+    (0x224, 'M', u'ȥ'),
+    (0x225, 'V'),
+    (0x226, 'M', u'ȧ'),
+    (0x227, 'V'),
+    (0x228, 'M', u'ȩ'),
+    (0x229, 'V'),
+    (0x22A, 'M', u'ȫ'),
+    (0x22B, 'V'),
+    (0x22C, 'M', u'ȭ'),
+    (0x22D, 'V'),
+    (0x22E, 'M', u'ȯ'),
+    (0x22F, 'V'),
+    (0x230, 'M', u'ȱ'),
+    (0x231, 'V'),
+    (0x232, 'M', u'ȳ'),
+    (0x233, 'V'),
+    (0x23A, 'M', u'ⱥ'),
+    (0x23B, 'M', u'ȼ'),
+    (0x23C, 'V'),
+    (0x23D, 'M', u'ƚ'),
+    (0x23E, 'M', u'ⱦ'),
+    (0x23F, 'V'),
+    (0x241, 'M', u'ɂ'),
+    (0x242, 'V'),
+    (0x243, 'M', u'ƀ'),
+    (0x244, 'M', u'ʉ'),
+    (0x245, 'M', u'ʌ'),
+    (0x246, 'M', u'ɇ'),
+    (0x247, 'V'),
+    (0x248, 'M', u'ɉ'),
+    (0x249, 'V'),
+    (0x24A, 'M', u'ɋ'),
+    (0x24B, 'V'),
+    (0x24C, 'M', u'ɍ'),
+    (0x24D, 'V'),
+    (0x24E, 'M', u'ɏ'),
+    (0x24F, 'V'),
+    (0x2B0, 'M', u'h'),
+    (0x2B1, 'M', u'ɦ'),
+    (0x2B2, 'M', u'j'),
+    (0x2B3, 'M', u'r'),
+    (0x2B4, 'M', u'ɹ'),
+    (0x2B5, 'M', u'ɻ'),
+    (0x2B6, 'M', u'ʁ'),
+    (0x2B7, 'M', u'w'),
+    (0x2B8, 'M', u'y'),
+    (0x2B9, 'V'),
+    (0x2D8, '3', u' ̆'),
+    (0x2D9, '3', u' ̇'),
+    (0x2DA, '3', u' ̊'),
+    (0x2DB, '3', u' ̨'),
+    (0x2DC, '3', u' ̃'),
+    (0x2DD, '3', u' ̋'),
+    (0x2DE, 'V'),
+    (0x2E0, 'M', u'ɣ'),
+    (0x2E1, 'M', u'l'),
+    (0x2E2, 'M', u's'),
+    (0x2E3, 'M', u'x'),
+    (0x2E4, 'M', u'ʕ'),
+    (0x2E5, 'V'),
+    (0x340, 'M', u'̀'),
+    (0x341, 'M', u'́'),
+    (0x342, 'V'),
+    (0x343, 'M', u'̓'),
+    (0x344, 'M', u'̈́'),
+    (0x345, 'M', u'ι'),
+    (0x346, 'V'),
+    (0x34F, 'I'),
+    (0x350, 'V'),
+    (0x370, 'M', u'ͱ'),
+    (0x371, 'V'),
+    (0x372, 'M', u'ͳ'),
+    (0x373, 'V'),
+    (0x374, 'M', u'ʹ'),
+    (0x375, 'V'),
+    (0x376, 'M', u'ͷ'),
+    (0x377, 'V'),
+    ]
+
+def _seg_6():
+    return [
+    (0x378, 'X'),
+    (0x37A, '3', u' ι'),
+    (0x37B, 'V'),
+    (0x37E, '3', u';'),
+    (0x37F, 'M', u'ϳ'),
+    (0x380, 'X'),
+    (0x384, '3', u' ́'),
+    (0x385, '3', u' ̈́'),
+    (0x386, 'M', u'ά'),
+    (0x387, 'M', u'·'),
+    (0x388, 'M', u'έ'),
+    (0x389, 'M', u'ή'),
+    (0x38A, 'M', u'ί'),
+    (0x38B, 'X'),
+    (0x38C, 'M', u'ό'),
+    (0x38D, 'X'),
+    (0x38E, 'M', u'ύ'),
+    (0x38F, 'M', u'ώ'),
+    (0x390, 'V'),
+    (0x391, 'M', u'α'),
+    (0x392, 'M', u'β'),
+    (0x393, 'M', u'γ'),
+    (0x394, 'M', u'δ'),
+    (0x395, 'M', u'ε'),
+    (0x396, 'M', u'ζ'),
+    (0x397, 'M', u'η'),
+    (0x398, 'M', u'θ'),
+    (0x399, 'M', u'ι'),
+    (0x39A, 'M', u'κ'),
+    (0x39B, 'M', u'λ'),
+    (0x39C, 'M', u'μ'),
+    (0x39D, 'M', u'ν'),
+    (0x39E, 'M', u'ξ'),
+    (0x39F, 'M', u'ο'),
+    (0x3A0, 'M', u'π'),
+    (0x3A1, 'M', u'ρ'),
+    (0x3A2, 'X'),
+    (0x3A3, 'M', u'σ'),
+    (0x3A4, 'M', u'τ'),
+    (0x3A5, 'M', u'υ'),
+    (0x3A6, 'M', u'φ'),
+    (0x3A7, 'M', u'χ'),
+    (0x3A8, 'M', u'ψ'),
+    (0x3A9, 'M', u'ω'),
+    (0x3AA, 'M', u'ϊ'),
+    (0x3AB, 'M', u'ϋ'),
+    (0x3AC, 'V'),
+    (0x3C2, 'D', u'σ'),
+    (0x3C3, 'V'),
+    (0x3CF, 'M', u'ϗ'),
+    (0x3D0, 'M', u'β'),
+    (0x3D1, 'M', u'θ'),
+    (0x3D2, 'M', u'υ'),
+    (0x3D3, 'M', u'ύ'),
+    (0x3D4, 'M', u'ϋ'),
+    (0x3D5, 'M', u'φ'),
+    (0x3D6, 'M', u'π'),
+    (0x3D7, 'V'),
+    (0x3D8, 'M', u'ϙ'),
+    (0x3D9, 'V'),
+    (0x3DA, 'M', u'ϛ'),
+    (0x3DB, 'V'),
+    (0x3DC, 'M', u'ϝ'),
+    (0x3DD, 'V'),
+    (0x3DE, 'M', u'ϟ'),
+    (0x3DF, 'V'),
+    (0x3E0, 'M', u'ϡ'),
+    (0x3E1, 'V'),
+    (0x3E2, 'M', u'ϣ'),
+    (0x3E3, 'V'),
+    (0x3E4, 'M', u'ϥ'),
+    (0x3E5, 'V'),
+    (0x3E6, 'M', u'ϧ'),
+    (0x3E7, 'V'),
+    (0x3E8, 'M', u'ϩ'),
+    (0x3E9, 'V'),
+    (0x3EA, 'M', u'ϫ'),
+    (0x3EB, 'V'),
+    (0x3EC, 'M', u'ϭ'),
+    (0x3ED, 'V'),
+    (0x3EE, 'M', u'ϯ'),
+    (0x3EF, 'V'),
+    (0x3F0, 'M', u'κ'),
+    (0x3F1, 'M', u'ρ'),
+    (0x3F2, 'M', u'σ'),
+    (0x3F3, 'V'),
+    (0x3F4, 'M', u'θ'),
+    (0x3F5, 'M', u'ε'),
+    (0x3F6, 'V'),
+    (0x3F7, 'M', u'ϸ'),
+    (0x3F8, 'V'),
+    (0x3F9, 'M', u'σ'),
+    (0x3FA, 'M', u'ϻ'),
+    (0x3FB, 'V'),
+    (0x3FD, 'M', u'ͻ'),
+    (0x3FE, 'M', u'ͼ'),
+    (0x3FF, 'M', u'ͽ'),
+    (0x400, 'M', u'ѐ'),
+    (0x401, 'M', u'ё'),
+    (0x402, 'M', u'ђ'),
+    ]
+
+def _seg_7():
+    return [
+    (0x403, 'M', u'ѓ'),
+    (0x404, 'M', u'є'),
+    (0x405, 'M', u'ѕ'),
+    (0x406, 'M', u'і'),
+    (0x407, 'M', u'ї'),
+    (0x408, 'M', u'ј'),
+    (0x409, 'M', u'љ'),
+    (0x40A, 'M', u'њ'),
+    (0x40B, 'M', u'ћ'),
+    (0x40C, 'M', u'ќ'),
+    (0x40D, 'M', u'ѝ'),
+    (0x40E, 'M', u'ў'),
+    (0x40F, 'M', u'џ'),
+    (0x410, 'M', u'а'),
+    (0x411, 'M', u'б'),
+    (0x412, 'M', u'в'),
+    (0x413, 'M', u'г'),
+    (0x414, 'M', u'д'),
+    (0x415, 'M', u'е'),
+    (0x416, 'M', u'ж'),
+    (0x417, 'M', u'з'),
+    (0x418, 'M', u'и'),
+    (0x419, 'M', u'й'),
+    (0x41A, 'M', u'к'),
+    (0x41B, 'M', u'л'),
+    (0x41C, 'M', u'м'),
+    (0x41D, 'M', u'н'),
+    (0x41E, 'M', u'о'),
+    (0x41F, 'M', u'п'),
+    (0x420, 'M', u'р'),
+    (0x421, 'M', u'с'),
+    (0x422, 'M', u'т'),
+    (0x423, 'M', u'у'),
+    (0x424, 'M', u'ф'),
+    (0x425, 'M', u'х'),
+    (0x426, 'M', u'ц'),
+    (0x427, 'M', u'ч'),
+    (0x428, 'M', u'ш'),
+    (0x429, 'M', u'щ'),
+    (0x42A, 'M', u'ъ'),
+    (0x42B, 'M', u'ы'),
+    (0x42C, 'M', u'ь'),
+    (0x42D, 'M', u'э'),
+    (0x42E, 'M', u'ю'),
+    (0x42F, 'M', u'я'),
+    (0x430, 'V'),
+    (0x460, 'M', u'ѡ'),
+    (0x461, 'V'),
+    (0x462, 'M', u'ѣ'),
+    (0x463, 'V'),
+    (0x464, 'M', u'ѥ'),
+    (0x465, 'V'),
+    (0x466, 'M', u'ѧ'),
+    (0x467, 'V'),
+    (0x468, 'M', u'ѩ'),
+    (0x469, 'V'),
+    (0x46A, 'M', u'ѫ'),
+    (0x46B, 'V'),
+    (0x46C, 'M', u'ѭ'),
+    (0x46D, 'V'),
+    (0x46E, 'M', u'ѯ'),
+    (0x46F, 'V'),
+    (0x470, 'M', u'ѱ'),
+    (0x471, 'V'),
+    (0x472, 'M', u'ѳ'),
+    (0x473, 'V'),
+    (0x474, 'M', u'ѵ'),
+    (0x475, 'V'),
+    (0x476, 'M', u'ѷ'),
+    (0x477, 'V'),
+    (0x478, 'M', u'ѹ'),
+    (0x479, 'V'),
+    (0x47A, 'M', u'ѻ'),
+    (0x47B, 'V'),
+    (0x47C, 'M', u'ѽ'),
+    (0x47D, 'V'),
+    (0x47E, 'M', u'ѿ'),
+    (0x47F, 'V'),
+    (0x480, 'M', u'ҁ'),
+    (0x481, 'V'),
+    (0x48A, 'M', u'ҋ'),
+    (0x48B, 'V'),
+    (0x48C, 'M', u'ҍ'),
+    (0x48D, 'V'),
+    (0x48E, 'M', u'ҏ'),
+    (0x48F, 'V'),
+    (0x490, 'M', u'ґ'),
+    (0x491, 'V'),
+    (0x492, 'M', u'ғ'),
+    (0x493, 'V'),
+    (0x494, 'M', u'ҕ'),
+    (0x495, 'V'),
+    (0x496, 'M', u'җ'),
+    (0x497, 'V'),
+    (0x498, 'M', u'ҙ'),
+    (0x499, 'V'),
+    (0x49A, 'M', u'қ'),
+    (0x49B, 'V'),
+    (0x49C, 'M', u'ҝ'),
+    (0x49D, 'V'),
+    ]
+
+def _seg_8():
+    return [
+    (0x49E, 'M', u'ҟ'),
+    (0x49F, 'V'),
+    (0x4A0, 'M', u'ҡ'),
+    (0x4A1, 'V'),
+    (0x4A2, 'M', u'ң'),
+    (0x4A3, 'V'),
+    (0x4A4, 'M', u'ҥ'),
+    (0x4A5, 'V'),
+    (0x4A6, 'M', u'ҧ'),
+    (0x4A7, 'V'),
+    (0x4A8, 'M', u'ҩ'),
+    (0x4A9, 'V'),
+    (0x4AA, 'M', u'ҫ'),
+    (0x4AB, 'V'),
+    (0x4AC, 'M', u'ҭ'),
+    (0x4AD, 'V'),
+    (0x4AE, 'M', u'ү'),
+    (0x4AF, 'V'),
+    (0x4B0, 'M', u'ұ'),
+    (0x4B1, 'V'),
+    (0x4B2, 'M', u'ҳ'),
+    (0x4B3, 'V'),
+    (0x4B4, 'M', u'ҵ'),
+    (0x4B5, 'V'),
+    (0x4B6, 'M', u'ҷ'),
+    (0x4B7, 'V'),
+    (0x4B8, 'M', u'ҹ'),
+    (0x4B9, 'V'),
+    (0x4BA, 'M', u'һ'),
+    (0x4BB, 'V'),
+    (0x4BC, 'M', u'ҽ'),
+    (0x4BD, 'V'),
+    (0x4BE, 'M', u'ҿ'),
+    (0x4BF, 'V'),
+    (0x4C0, 'X'),
+    (0x4C1, 'M', u'ӂ'),
+    (0x4C2, 'V'),
+    (0x4C3, 'M', u'ӄ'),
+    (0x4C4, 'V'),
+    (0x4C5, 'M', u'ӆ'),
+    (0x4C6, 'V'),
+    (0x4C7, 'M', u'ӈ'),
+    (0x4C8, 'V'),
+    (0x4C9, 'M', u'ӊ'),
+    (0x4CA, 'V'),
+    (0x4CB, 'M', u'ӌ'),
+    (0x4CC, 'V'),
+    (0x4CD, 'M', u'ӎ'),
+    (0x4CE, 'V'),
+    (0x4D0, 'M', u'ӑ'),
+    (0x4D1, 'V'),
+    (0x4D2, 'M', u'ӓ'),
+    (0x4D3, 'V'),
+    (0x4D4, 'M', u'ӕ'),
+    (0x4D5, 'V'),
+    (0x4D6, 'M', u'ӗ'),
+    (0x4D7, 'V'),
+    (0x4D8, 'M', u'ә'),
+    (0x4D9, 'V'),
+    (0x4DA, 'M', u'ӛ'),
+    (0x4DB, 'V'),
+    (0x4DC, 'M', u'ӝ'),
+    (0x4DD, 'V'),
+    (0x4DE, 'M', u'ӟ'),
+    (0x4DF, 'V'),
+    (0x4E0, 'M', u'ӡ'),
+    (0x4E1, 'V'),
+    (0x4E2, 'M', u'ӣ'),
+    (0x4E3, 'V'),
+    (0x4E4, 'M', u'ӥ'),
+    (0x4E5, 'V'),
+    (0x4E6, 'M', u'ӧ'),
+    (0x4E7, 'V'),
+    (0x4E8, 'M', u'ө'),
+    (0x4E9, 'V'),
+    (0x4EA, 'M', u'ӫ'),
+    (0x4EB, 'V'),
+    (0x4EC, 'M', u'ӭ'),
+    (0x4ED, 'V'),
+    (0x4EE, 'M', u'ӯ'),
+    (0x4EF, 'V'),
+    (0x4F0, 'M', u'ӱ'),
+    (0x4F1, 'V'),
+    (0x4F2, 'M', u'ӳ'),
+    (0x4F3, 'V'),
+    (0x4F4, 'M', u'ӵ'),
+    (0x4F5, 'V'),
+    (0x4F6, 'M', u'ӷ'),
+    (0x4F7, 'V'),
+    (0x4F8, 'M', u'ӹ'),
+    (0x4F9, 'V'),
+    (0x4FA, 'M', u'ӻ'),
+    (0x4FB, 'V'),
+    (0x4FC, 'M', u'ӽ'),
+    (0x4FD, 'V'),
+    (0x4FE, 'M', u'ӿ'),
+    (0x4FF, 'V'),
+    (0x500, 'M', u'ԁ'),
+    (0x501, 'V'),
+    (0x502, 'M', u'ԃ'),
+    ]
+
+def _seg_9():
+    return [
+    (0x503, 'V'),
+    (0x504, 'M', u'ԅ'),
+    (0x505, 'V'),
+    (0x506, 'M', u'ԇ'),
+    (0x507, 'V'),
+    (0x508, 'M', u'ԉ'),
+    (0x509, 'V'),
+    (0x50A, 'M', u'ԋ'),
+    (0x50B, 'V'),
+    (0x50C, 'M', u'ԍ'),
+    (0x50D, 'V'),
+    (0x50E, 'M', u'ԏ'),
+    (0x50F, 'V'),
+    (0x510, 'M', u'ԑ'),
+    (0x511, 'V'),
+    (0x512, 'M', u'ԓ'),
+    (0x513, 'V'),
+    (0x514, 'M', u'ԕ'),
+    (0x515, 'V'),
+    (0x516, 'M', u'ԗ'),
+    (0x517, 'V'),
+    (0x518, 'M', u'ԙ'),
+    (0x519, 'V'),
+    (0x51A, 'M', u'ԛ'),
+    (0x51B, 'V'),
+    (0x51C, 'M', u'ԝ'),
+    (0x51D, 'V'),
+    (0x51E, 'M', u'ԟ'),
+    (0x51F, 'V'),
+    (0x520, 'M', u'ԡ'),
+    (0x521, 'V'),
+    (0x522, 'M', u'ԣ'),
+    (0x523, 'V'),
+    (0x524, 'M', u'ԥ'),
+    (0x525, 'V'),
+    (0x526, 'M', u'ԧ'),
+    (0x527, 'V'),
+    (0x528, 'M', u'ԩ'),
+    (0x529, 'V'),
+    (0x52A, 'M', u'ԫ'),
+    (0x52B, 'V'),
+    (0x52C, 'M', u'ԭ'),
+    (0x52D, 'V'),
+    (0x52E, 'M', u'ԯ'),
+    (0x52F, 'V'),
+    (0x530, 'X'),
+    (0x531, 'M', u'ա'),
+    (0x532, 'M', u'բ'),
+    (0x533, 'M', u'գ'),
+    (0x534, 'M', u'դ'),
+    (0x535, 'M', u'ե'),
+    (0x536, 'M', u'զ'),
+    (0x537, 'M', u'է'),
+    (0x538, 'M', u'ը'),
+    (0x539, 'M', u'թ'),
+    (0x53A, 'M', u'ժ'),
+    (0x53B, 'M', u'ի'),
+    (0x53C, 'M', u'լ'),
+    (0x53D, 'M', u'խ'),
+    (0x53E, 'M', u'ծ'),
+    (0x53F, 'M', u'կ'),
+    (0x540, 'M', u'հ'),
+    (0x541, 'M', u'ձ'),
+    (0x542, 'M', u'ղ'),
+    (0x543, 'M', u'ճ'),
+    (0x544, 'M', u'մ'),
+    (0x545, 'M', u'յ'),
+    (0x546, 'M', u'ն'),
+    (0x547, 'M', u'շ'),
+    (0x548, 'M', u'ո'),
+    (0x549, 'M', u'չ'),
+    (0x54A, 'M', u'պ'),
+    (0x54B, 'M', u'ջ'),
+    (0x54C, 'M', u'ռ'),
+    (0x54D, 'M', u'ս'),
+    (0x54E, 'M', u'վ'),
+    (0x54F, 'M', u'տ'),
+    (0x550, 'M', u'ր'),
+    (0x551, 'M', u'ց'),
+    (0x552, 'M', u'ւ'),
+    (0x553, 'M', u'փ'),
+    (0x554, 'M', u'ք'),
+    (0x555, 'M', u'օ'),
+    (0x556, 'M', u'ֆ'),
+    (0x557, 'X'),
+    (0x559, 'V'),
+    (0x587, 'M', u'եւ'),
+    (0x588, 'V'),
+    (0x58B, 'X'),
+    (0x58D, 'V'),
+    (0x590, 'X'),
+    (0x591, 'V'),
+    (0x5C8, 'X'),
+    (0x5D0, 'V'),
+    (0x5EB, 'X'),
+    (0x5EF, 'V'),
+    (0x5F5, 'X'),
+    (0x606, 'V'),
+    (0x61C, 'X'),
+    (0x61E, 'V'),
+    ]
+
+def _seg_10():
+    return [
+    (0x675, 'M', u'اٴ'),
+    (0x676, 'M', u'وٴ'),
+    (0x677, 'M', u'ۇٴ'),
+    (0x678, 'M', u'يٴ'),
+    (0x679, 'V'),
+    (0x6DD, 'X'),
+    (0x6DE, 'V'),
+    (0x70E, 'X'),
+    (0x710, 'V'),
+    (0x74B, 'X'),
+    (0x74D, 'V'),
+    (0x7B2, 'X'),
+    (0x7C0, 'V'),
+    (0x7FB, 'X'),
+    (0x7FD, 'V'),
+    (0x82E, 'X'),
+    (0x830, 'V'),
+    (0x83F, 'X'),
+    (0x840, 'V'),
+    (0x85C, 'X'),
+    (0x85E, 'V'),
+    (0x85F, 'X'),
+    (0x860, 'V'),
+    (0x86B, 'X'),
+    (0x8A0, 'V'),
+    (0x8B5, 'X'),
+    (0x8B6, 'V'),
+    (0x8C8, 'X'),
+    (0x8D3, 'V'),
+    (0x8E2, 'X'),
+    (0x8E3, 'V'),
+    (0x958, 'M', u'क़'),
+    (0x959, 'M', u'ख़'),
+    (0x95A, 'M', u'ग़'),
+    (0x95B, 'M', u'ज़'),
+    (0x95C, 'M', u'ड़'),
+    (0x95D, 'M', u'ढ़'),
+    (0x95E, 'M', u'फ़'),
+    (0x95F, 'M', u'य़'),
+    (0x960, 'V'),
+    (0x984, 'X'),
+    (0x985, 'V'),
+    (0x98D, 'X'),
+    (0x98F, 'V'),
+    (0x991, 'X'),
+    (0x993, 'V'),
+    (0x9A9, 'X'),
+    (0x9AA, 'V'),
+    (0x9B1, 'X'),
+    (0x9B2, 'V'),
+    (0x9B3, 'X'),
+    (0x9B6, 'V'),
+    (0x9BA, 'X'),
+    (0x9BC, 'V'),
+    (0x9C5, 'X'),
+    (0x9C7, 'V'),
+    (0x9C9, 'X'),
+    (0x9CB, 'V'),
+    (0x9CF, 'X'),
+    (0x9D7, 'V'),
+    (0x9D8, 'X'),
+    (0x9DC, 'M', u'ড়'),
+    (0x9DD, 'M', u'ঢ়'),
+    (0x9DE, 'X'),
+    (0x9DF, 'M', u'য়'),
+    (0x9E0, 'V'),
+    (0x9E4, 'X'),
+    (0x9E6, 'V'),
+    (0x9FF, 'X'),
+    (0xA01, 'V'),
+    (0xA04, 'X'),
+    (0xA05, 'V'),
+    (0xA0B, 'X'),
+    (0xA0F, 'V'),
+    (0xA11, 'X'),
+    (0xA13, 'V'),
+    (0xA29, 'X'),
+    (0xA2A, 'V'),
+    (0xA31, 'X'),
+    (0xA32, 'V'),
+    (0xA33, 'M', u'ਲ਼'),
+    (0xA34, 'X'),
+    (0xA35, 'V'),
+    (0xA36, 'M', u'ਸ਼'),
+    (0xA37, 'X'),
+    (0xA38, 'V'),
+    (0xA3A, 'X'),
+    (0xA3C, 'V'),
+    (0xA3D, 'X'),
+    (0xA3E, 'V'),
+    (0xA43, 'X'),
+    (0xA47, 'V'),
+    (0xA49, 'X'),
+    (0xA4B, 'V'),
+    (0xA4E, 'X'),
+    (0xA51, 'V'),
+    (0xA52, 'X'),
+    (0xA59, 'M', u'ਖ਼'),
+    (0xA5A, 'M', u'ਗ਼'),
+    (0xA5B, 'M', u'ਜ਼'),
+    ]
+
+def _seg_11():
+    return [
+    (0xA5C, 'V'),
+    (0xA5D, 'X'),
+    (0xA5E, 'M', u'ਫ਼'),
+    (0xA5F, 'X'),
+    (0xA66, 'V'),
+    (0xA77, 'X'),
+    (0xA81, 'V'),
+    (0xA84, 'X'),
+    (0xA85, 'V'),
+    (0xA8E, 'X'),
+    (0xA8F, 'V'),
+    (0xA92, 'X'),
+    (0xA93, 'V'),
+    (0xAA9, 'X'),
+    (0xAAA, 'V'),
+    (0xAB1, 'X'),
+    (0xAB2, 'V'),
+    (0xAB4, 'X'),
+    (0xAB5, 'V'),
+    (0xABA, 'X'),
+    (0xABC, 'V'),
+    (0xAC6, 'X'),
+    (0xAC7, 'V'),
+    (0xACA, 'X'),
+    (0xACB, 'V'),
+    (0xACE, 'X'),
+    (0xAD0, 'V'),
+    (0xAD1, 'X'),
+    (0xAE0, 'V'),
+    (0xAE4, 'X'),
+    (0xAE6, 'V'),
+    (0xAF2, 'X'),
+    (0xAF9, 'V'),
+    (0xB00, 'X'),
+    (0xB01, 'V'),
+    (0xB04, 'X'),
+    (0xB05, 'V'),
+    (0xB0D, 'X'),
+    (0xB0F, 'V'),
+    (0xB11, 'X'),
+    (0xB13, 'V'),
+    (0xB29, 'X'),
+    (0xB2A, 'V'),
+    (0xB31, 'X'),
+    (0xB32, 'V'),
+    (0xB34, 'X'),
+    (0xB35, 'V'),
+    (0xB3A, 'X'),
+    (0xB3C, 'V'),
+    (0xB45, 'X'),
+    (0xB47, 'V'),
+    (0xB49, 'X'),
+    (0xB4B, 'V'),
+    (0xB4E, 'X'),
+    (0xB55, 'V'),
+    (0xB58, 'X'),
+    (0xB5C, 'M', u'ଡ଼'),
+    (0xB5D, 'M', u'ଢ଼'),
+    (0xB5E, 'X'),
+    (0xB5F, 'V'),
+    (0xB64, 'X'),
+    (0xB66, 'V'),
+    (0xB78, 'X'),
+    (0xB82, 'V'),
+    (0xB84, 'X'),
+    (0xB85, 'V'),
+    (0xB8B, 'X'),
+    (0xB8E, 'V'),
+    (0xB91, 'X'),
+    (0xB92, 'V'),
+    (0xB96, 'X'),
+    (0xB99, 'V'),
+    (0xB9B, 'X'),
+    (0xB9C, 'V'),
+    (0xB9D, 'X'),
+    (0xB9E, 'V'),
+    (0xBA0, 'X'),
+    (0xBA3, 'V'),
+    (0xBA5, 'X'),
+    (0xBA8, 'V'),
+    (0xBAB, 'X'),
+    (0xBAE, 'V'),
+    (0xBBA, 'X'),
+    (0xBBE, 'V'),
+    (0xBC3, 'X'),
+    (0xBC6, 'V'),
+    (0xBC9, 'X'),
+    (0xBCA, 'V'),
+    (0xBCE, 'X'),
+    (0xBD0, 'V'),
+    (0xBD1, 'X'),
+    (0xBD7, 'V'),
+    (0xBD8, 'X'),
+    (0xBE6, 'V'),
+    (0xBFB, 'X'),
+    (0xC00, 'V'),
+    (0xC0D, 'X'),
+    (0xC0E, 'V'),
+    (0xC11, 'X'),
+    (0xC12, 'V'),
+    ]
+
+def _seg_12():
+    return [
+    (0xC29, 'X'),
+    (0xC2A, 'V'),
+    (0xC3A, 'X'),
+    (0xC3D, 'V'),
+    (0xC45, 'X'),
+    (0xC46, 'V'),
+    (0xC49, 'X'),
+    (0xC4A, 'V'),
+    (0xC4E, 'X'),
+    (0xC55, 'V'),
+    (0xC57, 'X'),
+    (0xC58, 'V'),
+    (0xC5B, 'X'),
+    (0xC60, 'V'),
+    (0xC64, 'X'),
+    (0xC66, 'V'),
+    (0xC70, 'X'),
+    (0xC77, 'V'),
+    (0xC8D, 'X'),
+    (0xC8E, 'V'),
+    (0xC91, 'X'),
+    (0xC92, 'V'),
+    (0xCA9, 'X'),
+    (0xCAA, 'V'),
+    (0xCB4, 'X'),
+    (0xCB5, 'V'),
+    (0xCBA, 'X'),
+    (0xCBC, 'V'),
+    (0xCC5, 'X'),
+    (0xCC6, 'V'),
+    (0xCC9, 'X'),
+    (0xCCA, 'V'),
+    (0xCCE, 'X'),
+    (0xCD5, 'V'),
+    (0xCD7, 'X'),
+    (0xCDE, 'V'),
+    (0xCDF, 'X'),
+    (0xCE0, 'V'),
+    (0xCE4, 'X'),
+    (0xCE6, 'V'),
+    (0xCF0, 'X'),
+    (0xCF1, 'V'),
+    (0xCF3, 'X'),
+    (0xD00, 'V'),
+    (0xD0D, 'X'),
+    (0xD0E, 'V'),
+    (0xD11, 'X'),
+    (0xD12, 'V'),
+    (0xD45, 'X'),
+    (0xD46, 'V'),
+    (0xD49, 'X'),
+    (0xD4A, 'V'),
+    (0xD50, 'X'),
+    (0xD54, 'V'),
+    (0xD64, 'X'),
+    (0xD66, 'V'),
+    (0xD80, 'X'),
+    (0xD81, 'V'),
+    (0xD84, 'X'),
+    (0xD85, 'V'),
+    (0xD97, 'X'),
+    (0xD9A, 'V'),
+    (0xDB2, 'X'),
+    (0xDB3, 'V'),
+    (0xDBC, 'X'),
+    (0xDBD, 'V'),
+    (0xDBE, 'X'),
+    (0xDC0, 'V'),
+    (0xDC7, 'X'),
+    (0xDCA, 'V'),
+    (0xDCB, 'X'),
+    (0xDCF, 'V'),
+    (0xDD5, 'X'),
+    (0xDD6, 'V'),
+    (0xDD7, 'X'),
+    (0xDD8, 'V'),
+    (0xDE0, 'X'),
+    (0xDE6, 'V'),
+    (0xDF0, 'X'),
+    (0xDF2, 'V'),
+    (0xDF5, 'X'),
+    (0xE01, 'V'),
+    (0xE33, 'M', u'ํา'),
+    (0xE34, 'V'),
+    (0xE3B, 'X'),
+    (0xE3F, 'V'),
+    (0xE5C, 'X'),
+    (0xE81, 'V'),
+    (0xE83, 'X'),
+    (0xE84, 'V'),
+    (0xE85, 'X'),
+    (0xE86, 'V'),
+    (0xE8B, 'X'),
+    (0xE8C, 'V'),
+    (0xEA4, 'X'),
+    (0xEA5, 'V'),
+    (0xEA6, 'X'),
+    (0xEA7, 'V'),
+    (0xEB3, 'M', u'ໍາ'),
+    (0xEB4, 'V'),
+    ]
+
+def _seg_13():
+    return [
+    (0xEBE, 'X'),
+    (0xEC0, 'V'),
+    (0xEC5, 'X'),
+    (0xEC6, 'V'),
+    (0xEC7, 'X'),
+    (0xEC8, 'V'),
+    (0xECE, 'X'),
+    (0xED0, 'V'),
+    (0xEDA, 'X'),
+    (0xEDC, 'M', u'ຫນ'),
+    (0xEDD, 'M', u'ຫມ'),
+    (0xEDE, 'V'),
+    (0xEE0, 'X'),
+    (0xF00, 'V'),
+    (0xF0C, 'M', u'་'),
+    (0xF0D, 'V'),
+    (0xF43, 'M', u'གྷ'),
+    (0xF44, 'V'),
+    (0xF48, 'X'),
+    (0xF49, 'V'),
+    (0xF4D, 'M', u'ཌྷ'),
+    (0xF4E, 'V'),
+    (0xF52, 'M', u'དྷ'),
+    (0xF53, 'V'),
+    (0xF57, 'M', u'བྷ'),
+    (0xF58, 'V'),
+    (0xF5C, 'M', u'ཛྷ'),
+    (0xF5D, 'V'),
+    (0xF69, 'M', u'ཀྵ'),
+    (0xF6A, 'V'),
+    (0xF6D, 'X'),
+    (0xF71, 'V'),
+    (0xF73, 'M', u'ཱི'),
+    (0xF74, 'V'),
+    (0xF75, 'M', u'ཱུ'),
+    (0xF76, 'M', u'ྲྀ'),
+    (0xF77, 'M', u'ྲཱྀ'),
+    (0xF78, 'M', u'ླྀ'),
+    (0xF79, 'M', u'ླཱྀ'),
+    (0xF7A, 'V'),
+    (0xF81, 'M', u'ཱྀ'),
+    (0xF82, 'V'),
+    (0xF93, 'M', u'ྒྷ'),
+    (0xF94, 'V'),
+    (0xF98, 'X'),
+    (0xF99, 'V'),
+    (0xF9D, 'M', u'ྜྷ'),
+    (0xF9E, 'V'),
+    (0xFA2, 'M', u'ྡྷ'),
+    (0xFA3, 'V'),
+    (0xFA7, 'M', u'ྦྷ'),
+    (0xFA8, 'V'),
+    (0xFAC, 'M', u'ྫྷ'),
+    (0xFAD, 'V'),
+    (0xFB9, 'M', u'ྐྵ'),
+    (0xFBA, 'V'),
+    (0xFBD, 'X'),
+    (0xFBE, 'V'),
+    (0xFCD, 'X'),
+    (0xFCE, 'V'),
+    (0xFDB, 'X'),
+    (0x1000, 'V'),
+    (0x10A0, 'X'),
+    (0x10C7, 'M', u'ⴧ'),
+    (0x10C8, 'X'),
+    (0x10CD, 'M', u'ⴭ'),
+    (0x10CE, 'X'),
+    (0x10D0, 'V'),
+    (0x10FC, 'M', u'ნ'),
+    (0x10FD, 'V'),
+    (0x115F, 'X'),
+    (0x1161, 'V'),
+    (0x1249, 'X'),
+    (0x124A, 'V'),
+    (0x124E, 'X'),
+    (0x1250, 'V'),
+    (0x1257, 'X'),
+    (0x1258, 'V'),
+    (0x1259, 'X'),
+    (0x125A, 'V'),
+    (0x125E, 'X'),
+    (0x1260, 'V'),
+    (0x1289, 'X'),
+    (0x128A, 'V'),
+    (0x128E, 'X'),
+    (0x1290, 'V'),
+    (0x12B1, 'X'),
+    (0x12B2, 'V'),
+    (0x12B6, 'X'),
+    (0x12B8, 'V'),
+    (0x12BF, 'X'),
+    (0x12C0, 'V'),
+    (0x12C1, 'X'),
+    (0x12C2, 'V'),
+    (0x12C6, 'X'),
+    (0x12C8, 'V'),
+    (0x12D7, 'X'),
+    (0x12D8, 'V'),
+    (0x1311, 'X'),
+    (0x1312, 'V'),
+    ]
+
+def _seg_14():
+    return [
+    (0x1316, 'X'),
+    (0x1318, 'V'),
+    (0x135B, 'X'),
+    (0x135D, 'V'),
+    (0x137D, 'X'),
+    (0x1380, 'V'),
+    (0x139A, 'X'),
+    (0x13A0, 'V'),
+    (0x13F6, 'X'),
+    (0x13F8, 'M', u'Ᏸ'),
+    (0x13F9, 'M', u'Ᏹ'),
+    (0x13FA, 'M', u'Ᏺ'),
+    (0x13FB, 'M', u'Ᏻ'),
+    (0x13FC, 'M', u'Ᏼ'),
+    (0x13FD, 'M', u'Ᏽ'),
+    (0x13FE, 'X'),
+    (0x1400, 'V'),
+    (0x1680, 'X'),
+    (0x1681, 'V'),
+    (0x169D, 'X'),
+    (0x16A0, 'V'),
+    (0x16F9, 'X'),
+    (0x1700, 'V'),
+    (0x170D, 'X'),
+    (0x170E, 'V'),
+    (0x1715, 'X'),
+    (0x1720, 'V'),
+    (0x1737, 'X'),
+    (0x1740, 'V'),
+    (0x1754, 'X'),
+    (0x1760, 'V'),
+    (0x176D, 'X'),
+    (0x176E, 'V'),
+    (0x1771, 'X'),
+    (0x1772, 'V'),
+    (0x1774, 'X'),
+    (0x1780, 'V'),
+    (0x17B4, 'X'),
+    (0x17B6, 'V'),
+    (0x17DE, 'X'),
+    (0x17E0, 'V'),
+    (0x17EA, 'X'),
+    (0x17F0, 'V'),
+    (0x17FA, 'X'),
+    (0x1800, 'V'),
+    (0x1806, 'X'),
+    (0x1807, 'V'),
+    (0x180B, 'I'),
+    (0x180E, 'X'),
+    (0x1810, 'V'),
+    (0x181A, 'X'),
+    (0x1820, 'V'),
+    (0x1879, 'X'),
+    (0x1880, 'V'),
+    (0x18AB, 'X'),
+    (0x18B0, 'V'),
+    (0x18F6, 'X'),
+    (0x1900, 'V'),
+    (0x191F, 'X'),
+    (0x1920, 'V'),
+    (0x192C, 'X'),
+    (0x1930, 'V'),
+    (0x193C, 'X'),
+    (0x1940, 'V'),
+    (0x1941, 'X'),
+    (0x1944, 'V'),
+    (0x196E, 'X'),
+    (0x1970, 'V'),
+    (0x1975, 'X'),
+    (0x1980, 'V'),
+    (0x19AC, 'X'),
+    (0x19B0, 'V'),
+    (0x19CA, 'X'),
+    (0x19D0, 'V'),
+    (0x19DB, 'X'),
+    (0x19DE, 'V'),
+    (0x1A1C, 'X'),
+    (0x1A1E, 'V'),
+    (0x1A5F, 'X'),
+    (0x1A60, 'V'),
+    (0x1A7D, 'X'),
+    (0x1A7F, 'V'),
+    (0x1A8A, 'X'),
+    (0x1A90, 'V'),
+    (0x1A9A, 'X'),
+    (0x1AA0, 'V'),
+    (0x1AAE, 'X'),
+    (0x1AB0, 'V'),
+    (0x1AC1, 'X'),
+    (0x1B00, 'V'),
+    (0x1B4C, 'X'),
+    (0x1B50, 'V'),
+    (0x1B7D, 'X'),
+    (0x1B80, 'V'),
+    (0x1BF4, 'X'),
+    (0x1BFC, 'V'),
+    (0x1C38, 'X'),
+    (0x1C3B, 'V'),
+    (0x1C4A, 'X'),
+    (0x1C4D, 'V'),
+    ]
+
+def _seg_15():
+    return [
+    (0x1C80, 'M', u'в'),
+    (0x1C81, 'M', u'д'),
+    (0x1C82, 'M', u'о'),
+    (0x1C83, 'M', u'с'),
+    (0x1C84, 'M', u'т'),
+    (0x1C86, 'M', u'ъ'),
+    (0x1C87, 'M', u'ѣ'),
+    (0x1C88, 'M', u'ꙋ'),
+    (0x1C89, 'X'),
+    (0x1C90, 'M', u'ა'),
+    (0x1C91, 'M', u'ბ'),
+    (0x1C92, 'M', u'გ'),
+    (0x1C93, 'M', u'დ'),
+    (0x1C94, 'M', u'ე'),
+    (0x1C95, 'M', u'ვ'),
+    (0x1C96, 'M', u'ზ'),
+    (0x1C97, 'M', u'თ'),
+    (0x1C98, 'M', u'ი'),
+    (0x1C99, 'M', u'კ'),
+    (0x1C9A, 'M', u'ლ'),
+    (0x1C9B, 'M', u'მ'),
+    (0x1C9C, 'M', u'ნ'),
+    (0x1C9D, 'M', u'ო'),
+    (0x1C9E, 'M', u'პ'),
+    (0x1C9F, 'M', u'ჟ'),
+    (0x1CA0, 'M', u'რ'),
+    (0x1CA1, 'M', u'ს'),
+    (0x1CA2, 'M', u'ტ'),
+    (0x1CA3, 'M', u'უ'),
+    (0x1CA4, 'M', u'ფ'),
+    (0x1CA5, 'M', u'ქ'),
+    (0x1CA6, 'M', u'ღ'),
+    (0x1CA7, 'M', u'ყ'),
+    (0x1CA8, 'M', u'შ'),
+    (0x1CA9, 'M', u'ჩ'),
+    (0x1CAA, 'M', u'ც'),
+    (0x1CAB, 'M', u'ძ'),
+    (0x1CAC, 'M', u'წ'),
+    (0x1CAD, 'M', u'ჭ'),
+    (0x1CAE, 'M', u'ხ'),
+    (0x1CAF, 'M', u'ჯ'),
+    (0x1CB0, 'M', u'ჰ'),
+    (0x1CB1, 'M', u'ჱ'),
+    (0x1CB2, 'M', u'ჲ'),
+    (0x1CB3, 'M', u'ჳ'),
+    (0x1CB4, 'M', u'ჴ'),
+    (0x1CB5, 'M', u'ჵ'),
+    (0x1CB6, 'M', u'ჶ'),
+    (0x1CB7, 'M', u'ჷ'),
+    (0x1CB8, 'M', u'ჸ'),
+    (0x1CB9, 'M', u'ჹ'),
+    (0x1CBA, 'M', u'ჺ'),
+    (0x1CBB, 'X'),
+    (0x1CBD, 'M', u'ჽ'),
+    (0x1CBE, 'M', u'ჾ'),
+    (0x1CBF, 'M', u'ჿ'),
+    (0x1CC0, 'V'),
+    (0x1CC8, 'X'),
+    (0x1CD0, 'V'),
+    (0x1CFB, 'X'),
+    (0x1D00, 'V'),
+    (0x1D2C, 'M', u'a'),
+    (0x1D2D, 'M', u'æ'),
+    (0x1D2E, 'M', u'b'),
+    (0x1D2F, 'V'),
+    (0x1D30, 'M', u'd'),
+    (0x1D31, 'M', u'e'),
+    (0x1D32, 'M', u'ǝ'),
+    (0x1D33, 'M', u'g'),
+    (0x1D34, 'M', u'h'),
+    (0x1D35, 'M', u'i'),
+    (0x1D36, 'M', u'j'),
+    (0x1D37, 'M', u'k'),
+    (0x1D38, 'M', u'l'),
+    (0x1D39, 'M', u'm'),
+    (0x1D3A, 'M', u'n'),
+    (0x1D3B, 'V'),
+    (0x1D3C, 'M', u'o'),
+    (0x1D3D, 'M', u'ȣ'),
+    (0x1D3E, 'M', u'p'),
+    (0x1D3F, 'M', u'r'),
+    (0x1D40, 'M', u't'),
+    (0x1D41, 'M', u'u'),
+    (0x1D42, 'M', u'w'),
+    (0x1D43, 'M', u'a'),
+    (0x1D44, 'M', u'ɐ'),
+    (0x1D45, 'M', u'ɑ'),
+    (0x1D46, 'M', u'ᴂ'),
+    (0x1D47, 'M', u'b'),
+    (0x1D48, 'M', u'd'),
+    (0x1D49, 'M', u'e'),
+    (0x1D4A, 'M', u'ə'),
+    (0x1D4B, 'M', u'ɛ'),
+    (0x1D4C, 'M', u'ɜ'),
+    (0x1D4D, 'M', u'g'),
+    (0x1D4E, 'V'),
+    (0x1D4F, 'M', u'k'),
+    (0x1D50, 'M', u'm'),
+    (0x1D51, 'M', u'ŋ'),
+    (0x1D52, 'M', u'o'),
+    ]
+
+def _seg_16():
+    return [
+    (0x1D53, 'M', u'ɔ'),
+    (0x1D54, 'M', u'ᴖ'),
+    (0x1D55, 'M', u'ᴗ'),
+    (0x1D56, 'M', u'p'),
+    (0x1D57, 'M', u't'),
+    (0x1D58, 'M', u'u'),
+    (0x1D59, 'M', u'ᴝ'),
+    (0x1D5A, 'M', u'ɯ'),
+    (0x1D5B, 'M', u'v'),
+    (0x1D5C, 'M', u'ᴥ'),
+    (0x1D5D, 'M', u'β'),
+    (0x1D5E, 'M', u'γ'),
+    (0x1D5F, 'M', u'δ'),
+    (0x1D60, 'M', u'φ'),
+    (0x1D61, 'M', u'χ'),
+    (0x1D62, 'M', u'i'),
+    (0x1D63, 'M', u'r'),
+    (0x1D64, 'M', u'u'),
+    (0x1D65, 'M', u'v'),
+    (0x1D66, 'M', u'β'),
+    (0x1D67, 'M', u'γ'),
+    (0x1D68, 'M', u'ρ'),
+    (0x1D69, 'M', u'φ'),
+    (0x1D6A, 'M', u'χ'),
+    (0x1D6B, 'V'),
+    (0x1D78, 'M', u'н'),
+    (0x1D79, 'V'),
+    (0x1D9B, 'M', u'ɒ'),
+    (0x1D9C, 'M', u'c'),
+    (0x1D9D, 'M', u'ɕ'),
+    (0x1D9E, 'M', u'ð'),
+    (0x1D9F, 'M', u'ɜ'),
+    (0x1DA0, 'M', u'f'),
+    (0x1DA1, 'M', u'ɟ'),
+    (0x1DA2, 'M', u'ɡ'),
+    (0x1DA3, 'M', u'ɥ'),
+    (0x1DA4, 'M', u'ɨ'),
+    (0x1DA5, 'M', u'ɩ'),
+    (0x1DA6, 'M', u'ɪ'),
+    (0x1DA7, 'M', u'ᵻ'),
+    (0x1DA8, 'M', u'ʝ'),
+    (0x1DA9, 'M', u'ɭ'),
+    (0x1DAA, 'M', u'ᶅ'),
+    (0x1DAB, 'M', u'ʟ'),
+    (0x1DAC, 'M', u'ɱ'),
+    (0x1DAD, 'M', u'ɰ'),
+    (0x1DAE, 'M', u'ɲ'),
+    (0x1DAF, 'M', u'ɳ'),
+    (0x1DB0, 'M', u'ɴ'),
+    (0x1DB1, 'M', u'ɵ'),
+    (0x1DB2, 'M', u'ɸ'),
+    (0x1DB3, 'M', u'ʂ'),
+    (0x1DB4, 'M', u'ʃ'),
+    (0x1DB5, 'M', u'ƫ'),
+    (0x1DB6, 'M', u'ʉ'),
+    (0x1DB7, 'M', u'ʊ'),
+    (0x1DB8, 'M', u'ᴜ'),
+    (0x1DB9, 'M', u'ʋ'),
+    (0x1DBA, 'M', u'ʌ'),
+    (0x1DBB, 'M', u'z'),
+    (0x1DBC, 'M', u'ʐ'),
+    (0x1DBD, 'M', u'ʑ'),
+    (0x1DBE, 'M', u'ʒ'),
+    (0x1DBF, 'M', u'θ'),
+    (0x1DC0, 'V'),
+    (0x1DFA, 'X'),
+    (0x1DFB, 'V'),
+    (0x1E00, 'M', u'ḁ'),
+    (0x1E01, 'V'),
+    (0x1E02, 'M', u'ḃ'),
+    (0x1E03, 'V'),
+    (0x1E04, 'M', u'ḅ'),
+    (0x1E05, 'V'),
+    (0x1E06, 'M', u'ḇ'),
+    (0x1E07, 'V'),
+    (0x1E08, 'M', u'ḉ'),
+    (0x1E09, 'V'),
+    (0x1E0A, 'M', u'ḋ'),
+    (0x1E0B, 'V'),
+    (0x1E0C, 'M', u'ḍ'),
+    (0x1E0D, 'V'),
+    (0x1E0E, 'M', u'ḏ'),
+    (0x1E0F, 'V'),
+    (0x1E10, 'M', u'ḑ'),
+    (0x1E11, 'V'),
+    (0x1E12, 'M', u'ḓ'),
+    (0x1E13, 'V'),
+    (0x1E14, 'M', u'ḕ'),
+    (0x1E15, 'V'),
+    (0x1E16, 'M', u'ḗ'),
+    (0x1E17, 'V'),
+    (0x1E18, 'M', u'ḙ'),
+    (0x1E19, 'V'),
+    (0x1E1A, 'M', u'ḛ'),
+    (0x1E1B, 'V'),
+    (0x1E1C, 'M', u'ḝ'),
+    (0x1E1D, 'V'),
+    (0x1E1E, 'M', u'ḟ'),
+    (0x1E1F, 'V'),
+    (0x1E20, 'M', u'ḡ'),
+    ]
+
+def _seg_17():
+    return [
+    (0x1E21, 'V'),
+    (0x1E22, 'M', u'ḣ'),
+    (0x1E23, 'V'),
+    (0x1E24, 'M', u'ḥ'),
+    (0x1E25, 'V'),
+    (0x1E26, 'M', u'ḧ'),
+    (0x1E27, 'V'),
+    (0x1E28, 'M', u'ḩ'),
+    (0x1E29, 'V'),
+    (0x1E2A, 'M', u'ḫ'),
+    (0x1E2B, 'V'),
+    (0x1E2C, 'M', u'ḭ'),
+    (0x1E2D, 'V'),
+    (0x1E2E, 'M', u'ḯ'),
+    (0x1E2F, 'V'),
+    (0x1E30, 'M', u'ḱ'),
+    (0x1E31, 'V'),
+    (0x1E32, 'M', u'ḳ'),
+    (0x1E33, 'V'),
+    (0x1E34, 'M', u'ḵ'),
+    (0x1E35, 'V'),
+    (0x1E36, 'M', u'ḷ'),
+    (0x1E37, 'V'),
+    (0x1E38, 'M', u'ḹ'),
+    (0x1E39, 'V'),
+    (0x1E3A, 'M', u'ḻ'),
+    (0x1E3B, 'V'),
+    (0x1E3C, 'M', u'ḽ'),
+    (0x1E3D, 'V'),
+    (0x1E3E, 'M', u'ḿ'),
+    (0x1E3F, 'V'),
+    (0x1E40, 'M', u'ṁ'),
+    (0x1E41, 'V'),
+    (0x1E42, 'M', u'ṃ'),
+    (0x1E43, 'V'),
+    (0x1E44, 'M', u'ṅ'),
+    (0x1E45, 'V'),
+    (0x1E46, 'M', u'ṇ'),
+    (0x1E47, 'V'),
+    (0x1E48, 'M', u'ṉ'),
+    (0x1E49, 'V'),
+    (0x1E4A, 'M', u'ṋ'),
+    (0x1E4B, 'V'),
+    (0x1E4C, 'M', u'ṍ'),
+    (0x1E4D, 'V'),
+    (0x1E4E, 'M', u'ṏ'),
+    (0x1E4F, 'V'),
+    (0x1E50, 'M', u'ṑ'),
+    (0x1E51, 'V'),
+    (0x1E52, 'M', u'ṓ'),
+    (0x1E53, 'V'),
+    (0x1E54, 'M', u'ṕ'),
+    (0x1E55, 'V'),
+    (0x1E56, 'M', u'ṗ'),
+    (0x1E57, 'V'),
+    (0x1E58, 'M', u'ṙ'),
+    (0x1E59, 'V'),
+    (0x1E5A, 'M', u'ṛ'),
+    (0x1E5B, 'V'),
+    (0x1E5C, 'M', u'ṝ'),
+    (0x1E5D, 'V'),
+    (0x1E5E, 'M', u'ṟ'),
+    (0x1E5F, 'V'),
+    (0x1E60, 'M', u'ṡ'),
+    (0x1E61, 'V'),
+    (0x1E62, 'M', u'ṣ'),
+    (0x1E63, 'V'),
+    (0x1E64, 'M', u'ṥ'),
+    (0x1E65, 'V'),
+    (0x1E66, 'M', u'ṧ'),
+    (0x1E67, 'V'),
+    (0x1E68, 'M', u'ṩ'),
+    (0x1E69, 'V'),
+    (0x1E6A, 'M', u'ṫ'),
+    (0x1E6B, 'V'),
+    (0x1E6C, 'M', u'ṭ'),
+    (0x1E6D, 'V'),
+    (0x1E6E, 'M', u'ṯ'),
+    (0x1E6F, 'V'),
+    (0x1E70, 'M', u'ṱ'),
+    (0x1E71, 'V'),
+    (0x1E72, 'M', u'ṳ'),
+    (0x1E73, 'V'),
+    (0x1E74, 'M', u'ṵ'),
+    (0x1E75, 'V'),
+    (0x1E76, 'M', u'ṷ'),
+    (0x1E77, 'V'),
+    (0x1E78, 'M', u'ṹ'),
+    (0x1E79, 'V'),
+    (0x1E7A, 'M', u'ṻ'),
+    (0x1E7B, 'V'),
+    (0x1E7C, 'M', u'ṽ'),
+    (0x1E7D, 'V'),
+    (0x1E7E, 'M', u'ṿ'),
+    (0x1E7F, 'V'),
+    (0x1E80, 'M', u'ẁ'),
+    (0x1E81, 'V'),
+    (0x1E82, 'M', u'ẃ'),
+    (0x1E83, 'V'),
+    (0x1E84, 'M', u'ẅ'),
+    ]
+
+def _seg_18():
+    return [
+    (0x1E85, 'V'),
+    (0x1E86, 'M', u'ẇ'),
+    (0x1E87, 'V'),
+    (0x1E88, 'M', u'ẉ'),
+    (0x1E89, 'V'),
+    (0x1E8A, 'M', u'ẋ'),
+    (0x1E8B, 'V'),
+    (0x1E8C, 'M', u'ẍ'),
+    (0x1E8D, 'V'),
+    (0x1E8E, 'M', u'ẏ'),
+    (0x1E8F, 'V'),
+    (0x1E90, 'M', u'ẑ'),
+    (0x1E91, 'V'),
+    (0x1E92, 'M', u'ẓ'),
+    (0x1E93, 'V'),
+    (0x1E94, 'M', u'ẕ'),
+    (0x1E95, 'V'),
+    (0x1E9A, 'M', u'aʾ'),
+    (0x1E9B, 'M', u'ṡ'),
+    (0x1E9C, 'V'),
+    (0x1E9E, 'M', u'ss'),
+    (0x1E9F, 'V'),
+    (0x1EA0, 'M', u'ạ'),
+    (0x1EA1, 'V'),
+    (0x1EA2, 'M', u'ả'),
+    (0x1EA3, 'V'),
+    (0x1EA4, 'M', u'ấ'),
+    (0x1EA5, 'V'),
+    (0x1EA6, 'M', u'ầ'),
+    (0x1EA7, 'V'),
+    (0x1EA8, 'M', u'ẩ'),
+    (0x1EA9, 'V'),
+    (0x1EAA, 'M', u'ẫ'),
+    (0x1EAB, 'V'),
+    (0x1EAC, 'M', u'ậ'),
+    (0x1EAD, 'V'),
+    (0x1EAE, 'M', u'ắ'),
+    (0x1EAF, 'V'),
+    (0x1EB0, 'M', u'ằ'),
+    (0x1EB1, 'V'),
+    (0x1EB2, 'M', u'ẳ'),
+    (0x1EB3, 'V'),
+    (0x1EB4, 'M', u'ẵ'),
+    (0x1EB5, 'V'),
+    (0x1EB6, 'M', u'ặ'),
+    (0x1EB7, 'V'),
+    (0x1EB8, 'M', u'ẹ'),
+    (0x1EB9, 'V'),
+    (0x1EBA, 'M', u'ẻ'),
+    (0x1EBB, 'V'),
+    (0x1EBC, 'M', u'ẽ'),
+    (0x1EBD, 'V'),
+    (0x1EBE, 'M', u'ế'),
+    (0x1EBF, 'V'),
+    (0x1EC0, 'M', u'ề'),
+    (0x1EC1, 'V'),
+    (0x1EC2, 'M', u'ể'),
+    (0x1EC3, 'V'),
+    (0x1EC4, 'M', u'ễ'),
+    (0x1EC5, 'V'),
+    (0x1EC6, 'M', u'ệ'),
+    (0x1EC7, 'V'),
+    (0x1EC8, 'M', u'ỉ'),
+    (0x1EC9, 'V'),
+    (0x1ECA, 'M', u'ị'),
+    (0x1ECB, 'V'),
+    (0x1ECC, 'M', u'ọ'),
+    (0x1ECD, 'V'),
+    (0x1ECE, 'M', u'ỏ'),
+    (0x1ECF, 'V'),
+    (0x1ED0, 'M', u'ố'),
+    (0x1ED1, 'V'),
+    (0x1ED2, 'M', u'ồ'),
+    (0x1ED3, 'V'),
+    (0x1ED4, 'M', u'ổ'),
+    (0x1ED5, 'V'),
+    (0x1ED6, 'M', u'ỗ'),
+    (0x1ED7, 'V'),
+    (0x1ED8, 'M', u'ộ'),
+    (0x1ED9, 'V'),
+    (0x1EDA, 'M', u'ớ'),
+    (0x1EDB, 'V'),
+    (0x1EDC, 'M', u'ờ'),
+    (0x1EDD, 'V'),
+    (0x1EDE, 'M', u'ở'),
+    (0x1EDF, 'V'),
+    (0x1EE0, 'M', u'ỡ'),
+    (0x1EE1, 'V'),
+    (0x1EE2, 'M', u'ợ'),
+    (0x1EE3, 'V'),
+    (0x1EE4, 'M', u'ụ'),
+    (0x1EE5, 'V'),
+    (0x1EE6, 'M', u'ủ'),
+    (0x1EE7, 'V'),
+    (0x1EE8, 'M', u'ứ'),
+    (0x1EE9, 'V'),
+    (0x1EEA, 'M', u'ừ'),
+    (0x1EEB, 'V'),
+    (0x1EEC, 'M', u'ử'),
+    (0x1EED, 'V'),
+    ]
+
+def _seg_19():
+    return [
+    (0x1EEE, 'M', u'ữ'),
+    (0x1EEF, 'V'),
+    (0x1EF0, 'M', u'ự'),
+    (0x1EF1, 'V'),
+    (0x1EF2, 'M', u'ỳ'),
+    (0x1EF3, 'V'),
+    (0x1EF4, 'M', u'ỵ'),
+    (0x1EF5, 'V'),
+    (0x1EF6, 'M', u'ỷ'),
+    (0x1EF7, 'V'),
+    (0x1EF8, 'M', u'ỹ'),
+    (0x1EF9, 'V'),
+    (0x1EFA, 'M', u'ỻ'),
+    (0x1EFB, 'V'),
+    (0x1EFC, 'M', u'ỽ'),
+    (0x1EFD, 'V'),
+    (0x1EFE, 'M', u'ỿ'),
+    (0x1EFF, 'V'),
+    (0x1F08, 'M', u'ἀ'),
+    (0x1F09, 'M', u'ἁ'),
+    (0x1F0A, 'M', u'ἂ'),
+    (0x1F0B, 'M', u'ἃ'),
+    (0x1F0C, 'M', u'ἄ'),
+    (0x1F0D, 'M', u'ἅ'),
+    (0x1F0E, 'M', u'ἆ'),
+    (0x1F0F, 'M', u'ἇ'),
+    (0x1F10, 'V'),
+    (0x1F16, 'X'),
+    (0x1F18, 'M', u'ἐ'),
+    (0x1F19, 'M', u'ἑ'),
+    (0x1F1A, 'M', u'ἒ'),
+    (0x1F1B, 'M', u'ἓ'),
+    (0x1F1C, 'M', u'ἔ'),
+    (0x1F1D, 'M', u'ἕ'),
+    (0x1F1E, 'X'),
+    (0x1F20, 'V'),
+    (0x1F28, 'M', u'ἠ'),
+    (0x1F29, 'M', u'ἡ'),
+    (0x1F2A, 'M', u'ἢ'),
+    (0x1F2B, 'M', u'ἣ'),
+    (0x1F2C, 'M', u'ἤ'),
+    (0x1F2D, 'M', u'ἥ'),
+    (0x1F2E, 'M', u'ἦ'),
+    (0x1F2F, 'M', u'ἧ'),
+    (0x1F30, 'V'),
+    (0x1F38, 'M', u'ἰ'),
+    (0x1F39, 'M', u'ἱ'),
+    (0x1F3A, 'M', u'ἲ'),
+    (0x1F3B, 'M', u'ἳ'),
+    (0x1F3C, 'M', u'ἴ'),
+    (0x1F3D, 'M', u'ἵ'),
+    (0x1F3E, 'M', u'ἶ'),
+    (0x1F3F, 'M', u'ἷ'),
+    (0x1F40, 'V'),
+    (0x1F46, 'X'),
+    (0x1F48, 'M', u'ὀ'),
+    (0x1F49, 'M', u'ὁ'),
+    (0x1F4A, 'M', u'ὂ'),
+    (0x1F4B, 'M', u'ὃ'),
+    (0x1F4C, 'M', u'ὄ'),
+    (0x1F4D, 'M', u'ὅ'),
+    (0x1F4E, 'X'),
+    (0x1F50, 'V'),
+    (0x1F58, 'X'),
+    (0x1F59, 'M', u'ὑ'),
+    (0x1F5A, 'X'),
+    (0x1F5B, 'M', u'ὓ'),
+    (0x1F5C, 'X'),
+    (0x1F5D, 'M', u'ὕ'),
+    (0x1F5E, 'X'),
+    (0x1F5F, 'M', u'ὗ'),
+    (0x1F60, 'V'),
+    (0x1F68, 'M', u'ὠ'),
+    (0x1F69, 'M', u'ὡ'),
+    (0x1F6A, 'M', u'ὢ'),
+    (0x1F6B, 'M', u'ὣ'),
+    (0x1F6C, 'M', u'ὤ'),
+    (0x1F6D, 'M', u'ὥ'),
+    (0x1F6E, 'M', u'ὦ'),
+    (0x1F6F, 'M', u'ὧ'),
+    (0x1F70, 'V'),
+    (0x1F71, 'M', u'ά'),
+    (0x1F72, 'V'),
+    (0x1F73, 'M', u'έ'),
+    (0x1F74, 'V'),
+    (0x1F75, 'M', u'ή'),
+    (0x1F76, 'V'),
+    (0x1F77, 'M', u'ί'),
+    (0x1F78, 'V'),
+    (0x1F79, 'M', u'ό'),
+    (0x1F7A, 'V'),
+    (0x1F7B, 'M', u'ύ'),
+    (0x1F7C, 'V'),
+    (0x1F7D, 'M', u'ώ'),
+    (0x1F7E, 'X'),
+    (0x1F80, 'M', u'ἀι'),
+    (0x1F81, 'M', u'ἁι'),
+    (0x1F82, 'M', u'ἂι'),
+    (0x1F83, 'M', u'ἃι'),
+    (0x1F84, 'M', u'ἄι'),
+    ]
+
+def _seg_20():
+    return [
+    (0x1F85, 'M', u'ἅι'),
+    (0x1F86, 'M', u'ἆι'),
+    (0x1F87, 'M', u'ἇι'),
+    (0x1F88, 'M', u'ἀι'),
+    (0x1F89, 'M', u'ἁι'),
+    (0x1F8A, 'M', u'ἂι'),
+    (0x1F8B, 'M', u'ἃι'),
+    (0x1F8C, 'M', u'ἄι'),
+    (0x1F8D, 'M', u'ἅι'),
+    (0x1F8E, 'M', u'ἆι'),
+    (0x1F8F, 'M', u'ἇι'),
+    (0x1F90, 'M', u'ἠι'),
+    (0x1F91, 'M', u'ἡι'),
+    (0x1F92, 'M', u'ἢι'),
+    (0x1F93, 'M', u'ἣι'),
+    (0x1F94, 'M', u'ἤι'),
+    (0x1F95, 'M', u'ἥι'),
+    (0x1F96, 'M', u'ἦι'),
+    (0x1F97, 'M', u'ἧι'),
+    (0x1F98, 'M', u'ἠι'),
+    (0x1F99, 'M', u'ἡι'),
+    (0x1F9A, 'M', u'ἢι'),
+    (0x1F9B, 'M', u'ἣι'),
+    (0x1F9C, 'M', u'ἤι'),
+    (0x1F9D, 'M', u'ἥι'),
+    (0x1F9E, 'M', u'ἦι'),
+    (0x1F9F, 'M', u'ἧι'),
+    (0x1FA0, 'M', u'ὠι'),
+    (0x1FA1, 'M', u'ὡι'),
+    (0x1FA2, 'M', u'ὢι'),
+    (0x1FA3, 'M', u'ὣι'),
+    (0x1FA4, 'M', u'ὤι'),
+    (0x1FA5, 'M', u'ὥι'),
+    (0x1FA6, 'M', u'ὦι'),
+    (0x1FA7, 'M', u'ὧι'),
+    (0x1FA8, 'M', u'ὠι'),
+    (0x1FA9, 'M', u'ὡι'),
+    (0x1FAA, 'M', u'ὢι'),
+    (0x1FAB, 'M', u'ὣι'),
+    (0x1FAC, 'M', u'ὤι'),
+    (0x1FAD, 'M', u'ὥι'),
+    (0x1FAE, 'M', u'ὦι'),
+    (0x1FAF, 'M', u'ὧι'),
+    (0x1FB0, 'V'),
+    (0x1FB2, 'M', u'ὰι'),
+    (0x1FB3, 'M', u'αι'),
+    (0x1FB4, 'M', u'άι'),
+    (0x1FB5, 'X'),
+    (0x1FB6, 'V'),
+    (0x1FB7, 'M', u'ᾶι'),
+    (0x1FB8, 'M', u'ᾰ'),
+    (0x1FB9, 'M', u'ᾱ'),
+    (0x1FBA, 'M', u'ὰ'),
+    (0x1FBB, 'M', u'ά'),
+    (0x1FBC, 'M', u'αι'),
+    (0x1FBD, '3', u' ̓'),
+    (0x1FBE, 'M', u'ι'),
+    (0x1FBF, '3', u' ̓'),
+    (0x1FC0, '3', u' ͂'),
+    (0x1FC1, '3', u' ̈͂'),
+    (0x1FC2, 'M', u'ὴι'),
+    (0x1FC3, 'M', u'ηι'),
+    (0x1FC4, 'M', u'ήι'),
+    (0x1FC5, 'X'),
+    (0x1FC6, 'V'),
+    (0x1FC7, 'M', u'ῆι'),
+    (0x1FC8, 'M', u'ὲ'),
+    (0x1FC9, 'M', u'έ'),
+    (0x1FCA, 'M', u'ὴ'),
+    (0x1FCB, 'M', u'ή'),
+    (0x1FCC, 'M', u'ηι'),
+    (0x1FCD, '3', u' ̓̀'),
+    (0x1FCE, '3', u' ̓́'),
+    (0x1FCF, '3', u' ̓͂'),
+    (0x1FD0, 'V'),
+    (0x1FD3, 'M', u'ΐ'),
+    (0x1FD4, 'X'),
+    (0x1FD6, 'V'),
+    (0x1FD8, 'M', u'ῐ'),
+    (0x1FD9, 'M', u'ῑ'),
+    (0x1FDA, 'M', u'ὶ'),
+    (0x1FDB, 'M', u'ί'),
+    (0x1FDC, 'X'),
+    (0x1FDD, '3', u' ̔̀'),
+    (0x1FDE, '3', u' ̔́'),
+    (0x1FDF, '3', u' ̔͂'),
+    (0x1FE0, 'V'),
+    (0x1FE3, 'M', u'ΰ'),
+    (0x1FE4, 'V'),
+    (0x1FE8, 'M', u'ῠ'),
+    (0x1FE9, 'M', u'ῡ'),
+    (0x1FEA, 'M', u'ὺ'),
+    (0x1FEB, 'M', u'ύ'),
+    (0x1FEC, 'M', u'ῥ'),
+    (0x1FED, '3', u' ̈̀'),
+    (0x1FEE, '3', u' ̈́'),
+    (0x1FEF, '3', u'`'),
+    (0x1FF0, 'X'),
+    (0x1FF2, 'M', u'ὼι'),
+    (0x1FF3, 'M', u'ωι'),
+    ]
+
+def _seg_21():
+    return [
+    (0x1FF4, 'M', u'ώι'),
+    (0x1FF5, 'X'),
+    (0x1FF6, 'V'),
+    (0x1FF7, 'M', u'ῶι'),
+    (0x1FF8, 'M', u'ὸ'),
+    (0x1FF9, 'M', u'ό'),
+    (0x1FFA, 'M', u'ὼ'),
+    (0x1FFB, 'M', u'ώ'),
+    (0x1FFC, 'M', u'ωι'),
+    (0x1FFD, '3', u' ́'),
+    (0x1FFE, '3', u' ̔'),
+    (0x1FFF, 'X'),
+    (0x2000, '3', u' '),
+    (0x200B, 'I'),
+    (0x200C, 'D', u''),
+    (0x200E, 'X'),
+    (0x2010, 'V'),
+    (0x2011, 'M', u'‐'),
+    (0x2012, 'V'),
+    (0x2017, '3', u' ̳'),
+    (0x2018, 'V'),
+    (0x2024, 'X'),
+    (0x2027, 'V'),
+    (0x2028, 'X'),
+    (0x202F, '3', u' '),
+    (0x2030, 'V'),
+    (0x2033, 'M', u'′′'),
+    (0x2034, 'M', u'′′′'),
+    (0x2035, 'V'),
+    (0x2036, 'M', u'‵‵'),
+    (0x2037, 'M', u'‵‵‵'),
+    (0x2038, 'V'),
+    (0x203C, '3', u'!!'),
+    (0x203D, 'V'),
+    (0x203E, '3', u' ̅'),
+    (0x203F, 'V'),
+    (0x2047, '3', u'??'),
+    (0x2048, '3', u'?!'),
+    (0x2049, '3', u'!?'),
+    (0x204A, 'V'),
+    (0x2057, 'M', u'′′′′'),
+    (0x2058, 'V'),
+    (0x205F, '3', u' '),
+    (0x2060, 'I'),
+    (0x2061, 'X'),
+    (0x2064, 'I'),
+    (0x2065, 'X'),
+    (0x2070, 'M', u'0'),
+    (0x2071, 'M', u'i'),
+    (0x2072, 'X'),
+    (0x2074, 'M', u'4'),
+    (0x2075, 'M', u'5'),
+    (0x2076, 'M', u'6'),
+    (0x2077, 'M', u'7'),
+    (0x2078, 'M', u'8'),
+    (0x2079, 'M', u'9'),
+    (0x207A, '3', u'+'),
+    (0x207B, 'M', u'−'),
+    (0x207C, '3', u'='),
+    (0x207D, '3', u'('),
+    (0x207E, '3', u')'),
+    (0x207F, 'M', u'n'),
+    (0x2080, 'M', u'0'),
+    (0x2081, 'M', u'1'),
+    (0x2082, 'M', u'2'),
+    (0x2083, 'M', u'3'),
+    (0x2084, 'M', u'4'),
+    (0x2085, 'M', u'5'),
+    (0x2086, 'M', u'6'),
+    (0x2087, 'M', u'7'),
+    (0x2088, 'M', u'8'),
+    (0x2089, 'M', u'9'),
+    (0x208A, '3', u'+'),
+    (0x208B, 'M', u'−'),
+    (0x208C, '3', u'='),
+    (0x208D, '3', u'('),
+    (0x208E, '3', u')'),
+    (0x208F, 'X'),
+    (0x2090, 'M', u'a'),
+    (0x2091, 'M', u'e'),
+    (0x2092, 'M', u'o'),
+    (0x2093, 'M', u'x'),
+    (0x2094, 'M', u'ə'),
+    (0x2095, 'M', u'h'),
+    (0x2096, 'M', u'k'),
+    (0x2097, 'M', u'l'),
+    (0x2098, 'M', u'm'),
+    (0x2099, 'M', u'n'),
+    (0x209A, 'M', u'p'),
+    (0x209B, 'M', u's'),
+    (0x209C, 'M', u't'),
+    (0x209D, 'X'),
+    (0x20A0, 'V'),
+    (0x20A8, 'M', u'rs'),
+    (0x20A9, 'V'),
+    (0x20C0, 'X'),
+    (0x20D0, 'V'),
+    (0x20F1, 'X'),
+    (0x2100, '3', u'a/c'),
+    (0x2101, '3', u'a/s'),
+    ]
+
+def _seg_22():
+    return [
+    (0x2102, 'M', u'c'),
+    (0x2103, 'M', u'°c'),
+    (0x2104, 'V'),
+    (0x2105, '3', u'c/o'),
+    (0x2106, '3', u'c/u'),
+    (0x2107, 'M', u'ɛ'),
+    (0x2108, 'V'),
+    (0x2109, 'M', u'°f'),
+    (0x210A, 'M', u'g'),
+    (0x210B, 'M', u'h'),
+    (0x210F, 'M', u'ħ'),
+    (0x2110, 'M', u'i'),
+    (0x2112, 'M', u'l'),
+    (0x2114, 'V'),
+    (0x2115, 'M', u'n'),
+    (0x2116, 'M', u'no'),
+    (0x2117, 'V'),
+    (0x2119, 'M', u'p'),
+    (0x211A, 'M', u'q'),
+    (0x211B, 'M', u'r'),
+    (0x211E, 'V'),
+    (0x2120, 'M', u'sm'),
+    (0x2121, 'M', u'tel'),
+    (0x2122, 'M', u'tm'),
+    (0x2123, 'V'),
+    (0x2124, 'M', u'z'),
+    (0x2125, 'V'),
+    (0x2126, 'M', u'ω'),
+    (0x2127, 'V'),
+    (0x2128, 'M', u'z'),
+    (0x2129, 'V'),
+    (0x212A, 'M', u'k'),
+    (0x212B, 'M', u'å'),
+    (0x212C, 'M', u'b'),
+    (0x212D, 'M', u'c'),
+    (0x212E, 'V'),
+    (0x212F, 'M', u'e'),
+    (0x2131, 'M', u'f'),
+    (0x2132, 'X'),
+    (0x2133, 'M', u'm'),
+    (0x2134, 'M', u'o'),
+    (0x2135, 'M', u'א'),
+    (0x2136, 'M', u'ב'),
+    (0x2137, 'M', u'ג'),
+    (0x2138, 'M', u'ד'),
+    (0x2139, 'M', u'i'),
+    (0x213A, 'V'),
+    (0x213B, 'M', u'fax'),
+    (0x213C, 'M', u'π'),
+    (0x213D, 'M', u'γ'),
+    (0x213F, 'M', u'π'),
+    (0x2140, 'M', u'∑'),
+    (0x2141, 'V'),
+    (0x2145, 'M', u'd'),
+    (0x2147, 'M', u'e'),
+    (0x2148, 'M', u'i'),
+    (0x2149, 'M', u'j'),
+    (0x214A, 'V'),
+    (0x2150, 'M', u'1⁄7'),
+    (0x2151, 'M', u'1⁄9'),
+    (0x2152, 'M', u'1⁄10'),
+    (0x2153, 'M', u'1⁄3'),
+    (0x2154, 'M', u'2⁄3'),
+    (0x2155, 'M', u'1⁄5'),
+    (0x2156, 'M', u'2⁄5'),
+    (0x2157, 'M', u'3⁄5'),
+    (0x2158, 'M', u'4⁄5'),
+    (0x2159, 'M', u'1⁄6'),
+    (0x215A, 'M', u'5⁄6'),
+    (0x215B, 'M', u'1⁄8'),
+    (0x215C, 'M', u'3⁄8'),
+    (0x215D, 'M', u'5⁄8'),
+    (0x215E, 'M', u'7⁄8'),
+    (0x215F, 'M', u'1⁄'),
+    (0x2160, 'M', u'i'),
+    (0x2161, 'M', u'ii'),
+    (0x2162, 'M', u'iii'),
+    (0x2163, 'M', u'iv'),
+    (0x2164, 'M', u'v'),
+    (0x2165, 'M', u'vi'),
+    (0x2166, 'M', u'vii'),
+    (0x2167, 'M', u'viii'),
+    (0x2168, 'M', u'ix'),
+    (0x2169, 'M', u'x'),
+    (0x216A, 'M', u'xi'),
+    (0x216B, 'M', u'xii'),
+    (0x216C, 'M', u'l'),
+    (0x216D, 'M', u'c'),
+    (0x216E, 'M', u'd'),
+    (0x216F, 'M', u'm'),
+    (0x2170, 'M', u'i'),
+    (0x2171, 'M', u'ii'),
+    (0x2172, 'M', u'iii'),
+    (0x2173, 'M', u'iv'),
+    (0x2174, 'M', u'v'),
+    (0x2175, 'M', u'vi'),
+    (0x2176, 'M', u'vii'),
+    (0x2177, 'M', u'viii'),
+    (0x2178, 'M', u'ix'),
+    (0x2179, 'M', u'x'),
+    ]
+
+def _seg_23():
+    return [
+    (0x217A, 'M', u'xi'),
+    (0x217B, 'M', u'xii'),
+    (0x217C, 'M', u'l'),
+    (0x217D, 'M', u'c'),
+    (0x217E, 'M', u'd'),
+    (0x217F, 'M', u'm'),
+    (0x2180, 'V'),
+    (0x2183, 'X'),
+    (0x2184, 'V'),
+    (0x2189, 'M', u'0⁄3'),
+    (0x218A, 'V'),
+    (0x218C, 'X'),
+    (0x2190, 'V'),
+    (0x222C, 'M', u'∫∫'),
+    (0x222D, 'M', u'∫∫∫'),
+    (0x222E, 'V'),
+    (0x222F, 'M', u'∮∮'),
+    (0x2230, 'M', u'∮∮∮'),
+    (0x2231, 'V'),
+    (0x2260, '3'),
+    (0x2261, 'V'),
+    (0x226E, '3'),
+    (0x2270, 'V'),
+    (0x2329, 'M', u'〈'),
+    (0x232A, 'M', u'〉'),
+    (0x232B, 'V'),
+    (0x2427, 'X'),
+    (0x2440, 'V'),
+    (0x244B, 'X'),
+    (0x2460, 'M', u'1'),
+    (0x2461, 'M', u'2'),
+    (0x2462, 'M', u'3'),
+    (0x2463, 'M', u'4'),
+    (0x2464, 'M', u'5'),
+    (0x2465, 'M', u'6'),
+    (0x2466, 'M', u'7'),
+    (0x2467, 'M', u'8'),
+    (0x2468, 'M', u'9'),
+    (0x2469, 'M', u'10'),
+    (0x246A, 'M', u'11'),
+    (0x246B, 'M', u'12'),
+    (0x246C, 'M', u'13'),
+    (0x246D, 'M', u'14'),
+    (0x246E, 'M', u'15'),
+    (0x246F, 'M', u'16'),
+    (0x2470, 'M', u'17'),
+    (0x2471, 'M', u'18'),
+    (0x2472, 'M', u'19'),
+    (0x2473, 'M', u'20'),
+    (0x2474, '3', u'(1)'),
+    (0x2475, '3', u'(2)'),
+    (0x2476, '3', u'(3)'),
+    (0x2477, '3', u'(4)'),
+    (0x2478, '3', u'(5)'),
+    (0x2479, '3', u'(6)'),
+    (0x247A, '3', u'(7)'),
+    (0x247B, '3', u'(8)'),
+    (0x247C, '3', u'(9)'),
+    (0x247D, '3', u'(10)'),
+    (0x247E, '3', u'(11)'),
+    (0x247F, '3', u'(12)'),
+    (0x2480, '3', u'(13)'),
+    (0x2481, '3', u'(14)'),
+    (0x2482, '3', u'(15)'),
+    (0x2483, '3', u'(16)'),
+    (0x2484, '3', u'(17)'),
+    (0x2485, '3', u'(18)'),
+    (0x2486, '3', u'(19)'),
+    (0x2487, '3', u'(20)'),
+    (0x2488, 'X'),
+    (0x249C, '3', u'(a)'),
+    (0x249D, '3', u'(b)'),
+    (0x249E, '3', u'(c)'),
+    (0x249F, '3', u'(d)'),
+    (0x24A0, '3', u'(e)'),
+    (0x24A1, '3', u'(f)'),
+    (0x24A2, '3', u'(g)'),
+    (0x24A3, '3', u'(h)'),
+    (0x24A4, '3', u'(i)'),
+    (0x24A5, '3', u'(j)'),
+    (0x24A6, '3', u'(k)'),
+    (0x24A7, '3', u'(l)'),
+    (0x24A8, '3', u'(m)'),
+    (0x24A9, '3', u'(n)'),
+    (0x24AA, '3', u'(o)'),
+    (0x24AB, '3', u'(p)'),
+    (0x24AC, '3', u'(q)'),
+    (0x24AD, '3', u'(r)'),
+    (0x24AE, '3', u'(s)'),
+    (0x24AF, '3', u'(t)'),
+    (0x24B0, '3', u'(u)'),
+    (0x24B1, '3', u'(v)'),
+    (0x24B2, '3', u'(w)'),
+    (0x24B3, '3', u'(x)'),
+    (0x24B4, '3', u'(y)'),
+    (0x24B5, '3', u'(z)'),
+    (0x24B6, 'M', u'a'),
+    (0x24B7, 'M', u'b'),
+    (0x24B8, 'M', u'c'),
+    (0x24B9, 'M', u'd'),
+    ]
+
+def _seg_24():
+    return [
+    (0x24BA, 'M', u'e'),
+    (0x24BB, 'M', u'f'),
+    (0x24BC, 'M', u'g'),
+    (0x24BD, 'M', u'h'),
+    (0x24BE, 'M', u'i'),
+    (0x24BF, 'M', u'j'),
+    (0x24C0, 'M', u'k'),
+    (0x24C1, 'M', u'l'),
+    (0x24C2, 'M', u'm'),
+    (0x24C3, 'M', u'n'),
+    (0x24C4, 'M', u'o'),
+    (0x24C5, 'M', u'p'),
+    (0x24C6, 'M', u'q'),
+    (0x24C7, 'M', u'r'),
+    (0x24C8, 'M', u's'),
+    (0x24C9, 'M', u't'),
+    (0x24CA, 'M', u'u'),
+    (0x24CB, 'M', u'v'),
+    (0x24CC, 'M', u'w'),
+    (0x24CD, 'M', u'x'),
+    (0x24CE, 'M', u'y'),
+    (0x24CF, 'M', u'z'),
+    (0x24D0, 'M', u'a'),
+    (0x24D1, 'M', u'b'),
+    (0x24D2, 'M', u'c'),
+    (0x24D3, 'M', u'd'),
+    (0x24D4, 'M', u'e'),
+    (0x24D5, 'M', u'f'),
+    (0x24D6, 'M', u'g'),
+    (0x24D7, 'M', u'h'),
+    (0x24D8, 'M', u'i'),
+    (0x24D9, 'M', u'j'),
+    (0x24DA, 'M', u'k'),
+    (0x24DB, 'M', u'l'),
+    (0x24DC, 'M', u'm'),
+    (0x24DD, 'M', u'n'),
+    (0x24DE, 'M', u'o'),
+    (0x24DF, 'M', u'p'),
+    (0x24E0, 'M', u'q'),
+    (0x24E1, 'M', u'r'),
+    (0x24E2, 'M', u's'),
+    (0x24E3, 'M', u't'),
+    (0x24E4, 'M', u'u'),
+    (0x24E5, 'M', u'v'),
+    (0x24E6, 'M', u'w'),
+    (0x24E7, 'M', u'x'),
+    (0x24E8, 'M', u'y'),
+    (0x24E9, 'M', u'z'),
+    (0x24EA, 'M', u'0'),
+    (0x24EB, 'V'),
+    (0x2A0C, 'M', u'∫∫∫∫'),
+    (0x2A0D, 'V'),
+    (0x2A74, '3', u'::='),
+    (0x2A75, '3', u'=='),
+    (0x2A76, '3', u'==='),
+    (0x2A77, 'V'),
+    (0x2ADC, 'M', u'⫝̸'),
+    (0x2ADD, 'V'),
+    (0x2B74, 'X'),
+    (0x2B76, 'V'),
+    (0x2B96, 'X'),
+    (0x2B97, 'V'),
+    (0x2C00, 'M', u'ⰰ'),
+    (0x2C01, 'M', u'ⰱ'),
+    (0x2C02, 'M', u'ⰲ'),
+    (0x2C03, 'M', u'ⰳ'),
+    (0x2C04, 'M', u'ⰴ'),
+    (0x2C05, 'M', u'ⰵ'),
+    (0x2C06, 'M', u'ⰶ'),
+    (0x2C07, 'M', u'ⰷ'),
+    (0x2C08, 'M', u'ⰸ'),
+    (0x2C09, 'M', u'ⰹ'),
+    (0x2C0A, 'M', u'ⰺ'),
+    (0x2C0B, 'M', u'ⰻ'),
+    (0x2C0C, 'M', u'ⰼ'),
+    (0x2C0D, 'M', u'ⰽ'),
+    (0x2C0E, 'M', u'ⰾ'),
+    (0x2C0F, 'M', u'ⰿ'),
+    (0x2C10, 'M', u'ⱀ'),
+    (0x2C11, 'M', u'ⱁ'),
+    (0x2C12, 'M', u'ⱂ'),
+    (0x2C13, 'M', u'ⱃ'),
+    (0x2C14, 'M', u'ⱄ'),
+    (0x2C15, 'M', u'ⱅ'),
+    (0x2C16, 'M', u'ⱆ'),
+    (0x2C17, 'M', u'ⱇ'),
+    (0x2C18, 'M', u'ⱈ'),
+    (0x2C19, 'M', u'ⱉ'),
+    (0x2C1A, 'M', u'ⱊ'),
+    (0x2C1B, 'M', u'ⱋ'),
+    (0x2C1C, 'M', u'ⱌ'),
+    (0x2C1D, 'M', u'ⱍ'),
+    (0x2C1E, 'M', u'ⱎ'),
+    (0x2C1F, 'M', u'ⱏ'),
+    (0x2C20, 'M', u'ⱐ'),
+    (0x2C21, 'M', u'ⱑ'),
+    (0x2C22, 'M', u'ⱒ'),
+    (0x2C23, 'M', u'ⱓ'),
+    (0x2C24, 'M', u'ⱔ'),
+    (0x2C25, 'M', u'ⱕ'),
+    ]
+
+def _seg_25():
+    return [
+    (0x2C26, 'M', u'ⱖ'),
+    (0x2C27, 'M', u'ⱗ'),
+    (0x2C28, 'M', u'ⱘ'),
+    (0x2C29, 'M', u'ⱙ'),
+    (0x2C2A, 'M', u'ⱚ'),
+    (0x2C2B, 'M', u'ⱛ'),
+    (0x2C2C, 'M', u'ⱜ'),
+    (0x2C2D, 'M', u'ⱝ'),
+    (0x2C2E, 'M', u'ⱞ'),
+    (0x2C2F, 'X'),
+    (0x2C30, 'V'),
+    (0x2C5F, 'X'),
+    (0x2C60, 'M', u'ⱡ'),
+    (0x2C61, 'V'),
+    (0x2C62, 'M', u'ɫ'),
+    (0x2C63, 'M', u'ᵽ'),
+    (0x2C64, 'M', u'ɽ'),
+    (0x2C65, 'V'),
+    (0x2C67, 'M', u'ⱨ'),
+    (0x2C68, 'V'),
+    (0x2C69, 'M', u'ⱪ'),
+    (0x2C6A, 'V'),
+    (0x2C6B, 'M', u'ⱬ'),
+    (0x2C6C, 'V'),
+    (0x2C6D, 'M', u'ɑ'),
+    (0x2C6E, 'M', u'ɱ'),
+    (0x2C6F, 'M', u'ɐ'),
+    (0x2C70, 'M', u'ɒ'),
+    (0x2C71, 'V'),
+    (0x2C72, 'M', u'ⱳ'),
+    (0x2C73, 'V'),
+    (0x2C75, 'M', u'ⱶ'),
+    (0x2C76, 'V'),
+    (0x2C7C, 'M', u'j'),
+    (0x2C7D, 'M', u'v'),
+    (0x2C7E, 'M', u'ȿ'),
+    (0x2C7F, 'M', u'ɀ'),
+    (0x2C80, 'M', u'ⲁ'),
+    (0x2C81, 'V'),
+    (0x2C82, 'M', u'ⲃ'),
+    (0x2C83, 'V'),
+    (0x2C84, 'M', u'ⲅ'),
+    (0x2C85, 'V'),
+    (0x2C86, 'M', u'ⲇ'),
+    (0x2C87, 'V'),
+    (0x2C88, 'M', u'ⲉ'),
+    (0x2C89, 'V'),
+    (0x2C8A, 'M', u'ⲋ'),
+    (0x2C8B, 'V'),
+    (0x2C8C, 'M', u'ⲍ'),
+    (0x2C8D, 'V'),
+    (0x2C8E, 'M', u'ⲏ'),
+    (0x2C8F, 'V'),
+    (0x2C90, 'M', u'ⲑ'),
+    (0x2C91, 'V'),
+    (0x2C92, 'M', u'ⲓ'),
+    (0x2C93, 'V'),
+    (0x2C94, 'M', u'ⲕ'),
+    (0x2C95, 'V'),
+    (0x2C96, 'M', u'ⲗ'),
+    (0x2C97, 'V'),
+    (0x2C98, 'M', u'ⲙ'),
+    (0x2C99, 'V'),
+    (0x2C9A, 'M', u'ⲛ'),
+    (0x2C9B, 'V'),
+    (0x2C9C, 'M', u'ⲝ'),
+    (0x2C9D, 'V'),
+    (0x2C9E, 'M', u'ⲟ'),
+    (0x2C9F, 'V'),
+    (0x2CA0, 'M', u'ⲡ'),
+    (0x2CA1, 'V'),
+    (0x2CA2, 'M', u'ⲣ'),
+    (0x2CA3, 'V'),
+    (0x2CA4, 'M', u'ⲥ'),
+    (0x2CA5, 'V'),
+    (0x2CA6, 'M', u'ⲧ'),
+    (0x2CA7, 'V'),
+    (0x2CA8, 'M', u'ⲩ'),
+    (0x2CA9, 'V'),
+    (0x2CAA, 'M', u'ⲫ'),
+    (0x2CAB, 'V'),
+    (0x2CAC, 'M', u'ⲭ'),
+    (0x2CAD, 'V'),
+    (0x2CAE, 'M', u'ⲯ'),
+    (0x2CAF, 'V'),
+    (0x2CB0, 'M', u'ⲱ'),
+    (0x2CB1, 'V'),
+    (0x2CB2, 'M', u'ⲳ'),
+    (0x2CB3, 'V'),
+    (0x2CB4, 'M', u'ⲵ'),
+    (0x2CB5, 'V'),
+    (0x2CB6, 'M', u'ⲷ'),
+    (0x2CB7, 'V'),
+    (0x2CB8, 'M', u'ⲹ'),
+    (0x2CB9, 'V'),
+    (0x2CBA, 'M', u'ⲻ'),
+    (0x2CBB, 'V'),
+    (0x2CBC, 'M', u'ⲽ'),
+    (0x2CBD, 'V'),
+    (0x2CBE, 'M', u'ⲿ'),
+    ]
+
+def _seg_26():
+    return [
+    (0x2CBF, 'V'),
+    (0x2CC0, 'M', u'ⳁ'),
+    (0x2CC1, 'V'),
+    (0x2CC2, 'M', u'ⳃ'),
+    (0x2CC3, 'V'),
+    (0x2CC4, 'M', u'ⳅ'),
+    (0x2CC5, 'V'),
+    (0x2CC6, 'M', u'ⳇ'),
+    (0x2CC7, 'V'),
+    (0x2CC8, 'M', u'ⳉ'),
+    (0x2CC9, 'V'),
+    (0x2CCA, 'M', u'ⳋ'),
+    (0x2CCB, 'V'),
+    (0x2CCC, 'M', u'ⳍ'),
+    (0x2CCD, 'V'),
+    (0x2CCE, 'M', u'ⳏ'),
+    (0x2CCF, 'V'),
+    (0x2CD0, 'M', u'ⳑ'),
+    (0x2CD1, 'V'),
+    (0x2CD2, 'M', u'ⳓ'),
+    (0x2CD3, 'V'),
+    (0x2CD4, 'M', u'ⳕ'),
+    (0x2CD5, 'V'),
+    (0x2CD6, 'M', u'ⳗ'),
+    (0x2CD7, 'V'),
+    (0x2CD8, 'M', u'ⳙ'),
+    (0x2CD9, 'V'),
+    (0x2CDA, 'M', u'ⳛ'),
+    (0x2CDB, 'V'),
+    (0x2CDC, 'M', u'ⳝ'),
+    (0x2CDD, 'V'),
+    (0x2CDE, 'M', u'ⳟ'),
+    (0x2CDF, 'V'),
+    (0x2CE0, 'M', u'ⳡ'),
+    (0x2CE1, 'V'),
+    (0x2CE2, 'M', u'ⳣ'),
+    (0x2CE3, 'V'),
+    (0x2CEB, 'M', u'ⳬ'),
+    (0x2CEC, 'V'),
+    (0x2CED, 'M', u'ⳮ'),
+    (0x2CEE, 'V'),
+    (0x2CF2, 'M', u'ⳳ'),
+    (0x2CF3, 'V'),
+    (0x2CF4, 'X'),
+    (0x2CF9, 'V'),
+    (0x2D26, 'X'),
+    (0x2D27, 'V'),
+    (0x2D28, 'X'),
+    (0x2D2D, 'V'),
+    (0x2D2E, 'X'),
+    (0x2D30, 'V'),
+    (0x2D68, 'X'),
+    (0x2D6F, 'M', u'ⵡ'),
+    (0x2D70, 'V'),
+    (0x2D71, 'X'),
+    (0x2D7F, 'V'),
+    (0x2D97, 'X'),
+    (0x2DA0, 'V'),
+    (0x2DA7, 'X'),
+    (0x2DA8, 'V'),
+    (0x2DAF, 'X'),
+    (0x2DB0, 'V'),
+    (0x2DB7, 'X'),
+    (0x2DB8, 'V'),
+    (0x2DBF, 'X'),
+    (0x2DC0, 'V'),
+    (0x2DC7, 'X'),
+    (0x2DC8, 'V'),
+    (0x2DCF, 'X'),
+    (0x2DD0, 'V'),
+    (0x2DD7, 'X'),
+    (0x2DD8, 'V'),
+    (0x2DDF, 'X'),
+    (0x2DE0, 'V'),
+    (0x2E53, 'X'),
+    (0x2E80, 'V'),
+    (0x2E9A, 'X'),
+    (0x2E9B, 'V'),
+    (0x2E9F, 'M', u'母'),
+    (0x2EA0, 'V'),
+    (0x2EF3, 'M', u'龟'),
+    (0x2EF4, 'X'),
+    (0x2F00, 'M', u'一'),
+    (0x2F01, 'M', u'丨'),
+    (0x2F02, 'M', u'丶'),
+    (0x2F03, 'M', u'丿'),
+    (0x2F04, 'M', u'乙'),
+    (0x2F05, 'M', u'亅'),
+    (0x2F06, 'M', u'二'),
+    (0x2F07, 'M', u'亠'),
+    (0x2F08, 'M', u'人'),
+    (0x2F09, 'M', u'儿'),
+    (0x2F0A, 'M', u'入'),
+    (0x2F0B, 'M', u'八'),
+    (0x2F0C, 'M', u'冂'),
+    (0x2F0D, 'M', u'冖'),
+    (0x2F0E, 'M', u'冫'),
+    (0x2F0F, 'M', u'几'),
+    (0x2F10, 'M', u'凵'),
+    (0x2F11, 'M', u'刀'),
+    ]
+
+def _seg_27():
+    return [
+    (0x2F12, 'M', u'力'),
+    (0x2F13, 'M', u'勹'),
+    (0x2F14, 'M', u'匕'),
+    (0x2F15, 'M', u'匚'),
+    (0x2F16, 'M', u'匸'),
+    (0x2F17, 'M', u'十'),
+    (0x2F18, 'M', u'卜'),
+    (0x2F19, 'M', u'卩'),
+    (0x2F1A, 'M', u'厂'),
+    (0x2F1B, 'M', u'厶'),
+    (0x2F1C, 'M', u'又'),
+    (0x2F1D, 'M', u'口'),
+    (0x2F1E, 'M', u'囗'),
+    (0x2F1F, 'M', u'土'),
+    (0x2F20, 'M', u'士'),
+    (0x2F21, 'M', u'夂'),
+    (0x2F22, 'M', u'夊'),
+    (0x2F23, 'M', u'夕'),
+    (0x2F24, 'M', u'大'),
+    (0x2F25, 'M', u'女'),
+    (0x2F26, 'M', u'子'),
+    (0x2F27, 'M', u'宀'),
+    (0x2F28, 'M', u'寸'),
+    (0x2F29, 'M', u'小'),
+    (0x2F2A, 'M', u'尢'),
+    (0x2F2B, 'M', u'尸'),
+    (0x2F2C, 'M', u'屮'),
+    (0x2F2D, 'M', u'山'),
+    (0x2F2E, 'M', u'巛'),
+    (0x2F2F, 'M', u'工'),
+    (0x2F30, 'M', u'己'),
+    (0x2F31, 'M', u'巾'),
+    (0x2F32, 'M', u'干'),
+    (0x2F33, 'M', u'幺'),
+    (0x2F34, 'M', u'广'),
+    (0x2F35, 'M', u'廴'),
+    (0x2F36, 'M', u'廾'),
+    (0x2F37, 'M', u'弋'),
+    (0x2F38, 'M', u'弓'),
+    (0x2F39, 'M', u'彐'),
+    (0x2F3A, 'M', u'彡'),
+    (0x2F3B, 'M', u'彳'),
+    (0x2F3C, 'M', u'心'),
+    (0x2F3D, 'M', u'戈'),
+    (0x2F3E, 'M', u'戶'),
+    (0x2F3F, 'M', u'手'),
+    (0x2F40, 'M', u'支'),
+    (0x2F41, 'M', u'攴'),
+    (0x2F42, 'M', u'文'),
+    (0x2F43, 'M', u'斗'),
+    (0x2F44, 'M', u'斤'),
+    (0x2F45, 'M', u'方'),
+    (0x2F46, 'M', u'无'),
+    (0x2F47, 'M', u'日'),
+    (0x2F48, 'M', u'曰'),
+    (0x2F49, 'M', u'月'),
+    (0x2F4A, 'M', u'木'),
+    (0x2F4B, 'M', u'欠'),
+    (0x2F4C, 'M', u'止'),
+    (0x2F4D, 'M', u'歹'),
+    (0x2F4E, 'M', u'殳'),
+    (0x2F4F, 'M', u'毋'),
+    (0x2F50, 'M', u'比'),
+    (0x2F51, 'M', u'毛'),
+    (0x2F52, 'M', u'氏'),
+    (0x2F53, 'M', u'气'),
+    (0x2F54, 'M', u'水'),
+    (0x2F55, 'M', u'火'),
+    (0x2F56, 'M', u'爪'),
+    (0x2F57, 'M', u'父'),
+    (0x2F58, 'M', u'爻'),
+    (0x2F59, 'M', u'爿'),
+    (0x2F5A, 'M', u'片'),
+    (0x2F5B, 'M', u'牙'),
+    (0x2F5C, 'M', u'牛'),
+    (0x2F5D, 'M', u'犬'),
+    (0x2F5E, 'M', u'玄'),
+    (0x2F5F, 'M', u'玉'),
+    (0x2F60, 'M', u'瓜'),
+    (0x2F61, 'M', u'瓦'),
+    (0x2F62, 'M', u'甘'),
+    (0x2F63, 'M', u'生'),
+    (0x2F64, 'M', u'用'),
+    (0x2F65, 'M', u'田'),
+    (0x2F66, 'M', u'疋'),
+    (0x2F67, 'M', u'疒'),
+    (0x2F68, 'M', u'癶'),
+    (0x2F69, 'M', u'白'),
+    (0x2F6A, 'M', u'皮'),
+    (0x2F6B, 'M', u'皿'),
+    (0x2F6C, 'M', u'目'),
+    (0x2F6D, 'M', u'矛'),
+    (0x2F6E, 'M', u'矢'),
+    (0x2F6F, 'M', u'石'),
+    (0x2F70, 'M', u'示'),
+    (0x2F71, 'M', u'禸'),
+    (0x2F72, 'M', u'禾'),
+    (0x2F73, 'M', u'穴'),
+    (0x2F74, 'M', u'立'),
+    (0x2F75, 'M', u'竹'),
+    ]
+
+def _seg_28():
+    return [
+    (0x2F76, 'M', u'米'),
+    (0x2F77, 'M', u'糸'),
+    (0x2F78, 'M', u'缶'),
+    (0x2F79, 'M', u'网'),
+    (0x2F7A, 'M', u'羊'),
+    (0x2F7B, 'M', u'羽'),
+    (0x2F7C, 'M', u'老'),
+    (0x2F7D, 'M', u'而'),
+    (0x2F7E, 'M', u'耒'),
+    (0x2F7F, 'M', u'耳'),
+    (0x2F80, 'M', u'聿'),
+    (0x2F81, 'M', u'肉'),
+    (0x2F82, 'M', u'臣'),
+    (0x2F83, 'M', u'自'),
+    (0x2F84, 'M', u'至'),
+    (0x2F85, 'M', u'臼'),
+    (0x2F86, 'M', u'舌'),
+    (0x2F87, 'M', u'舛'),
+    (0x2F88, 'M', u'舟'),
+    (0x2F89, 'M', u'艮'),
+    (0x2F8A, 'M', u'色'),
+    (0x2F8B, 'M', u'艸'),
+    (0x2F8C, 'M', u'虍'),
+    (0x2F8D, 'M', u'虫'),
+    (0x2F8E, 'M', u'血'),
+    (0x2F8F, 'M', u'行'),
+    (0x2F90, 'M', u'衣'),
+    (0x2F91, 'M', u'襾'),
+    (0x2F92, 'M', u'見'),
+    (0x2F93, 'M', u'角'),
+    (0x2F94, 'M', u'言'),
+    (0x2F95, 'M', u'谷'),
+    (0x2F96, 'M', u'豆'),
+    (0x2F97, 'M', u'豕'),
+    (0x2F98, 'M', u'豸'),
+    (0x2F99, 'M', u'貝'),
+    (0x2F9A, 'M', u'赤'),
+    (0x2F9B, 'M', u'走'),
+    (0x2F9C, 'M', u'足'),
+    (0x2F9D, 'M', u'身'),
+    (0x2F9E, 'M', u'車'),
+    (0x2F9F, 'M', u'辛'),
+    (0x2FA0, 'M', u'辰'),
+    (0x2FA1, 'M', u'辵'),
+    (0x2FA2, 'M', u'邑'),
+    (0x2FA3, 'M', u'酉'),
+    (0x2FA4, 'M', u'釆'),
+    (0x2FA5, 'M', u'里'),
+    (0x2FA6, 'M', u'金'),
+    (0x2FA7, 'M', u'長'),
+    (0x2FA8, 'M', u'門'),
+    (0x2FA9, 'M', u'阜'),
+    (0x2FAA, 'M', u'隶'),
+    (0x2FAB, 'M', u'隹'),
+    (0x2FAC, 'M', u'雨'),
+    (0x2FAD, 'M', u'靑'),
+    (0x2FAE, 'M', u'非'),
+    (0x2FAF, 'M', u'面'),
+    (0x2FB0, 'M', u'革'),
+    (0x2FB1, 'M', u'韋'),
+    (0x2FB2, 'M', u'韭'),
+    (0x2FB3, 'M', u'音'),
+    (0x2FB4, 'M', u'頁'),
+    (0x2FB5, 'M', u'風'),
+    (0x2FB6, 'M', u'飛'),
+    (0x2FB7, 'M', u'食'),
+    (0x2FB8, 'M', u'首'),
+    (0x2FB9, 'M', u'香'),
+    (0x2FBA, 'M', u'馬'),
+    (0x2FBB, 'M', u'骨'),
+    (0x2FBC, 'M', u'高'),
+    (0x2FBD, 'M', u'髟'),
+    (0x2FBE, 'M', u'鬥'),
+    (0x2FBF, 'M', u'鬯'),
+    (0x2FC0, 'M', u'鬲'),
+    (0x2FC1, 'M', u'鬼'),
+    (0x2FC2, 'M', u'魚'),
+    (0x2FC3, 'M', u'鳥'),
+    (0x2FC4, 'M', u'鹵'),
+    (0x2FC5, 'M', u'鹿'),
+    (0x2FC6, 'M', u'麥'),
+    (0x2FC7, 'M', u'麻'),
+    (0x2FC8, 'M', u'黃'),
+    (0x2FC9, 'M', u'黍'),
+    (0x2FCA, 'M', u'黑'),
+    (0x2FCB, 'M', u'黹'),
+    (0x2FCC, 'M', u'黽'),
+    (0x2FCD, 'M', u'鼎'),
+    (0x2FCE, 'M', u'鼓'),
+    (0x2FCF, 'M', u'鼠'),
+    (0x2FD0, 'M', u'鼻'),
+    (0x2FD1, 'M', u'齊'),
+    (0x2FD2, 'M', u'齒'),
+    (0x2FD3, 'M', u'龍'),
+    (0x2FD4, 'M', u'龜'),
+    (0x2FD5, 'M', u'龠'),
+    (0x2FD6, 'X'),
+    (0x3000, '3', u' '),
+    (0x3001, 'V'),
+    (0x3002, 'M', u'.'),
+    ]
+
+def _seg_29():
+    return [
+    (0x3003, 'V'),
+    (0x3036, 'M', u'〒'),
+    (0x3037, 'V'),
+    (0x3038, 'M', u'十'),
+    (0x3039, 'M', u'卄'),
+    (0x303A, 'M', u'卅'),
+    (0x303B, 'V'),
+    (0x3040, 'X'),
+    (0x3041, 'V'),
+    (0x3097, 'X'),
+    (0x3099, 'V'),
+    (0x309B, '3', u' ゙'),
+    (0x309C, '3', u' ゚'),
+    (0x309D, 'V'),
+    (0x309F, 'M', u'より'),
+    (0x30A0, 'V'),
+    (0x30FF, 'M', u'コト'),
+    (0x3100, 'X'),
+    (0x3105, 'V'),
+    (0x3130, 'X'),
+    (0x3131, 'M', u'ᄀ'),
+    (0x3132, 'M', u'ᄁ'),
+    (0x3133, 'M', u'ᆪ'),
+    (0x3134, 'M', u'ᄂ'),
+    (0x3135, 'M', u'ᆬ'),
+    (0x3136, 'M', u'ᆭ'),
+    (0x3137, 'M', u'ᄃ'),
+    (0x3138, 'M', u'ᄄ'),
+    (0x3139, 'M', u'ᄅ'),
+    (0x313A, 'M', u'ᆰ'),
+    (0x313B, 'M', u'ᆱ'),
+    (0x313C, 'M', u'ᆲ'),
+    (0x313D, 'M', u'ᆳ'),
+    (0x313E, 'M', u'ᆴ'),
+    (0x313F, 'M', u'ᆵ'),
+    (0x3140, 'M', u'ᄚ'),
+    (0x3141, 'M', u'ᄆ'),
+    (0x3142, 'M', u'ᄇ'),
+    (0x3143, 'M', u'ᄈ'),
+    (0x3144, 'M', u'ᄡ'),
+    (0x3145, 'M', u'ᄉ'),
+    (0x3146, 'M', u'ᄊ'),
+    (0x3147, 'M', u'ᄋ'),
+    (0x3148, 'M', u'ᄌ'),
+    (0x3149, 'M', u'ᄍ'),
+    (0x314A, 'M', u'ᄎ'),
+    (0x314B, 'M', u'ᄏ'),
+    (0x314C, 'M', u'ᄐ'),
+    (0x314D, 'M', u'ᄑ'),
+    (0x314E, 'M', u'ᄒ'),
+    (0x314F, 'M', u'ᅡ'),
+    (0x3150, 'M', u'ᅢ'),
+    (0x3151, 'M', u'ᅣ'),
+    (0x3152, 'M', u'ᅤ'),
+    (0x3153, 'M', u'ᅥ'),
+    (0x3154, 'M', u'ᅦ'),
+    (0x3155, 'M', u'ᅧ'),
+    (0x3156, 'M', u'ᅨ'),
+    (0x3157, 'M', u'ᅩ'),
+    (0x3158, 'M', u'ᅪ'),
+    (0x3159, 'M', u'ᅫ'),
+    (0x315A, 'M', u'ᅬ'),
+    (0x315B, 'M', u'ᅭ'),
+    (0x315C, 'M', u'ᅮ'),
+    (0x315D, 'M', u'ᅯ'),
+    (0x315E, 'M', u'ᅰ'),
+    (0x315F, 'M', u'ᅱ'),
+    (0x3160, 'M', u'ᅲ'),
+    (0x3161, 'M', u'ᅳ'),
+    (0x3162, 'M', u'ᅴ'),
+    (0x3163, 'M', u'ᅵ'),
+    (0x3164, 'X'),
+    (0x3165, 'M', u'ᄔ'),
+    (0x3166, 'M', u'ᄕ'),
+    (0x3167, 'M', u'ᇇ'),
+    (0x3168, 'M', u'ᇈ'),
+    (0x3169, 'M', u'ᇌ'),
+    (0x316A, 'M', u'ᇎ'),
+    (0x316B, 'M', u'ᇓ'),
+    (0x316C, 'M', u'ᇗ'),
+    (0x316D, 'M', u'ᇙ'),
+    (0x316E, 'M', u'ᄜ'),
+    (0x316F, 'M', u'ᇝ'),
+    (0x3170, 'M', u'ᇟ'),
+    (0x3171, 'M', u'ᄝ'),
+    (0x3172, 'M', u'ᄞ'),
+    (0x3173, 'M', u'ᄠ'),
+    (0x3174, 'M', u'ᄢ'),
+    (0x3175, 'M', u'ᄣ'),
+    (0x3176, 'M', u'ᄧ'),
+    (0x3177, 'M', u'ᄩ'),
+    (0x3178, 'M', u'ᄫ'),
+    (0x3179, 'M', u'ᄬ'),
+    (0x317A, 'M', u'ᄭ'),
+    (0x317B, 'M', u'ᄮ'),
+    (0x317C, 'M', u'ᄯ'),
+    (0x317D, 'M', u'ᄲ'),
+    (0x317E, 'M', u'ᄶ'),
+    (0x317F, 'M', u'ᅀ'),
+    (0x3180, 'M', u'ᅇ'),
+    ]
+
+def _seg_30():
+    return [
+    (0x3181, 'M', u'ᅌ'),
+    (0x3182, 'M', u'ᇱ'),
+    (0x3183, 'M', u'ᇲ'),
+    (0x3184, 'M', u'ᅗ'),
+    (0x3185, 'M', u'ᅘ'),
+    (0x3186, 'M', u'ᅙ'),
+    (0x3187, 'M', u'ᆄ'),
+    (0x3188, 'M', u'ᆅ'),
+    (0x3189, 'M', u'ᆈ'),
+    (0x318A, 'M', u'ᆑ'),
+    (0x318B, 'M', u'ᆒ'),
+    (0x318C, 'M', u'ᆔ'),
+    (0x318D, 'M', u'ᆞ'),
+    (0x318E, 'M', u'ᆡ'),
+    (0x318F, 'X'),
+    (0x3190, 'V'),
+    (0x3192, 'M', u'一'),
+    (0x3193, 'M', u'二'),
+    (0x3194, 'M', u'三'),
+    (0x3195, 'M', u'四'),
+    (0x3196, 'M', u'上'),
+    (0x3197, 'M', u'中'),
+    (0x3198, 'M', u'下'),
+    (0x3199, 'M', u'甲'),
+    (0x319A, 'M', u'乙'),
+    (0x319B, 'M', u'丙'),
+    (0x319C, 'M', u'丁'),
+    (0x319D, 'M', u'天'),
+    (0x319E, 'M', u'地'),
+    (0x319F, 'M', u'人'),
+    (0x31A0, 'V'),
+    (0x31E4, 'X'),
+    (0x31F0, 'V'),
+    (0x3200, '3', u'(ᄀ)'),
+    (0x3201, '3', u'(ᄂ)'),
+    (0x3202, '3', u'(ᄃ)'),
+    (0x3203, '3', u'(ᄅ)'),
+    (0x3204, '3', u'(ᄆ)'),
+    (0x3205, '3', u'(ᄇ)'),
+    (0x3206, '3', u'(ᄉ)'),
+    (0x3207, '3', u'(ᄋ)'),
+    (0x3208, '3', u'(ᄌ)'),
+    (0x3209, '3', u'(ᄎ)'),
+    (0x320A, '3', u'(ᄏ)'),
+    (0x320B, '3', u'(ᄐ)'),
+    (0x320C, '3', u'(ᄑ)'),
+    (0x320D, '3', u'(ᄒ)'),
+    (0x320E, '3', u'(가)'),
+    (0x320F, '3', u'(나)'),
+    (0x3210, '3', u'(다)'),
+    (0x3211, '3', u'(라)'),
+    (0x3212, '3', u'(마)'),
+    (0x3213, '3', u'(바)'),
+    (0x3214, '3', u'(사)'),
+    (0x3215, '3', u'(아)'),
+    (0x3216, '3', u'(자)'),
+    (0x3217, '3', u'(차)'),
+    (0x3218, '3', u'(카)'),
+    (0x3219, '3', u'(타)'),
+    (0x321A, '3', u'(파)'),
+    (0x321B, '3', u'(하)'),
+    (0x321C, '3', u'(주)'),
+    (0x321D, '3', u'(오전)'),
+    (0x321E, '3', u'(오후)'),
+    (0x321F, 'X'),
+    (0x3220, '3', u'(一)'),
+    (0x3221, '3', u'(二)'),
+    (0x3222, '3', u'(三)'),
+    (0x3223, '3', u'(四)'),
+    (0x3224, '3', u'(五)'),
+    (0x3225, '3', u'(六)'),
+    (0x3226, '3', u'(七)'),
+    (0x3227, '3', u'(八)'),
+    (0x3228, '3', u'(九)'),
+    (0x3229, '3', u'(十)'),
+    (0x322A, '3', u'(月)'),
+    (0x322B, '3', u'(火)'),
+    (0x322C, '3', u'(水)'),
+    (0x322D, '3', u'(木)'),
+    (0x322E, '3', u'(金)'),
+    (0x322F, '3', u'(土)'),
+    (0x3230, '3', u'(日)'),
+    (0x3231, '3', u'(株)'),
+    (0x3232, '3', u'(有)'),
+    (0x3233, '3', u'(社)'),
+    (0x3234, '3', u'(名)'),
+    (0x3235, '3', u'(特)'),
+    (0x3236, '3', u'(財)'),
+    (0x3237, '3', u'(祝)'),
+    (0x3238, '3', u'(労)'),
+    (0x3239, '3', u'(代)'),
+    (0x323A, '3', u'(呼)'),
+    (0x323B, '3', u'(学)'),
+    (0x323C, '3', u'(監)'),
+    (0x323D, '3', u'(企)'),
+    (0x323E, '3', u'(資)'),
+    (0x323F, '3', u'(協)'),
+    (0x3240, '3', u'(祭)'),
+    (0x3241, '3', u'(休)'),
+    (0x3242, '3', u'(自)'),
+    ]
+
+def _seg_31():
+    return [
+    (0x3243, '3', u'(至)'),
+    (0x3244, 'M', u'問'),
+    (0x3245, 'M', u'幼'),
+    (0x3246, 'M', u'文'),
+    (0x3247, 'M', u'箏'),
+    (0x3248, 'V'),
+    (0x3250, 'M', u'pte'),
+    (0x3251, 'M', u'21'),
+    (0x3252, 'M', u'22'),
+    (0x3253, 'M', u'23'),
+    (0x3254, 'M', u'24'),
+    (0x3255, 'M', u'25'),
+    (0x3256, 'M', u'26'),
+    (0x3257, 'M', u'27'),
+    (0x3258, 'M', u'28'),
+    (0x3259, 'M', u'29'),
+    (0x325A, 'M', u'30'),
+    (0x325B, 'M', u'31'),
+    (0x325C, 'M', u'32'),
+    (0x325D, 'M', u'33'),
+    (0x325E, 'M', u'34'),
+    (0x325F, 'M', u'35'),
+    (0x3260, 'M', u'ᄀ'),
+    (0x3261, 'M', u'ᄂ'),
+    (0x3262, 'M', u'ᄃ'),
+    (0x3263, 'M', u'ᄅ'),
+    (0x3264, 'M', u'ᄆ'),
+    (0x3265, 'M', u'ᄇ'),
+    (0x3266, 'M', u'ᄉ'),
+    (0x3267, 'M', u'ᄋ'),
+    (0x3268, 'M', u'ᄌ'),
+    (0x3269, 'M', u'ᄎ'),
+    (0x326A, 'M', u'ᄏ'),
+    (0x326B, 'M', u'ᄐ'),
+    (0x326C, 'M', u'ᄑ'),
+    (0x326D, 'M', u'ᄒ'),
+    (0x326E, 'M', u'가'),
+    (0x326F, 'M', u'나'),
+    (0x3270, 'M', u'다'),
+    (0x3271, 'M', u'라'),
+    (0x3272, 'M', u'마'),
+    (0x3273, 'M', u'바'),
+    (0x3274, 'M', u'사'),
+    (0x3275, 'M', u'아'),
+    (0x3276, 'M', u'자'),
+    (0x3277, 'M', u'차'),
+    (0x3278, 'M', u'카'),
+    (0x3279, 'M', u'타'),
+    (0x327A, 'M', u'파'),
+    (0x327B, 'M', u'하'),
+    (0x327C, 'M', u'참고'),
+    (0x327D, 'M', u'주의'),
+    (0x327E, 'M', u'우'),
+    (0x327F, 'V'),
+    (0x3280, 'M', u'一'),
+    (0x3281, 'M', u'二'),
+    (0x3282, 'M', u'三'),
+    (0x3283, 'M', u'四'),
+    (0x3284, 'M', u'五'),
+    (0x3285, 'M', u'六'),
+    (0x3286, 'M', u'七'),
+    (0x3287, 'M', u'八'),
+    (0x3288, 'M', u'九'),
+    (0x3289, 'M', u'十'),
+    (0x328A, 'M', u'月'),
+    (0x328B, 'M', u'火'),
+    (0x328C, 'M', u'水'),
+    (0x328D, 'M', u'木'),
+    (0x328E, 'M', u'金'),
+    (0x328F, 'M', u'土'),
+    (0x3290, 'M', u'日'),
+    (0x3291, 'M', u'株'),
+    (0x3292, 'M', u'有'),
+    (0x3293, 'M', u'社'),
+    (0x3294, 'M', u'名'),
+    (0x3295, 'M', u'特'),
+    (0x3296, 'M', u'財'),
+    (0x3297, 'M', u'祝'),
+    (0x3298, 'M', u'労'),
+    (0x3299, 'M', u'秘'),
+    (0x329A, 'M', u'男'),
+    (0x329B, 'M', u'女'),
+    (0x329C, 'M', u'適'),
+    (0x329D, 'M', u'優'),
+    (0x329E, 'M', u'印'),
+    (0x329F, 'M', u'注'),
+    (0x32A0, 'M', u'項'),
+    (0x32A1, 'M', u'休'),
+    (0x32A2, 'M', u'写'),
+    (0x32A3, 'M', u'正'),
+    (0x32A4, 'M', u'上'),
+    (0x32A5, 'M', u'中'),
+    (0x32A6, 'M', u'下'),
+    (0x32A7, 'M', u'左'),
+    (0x32A8, 'M', u'右'),
+    (0x32A9, 'M', u'医'),
+    (0x32AA, 'M', u'宗'),
+    (0x32AB, 'M', u'学'),
+    (0x32AC, 'M', u'監'),
+    (0x32AD, 'M', u'企'),
+    ]
+
+def _seg_32():
+    return [
+    (0x32AE, 'M', u'資'),
+    (0x32AF, 'M', u'協'),
+    (0x32B0, 'M', u'夜'),
+    (0x32B1, 'M', u'36'),
+    (0x32B2, 'M', u'37'),
+    (0x32B3, 'M', u'38'),
+    (0x32B4, 'M', u'39'),
+    (0x32B5, 'M', u'40'),
+    (0x32B6, 'M', u'41'),
+    (0x32B7, 'M', u'42'),
+    (0x32B8, 'M', u'43'),
+    (0x32B9, 'M', u'44'),
+    (0x32BA, 'M', u'45'),
+    (0x32BB, 'M', u'46'),
+    (0x32BC, 'M', u'47'),
+    (0x32BD, 'M', u'48'),
+    (0x32BE, 'M', u'49'),
+    (0x32BF, 'M', u'50'),
+    (0x32C0, 'M', u'1月'),
+    (0x32C1, 'M', u'2月'),
+    (0x32C2, 'M', u'3月'),
+    (0x32C3, 'M', u'4月'),
+    (0x32C4, 'M', u'5月'),
+    (0x32C5, 'M', u'6月'),
+    (0x32C6, 'M', u'7月'),
+    (0x32C7, 'M', u'8月'),
+    (0x32C8, 'M', u'9月'),
+    (0x32C9, 'M', u'10月'),
+    (0x32CA, 'M', u'11月'),
+    (0x32CB, 'M', u'12月'),
+    (0x32CC, 'M', u'hg'),
+    (0x32CD, 'M', u'erg'),
+    (0x32CE, 'M', u'ev'),
+    (0x32CF, 'M', u'ltd'),
+    (0x32D0, 'M', u'ア'),
+    (0x32D1, 'M', u'イ'),
+    (0x32D2, 'M', u'ウ'),
+    (0x32D3, 'M', u'エ'),
+    (0x32D4, 'M', u'オ'),
+    (0x32D5, 'M', u'カ'),
+    (0x32D6, 'M', u'キ'),
+    (0x32D7, 'M', u'ク'),
+    (0x32D8, 'M', u'ケ'),
+    (0x32D9, 'M', u'コ'),
+    (0x32DA, 'M', u'サ'),
+    (0x32DB, 'M', u'シ'),
+    (0x32DC, 'M', u'ス'),
+    (0x32DD, 'M', u'セ'),
+    (0x32DE, 'M', u'ソ'),
+    (0x32DF, 'M', u'タ'),
+    (0x32E0, 'M', u'チ'),
+    (0x32E1, 'M', u'ツ'),
+    (0x32E2, 'M', u'テ'),
+    (0x32E3, 'M', u'ト'),
+    (0x32E4, 'M', u'ナ'),
+    (0x32E5, 'M', u'ニ'),
+    (0x32E6, 'M', u'ヌ'),
+    (0x32E7, 'M', u'ネ'),
+    (0x32E8, 'M', u'ノ'),
+    (0x32E9, 'M', u'ハ'),
+    (0x32EA, 'M', u'ヒ'),
+    (0x32EB, 'M', u'フ'),
+    (0x32EC, 'M', u'ヘ'),
+    (0x32ED, 'M', u'ホ'),
+    (0x32EE, 'M', u'マ'),
+    (0x32EF, 'M', u'ミ'),
+    (0x32F0, 'M', u'ム'),
+    (0x32F1, 'M', u'メ'),
+    (0x32F2, 'M', u'モ'),
+    (0x32F3, 'M', u'ヤ'),
+    (0x32F4, 'M', u'ユ'),
+    (0x32F5, 'M', u'ヨ'),
+    (0x32F6, 'M', u'ラ'),
+    (0x32F7, 'M', u'リ'),
+    (0x32F8, 'M', u'ル'),
+    (0x32F9, 'M', u'レ'),
+    (0x32FA, 'M', u'ロ'),
+    (0x32FB, 'M', u'ワ'),
+    (0x32FC, 'M', u'ヰ'),
+    (0x32FD, 'M', u'ヱ'),
+    (0x32FE, 'M', u'ヲ'),
+    (0x32FF, 'M', u'令和'),
+    (0x3300, 'M', u'アパート'),
+    (0x3301, 'M', u'アルファ'),
+    (0x3302, 'M', u'アンペア'),
+    (0x3303, 'M', u'アール'),
+    (0x3304, 'M', u'イニング'),
+    (0x3305, 'M', u'インチ'),
+    (0x3306, 'M', u'ウォン'),
+    (0x3307, 'M', u'エスクード'),
+    (0x3308, 'M', u'エーカー'),
+    (0x3309, 'M', u'オンス'),
+    (0x330A, 'M', u'オーム'),
+    (0x330B, 'M', u'カイリ'),
+    (0x330C, 'M', u'カラット'),
+    (0x330D, 'M', u'カロリー'),
+    (0x330E, 'M', u'ガロン'),
+    (0x330F, 'M', u'ガンマ'),
+    (0x3310, 'M', u'ギガ'),
+    (0x3311, 'M', u'ギニー'),
+    ]
+
+def _seg_33():
+    return [
+    (0x3312, 'M', u'キュリー'),
+    (0x3313, 'M', u'ギルダー'),
+    (0x3314, 'M', u'キロ'),
+    (0x3315, 'M', u'キログラム'),
+    (0x3316, 'M', u'キロメートル'),
+    (0x3317, 'M', u'キロワット'),
+    (0x3318, 'M', u'グラム'),
+    (0x3319, 'M', u'グラムトン'),
+    (0x331A, 'M', u'クルゼイロ'),
+    (0x331B, 'M', u'クローネ'),
+    (0x331C, 'M', u'ケース'),
+    (0x331D, 'M', u'コルナ'),
+    (0x331E, 'M', u'コーポ'),
+    (0x331F, 'M', u'サイクル'),
+    (0x3320, 'M', u'サンチーム'),
+    (0x3321, 'M', u'シリング'),
+    (0x3322, 'M', u'センチ'),
+    (0x3323, 'M', u'セント'),
+    (0x3324, 'M', u'ダース'),
+    (0x3325, 'M', u'デシ'),
+    (0x3326, 'M', u'ドル'),
+    (0x3327, 'M', u'トン'),
+    (0x3328, 'M', u'ナノ'),
+    (0x3329, 'M', u'ノット'),
+    (0x332A, 'M', u'ハイツ'),
+    (0x332B, 'M', u'パーセント'),
+    (0x332C, 'M', u'パーツ'),
+    (0x332D, 'M', u'バーレル'),
+    (0x332E, 'M', u'ピアストル'),
+    (0x332F, 'M', u'ピクル'),
+    (0x3330, 'M', u'ピコ'),
+    (0x3331, 'M', u'ビル'),
+    (0x3332, 'M', u'ファラッド'),
+    (0x3333, 'M', u'フィート'),
+    (0x3334, 'M', u'ブッシェル'),
+    (0x3335, 'M', u'フラン'),
+    (0x3336, 'M', u'ヘクタール'),
+    (0x3337, 'M', u'ペソ'),
+    (0x3338, 'M', u'ペニヒ'),
+    (0x3339, 'M', u'ヘルツ'),
+    (0x333A, 'M', u'ペンス'),
+    (0x333B, 'M', u'ページ'),
+    (0x333C, 'M', u'ベータ'),
+    (0x333D, 'M', u'ポイント'),
+    (0x333E, 'M', u'ボルト'),
+    (0x333F, 'M', u'ホン'),
+    (0x3340, 'M', u'ポンド'),
+    (0x3341, 'M', u'ホール'),
+    (0x3342, 'M', u'ホーン'),
+    (0x3343, 'M', u'マイクロ'),
+    (0x3344, 'M', u'マイル'),
+    (0x3345, 'M', u'マッハ'),
+    (0x3346, 'M', u'マルク'),
+    (0x3347, 'M', u'マンション'),
+    (0x3348, 'M', u'ミクロン'),
+    (0x3349, 'M', u'ミリ'),
+    (0x334A, 'M', u'ミリバール'),
+    (0x334B, 'M', u'メガ'),
+    (0x334C, 'M', u'メガトン'),
+    (0x334D, 'M', u'メートル'),
+    (0x334E, 'M', u'ヤード'),
+    (0x334F, 'M', u'ヤール'),
+    (0x3350, 'M', u'ユアン'),
+    (0x3351, 'M', u'リットル'),
+    (0x3352, 'M', u'リラ'),
+    (0x3353, 'M', u'ルピー'),
+    (0x3354, 'M', u'ルーブル'),
+    (0x3355, 'M', u'レム'),
+    (0x3356, 'M', u'レントゲン'),
+    (0x3357, 'M', u'ワット'),
+    (0x3358, 'M', u'0点'),
+    (0x3359, 'M', u'1点'),
+    (0x335A, 'M', u'2点'),
+    (0x335B, 'M', u'3点'),
+    (0x335C, 'M', u'4点'),
+    (0x335D, 'M', u'5点'),
+    (0x335E, 'M', u'6点'),
+    (0x335F, 'M', u'7点'),
+    (0x3360, 'M', u'8点'),
+    (0x3361, 'M', u'9点'),
+    (0x3362, 'M', u'10点'),
+    (0x3363, 'M', u'11点'),
+    (0x3364, 'M', u'12点'),
+    (0x3365, 'M', u'13点'),
+    (0x3366, 'M', u'14点'),
+    (0x3367, 'M', u'15点'),
+    (0x3368, 'M', u'16点'),
+    (0x3369, 'M', u'17点'),
+    (0x336A, 'M', u'18点'),
+    (0x336B, 'M', u'19点'),
+    (0x336C, 'M', u'20点'),
+    (0x336D, 'M', u'21点'),
+    (0x336E, 'M', u'22点'),
+    (0x336F, 'M', u'23点'),
+    (0x3370, 'M', u'24点'),
+    (0x3371, 'M', u'hpa'),
+    (0x3372, 'M', u'da'),
+    (0x3373, 'M', u'au'),
+    (0x3374, 'M', u'bar'),
+    (0x3375, 'M', u'ov'),
+    ]
+
+def _seg_34():
+    return [
+    (0x3376, 'M', u'pc'),
+    (0x3377, 'M', u'dm'),
+    (0x3378, 'M', u'dm2'),
+    (0x3379, 'M', u'dm3'),
+    (0x337A, 'M', u'iu'),
+    (0x337B, 'M', u'平成'),
+    (0x337C, 'M', u'昭和'),
+    (0x337D, 'M', u'大正'),
+    (0x337E, 'M', u'明治'),
+    (0x337F, 'M', u'株式会社'),
+    (0x3380, 'M', u'pa'),
+    (0x3381, 'M', u'na'),
+    (0x3382, 'M', u'μa'),
+    (0x3383, 'M', u'ma'),
+    (0x3384, 'M', u'ka'),
+    (0x3385, 'M', u'kb'),
+    (0x3386, 'M', u'mb'),
+    (0x3387, 'M', u'gb'),
+    (0x3388, 'M', u'cal'),
+    (0x3389, 'M', u'kcal'),
+    (0x338A, 'M', u'pf'),
+    (0x338B, 'M', u'nf'),
+    (0x338C, 'M', u'μf'),
+    (0x338D, 'M', u'μg'),
+    (0x338E, 'M', u'mg'),
+    (0x338F, 'M', u'kg'),
+    (0x3390, 'M', u'hz'),
+    (0x3391, 'M', u'khz'),
+    (0x3392, 'M', u'mhz'),
+    (0x3393, 'M', u'ghz'),
+    (0x3394, 'M', u'thz'),
+    (0x3395, 'M', u'μl'),
+    (0x3396, 'M', u'ml'),
+    (0x3397, 'M', u'dl'),
+    (0x3398, 'M', u'kl'),
+    (0x3399, 'M', u'fm'),
+    (0x339A, 'M', u'nm'),
+    (0x339B, 'M', u'μm'),
+    (0x339C, 'M', u'mm'),
+    (0x339D, 'M', u'cm'),
+    (0x339E, 'M', u'km'),
+    (0x339F, 'M', u'mm2'),
+    (0x33A0, 'M', u'cm2'),
+    (0x33A1, 'M', u'm2'),
+    (0x33A2, 'M', u'km2'),
+    (0x33A3, 'M', u'mm3'),
+    (0x33A4, 'M', u'cm3'),
+    (0x33A5, 'M', u'm3'),
+    (0x33A6, 'M', u'km3'),
+    (0x33A7, 'M', u'm∕s'),
+    (0x33A8, 'M', u'm∕s2'),
+    (0x33A9, 'M', u'pa'),
+    (0x33AA, 'M', u'kpa'),
+    (0x33AB, 'M', u'mpa'),
+    (0x33AC, 'M', u'gpa'),
+    (0x33AD, 'M', u'rad'),
+    (0x33AE, 'M', u'rad∕s'),
+    (0x33AF, 'M', u'rad∕s2'),
+    (0x33B0, 'M', u'ps'),
+    (0x33B1, 'M', u'ns'),
+    (0x33B2, 'M', u'μs'),
+    (0x33B3, 'M', u'ms'),
+    (0x33B4, 'M', u'pv'),
+    (0x33B5, 'M', u'nv'),
+    (0x33B6, 'M', u'μv'),
+    (0x33B7, 'M', u'mv'),
+    (0x33B8, 'M', u'kv'),
+    (0x33B9, 'M', u'mv'),
+    (0x33BA, 'M', u'pw'),
+    (0x33BB, 'M', u'nw'),
+    (0x33BC, 'M', u'μw'),
+    (0x33BD, 'M', u'mw'),
+    (0x33BE, 'M', u'kw'),
+    (0x33BF, 'M', u'mw'),
+    (0x33C0, 'M', u'kω'),
+    (0x33C1, 'M', u'mω'),
+    (0x33C2, 'X'),
+    (0x33C3, 'M', u'bq'),
+    (0x33C4, 'M', u'cc'),
+    (0x33C5, 'M', u'cd'),
+    (0x33C6, 'M', u'c∕kg'),
+    (0x33C7, 'X'),
+    (0x33C8, 'M', u'db'),
+    (0x33C9, 'M', u'gy'),
+    (0x33CA, 'M', u'ha'),
+    (0x33CB, 'M', u'hp'),
+    (0x33CC, 'M', u'in'),
+    (0x33CD, 'M', u'kk'),
+    (0x33CE, 'M', u'km'),
+    (0x33CF, 'M', u'kt'),
+    (0x33D0, 'M', u'lm'),
+    (0x33D1, 'M', u'ln'),
+    (0x33D2, 'M', u'log'),
+    (0x33D3, 'M', u'lx'),
+    (0x33D4, 'M', u'mb'),
+    (0x33D5, 'M', u'mil'),
+    (0x33D6, 'M', u'mol'),
+    (0x33D7, 'M', u'ph'),
+    (0x33D8, 'X'),
+    (0x33D9, 'M', u'ppm'),
+    ]
+
+def _seg_35():
+    return [
+    (0x33DA, 'M', u'pr'),
+    (0x33DB, 'M', u'sr'),
+    (0x33DC, 'M', u'sv'),
+    (0x33DD, 'M', u'wb'),
+    (0x33DE, 'M', u'v∕m'),
+    (0x33DF, 'M', u'a∕m'),
+    (0x33E0, 'M', u'1日'),
+    (0x33E1, 'M', u'2日'),
+    (0x33E2, 'M', u'3日'),
+    (0x33E3, 'M', u'4日'),
+    (0x33E4, 'M', u'5日'),
+    (0x33E5, 'M', u'6日'),
+    (0x33E6, 'M', u'7日'),
+    (0x33E7, 'M', u'8日'),
+    (0x33E8, 'M', u'9日'),
+    (0x33E9, 'M', u'10日'),
+    (0x33EA, 'M', u'11日'),
+    (0x33EB, 'M', u'12日'),
+    (0x33EC, 'M', u'13日'),
+    (0x33ED, 'M', u'14日'),
+    (0x33EE, 'M', u'15日'),
+    (0x33EF, 'M', u'16日'),
+    (0x33F0, 'M', u'17日'),
+    (0x33F1, 'M', u'18日'),
+    (0x33F2, 'M', u'19日'),
+    (0x33F3, 'M', u'20日'),
+    (0x33F4, 'M', u'21日'),
+    (0x33F5, 'M', u'22日'),
+    (0x33F6, 'M', u'23日'),
+    (0x33F7, 'M', u'24日'),
+    (0x33F8, 'M', u'25日'),
+    (0x33F9, 'M', u'26日'),
+    (0x33FA, 'M', u'27日'),
+    (0x33FB, 'M', u'28日'),
+    (0x33FC, 'M', u'29日'),
+    (0x33FD, 'M', u'30日'),
+    (0x33FE, 'M', u'31日'),
+    (0x33FF, 'M', u'gal'),
+    (0x3400, 'V'),
+    (0x9FFD, 'X'),
+    (0xA000, 'V'),
+    (0xA48D, 'X'),
+    (0xA490, 'V'),
+    (0xA4C7, 'X'),
+    (0xA4D0, 'V'),
+    (0xA62C, 'X'),
+    (0xA640, 'M', u'ꙁ'),
+    (0xA641, 'V'),
+    (0xA642, 'M', u'ꙃ'),
+    (0xA643, 'V'),
+    (0xA644, 'M', u'ꙅ'),
+    (0xA645, 'V'),
+    (0xA646, 'M', u'ꙇ'),
+    (0xA647, 'V'),
+    (0xA648, 'M', u'ꙉ'),
+    (0xA649, 'V'),
+    (0xA64A, 'M', u'ꙋ'),
+    (0xA64B, 'V'),
+    (0xA64C, 'M', u'ꙍ'),
+    (0xA64D, 'V'),
+    (0xA64E, 'M', u'ꙏ'),
+    (0xA64F, 'V'),
+    (0xA650, 'M', u'ꙑ'),
+    (0xA651, 'V'),
+    (0xA652, 'M', u'ꙓ'),
+    (0xA653, 'V'),
+    (0xA654, 'M', u'ꙕ'),
+    (0xA655, 'V'),
+    (0xA656, 'M', u'ꙗ'),
+    (0xA657, 'V'),
+    (0xA658, 'M', u'ꙙ'),
+    (0xA659, 'V'),
+    (0xA65A, 'M', u'ꙛ'),
+    (0xA65B, 'V'),
+    (0xA65C, 'M', u'ꙝ'),
+    (0xA65D, 'V'),
+    (0xA65E, 'M', u'ꙟ'),
+    (0xA65F, 'V'),
+    (0xA660, 'M', u'ꙡ'),
+    (0xA661, 'V'),
+    (0xA662, 'M', u'ꙣ'),
+    (0xA663, 'V'),
+    (0xA664, 'M', u'ꙥ'),
+    (0xA665, 'V'),
+    (0xA666, 'M', u'ꙧ'),
+    (0xA667, 'V'),
+    (0xA668, 'M', u'ꙩ'),
+    (0xA669, 'V'),
+    (0xA66A, 'M', u'ꙫ'),
+    (0xA66B, 'V'),
+    (0xA66C, 'M', u'ꙭ'),
+    (0xA66D, 'V'),
+    (0xA680, 'M', u'ꚁ'),
+    (0xA681, 'V'),
+    (0xA682, 'M', u'ꚃ'),
+    (0xA683, 'V'),
+    (0xA684, 'M', u'ꚅ'),
+    (0xA685, 'V'),
+    (0xA686, 'M', u'ꚇ'),
+    (0xA687, 'V'),
+    ]
+
+def _seg_36():
+    return [
+    (0xA688, 'M', u'ꚉ'),
+    (0xA689, 'V'),
+    (0xA68A, 'M', u'ꚋ'),
+    (0xA68B, 'V'),
+    (0xA68C, 'M', u'ꚍ'),
+    (0xA68D, 'V'),
+    (0xA68E, 'M', u'ꚏ'),
+    (0xA68F, 'V'),
+    (0xA690, 'M', u'ꚑ'),
+    (0xA691, 'V'),
+    (0xA692, 'M', u'ꚓ'),
+    (0xA693, 'V'),
+    (0xA694, 'M', u'ꚕ'),
+    (0xA695, 'V'),
+    (0xA696, 'M', u'ꚗ'),
+    (0xA697, 'V'),
+    (0xA698, 'M', u'ꚙ'),
+    (0xA699, 'V'),
+    (0xA69A, 'M', u'ꚛ'),
+    (0xA69B, 'V'),
+    (0xA69C, 'M', u'ъ'),
+    (0xA69D, 'M', u'ь'),
+    (0xA69E, 'V'),
+    (0xA6F8, 'X'),
+    (0xA700, 'V'),
+    (0xA722, 'M', u'ꜣ'),
+    (0xA723, 'V'),
+    (0xA724, 'M', u'ꜥ'),
+    (0xA725, 'V'),
+    (0xA726, 'M', u'ꜧ'),
+    (0xA727, 'V'),
+    (0xA728, 'M', u'ꜩ'),
+    (0xA729, 'V'),
+    (0xA72A, 'M', u'ꜫ'),
+    (0xA72B, 'V'),
+    (0xA72C, 'M', u'ꜭ'),
+    (0xA72D, 'V'),
+    (0xA72E, 'M', u'ꜯ'),
+    (0xA72F, 'V'),
+    (0xA732, 'M', u'ꜳ'),
+    (0xA733, 'V'),
+    (0xA734, 'M', u'ꜵ'),
+    (0xA735, 'V'),
+    (0xA736, 'M', u'ꜷ'),
+    (0xA737, 'V'),
+    (0xA738, 'M', u'ꜹ'),
+    (0xA739, 'V'),
+    (0xA73A, 'M', u'ꜻ'),
+    (0xA73B, 'V'),
+    (0xA73C, 'M', u'ꜽ'),
+    (0xA73D, 'V'),
+    (0xA73E, 'M', u'ꜿ'),
+    (0xA73F, 'V'),
+    (0xA740, 'M', u'ꝁ'),
+    (0xA741, 'V'),
+    (0xA742, 'M', u'ꝃ'),
+    (0xA743, 'V'),
+    (0xA744, 'M', u'ꝅ'),
+    (0xA745, 'V'),
+    (0xA746, 'M', u'ꝇ'),
+    (0xA747, 'V'),
+    (0xA748, 'M', u'ꝉ'),
+    (0xA749, 'V'),
+    (0xA74A, 'M', u'ꝋ'),
+    (0xA74B, 'V'),
+    (0xA74C, 'M', u'ꝍ'),
+    (0xA74D, 'V'),
+    (0xA74E, 'M', u'ꝏ'),
+    (0xA74F, 'V'),
+    (0xA750, 'M', u'ꝑ'),
+    (0xA751, 'V'),
+    (0xA752, 'M', u'ꝓ'),
+    (0xA753, 'V'),
+    (0xA754, 'M', u'ꝕ'),
+    (0xA755, 'V'),
+    (0xA756, 'M', u'ꝗ'),
+    (0xA757, 'V'),
+    (0xA758, 'M', u'ꝙ'),
+    (0xA759, 'V'),
+    (0xA75A, 'M', u'ꝛ'),
+    (0xA75B, 'V'),
+    (0xA75C, 'M', u'ꝝ'),
+    (0xA75D, 'V'),
+    (0xA75E, 'M', u'ꝟ'),
+    (0xA75F, 'V'),
+    (0xA760, 'M', u'ꝡ'),
+    (0xA761, 'V'),
+    (0xA762, 'M', u'ꝣ'),
+    (0xA763, 'V'),
+    (0xA764, 'M', u'ꝥ'),
+    (0xA765, 'V'),
+    (0xA766, 'M', u'ꝧ'),
+    (0xA767, 'V'),
+    (0xA768, 'M', u'ꝩ'),
+    (0xA769, 'V'),
+    (0xA76A, 'M', u'ꝫ'),
+    (0xA76B, 'V'),
+    (0xA76C, 'M', u'ꝭ'),
+    (0xA76D, 'V'),
+    (0xA76E, 'M', u'ꝯ'),
+    ]
+
+def _seg_37():
+    return [
+    (0xA76F, 'V'),
+    (0xA770, 'M', u'ꝯ'),
+    (0xA771, 'V'),
+    (0xA779, 'M', u'ꝺ'),
+    (0xA77A, 'V'),
+    (0xA77B, 'M', u'ꝼ'),
+    (0xA77C, 'V'),
+    (0xA77D, 'M', u'ᵹ'),
+    (0xA77E, 'M', u'ꝿ'),
+    (0xA77F, 'V'),
+    (0xA780, 'M', u'ꞁ'),
+    (0xA781, 'V'),
+    (0xA782, 'M', u'ꞃ'),
+    (0xA783, 'V'),
+    (0xA784, 'M', u'ꞅ'),
+    (0xA785, 'V'),
+    (0xA786, 'M', u'ꞇ'),
+    (0xA787, 'V'),
+    (0xA78B, 'M', u'ꞌ'),
+    (0xA78C, 'V'),
+    (0xA78D, 'M', u'ɥ'),
+    (0xA78E, 'V'),
+    (0xA790, 'M', u'ꞑ'),
+    (0xA791, 'V'),
+    (0xA792, 'M', u'ꞓ'),
+    (0xA793, 'V'),
+    (0xA796, 'M', u'ꞗ'),
+    (0xA797, 'V'),
+    (0xA798, 'M', u'ꞙ'),
+    (0xA799, 'V'),
+    (0xA79A, 'M', u'ꞛ'),
+    (0xA79B, 'V'),
+    (0xA79C, 'M', u'ꞝ'),
+    (0xA79D, 'V'),
+    (0xA79E, 'M', u'ꞟ'),
+    (0xA79F, 'V'),
+    (0xA7A0, 'M', u'ꞡ'),
+    (0xA7A1, 'V'),
+    (0xA7A2, 'M', u'ꞣ'),
+    (0xA7A3, 'V'),
+    (0xA7A4, 'M', u'ꞥ'),
+    (0xA7A5, 'V'),
+    (0xA7A6, 'M', u'ꞧ'),
+    (0xA7A7, 'V'),
+    (0xA7A8, 'M', u'ꞩ'),
+    (0xA7A9, 'V'),
+    (0xA7AA, 'M', u'ɦ'),
+    (0xA7AB, 'M', u'ɜ'),
+    (0xA7AC, 'M', u'ɡ'),
+    (0xA7AD, 'M', u'ɬ'),
+    (0xA7AE, 'M', u'ɪ'),
+    (0xA7AF, 'V'),
+    (0xA7B0, 'M', u'ʞ'),
+    (0xA7B1, 'M', u'ʇ'),
+    (0xA7B2, 'M', u'ʝ'),
+    (0xA7B3, 'M', u'ꭓ'),
+    (0xA7B4, 'M', u'ꞵ'),
+    (0xA7B5, 'V'),
+    (0xA7B6, 'M', u'ꞷ'),
+    (0xA7B7, 'V'),
+    (0xA7B8, 'M', u'ꞹ'),
+    (0xA7B9, 'V'),
+    (0xA7BA, 'M', u'ꞻ'),
+    (0xA7BB, 'V'),
+    (0xA7BC, 'M', u'ꞽ'),
+    (0xA7BD, 'V'),
+    (0xA7BE, 'M', u'ꞿ'),
+    (0xA7BF, 'V'),
+    (0xA7C0, 'X'),
+    (0xA7C2, 'M', u'ꟃ'),
+    (0xA7C3, 'V'),
+    (0xA7C4, 'M', u'ꞔ'),
+    (0xA7C5, 'M', u'ʂ'),
+    (0xA7C6, 'M', u'ᶎ'),
+    (0xA7C7, 'M', u'ꟈ'),
+    (0xA7C8, 'V'),
+    (0xA7C9, 'M', u'ꟊ'),
+    (0xA7CA, 'V'),
+    (0xA7CB, 'X'),
+    (0xA7F5, 'M', u'ꟶ'),
+    (0xA7F6, 'V'),
+    (0xA7F8, 'M', u'ħ'),
+    (0xA7F9, 'M', u'œ'),
+    (0xA7FA, 'V'),
+    (0xA82D, 'X'),
+    (0xA830, 'V'),
+    (0xA83A, 'X'),
+    (0xA840, 'V'),
+    (0xA878, 'X'),
+    (0xA880, 'V'),
+    (0xA8C6, 'X'),
+    (0xA8CE, 'V'),
+    (0xA8DA, 'X'),
+    (0xA8E0, 'V'),
+    (0xA954, 'X'),
+    (0xA95F, 'V'),
+    (0xA97D, 'X'),
+    (0xA980, 'V'),
+    (0xA9CE, 'X'),
+    (0xA9CF, 'V'),
+    ]
+
+def _seg_38():
+    return [
+    (0xA9DA, 'X'),
+    (0xA9DE, 'V'),
+    (0xA9FF, 'X'),
+    (0xAA00, 'V'),
+    (0xAA37, 'X'),
+    (0xAA40, 'V'),
+    (0xAA4E, 'X'),
+    (0xAA50, 'V'),
+    (0xAA5A, 'X'),
+    (0xAA5C, 'V'),
+    (0xAAC3, 'X'),
+    (0xAADB, 'V'),
+    (0xAAF7, 'X'),
+    (0xAB01, 'V'),
+    (0xAB07, 'X'),
+    (0xAB09, 'V'),
+    (0xAB0F, 'X'),
+    (0xAB11, 'V'),
+    (0xAB17, 'X'),
+    (0xAB20, 'V'),
+    (0xAB27, 'X'),
+    (0xAB28, 'V'),
+    (0xAB2F, 'X'),
+    (0xAB30, 'V'),
+    (0xAB5C, 'M', u'ꜧ'),
+    (0xAB5D, 'M', u'ꬷ'),
+    (0xAB5E, 'M', u'ɫ'),
+    (0xAB5F, 'M', u'ꭒ'),
+    (0xAB60, 'V'),
+    (0xAB69, 'M', u'ʍ'),
+    (0xAB6A, 'V'),
+    (0xAB6C, 'X'),
+    (0xAB70, 'M', u'Ꭰ'),
+    (0xAB71, 'M', u'Ꭱ'),
+    (0xAB72, 'M', u'Ꭲ'),
+    (0xAB73, 'M', u'Ꭳ'),
+    (0xAB74, 'M', u'Ꭴ'),
+    (0xAB75, 'M', u'Ꭵ'),
+    (0xAB76, 'M', u'Ꭶ'),
+    (0xAB77, 'M', u'Ꭷ'),
+    (0xAB78, 'M', u'Ꭸ'),
+    (0xAB79, 'M', u'Ꭹ'),
+    (0xAB7A, 'M', u'Ꭺ'),
+    (0xAB7B, 'M', u'Ꭻ'),
+    (0xAB7C, 'M', u'Ꭼ'),
+    (0xAB7D, 'M', u'Ꭽ'),
+    (0xAB7E, 'M', u'Ꭾ'),
+    (0xAB7F, 'M', u'Ꭿ'),
+    (0xAB80, 'M', u'Ꮀ'),
+    (0xAB81, 'M', u'Ꮁ'),
+    (0xAB82, 'M', u'Ꮂ'),
+    (0xAB83, 'M', u'Ꮃ'),
+    (0xAB84, 'M', u'Ꮄ'),
+    (0xAB85, 'M', u'Ꮅ'),
+    (0xAB86, 'M', u'Ꮆ'),
+    (0xAB87, 'M', u'Ꮇ'),
+    (0xAB88, 'M', u'Ꮈ'),
+    (0xAB89, 'M', u'Ꮉ'),
+    (0xAB8A, 'M', u'Ꮊ'),
+    (0xAB8B, 'M', u'Ꮋ'),
+    (0xAB8C, 'M', u'Ꮌ'),
+    (0xAB8D, 'M', u'Ꮍ'),
+    (0xAB8E, 'M', u'Ꮎ'),
+    (0xAB8F, 'M', u'Ꮏ'),
+    (0xAB90, 'M', u'Ꮐ'),
+    (0xAB91, 'M', u'Ꮑ'),
+    (0xAB92, 'M', u'Ꮒ'),
+    (0xAB93, 'M', u'Ꮓ'),
+    (0xAB94, 'M', u'Ꮔ'),
+    (0xAB95, 'M', u'Ꮕ'),
+    (0xAB96, 'M', u'Ꮖ'),
+    (0xAB97, 'M', u'Ꮗ'),
+    (0xAB98, 'M', u'Ꮘ'),
+    (0xAB99, 'M', u'Ꮙ'),
+    (0xAB9A, 'M', u'Ꮚ'),
+    (0xAB9B, 'M', u'Ꮛ'),
+    (0xAB9C, 'M', u'Ꮜ'),
+    (0xAB9D, 'M', u'Ꮝ'),
+    (0xAB9E, 'M', u'Ꮞ'),
+    (0xAB9F, 'M', u'Ꮟ'),
+    (0xABA0, 'M', u'Ꮠ'),
+    (0xABA1, 'M', u'Ꮡ'),
+    (0xABA2, 'M', u'Ꮢ'),
+    (0xABA3, 'M', u'Ꮣ'),
+    (0xABA4, 'M', u'Ꮤ'),
+    (0xABA5, 'M', u'Ꮥ'),
+    (0xABA6, 'M', u'Ꮦ'),
+    (0xABA7, 'M', u'Ꮧ'),
+    (0xABA8, 'M', u'Ꮨ'),
+    (0xABA9, 'M', u'Ꮩ'),
+    (0xABAA, 'M', u'Ꮪ'),
+    (0xABAB, 'M', u'Ꮫ'),
+    (0xABAC, 'M', u'Ꮬ'),
+    (0xABAD, 'M', u'Ꮭ'),
+    (0xABAE, 'M', u'Ꮮ'),
+    (0xABAF, 'M', u'Ꮯ'),
+    (0xABB0, 'M', u'Ꮰ'),
+    (0xABB1, 'M', u'Ꮱ'),
+    (0xABB2, 'M', u'Ꮲ'),
+    (0xABB3, 'M', u'Ꮳ'),
+    ]
+
+def _seg_39():
+    return [
+    (0xABB4, 'M', u'Ꮴ'),
+    (0xABB5, 'M', u'Ꮵ'),
+    (0xABB6, 'M', u'Ꮶ'),
+    (0xABB7, 'M', u'Ꮷ'),
+    (0xABB8, 'M', u'Ꮸ'),
+    (0xABB9, 'M', u'Ꮹ'),
+    (0xABBA, 'M', u'Ꮺ'),
+    (0xABBB, 'M', u'Ꮻ'),
+    (0xABBC, 'M', u'Ꮼ'),
+    (0xABBD, 'M', u'Ꮽ'),
+    (0xABBE, 'M', u'Ꮾ'),
+    (0xABBF, 'M', u'Ꮿ'),
+    (0xABC0, 'V'),
+    (0xABEE, 'X'),
+    (0xABF0, 'V'),
+    (0xABFA, 'X'),
+    (0xAC00, 'V'),
+    (0xD7A4, 'X'),
+    (0xD7B0, 'V'),
+    (0xD7C7, 'X'),
+    (0xD7CB, 'V'),
+    (0xD7FC, 'X'),
+    (0xF900, 'M', u'豈'),
+    (0xF901, 'M', u'更'),
+    (0xF902, 'M', u'車'),
+    (0xF903, 'M', u'賈'),
+    (0xF904, 'M', u'滑'),
+    (0xF905, 'M', u'串'),
+    (0xF906, 'M', u'句'),
+    (0xF907, 'M', u'龜'),
+    (0xF909, 'M', u'契'),
+    (0xF90A, 'M', u'金'),
+    (0xF90B, 'M', u'喇'),
+    (0xF90C, 'M', u'奈'),
+    (0xF90D, 'M', u'懶'),
+    (0xF90E, 'M', u'癩'),
+    (0xF90F, 'M', u'羅'),
+    (0xF910, 'M', u'蘿'),
+    (0xF911, 'M', u'螺'),
+    (0xF912, 'M', u'裸'),
+    (0xF913, 'M', u'邏'),
+    (0xF914, 'M', u'樂'),
+    (0xF915, 'M', u'洛'),
+    (0xF916, 'M', u'烙'),
+    (0xF917, 'M', u'珞'),
+    (0xF918, 'M', u'落'),
+    (0xF919, 'M', u'酪'),
+    (0xF91A, 'M', u'駱'),
+    (0xF91B, 'M', u'亂'),
+    (0xF91C, 'M', u'卵'),
+    (0xF91D, 'M', u'欄'),
+    (0xF91E, 'M', u'爛'),
+    (0xF91F, 'M', u'蘭'),
+    (0xF920, 'M', u'鸞'),
+    (0xF921, 'M', u'嵐'),
+    (0xF922, 'M', u'濫'),
+    (0xF923, 'M', u'藍'),
+    (0xF924, 'M', u'襤'),
+    (0xF925, 'M', u'拉'),
+    (0xF926, 'M', u'臘'),
+    (0xF927, 'M', u'蠟'),
+    (0xF928, 'M', u'廊'),
+    (0xF929, 'M', u'朗'),
+    (0xF92A, 'M', u'浪'),
+    (0xF92B, 'M', u'狼'),
+    (0xF92C, 'M', u'郎'),
+    (0xF92D, 'M', u'來'),
+    (0xF92E, 'M', u'冷'),
+    (0xF92F, 'M', u'勞'),
+    (0xF930, 'M', u'擄'),
+    (0xF931, 'M', u'櫓'),
+    (0xF932, 'M', u'爐'),
+    (0xF933, 'M', u'盧'),
+    (0xF934, 'M', u'老'),
+    (0xF935, 'M', u'蘆'),
+    (0xF936, 'M', u'虜'),
+    (0xF937, 'M', u'路'),
+    (0xF938, 'M', u'露'),
+    (0xF939, 'M', u'魯'),
+    (0xF93A, 'M', u'鷺'),
+    (0xF93B, 'M', u'碌'),
+    (0xF93C, 'M', u'祿'),
+    (0xF93D, 'M', u'綠'),
+    (0xF93E, 'M', u'菉'),
+    (0xF93F, 'M', u'錄'),
+    (0xF940, 'M', u'鹿'),
+    (0xF941, 'M', u'論'),
+    (0xF942, 'M', u'壟'),
+    (0xF943, 'M', u'弄'),
+    (0xF944, 'M', u'籠'),
+    (0xF945, 'M', u'聾'),
+    (0xF946, 'M', u'牢'),
+    (0xF947, 'M', u'磊'),
+    (0xF948, 'M', u'賂'),
+    (0xF949, 'M', u'雷'),
+    (0xF94A, 'M', u'壘'),
+    (0xF94B, 'M', u'屢'),
+    (0xF94C, 'M', u'樓'),
+    (0xF94D, 'M', u'淚'),
+    (0xF94E, 'M', u'漏'),
+    ]
+
+def _seg_40():
+    return [
+    (0xF94F, 'M', u'累'),
+    (0xF950, 'M', u'縷'),
+    (0xF951, 'M', u'陋'),
+    (0xF952, 'M', u'勒'),
+    (0xF953, 'M', u'肋'),
+    (0xF954, 'M', u'凜'),
+    (0xF955, 'M', u'凌'),
+    (0xF956, 'M', u'稜'),
+    (0xF957, 'M', u'綾'),
+    (0xF958, 'M', u'菱'),
+    (0xF959, 'M', u'陵'),
+    (0xF95A, 'M', u'讀'),
+    (0xF95B, 'M', u'拏'),
+    (0xF95C, 'M', u'樂'),
+    (0xF95D, 'M', u'諾'),
+    (0xF95E, 'M', u'丹'),
+    (0xF95F, 'M', u'寧'),
+    (0xF960, 'M', u'怒'),
+    (0xF961, 'M', u'率'),
+    (0xF962, 'M', u'異'),
+    (0xF963, 'M', u'北'),
+    (0xF964, 'M', u'磻'),
+    (0xF965, 'M', u'便'),
+    (0xF966, 'M', u'復'),
+    (0xF967, 'M', u'不'),
+    (0xF968, 'M', u'泌'),
+    (0xF969, 'M', u'數'),
+    (0xF96A, 'M', u'索'),
+    (0xF96B, 'M', u'參'),
+    (0xF96C, 'M', u'塞'),
+    (0xF96D, 'M', u'省'),
+    (0xF96E, 'M', u'葉'),
+    (0xF96F, 'M', u'說'),
+    (0xF970, 'M', u'殺'),
+    (0xF971, 'M', u'辰'),
+    (0xF972, 'M', u'沈'),
+    (0xF973, 'M', u'拾'),
+    (0xF974, 'M', u'若'),
+    (0xF975, 'M', u'掠'),
+    (0xF976, 'M', u'略'),
+    (0xF977, 'M', u'亮'),
+    (0xF978, 'M', u'兩'),
+    (0xF979, 'M', u'凉'),
+    (0xF97A, 'M', u'梁'),
+    (0xF97B, 'M', u'糧'),
+    (0xF97C, 'M', u'良'),
+    (0xF97D, 'M', u'諒'),
+    (0xF97E, 'M', u'量'),
+    (0xF97F, 'M', u'勵'),
+    (0xF980, 'M', u'呂'),
+    (0xF981, 'M', u'女'),
+    (0xF982, 'M', u'廬'),
+    (0xF983, 'M', u'旅'),
+    (0xF984, 'M', u'濾'),
+    (0xF985, 'M', u'礪'),
+    (0xF986, 'M', u'閭'),
+    (0xF987, 'M', u'驪'),
+    (0xF988, 'M', u'麗'),
+    (0xF989, 'M', u'黎'),
+    (0xF98A, 'M', u'力'),
+    (0xF98B, 'M', u'曆'),
+    (0xF98C, 'M', u'歷'),
+    (0xF98D, 'M', u'轢'),
+    (0xF98E, 'M', u'年'),
+    (0xF98F, 'M', u'憐'),
+    (0xF990, 'M', u'戀'),
+    (0xF991, 'M', u'撚'),
+    (0xF992, 'M', u'漣'),
+    (0xF993, 'M', u'煉'),
+    (0xF994, 'M', u'璉'),
+    (0xF995, 'M', u'秊'),
+    (0xF996, 'M', u'練'),
+    (0xF997, 'M', u'聯'),
+    (0xF998, 'M', u'輦'),
+    (0xF999, 'M', u'蓮'),
+    (0xF99A, 'M', u'連'),
+    (0xF99B, 'M', u'鍊'),
+    (0xF99C, 'M', u'列'),
+    (0xF99D, 'M', u'劣'),
+    (0xF99E, 'M', u'咽'),
+    (0xF99F, 'M', u'烈'),
+    (0xF9A0, 'M', u'裂'),
+    (0xF9A1, 'M', u'說'),
+    (0xF9A2, 'M', u'廉'),
+    (0xF9A3, 'M', u'念'),
+    (0xF9A4, 'M', u'捻'),
+    (0xF9A5, 'M', u'殮'),
+    (0xF9A6, 'M', u'簾'),
+    (0xF9A7, 'M', u'獵'),
+    (0xF9A8, 'M', u'令'),
+    (0xF9A9, 'M', u'囹'),
+    (0xF9AA, 'M', u'寧'),
+    (0xF9AB, 'M', u'嶺'),
+    (0xF9AC, 'M', u'怜'),
+    (0xF9AD, 'M', u'玲'),
+    (0xF9AE, 'M', u'瑩'),
+    (0xF9AF, 'M', u'羚'),
+    (0xF9B0, 'M', u'聆'),
+    (0xF9B1, 'M', u'鈴'),
+    (0xF9B2, 'M', u'零'),
+    ]
+
+def _seg_41():
+    return [
+    (0xF9B3, 'M', u'靈'),
+    (0xF9B4, 'M', u'領'),
+    (0xF9B5, 'M', u'例'),
+    (0xF9B6, 'M', u'禮'),
+    (0xF9B7, 'M', u'醴'),
+    (0xF9B8, 'M', u'隸'),
+    (0xF9B9, 'M', u'惡'),
+    (0xF9BA, 'M', u'了'),
+    (0xF9BB, 'M', u'僚'),
+    (0xF9BC, 'M', u'寮'),
+    (0xF9BD, 'M', u'尿'),
+    (0xF9BE, 'M', u'料'),
+    (0xF9BF, 'M', u'樂'),
+    (0xF9C0, 'M', u'燎'),
+    (0xF9C1, 'M', u'療'),
+    (0xF9C2, 'M', u'蓼'),
+    (0xF9C3, 'M', u'遼'),
+    (0xF9C4, 'M', u'龍'),
+    (0xF9C5, 'M', u'暈'),
+    (0xF9C6, 'M', u'阮'),
+    (0xF9C7, 'M', u'劉'),
+    (0xF9C8, 'M', u'杻'),
+    (0xF9C9, 'M', u'柳'),
+    (0xF9CA, 'M', u'流'),
+    (0xF9CB, 'M', u'溜'),
+    (0xF9CC, 'M', u'琉'),
+    (0xF9CD, 'M', u'留'),
+    (0xF9CE, 'M', u'硫'),
+    (0xF9CF, 'M', u'紐'),
+    (0xF9D0, 'M', u'類'),
+    (0xF9D1, 'M', u'六'),
+    (0xF9D2, 'M', u'戮'),
+    (0xF9D3, 'M', u'陸'),
+    (0xF9D4, 'M', u'倫'),
+    (0xF9D5, 'M', u'崙'),
+    (0xF9D6, 'M', u'淪'),
+    (0xF9D7, 'M', u'輪'),
+    (0xF9D8, 'M', u'律'),
+    (0xF9D9, 'M', u'慄'),
+    (0xF9DA, 'M', u'栗'),
+    (0xF9DB, 'M', u'率'),
+    (0xF9DC, 'M', u'隆'),
+    (0xF9DD, 'M', u'利'),
+    (0xF9DE, 'M', u'吏'),
+    (0xF9DF, 'M', u'履'),
+    (0xF9E0, 'M', u'易'),
+    (0xF9E1, 'M', u'李'),
+    (0xF9E2, 'M', u'梨'),
+    (0xF9E3, 'M', u'泥'),
+    (0xF9E4, 'M', u'理'),
+    (0xF9E5, 'M', u'痢'),
+    (0xF9E6, 'M', u'罹'),
+    (0xF9E7, 'M', u'裏'),
+    (0xF9E8, 'M', u'裡'),
+    (0xF9E9, 'M', u'里'),
+    (0xF9EA, 'M', u'離'),
+    (0xF9EB, 'M', u'匿'),
+    (0xF9EC, 'M', u'溺'),
+    (0xF9ED, 'M', u'吝'),
+    (0xF9EE, 'M', u'燐'),
+    (0xF9EF, 'M', u'璘'),
+    (0xF9F0, 'M', u'藺'),
+    (0xF9F1, 'M', u'隣'),
+    (0xF9F2, 'M', u'鱗'),
+    (0xF9F3, 'M', u'麟'),
+    (0xF9F4, 'M', u'林'),
+    (0xF9F5, 'M', u'淋'),
+    (0xF9F6, 'M', u'臨'),
+    (0xF9F7, 'M', u'立'),
+    (0xF9F8, 'M', u'笠'),
+    (0xF9F9, 'M', u'粒'),
+    (0xF9FA, 'M', u'狀'),
+    (0xF9FB, 'M', u'炙'),
+    (0xF9FC, 'M', u'識'),
+    (0xF9FD, 'M', u'什'),
+    (0xF9FE, 'M', u'茶'),
+    (0xF9FF, 'M', u'刺'),
+    (0xFA00, 'M', u'切'),
+    (0xFA01, 'M', u'度'),
+    (0xFA02, 'M', u'拓'),
+    (0xFA03, 'M', u'糖'),
+    (0xFA04, 'M', u'宅'),
+    (0xFA05, 'M', u'洞'),
+    (0xFA06, 'M', u'暴'),
+    (0xFA07, 'M', u'輻'),
+    (0xFA08, 'M', u'行'),
+    (0xFA09, 'M', u'降'),
+    (0xFA0A, 'M', u'見'),
+    (0xFA0B, 'M', u'廓'),
+    (0xFA0C, 'M', u'兀'),
+    (0xFA0D, 'M', u'嗀'),
+    (0xFA0E, 'V'),
+    (0xFA10, 'M', u'塚'),
+    (0xFA11, 'V'),
+    (0xFA12, 'M', u'晴'),
+    (0xFA13, 'V'),
+    (0xFA15, 'M', u'凞'),
+    (0xFA16, 'M', u'猪'),
+    (0xFA17, 'M', u'益'),
+    (0xFA18, 'M', u'礼'),
+    ]
+
+def _seg_42():
+    return [
+    (0xFA19, 'M', u'神'),
+    (0xFA1A, 'M', u'祥'),
+    (0xFA1B, 'M', u'福'),
+    (0xFA1C, 'M', u'靖'),
+    (0xFA1D, 'M', u'精'),
+    (0xFA1E, 'M', u'羽'),
+    (0xFA1F, 'V'),
+    (0xFA20, 'M', u'蘒'),
+    (0xFA21, 'V'),
+    (0xFA22, 'M', u'諸'),
+    (0xFA23, 'V'),
+    (0xFA25, 'M', u'逸'),
+    (0xFA26, 'M', u'都'),
+    (0xFA27, 'V'),
+    (0xFA2A, 'M', u'飯'),
+    (0xFA2B, 'M', u'飼'),
+    (0xFA2C, 'M', u'館'),
+    (0xFA2D, 'M', u'鶴'),
+    (0xFA2E, 'M', u'郞'),
+    (0xFA2F, 'M', u'隷'),
+    (0xFA30, 'M', u'侮'),
+    (0xFA31, 'M', u'僧'),
+    (0xFA32, 'M', u'免'),
+    (0xFA33, 'M', u'勉'),
+    (0xFA34, 'M', u'勤'),
+    (0xFA35, 'M', u'卑'),
+    (0xFA36, 'M', u'喝'),
+    (0xFA37, 'M', u'嘆'),
+    (0xFA38, 'M', u'器'),
+    (0xFA39, 'M', u'塀'),
+    (0xFA3A, 'M', u'墨'),
+    (0xFA3B, 'M', u'層'),
+    (0xFA3C, 'M', u'屮'),
+    (0xFA3D, 'M', u'悔'),
+    (0xFA3E, 'M', u'慨'),
+    (0xFA3F, 'M', u'憎'),
+    (0xFA40, 'M', u'懲'),
+    (0xFA41, 'M', u'敏'),
+    (0xFA42, 'M', u'既'),
+    (0xFA43, 'M', u'暑'),
+    (0xFA44, 'M', u'梅'),
+    (0xFA45, 'M', u'海'),
+    (0xFA46, 'M', u'渚'),
+    (0xFA47, 'M', u'漢'),
+    (0xFA48, 'M', u'煮'),
+    (0xFA49, 'M', u'爫'),
+    (0xFA4A, 'M', u'琢'),
+    (0xFA4B, 'M', u'碑'),
+    (0xFA4C, 'M', u'社'),
+    (0xFA4D, 'M', u'祉'),
+    (0xFA4E, 'M', u'祈'),
+    (0xFA4F, 'M', u'祐'),
+    (0xFA50, 'M', u'祖'),
+    (0xFA51, 'M', u'祝'),
+    (0xFA52, 'M', u'禍'),
+    (0xFA53, 'M', u'禎'),
+    (0xFA54, 'M', u'穀'),
+    (0xFA55, 'M', u'突'),
+    (0xFA56, 'M', u'節'),
+    (0xFA57, 'M', u'練'),
+    (0xFA58, 'M', u'縉'),
+    (0xFA59, 'M', u'繁'),
+    (0xFA5A, 'M', u'署'),
+    (0xFA5B, 'M', u'者'),
+    (0xFA5C, 'M', u'臭'),
+    (0xFA5D, 'M', u'艹'),
+    (0xFA5F, 'M', u'著'),
+    (0xFA60, 'M', u'褐'),
+    (0xFA61, 'M', u'視'),
+    (0xFA62, 'M', u'謁'),
+    (0xFA63, 'M', u'謹'),
+    (0xFA64, 'M', u'賓'),
+    (0xFA65, 'M', u'贈'),
+    (0xFA66, 'M', u'辶'),
+    (0xFA67, 'M', u'逸'),
+    (0xFA68, 'M', u'難'),
+    (0xFA69, 'M', u'響'),
+    (0xFA6A, 'M', u'頻'),
+    (0xFA6B, 'M', u'恵'),
+    (0xFA6C, 'M', u'𤋮'),
+    (0xFA6D, 'M', u'舘'),
+    (0xFA6E, 'X'),
+    (0xFA70, 'M', u'並'),
+    (0xFA71, 'M', u'况'),
+    (0xFA72, 'M', u'全'),
+    (0xFA73, 'M', u'侀'),
+    (0xFA74, 'M', u'充'),
+    (0xFA75, 'M', u'冀'),
+    (0xFA76, 'M', u'勇'),
+    (0xFA77, 'M', u'勺'),
+    (0xFA78, 'M', u'喝'),
+    (0xFA79, 'M', u'啕'),
+    (0xFA7A, 'M', u'喙'),
+    (0xFA7B, 'M', u'嗢'),
+    (0xFA7C, 'M', u'塚'),
+    (0xFA7D, 'M', u'墳'),
+    (0xFA7E, 'M', u'奄'),
+    (0xFA7F, 'M', u'奔'),
+    (0xFA80, 'M', u'婢'),
+    (0xFA81, 'M', u'嬨'),
+    ]
+
+def _seg_43():
+    return [
+    (0xFA82, 'M', u'廒'),
+    (0xFA83, 'M', u'廙'),
+    (0xFA84, 'M', u'彩'),
+    (0xFA85, 'M', u'徭'),
+    (0xFA86, 'M', u'惘'),
+    (0xFA87, 'M', u'慎'),
+    (0xFA88, 'M', u'愈'),
+    (0xFA89, 'M', u'憎'),
+    (0xFA8A, 'M', u'慠'),
+    (0xFA8B, 'M', u'懲'),
+    (0xFA8C, 'M', u'戴'),
+    (0xFA8D, 'M', u'揄'),
+    (0xFA8E, 'M', u'搜'),
+    (0xFA8F, 'M', u'摒'),
+    (0xFA90, 'M', u'敖'),
+    (0xFA91, 'M', u'晴'),
+    (0xFA92, 'M', u'朗'),
+    (0xFA93, 'M', u'望'),
+    (0xFA94, 'M', u'杖'),
+    (0xFA95, 'M', u'歹'),
+    (0xFA96, 'M', u'殺'),
+    (0xFA97, 'M', u'流'),
+    (0xFA98, 'M', u'滛'),
+    (0xFA99, 'M', u'滋'),
+    (0xFA9A, 'M', u'漢'),
+    (0xFA9B, 'M', u'瀞'),
+    (0xFA9C, 'M', u'煮'),
+    (0xFA9D, 'M', u'瞧'),
+    (0xFA9E, 'M', u'爵'),
+    (0xFA9F, 'M', u'犯'),
+    (0xFAA0, 'M', u'猪'),
+    (0xFAA1, 'M', u'瑱'),
+    (0xFAA2, 'M', u'甆'),
+    (0xFAA3, 'M', u'画'),
+    (0xFAA4, 'M', u'瘝'),
+    (0xFAA5, 'M', u'瘟'),
+    (0xFAA6, 'M', u'益'),
+    (0xFAA7, 'M', u'盛'),
+    (0xFAA8, 'M', u'直'),
+    (0xFAA9, 'M', u'睊'),
+    (0xFAAA, 'M', u'着'),
+    (0xFAAB, 'M', u'磌'),
+    (0xFAAC, 'M', u'窱'),
+    (0xFAAD, 'M', u'節'),
+    (0xFAAE, 'M', u'类'),
+    (0xFAAF, 'M', u'絛'),
+    (0xFAB0, 'M', u'練'),
+    (0xFAB1, 'M', u'缾'),
+    (0xFAB2, 'M', u'者'),
+    (0xFAB3, 'M', u'荒'),
+    (0xFAB4, 'M', u'華'),
+    (0xFAB5, 'M', u'蝹'),
+    (0xFAB6, 'M', u'襁'),
+    (0xFAB7, 'M', u'覆'),
+    (0xFAB8, 'M', u'視'),
+    (0xFAB9, 'M', u'調'),
+    (0xFABA, 'M', u'諸'),
+    (0xFABB, 'M', u'請'),
+    (0xFABC, 'M', u'謁'),
+    (0xFABD, 'M', u'諾'),
+    (0xFABE, 'M', u'諭'),
+    (0xFABF, 'M', u'謹'),
+    (0xFAC0, 'M', u'變'),
+    (0xFAC1, 'M', u'贈'),
+    (0xFAC2, 'M', u'輸'),
+    (0xFAC3, 'M', u'遲'),
+    (0xFAC4, 'M', u'醙'),
+    (0xFAC5, 'M', u'鉶'),
+    (0xFAC6, 'M', u'陼'),
+    (0xFAC7, 'M', u'難'),
+    (0xFAC8, 'M', u'靖'),
+    (0xFAC9, 'M', u'韛'),
+    (0xFACA, 'M', u'響'),
+    (0xFACB, 'M', u'頋'),
+    (0xFACC, 'M', u'頻'),
+    (0xFACD, 'M', u'鬒'),
+    (0xFACE, 'M', u'龜'),
+    (0xFACF, 'M', u'𢡊'),
+    (0xFAD0, 'M', u'𢡄'),
+    (0xFAD1, 'M', u'𣏕'),
+    (0xFAD2, 'M', u'㮝'),
+    (0xFAD3, 'M', u'䀘'),
+    (0xFAD4, 'M', u'䀹'),
+    (0xFAD5, 'M', u'𥉉'),
+    (0xFAD6, 'M', u'𥳐'),
+    (0xFAD7, 'M', u'𧻓'),
+    (0xFAD8, 'M', u'齃'),
+    (0xFAD9, 'M', u'龎'),
+    (0xFADA, 'X'),
+    (0xFB00, 'M', u'ff'),
+    (0xFB01, 'M', u'fi'),
+    (0xFB02, 'M', u'fl'),
+    (0xFB03, 'M', u'ffi'),
+    (0xFB04, 'M', u'ffl'),
+    (0xFB05, 'M', u'st'),
+    (0xFB07, 'X'),
+    (0xFB13, 'M', u'մն'),
+    (0xFB14, 'M', u'մե'),
+    (0xFB15, 'M', u'մի'),
+    (0xFB16, 'M', u'վն'),
+    ]
+
+def _seg_44():
+    return [
+    (0xFB17, 'M', u'մխ'),
+    (0xFB18, 'X'),
+    (0xFB1D, 'M', u'יִ'),
+    (0xFB1E, 'V'),
+    (0xFB1F, 'M', u'ײַ'),
+    (0xFB20, 'M', u'ע'),
+    (0xFB21, 'M', u'א'),
+    (0xFB22, 'M', u'ד'),
+    (0xFB23, 'M', u'ה'),
+    (0xFB24, 'M', u'כ'),
+    (0xFB25, 'M', u'ל'),
+    (0xFB26, 'M', u'ם'),
+    (0xFB27, 'M', u'ר'),
+    (0xFB28, 'M', u'ת'),
+    (0xFB29, '3', u'+'),
+    (0xFB2A, 'M', u'שׁ'),
+    (0xFB2B, 'M', u'שׂ'),
+    (0xFB2C, 'M', u'שּׁ'),
+    (0xFB2D, 'M', u'שּׂ'),
+    (0xFB2E, 'M', u'אַ'),
+    (0xFB2F, 'M', u'אָ'),
+    (0xFB30, 'M', u'אּ'),
+    (0xFB31, 'M', u'בּ'),
+    (0xFB32, 'M', u'גּ'),
+    (0xFB33, 'M', u'דּ'),
+    (0xFB34, 'M', u'הּ'),
+    (0xFB35, 'M', u'וּ'),
+    (0xFB36, 'M', u'זּ'),
+    (0xFB37, 'X'),
+    (0xFB38, 'M', u'טּ'),
+    (0xFB39, 'M', u'יּ'),
+    (0xFB3A, 'M', u'ךּ'),
+    (0xFB3B, 'M', u'כּ'),
+    (0xFB3C, 'M', u'לּ'),
+    (0xFB3D, 'X'),
+    (0xFB3E, 'M', u'מּ'),
+    (0xFB3F, 'X'),
+    (0xFB40, 'M', u'נּ'),
+    (0xFB41, 'M', u'סּ'),
+    (0xFB42, 'X'),
+    (0xFB43, 'M', u'ףּ'),
+    (0xFB44, 'M', u'פּ'),
+    (0xFB45, 'X'),
+    (0xFB46, 'M', u'צּ'),
+    (0xFB47, 'M', u'קּ'),
+    (0xFB48, 'M', u'רּ'),
+    (0xFB49, 'M', u'שּ'),
+    (0xFB4A, 'M', u'תּ'),
+    (0xFB4B, 'M', u'וֹ'),
+    (0xFB4C, 'M', u'בֿ'),
+    (0xFB4D, 'M', u'כֿ'),
+    (0xFB4E, 'M', u'פֿ'),
+    (0xFB4F, 'M', u'אל'),
+    (0xFB50, 'M', u'ٱ'),
+    (0xFB52, 'M', u'ٻ'),
+    (0xFB56, 'M', u'پ'),
+    (0xFB5A, 'M', u'ڀ'),
+    (0xFB5E, 'M', u'ٺ'),
+    (0xFB62, 'M', u'ٿ'),
+    (0xFB66, 'M', u'ٹ'),
+    (0xFB6A, 'M', u'ڤ'),
+    (0xFB6E, 'M', u'ڦ'),
+    (0xFB72, 'M', u'ڄ'),
+    (0xFB76, 'M', u'ڃ'),
+    (0xFB7A, 'M', u'چ'),
+    (0xFB7E, 'M', u'ڇ'),
+    (0xFB82, 'M', u'ڍ'),
+    (0xFB84, 'M', u'ڌ'),
+    (0xFB86, 'M', u'ڎ'),
+    (0xFB88, 'M', u'ڈ'),
+    (0xFB8A, 'M', u'ژ'),
+    (0xFB8C, 'M', u'ڑ'),
+    (0xFB8E, 'M', u'ک'),
+    (0xFB92, 'M', u'گ'),
+    (0xFB96, 'M', u'ڳ'),
+    (0xFB9A, 'M', u'ڱ'),
+    (0xFB9E, 'M', u'ں'),
+    (0xFBA0, 'M', u'ڻ'),
+    (0xFBA4, 'M', u'ۀ'),
+    (0xFBA6, 'M', u'ہ'),
+    (0xFBAA, 'M', u'ھ'),
+    (0xFBAE, 'M', u'ے'),
+    (0xFBB0, 'M', u'ۓ'),
+    (0xFBB2, 'V'),
+    (0xFBC2, 'X'),
+    (0xFBD3, 'M', u'ڭ'),
+    (0xFBD7, 'M', u'ۇ'),
+    (0xFBD9, 'M', u'ۆ'),
+    (0xFBDB, 'M', u'ۈ'),
+    (0xFBDD, 'M', u'ۇٴ'),
+    (0xFBDE, 'M', u'ۋ'),
+    (0xFBE0, 'M', u'ۅ'),
+    (0xFBE2, 'M', u'ۉ'),
+    (0xFBE4, 'M', u'ې'),
+    (0xFBE8, 'M', u'ى'),
+    (0xFBEA, 'M', u'ئا'),
+    (0xFBEC, 'M', u'ئە'),
+    (0xFBEE, 'M', u'ئو'),
+    (0xFBF0, 'M', u'ئۇ'),
+    (0xFBF2, 'M', u'ئۆ'),
+    ]
+
+def _seg_45():
+    return [
+    (0xFBF4, 'M', u'ئۈ'),
+    (0xFBF6, 'M', u'ئې'),
+    (0xFBF9, 'M', u'ئى'),
+    (0xFBFC, 'M', u'ی'),
+    (0xFC00, 'M', u'ئج'),
+    (0xFC01, 'M', u'ئح'),
+    (0xFC02, 'M', u'ئم'),
+    (0xFC03, 'M', u'ئى'),
+    (0xFC04, 'M', u'ئي'),
+    (0xFC05, 'M', u'بج'),
+    (0xFC06, 'M', u'بح'),
+    (0xFC07, 'M', u'بخ'),
+    (0xFC08, 'M', u'بم'),
+    (0xFC09, 'M', u'بى'),
+    (0xFC0A, 'M', u'بي'),
+    (0xFC0B, 'M', u'تج'),
+    (0xFC0C, 'M', u'تح'),
+    (0xFC0D, 'M', u'تخ'),
+    (0xFC0E, 'M', u'تم'),
+    (0xFC0F, 'M', u'تى'),
+    (0xFC10, 'M', u'تي'),
+    (0xFC11, 'M', u'ثج'),
+    (0xFC12, 'M', u'ثم'),
+    (0xFC13, 'M', u'ثى'),
+    (0xFC14, 'M', u'ثي'),
+    (0xFC15, 'M', u'جح'),
+    (0xFC16, 'M', u'جم'),
+    (0xFC17, 'M', u'حج'),
+    (0xFC18, 'M', u'حم'),
+    (0xFC19, 'M', u'خج'),
+    (0xFC1A, 'M', u'خح'),
+    (0xFC1B, 'M', u'خم'),
+    (0xFC1C, 'M', u'سج'),
+    (0xFC1D, 'M', u'سح'),
+    (0xFC1E, 'M', u'سخ'),
+    (0xFC1F, 'M', u'سم'),
+    (0xFC20, 'M', u'صح'),
+    (0xFC21, 'M', u'صم'),
+    (0xFC22, 'M', u'ضج'),
+    (0xFC23, 'M', u'ضح'),
+    (0xFC24, 'M', u'ضخ'),
+    (0xFC25, 'M', u'ضم'),
+    (0xFC26, 'M', u'طح'),
+    (0xFC27, 'M', u'طم'),
+    (0xFC28, 'M', u'ظم'),
+    (0xFC29, 'M', u'عج'),
+    (0xFC2A, 'M', u'عم'),
+    (0xFC2B, 'M', u'غج'),
+    (0xFC2C, 'M', u'غم'),
+    (0xFC2D, 'M', u'فج'),
+    (0xFC2E, 'M', u'فح'),
+    (0xFC2F, 'M', u'فخ'),
+    (0xFC30, 'M', u'فم'),
+    (0xFC31, 'M', u'فى'),
+    (0xFC32, 'M', u'في'),
+    (0xFC33, 'M', u'قح'),
+    (0xFC34, 'M', u'قم'),
+    (0xFC35, 'M', u'قى'),
+    (0xFC36, 'M', u'قي'),
+    (0xFC37, 'M', u'كا'),
+    (0xFC38, 'M', u'كج'),
+    (0xFC39, 'M', u'كح'),
+    (0xFC3A, 'M', u'كخ'),
+    (0xFC3B, 'M', u'كل'),
+    (0xFC3C, 'M', u'كم'),
+    (0xFC3D, 'M', u'كى'),
+    (0xFC3E, 'M', u'كي'),
+    (0xFC3F, 'M', u'لج'),
+    (0xFC40, 'M', u'لح'),
+    (0xFC41, 'M', u'لخ'),
+    (0xFC42, 'M', u'لم'),
+    (0xFC43, 'M', u'لى'),
+    (0xFC44, 'M', u'لي'),
+    (0xFC45, 'M', u'مج'),
+    (0xFC46, 'M', u'مح'),
+    (0xFC47, 'M', u'مخ'),
+    (0xFC48, 'M', u'مم'),
+    (0xFC49, 'M', u'مى'),
+    (0xFC4A, 'M', u'مي'),
+    (0xFC4B, 'M', u'نج'),
+    (0xFC4C, 'M', u'نح'),
+    (0xFC4D, 'M', u'نخ'),
+    (0xFC4E, 'M', u'نم'),
+    (0xFC4F, 'M', u'نى'),
+    (0xFC50, 'M', u'ني'),
+    (0xFC51, 'M', u'هج'),
+    (0xFC52, 'M', u'هم'),
+    (0xFC53, 'M', u'هى'),
+    (0xFC54, 'M', u'هي'),
+    (0xFC55, 'M', u'يج'),
+    (0xFC56, 'M', u'يح'),
+    (0xFC57, 'M', u'يخ'),
+    (0xFC58, 'M', u'يم'),
+    (0xFC59, 'M', u'يى'),
+    (0xFC5A, 'M', u'يي'),
+    (0xFC5B, 'M', u'ذٰ'),
+    (0xFC5C, 'M', u'رٰ'),
+    (0xFC5D, 'M', u'ىٰ'),
+    (0xFC5E, '3', u' ٌّ'),
+    (0xFC5F, '3', u' ٍّ'),
+    ]
+
+def _seg_46():
+    return [
+    (0xFC60, '3', u' َّ'),
+    (0xFC61, '3', u' ُّ'),
+    (0xFC62, '3', u' ِّ'),
+    (0xFC63, '3', u' ّٰ'),
+    (0xFC64, 'M', u'ئر'),
+    (0xFC65, 'M', u'ئز'),
+    (0xFC66, 'M', u'ئم'),
+    (0xFC67, 'M', u'ئن'),
+    (0xFC68, 'M', u'ئى'),
+    (0xFC69, 'M', u'ئي'),
+    (0xFC6A, 'M', u'بر'),
+    (0xFC6B, 'M', u'بز'),
+    (0xFC6C, 'M', u'بم'),
+    (0xFC6D, 'M', u'بن'),
+    (0xFC6E, 'M', u'بى'),
+    (0xFC6F, 'M', u'بي'),
+    (0xFC70, 'M', u'تر'),
+    (0xFC71, 'M', u'تز'),
+    (0xFC72, 'M', u'تم'),
+    (0xFC73, 'M', u'تن'),
+    (0xFC74, 'M', u'تى'),
+    (0xFC75, 'M', u'تي'),
+    (0xFC76, 'M', u'ثر'),
+    (0xFC77, 'M', u'ثز'),
+    (0xFC78, 'M', u'ثم'),
+    (0xFC79, 'M', u'ثن'),
+    (0xFC7A, 'M', u'ثى'),
+    (0xFC7B, 'M', u'ثي'),
+    (0xFC7C, 'M', u'فى'),
+    (0xFC7D, 'M', u'في'),
+    (0xFC7E, 'M', u'قى'),
+    (0xFC7F, 'M', u'قي'),
+    (0xFC80, 'M', u'كا'),
+    (0xFC81, 'M', u'كل'),
+    (0xFC82, 'M', u'كم'),
+    (0xFC83, 'M', u'كى'),
+    (0xFC84, 'M', u'كي'),
+    (0xFC85, 'M', u'لم'),
+    (0xFC86, 'M', u'لى'),
+    (0xFC87, 'M', u'لي'),
+    (0xFC88, 'M', u'ما'),
+    (0xFC89, 'M', u'مم'),
+    (0xFC8A, 'M', u'نر'),
+    (0xFC8B, 'M', u'نز'),
+    (0xFC8C, 'M', u'نم'),
+    (0xFC8D, 'M', u'نن'),
+    (0xFC8E, 'M', u'نى'),
+    (0xFC8F, 'M', u'ني'),
+    (0xFC90, 'M', u'ىٰ'),
+    (0xFC91, 'M', u'ير'),
+    (0xFC92, 'M', u'يز'),
+    (0xFC93, 'M', u'يم'),
+    (0xFC94, 'M', u'ين'),
+    (0xFC95, 'M', u'يى'),
+    (0xFC96, 'M', u'يي'),
+    (0xFC97, 'M', u'ئج'),
+    (0xFC98, 'M', u'ئح'),
+    (0xFC99, 'M', u'ئخ'),
+    (0xFC9A, 'M', u'ئم'),
+    (0xFC9B, 'M', u'ئه'),
+    (0xFC9C, 'M', u'بج'),
+    (0xFC9D, 'M', u'بح'),
+    (0xFC9E, 'M', u'بخ'),
+    (0xFC9F, 'M', u'بم'),
+    (0xFCA0, 'M', u'به'),
+    (0xFCA1, 'M', u'تج'),
+    (0xFCA2, 'M', u'تح'),
+    (0xFCA3, 'M', u'تخ'),
+    (0xFCA4, 'M', u'تم'),
+    (0xFCA5, 'M', u'ته'),
+    (0xFCA6, 'M', u'ثم'),
+    (0xFCA7, 'M', u'جح'),
+    (0xFCA8, 'M', u'جم'),
+    (0xFCA9, 'M', u'حج'),
+    (0xFCAA, 'M', u'حم'),
+    (0xFCAB, 'M', u'خج'),
+    (0xFCAC, 'M', u'خم'),
+    (0xFCAD, 'M', u'سج'),
+    (0xFCAE, 'M', u'سح'),
+    (0xFCAF, 'M', u'سخ'),
+    (0xFCB0, 'M', u'سم'),
+    (0xFCB1, 'M', u'صح'),
+    (0xFCB2, 'M', u'صخ'),
+    (0xFCB3, 'M', u'صم'),
+    (0xFCB4, 'M', u'ضج'),
+    (0xFCB5, 'M', u'ضح'),
+    (0xFCB6, 'M', u'ضخ'),
+    (0xFCB7, 'M', u'ضم'),
+    (0xFCB8, 'M', u'طح'),
+    (0xFCB9, 'M', u'ظم'),
+    (0xFCBA, 'M', u'عج'),
+    (0xFCBB, 'M', u'عم'),
+    (0xFCBC, 'M', u'غج'),
+    (0xFCBD, 'M', u'غم'),
+    (0xFCBE, 'M', u'فج'),
+    (0xFCBF, 'M', u'فح'),
+    (0xFCC0, 'M', u'فخ'),
+    (0xFCC1, 'M', u'فم'),
+    (0xFCC2, 'M', u'قح'),
+    (0xFCC3, 'M', u'قم'),
+    ]
+
+def _seg_47():
+    return [
+    (0xFCC4, 'M', u'كج'),
+    (0xFCC5, 'M', u'كح'),
+    (0xFCC6, 'M', u'كخ'),
+    (0xFCC7, 'M', u'كل'),
+    (0xFCC8, 'M', u'كم'),
+    (0xFCC9, 'M', u'لج'),
+    (0xFCCA, 'M', u'لح'),
+    (0xFCCB, 'M', u'لخ'),
+    (0xFCCC, 'M', u'لم'),
+    (0xFCCD, 'M', u'له'),
+    (0xFCCE, 'M', u'مج'),
+    (0xFCCF, 'M', u'مح'),
+    (0xFCD0, 'M', u'مخ'),
+    (0xFCD1, 'M', u'مم'),
+    (0xFCD2, 'M', u'نج'),
+    (0xFCD3, 'M', u'نح'),
+    (0xFCD4, 'M', u'نخ'),
+    (0xFCD5, 'M', u'نم'),
+    (0xFCD6, 'M', u'نه'),
+    (0xFCD7, 'M', u'هج'),
+    (0xFCD8, 'M', u'هم'),
+    (0xFCD9, 'M', u'هٰ'),
+    (0xFCDA, 'M', u'يج'),
+    (0xFCDB, 'M', u'يح'),
+    (0xFCDC, 'M', u'يخ'),
+    (0xFCDD, 'M', u'يم'),
+    (0xFCDE, 'M', u'يه'),
+    (0xFCDF, 'M', u'ئم'),
+    (0xFCE0, 'M', u'ئه'),
+    (0xFCE1, 'M', u'بم'),
+    (0xFCE2, 'M', u'به'),
+    (0xFCE3, 'M', u'تم'),
+    (0xFCE4, 'M', u'ته'),
+    (0xFCE5, 'M', u'ثم'),
+    (0xFCE6, 'M', u'ثه'),
+    (0xFCE7, 'M', u'سم'),
+    (0xFCE8, 'M', u'سه'),
+    (0xFCE9, 'M', u'شم'),
+    (0xFCEA, 'M', u'شه'),
+    (0xFCEB, 'M', u'كل'),
+    (0xFCEC, 'M', u'كم'),
+    (0xFCED, 'M', u'لم'),
+    (0xFCEE, 'M', u'نم'),
+    (0xFCEF, 'M', u'نه'),
+    (0xFCF0, 'M', u'يم'),
+    (0xFCF1, 'M', u'يه'),
+    (0xFCF2, 'M', u'ـَّ'),
+    (0xFCF3, 'M', u'ـُّ'),
+    (0xFCF4, 'M', u'ـِّ'),
+    (0xFCF5, 'M', u'طى'),
+    (0xFCF6, 'M', u'طي'),
+    (0xFCF7, 'M', u'عى'),
+    (0xFCF8, 'M', u'عي'),
+    (0xFCF9, 'M', u'غى'),
+    (0xFCFA, 'M', u'غي'),
+    (0xFCFB, 'M', u'سى'),
+    (0xFCFC, 'M', u'سي'),
+    (0xFCFD, 'M', u'شى'),
+    (0xFCFE, 'M', u'شي'),
+    (0xFCFF, 'M', u'حى'),
+    (0xFD00, 'M', u'حي'),
+    (0xFD01, 'M', u'جى'),
+    (0xFD02, 'M', u'جي'),
+    (0xFD03, 'M', u'خى'),
+    (0xFD04, 'M', u'خي'),
+    (0xFD05, 'M', u'صى'),
+    (0xFD06, 'M', u'صي'),
+    (0xFD07, 'M', u'ضى'),
+    (0xFD08, 'M', u'ضي'),
+    (0xFD09, 'M', u'شج'),
+    (0xFD0A, 'M', u'شح'),
+    (0xFD0B, 'M', u'شخ'),
+    (0xFD0C, 'M', u'شم'),
+    (0xFD0D, 'M', u'شر'),
+    (0xFD0E, 'M', u'سر'),
+    (0xFD0F, 'M', u'صر'),
+    (0xFD10, 'M', u'ضر'),
+    (0xFD11, 'M', u'طى'),
+    (0xFD12, 'M', u'طي'),
+    (0xFD13, 'M', u'عى'),
+    (0xFD14, 'M', u'عي'),
+    (0xFD15, 'M', u'غى'),
+    (0xFD16, 'M', u'غي'),
+    (0xFD17, 'M', u'سى'),
+    (0xFD18, 'M', u'سي'),
+    (0xFD19, 'M', u'شى'),
+    (0xFD1A, 'M', u'شي'),
+    (0xFD1B, 'M', u'حى'),
+    (0xFD1C, 'M', u'حي'),
+    (0xFD1D, 'M', u'جى'),
+    (0xFD1E, 'M', u'جي'),
+    (0xFD1F, 'M', u'خى'),
+    (0xFD20, 'M', u'خي'),
+    (0xFD21, 'M', u'صى'),
+    (0xFD22, 'M', u'صي'),
+    (0xFD23, 'M', u'ضى'),
+    (0xFD24, 'M', u'ضي'),
+    (0xFD25, 'M', u'شج'),
+    (0xFD26, 'M', u'شح'),
+    (0xFD27, 'M', u'شخ'),
+    ]
+
+def _seg_48():
+    return [
+    (0xFD28, 'M', u'شم'),
+    (0xFD29, 'M', u'شر'),
+    (0xFD2A, 'M', u'سر'),
+    (0xFD2B, 'M', u'صر'),
+    (0xFD2C, 'M', u'ضر'),
+    (0xFD2D, 'M', u'شج'),
+    (0xFD2E, 'M', u'شح'),
+    (0xFD2F, 'M', u'شخ'),
+    (0xFD30, 'M', u'شم'),
+    (0xFD31, 'M', u'سه'),
+    (0xFD32, 'M', u'شه'),
+    (0xFD33, 'M', u'طم'),
+    (0xFD34, 'M', u'سج'),
+    (0xFD35, 'M', u'سح'),
+    (0xFD36, 'M', u'سخ'),
+    (0xFD37, 'M', u'شج'),
+    (0xFD38, 'M', u'شح'),
+    (0xFD39, 'M', u'شخ'),
+    (0xFD3A, 'M', u'طم'),
+    (0xFD3B, 'M', u'ظم'),
+    (0xFD3C, 'M', u'اً'),
+    (0xFD3E, 'V'),
+    (0xFD40, 'X'),
+    (0xFD50, 'M', u'تجم'),
+    (0xFD51, 'M', u'تحج'),
+    (0xFD53, 'M', u'تحم'),
+    (0xFD54, 'M', u'تخم'),
+    (0xFD55, 'M', u'تمج'),
+    (0xFD56, 'M', u'تمح'),
+    (0xFD57, 'M', u'تمخ'),
+    (0xFD58, 'M', u'جمح'),
+    (0xFD5A, 'M', u'حمي'),
+    (0xFD5B, 'M', u'حمى'),
+    (0xFD5C, 'M', u'سحج'),
+    (0xFD5D, 'M', u'سجح'),
+    (0xFD5E, 'M', u'سجى'),
+    (0xFD5F, 'M', u'سمح'),
+    (0xFD61, 'M', u'سمج'),
+    (0xFD62, 'M', u'سمم'),
+    (0xFD64, 'M', u'صحح'),
+    (0xFD66, 'M', u'صمم'),
+    (0xFD67, 'M', u'شحم'),
+    (0xFD69, 'M', u'شجي'),
+    (0xFD6A, 'M', u'شمخ'),
+    (0xFD6C, 'M', u'شمم'),
+    (0xFD6E, 'M', u'ضحى'),
+    (0xFD6F, 'M', u'ضخم'),
+    (0xFD71, 'M', u'طمح'),
+    (0xFD73, 'M', u'طمم'),
+    (0xFD74, 'M', u'طمي'),
+    (0xFD75, 'M', u'عجم'),
+    (0xFD76, 'M', u'عمم'),
+    (0xFD78, 'M', u'عمى'),
+    (0xFD79, 'M', u'غمم'),
+    (0xFD7A, 'M', u'غمي'),
+    (0xFD7B, 'M', u'غمى'),
+    (0xFD7C, 'M', u'فخم'),
+    (0xFD7E, 'M', u'قمح'),
+    (0xFD7F, 'M', u'قمم'),
+    (0xFD80, 'M', u'لحم'),
+    (0xFD81, 'M', u'لحي'),
+    (0xFD82, 'M', u'لحى'),
+    (0xFD83, 'M', u'لجج'),
+    (0xFD85, 'M', u'لخم'),
+    (0xFD87, 'M', u'لمح'),
+    (0xFD89, 'M', u'محج'),
+    (0xFD8A, 'M', u'محم'),
+    (0xFD8B, 'M', u'محي'),
+    (0xFD8C, 'M', u'مجح'),
+    (0xFD8D, 'M', u'مجم'),
+    (0xFD8E, 'M', u'مخج'),
+    (0xFD8F, 'M', u'مخم'),
+    (0xFD90, 'X'),
+    (0xFD92, 'M', u'مجخ'),
+    (0xFD93, 'M', u'همج'),
+    (0xFD94, 'M', u'همم'),
+    (0xFD95, 'M', u'نحم'),
+    (0xFD96, 'M', u'نحى'),
+    (0xFD97, 'M', u'نجم'),
+    (0xFD99, 'M', u'نجى'),
+    (0xFD9A, 'M', u'نمي'),
+    (0xFD9B, 'M', u'نمى'),
+    (0xFD9C, 'M', u'يمم'),
+    (0xFD9E, 'M', u'بخي'),
+    (0xFD9F, 'M', u'تجي'),
+    (0xFDA0, 'M', u'تجى'),
+    (0xFDA1, 'M', u'تخي'),
+    (0xFDA2, 'M', u'تخى'),
+    (0xFDA3, 'M', u'تمي'),
+    (0xFDA4, 'M', u'تمى'),
+    (0xFDA5, 'M', u'جمي'),
+    (0xFDA6, 'M', u'جحى'),
+    (0xFDA7, 'M', u'جمى'),
+    (0xFDA8, 'M', u'سخى'),
+    (0xFDA9, 'M', u'صحي'),
+    (0xFDAA, 'M', u'شحي'),
+    (0xFDAB, 'M', u'ضحي'),
+    (0xFDAC, 'M', u'لجي'),
+    (0xFDAD, 'M', u'لمي'),
+    (0xFDAE, 'M', u'يحي'),
+    ]
+
+def _seg_49():
+    return [
+    (0xFDAF, 'M', u'يجي'),
+    (0xFDB0, 'M', u'يمي'),
+    (0xFDB1, 'M', u'ممي'),
+    (0xFDB2, 'M', u'قمي'),
+    (0xFDB3, 'M', u'نحي'),
+    (0xFDB4, 'M', u'قمح'),
+    (0xFDB5, 'M', u'لحم'),
+    (0xFDB6, 'M', u'عمي'),
+    (0xFDB7, 'M', u'كمي'),
+    (0xFDB8, 'M', u'نجح'),
+    (0xFDB9, 'M', u'مخي'),
+    (0xFDBA, 'M', u'لجم'),
+    (0xFDBB, 'M', u'كمم'),
+    (0xFDBC, 'M', u'لجم'),
+    (0xFDBD, 'M', u'نجح'),
+    (0xFDBE, 'M', u'جحي'),
+    (0xFDBF, 'M', u'حجي'),
+    (0xFDC0, 'M', u'مجي'),
+    (0xFDC1, 'M', u'فمي'),
+    (0xFDC2, 'M', u'بحي'),
+    (0xFDC3, 'M', u'كمم'),
+    (0xFDC4, 'M', u'عجم'),
+    (0xFDC5, 'M', u'صمم'),
+    (0xFDC6, 'M', u'سخي'),
+    (0xFDC7, 'M', u'نجي'),
+    (0xFDC8, 'X'),
+    (0xFDF0, 'M', u'صلے'),
+    (0xFDF1, 'M', u'قلے'),
+    (0xFDF2, 'M', u'الله'),
+    (0xFDF3, 'M', u'اكبر'),
+    (0xFDF4, 'M', u'محمد'),
+    (0xFDF5, 'M', u'صلعم'),
+    (0xFDF6, 'M', u'رسول'),
+    (0xFDF7, 'M', u'عليه'),
+    (0xFDF8, 'M', u'وسلم'),
+    (0xFDF9, 'M', u'صلى'),
+    (0xFDFA, '3', u'صلى الله عليه وسلم'),
+    (0xFDFB, '3', u'جل جلاله'),
+    (0xFDFC, 'M', u'ریال'),
+    (0xFDFD, 'V'),
+    (0xFDFE, 'X'),
+    (0xFE00, 'I'),
+    (0xFE10, '3', u','),
+    (0xFE11, 'M', u'、'),
+    (0xFE12, 'X'),
+    (0xFE13, '3', u':'),
+    (0xFE14, '3', u';'),
+    (0xFE15, '3', u'!'),
+    (0xFE16, '3', u'?'),
+    (0xFE17, 'M', u'〖'),
+    (0xFE18, 'M', u'〗'),
+    (0xFE19, 'X'),
+    (0xFE20, 'V'),
+    (0xFE30, 'X'),
+    (0xFE31, 'M', u'—'),
+    (0xFE32, 'M', u'–'),
+    (0xFE33, '3', u'_'),
+    (0xFE35, '3', u'('),
+    (0xFE36, '3', u')'),
+    (0xFE37, '3', u'{'),
+    (0xFE38, '3', u'}'),
+    (0xFE39, 'M', u'〔'),
+    (0xFE3A, 'M', u'〕'),
+    (0xFE3B, 'M', u'【'),
+    (0xFE3C, 'M', u'】'),
+    (0xFE3D, 'M', u'《'),
+    (0xFE3E, 'M', u'》'),
+    (0xFE3F, 'M', u'〈'),
+    (0xFE40, 'M', u'〉'),
+    (0xFE41, 'M', u'「'),
+    (0xFE42, 'M', u'」'),
+    (0xFE43, 'M', u'『'),
+    (0xFE44, 'M', u'』'),
+    (0xFE45, 'V'),
+    (0xFE47, '3', u'['),
+    (0xFE48, '3', u']'),
+    (0xFE49, '3', u' ̅'),
+    (0xFE4D, '3', u'_'),
+    (0xFE50, '3', u','),
+    (0xFE51, 'M', u'、'),
+    (0xFE52, 'X'),
+    (0xFE54, '3', u';'),
+    (0xFE55, '3', u':'),
+    (0xFE56, '3', u'?'),
+    (0xFE57, '3', u'!'),
+    (0xFE58, 'M', u'—'),
+    (0xFE59, '3', u'('),
+    (0xFE5A, '3', u')'),
+    (0xFE5B, '3', u'{'),
+    (0xFE5C, '3', u'}'),
+    (0xFE5D, 'M', u'〔'),
+    (0xFE5E, 'M', u'〕'),
+    (0xFE5F, '3', u'#'),
+    (0xFE60, '3', u'&'),
+    (0xFE61, '3', u'*'),
+    (0xFE62, '3', u'+'),
+    (0xFE63, 'M', u'-'),
+    (0xFE64, '3', u'<'),
+    (0xFE65, '3', u'>'),
+    (0xFE66, '3', u'='),
+    ]
+
+def _seg_50():
+    return [
+    (0xFE67, 'X'),
+    (0xFE68, '3', u'\\'),
+    (0xFE69, '3', u'$'),
+    (0xFE6A, '3', u'%'),
+    (0xFE6B, '3', u'@'),
+    (0xFE6C, 'X'),
+    (0xFE70, '3', u' ً'),
+    (0xFE71, 'M', u'ـً'),
+    (0xFE72, '3', u' ٌ'),
+    (0xFE73, 'V'),
+    (0xFE74, '3', u' ٍ'),
+    (0xFE75, 'X'),
+    (0xFE76, '3', u' َ'),
+    (0xFE77, 'M', u'ـَ'),
+    (0xFE78, '3', u' ُ'),
+    (0xFE79, 'M', u'ـُ'),
+    (0xFE7A, '3', u' ِ'),
+    (0xFE7B, 'M', u'ـِ'),
+    (0xFE7C, '3', u' ّ'),
+    (0xFE7D, 'M', u'ـّ'),
+    (0xFE7E, '3', u' ْ'),
+    (0xFE7F, 'M', u'ـْ'),
+    (0xFE80, 'M', u'ء'),
+    (0xFE81, 'M', u'آ'),
+    (0xFE83, 'M', u'أ'),
+    (0xFE85, 'M', u'ؤ'),
+    (0xFE87, 'M', u'إ'),
+    (0xFE89, 'M', u'ئ'),
+    (0xFE8D, 'M', u'ا'),
+    (0xFE8F, 'M', u'ب'),
+    (0xFE93, 'M', u'ة'),
+    (0xFE95, 'M', u'ت'),
+    (0xFE99, 'M', u'ث'),
+    (0xFE9D, 'M', u'ج'),
+    (0xFEA1, 'M', u'ح'),
+    (0xFEA5, 'M', u'خ'),
+    (0xFEA9, 'M', u'د'),
+    (0xFEAB, 'M', u'ذ'),
+    (0xFEAD, 'M', u'ر'),
+    (0xFEAF, 'M', u'ز'),
+    (0xFEB1, 'M', u'س'),
+    (0xFEB5, 'M', u'ش'),
+    (0xFEB9, 'M', u'ص'),
+    (0xFEBD, 'M', u'ض'),
+    (0xFEC1, 'M', u'ط'),
+    (0xFEC5, 'M', u'ظ'),
+    (0xFEC9, 'M', u'ع'),
+    (0xFECD, 'M', u'غ'),
+    (0xFED1, 'M', u'ف'),
+    (0xFED5, 'M', u'ق'),
+    (0xFED9, 'M', u'ك'),
+    (0xFEDD, 'M', u'ل'),
+    (0xFEE1, 'M', u'م'),
+    (0xFEE5, 'M', u'ن'),
+    (0xFEE9, 'M', u'ه'),
+    (0xFEED, 'M', u'و'),
+    (0xFEEF, 'M', u'ى'),
+    (0xFEF1, 'M', u'ي'),
+    (0xFEF5, 'M', u'لآ'),
+    (0xFEF7, 'M', u'لأ'),
+    (0xFEF9, 'M', u'لإ'),
+    (0xFEFB, 'M', u'لا'),
+    (0xFEFD, 'X'),
+    (0xFEFF, 'I'),
+    (0xFF00, 'X'),
+    (0xFF01, '3', u'!'),
+    (0xFF02, '3', u'"'),
+    (0xFF03, '3', u'#'),
+    (0xFF04, '3', u'$'),
+    (0xFF05, '3', u'%'),
+    (0xFF06, '3', u'&'),
+    (0xFF07, '3', u'\''),
+    (0xFF08, '3', u'('),
+    (0xFF09, '3', u')'),
+    (0xFF0A, '3', u'*'),
+    (0xFF0B, '3', u'+'),
+    (0xFF0C, '3', u','),
+    (0xFF0D, 'M', u'-'),
+    (0xFF0E, 'M', u'.'),
+    (0xFF0F, '3', u'/'),
+    (0xFF10, 'M', u'0'),
+    (0xFF11, 'M', u'1'),
+    (0xFF12, 'M', u'2'),
+    (0xFF13, 'M', u'3'),
+    (0xFF14, 'M', u'4'),
+    (0xFF15, 'M', u'5'),
+    (0xFF16, 'M', u'6'),
+    (0xFF17, 'M', u'7'),
+    (0xFF18, 'M', u'8'),
+    (0xFF19, 'M', u'9'),
+    (0xFF1A, '3', u':'),
+    (0xFF1B, '3', u';'),
+    (0xFF1C, '3', u'<'),
+    (0xFF1D, '3', u'='),
+    (0xFF1E, '3', u'>'),
+    (0xFF1F, '3', u'?'),
+    (0xFF20, '3', u'@'),
+    (0xFF21, 'M', u'a'),
+    (0xFF22, 'M', u'b'),
+    (0xFF23, 'M', u'c'),
+    ]
+
+def _seg_51():
+    return [
+    (0xFF24, 'M', u'd'),
+    (0xFF25, 'M', u'e'),
+    (0xFF26, 'M', u'f'),
+    (0xFF27, 'M', u'g'),
+    (0xFF28, 'M', u'h'),
+    (0xFF29, 'M', u'i'),
+    (0xFF2A, 'M', u'j'),
+    (0xFF2B, 'M', u'k'),
+    (0xFF2C, 'M', u'l'),
+    (0xFF2D, 'M', u'm'),
+    (0xFF2E, 'M', u'n'),
+    (0xFF2F, 'M', u'o'),
+    (0xFF30, 'M', u'p'),
+    (0xFF31, 'M', u'q'),
+    (0xFF32, 'M', u'r'),
+    (0xFF33, 'M', u's'),
+    (0xFF34, 'M', u't'),
+    (0xFF35, 'M', u'u'),
+    (0xFF36, 'M', u'v'),
+    (0xFF37, 'M', u'w'),
+    (0xFF38, 'M', u'x'),
+    (0xFF39, 'M', u'y'),
+    (0xFF3A, 'M', u'z'),
+    (0xFF3B, '3', u'['),
+    (0xFF3C, '3', u'\\'),
+    (0xFF3D, '3', u']'),
+    (0xFF3E, '3', u'^'),
+    (0xFF3F, '3', u'_'),
+    (0xFF40, '3', u'`'),
+    (0xFF41, 'M', u'a'),
+    (0xFF42, 'M', u'b'),
+    (0xFF43, 'M', u'c'),
+    (0xFF44, 'M', u'd'),
+    (0xFF45, 'M', u'e'),
+    (0xFF46, 'M', u'f'),
+    (0xFF47, 'M', u'g'),
+    (0xFF48, 'M', u'h'),
+    (0xFF49, 'M', u'i'),
+    (0xFF4A, 'M', u'j'),
+    (0xFF4B, 'M', u'k'),
+    (0xFF4C, 'M', u'l'),
+    (0xFF4D, 'M', u'm'),
+    (0xFF4E, 'M', u'n'),
+    (0xFF4F, 'M', u'o'),
+    (0xFF50, 'M', u'p'),
+    (0xFF51, 'M', u'q'),
+    (0xFF52, 'M', u'r'),
+    (0xFF53, 'M', u's'),
+    (0xFF54, 'M', u't'),
+    (0xFF55, 'M', u'u'),
+    (0xFF56, 'M', u'v'),
+    (0xFF57, 'M', u'w'),
+    (0xFF58, 'M', u'x'),
+    (0xFF59, 'M', u'y'),
+    (0xFF5A, 'M', u'z'),
+    (0xFF5B, '3', u'{'),
+    (0xFF5C, '3', u'|'),
+    (0xFF5D, '3', u'}'),
+    (0xFF5E, '3', u'~'),
+    (0xFF5F, 'M', u'⦅'),
+    (0xFF60, 'M', u'⦆'),
+    (0xFF61, 'M', u'.'),
+    (0xFF62, 'M', u'「'),
+    (0xFF63, 'M', u'」'),
+    (0xFF64, 'M', u'、'),
+    (0xFF65, 'M', u'・'),
+    (0xFF66, 'M', u'ヲ'),
+    (0xFF67, 'M', u'ァ'),
+    (0xFF68, 'M', u'ィ'),
+    (0xFF69, 'M', u'ゥ'),
+    (0xFF6A, 'M', u'ェ'),
+    (0xFF6B, 'M', u'ォ'),
+    (0xFF6C, 'M', u'ャ'),
+    (0xFF6D, 'M', u'ュ'),
+    (0xFF6E, 'M', u'ョ'),
+    (0xFF6F, 'M', u'ッ'),
+    (0xFF70, 'M', u'ー'),
+    (0xFF71, 'M', u'ア'),
+    (0xFF72, 'M', u'イ'),
+    (0xFF73, 'M', u'ウ'),
+    (0xFF74, 'M', u'エ'),
+    (0xFF75, 'M', u'オ'),
+    (0xFF76, 'M', u'カ'),
+    (0xFF77, 'M', u'キ'),
+    (0xFF78, 'M', u'ク'),
+    (0xFF79, 'M', u'ケ'),
+    (0xFF7A, 'M', u'コ'),
+    (0xFF7B, 'M', u'サ'),
+    (0xFF7C, 'M', u'シ'),
+    (0xFF7D, 'M', u'ス'),
+    (0xFF7E, 'M', u'セ'),
+    (0xFF7F, 'M', u'ソ'),
+    (0xFF80, 'M', u'タ'),
+    (0xFF81, 'M', u'チ'),
+    (0xFF82, 'M', u'ツ'),
+    (0xFF83, 'M', u'テ'),
+    (0xFF84, 'M', u'ト'),
+    (0xFF85, 'M', u'ナ'),
+    (0xFF86, 'M', u'ニ'),
+    (0xFF87, 'M', u'ヌ'),
+    ]
+
+def _seg_52():
+    return [
+    (0xFF88, 'M', u'ネ'),
+    (0xFF89, 'M', u'ノ'),
+    (0xFF8A, 'M', u'ハ'),
+    (0xFF8B, 'M', u'ヒ'),
+    (0xFF8C, 'M', u'フ'),
+    (0xFF8D, 'M', u'ヘ'),
+    (0xFF8E, 'M', u'ホ'),
+    (0xFF8F, 'M', u'マ'),
+    (0xFF90, 'M', u'ミ'),
+    (0xFF91, 'M', u'ム'),
+    (0xFF92, 'M', u'メ'),
+    (0xFF93, 'M', u'モ'),
+    (0xFF94, 'M', u'ヤ'),
+    (0xFF95, 'M', u'ユ'),
+    (0xFF96, 'M', u'ヨ'),
+    (0xFF97, 'M', u'ラ'),
+    (0xFF98, 'M', u'リ'),
+    (0xFF99, 'M', u'ル'),
+    (0xFF9A, 'M', u'レ'),
+    (0xFF9B, 'M', u'ロ'),
+    (0xFF9C, 'M', u'ワ'),
+    (0xFF9D, 'M', u'ン'),
+    (0xFF9E, 'M', u'゙'),
+    (0xFF9F, 'M', u'゚'),
+    (0xFFA0, 'X'),
+    (0xFFA1, 'M', u'ᄀ'),
+    (0xFFA2, 'M', u'ᄁ'),
+    (0xFFA3, 'M', u'ᆪ'),
+    (0xFFA4, 'M', u'ᄂ'),
+    (0xFFA5, 'M', u'ᆬ'),
+    (0xFFA6, 'M', u'ᆭ'),
+    (0xFFA7, 'M', u'ᄃ'),
+    (0xFFA8, 'M', u'ᄄ'),
+    (0xFFA9, 'M', u'ᄅ'),
+    (0xFFAA, 'M', u'ᆰ'),
+    (0xFFAB, 'M', u'ᆱ'),
+    (0xFFAC, 'M', u'ᆲ'),
+    (0xFFAD, 'M', u'ᆳ'),
+    (0xFFAE, 'M', u'ᆴ'),
+    (0xFFAF, 'M', u'ᆵ'),
+    (0xFFB0, 'M', u'ᄚ'),
+    (0xFFB1, 'M', u'ᄆ'),
+    (0xFFB2, 'M', u'ᄇ'),
+    (0xFFB3, 'M', u'ᄈ'),
+    (0xFFB4, 'M', u'ᄡ'),
+    (0xFFB5, 'M', u'ᄉ'),
+    (0xFFB6, 'M', u'ᄊ'),
+    (0xFFB7, 'M', u'ᄋ'),
+    (0xFFB8, 'M', u'ᄌ'),
+    (0xFFB9, 'M', u'ᄍ'),
+    (0xFFBA, 'M', u'ᄎ'),
+    (0xFFBB, 'M', u'ᄏ'),
+    (0xFFBC, 'M', u'ᄐ'),
+    (0xFFBD, 'M', u'ᄑ'),
+    (0xFFBE, 'M', u'ᄒ'),
+    (0xFFBF, 'X'),
+    (0xFFC2, 'M', u'ᅡ'),
+    (0xFFC3, 'M', u'ᅢ'),
+    (0xFFC4, 'M', u'ᅣ'),
+    (0xFFC5, 'M', u'ᅤ'),
+    (0xFFC6, 'M', u'ᅥ'),
+    (0xFFC7, 'M', u'ᅦ'),
+    (0xFFC8, 'X'),
+    (0xFFCA, 'M', u'ᅧ'),
+    (0xFFCB, 'M', u'ᅨ'),
+    (0xFFCC, 'M', u'ᅩ'),
+    (0xFFCD, 'M', u'ᅪ'),
+    (0xFFCE, 'M', u'ᅫ'),
+    (0xFFCF, 'M', u'ᅬ'),
+    (0xFFD0, 'X'),
+    (0xFFD2, 'M', u'ᅭ'),
+    (0xFFD3, 'M', u'ᅮ'),
+    (0xFFD4, 'M', u'ᅯ'),
+    (0xFFD5, 'M', u'ᅰ'),
+    (0xFFD6, 'M', u'ᅱ'),
+    (0xFFD7, 'M', u'ᅲ'),
+    (0xFFD8, 'X'),
+    (0xFFDA, 'M', u'ᅳ'),
+    (0xFFDB, 'M', u'ᅴ'),
+    (0xFFDC, 'M', u'ᅵ'),
+    (0xFFDD, 'X'),
+    (0xFFE0, 'M', u'¢'),
+    (0xFFE1, 'M', u'£'),
+    (0xFFE2, 'M', u'¬'),
+    (0xFFE3, '3', u' ̄'),
+    (0xFFE4, 'M', u'¦'),
+    (0xFFE5, 'M', u'¥'),
+    (0xFFE6, 'M', u'₩'),
+    (0xFFE7, 'X'),
+    (0xFFE8, 'M', u'│'),
+    (0xFFE9, 'M', u'←'),
+    (0xFFEA, 'M', u'↑'),
+    (0xFFEB, 'M', u'→'),
+    (0xFFEC, 'M', u'↓'),
+    (0xFFED, 'M', u'■'),
+    (0xFFEE, 'M', u'○'),
+    (0xFFEF, 'X'),
+    (0x10000, 'V'),
+    (0x1000C, 'X'),
+    (0x1000D, 'V'),
+    ]
+
+def _seg_53():
+    return [
+    (0x10027, 'X'),
+    (0x10028, 'V'),
+    (0x1003B, 'X'),
+    (0x1003C, 'V'),
+    (0x1003E, 'X'),
+    (0x1003F, 'V'),
+    (0x1004E, 'X'),
+    (0x10050, 'V'),
+    (0x1005E, 'X'),
+    (0x10080, 'V'),
+    (0x100FB, 'X'),
+    (0x10100, 'V'),
+    (0x10103, 'X'),
+    (0x10107, 'V'),
+    (0x10134, 'X'),
+    (0x10137, 'V'),
+    (0x1018F, 'X'),
+    (0x10190, 'V'),
+    (0x1019D, 'X'),
+    (0x101A0, 'V'),
+    (0x101A1, 'X'),
+    (0x101D0, 'V'),
+    (0x101FE, 'X'),
+    (0x10280, 'V'),
+    (0x1029D, 'X'),
+    (0x102A0, 'V'),
+    (0x102D1, 'X'),
+    (0x102E0, 'V'),
+    (0x102FC, 'X'),
+    (0x10300, 'V'),
+    (0x10324, 'X'),
+    (0x1032D, 'V'),
+    (0x1034B, 'X'),
+    (0x10350, 'V'),
+    (0x1037B, 'X'),
+    (0x10380, 'V'),
+    (0x1039E, 'X'),
+    (0x1039F, 'V'),
+    (0x103C4, 'X'),
+    (0x103C8, 'V'),
+    (0x103D6, 'X'),
+    (0x10400, 'M', u'𐐨'),
+    (0x10401, 'M', u'𐐩'),
+    (0x10402, 'M', u'𐐪'),
+    (0x10403, 'M', u'𐐫'),
+    (0x10404, 'M', u'𐐬'),
+    (0x10405, 'M', u'𐐭'),
+    (0x10406, 'M', u'𐐮'),
+    (0x10407, 'M', u'𐐯'),
+    (0x10408, 'M', u'𐐰'),
+    (0x10409, 'M', u'𐐱'),
+    (0x1040A, 'M', u'𐐲'),
+    (0x1040B, 'M', u'𐐳'),
+    (0x1040C, 'M', u'𐐴'),
+    (0x1040D, 'M', u'𐐵'),
+    (0x1040E, 'M', u'𐐶'),
+    (0x1040F, 'M', u'𐐷'),
+    (0x10410, 'M', u'𐐸'),
+    (0x10411, 'M', u'𐐹'),
+    (0x10412, 'M', u'𐐺'),
+    (0x10413, 'M', u'𐐻'),
+    (0x10414, 'M', u'𐐼'),
+    (0x10415, 'M', u'𐐽'),
+    (0x10416, 'M', u'𐐾'),
+    (0x10417, 'M', u'𐐿'),
+    (0x10418, 'M', u'𐑀'),
+    (0x10419, 'M', u'𐑁'),
+    (0x1041A, 'M', u'𐑂'),
+    (0x1041B, 'M', u'𐑃'),
+    (0x1041C, 'M', u'𐑄'),
+    (0x1041D, 'M', u'𐑅'),
+    (0x1041E, 'M', u'𐑆'),
+    (0x1041F, 'M', u'𐑇'),
+    (0x10420, 'M', u'𐑈'),
+    (0x10421, 'M', u'𐑉'),
+    (0x10422, 'M', u'𐑊'),
+    (0x10423, 'M', u'𐑋'),
+    (0x10424, 'M', u'𐑌'),
+    (0x10425, 'M', u'𐑍'),
+    (0x10426, 'M', u'𐑎'),
+    (0x10427, 'M', u'𐑏'),
+    (0x10428, 'V'),
+    (0x1049E, 'X'),
+    (0x104A0, 'V'),
+    (0x104AA, 'X'),
+    (0x104B0, 'M', u'𐓘'),
+    (0x104B1, 'M', u'𐓙'),
+    (0x104B2, 'M', u'𐓚'),
+    (0x104B3, 'M', u'𐓛'),
+    (0x104B4, 'M', u'𐓜'),
+    (0x104B5, 'M', u'𐓝'),
+    (0x104B6, 'M', u'𐓞'),
+    (0x104B7, 'M', u'𐓟'),
+    (0x104B8, 'M', u'𐓠'),
+    (0x104B9, 'M', u'𐓡'),
+    (0x104BA, 'M', u'𐓢'),
+    (0x104BB, 'M', u'𐓣'),
+    (0x104BC, 'M', u'𐓤'),
+    (0x104BD, 'M', u'𐓥'),
+    (0x104BE, 'M', u'𐓦'),
+    ]
+
+def _seg_54():
+    return [
+    (0x104BF, 'M', u'𐓧'),
+    (0x104C0, 'M', u'𐓨'),
+    (0x104C1, 'M', u'𐓩'),
+    (0x104C2, 'M', u'𐓪'),
+    (0x104C3, 'M', u'𐓫'),
+    (0x104C4, 'M', u'𐓬'),
+    (0x104C5, 'M', u'𐓭'),
+    (0x104C6, 'M', u'𐓮'),
+    (0x104C7, 'M', u'𐓯'),
+    (0x104C8, 'M', u'𐓰'),
+    (0x104C9, 'M', u'𐓱'),
+    (0x104CA, 'M', u'𐓲'),
+    (0x104CB, 'M', u'𐓳'),
+    (0x104CC, 'M', u'𐓴'),
+    (0x104CD, 'M', u'𐓵'),
+    (0x104CE, 'M', u'𐓶'),
+    (0x104CF, 'M', u'𐓷'),
+    (0x104D0, 'M', u'𐓸'),
+    (0x104D1, 'M', u'𐓹'),
+    (0x104D2, 'M', u'𐓺'),
+    (0x104D3, 'M', u'𐓻'),
+    (0x104D4, 'X'),
+    (0x104D8, 'V'),
+    (0x104FC, 'X'),
+    (0x10500, 'V'),
+    (0x10528, 'X'),
+    (0x10530, 'V'),
+    (0x10564, 'X'),
+    (0x1056F, 'V'),
+    (0x10570, 'X'),
+    (0x10600, 'V'),
+    (0x10737, 'X'),
+    (0x10740, 'V'),
+    (0x10756, 'X'),
+    (0x10760, 'V'),
+    (0x10768, 'X'),
+    (0x10800, 'V'),
+    (0x10806, 'X'),
+    (0x10808, 'V'),
+    (0x10809, 'X'),
+    (0x1080A, 'V'),
+    (0x10836, 'X'),
+    (0x10837, 'V'),
+    (0x10839, 'X'),
+    (0x1083C, 'V'),
+    (0x1083D, 'X'),
+    (0x1083F, 'V'),
+    (0x10856, 'X'),
+    (0x10857, 'V'),
+    (0x1089F, 'X'),
+    (0x108A7, 'V'),
+    (0x108B0, 'X'),
+    (0x108E0, 'V'),
+    (0x108F3, 'X'),
+    (0x108F4, 'V'),
+    (0x108F6, 'X'),
+    (0x108FB, 'V'),
+    (0x1091C, 'X'),
+    (0x1091F, 'V'),
+    (0x1093A, 'X'),
+    (0x1093F, 'V'),
+    (0x10940, 'X'),
+    (0x10980, 'V'),
+    (0x109B8, 'X'),
+    (0x109BC, 'V'),
+    (0x109D0, 'X'),
+    (0x109D2, 'V'),
+    (0x10A04, 'X'),
+    (0x10A05, 'V'),
+    (0x10A07, 'X'),
+    (0x10A0C, 'V'),
+    (0x10A14, 'X'),
+    (0x10A15, 'V'),
+    (0x10A18, 'X'),
+    (0x10A19, 'V'),
+    (0x10A36, 'X'),
+    (0x10A38, 'V'),
+    (0x10A3B, 'X'),
+    (0x10A3F, 'V'),
+    (0x10A49, 'X'),
+    (0x10A50, 'V'),
+    (0x10A59, 'X'),
+    (0x10A60, 'V'),
+    (0x10AA0, 'X'),
+    (0x10AC0, 'V'),
+    (0x10AE7, 'X'),
+    (0x10AEB, 'V'),
+    (0x10AF7, 'X'),
+    (0x10B00, 'V'),
+    (0x10B36, 'X'),
+    (0x10B39, 'V'),
+    (0x10B56, 'X'),
+    (0x10B58, 'V'),
+    (0x10B73, 'X'),
+    (0x10B78, 'V'),
+    (0x10B92, 'X'),
+    (0x10B99, 'V'),
+    (0x10B9D, 'X'),
+    (0x10BA9, 'V'),
+    (0x10BB0, 'X'),
+    ]
+
+def _seg_55():
+    return [
+    (0x10C00, 'V'),
+    (0x10C49, 'X'),
+    (0x10C80, 'M', u'𐳀'),
+    (0x10C81, 'M', u'𐳁'),
+    (0x10C82, 'M', u'𐳂'),
+    (0x10C83, 'M', u'𐳃'),
+    (0x10C84, 'M', u'𐳄'),
+    (0x10C85, 'M', u'𐳅'),
+    (0x10C86, 'M', u'𐳆'),
+    (0x10C87, 'M', u'𐳇'),
+    (0x10C88, 'M', u'𐳈'),
+    (0x10C89, 'M', u'𐳉'),
+    (0x10C8A, 'M', u'𐳊'),
+    (0x10C8B, 'M', u'𐳋'),
+    (0x10C8C, 'M', u'𐳌'),
+    (0x10C8D, 'M', u'𐳍'),
+    (0x10C8E, 'M', u'𐳎'),
+    (0x10C8F, 'M', u'𐳏'),
+    (0x10C90, 'M', u'𐳐'),
+    (0x10C91, 'M', u'𐳑'),
+    (0x10C92, 'M', u'𐳒'),
+    (0x10C93, 'M', u'𐳓'),
+    (0x10C94, 'M', u'𐳔'),
+    (0x10C95, 'M', u'𐳕'),
+    (0x10C96, 'M', u'𐳖'),
+    (0x10C97, 'M', u'𐳗'),
+    (0x10C98, 'M', u'𐳘'),
+    (0x10C99, 'M', u'𐳙'),
+    (0x10C9A, 'M', u'𐳚'),
+    (0x10C9B, 'M', u'𐳛'),
+    (0x10C9C, 'M', u'𐳜'),
+    (0x10C9D, 'M', u'𐳝'),
+    (0x10C9E, 'M', u'𐳞'),
+    (0x10C9F, 'M', u'𐳟'),
+    (0x10CA0, 'M', u'𐳠'),
+    (0x10CA1, 'M', u'𐳡'),
+    (0x10CA2, 'M', u'𐳢'),
+    (0x10CA3, 'M', u'𐳣'),
+    (0x10CA4, 'M', u'𐳤'),
+    (0x10CA5, 'M', u'𐳥'),
+    (0x10CA6, 'M', u'𐳦'),
+    (0x10CA7, 'M', u'𐳧'),
+    (0x10CA8, 'M', u'𐳨'),
+    (0x10CA9, 'M', u'𐳩'),
+    (0x10CAA, 'M', u'𐳪'),
+    (0x10CAB, 'M', u'𐳫'),
+    (0x10CAC, 'M', u'𐳬'),
+    (0x10CAD, 'M', u'𐳭'),
+    (0x10CAE, 'M', u'𐳮'),
+    (0x10CAF, 'M', u'𐳯'),
+    (0x10CB0, 'M', u'𐳰'),
+    (0x10CB1, 'M', u'𐳱'),
+    (0x10CB2, 'M', u'𐳲'),
+    (0x10CB3, 'X'),
+    (0x10CC0, 'V'),
+    (0x10CF3, 'X'),
+    (0x10CFA, 'V'),
+    (0x10D28, 'X'),
+    (0x10D30, 'V'),
+    (0x10D3A, 'X'),
+    (0x10E60, 'V'),
+    (0x10E7F, 'X'),
+    (0x10E80, 'V'),
+    (0x10EAA, 'X'),
+    (0x10EAB, 'V'),
+    (0x10EAE, 'X'),
+    (0x10EB0, 'V'),
+    (0x10EB2, 'X'),
+    (0x10F00, 'V'),
+    (0x10F28, 'X'),
+    (0x10F30, 'V'),
+    (0x10F5A, 'X'),
+    (0x10FB0, 'V'),
+    (0x10FCC, 'X'),
+    (0x10FE0, 'V'),
+    (0x10FF7, 'X'),
+    (0x11000, 'V'),
+    (0x1104E, 'X'),
+    (0x11052, 'V'),
+    (0x11070, 'X'),
+    (0x1107F, 'V'),
+    (0x110BD, 'X'),
+    (0x110BE, 'V'),
+    (0x110C2, 'X'),
+    (0x110D0, 'V'),
+    (0x110E9, 'X'),
+    (0x110F0, 'V'),
+    (0x110FA, 'X'),
+    (0x11100, 'V'),
+    (0x11135, 'X'),
+    (0x11136, 'V'),
+    (0x11148, 'X'),
+    (0x11150, 'V'),
+    (0x11177, 'X'),
+    (0x11180, 'V'),
+    (0x111E0, 'X'),
+    (0x111E1, 'V'),
+    (0x111F5, 'X'),
+    (0x11200, 'V'),
+    (0x11212, 'X'),
+    ]
+
+def _seg_56():
+    return [
+    (0x11213, 'V'),
+    (0x1123F, 'X'),
+    (0x11280, 'V'),
+    (0x11287, 'X'),
+    (0x11288, 'V'),
+    (0x11289, 'X'),
+    (0x1128A, 'V'),
+    (0x1128E, 'X'),
+    (0x1128F, 'V'),
+    (0x1129E, 'X'),
+    (0x1129F, 'V'),
+    (0x112AA, 'X'),
+    (0x112B0, 'V'),
+    (0x112EB, 'X'),
+    (0x112F0, 'V'),
+    (0x112FA, 'X'),
+    (0x11300, 'V'),
+    (0x11304, 'X'),
+    (0x11305, 'V'),
+    (0x1130D, 'X'),
+    (0x1130F, 'V'),
+    (0x11311, 'X'),
+    (0x11313, 'V'),
+    (0x11329, 'X'),
+    (0x1132A, 'V'),
+    (0x11331, 'X'),
+    (0x11332, 'V'),
+    (0x11334, 'X'),
+    (0x11335, 'V'),
+    (0x1133A, 'X'),
+    (0x1133B, 'V'),
+    (0x11345, 'X'),
+    (0x11347, 'V'),
+    (0x11349, 'X'),
+    (0x1134B, 'V'),
+    (0x1134E, 'X'),
+    (0x11350, 'V'),
+    (0x11351, 'X'),
+    (0x11357, 'V'),
+    (0x11358, 'X'),
+    (0x1135D, 'V'),
+    (0x11364, 'X'),
+    (0x11366, 'V'),
+    (0x1136D, 'X'),
+    (0x11370, 'V'),
+    (0x11375, 'X'),
+    (0x11400, 'V'),
+    (0x1145C, 'X'),
+    (0x1145D, 'V'),
+    (0x11462, 'X'),
+    (0x11480, 'V'),
+    (0x114C8, 'X'),
+    (0x114D0, 'V'),
+    (0x114DA, 'X'),
+    (0x11580, 'V'),
+    (0x115B6, 'X'),
+    (0x115B8, 'V'),
+    (0x115DE, 'X'),
+    (0x11600, 'V'),
+    (0x11645, 'X'),
+    (0x11650, 'V'),
+    (0x1165A, 'X'),
+    (0x11660, 'V'),
+    (0x1166D, 'X'),
+    (0x11680, 'V'),
+    (0x116B9, 'X'),
+    (0x116C0, 'V'),
+    (0x116CA, 'X'),
+    (0x11700, 'V'),
+    (0x1171B, 'X'),
+    (0x1171D, 'V'),
+    (0x1172C, 'X'),
+    (0x11730, 'V'),
+    (0x11740, 'X'),
+    (0x11800, 'V'),
+    (0x1183C, 'X'),
+    (0x118A0, 'M', u'𑣀'),
+    (0x118A1, 'M', u'𑣁'),
+    (0x118A2, 'M', u'𑣂'),
+    (0x118A3, 'M', u'𑣃'),
+    (0x118A4, 'M', u'𑣄'),
+    (0x118A5, 'M', u'𑣅'),
+    (0x118A6, 'M', u'𑣆'),
+    (0x118A7, 'M', u'𑣇'),
+    (0x118A8, 'M', u'𑣈'),
+    (0x118A9, 'M', u'𑣉'),
+    (0x118AA, 'M', u'𑣊'),
+    (0x118AB, 'M', u'𑣋'),
+    (0x118AC, 'M', u'𑣌'),
+    (0x118AD, 'M', u'𑣍'),
+    (0x118AE, 'M', u'𑣎'),
+    (0x118AF, 'M', u'𑣏'),
+    (0x118B0, 'M', u'𑣐'),
+    (0x118B1, 'M', u'𑣑'),
+    (0x118B2, 'M', u'𑣒'),
+    (0x118B3, 'M', u'𑣓'),
+    (0x118B4, 'M', u'𑣔'),
+    (0x118B5, 'M', u'𑣕'),
+    (0x118B6, 'M', u'𑣖'),
+    (0x118B7, 'M', u'𑣗'),
+    ]
+
+def _seg_57():
+    return [
+    (0x118B8, 'M', u'𑣘'),
+    (0x118B9, 'M', u'𑣙'),
+    (0x118BA, 'M', u'𑣚'),
+    (0x118BB, 'M', u'𑣛'),
+    (0x118BC, 'M', u'𑣜'),
+    (0x118BD, 'M', u'𑣝'),
+    (0x118BE, 'M', u'𑣞'),
+    (0x118BF, 'M', u'𑣟'),
+    (0x118C0, 'V'),
+    (0x118F3, 'X'),
+    (0x118FF, 'V'),
+    (0x11907, 'X'),
+    (0x11909, 'V'),
+    (0x1190A, 'X'),
+    (0x1190C, 'V'),
+    (0x11914, 'X'),
+    (0x11915, 'V'),
+    (0x11917, 'X'),
+    (0x11918, 'V'),
+    (0x11936, 'X'),
+    (0x11937, 'V'),
+    (0x11939, 'X'),
+    (0x1193B, 'V'),
+    (0x11947, 'X'),
+    (0x11950, 'V'),
+    (0x1195A, 'X'),
+    (0x119A0, 'V'),
+    (0x119A8, 'X'),
+    (0x119AA, 'V'),
+    (0x119D8, 'X'),
+    (0x119DA, 'V'),
+    (0x119E5, 'X'),
+    (0x11A00, 'V'),
+    (0x11A48, 'X'),
+    (0x11A50, 'V'),
+    (0x11AA3, 'X'),
+    (0x11AC0, 'V'),
+    (0x11AF9, 'X'),
+    (0x11C00, 'V'),
+    (0x11C09, 'X'),
+    (0x11C0A, 'V'),
+    (0x11C37, 'X'),
+    (0x11C38, 'V'),
+    (0x11C46, 'X'),
+    (0x11C50, 'V'),
+    (0x11C6D, 'X'),
+    (0x11C70, 'V'),
+    (0x11C90, 'X'),
+    (0x11C92, 'V'),
+    (0x11CA8, 'X'),
+    (0x11CA9, 'V'),
+    (0x11CB7, 'X'),
+    (0x11D00, 'V'),
+    (0x11D07, 'X'),
+    (0x11D08, 'V'),
+    (0x11D0A, 'X'),
+    (0x11D0B, 'V'),
+    (0x11D37, 'X'),
+    (0x11D3A, 'V'),
+    (0x11D3B, 'X'),
+    (0x11D3C, 'V'),
+    (0x11D3E, 'X'),
+    (0x11D3F, 'V'),
+    (0x11D48, 'X'),
+    (0x11D50, 'V'),
+    (0x11D5A, 'X'),
+    (0x11D60, 'V'),
+    (0x11D66, 'X'),
+    (0x11D67, 'V'),
+    (0x11D69, 'X'),
+    (0x11D6A, 'V'),
+    (0x11D8F, 'X'),
+    (0x11D90, 'V'),
+    (0x11D92, 'X'),
+    (0x11D93, 'V'),
+    (0x11D99, 'X'),
+    (0x11DA0, 'V'),
+    (0x11DAA, 'X'),
+    (0x11EE0, 'V'),
+    (0x11EF9, 'X'),
+    (0x11FB0, 'V'),
+    (0x11FB1, 'X'),
+    (0x11FC0, 'V'),
+    (0x11FF2, 'X'),
+    (0x11FFF, 'V'),
+    (0x1239A, 'X'),
+    (0x12400, 'V'),
+    (0x1246F, 'X'),
+    (0x12470, 'V'),
+    (0x12475, 'X'),
+    (0x12480, 'V'),
+    (0x12544, 'X'),
+    (0x13000, 'V'),
+    (0x1342F, 'X'),
+    (0x14400, 'V'),
+    (0x14647, 'X'),
+    (0x16800, 'V'),
+    (0x16A39, 'X'),
+    (0x16A40, 'V'),
+    (0x16A5F, 'X'),
+    ]
+
+def _seg_58():
+    return [
+    (0x16A60, 'V'),
+    (0x16A6A, 'X'),
+    (0x16A6E, 'V'),
+    (0x16A70, 'X'),
+    (0x16AD0, 'V'),
+    (0x16AEE, 'X'),
+    (0x16AF0, 'V'),
+    (0x16AF6, 'X'),
+    (0x16B00, 'V'),
+    (0x16B46, 'X'),
+    (0x16B50, 'V'),
+    (0x16B5A, 'X'),
+    (0x16B5B, 'V'),
+    (0x16B62, 'X'),
+    (0x16B63, 'V'),
+    (0x16B78, 'X'),
+    (0x16B7D, 'V'),
+    (0x16B90, 'X'),
+    (0x16E40, 'M', u'𖹠'),
+    (0x16E41, 'M', u'𖹡'),
+    (0x16E42, 'M', u'𖹢'),
+    (0x16E43, 'M', u'𖹣'),
+    (0x16E44, 'M', u'𖹤'),
+    (0x16E45, 'M', u'𖹥'),
+    (0x16E46, 'M', u'𖹦'),
+    (0x16E47, 'M', u'𖹧'),
+    (0x16E48, 'M', u'𖹨'),
+    (0x16E49, 'M', u'𖹩'),
+    (0x16E4A, 'M', u'𖹪'),
+    (0x16E4B, 'M', u'𖹫'),
+    (0x16E4C, 'M', u'𖹬'),
+    (0x16E4D, 'M', u'𖹭'),
+    (0x16E4E, 'M', u'𖹮'),
+    (0x16E4F, 'M', u'𖹯'),
+    (0x16E50, 'M', u'𖹰'),
+    (0x16E51, 'M', u'𖹱'),
+    (0x16E52, 'M', u'𖹲'),
+    (0x16E53, 'M', u'𖹳'),
+    (0x16E54, 'M', u'𖹴'),
+    (0x16E55, 'M', u'𖹵'),
+    (0x16E56, 'M', u'𖹶'),
+    (0x16E57, 'M', u'𖹷'),
+    (0x16E58, 'M', u'𖹸'),
+    (0x16E59, 'M', u'𖹹'),
+    (0x16E5A, 'M', u'𖹺'),
+    (0x16E5B, 'M', u'𖹻'),
+    (0x16E5C, 'M', u'𖹼'),
+    (0x16E5D, 'M', u'𖹽'),
+    (0x16E5E, 'M', u'𖹾'),
+    (0x16E5F, 'M', u'𖹿'),
+    (0x16E60, 'V'),
+    (0x16E9B, 'X'),
+    (0x16F00, 'V'),
+    (0x16F4B, 'X'),
+    (0x16F4F, 'V'),
+    (0x16F88, 'X'),
+    (0x16F8F, 'V'),
+    (0x16FA0, 'X'),
+    (0x16FE0, 'V'),
+    (0x16FE5, 'X'),
+    (0x16FF0, 'V'),
+    (0x16FF2, 'X'),
+    (0x17000, 'V'),
+    (0x187F8, 'X'),
+    (0x18800, 'V'),
+    (0x18CD6, 'X'),
+    (0x18D00, 'V'),
+    (0x18D09, 'X'),
+    (0x1B000, 'V'),
+    (0x1B11F, 'X'),
+    (0x1B150, 'V'),
+    (0x1B153, 'X'),
+    (0x1B164, 'V'),
+    (0x1B168, 'X'),
+    (0x1B170, 'V'),
+    (0x1B2FC, 'X'),
+    (0x1BC00, 'V'),
+    (0x1BC6B, 'X'),
+    (0x1BC70, 'V'),
+    (0x1BC7D, 'X'),
+    (0x1BC80, 'V'),
+    (0x1BC89, 'X'),
+    (0x1BC90, 'V'),
+    (0x1BC9A, 'X'),
+    (0x1BC9C, 'V'),
+    (0x1BCA0, 'I'),
+    (0x1BCA4, 'X'),
+    (0x1D000, 'V'),
+    (0x1D0F6, 'X'),
+    (0x1D100, 'V'),
+    (0x1D127, 'X'),
+    (0x1D129, 'V'),
+    (0x1D15E, 'M', u'𝅗𝅥'),
+    (0x1D15F, 'M', u'𝅘𝅥'),
+    (0x1D160, 'M', u'𝅘𝅥𝅮'),
+    (0x1D161, 'M', u'𝅘𝅥𝅯'),
+    (0x1D162, 'M', u'𝅘𝅥𝅰'),
+    (0x1D163, 'M', u'𝅘𝅥𝅱'),
+    (0x1D164, 'M', u'𝅘𝅥𝅲'),
+    (0x1D165, 'V'),
+    ]
+
+def _seg_59():
+    return [
+    (0x1D173, 'X'),
+    (0x1D17B, 'V'),
+    (0x1D1BB, 'M', u'𝆹𝅥'),
+    (0x1D1BC, 'M', u'𝆺𝅥'),
+    (0x1D1BD, 'M', u'𝆹𝅥𝅮'),
+    (0x1D1BE, 'M', u'𝆺𝅥𝅮'),
+    (0x1D1BF, 'M', u'𝆹𝅥𝅯'),
+    (0x1D1C0, 'M', u'𝆺𝅥𝅯'),
+    (0x1D1C1, 'V'),
+    (0x1D1E9, 'X'),
+    (0x1D200, 'V'),
+    (0x1D246, 'X'),
+    (0x1D2E0, 'V'),
+    (0x1D2F4, 'X'),
+    (0x1D300, 'V'),
+    (0x1D357, 'X'),
+    (0x1D360, 'V'),
+    (0x1D379, 'X'),
+    (0x1D400, 'M', u'a'),
+    (0x1D401, 'M', u'b'),
+    (0x1D402, 'M', u'c'),
+    (0x1D403, 'M', u'd'),
+    (0x1D404, 'M', u'e'),
+    (0x1D405, 'M', u'f'),
+    (0x1D406, 'M', u'g'),
+    (0x1D407, 'M', u'h'),
+    (0x1D408, 'M', u'i'),
+    (0x1D409, 'M', u'j'),
+    (0x1D40A, 'M', u'k'),
+    (0x1D40B, 'M', u'l'),
+    (0x1D40C, 'M', u'm'),
+    (0x1D40D, 'M', u'n'),
+    (0x1D40E, 'M', u'o'),
+    (0x1D40F, 'M', u'p'),
+    (0x1D410, 'M', u'q'),
+    (0x1D411, 'M', u'r'),
+    (0x1D412, 'M', u's'),
+    (0x1D413, 'M', u't'),
+    (0x1D414, 'M', u'u'),
+    (0x1D415, 'M', u'v'),
+    (0x1D416, 'M', u'w'),
+    (0x1D417, 'M', u'x'),
+    (0x1D418, 'M', u'y'),
+    (0x1D419, 'M', u'z'),
+    (0x1D41A, 'M', u'a'),
+    (0x1D41B, 'M', u'b'),
+    (0x1D41C, 'M', u'c'),
+    (0x1D41D, 'M', u'd'),
+    (0x1D41E, 'M', u'e'),
+    (0x1D41F, 'M', u'f'),
+    (0x1D420, 'M', u'g'),
+    (0x1D421, 'M', u'h'),
+    (0x1D422, 'M', u'i'),
+    (0x1D423, 'M', u'j'),
+    (0x1D424, 'M', u'k'),
+    (0x1D425, 'M', u'l'),
+    (0x1D426, 'M', u'm'),
+    (0x1D427, 'M', u'n'),
+    (0x1D428, 'M', u'o'),
+    (0x1D429, 'M', u'p'),
+    (0x1D42A, 'M', u'q'),
+    (0x1D42B, 'M', u'r'),
+    (0x1D42C, 'M', u's'),
+    (0x1D42D, 'M', u't'),
+    (0x1D42E, 'M', u'u'),
+    (0x1D42F, 'M', u'v'),
+    (0x1D430, 'M', u'w'),
+    (0x1D431, 'M', u'x'),
+    (0x1D432, 'M', u'y'),
+    (0x1D433, 'M', u'z'),
+    (0x1D434, 'M', u'a'),
+    (0x1D435, 'M', u'b'),
+    (0x1D436, 'M', u'c'),
+    (0x1D437, 'M', u'd'),
+    (0x1D438, 'M', u'e'),
+    (0x1D439, 'M', u'f'),
+    (0x1D43A, 'M', u'g'),
+    (0x1D43B, 'M', u'h'),
+    (0x1D43C, 'M', u'i'),
+    (0x1D43D, 'M', u'j'),
+    (0x1D43E, 'M', u'k'),
+    (0x1D43F, 'M', u'l'),
+    (0x1D440, 'M', u'm'),
+    (0x1D441, 'M', u'n'),
+    (0x1D442, 'M', u'o'),
+    (0x1D443, 'M', u'p'),
+    (0x1D444, 'M', u'q'),
+    (0x1D445, 'M', u'r'),
+    (0x1D446, 'M', u's'),
+    (0x1D447, 'M', u't'),
+    (0x1D448, 'M', u'u'),
+    (0x1D449, 'M', u'v'),
+    (0x1D44A, 'M', u'w'),
+    (0x1D44B, 'M', u'x'),
+    (0x1D44C, 'M', u'y'),
+    (0x1D44D, 'M', u'z'),
+    (0x1D44E, 'M', u'a'),
+    (0x1D44F, 'M', u'b'),
+    (0x1D450, 'M', u'c'),
+    (0x1D451, 'M', u'd'),
+    ]
+
+def _seg_60():
+    return [
+    (0x1D452, 'M', u'e'),
+    (0x1D453, 'M', u'f'),
+    (0x1D454, 'M', u'g'),
+    (0x1D455, 'X'),
+    (0x1D456, 'M', u'i'),
+    (0x1D457, 'M', u'j'),
+    (0x1D458, 'M', u'k'),
+    (0x1D459, 'M', u'l'),
+    (0x1D45A, 'M', u'm'),
+    (0x1D45B, 'M', u'n'),
+    (0x1D45C, 'M', u'o'),
+    (0x1D45D, 'M', u'p'),
+    (0x1D45E, 'M', u'q'),
+    (0x1D45F, 'M', u'r'),
+    (0x1D460, 'M', u's'),
+    (0x1D461, 'M', u't'),
+    (0x1D462, 'M', u'u'),
+    (0x1D463, 'M', u'v'),
+    (0x1D464, 'M', u'w'),
+    (0x1D465, 'M', u'x'),
+    (0x1D466, 'M', u'y'),
+    (0x1D467, 'M', u'z'),
+    (0x1D468, 'M', u'a'),
+    (0x1D469, 'M', u'b'),
+    (0x1D46A, 'M', u'c'),
+    (0x1D46B, 'M', u'd'),
+    (0x1D46C, 'M', u'e'),
+    (0x1D46D, 'M', u'f'),
+    (0x1D46E, 'M', u'g'),
+    (0x1D46F, 'M', u'h'),
+    (0x1D470, 'M', u'i'),
+    (0x1D471, 'M', u'j'),
+    (0x1D472, 'M', u'k'),
+    (0x1D473, 'M', u'l'),
+    (0x1D474, 'M', u'm'),
+    (0x1D475, 'M', u'n'),
+    (0x1D476, 'M', u'o'),
+    (0x1D477, 'M', u'p'),
+    (0x1D478, 'M', u'q'),
+    (0x1D479, 'M', u'r'),
+    (0x1D47A, 'M', u's'),
+    (0x1D47B, 'M', u't'),
+    (0x1D47C, 'M', u'u'),
+    (0x1D47D, 'M', u'v'),
+    (0x1D47E, 'M', u'w'),
+    (0x1D47F, 'M', u'x'),
+    (0x1D480, 'M', u'y'),
+    (0x1D481, 'M', u'z'),
+    (0x1D482, 'M', u'a'),
+    (0x1D483, 'M', u'b'),
+    (0x1D484, 'M', u'c'),
+    (0x1D485, 'M', u'd'),
+    (0x1D486, 'M', u'e'),
+    (0x1D487, 'M', u'f'),
+    (0x1D488, 'M', u'g'),
+    (0x1D489, 'M', u'h'),
+    (0x1D48A, 'M', u'i'),
+    (0x1D48B, 'M', u'j'),
+    (0x1D48C, 'M', u'k'),
+    (0x1D48D, 'M', u'l'),
+    (0x1D48E, 'M', u'm'),
+    (0x1D48F, 'M', u'n'),
+    (0x1D490, 'M', u'o'),
+    (0x1D491, 'M', u'p'),
+    (0x1D492, 'M', u'q'),
+    (0x1D493, 'M', u'r'),
+    (0x1D494, 'M', u's'),
+    (0x1D495, 'M', u't'),
+    (0x1D496, 'M', u'u'),
+    (0x1D497, 'M', u'v'),
+    (0x1D498, 'M', u'w'),
+    (0x1D499, 'M', u'x'),
+    (0x1D49A, 'M', u'y'),
+    (0x1D49B, 'M', u'z'),
+    (0x1D49C, 'M', u'a'),
+    (0x1D49D, 'X'),
+    (0x1D49E, 'M', u'c'),
+    (0x1D49F, 'M', u'd'),
+    (0x1D4A0, 'X'),
+    (0x1D4A2, 'M', u'g'),
+    (0x1D4A3, 'X'),
+    (0x1D4A5, 'M', u'j'),
+    (0x1D4A6, 'M', u'k'),
+    (0x1D4A7, 'X'),
+    (0x1D4A9, 'M', u'n'),
+    (0x1D4AA, 'M', u'o'),
+    (0x1D4AB, 'M', u'p'),
+    (0x1D4AC, 'M', u'q'),
+    (0x1D4AD, 'X'),
+    (0x1D4AE, 'M', u's'),
+    (0x1D4AF, 'M', u't'),
+    (0x1D4B0, 'M', u'u'),
+    (0x1D4B1, 'M', u'v'),
+    (0x1D4B2, 'M', u'w'),
+    (0x1D4B3, 'M', u'x'),
+    (0x1D4B4, 'M', u'y'),
+    (0x1D4B5, 'M', u'z'),
+    (0x1D4B6, 'M', u'a'),
+    (0x1D4B7, 'M', u'b'),
+    (0x1D4B8, 'M', u'c'),
+    ]
+
+def _seg_61():
+    return [
+    (0x1D4B9, 'M', u'd'),
+    (0x1D4BA, 'X'),
+    (0x1D4BB, 'M', u'f'),
+    (0x1D4BC, 'X'),
+    (0x1D4BD, 'M', u'h'),
+    (0x1D4BE, 'M', u'i'),
+    (0x1D4BF, 'M', u'j'),
+    (0x1D4C0, 'M', u'k'),
+    (0x1D4C1, 'M', u'l'),
+    (0x1D4C2, 'M', u'm'),
+    (0x1D4C3, 'M', u'n'),
+    (0x1D4C4, 'X'),
+    (0x1D4C5, 'M', u'p'),
+    (0x1D4C6, 'M', u'q'),
+    (0x1D4C7, 'M', u'r'),
+    (0x1D4C8, 'M', u's'),
+    (0x1D4C9, 'M', u't'),
+    (0x1D4CA, 'M', u'u'),
+    (0x1D4CB, 'M', u'v'),
+    (0x1D4CC, 'M', u'w'),
+    (0x1D4CD, 'M', u'x'),
+    (0x1D4CE, 'M', u'y'),
+    (0x1D4CF, 'M', u'z'),
+    (0x1D4D0, 'M', u'a'),
+    (0x1D4D1, 'M', u'b'),
+    (0x1D4D2, 'M', u'c'),
+    (0x1D4D3, 'M', u'd'),
+    (0x1D4D4, 'M', u'e'),
+    (0x1D4D5, 'M', u'f'),
+    (0x1D4D6, 'M', u'g'),
+    (0x1D4D7, 'M', u'h'),
+    (0x1D4D8, 'M', u'i'),
+    (0x1D4D9, 'M', u'j'),
+    (0x1D4DA, 'M', u'k'),
+    (0x1D4DB, 'M', u'l'),
+    (0x1D4DC, 'M', u'm'),
+    (0x1D4DD, 'M', u'n'),
+    (0x1D4DE, 'M', u'o'),
+    (0x1D4DF, 'M', u'p'),
+    (0x1D4E0, 'M', u'q'),
+    (0x1D4E1, 'M', u'r'),
+    (0x1D4E2, 'M', u's'),
+    (0x1D4E3, 'M', u't'),
+    (0x1D4E4, 'M', u'u'),
+    (0x1D4E5, 'M', u'v'),
+    (0x1D4E6, 'M', u'w'),
+    (0x1D4E7, 'M', u'x'),
+    (0x1D4E8, 'M', u'y'),
+    (0x1D4E9, 'M', u'z'),
+    (0x1D4EA, 'M', u'a'),
+    (0x1D4EB, 'M', u'b'),
+    (0x1D4EC, 'M', u'c'),
+    (0x1D4ED, 'M', u'd'),
+    (0x1D4EE, 'M', u'e'),
+    (0x1D4EF, 'M', u'f'),
+    (0x1D4F0, 'M', u'g'),
+    (0x1D4F1, 'M', u'h'),
+    (0x1D4F2, 'M', u'i'),
+    (0x1D4F3, 'M', u'j'),
+    (0x1D4F4, 'M', u'k'),
+    (0x1D4F5, 'M', u'l'),
+    (0x1D4F6, 'M', u'm'),
+    (0x1D4F7, 'M', u'n'),
+    (0x1D4F8, 'M', u'o'),
+    (0x1D4F9, 'M', u'p'),
+    (0x1D4FA, 'M', u'q'),
+    (0x1D4FB, 'M', u'r'),
+    (0x1D4FC, 'M', u's'),
+    (0x1D4FD, 'M', u't'),
+    (0x1D4FE, 'M', u'u'),
+    (0x1D4FF, 'M', u'v'),
+    (0x1D500, 'M', u'w'),
+    (0x1D501, 'M', u'x'),
+    (0x1D502, 'M', u'y'),
+    (0x1D503, 'M', u'z'),
+    (0x1D504, 'M', u'a'),
+    (0x1D505, 'M', u'b'),
+    (0x1D506, 'X'),
+    (0x1D507, 'M', u'd'),
+    (0x1D508, 'M', u'e'),
+    (0x1D509, 'M', u'f'),
+    (0x1D50A, 'M', u'g'),
+    (0x1D50B, 'X'),
+    (0x1D50D, 'M', u'j'),
+    (0x1D50E, 'M', u'k'),
+    (0x1D50F, 'M', u'l'),
+    (0x1D510, 'M', u'm'),
+    (0x1D511, 'M', u'n'),
+    (0x1D512, 'M', u'o'),
+    (0x1D513, 'M', u'p'),
+    (0x1D514, 'M', u'q'),
+    (0x1D515, 'X'),
+    (0x1D516, 'M', u's'),
+    (0x1D517, 'M', u't'),
+    (0x1D518, 'M', u'u'),
+    (0x1D519, 'M', u'v'),
+    (0x1D51A, 'M', u'w'),
+    (0x1D51B, 'M', u'x'),
+    (0x1D51C, 'M', u'y'),
+    (0x1D51D, 'X'),
+    ]
+
+def _seg_62():
+    return [
+    (0x1D51E, 'M', u'a'),
+    (0x1D51F, 'M', u'b'),
+    (0x1D520, 'M', u'c'),
+    (0x1D521, 'M', u'd'),
+    (0x1D522, 'M', u'e'),
+    (0x1D523, 'M', u'f'),
+    (0x1D524, 'M', u'g'),
+    (0x1D525, 'M', u'h'),
+    (0x1D526, 'M', u'i'),
+    (0x1D527, 'M', u'j'),
+    (0x1D528, 'M', u'k'),
+    (0x1D529, 'M', u'l'),
+    (0x1D52A, 'M', u'm'),
+    (0x1D52B, 'M', u'n'),
+    (0x1D52C, 'M', u'o'),
+    (0x1D52D, 'M', u'p'),
+    (0x1D52E, 'M', u'q'),
+    (0x1D52F, 'M', u'r'),
+    (0x1D530, 'M', u's'),
+    (0x1D531, 'M', u't'),
+    (0x1D532, 'M', u'u'),
+    (0x1D533, 'M', u'v'),
+    (0x1D534, 'M', u'w'),
+    (0x1D535, 'M', u'x'),
+    (0x1D536, 'M', u'y'),
+    (0x1D537, 'M', u'z'),
+    (0x1D538, 'M', u'a'),
+    (0x1D539, 'M', u'b'),
+    (0x1D53A, 'X'),
+    (0x1D53B, 'M', u'd'),
+    (0x1D53C, 'M', u'e'),
+    (0x1D53D, 'M', u'f'),
+    (0x1D53E, 'M', u'g'),
+    (0x1D53F, 'X'),
+    (0x1D540, 'M', u'i'),
+    (0x1D541, 'M', u'j'),
+    (0x1D542, 'M', u'k'),
+    (0x1D543, 'M', u'l'),
+    (0x1D544, 'M', u'm'),
+    (0x1D545, 'X'),
+    (0x1D546, 'M', u'o'),
+    (0x1D547, 'X'),
+    (0x1D54A, 'M', u's'),
+    (0x1D54B, 'M', u't'),
+    (0x1D54C, 'M', u'u'),
+    (0x1D54D, 'M', u'v'),
+    (0x1D54E, 'M', u'w'),
+    (0x1D54F, 'M', u'x'),
+    (0x1D550, 'M', u'y'),
+    (0x1D551, 'X'),
+    (0x1D552, 'M', u'a'),
+    (0x1D553, 'M', u'b'),
+    (0x1D554, 'M', u'c'),
+    (0x1D555, 'M', u'd'),
+    (0x1D556, 'M', u'e'),
+    (0x1D557, 'M', u'f'),
+    (0x1D558, 'M', u'g'),
+    (0x1D559, 'M', u'h'),
+    (0x1D55A, 'M', u'i'),
+    (0x1D55B, 'M', u'j'),
+    (0x1D55C, 'M', u'k'),
+    (0x1D55D, 'M', u'l'),
+    (0x1D55E, 'M', u'm'),
+    (0x1D55F, 'M', u'n'),
+    (0x1D560, 'M', u'o'),
+    (0x1D561, 'M', u'p'),
+    (0x1D562, 'M', u'q'),
+    (0x1D563, 'M', u'r'),
+    (0x1D564, 'M', u's'),
+    (0x1D565, 'M', u't'),
+    (0x1D566, 'M', u'u'),
+    (0x1D567, 'M', u'v'),
+    (0x1D568, 'M', u'w'),
+    (0x1D569, 'M', u'x'),
+    (0x1D56A, 'M', u'y'),
+    (0x1D56B, 'M', u'z'),
+    (0x1D56C, 'M', u'a'),
+    (0x1D56D, 'M', u'b'),
+    (0x1D56E, 'M', u'c'),
+    (0x1D56F, 'M', u'd'),
+    (0x1D570, 'M', u'e'),
+    (0x1D571, 'M', u'f'),
+    (0x1D572, 'M', u'g'),
+    (0x1D573, 'M', u'h'),
+    (0x1D574, 'M', u'i'),
+    (0x1D575, 'M', u'j'),
+    (0x1D576, 'M', u'k'),
+    (0x1D577, 'M', u'l'),
+    (0x1D578, 'M', u'm'),
+    (0x1D579, 'M', u'n'),
+    (0x1D57A, 'M', u'o'),
+    (0x1D57B, 'M', u'p'),
+    (0x1D57C, 'M', u'q'),
+    (0x1D57D, 'M', u'r'),
+    (0x1D57E, 'M', u's'),
+    (0x1D57F, 'M', u't'),
+    (0x1D580, 'M', u'u'),
+    (0x1D581, 'M', u'v'),
+    (0x1D582, 'M', u'w'),
+    (0x1D583, 'M', u'x'),
+    ]
+
+def _seg_63():
+    return [
+    (0x1D584, 'M', u'y'),
+    (0x1D585, 'M', u'z'),
+    (0x1D586, 'M', u'a'),
+    (0x1D587, 'M', u'b'),
+    (0x1D588, 'M', u'c'),
+    (0x1D589, 'M', u'd'),
+    (0x1D58A, 'M', u'e'),
+    (0x1D58B, 'M', u'f'),
+    (0x1D58C, 'M', u'g'),
+    (0x1D58D, 'M', u'h'),
+    (0x1D58E, 'M', u'i'),
+    (0x1D58F, 'M', u'j'),
+    (0x1D590, 'M', u'k'),
+    (0x1D591, 'M', u'l'),
+    (0x1D592, 'M', u'm'),
+    (0x1D593, 'M', u'n'),
+    (0x1D594, 'M', u'o'),
+    (0x1D595, 'M', u'p'),
+    (0x1D596, 'M', u'q'),
+    (0x1D597, 'M', u'r'),
+    (0x1D598, 'M', u's'),
+    (0x1D599, 'M', u't'),
+    (0x1D59A, 'M', u'u'),
+    (0x1D59B, 'M', u'v'),
+    (0x1D59C, 'M', u'w'),
+    (0x1D59D, 'M', u'x'),
+    (0x1D59E, 'M', u'y'),
+    (0x1D59F, 'M', u'z'),
+    (0x1D5A0, 'M', u'a'),
+    (0x1D5A1, 'M', u'b'),
+    (0x1D5A2, 'M', u'c'),
+    (0x1D5A3, 'M', u'd'),
+    (0x1D5A4, 'M', u'e'),
+    (0x1D5A5, 'M', u'f'),
+    (0x1D5A6, 'M', u'g'),
+    (0x1D5A7, 'M', u'h'),
+    (0x1D5A8, 'M', u'i'),
+    (0x1D5A9, 'M', u'j'),
+    (0x1D5AA, 'M', u'k'),
+    (0x1D5AB, 'M', u'l'),
+    (0x1D5AC, 'M', u'm'),
+    (0x1D5AD, 'M', u'n'),
+    (0x1D5AE, 'M', u'o'),
+    (0x1D5AF, 'M', u'p'),
+    (0x1D5B0, 'M', u'q'),
+    (0x1D5B1, 'M', u'r'),
+    (0x1D5B2, 'M', u's'),
+    (0x1D5B3, 'M', u't'),
+    (0x1D5B4, 'M', u'u'),
+    (0x1D5B5, 'M', u'v'),
+    (0x1D5B6, 'M', u'w'),
+    (0x1D5B7, 'M', u'x'),
+    (0x1D5B8, 'M', u'y'),
+    (0x1D5B9, 'M', u'z'),
+    (0x1D5BA, 'M', u'a'),
+    (0x1D5BB, 'M', u'b'),
+    (0x1D5BC, 'M', u'c'),
+    (0x1D5BD, 'M', u'd'),
+    (0x1D5BE, 'M', u'e'),
+    (0x1D5BF, 'M', u'f'),
+    (0x1D5C0, 'M', u'g'),
+    (0x1D5C1, 'M', u'h'),
+    (0x1D5C2, 'M', u'i'),
+    (0x1D5C3, 'M', u'j'),
+    (0x1D5C4, 'M', u'k'),
+    (0x1D5C5, 'M', u'l'),
+    (0x1D5C6, 'M', u'm'),
+    (0x1D5C7, 'M', u'n'),
+    (0x1D5C8, 'M', u'o'),
+    (0x1D5C9, 'M', u'p'),
+    (0x1D5CA, 'M', u'q'),
+    (0x1D5CB, 'M', u'r'),
+    (0x1D5CC, 'M', u's'),
+    (0x1D5CD, 'M', u't'),
+    (0x1D5CE, 'M', u'u'),
+    (0x1D5CF, 'M', u'v'),
+    (0x1D5D0, 'M', u'w'),
+    (0x1D5D1, 'M', u'x'),
+    (0x1D5D2, 'M', u'y'),
+    (0x1D5D3, 'M', u'z'),
+    (0x1D5D4, 'M', u'a'),
+    (0x1D5D5, 'M', u'b'),
+    (0x1D5D6, 'M', u'c'),
+    (0x1D5D7, 'M', u'd'),
+    (0x1D5D8, 'M', u'e'),
+    (0x1D5D9, 'M', u'f'),
+    (0x1D5DA, 'M', u'g'),
+    (0x1D5DB, 'M', u'h'),
+    (0x1D5DC, 'M', u'i'),
+    (0x1D5DD, 'M', u'j'),
+    (0x1D5DE, 'M', u'k'),
+    (0x1D5DF, 'M', u'l'),
+    (0x1D5E0, 'M', u'm'),
+    (0x1D5E1, 'M', u'n'),
+    (0x1D5E2, 'M', u'o'),
+    (0x1D5E3, 'M', u'p'),
+    (0x1D5E4, 'M', u'q'),
+    (0x1D5E5, 'M', u'r'),
+    (0x1D5E6, 'M', u's'),
+    (0x1D5E7, 'M', u't'),
+    ]
+
+def _seg_64():
+    return [
+    (0x1D5E8, 'M', u'u'),
+    (0x1D5E9, 'M', u'v'),
+    (0x1D5EA, 'M', u'w'),
+    (0x1D5EB, 'M', u'x'),
+    (0x1D5EC, 'M', u'y'),
+    (0x1D5ED, 'M', u'z'),
+    (0x1D5EE, 'M', u'a'),
+    (0x1D5EF, 'M', u'b'),
+    (0x1D5F0, 'M', u'c'),
+    (0x1D5F1, 'M', u'd'),
+    (0x1D5F2, 'M', u'e'),
+    (0x1D5F3, 'M', u'f'),
+    (0x1D5F4, 'M', u'g'),
+    (0x1D5F5, 'M', u'h'),
+    (0x1D5F6, 'M', u'i'),
+    (0x1D5F7, 'M', u'j'),
+    (0x1D5F8, 'M', u'k'),
+    (0x1D5F9, 'M', u'l'),
+    (0x1D5FA, 'M', u'm'),
+    (0x1D5FB, 'M', u'n'),
+    (0x1D5FC, 'M', u'o'),
+    (0x1D5FD, 'M', u'p'),
+    (0x1D5FE, 'M', u'q'),
+    (0x1D5FF, 'M', u'r'),
+    (0x1D600, 'M', u's'),
+    (0x1D601, 'M', u't'),
+    (0x1D602, 'M', u'u'),
+    (0x1D603, 'M', u'v'),
+    (0x1D604, 'M', u'w'),
+    (0x1D605, 'M', u'x'),
+    (0x1D606, 'M', u'y'),
+    (0x1D607, 'M', u'z'),
+    (0x1D608, 'M', u'a'),
+    (0x1D609, 'M', u'b'),
+    (0x1D60A, 'M', u'c'),
+    (0x1D60B, 'M', u'd'),
+    (0x1D60C, 'M', u'e'),
+    (0x1D60D, 'M', u'f'),
+    (0x1D60E, 'M', u'g'),
+    (0x1D60F, 'M', u'h'),
+    (0x1D610, 'M', u'i'),
+    (0x1D611, 'M', u'j'),
+    (0x1D612, 'M', u'k'),
+    (0x1D613, 'M', u'l'),
+    (0x1D614, 'M', u'm'),
+    (0x1D615, 'M', u'n'),
+    (0x1D616, 'M', u'o'),
+    (0x1D617, 'M', u'p'),
+    (0x1D618, 'M', u'q'),
+    (0x1D619, 'M', u'r'),
+    (0x1D61A, 'M', u's'),
+    (0x1D61B, 'M', u't'),
+    (0x1D61C, 'M', u'u'),
+    (0x1D61D, 'M', u'v'),
+    (0x1D61E, 'M', u'w'),
+    (0x1D61F, 'M', u'x'),
+    (0x1D620, 'M', u'y'),
+    (0x1D621, 'M', u'z'),
+    (0x1D622, 'M', u'a'),
+    (0x1D623, 'M', u'b'),
+    (0x1D624, 'M', u'c'),
+    (0x1D625, 'M', u'd'),
+    (0x1D626, 'M', u'e'),
+    (0x1D627, 'M', u'f'),
+    (0x1D628, 'M', u'g'),
+    (0x1D629, 'M', u'h'),
+    (0x1D62A, 'M', u'i'),
+    (0x1D62B, 'M', u'j'),
+    (0x1D62C, 'M', u'k'),
+    (0x1D62D, 'M', u'l'),
+    (0x1D62E, 'M', u'm'),
+    (0x1D62F, 'M', u'n'),
+    (0x1D630, 'M', u'o'),
+    (0x1D631, 'M', u'p'),
+    (0x1D632, 'M', u'q'),
+    (0x1D633, 'M', u'r'),
+    (0x1D634, 'M', u's'),
+    (0x1D635, 'M', u't'),
+    (0x1D636, 'M', u'u'),
+    (0x1D637, 'M', u'v'),
+    (0x1D638, 'M', u'w'),
+    (0x1D639, 'M', u'x'),
+    (0x1D63A, 'M', u'y'),
+    (0x1D63B, 'M', u'z'),
+    (0x1D63C, 'M', u'a'),
+    (0x1D63D, 'M', u'b'),
+    (0x1D63E, 'M', u'c'),
+    (0x1D63F, 'M', u'd'),
+    (0x1D640, 'M', u'e'),
+    (0x1D641, 'M', u'f'),
+    (0x1D642, 'M', u'g'),
+    (0x1D643, 'M', u'h'),
+    (0x1D644, 'M', u'i'),
+    (0x1D645, 'M', u'j'),
+    (0x1D646, 'M', u'k'),
+    (0x1D647, 'M', u'l'),
+    (0x1D648, 'M', u'm'),
+    (0x1D649, 'M', u'n'),
+    (0x1D64A, 'M', u'o'),
+    (0x1D64B, 'M', u'p'),
+    ]
+
+def _seg_65():
+    return [
+    (0x1D64C, 'M', u'q'),
+    (0x1D64D, 'M', u'r'),
+    (0x1D64E, 'M', u's'),
+    (0x1D64F, 'M', u't'),
+    (0x1D650, 'M', u'u'),
+    (0x1D651, 'M', u'v'),
+    (0x1D652, 'M', u'w'),
+    (0x1D653, 'M', u'x'),
+    (0x1D654, 'M', u'y'),
+    (0x1D655, 'M', u'z'),
+    (0x1D656, 'M', u'a'),
+    (0x1D657, 'M', u'b'),
+    (0x1D658, 'M', u'c'),
+    (0x1D659, 'M', u'd'),
+    (0x1D65A, 'M', u'e'),
+    (0x1D65B, 'M', u'f'),
+    (0x1D65C, 'M', u'g'),
+    (0x1D65D, 'M', u'h'),
+    (0x1D65E, 'M', u'i'),
+    (0x1D65F, 'M', u'j'),
+    (0x1D660, 'M', u'k'),
+    (0x1D661, 'M', u'l'),
+    (0x1D662, 'M', u'm'),
+    (0x1D663, 'M', u'n'),
+    (0x1D664, 'M', u'o'),
+    (0x1D665, 'M', u'p'),
+    (0x1D666, 'M', u'q'),
+    (0x1D667, 'M', u'r'),
+    (0x1D668, 'M', u's'),
+    (0x1D669, 'M', u't'),
+    (0x1D66A, 'M', u'u'),
+    (0x1D66B, 'M', u'v'),
+    (0x1D66C, 'M', u'w'),
+    (0x1D66D, 'M', u'x'),
+    (0x1D66E, 'M', u'y'),
+    (0x1D66F, 'M', u'z'),
+    (0x1D670, 'M', u'a'),
+    (0x1D671, 'M', u'b'),
+    (0x1D672, 'M', u'c'),
+    (0x1D673, 'M', u'd'),
+    (0x1D674, 'M', u'e'),
+    (0x1D675, 'M', u'f'),
+    (0x1D676, 'M', u'g'),
+    (0x1D677, 'M', u'h'),
+    (0x1D678, 'M', u'i'),
+    (0x1D679, 'M', u'j'),
+    (0x1D67A, 'M', u'k'),
+    (0x1D67B, 'M', u'l'),
+    (0x1D67C, 'M', u'm'),
+    (0x1D67D, 'M', u'n'),
+    (0x1D67E, 'M', u'o'),
+    (0x1D67F, 'M', u'p'),
+    (0x1D680, 'M', u'q'),
+    (0x1D681, 'M', u'r'),
+    (0x1D682, 'M', u's'),
+    (0x1D683, 'M', u't'),
+    (0x1D684, 'M', u'u'),
+    (0x1D685, 'M', u'v'),
+    (0x1D686, 'M', u'w'),
+    (0x1D687, 'M', u'x'),
+    (0x1D688, 'M', u'y'),
+    (0x1D689, 'M', u'z'),
+    (0x1D68A, 'M', u'a'),
+    (0x1D68B, 'M', u'b'),
+    (0x1D68C, 'M', u'c'),
+    (0x1D68D, 'M', u'd'),
+    (0x1D68E, 'M', u'e'),
+    (0x1D68F, 'M', u'f'),
+    (0x1D690, 'M', u'g'),
+    (0x1D691, 'M', u'h'),
+    (0x1D692, 'M', u'i'),
+    (0x1D693, 'M', u'j'),
+    (0x1D694, 'M', u'k'),
+    (0x1D695, 'M', u'l'),
+    (0x1D696, 'M', u'm'),
+    (0x1D697, 'M', u'n'),
+    (0x1D698, 'M', u'o'),
+    (0x1D699, 'M', u'p'),
+    (0x1D69A, 'M', u'q'),
+    (0x1D69B, 'M', u'r'),
+    (0x1D69C, 'M', u's'),
+    (0x1D69D, 'M', u't'),
+    (0x1D69E, 'M', u'u'),
+    (0x1D69F, 'M', u'v'),
+    (0x1D6A0, 'M', u'w'),
+    (0x1D6A1, 'M', u'x'),
+    (0x1D6A2, 'M', u'y'),
+    (0x1D6A3, 'M', u'z'),
+    (0x1D6A4, 'M', u'ı'),
+    (0x1D6A5, 'M', u'ȷ'),
+    (0x1D6A6, 'X'),
+    (0x1D6A8, 'M', u'α'),
+    (0x1D6A9, 'M', u'β'),
+    (0x1D6AA, 'M', u'γ'),
+    (0x1D6AB, 'M', u'δ'),
+    (0x1D6AC, 'M', u'ε'),
+    (0x1D6AD, 'M', u'ζ'),
+    (0x1D6AE, 'M', u'η'),
+    (0x1D6AF, 'M', u'θ'),
+    (0x1D6B0, 'M', u'ι'),
+    ]
+
+def _seg_66():
+    return [
+    (0x1D6B1, 'M', u'κ'),
+    (0x1D6B2, 'M', u'λ'),
+    (0x1D6B3, 'M', u'μ'),
+    (0x1D6B4, 'M', u'ν'),
+    (0x1D6B5, 'M', u'ξ'),
+    (0x1D6B6, 'M', u'ο'),
+    (0x1D6B7, 'M', u'π'),
+    (0x1D6B8, 'M', u'ρ'),
+    (0x1D6B9, 'M', u'θ'),
+    (0x1D6BA, 'M', u'σ'),
+    (0x1D6BB, 'M', u'τ'),
+    (0x1D6BC, 'M', u'υ'),
+    (0x1D6BD, 'M', u'φ'),
+    (0x1D6BE, 'M', u'χ'),
+    (0x1D6BF, 'M', u'ψ'),
+    (0x1D6C0, 'M', u'ω'),
+    (0x1D6C1, 'M', u'∇'),
+    (0x1D6C2, 'M', u'α'),
+    (0x1D6C3, 'M', u'β'),
+    (0x1D6C4, 'M', u'γ'),
+    (0x1D6C5, 'M', u'δ'),
+    (0x1D6C6, 'M', u'ε'),
+    (0x1D6C7, 'M', u'ζ'),
+    (0x1D6C8, 'M', u'η'),
+    (0x1D6C9, 'M', u'θ'),
+    (0x1D6CA, 'M', u'ι'),
+    (0x1D6CB, 'M', u'κ'),
+    (0x1D6CC, 'M', u'λ'),
+    (0x1D6CD, 'M', u'μ'),
+    (0x1D6CE, 'M', u'ν'),
+    (0x1D6CF, 'M', u'ξ'),
+    (0x1D6D0, 'M', u'ο'),
+    (0x1D6D1, 'M', u'π'),
+    (0x1D6D2, 'M', u'ρ'),
+    (0x1D6D3, 'M', u'σ'),
+    (0x1D6D5, 'M', u'τ'),
+    (0x1D6D6, 'M', u'υ'),
+    (0x1D6D7, 'M', u'φ'),
+    (0x1D6D8, 'M', u'χ'),
+    (0x1D6D9, 'M', u'ψ'),
+    (0x1D6DA, 'M', u'ω'),
+    (0x1D6DB, 'M', u'∂'),
+    (0x1D6DC, 'M', u'ε'),
+    (0x1D6DD, 'M', u'θ'),
+    (0x1D6DE, 'M', u'κ'),
+    (0x1D6DF, 'M', u'φ'),
+    (0x1D6E0, 'M', u'ρ'),
+    (0x1D6E1, 'M', u'π'),
+    (0x1D6E2, 'M', u'α'),
+    (0x1D6E3, 'M', u'β'),
+    (0x1D6E4, 'M', u'γ'),
+    (0x1D6E5, 'M', u'δ'),
+    (0x1D6E6, 'M', u'ε'),
+    (0x1D6E7, 'M', u'ζ'),
+    (0x1D6E8, 'M', u'η'),
+    (0x1D6E9, 'M', u'θ'),
+    (0x1D6EA, 'M', u'ι'),
+    (0x1D6EB, 'M', u'κ'),
+    (0x1D6EC, 'M', u'λ'),
+    (0x1D6ED, 'M', u'μ'),
+    (0x1D6EE, 'M', u'ν'),
+    (0x1D6EF, 'M', u'ξ'),
+    (0x1D6F0, 'M', u'ο'),
+    (0x1D6F1, 'M', u'π'),
+    (0x1D6F2, 'M', u'ρ'),
+    (0x1D6F3, 'M', u'θ'),
+    (0x1D6F4, 'M', u'σ'),
+    (0x1D6F5, 'M', u'τ'),
+    (0x1D6F6, 'M', u'υ'),
+    (0x1D6F7, 'M', u'φ'),
+    (0x1D6F8, 'M', u'χ'),
+    (0x1D6F9, 'M', u'ψ'),
+    (0x1D6FA, 'M', u'ω'),
+    (0x1D6FB, 'M', u'∇'),
+    (0x1D6FC, 'M', u'α'),
+    (0x1D6FD, 'M', u'β'),
+    (0x1D6FE, 'M', u'γ'),
+    (0x1D6FF, 'M', u'δ'),
+    (0x1D700, 'M', u'ε'),
+    (0x1D701, 'M', u'ζ'),
+    (0x1D702, 'M', u'η'),
+    (0x1D703, 'M', u'θ'),
+    (0x1D704, 'M', u'ι'),
+    (0x1D705, 'M', u'κ'),
+    (0x1D706, 'M', u'λ'),
+    (0x1D707, 'M', u'μ'),
+    (0x1D708, 'M', u'ν'),
+    (0x1D709, 'M', u'ξ'),
+    (0x1D70A, 'M', u'ο'),
+    (0x1D70B, 'M', u'π'),
+    (0x1D70C, 'M', u'ρ'),
+    (0x1D70D, 'M', u'σ'),
+    (0x1D70F, 'M', u'τ'),
+    (0x1D710, 'M', u'υ'),
+    (0x1D711, 'M', u'φ'),
+    (0x1D712, 'M', u'χ'),
+    (0x1D713, 'M', u'ψ'),
+    (0x1D714, 'M', u'ω'),
+    (0x1D715, 'M', u'∂'),
+    (0x1D716, 'M', u'ε'),
+    ]
+
+def _seg_67():
+    return [
+    (0x1D717, 'M', u'θ'),
+    (0x1D718, 'M', u'κ'),
+    (0x1D719, 'M', u'φ'),
+    (0x1D71A, 'M', u'ρ'),
+    (0x1D71B, 'M', u'π'),
+    (0x1D71C, 'M', u'α'),
+    (0x1D71D, 'M', u'β'),
+    (0x1D71E, 'M', u'γ'),
+    (0x1D71F, 'M', u'δ'),
+    (0x1D720, 'M', u'ε'),
+    (0x1D721, 'M', u'ζ'),
+    (0x1D722, 'M', u'η'),
+    (0x1D723, 'M', u'θ'),
+    (0x1D724, 'M', u'ι'),
+    (0x1D725, 'M', u'κ'),
+    (0x1D726, 'M', u'λ'),
+    (0x1D727, 'M', u'μ'),
+    (0x1D728, 'M', u'ν'),
+    (0x1D729, 'M', u'ξ'),
+    (0x1D72A, 'M', u'ο'),
+    (0x1D72B, 'M', u'π'),
+    (0x1D72C, 'M', u'ρ'),
+    (0x1D72D, 'M', u'θ'),
+    (0x1D72E, 'M', u'σ'),
+    (0x1D72F, 'M', u'τ'),
+    (0x1D730, 'M', u'υ'),
+    (0x1D731, 'M', u'φ'),
+    (0x1D732, 'M', u'χ'),
+    (0x1D733, 'M', u'ψ'),
+    (0x1D734, 'M', u'ω'),
+    (0x1D735, 'M', u'∇'),
+    (0x1D736, 'M', u'α'),
+    (0x1D737, 'M', u'β'),
+    (0x1D738, 'M', u'γ'),
+    (0x1D739, 'M', u'δ'),
+    (0x1D73A, 'M', u'ε'),
+    (0x1D73B, 'M', u'ζ'),
+    (0x1D73C, 'M', u'η'),
+    (0x1D73D, 'M', u'θ'),
+    (0x1D73E, 'M', u'ι'),
+    (0x1D73F, 'M', u'κ'),
+    (0x1D740, 'M', u'λ'),
+    (0x1D741, 'M', u'μ'),
+    (0x1D742, 'M', u'ν'),
+    (0x1D743, 'M', u'ξ'),
+    (0x1D744, 'M', u'ο'),
+    (0x1D745, 'M', u'π'),
+    (0x1D746, 'M', u'ρ'),
+    (0x1D747, 'M', u'σ'),
+    (0x1D749, 'M', u'τ'),
+    (0x1D74A, 'M', u'υ'),
+    (0x1D74B, 'M', u'φ'),
+    (0x1D74C, 'M', u'χ'),
+    (0x1D74D, 'M', u'ψ'),
+    (0x1D74E, 'M', u'ω'),
+    (0x1D74F, 'M', u'∂'),
+    (0x1D750, 'M', u'ε'),
+    (0x1D751, 'M', u'θ'),
+    (0x1D752, 'M', u'κ'),
+    (0x1D753, 'M', u'φ'),
+    (0x1D754, 'M', u'ρ'),
+    (0x1D755, 'M', u'π'),
+    (0x1D756, 'M', u'α'),
+    (0x1D757, 'M', u'β'),
+    (0x1D758, 'M', u'γ'),
+    (0x1D759, 'M', u'δ'),
+    (0x1D75A, 'M', u'ε'),
+    (0x1D75B, 'M', u'ζ'),
+    (0x1D75C, 'M', u'η'),
+    (0x1D75D, 'M', u'θ'),
+    (0x1D75E, 'M', u'ι'),
+    (0x1D75F, 'M', u'κ'),
+    (0x1D760, 'M', u'λ'),
+    (0x1D761, 'M', u'μ'),
+    (0x1D762, 'M', u'ν'),
+    (0x1D763, 'M', u'ξ'),
+    (0x1D764, 'M', u'ο'),
+    (0x1D765, 'M', u'π'),
+    (0x1D766, 'M', u'ρ'),
+    (0x1D767, 'M', u'θ'),
+    (0x1D768, 'M', u'σ'),
+    (0x1D769, 'M', u'τ'),
+    (0x1D76A, 'M', u'υ'),
+    (0x1D76B, 'M', u'φ'),
+    (0x1D76C, 'M', u'χ'),
+    (0x1D76D, 'M', u'ψ'),
+    (0x1D76E, 'M', u'ω'),
+    (0x1D76F, 'M', u'∇'),
+    (0x1D770, 'M', u'α'),
+    (0x1D771, 'M', u'β'),
+    (0x1D772, 'M', u'γ'),
+    (0x1D773, 'M', u'δ'),
+    (0x1D774, 'M', u'ε'),
+    (0x1D775, 'M', u'ζ'),
+    (0x1D776, 'M', u'η'),
+    (0x1D777, 'M', u'θ'),
+    (0x1D778, 'M', u'ι'),
+    (0x1D779, 'M', u'κ'),
+    (0x1D77A, 'M', u'λ'),
+    (0x1D77B, 'M', u'μ'),
+    ]
+
+def _seg_68():
+    return [
+    (0x1D77C, 'M', u'ν'),
+    (0x1D77D, 'M', u'ξ'),
+    (0x1D77E, 'M', u'ο'),
+    (0x1D77F, 'M', u'π'),
+    (0x1D780, 'M', u'ρ'),
+    (0x1D781, 'M', u'σ'),
+    (0x1D783, 'M', u'τ'),
+    (0x1D784, 'M', u'υ'),
+    (0x1D785, 'M', u'φ'),
+    (0x1D786, 'M', u'χ'),
+    (0x1D787, 'M', u'ψ'),
+    (0x1D788, 'M', u'ω'),
+    (0x1D789, 'M', u'∂'),
+    (0x1D78A, 'M', u'ε'),
+    (0x1D78B, 'M', u'θ'),
+    (0x1D78C, 'M', u'κ'),
+    (0x1D78D, 'M', u'φ'),
+    (0x1D78E, 'M', u'ρ'),
+    (0x1D78F, 'M', u'π'),
+    (0x1D790, 'M', u'α'),
+    (0x1D791, 'M', u'β'),
+    (0x1D792, 'M', u'γ'),
+    (0x1D793, 'M', u'δ'),
+    (0x1D794, 'M', u'ε'),
+    (0x1D795, 'M', u'ζ'),
+    (0x1D796, 'M', u'η'),
+    (0x1D797, 'M', u'θ'),
+    (0x1D798, 'M', u'ι'),
+    (0x1D799, 'M', u'κ'),
+    (0x1D79A, 'M', u'λ'),
+    (0x1D79B, 'M', u'μ'),
+    (0x1D79C, 'M', u'ν'),
+    (0x1D79D, 'M', u'ξ'),
+    (0x1D79E, 'M', u'ο'),
+    (0x1D79F, 'M', u'π'),
+    (0x1D7A0, 'M', u'ρ'),
+    (0x1D7A1, 'M', u'θ'),
+    (0x1D7A2, 'M', u'σ'),
+    (0x1D7A3, 'M', u'τ'),
+    (0x1D7A4, 'M', u'υ'),
+    (0x1D7A5, 'M', u'φ'),
+    (0x1D7A6, 'M', u'χ'),
+    (0x1D7A7, 'M', u'ψ'),
+    (0x1D7A8, 'M', u'ω'),
+    (0x1D7A9, 'M', u'∇'),
+    (0x1D7AA, 'M', u'α'),
+    (0x1D7AB, 'M', u'β'),
+    (0x1D7AC, 'M', u'γ'),
+    (0x1D7AD, 'M', u'δ'),
+    (0x1D7AE, 'M', u'ε'),
+    (0x1D7AF, 'M', u'ζ'),
+    (0x1D7B0, 'M', u'η'),
+    (0x1D7B1, 'M', u'θ'),
+    (0x1D7B2, 'M', u'ι'),
+    (0x1D7B3, 'M', u'κ'),
+    (0x1D7B4, 'M', u'λ'),
+    (0x1D7B5, 'M', u'μ'),
+    (0x1D7B6, 'M', u'ν'),
+    (0x1D7B7, 'M', u'ξ'),
+    (0x1D7B8, 'M', u'ο'),
+    (0x1D7B9, 'M', u'π'),
+    (0x1D7BA, 'M', u'ρ'),
+    (0x1D7BB, 'M', u'σ'),
+    (0x1D7BD, 'M', u'τ'),
+    (0x1D7BE, 'M', u'υ'),
+    (0x1D7BF, 'M', u'φ'),
+    (0x1D7C0, 'M', u'χ'),
+    (0x1D7C1, 'M', u'ψ'),
+    (0x1D7C2, 'M', u'ω'),
+    (0x1D7C3, 'M', u'∂'),
+    (0x1D7C4, 'M', u'ε'),
+    (0x1D7C5, 'M', u'θ'),
+    (0x1D7C6, 'M', u'κ'),
+    (0x1D7C7, 'M', u'φ'),
+    (0x1D7C8, 'M', u'ρ'),
+    (0x1D7C9, 'M', u'π'),
+    (0x1D7CA, 'M', u'ϝ'),
+    (0x1D7CC, 'X'),
+    (0x1D7CE, 'M', u'0'),
+    (0x1D7CF, 'M', u'1'),
+    (0x1D7D0, 'M', u'2'),
+    (0x1D7D1, 'M', u'3'),
+    (0x1D7D2, 'M', u'4'),
+    (0x1D7D3, 'M', u'5'),
+    (0x1D7D4, 'M', u'6'),
+    (0x1D7D5, 'M', u'7'),
+    (0x1D7D6, 'M', u'8'),
+    (0x1D7D7, 'M', u'9'),
+    (0x1D7D8, 'M', u'0'),
+    (0x1D7D9, 'M', u'1'),
+    (0x1D7DA, 'M', u'2'),
+    (0x1D7DB, 'M', u'3'),
+    (0x1D7DC, 'M', u'4'),
+    (0x1D7DD, 'M', u'5'),
+    (0x1D7DE, 'M', u'6'),
+    (0x1D7DF, 'M', u'7'),
+    (0x1D7E0, 'M', u'8'),
+    (0x1D7E1, 'M', u'9'),
+    (0x1D7E2, 'M', u'0'),
+    (0x1D7E3, 'M', u'1'),
+    ]
+
+def _seg_69():
+    return [
+    (0x1D7E4, 'M', u'2'),
+    (0x1D7E5, 'M', u'3'),
+    (0x1D7E6, 'M', u'4'),
+    (0x1D7E7, 'M', u'5'),
+    (0x1D7E8, 'M', u'6'),
+    (0x1D7E9, 'M', u'7'),
+    (0x1D7EA, 'M', u'8'),
+    (0x1D7EB, 'M', u'9'),
+    (0x1D7EC, 'M', u'0'),
+    (0x1D7ED, 'M', u'1'),
+    (0x1D7EE, 'M', u'2'),
+    (0x1D7EF, 'M', u'3'),
+    (0x1D7F0, 'M', u'4'),
+    (0x1D7F1, 'M', u'5'),
+    (0x1D7F2, 'M', u'6'),
+    (0x1D7F3, 'M', u'7'),
+    (0x1D7F4, 'M', u'8'),
+    (0x1D7F5, 'M', u'9'),
+    (0x1D7F6, 'M', u'0'),
+    (0x1D7F7, 'M', u'1'),
+    (0x1D7F8, 'M', u'2'),
+    (0x1D7F9, 'M', u'3'),
+    (0x1D7FA, 'M', u'4'),
+    (0x1D7FB, 'M', u'5'),
+    (0x1D7FC, 'M', u'6'),
+    (0x1D7FD, 'M', u'7'),
+    (0x1D7FE, 'M', u'8'),
+    (0x1D7FF, 'M', u'9'),
+    (0x1D800, 'V'),
+    (0x1DA8C, 'X'),
+    (0x1DA9B, 'V'),
+    (0x1DAA0, 'X'),
+    (0x1DAA1, 'V'),
+    (0x1DAB0, 'X'),
+    (0x1E000, 'V'),
+    (0x1E007, 'X'),
+    (0x1E008, 'V'),
+    (0x1E019, 'X'),
+    (0x1E01B, 'V'),
+    (0x1E022, 'X'),
+    (0x1E023, 'V'),
+    (0x1E025, 'X'),
+    (0x1E026, 'V'),
+    (0x1E02B, 'X'),
+    (0x1E100, 'V'),
+    (0x1E12D, 'X'),
+    (0x1E130, 'V'),
+    (0x1E13E, 'X'),
+    (0x1E140, 'V'),
+    (0x1E14A, 'X'),
+    (0x1E14E, 'V'),
+    (0x1E150, 'X'),
+    (0x1E2C0, 'V'),
+    (0x1E2FA, 'X'),
+    (0x1E2FF, 'V'),
+    (0x1E300, 'X'),
+    (0x1E800, 'V'),
+    (0x1E8C5, 'X'),
+    (0x1E8C7, 'V'),
+    (0x1E8D7, 'X'),
+    (0x1E900, 'M', u'𞤢'),
+    (0x1E901, 'M', u'𞤣'),
+    (0x1E902, 'M', u'𞤤'),
+    (0x1E903, 'M', u'𞤥'),
+    (0x1E904, 'M', u'𞤦'),
+    (0x1E905, 'M', u'𞤧'),
+    (0x1E906, 'M', u'𞤨'),
+    (0x1E907, 'M', u'𞤩'),
+    (0x1E908, 'M', u'𞤪'),
+    (0x1E909, 'M', u'𞤫'),
+    (0x1E90A, 'M', u'𞤬'),
+    (0x1E90B, 'M', u'𞤭'),
+    (0x1E90C, 'M', u'𞤮'),
+    (0x1E90D, 'M', u'𞤯'),
+    (0x1E90E, 'M', u'𞤰'),
+    (0x1E90F, 'M', u'𞤱'),
+    (0x1E910, 'M', u'𞤲'),
+    (0x1E911, 'M', u'𞤳'),
+    (0x1E912, 'M', u'𞤴'),
+    (0x1E913, 'M', u'𞤵'),
+    (0x1E914, 'M', u'𞤶'),
+    (0x1E915, 'M', u'𞤷'),
+    (0x1E916, 'M', u'𞤸'),
+    (0x1E917, 'M', u'𞤹'),
+    (0x1E918, 'M', u'𞤺'),
+    (0x1E919, 'M', u'𞤻'),
+    (0x1E91A, 'M', u'𞤼'),
+    (0x1E91B, 'M', u'𞤽'),
+    (0x1E91C, 'M', u'𞤾'),
+    (0x1E91D, 'M', u'𞤿'),
+    (0x1E91E, 'M', u'𞥀'),
+    (0x1E91F, 'M', u'𞥁'),
+    (0x1E920, 'M', u'𞥂'),
+    (0x1E921, 'M', u'𞥃'),
+    (0x1E922, 'V'),
+    (0x1E94C, 'X'),
+    (0x1E950, 'V'),
+    (0x1E95A, 'X'),
+    (0x1E95E, 'V'),
+    (0x1E960, 'X'),
+    ]
+
+def _seg_70():
+    return [
+    (0x1EC71, 'V'),
+    (0x1ECB5, 'X'),
+    (0x1ED01, 'V'),
+    (0x1ED3E, 'X'),
+    (0x1EE00, 'M', u'ا'),
+    (0x1EE01, 'M', u'ب'),
+    (0x1EE02, 'M', u'ج'),
+    (0x1EE03, 'M', u'د'),
+    (0x1EE04, 'X'),
+    (0x1EE05, 'M', u'و'),
+    (0x1EE06, 'M', u'ز'),
+    (0x1EE07, 'M', u'ح'),
+    (0x1EE08, 'M', u'ط'),
+    (0x1EE09, 'M', u'ي'),
+    (0x1EE0A, 'M', u'ك'),
+    (0x1EE0B, 'M', u'ل'),
+    (0x1EE0C, 'M', u'م'),
+    (0x1EE0D, 'M', u'ن'),
+    (0x1EE0E, 'M', u'س'),
+    (0x1EE0F, 'M', u'ع'),
+    (0x1EE10, 'M', u'ف'),
+    (0x1EE11, 'M', u'ص'),
+    (0x1EE12, 'M', u'ق'),
+    (0x1EE13, 'M', u'ر'),
+    (0x1EE14, 'M', u'ش'),
+    (0x1EE15, 'M', u'ت'),
+    (0x1EE16, 'M', u'ث'),
+    (0x1EE17, 'M', u'خ'),
+    (0x1EE18, 'M', u'ذ'),
+    (0x1EE19, 'M', u'ض'),
+    (0x1EE1A, 'M', u'ظ'),
+    (0x1EE1B, 'M', u'غ'),
+    (0x1EE1C, 'M', u'ٮ'),
+    (0x1EE1D, 'M', u'ں'),
+    (0x1EE1E, 'M', u'ڡ'),
+    (0x1EE1F, 'M', u'ٯ'),
+    (0x1EE20, 'X'),
+    (0x1EE21, 'M', u'ب'),
+    (0x1EE22, 'M', u'ج'),
+    (0x1EE23, 'X'),
+    (0x1EE24, 'M', u'ه'),
+    (0x1EE25, 'X'),
+    (0x1EE27, 'M', u'ح'),
+    (0x1EE28, 'X'),
+    (0x1EE29, 'M', u'ي'),
+    (0x1EE2A, 'M', u'ك'),
+    (0x1EE2B, 'M', u'ل'),
+    (0x1EE2C, 'M', u'م'),
+    (0x1EE2D, 'M', u'ن'),
+    (0x1EE2E, 'M', u'س'),
+    (0x1EE2F, 'M', u'ع'),
+    (0x1EE30, 'M', u'ف'),
+    (0x1EE31, 'M', u'ص'),
+    (0x1EE32, 'M', u'ق'),
+    (0x1EE33, 'X'),
+    (0x1EE34, 'M', u'ش'),
+    (0x1EE35, 'M', u'ت'),
+    (0x1EE36, 'M', u'ث'),
+    (0x1EE37, 'M', u'خ'),
+    (0x1EE38, 'X'),
+    (0x1EE39, 'M', u'ض'),
+    (0x1EE3A, 'X'),
+    (0x1EE3B, 'M', u'غ'),
+    (0x1EE3C, 'X'),
+    (0x1EE42, 'M', u'ج'),
+    (0x1EE43, 'X'),
+    (0x1EE47, 'M', u'ح'),
+    (0x1EE48, 'X'),
+    (0x1EE49, 'M', u'ي'),
+    (0x1EE4A, 'X'),
+    (0x1EE4B, 'M', u'ل'),
+    (0x1EE4C, 'X'),
+    (0x1EE4D, 'M', u'ن'),
+    (0x1EE4E, 'M', u'س'),
+    (0x1EE4F, 'M', u'ع'),
+    (0x1EE50, 'X'),
+    (0x1EE51, 'M', u'ص'),
+    (0x1EE52, 'M', u'ق'),
+    (0x1EE53, 'X'),
+    (0x1EE54, 'M', u'ش'),
+    (0x1EE55, 'X'),
+    (0x1EE57, 'M', u'خ'),
+    (0x1EE58, 'X'),
+    (0x1EE59, 'M', u'ض'),
+    (0x1EE5A, 'X'),
+    (0x1EE5B, 'M', u'غ'),
+    (0x1EE5C, 'X'),
+    (0x1EE5D, 'M', u'ں'),
+    (0x1EE5E, 'X'),
+    (0x1EE5F, 'M', u'ٯ'),
+    (0x1EE60, 'X'),
+    (0x1EE61, 'M', u'ب'),
+    (0x1EE62, 'M', u'ج'),
+    (0x1EE63, 'X'),
+    (0x1EE64, 'M', u'ه'),
+    (0x1EE65, 'X'),
+    (0x1EE67, 'M', u'ح'),
+    (0x1EE68, 'M', u'ط'),
+    (0x1EE69, 'M', u'ي'),
+    (0x1EE6A, 'M', u'ك'),
+    ]
+
+def _seg_71():
+    return [
+    (0x1EE6B, 'X'),
+    (0x1EE6C, 'M', u'م'),
+    (0x1EE6D, 'M', u'ن'),
+    (0x1EE6E, 'M', u'س'),
+    (0x1EE6F, 'M', u'ع'),
+    (0x1EE70, 'M', u'ف'),
+    (0x1EE71, 'M', u'ص'),
+    (0x1EE72, 'M', u'ق'),
+    (0x1EE73, 'X'),
+    (0x1EE74, 'M', u'ش'),
+    (0x1EE75, 'M', u'ت'),
+    (0x1EE76, 'M', u'ث'),
+    (0x1EE77, 'M', u'خ'),
+    (0x1EE78, 'X'),
+    (0x1EE79, 'M', u'ض'),
+    (0x1EE7A, 'M', u'ظ'),
+    (0x1EE7B, 'M', u'غ'),
+    (0x1EE7C, 'M', u'ٮ'),
+    (0x1EE7D, 'X'),
+    (0x1EE7E, 'M', u'ڡ'),
+    (0x1EE7F, 'X'),
+    (0x1EE80, 'M', u'ا'),
+    (0x1EE81, 'M', u'ب'),
+    (0x1EE82, 'M', u'ج'),
+    (0x1EE83, 'M', u'د'),
+    (0x1EE84, 'M', u'ه'),
+    (0x1EE85, 'M', u'و'),
+    (0x1EE86, 'M', u'ز'),
+    (0x1EE87, 'M', u'ح'),
+    (0x1EE88, 'M', u'ط'),
+    (0x1EE89, 'M', u'ي'),
+    (0x1EE8A, 'X'),
+    (0x1EE8B, 'M', u'ل'),
+    (0x1EE8C, 'M', u'م'),
+    (0x1EE8D, 'M', u'ن'),
+    (0x1EE8E, 'M', u'س'),
+    (0x1EE8F, 'M', u'ع'),
+    (0x1EE90, 'M', u'ف'),
+    (0x1EE91, 'M', u'ص'),
+    (0x1EE92, 'M', u'ق'),
+    (0x1EE93, 'M', u'ر'),
+    (0x1EE94, 'M', u'ش'),
+    (0x1EE95, 'M', u'ت'),
+    (0x1EE96, 'M', u'ث'),
+    (0x1EE97, 'M', u'خ'),
+    (0x1EE98, 'M', u'ذ'),
+    (0x1EE99, 'M', u'ض'),
+    (0x1EE9A, 'M', u'ظ'),
+    (0x1EE9B, 'M', u'غ'),
+    (0x1EE9C, 'X'),
+    (0x1EEA1, 'M', u'ب'),
+    (0x1EEA2, 'M', u'ج'),
+    (0x1EEA3, 'M', u'د'),
+    (0x1EEA4, 'X'),
+    (0x1EEA5, 'M', u'و'),
+    (0x1EEA6, 'M', u'ز'),
+    (0x1EEA7, 'M', u'ح'),
+    (0x1EEA8, 'M', u'ط'),
+    (0x1EEA9, 'M', u'ي'),
+    (0x1EEAA, 'X'),
+    (0x1EEAB, 'M', u'ل'),
+    (0x1EEAC, 'M', u'م'),
+    (0x1EEAD, 'M', u'ن'),
+    (0x1EEAE, 'M', u'س'),
+    (0x1EEAF, 'M', u'ع'),
+    (0x1EEB0, 'M', u'ف'),
+    (0x1EEB1, 'M', u'ص'),
+    (0x1EEB2, 'M', u'ق'),
+    (0x1EEB3, 'M', u'ر'),
+    (0x1EEB4, 'M', u'ش'),
+    (0x1EEB5, 'M', u'ت'),
+    (0x1EEB6, 'M', u'ث'),
+    (0x1EEB7, 'M', u'خ'),
+    (0x1EEB8, 'M', u'ذ'),
+    (0x1EEB9, 'M', u'ض'),
+    (0x1EEBA, 'M', u'ظ'),
+    (0x1EEBB, 'M', u'غ'),
+    (0x1EEBC, 'X'),
+    (0x1EEF0, 'V'),
+    (0x1EEF2, 'X'),
+    (0x1F000, 'V'),
+    (0x1F02C, 'X'),
+    (0x1F030, 'V'),
+    (0x1F094, 'X'),
+    (0x1F0A0, 'V'),
+    (0x1F0AF, 'X'),
+    (0x1F0B1, 'V'),
+    (0x1F0C0, 'X'),
+    (0x1F0C1, 'V'),
+    (0x1F0D0, 'X'),
+    (0x1F0D1, 'V'),
+    (0x1F0F6, 'X'),
+    (0x1F101, '3', u'0,'),
+    (0x1F102, '3', u'1,'),
+    (0x1F103, '3', u'2,'),
+    (0x1F104, '3', u'3,'),
+    (0x1F105, '3', u'4,'),
+    (0x1F106, '3', u'5,'),
+    (0x1F107, '3', u'6,'),
+    (0x1F108, '3', u'7,'),
+    ]
+
+def _seg_72():
+    return [
+    (0x1F109, '3', u'8,'),
+    (0x1F10A, '3', u'9,'),
+    (0x1F10B, 'V'),
+    (0x1F110, '3', u'(a)'),
+    (0x1F111, '3', u'(b)'),
+    (0x1F112, '3', u'(c)'),
+    (0x1F113, '3', u'(d)'),
+    (0x1F114, '3', u'(e)'),
+    (0x1F115, '3', u'(f)'),
+    (0x1F116, '3', u'(g)'),
+    (0x1F117, '3', u'(h)'),
+    (0x1F118, '3', u'(i)'),
+    (0x1F119, '3', u'(j)'),
+    (0x1F11A, '3', u'(k)'),
+    (0x1F11B, '3', u'(l)'),
+    (0x1F11C, '3', u'(m)'),
+    (0x1F11D, '3', u'(n)'),
+    (0x1F11E, '3', u'(o)'),
+    (0x1F11F, '3', u'(p)'),
+    (0x1F120, '3', u'(q)'),
+    (0x1F121, '3', u'(r)'),
+    (0x1F122, '3', u'(s)'),
+    (0x1F123, '3', u'(t)'),
+    (0x1F124, '3', u'(u)'),
+    (0x1F125, '3', u'(v)'),
+    (0x1F126, '3', u'(w)'),
+    (0x1F127, '3', u'(x)'),
+    (0x1F128, '3', u'(y)'),
+    (0x1F129, '3', u'(z)'),
+    (0x1F12A, 'M', u'〔s〕'),
+    (0x1F12B, 'M', u'c'),
+    (0x1F12C, 'M', u'r'),
+    (0x1F12D, 'M', u'cd'),
+    (0x1F12E, 'M', u'wz'),
+    (0x1F12F, 'V'),
+    (0x1F130, 'M', u'a'),
+    (0x1F131, 'M', u'b'),
+    (0x1F132, 'M', u'c'),
+    (0x1F133, 'M', u'd'),
+    (0x1F134, 'M', u'e'),
+    (0x1F135, 'M', u'f'),
+    (0x1F136, 'M', u'g'),
+    (0x1F137, 'M', u'h'),
+    (0x1F138, 'M', u'i'),
+    (0x1F139, 'M', u'j'),
+    (0x1F13A, 'M', u'k'),
+    (0x1F13B, 'M', u'l'),
+    (0x1F13C, 'M', u'm'),
+    (0x1F13D, 'M', u'n'),
+    (0x1F13E, 'M', u'o'),
+    (0x1F13F, 'M', u'p'),
+    (0x1F140, 'M', u'q'),
+    (0x1F141, 'M', u'r'),
+    (0x1F142, 'M', u's'),
+    (0x1F143, 'M', u't'),
+    (0x1F144, 'M', u'u'),
+    (0x1F145, 'M', u'v'),
+    (0x1F146, 'M', u'w'),
+    (0x1F147, 'M', u'x'),
+    (0x1F148, 'M', u'y'),
+    (0x1F149, 'M', u'z'),
+    (0x1F14A, 'M', u'hv'),
+    (0x1F14B, 'M', u'mv'),
+    (0x1F14C, 'M', u'sd'),
+    (0x1F14D, 'M', u'ss'),
+    (0x1F14E, 'M', u'ppv'),
+    (0x1F14F, 'M', u'wc'),
+    (0x1F150, 'V'),
+    (0x1F16A, 'M', u'mc'),
+    (0x1F16B, 'M', u'md'),
+    (0x1F16C, 'M', u'mr'),
+    (0x1F16D, 'V'),
+    (0x1F190, 'M', u'dj'),
+    (0x1F191, 'V'),
+    (0x1F1AE, 'X'),
+    (0x1F1E6, 'V'),
+    (0x1F200, 'M', u'ほか'),
+    (0x1F201, 'M', u'ココ'),
+    (0x1F202, 'M', u'サ'),
+    (0x1F203, 'X'),
+    (0x1F210, 'M', u'手'),
+    (0x1F211, 'M', u'字'),
+    (0x1F212, 'M', u'双'),
+    (0x1F213, 'M', u'デ'),
+    (0x1F214, 'M', u'二'),
+    (0x1F215, 'M', u'多'),
+    (0x1F216, 'M', u'解'),
+    (0x1F217, 'M', u'天'),
+    (0x1F218, 'M', u'交'),
+    (0x1F219, 'M', u'映'),
+    (0x1F21A, 'M', u'無'),
+    (0x1F21B, 'M', u'料'),
+    (0x1F21C, 'M', u'前'),
+    (0x1F21D, 'M', u'後'),
+    (0x1F21E, 'M', u'再'),
+    (0x1F21F, 'M', u'新'),
+    (0x1F220, 'M', u'初'),
+    (0x1F221, 'M', u'終'),
+    (0x1F222, 'M', u'生'),
+    (0x1F223, 'M', u'販'),
+    ]
+
+def _seg_73():
+    return [
+    (0x1F224, 'M', u'声'),
+    (0x1F225, 'M', u'吹'),
+    (0x1F226, 'M', u'演'),
+    (0x1F227, 'M', u'投'),
+    (0x1F228, 'M', u'捕'),
+    (0x1F229, 'M', u'一'),
+    (0x1F22A, 'M', u'三'),
+    (0x1F22B, 'M', u'遊'),
+    (0x1F22C, 'M', u'左'),
+    (0x1F22D, 'M', u'中'),
+    (0x1F22E, 'M', u'右'),
+    (0x1F22F, 'M', u'指'),
+    (0x1F230, 'M', u'走'),
+    (0x1F231, 'M', u'打'),
+    (0x1F232, 'M', u'禁'),
+    (0x1F233, 'M', u'空'),
+    (0x1F234, 'M', u'合'),
+    (0x1F235, 'M', u'満'),
+    (0x1F236, 'M', u'有'),
+    (0x1F237, 'M', u'月'),
+    (0x1F238, 'M', u'申'),
+    (0x1F239, 'M', u'割'),
+    (0x1F23A, 'M', u'営'),
+    (0x1F23B, 'M', u'配'),
+    (0x1F23C, 'X'),
+    (0x1F240, 'M', u'〔本〕'),
+    (0x1F241, 'M', u'〔三〕'),
+    (0x1F242, 'M', u'〔二〕'),
+    (0x1F243, 'M', u'〔安〕'),
+    (0x1F244, 'M', u'〔点〕'),
+    (0x1F245, 'M', u'〔打〕'),
+    (0x1F246, 'M', u'〔盗〕'),
+    (0x1F247, 'M', u'〔勝〕'),
+    (0x1F248, 'M', u'〔敗〕'),
+    (0x1F249, 'X'),
+    (0x1F250, 'M', u'得'),
+    (0x1F251, 'M', u'可'),
+    (0x1F252, 'X'),
+    (0x1F260, 'V'),
+    (0x1F266, 'X'),
+    (0x1F300, 'V'),
+    (0x1F6D8, 'X'),
+    (0x1F6E0, 'V'),
+    (0x1F6ED, 'X'),
+    (0x1F6F0, 'V'),
+    (0x1F6FD, 'X'),
+    (0x1F700, 'V'),
+    (0x1F774, 'X'),
+    (0x1F780, 'V'),
+    (0x1F7D9, 'X'),
+    (0x1F7E0, 'V'),
+    (0x1F7EC, 'X'),
+    (0x1F800, 'V'),
+    (0x1F80C, 'X'),
+    (0x1F810, 'V'),
+    (0x1F848, 'X'),
+    (0x1F850, 'V'),
+    (0x1F85A, 'X'),
+    (0x1F860, 'V'),
+    (0x1F888, 'X'),
+    (0x1F890, 'V'),
+    (0x1F8AE, 'X'),
+    (0x1F8B0, 'V'),
+    (0x1F8B2, 'X'),
+    (0x1F900, 'V'),
+    (0x1F979, 'X'),
+    (0x1F97A, 'V'),
+    (0x1F9CC, 'X'),
+    (0x1F9CD, 'V'),
+    (0x1FA54, 'X'),
+    (0x1FA60, 'V'),
+    (0x1FA6E, 'X'),
+    (0x1FA70, 'V'),
+    (0x1FA75, 'X'),
+    (0x1FA78, 'V'),
+    (0x1FA7B, 'X'),
+    (0x1FA80, 'V'),
+    (0x1FA87, 'X'),
+    (0x1FA90, 'V'),
+    (0x1FAA9, 'X'),
+    (0x1FAB0, 'V'),
+    (0x1FAB7, 'X'),
+    (0x1FAC0, 'V'),
+    (0x1FAC3, 'X'),
+    (0x1FAD0, 'V'),
+    (0x1FAD7, 'X'),
+    (0x1FB00, 'V'),
+    (0x1FB93, 'X'),
+    (0x1FB94, 'V'),
+    (0x1FBCB, 'X'),
+    (0x1FBF0, 'M', u'0'),
+    (0x1FBF1, 'M', u'1'),
+    (0x1FBF2, 'M', u'2'),
+    (0x1FBF3, 'M', u'3'),
+    (0x1FBF4, 'M', u'4'),
+    (0x1FBF5, 'M', u'5'),
+    (0x1FBF6, 'M', u'6'),
+    (0x1FBF7, 'M', u'7'),
+    (0x1FBF8, 'M', u'8'),
+    (0x1FBF9, 'M', u'9'),
+    ]
+
+def _seg_74():
+    return [
+    (0x1FBFA, 'X'),
+    (0x20000, 'V'),
+    (0x2A6DE, 'X'),
+    (0x2A700, 'V'),
+    (0x2B735, 'X'),
+    (0x2B740, 'V'),
+    (0x2B81E, 'X'),
+    (0x2B820, 'V'),
+    (0x2CEA2, 'X'),
+    (0x2CEB0, 'V'),
+    (0x2EBE1, 'X'),
+    (0x2F800, 'M', u'丽'),
+    (0x2F801, 'M', u'丸'),
+    (0x2F802, 'M', u'乁'),
+    (0x2F803, 'M', u'𠄢'),
+    (0x2F804, 'M', u'你'),
+    (0x2F805, 'M', u'侮'),
+    (0x2F806, 'M', u'侻'),
+    (0x2F807, 'M', u'倂'),
+    (0x2F808, 'M', u'偺'),
+    (0x2F809, 'M', u'備'),
+    (0x2F80A, 'M', u'僧'),
+    (0x2F80B, 'M', u'像'),
+    (0x2F80C, 'M', u'㒞'),
+    (0x2F80D, 'M', u'𠘺'),
+    (0x2F80E, 'M', u'免'),
+    (0x2F80F, 'M', u'兔'),
+    (0x2F810, 'M', u'兤'),
+    (0x2F811, 'M', u'具'),
+    (0x2F812, 'M', u'𠔜'),
+    (0x2F813, 'M', u'㒹'),
+    (0x2F814, 'M', u'內'),
+    (0x2F815, 'M', u'再'),
+    (0x2F816, 'M', u'𠕋'),
+    (0x2F817, 'M', u'冗'),
+    (0x2F818, 'M', u'冤'),
+    (0x2F819, 'M', u'仌'),
+    (0x2F81A, 'M', u'冬'),
+    (0x2F81B, 'M', u'况'),
+    (0x2F81C, 'M', u'𩇟'),
+    (0x2F81D, 'M', u'凵'),
+    (0x2F81E, 'M', u'刃'),
+    (0x2F81F, 'M', u'㓟'),
+    (0x2F820, 'M', u'刻'),
+    (0x2F821, 'M', u'剆'),
+    (0x2F822, 'M', u'割'),
+    (0x2F823, 'M', u'剷'),
+    (0x2F824, 'M', u'㔕'),
+    (0x2F825, 'M', u'勇'),
+    (0x2F826, 'M', u'勉'),
+    (0x2F827, 'M', u'勤'),
+    (0x2F828, 'M', u'勺'),
+    (0x2F829, 'M', u'包'),
+    (0x2F82A, 'M', u'匆'),
+    (0x2F82B, 'M', u'北'),
+    (0x2F82C, 'M', u'卉'),
+    (0x2F82D, 'M', u'卑'),
+    (0x2F82E, 'M', u'博'),
+    (0x2F82F, 'M', u'即'),
+    (0x2F830, 'M', u'卽'),
+    (0x2F831, 'M', u'卿'),
+    (0x2F834, 'M', u'𠨬'),
+    (0x2F835, 'M', u'灰'),
+    (0x2F836, 'M', u'及'),
+    (0x2F837, 'M', u'叟'),
+    (0x2F838, 'M', u'𠭣'),
+    (0x2F839, 'M', u'叫'),
+    (0x2F83A, 'M', u'叱'),
+    (0x2F83B, 'M', u'吆'),
+    (0x2F83C, 'M', u'咞'),
+    (0x2F83D, 'M', u'吸'),
+    (0x2F83E, 'M', u'呈'),
+    (0x2F83F, 'M', u'周'),
+    (0x2F840, 'M', u'咢'),
+    (0x2F841, 'M', u'哶'),
+    (0x2F842, 'M', u'唐'),
+    (0x2F843, 'M', u'啓'),
+    (0x2F844, 'M', u'啣'),
+    (0x2F845, 'M', u'善'),
+    (0x2F847, 'M', u'喙'),
+    (0x2F848, 'M', u'喫'),
+    (0x2F849, 'M', u'喳'),
+    (0x2F84A, 'M', u'嗂'),
+    (0x2F84B, 'M', u'圖'),
+    (0x2F84C, 'M', u'嘆'),
+    (0x2F84D, 'M', u'圗'),
+    (0x2F84E, 'M', u'噑'),
+    (0x2F84F, 'M', u'噴'),
+    (0x2F850, 'M', u'切'),
+    (0x2F851, 'M', u'壮'),
+    (0x2F852, 'M', u'城'),
+    (0x2F853, 'M', u'埴'),
+    (0x2F854, 'M', u'堍'),
+    (0x2F855, 'M', u'型'),
+    (0x2F856, 'M', u'堲'),
+    (0x2F857, 'M', u'報'),
+    (0x2F858, 'M', u'墬'),
+    (0x2F859, 'M', u'𡓤'),
+    (0x2F85A, 'M', u'売'),
+    (0x2F85B, 'M', u'壷'),
+    ]
+
+def _seg_75():
+    return [
+    (0x2F85C, 'M', u'夆'),
+    (0x2F85D, 'M', u'多'),
+    (0x2F85E, 'M', u'夢'),
+    (0x2F85F, 'M', u'奢'),
+    (0x2F860, 'M', u'𡚨'),
+    (0x2F861, 'M', u'𡛪'),
+    (0x2F862, 'M', u'姬'),
+    (0x2F863, 'M', u'娛'),
+    (0x2F864, 'M', u'娧'),
+    (0x2F865, 'M', u'姘'),
+    (0x2F866, 'M', u'婦'),
+    (0x2F867, 'M', u'㛮'),
+    (0x2F868, 'X'),
+    (0x2F869, 'M', u'嬈'),
+    (0x2F86A, 'M', u'嬾'),
+    (0x2F86C, 'M', u'𡧈'),
+    (0x2F86D, 'M', u'寃'),
+    (0x2F86E, 'M', u'寘'),
+    (0x2F86F, 'M', u'寧'),
+    (0x2F870, 'M', u'寳'),
+    (0x2F871, 'M', u'𡬘'),
+    (0x2F872, 'M', u'寿'),
+    (0x2F873, 'M', u'将'),
+    (0x2F874, 'X'),
+    (0x2F875, 'M', u'尢'),
+    (0x2F876, 'M', u'㞁'),
+    (0x2F877, 'M', u'屠'),
+    (0x2F878, 'M', u'屮'),
+    (0x2F879, 'M', u'峀'),
+    (0x2F87A, 'M', u'岍'),
+    (0x2F87B, 'M', u'𡷤'),
+    (0x2F87C, 'M', u'嵃'),
+    (0x2F87D, 'M', u'𡷦'),
+    (0x2F87E, 'M', u'嵮'),
+    (0x2F87F, 'M', u'嵫'),
+    (0x2F880, 'M', u'嵼'),
+    (0x2F881, 'M', u'巡'),
+    (0x2F882, 'M', u'巢'),
+    (0x2F883, 'M', u'㠯'),
+    (0x2F884, 'M', u'巽'),
+    (0x2F885, 'M', u'帨'),
+    (0x2F886, 'M', u'帽'),
+    (0x2F887, 'M', u'幩'),
+    (0x2F888, 'M', u'㡢'),
+    (0x2F889, 'M', u'𢆃'),
+    (0x2F88A, 'M', u'㡼'),
+    (0x2F88B, 'M', u'庰'),
+    (0x2F88C, 'M', u'庳'),
+    (0x2F88D, 'M', u'庶'),
+    (0x2F88E, 'M', u'廊'),
+    (0x2F88F, 'M', u'𪎒'),
+    (0x2F890, 'M', u'廾'),
+    (0x2F891, 'M', u'𢌱'),
+    (0x2F893, 'M', u'舁'),
+    (0x2F894, 'M', u'弢'),
+    (0x2F896, 'M', u'㣇'),
+    (0x2F897, 'M', u'𣊸'),
+    (0x2F898, 'M', u'𦇚'),
+    (0x2F899, 'M', u'形'),
+    (0x2F89A, 'M', u'彫'),
+    (0x2F89B, 'M', u'㣣'),
+    (0x2F89C, 'M', u'徚'),
+    (0x2F89D, 'M', u'忍'),
+    (0x2F89E, 'M', u'志'),
+    (0x2F89F, 'M', u'忹'),
+    (0x2F8A0, 'M', u'悁'),
+    (0x2F8A1, 'M', u'㤺'),
+    (0x2F8A2, 'M', u'㤜'),
+    (0x2F8A3, 'M', u'悔'),
+    (0x2F8A4, 'M', u'𢛔'),
+    (0x2F8A5, 'M', u'惇'),
+    (0x2F8A6, 'M', u'慈'),
+    (0x2F8A7, 'M', u'慌'),
+    (0x2F8A8, 'M', u'慎'),
+    (0x2F8A9, 'M', u'慌'),
+    (0x2F8AA, 'M', u'慺'),
+    (0x2F8AB, 'M', u'憎'),
+    (0x2F8AC, 'M', u'憲'),
+    (0x2F8AD, 'M', u'憤'),
+    (0x2F8AE, 'M', u'憯'),
+    (0x2F8AF, 'M', u'懞'),
+    (0x2F8B0, 'M', u'懲'),
+    (0x2F8B1, 'M', u'懶'),
+    (0x2F8B2, 'M', u'成'),
+    (0x2F8B3, 'M', u'戛'),
+    (0x2F8B4, 'M', u'扝'),
+    (0x2F8B5, 'M', u'抱'),
+    (0x2F8B6, 'M', u'拔'),
+    (0x2F8B7, 'M', u'捐'),
+    (0x2F8B8, 'M', u'𢬌'),
+    (0x2F8B9, 'M', u'挽'),
+    (0x2F8BA, 'M', u'拼'),
+    (0x2F8BB, 'M', u'捨'),
+    (0x2F8BC, 'M', u'掃'),
+    (0x2F8BD, 'M', u'揤'),
+    (0x2F8BE, 'M', u'𢯱'),
+    (0x2F8BF, 'M', u'搢'),
+    (0x2F8C0, 'M', u'揅'),
+    (0x2F8C1, 'M', u'掩'),
+    (0x2F8C2, 'M', u'㨮'),
+    ]
+
+def _seg_76():
+    return [
+    (0x2F8C3, 'M', u'摩'),
+    (0x2F8C4, 'M', u'摾'),
+    (0x2F8C5, 'M', u'撝'),
+    (0x2F8C6, 'M', u'摷'),
+    (0x2F8C7, 'M', u'㩬'),
+    (0x2F8C8, 'M', u'敏'),
+    (0x2F8C9, 'M', u'敬'),
+    (0x2F8CA, 'M', u'𣀊'),
+    (0x2F8CB, 'M', u'旣'),
+    (0x2F8CC, 'M', u'書'),
+    (0x2F8CD, 'M', u'晉'),
+    (0x2F8CE, 'M', u'㬙'),
+    (0x2F8CF, 'M', u'暑'),
+    (0x2F8D0, 'M', u'㬈'),
+    (0x2F8D1, 'M', u'㫤'),
+    (0x2F8D2, 'M', u'冒'),
+    (0x2F8D3, 'M', u'冕'),
+    (0x2F8D4, 'M', u'最'),
+    (0x2F8D5, 'M', u'暜'),
+    (0x2F8D6, 'M', u'肭'),
+    (0x2F8D7, 'M', u'䏙'),
+    (0x2F8D8, 'M', u'朗'),
+    (0x2F8D9, 'M', u'望'),
+    (0x2F8DA, 'M', u'朡'),
+    (0x2F8DB, 'M', u'杞'),
+    (0x2F8DC, 'M', u'杓'),
+    (0x2F8DD, 'M', u'𣏃'),
+    (0x2F8DE, 'M', u'㭉'),
+    (0x2F8DF, 'M', u'柺'),
+    (0x2F8E0, 'M', u'枅'),
+    (0x2F8E1, 'M', u'桒'),
+    (0x2F8E2, 'M', u'梅'),
+    (0x2F8E3, 'M', u'𣑭'),
+    (0x2F8E4, 'M', u'梎'),
+    (0x2F8E5, 'M', u'栟'),
+    (0x2F8E6, 'M', u'椔'),
+    (0x2F8E7, 'M', u'㮝'),
+    (0x2F8E8, 'M', u'楂'),
+    (0x2F8E9, 'M', u'榣'),
+    (0x2F8EA, 'M', u'槪'),
+    (0x2F8EB, 'M', u'檨'),
+    (0x2F8EC, 'M', u'𣚣'),
+    (0x2F8ED, 'M', u'櫛'),
+    (0x2F8EE, 'M', u'㰘'),
+    (0x2F8EF, 'M', u'次'),
+    (0x2F8F0, 'M', u'𣢧'),
+    (0x2F8F1, 'M', u'歔'),
+    (0x2F8F2, 'M', u'㱎'),
+    (0x2F8F3, 'M', u'歲'),
+    (0x2F8F4, 'M', u'殟'),
+    (0x2F8F5, 'M', u'殺'),
+    (0x2F8F6, 'M', u'殻'),
+    (0x2F8F7, 'M', u'𣪍'),
+    (0x2F8F8, 'M', u'𡴋'),
+    (0x2F8F9, 'M', u'𣫺'),
+    (0x2F8FA, 'M', u'汎'),
+    (0x2F8FB, 'M', u'𣲼'),
+    (0x2F8FC, 'M', u'沿'),
+    (0x2F8FD, 'M', u'泍'),
+    (0x2F8FE, 'M', u'汧'),
+    (0x2F8FF, 'M', u'洖'),
+    (0x2F900, 'M', u'派'),
+    (0x2F901, 'M', u'海'),
+    (0x2F902, 'M', u'流'),
+    (0x2F903, 'M', u'浩'),
+    (0x2F904, 'M', u'浸'),
+    (0x2F905, 'M', u'涅'),
+    (0x2F906, 'M', u'𣴞'),
+    (0x2F907, 'M', u'洴'),
+    (0x2F908, 'M', u'港'),
+    (0x2F909, 'M', u'湮'),
+    (0x2F90A, 'M', u'㴳'),
+    (0x2F90B, 'M', u'滋'),
+    (0x2F90C, 'M', u'滇'),
+    (0x2F90D, 'M', u'𣻑'),
+    (0x2F90E, 'M', u'淹'),
+    (0x2F90F, 'M', u'潮'),
+    (0x2F910, 'M', u'𣽞'),
+    (0x2F911, 'M', u'𣾎'),
+    (0x2F912, 'M', u'濆'),
+    (0x2F913, 'M', u'瀹'),
+    (0x2F914, 'M', u'瀞'),
+    (0x2F915, 'M', u'瀛'),
+    (0x2F916, 'M', u'㶖'),
+    (0x2F917, 'M', u'灊'),
+    (0x2F918, 'M', u'災'),
+    (0x2F919, 'M', u'灷'),
+    (0x2F91A, 'M', u'炭'),
+    (0x2F91B, 'M', u'𠔥'),
+    (0x2F91C, 'M', u'煅'),
+    (0x2F91D, 'M', u'𤉣'),
+    (0x2F91E, 'M', u'熜'),
+    (0x2F91F, 'X'),
+    (0x2F920, 'M', u'爨'),
+    (0x2F921, 'M', u'爵'),
+    (0x2F922, 'M', u'牐'),
+    (0x2F923, 'M', u'𤘈'),
+    (0x2F924, 'M', u'犀'),
+    (0x2F925, 'M', u'犕'),
+    (0x2F926, 'M', u'𤜵'),
+    ]
+
+def _seg_77():
+    return [
+    (0x2F927, 'M', u'𤠔'),
+    (0x2F928, 'M', u'獺'),
+    (0x2F929, 'M', u'王'),
+    (0x2F92A, 'M', u'㺬'),
+    (0x2F92B, 'M', u'玥'),
+    (0x2F92C, 'M', u'㺸'),
+    (0x2F92E, 'M', u'瑇'),
+    (0x2F92F, 'M', u'瑜'),
+    (0x2F930, 'M', u'瑱'),
+    (0x2F931, 'M', u'璅'),
+    (0x2F932, 'M', u'瓊'),
+    (0x2F933, 'M', u'㼛'),
+    (0x2F934, 'M', u'甤'),
+    (0x2F935, 'M', u'𤰶'),
+    (0x2F936, 'M', u'甾'),
+    (0x2F937, 'M', u'𤲒'),
+    (0x2F938, 'M', u'異'),
+    (0x2F939, 'M', u'𢆟'),
+    (0x2F93A, 'M', u'瘐'),
+    (0x2F93B, 'M', u'𤾡'),
+    (0x2F93C, 'M', u'𤾸'),
+    (0x2F93D, 'M', u'𥁄'),
+    (0x2F93E, 'M', u'㿼'),
+    (0x2F93F, 'M', u'䀈'),
+    (0x2F940, 'M', u'直'),
+    (0x2F941, 'M', u'𥃳'),
+    (0x2F942, 'M', u'𥃲'),
+    (0x2F943, 'M', u'𥄙'),
+    (0x2F944, 'M', u'𥄳'),
+    (0x2F945, 'M', u'眞'),
+    (0x2F946, 'M', u'真'),
+    (0x2F948, 'M', u'睊'),
+    (0x2F949, 'M', u'䀹'),
+    (0x2F94A, 'M', u'瞋'),
+    (0x2F94B, 'M', u'䁆'),
+    (0x2F94C, 'M', u'䂖'),
+    (0x2F94D, 'M', u'𥐝'),
+    (0x2F94E, 'M', u'硎'),
+    (0x2F94F, 'M', u'碌'),
+    (0x2F950, 'M', u'磌'),
+    (0x2F951, 'M', u'䃣'),
+    (0x2F952, 'M', u'𥘦'),
+    (0x2F953, 'M', u'祖'),
+    (0x2F954, 'M', u'𥚚'),
+    (0x2F955, 'M', u'𥛅'),
+    (0x2F956, 'M', u'福'),
+    (0x2F957, 'M', u'秫'),
+    (0x2F958, 'M', u'䄯'),
+    (0x2F959, 'M', u'穀'),
+    (0x2F95A, 'M', u'穊'),
+    (0x2F95B, 'M', u'穏'),
+    (0x2F95C, 'M', u'𥥼'),
+    (0x2F95D, 'M', u'𥪧'),
+    (0x2F95F, 'X'),
+    (0x2F960, 'M', u'䈂'),
+    (0x2F961, 'M', u'𥮫'),
+    (0x2F962, 'M', u'篆'),
+    (0x2F963, 'M', u'築'),
+    (0x2F964, 'M', u'䈧'),
+    (0x2F965, 'M', u'𥲀'),
+    (0x2F966, 'M', u'糒'),
+    (0x2F967, 'M', u'䊠'),
+    (0x2F968, 'M', u'糨'),
+    (0x2F969, 'M', u'糣'),
+    (0x2F96A, 'M', u'紀'),
+    (0x2F96B, 'M', u'𥾆'),
+    (0x2F96C, 'M', u'絣'),
+    (0x2F96D, 'M', u'䌁'),
+    (0x2F96E, 'M', u'緇'),
+    (0x2F96F, 'M', u'縂'),
+    (0x2F970, 'M', u'繅'),
+    (0x2F971, 'M', u'䌴'),
+    (0x2F972, 'M', u'𦈨'),
+    (0x2F973, 'M', u'𦉇'),
+    (0x2F974, 'M', u'䍙'),
+    (0x2F975, 'M', u'𦋙'),
+    (0x2F976, 'M', u'罺'),
+    (0x2F977, 'M', u'𦌾'),
+    (0x2F978, 'M', u'羕'),
+    (0x2F979, 'M', u'翺'),
+    (0x2F97A, 'M', u'者'),
+    (0x2F97B, 'M', u'𦓚'),
+    (0x2F97C, 'M', u'𦔣'),
+    (0x2F97D, 'M', u'聠'),
+    (0x2F97E, 'M', u'𦖨'),
+    (0x2F97F, 'M', u'聰'),
+    (0x2F980, 'M', u'𣍟'),
+    (0x2F981, 'M', u'䏕'),
+    (0x2F982, 'M', u'育'),
+    (0x2F983, 'M', u'脃'),
+    (0x2F984, 'M', u'䐋'),
+    (0x2F985, 'M', u'脾'),
+    (0x2F986, 'M', u'媵'),
+    (0x2F987, 'M', u'𦞧'),
+    (0x2F988, 'M', u'𦞵'),
+    (0x2F989, 'M', u'𣎓'),
+    (0x2F98A, 'M', u'𣎜'),
+    (0x2F98B, 'M', u'舁'),
+    (0x2F98C, 'M', u'舄'),
+    (0x2F98D, 'M', u'辞'),
+    ]
+
+def _seg_78():
+    return [
+    (0x2F98E, 'M', u'䑫'),
+    (0x2F98F, 'M', u'芑'),
+    (0x2F990, 'M', u'芋'),
+    (0x2F991, 'M', u'芝'),
+    (0x2F992, 'M', u'劳'),
+    (0x2F993, 'M', u'花'),
+    (0x2F994, 'M', u'芳'),
+    (0x2F995, 'M', u'芽'),
+    (0x2F996, 'M', u'苦'),
+    (0x2F997, 'M', u'𦬼'),
+    (0x2F998, 'M', u'若'),
+    (0x2F999, 'M', u'茝'),
+    (0x2F99A, 'M', u'荣'),
+    (0x2F99B, 'M', u'莭'),
+    (0x2F99C, 'M', u'茣'),
+    (0x2F99D, 'M', u'莽'),
+    (0x2F99E, 'M', u'菧'),
+    (0x2F99F, 'M', u'著'),
+    (0x2F9A0, 'M', u'荓'),
+    (0x2F9A1, 'M', u'菊'),
+    (0x2F9A2, 'M', u'菌'),
+    (0x2F9A3, 'M', u'菜'),
+    (0x2F9A4, 'M', u'𦰶'),
+    (0x2F9A5, 'M', u'𦵫'),
+    (0x2F9A6, 'M', u'𦳕'),
+    (0x2F9A7, 'M', u'䔫'),
+    (0x2F9A8, 'M', u'蓱'),
+    (0x2F9A9, 'M', u'蓳'),
+    (0x2F9AA, 'M', u'蔖'),
+    (0x2F9AB, 'M', u'𧏊'),
+    (0x2F9AC, 'M', u'蕤'),
+    (0x2F9AD, 'M', u'𦼬'),
+    (0x2F9AE, 'M', u'䕝'),
+    (0x2F9AF, 'M', u'䕡'),
+    (0x2F9B0, 'M', u'𦾱'),
+    (0x2F9B1, 'M', u'𧃒'),
+    (0x2F9B2, 'M', u'䕫'),
+    (0x2F9B3, 'M', u'虐'),
+    (0x2F9B4, 'M', u'虜'),
+    (0x2F9B5, 'M', u'虧'),
+    (0x2F9B6, 'M', u'虩'),
+    (0x2F9B7, 'M', u'蚩'),
+    (0x2F9B8, 'M', u'蚈'),
+    (0x2F9B9, 'M', u'蜎'),
+    (0x2F9BA, 'M', u'蛢'),
+    (0x2F9BB, 'M', u'蝹'),
+    (0x2F9BC, 'M', u'蜨'),
+    (0x2F9BD, 'M', u'蝫'),
+    (0x2F9BE, 'M', u'螆'),
+    (0x2F9BF, 'X'),
+    (0x2F9C0, 'M', u'蟡'),
+    (0x2F9C1, 'M', u'蠁'),
+    (0x2F9C2, 'M', u'䗹'),
+    (0x2F9C3, 'M', u'衠'),
+    (0x2F9C4, 'M', u'衣'),
+    (0x2F9C5, 'M', u'𧙧'),
+    (0x2F9C6, 'M', u'裗'),
+    (0x2F9C7, 'M', u'裞'),
+    (0x2F9C8, 'M', u'䘵'),
+    (0x2F9C9, 'M', u'裺'),
+    (0x2F9CA, 'M', u'㒻'),
+    (0x2F9CB, 'M', u'𧢮'),
+    (0x2F9CC, 'M', u'𧥦'),
+    (0x2F9CD, 'M', u'䚾'),
+    (0x2F9CE, 'M', u'䛇'),
+    (0x2F9CF, 'M', u'誠'),
+    (0x2F9D0, 'M', u'諭'),
+    (0x2F9D1, 'M', u'變'),
+    (0x2F9D2, 'M', u'豕'),
+    (0x2F9D3, 'M', u'𧲨'),
+    (0x2F9D4, 'M', u'貫'),
+    (0x2F9D5, 'M', u'賁'),
+    (0x2F9D6, 'M', u'贛'),
+    (0x2F9D7, 'M', u'起'),
+    (0x2F9D8, 'M', u'𧼯'),
+    (0x2F9D9, 'M', u'𠠄'),
+    (0x2F9DA, 'M', u'跋'),
+    (0x2F9DB, 'M', u'趼'),
+    (0x2F9DC, 'M', u'跰'),
+    (0x2F9DD, 'M', u'𠣞'),
+    (0x2F9DE, 'M', u'軔'),
+    (0x2F9DF, 'M', u'輸'),
+    (0x2F9E0, 'M', u'𨗒'),
+    (0x2F9E1, 'M', u'𨗭'),
+    (0x2F9E2, 'M', u'邔'),
+    (0x2F9E3, 'M', u'郱'),
+    (0x2F9E4, 'M', u'鄑'),
+    (0x2F9E5, 'M', u'𨜮'),
+    (0x2F9E6, 'M', u'鄛'),
+    (0x2F9E7, 'M', u'鈸'),
+    (0x2F9E8, 'M', u'鋗'),
+    (0x2F9E9, 'M', u'鋘'),
+    (0x2F9EA, 'M', u'鉼'),
+    (0x2F9EB, 'M', u'鏹'),
+    (0x2F9EC, 'M', u'鐕'),
+    (0x2F9ED, 'M', u'𨯺'),
+    (0x2F9EE, 'M', u'開'),
+    (0x2F9EF, 'M', u'䦕'),
+    (0x2F9F0, 'M', u'閷'),
+    (0x2F9F1, 'M', u'𨵷'),
+    ]
+
+def _seg_79():
+    return [
+    (0x2F9F2, 'M', u'䧦'),
+    (0x2F9F3, 'M', u'雃'),
+    (0x2F9F4, 'M', u'嶲'),
+    (0x2F9F5, 'M', u'霣'),
+    (0x2F9F6, 'M', u'𩅅'),
+    (0x2F9F7, 'M', u'𩈚'),
+    (0x2F9F8, 'M', u'䩮'),
+    (0x2F9F9, 'M', u'䩶'),
+    (0x2F9FA, 'M', u'韠'),
+    (0x2F9FB, 'M', u'𩐊'),
+    (0x2F9FC, 'M', u'䪲'),
+    (0x2F9FD, 'M', u'𩒖'),
+    (0x2F9FE, 'M', u'頋'),
+    (0x2FA00, 'M', u'頩'),
+    (0x2FA01, 'M', u'𩖶'),
+    (0x2FA02, 'M', u'飢'),
+    (0x2FA03, 'M', u'䬳'),
+    (0x2FA04, 'M', u'餩'),
+    (0x2FA05, 'M', u'馧'),
+    (0x2FA06, 'M', u'駂'),
+    (0x2FA07, 'M', u'駾'),
+    (0x2FA08, 'M', u'䯎'),
+    (0x2FA09, 'M', u'𩬰'),
+    (0x2FA0A, 'M', u'鬒'),
+    (0x2FA0B, 'M', u'鱀'),
+    (0x2FA0C, 'M', u'鳽'),
+    (0x2FA0D, 'M', u'䳎'),
+    (0x2FA0E, 'M', u'䳭'),
+    (0x2FA0F, 'M', u'鵧'),
+    (0x2FA10, 'M', u'𪃎'),
+    (0x2FA11, 'M', u'䳸'),
+    (0x2FA12, 'M', u'𪄅'),
+    (0x2FA13, 'M', u'𪈎'),
+    (0x2FA14, 'M', u'𪊑'),
+    (0x2FA15, 'M', u'麻'),
+    (0x2FA16, 'M', u'䵖'),
+    (0x2FA17, 'M', u'黹'),
+    (0x2FA18, 'M', u'黾'),
+    (0x2FA19, 'M', u'鼅'),
+    (0x2FA1A, 'M', u'鼏'),
+    (0x2FA1B, 'M', u'鼖'),
+    (0x2FA1C, 'M', u'鼻'),
+    (0x2FA1D, 'M', u'𪘀'),
+    (0x2FA1E, 'X'),
+    (0x30000, 'V'),
+    (0x3134B, 'X'),
+    (0xE0100, 'I'),
+    (0xE01F0, 'X'),
+    ]
+
+uts46data = tuple(
+    _seg_0()
+    + _seg_1()
+    + _seg_2()
+    + _seg_3()
+    + _seg_4()
+    + _seg_5()
+    + _seg_6()
+    + _seg_7()
+    + _seg_8()
+    + _seg_9()
+    + _seg_10()
+    + _seg_11()
+    + _seg_12()
+    + _seg_13()
+    + _seg_14()
+    + _seg_15()
+    + _seg_16()
+    + _seg_17()
+    + _seg_18()
+    + _seg_19()
+    + _seg_20()
+    + _seg_21()
+    + _seg_22()
+    + _seg_23()
+    + _seg_24()
+    + _seg_25()
+    + _seg_26()
+    + _seg_27()
+    + _seg_28()
+    + _seg_29()
+    + _seg_30()
+    + _seg_31()
+    + _seg_32()
+    + _seg_33()
+    + _seg_34()
+    + _seg_35()
+    + _seg_36()
+    + _seg_37()
+    + _seg_38()
+    + _seg_39()
+    + _seg_40()
+    + _seg_41()
+    + _seg_42()
+    + _seg_43()
+    + _seg_44()
+    + _seg_45()
+    + _seg_46()
+    + _seg_47()
+    + _seg_48()
+    + _seg_49()
+    + _seg_50()
+    + _seg_51()
+    + _seg_52()
+    + _seg_53()
+    + _seg_54()
+    + _seg_55()
+    + _seg_56()
+    + _seg_57()
+    + _seg_58()
+    + _seg_59()
+    + _seg_60()
+    + _seg_61()
+    + _seg_62()
+    + _seg_63()
+    + _seg_64()
+    + _seg_65()
+    + _seg_66()
+    + _seg_67()
+    + _seg_68()
+    + _seg_69()
+    + _seg_70()
+    + _seg_71()
+    + _seg_72()
+    + _seg_73()
+    + _seg_74()
+    + _seg_75()
+    + _seg_76()
+    + _seg_77()
+    + _seg_78()
+    + _seg_79()
+)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/ipaddress.py b/myenv/lib/python3.9/site-packages/pip/_vendor/ipaddress.py
new file mode 100644
index 0000000..3e6f9e4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/ipaddress.py
@@ -0,0 +1,2420 @@
+# Copyright 2007 Google Inc.
+#  Licensed to PSF under a Contributor Agreement.
+
+"""A fast, lightweight IPv4/IPv6 manipulation library in Python.
+
+This library is used to create/poke/manipulate IPv4 and IPv6 addresses
+and networks.
+
+"""
+
+from __future__ import unicode_literals
+
+
+import itertools
+import struct
+
+__version__ = '1.0.23'
+
+# Compatibility functions
+_compat_int_types = (int,)
+try:
+    _compat_int_types = (int, long)
+except NameError:
+    pass
+try:
+    _compat_str = unicode
+except NameError:
+    _compat_str = str
+    assert bytes != str
+if b'\0'[0] == 0:  # Python 3 semantics
+    def _compat_bytes_to_byte_vals(byt):
+        return byt
+else:
+    def _compat_bytes_to_byte_vals(byt):
+        return [struct.unpack(b'!B', b)[0] for b in byt]
+try:
+    _compat_int_from_byte_vals = int.from_bytes
+except AttributeError:
+    def _compat_int_from_byte_vals(bytvals, endianess):
+        assert endianess == 'big'
+        res = 0
+        for bv in bytvals:
+            assert isinstance(bv, _compat_int_types)
+            res = (res << 8) + bv
+        return res
+
+
+def _compat_to_bytes(intval, length, endianess):
+    assert isinstance(intval, _compat_int_types)
+    assert endianess == 'big'
+    if length == 4:
+        if intval < 0 or intval >= 2 ** 32:
+            raise struct.error("integer out of range for 'I' format code")
+        return struct.pack(b'!I', intval)
+    elif length == 16:
+        if intval < 0 or intval >= 2 ** 128:
+            raise struct.error("integer out of range for 'QQ' format code")
+        return struct.pack(b'!QQ', intval >> 64, intval & 0xffffffffffffffff)
+    else:
+        raise NotImplementedError()
+
+
+if hasattr(int, 'bit_length'):
+    # Not int.bit_length , since that won't work in 2.7 where long exists
+    def _compat_bit_length(i):
+        return i.bit_length()
+else:
+    def _compat_bit_length(i):
+        for res in itertools.count():
+            if i >> res == 0:
+                return res
+
+
+def _compat_range(start, end, step=1):
+    assert step > 0
+    i = start
+    while i < end:
+        yield i
+        i += step
+
+
+class _TotalOrderingMixin(object):
+    __slots__ = ()
+
+    # Helper that derives the other comparison operations from
+    # __lt__ and __eq__
+    # We avoid functools.total_ordering because it doesn't handle
+    # NotImplemented correctly yet (http://bugs.python.org/issue10042)
+    def __eq__(self, other):
+        raise NotImplementedError
+
+    def __ne__(self, other):
+        equal = self.__eq__(other)
+        if equal is NotImplemented:
+            return NotImplemented
+        return not equal
+
+    def __lt__(self, other):
+        raise NotImplementedError
+
+    def __le__(self, other):
+        less = self.__lt__(other)
+        if less is NotImplemented or not less:
+            return self.__eq__(other)
+        return less
+
+    def __gt__(self, other):
+        less = self.__lt__(other)
+        if less is NotImplemented:
+            return NotImplemented
+        equal = self.__eq__(other)
+        if equal is NotImplemented:
+            return NotImplemented
+        return not (less or equal)
+
+    def __ge__(self, other):
+        less = self.__lt__(other)
+        if less is NotImplemented:
+            return NotImplemented
+        return not less
+
+
+IPV4LENGTH = 32
+IPV6LENGTH = 128
+
+
+class AddressValueError(ValueError):
+    """A Value Error related to the address."""
+
+
+class NetmaskValueError(ValueError):
+    """A Value Error related to the netmask."""
+
+
+def ip_address(address):
+    """Take an IP string/int and return an object of the correct type.
+
+    Args:
+        address: A string or integer, the IP address.  Either IPv4 or
+          IPv6 addresses may be supplied; integers less than 2**32 will
+          be considered to be IPv4 by default.
+
+    Returns:
+        An IPv4Address or IPv6Address object.
+
+    Raises:
+        ValueError: if the *address* passed isn't either a v4 or a v6
+          address
+
+    """
+    try:
+        return IPv4Address(address)
+    except (AddressValueError, NetmaskValueError):
+        pass
+
+    try:
+        return IPv6Address(address)
+    except (AddressValueError, NetmaskValueError):
+        pass
+
+    if isinstance(address, bytes):
+        raise AddressValueError(
+            '%r does not appear to be an IPv4 or IPv6 address. '
+            'Did you pass in a bytes (str in Python 2) instead of'
+            ' a unicode object?' % address)
+
+    raise ValueError('%r does not appear to be an IPv4 or IPv6 address' %
+                     address)
+
+
+def ip_network(address, strict=True):
+    """Take an IP string/int and return an object of the correct type.
+
+    Args:
+        address: A string or integer, the IP network.  Either IPv4 or
+          IPv6 networks may be supplied; integers less than 2**32 will
+          be considered to be IPv4 by default.
+
+    Returns:
+        An IPv4Network or IPv6Network object.
+
+    Raises:
+        ValueError: if the string passed isn't either a v4 or a v6
+          address. Or if the network has host bits set.
+
+    """
+    try:
+        return IPv4Network(address, strict)
+    except (AddressValueError, NetmaskValueError):
+        pass
+
+    try:
+        return IPv6Network(address, strict)
+    except (AddressValueError, NetmaskValueError):
+        pass
+
+    if isinstance(address, bytes):
+        raise AddressValueError(
+            '%r does not appear to be an IPv4 or IPv6 network. '
+            'Did you pass in a bytes (str in Python 2) instead of'
+            ' a unicode object?' % address)
+
+    raise ValueError('%r does not appear to be an IPv4 or IPv6 network' %
+                     address)
+
+
+def ip_interface(address):
+    """Take an IP string/int and return an object of the correct type.
+
+    Args:
+        address: A string or integer, the IP address.  Either IPv4 or
+          IPv6 addresses may be supplied; integers less than 2**32 will
+          be considered to be IPv4 by default.
+
+    Returns:
+        An IPv4Interface or IPv6Interface object.
+
+    Raises:
+        ValueError: if the string passed isn't either a v4 or a v6
+          address.
+
+    Notes:
+        The IPv?Interface classes describe an Address on a particular
+        Network, so they're basically a combination of both the Address
+        and Network classes.
+
+    """
+    try:
+        return IPv4Interface(address)
+    except (AddressValueError, NetmaskValueError):
+        pass
+
+    try:
+        return IPv6Interface(address)
+    except (AddressValueError, NetmaskValueError):
+        pass
+
+    raise ValueError('%r does not appear to be an IPv4 or IPv6 interface' %
+                     address)
+
+
+def v4_int_to_packed(address):
+    """Represent an address as 4 packed bytes in network (big-endian) order.
+
+    Args:
+        address: An integer representation of an IPv4 IP address.
+
+    Returns:
+        The integer address packed as 4 bytes in network (big-endian) order.
+
+    Raises:
+        ValueError: If the integer is negative or too large to be an
+          IPv4 IP address.
+
+    """
+    try:
+        return _compat_to_bytes(address, 4, 'big')
+    except (struct.error, OverflowError):
+        raise ValueError("Address negative or too large for IPv4")
+
+
+def v6_int_to_packed(address):
+    """Represent an address as 16 packed bytes in network (big-endian) order.
+
+    Args:
+        address: An integer representation of an IPv6 IP address.
+
+    Returns:
+        The integer address packed as 16 bytes in network (big-endian) order.
+
+    """
+    try:
+        return _compat_to_bytes(address, 16, 'big')
+    except (struct.error, OverflowError):
+        raise ValueError("Address negative or too large for IPv6")
+
+
+def _split_optional_netmask(address):
+    """Helper to split the netmask and raise AddressValueError if needed"""
+    addr = _compat_str(address).split('/')
+    if len(addr) > 2:
+        raise AddressValueError("Only one '/' permitted in %r" % address)
+    return addr
+
+
+def _find_address_range(addresses):
+    """Find a sequence of sorted deduplicated IPv#Address.
+
+    Args:
+        addresses: a list of IPv#Address objects.
+
+    Yields:
+        A tuple containing the first and last IP addresses in the sequence.
+
+    """
+    it = iter(addresses)
+    first = last = next(it)
+    for ip in it:
+        if ip._ip != last._ip + 1:
+            yield first, last
+            first = ip
+        last = ip
+    yield first, last
+
+
+def _count_righthand_zero_bits(number, bits):
+    """Count the number of zero bits on the right hand side.
+
+    Args:
+        number: an integer.
+        bits: maximum number of bits to count.
+
+    Returns:
+        The number of zero bits on the right hand side of the number.
+
+    """
+    if number == 0:
+        return bits
+    return min(bits, _compat_bit_length(~number & (number - 1)))
+
+
+def summarize_address_range(first, last):
+    """Summarize a network range given the first and last IP addresses.
+
+    Example:
+        >>> list(summarize_address_range(IPv4Address('192.0.2.0'),
+        ...                              IPv4Address('192.0.2.130')))
+        ...                                #doctest: +NORMALIZE_WHITESPACE
+        [IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/31'),
+         IPv4Network('192.0.2.130/32')]
+
+    Args:
+        first: the first IPv4Address or IPv6Address in the range.
+        last: the last IPv4Address or IPv6Address in the range.
+
+    Returns:
+        An iterator of the summarized IPv(4|6) network objects.
+
+    Raise:
+        TypeError:
+            If the first and last objects are not IP addresses.
+            If the first and last objects are not the same version.
+        ValueError:
+            If the last object is not greater than the first.
+            If the version of the first address is not 4 or 6.
+
+    """
+    if (not (isinstance(first, _BaseAddress) and
+             isinstance(last, _BaseAddress))):
+        raise TypeError('first and last must be IP addresses, not networks')
+    if first.version != last.version:
+        raise TypeError("%s and %s are not of the same version" % (
+                        first, last))
+    if first > last:
+        raise ValueError('last IP address must be greater than first')
+
+    if first.version == 4:
+        ip = IPv4Network
+    elif first.version == 6:
+        ip = IPv6Network
+    else:
+        raise ValueError('unknown IP version')
+
+    ip_bits = first._max_prefixlen
+    first_int = first._ip
+    last_int = last._ip
+    while first_int <= last_int:
+        nbits = min(_count_righthand_zero_bits(first_int, ip_bits),
+                    _compat_bit_length(last_int - first_int + 1) - 1)
+        net = ip((first_int, ip_bits - nbits))
+        yield net
+        first_int += 1 << nbits
+        if first_int - 1 == ip._ALL_ONES:
+            break
+
+
+def _collapse_addresses_internal(addresses):
+    """Loops through the addresses, collapsing concurrent netblocks.
+
+    Example:
+
+        ip1 = IPv4Network('192.0.2.0/26')
+        ip2 = IPv4Network('192.0.2.64/26')
+        ip3 = IPv4Network('192.0.2.128/26')
+        ip4 = IPv4Network('192.0.2.192/26')
+
+        _collapse_addresses_internal([ip1, ip2, ip3, ip4]) ->
+          [IPv4Network('192.0.2.0/24')]
+
+        This shouldn't be called directly; it is called via
+          collapse_addresses([]).
+
+    Args:
+        addresses: A list of IPv4Network's or IPv6Network's
+
+    Returns:
+        A list of IPv4Network's or IPv6Network's depending on what we were
+        passed.
+
+    """
+    # First merge
+    to_merge = list(addresses)
+    subnets = {}
+    while to_merge:
+        net = to_merge.pop()
+        supernet = net.supernet()
+        existing = subnets.get(supernet)
+        if existing is None:
+            subnets[supernet] = net
+        elif existing != net:
+            # Merge consecutive subnets
+            del subnets[supernet]
+            to_merge.append(supernet)
+    # Then iterate over resulting networks, skipping subsumed subnets
+    last = None
+    for net in sorted(subnets.values()):
+        if last is not None:
+            # Since they are sorted,
+            # last.network_address <= net.network_address is a given.
+            if last.broadcast_address >= net.broadcast_address:
+                continue
+        yield net
+        last = net
+
+
+def collapse_addresses(addresses):
+    """Collapse a list of IP objects.
+
+    Example:
+        collapse_addresses([IPv4Network('192.0.2.0/25'),
+                            IPv4Network('192.0.2.128/25')]) ->
+                           [IPv4Network('192.0.2.0/24')]
+
+    Args:
+        addresses: An iterator of IPv4Network or IPv6Network objects.
+
+    Returns:
+        An iterator of the collapsed IPv(4|6)Network objects.
+
+    Raises:
+        TypeError: If passed a list of mixed version objects.
+
+    """
+    addrs = []
+    ips = []
+    nets = []
+
+    # split IP addresses and networks
+    for ip in addresses:
+        if isinstance(ip, _BaseAddress):
+            if ips and ips[-1]._version != ip._version:
+                raise TypeError("%s and %s are not of the same version" % (
+                                ip, ips[-1]))
+            ips.append(ip)
+        elif ip._prefixlen == ip._max_prefixlen:
+            if ips and ips[-1]._version != ip._version:
+                raise TypeError("%s and %s are not of the same version" % (
+                                ip, ips[-1]))
+            try:
+                ips.append(ip.ip)
+            except AttributeError:
+                ips.append(ip.network_address)
+        else:
+            if nets and nets[-1]._version != ip._version:
+                raise TypeError("%s and %s are not of the same version" % (
+                                ip, nets[-1]))
+            nets.append(ip)
+
+    # sort and dedup
+    ips = sorted(set(ips))
+
+    # find consecutive address ranges in the sorted sequence and summarize them
+    if ips:
+        for first, last in _find_address_range(ips):
+            addrs.extend(summarize_address_range(first, last))
+
+    return _collapse_addresses_internal(addrs + nets)
+
+
+def get_mixed_type_key(obj):
+    """Return a key suitable for sorting between networks and addresses.
+
+    Address and Network objects are not sortable by default; they're
+    fundamentally different so the expression
+
+        IPv4Address('192.0.2.0') <= IPv4Network('192.0.2.0/24')
+
+    doesn't make any sense.  There are some times however, where you may wish
+    to have ipaddress sort these for you anyway. If you need to do this, you
+    can use this function as the key= argument to sorted().
+
+    Args:
+      obj: either a Network or Address object.
+    Returns:
+      appropriate key.
+
+    """
+    if isinstance(obj, _BaseNetwork):
+        return obj._get_networks_key()
+    elif isinstance(obj, _BaseAddress):
+        return obj._get_address_key()
+    return NotImplemented
+
+
+class _IPAddressBase(_TotalOrderingMixin):
+
+    """The mother class."""
+
+    __slots__ = ()
+
+    @property
+    def exploded(self):
+        """Return the longhand version of the IP address as a string."""
+        return self._explode_shorthand_ip_string()
+
+    @property
+    def compressed(self):
+        """Return the shorthand version of the IP address as a string."""
+        return _compat_str(self)
+
+    @property
+    def reverse_pointer(self):
+        """The name of the reverse DNS pointer for the IP address, e.g.:
+            >>> ipaddress.ip_address("127.0.0.1").reverse_pointer
+            '1.0.0.127.in-addr.arpa'
+            >>> ipaddress.ip_address("2001:db8::1").reverse_pointer
+            '1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa'
+
+        """
+        return self._reverse_pointer()
+
+    @property
+    def version(self):
+        msg = '%200s has no version specified' % (type(self),)
+        raise NotImplementedError(msg)
+
+    def _check_int_address(self, address):
+        if address < 0:
+            msg = "%d (< 0) is not permitted as an IPv%d address"
+            raise AddressValueError(msg % (address, self._version))
+        if address > self._ALL_ONES:
+            msg = "%d (>= 2**%d) is not permitted as an IPv%d address"
+            raise AddressValueError(msg % (address, self._max_prefixlen,
+                                           self._version))
+
+    def _check_packed_address(self, address, expected_len):
+        address_len = len(address)
+        if address_len != expected_len:
+            msg = (
+                '%r (len %d != %d) is not permitted as an IPv%d address. '
+                'Did you pass in a bytes (str in Python 2) instead of'
+                ' a unicode object?')
+            raise AddressValueError(msg % (address, address_len,
+                                           expected_len, self._version))
+
+    @classmethod
+    def _ip_int_from_prefix(cls, prefixlen):
+        """Turn the prefix length into a bitwise netmask
+
+        Args:
+            prefixlen: An integer, the prefix length.
+
+        Returns:
+            An integer.
+
+        """
+        return cls._ALL_ONES ^ (cls._ALL_ONES >> prefixlen)
+
+    @classmethod
+    def _prefix_from_ip_int(cls, ip_int):
+        """Return prefix length from the bitwise netmask.
+
+        Args:
+            ip_int: An integer, the netmask in expanded bitwise format
+
+        Returns:
+            An integer, the prefix length.
+
+        Raises:
+            ValueError: If the input intermingles zeroes & ones
+        """
+        trailing_zeroes = _count_righthand_zero_bits(ip_int,
+                                                     cls._max_prefixlen)
+        prefixlen = cls._max_prefixlen - trailing_zeroes
+        leading_ones = ip_int >> trailing_zeroes
+        all_ones = (1 << prefixlen) - 1
+        if leading_ones != all_ones:
+            byteslen = cls._max_prefixlen // 8
+            details = _compat_to_bytes(ip_int, byteslen, 'big')
+            msg = 'Netmask pattern %r mixes zeroes & ones'
+            raise ValueError(msg % details)
+        return prefixlen
+
+    @classmethod
+    def _report_invalid_netmask(cls, netmask_str):
+        msg = '%r is not a valid netmask' % netmask_str
+        raise NetmaskValueError(msg)
+
+    @classmethod
+    def _prefix_from_prefix_string(cls, prefixlen_str):
+        """Return prefix length from a numeric string
+
+        Args:
+            prefixlen_str: The string to be converted
+
+        Returns:
+            An integer, the prefix length.
+
+        Raises:
+            NetmaskValueError: If the input is not a valid netmask
+        """
+        # int allows a leading +/- as well as surrounding whitespace,
+        # so we ensure that isn't the case
+        if not _BaseV4._DECIMAL_DIGITS.issuperset(prefixlen_str):
+            cls._report_invalid_netmask(prefixlen_str)
+        try:
+            prefixlen = int(prefixlen_str)
+        except ValueError:
+            cls._report_invalid_netmask(prefixlen_str)
+        if not (0 <= prefixlen <= cls._max_prefixlen):
+            cls._report_invalid_netmask(prefixlen_str)
+        return prefixlen
+
+    @classmethod
+    def _prefix_from_ip_string(cls, ip_str):
+        """Turn a netmask/hostmask string into a prefix length
+
+        Args:
+            ip_str: The netmask/hostmask to be converted
+
+        Returns:
+            An integer, the prefix length.
+
+        Raises:
+            NetmaskValueError: If the input is not a valid netmask/hostmask
+        """
+        # Parse the netmask/hostmask like an IP address.
+        try:
+            ip_int = cls._ip_int_from_string(ip_str)
+        except AddressValueError:
+            cls._report_invalid_netmask(ip_str)
+
+        # Try matching a netmask (this would be /1*0*/ as a bitwise regexp).
+        # Note that the two ambiguous cases (all-ones and all-zeroes) are
+        # treated as netmasks.
+        try:
+            return cls._prefix_from_ip_int(ip_int)
+        except ValueError:
+            pass
+
+        # Invert the bits, and try matching a /0+1+/ hostmask instead.
+        ip_int ^= cls._ALL_ONES
+        try:
+            return cls._prefix_from_ip_int(ip_int)
+        except ValueError:
+            cls._report_invalid_netmask(ip_str)
+
+    def __reduce__(self):
+        return self.__class__, (_compat_str(self),)
+
+
+class _BaseAddress(_IPAddressBase):
+
+    """A generic IP object.
+
+    This IP class contains the version independent methods which are
+    used by single IP addresses.
+    """
+
+    __slots__ = ()
+
+    def __int__(self):
+        return self._ip
+
+    def __eq__(self, other):
+        try:
+            return (self._ip == other._ip and
+                    self._version == other._version)
+        except AttributeError:
+            return NotImplemented
+
+    def __lt__(self, other):
+        if not isinstance(other, _IPAddressBase):
+            return NotImplemented
+        if not isinstance(other, _BaseAddress):
+            raise TypeError('%s and %s are not of the same type' % (
+                self, other))
+        if self._version != other._version:
+            raise TypeError('%s and %s are not of the same version' % (
+                self, other))
+        if self._ip != other._ip:
+            return self._ip < other._ip
+        return False
+
+    # Shorthand for Integer addition and subtraction. This is not
+    # meant to ever support addition/subtraction of addresses.
+    def __add__(self, other):
+        if not isinstance(other, _compat_int_types):
+            return NotImplemented
+        return self.__class__(int(self) + other)
+
+    def __sub__(self, other):
+        if not isinstance(other, _compat_int_types):
+            return NotImplemented
+        return self.__class__(int(self) - other)
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, _compat_str(self))
+
+    def __str__(self):
+        return _compat_str(self._string_from_ip_int(self._ip))
+
+    def __hash__(self):
+        return hash(hex(int(self._ip)))
+
+    def _get_address_key(self):
+        return (self._version, self)
+
+    def __reduce__(self):
+        return self.__class__, (self._ip,)
+
+
+class _BaseNetwork(_IPAddressBase):
+
+    """A generic IP network object.
+
+    This IP class contains the version independent methods which are
+    used by networks.
+
+    """
+    def __init__(self, address):
+        self._cache = {}
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, _compat_str(self))
+
+    def __str__(self):
+        return '%s/%d' % (self.network_address, self.prefixlen)
+
+    def hosts(self):
+        """Generate Iterator over usable hosts in a network.
+
+        This is like __iter__ except it doesn't return the network
+        or broadcast addresses.
+
+        """
+        network = int(self.network_address)
+        broadcast = int(self.broadcast_address)
+        for x in _compat_range(network + 1, broadcast):
+            yield self._address_class(x)
+
+    def __iter__(self):
+        network = int(self.network_address)
+        broadcast = int(self.broadcast_address)
+        for x in _compat_range(network, broadcast + 1):
+            yield self._address_class(x)
+
+    def __getitem__(self, n):
+        network = int(self.network_address)
+        broadcast = int(self.broadcast_address)
+        if n >= 0:
+            if network + n > broadcast:
+                raise IndexError('address out of range')
+            return self._address_class(network + n)
+        else:
+            n += 1
+            if broadcast + n < network:
+                raise IndexError('address out of range')
+            return self._address_class(broadcast + n)
+
+    def __lt__(self, other):
+        if not isinstance(other, _IPAddressBase):
+            return NotImplemented
+        if not isinstance(other, _BaseNetwork):
+            raise TypeError('%s and %s are not of the same type' % (
+                            self, other))
+        if self._version != other._version:
+            raise TypeError('%s and %s are not of the same version' % (
+                            self, other))
+        if self.network_address != other.network_address:
+            return self.network_address < other.network_address
+        if self.netmask != other.netmask:
+            return self.netmask < other.netmask
+        return False
+
+    def __eq__(self, other):
+        try:
+            return (self._version == other._version and
+                    self.network_address == other.network_address and
+                    int(self.netmask) == int(other.netmask))
+        except AttributeError:
+            return NotImplemented
+
+    def __hash__(self):
+        return hash(int(self.network_address) ^ int(self.netmask))
+
+    def __contains__(self, other):
+        # always false if one is v4 and the other is v6.
+        if self._version != other._version:
+            return False
+        # dealing with another network.
+        if isinstance(other, _BaseNetwork):
+            return False
+        # dealing with another address
+        else:
+            # address
+            return (int(self.network_address) <= int(other._ip) <=
+                    int(self.broadcast_address))
+
+    def overlaps(self, other):
+        """Tell if self is partly contained in other."""
+        return self.network_address in other or (
+            self.broadcast_address in other or (
+                other.network_address in self or (
+                    other.broadcast_address in self)))
+
+    @property
+    def broadcast_address(self):
+        x = self._cache.get('broadcast_address')
+        if x is None:
+            x = self._address_class(int(self.network_address) |
+                                    int(self.hostmask))
+            self._cache['broadcast_address'] = x
+        return x
+
+    @property
+    def hostmask(self):
+        x = self._cache.get('hostmask')
+        if x is None:
+            x = self._address_class(int(self.netmask) ^ self._ALL_ONES)
+            self._cache['hostmask'] = x
+        return x
+
+    @property
+    def with_prefixlen(self):
+        return '%s/%d' % (self.network_address, self._prefixlen)
+
+    @property
+    def with_netmask(self):
+        return '%s/%s' % (self.network_address, self.netmask)
+
+    @property
+    def with_hostmask(self):
+        return '%s/%s' % (self.network_address, self.hostmask)
+
+    @property
+    def num_addresses(self):
+        """Number of hosts in the current subnet."""
+        return int(self.broadcast_address) - int(self.network_address) + 1
+
+    @property
+    def _address_class(self):
+        # Returning bare address objects (rather than interfaces) allows for
+        # more consistent behaviour across the network address, broadcast
+        # address and individual host addresses.
+        msg = '%200s has no associated address class' % (type(self),)
+        raise NotImplementedError(msg)
+
+    @property
+    def prefixlen(self):
+        return self._prefixlen
+
+    def address_exclude(self, other):
+        """Remove an address from a larger block.
+
+        For example:
+
+            addr1 = ip_network('192.0.2.0/28')
+            addr2 = ip_network('192.0.2.1/32')
+            list(addr1.address_exclude(addr2)) =
+                [IPv4Network('192.0.2.0/32'), IPv4Network('192.0.2.2/31'),
+                 IPv4Network('192.0.2.4/30'), IPv4Network('192.0.2.8/29')]
+
+        or IPv6:
+
+            addr1 = ip_network('2001:db8::1/32')
+            addr2 = ip_network('2001:db8::1/128')
+            list(addr1.address_exclude(addr2)) =
+                [ip_network('2001:db8::1/128'),
+                 ip_network('2001:db8::2/127'),
+                 ip_network('2001:db8::4/126'),
+                 ip_network('2001:db8::8/125'),
+                 ...
+                 ip_network('2001:db8:8000::/33')]
+
+        Args:
+            other: An IPv4Network or IPv6Network object of the same type.
+
+        Returns:
+            An iterator of the IPv(4|6)Network objects which is self
+            minus other.
+
+        Raises:
+            TypeError: If self and other are of differing address
+              versions, or if other is not a network object.
+            ValueError: If other is not completely contained by self.
+
+        """
+        if not self._version == other._version:
+            raise TypeError("%s and %s are not of the same version" % (
+                            self, other))
+
+        if not isinstance(other, _BaseNetwork):
+            raise TypeError("%s is not a network object" % other)
+
+        if not other.subnet_of(self):
+            raise ValueError('%s not contained in %s' % (other, self))
+        if other == self:
+            return
+
+        # Make sure we're comparing the network of other.
+        other = other.__class__('%s/%s' % (other.network_address,
+                                           other.prefixlen))
+
+        s1, s2 = self.subnets()
+        while s1 != other and s2 != other:
+            if other.subnet_of(s1):
+                yield s2
+                s1, s2 = s1.subnets()
+            elif other.subnet_of(s2):
+                yield s1
+                s1, s2 = s2.subnets()
+            else:
+                # If we got here, there's a bug somewhere.
+                raise AssertionError('Error performing exclusion: '
+                                     's1: %s s2: %s other: %s' %
+                                     (s1, s2, other))
+        if s1 == other:
+            yield s2
+        elif s2 == other:
+            yield s1
+        else:
+            # If we got here, there's a bug somewhere.
+            raise AssertionError('Error performing exclusion: '
+                                 's1: %s s2: %s other: %s' %
+                                 (s1, s2, other))
+
+    def compare_networks(self, other):
+        """Compare two IP objects.
+
+        This is only concerned about the comparison of the integer
+        representation of the network addresses.  This means that the
+        host bits aren't considered at all in this method.  If you want
+        to compare host bits, you can easily enough do a
+        'HostA._ip < HostB._ip'
+
+        Args:
+            other: An IP object.
+
+        Returns:
+            If the IP versions of self and other are the same, returns:
+
+            -1 if self < other:
+              eg: IPv4Network('192.0.2.0/25') < IPv4Network('192.0.2.128/25')
+              IPv6Network('2001:db8::1000/124') <
+                  IPv6Network('2001:db8::2000/124')
+            0 if self == other
+              eg: IPv4Network('192.0.2.0/24') == IPv4Network('192.0.2.0/24')
+              IPv6Network('2001:db8::1000/124') ==
+                  IPv6Network('2001:db8::1000/124')
+            1 if self > other
+              eg: IPv4Network('192.0.2.128/25') > IPv4Network('192.0.2.0/25')
+                  IPv6Network('2001:db8::2000/124') >
+                      IPv6Network('2001:db8::1000/124')
+
+          Raises:
+              TypeError if the IP versions are different.
+
+        """
+        # does this need to raise a ValueError?
+        if self._version != other._version:
+            raise TypeError('%s and %s are not of the same type' % (
+                            self, other))
+        # self._version == other._version below here:
+        if self.network_address < other.network_address:
+            return -1
+        if self.network_address > other.network_address:
+            return 1
+        # self.network_address == other.network_address below here:
+        if self.netmask < other.netmask:
+            return -1
+        if self.netmask > other.netmask:
+            return 1
+        return 0
+
+    def _get_networks_key(self):
+        """Network-only key function.
+
+        Returns an object that identifies this address' network and
+        netmask. This function is a suitable "key" argument for sorted()
+        and list.sort().
+
+        """
+        return (self._version, self.network_address, self.netmask)
+
+    def subnets(self, prefixlen_diff=1, new_prefix=None):
+        """The subnets which join to make the current subnet.
+
+        In the case that self contains only one IP
+        (self._prefixlen == 32 for IPv4 or self._prefixlen == 128
+        for IPv6), yield an iterator with just ourself.
+
+        Args:
+            prefixlen_diff: An integer, the amount the prefix length
+              should be increased by. This should not be set if
+              new_prefix is also set.
+            new_prefix: The desired new prefix length. This must be a
+              larger number (smaller prefix) than the existing prefix.
+              This should not be set if prefixlen_diff is also set.
+
+        Returns:
+            An iterator of IPv(4|6) objects.
+
+        Raises:
+            ValueError: The prefixlen_diff is too small or too large.
+                OR
+            prefixlen_diff and new_prefix are both set or new_prefix
+              is a smaller number than the current prefix (smaller
+              number means a larger network)
+
+        """
+        if self._prefixlen == self._max_prefixlen:
+            yield self
+            return
+
+        if new_prefix is not None:
+            if new_prefix < self._prefixlen:
+                raise ValueError('new prefix must be longer')
+            if prefixlen_diff != 1:
+                raise ValueError('cannot set prefixlen_diff and new_prefix')
+            prefixlen_diff = new_prefix - self._prefixlen
+
+        if prefixlen_diff < 0:
+            raise ValueError('prefix length diff must be > 0')
+        new_prefixlen = self._prefixlen + prefixlen_diff
+
+        if new_prefixlen > self._max_prefixlen:
+            raise ValueError(
+                'prefix length diff %d is invalid for netblock %s' % (
+                    new_prefixlen, self))
+
+        start = int(self.network_address)
+        end = int(self.broadcast_address) + 1
+        step = (int(self.hostmask) + 1) >> prefixlen_diff
+        for new_addr in _compat_range(start, end, step):
+            current = self.__class__((new_addr, new_prefixlen))
+            yield current
+
+    def supernet(self, prefixlen_diff=1, new_prefix=None):
+        """The supernet containing the current network.
+
+        Args:
+            prefixlen_diff: An integer, the amount the prefix length of
+              the network should be decreased by.  For example, given a
+              /24 network and a prefixlen_diff of 3, a supernet with a
+              /21 netmask is returned.
+
+        Returns:
+            An IPv4 network object.
+
+        Raises:
+            ValueError: If self.prefixlen - prefixlen_diff < 0. I.e., you have
+              a negative prefix length.
+                OR
+            If prefixlen_diff and new_prefix are both set or new_prefix is a
+              larger number than the current prefix (larger number means a
+              smaller network)
+
+        """
+        if self._prefixlen == 0:
+            return self
+
+        if new_prefix is not None:
+            if new_prefix > self._prefixlen:
+                raise ValueError('new prefix must be shorter')
+            if prefixlen_diff != 1:
+                raise ValueError('cannot set prefixlen_diff and new_prefix')
+            prefixlen_diff = self._prefixlen - new_prefix
+
+        new_prefixlen = self.prefixlen - prefixlen_diff
+        if new_prefixlen < 0:
+            raise ValueError(
+                'current prefixlen is %d, cannot have a prefixlen_diff of %d' %
+                (self.prefixlen, prefixlen_diff))
+        return self.__class__((
+            int(self.network_address) & (int(self.netmask) << prefixlen_diff),
+            new_prefixlen))
+
+    @property
+    def is_multicast(self):
+        """Test if the address is reserved for multicast use.
+
+        Returns:
+            A boolean, True if the address is a multicast address.
+            See RFC 2373 2.7 for details.
+
+        """
+        return (self.network_address.is_multicast and
+                self.broadcast_address.is_multicast)
+
+    @staticmethod
+    def _is_subnet_of(a, b):
+        try:
+            # Always false if one is v4 and the other is v6.
+            if a._version != b._version:
+                raise TypeError(
+                    "%s and %s are not of the same version" % (a, b))
+            return (b.network_address <= a.network_address and
+                    b.broadcast_address >= a.broadcast_address)
+        except AttributeError:
+            raise TypeError("Unable to test subnet containment "
+                            "between %s and %s" % (a, b))
+
+    def subnet_of(self, other):
+        """Return True if this network is a subnet of other."""
+        return self._is_subnet_of(self, other)
+
+    def supernet_of(self, other):
+        """Return True if this network is a supernet of other."""
+        return self._is_subnet_of(other, self)
+
+    @property
+    def is_reserved(self):
+        """Test if the address is otherwise IETF reserved.
+
+        Returns:
+            A boolean, True if the address is within one of the
+            reserved IPv6 Network ranges.
+
+        """
+        return (self.network_address.is_reserved and
+                self.broadcast_address.is_reserved)
+
+    @property
+    def is_link_local(self):
+        """Test if the address is reserved for link-local.
+
+        Returns:
+            A boolean, True if the address is reserved per RFC 4291.
+
+        """
+        return (self.network_address.is_link_local and
+                self.broadcast_address.is_link_local)
+
+    @property
+    def is_private(self):
+        """Test if this address is allocated for private networks.
+
+        Returns:
+            A boolean, True if the address is reserved per
+            iana-ipv4-special-registry or iana-ipv6-special-registry.
+
+        """
+        return (self.network_address.is_private and
+                self.broadcast_address.is_private)
+
+    @property
+    def is_global(self):
+        """Test if this address is allocated for public networks.
+
+        Returns:
+            A boolean, True if the address is not reserved per
+            iana-ipv4-special-registry or iana-ipv6-special-registry.
+
+        """
+        return not self.is_private
+
+    @property
+    def is_unspecified(self):
+        """Test if the address is unspecified.
+
+        Returns:
+            A boolean, True if this is the unspecified address as defined in
+            RFC 2373 2.5.2.
+
+        """
+        return (self.network_address.is_unspecified and
+                self.broadcast_address.is_unspecified)
+
+    @property
+    def is_loopback(self):
+        """Test if the address is a loopback address.
+
+        Returns:
+            A boolean, True if the address is a loopback address as defined in
+            RFC 2373 2.5.3.
+
+        """
+        return (self.network_address.is_loopback and
+                self.broadcast_address.is_loopback)
+
+
+class _BaseV4(object):
+
+    """Base IPv4 object.
+
+    The following methods are used by IPv4 objects in both single IP
+    addresses and networks.
+
+    """
+
+    __slots__ = ()
+    _version = 4
+    # Equivalent to 255.255.255.255 or 32 bits of 1's.
+    _ALL_ONES = (2 ** IPV4LENGTH) - 1
+    _DECIMAL_DIGITS = frozenset('0123456789')
+
+    # the valid octets for host and netmasks. only useful for IPv4.
+    _valid_mask_octets = frozenset([255, 254, 252, 248, 240, 224, 192, 128, 0])
+
+    _max_prefixlen = IPV4LENGTH
+    # There are only a handful of valid v4 netmasks, so we cache them all
+    # when constructed (see _make_netmask()).
+    _netmask_cache = {}
+
+    def _explode_shorthand_ip_string(self):
+        return _compat_str(self)
+
+    @classmethod
+    def _make_netmask(cls, arg):
+        """Make a (netmask, prefix_len) tuple from the given argument.
+
+        Argument can be:
+        - an integer (the prefix length)
+        - a string representing the prefix length (e.g. "24")
+        - a string representing the prefix netmask (e.g. "255.255.255.0")
+        """
+        if arg not in cls._netmask_cache:
+            if isinstance(arg, _compat_int_types):
+                prefixlen = arg
+            else:
+                try:
+                    # Check for a netmask in prefix length form
+                    prefixlen = cls._prefix_from_prefix_string(arg)
+                except NetmaskValueError:
+                    # Check for a netmask or hostmask in dotted-quad form.
+                    # This may raise NetmaskValueError.
+                    prefixlen = cls._prefix_from_ip_string(arg)
+            netmask = IPv4Address(cls._ip_int_from_prefix(prefixlen))
+            cls._netmask_cache[arg] = netmask, prefixlen
+        return cls._netmask_cache[arg]
+
+    @classmethod
+    def _ip_int_from_string(cls, ip_str):
+        """Turn the given IP string into an integer for comparison.
+
+        Args:
+            ip_str: A string, the IP ip_str.
+
+        Returns:
+            The IP ip_str as an integer.
+
+        Raises:
+            AddressValueError: if ip_str isn't a valid IPv4 Address.
+
+        """
+        if not ip_str:
+            raise AddressValueError('Address cannot be empty')
+
+        octets = ip_str.split('.')
+        if len(octets) != 4:
+            raise AddressValueError("Expected 4 octets in %r" % ip_str)
+
+        try:
+            return _compat_int_from_byte_vals(
+                map(cls._parse_octet, octets), 'big')
+        except ValueError as exc:
+            raise AddressValueError("%s in %r" % (exc, ip_str))
+
+    @classmethod
+    def _parse_octet(cls, octet_str):
+        """Convert a decimal octet into an integer.
+
+        Args:
+            octet_str: A string, the number to parse.
+
+        Returns:
+            The octet as an integer.
+
+        Raises:
+            ValueError: if the octet isn't strictly a decimal from [0..255].
+
+        """
+        if not octet_str:
+            raise ValueError("Empty octet not permitted")
+        # Whitelist the characters, since int() allows a lot of bizarre stuff.
+        if not cls._DECIMAL_DIGITS.issuperset(octet_str):
+            msg = "Only decimal digits permitted in %r"
+            raise ValueError(msg % octet_str)
+        # We do the length check second, since the invalid character error
+        # is likely to be more informative for the user
+        if len(octet_str) > 3:
+            msg = "At most 3 characters permitted in %r"
+            raise ValueError(msg % octet_str)
+        # Convert to integer (we know digits are legal)
+        octet_int = int(octet_str, 10)
+        # Any octets that look like they *might* be written in octal,
+        # and which don't look exactly the same in both octal and
+        # decimal are rejected as ambiguous
+        if octet_int > 7 and octet_str[0] == '0':
+            msg = "Ambiguous (octal/decimal) value in %r not permitted"
+            raise ValueError(msg % octet_str)
+        if octet_int > 255:
+            raise ValueError("Octet %d (> 255) not permitted" % octet_int)
+        return octet_int
+
+    @classmethod
+    def _string_from_ip_int(cls, ip_int):
+        """Turns a 32-bit integer into dotted decimal notation.
+
+        Args:
+            ip_int: An integer, the IP address.
+
+        Returns:
+            The IP address as a string in dotted decimal notation.
+
+        """
+        return '.'.join(_compat_str(struct.unpack(b'!B', b)[0]
+                                    if isinstance(b, bytes)
+                                    else b)
+                        for b in _compat_to_bytes(ip_int, 4, 'big'))
+
+    def _is_hostmask(self, ip_str):
+        """Test if the IP string is a hostmask (rather than a netmask).
+
+        Args:
+            ip_str: A string, the potential hostmask.
+
+        Returns:
+            A boolean, True if the IP string is a hostmask.
+
+        """
+        bits = ip_str.split('.')
+        try:
+            parts = [x for x in map(int, bits) if x in self._valid_mask_octets]
+        except ValueError:
+            return False
+        if len(parts) != len(bits):
+            return False
+        if parts[0] < parts[-1]:
+            return True
+        return False
+
+    def _reverse_pointer(self):
+        """Return the reverse DNS pointer name for the IPv4 address.
+
+        This implements the method described in RFC1035 3.5.
+
+        """
+        reverse_octets = _compat_str(self).split('.')[::-1]
+        return '.'.join(reverse_octets) + '.in-addr.arpa'
+
+    @property
+    def max_prefixlen(self):
+        return self._max_prefixlen
+
+    @property
+    def version(self):
+        return self._version
+
+
+class IPv4Address(_BaseV4, _BaseAddress):
+
+    """Represent and manipulate single IPv4 Addresses."""
+
+    __slots__ = ('_ip', '__weakref__')
+
+    def __init__(self, address):
+
+        """
+        Args:
+            address: A string or integer representing the IP
+
+              Additionally, an integer can be passed, so
+              IPv4Address('192.0.2.1') == IPv4Address(3221225985).
+              or, more generally
+              IPv4Address(int(IPv4Address('192.0.2.1'))) ==
+                IPv4Address('192.0.2.1')
+
+        Raises:
+            AddressValueError: If ipaddress isn't a valid IPv4 address.
+
+        """
+        # Efficient constructor from integer.
+        if isinstance(address, _compat_int_types):
+            self._check_int_address(address)
+            self._ip = address
+            return
+
+        # Constructing from a packed address
+        if isinstance(address, bytes):
+            self._check_packed_address(address, 4)
+            bvs = _compat_bytes_to_byte_vals(address)
+            self._ip = _compat_int_from_byte_vals(bvs, 'big')
+            return
+
+        # Assume input argument to be string or any object representation
+        # which converts into a formatted IP string.
+        addr_str = _compat_str(address)
+        if '/' in addr_str:
+            raise AddressValueError("Unexpected '/' in %r" % address)
+        self._ip = self._ip_int_from_string(addr_str)
+
+    @property
+    def packed(self):
+        """The binary representation of this address."""
+        return v4_int_to_packed(self._ip)
+
+    @property
+    def is_reserved(self):
+        """Test if the address is otherwise IETF reserved.
+
+         Returns:
+             A boolean, True if the address is within the
+             reserved IPv4 Network range.
+
+        """
+        return self in self._constants._reserved_network
+
+    @property
+    def is_private(self):
+        """Test if this address is allocated for private networks.
+
+        Returns:
+            A boolean, True if the address is reserved per
+            iana-ipv4-special-registry.
+
+        """
+        return any(self in net for net in self._constants._private_networks)
+
+    @property
+    def is_global(self):
+        return (
+            self not in self._constants._public_network and
+            not self.is_private)
+
+    @property
+    def is_multicast(self):
+        """Test if the address is reserved for multicast use.
+
+        Returns:
+            A boolean, True if the address is multicast.
+            See RFC 3171 for details.
+
+        """
+        return self in self._constants._multicast_network
+
+    @property
+    def is_unspecified(self):
+        """Test if the address is unspecified.
+
+        Returns:
+            A boolean, True if this is the unspecified address as defined in
+            RFC 5735 3.
+
+        """
+        return self == self._constants._unspecified_address
+
+    @property
+    def is_loopback(self):
+        """Test if the address is a loopback address.
+
+        Returns:
+            A boolean, True if the address is a loopback per RFC 3330.
+
+        """
+        return self in self._constants._loopback_network
+
+    @property
+    def is_link_local(self):
+        """Test if the address is reserved for link-local.
+
+        Returns:
+            A boolean, True if the address is link-local per RFC 3927.
+
+        """
+        return self in self._constants._linklocal_network
+
+
+class IPv4Interface(IPv4Address):
+
+    def __init__(self, address):
+        if isinstance(address, (bytes, _compat_int_types)):
+            IPv4Address.__init__(self, address)
+            self.network = IPv4Network(self._ip)
+            self._prefixlen = self._max_prefixlen
+            return
+
+        if isinstance(address, tuple):
+            IPv4Address.__init__(self, address[0])
+            if len(address) > 1:
+                self._prefixlen = int(address[1])
+            else:
+                self._prefixlen = self._max_prefixlen
+
+            self.network = IPv4Network(address, strict=False)
+            self.netmask = self.network.netmask
+            self.hostmask = self.network.hostmask
+            return
+
+        addr = _split_optional_netmask(address)
+        IPv4Address.__init__(self, addr[0])
+
+        self.network = IPv4Network(address, strict=False)
+        self._prefixlen = self.network._prefixlen
+
+        self.netmask = self.network.netmask
+        self.hostmask = self.network.hostmask
+
+    def __str__(self):
+        return '%s/%d' % (self._string_from_ip_int(self._ip),
+                          self.network.prefixlen)
+
+    def __eq__(self, other):
+        address_equal = IPv4Address.__eq__(self, other)
+        if not address_equal or address_equal is NotImplemented:
+            return address_equal
+        try:
+            return self.network == other.network
+        except AttributeError:
+            # An interface with an associated network is NOT the
+            # same as an unassociated address. That's why the hash
+            # takes the extra info into account.
+            return False
+
+    def __lt__(self, other):
+        address_less = IPv4Address.__lt__(self, other)
+        if address_less is NotImplemented:
+            return NotImplemented
+        try:
+            return (self.network < other.network or
+                    self.network == other.network and address_less)
+        except AttributeError:
+            # We *do* allow addresses and interfaces to be sorted. The
+            # unassociated address is considered less than all interfaces.
+            return False
+
+    def __hash__(self):
+        return self._ip ^ self._prefixlen ^ int(self.network.network_address)
+
+    __reduce__ = _IPAddressBase.__reduce__
+
+    @property
+    def ip(self):
+        return IPv4Address(self._ip)
+
+    @property
+    def with_prefixlen(self):
+        return '%s/%s' % (self._string_from_ip_int(self._ip),
+                          self._prefixlen)
+
+    @property
+    def with_netmask(self):
+        return '%s/%s' % (self._string_from_ip_int(self._ip),
+                          self.netmask)
+
+    @property
+    def with_hostmask(self):
+        return '%s/%s' % (self._string_from_ip_int(self._ip),
+                          self.hostmask)
+
+
+class IPv4Network(_BaseV4, _BaseNetwork):
+
+    """This class represents and manipulates 32-bit IPv4 network + addresses..
+
+    Attributes: [examples for IPv4Network('192.0.2.0/27')]
+        .network_address: IPv4Address('192.0.2.0')
+        .hostmask: IPv4Address('0.0.0.31')
+        .broadcast_address: IPv4Address('192.0.2.32')
+        .netmask: IPv4Address('255.255.255.224')
+        .prefixlen: 27
+
+    """
+    # Class to use when creating address objects
+    _address_class = IPv4Address
+
+    def __init__(self, address, strict=True):
+
+        """Instantiate a new IPv4 network object.
+
+        Args:
+            address: A string or integer representing the IP [& network].
+              '192.0.2.0/24'
+              '192.0.2.0/255.255.255.0'
+              '192.0.0.2/0.0.0.255'
+              are all functionally the same in IPv4. Similarly,
+              '192.0.2.1'
+              '192.0.2.1/255.255.255.255'
+              '192.0.2.1/32'
+              are also functionally equivalent. That is to say, failing to
+              provide a subnetmask will create an object with a mask of /32.
+
+              If the mask (portion after the / in the argument) is given in
+              dotted quad form, it is treated as a netmask if it starts with a
+              non-zero field (e.g. /255.0.0.0 == /8) and as a hostmask if it
+              starts with a zero field (e.g. 0.255.255.255 == /8), with the
+              single exception of an all-zero mask which is treated as a
+              netmask == /0. If no mask is given, a default of /32 is used.
+
+              Additionally, an integer can be passed, so
+              IPv4Network('192.0.2.1') == IPv4Network(3221225985)
+              or, more generally
+              IPv4Interface(int(IPv4Interface('192.0.2.1'))) ==
+                IPv4Interface('192.0.2.1')
+
+        Raises:
+            AddressValueError: If ipaddress isn't a valid IPv4 address.
+            NetmaskValueError: If the netmask isn't valid for
+              an IPv4 address.
+            ValueError: If strict is True and a network address is not
+              supplied.
+
+        """
+        _BaseNetwork.__init__(self, address)
+
+        # Constructing from a packed address or integer
+        if isinstance(address, (_compat_int_types, bytes)):
+            self.network_address = IPv4Address(address)
+            self.netmask, self._prefixlen = self._make_netmask(
+                self._max_prefixlen)
+            # fixme: address/network test here.
+            return
+
+        if isinstance(address, tuple):
+            if len(address) > 1:
+                arg = address[1]
+            else:
+                # We weren't given an address[1]
+                arg = self._max_prefixlen
+            self.network_address = IPv4Address(address[0])
+            self.netmask, self._prefixlen = self._make_netmask(arg)
+            packed = int(self.network_address)
+            if packed & int(self.netmask) != packed:
+                if strict:
+                    raise ValueError('%s has host bits set' % self)
+                else:
+                    self.network_address = IPv4Address(packed &
+                                                       int(self.netmask))
+            return
+
+        # Assume input argument to be string or any object representation
+        # which converts into a formatted IP prefix string.
+        addr = _split_optional_netmask(address)
+        self.network_address = IPv4Address(self._ip_int_from_string(addr[0]))
+
+        if len(addr) == 2:
+            arg = addr[1]
+        else:
+            arg = self._max_prefixlen
+        self.netmask, self._prefixlen = self._make_netmask(arg)
+
+        if strict:
+            if (IPv4Address(int(self.network_address) & int(self.netmask)) !=
+                    self.network_address):
+                raise ValueError('%s has host bits set' % self)
+        self.network_address = IPv4Address(int(self.network_address) &
+                                           int(self.netmask))
+
+        if self._prefixlen == (self._max_prefixlen - 1):
+            self.hosts = self.__iter__
+
+    @property
+    def is_global(self):
+        """Test if this address is allocated for public networks.
+
+        Returns:
+            A boolean, True if the address is not reserved per
+            iana-ipv4-special-registry.
+
+        """
+        return (not (self.network_address in IPv4Network('100.64.0.0/10') and
+                self.broadcast_address in IPv4Network('100.64.0.0/10')) and
+                not self.is_private)
+
+
+class _IPv4Constants(object):
+
+    _linklocal_network = IPv4Network('169.254.0.0/16')
+
+    _loopback_network = IPv4Network('127.0.0.0/8')
+
+    _multicast_network = IPv4Network('224.0.0.0/4')
+
+    _public_network = IPv4Network('100.64.0.0/10')
+
+    _private_networks = [
+        IPv4Network('0.0.0.0/8'),
+        IPv4Network('10.0.0.0/8'),
+        IPv4Network('127.0.0.0/8'),
+        IPv4Network('169.254.0.0/16'),
+        IPv4Network('172.16.0.0/12'),
+        IPv4Network('192.0.0.0/29'),
+        IPv4Network('192.0.0.170/31'),
+        IPv4Network('192.0.2.0/24'),
+        IPv4Network('192.168.0.0/16'),
+        IPv4Network('198.18.0.0/15'),
+        IPv4Network('198.51.100.0/24'),
+        IPv4Network('203.0.113.0/24'),
+        IPv4Network('240.0.0.0/4'),
+        IPv4Network('255.255.255.255/32'),
+    ]
+
+    _reserved_network = IPv4Network('240.0.0.0/4')
+
+    _unspecified_address = IPv4Address('0.0.0.0')
+
+
+IPv4Address._constants = _IPv4Constants
+
+
+class _BaseV6(object):
+
+    """Base IPv6 object.
+
+    The following methods are used by IPv6 objects in both single IP
+    addresses and networks.
+
+    """
+
+    __slots__ = ()
+    _version = 6
+    _ALL_ONES = (2 ** IPV6LENGTH) - 1
+    _HEXTET_COUNT = 8
+    _HEX_DIGITS = frozenset('0123456789ABCDEFabcdef')
+    _max_prefixlen = IPV6LENGTH
+
+    # There are only a bunch of valid v6 netmasks, so we cache them all
+    # when constructed (see _make_netmask()).
+    _netmask_cache = {}
+
+    @classmethod
+    def _make_netmask(cls, arg):
+        """Make a (netmask, prefix_len) tuple from the given argument.
+
+        Argument can be:
+        - an integer (the prefix length)
+        - a string representing the prefix length (e.g. "24")
+        - a string representing the prefix netmask (e.g. "255.255.255.0")
+        """
+        if arg not in cls._netmask_cache:
+            if isinstance(arg, _compat_int_types):
+                prefixlen = arg
+            else:
+                prefixlen = cls._prefix_from_prefix_string(arg)
+            netmask = IPv6Address(cls._ip_int_from_prefix(prefixlen))
+            cls._netmask_cache[arg] = netmask, prefixlen
+        return cls._netmask_cache[arg]
+
+    @classmethod
+    def _ip_int_from_string(cls, ip_str):
+        """Turn an IPv6 ip_str into an integer.
+
+        Args:
+            ip_str: A string, the IPv6 ip_str.
+
+        Returns:
+            An int, the IPv6 address
+
+        Raises:
+            AddressValueError: if ip_str isn't a valid IPv6 Address.
+
+        """
+        if not ip_str:
+            raise AddressValueError('Address cannot be empty')
+
+        parts = ip_str.split(':')
+
+        # An IPv6 address needs at least 2 colons (3 parts).
+        _min_parts = 3
+        if len(parts) < _min_parts:
+            msg = "At least %d parts expected in %r" % (_min_parts, ip_str)
+            raise AddressValueError(msg)
+
+        # If the address has an IPv4-style suffix, convert it to hexadecimal.
+        if '.' in parts[-1]:
+            try:
+                ipv4_int = IPv4Address(parts.pop())._ip
+            except AddressValueError as exc:
+                raise AddressValueError("%s in %r" % (exc, ip_str))
+            parts.append('%x' % ((ipv4_int >> 16) & 0xFFFF))
+            parts.append('%x' % (ipv4_int & 0xFFFF))
+
+        # An IPv6 address can't have more than 8 colons (9 parts).
+        # The extra colon comes from using the "::" notation for a single
+        # leading or trailing zero part.
+        _max_parts = cls._HEXTET_COUNT + 1
+        if len(parts) > _max_parts:
+            msg = "At most %d colons permitted in %r" % (
+                _max_parts - 1, ip_str)
+            raise AddressValueError(msg)
+
+        # Disregarding the endpoints, find '::' with nothing in between.
+        # This indicates that a run of zeroes has been skipped.
+        skip_index = None
+        for i in _compat_range(1, len(parts) - 1):
+            if not parts[i]:
+                if skip_index is not None:
+                    # Can't have more than one '::'
+                    msg = "At most one '::' permitted in %r" % ip_str
+                    raise AddressValueError(msg)
+                skip_index = i
+
+        # parts_hi is the number of parts to copy from above/before the '::'
+        # parts_lo is the number of parts to copy from below/after the '::'
+        if skip_index is not None:
+            # If we found a '::', then check if it also covers the endpoints.
+            parts_hi = skip_index
+            parts_lo = len(parts) - skip_index - 1
+            if not parts[0]:
+                parts_hi -= 1
+                if parts_hi:
+                    msg = "Leading ':' only permitted as part of '::' in %r"
+                    raise AddressValueError(msg % ip_str)  # ^: requires ^::
+            if not parts[-1]:
+                parts_lo -= 1
+                if parts_lo:
+                    msg = "Trailing ':' only permitted as part of '::' in %r"
+                    raise AddressValueError(msg % ip_str)  # :$ requires ::$
+            parts_skipped = cls._HEXTET_COUNT - (parts_hi + parts_lo)
+            if parts_skipped < 1:
+                msg = "Expected at most %d other parts with '::' in %r"
+                raise AddressValueError(msg % (cls._HEXTET_COUNT - 1, ip_str))
+        else:
+            # Otherwise, allocate the entire address to parts_hi.  The
+            # endpoints could still be empty, but _parse_hextet() will check
+            # for that.
+            if len(parts) != cls._HEXTET_COUNT:
+                msg = "Exactly %d parts expected without '::' in %r"
+                raise AddressValueError(msg % (cls._HEXTET_COUNT, ip_str))
+            if not parts[0]:
+                msg = "Leading ':' only permitted as part of '::' in %r"
+                raise AddressValueError(msg % ip_str)  # ^: requires ^::
+            if not parts[-1]:
+                msg = "Trailing ':' only permitted as part of '::' in %r"
+                raise AddressValueError(msg % ip_str)  # :$ requires ::$
+            parts_hi = len(parts)
+            parts_lo = 0
+            parts_skipped = 0
+
+        try:
+            # Now, parse the hextets into a 128-bit integer.
+            ip_int = 0
+            for i in range(parts_hi):
+                ip_int <<= 16
+                ip_int |= cls._parse_hextet(parts[i])
+            ip_int <<= 16 * parts_skipped
+            for i in range(-parts_lo, 0):
+                ip_int <<= 16
+                ip_int |= cls._parse_hextet(parts[i])
+            return ip_int
+        except ValueError as exc:
+            raise AddressValueError("%s in %r" % (exc, ip_str))
+
+    @classmethod
+    def _parse_hextet(cls, hextet_str):
+        """Convert an IPv6 hextet string into an integer.
+
+        Args:
+            hextet_str: A string, the number to parse.
+
+        Returns:
+            The hextet as an integer.
+
+        Raises:
+            ValueError: if the input isn't strictly a hex number from
+              [0..FFFF].
+
+        """
+        # Whitelist the characters, since int() allows a lot of bizarre stuff.
+        if not cls._HEX_DIGITS.issuperset(hextet_str):
+            raise ValueError("Only hex digits permitted in %r" % hextet_str)
+        # We do the length check second, since the invalid character error
+        # is likely to be more informative for the user
+        if len(hextet_str) > 4:
+            msg = "At most 4 characters permitted in %r"
+            raise ValueError(msg % hextet_str)
+        # Length check means we can skip checking the integer value
+        return int(hextet_str, 16)
+
+    @classmethod
+    def _compress_hextets(cls, hextets):
+        """Compresses a list of hextets.
+
+        Compresses a list of strings, replacing the longest continuous
+        sequence of "0" in the list with "" and adding empty strings at
+        the beginning or at the end of the string such that subsequently
+        calling ":".join(hextets) will produce the compressed version of
+        the IPv6 address.
+
+        Args:
+            hextets: A list of strings, the hextets to compress.
+
+        Returns:
+            A list of strings.
+
+        """
+        best_doublecolon_start = -1
+        best_doublecolon_len = 0
+        doublecolon_start = -1
+        doublecolon_len = 0
+        for index, hextet in enumerate(hextets):
+            if hextet == '0':
+                doublecolon_len += 1
+                if doublecolon_start == -1:
+                    # Start of a sequence of zeros.
+                    doublecolon_start = index
+                if doublecolon_len > best_doublecolon_len:
+                    # This is the longest sequence of zeros so far.
+                    best_doublecolon_len = doublecolon_len
+                    best_doublecolon_start = doublecolon_start
+            else:
+                doublecolon_len = 0
+                doublecolon_start = -1
+
+        if best_doublecolon_len > 1:
+            best_doublecolon_end = (best_doublecolon_start +
+                                    best_doublecolon_len)
+            # For zeros at the end of the address.
+            if best_doublecolon_end == len(hextets):
+                hextets += ['']
+            hextets[best_doublecolon_start:best_doublecolon_end] = ['']
+            # For zeros at the beginning of the address.
+            if best_doublecolon_start == 0:
+                hextets = [''] + hextets
+
+        return hextets
+
+    @classmethod
+    def _string_from_ip_int(cls, ip_int=None):
+        """Turns a 128-bit integer into hexadecimal notation.
+
+        Args:
+            ip_int: An integer, the IP address.
+
+        Returns:
+            A string, the hexadecimal representation of the address.
+
+        Raises:
+            ValueError: The address is bigger than 128 bits of all ones.
+
+        """
+        if ip_int is None:
+            ip_int = int(cls._ip)
+
+        if ip_int > cls._ALL_ONES:
+            raise ValueError('IPv6 address is too large')
+
+        hex_str = '%032x' % ip_int
+        hextets = ['%x' % int(hex_str[x:x + 4], 16) for x in range(0, 32, 4)]
+
+        hextets = cls._compress_hextets(hextets)
+        return ':'.join(hextets)
+
+    def _explode_shorthand_ip_string(self):
+        """Expand a shortened IPv6 address.
+
+        Args:
+            ip_str: A string, the IPv6 address.
+
+        Returns:
+            A string, the expanded IPv6 address.
+
+        """
+        if isinstance(self, IPv6Network):
+            ip_str = _compat_str(self.network_address)
+        elif isinstance(self, IPv6Interface):
+            ip_str = _compat_str(self.ip)
+        else:
+            ip_str = _compat_str(self)
+
+        ip_int = self._ip_int_from_string(ip_str)
+        hex_str = '%032x' % ip_int
+        parts = [hex_str[x:x + 4] for x in range(0, 32, 4)]
+        if isinstance(self, (_BaseNetwork, IPv6Interface)):
+            return '%s/%d' % (':'.join(parts), self._prefixlen)
+        return ':'.join(parts)
+
+    def _reverse_pointer(self):
+        """Return the reverse DNS pointer name for the IPv6 address.
+
+        This implements the method described in RFC3596 2.5.
+
+        """
+        reverse_chars = self.exploded[::-1].replace(':', '')
+        return '.'.join(reverse_chars) + '.ip6.arpa'
+
+    @property
+    def max_prefixlen(self):
+        return self._max_prefixlen
+
+    @property
+    def version(self):
+        return self._version
+
+
+class IPv6Address(_BaseV6, _BaseAddress):
+
+    """Represent and manipulate single IPv6 Addresses."""
+
+    __slots__ = ('_ip', '__weakref__')
+
+    def __init__(self, address):
+        """Instantiate a new IPv6 address object.
+
+        Args:
+            address: A string or integer representing the IP
+
+              Additionally, an integer can be passed, so
+              IPv6Address('2001:db8::') ==
+                IPv6Address(42540766411282592856903984951653826560)
+              or, more generally
+              IPv6Address(int(IPv6Address('2001:db8::'))) ==
+                IPv6Address('2001:db8::')
+
+        Raises:
+            AddressValueError: If address isn't a valid IPv6 address.
+
+        """
+        # Efficient constructor from integer.
+        if isinstance(address, _compat_int_types):
+            self._check_int_address(address)
+            self._ip = address
+            return
+
+        # Constructing from a packed address
+        if isinstance(address, bytes):
+            self._check_packed_address(address, 16)
+            bvs = _compat_bytes_to_byte_vals(address)
+            self._ip = _compat_int_from_byte_vals(bvs, 'big')
+            return
+
+        # Assume input argument to be string or any object representation
+        # which converts into a formatted IP string.
+        addr_str = _compat_str(address)
+        if '/' in addr_str:
+            raise AddressValueError("Unexpected '/' in %r" % address)
+        self._ip = self._ip_int_from_string(addr_str)
+
+    @property
+    def packed(self):
+        """The binary representation of this address."""
+        return v6_int_to_packed(self._ip)
+
+    @property
+    def is_multicast(self):
+        """Test if the address is reserved for multicast use.
+
+        Returns:
+            A boolean, True if the address is a multicast address.
+            See RFC 2373 2.7 for details.
+
+        """
+        return self in self._constants._multicast_network
+
+    @property
+    def is_reserved(self):
+        """Test if the address is otherwise IETF reserved.
+
+        Returns:
+            A boolean, True if the address is within one of the
+            reserved IPv6 Network ranges.
+
+        """
+        return any(self in x for x in self._constants._reserved_networks)
+
+    @property
+    def is_link_local(self):
+        """Test if the address is reserved for link-local.
+
+        Returns:
+            A boolean, True if the address is reserved per RFC 4291.
+
+        """
+        return self in self._constants._linklocal_network
+
+    @property
+    def is_site_local(self):
+        """Test if the address is reserved for site-local.
+
+        Note that the site-local address space has been deprecated by RFC 3879.
+        Use is_private to test if this address is in the space of unique local
+        addresses as defined by RFC 4193.
+
+        Returns:
+            A boolean, True if the address is reserved per RFC 3513 2.5.6.
+
+        """
+        return self in self._constants._sitelocal_network
+
+    @property
+    def is_private(self):
+        """Test if this address is allocated for private networks.
+
+        Returns:
+            A boolean, True if the address is reserved per
+            iana-ipv6-special-registry.
+
+        """
+        return any(self in net for net in self._constants._private_networks)
+
+    @property
+    def is_global(self):
+        """Test if this address is allocated for public networks.
+
+        Returns:
+            A boolean, true if the address is not reserved per
+            iana-ipv6-special-registry.
+
+        """
+        return not self.is_private
+
+    @property
+    def is_unspecified(self):
+        """Test if the address is unspecified.
+
+        Returns:
+            A boolean, True if this is the unspecified address as defined in
+            RFC 2373 2.5.2.
+
+        """
+        return self._ip == 0
+
+    @property
+    def is_loopback(self):
+        """Test if the address is a loopback address.
+
+        Returns:
+            A boolean, True if the address is a loopback address as defined in
+            RFC 2373 2.5.3.
+
+        """
+        return self._ip == 1
+
+    @property
+    def ipv4_mapped(self):
+        """Return the IPv4 mapped address.
+
+        Returns:
+            If the IPv6 address is a v4 mapped address, return the
+            IPv4 mapped address. Return None otherwise.
+
+        """
+        if (self._ip >> 32) != 0xFFFF:
+            return None
+        return IPv4Address(self._ip & 0xFFFFFFFF)
+
+    @property
+    def teredo(self):
+        """Tuple of embedded teredo IPs.
+
+        Returns:
+            Tuple of the (server, client) IPs or None if the address
+            doesn't appear to be a teredo address (doesn't start with
+            2001::/32)
+
+        """
+        if (self._ip >> 96) != 0x20010000:
+            return None
+        return (IPv4Address((self._ip >> 64) & 0xFFFFFFFF),
+                IPv4Address(~self._ip & 0xFFFFFFFF))
+
+    @property
+    def sixtofour(self):
+        """Return the IPv4 6to4 embedded address.
+
+        Returns:
+            The IPv4 6to4-embedded address if present or None if the
+            address doesn't appear to contain a 6to4 embedded address.
+
+        """
+        if (self._ip >> 112) != 0x2002:
+            return None
+        return IPv4Address((self._ip >> 80) & 0xFFFFFFFF)
+
+
+class IPv6Interface(IPv6Address):
+
+    def __init__(self, address):
+        if isinstance(address, (bytes, _compat_int_types)):
+            IPv6Address.__init__(self, address)
+            self.network = IPv6Network(self._ip)
+            self._prefixlen = self._max_prefixlen
+            return
+        if isinstance(address, tuple):
+            IPv6Address.__init__(self, address[0])
+            if len(address) > 1:
+                self._prefixlen = int(address[1])
+            else:
+                self._prefixlen = self._max_prefixlen
+            self.network = IPv6Network(address, strict=False)
+            self.netmask = self.network.netmask
+            self.hostmask = self.network.hostmask
+            return
+
+        addr = _split_optional_netmask(address)
+        IPv6Address.__init__(self, addr[0])
+        self.network = IPv6Network(address, strict=False)
+        self.netmask = self.network.netmask
+        self._prefixlen = self.network._prefixlen
+        self.hostmask = self.network.hostmask
+
+    def __str__(self):
+        return '%s/%d' % (self._string_from_ip_int(self._ip),
+                          self.network.prefixlen)
+
+    def __eq__(self, other):
+        address_equal = IPv6Address.__eq__(self, other)
+        if not address_equal or address_equal is NotImplemented:
+            return address_equal
+        try:
+            return self.network == other.network
+        except AttributeError:
+            # An interface with an associated network is NOT the
+            # same as an unassociated address. That's why the hash
+            # takes the extra info into account.
+            return False
+
+    def __lt__(self, other):
+        address_less = IPv6Address.__lt__(self, other)
+        if address_less is NotImplemented:
+            return NotImplemented
+        try:
+            return (self.network < other.network or
+                    self.network == other.network and address_less)
+        except AttributeError:
+            # We *do* allow addresses and interfaces to be sorted. The
+            # unassociated address is considered less than all interfaces.
+            return False
+
+    def __hash__(self):
+        return self._ip ^ self._prefixlen ^ int(self.network.network_address)
+
+    __reduce__ = _IPAddressBase.__reduce__
+
+    @property
+    def ip(self):
+        return IPv6Address(self._ip)
+
+    @property
+    def with_prefixlen(self):
+        return '%s/%s' % (self._string_from_ip_int(self._ip),
+                          self._prefixlen)
+
+    @property
+    def with_netmask(self):
+        return '%s/%s' % (self._string_from_ip_int(self._ip),
+                          self.netmask)
+
+    @property
+    def with_hostmask(self):
+        return '%s/%s' % (self._string_from_ip_int(self._ip),
+                          self.hostmask)
+
+    @property
+    def is_unspecified(self):
+        return self._ip == 0 and self.network.is_unspecified
+
+    @property
+    def is_loopback(self):
+        return self._ip == 1 and self.network.is_loopback
+
+
+class IPv6Network(_BaseV6, _BaseNetwork):
+
+    """This class represents and manipulates 128-bit IPv6 networks.
+
+    Attributes: [examples for IPv6('2001:db8::1000/124')]
+        .network_address: IPv6Address('2001:db8::1000')
+        .hostmask: IPv6Address('::f')
+        .broadcast_address: IPv6Address('2001:db8::100f')
+        .netmask: IPv6Address('ffff:ffff:ffff:ffff:ffff:ffff:ffff:fff0')
+        .prefixlen: 124
+
+    """
+
+    # Class to use when creating address objects
+    _address_class = IPv6Address
+
+    def __init__(self, address, strict=True):
+        """Instantiate a new IPv6 Network object.
+
+        Args:
+            address: A string or integer representing the IPv6 network or the
+              IP and prefix/netmask.
+              '2001:db8::/128'
+              '2001:db8:0000:0000:0000:0000:0000:0000/128'
+              '2001:db8::'
+              are all functionally the same in IPv6.  That is to say,
+              failing to provide a subnetmask will create an object with
+              a mask of /128.
+
+              Additionally, an integer can be passed, so
+              IPv6Network('2001:db8::') ==
+                IPv6Network(42540766411282592856903984951653826560)
+              or, more generally
+              IPv6Network(int(IPv6Network('2001:db8::'))) ==
+                IPv6Network('2001:db8::')
+
+            strict: A boolean. If true, ensure that we have been passed
+              A true network address, eg, 2001:db8::1000/124 and not an
+              IP address on a network, eg, 2001:db8::1/124.
+
+        Raises:
+            AddressValueError: If address isn't a valid IPv6 address.
+            NetmaskValueError: If the netmask isn't valid for
+              an IPv6 address.
+            ValueError: If strict was True and a network address was not
+              supplied.
+
+        """
+        _BaseNetwork.__init__(self, address)
+
+        # Efficient constructor from integer or packed address
+        if isinstance(address, (bytes, _compat_int_types)):
+            self.network_address = IPv6Address(address)
+            self.netmask, self._prefixlen = self._make_netmask(
+                self._max_prefixlen)
+            return
+
+        if isinstance(address, tuple):
+            if len(address) > 1:
+                arg = address[1]
+            else:
+                arg = self._max_prefixlen
+            self.netmask, self._prefixlen = self._make_netmask(arg)
+            self.network_address = IPv6Address(address[0])
+            packed = int(self.network_address)
+            if packed & int(self.netmask) != packed:
+                if strict:
+                    raise ValueError('%s has host bits set' % self)
+                else:
+                    self.network_address = IPv6Address(packed &
+                                                       int(self.netmask))
+            return
+
+        # Assume input argument to be string or any object representation
+        # which converts into a formatted IP prefix string.
+        addr = _split_optional_netmask(address)
+
+        self.network_address = IPv6Address(self._ip_int_from_string(addr[0]))
+
+        if len(addr) == 2:
+            arg = addr[1]
+        else:
+            arg = self._max_prefixlen
+        self.netmask, self._prefixlen = self._make_netmask(arg)
+
+        if strict:
+            if (IPv6Address(int(self.network_address) & int(self.netmask)) !=
+                    self.network_address):
+                raise ValueError('%s has host bits set' % self)
+        self.network_address = IPv6Address(int(self.network_address) &
+                                           int(self.netmask))
+
+        if self._prefixlen == (self._max_prefixlen - 1):
+            self.hosts = self.__iter__
+
+    def hosts(self):
+        """Generate Iterator over usable hosts in a network.
+
+          This is like __iter__ except it doesn't return the
+          Subnet-Router anycast address.
+
+        """
+        network = int(self.network_address)
+        broadcast = int(self.broadcast_address)
+        for x in _compat_range(network + 1, broadcast + 1):
+            yield self._address_class(x)
+
+    @property
+    def is_site_local(self):
+        """Test if the address is reserved for site-local.
+
+        Note that the site-local address space has been deprecated by RFC 3879.
+        Use is_private to test if this address is in the space of unique local
+        addresses as defined by RFC 4193.
+
+        Returns:
+            A boolean, True if the address is reserved per RFC 3513 2.5.6.
+
+        """
+        return (self.network_address.is_site_local and
+                self.broadcast_address.is_site_local)
+
+
+class _IPv6Constants(object):
+
+    _linklocal_network = IPv6Network('fe80::/10')
+
+    _multicast_network = IPv6Network('ff00::/8')
+
+    _private_networks = [
+        IPv6Network('::1/128'),
+        IPv6Network('::/128'),
+        IPv6Network('::ffff:0:0/96'),
+        IPv6Network('100::/64'),
+        IPv6Network('2001::/23'),
+        IPv6Network('2001:2::/48'),
+        IPv6Network('2001:db8::/32'),
+        IPv6Network('2001:10::/28'),
+        IPv6Network('fc00::/7'),
+        IPv6Network('fe80::/10'),
+    ]
+
+    _reserved_networks = [
+        IPv6Network('::/8'), IPv6Network('100::/8'),
+        IPv6Network('200::/7'), IPv6Network('400::/6'),
+        IPv6Network('800::/5'), IPv6Network('1000::/4'),
+        IPv6Network('4000::/3'), IPv6Network('6000::/3'),
+        IPv6Network('8000::/3'), IPv6Network('A000::/3'),
+        IPv6Network('C000::/3'), IPv6Network('E000::/4'),
+        IPv6Network('F000::/5'), IPv6Network('F800::/6'),
+        IPv6Network('FE00::/9'),
+    ]
+
+    _sitelocal_network = IPv6Network('fec0::/10')
+
+
+IPv6Address._constants = _IPv6Constants
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/__init__.py
new file mode 100644
index 0000000..d6705e2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/__init__.py
@@ -0,0 +1,54 @@
+# coding: utf-8
+from ._version import version
+from .exceptions import *
+from .ext import ExtType, Timestamp
+
+import os
+import sys
+
+
+if os.environ.get("MSGPACK_PUREPYTHON") or sys.version_info[0] == 2:
+    from .fallback import Packer, unpackb, Unpacker
+else:
+    try:
+        from ._cmsgpack import Packer, unpackb, Unpacker
+    except ImportError:
+        from .fallback import Packer, unpackb, Unpacker
+
+
+def pack(o, stream, **kwargs):
+    """
+    Pack object `o` and write it to `stream`
+
+    See :class:`Packer` for options.
+    """
+    packer = Packer(**kwargs)
+    stream.write(packer.pack(o))
+
+
+def packb(o, **kwargs):
+    """
+    Pack object `o` and return packed bytes
+
+    See :class:`Packer` for options.
+    """
+    return Packer(**kwargs).pack(o)
+
+
+def unpack(stream, **kwargs):
+    """
+    Unpack an object from `stream`.
+
+    Raises `ExtraData` when `stream` contains extra bytes.
+    See :class:`Unpacker` for options.
+    """
+    data = stream.read()
+    return unpackb(data, **kwargs)
+
+
+# alias for compatibility to simplejson/marshal/pickle.
+load = unpack
+loads = unpackb
+
+dump = pack
+dumps = packb
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/_version.py b/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/_version.py
new file mode 100644
index 0000000..9f55cf5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/_version.py
@@ -0,0 +1 @@
+version = (1, 0, 0)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/exceptions.py b/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/exceptions.py
new file mode 100644
index 0000000..d6d2615
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/exceptions.py
@@ -0,0 +1,48 @@
+class UnpackException(Exception):
+    """Base class for some exceptions raised while unpacking.
+
+    NOTE: unpack may raise exception other than subclass of
+    UnpackException.  If you want to catch all error, catch
+    Exception instead.
+    """
+
+
+class BufferFull(UnpackException):
+    pass
+
+
+class OutOfData(UnpackException):
+    pass
+
+
+class FormatError(ValueError, UnpackException):
+    """Invalid msgpack format"""
+
+
+class StackError(ValueError, UnpackException):
+    """Too nested"""
+
+
+# Deprecated.  Use ValueError instead
+UnpackValueError = ValueError
+
+
+class ExtraData(UnpackValueError):
+    """ExtraData is raised when there is trailing data.
+
+    This exception is raised while only one-shot (not streaming)
+    unpack.
+    """
+
+    def __init__(self, unpacked, extra):
+        self.unpacked = unpacked
+        self.extra = extra
+
+    def __str__(self):
+        return "unpack(b) received extra data."
+
+
+# Deprecated.  Use Exception instead to catch all exception during packing.
+PackException = Exception
+PackValueError = ValueError
+PackOverflowError = OverflowError
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/ext.py b/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/ext.py
new file mode 100644
index 0000000..8341c68
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/ext.py
@@ -0,0 +1,191 @@
+# coding: utf-8
+from collections import namedtuple
+import datetime
+import sys
+import struct
+
+
+PY2 = sys.version_info[0] == 2
+
+if PY2:
+    int_types = (int, long)
+    _utc = None
+else:
+    int_types = int
+    try:
+        _utc = datetime.timezone.utc
+    except AttributeError:
+        _utc = datetime.timezone(datetime.timedelta(0))
+
+
+class ExtType(namedtuple("ExtType", "code data")):
+    """ExtType represents ext type in msgpack."""
+
+    def __new__(cls, code, data):
+        if not isinstance(code, int):
+            raise TypeError("code must be int")
+        if not isinstance(data, bytes):
+            raise TypeError("data must be bytes")
+        if not 0 <= code <= 127:
+            raise ValueError("code must be 0~127")
+        return super(ExtType, cls).__new__(cls, code, data)
+
+
+class Timestamp(object):
+    """Timestamp represents the Timestamp extension type in msgpack.
+
+    When built with Cython, msgpack uses C methods to pack and unpack `Timestamp`. When using pure-Python
+    msgpack, :func:`to_bytes` and :func:`from_bytes` are used to pack and unpack `Timestamp`.
+
+    This class is immutable: Do not override seconds and nanoseconds.
+    """
+
+    __slots__ = ["seconds", "nanoseconds"]
+
+    def __init__(self, seconds, nanoseconds=0):
+        """Initialize a Timestamp object.
+
+        :param int seconds:
+            Number of seconds since the UNIX epoch (00:00:00 UTC Jan 1 1970, minus leap seconds).
+            May be negative.
+
+        :param int nanoseconds:
+            Number of nanoseconds to add to `seconds` to get fractional time.
+            Maximum is 999_999_999.  Default is 0.
+
+        Note: Negative times (before the UNIX epoch) are represented as negative seconds + positive ns.
+        """
+        if not isinstance(seconds, int_types):
+            raise TypeError("seconds must be an interger")
+        if not isinstance(nanoseconds, int_types):
+            raise TypeError("nanoseconds must be an integer")
+        if not (0 <= nanoseconds < 10 ** 9):
+            raise ValueError(
+                "nanoseconds must be a non-negative integer less than 999999999."
+            )
+        self.seconds = seconds
+        self.nanoseconds = nanoseconds
+
+    def __repr__(self):
+        """String representation of Timestamp."""
+        return "Timestamp(seconds={0}, nanoseconds={1})".format(
+            self.seconds, self.nanoseconds
+        )
+
+    def __eq__(self, other):
+        """Check for equality with another Timestamp object"""
+        if type(other) is self.__class__:
+            return (
+                self.seconds == other.seconds and self.nanoseconds == other.nanoseconds
+            )
+        return False
+
+    def __ne__(self, other):
+        """not-equals method (see :func:`__eq__()`)"""
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash((self.seconds, self.nanoseconds))
+
+    @staticmethod
+    def from_bytes(b):
+        """Unpack bytes into a `Timestamp` object.
+
+        Used for pure-Python msgpack unpacking.
+
+        :param b: Payload from msgpack ext message with code -1
+        :type b: bytes
+
+        :returns: Timestamp object unpacked from msgpack ext payload
+        :rtype: Timestamp
+        """
+        if len(b) == 4:
+            seconds = struct.unpack("!L", b)[0]
+            nanoseconds = 0
+        elif len(b) == 8:
+            data64 = struct.unpack("!Q", b)[0]
+            seconds = data64 & 0x00000003FFFFFFFF
+            nanoseconds = data64 >> 34
+        elif len(b) == 12:
+            nanoseconds, seconds = struct.unpack("!Iq", b)
+        else:
+            raise ValueError(
+                "Timestamp type can only be created from 32, 64, or 96-bit byte objects"
+            )
+        return Timestamp(seconds, nanoseconds)
+
+    def to_bytes(self):
+        """Pack this Timestamp object into bytes.
+
+        Used for pure-Python msgpack packing.
+
+        :returns data: Payload for EXT message with code -1 (timestamp type)
+        :rtype: bytes
+        """
+        if (self.seconds >> 34) == 0:  # seconds is non-negative and fits in 34 bits
+            data64 = self.nanoseconds << 34 | self.seconds
+            if data64 & 0xFFFFFFFF00000000 == 0:
+                # nanoseconds is zero and seconds < 2**32, so timestamp 32
+                data = struct.pack("!L", data64)
+            else:
+                # timestamp 64
+                data = struct.pack("!Q", data64)
+        else:
+            # timestamp 96
+            data = struct.pack("!Iq", self.nanoseconds, self.seconds)
+        return data
+
+    @staticmethod
+    def from_unix(unix_sec):
+        """Create a Timestamp from posix timestamp in seconds.
+
+        :param unix_float: Posix timestamp in seconds.
+        :type unix_float: int or float.
+        """
+        seconds = int(unix_sec // 1)
+        nanoseconds = int((unix_sec % 1) * 10 ** 9)
+        return Timestamp(seconds, nanoseconds)
+
+    def to_unix(self):
+        """Get the timestamp as a floating-point value.
+
+        :returns: posix timestamp
+        :rtype: float
+        """
+        return self.seconds + self.nanoseconds / 1e9
+
+    @staticmethod
+    def from_unix_nano(unix_ns):
+        """Create a Timestamp from posix timestamp in nanoseconds.
+
+        :param int unix_ns: Posix timestamp in nanoseconds.
+        :rtype: Timestamp
+        """
+        return Timestamp(*divmod(unix_ns, 10 ** 9))
+
+    def to_unix_nano(self):
+        """Get the timestamp as a unixtime in nanoseconds.
+
+        :returns: posix timestamp in nanoseconds
+        :rtype: int
+        """
+        return self.seconds * 10 ** 9 + self.nanoseconds
+
+    def to_datetime(self):
+        """Get the timestamp as a UTC datetime.
+
+        Python 2 is not supported.
+
+        :rtype: datetime.
+        """
+        return datetime.datetime.fromtimestamp(self.to_unix(), _utc)
+
+    @staticmethod
+    def from_datetime(dt):
+        """Create a Timestamp from datetime with tzinfo.
+
+        Python 2 is not supported.
+
+        :rtype: Timestamp
+        """
+        return Timestamp.from_unix(dt.timestamp())
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/fallback.py b/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/fallback.py
new file mode 100644
index 0000000..9f6665b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/msgpack/fallback.py
@@ -0,0 +1,1063 @@
+"""Fallback pure Python implementation of msgpack"""
+
+from datetime import datetime as _DateTime
+import sys
+import struct
+
+
+PY2 = sys.version_info[0] == 2
+if PY2:
+    int_types = (int, long)
+
+    def dict_iteritems(d):
+        return d.iteritems()
+
+
+else:
+    int_types = int
+    unicode = str
+    xrange = range
+
+    def dict_iteritems(d):
+        return d.items()
+
+
+if sys.version_info < (3, 5):
+    # Ugly hack...
+    RecursionError = RuntimeError
+
+    def _is_recursionerror(e):
+        return (
+            len(e.args) == 1
+            and isinstance(e.args[0], str)
+            and e.args[0].startswith("maximum recursion depth exceeded")
+        )
+
+
+else:
+
+    def _is_recursionerror(e):
+        return True
+
+
+if hasattr(sys, "pypy_version_info"):
+    # StringIO is slow on PyPy, StringIO is faster.  However: PyPy's own
+    # StringBuilder is fastest.
+    from __pypy__ import newlist_hint
+
+    try:
+        from __pypy__.builders import BytesBuilder as StringBuilder
+    except ImportError:
+        from __pypy__.builders import StringBuilder
+    USING_STRINGBUILDER = True
+
+    class StringIO(object):
+        def __init__(self, s=b""):
+            if s:
+                self.builder = StringBuilder(len(s))
+                self.builder.append(s)
+            else:
+                self.builder = StringBuilder()
+
+        def write(self, s):
+            if isinstance(s, memoryview):
+                s = s.tobytes()
+            elif isinstance(s, bytearray):
+                s = bytes(s)
+            self.builder.append(s)
+
+        def getvalue(self):
+            return self.builder.build()
+
+
+else:
+    USING_STRINGBUILDER = False
+    from io import BytesIO as StringIO
+
+    newlist_hint = lambda size: []
+
+
+from .exceptions import BufferFull, OutOfData, ExtraData, FormatError, StackError
+
+from .ext import ExtType, Timestamp
+
+
+EX_SKIP = 0
+EX_CONSTRUCT = 1
+EX_READ_ARRAY_HEADER = 2
+EX_READ_MAP_HEADER = 3
+
+TYPE_IMMEDIATE = 0
+TYPE_ARRAY = 1
+TYPE_MAP = 2
+TYPE_RAW = 3
+TYPE_BIN = 4
+TYPE_EXT = 5
+
+DEFAULT_RECURSE_LIMIT = 511
+
+
+def _check_type_strict(obj, t, type=type, tuple=tuple):
+    if type(t) is tuple:
+        return type(obj) in t
+    else:
+        return type(obj) is t
+
+
+def _get_data_from_buffer(obj):
+    view = memoryview(obj)
+    if view.itemsize != 1:
+        raise ValueError("cannot unpack from multi-byte object")
+    return view
+
+
+def unpackb(packed, **kwargs):
+    """
+    Unpack an object from `packed`.
+
+    Raises ``ExtraData`` when *packed* contains extra bytes.
+    Raises ``ValueError`` when *packed* is incomplete.
+    Raises ``FormatError`` when *packed* is not valid msgpack.
+    Raises ``StackError`` when *packed* contains too nested.
+    Other exceptions can be raised during unpacking.
+
+    See :class:`Unpacker` for options.
+    """
+    unpacker = Unpacker(None, max_buffer_size=len(packed), **kwargs)
+    unpacker.feed(packed)
+    try:
+        ret = unpacker._unpack()
+    except OutOfData:
+        raise ValueError("Unpack failed: incomplete input")
+    except RecursionError as e:
+        if _is_recursionerror(e):
+            raise StackError
+        raise
+    if unpacker._got_extradata():
+        raise ExtraData(ret, unpacker._get_extradata())
+    return ret
+
+
+if sys.version_info < (2, 7, 6):
+
+    def _unpack_from(f, b, o=0):
+        """Explicit type cast for legacy struct.unpack_from"""
+        return struct.unpack_from(f, bytes(b), o)
+
+
+else:
+    _unpack_from = struct.unpack_from
+
+
+class Unpacker(object):
+    """Streaming unpacker.
+
+    Arguments:
+
+    :param file_like:
+        File-like object having `.read(n)` method.
+        If specified, unpacker reads serialized data from it and :meth:`feed()` is not usable.
+
+    :param int read_size:
+        Used as `file_like.read(read_size)`. (default: `min(16*1024, max_buffer_size)`)
+
+    :param bool use_list:
+        If true, unpack msgpack array to Python list.
+        Otherwise, unpack to Python tuple. (default: True)
+
+    :param bool raw:
+        If true, unpack msgpack raw to Python bytes.
+        Otherwise, unpack to Python str by decoding with UTF-8 encoding (default).
+
+    :param int timestamp:
+        Control how timestamp type is unpacked:
+
+            0 - Timestamp
+            1 - float  (Seconds from the EPOCH)
+            2 - int  (Nanoseconds from the EPOCH)
+            3 - datetime.datetime  (UTC).  Python 2 is not supported.
+
+    :param bool strict_map_key:
+        If true (default), only str or bytes are accepted for map (dict) keys.
+
+    :param callable object_hook:
+        When specified, it should be callable.
+        Unpacker calls it with a dict argument after unpacking msgpack map.
+        (See also simplejson)
+
+    :param callable object_pairs_hook:
+        When specified, it should be callable.
+        Unpacker calls it with a list of key-value pairs after unpacking msgpack map.
+        (See also simplejson)
+
+    :param str unicode_errors:
+        The error handler for decoding unicode. (default: 'strict')
+        This option should be used only when you have msgpack data which
+        contains invalid UTF-8 string.
+
+    :param int max_buffer_size:
+        Limits size of data waiting unpacked.  0 means 2**32-1.
+        The default value is 100*1024*1024 (100MiB).
+        Raises `BufferFull` exception when it is insufficient.
+        You should set this parameter when unpacking data from untrusted source.
+
+    :param int max_str_len:
+        Deprecated, use *max_buffer_size* instead.
+        Limits max length of str. (default: max_buffer_size)
+
+    :param int max_bin_len:
+        Deprecated, use *max_buffer_size* instead.
+        Limits max length of bin. (default: max_buffer_size)
+
+    :param int max_array_len:
+        Limits max length of array.
+        (default: max_buffer_size)
+
+    :param int max_map_len:
+        Limits max length of map.
+        (default: max_buffer_size//2)
+
+    :param int max_ext_len:
+        Deprecated, use *max_buffer_size* instead.
+        Limits max size of ext type.  (default: max_buffer_size)
+
+    Example of streaming deserialize from file-like object::
+
+        unpacker = Unpacker(file_like)
+        for o in unpacker:
+            process(o)
+
+    Example of streaming deserialize from socket::
+
+        unpacker = Unpacker(max_buffer_size)
+        while True:
+            buf = sock.recv(1024**2)
+            if not buf:
+                break
+            unpacker.feed(buf)
+            for o in unpacker:
+                process(o)
+
+    Raises ``ExtraData`` when *packed* contains extra bytes.
+    Raises ``OutOfData`` when *packed* is incomplete.
+    Raises ``FormatError`` when *packed* is not valid msgpack.
+    Raises ``StackError`` when *packed* contains too nested.
+    Other exceptions can be raised during unpacking.
+    """
+
+    def __init__(
+        self,
+        file_like=None,
+        read_size=0,
+        use_list=True,
+        raw=False,
+        timestamp=0,
+        strict_map_key=True,
+        object_hook=None,
+        object_pairs_hook=None,
+        list_hook=None,
+        unicode_errors=None,
+        max_buffer_size=100 * 1024 * 1024,
+        ext_hook=ExtType,
+        max_str_len=-1,
+        max_bin_len=-1,
+        max_array_len=-1,
+        max_map_len=-1,
+        max_ext_len=-1,
+    ):
+        if unicode_errors is None:
+            unicode_errors = "strict"
+
+        if file_like is None:
+            self._feeding = True
+        else:
+            if not callable(file_like.read):
+                raise TypeError("`file_like.read` must be callable")
+            self.file_like = file_like
+            self._feeding = False
+
+        #: array of bytes fed.
+        self._buffer = bytearray()
+        #: Which position we currently reads
+        self._buff_i = 0
+
+        # When Unpacker is used as an iterable, between the calls to next(),
+        # the buffer is not "consumed" completely, for efficiency sake.
+        # Instead, it is done sloppily.  To make sure we raise BufferFull at
+        # the correct moments, we have to keep track of how sloppy we were.
+        # Furthermore, when the buffer is incomplete (that is: in the case
+        # we raise an OutOfData) we need to rollback the buffer to the correct
+        # state, which _buf_checkpoint records.
+        self._buf_checkpoint = 0
+
+        if not max_buffer_size:
+            max_buffer_size = 2 ** 31 - 1
+        if max_str_len == -1:
+            max_str_len = max_buffer_size
+        if max_bin_len == -1:
+            max_bin_len = max_buffer_size
+        if max_array_len == -1:
+            max_array_len = max_buffer_size
+        if max_map_len == -1:
+            max_map_len = max_buffer_size // 2
+        if max_ext_len == -1:
+            max_ext_len = max_buffer_size
+
+        self._max_buffer_size = max_buffer_size
+        if read_size > self._max_buffer_size:
+            raise ValueError("read_size must be smaller than max_buffer_size")
+        self._read_size = read_size or min(self._max_buffer_size, 16 * 1024)
+        self._raw = bool(raw)
+        self._strict_map_key = bool(strict_map_key)
+        self._unicode_errors = unicode_errors
+        self._use_list = use_list
+        if not (0 <= timestamp <= 3):
+            raise ValueError("timestamp must be 0..3")
+        self._timestamp = timestamp
+        self._list_hook = list_hook
+        self._object_hook = object_hook
+        self._object_pairs_hook = object_pairs_hook
+        self._ext_hook = ext_hook
+        self._max_str_len = max_str_len
+        self._max_bin_len = max_bin_len
+        self._max_array_len = max_array_len
+        self._max_map_len = max_map_len
+        self._max_ext_len = max_ext_len
+        self._stream_offset = 0
+
+        if list_hook is not None and not callable(list_hook):
+            raise TypeError("`list_hook` is not callable")
+        if object_hook is not None and not callable(object_hook):
+            raise TypeError("`object_hook` is not callable")
+        if object_pairs_hook is not None and not callable(object_pairs_hook):
+            raise TypeError("`object_pairs_hook` is not callable")
+        if object_hook is not None and object_pairs_hook is not None:
+            raise TypeError(
+                "object_pairs_hook and object_hook are mutually " "exclusive"
+            )
+        if not callable(ext_hook):
+            raise TypeError("`ext_hook` is not callable")
+
+    def feed(self, next_bytes):
+        assert self._feeding
+        view = _get_data_from_buffer(next_bytes)
+        if len(self._buffer) - self._buff_i + len(view) > self._max_buffer_size:
+            raise BufferFull
+
+        # Strip buffer before checkpoint before reading file.
+        if self._buf_checkpoint > 0:
+            del self._buffer[: self._buf_checkpoint]
+            self._buff_i -= self._buf_checkpoint
+            self._buf_checkpoint = 0
+
+        # Use extend here: INPLACE_ADD += doesn't reliably typecast memoryview in jython
+        self._buffer.extend(view)
+
+    def _consume(self):
+        """ Gets rid of the used parts of the buffer. """
+        self._stream_offset += self._buff_i - self._buf_checkpoint
+        self._buf_checkpoint = self._buff_i
+
+    def _got_extradata(self):
+        return self._buff_i < len(self._buffer)
+
+    def _get_extradata(self):
+        return self._buffer[self._buff_i :]
+
+    def read_bytes(self, n):
+        ret = self._read(n)
+        self._consume()
+        return ret
+
+    def _read(self, n):
+        # (int) -> bytearray
+        self._reserve(n)
+        i = self._buff_i
+        self._buff_i = i + n
+        return self._buffer[i : i + n]
+
+    def _reserve(self, n):
+        remain_bytes = len(self._buffer) - self._buff_i - n
+
+        # Fast path: buffer has n bytes already
+        if remain_bytes >= 0:
+            return
+
+        if self._feeding:
+            self._buff_i = self._buf_checkpoint
+            raise OutOfData
+
+        # Strip buffer before checkpoint before reading file.
+        if self._buf_checkpoint > 0:
+            del self._buffer[: self._buf_checkpoint]
+            self._buff_i -= self._buf_checkpoint
+            self._buf_checkpoint = 0
+
+        # Read from file
+        remain_bytes = -remain_bytes
+        while remain_bytes > 0:
+            to_read_bytes = max(self._read_size, remain_bytes)
+            read_data = self.file_like.read(to_read_bytes)
+            if not read_data:
+                break
+            assert isinstance(read_data, bytes)
+            self._buffer += read_data
+            remain_bytes -= len(read_data)
+
+        if len(self._buffer) < n + self._buff_i:
+            self._buff_i = 0  # rollback
+            raise OutOfData
+
+    def _read_header(self, execute=EX_CONSTRUCT):
+        typ = TYPE_IMMEDIATE
+        n = 0
+        obj = None
+        self._reserve(1)
+        b = self._buffer[self._buff_i]
+        self._buff_i += 1
+        if b & 0b10000000 == 0:
+            obj = b
+        elif b & 0b11100000 == 0b11100000:
+            obj = -1 - (b ^ 0xFF)
+        elif b & 0b11100000 == 0b10100000:
+            n = b & 0b00011111
+            typ = TYPE_RAW
+            if n > self._max_str_len:
+                raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
+            obj = self._read(n)
+        elif b & 0b11110000 == 0b10010000:
+            n = b & 0b00001111
+            typ = TYPE_ARRAY
+            if n > self._max_array_len:
+                raise ValueError("%s exceeds max_array_len(%s)", n, self._max_array_len)
+        elif b & 0b11110000 == 0b10000000:
+            n = b & 0b00001111
+            typ = TYPE_MAP
+            if n > self._max_map_len:
+                raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
+        elif b == 0xC0:
+            obj = None
+        elif b == 0xC2:
+            obj = False
+        elif b == 0xC3:
+            obj = True
+        elif b == 0xC4:
+            typ = TYPE_BIN
+            self._reserve(1)
+            n = self._buffer[self._buff_i]
+            self._buff_i += 1
+            if n > self._max_bin_len:
+                raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
+            obj = self._read(n)
+        elif b == 0xC5:
+            typ = TYPE_BIN
+            self._reserve(2)
+            n = _unpack_from(">H", self._buffer, self._buff_i)[0]
+            self._buff_i += 2
+            if n > self._max_bin_len:
+                raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
+            obj = self._read(n)
+        elif b == 0xC6:
+            typ = TYPE_BIN
+            self._reserve(4)
+            n = _unpack_from(">I", self._buffer, self._buff_i)[0]
+            self._buff_i += 4
+            if n > self._max_bin_len:
+                raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
+            obj = self._read(n)
+        elif b == 0xC7:  # ext 8
+            typ = TYPE_EXT
+            self._reserve(2)
+            L, n = _unpack_from("Bb", self._buffer, self._buff_i)
+            self._buff_i += 2
+            if L > self._max_ext_len:
+                raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
+            obj = self._read(L)
+        elif b == 0xC8:  # ext 16
+            typ = TYPE_EXT
+            self._reserve(3)
+            L, n = _unpack_from(">Hb", self._buffer, self._buff_i)
+            self._buff_i += 3
+            if L > self._max_ext_len:
+                raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
+            obj = self._read(L)
+        elif b == 0xC9:  # ext 32
+            typ = TYPE_EXT
+            self._reserve(5)
+            L, n = _unpack_from(">Ib", self._buffer, self._buff_i)
+            self._buff_i += 5
+            if L > self._max_ext_len:
+                raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
+            obj = self._read(L)
+        elif b == 0xCA:
+            self._reserve(4)
+            obj = _unpack_from(">f", self._buffer, self._buff_i)[0]
+            self._buff_i += 4
+        elif b == 0xCB:
+            self._reserve(8)
+            obj = _unpack_from(">d", self._buffer, self._buff_i)[0]
+            self._buff_i += 8
+        elif b == 0xCC:
+            self._reserve(1)
+            obj = self._buffer[self._buff_i]
+            self._buff_i += 1
+        elif b == 0xCD:
+            self._reserve(2)
+            obj = _unpack_from(">H", self._buffer, self._buff_i)[0]
+            self._buff_i += 2
+        elif b == 0xCE:
+            self._reserve(4)
+            obj = _unpack_from(">I", self._buffer, self._buff_i)[0]
+            self._buff_i += 4
+        elif b == 0xCF:
+            self._reserve(8)
+            obj = _unpack_from(">Q", self._buffer, self._buff_i)[0]
+            self._buff_i += 8
+        elif b == 0xD0:
+            self._reserve(1)
+            obj = _unpack_from("b", self._buffer, self._buff_i)[0]
+            self._buff_i += 1
+        elif b == 0xD1:
+            self._reserve(2)
+            obj = _unpack_from(">h", self._buffer, self._buff_i)[0]
+            self._buff_i += 2
+        elif b == 0xD2:
+            self._reserve(4)
+            obj = _unpack_from(">i", self._buffer, self._buff_i)[0]
+            self._buff_i += 4
+        elif b == 0xD3:
+            self._reserve(8)
+            obj = _unpack_from(">q", self._buffer, self._buff_i)[0]
+            self._buff_i += 8
+        elif b == 0xD4:  # fixext 1
+            typ = TYPE_EXT
+            if self._max_ext_len < 1:
+                raise ValueError("%s exceeds max_ext_len(%s)" % (1, self._max_ext_len))
+            self._reserve(2)
+            n, obj = _unpack_from("b1s", self._buffer, self._buff_i)
+            self._buff_i += 2
+        elif b == 0xD5:  # fixext 2
+            typ = TYPE_EXT
+            if self._max_ext_len < 2:
+                raise ValueError("%s exceeds max_ext_len(%s)" % (2, self._max_ext_len))
+            self._reserve(3)
+            n, obj = _unpack_from("b2s", self._buffer, self._buff_i)
+            self._buff_i += 3
+        elif b == 0xD6:  # fixext 4
+            typ = TYPE_EXT
+            if self._max_ext_len < 4:
+                raise ValueError("%s exceeds max_ext_len(%s)" % (4, self._max_ext_len))
+            self._reserve(5)
+            n, obj = _unpack_from("b4s", self._buffer, self._buff_i)
+            self._buff_i += 5
+        elif b == 0xD7:  # fixext 8
+            typ = TYPE_EXT
+            if self._max_ext_len < 8:
+                raise ValueError("%s exceeds max_ext_len(%s)" % (8, self._max_ext_len))
+            self._reserve(9)
+            n, obj = _unpack_from("b8s", self._buffer, self._buff_i)
+            self._buff_i += 9
+        elif b == 0xD8:  # fixext 16
+            typ = TYPE_EXT
+            if self._max_ext_len < 16:
+                raise ValueError("%s exceeds max_ext_len(%s)" % (16, self._max_ext_len))
+            self._reserve(17)
+            n, obj = _unpack_from("b16s", self._buffer, self._buff_i)
+            self._buff_i += 17
+        elif b == 0xD9:
+            typ = TYPE_RAW
+            self._reserve(1)
+            n = self._buffer[self._buff_i]
+            self._buff_i += 1
+            if n > self._max_str_len:
+                raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
+            obj = self._read(n)
+        elif b == 0xDA:
+            typ = TYPE_RAW
+            self._reserve(2)
+            (n,) = _unpack_from(">H", self._buffer, self._buff_i)
+            self._buff_i += 2
+            if n > self._max_str_len:
+                raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
+            obj = self._read(n)
+        elif b == 0xDB:
+            typ = TYPE_RAW
+            self._reserve(4)
+            (n,) = _unpack_from(">I", self._buffer, self._buff_i)
+            self._buff_i += 4
+            if n > self._max_str_len:
+                raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
+            obj = self._read(n)
+        elif b == 0xDC:
+            typ = TYPE_ARRAY
+            self._reserve(2)
+            (n,) = _unpack_from(">H", self._buffer, self._buff_i)
+            self._buff_i += 2
+            if n > self._max_array_len:
+                raise ValueError("%s exceeds max_array_len(%s)", n, self._max_array_len)
+        elif b == 0xDD:
+            typ = TYPE_ARRAY
+            self._reserve(4)
+            (n,) = _unpack_from(">I", self._buffer, self._buff_i)
+            self._buff_i += 4
+            if n > self._max_array_len:
+                raise ValueError("%s exceeds max_array_len(%s)", n, self._max_array_len)
+        elif b == 0xDE:
+            self._reserve(2)
+            (n,) = _unpack_from(">H", self._buffer, self._buff_i)
+            self._buff_i += 2
+            if n > self._max_map_len:
+                raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
+            typ = TYPE_MAP
+        elif b == 0xDF:
+            self._reserve(4)
+            (n,) = _unpack_from(">I", self._buffer, self._buff_i)
+            self._buff_i += 4
+            if n > self._max_map_len:
+                raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
+            typ = TYPE_MAP
+        else:
+            raise FormatError("Unknown header: 0x%x" % b)
+        return typ, n, obj
+
+    def _unpack(self, execute=EX_CONSTRUCT):
+        typ, n, obj = self._read_header(execute)
+
+        if execute == EX_READ_ARRAY_HEADER:
+            if typ != TYPE_ARRAY:
+                raise ValueError("Expected array")
+            return n
+        if execute == EX_READ_MAP_HEADER:
+            if typ != TYPE_MAP:
+                raise ValueError("Expected map")
+            return n
+        # TODO should we eliminate the recursion?
+        if typ == TYPE_ARRAY:
+            if execute == EX_SKIP:
+                for i in xrange(n):
+                    # TODO check whether we need to call `list_hook`
+                    self._unpack(EX_SKIP)
+                return
+            ret = newlist_hint(n)
+            for i in xrange(n):
+                ret.append(self._unpack(EX_CONSTRUCT))
+            if self._list_hook is not None:
+                ret = self._list_hook(ret)
+            # TODO is the interaction between `list_hook` and `use_list` ok?
+            return ret if self._use_list else tuple(ret)
+        if typ == TYPE_MAP:
+            if execute == EX_SKIP:
+                for i in xrange(n):
+                    # TODO check whether we need to call hooks
+                    self._unpack(EX_SKIP)
+                    self._unpack(EX_SKIP)
+                return
+            if self._object_pairs_hook is not None:
+                ret = self._object_pairs_hook(
+                    (self._unpack(EX_CONSTRUCT), self._unpack(EX_CONSTRUCT))
+                    for _ in xrange(n)
+                )
+            else:
+                ret = {}
+                for _ in xrange(n):
+                    key = self._unpack(EX_CONSTRUCT)
+                    if self._strict_map_key and type(key) not in (unicode, bytes):
+                        raise ValueError(
+                            "%s is not allowed for map key" % str(type(key))
+                        )
+                    if not PY2 and type(key) is str:
+                        key = sys.intern(key)
+                    ret[key] = self._unpack(EX_CONSTRUCT)
+                if self._object_hook is not None:
+                    ret = self._object_hook(ret)
+            return ret
+        if execute == EX_SKIP:
+            return
+        if typ == TYPE_RAW:
+            if self._raw:
+                obj = bytes(obj)
+            else:
+                obj = obj.decode("utf_8", self._unicode_errors)
+            return obj
+        if typ == TYPE_BIN:
+            return bytes(obj)
+        if typ == TYPE_EXT:
+            if n == -1:  # timestamp
+                ts = Timestamp.from_bytes(bytes(obj))
+                if self._timestamp == 1:
+                    return ts.to_unix()
+                elif self._timestamp == 2:
+                    return ts.to_unix_nano()
+                elif self._timestamp == 3:
+                    return ts.to_datetime()
+                else:
+                    return ts
+            else:
+                return self._ext_hook(n, bytes(obj))
+        assert typ == TYPE_IMMEDIATE
+        return obj
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        try:
+            ret = self._unpack(EX_CONSTRUCT)
+            self._consume()
+            return ret
+        except OutOfData:
+            self._consume()
+            raise StopIteration
+        except RecursionError:
+            raise StackError
+
+    next = __next__
+
+    def skip(self):
+        self._unpack(EX_SKIP)
+        self._consume()
+
+    def unpack(self):
+        try:
+            ret = self._unpack(EX_CONSTRUCT)
+        except RecursionError:
+            raise StackError
+        self._consume()
+        return ret
+
+    def read_array_header(self):
+        ret = self._unpack(EX_READ_ARRAY_HEADER)
+        self._consume()
+        return ret
+
+    def read_map_header(self):
+        ret = self._unpack(EX_READ_MAP_HEADER)
+        self._consume()
+        return ret
+
+    def tell(self):
+        return self._stream_offset
+
+
+class Packer(object):
+    """
+    MessagePack Packer
+
+    Usage:
+
+        packer = Packer()
+        astream.write(packer.pack(a))
+        astream.write(packer.pack(b))
+
+    Packer's constructor has some keyword arguments:
+
+    :param callable default:
+        Convert user type to builtin type that Packer supports.
+        See also simplejson's document.
+
+    :param bool use_single_float:
+        Use single precision float type for float. (default: False)
+
+    :param bool autoreset:
+        Reset buffer after each pack and return its content as `bytes`. (default: True).
+        If set this to false, use `bytes()` to get content and `.reset()` to clear buffer.
+
+    :param bool use_bin_type:
+        Use bin type introduced in msgpack spec 2.0 for bytes.
+        It also enables str8 type for unicode. (default: True)
+
+    :param bool strict_types:
+        If set to true, types will be checked to be exact. Derived classes
+        from serializable types will not be serialized and will be
+        treated as unsupported type and forwarded to default.
+        Additionally tuples will not be serialized as lists.
+        This is useful when trying to implement accurate serialization
+        for python types.
+
+    :param bool datetime:
+        If set to true, datetime with tzinfo is packed into Timestamp type.
+        Note that the tzinfo is stripped in the timestamp.
+        You can get UTC datetime with `timestamp=3` option of the Unpacker.
+        (Python 2 is not supported).
+
+    :param str unicode_errors:
+        The error handler for encoding unicode. (default: 'strict')
+        DO NOT USE THIS!!  This option is kept for very specific usage.
+    """
+
+    def __init__(
+        self,
+        default=None,
+        use_single_float=False,
+        autoreset=True,
+        use_bin_type=True,
+        strict_types=False,
+        datetime=False,
+        unicode_errors=None,
+    ):
+        self._strict_types = strict_types
+        self._use_float = use_single_float
+        self._autoreset = autoreset
+        self._use_bin_type = use_bin_type
+        self._buffer = StringIO()
+        if PY2 and datetime:
+            raise ValueError("datetime is not supported in Python 2")
+        self._datetime = bool(datetime)
+        self._unicode_errors = unicode_errors or "strict"
+        if default is not None:
+            if not callable(default):
+                raise TypeError("default must be callable")
+        self._default = default
+
+    def _pack(
+        self,
+        obj,
+        nest_limit=DEFAULT_RECURSE_LIMIT,
+        check=isinstance,
+        check_type_strict=_check_type_strict,
+    ):
+        default_used = False
+        if self._strict_types:
+            check = check_type_strict
+            list_types = list
+        else:
+            list_types = (list, tuple)
+        while True:
+            if nest_limit < 0:
+                raise ValueError("recursion limit exceeded")
+            if obj is None:
+                return self._buffer.write(b"\xc0")
+            if check(obj, bool):
+                if obj:
+                    return self._buffer.write(b"\xc3")
+                return self._buffer.write(b"\xc2")
+            if check(obj, int_types):
+                if 0 <= obj < 0x80:
+                    return self._buffer.write(struct.pack("B", obj))
+                if -0x20 <= obj < 0:
+                    return self._buffer.write(struct.pack("b", obj))
+                if 0x80 <= obj <= 0xFF:
+                    return self._buffer.write(struct.pack("BB", 0xCC, obj))
+                if -0x80 <= obj < 0:
+                    return self._buffer.write(struct.pack(">Bb", 0xD0, obj))
+                if 0xFF < obj <= 0xFFFF:
+                    return self._buffer.write(struct.pack(">BH", 0xCD, obj))
+                if -0x8000 <= obj < -0x80:
+                    return self._buffer.write(struct.pack(">Bh", 0xD1, obj))
+                if 0xFFFF < obj <= 0xFFFFFFFF:
+                    return self._buffer.write(struct.pack(">BI", 0xCE, obj))
+                if -0x80000000 <= obj < -0x8000:
+                    return self._buffer.write(struct.pack(">Bi", 0xD2, obj))
+                if 0xFFFFFFFF < obj <= 0xFFFFFFFFFFFFFFFF:
+                    return self._buffer.write(struct.pack(">BQ", 0xCF, obj))
+                if -0x8000000000000000 <= obj < -0x80000000:
+                    return self._buffer.write(struct.pack(">Bq", 0xD3, obj))
+                if not default_used and self._default is not None:
+                    obj = self._default(obj)
+                    default_used = True
+                    continue
+                raise OverflowError("Integer value out of range")
+            if check(obj, (bytes, bytearray)):
+                n = len(obj)
+                if n >= 2 ** 32:
+                    raise ValueError("%s is too large" % type(obj).__name__)
+                self._pack_bin_header(n)
+                return self._buffer.write(obj)
+            if check(obj, unicode):
+                obj = obj.encode("utf-8", self._unicode_errors)
+                n = len(obj)
+                if n >= 2 ** 32:
+                    raise ValueError("String is too large")
+                self._pack_raw_header(n)
+                return self._buffer.write(obj)
+            if check(obj, memoryview):
+                n = len(obj) * obj.itemsize
+                if n >= 2 ** 32:
+                    raise ValueError("Memoryview is too large")
+                self._pack_bin_header(n)
+                return self._buffer.write(obj)
+            if check(obj, float):
+                if self._use_float:
+                    return self._buffer.write(struct.pack(">Bf", 0xCA, obj))
+                return self._buffer.write(struct.pack(">Bd", 0xCB, obj))
+            if check(obj, (ExtType, Timestamp)):
+                if check(obj, Timestamp):
+                    code = -1
+                    data = obj.to_bytes()
+                else:
+                    code = obj.code
+                    data = obj.data
+                assert isinstance(code, int)
+                assert isinstance(data, bytes)
+                L = len(data)
+                if L == 1:
+                    self._buffer.write(b"\xd4")
+                elif L == 2:
+                    self._buffer.write(b"\xd5")
+                elif L == 4:
+                    self._buffer.write(b"\xd6")
+                elif L == 8:
+                    self._buffer.write(b"\xd7")
+                elif L == 16:
+                    self._buffer.write(b"\xd8")
+                elif L <= 0xFF:
+                    self._buffer.write(struct.pack(">BB", 0xC7, L))
+                elif L <= 0xFFFF:
+                    self._buffer.write(struct.pack(">BH", 0xC8, L))
+                else:
+                    self._buffer.write(struct.pack(">BI", 0xC9, L))
+                self._buffer.write(struct.pack("b", code))
+                self._buffer.write(data)
+                return
+            if check(obj, list_types):
+                n = len(obj)
+                self._pack_array_header(n)
+                for i in xrange(n):
+                    self._pack(obj[i], nest_limit - 1)
+                return
+            if check(obj, dict):
+                return self._pack_map_pairs(
+                    len(obj), dict_iteritems(obj), nest_limit - 1
+                )
+
+            if self._datetime and check(obj, _DateTime):
+                obj = Timestamp.from_datetime(obj)
+                default_used = 1
+                continue
+
+            if not default_used and self._default is not None:
+                obj = self._default(obj)
+                default_used = 1
+                continue
+            raise TypeError("Cannot serialize %r" % (obj,))
+
+    def pack(self, obj):
+        try:
+            self._pack(obj)
+        except:
+            self._buffer = StringIO()  # force reset
+            raise
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = StringIO()
+            return ret
+
+    def pack_map_pairs(self, pairs):
+        self._pack_map_pairs(len(pairs), pairs)
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = StringIO()
+            return ret
+
+    def pack_array_header(self, n):
+        if n >= 2 ** 32:
+            raise ValueError
+        self._pack_array_header(n)
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = StringIO()
+            return ret
+
+    def pack_map_header(self, n):
+        if n >= 2 ** 32:
+            raise ValueError
+        self._pack_map_header(n)
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = StringIO()
+            return ret
+
+    def pack_ext_type(self, typecode, data):
+        if not isinstance(typecode, int):
+            raise TypeError("typecode must have int type.")
+        if not 0 <= typecode <= 127:
+            raise ValueError("typecode should be 0-127")
+        if not isinstance(data, bytes):
+            raise TypeError("data must have bytes type")
+        L = len(data)
+        if L > 0xFFFFFFFF:
+            raise ValueError("Too large data")
+        if L == 1:
+            self._buffer.write(b"\xd4")
+        elif L == 2:
+            self._buffer.write(b"\xd5")
+        elif L == 4:
+            self._buffer.write(b"\xd6")
+        elif L == 8:
+            self._buffer.write(b"\xd7")
+        elif L == 16:
+            self._buffer.write(b"\xd8")
+        elif L <= 0xFF:
+            self._buffer.write(b"\xc7" + struct.pack("B", L))
+        elif L <= 0xFFFF:
+            self._buffer.write(b"\xc8" + struct.pack(">H", L))
+        else:
+            self._buffer.write(b"\xc9" + struct.pack(">I", L))
+        self._buffer.write(struct.pack("B", typecode))
+        self._buffer.write(data)
+
+    def _pack_array_header(self, n):
+        if n <= 0x0F:
+            return self._buffer.write(struct.pack("B", 0x90 + n))
+        if n <= 0xFFFF:
+            return self._buffer.write(struct.pack(">BH", 0xDC, n))
+        if n <= 0xFFFFFFFF:
+            return self._buffer.write(struct.pack(">BI", 0xDD, n))
+        raise ValueError("Array is too large")
+
+    def _pack_map_header(self, n):
+        if n <= 0x0F:
+            return self._buffer.write(struct.pack("B", 0x80 + n))
+        if n <= 0xFFFF:
+            return self._buffer.write(struct.pack(">BH", 0xDE, n))
+        if n <= 0xFFFFFFFF:
+            return self._buffer.write(struct.pack(">BI", 0xDF, n))
+        raise ValueError("Dict is too large")
+
+    def _pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT):
+        self._pack_map_header(n)
+        for (k, v) in pairs:
+            self._pack(k, nest_limit - 1)
+            self._pack(v, nest_limit - 1)
+
+    def _pack_raw_header(self, n):
+        if n <= 0x1F:
+            self._buffer.write(struct.pack("B", 0xA0 + n))
+        elif self._use_bin_type and n <= 0xFF:
+            self._buffer.write(struct.pack(">BB", 0xD9, n))
+        elif n <= 0xFFFF:
+            self._buffer.write(struct.pack(">BH", 0xDA, n))
+        elif n <= 0xFFFFFFFF:
+            self._buffer.write(struct.pack(">BI", 0xDB, n))
+        else:
+            raise ValueError("Raw is too large")
+
+    def _pack_bin_header(self, n):
+        if not self._use_bin_type:
+            return self._pack_raw_header(n)
+        elif n <= 0xFF:
+            return self._buffer.write(struct.pack(">BB", 0xC4, n))
+        elif n <= 0xFFFF:
+            return self._buffer.write(struct.pack(">BH", 0xC5, n))
+        elif n <= 0xFFFFFFFF:
+            return self._buffer.write(struct.pack(">BI", 0xC6, n))
+        else:
+            raise ValueError("Bin is too large")
+
+    def bytes(self):
+        """Return internal buffer contents as bytes object"""
+        return self._buffer.getvalue()
+
+    def reset(self):
+        """Reset internal buffer.
+
+        This method is useful only when autoreset=False.
+        """
+        self._buffer = StringIO()
+
+    def getbuffer(self):
+        """Return view of internal buffer."""
+        if USING_STRINGBUILDER or PY2:
+            return memoryview(self.bytes())
+        else:
+            return self._buffer.getbuffer()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/__about__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/__about__.py
new file mode 100644
index 0000000..4d99857
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/__about__.py
@@ -0,0 +1,27 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
+
+__title__ = "packaging"
+__summary__ = "Core utilities for Python packages"
+__uri__ = "https://github.com/pypa/packaging"
+
+__version__ = "20.4"
+
+__author__ = "Donald Stufft and individual contributors"
+__email__ = "donald@stufft.io"
+
+__license__ = "BSD-2-Clause or Apache-2.0"
+__copyright__ = "Copyright 2014-2019 %s" % __author__
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/__init__.py
new file mode 100644
index 0000000..a0cf67d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/__init__.py
@@ -0,0 +1,26 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+from .__about__ import (
+    __author__,
+    __copyright__,
+    __email__,
+    __license__,
+    __summary__,
+    __title__,
+    __uri__,
+    __version__,
+)
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/_compat.py b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/_compat.py
new file mode 100644
index 0000000..e54bd4e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/_compat.py
@@ -0,0 +1,38 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import sys
+
+from ._typing import TYPE_CHECKING
+
+if TYPE_CHECKING:  # pragma: no cover
+    from typing import Any, Dict, Tuple, Type
+
+
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+# flake8: noqa
+
+if PY3:
+    string_types = (str,)
+else:
+    string_types = (basestring,)
+
+
+def with_metaclass(meta, *bases):
+    # type: (Type[Any], Tuple[Type[Any], ...]) -> Any
+    """
+    Create a base class with a metaclass.
+    """
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):  # type: ignore
+        def __new__(cls, name, this_bases, d):
+            # type: (Type[Any], str, Tuple[Any], Dict[Any, Any]) -> Any
+            return meta(name, bases, d)
+
+    return type.__new__(metaclass, "temporary_class", (), {})
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/_structures.py b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/_structures.py
new file mode 100644
index 0000000..800d5c5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/_structures.py
@@ -0,0 +1,86 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+
+class InfinityType(object):
+    def __repr__(self):
+        # type: () -> str
+        return "Infinity"
+
+    def __hash__(self):
+        # type: () -> int
+        return hash(repr(self))
+
+    def __lt__(self, other):
+        # type: (object) -> bool
+        return False
+
+    def __le__(self, other):
+        # type: (object) -> bool
+        return False
+
+    def __eq__(self, other):
+        # type: (object) -> bool
+        return isinstance(other, self.__class__)
+
+    def __ne__(self, other):
+        # type: (object) -> bool
+        return not isinstance(other, self.__class__)
+
+    def __gt__(self, other):
+        # type: (object) -> bool
+        return True
+
+    def __ge__(self, other):
+        # type: (object) -> bool
+        return True
+
+    def __neg__(self):
+        # type: (object) -> NegativeInfinityType
+        return NegativeInfinity
+
+
+Infinity = InfinityType()
+
+
+class NegativeInfinityType(object):
+    def __repr__(self):
+        # type: () -> str
+        return "-Infinity"
+
+    def __hash__(self):
+        # type: () -> int
+        return hash(repr(self))
+
+    def __lt__(self, other):
+        # type: (object) -> bool
+        return True
+
+    def __le__(self, other):
+        # type: (object) -> bool
+        return True
+
+    def __eq__(self, other):
+        # type: (object) -> bool
+        return isinstance(other, self.__class__)
+
+    def __ne__(self, other):
+        # type: (object) -> bool
+        return not isinstance(other, self.__class__)
+
+    def __gt__(self, other):
+        # type: (object) -> bool
+        return False
+
+    def __ge__(self, other):
+        # type: (object) -> bool
+        return False
+
+    def __neg__(self):
+        # type: (object) -> InfinityType
+        return Infinity
+
+
+NegativeInfinity = NegativeInfinityType()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/_typing.py b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/_typing.py
new file mode 100644
index 0000000..2846133
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/_typing.py
@@ -0,0 +1,48 @@
+"""For neatly implementing static typing in packaging.
+
+`mypy` - the static type analysis tool we use - uses the `typing` module, which
+provides core functionality fundamental to mypy's functioning.
+
+Generally, `typing` would be imported at runtime and used in that fashion -
+it acts as a no-op at runtime and does not have any run-time overhead by
+design.
+
+As it turns out, `typing` is not vendorable - it uses separate sources for
+Python 2/Python 3. Thus, this codebase can not expect it to be present.
+To work around this, mypy allows the typing import to be behind a False-y
+optional to prevent it from running at runtime and type-comments can be used
+to remove the need for the types to be accessible directly during runtime.
+
+This module provides the False-y guard in a nicely named fashion so that a
+curious maintainer can reach here to read this.
+
+In packaging, all static-typing related imports should be guarded as follows:
+
+    from pip._vendor.packaging._typing import TYPE_CHECKING
+
+    if TYPE_CHECKING:
+        from typing import ...
+
+Ref: https://github.com/python/mypy/issues/3216
+"""
+
+__all__ = ["TYPE_CHECKING", "cast"]
+
+# The TYPE_CHECKING constant defined by the typing module is False at runtime
+# but True while type checking.
+if False:  # pragma: no cover
+    from typing import TYPE_CHECKING
+else:
+    TYPE_CHECKING = False
+
+# typing's cast syntax requires calling typing.cast at runtime, but we don't
+# want to import typing at runtime. Here, we inform the type checkers that
+# we're importing `typing.cast` as `cast` and re-implement typing.cast's
+# runtime behavior in a block that is ignored by type checkers.
+if TYPE_CHECKING:  # pragma: no cover
+    # not executed at runtime
+    from typing import cast
+else:
+    # executed at runtime
+    def cast(type_, value):  # noqa
+        return value
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/markers.py b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/markers.py
new file mode 100644
index 0000000..ed642b0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/markers.py
@@ -0,0 +1,328 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import operator
+import os
+import platform
+import sys
+
+from pip._vendor.pyparsing import ParseException, ParseResults, stringStart, stringEnd
+from pip._vendor.pyparsing import ZeroOrMore, Group, Forward, QuotedString
+from pip._vendor.pyparsing import Literal as L  # noqa
+
+from ._compat import string_types
+from ._typing import TYPE_CHECKING
+from .specifiers import Specifier, InvalidSpecifier
+
+if TYPE_CHECKING:  # pragma: no cover
+    from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+    Operator = Callable[[str, str], bool]
+
+
+__all__ = [
+    "InvalidMarker",
+    "UndefinedComparison",
+    "UndefinedEnvironmentName",
+    "Marker",
+    "default_environment",
+]
+
+
+class InvalidMarker(ValueError):
+    """
+    An invalid marker was found, users should refer to PEP 508.
+    """
+
+
+class UndefinedComparison(ValueError):
+    """
+    An invalid operation was attempted on a value that doesn't support it.
+    """
+
+
+class UndefinedEnvironmentName(ValueError):
+    """
+    A name was attempted to be used that does not exist inside of the
+    environment.
+    """
+
+
+class Node(object):
+    def __init__(self, value):
+        # type: (Any) -> None
+        self.value = value
+
+    def __str__(self):
+        # type: () -> str
+        return str(self.value)
+
+    def __repr__(self):
+        # type: () -> str
+        return "<{0}({1!r})>".format(self.__class__.__name__, str(self))
+
+    def serialize(self):
+        # type: () -> str
+        raise NotImplementedError
+
+
+class Variable(Node):
+    def serialize(self):
+        # type: () -> str
+        return str(self)
+
+
+class Value(Node):
+    def serialize(self):
+        # type: () -> str
+        return '"{0}"'.format(self)
+
+
+class Op(Node):
+    def serialize(self):
+        # type: () -> str
+        return str(self)
+
+
+VARIABLE = (
+    L("implementation_version")
+    | L("platform_python_implementation")
+    | L("implementation_name")
+    | L("python_full_version")
+    | L("platform_release")
+    | L("platform_version")
+    | L("platform_machine")
+    | L("platform_system")
+    | L("python_version")
+    | L("sys_platform")
+    | L("os_name")
+    | L("os.name")  # PEP-345
+    | L("sys.platform")  # PEP-345
+    | L("platform.version")  # PEP-345
+    | L("platform.machine")  # PEP-345
+    | L("platform.python_implementation")  # PEP-345
+    | L("python_implementation")  # undocumented setuptools legacy
+    | L("extra")  # PEP-508
+)
+ALIASES = {
+    "os.name": "os_name",
+    "sys.platform": "sys_platform",
+    "platform.version": "platform_version",
+    "platform.machine": "platform_machine",
+    "platform.python_implementation": "platform_python_implementation",
+    "python_implementation": "platform_python_implementation",
+}
+VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))
+
+VERSION_CMP = (
+    L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<")
+)
+
+MARKER_OP = VERSION_CMP | L("not in") | L("in")
+MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))
+
+MARKER_VALUE = QuotedString("'") | QuotedString('"')
+MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
+
+BOOLOP = L("and") | L("or")
+
+MARKER_VAR = VARIABLE | MARKER_VALUE
+
+MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
+MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
+
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+
+MARKER_EXPR = Forward()
+MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
+MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
+
+MARKER = stringStart + MARKER_EXPR + stringEnd
+
+
+def _coerce_parse_result(results):
+    # type: (Union[ParseResults, List[Any]]) -> List[Any]
+    if isinstance(results, ParseResults):
+        return [_coerce_parse_result(i) for i in results]
+    else:
+        return results
+
+
+def _format_marker(marker, first=True):
+    # type: (Union[List[str], Tuple[Node, ...], str], Optional[bool]) -> str
+
+    assert isinstance(marker, (list, tuple, string_types))
+
+    # Sometimes we have a structure like [[...]] which is a single item list
+    # where the single item is itself it's own list. In that case we want skip
+    # the rest of this function so that we don't get extraneous () on the
+    # outside.
+    if (
+        isinstance(marker, list)
+        and len(marker) == 1
+        and isinstance(marker[0], (list, tuple))
+    ):
+        return _format_marker(marker[0])
+
+    if isinstance(marker, list):
+        inner = (_format_marker(m, first=False) for m in marker)
+        if first:
+            return " ".join(inner)
+        else:
+            return "(" + " ".join(inner) + ")"
+    elif isinstance(marker, tuple):
+        return " ".join([m.serialize() for m in marker])
+    else:
+        return marker
+
+
+_operators = {
+    "in": lambda lhs, rhs: lhs in rhs,
+    "not in": lambda lhs, rhs: lhs not in rhs,
+    "<": operator.lt,
+    "<=": operator.le,
+    "==": operator.eq,
+    "!=": operator.ne,
+    ">=": operator.ge,
+    ">": operator.gt,
+}  # type: Dict[str, Operator]
+
+
+def _eval_op(lhs, op, rhs):
+    # type: (str, Op, str) -> bool
+    try:
+        spec = Specifier("".join([op.serialize(), rhs]))
+    except InvalidSpecifier:
+        pass
+    else:
+        return spec.contains(lhs)
+
+    oper = _operators.get(op.serialize())  # type: Optional[Operator]
+    if oper is None:
+        raise UndefinedComparison(
+            "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs)
+        )
+
+    return oper(lhs, rhs)
+
+
+class Undefined(object):
+    pass
+
+
+_undefined = Undefined()
+
+
+def _get_env(environment, name):
+    # type: (Dict[str, str], str) -> str
+    value = environment.get(name, _undefined)  # type: Union[str, Undefined]
+
+    if isinstance(value, Undefined):
+        raise UndefinedEnvironmentName(
+            "{0!r} does not exist in evaluation environment.".format(name)
+        )
+
+    return value
+
+
+def _evaluate_markers(markers, environment):
+    # type: (List[Any], Dict[str, str]) -> bool
+    groups = [[]]  # type: List[List[bool]]
+
+    for marker in markers:
+        assert isinstance(marker, (list, tuple, string_types))
+
+        if isinstance(marker, list):
+            groups[-1].append(_evaluate_markers(marker, environment))
+        elif isinstance(marker, tuple):
+            lhs, op, rhs = marker
+
+            if isinstance(lhs, Variable):
+                lhs_value = _get_env(environment, lhs.value)
+                rhs_value = rhs.value
+            else:
+                lhs_value = lhs.value
+                rhs_value = _get_env(environment, rhs.value)
+
+            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
+        else:
+            assert marker in ["and", "or"]
+            if marker == "or":
+                groups.append([])
+
+    return any(all(item) for item in groups)
+
+
+def format_full_version(info):
+    # type: (sys._version_info) -> str
+    version = "{0.major}.{0.minor}.{0.micro}".format(info)
+    kind = info.releaselevel
+    if kind != "final":
+        version += kind[0] + str(info.serial)
+    return version
+
+
+def default_environment():
+    # type: () -> Dict[str, str]
+    if hasattr(sys, "implementation"):
+        # Ignoring the `sys.implementation` reference for type checking due to
+        # mypy not liking that the attribute doesn't exist in Python 2.7 when
+        # run with the `--py27` flag.
+        iver = format_full_version(sys.implementation.version)  # type: ignore
+        implementation_name = sys.implementation.name  # type: ignore
+    else:
+        iver = "0"
+        implementation_name = ""
+
+    return {
+        "implementation_name": implementation_name,
+        "implementation_version": iver,
+        "os_name": os.name,
+        "platform_machine": platform.machine(),
+        "platform_release": platform.release(),
+        "platform_system": platform.system(),
+        "platform_version": platform.version(),
+        "python_full_version": platform.python_version(),
+        "platform_python_implementation": platform.python_implementation(),
+        "python_version": ".".join(platform.python_version_tuple()[:2]),
+        "sys_platform": sys.platform,
+    }
+
+
+class Marker(object):
+    def __init__(self, marker):
+        # type: (str) -> None
+        try:
+            self._markers = _coerce_parse_result(MARKER.parseString(marker))
+        except ParseException as e:
+            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format(
+                marker, marker[e.loc : e.loc + 8]
+            )
+            raise InvalidMarker(err_str)
+
+    def __str__(self):
+        # type: () -> str
+        return _format_marker(self._markers)
+
+    def __repr__(self):
+        # type: () -> str
+        return "<Marker({0!r})>".format(str(self))
+
+    def evaluate(self, environment=None):
+        # type: (Optional[Dict[str, str]]) -> bool
+        """Evaluate a marker.
+
+        Return the boolean from evaluating the given marker against the
+        environment. environment is an optional argument to override all or
+        part of the determined environment.
+
+        The environment is determined from the current Python process.
+        """
+        current_environment = default_environment()
+        if environment is not None:
+            current_environment.update(environment)
+
+        return _evaluate_markers(self._markers, current_environment)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/requirements.py b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/requirements.py
new file mode 100644
index 0000000..5e64101
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/requirements.py
@@ -0,0 +1,145 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import string
+import re
+
+from pip._vendor.pyparsing import stringStart, stringEnd, originalTextFor, ParseException
+from pip._vendor.pyparsing import ZeroOrMore, Word, Optional, Regex, Combine
+from pip._vendor.pyparsing import Literal as L  # noqa
+from pip._vendor.six.moves.urllib import parse as urlparse
+
+from ._typing import TYPE_CHECKING
+from .markers import MARKER_EXPR, Marker
+from .specifiers import LegacySpecifier, Specifier, SpecifierSet
+
+if TYPE_CHECKING:  # pragma: no cover
+    from typing import List
+
+
+class InvalidRequirement(ValueError):
+    """
+    An invalid requirement was found, users should refer to PEP 508.
+    """
+
+
+ALPHANUM = Word(string.ascii_letters + string.digits)
+
+LBRACKET = L("[").suppress()
+RBRACKET = L("]").suppress()
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+COMMA = L(",").suppress()
+SEMICOLON = L(";").suppress()
+AT = L("@").suppress()
+
+PUNCTUATION = Word("-_.")
+IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
+IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
+
+NAME = IDENTIFIER("name")
+EXTRA = IDENTIFIER
+
+URI = Regex(r"[^ ]+")("url")
+URL = AT + URI
+
+EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
+EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
+
+VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
+VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
+
+VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
+VERSION_MANY = Combine(
+    VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False
+)("_raw_spec")
+_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY))
+_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "")
+
+VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
+VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
+
+MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
+MARKER_EXPR.setParseAction(
+    lambda s, l, t: Marker(s[t._original_start : t._original_end])
+)
+MARKER_SEPARATOR = SEMICOLON
+MARKER = MARKER_SEPARATOR + MARKER_EXPR
+
+VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
+URL_AND_MARKER = URL + Optional(MARKER)
+
+NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
+
+REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
+# pyparsing isn't thread safe during initialization, so we do it eagerly, see
+# issue #104
+REQUIREMENT.parseString("x[]")
+
+
+class Requirement(object):
+    """Parse a requirement.
+
+    Parse a given requirement string into its parts, such as name, specifier,
+    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
+    string.
+    """
+
+    # TODO: Can we test whether something is contained within a requirement?
+    #       If so how do we do that? Do we need to test against the _name_ of
+    #       the thing as well as the version? What about the markers?
+    # TODO: Can we normalize the name and extra name?
+
+    def __init__(self, requirement_string):
+        # type: (str) -> None
+        try:
+            req = REQUIREMENT.parseString(requirement_string)
+        except ParseException as e:
+            raise InvalidRequirement(
+                'Parse error at "{0!r}": {1}'.format(
+                    requirement_string[e.loc : e.loc + 8], e.msg
+                )
+            )
+
+        self.name = req.name
+        if req.url:
+            parsed_url = urlparse.urlparse(req.url)
+            if parsed_url.scheme == "file":
+                if urlparse.urlunparse(parsed_url) != req.url:
+                    raise InvalidRequirement("Invalid URL given")
+            elif not (parsed_url.scheme and parsed_url.netloc) or (
+                not parsed_url.scheme and not parsed_url.netloc
+            ):
+                raise InvalidRequirement("Invalid URL: {0}".format(req.url))
+            self.url = req.url
+        else:
+            self.url = None
+        self.extras = set(req.extras.asList() if req.extras else [])
+        self.specifier = SpecifierSet(req.specifier)
+        self.marker = req.marker if req.marker else None
+
+    def __str__(self):
+        # type: () -> str
+        parts = [self.name]  # type: List[str]
+
+        if self.extras:
+            parts.append("[{0}]".format(",".join(sorted(self.extras))))
+
+        if self.specifier:
+            parts.append(str(self.specifier))
+
+        if self.url:
+            parts.append("@ {0}".format(self.url))
+            if self.marker:
+                parts.append(" ")
+
+        if self.marker:
+            parts.append("; {0}".format(self.marker))
+
+        return "".join(parts)
+
+    def __repr__(self):
+        # type: () -> str
+        return "<Requirement({0!r})>".format(str(self))
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/specifiers.py b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/specifiers.py
new file mode 100644
index 0000000..fe09bb1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/specifiers.py
@@ -0,0 +1,863 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import abc
+import functools
+import itertools
+import re
+
+from ._compat import string_types, with_metaclass
+from ._typing import TYPE_CHECKING
+from .utils import canonicalize_version
+from .version import Version, LegacyVersion, parse
+
+if TYPE_CHECKING:  # pragma: no cover
+    from typing import (
+        List,
+        Dict,
+        Union,
+        Iterable,
+        Iterator,
+        Optional,
+        Callable,
+        Tuple,
+        FrozenSet,
+    )
+
+    ParsedVersion = Union[Version, LegacyVersion]
+    UnparsedVersion = Union[Version, LegacyVersion, str]
+    CallableOperator = Callable[[ParsedVersion, str], bool]
+
+
+class InvalidSpecifier(ValueError):
+    """
+    An invalid specifier was found, users should refer to PEP 440.
+    """
+
+
+class BaseSpecifier(with_metaclass(abc.ABCMeta, object)):  # type: ignore
+    @abc.abstractmethod
+    def __str__(self):
+        # type: () -> str
+        """
+        Returns the str representation of this Specifier like object. This
+        should be representative of the Specifier itself.
+        """
+
+    @abc.abstractmethod
+    def __hash__(self):
+        # type: () -> int
+        """
+        Returns a hash value for this Specifier like object.
+        """
+
+    @abc.abstractmethod
+    def __eq__(self, other):
+        # type: (object) -> bool
+        """
+        Returns a boolean representing whether or not the two Specifier like
+        objects are equal.
+        """
+
+    @abc.abstractmethod
+    def __ne__(self, other):
+        # type: (object) -> bool
+        """
+        Returns a boolean representing whether or not the two Specifier like
+        objects are not equal.
+        """
+
+    @abc.abstractproperty
+    def prereleases(self):
+        # type: () -> Optional[bool]
+        """
+        Returns whether or not pre-releases as a whole are allowed by this
+        specifier.
+        """
+
+    @prereleases.setter
+    def prereleases(self, value):
+        # type: (bool) -> None
+        """
+        Sets whether or not pre-releases as a whole are allowed by this
+        specifier.
+        """
+
+    @abc.abstractmethod
+    def contains(self, item, prereleases=None):
+        # type: (str, Optional[bool]) -> bool
+        """
+        Determines if the given item is contained within this specifier.
+        """
+
+    @abc.abstractmethod
+    def filter(self, iterable, prereleases=None):
+        # type: (Iterable[UnparsedVersion], Optional[bool]) -> Iterable[UnparsedVersion]
+        """
+        Takes an iterable of items and filters them so that only items which
+        are contained within this specifier are allowed in it.
+        """
+
+
+class _IndividualSpecifier(BaseSpecifier):
+
+    _operators = {}  # type: Dict[str, str]
+
+    def __init__(self, spec="", prereleases=None):
+        # type: (str, Optional[bool]) -> None
+        match = self._regex.search(spec)
+        if not match:
+            raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec))
+
+        self._spec = (
+            match.group("operator").strip(),
+            match.group("version").strip(),
+        )  # type: Tuple[str, str]
+
+        # Store whether or not this Specifier should accept prereleases
+        self._prereleases = prereleases
+
+    def __repr__(self):
+        # type: () -> str
+        pre = (
+            ", prereleases={0!r}".format(self.prereleases)
+            if self._prereleases is not None
+            else ""
+        )
+
+        return "<{0}({1!r}{2})>".format(self.__class__.__name__, str(self), pre)
+
+    def __str__(self):
+        # type: () -> str
+        return "{0}{1}".format(*self._spec)
+
+    @property
+    def _canonical_spec(self):
+        # type: () -> Tuple[str, Union[Version, str]]
+        return self._spec[0], canonicalize_version(self._spec[1])
+
+    def __hash__(self):
+        # type: () -> int
+        return hash(self._canonical_spec)
+
+    def __eq__(self, other):
+        # type: (object) -> bool
+        if isinstance(other, string_types):
+            try:
+                other = self.__class__(str(other))
+            except InvalidSpecifier:
+                return NotImplemented
+        elif not isinstance(other, self.__class__):
+            return NotImplemented
+
+        return self._canonical_spec == other._canonical_spec
+
+    def __ne__(self, other):
+        # type: (object) -> bool
+        if isinstance(other, string_types):
+            try:
+                other = self.__class__(str(other))
+            except InvalidSpecifier:
+                return NotImplemented
+        elif not isinstance(other, self.__class__):
+            return NotImplemented
+
+        return self._spec != other._spec
+
+    def _get_operator(self, op):
+        # type: (str) -> CallableOperator
+        operator_callable = getattr(
+            self, "_compare_{0}".format(self._operators[op])
+        )  # type: CallableOperator
+        return operator_callable
+
+    def _coerce_version(self, version):
+        # type: (UnparsedVersion) -> ParsedVersion
+        if not isinstance(version, (LegacyVersion, Version)):
+            version = parse(version)
+        return version
+
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._spec[0]
+
+    @property
+    def version(self):
+        # type: () -> str
+        return self._spec[1]
+
+    @property
+    def prereleases(self):
+        # type: () -> Optional[bool]
+        return self._prereleases
+
+    @prereleases.setter
+    def prereleases(self, value):
+        # type: (bool) -> None
+        self._prereleases = value
+
+    def __contains__(self, item):
+        # type: (str) -> bool
+        return self.contains(item)
+
+    def contains(self, item, prereleases=None):
+        # type: (UnparsedVersion, Optional[bool]) -> bool
+
+        # Determine if prereleases are to be allowed or not.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # Normalize item to a Version or LegacyVersion, this allows us to have
+        # a shortcut for ``"2.0" in Specifier(">=2")
+        normalized_item = self._coerce_version(item)
+
+        # Determine if we should be supporting prereleases in this specifier
+        # or not, if we do not support prereleases than we can short circuit
+        # logic if this version is a prereleases.
+        if normalized_item.is_prerelease and not prereleases:
+            return False
+
+        # Actually do the comparison to determine if this item is contained
+        # within this Specifier or not.
+        operator_callable = self._get_operator(self.operator)  # type: CallableOperator
+        return operator_callable(normalized_item, self.version)
+
+    def filter(self, iterable, prereleases=None):
+        # type: (Iterable[UnparsedVersion], Optional[bool]) -> Iterable[UnparsedVersion]
+
+        yielded = False
+        found_prereleases = []
+
+        kw = {"prereleases": prereleases if prereleases is not None else True}
+
+        # Attempt to iterate over all the values in the iterable and if any of
+        # them match, yield them.
+        for version in iterable:
+            parsed_version = self._coerce_version(version)
+
+            if self.contains(parsed_version, **kw):
+                # If our version is a prerelease, and we were not set to allow
+                # prereleases, then we'll store it for later incase nothing
+                # else matches this specifier.
+                if parsed_version.is_prerelease and not (
+                    prereleases or self.prereleases
+                ):
+                    found_prereleases.append(version)
+                # Either this is not a prerelease, or we should have been
+                # accepting prereleases from the beginning.
+                else:
+                    yielded = True
+                    yield version
+
+        # Now that we've iterated over everything, determine if we've yielded
+        # any values, and if we have not and we have any prereleases stored up
+        # then we will go ahead and yield the prereleases.
+        if not yielded and found_prereleases:
+            for version in found_prereleases:
+                yield version
+
+
+class LegacySpecifier(_IndividualSpecifier):
+
+    _regex_str = r"""
+        (?P<operator>(==|!=|<=|>=|<|>))
+        \s*
+        (?P<version>
+            [^,;\s)]* # Since this is a "legacy" specifier, and the version
+                      # string can be just about anything, we match everything
+                      # except for whitespace, a semi-colon for marker support,
+                      # a closing paren since versions can be enclosed in
+                      # them, and a comma since it's a version separator.
+        )
+        """
+
+    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    _operators = {
+        "==": "equal",
+        "!=": "not_equal",
+        "<=": "less_than_equal",
+        ">=": "greater_than_equal",
+        "<": "less_than",
+        ">": "greater_than",
+    }
+
+    def _coerce_version(self, version):
+        # type: (Union[ParsedVersion, str]) -> LegacyVersion
+        if not isinstance(version, LegacyVersion):
+            version = LegacyVersion(str(version))
+        return version
+
+    def _compare_equal(self, prospective, spec):
+        # type: (LegacyVersion, str) -> bool
+        return prospective == self._coerce_version(spec)
+
+    def _compare_not_equal(self, prospective, spec):
+        # type: (LegacyVersion, str) -> bool
+        return prospective != self._coerce_version(spec)
+
+    def _compare_less_than_equal(self, prospective, spec):
+        # type: (LegacyVersion, str) -> bool
+        return prospective <= self._coerce_version(spec)
+
+    def _compare_greater_than_equal(self, prospective, spec):
+        # type: (LegacyVersion, str) -> bool
+        return prospective >= self._coerce_version(spec)
+
+    def _compare_less_than(self, prospective, spec):
+        # type: (LegacyVersion, str) -> bool
+        return prospective < self._coerce_version(spec)
+
+    def _compare_greater_than(self, prospective, spec):
+        # type: (LegacyVersion, str) -> bool
+        return prospective > self._coerce_version(spec)
+
+
+def _require_version_compare(
+    fn  # type: (Callable[[Specifier, ParsedVersion, str], bool])
+):
+    # type: (...) -> Callable[[Specifier, ParsedVersion, str], bool]
+    @functools.wraps(fn)
+    def wrapped(self, prospective, spec):
+        # type: (Specifier, ParsedVersion, str) -> bool
+        if not isinstance(prospective, Version):
+            return False
+        return fn(self, prospective, spec)
+
+    return wrapped
+
+
+class Specifier(_IndividualSpecifier):
+
+    _regex_str = r"""
+        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
+        (?P<version>
+            (?:
+                # The identity operators allow for an escape hatch that will
+                # do an exact string match of the version you wish to install.
+                # This will not be parsed by PEP 440 and we cannot determine
+                # any semantic meaning from it. This operator is discouraged
+                # but included entirely as an escape hatch.
+                (?<====)  # Only match for the identity operator
+                \s*
+                [^\s]*    # We just match everything, except for whitespace
+                          # since we are only testing for strict identity.
+            )
+            |
+            (?:
+                # The (non)equality operators allow for wild card and local
+                # versions to be specified so we have to define these two
+                # operators separately to enable that.
+                (?<===|!=)            # Only match for equals and not equals
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)*   # release
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+
+                # You cannot use a wild card and a dev or local version
+                # together so group them with a | and make them optional.
+                (?:
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
+                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
+                    |
+                    \.\*  # Wild card syntax of .*
+                )?
+            )
+            |
+            (?:
+                # The compatible operator requires at least two digits in the
+                # release segment.
+                (?<=~=)               # Only match for the compatible operator
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+            )
+            |
+            (?:
+                # All other operators only allow a sub set of what the
+                # (non)equality operators do. Specifically they do not allow
+                # local versions to be specified nor do they allow the prefix
+                # matching wild cards.
+                (?<!==|!=|~=)         # We have special cases for these
+                                      # operators so we want to make sure they
+                                      # don't match here.
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)*   # release
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+            )
+        )
+        """
+
+    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    _operators = {
+        "~=": "compatible",
+        "==": "equal",
+        "!=": "not_equal",
+        "<=": "less_than_equal",
+        ">=": "greater_than_equal",
+        "<": "less_than",
+        ">": "greater_than",
+        "===": "arbitrary",
+    }
+
+    @_require_version_compare
+    def _compare_compatible(self, prospective, spec):
+        # type: (ParsedVersion, str) -> bool
+
+        # Compatible releases have an equivalent combination of >= and ==. That
+        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
+        # implement this in terms of the other specifiers instead of
+        # implementing it ourselves. The only thing we need to do is construct
+        # the other specifiers.
+
+        # We want everything but the last item in the version, but we want to
+        # ignore post and dev releases and we want to treat the pre-release as
+        # it's own separate segment.
+        prefix = ".".join(
+            list(
+                itertools.takewhile(
+                    lambda x: (not x.startswith("post") and not x.startswith("dev")),
+                    _version_split(spec),
+                )
+            )[:-1]
+        )
+
+        # Add the prefix notation to the end of our string
+        prefix += ".*"
+
+        return self._get_operator(">=")(prospective, spec) and self._get_operator("==")(
+            prospective, prefix
+        )
+
+    @_require_version_compare
+    def _compare_equal(self, prospective, spec):
+        # type: (ParsedVersion, str) -> bool
+
+        # We need special logic to handle prefix matching
+        if spec.endswith(".*"):
+            # In the case of prefix matching we want to ignore local segment.
+            prospective = Version(prospective.public)
+            # Split the spec out by dots, and pretend that there is an implicit
+            # dot in between a release segment and a pre-release segment.
+            split_spec = _version_split(spec[:-2])  # Remove the trailing .*
+
+            # Split the prospective version out by dots, and pretend that there
+            # is an implicit dot in between a release segment and a pre-release
+            # segment.
+            split_prospective = _version_split(str(prospective))
+
+            # Shorten the prospective version to be the same length as the spec
+            # so that we can determine if the specifier is a prefix of the
+            # prospective version or not.
+            shortened_prospective = split_prospective[: len(split_spec)]
+
+            # Pad out our two sides with zeros so that they both equal the same
+            # length.
+            padded_spec, padded_prospective = _pad_version(
+                split_spec, shortened_prospective
+            )
+
+            return padded_prospective == padded_spec
+        else:
+            # Convert our spec string into a Version
+            spec_version = Version(spec)
+
+            # If the specifier does not have a local segment, then we want to
+            # act as if the prospective version also does not have a local
+            # segment.
+            if not spec_version.local:
+                prospective = Version(prospective.public)
+
+            return prospective == spec_version
+
+    @_require_version_compare
+    def _compare_not_equal(self, prospective, spec):
+        # type: (ParsedVersion, str) -> bool
+        return not self._compare_equal(prospective, spec)
+
+    @_require_version_compare
+    def _compare_less_than_equal(self, prospective, spec):
+        # type: (ParsedVersion, str) -> bool
+
+        # NB: Local version identifiers are NOT permitted in the version
+        # specifier, so local version labels can be universally removed from
+        # the prospective version.
+        return Version(prospective.public) <= Version(spec)
+
+    @_require_version_compare
+    def _compare_greater_than_equal(self, prospective, spec):
+        # type: (ParsedVersion, str) -> bool
+
+        # NB: Local version identifiers are NOT permitted in the version
+        # specifier, so local version labels can be universally removed from
+        # the prospective version.
+        return Version(prospective.public) >= Version(spec)
+
+    @_require_version_compare
+    def _compare_less_than(self, prospective, spec_str):
+        # type: (ParsedVersion, str) -> bool
+
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
+        spec = Version(spec_str)
+
+        # Check to see if the prospective version is less than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective < spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a pre-release version, that we do not accept pre-release
+        # versions for the version mentioned in the specifier (e.g. <3.1 should
+        # not match 3.1.dev0, but should match 3.0.dev0).
+        if not spec.is_prerelease and prospective.is_prerelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # less than the spec version *and* it's not a pre-release of the same
+        # version in the spec.
+        return True
+
+    @_require_version_compare
+    def _compare_greater_than(self, prospective, spec_str):
+        # type: (ParsedVersion, str) -> bool
+
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
+        spec = Version(spec_str)
+
+        # Check to see if the prospective version is greater than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective > spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a post-release version, that we do not accept
+        # post-release versions for the version mentioned in the specifier
+        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
+        if not spec.is_postrelease and prospective.is_postrelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # Ensure that we do not allow a local version of the version mentioned
+        # in the specifier, which is technically greater than, to match.
+        if prospective.local is not None:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # greater than the spec version *and* it's not a pre-release of the
+        # same version in the spec.
+        return True
+
+    def _compare_arbitrary(self, prospective, spec):
+        # type: (Version, str) -> bool
+        return str(prospective).lower() == str(spec).lower()
+
+    @property
+    def prereleases(self):
+        # type: () -> bool
+
+        # If there is an explicit prereleases set for this, then we'll just
+        # blindly use that.
+        if self._prereleases is not None:
+            return self._prereleases
+
+        # Look at all of our specifiers and determine if they are inclusive
+        # operators, and if they are if they are including an explicit
+        # prerelease.
+        operator, version = self._spec
+        if operator in ["==", ">=", "<=", "~=", "==="]:
+            # The == specifier can include a trailing .*, if it does we
+            # want to remove before parsing.
+            if operator == "==" and version.endswith(".*"):
+                version = version[:-2]
+
+            # Parse the version, and if it is a pre-release than this
+            # specifier allows pre-releases.
+            if parse(version).is_prerelease:
+                return True
+
+        return False
+
+    @prereleases.setter
+    def prereleases(self, value):
+        # type: (bool) -> None
+        self._prereleases = value
+
+
+_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
+
+
+def _version_split(version):
+    # type: (str) -> List[str]
+    result = []  # type: List[str]
+    for item in version.split("."):
+        match = _prefix_regex.search(item)
+        if match:
+            result.extend(match.groups())
+        else:
+            result.append(item)
+    return result
+
+
+def _pad_version(left, right):
+    # type: (List[str], List[str]) -> Tuple[List[str], List[str]]
+    left_split, right_split = [], []
+
+    # Get the release segment of our versions
+    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
+    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
+
+    # Get the rest of our versions
+    left_split.append(left[len(left_split[0]) :])
+    right_split.append(right[len(right_split[0]) :])
+
+    # Insert our padding
+    left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0])))
+    right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0])))
+
+    return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split)))
+
+
+class SpecifierSet(BaseSpecifier):
+    def __init__(self, specifiers="", prereleases=None):
+        # type: (str, Optional[bool]) -> None
+
+        # Split on , to break each individual specifier into it's own item, and
+        # strip each item to remove leading/trailing whitespace.
+        split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
+
+        # Parsed each individual specifier, attempting first to make it a
+        # Specifier and falling back to a LegacySpecifier.
+        parsed = set()
+        for specifier in split_specifiers:
+            try:
+                parsed.add(Specifier(specifier))
+            except InvalidSpecifier:
+                parsed.add(LegacySpecifier(specifier))
+
+        # Turn our parsed specifiers into a frozen set and save them for later.
+        self._specs = frozenset(parsed)
+
+        # Store our prereleases value so we can use it later to determine if
+        # we accept prereleases or not.
+        self._prereleases = prereleases
+
+    def __repr__(self):
+        # type: () -> str
+        pre = (
+            ", prereleases={0!r}".format(self.prereleases)
+            if self._prereleases is not None
+            else ""
+        )
+
+        return "<SpecifierSet({0!r}{1})>".format(str(self), pre)
+
+    def __str__(self):
+        # type: () -> str
+        return ",".join(sorted(str(s) for s in self._specs))
+
+    def __hash__(self):
+        # type: () -> int
+        return hash(self._specs)
+
+    def __and__(self, other):
+        # type: (Union[SpecifierSet, str]) -> SpecifierSet
+        if isinstance(other, string_types):
+            other = SpecifierSet(other)
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        specifier = SpecifierSet()
+        specifier._specs = frozenset(self._specs | other._specs)
+
+        if self._prereleases is None and other._prereleases is not None:
+            specifier._prereleases = other._prereleases
+        elif self._prereleases is not None and other._prereleases is None:
+            specifier._prereleases = self._prereleases
+        elif self._prereleases == other._prereleases:
+            specifier._prereleases = self._prereleases
+        else:
+            raise ValueError(
+                "Cannot combine SpecifierSets with True and False prerelease "
+                "overrides."
+            )
+
+        return specifier
+
+    def __eq__(self, other):
+        # type: (object) -> bool
+        if isinstance(other, (string_types, _IndividualSpecifier)):
+            other = SpecifierSet(str(other))
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        return self._specs == other._specs
+
+    def __ne__(self, other):
+        # type: (object) -> bool
+        if isinstance(other, (string_types, _IndividualSpecifier)):
+            other = SpecifierSet(str(other))
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        return self._specs != other._specs
+
+    def __len__(self):
+        # type: () -> int
+        return len(self._specs)
+
+    def __iter__(self):
+        # type: () -> Iterator[FrozenSet[_IndividualSpecifier]]
+        return iter(self._specs)
+
+    @property
+    def prereleases(self):
+        # type: () -> Optional[bool]
+
+        # If we have been given an explicit prerelease modifier, then we'll
+        # pass that through here.
+        if self._prereleases is not None:
+            return self._prereleases
+
+        # If we don't have any specifiers, and we don't have a forced value,
+        # then we'll just return None since we don't know if this should have
+        # pre-releases or not.
+        if not self._specs:
+            return None
+
+        # Otherwise we'll see if any of the given specifiers accept
+        # prereleases, if any of them do we'll return True, otherwise False.
+        return any(s.prereleases for s in self._specs)
+
+    @prereleases.setter
+    def prereleases(self, value):
+        # type: (bool) -> None
+        self._prereleases = value
+
+    def __contains__(self, item):
+        # type: (Union[ParsedVersion, str]) -> bool
+        return self.contains(item)
+
+    def contains(self, item, prereleases=None):
+        # type: (Union[ParsedVersion, str], Optional[bool]) -> bool
+
+        # Ensure that our item is a Version or LegacyVersion instance.
+        if not isinstance(item, (LegacyVersion, Version)):
+            item = parse(item)
+
+        # Determine if we're forcing a prerelease or not, if we're not forcing
+        # one for this particular filter call, then we'll use whatever the
+        # SpecifierSet thinks for whether or not we should support prereleases.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # We can determine if we're going to allow pre-releases by looking to
+        # see if any of the underlying items supports them. If none of them do
+        # and this item is a pre-release then we do not allow it and we can
+        # short circuit that here.
+        # Note: This means that 1.0.dev1 would not be contained in something
+        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
+        if not prereleases and item.is_prerelease:
+            return False
+
+        # We simply dispatch to the underlying specs here to make sure that the
+        # given version is contained within all of them.
+        # Note: This use of all() here means that an empty set of specifiers
+        #       will always return True, this is an explicit design decision.
+        return all(s.contains(item, prereleases=prereleases) for s in self._specs)
+
+    def filter(
+        self,
+        iterable,  # type: Iterable[Union[ParsedVersion, str]]
+        prereleases=None,  # type: Optional[bool]
+    ):
+        # type: (...) -> Iterable[Union[ParsedVersion, str]]
+
+        # Determine if we're forcing a prerelease or not, if we're not forcing
+        # one for this particular filter call, then we'll use whatever the
+        # SpecifierSet thinks for whether or not we should support prereleases.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # If we have any specifiers, then we want to wrap our iterable in the
+        # filter method for each one, this will act as a logical AND amongst
+        # each specifier.
+        if self._specs:
+            for spec in self._specs:
+                iterable = spec.filter(iterable, prereleases=bool(prereleases))
+            return iterable
+        # If we do not have any specifiers, then we need to have a rough filter
+        # which will filter out any pre-releases, unless there are no final
+        # releases, and which will filter out LegacyVersion in general.
+        else:
+            filtered = []  # type: List[Union[ParsedVersion, str]]
+            found_prereleases = []  # type: List[Union[ParsedVersion, str]]
+
+            for item in iterable:
+                # Ensure that we some kind of Version class for this item.
+                if not isinstance(item, (LegacyVersion, Version)):
+                    parsed_version = parse(item)
+                else:
+                    parsed_version = item
+
+                # Filter out any item which is parsed as a LegacyVersion
+                if isinstance(parsed_version, LegacyVersion):
+                    continue
+
+                # Store any item which is a pre-release for later unless we've
+                # already found a final version or we are accepting prereleases
+                if parsed_version.is_prerelease and not prereleases:
+                    if not filtered:
+                        found_prereleases.append(item)
+                else:
+                    filtered.append(item)
+
+            # If we've found no items except for pre-releases, then we'll go
+            # ahead and use the pre-releases
+            if not filtered and found_prereleases and prereleases is None:
+                return found_prereleases
+
+            return filtered
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/tags.py b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/tags.py
new file mode 100644
index 0000000..9064910
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/tags.py
@@ -0,0 +1,751 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import absolute_import
+
+import distutils.util
+
+try:
+    from importlib.machinery import EXTENSION_SUFFIXES
+except ImportError:  # pragma: no cover
+    import imp
+
+    EXTENSION_SUFFIXES = [x[0] for x in imp.get_suffixes()]
+    del imp
+import logging
+import os
+import platform
+import re
+import struct
+import sys
+import sysconfig
+import warnings
+
+from ._typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:  # pragma: no cover
+    from typing import (
+        Dict,
+        FrozenSet,
+        IO,
+        Iterable,
+        Iterator,
+        List,
+        Optional,
+        Sequence,
+        Tuple,
+        Union,
+    )
+
+    PythonVersion = Sequence[int]
+    MacVersion = Tuple[int, int]
+    GlibcVersion = Tuple[int, int]
+
+
+logger = logging.getLogger(__name__)
+
+INTERPRETER_SHORT_NAMES = {
+    "python": "py",  # Generic.
+    "cpython": "cp",
+    "pypy": "pp",
+    "ironpython": "ip",
+    "jython": "jy",
+}  # type: Dict[str, str]
+
+
+_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32
+
+
+class Tag(object):
+    """
+    A representation of the tag triple for a wheel.
+
+    Instances are considered immutable and thus are hashable. Equality checking
+    is also supported.
+    """
+
+    __slots__ = ["_interpreter", "_abi", "_platform"]
+
+    def __init__(self, interpreter, abi, platform):
+        # type: (str, str, str) -> None
+        self._interpreter = interpreter.lower()
+        self._abi = abi.lower()
+        self._platform = platform.lower()
+
+    @property
+    def interpreter(self):
+        # type: () -> str
+        return self._interpreter
+
+    @property
+    def abi(self):
+        # type: () -> str
+        return self._abi
+
+    @property
+    def platform(self):
+        # type: () -> str
+        return self._platform
+
+    def __eq__(self, other):
+        # type: (object) -> bool
+        if not isinstance(other, Tag):
+            return NotImplemented
+
+        return (
+            (self.platform == other.platform)
+            and (self.abi == other.abi)
+            and (self.interpreter == other.interpreter)
+        )
+
+    def __hash__(self):
+        # type: () -> int
+        return hash((self._interpreter, self._abi, self._platform))
+
+    def __str__(self):
+        # type: () -> str
+        return "{}-{}-{}".format(self._interpreter, self._abi, self._platform)
+
+    def __repr__(self):
+        # type: () -> str
+        return "<{self} @ {self_id}>".format(self=self, self_id=id(self))
+
+
+def parse_tag(tag):
+    # type: (str) -> FrozenSet[Tag]
+    """
+    Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances.
+
+    Returning a set is required due to the possibility that the tag is a
+    compressed tag set.
+    """
+    tags = set()
+    interpreters, abis, platforms = tag.split("-")
+    for interpreter in interpreters.split("."):
+        for abi in abis.split("."):
+            for platform_ in platforms.split("."):
+                tags.add(Tag(interpreter, abi, platform_))
+    return frozenset(tags)
+
+
+def _warn_keyword_parameter(func_name, kwargs):
+    # type: (str, Dict[str, bool]) -> bool
+    """
+    Backwards-compatibility with Python 2.7 to allow treating 'warn' as keyword-only.
+    """
+    if not kwargs:
+        return False
+    elif len(kwargs) > 1 or "warn" not in kwargs:
+        kwargs.pop("warn", None)
+        arg = next(iter(kwargs.keys()))
+        raise TypeError(
+            "{}() got an unexpected keyword argument {!r}".format(func_name, arg)
+        )
+    return kwargs["warn"]
+
+
+def _get_config_var(name, warn=False):
+    # type: (str, bool) -> Union[int, str, None]
+    value = sysconfig.get_config_var(name)
+    if value is None and warn:
+        logger.debug(
+            "Config variable '%s' is unset, Python ABI tag may be incorrect", name
+        )
+    return value
+
+
+def _normalize_string(string):
+    # type: (str) -> str
+    return string.replace(".", "_").replace("-", "_")
+
+
+def _abi3_applies(python_version):
+    # type: (PythonVersion) -> bool
+    """
+    Determine if the Python version supports abi3.
+
+    PEP 384 was first implemented in Python 3.2.
+    """
+    return len(python_version) > 1 and tuple(python_version) >= (3, 2)
+
+
+def _cpython_abis(py_version, warn=False):
+    # type: (PythonVersion, bool) -> List[str]
+    py_version = tuple(py_version)  # To allow for version comparison.
+    abis = []
+    version = _version_nodot(py_version[:2])
+    debug = pymalloc = ucs4 = ""
+    with_debug = _get_config_var("Py_DEBUG", warn)
+    has_refcount = hasattr(sys, "gettotalrefcount")
+    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
+    # extension modules is the best option.
+    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692
+    has_ext = "_d.pyd" in EXTENSION_SUFFIXES
+    if with_debug or (with_debug is None and (has_refcount or has_ext)):
+        debug = "d"
+    if py_version < (3, 8):
+        with_pymalloc = _get_config_var("WITH_PYMALLOC", warn)
+        if with_pymalloc or with_pymalloc is None:
+            pymalloc = "m"
+        if py_version < (3, 3):
+            unicode_size = _get_config_var("Py_UNICODE_SIZE", warn)
+            if unicode_size == 4 or (
+                unicode_size is None and sys.maxunicode == 0x10FFFF
+            ):
+                ucs4 = "u"
+    elif debug:
+        # Debug builds can also load "normal" extension modules.
+        # We can also assume no UCS-4 or pymalloc requirement.
+        abis.append("cp{version}".format(version=version))
+    abis.insert(
+        0,
+        "cp{version}{debug}{pymalloc}{ucs4}".format(
+            version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4
+        ),
+    )
+    return abis
+
+
+def cpython_tags(
+    python_version=None,  # type: Optional[PythonVersion]
+    abis=None,  # type: Optional[Iterable[str]]
+    platforms=None,  # type: Optional[Iterable[str]]
+    **kwargs  # type: bool
+):
+    # type: (...) -> Iterator[Tag]
+    """
+    Yields the tags for a CPython interpreter.
+
+    The tags consist of:
+    - cp<python_version>-<abi>-<platform>
+    - cp<python_version>-abi3-<platform>
+    - cp<python_version>-none-<platform>
+    - cp<less than python_version>-abi3-<platform>  # Older Python versions down to 3.2.
+
+    If python_version only specifies a major version then user-provided ABIs and
+    the 'none' ABItag will be used.
+
+    If 'abi3' or 'none' are specified in 'abis' then they will be yielded at
+    their normal position and not at the beginning.
+    """
+    warn = _warn_keyword_parameter("cpython_tags", kwargs)
+    if not python_version:
+        python_version = sys.version_info[:2]
+
+    interpreter = "cp{}".format(_version_nodot(python_version[:2]))
+
+    if abis is None:
+        if len(python_version) > 1:
+            abis = _cpython_abis(python_version, warn)
+        else:
+            abis = []
+    abis = list(abis)
+    # 'abi3' and 'none' are explicitly handled later.
+    for explicit_abi in ("abi3", "none"):
+        try:
+            abis.remove(explicit_abi)
+        except ValueError:
+            pass
+
+    platforms = list(platforms or _platform_tags())
+    for abi in abis:
+        for platform_ in platforms:
+            yield Tag(interpreter, abi, platform_)
+    if _abi3_applies(python_version):
+        for tag in (Tag(interpreter, "abi3", platform_) for platform_ in platforms):
+            yield tag
+    for tag in (Tag(interpreter, "none", platform_) for platform_ in platforms):
+        yield tag
+
+    if _abi3_applies(python_version):
+        for minor_version in range(python_version[1] - 1, 1, -1):
+            for platform_ in platforms:
+                interpreter = "cp{version}".format(
+                    version=_version_nodot((python_version[0], minor_version))
+                )
+                yield Tag(interpreter, "abi3", platform_)
+
+
+def _generic_abi():
+    # type: () -> Iterator[str]
+    abi = sysconfig.get_config_var("SOABI")
+    if abi:
+        yield _normalize_string(abi)
+
+
+def generic_tags(
+    interpreter=None,  # type: Optional[str]
+    abis=None,  # type: Optional[Iterable[str]]
+    platforms=None,  # type: Optional[Iterable[str]]
+    **kwargs  # type: bool
+):
+    # type: (...) -> Iterator[Tag]
+    """
+    Yields the tags for a generic interpreter.
+
+    The tags consist of:
+    - <interpreter>-<abi>-<platform>
+
+    The "none" ABI will be added if it was not explicitly provided.
+    """
+    warn = _warn_keyword_parameter("generic_tags", kwargs)
+    if not interpreter:
+        interp_name = interpreter_name()
+        interp_version = interpreter_version(warn=warn)
+        interpreter = "".join([interp_name, interp_version])
+    if abis is None:
+        abis = _generic_abi()
+    platforms = list(platforms or _platform_tags())
+    abis = list(abis)
+    if "none" not in abis:
+        abis.append("none")
+    for abi in abis:
+        for platform_ in platforms:
+            yield Tag(interpreter, abi, platform_)
+
+
+def _py_interpreter_range(py_version):
+    # type: (PythonVersion) -> Iterator[str]
+    """
+    Yields Python versions in descending order.
+
+    After the latest version, the major-only version will be yielded, and then
+    all previous versions of that major version.
+    """
+    if len(py_version) > 1:
+        yield "py{version}".format(version=_version_nodot(py_version[:2]))
+    yield "py{major}".format(major=py_version[0])
+    if len(py_version) > 1:
+        for minor in range(py_version[1] - 1, -1, -1):
+            yield "py{version}".format(version=_version_nodot((py_version[0], minor)))
+
+
+def compatible_tags(
+    python_version=None,  # type: Optional[PythonVersion]
+    interpreter=None,  # type: Optional[str]
+    platforms=None,  # type: Optional[Iterable[str]]
+):
+    # type: (...) -> Iterator[Tag]
+    """
+    Yields the sequence of tags that are compatible with a specific version of Python.
+
+    The tags consist of:
+    - py*-none-<platform>
+    - <interpreter>-none-any  # ... if `interpreter` is provided.
+    - py*-none-any
+    """
+    if not python_version:
+        python_version = sys.version_info[:2]
+    platforms = list(platforms or _platform_tags())
+    for version in _py_interpreter_range(python_version):
+        for platform_ in platforms:
+            yield Tag(version, "none", platform_)
+    if interpreter:
+        yield Tag(interpreter, "none", "any")
+    for version in _py_interpreter_range(python_version):
+        yield Tag(version, "none", "any")
+
+
+def _mac_arch(arch, is_32bit=_32_BIT_INTERPRETER):
+    # type: (str, bool) -> str
+    if not is_32bit:
+        return arch
+
+    if arch.startswith("ppc"):
+        return "ppc"
+
+    return "i386"
+
+
+def _mac_binary_formats(version, cpu_arch):
+    # type: (MacVersion, str) -> List[str]
+    formats = [cpu_arch]
+    if cpu_arch == "x86_64":
+        if version < (10, 4):
+            return []
+        formats.extend(["intel", "fat64", "fat32"])
+
+    elif cpu_arch == "i386":
+        if version < (10, 4):
+            return []
+        formats.extend(["intel", "fat32", "fat"])
+
+    elif cpu_arch == "ppc64":
+        # TODO: Need to care about 32-bit PPC for ppc64 through 10.2?
+        if version > (10, 5) or version < (10, 4):
+            return []
+        formats.append("fat64")
+
+    elif cpu_arch == "ppc":
+        if version > (10, 6):
+            return []
+        formats.extend(["fat32", "fat"])
+
+    formats.append("universal")
+    return formats
+
+
+def mac_platforms(version=None, arch=None):
+    # type: (Optional[MacVersion], Optional[str]) -> Iterator[str]
+    """
+    Yields the platform tags for a macOS system.
+
+    The `version` parameter is a two-item tuple specifying the macOS version to
+    generate platform tags for. The `arch` parameter is the CPU architecture to
+    generate platform tags for. Both parameters default to the appropriate value
+    for the current system.
+    """
+    version_str, _, cpu_arch = platform.mac_ver()  # type: ignore
+    if version is None:
+        version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2])))
+    else:
+        version = version
+    if arch is None:
+        arch = _mac_arch(cpu_arch)
+    else:
+        arch = arch
+    for minor_version in range(version[1], -1, -1):
+        compat_version = version[0], minor_version
+        binary_formats = _mac_binary_formats(compat_version, arch)
+        for binary_format in binary_formats:
+            yield "macosx_{major}_{minor}_{binary_format}".format(
+                major=compat_version[0],
+                minor=compat_version[1],
+                binary_format=binary_format,
+            )
+
+
+# From PEP 513.
+def _is_manylinux_compatible(name, glibc_version):
+    # type: (str, GlibcVersion) -> bool
+    # Check for presence of _manylinux module.
+    try:
+        import _manylinux  # noqa
+
+        return bool(getattr(_manylinux, name + "_compatible"))
+    except (ImportError, AttributeError):
+        # Fall through to heuristic check below.
+        pass
+
+    return _have_compatible_glibc(*glibc_version)
+
+
+def _glibc_version_string():
+    # type: () -> Optional[str]
+    # Returns glibc version string, or None if not using glibc.
+    return _glibc_version_string_confstr() or _glibc_version_string_ctypes()
+
+
+def _glibc_version_string_confstr():
+    # type: () -> Optional[str]
+    """
+    Primary implementation of glibc_version_string using os.confstr.
+    """
+    # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely
+    # to be broken or missing. This strategy is used in the standard library
+    # platform module.
+    # https://github.com/python/cpython/blob/fcf1d003bf4f0100c9d0921ff3d70e1127ca1b71/Lib/platform.py#L175-L183
+    try:
+        # os.confstr("CS_GNU_LIBC_VERSION") returns a string like "glibc 2.17".
+        version_string = os.confstr(  # type: ignore[attr-defined] # noqa: F821
+            "CS_GNU_LIBC_VERSION"
+        )
+        assert version_string is not None
+        _, version = version_string.split()  # type: Tuple[str, str]
+    except (AssertionError, AttributeError, OSError, ValueError):
+        # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)...
+        return None
+    return version
+
+
+def _glibc_version_string_ctypes():
+    # type: () -> Optional[str]
+    """
+    Fallback implementation of glibc_version_string using ctypes.
+    """
+    try:
+        import ctypes
+    except ImportError:
+        return None
+
+    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
+    # manpage says, "If filename is NULL, then the returned handle is for the
+    # main program". This way we can let the linker do the work to figure out
+    # which libc our process is actually using.
+    #
+    # Note: typeshed is wrong here so we are ignoring this line.
+    process_namespace = ctypes.CDLL(None)  # type: ignore
+    try:
+        gnu_get_libc_version = process_namespace.gnu_get_libc_version
+    except AttributeError:
+        # Symbol doesn't exist -> therefore, we are not linked to
+        # glibc.
+        return None
+
+    # Call gnu_get_libc_version, which returns a string like "2.5"
+    gnu_get_libc_version.restype = ctypes.c_char_p
+    version_str = gnu_get_libc_version()  # type: str
+    # py2 / py3 compatibility:
+    if not isinstance(version_str, str):
+        version_str = version_str.decode("ascii")
+
+    return version_str
+
+
+# Separated out from have_compatible_glibc for easier unit testing.
+def _check_glibc_version(version_str, required_major, minimum_minor):
+    # type: (str, int, int) -> bool
+    # Parse string and check against requested version.
+    #
+    # We use a regexp instead of str.split because we want to discard any
+    # random junk that might come after the minor version -- this might happen
+    # in patched/forked versions of glibc (e.g. Linaro's version of glibc
+    # uses version strings like "2.20-2014.11"). See gh-3588.
+    m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str)
+    if not m:
+        warnings.warn(
+            "Expected glibc version with 2 components major.minor,"
+            " got: %s" % version_str,
+            RuntimeWarning,
+        )
+        return False
+    return (
+        int(m.group("major")) == required_major
+        and int(m.group("minor")) >= minimum_minor
+    )
+
+
+def _have_compatible_glibc(required_major, minimum_minor):
+    # type: (int, int) -> bool
+    version_str = _glibc_version_string()
+    if version_str is None:
+        return False
+    return _check_glibc_version(version_str, required_major, minimum_minor)
+
+
+# Python does not provide platform information at sufficient granularity to
+# identify the architecture of the running executable in some cases, so we
+# determine it dynamically by reading the information from the running
+# process. This only applies on Linux, which uses the ELF format.
+class _ELFFileHeader(object):
+    # https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header
+    class _InvalidELFFileHeader(ValueError):
+        """
+        An invalid ELF file header was found.
+        """
+
+    ELF_MAGIC_NUMBER = 0x7F454C46
+    ELFCLASS32 = 1
+    ELFCLASS64 = 2
+    ELFDATA2LSB = 1
+    ELFDATA2MSB = 2
+    EM_386 = 3
+    EM_S390 = 22
+    EM_ARM = 40
+    EM_X86_64 = 62
+    EF_ARM_ABIMASK = 0xFF000000
+    EF_ARM_ABI_VER5 = 0x05000000
+    EF_ARM_ABI_FLOAT_HARD = 0x00000400
+
+    def __init__(self, file):
+        # type: (IO[bytes]) -> None
+        def unpack(fmt):
+            # type: (str) -> int
+            try:
+                (result,) = struct.unpack(
+                    fmt, file.read(struct.calcsize(fmt))
+                )  # type: (int, )
+            except struct.error:
+                raise _ELFFileHeader._InvalidELFFileHeader()
+            return result
+
+        self.e_ident_magic = unpack(">I")
+        if self.e_ident_magic != self.ELF_MAGIC_NUMBER:
+            raise _ELFFileHeader._InvalidELFFileHeader()
+        self.e_ident_class = unpack("B")
+        if self.e_ident_class not in {self.ELFCLASS32, self.ELFCLASS64}:
+            raise _ELFFileHeader._InvalidELFFileHeader()
+        self.e_ident_data = unpack("B")
+        if self.e_ident_data not in {self.ELFDATA2LSB, self.ELFDATA2MSB}:
+            raise _ELFFileHeader._InvalidELFFileHeader()
+        self.e_ident_version = unpack("B")
+        self.e_ident_osabi = unpack("B")
+        self.e_ident_abiversion = unpack("B")
+        self.e_ident_pad = file.read(7)
+        format_h = "<H" if self.e_ident_data == self.ELFDATA2LSB else ">H"
+        format_i = "<I" if self.e_ident_data == self.ELFDATA2LSB else ">I"
+        format_q = "<Q" if self.e_ident_data == self.ELFDATA2LSB else ">Q"
+        format_p = format_i if self.e_ident_class == self.ELFCLASS32 else format_q
+        self.e_type = unpack(format_h)
+        self.e_machine = unpack(format_h)
+        self.e_version = unpack(format_i)
+        self.e_entry = unpack(format_p)
+        self.e_phoff = unpack(format_p)
+        self.e_shoff = unpack(format_p)
+        self.e_flags = unpack(format_i)
+        self.e_ehsize = unpack(format_h)
+        self.e_phentsize = unpack(format_h)
+        self.e_phnum = unpack(format_h)
+        self.e_shentsize = unpack(format_h)
+        self.e_shnum = unpack(format_h)
+        self.e_shstrndx = unpack(format_h)
+
+
+def _get_elf_header():
+    # type: () -> Optional[_ELFFileHeader]
+    try:
+        with open(sys.executable, "rb") as f:
+            elf_header = _ELFFileHeader(f)
+    except (IOError, OSError, TypeError, _ELFFileHeader._InvalidELFFileHeader):
+        return None
+    return elf_header
+
+
+def _is_linux_armhf():
+    # type: () -> bool
+    # hard-float ABI can be detected from the ELF header of the running
+    # process
+    # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf
+    elf_header = _get_elf_header()
+    if elf_header is None:
+        return False
+    result = elf_header.e_ident_class == elf_header.ELFCLASS32
+    result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB
+    result &= elf_header.e_machine == elf_header.EM_ARM
+    result &= (
+        elf_header.e_flags & elf_header.EF_ARM_ABIMASK
+    ) == elf_header.EF_ARM_ABI_VER5
+    result &= (
+        elf_header.e_flags & elf_header.EF_ARM_ABI_FLOAT_HARD
+    ) == elf_header.EF_ARM_ABI_FLOAT_HARD
+    return result
+
+
+def _is_linux_i686():
+    # type: () -> bool
+    elf_header = _get_elf_header()
+    if elf_header is None:
+        return False
+    result = elf_header.e_ident_class == elf_header.ELFCLASS32
+    result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB
+    result &= elf_header.e_machine == elf_header.EM_386
+    return result
+
+
+def _have_compatible_manylinux_abi(arch):
+    # type: (str) -> bool
+    if arch == "armv7l":
+        return _is_linux_armhf()
+    if arch == "i686":
+        return _is_linux_i686()
+    return True
+
+
+def _linux_platforms(is_32bit=_32_BIT_INTERPRETER):
+    # type: (bool) -> Iterator[str]
+    linux = _normalize_string(distutils.util.get_platform())
+    if is_32bit:
+        if linux == "linux_x86_64":
+            linux = "linux_i686"
+        elif linux == "linux_aarch64":
+            linux = "linux_armv7l"
+    manylinux_support = []
+    _, arch = linux.split("_", 1)
+    if _have_compatible_manylinux_abi(arch):
+        if arch in {"x86_64", "i686", "aarch64", "armv7l", "ppc64", "ppc64le", "s390x"}:
+            manylinux_support.append(
+                ("manylinux2014", (2, 17))
+            )  # CentOS 7 w/ glibc 2.17 (PEP 599)
+        if arch in {"x86_64", "i686"}:
+            manylinux_support.append(
+                ("manylinux2010", (2, 12))
+            )  # CentOS 6 w/ glibc 2.12 (PEP 571)
+            manylinux_support.append(
+                ("manylinux1", (2, 5))
+            )  # CentOS 5 w/ glibc 2.5 (PEP 513)
+    manylinux_support_iter = iter(manylinux_support)
+    for name, glibc_version in manylinux_support_iter:
+        if _is_manylinux_compatible(name, glibc_version):
+            yield linux.replace("linux", name)
+            break
+    # Support for a later manylinux implies support for an earlier version.
+    for name, _ in manylinux_support_iter:
+        yield linux.replace("linux", name)
+    yield linux
+
+
+def _generic_platforms():
+    # type: () -> Iterator[str]
+    yield _normalize_string(distutils.util.get_platform())
+
+
+def _platform_tags():
+    # type: () -> Iterator[str]
+    """
+    Provides the platform tags for this installation.
+    """
+    if platform.system() == "Darwin":
+        return mac_platforms()
+    elif platform.system() == "Linux":
+        return _linux_platforms()
+    else:
+        return _generic_platforms()
+
+
+def interpreter_name():
+    # type: () -> str
+    """
+    Returns the name of the running interpreter.
+    """
+    try:
+        name = sys.implementation.name  # type: ignore
+    except AttributeError:  # pragma: no cover
+        # Python 2.7 compatibility.
+        name = platform.python_implementation().lower()
+    return INTERPRETER_SHORT_NAMES.get(name) or name
+
+
+def interpreter_version(**kwargs):
+    # type: (bool) -> str
+    """
+    Returns the version of the running interpreter.
+    """
+    warn = _warn_keyword_parameter("interpreter_version", kwargs)
+    version = _get_config_var("py_version_nodot", warn=warn)
+    if version:
+        version = str(version)
+    else:
+        version = _version_nodot(sys.version_info[:2])
+    return version
+
+
+def _version_nodot(version):
+    # type: (PythonVersion) -> str
+    if any(v >= 10 for v in version):
+        sep = "_"
+    else:
+        sep = ""
+    return sep.join(map(str, version))
+
+
+def sys_tags(**kwargs):
+    # type: (bool) -> Iterator[Tag]
+    """
+    Returns the sequence of tag triples for the running interpreter.
+
+    The order of the sequence corresponds to priority order for the
+    interpreter, from most to least important.
+    """
+    warn = _warn_keyword_parameter("sys_tags", kwargs)
+
+    interp_name = interpreter_name()
+    if interp_name == "cp":
+        for tag in cpython_tags(warn=warn):
+            yield tag
+    else:
+        for tag in generic_tags():
+            yield tag
+
+    for tag in compatible_tags():
+        yield tag
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/utils.py b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/utils.py
new file mode 100644
index 0000000..19579c1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/utils.py
@@ -0,0 +1,65 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import re
+
+from ._typing import TYPE_CHECKING, cast
+from .version import InvalidVersion, Version
+
+if TYPE_CHECKING:  # pragma: no cover
+    from typing import NewType, Union
+
+    NormalizedName = NewType("NormalizedName", str)
+
+_canonicalize_regex = re.compile(r"[-_.]+")
+
+
+def canonicalize_name(name):
+    # type: (str) -> NormalizedName
+    # This is taken from PEP 503.
+    value = _canonicalize_regex.sub("-", name).lower()
+    return cast("NormalizedName", value)
+
+
+def canonicalize_version(_version):
+    # type: (str) -> Union[Version, str]
+    """
+    This is very similar to Version.__str__, but has one subtle difference
+    with the way it handles the release segment.
+    """
+
+    try:
+        version = Version(_version)
+    except InvalidVersion:
+        # Legacy versions cannot be normalized
+        return _version
+
+    parts = []
+
+    # Epoch
+    if version.epoch != 0:
+        parts.append("{0}!".format(version.epoch))
+
+    # Release segment
+    # NB: This strips trailing '.0's to normalize
+    parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in version.release)))
+
+    # Pre-release
+    if version.pre is not None:
+        parts.append("".join(str(x) for x in version.pre))
+
+    # Post-release
+    if version.post is not None:
+        parts.append(".post{0}".format(version.post))
+
+    # Development release
+    if version.dev is not None:
+        parts.append(".dev{0}".format(version.dev))
+
+    # Local version segment
+    if version.local is not None:
+        parts.append("+{0}".format(version.local))
+
+    return "".join(parts)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/version.py b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/version.py
new file mode 100644
index 0000000..00371e8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/packaging/version.py
@@ -0,0 +1,535 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import collections
+import itertools
+import re
+
+from ._structures import Infinity, NegativeInfinity
+from ._typing import TYPE_CHECKING
+
+if TYPE_CHECKING:  # pragma: no cover
+    from typing import Callable, Iterator, List, Optional, SupportsInt, Tuple, Union
+
+    from ._structures import InfinityType, NegativeInfinityType
+
+    InfiniteTypes = Union[InfinityType, NegativeInfinityType]
+    PrePostDevType = Union[InfiniteTypes, Tuple[str, int]]
+    SubLocalType = Union[InfiniteTypes, int, str]
+    LocalType = Union[
+        NegativeInfinityType,
+        Tuple[
+            Union[
+                SubLocalType,
+                Tuple[SubLocalType, str],
+                Tuple[NegativeInfinityType, SubLocalType],
+            ],
+            ...,
+        ],
+    ]
+    CmpKey = Tuple[
+        int, Tuple[int, ...], PrePostDevType, PrePostDevType, PrePostDevType, LocalType
+    ]
+    LegacyCmpKey = Tuple[int, Tuple[str, ...]]
+    VersionComparisonMethod = Callable[
+        [Union[CmpKey, LegacyCmpKey], Union[CmpKey, LegacyCmpKey]], bool
+    ]
+
+__all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"]
+
+
+_Version = collections.namedtuple(
+    "_Version", ["epoch", "release", "dev", "pre", "post", "local"]
+)
+
+
+def parse(version):
+    # type: (str) -> Union[LegacyVersion, Version]
+    """
+    Parse the given version string and return either a :class:`Version` object
+    or a :class:`LegacyVersion` object depending on if the given version is
+    a valid PEP 440 version or a legacy version.
+    """
+    try:
+        return Version(version)
+    except InvalidVersion:
+        return LegacyVersion(version)
+
+
+class InvalidVersion(ValueError):
+    """
+    An invalid version was found, users should refer to PEP 440.
+    """
+
+
+class _BaseVersion(object):
+    _key = None  # type: Union[CmpKey, LegacyCmpKey]
+
+    def __hash__(self):
+        # type: () -> int
+        return hash(self._key)
+
+    def __lt__(self, other):
+        # type: (_BaseVersion) -> bool
+        return self._compare(other, lambda s, o: s < o)
+
+    def __le__(self, other):
+        # type: (_BaseVersion) -> bool
+        return self._compare(other, lambda s, o: s <= o)
+
+    def __eq__(self, other):
+        # type: (object) -> bool
+        return self._compare(other, lambda s, o: s == o)
+
+    def __ge__(self, other):
+        # type: (_BaseVersion) -> bool
+        return self._compare(other, lambda s, o: s >= o)
+
+    def __gt__(self, other):
+        # type: (_BaseVersion) -> bool
+        return self._compare(other, lambda s, o: s > o)
+
+    def __ne__(self, other):
+        # type: (object) -> bool
+        return self._compare(other, lambda s, o: s != o)
+
+    def _compare(self, other, method):
+        # type: (object, VersionComparisonMethod) -> Union[bool, NotImplemented]
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+
+        return method(self._key, other._key)
+
+
+class LegacyVersion(_BaseVersion):
+    def __init__(self, version):
+        # type: (str) -> None
+        self._version = str(version)
+        self._key = _legacy_cmpkey(self._version)
+
+    def __str__(self):
+        # type: () -> str
+        return self._version
+
+    def __repr__(self):
+        # type: () -> str
+        return "<LegacyVersion({0})>".format(repr(str(self)))
+
+    @property
+    def public(self):
+        # type: () -> str
+        return self._version
+
+    @property
+    def base_version(self):
+        # type: () -> str
+        return self._version
+
+    @property
+    def epoch(self):
+        # type: () -> int
+        return -1
+
+    @property
+    def release(self):
+        # type: () -> None
+        return None
+
+    @property
+    def pre(self):
+        # type: () -> None
+        return None
+
+    @property
+    def post(self):
+        # type: () -> None
+        return None
+
+    @property
+    def dev(self):
+        # type: () -> None
+        return None
+
+    @property
+    def local(self):
+        # type: () -> None
+        return None
+
+    @property
+    def is_prerelease(self):
+        # type: () -> bool
+        return False
+
+    @property
+    def is_postrelease(self):
+        # type: () -> bool
+        return False
+
+    @property
+    def is_devrelease(self):
+        # type: () -> bool
+        return False
+
+
+_legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE)
+
+_legacy_version_replacement_map = {
+    "pre": "c",
+    "preview": "c",
+    "-": "final-",
+    "rc": "c",
+    "dev": "@",
+}
+
+
+def _parse_version_parts(s):
+    # type: (str) -> Iterator[str]
+    for part in _legacy_version_component_re.split(s):
+        part = _legacy_version_replacement_map.get(part, part)
+
+        if not part or part == ".":
+            continue
+
+        if part[:1] in "0123456789":
+            # pad for numeric comparison
+            yield part.zfill(8)
+        else:
+            yield "*" + part
+
+    # ensure that alpha/beta/candidate are before final
+    yield "*final"
+
+
+def _legacy_cmpkey(version):
+    # type: (str) -> LegacyCmpKey
+
+    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
+    # greater than or equal to 0. This will effectively put the LegacyVersion,
+    # which uses the defacto standard originally implemented by setuptools,
+    # as before all PEP 440 versions.
+    epoch = -1
+
+    # This scheme is taken from pkg_resources.parse_version setuptools prior to
+    # it's adoption of the packaging library.
+    parts = []  # type: List[str]
+    for part in _parse_version_parts(version.lower()):
+        if part.startswith("*"):
+            # remove "-" before a prerelease tag
+            if part < "*final":
+                while parts and parts[-1] == "*final-":
+                    parts.pop()
+
+            # remove trailing zeros from each series of numeric parts
+            while parts and parts[-1] == "00000000":
+                parts.pop()
+
+        parts.append(part)
+
+    return epoch, tuple(parts)
+
+
+# Deliberately not anchored to the start and end of the string, to make it
+# easier for 3rd party code to reuse
+VERSION_PATTERN = r"""
+    v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
+        (?P<pre>                                          # pre-release
+            [-_\.]?
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>                                         # post release
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>                                          # dev release
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+
+
+class Version(_BaseVersion):
+
+    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    def __init__(self, version):
+        # type: (str) -> None
+
+        # Validate the version and parse it into pieces
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion("Invalid version: '{0}'".format(version))
+
+        # Store the parsed out pieces of the version
+        self._version = _Version(
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+            release=tuple(int(i) for i in match.group("release").split(".")),
+            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
+            post=_parse_letter_version(
+                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
+            ),
+            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
+            local=_parse_local_version(match.group("local")),
+        )
+
+        # Generate a key which will be used for sorting
+        self._key = _cmpkey(
+            self._version.epoch,
+            self._version.release,
+            self._version.pre,
+            self._version.post,
+            self._version.dev,
+            self._version.local,
+        )
+
+    def __repr__(self):
+        # type: () -> str
+        return "<Version({0})>".format(repr(str(self)))
+
+    def __str__(self):
+        # type: () -> str
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append("{0}!".format(self.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        # Pre-release
+        if self.pre is not None:
+            parts.append("".join(str(x) for x in self.pre))
+
+        # Post-release
+        if self.post is not None:
+            parts.append(".post{0}".format(self.post))
+
+        # Development release
+        if self.dev is not None:
+            parts.append(".dev{0}".format(self.dev))
+
+        # Local version segment
+        if self.local is not None:
+            parts.append("+{0}".format(self.local))
+
+        return "".join(parts)
+
+    @property
+    def epoch(self):
+        # type: () -> int
+        _epoch = self._version.epoch  # type: int
+        return _epoch
+
+    @property
+    def release(self):
+        # type: () -> Tuple[int, ...]
+        _release = self._version.release  # type: Tuple[int, ...]
+        return _release
+
+    @property
+    def pre(self):
+        # type: () -> Optional[Tuple[str, int]]
+        _pre = self._version.pre  # type: Optional[Tuple[str, int]]
+        return _pre
+
+    @property
+    def post(self):
+        # type: () -> Optional[Tuple[str, int]]
+        return self._version.post[1] if self._version.post else None
+
+    @property
+    def dev(self):
+        # type: () -> Optional[Tuple[str, int]]
+        return self._version.dev[1] if self._version.dev else None
+
+    @property
+    def local(self):
+        # type: () -> Optional[str]
+        if self._version.local:
+            return ".".join(str(x) for x in self._version.local)
+        else:
+            return None
+
+    @property
+    def public(self):
+        # type: () -> str
+        return str(self).split("+", 1)[0]
+
+    @property
+    def base_version(self):
+        # type: () -> str
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append("{0}!".format(self.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        return "".join(parts)
+
+    @property
+    def is_prerelease(self):
+        # type: () -> bool
+        return self.dev is not None or self.pre is not None
+
+    @property
+    def is_postrelease(self):
+        # type: () -> bool
+        return self.post is not None
+
+    @property
+    def is_devrelease(self):
+        # type: () -> bool
+        return self.dev is not None
+
+    @property
+    def major(self):
+        # type: () -> int
+        return self.release[0] if len(self.release) >= 1 else 0
+
+    @property
+    def minor(self):
+        # type: () -> int
+        return self.release[1] if len(self.release) >= 2 else 0
+
+    @property
+    def micro(self):
+        # type: () -> int
+        return self.release[2] if len(self.release) >= 3 else 0
+
+
+def _parse_letter_version(
+    letter,  # type: str
+    number,  # type: Union[str, bytes, SupportsInt]
+):
+    # type: (...) -> Optional[Tuple[str, int]]
+
+    if letter:
+        # We consider there to be an implicit 0 in a pre-release if there is
+        # not a numeral associated with it.
+        if number is None:
+            number = 0
+
+        # We normalize any letters to their lower case form
+        letter = letter.lower()
+
+        # We consider some words to be alternate spellings of other words and
+        # in those cases we want to normalize the spellings to our preferred
+        # spelling.
+        if letter == "alpha":
+            letter = "a"
+        elif letter == "beta":
+            letter = "b"
+        elif letter in ["c", "pre", "preview"]:
+            letter = "rc"
+        elif letter in ["rev", "r"]:
+            letter = "post"
+
+        return letter, int(number)
+    if not letter and number:
+        # We assume if we are given a number, but we are not given a letter
+        # then this is using the implicit post release syntax (e.g. 1.0-1)
+        letter = "post"
+
+        return letter, int(number)
+
+    return None
+
+
+_local_version_separators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local):
+    # type: (str) -> Optional[LocalType]
+    """
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+    """
+    if local is not None:
+        return tuple(
+            part.lower() if not part.isdigit() else int(part)
+            for part in _local_version_separators.split(local)
+        )
+    return None
+
+
+def _cmpkey(
+    epoch,  # type: int
+    release,  # type: Tuple[int, ...]
+    pre,  # type: Optional[Tuple[str, int]]
+    post,  # type: Optional[Tuple[str, int]]
+    dev,  # type: Optional[Tuple[str, int]]
+    local,  # type: Optional[Tuple[SubLocalType]]
+):
+    # type: (...) -> CmpKey
+
+    # When we compare a release version, we want to compare it with all of the
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now
+    # leading zeros until we come to something non zero, then take the rest
+    # re-reverse it back into the correct order and make it a tuple and use
+    # that for our sorting key.
+    _release = tuple(
+        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
+    )
+
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+    # We'll do this by abusing the pre segment, but we _only_ want to do this
+    # if there is not a pre or a post segment. If we have one of those then
+    # the normal sorting rules will handle this case correctly.
+    if pre is None and post is None and dev is not None:
+        _pre = NegativeInfinity  # type: PrePostDevType
+    # Versions without a pre-release (except as noted above) should sort after
+    # those with one.
+    elif pre is None:
+        _pre = Infinity
+    else:
+        _pre = pre
+
+    # Versions without a post segment should sort before those with one.
+    if post is None:
+        _post = NegativeInfinity  # type: PrePostDevType
+
+    else:
+        _post = post
+
+    # Versions without a development segment should sort after those with one.
+    if dev is None:
+        _dev = Infinity  # type: PrePostDevType
+
+    else:
+        _dev = dev
+
+    if local is None:
+        # Versions without a local segment should sort before those with one.
+        _local = NegativeInfinity  # type: LocalType
+    else:
+        # Versions with a local segment need that segment parsed to implement
+        # the sorting rules in PEP440.
+        # - Alpha numeric segments sort before numeric segments
+        # - Alpha numeric segments sort lexicographically
+        # - Numeric segments sort numerically
+        # - Shorter versions sort before longer versions when the prefixes
+        #   match exactly
+        _local = tuple(
+            (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
+        )
+
+    return epoch, _release, _pre, _post, _dev, _local
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/__init__.py
new file mode 100644
index 0000000..7355b68
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/__init__.py
@@ -0,0 +1,4 @@
+"""Wrappers to build Python packages using PEP 517 hooks
+"""
+
+__version__ = '0.8.2'
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/_in_process.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/_in_process.py
new file mode 100644
index 0000000..a536b03
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/_in_process.py
@@ -0,0 +1,280 @@
+"""This is invoked in a subprocess to call the build backend hooks.
+
+It expects:
+- Command line args: hook_name, control_dir
+- Environment variables:
+      PEP517_BUILD_BACKEND=entry.point:spec
+      PEP517_BACKEND_PATH=paths (separated with os.pathsep)
+- control_dir/input.json:
+  - {"kwargs": {...}}
+
+Results:
+- control_dir/output.json
+  - {"return_val": ...}
+"""
+from glob import glob
+from importlib import import_module
+import json
+import os
+import os.path
+from os.path import join as pjoin
+import re
+import shutil
+import sys
+import traceback
+
+# This file is run as a script, and `import compat` is not zip-safe, so we
+# include write_json() and read_json() from compat.py.
+#
+# Handle reading and writing JSON in UTF-8, on Python 3 and 2.
+
+if sys.version_info[0] >= 3:
+    # Python 3
+    def write_json(obj, path, **kwargs):
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(obj, f, **kwargs)
+
+    def read_json(path):
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+else:
+    # Python 2
+    def write_json(obj, path, **kwargs):
+        with open(path, 'wb') as f:
+            json.dump(obj, f, encoding='utf-8', **kwargs)
+
+    def read_json(path):
+        with open(path, 'rb') as f:
+            return json.load(f)
+
+
+class BackendUnavailable(Exception):
+    """Raised if we cannot import the backend"""
+    def __init__(self, traceback):
+        self.traceback = traceback
+
+
+class BackendInvalid(Exception):
+    """Raised if the backend is invalid"""
+    def __init__(self, message):
+        self.message = message
+
+
+class HookMissing(Exception):
+    """Raised if a hook is missing and we are not executing the fallback"""
+
+
+def contained_in(filename, directory):
+    """Test if a file is located within the given directory."""
+    filename = os.path.normcase(os.path.abspath(filename))
+    directory = os.path.normcase(os.path.abspath(directory))
+    return os.path.commonprefix([filename, directory]) == directory
+
+
+def _build_backend():
+    """Find and load the build backend"""
+    # Add in-tree backend directories to the front of sys.path.
+    backend_path = os.environ.get('PEP517_BACKEND_PATH')
+    if backend_path:
+        extra_pathitems = backend_path.split(os.pathsep)
+        sys.path[:0] = extra_pathitems
+
+    ep = os.environ['PEP517_BUILD_BACKEND']
+    mod_path, _, obj_path = ep.partition(':')
+    try:
+        obj = import_module(mod_path)
+    except ImportError:
+        raise BackendUnavailable(traceback.format_exc())
+
+    if backend_path:
+        if not any(
+            contained_in(obj.__file__, path)
+            for path in extra_pathitems
+        ):
+            raise BackendInvalid("Backend was not loaded from backend-path")
+
+    if obj_path:
+        for path_part in obj_path.split('.'):
+            obj = getattr(obj, path_part)
+    return obj
+
+
+def get_requires_for_build_wheel(config_settings):
+    """Invoke the optional get_requires_for_build_wheel hook
+
+    Returns [] if the hook is not defined.
+    """
+    backend = _build_backend()
+    try:
+        hook = backend.get_requires_for_build_wheel
+    except AttributeError:
+        return []
+    else:
+        return hook(config_settings)
+
+
+def prepare_metadata_for_build_wheel(
+        metadata_directory, config_settings, _allow_fallback):
+    """Invoke optional prepare_metadata_for_build_wheel
+
+    Implements a fallback by building a wheel if the hook isn't defined,
+    unless _allow_fallback is False in which case HookMissing is raised.
+    """
+    backend = _build_backend()
+    try:
+        hook = backend.prepare_metadata_for_build_wheel
+    except AttributeError:
+        if not _allow_fallback:
+            raise HookMissing()
+        return _get_wheel_metadata_from_wheel(backend, metadata_directory,
+                                              config_settings)
+    else:
+        return hook(metadata_directory, config_settings)
+
+
+WHEEL_BUILT_MARKER = 'PEP517_ALREADY_BUILT_WHEEL'
+
+
+def _dist_info_files(whl_zip):
+    """Identify the .dist-info folder inside a wheel ZipFile."""
+    res = []
+    for path in whl_zip.namelist():
+        m = re.match(r'[^/\\]+-[^/\\]+\.dist-info/', path)
+        if m:
+            res.append(path)
+    if res:
+        return res
+    raise Exception("No .dist-info folder found in wheel")
+
+
+def _get_wheel_metadata_from_wheel(
+        backend, metadata_directory, config_settings):
+    """Build a wheel and extract the metadata from it.
+
+    Fallback for when the build backend does not
+    define the 'get_wheel_metadata' hook.
+    """
+    from zipfile import ZipFile
+    whl_basename = backend.build_wheel(metadata_directory, config_settings)
+    with open(os.path.join(metadata_directory, WHEEL_BUILT_MARKER), 'wb'):
+        pass  # Touch marker file
+
+    whl_file = os.path.join(metadata_directory, whl_basename)
+    with ZipFile(whl_file) as zipf:
+        dist_info = _dist_info_files(zipf)
+        zipf.extractall(path=metadata_directory, members=dist_info)
+    return dist_info[0].split('/')[0]
+
+
+def _find_already_built_wheel(metadata_directory):
+    """Check for a wheel already built during the get_wheel_metadata hook.
+    """
+    if not metadata_directory:
+        return None
+    metadata_parent = os.path.dirname(metadata_directory)
+    if not os.path.isfile(pjoin(metadata_parent, WHEEL_BUILT_MARKER)):
+        return None
+
+    whl_files = glob(os.path.join(metadata_parent, '*.whl'))
+    if not whl_files:
+        print('Found wheel built marker, but no .whl files')
+        return None
+    if len(whl_files) > 1:
+        print('Found multiple .whl files; unspecified behaviour. '
+              'Will call build_wheel.')
+        return None
+
+    # Exactly one .whl file
+    return whl_files[0]
+
+
+def build_wheel(wheel_directory, config_settings, metadata_directory=None):
+    """Invoke the mandatory build_wheel hook.
+
+    If a wheel was already built in the
+    prepare_metadata_for_build_wheel fallback, this
+    will copy it rather than rebuilding the wheel.
+    """
+    prebuilt_whl = _find_already_built_wheel(metadata_directory)
+    if prebuilt_whl:
+        shutil.copy2(prebuilt_whl, wheel_directory)
+        return os.path.basename(prebuilt_whl)
+
+    return _build_backend().build_wheel(wheel_directory, config_settings,
+                                        metadata_directory)
+
+
+def get_requires_for_build_sdist(config_settings):
+    """Invoke the optional get_requires_for_build_wheel hook
+
+    Returns [] if the hook is not defined.
+    """
+    backend = _build_backend()
+    try:
+        hook = backend.get_requires_for_build_sdist
+    except AttributeError:
+        return []
+    else:
+        return hook(config_settings)
+
+
+class _DummyException(Exception):
+    """Nothing should ever raise this exception"""
+
+
+class GotUnsupportedOperation(Exception):
+    """For internal use when backend raises UnsupportedOperation"""
+    def __init__(self, traceback):
+        self.traceback = traceback
+
+
+def build_sdist(sdist_directory, config_settings):
+    """Invoke the mandatory build_sdist hook."""
+    backend = _build_backend()
+    try:
+        return backend.build_sdist(sdist_directory, config_settings)
+    except getattr(backend, 'UnsupportedOperation', _DummyException):
+        raise GotUnsupportedOperation(traceback.format_exc())
+
+
+HOOK_NAMES = {
+    'get_requires_for_build_wheel',
+    'prepare_metadata_for_build_wheel',
+    'build_wheel',
+    'get_requires_for_build_sdist',
+    'build_sdist',
+}
+
+
+def main():
+    if len(sys.argv) < 3:
+        sys.exit("Needs args: hook_name, control_dir")
+    hook_name = sys.argv[1]
+    control_dir = sys.argv[2]
+    if hook_name not in HOOK_NAMES:
+        sys.exit("Unknown hook: %s" % hook_name)
+    hook = globals()[hook_name]
+
+    hook_input = read_json(pjoin(control_dir, 'input.json'))
+
+    json_out = {'unsupported': False, 'return_val': None}
+    try:
+        json_out['return_val'] = hook(**hook_input['kwargs'])
+    except BackendUnavailable as e:
+        json_out['no_backend'] = True
+        json_out['traceback'] = e.traceback
+    except BackendInvalid as e:
+        json_out['backend_invalid'] = True
+        json_out['backend_error'] = e.message
+    except GotUnsupportedOperation as e:
+        json_out['unsupported'] = True
+        json_out['traceback'] = e.traceback
+    except HookMissing:
+        json_out['hook_missing'] = True
+
+    write_json(json_out, pjoin(control_dir, 'output.json'), indent=2)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/build.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/build.py
new file mode 100644
index 0000000..2643014
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/build.py
@@ -0,0 +1,124 @@
+"""Build a project using PEP 517 hooks.
+"""
+import argparse
+import logging
+import os
+from pip._vendor import toml
+import shutil
+
+from .envbuild import BuildEnvironment
+from .wrappers import Pep517HookCaller
+from .dirtools import tempdir, mkdir_p
+from .compat import FileNotFoundError
+
+log = logging.getLogger(__name__)
+
+
+def validate_system(system):
+    """
+    Ensure build system has the requisite fields.
+    """
+    required = {'requires', 'build-backend'}
+    if not (required <= set(system)):
+        message = "Missing required fields: {missing}".format(
+            missing=required-set(system),
+        )
+        raise ValueError(message)
+
+
+def load_system(source_dir):
+    """
+    Load the build system from a source dir (pyproject.toml).
+    """
+    pyproject = os.path.join(source_dir, 'pyproject.toml')
+    with open(pyproject) as f:
+        pyproject_data = toml.load(f)
+    return pyproject_data['build-system']
+
+
+def compat_system(source_dir):
+    """
+    Given a source dir, attempt to get a build system backend
+    and requirements from pyproject.toml. Fallback to
+    setuptools but only if the file was not found or a build
+    system was not indicated.
+    """
+    try:
+        system = load_system(source_dir)
+    except (FileNotFoundError, KeyError):
+        system = {}
+    system.setdefault(
+        'build-backend',
+        'setuptools.build_meta:__legacy__',
+    )
+    system.setdefault('requires', ['setuptools', 'wheel'])
+    return system
+
+
+def _do_build(hooks, env, dist, dest):
+    get_requires_name = 'get_requires_for_build_{dist}'.format(**locals())
+    get_requires = getattr(hooks, get_requires_name)
+    reqs = get_requires({})
+    log.info('Got build requires: %s', reqs)
+
+    env.pip_install(reqs)
+    log.info('Installed dynamic build dependencies')
+
+    with tempdir() as td:
+        log.info('Trying to build %s in %s', dist, td)
+        build_name = 'build_{dist}'.format(**locals())
+        build = getattr(hooks, build_name)
+        filename = build(td, {})
+        source = os.path.join(td, filename)
+        shutil.move(source, os.path.join(dest, os.path.basename(filename)))
+
+
+def build(source_dir, dist, dest=None, system=None):
+    system = system or load_system(source_dir)
+    dest = os.path.join(source_dir, dest or 'dist')
+    mkdir_p(dest)
+
+    validate_system(system)
+    hooks = Pep517HookCaller(
+        source_dir, system['build-backend'], system.get('backend-path')
+    )
+
+    with BuildEnvironment() as env:
+        env.pip_install(system['requires'])
+        _do_build(hooks, env, dist, dest)
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    'source_dir',
+    help="A directory containing pyproject.toml",
+)
+parser.add_argument(
+    '--binary', '-b',
+    action='store_true',
+    default=False,
+)
+parser.add_argument(
+    '--source', '-s',
+    action='store_true',
+    default=False,
+)
+parser.add_argument(
+    '--out-dir', '-o',
+    help="Destination in which to save the builds relative to source dir",
+)
+
+
+def main(args):
+    # determine which dists to build
+    dists = list(filter(None, (
+        'sdist' if args.source or not args.binary else None,
+        'wheel' if args.binary or not args.source else None,
+    )))
+
+    for dist in dists:
+        build(args.source_dir, dist, args.out_dir)
+
+
+if __name__ == '__main__':
+    main(parser.parse_args())
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/check.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/check.py
new file mode 100644
index 0000000..13e722a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/check.py
@@ -0,0 +1,203 @@
+"""Check a project and backend by attempting to build using PEP 517 hooks.
+"""
+import argparse
+import logging
+import os
+from os.path import isfile, join as pjoin
+from pip._vendor.toml import TomlDecodeError, load as toml_load
+import shutil
+from subprocess import CalledProcessError
+import sys
+import tarfile
+from tempfile import mkdtemp
+import zipfile
+
+from .colorlog import enable_colourful_output
+from .envbuild import BuildEnvironment
+from .wrappers import Pep517HookCaller
+
+log = logging.getLogger(__name__)
+
+
+def check_build_sdist(hooks, build_sys_requires):
+    with BuildEnvironment() as env:
+        try:
+            env.pip_install(build_sys_requires)
+            log.info('Installed static build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install static build dependencies')
+            return False
+
+        try:
+            reqs = hooks.get_requires_for_build_sdist({})
+            log.info('Got build requires: %s', reqs)
+        except Exception:
+            log.error('Failure in get_requires_for_build_sdist', exc_info=True)
+            return False
+
+        try:
+            env.pip_install(reqs)
+            log.info('Installed dynamic build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install dynamic build dependencies')
+            return False
+
+        td = mkdtemp()
+        log.info('Trying to build sdist in %s', td)
+        try:
+            try:
+                filename = hooks.build_sdist(td, {})
+                log.info('build_sdist returned %r', filename)
+            except Exception:
+                log.info('Failure in build_sdist', exc_info=True)
+                return False
+
+            if not filename.endswith('.tar.gz'):
+                log.error(
+                    "Filename %s doesn't have .tar.gz extension", filename)
+                return False
+
+            path = pjoin(td, filename)
+            if isfile(path):
+                log.info("Output file %s exists", path)
+            else:
+                log.error("Output file %s does not exist", path)
+                return False
+
+            if tarfile.is_tarfile(path):
+                log.info("Output file is a tar file")
+            else:
+                log.error("Output file is not a tar file")
+                return False
+
+        finally:
+            shutil.rmtree(td)
+
+        return True
+
+
+def check_build_wheel(hooks, build_sys_requires):
+    with BuildEnvironment() as env:
+        try:
+            env.pip_install(build_sys_requires)
+            log.info('Installed static build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install static build dependencies')
+            return False
+
+        try:
+            reqs = hooks.get_requires_for_build_wheel({})
+            log.info('Got build requires: %s', reqs)
+        except Exception:
+            log.error('Failure in get_requires_for_build_sdist', exc_info=True)
+            return False
+
+        try:
+            env.pip_install(reqs)
+            log.info('Installed dynamic build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install dynamic build dependencies')
+            return False
+
+        td = mkdtemp()
+        log.info('Trying to build wheel in %s', td)
+        try:
+            try:
+                filename = hooks.build_wheel(td, {})
+                log.info('build_wheel returned %r', filename)
+            except Exception:
+                log.info('Failure in build_wheel', exc_info=True)
+                return False
+
+            if not filename.endswith('.whl'):
+                log.error("Filename %s doesn't have .whl extension", filename)
+                return False
+
+            path = pjoin(td, filename)
+            if isfile(path):
+                log.info("Output file %s exists", path)
+            else:
+                log.error("Output file %s does not exist", path)
+                return False
+
+            if zipfile.is_zipfile(path):
+                log.info("Output file is a zip file")
+            else:
+                log.error("Output file is not a zip file")
+                return False
+
+        finally:
+            shutil.rmtree(td)
+
+        return True
+
+
+def check(source_dir):
+    pyproject = pjoin(source_dir, 'pyproject.toml')
+    if isfile(pyproject):
+        log.info('Found pyproject.toml')
+    else:
+        log.error('Missing pyproject.toml')
+        return False
+
+    try:
+        with open(pyproject) as f:
+            pyproject_data = toml_load(f)
+        # Ensure the mandatory data can be loaded
+        buildsys = pyproject_data['build-system']
+        requires = buildsys['requires']
+        backend = buildsys['build-backend']
+        backend_path = buildsys.get('backend-path')
+        log.info('Loaded pyproject.toml')
+    except (TomlDecodeError, KeyError):
+        log.error("Invalid pyproject.toml", exc_info=True)
+        return False
+
+    hooks = Pep517HookCaller(source_dir, backend, backend_path)
+
+    sdist_ok = check_build_sdist(hooks, requires)
+    wheel_ok = check_build_wheel(hooks, requires)
+
+    if not sdist_ok:
+        log.warning('Sdist checks failed; scroll up to see')
+    if not wheel_ok:
+        log.warning('Wheel checks failed')
+
+    return sdist_ok
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        'source_dir',
+        help="A directory containing pyproject.toml")
+    args = ap.parse_args(argv)
+
+    enable_colourful_output()
+
+    ok = check(args.source_dir)
+
+    if ok:
+        print(ansi('Checks passed', 'green'))
+    else:
+        print(ansi('Checks failed', 'red'))
+        sys.exit(1)
+
+
+ansi_codes = {
+    'reset': '\x1b[0m',
+    'bold': '\x1b[1m',
+    'red': '\x1b[31m',
+    'green': '\x1b[32m',
+}
+
+
+def ansi(s, attr):
+    if os.name != 'nt' and sys.stdout.isatty():
+        return ansi_codes[attr] + str(s) + ansi_codes['reset']
+    else:
+        return str(s)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/colorlog.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/colorlog.py
new file mode 100644
index 0000000..69c8a59
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/colorlog.py
@@ -0,0 +1,115 @@
+"""Nicer log formatting with colours.
+
+Code copied from Tornado, Apache licensed.
+"""
+# Copyright 2012 Facebook
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import logging
+import sys
+
+try:
+    import curses
+except ImportError:
+    curses = None
+
+
+def _stderr_supports_color():
+    color = False
+    if curses and hasattr(sys.stderr, 'isatty') and sys.stderr.isatty():
+        try:
+            curses.setupterm()
+            if curses.tigetnum("colors") > 0:
+                color = True
+        except Exception:
+            pass
+    return color
+
+
+class LogFormatter(logging.Formatter):
+    """Log formatter with colour support
+    """
+    DEFAULT_COLORS = {
+        logging.INFO: 2,  # Green
+        logging.WARNING: 3,  # Yellow
+        logging.ERROR: 1,  # Red
+        logging.CRITICAL: 1,
+    }
+
+    def __init__(self, color=True, datefmt=None):
+        r"""
+        :arg bool color: Enables color support.
+        :arg string fmt: Log message format.
+        It will be applied to the attributes dict of log records. The
+        text between ``%(color)s`` and ``%(end_color)s`` will be colored
+        depending on the level if color support is on.
+        :arg dict colors: color mappings from logging level to terminal color
+        code
+        :arg string datefmt: Datetime format.
+        Used for formatting ``(asctime)`` placeholder in ``prefix_fmt``.
+        .. versionchanged:: 3.2
+        Added ``fmt`` and ``datefmt`` arguments.
+        """
+        logging.Formatter.__init__(self, datefmt=datefmt)
+        self._colors = {}
+        if color and _stderr_supports_color():
+            # The curses module has some str/bytes confusion in
+            # python3. Until version 3.2.3, most methods return
+            # bytes, but only accept strings. In addition, we want to
+            # output these strings with the logging module, which
+            # works with unicode strings. The explicit calls to
+            # unicode() below are harmless in python2 but will do the
+            # right conversion in python 3.
+            fg_color = (curses.tigetstr("setaf") or
+                        curses.tigetstr("setf") or "")
+            if (3, 0) < sys.version_info < (3, 2, 3):
+                fg_color = str(fg_color, "ascii")
+
+            for levelno, code in self.DEFAULT_COLORS.items():
+                self._colors[levelno] = str(
+                    curses.tparm(fg_color, code), "ascii")
+            self._normal = str(curses.tigetstr("sgr0"), "ascii")
+
+            scr = curses.initscr()
+            self.termwidth = scr.getmaxyx()[1]
+            curses.endwin()
+        else:
+            self._normal = ''
+            # Default width is usually 80, but too wide is
+            # worse than too narrow
+            self.termwidth = 70
+
+    def formatMessage(self, record):
+        mlen = len(record.message)
+        right_text = '{initial}-{name}'.format(initial=record.levelname[0],
+                                               name=record.name)
+        if mlen + len(right_text) < self.termwidth:
+            space = ' ' * (self.termwidth - (mlen + len(right_text)))
+        else:
+            space = '  '
+
+        if record.levelno in self._colors:
+            start_color = self._colors[record.levelno]
+            end_color = self._normal
+        else:
+            start_color = end_color = ''
+
+        return record.message + space + start_color + right_text + end_color
+
+
+def enable_colourful_output(level=logging.INFO):
+    handler = logging.StreamHandler()
+    handler.setFormatter(LogFormatter())
+    logging.root.addHandler(handler)
+    logging.root.setLevel(level)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/compat.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/compat.py
new file mode 100644
index 0000000..8432acb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/compat.py
@@ -0,0 +1,34 @@
+"""Python 2/3 compatibility"""
+import json
+import sys
+
+
+# Handle reading and writing JSON in UTF-8, on Python 3 and 2.
+
+if sys.version_info[0] >= 3:
+    # Python 3
+    def write_json(obj, path, **kwargs):
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(obj, f, **kwargs)
+
+    def read_json(path):
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+else:
+    # Python 2
+    def write_json(obj, path, **kwargs):
+        with open(path, 'wb') as f:
+            json.dump(obj, f, encoding='utf-8', **kwargs)
+
+    def read_json(path):
+        with open(path, 'rb') as f:
+            return json.load(f)
+
+
+# FileNotFoundError
+
+try:
+    FileNotFoundError = FileNotFoundError
+except NameError:
+    FileNotFoundError = IOError
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/dirtools.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/dirtools.py
new file mode 100644
index 0000000..58c6ca0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/dirtools.py
@@ -0,0 +1,44 @@
+import os
+import io
+import contextlib
+import tempfile
+import shutil
+import errno
+import zipfile
+
+
+@contextlib.contextmanager
+def tempdir():
+    """Create a temporary directory in a context manager."""
+    td = tempfile.mkdtemp()
+    try:
+        yield td
+    finally:
+        shutil.rmtree(td)
+
+
+def mkdir_p(*args, **kwargs):
+    """Like `mkdir`, but does not raise an exception if the
+    directory already exists.
+    """
+    try:
+        return os.mkdir(*args, **kwargs)
+    except OSError as exc:
+        if exc.errno != errno.EEXIST:
+            raise
+
+
+def dir_to_zipfile(root):
+    """Construct an in-memory zip file for a directory."""
+    buffer = io.BytesIO()
+    zip_file = zipfile.ZipFile(buffer, 'w')
+    for root, dirs, files in os.walk(root):
+        for path in dirs:
+            fs_path = os.path.join(root, path)
+            rel_path = os.path.relpath(fs_path, root)
+            zip_file.writestr(rel_path + '/', '')
+        for path in files:
+            fs_path = os.path.join(root, path)
+            rel_path = os.path.relpath(fs_path, root)
+            zip_file.write(fs_path, rel_path)
+    return zip_file
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/envbuild.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/envbuild.py
new file mode 100644
index 0000000..4088dcd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/envbuild.py
@@ -0,0 +1,167 @@
+"""Build wheels/sdists by installing build deps to a temporary environment.
+"""
+
+import os
+import logging
+from pip._vendor import toml
+import shutil
+from subprocess import check_call
+import sys
+from sysconfig import get_paths
+from tempfile import mkdtemp
+
+from .wrappers import Pep517HookCaller, LoggerWrapper
+
+log = logging.getLogger(__name__)
+
+
+def _load_pyproject(source_dir):
+    with open(os.path.join(source_dir, 'pyproject.toml')) as f:
+        pyproject_data = toml.load(f)
+    buildsys = pyproject_data['build-system']
+    return (
+        buildsys['requires'],
+        buildsys['build-backend'],
+        buildsys.get('backend-path'),
+    )
+
+
+class BuildEnvironment(object):
+    """Context manager to install build deps in a simple temporary environment
+
+    Based on code I wrote for pip, which is MIT licensed.
+    """
+    # Copyright (c) 2008-2016 The pip developers (see AUTHORS.txt file)
+    #
+    # Permission is hereby granted, free of charge, to any person obtaining
+    # a copy of this software and associated documentation files (the
+    # "Software"), to deal in the Software without restriction, including
+    # without limitation the rights to use, copy, modify, merge, publish,
+    # distribute, sublicense, and/or sell copies of the Software, and to
+    # permit persons to whom the Software is furnished to do so, subject to
+    # the following conditions:
+    #
+    # The above copyright notice and this permission notice shall be
+    # included in all copies or substantial portions of the Software.
+    #
+    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+    path = None
+
+    def __init__(self, cleanup=True):
+        self._cleanup = cleanup
+
+    def __enter__(self):
+        self.path = mkdtemp(prefix='pep517-build-env-')
+        log.info('Temporary build environment: %s', self.path)
+
+        self.save_path = os.environ.get('PATH', None)
+        self.save_pythonpath = os.environ.get('PYTHONPATH', None)
+
+        install_scheme = 'nt' if (os.name == 'nt') else 'posix_prefix'
+        install_dirs = get_paths(install_scheme, vars={
+            'base': self.path,
+            'platbase': self.path,
+        })
+
+        scripts = install_dirs['scripts']
+        if self.save_path:
+            os.environ['PATH'] = scripts + os.pathsep + self.save_path
+        else:
+            os.environ['PATH'] = scripts + os.pathsep + os.defpath
+
+        if install_dirs['purelib'] == install_dirs['platlib']:
+            lib_dirs = install_dirs['purelib']
+        else:
+            lib_dirs = install_dirs['purelib'] + os.pathsep + \
+                install_dirs['platlib']
+        if self.save_pythonpath:
+            os.environ['PYTHONPATH'] = lib_dirs + os.pathsep + \
+                self.save_pythonpath
+        else:
+            os.environ['PYTHONPATH'] = lib_dirs
+
+        return self
+
+    def pip_install(self, reqs):
+        """Install dependencies into this env by calling pip in a subprocess"""
+        if not reqs:
+            return
+        log.info('Calling pip to install %s', reqs)
+        cmd = [
+            sys.executable, '-m', 'pip', 'install', '--ignore-installed',
+            '--prefix', self.path] + list(reqs)
+        check_call(
+            cmd,
+            stdout=LoggerWrapper(log, logging.INFO),
+            stderr=LoggerWrapper(log, logging.ERROR),
+        )
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        needs_cleanup = (
+            self._cleanup and
+            self.path is not None and
+            os.path.isdir(self.path)
+        )
+        if needs_cleanup:
+            shutil.rmtree(self.path)
+
+        if self.save_path is None:
+            os.environ.pop('PATH', None)
+        else:
+            os.environ['PATH'] = self.save_path
+
+        if self.save_pythonpath is None:
+            os.environ.pop('PYTHONPATH', None)
+        else:
+            os.environ['PYTHONPATH'] = self.save_pythonpath
+
+
+def build_wheel(source_dir, wheel_dir, config_settings=None):
+    """Build a wheel from a source directory using PEP 517 hooks.
+
+    :param str source_dir: Source directory containing pyproject.toml
+    :param str wheel_dir: Target directory to create wheel in
+    :param dict config_settings: Options to pass to build backend
+
+    This is a blocking function which will run pip in a subprocess to install
+    build requirements.
+    """
+    if config_settings is None:
+        config_settings = {}
+    requires, backend, backend_path = _load_pyproject(source_dir)
+    hooks = Pep517HookCaller(source_dir, backend, backend_path)
+
+    with BuildEnvironment() as env:
+        env.pip_install(requires)
+        reqs = hooks.get_requires_for_build_wheel(config_settings)
+        env.pip_install(reqs)
+        return hooks.build_wheel(wheel_dir, config_settings)
+
+
+def build_sdist(source_dir, sdist_dir, config_settings=None):
+    """Build an sdist from a source directory using PEP 517 hooks.
+
+    :param str source_dir: Source directory containing pyproject.toml
+    :param str sdist_dir: Target directory to place sdist in
+    :param dict config_settings: Options to pass to build backend
+
+    This is a blocking function which will run pip in a subprocess to install
+    build requirements.
+    """
+    if config_settings is None:
+        config_settings = {}
+    requires, backend, backend_path = _load_pyproject(source_dir)
+    hooks = Pep517HookCaller(source_dir, backend, backend_path)
+
+    with BuildEnvironment() as env:
+        env.pip_install(requires)
+        reqs = hooks.get_requires_for_build_sdist(config_settings)
+        env.pip_install(reqs)
+        return hooks.build_sdist(sdist_dir, config_settings)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/meta.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/meta.py
new file mode 100644
index 0000000..d525de5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/meta.py
@@ -0,0 +1,92 @@
+"""Build metadata for a project using PEP 517 hooks.
+"""
+import argparse
+import logging
+import os
+import shutil
+import functools
+
+try:
+    import importlib.metadata as imp_meta
+except ImportError:
+    import importlib_metadata as imp_meta
+
+try:
+    from zipfile import Path
+except ImportError:
+    from zipp import Path
+
+from .envbuild import BuildEnvironment
+from .wrappers import Pep517HookCaller, quiet_subprocess_runner
+from .dirtools import tempdir, mkdir_p, dir_to_zipfile
+from .build import validate_system, load_system, compat_system
+
+log = logging.getLogger(__name__)
+
+
+def _prep_meta(hooks, env, dest):
+    reqs = hooks.get_requires_for_build_wheel({})
+    log.info('Got build requires: %s', reqs)
+
+    env.pip_install(reqs)
+    log.info('Installed dynamic build dependencies')
+
+    with tempdir() as td:
+        log.info('Trying to build metadata in %s', td)
+        filename = hooks.prepare_metadata_for_build_wheel(td, {})
+        source = os.path.join(td, filename)
+        shutil.move(source, os.path.join(dest, os.path.basename(filename)))
+
+
+def build(source_dir='.', dest=None, system=None):
+    system = system or load_system(source_dir)
+    dest = os.path.join(source_dir, dest or 'dist')
+    mkdir_p(dest)
+    validate_system(system)
+    hooks = Pep517HookCaller(
+        source_dir, system['build-backend'], system.get('backend-path')
+    )
+
+    with hooks.subprocess_runner(quiet_subprocess_runner):
+        with BuildEnvironment() as env:
+            env.pip_install(system['requires'])
+            _prep_meta(hooks, env, dest)
+
+
+def build_as_zip(builder=build):
+    with tempdir() as out_dir:
+        builder(dest=out_dir)
+        return dir_to_zipfile(out_dir)
+
+
+def load(root):
+    """
+    Given a source directory (root) of a package,
+    return an importlib.metadata.Distribution object
+    with metadata build from that package.
+    """
+    root = os.path.expanduser(root)
+    system = compat_system(root)
+    builder = functools.partial(build, source_dir=root, system=system)
+    path = Path(build_as_zip(builder))
+    return imp_meta.PathDistribution(path)
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    'source_dir',
+    help="A directory containing pyproject.toml",
+)
+parser.add_argument(
+    '--out-dir', '-o',
+    help="Destination in which to save the builds relative to source dir",
+)
+
+
+def main():
+    args = parser.parse_args()
+    build(args.source_dir, args.out_dir)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/wrappers.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/wrappers.py
new file mode 100644
index 0000000..00a3d1a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pep517/wrappers.py
@@ -0,0 +1,308 @@
+import threading
+from contextlib import contextmanager
+import os
+from os.path import dirname, abspath, join as pjoin
+import shutil
+from subprocess import check_call, check_output, STDOUT
+import sys
+from tempfile import mkdtemp
+
+from . import compat
+
+
+try:
+    import importlib.resources as resources
+
+    def _in_proc_script_path():
+        return resources.path(__package__, '_in_process.py')
+except ImportError:
+    @contextmanager
+    def _in_proc_script_path():
+        yield pjoin(dirname(abspath(__file__)), '_in_process.py')
+
+
+@contextmanager
+def tempdir():
+    td = mkdtemp()
+    try:
+        yield td
+    finally:
+        shutil.rmtree(td)
+
+
+class BackendUnavailable(Exception):
+    """Will be raised if the backend cannot be imported in the hook process."""
+    def __init__(self, traceback):
+        self.traceback = traceback
+
+
+class BackendInvalid(Exception):
+    """Will be raised if the backend is invalid."""
+    def __init__(self, backend_name, backend_path, message):
+        self.backend_name = backend_name
+        self.backend_path = backend_path
+        self.message = message
+
+
+class HookMissing(Exception):
+    """Will be raised on missing hooks."""
+    def __init__(self, hook_name):
+        super(HookMissing, self).__init__(hook_name)
+        self.hook_name = hook_name
+
+
+class UnsupportedOperation(Exception):
+    """May be raised by build_sdist if the backend indicates that it can't."""
+    def __init__(self, traceback):
+        self.traceback = traceback
+
+
+def default_subprocess_runner(cmd, cwd=None, extra_environ=None):
+    """The default method of calling the wrapper subprocess."""
+    env = os.environ.copy()
+    if extra_environ:
+        env.update(extra_environ)
+
+    check_call(cmd, cwd=cwd, env=env)
+
+
+def quiet_subprocess_runner(cmd, cwd=None, extra_environ=None):
+    """A method of calling the wrapper subprocess while suppressing output."""
+    env = os.environ.copy()
+    if extra_environ:
+        env.update(extra_environ)
+
+    check_output(cmd, cwd=cwd, env=env, stderr=STDOUT)
+
+
+def norm_and_check(source_tree, requested):
+    """Normalise and check a backend path.
+
+    Ensure that the requested backend path is specified as a relative path,
+    and resolves to a location under the given source tree.
+
+    Return an absolute version of the requested path.
+    """
+    if os.path.isabs(requested):
+        raise ValueError("paths must be relative")
+
+    abs_source = os.path.abspath(source_tree)
+    abs_requested = os.path.normpath(os.path.join(abs_source, requested))
+    # We have to use commonprefix for Python 2.7 compatibility. So we
+    # normalise case to avoid problems because commonprefix is a character
+    # based comparison :-(
+    norm_source = os.path.normcase(abs_source)
+    norm_requested = os.path.normcase(abs_requested)
+    if os.path.commonprefix([norm_source, norm_requested]) != norm_source:
+        raise ValueError("paths must be inside source tree")
+
+    return abs_requested
+
+
+class Pep517HookCaller(object):
+    """A wrapper around a source directory to be built with a PEP 517 backend.
+
+    source_dir : The path to the source directory, containing pyproject.toml.
+    build_backend : The build backend spec, as per PEP 517, from
+        pyproject.toml.
+    backend_path : The backend path, as per PEP 517, from pyproject.toml.
+    runner : A callable that invokes the wrapper subprocess.
+
+    The 'runner', if provided, must expect the following:
+        cmd : a list of strings representing the command and arguments to
+            execute, as would be passed to e.g. 'subprocess.check_call'.
+        cwd : a string representing the working directory that must be
+            used for the subprocess. Corresponds to the provided source_dir.
+        extra_environ : a dict mapping environment variable names to values
+            which must be set for the subprocess execution.
+    """
+    def __init__(
+            self,
+            source_dir,
+            build_backend,
+            backend_path=None,
+            runner=None,
+    ):
+        if runner is None:
+            runner = default_subprocess_runner
+
+        self.source_dir = abspath(source_dir)
+        self.build_backend = build_backend
+        if backend_path:
+            backend_path = [
+                norm_and_check(self.source_dir, p) for p in backend_path
+            ]
+        self.backend_path = backend_path
+        self._subprocess_runner = runner
+
+    @contextmanager
+    def subprocess_runner(self, runner):
+        """A context manager for temporarily overriding the default subprocess
+        runner.
+        """
+        prev = self._subprocess_runner
+        self._subprocess_runner = runner
+        try:
+            yield
+        finally:
+            self._subprocess_runner = prev
+
+    def get_requires_for_build_wheel(self, config_settings=None):
+        """Identify packages required for building a wheel
+
+        Returns a list of dependency specifications, e.g.:
+            ["wheel >= 0.25", "setuptools"]
+
+        This does not include requirements specified in pyproject.toml.
+        It returns the result of calling the equivalently named hook in a
+        subprocess.
+        """
+        return self._call_hook('get_requires_for_build_wheel', {
+            'config_settings': config_settings
+        })
+
+    def prepare_metadata_for_build_wheel(
+            self, metadata_directory, config_settings=None,
+            _allow_fallback=True):
+        """Prepare a *.dist-info folder with metadata for this project.
+
+        Returns the name of the newly created folder.
+
+        If the build backend defines a hook with this name, it will be called
+        in a subprocess. If not, the backend will be asked to build a wheel,
+        and the dist-info extracted from that (unless _allow_fallback is
+        False).
+        """
+        return self._call_hook('prepare_metadata_for_build_wheel', {
+            'metadata_directory': abspath(metadata_directory),
+            'config_settings': config_settings,
+            '_allow_fallback': _allow_fallback,
+        })
+
+    def build_wheel(
+            self, wheel_directory, config_settings=None,
+            metadata_directory=None):
+        """Build a wheel from this project.
+
+        Returns the name of the newly created file.
+
+        In general, this will call the 'build_wheel' hook in the backend.
+        However, if that was previously called by
+        'prepare_metadata_for_build_wheel', and the same metadata_directory is
+        used, the previously built wheel will be copied to wheel_directory.
+        """
+        if metadata_directory is not None:
+            metadata_directory = abspath(metadata_directory)
+        return self._call_hook('build_wheel', {
+            'wheel_directory': abspath(wheel_directory),
+            'config_settings': config_settings,
+            'metadata_directory': metadata_directory,
+        })
+
+    def get_requires_for_build_sdist(self, config_settings=None):
+        """Identify packages required for building a wheel
+
+        Returns a list of dependency specifications, e.g.:
+            ["setuptools >= 26"]
+
+        This does not include requirements specified in pyproject.toml.
+        It returns the result of calling the equivalently named hook in a
+        subprocess.
+        """
+        return self._call_hook('get_requires_for_build_sdist', {
+            'config_settings': config_settings
+        })
+
+    def build_sdist(self, sdist_directory, config_settings=None):
+        """Build an sdist from this project.
+
+        Returns the name of the newly created file.
+
+        This calls the 'build_sdist' backend hook in a subprocess.
+        """
+        return self._call_hook('build_sdist', {
+            'sdist_directory': abspath(sdist_directory),
+            'config_settings': config_settings,
+        })
+
+    def _call_hook(self, hook_name, kwargs):
+        # On Python 2, pytoml returns Unicode values (which is correct) but the
+        # environment passed to check_call needs to contain string values. We
+        # convert here by encoding using ASCII (the backend can only contain
+        # letters, digits and _, . and : characters, and will be used as a
+        # Python identifier, so non-ASCII content is wrong on Python 2 in
+        # any case).
+        # For backend_path, we use sys.getfilesystemencoding.
+        if sys.version_info[0] == 2:
+            build_backend = self.build_backend.encode('ASCII')
+        else:
+            build_backend = self.build_backend
+        extra_environ = {'PEP517_BUILD_BACKEND': build_backend}
+
+        if self.backend_path:
+            backend_path = os.pathsep.join(self.backend_path)
+            if sys.version_info[0] == 2:
+                backend_path = backend_path.encode(sys.getfilesystemencoding())
+            extra_environ['PEP517_BACKEND_PATH'] = backend_path
+
+        with tempdir() as td:
+            hook_input = {'kwargs': kwargs}
+            compat.write_json(hook_input, pjoin(td, 'input.json'),
+                              indent=2)
+
+            # Run the hook in a subprocess
+            with _in_proc_script_path() as script:
+                self._subprocess_runner(
+                    [sys.executable, str(script), hook_name, td],
+                    cwd=self.source_dir,
+                    extra_environ=extra_environ
+                )
+
+            data = compat.read_json(pjoin(td, 'output.json'))
+            if data.get('unsupported'):
+                raise UnsupportedOperation(data.get('traceback', ''))
+            if data.get('no_backend'):
+                raise BackendUnavailable(data.get('traceback', ''))
+            if data.get('backend_invalid'):
+                raise BackendInvalid(
+                    backend_name=self.build_backend,
+                    backend_path=self.backend_path,
+                    message=data.get('backend_error', '')
+                )
+            if data.get('hook_missing'):
+                raise HookMissing(hook_name)
+            return data['return_val']
+
+
+class LoggerWrapper(threading.Thread):
+    """
+    Read messages from a pipe and redirect them
+    to a logger (see python's logging module).
+    """
+
+    def __init__(self, logger, level):
+        threading.Thread.__init__(self)
+        self.daemon = True
+
+        self.logger = logger
+        self.level = level
+
+        # create the pipe and reader
+        self.fd_read, self.fd_write = os.pipe()
+        self.reader = os.fdopen(self.fd_read)
+
+        self.start()
+
+    def fileno(self):
+        return self.fd_write
+
+    @staticmethod
+    def remove_newline(msg):
+        return msg[:-1] if msg.endswith(os.linesep) else msg
+
+    def run(self):
+        for line in self.reader:
+            self._write(self.remove_newline(line))
+
+    def _write(self, message):
+        self.logger.log(self.level, message)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pkg_resources/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pkg_resources/__init__.py
new file mode 100644
index 0000000..a457ff2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pkg_resources/__init__.py
@@ -0,0 +1,3296 @@
+# coding: utf-8
+"""
+Package resource API
+--------------------
+
+A resource is a logical file contained within a package, or a logical
+subdirectory thereof.  The package resource API expects resource names
+to have their path parts separated with ``/``, *not* whatever the local
+path separator is.  Do not use os.path operations to manipulate resource
+names being passed into the API.
+
+The package resource API is designed to work with normal filesystem packages,
+.egg files, and unpacked .egg files.  It can also work in a limited way with
+.zip files and with custom PEP 302 loaders that support the ``get_data()``
+method.
+"""
+
+from __future__ import absolute_import
+
+import sys
+import os
+import io
+import time
+import re
+import types
+import zipfile
+import zipimport
+import warnings
+import stat
+import functools
+import pkgutil
+import operator
+import platform
+import collections
+import plistlib
+import email.parser
+import errno
+import tempfile
+import textwrap
+import itertools
+import inspect
+import ntpath
+import posixpath
+from pkgutil import get_importer
+
+try:
+    import _imp
+except ImportError:
+    # Python 3.2 compatibility
+    import imp as _imp
+
+try:
+    FileExistsError
+except NameError:
+    FileExistsError = OSError
+
+from pip._vendor import six
+from pip._vendor.six.moves import urllib, map, filter
+
+# capture these to bypass sandboxing
+from os import utime
+try:
+    from os import mkdir, rename, unlink
+    WRITE_SUPPORT = True
+except ImportError:
+    # no write support, probably under GAE
+    WRITE_SUPPORT = False
+
+from os import open as os_open
+from os.path import isdir, split
+
+try:
+    import importlib.machinery as importlib_machinery
+    # access attribute to force import under delayed import mechanisms.
+    importlib_machinery.__name__
+except ImportError:
+    importlib_machinery = None
+
+from . import py31compat
+from pip._vendor import appdirs
+from pip._vendor import packaging
+__import__('pip._vendor.packaging.version')
+__import__('pip._vendor.packaging.specifiers')
+__import__('pip._vendor.packaging.requirements')
+__import__('pip._vendor.packaging.markers')
+
+
+__metaclass__ = type
+
+
+if (3, 0) < sys.version_info < (3, 5):
+    raise RuntimeError("Python 3.5 or later is required")
+
+if six.PY2:
+    # Those builtin exceptions are only defined in Python 3
+    PermissionError = None
+    NotADirectoryError = None
+
+# declare some globals that will be defined later to
+# satisfy the linters.
+require = None
+working_set = None
+add_activation_listener = None
+resources_stream = None
+cleanup_resources = None
+resource_dir = None
+resource_stream = None
+set_extraction_path = None
+resource_isdir = None
+resource_string = None
+iter_entry_points = None
+resource_listdir = None
+resource_filename = None
+resource_exists = None
+_distribution_finders = None
+_namespace_handlers = None
+_namespace_packages = None
+
+
+class PEP440Warning(RuntimeWarning):
+    """
+    Used when there is an issue with a version or specifier not complying with
+    PEP 440.
+    """
+
+
+def parse_version(v):
+    try:
+        return packaging.version.Version(v)
+    except packaging.version.InvalidVersion:
+        return packaging.version.LegacyVersion(v)
+
+
+_state_vars = {}
+
+
+def _declare_state(vartype, **kw):
+    globals().update(kw)
+    _state_vars.update(dict.fromkeys(kw, vartype))
+
+
+def __getstate__():
+    state = {}
+    g = globals()
+    for k, v in _state_vars.items():
+        state[k] = g['_sget_' + v](g[k])
+    return state
+
+
+def __setstate__(state):
+    g = globals()
+    for k, v in state.items():
+        g['_sset_' + _state_vars[k]](k, g[k], v)
+    return state
+
+
+def _sget_dict(val):
+    return val.copy()
+
+
+def _sset_dict(key, ob, state):
+    ob.clear()
+    ob.update(state)
+
+
+def _sget_object(val):
+    return val.__getstate__()
+
+
+def _sset_object(key, ob, state):
+    ob.__setstate__(state)
+
+
+_sget_none = _sset_none = lambda *args: None
+
+
+def get_supported_platform():
+    """Return this platform's maximum compatible version.
+
+    distutils.util.get_platform() normally reports the minimum version
+    of Mac OS X that would be required to *use* extensions produced by
+    distutils.  But what we want when checking compatibility is to know the
+    version of Mac OS X that we are *running*.  To allow usage of packages that
+    explicitly require a newer version of Mac OS X, we must also know the
+    current version of the OS.
+
+    If this condition occurs for any other platform with a version in its
+    platform strings, this function should be extended accordingly.
+    """
+    plat = get_build_platform()
+    m = macosVersionString.match(plat)
+    if m is not None and sys.platform == "darwin":
+        try:
+            plat = 'macosx-%s-%s' % ('.'.join(_macosx_vers()[:2]), m.group(3))
+        except ValueError:
+            # not Mac OS X
+            pass
+    return plat
+
+
+__all__ = [
+    # Basic resource access and distribution/entry point discovery
+    'require', 'run_script', 'get_provider', 'get_distribution',
+    'load_entry_point', 'get_entry_map', 'get_entry_info',
+    'iter_entry_points',
+    'resource_string', 'resource_stream', 'resource_filename',
+    'resource_listdir', 'resource_exists', 'resource_isdir',
+
+    # Environmental control
+    'declare_namespace', 'working_set', 'add_activation_listener',
+    'find_distributions', 'set_extraction_path', 'cleanup_resources',
+    'get_default_cache',
+
+    # Primary implementation classes
+    'Environment', 'WorkingSet', 'ResourceManager',
+    'Distribution', 'Requirement', 'EntryPoint',
+
+    # Exceptions
+    'ResolutionError', 'VersionConflict', 'DistributionNotFound',
+    'UnknownExtra', 'ExtractionError',
+
+    # Warnings
+    'PEP440Warning',
+
+    # Parsing functions and string utilities
+    'parse_requirements', 'parse_version', 'safe_name', 'safe_version',
+    'get_platform', 'compatible_platforms', 'yield_lines', 'split_sections',
+    'safe_extra', 'to_filename', 'invalid_marker', 'evaluate_marker',
+
+    # filesystem utilities
+    'ensure_directory', 'normalize_path',
+
+    # Distribution "precedence" constants
+    'EGG_DIST', 'BINARY_DIST', 'SOURCE_DIST', 'CHECKOUT_DIST', 'DEVELOP_DIST',
+
+    # "Provider" interfaces, implementations, and registration/lookup APIs
+    'IMetadataProvider', 'IResourceProvider', 'FileMetadata',
+    'PathMetadata', 'EggMetadata', 'EmptyProvider', 'empty_provider',
+    'NullProvider', 'EggProvider', 'DefaultProvider', 'ZipProvider',
+    'register_finder', 'register_namespace_handler', 'register_loader_type',
+    'fixup_namespace_packages', 'get_importer',
+
+    # Warnings
+    'PkgResourcesDeprecationWarning',
+
+    # Deprecated/backward compatibility only
+    'run_main', 'AvailableDistributions',
+]
+
+
+class ResolutionError(Exception):
+    """Abstract base for dependency resolution errors"""
+
+    def __repr__(self):
+        return self.__class__.__name__ + repr(self.args)
+
+
+class VersionConflict(ResolutionError):
+    """
+    An already-installed version conflicts with the requested version.
+
+    Should be initialized with the installed Distribution and the requested
+    Requirement.
+    """
+
+    _template = "{self.dist} is installed but {self.req} is required"
+
+    @property
+    def dist(self):
+        return self.args[0]
+
+    @property
+    def req(self):
+        return self.args[1]
+
+    def report(self):
+        return self._template.format(**locals())
+
+    def with_context(self, required_by):
+        """
+        If required_by is non-empty, return a version of self that is a
+        ContextualVersionConflict.
+        """
+        if not required_by:
+            return self
+        args = self.args + (required_by,)
+        return ContextualVersionConflict(*args)
+
+
+class ContextualVersionConflict(VersionConflict):
+    """
+    A VersionConflict that accepts a third parameter, the set of the
+    requirements that required the installed Distribution.
+    """
+
+    _template = VersionConflict._template + ' by {self.required_by}'
+
+    @property
+    def required_by(self):
+        return self.args[2]
+
+
+class DistributionNotFound(ResolutionError):
+    """A requested distribution was not found"""
+
+    _template = ("The '{self.req}' distribution was not found "
+                 "and is required by {self.requirers_str}")
+
+    @property
+    def req(self):
+        return self.args[0]
+
+    @property
+    def requirers(self):
+        return self.args[1]
+
+    @property
+    def requirers_str(self):
+        if not self.requirers:
+            return 'the application'
+        return ', '.join(self.requirers)
+
+    def report(self):
+        return self._template.format(**locals())
+
+    def __str__(self):
+        return self.report()
+
+
+class UnknownExtra(ResolutionError):
+    """Distribution doesn't have an "extra feature" of the given name"""
+
+
+_provider_factories = {}
+
+PY_MAJOR = '{}.{}'.format(*sys.version_info)
+EGG_DIST = 3
+BINARY_DIST = 2
+SOURCE_DIST = 1
+CHECKOUT_DIST = 0
+DEVELOP_DIST = -1
+
+
+def register_loader_type(loader_type, provider_factory):
+    """Register `provider_factory` to make providers for `loader_type`
+
+    `loader_type` is the type or class of a PEP 302 ``module.__loader__``,
+    and `provider_factory` is a function that, passed a *module* object,
+    returns an ``IResourceProvider`` for that module.
+    """
+    _provider_factories[loader_type] = provider_factory
+
+
+def get_provider(moduleOrReq):
+    """Return an IResourceProvider for the named module or requirement"""
+    if isinstance(moduleOrReq, Requirement):
+        return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0]
+    try:
+        module = sys.modules[moduleOrReq]
+    except KeyError:
+        __import__(moduleOrReq)
+        module = sys.modules[moduleOrReq]
+    loader = getattr(module, '__loader__', None)
+    return _find_adapter(_provider_factories, loader)(module)
+
+
+def _macosx_vers(_cache=[]):
+    if not _cache:
+        version = platform.mac_ver()[0]
+        # fallback for MacPorts
+        if version == '':
+            plist = '/System/Library/CoreServices/SystemVersion.plist'
+            if os.path.exists(plist):
+                if hasattr(plistlib, 'readPlist'):
+                    plist_content = plistlib.readPlist(plist)
+                    if 'ProductVersion' in plist_content:
+                        version = plist_content['ProductVersion']
+
+        _cache.append(version.split('.'))
+    return _cache[0]
+
+
+def _macosx_arch(machine):
+    return {'PowerPC': 'ppc', 'Power_Macintosh': 'ppc'}.get(machine, machine)
+
+
+def get_build_platform():
+    """Return this platform's string for platform-specific distributions
+
+    XXX Currently this is the same as ``distutils.util.get_platform()``, but it
+    needs some hacks for Linux and Mac OS X.
+    """
+    from sysconfig import get_platform
+
+    plat = get_platform()
+    if sys.platform == "darwin" and not plat.startswith('macosx-'):
+        try:
+            version = _macosx_vers()
+            machine = os.uname()[4].replace(" ", "_")
+            return "macosx-%d.%d-%s" % (
+                int(version[0]), int(version[1]),
+                _macosx_arch(machine),
+            )
+        except ValueError:
+            # if someone is running a non-Mac darwin system, this will fall
+            # through to the default implementation
+            pass
+    return plat
+
+
+macosVersionString = re.compile(r"macosx-(\d+)\.(\d+)-(.*)")
+darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)")
+# XXX backward compat
+get_platform = get_build_platform
+
+
+def compatible_platforms(provided, required):
+    """Can code for the `provided` platform run on the `required` platform?
+
+    Returns true if either platform is ``None``, or the platforms are equal.
+
+    XXX Needs compatibility checks for Linux and other unixy OSes.
+    """
+    if provided is None or required is None or provided == required:
+        # easy case
+        return True
+
+    # Mac OS X special cases
+    reqMac = macosVersionString.match(required)
+    if reqMac:
+        provMac = macosVersionString.match(provided)
+
+        # is this a Mac package?
+        if not provMac:
+            # this is backwards compatibility for packages built before
+            # setuptools 0.6. All packages built after this point will
+            # use the new macosx designation.
+            provDarwin = darwinVersionString.match(provided)
+            if provDarwin:
+                dversion = int(provDarwin.group(1))
+                macosversion = "%s.%s" % (reqMac.group(1), reqMac.group(2))
+                if dversion == 7 and macosversion >= "10.3" or \
+                        dversion == 8 and macosversion >= "10.4":
+                    return True
+            # egg isn't macosx or legacy darwin
+            return False
+
+        # are they the same major version and machine type?
+        if provMac.group(1) != reqMac.group(1) or \
+                provMac.group(3) != reqMac.group(3):
+            return False
+
+        # is the required OS major update >= the provided one?
+        if int(provMac.group(2)) > int(reqMac.group(2)):
+            return False
+
+        return True
+
+    # XXX Linux and other platforms' special cases should go here
+    return False
+
+
+def run_script(dist_spec, script_name):
+    """Locate distribution `dist_spec` and run its `script_name` script"""
+    ns = sys._getframe(1).f_globals
+    name = ns['__name__']
+    ns.clear()
+    ns['__name__'] = name
+    require(dist_spec)[0].run_script(script_name, ns)
+
+
+# backward compatibility
+run_main = run_script
+
+
+def get_distribution(dist):
+    """Return a current distribution object for a Requirement or string"""
+    if isinstance(dist, six.string_types):
+        dist = Requirement.parse(dist)
+    if isinstance(dist, Requirement):
+        dist = get_provider(dist)
+    if not isinstance(dist, Distribution):
+        raise TypeError("Expected string, Requirement, or Distribution", dist)
+    return dist
+
+
+def load_entry_point(dist, group, name):
+    """Return `name` entry point of `group` for `dist` or raise ImportError"""
+    return get_distribution(dist).load_entry_point(group, name)
+
+
+def get_entry_map(dist, group=None):
+    """Return the entry point map for `group`, or the full entry map"""
+    return get_distribution(dist).get_entry_map(group)
+
+
+def get_entry_info(dist, group, name):
+    """Return the EntryPoint object for `group`+`name`, or ``None``"""
+    return get_distribution(dist).get_entry_info(group, name)
+
+
+class IMetadataProvider:
+    def has_metadata(name):
+        """Does the package's distribution contain the named metadata?"""
+
+    def get_metadata(name):
+        """The named metadata resource as a string"""
+
+    def get_metadata_lines(name):
+        """Yield named metadata resource as list of non-blank non-comment lines
+
+       Leading and trailing whitespace is stripped from each line, and lines
+       with ``#`` as the first non-blank character are omitted."""
+
+    def metadata_isdir(name):
+        """Is the named metadata a directory?  (like ``os.path.isdir()``)"""
+
+    def metadata_listdir(name):
+        """List of metadata names in the directory (like ``os.listdir()``)"""
+
+    def run_script(script_name, namespace):
+        """Execute the named script in the supplied namespace dictionary"""
+
+
+class IResourceProvider(IMetadataProvider):
+    """An object that provides access to package resources"""
+
+    def get_resource_filename(manager, resource_name):
+        """Return a true filesystem path for `resource_name`
+
+        `manager` must be an ``IResourceManager``"""
+
+    def get_resource_stream(manager, resource_name):
+        """Return a readable file-like object for `resource_name`
+
+        `manager` must be an ``IResourceManager``"""
+
+    def get_resource_string(manager, resource_name):
+        """Return a string containing the contents of `resource_name`
+
+        `manager` must be an ``IResourceManager``"""
+
+    def has_resource(resource_name):
+        """Does the package contain the named resource?"""
+
+    def resource_isdir(resource_name):
+        """Is the named resource a directory?  (like ``os.path.isdir()``)"""
+
+    def resource_listdir(resource_name):
+        """List of resource names in the directory (like ``os.listdir()``)"""
+
+
+class WorkingSet:
+    """A collection of active distributions on sys.path (or a similar list)"""
+
+    def __init__(self, entries=None):
+        """Create working set from list of path entries (default=sys.path)"""
+        self.entries = []
+        self.entry_keys = {}
+        self.by_key = {}
+        self.callbacks = []
+
+        if entries is None:
+            entries = sys.path
+
+        for entry in entries:
+            self.add_entry(entry)
+
+    @classmethod
+    def _build_master(cls):
+        """
+        Prepare the master working set.
+        """
+        ws = cls()
+        try:
+            from __main__ import __requires__
+        except ImportError:
+            # The main program does not list any requirements
+            return ws
+
+        # ensure the requirements are met
+        try:
+            ws.require(__requires__)
+        except VersionConflict:
+            return cls._build_from_requirements(__requires__)
+
+        return ws
+
+    @classmethod
+    def _build_from_requirements(cls, req_spec):
+        """
+        Build a working set from a requirement spec. Rewrites sys.path.
+        """
+        # try it without defaults already on sys.path
+        # by starting with an empty path
+        ws = cls([])
+        reqs = parse_requirements(req_spec)
+        dists = ws.resolve(reqs, Environment())
+        for dist in dists:
+            ws.add(dist)
+
+        # add any missing entries from sys.path
+        for entry in sys.path:
+            if entry not in ws.entries:
+                ws.add_entry(entry)
+
+        # then copy back to sys.path
+        sys.path[:] = ws.entries
+        return ws
+
+    def add_entry(self, entry):
+        """Add a path item to ``.entries``, finding any distributions on it
+
+        ``find_distributions(entry, True)`` is used to find distributions
+        corresponding to the path entry, and they are added.  `entry` is
+        always appended to ``.entries``, even if it is already present.
+        (This is because ``sys.path`` can contain the same value more than
+        once, and the ``.entries`` of the ``sys.path`` WorkingSet should always
+        equal ``sys.path``.)
+        """
+        self.entry_keys.setdefault(entry, [])
+        self.entries.append(entry)
+        for dist in find_distributions(entry, True):
+            self.add(dist, entry, False)
+
+    def __contains__(self, dist):
+        """True if `dist` is the active distribution for its project"""
+        return self.by_key.get(dist.key) == dist
+
+    def find(self, req):
+        """Find a distribution matching requirement `req`
+
+        If there is an active distribution for the requested project, this
+        returns it as long as it meets the version requirement specified by
+        `req`.  But, if there is an active distribution for the project and it
+        does *not* meet the `req` requirement, ``VersionConflict`` is raised.
+        If there is no active distribution for the requested project, ``None``
+        is returned.
+        """
+        dist = self.by_key.get(req.key)
+        if dist is not None and dist not in req:
+            # XXX add more info
+            raise VersionConflict(dist, req)
+        return dist
+
+    def iter_entry_points(self, group, name=None):
+        """Yield entry point objects from `group` matching `name`
+
+        If `name` is None, yields all entry points in `group` from all
+        distributions in the working set, otherwise only ones matching
+        both `group` and `name` are yielded (in distribution order).
+        """
+        return (
+            entry
+            for dist in self
+            for entry in dist.get_entry_map(group).values()
+            if name is None or name == entry.name
+        )
+
+    def run_script(self, requires, script_name):
+        """Locate distribution for `requires` and run `script_name` script"""
+        ns = sys._getframe(1).f_globals
+        name = ns['__name__']
+        ns.clear()
+        ns['__name__'] = name
+        self.require(requires)[0].run_script(script_name, ns)
+
+    def __iter__(self):
+        """Yield distributions for non-duplicate projects in the working set
+
+        The yield order is the order in which the items' path entries were
+        added to the working set.
+        """
+        seen = {}
+        for item in self.entries:
+            if item not in self.entry_keys:
+                # workaround a cache issue
+                continue
+
+            for key in self.entry_keys[item]:
+                if key not in seen:
+                    seen[key] = 1
+                    yield self.by_key[key]
+
+    def add(self, dist, entry=None, insert=True, replace=False):
+        """Add `dist` to working set, associated with `entry`
+
+        If `entry` is unspecified, it defaults to the ``.location`` of `dist`.
+        On exit from this routine, `entry` is added to the end of the working
+        set's ``.entries`` (if it wasn't already present).
+
+        `dist` is only added to the working set if it's for a project that
+        doesn't already have a distribution in the set, unless `replace=True`.
+        If it's added, any callbacks registered with the ``subscribe()`` method
+        will be called.
+        """
+        if insert:
+            dist.insert_on(self.entries, entry, replace=replace)
+
+        if entry is None:
+            entry = dist.location
+        keys = self.entry_keys.setdefault(entry, [])
+        keys2 = self.entry_keys.setdefault(dist.location, [])
+        if not replace and dist.key in self.by_key:
+            # ignore hidden distros
+            return
+
+        self.by_key[dist.key] = dist
+        if dist.key not in keys:
+            keys.append(dist.key)
+        if dist.key not in keys2:
+            keys2.append(dist.key)
+        self._added_new(dist)
+
+    def resolve(self, requirements, env=None, installer=None,
+                replace_conflicting=False, extras=None):
+        """List all distributions needed to (recursively) meet `requirements`
+
+        `requirements` must be a sequence of ``Requirement`` objects.  `env`,
+        if supplied, should be an ``Environment`` instance.  If
+        not supplied, it defaults to all distributions available within any
+        entry or distribution in the working set.  `installer`, if supplied,
+        will be invoked with each requirement that cannot be met by an
+        already-installed distribution; it should return a ``Distribution`` or
+        ``None``.
+
+        Unless `replace_conflicting=True`, raises a VersionConflict exception
+        if
+        any requirements are found on the path that have the correct name but
+        the wrong version.  Otherwise, if an `installer` is supplied it will be
+        invoked to obtain the correct version of the requirement and activate
+        it.
+
+        `extras` is a list of the extras to be used with these requirements.
+        This is important because extra requirements may look like `my_req;
+        extra = "my_extra"`, which would otherwise be interpreted as a purely
+        optional requirement.  Instead, we want to be able to assert that these
+        requirements are truly required.
+        """
+
+        # set up the stack
+        requirements = list(requirements)[::-1]
+        # set of processed requirements
+        processed = {}
+        # key -> dist
+        best = {}
+        to_activate = []
+
+        req_extras = _ReqExtras()
+
+        # Mapping of requirement to set of distributions that required it;
+        # useful for reporting info about conflicts.
+        required_by = collections.defaultdict(set)
+
+        while requirements:
+            # process dependencies breadth-first
+            req = requirements.pop(0)
+            if req in processed:
+                # Ignore cyclic or redundant dependencies
+                continue
+
+            if not req_extras.markers_pass(req, extras):
+                continue
+
+            dist = best.get(req.key)
+            if dist is None:
+                # Find the best distribution and add it to the map
+                dist = self.by_key.get(req.key)
+                if dist is None or (dist not in req and replace_conflicting):
+                    ws = self
+                    if env is None:
+                        if dist is None:
+                            env = Environment(self.entries)
+                        else:
+                            # Use an empty environment and workingset to avoid
+                            # any further conflicts with the conflicting
+                            # distribution
+                            env = Environment([])
+                            ws = WorkingSet([])
+                    dist = best[req.key] = env.best_match(
+                        req, ws, installer,
+                        replace_conflicting=replace_conflicting
+                    )
+                    if dist is None:
+                        requirers = required_by.get(req, None)
+                        raise DistributionNotFound(req, requirers)
+                to_activate.append(dist)
+            if dist not in req:
+                # Oops, the "best" so far conflicts with a dependency
+                dependent_req = required_by[req]
+                raise VersionConflict(dist, req).with_context(dependent_req)
+
+            # push the new requirements onto the stack
+            new_requirements = dist.requires(req.extras)[::-1]
+            requirements.extend(new_requirements)
+
+            # Register the new requirements needed by req
+            for new_requirement in new_requirements:
+                required_by[new_requirement].add(req.project_name)
+                req_extras[new_requirement] = req.extras
+
+            processed[req] = True
+
+        # return list of distros to activate
+        return to_activate
+
+    def find_plugins(
+            self, plugin_env, full_env=None, installer=None, fallback=True):
+        """Find all activatable distributions in `plugin_env`
+
+        Example usage::
+
+            distributions, errors = working_set.find_plugins(
+                Environment(plugin_dirlist)
+            )
+            # add plugins+libs to sys.path
+            map(working_set.add, distributions)
+            # display errors
+            print('Could not load', errors)
+
+        The `plugin_env` should be an ``Environment`` instance that contains
+        only distributions that are in the project's "plugin directory" or
+        directories. The `full_env`, if supplied, should be an ``Environment``
+        contains all currently-available distributions.  If `full_env` is not
+        supplied, one is created automatically from the ``WorkingSet`` this
+        method is called on, which will typically mean that every directory on
+        ``sys.path`` will be scanned for distributions.
+
+        `installer` is a standard installer callback as used by the
+        ``resolve()`` method. The `fallback` flag indicates whether we should
+        attempt to resolve older versions of a plugin if the newest version
+        cannot be resolved.
+
+        This method returns a 2-tuple: (`distributions`, `error_info`), where
+        `distributions` is a list of the distributions found in `plugin_env`
+        that were loadable, along with any other distributions that are needed
+        to resolve their dependencies.  `error_info` is a dictionary mapping
+        unloadable plugin distributions to an exception instance describing the
+        error that occurred. Usually this will be a ``DistributionNotFound`` or
+        ``VersionConflict`` instance.
+        """
+
+        plugin_projects = list(plugin_env)
+        # scan project names in alphabetic order
+        plugin_projects.sort()
+
+        error_info = {}
+        distributions = {}
+
+        if full_env is None:
+            env = Environment(self.entries)
+            env += plugin_env
+        else:
+            env = full_env + plugin_env
+
+        shadow_set = self.__class__([])
+        # put all our entries in shadow_set
+        list(map(shadow_set.add, self))
+
+        for project_name in plugin_projects:
+
+            for dist in plugin_env[project_name]:
+
+                req = [dist.as_requirement()]
+
+                try:
+                    resolvees = shadow_set.resolve(req, env, installer)
+
+                except ResolutionError as v:
+                    # save error info
+                    error_info[dist] = v
+                    if fallback:
+                        # try the next older version of project
+                        continue
+                    else:
+                        # give up on this project, keep going
+                        break
+
+                else:
+                    list(map(shadow_set.add, resolvees))
+                    distributions.update(dict.fromkeys(resolvees))
+
+                    # success, no need to try any more versions of this project
+                    break
+
+        distributions = list(distributions)
+        distributions.sort()
+
+        return distributions, error_info
+
+    def require(self, *requirements):
+        """Ensure that distributions matching `requirements` are activated
+
+        `requirements` must be a string or a (possibly-nested) sequence
+        thereof, specifying the distributions and versions required.  The
+        return value is a sequence of the distributions that needed to be
+        activated to fulfill the requirements; all relevant distributions are
+        included, even if they were already activated in this working set.
+        """
+        needed = self.resolve(parse_requirements(requirements))
+
+        for dist in needed:
+            self.add(dist)
+
+        return needed
+
+    def subscribe(self, callback, existing=True):
+        """Invoke `callback` for all distributions
+
+        If `existing=True` (default),
+        call on all existing ones, as well.
+        """
+        if callback in self.callbacks:
+            return
+        self.callbacks.append(callback)
+        if not existing:
+            return
+        for dist in self:
+            callback(dist)
+
+    def _added_new(self, dist):
+        for callback in self.callbacks:
+            callback(dist)
+
+    def __getstate__(self):
+        return (
+            self.entries[:], self.entry_keys.copy(), self.by_key.copy(),
+            self.callbacks[:]
+        )
+
+    def __setstate__(self, e_k_b_c):
+        entries, keys, by_key, callbacks = e_k_b_c
+        self.entries = entries[:]
+        self.entry_keys = keys.copy()
+        self.by_key = by_key.copy()
+        self.callbacks = callbacks[:]
+
+
+class _ReqExtras(dict):
+    """
+    Map each requirement to the extras that demanded it.
+    """
+
+    def markers_pass(self, req, extras=None):
+        """
+        Evaluate markers for req against each extra that
+        demanded it.
+
+        Return False if the req has a marker and fails
+        evaluation. Otherwise, return True.
+        """
+        extra_evals = (
+            req.marker.evaluate({'extra': extra})
+            for extra in self.get(req, ()) + (extras or (None,))
+        )
+        return not req.marker or any(extra_evals)
+
+
+class Environment:
+    """Searchable snapshot of distributions on a search path"""
+
+    def __init__(
+            self, search_path=None, platform=get_supported_platform(),
+            python=PY_MAJOR):
+        """Snapshot distributions available on a search path
+
+        Any distributions found on `search_path` are added to the environment.
+        `search_path` should be a sequence of ``sys.path`` items.  If not
+        supplied, ``sys.path`` is used.
+
+        `platform` is an optional string specifying the name of the platform
+        that platform-specific distributions must be compatible with.  If
+        unspecified, it defaults to the current platform.  `python` is an
+        optional string naming the desired version of Python (e.g. ``'3.6'``);
+        it defaults to the current version.
+
+        You may explicitly set `platform` (and/or `python`) to ``None`` if you
+        wish to map *all* distributions, not just those compatible with the
+        running platform or Python version.
+        """
+        self._distmap = {}
+        self.platform = platform
+        self.python = python
+        self.scan(search_path)
+
+    def can_add(self, dist):
+        """Is distribution `dist` acceptable for this environment?
+
+        The distribution must match the platform and python version
+        requirements specified when this environment was created, or False
+        is returned.
+        """
+        py_compat = (
+            self.python is None
+            or dist.py_version is None
+            or dist.py_version == self.python
+        )
+        return py_compat and compatible_platforms(dist.platform, self.platform)
+
+    def remove(self, dist):
+        """Remove `dist` from the environment"""
+        self._distmap[dist.key].remove(dist)
+
+    def scan(self, search_path=None):
+        """Scan `search_path` for distributions usable in this environment
+
+        Any distributions found are added to the environment.
+        `search_path` should be a sequence of ``sys.path`` items.  If not
+        supplied, ``sys.path`` is used.  Only distributions conforming to
+        the platform/python version defined at initialization are added.
+        """
+        if search_path is None:
+            search_path = sys.path
+
+        for item in search_path:
+            for dist in find_distributions(item):
+                self.add(dist)
+
+    def __getitem__(self, project_name):
+        """Return a newest-to-oldest list of distributions for `project_name`
+
+        Uses case-insensitive `project_name` comparison, assuming all the
+        project's distributions use their project's name converted to all
+        lowercase as their key.
+
+        """
+        distribution_key = project_name.lower()
+        return self._distmap.get(distribution_key, [])
+
+    def add(self, dist):
+        """Add `dist` if we ``can_add()`` it and it has not already been added
+        """
+        if self.can_add(dist) and dist.has_version():
+            dists = self._distmap.setdefault(dist.key, [])
+            if dist not in dists:
+                dists.append(dist)
+                dists.sort(key=operator.attrgetter('hashcmp'), reverse=True)
+
+    def best_match(
+            self, req, working_set, installer=None, replace_conflicting=False):
+        """Find distribution best matching `req` and usable on `working_set`
+
+        This calls the ``find(req)`` method of the `working_set` to see if a
+        suitable distribution is already active.  (This may raise
+        ``VersionConflict`` if an unsuitable version of the project is already
+        active in the specified `working_set`.)  If a suitable distribution
+        isn't active, this method returns the newest distribution in the
+        environment that meets the ``Requirement`` in `req`.  If no suitable
+        distribution is found, and `installer` is supplied, then the result of
+        calling the environment's ``obtain(req, installer)`` method will be
+        returned.
+        """
+        try:
+            dist = working_set.find(req)
+        except VersionConflict:
+            if not replace_conflicting:
+                raise
+            dist = None
+        if dist is not None:
+            return dist
+        for dist in self[req.key]:
+            if dist in req:
+                return dist
+        # try to download/install
+        return self.obtain(req, installer)
+
+    def obtain(self, requirement, installer=None):
+        """Obtain a distribution matching `requirement` (e.g. via download)
+
+        Obtain a distro that matches requirement (e.g. via download).  In the
+        base ``Environment`` class, this routine just returns
+        ``installer(requirement)``, unless `installer` is None, in which case
+        None is returned instead.  This method is a hook that allows subclasses
+        to attempt other ways of obtaining a distribution before falling back
+        to the `installer` argument."""
+        if installer is not None:
+            return installer(requirement)
+
+    def __iter__(self):
+        """Yield the unique project names of the available distributions"""
+        for key in self._distmap.keys():
+            if self[key]:
+                yield key
+
+    def __iadd__(self, other):
+        """In-place addition of a distribution or environment"""
+        if isinstance(other, Distribution):
+            self.add(other)
+        elif isinstance(other, Environment):
+            for project in other:
+                for dist in other[project]:
+                    self.add(dist)
+        else:
+            raise TypeError("Can't add %r to environment" % (other,))
+        return self
+
+    def __add__(self, other):
+        """Add an environment or distribution to an environment"""
+        new = self.__class__([], platform=None, python=None)
+        for env in self, other:
+            new += env
+        return new
+
+
+# XXX backward compatibility
+AvailableDistributions = Environment
+
+
+class ExtractionError(RuntimeError):
+    """An error occurred extracting a resource
+
+    The following attributes are available from instances of this exception:
+
+    manager
+        The resource manager that raised this exception
+
+    cache_path
+        The base directory for resource extraction
+
+    original_error
+        The exception instance that caused extraction to fail
+    """
+
+
+class ResourceManager:
+    """Manage resource extraction and packages"""
+    extraction_path = None
+
+    def __init__(self):
+        self.cached_files = {}
+
+    def resource_exists(self, package_or_requirement, resource_name):
+        """Does the named resource exist?"""
+        return get_provider(package_or_requirement).has_resource(resource_name)
+
+    def resource_isdir(self, package_or_requirement, resource_name):
+        """Is the named resource an existing directory?"""
+        return get_provider(package_or_requirement).resource_isdir(
+            resource_name
+        )
+
+    def resource_filename(self, package_or_requirement, resource_name):
+        """Return a true filesystem path for specified resource"""
+        return get_provider(package_or_requirement).get_resource_filename(
+            self, resource_name
+        )
+
+    def resource_stream(self, package_or_requirement, resource_name):
+        """Return a readable file-like object for specified resource"""
+        return get_provider(package_or_requirement).get_resource_stream(
+            self, resource_name
+        )
+
+    def resource_string(self, package_or_requirement, resource_name):
+        """Return specified resource as a string"""
+        return get_provider(package_or_requirement).get_resource_string(
+            self, resource_name
+        )
+
+    def resource_listdir(self, package_or_requirement, resource_name):
+        """List the contents of the named resource directory"""
+        return get_provider(package_or_requirement).resource_listdir(
+            resource_name
+        )
+
+    def extraction_error(self):
+        """Give an error message for problems extracting file(s)"""
+
+        old_exc = sys.exc_info()[1]
+        cache_path = self.extraction_path or get_default_cache()
+
+        tmpl = textwrap.dedent("""
+            Can't extract file(s) to egg cache
+
+            The following error occurred while trying to extract file(s)
+            to the Python egg cache:
+
+              {old_exc}
+
+            The Python egg cache directory is currently set to:
+
+              {cache_path}
+
+            Perhaps your account does not have write access to this directory?
+            You can change the cache directory by setting the PYTHON_EGG_CACHE
+            environment variable to point to an accessible directory.
+            """).lstrip()
+        err = ExtractionError(tmpl.format(**locals()))
+        err.manager = self
+        err.cache_path = cache_path
+        err.original_error = old_exc
+        raise err
+
+    def get_cache_path(self, archive_name, names=()):
+        """Return absolute location in cache for `archive_name` and `names`
+
+        The parent directory of the resulting path will be created if it does
+        not already exist.  `archive_name` should be the base filename of the
+        enclosing egg (which may not be the name of the enclosing zipfile!),
+        including its ".egg" extension.  `names`, if provided, should be a
+        sequence of path name parts "under" the egg's extraction location.
+
+        This method should only be called by resource providers that need to
+        obtain an extraction location, and only for names they intend to
+        extract, as it tracks the generated names for possible cleanup later.
+        """
+        extract_path = self.extraction_path or get_default_cache()
+        target_path = os.path.join(extract_path, archive_name + '-tmp', *names)
+        try:
+            _bypass_ensure_directory(target_path)
+        except Exception:
+            self.extraction_error()
+
+        self._warn_unsafe_extraction_path(extract_path)
+
+        self.cached_files[target_path] = 1
+        return target_path
+
+    @staticmethod
+    def _warn_unsafe_extraction_path(path):
+        """
+        If the default extraction path is overridden and set to an insecure
+        location, such as /tmp, it opens up an opportunity for an attacker to
+        replace an extracted file with an unauthorized payload. Warn the user
+        if a known insecure location is used.
+
+        See Distribute #375 for more details.
+        """
+        if os.name == 'nt' and not path.startswith(os.environ['windir']):
+            # On Windows, permissions are generally restrictive by default
+            #  and temp directories are not writable by other users, so
+            #  bypass the warning.
+            return
+        mode = os.stat(path).st_mode
+        if mode & stat.S_IWOTH or mode & stat.S_IWGRP:
+            msg = (
+                "%s is writable by group/others and vulnerable to attack "
+                "when "
+                "used with get_resource_filename. Consider a more secure "
+                "location (set with .set_extraction_path or the "
+                "PYTHON_EGG_CACHE environment variable)." % path
+            )
+            warnings.warn(msg, UserWarning)
+
+    def postprocess(self, tempname, filename):
+        """Perform any platform-specific postprocessing of `tempname`
+
+        This is where Mac header rewrites should be done; other platforms don't
+        have anything special they should do.
+
+        Resource providers should call this method ONLY after successfully
+        extracting a compressed resource.  They must NOT call it on resources
+        that are already in the filesystem.
+
+        `tempname` is the current (temporary) name of the file, and `filename`
+        is the name it will be renamed to by the caller after this routine
+        returns.
+        """
+
+        if os.name == 'posix':
+            # Make the resource executable
+            mode = ((os.stat(tempname).st_mode) | 0o555) & 0o7777
+            os.chmod(tempname, mode)
+
+    def set_extraction_path(self, path):
+        """Set the base path where resources will be extracted to, if needed.
+
+        If you do not call this routine before any extractions take place, the
+        path defaults to the return value of ``get_default_cache()``.  (Which
+        is based on the ``PYTHON_EGG_CACHE`` environment variable, with various
+        platform-specific fallbacks.  See that routine's documentation for more
+        details.)
+
+        Resources are extracted to subdirectories of this path based upon
+        information given by the ``IResourceProvider``.  You may set this to a
+        temporary directory, but then you must call ``cleanup_resources()`` to
+        delete the extracted files when done.  There is no guarantee that
+        ``cleanup_resources()`` will be able to remove all extracted files.
+
+        (Note: you may not change the extraction path for a given resource
+        manager once resources have been extracted, unless you first call
+        ``cleanup_resources()``.)
+        """
+        if self.cached_files:
+            raise ValueError(
+                "Can't change extraction path, files already extracted"
+            )
+
+        self.extraction_path = path
+
+    def cleanup_resources(self, force=False):
+        """
+        Delete all extracted resource files and directories, returning a list
+        of the file and directory names that could not be successfully removed.
+        This function does not have any concurrency protection, so it should
+        generally only be called when the extraction path is a temporary
+        directory exclusive to a single process.  This method is not
+        automatically called; you must call it explicitly or register it as an
+        ``atexit`` function if you wish to ensure cleanup of a temporary
+        directory used for extractions.
+        """
+        # XXX
+
+
+def get_default_cache():
+    """
+    Return the ``PYTHON_EGG_CACHE`` environment variable
+    or a platform-relevant user cache dir for an app
+    named "Python-Eggs".
+    """
+    return (
+        os.environ.get('PYTHON_EGG_CACHE')
+        or appdirs.user_cache_dir(appname='Python-Eggs')
+    )
+
+
+def safe_name(name):
+    """Convert an arbitrary string to a standard distribution name
+
+    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
+    """
+    return re.sub('[^A-Za-z0-9.]+', '-', name)
+
+
+def safe_version(version):
+    """
+    Convert an arbitrary string to a standard version string
+    """
+    try:
+        # normalize the version
+        return str(packaging.version.Version(version))
+    except packaging.version.InvalidVersion:
+        version = version.replace(' ', '.')
+        return re.sub('[^A-Za-z0-9.]+', '-', version)
+
+
+def safe_extra(extra):
+    """Convert an arbitrary string to a standard 'extra' name
+
+    Any runs of non-alphanumeric characters are replaced with a single '_',
+    and the result is always lowercased.
+    """
+    return re.sub('[^A-Za-z0-9.-]+', '_', extra).lower()
+
+
+def to_filename(name):
+    """Convert a project or version name to its filename-escaped form
+
+    Any '-' characters are currently replaced with '_'.
+    """
+    return name.replace('-', '_')
+
+
+def invalid_marker(text):
+    """
+    Validate text as a PEP 508 environment marker; return an exception
+    if invalid or False otherwise.
+    """
+    try:
+        evaluate_marker(text)
+    except SyntaxError as e:
+        e.filename = None
+        e.lineno = None
+        return e
+    return False
+
+
+def evaluate_marker(text, extra=None):
+    """
+    Evaluate a PEP 508 environment marker.
+    Return a boolean indicating the marker result in this environment.
+    Raise SyntaxError if marker is invalid.
+
+    This implementation uses the 'pyparsing' module.
+    """
+    try:
+        marker = packaging.markers.Marker(text)
+        return marker.evaluate()
+    except packaging.markers.InvalidMarker as e:
+        raise SyntaxError(e)
+
+
+class NullProvider:
+    """Try to implement resources and metadata for arbitrary PEP 302 loaders"""
+
+    egg_name = None
+    egg_info = None
+    loader = None
+
+    def __init__(self, module):
+        self.loader = getattr(module, '__loader__', None)
+        self.module_path = os.path.dirname(getattr(module, '__file__', ''))
+
+    def get_resource_filename(self, manager, resource_name):
+        return self._fn(self.module_path, resource_name)
+
+    def get_resource_stream(self, manager, resource_name):
+        return io.BytesIO(self.get_resource_string(manager, resource_name))
+
+    def get_resource_string(self, manager, resource_name):
+        return self._get(self._fn(self.module_path, resource_name))
+
+    def has_resource(self, resource_name):
+        return self._has(self._fn(self.module_path, resource_name))
+
+    def _get_metadata_path(self, name):
+        return self._fn(self.egg_info, name)
+
+    def has_metadata(self, name):
+        if not self.egg_info:
+            return self.egg_info
+
+        path = self._get_metadata_path(name)
+        return self._has(path)
+
+    def get_metadata(self, name):
+        if not self.egg_info:
+            return ""
+        path = self._get_metadata_path(name)
+        value = self._get(path)
+        if six.PY2:
+            return value
+        try:
+            return value.decode('utf-8')
+        except UnicodeDecodeError as exc:
+            # Include the path in the error message to simplify
+            # troubleshooting, and without changing the exception type.
+            exc.reason += ' in {} file at path: {}'.format(name, path)
+            raise
+
+    def get_metadata_lines(self, name):
+        return yield_lines(self.get_metadata(name))
+
+    def resource_isdir(self, resource_name):
+        return self._isdir(self._fn(self.module_path, resource_name))
+
+    def metadata_isdir(self, name):
+        return self.egg_info and self._isdir(self._fn(self.egg_info, name))
+
+    def resource_listdir(self, resource_name):
+        return self._listdir(self._fn(self.module_path, resource_name))
+
+    def metadata_listdir(self, name):
+        if self.egg_info:
+            return self._listdir(self._fn(self.egg_info, name))
+        return []
+
+    def run_script(self, script_name, namespace):
+        script = 'scripts/' + script_name
+        if not self.has_metadata(script):
+            raise ResolutionError(
+                "Script {script!r} not found in metadata at {self.egg_info!r}"
+                .format(**locals()),
+            )
+        script_text = self.get_metadata(script).replace('\r\n', '\n')
+        script_text = script_text.replace('\r', '\n')
+        script_filename = self._fn(self.egg_info, script)
+        namespace['__file__'] = script_filename
+        if os.path.exists(script_filename):
+            source = open(script_filename).read()
+            code = compile(source, script_filename, 'exec')
+            exec(code, namespace, namespace)
+        else:
+            from linecache import cache
+            cache[script_filename] = (
+                len(script_text), 0, script_text.split('\n'), script_filename
+            )
+            script_code = compile(script_text, script_filename, 'exec')
+            exec(script_code, namespace, namespace)
+
+    def _has(self, path):
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _isdir(self, path):
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _listdir(self, path):
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _fn(self, base, resource_name):
+        self._validate_resource_path(resource_name)
+        if resource_name:
+            return os.path.join(base, *resource_name.split('/'))
+        return base
+
+    @staticmethod
+    def _validate_resource_path(path):
+        """
+        Validate the resource paths according to the docs.
+        https://setuptools.readthedocs.io/en/latest/pkg_resources.html#basic-resource-access
+
+        >>> warned = getfixture('recwarn')
+        >>> warnings.simplefilter('always')
+        >>> vrp = NullProvider._validate_resource_path
+        >>> vrp('foo/bar.txt')
+        >>> bool(warned)
+        False
+        >>> vrp('../foo/bar.txt')
+        >>> bool(warned)
+        True
+        >>> warned.clear()
+        >>> vrp('/foo/bar.txt')
+        >>> bool(warned)
+        True
+        >>> vrp('foo/../../bar.txt')
+        >>> bool(warned)
+        True
+        >>> warned.clear()
+        >>> vrp('foo/f../bar.txt')
+        >>> bool(warned)
+        False
+
+        Windows path separators are straight-up disallowed.
+        >>> vrp(r'\\foo/bar.txt')
+        Traceback (most recent call last):
+        ...
+        ValueError: Use of .. or absolute path in a resource path \
+is not allowed.
+
+        >>> vrp(r'C:\\foo/bar.txt')
+        Traceback (most recent call last):
+        ...
+        ValueError: Use of .. or absolute path in a resource path \
+is not allowed.
+
+        Blank values are allowed
+
+        >>> vrp('')
+        >>> bool(warned)
+        False
+
+        Non-string values are not.
+
+        >>> vrp(None)
+        Traceback (most recent call last):
+        ...
+        AttributeError: ...
+        """
+        invalid = (
+            os.path.pardir in path.split(posixpath.sep) or
+            posixpath.isabs(path) or
+            ntpath.isabs(path)
+        )
+        if not invalid:
+            return
+
+        msg = "Use of .. or absolute path in a resource path is not allowed."
+
+        # Aggressively disallow Windows absolute paths
+        if ntpath.isabs(path) and not posixpath.isabs(path):
+            raise ValueError(msg)
+
+        # for compatibility, warn; in future
+        # raise ValueError(msg)
+        warnings.warn(
+            msg[:-1] + " and will raise exceptions in a future release.",
+            DeprecationWarning,
+            stacklevel=4,
+        )
+
+    def _get(self, path):
+        if hasattr(self.loader, 'get_data'):
+            return self.loader.get_data(path)
+        raise NotImplementedError(
+            "Can't perform this operation for loaders without 'get_data()'"
+        )
+
+
+register_loader_type(object, NullProvider)
+
+
+class EggProvider(NullProvider):
+    """Provider based on a virtual filesystem"""
+
+    def __init__(self, module):
+        NullProvider.__init__(self, module)
+        self._setup_prefix()
+
+    def _setup_prefix(self):
+        # we assume here that our metadata may be nested inside a "basket"
+        # of multiple eggs; that's why we use module_path instead of .archive
+        path = self.module_path
+        old = None
+        while path != old:
+            if _is_egg_path(path):
+                self.egg_name = os.path.basename(path)
+                self.egg_info = os.path.join(path, 'EGG-INFO')
+                self.egg_root = path
+                break
+            old = path
+            path, base = os.path.split(path)
+
+
+class DefaultProvider(EggProvider):
+    """Provides access to package resources in the filesystem"""
+
+    def _has(self, path):
+        return os.path.exists(path)
+
+    def _isdir(self, path):
+        return os.path.isdir(path)
+
+    def _listdir(self, path):
+        return os.listdir(path)
+
+    def get_resource_stream(self, manager, resource_name):
+        return open(self._fn(self.module_path, resource_name), 'rb')
+
+    def _get(self, path):
+        with open(path, 'rb') as stream:
+            return stream.read()
+
+    @classmethod
+    def _register(cls):
+        loader_names = 'SourceFileLoader', 'SourcelessFileLoader',
+        for name in loader_names:
+            loader_cls = getattr(importlib_machinery, name, type(None))
+            register_loader_type(loader_cls, cls)
+
+
+DefaultProvider._register()
+
+
+class EmptyProvider(NullProvider):
+    """Provider that returns nothing for all requests"""
+
+    module_path = None
+
+    _isdir = _has = lambda self, path: False
+
+    def _get(self, path):
+        return ''
+
+    def _listdir(self, path):
+        return []
+
+    def __init__(self):
+        pass
+
+
+empty_provider = EmptyProvider()
+
+
+class ZipManifests(dict):
+    """
+    zip manifest builder
+    """
+
+    @classmethod
+    def build(cls, path):
+        """
+        Build a dictionary similar to the zipimport directory
+        caches, except instead of tuples, store ZipInfo objects.
+
+        Use a platform-specific path separator (os.sep) for the path keys
+        for compatibility with pypy on Windows.
+        """
+        with zipfile.ZipFile(path) as zfile:
+            items = (
+                (
+                    name.replace('/', os.sep),
+                    zfile.getinfo(name),
+                )
+                for name in zfile.namelist()
+            )
+            return dict(items)
+
+    load = build
+
+
+class MemoizedZipManifests(ZipManifests):
+    """
+    Memoized zipfile manifests.
+    """
+    manifest_mod = collections.namedtuple('manifest_mod', 'manifest mtime')
+
+    def load(self, path):
+        """
+        Load a manifest at path or return a suitable manifest already loaded.
+        """
+        path = os.path.normpath(path)
+        mtime = os.stat(path).st_mtime
+
+        if path not in self or self[path].mtime != mtime:
+            manifest = self.build(path)
+            self[path] = self.manifest_mod(manifest, mtime)
+
+        return self[path].manifest
+
+
+class ZipProvider(EggProvider):
+    """Resource support for zips and eggs"""
+
+    eagers = None
+    _zip_manifests = MemoizedZipManifests()
+
+    def __init__(self, module):
+        EggProvider.__init__(self, module)
+        self.zip_pre = self.loader.archive + os.sep
+
+    def _zipinfo_name(self, fspath):
+        # Convert a virtual filename (full path to file) into a zipfile subpath
+        # usable with the zipimport directory cache for our target archive
+        fspath = fspath.rstrip(os.sep)
+        if fspath == self.loader.archive:
+            return ''
+        if fspath.startswith(self.zip_pre):
+            return fspath[len(self.zip_pre):]
+        raise AssertionError(
+            "%s is not a subpath of %s" % (fspath, self.zip_pre)
+        )
+
+    def _parts(self, zip_path):
+        # Convert a zipfile subpath into an egg-relative path part list.
+        # pseudo-fs path
+        fspath = self.zip_pre + zip_path
+        if fspath.startswith(self.egg_root + os.sep):
+            return fspath[len(self.egg_root) + 1:].split(os.sep)
+        raise AssertionError(
+            "%s is not a subpath of %s" % (fspath, self.egg_root)
+        )
+
+    @property
+    def zipinfo(self):
+        return self._zip_manifests.load(self.loader.archive)
+
+    def get_resource_filename(self, manager, resource_name):
+        if not self.egg_name:
+            raise NotImplementedError(
+                "resource_filename() only supported for .egg, not .zip"
+            )
+        # no need to lock for extraction, since we use temp names
+        zip_path = self._resource_to_zip(resource_name)
+        eagers = self._get_eager_resources()
+        if '/'.join(self._parts(zip_path)) in eagers:
+            for name in eagers:
+                self._extract_resource(manager, self._eager_to_zip(name))
+        return self._extract_resource(manager, zip_path)
+
+    @staticmethod
+    def _get_date_and_size(zip_stat):
+        size = zip_stat.file_size
+        # ymdhms+wday, yday, dst
+        date_time = zip_stat.date_time + (0, 0, -1)
+        # 1980 offset already done
+        timestamp = time.mktime(date_time)
+        return timestamp, size
+
+    def _extract_resource(self, manager, zip_path):
+
+        if zip_path in self._index():
+            for name in self._index()[zip_path]:
+                last = self._extract_resource(
+                    manager, os.path.join(zip_path, name)
+                )
+            # return the extracted directory name
+            return os.path.dirname(last)
+
+        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
+
+        if not WRITE_SUPPORT:
+            raise IOError('"os.rename" and "os.unlink" are not supported '
+                          'on this platform')
+        try:
+
+            real_path = manager.get_cache_path(
+                self.egg_name, self._parts(zip_path)
+            )
+
+            if self._is_current(real_path, zip_path):
+                return real_path
+
+            outf, tmpnam = _mkstemp(
+                ".$extract",
+                dir=os.path.dirname(real_path),
+            )
+            os.write(outf, self.loader.get_data(zip_path))
+            os.close(outf)
+            utime(tmpnam, (timestamp, timestamp))
+            manager.postprocess(tmpnam, real_path)
+
+            try:
+                rename(tmpnam, real_path)
+
+            except os.error:
+                if os.path.isfile(real_path):
+                    if self._is_current(real_path, zip_path):
+                        # the file became current since it was checked above,
+                        #  so proceed.
+                        return real_path
+                    # Windows, del old file and retry
+                    elif os.name == 'nt':
+                        unlink(real_path)
+                        rename(tmpnam, real_path)
+                        return real_path
+                raise
+
+        except os.error:
+            # report a user-friendly error
+            manager.extraction_error()
+
+        return real_path
+
+    def _is_current(self, file_path, zip_path):
+        """
+        Return True if the file_path is current for this zip_path
+        """
+        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
+        if not os.path.isfile(file_path):
+            return False
+        stat = os.stat(file_path)
+        if stat.st_size != size or stat.st_mtime != timestamp:
+            return False
+        # check that the contents match
+        zip_contents = self.loader.get_data(zip_path)
+        with open(file_path, 'rb') as f:
+            file_contents = f.read()
+        return zip_contents == file_contents
+
+    def _get_eager_resources(self):
+        if self.eagers is None:
+            eagers = []
+            for name in ('native_libs.txt', 'eager_resources.txt'):
+                if self.has_metadata(name):
+                    eagers.extend(self.get_metadata_lines(name))
+            self.eagers = eagers
+        return self.eagers
+
+    def _index(self):
+        try:
+            return self._dirindex
+        except AttributeError:
+            ind = {}
+            for path in self.zipinfo:
+                parts = path.split(os.sep)
+                while parts:
+                    parent = os.sep.join(parts[:-1])
+                    if parent in ind:
+                        ind[parent].append(parts[-1])
+                        break
+                    else:
+                        ind[parent] = [parts.pop()]
+            self._dirindex = ind
+            return ind
+
+    def _has(self, fspath):
+        zip_path = self._zipinfo_name(fspath)
+        return zip_path in self.zipinfo or zip_path in self._index()
+
+    def _isdir(self, fspath):
+        return self._zipinfo_name(fspath) in self._index()
+
+    def _listdir(self, fspath):
+        return list(self._index().get(self._zipinfo_name(fspath), ()))
+
+    def _eager_to_zip(self, resource_name):
+        return self._zipinfo_name(self._fn(self.egg_root, resource_name))
+
+    def _resource_to_zip(self, resource_name):
+        return self._zipinfo_name(self._fn(self.module_path, resource_name))
+
+
+register_loader_type(zipimport.zipimporter, ZipProvider)
+
+
+class FileMetadata(EmptyProvider):
+    """Metadata handler for standalone PKG-INFO files
+
+    Usage::
+
+        metadata = FileMetadata("/path/to/PKG-INFO")
+
+    This provider rejects all data and metadata requests except for PKG-INFO,
+    which is treated as existing, and will be the contents of the file at
+    the provided location.
+    """
+
+    def __init__(self, path):
+        self.path = path
+
+    def _get_metadata_path(self, name):
+        return self.path
+
+    def has_metadata(self, name):
+        return name == 'PKG-INFO' and os.path.isfile(self.path)
+
+    def get_metadata(self, name):
+        if name != 'PKG-INFO':
+            raise KeyError("No metadata except PKG-INFO is available")
+
+        with io.open(self.path, encoding='utf-8', errors="replace") as f:
+            metadata = f.read()
+        self._warn_on_replacement(metadata)
+        return metadata
+
+    def _warn_on_replacement(self, metadata):
+        # Python 2.7 compat for: replacement_char = '�'
+        replacement_char = b'\xef\xbf\xbd'.decode('utf-8')
+        if replacement_char in metadata:
+            tmpl = "{self.path} could not be properly decoded in UTF-8"
+            msg = tmpl.format(**locals())
+            warnings.warn(msg)
+
+    def get_metadata_lines(self, name):
+        return yield_lines(self.get_metadata(name))
+
+
+class PathMetadata(DefaultProvider):
+    """Metadata provider for egg directories
+
+    Usage::
+
+        # Development eggs:
+
+        egg_info = "/path/to/PackageName.egg-info"
+        base_dir = os.path.dirname(egg_info)
+        metadata = PathMetadata(base_dir, egg_info)
+        dist_name = os.path.splitext(os.path.basename(egg_info))[0]
+        dist = Distribution(basedir, project_name=dist_name, metadata=metadata)
+
+        # Unpacked egg directories:
+
+        egg_path = "/path/to/PackageName-ver-pyver-etc.egg"
+        metadata = PathMetadata(egg_path, os.path.join(egg_path,'EGG-INFO'))
+        dist = Distribution.from_filename(egg_path, metadata=metadata)
+    """
+
+    def __init__(self, path, egg_info):
+        self.module_path = path
+        self.egg_info = egg_info
+
+
+class EggMetadata(ZipProvider):
+    """Metadata provider for .egg files"""
+
+    def __init__(self, importer):
+        """Create a metadata provider from a zipimporter"""
+
+        self.zip_pre = importer.archive + os.sep
+        self.loader = importer
+        if importer.prefix:
+            self.module_path = os.path.join(importer.archive, importer.prefix)
+        else:
+            self.module_path = importer.archive
+        self._setup_prefix()
+
+
+_declare_state('dict', _distribution_finders={})
+
+
+def register_finder(importer_type, distribution_finder):
+    """Register `distribution_finder` to find distributions in sys.path items
+
+    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
+    handler), and `distribution_finder` is a callable that, passed a path
+    item and the importer instance, yields ``Distribution`` instances found on
+    that path item.  See ``pkg_resources.find_on_path`` for an example."""
+    _distribution_finders[importer_type] = distribution_finder
+
+
+def find_distributions(path_item, only=False):
+    """Yield distributions accessible via `path_item`"""
+    importer = get_importer(path_item)
+    finder = _find_adapter(_distribution_finders, importer)
+    return finder(importer, path_item, only)
+
+
+def find_eggs_in_zip(importer, path_item, only=False):
+    """
+    Find eggs in zip files; possibly multiple nested eggs.
+    """
+    if importer.archive.endswith('.whl'):
+        # wheels are not supported with this finder
+        # they don't have PKG-INFO metadata, and won't ever contain eggs
+        return
+    metadata = EggMetadata(importer)
+    if metadata.has_metadata('PKG-INFO'):
+        yield Distribution.from_filename(path_item, metadata=metadata)
+    if only:
+        # don't yield nested distros
+        return
+    for subitem in metadata.resource_listdir(''):
+        if _is_egg_path(subitem):
+            subpath = os.path.join(path_item, subitem)
+            dists = find_eggs_in_zip(zipimport.zipimporter(subpath), subpath)
+            for dist in dists:
+                yield dist
+        elif subitem.lower().endswith('.dist-info'):
+            subpath = os.path.join(path_item, subitem)
+            submeta = EggMetadata(zipimport.zipimporter(subpath))
+            submeta.egg_info = subpath
+            yield Distribution.from_location(path_item, subitem, submeta)
+
+
+register_finder(zipimport.zipimporter, find_eggs_in_zip)
+
+
+def find_nothing(importer, path_item, only=False):
+    return ()
+
+
+register_finder(object, find_nothing)
+
+
+def _by_version_descending(names):
+    """
+    Given a list of filenames, return them in descending order
+    by version number.
+
+    >>> names = 'bar', 'foo', 'Python-2.7.10.egg', 'Python-2.7.2.egg'
+    >>> _by_version_descending(names)
+    ['Python-2.7.10.egg', 'Python-2.7.2.egg', 'foo', 'bar']
+    >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.egg'
+    >>> _by_version_descending(names)
+    ['Setuptools-1.2.3.egg', 'Setuptools-1.2.3b1.egg']
+    >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.post1.egg'
+    >>> _by_version_descending(names)
+    ['Setuptools-1.2.3.post1.egg', 'Setuptools-1.2.3b1.egg']
+    """
+    def _by_version(name):
+        """
+        Parse each component of the filename
+        """
+        name, ext = os.path.splitext(name)
+        parts = itertools.chain(name.split('-'), [ext])
+        return [packaging.version.parse(part) for part in parts]
+
+    return sorted(names, key=_by_version, reverse=True)
+
+
+def find_on_path(importer, path_item, only=False):
+    """Yield distributions accessible on a sys.path directory"""
+    path_item = _normalize_cached(path_item)
+
+    if _is_unpacked_egg(path_item):
+        yield Distribution.from_filename(
+            path_item, metadata=PathMetadata(
+                path_item, os.path.join(path_item, 'EGG-INFO')
+            )
+        )
+        return
+
+    entries = safe_listdir(path_item)
+
+    # for performance, before sorting by version,
+    # screen entries for only those that will yield
+    # distributions
+    filtered = (
+        entry
+        for entry in entries
+        if dist_factory(path_item, entry, only)
+    )
+
+    # scan for .egg and .egg-info in directory
+    path_item_entries = _by_version_descending(filtered)
+    for entry in path_item_entries:
+        fullpath = os.path.join(path_item, entry)
+        factory = dist_factory(path_item, entry, only)
+        for dist in factory(fullpath):
+            yield dist
+
+
+def dist_factory(path_item, entry, only):
+    """
+    Return a dist_factory for a path_item and entry
+    """
+    lower = entry.lower()
+    is_meta = any(map(lower.endswith, ('.egg-info', '.dist-info')))
+    return (
+        distributions_from_metadata
+        if is_meta else
+        find_distributions
+        if not only and _is_egg_path(entry) else
+        resolve_egg_link
+        if not only and lower.endswith('.egg-link') else
+        NoDists()
+    )
+
+
+class NoDists:
+    """
+    >>> bool(NoDists())
+    False
+
+    >>> list(NoDists()('anything'))
+    []
+    """
+    def __bool__(self):
+        return False
+    if six.PY2:
+        __nonzero__ = __bool__
+
+    def __call__(self, fullpath):
+        return iter(())
+
+
+def safe_listdir(path):
+    """
+    Attempt to list contents of path, but suppress some exceptions.
+    """
+    try:
+        return os.listdir(path)
+    except (PermissionError, NotADirectoryError):
+        pass
+    except OSError as e:
+        # Ignore the directory if does not exist, not a directory or
+        # permission denied
+        ignorable = (
+            e.errno in (errno.ENOTDIR, errno.EACCES, errno.ENOENT)
+            # Python 2 on Windows needs to be handled this way :(
+            or getattr(e, "winerror", None) == 267
+        )
+        if not ignorable:
+            raise
+    return ()
+
+
+def distributions_from_metadata(path):
+    root = os.path.dirname(path)
+    if os.path.isdir(path):
+        if len(os.listdir(path)) == 0:
+            # empty metadata dir; skip
+            return
+        metadata = PathMetadata(root, path)
+    else:
+        metadata = FileMetadata(path)
+    entry = os.path.basename(path)
+    yield Distribution.from_location(
+        root, entry, metadata, precedence=DEVELOP_DIST,
+    )
+
+
+def non_empty_lines(path):
+    """
+    Yield non-empty lines from file at path
+    """
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield line
+
+
+def resolve_egg_link(path):
+    """
+    Given a path to an .egg-link, resolve distributions
+    present in the referenced path.
+    """
+    referenced_paths = non_empty_lines(path)
+    resolved_paths = (
+        os.path.join(os.path.dirname(path), ref)
+        for ref in referenced_paths
+    )
+    dist_groups = map(find_distributions, resolved_paths)
+    return next(dist_groups, ())
+
+
+register_finder(pkgutil.ImpImporter, find_on_path)
+
+if hasattr(importlib_machinery, 'FileFinder'):
+    register_finder(importlib_machinery.FileFinder, find_on_path)
+
+_declare_state('dict', _namespace_handlers={})
+_declare_state('dict', _namespace_packages={})
+
+
+def register_namespace_handler(importer_type, namespace_handler):
+    """Register `namespace_handler` to declare namespace packages
+
+    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
+    handler), and `namespace_handler` is a callable like this::
+
+        def namespace_handler(importer, path_entry, moduleName, module):
+            # return a path_entry to use for child packages
+
+    Namespace handlers are only called if the importer object has already
+    agreed that it can handle the relevant path item, and they should only
+    return a subpath if the module __path__ does not already contain an
+    equivalent subpath.  For an example namespace handler, see
+    ``pkg_resources.file_ns_handler``.
+    """
+    _namespace_handlers[importer_type] = namespace_handler
+
+
+def _handle_ns(packageName, path_item):
+    """Ensure that named package includes a subpath of path_item (if needed)"""
+
+    importer = get_importer(path_item)
+    if importer is None:
+        return None
+
+    # capture warnings due to #1111
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        loader = importer.find_module(packageName)
+
+    if loader is None:
+        return None
+    module = sys.modules.get(packageName)
+    if module is None:
+        module = sys.modules[packageName] = types.ModuleType(packageName)
+        module.__path__ = []
+        _set_parent_ns(packageName)
+    elif not hasattr(module, '__path__'):
+        raise TypeError("Not a package:", packageName)
+    handler = _find_adapter(_namespace_handlers, importer)
+    subpath = handler(importer, path_item, packageName, module)
+    if subpath is not None:
+        path = module.__path__
+        path.append(subpath)
+        loader.load_module(packageName)
+        _rebuild_mod_path(path, packageName, module)
+    return subpath
+
+
+def _rebuild_mod_path(orig_path, package_name, module):
+    """
+    Rebuild module.__path__ ensuring that all entries are ordered
+    corresponding to their sys.path order
+    """
+    sys_path = [_normalize_cached(p) for p in sys.path]
+
+    def safe_sys_path_index(entry):
+        """
+        Workaround for #520 and #513.
+        """
+        try:
+            return sys_path.index(entry)
+        except ValueError:
+            return float('inf')
+
+    def position_in_sys_path(path):
+        """
+        Return the ordinal of the path based on its position in sys.path
+        """
+        path_parts = path.split(os.sep)
+        module_parts = package_name.count('.') + 1
+        parts = path_parts[:-module_parts]
+        return safe_sys_path_index(_normalize_cached(os.sep.join(parts)))
+
+    new_path = sorted(orig_path, key=position_in_sys_path)
+    new_path = [_normalize_cached(p) for p in new_path]
+
+    if isinstance(module.__path__, list):
+        module.__path__[:] = new_path
+    else:
+        module.__path__ = new_path
+
+
+def declare_namespace(packageName):
+    """Declare that package 'packageName' is a namespace package"""
+
+    _imp.acquire_lock()
+    try:
+        if packageName in _namespace_packages:
+            return
+
+        path = sys.path
+        parent, _, _ = packageName.rpartition('.')
+
+        if parent:
+            declare_namespace(parent)
+            if parent not in _namespace_packages:
+                __import__(parent)
+            try:
+                path = sys.modules[parent].__path__
+            except AttributeError:
+                raise TypeError("Not a package:", parent)
+
+        # Track what packages are namespaces, so when new path items are added,
+        # they can be updated
+        _namespace_packages.setdefault(parent or None, []).append(packageName)
+        _namespace_packages.setdefault(packageName, [])
+
+        for path_item in path:
+            # Ensure all the parent's path items are reflected in the child,
+            # if they apply
+            _handle_ns(packageName, path_item)
+
+    finally:
+        _imp.release_lock()
+
+
+def fixup_namespace_packages(path_item, parent=None):
+    """Ensure that previously-declared namespace packages include path_item"""
+    _imp.acquire_lock()
+    try:
+        for package in _namespace_packages.get(parent, ()):
+            subpath = _handle_ns(package, path_item)
+            if subpath:
+                fixup_namespace_packages(subpath, package)
+    finally:
+        _imp.release_lock()
+
+
+def file_ns_handler(importer, path_item, packageName, module):
+    """Compute an ns-package subpath for a filesystem or zipfile importer"""
+
+    subpath = os.path.join(path_item, packageName.split('.')[-1])
+    normalized = _normalize_cached(subpath)
+    for item in module.__path__:
+        if _normalize_cached(item) == normalized:
+            break
+    else:
+        # Only return the path if it's not already there
+        return subpath
+
+
+register_namespace_handler(pkgutil.ImpImporter, file_ns_handler)
+register_namespace_handler(zipimport.zipimporter, file_ns_handler)
+
+if hasattr(importlib_machinery, 'FileFinder'):
+    register_namespace_handler(importlib_machinery.FileFinder, file_ns_handler)
+
+
+def null_ns_handler(importer, path_item, packageName, module):
+    return None
+
+
+register_namespace_handler(object, null_ns_handler)
+
+
+def normalize_path(filename):
+    """Normalize a file/dir name for comparison purposes"""
+    return os.path.normcase(os.path.realpath(os.path.normpath(_cygwin_patch(filename))))
+
+
+def _cygwin_patch(filename):  # pragma: nocover
+    """
+    Contrary to POSIX 2008, on Cygwin, getcwd (3) contains
+    symlink components. Using
+    os.path.abspath() works around this limitation. A fix in os.getcwd()
+    would probably better, in Cygwin even more so, except
+    that this seems to be by design...
+    """
+    return os.path.abspath(filename) if sys.platform == 'cygwin' else filename
+
+
+def _normalize_cached(filename, _cache={}):
+    try:
+        return _cache[filename]
+    except KeyError:
+        _cache[filename] = result = normalize_path(filename)
+        return result
+
+
+def _is_egg_path(path):
+    """
+    Determine if given path appears to be an egg.
+    """
+    return path.lower().endswith('.egg')
+
+
+def _is_unpacked_egg(path):
+    """
+    Determine if given path appears to be an unpacked egg.
+    """
+    return (
+        _is_egg_path(path) and
+        os.path.isfile(os.path.join(path, 'EGG-INFO', 'PKG-INFO'))
+    )
+
+
+def _set_parent_ns(packageName):
+    parts = packageName.split('.')
+    name = parts.pop()
+    if parts:
+        parent = '.'.join(parts)
+        setattr(sys.modules[parent], name, sys.modules[packageName])
+
+
+def yield_lines(strs):
+    """Yield non-empty/non-comment lines of a string or sequence"""
+    if isinstance(strs, six.string_types):
+        for s in strs.splitlines():
+            s = s.strip()
+            # skip blank lines/comments
+            if s and not s.startswith('#'):
+                yield s
+    else:
+        for ss in strs:
+            for s in yield_lines(ss):
+                yield s
+
+
+MODULE = re.compile(r"\w+(\.\w+)*$").match
+EGG_NAME = re.compile(
+    r"""
+    (?P<name>[^-]+) (
+        -(?P<ver>[^-]+) (
+            -py(?P<pyver>[^-]+) (
+                -(?P<plat>.+)
+            )?
+        )?
+    )?
+    """,
+    re.VERBOSE | re.IGNORECASE,
+).match
+
+
+class EntryPoint:
+    """Object representing an advertised importable object"""
+
+    def __init__(self, name, module_name, attrs=(), extras=(), dist=None):
+        if not MODULE(module_name):
+            raise ValueError("Invalid module name", module_name)
+        self.name = name
+        self.module_name = module_name
+        self.attrs = tuple(attrs)
+        self.extras = tuple(extras)
+        self.dist = dist
+
+    def __str__(self):
+        s = "%s = %s" % (self.name, self.module_name)
+        if self.attrs:
+            s += ':' + '.'.join(self.attrs)
+        if self.extras:
+            s += ' [%s]' % ','.join(self.extras)
+        return s
+
+    def __repr__(self):
+        return "EntryPoint.parse(%r)" % str(self)
+
+    def load(self, require=True, *args, **kwargs):
+        """
+        Require packages for this EntryPoint, then resolve it.
+        """
+        if not require or args or kwargs:
+            warnings.warn(
+                "Parameters to load are deprecated.  Call .resolve and "
+                ".require separately.",
+                PkgResourcesDeprecationWarning,
+                stacklevel=2,
+            )
+        if require:
+            self.require(*args, **kwargs)
+        return self.resolve()
+
+    def resolve(self):
+        """
+        Resolve the entry point from its module and attrs.
+        """
+        module = __import__(self.module_name, fromlist=['__name__'], level=0)
+        try:
+            return functools.reduce(getattr, self.attrs, module)
+        except AttributeError as exc:
+            raise ImportError(str(exc))
+
+    def require(self, env=None, installer=None):
+        if self.extras and not self.dist:
+            raise UnknownExtra("Can't require() without a distribution", self)
+
+        # Get the requirements for this entry point with all its extras and
+        # then resolve them. We have to pass `extras` along when resolving so
+        # that the working set knows what extras we want. Otherwise, for
+        # dist-info distributions, the working set will assume that the
+        # requirements for that extra are purely optional and skip over them.
+        reqs = self.dist.requires(self.extras)
+        items = working_set.resolve(reqs, env, installer, extras=self.extras)
+        list(map(working_set.add, items))
+
+    pattern = re.compile(
+        r'\s*'
+        r'(?P<name>.+?)\s*'
+        r'=\s*'
+        r'(?P<module>[\w.]+)\s*'
+        r'(:\s*(?P<attr>[\w.]+))?\s*'
+        r'(?P<extras>\[.*\])?\s*$'
+    )
+
+    @classmethod
+    def parse(cls, src, dist=None):
+        """Parse a single entry point from string `src`
+
+        Entry point syntax follows the form::
+
+            name = some.module:some.attr [extra1, extra2]
+
+        The entry name and module name are required, but the ``:attrs`` and
+        ``[extras]`` parts are optional
+        """
+        m = cls.pattern.match(src)
+        if not m:
+            msg = "EntryPoint must be in 'name=module:attrs [extras]' format"
+            raise ValueError(msg, src)
+        res = m.groupdict()
+        extras = cls._parse_extras(res['extras'])
+        attrs = res['attr'].split('.') if res['attr'] else ()
+        return cls(res['name'], res['module'], attrs, extras, dist)
+
+    @classmethod
+    def _parse_extras(cls, extras_spec):
+        if not extras_spec:
+            return ()
+        req = Requirement.parse('x' + extras_spec)
+        if req.specs:
+            raise ValueError()
+        return req.extras
+
+    @classmethod
+    def parse_group(cls, group, lines, dist=None):
+        """Parse an entry point group"""
+        if not MODULE(group):
+            raise ValueError("Invalid group name", group)
+        this = {}
+        for line in yield_lines(lines):
+            ep = cls.parse(line, dist)
+            if ep.name in this:
+                raise ValueError("Duplicate entry point", group, ep.name)
+            this[ep.name] = ep
+        return this
+
+    @classmethod
+    def parse_map(cls, data, dist=None):
+        """Parse a map of entry point groups"""
+        if isinstance(data, dict):
+            data = data.items()
+        else:
+            data = split_sections(data)
+        maps = {}
+        for group, lines in data:
+            if group is None:
+                if not lines:
+                    continue
+                raise ValueError("Entry points must be listed in groups")
+            group = group.strip()
+            if group in maps:
+                raise ValueError("Duplicate group name", group)
+            maps[group] = cls.parse_group(group, lines, dist)
+        return maps
+
+
+def _remove_md5_fragment(location):
+    if not location:
+        return ''
+    parsed = urllib.parse.urlparse(location)
+    if parsed[-1].startswith('md5='):
+        return urllib.parse.urlunparse(parsed[:-1] + ('',))
+    return location
+
+
+def _version_from_file(lines):
+    """
+    Given an iterable of lines from a Metadata file, return
+    the value of the Version field, if present, or None otherwise.
+    """
+    def is_version_line(line):
+        return line.lower().startswith('version:')
+    version_lines = filter(is_version_line, lines)
+    line = next(iter(version_lines), '')
+    _, _, value = line.partition(':')
+    return safe_version(value.strip()) or None
+
+
+class Distribution:
+    """Wrap an actual or potential sys.path entry w/metadata"""
+    PKG_INFO = 'PKG-INFO'
+
+    def __init__(
+            self, location=None, metadata=None, project_name=None,
+            version=None, py_version=PY_MAJOR, platform=None,
+            precedence=EGG_DIST):
+        self.project_name = safe_name(project_name or 'Unknown')
+        if version is not None:
+            self._version = safe_version(version)
+        self.py_version = py_version
+        self.platform = platform
+        self.location = location
+        self.precedence = precedence
+        self._provider = metadata or empty_provider
+
+    @classmethod
+    def from_location(cls, location, basename, metadata=None, **kw):
+        project_name, version, py_version, platform = [None] * 4
+        basename, ext = os.path.splitext(basename)
+        if ext.lower() in _distributionImpl:
+            cls = _distributionImpl[ext.lower()]
+
+            match = EGG_NAME(basename)
+            if match:
+                project_name, version, py_version, platform = match.group(
+                    'name', 'ver', 'pyver', 'plat'
+                )
+        return cls(
+            location, metadata, project_name=project_name, version=version,
+            py_version=py_version, platform=platform, **kw
+        )._reload_version()
+
+    def _reload_version(self):
+        return self
+
+    @property
+    def hashcmp(self):
+        return (
+            self.parsed_version,
+            self.precedence,
+            self.key,
+            _remove_md5_fragment(self.location),
+            self.py_version or '',
+            self.platform or '',
+        )
+
+    def __hash__(self):
+        return hash(self.hashcmp)
+
+    def __lt__(self, other):
+        return self.hashcmp < other.hashcmp
+
+    def __le__(self, other):
+        return self.hashcmp <= other.hashcmp
+
+    def __gt__(self, other):
+        return self.hashcmp > other.hashcmp
+
+    def __ge__(self, other):
+        return self.hashcmp >= other.hashcmp
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            # It's not a Distribution, so they are not equal
+            return False
+        return self.hashcmp == other.hashcmp
+
+    def __ne__(self, other):
+        return not self == other
+
+    # These properties have to be lazy so that we don't have to load any
+    # metadata until/unless it's actually needed.  (i.e., some distributions
+    # may not know their name or version without loading PKG-INFO)
+
+    @property
+    def key(self):
+        try:
+            return self._key
+        except AttributeError:
+            self._key = key = self.project_name.lower()
+            return key
+
+    @property
+    def parsed_version(self):
+        if not hasattr(self, "_parsed_version"):
+            self._parsed_version = parse_version(self.version)
+
+        return self._parsed_version
+
+    def _warn_legacy_version(self):
+        LV = packaging.version.LegacyVersion
+        is_legacy = isinstance(self._parsed_version, LV)
+        if not is_legacy:
+            return
+
+        # While an empty version is technically a legacy version and
+        # is not a valid PEP 440 version, it's also unlikely to
+        # actually come from someone and instead it is more likely that
+        # it comes from setuptools attempting to parse a filename and
+        # including it in the list. So for that we'll gate this warning
+        # on if the version is anything at all or not.
+        if not self.version:
+            return
+
+        tmpl = textwrap.dedent("""
+            '{project_name} ({version})' is being parsed as a legacy,
+            non PEP 440,
+            version. You may find odd behavior and sort order.
+            In particular it will be sorted as less than 0.0. It
+            is recommended to migrate to PEP 440 compatible
+            versions.
+            """).strip().replace('\n', ' ')
+
+        warnings.warn(tmpl.format(**vars(self)), PEP440Warning)
+
+    @property
+    def version(self):
+        try:
+            return self._version
+        except AttributeError:
+            version = self._get_version()
+            if version is None:
+                path = self._get_metadata_path_for_display(self.PKG_INFO)
+                msg = (
+                    "Missing 'Version:' header and/or {} file at path: {}"
+                ).format(self.PKG_INFO, path)
+                raise ValueError(msg, self)
+
+            return version
+
+    @property
+    def _dep_map(self):
+        """
+        A map of extra to its list of (direct) requirements
+        for this distribution, including the null extra.
+        """
+        try:
+            return self.__dep_map
+        except AttributeError:
+            self.__dep_map = self._filter_extras(self._build_dep_map())
+        return self.__dep_map
+
+    @staticmethod
+    def _filter_extras(dm):
+        """
+        Given a mapping of extras to dependencies, strip off
+        environment markers and filter out any dependencies
+        not matching the markers.
+        """
+        for extra in list(filter(None, dm)):
+            new_extra = extra
+            reqs = dm.pop(extra)
+            new_extra, _, marker = extra.partition(':')
+            fails_marker = marker and (
+                invalid_marker(marker)
+                or not evaluate_marker(marker)
+            )
+            if fails_marker:
+                reqs = []
+            new_extra = safe_extra(new_extra) or None
+
+            dm.setdefault(new_extra, []).extend(reqs)
+        return dm
+
+    def _build_dep_map(self):
+        dm = {}
+        for name in 'requires.txt', 'depends.txt':
+            for extra, reqs in split_sections(self._get_metadata(name)):
+                dm.setdefault(extra, []).extend(parse_requirements(reqs))
+        return dm
+
+    def requires(self, extras=()):
+        """List of Requirements needed for this distro if `extras` are used"""
+        dm = self._dep_map
+        deps = []
+        deps.extend(dm.get(None, ()))
+        for ext in extras:
+            try:
+                deps.extend(dm[safe_extra(ext)])
+            except KeyError:
+                raise UnknownExtra(
+                    "%s has no such extra feature %r" % (self, ext)
+                )
+        return deps
+
+    def _get_metadata_path_for_display(self, name):
+        """
+        Return the path to the given metadata file, if available.
+        """
+        try:
+            # We need to access _get_metadata_path() on the provider object
+            # directly rather than through this class's __getattr__()
+            # since _get_metadata_path() is marked private.
+            path = self._provider._get_metadata_path(name)
+
+        # Handle exceptions e.g. in case the distribution's metadata
+        # provider doesn't support _get_metadata_path().
+        except Exception:
+            return '[could not detect]'
+
+        return path
+
+    def _get_metadata(self, name):
+        if self.has_metadata(name):
+            for line in self.get_metadata_lines(name):
+                yield line
+
+    def _get_version(self):
+        lines = self._get_metadata(self.PKG_INFO)
+        version = _version_from_file(lines)
+
+        return version
+
+    def activate(self, path=None, replace=False):
+        """Ensure distribution is importable on `path` (default=sys.path)"""
+        if path is None:
+            path = sys.path
+        self.insert_on(path, replace=replace)
+        if path is sys.path:
+            fixup_namespace_packages(self.location)
+            for pkg in self._get_metadata('namespace_packages.txt'):
+                if pkg in sys.modules:
+                    declare_namespace(pkg)
+
+    def egg_name(self):
+        """Return what this distribution's standard .egg filename should be"""
+        filename = "%s-%s-py%s" % (
+            to_filename(self.project_name), to_filename(self.version),
+            self.py_version or PY_MAJOR
+        )
+
+        if self.platform:
+            filename += '-' + self.platform
+        return filename
+
+    def __repr__(self):
+        if self.location:
+            return "%s (%s)" % (self, self.location)
+        else:
+            return str(self)
+
+    def __str__(self):
+        try:
+            version = getattr(self, 'version', None)
+        except ValueError:
+            version = None
+        version = version or "[unknown version]"
+        return "%s %s" % (self.project_name, version)
+
+    def __getattr__(self, attr):
+        """Delegate all unrecognized public attributes to .metadata provider"""
+        if attr.startswith('_'):
+            raise AttributeError(attr)
+        return getattr(self._provider, attr)
+
+    def __dir__(self):
+        return list(
+            set(super(Distribution, self).__dir__())
+            | set(
+                attr for attr in self._provider.__dir__()
+                if not attr.startswith('_')
+            )
+        )
+
+    if not hasattr(object, '__dir__'):
+        # python 2.7 not supported
+        del __dir__
+
+    @classmethod
+    def from_filename(cls, filename, metadata=None, **kw):
+        return cls.from_location(
+            _normalize_cached(filename), os.path.basename(filename), metadata,
+            **kw
+        )
+
+    def as_requirement(self):
+        """Return a ``Requirement`` that matches this distribution exactly"""
+        if isinstance(self.parsed_version, packaging.version.Version):
+            spec = "%s==%s" % (self.project_name, self.parsed_version)
+        else:
+            spec = "%s===%s" % (self.project_name, self.parsed_version)
+
+        return Requirement.parse(spec)
+
+    def load_entry_point(self, group, name):
+        """Return the `name` entry point of `group` or raise ImportError"""
+        ep = self.get_entry_info(group, name)
+        if ep is None:
+            raise ImportError("Entry point %r not found" % ((group, name),))
+        return ep.load()
+
+    def get_entry_map(self, group=None):
+        """Return the entry point map for `group`, or the full entry map"""
+        try:
+            ep_map = self._ep_map
+        except AttributeError:
+            ep_map = self._ep_map = EntryPoint.parse_map(
+                self._get_metadata('entry_points.txt'), self
+            )
+        if group is not None:
+            return ep_map.get(group, {})
+        return ep_map
+
+    def get_entry_info(self, group, name):
+        """Return the EntryPoint object for `group`+`name`, or ``None``"""
+        return self.get_entry_map(group).get(name)
+
+    def insert_on(self, path, loc=None, replace=False):
+        """Ensure self.location is on path
+
+        If replace=False (default):
+            - If location is already in path anywhere, do nothing.
+            - Else:
+              - If it's an egg and its parent directory is on path,
+                insert just ahead of the parent.
+              - Else: add to the end of path.
+        If replace=True:
+            - If location is already on path anywhere (not eggs)
+              or higher priority than its parent (eggs)
+              do nothing.
+            - Else:
+              - If it's an egg and its parent directory is on path,
+                insert just ahead of the parent,
+                removing any lower-priority entries.
+              - Else: add it to the front of path.
+        """
+
+        loc = loc or self.location
+        if not loc:
+            return
+
+        nloc = _normalize_cached(loc)
+        bdir = os.path.dirname(nloc)
+        npath = [(p and _normalize_cached(p) or p) for p in path]
+
+        for p, item in enumerate(npath):
+            if item == nloc:
+                if replace:
+                    break
+                else:
+                    # don't modify path (even removing duplicates) if
+                    # found and not replace
+                    return
+            elif item == bdir and self.precedence == EGG_DIST:
+                # if it's an .egg, give it precedence over its directory
+                # UNLESS it's already been added to sys.path and replace=False
+                if (not replace) and nloc in npath[p:]:
+                    return
+                if path is sys.path:
+                    self.check_version_conflict()
+                path.insert(p, loc)
+                npath.insert(p, nloc)
+                break
+        else:
+            if path is sys.path:
+                self.check_version_conflict()
+            if replace:
+                path.insert(0, loc)
+            else:
+                path.append(loc)
+            return
+
+        # p is the spot where we found or inserted loc; now remove duplicates
+        while True:
+            try:
+                np = npath.index(nloc, p + 1)
+            except ValueError:
+                break
+            else:
+                del npath[np], path[np]
+                # ha!
+                p = np
+
+        return
+
+    def check_version_conflict(self):
+        if self.key == 'setuptools':
+            # ignore the inevitable setuptools self-conflicts  :(
+            return
+
+        nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt'))
+        loc = normalize_path(self.location)
+        for modname in self._get_metadata('top_level.txt'):
+            if (modname not in sys.modules or modname in nsp
+                    or modname in _namespace_packages):
+                continue
+            if modname in ('pkg_resources', 'setuptools', 'site'):
+                continue
+            fn = getattr(sys.modules[modname], '__file__', None)
+            if fn and (normalize_path(fn).startswith(loc) or
+                       fn.startswith(self.location)):
+                continue
+            issue_warning(
+                "Module %s was already imported from %s, but %s is being added"
+                " to sys.path" % (modname, fn, self.location),
+            )
+
+    def has_version(self):
+        try:
+            self.version
+        except ValueError:
+            issue_warning("Unbuilt egg for " + repr(self))
+            return False
+        return True
+
+    def clone(self, **kw):
+        """Copy this distribution, substituting in any changed keyword args"""
+        names = 'project_name version py_version platform location precedence'
+        for attr in names.split():
+            kw.setdefault(attr, getattr(self, attr, None))
+        kw.setdefault('metadata', self._provider)
+        return self.__class__(**kw)
+
+    @property
+    def extras(self):
+        return [dep for dep in self._dep_map if dep]
+
+
+class EggInfoDistribution(Distribution):
+    def _reload_version(self):
+        """
+        Packages installed by distutils (e.g. numpy or scipy),
+        which uses an old safe_version, and so
+        their version numbers can get mangled when
+        converted to filenames (e.g., 1.11.0.dev0+2329eae to
+        1.11.0.dev0_2329eae). These distributions will not be
+        parsed properly
+        downstream by Distribution and safe_version, so
+        take an extra step and try to get the version number from
+        the metadata file itself instead of the filename.
+        """
+        md_version = self._get_version()
+        if md_version:
+            self._version = md_version
+        return self
+
+
+class DistInfoDistribution(Distribution):
+    """
+    Wrap an actual or potential sys.path entry
+    w/metadata, .dist-info style.
+    """
+    PKG_INFO = 'METADATA'
+    EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])")
+
+    @property
+    def _parsed_pkg_info(self):
+        """Parse and cache metadata"""
+        try:
+            return self._pkg_info
+        except AttributeError:
+            metadata = self.get_metadata(self.PKG_INFO)
+            self._pkg_info = email.parser.Parser().parsestr(metadata)
+            return self._pkg_info
+
+    @property
+    def _dep_map(self):
+        try:
+            return self.__dep_map
+        except AttributeError:
+            self.__dep_map = self._compute_dependencies()
+            return self.__dep_map
+
+    def _compute_dependencies(self):
+        """Recompute this distribution's dependencies."""
+        dm = self.__dep_map = {None: []}
+
+        reqs = []
+        # Including any condition expressions
+        for req in self._parsed_pkg_info.get_all('Requires-Dist') or []:
+            reqs.extend(parse_requirements(req))
+
+        def reqs_for_extra(extra):
+            for req in reqs:
+                if not req.marker or req.marker.evaluate({'extra': extra}):
+                    yield req
+
+        common = frozenset(reqs_for_extra(None))
+        dm[None].extend(common)
+
+        for extra in self._parsed_pkg_info.get_all('Provides-Extra') or []:
+            s_extra = safe_extra(extra.strip())
+            dm[s_extra] = list(frozenset(reqs_for_extra(extra)) - common)
+
+        return dm
+
+
+_distributionImpl = {
+    '.egg': Distribution,
+    '.egg-info': EggInfoDistribution,
+    '.dist-info': DistInfoDistribution,
+}
+
+
+def issue_warning(*args, **kw):
+    level = 1
+    g = globals()
+    try:
+        # find the first stack frame that is *not* code in
+        # the pkg_resources module, to use for the warning
+        while sys._getframe(level).f_globals is g:
+            level += 1
+    except ValueError:
+        pass
+    warnings.warn(stacklevel=level + 1, *args, **kw)
+
+
+class RequirementParseError(ValueError):
+    def __str__(self):
+        return ' '.join(self.args)
+
+
+def parse_requirements(strs):
+    """Yield ``Requirement`` objects for each specification in `strs`
+
+    `strs` must be a string, or a (possibly-nested) iterable thereof.
+    """
+    # create a steppable iterator, so we can handle \-continuations
+    lines = iter(yield_lines(strs))
+
+    for line in lines:
+        # Drop comments -- a hash without a space may be in a URL.
+        if ' #' in line:
+            line = line[:line.find(' #')]
+        # If there is a line continuation, drop it, and append the next line.
+        if line.endswith('\\'):
+            line = line[:-2].strip()
+            try:
+                line += next(lines)
+            except StopIteration:
+                return
+        yield Requirement(line)
+
+
+class Requirement(packaging.requirements.Requirement):
+    def __init__(self, requirement_string):
+        """DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!"""
+        try:
+            super(Requirement, self).__init__(requirement_string)
+        except packaging.requirements.InvalidRequirement as e:
+            raise RequirementParseError(str(e))
+        self.unsafe_name = self.name
+        project_name = safe_name(self.name)
+        self.project_name, self.key = project_name, project_name.lower()
+        self.specs = [
+            (spec.operator, spec.version) for spec in self.specifier]
+        self.extras = tuple(map(safe_extra, self.extras))
+        self.hashCmp = (
+            self.key,
+            self.url,
+            self.specifier,
+            frozenset(self.extras),
+            str(self.marker) if self.marker else None,
+        )
+        self.__hash = hash(self.hashCmp)
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, Requirement) and
+            self.hashCmp == other.hashCmp
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __contains__(self, item):
+        if isinstance(item, Distribution):
+            if item.key != self.key:
+                return False
+
+            item = item.version
+
+        # Allow prereleases always in order to match the previous behavior of
+        # this method. In the future this should be smarter and follow PEP 440
+        # more accurately.
+        return self.specifier.contains(item, prereleases=True)
+
+    def __hash__(self):
+        return self.__hash
+
+    def __repr__(self):
+        return "Requirement.parse(%r)" % str(self)
+
+    @staticmethod
+    def parse(s):
+        req, = parse_requirements(s)
+        return req
+
+
+def _always_object(classes):
+    """
+    Ensure object appears in the mro even
+    for old-style classes.
+    """
+    if object not in classes:
+        return classes + (object,)
+    return classes
+
+
+def _find_adapter(registry, ob):
+    """Return an adapter factory for `ob` from `registry`"""
+    types = _always_object(inspect.getmro(getattr(ob, '__class__', type(ob))))
+    for t in types:
+        if t in registry:
+            return registry[t]
+
+
+def ensure_directory(path):
+    """Ensure that the parent directory of `path` exists"""
+    dirname = os.path.dirname(path)
+    py31compat.makedirs(dirname, exist_ok=True)
+
+
+def _bypass_ensure_directory(path):
+    """Sandbox-bypassing version of ensure_directory()"""
+    if not WRITE_SUPPORT:
+        raise IOError('"os.mkdir" not supported on this platform.')
+    dirname, filename = split(path)
+    if dirname and filename and not isdir(dirname):
+        _bypass_ensure_directory(dirname)
+        try:
+            mkdir(dirname, 0o755)
+        except FileExistsError:
+            pass
+
+
+def split_sections(s):
+    """Split a string or iterable thereof into (section, content) pairs
+
+    Each ``section`` is a stripped version of the section header ("[section]")
+    and each ``content`` is a list of stripped lines excluding blank lines and
+    comment-only lines.  If there are any such lines before the first section
+    header, they're returned in a first ``section`` of ``None``.
+    """
+    section = None
+    content = []
+    for line in yield_lines(s):
+        if line.startswith("["):
+            if line.endswith("]"):
+                if section or content:
+                    yield section, content
+                section = line[1:-1].strip()
+                content = []
+            else:
+                raise ValueError("Invalid section heading", line)
+        else:
+            content.append(line)
+
+    # wrap up last segment
+    yield section, content
+
+
+def _mkstemp(*args, **kw):
+    old_open = os.open
+    try:
+        # temporarily bypass sandboxing
+        os.open = os_open
+        return tempfile.mkstemp(*args, **kw)
+    finally:
+        # and then put it back
+        os.open = old_open
+
+
+# Silence the PEP440Warning by default, so that end users don't get hit by it
+# randomly just because they use pkg_resources. We want to append the rule
+# because we want earlier uses of filterwarnings to take precedence over this
+# one.
+warnings.filterwarnings("ignore", category=PEP440Warning, append=True)
+
+
+# from jaraco.functools 1.3
+def _call_aside(f, *args, **kwargs):
+    f(*args, **kwargs)
+    return f
+
+
+@_call_aside
+def _initialize(g=globals()):
+    "Set up global resource manager (deliberately not state-saved)"
+    manager = ResourceManager()
+    g['_manager'] = manager
+    g.update(
+        (name, getattr(manager, name))
+        for name in dir(manager)
+        if not name.startswith('_')
+    )
+
+
+@_call_aside
+def _initialize_master_working_set():
+    """
+    Prepare the master working set and make the ``require()``
+    API available.
+
+    This function has explicit effects on the global state
+    of pkg_resources. It is intended to be invoked once at
+    the initialization of this module.
+
+    Invocation by other packages is unsupported and done
+    at their own risk.
+    """
+    working_set = WorkingSet._build_master()
+    _declare_state('object', working_set=working_set)
+
+    require = working_set.require
+    iter_entry_points = working_set.iter_entry_points
+    add_activation_listener = working_set.subscribe
+    run_script = working_set.run_script
+    # backward compatibility
+    run_main = run_script
+    # Activate all distributions already on sys.path with replace=False and
+    # ensure that all distributions added to the working set in the future
+    # (e.g. by calling ``require()``) will get activated as well,
+    # with higher priority (replace=True).
+    tuple(
+        dist.activate(replace=False)
+        for dist in working_set
+    )
+    add_activation_listener(
+        lambda dist: dist.activate(replace=True),
+        existing=False,
+    )
+    working_set.entries = []
+    # match order
+    list(map(working_set.add_entry, sys.path))
+    globals().update(locals())
+
+class PkgResourcesDeprecationWarning(Warning):
+    """
+    Base class for warning about deprecations in ``pkg_resources``
+
+    This class is not derived from ``DeprecationWarning``, and as such is
+    visible by default.
+    """
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pkg_resources/py31compat.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pkg_resources/py31compat.py
new file mode 100644
index 0000000..a2d3007
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pkg_resources/py31compat.py
@@ -0,0 +1,23 @@
+import os
+import errno
+import sys
+
+from pip._vendor import six
+
+
+def _makedirs_31(path, exist_ok=False):
+    try:
+        os.makedirs(path)
+    except OSError as exc:
+        if not exist_ok or exc.errno != errno.EEXIST:
+            raise
+
+
+# rely on compatibility behavior until mode considerations
+#  and exists_ok considerations are disentangled.
+# See https://github.com/pypa/setuptools/pull/1083#issuecomment-315168663
+needs_makedirs = (
+    six.PY2 or
+    (3, 4) <= sys.version_info < (3, 4, 1)
+)
+makedirs = _makedirs_31 if needs_makedirs else os.makedirs
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/progress/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/progress/__init__.py
new file mode 100644
index 0000000..e434c25
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/progress/__init__.py
@@ -0,0 +1,177 @@
+# Copyright (c) 2012 Giorgos Verigakis <verigak@gmail.com>
+#
+# 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.
+
+from __future__ import division, print_function
+
+from collections import deque
+from datetime import timedelta
+from math import ceil
+from sys import stderr
+try:
+    from time import monotonic
+except ImportError:
+    from time import time as monotonic
+
+
+__version__ = '1.5'
+
+HIDE_CURSOR = '\x1b[?25l'
+SHOW_CURSOR = '\x1b[?25h'
+
+
+class Infinite(object):
+    file = stderr
+    sma_window = 10         # Simple Moving Average window
+    check_tty = True
+    hide_cursor = True
+
+    def __init__(self, message='', **kwargs):
+        self.index = 0
+        self.start_ts = monotonic()
+        self.avg = 0
+        self._avg_update_ts = self.start_ts
+        self._ts = self.start_ts
+        self._xput = deque(maxlen=self.sma_window)
+        for key, val in kwargs.items():
+            setattr(self, key, val)
+
+        self._width = 0
+        self.message = message
+
+        if self.file and self.is_tty():
+            if self.hide_cursor:
+                print(HIDE_CURSOR, end='', file=self.file)
+            print(self.message, end='', file=self.file)
+            self.file.flush()
+
+    def __getitem__(self, key):
+        if key.startswith('_'):
+            return None
+        return getattr(self, key, None)
+
+    @property
+    def elapsed(self):
+        return int(monotonic() - self.start_ts)
+
+    @property
+    def elapsed_td(self):
+        return timedelta(seconds=self.elapsed)
+
+    def update_avg(self, n, dt):
+        if n > 0:
+            xput_len = len(self._xput)
+            self._xput.append(dt / n)
+            now = monotonic()
+            # update when we're still filling _xput, then after every second
+            if (xput_len < self.sma_window or
+                    now - self._avg_update_ts > 1):
+                self.avg = sum(self._xput) / len(self._xput)
+                self._avg_update_ts = now
+
+    def update(self):
+        pass
+
+    def start(self):
+        pass
+
+    def clearln(self):
+        if self.file and self.is_tty():
+            print('\r\x1b[K', end='', file=self.file)
+
+    def write(self, s):
+        if self.file and self.is_tty():
+            line = self.message + s.ljust(self._width)
+            print('\r' + line, end='', file=self.file)
+            self._width = max(self._width, len(s))
+            self.file.flush()
+
+    def writeln(self, line):
+        if self.file and self.is_tty():
+            self.clearln()
+            print(line, end='', file=self.file)
+            self.file.flush()
+
+    def finish(self):
+        if self.file and self.is_tty():
+            print(file=self.file)
+            if self.hide_cursor:
+                print(SHOW_CURSOR, end='', file=self.file)
+
+    def is_tty(self):
+        return self.file.isatty() if self.check_tty else True
+
+    def next(self, n=1):
+        now = monotonic()
+        dt = now - self._ts
+        self.update_avg(n, dt)
+        self._ts = now
+        self.index = self.index + n
+        self.update()
+
+    def iter(self, it):
+        with self:
+            for x in it:
+                yield x
+                self.next()
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.finish()
+
+
+class Progress(Infinite):
+    def __init__(self, *args, **kwargs):
+        super(Progress, self).__init__(*args, **kwargs)
+        self.max = kwargs.get('max', 100)
+
+    @property
+    def eta(self):
+        return int(ceil(self.avg * self.remaining))
+
+    @property
+    def eta_td(self):
+        return timedelta(seconds=self.eta)
+
+    @property
+    def percent(self):
+        return self.progress * 100
+
+    @property
+    def progress(self):
+        return min(1, self.index / self.max)
+
+    @property
+    def remaining(self):
+        return max(self.max - self.index, 0)
+
+    def start(self):
+        self.update()
+
+    def goto(self, index):
+        incr = index - self.index
+        self.next(incr)
+
+    def iter(self, it):
+        try:
+            self.max = len(it)
+        except TypeError:
+            pass
+
+        with self:
+            for x in it:
+                yield x
+                self.next()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/progress/bar.py b/myenv/lib/python3.9/site-packages/pip/_vendor/progress/bar.py
new file mode 100644
index 0000000..8819efd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/progress/bar.py
@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2012 Giorgos Verigakis <verigak@gmail.com>
+#
+# 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.
+
+from __future__ import unicode_literals
+
+import sys
+
+from . import Progress
+
+
+class Bar(Progress):
+    width = 32
+    suffix = '%(index)d/%(max)d'
+    bar_prefix = ' |'
+    bar_suffix = '| '
+    empty_fill = ' '
+    fill = '#'
+
+    def update(self):
+        filled_length = int(self.width * self.progress)
+        empty_length = self.width - filled_length
+
+        message = self.message % self
+        bar = self.fill * filled_length
+        empty = self.empty_fill * empty_length
+        suffix = self.suffix % self
+        line = ''.join([message, self.bar_prefix, bar, empty, self.bar_suffix,
+                        suffix])
+        self.writeln(line)
+
+
+class ChargingBar(Bar):
+    suffix = '%(percent)d%%'
+    bar_prefix = ' '
+    bar_suffix = ' '
+    empty_fill = '∙'
+    fill = '█'
+
+
+class FillingSquaresBar(ChargingBar):
+    empty_fill = '▢'
+    fill = '▣'
+
+
+class FillingCirclesBar(ChargingBar):
+    empty_fill = '◯'
+    fill = '◉'
+
+
+class IncrementalBar(Bar):
+    if sys.platform.startswith('win'):
+        phases = (u' ', u'▌', u'█')
+    else:
+        phases = (' ', '▏', '▎', '▍', '▌', '▋', '▊', '▉', '█')
+
+    def update(self):
+        nphases = len(self.phases)
+        filled_len = self.width * self.progress
+        nfull = int(filled_len)                      # Number of full chars
+        phase = int((filled_len - nfull) * nphases)  # Phase of last char
+        nempty = self.width - nfull                  # Number of empty chars
+
+        message = self.message % self
+        bar = self.phases[-1] * nfull
+        current = self.phases[phase] if phase > 0 else ''
+        empty = self.empty_fill * max(0, nempty - len(current))
+        suffix = self.suffix % self
+        line = ''.join([message, self.bar_prefix, bar, current, empty,
+                        self.bar_suffix, suffix])
+        self.writeln(line)
+
+
+class PixelBar(IncrementalBar):
+    phases = ('⡀', '⡄', '⡆', '⡇', '⣇', '⣧', '⣷', '⣿')
+
+
+class ShadyBar(IncrementalBar):
+    phases = (' ', '░', '▒', '▓', '█')
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/progress/counter.py b/myenv/lib/python3.9/site-packages/pip/_vendor/progress/counter.py
new file mode 100644
index 0000000..d955ca4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/progress/counter.py
@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2012 Giorgos Verigakis <verigak@gmail.com>
+#
+# 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.
+
+from __future__ import unicode_literals
+from . import Infinite, Progress
+
+
+class Counter(Infinite):
+    def update(self):
+        self.write(str(self.index))
+
+
+class Countdown(Progress):
+    def update(self):
+        self.write(str(self.remaining))
+
+
+class Stack(Progress):
+    phases = (' ', '▁', '▂', '▃', '▄', '▅', '▆', '▇', '█')
+
+    def update(self):
+        nphases = len(self.phases)
+        i = min(nphases - 1, int(self.progress * nphases))
+        self.write(self.phases[i])
+
+
+class Pie(Stack):
+    phases = ('○', '◔', '◑', '◕', '●')
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/progress/spinner.py b/myenv/lib/python3.9/site-packages/pip/_vendor/progress/spinner.py
new file mode 100644
index 0000000..4e100ca
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/progress/spinner.py
@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2012 Giorgos Verigakis <verigak@gmail.com>
+#
+# 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.
+
+from __future__ import unicode_literals
+from . import Infinite
+
+
+class Spinner(Infinite):
+    phases = ('-', '\\', '|', '/')
+    hide_cursor = True
+
+    def update(self):
+        i = self.index % len(self.phases)
+        self.write(self.phases[i])
+
+
+class PieSpinner(Spinner):
+    phases = ['◷', '◶', '◵', '◴']
+
+
+class MoonSpinner(Spinner):
+    phases = ['◑', '◒', '◐', '◓']
+
+
+class LineSpinner(Spinner):
+    phases = ['⎺', '⎻', '⎼', '⎽', '⎼', '⎻']
+
+
+class PixelSpinner(Spinner):
+    phases = ['⣾', '⣷', '⣯', '⣟', '⡿', '⢿', '⣻', '⣽']
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/pyparsing.py b/myenv/lib/python3.9/site-packages/pip/_vendor/pyparsing.py
new file mode 100644
index 0000000..7ebc7eb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/pyparsing.py
@@ -0,0 +1,7107 @@
+# -*- coding: utf-8 -*-
+# module pyparsing.py
+#
+# Copyright (c) 2003-2019  Paul T. McGuire
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__doc__ = \
+"""
+pyparsing module - Classes and methods to define and execute parsing grammars
+=============================================================================
+
+The pyparsing module is an alternative approach to creating and
+executing simple grammars, vs. the traditional lex/yacc approach, or the
+use of regular expressions.  With pyparsing, you don't need to learn
+a new syntax for defining grammars or matching expressions - the parsing
+module provides a library of classes that you use to construct the
+grammar directly in Python.
+
+Here is a program to parse "Hello, World!" (or any greeting of the form
+``"<salutation>, <addressee>!"``), built up using :class:`Word`,
+:class:`Literal`, and :class:`And` elements
+(the :class:`'+'<ParserElement.__add__>` operators create :class:`And` expressions,
+and the strings are auto-converted to :class:`Literal` expressions)::
+
+    from pip._vendor.pyparsing import Word, alphas
+
+    # define grammar of a greeting
+    greet = Word(alphas) + "," + Word(alphas) + "!"
+
+    hello = "Hello, World!"
+    print (hello, "->", greet.parseString(hello))
+
+The program outputs the following::
+
+    Hello, World! -> ['Hello', ',', 'World', '!']
+
+The Python representation of the grammar is quite readable, owing to the
+self-explanatory class names, and the use of '+', '|' and '^' operators.
+
+The :class:`ParseResults` object returned from
+:class:`ParserElement.parseString` can be
+accessed as a nested list, a dictionary, or an object with named
+attributes.
+
+The pyparsing module handles some of the problems that are typically
+vexing when writing text parsers:
+
+  - extra or missing whitespace (the above program will also handle
+    "Hello,World!", "Hello  ,  World  !", etc.)
+  - quoted strings
+  - embedded comments
+
+
+Getting Started -
+-----------------
+Visit the classes :class:`ParserElement` and :class:`ParseResults` to
+see the base classes that most other pyparsing
+classes inherit from. Use the docstrings for examples of how to:
+
+ - construct literal match expressions from :class:`Literal` and
+   :class:`CaselessLiteral` classes
+ - construct character word-group expressions using the :class:`Word`
+   class
+ - see how to create repetitive expressions using :class:`ZeroOrMore`
+   and :class:`OneOrMore` classes
+ - use :class:`'+'<And>`, :class:`'|'<MatchFirst>`, :class:`'^'<Or>`,
+   and :class:`'&'<Each>` operators to combine simple expressions into
+   more complex ones
+ - associate names with your parsed results using
+   :class:`ParserElement.setResultsName`
+ - access the parsed data, which is returned as a :class:`ParseResults`
+   object
+ - find some helpful expression short-cuts like :class:`delimitedList`
+   and :class:`oneOf`
+ - find more useful common expressions in the :class:`pyparsing_common`
+   namespace class
+"""
+
+__version__ = "2.4.7"
+__versionTime__ = "30 Mar 2020 00:43 UTC"
+__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"
+
+import string
+from weakref import ref as wkref
+import copy
+import sys
+import warnings
+import re
+import sre_constants
+import collections
+import pprint
+import traceback
+import types
+from datetime import datetime
+from operator import itemgetter
+import itertools
+from functools import wraps
+from contextlib import contextmanager
+
+try:
+    # Python 3
+    from itertools import filterfalse
+except ImportError:
+    from itertools import ifilterfalse as filterfalse
+
+try:
+    from _thread import RLock
+except ImportError:
+    from threading import RLock
+
+try:
+    # Python 3
+    from collections.abc import Iterable
+    from collections.abc import MutableMapping, Mapping
+except ImportError:
+    # Python 2.7
+    from collections import Iterable
+    from collections import MutableMapping, Mapping
+
+try:
+    from collections import OrderedDict as _OrderedDict
+except ImportError:
+    try:
+        from ordereddict import OrderedDict as _OrderedDict
+    except ImportError:
+        _OrderedDict = None
+
+try:
+    from types import SimpleNamespace
+except ImportError:
+    class SimpleNamespace: pass
+
+# version compatibility configuration
+__compat__ = SimpleNamespace()
+__compat__.__doc__ = """
+    A cross-version compatibility configuration for pyparsing features that will be
+    released in a future version. By setting values in this configuration to True,
+    those features can be enabled in prior versions for compatibility development
+    and testing.
+
+     - collect_all_And_tokens - flag to enable fix for Issue #63 that fixes erroneous grouping
+       of results names when an And expression is nested within an Or or MatchFirst; set to
+       True to enable bugfix released in pyparsing 2.3.0, or False to preserve
+       pre-2.3.0 handling of named results
+"""
+__compat__.collect_all_And_tokens = True
+
+__diag__ = SimpleNamespace()
+__diag__.__doc__ = """
+Diagnostic configuration (all default to False)
+     - warn_multiple_tokens_in_named_alternation - flag to enable warnings when a results
+       name is defined on a MatchFirst or Or expression with one or more And subexpressions
+       (only warns if __compat__.collect_all_And_tokens is False)
+     - warn_ungrouped_named_tokens_in_collection - flag to enable warnings when a results
+       name is defined on a containing expression with ungrouped subexpressions that also
+       have results names
+     - warn_name_set_on_empty_Forward - flag to enable warnings whan a Forward is defined
+       with a results name, but has no contents defined
+     - warn_on_multiple_string_args_to_oneof - flag to enable warnings whan oneOf is
+       incorrectly called with multiple str arguments
+     - enable_debug_on_named_expressions - flag to auto-enable debug on all subsequent
+       calls to ParserElement.setName()
+"""
+__diag__.warn_multiple_tokens_in_named_alternation = False
+__diag__.warn_ungrouped_named_tokens_in_collection = False
+__diag__.warn_name_set_on_empty_Forward = False
+__diag__.warn_on_multiple_string_args_to_oneof = False
+__diag__.enable_debug_on_named_expressions = False
+__diag__._all_names = [nm for nm in vars(__diag__) if nm.startswith("enable_") or nm.startswith("warn_")]
+
+def _enable_all_warnings():
+    __diag__.warn_multiple_tokens_in_named_alternation = True
+    __diag__.warn_ungrouped_named_tokens_in_collection = True
+    __diag__.warn_name_set_on_empty_Forward = True
+    __diag__.warn_on_multiple_string_args_to_oneof = True
+__diag__.enable_all_warnings = _enable_all_warnings
+
+
+__all__ = ['__version__', '__versionTime__', '__author__', '__compat__', '__diag__',
+           'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',
+           'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',
+           'PrecededBy', 'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',
+           'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',
+           'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',
+           'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter',
+           'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore', 'Char',
+           'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',
+           'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',
+           'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums',
+           'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno',
+           'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',
+           'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',
+           'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity',
+           'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',
+           'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',
+           'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation', 'locatedExpr', 'withClass',
+           'CloseMatch', 'tokenMap', 'pyparsing_common', 'pyparsing_unicode', 'unicode_set',
+           'conditionAsParseAction', 're',
+           ]
+
+system_version = tuple(sys.version_info)[:3]
+PY_3 = system_version[0] == 3
+if PY_3:
+    _MAX_INT = sys.maxsize
+    basestring = str
+    unichr = chr
+    unicode = str
+    _ustr = str
+
+    # build list of single arg builtins, that can be used as parse actions
+    singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max]
+
+else:
+    _MAX_INT = sys.maxint
+    range = xrange
+
+    def _ustr(obj):
+        """Drop-in replacement for str(obj) that tries to be Unicode
+        friendly. It first tries str(obj). If that fails with
+        a UnicodeEncodeError, then it tries unicode(obj). It then
+        < returns the unicode object | encodes it with the default
+        encoding | ... >.
+        """
+        if isinstance(obj, unicode):
+            return obj
+
+        try:
+            # If this works, then _ustr(obj) has the same behaviour as str(obj), so
+            # it won't break any existing code.
+            return str(obj)
+
+        except UnicodeEncodeError:
+            # Else encode it
+            ret = unicode(obj).encode(sys.getdefaultencoding(), 'xmlcharrefreplace')
+            xmlcharref = Regex(r'&#\d+;')
+            xmlcharref.setParseAction(lambda t: '\\u' + hex(int(t[0][2:-1]))[2:])
+            return xmlcharref.transformString(ret)
+
+    # build list of single arg builtins, tolerant of Python version, that can be used as parse actions
+    singleArgBuiltins = []
+    import __builtin__
+
+    for fname in "sum len sorted reversed list tuple set any all min max".split():
+        try:
+            singleArgBuiltins.append(getattr(__builtin__, fname))
+        except AttributeError:
+            continue
+
+_generatorType = type((y for y in range(1)))
+
+def _xml_escape(data):
+    """Escape &, <, >, ", ', etc. in a string of data."""
+
+    # ampersand must be replaced first
+    from_symbols = '&><"\''
+    to_symbols = ('&' + s + ';' for s in "amp gt lt quot apos".split())
+    for from_, to_ in zip(from_symbols, to_symbols):
+        data = data.replace(from_, to_)
+    return data
+
+alphas = string.ascii_uppercase + string.ascii_lowercase
+nums = "0123456789"
+hexnums = nums + "ABCDEFabcdef"
+alphanums = alphas + nums
+_bslash = chr(92)
+printables = "".join(c for c in string.printable if c not in string.whitespace)
+
+
+def conditionAsParseAction(fn, message=None, fatal=False):
+    msg = message if message is not None else "failed user-defined condition"
+    exc_type = ParseFatalException if fatal else ParseException
+    fn = _trim_arity(fn)
+
+    @wraps(fn)
+    def pa(s, l, t):
+        if not bool(fn(s, l, t)):
+            raise exc_type(s, l, msg)
+
+    return pa
+
+class ParseBaseException(Exception):
+    """base exception class for all parsing runtime exceptions"""
+    # Performance tuning: we construct a *lot* of these, so keep this
+    # constructor as small and fast as possible
+    def __init__(self, pstr, loc=0, msg=None, elem=None):
+        self.loc = loc
+        if msg is None:
+            self.msg = pstr
+            self.pstr = ""
+        else:
+            self.msg = msg
+            self.pstr = pstr
+        self.parserElement = elem
+        self.args = (pstr, loc, msg)
+
+    @classmethod
+    def _from_exception(cls, pe):
+        """
+        internal factory method to simplify creating one type of ParseException
+        from another - avoids having __init__ signature conflicts among subclasses
+        """
+        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement)
+
+    def __getattr__(self, aname):
+        """supported attributes by name are:
+           - lineno - returns the line number of the exception text
+           - col - returns the column number of the exception text
+           - line - returns the line containing the exception text
+        """
+        if aname == "lineno":
+            return lineno(self.loc, self.pstr)
+        elif aname in ("col", "column"):
+            return col(self.loc, self.pstr)
+        elif aname == "line":
+            return line(self.loc, self.pstr)
+        else:
+            raise AttributeError(aname)
+
+    def __str__(self):
+        if self.pstr:
+            if self.loc >= len(self.pstr):
+                foundstr = ', found end of text'
+            else:
+                foundstr = (', found %r' % self.pstr[self.loc:self.loc + 1]).replace(r'\\', '\\')
+        else:
+            foundstr = ''
+        return ("%s%s  (at char %d), (line:%d, col:%d)" %
+                   (self.msg, foundstr, self.loc, self.lineno, self.column))
+    def __repr__(self):
+        return _ustr(self)
+    def markInputline(self, markerString=">!<"):
+        """Extracts the exception line from the input string, and marks
+           the location of the exception with a special symbol.
+        """
+        line_str = self.line
+        line_column = self.column - 1
+        if markerString:
+            line_str = "".join((line_str[:line_column],
+                                markerString, line_str[line_column:]))
+        return line_str.strip()
+    def __dir__(self):
+        return "lineno col line".split() + dir(type(self))
+
+class ParseException(ParseBaseException):
+    """
+    Exception thrown when parse expressions don't match class;
+    supported attributes by name are:
+    - lineno - returns the line number of the exception text
+    - col - returns the column number of the exception text
+    - line - returns the line containing the exception text
+
+    Example::
+
+        try:
+            Word(nums).setName("integer").parseString("ABC")
+        except ParseException as pe:
+            print(pe)
+            print("column: {}".format(pe.col))
+
+    prints::
+
+       Expected integer (at char 0), (line:1, col:1)
+        column: 1
+
+    """
+
+    @staticmethod
+    def explain(exc, depth=16):
+        """
+        Method to take an exception and translate the Python internal traceback into a list
+        of the pyparsing expressions that caused the exception to be raised.
+
+        Parameters:
+
+         - exc - exception raised during parsing (need not be a ParseException, in support
+           of Python exceptions that might be raised in a parse action)
+         - depth (default=16) - number of levels back in the stack trace to list expression
+           and function names; if None, the full stack trace names will be listed; if 0, only
+           the failing input line, marker, and exception string will be shown
+
+        Returns a multi-line string listing the ParserElements and/or function names in the
+        exception's stack trace.
+
+        Note: the diagnostic output will include string representations of the expressions
+        that failed to parse. These representations will be more helpful if you use `setName` to
+        give identifiable names to your expressions. Otherwise they will use the default string
+        forms, which may be cryptic to read.
+
+        explain() is only supported under Python 3.
+        """
+        import inspect
+
+        if depth is None:
+            depth = sys.getrecursionlimit()
+        ret = []
+        if isinstance(exc, ParseBaseException):
+            ret.append(exc.line)
+            ret.append(' ' * (exc.col - 1) + '^')
+        ret.append("{0}: {1}".format(type(exc).__name__, exc))
+
+        if depth > 0:
+            callers = inspect.getinnerframes(exc.__traceback__, context=depth)
+            seen = set()
+            for i, ff in enumerate(callers[-depth:]):
+                frm = ff[0]
+
+                f_self = frm.f_locals.get('self', None)
+                if isinstance(f_self, ParserElement):
+                    if frm.f_code.co_name not in ('parseImpl', '_parseNoCache'):
+                        continue
+                    if f_self in seen:
+                        continue
+                    seen.add(f_self)
+
+                    self_type = type(f_self)
+                    ret.append("{0}.{1} - {2}".format(self_type.__module__,
+                                                      self_type.__name__,
+                                                      f_self))
+                elif f_self is not None:
+                    self_type = type(f_self)
+                    ret.append("{0}.{1}".format(self_type.__module__,
+                                                self_type.__name__))
+                else:
+                    code = frm.f_code
+                    if code.co_name in ('wrapper', '<module>'):
+                        continue
+
+                    ret.append("{0}".format(code.co_name))
+
+                depth -= 1
+                if not depth:
+                    break
+
+        return '\n'.join(ret)
+
+
+class ParseFatalException(ParseBaseException):
+    """user-throwable exception thrown when inconsistent parse content
+       is found; stops all parsing immediately"""
+    pass
+
+class ParseSyntaxException(ParseFatalException):
+    """just like :class:`ParseFatalException`, but thrown internally
+    when an :class:`ErrorStop<And._ErrorStop>` ('-' operator) indicates
+    that parsing is to stop immediately because an unbacktrackable
+    syntax error has been found.
+    """
+    pass
+
+#~ class ReparseException(ParseBaseException):
+    #~ """Experimental class - parse actions can raise this exception to cause
+       #~ pyparsing to reparse the input string:
+        #~ - with a modified input string, and/or
+        #~ - with a modified start location
+       #~ Set the values of the ReparseException in the constructor, and raise the
+       #~ exception in a parse action to cause pyparsing to use the new string/location.
+       #~ Setting the values as None causes no change to be made.
+       #~ """
+    #~ def __init_( self, newstring, restartLoc ):
+        #~ self.newParseText = newstring
+        #~ self.reparseLoc = restartLoc
+
+class RecursiveGrammarException(Exception):
+    """exception thrown by :class:`ParserElement.validate` if the
+    grammar could be improperly recursive
+    """
+    def __init__(self, parseElementList):
+        self.parseElementTrace = parseElementList
+
+    def __str__(self):
+        return "RecursiveGrammarException: %s" % self.parseElementTrace
+
+class _ParseResultsWithOffset(object):
+    def __init__(self, p1, p2):
+        self.tup = (p1, p2)
+    def __getitem__(self, i):
+        return self.tup[i]
+    def __repr__(self):
+        return repr(self.tup[0])
+    def setOffset(self, i):
+        self.tup = (self.tup[0], i)
+
+class ParseResults(object):
+    """Structured parse results, to provide multiple means of access to
+    the parsed data:
+
+       - as a list (``len(results)``)
+       - by list index (``results[0], results[1]``, etc.)
+       - by attribute (``results.<resultsName>`` - see :class:`ParserElement.setResultsName`)
+
+    Example::
+
+        integer = Word(nums)
+        date_str = (integer.setResultsName("year") + '/'
+                        + integer.setResultsName("month") + '/'
+                        + integer.setResultsName("day"))
+        # equivalent form:
+        # date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+        # parseString returns a ParseResults object
+        result = date_str.parseString("1999/12/31")
+
+        def test(s, fn=repr):
+            print("%s -> %s" % (s, fn(eval(s))))
+        test("list(result)")
+        test("result[0]")
+        test("result['month']")
+        test("result.day")
+        test("'month' in result")
+        test("'minutes' in result")
+        test("result.dump()", str)
+
+    prints::
+
+        list(result) -> ['1999', '/', '12', '/', '31']
+        result[0] -> '1999'
+        result['month'] -> '12'
+        result.day -> '31'
+        'month' in result -> True
+        'minutes' in result -> False
+        result.dump() -> ['1999', '/', '12', '/', '31']
+        - day: 31
+        - month: 12
+        - year: 1999
+    """
+    def __new__(cls, toklist=None, name=None, asList=True, modal=True):
+        if isinstance(toklist, cls):
+            return toklist
+        retobj = object.__new__(cls)
+        retobj.__doinit = True
+        return retobj
+
+    # Performance tuning: we construct a *lot* of these, so keep this
+    # constructor as small and fast as possible
+    def __init__(self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance):
+        if self.__doinit:
+            self.__doinit = False
+            self.__name = None
+            self.__parent = None
+            self.__accumNames = {}
+            self.__asList = asList
+            self.__modal = modal
+            if toklist is None:
+                toklist = []
+            if isinstance(toklist, list):
+                self.__toklist = toklist[:]
+            elif isinstance(toklist, _generatorType):
+                self.__toklist = list(toklist)
+            else:
+                self.__toklist = [toklist]
+            self.__tokdict = dict()
+
+        if name is not None and name:
+            if not modal:
+                self.__accumNames[name] = 0
+            if isinstance(name, int):
+                name = _ustr(name)  # will always return a str, but use _ustr for consistency
+            self.__name = name
+            if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None, '', [])):
+                if isinstance(toklist, basestring):
+                    toklist = [toklist]
+                if asList:
+                    if isinstance(toklist, ParseResults):
+                        self[name] = _ParseResultsWithOffset(ParseResults(toklist.__toklist), 0)
+                    else:
+                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]), 0)
+                    self[name].__name = name
+                else:
+                    try:
+                        self[name] = toklist[0]
+                    except (KeyError, TypeError, IndexError):
+                        self[name] = toklist
+
+    def __getitem__(self, i):
+        if isinstance(i, (int, slice)):
+            return self.__toklist[i]
+        else:
+            if i not in self.__accumNames:
+                return self.__tokdict[i][-1][0]
+            else:
+                return ParseResults([v[0] for v in self.__tokdict[i]])
+
+    def __setitem__(self, k, v, isinstance=isinstance):
+        if isinstance(v, _ParseResultsWithOffset):
+            self.__tokdict[k] = self.__tokdict.get(k, list()) + [v]
+            sub = v[0]
+        elif isinstance(k, (int, slice)):
+            self.__toklist[k] = v
+            sub = v
+        else:
+            self.__tokdict[k] = self.__tokdict.get(k, list()) + [_ParseResultsWithOffset(v, 0)]
+            sub = v
+        if isinstance(sub, ParseResults):
+            sub.__parent = wkref(self)
+
+    def __delitem__(self, i):
+        if isinstance(i, (int, slice)):
+            mylen = len(self.__toklist)
+            del self.__toklist[i]
+
+            # convert int to slice
+            if isinstance(i, int):
+                if i < 0:
+                    i += mylen
+                i = slice(i, i + 1)
+            # get removed indices
+            removed = list(range(*i.indices(mylen)))
+            removed.reverse()
+            # fixup indices in token dictionary
+            for name, occurrences in self.__tokdict.items():
+                for j in removed:
+                    for k, (value, position) in enumerate(occurrences):
+                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))
+        else:
+            del self.__tokdict[i]
+
+    def __contains__(self, k):
+        return k in self.__tokdict
+
+    def __len__(self):
+        return len(self.__toklist)
+
+    def __bool__(self):
+        return (not not self.__toklist)
+    __nonzero__ = __bool__
+
+    def __iter__(self):
+        return iter(self.__toklist)
+
+    def __reversed__(self):
+        return iter(self.__toklist[::-1])
+
+    def _iterkeys(self):
+        if hasattr(self.__tokdict, "iterkeys"):
+            return self.__tokdict.iterkeys()
+        else:
+            return iter(self.__tokdict)
+
+    def _itervalues(self):
+        return (self[k] for k in self._iterkeys())
+
+    def _iteritems(self):
+        return ((k, self[k]) for k in self._iterkeys())
+
+    if PY_3:
+        keys = _iterkeys
+        """Returns an iterator of all named result keys."""
+
+        values = _itervalues
+        """Returns an iterator of all named result values."""
+
+        items = _iteritems
+        """Returns an iterator of all named result key-value tuples."""
+
+    else:
+        iterkeys = _iterkeys
+        """Returns an iterator of all named result keys (Python 2.x only)."""
+
+        itervalues = _itervalues
+        """Returns an iterator of all named result values (Python 2.x only)."""
+
+        iteritems = _iteritems
+        """Returns an iterator of all named result key-value tuples (Python 2.x only)."""
+
+        def keys(self):
+            """Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.iterkeys())
+
+        def values(self):
+            """Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.itervalues())
+
+        def items(self):
+            """Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.iteritems())
+
+    def haskeys(self):
+        """Since keys() returns an iterator, this method is helpful in bypassing
+           code that looks for the existence of any defined results names."""
+        return bool(self.__tokdict)
+
+    def pop(self, *args, **kwargs):
+        """
+        Removes and returns item at specified index (default= ``last``).
+        Supports both ``list`` and ``dict`` semantics for ``pop()``. If
+        passed no argument or an integer argument, it will use ``list``
+        semantics and pop tokens from the list of parsed tokens. If passed
+        a non-integer argument (most likely a string), it will use ``dict``
+        semantics and pop the corresponding value from any defined results
+        names. A second default return value argument is supported, just as in
+        ``dict.pop()``.
+
+        Example::
+
+            def remove_first(tokens):
+                tokens.pop(0)
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']
+
+            label = Word(alphas)
+            patt = label("LABEL") + OneOrMore(Word(nums))
+            print(patt.parseString("AAB 123 321").dump())
+
+            # Use pop() in a parse action to remove named result (note that corresponding value is not
+            # removed from list form of results)
+            def remove_LABEL(tokens):
+                tokens.pop("LABEL")
+                return tokens
+            patt.addParseAction(remove_LABEL)
+            print(patt.parseString("AAB 123 321").dump())
+
+        prints::
+
+            ['AAB', '123', '321']
+            - LABEL: AAB
+
+            ['AAB', '123', '321']
+        """
+        if not args:
+            args = [-1]
+        for k, v in kwargs.items():
+            if k == 'default':
+                args = (args[0], v)
+            else:
+                raise TypeError("pop() got an unexpected keyword argument '%s'" % k)
+        if (isinstance(args[0], int)
+                or len(args) == 1
+                or args[0] in self):
+            index = args[0]
+            ret = self[index]
+            del self[index]
+            return ret
+        else:
+            defaultvalue = args[1]
+            return defaultvalue
+
+    def get(self, key, defaultValue=None):
+        """
+        Returns named result matching the given key, or if there is no
+        such name, then returns the given ``defaultValue`` or ``None`` if no
+        ``defaultValue`` is specified.
+
+        Similar to ``dict.get()``.
+
+        Example::
+
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+            result = date_str.parseString("1999/12/31")
+            print(result.get("year")) # -> '1999'
+            print(result.get("hour", "not specified")) # -> 'not specified'
+            print(result.get("hour")) # -> None
+        """
+        if key in self:
+            return self[key]
+        else:
+            return defaultValue
+
+    def insert(self, index, insStr):
+        """
+        Inserts new element at location index in the list of parsed tokens.
+
+        Similar to ``list.insert()``.
+
+        Example::
+
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+
+            # use a parse action to insert the parse location in the front of the parsed results
+            def insert_locn(locn, tokens):
+                tokens.insert(0, locn)
+            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321']
+        """
+        self.__toklist.insert(index, insStr)
+        # fixup indices in token dictionary
+        for name, occurrences in self.__tokdict.items():
+            for k, (value, position) in enumerate(occurrences):
+                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))
+
+    def append(self, item):
+        """
+        Add single element to end of ParseResults list of elements.
+
+        Example::
+
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+
+            # use a parse action to compute the sum of the parsed integers, and add it to the end
+            def append_sum(tokens):
+                tokens.append(sum(map(int, tokens)))
+            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444]
+        """
+        self.__toklist.append(item)
+
+    def extend(self, itemseq):
+        """
+        Add sequence of elements to end of ParseResults list of elements.
+
+        Example::
+
+            patt = OneOrMore(Word(alphas))
+
+            # use a parse action to append the reverse of the matched strings, to make a palindrome
+            def make_palindrome(tokens):
+                tokens.extend(reversed([t[::-1] for t in tokens]))
+                return ''.join(tokens)
+            print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
+        """
+        if isinstance(itemseq, ParseResults):
+            self.__iadd__(itemseq)
+        else:
+            self.__toklist.extend(itemseq)
+
+    def clear(self):
+        """
+        Clear all elements and results names.
+        """
+        del self.__toklist[:]
+        self.__tokdict.clear()
+
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError:
+            return ""
+
+    def __add__(self, other):
+        ret = self.copy()
+        ret += other
+        return ret
+
+    def __iadd__(self, other):
+        if other.__tokdict:
+            offset = len(self.__toklist)
+            addoffset = lambda a: offset if a < 0 else a + offset
+            otheritems = other.__tokdict.items()
+            otherdictitems = [(k, _ParseResultsWithOffset(v[0], addoffset(v[1])))
+                              for k, vlist in otheritems for v in vlist]
+            for k, v in otherdictitems:
+                self[k] = v
+                if isinstance(v[0], ParseResults):
+                    v[0].__parent = wkref(self)
+
+        self.__toklist += other.__toklist
+        self.__accumNames.update(other.__accumNames)
+        return self
+
+    def __radd__(self, other):
+        if isinstance(other, int) and other == 0:
+            # useful for merging many ParseResults using sum() builtin
+            return self.copy()
+        else:
+            # this may raise a TypeError - so be it
+            return other + self
+
+    def __repr__(self):
+        return "(%s, %s)" % (repr(self.__toklist), repr(self.__tokdict))
+
+    def __str__(self):
+        return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']'
+
+    def _asStringList(self, sep=''):
+        out = []
+        for item in self.__toklist:
+            if out and sep:
+                out.append(sep)
+            if isinstance(item, ParseResults):
+                out += item._asStringList()
+            else:
+                out.append(_ustr(item))
+        return out
+
+    def asList(self):
+        """
+        Returns the parse results as a nested list of matching tokens, all converted to strings.
+
+        Example::
+
+            patt = OneOrMore(Word(alphas))
+            result = patt.parseString("sldkj lsdkj sldkj")
+            # even though the result prints in string-like form, it is actually a pyparsing ParseResults
+            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']
+
+            # Use asList() to create an actual list
+            result_list = result.asList()
+            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']
+        """
+        return [res.asList() if isinstance(res, ParseResults) else res for res in self.__toklist]
+
+    def asDict(self):
+        """
+        Returns the named parse results as a nested dictionary.
+
+        Example::
+
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+            result = date_str.parseString('12/31/1999')
+            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
+
+            result_dict = result.asDict()
+            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}
+
+            # even though a ParseResults supports dict-like access, sometime you just need to have a dict
+            import json
+            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
+            print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"}
+        """
+        if PY_3:
+            item_fn = self.items
+        else:
+            item_fn = self.iteritems
+
+        def toItem(obj):
+            if isinstance(obj, ParseResults):
+                if obj.haskeys():
+                    return obj.asDict()
+                else:
+                    return [toItem(v) for v in obj]
+            else:
+                return obj
+
+        return dict((k, toItem(v)) for k, v in item_fn())
+
+    def copy(self):
+        """
+        Returns a new copy of a :class:`ParseResults` object.
+        """
+        ret = ParseResults(self.__toklist)
+        ret.__tokdict = dict(self.__tokdict.items())
+        ret.__parent = self.__parent
+        ret.__accumNames.update(self.__accumNames)
+        ret.__name = self.__name
+        return ret
+
+    def asXML(self, doctag=None, namedItemsOnly=False, indent="", formatted=True):
+        """
+        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.
+        """
+        nl = "\n"
+        out = []
+        namedItems = dict((v[1], k) for (k, vlist) in self.__tokdict.items()
+                          for v in vlist)
+        nextLevelIndent = indent + "  "
+
+        # collapse out indents if formatting is not desired
+        if not formatted:
+            indent = ""
+            nextLevelIndent = ""
+            nl = ""
+
+        selfTag = None
+        if doctag is not None:
+            selfTag = doctag
+        else:
+            if self.__name:
+                selfTag = self.__name
+
+        if not selfTag:
+            if namedItemsOnly:
+                return ""
+            else:
+                selfTag = "ITEM"
+
+        out += [nl, indent, "<", selfTag, ">"]
+
+        for i, res in enumerate(self.__toklist):
+            if isinstance(res, ParseResults):
+                if i in namedItems:
+                    out += [res.asXML(namedItems[i],
+                                      namedItemsOnly and doctag is None,
+                                      nextLevelIndent,
+                                      formatted)]
+                else:
+                    out += [res.asXML(None,
+                                      namedItemsOnly and doctag is None,
+                                      nextLevelIndent,
+                                      formatted)]
+            else:
+                # individual token, see if there is a name for it
+                resTag = None
+                if i in namedItems:
+                    resTag = namedItems[i]
+                if not resTag:
+                    if namedItemsOnly:
+                        continue
+                    else:
+                        resTag = "ITEM"
+                xmlBodyText = _xml_escape(_ustr(res))
+                out += [nl, nextLevelIndent, "<", resTag, ">",
+                        xmlBodyText,
+                                                "</", resTag, ">"]
+
+        out += [nl, indent, "</", selfTag, ">"]
+        return "".join(out)
+
+    def __lookup(self, sub):
+        for k, vlist in self.__tokdict.items():
+            for v, loc in vlist:
+                if sub is v:
+                    return k
+        return None
+
+    def getName(self):
+        r"""
+        Returns the results name for this token expression. Useful when several
+        different expressions might match at a particular location.
+
+        Example::
+
+            integer = Word(nums)
+            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
+            house_number_expr = Suppress('#') + Word(nums, alphanums)
+            user_data = (Group(house_number_expr)("house_number")
+                        | Group(ssn_expr)("ssn")
+                        | Group(integer)("age"))
+            user_info = OneOrMore(user_data)
+
+            result = user_info.parseString("22 111-22-3333 #221B")
+            for item in result:
+                print(item.getName(), ':', item[0])
+
+        prints::
+
+            age : 22
+            ssn : 111-22-3333
+            house_number : 221B
+        """
+        if self.__name:
+            return self.__name
+        elif self.__parent:
+            par = self.__parent()
+            if par:
+                return par.__lookup(self)
+            else:
+                return None
+        elif (len(self) == 1
+              and len(self.__tokdict) == 1
+              and next(iter(self.__tokdict.values()))[0][1] in (0, -1)):
+            return next(iter(self.__tokdict.keys()))
+        else:
+            return None
+
+    def dump(self, indent='', full=True, include_list=True, _depth=0):
+        """
+        Diagnostic method for listing out the contents of
+        a :class:`ParseResults`. Accepts an optional ``indent`` argument so
+        that this string can be embedded in a nested display of other data.
+
+        Example::
+
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+            result = date_str.parseString('12/31/1999')
+            print(result.dump())
+
+        prints::
+
+            ['12', '/', '31', '/', '1999']
+            - day: 1999
+            - month: 31
+            - year: 12
+        """
+        out = []
+        NL = '\n'
+        if include_list:
+            out.append(indent + _ustr(self.asList()))
+        else:
+            out.append('')
+
+        if full:
+            if self.haskeys():
+                items = sorted((str(k), v) for k, v in self.items())
+                for k, v in items:
+                    if out:
+                        out.append(NL)
+                    out.append("%s%s- %s: " % (indent, ('  ' * _depth), k))
+                    if isinstance(v, ParseResults):
+                        if v:
+                            out.append(v.dump(indent=indent, full=full, include_list=include_list, _depth=_depth + 1))
+                        else:
+                            out.append(_ustr(v))
+                    else:
+                        out.append(repr(v))
+            elif any(isinstance(vv, ParseResults) for vv in self):
+                v = self
+                for i, vv in enumerate(v):
+                    if isinstance(vv, ParseResults):
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,
+                                                            ('  ' * (_depth)),
+                                                            i,
+                                                            indent,
+                                                            ('  ' * (_depth + 1)),
+                                                            vv.dump(indent=indent,
+                                                                    full=full,
+                                                                    include_list=include_list,
+                                                                    _depth=_depth + 1)))
+                    else:
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,
+                                                            ('  ' * (_depth)),
+                                                            i,
+                                                            indent,
+                                                            ('  ' * (_depth + 1)),
+                                                            _ustr(vv)))
+
+        return "".join(out)
+
+    def pprint(self, *args, **kwargs):
+        """
+        Pretty-printer for parsed results as a list, using the
+        `pprint <https://docs.python.org/3/library/pprint.html>`_ module.
+        Accepts additional positional or keyword args as defined for
+        `pprint.pprint <https://docs.python.org/3/library/pprint.html#pprint.pprint>`_ .
+
+        Example::
+
+            ident = Word(alphas, alphanums)
+            num = Word(nums)
+            func = Forward()
+            term = ident | num | Group('(' + func + ')')
+            func <<= ident + Group(Optional(delimitedList(term)))
+            result = func.parseString("fna a,b,(fnb c,d,200),100")
+            result.pprint(width=40)
+
+        prints::
+
+            ['fna',
+             ['a',
+              'b',
+              ['(', 'fnb', ['c', 'd', '200'], ')'],
+              '100']]
+        """
+        pprint.pprint(self.asList(), *args, **kwargs)
+
+    # add support for pickle protocol
+    def __getstate__(self):
+        return (self.__toklist,
+                (self.__tokdict.copy(),
+                 self.__parent is not None and self.__parent() or None,
+                 self.__accumNames,
+                 self.__name))
+
+    def __setstate__(self, state):
+        self.__toklist = state[0]
+        self.__tokdict, par, inAccumNames, self.__name = state[1]
+        self.__accumNames = {}
+        self.__accumNames.update(inAccumNames)
+        if par is not None:
+            self.__parent = wkref(par)
+        else:
+            self.__parent = None
+
+    def __getnewargs__(self):
+        return self.__toklist, self.__name, self.__asList, self.__modal
+
+    def __dir__(self):
+        return dir(type(self)) + list(self.keys())
+
+    @classmethod
+    def from_dict(cls, other, name=None):
+        """
+        Helper classmethod to construct a ParseResults from a dict, preserving the
+        name-value relations as results names. If an optional 'name' argument is
+        given, a nested ParseResults will be returned
+        """
+        def is_iterable(obj):
+            try:
+                iter(obj)
+            except Exception:
+                return False
+            else:
+                if PY_3:
+                    return not isinstance(obj, (str, bytes))
+                else:
+                    return not isinstance(obj, basestring)
+
+        ret = cls([])
+        for k, v in other.items():
+            if isinstance(v, Mapping):
+                ret += cls.from_dict(v, name=k)
+            else:
+                ret += cls([v], name=k, asList=is_iterable(v))
+        if name is not None:
+            ret = cls([ret], name=name)
+        return ret
+
+MutableMapping.register(ParseResults)
+
+def col (loc, strg):
+    """Returns current column within a string, counting newlines as line separators.
+   The first column is number 1.
+
+   Note: the default parsing behavior is to expand tabs in the input string
+   before starting the parsing process.  See
+   :class:`ParserElement.parseString` for more
+   information on parsing strings containing ``<TAB>`` s, and suggested
+   methods to maintain a consistent view of the parsed string, the parse
+   location, and line and column positions within the parsed string.
+   """
+    s = strg
+    return 1 if 0 < loc < len(s) and s[loc-1] == '\n' else loc - s.rfind("\n", 0, loc)
+
+def lineno(loc, strg):
+    """Returns current line number within a string, counting newlines as line separators.
+    The first line is number 1.
+
+    Note - the default parsing behavior is to expand tabs in the input string
+    before starting the parsing process.  See :class:`ParserElement.parseString`
+    for more information on parsing strings containing ``<TAB>`` s, and
+    suggested methods to maintain a consistent view of the parsed string, the
+    parse location, and line and column positions within the parsed string.
+    """
+    return strg.count("\n", 0, loc) + 1
+
+def line(loc, strg):
+    """Returns the line of text containing loc within a string, counting newlines as line separators.
+       """
+    lastCR = strg.rfind("\n", 0, loc)
+    nextCR = strg.find("\n", loc)
+    if nextCR >= 0:
+        return strg[lastCR + 1:nextCR]
+    else:
+        return strg[lastCR + 1:]
+
+def _defaultStartDebugAction(instring, loc, expr):
+    print(("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % (lineno(loc, instring), col(loc, instring))))
+
+def _defaultSuccessDebugAction(instring, startloc, endloc, expr, toks):
+    print("Matched " + _ustr(expr) + " -> " + str(toks.asList()))
+
+def _defaultExceptionDebugAction(instring, loc, expr, exc):
+    print("Exception raised:" + _ustr(exc))
+
+def nullDebugAction(*args):
+    """'Do-nothing' debug action, to suppress debugging output during parsing."""
+    pass
+
+# Only works on Python 3.x - nonlocal is toxic to Python 2 installs
+#~ 'decorator to trim function calls to match the arity of the target'
+#~ def _trim_arity(func, maxargs=3):
+    #~ if func in singleArgBuiltins:
+        #~ return lambda s,l,t: func(t)
+    #~ limit = 0
+    #~ foundArity = False
+    #~ def wrapper(*args):
+        #~ nonlocal limit,foundArity
+        #~ while 1:
+            #~ try:
+                #~ ret = func(*args[limit:])
+                #~ foundArity = True
+                #~ return ret
+            #~ except TypeError:
+                #~ if limit == maxargs or foundArity:
+                    #~ raise
+                #~ limit += 1
+                #~ continue
+    #~ return wrapper
+
+# this version is Python 2.x-3.x cross-compatible
+'decorator to trim function calls to match the arity of the target'
+def _trim_arity(func, maxargs=2):
+    if func in singleArgBuiltins:
+        return lambda s, l, t: func(t)
+    limit = [0]
+    foundArity = [False]
+
+    # traceback return data structure changed in Py3.5 - normalize back to plain tuples
+    if system_version[:2] >= (3, 5):
+        def extract_stack(limit=0):
+            # special handling for Python 3.5.0 - extra deep call stack by 1
+            offset = -3 if system_version == (3, 5, 0) else -2
+            frame_summary = traceback.extract_stack(limit=-offset + limit - 1)[offset]
+            return [frame_summary[:2]]
+        def extract_tb(tb, limit=0):
+            frames = traceback.extract_tb(tb, limit=limit)
+            frame_summary = frames[-1]
+            return [frame_summary[:2]]
+    else:
+        extract_stack = traceback.extract_stack
+        extract_tb = traceback.extract_tb
+
+    # synthesize what would be returned by traceback.extract_stack at the call to
+    # user's parse action 'func', so that we don't incur call penalty at parse time
+
+    LINE_DIFF = 6
+    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND
+    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!!
+    this_line = extract_stack(limit=2)[-1]
+    pa_call_line_synth = (this_line[0], this_line[1] + LINE_DIFF)
+
+    def wrapper(*args):
+        while 1:
+            try:
+                ret = func(*args[limit[0]:])
+                foundArity[0] = True
+                return ret
+            except TypeError:
+                # re-raise TypeErrors if they did not come from our arity testing
+                if foundArity[0]:
+                    raise
+                else:
+                    try:
+                        tb = sys.exc_info()[-1]
+                        if not extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth:
+                            raise
+                    finally:
+                        try:
+                            del tb
+                        except NameError:
+                            pass
+
+                if limit[0] <= maxargs:
+                    limit[0] += 1
+                    continue
+                raise
+
+    # copy func name to wrapper for sensible debug output
+    func_name = "<parse action>"
+    try:
+        func_name = getattr(func, '__name__',
+                            getattr(func, '__class__').__name__)
+    except Exception:
+        func_name = str(func)
+    wrapper.__name__ = func_name
+
+    return wrapper
+
+
+class ParserElement(object):
+    """Abstract base level parser element class."""
+    DEFAULT_WHITE_CHARS = " \n\t\r"
+    verbose_stacktrace = False
+
+    @staticmethod
+    def setDefaultWhitespaceChars(chars):
+        r"""
+        Overrides the default whitespace chars
+
+        Example::
+
+            # default whitespace chars are space, <TAB> and newline
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl']
+
+            # change to just treat newline as significant
+            ParserElement.setDefaultWhitespaceChars(" \t")
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def']
+        """
+        ParserElement.DEFAULT_WHITE_CHARS = chars
+
+    @staticmethod
+    def inlineLiteralsUsing(cls):
+        """
+        Set class to be used for inclusion of string literals into a parser.
+
+        Example::
+
+            # default literal class used is Literal
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']
+
+
+            # change to Suppress
+            ParserElement.inlineLiteralsUsing(Suppress)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '12', '31']
+        """
+        ParserElement._literalStringClass = cls
+
+    @classmethod
+    def _trim_traceback(cls, tb):
+        while tb.tb_next:
+            tb = tb.tb_next
+        return tb
+
+    def __init__(self, savelist=False):
+        self.parseAction = list()
+        self.failAction = None
+        # ~ self.name = "<unknown>"  # don't define self.name, let subclasses try/except upcall
+        self.strRepr = None
+        self.resultsName = None
+        self.saveAsList = savelist
+        self.skipWhitespace = True
+        self.whiteChars = set(ParserElement.DEFAULT_WHITE_CHARS)
+        self.copyDefaultWhiteChars = True
+        self.mayReturnEmpty = False # used when checking for left-recursion
+        self.keepTabs = False
+        self.ignoreExprs = list()
+        self.debug = False
+        self.streamlined = False
+        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index
+        self.errmsg = ""
+        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)
+        self.debugActions = (None, None, None)  # custom debug actions
+        self.re = None
+        self.callPreparse = True # used to avoid redundant calls to preParse
+        self.callDuringTry = False
+
+    def copy(self):
+        """
+        Make a copy of this :class:`ParserElement`.  Useful for defining
+        different parse actions for the same parsing pattern, using copies of
+        the original parse element.
+
+        Example::
+
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            integerK = integer.copy().addParseAction(lambda toks: toks[0] * 1024) + Suppress("K")
+            integerM = integer.copy().addParseAction(lambda toks: toks[0] * 1024 * 1024) + Suppress("M")
+
+            print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))
+
+        prints::
+
+            [5120, 100, 655360, 268435456]
+
+        Equivalent form of ``expr.copy()`` is just ``expr()``::
+
+            integerM = integer().addParseAction(lambda toks: toks[0] * 1024 * 1024) + Suppress("M")
+        """
+        cpy = copy.copy(self)
+        cpy.parseAction = self.parseAction[:]
+        cpy.ignoreExprs = self.ignoreExprs[:]
+        if self.copyDefaultWhiteChars:
+            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
+        return cpy
+
+    def setName(self, name):
+        """
+        Define name for this expression, makes debugging and exception messages clearer.
+
+        Example::
+
+            Word(nums).parseString("ABC")  # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)
+            Word(nums).setName("integer").parseString("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1)
+        """
+        self.name = name
+        self.errmsg = "Expected " + self.name
+        if __diag__.enable_debug_on_named_expressions:
+            self.setDebug()
+        return self
+
+    def setResultsName(self, name, listAllMatches=False):
+        """
+        Define name for referencing matching tokens as a nested attribute
+        of the returned parse results.
+        NOTE: this returns a *copy* of the original :class:`ParserElement` object;
+        this is so that the client can define a basic element, such as an
+        integer, and reference it in multiple places with different names.
+
+        You can also set results names using the abbreviated syntax,
+        ``expr("name")`` in place of ``expr.setResultsName("name")``
+        - see :class:`__call__`.
+
+        Example::
+
+            date_str = (integer.setResultsName("year") + '/'
+                        + integer.setResultsName("month") + '/'
+                        + integer.setResultsName("day"))
+
+            # equivalent form:
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+        """
+        return self._setResultsName(name, listAllMatches)
+
+    def _setResultsName(self, name, listAllMatches=False):
+        newself = self.copy()
+        if name.endswith("*"):
+            name = name[:-1]
+            listAllMatches = True
+        newself.resultsName = name
+        newself.modalResults = not listAllMatches
+        return newself
+
+    def setBreak(self, breakFlag=True):
+        """Method to invoke the Python pdb debugger when this element is
+           about to be parsed. Set ``breakFlag`` to True to enable, False to
+           disable.
+        """
+        if breakFlag:
+            _parseMethod = self._parse
+            def breaker(instring, loc, doActions=True, callPreParse=True):
+                import pdb
+                # this call to pdb.set_trace() is intentional, not a checkin error
+                pdb.set_trace()
+                return _parseMethod(instring, loc, doActions, callPreParse)
+            breaker._originalParseMethod = _parseMethod
+            self._parse = breaker
+        else:
+            if hasattr(self._parse, "_originalParseMethod"):
+                self._parse = self._parse._originalParseMethod
+        return self
+
+    def setParseAction(self, *fns, **kwargs):
+        """
+        Define one or more actions to perform when successfully matching parse element definition.
+        Parse action fn is a callable method with 0-3 arguments, called as ``fn(s, loc, toks)`` ,
+        ``fn(loc, toks)`` , ``fn(toks)`` , or just ``fn()`` , where:
+
+        - s   = the original string being parsed (see note below)
+        - loc = the location of the matching substring
+        - toks = a list of the matched tokens, packaged as a :class:`ParseResults` object
+
+        If the functions in fns modify the tokens, they can return them as the return
+        value from fn, and the modified list of tokens will replace the original.
+        Otherwise, fn does not need to return any value.
+
+        If None is passed as the parse action, all previously added parse actions for this
+        expression are cleared.
+
+        Optional keyword arguments:
+        - callDuringTry = (default= ``False``) indicate if parse action should be run during lookaheads and alternate testing
+
+        Note: the default parsing behavior is to expand tabs in the input string
+        before starting the parsing process.  See :class:`parseString for more
+        information on parsing strings containing ``<TAB>`` s, and suggested
+        methods to maintain a consistent view of the parsed string, the parse
+        location, and line and column positions within the parsed string.
+
+        Example::
+
+            integer = Word(nums)
+            date_str = integer + '/' + integer + '/' + integer
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']
+
+            # use parse action to convert to ints at parse time
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            date_str = integer + '/' + integer + '/' + integer
+
+            # note that integer fields are now ints, not strings
+            date_str.parseString("1999/12/31")  # -> [1999, '/', 12, '/', 31]
+        """
+        if list(fns) == [None,]:
+            self.parseAction = []
+        else:
+            if not all(callable(fn) for fn in fns):
+                raise TypeError("parse actions must be callable")
+            self.parseAction = list(map(_trim_arity, list(fns)))
+            self.callDuringTry = kwargs.get("callDuringTry", False)
+        return self
+
+    def addParseAction(self, *fns, **kwargs):
+        """
+        Add one or more parse actions to expression's list of parse actions. See :class:`setParseAction`.
+
+        See examples in :class:`copy`.
+        """
+        self.parseAction += list(map(_trim_arity, list(fns)))
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
+        return self
+
+    def addCondition(self, *fns, **kwargs):
+        """Add a boolean predicate function to expression's list of parse actions. See
+        :class:`setParseAction` for function call signatures. Unlike ``setParseAction``,
+        functions passed to ``addCondition`` need to return boolean success/fail of the condition.
+
+        Optional keyword arguments:
+        - message = define a custom message to be used in the raised exception
+        - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException
+
+        Example::
+
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            year_int = integer.copy()
+            year_int.addCondition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later")
+            date_str = year_int + '/' + integer + '/' + integer
+
+            result = date_str.parseString("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1)
+        """
+        for fn in fns:
+            self.parseAction.append(conditionAsParseAction(fn, message=kwargs.get('message'),
+                                                           fatal=kwargs.get('fatal', False)))
+
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
+        return self
+
+    def setFailAction(self, fn):
+        """Define action to perform if parsing fails at this expression.
+           Fail acton fn is a callable function that takes the arguments
+           ``fn(s, loc, expr, err)`` where:
+           - s = string being parsed
+           - loc = location where expression match was attempted and failed
+           - expr = the parse expression that failed
+           - err = the exception thrown
+           The function returns no value.  It may throw :class:`ParseFatalException`
+           if it is desired to stop parsing immediately."""
+        self.failAction = fn
+        return self
+
+    def _skipIgnorables(self, instring, loc):
+        exprsFound = True
+        while exprsFound:
+            exprsFound = False
+            for e in self.ignoreExprs:
+                try:
+                    while 1:
+                        loc, dummy = e._parse(instring, loc)
+                        exprsFound = True
+                except ParseException:
+                    pass
+        return loc
+
+    def preParse(self, instring, loc):
+        if self.ignoreExprs:
+            loc = self._skipIgnorables(instring, loc)
+
+        if self.skipWhitespace:
+            wt = self.whiteChars
+            instrlen = len(instring)
+            while loc < instrlen and instring[loc] in wt:
+                loc += 1
+
+        return loc
+
+    def parseImpl(self, instring, loc, doActions=True):
+        return loc, []
+
+    def postParse(self, instring, loc, tokenlist):
+        return tokenlist
+
+    # ~ @profile
+    def _parseNoCache(self, instring, loc, doActions=True, callPreParse=True):
+        TRY, MATCH, FAIL = 0, 1, 2
+        debugging = (self.debug)  # and doActions)
+
+        if debugging or self.failAction:
+            # ~ print ("Match", self, "at loc", loc, "(%d, %d)" % (lineno(loc, instring), col(loc, instring)))
+            if self.debugActions[TRY]:
+                self.debugActions[TRY](instring, loc, self)
+            try:
+                if callPreParse and self.callPreparse:
+                    preloc = self.preParse(instring, loc)
+                else:
+                    preloc = loc
+                tokensStart = preloc
+                if self.mayIndexError or preloc >= len(instring):
+                    try:
+                        loc, tokens = self.parseImpl(instring, preloc, doActions)
+                    except IndexError:
+                        raise ParseException(instring, len(instring), self.errmsg, self)
+                else:
+                    loc, tokens = self.parseImpl(instring, preloc, doActions)
+            except Exception as err:
+                # ~ print ("Exception raised:", err)
+                if self.debugActions[FAIL]:
+                    self.debugActions[FAIL](instring, tokensStart, self, err)
+                if self.failAction:
+                    self.failAction(instring, tokensStart, self, err)
+                raise
+        else:
+            if callPreParse and self.callPreparse:
+                preloc = self.preParse(instring, loc)
+            else:
+                preloc = loc
+            tokensStart = preloc
+            if self.mayIndexError or preloc >= len(instring):
+                try:
+                    loc, tokens = self.parseImpl(instring, preloc, doActions)
+                except IndexError:
+                    raise ParseException(instring, len(instring), self.errmsg, self)
+            else:
+                loc, tokens = self.parseImpl(instring, preloc, doActions)
+
+        tokens = self.postParse(instring, loc, tokens)
+
+        retTokens = ParseResults(tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults)
+        if self.parseAction and (doActions or self.callDuringTry):
+            if debugging:
+                try:
+                    for fn in self.parseAction:
+                        try:
+                            tokens = fn(instring, tokensStart, retTokens)
+                        except IndexError as parse_action_exc:
+                            exc = ParseException("exception raised in parse action")
+                            exc.__cause__ = parse_action_exc
+                            raise exc
+
+                        if tokens is not None and tokens is not retTokens:
+                            retTokens = ParseResults(tokens,
+                                                      self.resultsName,
+                                                      asList=self.saveAsList and isinstance(tokens, (ParseResults, list)),
+                                                      modal=self.modalResults)
+                except Exception as err:
+                    # ~ print "Exception raised in user parse action:", err
+                    if self.debugActions[FAIL]:
+                        self.debugActions[FAIL](instring, tokensStart, self, err)
+                    raise
+            else:
+                for fn in self.parseAction:
+                    try:
+                        tokens = fn(instring, tokensStart, retTokens)
+                    except IndexError as parse_action_exc:
+                        exc = ParseException("exception raised in parse action")
+                        exc.__cause__ = parse_action_exc
+                        raise exc
+
+                    if tokens is not None and tokens is not retTokens:
+                        retTokens = ParseResults(tokens,
+                                                  self.resultsName,
+                                                  asList=self.saveAsList and isinstance(tokens, (ParseResults, list)),
+                                                  modal=self.modalResults)
+        if debugging:
+            # ~ print ("Matched", self, "->", retTokens.asList())
+            if self.debugActions[MATCH]:
+                self.debugActions[MATCH](instring, tokensStart, loc, self, retTokens)
+
+        return loc, retTokens
+
+    def tryParse(self, instring, loc):
+        try:
+            return self._parse(instring, loc, doActions=False)[0]
+        except ParseFatalException:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+    def canParseNext(self, instring, loc):
+        try:
+            self.tryParse(instring, loc)
+        except (ParseException, IndexError):
+            return False
+        else:
+            return True
+
+    class _UnboundedCache(object):
+        def __init__(self):
+            cache = {}
+            self.not_in_cache = not_in_cache = object()
+
+            def get(self, key):
+                return cache.get(key, not_in_cache)
+
+            def set(self, key, value):
+                cache[key] = value
+
+            def clear(self):
+                cache.clear()
+
+            def cache_len(self):
+                return len(cache)
+
+            self.get = types.MethodType(get, self)
+            self.set = types.MethodType(set, self)
+            self.clear = types.MethodType(clear, self)
+            self.__len__ = types.MethodType(cache_len, self)
+
+    if _OrderedDict is not None:
+        class _FifoCache(object):
+            def __init__(self, size):
+                self.not_in_cache = not_in_cache = object()
+
+                cache = _OrderedDict()
+
+                def get(self, key):
+                    return cache.get(key, not_in_cache)
+
+                def set(self, key, value):
+                    cache[key] = value
+                    while len(cache) > size:
+                        try:
+                            cache.popitem(False)
+                        except KeyError:
+                            pass
+
+                def clear(self):
+                    cache.clear()
+
+                def cache_len(self):
+                    return len(cache)
+
+                self.get = types.MethodType(get, self)
+                self.set = types.MethodType(set, self)
+                self.clear = types.MethodType(clear, self)
+                self.__len__ = types.MethodType(cache_len, self)
+
+    else:
+        class _FifoCache(object):
+            def __init__(self, size):
+                self.not_in_cache = not_in_cache = object()
+
+                cache = {}
+                key_fifo = collections.deque([], size)
+
+                def get(self, key):
+                    return cache.get(key, not_in_cache)
+
+                def set(self, key, value):
+                    cache[key] = value
+                    while len(key_fifo) > size:
+                        cache.pop(key_fifo.popleft(), None)
+                    key_fifo.append(key)
+
+                def clear(self):
+                    cache.clear()
+                    key_fifo.clear()
+
+                def cache_len(self):
+                    return len(cache)
+
+                self.get = types.MethodType(get, self)
+                self.set = types.MethodType(set, self)
+                self.clear = types.MethodType(clear, self)
+                self.__len__ = types.MethodType(cache_len, self)
+
+    # argument cache for optimizing repeated calls when backtracking through recursive expressions
+    packrat_cache = {} # this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail
+    packrat_cache_lock = RLock()
+    packrat_cache_stats = [0, 0]
+
+    # this method gets repeatedly called during backtracking with the same arguments -
+    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression
+    def _parseCache(self, instring, loc, doActions=True, callPreParse=True):
+        HIT, MISS = 0, 1
+        lookup = (self, instring, loc, callPreParse, doActions)
+        with ParserElement.packrat_cache_lock:
+            cache = ParserElement.packrat_cache
+            value = cache.get(lookup)
+            if value is cache.not_in_cache:
+                ParserElement.packrat_cache_stats[MISS] += 1
+                try:
+                    value = self._parseNoCache(instring, loc, doActions, callPreParse)
+                except ParseBaseException as pe:
+                    # cache a copy of the exception, without the traceback
+                    cache.set(lookup, pe.__class__(*pe.args))
+                    raise
+                else:
+                    cache.set(lookup, (value[0], value[1].copy()))
+                    return value
+            else:
+                ParserElement.packrat_cache_stats[HIT] += 1
+                if isinstance(value, Exception):
+                    raise value
+                return value[0], value[1].copy()
+
+    _parse = _parseNoCache
+
+    @staticmethod
+    def resetCache():
+        ParserElement.packrat_cache.clear()
+        ParserElement.packrat_cache_stats[:] = [0] * len(ParserElement.packrat_cache_stats)
+
+    _packratEnabled = False
+    @staticmethod
+    def enablePackrat(cache_size_limit=128):
+        """Enables "packrat" parsing, which adds memoizing to the parsing logic.
+           Repeated parse attempts at the same string location (which happens
+           often in many complex grammars) can immediately return a cached value,
+           instead of re-executing parsing/validating code.  Memoizing is done of
+           both valid results and parsing exceptions.
+
+           Parameters:
+
+           - cache_size_limit - (default= ``128``) - if an integer value is provided
+             will limit the size of the packrat cache; if None is passed, then
+             the cache size will be unbounded; if 0 is passed, the cache will
+             be effectively disabled.
+
+           This speedup may break existing programs that use parse actions that
+           have side-effects.  For this reason, packrat parsing is disabled when
+           you first import pyparsing.  To activate the packrat feature, your
+           program must call the class method :class:`ParserElement.enablePackrat`.
+           For best results, call ``enablePackrat()`` immediately after
+           importing pyparsing.
+
+           Example::
+
+               from pip._vendor import pyparsing
+               pyparsing.ParserElement.enablePackrat()
+        """
+        if not ParserElement._packratEnabled:
+            ParserElement._packratEnabled = True
+            if cache_size_limit is None:
+                ParserElement.packrat_cache = ParserElement._UnboundedCache()
+            else:
+                ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit)
+            ParserElement._parse = ParserElement._parseCache
+
+    def parseString(self, instring, parseAll=False):
+        """
+        Execute the parse expression with the given string.
+        This is the main interface to the client code, once the complete
+        expression has been built.
+
+        Returns the parsed data as a :class:`ParseResults` object, which may be
+        accessed as a list, or as a dict or object with attributes if the given parser
+        includes results names.
+
+        If you want the grammar to require that the entire input string be
+        successfully parsed, then set ``parseAll`` to True (equivalent to ending
+        the grammar with ``StringEnd()``).
+
+        Note: ``parseString`` implicitly calls ``expandtabs()`` on the input string,
+        in order to report proper column numbers in parse actions.
+        If the input string contains tabs and
+        the grammar uses parse actions that use the ``loc`` argument to index into the
+        string being parsed, you can ensure you have a consistent view of the input
+        string by:
+
+        - calling ``parseWithTabs`` on your grammar before calling ``parseString``
+          (see :class:`parseWithTabs`)
+        - define your parse action using the full ``(s, loc, toks)`` signature, and
+          reference the input string using the parse action's ``s`` argument
+        - explictly expand the tabs in your input string before calling
+          ``parseString``
+
+        Example::
+
+            Word('a').parseString('aaaaabaaa')  # -> ['aaaaa']
+            Word('a').parseString('aaaaabaaa', parseAll=True)  # -> Exception: Expected end of text
+        """
+        ParserElement.resetCache()
+        if not self.streamlined:
+            self.streamline()
+            # ~ self.saveAsList = True
+        for e in self.ignoreExprs:
+            e.streamline()
+        if not self.keepTabs:
+            instring = instring.expandtabs()
+        try:
+            loc, tokens = self._parse(instring, 0)
+            if parseAll:
+                loc = self.preParse(instring, loc)
+                se = Empty() + StringEnd()
+                se._parse(instring, loc)
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clearing out pyparsing internal stack trace
+                if getattr(exc, '__traceback__', None) is not None:
+                    exc.__traceback__ = self._trim_traceback(exc.__traceback__)
+                raise exc
+        else:
+            return tokens
+
+    def scanString(self, instring, maxMatches=_MAX_INT, overlap=False):
+        """
+        Scan the input string for expression matches.  Each match will return the
+        matching tokens, start location, and end location.  May be called with optional
+        ``maxMatches`` argument, to clip scanning after 'n' matches are found.  If
+        ``overlap`` is specified, then overlapping matches will be reported.
+
+        Note that the start and end locations are reported relative to the string
+        being parsed.  See :class:`parseString` for more information on parsing
+        strings with embedded tabs.
+
+        Example::
+
+            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987"
+            print(source)
+            for tokens, start, end in Word(alphas).scanString(source):
+                print(' '*start + '^'*(end-start))
+                print(' '*start + tokens[0])
+
+        prints::
+
+            sldjf123lsdjjkf345sldkjf879lkjsfd987
+            ^^^^^
+            sldjf
+                    ^^^^^^^
+                    lsdjjkf
+                              ^^^^^^
+                              sldkjf
+                                       ^^^^^^
+                                       lkjsfd
+        """
+        if not self.streamlined:
+            self.streamline()
+        for e in self.ignoreExprs:
+            e.streamline()
+
+        if not self.keepTabs:
+            instring = _ustr(instring).expandtabs()
+        instrlen = len(instring)
+        loc = 0
+        preparseFn = self.preParse
+        parseFn = self._parse
+        ParserElement.resetCache()
+        matches = 0
+        try:
+            while loc <= instrlen and matches < maxMatches:
+                try:
+                    preloc = preparseFn(instring, loc)
+                    nextLoc, tokens = parseFn(instring, preloc, callPreParse=False)
+                except ParseException:
+                    loc = preloc + 1
+                else:
+                    if nextLoc > loc:
+                        matches += 1
+                        yield tokens, preloc, nextLoc
+                        if overlap:
+                            nextloc = preparseFn(instring, loc)
+                            if nextloc > loc:
+                                loc = nextLoc
+                            else:
+                                loc += 1
+                        else:
+                            loc = nextLoc
+                    else:
+                        loc = preloc + 1
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clearing out pyparsing internal stack trace
+                if getattr(exc, '__traceback__', None) is not None:
+                    exc.__traceback__ = self._trim_traceback(exc.__traceback__)
+                raise exc
+
+    def transformString(self, instring):
+        """
+        Extension to :class:`scanString`, to modify matching text with modified tokens that may
+        be returned from a parse action.  To use ``transformString``, define a grammar and
+        attach a parse action to it that modifies the returned token list.
+        Invoking ``transformString()`` on a target string will then scan for matches,
+        and replace the matched text patterns according to the logic in the parse
+        action.  ``transformString()`` returns the resulting transformed string.
+
+        Example::
+
+            wd = Word(alphas)
+            wd.setParseAction(lambda toks: toks[0].title())
+
+            print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york."))
+
+        prints::
+
+            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York.
+        """
+        out = []
+        lastE = 0
+        # force preservation of <TAB>s, to minimize unwanted transformation of string, and to
+        # keep string locs straight between transformString and scanString
+        self.keepTabs = True
+        try:
+            for t, s, e in self.scanString(instring):
+                out.append(instring[lastE:s])
+                if t:
+                    if isinstance(t, ParseResults):
+                        out += t.asList()
+                    elif isinstance(t, list):
+                        out += t
+                    else:
+                        out.append(t)
+                lastE = e
+            out.append(instring[lastE:])
+            out = [o for o in out if o]
+            return "".join(map(_ustr, _flatten(out)))
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clearing out pyparsing internal stack trace
+                if getattr(exc, '__traceback__', None) is not None:
+                    exc.__traceback__ = self._trim_traceback(exc.__traceback__)
+                raise exc
+
+    def searchString(self, instring, maxMatches=_MAX_INT):
+        """
+        Another extension to :class:`scanString`, simplifying the access to the tokens found
+        to match the given parse expression.  May be called with optional
+        ``maxMatches`` argument, to clip searching after 'n' matches are found.
+
+        Example::
+
+            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters
+            cap_word = Word(alphas.upper(), alphas.lower())
+
+            print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))
+
+            # the sum() builtin can be used to merge results into a single ParseResults object
+            print(sum(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity")))
+
+        prints::
+
+            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']]
+            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity']
+        """
+        try:
+            return ParseResults([t for t, s, e in self.scanString(instring, maxMatches)])
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clearing out pyparsing internal stack trace
+                if getattr(exc, '__traceback__', None) is not None:
+                    exc.__traceback__ = self._trim_traceback(exc.__traceback__)
+                raise exc
+
+    def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False):
+        """
+        Generator method to split a string using the given expression as a separator.
+        May be called with optional ``maxsplit`` argument, to limit the number of splits;
+        and the optional ``includeSeparators`` argument (default= ``False``), if the separating
+        matching text should be included in the split results.
+
+        Example::
+
+            punc = oneOf(list(".,;:/-!?"))
+            print(list(punc.split("This, this?, this sentence, is badly punctuated!")))
+
+        prints::
+
+            ['This', ' this', '', ' this sentence', ' is badly punctuated', '']
+        """
+        splits = 0
+        last = 0
+        for t, s, e in self.scanString(instring, maxMatches=maxsplit):
+            yield instring[last:s]
+            if includeSeparators:
+                yield t[0]
+            last = e
+        yield instring[last:]
+
+    def __add__(self, other):
+        """
+        Implementation of + operator - returns :class:`And`. Adding strings to a ParserElement
+        converts them to :class:`Literal`s by default.
+
+        Example::
+
+            greet = Word(alphas) + "," + Word(alphas) + "!"
+            hello = "Hello, World!"
+            print (hello, "->", greet.parseString(hello))
+
+        prints::
+
+            Hello, World! -> ['Hello', ',', 'World', '!']
+
+        ``...`` may be used as a parse expression as a short form of :class:`SkipTo`.
+
+            Literal('start') + ... + Literal('end')
+
+        is equivalent to:
+
+            Literal('start') + SkipTo('end')("_skipped*") + Literal('end')
+
+        Note that the skipped text is returned with '_skipped' as a results name,
+        and to support having multiple skips in the same parser, the value returned is
+        a list of all skipped text.
+        """
+        if other is Ellipsis:
+            return _PendingSkip(self)
+
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                          SyntaxWarning, stacklevel=2)
+            return None
+        return And([self, other])
+
+    def __radd__(self, other):
+        """
+        Implementation of + operator when left operand is not a :class:`ParserElement`
+        """
+        if other is Ellipsis:
+            return SkipTo(self)("_skipped*") + self
+
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                          SyntaxWarning, stacklevel=2)
+            return None
+        return other + self
+
+    def __sub__(self, other):
+        """
+        Implementation of - operator, returns :class:`And` with error stop
+        """
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                          SyntaxWarning, stacklevel=2)
+            return None
+        return self + And._ErrorStop() + other
+
+    def __rsub__(self, other):
+        """
+        Implementation of - operator when left operand is not a :class:`ParserElement`
+        """
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                          SyntaxWarning, stacklevel=2)
+            return None
+        return other - self
+
+    def __mul__(self, other):
+        """
+        Implementation of * operator, allows use of ``expr * 3`` in place of
+        ``expr + expr + expr``.  Expressions may also me multiplied by a 2-integer
+        tuple, similar to ``{min, max}`` multipliers in regular expressions.  Tuples
+        may also include ``None`` as in:
+         - ``expr*(n, None)`` or ``expr*(n, )`` is equivalent
+              to ``expr*n + ZeroOrMore(expr)``
+              (read as "at least n instances of ``expr``")
+         - ``expr*(None, n)`` is equivalent to ``expr*(0, n)``
+              (read as "0 to n instances of ``expr``")
+         - ``expr*(None, None)`` is equivalent to ``ZeroOrMore(expr)``
+         - ``expr*(1, None)`` is equivalent to ``OneOrMore(expr)``
+
+        Note that ``expr*(None, n)`` does not raise an exception if
+        more than n exprs exist in the input stream; that is,
+        ``expr*(None, n)`` does not enforce a maximum number of expr
+        occurrences.  If this behavior is desired, then write
+        ``expr*(None, n) + ~expr``
+        """
+        if other is Ellipsis:
+            other = (0, None)
+        elif isinstance(other, tuple) and other[:1] == (Ellipsis,):
+            other = ((0, ) + other[1:] + (None,))[:2]
+
+        if isinstance(other, int):
+            minElements, optElements = other, 0
+        elif isinstance(other, tuple):
+            other = tuple(o if o is not Ellipsis else None for o in other)
+            other = (other + (None, None))[:2]
+            if other[0] is None:
+                other = (0, other[1])
+            if isinstance(other[0], int) and other[1] is None:
+                if other[0] == 0:
+                    return ZeroOrMore(self)
+                if other[0] == 1:
+                    return OneOrMore(self)
+                else:
+                    return self * other[0] + ZeroOrMore(self)
+            elif isinstance(other[0], int) and isinstance(other[1], int):
+                minElements, optElements = other
+                optElements -= minElements
+            else:
+                raise TypeError("cannot multiply 'ParserElement' and ('%s', '%s') objects", type(other[0]), type(other[1]))
+        else:
+            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))
+
+        if minElements < 0:
+            raise ValueError("cannot multiply ParserElement by negative value")
+        if optElements < 0:
+            raise ValueError("second tuple value must be greater or equal to first tuple value")
+        if minElements == optElements == 0:
+            raise ValueError("cannot multiply ParserElement by 0 or (0, 0)")
+
+        if optElements:
+            def makeOptionalList(n):
+                if n > 1:
+                    return Optional(self + makeOptionalList(n - 1))
+                else:
+                    return Optional(self)
+            if minElements:
+                if minElements == 1:
+                    ret = self + makeOptionalList(optElements)
+                else:
+                    ret = And([self] * minElements) + makeOptionalList(optElements)
+            else:
+                ret = makeOptionalList(optElements)
+        else:
+            if minElements == 1:
+                ret = self
+            else:
+                ret = And([self] * minElements)
+        return ret
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __or__(self, other):
+        """
+        Implementation of | operator - returns :class:`MatchFirst`
+        """
+        if other is Ellipsis:
+            return _PendingSkip(self, must_skip=True)
+
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                          SyntaxWarning, stacklevel=2)
+            return None
+        return MatchFirst([self, other])
+
+    def __ror__(self, other):
+        """
+        Implementation of | operator when left operand is not a :class:`ParserElement`
+        """
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                          SyntaxWarning, stacklevel=2)
+            return None
+        return other | self
+
+    def __xor__(self, other):
+        """
+        Implementation of ^ operator - returns :class:`Or`
+        """
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                          SyntaxWarning, stacklevel=2)
+            return None
+        return Or([self, other])
+
+    def __rxor__(self, other):
+        """
+        Implementation of ^ operator when left operand is not a :class:`ParserElement`
+        """
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                          SyntaxWarning, stacklevel=2)
+            return None
+        return other ^ self
+
+    def __and__(self, other):
+        """
+        Implementation of & operator - returns :class:`Each`
+        """
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                          SyntaxWarning, stacklevel=2)
+            return None
+        return Each([self, other])
+
+    def __rand__(self, other):
+        """
+        Implementation of & operator when left operand is not a :class:`ParserElement`
+        """
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                          SyntaxWarning, stacklevel=2)
+            return None
+        return other & self
+
+    def __invert__(self):
+        """
+        Implementation of ~ operator - returns :class:`NotAny`
+        """
+        return NotAny(self)
+
+    def __iter__(self):
+        # must implement __iter__ to override legacy use of sequential access to __getitem__ to
+        # iterate over a sequence
+        raise TypeError('%r object is not iterable' % self.__class__.__name__)
+
+    def __getitem__(self, key):
+        """
+        use ``[]`` indexing notation as a short form for expression repetition:
+         - ``expr[n]`` is equivalent to ``expr*n``
+         - ``expr[m, n]`` is equivalent to ``expr*(m, n)``
+         - ``expr[n, ...]`` or ``expr[n,]`` is equivalent
+              to ``expr*n + ZeroOrMore(expr)``
+              (read as "at least n instances of ``expr``")
+         - ``expr[..., n]`` is equivalent to ``expr*(0, n)``
+              (read as "0 to n instances of ``expr``")
+         - ``expr[...]`` and ``expr[0, ...]`` are equivalent to ``ZeroOrMore(expr)``
+         - ``expr[1, ...]`` is equivalent to ``OneOrMore(expr)``
+         ``None`` may be used in place of ``...``.
+
+        Note that ``expr[..., n]`` and ``expr[m, n]``do not raise an exception
+        if more than ``n`` ``expr``s exist in the input stream.  If this behavior is
+        desired, then write ``expr[..., n] + ~expr``.
+       """
+
+        # convert single arg keys to tuples
+        try:
+            if isinstance(key, str):
+                key = (key,)
+            iter(key)
+        except TypeError:
+            key = (key, key)
+
+        if len(key) > 2:
+            warnings.warn("only 1 or 2 index arguments supported ({0}{1})".format(key[:5],
+                                                                                '... [{0}]'.format(len(key))
+                                                                                if len(key) > 5 else ''))
+
+        # clip to 2 elements
+        ret = self * tuple(key[:2])
+        return ret
+
+    def __call__(self, name=None):
+        """
+        Shortcut for :class:`setResultsName`, with ``listAllMatches=False``.
+
+        If ``name`` is given with a trailing ``'*'`` character, then ``listAllMatches`` will be
+        passed as ``True``.
+
+        If ``name` is omitted, same as calling :class:`copy`.
+
+        Example::
+
+            # these are equivalent
+            userdata = Word(alphas).setResultsName("name") + Word(nums + "-").setResultsName("socsecno")
+            userdata = Word(alphas)("name") + Word(nums + "-")("socsecno")
+        """
+        if name is not None:
+            return self._setResultsName(name)
+        else:
+            return self.copy()
+
+    def suppress(self):
+        """
+        Suppresses the output of this :class:`ParserElement`; useful to keep punctuation from
+        cluttering up returned output.
+        """
+        return Suppress(self)
+
+    def leaveWhitespace(self):
+        """
+        Disables the skipping of whitespace before matching the characters in the
+        :class:`ParserElement`'s defined pattern.  This is normally only used internally by
+        the pyparsing module, but may be needed in some whitespace-sensitive grammars.
+        """
+        self.skipWhitespace = False
+        return self
+
+    def setWhitespaceChars(self, chars):
+        """
+        Overrides the default whitespace chars
+        """
+        self.skipWhitespace = True
+        self.whiteChars = chars
+        self.copyDefaultWhiteChars = False
+        return self
+
+    def parseWithTabs(self):
+        """
+        Overrides default behavior to expand ``<TAB>``s to spaces before parsing the input string.
+        Must be called before ``parseString`` when the input grammar contains elements that
+        match ``<TAB>`` characters.
+        """
+        self.keepTabs = True
+        return self
+
+    def ignore(self, other):
+        """
+        Define expression to be ignored (e.g., comments) while doing pattern
+        matching; may be called repeatedly, to define multiple comment or other
+        ignorable patterns.
+
+        Example::
+
+            patt = OneOrMore(Word(alphas))
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj']
+
+            patt.ignore(cStyleComment)
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd']
+        """
+        if isinstance(other, basestring):
+            other = Suppress(other)
+
+        if isinstance(other, Suppress):
+            if other not in self.ignoreExprs:
+                self.ignoreExprs.append(other)
+        else:
+            self.ignoreExprs.append(Suppress(other.copy()))
+        return self
+
+    def setDebugActions(self, startAction, successAction, exceptionAction):
+        """
+        Enable display of debugging messages while doing pattern matching.
+        """
+        self.debugActions = (startAction or _defaultStartDebugAction,
+                             successAction or _defaultSuccessDebugAction,
+                             exceptionAction or _defaultExceptionDebugAction)
+        self.debug = True
+        return self
+
+    def setDebug(self, flag=True):
+        """
+        Enable display of debugging messages while doing pattern matching.
+        Set ``flag`` to True to enable, False to disable.
+
+        Example::
+
+            wd = Word(alphas).setName("alphaword")
+            integer = Word(nums).setName("numword")
+            term = wd | integer
+
+            # turn on debugging for wd
+            wd.setDebug()
+
+            OneOrMore(term).parseString("abc 123 xyz 890")
+
+        prints::
+
+            Match alphaword at loc 0(1,1)
+            Matched alphaword -> ['abc']
+            Match alphaword at loc 3(1,4)
+            Exception raised:Expected alphaword (at char 4), (line:1, col:5)
+            Match alphaword at loc 7(1,8)
+            Matched alphaword -> ['xyz']
+            Match alphaword at loc 11(1,12)
+            Exception raised:Expected alphaword (at char 12), (line:1, col:13)
+            Match alphaword at loc 15(1,16)
+            Exception raised:Expected alphaword (at char 15), (line:1, col:16)
+
+        The output shown is that produced by the default debug actions - custom debug actions can be
+        specified using :class:`setDebugActions`. Prior to attempting
+        to match the ``wd`` expression, the debugging message ``"Match <exprname> at loc <n>(<line>,<col>)"``
+        is shown. Then if the parse succeeds, a ``"Matched"`` message is shown, or an ``"Exception raised"``
+        message is shown. Also note the use of :class:`setName` to assign a human-readable name to the expression,
+        which makes debugging and exception messages easier to understand - for instance, the default
+        name created for the :class:`Word` expression without calling ``setName`` is ``"W:(ABCD...)"``.
+        """
+        if flag:
+            self.setDebugActions(_defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction)
+        else:
+            self.debug = False
+        return self
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return _ustr(self)
+
+    def streamline(self):
+        self.streamlined = True
+        self.strRepr = None
+        return self
+
+    def checkRecursion(self, parseElementList):
+        pass
+
+    def validate(self, validateTrace=None):
+        """
+        Check defined expressions for valid structure, check for infinite recursive definitions.
+        """
+        self.checkRecursion([])
+
+    def parseFile(self, file_or_filename, parseAll=False):
+        """
+        Execute the parse expression on the given file or filename.
+        If a filename is specified (instead of a file object),
+        the entire file is opened, read, and closed before parsing.
+        """
+        try:
+            file_contents = file_or_filename.read()
+        except AttributeError:
+            with open(file_or_filename, "r") as f:
+                file_contents = f.read()
+        try:
+            return self.parseString(file_contents, parseAll)
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clearing out pyparsing internal stack trace
+                if getattr(exc, '__traceback__', None) is not None:
+                    exc.__traceback__ = self._trim_traceback(exc.__traceback__)
+                raise exc
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif isinstance(other, basestring):
+            return self.matches(other)
+        elif isinstance(other, ParserElement):
+            return vars(self) == vars(other)
+        return False
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __hash__(self):
+        return id(self)
+
+    def __req__(self, other):
+        return self == other
+
+    def __rne__(self, other):
+        return not (self == other)
+
+    def matches(self, testString, parseAll=True):
+        """
+        Method for quick testing of a parser against a test string. Good for simple
+        inline microtests of sub expressions while building up larger parser.
+
+        Parameters:
+         - testString - to test against this expression for a match
+         - parseAll - (default= ``True``) - flag to pass to :class:`parseString` when running tests
+
+        Example::
+
+            expr = Word(nums)
+            assert expr.matches("100")
+        """
+        try:
+            self.parseString(_ustr(testString), parseAll=parseAll)
+            return True
+        except ParseBaseException:
+            return False
+
+    def runTests(self, tests, parseAll=True, comment='#',
+                 fullDump=True, printResults=True, failureTests=False, postParse=None,
+                 file=None):
+        """
+        Execute the parse expression on a series of test strings, showing each
+        test, the parsed results or where the parse failed. Quick and easy way to
+        run a parse expression against a list of sample strings.
+
+        Parameters:
+         - tests - a list of separate test strings, or a multiline string of test strings
+         - parseAll - (default= ``True``) - flag to pass to :class:`parseString` when running tests
+         - comment - (default= ``'#'``) - expression for indicating embedded comments in the test
+              string; pass None to disable comment filtering
+         - fullDump - (default= ``True``) - dump results as list followed by results names in nested outline;
+              if False, only dump nested list
+         - printResults - (default= ``True``) prints test output to stdout
+         - failureTests - (default= ``False``) indicates if these tests are expected to fail parsing
+         - postParse - (default= ``None``) optional callback for successful parse results; called as
+              `fn(test_string, parse_results)` and returns a string to be added to the test output
+         - file - (default=``None``) optional file-like object to which test output will be written;
+              if None, will default to ``sys.stdout``
+
+        Returns: a (success, results) tuple, where success indicates that all tests succeeded
+        (or failed if ``failureTests`` is True), and the results contain a list of lines of each
+        test's output
+
+        Example::
+
+            number_expr = pyparsing_common.number.copy()
+
+            result = number_expr.runTests('''
+                # unsigned integer
+                100
+                # negative integer
+                -100
+                # float with scientific notation
+                6.02e23
+                # integer with scientific notation
+                1e-12
+                ''')
+            print("Success" if result[0] else "Failed!")
+
+            result = number_expr.runTests('''
+                # stray character
+                100Z
+                # missing leading digit before '.'
+                -.100
+                # too many '.'
+                3.14.159
+                ''', failureTests=True)
+            print("Success" if result[0] else "Failed!")
+
+        prints::
+
+            # unsigned integer
+            100
+            [100]
+
+            # negative integer
+            -100
+            [-100]
+
+            # float with scientific notation
+            6.02e23
+            [6.02e+23]
+
+            # integer with scientific notation
+            1e-12
+            [1e-12]
+
+            Success
+
+            # stray character
+            100Z
+               ^
+            FAIL: Expected end of text (at char 3), (line:1, col:4)
+
+            # missing leading digit before '.'
+            -.100
+            ^
+            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1)
+
+            # too many '.'
+            3.14.159
+                ^
+            FAIL: Expected end of text (at char 4), (line:1, col:5)
+
+            Success
+
+        Each test string must be on a single line. If you want to test a string that spans multiple
+        lines, create a test like this::
+
+            expr.runTest(r"this is a test\\n of strings that spans \\n 3 lines")
+
+        (Note that this is a raw string literal, you must include the leading 'r'.)
+        """
+        if isinstance(tests, basestring):
+            tests = list(map(str.strip, tests.rstrip().splitlines()))
+        if isinstance(comment, basestring):
+            comment = Literal(comment)
+        if file is None:
+            file = sys.stdout
+        print_ = file.write
+
+        allResults = []
+        comments = []
+        success = True
+        NL = Literal(r'\n').addParseAction(replaceWith('\n')).ignore(quotedString)
+        BOM = u'\ufeff'
+        for t in tests:
+            if comment is not None and comment.matches(t, False) or comments and not t:
+                comments.append(t)
+                continue
+            if not t:
+                continue
+            out = ['\n' + '\n'.join(comments) if comments else '', t]
+            comments = []
+            try:
+                # convert newline marks to actual newlines, and strip leading BOM if present
+                t = NL.transformString(t.lstrip(BOM))
+                result = self.parseString(t, parseAll=parseAll)
+            except ParseBaseException as pe:
+                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else ""
+                if '\n' in t:
+                    out.append(line(pe.loc, t))
+                    out.append(' ' * (col(pe.loc, t) - 1) + '^' + fatal)
+                else:
+                    out.append(' ' * pe.loc + '^' + fatal)
+                out.append("FAIL: " + str(pe))
+                success = success and failureTests
+                result = pe
+            except Exception as exc:
+                out.append("FAIL-EXCEPTION: " + str(exc))
+                success = success and failureTests
+                result = exc
+            else:
+                success = success and not failureTests
+                if postParse is not None:
+                    try:
+                        pp_value = postParse(t, result)
+                        if pp_value is not None:
+                            if isinstance(pp_value, ParseResults):
+                                out.append(pp_value.dump())
+                            else:
+                                out.append(str(pp_value))
+                        else:
+                            out.append(result.dump())
+                    except Exception as e:
+                        out.append(result.dump(full=fullDump))
+                        out.append("{0} failed: {1}: {2}".format(postParse.__name__, type(e).__name__, e))
+                else:
+                    out.append(result.dump(full=fullDump))
+
+            if printResults:
+                if fullDump:
+                    out.append('')
+                print_('\n'.join(out))
+
+            allResults.append((t, result))
+
+        return success, allResults
+
+
+class _PendingSkip(ParserElement):
+    # internal placeholder class to hold a place were '...' is added to a parser element,
+    # once another ParserElement is added, this placeholder will be replaced with a SkipTo
+    def __init__(self, expr, must_skip=False):
+        super(_PendingSkip, self).__init__()
+        self.strRepr = str(expr + Empty()).replace('Empty', '...')
+        self.name = self.strRepr
+        self.anchor = expr
+        self.must_skip = must_skip
+
+    def __add__(self, other):
+        skipper = SkipTo(other).setName("...")("_skipped*")
+        if self.must_skip:
+            def must_skip(t):
+                if not t._skipped or t._skipped.asList() == ['']:
+                    del t[0]
+                    t.pop("_skipped", None)
+            def show_skip(t):
+                if t._skipped.asList()[-1:] == ['']:
+                    skipped = t.pop('_skipped')
+                    t['_skipped'] = 'missing <' + repr(self.anchor) + '>'
+            return (self.anchor + skipper().addParseAction(must_skip)
+                    | skipper().addParseAction(show_skip)) + other
+
+        return self.anchor + skipper + other
+
+    def __repr__(self):
+        return self.strRepr
+
+    def parseImpl(self, *args):
+        raise Exception("use of `...` expression without following SkipTo target expression")
+
+
+class Token(ParserElement):
+    """Abstract :class:`ParserElement` subclass, for defining atomic
+    matching patterns.
+    """
+    def __init__(self):
+        super(Token, self).__init__(savelist=False)
+
+
+class Empty(Token):
+    """An empty token, will always match.
+    """
+    def __init__(self):
+        super(Empty, self).__init__()
+        self.name = "Empty"
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+
+
+class NoMatch(Token):
+    """A token that will never match.
+    """
+    def __init__(self):
+        super(NoMatch, self).__init__()
+        self.name = "NoMatch"
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.errmsg = "Unmatchable token"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class Literal(Token):
+    """Token to exactly match a specified string.
+
+    Example::
+
+        Literal('blah').parseString('blah')  # -> ['blah']
+        Literal('blah').parseString('blahfooblah')  # -> ['blah']
+        Literal('blah').parseString('bla')  # -> Exception: Expected "blah"
+
+    For case-insensitive matching, use :class:`CaselessLiteral`.
+
+    For keyword matching (force word break before and after the matched string),
+    use :class:`Keyword` or :class:`CaselessKeyword`.
+    """
+    def __init__(self, matchString):
+        super(Literal, self).__init__()
+        self.match = matchString
+        self.matchLen = len(matchString)
+        try:
+            self.firstMatchChar = matchString[0]
+        except IndexError:
+            warnings.warn("null string passed to Literal; use Empty() instead",
+                            SyntaxWarning, stacklevel=2)
+            self.__class__ = Empty
+        self.name = '"%s"' % _ustr(self.match)
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = False
+        self.mayIndexError = False
+
+        # Performance tuning: modify __class__ to select
+        # a parseImpl optimized for single-character check
+        if self.matchLen == 1 and type(self) is Literal:
+            self.__class__ = _SingleCharLiteral
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if instring[loc] == self.firstMatchChar and instring.startswith(self.match, loc):
+            return loc + self.matchLen, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class _SingleCharLiteral(Literal):
+    def parseImpl(self, instring, loc, doActions=True):
+        if instring[loc] == self.firstMatchChar:
+            return loc + 1, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+
+_L = Literal
+ParserElement._literalStringClass = Literal
+
+class Keyword(Token):
+    """Token to exactly match a specified string as a keyword, that is,
+    it must be immediately followed by a non-keyword character.  Compare
+    with :class:`Literal`:
+
+     - ``Literal("if")`` will match the leading ``'if'`` in
+       ``'ifAndOnlyIf'``.
+     - ``Keyword("if")`` will not; it will only match the leading
+       ``'if'`` in ``'if x=1'``, or ``'if(y==2)'``
+
+    Accepts two optional constructor arguments in addition to the
+    keyword string:
+
+     - ``identChars`` is a string of characters that would be valid
+       identifier characters, defaulting to all alphanumerics + "_" and
+       "$"
+     - ``caseless`` allows case-insensitive matching, default is ``False``.
+
+    Example::
+
+        Keyword("start").parseString("start")  # -> ['start']
+        Keyword("start").parseString("starting")  # -> Exception
+
+    For case-insensitive matching, use :class:`CaselessKeyword`.
+    """
+    DEFAULT_KEYWORD_CHARS = alphanums + "_$"
+
+    def __init__(self, matchString, identChars=None, caseless=False):
+        super(Keyword, self).__init__()
+        if identChars is None:
+            identChars = Keyword.DEFAULT_KEYWORD_CHARS
+        self.match = matchString
+        self.matchLen = len(matchString)
+        try:
+            self.firstMatchChar = matchString[0]
+        except IndexError:
+            warnings.warn("null string passed to Keyword; use Empty() instead",
+                          SyntaxWarning, stacklevel=2)
+        self.name = '"%s"' % self.match
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = False
+        self.mayIndexError = False
+        self.caseless = caseless
+        if caseless:
+            self.caselessmatch = matchString.upper()
+            identChars = identChars.upper()
+        self.identChars = set(identChars)
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if self.caseless:
+            if ((instring[loc:loc + self.matchLen].upper() == self.caselessmatch)
+                    and (loc >= len(instring) - self.matchLen
+                         or instring[loc + self.matchLen].upper() not in self.identChars)
+                    and (loc == 0
+                         or instring[loc - 1].upper() not in self.identChars)):
+                return loc + self.matchLen, self.match
+
+        else:
+            if instring[loc] == self.firstMatchChar:
+                if ((self.matchLen == 1 or instring.startswith(self.match, loc))
+                        and (loc >= len(instring) - self.matchLen
+                             or instring[loc + self.matchLen] not in self.identChars)
+                        and (loc == 0 or instring[loc - 1] not in self.identChars)):
+                    return loc + self.matchLen, self.match
+
+        raise ParseException(instring, loc, self.errmsg, self)
+
+    def copy(self):
+        c = super(Keyword, self).copy()
+        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS
+        return c
+
+    @staticmethod
+    def setDefaultKeywordChars(chars):
+        """Overrides the default Keyword chars
+        """
+        Keyword.DEFAULT_KEYWORD_CHARS = chars
+
+class CaselessLiteral(Literal):
+    """Token to match a specified string, ignoring case of letters.
+    Note: the matched results will always be in the case of the given
+    match string, NOT the case of the input text.
+
+    Example::
+
+        OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD']
+
+    (Contrast with example for :class:`CaselessKeyword`.)
+    """
+    def __init__(self, matchString):
+        super(CaselessLiteral, self).__init__(matchString.upper())
+        # Preserve the defining literal.
+        self.returnString = matchString
+        self.name = "'%s'" % self.returnString
+        self.errmsg = "Expected " + self.name
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if instring[loc:loc + self.matchLen].upper() == self.match:
+            return loc + self.matchLen, self.returnString
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class CaselessKeyword(Keyword):
+    """
+    Caseless version of :class:`Keyword`.
+
+    Example::
+
+        OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']
+
+    (Contrast with example for :class:`CaselessLiteral`.)
+    """
+    def __init__(self, matchString, identChars=None):
+        super(CaselessKeyword, self).__init__(matchString, identChars, caseless=True)
+
+class CloseMatch(Token):
+    """A variation on :class:`Literal` which matches "close" matches,
+    that is, strings with at most 'n' mismatching characters.
+    :class:`CloseMatch` takes parameters:
+
+     - ``match_string`` - string to be matched
+     - ``maxMismatches`` - (``default=1``) maximum number of
+       mismatches allowed to count as a match
+
+    The results from a successful parse will contain the matched text
+    from the input string and the following named results:
+
+     - ``mismatches`` - a list of the positions within the
+       match_string where mismatches were found
+     - ``original`` - the original match_string used to compare
+       against the input string
+
+    If ``mismatches`` is an empty list, then the match was an exact
+    match.
+
+    Example::
+
+        patt = CloseMatch("ATCATCGAATGGA")
+        patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})
+        patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)
+
+        # exact match
+        patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})
+
+        # close match allowing up to 2 mismatches
+        patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2)
+        patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})
+    """
+    def __init__(self, match_string, maxMismatches=1):
+        super(CloseMatch, self).__init__()
+        self.name = match_string
+        self.match_string = match_string
+        self.maxMismatches = maxMismatches
+        self.errmsg = "Expected %r (with up to %d mismatches)" % (self.match_string, self.maxMismatches)
+        self.mayIndexError = False
+        self.mayReturnEmpty = False
+
+    def parseImpl(self, instring, loc, doActions=True):
+        start = loc
+        instrlen = len(instring)
+        maxloc = start + len(self.match_string)
+
+        if maxloc <= instrlen:
+            match_string = self.match_string
+            match_stringloc = 0
+            mismatches = []
+            maxMismatches = self.maxMismatches
+
+            for match_stringloc, s_m in enumerate(zip(instring[loc:maxloc], match_string)):
+                src, mat = s_m
+                if src != mat:
+                    mismatches.append(match_stringloc)
+                    if len(mismatches) > maxMismatches:
+                        break
+            else:
+                loc = match_stringloc + 1
+                results = ParseResults([instring[start:loc]])
+                results['original'] = match_string
+                results['mismatches'] = mismatches
+                return loc, results
+
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class Word(Token):
+    """Token for matching words composed of allowed character sets.
+    Defined with string containing all allowed initial characters, an
+    optional string containing allowed body characters (if omitted,
+    defaults to the initial character set), and an optional minimum,
+    maximum, and/or exact length.  The default value for ``min`` is
+    1 (a minimum value < 1 is not valid); the default values for
+    ``max`` and ``exact`` are 0, meaning no maximum or exact
+    length restriction. An optional ``excludeChars`` parameter can
+    list characters that might be found in the input ``bodyChars``
+    string; useful to define a word of all printables except for one or
+    two characters, for instance.
+
+    :class:`srange` is useful for defining custom character set strings
+    for defining ``Word`` expressions, using range notation from
+    regular expression character sets.
+
+    A common mistake is to use :class:`Word` to match a specific literal
+    string, as in ``Word("Address")``. Remember that :class:`Word`
+    uses the string argument to define *sets* of matchable characters.
+    This expression would match "Add", "AAA", "dAred", or any other word
+    made up of the characters 'A', 'd', 'r', 'e', and 's'. To match an
+    exact literal string, use :class:`Literal` or :class:`Keyword`.
+
+    pyparsing includes helper strings for building Words:
+
+     - :class:`alphas`
+     - :class:`nums`
+     - :class:`alphanums`
+     - :class:`hexnums`
+     - :class:`alphas8bit` (alphabetic characters in ASCII range 128-255
+       - accented, tilded, umlauted, etc.)
+     - :class:`punc8bit` (non-alphabetic characters in ASCII range
+       128-255 - currency, symbols, superscripts, diacriticals, etc.)
+     - :class:`printables` (any non-whitespace character)
+
+    Example::
+
+        # a word composed of digits
+        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))
+
+        # a word with a leading capital, and zero or more lowercase
+        capital_word = Word(alphas.upper(), alphas.lower())
+
+        # hostnames are alphanumeric, with leading alpha, and '-'
+        hostname = Word(alphas, alphanums + '-')
+
+        # roman numeral (not a strict parser, accepts invalid mix of characters)
+        roman = Word("IVXLCDM")
+
+        # any string of non-whitespace characters, except for ','
+        csv_value = Word(printables, excludeChars=",")
+    """
+    def __init__(self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None):
+        super(Word, self).__init__()
+        if excludeChars:
+            excludeChars = set(excludeChars)
+            initChars = ''.join(c for c in initChars if c not in excludeChars)
+            if bodyChars:
+                bodyChars = ''.join(c for c in bodyChars if c not in excludeChars)
+        self.initCharsOrig = initChars
+        self.initChars = set(initChars)
+        if bodyChars:
+            self.bodyCharsOrig = bodyChars
+            self.bodyChars = set(bodyChars)
+        else:
+            self.bodyCharsOrig = initChars
+            self.bodyChars = set(initChars)
+
+        self.maxSpecified = max > 0
+
+        if min < 1:
+            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.asKeyword = asKeyword
+
+        if ' ' not in self.initCharsOrig + self.bodyCharsOrig and (min == 1 and max == 0 and exact == 0):
+            if self.bodyCharsOrig == self.initCharsOrig:
+                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)
+            elif len(self.initCharsOrig) == 1:
+                self.reString = "%s[%s]*" % (re.escape(self.initCharsOrig),
+                                             _escapeRegexRangeChars(self.bodyCharsOrig),)
+            else:
+                self.reString = "[%s][%s]*" % (_escapeRegexRangeChars(self.initCharsOrig),
+                                               _escapeRegexRangeChars(self.bodyCharsOrig),)
+            if self.asKeyword:
+                self.reString = r"\b" + self.reString + r"\b"
+
+            try:
+                self.re = re.compile(self.reString)
+            except Exception:
+                self.re = None
+            else:
+                self.re_match = self.re.match
+                self.__class__ = _WordRegex
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if instring[loc] not in self.initChars:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        start = loc
+        loc += 1
+        instrlen = len(instring)
+        bodychars = self.bodyChars
+        maxloc = start + self.maxLen
+        maxloc = min(maxloc, instrlen)
+        while loc < maxloc and instring[loc] in bodychars:
+            loc += 1
+
+        throwException = False
+        if loc - start < self.minLen:
+            throwException = True
+        elif self.maxSpecified and loc < instrlen and instring[loc] in bodychars:
+            throwException = True
+        elif self.asKeyword:
+            if (start > 0 and instring[start - 1] in bodychars
+                    or loc < instrlen and instring[loc] in bodychars):
+                throwException = True
+
+        if throwException:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+    def __str__(self):
+        try:
+            return super(Word, self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+
+            def charsAsStr(s):
+                if len(s) > 4:
+                    return s[:4] + "..."
+                else:
+                    return s
+
+            if self.initCharsOrig != self.bodyCharsOrig:
+                self.strRepr = "W:(%s, %s)" % (charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig))
+            else:
+                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)
+
+        return self.strRepr
+
+class _WordRegex(Word):
+    def parseImpl(self, instring, loc, doActions=True):
+        result = self.re_match(instring, loc)
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        return loc, result.group()
+
+
+class Char(_WordRegex):
+    """A short-cut class for defining ``Word(characters, exact=1)``,
+    when defining a match of any single character in a string of
+    characters.
+    """
+    def __init__(self, charset, asKeyword=False, excludeChars=None):
+        super(Char, self).__init__(charset, exact=1, asKeyword=asKeyword, excludeChars=excludeChars)
+        self.reString = "[%s]" % _escapeRegexRangeChars(''.join(self.initChars))
+        if asKeyword:
+            self.reString = r"\b%s\b" % self.reString
+        self.re = re.compile(self.reString)
+        self.re_match = self.re.match
+
+
+class Regex(Token):
+    r"""Token for matching strings that match a given regular
+    expression. Defined with string specifying the regular expression in
+    a form recognized by the stdlib Python  `re module <https://docs.python.org/3/library/re.html>`_.
+    If the given regex contains named groups (defined using ``(?P<name>...)``),
+    these will be preserved as named parse results.
+
+    If instead of the Python stdlib re module you wish to use a different RE module
+    (such as the `regex` module), you can replace it by either building your
+    Regex object with a compiled RE that was compiled using regex:
+
+    Example::
+
+        realnum = Regex(r"[+-]?\d+\.\d*")
+        date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)')
+        # ref: https://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression
+        roman = Regex(r"M{0,4}(CM|CD|D?{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
+
+        # use regex module instead of stdlib re module to construct a Regex using
+        # a compiled regular expression
+        import regex
+        parser = pp.Regex(regex.compile(r'[0-9]'))
+
+    """
+    def __init__(self, pattern, flags=0, asGroupList=False, asMatch=False):
+        """The parameters ``pattern`` and ``flags`` are passed
+        to the ``re.compile()`` function as-is. See the Python
+        `re module <https://docs.python.org/3/library/re.html>`_ module for an
+        explanation of the acceptable patterns and flags.
+        """
+        super(Regex, self).__init__()
+
+        if isinstance(pattern, basestring):
+            if not pattern:
+                warnings.warn("null string passed to Regex; use Empty() instead",
+                              SyntaxWarning, stacklevel=2)
+
+            self.pattern = pattern
+            self.flags = flags
+
+            try:
+                self.re = re.compile(self.pattern, self.flags)
+                self.reString = self.pattern
+            except sre_constants.error:
+                warnings.warn("invalid pattern (%s) passed to Regex" % pattern,
+                              SyntaxWarning, stacklevel=2)
+                raise
+
+        elif hasattr(pattern, 'pattern') and hasattr(pattern, 'match'):
+            self.re = pattern
+            self.pattern = self.reString = pattern.pattern
+            self.flags = flags
+
+        else:
+            raise TypeError("Regex may only be constructed with a string or a compiled RE object")
+
+        self.re_match = self.re.match
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.mayReturnEmpty = self.re_match("") is not None
+        self.asGroupList = asGroupList
+        self.asMatch = asMatch
+        if self.asGroupList:
+            self.parseImpl = self.parseImplAsGroupList
+        if self.asMatch:
+            self.parseImpl = self.parseImplAsMatch
+
+    def parseImpl(self, instring, loc, doActions=True):
+        result = self.re_match(instring, loc)
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        ret = ParseResults(result.group())
+        d = result.groupdict()
+        if d:
+            for k, v in d.items():
+                ret[k] = v
+        return loc, ret
+
+    def parseImplAsGroupList(self, instring, loc, doActions=True):
+        result = self.re_match(instring, loc)
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        ret = result.groups()
+        return loc, ret
+
+    def parseImplAsMatch(self, instring, loc, doActions=True):
+        result = self.re_match(instring, loc)
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        ret = result
+        return loc, ret
+
+    def __str__(self):
+        try:
+            return super(Regex, self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "Re:(%s)" % repr(self.pattern)
+
+        return self.strRepr
+
+    def sub(self, repl):
+        r"""
+        Return Regex with an attached parse action to transform the parsed
+        result as if called using `re.sub(expr, repl, string) <https://docs.python.org/3/library/re.html#re.sub>`_.
+
+        Example::
+
+            make_html = Regex(r"(\w+):(.*?):").sub(r"<\1>\2</\1>")
+            print(make_html.transformString("h1:main title:"))
+            # prints "<h1>main title</h1>"
+        """
+        if self.asGroupList:
+            warnings.warn("cannot use sub() with Regex(asGroupList=True)",
+                          SyntaxWarning, stacklevel=2)
+            raise SyntaxError()
+
+        if self.asMatch and callable(repl):
+            warnings.warn("cannot use sub() with a callable with Regex(asMatch=True)",
+                          SyntaxWarning, stacklevel=2)
+            raise SyntaxError()
+
+        if self.asMatch:
+            def pa(tokens):
+                return tokens[0].expand(repl)
+        else:
+            def pa(tokens):
+                return self.re.sub(repl, tokens[0])
+        return self.addParseAction(pa)
+
+class QuotedString(Token):
+    r"""
+    Token for matching strings that are delimited by quoting characters.
+
+    Defined with the following parameters:
+
+        - quoteChar - string of one or more characters defining the
+          quote delimiting string
+        - escChar - character to escape quotes, typically backslash
+          (default= ``None``)
+        - escQuote - special quote sequence to escape an embedded quote
+          string (such as SQL's ``""`` to escape an embedded ``"``)
+          (default= ``None``)
+        - multiline - boolean indicating whether quotes can span
+          multiple lines (default= ``False``)
+        - unquoteResults - boolean indicating whether the matched text
+          should be unquoted (default= ``True``)
+        - endQuoteChar - string of one or more characters defining the
+          end of the quote delimited string (default= ``None``  => same as
+          quoteChar)
+        - convertWhitespaceEscapes - convert escaped whitespace
+          (``'\t'``, ``'\n'``, etc.) to actual whitespace
+          (default= ``True``)
+
+    Example::
+
+        qs = QuotedString('"')
+        print(qs.searchString('lsjdf "This is the quote" sldjf'))
+        complex_qs = QuotedString('{{', endQuoteChar='}}')
+        print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf'))
+        sql_qs = QuotedString('"', escQuote='""')
+        print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))
+
+    prints::
+
+        [['This is the quote']]
+        [['This is the "quote"']]
+        [['This is the quote with "embedded" quotes']]
+    """
+    def __init__(self, quoteChar, escChar=None, escQuote=None, multiline=False,
+                 unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True):
+        super(QuotedString, self).__init__()
+
+        # remove white space from quote chars - wont work anyway
+        quoteChar = quoteChar.strip()
+        if not quoteChar:
+            warnings.warn("quoteChar cannot be the empty string", SyntaxWarning, stacklevel=2)
+            raise SyntaxError()
+
+        if endQuoteChar is None:
+            endQuoteChar = quoteChar
+        else:
+            endQuoteChar = endQuoteChar.strip()
+            if not endQuoteChar:
+                warnings.warn("endQuoteChar cannot be the empty string", SyntaxWarning, stacklevel=2)
+                raise SyntaxError()
+
+        self.quoteChar = quoteChar
+        self.quoteCharLen = len(quoteChar)
+        self.firstQuoteChar = quoteChar[0]
+        self.endQuoteChar = endQuoteChar
+        self.endQuoteCharLen = len(endQuoteChar)
+        self.escChar = escChar
+        self.escQuote = escQuote
+        self.unquoteResults = unquoteResults
+        self.convertWhitespaceEscapes = convertWhitespaceEscapes
+
+        if multiline:
+            self.flags = re.MULTILINE | re.DOTALL
+            self.pattern = r'%s(?:[^%s%s]' % (re.escape(self.quoteChar),
+                                              _escapeRegexRangeChars(self.endQuoteChar[0]),
+                                              (escChar is not None and _escapeRegexRangeChars(escChar) or ''))
+        else:
+            self.flags = 0
+            self.pattern = r'%s(?:[^%s\n\r%s]' % (re.escape(self.quoteChar),
+                                                  _escapeRegexRangeChars(self.endQuoteChar[0]),
+                                                  (escChar is not None and _escapeRegexRangeChars(escChar) or ''))
+        if len(self.endQuoteChar) > 1:
+            self.pattern += (
+                '|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]),
+                                                   _escapeRegexRangeChars(self.endQuoteChar[i]))
+                                      for i in range(len(self.endQuoteChar) - 1, 0, -1)) + ')')
+
+        if escQuote:
+            self.pattern += (r'|(?:%s)' % re.escape(escQuote))
+        if escChar:
+            self.pattern += (r'|(?:%s.)' % re.escape(escChar))
+            self.escCharReplacePattern = re.escape(self.escChar) + "(.)"
+        self.pattern += (r')*%s' % re.escape(self.endQuoteChar))
+
+        try:
+            self.re = re.compile(self.pattern, self.flags)
+            self.reString = self.pattern
+            self.re_match = self.re.match
+        except sre_constants.error:
+            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,
+                          SyntaxWarning, stacklevel=2)
+            raise
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.mayReturnEmpty = True
+
+    def parseImpl(self, instring, loc, doActions=True):
+        result = instring[loc] == self.firstQuoteChar and self.re_match(instring, loc) or None
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        ret = result.group()
+
+        if self.unquoteResults:
+
+            # strip off quotes
+            ret = ret[self.quoteCharLen: -self.endQuoteCharLen]
+
+            if isinstance(ret, basestring):
+                # replace escaped whitespace
+                if '\\' in ret and self.convertWhitespaceEscapes:
+                    ws_map = {
+                        r'\t': '\t',
+                        r'\n': '\n',
+                        r'\f': '\f',
+                        r'\r': '\r',
+                    }
+                    for wslit, wschar in ws_map.items():
+                        ret = ret.replace(wslit, wschar)
+
+                # replace escaped characters
+                if self.escChar:
+                    ret = re.sub(self.escCharReplacePattern, r"\g<1>", ret)
+
+                # replace escaped quotes
+                if self.escQuote:
+                    ret = ret.replace(self.escQuote, self.endQuoteChar)
+
+        return loc, ret
+
+    def __str__(self):
+        try:
+            return super(QuotedString, self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)
+
+        return self.strRepr
+
+
+class CharsNotIn(Token):
+    """Token for matching words composed of characters *not* in a given
+    set (will include whitespace in matched characters if not listed in
+    the provided exclusion set - see example). Defined with string
+    containing all disallowed characters, and an optional minimum,
+    maximum, and/or exact length.  The default value for ``min`` is
+    1 (a minimum value < 1 is not valid); the default values for
+    ``max`` and ``exact`` are 0, meaning no maximum or exact
+    length restriction.
+
+    Example::
+
+        # define a comma-separated-value as anything that is not a ','
+        csv_value = CharsNotIn(',')
+        print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213"))
+
+    prints::
+
+        ['dkls', 'lsdkjf', 's12 34', '@!#', '213']
+    """
+    def __init__(self, notChars, min=1, max=0, exact=0):
+        super(CharsNotIn, self).__init__()
+        self.skipWhitespace = False
+        self.notChars = notChars
+
+        if min < 1:
+            raise ValueError("cannot specify a minimum length < 1; use "
+                             "Optional(CharsNotIn()) if zero-length char group is permitted")
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = (self.minLen == 0)
+        self.mayIndexError = False
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if instring[loc] in self.notChars:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        start = loc
+        loc += 1
+        notchars = self.notChars
+        maxlen = min(start + self.maxLen, len(instring))
+        while loc < maxlen and instring[loc] not in notchars:
+            loc += 1
+
+        if loc - start < self.minLen:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+    def __str__(self):
+        try:
+            return super(CharsNotIn, self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            if len(self.notChars) > 4:
+                self.strRepr = "!W:(%s...)" % self.notChars[:4]
+            else:
+                self.strRepr = "!W:(%s)" % self.notChars
+
+        return self.strRepr
+
+class White(Token):
+    """Special matching class for matching whitespace.  Normally,
+    whitespace is ignored by pyparsing grammars.  This class is included
+    when some whitespace structures are significant.  Define with
+    a string containing the whitespace characters to be matched; default
+    is ``" \\t\\r\\n"``.  Also takes optional ``min``,
+    ``max``, and ``exact`` arguments, as defined for the
+    :class:`Word` class.
+    """
+    whiteStrs = {
+        ' ' : '<SP>',
+        '\t': '<TAB>',
+        '\n': '<LF>',
+        '\r': '<CR>',
+        '\f': '<FF>',
+        u'\u00A0': '<NBSP>',
+        u'\u1680': '<OGHAM_SPACE_MARK>',
+        u'\u180E': '<MONGOLIAN_VOWEL_SEPARATOR>',
+        u'\u2000': '<EN_QUAD>',
+        u'\u2001': '<EM_QUAD>',
+        u'\u2002': '<EN_SPACE>',
+        u'\u2003': '<EM_SPACE>',
+        u'\u2004': '<THREE-PER-EM_SPACE>',
+        u'\u2005': '<FOUR-PER-EM_SPACE>',
+        u'\u2006': '<SIX-PER-EM_SPACE>',
+        u'\u2007': '<FIGURE_SPACE>',
+        u'\u2008': '<PUNCTUATION_SPACE>',
+        u'\u2009': '<THIN_SPACE>',
+        u'\u200A': '<HAIR_SPACE>',
+        u'\u200B': '<ZERO_WIDTH_SPACE>',
+        u'\u202F': '<NNBSP>',
+        u'\u205F': '<MMSP>',
+        u'\u3000': '<IDEOGRAPHIC_SPACE>',
+        }
+    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):
+        super(White, self).__init__()
+        self.matchWhite = ws
+        self.setWhitespaceChars("".join(c for c in self.whiteChars if c not in self.matchWhite))
+        # ~ self.leaveWhitespace()
+        self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite))
+        self.mayReturnEmpty = True
+        self.errmsg = "Expected " + self.name
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if instring[loc] not in self.matchWhite:
+            raise ParseException(instring, loc, self.errmsg, self)
+        start = loc
+        loc += 1
+        maxloc = start + self.maxLen
+        maxloc = min(maxloc, len(instring))
+        while loc < maxloc and instring[loc] in self.matchWhite:
+            loc += 1
+
+        if loc - start < self.minLen:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+
+class _PositionToken(Token):
+    def __init__(self):
+        super(_PositionToken, self).__init__()
+        self.name = self.__class__.__name__
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+
+class GoToColumn(_PositionToken):
+    """Token to advance to a specific column of input text; useful for
+    tabular report scraping.
+    """
+    def __init__(self, colno):
+        super(GoToColumn, self).__init__()
+        self.col = colno
+
+    def preParse(self, instring, loc):
+        if col(loc, instring) != self.col:
+            instrlen = len(instring)
+            if self.ignoreExprs:
+                loc = self._skipIgnorables(instring, loc)
+            while loc < instrlen and instring[loc].isspace() and col(loc, instring) != self.col:
+                loc += 1
+        return loc
+
+    def parseImpl(self, instring, loc, doActions=True):
+        thiscol = col(loc, instring)
+        if thiscol > self.col:
+            raise ParseException(instring, loc, "Text not in expected column", self)
+        newloc = loc + self.col - thiscol
+        ret = instring[loc: newloc]
+        return newloc, ret
+
+
+class LineStart(_PositionToken):
+    r"""Matches if current position is at the beginning of a line within
+    the parse string
+
+    Example::
+
+        test = '''\
+        AAA this line
+        AAA and this line
+          AAA but not this one
+        B AAA and definitely not this one
+        '''
+
+        for t in (LineStart() + 'AAA' + restOfLine).searchString(test):
+            print(t)
+
+    prints::
+
+        ['AAA', ' this line']
+        ['AAA', ' and this line']
+
+    """
+    def __init__(self):
+        super(LineStart, self).__init__()
+        self.errmsg = "Expected start of line"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if col(loc, instring) == 1:
+            return loc, []
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class LineEnd(_PositionToken):
+    """Matches if current position is at the end of a line within the
+    parse string
+    """
+    def __init__(self):
+        super(LineEnd, self).__init__()
+        self.setWhitespaceChars(ParserElement.DEFAULT_WHITE_CHARS.replace("\n", ""))
+        self.errmsg = "Expected end of line"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if loc < len(instring):
+            if instring[loc] == "\n":
+                return loc + 1, "\n"
+            else:
+                raise ParseException(instring, loc, self.errmsg, self)
+        elif loc == len(instring):
+            return loc + 1, []
+        else:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+class StringStart(_PositionToken):
+    """Matches if current position is at the beginning of the parse
+    string
+    """
+    def __init__(self):
+        super(StringStart, self).__init__()
+        self.errmsg = "Expected start of text"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if loc != 0:
+            # see if entire string up to here is just whitespace and ignoreables
+            if loc != self.preParse(instring, 0):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+class StringEnd(_PositionToken):
+    """Matches if current position is at the end of the parse string
+    """
+    def __init__(self):
+        super(StringEnd, self).__init__()
+        self.errmsg = "Expected end of text"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if loc < len(instring):
+            raise ParseException(instring, loc, self.errmsg, self)
+        elif loc == len(instring):
+            return loc + 1, []
+        elif loc > len(instring):
+            return loc, []
+        else:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+class WordStart(_PositionToken):
+    """Matches if the current position is at the beginning of a Word,
+    and is not preceded by any character in a given set of
+    ``wordChars`` (default= ``printables``). To emulate the
+    ``\b`` behavior of regular expressions, use
+    ``WordStart(alphanums)``. ``WordStart`` will also match at
+    the beginning of the string being parsed, or at the beginning of
+    a line.
+    """
+    def __init__(self, wordChars=printables):
+        super(WordStart, self).__init__()
+        self.wordChars = set(wordChars)
+        self.errmsg = "Not at the start of a word"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if loc != 0:
+            if (instring[loc - 1] in self.wordChars
+                    or instring[loc] not in self.wordChars):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+class WordEnd(_PositionToken):
+    """Matches if the current position is at the end of a Word, and is
+    not followed by any character in a given set of ``wordChars``
+    (default= ``printables``). To emulate the ``\b`` behavior of
+    regular expressions, use ``WordEnd(alphanums)``. ``WordEnd``
+    will also match at the end of the string being parsed, or at the end
+    of a line.
+    """
+    def __init__(self, wordChars=printables):
+        super(WordEnd, self).__init__()
+        self.wordChars = set(wordChars)
+        self.skipWhitespace = False
+        self.errmsg = "Not at the end of a word"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        instrlen = len(instring)
+        if instrlen > 0 and loc < instrlen:
+            if (instring[loc] in self.wordChars or
+                    instring[loc - 1] not in self.wordChars):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+
+class ParseExpression(ParserElement):
+    """Abstract subclass of ParserElement, for combining and
+    post-processing parsed tokens.
+    """
+    def __init__(self, exprs, savelist=False):
+        super(ParseExpression, self).__init__(savelist)
+        if isinstance(exprs, _generatorType):
+            exprs = list(exprs)
+
+        if isinstance(exprs, basestring):
+            self.exprs = [self._literalStringClass(exprs)]
+        elif isinstance(exprs, ParserElement):
+            self.exprs = [exprs]
+        elif isinstance(exprs, Iterable):
+            exprs = list(exprs)
+            # if sequence of strings provided, wrap with Literal
+            if any(isinstance(expr, basestring) for expr in exprs):
+                exprs = (self._literalStringClass(e) if isinstance(e, basestring) else e for e in exprs)
+            self.exprs = list(exprs)
+        else:
+            try:
+                self.exprs = list(exprs)
+            except TypeError:
+                self.exprs = [exprs]
+        self.callPreparse = False
+
+    def append(self, other):
+        self.exprs.append(other)
+        self.strRepr = None
+        return self
+
+    def leaveWhitespace(self):
+        """Extends ``leaveWhitespace`` defined in base class, and also invokes ``leaveWhitespace`` on
+           all contained expressions."""
+        self.skipWhitespace = False
+        self.exprs = [e.copy() for e in self.exprs]
+        for e in self.exprs:
+            e.leaveWhitespace()
+        return self
+
+    def ignore(self, other):
+        if isinstance(other, Suppress):
+            if other not in self.ignoreExprs:
+                super(ParseExpression, self).ignore(other)
+                for e in self.exprs:
+                    e.ignore(self.ignoreExprs[-1])
+        else:
+            super(ParseExpression, self).ignore(other)
+            for e in self.exprs:
+                e.ignore(self.ignoreExprs[-1])
+        return self
+
+    def __str__(self):
+        try:
+            return super(ParseExpression, self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "%s:(%s)" % (self.__class__.__name__, _ustr(self.exprs))
+        return self.strRepr
+
+    def streamline(self):
+        super(ParseExpression, self).streamline()
+
+        for e in self.exprs:
+            e.streamline()
+
+        # collapse nested And's of the form And(And(And(a, b), c), d) to And(a, b, c, d)
+        # but only if there are no parse actions or resultsNames on the nested And's
+        # (likewise for Or's and MatchFirst's)
+        if len(self.exprs) == 2:
+            other = self.exprs[0]
+            if (isinstance(other, self.__class__)
+                    and not other.parseAction
+                    and other.resultsName is None
+                    and not other.debug):
+                self.exprs = other.exprs[:] + [self.exprs[1]]
+                self.strRepr = None
+                self.mayReturnEmpty |= other.mayReturnEmpty
+                self.mayIndexError  |= other.mayIndexError
+
+            other = self.exprs[-1]
+            if (isinstance(other, self.__class__)
+                    and not other.parseAction
+                    and other.resultsName is None
+                    and not other.debug):
+                self.exprs = self.exprs[:-1] + other.exprs[:]
+                self.strRepr = None
+                self.mayReturnEmpty |= other.mayReturnEmpty
+                self.mayIndexError  |= other.mayIndexError
+
+        self.errmsg = "Expected " + _ustr(self)
+
+        return self
+
+    def validate(self, validateTrace=None):
+        tmp = (validateTrace if validateTrace is not None else [])[:] + [self]
+        for e in self.exprs:
+            e.validate(tmp)
+        self.checkRecursion([])
+
+    def copy(self):
+        ret = super(ParseExpression, self).copy()
+        ret.exprs = [e.copy() for e in self.exprs]
+        return ret
+
+    def _setResultsName(self, name, listAllMatches=False):
+        if __diag__.warn_ungrouped_named_tokens_in_collection:
+            for e in self.exprs:
+                if isinstance(e, ParserElement) and e.resultsName:
+                    warnings.warn("{0}: setting results name {1!r} on {2} expression "
+                                  "collides with {3!r} on contained expression".format("warn_ungrouped_named_tokens_in_collection",
+                                                                                       name,
+                                                                                       type(self).__name__,
+                                                                                       e.resultsName),
+                                  stacklevel=3)
+
+        return super(ParseExpression, self)._setResultsName(name, listAllMatches)
+
+
+class And(ParseExpression):
+    """
+    Requires all given :class:`ParseExpression` s to be found in the given order.
+    Expressions may be separated by whitespace.
+    May be constructed using the ``'+'`` operator.
+    May also be constructed using the ``'-'`` operator, which will
+    suppress backtracking.
+
+    Example::
+
+        integer = Word(nums)
+        name_expr = OneOrMore(Word(alphas))
+
+        expr = And([integer("id"), name_expr("name"), integer("age")])
+        # more easily written as:
+        expr = integer("id") + name_expr("name") + integer("age")
+    """
+
+    class _ErrorStop(Empty):
+        def __init__(self, *args, **kwargs):
+            super(And._ErrorStop, self).__init__(*args, **kwargs)
+            self.name = '-'
+            self.leaveWhitespace()
+
+    def __init__(self, exprs, savelist=True):
+        exprs = list(exprs)
+        if exprs and Ellipsis in exprs:
+            tmp = []
+            for i, expr in enumerate(exprs):
+                if expr is Ellipsis:
+                    if i < len(exprs) - 1:
+                        skipto_arg = (Empty() + exprs[i + 1]).exprs[-1]
+                        tmp.append(SkipTo(skipto_arg)("_skipped*"))
+                    else:
+                        raise Exception("cannot construct And with sequence ending in ...")
+                else:
+                    tmp.append(expr)
+            exprs[:] = tmp
+        super(And, self).__init__(exprs, savelist)
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        self.setWhitespaceChars(self.exprs[0].whiteChars)
+        self.skipWhitespace = self.exprs[0].skipWhitespace
+        self.callPreparse = True
+
+    def streamline(self):
+        # collapse any _PendingSkip's
+        if self.exprs:
+            if any(isinstance(e, ParseExpression) and e.exprs and isinstance(e.exprs[-1], _PendingSkip)
+                   for e in self.exprs[:-1]):
+                for i, e in enumerate(self.exprs[:-1]):
+                    if e is None:
+                        continue
+                    if (isinstance(e, ParseExpression)
+                            and e.exprs and isinstance(e.exprs[-1], _PendingSkip)):
+                        e.exprs[-1] = e.exprs[-1] + self.exprs[i + 1]
+                        self.exprs[i + 1] = None
+                self.exprs = [e for e in self.exprs if e is not None]
+
+        super(And, self).streamline()
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        return self
+
+    def parseImpl(self, instring, loc, doActions=True):
+        # pass False as last arg to _parse for first element, since we already
+        # pre-parsed the string as part of our And pre-parsing
+        loc, resultlist = self.exprs[0]._parse(instring, loc, doActions, callPreParse=False)
+        errorStop = False
+        for e in self.exprs[1:]:
+            if isinstance(e, And._ErrorStop):
+                errorStop = True
+                continue
+            if errorStop:
+                try:
+                    loc, exprtokens = e._parse(instring, loc, doActions)
+                except ParseSyntaxException:
+                    raise
+                except ParseBaseException as pe:
+                    pe.__traceback__ = None
+                    raise ParseSyntaxException._from_exception(pe)
+                except IndexError:
+                    raise ParseSyntaxException(instring, len(instring), self.errmsg, self)
+            else:
+                loc, exprtokens = e._parse(instring, loc, doActions)
+            if exprtokens or exprtokens.haskeys():
+                resultlist += exprtokens
+        return loc, resultlist
+
+    def __iadd__(self, other):
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        return self.append(other)  # And([self, other])
+
+    def checkRecursion(self, parseElementList):
+        subRecCheckList = parseElementList[:] + [self]
+        for e in self.exprs:
+            e.checkRecursion(subRecCheckList)
+            if not e.mayReturnEmpty:
+                break
+
+    def __str__(self):
+        if hasattr(self, "name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+
+class Or(ParseExpression):
+    """Requires that at least one :class:`ParseExpression` is found. If
+    two expressions match, the expression that matches the longest
+    string will be used. May be constructed using the ``'^'``
+    operator.
+
+    Example::
+
+        # construct Or using '^' operator
+
+        number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums))
+        print(number.searchString("123 3.1416 789"))
+
+    prints::
+
+        [['123'], ['3.1416'], ['789']]
+    """
+    def __init__(self, exprs, savelist=False):
+        super(Or, self).__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+
+    def streamline(self):
+        super(Or, self).streamline()
+        if __compat__.collect_all_And_tokens:
+            self.saveAsList = any(e.saveAsList for e in self.exprs)
+        return self
+
+    def parseImpl(self, instring, loc, doActions=True):
+        maxExcLoc = -1
+        maxException = None
+        matches = []
+        for e in self.exprs:
+            try:
+                loc2 = e.tryParse(instring, loc)
+            except ParseException as err:
+                err.__traceback__ = None
+                if err.loc > maxExcLoc:
+                    maxException = err
+                    maxExcLoc = err.loc
+            except IndexError:
+                if len(instring) > maxExcLoc:
+                    maxException = ParseException(instring, len(instring), e.errmsg, self)
+                    maxExcLoc = len(instring)
+            else:
+                # save match among all matches, to retry longest to shortest
+                matches.append((loc2, e))
+
+        if matches:
+            # re-evaluate all matches in descending order of length of match, in case attached actions
+            # might change whether or how much they match of the input.
+            matches.sort(key=itemgetter(0), reverse=True)
+
+            if not doActions:
+                # no further conditions or parse actions to change the selection of
+                # alternative, so the first match will be the best match
+                best_expr = matches[0][1]
+                return best_expr._parse(instring, loc, doActions)
+
+            longest = -1, None
+            for loc1, expr1 in matches:
+                if loc1 <= longest[0]:
+                    # already have a longer match than this one will deliver, we are done
+                    return longest
+
+                try:
+                    loc2, toks = expr1._parse(instring, loc, doActions)
+                except ParseException as err:
+                    err.__traceback__ = None
+                    if err.loc > maxExcLoc:
+                        maxException = err
+                        maxExcLoc = err.loc
+                else:
+                    if loc2 >= loc1:
+                        return loc2, toks
+                    # didn't match as much as before
+                    elif loc2 > longest[0]:
+                        longest = loc2, toks
+
+            if longest != (-1, None):
+                return longest
+
+        if maxException is not None:
+            maxException.msg = self.errmsg
+            raise maxException
+        else:
+            raise ParseException(instring, loc, "no defined alternatives to match", self)
+
+
+    def __ixor__(self, other):
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        return self.append(other)  # Or([self, other])
+
+    def __str__(self):
+        if hasattr(self, "name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion(self, parseElementList):
+        subRecCheckList = parseElementList[:] + [self]
+        for e in self.exprs:
+            e.checkRecursion(subRecCheckList)
+
+    def _setResultsName(self, name, listAllMatches=False):
+        if (not __compat__.collect_all_And_tokens
+                and __diag__.warn_multiple_tokens_in_named_alternation):
+            if any(isinstance(e, And) for e in self.exprs):
+                warnings.warn("{0}: setting results name {1!r} on {2} expression "
+                              "may only return a single token for an And alternative, "
+                              "in future will return the full list of tokens".format(
+                    "warn_multiple_tokens_in_named_alternation", name, type(self).__name__),
+                    stacklevel=3)
+
+        return super(Or, self)._setResultsName(name, listAllMatches)
+
+
+class MatchFirst(ParseExpression):
+    """Requires that at least one :class:`ParseExpression` is found. If
+    two expressions match, the first one listed is the one that will
+    match. May be constructed using the ``'|'`` operator.
+
+    Example::
+
+        # construct MatchFirst using '|' operator
+
+        # watch the order of expressions to match
+        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))
+        print(number.searchString("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']]
+
+        # put more selective expression first
+        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)
+        print(number.searchString("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']]
+    """
+    def __init__(self, exprs, savelist=False):
+        super(MatchFirst, self).__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+
+    def streamline(self):
+        super(MatchFirst, self).streamline()
+        if __compat__.collect_all_And_tokens:
+            self.saveAsList = any(e.saveAsList for e in self.exprs)
+        return self
+
+    def parseImpl(self, instring, loc, doActions=True):
+        maxExcLoc = -1
+        maxException = None
+        for e in self.exprs:
+            try:
+                ret = e._parse(instring, loc, doActions)
+                return ret
+            except ParseException as err:
+                if err.loc > maxExcLoc:
+                    maxException = err
+                    maxExcLoc = err.loc
+            except IndexError:
+                if len(instring) > maxExcLoc:
+                    maxException = ParseException(instring, len(instring), e.errmsg, self)
+                    maxExcLoc = len(instring)
+
+        # only got here if no expression matched, raise exception for match that made it the furthest
+        else:
+            if maxException is not None:
+                maxException.msg = self.errmsg
+                raise maxException
+            else:
+                raise ParseException(instring, loc, "no defined alternatives to match", self)
+
+    def __ior__(self, other):
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        return self.append(other)  # MatchFirst([self, other])
+
+    def __str__(self):
+        if hasattr(self, "name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion(self, parseElementList):
+        subRecCheckList = parseElementList[:] + [self]
+        for e in self.exprs:
+            e.checkRecursion(subRecCheckList)
+
+    def _setResultsName(self, name, listAllMatches=False):
+        if (not __compat__.collect_all_And_tokens
+                and __diag__.warn_multiple_tokens_in_named_alternation):
+            if any(isinstance(e, And) for e in self.exprs):
+                warnings.warn("{0}: setting results name {1!r} on {2} expression "
+                              "may only return a single token for an And alternative, "
+                              "in future will return the full list of tokens".format(
+                    "warn_multiple_tokens_in_named_alternation", name, type(self).__name__),
+                    stacklevel=3)
+
+        return super(MatchFirst, self)._setResultsName(name, listAllMatches)
+
+
+class Each(ParseExpression):
+    """Requires all given :class:`ParseExpression` s to be found, but in
+    any order. Expressions may be separated by whitespace.
+
+    May be constructed using the ``'&'`` operator.
+
+    Example::
+
+        color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")
+        shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")
+        integer = Word(nums)
+        shape_attr = "shape:" + shape_type("shape")
+        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")
+        color_attr = "color:" + color("color")
+        size_attr = "size:" + integer("size")
+
+        # use Each (using operator '&') to accept attributes in any order
+        # (shape and posn are required, color and size are optional)
+        shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr)
+
+        shape_spec.runTests('''
+            shape: SQUARE color: BLACK posn: 100, 120
+            shape: CIRCLE size: 50 color: BLUE posn: 50,80
+            color:GREEN size:20 shape:TRIANGLE posn:20,40
+            '''
+            )
+
+    prints::
+
+        shape: SQUARE color: BLACK posn: 100, 120
+        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]
+        - color: BLACK
+        - posn: ['100', ',', '120']
+          - x: 100
+          - y: 120
+        - shape: SQUARE
+
+
+        shape: CIRCLE size: 50 color: BLUE posn: 50,80
+        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]
+        - color: BLUE
+        - posn: ['50', ',', '80']
+          - x: 50
+          - y: 80
+        - shape: CIRCLE
+        - size: 50
+
+
+        color: GREEN size: 20 shape: TRIANGLE posn: 20,40
+        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]
+        - color: GREEN
+        - posn: ['20', ',', '40']
+          - x: 20
+          - y: 40
+        - shape: TRIANGLE
+        - size: 20
+    """
+    def __init__(self, exprs, savelist=True):
+        super(Each, self).__init__(exprs, savelist)
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        self.skipWhitespace = True
+        self.initExprGroups = True
+        self.saveAsList = True
+
+    def streamline(self):
+        super(Each, self).streamline()
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        return self
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if self.initExprGroups:
+            self.opt1map = dict((id(e.expr), e) for e in self.exprs if isinstance(e, Optional))
+            opt1 = [e.expr for e in self.exprs if isinstance(e, Optional)]
+            opt2 = [e for e in self.exprs if e.mayReturnEmpty and not isinstance(e, (Optional, Regex))]
+            self.optionals = opt1 + opt2
+            self.multioptionals = [e.expr for e in self.exprs if isinstance(e, ZeroOrMore)]
+            self.multirequired = [e.expr for e in self.exprs if isinstance(e, OneOrMore)]
+            self.required = [e for e in self.exprs if not isinstance(e, (Optional, ZeroOrMore, OneOrMore))]
+            self.required += self.multirequired
+            self.initExprGroups = False
+        tmpLoc = loc
+        tmpReqd = self.required[:]
+        tmpOpt  = self.optionals[:]
+        matchOrder = []
+
+        keepMatching = True
+        while keepMatching:
+            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired
+            failed = []
+            for e in tmpExprs:
+                try:
+                    tmpLoc = e.tryParse(instring, tmpLoc)
+                except ParseException:
+                    failed.append(e)
+                else:
+                    matchOrder.append(self.opt1map.get(id(e), e))
+                    if e in tmpReqd:
+                        tmpReqd.remove(e)
+                    elif e in tmpOpt:
+                        tmpOpt.remove(e)
+            if len(failed) == len(tmpExprs):
+                keepMatching = False
+
+        if tmpReqd:
+            missing = ", ".join(_ustr(e) for e in tmpReqd)
+            raise ParseException(instring, loc, "Missing one or more required elements (%s)" % missing)
+
+        # add any unmatched Optionals, in case they have default values defined
+        matchOrder += [e for e in self.exprs if isinstance(e, Optional) and e.expr in tmpOpt]
+
+        resultlist = []
+        for e in matchOrder:
+            loc, results = e._parse(instring, loc, doActions)
+            resultlist.append(results)
+
+        finalResults = sum(resultlist, ParseResults([]))
+        return loc, finalResults
+
+    def __str__(self):
+        if hasattr(self, "name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion(self, parseElementList):
+        subRecCheckList = parseElementList[:] + [self]
+        for e in self.exprs:
+            e.checkRecursion(subRecCheckList)
+
+
+class ParseElementEnhance(ParserElement):
+    """Abstract subclass of :class:`ParserElement`, for combining and
+    post-processing parsed tokens.
+    """
+    def __init__(self, expr, savelist=False):
+        super(ParseElementEnhance, self).__init__(savelist)
+        if isinstance(expr, basestring):
+            if issubclass(self._literalStringClass, Token):
+                expr = self._literalStringClass(expr)
+            else:
+                expr = self._literalStringClass(Literal(expr))
+        self.expr = expr
+        self.strRepr = None
+        if expr is not None:
+            self.mayIndexError = expr.mayIndexError
+            self.mayReturnEmpty = expr.mayReturnEmpty
+            self.setWhitespaceChars(expr.whiteChars)
+            self.skipWhitespace = expr.skipWhitespace
+            self.saveAsList = expr.saveAsList
+            self.callPreparse = expr.callPreparse
+            self.ignoreExprs.extend(expr.ignoreExprs)
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if self.expr is not None:
+            return self.expr._parse(instring, loc, doActions, callPreParse=False)
+        else:
+            raise ParseException("", loc, self.errmsg, self)
+
+    def leaveWhitespace(self):
+        self.skipWhitespace = False
+        self.expr = self.expr.copy()
+        if self.expr is not None:
+            self.expr.leaveWhitespace()
+        return self
+
+    def ignore(self, other):
+        if isinstance(other, Suppress):
+            if other not in self.ignoreExprs:
+                super(ParseElementEnhance, self).ignore(other)
+                if self.expr is not None:
+                    self.expr.ignore(self.ignoreExprs[-1])
+        else:
+            super(ParseElementEnhance, self).ignore(other)
+            if self.expr is not None:
+                self.expr.ignore(self.ignoreExprs[-1])
+        return self
+
+    def streamline(self):
+        super(ParseElementEnhance, self).streamline()
+        if self.expr is not None:
+            self.expr.streamline()
+        return self
+
+    def checkRecursion(self, parseElementList):
+        if self in parseElementList:
+            raise RecursiveGrammarException(parseElementList + [self])
+        subRecCheckList = parseElementList[:] + [self]
+        if self.expr is not None:
+            self.expr.checkRecursion(subRecCheckList)
+
+    def validate(self, validateTrace=None):
+        if validateTrace is None:
+            validateTrace = []
+        tmp = validateTrace[:] + [self]
+        if self.expr is not None:
+            self.expr.validate(tmp)
+        self.checkRecursion([])
+
+    def __str__(self):
+        try:
+            return super(ParseElementEnhance, self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None and self.expr is not None:
+            self.strRepr = "%s:(%s)" % (self.__class__.__name__, _ustr(self.expr))
+        return self.strRepr
+
+
+class FollowedBy(ParseElementEnhance):
+    """Lookahead matching of the given parse expression.
+    ``FollowedBy`` does *not* advance the parsing position within
+    the input string, it only verifies that the specified parse
+    expression matches at the current position.  ``FollowedBy``
+    always returns a null token list. If any results names are defined
+    in the lookahead expression, those *will* be returned for access by
+    name.
+
+    Example::
+
+        # use FollowedBy to match a label only if it is followed by a ':'
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+
+        OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint()
+
+    prints::
+
+        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]
+    """
+    def __init__(self, expr):
+        super(FollowedBy, self).__init__(expr)
+        self.mayReturnEmpty = True
+
+    def parseImpl(self, instring, loc, doActions=True):
+        # by using self._expr.parse and deleting the contents of the returned ParseResults list
+        # we keep any named results that were defined in the FollowedBy expression
+        _, ret = self.expr._parse(instring, loc, doActions=doActions)
+        del ret[:]
+
+        return loc, ret
+
+
+class PrecededBy(ParseElementEnhance):
+    """Lookbehind matching of the given parse expression.
+    ``PrecededBy`` does not advance the parsing position within the
+    input string, it only verifies that the specified parse expression
+    matches prior to the current position.  ``PrecededBy`` always
+    returns a null token list, but if a results name is defined on the
+    given expression, it is returned.
+
+    Parameters:
+
+     - expr - expression that must match prior to the current parse
+       location
+     - retreat - (default= ``None``) - (int) maximum number of characters
+       to lookbehind prior to the current parse location
+
+    If the lookbehind expression is a string, Literal, Keyword, or
+    a Word or CharsNotIn with a specified exact or maximum length, then
+    the retreat parameter is not required. Otherwise, retreat must be
+    specified to give a maximum number of characters to look back from
+    the current parse position for a lookbehind match.
+
+    Example::
+
+        # VB-style variable names with type prefixes
+        int_var = PrecededBy("#") + pyparsing_common.identifier
+        str_var = PrecededBy("$") + pyparsing_common.identifier
+
+    """
+    def __init__(self, expr, retreat=None):
+        super(PrecededBy, self).__init__(expr)
+        self.expr = self.expr().leaveWhitespace()
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.exact = False
+        if isinstance(expr, str):
+            retreat = len(expr)
+            self.exact = True
+        elif isinstance(expr, (Literal, Keyword)):
+            retreat = expr.matchLen
+            self.exact = True
+        elif isinstance(expr, (Word, CharsNotIn)) and expr.maxLen != _MAX_INT:
+            retreat = expr.maxLen
+            self.exact = True
+        elif isinstance(expr, _PositionToken):
+            retreat = 0
+            self.exact = True
+        self.retreat = retreat
+        self.errmsg = "not preceded by " + str(expr)
+        self.skipWhitespace = False
+        self.parseAction.append(lambda s, l, t: t.__delitem__(slice(None, None)))
+
+    def parseImpl(self, instring, loc=0, doActions=True):
+        if self.exact:
+            if loc < self.retreat:
+                raise ParseException(instring, loc, self.errmsg)
+            start = loc - self.retreat
+            _, ret = self.expr._parse(instring, start)
+        else:
+            # retreat specified a maximum lookbehind window, iterate
+            test_expr = self.expr + StringEnd()
+            instring_slice = instring[max(0, loc - self.retreat):loc]
+            last_expr = ParseException(instring, loc, self.errmsg)
+            for offset in range(1, min(loc, self.retreat + 1)+1):
+                try:
+                    # print('trying', offset, instring_slice, repr(instring_slice[loc - offset:]))
+                    _, ret = test_expr._parse(instring_slice, len(instring_slice) - offset)
+                except ParseBaseException as pbe:
+                    last_expr = pbe
+                else:
+                    break
+            else:
+                raise last_expr
+        return loc, ret
+
+
+class NotAny(ParseElementEnhance):
+    """Lookahead to disallow matching with the given parse expression.
+    ``NotAny`` does *not* advance the parsing position within the
+    input string, it only verifies that the specified parse expression
+    does *not* match at the current position.  Also, ``NotAny`` does
+    *not* skip over leading whitespace. ``NotAny`` always returns
+    a null token list.  May be constructed using the '~' operator.
+
+    Example::
+
+        AND, OR, NOT = map(CaselessKeyword, "AND OR NOT".split())
+
+        # take care not to mistake keywords for identifiers
+        ident = ~(AND | OR | NOT) + Word(alphas)
+        boolean_term = Optional(NOT) + ident
+
+        # very crude boolean expression - to support parenthesis groups and
+        # operation hierarchy, use infixNotation
+        boolean_expr = boolean_term + ZeroOrMore((AND | OR) + boolean_term)
+
+        # integers that are followed by "." are actually floats
+        integer = Word(nums) + ~Char(".")
+    """
+    def __init__(self, expr):
+        super(NotAny, self).__init__(expr)
+        # ~ self.leaveWhitespace()
+        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs
+        self.mayReturnEmpty = True
+        self.errmsg = "Found unwanted token, " + _ustr(self.expr)
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if self.expr.canParseNext(instring, loc):
+            raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+    def __str__(self):
+        if hasattr(self, "name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "~{" + _ustr(self.expr) + "}"
+
+        return self.strRepr
+
+class _MultipleMatch(ParseElementEnhance):
+    def __init__(self, expr, stopOn=None):
+        super(_MultipleMatch, self).__init__(expr)
+        self.saveAsList = True
+        ender = stopOn
+        if isinstance(ender, basestring):
+            ender = self._literalStringClass(ender)
+        self.stopOn(ender)
+
+    def stopOn(self, ender):
+        if isinstance(ender, basestring):
+            ender = self._literalStringClass(ender)
+        self.not_ender = ~ender if ender is not None else None
+        return self
+
+    def parseImpl(self, instring, loc, doActions=True):
+        self_expr_parse = self.expr._parse
+        self_skip_ignorables = self._skipIgnorables
+        check_ender = self.not_ender is not None
+        if check_ender:
+            try_not_ender = self.not_ender.tryParse
+
+        # must be at least one (but first see if we are the stopOn sentinel;
+        # if so, fail)
+        if check_ender:
+            try_not_ender(instring, loc)
+        loc, tokens = self_expr_parse(instring, loc, doActions, callPreParse=False)
+        try:
+            hasIgnoreExprs = (not not self.ignoreExprs)
+            while 1:
+                if check_ender:
+                    try_not_ender(instring, loc)
+                if hasIgnoreExprs:
+                    preloc = self_skip_ignorables(instring, loc)
+                else:
+                    preloc = loc
+                loc, tmptokens = self_expr_parse(instring, preloc, doActions)
+                if tmptokens or tmptokens.haskeys():
+                    tokens += tmptokens
+        except (ParseException, IndexError):
+            pass
+
+        return loc, tokens
+
+    def _setResultsName(self, name, listAllMatches=False):
+        if __diag__.warn_ungrouped_named_tokens_in_collection:
+            for e in [self.expr] + getattr(self.expr, 'exprs', []):
+                if isinstance(e, ParserElement) and e.resultsName:
+                    warnings.warn("{0}: setting results name {1!r} on {2} expression "
+                                  "collides with {3!r} on contained expression".format("warn_ungrouped_named_tokens_in_collection",
+                                                                                       name,
+                                                                                       type(self).__name__,
+                                                                                       e.resultsName),
+                                  stacklevel=3)
+
+        return super(_MultipleMatch, self)._setResultsName(name, listAllMatches)
+
+
+class OneOrMore(_MultipleMatch):
+    """Repetition of one or more of the given expression.
+
+    Parameters:
+     - expr - expression that must match one or more times
+     - stopOn - (default= ``None``) - expression for a terminating sentinel
+          (only required if the sentinel would ordinarily match the repetition
+          expression)
+
+    Example::
+
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
+
+        text = "shape: SQUARE posn: upper left color: BLACK"
+        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]
+
+        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]
+
+        # could also be written as
+        (attr_expr * (1,)).parseString(text).pprint()
+    """
+
+    def __str__(self):
+        if hasattr(self, "name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + _ustr(self.expr) + "}..."
+
+        return self.strRepr
+
+class ZeroOrMore(_MultipleMatch):
+    """Optional repetition of zero or more of the given expression.
+
+    Parameters:
+     - expr - expression that must match zero or more times
+     - stopOn - (default= ``None``) - expression for a terminating sentinel
+          (only required if the sentinel would ordinarily match the repetition
+          expression)
+
+    Example: similar to :class:`OneOrMore`
+    """
+    def __init__(self, expr, stopOn=None):
+        super(ZeroOrMore, self).__init__(expr, stopOn=stopOn)
+        self.mayReturnEmpty = True
+
+    def parseImpl(self, instring, loc, doActions=True):
+        try:
+            return super(ZeroOrMore, self).parseImpl(instring, loc, doActions)
+        except (ParseException, IndexError):
+            return loc, []
+
+    def __str__(self):
+        if hasattr(self, "name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "[" + _ustr(self.expr) + "]..."
+
+        return self.strRepr
+
+
+class _NullToken(object):
+    def __bool__(self):
+        return False
+    __nonzero__ = __bool__
+    def __str__(self):
+        return ""
+
+class Optional(ParseElementEnhance):
+    """Optional matching of the given expression.
+
+    Parameters:
+     - expr - expression that must match zero or more times
+     - default (optional) - value to be returned if the optional expression is not found.
+
+    Example::
+
+        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier
+        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4)))
+        zip.runTests('''
+            # traditional ZIP code
+            12345
+
+            # ZIP+4 form
+            12101-0001
+
+            # invalid ZIP
+            98765-
+            ''')
+
+    prints::
+
+        # traditional ZIP code
+        12345
+        ['12345']
+
+        # ZIP+4 form
+        12101-0001
+        ['12101-0001']
+
+        # invalid ZIP
+        98765-
+             ^
+        FAIL: Expected end of text (at char 5), (line:1, col:6)
+    """
+    __optionalNotMatched = _NullToken()
+
+    def __init__(self, expr, default=__optionalNotMatched):
+        super(Optional, self).__init__(expr, savelist=False)
+        self.saveAsList = self.expr.saveAsList
+        self.defaultValue = default
+        self.mayReturnEmpty = True
+
+    def parseImpl(self, instring, loc, doActions=True):
+        try:
+            loc, tokens = self.expr._parse(instring, loc, doActions, callPreParse=False)
+        except (ParseException, IndexError):
+            if self.defaultValue is not self.__optionalNotMatched:
+                if self.expr.resultsName:
+                    tokens = ParseResults([self.defaultValue])
+                    tokens[self.expr.resultsName] = self.defaultValue
+                else:
+                    tokens = [self.defaultValue]
+            else:
+                tokens = []
+        return loc, tokens
+
+    def __str__(self):
+        if hasattr(self, "name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "[" + _ustr(self.expr) + "]"
+
+        return self.strRepr
+
+class SkipTo(ParseElementEnhance):
+    """Token for skipping over all undefined text until the matched
+    expression is found.
+
+    Parameters:
+     - expr - target expression marking the end of the data to be skipped
+     - include - (default= ``False``) if True, the target expression is also parsed
+          (the skipped text and target expression are returned as a 2-element list).
+     - ignore - (default= ``None``) used to define grammars (typically quoted strings and
+          comments) that might contain false matches to the target expression
+     - failOn - (default= ``None``) define expressions that are not allowed to be
+          included in the skipped test; if found before the target expression is found,
+          the SkipTo is not a match
+
+    Example::
+
+        report = '''
+            Outstanding Issues Report - 1 Jan 2000
+
+               # | Severity | Description                               |  Days Open
+            -----+----------+-------------------------------------------+-----------
+             101 | Critical | Intermittent system crash                 |          6
+              94 | Cosmetic | Spelling error on Login ('log|n')         |         14
+              79 | Minor    | System slow when running too many reports |         47
+            '''
+        integer = Word(nums)
+        SEP = Suppress('|')
+        # use SkipTo to simply match everything up until the next SEP
+        # - ignore quoted strings, so that a '|' character inside a quoted string does not match
+        # - parse action will call token.strip() for each matched token, i.e., the description body
+        string_data = SkipTo(SEP, ignore=quotedString)
+        string_data.setParseAction(tokenMap(str.strip))
+        ticket_expr = (integer("issue_num") + SEP
+                      + string_data("sev") + SEP
+                      + string_data("desc") + SEP
+                      + integer("days_open"))
+
+        for tkt in ticket_expr.searchString(report):
+            print tkt.dump()
+
+    prints::
+
+        ['101', 'Critical', 'Intermittent system crash', '6']
+        - days_open: 6
+        - desc: Intermittent system crash
+        - issue_num: 101
+        - sev: Critical
+        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']
+        - days_open: 14
+        - desc: Spelling error on Login ('log|n')
+        - issue_num: 94
+        - sev: Cosmetic
+        ['79', 'Minor', 'System slow when running too many reports', '47']
+        - days_open: 47
+        - desc: System slow when running too many reports
+        - issue_num: 79
+        - sev: Minor
+    """
+    def __init__(self, other, include=False, ignore=None, failOn=None):
+        super(SkipTo, self).__init__(other)
+        self.ignoreExpr = ignore
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.includeMatch = include
+        self.saveAsList = False
+        if isinstance(failOn, basestring):
+            self.failOn = self._literalStringClass(failOn)
+        else:
+            self.failOn = failOn
+        self.errmsg = "No match found for " + _ustr(self.expr)
+
+    def parseImpl(self, instring, loc, doActions=True):
+        startloc = loc
+        instrlen = len(instring)
+        expr = self.expr
+        expr_parse = self.expr._parse
+        self_failOn_canParseNext = self.failOn.canParseNext if self.failOn is not None else None
+        self_ignoreExpr_tryParse = self.ignoreExpr.tryParse if self.ignoreExpr is not None else None
+
+        tmploc = loc
+        while tmploc <= instrlen:
+            if self_failOn_canParseNext is not None:
+                # break if failOn expression matches
+                if self_failOn_canParseNext(instring, tmploc):
+                    break
+
+            if self_ignoreExpr_tryParse is not None:
+                # advance past ignore expressions
+                while 1:
+                    try:
+                        tmploc = self_ignoreExpr_tryParse(instring, tmploc)
+                    except ParseBaseException:
+                        break
+
+            try:
+                expr_parse(instring, tmploc, doActions=False, callPreParse=False)
+            except (ParseException, IndexError):
+                # no match, advance loc in string
+                tmploc += 1
+            else:
+                # matched skipto expr, done
+                break
+
+        else:
+            # ran off the end of the input string without matching skipto expr, fail
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        # build up return values
+        loc = tmploc
+        skiptext = instring[startloc:loc]
+        skipresult = ParseResults(skiptext)
+
+        if self.includeMatch:
+            loc, mat = expr_parse(instring, loc, doActions, callPreParse=False)
+            skipresult += mat
+
+        return loc, skipresult
+
+class Forward(ParseElementEnhance):
+    """Forward declaration of an expression to be defined later -
+    used for recursive grammars, such as algebraic infix notation.
+    When the expression is known, it is assigned to the ``Forward``
+    variable using the '<<' operator.
+
+    Note: take care when assigning to ``Forward`` not to overlook
+    precedence of operators.
+
+    Specifically, '|' has a lower precedence than '<<', so that::
+
+        fwdExpr << a | b | c
+
+    will actually be evaluated as::
+
+        (fwdExpr << a) | b | c
+
+    thereby leaving b and c out as parseable alternatives.  It is recommended that you
+    explicitly group the values inserted into the ``Forward``::
+
+        fwdExpr << (a | b | c)
+
+    Converting to use the '<<=' operator instead will avoid this problem.
+
+    See :class:`ParseResults.pprint` for an example of a recursive
+    parser created using ``Forward``.
+    """
+    def __init__(self, other=None):
+        super(Forward, self).__init__(other, savelist=False)
+
+    def __lshift__(self, other):
+        if isinstance(other, basestring):
+            other = self._literalStringClass(other)
+        self.expr = other
+        self.strRepr = None
+        self.mayIndexError = self.expr.mayIndexError
+        self.mayReturnEmpty = self.expr.mayReturnEmpty
+        self.setWhitespaceChars(self.expr.whiteChars)
+        self.skipWhitespace = self.expr.skipWhitespace
+        self.saveAsList = self.expr.saveAsList
+        self.ignoreExprs.extend(self.expr.ignoreExprs)
+        return self
+
+    def __ilshift__(self, other):
+        return self << other
+
+    def leaveWhitespace(self):
+        self.skipWhitespace = False
+        return self
+
+    def streamline(self):
+        if not self.streamlined:
+            self.streamlined = True
+            if self.expr is not None:
+                self.expr.streamline()
+        return self
+
+    def validate(self, validateTrace=None):
+        if validateTrace is None:
+            validateTrace = []
+
+        if self not in validateTrace:
+            tmp = validateTrace[:] + [self]
+            if self.expr is not None:
+                self.expr.validate(tmp)
+        self.checkRecursion([])
+
+    def __str__(self):
+        if hasattr(self, "name"):
+            return self.name
+        if self.strRepr is not None:
+            return self.strRepr
+
+        # Avoid infinite recursion by setting a temporary strRepr
+        self.strRepr = ": ..."
+
+        # Use the string representation of main expression.
+        retString = '...'
+        try:
+            if self.expr is not None:
+                retString = _ustr(self.expr)[:1000]
+            else:
+                retString = "None"
+        finally:
+            self.strRepr = self.__class__.__name__ + ": " + retString
+        return self.strRepr
+
+    def copy(self):
+        if self.expr is not None:
+            return super(Forward, self).copy()
+        else:
+            ret = Forward()
+            ret <<= self
+            return ret
+
+    def _setResultsName(self, name, listAllMatches=False):
+        if __diag__.warn_name_set_on_empty_Forward:
+            if self.expr is None:
+                warnings.warn("{0}: setting results name {0!r} on {1} expression "
+                              "that has no contained expression".format("warn_name_set_on_empty_Forward",
+                                                                        name,
+                                                                        type(self).__name__),
+                              stacklevel=3)
+
+        return super(Forward, self)._setResultsName(name, listAllMatches)
+
+class TokenConverter(ParseElementEnhance):
+    """
+    Abstract subclass of :class:`ParseExpression`, for converting parsed results.
+    """
+    def __init__(self, expr, savelist=False):
+        super(TokenConverter, self).__init__(expr)  # , savelist)
+        self.saveAsList = False
+
+class Combine(TokenConverter):
+    """Converter to concatenate all matching tokens to a single string.
+    By default, the matching patterns must also be contiguous in the
+    input string; this can be disabled by specifying
+    ``'adjacent=False'`` in the constructor.
+
+    Example::
+
+        real = Word(nums) + '.' + Word(nums)
+        print(real.parseString('3.1416')) # -> ['3', '.', '1416']
+        # will also erroneously match the following
+        print(real.parseString('3. 1416')) # -> ['3', '.', '1416']
+
+        real = Combine(Word(nums) + '.' + Word(nums))
+        print(real.parseString('3.1416')) # -> ['3.1416']
+        # no match when there are internal spaces
+        print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...)
+    """
+    def __init__(self, expr, joinString="", adjacent=True):
+        super(Combine, self).__init__(expr)
+        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself
+        if adjacent:
+            self.leaveWhitespace()
+        self.adjacent = adjacent
+        self.skipWhitespace = True
+        self.joinString = joinString
+        self.callPreparse = True
+
+    def ignore(self, other):
+        if self.adjacent:
+            ParserElement.ignore(self, other)
+        else:
+            super(Combine, self).ignore(other)
+        return self
+
+    def postParse(self, instring, loc, tokenlist):
+        retToks = tokenlist.copy()
+        del retToks[:]
+        retToks += ParseResults(["".join(tokenlist._asStringList(self.joinString))], modal=self.modalResults)
+
+        if self.resultsName and retToks.haskeys():
+            return [retToks]
+        else:
+            return retToks
+
+class Group(TokenConverter):
+    """Converter to return the matched tokens as a list - useful for
+    returning tokens of :class:`ZeroOrMore` and :class:`OneOrMore` expressions.
+
+    Example::
+
+        ident = Word(alphas)
+        num = Word(nums)
+        term = ident | num
+        func = ident + Optional(delimitedList(term))
+        print(func.parseString("fn a, b, 100"))  # -> ['fn', 'a', 'b', '100']
+
+        func = ident + Group(Optional(delimitedList(term)))
+        print(func.parseString("fn a, b, 100"))  # -> ['fn', ['a', 'b', '100']]
+    """
+    def __init__(self, expr):
+        super(Group, self).__init__(expr)
+        self.saveAsList = True
+
+    def postParse(self, instring, loc, tokenlist):
+        return [tokenlist]
+
+class Dict(TokenConverter):
+    """Converter to return a repetitive expression as a list, but also
+    as a dictionary. Each element can also be referenced using the first
+    token in the expression as its key. Useful for tabular report
+    scraping when the first column can be used as a item key.
+
+    Example::
+
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
+
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+
+        # print attributes as plain groups
+        print(OneOrMore(attr_expr).parseString(text).dump())
+
+        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names
+        result = Dict(OneOrMore(Group(attr_expr))).parseString(text)
+        print(result.dump())
+
+        # access named fields as dict entries, or output as dict
+        print(result['shape'])
+        print(result.asDict())
+
+    prints::
+
+        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
+        - color: light blue
+        - posn: upper left
+        - shape: SQUARE
+        - texture: burlap
+        SQUARE
+        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}
+
+    See more examples at :class:`ParseResults` of accessing fields by results name.
+    """
+    def __init__(self, expr):
+        super(Dict, self).__init__(expr)
+        self.saveAsList = True
+
+    def postParse(self, instring, loc, tokenlist):
+        for i, tok in enumerate(tokenlist):
+            if len(tok) == 0:
+                continue
+            ikey = tok[0]
+            if isinstance(ikey, int):
+                ikey = _ustr(tok[0]).strip()
+            if len(tok) == 1:
+                tokenlist[ikey] = _ParseResultsWithOffset("", i)
+            elif len(tok) == 2 and not isinstance(tok[1], ParseResults):
+                tokenlist[ikey] = _ParseResultsWithOffset(tok[1], i)
+            else:
+                dictvalue = tok.copy()  # ParseResults(i)
+                del dictvalue[0]
+                if len(dictvalue) != 1 or (isinstance(dictvalue, ParseResults) and dictvalue.haskeys()):
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue, i)
+                else:
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0], i)
+
+        if self.resultsName:
+            return [tokenlist]
+        else:
+            return tokenlist
+
+
+class Suppress(TokenConverter):
+    """Converter for ignoring the results of a parsed expression.
+
+    Example::
+
+        source = "a, b, c,d"
+        wd = Word(alphas)
+        wd_list1 = wd + ZeroOrMore(',' + wd)
+        print(wd_list1.parseString(source))
+
+        # often, delimiters that are useful during parsing are just in the
+        # way afterward - use Suppress to keep them out of the parsed output
+        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd)
+        print(wd_list2.parseString(source))
+
+    prints::
+
+        ['a', ',', 'b', ',', 'c', ',', 'd']
+        ['a', 'b', 'c', 'd']
+
+    (See also :class:`delimitedList`.)
+    """
+    def postParse(self, instring, loc, tokenlist):
+        return []
+
+    def suppress(self):
+        return self
+
+
+class OnlyOnce(object):
+    """Wrapper for parse actions, to ensure they are only called once.
+    """
+    def __init__(self, methodCall):
+        self.callable = _trim_arity(methodCall)
+        self.called = False
+    def __call__(self, s, l, t):
+        if not self.called:
+            results = self.callable(s, l, t)
+            self.called = True
+            return results
+        raise ParseException(s, l, "")
+    def reset(self):
+        self.called = False
+
+def traceParseAction(f):
+    """Decorator for debugging parse actions.
+
+    When the parse action is called, this decorator will print
+    ``">> entering method-name(line:<current_source_line>, <parse_location>, <matched_tokens>)"``.
+    When the parse action completes, the decorator will print
+    ``"<<"`` followed by the returned value, or any exception that the parse action raised.
+
+    Example::
+
+        wd = Word(alphas)
+
+        @traceParseAction
+        def remove_duplicate_chars(tokens):
+            return ''.join(sorted(set(''.join(tokens))))
+
+        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
+        print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
+
+    prints::
+
+        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))
+        <<leaving remove_duplicate_chars (ret: 'dfjkls')
+        ['dfjkls']
+    """
+    f = _trim_arity(f)
+    def z(*paArgs):
+        thisFunc = f.__name__
+        s, l, t = paArgs[-3:]
+        if len(paArgs) > 3:
+            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc
+        sys.stderr.write(">>entering %s(line: '%s', %d, %r)\n" % (thisFunc, line(l, s), l, t))
+        try:
+            ret = f(*paArgs)
+        except Exception as exc:
+            sys.stderr.write("<<leaving %s (exception: %s)\n" % (thisFunc, exc))
+            raise
+        sys.stderr.write("<<leaving %s (ret: %r)\n" % (thisFunc, ret))
+        return ret
+    try:
+        z.__name__ = f.__name__
+    except AttributeError:
+        pass
+    return z
+
+#
+# global helpers
+#
+def delimitedList(expr, delim=",", combine=False):
+    """Helper to define a delimited list of expressions - the delimiter
+    defaults to ','. By default, the list elements and delimiters can
+    have intervening whitespace, and comments, but this can be
+    overridden by passing ``combine=True`` in the constructor. If
+    ``combine`` is set to ``True``, the matching tokens are
+    returned as a single token string, with the delimiters included;
+    otherwise, the matching tokens are returned as a list of tokens,
+    with the delimiters suppressed.
+
+    Example::
+
+        delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc']
+        delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
+    """
+    dlName = _ustr(expr) + " [" + _ustr(delim) + " " + _ustr(expr) + "]..."
+    if combine:
+        return Combine(expr + ZeroOrMore(delim + expr)).setName(dlName)
+    else:
+        return (expr + ZeroOrMore(Suppress(delim) + expr)).setName(dlName)
+
+def countedArray(expr, intExpr=None):
+    """Helper to define a counted list of expressions.
+
+    This helper defines a pattern of the form::
+
+        integer expr expr expr...
+
+    where the leading integer tells how many expr expressions follow.
+    The matched tokens returns the array of expr tokens as a list - the
+    leading count token is suppressed.
+
+    If ``intExpr`` is specified, it should be a pyparsing expression
+    that produces an integer value.
+
+    Example::
+
+        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -> ['ab', 'cd']
+
+        # in this parser, the leading integer value is given in binary,
+        # '10' indicating that 2 values are in the array
+        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2))
+        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -> ['ab', 'cd']
+    """
+    arrayExpr = Forward()
+    def countFieldParseAction(s, l, t):
+        n = t[0]
+        arrayExpr << (n and Group(And([expr] * n)) or Group(empty))
+        return []
+    if intExpr is None:
+        intExpr = Word(nums).setParseAction(lambda t: int(t[0]))
+    else:
+        intExpr = intExpr.copy()
+    intExpr.setName("arrayLen")
+    intExpr.addParseAction(countFieldParseAction, callDuringTry=True)
+    return (intExpr + arrayExpr).setName('(len) ' + _ustr(expr) + '...')
+
+def _flatten(L):
+    ret = []
+    for i in L:
+        if isinstance(i, list):
+            ret.extend(_flatten(i))
+        else:
+            ret.append(i)
+    return ret
+
+def matchPreviousLiteral(expr):
+    """Helper to define an expression that is indirectly defined from
+    the tokens matched in a previous expression, that is, it looks for
+    a 'repeat' of a previous expression.  For example::
+
+        first = Word(nums)
+        second = matchPreviousLiteral(first)
+        matchExpr = first + ":" + second
+
+    will match ``"1:1"``, but not ``"1:2"``.  Because this
+    matches a previous literal, will also match the leading
+    ``"1:1"`` in ``"1:10"``. If this is not desired, use
+    :class:`matchPreviousExpr`. Do *not* use with packrat parsing
+    enabled.
+    """
+    rep = Forward()
+    def copyTokenToRepeater(s, l, t):
+        if t:
+            if len(t) == 1:
+                rep << t[0]
+            else:
+                # flatten t tokens
+                tflat = _flatten(t.asList())
+                rep << And(Literal(tt) for tt in tflat)
+        else:
+            rep << Empty()
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
+    rep.setName('(prev) ' + _ustr(expr))
+    return rep
+
+def matchPreviousExpr(expr):
+    """Helper to define an expression that is indirectly defined from
+    the tokens matched in a previous expression, that is, it looks for
+    a 'repeat' of a previous expression.  For example::
+
+        first = Word(nums)
+        second = matchPreviousExpr(first)
+        matchExpr = first + ":" + second
+
+    will match ``"1:1"``, but not ``"1:2"``.  Because this
+    matches by expressions, will *not* match the leading ``"1:1"``
+    in ``"1:10"``; the expressions are evaluated first, and then
+    compared, so ``"1"`` is compared with ``"10"``. Do *not* use
+    with packrat parsing enabled.
+    """
+    rep = Forward()
+    e2 = expr.copy()
+    rep <<= e2
+    def copyTokenToRepeater(s, l, t):
+        matchTokens = _flatten(t.asList())
+        def mustMatchTheseTokens(s, l, t):
+            theseTokens = _flatten(t.asList())
+            if theseTokens != matchTokens:
+                raise ParseException('', 0, '')
+        rep.setParseAction(mustMatchTheseTokens, callDuringTry=True)
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
+    rep.setName('(prev) ' + _ustr(expr))
+    return rep
+
+def _escapeRegexRangeChars(s):
+    # ~  escape these chars: ^-[]
+    for c in r"\^-[]":
+        s = s.replace(c, _bslash + c)
+    s = s.replace("\n", r"\n")
+    s = s.replace("\t", r"\t")
+    return _ustr(s)
+
+def oneOf(strs, caseless=False, useRegex=True, asKeyword=False):
+    """Helper to quickly define a set of alternative Literals, and makes
+    sure to do longest-first testing when there is a conflict,
+    regardless of the input order, but returns
+    a :class:`MatchFirst` for best performance.
+
+    Parameters:
+
+     - strs - a string of space-delimited literals, or a collection of
+       string literals
+     - caseless - (default= ``False``) - treat all literals as
+       caseless
+     - useRegex - (default= ``True``) - as an optimization, will
+       generate a Regex object; otherwise, will generate
+       a :class:`MatchFirst` object (if ``caseless=True`` or ``asKeyword=True``, or if
+       creating a :class:`Regex` raises an exception)
+     - asKeyword - (default=``False``) - enforce Keyword-style matching on the
+       generated expressions
+
+    Example::
+
+        comp_oper = oneOf("< = > <= >= !=")
+        var = Word(alphas)
+        number = Word(nums)
+        term = var | number
+        comparison_expr = term + comp_oper + term
+        print(comparison_expr.searchString("B = 12  AA=23 B<=AA AA>12"))
+
+    prints::
+
+        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
+    """
+    if isinstance(caseless, basestring):
+        warnings.warn("More than one string argument passed to oneOf, pass "
+                      "choices as a list or space-delimited string", stacklevel=2)
+
+    if caseless:
+        isequal = (lambda a, b: a.upper() == b.upper())
+        masks = (lambda a, b: b.upper().startswith(a.upper()))
+        parseElementClass = CaselessKeyword if asKeyword else CaselessLiteral
+    else:
+        isequal = (lambda a, b: a == b)
+        masks = (lambda a, b: b.startswith(a))
+        parseElementClass = Keyword if asKeyword else Literal
+
+    symbols = []
+    if isinstance(strs, basestring):
+        symbols = strs.split()
+    elif isinstance(strs, Iterable):
+        symbols = list(strs)
+    else:
+        warnings.warn("Invalid argument to oneOf, expected string or iterable",
+                      SyntaxWarning, stacklevel=2)
+    if not symbols:
+        return NoMatch()
+
+    if not asKeyword:
+        # if not producing keywords, need to reorder to take care to avoid masking
+        # longer choices with shorter ones
+        i = 0
+        while i < len(symbols) - 1:
+            cur = symbols[i]
+            for j, other in enumerate(symbols[i + 1:]):
+                if isequal(other, cur):
+                    del symbols[i + j + 1]
+                    break
+                elif masks(cur, other):
+                    del symbols[i + j + 1]
+                    symbols.insert(i, other)
+                    break
+            else:
+                i += 1
+
+    if not (caseless or asKeyword) and useRegex:
+        # ~ print (strs, "->", "|".join([_escapeRegexChars(sym) for sym in symbols]))
+        try:
+            if len(symbols) == len("".join(symbols)):
+                return Regex("[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols)).setName(' | '.join(symbols))
+            else:
+                return Regex("|".join(re.escape(sym) for sym in symbols)).setName(' | '.join(symbols))
+        except Exception:
+            warnings.warn("Exception creating Regex for oneOf, building MatchFirst",
+                    SyntaxWarning, stacklevel=2)
+
+    # last resort, just use MatchFirst
+    return MatchFirst(parseElementClass(sym) for sym in symbols).setName(' | '.join(symbols))
+
+def dictOf(key, value):
+    """Helper to easily and clearly define a dictionary by specifying
+    the respective patterns for the key and value.  Takes care of
+    defining the :class:`Dict`, :class:`ZeroOrMore`, and
+    :class:`Group` tokens in the proper order.  The key pattern
+    can include delimiting markers or punctuation, as long as they are
+    suppressed, thereby leaving the significant key text.  The value
+    pattern can include named results, so that the :class:`Dict` results
+    can include named token fields.
+
+    Example::
+
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        print(OneOrMore(attr_expr).parseString(text).dump())
+
+        attr_label = label
+        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)
+
+        # similar to Dict, but simpler call format
+        result = dictOf(attr_label, attr_value).parseString(text)
+        print(result.dump())
+        print(result['shape'])
+        print(result.shape)  # object attribute access works too
+        print(result.asDict())
+
+    prints::
+
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
+        - color: light blue
+        - posn: upper left
+        - shape: SQUARE
+        - texture: burlap
+        SQUARE
+        SQUARE
+        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
+    """
+    return Dict(OneOrMore(Group(key + value)))
+
+def originalTextFor(expr, asString=True):
+    """Helper to return the original, untokenized text for a given
+    expression.  Useful to restore the parsed fields of an HTML start
+    tag into the raw tag text itself, or to revert separate tokens with
+    intervening whitespace back to the original matching input text. By
+    default, returns astring containing the original parsed text.
+
+    If the optional ``asString`` argument is passed as
+    ``False``, then the return value is
+    a :class:`ParseResults` containing any results names that
+    were originally matched, and a single token containing the original
+    matched text from the input string.  So if the expression passed to
+    :class:`originalTextFor` contains expressions with defined
+    results names, you must set ``asString`` to ``False`` if you
+    want to preserve those results name values.
+
+    Example::
+
+        src = "this is test <b> bold <i>text</i> </b> normal text "
+        for tag in ("b", "i"):
+            opener, closer = makeHTMLTags(tag)
+            patt = originalTextFor(opener + SkipTo(closer) + closer)
+            print(patt.searchString(src)[0])
+
+    prints::
+
+        ['<b> bold <i>text</i> </b>']
+        ['<i>text</i>']
+    """
+    locMarker = Empty().setParseAction(lambda s, loc, t: loc)
+    endlocMarker = locMarker.copy()
+    endlocMarker.callPreparse = False
+    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")
+    if asString:
+        extractText = lambda s, l, t: s[t._original_start: t._original_end]
+    else:
+        def extractText(s, l, t):
+            t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]]
+    matchExpr.setParseAction(extractText)
+    matchExpr.ignoreExprs = expr.ignoreExprs
+    return matchExpr
+
+def ungroup(expr):
+    """Helper to undo pyparsing's default grouping of And expressions,
+    even if all but one are non-empty.
+    """
+    return TokenConverter(expr).addParseAction(lambda t: t[0])
+
+def locatedExpr(expr):
+    """Helper to decorate a returned token with its starting and ending
+    locations in the input string.
+
+    This helper adds the following results names:
+
+     - locn_start = location where matched expression begins
+     - locn_end = location where matched expression ends
+     - value = the actual parsed results
+
+    Be careful if the input text contains ``<TAB>`` characters, you
+    may want to call :class:`ParserElement.parseWithTabs`
+
+    Example::
+
+        wd = Word(alphas)
+        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
+            print(match)
+
+    prints::
+
+        [[0, 'ljsdf', 5]]
+        [[8, 'lksdjjf', 15]]
+        [[18, 'lkkjj', 23]]
+    """
+    locator = Empty().setParseAction(lambda s, l, t: l)
+    return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end"))
+
+
+# convenience constants for positional expressions
+empty       = Empty().setName("empty")
+lineStart   = LineStart().setName("lineStart")
+lineEnd     = LineEnd().setName("lineEnd")
+stringStart = StringStart().setName("stringStart")
+stringEnd   = StringEnd().setName("stringEnd")
+
+_escapedPunc = Word(_bslash, r"\[]-*.$+^?()~ ", exact=2).setParseAction(lambda s, l, t: t[0][1])
+_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s, l, t: unichr(int(t[0].lstrip(r'\0x'), 16)))
+_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s, l, t: unichr(int(t[0][1:], 8)))
+_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1)
+_charRange = Group(_singleChar + Suppress("-") + _singleChar)
+_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group(OneOrMore(_charRange | _singleChar)).setResultsName("body") + "]"
+
+def srange(s):
+    r"""Helper to easily define string ranges for use in Word
+    construction. Borrows syntax from regexp '[]' string range
+    definitions::
+
+        srange("[0-9]")   -> "0123456789"
+        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz"
+        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"
+
+    The input string must be enclosed in []'s, and the returned string
+    is the expanded character set joined into a single string. The
+    values enclosed in the []'s may be:
+
+     - a single character
+     - an escaped character with a leading backslash (such as ``\-``
+       or ``\]``)
+     - an escaped hex character with a leading ``'\x'``
+       (``\x21``, which is a ``'!'`` character) (``\0x##``
+       is also supported for backwards compatibility)
+     - an escaped octal character with a leading ``'\0'``
+       (``\041``, which is a ``'!'`` character)
+     - a range of any of the above, separated by a dash (``'a-z'``,
+       etc.)
+     - any combination of the above (``'aeiouy'``,
+       ``'a-zA-Z0-9_$'``, etc.)
+    """
+    _expanded = lambda p: p if not isinstance(p, ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]), ord(p[1]) + 1))
+    try:
+        return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body)
+    except Exception:
+        return ""
+
+def matchOnlyAtCol(n):
+    """Helper method for defining parse actions that require matching at
+    a specific column in the input text.
+    """
+    def verifyCol(strg, locn, toks):
+        if col(locn, strg) != n:
+            raise ParseException(strg, locn, "matched token not at column %d" % n)
+    return verifyCol
+
+def replaceWith(replStr):
+    """Helper method for common parse actions that simply return
+    a literal value.  Especially useful when used with
+    :class:`transformString<ParserElement.transformString>` ().
+
+    Example::
+
+        num = Word(nums).setParseAction(lambda toks: int(toks[0]))
+        na = oneOf("N/A NA").setParseAction(replaceWith(math.nan))
+        term = na | num
+
+        OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234]
+    """
+    return lambda s, l, t: [replStr]
+
+def removeQuotes(s, l, t):
+    """Helper parse action for removing quotation marks from parsed
+    quoted strings.
+
+    Example::
+
+        # by default, quotation marks are included in parsed results
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"]
+
+        # use removeQuotes to strip quotation marks from parsed results
+        quotedString.setParseAction(removeQuotes)
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"]
+    """
+    return t[0][1:-1]
+
+def tokenMap(func, *args):
+    """Helper to define a parse action by mapping a function to all
+    elements of a ParseResults list. If any additional args are passed,
+    they are forwarded to the given function as additional arguments
+    after the token, as in
+    ``hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))``,
+    which will convert the parsed data to an integer using base 16.
+
+    Example (compare the last to example in :class:`ParserElement.transformString`::
+
+        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16))
+        hex_ints.runTests('''
+            00 11 22 aa FF 0a 0d 1a
+            ''')
+
+        upperword = Word(alphas).setParseAction(tokenMap(str.upper))
+        OneOrMore(upperword).runTests('''
+            my kingdom for a horse
+            ''')
+
+        wd = Word(alphas).setParseAction(tokenMap(str.title))
+        OneOrMore(wd).setParseAction(' '.join).runTests('''
+            now is the winter of our discontent made glorious summer by this sun of york
+            ''')
+
+    prints::
+
+        00 11 22 aa FF 0a 0d 1a
+        [0, 17, 34, 170, 255, 10, 13, 26]
+
+        my kingdom for a horse
+        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE']
+
+        now is the winter of our discontent made glorious summer by this sun of york
+        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York']
+    """
+    def pa(s, l, t):
+        return [func(tokn, *args) for tokn in t]
+
+    try:
+        func_name = getattr(func, '__name__',
+                            getattr(func, '__class__').__name__)
+    except Exception:
+        func_name = str(func)
+    pa.__name__ = func_name
+
+    return pa
+
+upcaseTokens = tokenMap(lambda t: _ustr(t).upper())
+"""(Deprecated) Helper parse action to convert tokens to upper case.
+Deprecated in favor of :class:`pyparsing_common.upcaseTokens`"""
+
+downcaseTokens = tokenMap(lambda t: _ustr(t).lower())
+"""(Deprecated) Helper parse action to convert tokens to lower case.
+Deprecated in favor of :class:`pyparsing_common.downcaseTokens`"""
+
+def _makeTags(tagStr, xml,
+              suppress_LT=Suppress("<"),
+              suppress_GT=Suppress(">")):
+    """Internal helper to construct opening and closing tag expressions, given a tag name"""
+    if isinstance(tagStr, basestring):
+        resname = tagStr
+        tagStr = Keyword(tagStr, caseless=not xml)
+    else:
+        resname = tagStr.name
+
+    tagAttrName = Word(alphas, alphanums + "_-:")
+    if xml:
+        tagAttrValue = dblQuotedString.copy().setParseAction(removeQuotes)
+        openTag = (suppress_LT
+                   + tagStr("tag")
+                   + Dict(ZeroOrMore(Group(tagAttrName + Suppress("=") + tagAttrValue)))
+                   + Optional("/", default=[False])("empty").setParseAction(lambda s, l, t: t[0] == '/')
+                   + suppress_GT)
+    else:
+        tagAttrValue = quotedString.copy().setParseAction(removeQuotes) | Word(printables, excludeChars=">")
+        openTag = (suppress_LT
+                   + tagStr("tag")
+                   + Dict(ZeroOrMore(Group(tagAttrName.setParseAction(downcaseTokens)
+                                           + Optional(Suppress("=") + tagAttrValue))))
+                   + Optional("/", default=[False])("empty").setParseAction(lambda s, l, t: t[0] == '/')
+                   + suppress_GT)
+    closeTag = Combine(_L("</") + tagStr + ">", adjacent=False)
+
+    openTag.setName("<%s>" % resname)
+    # add start<tagname> results name in parse action now that ungrouped names are not reported at two levels
+    openTag.addParseAction(lambda t: t.__setitem__("start" + "".join(resname.replace(":", " ").title().split()), t.copy()))
+    closeTag = closeTag("end" + "".join(resname.replace(":", " ").title().split())).setName("</%s>" % resname)
+    openTag.tag = resname
+    closeTag.tag = resname
+    openTag.tag_body = SkipTo(closeTag())
+    return openTag, closeTag
+
+def makeHTMLTags(tagStr):
+    """Helper to construct opening and closing tag expressions for HTML,
+    given a tag name. Matches tags in either upper or lower case,
+    attributes with namespaces and with quoted or unquoted values.
+
+    Example::
+
+        text = '<td>More info at the <a href="https://github.com/pyparsing/pyparsing/wiki">pyparsing</a> wiki page</td>'
+        # makeHTMLTags returns pyparsing expressions for the opening and
+        # closing tags as a 2-tuple
+        a, a_end = makeHTMLTags("A")
+        link_expr = a + SkipTo(a_end)("link_text") + a_end
+
+        for link in link_expr.searchString(text):
+            # attributes in the <A> tag (like "href" shown here) are
+            # also accessible as named results
+            print(link.link_text, '->', link.href)
+
+    prints::
+
+        pyparsing -> https://github.com/pyparsing/pyparsing/wiki
+    """
+    return _makeTags(tagStr, False)
+
+def makeXMLTags(tagStr):
+    """Helper to construct opening and closing tag expressions for XML,
+    given a tag name. Matches tags only in the given upper/lower case.
+
+    Example: similar to :class:`makeHTMLTags`
+    """
+    return _makeTags(tagStr, True)
+
+def withAttribute(*args, **attrDict):
+    """Helper to create a validating parse action to be used with start
+    tags created with :class:`makeXMLTags` or
+    :class:`makeHTMLTags`. Use ``withAttribute`` to qualify
+    a starting tag with a required attribute value, to avoid false
+    matches on common tags such as ``<TD>`` or ``<DIV>``.
+
+    Call ``withAttribute`` with a series of attribute names and
+    values. Specify the list of filter attributes names and values as:
+
+     - keyword arguments, as in ``(align="right")``, or
+     - as an explicit dict with ``**`` operator, when an attribute
+       name is also a Python reserved word, as in ``**{"class":"Customer", "align":"right"}``
+     - a list of name-value tuples, as in ``(("ns1:class", "Customer"), ("ns2:align", "right"))``
+
+    For attribute names with a namespace prefix, you must use the second
+    form.  Attribute names are matched insensitive to upper/lower case.
+
+    If just testing for ``class`` (with or without a namespace), use
+    :class:`withClass`.
+
+    To verify that the attribute exists, but without specifying a value,
+    pass ``withAttribute.ANY_VALUE`` as the value.
+
+    Example::
+
+        html = '''
+            <div>
+            Some text
+            <div type="grid">1 4 0 1 0</div>
+            <div type="graph">1,3 2,3 1,1</div>
+            <div>this has no type</div>
+            </div>
+
+        '''
+        div,div_end = makeHTMLTags("div")
+
+        # only match div tag having a type attribute with value "grid"
+        div_grid = div().setParseAction(withAttribute(type="grid"))
+        grid_expr = div_grid + SkipTo(div | div_end)("body")
+        for grid_header in grid_expr.searchString(html):
+            print(grid_header.body)
+
+        # construct a match with any div tag having a type attribute, regardless of the value
+        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE))
+        div_expr = div_any_type + SkipTo(div | div_end)("body")
+        for div_header in div_expr.searchString(html):
+            print(div_header.body)
+
+    prints::
+
+        1 4 0 1 0
+
+        1 4 0 1 0
+        1,3 2,3 1,1
+    """
+    if args:
+        attrs = args[:]
+    else:
+        attrs = attrDict.items()
+    attrs = [(k, v) for k, v in attrs]
+    def pa(s, l, tokens):
+        for attrName, attrValue in attrs:
+            if attrName not in tokens:
+                raise ParseException(s, l, "no matching attribute " + attrName)
+            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:
+                raise ParseException(s, l, "attribute '%s' has value '%s', must be '%s'" %
+                                            (attrName, tokens[attrName], attrValue))
+    return pa
+withAttribute.ANY_VALUE = object()
+
+def withClass(classname, namespace=''):
+    """Simplified version of :class:`withAttribute` when
+    matching on a div class - made difficult because ``class`` is
+    a reserved word in Python.
+
+    Example::
+
+        html = '''
+            <div>
+            Some text
+            <div class="grid">1 4 0 1 0</div>
+            <div class="graph">1,3 2,3 1,1</div>
+            <div>this &lt;div&gt; has no class</div>
+            </div>
+
+        '''
+        div,div_end = makeHTMLTags("div")
+        div_grid = div().setParseAction(withClass("grid"))
+
+        grid_expr = div_grid + SkipTo(div | div_end)("body")
+        for grid_header in grid_expr.searchString(html):
+            print(grid_header.body)
+
+        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE))
+        div_expr = div_any_type + SkipTo(div | div_end)("body")
+        for div_header in div_expr.searchString(html):
+            print(div_header.body)
+
+    prints::
+
+        1 4 0 1 0
+
+        1 4 0 1 0
+        1,3 2,3 1,1
+    """
+    classattr = "%s:class" % namespace if namespace else "class"
+    return withAttribute(**{classattr: classname})
+
+opAssoc = SimpleNamespace()
+opAssoc.LEFT = object()
+opAssoc.RIGHT = object()
+
+def infixNotation(baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')')):
+    """Helper method for constructing grammars of expressions made up of
+    operators working in a precedence hierarchy.  Operators may be unary
+    or binary, left- or right-associative.  Parse actions can also be
+    attached to operator expressions. The generated parser will also
+    recognize the use of parentheses to override operator precedences
+    (see example below).
+
+    Note: if you define a deep operator list, you may see performance
+    issues when using infixNotation. See
+    :class:`ParserElement.enablePackrat` for a mechanism to potentially
+    improve your parser performance.
+
+    Parameters:
+     - baseExpr - expression representing the most basic element for the
+       nested
+     - opList - list of tuples, one for each operator precedence level
+       in the expression grammar; each tuple is of the form ``(opExpr,
+       numTerms, rightLeftAssoc, parseAction)``, where:
+
+       - opExpr is the pyparsing expression for the operator; may also
+         be a string, which will be converted to a Literal; if numTerms
+         is 3, opExpr is a tuple of two expressions, for the two
+         operators separating the 3 terms
+       - numTerms is the number of terms for this operator (must be 1,
+         2, or 3)
+       - rightLeftAssoc is the indicator whether the operator is right
+         or left associative, using the pyparsing-defined constants
+         ``opAssoc.RIGHT`` and ``opAssoc.LEFT``.
+       - parseAction is the parse action to be associated with
+         expressions matching this operator expression (the parse action
+         tuple member may be omitted); if the parse action is passed
+         a tuple or list of functions, this is equivalent to calling
+         ``setParseAction(*fn)``
+         (:class:`ParserElement.setParseAction`)
+     - lpar - expression for matching left-parentheses
+       (default= ``Suppress('(')``)
+     - rpar - expression for matching right-parentheses
+       (default= ``Suppress(')')``)
+
+    Example::
+
+        # simple example of four-function arithmetic with ints and
+        # variable names
+        integer = pyparsing_common.signed_integer
+        varname = pyparsing_common.identifier
+
+        arith_expr = infixNotation(integer | varname,
+            [
+            ('-', 1, opAssoc.RIGHT),
+            (oneOf('* /'), 2, opAssoc.LEFT),
+            (oneOf('+ -'), 2, opAssoc.LEFT),
+            ])
+
+        arith_expr.runTests('''
+            5+3*6
+            (5+3)*6
+            -2--11
+            ''', fullDump=False)
+
+    prints::
+
+        5+3*6
+        [[5, '+', [3, '*', 6]]]
+
+        (5+3)*6
+        [[[5, '+', 3], '*', 6]]
+
+        -2--11
+        [[['-', 2], '-', ['-', 11]]]
+    """
+    # captive version of FollowedBy that does not do parse actions or capture results names
+    class _FB(FollowedBy):
+        def parseImpl(self, instring, loc, doActions=True):
+            self.expr.tryParse(instring, loc)
+            return loc, []
+
+    ret = Forward()
+    lastExpr = baseExpr | (lpar + ret + rpar)
+    for i, operDef in enumerate(opList):
+        opExpr, arity, rightLeftAssoc, pa = (operDef + (None, ))[:4]
+        termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr
+        if arity == 3:
+            if opExpr is None or len(opExpr) != 2:
+                raise ValueError(
+                    "if numterms=3, opExpr must be a tuple or list of two expressions")
+            opExpr1, opExpr2 = opExpr
+        thisExpr = Forward().setName(termName)
+        if rightLeftAssoc == opAssoc.LEFT:
+            if arity == 1:
+                matchExpr = _FB(lastExpr + opExpr) + Group(lastExpr + OneOrMore(opExpr))
+            elif arity == 2:
+                if opExpr is not None:
+                    matchExpr = _FB(lastExpr + opExpr + lastExpr) + Group(lastExpr + OneOrMore(opExpr + lastExpr))
+                else:
+                    matchExpr = _FB(lastExpr + lastExpr) + Group(lastExpr + OneOrMore(lastExpr))
+            elif arity == 3:
+                matchExpr = (_FB(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr)
+                             + Group(lastExpr + OneOrMore(opExpr1 + lastExpr + opExpr2 + lastExpr)))
+            else:
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
+        elif rightLeftAssoc == opAssoc.RIGHT:
+            if arity == 1:
+                # try to avoid LR with this extra test
+                if not isinstance(opExpr, Optional):
+                    opExpr = Optional(opExpr)
+                matchExpr = _FB(opExpr.expr + thisExpr) + Group(opExpr + thisExpr)
+            elif arity == 2:
+                if opExpr is not None:
+                    matchExpr = _FB(lastExpr + opExpr + thisExpr) + Group(lastExpr + OneOrMore(opExpr + thisExpr))
+                else:
+                    matchExpr = _FB(lastExpr + thisExpr) + Group(lastExpr + OneOrMore(thisExpr))
+            elif arity == 3:
+                matchExpr = (_FB(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr)
+                             + Group(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr))
+            else:
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
+        else:
+            raise ValueError("operator must indicate right or left associativity")
+        if pa:
+            if isinstance(pa, (tuple, list)):
+                matchExpr.setParseAction(*pa)
+            else:
+                matchExpr.setParseAction(pa)
+        thisExpr <<= (matchExpr.setName(termName) | lastExpr)
+        lastExpr = thisExpr
+    ret <<= lastExpr
+    return ret
+
+operatorPrecedence = infixNotation
+"""(Deprecated) Former name of :class:`infixNotation`, will be
+dropped in a future release."""
+
+dblQuotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*') + '"').setName("string enclosed in double quotes")
+sglQuotedString = Combine(Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*") + "'").setName("string enclosed in single quotes")
+quotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*') + '"'
+                       | Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*") + "'").setName("quotedString using single or double quotes")
+unicodeString = Combine(_L('u') + quotedString.copy()).setName("unicode string literal")
+
+def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()):
+    """Helper method for defining nested lists enclosed in opening and
+    closing delimiters ("(" and ")" are the default).
+
+    Parameters:
+     - opener - opening character for a nested list
+       (default= ``"("``); can also be a pyparsing expression
+     - closer - closing character for a nested list
+       (default= ``")"``); can also be a pyparsing expression
+     - content - expression for items within the nested lists
+       (default= ``None``)
+     - ignoreExpr - expression for ignoring opening and closing
+       delimiters (default= :class:`quotedString`)
+
+    If an expression is not provided for the content argument, the
+    nested expression will capture all whitespace-delimited content
+    between delimiters as a list of separate values.
+
+    Use the ``ignoreExpr`` argument to define expressions that may
+    contain opening or closing characters that should not be treated as
+    opening or closing characters for nesting, such as quotedString or
+    a comment expression.  Specify multiple expressions using an
+    :class:`Or` or :class:`MatchFirst`. The default is
+    :class:`quotedString`, but if no expressions are to be ignored, then
+    pass ``None`` for this argument.
+
+    Example::
+
+        data_type = oneOf("void int short long char float double")
+        decl_data_type = Combine(data_type + Optional(Word('*')))
+        ident = Word(alphas+'_', alphanums+'_')
+        number = pyparsing_common.number
+        arg = Group(decl_data_type + ident)
+        LPAR, RPAR = map(Suppress, "()")
+
+        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment))
+
+        c_function = (decl_data_type("type")
+                      + ident("name")
+                      + LPAR + Optional(delimitedList(arg), [])("args") + RPAR
+                      + code_body("body"))
+        c_function.ignore(cStyleComment)
+
+        source_code = '''
+            int is_odd(int x) {
+                return (x%2);
+            }
+
+            int dec_to_hex(char hchar) {
+                if (hchar >= '0' && hchar <= '9') {
+                    return (ord(hchar)-ord('0'));
+                } else {
+                    return (10+ord(hchar)-ord('A'));
+                }
+            }
+        '''
+        for func in c_function.searchString(source_code):
+            print("%(name)s (%(type)s) args: %(args)s" % func)
+
+
+    prints::
+
+        is_odd (int) args: [['int', 'x']]
+        dec_to_hex (int) args: [['char', 'hchar']]
+    """
+    if opener == closer:
+        raise ValueError("opening and closing strings cannot be the same")
+    if content is None:
+        if isinstance(opener, basestring) and isinstance(closer, basestring):
+            if len(opener) == 1 and len(closer) == 1:
+                if ignoreExpr is not None:
+                    content = (Combine(OneOrMore(~ignoreExpr
+                                                 + CharsNotIn(opener
+                                                              + closer
+                                                              + ParserElement.DEFAULT_WHITE_CHARS, exact=1)
+                                                 )
+                                       ).setParseAction(lambda t: t[0].strip()))
+                else:
+                    content = (empty.copy() + CharsNotIn(opener
+                                                         + closer
+                                                         + ParserElement.DEFAULT_WHITE_CHARS
+                                                         ).setParseAction(lambda t: t[0].strip()))
+            else:
+                if ignoreExpr is not None:
+                    content = (Combine(OneOrMore(~ignoreExpr
+                                                 + ~Literal(opener)
+                                                 + ~Literal(closer)
+                                                 + CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS, exact=1))
+                                       ).setParseAction(lambda t: t[0].strip()))
+                else:
+                    content = (Combine(OneOrMore(~Literal(opener)
+                                                 + ~Literal(closer)
+                                                 + CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS, exact=1))
+                                       ).setParseAction(lambda t: t[0].strip()))
+        else:
+            raise ValueError("opening and closing arguments must be strings if no content expression is given")
+    ret = Forward()
+    if ignoreExpr is not None:
+        ret <<= Group(Suppress(opener) + ZeroOrMore(ignoreExpr | ret | content) + Suppress(closer))
+    else:
+        ret <<= Group(Suppress(opener) + ZeroOrMore(ret | content)  + Suppress(closer))
+    ret.setName('nested %s%s expression' % (opener, closer))
+    return ret
+
+def indentedBlock(blockStatementExpr, indentStack, indent=True):
+    """Helper method for defining space-delimited indentation blocks,
+    such as those used to define block statements in Python source code.
+
+    Parameters:
+
+     - blockStatementExpr - expression defining syntax of statement that
+       is repeated within the indented block
+     - indentStack - list created by caller to manage indentation stack
+       (multiple statementWithIndentedBlock expressions within a single
+       grammar should share a common indentStack)
+     - indent - boolean indicating whether block must be indented beyond
+       the current level; set to False for block of left-most
+       statements (default= ``True``)
+
+    A valid block must contain at least one ``blockStatement``.
+
+    Example::
+
+        data = '''
+        def A(z):
+          A1
+          B = 100
+          G = A2
+          A2
+          A3
+        B
+        def BB(a,b,c):
+          BB1
+          def BBA():
+            bba1
+            bba2
+            bba3
+        C
+        D
+        def spam(x,y):
+             def eggs(z):
+                 pass
+        '''
+
+
+        indentStack = [1]
+        stmt = Forward()
+
+        identifier = Word(alphas, alphanums)
+        funcDecl = ("def" + identifier + Group("(" + Optional(delimitedList(identifier)) + ")") + ":")
+        func_body = indentedBlock(stmt, indentStack)
+        funcDef = Group(funcDecl + func_body)
+
+        rvalue = Forward()
+        funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")")
+        rvalue << (funcCall | identifier | Word(nums))
+        assignment = Group(identifier + "=" + rvalue)
+        stmt << (funcDef | assignment | identifier)
+
+        module_body = OneOrMore(stmt)
+
+        parseTree = module_body.parseString(data)
+        parseTree.pprint()
+
+    prints::
+
+        [['def',
+          'A',
+          ['(', 'z', ')'],
+          ':',
+          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],
+         'B',
+         ['def',
+          'BB',
+          ['(', 'a', 'b', 'c', ')'],
+          ':',
+          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],
+         'C',
+         'D',
+         ['def',
+          'spam',
+          ['(', 'x', 'y', ')'],
+          ':',
+          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]]
+    """
+    backup_stack = indentStack[:]
+
+    def reset_stack():
+        indentStack[:] = backup_stack
+
+    def checkPeerIndent(s, l, t):
+        if l >= len(s): return
+        curCol = col(l, s)
+        if curCol != indentStack[-1]:
+            if curCol > indentStack[-1]:
+                raise ParseException(s, l, "illegal nesting")
+            raise ParseException(s, l, "not a peer entry")
+
+    def checkSubIndent(s, l, t):
+        curCol = col(l, s)
+        if curCol > indentStack[-1]:
+            indentStack.append(curCol)
+        else:
+            raise ParseException(s, l, "not a subentry")
+
+    def checkUnindent(s, l, t):
+        if l >= len(s): return
+        curCol = col(l, s)
+        if not(indentStack and curCol in indentStack):
+            raise ParseException(s, l, "not an unindent")
+        if curCol < indentStack[-1]:
+            indentStack.pop()
+
+    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress(), stopOn=StringEnd())
+    INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName('INDENT')
+    PEER   = Empty().setParseAction(checkPeerIndent).setName('')
+    UNDENT = Empty().setParseAction(checkUnindent).setName('UNINDENT')
+    if indent:
+        smExpr = Group(Optional(NL)
+                       + INDENT
+                       + OneOrMore(PEER + Group(blockStatementExpr) + Optional(NL), stopOn=StringEnd())
+                       + UNDENT)
+    else:
+        smExpr = Group(Optional(NL)
+                       + OneOrMore(PEER + Group(blockStatementExpr) + Optional(NL), stopOn=StringEnd())
+                       + UNDENT)
+    smExpr.setFailAction(lambda a, b, c, d: reset_stack())
+    blockStatementExpr.ignore(_bslash + LineEnd())
+    return smExpr.setName('indented block')
+
+alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")
+punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")
+
+anyOpenTag, anyCloseTag = makeHTMLTags(Word(alphas, alphanums + "_:").setName('any tag'))
+_htmlEntityMap = dict(zip("gt lt amp nbsp quot apos".split(), '><& "\''))
+commonHTMLEntity = Regex('&(?P<entity>' + '|'.join(_htmlEntityMap.keys()) +");").setName("common HTML entity")
+def replaceHTMLEntity(t):
+    """Helper parser action to replace common HTML entities with their special characters"""
+    return _htmlEntityMap.get(t.entity)
+
+# it's easy to get these comment structures wrong - they're very common, so may as well make them available
+cStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/').setName("C style comment")
+"Comment of the form ``/* ... */``"
+
+htmlComment = Regex(r"<!--[\s\S]*?-->").setName("HTML comment")
+"Comment of the form ``<!-- ... -->``"
+
+restOfLine = Regex(r".*").leaveWhitespace().setName("rest of line")
+dblSlashComment = Regex(r"//(?:\\\n|[^\n])*").setName("// comment")
+"Comment of the form ``// ... (to end of line)``"
+
+cppStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/' | dblSlashComment).setName("C++ style comment")
+"Comment of either form :class:`cStyleComment` or :class:`dblSlashComment`"
+
+javaStyleComment = cppStyleComment
+"Same as :class:`cppStyleComment`"
+
+pythonStyleComment = Regex(r"#.*").setName("Python style comment")
+"Comment of the form ``# ... (to end of line)``"
+
+_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',')
+                                  + Optional(Word(" \t")
+                                             + ~Literal(",") + ~LineEnd()))).streamline().setName("commaItem")
+commaSeparatedList = delimitedList(Optional(quotedString.copy() | _commasepitem, default="")).setName("commaSeparatedList")
+"""(Deprecated) Predefined expression of 1 or more printable words or
+quoted strings, separated by commas.
+
+This expression is deprecated in favor of :class:`pyparsing_common.comma_separated_list`.
+"""
+
+# some other useful expressions - using lower-case class name since we are really using this as a namespace
+class pyparsing_common:
+    """Here are some common low-level expressions that may be useful in
+    jump-starting parser development:
+
+     - numeric forms (:class:`integers<integer>`, :class:`reals<real>`,
+       :class:`scientific notation<sci_real>`)
+     - common :class:`programming identifiers<identifier>`
+     - network addresses (:class:`MAC<mac_address>`,
+       :class:`IPv4<ipv4_address>`, :class:`IPv6<ipv6_address>`)
+     - ISO8601 :class:`dates<iso8601_date>` and
+       :class:`datetime<iso8601_datetime>`
+     - :class:`UUID<uuid>`
+     - :class:`comma-separated list<comma_separated_list>`
+
+    Parse actions:
+
+     - :class:`convertToInteger`
+     - :class:`convertToFloat`
+     - :class:`convertToDate`
+     - :class:`convertToDatetime`
+     - :class:`stripHTMLTags`
+     - :class:`upcaseTokens`
+     - :class:`downcaseTokens`
+
+    Example::
+
+        pyparsing_common.number.runTests('''
+            # any int or real number, returned as the appropriate type
+            100
+            -100
+            +100
+            3.14159
+            6.02e23
+            1e-12
+            ''')
+
+        pyparsing_common.fnumber.runTests('''
+            # any int or real number, returned as float
+            100
+            -100
+            +100
+            3.14159
+            6.02e23
+            1e-12
+            ''')
+
+        pyparsing_common.hex_integer.runTests('''
+            # hex numbers
+            100
+            FF
+            ''')
+
+        pyparsing_common.fraction.runTests('''
+            # fractions
+            1/2
+            -3/4
+            ''')
+
+        pyparsing_common.mixed_integer.runTests('''
+            # mixed fractions
+            1
+            1/2
+            -3/4
+            1-3/4
+            ''')
+
+        import uuid
+        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
+        pyparsing_common.uuid.runTests('''
+            # uuid
+            12345678-1234-5678-1234-567812345678
+            ''')
+
+    prints::
+
+        # any int or real number, returned as the appropriate type
+        100
+        [100]
+
+        -100
+        [-100]
+
+        +100
+        [100]
+
+        3.14159
+        [3.14159]
+
+        6.02e23
+        [6.02e+23]
+
+        1e-12
+        [1e-12]
+
+        # any int or real number, returned as float
+        100
+        [100.0]
+
+        -100
+        [-100.0]
+
+        +100
+        [100.0]
+
+        3.14159
+        [3.14159]
+
+        6.02e23
+        [6.02e+23]
+
+        1e-12
+        [1e-12]
+
+        # hex numbers
+        100
+        [256]
+
+        FF
+        [255]
+
+        # fractions
+        1/2
+        [0.5]
+
+        -3/4
+        [-0.75]
+
+        # mixed fractions
+        1
+        [1]
+
+        1/2
+        [0.5]
+
+        -3/4
+        [-0.75]
+
+        1-3/4
+        [1.75]
+
+        # uuid
+        12345678-1234-5678-1234-567812345678
+        [UUID('12345678-1234-5678-1234-567812345678')]
+    """
+
+    convertToInteger = tokenMap(int)
+    """
+    Parse action for converting parsed integers to Python int
+    """
+
+    convertToFloat = tokenMap(float)
+    """
+    Parse action for converting parsed numbers to Python float
+    """
+
+    integer = Word(nums).setName("integer").setParseAction(convertToInteger)
+    """expression that parses an unsigned integer, returns an int"""
+
+    hex_integer = Word(hexnums).setName("hex integer").setParseAction(tokenMap(int, 16))
+    """expression that parses a hexadecimal integer, returns an int"""
+
+    signed_integer = Regex(r'[+-]?\d+').setName("signed integer").setParseAction(convertToInteger)
+    """expression that parses an integer with optional leading sign, returns an int"""
+
+    fraction = (signed_integer().setParseAction(convertToFloat) + '/' + signed_integer().setParseAction(convertToFloat)).setName("fraction")
+    """fractional expression of an integer divided by an integer, returns a float"""
+    fraction.addParseAction(lambda t: t[0]/t[-1])
+
+    mixed_integer = (fraction | signed_integer + Optional(Optional('-').suppress() + fraction)).setName("fraction or mixed integer-fraction")
+    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float"""
+    mixed_integer.addParseAction(sum)
+
+    real = Regex(r'[+-]?(?:\d+\.\d*|\.\d+)').setName("real number").setParseAction(convertToFloat)
+    """expression that parses a floating point number and returns a float"""
+
+    sci_real = Regex(r'[+-]?(?:\d+(?:[eE][+-]?\d+)|(?:\d+\.\d*|\.\d+)(?:[eE][+-]?\d+)?)').setName("real number with scientific notation").setParseAction(convertToFloat)
+    """expression that parses a floating point number with optional
+    scientific notation and returns a float"""
+
+    # streamlining this expression makes the docs nicer-looking
+    number = (sci_real | real | signed_integer).streamline()
+    """any numeric expression, returns the corresponding Python type"""
+
+    fnumber = Regex(r'[+-]?\d+\.?\d*([eE][+-]?\d+)?').setName("fnumber").setParseAction(convertToFloat)
+    """any int or real number, returned as float"""
+
+    identifier = Word(alphas + '_', alphanums + '_').setName("identifier")
+    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')"""
+
+    ipv4_address = Regex(r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}').setName("IPv4 address")
+    "IPv4 address (``0.0.0.0 - 255.255.255.255``)"
+
+    _ipv6_part = Regex(r'[0-9a-fA-F]{1,4}').setName("hex_integer")
+    _full_ipv6_address = (_ipv6_part + (':' + _ipv6_part) * 7).setName("full IPv6 address")
+    _short_ipv6_address = (Optional(_ipv6_part + (':' + _ipv6_part) * (0, 6))
+                           + "::"
+                           + Optional(_ipv6_part + (':' + _ipv6_part) * (0, 6))
+                           ).setName("short IPv6 address")
+    _short_ipv6_address.addCondition(lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8)
+    _mixed_ipv6_address = ("::ffff:" + ipv4_address).setName("mixed IPv6 address")
+    ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName("IPv6 address")).setName("IPv6 address")
+    "IPv6 address (long, short, or mixed form)"
+
+    mac_address = Regex(r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}').setName("MAC address")
+    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)"
+
+    @staticmethod
+    def convertToDate(fmt="%Y-%m-%d"):
+        """
+        Helper to create a parse action for converting parsed date string to Python datetime.date
+
+        Params -
+         - fmt - format to be passed to datetime.strptime (default= ``"%Y-%m-%d"``)
+
+        Example::
+
+            date_expr = pyparsing_common.iso8601_date.copy()
+            date_expr.setParseAction(pyparsing_common.convertToDate())
+            print(date_expr.parseString("1999-12-31"))
+
+        prints::
+
+            [datetime.date(1999, 12, 31)]
+        """
+        def cvt_fn(s, l, t):
+            try:
+                return datetime.strptime(t[0], fmt).date()
+            except ValueError as ve:
+                raise ParseException(s, l, str(ve))
+        return cvt_fn
+
+    @staticmethod
+    def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"):
+        """Helper to create a parse action for converting parsed
+        datetime string to Python datetime.datetime
+
+        Params -
+         - fmt - format to be passed to datetime.strptime (default= ``"%Y-%m-%dT%H:%M:%S.%f"``)
+
+        Example::
+
+            dt_expr = pyparsing_common.iso8601_datetime.copy()
+            dt_expr.setParseAction(pyparsing_common.convertToDatetime())
+            print(dt_expr.parseString("1999-12-31T23:59:59.999"))
+
+        prints::
+
+            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]
+        """
+        def cvt_fn(s, l, t):
+            try:
+                return datetime.strptime(t[0], fmt)
+            except ValueError as ve:
+                raise ParseException(s, l, str(ve))
+        return cvt_fn
+
+    iso8601_date = Regex(r'(?P<year>\d{4})(?:-(?P<month>\d\d)(?:-(?P<day>\d\d))?)?').setName("ISO8601 date")
+    "ISO8601 date (``yyyy-mm-dd``)"
+
+    iso8601_datetime = Regex(r'(?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)[T ](?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d(\.\d*)?)?)?(?P<tz>Z|[+-]\d\d:?\d\d)?').setName("ISO8601 datetime")
+    "ISO8601 datetime (``yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)``) - trailing seconds, milliseconds, and timezone optional; accepts separating ``'T'`` or ``' '``"
+
+    uuid = Regex(r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}').setName("UUID")
+    "UUID (``xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx``)"
+
+    _html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress()
+    @staticmethod
+    def stripHTMLTags(s, l, tokens):
+        """Parse action to remove HTML tags from web page HTML source
+
+        Example::
+
+            # strip HTML links from normal text
+            text = '<td>More info at the <a href="https://github.com/pyparsing/pyparsing/wiki">pyparsing</a> wiki page</td>'
+            td, td_end = makeHTMLTags("TD")
+            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end
+            print(table_text.parseString(text).body)
+
+        Prints::
+
+            More info at the pyparsing wiki page
+        """
+        return pyparsing_common._html_stripper.transformString(tokens[0])
+
+    _commasepitem = Combine(OneOrMore(~Literal(",")
+                                      + ~LineEnd()
+                                      + Word(printables, excludeChars=',')
+                                      + Optional(White(" \t")))).streamline().setName("commaItem")
+    comma_separated_list = delimitedList(Optional(quotedString.copy()
+                                                  | _commasepitem, default='')
+                                         ).setName("comma separated list")
+    """Predefined expression of 1 or more printable words or quoted strings, separated by commas."""
+
+    upcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).upper()))
+    """Parse action to convert tokens to upper case."""
+
+    downcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).lower()))
+    """Parse action to convert tokens to lower case."""
+
+
+class _lazyclassproperty(object):
+    def __init__(self, fn):
+        self.fn = fn
+        self.__doc__ = fn.__doc__
+        self.__name__ = fn.__name__
+
+    def __get__(self, obj, cls):
+        if cls is None:
+            cls = type(obj)
+        if not hasattr(cls, '_intern') or any(cls._intern is getattr(superclass, '_intern', [])
+                                              for superclass in cls.__mro__[1:]):
+            cls._intern = {}
+        attrname = self.fn.__name__
+        if attrname not in cls._intern:
+            cls._intern[attrname] = self.fn(cls)
+        return cls._intern[attrname]
+
+
+class unicode_set(object):
+    """
+    A set of Unicode characters, for language-specific strings for
+    ``alphas``, ``nums``, ``alphanums``, and ``printables``.
+    A unicode_set is defined by a list of ranges in the Unicode character
+    set, in a class attribute ``_ranges``, such as::
+
+        _ranges = [(0x0020, 0x007e), (0x00a0, 0x00ff),]
+
+    A unicode set can also be defined using multiple inheritance of other unicode sets::
+
+        class CJK(Chinese, Japanese, Korean):
+            pass
+    """
+    _ranges = []
+
+    @classmethod
+    def _get_chars_for_ranges(cls):
+        ret = []
+        for cc in cls.__mro__:
+            if cc is unicode_set:
+                break
+            for rr in cc._ranges:
+                ret.extend(range(rr[0], rr[-1] + 1))
+        return [unichr(c) for c in sorted(set(ret))]
+
+    @_lazyclassproperty
+    def printables(cls):
+        "all non-whitespace characters in this range"
+        return u''.join(filterfalse(unicode.isspace, cls._get_chars_for_ranges()))
+
+    @_lazyclassproperty
+    def alphas(cls):
+        "all alphabetic characters in this range"
+        return u''.join(filter(unicode.isalpha, cls._get_chars_for_ranges()))
+
+    @_lazyclassproperty
+    def nums(cls):
+        "all numeric digit characters in this range"
+        return u''.join(filter(unicode.isdigit, cls._get_chars_for_ranges()))
+
+    @_lazyclassproperty
+    def alphanums(cls):
+        "all alphanumeric characters in this range"
+        return cls.alphas + cls.nums
+
+
+class pyparsing_unicode(unicode_set):
+    """
+    A namespace class for defining common language unicode_sets.
+    """
+    _ranges = [(32, sys.maxunicode)]
+
+    class Latin1(unicode_set):
+        "Unicode set for Latin-1 Unicode Character Range"
+        _ranges = [(0x0020, 0x007e), (0x00a0, 0x00ff),]
+
+    class LatinA(unicode_set):
+        "Unicode set for Latin-A Unicode Character Range"
+        _ranges = [(0x0100, 0x017f),]
+
+    class LatinB(unicode_set):
+        "Unicode set for Latin-B Unicode Character Range"
+        _ranges = [(0x0180, 0x024f),]
+
+    class Greek(unicode_set):
+        "Unicode set for Greek Unicode Character Ranges"
+        _ranges = [
+            (0x0370, 0x03ff), (0x1f00, 0x1f15), (0x1f18, 0x1f1d), (0x1f20, 0x1f45), (0x1f48, 0x1f4d),
+            (0x1f50, 0x1f57), (0x1f59,), (0x1f5b,), (0x1f5d,), (0x1f5f, 0x1f7d), (0x1f80, 0x1fb4), (0x1fb6, 0x1fc4),
+            (0x1fc6, 0x1fd3), (0x1fd6, 0x1fdb), (0x1fdd, 0x1fef), (0x1ff2, 0x1ff4), (0x1ff6, 0x1ffe),
+        ]
+
+    class Cyrillic(unicode_set):
+        "Unicode set for Cyrillic Unicode Character Range"
+        _ranges = [(0x0400, 0x04ff)]
+
+    class Chinese(unicode_set):
+        "Unicode set for Chinese Unicode Character Range"
+        _ranges = [(0x4e00, 0x9fff), (0x3000, 0x303f),]
+
+    class Japanese(unicode_set):
+        "Unicode set for Japanese Unicode Character Range, combining Kanji, Hiragana, and Katakana ranges"
+        _ranges = []
+
+        class Kanji(unicode_set):
+            "Unicode set for Kanji Unicode Character Range"
+            _ranges = [(0x4E00, 0x9Fbf), (0x3000, 0x303f),]
+
+        class Hiragana(unicode_set):
+            "Unicode set for Hiragana Unicode Character Range"
+            _ranges = [(0x3040, 0x309f),]
+
+        class Katakana(unicode_set):
+            "Unicode set for Katakana  Unicode Character Range"
+            _ranges = [(0x30a0, 0x30ff),]
+
+    class Korean(unicode_set):
+        "Unicode set for Korean Unicode Character Range"
+        _ranges = [(0xac00, 0xd7af), (0x1100, 0x11ff), (0x3130, 0x318f), (0xa960, 0xa97f), (0xd7b0, 0xd7ff), (0x3000, 0x303f),]
+
+    class CJK(Chinese, Japanese, Korean):
+        "Unicode set for combined Chinese, Japanese, and Korean (CJK) Unicode Character Range"
+        pass
+
+    class Thai(unicode_set):
+        "Unicode set for Thai Unicode Character Range"
+        _ranges = [(0x0e01, 0x0e3a), (0x0e3f, 0x0e5b),]
+
+    class Arabic(unicode_set):
+        "Unicode set for Arabic Unicode Character Range"
+        _ranges = [(0x0600, 0x061b), (0x061e, 0x06ff), (0x0700, 0x077f),]
+
+    class Hebrew(unicode_set):
+        "Unicode set for Hebrew Unicode Character Range"
+        _ranges = [(0x0590, 0x05ff),]
+
+    class Devanagari(unicode_set):
+        "Unicode set for Devanagari Unicode Character Range"
+        _ranges = [(0x0900, 0x097f), (0xa8e0, 0xa8ff)]
+
+pyparsing_unicode.Japanese._ranges = (pyparsing_unicode.Japanese.Kanji._ranges
+                                      + pyparsing_unicode.Japanese.Hiragana._ranges
+                                      + pyparsing_unicode.Japanese.Katakana._ranges)
+
+# define ranges in language character sets
+if PY_3:
+    setattr(pyparsing_unicode, u"العربية", pyparsing_unicode.Arabic)
+    setattr(pyparsing_unicode, u"中文", pyparsing_unicode.Chinese)
+    setattr(pyparsing_unicode, u"кириллица", pyparsing_unicode.Cyrillic)
+    setattr(pyparsing_unicode, u"Ελληνικά", pyparsing_unicode.Greek)
+    setattr(pyparsing_unicode, u"עִברִית", pyparsing_unicode.Hebrew)
+    setattr(pyparsing_unicode, u"日本語", pyparsing_unicode.Japanese)
+    setattr(pyparsing_unicode.Japanese, u"漢字", pyparsing_unicode.Japanese.Kanji)
+    setattr(pyparsing_unicode.Japanese, u"カタカナ", pyparsing_unicode.Japanese.Katakana)
+    setattr(pyparsing_unicode.Japanese, u"ひらがな", pyparsing_unicode.Japanese.Hiragana)
+    setattr(pyparsing_unicode, u"한국어", pyparsing_unicode.Korean)
+    setattr(pyparsing_unicode, u"ไทย", pyparsing_unicode.Thai)
+    setattr(pyparsing_unicode, u"देवनागरी", pyparsing_unicode.Devanagari)
+
+
+class pyparsing_test:
+    """
+    namespace class for classes useful in writing unit tests
+    """
+
+    class reset_pyparsing_context:
+        """
+        Context manager to be used when writing unit tests that modify pyparsing config values:
+         - packrat parsing
+         - default whitespace characters.
+         - default keyword characters
+         - literal string auto-conversion class
+         - __diag__ settings
+
+        Example:
+            with reset_pyparsing_context():
+                # test that literals used to construct a grammar are automatically suppressed
+                ParserElement.inlineLiteralsUsing(Suppress)
+
+                term = Word(alphas) | Word(nums)
+                group = Group('(' + term[...] + ')')
+
+                # assert that the '()' characters are not included in the parsed tokens
+                self.assertParseAndCheckLisst(group, "(abc 123 def)", ['abc', '123', 'def'])
+
+            # after exiting context manager, literals are converted to Literal expressions again
+        """
+
+        def __init__(self):
+            self._save_context = {}
+
+        def save(self):
+            self._save_context["default_whitespace"] = ParserElement.DEFAULT_WHITE_CHARS
+            self._save_context["default_keyword_chars"] = Keyword.DEFAULT_KEYWORD_CHARS
+            self._save_context[
+                "literal_string_class"
+            ] = ParserElement._literalStringClass
+            self._save_context["packrat_enabled"] = ParserElement._packratEnabled
+            self._save_context["packrat_parse"] = ParserElement._parse
+            self._save_context["__diag__"] = {
+                name: getattr(__diag__, name) for name in __diag__._all_names
+            }
+            self._save_context["__compat__"] = {
+                "collect_all_And_tokens": __compat__.collect_all_And_tokens
+            }
+            return self
+
+        def restore(self):
+            # reset pyparsing global state
+            if (
+                ParserElement.DEFAULT_WHITE_CHARS
+                != self._save_context["default_whitespace"]
+            ):
+                ParserElement.setDefaultWhitespaceChars(
+                    self._save_context["default_whitespace"]
+                )
+            Keyword.DEFAULT_KEYWORD_CHARS = self._save_context["default_keyword_chars"]
+            ParserElement.inlineLiteralsUsing(
+                self._save_context["literal_string_class"]
+            )
+            for name, value in self._save_context["__diag__"].items():
+                setattr(__diag__, name, value)
+            ParserElement._packratEnabled = self._save_context["packrat_enabled"]
+            ParserElement._parse = self._save_context["packrat_parse"]
+            __compat__.collect_all_And_tokens = self._save_context["__compat__"]
+
+        def __enter__(self):
+            return self.save()
+
+        def __exit__(self, *args):
+            return self.restore()
+
+    class TestParseResultsAsserts:
+        """
+        A mixin class to add parse results assertion methods to normal unittest.TestCase classes.
+        """
+        def assertParseResultsEquals(
+            self, result, expected_list=None, expected_dict=None, msg=None
+        ):
+            """
+            Unit test assertion to compare a ParseResults object with an optional expected_list,
+            and compare any defined results names with an optional expected_dict.
+            """
+            if expected_list is not None:
+                self.assertEqual(expected_list, result.asList(), msg=msg)
+            if expected_dict is not None:
+                self.assertEqual(expected_dict, result.asDict(), msg=msg)
+
+        def assertParseAndCheckList(
+            self, expr, test_string, expected_list, msg=None, verbose=True
+        ):
+            """
+            Convenience wrapper assert to test a parser element and input string, and assert that
+            the resulting ParseResults.asList() is equal to the expected_list.
+            """
+            result = expr.parseString(test_string, parseAll=True)
+            if verbose:
+                print(result.dump())
+            self.assertParseResultsEquals(result, expected_list=expected_list, msg=msg)
+
+        def assertParseAndCheckDict(
+            self, expr, test_string, expected_dict, msg=None, verbose=True
+        ):
+            """
+            Convenience wrapper assert to test a parser element and input string, and assert that
+            the resulting ParseResults.asDict() is equal to the expected_dict.
+            """
+            result = expr.parseString(test_string, parseAll=True)
+            if verbose:
+                print(result.dump())
+            self.assertParseResultsEquals(result, expected_dict=expected_dict, msg=msg)
+
+        def assertRunTestResults(
+            self, run_tests_report, expected_parse_results=None, msg=None
+        ):
+            """
+            Unit test assertion to evaluate output of ParserElement.runTests(). If a list of
+            list-dict tuples is given as the expected_parse_results argument, then these are zipped
+            with the report tuples returned by runTests and evaluated using assertParseResultsEquals.
+            Finally, asserts that the overall runTests() success value is True.
+
+            :param run_tests_report: tuple(bool, [tuple(str, ParseResults or Exception)]) returned from runTests
+            :param expected_parse_results (optional): [tuple(str, list, dict, Exception)]
+            """
+            run_test_success, run_test_results = run_tests_report
+
+            if expected_parse_results is not None:
+                merged = [
+                    (rpt[0], rpt[1], expected)
+                    for rpt, expected in zip(run_test_results, expected_parse_results)
+                ]
+                for test_string, result, expected in merged:
+                    # expected should be a tuple containing a list and/or a dict or an exception,
+                    # and optional failure message string
+                    # an empty tuple will skip any result validation
+                    fail_msg = next(
+                        (exp for exp in expected if isinstance(exp, str)), None
+                    )
+                    expected_exception = next(
+                        (
+                            exp
+                            for exp in expected
+                            if isinstance(exp, type) and issubclass(exp, Exception)
+                        ),
+                        None,
+                    )
+                    if expected_exception is not None:
+                        with self.assertRaises(
+                            expected_exception=expected_exception, msg=fail_msg or msg
+                        ):
+                            if isinstance(result, Exception):
+                                raise result
+                    else:
+                        expected_list = next(
+                            (exp for exp in expected if isinstance(exp, list)), None
+                        )
+                        expected_dict = next(
+                            (exp for exp in expected if isinstance(exp, dict)), None
+                        )
+                        if (expected_list, expected_dict) != (None, None):
+                            self.assertParseResultsEquals(
+                                result,
+                                expected_list=expected_list,
+                                expected_dict=expected_dict,
+                                msg=fail_msg or msg,
+                            )
+                        else:
+                            # warning here maybe?
+                            print("no validation for {!r}".format(test_string))
+
+            # do this last, in case some specific test results can be reported instead
+            self.assertTrue(
+                run_test_success, msg=msg if msg is not None else "failed runTests"
+            )
+
+        @contextmanager
+        def assertRaisesParseException(self, exc_type=ParseException, msg=None):
+            with self.assertRaises(exc_type, msg=msg):
+                yield
+
+
+if __name__ == "__main__":
+
+    selectToken    = CaselessLiteral("select")
+    fromToken      = CaselessLiteral("from")
+
+    ident          = Word(alphas, alphanums + "_$")
+
+    columnName     = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
+    columnNameList = Group(delimitedList(columnName)).setName("columns")
+    columnSpec     = ('*' | columnNameList)
+
+    tableName      = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
+    tableNameList  = Group(delimitedList(tableName)).setName("tables")
+
+    simpleSQL      = selectToken("command") + columnSpec("columns") + fromToken + tableNameList("tables")
+
+    # demo runTests method, including embedded comments in test string
+    simpleSQL.runTests("""
+        # '*' as column list and dotted table name
+        select * from SYS.XYZZY
+
+        # caseless match on "SELECT", and casts back to "select"
+        SELECT * from XYZZY, ABC
+
+        # list of column names, and mixed case SELECT keyword
+        Select AA,BB,CC from Sys.dual
+
+        # multiple tables
+        Select A, B, C from Sys.dual, Table2
+
+        # invalid SELECT keyword - should fail
+        Xelect A, B, C from Sys.dual
+
+        # incomplete command - should fail
+        Select
+
+        # invalid column name - should fail
+        Select ^^^ frox Sys.dual
+
+        """)
+
+    pyparsing_common.number.runTests("""
+        100
+        -100
+        +100
+        3.14159
+        6.02e23
+        1e-12
+        """)
+
+    # any int or real number, returned as float
+    pyparsing_common.fnumber.runTests("""
+        100
+        -100
+        +100
+        3.14159
+        6.02e23
+        1e-12
+        """)
+
+    pyparsing_common.hex_integer.runTests("""
+        100
+        FF
+        """)
+
+    import uuid
+    pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
+    pyparsing_common.uuid.runTests("""
+        12345678-1234-5678-1234-567812345678
+        """)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/__init__.py
new file mode 100644
index 0000000..517458b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/__init__.py
@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+
+#   __
+#  /__)  _  _     _   _ _/   _
+# / (   (- (/ (/ (- _)  /  _)
+#          /
+
+"""
+Requests HTTP Library
+~~~~~~~~~~~~~~~~~~~~~
+
+Requests is an HTTP library, written in Python, for human beings.
+Basic GET usage:
+
+   >>> import requests
+   >>> r = requests.get('https://www.python.org')
+   >>> r.status_code
+   200
+   >>> b'Python is a programming language' in r.content
+   True
+
+... or POST:
+
+   >>> payload = dict(key1='value1', key2='value2')
+   >>> r = requests.post('https://httpbin.org/post', data=payload)
+   >>> print(r.text)
+   {
+     ...
+     "form": {
+       "key1": "value1",
+       "key2": "value2"
+     },
+     ...
+   }
+
+The other HTTP methods are supported - see `requests.api`. Full documentation
+is at <https://requests.readthedocs.io>.
+
+:copyright: (c) 2017 by Kenneth Reitz.
+:license: Apache 2.0, see LICENSE for more details.
+"""
+
+from pip._vendor import urllib3
+from pip._vendor import chardet
+import warnings
+from .exceptions import RequestsDependencyWarning
+
+
+def check_compatibility(urllib3_version, chardet_version):
+    urllib3_version = urllib3_version.split('.')
+    assert urllib3_version != ['dev']  # Verify urllib3 isn't installed from git.
+
+    # Sometimes, urllib3 only reports its version as 16.1.
+    if len(urllib3_version) == 2:
+        urllib3_version.append('0')
+
+    # Check urllib3 for compatibility.
+    major, minor, patch = urllib3_version  # noqa: F811
+    major, minor, patch = int(major), int(minor), int(patch)
+    # urllib3 >= 1.21.1, <= 1.25
+    assert major == 1
+    assert minor >= 21
+    assert minor <= 25
+
+    # Check chardet for compatibility.
+    major, minor, patch = chardet_version.split('.')[:3]
+    major, minor, patch = int(major), int(minor), int(patch)
+    # chardet >= 3.0.2, < 3.1.0
+    assert major == 3
+    assert minor < 1
+    assert patch >= 2
+
+
+def _check_cryptography(cryptography_version):
+    # cryptography < 1.3.4
+    try:
+        cryptography_version = list(map(int, cryptography_version.split('.')))
+    except ValueError:
+        return
+
+    if cryptography_version < [1, 3, 4]:
+        warning = 'Old version of cryptography ({}) may cause slowdown.'.format(cryptography_version)
+        warnings.warn(warning, RequestsDependencyWarning)
+
+# Check imported dependencies for compatibility.
+try:
+    check_compatibility(urllib3.__version__, chardet.__version__)
+except (AssertionError, ValueError):
+    warnings.warn("urllib3 ({}) or chardet ({}) doesn't match a supported "
+                  "version!".format(urllib3.__version__, chardet.__version__),
+                  RequestsDependencyWarning)
+
+# Attempt to enable urllib3's fallback for SNI support
+# if the standard library doesn't support SNI or the
+# 'ssl' library isn't available.
+try:
+    # Note: This logic prevents upgrading cryptography on Windows, if imported
+    #       as part of pip.
+    from pip._internal.utils.compat import WINDOWS
+    if not WINDOWS:
+        raise ImportError("pip internals: don't import cryptography on Windows")
+    try:
+        import ssl
+    except ImportError:
+        ssl = None
+
+    if not getattr(ssl, "HAS_SNI", False):
+        from pip._vendor.urllib3.contrib import pyopenssl
+        pyopenssl.inject_into_urllib3()
+
+        # Check cryptography version
+        from cryptography import __version__ as cryptography_version
+        _check_cryptography(cryptography_version)
+except ImportError:
+    pass
+
+# urllib3's DependencyWarnings should be silenced.
+from pip._vendor.urllib3.exceptions import DependencyWarning
+warnings.simplefilter('ignore', DependencyWarning)
+
+from .__version__ import __title__, __description__, __url__, __version__
+from .__version__ import __build__, __author__, __author_email__, __license__
+from .__version__ import __copyright__, __cake__
+
+from . import utils
+from . import packages
+from .models import Request, Response, PreparedRequest
+from .api import request, get, head, post, patch, put, delete, options
+from .sessions import session, Session
+from .status_codes import codes
+from .exceptions import (
+    RequestException, Timeout, URLRequired,
+    TooManyRedirects, HTTPError, ConnectionError,
+    FileModeWarning, ConnectTimeout, ReadTimeout
+)
+
+# Set default logging handler to avoid "No handler found" warnings.
+import logging
+from logging import NullHandler
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+# FileModeWarnings go off per the default.
+warnings.simplefilter('default', FileModeWarning, append=True)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/__version__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/__version__.py
new file mode 100644
index 0000000..531e26c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/__version__.py
@@ -0,0 +1,14 @@
+# .-. .-. .-. . . .-. .-. .-. .-.
+# |(  |-  |.| | | |-  `-.  |  `-.
+# ' ' `-' `-`.`-' `-' `-'  '  `-'
+
+__title__ = 'requests'
+__description__ = 'Python HTTP for Humans.'
+__url__ = 'https://requests.readthedocs.io'
+__version__ = '2.24.0'
+__build__ = 0x022400
+__author__ = 'Kenneth Reitz'
+__author_email__ = 'me@kennethreitz.org'
+__license__ = 'Apache 2.0'
+__copyright__ = 'Copyright 2020 Kenneth Reitz'
+__cake__ = u'\u2728 \U0001f370 \u2728'
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/_internal_utils.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/_internal_utils.py
new file mode 100644
index 0000000..759d9a5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/_internal_utils.py
@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests._internal_utils
+~~~~~~~~~~~~~~
+
+Provides utility functions that are consumed internally by Requests
+which depend on extremely few external helpers (such as compat)
+"""
+
+from .compat import is_py2, builtin_str, str
+
+
+def to_native_string(string, encoding='ascii'):
+    """Given a string object, regardless of type, returns a representation of
+    that string in the native string type, encoding and decoding where
+    necessary. This assumes ASCII unless told otherwise.
+    """
+    if isinstance(string, builtin_str):
+        out = string
+    else:
+        if is_py2:
+            out = string.encode(encoding)
+        else:
+            out = string.decode(encoding)
+
+    return out
+
+
+def unicode_is_ascii(u_string):
+    """Determine if unicode string only contains ASCII characters.
+
+    :param str u_string: unicode string to check. Must be unicode
+        and not Python 2 `str`.
+    :rtype: bool
+    """
+    assert isinstance(u_string, str)
+    try:
+        u_string.encode('ascii')
+        return True
+    except UnicodeEncodeError:
+        return False
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/adapters.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/adapters.py
new file mode 100644
index 0000000..c30e7c9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/adapters.py
@@ -0,0 +1,533 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.adapters
+~~~~~~~~~~~~~~~~~
+
+This module contains the transport adapters that Requests uses to define
+and maintain connections.
+"""
+
+import os.path
+import socket
+
+from pip._vendor.urllib3.poolmanager import PoolManager, proxy_from_url
+from pip._vendor.urllib3.response import HTTPResponse
+from pip._vendor.urllib3.util import parse_url
+from pip._vendor.urllib3.util import Timeout as TimeoutSauce
+from pip._vendor.urllib3.util.retry import Retry
+from pip._vendor.urllib3.exceptions import ClosedPoolError
+from pip._vendor.urllib3.exceptions import ConnectTimeoutError
+from pip._vendor.urllib3.exceptions import HTTPError as _HTTPError
+from pip._vendor.urllib3.exceptions import MaxRetryError
+from pip._vendor.urllib3.exceptions import NewConnectionError
+from pip._vendor.urllib3.exceptions import ProxyError as _ProxyError
+from pip._vendor.urllib3.exceptions import ProtocolError
+from pip._vendor.urllib3.exceptions import ReadTimeoutError
+from pip._vendor.urllib3.exceptions import SSLError as _SSLError
+from pip._vendor.urllib3.exceptions import ResponseError
+from pip._vendor.urllib3.exceptions import LocationValueError
+
+from .models import Response
+from .compat import urlparse, basestring
+from .utils import (DEFAULT_CA_BUNDLE_PATH, extract_zipped_paths,
+                    get_encoding_from_headers, prepend_scheme_if_needed,
+                    get_auth_from_url, urldefragauth, select_proxy)
+from .structures import CaseInsensitiveDict
+from .cookies import extract_cookies_to_jar
+from .exceptions import (ConnectionError, ConnectTimeout, ReadTimeout, SSLError,
+                         ProxyError, RetryError, InvalidSchema, InvalidProxyURL,
+                         InvalidURL)
+from .auth import _basic_auth_str
+
+try:
+    from pip._vendor.urllib3.contrib.socks import SOCKSProxyManager
+except ImportError:
+    def SOCKSProxyManager(*args, **kwargs):
+        raise InvalidSchema("Missing dependencies for SOCKS support.")
+
+DEFAULT_POOLBLOCK = False
+DEFAULT_POOLSIZE = 10
+DEFAULT_RETRIES = 0
+DEFAULT_POOL_TIMEOUT = None
+
+
+class BaseAdapter(object):
+    """The Base Transport Adapter"""
+
+    def __init__(self):
+        super(BaseAdapter, self).__init__()
+
+    def send(self, request, stream=False, timeout=None, verify=True,
+             cert=None, proxies=None):
+        """Sends PreparedRequest object. Returns Response object.
+
+        :param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
+        :param stream: (optional) Whether to stream the request content.
+        :param timeout: (optional) How long to wait for the server to send
+            data before giving up, as a float, or a :ref:`(connect timeout,
+            read timeout) <timeouts>` tuple.
+        :type timeout: float or tuple
+        :param verify: (optional) Either a boolean, in which case it controls whether we verify
+            the server's TLS certificate, or a string, in which case it must be a path
+            to a CA bundle to use
+        :param cert: (optional) Any user-provided SSL certificate to be trusted.
+        :param proxies: (optional) The proxies dictionary to apply to the request.
+        """
+        raise NotImplementedError
+
+    def close(self):
+        """Cleans up adapter specific items."""
+        raise NotImplementedError
+
+
+class HTTPAdapter(BaseAdapter):
+    """The built-in HTTP Adapter for urllib3.
+
+    Provides a general-case interface for Requests sessions to contact HTTP and
+    HTTPS urls by implementing the Transport Adapter interface. This class will
+    usually be created by the :class:`Session <Session>` class under the
+    covers.
+
+    :param pool_connections: The number of urllib3 connection pools to cache.
+    :param pool_maxsize: The maximum number of connections to save in the pool.
+    :param max_retries: The maximum number of retries each connection
+        should attempt. Note, this applies only to failed DNS lookups, socket
+        connections and connection timeouts, never to requests where data has
+        made it to the server. By default, Requests does not retry failed
+        connections. If you need granular control over the conditions under
+        which we retry a request, import urllib3's ``Retry`` class and pass
+        that instead.
+    :param pool_block: Whether the connection pool should block for connections.
+
+    Usage::
+
+      >>> import requests
+      >>> s = requests.Session()
+      >>> a = requests.adapters.HTTPAdapter(max_retries=3)
+      >>> s.mount('http://', a)
+    """
+    __attrs__ = ['max_retries', 'config', '_pool_connections', '_pool_maxsize',
+                 '_pool_block']
+
+    def __init__(self, pool_connections=DEFAULT_POOLSIZE,
+                 pool_maxsize=DEFAULT_POOLSIZE, max_retries=DEFAULT_RETRIES,
+                 pool_block=DEFAULT_POOLBLOCK):
+        if max_retries == DEFAULT_RETRIES:
+            self.max_retries = Retry(0, read=False)
+        else:
+            self.max_retries = Retry.from_int(max_retries)
+        self.config = {}
+        self.proxy_manager = {}
+
+        super(HTTPAdapter, self).__init__()
+
+        self._pool_connections = pool_connections
+        self._pool_maxsize = pool_maxsize
+        self._pool_block = pool_block
+
+        self.init_poolmanager(pool_connections, pool_maxsize, block=pool_block)
+
+    def __getstate__(self):
+        return {attr: getattr(self, attr, None) for attr in self.__attrs__}
+
+    def __setstate__(self, state):
+        # Can't handle by adding 'proxy_manager' to self.__attrs__ because
+        # self.poolmanager uses a lambda function, which isn't pickleable.
+        self.proxy_manager = {}
+        self.config = {}
+
+        for attr, value in state.items():
+            setattr(self, attr, value)
+
+        self.init_poolmanager(self._pool_connections, self._pool_maxsize,
+                              block=self._pool_block)
+
+    def init_poolmanager(self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs):
+        """Initializes a urllib3 PoolManager.
+
+        This method should not be called from user code, and is only
+        exposed for use when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param connections: The number of urllib3 connection pools to cache.
+        :param maxsize: The maximum number of connections to save in the pool.
+        :param block: Block when no free connections are available.
+        :param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager.
+        """
+        # save these values for pickling
+        self._pool_connections = connections
+        self._pool_maxsize = maxsize
+        self._pool_block = block
+
+        self.poolmanager = PoolManager(num_pools=connections, maxsize=maxsize,
+                                       block=block, strict=True, **pool_kwargs)
+
+    def proxy_manager_for(self, proxy, **proxy_kwargs):
+        """Return urllib3 ProxyManager for the given proxy.
+
+        This method should not be called from user code, and is only
+        exposed for use when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param proxy: The proxy to return a urllib3 ProxyManager for.
+        :param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager.
+        :returns: ProxyManager
+        :rtype: urllib3.ProxyManager
+        """
+        if proxy in self.proxy_manager:
+            manager = self.proxy_manager[proxy]
+        elif proxy.lower().startswith('socks'):
+            username, password = get_auth_from_url(proxy)
+            manager = self.proxy_manager[proxy] = SOCKSProxyManager(
+                proxy,
+                username=username,
+                password=password,
+                num_pools=self._pool_connections,
+                maxsize=self._pool_maxsize,
+                block=self._pool_block,
+                **proxy_kwargs
+            )
+        else:
+            proxy_headers = self.proxy_headers(proxy)
+            manager = self.proxy_manager[proxy] = proxy_from_url(
+                proxy,
+                proxy_headers=proxy_headers,
+                num_pools=self._pool_connections,
+                maxsize=self._pool_maxsize,
+                block=self._pool_block,
+                **proxy_kwargs)
+
+        return manager
+
+    def cert_verify(self, conn, url, verify, cert):
+        """Verify a SSL certificate. This method should not be called from user
+        code, and is only exposed for use when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param conn: The urllib3 connection object associated with the cert.
+        :param url: The requested URL.
+        :param verify: Either a boolean, in which case it controls whether we verify
+            the server's TLS certificate, or a string, in which case it must be a path
+            to a CA bundle to use
+        :param cert: The SSL certificate to verify.
+        """
+        if url.lower().startswith('https') and verify:
+
+            cert_loc = None
+
+            # Allow self-specified cert location.
+            if verify is not True:
+                cert_loc = verify
+
+            if not cert_loc:
+                cert_loc = extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH)
+
+            if not cert_loc or not os.path.exists(cert_loc):
+                raise IOError("Could not find a suitable TLS CA certificate bundle, "
+                              "invalid path: {}".format(cert_loc))
+
+            conn.cert_reqs = 'CERT_REQUIRED'
+
+            if not os.path.isdir(cert_loc):
+                conn.ca_certs = cert_loc
+            else:
+                conn.ca_cert_dir = cert_loc
+        else:
+            conn.cert_reqs = 'CERT_NONE'
+            conn.ca_certs = None
+            conn.ca_cert_dir = None
+
+        if cert:
+            if not isinstance(cert, basestring):
+                conn.cert_file = cert[0]
+                conn.key_file = cert[1]
+            else:
+                conn.cert_file = cert
+                conn.key_file = None
+            if conn.cert_file and not os.path.exists(conn.cert_file):
+                raise IOError("Could not find the TLS certificate file, "
+                              "invalid path: {}".format(conn.cert_file))
+            if conn.key_file and not os.path.exists(conn.key_file):
+                raise IOError("Could not find the TLS key file, "
+                              "invalid path: {}".format(conn.key_file))
+
+    def build_response(self, req, resp):
+        """Builds a :class:`Response <requests.Response>` object from a urllib3
+        response. This should not be called from user code, and is only exposed
+        for use when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`
+
+        :param req: The :class:`PreparedRequest <PreparedRequest>` used to generate the response.
+        :param resp: The urllib3 response object.
+        :rtype: requests.Response
+        """
+        response = Response()
+
+        # Fallback to None if there's no status_code, for whatever reason.
+        response.status_code = getattr(resp, 'status', None)
+
+        # Make headers case-insensitive.
+        response.headers = CaseInsensitiveDict(getattr(resp, 'headers', {}))
+
+        # Set encoding.
+        response.encoding = get_encoding_from_headers(response.headers)
+        response.raw = resp
+        response.reason = response.raw.reason
+
+        if isinstance(req.url, bytes):
+            response.url = req.url.decode('utf-8')
+        else:
+            response.url = req.url
+
+        # Add new cookies from the server.
+        extract_cookies_to_jar(response.cookies, req, resp)
+
+        # Give the Response some context.
+        response.request = req
+        response.connection = self
+
+        return response
+
+    def get_connection(self, url, proxies=None):
+        """Returns a urllib3 connection for the given URL. This should not be
+        called from user code, and is only exposed for use when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param url: The URL to connect to.
+        :param proxies: (optional) A Requests-style dictionary of proxies used on this request.
+        :rtype: urllib3.ConnectionPool
+        """
+        proxy = select_proxy(url, proxies)
+
+        if proxy:
+            proxy = prepend_scheme_if_needed(proxy, 'http')
+            proxy_url = parse_url(proxy)
+            if not proxy_url.host:
+                raise InvalidProxyURL("Please check proxy URL. It is malformed"
+                                      " and could be missing the host.")
+            proxy_manager = self.proxy_manager_for(proxy)
+            conn = proxy_manager.connection_from_url(url)
+        else:
+            # Only scheme should be lower case
+            parsed = urlparse(url)
+            url = parsed.geturl()
+            conn = self.poolmanager.connection_from_url(url)
+
+        return conn
+
+    def close(self):
+        """Disposes of any internal state.
+
+        Currently, this closes the PoolManager and any active ProxyManager,
+        which closes any pooled connections.
+        """
+        self.poolmanager.clear()
+        for proxy in self.proxy_manager.values():
+            proxy.clear()
+
+    def request_url(self, request, proxies):
+        """Obtain the url to use when making the final request.
+
+        If the message is being sent through a HTTP proxy, the full URL has to
+        be used. Otherwise, we should only use the path portion of the URL.
+
+        This should not be called from user code, and is only exposed for use
+        when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
+        :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs.
+        :rtype: str
+        """
+        proxy = select_proxy(request.url, proxies)
+        scheme = urlparse(request.url).scheme
+
+        is_proxied_http_request = (proxy and scheme != 'https')
+        using_socks_proxy = False
+        if proxy:
+            proxy_scheme = urlparse(proxy).scheme.lower()
+            using_socks_proxy = proxy_scheme.startswith('socks')
+
+        url = request.path_url
+        if is_proxied_http_request and not using_socks_proxy:
+            url = urldefragauth(request.url)
+
+        return url
+
+    def add_headers(self, request, **kwargs):
+        """Add any headers needed by the connection. As of v2.0 this does
+        nothing by default, but is left for overriding by users that subclass
+        the :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        This should not be called from user code, and is only exposed for use
+        when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param request: The :class:`PreparedRequest <PreparedRequest>` to add headers to.
+        :param kwargs: The keyword arguments from the call to send().
+        """
+        pass
+
+    def proxy_headers(self, proxy):
+        """Returns a dictionary of the headers to add to any request sent
+        through a proxy. This works with urllib3 magic to ensure that they are
+        correctly sent to the proxy, rather than in a tunnelled request if
+        CONNECT is being used.
+
+        This should not be called from user code, and is only exposed for use
+        when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param proxy: The url of the proxy being used for this request.
+        :rtype: dict
+        """
+        headers = {}
+        username, password = get_auth_from_url(proxy)
+
+        if username:
+            headers['Proxy-Authorization'] = _basic_auth_str(username,
+                                                             password)
+
+        return headers
+
+    def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
+        """Sends PreparedRequest object. Returns Response object.
+
+        :param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
+        :param stream: (optional) Whether to stream the request content.
+        :param timeout: (optional) How long to wait for the server to send
+            data before giving up, as a float, or a :ref:`(connect timeout,
+            read timeout) <timeouts>` tuple.
+        :type timeout: float or tuple or urllib3 Timeout object
+        :param verify: (optional) Either a boolean, in which case it controls whether
+            we verify the server's TLS certificate, or a string, in which case it
+            must be a path to a CA bundle to use
+        :param cert: (optional) Any user-provided SSL certificate to be trusted.
+        :param proxies: (optional) The proxies dictionary to apply to the request.
+        :rtype: requests.Response
+        """
+
+        try:
+            conn = self.get_connection(request.url, proxies)
+        except LocationValueError as e:
+            raise InvalidURL(e, request=request)
+
+        self.cert_verify(conn, request.url, verify, cert)
+        url = self.request_url(request, proxies)
+        self.add_headers(request, stream=stream, timeout=timeout, verify=verify, cert=cert, proxies=proxies)
+
+        chunked = not (request.body is None or 'Content-Length' in request.headers)
+
+        if isinstance(timeout, tuple):
+            try:
+                connect, read = timeout
+                timeout = TimeoutSauce(connect=connect, read=read)
+            except ValueError as e:
+                # this may raise a string formatting error.
+                err = ("Invalid timeout {}. Pass a (connect, read) "
+                       "timeout tuple, or a single float to set "
+                       "both timeouts to the same value".format(timeout))
+                raise ValueError(err)
+        elif isinstance(timeout, TimeoutSauce):
+            pass
+        else:
+            timeout = TimeoutSauce(connect=timeout, read=timeout)
+
+        try:
+            if not chunked:
+                resp = conn.urlopen(
+                    method=request.method,
+                    url=url,
+                    body=request.body,
+                    headers=request.headers,
+                    redirect=False,
+                    assert_same_host=False,
+                    preload_content=False,
+                    decode_content=False,
+                    retries=self.max_retries,
+                    timeout=timeout
+                )
+
+            # Send the request.
+            else:
+                if hasattr(conn, 'proxy_pool'):
+                    conn = conn.proxy_pool
+
+                low_conn = conn._get_conn(timeout=DEFAULT_POOL_TIMEOUT)
+
+                try:
+                    low_conn.putrequest(request.method,
+                                        url,
+                                        skip_accept_encoding=True)
+
+                    for header, value in request.headers.items():
+                        low_conn.putheader(header, value)
+
+                    low_conn.endheaders()
+
+                    for i in request.body:
+                        low_conn.send(hex(len(i))[2:].encode('utf-8'))
+                        low_conn.send(b'\r\n')
+                        low_conn.send(i)
+                        low_conn.send(b'\r\n')
+                    low_conn.send(b'0\r\n\r\n')
+
+                    # Receive the response from the server
+                    try:
+                        # For Python 2.7, use buffering of HTTP responses
+                        r = low_conn.getresponse(buffering=True)
+                    except TypeError:
+                        # For compatibility with Python 3.3+
+                        r = low_conn.getresponse()
+
+                    resp = HTTPResponse.from_httplib(
+                        r,
+                        pool=conn,
+                        connection=low_conn,
+                        preload_content=False,
+                        decode_content=False
+                    )
+                except:
+                    # If we hit any problems here, clean up the connection.
+                    # Then, reraise so that we can handle the actual exception.
+                    low_conn.close()
+                    raise
+
+        except (ProtocolError, socket.error) as err:
+            raise ConnectionError(err, request=request)
+
+        except MaxRetryError as e:
+            if isinstance(e.reason, ConnectTimeoutError):
+                # TODO: Remove this in 3.0.0: see #2811
+                if not isinstance(e.reason, NewConnectionError):
+                    raise ConnectTimeout(e, request=request)
+
+            if isinstance(e.reason, ResponseError):
+                raise RetryError(e, request=request)
+
+            if isinstance(e.reason, _ProxyError):
+                raise ProxyError(e, request=request)
+
+            if isinstance(e.reason, _SSLError):
+                # This branch is for urllib3 v1.22 and later.
+                raise SSLError(e, request=request)
+
+            raise ConnectionError(e, request=request)
+
+        except ClosedPoolError as e:
+            raise ConnectionError(e, request=request)
+
+        except _ProxyError as e:
+            raise ProxyError(e)
+
+        except (_SSLError, _HTTPError) as e:
+            if isinstance(e, _SSLError):
+                # This branch is for urllib3 versions earlier than v1.22
+                raise SSLError(e, request=request)
+            elif isinstance(e, ReadTimeoutError):
+                raise ReadTimeout(e, request=request)
+            else:
+                raise
+
+        return self.build_response(request, resp)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/api.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/api.py
new file mode 100644
index 0000000..e978e20
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/api.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.api
+~~~~~~~~~~~~
+
+This module implements the Requests API.
+
+:copyright: (c) 2012 by Kenneth Reitz.
+:license: Apache2, see LICENSE for more details.
+"""
+
+from . import sessions
+
+
+def request(method, url, **kwargs):
+    """Constructs and sends a :class:`Request <Request>`.
+
+    :param method: method for the new :class:`Request` object: ``GET``, ``OPTIONS``, ``HEAD``, ``POST``, ``PUT``, ``PATCH``, or ``DELETE``.
+    :param url: URL for the new :class:`Request` object.
+    :param params: (optional) Dictionary, list of tuples or bytes to send
+        in the query string for the :class:`Request`.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
+    :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
+    :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.
+    :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.
+    :param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload.
+        ``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')``
+        or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content-type'`` is a string
+        defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers
+        to add for the file.
+    :param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
+    :param timeout: (optional) How many seconds to wait for the server to send data
+        before giving up, as a float, or a :ref:`(connect timeout, read
+        timeout) <timeouts>` tuple.
+    :type timeout: float or tuple
+    :param allow_redirects: (optional) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``.
+    :type allow_redirects: bool
+    :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
+    :param verify: (optional) Either a boolean, in which case it controls whether we verify
+            the server's TLS certificate, or a string, in which case it must be a path
+            to a CA bundle to use. Defaults to ``True``.
+    :param stream: (optional) if ``False``, the response content will be immediately downloaded.
+    :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+
+    Usage::
+
+      >>> import requests
+      >>> req = requests.request('GET', 'https://httpbin.org/get')
+      >>> req
+      <Response [200]>
+    """
+
+    # By using the 'with' statement we are sure the session is closed, thus we
+    # avoid leaving sockets open which can trigger a ResourceWarning in some
+    # cases, and look like a memory leak in others.
+    with sessions.Session() as session:
+        return session.request(method=method, url=url, **kwargs)
+
+
+def get(url, params=None, **kwargs):
+    r"""Sends a GET request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param params: (optional) Dictionary, list of tuples or bytes to send
+        in the query string for the :class:`Request`.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    kwargs.setdefault('allow_redirects', True)
+    return request('get', url, params=params, **kwargs)
+
+
+def options(url, **kwargs):
+    r"""Sends an OPTIONS request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    kwargs.setdefault('allow_redirects', True)
+    return request('options', url, **kwargs)
+
+
+def head(url, **kwargs):
+    r"""Sends a HEAD request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param \*\*kwargs: Optional arguments that ``request`` takes. If
+        `allow_redirects` is not provided, it will be set to `False` (as
+        opposed to the default :meth:`request` behavior).
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    kwargs.setdefault('allow_redirects', False)
+    return request('head', url, **kwargs)
+
+
+def post(url, data=None, json=None, **kwargs):
+    r"""Sends a POST request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
+    :param json: (optional) json data to send in the body of the :class:`Request`.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    return request('post', url, data=data, json=json, **kwargs)
+
+
+def put(url, data=None, **kwargs):
+    r"""Sends a PUT request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
+    :param json: (optional) json data to send in the body of the :class:`Request`.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    return request('put', url, data=data, **kwargs)
+
+
+def patch(url, data=None, **kwargs):
+    r"""Sends a PATCH request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
+    :param json: (optional) json data to send in the body of the :class:`Request`.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    return request('patch', url, data=data, **kwargs)
+
+
+def delete(url, **kwargs):
+    r"""Sends a DELETE request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    return request('delete', url, **kwargs)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/auth.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/auth.py
new file mode 100644
index 0000000..eeface3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/auth.py
@@ -0,0 +1,305 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.auth
+~~~~~~~~~~~~~
+
+This module contains the authentication handlers for Requests.
+"""
+
+import os
+import re
+import time
+import hashlib
+import threading
+import warnings
+
+from base64 import b64encode
+
+from .compat import urlparse, str, basestring
+from .cookies import extract_cookies_to_jar
+from ._internal_utils import to_native_string
+from .utils import parse_dict_header
+
+CONTENT_TYPE_FORM_URLENCODED = 'application/x-www-form-urlencoded'
+CONTENT_TYPE_MULTI_PART = 'multipart/form-data'
+
+
+def _basic_auth_str(username, password):
+    """Returns a Basic Auth string."""
+
+    # "I want us to put a big-ol' comment on top of it that
+    # says that this behaviour is dumb but we need to preserve
+    # it because people are relying on it."
+    #    - Lukasa
+    #
+    # These are here solely to maintain backwards compatibility
+    # for things like ints. This will be removed in 3.0.0.
+    if not isinstance(username, basestring):
+        warnings.warn(
+            "Non-string usernames will no longer be supported in Requests "
+            "3.0.0. Please convert the object you've passed in ({!r}) to "
+            "a string or bytes object in the near future to avoid "
+            "problems.".format(username),
+            category=DeprecationWarning,
+        )
+        username = str(username)
+
+    if not isinstance(password, basestring):
+        warnings.warn(
+            "Non-string passwords will no longer be supported in Requests "
+            "3.0.0. Please convert the object you've passed in ({!r}) to "
+            "a string or bytes object in the near future to avoid "
+            "problems.".format(type(password)),
+            category=DeprecationWarning,
+        )
+        password = str(password)
+    # -- End Removal --
+
+    if isinstance(username, str):
+        username = username.encode('latin1')
+
+    if isinstance(password, str):
+        password = password.encode('latin1')
+
+    authstr = 'Basic ' + to_native_string(
+        b64encode(b':'.join((username, password))).strip()
+    )
+
+    return authstr
+
+
+class AuthBase(object):
+    """Base class that all auth implementations derive from"""
+
+    def __call__(self, r):
+        raise NotImplementedError('Auth hooks must be callable.')
+
+
+class HTTPBasicAuth(AuthBase):
+    """Attaches HTTP Basic Authentication to the given Request object."""
+
+    def __init__(self, username, password):
+        self.username = username
+        self.password = password
+
+    def __eq__(self, other):
+        return all([
+            self.username == getattr(other, 'username', None),
+            self.password == getattr(other, 'password', None)
+        ])
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __call__(self, r):
+        r.headers['Authorization'] = _basic_auth_str(self.username, self.password)
+        return r
+
+
+class HTTPProxyAuth(HTTPBasicAuth):
+    """Attaches HTTP Proxy Authentication to a given Request object."""
+
+    def __call__(self, r):
+        r.headers['Proxy-Authorization'] = _basic_auth_str(self.username, self.password)
+        return r
+
+
+class HTTPDigestAuth(AuthBase):
+    """Attaches HTTP Digest Authentication to the given Request object."""
+
+    def __init__(self, username, password):
+        self.username = username
+        self.password = password
+        # Keep state in per-thread local storage
+        self._thread_local = threading.local()
+
+    def init_per_thread_state(self):
+        # Ensure state is initialized just once per-thread
+        if not hasattr(self._thread_local, 'init'):
+            self._thread_local.init = True
+            self._thread_local.last_nonce = ''
+            self._thread_local.nonce_count = 0
+            self._thread_local.chal = {}
+            self._thread_local.pos = None
+            self._thread_local.num_401_calls = None
+
+    def build_digest_header(self, method, url):
+        """
+        :rtype: str
+        """
+
+        realm = self._thread_local.chal['realm']
+        nonce = self._thread_local.chal['nonce']
+        qop = self._thread_local.chal.get('qop')
+        algorithm = self._thread_local.chal.get('algorithm')
+        opaque = self._thread_local.chal.get('opaque')
+        hash_utf8 = None
+
+        if algorithm is None:
+            _algorithm = 'MD5'
+        else:
+            _algorithm = algorithm.upper()
+        # lambdas assume digest modules are imported at the top level
+        if _algorithm == 'MD5' or _algorithm == 'MD5-SESS':
+            def md5_utf8(x):
+                if isinstance(x, str):
+                    x = x.encode('utf-8')
+                return hashlib.md5(x).hexdigest()
+            hash_utf8 = md5_utf8
+        elif _algorithm == 'SHA':
+            def sha_utf8(x):
+                if isinstance(x, str):
+                    x = x.encode('utf-8')
+                return hashlib.sha1(x).hexdigest()
+            hash_utf8 = sha_utf8
+        elif _algorithm == 'SHA-256':
+            def sha256_utf8(x):
+                if isinstance(x, str):
+                    x = x.encode('utf-8')
+                return hashlib.sha256(x).hexdigest()
+            hash_utf8 = sha256_utf8
+        elif _algorithm == 'SHA-512':
+            def sha512_utf8(x):
+                if isinstance(x, str):
+                    x = x.encode('utf-8')
+                return hashlib.sha512(x).hexdigest()
+            hash_utf8 = sha512_utf8
+
+        KD = lambda s, d: hash_utf8("%s:%s" % (s, d))
+
+        if hash_utf8 is None:
+            return None
+
+        # XXX not implemented yet
+        entdig = None
+        p_parsed = urlparse(url)
+        #: path is request-uri defined in RFC 2616 which should not be empty
+        path = p_parsed.path or "/"
+        if p_parsed.query:
+            path += '?' + p_parsed.query
+
+        A1 = '%s:%s:%s' % (self.username, realm, self.password)
+        A2 = '%s:%s' % (method, path)
+
+        HA1 = hash_utf8(A1)
+        HA2 = hash_utf8(A2)
+
+        if nonce == self._thread_local.last_nonce:
+            self._thread_local.nonce_count += 1
+        else:
+            self._thread_local.nonce_count = 1
+        ncvalue = '%08x' % self._thread_local.nonce_count
+        s = str(self._thread_local.nonce_count).encode('utf-8')
+        s += nonce.encode('utf-8')
+        s += time.ctime().encode('utf-8')
+        s += os.urandom(8)
+
+        cnonce = (hashlib.sha1(s).hexdigest()[:16])
+        if _algorithm == 'MD5-SESS':
+            HA1 = hash_utf8('%s:%s:%s' % (HA1, nonce, cnonce))
+
+        if not qop:
+            respdig = KD(HA1, "%s:%s" % (nonce, HA2))
+        elif qop == 'auth' or 'auth' in qop.split(','):
+            noncebit = "%s:%s:%s:%s:%s" % (
+                nonce, ncvalue, cnonce, 'auth', HA2
+            )
+            respdig = KD(HA1, noncebit)
+        else:
+            # XXX handle auth-int.
+            return None
+
+        self._thread_local.last_nonce = nonce
+
+        # XXX should the partial digests be encoded too?
+        base = 'username="%s", realm="%s", nonce="%s", uri="%s", ' \
+               'response="%s"' % (self.username, realm, nonce, path, respdig)
+        if opaque:
+            base += ', opaque="%s"' % opaque
+        if algorithm:
+            base += ', algorithm="%s"' % algorithm
+        if entdig:
+            base += ', digest="%s"' % entdig
+        if qop:
+            base += ', qop="auth", nc=%s, cnonce="%s"' % (ncvalue, cnonce)
+
+        return 'Digest %s' % (base)
+
+    def handle_redirect(self, r, **kwargs):
+        """Reset num_401_calls counter on redirects."""
+        if r.is_redirect:
+            self._thread_local.num_401_calls = 1
+
+    def handle_401(self, r, **kwargs):
+        """
+        Takes the given response and tries digest-auth, if needed.
+
+        :rtype: requests.Response
+        """
+
+        # If response is not 4xx, do not auth
+        # See https://github.com/psf/requests/issues/3772
+        if not 400 <= r.status_code < 500:
+            self._thread_local.num_401_calls = 1
+            return r
+
+        if self._thread_local.pos is not None:
+            # Rewind the file position indicator of the body to where
+            # it was to resend the request.
+            r.request.body.seek(self._thread_local.pos)
+        s_auth = r.headers.get('www-authenticate', '')
+
+        if 'digest' in s_auth.lower() and self._thread_local.num_401_calls < 2:
+
+            self._thread_local.num_401_calls += 1
+            pat = re.compile(r'digest ', flags=re.IGNORECASE)
+            self._thread_local.chal = parse_dict_header(pat.sub('', s_auth, count=1))
+
+            # Consume content and release the original connection
+            # to allow our new request to reuse the same one.
+            r.content
+            r.close()
+            prep = r.request.copy()
+            extract_cookies_to_jar(prep._cookies, r.request, r.raw)
+            prep.prepare_cookies(prep._cookies)
+
+            prep.headers['Authorization'] = self.build_digest_header(
+                prep.method, prep.url)
+            _r = r.connection.send(prep, **kwargs)
+            _r.history.append(r)
+            _r.request = prep
+
+            return _r
+
+        self._thread_local.num_401_calls = 1
+        return r
+
+    def __call__(self, r):
+        # Initialize per-thread state, if needed
+        self.init_per_thread_state()
+        # If we have a saved nonce, skip the 401
+        if self._thread_local.last_nonce:
+            r.headers['Authorization'] = self.build_digest_header(r.method, r.url)
+        try:
+            self._thread_local.pos = r.body.tell()
+        except AttributeError:
+            # In the case of HTTPDigestAuth being reused and the body of
+            # the previous request was a file-like object, pos has the
+            # file position of the previous body. Ensure it's set to
+            # None.
+            self._thread_local.pos = None
+        r.register_hook('response', self.handle_401)
+        r.register_hook('response', self.handle_redirect)
+        self._thread_local.num_401_calls = 1
+
+        return r
+
+    def __eq__(self, other):
+        return all([
+            self.username == getattr(other, 'username', None),
+            self.password == getattr(other, 'password', None)
+        ])
+
+    def __ne__(self, other):
+        return not self == other
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/certs.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/certs.py
new file mode 100644
index 0000000..06a594e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/certs.py
@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+requests.certs
+~~~~~~~~~~~~~~
+
+This module returns the preferred default CA certificate bundle. There is
+only one — the one from the certifi package.
+
+If you are packaging Requests, e.g., for a Linux distribution or a managed
+environment, you can change the definition of where() to return a separately
+packaged CA bundle.
+"""
+from pip._vendor.certifi import where
+
+if __name__ == '__main__':
+    print(where())
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/compat.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/compat.py
new file mode 100644
index 0000000..9e29371
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/compat.py
@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.compat
+~~~~~~~~~~~~~~~
+
+This module handles import compatibility issues between Python 2 and
+Python 3.
+"""
+
+from pip._vendor import chardet
+
+import sys
+
+# -------
+# Pythons
+# -------
+
+# Syntax sugar.
+_ver = sys.version_info
+
+#: Python 2.x?
+is_py2 = (_ver[0] == 2)
+
+#: Python 3.x?
+is_py3 = (_ver[0] == 3)
+
+# Note: We've patched out simplejson support in pip because it prevents
+#       upgrading simplejson on Windows.
+# try:
+#     import simplejson as json
+# except (ImportError, SyntaxError):
+#     # simplejson does not support Python 3.2, it throws a SyntaxError
+#     # because of u'...' Unicode literals.
+import json
+
+# ---------
+# Specifics
+# ---------
+
+if is_py2:
+    from urllib import (
+        quote, unquote, quote_plus, unquote_plus, urlencode, getproxies,
+        proxy_bypass, proxy_bypass_environment, getproxies_environment)
+    from urlparse import urlparse, urlunparse, urljoin, urlsplit, urldefrag
+    from urllib2 import parse_http_list
+    import cookielib
+    from Cookie import Morsel
+    from StringIO import StringIO
+    # Keep OrderedDict for backwards compatibility.
+    from collections import Callable, Mapping, MutableMapping, OrderedDict
+
+
+    builtin_str = str
+    bytes = str
+    str = unicode
+    basestring = basestring
+    numeric_types = (int, long, float)
+    integer_types = (int, long)
+
+elif is_py3:
+    from urllib.parse import urlparse, urlunparse, urljoin, urlsplit, urlencode, quote, unquote, quote_plus, unquote_plus, urldefrag
+    from urllib.request import parse_http_list, getproxies, proxy_bypass, proxy_bypass_environment, getproxies_environment
+    from http import cookiejar as cookielib
+    from http.cookies import Morsel
+    from io import StringIO
+    # Keep OrderedDict for backwards compatibility.
+    from collections import OrderedDict
+    from collections.abc import Callable, Mapping, MutableMapping
+
+    builtin_str = str
+    str = str
+    bytes = bytes
+    basestring = (str, bytes)
+    numeric_types = (int, float)
+    integer_types = (int,)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/cookies.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/cookies.py
new file mode 100644
index 0000000..56fccd9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/cookies.py
@@ -0,0 +1,549 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.cookies
+~~~~~~~~~~~~~~~~
+
+Compatibility code to be able to use `cookielib.CookieJar` with requests.
+
+requests.utils imports from here, so be careful with imports.
+"""
+
+import copy
+import time
+import calendar
+
+from ._internal_utils import to_native_string
+from .compat import cookielib, urlparse, urlunparse, Morsel, MutableMapping
+
+try:
+    import threading
+except ImportError:
+    import dummy_threading as threading
+
+
+class MockRequest(object):
+    """Wraps a `requests.Request` to mimic a `urllib2.Request`.
+
+    The code in `cookielib.CookieJar` expects this interface in order to correctly
+    manage cookie policies, i.e., determine whether a cookie can be set, given the
+    domains of the request and the cookie.
+
+    The original request object is read-only. The client is responsible for collecting
+    the new headers via `get_new_headers()` and interpreting them appropriately. You
+    probably want `get_cookie_header`, defined below.
+    """
+
+    def __init__(self, request):
+        self._r = request
+        self._new_headers = {}
+        self.type = urlparse(self._r.url).scheme
+
+    def get_type(self):
+        return self.type
+
+    def get_host(self):
+        return urlparse(self._r.url).netloc
+
+    def get_origin_req_host(self):
+        return self.get_host()
+
+    def get_full_url(self):
+        # Only return the response's URL if the user hadn't set the Host
+        # header
+        if not self._r.headers.get('Host'):
+            return self._r.url
+        # If they did set it, retrieve it and reconstruct the expected domain
+        host = to_native_string(self._r.headers['Host'], encoding='utf-8')
+        parsed = urlparse(self._r.url)
+        # Reconstruct the URL as we expect it
+        return urlunparse([
+            parsed.scheme, host, parsed.path, parsed.params, parsed.query,
+            parsed.fragment
+        ])
+
+    def is_unverifiable(self):
+        return True
+
+    def has_header(self, name):
+        return name in self._r.headers or name in self._new_headers
+
+    def get_header(self, name, default=None):
+        return self._r.headers.get(name, self._new_headers.get(name, default))
+
+    def add_header(self, key, val):
+        """cookielib has no legitimate use for this method; add it back if you find one."""
+        raise NotImplementedError("Cookie headers should be added with add_unredirected_header()")
+
+    def add_unredirected_header(self, name, value):
+        self._new_headers[name] = value
+
+    def get_new_headers(self):
+        return self._new_headers
+
+    @property
+    def unverifiable(self):
+        return self.is_unverifiable()
+
+    @property
+    def origin_req_host(self):
+        return self.get_origin_req_host()
+
+    @property
+    def host(self):
+        return self.get_host()
+
+
+class MockResponse(object):
+    """Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`.
+
+    ...what? Basically, expose the parsed HTTP headers from the server response
+    the way `cookielib` expects to see them.
+    """
+
+    def __init__(self, headers):
+        """Make a MockResponse for `cookielib` to read.
+
+        :param headers: a httplib.HTTPMessage or analogous carrying the headers
+        """
+        self._headers = headers
+
+    def info(self):
+        return self._headers
+
+    def getheaders(self, name):
+        self._headers.getheaders(name)
+
+
+def extract_cookies_to_jar(jar, request, response):
+    """Extract the cookies from the response into a CookieJar.
+
+    :param jar: cookielib.CookieJar (not necessarily a RequestsCookieJar)
+    :param request: our own requests.Request object
+    :param response: urllib3.HTTPResponse object
+    """
+    if not (hasattr(response, '_original_response') and
+            response._original_response):
+        return
+    # the _original_response field is the wrapped httplib.HTTPResponse object,
+    req = MockRequest(request)
+    # pull out the HTTPMessage with the headers and put it in the mock:
+    res = MockResponse(response._original_response.msg)
+    jar.extract_cookies(res, req)
+
+
+def get_cookie_header(jar, request):
+    """
+    Produce an appropriate Cookie header string to be sent with `request`, or None.
+
+    :rtype: str
+    """
+    r = MockRequest(request)
+    jar.add_cookie_header(r)
+    return r.get_new_headers().get('Cookie')
+
+
+def remove_cookie_by_name(cookiejar, name, domain=None, path=None):
+    """Unsets a cookie by name, by default over all domains and paths.
+
+    Wraps CookieJar.clear(), is O(n).
+    """
+    clearables = []
+    for cookie in cookiejar:
+        if cookie.name != name:
+            continue
+        if domain is not None and domain != cookie.domain:
+            continue
+        if path is not None and path != cookie.path:
+            continue
+        clearables.append((cookie.domain, cookie.path, cookie.name))
+
+    for domain, path, name in clearables:
+        cookiejar.clear(domain, path, name)
+
+
+class CookieConflictError(RuntimeError):
+    """There are two cookies that meet the criteria specified in the cookie jar.
+    Use .get and .set and include domain and path args in order to be more specific.
+    """
+
+
+class RequestsCookieJar(cookielib.CookieJar, MutableMapping):
+    """Compatibility class; is a cookielib.CookieJar, but exposes a dict
+    interface.
+
+    This is the CookieJar we create by default for requests and sessions that
+    don't specify one, since some clients may expect response.cookies and
+    session.cookies to support dict operations.
+
+    Requests does not use the dict interface internally; it's just for
+    compatibility with external client code. All requests code should work
+    out of the box with externally provided instances of ``CookieJar``, e.g.
+    ``LWPCookieJar`` and ``FileCookieJar``.
+
+    Unlike a regular CookieJar, this class is pickleable.
+
+    .. warning:: dictionary operations that are normally O(1) may be O(n).
+    """
+
+    def get(self, name, default=None, domain=None, path=None):
+        """Dict-like get() that also supports optional domain and path args in
+        order to resolve naming collisions from using one cookie jar over
+        multiple domains.
+
+        .. warning:: operation is O(n), not O(1).
+        """
+        try:
+            return self._find_no_duplicates(name, domain, path)
+        except KeyError:
+            return default
+
+    def set(self, name, value, **kwargs):
+        """Dict-like set() that also supports optional domain and path args in
+        order to resolve naming collisions from using one cookie jar over
+        multiple domains.
+        """
+        # support client code that unsets cookies by assignment of a None value:
+        if value is None:
+            remove_cookie_by_name(self, name, domain=kwargs.get('domain'), path=kwargs.get('path'))
+            return
+
+        if isinstance(value, Morsel):
+            c = morsel_to_cookie(value)
+        else:
+            c = create_cookie(name, value, **kwargs)
+        self.set_cookie(c)
+        return c
+
+    def iterkeys(self):
+        """Dict-like iterkeys() that returns an iterator of names of cookies
+        from the jar.
+
+        .. seealso:: itervalues() and iteritems().
+        """
+        for cookie in iter(self):
+            yield cookie.name
+
+    def keys(self):
+        """Dict-like keys() that returns a list of names of cookies from the
+        jar.
+
+        .. seealso:: values() and items().
+        """
+        return list(self.iterkeys())
+
+    def itervalues(self):
+        """Dict-like itervalues() that returns an iterator of values of cookies
+        from the jar.
+
+        .. seealso:: iterkeys() and iteritems().
+        """
+        for cookie in iter(self):
+            yield cookie.value
+
+    def values(self):
+        """Dict-like values() that returns a list of values of cookies from the
+        jar.
+
+        .. seealso:: keys() and items().
+        """
+        return list(self.itervalues())
+
+    def iteritems(self):
+        """Dict-like iteritems() that returns an iterator of name-value tuples
+        from the jar.
+
+        .. seealso:: iterkeys() and itervalues().
+        """
+        for cookie in iter(self):
+            yield cookie.name, cookie.value
+
+    def items(self):
+        """Dict-like items() that returns a list of name-value tuples from the
+        jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a
+        vanilla python dict of key value pairs.
+
+        .. seealso:: keys() and values().
+        """
+        return list(self.iteritems())
+
+    def list_domains(self):
+        """Utility method to list all the domains in the jar."""
+        domains = []
+        for cookie in iter(self):
+            if cookie.domain not in domains:
+                domains.append(cookie.domain)
+        return domains
+
+    def list_paths(self):
+        """Utility method to list all the paths in the jar."""
+        paths = []
+        for cookie in iter(self):
+            if cookie.path not in paths:
+                paths.append(cookie.path)
+        return paths
+
+    def multiple_domains(self):
+        """Returns True if there are multiple domains in the jar.
+        Returns False otherwise.
+
+        :rtype: bool
+        """
+        domains = []
+        for cookie in iter(self):
+            if cookie.domain is not None and cookie.domain in domains:
+                return True
+            domains.append(cookie.domain)
+        return False  # there is only one domain in jar
+
+    def get_dict(self, domain=None, path=None):
+        """Takes as an argument an optional domain and path and returns a plain
+        old Python dict of name-value pairs of cookies that meet the
+        requirements.
+
+        :rtype: dict
+        """
+        dictionary = {}
+        for cookie in iter(self):
+            if (
+                (domain is None or cookie.domain == domain) and
+                (path is None or cookie.path == path)
+            ):
+                dictionary[cookie.name] = cookie.value
+        return dictionary
+
+    def __contains__(self, name):
+        try:
+            return super(RequestsCookieJar, self).__contains__(name)
+        except CookieConflictError:
+            return True
+
+    def __getitem__(self, name):
+        """Dict-like __getitem__() for compatibility with client code. Throws
+        exception if there are more than one cookie with name. In that case,
+        use the more explicit get() method instead.
+
+        .. warning:: operation is O(n), not O(1).
+        """
+        return self._find_no_duplicates(name)
+
+    def __setitem__(self, name, value):
+        """Dict-like __setitem__ for compatibility with client code. Throws
+        exception if there is already a cookie of that name in the jar. In that
+        case, use the more explicit set() method instead.
+        """
+        self.set(name, value)
+
+    def __delitem__(self, name):
+        """Deletes a cookie given a name. Wraps ``cookielib.CookieJar``'s
+        ``remove_cookie_by_name()``.
+        """
+        remove_cookie_by_name(self, name)
+
+    def set_cookie(self, cookie, *args, **kwargs):
+        if hasattr(cookie.value, 'startswith') and cookie.value.startswith('"') and cookie.value.endswith('"'):
+            cookie.value = cookie.value.replace('\\"', '')
+        return super(RequestsCookieJar, self).set_cookie(cookie, *args, **kwargs)
+
+    def update(self, other):
+        """Updates this jar with cookies from another CookieJar or dict-like"""
+        if isinstance(other, cookielib.CookieJar):
+            for cookie in other:
+                self.set_cookie(copy.copy(cookie))
+        else:
+            super(RequestsCookieJar, self).update(other)
+
+    def _find(self, name, domain=None, path=None):
+        """Requests uses this method internally to get cookie values.
+
+        If there are conflicting cookies, _find arbitrarily chooses one.
+        See _find_no_duplicates if you want an exception thrown if there are
+        conflicting cookies.
+
+        :param name: a string containing name of cookie
+        :param domain: (optional) string containing domain of cookie
+        :param path: (optional) string containing path of cookie
+        :return: cookie.value
+        """
+        for cookie in iter(self):
+            if cookie.name == name:
+                if domain is None or cookie.domain == domain:
+                    if path is None or cookie.path == path:
+                        return cookie.value
+
+        raise KeyError('name=%r, domain=%r, path=%r' % (name, domain, path))
+
+    def _find_no_duplicates(self, name, domain=None, path=None):
+        """Both ``__get_item__`` and ``get`` call this function: it's never
+        used elsewhere in Requests.
+
+        :param name: a string containing name of cookie
+        :param domain: (optional) string containing domain of cookie
+        :param path: (optional) string containing path of cookie
+        :raises KeyError: if cookie is not found
+        :raises CookieConflictError: if there are multiple cookies
+            that match name and optionally domain and path
+        :return: cookie.value
+        """
+        toReturn = None
+        for cookie in iter(self):
+            if cookie.name == name:
+                if domain is None or cookie.domain == domain:
+                    if path is None or cookie.path == path:
+                        if toReturn is not None:  # if there are multiple cookies that meet passed in criteria
+                            raise CookieConflictError('There are multiple cookies with name, %r' % (name))
+                        toReturn = cookie.value  # we will eventually return this as long as no cookie conflict
+
+        if toReturn:
+            return toReturn
+        raise KeyError('name=%r, domain=%r, path=%r' % (name, domain, path))
+
+    def __getstate__(self):
+        """Unlike a normal CookieJar, this class is pickleable."""
+        state = self.__dict__.copy()
+        # remove the unpickleable RLock object
+        state.pop('_cookies_lock')
+        return state
+
+    def __setstate__(self, state):
+        """Unlike a normal CookieJar, this class is pickleable."""
+        self.__dict__.update(state)
+        if '_cookies_lock' not in self.__dict__:
+            self._cookies_lock = threading.RLock()
+
+    def copy(self):
+        """Return a copy of this RequestsCookieJar."""
+        new_cj = RequestsCookieJar()
+        new_cj.set_policy(self.get_policy())
+        new_cj.update(self)
+        return new_cj
+
+    def get_policy(self):
+        """Return the CookiePolicy instance used."""
+        return self._policy
+
+
+def _copy_cookie_jar(jar):
+    if jar is None:
+        return None
+
+    if hasattr(jar, 'copy'):
+        # We're dealing with an instance of RequestsCookieJar
+        return jar.copy()
+    # We're dealing with a generic CookieJar instance
+    new_jar = copy.copy(jar)
+    new_jar.clear()
+    for cookie in jar:
+        new_jar.set_cookie(copy.copy(cookie))
+    return new_jar
+
+
+def create_cookie(name, value, **kwargs):
+    """Make a cookie from underspecified parameters.
+
+    By default, the pair of `name` and `value` will be set for the domain ''
+    and sent on every request (this is sometimes called a "supercookie").
+    """
+    result = {
+        'version': 0,
+        'name': name,
+        'value': value,
+        'port': None,
+        'domain': '',
+        'path': '/',
+        'secure': False,
+        'expires': None,
+        'discard': True,
+        'comment': None,
+        'comment_url': None,
+        'rest': {'HttpOnly': None},
+        'rfc2109': False,
+    }
+
+    badargs = set(kwargs) - set(result)
+    if badargs:
+        err = 'create_cookie() got unexpected keyword arguments: %s'
+        raise TypeError(err % list(badargs))
+
+    result.update(kwargs)
+    result['port_specified'] = bool(result['port'])
+    result['domain_specified'] = bool(result['domain'])
+    result['domain_initial_dot'] = result['domain'].startswith('.')
+    result['path_specified'] = bool(result['path'])
+
+    return cookielib.Cookie(**result)
+
+
+def morsel_to_cookie(morsel):
+    """Convert a Morsel object into a Cookie containing the one k/v pair."""
+
+    expires = None
+    if morsel['max-age']:
+        try:
+            expires = int(time.time() + int(morsel['max-age']))
+        except ValueError:
+            raise TypeError('max-age: %s must be integer' % morsel['max-age'])
+    elif morsel['expires']:
+        time_template = '%a, %d-%b-%Y %H:%M:%S GMT'
+        expires = calendar.timegm(
+            time.strptime(morsel['expires'], time_template)
+        )
+    return create_cookie(
+        comment=morsel['comment'],
+        comment_url=bool(morsel['comment']),
+        discard=False,
+        domain=morsel['domain'],
+        expires=expires,
+        name=morsel.key,
+        path=morsel['path'],
+        port=None,
+        rest={'HttpOnly': morsel['httponly']},
+        rfc2109=False,
+        secure=bool(morsel['secure']),
+        value=morsel.value,
+        version=morsel['version'] or 0,
+    )
+
+
+def cookiejar_from_dict(cookie_dict, cookiejar=None, overwrite=True):
+    """Returns a CookieJar from a key/value dictionary.
+
+    :param cookie_dict: Dict of key/values to insert into CookieJar.
+    :param cookiejar: (optional) A cookiejar to add the cookies to.
+    :param overwrite: (optional) If False, will not replace cookies
+        already in the jar with new ones.
+    :rtype: CookieJar
+    """
+    if cookiejar is None:
+        cookiejar = RequestsCookieJar()
+
+    if cookie_dict is not None:
+        names_from_jar = [cookie.name for cookie in cookiejar]
+        for name in cookie_dict:
+            if overwrite or (name not in names_from_jar):
+                cookiejar.set_cookie(create_cookie(name, cookie_dict[name]))
+
+    return cookiejar
+
+
+def merge_cookies(cookiejar, cookies):
+    """Add cookies to cookiejar and returns a merged CookieJar.
+
+    :param cookiejar: CookieJar object to add the cookies to.
+    :param cookies: Dictionary or CookieJar object to be added.
+    :rtype: CookieJar
+    """
+    if not isinstance(cookiejar, cookielib.CookieJar):
+        raise ValueError('You can only merge into CookieJar')
+
+    if isinstance(cookies, dict):
+        cookiejar = cookiejar_from_dict(
+            cookies, cookiejar=cookiejar, overwrite=False)
+    elif isinstance(cookies, cookielib.CookieJar):
+        try:
+            cookiejar.update(cookies)
+        except AttributeError:
+            for cookie_in_jar in cookies:
+                cookiejar.set_cookie(cookie_in_jar)
+
+    return cookiejar
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/exceptions.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/exceptions.py
new file mode 100644
index 0000000..9ef9e6e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/exceptions.py
@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.exceptions
+~~~~~~~~~~~~~~~~~~~
+
+This module contains the set of Requests' exceptions.
+"""
+from pip._vendor.urllib3.exceptions import HTTPError as BaseHTTPError
+
+
+class RequestException(IOError):
+    """There was an ambiguous exception that occurred while handling your
+    request.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Initialize RequestException with `request` and `response` objects."""
+        response = kwargs.pop('response', None)
+        self.response = response
+        self.request = kwargs.pop('request', None)
+        if (response is not None and not self.request and
+                hasattr(response, 'request')):
+            self.request = self.response.request
+        super(RequestException, self).__init__(*args, **kwargs)
+
+
+class HTTPError(RequestException):
+    """An HTTP error occurred."""
+
+
+class ConnectionError(RequestException):
+    """A Connection error occurred."""
+
+
+class ProxyError(ConnectionError):
+    """A proxy error occurred."""
+
+
+class SSLError(ConnectionError):
+    """An SSL error occurred."""
+
+
+class Timeout(RequestException):
+    """The request timed out.
+
+    Catching this error will catch both
+    :exc:`~requests.exceptions.ConnectTimeout` and
+    :exc:`~requests.exceptions.ReadTimeout` errors.
+    """
+
+
+class ConnectTimeout(ConnectionError, Timeout):
+    """The request timed out while trying to connect to the remote server.
+
+    Requests that produced this error are safe to retry.
+    """
+
+
+class ReadTimeout(Timeout):
+    """The server did not send any data in the allotted amount of time."""
+
+
+class URLRequired(RequestException):
+    """A valid URL is required to make a request."""
+
+
+class TooManyRedirects(RequestException):
+    """Too many redirects."""
+
+
+class MissingSchema(RequestException, ValueError):
+    """The URL schema (e.g. http or https) is missing."""
+
+
+class InvalidSchema(RequestException, ValueError):
+    """See defaults.py for valid schemas."""
+
+
+class InvalidURL(RequestException, ValueError):
+    """The URL provided was somehow invalid."""
+
+
+class InvalidHeader(RequestException, ValueError):
+    """The header value provided was somehow invalid."""
+
+
+class InvalidProxyURL(InvalidURL):
+    """The proxy URL provided is invalid."""
+
+
+class ChunkedEncodingError(RequestException):
+    """The server declared chunked encoding but sent an invalid chunk."""
+
+
+class ContentDecodingError(RequestException, BaseHTTPError):
+    """Failed to decode response content."""
+
+
+class StreamConsumedError(RequestException, TypeError):
+    """The content for this response was already consumed."""
+
+
+class RetryError(RequestException):
+    """Custom retries logic failed"""
+
+
+class UnrewindableBodyError(RequestException):
+    """Requests encountered an error when trying to rewind a body."""
+
+# Warnings
+
+
+class RequestsWarning(Warning):
+    """Base warning for Requests."""
+
+
+class FileModeWarning(RequestsWarning, DeprecationWarning):
+    """A file was opened in text mode, but Requests determined its binary length."""
+
+
+class RequestsDependencyWarning(RequestsWarning):
+    """An imported dependency doesn't match the expected version range."""
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/help.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/help.py
new file mode 100644
index 0000000..3c3072b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/help.py
@@ -0,0 +1,119 @@
+"""Module containing bug report helper(s)."""
+from __future__ import print_function
+
+import json
+import platform
+import sys
+import ssl
+
+from pip._vendor import idna
+from pip._vendor import urllib3
+from pip._vendor import chardet
+
+from . import __version__ as requests_version
+
+try:
+    from pip._vendor.urllib3.contrib import pyopenssl
+except ImportError:
+    pyopenssl = None
+    OpenSSL = None
+    cryptography = None
+else:
+    import OpenSSL
+    import cryptography
+
+
+def _implementation():
+    """Return a dict with the Python implementation and version.
+
+    Provide both the name and the version of the Python implementation
+    currently running. For example, on CPython 2.7.5 it will return
+    {'name': 'CPython', 'version': '2.7.5'}.
+
+    This function works best on CPython and PyPy: in particular, it probably
+    doesn't work for Jython or IronPython. Future investigation should be done
+    to work out the correct shape of the code for those platforms.
+    """
+    implementation = platform.python_implementation()
+
+    if implementation == 'CPython':
+        implementation_version = platform.python_version()
+    elif implementation == 'PyPy':
+        implementation_version = '%s.%s.%s' % (sys.pypy_version_info.major,
+                                               sys.pypy_version_info.minor,
+                                               sys.pypy_version_info.micro)
+        if sys.pypy_version_info.releaselevel != 'final':
+            implementation_version = ''.join([
+                implementation_version, sys.pypy_version_info.releaselevel
+            ])
+    elif implementation == 'Jython':
+        implementation_version = platform.python_version()  # Complete Guess
+    elif implementation == 'IronPython':
+        implementation_version = platform.python_version()  # Complete Guess
+    else:
+        implementation_version = 'Unknown'
+
+    return {'name': implementation, 'version': implementation_version}
+
+
+def info():
+    """Generate information for a bug report."""
+    try:
+        platform_info = {
+            'system': platform.system(),
+            'release': platform.release(),
+        }
+    except IOError:
+        platform_info = {
+            'system': 'Unknown',
+            'release': 'Unknown',
+        }
+
+    implementation_info = _implementation()
+    urllib3_info = {'version': urllib3.__version__}
+    chardet_info = {'version': chardet.__version__}
+
+    pyopenssl_info = {
+        'version': None,
+        'openssl_version': '',
+    }
+    if OpenSSL:
+        pyopenssl_info = {
+            'version': OpenSSL.__version__,
+            'openssl_version': '%x' % OpenSSL.SSL.OPENSSL_VERSION_NUMBER,
+        }
+    cryptography_info = {
+        'version': getattr(cryptography, '__version__', ''),
+    }
+    idna_info = {
+        'version': getattr(idna, '__version__', ''),
+    }
+
+    system_ssl = ssl.OPENSSL_VERSION_NUMBER
+    system_ssl_info = {
+        'version': '%x' % system_ssl if system_ssl is not None else ''
+    }
+
+    return {
+        'platform': platform_info,
+        'implementation': implementation_info,
+        'system_ssl': system_ssl_info,
+        'using_pyopenssl': pyopenssl is not None,
+        'pyOpenSSL': pyopenssl_info,
+        'urllib3': urllib3_info,
+        'chardet': chardet_info,
+        'cryptography': cryptography_info,
+        'idna': idna_info,
+        'requests': {
+            'version': requests_version,
+        },
+    }
+
+
+def main():
+    """Pretty-print the bug information as JSON."""
+    print(json.dumps(info(), sort_keys=True, indent=2))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/hooks.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/hooks.py
new file mode 100644
index 0000000..7a51f21
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/hooks.py
@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.hooks
+~~~~~~~~~~~~~~
+
+This module provides the capabilities for the Requests hooks system.
+
+Available hooks:
+
+``response``:
+    The response generated from a Request.
+"""
+HOOKS = ['response']
+
+
+def default_hooks():
+    return {event: [] for event in HOOKS}
+
+# TODO: response is the only one
+
+
+def dispatch_hook(key, hooks, hook_data, **kwargs):
+    """Dispatches a hook dictionary on a given piece of data."""
+    hooks = hooks or {}
+    hooks = hooks.get(key)
+    if hooks:
+        if hasattr(hooks, '__call__'):
+            hooks = [hooks]
+        for hook in hooks:
+            _hook_data = hook(hook_data, **kwargs)
+            if _hook_data is not None:
+                hook_data = _hook_data
+    return hook_data
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/models.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/models.py
new file mode 100644
index 0000000..015e715
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/models.py
@@ -0,0 +1,954 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.models
+~~~~~~~~~~~~~~~
+
+This module contains the primary objects that power Requests.
+"""
+
+import datetime
+import sys
+
+# Import encoding now, to avoid implicit import later.
+# Implicit import within threads may cause LookupError when standard library is in a ZIP,
+# such as in Embedded Python. See https://github.com/psf/requests/issues/3578.
+import encodings.idna
+
+from pip._vendor.urllib3.fields import RequestField
+from pip._vendor.urllib3.filepost import encode_multipart_formdata
+from pip._vendor.urllib3.util import parse_url
+from pip._vendor.urllib3.exceptions import (
+    DecodeError, ReadTimeoutError, ProtocolError, LocationParseError)
+
+from io import UnsupportedOperation
+from .hooks import default_hooks
+from .structures import CaseInsensitiveDict
+
+from .auth import HTTPBasicAuth
+from .cookies import cookiejar_from_dict, get_cookie_header, _copy_cookie_jar
+from .exceptions import (
+    HTTPError, MissingSchema, InvalidURL, ChunkedEncodingError,
+    ContentDecodingError, ConnectionError, StreamConsumedError)
+from ._internal_utils import to_native_string, unicode_is_ascii
+from .utils import (
+    guess_filename, get_auth_from_url, requote_uri,
+    stream_decode_response_unicode, to_key_val_list, parse_header_links,
+    iter_slices, guess_json_utf, super_len, check_header_validity)
+from .compat import (
+    Callable, Mapping,
+    cookielib, urlunparse, urlsplit, urlencode, str, bytes,
+    is_py2, chardet, builtin_str, basestring)
+from .compat import json as complexjson
+from .status_codes import codes
+
+#: The set of HTTP status codes that indicate an automatically
+#: processable redirect.
+REDIRECT_STATI = (
+    codes.moved,               # 301
+    codes.found,               # 302
+    codes.other,               # 303
+    codes.temporary_redirect,  # 307
+    codes.permanent_redirect,  # 308
+)
+
+DEFAULT_REDIRECT_LIMIT = 30
+CONTENT_CHUNK_SIZE = 10 * 1024
+ITER_CHUNK_SIZE = 512
+
+
+class RequestEncodingMixin(object):
+    @property
+    def path_url(self):
+        """Build the path URL to use."""
+
+        url = []
+
+        p = urlsplit(self.url)
+
+        path = p.path
+        if not path:
+            path = '/'
+
+        url.append(path)
+
+        query = p.query
+        if query:
+            url.append('?')
+            url.append(query)
+
+        return ''.join(url)
+
+    @staticmethod
+    def _encode_params(data):
+        """Encode parameters in a piece of data.
+
+        Will successfully encode parameters when passed as a dict or a list of
+        2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
+        if parameters are supplied as a dict.
+        """
+
+        if isinstance(data, (str, bytes)):
+            return data
+        elif hasattr(data, 'read'):
+            return data
+        elif hasattr(data, '__iter__'):
+            result = []
+            for k, vs in to_key_val_list(data):
+                if isinstance(vs, basestring) or not hasattr(vs, '__iter__'):
+                    vs = [vs]
+                for v in vs:
+                    if v is not None:
+                        result.append(
+                            (k.encode('utf-8') if isinstance(k, str) else k,
+                             v.encode('utf-8') if isinstance(v, str) else v))
+            return urlencode(result, doseq=True)
+        else:
+            return data
+
+    @staticmethod
+    def _encode_files(files, data):
+        """Build the body for a multipart/form-data request.
+
+        Will successfully encode files when passed as a dict or a list of
+        tuples. Order is retained if data is a list of tuples but arbitrary
+        if parameters are supplied as a dict.
+        The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
+        or 4-tuples (filename, fileobj, contentype, custom_headers).
+        """
+        if (not files):
+            raise ValueError("Files must be provided.")
+        elif isinstance(data, basestring):
+            raise ValueError("Data must not be a string.")
+
+        new_fields = []
+        fields = to_key_val_list(data or {})
+        files = to_key_val_list(files or {})
+
+        for field, val in fields:
+            if isinstance(val, basestring) or not hasattr(val, '__iter__'):
+                val = [val]
+            for v in val:
+                if v is not None:
+                    # Don't call str() on bytestrings: in Py3 it all goes wrong.
+                    if not isinstance(v, bytes):
+                        v = str(v)
+
+                    new_fields.append(
+                        (field.decode('utf-8') if isinstance(field, bytes) else field,
+                         v.encode('utf-8') if isinstance(v, str) else v))
+
+        for (k, v) in files:
+            # support for explicit filename
+            ft = None
+            fh = None
+            if isinstance(v, (tuple, list)):
+                if len(v) == 2:
+                    fn, fp = v
+                elif len(v) == 3:
+                    fn, fp, ft = v
+                else:
+                    fn, fp, ft, fh = v
+            else:
+                fn = guess_filename(v) or k
+                fp = v
+
+            if isinstance(fp, (str, bytes, bytearray)):
+                fdata = fp
+            elif hasattr(fp, 'read'):
+                fdata = fp.read()
+            elif fp is None:
+                continue
+            else:
+                fdata = fp
+
+            rf = RequestField(name=k, data=fdata, filename=fn, headers=fh)
+            rf.make_multipart(content_type=ft)
+            new_fields.append(rf)
+
+        body, content_type = encode_multipart_formdata(new_fields)
+
+        return body, content_type
+
+
+class RequestHooksMixin(object):
+    def register_hook(self, event, hook):
+        """Properly register a hook."""
+
+        if event not in self.hooks:
+            raise ValueError('Unsupported event specified, with event name "%s"' % (event))
+
+        if isinstance(hook, Callable):
+            self.hooks[event].append(hook)
+        elif hasattr(hook, '__iter__'):
+            self.hooks[event].extend(h for h in hook if isinstance(h, Callable))
+
+    def deregister_hook(self, event, hook):
+        """Deregister a previously registered hook.
+        Returns True if the hook existed, False if not.
+        """
+
+        try:
+            self.hooks[event].remove(hook)
+            return True
+        except ValueError:
+            return False
+
+
+class Request(RequestHooksMixin):
+    """A user-created :class:`Request <Request>` object.
+
+    Used to prepare a :class:`PreparedRequest <PreparedRequest>`, which is sent to the server.
+
+    :param method: HTTP method to use.
+    :param url: URL to send.
+    :param headers: dictionary of headers to send.
+    :param files: dictionary of {filename: fileobject} files to multipart upload.
+    :param data: the body to attach to the request. If a dictionary or
+        list of tuples ``[(key, value)]`` is provided, form-encoding will
+        take place.
+    :param json: json for the body to attach to the request (if files or data is not specified).
+    :param params: URL parameters to append to the URL. If a dictionary or
+        list of tuples ``[(key, value)]`` is provided, form-encoding will
+        take place.
+    :param auth: Auth handler or (user, pass) tuple.
+    :param cookies: dictionary or CookieJar of cookies to attach to this request.
+    :param hooks: dictionary of callback hooks, for internal usage.
+
+    Usage::
+
+      >>> import requests
+      >>> req = requests.Request('GET', 'https://httpbin.org/get')
+      >>> req.prepare()
+      <PreparedRequest [GET]>
+    """
+
+    def __init__(self,
+            method=None, url=None, headers=None, files=None, data=None,
+            params=None, auth=None, cookies=None, hooks=None, json=None):
+
+        # Default empty dicts for dict params.
+        data = [] if data is None else data
+        files = [] if files is None else files
+        headers = {} if headers is None else headers
+        params = {} if params is None else params
+        hooks = {} if hooks is None else hooks
+
+        self.hooks = default_hooks()
+        for (k, v) in list(hooks.items()):
+            self.register_hook(event=k, hook=v)
+
+        self.method = method
+        self.url = url
+        self.headers = headers
+        self.files = files
+        self.data = data
+        self.json = json
+        self.params = params
+        self.auth = auth
+        self.cookies = cookies
+
+    def __repr__(self):
+        return '<Request [%s]>' % (self.method)
+
+    def prepare(self):
+        """Constructs a :class:`PreparedRequest <PreparedRequest>` for transmission and returns it."""
+        p = PreparedRequest()
+        p.prepare(
+            method=self.method,
+            url=self.url,
+            headers=self.headers,
+            files=self.files,
+            data=self.data,
+            json=self.json,
+            params=self.params,
+            auth=self.auth,
+            cookies=self.cookies,
+            hooks=self.hooks,
+        )
+        return p
+
+
+class PreparedRequest(RequestEncodingMixin, RequestHooksMixin):
+    """The fully mutable :class:`PreparedRequest <PreparedRequest>` object,
+    containing the exact bytes that will be sent to the server.
+
+    Generated from either a :class:`Request <Request>` object or manually.
+
+    Usage::
+
+      >>> import requests
+      >>> req = requests.Request('GET', 'https://httpbin.org/get')
+      >>> r = req.prepare()
+      >>> r
+      <PreparedRequest [GET]>
+
+      >>> s = requests.Session()
+      >>> s.send(r)
+      <Response [200]>
+    """
+
+    def __init__(self):
+        #: HTTP verb to send to the server.
+        self.method = None
+        #: HTTP URL to send the request to.
+        self.url = None
+        #: dictionary of HTTP headers.
+        self.headers = None
+        # The `CookieJar` used to create the Cookie header will be stored here
+        # after prepare_cookies is called
+        self._cookies = None
+        #: request body to send to the server.
+        self.body = None
+        #: dictionary of callback hooks, for internal usage.
+        self.hooks = default_hooks()
+        #: integer denoting starting position of a readable file-like body.
+        self._body_position = None
+
+    def prepare(self,
+            method=None, url=None, headers=None, files=None, data=None,
+            params=None, auth=None, cookies=None, hooks=None, json=None):
+        """Prepares the entire request with the given parameters."""
+
+        self.prepare_method(method)
+        self.prepare_url(url, params)
+        self.prepare_headers(headers)
+        self.prepare_cookies(cookies)
+        self.prepare_body(data, files, json)
+        self.prepare_auth(auth, url)
+
+        # Note that prepare_auth must be last to enable authentication schemes
+        # such as OAuth to work on a fully prepared request.
+
+        # This MUST go after prepare_auth. Authenticators could add a hook
+        self.prepare_hooks(hooks)
+
+    def __repr__(self):
+        return '<PreparedRequest [%s]>' % (self.method)
+
+    def copy(self):
+        p = PreparedRequest()
+        p.method = self.method
+        p.url = self.url
+        p.headers = self.headers.copy() if self.headers is not None else None
+        p._cookies = _copy_cookie_jar(self._cookies)
+        p.body = self.body
+        p.hooks = self.hooks
+        p._body_position = self._body_position
+        return p
+
+    def prepare_method(self, method):
+        """Prepares the given HTTP method."""
+        self.method = method
+        if self.method is not None:
+            self.method = to_native_string(self.method.upper())
+
+    @staticmethod
+    def _get_idna_encoded_host(host):
+        from pip._vendor import idna
+
+        try:
+            host = idna.encode(host, uts46=True).decode('utf-8')
+        except idna.IDNAError:
+            raise UnicodeError
+        return host
+
+    def prepare_url(self, url, params):
+        """Prepares the given HTTP URL."""
+        #: Accept objects that have string representations.
+        #: We're unable to blindly call unicode/str functions
+        #: as this will include the bytestring indicator (b'')
+        #: on python 3.x.
+        #: https://github.com/psf/requests/pull/2238
+        if isinstance(url, bytes):
+            url = url.decode('utf8')
+        else:
+            url = unicode(url) if is_py2 else str(url)
+
+        # Remove leading whitespaces from url
+        url = url.lstrip()
+
+        # Don't do any URL preparation for non-HTTP schemes like `mailto`,
+        # `data` etc to work around exceptions from `url_parse`, which
+        # handles RFC 3986 only.
+        if ':' in url and not url.lower().startswith('http'):
+            self.url = url
+            return
+
+        # Support for unicode domain names and paths.
+        try:
+            scheme, auth, host, port, path, query, fragment = parse_url(url)
+        except LocationParseError as e:
+            raise InvalidURL(*e.args)
+
+        if not scheme:
+            error = ("Invalid URL {0!r}: No schema supplied. Perhaps you meant http://{0}?")
+            error = error.format(to_native_string(url, 'utf8'))
+
+            raise MissingSchema(error)
+
+        if not host:
+            raise InvalidURL("Invalid URL %r: No host supplied" % url)
+
+        # In general, we want to try IDNA encoding the hostname if the string contains
+        # non-ASCII characters. This allows users to automatically get the correct IDNA
+        # behaviour. For strings containing only ASCII characters, we need to also verify
+        # it doesn't start with a wildcard (*), before allowing the unencoded hostname.
+        if not unicode_is_ascii(host):
+            try:
+                host = self._get_idna_encoded_host(host)
+            except UnicodeError:
+                raise InvalidURL('URL has an invalid label.')
+        elif host.startswith(u'*'):
+            raise InvalidURL('URL has an invalid label.')
+
+        # Carefully reconstruct the network location
+        netloc = auth or ''
+        if netloc:
+            netloc += '@'
+        netloc += host
+        if port:
+            netloc += ':' + str(port)
+
+        # Bare domains aren't valid URLs.
+        if not path:
+            path = '/'
+
+        if is_py2:
+            if isinstance(scheme, str):
+                scheme = scheme.encode('utf-8')
+            if isinstance(netloc, str):
+                netloc = netloc.encode('utf-8')
+            if isinstance(path, str):
+                path = path.encode('utf-8')
+            if isinstance(query, str):
+                query = query.encode('utf-8')
+            if isinstance(fragment, str):
+                fragment = fragment.encode('utf-8')
+
+        if isinstance(params, (str, bytes)):
+            params = to_native_string(params)
+
+        enc_params = self._encode_params(params)
+        if enc_params:
+            if query:
+                query = '%s&%s' % (query, enc_params)
+            else:
+                query = enc_params
+
+        url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
+        self.url = url
+
+    def prepare_headers(self, headers):
+        """Prepares the given HTTP headers."""
+
+        self.headers = CaseInsensitiveDict()
+        if headers:
+            for header in headers.items():
+                # Raise exception on invalid header value.
+                check_header_validity(header)
+                name, value = header
+                self.headers[to_native_string(name)] = value
+
+    def prepare_body(self, data, files, json=None):
+        """Prepares the given HTTP body data."""
+
+        # Check if file, fo, generator, iterator.
+        # If not, run through normal process.
+
+        # Nottin' on you.
+        body = None
+        content_type = None
+
+        if not data and json is not None:
+            # urllib3 requires a bytes-like body. Python 2's json.dumps
+            # provides this natively, but Python 3 gives a Unicode string.
+            content_type = 'application/json'
+            body = complexjson.dumps(json)
+            if not isinstance(body, bytes):
+                body = body.encode('utf-8')
+
+        is_stream = all([
+            hasattr(data, '__iter__'),
+            not isinstance(data, (basestring, list, tuple, Mapping))
+        ])
+
+        if is_stream:
+            try:
+                length = super_len(data)
+            except (TypeError, AttributeError, UnsupportedOperation):
+                length = None
+
+            body = data
+
+            if getattr(body, 'tell', None) is not None:
+                # Record the current file position before reading.
+                # This will allow us to rewind a file in the event
+                # of a redirect.
+                try:
+                    self._body_position = body.tell()
+                except (IOError, OSError):
+                    # This differentiates from None, allowing us to catch
+                    # a failed `tell()` later when trying to rewind the body
+                    self._body_position = object()
+
+            if files:
+                raise NotImplementedError('Streamed bodies and files are mutually exclusive.')
+
+            if length:
+                self.headers['Content-Length'] = builtin_str(length)
+            else:
+                self.headers['Transfer-Encoding'] = 'chunked'
+        else:
+            # Multi-part file uploads.
+            if files:
+                (body, content_type) = self._encode_files(files, data)
+            else:
+                if data:
+                    body = self._encode_params(data)
+                    if isinstance(data, basestring) or hasattr(data, 'read'):
+                        content_type = None
+                    else:
+                        content_type = 'application/x-www-form-urlencoded'
+
+            self.prepare_content_length(body)
+
+            # Add content-type if it wasn't explicitly provided.
+            if content_type and ('content-type' not in self.headers):
+                self.headers['Content-Type'] = content_type
+
+        self.body = body
+
+    def prepare_content_length(self, body):
+        """Prepare Content-Length header based on request method and body"""
+        if body is not None:
+            length = super_len(body)
+            if length:
+                # If length exists, set it. Otherwise, we fallback
+                # to Transfer-Encoding: chunked.
+                self.headers['Content-Length'] = builtin_str(length)
+        elif self.method not in ('GET', 'HEAD') and self.headers.get('Content-Length') is None:
+            # Set Content-Length to 0 for methods that can have a body
+            # but don't provide one. (i.e. not GET or HEAD)
+            self.headers['Content-Length'] = '0'
+
+    def prepare_auth(self, auth, url=''):
+        """Prepares the given HTTP auth data."""
+
+        # If no Auth is explicitly provided, extract it from the URL first.
+        if auth is None:
+            url_auth = get_auth_from_url(self.url)
+            auth = url_auth if any(url_auth) else None
+
+        if auth:
+            if isinstance(auth, tuple) and len(auth) == 2:
+                # special-case basic HTTP auth
+                auth = HTTPBasicAuth(*auth)
+
+            # Allow auth to make its changes.
+            r = auth(self)
+
+            # Update self to reflect the auth changes.
+            self.__dict__.update(r.__dict__)
+
+            # Recompute Content-Length
+            self.prepare_content_length(self.body)
+
+    def prepare_cookies(self, cookies):
+        """Prepares the given HTTP cookie data.
+
+        This function eventually generates a ``Cookie`` header from the
+        given cookies using cookielib. Due to cookielib's design, the header
+        will not be regenerated if it already exists, meaning this function
+        can only be called once for the life of the
+        :class:`PreparedRequest <PreparedRequest>` object. Any subsequent calls
+        to ``prepare_cookies`` will have no actual effect, unless the "Cookie"
+        header is removed beforehand.
+        """
+        if isinstance(cookies, cookielib.CookieJar):
+            self._cookies = cookies
+        else:
+            self._cookies = cookiejar_from_dict(cookies)
+
+        cookie_header = get_cookie_header(self._cookies, self)
+        if cookie_header is not None:
+            self.headers['Cookie'] = cookie_header
+
+    def prepare_hooks(self, hooks):
+        """Prepares the given hooks."""
+        # hooks can be passed as None to the prepare method and to this
+        # method. To prevent iterating over None, simply use an empty list
+        # if hooks is False-y
+        hooks = hooks or []
+        for event in hooks:
+            self.register_hook(event, hooks[event])
+
+
+class Response(object):
+    """The :class:`Response <Response>` object, which contains a
+    server's response to an HTTP request.
+    """
+
+    __attrs__ = [
+        '_content', 'status_code', 'headers', 'url', 'history',
+        'encoding', 'reason', 'cookies', 'elapsed', 'request'
+    ]
+
+    def __init__(self):
+        self._content = False
+        self._content_consumed = False
+        self._next = None
+
+        #: Integer Code of responded HTTP Status, e.g. 404 or 200.
+        self.status_code = None
+
+        #: Case-insensitive Dictionary of Response Headers.
+        #: For example, ``headers['content-encoding']`` will return the
+        #: value of a ``'Content-Encoding'`` response header.
+        self.headers = CaseInsensitiveDict()
+
+        #: File-like object representation of response (for advanced usage).
+        #: Use of ``raw`` requires that ``stream=True`` be set on the request.
+        #: This requirement does not apply for use internally to Requests.
+        self.raw = None
+
+        #: Final URL location of Response.
+        self.url = None
+
+        #: Encoding to decode with when accessing r.text.
+        self.encoding = None
+
+        #: A list of :class:`Response <Response>` objects from
+        #: the history of the Request. Any redirect responses will end
+        #: up here. The list is sorted from the oldest to the most recent request.
+        self.history = []
+
+        #: Textual reason of responded HTTP Status, e.g. "Not Found" or "OK".
+        self.reason = None
+
+        #: A CookieJar of Cookies the server sent back.
+        self.cookies = cookiejar_from_dict({})
+
+        #: The amount of time elapsed between sending the request
+        #: and the arrival of the response (as a timedelta).
+        #: This property specifically measures the time taken between sending
+        #: the first byte of the request and finishing parsing the headers. It
+        #: is therefore unaffected by consuming the response content or the
+        #: value of the ``stream`` keyword argument.
+        self.elapsed = datetime.timedelta(0)
+
+        #: The :class:`PreparedRequest <PreparedRequest>` object to which this
+        #: is a response.
+        self.request = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def __getstate__(self):
+        # Consume everything; accessing the content attribute makes
+        # sure the content has been fully read.
+        if not self._content_consumed:
+            self.content
+
+        return {attr: getattr(self, attr, None) for attr in self.__attrs__}
+
+    def __setstate__(self, state):
+        for name, value in state.items():
+            setattr(self, name, value)
+
+        # pickled objects do not have .raw
+        setattr(self, '_content_consumed', True)
+        setattr(self, 'raw', None)
+
+    def __repr__(self):
+        return '<Response [%s]>' % (self.status_code)
+
+    def __bool__(self):
+        """Returns True if :attr:`status_code` is less than 400.
+
+        This attribute checks if the status code of the response is between
+        400 and 600 to see if there was a client error or a server error. If
+        the status code, is between 200 and 400, this will return True. This
+        is **not** a check to see if the response code is ``200 OK``.
+        """
+        return self.ok
+
+    def __nonzero__(self):
+        """Returns True if :attr:`status_code` is less than 400.
+
+        This attribute checks if the status code of the response is between
+        400 and 600 to see if there was a client error or a server error. If
+        the status code, is between 200 and 400, this will return True. This
+        is **not** a check to see if the response code is ``200 OK``.
+        """
+        return self.ok
+
+    def __iter__(self):
+        """Allows you to use a response as an iterator."""
+        return self.iter_content(128)
+
+    @property
+    def ok(self):
+        """Returns True if :attr:`status_code` is less than 400, False if not.
+
+        This attribute checks if the status code of the response is between
+        400 and 600 to see if there was a client error or a server error. If
+        the status code is between 200 and 400, this will return True. This
+        is **not** a check to see if the response code is ``200 OK``.
+        """
+        try:
+            self.raise_for_status()
+        except HTTPError:
+            return False
+        return True
+
+    @property
+    def is_redirect(self):
+        """True if this Response is a well-formed HTTP redirect that could have
+        been processed automatically (by :meth:`Session.resolve_redirects`).
+        """
+        return ('location' in self.headers and self.status_code in REDIRECT_STATI)
+
+    @property
+    def is_permanent_redirect(self):
+        """True if this Response one of the permanent versions of redirect."""
+        return ('location' in self.headers and self.status_code in (codes.moved_permanently, codes.permanent_redirect))
+
+    @property
+    def next(self):
+        """Returns a PreparedRequest for the next request in a redirect chain, if there is one."""
+        return self._next
+
+    @property
+    def apparent_encoding(self):
+        """The apparent encoding, provided by the chardet library."""
+        return chardet.detect(self.content)['encoding']
+
+    def iter_content(self, chunk_size=1, decode_unicode=False):
+        """Iterates over the response data.  When stream=True is set on the
+        request, this avoids reading the content at once into memory for
+        large responses.  The chunk size is the number of bytes it should
+        read into memory.  This is not necessarily the length of each item
+        returned as decoding can take place.
+
+        chunk_size must be of type int or None. A value of None will
+        function differently depending on the value of `stream`.
+        stream=True will read data as it arrives in whatever size the
+        chunks are received. If stream=False, data is returned as
+        a single chunk.
+
+        If decode_unicode is True, content will be decoded using the best
+        available encoding based on the response.
+        """
+
+        def generate():
+            # Special case for urllib3.
+            if hasattr(self.raw, 'stream'):
+                try:
+                    for chunk in self.raw.stream(chunk_size, decode_content=True):
+                        yield chunk
+                except ProtocolError as e:
+                    raise ChunkedEncodingError(e)
+                except DecodeError as e:
+                    raise ContentDecodingError(e)
+                except ReadTimeoutError as e:
+                    raise ConnectionError(e)
+            else:
+                # Standard file-like object.
+                while True:
+                    chunk = self.raw.read(chunk_size)
+                    if not chunk:
+                        break
+                    yield chunk
+
+            self._content_consumed = True
+
+        if self._content_consumed and isinstance(self._content, bool):
+            raise StreamConsumedError()
+        elif chunk_size is not None and not isinstance(chunk_size, int):
+            raise TypeError("chunk_size must be an int, it is instead a %s." % type(chunk_size))
+        # simulate reading small chunks of the content
+        reused_chunks = iter_slices(self._content, chunk_size)
+
+        stream_chunks = generate()
+
+        chunks = reused_chunks if self._content_consumed else stream_chunks
+
+        if decode_unicode:
+            chunks = stream_decode_response_unicode(chunks, self)
+
+        return chunks
+
+    def iter_lines(self, chunk_size=ITER_CHUNK_SIZE, decode_unicode=False, delimiter=None):
+        """Iterates over the response data, one line at a time.  When
+        stream=True is set on the request, this avoids reading the
+        content at once into memory for large responses.
+
+        .. note:: This method is not reentrant safe.
+        """
+
+        pending = None
+
+        for chunk in self.iter_content(chunk_size=chunk_size, decode_unicode=decode_unicode):
+
+            if pending is not None:
+                chunk = pending + chunk
+
+            if delimiter:
+                lines = chunk.split(delimiter)
+            else:
+                lines = chunk.splitlines()
+
+            if lines and lines[-1] and chunk and lines[-1][-1] == chunk[-1]:
+                pending = lines.pop()
+            else:
+                pending = None
+
+            for line in lines:
+                yield line
+
+        if pending is not None:
+            yield pending
+
+    @property
+    def content(self):
+        """Content of the response, in bytes."""
+
+        if self._content is False:
+            # Read the contents.
+            if self._content_consumed:
+                raise RuntimeError(
+                    'The content for this response was already consumed')
+
+            if self.status_code == 0 or self.raw is None:
+                self._content = None
+            else:
+                self._content = b''.join(self.iter_content(CONTENT_CHUNK_SIZE)) or b''
+
+        self._content_consumed = True
+        # don't need to release the connection; that's been handled by urllib3
+        # since we exhausted the data.
+        return self._content
+
+    @property
+    def text(self):
+        """Content of the response, in unicode.
+
+        If Response.encoding is None, encoding will be guessed using
+        ``chardet``.
+
+        The encoding of the response content is determined based solely on HTTP
+        headers, following RFC 2616 to the letter. If you can take advantage of
+        non-HTTP knowledge to make a better guess at the encoding, you should
+        set ``r.encoding`` appropriately before accessing this property.
+        """
+
+        # Try charset from content-type
+        content = None
+        encoding = self.encoding
+
+        if not self.content:
+            return str('')
+
+        # Fallback to auto-detected encoding.
+        if self.encoding is None:
+            encoding = self.apparent_encoding
+
+        # Decode unicode from given encoding.
+        try:
+            content = str(self.content, encoding, errors='replace')
+        except (LookupError, TypeError):
+            # A LookupError is raised if the encoding was not found which could
+            # indicate a misspelling or similar mistake.
+            #
+            # A TypeError can be raised if encoding is None
+            #
+            # So we try blindly encoding.
+            content = str(self.content, errors='replace')
+
+        return content
+
+    def json(self, **kwargs):
+        r"""Returns the json-encoded content of a response, if any.
+
+        :param \*\*kwargs: Optional arguments that ``json.loads`` takes.
+        :raises ValueError: If the response body does not contain valid json.
+        """
+
+        if not self.encoding and self.content and len(self.content) > 3:
+            # No encoding set. JSON RFC 4627 section 3 states we should expect
+            # UTF-8, -16 or -32. Detect which one to use; If the detection or
+            # decoding fails, fall back to `self.text` (using chardet to make
+            # a best guess).
+            encoding = guess_json_utf(self.content)
+            if encoding is not None:
+                try:
+                    return complexjson.loads(
+                        self.content.decode(encoding), **kwargs
+                    )
+                except UnicodeDecodeError:
+                    # Wrong UTF codec detected; usually because it's not UTF-8
+                    # but some other 8-bit codec.  This is an RFC violation,
+                    # and the server didn't bother to tell us what codec *was*
+                    # used.
+                    pass
+        return complexjson.loads(self.text, **kwargs)
+
+    @property
+    def links(self):
+        """Returns the parsed header links of the response, if any."""
+
+        header = self.headers.get('link')
+
+        # l = MultiDict()
+        l = {}
+
+        if header:
+            links = parse_header_links(header)
+
+            for link in links:
+                key = link.get('rel') or link.get('url')
+                l[key] = link
+
+        return l
+
+    def raise_for_status(self):
+        """Raises :class:`HTTPError`, if one occurred."""
+
+        http_error_msg = ''
+        if isinstance(self.reason, bytes):
+            # We attempt to decode utf-8 first because some servers
+            # choose to localize their reason strings. If the string
+            # isn't utf-8, we fall back to iso-8859-1 for all other
+            # encodings. (See PR #3538)
+            try:
+                reason = self.reason.decode('utf-8')
+            except UnicodeDecodeError:
+                reason = self.reason.decode('iso-8859-1')
+        else:
+            reason = self.reason
+
+        if 400 <= self.status_code < 500:
+            http_error_msg = u'%s Client Error: %s for url: %s' % (self.status_code, reason, self.url)
+
+        elif 500 <= self.status_code < 600:
+            http_error_msg = u'%s Server Error: %s for url: %s' % (self.status_code, reason, self.url)
+
+        if http_error_msg:
+            raise HTTPError(http_error_msg, response=self)
+
+    def close(self):
+        """Releases the connection back to the pool. Once this method has been
+        called the underlying ``raw`` object must not be accessed again.
+
+        *Note: Should not normally need to be called explicitly.*
+        """
+        if not self._content_consumed:
+            self.raw.close()
+
+        release_conn = getattr(self.raw, 'release_conn', None)
+        if release_conn is not None:
+            release_conn()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/packages.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/packages.py
new file mode 100644
index 0000000..9582fa7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/packages.py
@@ -0,0 +1,16 @@
+import sys
+
+# This code exists for backwards compatibility reasons.
+# I don't like it either. Just look the other way. :)
+
+for package in ('urllib3', 'idna', 'chardet'):
+    vendored_package = "pip._vendor." + package
+    locals()[package] = __import__(vendored_package)
+    # This traversal is apparently necessary such that the identities are
+    # preserved (requests.packages.urllib3.* is urllib3.*)
+    for mod in list(sys.modules):
+        if mod == vendored_package or mod.startswith(vendored_package + '.'):
+            unprefixed_mod = mod[len("pip._vendor."):]
+            sys.modules['pip._vendor.requests.packages.' + unprefixed_mod] = sys.modules[mod]
+
+# Kinda cool, though, right?
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/sessions.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/sessions.py
new file mode 100644
index 0000000..e8e2d60
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/sessions.py
@@ -0,0 +1,769 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.session
+~~~~~~~~~~~~~~~~
+
+This module provides a Session object to manage and persist settings across
+requests (cookies, auth, proxies).
+"""
+import os
+import sys
+import time
+from datetime import timedelta
+from collections import OrderedDict
+
+from .auth import _basic_auth_str
+from .compat import cookielib, is_py3, urljoin, urlparse, Mapping
+from .cookies import (
+    cookiejar_from_dict, extract_cookies_to_jar, RequestsCookieJar, merge_cookies)
+from .models import Request, PreparedRequest, DEFAULT_REDIRECT_LIMIT
+from .hooks import default_hooks, dispatch_hook
+from ._internal_utils import to_native_string
+from .utils import to_key_val_list, default_headers, DEFAULT_PORTS
+from .exceptions import (
+    TooManyRedirects, InvalidSchema, ChunkedEncodingError, ContentDecodingError)
+
+from .structures import CaseInsensitiveDict
+from .adapters import HTTPAdapter
+
+from .utils import (
+    requote_uri, get_environ_proxies, get_netrc_auth, should_bypass_proxies,
+    get_auth_from_url, rewind_body
+)
+
+from .status_codes import codes
+
+# formerly defined here, reexposed here for backward compatibility
+from .models import REDIRECT_STATI
+
+# Preferred clock, based on which one is more accurate on a given system.
+if sys.platform == 'win32':
+    try:  # Python 3.4+
+        preferred_clock = time.perf_counter
+    except AttributeError:  # Earlier than Python 3.
+        preferred_clock = time.clock
+else:
+    preferred_clock = time.time
+
+
+def merge_setting(request_setting, session_setting, dict_class=OrderedDict):
+    """Determines appropriate setting for a given request, taking into account
+    the explicit setting on that request, and the setting in the session. If a
+    setting is a dictionary, they will be merged together using `dict_class`
+    """
+
+    if session_setting is None:
+        return request_setting
+
+    if request_setting is None:
+        return session_setting
+
+    # Bypass if not a dictionary (e.g. verify)
+    if not (
+            isinstance(session_setting, Mapping) and
+            isinstance(request_setting, Mapping)
+    ):
+        return request_setting
+
+    merged_setting = dict_class(to_key_val_list(session_setting))
+    merged_setting.update(to_key_val_list(request_setting))
+
+    # Remove keys that are set to None. Extract keys first to avoid altering
+    # the dictionary during iteration.
+    none_keys = [k for (k, v) in merged_setting.items() if v is None]
+    for key in none_keys:
+        del merged_setting[key]
+
+    return merged_setting
+
+
+def merge_hooks(request_hooks, session_hooks, dict_class=OrderedDict):
+    """Properly merges both requests and session hooks.
+
+    This is necessary because when request_hooks == {'response': []}, the
+    merge breaks Session hooks entirely.
+    """
+    if session_hooks is None or session_hooks.get('response') == []:
+        return request_hooks
+
+    if request_hooks is None or request_hooks.get('response') == []:
+        return session_hooks
+
+    return merge_setting(request_hooks, session_hooks, dict_class)
+
+
+class SessionRedirectMixin(object):
+
+    def get_redirect_target(self, resp):
+        """Receives a Response. Returns a redirect URI or ``None``"""
+        # Due to the nature of how requests processes redirects this method will
+        # be called at least once upon the original response and at least twice
+        # on each subsequent redirect response (if any).
+        # If a custom mixin is used to handle this logic, it may be advantageous
+        # to cache the redirect location onto the response object as a private
+        # attribute.
+        if resp.is_redirect:
+            location = resp.headers['location']
+            # Currently the underlying http module on py3 decode headers
+            # in latin1, but empirical evidence suggests that latin1 is very
+            # rarely used with non-ASCII characters in HTTP headers.
+            # It is more likely to get UTF8 header rather than latin1.
+            # This causes incorrect handling of UTF8 encoded location headers.
+            # To solve this, we re-encode the location in latin1.
+            if is_py3:
+                location = location.encode('latin1')
+            return to_native_string(location, 'utf8')
+        return None
+
+    def should_strip_auth(self, old_url, new_url):
+        """Decide whether Authorization header should be removed when redirecting"""
+        old_parsed = urlparse(old_url)
+        new_parsed = urlparse(new_url)
+        if old_parsed.hostname != new_parsed.hostname:
+            return True
+        # Special case: allow http -> https redirect when using the standard
+        # ports. This isn't specified by RFC 7235, but is kept to avoid
+        # breaking backwards compatibility with older versions of requests
+        # that allowed any redirects on the same host.
+        if (old_parsed.scheme == 'http' and old_parsed.port in (80, None)
+                and new_parsed.scheme == 'https' and new_parsed.port in (443, None)):
+            return False
+
+        # Handle default port usage corresponding to scheme.
+        changed_port = old_parsed.port != new_parsed.port
+        changed_scheme = old_parsed.scheme != new_parsed.scheme
+        default_port = (DEFAULT_PORTS.get(old_parsed.scheme, None), None)
+        if (not changed_scheme and old_parsed.port in default_port
+                and new_parsed.port in default_port):
+            return False
+
+        # Standard case: root URI must match
+        return changed_port or changed_scheme
+
+    def resolve_redirects(self, resp, req, stream=False, timeout=None,
+                          verify=True, cert=None, proxies=None, yield_requests=False, **adapter_kwargs):
+        """Receives a Response. Returns a generator of Responses or Requests."""
+
+        hist = []  # keep track of history
+
+        url = self.get_redirect_target(resp)
+        previous_fragment = urlparse(req.url).fragment
+        while url:
+            prepared_request = req.copy()
+
+            # Update history and keep track of redirects.
+            # resp.history must ignore the original request in this loop
+            hist.append(resp)
+            resp.history = hist[1:]
+
+            try:
+                resp.content  # Consume socket so it can be released
+            except (ChunkedEncodingError, ContentDecodingError, RuntimeError):
+                resp.raw.read(decode_content=False)
+
+            if len(resp.history) >= self.max_redirects:
+                raise TooManyRedirects('Exceeded {} redirects.'.format(self.max_redirects), response=resp)
+
+            # Release the connection back into the pool.
+            resp.close()
+
+            # Handle redirection without scheme (see: RFC 1808 Section 4)
+            if url.startswith('//'):
+                parsed_rurl = urlparse(resp.url)
+                url = ':'.join([to_native_string(parsed_rurl.scheme), url])
+
+            # Normalize url case and attach previous fragment if needed (RFC 7231 7.1.2)
+            parsed = urlparse(url)
+            if parsed.fragment == '' and previous_fragment:
+                parsed = parsed._replace(fragment=previous_fragment)
+            elif parsed.fragment:
+                previous_fragment = parsed.fragment
+            url = parsed.geturl()
+
+            # Facilitate relative 'location' headers, as allowed by RFC 7231.
+            # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
+            # Compliant with RFC3986, we percent encode the url.
+            if not parsed.netloc:
+                url = urljoin(resp.url, requote_uri(url))
+            else:
+                url = requote_uri(url)
+
+            prepared_request.url = to_native_string(url)
+
+            self.rebuild_method(prepared_request, resp)
+
+            # https://github.com/psf/requests/issues/1084
+            if resp.status_code not in (codes.temporary_redirect, codes.permanent_redirect):
+                # https://github.com/psf/requests/issues/3490
+                purged_headers = ('Content-Length', 'Content-Type', 'Transfer-Encoding')
+                for header in purged_headers:
+                    prepared_request.headers.pop(header, None)
+                prepared_request.body = None
+
+            headers = prepared_request.headers
+            headers.pop('Cookie', None)
+
+            # Extract any cookies sent on the response to the cookiejar
+            # in the new request. Because we've mutated our copied prepared
+            # request, use the old one that we haven't yet touched.
+            extract_cookies_to_jar(prepared_request._cookies, req, resp.raw)
+            merge_cookies(prepared_request._cookies, self.cookies)
+            prepared_request.prepare_cookies(prepared_request._cookies)
+
+            # Rebuild auth and proxy information.
+            proxies = self.rebuild_proxies(prepared_request, proxies)
+            self.rebuild_auth(prepared_request, resp)
+
+            # A failed tell() sets `_body_position` to `object()`. This non-None
+            # value ensures `rewindable` will be True, allowing us to raise an
+            # UnrewindableBodyError, instead of hanging the connection.
+            rewindable = (
+                prepared_request._body_position is not None and
+                ('Content-Length' in headers or 'Transfer-Encoding' in headers)
+            )
+
+            # Attempt to rewind consumed file-like object.
+            if rewindable:
+                rewind_body(prepared_request)
+
+            # Override the original request.
+            req = prepared_request
+
+            if yield_requests:
+                yield req
+            else:
+
+                resp = self.send(
+                    req,
+                    stream=stream,
+                    timeout=timeout,
+                    verify=verify,
+                    cert=cert,
+                    proxies=proxies,
+                    allow_redirects=False,
+                    **adapter_kwargs
+                )
+
+                extract_cookies_to_jar(self.cookies, prepared_request, resp.raw)
+
+                # extract redirect url, if any, for the next loop
+                url = self.get_redirect_target(resp)
+                yield resp
+
+    def rebuild_auth(self, prepared_request, response):
+        """When being redirected we may want to strip authentication from the
+        request to avoid leaking credentials. This method intelligently removes
+        and reapplies authentication where possible to avoid credential loss.
+        """
+        headers = prepared_request.headers
+        url = prepared_request.url
+
+        if 'Authorization' in headers and self.should_strip_auth(response.request.url, url):
+            # If we get redirected to a new host, we should strip out any
+            # authentication headers.
+            del headers['Authorization']
+
+        # .netrc might have more auth for us on our new host.
+        new_auth = get_netrc_auth(url) if self.trust_env else None
+        if new_auth is not None:
+            prepared_request.prepare_auth(new_auth)
+
+
+    def rebuild_proxies(self, prepared_request, proxies):
+        """This method re-evaluates the proxy configuration by considering the
+        environment variables. If we are redirected to a URL covered by
+        NO_PROXY, we strip the proxy configuration. Otherwise, we set missing
+        proxy keys for this URL (in case they were stripped by a previous
+        redirect).
+
+        This method also replaces the Proxy-Authorization header where
+        necessary.
+
+        :rtype: dict
+        """
+        proxies = proxies if proxies is not None else {}
+        headers = prepared_request.headers
+        url = prepared_request.url
+        scheme = urlparse(url).scheme
+        new_proxies = proxies.copy()
+        no_proxy = proxies.get('no_proxy')
+
+        bypass_proxy = should_bypass_proxies(url, no_proxy=no_proxy)
+        if self.trust_env and not bypass_proxy:
+            environ_proxies = get_environ_proxies(url, no_proxy=no_proxy)
+
+            proxy = environ_proxies.get(scheme, environ_proxies.get('all'))
+
+            if proxy:
+                new_proxies.setdefault(scheme, proxy)
+
+        if 'Proxy-Authorization' in headers:
+            del headers['Proxy-Authorization']
+
+        try:
+            username, password = get_auth_from_url(new_proxies[scheme])
+        except KeyError:
+            username, password = None, None
+
+        if username and password:
+            headers['Proxy-Authorization'] = _basic_auth_str(username, password)
+
+        return new_proxies
+
+    def rebuild_method(self, prepared_request, response):
+        """When being redirected we may want to change the method of the request
+        based on certain specs or browser behavior.
+        """
+        method = prepared_request.method
+
+        # https://tools.ietf.org/html/rfc7231#section-6.4.4
+        if response.status_code == codes.see_other and method != 'HEAD':
+            method = 'GET'
+
+        # Do what the browsers do, despite standards...
+        # First, turn 302s into GETs.
+        if response.status_code == codes.found and method != 'HEAD':
+            method = 'GET'
+
+        # Second, if a POST is responded to with a 301, turn it into a GET.
+        # This bizarre behaviour is explained in Issue 1704.
+        if response.status_code == codes.moved and method == 'POST':
+            method = 'GET'
+
+        prepared_request.method = method
+
+
+class Session(SessionRedirectMixin):
+    """A Requests session.
+
+    Provides cookie persistence, connection-pooling, and configuration.
+
+    Basic Usage::
+
+      >>> import requests
+      >>> s = requests.Session()
+      >>> s.get('https://httpbin.org/get')
+      <Response [200]>
+
+    Or as a context manager::
+
+      >>> with requests.Session() as s:
+      ...     s.get('https://httpbin.org/get')
+      <Response [200]>
+    """
+
+    __attrs__ = [
+        'headers', 'cookies', 'auth', 'proxies', 'hooks', 'params', 'verify',
+        'cert', 'adapters', 'stream', 'trust_env',
+        'max_redirects',
+    ]
+
+    def __init__(self):
+
+        #: A case-insensitive dictionary of headers to be sent on each
+        #: :class:`Request <Request>` sent from this
+        #: :class:`Session <Session>`.
+        self.headers = default_headers()
+
+        #: Default Authentication tuple or object to attach to
+        #: :class:`Request <Request>`.
+        self.auth = None
+
+        #: Dictionary mapping protocol or protocol and host to the URL of the proxy
+        #: (e.g. {'http': 'foo.bar:3128', 'http://host.name': 'foo.bar:4012'}) to
+        #: be used on each :class:`Request <Request>`.
+        self.proxies = {}
+
+        #: Event-handling hooks.
+        self.hooks = default_hooks()
+
+        #: Dictionary of querystring data to attach to each
+        #: :class:`Request <Request>`. The dictionary values may be lists for
+        #: representing multivalued query parameters.
+        self.params = {}
+
+        #: Stream response content default.
+        self.stream = False
+
+        #: SSL Verification default.
+        self.verify = True
+
+        #: SSL client certificate default, if String, path to ssl client
+        #: cert file (.pem). If Tuple, ('cert', 'key') pair.
+        self.cert = None
+
+        #: Maximum number of redirects allowed. If the request exceeds this
+        #: limit, a :class:`TooManyRedirects` exception is raised.
+        #: This defaults to requests.models.DEFAULT_REDIRECT_LIMIT, which is
+        #: 30.
+        self.max_redirects = DEFAULT_REDIRECT_LIMIT
+
+        #: Trust environment settings for proxy configuration, default
+        #: authentication and similar.
+        self.trust_env = True
+
+        #: A CookieJar containing all currently outstanding cookies set on this
+        #: session. By default it is a
+        #: :class:`RequestsCookieJar <requests.cookies.RequestsCookieJar>`, but
+        #: may be any other ``cookielib.CookieJar`` compatible object.
+        self.cookies = cookiejar_from_dict({})
+
+        # Default connection adapters.
+        self.adapters = OrderedDict()
+        self.mount('https://', HTTPAdapter())
+        self.mount('http://', HTTPAdapter())
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def prepare_request(self, request):
+        """Constructs a :class:`PreparedRequest <PreparedRequest>` for
+        transmission and returns it. The :class:`PreparedRequest` has settings
+        merged from the :class:`Request <Request>` instance and those of the
+        :class:`Session`.
+
+        :param request: :class:`Request` instance to prepare with this
+            session's settings.
+        :rtype: requests.PreparedRequest
+        """
+        cookies = request.cookies or {}
+
+        # Bootstrap CookieJar.
+        if not isinstance(cookies, cookielib.CookieJar):
+            cookies = cookiejar_from_dict(cookies)
+
+        # Merge with session cookies
+        merged_cookies = merge_cookies(
+            merge_cookies(RequestsCookieJar(), self.cookies), cookies)
+
+        # Set environment's basic authentication if not explicitly set.
+        auth = request.auth
+        if self.trust_env and not auth and not self.auth:
+            auth = get_netrc_auth(request.url)
+
+        p = PreparedRequest()
+        p.prepare(
+            method=request.method.upper(),
+            url=request.url,
+            files=request.files,
+            data=request.data,
+            json=request.json,
+            headers=merge_setting(request.headers, self.headers, dict_class=CaseInsensitiveDict),
+            params=merge_setting(request.params, self.params),
+            auth=merge_setting(auth, self.auth),
+            cookies=merged_cookies,
+            hooks=merge_hooks(request.hooks, self.hooks),
+        )
+        return p
+
+    def request(self, method, url,
+            params=None, data=None, headers=None, cookies=None, files=None,
+            auth=None, timeout=None, allow_redirects=True, proxies=None,
+            hooks=None, stream=None, verify=None, cert=None, json=None):
+        """Constructs a :class:`Request <Request>`, prepares it and sends it.
+        Returns :class:`Response <Response>` object.
+
+        :param method: method for the new :class:`Request` object.
+        :param url: URL for the new :class:`Request` object.
+        :param params: (optional) Dictionary or bytes to be sent in the query
+            string for the :class:`Request`.
+        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+            object to send in the body of the :class:`Request`.
+        :param json: (optional) json to send in the body of the
+            :class:`Request`.
+        :param headers: (optional) Dictionary of HTTP Headers to send with the
+            :class:`Request`.
+        :param cookies: (optional) Dict or CookieJar object to send with the
+            :class:`Request`.
+        :param files: (optional) Dictionary of ``'filename': file-like-objects``
+            for multipart encoding upload.
+        :param auth: (optional) Auth tuple or callable to enable
+            Basic/Digest/Custom HTTP Auth.
+        :param timeout: (optional) How long to wait for the server to send
+            data before giving up, as a float, or a :ref:`(connect timeout,
+            read timeout) <timeouts>` tuple.
+        :type timeout: float or tuple
+        :param allow_redirects: (optional) Set to True by default.
+        :type allow_redirects: bool
+        :param proxies: (optional) Dictionary mapping protocol or protocol and
+            hostname to the URL of the proxy.
+        :param stream: (optional) whether to immediately download the response
+            content. Defaults to ``False``.
+        :param verify: (optional) Either a boolean, in which case it controls whether we verify
+            the server's TLS certificate, or a string, in which case it must be a path
+            to a CA bundle to use. Defaults to ``True``.
+        :param cert: (optional) if String, path to ssl client cert file (.pem).
+            If Tuple, ('cert', 'key') pair.
+        :rtype: requests.Response
+        """
+        # Create the Request.
+        req = Request(
+            method=method.upper(),
+            url=url,
+            headers=headers,
+            files=files,
+            data=data or {},
+            json=json,
+            params=params or {},
+            auth=auth,
+            cookies=cookies,
+            hooks=hooks,
+        )
+        prep = self.prepare_request(req)
+
+        proxies = proxies or {}
+
+        settings = self.merge_environment_settings(
+            prep.url, proxies, stream, verify, cert
+        )
+
+        # Send the request.
+        send_kwargs = {
+            'timeout': timeout,
+            'allow_redirects': allow_redirects,
+        }
+        send_kwargs.update(settings)
+        resp = self.send(prep, **send_kwargs)
+
+        return resp
+
+    def get(self, url, **kwargs):
+        r"""Sends a GET request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+
+        kwargs.setdefault('allow_redirects', True)
+        return self.request('GET', url, **kwargs)
+
+    def options(self, url, **kwargs):
+        r"""Sends a OPTIONS request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+
+        kwargs.setdefault('allow_redirects', True)
+        return self.request('OPTIONS', url, **kwargs)
+
+    def head(self, url, **kwargs):
+        r"""Sends a HEAD request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+
+        kwargs.setdefault('allow_redirects', False)
+        return self.request('HEAD', url, **kwargs)
+
+    def post(self, url, data=None, json=None, **kwargs):
+        r"""Sends a POST request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+            object to send in the body of the :class:`Request`.
+        :param json: (optional) json to send in the body of the :class:`Request`.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+
+        return self.request('POST', url, data=data, json=json, **kwargs)
+
+    def put(self, url, data=None, **kwargs):
+        r"""Sends a PUT request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+            object to send in the body of the :class:`Request`.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+
+        return self.request('PUT', url, data=data, **kwargs)
+
+    def patch(self, url, data=None, **kwargs):
+        r"""Sends a PATCH request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+            object to send in the body of the :class:`Request`.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+
+        return self.request('PATCH', url, data=data, **kwargs)
+
+    def delete(self, url, **kwargs):
+        r"""Sends a DELETE request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+
+        return self.request('DELETE', url, **kwargs)
+
+    def send(self, request, **kwargs):
+        """Send a given PreparedRequest.
+
+        :rtype: requests.Response
+        """
+        # Set defaults that the hooks can utilize to ensure they always have
+        # the correct parameters to reproduce the previous request.
+        kwargs.setdefault('stream', self.stream)
+        kwargs.setdefault('verify', self.verify)
+        kwargs.setdefault('cert', self.cert)
+        kwargs.setdefault('proxies', self.proxies)
+
+        # It's possible that users might accidentally send a Request object.
+        # Guard against that specific failure case.
+        if isinstance(request, Request):
+            raise ValueError('You can only send PreparedRequests.')
+
+        # Set up variables needed for resolve_redirects and dispatching of hooks
+        allow_redirects = kwargs.pop('allow_redirects', True)
+        stream = kwargs.get('stream')
+        hooks = request.hooks
+
+        # Get the appropriate adapter to use
+        adapter = self.get_adapter(url=request.url)
+
+        # Start time (approximately) of the request
+        start = preferred_clock()
+
+        # Send the request
+        r = adapter.send(request, **kwargs)
+
+        # Total elapsed time of the request (approximately)
+        elapsed = preferred_clock() - start
+        r.elapsed = timedelta(seconds=elapsed)
+
+        # Response manipulation hooks
+        r = dispatch_hook('response', hooks, r, **kwargs)
+
+        # Persist cookies
+        if r.history:
+
+            # If the hooks create history then we want those cookies too
+            for resp in r.history:
+                extract_cookies_to_jar(self.cookies, resp.request, resp.raw)
+
+        extract_cookies_to_jar(self.cookies, request, r.raw)
+
+        # Resolve redirects if allowed.
+        if allow_redirects:
+            # Redirect resolving generator.
+            gen = self.resolve_redirects(r, request, **kwargs)
+            history = [resp for resp in gen]
+        else:
+            history = []
+
+        # Shuffle things around if there's history.
+        if history:
+            # Insert the first (original) request at the start
+            history.insert(0, r)
+            # Get the last request made
+            r = history.pop()
+            r.history = history
+
+        # If redirects aren't being followed, store the response on the Request for Response.next().
+        if not allow_redirects:
+            try:
+                r._next = next(self.resolve_redirects(r, request, yield_requests=True, **kwargs))
+            except StopIteration:
+                pass
+
+        if not stream:
+            r.content
+
+        return r
+
+    def merge_environment_settings(self, url, proxies, stream, verify, cert):
+        """
+        Check the environment and merge it with some settings.
+
+        :rtype: dict
+        """
+        # Gather clues from the surrounding environment.
+        if self.trust_env:
+            # Set environment's proxies.
+            no_proxy = proxies.get('no_proxy') if proxies is not None else None
+            env_proxies = get_environ_proxies(url, no_proxy=no_proxy)
+            for (k, v) in env_proxies.items():
+                proxies.setdefault(k, v)
+
+            # Look for requests environment configuration and be compatible
+            # with cURL.
+            if verify is True or verify is None:
+                verify = (os.environ.get('REQUESTS_CA_BUNDLE') or
+                          os.environ.get('CURL_CA_BUNDLE'))
+
+        # Merge all the kwargs.
+        proxies = merge_setting(proxies, self.proxies)
+        stream = merge_setting(stream, self.stream)
+        verify = merge_setting(verify, self.verify)
+        cert = merge_setting(cert, self.cert)
+
+        return {'verify': verify, 'proxies': proxies, 'stream': stream,
+                'cert': cert}
+
+    def get_adapter(self, url):
+        """
+        Returns the appropriate connection adapter for the given URL.
+
+        :rtype: requests.adapters.BaseAdapter
+        """
+        for (prefix, adapter) in self.adapters.items():
+
+            if url.lower().startswith(prefix.lower()):
+                return adapter
+
+        # Nothing matches :-/
+        raise InvalidSchema("No connection adapters were found for {!r}".format(url))
+
+    def close(self):
+        """Closes all adapters and as such the session"""
+        for v in self.adapters.values():
+            v.close()
+
+    def mount(self, prefix, adapter):
+        """Registers a connection adapter to a prefix.
+
+        Adapters are sorted in descending order by prefix length.
+        """
+        self.adapters[prefix] = adapter
+        keys_to_move = [k for k in self.adapters if len(k) < len(prefix)]
+
+        for key in keys_to_move:
+            self.adapters[key] = self.adapters.pop(key)
+
+    def __getstate__(self):
+        state = {attr: getattr(self, attr, None) for attr in self.__attrs__}
+        return state
+
+    def __setstate__(self, state):
+        for attr, value in state.items():
+            setattr(self, attr, value)
+
+
+def session():
+    """
+    Returns a :class:`Session` for context-management.
+
+    .. deprecated:: 1.0.0
+
+        This method has been deprecated since version 1.0.0 and is only kept for
+        backwards compatibility. New code should use :class:`~requests.sessions.Session`
+        to create a session. This may be removed at a future date.
+
+    :rtype: Session
+    """
+    return Session()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/status_codes.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/status_codes.py
new file mode 100644
index 0000000..d80a7cd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/status_codes.py
@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+
+r"""
+The ``codes`` object defines a mapping from common names for HTTP statuses
+to their numerical codes, accessible either as attributes or as dictionary
+items.
+
+Example::
+
+    >>> import requests
+    >>> requests.codes['temporary_redirect']
+    307
+    >>> requests.codes.teapot
+    418
+    >>> requests.codes['\o/']
+    200
+
+Some codes have multiple names, and both upper- and lower-case versions of
+the names are allowed. For example, ``codes.ok``, ``codes.OK``, and
+``codes.okay`` all correspond to the HTTP status code 200.
+"""
+
+from .structures import LookupDict
+
+_codes = {
+
+    # Informational.
+    100: ('continue',),
+    101: ('switching_protocols',),
+    102: ('processing',),
+    103: ('checkpoint',),
+    122: ('uri_too_long', 'request_uri_too_long'),
+    200: ('ok', 'okay', 'all_ok', 'all_okay', 'all_good', '\\o/', '✓'),
+    201: ('created',),
+    202: ('accepted',),
+    203: ('non_authoritative_info', 'non_authoritative_information'),
+    204: ('no_content',),
+    205: ('reset_content', 'reset'),
+    206: ('partial_content', 'partial'),
+    207: ('multi_status', 'multiple_status', 'multi_stati', 'multiple_stati'),
+    208: ('already_reported',),
+    226: ('im_used',),
+
+    # Redirection.
+    300: ('multiple_choices',),
+    301: ('moved_permanently', 'moved', '\\o-'),
+    302: ('found',),
+    303: ('see_other', 'other'),
+    304: ('not_modified',),
+    305: ('use_proxy',),
+    306: ('switch_proxy',),
+    307: ('temporary_redirect', 'temporary_moved', 'temporary'),
+    308: ('permanent_redirect',
+          'resume_incomplete', 'resume',),  # These 2 to be removed in 3.0
+
+    # Client Error.
+    400: ('bad_request', 'bad'),
+    401: ('unauthorized',),
+    402: ('payment_required', 'payment'),
+    403: ('forbidden',),
+    404: ('not_found', '-o-'),
+    405: ('method_not_allowed', 'not_allowed'),
+    406: ('not_acceptable',),
+    407: ('proxy_authentication_required', 'proxy_auth', 'proxy_authentication'),
+    408: ('request_timeout', 'timeout'),
+    409: ('conflict',),
+    410: ('gone',),
+    411: ('length_required',),
+    412: ('precondition_failed', 'precondition'),
+    413: ('request_entity_too_large',),
+    414: ('request_uri_too_large',),
+    415: ('unsupported_media_type', 'unsupported_media', 'media_type'),
+    416: ('requested_range_not_satisfiable', 'requested_range', 'range_not_satisfiable'),
+    417: ('expectation_failed',),
+    418: ('im_a_teapot', 'teapot', 'i_am_a_teapot'),
+    421: ('misdirected_request',),
+    422: ('unprocessable_entity', 'unprocessable'),
+    423: ('locked',),
+    424: ('failed_dependency', 'dependency'),
+    425: ('unordered_collection', 'unordered'),
+    426: ('upgrade_required', 'upgrade'),
+    428: ('precondition_required', 'precondition'),
+    429: ('too_many_requests', 'too_many'),
+    431: ('header_fields_too_large', 'fields_too_large'),
+    444: ('no_response', 'none'),
+    449: ('retry_with', 'retry'),
+    450: ('blocked_by_windows_parental_controls', 'parental_controls'),
+    451: ('unavailable_for_legal_reasons', 'legal_reasons'),
+    499: ('client_closed_request',),
+
+    # Server Error.
+    500: ('internal_server_error', 'server_error', '/o\\', '✗'),
+    501: ('not_implemented',),
+    502: ('bad_gateway',),
+    503: ('service_unavailable', 'unavailable'),
+    504: ('gateway_timeout',),
+    505: ('http_version_not_supported', 'http_version'),
+    506: ('variant_also_negotiates',),
+    507: ('insufficient_storage',),
+    509: ('bandwidth_limit_exceeded', 'bandwidth'),
+    510: ('not_extended',),
+    511: ('network_authentication_required', 'network_auth', 'network_authentication'),
+}
+
+codes = LookupDict(name='status_codes')
+
+def _init():
+    for code, titles in _codes.items():
+        for title in titles:
+            setattr(codes, title, code)
+            if not title.startswith(('\\', '/')):
+                setattr(codes, title.upper(), code)
+
+    def doc(code):
+        names = ', '.join('``%s``' % n for n in _codes[code])
+        return '* %d: %s' % (code, names)
+
+    global __doc__
+    __doc__ = (__doc__ + '\n' +
+               '\n'.join(doc(code) for code in sorted(_codes))
+               if __doc__ is not None else None)
+
+_init()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/structures.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/structures.py
new file mode 100644
index 0000000..8ee0ba7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/structures.py
@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.structures
+~~~~~~~~~~~~~~~~~~~
+
+Data structures that power Requests.
+"""
+
+from collections import OrderedDict
+
+from .compat import Mapping, MutableMapping
+
+
+class CaseInsensitiveDict(MutableMapping):
+    """A case-insensitive ``dict``-like object.
+
+    Implements all methods and operations of
+    ``MutableMapping`` as well as dict's ``copy``. Also
+    provides ``lower_items``.
+
+    All keys are expected to be strings. The structure remembers the
+    case of the last key to be set, and ``iter(instance)``,
+    ``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
+    will contain case-sensitive keys. However, querying and contains
+    testing is case insensitive::
+
+        cid = CaseInsensitiveDict()
+        cid['Accept'] = 'application/json'
+        cid['aCCEPT'] == 'application/json'  # True
+        list(cid) == ['Accept']  # True
+
+    For example, ``headers['content-encoding']`` will return the
+    value of a ``'Content-Encoding'`` response header, regardless
+    of how the header name was originally stored.
+
+    If the constructor, ``.update``, or equality comparison
+    operations are given keys that have equal ``.lower()``s, the
+    behavior is undefined.
+    """
+
+    def __init__(self, data=None, **kwargs):
+        self._store = OrderedDict()
+        if data is None:
+            data = {}
+        self.update(data, **kwargs)
+
+    def __setitem__(self, key, value):
+        # Use the lowercased key for lookups, but store the actual
+        # key alongside the value.
+        self._store[key.lower()] = (key, value)
+
+    def __getitem__(self, key):
+        return self._store[key.lower()][1]
+
+    def __delitem__(self, key):
+        del self._store[key.lower()]
+
+    def __iter__(self):
+        return (casedkey for casedkey, mappedvalue in self._store.values())
+
+    def __len__(self):
+        return len(self._store)
+
+    def lower_items(self):
+        """Like iteritems(), but with all lowercase keys."""
+        return (
+            (lowerkey, keyval[1])
+            for (lowerkey, keyval)
+            in self._store.items()
+        )
+
+    def __eq__(self, other):
+        if isinstance(other, Mapping):
+            other = CaseInsensitiveDict(other)
+        else:
+            return NotImplemented
+        # Compare insensitively
+        return dict(self.lower_items()) == dict(other.lower_items())
+
+    # Copy is required
+    def copy(self):
+        return CaseInsensitiveDict(self._store.values())
+
+    def __repr__(self):
+        return str(dict(self.items()))
+
+
+class LookupDict(dict):
+    """Dictionary lookup object."""
+
+    def __init__(self, name=None):
+        self.name = name
+        super(LookupDict, self).__init__()
+
+    def __repr__(self):
+        return '<lookup \'%s\'>' % (self.name)
+
+    def __getitem__(self, key):
+        # We allow fall-through here, so values default to None
+
+        return self.__dict__.get(key, None)
+
+    def get(self, key, default=None):
+        return self.__dict__.get(key, default)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/requests/utils.py b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/utils.py
new file mode 100644
index 0000000..c1700d7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/requests/utils.py
@@ -0,0 +1,982 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.utils
+~~~~~~~~~~~~~~
+
+This module provides utility functions that are used within Requests
+that are also useful for external consumption.
+"""
+
+import codecs
+import contextlib
+import io
+import os
+import re
+import socket
+import struct
+import sys
+import tempfile
+import warnings
+import zipfile
+from collections import OrderedDict
+
+from .__version__ import __version__
+from . import certs
+# to_native_string is unused here, but imported here for backwards compatibility
+from ._internal_utils import to_native_string
+from .compat import parse_http_list as _parse_list_header
+from .compat import (
+    quote, urlparse, bytes, str, unquote, getproxies,
+    proxy_bypass, urlunparse, basestring, integer_types, is_py3,
+    proxy_bypass_environment, getproxies_environment, Mapping)
+from .cookies import cookiejar_from_dict
+from .structures import CaseInsensitiveDict
+from .exceptions import (
+    InvalidURL, InvalidHeader, FileModeWarning, UnrewindableBodyError)
+
+NETRC_FILES = ('.netrc', '_netrc')
+
+DEFAULT_CA_BUNDLE_PATH = certs.where()
+
+DEFAULT_PORTS = {'http': 80, 'https': 443}
+
+
+if sys.platform == 'win32':
+    # provide a proxy_bypass version on Windows without DNS lookups
+
+    def proxy_bypass_registry(host):
+        try:
+            if is_py3:
+                import winreg
+            else:
+                import _winreg as winreg
+        except ImportError:
+            return False
+
+        try:
+            internetSettings = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
+                r'Software\Microsoft\Windows\CurrentVersion\Internet Settings')
+            # ProxyEnable could be REG_SZ or REG_DWORD, normalizing it
+            proxyEnable = int(winreg.QueryValueEx(internetSettings,
+                                              'ProxyEnable')[0])
+            # ProxyOverride is almost always a string
+            proxyOverride = winreg.QueryValueEx(internetSettings,
+                                                'ProxyOverride')[0]
+        except OSError:
+            return False
+        if not proxyEnable or not proxyOverride:
+            return False
+
+        # make a check value list from the registry entry: replace the
+        # '<local>' string by the localhost entry and the corresponding
+        # canonical entry.
+        proxyOverride = proxyOverride.split(';')
+        # now check if we match one of the registry values.
+        for test in proxyOverride:
+            if test == '<local>':
+                if '.' not in host:
+                    return True
+            test = test.replace(".", r"\.")     # mask dots
+            test = test.replace("*", r".*")     # change glob sequence
+            test = test.replace("?", r".")      # change glob char
+            if re.match(test, host, re.I):
+                return True
+        return False
+
+    def proxy_bypass(host):  # noqa
+        """Return True, if the host should be bypassed.
+
+        Checks proxy settings gathered from the environment, if specified,
+        or the registry.
+        """
+        if getproxies_environment():
+            return proxy_bypass_environment(host)
+        else:
+            return proxy_bypass_registry(host)
+
+
+def dict_to_sequence(d):
+    """Returns an internal sequence dictionary update."""
+
+    if hasattr(d, 'items'):
+        d = d.items()
+
+    return d
+
+
+def super_len(o):
+    total_length = None
+    current_position = 0
+
+    if hasattr(o, '__len__'):
+        total_length = len(o)
+
+    elif hasattr(o, 'len'):
+        total_length = o.len
+
+    elif hasattr(o, 'fileno'):
+        try:
+            fileno = o.fileno()
+        except io.UnsupportedOperation:
+            pass
+        else:
+            total_length = os.fstat(fileno).st_size
+
+            # Having used fstat to determine the file length, we need to
+            # confirm that this file was opened up in binary mode.
+            if 'b' not in o.mode:
+                warnings.warn((
+                    "Requests has determined the content-length for this "
+                    "request using the binary size of the file: however, the "
+                    "file has been opened in text mode (i.e. without the 'b' "
+                    "flag in the mode). This may lead to an incorrect "
+                    "content-length. In Requests 3.0, support will be removed "
+                    "for files in text mode."),
+                    FileModeWarning
+                )
+
+    if hasattr(o, 'tell'):
+        try:
+            current_position = o.tell()
+        except (OSError, IOError):
+            # This can happen in some weird situations, such as when the file
+            # is actually a special file descriptor like stdin. In this
+            # instance, we don't know what the length is, so set it to zero and
+            # let requests chunk it instead.
+            if total_length is not None:
+                current_position = total_length
+        else:
+            if hasattr(o, 'seek') and total_length is None:
+                # StringIO and BytesIO have seek but no useable fileno
+                try:
+                    # seek to end of file
+                    o.seek(0, 2)
+                    total_length = o.tell()
+
+                    # seek back to current position to support
+                    # partially read file-like objects
+                    o.seek(current_position or 0)
+                except (OSError, IOError):
+                    total_length = 0
+
+    if total_length is None:
+        total_length = 0
+
+    return max(0, total_length - current_position)
+
+
+def get_netrc_auth(url, raise_errors=False):
+    """Returns the Requests tuple auth for a given url from netrc."""
+
+    try:
+        from netrc import netrc, NetrcParseError
+
+        netrc_path = None
+
+        for f in NETRC_FILES:
+            try:
+                loc = os.path.expanduser('~/{}'.format(f))
+            except KeyError:
+                # os.path.expanduser can fail when $HOME is undefined and
+                # getpwuid fails. See https://bugs.python.org/issue20164 &
+                # https://github.com/psf/requests/issues/1846
+                return
+
+            if os.path.exists(loc):
+                netrc_path = loc
+                break
+
+        # Abort early if there isn't one.
+        if netrc_path is None:
+            return
+
+        ri = urlparse(url)
+
+        # Strip port numbers from netloc. This weird `if...encode`` dance is
+        # used for Python 3.2, which doesn't support unicode literals.
+        splitstr = b':'
+        if isinstance(url, str):
+            splitstr = splitstr.decode('ascii')
+        host = ri.netloc.split(splitstr)[0]
+
+        try:
+            _netrc = netrc(netrc_path).authenticators(host)
+            if _netrc:
+                # Return with login / password
+                login_i = (0 if _netrc[0] else 1)
+                return (_netrc[login_i], _netrc[2])
+        except (NetrcParseError, IOError):
+            # If there was a parsing error or a permissions issue reading the file,
+            # we'll just skip netrc auth unless explicitly asked to raise errors.
+            if raise_errors:
+                raise
+
+    # AppEngine hackiness.
+    except (ImportError, AttributeError):
+        pass
+
+
+def guess_filename(obj):
+    """Tries to guess the filename of the given object."""
+    name = getattr(obj, 'name', None)
+    if (name and isinstance(name, basestring) and name[0] != '<' and
+            name[-1] != '>'):
+        return os.path.basename(name)
+
+
+def extract_zipped_paths(path):
+    """Replace nonexistent paths that look like they refer to a member of a zip
+    archive with the location of an extracted copy of the target, or else
+    just return the provided path unchanged.
+    """
+    if os.path.exists(path):
+        # this is already a valid path, no need to do anything further
+        return path
+
+    # find the first valid part of the provided path and treat that as a zip archive
+    # assume the rest of the path is the name of a member in the archive
+    archive, member = os.path.split(path)
+    while archive and not os.path.exists(archive):
+        archive, prefix = os.path.split(archive)
+        member = '/'.join([prefix, member])
+
+    if not zipfile.is_zipfile(archive):
+        return path
+
+    zip_file = zipfile.ZipFile(archive)
+    if member not in zip_file.namelist():
+        return path
+
+    # we have a valid zip archive and a valid member of that archive
+    tmp = tempfile.gettempdir()
+    extracted_path = os.path.join(tmp, *member.split('/'))
+    if not os.path.exists(extracted_path):
+        extracted_path = zip_file.extract(member, path=tmp)
+
+    return extracted_path
+
+
+def from_key_val_list(value):
+    """Take an object and test to see if it can be represented as a
+    dictionary. Unless it can not be represented as such, return an
+    OrderedDict, e.g.,
+
+    ::
+
+        >>> from_key_val_list([('key', 'val')])
+        OrderedDict([('key', 'val')])
+        >>> from_key_val_list('string')
+        Traceback (most recent call last):
+        ...
+        ValueError: cannot encode objects that are not 2-tuples
+        >>> from_key_val_list({'key': 'val'})
+        OrderedDict([('key', 'val')])
+
+    :rtype: OrderedDict
+    """
+    if value is None:
+        return None
+
+    if isinstance(value, (str, bytes, bool, int)):
+        raise ValueError('cannot encode objects that are not 2-tuples')
+
+    return OrderedDict(value)
+
+
+def to_key_val_list(value):
+    """Take an object and test to see if it can be represented as a
+    dictionary. If it can be, return a list of tuples, e.g.,
+
+    ::
+
+        >>> to_key_val_list([('key', 'val')])
+        [('key', 'val')]
+        >>> to_key_val_list({'key': 'val'})
+        [('key', 'val')]
+        >>> to_key_val_list('string')
+        Traceback (most recent call last):
+        ...
+        ValueError: cannot encode objects that are not 2-tuples
+
+    :rtype: list
+    """
+    if value is None:
+        return None
+
+    if isinstance(value, (str, bytes, bool, int)):
+        raise ValueError('cannot encode objects that are not 2-tuples')
+
+    if isinstance(value, Mapping):
+        value = value.items()
+
+    return list(value)
+
+
+# From mitsuhiko/werkzeug (used with permission).
+def parse_list_header(value):
+    """Parse lists as described by RFC 2068 Section 2.
+
+    In particular, parse comma-separated lists where the elements of
+    the list may include quoted-strings.  A quoted-string could
+    contain a comma.  A non-quoted string could have quotes in the
+    middle.  Quotes are removed automatically after parsing.
+
+    It basically works like :func:`parse_set_header` just that items
+    may appear multiple times and case sensitivity is preserved.
+
+    The return value is a standard :class:`list`:
+
+    >>> parse_list_header('token, "quoted value"')
+    ['token', 'quoted value']
+
+    To create a header from the :class:`list` again, use the
+    :func:`dump_header` function.
+
+    :param value: a string with a list header.
+    :return: :class:`list`
+    :rtype: list
+    """
+    result = []
+    for item in _parse_list_header(value):
+        if item[:1] == item[-1:] == '"':
+            item = unquote_header_value(item[1:-1])
+        result.append(item)
+    return result
+
+
+# From mitsuhiko/werkzeug (used with permission).
+def parse_dict_header(value):
+    """Parse lists of key, value pairs as described by RFC 2068 Section 2 and
+    convert them into a python dict:
+
+    >>> d = parse_dict_header('foo="is a fish", bar="as well"')
+    >>> type(d) is dict
+    True
+    >>> sorted(d.items())
+    [('bar', 'as well'), ('foo', 'is a fish')]
+
+    If there is no value for a key it will be `None`:
+
+    >>> parse_dict_header('key_without_value')
+    {'key_without_value': None}
+
+    To create a header from the :class:`dict` again, use the
+    :func:`dump_header` function.
+
+    :param value: a string with a dict header.
+    :return: :class:`dict`
+    :rtype: dict
+    """
+    result = {}
+    for item in _parse_list_header(value):
+        if '=' not in item:
+            result[item] = None
+            continue
+        name, value = item.split('=', 1)
+        if value[:1] == value[-1:] == '"':
+            value = unquote_header_value(value[1:-1])
+        result[name] = value
+    return result
+
+
+# From mitsuhiko/werkzeug (used with permission).
+def unquote_header_value(value, is_filename=False):
+    r"""Unquotes a header value.  (Reversal of :func:`quote_header_value`).
+    This does not use the real unquoting but what browsers are actually
+    using for quoting.
+
+    :param value: the header value to unquote.
+    :rtype: str
+    """
+    if value and value[0] == value[-1] == '"':
+        # this is not the real unquoting, but fixing this so that the
+        # RFC is met will result in bugs with internet explorer and
+        # probably some other browsers as well.  IE for example is
+        # uploading files with "C:\foo\bar.txt" as filename
+        value = value[1:-1]
+
+        # if this is a filename and the starting characters look like
+        # a UNC path, then just return the value without quotes.  Using the
+        # replace sequence below on a UNC path has the effect of turning
+        # the leading double slash into a single slash and then
+        # _fix_ie_filename() doesn't work correctly.  See #458.
+        if not is_filename or value[:2] != '\\\\':
+            return value.replace('\\\\', '\\').replace('\\"', '"')
+    return value
+
+
+def dict_from_cookiejar(cj):
+    """Returns a key/value dictionary from a CookieJar.
+
+    :param cj: CookieJar object to extract cookies from.
+    :rtype: dict
+    """
+
+    cookie_dict = {}
+
+    for cookie in cj:
+        cookie_dict[cookie.name] = cookie.value
+
+    return cookie_dict
+
+
+def add_dict_to_cookiejar(cj, cookie_dict):
+    """Returns a CookieJar from a key/value dictionary.
+
+    :param cj: CookieJar to insert cookies into.
+    :param cookie_dict: Dict of key/values to insert into CookieJar.
+    :rtype: CookieJar
+    """
+
+    return cookiejar_from_dict(cookie_dict, cj)
+
+
+def get_encodings_from_content(content):
+    """Returns encodings from given content string.
+
+    :param content: bytestring to extract encodings from.
+    """
+    warnings.warn((
+        'In requests 3.0, get_encodings_from_content will be removed. For '
+        'more information, please see the discussion on issue #2266. (This'
+        ' warning should only appear once.)'),
+        DeprecationWarning)
+
+    charset_re = re.compile(r'<meta.*?charset=["\']*(.+?)["\'>]', flags=re.I)
+    pragma_re = re.compile(r'<meta.*?content=["\']*;?charset=(.+?)["\'>]', flags=re.I)
+    xml_re = re.compile(r'^<\?xml.*?encoding=["\']*(.+?)["\'>]')
+
+    return (charset_re.findall(content) +
+            pragma_re.findall(content) +
+            xml_re.findall(content))
+
+
+def _parse_content_type_header(header):
+    """Returns content type and parameters from given header
+
+    :param header: string
+    :return: tuple containing content type and dictionary of
+         parameters
+    """
+
+    tokens = header.split(';')
+    content_type, params = tokens[0].strip(), tokens[1:]
+    params_dict = {}
+    items_to_strip = "\"' "
+
+    for param in params:
+        param = param.strip()
+        if param:
+            key, value = param, True
+            index_of_equals = param.find("=")
+            if index_of_equals != -1:
+                key = param[:index_of_equals].strip(items_to_strip)
+                value = param[index_of_equals + 1:].strip(items_to_strip)
+            params_dict[key.lower()] = value
+    return content_type, params_dict
+
+
+def get_encoding_from_headers(headers):
+    """Returns encodings from given HTTP Header Dict.
+
+    :param headers: dictionary to extract encoding from.
+    :rtype: str
+    """
+
+    content_type = headers.get('content-type')
+
+    if not content_type:
+        return None
+
+    content_type, params = _parse_content_type_header(content_type)
+
+    if 'charset' in params:
+        return params['charset'].strip("'\"")
+
+    if 'text' in content_type:
+        return 'ISO-8859-1'
+
+
+def stream_decode_response_unicode(iterator, r):
+    """Stream decodes a iterator."""
+
+    if r.encoding is None:
+        for item in iterator:
+            yield item
+        return
+
+    decoder = codecs.getincrementaldecoder(r.encoding)(errors='replace')
+    for chunk in iterator:
+        rv = decoder.decode(chunk)
+        if rv:
+            yield rv
+    rv = decoder.decode(b'', final=True)
+    if rv:
+        yield rv
+
+
+def iter_slices(string, slice_length):
+    """Iterate over slices of a string."""
+    pos = 0
+    if slice_length is None or slice_length <= 0:
+        slice_length = len(string)
+    while pos < len(string):
+        yield string[pos:pos + slice_length]
+        pos += slice_length
+
+
+def get_unicode_from_response(r):
+    """Returns the requested content back in unicode.
+
+    :param r: Response object to get unicode content from.
+
+    Tried:
+
+    1. charset from content-type
+    2. fall back and replace all unicode characters
+
+    :rtype: str
+    """
+    warnings.warn((
+        'In requests 3.0, get_unicode_from_response will be removed. For '
+        'more information, please see the discussion on issue #2266. (This'
+        ' warning should only appear once.)'),
+        DeprecationWarning)
+
+    tried_encodings = []
+
+    # Try charset from content-type
+    encoding = get_encoding_from_headers(r.headers)
+
+    if encoding:
+        try:
+            return str(r.content, encoding)
+        except UnicodeError:
+            tried_encodings.append(encoding)
+
+    # Fall back:
+    try:
+        return str(r.content, encoding, errors='replace')
+    except TypeError:
+        return r.content
+
+
+# The unreserved URI characters (RFC 3986)
+UNRESERVED_SET = frozenset(
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789-._~")
+
+
+def unquote_unreserved(uri):
+    """Un-escape any percent-escape sequences in a URI that are unreserved
+    characters. This leaves all reserved, illegal and non-ASCII bytes encoded.
+
+    :rtype: str
+    """
+    parts = uri.split('%')
+    for i in range(1, len(parts)):
+        h = parts[i][0:2]
+        if len(h) == 2 and h.isalnum():
+            try:
+                c = chr(int(h, 16))
+            except ValueError:
+                raise InvalidURL("Invalid percent-escape sequence: '%s'" % h)
+
+            if c in UNRESERVED_SET:
+                parts[i] = c + parts[i][2:]
+            else:
+                parts[i] = '%' + parts[i]
+        else:
+            parts[i] = '%' + parts[i]
+    return ''.join(parts)
+
+
+def requote_uri(uri):
+    """Re-quote the given URI.
+
+    This function passes the given URI through an unquote/quote cycle to
+    ensure that it is fully and consistently quoted.
+
+    :rtype: str
+    """
+    safe_with_percent = "!#$%&'()*+,/:;=?@[]~"
+    safe_without_percent = "!#$&'()*+,/:;=?@[]~"
+    try:
+        # Unquote only the unreserved characters
+        # Then quote only illegal characters (do not quote reserved,
+        # unreserved, or '%')
+        return quote(unquote_unreserved(uri), safe=safe_with_percent)
+    except InvalidURL:
+        # We couldn't unquote the given URI, so let's try quoting it, but
+        # there may be unquoted '%'s in the URI. We need to make sure they're
+        # properly quoted so they do not cause issues elsewhere.
+        return quote(uri, safe=safe_without_percent)
+
+
+def address_in_network(ip, net):
+    """This function allows you to check if an IP belongs to a network subnet
+
+    Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
+             returns False if ip = 192.168.1.1 and net = 192.168.100.0/24
+
+    :rtype: bool
+    """
+    ipaddr = struct.unpack('=L', socket.inet_aton(ip))[0]
+    netaddr, bits = net.split('/')
+    netmask = struct.unpack('=L', socket.inet_aton(dotted_netmask(int(bits))))[0]
+    network = struct.unpack('=L', socket.inet_aton(netaddr))[0] & netmask
+    return (ipaddr & netmask) == (network & netmask)
+
+
+def dotted_netmask(mask):
+    """Converts mask from /xx format to xxx.xxx.xxx.xxx
+
+    Example: if mask is 24 function returns 255.255.255.0
+
+    :rtype: str
+    """
+    bits = 0xffffffff ^ (1 << 32 - mask) - 1
+    return socket.inet_ntoa(struct.pack('>I', bits))
+
+
+def is_ipv4_address(string_ip):
+    """
+    :rtype: bool
+    """
+    try:
+        socket.inet_aton(string_ip)
+    except socket.error:
+        return False
+    return True
+
+
+def is_valid_cidr(string_network):
+    """
+    Very simple check of the cidr format in no_proxy variable.
+
+    :rtype: bool
+    """
+    if string_network.count('/') == 1:
+        try:
+            mask = int(string_network.split('/')[1])
+        except ValueError:
+            return False
+
+        if mask < 1 or mask > 32:
+            return False
+
+        try:
+            socket.inet_aton(string_network.split('/')[0])
+        except socket.error:
+            return False
+    else:
+        return False
+    return True
+
+
+@contextlib.contextmanager
+def set_environ(env_name, value):
+    """Set the environment variable 'env_name' to 'value'
+
+    Save previous value, yield, and then restore the previous value stored in
+    the environment variable 'env_name'.
+
+    If 'value' is None, do nothing"""
+    value_changed = value is not None
+    if value_changed:
+        old_value = os.environ.get(env_name)
+        os.environ[env_name] = value
+    try:
+        yield
+    finally:
+        if value_changed:
+            if old_value is None:
+                del os.environ[env_name]
+            else:
+                os.environ[env_name] = old_value
+
+
+def should_bypass_proxies(url, no_proxy):
+    """
+    Returns whether we should bypass proxies or not.
+
+    :rtype: bool
+    """
+    # Prioritize lowercase environment variables over uppercase
+    # to keep a consistent behaviour with other http projects (curl, wget).
+    get_proxy = lambda k: os.environ.get(k) or os.environ.get(k.upper())
+
+    # First check whether no_proxy is defined. If it is, check that the URL
+    # we're getting isn't in the no_proxy list.
+    no_proxy_arg = no_proxy
+    if no_proxy is None:
+        no_proxy = get_proxy('no_proxy')
+    parsed = urlparse(url)
+
+    if parsed.hostname is None:
+        # URLs don't always have hostnames, e.g. file:/// urls.
+        return True
+
+    if no_proxy:
+        # We need to check whether we match here. We need to see if we match
+        # the end of the hostname, both with and without the port.
+        no_proxy = (
+            host for host in no_proxy.replace(' ', '').split(',') if host
+        )
+
+        if is_ipv4_address(parsed.hostname):
+            for proxy_ip in no_proxy:
+                if is_valid_cidr(proxy_ip):
+                    if address_in_network(parsed.hostname, proxy_ip):
+                        return True
+                elif parsed.hostname == proxy_ip:
+                    # If no_proxy ip was defined in plain IP notation instead of cidr notation &
+                    # matches the IP of the index
+                    return True
+        else:
+            host_with_port = parsed.hostname
+            if parsed.port:
+                host_with_port += ':{}'.format(parsed.port)
+
+            for host in no_proxy:
+                if parsed.hostname.endswith(host) or host_with_port.endswith(host):
+                    # The URL does match something in no_proxy, so we don't want
+                    # to apply the proxies on this URL.
+                    return True
+
+    with set_environ('no_proxy', no_proxy_arg):
+        # parsed.hostname can be `None` in cases such as a file URI.
+        try:
+            bypass = proxy_bypass(parsed.hostname)
+        except (TypeError, socket.gaierror):
+            bypass = False
+
+    if bypass:
+        return True
+
+    return False
+
+
+def get_environ_proxies(url, no_proxy=None):
+    """
+    Return a dict of environment proxies.
+
+    :rtype: dict
+    """
+    if should_bypass_proxies(url, no_proxy=no_proxy):
+        return {}
+    else:
+        return getproxies()
+
+
+def select_proxy(url, proxies):
+    """Select a proxy for the url, if applicable.
+
+    :param url: The url being for the request
+    :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
+    """
+    proxies = proxies or {}
+    urlparts = urlparse(url)
+    if urlparts.hostname is None:
+        return proxies.get(urlparts.scheme, proxies.get('all'))
+
+    proxy_keys = [
+        urlparts.scheme + '://' + urlparts.hostname,
+        urlparts.scheme,
+        'all://' + urlparts.hostname,
+        'all',
+    ]
+    proxy = None
+    for proxy_key in proxy_keys:
+        if proxy_key in proxies:
+            proxy = proxies[proxy_key]
+            break
+
+    return proxy
+
+
+def default_user_agent(name="python-requests"):
+    """
+    Return a string representing the default user agent.
+
+    :rtype: str
+    """
+    return '%s/%s' % (name, __version__)
+
+
+def default_headers():
+    """
+    :rtype: requests.structures.CaseInsensitiveDict
+    """
+    return CaseInsensitiveDict({
+        'User-Agent': default_user_agent(),
+        'Accept-Encoding': ', '.join(('gzip', 'deflate')),
+        'Accept': '*/*',
+        'Connection': 'keep-alive',
+    })
+
+
+def parse_header_links(value):
+    """Return a list of parsed link headers proxies.
+
+    i.e. Link: <http:/.../front.jpeg>; rel=front; type="image/jpeg",<http://.../back.jpeg>; rel=back;type="image/jpeg"
+
+    :rtype: list
+    """
+
+    links = []
+
+    replace_chars = ' \'"'
+
+    value = value.strip(replace_chars)
+    if not value:
+        return links
+
+    for val in re.split(', *<', value):
+        try:
+            url, params = val.split(';', 1)
+        except ValueError:
+            url, params = val, ''
+
+        link = {'url': url.strip('<> \'"')}
+
+        for param in params.split(';'):
+            try:
+                key, value = param.split('=')
+            except ValueError:
+                break
+
+            link[key.strip(replace_chars)] = value.strip(replace_chars)
+
+        links.append(link)
+
+    return links
+
+
+# Null bytes; no need to recreate these on each call to guess_json_utf
+_null = '\x00'.encode('ascii')  # encoding to ASCII for Python 3
+_null2 = _null * 2
+_null3 = _null * 3
+
+
+def guess_json_utf(data):
+    """
+    :rtype: str
+    """
+    # JSON always starts with two ASCII characters, so detection is as
+    # easy as counting the nulls and from their location and count
+    # determine the encoding. Also detect a BOM, if present.
+    sample = data[:4]
+    if sample in (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE):
+        return 'utf-32'     # BOM included
+    if sample[:3] == codecs.BOM_UTF8:
+        return 'utf-8-sig'  # BOM included, MS style (discouraged)
+    if sample[:2] in (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE):
+        return 'utf-16'     # BOM included
+    nullcount = sample.count(_null)
+    if nullcount == 0:
+        return 'utf-8'
+    if nullcount == 2:
+        if sample[::2] == _null2:   # 1st and 3rd are null
+            return 'utf-16-be'
+        if sample[1::2] == _null2:  # 2nd and 4th are null
+            return 'utf-16-le'
+        # Did not detect 2 valid UTF-16 ascii-range characters
+    if nullcount == 3:
+        if sample[:3] == _null3:
+            return 'utf-32-be'
+        if sample[1:] == _null3:
+            return 'utf-32-le'
+        # Did not detect a valid UTF-32 ascii-range character
+    return None
+
+
+def prepend_scheme_if_needed(url, new_scheme):
+    """Given a URL that may or may not have a scheme, prepend the given scheme.
+    Does not replace a present scheme with the one provided as an argument.
+
+    :rtype: str
+    """
+    scheme, netloc, path, params, query, fragment = urlparse(url, new_scheme)
+
+    # urlparse is a finicky beast, and sometimes decides that there isn't a
+    # netloc present. Assume that it's being over-cautious, and switch netloc
+    # and path if urlparse decided there was no netloc.
+    if not netloc:
+        netloc, path = path, netloc
+
+    return urlunparse((scheme, netloc, path, params, query, fragment))
+
+
+def get_auth_from_url(url):
+    """Given a url with authentication components, extract them into a tuple of
+    username,password.
+
+    :rtype: (str,str)
+    """
+    parsed = urlparse(url)
+
+    try:
+        auth = (unquote(parsed.username), unquote(parsed.password))
+    except (AttributeError, TypeError):
+        auth = ('', '')
+
+    return auth
+
+
+# Moved outside of function to avoid recompile every call
+_CLEAN_HEADER_REGEX_BYTE = re.compile(b'^\\S[^\\r\\n]*$|^$')
+_CLEAN_HEADER_REGEX_STR = re.compile(r'^\S[^\r\n]*$|^$')
+
+
+def check_header_validity(header):
+    """Verifies that header value is a string which doesn't contain
+    leading whitespace or return characters. This prevents unintended
+    header injection.
+
+    :param header: tuple, in the format (name, value).
+    """
+    name, value = header
+
+    if isinstance(value, bytes):
+        pat = _CLEAN_HEADER_REGEX_BYTE
+    else:
+        pat = _CLEAN_HEADER_REGEX_STR
+    try:
+        if not pat.match(value):
+            raise InvalidHeader("Invalid return character or leading space in header: %s" % name)
+    except TypeError:
+        raise InvalidHeader("Value for header {%s: %s} must be of type str or "
+                            "bytes, not %s" % (name, value, type(value)))
+
+
+def urldefragauth(url):
+    """
+    Given a url remove the fragment and the authentication part.
+
+    :rtype: str
+    """
+    scheme, netloc, path, params, query, fragment = urlparse(url)
+
+    # see func:`prepend_scheme_if_needed`
+    if not netloc:
+        netloc, path = path, netloc
+
+    netloc = netloc.rsplit('@', 1)[-1]
+
+    return urlunparse((scheme, netloc, path, params, query, ''))
+
+
+def rewind_body(prepared_request):
+    """Move file pointer back to its recorded starting position
+    so it can be read again on redirect.
+    """
+    body_seek = getattr(prepared_request.body, 'seek', None)
+    if body_seek is not None and isinstance(prepared_request._body_position, integer_types):
+        try:
+            body_seek(prepared_request._body_position)
+        except (IOError, OSError):
+            raise UnrewindableBodyError("An error occurred when rewinding request "
+                                        "body for redirect.")
+    else:
+        raise UnrewindableBodyError("Unable to rewind request body for redirect.")
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/__init__.py
new file mode 100644
index 0000000..3b44454
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/__init__.py
@@ -0,0 +1,26 @@
+__all__ = [
+    "__version__",
+    "AbstractProvider",
+    "AbstractResolver",
+    "BaseReporter",
+    "InconsistentCandidate",
+    "Resolver",
+    "RequirementsConflicted",
+    "ResolutionError",
+    "ResolutionImpossible",
+    "ResolutionTooDeep",
+]
+
+__version__ = "0.4.0"
+
+
+from .providers import AbstractProvider, AbstractResolver
+from .reporters import BaseReporter
+from .resolvers import (
+    InconsistentCandidate,
+    RequirementsConflicted,
+    Resolver,
+    ResolutionError,
+    ResolutionImpossible,
+    ResolutionTooDeep,
+)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/compat/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/compat/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/compat/collections_abc.py b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/compat/collections_abc.py
new file mode 100644
index 0000000..366cc5e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/compat/collections_abc.py
@@ -0,0 +1,6 @@
+__all__ = ["Sequence"]
+
+try:
+    from collections.abc import Sequence
+except ImportError:
+    from collections import Sequence
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/providers.py b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/providers.py
new file mode 100644
index 0000000..68b7290
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/providers.py
@@ -0,0 +1,109 @@
+class AbstractProvider(object):
+    """Delegate class to provide requirement interface for the resolver.
+    """
+
+    def identify(self, dependency):
+        """Given a dependency, return an identifier for it.
+
+        This is used in many places to identify the dependency, e.g. whether
+        two requirements should have their specifier parts merged, whether
+        two specifications would conflict with each other (because they the
+        same name but different versions).
+        """
+        raise NotImplementedError
+
+    def get_preference(self, resolution, candidates, information):
+        """Produce a sort key for given specification based on preference.
+
+        The preference is defined as "I think this requirement should be
+        resolved first". The lower the return value is, the more preferred
+        this group of arguments is.
+
+        :param resolution: Currently pinned candidate, or `None`.
+        :param candidates: A list of possible candidates.
+        :param information: A list of requirement information.
+
+        Each information instance is a named tuple with two entries:
+
+        * `requirement` specifies a requirement contributing to the current
+          candidate list
+        * `parent` specifies the candidate that provides (dependend on) the
+          requirement, or `None` to indicate a root requirement.
+
+        The preference could depend on a various of issues, including (not
+        necessarily in this order):
+
+        * Is this package pinned in the current resolution result?
+        * How relaxed is the requirement? Stricter ones should probably be
+          worked on first? (I don't know, actually.)
+        * How many possibilities are there to satisfy this requirement? Those
+          with few left should likely be worked on first, I guess?
+        * Are there any known conflicts for this requirement? We should
+          probably work on those with the most known conflicts.
+
+        A sortable value should be returned (this will be used as the `key`
+        parameter of the built-in sorting function). The smaller the value is,
+        the more preferred this specification is (i.e. the sorting function
+        is called with `reverse=False`).
+        """
+        raise NotImplementedError
+
+    def find_matches(self, requirements):
+        """Find all possible candidates that satisfy the given requirements.
+
+        This should try to get candidates based on the requirements' types.
+        For VCS, local, and archive requirements, the one-and-only match is
+        returned, and for a "named" requirement, the index(es) should be
+        consulted to find concrete candidates for this requirement.
+
+        :param requirements: A collection of requirements which all of the the
+            returned candidates must match. All requirements are guaranteed to
+            have the same identifier. The collection is never empty.
+        :returns: An iterable that orders candidates by preference, e.g. the
+            most preferred candidate should come first.
+        """
+        raise NotImplementedError
+
+    def is_satisfied_by(self, requirement, candidate):
+        """Whether the given requirement can be satisfied by a candidate.
+
+        The candidate is guarenteed to have been generated from the
+        requirement.
+
+        A boolean should be returned to indicate whether `candidate` is a
+        viable solution to the requirement.
+        """
+        raise NotImplementedError
+
+    def get_dependencies(self, candidate):
+        """Get dependencies of a candidate.
+
+        This should return a collection of requirements that `candidate`
+        specifies as its dependencies.
+        """
+        raise NotImplementedError
+
+
+class AbstractResolver(object):
+    """The thing that performs the actual resolution work.
+    """
+
+    base_exception = Exception
+
+    def __init__(self, provider, reporter):
+        self.provider = provider
+        self.reporter = reporter
+
+    def resolve(self, requirements, **kwargs):
+        """Take a collection of constraints, spit out the resolution result.
+
+        This returns a representation of the final resolution state, with one
+        guarenteed attribute ``mapping`` that contains resolved candidates as
+        values. The keys are their respective identifiers.
+
+        :param requirements: A collection of constraints.
+        :param kwargs: Additional keyword arguments that subclasses may accept.
+
+        :raises: ``self.base_exception`` or its subclass.
+        """
+        raise NotImplementedError
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/reporters.py b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/reporters.py
new file mode 100644
index 0000000..a0a2a45
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/reporters.py
@@ -0,0 +1,42 @@
+class BaseReporter(object):
+    """Delegate class to provider progress reporting for the resolver.
+    """
+
+    def starting(self):
+        """Called before the resolution actually starts.
+        """
+
+    def starting_round(self, index):
+        """Called before each round of resolution starts.
+
+        The index is zero-based.
+        """
+
+    def ending_round(self, index, state):
+        """Called before each round of resolution ends.
+
+        This is NOT called if the resolution ends at this round. Use `ending`
+        if you want to report finalization. The index is zero-based.
+        """
+
+    def ending(self, state):
+        """Called before the resolution ends successfully.
+        """
+
+    def adding_requirement(self, requirement, parent):
+        """Called when adding a new requirement into the resolve criteria.
+
+        :param requirement: The additional requirement to be applied to filter
+            the available candidaites.
+        :param parent: The candidate that requires ``requirement`` as a
+            dependency, or None if ``requirement`` is one of the root
+            requirements passed in from ``Resolver.resolve()``.
+        """
+
+    def backtracking(self, candidate):
+        """Called when rejecting a candidate during backtracking.
+        """
+
+    def pinning(self, candidate):
+        """Called when adding a candidate to the potential solution.
+        """
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/resolvers.py b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/resolvers.py
new file mode 100644
index 0000000..4497f97
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/resolvers.py
@@ -0,0 +1,428 @@
+import collections
+
+from .compat import collections_abc
+from .providers import AbstractResolver
+from .structs import DirectedGraph
+
+
+RequirementInformation = collections.namedtuple(
+    "RequirementInformation", ["requirement", "parent"]
+)
+
+
+class ResolverException(Exception):
+    """A base class for all exceptions raised by this module.
+
+    Exceptions derived by this class should all be handled in this module. Any
+    bubbling pass the resolver should be treated as a bug.
+    """
+
+
+class RequirementsConflicted(ResolverException):
+    def __init__(self, criterion):
+        super(RequirementsConflicted, self).__init__(criterion)
+        self.criterion = criterion
+
+    def __str__(self):
+        return "Requirements conflict: {}".format(
+            ", ".join(repr(r) for r in self.criterion.iter_requirement()),
+        )
+
+
+class InconsistentCandidate(ResolverException):
+    def __init__(self, candidate, criterion):
+        super(InconsistentCandidate, self).__init__(candidate, criterion)
+        self.candidate = candidate
+        self.criterion = criterion
+
+    def __str__(self):
+        return "Provided candidate {!r} does not satisfy {}".format(
+            self.candidate,
+            ", ".join(repr(r) for r in self.criterion.iter_requirement()),
+        )
+
+
+class Criterion(object):
+    """Representation of possible resolution results of a package.
+
+    This holds three attributes:
+
+    * `information` is a collection of `RequirementInformation` pairs.
+      Each pair is a requirement contributing to this criterion, and the
+      candidate that provides the requirement.
+    * `incompatibilities` is a collection of all known not-to-work candidates
+      to exclude from consideration.
+    * `candidates` is a collection containing all possible candidates deducted
+      from the union of contributing requirements and known incompatibilities.
+      It should never be empty, except when the criterion is an attribute of a
+      raised `RequirementsConflicted` (in which case it is always empty).
+
+    .. note::
+        This class is intended to be externally immutable. **Do not** mutate
+        any of its attribute containers.
+    """
+
+    def __init__(self, candidates, information, incompatibilities):
+        self.candidates = candidates
+        self.information = information
+        self.incompatibilities = incompatibilities
+
+    def __repr__(self):
+        requirements = ", ".join(
+            "({!r}, via={!r})".format(req, parent)
+            for req, parent in self.information
+        )
+        return "Criterion({})".format(requirements)
+
+    @classmethod
+    def from_requirement(cls, provider, requirement, parent):
+        """Build an instance from a requirement.
+        """
+        candidates = provider.find_matches([requirement])
+        if not isinstance(candidates, collections_abc.Sequence):
+            candidates = list(candidates)
+        criterion = cls(
+            candidates=candidates,
+            information=[RequirementInformation(requirement, parent)],
+            incompatibilities=[],
+        )
+        if not candidates:
+            raise RequirementsConflicted(criterion)
+        return criterion
+
+    def iter_requirement(self):
+        return (i.requirement for i in self.information)
+
+    def iter_parent(self):
+        return (i.parent for i in self.information)
+
+    def merged_with(self, provider, requirement, parent):
+        """Build a new instance from this and a new requirement.
+        """
+        infos = list(self.information)
+        infos.append(RequirementInformation(requirement, parent))
+        candidates = provider.find_matches([r for r, _ in infos])
+        if not isinstance(candidates, collections_abc.Sequence):
+            candidates = list(candidates)
+        criterion = type(self)(candidates, infos, list(self.incompatibilities))
+        if not candidates:
+            raise RequirementsConflicted(criterion)
+        return criterion
+
+    def excluded_of(self, candidate):
+        """Build a new instance from this, but excluding specified candidate.
+
+        Returns the new instance, or None if we still have no valid candidates.
+        """
+        incompats = list(self.incompatibilities)
+        incompats.append(candidate)
+        candidates = [c for c in self.candidates if c != candidate]
+        if not candidates:
+            return None
+        criterion = type(self)(candidates, list(self.information), incompats)
+        return criterion
+
+
+class ResolutionError(ResolverException):
+    pass
+
+
+class ResolutionImpossible(ResolutionError):
+    def __init__(self, causes):
+        super(ResolutionImpossible, self).__init__(causes)
+        # causes is a list of RequirementInformation objects
+        self.causes = causes
+
+
+class ResolutionTooDeep(ResolutionError):
+    def __init__(self, round_count):
+        super(ResolutionTooDeep, self).__init__(round_count)
+        self.round_count = round_count
+
+
+# Resolution state in a round.
+State = collections.namedtuple("State", "mapping criteria")
+
+
+class Resolution(object):
+    """Stateful resolution object.
+
+    This is designed as a one-off object that holds information to kick start
+    the resolution process, and holds the results afterwards.
+    """
+
+    def __init__(self, provider, reporter):
+        self._p = provider
+        self._r = reporter
+        self._states = []
+
+    @property
+    def state(self):
+        try:
+            return self._states[-1]
+        except IndexError:
+            raise AttributeError("state")
+
+    def _push_new_state(self):
+        """Push a new state into history.
+
+        This new state will be used to hold resolution results of the next
+        coming round.
+        """
+        try:
+            base = self._states[-1]
+        except IndexError:
+            state = State(mapping=collections.OrderedDict(), criteria={})
+        else:
+            state = State(
+                mapping=base.mapping.copy(), criteria=base.criteria.copy(),
+            )
+        self._states.append(state)
+
+    def _merge_into_criterion(self, requirement, parent):
+        self._r.adding_requirement(requirement, parent)
+        name = self._p.identify(requirement)
+        try:
+            crit = self.state.criteria[name]
+        except KeyError:
+            crit = Criterion.from_requirement(self._p, requirement, parent)
+        else:
+            crit = crit.merged_with(self._p, requirement, parent)
+        return name, crit
+
+    def _get_criterion_item_preference(self, item):
+        name, criterion = item
+        try:
+            pinned = self.state.mapping[name]
+        except KeyError:
+            pinned = None
+        return self._p.get_preference(
+            pinned, criterion.candidates, criterion.information,
+        )
+
+    def _is_current_pin_satisfying(self, name, criterion):
+        try:
+            current_pin = self.state.mapping[name]
+        except KeyError:
+            return False
+        return all(
+            self._p.is_satisfied_by(r, current_pin)
+            for r in criterion.iter_requirement()
+        )
+
+    def _get_criteria_to_update(self, candidate):
+        criteria = {}
+        for r in self._p.get_dependencies(candidate):
+            name, crit = self._merge_into_criterion(r, parent=candidate)
+            criteria[name] = crit
+        return criteria
+
+    def _attempt_to_pin_criterion(self, name, criterion):
+        causes = []
+        for candidate in criterion.candidates:
+            try:
+                criteria = self._get_criteria_to_update(candidate)
+            except RequirementsConflicted as e:
+                causes.append(e.criterion)
+                continue
+
+            # Check the newly-pinned candidate actually works. This should
+            # always pass under normal circumstances, but in the case of a
+            # faulty provider, we will raise an error to notify the implementer
+            # to fix find_matches() and/or is_satisfied_by().
+            satisfied = all(
+                self._p.is_satisfied_by(r, candidate)
+                for r in criterion.iter_requirement()
+            )
+            if not satisfied:
+                raise InconsistentCandidate(candidate, criterion)
+
+            # Put newly-pinned candidate at the end. This is essential because
+            # backtracking looks at this mapping to get the last pin.
+            self._r.pinning(candidate)
+            self.state.mapping.pop(name, None)
+            self.state.mapping[name] = candidate
+            self.state.criteria.update(criteria)
+
+            return []
+
+        # All candidates tried, nothing works. This criterion is a dead
+        # end, signal for backtracking.
+        return causes
+
+    def _backtrack(self):
+        # Drop the current state, it's known not to work.
+        del self._states[-1]
+
+        # We need at least 2 states here:
+        # (a) One to backtrack to.
+        # (b) One to restore state (a) to its state prior to candidate-pinning,
+        #     so we can pin another one instead.
+
+        while len(self._states) >= 2:
+            # Retract the last candidate pin.
+            prev_state = self._states.pop()
+            try:
+                name, candidate = prev_state.mapping.popitem()
+            except KeyError:
+                continue
+            self._r.backtracking(candidate)
+
+            # Create a new state to work on, with the newly known not-working
+            # candidate excluded.
+            self._push_new_state()
+
+            # Mark the retracted candidate as incompatible.
+            criterion = self.state.criteria[name].excluded_of(candidate)
+            if criterion is None:
+                # This state still does not work. Try the still previous state.
+                del self._states[-1]
+                continue
+            self.state.criteria[name] = criterion
+
+            return True
+
+        return False
+
+    def resolve(self, requirements, max_rounds):
+        if self._states:
+            raise RuntimeError("already resolved")
+
+        self._push_new_state()
+        for r in requirements:
+            try:
+                name, crit = self._merge_into_criterion(r, parent=None)
+            except RequirementsConflicted as e:
+                raise ResolutionImpossible(e.criterion.information)
+            self.state.criteria[name] = crit
+
+        self._r.starting()
+
+        for round_index in range(max_rounds):
+            self._r.starting_round(round_index)
+
+            self._push_new_state()
+            curr = self.state
+
+            unsatisfied_criterion_items = [
+                item
+                for item in self.state.criteria.items()
+                if not self._is_current_pin_satisfying(*item)
+            ]
+
+            # All criteria are accounted for. Nothing more to pin, we are done!
+            if not unsatisfied_criterion_items:
+                del self._states[-1]
+                self._r.ending(curr)
+                return self.state
+
+            # Choose the most preferred unpinned criterion to try.
+            name, criterion = min(
+                unsatisfied_criterion_items,
+                key=self._get_criterion_item_preference,
+            )
+            failure_causes = self._attempt_to_pin_criterion(name, criterion)
+
+            # Backtrack if pinning fails.
+            if failure_causes:
+                result = self._backtrack()
+                if not result:
+                    causes = [
+                        i for crit in failure_causes for i in crit.information
+                    ]
+                    raise ResolutionImpossible(causes)
+
+            self._r.ending_round(round_index, curr)
+
+        raise ResolutionTooDeep(max_rounds)
+
+
+def _has_route_to_root(criteria, key, all_keys, connected):
+    if key in connected:
+        return True
+    if key not in criteria:
+        return False
+    for p in criteria[key].iter_parent():
+        try:
+            pkey = all_keys[id(p)]
+        except KeyError:
+            continue
+        if pkey in connected:
+            connected.add(key)
+            return True
+        if _has_route_to_root(criteria, pkey, all_keys, connected):
+            connected.add(key)
+            return True
+    return False
+
+
+Result = collections.namedtuple("Result", "mapping graph criteria")
+
+
+def _build_result(state):
+    mapping = state.mapping
+    all_keys = {id(v): k for k, v in mapping.items()}
+    all_keys[id(None)] = None
+
+    graph = DirectedGraph()
+    graph.add(None)  # Sentinel as root dependencies' parent.
+
+    connected = {None}
+    for key, criterion in state.criteria.items():
+        if not _has_route_to_root(state.criteria, key, all_keys, connected):
+            continue
+        if key not in graph:
+            graph.add(key)
+        for p in criterion.iter_parent():
+            try:
+                pkey = all_keys[id(p)]
+            except KeyError:
+                continue
+            if pkey not in graph:
+                graph.add(pkey)
+            graph.connect(pkey, key)
+
+    return Result(
+        mapping={k: v for k, v in mapping.items() if k in connected},
+        graph=graph,
+        criteria=state.criteria,
+    )
+
+
+class Resolver(AbstractResolver):
+    """The thing that performs the actual resolution work.
+    """
+
+    base_exception = ResolverException
+
+    def resolve(self, requirements, max_rounds=100):
+        """Take a collection of constraints, spit out the resolution result.
+
+        The return value is a representation to the final resolution result. It
+        is a tuple subclass with three public members:
+
+        * `mapping`: A dict of resolved candidates. Each key is an identifier
+            of a requirement (as returned by the provider's `identify` method),
+            and the value is the resolved candidate.
+        * `graph`: A `DirectedGraph` instance representing the dependency tree.
+            The vertices are keys of `mapping`, and each edge represents *why*
+            a particular package is included. A special vertex `None` is
+            included to represent parents of user-supplied requirements.
+        * `criteria`: A dict of "criteria" that hold detailed information on
+            how edges in the graph are derived. Each key is an identifier of a
+            requirement, and the value is a `Criterion` instance.
+
+        The following exceptions may be raised if a resolution cannot be found:
+
+        * `ResolutionImpossible`: A resolution cannot be found for the given
+            combination of requirements. The `causes` attribute of the
+            exception is a list of (requirement, parent), giving the
+            requirements that could not be satisfied.
+        * `ResolutionTooDeep`: The dependency tree is too deeply nested and
+            the resolver gave up. This is usually caused by a circular
+            dependency, but you can try to resolve this by increasing the
+            `max_rounds` argument.
+        """
+        resolution = Resolution(self.provider, self.reporter)
+        state = resolution.resolve(requirements, max_rounds=max_rounds)
+        return _build_result(state)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/structs.py b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/structs.py
new file mode 100644
index 0000000..1eee08b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/resolvelib/structs.py
@@ -0,0 +1,68 @@
+class DirectedGraph(object):
+    """A graph structure with directed edges.
+    """
+
+    def __init__(self):
+        self._vertices = set()
+        self._forwards = {}  # <key> -> Set[<key>]
+        self._backwards = {}  # <key> -> Set[<key>]
+
+    def __iter__(self):
+        return iter(self._vertices)
+
+    def __len__(self):
+        return len(self._vertices)
+
+    def __contains__(self, key):
+        return key in self._vertices
+
+    def copy(self):
+        """Return a shallow copy of this graph.
+        """
+        other = DirectedGraph()
+        other._vertices = set(self._vertices)
+        other._forwards = {k: set(v) for k, v in self._forwards.items()}
+        other._backwards = {k: set(v) for k, v in self._backwards.items()}
+        return other
+
+    def add(self, key):
+        """Add a new vertex to the graph.
+        """
+        if key in self._vertices:
+            raise ValueError("vertex exists")
+        self._vertices.add(key)
+        self._forwards[key] = set()
+        self._backwards[key] = set()
+
+    def remove(self, key):
+        """Remove a vertex from the graph, disconnecting all edges from/to it.
+        """
+        self._vertices.remove(key)
+        for f in self._forwards.pop(key):
+            self._backwards[f].remove(key)
+        for t in self._backwards.pop(key):
+            self._forwards[t].remove(key)
+
+    def connected(self, f, t):
+        return f in self._backwards[t] and t in self._forwards[f]
+
+    def connect(self, f, t):
+        """Connect two existing vertices.
+
+        Nothing happens if the vertices are already connected.
+        """
+        if t not in self._vertices:
+            raise KeyError(t)
+        self._forwards[f].add(t)
+        self._backwards[t].add(f)
+
+    def iter_edges(self):
+        for f, children in self._forwards.items():
+            for t in children:
+                yield f, t
+
+    def iter_children(self, key):
+        return iter(self._forwards[key])
+
+    def iter_parents(self, key):
+        return iter(self._backwards[key])
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/retrying.py b/myenv/lib/python3.9/site-packages/pip/_vendor/retrying.py
new file mode 100644
index 0000000..6d1e627
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/retrying.py
@@ -0,0 +1,267 @@
+## Copyright 2013-2014 Ray Holder
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+## http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+
+import random
+from pip._vendor import six
+import sys
+import time
+import traceback
+
+
+# sys.maxint / 2, since Python 3.2 doesn't have a sys.maxint...
+MAX_WAIT = 1073741823
+
+
+def retry(*dargs, **dkw):
+    """
+    Decorator function that instantiates the Retrying object
+    @param *dargs: positional arguments passed to Retrying object
+    @param **dkw: keyword arguments passed to the Retrying object
+    """
+    # support both @retry and @retry() as valid syntax
+    if len(dargs) == 1 and callable(dargs[0]):
+        def wrap_simple(f):
+
+            @six.wraps(f)
+            def wrapped_f(*args, **kw):
+                return Retrying().call(f, *args, **kw)
+
+            return wrapped_f
+
+        return wrap_simple(dargs[0])
+
+    else:
+        def wrap(f):
+
+            @six.wraps(f)
+            def wrapped_f(*args, **kw):
+                return Retrying(*dargs, **dkw).call(f, *args, **kw)
+
+            return wrapped_f
+
+        return wrap
+
+
+class Retrying(object):
+
+    def __init__(self,
+                 stop=None, wait=None,
+                 stop_max_attempt_number=None,
+                 stop_max_delay=None,
+                 wait_fixed=None,
+                 wait_random_min=None, wait_random_max=None,
+                 wait_incrementing_start=None, wait_incrementing_increment=None,
+                 wait_exponential_multiplier=None, wait_exponential_max=None,
+                 retry_on_exception=None,
+                 retry_on_result=None,
+                 wrap_exception=False,
+                 stop_func=None,
+                 wait_func=None,
+                 wait_jitter_max=None):
+
+        self._stop_max_attempt_number = 5 if stop_max_attempt_number is None else stop_max_attempt_number
+        self._stop_max_delay = 100 if stop_max_delay is None else stop_max_delay
+        self._wait_fixed = 1000 if wait_fixed is None else wait_fixed
+        self._wait_random_min = 0 if wait_random_min is None else wait_random_min
+        self._wait_random_max = 1000 if wait_random_max is None else wait_random_max
+        self._wait_incrementing_start = 0 if wait_incrementing_start is None else wait_incrementing_start
+        self._wait_incrementing_increment = 100 if wait_incrementing_increment is None else wait_incrementing_increment
+        self._wait_exponential_multiplier = 1 if wait_exponential_multiplier is None else wait_exponential_multiplier
+        self._wait_exponential_max = MAX_WAIT if wait_exponential_max is None else wait_exponential_max
+        self._wait_jitter_max = 0 if wait_jitter_max is None else wait_jitter_max
+
+        # TODO add chaining of stop behaviors
+        # stop behavior
+        stop_funcs = []
+        if stop_max_attempt_number is not None:
+            stop_funcs.append(self.stop_after_attempt)
+
+        if stop_max_delay is not None:
+            stop_funcs.append(self.stop_after_delay)
+
+        if stop_func is not None:
+            self.stop = stop_func
+
+        elif stop is None:
+            self.stop = lambda attempts, delay: any(f(attempts, delay) for f in stop_funcs)
+
+        else:
+            self.stop = getattr(self, stop)
+
+        # TODO add chaining of wait behaviors
+        # wait behavior
+        wait_funcs = [lambda *args, **kwargs: 0]
+        if wait_fixed is not None:
+            wait_funcs.append(self.fixed_sleep)
+
+        if wait_random_min is not None or wait_random_max is not None:
+            wait_funcs.append(self.random_sleep)
+
+        if wait_incrementing_start is not None or wait_incrementing_increment is not None:
+            wait_funcs.append(self.incrementing_sleep)
+
+        if wait_exponential_multiplier is not None or wait_exponential_max is not None:
+            wait_funcs.append(self.exponential_sleep)
+
+        if wait_func is not None:
+            self.wait = wait_func
+
+        elif wait is None:
+            self.wait = lambda attempts, delay: max(f(attempts, delay) for f in wait_funcs)
+
+        else:
+            self.wait = getattr(self, wait)
+
+        # retry on exception filter
+        if retry_on_exception is None:
+            self._retry_on_exception = self.always_reject
+        else:
+            self._retry_on_exception = retry_on_exception
+
+        # TODO simplify retrying by Exception types
+        # retry on result filter
+        if retry_on_result is None:
+            self._retry_on_result = self.never_reject
+        else:
+            self._retry_on_result = retry_on_result
+
+        self._wrap_exception = wrap_exception
+
+    def stop_after_attempt(self, previous_attempt_number, delay_since_first_attempt_ms):
+        """Stop after the previous attempt >= stop_max_attempt_number."""
+        return previous_attempt_number >= self._stop_max_attempt_number
+
+    def stop_after_delay(self, previous_attempt_number, delay_since_first_attempt_ms):
+        """Stop after the time from the first attempt >= stop_max_delay."""
+        return delay_since_first_attempt_ms >= self._stop_max_delay
+
+    def no_sleep(self, previous_attempt_number, delay_since_first_attempt_ms):
+        """Don't sleep at all before retrying."""
+        return 0
+
+    def fixed_sleep(self, previous_attempt_number, delay_since_first_attempt_ms):
+        """Sleep a fixed amount of time between each retry."""
+        return self._wait_fixed
+
+    def random_sleep(self, previous_attempt_number, delay_since_first_attempt_ms):
+        """Sleep a random amount of time between wait_random_min and wait_random_max"""
+        return random.randint(self._wait_random_min, self._wait_random_max)
+
+    def incrementing_sleep(self, previous_attempt_number, delay_since_first_attempt_ms):
+        """
+        Sleep an incremental amount of time after each attempt, starting at
+        wait_incrementing_start and incrementing by wait_incrementing_increment
+        """
+        result = self._wait_incrementing_start + (self._wait_incrementing_increment * (previous_attempt_number - 1))
+        if result < 0:
+            result = 0
+        return result
+
+    def exponential_sleep(self, previous_attempt_number, delay_since_first_attempt_ms):
+        exp = 2 ** previous_attempt_number
+        result = self._wait_exponential_multiplier * exp
+        if result > self._wait_exponential_max:
+            result = self._wait_exponential_max
+        if result < 0:
+            result = 0
+        return result
+
+    def never_reject(self, result):
+        return False
+
+    def always_reject(self, result):
+        return True
+
+    def should_reject(self, attempt):
+        reject = False
+        if attempt.has_exception:
+            reject |= self._retry_on_exception(attempt.value[1])
+        else:
+            reject |= self._retry_on_result(attempt.value)
+
+        return reject
+
+    def call(self, fn, *args, **kwargs):
+        start_time = int(round(time.time() * 1000))
+        attempt_number = 1
+        while True:
+            try:
+                attempt = Attempt(fn(*args, **kwargs), attempt_number, False)
+            except:
+                tb = sys.exc_info()
+                attempt = Attempt(tb, attempt_number, True)
+
+            if not self.should_reject(attempt):
+                return attempt.get(self._wrap_exception)
+
+            delay_since_first_attempt_ms = int(round(time.time() * 1000)) - start_time
+            if self.stop(attempt_number, delay_since_first_attempt_ms):
+                if not self._wrap_exception and attempt.has_exception:
+                    # get() on an attempt with an exception should cause it to be raised, but raise just in case
+                    raise attempt.get()
+                else:
+                    raise RetryError(attempt)
+            else:
+                sleep = self.wait(attempt_number, delay_since_first_attempt_ms)
+                if self._wait_jitter_max:
+                    jitter = random.random() * self._wait_jitter_max
+                    sleep = sleep + max(0, jitter)
+                time.sleep(sleep / 1000.0)
+
+            attempt_number += 1
+
+
+class Attempt(object):
+    """
+    An Attempt encapsulates a call to a target function that may end as a
+    normal return value from the function or an Exception depending on what
+    occurred during the execution.
+    """
+
+    def __init__(self, value, attempt_number, has_exception):
+        self.value = value
+        self.attempt_number = attempt_number
+        self.has_exception = has_exception
+
+    def get(self, wrap_exception=False):
+        """
+        Return the return value of this Attempt instance or raise an Exception.
+        If wrap_exception is true, this Attempt is wrapped inside of a
+        RetryError before being raised.
+        """
+        if self.has_exception:
+            if wrap_exception:
+                raise RetryError(self)
+            else:
+                six.reraise(self.value[0], self.value[1], self.value[2])
+        else:
+            return self.value
+
+    def __repr__(self):
+        if self.has_exception:
+            return "Attempts: {0}, Error:\n{1}".format(self.attempt_number, "".join(traceback.format_tb(self.value[2])))
+        else:
+            return "Attempts: {0}, Value: {1}".format(self.attempt_number, self.value)
+
+
+class RetryError(Exception):
+    """
+    A RetryError encapsulates the last Attempt instance right before giving up.
+    """
+
+    def __init__(self, last_attempt):
+        self.last_attempt = last_attempt
+
+    def __str__(self):
+        return "RetryError[{0}]".format(self.last_attempt)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/six.py b/myenv/lib/python3.9/site-packages/pip/_vendor/six.py
new file mode 100644
index 0000000..83f6978
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/six.py
@@ -0,0 +1,982 @@
+# Copyright (c) 2010-2020 Benjamin Peterson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+from __future__ import absolute_import
+
+import functools
+import itertools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.15.0"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+PY34 = sys.version_info[0:2] >= (3, 4)
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result)  # Invokes __set__.
+        try:
+            # This is a bit ugly, but it avoids running this again by
+            # removing this descriptor.
+            delattr(obj.__class__, self.name)
+        except AttributeError:
+            pass
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
+    MovedAttribute("getoutput", "commands", "subprocess"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("collections_abc", "collections", "collections.abc" if sys.version_info >= (3, 3) else "collections"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread" if sys.version_info < (3, 9) else "_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+]
+# Add windows specific modules.
+if sys.platform == "win32":
+    _moved_attributes += [
+        MovedModule("winreg", "_winreg"),
+    ]
+
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
+    MovedAttribute("splitvalue", "urllib", "urllib.parse"),
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+    MovedAttribute("parse_http_list", "urllib2", "urllib.request"),
+    MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"),
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    def create_unbound_method(func, cls):
+        return func
+
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    def create_unbound_method(func, cls):
+        return types.MethodType(func, None, cls)
+
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+
+    viewkeys = operator.methodcaller("keys")
+
+    viewvalues = operator.methodcaller("values")
+
+    viewitems = operator.methodcaller("items")
+else:
+    def iterkeys(d, **kw):
+        return d.iterkeys(**kw)
+
+    def itervalues(d, **kw):
+        return d.itervalues(**kw)
+
+    def iteritems(d, **kw):
+        return d.iteritems(**kw)
+
+    def iterlists(d, **kw):
+        return d.iterlists(**kw)
+
+    viewkeys = operator.methodcaller("viewkeys")
+
+    viewvalues = operator.methodcaller("viewvalues")
+
+    viewitems = operator.methodcaller("viewitems")
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+
+    def u(s):
+        return s
+    unichr = chr
+    import struct
+    int2byte = struct.Struct(">B").pack
+    del struct
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+    del io
+    _assertCountEqual = "assertCountEqual"
+    if sys.version_info[1] <= 1:
+        _assertRaisesRegex = "assertRaisesRegexp"
+        _assertRegex = "assertRegexpMatches"
+        _assertNotRegex = "assertNotRegexpMatches"
+    else:
+        _assertRaisesRegex = "assertRaisesRegex"
+        _assertRegex = "assertRegex"
+        _assertNotRegex = "assertNotRegex"
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
+
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
+
+    def byte2int(bs):
+        return ord(bs[0])
+
+    def indexbytes(buf, i):
+        return ord(buf[i])
+    iterbytes = functools.partial(itertools.imap, ord)
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
+    _assertCountEqual = "assertItemsEqual"
+    _assertRaisesRegex = "assertRaisesRegexp"
+    _assertRegex = "assertRegexpMatches"
+    _assertNotRegex = "assertNotRegexpMatches"
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+def assertCountEqual(self, *args, **kwargs):
+    return getattr(self, _assertCountEqual)(*args, **kwargs)
+
+
+def assertRaisesRegex(self, *args, **kwargs):
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
+
+
+def assertRegex(self, *args, **kwargs):
+    return getattr(self, _assertRegex)(*args, **kwargs)
+
+
+def assertNotRegex(self, *args, **kwargs):
+    return getattr(self, _assertNotRegex)(*args, **kwargs)
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+    def reraise(tp, value, tb=None):
+        try:
+            if value is None:
+                value = tp()
+            if value.__traceback__ is not tb:
+                raise value.with_traceback(tb)
+            raise value
+        finally:
+            value = None
+            tb = None
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+    exec_("""def reraise(tp, value, tb=None):
+    try:
+        raise tp, value, tb
+    finally:
+        tb = None
+""")
+
+
+if sys.version_info[:2] > (3,):
+    exec_("""def raise_from(value, from_value):
+    try:
+        raise value from from_value
+    finally:
+        value = None
+""")
+else:
+    def raise_from(value, from_value):
+        raise value
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
+                    isinstance(data, unicode) and
+                    fp.encoding is not None):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+if sys.version_info[:2] < (3, 3):
+    _print = print_
+
+    def print_(*args, **kwargs):
+        fp = kwargs.get("file", sys.stdout)
+        flush = kwargs.pop("flush", False)
+        _print(*args, **kwargs)
+        if flush and fp is not None:
+            fp.flush()
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+    # This does exactly the same what the :func:`py3:functools.update_wrapper`
+    # function does on Python versions after 3.2. It sets the ``__wrapped__``
+    # attribute on ``wrapper`` object and it doesn't raise an error if any of
+    # the attributes mentioned in ``assigned`` and ``updated`` are missing on
+    # ``wrapped`` object.
+    def _update_wrapper(wrapper, wrapped,
+                        assigned=functools.WRAPPER_ASSIGNMENTS,
+                        updated=functools.WRAPPER_UPDATES):
+        for attr in assigned:
+            try:
+                value = getattr(wrapped, attr)
+            except AttributeError:
+                continue
+            else:
+                setattr(wrapper, attr, value)
+        for attr in updated:
+            getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
+        wrapper.__wrapped__ = wrapped
+        return wrapper
+    _update_wrapper.__doc__ = functools.update_wrapper.__doc__
+
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+              updated=functools.WRAPPER_UPDATES):
+        return functools.partial(_update_wrapper, wrapped=wrapped,
+                                 assigned=assigned, updated=updated)
+    wraps.__doc__ = functools.wraps.__doc__
+
+else:
+    wraps = functools.wraps
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(type):
+
+        def __new__(cls, name, this_bases, d):
+            if sys.version_info[:2] >= (3, 7):
+                # This version introduced PEP 560 that requires a bit
+                # of extra care (we mimic what is done by __build_class__).
+                resolved_bases = types.resolve_bases(bases)
+                if resolved_bases is not bases:
+                    d['__orig_bases__'] = bases
+            else:
+                resolved_bases = bases
+            return meta(name, resolved_bases, d)
+
+        @classmethod
+        def __prepare__(cls, name, this_bases):
+            return meta.__prepare__(name, bases)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        if hasattr(cls, '__qualname__'):
+            orig_vars['__qualname__'] = cls.__qualname__
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
+
+def ensure_binary(s, encoding='utf-8', errors='strict'):
+    """Coerce **s** to six.binary_type.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> encoded to `bytes`
+      - `bytes` -> `bytes`
+    """
+    if isinstance(s, binary_type):
+        return s
+    if isinstance(s, text_type):
+        return s.encode(encoding, errors)
+    raise TypeError("not expecting type '%s'" % type(s))
+
+
+def ensure_str(s, encoding='utf-8', errors='strict'):
+    """Coerce *s* to `str`.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    # Optimization: Fast return for the common case.
+    if type(s) is str:
+        return s
+    if PY2 and isinstance(s, text_type):
+        return s.encode(encoding, errors)
+    elif PY3 and isinstance(s, binary_type):
+        return s.decode(encoding, errors)
+    elif not isinstance(s, (text_type, binary_type)):
+        raise TypeError("not expecting type '%s'" % type(s))
+    return s
+
+
+def ensure_text(s, encoding='utf-8', errors='strict'):
+    """Coerce *s* to six.text_type.
+
+    For Python 2:
+      - `unicode` -> `unicode`
+      - `str` -> `unicode`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    if isinstance(s, binary_type):
+        return s.decode(encoding, errors)
+    elif isinstance(s, text_type):
+        return s
+    else:
+        raise TypeError("not expecting type '%s'" % type(s))
+
+
+def python_2_unicode_compatible(klass):
+    """
+    A class decorator that defines __unicode__ and __str__ methods under Python 2.
+    Under Python 3 it does nothing.
+
+    To support Python 2 and 3 with a single code base, define a __str__ method
+    returning text and apply this decorator to the class.
+    """
+    if PY2:
+        if '__str__' not in klass.__dict__:
+            raise ValueError("@python_2_unicode_compatible cannot be applied "
+                             "to %s because it doesn't define __str__()." %
+                             klass.__name__)
+        klass.__unicode__ = klass.__str__
+        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
+    return klass
+
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
+                importer.name == __name__):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/toml/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/__init__.py
new file mode 100644
index 0000000..7a08fe7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/__init__.py
@@ -0,0 +1,25 @@
+"""Python module which parses and emits TOML.
+
+Released under the MIT license.
+"""
+
+from pip._vendor.toml import encoder
+from pip._vendor.toml import decoder
+
+__version__ = "0.10.1"
+_spec_ = "0.5.0"
+
+load = decoder.load
+loads = decoder.loads
+TomlDecoder = decoder.TomlDecoder
+TomlDecodeError = decoder.TomlDecodeError
+TomlPreserveCommentDecoder = decoder.TomlPreserveCommentDecoder
+
+dump = encoder.dump
+dumps = encoder.dumps
+TomlEncoder = encoder.TomlEncoder
+TomlArraySeparatorEncoder = encoder.TomlArraySeparatorEncoder
+TomlPreserveInlineDictEncoder = encoder.TomlPreserveInlineDictEncoder
+TomlNumpyEncoder = encoder.TomlNumpyEncoder
+TomlPreserveCommentEncoder = encoder.TomlPreserveCommentEncoder
+TomlPathlibEncoder = encoder.TomlPathlibEncoder
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/toml/common.py b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/common.py
new file mode 100644
index 0000000..a5d673d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/common.py
@@ -0,0 +1,6 @@
+# content after the \
+escapes = ['0', 'b', 'f', 'n', 'r', 't', '"']
+# What it should be replaced by
+escapedchars = ['\0', '\b', '\f', '\n', '\r', '\t', '\"']
+# Used for substitution
+escape_to_escapedchars = dict(zip(_escapes, _escapedchars))
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/toml/decoder.py b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/decoder.py
new file mode 100644
index 0000000..e488777
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/decoder.py
@@ -0,0 +1,1052 @@
+import datetime
+import io
+from os import linesep
+import re
+import sys
+
+from pip._vendor.toml.tz import TomlTz
+
+if sys.version_info < (3,):
+    _range = xrange  # noqa: F821
+else:
+    unicode = str
+    _range = range
+    basestring = str
+    unichr = chr
+
+
+def _detect_pathlib_path(p):
+    if (3, 4) <= sys.version_info:
+        import pathlib
+        if isinstance(p, pathlib.PurePath):
+            return True
+    return False
+
+
+def _ispath(p):
+    if isinstance(p, (bytes, basestring)):
+        return True
+    return _detect_pathlib_path(p)
+
+
+def _getpath(p):
+    if (3, 6) <= sys.version_info:
+        import os
+        return os.fspath(p)
+    if _detect_pathlib_path(p):
+        return str(p)
+    return p
+
+
+try:
+    FNFError = FileNotFoundError
+except NameError:
+    FNFError = IOError
+
+
+TIME_RE = re.compile(r"([0-9]{2}):([0-9]{2}):([0-9]{2})(\.([0-9]{3,6}))?")
+
+
+class TomlDecodeError(ValueError):
+    """Base toml Exception / Error."""
+
+    def __init__(self, msg, doc, pos):
+        lineno = doc.count('\n', 0, pos) + 1
+        colno = pos - doc.rfind('\n', 0, pos)
+        emsg = '{} (line {} column {} char {})'.format(msg, lineno, colno, pos)
+        ValueError.__init__(self, emsg)
+        self.msg = msg
+        self.doc = doc
+        self.pos = pos
+        self.lineno = lineno
+        self.colno = colno
+
+
+# Matches a TOML number, which allows underscores for readability
+_number_with_underscores = re.compile('([0-9])(_([0-9]))*')
+
+
+class CommentValue(object):
+    def __init__(self, val, comment, beginline, _dict):
+        self.val = val
+        separator = "\n" if beginline else " "
+        self.comment = separator + comment
+        self._dict = _dict
+
+    def __getitem__(self, key):
+        return self.val[key]
+
+    def __setitem__(self, key, value):
+        self.val[key] = value
+
+    def dump(self, dump_value_func):
+        retstr = dump_value_func(self.val)
+        if isinstance(self.val, self._dict):
+            return self.comment + "\n" + unicode(retstr)
+        else:
+            return unicode(retstr) + self.comment
+
+
+def _strictly_valid_num(n):
+    n = n.strip()
+    if not n:
+        return False
+    if n[0] == '_':
+        return False
+    if n[-1] == '_':
+        return False
+    if "_." in n or "._" in n:
+        return False
+    if len(n) == 1:
+        return True
+    if n[0] == '0' and n[1] not in ['.', 'o', 'b', 'x']:
+        return False
+    if n[0] == '+' or n[0] == '-':
+        n = n[1:]
+        if len(n) > 1 and n[0] == '0' and n[1] != '.':
+            return False
+    if '__' in n:
+        return False
+    return True
+
+
+def load(f, _dict=dict, decoder=None):
+    """Parses named file or files as toml and returns a dictionary
+
+    Args:
+        f: Path to the file to open, array of files to read into single dict
+           or a file descriptor
+        _dict: (optional) Specifies the class of the returned toml dictionary
+        decoder: The decoder to use
+
+    Returns:
+        Parsed toml file represented as a dictionary
+
+    Raises:
+        TypeError -- When f is invalid type
+        TomlDecodeError: Error while decoding toml
+        IOError / FileNotFoundError -- When an array with no valid (existing)
+        (Python 2 / Python 3)          file paths is passed
+    """
+
+    if _ispath(f):
+        with io.open(_getpath(f), encoding='utf-8') as ffile:
+            return loads(ffile.read(), _dict, decoder)
+    elif isinstance(f, list):
+        from os import path as op
+        from warnings import warn
+        if not [path for path in f if op.exists(path)]:
+            error_msg = "Load expects a list to contain filenames only."
+            error_msg += linesep
+            error_msg += ("The list needs to contain the path of at least one "
+                          "existing file.")
+            raise FNFError(error_msg)
+        if decoder is None:
+            decoder = TomlDecoder(_dict)
+        d = decoder.get_empty_table()
+        for l in f:  # noqa: E741
+            if op.exists(l):
+                d.update(load(l, _dict, decoder))
+            else:
+                warn("Non-existent filename in list with at least one valid "
+                     "filename")
+        return d
+    else:
+        try:
+            return loads(f.read(), _dict, decoder)
+        except AttributeError:
+            raise TypeError("You can only load a file descriptor, filename or "
+                            "list")
+
+
+_groupname_re = re.compile(r'^[A-Za-z0-9_-]+$')
+
+
+def loads(s, _dict=dict, decoder=None):
+    """Parses string as toml
+
+    Args:
+        s: String to be parsed
+        _dict: (optional) Specifies the class of the returned toml dictionary
+
+    Returns:
+        Parsed toml file represented as a dictionary
+
+    Raises:
+        TypeError: When a non-string is passed
+        TomlDecodeError: Error while decoding toml
+    """
+
+    implicitgroups = []
+    if decoder is None:
+        decoder = TomlDecoder(_dict)
+    retval = decoder.get_empty_table()
+    currentlevel = retval
+    if not isinstance(s, basestring):
+        raise TypeError("Expecting something like a string")
+
+    if not isinstance(s, unicode):
+        s = s.decode('utf8')
+
+    original = s
+    sl = list(s)
+    openarr = 0
+    openstring = False
+    openstrchar = ""
+    multilinestr = False
+    arrayoftables = False
+    beginline = True
+    keygroup = False
+    dottedkey = False
+    keyname = 0
+    key = ''
+    prev_key = ''
+    line_no = 1
+
+    for i, item in enumerate(sl):
+        if item == '\r' and sl[i + 1] == '\n':
+            sl[i] = ' '
+            continue
+        if keyname:
+            key += item
+            if item == '\n':
+                raise TomlDecodeError("Key name found without value."
+                                      " Reached end of line.", original, i)
+            if openstring:
+                if item == openstrchar:
+                    oddbackslash = False
+                    k = 1
+                    while i >= k and sl[i - k] == '\\':
+                        oddbackslash = not oddbackslash
+                        k += 1
+                    if not oddbackslash:
+                        keyname = 2
+                        openstring = False
+                        openstrchar = ""
+                continue
+            elif keyname == 1:
+                if item.isspace():
+                    keyname = 2
+                    continue
+                elif item == '.':
+                    dottedkey = True
+                    continue
+                elif item.isalnum() or item == '_' or item == '-':
+                    continue
+                elif (dottedkey and sl[i - 1] == '.' and
+                      (item == '"' or item == "'")):
+                    openstring = True
+                    openstrchar = item
+                    continue
+            elif keyname == 2:
+                if item.isspace():
+                    if dottedkey:
+                        nextitem = sl[i + 1]
+                        if not nextitem.isspace() and nextitem != '.':
+                            keyname = 1
+                    continue
+                if item == '.':
+                    dottedkey = True
+                    nextitem = sl[i + 1]
+                    if not nextitem.isspace() and nextitem != '.':
+                        keyname = 1
+                    continue
+            if item == '=':
+                keyname = 0
+                prev_key = key[:-1].rstrip()
+                key = ''
+                dottedkey = False
+            else:
+                raise TomlDecodeError("Found invalid character in key name: '" +
+                                      item + "'. Try quoting the key name.",
+                                      original, i)
+        if item == "'" and openstrchar != '"':
+            k = 1
+            try:
+                while sl[i - k] == "'":
+                    k += 1
+                    if k == 3:
+                        break
+            except IndexError:
+                pass
+            if k == 3:
+                multilinestr = not multilinestr
+                openstring = multilinestr
+            else:
+                openstring = not openstring
+            if openstring:
+                openstrchar = "'"
+            else:
+                openstrchar = ""
+        if item == '"' and openstrchar != "'":
+            oddbackslash = False
+            k = 1
+            tripquote = False
+            try:
+                while sl[i - k] == '"':
+                    k += 1
+                    if k == 3:
+                        tripquote = True
+                        break
+                if k == 1 or (k == 3 and tripquote):
+                    while sl[i - k] == '\\':
+                        oddbackslash = not oddbackslash
+                        k += 1
+            except IndexError:
+                pass
+            if not oddbackslash:
+                if tripquote:
+                    multilinestr = not multilinestr
+                    openstring = multilinestr
+                else:
+                    openstring = not openstring
+            if openstring:
+                openstrchar = '"'
+            else:
+                openstrchar = ""
+        if item == '#' and (not openstring and not keygroup and
+                            not arrayoftables):
+            j = i
+            comment = ""
+            try:
+                while sl[j] != '\n':
+                    comment += s[j]
+                    sl[j] = ' '
+                    j += 1
+            except IndexError:
+                break
+            if not openarr:
+                decoder.preserve_comment(line_no, prev_key, comment, beginline)
+        if item == '[' and (not openstring and not keygroup and
+                            not arrayoftables):
+            if beginline:
+                if len(sl) > i + 1 and sl[i + 1] == '[':
+                    arrayoftables = True
+                else:
+                    keygroup = True
+            else:
+                openarr += 1
+        if item == ']' and not openstring:
+            if keygroup:
+                keygroup = False
+            elif arrayoftables:
+                if sl[i - 1] == ']':
+                    arrayoftables = False
+            else:
+                openarr -= 1
+        if item == '\n':
+            if openstring or multilinestr:
+                if not multilinestr:
+                    raise TomlDecodeError("Unbalanced quotes", original, i)
+                if ((sl[i - 1] == "'" or sl[i - 1] == '"') and (
+                        sl[i - 2] == sl[i - 1])):
+                    sl[i] = sl[i - 1]
+                    if sl[i - 3] == sl[i - 1]:
+                        sl[i - 3] = ' '
+            elif openarr:
+                sl[i] = ' '
+            else:
+                beginline = True
+            line_no += 1
+        elif beginline and sl[i] != ' ' and sl[i] != '\t':
+            beginline = False
+            if not keygroup and not arrayoftables:
+                if sl[i] == '=':
+                    raise TomlDecodeError("Found empty keyname. ", original, i)
+                keyname = 1
+                key += item
+    if keyname:
+        raise TomlDecodeError("Key name found without value."
+                              " Reached end of file.", original, len(s))
+    if openstring:  # reached EOF and have an unterminated string
+        raise TomlDecodeError("Unterminated string found."
+                              " Reached end of file.", original, len(s))
+    s = ''.join(sl)
+    s = s.split('\n')
+    multikey = None
+    multilinestr = ""
+    multibackslash = False
+    pos = 0
+    for idx, line in enumerate(s):
+        if idx > 0:
+            pos += len(s[idx - 1]) + 1
+
+        decoder.embed_comments(idx, currentlevel)
+
+        if not multilinestr or multibackslash or '\n' not in multilinestr:
+            line = line.strip()
+        if line == "" and (not multikey or multibackslash):
+            continue
+        if multikey:
+            if multibackslash:
+                multilinestr += line
+            else:
+                multilinestr += line
+            multibackslash = False
+            closed = False
+            if multilinestr[0] == '[':
+                closed = line[-1] == ']'
+            elif len(line) > 2:
+                closed = (line[-1] == multilinestr[0] and
+                          line[-2] == multilinestr[0] and
+                          line[-3] == multilinestr[0])
+            if closed:
+                try:
+                    value, vtype = decoder.load_value(multilinestr)
+                except ValueError as err:
+                    raise TomlDecodeError(str(err), original, pos)
+                currentlevel[multikey] = value
+                multikey = None
+                multilinestr = ""
+            else:
+                k = len(multilinestr) - 1
+                while k > -1 and multilinestr[k] == '\\':
+                    multibackslash = not multibackslash
+                    k -= 1
+                if multibackslash:
+                    multilinestr = multilinestr[:-1]
+                else:
+                    multilinestr += "\n"
+            continue
+        if line[0] == '[':
+            arrayoftables = False
+            if len(line) == 1:
+                raise TomlDecodeError("Opening key group bracket on line by "
+                                      "itself.", original, pos)
+            if line[1] == '[':
+                arrayoftables = True
+                line = line[2:]
+                splitstr = ']]'
+            else:
+                line = line[1:]
+                splitstr = ']'
+            i = 1
+            quotesplits = decoder._get_split_on_quotes(line)
+            quoted = False
+            for quotesplit in quotesplits:
+                if not quoted and splitstr in quotesplit:
+                    break
+                i += quotesplit.count(splitstr)
+                quoted = not quoted
+            line = line.split(splitstr, i)
+            if len(line) < i + 1 or line[-1].strip() != "":
+                raise TomlDecodeError("Key group not on a line by itself.",
+                                      original, pos)
+            groups = splitstr.join(line[:-1]).split('.')
+            i = 0
+            while i < len(groups):
+                groups[i] = groups[i].strip()
+                if len(groups[i]) > 0 and (groups[i][0] == '"' or
+                                           groups[i][0] == "'"):
+                    groupstr = groups[i]
+                    j = i + 1
+                    while not groupstr[0] == groupstr[-1]:
+                        j += 1
+                        if j > len(groups) + 2:
+                            raise TomlDecodeError("Invalid group name '" +
+                                                  groupstr + "' Something " +
+                                                  "went wrong.", original, pos)
+                        groupstr = '.'.join(groups[i:j]).strip()
+                    groups[i] = groupstr[1:-1]
+                    groups[i + 1:j] = []
+                else:
+                    if not _groupname_re.match(groups[i]):
+                        raise TomlDecodeError("Invalid group name '" +
+                                              groups[i] + "'. Try quoting it.",
+                                              original, pos)
+                i += 1
+            currentlevel = retval
+            for i in _range(len(groups)):
+                group = groups[i]
+                if group == "":
+                    raise TomlDecodeError("Can't have a keygroup with an empty "
+                                          "name", original, pos)
+                try:
+                    currentlevel[group]
+                    if i == len(groups) - 1:
+                        if group in implicitgroups:
+                            implicitgroups.remove(group)
+                            if arrayoftables:
+                                raise TomlDecodeError("An implicitly defined "
+                                                      "table can't be an array",
+                                                      original, pos)
+                        elif arrayoftables:
+                            currentlevel[group].append(decoder.get_empty_table()
+                                                       )
+                        else:
+                            raise TomlDecodeError("What? " + group +
+                                                  " already exists?" +
+                                                  str(currentlevel),
+                                                  original, pos)
+                except TypeError:
+                    currentlevel = currentlevel[-1]
+                    if group not in currentlevel:
+                        currentlevel[group] = decoder.get_empty_table()
+                        if i == len(groups) - 1 and arrayoftables:
+                            currentlevel[group] = [decoder.get_empty_table()]
+                except KeyError:
+                    if i != len(groups) - 1:
+                        implicitgroups.append(group)
+                    currentlevel[group] = decoder.get_empty_table()
+                    if i == len(groups) - 1 and arrayoftables:
+                        currentlevel[group] = [decoder.get_empty_table()]
+                currentlevel = currentlevel[group]
+                if arrayoftables:
+                    try:
+                        currentlevel = currentlevel[-1]
+                    except KeyError:
+                        pass
+        elif line[0] == "{":
+            if line[-1] != "}":
+                raise TomlDecodeError("Line breaks are not allowed in inline"
+                                      "objects", original, pos)
+            try:
+                decoder.load_inline_object(line, currentlevel, multikey,
+                                           multibackslash)
+            except ValueError as err:
+                raise TomlDecodeError(str(err), original, pos)
+        elif "=" in line:
+            try:
+                ret = decoder.load_line(line, currentlevel, multikey,
+                                        multibackslash)
+            except ValueError as err:
+                raise TomlDecodeError(str(err), original, pos)
+            if ret is not None:
+                multikey, multilinestr, multibackslash = ret
+    return retval
+
+
+def _load_date(val):
+    microsecond = 0
+    tz = None
+    try:
+        if len(val) > 19:
+            if val[19] == '.':
+                if val[-1].upper() == 'Z':
+                    subsecondval = val[20:-1]
+                    tzval = "Z"
+                else:
+                    subsecondvalandtz = val[20:]
+                    if '+' in subsecondvalandtz:
+                        splitpoint = subsecondvalandtz.index('+')
+                        subsecondval = subsecondvalandtz[:splitpoint]
+                        tzval = subsecondvalandtz[splitpoint:]
+                    elif '-' in subsecondvalandtz:
+                        splitpoint = subsecondvalandtz.index('-')
+                        subsecondval = subsecondvalandtz[:splitpoint]
+                        tzval = subsecondvalandtz[splitpoint:]
+                    else:
+                        tzval = None
+                        subsecondval = subsecondvalandtz
+                if tzval is not None:
+                    tz = TomlTz(tzval)
+                microsecond = int(int(subsecondval) *
+                                  (10 ** (6 - len(subsecondval))))
+            else:
+                tz = TomlTz(val[19:])
+    except ValueError:
+        tz = None
+    if "-" not in val[1:]:
+        return None
+    try:
+        if len(val) == 10:
+            d = datetime.date(
+                int(val[:4]), int(val[5:7]),
+                int(val[8:10]))
+        else:
+            d = datetime.datetime(
+                int(val[:4]), int(val[5:7]),
+                int(val[8:10]), int(val[11:13]),
+                int(val[14:16]), int(val[17:19]), microsecond, tz)
+    except ValueError:
+        return None
+    return d
+
+
+def _load_unicode_escapes(v, hexbytes, prefix):
+    skip = False
+    i = len(v) - 1
+    while i > -1 and v[i] == '\\':
+        skip = not skip
+        i -= 1
+    for hx in hexbytes:
+        if skip:
+            skip = False
+            i = len(hx) - 1
+            while i > -1 and hx[i] == '\\':
+                skip = not skip
+                i -= 1
+            v += prefix
+            v += hx
+            continue
+        hxb = ""
+        i = 0
+        hxblen = 4
+        if prefix == "\\U":
+            hxblen = 8
+        hxb = ''.join(hx[i:i + hxblen]).lower()
+        if hxb.strip('0123456789abcdef'):
+            raise ValueError("Invalid escape sequence: " + hxb)
+        if hxb[0] == "d" and hxb[1].strip('01234567'):
+            raise ValueError("Invalid escape sequence: " + hxb +
+                             ". Only scalar unicode points are allowed.")
+        v += unichr(int(hxb, 16))
+        v += unicode(hx[len(hxb):])
+    return v
+
+
+# Unescape TOML string values.
+
+# content after the \
+_escapes = ['0', 'b', 'f', 'n', 'r', 't', '"']
+# What it should be replaced by
+_escapedchars = ['\0', '\b', '\f', '\n', '\r', '\t', '\"']
+# Used for substitution
+_escape_to_escapedchars = dict(zip(_escapes, _escapedchars))
+
+
+def _unescape(v):
+    """Unescape characters in a TOML string."""
+    i = 0
+    backslash = False
+    while i < len(v):
+        if backslash:
+            backslash = False
+            if v[i] in _escapes:
+                v = v[:i - 1] + _escape_to_escapedchars[v[i]] + v[i + 1:]
+            elif v[i] == '\\':
+                v = v[:i - 1] + v[i:]
+            elif v[i] == 'u' or v[i] == 'U':
+                i += 1
+            else:
+                raise ValueError("Reserved escape sequence used")
+            continue
+        elif v[i] == '\\':
+            backslash = True
+        i += 1
+    return v
+
+
+class InlineTableDict(object):
+    """Sentinel subclass of dict for inline tables."""
+
+
+class TomlDecoder(object):
+
+    def __init__(self, _dict=dict):
+        self._dict = _dict
+
+    def get_empty_table(self):
+        return self._dict()
+
+    def get_empty_inline_table(self):
+        class DynamicInlineTableDict(self._dict, InlineTableDict):
+            """Concrete sentinel subclass for inline tables.
+            It is a subclass of _dict which is passed in dynamically at load
+            time
+
+            It is also a subclass of InlineTableDict
+            """
+
+        return DynamicInlineTableDict()
+
+    def load_inline_object(self, line, currentlevel, multikey=False,
+                           multibackslash=False):
+        candidate_groups = line[1:-1].split(",")
+        groups = []
+        if len(candidate_groups) == 1 and not candidate_groups[0].strip():
+            candidate_groups.pop()
+        while len(candidate_groups) > 0:
+            candidate_group = candidate_groups.pop(0)
+            try:
+                _, value = candidate_group.split('=', 1)
+            except ValueError:
+                raise ValueError("Invalid inline table encountered")
+            value = value.strip()
+            if ((value[0] == value[-1] and value[0] in ('"', "'")) or (
+                    value[0] in '-0123456789' or
+                    value in ('true', 'false') or
+                    (value[0] == "[" and value[-1] == "]") or
+                    (value[0] == '{' and value[-1] == '}'))):
+                groups.append(candidate_group)
+            elif len(candidate_groups) > 0:
+                candidate_groups[0] = (candidate_group + "," +
+                                       candidate_groups[0])
+            else:
+                raise ValueError("Invalid inline table value encountered")
+        for group in groups:
+            status = self.load_line(group, currentlevel, multikey,
+                                    multibackslash)
+            if status is not None:
+                break
+
+    def _get_split_on_quotes(self, line):
+        doublequotesplits = line.split('"')
+        quoted = False
+        quotesplits = []
+        if len(doublequotesplits) > 1 and "'" in doublequotesplits[0]:
+            singlequotesplits = doublequotesplits[0].split("'")
+            doublequotesplits = doublequotesplits[1:]
+            while len(singlequotesplits) % 2 == 0 and len(doublequotesplits):
+                singlequotesplits[-1] += '"' + doublequotesplits[0]
+                doublequotesplits = doublequotesplits[1:]
+                if "'" in singlequotesplits[-1]:
+                    singlequotesplits = (singlequotesplits[:-1] +
+                                         singlequotesplits[-1].split("'"))
+            quotesplits += singlequotesplits
+        for doublequotesplit in doublequotesplits:
+            if quoted:
+                quotesplits.append(doublequotesplit)
+            else:
+                quotesplits += doublequotesplit.split("'")
+                quoted = not quoted
+        return quotesplits
+
+    def load_line(self, line, currentlevel, multikey, multibackslash):
+        i = 1
+        quotesplits = self._get_split_on_quotes(line)
+        quoted = False
+        for quotesplit in quotesplits:
+            if not quoted and '=' in quotesplit:
+                break
+            i += quotesplit.count('=')
+            quoted = not quoted
+        pair = line.split('=', i)
+        strictly_valid = _strictly_valid_num(pair[-1])
+        if _number_with_underscores.match(pair[-1]):
+            pair[-1] = pair[-1].replace('_', '')
+        while len(pair[-1]) and (pair[-1][0] != ' ' and pair[-1][0] != '\t' and
+                                 pair[-1][0] != "'" and pair[-1][0] != '"' and
+                                 pair[-1][0] != '[' and pair[-1][0] != '{' and
+                                 pair[-1].strip() != 'true' and
+                                 pair[-1].strip() != 'false'):
+            try:
+                float(pair[-1])
+                break
+            except ValueError:
+                pass
+            if _load_date(pair[-1]) is not None:
+                break
+            if TIME_RE.match(pair[-1]):
+                break
+            i += 1
+            prev_val = pair[-1]
+            pair = line.split('=', i)
+            if prev_val == pair[-1]:
+                raise ValueError("Invalid date or number")
+            if strictly_valid:
+                strictly_valid = _strictly_valid_num(pair[-1])
+        pair = ['='.join(pair[:-1]).strip(), pair[-1].strip()]
+        if '.' in pair[0]:
+            if '"' in pair[0] or "'" in pair[0]:
+                quotesplits = self._get_split_on_quotes(pair[0])
+                quoted = False
+                levels = []
+                for quotesplit in quotesplits:
+                    if quoted:
+                        levels.append(quotesplit)
+                    else:
+                        levels += [level.strip() for level in
+                                   quotesplit.split('.')]
+                    quoted = not quoted
+            else:
+                levels = pair[0].split('.')
+            while levels[-1] == "":
+                levels = levels[:-1]
+            for level in levels[:-1]:
+                if level == "":
+                    continue
+                if level not in currentlevel:
+                    currentlevel[level] = self.get_empty_table()
+                currentlevel = currentlevel[level]
+            pair[0] = levels[-1].strip()
+        elif (pair[0][0] == '"' or pair[0][0] == "'") and \
+                (pair[0][-1] == pair[0][0]):
+            pair[0] = _unescape(pair[0][1:-1])
+        k, koffset = self._load_line_multiline_str(pair[1])
+        if k > -1:
+            while k > -1 and pair[1][k + koffset] == '\\':
+                multibackslash = not multibackslash
+                k -= 1
+            if multibackslash:
+                multilinestr = pair[1][:-1]
+            else:
+                multilinestr = pair[1] + "\n"
+            multikey = pair[0]
+        else:
+            value, vtype = self.load_value(pair[1], strictly_valid)
+        try:
+            currentlevel[pair[0]]
+            raise ValueError("Duplicate keys!")
+        except TypeError:
+            raise ValueError("Duplicate keys!")
+        except KeyError:
+            if multikey:
+                return multikey, multilinestr, multibackslash
+            else:
+                currentlevel[pair[0]] = value
+
+    def _load_line_multiline_str(self, p):
+        poffset = 0
+        if len(p) < 3:
+            return -1, poffset
+        if p[0] == '[' and (p.strip()[-1] != ']' and
+                            self._load_array_isstrarray(p)):
+            newp = p[1:].strip().split(',')
+            while len(newp) > 1 and newp[-1][0] != '"' and newp[-1][0] != "'":
+                newp = newp[:-2] + [newp[-2] + ',' + newp[-1]]
+            newp = newp[-1]
+            poffset = len(p) - len(newp)
+            p = newp
+        if p[0] != '"' and p[0] != "'":
+            return -1, poffset
+        if p[1] != p[0] or p[2] != p[0]:
+            return -1, poffset
+        if len(p) > 5 and p[-1] == p[0] and p[-2] == p[0] and p[-3] == p[0]:
+            return -1, poffset
+        return len(p) - 1, poffset
+
+    def load_value(self, v, strictly_valid=True):
+        if not v:
+            raise ValueError("Empty value is invalid")
+        if v == 'true':
+            return (True, "bool")
+        elif v == 'false':
+            return (False, "bool")
+        elif v[0] == '"' or v[0] == "'":
+            quotechar = v[0]
+            testv = v[1:].split(quotechar)
+            triplequote = False
+            triplequotecount = 0
+            if len(testv) > 1 and testv[0] == '' and testv[1] == '':
+                testv = testv[2:]
+                triplequote = True
+            closed = False
+            for tv in testv:
+                if tv == '':
+                    if triplequote:
+                        triplequotecount += 1
+                    else:
+                        closed = True
+                else:
+                    oddbackslash = False
+                    try:
+                        i = -1
+                        j = tv[i]
+                        while j == '\\':
+                            oddbackslash = not oddbackslash
+                            i -= 1
+                            j = tv[i]
+                    except IndexError:
+                        pass
+                    if not oddbackslash:
+                        if closed:
+                            raise ValueError("Found tokens after a closed " +
+                                             "string. Invalid TOML.")
+                        else:
+                            if not triplequote or triplequotecount > 1:
+                                closed = True
+                            else:
+                                triplequotecount = 0
+            if quotechar == '"':
+                escapeseqs = v.split('\\')[1:]
+                backslash = False
+                for i in escapeseqs:
+                    if i == '':
+                        backslash = not backslash
+                    else:
+                        if i[0] not in _escapes and (i[0] != 'u' and
+                                                     i[0] != 'U' and
+                                                     not backslash):
+                            raise ValueError("Reserved escape sequence used")
+                        if backslash:
+                            backslash = False
+                for prefix in ["\\u", "\\U"]:
+                    if prefix in v:
+                        hexbytes = v.split(prefix)
+                        v = _load_unicode_escapes(hexbytes[0], hexbytes[1:],
+                                                  prefix)
+                v = _unescape(v)
+            if len(v) > 1 and v[1] == quotechar and (len(v) < 3 or
+                                                     v[1] == v[2]):
+                v = v[2:-2]
+            return (v[1:-1], "str")
+        elif v[0] == '[':
+            return (self.load_array(v), "array")
+        elif v[0] == '{':
+            inline_object = self.get_empty_inline_table()
+            self.load_inline_object(v, inline_object)
+            return (inline_object, "inline_object")
+        elif TIME_RE.match(v):
+            h, m, s, _, ms = TIME_RE.match(v).groups()
+            time = datetime.time(int(h), int(m), int(s), int(ms) if ms else 0)
+            return (time, "time")
+        else:
+            parsed_date = _load_date(v)
+            if parsed_date is not None:
+                return (parsed_date, "date")
+            if not strictly_valid:
+                raise ValueError("Weirdness with leading zeroes or "
+                                 "underscores in your number.")
+            itype = "int"
+            neg = False
+            if v[0] == '-':
+                neg = True
+                v = v[1:]
+            elif v[0] == '+':
+                v = v[1:]
+            v = v.replace('_', '')
+            lowerv = v.lower()
+            if '.' in v or ('x' not in v and ('e' in v or 'E' in v)):
+                if '.' in v and v.split('.', 1)[1] == '':
+                    raise ValueError("This float is missing digits after "
+                                     "the point")
+                if v[0] not in '0123456789':
+                    raise ValueError("This float doesn't have a leading "
+                                     "digit")
+                v = float(v)
+                itype = "float"
+            elif len(lowerv) == 3 and (lowerv == 'inf' or lowerv == 'nan'):
+                v = float(v)
+                itype = "float"
+            if itype == "int":
+                v = int(v, 0)
+            if neg:
+                return (0 - v, itype)
+            return (v, itype)
+
+    def bounded_string(self, s):
+        if len(s) == 0:
+            return True
+        if s[-1] != s[0]:
+            return False
+        i = -2
+        backslash = False
+        while len(s) + i > 0:
+            if s[i] == "\\":
+                backslash = not backslash
+                i -= 1
+            else:
+                break
+        return not backslash
+
+    def _load_array_isstrarray(self, a):
+        a = a[1:-1].strip()
+        if a != '' and (a[0] == '"' or a[0] == "'"):
+            return True
+        return False
+
+    def load_array(self, a):
+        atype = None
+        retval = []
+        a = a.strip()
+        if '[' not in a[1:-1] or "" != a[1:-1].split('[')[0].strip():
+            strarray = self._load_array_isstrarray(a)
+            if not a[1:-1].strip().startswith('{'):
+                a = a[1:-1].split(',')
+            else:
+                # a is an inline object, we must find the matching parenthesis
+                # to define groups
+                new_a = []
+                start_group_index = 1
+                end_group_index = 2
+                open_bracket_count = 1 if a[start_group_index] == '{' else 0
+                in_str = False
+                while end_group_index < len(a[1:]):
+                    if a[end_group_index] == '"' or a[end_group_index] == "'":
+                        if in_str:
+                            backslash_index = end_group_index - 1
+                            while (backslash_index > -1 and
+                                   a[backslash_index] == '\\'):
+                                in_str = not in_str
+                                backslash_index -= 1
+                        in_str = not in_str
+                    if not in_str and a[end_group_index] == '{':
+                        open_bracket_count += 1
+                    if in_str or a[end_group_index] != '}':
+                        end_group_index += 1
+                        continue
+                    elif a[end_group_index] == '}' and open_bracket_count > 1:
+                        open_bracket_count -= 1
+                        end_group_index += 1
+                        continue
+
+                    # Increase end_group_index by 1 to get the closing bracket
+                    end_group_index += 1
+
+                    new_a.append(a[start_group_index:end_group_index])
+
+                    # The next start index is at least after the closing
+                    # bracket, a closing bracket can be followed by a comma
+                    # since we are in an array.
+                    start_group_index = end_group_index + 1
+                    while (start_group_index < len(a[1:]) and
+                           a[start_group_index] != '{'):
+                        start_group_index += 1
+                    end_group_index = start_group_index + 1
+                a = new_a
+            b = 0
+            if strarray:
+                while b < len(a) - 1:
+                    ab = a[b].strip()
+                    while (not self.bounded_string(ab) or
+                           (len(ab) > 2 and
+                            ab[0] == ab[1] == ab[2] and
+                            ab[-2] != ab[0] and
+                            ab[-3] != ab[0])):
+                        a[b] = a[b] + ',' + a[b + 1]
+                        ab = a[b].strip()
+                        if b < len(a) - 2:
+                            a = a[:b + 1] + a[b + 2:]
+                        else:
+                            a = a[:b + 1]
+                    b += 1
+        else:
+            al = list(a[1:-1])
+            a = []
+            openarr = 0
+            j = 0
+            for i in _range(len(al)):
+                if al[i] == '[':
+                    openarr += 1
+                elif al[i] == ']':
+                    openarr -= 1
+                elif al[i] == ',' and not openarr:
+                    a.append(''.join(al[j:i]))
+                    j = i + 1
+            a.append(''.join(al[j:]))
+        for i in _range(len(a)):
+            a[i] = a[i].strip()
+            if a[i] != '':
+                nval, ntype = self.load_value(a[i])
+                if atype:
+                    if ntype != atype:
+                        raise ValueError("Not a homogeneous array")
+                else:
+                    atype = ntype
+                retval.append(nval)
+        return retval
+
+    def preserve_comment(self, line_no, key, comment, beginline):
+        pass
+
+    def embed_comments(self, idx, currentlevel):
+        pass
+
+
+class TomlPreserveCommentDecoder(TomlDecoder):
+
+    def __init__(self, _dict=dict):
+        self.saved_comments = {}
+        super(TomlPreserveCommentDecoder, self).__init__(_dict)
+
+    def preserve_comment(self, line_no, key, comment, beginline):
+        self.saved_comments[line_no] = (key, comment, beginline)
+
+    def embed_comments(self, idx, currentlevel):
+        if idx not in self.saved_comments:
+            return
+
+        key, comment, beginline = self.saved_comments[idx]
+        currentlevel[key] = CommentValue(currentlevel[key], comment, beginline,
+                                         self._dict)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/toml/encoder.py b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/encoder.py
new file mode 100644
index 0000000..a8b03c7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/encoder.py
@@ -0,0 +1,304 @@
+import datetime
+import re
+import sys
+from decimal import Decimal
+
+from pip._vendor.toml.decoder import InlineTableDict
+
+if sys.version_info >= (3,):
+    unicode = str
+
+
+def dump(o, f, encoder=None):
+    """Writes out dict as toml to a file
+
+    Args:
+        o: Object to dump into toml
+        f: File descriptor where the toml should be stored
+        encoder: The ``TomlEncoder`` to use for constructing the output string
+
+    Returns:
+        String containing the toml corresponding to dictionary
+
+    Raises:
+        TypeError: When anything other than file descriptor is passed
+    """
+
+    if not f.write:
+        raise TypeError("You can only dump an object to a file descriptor")
+    d = dumps(o, encoder=encoder)
+    f.write(d)
+    return d
+
+
+def dumps(o, encoder=None):
+    """Stringifies input dict as toml
+
+    Args:
+        o: Object to dump into toml
+        encoder: The ``TomlEncoder`` to use for constructing the output string
+
+    Returns:
+        String containing the toml corresponding to dict
+
+    Examples:
+        ```python
+        >>> import toml
+        >>> output = {
+        ... 'a': "I'm a string",
+        ... 'b': ["I'm", "a", "list"],
+        ... 'c': 2400
+        ... }
+        >>> toml.dumps(output)
+        'a = "I\'m a string"\nb = [ "I\'m", "a", "list",]\nc = 2400\n'
+        ```
+    """
+
+    retval = ""
+    if encoder is None:
+        encoder = TomlEncoder(o.__class__)
+    addtoretval, sections = encoder.dump_sections(o, "")
+    retval += addtoretval
+    outer_objs = [id(o)]
+    while sections:
+        section_ids = [id(section) for section in sections]
+        for outer_obj in outer_objs:
+            if outer_obj in section_ids:
+                raise ValueError("Circular reference detected")
+        outer_objs += section_ids
+        newsections = encoder.get_empty_table()
+        for section in sections:
+            addtoretval, addtosections = encoder.dump_sections(
+                sections[section], section)
+
+            if addtoretval or (not addtoretval and not addtosections):
+                if retval and retval[-2:] != "\n\n":
+                    retval += "\n"
+                retval += "[" + section + "]\n"
+                if addtoretval:
+                    retval += addtoretval
+            for s in addtosections:
+                newsections[section + "." + s] = addtosections[s]
+        sections = newsections
+    return retval
+
+
+def _dump_str(v):
+    if sys.version_info < (3,) and hasattr(v, 'decode') and isinstance(v, str):
+        v = v.decode('utf-8')
+    v = "%r" % v
+    if v[0] == 'u':
+        v = v[1:]
+    singlequote = v.startswith("'")
+    if singlequote or v.startswith('"'):
+        v = v[1:-1]
+    if singlequote:
+        v = v.replace("\\'", "'")
+        v = v.replace('"', '\\"')
+    v = v.split("\\x")
+    while len(v) > 1:
+        i = -1
+        if not v[0]:
+            v = v[1:]
+        v[0] = v[0].replace("\\\\", "\\")
+        # No, I don't know why != works and == breaks
+        joinx = v[0][i] != "\\"
+        while v[0][:i] and v[0][i] == "\\":
+            joinx = not joinx
+            i -= 1
+        if joinx:
+            joiner = "x"
+        else:
+            joiner = "u00"
+        v = [v[0] + joiner + v[1]] + v[2:]
+    return unicode('"' + v[0] + '"')
+
+
+def _dump_float(v):
+    return "{}".format(v).replace("e+0", "e+").replace("e-0", "e-")
+
+
+def _dump_time(v):
+    utcoffset = v.utcoffset()
+    if utcoffset is None:
+        return v.isoformat()
+    # The TOML norm specifies that it's local time thus we drop the offset
+    return v.isoformat()[:-6]
+
+
+class TomlEncoder(object):
+
+    def __init__(self, _dict=dict, preserve=False):
+        self._dict = _dict
+        self.preserve = preserve
+        self.dump_funcs = {
+            str: _dump_str,
+            unicode: _dump_str,
+            list: self.dump_list,
+            bool: lambda v: unicode(v).lower(),
+            int: lambda v: v,
+            float: _dump_float,
+            Decimal: _dump_float,
+            datetime.datetime: lambda v: v.isoformat().replace('+00:00', 'Z'),
+            datetime.time: _dump_time,
+            datetime.date: lambda v: v.isoformat()
+        }
+
+    def get_empty_table(self):
+        return self._dict()
+
+    def dump_list(self, v):
+        retval = "["
+        for u in v:
+            retval += " " + unicode(self.dump_value(u)) + ","
+        retval += "]"
+        return retval
+
+    def dump_inline_table(self, section):
+        """Preserve inline table in its compact syntax instead of expanding
+        into subsection.
+
+        https://github.com/toml-lang/toml#user-content-inline-table
+        """
+        retval = ""
+        if isinstance(section, dict):
+            val_list = []
+            for k, v in section.items():
+                val = self.dump_inline_table(v)
+                val_list.append(k + " = " + val)
+            retval += "{ " + ", ".join(val_list) + " }\n"
+            return retval
+        else:
+            return unicode(self.dump_value(section))
+
+    def dump_value(self, v):
+        # Lookup function corresponding to v's type
+        dump_fn = self.dump_funcs.get(type(v))
+        if dump_fn is None and hasattr(v, '__iter__'):
+            dump_fn = self.dump_funcs[list]
+        # Evaluate function (if it exists) else return v
+        return dump_fn(v) if dump_fn is not None else self.dump_funcs[str](v)
+
+    def dump_sections(self, o, sup):
+        retstr = ""
+        if sup != "" and sup[-1] != ".":
+            sup += '.'
+        retdict = self._dict()
+        arraystr = ""
+        for section in o:
+            section = unicode(section)
+            qsection = section
+            if not re.match(r'^[A-Za-z0-9_-]+$', section):
+                qsection = _dump_str(section)
+            if not isinstance(o[section], dict):
+                arrayoftables = False
+                if isinstance(o[section], list):
+                    for a in o[section]:
+                        if isinstance(a, dict):
+                            arrayoftables = True
+                if arrayoftables:
+                    for a in o[section]:
+                        arraytabstr = "\n"
+                        arraystr += "[[" + sup + qsection + "]]\n"
+                        s, d = self.dump_sections(a, sup + qsection)
+                        if s:
+                            if s[0] == "[":
+                                arraytabstr += s
+                            else:
+                                arraystr += s
+                        while d:
+                            newd = self._dict()
+                            for dsec in d:
+                                s1, d1 = self.dump_sections(d[dsec], sup +
+                                                            qsection + "." +
+                                                            dsec)
+                                if s1:
+                                    arraytabstr += ("[" + sup + qsection +
+                                                    "." + dsec + "]\n")
+                                    arraytabstr += s1
+                                for s1 in d1:
+                                    newd[dsec + "." + s1] = d1[s1]
+                            d = newd
+                        arraystr += arraytabstr
+                else:
+                    if o[section] is not None:
+                        retstr += (qsection + " = " +
+                                   unicode(self.dump_value(o[section])) + '\n')
+            elif self.preserve and isinstance(o[section], InlineTableDict):
+                retstr += (qsection + " = " +
+                           self.dump_inline_table(o[section]))
+            else:
+                retdict[qsection] = o[section]
+        retstr += arraystr
+        return (retstr, retdict)
+
+
+class TomlPreserveInlineDictEncoder(TomlEncoder):
+
+    def __init__(self, _dict=dict):
+        super(TomlPreserveInlineDictEncoder, self).__init__(_dict, True)
+
+
+class TomlArraySeparatorEncoder(TomlEncoder):
+
+    def __init__(self, _dict=dict, preserve=False, separator=","):
+        super(TomlArraySeparatorEncoder, self).__init__(_dict, preserve)
+        if separator.strip() == "":
+            separator = "," + separator
+        elif separator.strip(' \t\n\r,'):
+            raise ValueError("Invalid separator for arrays")
+        self.separator = separator
+
+    def dump_list(self, v):
+        t = []
+        retval = "["
+        for u in v:
+            t.append(self.dump_value(u))
+        while t != []:
+            s = []
+            for u in t:
+                if isinstance(u, list):
+                    for r in u:
+                        s.append(r)
+                else:
+                    retval += " " + unicode(u) + self.separator
+            t = s
+        retval += "]"
+        return retval
+
+
+class TomlNumpyEncoder(TomlEncoder):
+
+    def __init__(self, _dict=dict, preserve=False):
+        import numpy as np
+        super(TomlNumpyEncoder, self).__init__(_dict, preserve)
+        self.dump_funcs[np.float16] = _dump_float
+        self.dump_funcs[np.float32] = _dump_float
+        self.dump_funcs[np.float64] = _dump_float
+        self.dump_funcs[np.int16] = self._dump_int
+        self.dump_funcs[np.int32] = self._dump_int
+        self.dump_funcs[np.int64] = self._dump_int
+
+    def _dump_int(self, v):
+        return "{}".format(int(v))
+
+
+class TomlPreserveCommentEncoder(TomlEncoder):
+
+    def __init__(self, _dict=dict, preserve=False):
+        from pip._vendor.toml.decoder import CommentValue
+        super(TomlPreserveCommentEncoder, self).__init__(_dict, preserve)
+        self.dump_funcs[CommentValue] = lambda v: v.dump(self.dump_value)
+
+
+class TomlPathlibEncoder(TomlEncoder):
+
+    def _dump_pathlib_path(self, v):
+        return _dump_str(str(v))
+
+    def dump_value(self, v):
+        if (3, 4) <= sys.version_info:
+            import pathlib
+            if isinstance(v, pathlib.PurePath):
+                v = str(v)
+        return super(TomlPathlibEncoder, self).dump_value(v)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/toml/ordered.py b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/ordered.py
new file mode 100644
index 0000000..6052016
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/ordered.py
@@ -0,0 +1,15 @@
+from collections import OrderedDict
+from pip._vendor.toml import TomlEncoder
+from pip._vendor.toml import TomlDecoder
+
+
+class TomlOrderedDecoder(TomlDecoder):
+
+    def __init__(self):
+        super(self.__class__, self).__init__(_dict=OrderedDict)
+
+
+class TomlOrderedEncoder(TomlEncoder):
+
+    def __init__(self):
+        super(self.__class__, self).__init__(_dict=OrderedDict)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/toml/tz.py b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/tz.py
new file mode 100644
index 0000000..93c3c8a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/toml/tz.py
@@ -0,0 +1,21 @@
+from datetime import tzinfo, timedelta
+
+
+class TomlTz(tzinfo):
+    def __init__(self, toml_offset):
+        if toml_offset == "Z":
+            self._raw_offset = "+00:00"
+        else:
+            self._raw_offset = toml_offset
+        self._sign = -1 if self._raw_offset[0] == '-' else 1
+        self._hours = int(self._raw_offset[1:3])
+        self._minutes = int(self._raw_offset[4:6])
+
+    def tzname(self, dt):
+        return "UTC" + self._raw_offset
+
+    def utcoffset(self, dt):
+        return self._sign * timedelta(hours=self._hours, minutes=self._minutes)
+
+    def dst(self, dt):
+        return timedelta(0)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/__init__.py
new file mode 100644
index 0000000..667e9bc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/__init__.py
@@ -0,0 +1,86 @@
+"""
+urllib3 - Thread-safe connection pooling and re-using.
+"""
+from __future__ import absolute_import
+import warnings
+
+from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, connection_from_url
+
+from . import exceptions
+from .filepost import encode_multipart_formdata
+from .poolmanager import PoolManager, ProxyManager, proxy_from_url
+from .response import HTTPResponse
+from .util.request import make_headers
+from .util.url import get_host
+from .util.timeout import Timeout
+from .util.retry import Retry
+
+
+# Set default logging handler to avoid "No handler found" warnings.
+import logging
+from logging import NullHandler
+
+__author__ = "Andrey Petrov (andrey.petrov@shazow.net)"
+__license__ = "MIT"
+__version__ = "1.25.9"
+
+__all__ = (
+    "HTTPConnectionPool",
+    "HTTPSConnectionPool",
+    "PoolManager",
+    "ProxyManager",
+    "HTTPResponse",
+    "Retry",
+    "Timeout",
+    "add_stderr_logger",
+    "connection_from_url",
+    "disable_warnings",
+    "encode_multipart_formdata",
+    "get_host",
+    "make_headers",
+    "proxy_from_url",
+)
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+
+def add_stderr_logger(level=logging.DEBUG):
+    """
+    Helper for quickly adding a StreamHandler to the logger. Useful for
+    debugging.
+
+    Returns the handler after adding it.
+    """
+    # This method needs to be in this __init__.py to get the __name__ correct
+    # even if urllib3 is vendored within another package.
+    logger = logging.getLogger(__name__)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+    logger.addHandler(handler)
+    logger.setLevel(level)
+    logger.debug("Added a stderr logging handler to logger: %s", __name__)
+    return handler
+
+
+# ... Clean up.
+del NullHandler
+
+
+# All warning filters *must* be appended unless you're really certain that they
+# shouldn't be: otherwise, it's very hard for users to use most Python
+# mechanisms to silence them.
+# SecurityWarning's always go off by default.
+warnings.simplefilter("always", exceptions.SecurityWarning, append=True)
+# SubjectAltNameWarning's should go off once per host
+warnings.simplefilter("default", exceptions.SubjectAltNameWarning, append=True)
+# InsecurePlatformWarning's don't vary between requests, so we keep it default.
+warnings.simplefilter("default", exceptions.InsecurePlatformWarning, append=True)
+# SNIMissingWarnings should go off only once.
+warnings.simplefilter("default", exceptions.SNIMissingWarning, append=True)
+
+
+def disable_warnings(category=exceptions.HTTPWarning):
+    """
+    Helper for quickly disabling all urllib3 warnings.
+    """
+    warnings.simplefilter("ignore", category)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/_collections.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/_collections.py
new file mode 100644
index 0000000..019d151
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/_collections.py
@@ -0,0 +1,336 @@
+from __future__ import absolute_import
+
+try:
+    from collections.abc import Mapping, MutableMapping
+except ImportError:
+    from collections import Mapping, MutableMapping
+try:
+    from threading import RLock
+except ImportError:  # Platform-specific: No threads available
+
+    class RLock:
+        def __enter__(self):
+            pass
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            pass
+
+
+from collections import OrderedDict
+from .exceptions import InvalidHeader
+from .packages.six import iterkeys, itervalues, PY3
+
+
+__all__ = ["RecentlyUsedContainer", "HTTPHeaderDict"]
+
+
+_Null = object()
+
+
+class RecentlyUsedContainer(MutableMapping):
+    """
+    Provides a thread-safe dict-like container which maintains up to
+    ``maxsize`` keys while throwing away the least-recently-used keys beyond
+    ``maxsize``.
+
+    :param maxsize:
+        Maximum number of recent elements to retain.
+
+    :param dispose_func:
+        Every time an item is evicted from the container,
+        ``dispose_func(value)`` is called.  Callback which will get called
+    """
+
+    ContainerCls = OrderedDict
+
+    def __init__(self, maxsize=10, dispose_func=None):
+        self._maxsize = maxsize
+        self.dispose_func = dispose_func
+
+        self._container = self.ContainerCls()
+        self.lock = RLock()
+
+    def __getitem__(self, key):
+        # Re-insert the item, moving it to the end of the eviction line.
+        with self.lock:
+            item = self._container.pop(key)
+            self._container[key] = item
+            return item
+
+    def __setitem__(self, key, value):
+        evicted_value = _Null
+        with self.lock:
+            # Possibly evict the existing value of 'key'
+            evicted_value = self._container.get(key, _Null)
+            self._container[key] = value
+
+            # If we didn't evict an existing value, we might have to evict the
+            # least recently used item from the beginning of the container.
+            if len(self._container) > self._maxsize:
+                _key, evicted_value = self._container.popitem(last=False)
+
+        if self.dispose_func and evicted_value is not _Null:
+            self.dispose_func(evicted_value)
+
+    def __delitem__(self, key):
+        with self.lock:
+            value = self._container.pop(key)
+
+        if self.dispose_func:
+            self.dispose_func(value)
+
+    def __len__(self):
+        with self.lock:
+            return len(self._container)
+
+    def __iter__(self):
+        raise NotImplementedError(
+            "Iteration over this class is unlikely to be threadsafe."
+        )
+
+    def clear(self):
+        with self.lock:
+            # Copy pointers to all values, then wipe the mapping
+            values = list(itervalues(self._container))
+            self._container.clear()
+
+        if self.dispose_func:
+            for value in values:
+                self.dispose_func(value)
+
+    def keys(self):
+        with self.lock:
+            return list(iterkeys(self._container))
+
+
+class HTTPHeaderDict(MutableMapping):
+    """
+    :param headers:
+        An iterable of field-value pairs. Must not contain multiple field names
+        when compared case-insensitively.
+
+    :param kwargs:
+        Additional field-value pairs to pass in to ``dict.update``.
+
+    A ``dict`` like container for storing HTTP Headers.
+
+    Field names are stored and compared case-insensitively in compliance with
+    RFC 7230. Iteration provides the first case-sensitive key seen for each
+    case-insensitive pair.
+
+    Using ``__setitem__`` syntax overwrites fields that compare equal
+    case-insensitively in order to maintain ``dict``'s api. For fields that
+    compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add``
+    in a loop.
+
+    If multiple fields that are equal case-insensitively are passed to the
+    constructor or ``.update``, the behavior is undefined and some will be
+    lost.
+
+    >>> headers = HTTPHeaderDict()
+    >>> headers.add('Set-Cookie', 'foo=bar')
+    >>> headers.add('set-cookie', 'baz=quxx')
+    >>> headers['content-length'] = '7'
+    >>> headers['SET-cookie']
+    'foo=bar, baz=quxx'
+    >>> headers['Content-Length']
+    '7'
+    """
+
+    def __init__(self, headers=None, **kwargs):
+        super(HTTPHeaderDict, self).__init__()
+        self._container = OrderedDict()
+        if headers is not None:
+            if isinstance(headers, HTTPHeaderDict):
+                self._copy_from(headers)
+            else:
+                self.extend(headers)
+        if kwargs:
+            self.extend(kwargs)
+
+    def __setitem__(self, key, val):
+        self._container[key.lower()] = [key, val]
+        return self._container[key.lower()]
+
+    def __getitem__(self, key):
+        val = self._container[key.lower()]
+        return ", ".join(val[1:])
+
+    def __delitem__(self, key):
+        del self._container[key.lower()]
+
+    def __contains__(self, key):
+        return key.lower() in self._container
+
+    def __eq__(self, other):
+        if not isinstance(other, Mapping) and not hasattr(other, "keys"):
+            return False
+        if not isinstance(other, type(self)):
+            other = type(self)(other)
+        return dict((k.lower(), v) for k, v in self.itermerged()) == dict(
+            (k.lower(), v) for k, v in other.itermerged()
+        )
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    if not PY3:  # Python 2
+        iterkeys = MutableMapping.iterkeys
+        itervalues = MutableMapping.itervalues
+
+    __marker = object()
+
+    def __len__(self):
+        return len(self._container)
+
+    def __iter__(self):
+        # Only provide the originally cased names
+        for vals in self._container.values():
+            yield vals[0]
+
+    def pop(self, key, default=__marker):
+        """D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+          If key is not found, d is returned if given, otherwise KeyError is raised.
+        """
+        # Using the MutableMapping function directly fails due to the private marker.
+        # Using ordinary dict.pop would expose the internal structures.
+        # So let's reinvent the wheel.
+        try:
+            value = self[key]
+        except KeyError:
+            if default is self.__marker:
+                raise
+            return default
+        else:
+            del self[key]
+            return value
+
+    def discard(self, key):
+        try:
+            del self[key]
+        except KeyError:
+            pass
+
+    def add(self, key, val):
+        """Adds a (name, value) pair, doesn't overwrite the value if it already
+        exists.
+
+        >>> headers = HTTPHeaderDict(foo='bar')
+        >>> headers.add('Foo', 'baz')
+        >>> headers['foo']
+        'bar, baz'
+        """
+        key_lower = key.lower()
+        new_vals = [key, val]
+        # Keep the common case aka no item present as fast as possible
+        vals = self._container.setdefault(key_lower, new_vals)
+        if new_vals is not vals:
+            vals.append(val)
+
+    def extend(self, *args, **kwargs):
+        """Generic import function for any type of header-like object.
+        Adapted version of MutableMapping.update in order to insert items
+        with self.add instead of self.__setitem__
+        """
+        if len(args) > 1:
+            raise TypeError(
+                "extend() takes at most 1 positional "
+                "arguments ({0} given)".format(len(args))
+            )
+        other = args[0] if len(args) >= 1 else ()
+
+        if isinstance(other, HTTPHeaderDict):
+            for key, val in other.iteritems():
+                self.add(key, val)
+        elif isinstance(other, Mapping):
+            for key in other:
+                self.add(key, other[key])
+        elif hasattr(other, "keys"):
+            for key in other.keys():
+                self.add(key, other[key])
+        else:
+            for key, value in other:
+                self.add(key, value)
+
+        for key, value in kwargs.items():
+            self.add(key, value)
+
+    def getlist(self, key, default=__marker):
+        """Returns a list of all the values for the named field. Returns an
+        empty list if the key doesn't exist."""
+        try:
+            vals = self._container[key.lower()]
+        except KeyError:
+            if default is self.__marker:
+                return []
+            return default
+        else:
+            return vals[1:]
+
+    # Backwards compatibility for httplib
+    getheaders = getlist
+    getallmatchingheaders = getlist
+    iget = getlist
+
+    # Backwards compatibility for http.cookiejar
+    get_all = getlist
+
+    def __repr__(self):
+        return "%s(%s)" % (type(self).__name__, dict(self.itermerged()))
+
+    def _copy_from(self, other):
+        for key in other:
+            val = other.getlist(key)
+            if isinstance(val, list):
+                # Don't need to convert tuples
+                val = list(val)
+            self._container[key.lower()] = [key] + val
+
+    def copy(self):
+        clone = type(self)()
+        clone._copy_from(self)
+        return clone
+
+    def iteritems(self):
+        """Iterate over all header lines, including duplicate ones."""
+        for key in self:
+            vals = self._container[key.lower()]
+            for val in vals[1:]:
+                yield vals[0], val
+
+    def itermerged(self):
+        """Iterate over all headers, merging duplicate ones together."""
+        for key in self:
+            val = self._container[key.lower()]
+            yield val[0], ", ".join(val[1:])
+
+    def items(self):
+        return list(self.iteritems())
+
+    @classmethod
+    def from_httplib(cls, message):  # Python 2
+        """Read headers from a Python 2 httplib message object."""
+        # python2.7 does not expose a proper API for exporting multiheaders
+        # efficiently. This function re-reads raw lines from the message
+        # object and extracts the multiheaders properly.
+        obs_fold_continued_leaders = (" ", "\t")
+        headers = []
+
+        for line in message.headers:
+            if line.startswith(obs_fold_continued_leaders):
+                if not headers:
+                    # We received a header line that starts with OWS as described
+                    # in RFC-7230 S3.2.4. This indicates a multiline header, but
+                    # there exists no previous header to which we can attach it.
+                    raise InvalidHeader(
+                        "Header continuation with no previous header: %s" % line
+                    )
+                else:
+                    key, value = headers[-1]
+                    headers[-1] = (key, value + " " + line.strip())
+                    continue
+
+            key, value = line.split(":", 1)
+            headers.append((key, value.strip()))
+
+        return cls(headers)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/connection.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/connection.py
new file mode 100644
index 0000000..6da1cf4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/connection.py
@@ -0,0 +1,423 @@
+from __future__ import absolute_import
+import re
+import datetime
+import logging
+import os
+import socket
+from socket import error as SocketError, timeout as SocketTimeout
+import warnings
+from .packages import six
+from .packages.six.moves.http_client import HTTPConnection as _HTTPConnection
+from .packages.six.moves.http_client import HTTPException  # noqa: F401
+
+try:  # Compiled with SSL?
+    import ssl
+
+    BaseSSLError = ssl.SSLError
+except (ImportError, AttributeError):  # Platform-specific: No SSL.
+    ssl = None
+
+    class BaseSSLError(BaseException):
+        pass
+
+
+try:
+    # Python 3: not a no-op, we're adding this to the namespace so it can be imported.
+    ConnectionError = ConnectionError
+except NameError:
+    # Python 2
+    class ConnectionError(Exception):
+        pass
+
+
+from .exceptions import (
+    NewConnectionError,
+    ConnectTimeoutError,
+    SubjectAltNameWarning,
+    SystemTimeWarning,
+)
+from .packages.ssl_match_hostname import match_hostname, CertificateError
+
+from .util.ssl_ import (
+    resolve_cert_reqs,
+    resolve_ssl_version,
+    assert_fingerprint,
+    create_urllib3_context,
+    ssl_wrap_socket,
+)
+
+
+from .util import connection
+
+from ._collections import HTTPHeaderDict
+
+log = logging.getLogger(__name__)
+
+port_by_scheme = {"http": 80, "https": 443}
+
+# When it comes time to update this value as a part of regular maintenance
+# (ie test_recent_date is failing) update it to ~6 months before the current date.
+RECENT_DATE = datetime.date(2019, 1, 1)
+
+_CONTAINS_CONTROL_CHAR_RE = re.compile(r"[^-!#$%&'*+.^_`|~0-9a-zA-Z]")
+
+
+class DummyConnection(object):
+    """Used to detect a failed ConnectionCls import."""
+
+    pass
+
+
+class HTTPConnection(_HTTPConnection, object):
+    """
+    Based on httplib.HTTPConnection but provides an extra constructor
+    backwards-compatibility layer between older and newer Pythons.
+
+    Additional keyword parameters are used to configure attributes of the connection.
+    Accepted parameters include:
+
+      - ``strict``: See the documentation on :class:`urllib3.connectionpool.HTTPConnectionPool`
+      - ``source_address``: Set the source address for the current connection.
+      - ``socket_options``: Set specific options on the underlying socket. If not specified, then
+        defaults are loaded from ``HTTPConnection.default_socket_options`` which includes disabling
+        Nagle's algorithm (sets TCP_NODELAY to 1) unless the connection is behind a proxy.
+
+        For example, if you wish to enable TCP Keep Alive in addition to the defaults,
+        you might pass::
+
+            HTTPConnection.default_socket_options + [
+                (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
+            ]
+
+        Or you may want to disable the defaults by passing an empty list (e.g., ``[]``).
+    """
+
+    default_port = port_by_scheme["http"]
+
+    #: Disable Nagle's algorithm by default.
+    #: ``[(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]``
+    default_socket_options = [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]
+
+    #: Whether this connection verifies the host's certificate.
+    is_verified = False
+
+    def __init__(self, *args, **kw):
+        if not six.PY2:
+            kw.pop("strict", None)
+
+        # Pre-set source_address.
+        self.source_address = kw.get("source_address")
+
+        #: The socket options provided by the user. If no options are
+        #: provided, we use the default options.
+        self.socket_options = kw.pop("socket_options", self.default_socket_options)
+
+        _HTTPConnection.__init__(self, *args, **kw)
+
+    @property
+    def host(self):
+        """
+        Getter method to remove any trailing dots that indicate the hostname is an FQDN.
+
+        In general, SSL certificates don't include the trailing dot indicating a
+        fully-qualified domain name, and thus, they don't validate properly when
+        checked against a domain name that includes the dot. In addition, some
+        servers may not expect to receive the trailing dot when provided.
+
+        However, the hostname with trailing dot is critical to DNS resolution; doing a
+        lookup with the trailing dot will properly only resolve the appropriate FQDN,
+        whereas a lookup without a trailing dot will search the system's search domain
+        list. Thus, it's important to keep the original host around for use only in
+        those cases where it's appropriate (i.e., when doing DNS lookup to establish the
+        actual TCP connection across which we're going to send HTTP requests).
+        """
+        return self._dns_host.rstrip(".")
+
+    @host.setter
+    def host(self, value):
+        """
+        Setter for the `host` property.
+
+        We assume that only urllib3 uses the _dns_host attribute; httplib itself
+        only uses `host`, and it seems reasonable that other libraries follow suit.
+        """
+        self._dns_host = value
+
+    def _new_conn(self):
+        """ Establish a socket connection and set nodelay settings on it.
+
+        :return: New socket connection.
+        """
+        extra_kw = {}
+        if self.source_address:
+            extra_kw["source_address"] = self.source_address
+
+        if self.socket_options:
+            extra_kw["socket_options"] = self.socket_options
+
+        try:
+            conn = connection.create_connection(
+                (self._dns_host, self.port), self.timeout, **extra_kw
+            )
+
+        except SocketTimeout:
+            raise ConnectTimeoutError(
+                self,
+                "Connection to %s timed out. (connect timeout=%s)"
+                % (self.host, self.timeout),
+            )
+
+        except SocketError as e:
+            raise NewConnectionError(
+                self, "Failed to establish a new connection: %s" % e
+            )
+
+        return conn
+
+    def _prepare_conn(self, conn):
+        self.sock = conn
+        # Google App Engine's httplib does not define _tunnel_host
+        if getattr(self, "_tunnel_host", None):
+            # TODO: Fix tunnel so it doesn't depend on self.sock state.
+            self._tunnel()
+            # Mark this connection as not reusable
+            self.auto_open = 0
+
+    def connect(self):
+        conn = self._new_conn()
+        self._prepare_conn(conn)
+
+    def putrequest(self, method, url, *args, **kwargs):
+        """Send a request to the server"""
+        match = _CONTAINS_CONTROL_CHAR_RE.search(method)
+        if match:
+            raise ValueError(
+                "Method cannot contain non-token characters %r (found at least %r)"
+                % (method, match.group())
+            )
+
+        return _HTTPConnection.putrequest(self, method, url, *args, **kwargs)
+
+    def request_chunked(self, method, url, body=None, headers=None):
+        """
+        Alternative to the common request method, which sends the
+        body with chunked encoding and not as one block
+        """
+        headers = HTTPHeaderDict(headers if headers is not None else {})
+        skip_accept_encoding = "accept-encoding" in headers
+        skip_host = "host" in headers
+        self.putrequest(
+            method, url, skip_accept_encoding=skip_accept_encoding, skip_host=skip_host
+        )
+        for header, value in headers.items():
+            self.putheader(header, value)
+        if "transfer-encoding" not in headers:
+            self.putheader("Transfer-Encoding", "chunked")
+        self.endheaders()
+
+        if body is not None:
+            stringish_types = six.string_types + (bytes,)
+            if isinstance(body, stringish_types):
+                body = (body,)
+            for chunk in body:
+                if not chunk:
+                    continue
+                if not isinstance(chunk, bytes):
+                    chunk = chunk.encode("utf8")
+                len_str = hex(len(chunk))[2:]
+                self.send(len_str.encode("utf-8"))
+                self.send(b"\r\n")
+                self.send(chunk)
+                self.send(b"\r\n")
+
+        # After the if clause, to always have a closed body
+        self.send(b"0\r\n\r\n")
+
+
+class HTTPSConnection(HTTPConnection):
+    default_port = port_by_scheme["https"]
+
+    cert_reqs = None
+    ca_certs = None
+    ca_cert_dir = None
+    ca_cert_data = None
+    ssl_version = None
+    assert_fingerprint = None
+
+    def __init__(
+        self,
+        host,
+        port=None,
+        key_file=None,
+        cert_file=None,
+        key_password=None,
+        strict=None,
+        timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
+        ssl_context=None,
+        server_hostname=None,
+        **kw
+    ):
+
+        HTTPConnection.__init__(self, host, port, strict=strict, timeout=timeout, **kw)
+
+        self.key_file = key_file
+        self.cert_file = cert_file
+        self.key_password = key_password
+        self.ssl_context = ssl_context
+        self.server_hostname = server_hostname
+
+        # Required property for Google AppEngine 1.9.0 which otherwise causes
+        # HTTPS requests to go out as HTTP. (See Issue #356)
+        self._protocol = "https"
+
+    def set_cert(
+        self,
+        key_file=None,
+        cert_file=None,
+        cert_reqs=None,
+        key_password=None,
+        ca_certs=None,
+        assert_hostname=None,
+        assert_fingerprint=None,
+        ca_cert_dir=None,
+        ca_cert_data=None,
+    ):
+        """
+        This method should only be called once, before the connection is used.
+        """
+        # If cert_reqs is not provided we'll assume CERT_REQUIRED unless we also
+        # have an SSLContext object in which case we'll use its verify_mode.
+        if cert_reqs is None:
+            if self.ssl_context is not None:
+                cert_reqs = self.ssl_context.verify_mode
+            else:
+                cert_reqs = resolve_cert_reqs(None)
+
+        self.key_file = key_file
+        self.cert_file = cert_file
+        self.cert_reqs = cert_reqs
+        self.key_password = key_password
+        self.assert_hostname = assert_hostname
+        self.assert_fingerprint = assert_fingerprint
+        self.ca_certs = ca_certs and os.path.expanduser(ca_certs)
+        self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir)
+        self.ca_cert_data = ca_cert_data
+
+    def connect(self):
+        # Add certificate verification
+        conn = self._new_conn()
+        hostname = self.host
+
+        # Google App Engine's httplib does not define _tunnel_host
+        if getattr(self, "_tunnel_host", None):
+            self.sock = conn
+            # Calls self._set_hostport(), so self.host is
+            # self._tunnel_host below.
+            self._tunnel()
+            # Mark this connection as not reusable
+            self.auto_open = 0
+
+            # Override the host with the one we're requesting data from.
+            hostname = self._tunnel_host
+
+        server_hostname = hostname
+        if self.server_hostname is not None:
+            server_hostname = self.server_hostname
+
+        is_time_off = datetime.date.today() < RECENT_DATE
+        if is_time_off:
+            warnings.warn(
+                (
+                    "System time is way off (before {0}). This will probably "
+                    "lead to SSL verification errors"
+                ).format(RECENT_DATE),
+                SystemTimeWarning,
+            )
+
+        # Wrap socket using verification with the root certs in
+        # trusted_root_certs
+        default_ssl_context = False
+        if self.ssl_context is None:
+            default_ssl_context = True
+            self.ssl_context = create_urllib3_context(
+                ssl_version=resolve_ssl_version(self.ssl_version),
+                cert_reqs=resolve_cert_reqs(self.cert_reqs),
+            )
+
+        context = self.ssl_context
+        context.verify_mode = resolve_cert_reqs(self.cert_reqs)
+
+        # Try to load OS default certs if none are given.
+        # Works well on Windows (requires Python3.4+)
+        if (
+            not self.ca_certs
+            and not self.ca_cert_dir
+            and not self.ca_cert_data
+            and default_ssl_context
+            and hasattr(context, "load_default_certs")
+        ):
+            context.load_default_certs()
+
+        self.sock = ssl_wrap_socket(
+            sock=conn,
+            keyfile=self.key_file,
+            certfile=self.cert_file,
+            key_password=self.key_password,
+            ca_certs=self.ca_certs,
+            ca_cert_dir=self.ca_cert_dir,
+            ca_cert_data=self.ca_cert_data,
+            server_hostname=server_hostname,
+            ssl_context=context,
+        )
+
+        if self.assert_fingerprint:
+            assert_fingerprint(
+                self.sock.getpeercert(binary_form=True), self.assert_fingerprint
+            )
+        elif (
+            context.verify_mode != ssl.CERT_NONE
+            and not getattr(context, "check_hostname", False)
+            and self.assert_hostname is not False
+        ):
+            # While urllib3 attempts to always turn off hostname matching from
+            # the TLS library, this cannot always be done. So we check whether
+            # the TLS Library still thinks it's matching hostnames.
+            cert = self.sock.getpeercert()
+            if not cert.get("subjectAltName", ()):
+                warnings.warn(
+                    (
+                        "Certificate for {0} has no `subjectAltName`, falling back to check for a "
+                        "`commonName` for now. This feature is being removed by major browsers and "
+                        "deprecated by RFC 2818. (See https://github.com/urllib3/urllib3/issues/497 "
+                        "for details.)".format(hostname)
+                    ),
+                    SubjectAltNameWarning,
+                )
+            _match_hostname(cert, self.assert_hostname or server_hostname)
+
+        self.is_verified = (
+            context.verify_mode == ssl.CERT_REQUIRED
+            or self.assert_fingerprint is not None
+        )
+
+
+def _match_hostname(cert, asserted_hostname):
+    try:
+        match_hostname(cert, asserted_hostname)
+    except CertificateError as e:
+        log.warning(
+            "Certificate did not match expected hostname: %s. Certificate: %s",
+            asserted_hostname,
+            cert,
+        )
+        # Add cert to exception and reraise so client code can inspect
+        # the cert when catching the exception, if they want to
+        e._peer_cert = cert
+        raise
+
+
+if not ssl:
+    HTTPSConnection = DummyConnection  # noqa: F811
+
+
+VerifiedHTTPSConnection = HTTPSConnection
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/connectionpool.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/connectionpool.py
new file mode 100644
index 0000000..5f044db
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/connectionpool.py
@@ -0,0 +1,1033 @@
+from __future__ import absolute_import
+import errno
+import logging
+import sys
+import warnings
+
+from socket import error as SocketError, timeout as SocketTimeout
+import socket
+
+
+from .exceptions import (
+    ClosedPoolError,
+    ProtocolError,
+    EmptyPoolError,
+    HeaderParsingError,
+    HostChangedError,
+    LocationValueError,
+    MaxRetryError,
+    ProxyError,
+    ReadTimeoutError,
+    SSLError,
+    TimeoutError,
+    InsecureRequestWarning,
+    NewConnectionError,
+)
+from .packages.ssl_match_hostname import CertificateError
+from .packages import six
+from .packages.six.moves import queue
+from .connection import (
+    port_by_scheme,
+    DummyConnection,
+    HTTPConnection,
+    HTTPSConnection,
+    VerifiedHTTPSConnection,
+    HTTPException,
+    BaseSSLError,
+)
+from .request import RequestMethods
+from .response import HTTPResponse
+
+from .util.connection import is_connection_dropped
+from .util.request import set_file_position
+from .util.response import assert_header_parsing
+from .util.retry import Retry
+from .util.timeout import Timeout
+from .util.url import (
+    get_host,
+    parse_url,
+    Url,
+    _normalize_host as normalize_host,
+    _encode_target,
+)
+from .util.queue import LifoQueue
+
+
+xrange = six.moves.xrange
+
+log = logging.getLogger(__name__)
+
+_Default = object()
+
+
+# Pool objects
+class ConnectionPool(object):
+    """
+    Base class for all connection pools, such as
+    :class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`.
+
+    .. note::
+       ConnectionPool.urlopen() does not normalize or percent-encode target URIs
+       which is useful if your target server doesn't support percent-encoded
+       target URIs.
+    """
+
+    scheme = None
+    QueueCls = LifoQueue
+
+    def __init__(self, host, port=None):
+        if not host:
+            raise LocationValueError("No host specified.")
+
+        self.host = _normalize_host(host, scheme=self.scheme)
+        self._proxy_host = host.lower()
+        self.port = port
+
+    def __str__(self):
+        return "%s(host=%r, port=%r)" % (type(self).__name__, self.host, self.port)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        # Return False to re-raise any potential exceptions
+        return False
+
+    def close(self):
+        """
+        Close all pooled connections and disable the pool.
+        """
+        pass
+
+
+# This is taken from http://hg.python.org/cpython/file/7aaba721ebc0/Lib/socket.py#l252
+_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK}
+
+
+class HTTPConnectionPool(ConnectionPool, RequestMethods):
+    """
+    Thread-safe connection pool for one host.
+
+    :param host:
+        Host used for this HTTP Connection (e.g. "localhost"), passed into
+        :class:`httplib.HTTPConnection`.
+
+    :param port:
+        Port used for this HTTP Connection (None is equivalent to 80), passed
+        into :class:`httplib.HTTPConnection`.
+
+    :param strict:
+        Causes BadStatusLine to be raised if the status line can't be parsed
+        as a valid HTTP/1.0 or 1.1 status line, passed into
+        :class:`httplib.HTTPConnection`.
+
+        .. note::
+           Only works in Python 2. This parameter is ignored in Python 3.
+
+    :param timeout:
+        Socket timeout in seconds for each individual connection. This can
+        be a float or integer, which sets the timeout for the HTTP request,
+        or an instance of :class:`urllib3.util.Timeout` which gives you more
+        fine-grained control over request timeouts. After the constructor has
+        been parsed, this is always a `urllib3.util.Timeout` object.
+
+    :param maxsize:
+        Number of connections to save that can be reused. More than 1 is useful
+        in multithreaded situations. If ``block`` is set to False, more
+        connections will be created but they will not be saved once they've
+        been used.
+
+    :param block:
+        If set to True, no more than ``maxsize`` connections will be used at
+        a time. When no free connections are available, the call will block
+        until a connection has been released. This is a useful side effect for
+        particular multithreaded situations where one does not want to use more
+        than maxsize connections per host to prevent flooding.
+
+    :param headers:
+        Headers to include with all requests, unless other headers are given
+        explicitly.
+
+    :param retries:
+        Retry configuration to use by default with requests in this pool.
+
+    :param _proxy:
+        Parsed proxy URL, should not be used directly, instead, see
+        :class:`urllib3.connectionpool.ProxyManager`"
+
+    :param _proxy_headers:
+        A dictionary with proxy headers, should not be used directly,
+        instead, see :class:`urllib3.connectionpool.ProxyManager`"
+
+    :param \\**conn_kw:
+        Additional parameters are used to create fresh :class:`urllib3.connection.HTTPConnection`,
+        :class:`urllib3.connection.HTTPSConnection` instances.
+    """
+
+    scheme = "http"
+    ConnectionCls = HTTPConnection
+    ResponseCls = HTTPResponse
+
+    def __init__(
+        self,
+        host,
+        port=None,
+        strict=False,
+        timeout=Timeout.DEFAULT_TIMEOUT,
+        maxsize=1,
+        block=False,
+        headers=None,
+        retries=None,
+        _proxy=None,
+        _proxy_headers=None,
+        **conn_kw
+    ):
+        ConnectionPool.__init__(self, host, port)
+        RequestMethods.__init__(self, headers)
+
+        self.strict = strict
+
+        if not isinstance(timeout, Timeout):
+            timeout = Timeout.from_float(timeout)
+
+        if retries is None:
+            retries = Retry.DEFAULT
+
+        self.timeout = timeout
+        self.retries = retries
+
+        self.pool = self.QueueCls(maxsize)
+        self.block = block
+
+        self.proxy = _proxy
+        self.proxy_headers = _proxy_headers or {}
+
+        # Fill the queue up so that doing get() on it will block properly
+        for _ in xrange(maxsize):
+            self.pool.put(None)
+
+        # These are mostly for testing and debugging purposes.
+        self.num_connections = 0
+        self.num_requests = 0
+        self.conn_kw = conn_kw
+
+        if self.proxy:
+            # Enable Nagle's algorithm for proxies, to avoid packet fragmentation.
+            # We cannot know if the user has added default socket options, so we cannot replace the
+            # list.
+            self.conn_kw.setdefault("socket_options", [])
+
+    def _new_conn(self):
+        """
+        Return a fresh :class:`HTTPConnection`.
+        """
+        self.num_connections += 1
+        log.debug(
+            "Starting new HTTP connection (%d): %s:%s",
+            self.num_connections,
+            self.host,
+            self.port or "80",
+        )
+
+        conn = self.ConnectionCls(
+            host=self.host,
+            port=self.port,
+            timeout=self.timeout.connect_timeout,
+            strict=self.strict,
+            **self.conn_kw
+        )
+        return conn
+
+    def _get_conn(self, timeout=None):
+        """
+        Get a connection. Will return a pooled connection if one is available.
+
+        If no connections are available and :prop:`.block` is ``False``, then a
+        fresh connection is returned.
+
+        :param timeout:
+            Seconds to wait before giving up and raising
+            :class:`urllib3.exceptions.EmptyPoolError` if the pool is empty and
+            :prop:`.block` is ``True``.
+        """
+        conn = None
+        try:
+            conn = self.pool.get(block=self.block, timeout=timeout)
+
+        except AttributeError:  # self.pool is None
+            raise ClosedPoolError(self, "Pool is closed.")
+
+        except queue.Empty:
+            if self.block:
+                raise EmptyPoolError(
+                    self,
+                    "Pool reached maximum size and no more connections are allowed.",
+                )
+            pass  # Oh well, we'll create a new connection then
+
+        # If this is a persistent connection, check if it got disconnected
+        if conn and is_connection_dropped(conn):
+            log.debug("Resetting dropped connection: %s", self.host)
+            conn.close()
+            if getattr(conn, "auto_open", 1) == 0:
+                # This is a proxied connection that has been mutated by
+                # httplib._tunnel() and cannot be reused (since it would
+                # attempt to bypass the proxy)
+                conn = None
+
+        return conn or self._new_conn()
+
+    def _put_conn(self, conn):
+        """
+        Put a connection back into the pool.
+
+        :param conn:
+            Connection object for the current host and port as returned by
+            :meth:`._new_conn` or :meth:`._get_conn`.
+
+        If the pool is already full, the connection is closed and discarded
+        because we exceeded maxsize. If connections are discarded frequently,
+        then maxsize should be increased.
+
+        If the pool is closed, then the connection will be closed and discarded.
+        """
+        try:
+            self.pool.put(conn, block=False)
+            return  # Everything is dandy, done.
+        except AttributeError:
+            # self.pool is None.
+            pass
+        except queue.Full:
+            # This should never happen if self.block == True
+            log.warning("Connection pool is full, discarding connection: %s", self.host)
+
+        # Connection never got put back into the pool, close it.
+        if conn:
+            conn.close()
+
+    def _validate_conn(self, conn):
+        """
+        Called right before a request is made, after the socket is created.
+        """
+        pass
+
+    def _prepare_proxy(self, conn):
+        # Nothing to do for HTTP connections.
+        pass
+
+    def _get_timeout(self, timeout):
+        """ Helper that always returns a :class:`urllib3.util.Timeout` """
+        if timeout is _Default:
+            return self.timeout.clone()
+
+        if isinstance(timeout, Timeout):
+            return timeout.clone()
+        else:
+            # User passed us an int/float. This is for backwards compatibility,
+            # can be removed later
+            return Timeout.from_float(timeout)
+
+    def _raise_timeout(self, err, url, timeout_value):
+        """Is the error actually a timeout? Will raise a ReadTimeout or pass"""
+
+        if isinstance(err, SocketTimeout):
+            raise ReadTimeoutError(
+                self, url, "Read timed out. (read timeout=%s)" % timeout_value
+            )
+
+        # See the above comment about EAGAIN in Python 3. In Python 2 we have
+        # to specifically catch it and throw the timeout error
+        if hasattr(err, "errno") and err.errno in _blocking_errnos:
+            raise ReadTimeoutError(
+                self, url, "Read timed out. (read timeout=%s)" % timeout_value
+            )
+
+        # Catch possible read timeouts thrown as SSL errors. If not the
+        # case, rethrow the original. We need to do this because of:
+        # http://bugs.python.org/issue10272
+        if "timed out" in str(err) or "did not complete (read)" in str(
+            err
+        ):  # Python < 2.7.4
+            raise ReadTimeoutError(
+                self, url, "Read timed out. (read timeout=%s)" % timeout_value
+            )
+
+    def _make_request(
+        self, conn, method, url, timeout=_Default, chunked=False, **httplib_request_kw
+    ):
+        """
+        Perform a request on a given urllib connection object taken from our
+        pool.
+
+        :param conn:
+            a connection from one of our connection pools
+
+        :param timeout:
+            Socket timeout in seconds for the request. This can be a
+            float or integer, which will set the same timeout value for
+            the socket connect and the socket read, or an instance of
+            :class:`urllib3.util.Timeout`, which gives you more fine-grained
+            control over your timeouts.
+        """
+        self.num_requests += 1
+
+        timeout_obj = self._get_timeout(timeout)
+        timeout_obj.start_connect()
+        conn.timeout = timeout_obj.connect_timeout
+
+        # Trigger any extra validation we need to do.
+        try:
+            self._validate_conn(conn)
+        except (SocketTimeout, BaseSSLError) as e:
+            # Py2 raises this as a BaseSSLError, Py3 raises it as socket timeout.
+            self._raise_timeout(err=e, url=url, timeout_value=conn.timeout)
+            raise
+
+        # conn.request() calls httplib.*.request, not the method in
+        # urllib3.request. It also calls makefile (recv) on the socket.
+        if chunked:
+            conn.request_chunked(method, url, **httplib_request_kw)
+        else:
+            conn.request(method, url, **httplib_request_kw)
+
+        # Reset the timeout for the recv() on the socket
+        read_timeout = timeout_obj.read_timeout
+
+        # App Engine doesn't have a sock attr
+        if getattr(conn, "sock", None):
+            # In Python 3 socket.py will catch EAGAIN and return None when you
+            # try and read into the file pointer created by http.client, which
+            # instead raises a BadStatusLine exception. Instead of catching
+            # the exception and assuming all BadStatusLine exceptions are read
+            # timeouts, check for a zero timeout before making the request.
+            if read_timeout == 0:
+                raise ReadTimeoutError(
+                    self, url, "Read timed out. (read timeout=%s)" % read_timeout
+                )
+            if read_timeout is Timeout.DEFAULT_TIMEOUT:
+                conn.sock.settimeout(socket.getdefaulttimeout())
+            else:  # None or a value
+                conn.sock.settimeout(read_timeout)
+
+        # Receive the response from the server
+        try:
+            try:
+                # Python 2.7, use buffering of HTTP responses
+                httplib_response = conn.getresponse(buffering=True)
+            except TypeError:
+                # Python 3
+                try:
+                    httplib_response = conn.getresponse()
+                except BaseException as e:
+                    # Remove the TypeError from the exception chain in
+                    # Python 3 (including for exceptions like SystemExit).
+                    # Otherwise it looks like a bug in the code.
+                    six.raise_from(e, None)
+        except (SocketTimeout, BaseSSLError, SocketError) as e:
+            self._raise_timeout(err=e, url=url, timeout_value=read_timeout)
+            raise
+
+        # AppEngine doesn't have a version attr.
+        http_version = getattr(conn, "_http_vsn_str", "HTTP/?")
+        log.debug(
+            '%s://%s:%s "%s %s %s" %s %s',
+            self.scheme,
+            self.host,
+            self.port,
+            method,
+            url,
+            http_version,
+            httplib_response.status,
+            httplib_response.length,
+        )
+
+        try:
+            assert_header_parsing(httplib_response.msg)
+        except (HeaderParsingError, TypeError) as hpe:  # Platform-specific: Python 3
+            log.warning(
+                "Failed to parse headers (url=%s): %s",
+                self._absolute_url(url),
+                hpe,
+                exc_info=True,
+            )
+
+        return httplib_response
+
+    def _absolute_url(self, path):
+        return Url(scheme=self.scheme, host=self.host, port=self.port, path=path).url
+
+    def close(self):
+        """
+        Close all pooled connections and disable the pool.
+        """
+        if self.pool is None:
+            return
+        # Disable access to the pool
+        old_pool, self.pool = self.pool, None
+
+        try:
+            while True:
+                conn = old_pool.get(block=False)
+                if conn:
+                    conn.close()
+
+        except queue.Empty:
+            pass  # Done.
+
+    def is_same_host(self, url):
+        """
+        Check if the given ``url`` is a member of the same host as this
+        connection pool.
+        """
+        if url.startswith("/"):
+            return True
+
+        # TODO: Add optional support for socket.gethostbyname checking.
+        scheme, host, port = get_host(url)
+        if host is not None:
+            host = _normalize_host(host, scheme=scheme)
+
+        # Use explicit default port for comparison when none is given
+        if self.port and not port:
+            port = port_by_scheme.get(scheme)
+        elif not self.port and port == port_by_scheme.get(scheme):
+            port = None
+
+        return (scheme, host, port) == (self.scheme, self.host, self.port)
+
+    def urlopen(
+        self,
+        method,
+        url,
+        body=None,
+        headers=None,
+        retries=None,
+        redirect=True,
+        assert_same_host=True,
+        timeout=_Default,
+        pool_timeout=None,
+        release_conn=None,
+        chunked=False,
+        body_pos=None,
+        **response_kw
+    ):
+        """
+        Get a connection from the pool and perform an HTTP request. This is the
+        lowest level call for making a request, so you'll need to specify all
+        the raw details.
+
+        .. note::
+
+           More commonly, it's appropriate to use a convenience method provided
+           by :class:`.RequestMethods`, such as :meth:`request`.
+
+        .. note::
+
+           `release_conn` will only behave as expected if
+           `preload_content=False` because we want to make
+           `preload_content=False` the default behaviour someday soon without
+           breaking backwards compatibility.
+
+        :param method:
+            HTTP request method (such as GET, POST, PUT, etc.)
+
+        :param body:
+            Data to send in the request body (useful for creating
+            POST requests, see HTTPConnectionPool.post_url for
+            more convenience).
+
+        :param headers:
+            Dictionary of custom headers to send, such as User-Agent,
+            If-None-Match, etc. If None, pool headers are used. If provided,
+            these headers completely replace any pool-specific headers.
+
+        :param retries:
+            Configure the number of retries to allow before raising a
+            :class:`~urllib3.exceptions.MaxRetryError` exception.
+
+            Pass ``None`` to retry until you receive a response. Pass a
+            :class:`~urllib3.util.retry.Retry` object for fine-grained control
+            over different types of retries.
+            Pass an integer number to retry connection errors that many times,
+            but no other types of errors. Pass zero to never retry.
+
+            If ``False``, then retries are disabled and any exception is raised
+            immediately. Also, instead of raising a MaxRetryError on redirects,
+            the redirect response will be returned.
+
+        :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int.
+
+        :param redirect:
+            If True, automatically handle redirects (status codes 301, 302,
+            303, 307, 308). Each redirect counts as a retry. Disabling retries
+            will disable redirect, too.
+
+        :param assert_same_host:
+            If ``True``, will make sure that the host of the pool requests is
+            consistent else will raise HostChangedError. When False, you can
+            use the pool on an HTTP proxy and request foreign hosts.
+
+        :param timeout:
+            If specified, overrides the default timeout for this one
+            request. It may be a float (in seconds) or an instance of
+            :class:`urllib3.util.Timeout`.
+
+        :param pool_timeout:
+            If set and the pool is set to block=True, then this method will
+            block for ``pool_timeout`` seconds and raise EmptyPoolError if no
+            connection is available within the time period.
+
+        :param release_conn:
+            If False, then the urlopen call will not release the connection
+            back into the pool once a response is received (but will release if
+            you read the entire contents of the response such as when
+            `preload_content=True`). This is useful if you're not preloading
+            the response's content immediately. You will need to call
+            ``r.release_conn()`` on the response ``r`` to return the connection
+            back into the pool. If None, it takes the value of
+            ``response_kw.get('preload_content', True)``.
+
+        :param chunked:
+            If True, urllib3 will send the body using chunked transfer
+            encoding. Otherwise, urllib3 will send the body using the standard
+            content-length form. Defaults to False.
+
+        :param int body_pos:
+            Position to seek to in file-like body in the event of a retry or
+            redirect. Typically this won't need to be set because urllib3 will
+            auto-populate the value when needed.
+
+        :param \\**response_kw:
+            Additional parameters are passed to
+            :meth:`urllib3.response.HTTPResponse.from_httplib`
+        """
+        if headers is None:
+            headers = self.headers
+
+        if not isinstance(retries, Retry):
+            retries = Retry.from_int(retries, redirect=redirect, default=self.retries)
+
+        if release_conn is None:
+            release_conn = response_kw.get("preload_content", True)
+
+        # Check host
+        if assert_same_host and not self.is_same_host(url):
+            raise HostChangedError(self, url, retries)
+
+        # Ensure that the URL we're connecting to is properly encoded
+        if url.startswith("/"):
+            url = six.ensure_str(_encode_target(url))
+        else:
+            url = six.ensure_str(parse_url(url).url)
+
+        conn = None
+
+        # Track whether `conn` needs to be released before
+        # returning/raising/recursing. Update this variable if necessary, and
+        # leave `release_conn` constant throughout the function. That way, if
+        # the function recurses, the original value of `release_conn` will be
+        # passed down into the recursive call, and its value will be respected.
+        #
+        # See issue #651 [1] for details.
+        #
+        # [1] <https://github.com/urllib3/urllib3/issues/651>
+        release_this_conn = release_conn
+
+        # Merge the proxy headers. Only do this in HTTP. We have to copy the
+        # headers dict so we can safely change it without those changes being
+        # reflected in anyone else's copy.
+        if self.scheme == "http":
+            headers = headers.copy()
+            headers.update(self.proxy_headers)
+
+        # Must keep the exception bound to a separate variable or else Python 3
+        # complains about UnboundLocalError.
+        err = None
+
+        # Keep track of whether we cleanly exited the except block. This
+        # ensures we do proper cleanup in finally.
+        clean_exit = False
+
+        # Rewind body position, if needed. Record current position
+        # for future rewinds in the event of a redirect/retry.
+        body_pos = set_file_position(body, body_pos)
+
+        try:
+            # Request a connection from the queue.
+            timeout_obj = self._get_timeout(timeout)
+            conn = self._get_conn(timeout=pool_timeout)
+
+            conn.timeout = timeout_obj.connect_timeout
+
+            is_new_proxy_conn = self.proxy is not None and not getattr(
+                conn, "sock", None
+            )
+            if is_new_proxy_conn:
+                self._prepare_proxy(conn)
+
+            # Make the request on the httplib connection object.
+            httplib_response = self._make_request(
+                conn,
+                method,
+                url,
+                timeout=timeout_obj,
+                body=body,
+                headers=headers,
+                chunked=chunked,
+            )
+
+            # If we're going to release the connection in ``finally:``, then
+            # the response doesn't need to know about the connection. Otherwise
+            # it will also try to release it and we'll have a double-release
+            # mess.
+            response_conn = conn if not release_conn else None
+
+            # Pass method to Response for length checking
+            response_kw["request_method"] = method
+
+            # Import httplib's response into our own wrapper object
+            response = self.ResponseCls.from_httplib(
+                httplib_response,
+                pool=self,
+                connection=response_conn,
+                retries=retries,
+                **response_kw
+            )
+
+            # Everything went great!
+            clean_exit = True
+
+        except queue.Empty:
+            # Timed out by queue.
+            raise EmptyPoolError(self, "No pool connections are available.")
+
+        except (
+            TimeoutError,
+            HTTPException,
+            SocketError,
+            ProtocolError,
+            BaseSSLError,
+            SSLError,
+            CertificateError,
+        ) as e:
+            # Discard the connection for these exceptions. It will be
+            # replaced during the next _get_conn() call.
+            clean_exit = False
+            if isinstance(e, (BaseSSLError, CertificateError)):
+                e = SSLError(e)
+            elif isinstance(e, (SocketError, NewConnectionError)) and self.proxy:
+                e = ProxyError("Cannot connect to proxy.", e)
+            elif isinstance(e, (SocketError, HTTPException)):
+                e = ProtocolError("Connection aborted.", e)
+
+            retries = retries.increment(
+                method, url, error=e, _pool=self, _stacktrace=sys.exc_info()[2]
+            )
+            retries.sleep()
+
+            # Keep track of the error for the retry warning.
+            err = e
+
+        finally:
+            if not clean_exit:
+                # We hit some kind of exception, handled or otherwise. We need
+                # to throw the connection away unless explicitly told not to.
+                # Close the connection, set the variable to None, and make sure
+                # we put the None back in the pool to avoid leaking it.
+                conn = conn and conn.close()
+                release_this_conn = True
+
+            if release_this_conn:
+                # Put the connection back to be reused. If the connection is
+                # expired then it will be None, which will get replaced with a
+                # fresh connection during _get_conn.
+                self._put_conn(conn)
+
+        if not conn:
+            # Try again
+            log.warning(
+                "Retrying (%r) after connection broken by '%r': %s", retries, err, url
+            )
+            return self.urlopen(
+                method,
+                url,
+                body,
+                headers,
+                retries,
+                redirect,
+                assert_same_host,
+                timeout=timeout,
+                pool_timeout=pool_timeout,
+                release_conn=release_conn,
+                chunked=chunked,
+                body_pos=body_pos,
+                **response_kw
+            )
+
+        # Handle redirect?
+        redirect_location = redirect and response.get_redirect_location()
+        if redirect_location:
+            if response.status == 303:
+                method = "GET"
+
+            try:
+                retries = retries.increment(method, url, response=response, _pool=self)
+            except MaxRetryError:
+                if retries.raise_on_redirect:
+                    response.drain_conn()
+                    raise
+                return response
+
+            response.drain_conn()
+            retries.sleep_for_retry(response)
+            log.debug("Redirecting %s -> %s", url, redirect_location)
+            return self.urlopen(
+                method,
+                redirect_location,
+                body,
+                headers,
+                retries=retries,
+                redirect=redirect,
+                assert_same_host=assert_same_host,
+                timeout=timeout,
+                pool_timeout=pool_timeout,
+                release_conn=release_conn,
+                chunked=chunked,
+                body_pos=body_pos,
+                **response_kw
+            )
+
+        # Check if we should retry the HTTP response.
+        has_retry_after = bool(response.getheader("Retry-After"))
+        if retries.is_retry(method, response.status, has_retry_after):
+            try:
+                retries = retries.increment(method, url, response=response, _pool=self)
+            except MaxRetryError:
+                if retries.raise_on_status:
+                    response.drain_conn()
+                    raise
+                return response
+
+            response.drain_conn()
+            retries.sleep(response)
+            log.debug("Retry: %s", url)
+            return self.urlopen(
+                method,
+                url,
+                body,
+                headers,
+                retries=retries,
+                redirect=redirect,
+                assert_same_host=assert_same_host,
+                timeout=timeout,
+                pool_timeout=pool_timeout,
+                release_conn=release_conn,
+                chunked=chunked,
+                body_pos=body_pos,
+                **response_kw
+            )
+
+        return response
+
+
+class HTTPSConnectionPool(HTTPConnectionPool):
+    """
+    Same as :class:`.HTTPConnectionPool`, but HTTPS.
+
+    When Python is compiled with the :mod:`ssl` module, then
+    :class:`.VerifiedHTTPSConnection` is used, which *can* verify certificates,
+    instead of :class:`.HTTPSConnection`.
+
+    :class:`.VerifiedHTTPSConnection` uses one of ``assert_fingerprint``,
+    ``assert_hostname`` and ``host`` in this order to verify connections.
+    If ``assert_hostname`` is False, no verification is done.
+
+    The ``key_file``, ``cert_file``, ``cert_reqs``, ``ca_certs``,
+    ``ca_cert_dir``, ``ssl_version``, ``key_password`` are only used if :mod:`ssl`
+    is available and are fed into :meth:`urllib3.util.ssl_wrap_socket` to upgrade
+    the connection socket into an SSL socket.
+    """
+
+    scheme = "https"
+    ConnectionCls = HTTPSConnection
+
+    def __init__(
+        self,
+        host,
+        port=None,
+        strict=False,
+        timeout=Timeout.DEFAULT_TIMEOUT,
+        maxsize=1,
+        block=False,
+        headers=None,
+        retries=None,
+        _proxy=None,
+        _proxy_headers=None,
+        key_file=None,
+        cert_file=None,
+        cert_reqs=None,
+        key_password=None,
+        ca_certs=None,
+        ssl_version=None,
+        assert_hostname=None,
+        assert_fingerprint=None,
+        ca_cert_dir=None,
+        **conn_kw
+    ):
+
+        HTTPConnectionPool.__init__(
+            self,
+            host,
+            port,
+            strict,
+            timeout,
+            maxsize,
+            block,
+            headers,
+            retries,
+            _proxy,
+            _proxy_headers,
+            **conn_kw
+        )
+
+        self.key_file = key_file
+        self.cert_file = cert_file
+        self.cert_reqs = cert_reqs
+        self.key_password = key_password
+        self.ca_certs = ca_certs
+        self.ca_cert_dir = ca_cert_dir
+        self.ssl_version = ssl_version
+        self.assert_hostname = assert_hostname
+        self.assert_fingerprint = assert_fingerprint
+
+    def _prepare_conn(self, conn):
+        """
+        Prepare the ``connection`` for :meth:`urllib3.util.ssl_wrap_socket`
+        and establish the tunnel if proxy is used.
+        """
+
+        if isinstance(conn, VerifiedHTTPSConnection):
+            conn.set_cert(
+                key_file=self.key_file,
+                key_password=self.key_password,
+                cert_file=self.cert_file,
+                cert_reqs=self.cert_reqs,
+                ca_certs=self.ca_certs,
+                ca_cert_dir=self.ca_cert_dir,
+                assert_hostname=self.assert_hostname,
+                assert_fingerprint=self.assert_fingerprint,
+            )
+            conn.ssl_version = self.ssl_version
+        return conn
+
+    def _prepare_proxy(self, conn):
+        """
+        Establish tunnel connection early, because otherwise httplib
+        would improperly set Host: header to proxy's IP:port.
+        """
+        conn.set_tunnel(self._proxy_host, self.port, self.proxy_headers)
+        conn.connect()
+
+    def _new_conn(self):
+        """
+        Return a fresh :class:`httplib.HTTPSConnection`.
+        """
+        self.num_connections += 1
+        log.debug(
+            "Starting new HTTPS connection (%d): %s:%s",
+            self.num_connections,
+            self.host,
+            self.port or "443",
+        )
+
+        if not self.ConnectionCls or self.ConnectionCls is DummyConnection:
+            raise SSLError(
+                "Can't connect to HTTPS URL because the SSL module is not available."
+            )
+
+        actual_host = self.host
+        actual_port = self.port
+        if self.proxy is not None:
+            actual_host = self.proxy.host
+            actual_port = self.proxy.port
+
+        conn = self.ConnectionCls(
+            host=actual_host,
+            port=actual_port,
+            timeout=self.timeout.connect_timeout,
+            strict=self.strict,
+            cert_file=self.cert_file,
+            key_file=self.key_file,
+            key_password=self.key_password,
+            **self.conn_kw
+        )
+
+        return self._prepare_conn(conn)
+
+    def _validate_conn(self, conn):
+        """
+        Called right before a request is made, after the socket is created.
+        """
+        super(HTTPSConnectionPool, self)._validate_conn(conn)
+
+        # Force connect early to allow us to validate the connection.
+        if not getattr(conn, "sock", None):  # AppEngine might not have  `.sock`
+            conn.connect()
+
+        if not conn.is_verified:
+            warnings.warn(
+                (
+                    "Unverified HTTPS request is being made to host '%s'. "
+                    "Adding certificate verification is strongly advised. See: "
+                    "https://urllib3.readthedocs.io/en/latest/advanced-usage.html"
+                    "#ssl-warnings" % conn.host
+                ),
+                InsecureRequestWarning,
+            )
+
+
+def connection_from_url(url, **kw):
+    """
+    Given a url, return an :class:`.ConnectionPool` instance of its host.
+
+    This is a shortcut for not having to parse out the scheme, host, and port
+    of the url before creating an :class:`.ConnectionPool` instance.
+
+    :param url:
+        Absolute URL string that must include the scheme. Port is optional.
+
+    :param \\**kw:
+        Passes additional parameters to the constructor of the appropriate
+        :class:`.ConnectionPool`. Useful for specifying things like
+        timeout, maxsize, headers, etc.
+
+    Example::
+
+        >>> conn = connection_from_url('http://google.com/')
+        >>> r = conn.request('GET', '/')
+    """
+    scheme, host, port = get_host(url)
+    port = port or port_by_scheme.get(scheme, 80)
+    if scheme == "https":
+        return HTTPSConnectionPool(host, port=port, **kw)
+    else:
+        return HTTPConnectionPool(host, port=port, **kw)
+
+
+def _normalize_host(host, scheme):
+    """
+    Normalize hosts for comparisons and use with sockets.
+    """
+
+    host = normalize_host(host, scheme)
+
+    # httplib doesn't like it when we include brackets in IPv6 addresses
+    # Specifically, if we include brackets but also pass the port then
+    # httplib crazily doubles up the square brackets on the Host header.
+    # Instead, we need to make sure we never pass ``None`` as the port.
+    # However, for backward compatibility reasons we can't actually
+    # *assert* that.  See http://bugs.python.org/issue28539
+    if host.startswith("[") and host.endswith("]"):
+        host = host[1:-1]
+    return host
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py
new file mode 100644
index 0000000..8765b90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py
@@ -0,0 +1,36 @@
+"""
+This module provides means to detect the App Engine environment.
+"""
+
+import os
+
+
+def is_appengine():
+    return is_local_appengine() or is_prod_appengine()
+
+
+def is_appengine_sandbox():
+    """Reports if the app is running in the first generation sandbox.
+
+    The second generation runtimes are technically still in a sandbox, but it
+    is much less restrictive, so generally you shouldn't need to check for it.
+    see https://cloud.google.com/appengine/docs/standard/runtimes
+    """
+    return is_appengine() and os.environ["APPENGINE_RUNTIME"] == "python27"
+
+
+def is_local_appengine():
+    return "APPENGINE_RUNTIME" in os.environ and os.environ.get(
+        "SERVER_SOFTWARE", ""
+    ).startswith("Development/")
+
+
+def is_prod_appengine():
+    return "APPENGINE_RUNTIME" in os.environ and os.environ.get(
+        "SERVER_SOFTWARE", ""
+    ).startswith("Google App Engine/")
+
+
+def is_prod_appengine_mvms():
+    """Deprecated."""
+    return False
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py
new file mode 100644
index 0000000..d9b6733
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py
@@ -0,0 +1,493 @@
+"""
+This module uses ctypes to bind a whole bunch of functions and constants from
+SecureTransport. The goal here is to provide the low-level API to
+SecureTransport. These are essentially the C-level functions and constants, and
+they're pretty gross to work with.
+
+This code is a bastardised version of the code found in Will Bond's oscrypto
+library. An enormous debt is owed to him for blazing this trail for us. For
+that reason, this code should be considered to be covered both by urllib3's
+license and by oscrypto's:
+
+    Copyright (c) 2015-2016 Will Bond <will@wbond.net>
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+"""
+from __future__ import absolute_import
+
+import platform
+from ctypes.util import find_library
+from ctypes import (
+    c_void_p,
+    c_int32,
+    c_char_p,
+    c_size_t,
+    c_byte,
+    c_uint32,
+    c_ulong,
+    c_long,
+    c_bool,
+)
+from ctypes import CDLL, POINTER, CFUNCTYPE
+
+
+security_path = find_library("Security")
+if not security_path:
+    raise ImportError("The library Security could not be found")
+
+
+core_foundation_path = find_library("CoreFoundation")
+if not core_foundation_path:
+    raise ImportError("The library CoreFoundation could not be found")
+
+
+version = platform.mac_ver()[0]
+version_info = tuple(map(int, version.split(".")))
+if version_info < (10, 8):
+    raise OSError(
+        "Only OS X 10.8 and newer are supported, not %s.%s"
+        % (version_info[0], version_info[1])
+    )
+
+Security = CDLL(security_path, use_errno=True)
+CoreFoundation = CDLL(core_foundation_path, use_errno=True)
+
+Boolean = c_bool
+CFIndex = c_long
+CFStringEncoding = c_uint32
+CFData = c_void_p
+CFString = c_void_p
+CFArray = c_void_p
+CFMutableArray = c_void_p
+CFDictionary = c_void_p
+CFError = c_void_p
+CFType = c_void_p
+CFTypeID = c_ulong
+
+CFTypeRef = POINTER(CFType)
+CFAllocatorRef = c_void_p
+
+OSStatus = c_int32
+
+CFDataRef = POINTER(CFData)
+CFStringRef = POINTER(CFString)
+CFArrayRef = POINTER(CFArray)
+CFMutableArrayRef = POINTER(CFMutableArray)
+CFDictionaryRef = POINTER(CFDictionary)
+CFArrayCallBacks = c_void_p
+CFDictionaryKeyCallBacks = c_void_p
+CFDictionaryValueCallBacks = c_void_p
+
+SecCertificateRef = POINTER(c_void_p)
+SecExternalFormat = c_uint32
+SecExternalItemType = c_uint32
+SecIdentityRef = POINTER(c_void_p)
+SecItemImportExportFlags = c_uint32
+SecItemImportExportKeyParameters = c_void_p
+SecKeychainRef = POINTER(c_void_p)
+SSLProtocol = c_uint32
+SSLCipherSuite = c_uint32
+SSLContextRef = POINTER(c_void_p)
+SecTrustRef = POINTER(c_void_p)
+SSLConnectionRef = c_uint32
+SecTrustResultType = c_uint32
+SecTrustOptionFlags = c_uint32
+SSLProtocolSide = c_uint32
+SSLConnectionType = c_uint32
+SSLSessionOption = c_uint32
+
+
+try:
+    Security.SecItemImport.argtypes = [
+        CFDataRef,
+        CFStringRef,
+        POINTER(SecExternalFormat),
+        POINTER(SecExternalItemType),
+        SecItemImportExportFlags,
+        POINTER(SecItemImportExportKeyParameters),
+        SecKeychainRef,
+        POINTER(CFArrayRef),
+    ]
+    Security.SecItemImport.restype = OSStatus
+
+    Security.SecCertificateGetTypeID.argtypes = []
+    Security.SecCertificateGetTypeID.restype = CFTypeID
+
+    Security.SecIdentityGetTypeID.argtypes = []
+    Security.SecIdentityGetTypeID.restype = CFTypeID
+
+    Security.SecKeyGetTypeID.argtypes = []
+    Security.SecKeyGetTypeID.restype = CFTypeID
+
+    Security.SecCertificateCreateWithData.argtypes = [CFAllocatorRef, CFDataRef]
+    Security.SecCertificateCreateWithData.restype = SecCertificateRef
+
+    Security.SecCertificateCopyData.argtypes = [SecCertificateRef]
+    Security.SecCertificateCopyData.restype = CFDataRef
+
+    Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p]
+    Security.SecCopyErrorMessageString.restype = CFStringRef
+
+    Security.SecIdentityCreateWithCertificate.argtypes = [
+        CFTypeRef,
+        SecCertificateRef,
+        POINTER(SecIdentityRef),
+    ]
+    Security.SecIdentityCreateWithCertificate.restype = OSStatus
+
+    Security.SecKeychainCreate.argtypes = [
+        c_char_p,
+        c_uint32,
+        c_void_p,
+        Boolean,
+        c_void_p,
+        POINTER(SecKeychainRef),
+    ]
+    Security.SecKeychainCreate.restype = OSStatus
+
+    Security.SecKeychainDelete.argtypes = [SecKeychainRef]
+    Security.SecKeychainDelete.restype = OSStatus
+
+    Security.SecPKCS12Import.argtypes = [
+        CFDataRef,
+        CFDictionaryRef,
+        POINTER(CFArrayRef),
+    ]
+    Security.SecPKCS12Import.restype = OSStatus
+
+    SSLReadFunc = CFUNCTYPE(OSStatus, SSLConnectionRef, c_void_p, POINTER(c_size_t))
+    SSLWriteFunc = CFUNCTYPE(
+        OSStatus, SSLConnectionRef, POINTER(c_byte), POINTER(c_size_t)
+    )
+
+    Security.SSLSetIOFuncs.argtypes = [SSLContextRef, SSLReadFunc, SSLWriteFunc]
+    Security.SSLSetIOFuncs.restype = OSStatus
+
+    Security.SSLSetPeerID.argtypes = [SSLContextRef, c_char_p, c_size_t]
+    Security.SSLSetPeerID.restype = OSStatus
+
+    Security.SSLSetCertificate.argtypes = [SSLContextRef, CFArrayRef]
+    Security.SSLSetCertificate.restype = OSStatus
+
+    Security.SSLSetCertificateAuthorities.argtypes = [SSLContextRef, CFTypeRef, Boolean]
+    Security.SSLSetCertificateAuthorities.restype = OSStatus
+
+    Security.SSLSetConnection.argtypes = [SSLContextRef, SSLConnectionRef]
+    Security.SSLSetConnection.restype = OSStatus
+
+    Security.SSLSetPeerDomainName.argtypes = [SSLContextRef, c_char_p, c_size_t]
+    Security.SSLSetPeerDomainName.restype = OSStatus
+
+    Security.SSLHandshake.argtypes = [SSLContextRef]
+    Security.SSLHandshake.restype = OSStatus
+
+    Security.SSLRead.argtypes = [SSLContextRef, c_char_p, c_size_t, POINTER(c_size_t)]
+    Security.SSLRead.restype = OSStatus
+
+    Security.SSLWrite.argtypes = [SSLContextRef, c_char_p, c_size_t, POINTER(c_size_t)]
+    Security.SSLWrite.restype = OSStatus
+
+    Security.SSLClose.argtypes = [SSLContextRef]
+    Security.SSLClose.restype = OSStatus
+
+    Security.SSLGetNumberSupportedCiphers.argtypes = [SSLContextRef, POINTER(c_size_t)]
+    Security.SSLGetNumberSupportedCiphers.restype = OSStatus
+
+    Security.SSLGetSupportedCiphers.argtypes = [
+        SSLContextRef,
+        POINTER(SSLCipherSuite),
+        POINTER(c_size_t),
+    ]
+    Security.SSLGetSupportedCiphers.restype = OSStatus
+
+    Security.SSLSetEnabledCiphers.argtypes = [
+        SSLContextRef,
+        POINTER(SSLCipherSuite),
+        c_size_t,
+    ]
+    Security.SSLSetEnabledCiphers.restype = OSStatus
+
+    Security.SSLGetNumberEnabledCiphers.argtype = [SSLContextRef, POINTER(c_size_t)]
+    Security.SSLGetNumberEnabledCiphers.restype = OSStatus
+
+    Security.SSLGetEnabledCiphers.argtypes = [
+        SSLContextRef,
+        POINTER(SSLCipherSuite),
+        POINTER(c_size_t),
+    ]
+    Security.SSLGetEnabledCiphers.restype = OSStatus
+
+    Security.SSLGetNegotiatedCipher.argtypes = [SSLContextRef, POINTER(SSLCipherSuite)]
+    Security.SSLGetNegotiatedCipher.restype = OSStatus
+
+    Security.SSLGetNegotiatedProtocolVersion.argtypes = [
+        SSLContextRef,
+        POINTER(SSLProtocol),
+    ]
+    Security.SSLGetNegotiatedProtocolVersion.restype = OSStatus
+
+    Security.SSLCopyPeerTrust.argtypes = [SSLContextRef, POINTER(SecTrustRef)]
+    Security.SSLCopyPeerTrust.restype = OSStatus
+
+    Security.SecTrustSetAnchorCertificates.argtypes = [SecTrustRef, CFArrayRef]
+    Security.SecTrustSetAnchorCertificates.restype = OSStatus
+
+    Security.SecTrustSetAnchorCertificatesOnly.argstypes = [SecTrustRef, Boolean]
+    Security.SecTrustSetAnchorCertificatesOnly.restype = OSStatus
+
+    Security.SecTrustEvaluate.argtypes = [SecTrustRef, POINTER(SecTrustResultType)]
+    Security.SecTrustEvaluate.restype = OSStatus
+
+    Security.SecTrustGetCertificateCount.argtypes = [SecTrustRef]
+    Security.SecTrustGetCertificateCount.restype = CFIndex
+
+    Security.SecTrustGetCertificateAtIndex.argtypes = [SecTrustRef, CFIndex]
+    Security.SecTrustGetCertificateAtIndex.restype = SecCertificateRef
+
+    Security.SSLCreateContext.argtypes = [
+        CFAllocatorRef,
+        SSLProtocolSide,
+        SSLConnectionType,
+    ]
+    Security.SSLCreateContext.restype = SSLContextRef
+
+    Security.SSLSetSessionOption.argtypes = [SSLContextRef, SSLSessionOption, Boolean]
+    Security.SSLSetSessionOption.restype = OSStatus
+
+    Security.SSLSetProtocolVersionMin.argtypes = [SSLContextRef, SSLProtocol]
+    Security.SSLSetProtocolVersionMin.restype = OSStatus
+
+    Security.SSLSetProtocolVersionMax.argtypes = [SSLContextRef, SSLProtocol]
+    Security.SSLSetProtocolVersionMax.restype = OSStatus
+
+    Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p]
+    Security.SecCopyErrorMessageString.restype = CFStringRef
+
+    Security.SSLReadFunc = SSLReadFunc
+    Security.SSLWriteFunc = SSLWriteFunc
+    Security.SSLContextRef = SSLContextRef
+    Security.SSLProtocol = SSLProtocol
+    Security.SSLCipherSuite = SSLCipherSuite
+    Security.SecIdentityRef = SecIdentityRef
+    Security.SecKeychainRef = SecKeychainRef
+    Security.SecTrustRef = SecTrustRef
+    Security.SecTrustResultType = SecTrustResultType
+    Security.SecExternalFormat = SecExternalFormat
+    Security.OSStatus = OSStatus
+
+    Security.kSecImportExportPassphrase = CFStringRef.in_dll(
+        Security, "kSecImportExportPassphrase"
+    )
+    Security.kSecImportItemIdentity = CFStringRef.in_dll(
+        Security, "kSecImportItemIdentity"
+    )
+
+    # CoreFoundation time!
+    CoreFoundation.CFRetain.argtypes = [CFTypeRef]
+    CoreFoundation.CFRetain.restype = CFTypeRef
+
+    CoreFoundation.CFRelease.argtypes = [CFTypeRef]
+    CoreFoundation.CFRelease.restype = None
+
+    CoreFoundation.CFGetTypeID.argtypes = [CFTypeRef]
+    CoreFoundation.CFGetTypeID.restype = CFTypeID
+
+    CoreFoundation.CFStringCreateWithCString.argtypes = [
+        CFAllocatorRef,
+        c_char_p,
+        CFStringEncoding,
+    ]
+    CoreFoundation.CFStringCreateWithCString.restype = CFStringRef
+
+    CoreFoundation.CFStringGetCStringPtr.argtypes = [CFStringRef, CFStringEncoding]
+    CoreFoundation.CFStringGetCStringPtr.restype = c_char_p
+
+    CoreFoundation.CFStringGetCString.argtypes = [
+        CFStringRef,
+        c_char_p,
+        CFIndex,
+        CFStringEncoding,
+    ]
+    CoreFoundation.CFStringGetCString.restype = c_bool
+
+    CoreFoundation.CFDataCreate.argtypes = [CFAllocatorRef, c_char_p, CFIndex]
+    CoreFoundation.CFDataCreate.restype = CFDataRef
+
+    CoreFoundation.CFDataGetLength.argtypes = [CFDataRef]
+    CoreFoundation.CFDataGetLength.restype = CFIndex
+
+    CoreFoundation.CFDataGetBytePtr.argtypes = [CFDataRef]
+    CoreFoundation.CFDataGetBytePtr.restype = c_void_p
+
+    CoreFoundation.CFDictionaryCreate.argtypes = [
+        CFAllocatorRef,
+        POINTER(CFTypeRef),
+        POINTER(CFTypeRef),
+        CFIndex,
+        CFDictionaryKeyCallBacks,
+        CFDictionaryValueCallBacks,
+    ]
+    CoreFoundation.CFDictionaryCreate.restype = CFDictionaryRef
+
+    CoreFoundation.CFDictionaryGetValue.argtypes = [CFDictionaryRef, CFTypeRef]
+    CoreFoundation.CFDictionaryGetValue.restype = CFTypeRef
+
+    CoreFoundation.CFArrayCreate.argtypes = [
+        CFAllocatorRef,
+        POINTER(CFTypeRef),
+        CFIndex,
+        CFArrayCallBacks,
+    ]
+    CoreFoundation.CFArrayCreate.restype = CFArrayRef
+
+    CoreFoundation.CFArrayCreateMutable.argtypes = [
+        CFAllocatorRef,
+        CFIndex,
+        CFArrayCallBacks,
+    ]
+    CoreFoundation.CFArrayCreateMutable.restype = CFMutableArrayRef
+
+    CoreFoundation.CFArrayAppendValue.argtypes = [CFMutableArrayRef, c_void_p]
+    CoreFoundation.CFArrayAppendValue.restype = None
+
+    CoreFoundation.CFArrayGetCount.argtypes = [CFArrayRef]
+    CoreFoundation.CFArrayGetCount.restype = CFIndex
+
+    CoreFoundation.CFArrayGetValueAtIndex.argtypes = [CFArrayRef, CFIndex]
+    CoreFoundation.CFArrayGetValueAtIndex.restype = c_void_p
+
+    CoreFoundation.kCFAllocatorDefault = CFAllocatorRef.in_dll(
+        CoreFoundation, "kCFAllocatorDefault"
+    )
+    CoreFoundation.kCFTypeArrayCallBacks = c_void_p.in_dll(
+        CoreFoundation, "kCFTypeArrayCallBacks"
+    )
+    CoreFoundation.kCFTypeDictionaryKeyCallBacks = c_void_p.in_dll(
+        CoreFoundation, "kCFTypeDictionaryKeyCallBacks"
+    )
+    CoreFoundation.kCFTypeDictionaryValueCallBacks = c_void_p.in_dll(
+        CoreFoundation, "kCFTypeDictionaryValueCallBacks"
+    )
+
+    CoreFoundation.CFTypeRef = CFTypeRef
+    CoreFoundation.CFArrayRef = CFArrayRef
+    CoreFoundation.CFStringRef = CFStringRef
+    CoreFoundation.CFDictionaryRef = CFDictionaryRef
+
+except (AttributeError):
+    raise ImportError("Error initializing ctypes")
+
+
+class CFConst(object):
+    """
+    A class object that acts as essentially a namespace for CoreFoundation
+    constants.
+    """
+
+    kCFStringEncodingUTF8 = CFStringEncoding(0x08000100)
+
+
+class SecurityConst(object):
+    """
+    A class object that acts as essentially a namespace for Security constants.
+    """
+
+    kSSLSessionOptionBreakOnServerAuth = 0
+
+    kSSLProtocol2 = 1
+    kSSLProtocol3 = 2
+    kTLSProtocol1 = 4
+    kTLSProtocol11 = 7
+    kTLSProtocol12 = 8
+    # SecureTransport does not support TLS 1.3 even if there's a constant for it
+    kTLSProtocol13 = 10
+    kTLSProtocolMaxSupported = 999
+
+    kSSLClientSide = 1
+    kSSLStreamType = 0
+
+    kSecFormatPEMSequence = 10
+
+    kSecTrustResultInvalid = 0
+    kSecTrustResultProceed = 1
+    # This gap is present on purpose: this was kSecTrustResultConfirm, which
+    # is deprecated.
+    kSecTrustResultDeny = 3
+    kSecTrustResultUnspecified = 4
+    kSecTrustResultRecoverableTrustFailure = 5
+    kSecTrustResultFatalTrustFailure = 6
+    kSecTrustResultOtherError = 7
+
+    errSSLProtocol = -9800
+    errSSLWouldBlock = -9803
+    errSSLClosedGraceful = -9805
+    errSSLClosedNoNotify = -9816
+    errSSLClosedAbort = -9806
+
+    errSSLXCertChainInvalid = -9807
+    errSSLCrypto = -9809
+    errSSLInternal = -9810
+    errSSLCertExpired = -9814
+    errSSLCertNotYetValid = -9815
+    errSSLUnknownRootCert = -9812
+    errSSLNoRootCert = -9813
+    errSSLHostNameMismatch = -9843
+    errSSLPeerHandshakeFail = -9824
+    errSSLPeerUserCancelled = -9839
+    errSSLWeakPeerEphemeralDHKey = -9850
+    errSSLServerAuthCompleted = -9841
+    errSSLRecordOverflow = -9847
+
+    errSecVerifyFailed = -67808
+    errSecNoTrustSettings = -25263
+    errSecItemNotFound = -25300
+    errSecInvalidTrustSettings = -25262
+
+    # Cipher suites. We only pick the ones our default cipher string allows.
+    # Source: https://developer.apple.com/documentation/security/1550981-ssl_cipher_suite_values
+    TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = 0xC02C
+    TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = 0xC030
+    TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = 0xC02B
+    TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xC02F
+    TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA9
+    TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA8
+    TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 = 0x009F
+    TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 = 0x009E
+    TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = 0xC024
+    TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = 0xC028
+    TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = 0xC00A
+    TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014
+    TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = 0x006B
+    TLS_DHE_RSA_WITH_AES_256_CBC_SHA = 0x0039
+    TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 0xC023
+    TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 0xC027
+    TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = 0xC009
+    TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = 0xC013
+    TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = 0x0067
+    TLS_DHE_RSA_WITH_AES_128_CBC_SHA = 0x0033
+    TLS_RSA_WITH_AES_256_GCM_SHA384 = 0x009D
+    TLS_RSA_WITH_AES_128_GCM_SHA256 = 0x009C
+    TLS_RSA_WITH_AES_256_CBC_SHA256 = 0x003D
+    TLS_RSA_WITH_AES_128_CBC_SHA256 = 0x003C
+    TLS_RSA_WITH_AES_256_CBC_SHA = 0x0035
+    TLS_RSA_WITH_AES_128_CBC_SHA = 0x002F
+    TLS_AES_128_GCM_SHA256 = 0x1301
+    TLS_AES_256_GCM_SHA384 = 0x1302
+    TLS_AES_128_CCM_8_SHA256 = 0x1305
+    TLS_AES_128_CCM_SHA256 = 0x1304
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py
new file mode 100644
index 0000000..e60168c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py
@@ -0,0 +1,328 @@
+"""
+Low-level helpers for the SecureTransport bindings.
+
+These are Python functions that are not directly related to the high-level APIs
+but are necessary to get them to work. They include a whole bunch of low-level
+CoreFoundation messing about and memory management. The concerns in this module
+are almost entirely about trying to avoid memory leaks and providing
+appropriate and useful assistance to the higher-level code.
+"""
+import base64
+import ctypes
+import itertools
+import re
+import os
+import ssl
+import tempfile
+
+from .bindings import Security, CoreFoundation, CFConst
+
+
+# This regular expression is used to grab PEM data out of a PEM bundle.
+_PEM_CERTS_RE = re.compile(
+    b"-----BEGIN CERTIFICATE-----\n(.*?)\n-----END CERTIFICATE-----", re.DOTALL
+)
+
+
+def _cf_data_from_bytes(bytestring):
+    """
+    Given a bytestring, create a CFData object from it. This CFData object must
+    be CFReleased by the caller.
+    """
+    return CoreFoundation.CFDataCreate(
+        CoreFoundation.kCFAllocatorDefault, bytestring, len(bytestring)
+    )
+
+
+def _cf_dictionary_from_tuples(tuples):
+    """
+    Given a list of Python tuples, create an associated CFDictionary.
+    """
+    dictionary_size = len(tuples)
+
+    # We need to get the dictionary keys and values out in the same order.
+    keys = (t[0] for t in tuples)
+    values = (t[1] for t in tuples)
+    cf_keys = (CoreFoundation.CFTypeRef * dictionary_size)(*keys)
+    cf_values = (CoreFoundation.CFTypeRef * dictionary_size)(*values)
+
+    return CoreFoundation.CFDictionaryCreate(
+        CoreFoundation.kCFAllocatorDefault,
+        cf_keys,
+        cf_values,
+        dictionary_size,
+        CoreFoundation.kCFTypeDictionaryKeyCallBacks,
+        CoreFoundation.kCFTypeDictionaryValueCallBacks,
+    )
+
+
+def _cf_string_to_unicode(value):
+    """
+    Creates a Unicode string from a CFString object. Used entirely for error
+    reporting.
+
+    Yes, it annoys me quite a lot that this function is this complex.
+    """
+    value_as_void_p = ctypes.cast(value, ctypes.POINTER(ctypes.c_void_p))
+
+    string = CoreFoundation.CFStringGetCStringPtr(
+        value_as_void_p, CFConst.kCFStringEncodingUTF8
+    )
+    if string is None:
+        buffer = ctypes.create_string_buffer(1024)
+        result = CoreFoundation.CFStringGetCString(
+            value_as_void_p, buffer, 1024, CFConst.kCFStringEncodingUTF8
+        )
+        if not result:
+            raise OSError("Error copying C string from CFStringRef")
+        string = buffer.value
+    if string is not None:
+        string = string.decode("utf-8")
+    return string
+
+
+def _assert_no_error(error, exception_class=None):
+    """
+    Checks the return code and throws an exception if there is an error to
+    report
+    """
+    if error == 0:
+        return
+
+    cf_error_string = Security.SecCopyErrorMessageString(error, None)
+    output = _cf_string_to_unicode(cf_error_string)
+    CoreFoundation.CFRelease(cf_error_string)
+
+    if output is None or output == u"":
+        output = u"OSStatus %s" % error
+
+    if exception_class is None:
+        exception_class = ssl.SSLError
+
+    raise exception_class(output)
+
+
+def _cert_array_from_pem(pem_bundle):
+    """
+    Given a bundle of certs in PEM format, turns them into a CFArray of certs
+    that can be used to validate a cert chain.
+    """
+    # Normalize the PEM bundle's line endings.
+    pem_bundle = pem_bundle.replace(b"\r\n", b"\n")
+
+    der_certs = [
+        base64.b64decode(match.group(1)) for match in _PEM_CERTS_RE.finditer(pem_bundle)
+    ]
+    if not der_certs:
+        raise ssl.SSLError("No root certificates specified")
+
+    cert_array = CoreFoundation.CFArrayCreateMutable(
+        CoreFoundation.kCFAllocatorDefault,
+        0,
+        ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks),
+    )
+    if not cert_array:
+        raise ssl.SSLError("Unable to allocate memory!")
+
+    try:
+        for der_bytes in der_certs:
+            certdata = _cf_data_from_bytes(der_bytes)
+            if not certdata:
+                raise ssl.SSLError("Unable to allocate memory!")
+            cert = Security.SecCertificateCreateWithData(
+                CoreFoundation.kCFAllocatorDefault, certdata
+            )
+            CoreFoundation.CFRelease(certdata)
+            if not cert:
+                raise ssl.SSLError("Unable to build cert object!")
+
+            CoreFoundation.CFArrayAppendValue(cert_array, cert)
+            CoreFoundation.CFRelease(cert)
+    except Exception:
+        # We need to free the array before the exception bubbles further.
+        # We only want to do that if an error occurs: otherwise, the caller
+        # should free.
+        CoreFoundation.CFRelease(cert_array)
+
+    return cert_array
+
+
+def _is_cert(item):
+    """
+    Returns True if a given CFTypeRef is a certificate.
+    """
+    expected = Security.SecCertificateGetTypeID()
+    return CoreFoundation.CFGetTypeID(item) == expected
+
+
+def _is_identity(item):
+    """
+    Returns True if a given CFTypeRef is an identity.
+    """
+    expected = Security.SecIdentityGetTypeID()
+    return CoreFoundation.CFGetTypeID(item) == expected
+
+
+def _temporary_keychain():
+    """
+    This function creates a temporary Mac keychain that we can use to work with
+    credentials. This keychain uses a one-time password and a temporary file to
+    store the data. We expect to have one keychain per socket. The returned
+    SecKeychainRef must be freed by the caller, including calling
+    SecKeychainDelete.
+
+    Returns a tuple of the SecKeychainRef and the path to the temporary
+    directory that contains it.
+    """
+    # Unfortunately, SecKeychainCreate requires a path to a keychain. This
+    # means we cannot use mkstemp to use a generic temporary file. Instead,
+    # we're going to create a temporary directory and a filename to use there.
+    # This filename will be 8 random bytes expanded into base64. We also need
+    # some random bytes to password-protect the keychain we're creating, so we
+    # ask for 40 random bytes.
+    random_bytes = os.urandom(40)
+    filename = base64.b16encode(random_bytes[:8]).decode("utf-8")
+    password = base64.b16encode(random_bytes[8:])  # Must be valid UTF-8
+    tempdirectory = tempfile.mkdtemp()
+
+    keychain_path = os.path.join(tempdirectory, filename).encode("utf-8")
+
+    # We now want to create the keychain itself.
+    keychain = Security.SecKeychainRef()
+    status = Security.SecKeychainCreate(
+        keychain_path, len(password), password, False, None, ctypes.byref(keychain)
+    )
+    _assert_no_error(status)
+
+    # Having created the keychain, we want to pass it off to the caller.
+    return keychain, tempdirectory
+
+
+def _load_items_from_file(keychain, path):
+    """
+    Given a single file, loads all the trust objects from it into arrays and
+    the keychain.
+    Returns a tuple of lists: the first list is a list of identities, the
+    second a list of certs.
+    """
+    certificates = []
+    identities = []
+    result_array = None
+
+    with open(path, "rb") as f:
+        raw_filedata = f.read()
+
+    try:
+        filedata = CoreFoundation.CFDataCreate(
+            CoreFoundation.kCFAllocatorDefault, raw_filedata, len(raw_filedata)
+        )
+        result_array = CoreFoundation.CFArrayRef()
+        result = Security.SecItemImport(
+            filedata,  # cert data
+            None,  # Filename, leaving it out for now
+            None,  # What the type of the file is, we don't care
+            None,  # what's in the file, we don't care
+            0,  # import flags
+            None,  # key params, can include passphrase in the future
+            keychain,  # The keychain to insert into
+            ctypes.byref(result_array),  # Results
+        )
+        _assert_no_error(result)
+
+        # A CFArray is not very useful to us as an intermediary
+        # representation, so we are going to extract the objects we want
+        # and then free the array. We don't need to keep hold of keys: the
+        # keychain already has them!
+        result_count = CoreFoundation.CFArrayGetCount(result_array)
+        for index in range(result_count):
+            item = CoreFoundation.CFArrayGetValueAtIndex(result_array, index)
+            item = ctypes.cast(item, CoreFoundation.CFTypeRef)
+
+            if _is_cert(item):
+                CoreFoundation.CFRetain(item)
+                certificates.append(item)
+            elif _is_identity(item):
+                CoreFoundation.CFRetain(item)
+                identities.append(item)
+    finally:
+        if result_array:
+            CoreFoundation.CFRelease(result_array)
+
+        CoreFoundation.CFRelease(filedata)
+
+    return (identities, certificates)
+
+
+def _load_client_cert_chain(keychain, *paths):
+    """
+    Load certificates and maybe keys from a number of files. Has the end goal
+    of returning a CFArray containing one SecIdentityRef, and then zero or more
+    SecCertificateRef objects, suitable for use as a client certificate trust
+    chain.
+    """
+    # Ok, the strategy.
+    #
+    # This relies on knowing that macOS will not give you a SecIdentityRef
+    # unless you have imported a key into a keychain. This is a somewhat
+    # artificial limitation of macOS (for example, it doesn't necessarily
+    # affect iOS), but there is nothing inside Security.framework that lets you
+    # get a SecIdentityRef without having a key in a keychain.
+    #
+    # So the policy here is we take all the files and iterate them in order.
+    # Each one will use SecItemImport to have one or more objects loaded from
+    # it. We will also point at a keychain that macOS can use to work with the
+    # private key.
+    #
+    # Once we have all the objects, we'll check what we actually have. If we
+    # already have a SecIdentityRef in hand, fab: we'll use that. Otherwise,
+    # we'll take the first certificate (which we assume to be our leaf) and
+    # ask the keychain to give us a SecIdentityRef with that cert's associated
+    # key.
+    #
+    # We'll then return a CFArray containing the trust chain: one
+    # SecIdentityRef and then zero-or-more SecCertificateRef objects. The
+    # responsibility for freeing this CFArray will be with the caller. This
+    # CFArray must remain alive for the entire connection, so in practice it
+    # will be stored with a single SSLSocket, along with the reference to the
+    # keychain.
+    certificates = []
+    identities = []
+
+    # Filter out bad paths.
+    paths = (path for path in paths if path)
+
+    try:
+        for file_path in paths:
+            new_identities, new_certs = _load_items_from_file(keychain, file_path)
+            identities.extend(new_identities)
+            certificates.extend(new_certs)
+
+        # Ok, we have everything. The question is: do we have an identity? If
+        # not, we want to grab one from the first cert we have.
+        if not identities:
+            new_identity = Security.SecIdentityRef()
+            status = Security.SecIdentityCreateWithCertificate(
+                keychain, certificates[0], ctypes.byref(new_identity)
+            )
+            _assert_no_error(status)
+            identities.append(new_identity)
+
+            # We now want to release the original certificate, as we no longer
+            # need it.
+            CoreFoundation.CFRelease(certificates.pop(0))
+
+        # We now need to build a new CFArray that holds the trust chain.
+        trust_chain = CoreFoundation.CFArrayCreateMutable(
+            CoreFoundation.kCFAllocatorDefault,
+            0,
+            ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks),
+        )
+        for item in itertools.chain(identities, certificates):
+            # ArrayAppendValue does a CFRetain on the item. That's fine,
+            # because the finally block will release our other refs to them.
+            CoreFoundation.CFArrayAppendValue(trust_chain, item)
+
+        return trust_chain
+    finally:
+        for obj in itertools.chain(identities, certificates):
+            CoreFoundation.CFRelease(obj)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/appengine.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/appengine.py
new file mode 100644
index 0000000..d09d2be
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/appengine.py
@@ -0,0 +1,314 @@
+"""
+This module provides a pool manager that uses Google App Engine's
+`URLFetch Service <https://cloud.google.com/appengine/docs/python/urlfetch>`_.
+
+Example usage::
+
+    from pip._vendor.urllib3 import PoolManager
+    from pip._vendor.urllib3.contrib.appengine import AppEngineManager, is_appengine_sandbox
+
+    if is_appengine_sandbox():
+        # AppEngineManager uses AppEngine's URLFetch API behind the scenes
+        http = AppEngineManager()
+    else:
+        # PoolManager uses a socket-level API behind the scenes
+        http = PoolManager()
+
+    r = http.request('GET', 'https://google.com/')
+
+There are `limitations <https://cloud.google.com/appengine/docs/python/\
+urlfetch/#Python_Quotas_and_limits>`_ to the URLFetch service and it may not be
+the best choice for your application. There are three options for using
+urllib3 on Google App Engine:
+
+1. You can use :class:`AppEngineManager` with URLFetch. URLFetch is
+   cost-effective in many circumstances as long as your usage is within the
+   limitations.
+2. You can use a normal :class:`~urllib3.PoolManager` by enabling sockets.
+   Sockets also have `limitations and restrictions
+   <https://cloud.google.com/appengine/docs/python/sockets/\
+   #limitations-and-restrictions>`_ and have a lower free quota than URLFetch.
+   To use sockets, be sure to specify the following in your ``app.yaml``::
+
+        env_variables:
+            GAE_USE_SOCKETS_HTTPLIB : 'true'
+
+3. If you are using `App Engine Flexible
+<https://cloud.google.com/appengine/docs/flexible/>`_, you can use the standard
+:class:`PoolManager` without any configuration or special environment variables.
+"""
+
+from __future__ import absolute_import
+import io
+import logging
+import warnings
+from ..packages.six.moves.urllib.parse import urljoin
+
+from ..exceptions import (
+    HTTPError,
+    HTTPWarning,
+    MaxRetryError,
+    ProtocolError,
+    TimeoutError,
+    SSLError,
+)
+
+from ..request import RequestMethods
+from ..response import HTTPResponse
+from ..util.timeout import Timeout
+from ..util.retry import Retry
+from . import _appengine_environ
+
+try:
+    from google.appengine.api import urlfetch
+except ImportError:
+    urlfetch = None
+
+
+log = logging.getLogger(__name__)
+
+
+class AppEnginePlatformWarning(HTTPWarning):
+    pass
+
+
+class AppEnginePlatformError(HTTPError):
+    pass
+
+
+class AppEngineManager(RequestMethods):
+    """
+    Connection manager for Google App Engine sandbox applications.
+
+    This manager uses the URLFetch service directly instead of using the
+    emulated httplib, and is subject to URLFetch limitations as described in
+    the App Engine documentation `here
+    <https://cloud.google.com/appengine/docs/python/urlfetch>`_.
+
+    Notably it will raise an :class:`AppEnginePlatformError` if:
+        * URLFetch is not available.
+        * If you attempt to use this on App Engine Flexible, as full socket
+          support is available.
+        * If a request size is more than 10 megabytes.
+        * If a response size is more than 32 megabtyes.
+        * If you use an unsupported request method such as OPTIONS.
+
+    Beyond those cases, it will raise normal urllib3 errors.
+    """
+
+    def __init__(
+        self,
+        headers=None,
+        retries=None,
+        validate_certificate=True,
+        urlfetch_retries=True,
+    ):
+        if not urlfetch:
+            raise AppEnginePlatformError(
+                "URLFetch is not available in this environment."
+            )
+
+        warnings.warn(
+            "urllib3 is using URLFetch on Google App Engine sandbox instead "
+            "of sockets. To use sockets directly instead of URLFetch see "
+            "https://urllib3.readthedocs.io/en/latest/reference/urllib3.contrib.html.",
+            AppEnginePlatformWarning,
+        )
+
+        RequestMethods.__init__(self, headers)
+        self.validate_certificate = validate_certificate
+        self.urlfetch_retries = urlfetch_retries
+
+        self.retries = retries or Retry.DEFAULT
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # Return False to re-raise any potential exceptions
+        return False
+
+    def urlopen(
+        self,
+        method,
+        url,
+        body=None,
+        headers=None,
+        retries=None,
+        redirect=True,
+        timeout=Timeout.DEFAULT_TIMEOUT,
+        **response_kw
+    ):
+
+        retries = self._get_retries(retries, redirect)
+
+        try:
+            follow_redirects = redirect and retries.redirect != 0 and retries.total
+            response = urlfetch.fetch(
+                url,
+                payload=body,
+                method=method,
+                headers=headers or {},
+                allow_truncated=False,
+                follow_redirects=self.urlfetch_retries and follow_redirects,
+                deadline=self._get_absolute_timeout(timeout),
+                validate_certificate=self.validate_certificate,
+            )
+        except urlfetch.DeadlineExceededError as e:
+            raise TimeoutError(self, e)
+
+        except urlfetch.InvalidURLError as e:
+            if "too large" in str(e):
+                raise AppEnginePlatformError(
+                    "URLFetch request too large, URLFetch only "
+                    "supports requests up to 10mb in size.",
+                    e,
+                )
+            raise ProtocolError(e)
+
+        except urlfetch.DownloadError as e:
+            if "Too many redirects" in str(e):
+                raise MaxRetryError(self, url, reason=e)
+            raise ProtocolError(e)
+
+        except urlfetch.ResponseTooLargeError as e:
+            raise AppEnginePlatformError(
+                "URLFetch response too large, URLFetch only supports"
+                "responses up to 32mb in size.",
+                e,
+            )
+
+        except urlfetch.SSLCertificateError as e:
+            raise SSLError(e)
+
+        except urlfetch.InvalidMethodError as e:
+            raise AppEnginePlatformError(
+                "URLFetch does not support method: %s" % method, e
+            )
+
+        http_response = self._urlfetch_response_to_http_response(
+            response, retries=retries, **response_kw
+        )
+
+        # Handle redirect?
+        redirect_location = redirect and http_response.get_redirect_location()
+        if redirect_location:
+            # Check for redirect response
+            if self.urlfetch_retries and retries.raise_on_redirect:
+                raise MaxRetryError(self, url, "too many redirects")
+            else:
+                if http_response.status == 303:
+                    method = "GET"
+
+                try:
+                    retries = retries.increment(
+                        method, url, response=http_response, _pool=self
+                    )
+                except MaxRetryError:
+                    if retries.raise_on_redirect:
+                        raise MaxRetryError(self, url, "too many redirects")
+                    return http_response
+
+                retries.sleep_for_retry(http_response)
+                log.debug("Redirecting %s -> %s", url, redirect_location)
+                redirect_url = urljoin(url, redirect_location)
+                return self.urlopen(
+                    method,
+                    redirect_url,
+                    body,
+                    headers,
+                    retries=retries,
+                    redirect=redirect,
+                    timeout=timeout,
+                    **response_kw
+                )
+
+        # Check if we should retry the HTTP response.
+        has_retry_after = bool(http_response.getheader("Retry-After"))
+        if retries.is_retry(method, http_response.status, has_retry_after):
+            retries = retries.increment(method, url, response=http_response, _pool=self)
+            log.debug("Retry: %s", url)
+            retries.sleep(http_response)
+            return self.urlopen(
+                method,
+                url,
+                body=body,
+                headers=headers,
+                retries=retries,
+                redirect=redirect,
+                timeout=timeout,
+                **response_kw
+            )
+
+        return http_response
+
+    def _urlfetch_response_to_http_response(self, urlfetch_resp, **response_kw):
+
+        if is_prod_appengine():
+            # Production GAE handles deflate encoding automatically, but does
+            # not remove the encoding header.
+            content_encoding = urlfetch_resp.headers.get("content-encoding")
+
+            if content_encoding == "deflate":
+                del urlfetch_resp.headers["content-encoding"]
+
+        transfer_encoding = urlfetch_resp.headers.get("transfer-encoding")
+        # We have a full response's content,
+        # so let's make sure we don't report ourselves as chunked data.
+        if transfer_encoding == "chunked":
+            encodings = transfer_encoding.split(",")
+            encodings.remove("chunked")
+            urlfetch_resp.headers["transfer-encoding"] = ",".join(encodings)
+
+        original_response = HTTPResponse(
+            # In order for decoding to work, we must present the content as
+            # a file-like object.
+            body=io.BytesIO(urlfetch_resp.content),
+            msg=urlfetch_resp.header_msg,
+            headers=urlfetch_resp.headers,
+            status=urlfetch_resp.status_code,
+            **response_kw
+        )
+
+        return HTTPResponse(
+            body=io.BytesIO(urlfetch_resp.content),
+            headers=urlfetch_resp.headers,
+            status=urlfetch_resp.status_code,
+            original_response=original_response,
+            **response_kw
+        )
+
+    def _get_absolute_timeout(self, timeout):
+        if timeout is Timeout.DEFAULT_TIMEOUT:
+            return None  # Defer to URLFetch's default.
+        if isinstance(timeout, Timeout):
+            if timeout._read is not None or timeout._connect is not None:
+                warnings.warn(
+                    "URLFetch does not support granular timeout settings, "
+                    "reverting to total or default URLFetch timeout.",
+                    AppEnginePlatformWarning,
+                )
+            return timeout.total
+        return timeout
+
+    def _get_retries(self, retries, redirect):
+        if not isinstance(retries, Retry):
+            retries = Retry.from_int(retries, redirect=redirect, default=self.retries)
+
+        if retries.connect or retries.read or retries.redirect:
+            warnings.warn(
+                "URLFetch only supports total retries and does not "
+                "recognize connect, read, or redirect retry parameters.",
+                AppEnginePlatformWarning,
+            )
+
+        return retries
+
+
+# Alias methods from _appengine_environ to maintain public API interface.
+
+is_appengine = _appengine_environ.is_appengine
+is_appengine_sandbox = _appengine_environ.is_appengine_sandbox
+is_local_appengine = _appengine_environ.is_local_appengine
+is_prod_appengine = _appengine_environ.is_prod_appengine
+is_prod_appengine_mvms = _appengine_environ.is_prod_appengine_mvms
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py
new file mode 100644
index 0000000..1fd242a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py
@@ -0,0 +1,121 @@
+"""
+NTLM authenticating pool, contributed by erikcederstran
+
+Issue #10, see: http://code.google.com/p/urllib3/issues/detail?id=10
+"""
+from __future__ import absolute_import
+
+from logging import getLogger
+from ntlm import ntlm
+
+from .. import HTTPSConnectionPool
+from ..packages.six.moves.http_client import HTTPSConnection
+
+
+log = getLogger(__name__)
+
+
+class NTLMConnectionPool(HTTPSConnectionPool):
+    """
+    Implements an NTLM authentication version of an urllib3 connection pool
+    """
+
+    scheme = "https"
+
+    def __init__(self, user, pw, authurl, *args, **kwargs):
+        """
+        authurl is a random URL on the server that is protected by NTLM.
+        user is the Windows user, probably in the DOMAIN\\username format.
+        pw is the password for the user.
+        """
+        super(NTLMConnectionPool, self).__init__(*args, **kwargs)
+        self.authurl = authurl
+        self.rawuser = user
+        user_parts = user.split("\\", 1)
+        self.domain = user_parts[0].upper()
+        self.user = user_parts[1]
+        self.pw = pw
+
+    def _new_conn(self):
+        # Performs the NTLM handshake that secures the connection. The socket
+        # must be kept open while requests are performed.
+        self.num_connections += 1
+        log.debug(
+            "Starting NTLM HTTPS connection no. %d: https://%s%s",
+            self.num_connections,
+            self.host,
+            self.authurl,
+        )
+
+        headers = {"Connection": "Keep-Alive"}
+        req_header = "Authorization"
+        resp_header = "www-authenticate"
+
+        conn = HTTPSConnection(host=self.host, port=self.port)
+
+        # Send negotiation message
+        headers[req_header] = "NTLM %s" % ntlm.create_NTLM_NEGOTIATE_MESSAGE(
+            self.rawuser
+        )
+        log.debug("Request headers: %s", headers)
+        conn.request("GET", self.authurl, None, headers)
+        res = conn.getresponse()
+        reshdr = dict(res.getheaders())
+        log.debug("Response status: %s %s", res.status, res.reason)
+        log.debug("Response headers: %s", reshdr)
+        log.debug("Response data: %s [...]", res.read(100))
+
+        # Remove the reference to the socket, so that it can not be closed by
+        # the response object (we want to keep the socket open)
+        res.fp = None
+
+        # Server should respond with a challenge message
+        auth_header_values = reshdr[resp_header].split(", ")
+        auth_header_value = None
+        for s in auth_header_values:
+            if s[:5] == "NTLM ":
+                auth_header_value = s[5:]
+        if auth_header_value is None:
+            raise Exception(
+                "Unexpected %s response header: %s" % (resp_header, reshdr[resp_header])
+            )
+
+        # Send authentication message
+        ServerChallenge, NegotiateFlags = ntlm.parse_NTLM_CHALLENGE_MESSAGE(
+            auth_header_value
+        )
+        auth_msg = ntlm.create_NTLM_AUTHENTICATE_MESSAGE(
+            ServerChallenge, self.user, self.domain, self.pw, NegotiateFlags
+        )
+        headers[req_header] = "NTLM %s" % auth_msg
+        log.debug("Request headers: %s", headers)
+        conn.request("GET", self.authurl, None, headers)
+        res = conn.getresponse()
+        log.debug("Response status: %s %s", res.status, res.reason)
+        log.debug("Response headers: %s", dict(res.getheaders()))
+        log.debug("Response data: %s [...]", res.read()[:100])
+        if res.status != 200:
+            if res.status == 401:
+                raise Exception("Server rejected request: wrong username or password")
+            raise Exception("Wrong server response: %s %s" % (res.status, res.reason))
+
+        res.fp = None
+        log.debug("Connection established")
+        return conn
+
+    def urlopen(
+        self,
+        method,
+        url,
+        body=None,
+        headers=None,
+        retries=3,
+        redirect=True,
+        assert_same_host=True,
+    ):
+        if headers is None:
+            headers = {}
+        headers["Connection"] = "Keep-Alive"
+        return super(NTLMConnectionPool, self).urlopen(
+            method, url, body, headers, retries, redirect, assert_same_host
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py
new file mode 100644
index 0000000..d8fe062
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py
@@ -0,0 +1,501 @@
+"""
+SSL with SNI_-support for Python 2. Follow these instructions if you would
+like to verify SSL certificates in Python 2. Note, the default libraries do
+*not* do certificate checking; you need to do additional work to validate
+certificates yourself.
+
+This needs the following packages installed:
+
+* pyOpenSSL (tested with 16.0.0)
+* cryptography (minimum 1.3.4, from pyopenssl)
+* idna (minimum 2.0, from cryptography)
+
+However, pyopenssl depends on cryptography, which depends on idna, so while we
+use all three directly here we end up having relatively few packages required.
+
+You can install them with the following command:
+
+    pip install pyopenssl cryptography idna
+
+To activate certificate checking, call
+:func:`~urllib3.contrib.pyopenssl.inject_into_urllib3` from your Python code
+before you begin making HTTP requests. This can be done in a ``sitecustomize``
+module, or at any other time before your application begins using ``urllib3``,
+like this::
+
+    try:
+        import urllib3.contrib.pyopenssl
+        urllib3.contrib.pyopenssl.inject_into_urllib3()
+    except ImportError:
+        pass
+
+Now you can use :mod:`urllib3` as you normally would, and it will support SNI
+when the required modules are installed.
+
+Activating this module also has the positive side effect of disabling SSL/TLS
+compression in Python 2 (see `CRIME attack`_).
+
+If you want to configure the default list of supported cipher suites, you can
+set the ``urllib3.contrib.pyopenssl.DEFAULT_SSL_CIPHER_LIST`` variable.
+
+.. _sni: https://en.wikipedia.org/wiki/Server_Name_Indication
+.. _crime attack: https://en.wikipedia.org/wiki/CRIME_(security_exploit)
+"""
+from __future__ import absolute_import
+
+import OpenSSL.SSL
+from cryptography import x509
+from cryptography.hazmat.backends.openssl import backend as openssl_backend
+from cryptography.hazmat.backends.openssl.x509 import _Certificate
+
+try:
+    from cryptography.x509 import UnsupportedExtension
+except ImportError:
+    # UnsupportedExtension is gone in cryptography >= 2.1.0
+    class UnsupportedExtension(Exception):
+        pass
+
+
+from socket import timeout, error as SocketError
+from io import BytesIO
+
+try:  # Platform-specific: Python 2
+    from socket import _fileobject
+except ImportError:  # Platform-specific: Python 3
+    _fileobject = None
+    from ..packages.backports.makefile import backport_makefile
+
+import logging
+import ssl
+from ..packages import six
+import sys
+
+from .. import util
+
+
+__all__ = ["inject_into_urllib3", "extract_from_urllib3"]
+
+# SNI always works.
+HAS_SNI = True
+
+# Map from urllib3 to PyOpenSSL compatible parameter-values.
+_openssl_versions = {
+    util.PROTOCOL_TLS: OpenSSL.SSL.SSLv23_METHOD,
+    ssl.PROTOCOL_TLSv1: OpenSSL.SSL.TLSv1_METHOD,
+}
+
+if hasattr(ssl, "PROTOCOL_SSLv3") and hasattr(OpenSSL.SSL, "SSLv3_METHOD"):
+    _openssl_versions[ssl.PROTOCOL_SSLv3] = OpenSSL.SSL.SSLv3_METHOD
+
+if hasattr(ssl, "PROTOCOL_TLSv1_1") and hasattr(OpenSSL.SSL, "TLSv1_1_METHOD"):
+    _openssl_versions[ssl.PROTOCOL_TLSv1_1] = OpenSSL.SSL.TLSv1_1_METHOD
+
+if hasattr(ssl, "PROTOCOL_TLSv1_2") and hasattr(OpenSSL.SSL, "TLSv1_2_METHOD"):
+    _openssl_versions[ssl.PROTOCOL_TLSv1_2] = OpenSSL.SSL.TLSv1_2_METHOD
+
+
+_stdlib_to_openssl_verify = {
+    ssl.CERT_NONE: OpenSSL.SSL.VERIFY_NONE,
+    ssl.CERT_OPTIONAL: OpenSSL.SSL.VERIFY_PEER,
+    ssl.CERT_REQUIRED: OpenSSL.SSL.VERIFY_PEER
+    + OpenSSL.SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
+}
+_openssl_to_stdlib_verify = dict((v, k) for k, v in _stdlib_to_openssl_verify.items())
+
+# OpenSSL will only write 16K at a time
+SSL_WRITE_BLOCKSIZE = 16384
+
+orig_util_HAS_SNI = util.HAS_SNI
+orig_util_SSLContext = util.ssl_.SSLContext
+
+
+log = logging.getLogger(__name__)
+
+
+def inject_into_urllib3():
+    "Monkey-patch urllib3 with PyOpenSSL-backed SSL-support."
+
+    _validate_dependencies_met()
+
+    util.SSLContext = PyOpenSSLContext
+    util.ssl_.SSLContext = PyOpenSSLContext
+    util.HAS_SNI = HAS_SNI
+    util.ssl_.HAS_SNI = HAS_SNI
+    util.IS_PYOPENSSL = True
+    util.ssl_.IS_PYOPENSSL = True
+
+
+def extract_from_urllib3():
+    "Undo monkey-patching by :func:`inject_into_urllib3`."
+
+    util.SSLContext = orig_util_SSLContext
+    util.ssl_.SSLContext = orig_util_SSLContext
+    util.HAS_SNI = orig_util_HAS_SNI
+    util.ssl_.HAS_SNI = orig_util_HAS_SNI
+    util.IS_PYOPENSSL = False
+    util.ssl_.IS_PYOPENSSL = False
+
+
+def _validate_dependencies_met():
+    """
+    Verifies that PyOpenSSL's package-level dependencies have been met.
+    Throws `ImportError` if they are not met.
+    """
+    # Method added in `cryptography==1.1`; not available in older versions
+    from cryptography.x509.extensions import Extensions
+
+    if getattr(Extensions, "get_extension_for_class", None) is None:
+        raise ImportError(
+            "'cryptography' module missing required functionality.  "
+            "Try upgrading to v1.3.4 or newer."
+        )
+
+    # pyOpenSSL 0.14 and above use cryptography for OpenSSL bindings. The _x509
+    # attribute is only present on those versions.
+    from OpenSSL.crypto import X509
+
+    x509 = X509()
+    if getattr(x509, "_x509", None) is None:
+        raise ImportError(
+            "'pyOpenSSL' module missing required functionality. "
+            "Try upgrading to v0.14 or newer."
+        )
+
+
+def _dnsname_to_stdlib(name):
+    """
+    Converts a dNSName SubjectAlternativeName field to the form used by the
+    standard library on the given Python version.
+
+    Cryptography produces a dNSName as a unicode string that was idna-decoded
+    from ASCII bytes. We need to idna-encode that string to get it back, and
+    then on Python 3 we also need to convert to unicode via UTF-8 (the stdlib
+    uses PyUnicode_FromStringAndSize on it, which decodes via UTF-8).
+
+    If the name cannot be idna-encoded then we return None signalling that
+    the name given should be skipped.
+    """
+
+    def idna_encode(name):
+        """
+        Borrowed wholesale from the Python Cryptography Project. It turns out
+        that we can't just safely call `idna.encode`: it can explode for
+        wildcard names. This avoids that problem.
+        """
+        from pip._vendor import idna
+
+        try:
+            for prefix in [u"*.", u"."]:
+                if name.startswith(prefix):
+                    name = name[len(prefix) :]
+                    return prefix.encode("ascii") + idna.encode(name)
+            return idna.encode(name)
+        except idna.core.IDNAError:
+            return None
+
+    # Don't send IPv6 addresses through the IDNA encoder.
+    if ":" in name:
+        return name
+
+    name = idna_encode(name)
+    if name is None:
+        return None
+    elif sys.version_info >= (3, 0):
+        name = name.decode("utf-8")
+    return name
+
+
+def get_subj_alt_name(peer_cert):
+    """
+    Given an PyOpenSSL certificate, provides all the subject alternative names.
+    """
+    # Pass the cert to cryptography, which has much better APIs for this.
+    if hasattr(peer_cert, "to_cryptography"):
+        cert = peer_cert.to_cryptography()
+    else:
+        # This is technically using private APIs, but should work across all
+        # relevant versions before PyOpenSSL got a proper API for this.
+        cert = _Certificate(openssl_backend, peer_cert._x509)
+
+    # We want to find the SAN extension. Ask Cryptography to locate it (it's
+    # faster than looping in Python)
+    try:
+        ext = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value
+    except x509.ExtensionNotFound:
+        # No such extension, return the empty list.
+        return []
+    except (
+        x509.DuplicateExtension,
+        UnsupportedExtension,
+        x509.UnsupportedGeneralNameType,
+        UnicodeError,
+    ) as e:
+        # A problem has been found with the quality of the certificate. Assume
+        # no SAN field is present.
+        log.warning(
+            "A problem was encountered with the certificate that prevented "
+            "urllib3 from finding the SubjectAlternativeName field. This can "
+            "affect certificate validation. The error was %s",
+            e,
+        )
+        return []
+
+    # We want to return dNSName and iPAddress fields. We need to cast the IPs
+    # back to strings because the match_hostname function wants them as
+    # strings.
+    # Sadly the DNS names need to be idna encoded and then, on Python 3, UTF-8
+    # decoded. This is pretty frustrating, but that's what the standard library
+    # does with certificates, and so we need to attempt to do the same.
+    # We also want to skip over names which cannot be idna encoded.
+    names = [
+        ("DNS", name)
+        for name in map(_dnsname_to_stdlib, ext.get_values_for_type(x509.DNSName))
+        if name is not None
+    ]
+    names.extend(
+        ("IP Address", str(name)) for name in ext.get_values_for_type(x509.IPAddress)
+    )
+
+    return names
+
+
+class WrappedSocket(object):
+    """API-compatibility wrapper for Python OpenSSL's Connection-class.
+
+    Note: _makefile_refs, _drop() and _reuse() are needed for the garbage
+    collector of pypy.
+    """
+
+    def __init__(self, connection, socket, suppress_ragged_eofs=True):
+        self.connection = connection
+        self.socket = socket
+        self.suppress_ragged_eofs = suppress_ragged_eofs
+        self._makefile_refs = 0
+        self._closed = False
+
+    def fileno(self):
+        return self.socket.fileno()
+
+    # Copy-pasted from Python 3.5 source code
+    def _decref_socketios(self):
+        if self._makefile_refs > 0:
+            self._makefile_refs -= 1
+        if self._closed:
+            self.close()
+
+    def recv(self, *args, **kwargs):
+        try:
+            data = self.connection.recv(*args, **kwargs)
+        except OpenSSL.SSL.SysCallError as e:
+            if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"):
+                return b""
+            else:
+                raise SocketError(str(e))
+        except OpenSSL.SSL.ZeroReturnError:
+            if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN:
+                return b""
+            else:
+                raise
+        except OpenSSL.SSL.WantReadError:
+            if not util.wait_for_read(self.socket, self.socket.gettimeout()):
+                raise timeout("The read operation timed out")
+            else:
+                return self.recv(*args, **kwargs)
+
+        # TLS 1.3 post-handshake authentication
+        except OpenSSL.SSL.Error as e:
+            raise ssl.SSLError("read error: %r" % e)
+        else:
+            return data
+
+    def recv_into(self, *args, **kwargs):
+        try:
+            return self.connection.recv_into(*args, **kwargs)
+        except OpenSSL.SSL.SysCallError as e:
+            if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"):
+                return 0
+            else:
+                raise SocketError(str(e))
+        except OpenSSL.SSL.ZeroReturnError:
+            if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN:
+                return 0
+            else:
+                raise
+        except OpenSSL.SSL.WantReadError:
+            if not util.wait_for_read(self.socket, self.socket.gettimeout()):
+                raise timeout("The read operation timed out")
+            else:
+                return self.recv_into(*args, **kwargs)
+
+        # TLS 1.3 post-handshake authentication
+        except OpenSSL.SSL.Error as e:
+            raise ssl.SSLError("read error: %r" % e)
+
+    def settimeout(self, timeout):
+        return self.socket.settimeout(timeout)
+
+    def _send_until_done(self, data):
+        while True:
+            try:
+                return self.connection.send(data)
+            except OpenSSL.SSL.WantWriteError:
+                if not util.wait_for_write(self.socket, self.socket.gettimeout()):
+                    raise timeout()
+                continue
+            except OpenSSL.SSL.SysCallError as e:
+                raise SocketError(str(e))
+
+    def sendall(self, data):
+        total_sent = 0
+        while total_sent < len(data):
+            sent = self._send_until_done(
+                data[total_sent : total_sent + SSL_WRITE_BLOCKSIZE]
+            )
+            total_sent += sent
+
+    def shutdown(self):
+        # FIXME rethrow compatible exceptions should we ever use this
+        self.connection.shutdown()
+
+    def close(self):
+        if self._makefile_refs < 1:
+            try:
+                self._closed = True
+                return self.connection.close()
+            except OpenSSL.SSL.Error:
+                return
+        else:
+            self._makefile_refs -= 1
+
+    def getpeercert(self, binary_form=False):
+        x509 = self.connection.get_peer_certificate()
+
+        if not x509:
+            return x509
+
+        if binary_form:
+            return OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_ASN1, x509)
+
+        return {
+            "subject": ((("commonName", x509.get_subject().CN),),),
+            "subjectAltName": get_subj_alt_name(x509),
+        }
+
+    def version(self):
+        return self.connection.get_protocol_version_name()
+
+    def _reuse(self):
+        self._makefile_refs += 1
+
+    def _drop(self):
+        if self._makefile_refs < 1:
+            self.close()
+        else:
+            self._makefile_refs -= 1
+
+
+if _fileobject:  # Platform-specific: Python 2
+
+    def makefile(self, mode, bufsize=-1):
+        self._makefile_refs += 1
+        return _fileobject(self, mode, bufsize, close=True)
+
+
+else:  # Platform-specific: Python 3
+    makefile = backport_makefile
+
+WrappedSocket.makefile = makefile
+
+
+class PyOpenSSLContext(object):
+    """
+    I am a wrapper class for the PyOpenSSL ``Context`` object. I am responsible
+    for translating the interface of the standard library ``SSLContext`` object
+    to calls into PyOpenSSL.
+    """
+
+    def __init__(self, protocol):
+        self.protocol = _openssl_versions[protocol]
+        self._ctx = OpenSSL.SSL.Context(self.protocol)
+        self._options = 0
+        self.check_hostname = False
+
+    @property
+    def options(self):
+        return self._options
+
+    @options.setter
+    def options(self, value):
+        self._options = value
+        self._ctx.set_options(value)
+
+    @property
+    def verify_mode(self):
+        return _openssl_to_stdlib_verify[self._ctx.get_verify_mode()]
+
+    @verify_mode.setter
+    def verify_mode(self, value):
+        self._ctx.set_verify(_stdlib_to_openssl_verify[value], _verify_callback)
+
+    def set_default_verify_paths(self):
+        self._ctx.set_default_verify_paths()
+
+    def set_ciphers(self, ciphers):
+        if isinstance(ciphers, six.text_type):
+            ciphers = ciphers.encode("utf-8")
+        self._ctx.set_cipher_list(ciphers)
+
+    def load_verify_locations(self, cafile=None, capath=None, cadata=None):
+        if cafile is not None:
+            cafile = cafile.encode("utf-8")
+        if capath is not None:
+            capath = capath.encode("utf-8")
+        try:
+            self._ctx.load_verify_locations(cafile, capath)
+            if cadata is not None:
+                self._ctx.load_verify_locations(BytesIO(cadata))
+        except OpenSSL.SSL.Error as e:
+            raise ssl.SSLError("unable to load trusted certificates: %r" % e)
+
+    def load_cert_chain(self, certfile, keyfile=None, password=None):
+        self._ctx.use_certificate_chain_file(certfile)
+        if password is not None:
+            if not isinstance(password, six.binary_type):
+                password = password.encode("utf-8")
+            self._ctx.set_passwd_cb(lambda *_: password)
+        self._ctx.use_privatekey_file(keyfile or certfile)
+
+    def wrap_socket(
+        self,
+        sock,
+        server_side=False,
+        do_handshake_on_connect=True,
+        suppress_ragged_eofs=True,
+        server_hostname=None,
+    ):
+        cnx = OpenSSL.SSL.Connection(self._ctx, sock)
+
+        if isinstance(server_hostname, six.text_type):  # Platform-specific: Python 3
+            server_hostname = server_hostname.encode("utf-8")
+
+        if server_hostname is not None:
+            cnx.set_tlsext_host_name(server_hostname)
+
+        cnx.set_connect_state()
+
+        while True:
+            try:
+                cnx.do_handshake()
+            except OpenSSL.SSL.WantReadError:
+                if not util.wait_for_read(sock, sock.gettimeout()):
+                    raise timeout("select timed out")
+                continue
+            except OpenSSL.SSL.Error as e:
+                raise ssl.SSLError("bad handshake: %r" % e)
+            break
+
+        return WrappedSocket(cnx, sock)
+
+
+def _verify_callback(cnx, x509, err_no, err_depth, return_code):
+    return err_no == 0
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/securetransport.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/securetransport.py
new file mode 100644
index 0000000..a6b7e94
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/securetransport.py
@@ -0,0 +1,864 @@
+"""
+SecureTranport support for urllib3 via ctypes.
+
+This makes platform-native TLS available to urllib3 users on macOS without the
+use of a compiler. This is an important feature because the Python Package
+Index is moving to become a TLSv1.2-or-higher server, and the default OpenSSL
+that ships with macOS is not capable of doing TLSv1.2. The only way to resolve
+this is to give macOS users an alternative solution to the problem, and that
+solution is to use SecureTransport.
+
+We use ctypes here because this solution must not require a compiler. That's
+because pip is not allowed to require a compiler either.
+
+This is not intended to be a seriously long-term solution to this problem.
+The hope is that PEP 543 will eventually solve this issue for us, at which
+point we can retire this contrib module. But in the short term, we need to
+solve the impending tire fire that is Python on Mac without this kind of
+contrib module. So...here we are.
+
+To use this module, simply import and inject it::
+
+    import urllib3.contrib.securetransport
+    urllib3.contrib.securetransport.inject_into_urllib3()
+
+Happy TLSing!
+
+This code is a bastardised version of the code found in Will Bond's oscrypto
+library. An enormous debt is owed to him for blazing this trail for us. For
+that reason, this code should be considered to be covered both by urllib3's
+license and by oscrypto's:
+
+    Copyright (c) 2015-2016 Will Bond <will@wbond.net>
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+"""
+from __future__ import absolute_import
+
+import contextlib
+import ctypes
+import errno
+import os.path
+import shutil
+import socket
+import ssl
+import threading
+import weakref
+
+from .. import util
+from ._securetransport.bindings import Security, SecurityConst, CoreFoundation
+from ._securetransport.low_level import (
+    _assert_no_error,
+    _cert_array_from_pem,
+    _temporary_keychain,
+    _load_client_cert_chain,
+)
+
+try:  # Platform-specific: Python 2
+    from socket import _fileobject
+except ImportError:  # Platform-specific: Python 3
+    _fileobject = None
+    from ..packages.backports.makefile import backport_makefile
+
+__all__ = ["inject_into_urllib3", "extract_from_urllib3"]
+
+# SNI always works
+HAS_SNI = True
+
+orig_util_HAS_SNI = util.HAS_SNI
+orig_util_SSLContext = util.ssl_.SSLContext
+
+# This dictionary is used by the read callback to obtain a handle to the
+# calling wrapped socket. This is a pretty silly approach, but for now it'll
+# do. I feel like I should be able to smuggle a handle to the wrapped socket
+# directly in the SSLConnectionRef, but for now this approach will work I
+# guess.
+#
+# We need to lock around this structure for inserts, but we don't do it for
+# reads/writes in the callbacks. The reasoning here goes as follows:
+#
+#    1. It is not possible to call into the callbacks before the dictionary is
+#       populated, so once in the callback the id must be in the dictionary.
+#    2. The callbacks don't mutate the dictionary, they only read from it, and
+#       so cannot conflict with any of the insertions.
+#
+# This is good: if we had to lock in the callbacks we'd drastically slow down
+# the performance of this code.
+_connection_refs = weakref.WeakValueDictionary()
+_connection_ref_lock = threading.Lock()
+
+# Limit writes to 16kB. This is OpenSSL's limit, but we'll cargo-cult it over
+# for no better reason than we need *a* limit, and this one is right there.
+SSL_WRITE_BLOCKSIZE = 16384
+
+# This is our equivalent of util.ssl_.DEFAULT_CIPHERS, but expanded out to
+# individual cipher suites. We need to do this because this is how
+# SecureTransport wants them.
+CIPHER_SUITES = [
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
+    SecurityConst.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
+    SecurityConst.TLS_AES_256_GCM_SHA384,
+    SecurityConst.TLS_AES_128_GCM_SHA256,
+    SecurityConst.TLS_RSA_WITH_AES_256_GCM_SHA384,
+    SecurityConst.TLS_RSA_WITH_AES_128_GCM_SHA256,
+    SecurityConst.TLS_AES_128_CCM_8_SHA256,
+    SecurityConst.TLS_AES_128_CCM_SHA256,
+    SecurityConst.TLS_RSA_WITH_AES_256_CBC_SHA256,
+    SecurityConst.TLS_RSA_WITH_AES_128_CBC_SHA256,
+    SecurityConst.TLS_RSA_WITH_AES_256_CBC_SHA,
+    SecurityConst.TLS_RSA_WITH_AES_128_CBC_SHA,
+]
+
+# Basically this is simple: for PROTOCOL_SSLv23 we turn it into a low of
+# TLSv1 and a high of TLSv1.2. For everything else, we pin to that version.
+# TLSv1 to 1.2 are supported on macOS 10.8+
+_protocol_to_min_max = {
+    util.PROTOCOL_TLS: (SecurityConst.kTLSProtocol1, SecurityConst.kTLSProtocol12)
+}
+
+if hasattr(ssl, "PROTOCOL_SSLv2"):
+    _protocol_to_min_max[ssl.PROTOCOL_SSLv2] = (
+        SecurityConst.kSSLProtocol2,
+        SecurityConst.kSSLProtocol2,
+    )
+if hasattr(ssl, "PROTOCOL_SSLv3"):
+    _protocol_to_min_max[ssl.PROTOCOL_SSLv3] = (
+        SecurityConst.kSSLProtocol3,
+        SecurityConst.kSSLProtocol3,
+    )
+if hasattr(ssl, "PROTOCOL_TLSv1"):
+    _protocol_to_min_max[ssl.PROTOCOL_TLSv1] = (
+        SecurityConst.kTLSProtocol1,
+        SecurityConst.kTLSProtocol1,
+    )
+if hasattr(ssl, "PROTOCOL_TLSv1_1"):
+    _protocol_to_min_max[ssl.PROTOCOL_TLSv1_1] = (
+        SecurityConst.kTLSProtocol11,
+        SecurityConst.kTLSProtocol11,
+    )
+if hasattr(ssl, "PROTOCOL_TLSv1_2"):
+    _protocol_to_min_max[ssl.PROTOCOL_TLSv1_2] = (
+        SecurityConst.kTLSProtocol12,
+        SecurityConst.kTLSProtocol12,
+    )
+
+
+def inject_into_urllib3():
+    """
+    Monkey-patch urllib3 with SecureTransport-backed SSL-support.
+    """
+    util.SSLContext = SecureTransportContext
+    util.ssl_.SSLContext = SecureTransportContext
+    util.HAS_SNI = HAS_SNI
+    util.ssl_.HAS_SNI = HAS_SNI
+    util.IS_SECURETRANSPORT = True
+    util.ssl_.IS_SECURETRANSPORT = True
+
+
+def extract_from_urllib3():
+    """
+    Undo monkey-patching by :func:`inject_into_urllib3`.
+    """
+    util.SSLContext = orig_util_SSLContext
+    util.ssl_.SSLContext = orig_util_SSLContext
+    util.HAS_SNI = orig_util_HAS_SNI
+    util.ssl_.HAS_SNI = orig_util_HAS_SNI
+    util.IS_SECURETRANSPORT = False
+    util.ssl_.IS_SECURETRANSPORT = False
+
+
+def _read_callback(connection_id, data_buffer, data_length_pointer):
+    """
+    SecureTransport read callback. This is called by ST to request that data
+    be returned from the socket.
+    """
+    wrapped_socket = None
+    try:
+        wrapped_socket = _connection_refs.get(connection_id)
+        if wrapped_socket is None:
+            return SecurityConst.errSSLInternal
+        base_socket = wrapped_socket.socket
+
+        requested_length = data_length_pointer[0]
+
+        timeout = wrapped_socket.gettimeout()
+        error = None
+        read_count = 0
+
+        try:
+            while read_count < requested_length:
+                if timeout is None or timeout >= 0:
+                    if not util.wait_for_read(base_socket, timeout):
+                        raise socket.error(errno.EAGAIN, "timed out")
+
+                remaining = requested_length - read_count
+                buffer = (ctypes.c_char * remaining).from_address(
+                    data_buffer + read_count
+                )
+                chunk_size = base_socket.recv_into(buffer, remaining)
+                read_count += chunk_size
+                if not chunk_size:
+                    if not read_count:
+                        return SecurityConst.errSSLClosedGraceful
+                    break
+        except (socket.error) as e:
+            error = e.errno
+
+            if error is not None and error != errno.EAGAIN:
+                data_length_pointer[0] = read_count
+                if error == errno.ECONNRESET or error == errno.EPIPE:
+                    return SecurityConst.errSSLClosedAbort
+                raise
+
+        data_length_pointer[0] = read_count
+
+        if read_count != requested_length:
+            return SecurityConst.errSSLWouldBlock
+
+        return 0
+    except Exception as e:
+        if wrapped_socket is not None:
+            wrapped_socket._exception = e
+        return SecurityConst.errSSLInternal
+
+
+def _write_callback(connection_id, data_buffer, data_length_pointer):
+    """
+    SecureTransport write callback. This is called by ST to request that data
+    actually be sent on the network.
+    """
+    wrapped_socket = None
+    try:
+        wrapped_socket = _connection_refs.get(connection_id)
+        if wrapped_socket is None:
+            return SecurityConst.errSSLInternal
+        base_socket = wrapped_socket.socket
+
+        bytes_to_write = data_length_pointer[0]
+        data = ctypes.string_at(data_buffer, bytes_to_write)
+
+        timeout = wrapped_socket.gettimeout()
+        error = None
+        sent = 0
+
+        try:
+            while sent < bytes_to_write:
+                if timeout is None or timeout >= 0:
+                    if not util.wait_for_write(base_socket, timeout):
+                        raise socket.error(errno.EAGAIN, "timed out")
+                chunk_sent = base_socket.send(data)
+                sent += chunk_sent
+
+                # This has some needless copying here, but I'm not sure there's
+                # much value in optimising this data path.
+                data = data[chunk_sent:]
+        except (socket.error) as e:
+            error = e.errno
+
+            if error is not None and error != errno.EAGAIN:
+                data_length_pointer[0] = sent
+                if error == errno.ECONNRESET or error == errno.EPIPE:
+                    return SecurityConst.errSSLClosedAbort
+                raise
+
+        data_length_pointer[0] = sent
+
+        if sent != bytes_to_write:
+            return SecurityConst.errSSLWouldBlock
+
+        return 0
+    except Exception as e:
+        if wrapped_socket is not None:
+            wrapped_socket._exception = e
+        return SecurityConst.errSSLInternal
+
+
+# We need to keep these two objects references alive: if they get GC'd while
+# in use then SecureTransport could attempt to call a function that is in freed
+# memory. That would be...uh...bad. Yeah, that's the word. Bad.
+_read_callback_pointer = Security.SSLReadFunc(_read_callback)
+_write_callback_pointer = Security.SSLWriteFunc(_write_callback)
+
+
+class WrappedSocket(object):
+    """
+    API-compatibility wrapper for Python's OpenSSL wrapped socket object.
+
+    Note: _makefile_refs, _drop(), and _reuse() are needed for the garbage
+    collector of PyPy.
+    """
+
+    def __init__(self, socket):
+        self.socket = socket
+        self.context = None
+        self._makefile_refs = 0
+        self._closed = False
+        self._exception = None
+        self._keychain = None
+        self._keychain_dir = None
+        self._client_cert_chain = None
+
+        # We save off the previously-configured timeout and then set it to
+        # zero. This is done because we use select and friends to handle the
+        # timeouts, but if we leave the timeout set on the lower socket then
+        # Python will "kindly" call select on that socket again for us. Avoid
+        # that by forcing the timeout to zero.
+        self._timeout = self.socket.gettimeout()
+        self.socket.settimeout(0)
+
+    @contextlib.contextmanager
+    def _raise_on_error(self):
+        """
+        A context manager that can be used to wrap calls that do I/O from
+        SecureTransport. If any of the I/O callbacks hit an exception, this
+        context manager will correctly propagate the exception after the fact.
+        This avoids silently swallowing those exceptions.
+
+        It also correctly forces the socket closed.
+        """
+        self._exception = None
+
+        # We explicitly don't catch around this yield because in the unlikely
+        # event that an exception was hit in the block we don't want to swallow
+        # it.
+        yield
+        if self._exception is not None:
+            exception, self._exception = self._exception, None
+            self.close()
+            raise exception
+
+    def _set_ciphers(self):
+        """
+        Sets up the allowed ciphers. By default this matches the set in
+        util.ssl_.DEFAULT_CIPHERS, at least as supported by macOS. This is done
+        custom and doesn't allow changing at this time, mostly because parsing
+        OpenSSL cipher strings is going to be a freaking nightmare.
+        """
+        ciphers = (Security.SSLCipherSuite * len(CIPHER_SUITES))(*CIPHER_SUITES)
+        result = Security.SSLSetEnabledCiphers(
+            self.context, ciphers, len(CIPHER_SUITES)
+        )
+        _assert_no_error(result)
+
+    def _custom_validate(self, verify, trust_bundle):
+        """
+        Called when we have set custom validation. We do this in two cases:
+        first, when cert validation is entirely disabled; and second, when
+        using a custom trust DB.
+        """
+        # If we disabled cert validation, just say: cool.
+        if not verify:
+            return
+
+        # We want data in memory, so load it up.
+        if os.path.isfile(trust_bundle):
+            with open(trust_bundle, "rb") as f:
+                trust_bundle = f.read()
+
+        cert_array = None
+        trust = Security.SecTrustRef()
+
+        try:
+            # Get a CFArray that contains the certs we want.
+            cert_array = _cert_array_from_pem(trust_bundle)
+
+            # Ok, now the hard part. We want to get the SecTrustRef that ST has
+            # created for this connection, shove our CAs into it, tell ST to
+            # ignore everything else it knows, and then ask if it can build a
+            # chain. This is a buuuunch of code.
+            result = Security.SSLCopyPeerTrust(self.context, ctypes.byref(trust))
+            _assert_no_error(result)
+            if not trust:
+                raise ssl.SSLError("Failed to copy trust reference")
+
+            result = Security.SecTrustSetAnchorCertificates(trust, cert_array)
+            _assert_no_error(result)
+
+            result = Security.SecTrustSetAnchorCertificatesOnly(trust, True)
+            _assert_no_error(result)
+
+            trust_result = Security.SecTrustResultType()
+            result = Security.SecTrustEvaluate(trust, ctypes.byref(trust_result))
+            _assert_no_error(result)
+        finally:
+            if trust:
+                CoreFoundation.CFRelease(trust)
+
+            if cert_array is not None:
+                CoreFoundation.CFRelease(cert_array)
+
+        # Ok, now we can look at what the result was.
+        successes = (
+            SecurityConst.kSecTrustResultUnspecified,
+            SecurityConst.kSecTrustResultProceed,
+        )
+        if trust_result.value not in successes:
+            raise ssl.SSLError(
+                "certificate verify failed, error code: %d" % trust_result.value
+            )
+
+    def handshake(
+        self,
+        server_hostname,
+        verify,
+        trust_bundle,
+        min_version,
+        max_version,
+        client_cert,
+        client_key,
+        client_key_passphrase,
+    ):
+        """
+        Actually performs the TLS handshake. This is run automatically by
+        wrapped socket, and shouldn't be needed in user code.
+        """
+        # First, we do the initial bits of connection setup. We need to create
+        # a context, set its I/O funcs, and set the connection reference.
+        self.context = Security.SSLCreateContext(
+            None, SecurityConst.kSSLClientSide, SecurityConst.kSSLStreamType
+        )
+        result = Security.SSLSetIOFuncs(
+            self.context, _read_callback_pointer, _write_callback_pointer
+        )
+        _assert_no_error(result)
+
+        # Here we need to compute the handle to use. We do this by taking the
+        # id of self modulo 2**31 - 1. If this is already in the dictionary, we
+        # just keep incrementing by one until we find a free space.
+        with _connection_ref_lock:
+            handle = id(self) % 2147483647
+            while handle in _connection_refs:
+                handle = (handle + 1) % 2147483647
+            _connection_refs[handle] = self
+
+        result = Security.SSLSetConnection(self.context, handle)
+        _assert_no_error(result)
+
+        # If we have a server hostname, we should set that too.
+        if server_hostname:
+            if not isinstance(server_hostname, bytes):
+                server_hostname = server_hostname.encode("utf-8")
+
+            result = Security.SSLSetPeerDomainName(
+                self.context, server_hostname, len(server_hostname)
+            )
+            _assert_no_error(result)
+
+        # Setup the ciphers.
+        self._set_ciphers()
+
+        # Set the minimum and maximum TLS versions.
+        result = Security.SSLSetProtocolVersionMin(self.context, min_version)
+        _assert_no_error(result)
+
+        result = Security.SSLSetProtocolVersionMax(self.context, max_version)
+        _assert_no_error(result)
+
+        # If there's a trust DB, we need to use it. We do that by telling
+        # SecureTransport to break on server auth. We also do that if we don't
+        # want to validate the certs at all: we just won't actually do any
+        # authing in that case.
+        if not verify or trust_bundle is not None:
+            result = Security.SSLSetSessionOption(
+                self.context, SecurityConst.kSSLSessionOptionBreakOnServerAuth, True
+            )
+            _assert_no_error(result)
+
+        # If there's a client cert, we need to use it.
+        if client_cert:
+            self._keychain, self._keychain_dir = _temporary_keychain()
+            self._client_cert_chain = _load_client_cert_chain(
+                self._keychain, client_cert, client_key
+            )
+            result = Security.SSLSetCertificate(self.context, self._client_cert_chain)
+            _assert_no_error(result)
+
+        while True:
+            with self._raise_on_error():
+                result = Security.SSLHandshake(self.context)
+
+                if result == SecurityConst.errSSLWouldBlock:
+                    raise socket.timeout("handshake timed out")
+                elif result == SecurityConst.errSSLServerAuthCompleted:
+                    self._custom_validate(verify, trust_bundle)
+                    continue
+                else:
+                    _assert_no_error(result)
+                    break
+
+    def fileno(self):
+        return self.socket.fileno()
+
+    # Copy-pasted from Python 3.5 source code
+    def _decref_socketios(self):
+        if self._makefile_refs > 0:
+            self._makefile_refs -= 1
+        if self._closed:
+            self.close()
+
+    def recv(self, bufsiz):
+        buffer = ctypes.create_string_buffer(bufsiz)
+        bytes_read = self.recv_into(buffer, bufsiz)
+        data = buffer[:bytes_read]
+        return data
+
+    def recv_into(self, buffer, nbytes=None):
+        # Read short on EOF.
+        if self._closed:
+            return 0
+
+        if nbytes is None:
+            nbytes = len(buffer)
+
+        buffer = (ctypes.c_char * nbytes).from_buffer(buffer)
+        processed_bytes = ctypes.c_size_t(0)
+
+        with self._raise_on_error():
+            result = Security.SSLRead(
+                self.context, buffer, nbytes, ctypes.byref(processed_bytes)
+            )
+
+        # There are some result codes that we want to treat as "not always
+        # errors". Specifically, those are errSSLWouldBlock,
+        # errSSLClosedGraceful, and errSSLClosedNoNotify.
+        if result == SecurityConst.errSSLWouldBlock:
+            # If we didn't process any bytes, then this was just a time out.
+            # However, we can get errSSLWouldBlock in situations when we *did*
+            # read some data, and in those cases we should just read "short"
+            # and return.
+            if processed_bytes.value == 0:
+                # Timed out, no data read.
+                raise socket.timeout("recv timed out")
+        elif result in (
+            SecurityConst.errSSLClosedGraceful,
+            SecurityConst.errSSLClosedNoNotify,
+        ):
+            # The remote peer has closed this connection. We should do so as
+            # well. Note that we don't actually return here because in
+            # principle this could actually be fired along with return data.
+            # It's unlikely though.
+            self.close()
+        else:
+            _assert_no_error(result)
+
+        # Ok, we read and probably succeeded. We should return whatever data
+        # was actually read.
+        return processed_bytes.value
+
+    def settimeout(self, timeout):
+        self._timeout = timeout
+
+    def gettimeout(self):
+        return self._timeout
+
+    def send(self, data):
+        processed_bytes = ctypes.c_size_t(0)
+
+        with self._raise_on_error():
+            result = Security.SSLWrite(
+                self.context, data, len(data), ctypes.byref(processed_bytes)
+            )
+
+        if result == SecurityConst.errSSLWouldBlock and processed_bytes.value == 0:
+            # Timed out
+            raise socket.timeout("send timed out")
+        else:
+            _assert_no_error(result)
+
+        # We sent, and probably succeeded. Tell them how much we sent.
+        return processed_bytes.value
+
+    def sendall(self, data):
+        total_sent = 0
+        while total_sent < len(data):
+            sent = self.send(data[total_sent : total_sent + SSL_WRITE_BLOCKSIZE])
+            total_sent += sent
+
+    def shutdown(self):
+        with self._raise_on_error():
+            Security.SSLClose(self.context)
+
+    def close(self):
+        # TODO: should I do clean shutdown here? Do I have to?
+        if self._makefile_refs < 1:
+            self._closed = True
+            if self.context:
+                CoreFoundation.CFRelease(self.context)
+                self.context = None
+            if self._client_cert_chain:
+                CoreFoundation.CFRelease(self._client_cert_chain)
+                self._client_cert_chain = None
+            if self._keychain:
+                Security.SecKeychainDelete(self._keychain)
+                CoreFoundation.CFRelease(self._keychain)
+                shutil.rmtree(self._keychain_dir)
+                self._keychain = self._keychain_dir = None
+            return self.socket.close()
+        else:
+            self._makefile_refs -= 1
+
+    def getpeercert(self, binary_form=False):
+        # Urgh, annoying.
+        #
+        # Here's how we do this:
+        #
+        # 1. Call SSLCopyPeerTrust to get hold of the trust object for this
+        #    connection.
+        # 2. Call SecTrustGetCertificateAtIndex for index 0 to get the leaf.
+        # 3. To get the CN, call SecCertificateCopyCommonName and process that
+        #    string so that it's of the appropriate type.
+        # 4. To get the SAN, we need to do something a bit more complex:
+        #    a. Call SecCertificateCopyValues to get the data, requesting
+        #       kSecOIDSubjectAltName.
+        #    b. Mess about with this dictionary to try to get the SANs out.
+        #
+        # This is gross. Really gross. It's going to be a few hundred LoC extra
+        # just to repeat something that SecureTransport can *already do*. So my
+        # operating assumption at this time is that what we want to do is
+        # instead to just flag to urllib3 that it shouldn't do its own hostname
+        # validation when using SecureTransport.
+        if not binary_form:
+            raise ValueError("SecureTransport only supports dumping binary certs")
+        trust = Security.SecTrustRef()
+        certdata = None
+        der_bytes = None
+
+        try:
+            # Grab the trust store.
+            result = Security.SSLCopyPeerTrust(self.context, ctypes.byref(trust))
+            _assert_no_error(result)
+            if not trust:
+                # Probably we haven't done the handshake yet. No biggie.
+                return None
+
+            cert_count = Security.SecTrustGetCertificateCount(trust)
+            if not cert_count:
+                # Also a case that might happen if we haven't handshaked.
+                # Handshook? Handshaken?
+                return None
+
+            leaf = Security.SecTrustGetCertificateAtIndex(trust, 0)
+            assert leaf
+
+            # Ok, now we want the DER bytes.
+            certdata = Security.SecCertificateCopyData(leaf)
+            assert certdata
+
+            data_length = CoreFoundation.CFDataGetLength(certdata)
+            data_buffer = CoreFoundation.CFDataGetBytePtr(certdata)
+            der_bytes = ctypes.string_at(data_buffer, data_length)
+        finally:
+            if certdata:
+                CoreFoundation.CFRelease(certdata)
+            if trust:
+                CoreFoundation.CFRelease(trust)
+
+        return der_bytes
+
+    def version(self):
+        protocol = Security.SSLProtocol()
+        result = Security.SSLGetNegotiatedProtocolVersion(
+            self.context, ctypes.byref(protocol)
+        )
+        _assert_no_error(result)
+        if protocol.value == SecurityConst.kTLSProtocol13:
+            raise ssl.SSLError("SecureTransport does not support TLS 1.3")
+        elif protocol.value == SecurityConst.kTLSProtocol12:
+            return "TLSv1.2"
+        elif protocol.value == SecurityConst.kTLSProtocol11:
+            return "TLSv1.1"
+        elif protocol.value == SecurityConst.kTLSProtocol1:
+            return "TLSv1"
+        elif protocol.value == SecurityConst.kSSLProtocol3:
+            return "SSLv3"
+        elif protocol.value == SecurityConst.kSSLProtocol2:
+            return "SSLv2"
+        else:
+            raise ssl.SSLError("Unknown TLS version: %r" % protocol)
+
+    def _reuse(self):
+        self._makefile_refs += 1
+
+    def _drop(self):
+        if self._makefile_refs < 1:
+            self.close()
+        else:
+            self._makefile_refs -= 1
+
+
+if _fileobject:  # Platform-specific: Python 2
+
+    def makefile(self, mode, bufsize=-1):
+        self._makefile_refs += 1
+        return _fileobject(self, mode, bufsize, close=True)
+
+
+else:  # Platform-specific: Python 3
+
+    def makefile(self, mode="r", buffering=None, *args, **kwargs):
+        # We disable buffering with SecureTransport because it conflicts with
+        # the buffering that ST does internally (see issue #1153 for more).
+        buffering = 0
+        return backport_makefile(self, mode, buffering, *args, **kwargs)
+
+
+WrappedSocket.makefile = makefile
+
+
+class SecureTransportContext(object):
+    """
+    I am a wrapper class for the SecureTransport library, to translate the
+    interface of the standard library ``SSLContext`` object to calls into
+    SecureTransport.
+    """
+
+    def __init__(self, protocol):
+        self._min_version, self._max_version = _protocol_to_min_max[protocol]
+        self._options = 0
+        self._verify = False
+        self._trust_bundle = None
+        self._client_cert = None
+        self._client_key = None
+        self._client_key_passphrase = None
+
+    @property
+    def check_hostname(self):
+        """
+        SecureTransport cannot have its hostname checking disabled. For more,
+        see the comment on getpeercert() in this file.
+        """
+        return True
+
+    @check_hostname.setter
+    def check_hostname(self, value):
+        """
+        SecureTransport cannot have its hostname checking disabled. For more,
+        see the comment on getpeercert() in this file.
+        """
+        pass
+
+    @property
+    def options(self):
+        # TODO: Well, crap.
+        #
+        # So this is the bit of the code that is the most likely to cause us
+        # trouble. Essentially we need to enumerate all of the SSL options that
+        # users might want to use and try to see if we can sensibly translate
+        # them, or whether we should just ignore them.
+        return self._options
+
+    @options.setter
+    def options(self, value):
+        # TODO: Update in line with above.
+        self._options = value
+
+    @property
+    def verify_mode(self):
+        return ssl.CERT_REQUIRED if self._verify else ssl.CERT_NONE
+
+    @verify_mode.setter
+    def verify_mode(self, value):
+        self._verify = True if value == ssl.CERT_REQUIRED else False
+
+    def set_default_verify_paths(self):
+        # So, this has to do something a bit weird. Specifically, what it does
+        # is nothing.
+        #
+        # This means that, if we had previously had load_verify_locations
+        # called, this does not undo that. We need to do that because it turns
+        # out that the rest of the urllib3 code will attempt to load the
+        # default verify paths if it hasn't been told about any paths, even if
+        # the context itself was sometime earlier. We resolve that by just
+        # ignoring it.
+        pass
+
+    def load_default_certs(self):
+        return self.set_default_verify_paths()
+
+    def set_ciphers(self, ciphers):
+        # For now, we just require the default cipher string.
+        if ciphers != util.ssl_.DEFAULT_CIPHERS:
+            raise ValueError("SecureTransport doesn't support custom cipher strings")
+
+    def load_verify_locations(self, cafile=None, capath=None, cadata=None):
+        # OK, we only really support cadata and cafile.
+        if capath is not None:
+            raise ValueError("SecureTransport does not support cert directories")
+
+        # Raise if cafile does not exist.
+        if cafile is not None:
+            with open(cafile):
+                pass
+
+        self._trust_bundle = cafile or cadata
+
+    def load_cert_chain(self, certfile, keyfile=None, password=None):
+        self._client_cert = certfile
+        self._client_key = keyfile
+        self._client_cert_passphrase = password
+
+    def wrap_socket(
+        self,
+        sock,
+        server_side=False,
+        do_handshake_on_connect=True,
+        suppress_ragged_eofs=True,
+        server_hostname=None,
+    ):
+        # So, what do we do here? Firstly, we assert some properties. This is a
+        # stripped down shim, so there is some functionality we don't support.
+        # See PEP 543 for the real deal.
+        assert not server_side
+        assert do_handshake_on_connect
+        assert suppress_ragged_eofs
+
+        # Ok, we're good to go. Now we want to create the wrapped socket object
+        # and store it in the appropriate place.
+        wrapped_socket = WrappedSocket(sock)
+
+        # Now we can handshake
+        wrapped_socket.handshake(
+            server_hostname,
+            self._verify,
+            self._trust_bundle,
+            self._min_version,
+            self._max_version,
+            self._client_cert,
+            self._client_key,
+            self._client_key_passphrase,
+        )
+        return wrapped_socket
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/socks.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/socks.py
new file mode 100644
index 0000000..9e97f7a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/contrib/socks.py
@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+"""
+This module contains provisional support for SOCKS proxies from within
+urllib3. This module supports SOCKS4, SOCKS4A (an extension of SOCKS4), and
+SOCKS5. To enable its functionality, either install PySocks or install this
+module with the ``socks`` extra.
+
+The SOCKS implementation supports the full range of urllib3 features. It also
+supports the following SOCKS features:
+
+- SOCKS4A (``proxy_url='socks4a://...``)
+- SOCKS4 (``proxy_url='socks4://...``)
+- SOCKS5 with remote DNS (``proxy_url='socks5h://...``)
+- SOCKS5 with local DNS (``proxy_url='socks5://...``)
+- Usernames and passwords for the SOCKS proxy
+
+ .. note::
+    It is recommended to use ``socks5h://`` or ``socks4a://`` schemes in
+    your ``proxy_url`` to ensure that DNS resolution is done from the remote
+    server instead of client-side when connecting to a domain name.
+
+SOCKS4 supports IPv4 and domain names with the SOCKS4A extension. SOCKS5
+supports IPv4, IPv6, and domain names.
+
+When connecting to a SOCKS4 proxy the ``username`` portion of the ``proxy_url``
+will be sent as the ``userid`` section of the SOCKS request::
+
+    proxy_url="socks4a://<userid>@proxy-host"
+
+When connecting to a SOCKS5 proxy the ``username`` and ``password`` portion
+of the ``proxy_url`` will be sent as the username/password to authenticate
+with the proxy::
+
+    proxy_url="socks5h://<username>:<password>@proxy-host"
+
+"""
+from __future__ import absolute_import
+
+try:
+    import socks
+except ImportError:
+    import warnings
+    from ..exceptions import DependencyWarning
+
+    warnings.warn(
+        (
+            "SOCKS support in urllib3 requires the installation of optional "
+            "dependencies: specifically, PySocks.  For more information, see "
+            "https://urllib3.readthedocs.io/en/latest/contrib.html#socks-proxies"
+        ),
+        DependencyWarning,
+    )
+    raise
+
+from socket import error as SocketError, timeout as SocketTimeout
+
+from ..connection import HTTPConnection, HTTPSConnection
+from ..connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+from ..exceptions import ConnectTimeoutError, NewConnectionError
+from ..poolmanager import PoolManager
+from ..util.url import parse_url
+
+try:
+    import ssl
+except ImportError:
+    ssl = None
+
+
+class SOCKSConnection(HTTPConnection):
+    """
+    A plain-text HTTP connection that connects via a SOCKS proxy.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self._socks_options = kwargs.pop("_socks_options")
+        super(SOCKSConnection, self).__init__(*args, **kwargs)
+
+    def _new_conn(self):
+        """
+        Establish a new connection via the SOCKS proxy.
+        """
+        extra_kw = {}
+        if self.source_address:
+            extra_kw["source_address"] = self.source_address
+
+        if self.socket_options:
+            extra_kw["socket_options"] = self.socket_options
+
+        try:
+            conn = socks.create_connection(
+                (self.host, self.port),
+                proxy_type=self._socks_options["socks_version"],
+                proxy_addr=self._socks_options["proxy_host"],
+                proxy_port=self._socks_options["proxy_port"],
+                proxy_username=self._socks_options["username"],
+                proxy_password=self._socks_options["password"],
+                proxy_rdns=self._socks_options["rdns"],
+                timeout=self.timeout,
+                **extra_kw
+            )
+
+        except SocketTimeout:
+            raise ConnectTimeoutError(
+                self,
+                "Connection to %s timed out. (connect timeout=%s)"
+                % (self.host, self.timeout),
+            )
+
+        except socks.ProxyError as e:
+            # This is fragile as hell, but it seems to be the only way to raise
+            # useful errors here.
+            if e.socket_err:
+                error = e.socket_err
+                if isinstance(error, SocketTimeout):
+                    raise ConnectTimeoutError(
+                        self,
+                        "Connection to %s timed out. (connect timeout=%s)"
+                        % (self.host, self.timeout),
+                    )
+                else:
+                    raise NewConnectionError(
+                        self, "Failed to establish a new connection: %s" % error
+                    )
+            else:
+                raise NewConnectionError(
+                    self, "Failed to establish a new connection: %s" % e
+                )
+
+        except SocketError as e:  # Defensive: PySocks should catch all these.
+            raise NewConnectionError(
+                self, "Failed to establish a new connection: %s" % e
+            )
+
+        return conn
+
+
+# We don't need to duplicate the Verified/Unverified distinction from
+# urllib3/connection.py here because the HTTPSConnection will already have been
+# correctly set to either the Verified or Unverified form by that module. This
+# means the SOCKSHTTPSConnection will automatically be the correct type.
+class SOCKSHTTPSConnection(SOCKSConnection, HTTPSConnection):
+    pass
+
+
+class SOCKSHTTPConnectionPool(HTTPConnectionPool):
+    ConnectionCls = SOCKSConnection
+
+
+class SOCKSHTTPSConnectionPool(HTTPSConnectionPool):
+    ConnectionCls = SOCKSHTTPSConnection
+
+
+class SOCKSProxyManager(PoolManager):
+    """
+    A version of the urllib3 ProxyManager that routes connections via the
+    defined SOCKS proxy.
+    """
+
+    pool_classes_by_scheme = {
+        "http": SOCKSHTTPConnectionPool,
+        "https": SOCKSHTTPSConnectionPool,
+    }
+
+    def __init__(
+        self,
+        proxy_url,
+        username=None,
+        password=None,
+        num_pools=10,
+        headers=None,
+        **connection_pool_kw
+    ):
+        parsed = parse_url(proxy_url)
+
+        if username is None and password is None and parsed.auth is not None:
+            split = parsed.auth.split(":")
+            if len(split) == 2:
+                username, password = split
+        if parsed.scheme == "socks5":
+            socks_version = socks.PROXY_TYPE_SOCKS5
+            rdns = False
+        elif parsed.scheme == "socks5h":
+            socks_version = socks.PROXY_TYPE_SOCKS5
+            rdns = True
+        elif parsed.scheme == "socks4":
+            socks_version = socks.PROXY_TYPE_SOCKS4
+            rdns = False
+        elif parsed.scheme == "socks4a":
+            socks_version = socks.PROXY_TYPE_SOCKS4
+            rdns = True
+        else:
+            raise ValueError("Unable to determine SOCKS version from %s" % proxy_url)
+
+        self.proxy_url = proxy_url
+
+        socks_options = {
+            "socks_version": socks_version,
+            "proxy_host": parsed.host,
+            "proxy_port": parsed.port,
+            "username": username,
+            "password": password,
+            "rdns": rdns,
+        }
+        connection_pool_kw["_socks_options"] = socks_options
+
+        super(SOCKSProxyManager, self).__init__(
+            num_pools, headers, **connection_pool_kw
+        )
+
+        self.pool_classes_by_scheme = SOCKSProxyManager.pool_classes_by_scheme
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/exceptions.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/exceptions.py
new file mode 100644
index 0000000..5cc4d8a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/exceptions.py
@@ -0,0 +1,272 @@
+from __future__ import absolute_import
+from .packages.six.moves.http_client import IncompleteRead as httplib_IncompleteRead
+
+# Base Exceptions
+
+
+class HTTPError(Exception):
+    "Base exception used by this module."
+    pass
+
+
+class HTTPWarning(Warning):
+    "Base warning used by this module."
+    pass
+
+
+class PoolError(HTTPError):
+    "Base exception for errors caused within a pool."
+
+    def __init__(self, pool, message):
+        self.pool = pool
+        HTTPError.__init__(self, "%s: %s" % (pool, message))
+
+    def __reduce__(self):
+        # For pickling purposes.
+        return self.__class__, (None, None)
+
+
+class RequestError(PoolError):
+    "Base exception for PoolErrors that have associated URLs."
+
+    def __init__(self, pool, url, message):
+        self.url = url
+        PoolError.__init__(self, pool, message)
+
+    def __reduce__(self):
+        # For pickling purposes.
+        return self.__class__, (None, self.url, None)
+
+
+class SSLError(HTTPError):
+    "Raised when SSL certificate fails in an HTTPS connection."
+    pass
+
+
+class ProxyError(HTTPError):
+    "Raised when the connection to a proxy fails."
+
+    def __init__(self, message, error, *args):
+        super(ProxyError, self).__init__(message, error, *args)
+        self.original_error = error
+
+
+class DecodeError(HTTPError):
+    "Raised when automatic decoding based on Content-Type fails."
+    pass
+
+
+class ProtocolError(HTTPError):
+    "Raised when something unexpected happens mid-request/response."
+    pass
+
+
+#: Renamed to ProtocolError but aliased for backwards compatibility.
+ConnectionError = ProtocolError
+
+
+# Leaf Exceptions
+
+
+class MaxRetryError(RequestError):
+    """Raised when the maximum number of retries is exceeded.
+
+    :param pool: The connection pool
+    :type pool: :class:`~urllib3.connectionpool.HTTPConnectionPool`
+    :param string url: The requested Url
+    :param exceptions.Exception reason: The underlying error
+
+    """
+
+    def __init__(self, pool, url, reason=None):
+        self.reason = reason
+
+        message = "Max retries exceeded with url: %s (Caused by %r)" % (url, reason)
+
+        RequestError.__init__(self, pool, url, message)
+
+
+class HostChangedError(RequestError):
+    "Raised when an existing pool gets a request for a foreign host."
+
+    def __init__(self, pool, url, retries=3):
+        message = "Tried to open a foreign host with url: %s" % url
+        RequestError.__init__(self, pool, url, message)
+        self.retries = retries
+
+
+class TimeoutStateError(HTTPError):
+    """ Raised when passing an invalid state to a timeout """
+
+    pass
+
+
+class TimeoutError(HTTPError):
+    """ Raised when a socket timeout error occurs.
+
+    Catching this error will catch both :exc:`ReadTimeoutErrors
+    <ReadTimeoutError>` and :exc:`ConnectTimeoutErrors <ConnectTimeoutError>`.
+    """
+
+    pass
+
+
+class ReadTimeoutError(TimeoutError, RequestError):
+    "Raised when a socket timeout occurs while receiving data from a server"
+    pass
+
+
+# This timeout error does not have a URL attached and needs to inherit from the
+# base HTTPError
+class ConnectTimeoutError(TimeoutError):
+    "Raised when a socket timeout occurs while connecting to a server"
+    pass
+
+
+class NewConnectionError(ConnectTimeoutError, PoolError):
+    "Raised when we fail to establish a new connection. Usually ECONNREFUSED."
+    pass
+
+
+class EmptyPoolError(PoolError):
+    "Raised when a pool runs out of connections and no more are allowed."
+    pass
+
+
+class ClosedPoolError(PoolError):
+    "Raised when a request enters a pool after the pool has been closed."
+    pass
+
+
+class LocationValueError(ValueError, HTTPError):
+    "Raised when there is something wrong with a given URL input."
+    pass
+
+
+class LocationParseError(LocationValueError):
+    "Raised when get_host or similar fails to parse the URL input."
+
+    def __init__(self, location):
+        message = "Failed to parse: %s" % location
+        HTTPError.__init__(self, message)
+
+        self.location = location
+
+
+class ResponseError(HTTPError):
+    "Used as a container for an error reason supplied in a MaxRetryError."
+    GENERIC_ERROR = "too many error responses"
+    SPECIFIC_ERROR = "too many {status_code} error responses"
+
+
+class SecurityWarning(HTTPWarning):
+    "Warned when performing security reducing actions"
+    pass
+
+
+class SubjectAltNameWarning(SecurityWarning):
+    "Warned when connecting to a host with a certificate missing a SAN."
+    pass
+
+
+class InsecureRequestWarning(SecurityWarning):
+    "Warned when making an unverified HTTPS request."
+    pass
+
+
+class SystemTimeWarning(SecurityWarning):
+    "Warned when system time is suspected to be wrong"
+    pass
+
+
+class InsecurePlatformWarning(SecurityWarning):
+    "Warned when certain SSL configuration is not available on a platform."
+    pass
+
+
+class SNIMissingWarning(HTTPWarning):
+    "Warned when making a HTTPS request without SNI available."
+    pass
+
+
+class DependencyWarning(HTTPWarning):
+    """
+    Warned when an attempt is made to import a module with missing optional
+    dependencies.
+    """
+
+    pass
+
+
+class InvalidProxyConfigurationWarning(HTTPWarning):
+    """
+    Warned when using an HTTPS proxy and an HTTPS URL. Currently
+    urllib3 doesn't support HTTPS proxies and the proxy will be
+    contacted via HTTP instead. This warning can be fixed by
+    changing your HTTPS proxy URL into an HTTP proxy URL.
+
+    If you encounter this warning read this:
+    https://github.com/urllib3/urllib3/issues/1850
+    """
+
+    pass
+
+
+class ResponseNotChunked(ProtocolError, ValueError):
+    "Response needs to be chunked in order to read it as chunks."
+    pass
+
+
+class BodyNotHttplibCompatible(HTTPError):
+    """
+    Body should be httplib.HTTPResponse like (have an fp attribute which
+    returns raw chunks) for read_chunked().
+    """
+
+    pass
+
+
+class IncompleteRead(HTTPError, httplib_IncompleteRead):
+    """
+    Response length doesn't match expected Content-Length
+
+    Subclass of http_client.IncompleteRead to allow int value
+    for `partial` to avoid creating large objects on streamed
+    reads.
+    """
+
+    def __init__(self, partial, expected):
+        super(IncompleteRead, self).__init__(partial, expected)
+
+    def __repr__(self):
+        return "IncompleteRead(%i bytes read, %i more expected)" % (
+            self.partial,
+            self.expected,
+        )
+
+
+class InvalidHeader(HTTPError):
+    "The header provided was somehow invalid."
+    pass
+
+
+class ProxySchemeUnknown(AssertionError, ValueError):
+    "ProxyManager does not support the supplied scheme"
+    # TODO(t-8ch): Stop inheriting from AssertionError in v2.0.
+
+    def __init__(self, scheme):
+        message = "Not supported proxy scheme %s" % scheme
+        super(ProxySchemeUnknown, self).__init__(message)
+
+
+class HeaderParsingError(HTTPError):
+    "Raised by assert_header_parsing, but we convert it to a log.warning statement."
+
+    def __init__(self, defects, unparsed_data):
+        message = "%s, unparsed data: %r" % (defects or "Unknown", unparsed_data)
+        super(HeaderParsingError, self).__init__(message)
+
+
+class UnrewindableBodyError(HTTPError):
+    "urllib3 encountered an error when trying to rewind a body"
+    pass
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/fields.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/fields.py
new file mode 100644
index 0000000..8715b22
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/fields.py
@@ -0,0 +1,273 @@
+from __future__ import absolute_import
+import email.utils
+import mimetypes
+import re
+
+from .packages import six
+
+
+def guess_content_type(filename, default="application/octet-stream"):
+    """
+    Guess the "Content-Type" of a file.
+
+    :param filename:
+        The filename to guess the "Content-Type" of using :mod:`mimetypes`.
+    :param default:
+        If no "Content-Type" can be guessed, default to `default`.
+    """
+    if filename:
+        return mimetypes.guess_type(filename)[0] or default
+    return default
+
+
+def format_header_param_rfc2231(name, value):
+    """
+    Helper function to format and quote a single header parameter using the
+    strategy defined in RFC 2231.
+
+    Particularly useful for header parameters which might contain
+    non-ASCII values, like file names. This follows RFC 2388 Section 4.4.
+
+    :param name:
+        The name of the parameter, a string expected to be ASCII only.
+    :param value:
+        The value of the parameter, provided as ``bytes`` or `str``.
+    :ret:
+        An RFC-2231-formatted unicode string.
+    """
+    if isinstance(value, six.binary_type):
+        value = value.decode("utf-8")
+
+    if not any(ch in value for ch in '"\\\r\n'):
+        result = u'%s="%s"' % (name, value)
+        try:
+            result.encode("ascii")
+        except (UnicodeEncodeError, UnicodeDecodeError):
+            pass
+        else:
+            return result
+
+    if six.PY2:  # Python 2:
+        value = value.encode("utf-8")
+
+    # encode_rfc2231 accepts an encoded string and returns an ascii-encoded
+    # string in Python 2 but accepts and returns unicode strings in Python 3
+    value = email.utils.encode_rfc2231(value, "utf-8")
+    value = "%s*=%s" % (name, value)
+
+    if six.PY2:  # Python 2:
+        value = value.decode("utf-8")
+
+    return value
+
+
+_HTML5_REPLACEMENTS = {
+    u"\u0022": u"%22",
+    # Replace "\" with "\\".
+    u"\u005C": u"\u005C\u005C",
+    u"\u005C": u"\u005C\u005C",
+}
+
+# All control characters from 0x00 to 0x1F *except* 0x1B.
+_HTML5_REPLACEMENTS.update(
+    {
+        six.unichr(cc): u"%{:02X}".format(cc)
+        for cc in range(0x00, 0x1F + 1)
+        if cc not in (0x1B,)
+    }
+)
+
+
+def _replace_multiple(value, needles_and_replacements):
+    def replacer(match):
+        return needles_and_replacements[match.group(0)]
+
+    pattern = re.compile(
+        r"|".join([re.escape(needle) for needle in needles_and_replacements.keys()])
+    )
+
+    result = pattern.sub(replacer, value)
+
+    return result
+
+
+def format_header_param_html5(name, value):
+    """
+    Helper function to format and quote a single header parameter using the
+    HTML5 strategy.
+
+    Particularly useful for header parameters which might contain
+    non-ASCII values, like file names. This follows the `HTML5 Working Draft
+    Section 4.10.22.7`_ and matches the behavior of curl and modern browsers.
+
+    .. _HTML5 Working Draft Section 4.10.22.7:
+        https://w3c.github.io/html/sec-forms.html#multipart-form-data
+
+    :param name:
+        The name of the parameter, a string expected to be ASCII only.
+    :param value:
+        The value of the parameter, provided as ``bytes`` or `str``.
+    :ret:
+        A unicode string, stripped of troublesome characters.
+    """
+    if isinstance(value, six.binary_type):
+        value = value.decode("utf-8")
+
+    value = _replace_multiple(value, _HTML5_REPLACEMENTS)
+
+    return u'%s="%s"' % (name, value)
+
+
+# For backwards-compatibility.
+format_header_param = format_header_param_html5
+
+
+class RequestField(object):
+    """
+    A data container for request body parameters.
+
+    :param name:
+        The name of this request field. Must be unicode.
+    :param data:
+        The data/value body.
+    :param filename:
+        An optional filename of the request field. Must be unicode.
+    :param headers:
+        An optional dict-like object of headers to initially use for the field.
+    :param header_formatter:
+        An optional callable that is used to encode and format the headers. By
+        default, this is :func:`format_header_param_html5`.
+    """
+
+    def __init__(
+        self,
+        name,
+        data,
+        filename=None,
+        headers=None,
+        header_formatter=format_header_param_html5,
+    ):
+        self._name = name
+        self._filename = filename
+        self.data = data
+        self.headers = {}
+        if headers:
+            self.headers = dict(headers)
+        self.header_formatter = header_formatter
+
+    @classmethod
+    def from_tuples(cls, fieldname, value, header_formatter=format_header_param_html5):
+        """
+        A :class:`~urllib3.fields.RequestField` factory from old-style tuple parameters.
+
+        Supports constructing :class:`~urllib3.fields.RequestField` from
+        parameter of key/value strings AND key/filetuple. A filetuple is a
+        (filename, data, MIME type) tuple where the MIME type is optional.
+        For example::
+
+            'foo': 'bar',
+            'fakefile': ('foofile.txt', 'contents of foofile'),
+            'realfile': ('barfile.txt', open('realfile').read()),
+            'typedfile': ('bazfile.bin', open('bazfile').read(), 'image/jpeg'),
+            'nonamefile': 'contents of nonamefile field',
+
+        Field names and filenames must be unicode.
+        """
+        if isinstance(value, tuple):
+            if len(value) == 3:
+                filename, data, content_type = value
+            else:
+                filename, data = value
+                content_type = guess_content_type(filename)
+        else:
+            filename = None
+            content_type = None
+            data = value
+
+        request_param = cls(
+            fieldname, data, filename=filename, header_formatter=header_formatter
+        )
+        request_param.make_multipart(content_type=content_type)
+
+        return request_param
+
+    def _render_part(self, name, value):
+        """
+        Overridable helper function to format a single header parameter. By
+        default, this calls ``self.header_formatter``.
+
+        :param name:
+            The name of the parameter, a string expected to be ASCII only.
+        :param value:
+            The value of the parameter, provided as a unicode string.
+        """
+
+        return self.header_formatter(name, value)
+
+    def _render_parts(self, header_parts):
+        """
+        Helper function to format and quote a single header.
+
+        Useful for single headers that are composed of multiple items. E.g.,
+        'Content-Disposition' fields.
+
+        :param header_parts:
+            A sequence of (k, v) tuples or a :class:`dict` of (k, v) to format
+            as `k1="v1"; k2="v2"; ...`.
+        """
+        parts = []
+        iterable = header_parts
+        if isinstance(header_parts, dict):
+            iterable = header_parts.items()
+
+        for name, value in iterable:
+            if value is not None:
+                parts.append(self._render_part(name, value))
+
+        return u"; ".join(parts)
+
+    def render_headers(self):
+        """
+        Renders the headers for this request field.
+        """
+        lines = []
+
+        sort_keys = ["Content-Disposition", "Content-Type", "Content-Location"]
+        for sort_key in sort_keys:
+            if self.headers.get(sort_key, False):
+                lines.append(u"%s: %s" % (sort_key, self.headers[sort_key]))
+
+        for header_name, header_value in self.headers.items():
+            if header_name not in sort_keys:
+                if header_value:
+                    lines.append(u"%s: %s" % (header_name, header_value))
+
+        lines.append(u"\r\n")
+        return u"\r\n".join(lines)
+
+    def make_multipart(
+        self, content_disposition=None, content_type=None, content_location=None
+    ):
+        """
+        Makes this request field into a multipart request field.
+
+        This method overrides "Content-Disposition", "Content-Type" and
+        "Content-Location" headers to the request parameter.
+
+        :param content_type:
+            The 'Content-Type' of the request body.
+        :param content_location:
+            The 'Content-Location' of the request body.
+
+        """
+        self.headers["Content-Disposition"] = content_disposition or u"form-data"
+        self.headers["Content-Disposition"] += u"; ".join(
+            [
+                u"",
+                self._render_parts(
+                    ((u"name", self._name), (u"filename", self._filename))
+                ),
+            ]
+        )
+        self.headers["Content-Type"] = content_type
+        self.headers["Content-Location"] = content_location
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/filepost.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/filepost.py
new file mode 100644
index 0000000..b7b0099
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/filepost.py
@@ -0,0 +1,98 @@
+from __future__ import absolute_import
+import binascii
+import codecs
+import os
+
+from io import BytesIO
+
+from .packages import six
+from .packages.six import b
+from .fields import RequestField
+
+writer = codecs.lookup("utf-8")[3]
+
+
+def choose_boundary():
+    """
+    Our embarrassingly-simple replacement for mimetools.choose_boundary.
+    """
+    boundary = binascii.hexlify(os.urandom(16))
+    if not six.PY2:
+        boundary = boundary.decode("ascii")
+    return boundary
+
+
+def iter_field_objects(fields):
+    """
+    Iterate over fields.
+
+    Supports list of (k, v) tuples and dicts, and lists of
+    :class:`~urllib3.fields.RequestField`.
+
+    """
+    if isinstance(fields, dict):
+        i = six.iteritems(fields)
+    else:
+        i = iter(fields)
+
+    for field in i:
+        if isinstance(field, RequestField):
+            yield field
+        else:
+            yield RequestField.from_tuples(*field)
+
+
+def iter_fields(fields):
+    """
+    .. deprecated:: 1.6
+
+    Iterate over fields.
+
+    The addition of :class:`~urllib3.fields.RequestField` makes this function
+    obsolete. Instead, use :func:`iter_field_objects`, which returns
+    :class:`~urllib3.fields.RequestField` objects.
+
+    Supports list of (k, v) tuples and dicts.
+    """
+    if isinstance(fields, dict):
+        return ((k, v) for k, v in six.iteritems(fields))
+
+    return ((k, v) for k, v in fields)
+
+
+def encode_multipart_formdata(fields, boundary=None):
+    """
+    Encode a dictionary of ``fields`` using the multipart/form-data MIME format.
+
+    :param fields:
+        Dictionary of fields or list of (key, :class:`~urllib3.fields.RequestField`).
+
+    :param boundary:
+        If not specified, then a random boundary will be generated using
+        :func:`urllib3.filepost.choose_boundary`.
+    """
+    body = BytesIO()
+    if boundary is None:
+        boundary = choose_boundary()
+
+    for field in iter_field_objects(fields):
+        body.write(b("--%s\r\n" % (boundary)))
+
+        writer(body).write(field.render_headers())
+        data = field.data
+
+        if isinstance(data, int):
+            data = str(data)  # Backwards compatibility
+
+        if isinstance(data, six.text_type):
+            writer(body).write(data)
+        else:
+            body.write(data)
+
+        body.write(b"\r\n")
+
+    body.write(b("--%s--\r\n" % (boundary)))
+
+    content_type = str("multipart/form-data; boundary=%s" % boundary)
+
+    return body.getvalue(), content_type
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/__init__.py
new file mode 100644
index 0000000..fce4caa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/__init__.py
@@ -0,0 +1,5 @@
+from __future__ import absolute_import
+
+from . import ssl_match_hostname
+
+__all__ = ("ssl_match_hostname",)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/backports/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/backports/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py
new file mode 100644
index 0000000..a3156a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py
@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+"""
+backports.makefile
+~~~~~~~~~~~~~~~~~~
+
+Backports the Python 3 ``socket.makefile`` method for use with anything that
+wants to create a "fake" socket object.
+"""
+import io
+
+from socket import SocketIO
+
+
+def backport_makefile(
+    self, mode="r", buffering=None, encoding=None, errors=None, newline=None
+):
+    """
+    Backport of ``socket.makefile`` from Python 3.5.
+    """
+    if not set(mode) <= {"r", "w", "b"}:
+        raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,))
+    writing = "w" in mode
+    reading = "r" in mode or not writing
+    assert reading or writing
+    binary = "b" in mode
+    rawmode = ""
+    if reading:
+        rawmode += "r"
+    if writing:
+        rawmode += "w"
+    raw = SocketIO(self, rawmode)
+    self._makefile_refs += 1
+    if buffering is None:
+        buffering = -1
+    if buffering < 0:
+        buffering = io.DEFAULT_BUFFER_SIZE
+    if buffering == 0:
+        if not binary:
+            raise ValueError("unbuffered streams must be binary")
+        return raw
+    if reading and writing:
+        buffer = io.BufferedRWPair(raw, raw, buffering)
+    elif reading:
+        buffer = io.BufferedReader(raw, buffering)
+    else:
+        assert writing
+        buffer = io.BufferedWriter(raw, buffering)
+    if binary:
+        return buffer
+    text = io.TextIOWrapper(buffer, encoding, errors, newline)
+    text.mode = mode
+    return text
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/six.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/six.py
new file mode 100644
index 0000000..3144240
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/six.py
@@ -0,0 +1,1021 @@
+# Copyright (c) 2010-2019 Benjamin Peterson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+from __future__ import absolute_import
+
+import functools
+import itertools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.12.0"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+PY34 = sys.version_info[0:2] >= (3, 4)
+
+if PY3:
+    string_types = (str,)
+    integer_types = (int,)
+    class_types = (type,)
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = (basestring,)
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+            def __len__(self):
+                return 1 << 31
+
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result)  # Invokes __set__.
+        try:
+            # This is a bit ugly, but it avoids running this again by
+            # removing this descriptor.
+            delattr(obj.__class__, self.name)
+        except AttributeError:
+            pass
+        return result
+
+
+class MovedModule(_LazyDescr):
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+
+    get_source = get_code  # same as get_code
+
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+
+    """Lazy loading of moved objects"""
+
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute(
+        "filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"
+    ),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
+    MovedAttribute("getoutput", "commands", "subprocess"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute(
+        "reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"
+    ),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute(
+        "zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"
+    ),
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule(
+        "email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"
+    ),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser", "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog", "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+]
+# Add windows specific modules.
+if sys.platform == "win32":
+    _moved_attributes += [MovedModule("winreg", "_winreg")]
+
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute(
+        "unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"
+    ),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
+    MovedAttribute("splitvalue", "urllib", "urllib.parse"),
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(
+    Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+    "moves.urllib_parse",
+    "moves.urllib.parse",
+)
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(
+    Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+    "moves.urllib_error",
+    "moves.urllib.error",
+)
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+    MovedAttribute("parse_http_list", "urllib2", "urllib.request"),
+    MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"),
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(
+    Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+    "moves.urllib_request",
+    "moves.urllib.request",
+)
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(
+    Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+    "moves.urllib_response",
+    "moves.urllib.response",
+)
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser")
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = (
+    _urllib_robotparser_moved_attributes
+)
+
+_importer._add_module(
+    Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+    "moves.urllib_robotparser",
+    "moves.urllib.robotparser",
+)
+
+
+class Module_six_moves_urllib(types.ModuleType):
+
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ["parse", "error", "request", "response", "robotparser"]
+
+
+_importer._add_module(
+    Module_six_moves_urllib(__name__ + ".moves.urllib"), "moves.urllib"
+)
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+
+    def advance_iterator(it):
+        return it.next()
+
+
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    def create_unbound_method(func, cls):
+        return func
+
+    Iterator = object
+else:
+
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    def create_unbound_method(func, cls):
+        return types.MethodType(func, None, cls)
+
+    class Iterator(object):
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(
+    get_unbound_function, """Get the function out of a possibly unbound function"""
+)
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+
+    viewkeys = operator.methodcaller("keys")
+
+    viewvalues = operator.methodcaller("values")
+
+    viewitems = operator.methodcaller("items")
+else:
+
+    def iterkeys(d, **kw):
+        return d.iterkeys(**kw)
+
+    def itervalues(d, **kw):
+        return d.itervalues(**kw)
+
+    def iteritems(d, **kw):
+        return d.iteritems(**kw)
+
+    def iterlists(d, **kw):
+        return d.iterlists(**kw)
+
+    viewkeys = operator.methodcaller("viewkeys")
+
+    viewvalues = operator.methodcaller("viewvalues")
+
+    viewitems = operator.methodcaller("viewitems")
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems, "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(
+    iterlists, "Return an iterator over the (key, [values]) pairs of a dictionary."
+)
+
+
+if PY3:
+
+    def b(s):
+        return s.encode("latin-1")
+
+    def u(s):
+        return s
+
+    unichr = chr
+    import struct
+
+    int2byte = struct.Struct(">B").pack
+    del struct
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+    del io
+    _assertCountEqual = "assertCountEqual"
+    if sys.version_info[1] <= 1:
+        _assertRaisesRegex = "assertRaisesRegexp"
+        _assertRegex = "assertRegexpMatches"
+    else:
+        _assertRaisesRegex = "assertRaisesRegex"
+        _assertRegex = "assertRegex"
+else:
+
+    def b(s):
+        return s
+
+    # Workaround for standalone backslash
+
+    def u(s):
+        return unicode(s.replace(r"\\", r"\\\\"), "unicode_escape")
+
+    unichr = unichr
+    int2byte = chr
+
+    def byte2int(bs):
+        return ord(bs[0])
+
+    def indexbytes(buf, i):
+        return ord(buf[i])
+
+    iterbytes = functools.partial(itertools.imap, ord)
+    import StringIO
+
+    StringIO = BytesIO = StringIO.StringIO
+    _assertCountEqual = "assertItemsEqual"
+    _assertRaisesRegex = "assertRaisesRegexp"
+    _assertRegex = "assertRegexpMatches"
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+def assertCountEqual(self, *args, **kwargs):
+    return getattr(self, _assertCountEqual)(*args, **kwargs)
+
+
+def assertRaisesRegex(self, *args, **kwargs):
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
+
+
+def assertRegex(self, *args, **kwargs):
+    return getattr(self, _assertRegex)(*args, **kwargs)
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+    def reraise(tp, value, tb=None):
+        try:
+            if value is None:
+                value = tp()
+            if value.__traceback__ is not tb:
+                raise value.with_traceback(tb)
+            raise value
+        finally:
+            value = None
+            tb = None
+
+
+else:
+
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+    exec_(
+        """def reraise(tp, value, tb=None):
+    try:
+        raise tp, value, tb
+    finally:
+        tb = None
+"""
+    )
+
+
+if sys.version_info[:2] == (3, 2):
+    exec_(
+        """def raise_from(value, from_value):
+    try:
+        if from_value is None:
+            raise value
+        raise value from from_value
+    finally:
+        value = None
+"""
+    )
+elif sys.version_info[:2] > (3, 2):
+    exec_(
+        """def raise_from(value, from_value):
+    try:
+        raise value from from_value
+    finally:
+        value = None
+"""
+    )
+else:
+
+    def raise_from(value, from_value):
+        raise value
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (
+                isinstance(fp, file)
+                and isinstance(data, unicode)
+                and fp.encoding is not None
+            ):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+
+
+if sys.version_info[:2] < (3, 3):
+    _print = print_
+
+    def print_(*args, **kwargs):
+        fp = kwargs.get("file", sys.stdout)
+        flush = kwargs.pop("flush", False)
+        _print(*args, **kwargs)
+        if flush and fp is not None:
+            fp.flush()
+
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+
+    def wraps(
+        wrapped,
+        assigned=functools.WRAPPER_ASSIGNMENTS,
+        updated=functools.WRAPPER_UPDATES,
+    ):
+        def wrapper(f):
+            f = functools.wraps(wrapped, assigned, updated)(f)
+            f.__wrapped__ = wrapped
+            return f
+
+        return wrapper
+
+
+else:
+    wraps = functools.wraps
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(type):
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+
+        @classmethod
+        def __prepare__(cls, name, this_bases):
+            return meta.__prepare__(name, bases)
+
+    return type.__new__(metaclass, "temporary_class", (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get("__slots__")
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop("__dict__", None)
+        orig_vars.pop("__weakref__", None)
+        if hasattr(cls, "__qualname__"):
+            orig_vars["__qualname__"] = cls.__qualname__
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+
+    return wrapper
+
+
+def ensure_binary(s, encoding="utf-8", errors="strict"):
+    """Coerce **s** to six.binary_type.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> encoded to `bytes`
+      - `bytes` -> `bytes`
+    """
+    if isinstance(s, text_type):
+        return s.encode(encoding, errors)
+    elif isinstance(s, binary_type):
+        return s
+    else:
+        raise TypeError("not expecting type '%s'" % type(s))
+
+
+def ensure_str(s, encoding="utf-8", errors="strict"):
+    """Coerce *s* to `str`.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    if not isinstance(s, (text_type, binary_type)):
+        raise TypeError("not expecting type '%s'" % type(s))
+    if PY2 and isinstance(s, text_type):
+        s = s.encode(encoding, errors)
+    elif PY3 and isinstance(s, binary_type):
+        s = s.decode(encoding, errors)
+    return s
+
+
+def ensure_text(s, encoding="utf-8", errors="strict"):
+    """Coerce *s* to six.text_type.
+
+    For Python 2:
+      - `unicode` -> `unicode`
+      - `str` -> `unicode`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    if isinstance(s, binary_type):
+        return s.decode(encoding, errors)
+    elif isinstance(s, text_type):
+        return s
+    else:
+        raise TypeError("not expecting type '%s'" % type(s))
+
+
+def python_2_unicode_compatible(klass):
+    """
+    A decorator that defines __unicode__ and __str__ methods under Python 2.
+    Under Python 3 it does nothing.
+
+    To support Python 2 and 3 with a single code base, define a __str__ method
+    returning text and apply this decorator to the class.
+    """
+    if PY2:
+        if "__str__" not in klass.__dict__:
+            raise ValueError(
+                "@python_2_unicode_compatible cannot be applied "
+                "to %s because it doesn't define __str__()." % klass.__name__
+            )
+        klass.__unicode__ = klass.__str__
+        klass.__str__ = lambda self: self.__unicode__().encode("utf-8")
+    return klass
+
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (
+            type(importer).__name__ == "_SixMetaPathImporter"
+            and importer.name == __name__
+        ):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/__init__.py
new file mode 100644
index 0000000..75b6bb1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/__init__.py
@@ -0,0 +1,19 @@
+import sys
+
+try:
+    # Our match_hostname function is the same as 3.5's, so we only want to
+    # import the match_hostname function if it's at least that good.
+    if sys.version_info < (3, 5):
+        raise ImportError("Fallback to vendored code")
+
+    from ssl import CertificateError, match_hostname
+except ImportError:
+    try:
+        # Backport of the function from a pypi module
+        from backports.ssl_match_hostname import CertificateError, match_hostname
+    except ImportError:
+        # Our vendored copy
+        from ._implementation import CertificateError, match_hostname
+
+# Not needed, but documenting what we provide.
+__all__ = ("CertificateError", "match_hostname")
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/_implementation.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/_implementation.py
new file mode 100644
index 0000000..5831c2e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/_implementation.py
@@ -0,0 +1,160 @@
+"""The match_hostname() function from Python 3.3.3, essential when using SSL."""
+
+# Note: This file is under the PSF license as the code comes from the python
+# stdlib.   http://docs.python.org/3/license.html
+
+import re
+import sys
+
+# ipaddress has been backported to 2.6+ in pypi.  If it is installed on the
+# system, use it to handle IPAddress ServerAltnames (this was added in
+# python-3.5) otherwise only do DNS matching.  This allows
+# backports.ssl_match_hostname to continue to be used in Python 2.7.
+try:
+    from pip._vendor import ipaddress
+except ImportError:
+    ipaddress = None
+
+__version__ = "3.5.0.1"
+
+
+class CertificateError(ValueError):
+    pass
+
+
+def _dnsname_match(dn, hostname, max_wildcards=1):
+    """Matching according to RFC 6125, section 6.4.3
+
+    http://tools.ietf.org/html/rfc6125#section-6.4.3
+    """
+    pats = []
+    if not dn:
+        return False
+
+    # Ported from python3-syntax:
+    # leftmost, *remainder = dn.split(r'.')
+    parts = dn.split(r".")
+    leftmost = parts[0]
+    remainder = parts[1:]
+
+    wildcards = leftmost.count("*")
+    if wildcards > max_wildcards:
+        # Issue #17980: avoid denials of service by refusing more
+        # than one wildcard per fragment.  A survey of established
+        # policy among SSL implementations showed it to be a
+        # reasonable choice.
+        raise CertificateError(
+            "too many wildcards in certificate DNS name: " + repr(dn)
+        )
+
+    # speed up common case w/o wildcards
+    if not wildcards:
+        return dn.lower() == hostname.lower()
+
+    # RFC 6125, section 6.4.3, subitem 1.
+    # The client SHOULD NOT attempt to match a presented identifier in which
+    # the wildcard character comprises a label other than the left-most label.
+    if leftmost == "*":
+        # When '*' is a fragment by itself, it matches a non-empty dotless
+        # fragment.
+        pats.append("[^.]+")
+    elif leftmost.startswith("xn--") or hostname.startswith("xn--"):
+        # RFC 6125, section 6.4.3, subitem 3.
+        # The client SHOULD NOT attempt to match a presented identifier
+        # where the wildcard character is embedded within an A-label or
+        # U-label of an internationalized domain name.
+        pats.append(re.escape(leftmost))
+    else:
+        # Otherwise, '*' matches any dotless string, e.g. www*
+        pats.append(re.escape(leftmost).replace(r"\*", "[^.]*"))
+
+    # add the remaining fragments, ignore any wildcards
+    for frag in remainder:
+        pats.append(re.escape(frag))
+
+    pat = re.compile(r"\A" + r"\.".join(pats) + r"\Z", re.IGNORECASE)
+    return pat.match(hostname)
+
+
+def _to_unicode(obj):
+    if isinstance(obj, str) and sys.version_info < (3,):
+        obj = unicode(obj, encoding="ascii", errors="strict")
+    return obj
+
+
+def _ipaddress_match(ipname, host_ip):
+    """Exact matching of IP addresses.
+
+    RFC 6125 explicitly doesn't define an algorithm for this
+    (section 1.7.2 - "Out of Scope").
+    """
+    # OpenSSL may add a trailing newline to a subjectAltName's IP address
+    # Divergence from upstream: ipaddress can't handle byte str
+    ip = ipaddress.ip_address(_to_unicode(ipname).rstrip())
+    return ip == host_ip
+
+
+def match_hostname(cert, hostname):
+    """Verify that *cert* (in decoded format as returned by
+    SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
+    rules are followed, but IP addresses are not accepted for *hostname*.
+
+    CertificateError is raised on failure. On success, the function
+    returns nothing.
+    """
+    if not cert:
+        raise ValueError(
+            "empty or no certificate, match_hostname needs a "
+            "SSL socket or SSL context with either "
+            "CERT_OPTIONAL or CERT_REQUIRED"
+        )
+    try:
+        # Divergence from upstream: ipaddress can't handle byte str
+        host_ip = ipaddress.ip_address(_to_unicode(hostname))
+    except ValueError:
+        # Not an IP address (common case)
+        host_ip = None
+    except UnicodeError:
+        # Divergence from upstream: Have to deal with ipaddress not taking
+        # byte strings.  addresses should be all ascii, so we consider it not
+        # an ipaddress in this case
+        host_ip = None
+    except AttributeError:
+        # Divergence from upstream: Make ipaddress library optional
+        if ipaddress is None:
+            host_ip = None
+        else:
+            raise
+    dnsnames = []
+    san = cert.get("subjectAltName", ())
+    for key, value in san:
+        if key == "DNS":
+            if host_ip is None and _dnsname_match(value, hostname):
+                return
+            dnsnames.append(value)
+        elif key == "IP Address":
+            if host_ip is not None and _ipaddress_match(value, host_ip):
+                return
+            dnsnames.append(value)
+    if not dnsnames:
+        # The subject is only checked when there is no dNSName entry
+        # in subjectAltName
+        for sub in cert.get("subject", ()):
+            for key, value in sub:
+                # XXX according to RFC 2818, the most specific Common Name
+                # must be used.
+                if key == "commonName":
+                    if _dnsname_match(value, hostname):
+                        return
+                    dnsnames.append(value)
+    if len(dnsnames) > 1:
+        raise CertificateError(
+            "hostname %r "
+            "doesn't match either of %s" % (hostname, ", ".join(map(repr, dnsnames)))
+        )
+    elif len(dnsnames) == 1:
+        raise CertificateError("hostname %r doesn't match %r" % (hostname, dnsnames[0]))
+    else:
+        raise CertificateError(
+            "no appropriate commonName or subjectAltName fields were found"
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/poolmanager.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/poolmanager.py
new file mode 100644
index 0000000..e2bd3bd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/poolmanager.py
@@ -0,0 +1,492 @@
+from __future__ import absolute_import
+import collections
+import functools
+import logging
+import warnings
+
+from ._collections import RecentlyUsedContainer
+from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+from .connectionpool import port_by_scheme
+from .exceptions import (
+    LocationValueError,
+    MaxRetryError,
+    ProxySchemeUnknown,
+    InvalidProxyConfigurationWarning,
+)
+from .packages import six
+from .packages.six.moves.urllib.parse import urljoin
+from .request import RequestMethods
+from .util.url import parse_url
+from .util.retry import Retry
+
+
+__all__ = ["PoolManager", "ProxyManager", "proxy_from_url"]
+
+
+log = logging.getLogger(__name__)
+
+SSL_KEYWORDS = (
+    "key_file",
+    "cert_file",
+    "cert_reqs",
+    "ca_certs",
+    "ssl_version",
+    "ca_cert_dir",
+    "ssl_context",
+    "key_password",
+)
+
+# All known keyword arguments that could be provided to the pool manager, its
+# pools, or the underlying connections. This is used to construct a pool key.
+_key_fields = (
+    "key_scheme",  # str
+    "key_host",  # str
+    "key_port",  # int
+    "key_timeout",  # int or float or Timeout
+    "key_retries",  # int or Retry
+    "key_strict",  # bool
+    "key_block",  # bool
+    "key_source_address",  # str
+    "key_key_file",  # str
+    "key_key_password",  # str
+    "key_cert_file",  # str
+    "key_cert_reqs",  # str
+    "key_ca_certs",  # str
+    "key_ssl_version",  # str
+    "key_ca_cert_dir",  # str
+    "key_ssl_context",  # instance of ssl.SSLContext or urllib3.util.ssl_.SSLContext
+    "key_maxsize",  # int
+    "key_headers",  # dict
+    "key__proxy",  # parsed proxy url
+    "key__proxy_headers",  # dict
+    "key_socket_options",  # list of (level (int), optname (int), value (int or str)) tuples
+    "key__socks_options",  # dict
+    "key_assert_hostname",  # bool or string
+    "key_assert_fingerprint",  # str
+    "key_server_hostname",  # str
+)
+
+#: The namedtuple class used to construct keys for the connection pool.
+#: All custom key schemes should include the fields in this key at a minimum.
+PoolKey = collections.namedtuple("PoolKey", _key_fields)
+
+
+def _default_key_normalizer(key_class, request_context):
+    """
+    Create a pool key out of a request context dictionary.
+
+    According to RFC 3986, both the scheme and host are case-insensitive.
+    Therefore, this function normalizes both before constructing the pool
+    key for an HTTPS request. If you wish to change this behaviour, provide
+    alternate callables to ``key_fn_by_scheme``.
+
+    :param key_class:
+        The class to use when constructing the key. This should be a namedtuple
+        with the ``scheme`` and ``host`` keys at a minimum.
+    :type  key_class: namedtuple
+    :param request_context:
+        A dictionary-like object that contain the context for a request.
+    :type  request_context: dict
+
+    :return: A namedtuple that can be used as a connection pool key.
+    :rtype:  PoolKey
+    """
+    # Since we mutate the dictionary, make a copy first
+    context = request_context.copy()
+    context["scheme"] = context["scheme"].lower()
+    context["host"] = context["host"].lower()
+
+    # These are both dictionaries and need to be transformed into frozensets
+    for key in ("headers", "_proxy_headers", "_socks_options"):
+        if key in context and context[key] is not None:
+            context[key] = frozenset(context[key].items())
+
+    # The socket_options key may be a list and needs to be transformed into a
+    # tuple.
+    socket_opts = context.get("socket_options")
+    if socket_opts is not None:
+        context["socket_options"] = tuple(socket_opts)
+
+    # Map the kwargs to the names in the namedtuple - this is necessary since
+    # namedtuples can't have fields starting with '_'.
+    for key in list(context.keys()):
+        context["key_" + key] = context.pop(key)
+
+    # Default to ``None`` for keys missing from the context
+    for field in key_class._fields:
+        if field not in context:
+            context[field] = None
+
+    return key_class(**context)
+
+
+#: A dictionary that maps a scheme to a callable that creates a pool key.
+#: This can be used to alter the way pool keys are constructed, if desired.
+#: Each PoolManager makes a copy of this dictionary so they can be configured
+#: globally here, or individually on the instance.
+key_fn_by_scheme = {
+    "http": functools.partial(_default_key_normalizer, PoolKey),
+    "https": functools.partial(_default_key_normalizer, PoolKey),
+}
+
+pool_classes_by_scheme = {"http": HTTPConnectionPool, "https": HTTPSConnectionPool}
+
+
+class PoolManager(RequestMethods):
+    """
+    Allows for arbitrary requests while transparently keeping track of
+    necessary connection pools for you.
+
+    :param num_pools:
+        Number of connection pools to cache before discarding the least
+        recently used pool.
+
+    :param headers:
+        Headers to include with all requests, unless other headers are given
+        explicitly.
+
+    :param \\**connection_pool_kw:
+        Additional parameters are used to create fresh
+        :class:`urllib3.connectionpool.ConnectionPool` instances.
+
+    Example::
+
+        >>> manager = PoolManager(num_pools=2)
+        >>> r = manager.request('GET', 'http://google.com/')
+        >>> r = manager.request('GET', 'http://google.com/mail')
+        >>> r = manager.request('GET', 'http://yahoo.com/')
+        >>> len(manager.pools)
+        2
+
+    """
+
+    proxy = None
+
+    def __init__(self, num_pools=10, headers=None, **connection_pool_kw):
+        RequestMethods.__init__(self, headers)
+        self.connection_pool_kw = connection_pool_kw
+        self.pools = RecentlyUsedContainer(num_pools, dispose_func=lambda p: p.close())
+
+        # Locally set the pool classes and keys so other PoolManagers can
+        # override them.
+        self.pool_classes_by_scheme = pool_classes_by_scheme
+        self.key_fn_by_scheme = key_fn_by_scheme.copy()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.clear()
+        # Return False to re-raise any potential exceptions
+        return False
+
+    def _new_pool(self, scheme, host, port, request_context=None):
+        """
+        Create a new :class:`ConnectionPool` based on host, port, scheme, and
+        any additional pool keyword arguments.
+
+        If ``request_context`` is provided, it is provided as keyword arguments
+        to the pool class used. This method is used to actually create the
+        connection pools handed out by :meth:`connection_from_url` and
+        companion methods. It is intended to be overridden for customization.
+        """
+        pool_cls = self.pool_classes_by_scheme[scheme]
+        if request_context is None:
+            request_context = self.connection_pool_kw.copy()
+
+        # Although the context has everything necessary to create the pool,
+        # this function has historically only used the scheme, host, and port
+        # in the positional args. When an API change is acceptable these can
+        # be removed.
+        for key in ("scheme", "host", "port"):
+            request_context.pop(key, None)
+
+        if scheme == "http":
+            for kw in SSL_KEYWORDS:
+                request_context.pop(kw, None)
+
+        return pool_cls(host, port, **request_context)
+
+    def clear(self):
+        """
+        Empty our store of pools and direct them all to close.
+
+        This will not affect in-flight connections, but they will not be
+        re-used after completion.
+        """
+        self.pools.clear()
+
+    def connection_from_host(self, host, port=None, scheme="http", pool_kwargs=None):
+        """
+        Get a :class:`ConnectionPool` based on the host, port, and scheme.
+
+        If ``port`` isn't given, it will be derived from the ``scheme`` using
+        ``urllib3.connectionpool.port_by_scheme``. If ``pool_kwargs`` is
+        provided, it is merged with the instance's ``connection_pool_kw``
+        variable and used to create the new connection pool, if one is
+        needed.
+        """
+
+        if not host:
+            raise LocationValueError("No host specified.")
+
+        request_context = self._merge_pool_kwargs(pool_kwargs)
+        request_context["scheme"] = scheme or "http"
+        if not port:
+            port = port_by_scheme.get(request_context["scheme"].lower(), 80)
+        request_context["port"] = port
+        request_context["host"] = host
+
+        return self.connection_from_context(request_context)
+
+    def connection_from_context(self, request_context):
+        """
+        Get a :class:`ConnectionPool` based on the request context.
+
+        ``request_context`` must at least contain the ``scheme`` key and its
+        value must be a key in ``key_fn_by_scheme`` instance variable.
+        """
+        scheme = request_context["scheme"].lower()
+        pool_key_constructor = self.key_fn_by_scheme[scheme]
+        pool_key = pool_key_constructor(request_context)
+
+        return self.connection_from_pool_key(pool_key, request_context=request_context)
+
+    def connection_from_pool_key(self, pool_key, request_context=None):
+        """
+        Get a :class:`ConnectionPool` based on the provided pool key.
+
+        ``pool_key`` should be a namedtuple that only contains immutable
+        objects. At a minimum it must have the ``scheme``, ``host``, and
+        ``port`` fields.
+        """
+        with self.pools.lock:
+            # If the scheme, host, or port doesn't match existing open
+            # connections, open a new ConnectionPool.
+            pool = self.pools.get(pool_key)
+            if pool:
+                return pool
+
+            # Make a fresh ConnectionPool of the desired type
+            scheme = request_context["scheme"]
+            host = request_context["host"]
+            port = request_context["port"]
+            pool = self._new_pool(scheme, host, port, request_context=request_context)
+            self.pools[pool_key] = pool
+
+        return pool
+
+    def connection_from_url(self, url, pool_kwargs=None):
+        """
+        Similar to :func:`urllib3.connectionpool.connection_from_url`.
+
+        If ``pool_kwargs`` is not provided and a new pool needs to be
+        constructed, ``self.connection_pool_kw`` is used to initialize
+        the :class:`urllib3.connectionpool.ConnectionPool`. If ``pool_kwargs``
+        is provided, it is used instead. Note that if a new pool does not
+        need to be created for the request, the provided ``pool_kwargs`` are
+        not used.
+        """
+        u = parse_url(url)
+        return self.connection_from_host(
+            u.host, port=u.port, scheme=u.scheme, pool_kwargs=pool_kwargs
+        )
+
+    def _merge_pool_kwargs(self, override):
+        """
+        Merge a dictionary of override values for self.connection_pool_kw.
+
+        This does not modify self.connection_pool_kw and returns a new dict.
+        Any keys in the override dictionary with a value of ``None`` are
+        removed from the merged dictionary.
+        """
+        base_pool_kwargs = self.connection_pool_kw.copy()
+        if override:
+            for key, value in override.items():
+                if value is None:
+                    try:
+                        del base_pool_kwargs[key]
+                    except KeyError:
+                        pass
+                else:
+                    base_pool_kwargs[key] = value
+        return base_pool_kwargs
+
+    def urlopen(self, method, url, redirect=True, **kw):
+        """
+        Same as :meth:`urllib3.connectionpool.HTTPConnectionPool.urlopen`
+        with custom cross-host redirect logic and only sends the request-uri
+        portion of the ``url``.
+
+        The given ``url`` parameter must be absolute, such that an appropriate
+        :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it.
+        """
+        u = parse_url(url)
+        conn = self.connection_from_host(u.host, port=u.port, scheme=u.scheme)
+
+        kw["assert_same_host"] = False
+        kw["redirect"] = False
+
+        if "headers" not in kw:
+            kw["headers"] = self.headers.copy()
+
+        if self.proxy is not None and u.scheme == "http":
+            response = conn.urlopen(method, url, **kw)
+        else:
+            response = conn.urlopen(method, u.request_uri, **kw)
+
+        redirect_location = redirect and response.get_redirect_location()
+        if not redirect_location:
+            return response
+
+        # Support relative URLs for redirecting.
+        redirect_location = urljoin(url, redirect_location)
+
+        # RFC 7231, Section 6.4.4
+        if response.status == 303:
+            method = "GET"
+
+        retries = kw.get("retries")
+        if not isinstance(retries, Retry):
+            retries = Retry.from_int(retries, redirect=redirect)
+
+        # Strip headers marked as unsafe to forward to the redirected location.
+        # Check remove_headers_on_redirect to avoid a potential network call within
+        # conn.is_same_host() which may use socket.gethostbyname() in the future.
+        if retries.remove_headers_on_redirect and not conn.is_same_host(
+            redirect_location
+        ):
+            headers = list(six.iterkeys(kw["headers"]))
+            for header in headers:
+                if header.lower() in retries.remove_headers_on_redirect:
+                    kw["headers"].pop(header, None)
+
+        try:
+            retries = retries.increment(method, url, response=response, _pool=conn)
+        except MaxRetryError:
+            if retries.raise_on_redirect:
+                response.drain_conn()
+                raise
+            return response
+
+        kw["retries"] = retries
+        kw["redirect"] = redirect
+
+        log.info("Redirecting %s -> %s", url, redirect_location)
+
+        response.drain_conn()
+        return self.urlopen(method, redirect_location, **kw)
+
+
+class ProxyManager(PoolManager):
+    """
+    Behaves just like :class:`PoolManager`, but sends all requests through
+    the defined proxy, using the CONNECT method for HTTPS URLs.
+
+    :param proxy_url:
+        The URL of the proxy to be used.
+
+    :param proxy_headers:
+        A dictionary containing headers that will be sent to the proxy. In case
+        of HTTP they are being sent with each request, while in the
+        HTTPS/CONNECT case they are sent only once. Could be used for proxy
+        authentication.
+
+    Example:
+        >>> proxy = urllib3.ProxyManager('http://localhost:3128/')
+        >>> r1 = proxy.request('GET', 'http://google.com/')
+        >>> r2 = proxy.request('GET', 'http://httpbin.org/')
+        >>> len(proxy.pools)
+        1
+        >>> r3 = proxy.request('GET', 'https://httpbin.org/')
+        >>> r4 = proxy.request('GET', 'https://twitter.com/')
+        >>> len(proxy.pools)
+        3
+
+    """
+
+    def __init__(
+        self,
+        proxy_url,
+        num_pools=10,
+        headers=None,
+        proxy_headers=None,
+        **connection_pool_kw
+    ):
+
+        if isinstance(proxy_url, HTTPConnectionPool):
+            proxy_url = "%s://%s:%i" % (
+                proxy_url.scheme,
+                proxy_url.host,
+                proxy_url.port,
+            )
+        proxy = parse_url(proxy_url)
+        if not proxy.port:
+            port = port_by_scheme.get(proxy.scheme, 80)
+            proxy = proxy._replace(port=port)
+
+        if proxy.scheme not in ("http", "https"):
+            raise ProxySchemeUnknown(proxy.scheme)
+
+        self.proxy = proxy
+        self.proxy_headers = proxy_headers or {}
+
+        connection_pool_kw["_proxy"] = self.proxy
+        connection_pool_kw["_proxy_headers"] = self.proxy_headers
+
+        super(ProxyManager, self).__init__(num_pools, headers, **connection_pool_kw)
+
+    def connection_from_host(self, host, port=None, scheme="http", pool_kwargs=None):
+        if scheme == "https":
+            return super(ProxyManager, self).connection_from_host(
+                host, port, scheme, pool_kwargs=pool_kwargs
+            )
+
+        return super(ProxyManager, self).connection_from_host(
+            self.proxy.host, self.proxy.port, self.proxy.scheme, pool_kwargs=pool_kwargs
+        )
+
+    def _set_proxy_headers(self, url, headers=None):
+        """
+        Sets headers needed by proxies: specifically, the Accept and Host
+        headers. Only sets headers not provided by the user.
+        """
+        headers_ = {"Accept": "*/*"}
+
+        netloc = parse_url(url).netloc
+        if netloc:
+            headers_["Host"] = netloc
+
+        if headers:
+            headers_.update(headers)
+        return headers_
+
+    def _validate_proxy_scheme_url_selection(self, url_scheme):
+        if url_scheme == "https" and self.proxy.scheme == "https":
+            warnings.warn(
+                "Your proxy configuration specified an HTTPS scheme for the proxy. "
+                "Are you sure you want to use HTTPS to contact the proxy? "
+                "This most likely indicates an error in your configuration. "
+                "Read this issue for more info: "
+                "https://github.com/urllib3/urllib3/issues/1850",
+                InvalidProxyConfigurationWarning,
+                stacklevel=3,
+            )
+
+    def urlopen(self, method, url, redirect=True, **kw):
+        "Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute."
+        u = parse_url(url)
+        self._validate_proxy_scheme_url_selection(u.scheme)
+
+        if u.scheme == "http":
+            # For proxied HTTPS requests, httplib sets the necessary headers
+            # on the CONNECT to the proxy. For HTTP, we'll definitely
+            # need to set 'Host' at the very least.
+            headers = kw.get("headers", self.headers)
+            kw["headers"] = self._set_proxy_headers(url, headers)
+
+        return super(ProxyManager, self).urlopen(method, url, redirect=redirect, **kw)
+
+
+def proxy_from_url(url, **kw):
+    return ProxyManager(proxy_url=url, **kw)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/request.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/request.py
new file mode 100644
index 0000000..55f160b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/request.py
@@ -0,0 +1,171 @@
+from __future__ import absolute_import
+
+from .filepost import encode_multipart_formdata
+from .packages.six.moves.urllib.parse import urlencode
+
+
+__all__ = ["RequestMethods"]
+
+
+class RequestMethods(object):
+    """
+    Convenience mixin for classes who implement a :meth:`urlopen` method, such
+    as :class:`~urllib3.connectionpool.HTTPConnectionPool` and
+    :class:`~urllib3.poolmanager.PoolManager`.
+
+    Provides behavior for making common types of HTTP request methods and
+    decides which type of request field encoding to use.
+
+    Specifically,
+
+    :meth:`.request_encode_url` is for sending requests whose fields are
+    encoded in the URL (such as GET, HEAD, DELETE).
+
+    :meth:`.request_encode_body` is for sending requests whose fields are
+    encoded in the *body* of the request using multipart or www-form-urlencoded
+    (such as for POST, PUT, PATCH).
+
+    :meth:`.request` is for making any kind of request, it will look up the
+    appropriate encoding format and use one of the above two methods to make
+    the request.
+
+    Initializer parameters:
+
+    :param headers:
+        Headers to include with all requests, unless other headers are given
+        explicitly.
+    """
+
+    _encode_url_methods = {"DELETE", "GET", "HEAD", "OPTIONS"}
+
+    def __init__(self, headers=None):
+        self.headers = headers or {}
+
+    def urlopen(
+        self,
+        method,
+        url,
+        body=None,
+        headers=None,
+        encode_multipart=True,
+        multipart_boundary=None,
+        **kw
+    ):  # Abstract
+        raise NotImplementedError(
+            "Classes extending RequestMethods must implement "
+            "their own ``urlopen`` method."
+        )
+
+    def request(self, method, url, fields=None, headers=None, **urlopen_kw):
+        """
+        Make a request using :meth:`urlopen` with the appropriate encoding of
+        ``fields`` based on the ``method`` used.
+
+        This is a convenience method that requires the least amount of manual
+        effort. It can be used in most situations, while still having the
+        option to drop down to more specific methods when necessary, such as
+        :meth:`request_encode_url`, :meth:`request_encode_body`,
+        or even the lowest level :meth:`urlopen`.
+        """
+        method = method.upper()
+
+        urlopen_kw["request_url"] = url
+
+        if method in self._encode_url_methods:
+            return self.request_encode_url(
+                method, url, fields=fields, headers=headers, **urlopen_kw
+            )
+        else:
+            return self.request_encode_body(
+                method, url, fields=fields, headers=headers, **urlopen_kw
+            )
+
+    def request_encode_url(self, method, url, fields=None, headers=None, **urlopen_kw):
+        """
+        Make a request using :meth:`urlopen` with the ``fields`` encoded in
+        the url. This is useful for request methods like GET, HEAD, DELETE, etc.
+        """
+        if headers is None:
+            headers = self.headers
+
+        extra_kw = {"headers": headers}
+        extra_kw.update(urlopen_kw)
+
+        if fields:
+            url += "?" + urlencode(fields)
+
+        return self.urlopen(method, url, **extra_kw)
+
+    def request_encode_body(
+        self,
+        method,
+        url,
+        fields=None,
+        headers=None,
+        encode_multipart=True,
+        multipart_boundary=None,
+        **urlopen_kw
+    ):
+        """
+        Make a request using :meth:`urlopen` with the ``fields`` encoded in
+        the body. This is useful for request methods like POST, PUT, PATCH, etc.
+
+        When ``encode_multipart=True`` (default), then
+        :meth:`urllib3.filepost.encode_multipart_formdata` is used to encode
+        the payload with the appropriate content type. Otherwise
+        :meth:`urllib.urlencode` is used with the
+        'application/x-www-form-urlencoded' content type.
+
+        Multipart encoding must be used when posting files, and it's reasonably
+        safe to use it in other times too. However, it may break request
+        signing, such as with OAuth.
+
+        Supports an optional ``fields`` parameter of key/value strings AND
+        key/filetuple. A filetuple is a (filename, data, MIME type) tuple where
+        the MIME type is optional. For example::
+
+            fields = {
+                'foo': 'bar',
+                'fakefile': ('foofile.txt', 'contents of foofile'),
+                'realfile': ('barfile.txt', open('realfile').read()),
+                'typedfile': ('bazfile.bin', open('bazfile').read(),
+                              'image/jpeg'),
+                'nonamefile': 'contents of nonamefile field',
+            }
+
+        When uploading a file, providing a filename (the first parameter of the
+        tuple) is optional but recommended to best mimic behavior of browsers.
+
+        Note that if ``headers`` are supplied, the 'Content-Type' header will
+        be overwritten because it depends on the dynamic random boundary string
+        which is used to compose the body of the request. The random boundary
+        string can be explicitly set with the ``multipart_boundary`` parameter.
+        """
+        if headers is None:
+            headers = self.headers
+
+        extra_kw = {"headers": {}}
+
+        if fields:
+            if "body" in urlopen_kw:
+                raise TypeError(
+                    "request got values for both 'fields' and 'body', can only specify one."
+                )
+
+            if encode_multipart:
+                body, content_type = encode_multipart_formdata(
+                    fields, boundary=multipart_boundary
+                )
+            else:
+                body, content_type = (
+                    urlencode(fields),
+                    "application/x-www-form-urlencoded",
+                )
+
+            extra_kw["body"] = body
+            extra_kw["headers"] = {"Content-Type": content_type}
+
+        extra_kw["headers"].update(headers)
+        extra_kw.update(urlopen_kw)
+
+        return self.urlopen(method, url, **extra_kw)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/response.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/response.py
new file mode 100644
index 0000000..7dc9b93
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/response.py
@@ -0,0 +1,821 @@
+from __future__ import absolute_import
+from contextlib import contextmanager
+import zlib
+import io
+import logging
+from socket import timeout as SocketTimeout
+from socket import error as SocketError
+
+try:
+    import brotli
+except ImportError:
+    brotli = None
+
+from ._collections import HTTPHeaderDict
+from .exceptions import (
+    BodyNotHttplibCompatible,
+    ProtocolError,
+    DecodeError,
+    ReadTimeoutError,
+    ResponseNotChunked,
+    IncompleteRead,
+    InvalidHeader,
+    HTTPError,
+)
+from .packages.six import string_types as basestring, PY3
+from .packages.six.moves import http_client as httplib
+from .connection import HTTPException, BaseSSLError
+from .util.response import is_fp_closed, is_response_to_head
+
+log = logging.getLogger(__name__)
+
+
+class DeflateDecoder(object):
+    def __init__(self):
+        self._first_try = True
+        self._data = b""
+        self._obj = zlib.decompressobj()
+
+    def __getattr__(self, name):
+        return getattr(self._obj, name)
+
+    def decompress(self, data):
+        if not data:
+            return data
+
+        if not self._first_try:
+            return self._obj.decompress(data)
+
+        self._data += data
+        try:
+            decompressed = self._obj.decompress(data)
+            if decompressed:
+                self._first_try = False
+                self._data = None
+            return decompressed
+        except zlib.error:
+            self._first_try = False
+            self._obj = zlib.decompressobj(-zlib.MAX_WBITS)
+            try:
+                return self.decompress(self._data)
+            finally:
+                self._data = None
+
+
+class GzipDecoderState(object):
+
+    FIRST_MEMBER = 0
+    OTHER_MEMBERS = 1
+    SWALLOW_DATA = 2
+
+
+class GzipDecoder(object):
+    def __init__(self):
+        self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS)
+        self._state = GzipDecoderState.FIRST_MEMBER
+
+    def __getattr__(self, name):
+        return getattr(self._obj, name)
+
+    def decompress(self, data):
+        ret = bytearray()
+        if self._state == GzipDecoderState.SWALLOW_DATA or not data:
+            return bytes(ret)
+        while True:
+            try:
+                ret += self._obj.decompress(data)
+            except zlib.error:
+                previous_state = self._state
+                # Ignore data after the first error
+                self._state = GzipDecoderState.SWALLOW_DATA
+                if previous_state == GzipDecoderState.OTHER_MEMBERS:
+                    # Allow trailing garbage acceptable in other gzip clients
+                    return bytes(ret)
+                raise
+            data = self._obj.unused_data
+            if not data:
+                return bytes(ret)
+            self._state = GzipDecoderState.OTHER_MEMBERS
+            self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS)
+
+
+if brotli is not None:
+
+    class BrotliDecoder(object):
+        # Supports both 'brotlipy' and 'Brotli' packages
+        # since they share an import name. The top branches
+        # are for 'brotlipy' and bottom branches for 'Brotli'
+        def __init__(self):
+            self._obj = brotli.Decompressor()
+
+        def decompress(self, data):
+            if hasattr(self._obj, "decompress"):
+                return self._obj.decompress(data)
+            return self._obj.process(data)
+
+        def flush(self):
+            if hasattr(self._obj, "flush"):
+                return self._obj.flush()
+            return b""
+
+
+class MultiDecoder(object):
+    """
+    From RFC7231:
+        If one or more encodings have been applied to a representation, the
+        sender that applied the encodings MUST generate a Content-Encoding
+        header field that lists the content codings in the order in which
+        they were applied.
+    """
+
+    def __init__(self, modes):
+        self._decoders = [_get_decoder(m.strip()) for m in modes.split(",")]
+
+    def flush(self):
+        return self._decoders[0].flush()
+
+    def decompress(self, data):
+        for d in reversed(self._decoders):
+            data = d.decompress(data)
+        return data
+
+
+def _get_decoder(mode):
+    if "," in mode:
+        return MultiDecoder(mode)
+
+    if mode == "gzip":
+        return GzipDecoder()
+
+    if brotli is not None and mode == "br":
+        return BrotliDecoder()
+
+    return DeflateDecoder()
+
+
+class HTTPResponse(io.IOBase):
+    """
+    HTTP Response container.
+
+    Backwards-compatible to httplib's HTTPResponse but the response ``body`` is
+    loaded and decoded on-demand when the ``data`` property is accessed.  This
+    class is also compatible with the Python standard library's :mod:`io`
+    module, and can hence be treated as a readable object in the context of that
+    framework.
+
+    Extra parameters for behaviour not present in httplib.HTTPResponse:
+
+    :param preload_content:
+        If True, the response's body will be preloaded during construction.
+
+    :param decode_content:
+        If True, will attempt to decode the body based on the
+        'content-encoding' header.
+
+    :param original_response:
+        When this HTTPResponse wrapper is generated from an httplib.HTTPResponse
+        object, it's convenient to include the original for debug purposes. It's
+        otherwise unused.
+
+    :param retries:
+        The retries contains the last :class:`~urllib3.util.retry.Retry` that
+        was used during the request.
+
+    :param enforce_content_length:
+        Enforce content length checking. Body returned by server must match
+        value of Content-Length header, if present. Otherwise, raise error.
+    """
+
+    CONTENT_DECODERS = ["gzip", "deflate"]
+    if brotli is not None:
+        CONTENT_DECODERS += ["br"]
+    REDIRECT_STATUSES = [301, 302, 303, 307, 308]
+
+    def __init__(
+        self,
+        body="",
+        headers=None,
+        status=0,
+        version=0,
+        reason=None,
+        strict=0,
+        preload_content=True,
+        decode_content=True,
+        original_response=None,
+        pool=None,
+        connection=None,
+        msg=None,
+        retries=None,
+        enforce_content_length=False,
+        request_method=None,
+        request_url=None,
+        auto_close=True,
+    ):
+
+        if isinstance(headers, HTTPHeaderDict):
+            self.headers = headers
+        else:
+            self.headers = HTTPHeaderDict(headers)
+        self.status = status
+        self.version = version
+        self.reason = reason
+        self.strict = strict
+        self.decode_content = decode_content
+        self.retries = retries
+        self.enforce_content_length = enforce_content_length
+        self.auto_close = auto_close
+
+        self._decoder = None
+        self._body = None
+        self._fp = None
+        self._original_response = original_response
+        self._fp_bytes_read = 0
+        self.msg = msg
+        self._request_url = request_url
+
+        if body and isinstance(body, (basestring, bytes)):
+            self._body = body
+
+        self._pool = pool
+        self._connection = connection
+
+        if hasattr(body, "read"):
+            self._fp = body
+
+        # Are we using the chunked-style of transfer encoding?
+        self.chunked = False
+        self.chunk_left = None
+        tr_enc = self.headers.get("transfer-encoding", "").lower()
+        # Don't incur the penalty of creating a list and then discarding it
+        encodings = (enc.strip() for enc in tr_enc.split(","))
+        if "chunked" in encodings:
+            self.chunked = True
+
+        # Determine length of response
+        self.length_remaining = self._init_length(request_method)
+
+        # If requested, preload the body.
+        if preload_content and not self._body:
+            self._body = self.read(decode_content=decode_content)
+
+    def get_redirect_location(self):
+        """
+        Should we redirect and where to?
+
+        :returns: Truthy redirect location string if we got a redirect status
+            code and valid location. ``None`` if redirect status and no
+            location. ``False`` if not a redirect status code.
+        """
+        if self.status in self.REDIRECT_STATUSES:
+            return self.headers.get("location")
+
+        return False
+
+    def release_conn(self):
+        if not self._pool or not self._connection:
+            return
+
+        self._pool._put_conn(self._connection)
+        self._connection = None
+
+    def drain_conn(self):
+        """
+        Read and discard any remaining HTTP response data in the response connection.
+
+        Unread data in the HTTPResponse connection blocks the connection from being released back to the pool.
+        """
+        try:
+            self.read()
+        except (HTTPError, SocketError, BaseSSLError, HTTPException):
+            pass
+
+    @property
+    def data(self):
+        # For backwords-compat with earlier urllib3 0.4 and earlier.
+        if self._body:
+            return self._body
+
+        if self._fp:
+            return self.read(cache_content=True)
+
+    @property
+    def connection(self):
+        return self._connection
+
+    def isclosed(self):
+        return is_fp_closed(self._fp)
+
+    def tell(self):
+        """
+        Obtain the number of bytes pulled over the wire so far. May differ from
+        the amount of content returned by :meth:``HTTPResponse.read`` if bytes
+        are encoded on the wire (e.g, compressed).
+        """
+        return self._fp_bytes_read
+
+    def _init_length(self, request_method):
+        """
+        Set initial length value for Response content if available.
+        """
+        length = self.headers.get("content-length")
+
+        if length is not None:
+            if self.chunked:
+                # This Response will fail with an IncompleteRead if it can't be
+                # received as chunked. This method falls back to attempt reading
+                # the response before raising an exception.
+                log.warning(
+                    "Received response with both Content-Length and "
+                    "Transfer-Encoding set. This is expressly forbidden "
+                    "by RFC 7230 sec 3.3.2. Ignoring Content-Length and "
+                    "attempting to process response as Transfer-Encoding: "
+                    "chunked."
+                )
+                return None
+
+            try:
+                # RFC 7230 section 3.3.2 specifies multiple content lengths can
+                # be sent in a single Content-Length header
+                # (e.g. Content-Length: 42, 42). This line ensures the values
+                # are all valid ints and that as long as the `set` length is 1,
+                # all values are the same. Otherwise, the header is invalid.
+                lengths = set([int(val) for val in length.split(",")])
+                if len(lengths) > 1:
+                    raise InvalidHeader(
+                        "Content-Length contained multiple "
+                        "unmatching values (%s)" % length
+                    )
+                length = lengths.pop()
+            except ValueError:
+                length = None
+            else:
+                if length < 0:
+                    length = None
+
+        # Convert status to int for comparison
+        # In some cases, httplib returns a status of "_UNKNOWN"
+        try:
+            status = int(self.status)
+        except ValueError:
+            status = 0
+
+        # Check for responses that shouldn't include a body
+        if status in (204, 304) or 100 <= status < 200 or request_method == "HEAD":
+            length = 0
+
+        return length
+
+    def _init_decoder(self):
+        """
+        Set-up the _decoder attribute if necessary.
+        """
+        # Note: content-encoding value should be case-insensitive, per RFC 7230
+        # Section 3.2
+        content_encoding = self.headers.get("content-encoding", "").lower()
+        if self._decoder is None:
+            if content_encoding in self.CONTENT_DECODERS:
+                self._decoder = _get_decoder(content_encoding)
+            elif "," in content_encoding:
+                encodings = [
+                    e.strip()
+                    for e in content_encoding.split(",")
+                    if e.strip() in self.CONTENT_DECODERS
+                ]
+                if len(encodings):
+                    self._decoder = _get_decoder(content_encoding)
+
+    DECODER_ERROR_CLASSES = (IOError, zlib.error)
+    if brotli is not None:
+        DECODER_ERROR_CLASSES += (brotli.error,)
+
+    def _decode(self, data, decode_content, flush_decoder):
+        """
+        Decode the data passed in and potentially flush the decoder.
+        """
+        if not decode_content:
+            return data
+
+        try:
+            if self._decoder:
+                data = self._decoder.decompress(data)
+        except self.DECODER_ERROR_CLASSES as e:
+            content_encoding = self.headers.get("content-encoding", "").lower()
+            raise DecodeError(
+                "Received response with content-encoding: %s, but "
+                "failed to decode it." % content_encoding,
+                e,
+            )
+        if flush_decoder:
+            data += self._flush_decoder()
+
+        return data
+
+    def _flush_decoder(self):
+        """
+        Flushes the decoder. Should only be called if the decoder is actually
+        being used.
+        """
+        if self._decoder:
+            buf = self._decoder.decompress(b"")
+            return buf + self._decoder.flush()
+
+        return b""
+
+    @contextmanager
+    def _error_catcher(self):
+        """
+        Catch low-level python exceptions, instead re-raising urllib3
+        variants, so that low-level exceptions are not leaked in the
+        high-level api.
+
+        On exit, release the connection back to the pool.
+        """
+        clean_exit = False
+
+        try:
+            try:
+                yield
+
+            except SocketTimeout:
+                # FIXME: Ideally we'd like to include the url in the ReadTimeoutError but
+                # there is yet no clean way to get at it from this context.
+                raise ReadTimeoutError(self._pool, None, "Read timed out.")
+
+            except BaseSSLError as e:
+                # FIXME: Is there a better way to differentiate between SSLErrors?
+                if "read operation timed out" not in str(e):  # Defensive:
+                    # This shouldn't happen but just in case we're missing an edge
+                    # case, let's avoid swallowing SSL errors.
+                    raise
+
+                raise ReadTimeoutError(self._pool, None, "Read timed out.")
+
+            except (HTTPException, SocketError) as e:
+                # This includes IncompleteRead.
+                raise ProtocolError("Connection broken: %r" % e, e)
+
+            # If no exception is thrown, we should avoid cleaning up
+            # unnecessarily.
+            clean_exit = True
+        finally:
+            # If we didn't terminate cleanly, we need to throw away our
+            # connection.
+            if not clean_exit:
+                # The response may not be closed but we're not going to use it
+                # anymore so close it now to ensure that the connection is
+                # released back to the pool.
+                if self._original_response:
+                    self._original_response.close()
+
+                # Closing the response may not actually be sufficient to close
+                # everything, so if we have a hold of the connection close that
+                # too.
+                if self._connection:
+                    self._connection.close()
+
+            # If we hold the original response but it's closed now, we should
+            # return the connection back to the pool.
+            if self._original_response and self._original_response.isclosed():
+                self.release_conn()
+
+    def read(self, amt=None, decode_content=None, cache_content=False):
+        """
+        Similar to :meth:`httplib.HTTPResponse.read`, but with two additional
+        parameters: ``decode_content`` and ``cache_content``.
+
+        :param amt:
+            How much of the content to read. If specified, caching is skipped
+            because it doesn't make sense to cache partial content as the full
+            response.
+
+        :param decode_content:
+            If True, will attempt to decode the body based on the
+            'content-encoding' header.
+
+        :param cache_content:
+            If True, will save the returned data such that the same result is
+            returned despite of the state of the underlying file object. This
+            is useful if you want the ``.data`` property to continue working
+            after having ``.read()`` the file object. (Overridden if ``amt`` is
+            set.)
+        """
+        self._init_decoder()
+        if decode_content is None:
+            decode_content = self.decode_content
+
+        if self._fp is None:
+            return
+
+        flush_decoder = False
+        fp_closed = getattr(self._fp, "closed", False)
+
+        with self._error_catcher():
+            if amt is None:
+                # cStringIO doesn't like amt=None
+                data = self._fp.read() if not fp_closed else b""
+                flush_decoder = True
+            else:
+                cache_content = False
+                data = self._fp.read(amt) if not fp_closed else b""
+                if (
+                    amt != 0 and not data
+                ):  # Platform-specific: Buggy versions of Python.
+                    # Close the connection when no data is returned
+                    #
+                    # This is redundant to what httplib/http.client _should_
+                    # already do.  However, versions of python released before
+                    # December 15, 2012 (http://bugs.python.org/issue16298) do
+                    # not properly close the connection in all cases. There is
+                    # no harm in redundantly calling close.
+                    self._fp.close()
+                    flush_decoder = True
+                    if self.enforce_content_length and self.length_remaining not in (
+                        0,
+                        None,
+                    ):
+                        # This is an edge case that httplib failed to cover due
+                        # to concerns of backward compatibility. We're
+                        # addressing it here to make sure IncompleteRead is
+                        # raised during streaming, so all calls with incorrect
+                        # Content-Length are caught.
+                        raise IncompleteRead(self._fp_bytes_read, self.length_remaining)
+
+        if data:
+            self._fp_bytes_read += len(data)
+            if self.length_remaining is not None:
+                self.length_remaining -= len(data)
+
+            data = self._decode(data, decode_content, flush_decoder)
+
+            if cache_content:
+                self._body = data
+
+        return data
+
+    def stream(self, amt=2 ** 16, decode_content=None):
+        """
+        A generator wrapper for the read() method. A call will block until
+        ``amt`` bytes have been read from the connection or until the
+        connection is closed.
+
+        :param amt:
+            How much of the content to read. The generator will return up to
+            much data per iteration, but may return less. This is particularly
+            likely when using compressed data. However, the empty string will
+            never be returned.
+
+        :param decode_content:
+            If True, will attempt to decode the body based on the
+            'content-encoding' header.
+        """
+        if self.chunked and self.supports_chunked_reads():
+            for line in self.read_chunked(amt, decode_content=decode_content):
+                yield line
+        else:
+            while not is_fp_closed(self._fp):
+                data = self.read(amt=amt, decode_content=decode_content)
+
+                if data:
+                    yield data
+
+    @classmethod
+    def from_httplib(ResponseCls, r, **response_kw):
+        """
+        Given an :class:`httplib.HTTPResponse` instance ``r``, return a
+        corresponding :class:`urllib3.response.HTTPResponse` object.
+
+        Remaining parameters are passed to the HTTPResponse constructor, along
+        with ``original_response=r``.
+        """
+        headers = r.msg
+
+        if not isinstance(headers, HTTPHeaderDict):
+            if PY3:
+                headers = HTTPHeaderDict(headers.items())
+            else:
+                # Python 2.7
+                headers = HTTPHeaderDict.from_httplib(headers)
+
+        # HTTPResponse objects in Python 3 don't have a .strict attribute
+        strict = getattr(r, "strict", 0)
+        resp = ResponseCls(
+            body=r,
+            headers=headers,
+            status=r.status,
+            version=r.version,
+            reason=r.reason,
+            strict=strict,
+            original_response=r,
+            **response_kw
+        )
+        return resp
+
+    # Backwards-compatibility methods for httplib.HTTPResponse
+    def getheaders(self):
+        return self.headers
+
+    def getheader(self, name, default=None):
+        return self.headers.get(name, default)
+
+    # Backwards compatibility for http.cookiejar
+    def info(self):
+        return self.headers
+
+    # Overrides from io.IOBase
+    def close(self):
+        if not self.closed:
+            self._fp.close()
+
+        if self._connection:
+            self._connection.close()
+
+        if not self.auto_close:
+            io.IOBase.close(self)
+
+    @property
+    def closed(self):
+        if not self.auto_close:
+            return io.IOBase.closed.__get__(self)
+        elif self._fp is None:
+            return True
+        elif hasattr(self._fp, "isclosed"):
+            return self._fp.isclosed()
+        elif hasattr(self._fp, "closed"):
+            return self._fp.closed
+        else:
+            return True
+
+    def fileno(self):
+        if self._fp is None:
+            raise IOError("HTTPResponse has no file to get a fileno from")
+        elif hasattr(self._fp, "fileno"):
+            return self._fp.fileno()
+        else:
+            raise IOError(
+                "The file-like object this HTTPResponse is wrapped "
+                "around has no file descriptor"
+            )
+
+    def flush(self):
+        if (
+            self._fp is not None
+            and hasattr(self._fp, "flush")
+            and not getattr(self._fp, "closed", False)
+        ):
+            return self._fp.flush()
+
+    def readable(self):
+        # This method is required for `io` module compatibility.
+        return True
+
+    def readinto(self, b):
+        # This method is required for `io` module compatibility.
+        temp = self.read(len(b))
+        if len(temp) == 0:
+            return 0
+        else:
+            b[: len(temp)] = temp
+            return len(temp)
+
+    def supports_chunked_reads(self):
+        """
+        Checks if the underlying file-like object looks like a
+        httplib.HTTPResponse object. We do this by testing for the fp
+        attribute. If it is present we assume it returns raw chunks as
+        processed by read_chunked().
+        """
+        return hasattr(self._fp, "fp")
+
+    def _update_chunk_length(self):
+        # First, we'll figure out length of a chunk and then
+        # we'll try to read it from socket.
+        if self.chunk_left is not None:
+            return
+        line = self._fp.fp.readline()
+        line = line.split(b";", 1)[0]
+        try:
+            self.chunk_left = int(line, 16)
+        except ValueError:
+            # Invalid chunked protocol response, abort.
+            self.close()
+            raise httplib.IncompleteRead(line)
+
+    def _handle_chunk(self, amt):
+        returned_chunk = None
+        if amt is None:
+            chunk = self._fp._safe_read(self.chunk_left)
+            returned_chunk = chunk
+            self._fp._safe_read(2)  # Toss the CRLF at the end of the chunk.
+            self.chunk_left = None
+        elif amt < self.chunk_left:
+            value = self._fp._safe_read(amt)
+            self.chunk_left = self.chunk_left - amt
+            returned_chunk = value
+        elif amt == self.chunk_left:
+            value = self._fp._safe_read(amt)
+            self._fp._safe_read(2)  # Toss the CRLF at the end of the chunk.
+            self.chunk_left = None
+            returned_chunk = value
+        else:  # amt > self.chunk_left
+            returned_chunk = self._fp._safe_read(self.chunk_left)
+            self._fp._safe_read(2)  # Toss the CRLF at the end of the chunk.
+            self.chunk_left = None
+        return returned_chunk
+
+    def read_chunked(self, amt=None, decode_content=None):
+        """
+        Similar to :meth:`HTTPResponse.read`, but with an additional
+        parameter: ``decode_content``.
+
+        :param amt:
+            How much of the content to read. If specified, caching is skipped
+            because it doesn't make sense to cache partial content as the full
+            response.
+
+        :param decode_content:
+            If True, will attempt to decode the body based on the
+            'content-encoding' header.
+        """
+        self._init_decoder()
+        # FIXME: Rewrite this method and make it a class with a better structured logic.
+        if not self.chunked:
+            raise ResponseNotChunked(
+                "Response is not chunked. "
+                "Header 'transfer-encoding: chunked' is missing."
+            )
+        if not self.supports_chunked_reads():
+            raise BodyNotHttplibCompatible(
+                "Body should be httplib.HTTPResponse like. "
+                "It should have have an fp attribute which returns raw chunks."
+            )
+
+        with self._error_catcher():
+            # Don't bother reading the body of a HEAD request.
+            if self._original_response and is_response_to_head(self._original_response):
+                self._original_response.close()
+                return
+
+            # If a response is already read and closed
+            # then return immediately.
+            if self._fp.fp is None:
+                return
+
+            while True:
+                self._update_chunk_length()
+                if self.chunk_left == 0:
+                    break
+                chunk = self._handle_chunk(amt)
+                decoded = self._decode(
+                    chunk, decode_content=decode_content, flush_decoder=False
+                )
+                if decoded:
+                    yield decoded
+
+            if decode_content:
+                # On CPython and PyPy, we should never need to flush the
+                # decoder. However, on Jython we *might* need to, so
+                # lets defensively do it anyway.
+                decoded = self._flush_decoder()
+                if decoded:  # Platform-specific: Jython.
+                    yield decoded
+
+            # Chunk content ends with \r\n: discard it.
+            while True:
+                line = self._fp.fp.readline()
+                if not line:
+                    # Some sites may not end with '\r\n'.
+                    break
+                if line == b"\r\n":
+                    break
+
+            # We read everything; close the "file".
+            if self._original_response:
+                self._original_response.close()
+
+    def geturl(self):
+        """
+        Returns the URL that was the source of this response.
+        If the request that generated this response redirected, this method
+        will return the final redirect location.
+        """
+        if self.retries is not None and len(self.retries.history):
+            return self.retries.history[-1].redirect_location
+        else:
+            return self._request_url
+
+    def __iter__(self):
+        buffer = []
+        for chunk in self.stream(decode_content=True):
+            if b"\n" in chunk:
+                chunk = chunk.split(b"\n")
+                yield b"".join(buffer) + chunk[0] + b"\n"
+                for x in chunk[1:-1]:
+                    yield x + b"\n"
+                if chunk[-1]:
+                    buffer = [chunk[-1]]
+                else:
+                    buffer = []
+            else:
+                buffer.append(chunk)
+        if buffer:
+            yield b"".join(buffer)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/__init__.py
new file mode 100644
index 0000000..a96c73a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/__init__.py
@@ -0,0 +1,46 @@
+from __future__ import absolute_import
+
+# For backwards compatibility, provide imports that used to be here.
+from .connection import is_connection_dropped
+from .request import make_headers
+from .response import is_fp_closed
+from .ssl_ import (
+    SSLContext,
+    HAS_SNI,
+    IS_PYOPENSSL,
+    IS_SECURETRANSPORT,
+    assert_fingerprint,
+    resolve_cert_reqs,
+    resolve_ssl_version,
+    ssl_wrap_socket,
+    PROTOCOL_TLS,
+)
+from .timeout import current_time, Timeout
+
+from .retry import Retry
+from .url import get_host, parse_url, split_first, Url
+from .wait import wait_for_read, wait_for_write
+
+__all__ = (
+    "HAS_SNI",
+    "IS_PYOPENSSL",
+    "IS_SECURETRANSPORT",
+    "SSLContext",
+    "PROTOCOL_TLS",
+    "Retry",
+    "Timeout",
+    "Url",
+    "assert_fingerprint",
+    "current_time",
+    "is_connection_dropped",
+    "is_fp_closed",
+    "get_host",
+    "parse_url",
+    "make_headers",
+    "resolve_cert_reqs",
+    "resolve_ssl_version",
+    "split_first",
+    "ssl_wrap_socket",
+    "wait_for_read",
+    "wait_for_write",
+)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/connection.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/connection.py
new file mode 100644
index 0000000..86f0a3b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/connection.py
@@ -0,0 +1,138 @@
+from __future__ import absolute_import
+import socket
+from .wait import NoWayToWaitForSocketError, wait_for_read
+from ..contrib import _appengine_environ
+
+
+def is_connection_dropped(conn):  # Platform-specific
+    """
+    Returns True if the connection is dropped and should be closed.
+
+    :param conn:
+        :class:`httplib.HTTPConnection` object.
+
+    Note: For platforms like AppEngine, this will always return ``False`` to
+    let the platform handle connection recycling transparently for us.
+    """
+    sock = getattr(conn, "sock", False)
+    if sock is False:  # Platform-specific: AppEngine
+        return False
+    if sock is None:  # Connection already closed (such as by httplib).
+        return True
+    try:
+        # Returns True if readable, which here means it's been dropped
+        return wait_for_read(sock, timeout=0.0)
+    except NoWayToWaitForSocketError:  # Platform-specific: AppEngine
+        return False
+
+
+# This function is copied from socket.py in the Python 2.7 standard
+# library test suite. Added to its signature is only `socket_options`.
+# One additional modification is that we avoid binding to IPv6 servers
+# discovered in DNS if the system doesn't have IPv6 functionality.
+def create_connection(
+    address,
+    timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
+    source_address=None,
+    socket_options=None,
+):
+    """Connect to *address* and return the socket object.
+
+    Convenience function.  Connect to *address* (a 2-tuple ``(host,
+    port)``) and return the socket object.  Passing the optional
+    *timeout* parameter will set the timeout on the socket instance
+    before attempting to connect.  If no *timeout* is supplied, the
+    global default timeout setting returned by :func:`getdefaulttimeout`
+    is used.  If *source_address* is set it must be a tuple of (host, port)
+    for the socket to bind as a source address before making the connection.
+    An host of '' or port 0 tells the OS to use the default.
+    """
+
+    host, port = address
+    if host.startswith("["):
+        host = host.strip("[]")
+    err = None
+
+    # Using the value from allowed_gai_family() in the context of getaddrinfo lets
+    # us select whether to work with IPv4 DNS records, IPv6 records, or both.
+    # The original create_connection function always returns all records.
+    family = allowed_gai_family()
+
+    for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM):
+        af, socktype, proto, canonname, sa = res
+        sock = None
+        try:
+            sock = socket.socket(af, socktype, proto)
+
+            # If provided, set socket level options before connecting.
+            _set_socket_options(sock, socket_options)
+
+            if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:
+                sock.settimeout(timeout)
+            if source_address:
+                sock.bind(source_address)
+            sock.connect(sa)
+            return sock
+
+        except socket.error as e:
+            err = e
+            if sock is not None:
+                sock.close()
+                sock = None
+
+    if err is not None:
+        raise err
+
+    raise socket.error("getaddrinfo returns an empty list")
+
+
+def _set_socket_options(sock, options):
+    if options is None:
+        return
+
+    for opt in options:
+        sock.setsockopt(*opt)
+
+
+def allowed_gai_family():
+    """This function is designed to work in the context of
+    getaddrinfo, where family=socket.AF_UNSPEC is the default and
+    will perform a DNS search for both IPv6 and IPv4 records."""
+
+    family = socket.AF_INET
+    if HAS_IPV6:
+        family = socket.AF_UNSPEC
+    return family
+
+
+def _has_ipv6(host):
+    """ Returns True if the system can bind an IPv6 address. """
+    sock = None
+    has_ipv6 = False
+
+    # App Engine doesn't support IPV6 sockets and actually has a quota on the
+    # number of sockets that can be used, so just early out here instead of
+    # creating a socket needlessly.
+    # See https://github.com/urllib3/urllib3/issues/1446
+    if _appengine_environ.is_appengine_sandbox():
+        return False
+
+    if socket.has_ipv6:
+        # has_ipv6 returns true if cPython was compiled with IPv6 support.
+        # It does not tell us if the system has IPv6 support enabled. To
+        # determine that we must bind to an IPv6 address.
+        # https://github.com/urllib3/urllib3/pull/611
+        # https://bugs.python.org/issue658327
+        try:
+            sock = socket.socket(socket.AF_INET6)
+            sock.bind((host, 0))
+            has_ipv6 = True
+        except Exception:
+            pass
+
+    if sock:
+        sock.close()
+    return has_ipv6
+
+
+HAS_IPV6 = _has_ipv6("::1")
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/queue.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/queue.py
new file mode 100644
index 0000000..d3d379a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/queue.py
@@ -0,0 +1,21 @@
+import collections
+from ..packages import six
+from ..packages.six.moves import queue
+
+if six.PY2:
+    # Queue is imported for side effects on MS Windows. See issue #229.
+    import Queue as _unused_module_Queue  # noqa: F401
+
+
+class LifoQueue(queue.Queue):
+    def _init(self, _):
+        self.queue = collections.deque()
+
+    def _qsize(self, len=len):
+        return len(self.queue)
+
+    def _put(self, item):
+        self.queue.append(item)
+
+    def _get(self):
+        return self.queue.pop()
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/request.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/request.py
new file mode 100644
index 0000000..3b7bb54
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/request.py
@@ -0,0 +1,135 @@
+from __future__ import absolute_import
+from base64 import b64encode
+
+from ..packages.six import b, integer_types
+from ..exceptions import UnrewindableBodyError
+
+ACCEPT_ENCODING = "gzip,deflate"
+try:
+    import brotli as _unused_module_brotli  # noqa: F401
+except ImportError:
+    pass
+else:
+    ACCEPT_ENCODING += ",br"
+
+_FAILEDTELL = object()
+
+
+def make_headers(
+    keep_alive=None,
+    accept_encoding=None,
+    user_agent=None,
+    basic_auth=None,
+    proxy_basic_auth=None,
+    disable_cache=None,
+):
+    """
+    Shortcuts for generating request headers.
+
+    :param keep_alive:
+        If ``True``, adds 'connection: keep-alive' header.
+
+    :param accept_encoding:
+        Can be a boolean, list, or string.
+        ``True`` translates to 'gzip,deflate'.
+        List will get joined by comma.
+        String will be used as provided.
+
+    :param user_agent:
+        String representing the user-agent you want, such as
+        "python-urllib3/0.6"
+
+    :param basic_auth:
+        Colon-separated username:password string for 'authorization: basic ...'
+        auth header.
+
+    :param proxy_basic_auth:
+        Colon-separated username:password string for 'proxy-authorization: basic ...'
+        auth header.
+
+    :param disable_cache:
+        If ``True``, adds 'cache-control: no-cache' header.
+
+    Example::
+
+        >>> make_headers(keep_alive=True, user_agent="Batman/1.0")
+        {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}
+        >>> make_headers(accept_encoding=True)
+        {'accept-encoding': 'gzip,deflate'}
+    """
+    headers = {}
+    if accept_encoding:
+        if isinstance(accept_encoding, str):
+            pass
+        elif isinstance(accept_encoding, list):
+            accept_encoding = ",".join(accept_encoding)
+        else:
+            accept_encoding = ACCEPT_ENCODING
+        headers["accept-encoding"] = accept_encoding
+
+    if user_agent:
+        headers["user-agent"] = user_agent
+
+    if keep_alive:
+        headers["connection"] = "keep-alive"
+
+    if basic_auth:
+        headers["authorization"] = "Basic " + b64encode(b(basic_auth)).decode("utf-8")
+
+    if proxy_basic_auth:
+        headers["proxy-authorization"] = "Basic " + b64encode(
+            b(proxy_basic_auth)
+        ).decode("utf-8")
+
+    if disable_cache:
+        headers["cache-control"] = "no-cache"
+
+    return headers
+
+
+def set_file_position(body, pos):
+    """
+    If a position is provided, move file to that point.
+    Otherwise, we'll attempt to record a position for future use.
+    """
+    if pos is not None:
+        rewind_body(body, pos)
+    elif getattr(body, "tell", None) is not None:
+        try:
+            pos = body.tell()
+        except (IOError, OSError):
+            # This differentiates from None, allowing us to catch
+            # a failed `tell()` later when trying to rewind the body.
+            pos = _FAILEDTELL
+
+    return pos
+
+
+def rewind_body(body, body_pos):
+    """
+    Attempt to rewind body to a certain position.
+    Primarily used for request redirects and retries.
+
+    :param body:
+        File-like object that supports seek.
+
+    :param int pos:
+        Position to seek to in file.
+    """
+    body_seek = getattr(body, "seek", None)
+    if body_seek is not None and isinstance(body_pos, integer_types):
+        try:
+            body_seek(body_pos)
+        except (IOError, OSError):
+            raise UnrewindableBodyError(
+                "An error occurred when rewinding request body for redirect/retry."
+            )
+    elif body_pos is _FAILEDTELL:
+        raise UnrewindableBodyError(
+            "Unable to record file position for rewinding "
+            "request body during a redirect/retry."
+        )
+    else:
+        raise ValueError(
+            "body_pos must be of type integer, instead it was %s." % type(body_pos)
+        )
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/response.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/response.py
new file mode 100644
index 0000000..715868d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/response.py
@@ -0,0 +1,86 @@
+from __future__ import absolute_import
+from ..packages.six.moves import http_client as httplib
+
+from ..exceptions import HeaderParsingError
+
+
+def is_fp_closed(obj):
+    """
+    Checks whether a given file-like object is closed.
+
+    :param obj:
+        The file-like object to check.
+    """
+
+    try:
+        # Check `isclosed()` first, in case Python3 doesn't set `closed`.
+        # GH Issue #928
+        return obj.isclosed()
+    except AttributeError:
+        pass
+
+    try:
+        # Check via the official file-like-object way.
+        return obj.closed
+    except AttributeError:
+        pass
+
+    try:
+        # Check if the object is a container for another file-like object that
+        # gets released on exhaustion (e.g. HTTPResponse).
+        return obj.fp is None
+    except AttributeError:
+        pass
+
+    raise ValueError("Unable to determine whether fp is closed.")
+
+
+def assert_header_parsing(headers):
+    """
+    Asserts whether all headers have been successfully parsed.
+    Extracts encountered errors from the result of parsing headers.
+
+    Only works on Python 3.
+
+    :param headers: Headers to verify.
+    :type headers: `httplib.HTTPMessage`.
+
+    :raises urllib3.exceptions.HeaderParsingError:
+        If parsing errors are found.
+    """
+
+    # This will fail silently if we pass in the wrong kind of parameter.
+    # To make debugging easier add an explicit check.
+    if not isinstance(headers, httplib.HTTPMessage):
+        raise TypeError("expected httplib.Message, got {0}.".format(type(headers)))
+
+    defects = getattr(headers, "defects", None)
+    get_payload = getattr(headers, "get_payload", None)
+
+    unparsed_data = None
+    if get_payload:
+        # get_payload is actually email.message.Message.get_payload;
+        # we're only interested in the result if it's not a multipart message
+        if not headers.is_multipart():
+            payload = get_payload()
+
+            if isinstance(payload, (bytes, str)):
+                unparsed_data = payload
+
+    if defects or unparsed_data:
+        raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data)
+
+
+def is_response_to_head(response):
+    """
+    Checks whether the request of a response has been a HEAD-request.
+    Handles the quirks of AppEngine.
+
+    :param conn:
+    :type conn: :class:`httplib.HTTPResponse`
+    """
+    # FIXME: Can we do this somehow without accessing private httplib _method?
+    method = response._method
+    if isinstance(method, int):  # Platform-specific: Appengine
+        return method == 3
+    return method.upper() == "HEAD"
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/retry.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/retry.py
new file mode 100644
index 0000000..ee30c91
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/retry.py
@@ -0,0 +1,453 @@
+from __future__ import absolute_import
+import time
+import logging
+from collections import namedtuple
+from itertools import takewhile
+import email
+import re
+
+from ..exceptions import (
+    ConnectTimeoutError,
+    MaxRetryError,
+    ProtocolError,
+    ReadTimeoutError,
+    ResponseError,
+    InvalidHeader,
+    ProxyError,
+)
+from ..packages import six
+
+
+log = logging.getLogger(__name__)
+
+
+# Data structure for representing the metadata of requests that result in a retry.
+RequestHistory = namedtuple(
+    "RequestHistory", ["method", "url", "error", "status", "redirect_location"]
+)
+
+
+class Retry(object):
+    """ Retry configuration.
+
+    Each retry attempt will create a new Retry object with updated values, so
+    they can be safely reused.
+
+    Retries can be defined as a default for a pool::
+
+        retries = Retry(connect=5, read=2, redirect=5)
+        http = PoolManager(retries=retries)
+        response = http.request('GET', 'http://example.com/')
+
+    Or per-request (which overrides the default for the pool)::
+
+        response = http.request('GET', 'http://example.com/', retries=Retry(10))
+
+    Retries can be disabled by passing ``False``::
+
+        response = http.request('GET', 'http://example.com/', retries=False)
+
+    Errors will be wrapped in :class:`~urllib3.exceptions.MaxRetryError` unless
+    retries are disabled, in which case the causing exception will be raised.
+
+    :param int total:
+        Total number of retries to allow. Takes precedence over other counts.
+
+        Set to ``None`` to remove this constraint and fall back on other
+        counts. It's a good idea to set this to some sensibly-high value to
+        account for unexpected edge cases and avoid infinite retry loops.
+
+        Set to ``0`` to fail on the first retry.
+
+        Set to ``False`` to disable and imply ``raise_on_redirect=False``.
+
+    :param int connect:
+        How many connection-related errors to retry on.
+
+        These are errors raised before the request is sent to the remote server,
+        which we assume has not triggered the server to process the request.
+
+        Set to ``0`` to fail on the first retry of this type.
+
+    :param int read:
+        How many times to retry on read errors.
+
+        These errors are raised after the request was sent to the server, so the
+        request may have side-effects.
+
+        Set to ``0`` to fail on the first retry of this type.
+
+    :param int redirect:
+        How many redirects to perform. Limit this to avoid infinite redirect
+        loops.
+
+        A redirect is a HTTP response with a status code 301, 302, 303, 307 or
+        308.
+
+        Set to ``0`` to fail on the first retry of this type.
+
+        Set to ``False`` to disable and imply ``raise_on_redirect=False``.
+
+    :param int status:
+        How many times to retry on bad status codes.
+
+        These are retries made on responses, where status code matches
+        ``status_forcelist``.
+
+        Set to ``0`` to fail on the first retry of this type.
+
+    :param iterable method_whitelist:
+        Set of uppercased HTTP method verbs that we should retry on.
+
+        By default, we only retry on methods which are considered to be
+        idempotent (multiple requests with the same parameters end with the
+        same state). See :attr:`Retry.DEFAULT_METHOD_WHITELIST`.
+
+        Set to a ``False`` value to retry on any verb.
+
+    :param iterable status_forcelist:
+        A set of integer HTTP status codes that we should force a retry on.
+        A retry is initiated if the request method is in ``method_whitelist``
+        and the response status code is in ``status_forcelist``.
+
+        By default, this is disabled with ``None``.
+
+    :param float backoff_factor:
+        A backoff factor to apply between attempts after the second try
+        (most errors are resolved immediately by a second try without a
+        delay). urllib3 will sleep for::
+
+            {backoff factor} * (2 ** ({number of total retries} - 1))
+
+        seconds. If the backoff_factor is 0.1, then :func:`.sleep` will sleep
+        for [0.0s, 0.2s, 0.4s, ...] between retries. It will never be longer
+        than :attr:`Retry.BACKOFF_MAX`.
+
+        By default, backoff is disabled (set to 0).
+
+    :param bool raise_on_redirect: Whether, if the number of redirects is
+        exhausted, to raise a MaxRetryError, or to return a response with a
+        response code in the 3xx range.
+
+    :param bool raise_on_status: Similar meaning to ``raise_on_redirect``:
+        whether we should raise an exception, or return a response,
+        if status falls in ``status_forcelist`` range and retries have
+        been exhausted.
+
+    :param tuple history: The history of the request encountered during
+        each call to :meth:`~Retry.increment`. The list is in the order
+        the requests occurred. Each list item is of class :class:`RequestHistory`.
+
+    :param bool respect_retry_after_header:
+        Whether to respect Retry-After header on status codes defined as
+        :attr:`Retry.RETRY_AFTER_STATUS_CODES` or not.
+
+    :param iterable remove_headers_on_redirect:
+        Sequence of headers to remove from the request when a response
+        indicating a redirect is returned before firing off the redirected
+        request.
+    """
+
+    DEFAULT_METHOD_WHITELIST = frozenset(
+        ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"]
+    )
+
+    RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503])
+
+    DEFAULT_REDIRECT_HEADERS_BLACKLIST = frozenset(["Authorization"])
+
+    #: Maximum backoff time.
+    BACKOFF_MAX = 120
+
+    def __init__(
+        self,
+        total=10,
+        connect=None,
+        read=None,
+        redirect=None,
+        status=None,
+        method_whitelist=DEFAULT_METHOD_WHITELIST,
+        status_forcelist=None,
+        backoff_factor=0,
+        raise_on_redirect=True,
+        raise_on_status=True,
+        history=None,
+        respect_retry_after_header=True,
+        remove_headers_on_redirect=DEFAULT_REDIRECT_HEADERS_BLACKLIST,
+    ):
+
+        self.total = total
+        self.connect = connect
+        self.read = read
+        self.status = status
+
+        if redirect is False or total is False:
+            redirect = 0
+            raise_on_redirect = False
+
+        self.redirect = redirect
+        self.status_forcelist = status_forcelist or set()
+        self.method_whitelist = method_whitelist
+        self.backoff_factor = backoff_factor
+        self.raise_on_redirect = raise_on_redirect
+        self.raise_on_status = raise_on_status
+        self.history = history or tuple()
+        self.respect_retry_after_header = respect_retry_after_header
+        self.remove_headers_on_redirect = frozenset(
+            [h.lower() for h in remove_headers_on_redirect]
+        )
+
+    def new(self, **kw):
+        params = dict(
+            total=self.total,
+            connect=self.connect,
+            read=self.read,
+            redirect=self.redirect,
+            status=self.status,
+            method_whitelist=self.method_whitelist,
+            status_forcelist=self.status_forcelist,
+            backoff_factor=self.backoff_factor,
+            raise_on_redirect=self.raise_on_redirect,
+            raise_on_status=self.raise_on_status,
+            history=self.history,
+            remove_headers_on_redirect=self.remove_headers_on_redirect,
+            respect_retry_after_header=self.respect_retry_after_header,
+        )
+        params.update(kw)
+        return type(self)(**params)
+
+    @classmethod
+    def from_int(cls, retries, redirect=True, default=None):
+        """ Backwards-compatibility for the old retries format."""
+        if retries is None:
+            retries = default if default is not None else cls.DEFAULT
+
+        if isinstance(retries, Retry):
+            return retries
+
+        redirect = bool(redirect) and None
+        new_retries = cls(retries, redirect=redirect)
+        log.debug("Converted retries value: %r -> %r", retries, new_retries)
+        return new_retries
+
+    def get_backoff_time(self):
+        """ Formula for computing the current backoff
+
+        :rtype: float
+        """
+        # We want to consider only the last consecutive errors sequence (Ignore redirects).
+        consecutive_errors_len = len(
+            list(
+                takewhile(lambda x: x.redirect_location is None, reversed(self.history))
+            )
+        )
+        if consecutive_errors_len <= 1:
+            return 0
+
+        backoff_value = self.backoff_factor * (2 ** (consecutive_errors_len - 1))
+        return min(self.BACKOFF_MAX, backoff_value)
+
+    def parse_retry_after(self, retry_after):
+        # Whitespace: https://tools.ietf.org/html/rfc7230#section-3.2.4
+        if re.match(r"^\s*[0-9]+\s*$", retry_after):
+            seconds = int(retry_after)
+        else:
+            retry_date_tuple = email.utils.parsedate(retry_after)
+            if retry_date_tuple is None:
+                raise InvalidHeader("Invalid Retry-After header: %s" % retry_after)
+            retry_date = time.mktime(retry_date_tuple)
+            seconds = retry_date - time.time()
+
+        if seconds < 0:
+            seconds = 0
+
+        return seconds
+
+    def get_retry_after(self, response):
+        """ Get the value of Retry-After in seconds. """
+
+        retry_after = response.getheader("Retry-After")
+
+        if retry_after is None:
+            return None
+
+        return self.parse_retry_after(retry_after)
+
+    def sleep_for_retry(self, response=None):
+        retry_after = self.get_retry_after(response)
+        if retry_after:
+            time.sleep(retry_after)
+            return True
+
+        return False
+
+    def _sleep_backoff(self):
+        backoff = self.get_backoff_time()
+        if backoff <= 0:
+            return
+        time.sleep(backoff)
+
+    def sleep(self, response=None):
+        """ Sleep between retry attempts.
+
+        This method will respect a server's ``Retry-After`` response header
+        and sleep the duration of the time requested. If that is not present, it
+        will use an exponential backoff. By default, the backoff factor is 0 and
+        this method will return immediately.
+        """
+
+        if self.respect_retry_after_header and response:
+            slept = self.sleep_for_retry(response)
+            if slept:
+                return
+
+        self._sleep_backoff()
+
+    def _is_connection_error(self, err):
+        """ Errors when we're fairly sure that the server did not receive the
+        request, so it should be safe to retry.
+        """
+        if isinstance(err, ProxyError):
+            err = err.original_error
+        return isinstance(err, ConnectTimeoutError)
+
+    def _is_read_error(self, err):
+        """ Errors that occur after the request has been started, so we should
+        assume that the server began processing it.
+        """
+        return isinstance(err, (ReadTimeoutError, ProtocolError))
+
+    def _is_method_retryable(self, method):
+        """ Checks if a given HTTP method should be retried upon, depending if
+        it is included on the method whitelist.
+        """
+        if self.method_whitelist and method.upper() not in self.method_whitelist:
+            return False
+
+        return True
+
+    def is_retry(self, method, status_code, has_retry_after=False):
+        """ Is this method/status code retryable? (Based on whitelists and control
+        variables such as the number of total retries to allow, whether to
+        respect the Retry-After header, whether this header is present, and
+        whether the returned status code is on the list of status codes to
+        be retried upon on the presence of the aforementioned header)
+        """
+        if not self._is_method_retryable(method):
+            return False
+
+        if self.status_forcelist and status_code in self.status_forcelist:
+            return True
+
+        return (
+            self.total
+            and self.respect_retry_after_header
+            and has_retry_after
+            and (status_code in self.RETRY_AFTER_STATUS_CODES)
+        )
+
+    def is_exhausted(self):
+        """ Are we out of retries? """
+        retry_counts = (self.total, self.connect, self.read, self.redirect, self.status)
+        retry_counts = list(filter(None, retry_counts))
+        if not retry_counts:
+            return False
+
+        return min(retry_counts) < 0
+
+    def increment(
+        self,
+        method=None,
+        url=None,
+        response=None,
+        error=None,
+        _pool=None,
+        _stacktrace=None,
+    ):
+        """ Return a new Retry object with incremented retry counters.
+
+        :param response: A response object, or None, if the server did not
+            return a response.
+        :type response: :class:`~urllib3.response.HTTPResponse`
+        :param Exception error: An error encountered during the request, or
+            None if the response was received successfully.
+
+        :return: A new ``Retry`` object.
+        """
+        if self.total is False and error:
+            # Disabled, indicate to re-raise the error.
+            raise six.reraise(type(error), error, _stacktrace)
+
+        total = self.total
+        if total is not None:
+            total -= 1
+
+        connect = self.connect
+        read = self.read
+        redirect = self.redirect
+        status_count = self.status
+        cause = "unknown"
+        status = None
+        redirect_location = None
+
+        if error and self._is_connection_error(error):
+            # Connect retry?
+            if connect is False:
+                raise six.reraise(type(error), error, _stacktrace)
+            elif connect is not None:
+                connect -= 1
+
+        elif error and self._is_read_error(error):
+            # Read retry?
+            if read is False or not self._is_method_retryable(method):
+                raise six.reraise(type(error), error, _stacktrace)
+            elif read is not None:
+                read -= 1
+
+        elif response and response.get_redirect_location():
+            # Redirect retry?
+            if redirect is not None:
+                redirect -= 1
+            cause = "too many redirects"
+            redirect_location = response.get_redirect_location()
+            status = response.status
+
+        else:
+            # Incrementing because of a server error like a 500 in
+            # status_forcelist and a the given method is in the whitelist
+            cause = ResponseError.GENERIC_ERROR
+            if response and response.status:
+                if status_count is not None:
+                    status_count -= 1
+                cause = ResponseError.SPECIFIC_ERROR.format(status_code=response.status)
+                status = response.status
+
+        history = self.history + (
+            RequestHistory(method, url, error, status, redirect_location),
+        )
+
+        new_retry = self.new(
+            total=total,
+            connect=connect,
+            read=read,
+            redirect=redirect,
+            status=status_count,
+            history=history,
+        )
+
+        if new_retry.is_exhausted():
+            raise MaxRetryError(_pool, url, error or ResponseError(cause))
+
+        log.debug("Incremented Retry for (url='%s'): %r", url, new_retry)
+
+        return new_retry
+
+    def __repr__(self):
+        return (
+            "{cls.__name__}(total={self.total}, connect={self.connect}, "
+            "read={self.read}, redirect={self.redirect}, status={self.status})"
+        ).format(cls=type(self), self=self)
+
+
+# For backwards compatibility (equivalent to pre-v1.9):
+Retry.DEFAULT = Retry(3)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/ssl_.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/ssl_.py
new file mode 100644
index 0000000..d3b463d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/ssl_.py
@@ -0,0 +1,414 @@
+from __future__ import absolute_import
+import errno
+import warnings
+import hmac
+import sys
+
+from binascii import hexlify, unhexlify
+from hashlib import md5, sha1, sha256
+
+from .url import IPV4_RE, BRACELESS_IPV6_ADDRZ_RE
+from ..exceptions import SSLError, InsecurePlatformWarning, SNIMissingWarning
+from ..packages import six
+
+
+SSLContext = None
+HAS_SNI = False
+IS_PYOPENSSL = False
+IS_SECURETRANSPORT = False
+
+# Maps the length of a digest to a possible hash function producing this digest
+HASHFUNC_MAP = {32: md5, 40: sha1, 64: sha256}
+
+
+def _const_compare_digest_backport(a, b):
+    """
+    Compare two digests of equal length in constant time.
+
+    The digests must be of type str/bytes.
+    Returns True if the digests match, and False otherwise.
+    """
+    result = abs(len(a) - len(b))
+    for l, r in zip(bytearray(a), bytearray(b)):
+        result |= l ^ r
+    return result == 0
+
+
+_const_compare_digest = getattr(hmac, "compare_digest", _const_compare_digest_backport)
+
+try:  # Test for SSL features
+    import ssl
+    from ssl import wrap_socket, CERT_REQUIRED
+    from ssl import HAS_SNI  # Has SNI?
+except ImportError:
+    pass
+
+try:  # Platform-specific: Python 3.6
+    from ssl import PROTOCOL_TLS
+
+    PROTOCOL_SSLv23 = PROTOCOL_TLS
+except ImportError:
+    try:
+        from ssl import PROTOCOL_SSLv23 as PROTOCOL_TLS
+
+        PROTOCOL_SSLv23 = PROTOCOL_TLS
+    except ImportError:
+        PROTOCOL_SSLv23 = PROTOCOL_TLS = 2
+
+
+try:
+    from ssl import OP_NO_SSLv2, OP_NO_SSLv3, OP_NO_COMPRESSION
+except ImportError:
+    OP_NO_SSLv2, OP_NO_SSLv3 = 0x1000000, 0x2000000
+    OP_NO_COMPRESSION = 0x20000
+
+
+# A secure default.
+# Sources for more information on TLS ciphers:
+#
+# - https://wiki.mozilla.org/Security/Server_Side_TLS
+# - https://www.ssllabs.com/projects/best-practices/index.html
+# - https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/
+#
+# The general intent is:
+# - prefer cipher suites that offer perfect forward secrecy (DHE/ECDHE),
+# - prefer ECDHE over DHE for better performance,
+# - prefer any AES-GCM and ChaCha20 over any AES-CBC for better performance and
+#   security,
+# - prefer AES-GCM over ChaCha20 because hardware-accelerated AES is common,
+# - disable NULL authentication, MD5 MACs, DSS, and other
+#   insecure ciphers for security reasons.
+# - NOTE: TLS 1.3 cipher suites are managed through a different interface
+#   not exposed by CPython (yet!) and are enabled by default if they're available.
+DEFAULT_CIPHERS = ":".join(
+    [
+        "ECDHE+AESGCM",
+        "ECDHE+CHACHA20",
+        "DHE+AESGCM",
+        "DHE+CHACHA20",
+        "ECDH+AESGCM",
+        "DH+AESGCM",
+        "ECDH+AES",
+        "DH+AES",
+        "RSA+AESGCM",
+        "RSA+AES",
+        "!aNULL",
+        "!eNULL",
+        "!MD5",
+        "!DSS",
+    ]
+)
+
+try:
+    from ssl import SSLContext  # Modern SSL?
+except ImportError:
+
+    class SSLContext(object):  # Platform-specific: Python 2
+        def __init__(self, protocol_version):
+            self.protocol = protocol_version
+            # Use default values from a real SSLContext
+            self.check_hostname = False
+            self.verify_mode = ssl.CERT_NONE
+            self.ca_certs = None
+            self.options = 0
+            self.certfile = None
+            self.keyfile = None
+            self.ciphers = None
+
+        def load_cert_chain(self, certfile, keyfile):
+            self.certfile = certfile
+            self.keyfile = keyfile
+
+        def load_verify_locations(self, cafile=None, capath=None, cadata=None):
+            self.ca_certs = cafile
+
+            if capath is not None:
+                raise SSLError("CA directories not supported in older Pythons")
+
+            if cadata is not None:
+                raise SSLError("CA data not supported in older Pythons")
+
+        def set_ciphers(self, cipher_suite):
+            self.ciphers = cipher_suite
+
+        def wrap_socket(self, socket, server_hostname=None, server_side=False):
+            warnings.warn(
+                "A true SSLContext object is not available. This prevents "
+                "urllib3 from configuring SSL appropriately and may cause "
+                "certain SSL connections to fail. You can upgrade to a newer "
+                "version of Python to solve this. For more information, see "
+                "https://urllib3.readthedocs.io/en/latest/advanced-usage.html"
+                "#ssl-warnings",
+                InsecurePlatformWarning,
+            )
+            kwargs = {
+                "keyfile": self.keyfile,
+                "certfile": self.certfile,
+                "ca_certs": self.ca_certs,
+                "cert_reqs": self.verify_mode,
+                "ssl_version": self.protocol,
+                "server_side": server_side,
+            }
+            return wrap_socket(socket, ciphers=self.ciphers, **kwargs)
+
+
+def assert_fingerprint(cert, fingerprint):
+    """
+    Checks if given fingerprint matches the supplied certificate.
+
+    :param cert:
+        Certificate as bytes object.
+    :param fingerprint:
+        Fingerprint as string of hexdigits, can be interspersed by colons.
+    """
+
+    fingerprint = fingerprint.replace(":", "").lower()
+    digest_length = len(fingerprint)
+    hashfunc = HASHFUNC_MAP.get(digest_length)
+    if not hashfunc:
+        raise SSLError("Fingerprint of invalid length: {0}".format(fingerprint))
+
+    # We need encode() here for py32; works on py2 and p33.
+    fingerprint_bytes = unhexlify(fingerprint.encode())
+
+    cert_digest = hashfunc(cert).digest()
+
+    if not _const_compare_digest(cert_digest, fingerprint_bytes):
+        raise SSLError(
+            'Fingerprints did not match. Expected "{0}", got "{1}".'.format(
+                fingerprint, hexlify(cert_digest)
+            )
+        )
+
+
+def resolve_cert_reqs(candidate):
+    """
+    Resolves the argument to a numeric constant, which can be passed to
+    the wrap_socket function/method from the ssl module.
+    Defaults to :data:`ssl.CERT_REQUIRED`.
+    If given a string it is assumed to be the name of the constant in the
+    :mod:`ssl` module or its abbreviation.
+    (So you can specify `REQUIRED` instead of `CERT_REQUIRED`.
+    If it's neither `None` nor a string we assume it is already the numeric
+    constant which can directly be passed to wrap_socket.
+    """
+    if candidate is None:
+        return CERT_REQUIRED
+
+    if isinstance(candidate, str):
+        res = getattr(ssl, candidate, None)
+        if res is None:
+            res = getattr(ssl, "CERT_" + candidate)
+        return res
+
+    return candidate
+
+
+def resolve_ssl_version(candidate):
+    """
+    like resolve_cert_reqs
+    """
+    if candidate is None:
+        return PROTOCOL_TLS
+
+    if isinstance(candidate, str):
+        res = getattr(ssl, candidate, None)
+        if res is None:
+            res = getattr(ssl, "PROTOCOL_" + candidate)
+        return res
+
+    return candidate
+
+
+def create_urllib3_context(
+    ssl_version=None, cert_reqs=None, options=None, ciphers=None
+):
+    """All arguments have the same meaning as ``ssl_wrap_socket``.
+
+    By default, this function does a lot of the same work that
+    ``ssl.create_default_context`` does on Python 3.4+. It:
+
+    - Disables SSLv2, SSLv3, and compression
+    - Sets a restricted set of server ciphers
+
+    If you wish to enable SSLv3, you can do::
+
+        from pip._vendor.urllib3.util import ssl_
+        context = ssl_.create_urllib3_context()
+        context.options &= ~ssl_.OP_NO_SSLv3
+
+    You can do the same to enable compression (substituting ``COMPRESSION``
+    for ``SSLv3`` in the last line above).
+
+    :param ssl_version:
+        The desired protocol version to use. This will default to
+        PROTOCOL_SSLv23 which will negotiate the highest protocol that both
+        the server and your installation of OpenSSL support.
+    :param cert_reqs:
+        Whether to require the certificate verification. This defaults to
+        ``ssl.CERT_REQUIRED``.
+    :param options:
+        Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``,
+        ``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``.
+    :param ciphers:
+        Which cipher suites to allow the server to select.
+    :returns:
+        Constructed SSLContext object with specified options
+    :rtype: SSLContext
+    """
+    context = SSLContext(ssl_version or PROTOCOL_TLS)
+
+    context.set_ciphers(ciphers or DEFAULT_CIPHERS)
+
+    # Setting the default here, as we may have no ssl module on import
+    cert_reqs = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs
+
+    if options is None:
+        options = 0
+        # SSLv2 is easily broken and is considered harmful and dangerous
+        options |= OP_NO_SSLv2
+        # SSLv3 has several problems and is now dangerous
+        options |= OP_NO_SSLv3
+        # Disable compression to prevent CRIME attacks for OpenSSL 1.0+
+        # (issue #309)
+        options |= OP_NO_COMPRESSION
+
+    context.options |= options
+
+    # Enable post-handshake authentication for TLS 1.3, see GH #1634. PHA is
+    # necessary for conditional client cert authentication with TLS 1.3.
+    # The attribute is None for OpenSSL <= 1.1.0 or does not exist in older
+    # versions of Python.  We only enable on Python 3.7.4+ or if certificate
+    # verification is enabled to work around Python issue #37428
+    # See: https://bugs.python.org/issue37428
+    if (cert_reqs == ssl.CERT_REQUIRED or sys.version_info >= (3, 7, 4)) and getattr(
+        context, "post_handshake_auth", None
+    ) is not None:
+        context.post_handshake_auth = True
+
+    context.verify_mode = cert_reqs
+    if (
+        getattr(context, "check_hostname", None) is not None
+    ):  # Platform-specific: Python 3.2
+        # We do our own verification, including fingerprints and alternative
+        # hostnames. So disable it here
+        context.check_hostname = False
+    return context
+
+
+def ssl_wrap_socket(
+    sock,
+    keyfile=None,
+    certfile=None,
+    cert_reqs=None,
+    ca_certs=None,
+    server_hostname=None,
+    ssl_version=None,
+    ciphers=None,
+    ssl_context=None,
+    ca_cert_dir=None,
+    key_password=None,
+    ca_cert_data=None,
+):
+    """
+    All arguments except for server_hostname, ssl_context, and ca_cert_dir have
+    the same meaning as they do when using :func:`ssl.wrap_socket`.
+
+    :param server_hostname:
+        When SNI is supported, the expected hostname of the certificate
+    :param ssl_context:
+        A pre-made :class:`SSLContext` object. If none is provided, one will
+        be created using :func:`create_urllib3_context`.
+    :param ciphers:
+        A string of ciphers we wish the client to support.
+    :param ca_cert_dir:
+        A directory containing CA certificates in multiple separate files, as
+        supported by OpenSSL's -CApath flag or the capath argument to
+        SSLContext.load_verify_locations().
+    :param key_password:
+        Optional password if the keyfile is encrypted.
+    :param ca_cert_data:
+        Optional string containing CA certificates in PEM format suitable for
+        passing as the cadata parameter to SSLContext.load_verify_locations()
+    """
+    context = ssl_context
+    if context is None:
+        # Note: This branch of code and all the variables in it are no longer
+        # used by urllib3 itself. We should consider deprecating and removing
+        # this code.
+        context = create_urllib3_context(ssl_version, cert_reqs, ciphers=ciphers)
+
+    if ca_certs or ca_cert_dir or ca_cert_data:
+        try:
+            context.load_verify_locations(ca_certs, ca_cert_dir, ca_cert_data)
+        except IOError as e:  # Platform-specific: Python 2.7
+            raise SSLError(e)
+        # Py33 raises FileNotFoundError which subclasses OSError
+        # These are not equivalent unless we check the errno attribute
+        except OSError as e:  # Platform-specific: Python 3.3 and beyond
+            if e.errno == errno.ENOENT:
+                raise SSLError(e)
+            raise
+
+    elif ssl_context is None and hasattr(context, "load_default_certs"):
+        # try to load OS default certs; works well on Windows (require Python3.4+)
+        context.load_default_certs()
+
+    # Attempt to detect if we get the goofy behavior of the
+    # keyfile being encrypted and OpenSSL asking for the
+    # passphrase via the terminal and instead error out.
+    if keyfile and key_password is None and _is_key_file_encrypted(keyfile):
+        raise SSLError("Client private key is encrypted, password is required")
+
+    if certfile:
+        if key_password is None:
+            context.load_cert_chain(certfile, keyfile)
+        else:
+            context.load_cert_chain(certfile, keyfile, key_password)
+
+    # If we detect server_hostname is an IP address then the SNI
+    # extension should not be used according to RFC3546 Section 3.1
+    # We shouldn't warn the user if SNI isn't available but we would
+    # not be using SNI anyways due to IP address for server_hostname.
+    if (
+        server_hostname is not None and not is_ipaddress(server_hostname)
+    ) or IS_SECURETRANSPORT:
+        if HAS_SNI and server_hostname is not None:
+            return context.wrap_socket(sock, server_hostname=server_hostname)
+
+        warnings.warn(
+            "An HTTPS request has been made, but the SNI (Server Name "
+            "Indication) extension to TLS is not available on this platform. "
+            "This may cause the server to present an incorrect TLS "
+            "certificate, which can cause validation failures. You can upgrade to "
+            "a newer version of Python to solve this. For more information, see "
+            "https://urllib3.readthedocs.io/en/latest/advanced-usage.html"
+            "#ssl-warnings",
+            SNIMissingWarning,
+        )
+
+    return context.wrap_socket(sock)
+
+
+def is_ipaddress(hostname):
+    """Detects whether the hostname given is an IPv4 or IPv6 address.
+    Also detects IPv6 addresses with Zone IDs.
+
+    :param str hostname: Hostname to examine.
+    :return: True if the hostname is an IP address, False otherwise.
+    """
+    if not six.PY2 and isinstance(hostname, bytes):
+        # IDN A-label bytes are ASCII compatible.
+        hostname = hostname.decode("ascii")
+    return bool(IPV4_RE.match(hostname) or BRACELESS_IPV6_ADDRZ_RE.match(hostname))
+
+
+def _is_key_file_encrypted(key_file):
+    """Detects if a key file is encrypted or not."""
+    with open(key_file, "r") as f:
+        for line in f:
+            # Look for Proc-Type: 4,ENCRYPTED
+            if "ENCRYPTED" in line:
+                return True
+
+    return False
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/timeout.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/timeout.py
new file mode 100644
index 0000000..b61fea7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/timeout.py
@@ -0,0 +1,261 @@
+from __future__ import absolute_import
+
+# The default socket timeout, used by httplib to indicate that no timeout was
+# specified by the user
+from socket import _GLOBAL_DEFAULT_TIMEOUT
+import time
+
+from ..exceptions import TimeoutStateError
+
+# A sentinel value to indicate that no timeout was specified by the user in
+# urllib3
+_Default = object()
+
+
+# Use time.monotonic if available.
+current_time = getattr(time, "monotonic", time.time)
+
+
+class Timeout(object):
+    """ Timeout configuration.
+
+    Timeouts can be defined as a default for a pool::
+
+        timeout = Timeout(connect=2.0, read=7.0)
+        http = PoolManager(timeout=timeout)
+        response = http.request('GET', 'http://example.com/')
+
+    Or per-request (which overrides the default for the pool)::
+
+        response = http.request('GET', 'http://example.com/', timeout=Timeout(10))
+
+    Timeouts can be disabled by setting all the parameters to ``None``::
+
+        no_timeout = Timeout(connect=None, read=None)
+        response = http.request('GET', 'http://example.com/, timeout=no_timeout)
+
+
+    :param total:
+        This combines the connect and read timeouts into one; the read timeout
+        will be set to the time leftover from the connect attempt. In the
+        event that both a connect timeout and a total are specified, or a read
+        timeout and a total are specified, the shorter timeout will be applied.
+
+        Defaults to None.
+
+    :type total: integer, float, or None
+
+    :param connect:
+        The maximum amount of time (in seconds) to wait for a connection
+        attempt to a server to succeed. Omitting the parameter will default the
+        connect timeout to the system default, probably `the global default
+        timeout in socket.py
+        <http://hg.python.org/cpython/file/603b4d593758/Lib/socket.py#l535>`_.
+        None will set an infinite timeout for connection attempts.
+
+    :type connect: integer, float, or None
+
+    :param read:
+        The maximum amount of time (in seconds) to wait between consecutive
+        read operations for a response from the server. Omitting the parameter
+        will default the read timeout to the system default, probably `the
+        global default timeout in socket.py
+        <http://hg.python.org/cpython/file/603b4d593758/Lib/socket.py#l535>`_.
+        None will set an infinite timeout.
+
+    :type read: integer, float, or None
+
+    .. note::
+
+        Many factors can affect the total amount of time for urllib3 to return
+        an HTTP response.
+
+        For example, Python's DNS resolver does not obey the timeout specified
+        on the socket. Other factors that can affect total request time include
+        high CPU load, high swap, the program running at a low priority level,
+        or other behaviors.
+
+        In addition, the read and total timeouts only measure the time between
+        read operations on the socket connecting the client and the server,
+        not the total amount of time for the request to return a complete
+        response. For most requests, the timeout is raised because the server
+        has not sent the first byte in the specified time. This is not always
+        the case; if a server streams one byte every fifteen seconds, a timeout
+        of 20 seconds will not trigger, even though the request will take
+        several minutes to complete.
+
+        If your goal is to cut off any request after a set amount of wall clock
+        time, consider having a second "watcher" thread to cut off a slow
+        request.
+    """
+
+    #: A sentinel object representing the default timeout value
+    DEFAULT_TIMEOUT = _GLOBAL_DEFAULT_TIMEOUT
+
+    def __init__(self, total=None, connect=_Default, read=_Default):
+        self._connect = self._validate_timeout(connect, "connect")
+        self._read = self._validate_timeout(read, "read")
+        self.total = self._validate_timeout(total, "total")
+        self._start_connect = None
+
+    def __repr__(self):
+        return "%s(connect=%r, read=%r, total=%r)" % (
+            type(self).__name__,
+            self._connect,
+            self._read,
+            self.total,
+        )
+
+    # __str__ provided for backwards compatibility
+    __str__ = __repr__
+
+    @classmethod
+    def _validate_timeout(cls, value, name):
+        """ Check that a timeout attribute is valid.
+
+        :param value: The timeout value to validate
+        :param name: The name of the timeout attribute to validate. This is
+            used to specify in error messages.
+        :return: The validated and casted version of the given value.
+        :raises ValueError: If it is a numeric value less than or equal to
+            zero, or the type is not an integer, float, or None.
+        """
+        if value is _Default:
+            return cls.DEFAULT_TIMEOUT
+
+        if value is None or value is cls.DEFAULT_TIMEOUT:
+            return value
+
+        if isinstance(value, bool):
+            raise ValueError(
+                "Timeout cannot be a boolean value. It must "
+                "be an int, float or None."
+            )
+        try:
+            float(value)
+        except (TypeError, ValueError):
+            raise ValueError(
+                "Timeout value %s was %s, but it must be an "
+                "int, float or None." % (name, value)
+            )
+
+        try:
+            if value <= 0:
+                raise ValueError(
+                    "Attempted to set %s timeout to %s, but the "
+                    "timeout cannot be set to a value less "
+                    "than or equal to 0." % (name, value)
+                )
+        except TypeError:
+            # Python 3
+            raise ValueError(
+                "Timeout value %s was %s, but it must be an "
+                "int, float or None." % (name, value)
+            )
+
+        return value
+
+    @classmethod
+    def from_float(cls, timeout):
+        """ Create a new Timeout from a legacy timeout value.
+
+        The timeout value used by httplib.py sets the same timeout on the
+        connect(), and recv() socket requests. This creates a :class:`Timeout`
+        object that sets the individual timeouts to the ``timeout`` value
+        passed to this function.
+
+        :param timeout: The legacy timeout value.
+        :type timeout: integer, float, sentinel default object, or None
+        :return: Timeout object
+        :rtype: :class:`Timeout`
+        """
+        return Timeout(read=timeout, connect=timeout)
+
+    def clone(self):
+        """ Create a copy of the timeout object
+
+        Timeout properties are stored per-pool but each request needs a fresh
+        Timeout object to ensure each one has its own start/stop configured.
+
+        :return: a copy of the timeout object
+        :rtype: :class:`Timeout`
+        """
+        # We can't use copy.deepcopy because that will also create a new object
+        # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to
+        # detect the user default.
+        return Timeout(connect=self._connect, read=self._read, total=self.total)
+
+    def start_connect(self):
+        """ Start the timeout clock, used during a connect() attempt
+
+        :raises urllib3.exceptions.TimeoutStateError: if you attempt
+            to start a timer that has been started already.
+        """
+        if self._start_connect is not None:
+            raise TimeoutStateError("Timeout timer has already been started.")
+        self._start_connect = current_time()
+        return self._start_connect
+
+    def get_connect_duration(self):
+        """ Gets the time elapsed since the call to :meth:`start_connect`.
+
+        :return: Elapsed time in seconds.
+        :rtype: float
+        :raises urllib3.exceptions.TimeoutStateError: if you attempt
+            to get duration for a timer that hasn't been started.
+        """
+        if self._start_connect is None:
+            raise TimeoutStateError(
+                "Can't get connect duration for timer that has not started."
+            )
+        return current_time() - self._start_connect
+
+    @property
+    def connect_timeout(self):
+        """ Get the value to use when setting a connection timeout.
+
+        This will be a positive float or integer, the value None
+        (never timeout), or the default system timeout.
+
+        :return: Connect timeout.
+        :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
+        """
+        if self.total is None:
+            return self._connect
+
+        if self._connect is None or self._connect is self.DEFAULT_TIMEOUT:
+            return self.total
+
+        return min(self._connect, self.total)
+
+    @property
+    def read_timeout(self):
+        """ Get the value for the read timeout.
+
+        This assumes some time has elapsed in the connection timeout and
+        computes the read timeout appropriately.
+
+        If self.total is set, the read timeout is dependent on the amount of
+        time taken by the connect timeout. If the connection time has not been
+        established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be
+        raised.
+
+        :return: Value to use for the read timeout.
+        :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
+        :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect`
+            has not yet been called on this object.
+        """
+        if (
+            self.total is not None
+            and self.total is not self.DEFAULT_TIMEOUT
+            and self._read is not None
+            and self._read is not self.DEFAULT_TIMEOUT
+        ):
+            # In case the connect timeout has not yet been established.
+            if self._start_connect is None:
+                return self._read
+            return max(0, min(self.total - self.get_connect_duration(), self._read))
+        elif self.total is not None and self.total is not self.DEFAULT_TIMEOUT:
+            return max(0, self.total - self.get_connect_duration())
+        else:
+            return self._read
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/url.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/url.py
new file mode 100644
index 0000000..0eb0b6a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/url.py
@@ -0,0 +1,430 @@
+from __future__ import absolute_import
+import re
+from collections import namedtuple
+
+from ..exceptions import LocationParseError
+from ..packages import six
+
+
+url_attrs = ["scheme", "auth", "host", "port", "path", "query", "fragment"]
+
+# We only want to normalize urls with an HTTP(S) scheme.
+# urllib3 infers URLs without a scheme (None) to be http.
+NORMALIZABLE_SCHEMES = ("http", "https", None)
+
+# Almost all of these patterns were derived from the
+# 'rfc3986' module: https://github.com/python-hyper/rfc3986
+PERCENT_RE = re.compile(r"%[a-fA-F0-9]{2}")
+SCHEME_RE = re.compile(r"^(?:[a-zA-Z][a-zA-Z0-9+-]*:|/)")
+URI_RE = re.compile(
+    r"^(?:([a-zA-Z][a-zA-Z0-9+.-]*):)?"
+    r"(?://([^\\/?#]*))?"
+    r"([^?#]*)"
+    r"(?:\?([^#]*))?"
+    r"(?:#(.*))?$",
+    re.UNICODE | re.DOTALL,
+)
+
+IPV4_PAT = r"(?:[0-9]{1,3}\.){3}[0-9]{1,3}"
+HEX_PAT = "[0-9A-Fa-f]{1,4}"
+LS32_PAT = "(?:{hex}:{hex}|{ipv4})".format(hex=HEX_PAT, ipv4=IPV4_PAT)
+_subs = {"hex": HEX_PAT, "ls32": LS32_PAT}
+_variations = [
+    #                            6( h16 ":" ) ls32
+    "(?:%(hex)s:){6}%(ls32)s",
+    #                       "::" 5( h16 ":" ) ls32
+    "::(?:%(hex)s:){5}%(ls32)s",
+    # [               h16 ] "::" 4( h16 ":" ) ls32
+    "(?:%(hex)s)?::(?:%(hex)s:){4}%(ls32)s",
+    # [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
+    "(?:(?:%(hex)s:)?%(hex)s)?::(?:%(hex)s:){3}%(ls32)s",
+    # [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
+    "(?:(?:%(hex)s:){0,2}%(hex)s)?::(?:%(hex)s:){2}%(ls32)s",
+    # [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32
+    "(?:(?:%(hex)s:){0,3}%(hex)s)?::%(hex)s:%(ls32)s",
+    # [ *4( h16 ":" ) h16 ] "::"              ls32
+    "(?:(?:%(hex)s:){0,4}%(hex)s)?::%(ls32)s",
+    # [ *5( h16 ":" ) h16 ] "::"              h16
+    "(?:(?:%(hex)s:){0,5}%(hex)s)?::%(hex)s",
+    # [ *6( h16 ":" ) h16 ] "::"
+    "(?:(?:%(hex)s:){0,6}%(hex)s)?::",
+]
+
+UNRESERVED_PAT = r"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._!\-~"
+IPV6_PAT = "(?:" + "|".join([x % _subs for x in _variations]) + ")"
+ZONE_ID_PAT = "(?:%25|%)(?:[" + UNRESERVED_PAT + "]|%[a-fA-F0-9]{2})+"
+IPV6_ADDRZ_PAT = r"\[" + IPV6_PAT + r"(?:" + ZONE_ID_PAT + r")?\]"
+REG_NAME_PAT = r"(?:[^\[\]%:/?#]|%[a-fA-F0-9]{2})*"
+TARGET_RE = re.compile(r"^(/[^?#]*)(?:\?([^#]*))?(?:#.*)?$")
+
+IPV4_RE = re.compile("^" + IPV4_PAT + "$")
+IPV6_RE = re.compile("^" + IPV6_PAT + "$")
+IPV6_ADDRZ_RE = re.compile("^" + IPV6_ADDRZ_PAT + "$")
+BRACELESS_IPV6_ADDRZ_RE = re.compile("^" + IPV6_ADDRZ_PAT[2:-2] + "$")
+ZONE_ID_RE = re.compile("(" + ZONE_ID_PAT + r")\]$")
+
+SUBAUTHORITY_PAT = (u"^(?:(.*)@)?(%s|%s|%s)(?::([0-9]{0,5}))?$") % (
+    REG_NAME_PAT,
+    IPV4_PAT,
+    IPV6_ADDRZ_PAT,
+)
+SUBAUTHORITY_RE = re.compile(SUBAUTHORITY_PAT, re.UNICODE | re.DOTALL)
+
+UNRESERVED_CHARS = set(
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-~"
+)
+SUB_DELIM_CHARS = set("!$&'()*+,;=")
+USERINFO_CHARS = UNRESERVED_CHARS | SUB_DELIM_CHARS | {":"}
+PATH_CHARS = USERINFO_CHARS | {"@", "/"}
+QUERY_CHARS = FRAGMENT_CHARS = PATH_CHARS | {"?"}
+
+
+class Url(namedtuple("Url", url_attrs)):
+    """
+    Data structure for representing an HTTP URL. Used as a return value for
+    :func:`parse_url`. Both the scheme and host are normalized as they are
+    both case-insensitive according to RFC 3986.
+    """
+
+    __slots__ = ()
+
+    def __new__(
+        cls,
+        scheme=None,
+        auth=None,
+        host=None,
+        port=None,
+        path=None,
+        query=None,
+        fragment=None,
+    ):
+        if path and not path.startswith("/"):
+            path = "/" + path
+        if scheme is not None:
+            scheme = scheme.lower()
+        return super(Url, cls).__new__(
+            cls, scheme, auth, host, port, path, query, fragment
+        )
+
+    @property
+    def hostname(self):
+        """For backwards-compatibility with urlparse. We're nice like that."""
+        return self.host
+
+    @property
+    def request_uri(self):
+        """Absolute path including the query string."""
+        uri = self.path or "/"
+
+        if self.query is not None:
+            uri += "?" + self.query
+
+        return uri
+
+    @property
+    def netloc(self):
+        """Network location including host and port"""
+        if self.port:
+            return "%s:%d" % (self.host, self.port)
+        return self.host
+
+    @property
+    def url(self):
+        """
+        Convert self into a url
+
+        This function should more or less round-trip with :func:`.parse_url`. The
+        returned url may not be exactly the same as the url inputted to
+        :func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls
+        with a blank port will have : removed).
+
+        Example: ::
+
+            >>> U = parse_url('http://google.com/mail/')
+            >>> U.url
+            'http://google.com/mail/'
+            >>> Url('http', 'username:password', 'host.com', 80,
+            ... '/path', 'query', 'fragment').url
+            'http://username:password@host.com:80/path?query#fragment'
+        """
+        scheme, auth, host, port, path, query, fragment = self
+        url = u""
+
+        # We use "is not None" we want things to happen with empty strings (or 0 port)
+        if scheme is not None:
+            url += scheme + u"://"
+        if auth is not None:
+            url += auth + u"@"
+        if host is not None:
+            url += host
+        if port is not None:
+            url += u":" + str(port)
+        if path is not None:
+            url += path
+        if query is not None:
+            url += u"?" + query
+        if fragment is not None:
+            url += u"#" + fragment
+
+        return url
+
+    def __str__(self):
+        return self.url
+
+
+def split_first(s, delims):
+    """
+    .. deprecated:: 1.25
+
+    Given a string and an iterable of delimiters, split on the first found
+    delimiter. Return two split parts and the matched delimiter.
+
+    If not found, then the first part is the full input string.
+
+    Example::
+
+        >>> split_first('foo/bar?baz', '?/=')
+        ('foo', 'bar?baz', '/')
+        >>> split_first('foo/bar?baz', '123')
+        ('foo/bar?baz', '', None)
+
+    Scales linearly with number of delims. Not ideal for large number of delims.
+    """
+    min_idx = None
+    min_delim = None
+    for d in delims:
+        idx = s.find(d)
+        if idx < 0:
+            continue
+
+        if min_idx is None or idx < min_idx:
+            min_idx = idx
+            min_delim = d
+
+    if min_idx is None or min_idx < 0:
+        return s, "", None
+
+    return s[:min_idx], s[min_idx + 1 :], min_delim
+
+
+def _encode_invalid_chars(component, allowed_chars, encoding="utf-8"):
+    """Percent-encodes a URI component without reapplying
+    onto an already percent-encoded component.
+    """
+    if component is None:
+        return component
+
+    component = six.ensure_text(component)
+
+    # Normalize existing percent-encoded bytes.
+    # Try to see if the component we're encoding is already percent-encoded
+    # so we can skip all '%' characters but still encode all others.
+    component, percent_encodings = PERCENT_RE.subn(
+        lambda match: match.group(0).upper(), component
+    )
+
+    uri_bytes = component.encode("utf-8", "surrogatepass")
+    is_percent_encoded = percent_encodings == uri_bytes.count(b"%")
+    encoded_component = bytearray()
+
+    for i in range(0, len(uri_bytes)):
+        # Will return a single character bytestring on both Python 2 & 3
+        byte = uri_bytes[i : i + 1]
+        byte_ord = ord(byte)
+        if (is_percent_encoded and byte == b"%") or (
+            byte_ord < 128 and byte.decode() in allowed_chars
+        ):
+            encoded_component += byte
+            continue
+        encoded_component.extend(b"%" + (hex(byte_ord)[2:].encode().zfill(2).upper()))
+
+    return encoded_component.decode(encoding)
+
+
+def _remove_path_dot_segments(path):
+    # See http://tools.ietf.org/html/rfc3986#section-5.2.4 for pseudo-code
+    segments = path.split("/")  # Turn the path into a list of segments
+    output = []  # Initialize the variable to use to store output
+
+    for segment in segments:
+        # '.' is the current directory, so ignore it, it is superfluous
+        if segment == ".":
+            continue
+        # Anything other than '..', should be appended to the output
+        elif segment != "..":
+            output.append(segment)
+        # In this case segment == '..', if we can, we should pop the last
+        # element
+        elif output:
+            output.pop()
+
+    # If the path starts with '/' and the output is empty or the first string
+    # is non-empty
+    if path.startswith("/") and (not output or output[0]):
+        output.insert(0, "")
+
+    # If the path starts with '/.' or '/..' ensure we add one more empty
+    # string to add a trailing '/'
+    if path.endswith(("/.", "/..")):
+        output.append("")
+
+    return "/".join(output)
+
+
+def _normalize_host(host, scheme):
+    if host:
+        if isinstance(host, six.binary_type):
+            host = six.ensure_str(host)
+
+        if scheme in NORMALIZABLE_SCHEMES:
+            is_ipv6 = IPV6_ADDRZ_RE.match(host)
+            if is_ipv6:
+                match = ZONE_ID_RE.search(host)
+                if match:
+                    start, end = match.span(1)
+                    zone_id = host[start:end]
+
+                    if zone_id.startswith("%25") and zone_id != "%25":
+                        zone_id = zone_id[3:]
+                    else:
+                        zone_id = zone_id[1:]
+                    zone_id = "%" + _encode_invalid_chars(zone_id, UNRESERVED_CHARS)
+                    return host[:start].lower() + zone_id + host[end:]
+                else:
+                    return host.lower()
+            elif not IPV4_RE.match(host):
+                return six.ensure_str(
+                    b".".join([_idna_encode(label) for label in host.split(".")])
+                )
+    return host
+
+
+def _idna_encode(name):
+    if name and any([ord(x) > 128 for x in name]):
+        try:
+            from pip._vendor import idna
+        except ImportError:
+            six.raise_from(
+                LocationParseError("Unable to parse URL without the 'idna' module"),
+                None,
+            )
+        try:
+            return idna.encode(name.lower(), strict=True, std3_rules=True)
+        except idna.IDNAError:
+            six.raise_from(
+                LocationParseError(u"Name '%s' is not a valid IDNA label" % name), None
+            )
+    return name.lower().encode("ascii")
+
+
+def _encode_target(target):
+    """Percent-encodes a request target so that there are no invalid characters"""
+    path, query = TARGET_RE.match(target).groups()
+    target = _encode_invalid_chars(path, PATH_CHARS)
+    query = _encode_invalid_chars(query, QUERY_CHARS)
+    if query is not None:
+        target += "?" + query
+    return target
+
+
+def parse_url(url):
+    """
+    Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is
+    performed to parse incomplete urls. Fields not provided will be None.
+    This parser is RFC 3986 compliant.
+
+    The parser logic and helper functions are based heavily on
+    work done in the ``rfc3986`` module.
+
+    :param str url: URL to parse into a :class:`.Url` namedtuple.
+
+    Partly backwards-compatible with :mod:`urlparse`.
+
+    Example::
+
+        >>> parse_url('http://google.com/mail/')
+        Url(scheme='http', host='google.com', port=None, path='/mail/', ...)
+        >>> parse_url('google.com:80')
+        Url(scheme=None, host='google.com', port=80, path=None, ...)
+        >>> parse_url('/foo?bar')
+        Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)
+    """
+    if not url:
+        # Empty
+        return Url()
+
+    source_url = url
+    if not SCHEME_RE.search(url):
+        url = "//" + url
+
+    try:
+        scheme, authority, path, query, fragment = URI_RE.match(url).groups()
+        normalize_uri = scheme is None or scheme.lower() in NORMALIZABLE_SCHEMES
+
+        if scheme:
+            scheme = scheme.lower()
+
+        if authority:
+            auth, host, port = SUBAUTHORITY_RE.match(authority).groups()
+            if auth and normalize_uri:
+                auth = _encode_invalid_chars(auth, USERINFO_CHARS)
+            if port == "":
+                port = None
+        else:
+            auth, host, port = None, None, None
+
+        if port is not None:
+            port = int(port)
+            if not (0 <= port <= 65535):
+                raise LocationParseError(url)
+
+        host = _normalize_host(host, scheme)
+
+        if normalize_uri and path:
+            path = _remove_path_dot_segments(path)
+            path = _encode_invalid_chars(path, PATH_CHARS)
+        if normalize_uri and query:
+            query = _encode_invalid_chars(query, QUERY_CHARS)
+        if normalize_uri and fragment:
+            fragment = _encode_invalid_chars(fragment, FRAGMENT_CHARS)
+
+    except (ValueError, AttributeError):
+        return six.raise_from(LocationParseError(source_url), None)
+
+    # For the sake of backwards compatibility we put empty
+    # string values for path if there are any defined values
+    # beyond the path in the URL.
+    # TODO: Remove this when we break backwards compatibility.
+    if not path:
+        if query is not None or fragment is not None:
+            path = ""
+        else:
+            path = None
+
+    # Ensure that each part of the URL is a `str` for
+    # backwards compatibility.
+    if isinstance(url, six.text_type):
+        ensure_func = six.ensure_text
+    else:
+        ensure_func = six.ensure_str
+
+    def ensure_type(x):
+        return x if x is None else ensure_func(x)
+
+    return Url(
+        scheme=ensure_type(scheme),
+        auth=ensure_type(auth),
+        host=ensure_type(host),
+        port=port,
+        path=ensure_type(path),
+        query=ensure_type(query),
+        fragment=ensure_type(fragment),
+    )
+
+
+def get_host(url):
+    """
+    Deprecated. Use :func:`parse_url` instead.
+    """
+    p = parse_url(url)
+    return p.scheme or "http", p.hostname, p.port
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/wait.py b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/wait.py
new file mode 100644
index 0000000..d71d2fd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/urllib3/util/wait.py
@@ -0,0 +1,153 @@
+import errno
+from functools import partial
+import select
+import sys
+
+try:
+    from time import monotonic
+except ImportError:
+    from time import time as monotonic
+
+__all__ = ["NoWayToWaitForSocketError", "wait_for_read", "wait_for_write"]
+
+
+class NoWayToWaitForSocketError(Exception):
+    pass
+
+
+# How should we wait on sockets?
+#
+# There are two types of APIs you can use for waiting on sockets: the fancy
+# modern stateful APIs like epoll/kqueue, and the older stateless APIs like
+# select/poll. The stateful APIs are more efficient when you have a lots of
+# sockets to keep track of, because you can set them up once and then use them
+# lots of times. But we only ever want to wait on a single socket at a time
+# and don't want to keep track of state, so the stateless APIs are actually
+# more efficient. So we want to use select() or poll().
+#
+# Now, how do we choose between select() and poll()? On traditional Unixes,
+# select() has a strange calling convention that makes it slow, or fail
+# altogether, for high-numbered file descriptors. The point of poll() is to fix
+# that, so on Unixes, we prefer poll().
+#
+# On Windows, there is no poll() (or at least Python doesn't provide a wrapper
+# for it), but that's OK, because on Windows, select() doesn't have this
+# strange calling convention; plain select() works fine.
+#
+# So: on Windows we use select(), and everywhere else we use poll(). We also
+# fall back to select() in case poll() is somehow broken or missing.
+
+if sys.version_info >= (3, 5):
+    # Modern Python, that retries syscalls by default
+    def _retry_on_intr(fn, timeout):
+        return fn(timeout)
+
+
+else:
+    # Old and broken Pythons.
+    def _retry_on_intr(fn, timeout):
+        if timeout is None:
+            deadline = float("inf")
+        else:
+            deadline = monotonic() + timeout
+
+        while True:
+            try:
+                return fn(timeout)
+            # OSError for 3 <= pyver < 3.5, select.error for pyver <= 2.7
+            except (OSError, select.error) as e:
+                # 'e.args[0]' incantation works for both OSError and select.error
+                if e.args[0] != errno.EINTR:
+                    raise
+                else:
+                    timeout = deadline - monotonic()
+                    if timeout < 0:
+                        timeout = 0
+                    if timeout == float("inf"):
+                        timeout = None
+                    continue
+
+
+def select_wait_for_socket(sock, read=False, write=False, timeout=None):
+    if not read and not write:
+        raise RuntimeError("must specify at least one of read=True, write=True")
+    rcheck = []
+    wcheck = []
+    if read:
+        rcheck.append(sock)
+    if write:
+        wcheck.append(sock)
+    # When doing a non-blocking connect, most systems signal success by
+    # marking the socket writable. Windows, though, signals success by marked
+    # it as "exceptional". We paper over the difference by checking the write
+    # sockets for both conditions. (The stdlib selectors module does the same
+    # thing.)
+    fn = partial(select.select, rcheck, wcheck, wcheck)
+    rready, wready, xready = _retry_on_intr(fn, timeout)
+    return bool(rready or wready or xready)
+
+
+def poll_wait_for_socket(sock, read=False, write=False, timeout=None):
+    if not read and not write:
+        raise RuntimeError("must specify at least one of read=True, write=True")
+    mask = 0
+    if read:
+        mask |= select.POLLIN
+    if write:
+        mask |= select.POLLOUT
+    poll_obj = select.poll()
+    poll_obj.register(sock, mask)
+
+    # For some reason, poll() takes timeout in milliseconds
+    def do_poll(t):
+        if t is not None:
+            t *= 1000
+        return poll_obj.poll(t)
+
+    return bool(_retry_on_intr(do_poll, timeout))
+
+
+def null_wait_for_socket(*args, **kwargs):
+    raise NoWayToWaitForSocketError("no select-equivalent available")
+
+
+def _have_working_poll():
+    # Apparently some systems have a select.poll that fails as soon as you try
+    # to use it, either due to strange configuration or broken monkeypatching
+    # from libraries like eventlet/greenlet.
+    try:
+        poll_obj = select.poll()
+        _retry_on_intr(poll_obj.poll, 0)
+    except (AttributeError, OSError):
+        return False
+    else:
+        return True
+
+
+def wait_for_socket(*args, **kwargs):
+    # We delay choosing which implementation to use until the first time we're
+    # called. We could do it at import time, but then we might make the wrong
+    # decision if someone goes wild with monkeypatching select.poll after
+    # we're imported.
+    global wait_for_socket
+    if _have_working_poll():
+        wait_for_socket = poll_wait_for_socket
+    elif hasattr(select, "select"):
+        wait_for_socket = select_wait_for_socket
+    else:  # Platform-specific: Appengine.
+        wait_for_socket = null_wait_for_socket
+    return wait_for_socket(*args, **kwargs)
+
+
+def wait_for_read(sock, timeout=None):
+    """ Waits for reading to be available on a given socket.
+    Returns True if the socket is readable, or False if the timeout expired.
+    """
+    return wait_for_socket(sock, read=True, timeout=timeout)
+
+
+def wait_for_write(sock, timeout=None):
+    """ Waits for writing to be available on a given socket.
+    Returns True if the socket is readable, or False if the timeout expired.
+    """
+    return wait_for_socket(sock, write=True, timeout=timeout)
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/vendor.txt b/myenv/lib/python3.9/site-packages/pip/_vendor/vendor.txt
new file mode 100644
index 0000000..06fa135
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/vendor.txt
@@ -0,0 +1,24 @@
+appdirs==1.4.4
+CacheControl==0.12.6
+colorama==0.4.3
+contextlib2==0.6.0.post1
+distlib==0.3.1
+distro==1.5.0
+html5lib==1.1
+ipaddress==1.0.23  # Only needed on 2.6 and 2.7
+msgpack==1.0.0
+packaging==20.4
+pep517==0.8.2
+progress==1.5
+pyparsing==2.4.7
+requests==2.24.0
+    certifi==2020.06.20
+    chardet==3.0.4
+    idna==2.10
+    urllib3==1.25.9
+resolvelib==0.4.0
+retrying==1.3.3
+setuptools==44.0.0
+six==1.15.0
+toml==0.10.1
+webencodings==0.5.1
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/__init__.py b/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/__init__.py
new file mode 100644
index 0000000..d21d697
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/__init__.py
@@ -0,0 +1,342 @@
+# coding: utf-8
+"""
+
+    webencodings
+    ~~~~~~~~~~~~
+
+    This is a Python implementation of the `WHATWG Encoding standard
+    <http://encoding.spec.whatwg.org/>`. See README for details.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+from __future__ import unicode_literals
+
+import codecs
+
+from .labels import LABELS
+
+
+VERSION = '0.5.1'
+
+
+# Some names in Encoding are not valid Python aliases. Remap these.
+PYTHON_NAMES = {
+    'iso-8859-8-i': 'iso-8859-8',
+    'x-mac-cyrillic': 'mac-cyrillic',
+    'macintosh': 'mac-roman',
+    'windows-874': 'cp874'}
+
+CACHE = {}
+
+
+def ascii_lower(string):
+    r"""Transform (only) ASCII letters to lower case: A-Z is mapped to a-z.
+
+    :param string: An Unicode string.
+    :returns: A new Unicode string.
+
+    This is used for `ASCII case-insensitive
+    <http://encoding.spec.whatwg.org/#ascii-case-insensitive>`_
+    matching of encoding labels.
+    The same matching is also used, among other things,
+    for `CSS keywords <http://dev.w3.org/csswg/css-values/#keywords>`_.
+
+    This is different from the :meth:`~py:str.lower` method of Unicode strings
+    which also affect non-ASCII characters,
+    sometimes mapping them into the ASCII range:
+
+        >>> keyword = u'Bac\N{KELVIN SIGN}ground'
+        >>> assert keyword.lower() == u'background'
+        >>> assert ascii_lower(keyword) != keyword.lower()
+        >>> assert ascii_lower(keyword) == u'bac\N{KELVIN SIGN}ground'
+
+    """
+    # This turns out to be faster than unicode.translate()
+    return string.encode('utf8').lower().decode('utf8')
+
+
+def lookup(label):
+    """
+    Look for an encoding by its label.
+    This is the spec’s `get an encoding
+    <http://encoding.spec.whatwg.org/#concept-encoding-get>`_ algorithm.
+    Supported labels are listed there.
+
+    :param label: A string.
+    :returns:
+        An :class:`Encoding` object, or :obj:`None` for an unknown label.
+
+    """
+    # Only strip ASCII whitespace: U+0009, U+000A, U+000C, U+000D, and U+0020.
+    label = ascii_lower(label.strip('\t\n\f\r '))
+    name = LABELS.get(label)
+    if name is None:
+        return None
+    encoding = CACHE.get(name)
+    if encoding is None:
+        if name == 'x-user-defined':
+            from .x_user_defined import codec_info
+        else:
+            python_name = PYTHON_NAMES.get(name, name)
+            # Any python_name value that gets to here should be valid.
+            codec_info = codecs.lookup(python_name)
+        encoding = Encoding(name, codec_info)
+        CACHE[name] = encoding
+    return encoding
+
+
+def _get_encoding(encoding_or_label):
+    """
+    Accept either an encoding object or label.
+
+    :param encoding: An :class:`Encoding` object or a label string.
+    :returns: An :class:`Encoding` object.
+    :raises: :exc:`~exceptions.LookupError` for an unknown label.
+
+    """
+    if hasattr(encoding_or_label, 'codec_info'):
+        return encoding_or_label
+
+    encoding = lookup(encoding_or_label)
+    if encoding is None:
+        raise LookupError('Unknown encoding label: %r' % encoding_or_label)
+    return encoding
+
+
+class Encoding(object):
+    """Reresents a character encoding such as UTF-8,
+    that can be used for decoding or encoding.
+
+    .. attribute:: name
+
+        Canonical name of the encoding
+
+    .. attribute:: codec_info
+
+        The actual implementation of the encoding,
+        a stdlib :class:`~codecs.CodecInfo` object.
+        See :func:`codecs.register`.
+
+    """
+    def __init__(self, name, codec_info):
+        self.name = name
+        self.codec_info = codec_info
+
+    def __repr__(self):
+        return '<Encoding %s>' % self.name
+
+
+#: The UTF-8 encoding. Should be used for new content and formats.
+UTF8 = lookup('utf-8')
+
+_UTF16LE = lookup('utf-16le')
+_UTF16BE = lookup('utf-16be')
+
+
+def decode(input, fallback_encoding, errors='replace'):
+    """
+    Decode a single string.
+
+    :param input: A byte string
+    :param fallback_encoding:
+        An :class:`Encoding` object or a label string.
+        The encoding to use if :obj:`input` does note have a BOM.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+    :return:
+        A ``(output, encoding)`` tuple of an Unicode string
+        and an :obj:`Encoding`.
+
+    """
+    # Fail early if `encoding` is an invalid label.
+    fallback_encoding = _get_encoding(fallback_encoding)
+    bom_encoding, input = _detect_bom(input)
+    encoding = bom_encoding or fallback_encoding
+    return encoding.codec_info.decode(input, errors)[0], encoding
+
+
+def _detect_bom(input):
+    """Return (bom_encoding, input), with any BOM removed from the input."""
+    if input.startswith(b'\xFF\xFE'):
+        return _UTF16LE, input[2:]
+    if input.startswith(b'\xFE\xFF'):
+        return _UTF16BE, input[2:]
+    if input.startswith(b'\xEF\xBB\xBF'):
+        return UTF8, input[3:]
+    return None, input
+
+
+def encode(input, encoding=UTF8, errors='strict'):
+    """
+    Encode a single string.
+
+    :param input: An Unicode string.
+    :param encoding: An :class:`Encoding` object or a label string.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+    :return: A byte string.
+
+    """
+    return _get_encoding(encoding).codec_info.encode(input, errors)[0]
+
+
+def iter_decode(input, fallback_encoding, errors='replace'):
+    """
+    "Pull"-based decoder.
+
+    :param input:
+        An iterable of byte strings.
+
+        The input is first consumed just enough to determine the encoding
+        based on the precense of a BOM,
+        then consumed on demand when the return value is.
+    :param fallback_encoding:
+        An :class:`Encoding` object or a label string.
+        The encoding to use if :obj:`input` does note have a BOM.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+    :returns:
+        An ``(output, encoding)`` tuple.
+        :obj:`output` is an iterable of Unicode strings,
+        :obj:`encoding` is the :obj:`Encoding` that is being used.
+
+    """
+
+    decoder = IncrementalDecoder(fallback_encoding, errors)
+    generator = _iter_decode_generator(input, decoder)
+    encoding = next(generator)
+    return generator, encoding
+
+
+def _iter_decode_generator(input, decoder):
+    """Return a generator that first yields the :obj:`Encoding`,
+    then yields output chukns as Unicode strings.
+
+    """
+    decode = decoder.decode
+    input = iter(input)
+    for chunck in input:
+        output = decode(chunck)
+        if output:
+            assert decoder.encoding is not None
+            yield decoder.encoding
+            yield output
+            break
+    else:
+        # Input exhausted without determining the encoding
+        output = decode(b'', final=True)
+        assert decoder.encoding is not None
+        yield decoder.encoding
+        if output:
+            yield output
+        return
+
+    for chunck in input:
+        output = decode(chunck)
+        if output:
+            yield output
+    output = decode(b'', final=True)
+    if output:
+        yield output
+
+
+def iter_encode(input, encoding=UTF8, errors='strict'):
+    """
+    “Pull”-based encoder.
+
+    :param input: An iterable of Unicode strings.
+    :param encoding: An :class:`Encoding` object or a label string.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+    :returns: An iterable of byte strings.
+
+    """
+    # Fail early if `encoding` is an invalid label.
+    encode = IncrementalEncoder(encoding, errors).encode
+    return _iter_encode_generator(input, encode)
+
+
+def _iter_encode_generator(input, encode):
+    for chunck in input:
+        output = encode(chunck)
+        if output:
+            yield output
+    output = encode('', final=True)
+    if output:
+        yield output
+
+
+class IncrementalDecoder(object):
+    """
+    “Push”-based decoder.
+
+    :param fallback_encoding:
+        An :class:`Encoding` object or a label string.
+        The encoding to use if :obj:`input` does note have a BOM.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+
+    """
+    def __init__(self, fallback_encoding, errors='replace'):
+        # Fail early if `encoding` is an invalid label.
+        self._fallback_encoding = _get_encoding(fallback_encoding)
+        self._errors = errors
+        self._buffer = b''
+        self._decoder = None
+        #: The actual :class:`Encoding` that is being used,
+        #: or :obj:`None` if that is not determined yet.
+        #: (Ie. if there is not enough input yet to determine
+        #: if there is a BOM.)
+        self.encoding = None  # Not known yet.
+
+    def decode(self, input, final=False):
+        """Decode one chunk of the input.
+
+        :param input: A byte string.
+        :param final:
+            Indicate that no more input is available.
+            Must be :obj:`True` if this is the last call.
+        :returns: An Unicode string.
+
+        """
+        decoder = self._decoder
+        if decoder is not None:
+            return decoder(input, final)
+
+        input = self._buffer + input
+        encoding, input = _detect_bom(input)
+        if encoding is None:
+            if len(input) < 3 and not final:  # Not enough data yet.
+                self._buffer = input
+                return ''
+            else:  # No BOM
+                encoding = self._fallback_encoding
+        decoder = encoding.codec_info.incrementaldecoder(self._errors).decode
+        self._decoder = decoder
+        self.encoding = encoding
+        return decoder(input, final)
+
+
+class IncrementalEncoder(object):
+    """
+    “Push”-based encoder.
+
+    :param encoding: An :class:`Encoding` object or a label string.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+
+    .. method:: encode(input, final=False)
+
+        :param input: An Unicode string.
+        :param final:
+            Indicate that no more input is available.
+            Must be :obj:`True` if this is the last call.
+        :returns: A byte string.
+
+    """
+    def __init__(self, encoding=UTF8, errors='strict'):
+        encoding = _get_encoding(encoding)
+        self.encode = encoding.codec_info.incrementalencoder(errors).encode
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/labels.py b/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/labels.py
new file mode 100644
index 0000000..29cbf91
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/labels.py
@@ -0,0 +1,231 @@
+"""
+
+    webencodings.labels
+    ~~~~~~~~~~~~~~~~~~~
+
+    Map encoding labels to their name.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+# XXX Do not edit!
+# This file is automatically generated by mklabels.py
+
+LABELS = {
+    'unicode-1-1-utf-8':   'utf-8',
+    'utf-8':               'utf-8',
+    'utf8':                'utf-8',
+    '866':                 'ibm866',
+    'cp866':               'ibm866',
+    'csibm866':            'ibm866',
+    'ibm866':              'ibm866',
+    'csisolatin2':         'iso-8859-2',
+    'iso-8859-2':          'iso-8859-2',
+    'iso-ir-101':          'iso-8859-2',
+    'iso8859-2':           'iso-8859-2',
+    'iso88592':            'iso-8859-2',
+    'iso_8859-2':          'iso-8859-2',
+    'iso_8859-2:1987':     'iso-8859-2',
+    'l2':                  'iso-8859-2',
+    'latin2':              'iso-8859-2',
+    'csisolatin3':         'iso-8859-3',
+    'iso-8859-3':          'iso-8859-3',
+    'iso-ir-109':          'iso-8859-3',
+    'iso8859-3':           'iso-8859-3',
+    'iso88593':            'iso-8859-3',
+    'iso_8859-3':          'iso-8859-3',
+    'iso_8859-3:1988':     'iso-8859-3',
+    'l3':                  'iso-8859-3',
+    'latin3':              'iso-8859-3',
+    'csisolatin4':         'iso-8859-4',
+    'iso-8859-4':          'iso-8859-4',
+    'iso-ir-110':          'iso-8859-4',
+    'iso8859-4':           'iso-8859-4',
+    'iso88594':            'iso-8859-4',
+    'iso_8859-4':          'iso-8859-4',
+    'iso_8859-4:1988':     'iso-8859-4',
+    'l4':                  'iso-8859-4',
+    'latin4':              'iso-8859-4',
+    'csisolatincyrillic':  'iso-8859-5',
+    'cyrillic':            'iso-8859-5',
+    'iso-8859-5':          'iso-8859-5',
+    'iso-ir-144':          'iso-8859-5',
+    'iso8859-5':           'iso-8859-5',
+    'iso88595':            'iso-8859-5',
+    'iso_8859-5':          'iso-8859-5',
+    'iso_8859-5:1988':     'iso-8859-5',
+    'arabic':              'iso-8859-6',
+    'asmo-708':            'iso-8859-6',
+    'csiso88596e':         'iso-8859-6',
+    'csiso88596i':         'iso-8859-6',
+    'csisolatinarabic':    'iso-8859-6',
+    'ecma-114':            'iso-8859-6',
+    'iso-8859-6':          'iso-8859-6',
+    'iso-8859-6-e':        'iso-8859-6',
+    'iso-8859-6-i':        'iso-8859-6',
+    'iso-ir-127':          'iso-8859-6',
+    'iso8859-6':           'iso-8859-6',
+    'iso88596':            'iso-8859-6',
+    'iso_8859-6':          'iso-8859-6',
+    'iso_8859-6:1987':     'iso-8859-6',
+    'csisolatingreek':     'iso-8859-7',
+    'ecma-118':            'iso-8859-7',
+    'elot_928':            'iso-8859-7',
+    'greek':               'iso-8859-7',
+    'greek8':              'iso-8859-7',
+    'iso-8859-7':          'iso-8859-7',
+    'iso-ir-126':          'iso-8859-7',
+    'iso8859-7':           'iso-8859-7',
+    'iso88597':            'iso-8859-7',
+    'iso_8859-7':          'iso-8859-7',
+    'iso_8859-7:1987':     'iso-8859-7',
+    'sun_eu_greek':        'iso-8859-7',
+    'csiso88598e':         'iso-8859-8',
+    'csisolatinhebrew':    'iso-8859-8',
+    'hebrew':              'iso-8859-8',
+    'iso-8859-8':          'iso-8859-8',
+    'iso-8859-8-e':        'iso-8859-8',
+    'iso-ir-138':          'iso-8859-8',
+    'iso8859-8':           'iso-8859-8',
+    'iso88598':            'iso-8859-8',
+    'iso_8859-8':          'iso-8859-8',
+    'iso_8859-8:1988':     'iso-8859-8',
+    'visual':              'iso-8859-8',
+    'csiso88598i':         'iso-8859-8-i',
+    'iso-8859-8-i':        'iso-8859-8-i',
+    'logical':             'iso-8859-8-i',
+    'csisolatin6':         'iso-8859-10',
+    'iso-8859-10':         'iso-8859-10',
+    'iso-ir-157':          'iso-8859-10',
+    'iso8859-10':          'iso-8859-10',
+    'iso885910':           'iso-8859-10',
+    'l6':                  'iso-8859-10',
+    'latin6':              'iso-8859-10',
+    'iso-8859-13':         'iso-8859-13',
+    'iso8859-13':          'iso-8859-13',
+    'iso885913':           'iso-8859-13',
+    'iso-8859-14':         'iso-8859-14',
+    'iso8859-14':          'iso-8859-14',
+    'iso885914':           'iso-8859-14',
+    'csisolatin9':         'iso-8859-15',
+    'iso-8859-15':         'iso-8859-15',
+    'iso8859-15':          'iso-8859-15',
+    'iso885915':           'iso-8859-15',
+    'iso_8859-15':         'iso-8859-15',
+    'l9':                  'iso-8859-15',
+    'iso-8859-16':         'iso-8859-16',
+    'cskoi8r':             'koi8-r',
+    'koi':                 'koi8-r',
+    'koi8':                'koi8-r',
+    'koi8-r':              'koi8-r',
+    'koi8_r':              'koi8-r',
+    'koi8-u':              'koi8-u',
+    'csmacintosh':         'macintosh',
+    'mac':                 'macintosh',
+    'macintosh':           'macintosh',
+    'x-mac-roman':         'macintosh',
+    'dos-874':             'windows-874',
+    'iso-8859-11':         'windows-874',
+    'iso8859-11':          'windows-874',
+    'iso885911':           'windows-874',
+    'tis-620':             'windows-874',
+    'windows-874':         'windows-874',
+    'cp1250':              'windows-1250',
+    'windows-1250':        'windows-1250',
+    'x-cp1250':            'windows-1250',
+    'cp1251':              'windows-1251',
+    'windows-1251':        'windows-1251',
+    'x-cp1251':            'windows-1251',
+    'ansi_x3.4-1968':      'windows-1252',
+    'ascii':               'windows-1252',
+    'cp1252':              'windows-1252',
+    'cp819':               'windows-1252',
+    'csisolatin1':         'windows-1252',
+    'ibm819':              'windows-1252',
+    'iso-8859-1':          'windows-1252',
+    'iso-ir-100':          'windows-1252',
+    'iso8859-1':           'windows-1252',
+    'iso88591':            'windows-1252',
+    'iso_8859-1':          'windows-1252',
+    'iso_8859-1:1987':     'windows-1252',
+    'l1':                  'windows-1252',
+    'latin1':              'windows-1252',
+    'us-ascii':            'windows-1252',
+    'windows-1252':        'windows-1252',
+    'x-cp1252':            'windows-1252',
+    'cp1253':              'windows-1253',
+    'windows-1253':        'windows-1253',
+    'x-cp1253':            'windows-1253',
+    'cp1254':              'windows-1254',
+    'csisolatin5':         'windows-1254',
+    'iso-8859-9':          'windows-1254',
+    'iso-ir-148':          'windows-1254',
+    'iso8859-9':           'windows-1254',
+    'iso88599':            'windows-1254',
+    'iso_8859-9':          'windows-1254',
+    'iso_8859-9:1989':     'windows-1254',
+    'l5':                  'windows-1254',
+    'latin5':              'windows-1254',
+    'windows-1254':        'windows-1254',
+    'x-cp1254':            'windows-1254',
+    'cp1255':              'windows-1255',
+    'windows-1255':        'windows-1255',
+    'x-cp1255':            'windows-1255',
+    'cp1256':              'windows-1256',
+    'windows-1256':        'windows-1256',
+    'x-cp1256':            'windows-1256',
+    'cp1257':              'windows-1257',
+    'windows-1257':        'windows-1257',
+    'x-cp1257':            'windows-1257',
+    'cp1258':              'windows-1258',
+    'windows-1258':        'windows-1258',
+    'x-cp1258':            'windows-1258',
+    'x-mac-cyrillic':      'x-mac-cyrillic',
+    'x-mac-ukrainian':     'x-mac-cyrillic',
+    'chinese':             'gbk',
+    'csgb2312':            'gbk',
+    'csiso58gb231280':     'gbk',
+    'gb2312':              'gbk',
+    'gb_2312':             'gbk',
+    'gb_2312-80':          'gbk',
+    'gbk':                 'gbk',
+    'iso-ir-58':           'gbk',
+    'x-gbk':               'gbk',
+    'gb18030':             'gb18030',
+    'hz-gb-2312':          'hz-gb-2312',
+    'big5':                'big5',
+    'big5-hkscs':          'big5',
+    'cn-big5':             'big5',
+    'csbig5':              'big5',
+    'x-x-big5':            'big5',
+    'cseucpkdfmtjapanese': 'euc-jp',
+    'euc-jp':              'euc-jp',
+    'x-euc-jp':            'euc-jp',
+    'csiso2022jp':         'iso-2022-jp',
+    'iso-2022-jp':         'iso-2022-jp',
+    'csshiftjis':          'shift_jis',
+    'ms_kanji':            'shift_jis',
+    'shift-jis':           'shift_jis',
+    'shift_jis':           'shift_jis',
+    'sjis':                'shift_jis',
+    'windows-31j':         'shift_jis',
+    'x-sjis':              'shift_jis',
+    'cseuckr':             'euc-kr',
+    'csksc56011987':       'euc-kr',
+    'euc-kr':              'euc-kr',
+    'iso-ir-149':          'euc-kr',
+    'korean':              'euc-kr',
+    'ks_c_5601-1987':      'euc-kr',
+    'ks_c_5601-1989':      'euc-kr',
+    'ksc5601':             'euc-kr',
+    'ksc_5601':            'euc-kr',
+    'windows-949':         'euc-kr',
+    'csiso2022kr':         'iso-2022-kr',
+    'iso-2022-kr':         'iso-2022-kr',
+    'utf-16be':            'utf-16be',
+    'utf-16':              'utf-16le',
+    'utf-16le':            'utf-16le',
+    'x-user-defined':      'x-user-defined',
+}
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/mklabels.py b/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/mklabels.py
new file mode 100644
index 0000000..295dc92
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/mklabels.py
@@ -0,0 +1,59 @@
+"""
+
+    webencodings.mklabels
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Regenarate the webencodings.labels module.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+import json
+try:
+    from urllib import urlopen
+except ImportError:
+    from urllib.request import urlopen
+
+
+def assert_lower(string):
+    assert string == string.lower()
+    return string
+
+
+def generate(url):
+    parts = ['''\
+"""
+
+    webencodings.labels
+    ~~~~~~~~~~~~~~~~~~~
+
+    Map encoding labels to their name.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+# XXX Do not edit!
+# This file is automatically generated by mklabels.py
+
+LABELS = {
+''']
+    labels = [
+        (repr(assert_lower(label)).lstrip('u'),
+         repr(encoding['name']).lstrip('u'))
+        for category in json.loads(urlopen(url).read().decode('ascii'))
+        for encoding in category['encodings']
+        for label in encoding['labels']]
+    max_len = max(len(label) for label, name in labels)
+    parts.extend(
+        '    %s:%s %s,\n' % (label, ' ' * (max_len - len(label)), name)
+        for label, name in labels)
+    parts.append('}')
+    return ''.join(parts)
+
+
+if __name__ == '__main__':
+    print(generate('http://encoding.spec.whatwg.org/encodings.json'))
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/tests.py b/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/tests.py
new file mode 100644
index 0000000..e12c10d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/tests.py
@@ -0,0 +1,153 @@
+# coding: utf-8
+"""
+
+    webencodings.tests
+    ~~~~~~~~~~~~~~~~~~
+
+    A basic test suite for Encoding.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+from __future__ import unicode_literals
+
+from . import (lookup, LABELS, decode, encode, iter_decode, iter_encode,
+               IncrementalDecoder, IncrementalEncoder, UTF8)
+
+
+def assert_raises(exception, function, *args, **kwargs):
+    try:
+        function(*args, **kwargs)
+    except exception:
+        return
+    else:  # pragma: no cover
+        raise AssertionError('Did not raise %s.' % exception)
+
+
+def test_labels():
+    assert lookup('utf-8').name == 'utf-8'
+    assert lookup('Utf-8').name == 'utf-8'
+    assert lookup('UTF-8').name == 'utf-8'
+    assert lookup('utf8').name == 'utf-8'
+    assert lookup('utf8').name == 'utf-8'
+    assert lookup('utf8 ').name == 'utf-8'
+    assert lookup(' \r\nutf8\t').name == 'utf-8'
+    assert lookup('u8') is None  # Python label.
+    assert lookup('utf-8 ') is None  # Non-ASCII white space.
+
+    assert lookup('US-ASCII').name == 'windows-1252'
+    assert lookup('iso-8859-1').name == 'windows-1252'
+    assert lookup('latin1').name == 'windows-1252'
+    assert lookup('LATIN1').name == 'windows-1252'
+    assert lookup('latin-1') is None
+    assert lookup('LATİN1') is None  # ASCII-only case insensitivity.
+
+
+def test_all_labels():
+    for label in LABELS:
+        assert decode(b'', label) == ('', lookup(label))
+        assert encode('', label) == b''
+        for repeat in [0, 1, 12]:
+            output, _ = iter_decode([b''] * repeat, label)
+            assert list(output) == []
+            assert list(iter_encode([''] * repeat, label)) == []
+        decoder = IncrementalDecoder(label)
+        assert decoder.decode(b'') == ''
+        assert decoder.decode(b'', final=True) == ''
+        encoder = IncrementalEncoder(label)
+        assert encoder.encode('') == b''
+        assert encoder.encode('', final=True) == b''
+    # All encoding names are valid labels too:
+    for name in set(LABELS.values()):
+        assert lookup(name).name == name
+
+
+def test_invalid_label():
+    assert_raises(LookupError, decode, b'\xEF\xBB\xBF\xc3\xa9', 'invalid')
+    assert_raises(LookupError, encode, 'é', 'invalid')
+    assert_raises(LookupError, iter_decode, [], 'invalid')
+    assert_raises(LookupError, iter_encode, [], 'invalid')
+    assert_raises(LookupError, IncrementalDecoder, 'invalid')
+    assert_raises(LookupError, IncrementalEncoder, 'invalid')
+
+
+def test_decode():
+    assert decode(b'\x80', 'latin1') == ('€', lookup('latin1'))
+    assert decode(b'\x80', lookup('latin1')) == ('€', lookup('latin1'))
+    assert decode(b'\xc3\xa9', 'utf8') == ('é', lookup('utf8'))
+    assert decode(b'\xc3\xa9', UTF8) == ('é', lookup('utf8'))
+    assert decode(b'\xc3\xa9', 'ascii') == ('é', lookup('ascii'))
+    assert decode(b'\xEF\xBB\xBF\xc3\xa9', 'ascii') == ('é', lookup('utf8'))  # UTF-8 with BOM
+
+    assert decode(b'\xFE\xFF\x00\xe9', 'ascii') == ('é', lookup('utf-16be'))  # UTF-16-BE with BOM
+    assert decode(b'\xFF\xFE\xe9\x00', 'ascii') == ('é', lookup('utf-16le'))  # UTF-16-LE with BOM
+    assert decode(b'\xFE\xFF\xe9\x00', 'ascii') == ('\ue900', lookup('utf-16be'))
+    assert decode(b'\xFF\xFE\x00\xe9', 'ascii') == ('\ue900', lookup('utf-16le'))
+
+    assert decode(b'\x00\xe9', 'UTF-16BE') == ('é', lookup('utf-16be'))
+    assert decode(b'\xe9\x00', 'UTF-16LE') == ('é', lookup('utf-16le'))
+    assert decode(b'\xe9\x00', 'UTF-16') == ('é', lookup('utf-16le'))
+
+    assert decode(b'\xe9\x00', 'UTF-16BE') == ('\ue900', lookup('utf-16be'))
+    assert decode(b'\x00\xe9', 'UTF-16LE') == ('\ue900', lookup('utf-16le'))
+    assert decode(b'\x00\xe9', 'UTF-16') == ('\ue900', lookup('utf-16le'))
+
+
+def test_encode():
+    assert encode('é', 'latin1') == b'\xe9'
+    assert encode('é', 'utf8') == b'\xc3\xa9'
+    assert encode('é', 'utf8') == b'\xc3\xa9'
+    assert encode('é', 'utf-16') == b'\xe9\x00'
+    assert encode('é', 'utf-16le') == b'\xe9\x00'
+    assert encode('é', 'utf-16be') == b'\x00\xe9'
+
+
+def test_iter_decode():
+    def iter_decode_to_string(input, fallback_encoding):
+        output, _encoding = iter_decode(input, fallback_encoding)
+        return ''.join(output)
+    assert iter_decode_to_string([], 'latin1') == ''
+    assert iter_decode_to_string([b''], 'latin1') == ''
+    assert iter_decode_to_string([b'\xe9'], 'latin1') == 'é'
+    assert iter_decode_to_string([b'hello'], 'latin1') == 'hello'
+    assert iter_decode_to_string([b'he', b'llo'], 'latin1') == 'hello'
+    assert iter_decode_to_string([b'hell', b'o'], 'latin1') == 'hello'
+    assert iter_decode_to_string([b'\xc3\xa9'], 'latin1') == 'é'
+    assert iter_decode_to_string([b'\xEF\xBB\xBF\xc3\xa9'], 'latin1') == 'é'
+    assert iter_decode_to_string([
+        b'\xEF\xBB\xBF', b'\xc3', b'\xa9'], 'latin1') == 'é'
+    assert iter_decode_to_string([
+        b'\xEF\xBB\xBF', b'a', b'\xc3'], 'latin1') == 'a\uFFFD'
+    assert iter_decode_to_string([
+        b'', b'\xEF', b'', b'', b'\xBB\xBF\xc3', b'\xa9'], 'latin1') == 'é'
+    assert iter_decode_to_string([b'\xEF\xBB\xBF'], 'latin1') == ''
+    assert iter_decode_to_string([b'\xEF\xBB'], 'latin1') == 'ï»'
+    assert iter_decode_to_string([b'\xFE\xFF\x00\xe9'], 'latin1') == 'é'
+    assert iter_decode_to_string([b'\xFF\xFE\xe9\x00'], 'latin1') == 'é'
+    assert iter_decode_to_string([
+        b'', b'\xFF', b'', b'', b'\xFE\xe9', b'\x00'], 'latin1') == 'é'
+    assert iter_decode_to_string([
+        b'', b'h\xe9', b'llo'], 'x-user-defined') == 'h\uF7E9llo'
+
+
+def test_iter_encode():
+    assert b''.join(iter_encode([], 'latin1')) == b''
+    assert b''.join(iter_encode([''], 'latin1')) == b''
+    assert b''.join(iter_encode(['é'], 'latin1')) == b'\xe9'
+    assert b''.join(iter_encode(['', 'é', '', ''], 'latin1')) == b'\xe9'
+    assert b''.join(iter_encode(['', 'é', '', ''], 'utf-16')) == b'\xe9\x00'
+    assert b''.join(iter_encode(['', 'é', '', ''], 'utf-16le')) == b'\xe9\x00'
+    assert b''.join(iter_encode(['', 'é', '', ''], 'utf-16be')) == b'\x00\xe9'
+    assert b''.join(iter_encode([
+        '', 'h\uF7E9', '', 'llo'], 'x-user-defined')) == b'h\xe9llo'
+
+
+def test_x_user_defined():
+    encoded = b'2,\x0c\x0b\x1aO\xd9#\xcb\x0f\xc9\xbbt\xcf\xa8\xca'
+    decoded = '2,\x0c\x0b\x1aO\uf7d9#\uf7cb\x0f\uf7c9\uf7bbt\uf7cf\uf7a8\uf7ca'
+    encoded = b'aa'
+    decoded = 'aa'
+    assert decode(encoded, 'x-user-defined') == (decoded, lookup('x-user-defined'))
+    assert encode(decoded, 'x-user-defined') == encoded
diff --git a/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/x_user_defined.py b/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/x_user_defined.py
new file mode 100644
index 0000000..d16e326
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pip/_vendor/webencodings/x_user_defined.py
@@ -0,0 +1,325 @@
+# coding: utf-8
+"""
+
+    webencodings.x_user_defined
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    An implementation of the x-user-defined encoding.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+from __future__ import unicode_literals
+
+import codecs
+
+
+### Codec APIs
+
+class Codec(codecs.Codec):
+
+    def encode(self, input, errors='strict'):
+        return codecs.charmap_encode(input, errors, encoding_table)
+
+    def decode(self, input, errors='strict'):
+        return codecs.charmap_decode(input, errors, decoding_table)
+
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input, final=False):
+        return codecs.charmap_encode(input, self.errors, encoding_table)[0]
+
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input, final=False):
+        return codecs.charmap_decode(input, self.errors, decoding_table)[0]
+
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    pass
+
+
+class StreamReader(Codec, codecs.StreamReader):
+    pass
+
+
+### encodings module API
+
+codec_info = codecs.CodecInfo(
+    name='x-user-defined',
+    encode=Codec().encode,
+    decode=Codec().decode,
+    incrementalencoder=IncrementalEncoder,
+    incrementaldecoder=IncrementalDecoder,
+    streamreader=StreamReader,
+    streamwriter=StreamWriter,
+)
+
+
+### Decoding Table
+
+# Python 3:
+# for c in range(256): print('    %r' % chr(c if c < 128 else c + 0xF700))
+decoding_table = (
+    '\x00'
+    '\x01'
+    '\x02'
+    '\x03'
+    '\x04'
+    '\x05'
+    '\x06'
+    '\x07'
+    '\x08'
+    '\t'
+    '\n'
+    '\x0b'
+    '\x0c'
+    '\r'
+    '\x0e'
+    '\x0f'
+    '\x10'
+    '\x11'
+    '\x12'
+    '\x13'
+    '\x14'
+    '\x15'
+    '\x16'
+    '\x17'
+    '\x18'
+    '\x19'
+    '\x1a'
+    '\x1b'
+    '\x1c'
+    '\x1d'
+    '\x1e'
+    '\x1f'
+    ' '
+    '!'
+    '"'
+    '#'
+    '$'
+    '%'
+    '&'
+    "'"
+    '('
+    ')'
+    '*'
+    '+'
+    ','
+    '-'
+    '.'
+    '/'
+    '0'
+    '1'
+    '2'
+    '3'
+    '4'
+    '5'
+    '6'
+    '7'
+    '8'
+    '9'
+    ':'
+    ';'
+    '<'
+    '='
+    '>'
+    '?'
+    '@'
+    'A'
+    'B'
+    'C'
+    'D'
+    'E'
+    'F'
+    'G'
+    'H'
+    'I'
+    'J'
+    'K'
+    'L'
+    'M'
+    'N'
+    'O'
+    'P'
+    'Q'
+    'R'
+    'S'
+    'T'
+    'U'
+    'V'
+    'W'
+    'X'
+    'Y'
+    'Z'
+    '['
+    '\\'
+    ']'
+    '^'
+    '_'
+    '`'
+    'a'
+    'b'
+    'c'
+    'd'
+    'e'
+    'f'
+    'g'
+    'h'
+    'i'
+    'j'
+    'k'
+    'l'
+    'm'
+    'n'
+    'o'
+    'p'
+    'q'
+    'r'
+    's'
+    't'
+    'u'
+    'v'
+    'w'
+    'x'
+    'y'
+    'z'
+    '{'
+    '|'
+    '}'
+    '~'
+    '\x7f'
+    '\uf780'
+    '\uf781'
+    '\uf782'
+    '\uf783'
+    '\uf784'
+    '\uf785'
+    '\uf786'
+    '\uf787'
+    '\uf788'
+    '\uf789'
+    '\uf78a'
+    '\uf78b'
+    '\uf78c'
+    '\uf78d'
+    '\uf78e'
+    '\uf78f'
+    '\uf790'
+    '\uf791'
+    '\uf792'
+    '\uf793'
+    '\uf794'
+    '\uf795'
+    '\uf796'
+    '\uf797'
+    '\uf798'
+    '\uf799'
+    '\uf79a'
+    '\uf79b'
+    '\uf79c'
+    '\uf79d'
+    '\uf79e'
+    '\uf79f'
+    '\uf7a0'
+    '\uf7a1'
+    '\uf7a2'
+    '\uf7a3'
+    '\uf7a4'
+    '\uf7a5'
+    '\uf7a6'
+    '\uf7a7'
+    '\uf7a8'
+    '\uf7a9'
+    '\uf7aa'
+    '\uf7ab'
+    '\uf7ac'
+    '\uf7ad'
+    '\uf7ae'
+    '\uf7af'
+    '\uf7b0'
+    '\uf7b1'
+    '\uf7b2'
+    '\uf7b3'
+    '\uf7b4'
+    '\uf7b5'
+    '\uf7b6'
+    '\uf7b7'
+    '\uf7b8'
+    '\uf7b9'
+    '\uf7ba'
+    '\uf7bb'
+    '\uf7bc'
+    '\uf7bd'
+    '\uf7be'
+    '\uf7bf'
+    '\uf7c0'
+    '\uf7c1'
+    '\uf7c2'
+    '\uf7c3'
+    '\uf7c4'
+    '\uf7c5'
+    '\uf7c6'
+    '\uf7c7'
+    '\uf7c8'
+    '\uf7c9'
+    '\uf7ca'
+    '\uf7cb'
+    '\uf7cc'
+    '\uf7cd'
+    '\uf7ce'
+    '\uf7cf'
+    '\uf7d0'
+    '\uf7d1'
+    '\uf7d2'
+    '\uf7d3'
+    '\uf7d4'
+    '\uf7d5'
+    '\uf7d6'
+    '\uf7d7'
+    '\uf7d8'
+    '\uf7d9'
+    '\uf7da'
+    '\uf7db'
+    '\uf7dc'
+    '\uf7dd'
+    '\uf7de'
+    '\uf7df'
+    '\uf7e0'
+    '\uf7e1'
+    '\uf7e2'
+    '\uf7e3'
+    '\uf7e4'
+    '\uf7e5'
+    '\uf7e6'
+    '\uf7e7'
+    '\uf7e8'
+    '\uf7e9'
+    '\uf7ea'
+    '\uf7eb'
+    '\uf7ec'
+    '\uf7ed'
+    '\uf7ee'
+    '\uf7ef'
+    '\uf7f0'
+    '\uf7f1'
+    '\uf7f2'
+    '\uf7f3'
+    '\uf7f4'
+    '\uf7f5'
+    '\uf7f6'
+    '\uf7f7'
+    '\uf7f8'
+    '\uf7f9'
+    '\uf7fa'
+    '\uf7fb'
+    '\uf7fc'
+    '\uf7fd'
+    '\uf7fe'
+    '\uf7ff'
+)
+
+### Encoding table
+encoding_table = codecs.charmap_build(decoding_table)
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/__init__.py b/myenv/lib/python3.9/site-packages/pkg_resources/__init__.py
new file mode 100644
index 0000000..5927ef0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/__init__.py
@@ -0,0 +1,3302 @@
+# coding: utf-8
+"""
+Package resource API
+--------------------
+
+A resource is a logical file contained within a package, or a logical
+subdirectory thereof.  The package resource API expects resource names
+to have their path parts separated with ``/``, *not* whatever the local
+path separator is.  Do not use os.path operations to manipulate resource
+names being passed into the API.
+
+The package resource API is designed to work with normal filesystem packages,
+.egg files, and unpacked .egg files.  It can also work in a limited way with
+.zip files and with custom PEP 302 loaders that support the ``get_data()``
+method.
+"""
+
+from __future__ import absolute_import
+
+import sys
+import os
+import io
+import time
+import re
+import types
+import zipfile
+import zipimport
+import warnings
+import stat
+import functools
+import pkgutil
+import operator
+import platform
+import collections
+import plistlib
+import email.parser
+import errno
+import tempfile
+import textwrap
+import itertools
+import inspect
+import ntpath
+import posixpath
+from pkgutil import get_importer
+
+try:
+    import _imp
+except ImportError:
+    # Python 3.2 compatibility
+    import imp as _imp
+
+try:
+    FileExistsError
+except NameError:
+    FileExistsError = OSError
+
+from pkg_resources.extern import six
+from pkg_resources.extern.six.moves import map, filter
+
+# capture these to bypass sandboxing
+from os import utime
+try:
+    from os import mkdir, rename, unlink
+    WRITE_SUPPORT = True
+except ImportError:
+    # no write support, probably under GAE
+    WRITE_SUPPORT = False
+
+from os import open as os_open
+from os.path import isdir, split
+
+try:
+    import importlib.machinery as importlib_machinery
+    # access attribute to force import under delayed import mechanisms.
+    importlib_machinery.__name__
+except ImportError:
+    importlib_machinery = None
+
+from pkg_resources.extern import appdirs
+from pkg_resources.extern import packaging
+__import__('pkg_resources.extern.packaging.version')
+__import__('pkg_resources.extern.packaging.specifiers')
+__import__('pkg_resources.extern.packaging.requirements')
+__import__('pkg_resources.extern.packaging.markers')
+
+
+__metaclass__ = type
+
+
+if (3, 0) < sys.version_info < (3, 5):
+    raise RuntimeError("Python 3.5 or later is required")
+
+if six.PY2:
+    # Those builtin exceptions are only defined in Python 3
+    PermissionError = None
+    NotADirectoryError = None
+
+# declare some globals that will be defined later to
+# satisfy the linters.
+require = None
+working_set = None
+add_activation_listener = None
+resources_stream = None
+cleanup_resources = None
+resource_dir = None
+resource_stream = None
+set_extraction_path = None
+resource_isdir = None
+resource_string = None
+iter_entry_points = None
+resource_listdir = None
+resource_filename = None
+resource_exists = None
+_distribution_finders = None
+_namespace_handlers = None
+_namespace_packages = None
+
+
+class PEP440Warning(RuntimeWarning):
+    """
+    Used when there is an issue with a version or specifier not complying with
+    PEP 440.
+    """
+
+
+def parse_version(v):
+    try:
+        return packaging.version.Version(v)
+    except packaging.version.InvalidVersion:
+        return packaging.version.LegacyVersion(v)
+
+
+_state_vars = {}
+
+
+def _declare_state(vartype, **kw):
+    globals().update(kw)
+    _state_vars.update(dict.fromkeys(kw, vartype))
+
+
+def __getstate__():
+    state = {}
+    g = globals()
+    for k, v in _state_vars.items():
+        state[k] = g['_sget_' + v](g[k])
+    return state
+
+
+def __setstate__(state):
+    g = globals()
+    for k, v in state.items():
+        g['_sset_' + _state_vars[k]](k, g[k], v)
+    return state
+
+
+def _sget_dict(val):
+    return val.copy()
+
+
+def _sset_dict(key, ob, state):
+    ob.clear()
+    ob.update(state)
+
+
+def _sget_object(val):
+    return val.__getstate__()
+
+
+def _sset_object(key, ob, state):
+    ob.__setstate__(state)
+
+
+_sget_none = _sset_none = lambda *args: None
+
+
+def get_supported_platform():
+    """Return this platform's maximum compatible version.
+
+    distutils.util.get_platform() normally reports the minimum version
+    of macOS that would be required to *use* extensions produced by
+    distutils.  But what we want when checking compatibility is to know the
+    version of macOS that we are *running*.  To allow usage of packages that
+    explicitly require a newer version of macOS, we must also know the
+    current version of the OS.
+
+    If this condition occurs for any other platform with a version in its
+    platform strings, this function should be extended accordingly.
+    """
+    plat = get_build_platform()
+    m = macosVersionString.match(plat)
+    if m is not None and sys.platform == "darwin":
+        try:
+            plat = 'macosx-%s-%s' % ('.'.join(_macos_vers()[:2]), m.group(3))
+        except ValueError:
+            # not macOS
+            pass
+    return plat
+
+
+__all__ = [
+    # Basic resource access and distribution/entry point discovery
+    'require', 'run_script', 'get_provider', 'get_distribution',
+    'load_entry_point', 'get_entry_map', 'get_entry_info',
+    'iter_entry_points',
+    'resource_string', 'resource_stream', 'resource_filename',
+    'resource_listdir', 'resource_exists', 'resource_isdir',
+
+    # Environmental control
+    'declare_namespace', 'working_set', 'add_activation_listener',
+    'find_distributions', 'set_extraction_path', 'cleanup_resources',
+    'get_default_cache',
+
+    # Primary implementation classes
+    'Environment', 'WorkingSet', 'ResourceManager',
+    'Distribution', 'Requirement', 'EntryPoint',
+
+    # Exceptions
+    'ResolutionError', 'VersionConflict', 'DistributionNotFound',
+    'UnknownExtra', 'ExtractionError',
+
+    # Warnings
+    'PEP440Warning',
+
+    # Parsing functions and string utilities
+    'parse_requirements', 'parse_version', 'safe_name', 'safe_version',
+    'get_platform', 'compatible_platforms', 'yield_lines', 'split_sections',
+    'safe_extra', 'to_filename', 'invalid_marker', 'evaluate_marker',
+
+    # filesystem utilities
+    'ensure_directory', 'normalize_path',
+
+    # Distribution "precedence" constants
+    'EGG_DIST', 'BINARY_DIST', 'SOURCE_DIST', 'CHECKOUT_DIST', 'DEVELOP_DIST',
+
+    # "Provider" interfaces, implementations, and registration/lookup APIs
+    'IMetadataProvider', 'IResourceProvider', 'FileMetadata',
+    'PathMetadata', 'EggMetadata', 'EmptyProvider', 'empty_provider',
+    'NullProvider', 'EggProvider', 'DefaultProvider', 'ZipProvider',
+    'register_finder', 'register_namespace_handler', 'register_loader_type',
+    'fixup_namespace_packages', 'get_importer',
+
+    # Warnings
+    'PkgResourcesDeprecationWarning',
+
+    # Deprecated/backward compatibility only
+    'run_main', 'AvailableDistributions',
+]
+
+
+class ResolutionError(Exception):
+    """Abstract base for dependency resolution errors"""
+
+    def __repr__(self):
+        return self.__class__.__name__ + repr(self.args)
+
+
+class VersionConflict(ResolutionError):
+    """
+    An already-installed version conflicts with the requested version.
+
+    Should be initialized with the installed Distribution and the requested
+    Requirement.
+    """
+
+    _template = "{self.dist} is installed but {self.req} is required"
+
+    @property
+    def dist(self):
+        return self.args[0]
+
+    @property
+    def req(self):
+        return self.args[1]
+
+    def report(self):
+        return self._template.format(**locals())
+
+    def with_context(self, required_by):
+        """
+        If required_by is non-empty, return a version of self that is a
+        ContextualVersionConflict.
+        """
+        if not required_by:
+            return self
+        args = self.args + (required_by,)
+        return ContextualVersionConflict(*args)
+
+
+class ContextualVersionConflict(VersionConflict):
+    """
+    A VersionConflict that accepts a third parameter, the set of the
+    requirements that required the installed Distribution.
+    """
+
+    _template = VersionConflict._template + ' by {self.required_by}'
+
+    @property
+    def required_by(self):
+        return self.args[2]
+
+
+class DistributionNotFound(ResolutionError):
+    """A requested distribution was not found"""
+
+    _template = ("The '{self.req}' distribution was not found "
+                 "and is required by {self.requirers_str}")
+
+    @property
+    def req(self):
+        return self.args[0]
+
+    @property
+    def requirers(self):
+        return self.args[1]
+
+    @property
+    def requirers_str(self):
+        if not self.requirers:
+            return 'the application'
+        return ', '.join(self.requirers)
+
+    def report(self):
+        return self._template.format(**locals())
+
+    def __str__(self):
+        return self.report()
+
+
+class UnknownExtra(ResolutionError):
+    """Distribution doesn't have an "extra feature" of the given name"""
+
+
+_provider_factories = {}
+
+PY_MAJOR = '{}.{}'.format(*sys.version_info)
+EGG_DIST = 3
+BINARY_DIST = 2
+SOURCE_DIST = 1
+CHECKOUT_DIST = 0
+DEVELOP_DIST = -1
+
+
+def register_loader_type(loader_type, provider_factory):
+    """Register `provider_factory` to make providers for `loader_type`
+
+    `loader_type` is the type or class of a PEP 302 ``module.__loader__``,
+    and `provider_factory` is a function that, passed a *module* object,
+    returns an ``IResourceProvider`` for that module.
+    """
+    _provider_factories[loader_type] = provider_factory
+
+
+def get_provider(moduleOrReq):
+    """Return an IResourceProvider for the named module or requirement"""
+    if isinstance(moduleOrReq, Requirement):
+        return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0]
+    try:
+        module = sys.modules[moduleOrReq]
+    except KeyError:
+        __import__(moduleOrReq)
+        module = sys.modules[moduleOrReq]
+    loader = getattr(module, '__loader__', None)
+    return _find_adapter(_provider_factories, loader)(module)
+
+
+def _macos_vers(_cache=[]):
+    if not _cache:
+        version = platform.mac_ver()[0]
+        # fallback for MacPorts
+        if version == '':
+            plist = '/System/Library/CoreServices/SystemVersion.plist'
+            if os.path.exists(plist):
+                if hasattr(plistlib, 'readPlist'):
+                    plist_content = plistlib.readPlist(plist)
+                    if 'ProductVersion' in plist_content:
+                        version = plist_content['ProductVersion']
+
+        _cache.append(version.split('.'))
+    return _cache[0]
+
+
+def _macos_arch(machine):
+    return {'PowerPC': 'ppc', 'Power_Macintosh': 'ppc'}.get(machine, machine)
+
+
+def get_build_platform():
+    """Return this platform's string for platform-specific distributions
+
+    XXX Currently this is the same as ``distutils.util.get_platform()``, but it
+    needs some hacks for Linux and macOS.
+    """
+    from sysconfig import get_platform
+
+    plat = get_platform()
+    if sys.platform == "darwin" and not plat.startswith('macosx-'):
+        try:
+            version = _macos_vers()
+            machine = os.uname()[4].replace(" ", "_")
+            return "macosx-%d.%d-%s" % (
+                int(version[0]), int(version[1]),
+                _macos_arch(machine),
+            )
+        except ValueError:
+            # if someone is running a non-Mac darwin system, this will fall
+            # through to the default implementation
+            pass
+    return plat
+
+
+macosVersionString = re.compile(r"macosx-(\d+)\.(\d+)-(.*)")
+darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)")
+# XXX backward compat
+get_platform = get_build_platform
+
+
+def compatible_platforms(provided, required):
+    """Can code for the `provided` platform run on the `required` platform?
+
+    Returns true if either platform is ``None``, or the platforms are equal.
+
+    XXX Needs compatibility checks for Linux and other unixy OSes.
+    """
+    if provided is None or required is None or provided == required:
+        # easy case
+        return True
+
+    # macOS special cases
+    reqMac = macosVersionString.match(required)
+    if reqMac:
+        provMac = macosVersionString.match(provided)
+
+        # is this a Mac package?
+        if not provMac:
+            # this is backwards compatibility for packages built before
+            # setuptools 0.6. All packages built after this point will
+            # use the new macOS designation.
+            provDarwin = darwinVersionString.match(provided)
+            if provDarwin:
+                dversion = int(provDarwin.group(1))
+                macosversion = "%s.%s" % (reqMac.group(1), reqMac.group(2))
+                if dversion == 7 and macosversion >= "10.3" or \
+                        dversion == 8 and macosversion >= "10.4":
+                    return True
+            # egg isn't macOS or legacy darwin
+            return False
+
+        # are they the same major version and machine type?
+        if provMac.group(1) != reqMac.group(1) or \
+                provMac.group(3) != reqMac.group(3):
+            return False
+
+        # is the required OS major update >= the provided one?
+        if int(provMac.group(2)) > int(reqMac.group(2)):
+            return False
+
+        return True
+
+    # XXX Linux and other platforms' special cases should go here
+    return False
+
+
+def run_script(dist_spec, script_name):
+    """Locate distribution `dist_spec` and run its `script_name` script"""
+    ns = sys._getframe(1).f_globals
+    name = ns['__name__']
+    ns.clear()
+    ns['__name__'] = name
+    require(dist_spec)[0].run_script(script_name, ns)
+
+
+# backward compatibility
+run_main = run_script
+
+
+def get_distribution(dist):
+    """Return a current distribution object for a Requirement or string"""
+    if isinstance(dist, six.string_types):
+        dist = Requirement.parse(dist)
+    if isinstance(dist, Requirement):
+        dist = get_provider(dist)
+    if not isinstance(dist, Distribution):
+        raise TypeError("Expected string, Requirement, or Distribution", dist)
+    return dist
+
+
+def load_entry_point(dist, group, name):
+    """Return `name` entry point of `group` for `dist` or raise ImportError"""
+    return get_distribution(dist).load_entry_point(group, name)
+
+
+def get_entry_map(dist, group=None):
+    """Return the entry point map for `group`, or the full entry map"""
+    return get_distribution(dist).get_entry_map(group)
+
+
+def get_entry_info(dist, group, name):
+    """Return the EntryPoint object for `group`+`name`, or ``None``"""
+    return get_distribution(dist).get_entry_info(group, name)
+
+
+class IMetadataProvider:
+    def has_metadata(name):
+        """Does the package's distribution contain the named metadata?"""
+
+    def get_metadata(name):
+        """The named metadata resource as a string"""
+
+    def get_metadata_lines(name):
+        """Yield named metadata resource as list of non-blank non-comment lines
+
+       Leading and trailing whitespace is stripped from each line, and lines
+       with ``#`` as the first non-blank character are omitted."""
+
+    def metadata_isdir(name):
+        """Is the named metadata a directory?  (like ``os.path.isdir()``)"""
+
+    def metadata_listdir(name):
+        """List of metadata names in the directory (like ``os.listdir()``)"""
+
+    def run_script(script_name, namespace):
+        """Execute the named script in the supplied namespace dictionary"""
+
+
+class IResourceProvider(IMetadataProvider):
+    """An object that provides access to package resources"""
+
+    def get_resource_filename(manager, resource_name):
+        """Return a true filesystem path for `resource_name`
+
+        `manager` must be an ``IResourceManager``"""
+
+    def get_resource_stream(manager, resource_name):
+        """Return a readable file-like object for `resource_name`
+
+        `manager` must be an ``IResourceManager``"""
+
+    def get_resource_string(manager, resource_name):
+        """Return a string containing the contents of `resource_name`
+
+        `manager` must be an ``IResourceManager``"""
+
+    def has_resource(resource_name):
+        """Does the package contain the named resource?"""
+
+    def resource_isdir(resource_name):
+        """Is the named resource a directory?  (like ``os.path.isdir()``)"""
+
+    def resource_listdir(resource_name):
+        """List of resource names in the directory (like ``os.listdir()``)"""
+
+
+class WorkingSet:
+    """A collection of active distributions on sys.path (or a similar list)"""
+
+    def __init__(self, entries=None):
+        """Create working set from list of path entries (default=sys.path)"""
+        self.entries = []
+        self.entry_keys = {}
+        self.by_key = {}
+        self.callbacks = []
+
+        if entries is None:
+            entries = sys.path
+
+        for entry in entries:
+            self.add_entry(entry)
+
+    @classmethod
+    def _build_master(cls):
+        """
+        Prepare the master working set.
+        """
+        ws = cls()
+        try:
+            from __main__ import __requires__
+        except ImportError:
+            # The main program does not list any requirements
+            return ws
+
+        # ensure the requirements are met
+        try:
+            ws.require(__requires__)
+        except VersionConflict:
+            return cls._build_from_requirements(__requires__)
+
+        return ws
+
+    @classmethod
+    def _build_from_requirements(cls, req_spec):
+        """
+        Build a working set from a requirement spec. Rewrites sys.path.
+        """
+        # try it without defaults already on sys.path
+        # by starting with an empty path
+        ws = cls([])
+        reqs = parse_requirements(req_spec)
+        dists = ws.resolve(reqs, Environment())
+        for dist in dists:
+            ws.add(dist)
+
+        # add any missing entries from sys.path
+        for entry in sys.path:
+            if entry not in ws.entries:
+                ws.add_entry(entry)
+
+        # then copy back to sys.path
+        sys.path[:] = ws.entries
+        return ws
+
+    def add_entry(self, entry):
+        """Add a path item to ``.entries``, finding any distributions on it
+
+        ``find_distributions(entry, True)`` is used to find distributions
+        corresponding to the path entry, and they are added.  `entry` is
+        always appended to ``.entries``, even if it is already present.
+        (This is because ``sys.path`` can contain the same value more than
+        once, and the ``.entries`` of the ``sys.path`` WorkingSet should always
+        equal ``sys.path``.)
+        """
+        self.entry_keys.setdefault(entry, [])
+        self.entries.append(entry)
+        for dist in find_distributions(entry, True):
+            self.add(dist, entry, False)
+
+    def __contains__(self, dist):
+        """True if `dist` is the active distribution for its project"""
+        return self.by_key.get(dist.key) == dist
+
+    def find(self, req):
+        """Find a distribution matching requirement `req`
+
+        If there is an active distribution for the requested project, this
+        returns it as long as it meets the version requirement specified by
+        `req`.  But, if there is an active distribution for the project and it
+        does *not* meet the `req` requirement, ``VersionConflict`` is raised.
+        If there is no active distribution for the requested project, ``None``
+        is returned.
+        """
+        dist = self.by_key.get(req.key)
+        if dist is not None and dist not in req:
+            # XXX add more info
+            raise VersionConflict(dist, req)
+        return dist
+
+    def iter_entry_points(self, group, name=None):
+        """Yield entry point objects from `group` matching `name`
+
+        If `name` is None, yields all entry points in `group` from all
+        distributions in the working set, otherwise only ones matching
+        both `group` and `name` are yielded (in distribution order).
+        """
+        return (
+            entry
+            for dist in self
+            for entry in dist.get_entry_map(group).values()
+            if name is None or name == entry.name
+        )
+
+    def run_script(self, requires, script_name):
+        """Locate distribution for `requires` and run `script_name` script"""
+        ns = sys._getframe(1).f_globals
+        name = ns['__name__']
+        ns.clear()
+        ns['__name__'] = name
+        self.require(requires)[0].run_script(script_name, ns)
+
+    def __iter__(self):
+        """Yield distributions for non-duplicate projects in the working set
+
+        The yield order is the order in which the items' path entries were
+        added to the working set.
+        """
+        seen = {}
+        for item in self.entries:
+            if item not in self.entry_keys:
+                # workaround a cache issue
+                continue
+
+            for key in self.entry_keys[item]:
+                if key not in seen:
+                    seen[key] = 1
+                    yield self.by_key[key]
+
+    def add(self, dist, entry=None, insert=True, replace=False):
+        """Add `dist` to working set, associated with `entry`
+
+        If `entry` is unspecified, it defaults to the ``.location`` of `dist`.
+        On exit from this routine, `entry` is added to the end of the working
+        set's ``.entries`` (if it wasn't already present).
+
+        `dist` is only added to the working set if it's for a project that
+        doesn't already have a distribution in the set, unless `replace=True`.
+        If it's added, any callbacks registered with the ``subscribe()`` method
+        will be called.
+        """
+        if insert:
+            dist.insert_on(self.entries, entry, replace=replace)
+
+        if entry is None:
+            entry = dist.location
+        keys = self.entry_keys.setdefault(entry, [])
+        keys2 = self.entry_keys.setdefault(dist.location, [])
+        if not replace and dist.key in self.by_key:
+            # ignore hidden distros
+            return
+
+        self.by_key[dist.key] = dist
+        if dist.key not in keys:
+            keys.append(dist.key)
+        if dist.key not in keys2:
+            keys2.append(dist.key)
+        self._added_new(dist)
+
+    def resolve(self, requirements, env=None, installer=None,
+                replace_conflicting=False, extras=None):
+        """List all distributions needed to (recursively) meet `requirements`
+
+        `requirements` must be a sequence of ``Requirement`` objects.  `env`,
+        if supplied, should be an ``Environment`` instance.  If
+        not supplied, it defaults to all distributions available within any
+        entry or distribution in the working set.  `installer`, if supplied,
+        will be invoked with each requirement that cannot be met by an
+        already-installed distribution; it should return a ``Distribution`` or
+        ``None``.
+
+        Unless `replace_conflicting=True`, raises a VersionConflict exception
+        if
+        any requirements are found on the path that have the correct name but
+        the wrong version.  Otherwise, if an `installer` is supplied it will be
+        invoked to obtain the correct version of the requirement and activate
+        it.
+
+        `extras` is a list of the extras to be used with these requirements.
+        This is important because extra requirements may look like `my_req;
+        extra = "my_extra"`, which would otherwise be interpreted as a purely
+        optional requirement.  Instead, we want to be able to assert that these
+        requirements are truly required.
+        """
+
+        # set up the stack
+        requirements = list(requirements)[::-1]
+        # set of processed requirements
+        processed = {}
+        # key -> dist
+        best = {}
+        to_activate = []
+
+        req_extras = _ReqExtras()
+
+        # Mapping of requirement to set of distributions that required it;
+        # useful for reporting info about conflicts.
+        required_by = collections.defaultdict(set)
+
+        while requirements:
+            # process dependencies breadth-first
+            req = requirements.pop(0)
+            if req in processed:
+                # Ignore cyclic or redundant dependencies
+                continue
+
+            if not req_extras.markers_pass(req, extras):
+                continue
+
+            dist = best.get(req.key)
+            if dist is None:
+                # Find the best distribution and add it to the map
+                dist = self.by_key.get(req.key)
+                if dist is None or (dist not in req and replace_conflicting):
+                    ws = self
+                    if env is None:
+                        if dist is None:
+                            env = Environment(self.entries)
+                        else:
+                            # Use an empty environment and workingset to avoid
+                            # any further conflicts with the conflicting
+                            # distribution
+                            env = Environment([])
+                            ws = WorkingSet([])
+                    dist = best[req.key] = env.best_match(
+                        req, ws, installer,
+                        replace_conflicting=replace_conflicting
+                    )
+                    if dist is None:
+                        requirers = required_by.get(req, None)
+                        raise DistributionNotFound(req, requirers)
+                to_activate.append(dist)
+            if dist not in req:
+                # Oops, the "best" so far conflicts with a dependency
+                dependent_req = required_by[req]
+                raise VersionConflict(dist, req).with_context(dependent_req)
+
+            # push the new requirements onto the stack
+            new_requirements = dist.requires(req.extras)[::-1]
+            requirements.extend(new_requirements)
+
+            # Register the new requirements needed by req
+            for new_requirement in new_requirements:
+                required_by[new_requirement].add(req.project_name)
+                req_extras[new_requirement] = req.extras
+
+            processed[req] = True
+
+        # return list of distros to activate
+        return to_activate
+
+    def find_plugins(
+            self, plugin_env, full_env=None, installer=None, fallback=True):
+        """Find all activatable distributions in `plugin_env`
+
+        Example usage::
+
+            distributions, errors = working_set.find_plugins(
+                Environment(plugin_dirlist)
+            )
+            # add plugins+libs to sys.path
+            map(working_set.add, distributions)
+            # display errors
+            print('Could not load', errors)
+
+        The `plugin_env` should be an ``Environment`` instance that contains
+        only distributions that are in the project's "plugin directory" or
+        directories. The `full_env`, if supplied, should be an ``Environment``
+        contains all currently-available distributions.  If `full_env` is not
+        supplied, one is created automatically from the ``WorkingSet`` this
+        method is called on, which will typically mean that every directory on
+        ``sys.path`` will be scanned for distributions.
+
+        `installer` is a standard installer callback as used by the
+        ``resolve()`` method. The `fallback` flag indicates whether we should
+        attempt to resolve older versions of a plugin if the newest version
+        cannot be resolved.
+
+        This method returns a 2-tuple: (`distributions`, `error_info`), where
+        `distributions` is a list of the distributions found in `plugin_env`
+        that were loadable, along with any other distributions that are needed
+        to resolve their dependencies.  `error_info` is a dictionary mapping
+        unloadable plugin distributions to an exception instance describing the
+        error that occurred. Usually this will be a ``DistributionNotFound`` or
+        ``VersionConflict`` instance.
+        """
+
+        plugin_projects = list(plugin_env)
+        # scan project names in alphabetic order
+        plugin_projects.sort()
+
+        error_info = {}
+        distributions = {}
+
+        if full_env is None:
+            env = Environment(self.entries)
+            env += plugin_env
+        else:
+            env = full_env + plugin_env
+
+        shadow_set = self.__class__([])
+        # put all our entries in shadow_set
+        list(map(shadow_set.add, self))
+
+        for project_name in plugin_projects:
+
+            for dist in plugin_env[project_name]:
+
+                req = [dist.as_requirement()]
+
+                try:
+                    resolvees = shadow_set.resolve(req, env, installer)
+
+                except ResolutionError as v:
+                    # save error info
+                    error_info[dist] = v
+                    if fallback:
+                        # try the next older version of project
+                        continue
+                    else:
+                        # give up on this project, keep going
+                        break
+
+                else:
+                    list(map(shadow_set.add, resolvees))
+                    distributions.update(dict.fromkeys(resolvees))
+
+                    # success, no need to try any more versions of this project
+                    break
+
+        distributions = list(distributions)
+        distributions.sort()
+
+        return distributions, error_info
+
+    def require(self, *requirements):
+        """Ensure that distributions matching `requirements` are activated
+
+        `requirements` must be a string or a (possibly-nested) sequence
+        thereof, specifying the distributions and versions required.  The
+        return value is a sequence of the distributions that needed to be
+        activated to fulfill the requirements; all relevant distributions are
+        included, even if they were already activated in this working set.
+        """
+        needed = self.resolve(parse_requirements(requirements))
+
+        for dist in needed:
+            self.add(dist)
+
+        return needed
+
+    def subscribe(self, callback, existing=True):
+        """Invoke `callback` for all distributions
+
+        If `existing=True` (default),
+        call on all existing ones, as well.
+        """
+        if callback in self.callbacks:
+            return
+        self.callbacks.append(callback)
+        if not existing:
+            return
+        for dist in self:
+            callback(dist)
+
+    def _added_new(self, dist):
+        for callback in self.callbacks:
+            callback(dist)
+
+    def __getstate__(self):
+        return (
+            self.entries[:], self.entry_keys.copy(), self.by_key.copy(),
+            self.callbacks[:]
+        )
+
+    def __setstate__(self, e_k_b_c):
+        entries, keys, by_key, callbacks = e_k_b_c
+        self.entries = entries[:]
+        self.entry_keys = keys.copy()
+        self.by_key = by_key.copy()
+        self.callbacks = callbacks[:]
+
+
+class _ReqExtras(dict):
+    """
+    Map each requirement to the extras that demanded it.
+    """
+
+    def markers_pass(self, req, extras=None):
+        """
+        Evaluate markers for req against each extra that
+        demanded it.
+
+        Return False if the req has a marker and fails
+        evaluation. Otherwise, return True.
+        """
+        extra_evals = (
+            req.marker.evaluate({'extra': extra})
+            for extra in self.get(req, ()) + (extras or (None,))
+        )
+        return not req.marker or any(extra_evals)
+
+
+class Environment:
+    """Searchable snapshot of distributions on a search path"""
+
+    def __init__(
+            self, search_path=None, platform=get_supported_platform(),
+            python=PY_MAJOR):
+        """Snapshot distributions available on a search path
+
+        Any distributions found on `search_path` are added to the environment.
+        `search_path` should be a sequence of ``sys.path`` items.  If not
+        supplied, ``sys.path`` is used.
+
+        `platform` is an optional string specifying the name of the platform
+        that platform-specific distributions must be compatible with.  If
+        unspecified, it defaults to the current platform.  `python` is an
+        optional string naming the desired version of Python (e.g. ``'3.6'``);
+        it defaults to the current version.
+
+        You may explicitly set `platform` (and/or `python`) to ``None`` if you
+        wish to map *all* distributions, not just those compatible with the
+        running platform or Python version.
+        """
+        self._distmap = {}
+        self.platform = platform
+        self.python = python
+        self.scan(search_path)
+
+    def can_add(self, dist):
+        """Is distribution `dist` acceptable for this environment?
+
+        The distribution must match the platform and python version
+        requirements specified when this environment was created, or False
+        is returned.
+        """
+        py_compat = (
+            self.python is None
+            or dist.py_version is None
+            or dist.py_version == self.python
+        )
+        return py_compat and compatible_platforms(dist.platform, self.platform)
+
+    def remove(self, dist):
+        """Remove `dist` from the environment"""
+        self._distmap[dist.key].remove(dist)
+
+    def scan(self, search_path=None):
+        """Scan `search_path` for distributions usable in this environment
+
+        Any distributions found are added to the environment.
+        `search_path` should be a sequence of ``sys.path`` items.  If not
+        supplied, ``sys.path`` is used.  Only distributions conforming to
+        the platform/python version defined at initialization are added.
+        """
+        if search_path is None:
+            search_path = sys.path
+
+        for item in search_path:
+            for dist in find_distributions(item):
+                self.add(dist)
+
+    def __getitem__(self, project_name):
+        """Return a newest-to-oldest list of distributions for `project_name`
+
+        Uses case-insensitive `project_name` comparison, assuming all the
+        project's distributions use their project's name converted to all
+        lowercase as their key.
+
+        """
+        distribution_key = project_name.lower()
+        return self._distmap.get(distribution_key, [])
+
+    def add(self, dist):
+        """Add `dist` if we ``can_add()`` it and it has not already been added
+        """
+        if self.can_add(dist) and dist.has_version():
+            dists = self._distmap.setdefault(dist.key, [])
+            if dist not in dists:
+                dists.append(dist)
+                dists.sort(key=operator.attrgetter('hashcmp'), reverse=True)
+
+    def best_match(
+            self, req, working_set, installer=None, replace_conflicting=False):
+        """Find distribution best matching `req` and usable on `working_set`
+
+        This calls the ``find(req)`` method of the `working_set` to see if a
+        suitable distribution is already active.  (This may raise
+        ``VersionConflict`` if an unsuitable version of the project is already
+        active in the specified `working_set`.)  If a suitable distribution
+        isn't active, this method returns the newest distribution in the
+        environment that meets the ``Requirement`` in `req`.  If no suitable
+        distribution is found, and `installer` is supplied, then the result of
+        calling the environment's ``obtain(req, installer)`` method will be
+        returned.
+        """
+        try:
+            dist = working_set.find(req)
+        except VersionConflict:
+            if not replace_conflicting:
+                raise
+            dist = None
+        if dist is not None:
+            return dist
+        for dist in self[req.key]:
+            if dist in req:
+                return dist
+        # try to download/install
+        return self.obtain(req, installer)
+
+    def obtain(self, requirement, installer=None):
+        """Obtain a distribution matching `requirement` (e.g. via download)
+
+        Obtain a distro that matches requirement (e.g. via download).  In the
+        base ``Environment`` class, this routine just returns
+        ``installer(requirement)``, unless `installer` is None, in which case
+        None is returned instead.  This method is a hook that allows subclasses
+        to attempt other ways of obtaining a distribution before falling back
+        to the `installer` argument."""
+        if installer is not None:
+            return installer(requirement)
+
+    def __iter__(self):
+        """Yield the unique project names of the available distributions"""
+        for key in self._distmap.keys():
+            if self[key]:
+                yield key
+
+    def __iadd__(self, other):
+        """In-place addition of a distribution or environment"""
+        if isinstance(other, Distribution):
+            self.add(other)
+        elif isinstance(other, Environment):
+            for project in other:
+                for dist in other[project]:
+                    self.add(dist)
+        else:
+            raise TypeError("Can't add %r to environment" % (other,))
+        return self
+
+    def __add__(self, other):
+        """Add an environment or distribution to an environment"""
+        new = self.__class__([], platform=None, python=None)
+        for env in self, other:
+            new += env
+        return new
+
+
+# XXX backward compatibility
+AvailableDistributions = Environment
+
+
+class ExtractionError(RuntimeError):
+    """An error occurred extracting a resource
+
+    The following attributes are available from instances of this exception:
+
+    manager
+        The resource manager that raised this exception
+
+    cache_path
+        The base directory for resource extraction
+
+    original_error
+        The exception instance that caused extraction to fail
+    """
+
+
+class ResourceManager:
+    """Manage resource extraction and packages"""
+    extraction_path = None
+
+    def __init__(self):
+        self.cached_files = {}
+
+    def resource_exists(self, package_or_requirement, resource_name):
+        """Does the named resource exist?"""
+        return get_provider(package_or_requirement).has_resource(resource_name)
+
+    def resource_isdir(self, package_or_requirement, resource_name):
+        """Is the named resource an existing directory?"""
+        return get_provider(package_or_requirement).resource_isdir(
+            resource_name
+        )
+
+    def resource_filename(self, package_or_requirement, resource_name):
+        """Return a true filesystem path for specified resource"""
+        return get_provider(package_or_requirement).get_resource_filename(
+            self, resource_name
+        )
+
+    def resource_stream(self, package_or_requirement, resource_name):
+        """Return a readable file-like object for specified resource"""
+        return get_provider(package_or_requirement).get_resource_stream(
+            self, resource_name
+        )
+
+    def resource_string(self, package_or_requirement, resource_name):
+        """Return specified resource as a string"""
+        return get_provider(package_or_requirement).get_resource_string(
+            self, resource_name
+        )
+
+    def resource_listdir(self, package_or_requirement, resource_name):
+        """List the contents of the named resource directory"""
+        return get_provider(package_or_requirement).resource_listdir(
+            resource_name
+        )
+
+    def extraction_error(self):
+        """Give an error message for problems extracting file(s)"""
+
+        old_exc = sys.exc_info()[1]
+        cache_path = self.extraction_path or get_default_cache()
+
+        tmpl = textwrap.dedent("""
+            Can't extract file(s) to egg cache
+
+            The following error occurred while trying to extract file(s)
+            to the Python egg cache:
+
+              {old_exc}
+
+            The Python egg cache directory is currently set to:
+
+              {cache_path}
+
+            Perhaps your account does not have write access to this directory?
+            You can change the cache directory by setting the PYTHON_EGG_CACHE
+            environment variable to point to an accessible directory.
+            """).lstrip()
+        err = ExtractionError(tmpl.format(**locals()))
+        err.manager = self
+        err.cache_path = cache_path
+        err.original_error = old_exc
+        raise err
+
+    def get_cache_path(self, archive_name, names=()):
+        """Return absolute location in cache for `archive_name` and `names`
+
+        The parent directory of the resulting path will be created if it does
+        not already exist.  `archive_name` should be the base filename of the
+        enclosing egg (which may not be the name of the enclosing zipfile!),
+        including its ".egg" extension.  `names`, if provided, should be a
+        sequence of path name parts "under" the egg's extraction location.
+
+        This method should only be called by resource providers that need to
+        obtain an extraction location, and only for names they intend to
+        extract, as it tracks the generated names for possible cleanup later.
+        """
+        extract_path = self.extraction_path or get_default_cache()
+        target_path = os.path.join(extract_path, archive_name + '-tmp', *names)
+        try:
+            _bypass_ensure_directory(target_path)
+        except Exception:
+            self.extraction_error()
+
+        self._warn_unsafe_extraction_path(extract_path)
+
+        self.cached_files[target_path] = 1
+        return target_path
+
+    @staticmethod
+    def _warn_unsafe_extraction_path(path):
+        """
+        If the default extraction path is overridden and set to an insecure
+        location, such as /tmp, it opens up an opportunity for an attacker to
+        replace an extracted file with an unauthorized payload. Warn the user
+        if a known insecure location is used.
+
+        See Distribute #375 for more details.
+        """
+        if os.name == 'nt' and not path.startswith(os.environ['windir']):
+            # On Windows, permissions are generally restrictive by default
+            #  and temp directories are not writable by other users, so
+            #  bypass the warning.
+            return
+        mode = os.stat(path).st_mode
+        if mode & stat.S_IWOTH or mode & stat.S_IWGRP:
+            msg = (
+                "Extraction path is writable by group/others "
+                "and vulnerable to attack when "
+                "used with get_resource_filename ({path}). "
+                "Consider a more secure "
+                "location (set with .set_extraction_path or the "
+                "PYTHON_EGG_CACHE environment variable)."
+            ).format(**locals())
+            warnings.warn(msg, UserWarning)
+
+    def postprocess(self, tempname, filename):
+        """Perform any platform-specific postprocessing of `tempname`
+
+        This is where Mac header rewrites should be done; other platforms don't
+        have anything special they should do.
+
+        Resource providers should call this method ONLY after successfully
+        extracting a compressed resource.  They must NOT call it on resources
+        that are already in the filesystem.
+
+        `tempname` is the current (temporary) name of the file, and `filename`
+        is the name it will be renamed to by the caller after this routine
+        returns.
+        """
+
+        if os.name == 'posix':
+            # Make the resource executable
+            mode = ((os.stat(tempname).st_mode) | 0o555) & 0o7777
+            os.chmod(tempname, mode)
+
+    def set_extraction_path(self, path):
+        """Set the base path where resources will be extracted to, if needed.
+
+        If you do not call this routine before any extractions take place, the
+        path defaults to the return value of ``get_default_cache()``.  (Which
+        is based on the ``PYTHON_EGG_CACHE`` environment variable, with various
+        platform-specific fallbacks.  See that routine's documentation for more
+        details.)
+
+        Resources are extracted to subdirectories of this path based upon
+        information given by the ``IResourceProvider``.  You may set this to a
+        temporary directory, but then you must call ``cleanup_resources()`` to
+        delete the extracted files when done.  There is no guarantee that
+        ``cleanup_resources()`` will be able to remove all extracted files.
+
+        (Note: you may not change the extraction path for a given resource
+        manager once resources have been extracted, unless you first call
+        ``cleanup_resources()``.)
+        """
+        if self.cached_files:
+            raise ValueError(
+                "Can't change extraction path, files already extracted"
+            )
+
+        self.extraction_path = path
+
+    def cleanup_resources(self, force=False):
+        """
+        Delete all extracted resource files and directories, returning a list
+        of the file and directory names that could not be successfully removed.
+        This function does not have any concurrency protection, so it should
+        generally only be called when the extraction path is a temporary
+        directory exclusive to a single process.  This method is not
+        automatically called; you must call it explicitly or register it as an
+        ``atexit`` function if you wish to ensure cleanup of a temporary
+        directory used for extractions.
+        """
+        # XXX
+
+
+def get_default_cache():
+    """
+    Return the ``PYTHON_EGG_CACHE`` environment variable
+    or a platform-relevant user cache dir for an app
+    named "Python-Eggs".
+    """
+    return (
+        os.environ.get('PYTHON_EGG_CACHE')
+        or appdirs.user_cache_dir(appname='Python-Eggs')
+    )
+
+
+def safe_name(name):
+    """Convert an arbitrary string to a standard distribution name
+
+    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
+    """
+    return re.sub('[^A-Za-z0-9.]+', '-', name)
+
+
+def safe_version(version):
+    """
+    Convert an arbitrary string to a standard version string
+    """
+    try:
+        # normalize the version
+        return str(packaging.version.Version(version))
+    except packaging.version.InvalidVersion:
+        version = version.replace(' ', '.')
+        return re.sub('[^A-Za-z0-9.]+', '-', version)
+
+
+def safe_extra(extra):
+    """Convert an arbitrary string to a standard 'extra' name
+
+    Any runs of non-alphanumeric characters are replaced with a single '_',
+    and the result is always lowercased.
+    """
+    return re.sub('[^A-Za-z0-9.-]+', '_', extra).lower()
+
+
+def to_filename(name):
+    """Convert a project or version name to its filename-escaped form
+
+    Any '-' characters are currently replaced with '_'.
+    """
+    return name.replace('-', '_')
+
+
+def invalid_marker(text):
+    """
+    Validate text as a PEP 508 environment marker; return an exception
+    if invalid or False otherwise.
+    """
+    try:
+        evaluate_marker(text)
+    except SyntaxError as e:
+        e.filename = None
+        e.lineno = None
+        return e
+    return False
+
+
+def evaluate_marker(text, extra=None):
+    """
+    Evaluate a PEP 508 environment marker.
+    Return a boolean indicating the marker result in this environment.
+    Raise SyntaxError if marker is invalid.
+
+    This implementation uses the 'pyparsing' module.
+    """
+    try:
+        marker = packaging.markers.Marker(text)
+        return marker.evaluate()
+    except packaging.markers.InvalidMarker as e:
+        raise SyntaxError(e) from e
+
+
+class NullProvider:
+    """Try to implement resources and metadata for arbitrary PEP 302 loaders"""
+
+    egg_name = None
+    egg_info = None
+    loader = None
+
+    def __init__(self, module):
+        self.loader = getattr(module, '__loader__', None)
+        self.module_path = os.path.dirname(getattr(module, '__file__', ''))
+
+    def get_resource_filename(self, manager, resource_name):
+        return self._fn(self.module_path, resource_name)
+
+    def get_resource_stream(self, manager, resource_name):
+        return io.BytesIO(self.get_resource_string(manager, resource_name))
+
+    def get_resource_string(self, manager, resource_name):
+        return self._get(self._fn(self.module_path, resource_name))
+
+    def has_resource(self, resource_name):
+        return self._has(self._fn(self.module_path, resource_name))
+
+    def _get_metadata_path(self, name):
+        return self._fn(self.egg_info, name)
+
+    def has_metadata(self, name):
+        if not self.egg_info:
+            return self.egg_info
+
+        path = self._get_metadata_path(name)
+        return self._has(path)
+
+    def get_metadata(self, name):
+        if not self.egg_info:
+            return ""
+        path = self._get_metadata_path(name)
+        value = self._get(path)
+        if six.PY2:
+            return value
+        try:
+            return value.decode('utf-8')
+        except UnicodeDecodeError as exc:
+            # Include the path in the error message to simplify
+            # troubleshooting, and without changing the exception type.
+            exc.reason += ' in {} file at path: {}'.format(name, path)
+            raise
+
+    def get_metadata_lines(self, name):
+        return yield_lines(self.get_metadata(name))
+
+    def resource_isdir(self, resource_name):
+        return self._isdir(self._fn(self.module_path, resource_name))
+
+    def metadata_isdir(self, name):
+        return self.egg_info and self._isdir(self._fn(self.egg_info, name))
+
+    def resource_listdir(self, resource_name):
+        return self._listdir(self._fn(self.module_path, resource_name))
+
+    def metadata_listdir(self, name):
+        if self.egg_info:
+            return self._listdir(self._fn(self.egg_info, name))
+        return []
+
+    def run_script(self, script_name, namespace):
+        script = 'scripts/' + script_name
+        if not self.has_metadata(script):
+            raise ResolutionError(
+                "Script {script!r} not found in metadata at {self.egg_info!r}"
+                .format(**locals()),
+            )
+        script_text = self.get_metadata(script).replace('\r\n', '\n')
+        script_text = script_text.replace('\r', '\n')
+        script_filename = self._fn(self.egg_info, script)
+        namespace['__file__'] = script_filename
+        if os.path.exists(script_filename):
+            with open(script_filename) as fid:
+                source = fid.read()
+            code = compile(source, script_filename, 'exec')
+            exec(code, namespace, namespace)
+        else:
+            from linecache import cache
+            cache[script_filename] = (
+                len(script_text), 0, script_text.split('\n'), script_filename
+            )
+            script_code = compile(script_text, script_filename, 'exec')
+            exec(script_code, namespace, namespace)
+
+    def _has(self, path):
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _isdir(self, path):
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _listdir(self, path):
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _fn(self, base, resource_name):
+        self._validate_resource_path(resource_name)
+        if resource_name:
+            return os.path.join(base, *resource_name.split('/'))
+        return base
+
+    @staticmethod
+    def _validate_resource_path(path):
+        """
+        Validate the resource paths according to the docs.
+        https://setuptools.readthedocs.io/en/latest/pkg_resources.html#basic-resource-access
+
+        >>> warned = getfixture('recwarn')
+        >>> warnings.simplefilter('always')
+        >>> vrp = NullProvider._validate_resource_path
+        >>> vrp('foo/bar.txt')
+        >>> bool(warned)
+        False
+        >>> vrp('../foo/bar.txt')
+        >>> bool(warned)
+        True
+        >>> warned.clear()
+        >>> vrp('/foo/bar.txt')
+        >>> bool(warned)
+        True
+        >>> vrp('foo/../../bar.txt')
+        >>> bool(warned)
+        True
+        >>> warned.clear()
+        >>> vrp('foo/f../bar.txt')
+        >>> bool(warned)
+        False
+
+        Windows path separators are straight-up disallowed.
+        >>> vrp(r'\\foo/bar.txt')
+        Traceback (most recent call last):
+        ...
+        ValueError: Use of .. or absolute path in a resource path \
+is not allowed.
+
+        >>> vrp(r'C:\\foo/bar.txt')
+        Traceback (most recent call last):
+        ...
+        ValueError: Use of .. or absolute path in a resource path \
+is not allowed.
+
+        Blank values are allowed
+
+        >>> vrp('')
+        >>> bool(warned)
+        False
+
+        Non-string values are not.
+
+        >>> vrp(None)
+        Traceback (most recent call last):
+        ...
+        AttributeError: ...
+        """
+        invalid = (
+            os.path.pardir in path.split(posixpath.sep) or
+            posixpath.isabs(path) or
+            ntpath.isabs(path)
+        )
+        if not invalid:
+            return
+
+        msg = "Use of .. or absolute path in a resource path is not allowed."
+
+        # Aggressively disallow Windows absolute paths
+        if ntpath.isabs(path) and not posixpath.isabs(path):
+            raise ValueError(msg)
+
+        # for compatibility, warn; in future
+        # raise ValueError(msg)
+        warnings.warn(
+            msg[:-1] + " and will raise exceptions in a future release.",
+            DeprecationWarning,
+            stacklevel=4,
+        )
+
+    def _get(self, path):
+        if hasattr(self.loader, 'get_data'):
+            return self.loader.get_data(path)
+        raise NotImplementedError(
+            "Can't perform this operation for loaders without 'get_data()'"
+        )
+
+
+register_loader_type(object, NullProvider)
+
+
+def _parents(path):
+    """
+    yield all parents of path including path
+    """
+    last = None
+    while path != last:
+        yield path
+        last = path
+        path, _ = os.path.split(path)
+
+
+class EggProvider(NullProvider):
+    """Provider based on a virtual filesystem"""
+
+    def __init__(self, module):
+        NullProvider.__init__(self, module)
+        self._setup_prefix()
+
+    def _setup_prefix(self):
+        # Assume that metadata may be nested inside a "basket"
+        # of multiple eggs and use module_path instead of .archive.
+        eggs = filter(_is_egg_path, _parents(self.module_path))
+        egg = next(eggs, None)
+        egg and self._set_egg(egg)
+
+    def _set_egg(self, path):
+        self.egg_name = os.path.basename(path)
+        self.egg_info = os.path.join(path, 'EGG-INFO')
+        self.egg_root = path
+
+
+class DefaultProvider(EggProvider):
+    """Provides access to package resources in the filesystem"""
+
+    def _has(self, path):
+        return os.path.exists(path)
+
+    def _isdir(self, path):
+        return os.path.isdir(path)
+
+    def _listdir(self, path):
+        return os.listdir(path)
+
+    def get_resource_stream(self, manager, resource_name):
+        return open(self._fn(self.module_path, resource_name), 'rb')
+
+    def _get(self, path):
+        with open(path, 'rb') as stream:
+            return stream.read()
+
+    @classmethod
+    def _register(cls):
+        loader_names = 'SourceFileLoader', 'SourcelessFileLoader',
+        for name in loader_names:
+            loader_cls = getattr(importlib_machinery, name, type(None))
+            register_loader_type(loader_cls, cls)
+
+
+DefaultProvider._register()
+
+
+class EmptyProvider(NullProvider):
+    """Provider that returns nothing for all requests"""
+
+    module_path = None
+
+    _isdir = _has = lambda self, path: False
+
+    def _get(self, path):
+        return ''
+
+    def _listdir(self, path):
+        return []
+
+    def __init__(self):
+        pass
+
+
+empty_provider = EmptyProvider()
+
+
+class ZipManifests(dict):
+    """
+    zip manifest builder
+    """
+
+    @classmethod
+    def build(cls, path):
+        """
+        Build a dictionary similar to the zipimport directory
+        caches, except instead of tuples, store ZipInfo objects.
+
+        Use a platform-specific path separator (os.sep) for the path keys
+        for compatibility with pypy on Windows.
+        """
+        with zipfile.ZipFile(path) as zfile:
+            items = (
+                (
+                    name.replace('/', os.sep),
+                    zfile.getinfo(name),
+                )
+                for name in zfile.namelist()
+            )
+            return dict(items)
+
+    load = build
+
+
+class MemoizedZipManifests(ZipManifests):
+    """
+    Memoized zipfile manifests.
+    """
+    manifest_mod = collections.namedtuple('manifest_mod', 'manifest mtime')
+
+    def load(self, path):
+        """
+        Load a manifest at path or return a suitable manifest already loaded.
+        """
+        path = os.path.normpath(path)
+        mtime = os.stat(path).st_mtime
+
+        if path not in self or self[path].mtime != mtime:
+            manifest = self.build(path)
+            self[path] = self.manifest_mod(manifest, mtime)
+
+        return self[path].manifest
+
+
+class ZipProvider(EggProvider):
+    """Resource support for zips and eggs"""
+
+    eagers = None
+    _zip_manifests = MemoizedZipManifests()
+
+    def __init__(self, module):
+        EggProvider.__init__(self, module)
+        self.zip_pre = self.loader.archive + os.sep
+
+    def _zipinfo_name(self, fspath):
+        # Convert a virtual filename (full path to file) into a zipfile subpath
+        # usable with the zipimport directory cache for our target archive
+        fspath = fspath.rstrip(os.sep)
+        if fspath == self.loader.archive:
+            return ''
+        if fspath.startswith(self.zip_pre):
+            return fspath[len(self.zip_pre):]
+        raise AssertionError(
+            "%s is not a subpath of %s" % (fspath, self.zip_pre)
+        )
+
+    def _parts(self, zip_path):
+        # Convert a zipfile subpath into an egg-relative path part list.
+        # pseudo-fs path
+        fspath = self.zip_pre + zip_path
+        if fspath.startswith(self.egg_root + os.sep):
+            return fspath[len(self.egg_root) + 1:].split(os.sep)
+        raise AssertionError(
+            "%s is not a subpath of %s" % (fspath, self.egg_root)
+        )
+
+    @property
+    def zipinfo(self):
+        return self._zip_manifests.load(self.loader.archive)
+
+    def get_resource_filename(self, manager, resource_name):
+        if not self.egg_name:
+            raise NotImplementedError(
+                "resource_filename() only supported for .egg, not .zip"
+            )
+        # no need to lock for extraction, since we use temp names
+        zip_path = self._resource_to_zip(resource_name)
+        eagers = self._get_eager_resources()
+        if '/'.join(self._parts(zip_path)) in eagers:
+            for name in eagers:
+                self._extract_resource(manager, self._eager_to_zip(name))
+        return self._extract_resource(manager, zip_path)
+
+    @staticmethod
+    def _get_date_and_size(zip_stat):
+        size = zip_stat.file_size
+        # ymdhms+wday, yday, dst
+        date_time = zip_stat.date_time + (0, 0, -1)
+        # 1980 offset already done
+        timestamp = time.mktime(date_time)
+        return timestamp, size
+
+    def _extract_resource(self, manager, zip_path):
+
+        if zip_path in self._index():
+            for name in self._index()[zip_path]:
+                last = self._extract_resource(
+                    manager, os.path.join(zip_path, name)
+                )
+            # return the extracted directory name
+            return os.path.dirname(last)
+
+        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
+
+        if not WRITE_SUPPORT:
+            raise IOError('"os.rename" and "os.unlink" are not supported '
+                          'on this platform')
+        try:
+
+            real_path = manager.get_cache_path(
+                self.egg_name, self._parts(zip_path)
+            )
+
+            if self._is_current(real_path, zip_path):
+                return real_path
+
+            outf, tmpnam = _mkstemp(
+                ".$extract",
+                dir=os.path.dirname(real_path),
+            )
+            os.write(outf, self.loader.get_data(zip_path))
+            os.close(outf)
+            utime(tmpnam, (timestamp, timestamp))
+            manager.postprocess(tmpnam, real_path)
+
+            try:
+                rename(tmpnam, real_path)
+
+            except os.error:
+                if os.path.isfile(real_path):
+                    if self._is_current(real_path, zip_path):
+                        # the file became current since it was checked above,
+                        #  so proceed.
+                        return real_path
+                    # Windows, del old file and retry
+                    elif os.name == 'nt':
+                        unlink(real_path)
+                        rename(tmpnam, real_path)
+                        return real_path
+                raise
+
+        except os.error:
+            # report a user-friendly error
+            manager.extraction_error()
+
+        return real_path
+
+    def _is_current(self, file_path, zip_path):
+        """
+        Return True if the file_path is current for this zip_path
+        """
+        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
+        if not os.path.isfile(file_path):
+            return False
+        stat = os.stat(file_path)
+        if stat.st_size != size or stat.st_mtime != timestamp:
+            return False
+        # check that the contents match
+        zip_contents = self.loader.get_data(zip_path)
+        with open(file_path, 'rb') as f:
+            file_contents = f.read()
+        return zip_contents == file_contents
+
+    def _get_eager_resources(self):
+        if self.eagers is None:
+            eagers = []
+            for name in ('native_libs.txt', 'eager_resources.txt'):
+                if self.has_metadata(name):
+                    eagers.extend(self.get_metadata_lines(name))
+            self.eagers = eagers
+        return self.eagers
+
+    def _index(self):
+        try:
+            return self._dirindex
+        except AttributeError:
+            ind = {}
+            for path in self.zipinfo:
+                parts = path.split(os.sep)
+                while parts:
+                    parent = os.sep.join(parts[:-1])
+                    if parent in ind:
+                        ind[parent].append(parts[-1])
+                        break
+                    else:
+                        ind[parent] = [parts.pop()]
+            self._dirindex = ind
+            return ind
+
+    def _has(self, fspath):
+        zip_path = self._zipinfo_name(fspath)
+        return zip_path in self.zipinfo or zip_path in self._index()
+
+    def _isdir(self, fspath):
+        return self._zipinfo_name(fspath) in self._index()
+
+    def _listdir(self, fspath):
+        return list(self._index().get(self._zipinfo_name(fspath), ()))
+
+    def _eager_to_zip(self, resource_name):
+        return self._zipinfo_name(self._fn(self.egg_root, resource_name))
+
+    def _resource_to_zip(self, resource_name):
+        return self._zipinfo_name(self._fn(self.module_path, resource_name))
+
+
+register_loader_type(zipimport.zipimporter, ZipProvider)
+
+
+class FileMetadata(EmptyProvider):
+    """Metadata handler for standalone PKG-INFO files
+
+    Usage::
+
+        metadata = FileMetadata("/path/to/PKG-INFO")
+
+    This provider rejects all data and metadata requests except for PKG-INFO,
+    which is treated as existing, and will be the contents of the file at
+    the provided location.
+    """
+
+    def __init__(self, path):
+        self.path = path
+
+    def _get_metadata_path(self, name):
+        return self.path
+
+    def has_metadata(self, name):
+        return name == 'PKG-INFO' and os.path.isfile(self.path)
+
+    def get_metadata(self, name):
+        if name != 'PKG-INFO':
+            raise KeyError("No metadata except PKG-INFO is available")
+
+        with io.open(self.path, encoding='utf-8', errors="replace") as f:
+            metadata = f.read()
+        self._warn_on_replacement(metadata)
+        return metadata
+
+    def _warn_on_replacement(self, metadata):
+        # Python 2.7 compat for: replacement_char = '�'
+        replacement_char = b'\xef\xbf\xbd'.decode('utf-8')
+        if replacement_char in metadata:
+            tmpl = "{self.path} could not be properly decoded in UTF-8"
+            msg = tmpl.format(**locals())
+            warnings.warn(msg)
+
+    def get_metadata_lines(self, name):
+        return yield_lines(self.get_metadata(name))
+
+
+class PathMetadata(DefaultProvider):
+    """Metadata provider for egg directories
+
+    Usage::
+
+        # Development eggs:
+
+        egg_info = "/path/to/PackageName.egg-info"
+        base_dir = os.path.dirname(egg_info)
+        metadata = PathMetadata(base_dir, egg_info)
+        dist_name = os.path.splitext(os.path.basename(egg_info))[0]
+        dist = Distribution(basedir, project_name=dist_name, metadata=metadata)
+
+        # Unpacked egg directories:
+
+        egg_path = "/path/to/PackageName-ver-pyver-etc.egg"
+        metadata = PathMetadata(egg_path, os.path.join(egg_path,'EGG-INFO'))
+        dist = Distribution.from_filename(egg_path, metadata=metadata)
+    """
+
+    def __init__(self, path, egg_info):
+        self.module_path = path
+        self.egg_info = egg_info
+
+
+class EggMetadata(ZipProvider):
+    """Metadata provider for .egg files"""
+
+    def __init__(self, importer):
+        """Create a metadata provider from a zipimporter"""
+
+        self.zip_pre = importer.archive + os.sep
+        self.loader = importer
+        if importer.prefix:
+            self.module_path = os.path.join(importer.archive, importer.prefix)
+        else:
+            self.module_path = importer.archive
+        self._setup_prefix()
+
+
+_declare_state('dict', _distribution_finders={})
+
+
+def register_finder(importer_type, distribution_finder):
+    """Register `distribution_finder` to find distributions in sys.path items
+
+    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
+    handler), and `distribution_finder` is a callable that, passed a path
+    item and the importer instance, yields ``Distribution`` instances found on
+    that path item.  See ``pkg_resources.find_on_path`` for an example."""
+    _distribution_finders[importer_type] = distribution_finder
+
+
+def find_distributions(path_item, only=False):
+    """Yield distributions accessible via `path_item`"""
+    importer = get_importer(path_item)
+    finder = _find_adapter(_distribution_finders, importer)
+    return finder(importer, path_item, only)
+
+
+def find_eggs_in_zip(importer, path_item, only=False):
+    """
+    Find eggs in zip files; possibly multiple nested eggs.
+    """
+    if importer.archive.endswith('.whl'):
+        # wheels are not supported with this finder
+        # they don't have PKG-INFO metadata, and won't ever contain eggs
+        return
+    metadata = EggMetadata(importer)
+    if metadata.has_metadata('PKG-INFO'):
+        yield Distribution.from_filename(path_item, metadata=metadata)
+    if only:
+        # don't yield nested distros
+        return
+    for subitem in metadata.resource_listdir(''):
+        if _is_egg_path(subitem):
+            subpath = os.path.join(path_item, subitem)
+            dists = find_eggs_in_zip(zipimport.zipimporter(subpath), subpath)
+            for dist in dists:
+                yield dist
+        elif subitem.lower().endswith('.dist-info'):
+            subpath = os.path.join(path_item, subitem)
+            submeta = EggMetadata(zipimport.zipimporter(subpath))
+            submeta.egg_info = subpath
+            yield Distribution.from_location(path_item, subitem, submeta)
+
+
+register_finder(zipimport.zipimporter, find_eggs_in_zip)
+
+
+def find_nothing(importer, path_item, only=False):
+    return ()
+
+
+register_finder(object, find_nothing)
+
+
+def _by_version_descending(names):
+    """
+    Given a list of filenames, return them in descending order
+    by version number.
+
+    >>> names = 'bar', 'foo', 'Python-2.7.10.egg', 'Python-2.7.2.egg'
+    >>> _by_version_descending(names)
+    ['Python-2.7.10.egg', 'Python-2.7.2.egg', 'foo', 'bar']
+    >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.egg'
+    >>> _by_version_descending(names)
+    ['Setuptools-1.2.3.egg', 'Setuptools-1.2.3b1.egg']
+    >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.post1.egg'
+    >>> _by_version_descending(names)
+    ['Setuptools-1.2.3.post1.egg', 'Setuptools-1.2.3b1.egg']
+    """
+    def _by_version(name):
+        """
+        Parse each component of the filename
+        """
+        name, ext = os.path.splitext(name)
+        parts = itertools.chain(name.split('-'), [ext])
+        return [packaging.version.parse(part) for part in parts]
+
+    return sorted(names, key=_by_version, reverse=True)
+
+
+def find_on_path(importer, path_item, only=False):
+    """Yield distributions accessible on a sys.path directory"""
+    path_item = _normalize_cached(path_item)
+
+    if _is_unpacked_egg(path_item):
+        yield Distribution.from_filename(
+            path_item, metadata=PathMetadata(
+                path_item, os.path.join(path_item, 'EGG-INFO')
+            )
+        )
+        return
+
+    entries = safe_listdir(path_item)
+
+    # for performance, before sorting by version,
+    # screen entries for only those that will yield
+    # distributions
+    filtered = (
+        entry
+        for entry in entries
+        if dist_factory(path_item, entry, only)
+    )
+
+    # scan for .egg and .egg-info in directory
+    path_item_entries = _by_version_descending(filtered)
+    for entry in path_item_entries:
+        fullpath = os.path.join(path_item, entry)
+        factory = dist_factory(path_item, entry, only)
+        for dist in factory(fullpath):
+            yield dist
+
+
+def dist_factory(path_item, entry, only):
+    """Return a dist_factory for the given entry."""
+    lower = entry.lower()
+    is_egg_info = lower.endswith('.egg-info')
+    is_dist_info = (
+        lower.endswith('.dist-info') and
+        os.path.isdir(os.path.join(path_item, entry))
+    )
+    is_meta = is_egg_info or is_dist_info
+    return (
+        distributions_from_metadata
+        if is_meta else
+        find_distributions
+        if not only and _is_egg_path(entry) else
+        resolve_egg_link
+        if not only and lower.endswith('.egg-link') else
+        NoDists()
+    )
+
+
+class NoDists:
+    """
+    >>> bool(NoDists())
+    False
+
+    >>> list(NoDists()('anything'))
+    []
+    """
+    def __bool__(self):
+        return False
+    if six.PY2:
+        __nonzero__ = __bool__
+
+    def __call__(self, fullpath):
+        return iter(())
+
+
+def safe_listdir(path):
+    """
+    Attempt to list contents of path, but suppress some exceptions.
+    """
+    try:
+        return os.listdir(path)
+    except (PermissionError, NotADirectoryError):
+        pass
+    except OSError as e:
+        # Ignore the directory if does not exist, not a directory or
+        # permission denied
+        ignorable = (
+            e.errno in (errno.ENOTDIR, errno.EACCES, errno.ENOENT)
+            # Python 2 on Windows needs to be handled this way :(
+            or getattr(e, "winerror", None) == 267
+        )
+        if not ignorable:
+            raise
+    return ()
+
+
+def distributions_from_metadata(path):
+    root = os.path.dirname(path)
+    if os.path.isdir(path):
+        if len(os.listdir(path)) == 0:
+            # empty metadata dir; skip
+            return
+        metadata = PathMetadata(root, path)
+    else:
+        metadata = FileMetadata(path)
+    entry = os.path.basename(path)
+    yield Distribution.from_location(
+        root, entry, metadata, precedence=DEVELOP_DIST,
+    )
+
+
+def non_empty_lines(path):
+    """
+    Yield non-empty lines from file at path
+    """
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield line
+
+
+def resolve_egg_link(path):
+    """
+    Given a path to an .egg-link, resolve distributions
+    present in the referenced path.
+    """
+    referenced_paths = non_empty_lines(path)
+    resolved_paths = (
+        os.path.join(os.path.dirname(path), ref)
+        for ref in referenced_paths
+    )
+    dist_groups = map(find_distributions, resolved_paths)
+    return next(dist_groups, ())
+
+
+register_finder(pkgutil.ImpImporter, find_on_path)
+
+if hasattr(importlib_machinery, 'FileFinder'):
+    register_finder(importlib_machinery.FileFinder, find_on_path)
+
+_declare_state('dict', _namespace_handlers={})
+_declare_state('dict', _namespace_packages={})
+
+
+def register_namespace_handler(importer_type, namespace_handler):
+    """Register `namespace_handler` to declare namespace packages
+
+    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
+    handler), and `namespace_handler` is a callable like this::
+
+        def namespace_handler(importer, path_entry, moduleName, module):
+            # return a path_entry to use for child packages
+
+    Namespace handlers are only called if the importer object has already
+    agreed that it can handle the relevant path item, and they should only
+    return a subpath if the module __path__ does not already contain an
+    equivalent subpath.  For an example namespace handler, see
+    ``pkg_resources.file_ns_handler``.
+    """
+    _namespace_handlers[importer_type] = namespace_handler
+
+
+def _handle_ns(packageName, path_item):
+    """Ensure that named package includes a subpath of path_item (if needed)"""
+
+    importer = get_importer(path_item)
+    if importer is None:
+        return None
+
+    # use find_spec (PEP 451) and fall-back to find_module (PEP 302)
+    try:
+        loader = importer.find_spec(packageName).loader
+    except AttributeError:
+        # capture warnings due to #1111
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            loader = importer.find_module(packageName)
+
+    if loader is None:
+        return None
+    module = sys.modules.get(packageName)
+    if module is None:
+        module = sys.modules[packageName] = types.ModuleType(packageName)
+        module.__path__ = []
+        _set_parent_ns(packageName)
+    elif not hasattr(module, '__path__'):
+        raise TypeError("Not a package:", packageName)
+    handler = _find_adapter(_namespace_handlers, importer)
+    subpath = handler(importer, path_item, packageName, module)
+    if subpath is not None:
+        path = module.__path__
+        path.append(subpath)
+        loader.load_module(packageName)
+        _rebuild_mod_path(path, packageName, module)
+    return subpath
+
+
+def _rebuild_mod_path(orig_path, package_name, module):
+    """
+    Rebuild module.__path__ ensuring that all entries are ordered
+    corresponding to their sys.path order
+    """
+    sys_path = [_normalize_cached(p) for p in sys.path]
+
+    def safe_sys_path_index(entry):
+        """
+        Workaround for #520 and #513.
+        """
+        try:
+            return sys_path.index(entry)
+        except ValueError:
+            return float('inf')
+
+    def position_in_sys_path(path):
+        """
+        Return the ordinal of the path based on its position in sys.path
+        """
+        path_parts = path.split(os.sep)
+        module_parts = package_name.count('.') + 1
+        parts = path_parts[:-module_parts]
+        return safe_sys_path_index(_normalize_cached(os.sep.join(parts)))
+
+    new_path = sorted(orig_path, key=position_in_sys_path)
+    new_path = [_normalize_cached(p) for p in new_path]
+
+    if isinstance(module.__path__, list):
+        module.__path__[:] = new_path
+    else:
+        module.__path__ = new_path
+
+
+def declare_namespace(packageName):
+    """Declare that package 'packageName' is a namespace package"""
+
+    _imp.acquire_lock()
+    try:
+        if packageName in _namespace_packages:
+            return
+
+        path = sys.path
+        parent, _, _ = packageName.rpartition('.')
+
+        if parent:
+            declare_namespace(parent)
+            if parent not in _namespace_packages:
+                __import__(parent)
+            try:
+                path = sys.modules[parent].__path__
+            except AttributeError as e:
+                raise TypeError("Not a package:", parent) from e
+
+        # Track what packages are namespaces, so when new path items are added,
+        # they can be updated
+        _namespace_packages.setdefault(parent or None, []).append(packageName)
+        _namespace_packages.setdefault(packageName, [])
+
+        for path_item in path:
+            # Ensure all the parent's path items are reflected in the child,
+            # if they apply
+            _handle_ns(packageName, path_item)
+
+    finally:
+        _imp.release_lock()
+
+
+def fixup_namespace_packages(path_item, parent=None):
+    """Ensure that previously-declared namespace packages include path_item"""
+    _imp.acquire_lock()
+    try:
+        for package in _namespace_packages.get(parent, ()):
+            subpath = _handle_ns(package, path_item)
+            if subpath:
+                fixup_namespace_packages(subpath, package)
+    finally:
+        _imp.release_lock()
+
+
+def file_ns_handler(importer, path_item, packageName, module):
+    """Compute an ns-package subpath for a filesystem or zipfile importer"""
+
+    subpath = os.path.join(path_item, packageName.split('.')[-1])
+    normalized = _normalize_cached(subpath)
+    for item in module.__path__:
+        if _normalize_cached(item) == normalized:
+            break
+    else:
+        # Only return the path if it's not already there
+        return subpath
+
+
+register_namespace_handler(pkgutil.ImpImporter, file_ns_handler)
+register_namespace_handler(zipimport.zipimporter, file_ns_handler)
+
+if hasattr(importlib_machinery, 'FileFinder'):
+    register_namespace_handler(importlib_machinery.FileFinder, file_ns_handler)
+
+
+def null_ns_handler(importer, path_item, packageName, module):
+    return None
+
+
+register_namespace_handler(object, null_ns_handler)
+
+
+def normalize_path(filename):
+    """Normalize a file/dir name for comparison purposes"""
+    return os.path.normcase(os.path.realpath(os.path.normpath(
+        _cygwin_patch(filename))))
+
+
+def _cygwin_patch(filename):  # pragma: nocover
+    """
+    Contrary to POSIX 2008, on Cygwin, getcwd (3) contains
+    symlink components. Using
+    os.path.abspath() works around this limitation. A fix in os.getcwd()
+    would probably better, in Cygwin even more so, except
+    that this seems to be by design...
+    """
+    return os.path.abspath(filename) if sys.platform == 'cygwin' else filename
+
+
+def _normalize_cached(filename, _cache={}):
+    try:
+        return _cache[filename]
+    except KeyError:
+        _cache[filename] = result = normalize_path(filename)
+        return result
+
+
+def _is_egg_path(path):
+    """
+    Determine if given path appears to be an egg.
+    """
+    return path.lower().endswith('.egg')
+
+
+def _is_unpacked_egg(path):
+    """
+    Determine if given path appears to be an unpacked egg.
+    """
+    return (
+        _is_egg_path(path) and
+        os.path.isfile(os.path.join(path, 'EGG-INFO', 'PKG-INFO'))
+    )
+
+
+def _set_parent_ns(packageName):
+    parts = packageName.split('.')
+    name = parts.pop()
+    if parts:
+        parent = '.'.join(parts)
+        setattr(sys.modules[parent], name, sys.modules[packageName])
+
+
+def yield_lines(strs):
+    """Yield non-empty/non-comment lines of a string or sequence"""
+    if isinstance(strs, six.string_types):
+        for s in strs.splitlines():
+            s = s.strip()
+            # skip blank lines/comments
+            if s and not s.startswith('#'):
+                yield s
+    else:
+        for ss in strs:
+            for s in yield_lines(ss):
+                yield s
+
+
+MODULE = re.compile(r"\w+(\.\w+)*$").match
+EGG_NAME = re.compile(
+    r"""
+    (?P<name>[^-]+) (
+        -(?P<ver>[^-]+) (
+            -py(?P<pyver>[^-]+) (
+                -(?P<plat>.+)
+            )?
+        )?
+    )?
+    """,
+    re.VERBOSE | re.IGNORECASE,
+).match
+
+
+class EntryPoint:
+    """Object representing an advertised importable object"""
+
+    def __init__(self, name, module_name, attrs=(), extras=(), dist=None):
+        if not MODULE(module_name):
+            raise ValueError("Invalid module name", module_name)
+        self.name = name
+        self.module_name = module_name
+        self.attrs = tuple(attrs)
+        self.extras = tuple(extras)
+        self.dist = dist
+
+    def __str__(self):
+        s = "%s = %s" % (self.name, self.module_name)
+        if self.attrs:
+            s += ':' + '.'.join(self.attrs)
+        if self.extras:
+            s += ' [%s]' % ','.join(self.extras)
+        return s
+
+    def __repr__(self):
+        return "EntryPoint.parse(%r)" % str(self)
+
+    def load(self, require=True, *args, **kwargs):
+        """
+        Require packages for this EntryPoint, then resolve it.
+        """
+        if not require or args or kwargs:
+            warnings.warn(
+                "Parameters to load are deprecated.  Call .resolve and "
+                ".require separately.",
+                PkgResourcesDeprecationWarning,
+                stacklevel=2,
+            )
+        if require:
+            self.require(*args, **kwargs)
+        return self.resolve()
+
+    def resolve(self):
+        """
+        Resolve the entry point from its module and attrs.
+        """
+        module = __import__(self.module_name, fromlist=['__name__'], level=0)
+        try:
+            return functools.reduce(getattr, self.attrs, module)
+        except AttributeError as exc:
+            raise ImportError(str(exc)) from exc
+
+    def require(self, env=None, installer=None):
+        if self.extras and not self.dist:
+            raise UnknownExtra("Can't require() without a distribution", self)
+
+        # Get the requirements for this entry point with all its extras and
+        # then resolve them. We have to pass `extras` along when resolving so
+        # that the working set knows what extras we want. Otherwise, for
+        # dist-info distributions, the working set will assume that the
+        # requirements for that extra are purely optional and skip over them.
+        reqs = self.dist.requires(self.extras)
+        items = working_set.resolve(reqs, env, installer, extras=self.extras)
+        list(map(working_set.add, items))
+
+    pattern = re.compile(
+        r'\s*'
+        r'(?P<name>.+?)\s*'
+        r'=\s*'
+        r'(?P<module>[\w.]+)\s*'
+        r'(:\s*(?P<attr>[\w.]+))?\s*'
+        r'(?P<extras>\[.*\])?\s*$'
+    )
+
+    @classmethod
+    def parse(cls, src, dist=None):
+        """Parse a single entry point from string `src`
+
+        Entry point syntax follows the form::
+
+            name = some.module:some.attr [extra1, extra2]
+
+        The entry name and module name are required, but the ``:attrs`` and
+        ``[extras]`` parts are optional
+        """
+        m = cls.pattern.match(src)
+        if not m:
+            msg = "EntryPoint must be in 'name=module:attrs [extras]' format"
+            raise ValueError(msg, src)
+        res = m.groupdict()
+        extras = cls._parse_extras(res['extras'])
+        attrs = res['attr'].split('.') if res['attr'] else ()
+        return cls(res['name'], res['module'], attrs, extras, dist)
+
+    @classmethod
+    def _parse_extras(cls, extras_spec):
+        if not extras_spec:
+            return ()
+        req = Requirement.parse('x' + extras_spec)
+        if req.specs:
+            raise ValueError()
+        return req.extras
+
+    @classmethod
+    def parse_group(cls, group, lines, dist=None):
+        """Parse an entry point group"""
+        if not MODULE(group):
+            raise ValueError("Invalid group name", group)
+        this = {}
+        for line in yield_lines(lines):
+            ep = cls.parse(line, dist)
+            if ep.name in this:
+                raise ValueError("Duplicate entry point", group, ep.name)
+            this[ep.name] = ep
+        return this
+
+    @classmethod
+    def parse_map(cls, data, dist=None):
+        """Parse a map of entry point groups"""
+        if isinstance(data, dict):
+            data = data.items()
+        else:
+            data = split_sections(data)
+        maps = {}
+        for group, lines in data:
+            if group is None:
+                if not lines:
+                    continue
+                raise ValueError("Entry points must be listed in groups")
+            group = group.strip()
+            if group in maps:
+                raise ValueError("Duplicate group name", group)
+            maps[group] = cls.parse_group(group, lines, dist)
+        return maps
+
+
+def _version_from_file(lines):
+    """
+    Given an iterable of lines from a Metadata file, return
+    the value of the Version field, if present, or None otherwise.
+    """
+    def is_version_line(line):
+        return line.lower().startswith('version:')
+    version_lines = filter(is_version_line, lines)
+    line = next(iter(version_lines), '')
+    _, _, value = line.partition(':')
+    return safe_version(value.strip()) or None
+
+
+class Distribution:
+    """Wrap an actual or potential sys.path entry w/metadata"""
+    PKG_INFO = 'PKG-INFO'
+
+    def __init__(
+            self, location=None, metadata=None, project_name=None,
+            version=None, py_version=PY_MAJOR, platform=None,
+            precedence=EGG_DIST):
+        self.project_name = safe_name(project_name or 'Unknown')
+        if version is not None:
+            self._version = safe_version(version)
+        self.py_version = py_version
+        self.platform = platform
+        self.location = location
+        self.precedence = precedence
+        self._provider = metadata or empty_provider
+
+    @classmethod
+    def from_location(cls, location, basename, metadata=None, **kw):
+        project_name, version, py_version, platform = [None] * 4
+        basename, ext = os.path.splitext(basename)
+        if ext.lower() in _distributionImpl:
+            cls = _distributionImpl[ext.lower()]
+
+            match = EGG_NAME(basename)
+            if match:
+                project_name, version, py_version, platform = match.group(
+                    'name', 'ver', 'pyver', 'plat'
+                )
+        return cls(
+            location, metadata, project_name=project_name, version=version,
+            py_version=py_version, platform=platform, **kw
+        )._reload_version()
+
+    def _reload_version(self):
+        return self
+
+    @property
+    def hashcmp(self):
+        return (
+            self.parsed_version,
+            self.precedence,
+            self.key,
+            self.location,
+            self.py_version or '',
+            self.platform or '',
+        )
+
+    def __hash__(self):
+        return hash(self.hashcmp)
+
+    def __lt__(self, other):
+        return self.hashcmp < other.hashcmp
+
+    def __le__(self, other):
+        return self.hashcmp <= other.hashcmp
+
+    def __gt__(self, other):
+        return self.hashcmp > other.hashcmp
+
+    def __ge__(self, other):
+        return self.hashcmp >= other.hashcmp
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            # It's not a Distribution, so they are not equal
+            return False
+        return self.hashcmp == other.hashcmp
+
+    def __ne__(self, other):
+        return not self == other
+
+    # These properties have to be lazy so that we don't have to load any
+    # metadata until/unless it's actually needed.  (i.e., some distributions
+    # may not know their name or version without loading PKG-INFO)
+
+    @property
+    def key(self):
+        try:
+            return self._key
+        except AttributeError:
+            self._key = key = self.project_name.lower()
+            return key
+
+    @property
+    def parsed_version(self):
+        if not hasattr(self, "_parsed_version"):
+            self._parsed_version = parse_version(self.version)
+
+        return self._parsed_version
+
+    def _warn_legacy_version(self):
+        LV = packaging.version.LegacyVersion
+        is_legacy = isinstance(self._parsed_version, LV)
+        if not is_legacy:
+            return
+
+        # While an empty version is technically a legacy version and
+        # is not a valid PEP 440 version, it's also unlikely to
+        # actually come from someone and instead it is more likely that
+        # it comes from setuptools attempting to parse a filename and
+        # including it in the list. So for that we'll gate this warning
+        # on if the version is anything at all or not.
+        if not self.version:
+            return
+
+        tmpl = textwrap.dedent("""
+            '{project_name} ({version})' is being parsed as a legacy,
+            non PEP 440,
+            version. You may find odd behavior and sort order.
+            In particular it will be sorted as less than 0.0. It
+            is recommended to migrate to PEP 440 compatible
+            versions.
+            """).strip().replace('\n', ' ')
+
+        warnings.warn(tmpl.format(**vars(self)), PEP440Warning)
+
+    @property
+    def version(self):
+        try:
+            return self._version
+        except AttributeError as e:
+            version = self._get_version()
+            if version is None:
+                path = self._get_metadata_path_for_display(self.PKG_INFO)
+                msg = (
+                    "Missing 'Version:' header and/or {} file at path: {}"
+                ).format(self.PKG_INFO, path)
+                raise ValueError(msg, self) from e
+
+            return version
+
+    @property
+    def _dep_map(self):
+        """
+        A map of extra to its list of (direct) requirements
+        for this distribution, including the null extra.
+        """
+        try:
+            return self.__dep_map
+        except AttributeError:
+            self.__dep_map = self._filter_extras(self._build_dep_map())
+        return self.__dep_map
+
+    @staticmethod
+    def _filter_extras(dm):
+        """
+        Given a mapping of extras to dependencies, strip off
+        environment markers and filter out any dependencies
+        not matching the markers.
+        """
+        for extra in list(filter(None, dm)):
+            new_extra = extra
+            reqs = dm.pop(extra)
+            new_extra, _, marker = extra.partition(':')
+            fails_marker = marker and (
+                invalid_marker(marker)
+                or not evaluate_marker(marker)
+            )
+            if fails_marker:
+                reqs = []
+            new_extra = safe_extra(new_extra) or None
+
+            dm.setdefault(new_extra, []).extend(reqs)
+        return dm
+
+    def _build_dep_map(self):
+        dm = {}
+        for name in 'requires.txt', 'depends.txt':
+            for extra, reqs in split_sections(self._get_metadata(name)):
+                dm.setdefault(extra, []).extend(parse_requirements(reqs))
+        return dm
+
+    def requires(self, extras=()):
+        """List of Requirements needed for this distro if `extras` are used"""
+        dm = self._dep_map
+        deps = []
+        deps.extend(dm.get(None, ()))
+        for ext in extras:
+            try:
+                deps.extend(dm[safe_extra(ext)])
+            except KeyError as e:
+                raise UnknownExtra(
+                    "%s has no such extra feature %r" % (self, ext)
+                ) from e
+        return deps
+
+    def _get_metadata_path_for_display(self, name):
+        """
+        Return the path to the given metadata file, if available.
+        """
+        try:
+            # We need to access _get_metadata_path() on the provider object
+            # directly rather than through this class's __getattr__()
+            # since _get_metadata_path() is marked private.
+            path = self._provider._get_metadata_path(name)
+
+        # Handle exceptions e.g. in case the distribution's metadata
+        # provider doesn't support _get_metadata_path().
+        except Exception:
+            return '[could not detect]'
+
+        return path
+
+    def _get_metadata(self, name):
+        if self.has_metadata(name):
+            for line in self.get_metadata_lines(name):
+                yield line
+
+    def _get_version(self):
+        lines = self._get_metadata(self.PKG_INFO)
+        version = _version_from_file(lines)
+
+        return version
+
+    def activate(self, path=None, replace=False):
+        """Ensure distribution is importable on `path` (default=sys.path)"""
+        if path is None:
+            path = sys.path
+        self.insert_on(path, replace=replace)
+        if path is sys.path:
+            fixup_namespace_packages(self.location)
+            for pkg in self._get_metadata('namespace_packages.txt'):
+                if pkg in sys.modules:
+                    declare_namespace(pkg)
+
+    def egg_name(self):
+        """Return what this distribution's standard .egg filename should be"""
+        filename = "%s-%s-py%s" % (
+            to_filename(self.project_name), to_filename(self.version),
+            self.py_version or PY_MAJOR
+        )
+
+        if self.platform:
+            filename += '-' + self.platform
+        return filename
+
+    def __repr__(self):
+        if self.location:
+            return "%s (%s)" % (self, self.location)
+        else:
+            return str(self)
+
+    def __str__(self):
+        try:
+            version = getattr(self, 'version', None)
+        except ValueError:
+            version = None
+        version = version or "[unknown version]"
+        return "%s %s" % (self.project_name, version)
+
+    def __getattr__(self, attr):
+        """Delegate all unrecognized public attributes to .metadata provider"""
+        if attr.startswith('_'):
+            raise AttributeError(attr)
+        return getattr(self._provider, attr)
+
+    def __dir__(self):
+        return list(
+            set(super(Distribution, self).__dir__())
+            | set(
+                attr for attr in self._provider.__dir__()
+                if not attr.startswith('_')
+            )
+        )
+
+    if not hasattr(object, '__dir__'):
+        # python 2.7 not supported
+        del __dir__
+
+    @classmethod
+    def from_filename(cls, filename, metadata=None, **kw):
+        return cls.from_location(
+            _normalize_cached(filename), os.path.basename(filename), metadata,
+            **kw
+        )
+
+    def as_requirement(self):
+        """Return a ``Requirement`` that matches this distribution exactly"""
+        if isinstance(self.parsed_version, packaging.version.Version):
+            spec = "%s==%s" % (self.project_name, self.parsed_version)
+        else:
+            spec = "%s===%s" % (self.project_name, self.parsed_version)
+
+        return Requirement.parse(spec)
+
+    def load_entry_point(self, group, name):
+        """Return the `name` entry point of `group` or raise ImportError"""
+        ep = self.get_entry_info(group, name)
+        if ep is None:
+            raise ImportError("Entry point %r not found" % ((group, name),))
+        return ep.load()
+
+    def get_entry_map(self, group=None):
+        """Return the entry point map for `group`, or the full entry map"""
+        try:
+            ep_map = self._ep_map
+        except AttributeError:
+            ep_map = self._ep_map = EntryPoint.parse_map(
+                self._get_metadata('entry_points.txt'), self
+            )
+        if group is not None:
+            return ep_map.get(group, {})
+        return ep_map
+
+    def get_entry_info(self, group, name):
+        """Return the EntryPoint object for `group`+`name`, or ``None``"""
+        return self.get_entry_map(group).get(name)
+
+    def insert_on(self, path, loc=None, replace=False):
+        """Ensure self.location is on path
+
+        If replace=False (default):
+            - If location is already in path anywhere, do nothing.
+            - Else:
+              - If it's an egg and its parent directory is on path,
+                insert just ahead of the parent.
+              - Else: add to the end of path.
+        If replace=True:
+            - If location is already on path anywhere (not eggs)
+              or higher priority than its parent (eggs)
+              do nothing.
+            - Else:
+              - If it's an egg and its parent directory is on path,
+                insert just ahead of the parent,
+                removing any lower-priority entries.
+              - Else: add it to the front of path.
+        """
+
+        loc = loc or self.location
+        if not loc:
+            return
+
+        nloc = _normalize_cached(loc)
+        bdir = os.path.dirname(nloc)
+        npath = [(p and _normalize_cached(p) or p) for p in path]
+
+        for p, item in enumerate(npath):
+            if item == nloc:
+                if replace:
+                    break
+                else:
+                    # don't modify path (even removing duplicates) if
+                    # found and not replace
+                    return
+            elif item == bdir and self.precedence == EGG_DIST:
+                # if it's an .egg, give it precedence over its directory
+                # UNLESS it's already been added to sys.path and replace=False
+                if (not replace) and nloc in npath[p:]:
+                    return
+                if path is sys.path:
+                    self.check_version_conflict()
+                path.insert(p, loc)
+                npath.insert(p, nloc)
+                break
+        else:
+            if path is sys.path:
+                self.check_version_conflict()
+            if replace:
+                path.insert(0, loc)
+            else:
+                path.append(loc)
+            return
+
+        # p is the spot where we found or inserted loc; now remove duplicates
+        while True:
+            try:
+                np = npath.index(nloc, p + 1)
+            except ValueError:
+                break
+            else:
+                del npath[np], path[np]
+                # ha!
+                p = np
+
+        return
+
+    def check_version_conflict(self):
+        if self.key == 'setuptools':
+            # ignore the inevitable setuptools self-conflicts  :(
+            return
+
+        nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt'))
+        loc = normalize_path(self.location)
+        for modname in self._get_metadata('top_level.txt'):
+            if (modname not in sys.modules or modname in nsp
+                    or modname in _namespace_packages):
+                continue
+            if modname in ('pkg_resources', 'setuptools', 'site'):
+                continue
+            fn = getattr(sys.modules[modname], '__file__', None)
+            if fn and (normalize_path(fn).startswith(loc) or
+                       fn.startswith(self.location)):
+                continue
+            issue_warning(
+                "Module %s was already imported from %s, but %s is being added"
+                " to sys.path" % (modname, fn, self.location),
+            )
+
+    def has_version(self):
+        try:
+            self.version
+        except ValueError:
+            issue_warning("Unbuilt egg for " + repr(self))
+            return False
+        return True
+
+    def clone(self, **kw):
+        """Copy this distribution, substituting in any changed keyword args"""
+        names = 'project_name version py_version platform location precedence'
+        for attr in names.split():
+            kw.setdefault(attr, getattr(self, attr, None))
+        kw.setdefault('metadata', self._provider)
+        return self.__class__(**kw)
+
+    @property
+    def extras(self):
+        return [dep for dep in self._dep_map if dep]
+
+
+class EggInfoDistribution(Distribution):
+    def _reload_version(self):
+        """
+        Packages installed by distutils (e.g. numpy or scipy),
+        which uses an old safe_version, and so
+        their version numbers can get mangled when
+        converted to filenames (e.g., 1.11.0.dev0+2329eae to
+        1.11.0.dev0_2329eae). These distributions will not be
+        parsed properly
+        downstream by Distribution and safe_version, so
+        take an extra step and try to get the version number from
+        the metadata file itself instead of the filename.
+        """
+        md_version = self._get_version()
+        if md_version:
+            self._version = md_version
+        return self
+
+
+class DistInfoDistribution(Distribution):
+    """
+    Wrap an actual or potential sys.path entry
+    w/metadata, .dist-info style.
+    """
+    PKG_INFO = 'METADATA'
+    EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])")
+
+    @property
+    def _parsed_pkg_info(self):
+        """Parse and cache metadata"""
+        try:
+            return self._pkg_info
+        except AttributeError:
+            metadata = self.get_metadata(self.PKG_INFO)
+            self._pkg_info = email.parser.Parser().parsestr(metadata)
+            return self._pkg_info
+
+    @property
+    def _dep_map(self):
+        try:
+            return self.__dep_map
+        except AttributeError:
+            self.__dep_map = self._compute_dependencies()
+            return self.__dep_map
+
+    def _compute_dependencies(self):
+        """Recompute this distribution's dependencies."""
+        dm = self.__dep_map = {None: []}
+
+        reqs = []
+        # Including any condition expressions
+        for req in self._parsed_pkg_info.get_all('Requires-Dist') or []:
+            reqs.extend(parse_requirements(req))
+
+        def reqs_for_extra(extra):
+            for req in reqs:
+                if not req.marker or req.marker.evaluate({'extra': extra}):
+                    yield req
+
+        common = frozenset(reqs_for_extra(None))
+        dm[None].extend(common)
+
+        for extra in self._parsed_pkg_info.get_all('Provides-Extra') or []:
+            s_extra = safe_extra(extra.strip())
+            dm[s_extra] = list(frozenset(reqs_for_extra(extra)) - common)
+
+        return dm
+
+
+_distributionImpl = {
+    '.egg': Distribution,
+    '.egg-info': EggInfoDistribution,
+    '.dist-info': DistInfoDistribution,
+}
+
+
+def issue_warning(*args, **kw):
+    level = 1
+    g = globals()
+    try:
+        # find the first stack frame that is *not* code in
+        # the pkg_resources module, to use for the warning
+        while sys._getframe(level).f_globals is g:
+            level += 1
+    except ValueError:
+        pass
+    warnings.warn(stacklevel=level + 1, *args, **kw)
+
+
+def parse_requirements(strs):
+    """Yield ``Requirement`` objects for each specification in `strs`
+
+    `strs` must be a string, or a (possibly-nested) iterable thereof.
+    """
+    # create a steppable iterator, so we can handle \-continuations
+    lines = iter(yield_lines(strs))
+
+    for line in lines:
+        # Drop comments -- a hash without a space may be in a URL.
+        if ' #' in line:
+            line = line[:line.find(' #')]
+        # If there is a line continuation, drop it, and append the next line.
+        if line.endswith('\\'):
+            line = line[:-2].strip()
+            try:
+                line += next(lines)
+            except StopIteration:
+                return
+        yield Requirement(line)
+
+
+class RequirementParseError(packaging.requirements.InvalidRequirement):
+    "Compatibility wrapper for InvalidRequirement"
+
+
+class Requirement(packaging.requirements.Requirement):
+    def __init__(self, requirement_string):
+        """DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!"""
+        super(Requirement, self).__init__(requirement_string)
+        self.unsafe_name = self.name
+        project_name = safe_name(self.name)
+        self.project_name, self.key = project_name, project_name.lower()
+        self.specs = [
+            (spec.operator, spec.version) for spec in self.specifier]
+        self.extras = tuple(map(safe_extra, self.extras))
+        self.hashCmp = (
+            self.key,
+            self.url,
+            self.specifier,
+            frozenset(self.extras),
+            str(self.marker) if self.marker else None,
+        )
+        self.__hash = hash(self.hashCmp)
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, Requirement) and
+            self.hashCmp == other.hashCmp
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __contains__(self, item):
+        if isinstance(item, Distribution):
+            if item.key != self.key:
+                return False
+
+            item = item.version
+
+        # Allow prereleases always in order to match the previous behavior of
+        # this method. In the future this should be smarter and follow PEP 440
+        # more accurately.
+        return self.specifier.contains(item, prereleases=True)
+
+    def __hash__(self):
+        return self.__hash
+
+    def __repr__(self):
+        return "Requirement.parse(%r)" % str(self)
+
+    @staticmethod
+    def parse(s):
+        req, = parse_requirements(s)
+        return req
+
+
+def _always_object(classes):
+    """
+    Ensure object appears in the mro even
+    for old-style classes.
+    """
+    if object not in classes:
+        return classes + (object,)
+    return classes
+
+
+def _find_adapter(registry, ob):
+    """Return an adapter factory for `ob` from `registry`"""
+    types = _always_object(inspect.getmro(getattr(ob, '__class__', type(ob))))
+    for t in types:
+        if t in registry:
+            return registry[t]
+
+
+def ensure_directory(path):
+    """Ensure that the parent directory of `path` exists"""
+    dirname = os.path.dirname(path)
+    os.makedirs(dirname, exist_ok=True)
+
+
+def _bypass_ensure_directory(path):
+    """Sandbox-bypassing version of ensure_directory()"""
+    if not WRITE_SUPPORT:
+        raise IOError('"os.mkdir" not supported on this platform.')
+    dirname, filename = split(path)
+    if dirname and filename and not isdir(dirname):
+        _bypass_ensure_directory(dirname)
+        try:
+            mkdir(dirname, 0o755)
+        except FileExistsError:
+            pass
+
+
+def split_sections(s):
+    """Split a string or iterable thereof into (section, content) pairs
+
+    Each ``section`` is a stripped version of the section header ("[section]")
+    and each ``content`` is a list of stripped lines excluding blank lines and
+    comment-only lines.  If there are any such lines before the first section
+    header, they're returned in a first ``section`` of ``None``.
+    """
+    section = None
+    content = []
+    for line in yield_lines(s):
+        if line.startswith("["):
+            if line.endswith("]"):
+                if section or content:
+                    yield section, content
+                section = line[1:-1].strip()
+                content = []
+            else:
+                raise ValueError("Invalid section heading", line)
+        else:
+            content.append(line)
+
+    # wrap up last segment
+    yield section, content
+
+
+def _mkstemp(*args, **kw):
+    old_open = os.open
+    try:
+        # temporarily bypass sandboxing
+        os.open = os_open
+        return tempfile.mkstemp(*args, **kw)
+    finally:
+        # and then put it back
+        os.open = old_open
+
+
+# Silence the PEP440Warning by default, so that end users don't get hit by it
+# randomly just because they use pkg_resources. We want to append the rule
+# because we want earlier uses of filterwarnings to take precedence over this
+# one.
+warnings.filterwarnings("ignore", category=PEP440Warning, append=True)
+
+
+# from jaraco.functools 1.3
+def _call_aside(f, *args, **kwargs):
+    f(*args, **kwargs)
+    return f
+
+
+@_call_aside
+def _initialize(g=globals()):
+    "Set up global resource manager (deliberately not state-saved)"
+    manager = ResourceManager()
+    g['_manager'] = manager
+    g.update(
+        (name, getattr(manager, name))
+        for name in dir(manager)
+        if not name.startswith('_')
+    )
+
+
+@_call_aside
+def _initialize_master_working_set():
+    """
+    Prepare the master working set and make the ``require()``
+    API available.
+
+    This function has explicit effects on the global state
+    of pkg_resources. It is intended to be invoked once at
+    the initialization of this module.
+
+    Invocation by other packages is unsupported and done
+    at their own risk.
+    """
+    working_set = WorkingSet._build_master()
+    _declare_state('object', working_set=working_set)
+
+    require = working_set.require
+    iter_entry_points = working_set.iter_entry_points
+    add_activation_listener = working_set.subscribe
+    run_script = working_set.run_script
+    # backward compatibility
+    run_main = run_script
+    # Activate all distributions already on sys.path with replace=False and
+    # ensure that all distributions added to the working set in the future
+    # (e.g. by calling ``require()``) will get activated as well,
+    # with higher priority (replace=True).
+    tuple(
+        dist.activate(replace=False)
+        for dist in working_set
+    )
+    add_activation_listener(
+        lambda dist: dist.activate(replace=True),
+        existing=False,
+    )
+    working_set.entries = []
+    # match order
+    list(map(working_set.add_entry, sys.path))
+    globals().update(locals())
+
+
+class PkgResourcesDeprecationWarning(Warning):
+    """
+    Base class for warning about deprecations in ``pkg_resources``
+
+    This class is not derived from ``DeprecationWarning``, and as such is
+    visible by default.
+    """
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/__init__.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/appdirs.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/appdirs.py
new file mode 100644
index 0000000..ae67001
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/appdirs.py
@@ -0,0 +1,608 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2005-2010 ActiveState Software Inc.
+# Copyright (c) 2013 Eddy Petrișor
+
+"""Utilities for determining application-specific dirs.
+
+See <http://github.com/ActiveState/appdirs> for details and usage.
+"""
+# Dev Notes:
+# - MSDN on where to store app data files:
+#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
+# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
+# - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+__version_info__ = (1, 4, 3)
+__version__ = '.'.join(map(str, __version_info__))
+
+
+import sys
+import os
+
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    unicode = str
+
+if sys.platform.startswith('java'):
+    import platform
+    os_name = platform.java_ver()[3][0]
+    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc.
+        system = 'win32'
+    elif os_name.startswith('Mac'): # "Mac OS X", etc.
+        system = 'darwin'
+    else: # "Linux", "SunOS", "FreeBSD", etc.
+        # Setting this to "linux2" is not ideal, but only Windows or Mac
+        # are actually checked for and the rest of the module expects
+        # *sys.platform* style strings.
+        system = 'linux2'
+else:
+    system = sys.platform
+
+
+
+def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user data directories are:
+        Mac OS X:               ~/Library/Application Support/<AppName>
+        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined
+        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName>
+        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>
+        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>
+        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName>
+
+    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
+    That means, by default "~/.local/share/<AppName>".
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
+        path = os.path.normpath(_get_win_folder(const))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Application Support/')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of data dirs should be
+            returned. By default, the first item from XDG_DATA_DIRS is
+            returned, or '/usr/local/share/<AppName>',
+            if XDG_DATA_DIRS is not set
+
+    Typical site data directories are:
+        Mac OS X:   /Library/Application Support/<AppName>
+        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName>
+        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName>
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7.
+
+    For Unix, this is using the $XDG_DATA_DIRS[0] default.
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('/Library/Application Support')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        # XDG default for $XDG_DATA_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_DATA_DIRS',
+                         os.pathsep.join(['/usr/local/share', '/usr/share']))
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+        return path
+
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific config dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user config directories are:
+        Mac OS X:               same as user_data_dir
+        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined
+        Win *:                  same as user_data_dir
+
+    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
+    That means, by default "~/.config/<AppName>".
+    """
+    if system in ["win32", "darwin"]:
+        path = user_data_dir(appname, appauthor, None, roaming)
+    else:
+        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of config dirs should be
+            returned. By default, the first item from XDG_CONFIG_DIRS is
+            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set
+
+    Typical site config directories are:
+        Mac OS X:   same as site_data_dir
+        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in
+                    $XDG_CONFIG_DIRS
+        Win *:      same as site_data_dir
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+
+    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system in ["win32", "darwin"]:
+        path = site_data_dir(appname, appauthor)
+        if appname and version:
+            path = os.path.join(path, version)
+    else:
+        # XDG default for $XDG_CONFIG_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+    return path
+
+
+def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific cache dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Cache" to the base app data dir for Windows. See
+            discussion below.
+
+    Typical user cache directories are:
+        Mac OS X:   ~/Library/Caches/<AppName>
+        Unix:       ~/.cache/<AppName> (XDG default)
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache
+
+    On Windows the only suggestion in the MSDN docs is that local settings go in
+    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
+    app data dir (the default returned by `user_data_dir` above). Apps typically
+    put cache data somewhere *under* the given dir here. Some examples:
+        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
+        ...\Acme\SuperApp\Cache\1.0
+    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+            if opinion:
+                path = os.path.join(path, "Cache")
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Caches')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_state_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific state dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user state directories are:
+        Mac OS X:  same as user_data_dir
+        Unix:      ~/.local/state/<AppName>   # or in $XDG_STATE_HOME, if defined
+        Win *:     same as user_data_dir
+
+    For Unix, we follow this Debian proposal <https://wiki.debian.org/XDGBaseDirectorySpecification#state>
+    to extend the XDG spec and support $XDG_STATE_HOME.
+
+    That means, by default "~/.local/state/<AppName>".
+    """
+    if system in ["win32", "darwin"]:
+        path = user_data_dir(appname, appauthor, None, roaming)
+    else:
+        path = os.getenv('XDG_STATE_HOME', os.path.expanduser("~/.local/state"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific log dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Logs" to the base app data dir for Windows, and "log" to the
+            base cache dir for Unix. See discussion below.
+
+    Typical user log directories are:
+        Mac OS X:   ~/Library/Logs/<AppName>
+        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs
+
+    On Windows the only suggestion in the MSDN docs is that local settings
+    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
+    examples of what some windows apps use for a logs dir.)
+
+    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
+    value for Windows and appends "log" to the user cache dir for Unix.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "darwin":
+        path = os.path.join(
+            os.path.expanduser('~/Library/Logs'),
+            appname)
+    elif system == "win32":
+        path = user_data_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "Logs")
+    else:
+        path = user_cache_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "log")
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+class AppDirs(object):
+    """Convenience wrapper for getting application dirs."""
+    def __init__(self, appname=None, appauthor=None, version=None,
+            roaming=False, multipath=False):
+        self.appname = appname
+        self.appauthor = appauthor
+        self.version = version
+        self.roaming = roaming
+        self.multipath = multipath
+
+    @property
+    def user_data_dir(self):
+        return user_data_dir(self.appname, self.appauthor,
+                             version=self.version, roaming=self.roaming)
+
+    @property
+    def site_data_dir(self):
+        return site_data_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_config_dir(self):
+        return user_config_dir(self.appname, self.appauthor,
+                               version=self.version, roaming=self.roaming)
+
+    @property
+    def site_config_dir(self):
+        return site_config_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_cache_dir(self):
+        return user_cache_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_state_dir(self):
+        return user_state_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_log_dir(self):
+        return user_log_dir(self.appname, self.appauthor,
+                            version=self.version)
+
+
+#---- internal support stuff
+
+def _get_win_folder_from_registry(csidl_name):
+    """This is a fallback technique at best. I'm not sure if using the
+    registry for this guarantees us the correct answer for all CSIDL_*
+    names.
+    """
+    if PY3:
+      import winreg as _winreg
+    else:
+      import _winreg
+
+    shell_folder_name = {
+        "CSIDL_APPDATA": "AppData",
+        "CSIDL_COMMON_APPDATA": "Common AppData",
+        "CSIDL_LOCAL_APPDATA": "Local AppData",
+    }[csidl_name]
+
+    key = _winreg.OpenKey(
+        _winreg.HKEY_CURRENT_USER,
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
+    )
+    dir, type = _winreg.QueryValueEx(key, shell_folder_name)
+    return dir
+
+
+def _get_win_folder_with_pywin32(csidl_name):
+    from win32com.shell import shellcon, shell
+    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
+    # Try to make this a unicode path because SHGetFolderPath does
+    # not return unicode strings when there is unicode data in the
+    # path.
+    try:
+        dir = unicode(dir)
+
+        # Downgrade to short path name if have highbit chars. See
+        # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+        has_high_char = False
+        for c in dir:
+            if ord(c) > 255:
+                has_high_char = True
+                break
+        if has_high_char:
+            try:
+                import win32api
+                dir = win32api.GetShortPathName(dir)
+            except ImportError:
+                pass
+    except UnicodeError:
+        pass
+    return dir
+
+
+def _get_win_folder_with_ctypes(csidl_name):
+    import ctypes
+
+    csidl_const = {
+        "CSIDL_APPDATA": 26,
+        "CSIDL_COMMON_APPDATA": 35,
+        "CSIDL_LOCAL_APPDATA": 28,
+    }[csidl_name]
+
+    buf = ctypes.create_unicode_buffer(1024)
+    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in buf:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf2 = ctypes.create_unicode_buffer(1024)
+        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+            buf = buf2
+
+    return buf.value
+
+def _get_win_folder_with_jna(csidl_name):
+    import array
+    from com.sun import jna
+    from com.sun.jna.platform import win32
+
+    buf_size = win32.WinDef.MAX_PATH * 2
+    buf = array.zeros('c', buf_size)
+    shell = win32.Shell32.INSTANCE
+    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf)
+    dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in dir:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf = array.zeros('c', buf_size)
+        kernel = win32.Kernel32.INSTANCE
+        if kernel.GetShortPathName(dir, buf, buf_size):
+            dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    return dir
+
+if system == "win32":
+    try:
+        import win32com.shell
+        _get_win_folder = _get_win_folder_with_pywin32
+    except ImportError:
+        try:
+            from ctypes import windll
+            _get_win_folder = _get_win_folder_with_ctypes
+        except ImportError:
+            try:
+                import com.sun.jna
+                _get_win_folder = _get_win_folder_with_jna
+            except ImportError:
+                _get_win_folder = _get_win_folder_from_registry
+
+
+#---- self test code
+
+if __name__ == "__main__":
+    appname = "MyApp"
+    appauthor = "MyCompany"
+
+    props = ("user_data_dir",
+             "user_config_dir",
+             "user_cache_dir",
+             "user_state_dir",
+             "user_log_dir",
+             "site_data_dir",
+             "site_config_dir")
+
+    print("-- app dirs %s --" % __version__)
+
+    print("-- app dirs (with optional 'version')")
+    dirs = AppDirs(appname, appauthor, version="1.0")
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'version')")
+    dirs = AppDirs(appname, appauthor)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'appauthor')")
+    dirs = AppDirs(appname)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (with disabled 'appauthor')")
+    dirs = AppDirs(appname, appauthor=False)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/__about__.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/__about__.py
new file mode 100644
index 0000000..dc95138
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/__about__.py
@@ -0,0 +1,27 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
+
+__title__ = "packaging"
+__summary__ = "Core utilities for Python packages"
+__uri__ = "https://github.com/pypa/packaging"
+
+__version__ = "19.2"
+
+__author__ = "Donald Stufft and individual contributors"
+__email__ = "donald@stufft.io"
+
+__license__ = "BSD or Apache License, Version 2.0"
+__copyright__ = "Copyright 2014-2019 %s" % __author__
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/__init__.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/__init__.py
new file mode 100644
index 0000000..a0cf67d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/__init__.py
@@ -0,0 +1,26 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+from .__about__ import (
+    __author__,
+    __copyright__,
+    __email__,
+    __license__,
+    __summary__,
+    __title__,
+    __uri__,
+    __version__,
+)
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/_compat.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/_compat.py
new file mode 100644
index 0000000..25da473
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/_compat.py
@@ -0,0 +1,31 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import sys
+
+
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+# flake8: noqa
+
+if PY3:
+    string_types = (str,)
+else:
+    string_types = (basestring,)
+
+
+def with_metaclass(meta, *bases):
+    """
+    Create a base class with a metaclass.
+    """
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+
+    return type.__new__(metaclass, "temporary_class", (), {})
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/_structures.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/_structures.py
new file mode 100644
index 0000000..68dcca6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/_structures.py
@@ -0,0 +1,68 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+
+class Infinity(object):
+    def __repr__(self):
+        return "Infinity"
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def __lt__(self, other):
+        return False
+
+    def __le__(self, other):
+        return False
+
+    def __eq__(self, other):
+        return isinstance(other, self.__class__)
+
+    def __ne__(self, other):
+        return not isinstance(other, self.__class__)
+
+    def __gt__(self, other):
+        return True
+
+    def __ge__(self, other):
+        return True
+
+    def __neg__(self):
+        return NegativeInfinity
+
+
+Infinity = Infinity()
+
+
+class NegativeInfinity(object):
+    def __repr__(self):
+        return "-Infinity"
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def __lt__(self, other):
+        return True
+
+    def __le__(self, other):
+        return True
+
+    def __eq__(self, other):
+        return isinstance(other, self.__class__)
+
+    def __ne__(self, other):
+        return not isinstance(other, self.__class__)
+
+    def __gt__(self, other):
+        return False
+
+    def __ge__(self, other):
+        return False
+
+    def __neg__(self):
+        return Infinity
+
+
+NegativeInfinity = NegativeInfinity()
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/markers.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/markers.py
new file mode 100644
index 0000000..733123f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/markers.py
@@ -0,0 +1,296 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import operator
+import os
+import platform
+import sys
+
+from pkg_resources.extern.pyparsing import ParseException, ParseResults, stringStart, stringEnd
+from pkg_resources.extern.pyparsing import ZeroOrMore, Group, Forward, QuotedString
+from pkg_resources.extern.pyparsing import Literal as L  # noqa
+
+from ._compat import string_types
+from .specifiers import Specifier, InvalidSpecifier
+
+
+__all__ = [
+    "InvalidMarker",
+    "UndefinedComparison",
+    "UndefinedEnvironmentName",
+    "Marker",
+    "default_environment",
+]
+
+
+class InvalidMarker(ValueError):
+    """
+    An invalid marker was found, users should refer to PEP 508.
+    """
+
+
+class UndefinedComparison(ValueError):
+    """
+    An invalid operation was attempted on a value that doesn't support it.
+    """
+
+
+class UndefinedEnvironmentName(ValueError):
+    """
+    A name was attempted to be used that does not exist inside of the
+    environment.
+    """
+
+
+class Node(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return str(self.value)
+
+    def __repr__(self):
+        return "<{0}({1!r})>".format(self.__class__.__name__, str(self))
+
+    def serialize(self):
+        raise NotImplementedError
+
+
+class Variable(Node):
+    def serialize(self):
+        return str(self)
+
+
+class Value(Node):
+    def serialize(self):
+        return '"{0}"'.format(self)
+
+
+class Op(Node):
+    def serialize(self):
+        return str(self)
+
+
+VARIABLE = (
+    L("implementation_version")
+    | L("platform_python_implementation")
+    | L("implementation_name")
+    | L("python_full_version")
+    | L("platform_release")
+    | L("platform_version")
+    | L("platform_machine")
+    | L("platform_system")
+    | L("python_version")
+    | L("sys_platform")
+    | L("os_name")
+    | L("os.name")
+    | L("sys.platform")  # PEP-345
+    | L("platform.version")  # PEP-345
+    | L("platform.machine")  # PEP-345
+    | L("platform.python_implementation")  # PEP-345
+    | L("python_implementation")  # PEP-345
+    | L("extra")  # undocumented setuptools legacy
+)
+ALIASES = {
+    "os.name": "os_name",
+    "sys.platform": "sys_platform",
+    "platform.version": "platform_version",
+    "platform.machine": "platform_machine",
+    "platform.python_implementation": "platform_python_implementation",
+    "python_implementation": "platform_python_implementation",
+}
+VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))
+
+VERSION_CMP = (
+    L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<")
+)
+
+MARKER_OP = VERSION_CMP | L("not in") | L("in")
+MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))
+
+MARKER_VALUE = QuotedString("'") | QuotedString('"')
+MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
+
+BOOLOP = L("and") | L("or")
+
+MARKER_VAR = VARIABLE | MARKER_VALUE
+
+MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
+MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
+
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+
+MARKER_EXPR = Forward()
+MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
+MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
+
+MARKER = stringStart + MARKER_EXPR + stringEnd
+
+
+def _coerce_parse_result(results):
+    if isinstance(results, ParseResults):
+        return [_coerce_parse_result(i) for i in results]
+    else:
+        return results
+
+
+def _format_marker(marker, first=True):
+    assert isinstance(marker, (list, tuple, string_types))
+
+    # Sometimes we have a structure like [[...]] which is a single item list
+    # where the single item is itself it's own list. In that case we want skip
+    # the rest of this function so that we don't get extraneous () on the
+    # outside.
+    if (
+        isinstance(marker, list)
+        and len(marker) == 1
+        and isinstance(marker[0], (list, tuple))
+    ):
+        return _format_marker(marker[0])
+
+    if isinstance(marker, list):
+        inner = (_format_marker(m, first=False) for m in marker)
+        if first:
+            return " ".join(inner)
+        else:
+            return "(" + " ".join(inner) + ")"
+    elif isinstance(marker, tuple):
+        return " ".join([m.serialize() for m in marker])
+    else:
+        return marker
+
+
+_operators = {
+    "in": lambda lhs, rhs: lhs in rhs,
+    "not in": lambda lhs, rhs: lhs not in rhs,
+    "<": operator.lt,
+    "<=": operator.le,
+    "==": operator.eq,
+    "!=": operator.ne,
+    ">=": operator.ge,
+    ">": operator.gt,
+}
+
+
+def _eval_op(lhs, op, rhs):
+    try:
+        spec = Specifier("".join([op.serialize(), rhs]))
+    except InvalidSpecifier:
+        pass
+    else:
+        return spec.contains(lhs)
+
+    oper = _operators.get(op.serialize())
+    if oper is None:
+        raise UndefinedComparison(
+            "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs)
+        )
+
+    return oper(lhs, rhs)
+
+
+_undefined = object()
+
+
+def _get_env(environment, name):
+    value = environment.get(name, _undefined)
+
+    if value is _undefined:
+        raise UndefinedEnvironmentName(
+            "{0!r} does not exist in evaluation environment.".format(name)
+        )
+
+    return value
+
+
+def _evaluate_markers(markers, environment):
+    groups = [[]]
+
+    for marker in markers:
+        assert isinstance(marker, (list, tuple, string_types))
+
+        if isinstance(marker, list):
+            groups[-1].append(_evaluate_markers(marker, environment))
+        elif isinstance(marker, tuple):
+            lhs, op, rhs = marker
+
+            if isinstance(lhs, Variable):
+                lhs_value = _get_env(environment, lhs.value)
+                rhs_value = rhs.value
+            else:
+                lhs_value = lhs.value
+                rhs_value = _get_env(environment, rhs.value)
+
+            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
+        else:
+            assert marker in ["and", "or"]
+            if marker == "or":
+                groups.append([])
+
+    return any(all(item) for item in groups)
+
+
+def format_full_version(info):
+    version = "{0.major}.{0.minor}.{0.micro}".format(info)
+    kind = info.releaselevel
+    if kind != "final":
+        version += kind[0] + str(info.serial)
+    return version
+
+
+def default_environment():
+    if hasattr(sys, "implementation"):
+        iver = format_full_version(sys.implementation.version)
+        implementation_name = sys.implementation.name
+    else:
+        iver = "0"
+        implementation_name = ""
+
+    return {
+        "implementation_name": implementation_name,
+        "implementation_version": iver,
+        "os_name": os.name,
+        "platform_machine": platform.machine(),
+        "platform_release": platform.release(),
+        "platform_system": platform.system(),
+        "platform_version": platform.version(),
+        "python_full_version": platform.python_version(),
+        "platform_python_implementation": platform.python_implementation(),
+        "python_version": ".".join(platform.python_version_tuple()[:2]),
+        "sys_platform": sys.platform,
+    }
+
+
+class Marker(object):
+    def __init__(self, marker):
+        try:
+            self._markers = _coerce_parse_result(MARKER.parseString(marker))
+        except ParseException as e:
+            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format(
+                marker, marker[e.loc : e.loc + 8]
+            )
+            raise InvalidMarker(err_str)
+
+    def __str__(self):
+        return _format_marker(self._markers)
+
+    def __repr__(self):
+        return "<Marker({0!r})>".format(str(self))
+
+    def evaluate(self, environment=None):
+        """Evaluate a marker.
+
+        Return the boolean from evaluating the given marker against the
+        environment. environment is an optional argument to override all or
+        part of the determined environment.
+
+        The environment is determined from the current Python process.
+        """
+        current_environment = default_environment()
+        if environment is not None:
+            current_environment.update(environment)
+
+        return _evaluate_markers(self._markers, current_environment)
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/requirements.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/requirements.py
new file mode 100644
index 0000000..c3424dc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/requirements.py
@@ -0,0 +1,138 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import string
+import re
+
+from pkg_resources.extern.pyparsing import stringStart, stringEnd, originalTextFor, ParseException
+from pkg_resources.extern.pyparsing import ZeroOrMore, Word, Optional, Regex, Combine
+from pkg_resources.extern.pyparsing import Literal as L  # noqa
+from pkg_resources.extern.six.moves.urllib import parse as urlparse
+
+from .markers import MARKER_EXPR, Marker
+from .specifiers import LegacySpecifier, Specifier, SpecifierSet
+
+
+class InvalidRequirement(ValueError):
+    """
+    An invalid requirement was found, users should refer to PEP 508.
+    """
+
+
+ALPHANUM = Word(string.ascii_letters + string.digits)
+
+LBRACKET = L("[").suppress()
+RBRACKET = L("]").suppress()
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+COMMA = L(",").suppress()
+SEMICOLON = L(";").suppress()
+AT = L("@").suppress()
+
+PUNCTUATION = Word("-_.")
+IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
+IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
+
+NAME = IDENTIFIER("name")
+EXTRA = IDENTIFIER
+
+URI = Regex(r"[^ ]+")("url")
+URL = AT + URI
+
+EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
+EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
+
+VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
+VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
+
+VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
+VERSION_MANY = Combine(
+    VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False
+)("_raw_spec")
+_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY))
+_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "")
+
+VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
+VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
+
+MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
+MARKER_EXPR.setParseAction(
+    lambda s, l, t: Marker(s[t._original_start : t._original_end])
+)
+MARKER_SEPARATOR = SEMICOLON
+MARKER = MARKER_SEPARATOR + MARKER_EXPR
+
+VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
+URL_AND_MARKER = URL + Optional(MARKER)
+
+NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
+
+REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
+# pkg_resources.extern.pyparsing isn't thread safe during initialization, so we do it eagerly, see
+# issue #104
+REQUIREMENT.parseString("x[]")
+
+
+class Requirement(object):
+    """Parse a requirement.
+
+    Parse a given requirement string into its parts, such as name, specifier,
+    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
+    string.
+    """
+
+    # TODO: Can we test whether something is contained within a requirement?
+    #       If so how do we do that? Do we need to test against the _name_ of
+    #       the thing as well as the version? What about the markers?
+    # TODO: Can we normalize the name and extra name?
+
+    def __init__(self, requirement_string):
+        try:
+            req = REQUIREMENT.parseString(requirement_string)
+        except ParseException as e:
+            raise InvalidRequirement(
+                'Parse error at "{0!r}": {1}'.format(
+                    requirement_string[e.loc : e.loc + 8], e.msg
+                )
+            )
+
+        self.name = req.name
+        if req.url:
+            parsed_url = urlparse.urlparse(req.url)
+            if parsed_url.scheme == "file":
+                if urlparse.urlunparse(parsed_url) != req.url:
+                    raise InvalidRequirement("Invalid URL given")
+            elif not (parsed_url.scheme and parsed_url.netloc) or (
+                not parsed_url.scheme and not parsed_url.netloc
+            ):
+                raise InvalidRequirement("Invalid URL: {0}".format(req.url))
+            self.url = req.url
+        else:
+            self.url = None
+        self.extras = set(req.extras.asList() if req.extras else [])
+        self.specifier = SpecifierSet(req.specifier)
+        self.marker = req.marker if req.marker else None
+
+    def __str__(self):
+        parts = [self.name]
+
+        if self.extras:
+            parts.append("[{0}]".format(",".join(sorted(self.extras))))
+
+        if self.specifier:
+            parts.append(str(self.specifier))
+
+        if self.url:
+            parts.append("@ {0}".format(self.url))
+            if self.marker:
+                parts.append(" ")
+
+        if self.marker:
+            parts.append("; {0}".format(self.marker))
+
+        return "".join(parts)
+
+    def __repr__(self):
+        return "<Requirement({0!r})>".format(str(self))
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/specifiers.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/specifiers.py
new file mode 100644
index 0000000..743576a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/specifiers.py
@@ -0,0 +1,749 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import abc
+import functools
+import itertools
+import re
+
+from ._compat import string_types, with_metaclass
+from .version import Version, LegacyVersion, parse
+
+
+class InvalidSpecifier(ValueError):
+    """
+    An invalid specifier was found, users should refer to PEP 440.
+    """
+
+
+class BaseSpecifier(with_metaclass(abc.ABCMeta, object)):
+    @abc.abstractmethod
+    def __str__(self):
+        """
+        Returns the str representation of this Specifier like object. This
+        should be representative of the Specifier itself.
+        """
+
+    @abc.abstractmethod
+    def __hash__(self):
+        """
+        Returns a hash value for this Specifier like object.
+        """
+
+    @abc.abstractmethod
+    def __eq__(self, other):
+        """
+        Returns a boolean representing whether or not the two Specifier like
+        objects are equal.
+        """
+
+    @abc.abstractmethod
+    def __ne__(self, other):
+        """
+        Returns a boolean representing whether or not the two Specifier like
+        objects are not equal.
+        """
+
+    @abc.abstractproperty
+    def prereleases(self):
+        """
+        Returns whether or not pre-releases as a whole are allowed by this
+        specifier.
+        """
+
+    @prereleases.setter
+    def prereleases(self, value):
+        """
+        Sets whether or not pre-releases as a whole are allowed by this
+        specifier.
+        """
+
+    @abc.abstractmethod
+    def contains(self, item, prereleases=None):
+        """
+        Determines if the given item is contained within this specifier.
+        """
+
+    @abc.abstractmethod
+    def filter(self, iterable, prereleases=None):
+        """
+        Takes an iterable of items and filters them so that only items which
+        are contained within this specifier are allowed in it.
+        """
+
+
+class _IndividualSpecifier(BaseSpecifier):
+
+    _operators = {}
+
+    def __init__(self, spec="", prereleases=None):
+        match = self._regex.search(spec)
+        if not match:
+            raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec))
+
+        self._spec = (match.group("operator").strip(), match.group("version").strip())
+
+        # Store whether or not this Specifier should accept prereleases
+        self._prereleases = prereleases
+
+    def __repr__(self):
+        pre = (
+            ", prereleases={0!r}".format(self.prereleases)
+            if self._prereleases is not None
+            else ""
+        )
+
+        return "<{0}({1!r}{2})>".format(self.__class__.__name__, str(self), pre)
+
+    def __str__(self):
+        return "{0}{1}".format(*self._spec)
+
+    def __hash__(self):
+        return hash(self._spec)
+
+    def __eq__(self, other):
+        if isinstance(other, string_types):
+            try:
+                other = self.__class__(other)
+            except InvalidSpecifier:
+                return NotImplemented
+        elif not isinstance(other, self.__class__):
+            return NotImplemented
+
+        return self._spec == other._spec
+
+    def __ne__(self, other):
+        if isinstance(other, string_types):
+            try:
+                other = self.__class__(other)
+            except InvalidSpecifier:
+                return NotImplemented
+        elif not isinstance(other, self.__class__):
+            return NotImplemented
+
+        return self._spec != other._spec
+
+    def _get_operator(self, op):
+        return getattr(self, "_compare_{0}".format(self._operators[op]))
+
+    def _coerce_version(self, version):
+        if not isinstance(version, (LegacyVersion, Version)):
+            version = parse(version)
+        return version
+
+    @property
+    def operator(self):
+        return self._spec[0]
+
+    @property
+    def version(self):
+        return self._spec[1]
+
+    @property
+    def prereleases(self):
+        return self._prereleases
+
+    @prereleases.setter
+    def prereleases(self, value):
+        self._prereleases = value
+
+    def __contains__(self, item):
+        return self.contains(item)
+
+    def contains(self, item, prereleases=None):
+        # Determine if prereleases are to be allowed or not.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # Normalize item to a Version or LegacyVersion, this allows us to have
+        # a shortcut for ``"2.0" in Specifier(">=2")
+        item = self._coerce_version(item)
+
+        # Determine if we should be supporting prereleases in this specifier
+        # or not, if we do not support prereleases than we can short circuit
+        # logic if this version is a prereleases.
+        if item.is_prerelease and not prereleases:
+            return False
+
+        # Actually do the comparison to determine if this item is contained
+        # within this Specifier or not.
+        return self._get_operator(self.operator)(item, self.version)
+
+    def filter(self, iterable, prereleases=None):
+        yielded = False
+        found_prereleases = []
+
+        kw = {"prereleases": prereleases if prereleases is not None else True}
+
+        # Attempt to iterate over all the values in the iterable and if any of
+        # them match, yield them.
+        for version in iterable:
+            parsed_version = self._coerce_version(version)
+
+            if self.contains(parsed_version, **kw):
+                # If our version is a prerelease, and we were not set to allow
+                # prereleases, then we'll store it for later incase nothing
+                # else matches this specifier.
+                if parsed_version.is_prerelease and not (
+                    prereleases or self.prereleases
+                ):
+                    found_prereleases.append(version)
+                # Either this is not a prerelease, or we should have been
+                # accepting prereleases from the beginning.
+                else:
+                    yielded = True
+                    yield version
+
+        # Now that we've iterated over everything, determine if we've yielded
+        # any values, and if we have not and we have any prereleases stored up
+        # then we will go ahead and yield the prereleases.
+        if not yielded and found_prereleases:
+            for version in found_prereleases:
+                yield version
+
+
+class LegacySpecifier(_IndividualSpecifier):
+
+    _regex_str = r"""
+        (?P<operator>(==|!=|<=|>=|<|>))
+        \s*
+        (?P<version>
+            [^,;\s)]* # Since this is a "legacy" specifier, and the version
+                      # string can be just about anything, we match everything
+                      # except for whitespace, a semi-colon for marker support,
+                      # a closing paren since versions can be enclosed in
+                      # them, and a comma since it's a version separator.
+        )
+        """
+
+    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    _operators = {
+        "==": "equal",
+        "!=": "not_equal",
+        "<=": "less_than_equal",
+        ">=": "greater_than_equal",
+        "<": "less_than",
+        ">": "greater_than",
+    }
+
+    def _coerce_version(self, version):
+        if not isinstance(version, LegacyVersion):
+            version = LegacyVersion(str(version))
+        return version
+
+    def _compare_equal(self, prospective, spec):
+        return prospective == self._coerce_version(spec)
+
+    def _compare_not_equal(self, prospective, spec):
+        return prospective != self._coerce_version(spec)
+
+    def _compare_less_than_equal(self, prospective, spec):
+        return prospective <= self._coerce_version(spec)
+
+    def _compare_greater_than_equal(self, prospective, spec):
+        return prospective >= self._coerce_version(spec)
+
+    def _compare_less_than(self, prospective, spec):
+        return prospective < self._coerce_version(spec)
+
+    def _compare_greater_than(self, prospective, spec):
+        return prospective > self._coerce_version(spec)
+
+
+def _require_version_compare(fn):
+    @functools.wraps(fn)
+    def wrapped(self, prospective, spec):
+        if not isinstance(prospective, Version):
+            return False
+        return fn(self, prospective, spec)
+
+    return wrapped
+
+
+class Specifier(_IndividualSpecifier):
+
+    _regex_str = r"""
+        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
+        (?P<version>
+            (?:
+                # The identity operators allow for an escape hatch that will
+                # do an exact string match of the version you wish to install.
+                # This will not be parsed by PEP 440 and we cannot determine
+                # any semantic meaning from it. This operator is discouraged
+                # but included entirely as an escape hatch.
+                (?<====)  # Only match for the identity operator
+                \s*
+                [^\s]*    # We just match everything, except for whitespace
+                          # since we are only testing for strict identity.
+            )
+            |
+            (?:
+                # The (non)equality operators allow for wild card and local
+                # versions to be specified so we have to define these two
+                # operators separately to enable that.
+                (?<===|!=)            # Only match for equals and not equals
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)*   # release
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+
+                # You cannot use a wild card and a dev or local version
+                # together so group them with a | and make them optional.
+                (?:
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
+                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
+                    |
+                    \.\*  # Wild card syntax of .*
+                )?
+            )
+            |
+            (?:
+                # The compatible operator requires at least two digits in the
+                # release segment.
+                (?<=~=)               # Only match for the compatible operator
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+            )
+            |
+            (?:
+                # All other operators only allow a sub set of what the
+                # (non)equality operators do. Specifically they do not allow
+                # local versions to be specified nor do they allow the prefix
+                # matching wild cards.
+                (?<!==|!=|~=)         # We have special cases for these
+                                      # operators so we want to make sure they
+                                      # don't match here.
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)*   # release
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+            )
+        )
+        """
+
+    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    _operators = {
+        "~=": "compatible",
+        "==": "equal",
+        "!=": "not_equal",
+        "<=": "less_than_equal",
+        ">=": "greater_than_equal",
+        "<": "less_than",
+        ">": "greater_than",
+        "===": "arbitrary",
+    }
+
+    @_require_version_compare
+    def _compare_compatible(self, prospective, spec):
+        # Compatible releases have an equivalent combination of >= and ==. That
+        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
+        # implement this in terms of the other specifiers instead of
+        # implementing it ourselves. The only thing we need to do is construct
+        # the other specifiers.
+
+        # We want everything but the last item in the version, but we want to
+        # ignore post and dev releases and we want to treat the pre-release as
+        # it's own separate segment.
+        prefix = ".".join(
+            list(
+                itertools.takewhile(
+                    lambda x: (not x.startswith("post") and not x.startswith("dev")),
+                    _version_split(spec),
+                )
+            )[:-1]
+        )
+
+        # Add the prefix notation to the end of our string
+        prefix += ".*"
+
+        return self._get_operator(">=")(prospective, spec) and self._get_operator("==")(
+            prospective, prefix
+        )
+
+    @_require_version_compare
+    def _compare_equal(self, prospective, spec):
+        # We need special logic to handle prefix matching
+        if spec.endswith(".*"):
+            # In the case of prefix matching we want to ignore local segment.
+            prospective = Version(prospective.public)
+            # Split the spec out by dots, and pretend that there is an implicit
+            # dot in between a release segment and a pre-release segment.
+            spec = _version_split(spec[:-2])  # Remove the trailing .*
+
+            # Split the prospective version out by dots, and pretend that there
+            # is an implicit dot in between a release segment and a pre-release
+            # segment.
+            prospective = _version_split(str(prospective))
+
+            # Shorten the prospective version to be the same length as the spec
+            # so that we can determine if the specifier is a prefix of the
+            # prospective version or not.
+            prospective = prospective[: len(spec)]
+
+            # Pad out our two sides with zeros so that they both equal the same
+            # length.
+            spec, prospective = _pad_version(spec, prospective)
+        else:
+            # Convert our spec string into a Version
+            spec = Version(spec)
+
+            # If the specifier does not have a local segment, then we want to
+            # act as if the prospective version also does not have a local
+            # segment.
+            if not spec.local:
+                prospective = Version(prospective.public)
+
+        return prospective == spec
+
+    @_require_version_compare
+    def _compare_not_equal(self, prospective, spec):
+        return not self._compare_equal(prospective, spec)
+
+    @_require_version_compare
+    def _compare_less_than_equal(self, prospective, spec):
+        return prospective <= Version(spec)
+
+    @_require_version_compare
+    def _compare_greater_than_equal(self, prospective, spec):
+        return prospective >= Version(spec)
+
+    @_require_version_compare
+    def _compare_less_than(self, prospective, spec):
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
+        spec = Version(spec)
+
+        # Check to see if the prospective version is less than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective < spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a pre-release version, that we do not accept pre-release
+        # versions for the version mentioned in the specifier (e.g. <3.1 should
+        # not match 3.1.dev0, but should match 3.0.dev0).
+        if not spec.is_prerelease and prospective.is_prerelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # less than the spec version *and* it's not a pre-release of the same
+        # version in the spec.
+        return True
+
+    @_require_version_compare
+    def _compare_greater_than(self, prospective, spec):
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
+        spec = Version(spec)
+
+        # Check to see if the prospective version is greater than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective > spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a post-release version, that we do not accept
+        # post-release versions for the version mentioned in the specifier
+        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
+        if not spec.is_postrelease and prospective.is_postrelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # Ensure that we do not allow a local version of the version mentioned
+        # in the specifier, which is technically greater than, to match.
+        if prospective.local is not None:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # greater than the spec version *and* it's not a pre-release of the
+        # same version in the spec.
+        return True
+
+    def _compare_arbitrary(self, prospective, spec):
+        return str(prospective).lower() == str(spec).lower()
+
+    @property
+    def prereleases(self):
+        # If there is an explicit prereleases set for this, then we'll just
+        # blindly use that.
+        if self._prereleases is not None:
+            return self._prereleases
+
+        # Look at all of our specifiers and determine if they are inclusive
+        # operators, and if they are if they are including an explicit
+        # prerelease.
+        operator, version = self._spec
+        if operator in ["==", ">=", "<=", "~=", "==="]:
+            # The == specifier can include a trailing .*, if it does we
+            # want to remove before parsing.
+            if operator == "==" and version.endswith(".*"):
+                version = version[:-2]
+
+            # Parse the version, and if it is a pre-release than this
+            # specifier allows pre-releases.
+            if parse(version).is_prerelease:
+                return True
+
+        return False
+
+    @prereleases.setter
+    def prereleases(self, value):
+        self._prereleases = value
+
+
+_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
+
+
+def _version_split(version):
+    result = []
+    for item in version.split("."):
+        match = _prefix_regex.search(item)
+        if match:
+            result.extend(match.groups())
+        else:
+            result.append(item)
+    return result
+
+
+def _pad_version(left, right):
+    left_split, right_split = [], []
+
+    # Get the release segment of our versions
+    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
+    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
+
+    # Get the rest of our versions
+    left_split.append(left[len(left_split[0]) :])
+    right_split.append(right[len(right_split[0]) :])
+
+    # Insert our padding
+    left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0])))
+    right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0])))
+
+    return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split)))
+
+
+class SpecifierSet(BaseSpecifier):
+    def __init__(self, specifiers="", prereleases=None):
+        # Split on , to break each indidivual specifier into it's own item, and
+        # strip each item to remove leading/trailing whitespace.
+        specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
+
+        # Parsed each individual specifier, attempting first to make it a
+        # Specifier and falling back to a LegacySpecifier.
+        parsed = set()
+        for specifier in specifiers:
+            try:
+                parsed.add(Specifier(specifier))
+            except InvalidSpecifier:
+                parsed.add(LegacySpecifier(specifier))
+
+        # Turn our parsed specifiers into a frozen set and save them for later.
+        self._specs = frozenset(parsed)
+
+        # Store our prereleases value so we can use it later to determine if
+        # we accept prereleases or not.
+        self._prereleases = prereleases
+
+    def __repr__(self):
+        pre = (
+            ", prereleases={0!r}".format(self.prereleases)
+            if self._prereleases is not None
+            else ""
+        )
+
+        return "<SpecifierSet({0!r}{1})>".format(str(self), pre)
+
+    def __str__(self):
+        return ",".join(sorted(str(s) for s in self._specs))
+
+    def __hash__(self):
+        return hash(self._specs)
+
+    def __and__(self, other):
+        if isinstance(other, string_types):
+            other = SpecifierSet(other)
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        specifier = SpecifierSet()
+        specifier._specs = frozenset(self._specs | other._specs)
+
+        if self._prereleases is None and other._prereleases is not None:
+            specifier._prereleases = other._prereleases
+        elif self._prereleases is not None and other._prereleases is None:
+            specifier._prereleases = self._prereleases
+        elif self._prereleases == other._prereleases:
+            specifier._prereleases = self._prereleases
+        else:
+            raise ValueError(
+                "Cannot combine SpecifierSets with True and False prerelease "
+                "overrides."
+            )
+
+        return specifier
+
+    def __eq__(self, other):
+        if isinstance(other, string_types):
+            other = SpecifierSet(other)
+        elif isinstance(other, _IndividualSpecifier):
+            other = SpecifierSet(str(other))
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        return self._specs == other._specs
+
+    def __ne__(self, other):
+        if isinstance(other, string_types):
+            other = SpecifierSet(other)
+        elif isinstance(other, _IndividualSpecifier):
+            other = SpecifierSet(str(other))
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        return self._specs != other._specs
+
+    def __len__(self):
+        return len(self._specs)
+
+    def __iter__(self):
+        return iter(self._specs)
+
+    @property
+    def prereleases(self):
+        # If we have been given an explicit prerelease modifier, then we'll
+        # pass that through here.
+        if self._prereleases is not None:
+            return self._prereleases
+
+        # If we don't have any specifiers, and we don't have a forced value,
+        # then we'll just return None since we don't know if this should have
+        # pre-releases or not.
+        if not self._specs:
+            return None
+
+        # Otherwise we'll see if any of the given specifiers accept
+        # prereleases, if any of them do we'll return True, otherwise False.
+        return any(s.prereleases for s in self._specs)
+
+    @prereleases.setter
+    def prereleases(self, value):
+        self._prereleases = value
+
+    def __contains__(self, item):
+        return self.contains(item)
+
+    def contains(self, item, prereleases=None):
+        # Ensure that our item is a Version or LegacyVersion instance.
+        if not isinstance(item, (LegacyVersion, Version)):
+            item = parse(item)
+
+        # Determine if we're forcing a prerelease or not, if we're not forcing
+        # one for this particular filter call, then we'll use whatever the
+        # SpecifierSet thinks for whether or not we should support prereleases.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # We can determine if we're going to allow pre-releases by looking to
+        # see if any of the underlying items supports them. If none of them do
+        # and this item is a pre-release then we do not allow it and we can
+        # short circuit that here.
+        # Note: This means that 1.0.dev1 would not be contained in something
+        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
+        if not prereleases and item.is_prerelease:
+            return False
+
+        # We simply dispatch to the underlying specs here to make sure that the
+        # given version is contained within all of them.
+        # Note: This use of all() here means that an empty set of specifiers
+        #       will always return True, this is an explicit design decision.
+        return all(s.contains(item, prereleases=prereleases) for s in self._specs)
+
+    def filter(self, iterable, prereleases=None):
+        # Determine if we're forcing a prerelease or not, if we're not forcing
+        # one for this particular filter call, then we'll use whatever the
+        # SpecifierSet thinks for whether or not we should support prereleases.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # If we have any specifiers, then we want to wrap our iterable in the
+        # filter method for each one, this will act as a logical AND amongst
+        # each specifier.
+        if self._specs:
+            for spec in self._specs:
+                iterable = spec.filter(iterable, prereleases=bool(prereleases))
+            return iterable
+        # If we do not have any specifiers, then we need to have a rough filter
+        # which will filter out any pre-releases, unless there are no final
+        # releases, and which will filter out LegacyVersion in general.
+        else:
+            filtered = []
+            found_prereleases = []
+
+            for item in iterable:
+                # Ensure that we some kind of Version class for this item.
+                if not isinstance(item, (LegacyVersion, Version)):
+                    parsed_version = parse(item)
+                else:
+                    parsed_version = item
+
+                # Filter out any item which is parsed as a LegacyVersion
+                if isinstance(parsed_version, LegacyVersion):
+                    continue
+
+                # Store any item which is a pre-release for later unless we've
+                # already found a final version or we are accepting prereleases
+                if parsed_version.is_prerelease and not prereleases:
+                    if not filtered:
+                        found_prereleases.append(item)
+                else:
+                    filtered.append(item)
+
+            # If we've found no items except for pre-releases, then we'll go
+            # ahead and use the pre-releases
+            if not filtered and found_prereleases and prereleases is None:
+                return found_prereleases
+
+            return filtered
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/tags.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/tags.py
new file mode 100644
index 0000000..ec9942f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/tags.py
@@ -0,0 +1,404 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import absolute_import
+
+import distutils.util
+
+try:
+    from importlib.machinery import EXTENSION_SUFFIXES
+except ImportError:  # pragma: no cover
+    import imp
+
+    EXTENSION_SUFFIXES = [x[0] for x in imp.get_suffixes()]
+    del imp
+import platform
+import re
+import sys
+import sysconfig
+import warnings
+
+
+INTERPRETER_SHORT_NAMES = {
+    "python": "py",  # Generic.
+    "cpython": "cp",
+    "pypy": "pp",
+    "ironpython": "ip",
+    "jython": "jy",
+}
+
+
+_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32
+
+
+class Tag(object):
+
+    __slots__ = ["_interpreter", "_abi", "_platform"]
+
+    def __init__(self, interpreter, abi, platform):
+        self._interpreter = interpreter.lower()
+        self._abi = abi.lower()
+        self._platform = platform.lower()
+
+    @property
+    def interpreter(self):
+        return self._interpreter
+
+    @property
+    def abi(self):
+        return self._abi
+
+    @property
+    def platform(self):
+        return self._platform
+
+    def __eq__(self, other):
+        return (
+            (self.platform == other.platform)
+            and (self.abi == other.abi)
+            and (self.interpreter == other.interpreter)
+        )
+
+    def __hash__(self):
+        return hash((self._interpreter, self._abi, self._platform))
+
+    def __str__(self):
+        return "{}-{}-{}".format(self._interpreter, self._abi, self._platform)
+
+    def __repr__(self):
+        return "<{self} @ {self_id}>".format(self=self, self_id=id(self))
+
+
+def parse_tag(tag):
+    tags = set()
+    interpreters, abis, platforms = tag.split("-")
+    for interpreter in interpreters.split("."):
+        for abi in abis.split("."):
+            for platform_ in platforms.split("."):
+                tags.add(Tag(interpreter, abi, platform_))
+    return frozenset(tags)
+
+
+def _normalize_string(string):
+    return string.replace(".", "_").replace("-", "_")
+
+
+def _cpython_interpreter(py_version):
+    # TODO: Is using py_version_nodot for interpreter version critical?
+    return "cp{major}{minor}".format(major=py_version[0], minor=py_version[1])
+
+
+def _cpython_abis(py_version):
+    abis = []
+    version = "{}{}".format(*py_version[:2])
+    debug = pymalloc = ucs4 = ""
+    with_debug = sysconfig.get_config_var("Py_DEBUG")
+    has_refcount = hasattr(sys, "gettotalrefcount")
+    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
+    # extension modules is the best option.
+    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692
+    has_ext = "_d.pyd" in EXTENSION_SUFFIXES
+    if with_debug or (with_debug is None and (has_refcount or has_ext)):
+        debug = "d"
+    if py_version < (3, 8):
+        with_pymalloc = sysconfig.get_config_var("WITH_PYMALLOC")
+        if with_pymalloc or with_pymalloc is None:
+            pymalloc = "m"
+        if py_version < (3, 3):
+            unicode_size = sysconfig.get_config_var("Py_UNICODE_SIZE")
+            if unicode_size == 4 or (
+                unicode_size is None and sys.maxunicode == 0x10FFFF
+            ):
+                ucs4 = "u"
+    elif debug:
+        # Debug builds can also load "normal" extension modules.
+        # We can also assume no UCS-4 or pymalloc requirement.
+        abis.append("cp{version}".format(version=version))
+    abis.insert(
+        0,
+        "cp{version}{debug}{pymalloc}{ucs4}".format(
+            version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4
+        ),
+    )
+    return abis
+
+
+def _cpython_tags(py_version, interpreter, abis, platforms):
+    for abi in abis:
+        for platform_ in platforms:
+            yield Tag(interpreter, abi, platform_)
+    for tag in (Tag(interpreter, "abi3", platform_) for platform_ in platforms):
+        yield tag
+    for tag in (Tag(interpreter, "none", platform_) for platform_ in platforms):
+        yield tag
+    # PEP 384 was first implemented in Python 3.2.
+    for minor_version in range(py_version[1] - 1, 1, -1):
+        for platform_ in platforms:
+            interpreter = "cp{major}{minor}".format(
+                major=py_version[0], minor=minor_version
+            )
+            yield Tag(interpreter, "abi3", platform_)
+
+
+def _pypy_interpreter():
+    return "pp{py_major}{pypy_major}{pypy_minor}".format(
+        py_major=sys.version_info[0],
+        pypy_major=sys.pypy_version_info.major,
+        pypy_minor=sys.pypy_version_info.minor,
+    )
+
+
+def _generic_abi():
+    abi = sysconfig.get_config_var("SOABI")
+    if abi:
+        return _normalize_string(abi)
+    else:
+        return "none"
+
+
+def _pypy_tags(py_version, interpreter, abi, platforms):
+    for tag in (Tag(interpreter, abi, platform) for platform in platforms):
+        yield tag
+    for tag in (Tag(interpreter, "none", platform) for platform in platforms):
+        yield tag
+
+
+def _generic_tags(interpreter, py_version, abi, platforms):
+    for tag in (Tag(interpreter, abi, platform) for platform in platforms):
+        yield tag
+    if abi != "none":
+        tags = (Tag(interpreter, "none", platform_) for platform_ in platforms)
+        for tag in tags:
+            yield tag
+
+
+def _py_interpreter_range(py_version):
+    """
+    Yield Python versions in descending order.
+
+    After the latest version, the major-only version will be yielded, and then
+    all following versions up to 'end'.
+    """
+    yield "py{major}{minor}".format(major=py_version[0], minor=py_version[1])
+    yield "py{major}".format(major=py_version[0])
+    for minor in range(py_version[1] - 1, -1, -1):
+        yield "py{major}{minor}".format(major=py_version[0], minor=minor)
+
+
+def _independent_tags(interpreter, py_version, platforms):
+    """
+    Return the sequence of tags that are consistent across implementations.
+
+    The tags consist of:
+    - py*-none-<platform>
+    - <interpreter>-none-any
+    - py*-none-any
+    """
+    for version in _py_interpreter_range(py_version):
+        for platform_ in platforms:
+            yield Tag(version, "none", platform_)
+    yield Tag(interpreter, "none", "any")
+    for version in _py_interpreter_range(py_version):
+        yield Tag(version, "none", "any")
+
+
+def _mac_arch(arch, is_32bit=_32_BIT_INTERPRETER):
+    if not is_32bit:
+        return arch
+
+    if arch.startswith("ppc"):
+        return "ppc"
+
+    return "i386"
+
+
+def _mac_binary_formats(version, cpu_arch):
+    formats = [cpu_arch]
+    if cpu_arch == "x86_64":
+        if version < (10, 4):
+            return []
+        formats.extend(["intel", "fat64", "fat32"])
+
+    elif cpu_arch == "i386":
+        if version < (10, 4):
+            return []
+        formats.extend(["intel", "fat32", "fat"])
+
+    elif cpu_arch == "ppc64":
+        # TODO: Need to care about 32-bit PPC for ppc64 through 10.2?
+        if version > (10, 5) or version < (10, 4):
+            return []
+        formats.append("fat64")
+
+    elif cpu_arch == "ppc":
+        if version > (10, 6):
+            return []
+        formats.extend(["fat32", "fat"])
+
+    formats.append("universal")
+    return formats
+
+
+def _mac_platforms(version=None, arch=None):
+    version_str, _, cpu_arch = platform.mac_ver()
+    if version is None:
+        version = tuple(map(int, version_str.split(".")[:2]))
+    if arch is None:
+        arch = _mac_arch(cpu_arch)
+    platforms = []
+    for minor_version in range(version[1], -1, -1):
+        compat_version = version[0], minor_version
+        binary_formats = _mac_binary_formats(compat_version, arch)
+        for binary_format in binary_formats:
+            platforms.append(
+                "macosx_{major}_{minor}_{binary_format}".format(
+                    major=compat_version[0],
+                    minor=compat_version[1],
+                    binary_format=binary_format,
+                )
+            )
+    return platforms
+
+
+# From PEP 513.
+def _is_manylinux_compatible(name, glibc_version):
+    # Check for presence of _manylinux module.
+    try:
+        import _manylinux
+
+        return bool(getattr(_manylinux, name + "_compatible"))
+    except (ImportError, AttributeError):
+        # Fall through to heuristic check below.
+        pass
+
+    return _have_compatible_glibc(*glibc_version)
+
+
+def _glibc_version_string():
+    # Returns glibc version string, or None if not using glibc.
+    import ctypes
+
+    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
+    # manpage says, "If filename is NULL, then the returned handle is for the
+    # main program". This way we can let the linker do the work to figure out
+    # which libc our process is actually using.
+    process_namespace = ctypes.CDLL(None)
+    try:
+        gnu_get_libc_version = process_namespace.gnu_get_libc_version
+    except AttributeError:
+        # Symbol doesn't exist -> therefore, we are not linked to
+        # glibc.
+        return None
+
+    # Call gnu_get_libc_version, which returns a string like "2.5"
+    gnu_get_libc_version.restype = ctypes.c_char_p
+    version_str = gnu_get_libc_version()
+    # py2 / py3 compatibility:
+    if not isinstance(version_str, str):
+        version_str = version_str.decode("ascii")
+
+    return version_str
+
+
+# Separated out from have_compatible_glibc for easier unit testing.
+def _check_glibc_version(version_str, required_major, minimum_minor):
+    # Parse string and check against requested version.
+    #
+    # We use a regexp instead of str.split because we want to discard any
+    # random junk that might come after the minor version -- this might happen
+    # in patched/forked versions of glibc (e.g. Linaro's version of glibc
+    # uses version strings like "2.20-2014.11"). See gh-3588.
+    m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str)
+    if not m:
+        warnings.warn(
+            "Expected glibc version with 2 components major.minor,"
+            " got: %s" % version_str,
+            RuntimeWarning,
+        )
+        return False
+    return (
+        int(m.group("major")) == required_major
+        and int(m.group("minor")) >= minimum_minor
+    )
+
+
+def _have_compatible_glibc(required_major, minimum_minor):
+    version_str = _glibc_version_string()
+    if version_str is None:
+        return False
+    return _check_glibc_version(version_str, required_major, minimum_minor)
+
+
+def _linux_platforms(is_32bit=_32_BIT_INTERPRETER):
+    linux = _normalize_string(distutils.util.get_platform())
+    if linux == "linux_x86_64" and is_32bit:
+        linux = "linux_i686"
+    manylinux_support = (
+        ("manylinux2014", (2, 17)),  # CentOS 7 w/ glibc 2.17 (PEP 599)
+        ("manylinux2010", (2, 12)),  # CentOS 6 w/ glibc 2.12 (PEP 571)
+        ("manylinux1", (2, 5)),  # CentOS 5 w/ glibc 2.5 (PEP 513)
+    )
+    manylinux_support_iter = iter(manylinux_support)
+    for name, glibc_version in manylinux_support_iter:
+        if _is_manylinux_compatible(name, glibc_version):
+            platforms = [linux.replace("linux", name)]
+            break
+    else:
+        platforms = []
+    # Support for a later manylinux implies support for an earlier version.
+    platforms += [linux.replace("linux", name) for name, _ in manylinux_support_iter]
+    platforms.append(linux)
+    return platforms
+
+
+def _generic_platforms():
+    platform = _normalize_string(distutils.util.get_platform())
+    return [platform]
+
+
+def _interpreter_name():
+    name = platform.python_implementation().lower()
+    return INTERPRETER_SHORT_NAMES.get(name) or name
+
+
+def _generic_interpreter(name, py_version):
+    version = sysconfig.get_config_var("py_version_nodot")
+    if not version:
+        version = "".join(map(str, py_version[:2]))
+    return "{name}{version}".format(name=name, version=version)
+
+
+def sys_tags():
+    """
+    Returns the sequence of tag triples for the running interpreter.
+
+    The order of the sequence corresponds to priority order for the
+    interpreter, from most to least important.
+    """
+    py_version = sys.version_info[:2]
+    interpreter_name = _interpreter_name()
+    if platform.system() == "Darwin":
+        platforms = _mac_platforms()
+    elif platform.system() == "Linux":
+        platforms = _linux_platforms()
+    else:
+        platforms = _generic_platforms()
+
+    if interpreter_name == "cp":
+        interpreter = _cpython_interpreter(py_version)
+        abis = _cpython_abis(py_version)
+        for tag in _cpython_tags(py_version, interpreter, abis, platforms):
+            yield tag
+    elif interpreter_name == "pp":
+        interpreter = _pypy_interpreter()
+        abi = _generic_abi()
+        for tag in _pypy_tags(py_version, interpreter, abi, platforms):
+            yield tag
+    else:
+        interpreter = _generic_interpreter(interpreter_name, py_version)
+        abi = _generic_abi()
+        for tag in _generic_tags(interpreter, py_version, abi, platforms):
+            yield tag
+    for tag in _independent_tags(interpreter, py_version, platforms):
+        yield tag
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/utils.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/utils.py
new file mode 100644
index 0000000..8841878
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/utils.py
@@ -0,0 +1,57 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import re
+
+from .version import InvalidVersion, Version
+
+
+_canonicalize_regex = re.compile(r"[-_.]+")
+
+
+def canonicalize_name(name):
+    # This is taken from PEP 503.
+    return _canonicalize_regex.sub("-", name).lower()
+
+
+def canonicalize_version(version):
+    """
+    This is very similar to Version.__str__, but has one subtle differences
+    with the way it handles the release segment.
+    """
+
+    try:
+        version = Version(version)
+    except InvalidVersion:
+        # Legacy versions cannot be normalized
+        return version
+
+    parts = []
+
+    # Epoch
+    if version.epoch != 0:
+        parts.append("{0}!".format(version.epoch))
+
+    # Release segment
+    # NB: This strips trailing '.0's to normalize
+    parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in version.release)))
+
+    # Pre-release
+    if version.pre is not None:
+        parts.append("".join(str(x) for x in version.pre))
+
+    # Post-release
+    if version.post is not None:
+        parts.append(".post{0}".format(version.post))
+
+    # Development release
+    if version.dev is not None:
+        parts.append(".dev{0}".format(version.dev))
+
+    # Local version segment
+    if version.local is not None:
+        parts.append("+{0}".format(version.local))
+
+    return "".join(parts)
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/version.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/version.py
new file mode 100644
index 0000000..95157a1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/packaging/version.py
@@ -0,0 +1,420 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import collections
+import itertools
+import re
+
+from ._structures import Infinity
+
+
+__all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"]
+
+
+_Version = collections.namedtuple(
+    "_Version", ["epoch", "release", "dev", "pre", "post", "local"]
+)
+
+
+def parse(version):
+    """
+    Parse the given version string and return either a :class:`Version` object
+    or a :class:`LegacyVersion` object depending on if the given version is
+    a valid PEP 440 version or a legacy version.
+    """
+    try:
+        return Version(version)
+    except InvalidVersion:
+        return LegacyVersion(version)
+
+
+class InvalidVersion(ValueError):
+    """
+    An invalid version was found, users should refer to PEP 440.
+    """
+
+
+class _BaseVersion(object):
+    def __hash__(self):
+        return hash(self._key)
+
+    def __lt__(self, other):
+        return self._compare(other, lambda s, o: s < o)
+
+    def __le__(self, other):
+        return self._compare(other, lambda s, o: s <= o)
+
+    def __eq__(self, other):
+        return self._compare(other, lambda s, o: s == o)
+
+    def __ge__(self, other):
+        return self._compare(other, lambda s, o: s >= o)
+
+    def __gt__(self, other):
+        return self._compare(other, lambda s, o: s > o)
+
+    def __ne__(self, other):
+        return self._compare(other, lambda s, o: s != o)
+
+    def _compare(self, other, method):
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+
+        return method(self._key, other._key)
+
+
+class LegacyVersion(_BaseVersion):
+    def __init__(self, version):
+        self._version = str(version)
+        self._key = _legacy_cmpkey(self._version)
+
+    def __str__(self):
+        return self._version
+
+    def __repr__(self):
+        return "<LegacyVersion({0})>".format(repr(str(self)))
+
+    @property
+    def public(self):
+        return self._version
+
+    @property
+    def base_version(self):
+        return self._version
+
+    @property
+    def epoch(self):
+        return -1
+
+    @property
+    def release(self):
+        return None
+
+    @property
+    def pre(self):
+        return None
+
+    @property
+    def post(self):
+        return None
+
+    @property
+    def dev(self):
+        return None
+
+    @property
+    def local(self):
+        return None
+
+    @property
+    def is_prerelease(self):
+        return False
+
+    @property
+    def is_postrelease(self):
+        return False
+
+    @property
+    def is_devrelease(self):
+        return False
+
+
+_legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE)
+
+_legacy_version_replacement_map = {
+    "pre": "c",
+    "preview": "c",
+    "-": "final-",
+    "rc": "c",
+    "dev": "@",
+}
+
+
+def _parse_version_parts(s):
+    for part in _legacy_version_component_re.split(s):
+        part = _legacy_version_replacement_map.get(part, part)
+
+        if not part or part == ".":
+            continue
+
+        if part[:1] in "0123456789":
+            # pad for numeric comparison
+            yield part.zfill(8)
+        else:
+            yield "*" + part
+
+    # ensure that alpha/beta/candidate are before final
+    yield "*final"
+
+
+def _legacy_cmpkey(version):
+    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
+    # greater than or equal to 0. This will effectively put the LegacyVersion,
+    # which uses the defacto standard originally implemented by setuptools,
+    # as before all PEP 440 versions.
+    epoch = -1
+
+    # This scheme is taken from pkg_resources.parse_version setuptools prior to
+    # it's adoption of the packaging library.
+    parts = []
+    for part in _parse_version_parts(version.lower()):
+        if part.startswith("*"):
+            # remove "-" before a prerelease tag
+            if part < "*final":
+                while parts and parts[-1] == "*final-":
+                    parts.pop()
+
+            # remove trailing zeros from each series of numeric parts
+            while parts and parts[-1] == "00000000":
+                parts.pop()
+
+        parts.append(part)
+    parts = tuple(parts)
+
+    return epoch, parts
+
+
+# Deliberately not anchored to the start and end of the string, to make it
+# easier for 3rd party code to reuse
+VERSION_PATTERN = r"""
+    v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
+        (?P<pre>                                          # pre-release
+            [-_\.]?
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>                                         # post release
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>                                          # dev release
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+
+
+class Version(_BaseVersion):
+
+    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    def __init__(self, version):
+        # Validate the version and parse it into pieces
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion("Invalid version: '{0}'".format(version))
+
+        # Store the parsed out pieces of the version
+        self._version = _Version(
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+            release=tuple(int(i) for i in match.group("release").split(".")),
+            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
+            post=_parse_letter_version(
+                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
+            ),
+            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
+            local=_parse_local_version(match.group("local")),
+        )
+
+        # Generate a key which will be used for sorting
+        self._key = _cmpkey(
+            self._version.epoch,
+            self._version.release,
+            self._version.pre,
+            self._version.post,
+            self._version.dev,
+            self._version.local,
+        )
+
+    def __repr__(self):
+        return "<Version({0})>".format(repr(str(self)))
+
+    def __str__(self):
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append("{0}!".format(self.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        # Pre-release
+        if self.pre is not None:
+            parts.append("".join(str(x) for x in self.pre))
+
+        # Post-release
+        if self.post is not None:
+            parts.append(".post{0}".format(self.post))
+
+        # Development release
+        if self.dev is not None:
+            parts.append(".dev{0}".format(self.dev))
+
+        # Local version segment
+        if self.local is not None:
+            parts.append("+{0}".format(self.local))
+
+        return "".join(parts)
+
+    @property
+    def epoch(self):
+        return self._version.epoch
+
+    @property
+    def release(self):
+        return self._version.release
+
+    @property
+    def pre(self):
+        return self._version.pre
+
+    @property
+    def post(self):
+        return self._version.post[1] if self._version.post else None
+
+    @property
+    def dev(self):
+        return self._version.dev[1] if self._version.dev else None
+
+    @property
+    def local(self):
+        if self._version.local:
+            return ".".join(str(x) for x in self._version.local)
+        else:
+            return None
+
+    @property
+    def public(self):
+        return str(self).split("+", 1)[0]
+
+    @property
+    def base_version(self):
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append("{0}!".format(self.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        return "".join(parts)
+
+    @property
+    def is_prerelease(self):
+        return self.dev is not None or self.pre is not None
+
+    @property
+    def is_postrelease(self):
+        return self.post is not None
+
+    @property
+    def is_devrelease(self):
+        return self.dev is not None
+
+
+def _parse_letter_version(letter, number):
+    if letter:
+        # We consider there to be an implicit 0 in a pre-release if there is
+        # not a numeral associated with it.
+        if number is None:
+            number = 0
+
+        # We normalize any letters to their lower case form
+        letter = letter.lower()
+
+        # We consider some words to be alternate spellings of other words and
+        # in those cases we want to normalize the spellings to our preferred
+        # spelling.
+        if letter == "alpha":
+            letter = "a"
+        elif letter == "beta":
+            letter = "b"
+        elif letter in ["c", "pre", "preview"]:
+            letter = "rc"
+        elif letter in ["rev", "r"]:
+            letter = "post"
+
+        return letter, int(number)
+    if not letter and number:
+        # We assume if we are given a number, but we are not given a letter
+        # then this is using the implicit post release syntax (e.g. 1.0-1)
+        letter = "post"
+
+        return letter, int(number)
+
+
+_local_version_separators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local):
+    """
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+    """
+    if local is not None:
+        return tuple(
+            part.lower() if not part.isdigit() else int(part)
+            for part in _local_version_separators.split(local)
+        )
+
+
+def _cmpkey(epoch, release, pre, post, dev, local):
+    # When we compare a release version, we want to compare it with all of the
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now
+    # leading zeros until we come to something non zero, then take the rest
+    # re-reverse it back into the correct order and make it a tuple and use
+    # that for our sorting key.
+    release = tuple(
+        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
+    )
+
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+    # We'll do this by abusing the pre segment, but we _only_ want to do this
+    # if there is not a pre or a post segment. If we have one of those then
+    # the normal sorting rules will handle this case correctly.
+    if pre is None and post is None and dev is not None:
+        pre = -Infinity
+    # Versions without a pre-release (except as noted above) should sort after
+    # those with one.
+    elif pre is None:
+        pre = Infinity
+
+    # Versions without a post segment should sort before those with one.
+    if post is None:
+        post = -Infinity
+
+    # Versions without a development segment should sort after those with one.
+    if dev is None:
+        dev = Infinity
+
+    if local is None:
+        # Versions without a local segment should sort before those with one.
+        local = -Infinity
+    else:
+        # Versions with a local segment need that segment parsed to implement
+        # the sorting rules in PEP440.
+        # - Alpha numeric segments sort before numeric segments
+        # - Alpha numeric segments sort lexicographically
+        # - Numeric segments sort numerically
+        # - Shorter versions sort before longer versions when the prefixes
+        #   match exactly
+        local = tuple((i, "") if isinstance(i, int) else (-Infinity, i) for i in local)
+
+    return epoch, release, pre, post, dev, local
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/pyparsing.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/pyparsing.py
new file mode 100644
index 0000000..cf75e1e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/pyparsing.py
@@ -0,0 +1,5742 @@
+# module pyparsing.py
+#
+# Copyright (c) 2003-2018  Paul T. McGuire
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__doc__ = \
+"""
+pyparsing module - Classes and methods to define and execute parsing grammars
+=============================================================================
+
+The pyparsing module is an alternative approach to creating and executing simple grammars,
+vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you
+don't need to learn a new syntax for defining grammars or matching expressions - the parsing module
+provides a library of classes that you use to construct the grammar directly in Python.
+
+Here is a program to parse "Hello, World!" (or any greeting of the form 
+C{"<salutation>, <addressee>!"}), built up using L{Word}, L{Literal}, and L{And} elements 
+(L{'+'<ParserElement.__add__>} operator gives L{And} expressions, strings are auto-converted to
+L{Literal} expressions)::
+
+    from pyparsing import Word, alphas
+
+    # define grammar of a greeting
+    greet = Word(alphas) + "," + Word(alphas) + "!"
+
+    hello = "Hello, World!"
+    print (hello, "->", greet.parseString(hello))
+
+The program outputs the following::
+
+    Hello, World! -> ['Hello', ',', 'World', '!']
+
+The Python representation of the grammar is quite readable, owing to the self-explanatory
+class names, and the use of '+', '|' and '^' operators.
+
+The L{ParseResults} object returned from L{ParserElement.parseString<ParserElement.parseString>} can be accessed as a nested list, a dictionary, or an
+object with named attributes.
+
+The pyparsing module handles some of the problems that are typically vexing when writing text parsers:
+ - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)
+ - quoted strings
+ - embedded comments
+
+
+Getting Started -
+-----------------
+Visit the classes L{ParserElement} and L{ParseResults} to see the base classes that most other pyparsing
+classes inherit from. Use the docstrings for examples of how to:
+ - construct literal match expressions from L{Literal} and L{CaselessLiteral} classes
+ - construct character word-group expressions using the L{Word} class
+ - see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes
+ - use L{'+'<And>}, L{'|'<MatchFirst>}, L{'^'<Or>}, and L{'&'<Each>} operators to combine simple expressions into more complex ones
+ - associate names with your parsed results using L{ParserElement.setResultsName}
+ - find some helpful expression short-cuts like L{delimitedList} and L{oneOf}
+ - find more useful common expressions in the L{pyparsing_common} namespace class
+"""
+
+__version__ = "2.2.1"
+__versionTime__ = "18 Sep 2018 00:49 UTC"
+__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"
+
+import string
+from weakref import ref as wkref
+import copy
+import sys
+import warnings
+import re
+import sre_constants
+import collections
+import pprint
+import traceback
+import types
+from datetime import datetime
+
+try:
+    from _thread import RLock
+except ImportError:
+    from threading import RLock
+
+try:
+    # Python 3
+    from collections.abc import Iterable
+    from collections.abc import MutableMapping
+except ImportError:
+    # Python 2.7
+    from collections import Iterable
+    from collections import MutableMapping
+
+try:
+    from collections import OrderedDict as _OrderedDict
+except ImportError:
+    try:
+        from ordereddict import OrderedDict as _OrderedDict
+    except ImportError:
+        _OrderedDict = None
+
+#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )
+
+__all__ = [
+'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',
+'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',
+'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',
+'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',
+'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',
+'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 
+'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',
+'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',
+'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',
+'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums',
+'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno',
+'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',
+'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',
+'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity', 
+'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',
+'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',
+'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation','locatedExpr', 'withClass',
+'CloseMatch', 'tokenMap', 'pyparsing_common',
+]
+
+system_version = tuple(sys.version_info)[:3]
+PY_3 = system_version[0] == 3
+if PY_3:
+    _MAX_INT = sys.maxsize
+    basestring = str
+    unichr = chr
+    _ustr = str
+
+    # build list of single arg builtins, that can be used as parse actions
+    singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max]
+
+else:
+    _MAX_INT = sys.maxint
+    range = xrange
+
+    def _ustr(obj):
+        """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries
+           str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It
+           then < returns the unicode object | encodes it with the default encoding | ... >.
+        """
+        if isinstance(obj,unicode):
+            return obj
+
+        try:
+            # If this works, then _ustr(obj) has the same behaviour as str(obj), so
+            # it won't break any existing code.
+            return str(obj)
+
+        except UnicodeEncodeError:
+            # Else encode it
+            ret = unicode(obj).encode(sys.getdefaultencoding(), 'xmlcharrefreplace')
+            xmlcharref = Regex(r'&#\d+;')
+            xmlcharref.setParseAction(lambda t: '\\u' + hex(int(t[0][2:-1]))[2:])
+            return xmlcharref.transformString(ret)
+
+    # build list of single arg builtins, tolerant of Python version, that can be used as parse actions
+    singleArgBuiltins = []
+    import __builtin__
+    for fname in "sum len sorted reversed list tuple set any all min max".split():
+        try:
+            singleArgBuiltins.append(getattr(__builtin__,fname))
+        except AttributeError:
+            continue
+            
+_generatorType = type((y for y in range(1)))
+ 
+def _xml_escape(data):
+    """Escape &, <, >, ", ', etc. in a string of data."""
+
+    # ampersand must be replaced first
+    from_symbols = '&><"\''
+    to_symbols = ('&'+s+';' for s in "amp gt lt quot apos".split())
+    for from_,to_ in zip(from_symbols, to_symbols):
+        data = data.replace(from_, to_)
+    return data
+
+class _Constants(object):
+    pass
+
+alphas     = string.ascii_uppercase + string.ascii_lowercase
+nums       = "0123456789"
+hexnums    = nums + "ABCDEFabcdef"
+alphanums  = alphas + nums
+_bslash    = chr(92)
+printables = "".join(c for c in string.printable if c not in string.whitespace)
+
+class ParseBaseException(Exception):
+    """base exception class for all parsing runtime exceptions"""
+    # Performance tuning: we construct a *lot* of these, so keep this
+    # constructor as small and fast as possible
+    def __init__( self, pstr, loc=0, msg=None, elem=None ):
+        self.loc = loc
+        if msg is None:
+            self.msg = pstr
+            self.pstr = ""
+        else:
+            self.msg = msg
+            self.pstr = pstr
+        self.parserElement = elem
+        self.args = (pstr, loc, msg)
+
+    @classmethod
+    def _from_exception(cls, pe):
+        """
+        internal factory method to simplify creating one type of ParseException 
+        from another - avoids having __init__ signature conflicts among subclasses
+        """
+        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement)
+
+    def __getattr__( self, aname ):
+        """supported attributes by name are:
+            - lineno - returns the line number of the exception text
+            - col - returns the column number of the exception text
+            - line - returns the line containing the exception text
+        """
+        if( aname == "lineno" ):
+            return lineno( self.loc, self.pstr )
+        elif( aname in ("col", "column") ):
+            return col( self.loc, self.pstr )
+        elif( aname == "line" ):
+            return line( self.loc, self.pstr )
+        else:
+            raise AttributeError(aname)
+
+    def __str__( self ):
+        return "%s (at char %d), (line:%d, col:%d)" % \
+                ( self.msg, self.loc, self.lineno, self.column )
+    def __repr__( self ):
+        return _ustr(self)
+    def markInputline( self, markerString = ">!<" ):
+        """Extracts the exception line from the input string, and marks
+           the location of the exception with a special symbol.
+        """
+        line_str = self.line
+        line_column = self.column - 1
+        if markerString:
+            line_str = "".join((line_str[:line_column],
+                                markerString, line_str[line_column:]))
+        return line_str.strip()
+    def __dir__(self):
+        return "lineno col line".split() + dir(type(self))
+
+class ParseException(ParseBaseException):
+    """
+    Exception thrown when parse expressions don't match class;
+    supported attributes by name are:
+     - lineno - returns the line number of the exception text
+     - col - returns the column number of the exception text
+     - line - returns the line containing the exception text
+        
+    Example::
+        try:
+            Word(nums).setName("integer").parseString("ABC")
+        except ParseException as pe:
+            print(pe)
+            print("column: {}".format(pe.col))
+            
+    prints::
+       Expected integer (at char 0), (line:1, col:1)
+        column: 1
+    """
+    pass
+
+class ParseFatalException(ParseBaseException):
+    """user-throwable exception thrown when inconsistent parse content
+       is found; stops all parsing immediately"""
+    pass
+
+class ParseSyntaxException(ParseFatalException):
+    """just like L{ParseFatalException}, but thrown internally when an
+       L{ErrorStop<And._ErrorStop>} ('-' operator) indicates that parsing is to stop 
+       immediately because an unbacktrackable syntax error has been found"""
+    pass
+
+#~ class ReparseException(ParseBaseException):
+    #~ """Experimental class - parse actions can raise this exception to cause
+       #~ pyparsing to reparse the input string:
+        #~ - with a modified input string, and/or
+        #~ - with a modified start location
+       #~ Set the values of the ReparseException in the constructor, and raise the
+       #~ exception in a parse action to cause pyparsing to use the new string/location.
+       #~ Setting the values as None causes no change to be made.
+       #~ """
+    #~ def __init_( self, newstring, restartLoc ):
+        #~ self.newParseText = newstring
+        #~ self.reparseLoc = restartLoc
+
+class RecursiveGrammarException(Exception):
+    """exception thrown by L{ParserElement.validate} if the grammar could be improperly recursive"""
+    def __init__( self, parseElementList ):
+        self.parseElementTrace = parseElementList
+
+    def __str__( self ):
+        return "RecursiveGrammarException: %s" % self.parseElementTrace
+
+class _ParseResultsWithOffset(object):
+    def __init__(self,p1,p2):
+        self.tup = (p1,p2)
+    def __getitem__(self,i):
+        return self.tup[i]
+    def __repr__(self):
+        return repr(self.tup[0])
+    def setOffset(self,i):
+        self.tup = (self.tup[0],i)
+
+class ParseResults(object):
+    """
+    Structured parse results, to provide multiple means of access to the parsed data:
+       - as a list (C{len(results)})
+       - by list index (C{results[0], results[1]}, etc.)
+       - by attribute (C{results.<resultsName>} - see L{ParserElement.setResultsName})
+
+    Example::
+        integer = Word(nums)
+        date_str = (integer.setResultsName("year") + '/' 
+                        + integer.setResultsName("month") + '/' 
+                        + integer.setResultsName("day"))
+        # equivalent form:
+        # date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+        # parseString returns a ParseResults object
+        result = date_str.parseString("1999/12/31")
+
+        def test(s, fn=repr):
+            print("%s -> %s" % (s, fn(eval(s))))
+        test("list(result)")
+        test("result[0]")
+        test("result['month']")
+        test("result.day")
+        test("'month' in result")
+        test("'minutes' in result")
+        test("result.dump()", str)
+    prints::
+        list(result) -> ['1999', '/', '12', '/', '31']
+        result[0] -> '1999'
+        result['month'] -> '12'
+        result.day -> '31'
+        'month' in result -> True
+        'minutes' in result -> False
+        result.dump() -> ['1999', '/', '12', '/', '31']
+        - day: 31
+        - month: 12
+        - year: 1999
+    """
+    def __new__(cls, toklist=None, name=None, asList=True, modal=True ):
+        if isinstance(toklist, cls):
+            return toklist
+        retobj = object.__new__(cls)
+        retobj.__doinit = True
+        return retobj
+
+    # Performance tuning: we construct a *lot* of these, so keep this
+    # constructor as small and fast as possible
+    def __init__( self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance ):
+        if self.__doinit:
+            self.__doinit = False
+            self.__name = None
+            self.__parent = None
+            self.__accumNames = {}
+            self.__asList = asList
+            self.__modal = modal
+            if toklist is None:
+                toklist = []
+            if isinstance(toklist, list):
+                self.__toklist = toklist[:]
+            elif isinstance(toklist, _generatorType):
+                self.__toklist = list(toklist)
+            else:
+                self.__toklist = [toklist]
+            self.__tokdict = dict()
+
+        if name is not None and name:
+            if not modal:
+                self.__accumNames[name] = 0
+            if isinstance(name,int):
+                name = _ustr(name) # will always return a str, but use _ustr for consistency
+            self.__name = name
+            if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None,'',[])):
+                if isinstance(toklist,basestring):
+                    toklist = [ toklist ]
+                if asList:
+                    if isinstance(toklist,ParseResults):
+                        self[name] = _ParseResultsWithOffset(toklist.copy(),0)
+                    else:
+                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0)
+                    self[name].__name = name
+                else:
+                    try:
+                        self[name] = toklist[0]
+                    except (KeyError,TypeError,IndexError):
+                        self[name] = toklist
+
+    def __getitem__( self, i ):
+        if isinstance( i, (int,slice) ):
+            return self.__toklist[i]
+        else:
+            if i not in self.__accumNames:
+                return self.__tokdict[i][-1][0]
+            else:
+                return ParseResults([ v[0] for v in self.__tokdict[i] ])
+
+    def __setitem__( self, k, v, isinstance=isinstance ):
+        if isinstance(v,_ParseResultsWithOffset):
+            self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]
+            sub = v[0]
+        elif isinstance(k,(int,slice)):
+            self.__toklist[k] = v
+            sub = v
+        else:
+            self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)]
+            sub = v
+        if isinstance(sub,ParseResults):
+            sub.__parent = wkref(self)
+
+    def __delitem__( self, i ):
+        if isinstance(i,(int,slice)):
+            mylen = len( self.__toklist )
+            del self.__toklist[i]
+
+            # convert int to slice
+            if isinstance(i, int):
+                if i < 0:
+                    i += mylen
+                i = slice(i, i+1)
+            # get removed indices
+            removed = list(range(*i.indices(mylen)))
+            removed.reverse()
+            # fixup indices in token dictionary
+            for name,occurrences in self.__tokdict.items():
+                for j in removed:
+                    for k, (value, position) in enumerate(occurrences):
+                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))
+        else:
+            del self.__tokdict[i]
+
+    def __contains__( self, k ):
+        return k in self.__tokdict
+
+    def __len__( self ): return len( self.__toklist )
+    def __bool__(self): return ( not not self.__toklist )
+    __nonzero__ = __bool__
+    def __iter__( self ): return iter( self.__toklist )
+    def __reversed__( self ): return iter( self.__toklist[::-1] )
+    def _iterkeys( self ):
+        if hasattr(self.__tokdict, "iterkeys"):
+            return self.__tokdict.iterkeys()
+        else:
+            return iter(self.__tokdict)
+
+    def _itervalues( self ):
+        return (self[k] for k in self._iterkeys())
+            
+    def _iteritems( self ):
+        return ((k, self[k]) for k in self._iterkeys())
+
+    if PY_3:
+        keys = _iterkeys       
+        """Returns an iterator of all named result keys (Python 3.x only)."""
+
+        values = _itervalues
+        """Returns an iterator of all named result values (Python 3.x only)."""
+
+        items = _iteritems
+        """Returns an iterator of all named result key-value tuples (Python 3.x only)."""
+
+    else:
+        iterkeys = _iterkeys
+        """Returns an iterator of all named result keys (Python 2.x only)."""
+
+        itervalues = _itervalues
+        """Returns an iterator of all named result values (Python 2.x only)."""
+
+        iteritems = _iteritems
+        """Returns an iterator of all named result key-value tuples (Python 2.x only)."""
+
+        def keys( self ):
+            """Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.iterkeys())
+
+        def values( self ):
+            """Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.itervalues())
+                
+        def items( self ):
+            """Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.iteritems())
+
+    def haskeys( self ):
+        """Since keys() returns an iterator, this method is helpful in bypassing
+           code that looks for the existence of any defined results names."""
+        return bool(self.__tokdict)
+        
+    def pop( self, *args, **kwargs):
+        """
+        Removes and returns item at specified index (default=C{last}).
+        Supports both C{list} and C{dict} semantics for C{pop()}. If passed no
+        argument or an integer argument, it will use C{list} semantics
+        and pop tokens from the list of parsed tokens. If passed a 
+        non-integer argument (most likely a string), it will use C{dict}
+        semantics and pop the corresponding value from any defined 
+        results names. A second default return value argument is 
+        supported, just as in C{dict.pop()}.
+
+        Example::
+            def remove_first(tokens):
+                tokens.pop(0)
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']
+
+            label = Word(alphas)
+            patt = label("LABEL") + OneOrMore(Word(nums))
+            print(patt.parseString("AAB 123 321").dump())
+
+            # Use pop() in a parse action to remove named result (note that corresponding value is not
+            # removed from list form of results)
+            def remove_LABEL(tokens):
+                tokens.pop("LABEL")
+                return tokens
+            patt.addParseAction(remove_LABEL)
+            print(patt.parseString("AAB 123 321").dump())
+        prints::
+            ['AAB', '123', '321']
+            - LABEL: AAB
+
+            ['AAB', '123', '321']
+        """
+        if not args:
+            args = [-1]
+        for k,v in kwargs.items():
+            if k == 'default':
+                args = (args[0], v)
+            else:
+                raise TypeError("pop() got an unexpected keyword argument '%s'" % k)
+        if (isinstance(args[0], int) or 
+                        len(args) == 1 or 
+                        args[0] in self):
+            index = args[0]
+            ret = self[index]
+            del self[index]
+            return ret
+        else:
+            defaultvalue = args[1]
+            return defaultvalue
+
+    def get(self, key, defaultValue=None):
+        """
+        Returns named result matching the given key, or if there is no
+        such name, then returns the given C{defaultValue} or C{None} if no
+        C{defaultValue} is specified.
+
+        Similar to C{dict.get()}.
+        
+        Example::
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
+
+            result = date_str.parseString("1999/12/31")
+            print(result.get("year")) # -> '1999'
+            print(result.get("hour", "not specified")) # -> 'not specified'
+            print(result.get("hour")) # -> None
+        """
+        if key in self:
+            return self[key]
+        else:
+            return defaultValue
+
+    def insert( self, index, insStr ):
+        """
+        Inserts new element at location index in the list of parsed tokens.
+        
+        Similar to C{list.insert()}.
+
+        Example::
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+
+            # use a parse action to insert the parse location in the front of the parsed results
+            def insert_locn(locn, tokens):
+                tokens.insert(0, locn)
+            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321']
+        """
+        self.__toklist.insert(index, insStr)
+        # fixup indices in token dictionary
+        for name,occurrences in self.__tokdict.items():
+            for k, (value, position) in enumerate(occurrences):
+                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))
+
+    def append( self, item ):
+        """
+        Add single element to end of ParseResults list of elements.
+
+        Example::
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+            
+            # use a parse action to compute the sum of the parsed integers, and add it to the end
+            def append_sum(tokens):
+                tokens.append(sum(map(int, tokens)))
+            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444]
+        """
+        self.__toklist.append(item)
+
+    def extend( self, itemseq ):
+        """
+        Add sequence of elements to end of ParseResults list of elements.
+
+        Example::
+            patt = OneOrMore(Word(alphas))
+            
+            # use a parse action to append the reverse of the matched strings, to make a palindrome
+            def make_palindrome(tokens):
+                tokens.extend(reversed([t[::-1] for t in tokens]))
+                return ''.join(tokens)
+            print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
+        """
+        if isinstance(itemseq, ParseResults):
+            self += itemseq
+        else:
+            self.__toklist.extend(itemseq)
+
+    def clear( self ):
+        """
+        Clear all elements and results names.
+        """
+        del self.__toklist[:]
+        self.__tokdict.clear()
+
+    def __getattr__( self, name ):
+        try:
+            return self[name]
+        except KeyError:
+            return ""
+            
+        if name in self.__tokdict:
+            if name not in self.__accumNames:
+                return self.__tokdict[name][-1][0]
+            else:
+                return ParseResults([ v[0] for v in self.__tokdict[name] ])
+        else:
+            return ""
+
+    def __add__( self, other ):
+        ret = self.copy()
+        ret += other
+        return ret
+
+    def __iadd__( self, other ):
+        if other.__tokdict:
+            offset = len(self.__toklist)
+            addoffset = lambda a: offset if a<0 else a+offset
+            otheritems = other.__tokdict.items()
+            otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) )
+                                for (k,vlist) in otheritems for v in vlist]
+            for k,v in otherdictitems:
+                self[k] = v
+                if isinstance(v[0],ParseResults):
+                    v[0].__parent = wkref(self)
+            
+        self.__toklist += other.__toklist
+        self.__accumNames.update( other.__accumNames )
+        return self
+
+    def __radd__(self, other):
+        if isinstance(other,int) and other == 0:
+            # useful for merging many ParseResults using sum() builtin
+            return self.copy()
+        else:
+            # this may raise a TypeError - so be it
+            return other + self
+        
+    def __repr__( self ):
+        return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )
+
+    def __str__( self ):
+        return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']'
+
+    def _asStringList( self, sep='' ):
+        out = []
+        for item in self.__toklist:
+            if out and sep:
+                out.append(sep)
+            if isinstance( item, ParseResults ):
+                out += item._asStringList()
+            else:
+                out.append( _ustr(item) )
+        return out
+
+    def asList( self ):
+        """
+        Returns the parse results as a nested list of matching tokens, all converted to strings.
+
+        Example::
+            patt = OneOrMore(Word(alphas))
+            result = patt.parseString("sldkj lsdkj sldkj")
+            # even though the result prints in string-like form, it is actually a pyparsing ParseResults
+            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']
+            
+            # Use asList() to create an actual list
+            result_list = result.asList()
+            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']
+        """
+        return [res.asList() if isinstance(res,ParseResults) else res for res in self.__toklist]
+
+    def asDict( self ):
+        """
+        Returns the named parse results as a nested dictionary.
+
+        Example::
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+            
+            result = date_str.parseString('12/31/1999')
+            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
+            
+            result_dict = result.asDict()
+            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}
+
+            # even though a ParseResults supports dict-like access, sometime you just need to have a dict
+            import json
+            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
+            print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"}
+        """
+        if PY_3:
+            item_fn = self.items
+        else:
+            item_fn = self.iteritems
+            
+        def toItem(obj):
+            if isinstance(obj, ParseResults):
+                if obj.haskeys():
+                    return obj.asDict()
+                else:
+                    return [toItem(v) for v in obj]
+            else:
+                return obj
+                
+        return dict((k,toItem(v)) for k,v in item_fn())
+
+    def copy( self ):
+        """
+        Returns a new copy of a C{ParseResults} object.
+        """
+        ret = ParseResults( self.__toklist )
+        ret.__tokdict = self.__tokdict.copy()
+        ret.__parent = self.__parent
+        ret.__accumNames.update( self.__accumNames )
+        ret.__name = self.__name
+        return ret
+
+    def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):
+        """
+        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.
+        """
+        nl = "\n"
+        out = []
+        namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items()
+                                                            for v in vlist)
+        nextLevelIndent = indent + "  "
+
+        # collapse out indents if formatting is not desired
+        if not formatted:
+            indent = ""
+            nextLevelIndent = ""
+            nl = ""
+
+        selfTag = None
+        if doctag is not None:
+            selfTag = doctag
+        else:
+            if self.__name:
+                selfTag = self.__name
+
+        if not selfTag:
+            if namedItemsOnly:
+                return ""
+            else:
+                selfTag = "ITEM"
+
+        out += [ nl, indent, "<", selfTag, ">" ]
+
+        for i,res in enumerate(self.__toklist):
+            if isinstance(res,ParseResults):
+                if i in namedItems:
+                    out += [ res.asXML(namedItems[i],
+                                        namedItemsOnly and doctag is None,
+                                        nextLevelIndent,
+                                        formatted)]
+                else:
+                    out += [ res.asXML(None,
+                                        namedItemsOnly and doctag is None,
+                                        nextLevelIndent,
+                                        formatted)]
+            else:
+                # individual token, see if there is a name for it
+                resTag = None
+                if i in namedItems:
+                    resTag = namedItems[i]
+                if not resTag:
+                    if namedItemsOnly:
+                        continue
+                    else:
+                        resTag = "ITEM"
+                xmlBodyText = _xml_escape(_ustr(res))
+                out += [ nl, nextLevelIndent, "<", resTag, ">",
+                                                xmlBodyText,
+                                                "</", resTag, ">" ]
+
+        out += [ nl, indent, "</", selfTag, ">" ]
+        return "".join(out)
+
+    def __lookup(self,sub):
+        for k,vlist in self.__tokdict.items():
+            for v,loc in vlist:
+                if sub is v:
+                    return k
+        return None
+
+    def getName(self):
+        r"""
+        Returns the results name for this token expression. Useful when several 
+        different expressions might match at a particular location.
+
+        Example::
+            integer = Word(nums)
+            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
+            house_number_expr = Suppress('#') + Word(nums, alphanums)
+            user_data = (Group(house_number_expr)("house_number") 
+                        | Group(ssn_expr)("ssn")
+                        | Group(integer)("age"))
+            user_info = OneOrMore(user_data)
+            
+            result = user_info.parseString("22 111-22-3333 #221B")
+            for item in result:
+                print(item.getName(), ':', item[0])
+        prints::
+            age : 22
+            ssn : 111-22-3333
+            house_number : 221B
+        """
+        if self.__name:
+            return self.__name
+        elif self.__parent:
+            par = self.__parent()
+            if par:
+                return par.__lookup(self)
+            else:
+                return None
+        elif (len(self) == 1 and
+               len(self.__tokdict) == 1 and
+               next(iter(self.__tokdict.values()))[0][1] in (0,-1)):
+            return next(iter(self.__tokdict.keys()))
+        else:
+            return None
+
+    def dump(self, indent='', depth=0, full=True):
+        """
+        Diagnostic method for listing out the contents of a C{ParseResults}.
+        Accepts an optional C{indent} argument so that this string can be embedded
+        in a nested display of other data.
+
+        Example::
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+            
+            result = date_str.parseString('12/31/1999')
+            print(result.dump())
+        prints::
+            ['12', '/', '31', '/', '1999']
+            - day: 1999
+            - month: 31
+            - year: 12
+        """
+        out = []
+        NL = '\n'
+        out.append( indent+_ustr(self.asList()) )
+        if full:
+            if self.haskeys():
+                items = sorted((str(k), v) for k,v in self.items())
+                for k,v in items:
+                    if out:
+                        out.append(NL)
+                    out.append( "%s%s- %s: " % (indent,('  '*depth), k) )
+                    if isinstance(v,ParseResults):
+                        if v:
+                            out.append( v.dump(indent,depth+1) )
+                        else:
+                            out.append(_ustr(v))
+                    else:
+                        out.append(repr(v))
+            elif any(isinstance(vv,ParseResults) for vv in self):
+                v = self
+                for i,vv in enumerate(v):
+                    if isinstance(vv,ParseResults):
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),vv.dump(indent,depth+1) ))
+                    else:
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),_ustr(vv)))
+            
+        return "".join(out)
+
+    def pprint(self, *args, **kwargs):
+        """
+        Pretty-printer for parsed results as a list, using the C{pprint} module.
+        Accepts additional positional or keyword args as defined for the 
+        C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#pprint.pprint})
+
+        Example::
+            ident = Word(alphas, alphanums)
+            num = Word(nums)
+            func = Forward()
+            term = ident | num | Group('(' + func + ')')
+            func <<= ident + Group(Optional(delimitedList(term)))
+            result = func.parseString("fna a,b,(fnb c,d,200),100")
+            result.pprint(width=40)
+        prints::
+            ['fna',
+             ['a',
+              'b',
+              ['(', 'fnb', ['c', 'd', '200'], ')'],
+              '100']]
+        """
+        pprint.pprint(self.asList(), *args, **kwargs)
+
+    # add support for pickle protocol
+    def __getstate__(self):
+        return ( self.__toklist,
+                 ( self.__tokdict.copy(),
+                   self.__parent is not None and self.__parent() or None,
+                   self.__accumNames,
+                   self.__name ) )
+
+    def __setstate__(self,state):
+        self.__toklist = state[0]
+        (self.__tokdict,
+         par,
+         inAccumNames,
+         self.__name) = state[1]
+        self.__accumNames = {}
+        self.__accumNames.update(inAccumNames)
+        if par is not None:
+            self.__parent = wkref(par)
+        else:
+            self.__parent = None
+
+    def __getnewargs__(self):
+        return self.__toklist, self.__name, self.__asList, self.__modal
+
+    def __dir__(self):
+        return (dir(type(self)) + list(self.keys()))
+
+MutableMapping.register(ParseResults)
+
+def col (loc,strg):
+    """Returns current column within a string, counting newlines as line separators.
+   The first column is number 1.
+
+   Note: the default parsing behavior is to expand tabs in the input string
+   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
+   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
+   consistent view of the parsed string, the parse location, and line and column
+   positions within the parsed string.
+   """
+    s = strg
+    return 1 if 0<loc<len(s) and s[loc-1] == '\n' else loc - s.rfind("\n", 0, loc)
+
+def lineno(loc,strg):
+    """Returns current line number within a string, counting newlines as line separators.
+   The first line is number 1.
+
+   Note: the default parsing behavior is to expand tabs in the input string
+   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
+   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
+   consistent view of the parsed string, the parse location, and line and column
+   positions within the parsed string.
+   """
+    return strg.count("\n",0,loc) + 1
+
+def line( loc, strg ):
+    """Returns the line of text containing loc within a string, counting newlines as line separators.
+       """
+    lastCR = strg.rfind("\n", 0, loc)
+    nextCR = strg.find("\n", loc)
+    if nextCR >= 0:
+        return strg[lastCR+1:nextCR]
+    else:
+        return strg[lastCR+1:]
+
+def _defaultStartDebugAction( instring, loc, expr ):
+    print (("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )))
+
+def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):
+    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))
+
+def _defaultExceptionDebugAction( instring, loc, expr, exc ):
+    print ("Exception raised:" + _ustr(exc))
+
+def nullDebugAction(*args):
+    """'Do-nothing' debug action, to suppress debugging output during parsing."""
+    pass
+
+# Only works on Python 3.x - nonlocal is toxic to Python 2 installs
+#~ 'decorator to trim function calls to match the arity of the target'
+#~ def _trim_arity(func, maxargs=3):
+    #~ if func in singleArgBuiltins:
+        #~ return lambda s,l,t: func(t)
+    #~ limit = 0
+    #~ foundArity = False
+    #~ def wrapper(*args):
+        #~ nonlocal limit,foundArity
+        #~ while 1:
+            #~ try:
+                #~ ret = func(*args[limit:])
+                #~ foundArity = True
+                #~ return ret
+            #~ except TypeError:
+                #~ if limit == maxargs or foundArity:
+                    #~ raise
+                #~ limit += 1
+                #~ continue
+    #~ return wrapper
+
+# this version is Python 2.x-3.x cross-compatible
+'decorator to trim function calls to match the arity of the target'
+def _trim_arity(func, maxargs=2):
+    if func in singleArgBuiltins:
+        return lambda s,l,t: func(t)
+    limit = [0]
+    foundArity = [False]
+    
+    # traceback return data structure changed in Py3.5 - normalize back to plain tuples
+    if system_version[:2] >= (3,5):
+        def extract_stack(limit=0):
+            # special handling for Python 3.5.0 - extra deep call stack by 1
+            offset = -3 if system_version == (3,5,0) else -2
+            frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset]
+            return [frame_summary[:2]]
+        def extract_tb(tb, limit=0):
+            frames = traceback.extract_tb(tb, limit=limit)
+            frame_summary = frames[-1]
+            return [frame_summary[:2]]
+    else:
+        extract_stack = traceback.extract_stack
+        extract_tb = traceback.extract_tb
+    
+    # synthesize what would be returned by traceback.extract_stack at the call to 
+    # user's parse action 'func', so that we don't incur call penalty at parse time
+    
+    LINE_DIFF = 6
+    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND 
+    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!!
+    this_line = extract_stack(limit=2)[-1]
+    pa_call_line_synth = (this_line[0], this_line[1]+LINE_DIFF)
+
+    def wrapper(*args):
+        while 1:
+            try:
+                ret = func(*args[limit[0]:])
+                foundArity[0] = True
+                return ret
+            except TypeError:
+                # re-raise TypeErrors if they did not come from our arity testing
+                if foundArity[0]:
+                    raise
+                else:
+                    try:
+                        tb = sys.exc_info()[-1]
+                        if not extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth:
+                            raise
+                    finally:
+                        del tb
+
+                if limit[0] <= maxargs:
+                    limit[0] += 1
+                    continue
+                raise
+
+    # copy func name to wrapper for sensible debug output
+    func_name = "<parse action>"
+    try:
+        func_name = getattr(func, '__name__', 
+                            getattr(func, '__class__').__name__)
+    except Exception:
+        func_name = str(func)
+    wrapper.__name__ = func_name
+
+    return wrapper
+
+class ParserElement(object):
+    """Abstract base level parser element class."""
+    DEFAULT_WHITE_CHARS = " \n\t\r"
+    verbose_stacktrace = False
+
+    @staticmethod
+    def setDefaultWhitespaceChars( chars ):
+        r"""
+        Overrides the default whitespace chars
+
+        Example::
+            # default whitespace chars are space, <TAB> and newline
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl']
+            
+            # change to just treat newline as significant
+            ParserElement.setDefaultWhitespaceChars(" \t")
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def']
+        """
+        ParserElement.DEFAULT_WHITE_CHARS = chars
+
+    @staticmethod
+    def inlineLiteralsUsing(cls):
+        """
+        Set class to be used for inclusion of string literals into a parser.
+        
+        Example::
+            # default literal class used is Literal
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']
+
+
+            # change to Suppress
+            ParserElement.inlineLiteralsUsing(Suppress)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '12', '31']
+        """
+        ParserElement._literalStringClass = cls
+
+    def __init__( self, savelist=False ):
+        self.parseAction = list()
+        self.failAction = None
+        #~ self.name = "<unknown>"  # don't define self.name, let subclasses try/except upcall
+        self.strRepr = None
+        self.resultsName = None
+        self.saveAsList = savelist
+        self.skipWhitespace = True
+        self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
+        self.copyDefaultWhiteChars = True
+        self.mayReturnEmpty = False # used when checking for left-recursion
+        self.keepTabs = False
+        self.ignoreExprs = list()
+        self.debug = False
+        self.streamlined = False
+        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index
+        self.errmsg = ""
+        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)
+        self.debugActions = ( None, None, None ) #custom debug actions
+        self.re = None
+        self.callPreparse = True # used to avoid redundant calls to preParse
+        self.callDuringTry = False
+
+    def copy( self ):
+        """
+        Make a copy of this C{ParserElement}.  Useful for defining different parse actions
+        for the same parsing pattern, using copies of the original parse element.
+        
+        Example::
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K")
+            integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
+            
+            print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))
+        prints::
+            [5120, 100, 655360, 268435456]
+        Equivalent form of C{expr.copy()} is just C{expr()}::
+            integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
+        """
+        cpy = copy.copy( self )
+        cpy.parseAction = self.parseAction[:]
+        cpy.ignoreExprs = self.ignoreExprs[:]
+        if self.copyDefaultWhiteChars:
+            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
+        return cpy
+
+    def setName( self, name ):
+        """
+        Define name for this expression, makes debugging and exception messages clearer.
+        
+        Example::
+            Word(nums).parseString("ABC")  # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)
+            Word(nums).setName("integer").parseString("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1)
+        """
+        self.name = name
+        self.errmsg = "Expected " + self.name
+        if hasattr(self,"exception"):
+            self.exception.msg = self.errmsg
+        return self
+
+    def setResultsName( self, name, listAllMatches=False ):
+        """
+        Define name for referencing matching tokens as a nested attribute
+        of the returned parse results.
+        NOTE: this returns a *copy* of the original C{ParserElement} object;
+        this is so that the client can define a basic element, such as an
+        integer, and reference it in multiple places with different names.
+
+        You can also set results names using the abbreviated syntax,
+        C{expr("name")} in place of C{expr.setResultsName("name")} - 
+        see L{I{__call__}<__call__>}.
+
+        Example::
+            date_str = (integer.setResultsName("year") + '/' 
+                        + integer.setResultsName("month") + '/' 
+                        + integer.setResultsName("day"))
+
+            # equivalent form:
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+        """
+        newself = self.copy()
+        if name.endswith("*"):
+            name = name[:-1]
+            listAllMatches=True
+        newself.resultsName = name
+        newself.modalResults = not listAllMatches
+        return newself
+
+    def setBreak(self,breakFlag = True):
+        """Method to invoke the Python pdb debugger when this element is
+           about to be parsed. Set C{breakFlag} to True to enable, False to
+           disable.
+        """
+        if breakFlag:
+            _parseMethod = self._parse
+            def breaker(instring, loc, doActions=True, callPreParse=True):
+                import pdb
+                pdb.set_trace()
+                return _parseMethod( instring, loc, doActions, callPreParse )
+            breaker._originalParseMethod = _parseMethod
+            self._parse = breaker
+        else:
+            if hasattr(self._parse,"_originalParseMethod"):
+                self._parse = self._parse._originalParseMethod
+        return self
+
+    def setParseAction( self, *fns, **kwargs ):
+        """
+        Define one or more actions to perform when successfully matching parse element definition.
+        Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)},
+        C{fn(loc,toks)}, C{fn(toks)}, or just C{fn()}, where:
+         - s   = the original string being parsed (see note below)
+         - loc = the location of the matching substring
+         - toks = a list of the matched tokens, packaged as a C{L{ParseResults}} object
+        If the functions in fns modify the tokens, they can return them as the return
+        value from fn, and the modified list of tokens will replace the original.
+        Otherwise, fn does not need to return any value.
+
+        Optional keyword arguments:
+         - callDuringTry = (default=C{False}) indicate if parse action should be run during lookaheads and alternate testing
+
+        Note: the default parsing behavior is to expand tabs in the input string
+        before starting the parsing process.  See L{I{parseString}<parseString>} for more information
+        on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
+        consistent view of the parsed string, the parse location, and line and column
+        positions within the parsed string.
+        
+        Example::
+            integer = Word(nums)
+            date_str = integer + '/' + integer + '/' + integer
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']
+
+            # use parse action to convert to ints at parse time
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            date_str = integer + '/' + integer + '/' + integer
+
+            # note that integer fields are now ints, not strings
+            date_str.parseString("1999/12/31")  # -> [1999, '/', 12, '/', 31]
+        """
+        self.parseAction = list(map(_trim_arity, list(fns)))
+        self.callDuringTry = kwargs.get("callDuringTry", False)
+        return self
+
+    def addParseAction( self, *fns, **kwargs ):
+        """
+        Add one or more parse actions to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}.
+        
+        See examples in L{I{copy}<copy>}.
+        """
+        self.parseAction += list(map(_trim_arity, list(fns)))
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
+        return self
+
+    def addCondition(self, *fns, **kwargs):
+        """Add a boolean predicate function to expression's list of parse actions. See 
+        L{I{setParseAction}<setParseAction>} for function call signatures. Unlike C{setParseAction}, 
+        functions passed to C{addCondition} need to return boolean success/fail of the condition.
+
+        Optional keyword arguments:
+         - message = define a custom message to be used in the raised exception
+         - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException
+         
+        Example::
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            year_int = integer.copy()
+            year_int.addCondition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later")
+            date_str = year_int + '/' + integer + '/' + integer
+
+            result = date_str.parseString("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1)
+        """
+        msg = kwargs.get("message", "failed user-defined condition")
+        exc_type = ParseFatalException if kwargs.get("fatal", False) else ParseException
+        for fn in fns:
+            def pa(s,l,t):
+                if not bool(_trim_arity(fn)(s,l,t)):
+                    raise exc_type(s,l,msg)
+            self.parseAction.append(pa)
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
+        return self
+
+    def setFailAction( self, fn ):
+        """Define action to perform if parsing fails at this expression.
+           Fail acton fn is a callable function that takes the arguments
+           C{fn(s,loc,expr,err)} where:
+            - s = string being parsed
+            - loc = location where expression match was attempted and failed
+            - expr = the parse expression that failed
+            - err = the exception thrown
+           The function returns no value.  It may throw C{L{ParseFatalException}}
+           if it is desired to stop parsing immediately."""
+        self.failAction = fn
+        return self
+
+    def _skipIgnorables( self, instring, loc ):
+        exprsFound = True
+        while exprsFound:
+            exprsFound = False
+            for e in self.ignoreExprs:
+                try:
+                    while 1:
+                        loc,dummy = e._parse( instring, loc )
+                        exprsFound = True
+                except ParseException:
+                    pass
+        return loc
+
+    def preParse( self, instring, loc ):
+        if self.ignoreExprs:
+            loc = self._skipIgnorables( instring, loc )
+
+        if self.skipWhitespace:
+            wt = self.whiteChars
+            instrlen = len(instring)
+            while loc < instrlen and instring[loc] in wt:
+                loc += 1
+
+        return loc
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        return loc, []
+
+    def postParse( self, instring, loc, tokenlist ):
+        return tokenlist
+
+    #~ @profile
+    def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):
+        debugging = ( self.debug ) #and doActions )
+
+        if debugging or self.failAction:
+            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
+            if (self.debugActions[0] ):
+                self.debugActions[0]( instring, loc, self )
+            if callPreParse and self.callPreparse:
+                preloc = self.preParse( instring, loc )
+            else:
+                preloc = loc
+            tokensStart = preloc
+            try:
+                try:
+                    loc,tokens = self.parseImpl( instring, preloc, doActions )
+                except IndexError:
+                    raise ParseException( instring, len(instring), self.errmsg, self )
+            except ParseBaseException as err:
+                #~ print ("Exception raised:", err)
+                if self.debugActions[2]:
+                    self.debugActions[2]( instring, tokensStart, self, err )
+                if self.failAction:
+                    self.failAction( instring, tokensStart, self, err )
+                raise
+        else:
+            if callPreParse and self.callPreparse:
+                preloc = self.preParse( instring, loc )
+            else:
+                preloc = loc
+            tokensStart = preloc
+            if self.mayIndexError or preloc >= len(instring):
+                try:
+                    loc,tokens = self.parseImpl( instring, preloc, doActions )
+                except IndexError:
+                    raise ParseException( instring, len(instring), self.errmsg, self )
+            else:
+                loc,tokens = self.parseImpl( instring, preloc, doActions )
+
+        tokens = self.postParse( instring, loc, tokens )
+
+        retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )
+        if self.parseAction and (doActions or self.callDuringTry):
+            if debugging:
+                try:
+                    for fn in self.parseAction:
+                        tokens = fn( instring, tokensStart, retTokens )
+                        if tokens is not None:
+                            retTokens = ParseResults( tokens,
+                                                      self.resultsName,
+                                                      asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
+                                                      modal=self.modalResults )
+                except ParseBaseException as err:
+                    #~ print "Exception raised in user parse action:", err
+                    if (self.debugActions[2] ):
+                        self.debugActions[2]( instring, tokensStart, self, err )
+                    raise
+            else:
+                for fn in self.parseAction:
+                    tokens = fn( instring, tokensStart, retTokens )
+                    if tokens is not None:
+                        retTokens = ParseResults( tokens,
+                                                  self.resultsName,
+                                                  asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
+                                                  modal=self.modalResults )
+        if debugging:
+            #~ print ("Matched",self,"->",retTokens.asList())
+            if (self.debugActions[1] ):
+                self.debugActions[1]( instring, tokensStart, loc, self, retTokens )
+
+        return loc, retTokens
+
+    def tryParse( self, instring, loc ):
+        try:
+            return self._parse( instring, loc, doActions=False )[0]
+        except ParseFatalException:
+            raise ParseException( instring, loc, self.errmsg, self)
+    
+    def canParseNext(self, instring, loc):
+        try:
+            self.tryParse(instring, loc)
+        except (ParseException, IndexError):
+            return False
+        else:
+            return True
+
+    class _UnboundedCache(object):
+        def __init__(self):
+            cache = {}
+            self.not_in_cache = not_in_cache = object()
+
+            def get(self, key):
+                return cache.get(key, not_in_cache)
+
+            def set(self, key, value):
+                cache[key] = value
+
+            def clear(self):
+                cache.clear()
+                
+            def cache_len(self):
+                return len(cache)
+
+            self.get = types.MethodType(get, self)
+            self.set = types.MethodType(set, self)
+            self.clear = types.MethodType(clear, self)
+            self.__len__ = types.MethodType(cache_len, self)
+
+    if _OrderedDict is not None:
+        class _FifoCache(object):
+            def __init__(self, size):
+                self.not_in_cache = not_in_cache = object()
+
+                cache = _OrderedDict()
+
+                def get(self, key):
+                    return cache.get(key, not_in_cache)
+
+                def set(self, key, value):
+                    cache[key] = value
+                    while len(cache) > size:
+                        try:
+                            cache.popitem(False)
+                        except KeyError:
+                            pass
+
+                def clear(self):
+                    cache.clear()
+
+                def cache_len(self):
+                    return len(cache)
+
+                self.get = types.MethodType(get, self)
+                self.set = types.MethodType(set, self)
+                self.clear = types.MethodType(clear, self)
+                self.__len__ = types.MethodType(cache_len, self)
+
+    else:
+        class _FifoCache(object):
+            def __init__(self, size):
+                self.not_in_cache = not_in_cache = object()
+
+                cache = {}
+                key_fifo = collections.deque([], size)
+
+                def get(self, key):
+                    return cache.get(key, not_in_cache)
+
+                def set(self, key, value):
+                    cache[key] = value
+                    while len(key_fifo) > size:
+                        cache.pop(key_fifo.popleft(), None)
+                    key_fifo.append(key)
+
+                def clear(self):
+                    cache.clear()
+                    key_fifo.clear()
+
+                def cache_len(self):
+                    return len(cache)
+
+                self.get = types.MethodType(get, self)
+                self.set = types.MethodType(set, self)
+                self.clear = types.MethodType(clear, self)
+                self.__len__ = types.MethodType(cache_len, self)
+
+    # argument cache for optimizing repeated calls when backtracking through recursive expressions
+    packrat_cache = {} # this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail
+    packrat_cache_lock = RLock()
+    packrat_cache_stats = [0, 0]
+
+    # this method gets repeatedly called during backtracking with the same arguments -
+    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression
+    def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):
+        HIT, MISS = 0, 1
+        lookup = (self, instring, loc, callPreParse, doActions)
+        with ParserElement.packrat_cache_lock:
+            cache = ParserElement.packrat_cache
+            value = cache.get(lookup)
+            if value is cache.not_in_cache:
+                ParserElement.packrat_cache_stats[MISS] += 1
+                try:
+                    value = self._parseNoCache(instring, loc, doActions, callPreParse)
+                except ParseBaseException as pe:
+                    # cache a copy of the exception, without the traceback
+                    cache.set(lookup, pe.__class__(*pe.args))
+                    raise
+                else:
+                    cache.set(lookup, (value[0], value[1].copy()))
+                    return value
+            else:
+                ParserElement.packrat_cache_stats[HIT] += 1
+                if isinstance(value, Exception):
+                    raise value
+                return (value[0], value[1].copy())
+
+    _parse = _parseNoCache
+
+    @staticmethod
+    def resetCache():
+        ParserElement.packrat_cache.clear()
+        ParserElement.packrat_cache_stats[:] = [0] * len(ParserElement.packrat_cache_stats)
+
+    _packratEnabled = False
+    @staticmethod
+    def enablePackrat(cache_size_limit=128):
+        """Enables "packrat" parsing, which adds memoizing to the parsing logic.
+           Repeated parse attempts at the same string location (which happens
+           often in many complex grammars) can immediately return a cached value,
+           instead of re-executing parsing/validating code.  Memoizing is done of
+           both valid results and parsing exceptions.
+           
+           Parameters:
+            - cache_size_limit - (default=C{128}) - if an integer value is provided
+              will limit the size of the packrat cache; if None is passed, then
+              the cache size will be unbounded; if 0 is passed, the cache will
+              be effectively disabled.
+            
+           This speedup may break existing programs that use parse actions that
+           have side-effects.  For this reason, packrat parsing is disabled when
+           you first import pyparsing.  To activate the packrat feature, your
+           program must call the class method C{ParserElement.enablePackrat()}.  If
+           your program uses C{psyco} to "compile as you go", you must call
+           C{enablePackrat} before calling C{psyco.full()}.  If you do not do this,
+           Python will crash.  For best results, call C{enablePackrat()} immediately
+           after importing pyparsing.
+           
+           Example::
+               import pyparsing
+               pyparsing.ParserElement.enablePackrat()
+        """
+        if not ParserElement._packratEnabled:
+            ParserElement._packratEnabled = True
+            if cache_size_limit is None:
+                ParserElement.packrat_cache = ParserElement._UnboundedCache()
+            else:
+                ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit)
+            ParserElement._parse = ParserElement._parseCache
+
+    def parseString( self, instring, parseAll=False ):
+        """
+        Execute the parse expression with the given string.
+        This is the main interface to the client code, once the complete
+        expression has been built.
+
+        If you want the grammar to require that the entire input string be
+        successfully parsed, then set C{parseAll} to True (equivalent to ending
+        the grammar with C{L{StringEnd()}}).
+
+        Note: C{parseString} implicitly calls C{expandtabs()} on the input string,
+        in order to report proper column numbers in parse actions.
+        If the input string contains tabs and
+        the grammar uses parse actions that use the C{loc} argument to index into the
+        string being parsed, you can ensure you have a consistent view of the input
+        string by:
+         - calling C{parseWithTabs} on your grammar before calling C{parseString}
+           (see L{I{parseWithTabs}<parseWithTabs>})
+         - define your parse action using the full C{(s,loc,toks)} signature, and
+           reference the input string using the parse action's C{s} argument
+         - explictly expand the tabs in your input string before calling
+           C{parseString}
+        
+        Example::
+            Word('a').parseString('aaaaabaaa')  # -> ['aaaaa']
+            Word('a').parseString('aaaaabaaa', parseAll=True)  # -> Exception: Expected end of text
+        """
+        ParserElement.resetCache()
+        if not self.streamlined:
+            self.streamline()
+            #~ self.saveAsList = True
+        for e in self.ignoreExprs:
+            e.streamline()
+        if not self.keepTabs:
+            instring = instring.expandtabs()
+        try:
+            loc, tokens = self._parse( instring, 0 )
+            if parseAll:
+                loc = self.preParse( instring, loc )
+                se = Empty() + StringEnd()
+                se._parse( instring, loc )
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+        else:
+            return tokens
+
+    def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ):
+        """
+        Scan the input string for expression matches.  Each match will return the
+        matching tokens, start location, and end location.  May be called with optional
+        C{maxMatches} argument, to clip scanning after 'n' matches are found.  If
+        C{overlap} is specified, then overlapping matches will be reported.
+
+        Note that the start and end locations are reported relative to the string
+        being parsed.  See L{I{parseString}<parseString>} for more information on parsing
+        strings with embedded tabs.
+
+        Example::
+            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987"
+            print(source)
+            for tokens,start,end in Word(alphas).scanString(source):
+                print(' '*start + '^'*(end-start))
+                print(' '*start + tokens[0])
+        
+        prints::
+        
+            sldjf123lsdjjkf345sldkjf879lkjsfd987
+            ^^^^^
+            sldjf
+                    ^^^^^^^
+                    lsdjjkf
+                              ^^^^^^
+                              sldkjf
+                                       ^^^^^^
+                                       lkjsfd
+        """
+        if not self.streamlined:
+            self.streamline()
+        for e in self.ignoreExprs:
+            e.streamline()
+
+        if not self.keepTabs:
+            instring = _ustr(instring).expandtabs()
+        instrlen = len(instring)
+        loc = 0
+        preparseFn = self.preParse
+        parseFn = self._parse
+        ParserElement.resetCache()
+        matches = 0
+        try:
+            while loc <= instrlen and matches < maxMatches:
+                try:
+                    preloc = preparseFn( instring, loc )
+                    nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )
+                except ParseException:
+                    loc = preloc+1
+                else:
+                    if nextLoc > loc:
+                        matches += 1
+                        yield tokens, preloc, nextLoc
+                        if overlap:
+                            nextloc = preparseFn( instring, loc )
+                            if nextloc > loc:
+                                loc = nextLoc
+                            else:
+                                loc += 1
+                        else:
+                            loc = nextLoc
+                    else:
+                        loc = preloc+1
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def transformString( self, instring ):
+        """
+        Extension to C{L{scanString}}, to modify matching text with modified tokens that may
+        be returned from a parse action.  To use C{transformString}, define a grammar and
+        attach a parse action to it that modifies the returned token list.
+        Invoking C{transformString()} on a target string will then scan for matches,
+        and replace the matched text patterns according to the logic in the parse
+        action.  C{transformString()} returns the resulting transformed string.
+        
+        Example::
+            wd = Word(alphas)
+            wd.setParseAction(lambda toks: toks[0].title())
+            
+            print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york."))
+        Prints::
+            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York.
+        """
+        out = []
+        lastE = 0
+        # force preservation of <TAB>s, to minimize unwanted transformation of string, and to
+        # keep string locs straight between transformString and scanString
+        self.keepTabs = True
+        try:
+            for t,s,e in self.scanString( instring ):
+                out.append( instring[lastE:s] )
+                if t:
+                    if isinstance(t,ParseResults):
+                        out += t.asList()
+                    elif isinstance(t,list):
+                        out += t
+                    else:
+                        out.append(t)
+                lastE = e
+            out.append(instring[lastE:])
+            out = [o for o in out if o]
+            return "".join(map(_ustr,_flatten(out)))
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def searchString( self, instring, maxMatches=_MAX_INT ):
+        """
+        Another extension to C{L{scanString}}, simplifying the access to the tokens found
+        to match the given parse expression.  May be called with optional
+        C{maxMatches} argument, to clip searching after 'n' matches are found.
+        
+        Example::
+            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters
+            cap_word = Word(alphas.upper(), alphas.lower())
+            
+            print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))
+
+            # the sum() builtin can be used to merge results into a single ParseResults object
+            print(sum(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity")))
+        prints::
+            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']]
+            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity']
+        """
+        try:
+            return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False):
+        """
+        Generator method to split a string using the given expression as a separator.
+        May be called with optional C{maxsplit} argument, to limit the number of splits;
+        and the optional C{includeSeparators} argument (default=C{False}), if the separating
+        matching text should be included in the split results.
+        
+        Example::        
+            punc = oneOf(list(".,;:/-!?"))
+            print(list(punc.split("This, this?, this sentence, is badly punctuated!")))
+        prints::
+            ['This', ' this', '', ' this sentence', ' is badly punctuated', '']
+        """
+        splits = 0
+        last = 0
+        for t,s,e in self.scanString(instring, maxMatches=maxsplit):
+            yield instring[last:s]
+            if includeSeparators:
+                yield t[0]
+            last = e
+        yield instring[last:]
+
+    def __add__(self, other ):
+        """
+        Implementation of + operator - returns C{L{And}}. Adding strings to a ParserElement
+        converts them to L{Literal}s by default.
+        
+        Example::
+            greet = Word(alphas) + "," + Word(alphas) + "!"
+            hello = "Hello, World!"
+            print (hello, "->", greet.parseString(hello))
+        Prints::
+            Hello, World! -> ['Hello', ',', 'World', '!']
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return And( [ self, other ] )
+
+    def __radd__(self, other ):
+        """
+        Implementation of + operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other + self
+
+    def __sub__(self, other):
+        """
+        Implementation of - operator, returns C{L{And}} with error stop
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return self + And._ErrorStop() + other
+
+    def __rsub__(self, other ):
+        """
+        Implementation of - operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other - self
+
+    def __mul__(self,other):
+        """
+        Implementation of * operator, allows use of C{expr * 3} in place of
+        C{expr + expr + expr}.  Expressions may also me multiplied by a 2-integer
+        tuple, similar to C{{min,max}} multipliers in regular expressions.  Tuples
+        may also include C{None} as in:
+         - C{expr*(n,None)} or C{expr*(n,)} is equivalent
+              to C{expr*n + L{ZeroOrMore}(expr)}
+              (read as "at least n instances of C{expr}")
+         - C{expr*(None,n)} is equivalent to C{expr*(0,n)}
+              (read as "0 to n instances of C{expr}")
+         - C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)}
+         - C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)}
+
+        Note that C{expr*(None,n)} does not raise an exception if
+        more than n exprs exist in the input stream; that is,
+        C{expr*(None,n)} does not enforce a maximum number of expr
+        occurrences.  If this behavior is desired, then write
+        C{expr*(None,n) + ~expr}
+        """
+        if isinstance(other,int):
+            minElements, optElements = other,0
+        elif isinstance(other,tuple):
+            other = (other + (None, None))[:2]
+            if other[0] is None:
+                other = (0, other[1])
+            if isinstance(other[0],int) and other[1] is None:
+                if other[0] == 0:
+                    return ZeroOrMore(self)
+                if other[0] == 1:
+                    return OneOrMore(self)
+                else:
+                    return self*other[0] + ZeroOrMore(self)
+            elif isinstance(other[0],int) and isinstance(other[1],int):
+                minElements, optElements = other
+                optElements -= minElements
+            else:
+                raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1]))
+        else:
+            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))
+
+        if minElements < 0:
+            raise ValueError("cannot multiply ParserElement by negative value")
+        if optElements < 0:
+            raise ValueError("second tuple value must be greater or equal to first tuple value")
+        if minElements == optElements == 0:
+            raise ValueError("cannot multiply ParserElement by 0 or (0,0)")
+
+        if (optElements):
+            def makeOptionalList(n):
+                if n>1:
+                    return Optional(self + makeOptionalList(n-1))
+                else:
+                    return Optional(self)
+            if minElements:
+                if minElements == 1:
+                    ret = self + makeOptionalList(optElements)
+                else:
+                    ret = And([self]*minElements) + makeOptionalList(optElements)
+            else:
+                ret = makeOptionalList(optElements)
+        else:
+            if minElements == 1:
+                ret = self
+            else:
+                ret = And([self]*minElements)
+        return ret
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __or__(self, other ):
+        """
+        Implementation of | operator - returns C{L{MatchFirst}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return MatchFirst( [ self, other ] )
+
+    def __ror__(self, other ):
+        """
+        Implementation of | operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other | self
+
+    def __xor__(self, other ):
+        """
+        Implementation of ^ operator - returns C{L{Or}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return Or( [ self, other ] )
+
+    def __rxor__(self, other ):
+        """
+        Implementation of ^ operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other ^ self
+
+    def __and__(self, other ):
+        """
+        Implementation of & operator - returns C{L{Each}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return Each( [ self, other ] )
+
+    def __rand__(self, other ):
+        """
+        Implementation of & operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other & self
+
+    def __invert__( self ):
+        """
+        Implementation of ~ operator - returns C{L{NotAny}}
+        """
+        return NotAny( self )
+
+    def __call__(self, name=None):
+        """
+        Shortcut for C{L{setResultsName}}, with C{listAllMatches=False}.
+        
+        If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be
+        passed as C{True}.
+           
+        If C{name} is omitted, same as calling C{L{copy}}.
+
+        Example::
+            # these are equivalent
+            userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")
+            userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")             
+        """
+        if name is not None:
+            return self.setResultsName(name)
+        else:
+            return self.copy()
+
+    def suppress( self ):
+        """
+        Suppresses the output of this C{ParserElement}; useful to keep punctuation from
+        cluttering up returned output.
+        """
+        return Suppress( self )
+
+    def leaveWhitespace( self ):
+        """
+        Disables the skipping of whitespace before matching the characters in the
+        C{ParserElement}'s defined pattern.  This is normally only used internally by
+        the pyparsing module, but may be needed in some whitespace-sensitive grammars.
+        """
+        self.skipWhitespace = False
+        return self
+
+    def setWhitespaceChars( self, chars ):
+        """
+        Overrides the default whitespace chars
+        """
+        self.skipWhitespace = True
+        self.whiteChars = chars
+        self.copyDefaultWhiteChars = False
+        return self
+
+    def parseWithTabs( self ):
+        """
+        Overrides default behavior to expand C{<TAB>}s to spaces before parsing the input string.
+        Must be called before C{parseString} when the input grammar contains elements that
+        match C{<TAB>} characters.
+        """
+        self.keepTabs = True
+        return self
+
+    def ignore( self, other ):
+        """
+        Define expression to be ignored (e.g., comments) while doing pattern
+        matching; may be called repeatedly, to define multiple comment or other
+        ignorable patterns.
+        
+        Example::
+            patt = OneOrMore(Word(alphas))
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj']
+            
+            patt.ignore(cStyleComment)
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd']
+        """
+        if isinstance(other, basestring):
+            other = Suppress(other)
+
+        if isinstance( other, Suppress ):
+            if other not in self.ignoreExprs:
+                self.ignoreExprs.append(other)
+        else:
+            self.ignoreExprs.append( Suppress( other.copy() ) )
+        return self
+
+    def setDebugActions( self, startAction, successAction, exceptionAction ):
+        """
+        Enable display of debugging messages while doing pattern matching.
+        """
+        self.debugActions = (startAction or _defaultStartDebugAction,
+                             successAction or _defaultSuccessDebugAction,
+                             exceptionAction or _defaultExceptionDebugAction)
+        self.debug = True
+        return self
+
+    def setDebug( self, flag=True ):
+        """
+        Enable display of debugging messages while doing pattern matching.
+        Set C{flag} to True to enable, False to disable.
+
+        Example::
+            wd = Word(alphas).setName("alphaword")
+            integer = Word(nums).setName("numword")
+            term = wd | integer
+            
+            # turn on debugging for wd
+            wd.setDebug()
+
+            OneOrMore(term).parseString("abc 123 xyz 890")
+        
+        prints::
+            Match alphaword at loc 0(1,1)
+            Matched alphaword -> ['abc']
+            Match alphaword at loc 3(1,4)
+            Exception raised:Expected alphaword (at char 4), (line:1, col:5)
+            Match alphaword at loc 7(1,8)
+            Matched alphaword -> ['xyz']
+            Match alphaword at loc 11(1,12)
+            Exception raised:Expected alphaword (at char 12), (line:1, col:13)
+            Match alphaword at loc 15(1,16)
+            Exception raised:Expected alphaword (at char 15), (line:1, col:16)
+
+        The output shown is that produced by the default debug actions - custom debug actions can be
+        specified using L{setDebugActions}. Prior to attempting
+        to match the C{wd} expression, the debugging message C{"Match <exprname> at loc <n>(<line>,<col>)"}
+        is shown. Then if the parse succeeds, a C{"Matched"} message is shown, or an C{"Exception raised"}
+        message is shown. Also note the use of L{setName} to assign a human-readable name to the expression,
+        which makes debugging and exception messages easier to understand - for instance, the default
+        name created for the C{Word} expression without calling C{setName} is C{"W:(ABCD...)"}.
+        """
+        if flag:
+            self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )
+        else:
+            self.debug = False
+        return self
+
+    def __str__( self ):
+        return self.name
+
+    def __repr__( self ):
+        return _ustr(self)
+
+    def streamline( self ):
+        self.streamlined = True
+        self.strRepr = None
+        return self
+
+    def checkRecursion( self, parseElementList ):
+        pass
+
+    def validate( self, validateTrace=[] ):
+        """
+        Check defined expressions for valid structure, check for infinite recursive definitions.
+        """
+        self.checkRecursion( [] )
+
+    def parseFile( self, file_or_filename, parseAll=False ):
+        """
+        Execute the parse expression on the given file or filename.
+        If a filename is specified (instead of a file object),
+        the entire file is opened, read, and closed before parsing.
+        """
+        try:
+            file_contents = file_or_filename.read()
+        except AttributeError:
+            with open(file_or_filename, "r") as f:
+                file_contents = f.read()
+        try:
+            return self.parseString(file_contents, parseAll)
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def __eq__(self,other):
+        if isinstance(other, ParserElement):
+            return self is other or vars(self) == vars(other)
+        elif isinstance(other, basestring):
+            return self.matches(other)
+        else:
+            return super(ParserElement,self)==other
+
+    def __ne__(self,other):
+        return not (self == other)
+
+    def __hash__(self):
+        return hash(id(self))
+
+    def __req__(self,other):
+        return self == other
+
+    def __rne__(self,other):
+        return not (self == other)
+
+    def matches(self, testString, parseAll=True):
+        """
+        Method for quick testing of a parser against a test string. Good for simple 
+        inline microtests of sub expressions while building up larger parser.
+           
+        Parameters:
+         - testString - to test against this expression for a match
+         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests
+            
+        Example::
+            expr = Word(nums)
+            assert expr.matches("100")
+        """
+        try:
+            self.parseString(_ustr(testString), parseAll=parseAll)
+            return True
+        except ParseBaseException:
+            return False
+                
+    def runTests(self, tests, parseAll=True, comment='#', fullDump=True, printResults=True, failureTests=False):
+        """
+        Execute the parse expression on a series of test strings, showing each
+        test, the parsed results or where the parse failed. Quick and easy way to
+        run a parse expression against a list of sample strings.
+           
+        Parameters:
+         - tests - a list of separate test strings, or a multiline string of test strings
+         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests           
+         - comment - (default=C{'#'}) - expression for indicating embedded comments in the test 
+              string; pass None to disable comment filtering
+         - fullDump - (default=C{True}) - dump results as list followed by results names in nested outline;
+              if False, only dump nested list
+         - printResults - (default=C{True}) prints test output to stdout
+         - failureTests - (default=C{False}) indicates if these tests are expected to fail parsing
+
+        Returns: a (success, results) tuple, where success indicates that all tests succeeded
+        (or failed if C{failureTests} is True), and the results contain a list of lines of each 
+        test's output
+        
+        Example::
+            number_expr = pyparsing_common.number.copy()
+
+            result = number_expr.runTests('''
+                # unsigned integer
+                100
+                # negative integer
+                -100
+                # float with scientific notation
+                6.02e23
+                # integer with scientific notation
+                1e-12
+                ''')
+            print("Success" if result[0] else "Failed!")
+
+            result = number_expr.runTests('''
+                # stray character
+                100Z
+                # missing leading digit before '.'
+                -.100
+                # too many '.'
+                3.14.159
+                ''', failureTests=True)
+            print("Success" if result[0] else "Failed!")
+        prints::
+            # unsigned integer
+            100
+            [100]
+
+            # negative integer
+            -100
+            [-100]
+
+            # float with scientific notation
+            6.02e23
+            [6.02e+23]
+
+            # integer with scientific notation
+            1e-12
+            [1e-12]
+
+            Success
+            
+            # stray character
+            100Z
+               ^
+            FAIL: Expected end of text (at char 3), (line:1, col:4)
+
+            # missing leading digit before '.'
+            -.100
+            ^
+            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1)
+
+            # too many '.'
+            3.14.159
+                ^
+            FAIL: Expected end of text (at char 4), (line:1, col:5)
+
+            Success
+
+        Each test string must be on a single line. If you want to test a string that spans multiple
+        lines, create a test like this::
+
+            expr.runTest(r"this is a test\\n of strings that spans \\n 3 lines")
+        
+        (Note that this is a raw string literal, you must include the leading 'r'.)
+        """
+        if isinstance(tests, basestring):
+            tests = list(map(str.strip, tests.rstrip().splitlines()))
+        if isinstance(comment, basestring):
+            comment = Literal(comment)
+        allResults = []
+        comments = []
+        success = True
+        for t in tests:
+            if comment is not None and comment.matches(t, False) or comments and not t:
+                comments.append(t)
+                continue
+            if not t:
+                continue
+            out = ['\n'.join(comments), t]
+            comments = []
+            try:
+                t = t.replace(r'\n','\n')
+                result = self.parseString(t, parseAll=parseAll)
+                out.append(result.dump(full=fullDump))
+                success = success and not failureTests
+            except ParseBaseException as pe:
+                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else ""
+                if '\n' in t:
+                    out.append(line(pe.loc, t))
+                    out.append(' '*(col(pe.loc,t)-1) + '^' + fatal)
+                else:
+                    out.append(' '*pe.loc + '^' + fatal)
+                out.append("FAIL: " + str(pe))
+                success = success and failureTests
+                result = pe
+            except Exception as exc:
+                out.append("FAIL-EXCEPTION: " + str(exc))
+                success = success and failureTests
+                result = exc
+
+            if printResults:
+                if fullDump:
+                    out.append('')
+                print('\n'.join(out))
+
+            allResults.append((t, result))
+        
+        return success, allResults
+
+        
+class Token(ParserElement):
+    """
+    Abstract C{ParserElement} subclass, for defining atomic matching patterns.
+    """
+    def __init__( self ):
+        super(Token,self).__init__( savelist=False )
+
+
+class Empty(Token):
+    """
+    An empty token, will always match.
+    """
+    def __init__( self ):
+        super(Empty,self).__init__()
+        self.name = "Empty"
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+
+
+class NoMatch(Token):
+    """
+    A token that will never match.
+    """
+    def __init__( self ):
+        super(NoMatch,self).__init__()
+        self.name = "NoMatch"
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.errmsg = "Unmatchable token"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class Literal(Token):
+    """
+    Token to exactly match a specified string.
+    
+    Example::
+        Literal('blah').parseString('blah')  # -> ['blah']
+        Literal('blah').parseString('blahfooblah')  # -> ['blah']
+        Literal('blah').parseString('bla')  # -> Exception: Expected "blah"
+    
+    For case-insensitive matching, use L{CaselessLiteral}.
+    
+    For keyword matching (force word break before and after the matched string),
+    use L{Keyword} or L{CaselessKeyword}.
+    """
+    def __init__( self, matchString ):
+        super(Literal,self).__init__()
+        self.match = matchString
+        self.matchLen = len(matchString)
+        try:
+            self.firstMatchChar = matchString[0]
+        except IndexError:
+            warnings.warn("null string passed to Literal; use Empty() instead",
+                            SyntaxWarning, stacklevel=2)
+            self.__class__ = Empty
+        self.name = '"%s"' % _ustr(self.match)
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = False
+        self.mayIndexError = False
+
+    # Performance tuning: this routine gets called a *lot*
+    # if this is a single character match string  and the first character matches,
+    # short-circuit as quickly as possible, and avoid calling startswith
+    #~ @profile
+    def parseImpl( self, instring, loc, doActions=True ):
+        if (instring[loc] == self.firstMatchChar and
+            (self.matchLen==1 or instring.startswith(self.match,loc)) ):
+            return loc+self.matchLen, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+_L = Literal
+ParserElement._literalStringClass = Literal
+
+class Keyword(Token):
+    """
+    Token to exactly match a specified string as a keyword, that is, it must be
+    immediately followed by a non-keyword character.  Compare with C{L{Literal}}:
+     - C{Literal("if")} will match the leading C{'if'} in C{'ifAndOnlyIf'}.
+     - C{Keyword("if")} will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'}
+    Accepts two optional constructor arguments in addition to the keyword string:
+     - C{identChars} is a string of characters that would be valid identifier characters,
+          defaulting to all alphanumerics + "_" and "$"
+     - C{caseless} allows case-insensitive matching, default is C{False}.
+       
+    Example::
+        Keyword("start").parseString("start")  # -> ['start']
+        Keyword("start").parseString("starting")  # -> Exception
+
+    For case-insensitive matching, use L{CaselessKeyword}.
+    """
+    DEFAULT_KEYWORD_CHARS = alphanums+"_$"
+
+    def __init__( self, matchString, identChars=None, caseless=False ):
+        super(Keyword,self).__init__()
+        if identChars is None:
+            identChars = Keyword.DEFAULT_KEYWORD_CHARS
+        self.match = matchString
+        self.matchLen = len(matchString)
+        try:
+            self.firstMatchChar = matchString[0]
+        except IndexError:
+            warnings.warn("null string passed to Keyword; use Empty() instead",
+                            SyntaxWarning, stacklevel=2)
+        self.name = '"%s"' % self.match
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = False
+        self.mayIndexError = False
+        self.caseless = caseless
+        if caseless:
+            self.caselessmatch = matchString.upper()
+            identChars = identChars.upper()
+        self.identChars = set(identChars)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.caseless:
+            if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
+                 (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and
+                 (loc == 0 or instring[loc-1].upper() not in self.identChars) ):
+                return loc+self.matchLen, self.match
+        else:
+            if (instring[loc] == self.firstMatchChar and
+                (self.matchLen==1 or instring.startswith(self.match,loc)) and
+                (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and
+                (loc == 0 or instring[loc-1] not in self.identChars) ):
+                return loc+self.matchLen, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+
+    def copy(self):
+        c = super(Keyword,self).copy()
+        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS
+        return c
+
+    @staticmethod
+    def setDefaultKeywordChars( chars ):
+        """Overrides the default Keyword chars
+        """
+        Keyword.DEFAULT_KEYWORD_CHARS = chars
+
+class CaselessLiteral(Literal):
+    """
+    Token to match a specified string, ignoring case of letters.
+    Note: the matched results will always be in the case of the given
+    match string, NOT the case of the input text.
+
+    Example::
+        OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD']
+        
+    (Contrast with example for L{CaselessKeyword}.)
+    """
+    def __init__( self, matchString ):
+        super(CaselessLiteral,self).__init__( matchString.upper() )
+        # Preserve the defining literal.
+        self.returnString = matchString
+        self.name = "'%s'" % self.returnString
+        self.errmsg = "Expected " + self.name
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if instring[ loc:loc+self.matchLen ].upper() == self.match:
+            return loc+self.matchLen, self.returnString
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class CaselessKeyword(Keyword):
+    """
+    Caseless version of L{Keyword}.
+
+    Example::
+        OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']
+        
+    (Contrast with example for L{CaselessLiteral}.)
+    """
+    def __init__( self, matchString, identChars=None ):
+        super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
+             (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):
+            return loc+self.matchLen, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class CloseMatch(Token):
+    """
+    A variation on L{Literal} which matches "close" matches, that is, 
+    strings with at most 'n' mismatching characters. C{CloseMatch} takes parameters:
+     - C{match_string} - string to be matched
+     - C{maxMismatches} - (C{default=1}) maximum number of mismatches allowed to count as a match
+    
+    The results from a successful parse will contain the matched text from the input string and the following named results:
+     - C{mismatches} - a list of the positions within the match_string where mismatches were found
+     - C{original} - the original match_string used to compare against the input string
+    
+    If C{mismatches} is an empty list, then the match was an exact match.
+    
+    Example::
+        patt = CloseMatch("ATCATCGAATGGA")
+        patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})
+        patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)
+
+        # exact match
+        patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})
+
+        # close match allowing up to 2 mismatches
+        patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2)
+        patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})
+    """
+    def __init__(self, match_string, maxMismatches=1):
+        super(CloseMatch,self).__init__()
+        self.name = match_string
+        self.match_string = match_string
+        self.maxMismatches = maxMismatches
+        self.errmsg = "Expected %r (with up to %d mismatches)" % (self.match_string, self.maxMismatches)
+        self.mayIndexError = False
+        self.mayReturnEmpty = False
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        start = loc
+        instrlen = len(instring)
+        maxloc = start + len(self.match_string)
+
+        if maxloc <= instrlen:
+            match_string = self.match_string
+            match_stringloc = 0
+            mismatches = []
+            maxMismatches = self.maxMismatches
+
+            for match_stringloc,s_m in enumerate(zip(instring[loc:maxloc], self.match_string)):
+                src,mat = s_m
+                if src != mat:
+                    mismatches.append(match_stringloc)
+                    if len(mismatches) > maxMismatches:
+                        break
+            else:
+                loc = match_stringloc + 1
+                results = ParseResults([instring[start:loc]])
+                results['original'] = self.match_string
+                results['mismatches'] = mismatches
+                return loc, results
+
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class Word(Token):
+    """
+    Token for matching words composed of allowed character sets.
+    Defined with string containing all allowed initial characters,
+    an optional string containing allowed body characters (if omitted,
+    defaults to the initial character set), and an optional minimum,
+    maximum, and/or exact length.  The default value for C{min} is 1 (a
+    minimum value < 1 is not valid); the default values for C{max} and C{exact}
+    are 0, meaning no maximum or exact length restriction. An optional
+    C{excludeChars} parameter can list characters that might be found in 
+    the input C{bodyChars} string; useful to define a word of all printables
+    except for one or two characters, for instance.
+    
+    L{srange} is useful for defining custom character set strings for defining 
+    C{Word} expressions, using range notation from regular expression character sets.
+    
+    A common mistake is to use C{Word} to match a specific literal string, as in 
+    C{Word("Address")}. Remember that C{Word} uses the string argument to define
+    I{sets} of matchable characters. This expression would match "Add", "AAA",
+    "dAred", or any other word made up of the characters 'A', 'd', 'r', 'e', and 's'.
+    To match an exact literal string, use L{Literal} or L{Keyword}.
+
+    pyparsing includes helper strings for building Words:
+     - L{alphas}
+     - L{nums}
+     - L{alphanums}
+     - L{hexnums}
+     - L{alphas8bit} (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.)
+     - L{punc8bit} (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.)
+     - L{printables} (any non-whitespace character)
+
+    Example::
+        # a word composed of digits
+        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))
+        
+        # a word with a leading capital, and zero or more lowercase
+        capital_word = Word(alphas.upper(), alphas.lower())
+
+        # hostnames are alphanumeric, with leading alpha, and '-'
+        hostname = Word(alphas, alphanums+'-')
+        
+        # roman numeral (not a strict parser, accepts invalid mix of characters)
+        roman = Word("IVXLCDM")
+        
+        # any string of non-whitespace characters, except for ','
+        csv_value = Word(printables, excludeChars=",")
+    """
+    def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ):
+        super(Word,self).__init__()
+        if excludeChars:
+            initChars = ''.join(c for c in initChars if c not in excludeChars)
+            if bodyChars:
+                bodyChars = ''.join(c for c in bodyChars if c not in excludeChars)
+        self.initCharsOrig = initChars
+        self.initChars = set(initChars)
+        if bodyChars :
+            self.bodyCharsOrig = bodyChars
+            self.bodyChars = set(bodyChars)
+        else:
+            self.bodyCharsOrig = initChars
+            self.bodyChars = set(initChars)
+
+        self.maxSpecified = max > 0
+
+        if min < 1:
+            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.asKeyword = asKeyword
+
+        if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):
+            if self.bodyCharsOrig == self.initCharsOrig:
+                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)
+            elif len(self.initCharsOrig) == 1:
+                self.reString = "%s[%s]*" % \
+                                      (re.escape(self.initCharsOrig),
+                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
+            else:
+                self.reString = "[%s][%s]*" % \
+                                      (_escapeRegexRangeChars(self.initCharsOrig),
+                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
+            if self.asKeyword:
+                self.reString = r"\b"+self.reString+r"\b"
+            try:
+                self.re = re.compile( self.reString )
+            except Exception:
+                self.re = None
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.re:
+            result = self.re.match(instring,loc)
+            if not result:
+                raise ParseException(instring, loc, self.errmsg, self)
+
+            loc = result.end()
+            return loc, result.group()
+
+        if not(instring[ loc ] in self.initChars):
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        start = loc
+        loc += 1
+        instrlen = len(instring)
+        bodychars = self.bodyChars
+        maxloc = start + self.maxLen
+        maxloc = min( maxloc, instrlen )
+        while loc < maxloc and instring[loc] in bodychars:
+            loc += 1
+
+        throwException = False
+        if loc - start < self.minLen:
+            throwException = True
+        if self.maxSpecified and loc < instrlen and instring[loc] in bodychars:
+            throwException = True
+        if self.asKeyword:
+            if (start>0 and instring[start-1] in bodychars) or (loc<instrlen and instring[loc] in bodychars):
+                throwException = True
+
+        if throwException:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+    def __str__( self ):
+        try:
+            return super(Word,self).__str__()
+        except Exception:
+            pass
+
+
+        if self.strRepr is None:
+
+            def charsAsStr(s):
+                if len(s)>4:
+                    return s[:4]+"..."
+                else:
+                    return s
+
+            if ( self.initCharsOrig != self.bodyCharsOrig ):
+                self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) )
+            else:
+                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)
+
+        return self.strRepr
+
+
+class Regex(Token):
+    r"""
+    Token for matching strings that match a given regular expression.
+    Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.
+    If the given regex contains named groups (defined using C{(?P<name>...)}), these will be preserved as 
+    named parse results.
+
+    Example::
+        realnum = Regex(r"[+-]?\d+\.\d*")
+        date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)')
+        # ref: http://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression
+        roman = Regex(r"M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
+    """
+    compiledREtype = type(re.compile("[A-Z]"))
+    def __init__( self, pattern, flags=0):
+        """The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags."""
+        super(Regex,self).__init__()
+
+        if isinstance(pattern, basestring):
+            if not pattern:
+                warnings.warn("null string passed to Regex; use Empty() instead",
+                        SyntaxWarning, stacklevel=2)
+
+            self.pattern = pattern
+            self.flags = flags
+
+            try:
+                self.re = re.compile(self.pattern, self.flags)
+                self.reString = self.pattern
+            except sre_constants.error:
+                warnings.warn("invalid pattern (%s) passed to Regex" % pattern,
+                    SyntaxWarning, stacklevel=2)
+                raise
+
+        elif isinstance(pattern, Regex.compiledREtype):
+            self.re = pattern
+            self.pattern = \
+            self.reString = str(pattern)
+            self.flags = flags
+            
+        else:
+            raise ValueError("Regex may only be constructed with a string or a compiled RE object")
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        result = self.re.match(instring,loc)
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        d = result.groupdict()
+        ret = ParseResults(result.group())
+        if d:
+            for k in d:
+                ret[k] = d[k]
+        return loc,ret
+
+    def __str__( self ):
+        try:
+            return super(Regex,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "Re:(%s)" % repr(self.pattern)
+
+        return self.strRepr
+
+
+class QuotedString(Token):
+    r"""
+    Token for matching strings that are delimited by quoting characters.
+    
+    Defined with the following parameters:
+        - quoteChar - string of one or more characters defining the quote delimiting string
+        - escChar - character to escape quotes, typically backslash (default=C{None})
+        - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=C{None})
+        - multiline - boolean indicating whether quotes can span multiple lines (default=C{False})
+        - unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True})
+        - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar)
+        - convertWhitespaceEscapes - convert escaped whitespace (C{'\t'}, C{'\n'}, etc.) to actual whitespace (default=C{True})
+
+    Example::
+        qs = QuotedString('"')
+        print(qs.searchString('lsjdf "This is the quote" sldjf'))
+        complex_qs = QuotedString('{{', endQuoteChar='}}')
+        print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf'))
+        sql_qs = QuotedString('"', escQuote='""')
+        print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))
+    prints::
+        [['This is the quote']]
+        [['This is the "quote"']]
+        [['This is the quote with "embedded" quotes']]
+    """
+    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True):
+        super(QuotedString,self).__init__()
+
+        # remove white space from quote chars - wont work anyway
+        quoteChar = quoteChar.strip()
+        if not quoteChar:
+            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
+            raise SyntaxError()
+
+        if endQuoteChar is None:
+            endQuoteChar = quoteChar
+        else:
+            endQuoteChar = endQuoteChar.strip()
+            if not endQuoteChar:
+                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
+                raise SyntaxError()
+
+        self.quoteChar = quoteChar
+        self.quoteCharLen = len(quoteChar)
+        self.firstQuoteChar = quoteChar[0]
+        self.endQuoteChar = endQuoteChar
+        self.endQuoteCharLen = len(endQuoteChar)
+        self.escChar = escChar
+        self.escQuote = escQuote
+        self.unquoteResults = unquoteResults
+        self.convertWhitespaceEscapes = convertWhitespaceEscapes
+
+        if multiline:
+            self.flags = re.MULTILINE | re.DOTALL
+            self.pattern = r'%s(?:[^%s%s]' % \
+                ( re.escape(self.quoteChar),
+                  _escapeRegexRangeChars(self.endQuoteChar[0]),
+                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
+        else:
+            self.flags = 0
+            self.pattern = r'%s(?:[^%s\n\r%s]' % \
+                ( re.escape(self.quoteChar),
+                  _escapeRegexRangeChars(self.endQuoteChar[0]),
+                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
+        if len(self.endQuoteChar) > 1:
+            self.pattern += (
+                '|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]),
+                                               _escapeRegexRangeChars(self.endQuoteChar[i]))
+                                    for i in range(len(self.endQuoteChar)-1,0,-1)) + ')'
+                )
+        if escQuote:
+            self.pattern += (r'|(?:%s)' % re.escape(escQuote))
+        if escChar:
+            self.pattern += (r'|(?:%s.)' % re.escape(escChar))
+            self.escCharReplacePattern = re.escape(self.escChar)+"(.)"
+        self.pattern += (r')*%s' % re.escape(self.endQuoteChar))
+
+        try:
+            self.re = re.compile(self.pattern, self.flags)
+            self.reString = self.pattern
+        except sre_constants.error:
+            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,
+                SyntaxWarning, stacklevel=2)
+            raise
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        ret = result.group()
+
+        if self.unquoteResults:
+
+            # strip off quotes
+            ret = ret[self.quoteCharLen:-self.endQuoteCharLen]
+
+            if isinstance(ret,basestring):
+                # replace escaped whitespace
+                if '\\' in ret and self.convertWhitespaceEscapes:
+                    ws_map = {
+                        r'\t' : '\t',
+                        r'\n' : '\n',
+                        r'\f' : '\f',
+                        r'\r' : '\r',
+                    }
+                    for wslit,wschar in ws_map.items():
+                        ret = ret.replace(wslit, wschar)
+
+                # replace escaped characters
+                if self.escChar:
+                    ret = re.sub(self.escCharReplacePattern, r"\g<1>", ret)
+
+                # replace escaped quotes
+                if self.escQuote:
+                    ret = ret.replace(self.escQuote, self.endQuoteChar)
+
+        return loc, ret
+
+    def __str__( self ):
+        try:
+            return super(QuotedString,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)
+
+        return self.strRepr
+
+
+class CharsNotIn(Token):
+    """
+    Token for matching words composed of characters I{not} in a given set (will
+    include whitespace in matched characters if not listed in the provided exclusion set - see example).
+    Defined with string containing all disallowed characters, and an optional
+    minimum, maximum, and/or exact length.  The default value for C{min} is 1 (a
+    minimum value < 1 is not valid); the default values for C{max} and C{exact}
+    are 0, meaning no maximum or exact length restriction.
+
+    Example::
+        # define a comma-separated-value as anything that is not a ','
+        csv_value = CharsNotIn(',')
+        print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213"))
+    prints::
+        ['dkls', 'lsdkjf', 's12 34', '@!#', '213']
+    """
+    def __init__( self, notChars, min=1, max=0, exact=0 ):
+        super(CharsNotIn,self).__init__()
+        self.skipWhitespace = False
+        self.notChars = notChars
+
+        if min < 1:
+            raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted")
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = ( self.minLen == 0 )
+        self.mayIndexError = False
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if instring[loc] in self.notChars:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        start = loc
+        loc += 1
+        notchars = self.notChars
+        maxlen = min( start+self.maxLen, len(instring) )
+        while loc < maxlen and \
+              (instring[loc] not in notchars):
+            loc += 1
+
+        if loc - start < self.minLen:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+    def __str__( self ):
+        try:
+            return super(CharsNotIn, self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            if len(self.notChars) > 4:
+                self.strRepr = "!W:(%s...)" % self.notChars[:4]
+            else:
+                self.strRepr = "!W:(%s)" % self.notChars
+
+        return self.strRepr
+
+class White(Token):
+    """
+    Special matching class for matching whitespace.  Normally, whitespace is ignored
+    by pyparsing grammars.  This class is included when some whitespace structures
+    are significant.  Define with a string containing the whitespace characters to be
+    matched; default is C{" \\t\\r\\n"}.  Also takes optional C{min}, C{max}, and C{exact} arguments,
+    as defined for the C{L{Word}} class.
+    """
+    whiteStrs = {
+        " " : "<SPC>",
+        "\t": "<TAB>",
+        "\n": "<LF>",
+        "\r": "<CR>",
+        "\f": "<FF>",
+        }
+    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):
+        super(White,self).__init__()
+        self.matchWhite = ws
+        self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) )
+        #~ self.leaveWhitespace()
+        self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite))
+        self.mayReturnEmpty = True
+        self.errmsg = "Expected " + self.name
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if not(instring[ loc ] in self.matchWhite):
+            raise ParseException(instring, loc, self.errmsg, self)
+        start = loc
+        loc += 1
+        maxloc = start + self.maxLen
+        maxloc = min( maxloc, len(instring) )
+        while loc < maxloc and instring[loc] in self.matchWhite:
+            loc += 1
+
+        if loc - start < self.minLen:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+
+class _PositionToken(Token):
+    def __init__( self ):
+        super(_PositionToken,self).__init__()
+        self.name=self.__class__.__name__
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+
+class GoToColumn(_PositionToken):
+    """
+    Token to advance to a specific column of input text; useful for tabular report scraping.
+    """
+    def __init__( self, colno ):
+        super(GoToColumn,self).__init__()
+        self.col = colno
+
+    def preParse( self, instring, loc ):
+        if col(loc,instring) != self.col:
+            instrlen = len(instring)
+            if self.ignoreExprs:
+                loc = self._skipIgnorables( instring, loc )
+            while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col :
+                loc += 1
+        return loc
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        thiscol = col( loc, instring )
+        if thiscol > self.col:
+            raise ParseException( instring, loc, "Text not in expected column", self )
+        newloc = loc + self.col - thiscol
+        ret = instring[ loc: newloc ]
+        return newloc, ret
+
+
+class LineStart(_PositionToken):
+    """
+    Matches if current position is at the beginning of a line within the parse string
+    
+    Example::
+    
+        test = '''\
+        AAA this line
+        AAA and this line
+          AAA but not this one
+        B AAA and definitely not this one
+        '''
+
+        for t in (LineStart() + 'AAA' + restOfLine).searchString(test):
+            print(t)
+    
+    Prints::
+        ['AAA', ' this line']
+        ['AAA', ' and this line']    
+
+    """
+    def __init__( self ):
+        super(LineStart,self).__init__()
+        self.errmsg = "Expected start of line"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if col(loc, instring) == 1:
+            return loc, []
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class LineEnd(_PositionToken):
+    """
+    Matches if current position is at the end of a line within the parse string
+    """
+    def __init__( self ):
+        super(LineEnd,self).__init__()
+        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )
+        self.errmsg = "Expected end of line"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if loc<len(instring):
+            if instring[loc] == "\n":
+                return loc+1, "\n"
+            else:
+                raise ParseException(instring, loc, self.errmsg, self)
+        elif loc == len(instring):
+            return loc+1, []
+        else:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+class StringStart(_PositionToken):
+    """
+    Matches if current position is at the beginning of the parse string
+    """
+    def __init__( self ):
+        super(StringStart,self).__init__()
+        self.errmsg = "Expected start of text"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if loc != 0:
+            # see if entire string up to here is just whitespace and ignoreables
+            if loc != self.preParse( instring, 0 ):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+class StringEnd(_PositionToken):
+    """
+    Matches if current position is at the end of the parse string
+    """
+    def __init__( self ):
+        super(StringEnd,self).__init__()
+        self.errmsg = "Expected end of text"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if loc < len(instring):
+            raise ParseException(instring, loc, self.errmsg, self)
+        elif loc == len(instring):
+            return loc+1, []
+        elif loc > len(instring):
+            return loc, []
+        else:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+class WordStart(_PositionToken):
+    """
+    Matches if the current position is at the beginning of a Word, and
+    is not preceded by any character in a given set of C{wordChars}
+    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
+    use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of
+    the string being parsed, or at the beginning of a line.
+    """
+    def __init__(self, wordChars = printables):
+        super(WordStart,self).__init__()
+        self.wordChars = set(wordChars)
+        self.errmsg = "Not at the start of a word"
+
+    def parseImpl(self, instring, loc, doActions=True ):
+        if loc != 0:
+            if (instring[loc-1] in self.wordChars or
+                instring[loc] not in self.wordChars):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+class WordEnd(_PositionToken):
+    """
+    Matches if the current position is at the end of a Word, and
+    is not followed by any character in a given set of C{wordChars}
+    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
+    use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of
+    the string being parsed, or at the end of a line.
+    """
+    def __init__(self, wordChars = printables):
+        super(WordEnd,self).__init__()
+        self.wordChars = set(wordChars)
+        self.skipWhitespace = False
+        self.errmsg = "Not at the end of a word"
+
+    def parseImpl(self, instring, loc, doActions=True ):
+        instrlen = len(instring)
+        if instrlen>0 and loc<instrlen:
+            if (instring[loc] in self.wordChars or
+                instring[loc-1] not in self.wordChars):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+
+class ParseExpression(ParserElement):
+    """
+    Abstract subclass of ParserElement, for combining and post-processing parsed tokens.
+    """
+    def __init__( self, exprs, savelist = False ):
+        super(ParseExpression,self).__init__(savelist)
+        if isinstance( exprs, _generatorType ):
+            exprs = list(exprs)
+
+        if isinstance( exprs, basestring ):
+            self.exprs = [ ParserElement._literalStringClass( exprs ) ]
+        elif isinstance( exprs, Iterable ):
+            exprs = list(exprs)
+            # if sequence of strings provided, wrap with Literal
+            if all(isinstance(expr, basestring) for expr in exprs):
+                exprs = map(ParserElement._literalStringClass, exprs)
+            self.exprs = list(exprs)
+        else:
+            try:
+                self.exprs = list( exprs )
+            except TypeError:
+                self.exprs = [ exprs ]
+        self.callPreparse = False
+
+    def __getitem__( self, i ):
+        return self.exprs[i]
+
+    def append( self, other ):
+        self.exprs.append( other )
+        self.strRepr = None
+        return self
+
+    def leaveWhitespace( self ):
+        """Extends C{leaveWhitespace} defined in base class, and also invokes C{leaveWhitespace} on
+           all contained expressions."""
+        self.skipWhitespace = False
+        self.exprs = [ e.copy() for e in self.exprs ]
+        for e in self.exprs:
+            e.leaveWhitespace()
+        return self
+
+    def ignore( self, other ):
+        if isinstance( other, Suppress ):
+            if other not in self.ignoreExprs:
+                super( ParseExpression, self).ignore( other )
+                for e in self.exprs:
+                    e.ignore( self.ignoreExprs[-1] )
+        else:
+            super( ParseExpression, self).ignore( other )
+            for e in self.exprs:
+                e.ignore( self.ignoreExprs[-1] )
+        return self
+
+    def __str__( self ):
+        try:
+            return super(ParseExpression,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.exprs) )
+        return self.strRepr
+
+    def streamline( self ):
+        super(ParseExpression,self).streamline()
+
+        for e in self.exprs:
+            e.streamline()
+
+        # collapse nested And's of the form And( And( And( a,b), c), d) to And( a,b,c,d )
+        # but only if there are no parse actions or resultsNames on the nested And's
+        # (likewise for Or's and MatchFirst's)
+        if ( len(self.exprs) == 2 ):
+            other = self.exprs[0]
+            if ( isinstance( other, self.__class__ ) and
+                  not(other.parseAction) and
+                  other.resultsName is None and
+                  not other.debug ):
+                self.exprs = other.exprs[:] + [ self.exprs[1] ]
+                self.strRepr = None
+                self.mayReturnEmpty |= other.mayReturnEmpty
+                self.mayIndexError  |= other.mayIndexError
+
+            other = self.exprs[-1]
+            if ( isinstance( other, self.__class__ ) and
+                  not(other.parseAction) and
+                  other.resultsName is None and
+                  not other.debug ):
+                self.exprs = self.exprs[:-1] + other.exprs[:]
+                self.strRepr = None
+                self.mayReturnEmpty |= other.mayReturnEmpty
+                self.mayIndexError  |= other.mayIndexError
+
+        self.errmsg = "Expected " + _ustr(self)
+        
+        return self
+
+    def setResultsName( self, name, listAllMatches=False ):
+        ret = super(ParseExpression,self).setResultsName(name,listAllMatches)
+        return ret
+
+    def validate( self, validateTrace=[] ):
+        tmp = validateTrace[:]+[self]
+        for e in self.exprs:
+            e.validate(tmp)
+        self.checkRecursion( [] )
+        
+    def copy(self):
+        ret = super(ParseExpression,self).copy()
+        ret.exprs = [e.copy() for e in self.exprs]
+        return ret
+
+class And(ParseExpression):
+    """
+    Requires all given C{ParseExpression}s to be found in the given order.
+    Expressions may be separated by whitespace.
+    May be constructed using the C{'+'} operator.
+    May also be constructed using the C{'-'} operator, which will suppress backtracking.
+
+    Example::
+        integer = Word(nums)
+        name_expr = OneOrMore(Word(alphas))
+
+        expr = And([integer("id"),name_expr("name"),integer("age")])
+        # more easily written as:
+        expr = integer("id") + name_expr("name") + integer("age")
+    """
+
+    class _ErrorStop(Empty):
+        def __init__(self, *args, **kwargs):
+            super(And._ErrorStop,self).__init__(*args, **kwargs)
+            self.name = '-'
+            self.leaveWhitespace()
+
+    def __init__( self, exprs, savelist = True ):
+        super(And,self).__init__(exprs, savelist)
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        self.setWhitespaceChars( self.exprs[0].whiteChars )
+        self.skipWhitespace = self.exprs[0].skipWhitespace
+        self.callPreparse = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        # pass False as last arg to _parse for first element, since we already
+        # pre-parsed the string as part of our And pre-parsing
+        loc, resultlist = self.exprs[0]._parse( instring, loc, doActions, callPreParse=False )
+        errorStop = False
+        for e in self.exprs[1:]:
+            if isinstance(e, And._ErrorStop):
+                errorStop = True
+                continue
+            if errorStop:
+                try:
+                    loc, exprtokens = e._parse( instring, loc, doActions )
+                except ParseSyntaxException:
+                    raise
+                except ParseBaseException as pe:
+                    pe.__traceback__ = None
+                    raise ParseSyntaxException._from_exception(pe)
+                except IndexError:
+                    raise ParseSyntaxException(instring, len(instring), self.errmsg, self)
+            else:
+                loc, exprtokens = e._parse( instring, loc, doActions )
+            if exprtokens or exprtokens.haskeys():
+                resultlist += exprtokens
+        return loc, resultlist
+
+    def __iadd__(self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        return self.append( other ) #And( [ self, other ] )
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+            if not e.mayReturnEmpty:
+                break
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+
+class Or(ParseExpression):
+    """
+    Requires that at least one C{ParseExpression} is found.
+    If two expressions match, the expression that matches the longest string will be used.
+    May be constructed using the C{'^'} operator.
+
+    Example::
+        # construct Or using '^' operator
+        
+        number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums))
+        print(number.searchString("123 3.1416 789"))
+    prints::
+        [['123'], ['3.1416'], ['789']]
+    """
+    def __init__( self, exprs, savelist = False ):
+        super(Or,self).__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        maxExcLoc = -1
+        maxException = None
+        matches = []
+        for e in self.exprs:
+            try:
+                loc2 = e.tryParse( instring, loc )
+            except ParseException as err:
+                err.__traceback__ = None
+                if err.loc > maxExcLoc:
+                    maxException = err
+                    maxExcLoc = err.loc
+            except IndexError:
+                if len(instring) > maxExcLoc:
+                    maxException = ParseException(instring,len(instring),e.errmsg,self)
+                    maxExcLoc = len(instring)
+            else:
+                # save match among all matches, to retry longest to shortest
+                matches.append((loc2, e))
+
+        if matches:
+            matches.sort(key=lambda x: -x[0])
+            for _,e in matches:
+                try:
+                    return e._parse( instring, loc, doActions )
+                except ParseException as err:
+                    err.__traceback__ = None
+                    if err.loc > maxExcLoc:
+                        maxException = err
+                        maxExcLoc = err.loc
+
+        if maxException is not None:
+            maxException.msg = self.errmsg
+            raise maxException
+        else:
+            raise ParseException(instring, loc, "no defined alternatives to match", self)
+
+
+    def __ixor__(self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        return self.append( other ) #Or( [ self, other ] )
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+
+
+class MatchFirst(ParseExpression):
+    """
+    Requires that at least one C{ParseExpression} is found.
+    If two expressions match, the first one listed is the one that will match.
+    May be constructed using the C{'|'} operator.
+
+    Example::
+        # construct MatchFirst using '|' operator
+        
+        # watch the order of expressions to match
+        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))
+        print(number.searchString("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']]
+
+        # put more selective expression first
+        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)
+        print(number.searchString("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']]
+    """
+    def __init__( self, exprs, savelist = False ):
+        super(MatchFirst,self).__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        maxExcLoc = -1
+        maxException = None
+        for e in self.exprs:
+            try:
+                ret = e._parse( instring, loc, doActions )
+                return ret
+            except ParseException as err:
+                if err.loc > maxExcLoc:
+                    maxException = err
+                    maxExcLoc = err.loc
+            except IndexError:
+                if len(instring) > maxExcLoc:
+                    maxException = ParseException(instring,len(instring),e.errmsg,self)
+                    maxExcLoc = len(instring)
+
+        # only got here if no expression matched, raise exception for match that made it the furthest
+        else:
+            if maxException is not None:
+                maxException.msg = self.errmsg
+                raise maxException
+            else:
+                raise ParseException(instring, loc, "no defined alternatives to match", self)
+
+    def __ior__(self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        return self.append( other ) #MatchFirst( [ self, other ] )
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+
+
+class Each(ParseExpression):
+    """
+    Requires all given C{ParseExpression}s to be found, but in any order.
+    Expressions may be separated by whitespace.
+    May be constructed using the C{'&'} operator.
+
+    Example::
+        color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")
+        shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")
+        integer = Word(nums)
+        shape_attr = "shape:" + shape_type("shape")
+        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")
+        color_attr = "color:" + color("color")
+        size_attr = "size:" + integer("size")
+
+        # use Each (using operator '&') to accept attributes in any order 
+        # (shape and posn are required, color and size are optional)
+        shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr)
+
+        shape_spec.runTests('''
+            shape: SQUARE color: BLACK posn: 100, 120
+            shape: CIRCLE size: 50 color: BLUE posn: 50,80
+            color:GREEN size:20 shape:TRIANGLE posn:20,40
+            '''
+            )
+    prints::
+        shape: SQUARE color: BLACK posn: 100, 120
+        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]
+        - color: BLACK
+        - posn: ['100', ',', '120']
+          - x: 100
+          - y: 120
+        - shape: SQUARE
+
+
+        shape: CIRCLE size: 50 color: BLUE posn: 50,80
+        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]
+        - color: BLUE
+        - posn: ['50', ',', '80']
+          - x: 50
+          - y: 80
+        - shape: CIRCLE
+        - size: 50
+
+
+        color: GREEN size: 20 shape: TRIANGLE posn: 20,40
+        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]
+        - color: GREEN
+        - posn: ['20', ',', '40']
+          - x: 20
+          - y: 40
+        - shape: TRIANGLE
+        - size: 20
+    """
+    def __init__( self, exprs, savelist = True ):
+        super(Each,self).__init__(exprs, savelist)
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        self.skipWhitespace = True
+        self.initExprGroups = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.initExprGroups:
+            self.opt1map = dict((id(e.expr),e) for e in self.exprs if isinstance(e,Optional))
+            opt1 = [ e.expr for e in self.exprs if isinstance(e,Optional) ]
+            opt2 = [ e for e in self.exprs if e.mayReturnEmpty and not isinstance(e,Optional)]
+            self.optionals = opt1 + opt2
+            self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ]
+            self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ]
+            self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ]
+            self.required += self.multirequired
+            self.initExprGroups = False
+        tmpLoc = loc
+        tmpReqd = self.required[:]
+        tmpOpt  = self.optionals[:]
+        matchOrder = []
+
+        keepMatching = True
+        while keepMatching:
+            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired
+            failed = []
+            for e in tmpExprs:
+                try:
+                    tmpLoc = e.tryParse( instring, tmpLoc )
+                except ParseException:
+                    failed.append(e)
+                else:
+                    matchOrder.append(self.opt1map.get(id(e),e))
+                    if e in tmpReqd:
+                        tmpReqd.remove(e)
+                    elif e in tmpOpt:
+                        tmpOpt.remove(e)
+            if len(failed) == len(tmpExprs):
+                keepMatching = False
+
+        if tmpReqd:
+            missing = ", ".join(_ustr(e) for e in tmpReqd)
+            raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing )
+
+        # add any unmatched Optionals, in case they have default values defined
+        matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt]
+
+        resultlist = []
+        for e in matchOrder:
+            loc,results = e._parse(instring,loc,doActions)
+            resultlist.append(results)
+
+        finalResults = sum(resultlist, ParseResults([]))
+        return loc, finalResults
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+
+
+class ParseElementEnhance(ParserElement):
+    """
+    Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens.
+    """
+    def __init__( self, expr, savelist=False ):
+        super(ParseElementEnhance,self).__init__(savelist)
+        if isinstance( expr, basestring ):
+            if issubclass(ParserElement._literalStringClass, Token):
+                expr = ParserElement._literalStringClass(expr)
+            else:
+                expr = ParserElement._literalStringClass(Literal(expr))
+        self.expr = expr
+        self.strRepr = None
+        if expr is not None:
+            self.mayIndexError = expr.mayIndexError
+            self.mayReturnEmpty = expr.mayReturnEmpty
+            self.setWhitespaceChars( expr.whiteChars )
+            self.skipWhitespace = expr.skipWhitespace
+            self.saveAsList = expr.saveAsList
+            self.callPreparse = expr.callPreparse
+            self.ignoreExprs.extend(expr.ignoreExprs)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.expr is not None:
+            return self.expr._parse( instring, loc, doActions, callPreParse=False )
+        else:
+            raise ParseException("",loc,self.errmsg,self)
+
+    def leaveWhitespace( self ):
+        self.skipWhitespace = False
+        self.expr = self.expr.copy()
+        if self.expr is not None:
+            self.expr.leaveWhitespace()
+        return self
+
+    def ignore( self, other ):
+        if isinstance( other, Suppress ):
+            if other not in self.ignoreExprs:
+                super( ParseElementEnhance, self).ignore( other )
+                if self.expr is not None:
+                    self.expr.ignore( self.ignoreExprs[-1] )
+        else:
+            super( ParseElementEnhance, self).ignore( other )
+            if self.expr is not None:
+                self.expr.ignore( self.ignoreExprs[-1] )
+        return self
+
+    def streamline( self ):
+        super(ParseElementEnhance,self).streamline()
+        if self.expr is not None:
+            self.expr.streamline()
+        return self
+
+    def checkRecursion( self, parseElementList ):
+        if self in parseElementList:
+            raise RecursiveGrammarException( parseElementList+[self] )
+        subRecCheckList = parseElementList[:] + [ self ]
+        if self.expr is not None:
+            self.expr.checkRecursion( subRecCheckList )
+
+    def validate( self, validateTrace=[] ):
+        tmp = validateTrace[:]+[self]
+        if self.expr is not None:
+            self.expr.validate(tmp)
+        self.checkRecursion( [] )
+
+    def __str__( self ):
+        try:
+            return super(ParseElementEnhance,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None and self.expr is not None:
+            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) )
+        return self.strRepr
+
+
+class FollowedBy(ParseElementEnhance):
+    """
+    Lookahead matching of the given parse expression.  C{FollowedBy}
+    does I{not} advance the parsing position within the input string, it only
+    verifies that the specified parse expression matches at the current
+    position.  C{FollowedBy} always returns a null token list.
+
+    Example::
+        # use FollowedBy to match a label only if it is followed by a ':'
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        
+        OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint()
+    prints::
+        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]
+    """
+    def __init__( self, expr ):
+        super(FollowedBy,self).__init__(expr)
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        self.expr.tryParse( instring, loc )
+        return loc, []
+
+
+class NotAny(ParseElementEnhance):
+    """
+    Lookahead to disallow matching with the given parse expression.  C{NotAny}
+    does I{not} advance the parsing position within the input string, it only
+    verifies that the specified parse expression does I{not} match at the current
+    position.  Also, C{NotAny} does I{not} skip over leading whitespace. C{NotAny}
+    always returns a null token list.  May be constructed using the '~' operator.
+
+    Example::
+        
+    """
+    def __init__( self, expr ):
+        super(NotAny,self).__init__(expr)
+        #~ self.leaveWhitespace()
+        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs
+        self.mayReturnEmpty = True
+        self.errmsg = "Found unwanted token, "+_ustr(self.expr)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.expr.canParseNext(instring, loc):
+            raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "~{" + _ustr(self.expr) + "}"
+
+        return self.strRepr
+
+class _MultipleMatch(ParseElementEnhance):
+    def __init__( self, expr, stopOn=None):
+        super(_MultipleMatch, self).__init__(expr)
+        self.saveAsList = True
+        ender = stopOn
+        if isinstance(ender, basestring):
+            ender = ParserElement._literalStringClass(ender)
+        self.not_ender = ~ender if ender is not None else None
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        self_expr_parse = self.expr._parse
+        self_skip_ignorables = self._skipIgnorables
+        check_ender = self.not_ender is not None
+        if check_ender:
+            try_not_ender = self.not_ender.tryParse
+        
+        # must be at least one (but first see if we are the stopOn sentinel;
+        # if so, fail)
+        if check_ender:
+            try_not_ender(instring, loc)
+        loc, tokens = self_expr_parse( instring, loc, doActions, callPreParse=False )
+        try:
+            hasIgnoreExprs = (not not self.ignoreExprs)
+            while 1:
+                if check_ender:
+                    try_not_ender(instring, loc)
+                if hasIgnoreExprs:
+                    preloc = self_skip_ignorables( instring, loc )
+                else:
+                    preloc = loc
+                loc, tmptokens = self_expr_parse( instring, preloc, doActions )
+                if tmptokens or tmptokens.haskeys():
+                    tokens += tmptokens
+        except (ParseException,IndexError):
+            pass
+
+        return loc, tokens
+        
+class OneOrMore(_MultipleMatch):
+    """
+    Repetition of one or more of the given expression.
+    
+    Parameters:
+     - expr - expression that must match one or more times
+     - stopOn - (default=C{None}) - expression for a terminating sentinel
+          (only required if the sentinel would ordinarily match the repetition 
+          expression)          
+
+    Example::
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
+
+        text = "shape: SQUARE posn: upper left color: BLACK"
+        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]
+
+        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]
+        
+        # could also be written as
+        (attr_expr * (1,)).parseString(text).pprint()
+    """
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + _ustr(self.expr) + "}..."
+
+        return self.strRepr
+
+class ZeroOrMore(_MultipleMatch):
+    """
+    Optional repetition of zero or more of the given expression.
+    
+    Parameters:
+     - expr - expression that must match zero or more times
+     - stopOn - (default=C{None}) - expression for a terminating sentinel
+          (only required if the sentinel would ordinarily match the repetition 
+          expression)          
+
+    Example: similar to L{OneOrMore}
+    """
+    def __init__( self, expr, stopOn=None):
+        super(ZeroOrMore,self).__init__(expr, stopOn=stopOn)
+        self.mayReturnEmpty = True
+        
+    def parseImpl( self, instring, loc, doActions=True ):
+        try:
+            return super(ZeroOrMore, self).parseImpl(instring, loc, doActions)
+        except (ParseException,IndexError):
+            return loc, []
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "[" + _ustr(self.expr) + "]..."
+
+        return self.strRepr
+
+class _NullToken(object):
+    def __bool__(self):
+        return False
+    __nonzero__ = __bool__
+    def __str__(self):
+        return ""
+
+_optionalNotMatched = _NullToken()
+class Optional(ParseElementEnhance):
+    """
+    Optional matching of the given expression.
+
+    Parameters:
+     - expr - expression that must match zero or more times
+     - default (optional) - value to be returned if the optional expression is not found.
+
+    Example::
+        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier
+        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4)))
+        zip.runTests('''
+            # traditional ZIP code
+            12345
+            
+            # ZIP+4 form
+            12101-0001
+            
+            # invalid ZIP
+            98765-
+            ''')
+    prints::
+        # traditional ZIP code
+        12345
+        ['12345']
+
+        # ZIP+4 form
+        12101-0001
+        ['12101-0001']
+
+        # invalid ZIP
+        98765-
+             ^
+        FAIL: Expected end of text (at char 5), (line:1, col:6)
+    """
+    def __init__( self, expr, default=_optionalNotMatched ):
+        super(Optional,self).__init__( expr, savelist=False )
+        self.saveAsList = self.expr.saveAsList
+        self.defaultValue = default
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        try:
+            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
+        except (ParseException,IndexError):
+            if self.defaultValue is not _optionalNotMatched:
+                if self.expr.resultsName:
+                    tokens = ParseResults([ self.defaultValue ])
+                    tokens[self.expr.resultsName] = self.defaultValue
+                else:
+                    tokens = [ self.defaultValue ]
+            else:
+                tokens = []
+        return loc, tokens
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "[" + _ustr(self.expr) + "]"
+
+        return self.strRepr
+
+class SkipTo(ParseElementEnhance):
+    """
+    Token for skipping over all undefined text until the matched expression is found.
+
+    Parameters:
+     - expr - target expression marking the end of the data to be skipped
+     - include - (default=C{False}) if True, the target expression is also parsed 
+          (the skipped text and target expression are returned as a 2-element list).
+     - ignore - (default=C{None}) used to define grammars (typically quoted strings and 
+          comments) that might contain false matches to the target expression
+     - failOn - (default=C{None}) define expressions that are not allowed to be 
+          included in the skipped test; if found before the target expression is found, 
+          the SkipTo is not a match
+
+    Example::
+        report = '''
+            Outstanding Issues Report - 1 Jan 2000
+
+               # | Severity | Description                               |  Days Open
+            -----+----------+-------------------------------------------+-----------
+             101 | Critical | Intermittent system crash                 |          6
+              94 | Cosmetic | Spelling error on Login ('log|n')         |         14
+              79 | Minor    | System slow when running too many reports |         47
+            '''
+        integer = Word(nums)
+        SEP = Suppress('|')
+        # use SkipTo to simply match everything up until the next SEP
+        # - ignore quoted strings, so that a '|' character inside a quoted string does not match
+        # - parse action will call token.strip() for each matched token, i.e., the description body
+        string_data = SkipTo(SEP, ignore=quotedString)
+        string_data.setParseAction(tokenMap(str.strip))
+        ticket_expr = (integer("issue_num") + SEP 
+                      + string_data("sev") + SEP 
+                      + string_data("desc") + SEP 
+                      + integer("days_open"))
+        
+        for tkt in ticket_expr.searchString(report):
+            print tkt.dump()
+    prints::
+        ['101', 'Critical', 'Intermittent system crash', '6']
+        - days_open: 6
+        - desc: Intermittent system crash
+        - issue_num: 101
+        - sev: Critical
+        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']
+        - days_open: 14
+        - desc: Spelling error on Login ('log|n')
+        - issue_num: 94
+        - sev: Cosmetic
+        ['79', 'Minor', 'System slow when running too many reports', '47']
+        - days_open: 47
+        - desc: System slow when running too many reports
+        - issue_num: 79
+        - sev: Minor
+    """
+    def __init__( self, other, include=False, ignore=None, failOn=None ):
+        super( SkipTo, self ).__init__( other )
+        self.ignoreExpr = ignore
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.includeMatch = include
+        self.asList = False
+        if isinstance(failOn, basestring):
+            self.failOn = ParserElement._literalStringClass(failOn)
+        else:
+            self.failOn = failOn
+        self.errmsg = "No match found for "+_ustr(self.expr)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        startloc = loc
+        instrlen = len(instring)
+        expr = self.expr
+        expr_parse = self.expr._parse
+        self_failOn_canParseNext = self.failOn.canParseNext if self.failOn is not None else None
+        self_ignoreExpr_tryParse = self.ignoreExpr.tryParse if self.ignoreExpr is not None else None
+        
+        tmploc = loc
+        while tmploc <= instrlen:
+            if self_failOn_canParseNext is not None:
+                # break if failOn expression matches
+                if self_failOn_canParseNext(instring, tmploc):
+                    break
+                    
+            if self_ignoreExpr_tryParse is not None:
+                # advance past ignore expressions
+                while 1:
+                    try:
+                        tmploc = self_ignoreExpr_tryParse(instring, tmploc)
+                    except ParseBaseException:
+                        break
+            
+            try:
+                expr_parse(instring, tmploc, doActions=False, callPreParse=False)
+            except (ParseException, IndexError):
+                # no match, advance loc in string
+                tmploc += 1
+            else:
+                # matched skipto expr, done
+                break
+
+        else:
+            # ran off the end of the input string without matching skipto expr, fail
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        # build up return values
+        loc = tmploc
+        skiptext = instring[startloc:loc]
+        skipresult = ParseResults(skiptext)
+        
+        if self.includeMatch:
+            loc, mat = expr_parse(instring,loc,doActions,callPreParse=False)
+            skipresult += mat
+
+        return loc, skipresult
+
+class Forward(ParseElementEnhance):
+    """
+    Forward declaration of an expression to be defined later -
+    used for recursive grammars, such as algebraic infix notation.
+    When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator.
+
+    Note: take care when assigning to C{Forward} not to overlook precedence of operators.
+    Specifically, '|' has a lower precedence than '<<', so that::
+        fwdExpr << a | b | c
+    will actually be evaluated as::
+        (fwdExpr << a) | b | c
+    thereby leaving b and c out as parseable alternatives.  It is recommended that you
+    explicitly group the values inserted into the C{Forward}::
+        fwdExpr << (a | b | c)
+    Converting to use the '<<=' operator instead will avoid this problem.
+
+    See L{ParseResults.pprint} for an example of a recursive parser created using
+    C{Forward}.
+    """
+    def __init__( self, other=None ):
+        super(Forward,self).__init__( other, savelist=False )
+
+    def __lshift__( self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass(other)
+        self.expr = other
+        self.strRepr = None
+        self.mayIndexError = self.expr.mayIndexError
+        self.mayReturnEmpty = self.expr.mayReturnEmpty
+        self.setWhitespaceChars( self.expr.whiteChars )
+        self.skipWhitespace = self.expr.skipWhitespace
+        self.saveAsList = self.expr.saveAsList
+        self.ignoreExprs.extend(self.expr.ignoreExprs)
+        return self
+        
+    def __ilshift__(self, other):
+        return self << other
+    
+    def leaveWhitespace( self ):
+        self.skipWhitespace = False
+        return self
+
+    def streamline( self ):
+        if not self.streamlined:
+            self.streamlined = True
+            if self.expr is not None:
+                self.expr.streamline()
+        return self
+
+    def validate( self, validateTrace=[] ):
+        if self not in validateTrace:
+            tmp = validateTrace[:]+[self]
+            if self.expr is not None:
+                self.expr.validate(tmp)
+        self.checkRecursion([])
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+        return self.__class__.__name__ + ": ..."
+
+        # stubbed out for now - creates awful memory and perf issues
+        self._revertClass = self.__class__
+        self.__class__ = _ForwardNoRecurse
+        try:
+            if self.expr is not None:
+                retString = _ustr(self.expr)
+            else:
+                retString = "None"
+        finally:
+            self.__class__ = self._revertClass
+        return self.__class__.__name__ + ": " + retString
+
+    def copy(self):
+        if self.expr is not None:
+            return super(Forward,self).copy()
+        else:
+            ret = Forward()
+            ret <<= self
+            return ret
+
+class _ForwardNoRecurse(Forward):
+    def __str__( self ):
+        return "..."
+
+class TokenConverter(ParseElementEnhance):
+    """
+    Abstract subclass of C{ParseExpression}, for converting parsed results.
+    """
+    def __init__( self, expr, savelist=False ):
+        super(TokenConverter,self).__init__( expr )#, savelist )
+        self.saveAsList = False
+
+class Combine(TokenConverter):
+    """
+    Converter to concatenate all matching tokens to a single string.
+    By default, the matching patterns must also be contiguous in the input string;
+    this can be disabled by specifying C{'adjacent=False'} in the constructor.
+
+    Example::
+        real = Word(nums) + '.' + Word(nums)
+        print(real.parseString('3.1416')) # -> ['3', '.', '1416']
+        # will also erroneously match the following
+        print(real.parseString('3. 1416')) # -> ['3', '.', '1416']
+
+        real = Combine(Word(nums) + '.' + Word(nums))
+        print(real.parseString('3.1416')) # -> ['3.1416']
+        # no match when there are internal spaces
+        print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...)
+    """
+    def __init__( self, expr, joinString="", adjacent=True ):
+        super(Combine,self).__init__( expr )
+        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself
+        if adjacent:
+            self.leaveWhitespace()
+        self.adjacent = adjacent
+        self.skipWhitespace = True
+        self.joinString = joinString
+        self.callPreparse = True
+
+    def ignore( self, other ):
+        if self.adjacent:
+            ParserElement.ignore(self, other)
+        else:
+            super( Combine, self).ignore( other )
+        return self
+
+    def postParse( self, instring, loc, tokenlist ):
+        retToks = tokenlist.copy()
+        del retToks[:]
+        retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults)
+
+        if self.resultsName and retToks.haskeys():
+            return [ retToks ]
+        else:
+            return retToks
+
+class Group(TokenConverter):
+    """
+    Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions.
+
+    Example::
+        ident = Word(alphas)
+        num = Word(nums)
+        term = ident | num
+        func = ident + Optional(delimitedList(term))
+        print(func.parseString("fn a,b,100"))  # -> ['fn', 'a', 'b', '100']
+
+        func = ident + Group(Optional(delimitedList(term)))
+        print(func.parseString("fn a,b,100"))  # -> ['fn', ['a', 'b', '100']]
+    """
+    def __init__( self, expr ):
+        super(Group,self).__init__( expr )
+        self.saveAsList = True
+
+    def postParse( self, instring, loc, tokenlist ):
+        return [ tokenlist ]
+
+class Dict(TokenConverter):
+    """
+    Converter to return a repetitive expression as a list, but also as a dictionary.
+    Each element can also be referenced using the first token in the expression as its key.
+    Useful for tabular report scraping when the first column can be used as a item key.
+
+    Example::
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
+
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        
+        # print attributes as plain groups
+        print(OneOrMore(attr_expr).parseString(text).dump())
+        
+        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names
+        result = Dict(OneOrMore(Group(attr_expr))).parseString(text)
+        print(result.dump())
+        
+        # access named fields as dict entries, or output as dict
+        print(result['shape'])        
+        print(result.asDict())
+    prints::
+        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']
+
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
+        - color: light blue
+        - posn: upper left
+        - shape: SQUARE
+        - texture: burlap
+        SQUARE
+        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}
+    See more examples at L{ParseResults} of accessing fields by results name.
+    """
+    def __init__( self, expr ):
+        super(Dict,self).__init__( expr )
+        self.saveAsList = True
+
+    def postParse( self, instring, loc, tokenlist ):
+        for i,tok in enumerate(tokenlist):
+            if len(tok) == 0:
+                continue
+            ikey = tok[0]
+            if isinstance(ikey,int):
+                ikey = _ustr(tok[0]).strip()
+            if len(tok)==1:
+                tokenlist[ikey] = _ParseResultsWithOffset("",i)
+            elif len(tok)==2 and not isinstance(tok[1],ParseResults):
+                tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i)
+            else:
+                dictvalue = tok.copy() #ParseResults(i)
+                del dictvalue[0]
+                if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.haskeys()):
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i)
+                else:
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i)
+
+        if self.resultsName:
+            return [ tokenlist ]
+        else:
+            return tokenlist
+
+
+class Suppress(TokenConverter):
+    """
+    Converter for ignoring the results of a parsed expression.
+
+    Example::
+        source = "a, b, c,d"
+        wd = Word(alphas)
+        wd_list1 = wd + ZeroOrMore(',' + wd)
+        print(wd_list1.parseString(source))
+
+        # often, delimiters that are useful during parsing are just in the
+        # way afterward - use Suppress to keep them out of the parsed output
+        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd)
+        print(wd_list2.parseString(source))
+    prints::
+        ['a', ',', 'b', ',', 'c', ',', 'd']
+        ['a', 'b', 'c', 'd']
+    (See also L{delimitedList}.)
+    """
+    def postParse( self, instring, loc, tokenlist ):
+        return []
+
+    def suppress( self ):
+        return self
+
+
+class OnlyOnce(object):
+    """
+    Wrapper for parse actions, to ensure they are only called once.
+    """
+    def __init__(self, methodCall):
+        self.callable = _trim_arity(methodCall)
+        self.called = False
+    def __call__(self,s,l,t):
+        if not self.called:
+            results = self.callable(s,l,t)
+            self.called = True
+            return results
+        raise ParseException(s,l,"")
+    def reset(self):
+        self.called = False
+
+def traceParseAction(f):
+    """
+    Decorator for debugging parse actions. 
+    
+    When the parse action is called, this decorator will print C{">> entering I{method-name}(line:I{current_source_line}, I{parse_location}, I{matched_tokens})".}
+    When the parse action completes, the decorator will print C{"<<"} followed by the returned value, or any exception that the parse action raised.
+
+    Example::
+        wd = Word(alphas)
+
+        @traceParseAction
+        def remove_duplicate_chars(tokens):
+            return ''.join(sorted(set(''.join(tokens))))
+
+        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
+        print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
+    prints::
+        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))
+        <<leaving remove_duplicate_chars (ret: 'dfjkls')
+        ['dfjkls']
+    """
+    f = _trim_arity(f)
+    def z(*paArgs):
+        thisFunc = f.__name__
+        s,l,t = paArgs[-3:]
+        if len(paArgs)>3:
+            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc
+        sys.stderr.write( ">>entering %s(line: '%s', %d, %r)\n" % (thisFunc,line(l,s),l,t) )
+        try:
+            ret = f(*paArgs)
+        except Exception as exc:
+            sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) )
+            raise
+        sys.stderr.write( "<<leaving %s (ret: %r)\n" % (thisFunc,ret) )
+        return ret
+    try:
+        z.__name__ = f.__name__
+    except AttributeError:
+        pass
+    return z
+
+#
+# global helpers
+#
+def delimitedList( expr, delim=",", combine=False ):
+    """
+    Helper to define a delimited list of expressions - the delimiter defaults to ','.
+    By default, the list elements and delimiters can have intervening whitespace, and
+    comments, but this can be overridden by passing C{combine=True} in the constructor.
+    If C{combine} is set to C{True}, the matching tokens are returned as a single token
+    string, with the delimiters included; otherwise, the matching tokens are returned
+    as a list of tokens, with the delimiters suppressed.
+
+    Example::
+        delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc']
+        delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
+    """
+    dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..."
+    if combine:
+        return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName)
+    else:
+        return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName)
+
+def countedArray( expr, intExpr=None ):
+    """
+    Helper to define a counted list of expressions.
+    This helper defines a pattern of the form::
+        integer expr expr expr...
+    where the leading integer tells how many expr expressions follow.
+    The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.
+    
+    If C{intExpr} is specified, it should be a pyparsing expression that produces an integer value.
+
+    Example::
+        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -> ['ab', 'cd']
+
+        # in this parser, the leading integer value is given in binary,
+        # '10' indicating that 2 values are in the array
+        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2))
+        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -> ['ab', 'cd']
+    """
+    arrayExpr = Forward()
+    def countFieldParseAction(s,l,t):
+        n = t[0]
+        arrayExpr << (n and Group(And([expr]*n)) or Group(empty))
+        return []
+    if intExpr is None:
+        intExpr = Word(nums).setParseAction(lambda t:int(t[0]))
+    else:
+        intExpr = intExpr.copy()
+    intExpr.setName("arrayLen")
+    intExpr.addParseAction(countFieldParseAction, callDuringTry=True)
+    return ( intExpr + arrayExpr ).setName('(len) ' + _ustr(expr) + '...')
+
+def _flatten(L):
+    ret = []
+    for i in L:
+        if isinstance(i,list):
+            ret.extend(_flatten(i))
+        else:
+            ret.append(i)
+    return ret
+
+def matchPreviousLiteral(expr):
+    """
+    Helper to define an expression that is indirectly defined from
+    the tokens matched in a previous expression, that is, it looks
+    for a 'repeat' of a previous expression.  For example::
+        first = Word(nums)
+        second = matchPreviousLiteral(first)
+        matchExpr = first + ":" + second
+    will match C{"1:1"}, but not C{"1:2"}.  Because this matches a
+    previous literal, will also match the leading C{"1:1"} in C{"1:10"}.
+    If this is not desired, use C{matchPreviousExpr}.
+    Do I{not} use with packrat parsing enabled.
+    """
+    rep = Forward()
+    def copyTokenToRepeater(s,l,t):
+        if t:
+            if len(t) == 1:
+                rep << t[0]
+            else:
+                # flatten t tokens
+                tflat = _flatten(t.asList())
+                rep << And(Literal(tt) for tt in tflat)
+        else:
+            rep << Empty()
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
+    rep.setName('(prev) ' + _ustr(expr))
+    return rep
+
+def matchPreviousExpr(expr):
+    """
+    Helper to define an expression that is indirectly defined from
+    the tokens matched in a previous expression, that is, it looks
+    for a 'repeat' of a previous expression.  For example::
+        first = Word(nums)
+        second = matchPreviousExpr(first)
+        matchExpr = first + ":" + second
+    will match C{"1:1"}, but not C{"1:2"}.  Because this matches by
+    expressions, will I{not} match the leading C{"1:1"} in C{"1:10"};
+    the expressions are evaluated first, and then compared, so
+    C{"1"} is compared with C{"10"}.
+    Do I{not} use with packrat parsing enabled.
+    """
+    rep = Forward()
+    e2 = expr.copy()
+    rep <<= e2
+    def copyTokenToRepeater(s,l,t):
+        matchTokens = _flatten(t.asList())
+        def mustMatchTheseTokens(s,l,t):
+            theseTokens = _flatten(t.asList())
+            if  theseTokens != matchTokens:
+                raise ParseException("",0,"")
+        rep.setParseAction( mustMatchTheseTokens, callDuringTry=True )
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
+    rep.setName('(prev) ' + _ustr(expr))
+    return rep
+
+def _escapeRegexRangeChars(s):
+    #~  escape these chars: ^-]
+    for c in r"\^-]":
+        s = s.replace(c,_bslash+c)
+    s = s.replace("\n",r"\n")
+    s = s.replace("\t",r"\t")
+    return _ustr(s)
+
+def oneOf( strs, caseless=False, useRegex=True ):
+    """
+    Helper to quickly define a set of alternative Literals, and makes sure to do
+    longest-first testing when there is a conflict, regardless of the input order,
+    but returns a C{L{MatchFirst}} for best performance.
+
+    Parameters:
+     - strs - a string of space-delimited literals, or a collection of string literals
+     - caseless - (default=C{False}) - treat all literals as caseless
+     - useRegex - (default=C{True}) - as an optimization, will generate a Regex
+          object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or
+          if creating a C{Regex} raises an exception)
+
+    Example::
+        comp_oper = oneOf("< = > <= >= !=")
+        var = Word(alphas)
+        number = Word(nums)
+        term = var | number
+        comparison_expr = term + comp_oper + term
+        print(comparison_expr.searchString("B = 12  AA=23 B<=AA AA>12"))
+    prints::
+        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
+    """
+    if caseless:
+        isequal = ( lambda a,b: a.upper() == b.upper() )
+        masks = ( lambda a,b: b.upper().startswith(a.upper()) )
+        parseElementClass = CaselessLiteral
+    else:
+        isequal = ( lambda a,b: a == b )
+        masks = ( lambda a,b: b.startswith(a) )
+        parseElementClass = Literal
+
+    symbols = []
+    if isinstance(strs,basestring):
+        symbols = strs.split()
+    elif isinstance(strs, Iterable):
+        symbols = list(strs)
+    else:
+        warnings.warn("Invalid argument to oneOf, expected string or iterable",
+                SyntaxWarning, stacklevel=2)
+    if not symbols:
+        return NoMatch()
+
+    i = 0
+    while i < len(symbols)-1:
+        cur = symbols[i]
+        for j,other in enumerate(symbols[i+1:]):
+            if ( isequal(other, cur) ):
+                del symbols[i+j+1]
+                break
+            elif ( masks(cur, other) ):
+                del symbols[i+j+1]
+                symbols.insert(i,other)
+                cur = other
+                break
+        else:
+            i += 1
+
+    if not caseless and useRegex:
+        #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] ))
+        try:
+            if len(symbols)==len("".join(symbols)):
+                return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) ).setName(' | '.join(symbols))
+            else:
+                return Regex( "|".join(re.escape(sym) for sym in symbols) ).setName(' | '.join(symbols))
+        except Exception:
+            warnings.warn("Exception creating Regex for oneOf, building MatchFirst",
+                    SyntaxWarning, stacklevel=2)
+
+
+    # last resort, just use MatchFirst
+    return MatchFirst(parseElementClass(sym) for sym in symbols).setName(' | '.join(symbols))
+
+def dictOf( key, value ):
+    """
+    Helper to easily and clearly define a dictionary by specifying the respective patterns
+    for the key and value.  Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens
+    in the proper order.  The key pattern can include delimiting markers or punctuation,
+    as long as they are suppressed, thereby leaving the significant key text.  The value
+    pattern can include named results, so that the C{Dict} results can include named token
+    fields.
+
+    Example::
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        print(OneOrMore(attr_expr).parseString(text).dump())
+        
+        attr_label = label
+        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)
+
+        # similar to Dict, but simpler call format
+        result = dictOf(attr_label, attr_value).parseString(text)
+        print(result.dump())
+        print(result['shape'])
+        print(result.shape)  # object attribute access works too
+        print(result.asDict())
+    prints::
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
+        - color: light blue
+        - posn: upper left
+        - shape: SQUARE
+        - texture: burlap
+        SQUARE
+        SQUARE
+        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
+    """
+    return Dict( ZeroOrMore( Group ( key + value ) ) )
+
+def originalTextFor(expr, asString=True):
+    """
+    Helper to return the original, untokenized text for a given expression.  Useful to
+    restore the parsed fields of an HTML start tag into the raw tag text itself, or to
+    revert separate tokens with intervening whitespace back to the original matching
+    input text. By default, returns astring containing the original parsed text.  
+       
+    If the optional C{asString} argument is passed as C{False}, then the return value is a 
+    C{L{ParseResults}} containing any results names that were originally matched, and a 
+    single token containing the original matched text from the input string.  So if 
+    the expression passed to C{L{originalTextFor}} contains expressions with defined
+    results names, you must set C{asString} to C{False} if you want to preserve those
+    results name values.
+
+    Example::
+        src = "this is test <b> bold <i>text</i> </b> normal text "
+        for tag in ("b","i"):
+            opener,closer = makeHTMLTags(tag)
+            patt = originalTextFor(opener + SkipTo(closer) + closer)
+            print(patt.searchString(src)[0])
+    prints::
+        ['<b> bold <i>text</i> </b>']
+        ['<i>text</i>']
+    """
+    locMarker = Empty().setParseAction(lambda s,loc,t: loc)
+    endlocMarker = locMarker.copy()
+    endlocMarker.callPreparse = False
+    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")
+    if asString:
+        extractText = lambda s,l,t: s[t._original_start:t._original_end]
+    else:
+        def extractText(s,l,t):
+            t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]]
+    matchExpr.setParseAction(extractText)
+    matchExpr.ignoreExprs = expr.ignoreExprs
+    return matchExpr
+
+def ungroup(expr): 
+    """
+    Helper to undo pyparsing's default grouping of And expressions, even
+    if all but one are non-empty.
+    """
+    return TokenConverter(expr).setParseAction(lambda t:t[0])
+
+def locatedExpr(expr):
+    """
+    Helper to decorate a returned token with its starting and ending locations in the input string.
+    This helper adds the following results names:
+     - locn_start = location where matched expression begins
+     - locn_end = location where matched expression ends
+     - value = the actual parsed results
+
+    Be careful if the input text contains C{<TAB>} characters, you may want to call
+    C{L{ParserElement.parseWithTabs}}
+
+    Example::
+        wd = Word(alphas)
+        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
+            print(match)
+    prints::
+        [[0, 'ljsdf', 5]]
+        [[8, 'lksdjjf', 15]]
+        [[18, 'lkkjj', 23]]
+    """
+    locator = Empty().setParseAction(lambda s,l,t: l)
+    return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end"))
+
+
+# convenience constants for positional expressions
+empty       = Empty().setName("empty")
+lineStart   = LineStart().setName("lineStart")
+lineEnd     = LineEnd().setName("lineEnd")
+stringStart = StringStart().setName("stringStart")
+stringEnd   = StringEnd().setName("stringEnd")
+
+_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])
+_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))
+_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))
+_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1)
+_charRange = Group(_singleChar + Suppress("-") + _singleChar)
+_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"
+
+def srange(s):
+    r"""
+    Helper to easily define string ranges for use in Word construction.  Borrows
+    syntax from regexp '[]' string range definitions::
+        srange("[0-9]")   -> "0123456789"
+        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz"
+        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"
+    The input string must be enclosed in []'s, and the returned string is the expanded
+    character set joined into a single string.
+    The values enclosed in the []'s may be:
+     - a single character
+     - an escaped character with a leading backslash (such as C{\-} or C{\]})
+     - an escaped hex character with a leading C{'\x'} (C{\x21}, which is a C{'!'} character) 
+         (C{\0x##} is also supported for backwards compatibility) 
+     - an escaped octal character with a leading C{'\0'} (C{\041}, which is a C{'!'} character)
+     - a range of any of the above, separated by a dash (C{'a-z'}, etc.)
+     - any combination of the above (C{'aeiouy'}, C{'a-zA-Z0-9_$'}, etc.)
+    """
+    _expanded = lambda p: p if not isinstance(p,ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]),ord(p[1])+1))
+    try:
+        return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body)
+    except Exception:
+        return ""
+
+def matchOnlyAtCol(n):
+    """
+    Helper method for defining parse actions that require matching at a specific
+    column in the input text.
+    """
+    def verifyCol(strg,locn,toks):
+        if col(locn,strg) != n:
+            raise ParseException(strg,locn,"matched token not at column %d" % n)
+    return verifyCol
+
+def replaceWith(replStr):
+    """
+    Helper method for common parse actions that simply return a literal value.  Especially
+    useful when used with C{L{transformString<ParserElement.transformString>}()}.
+
+    Example::
+        num = Word(nums).setParseAction(lambda toks: int(toks[0]))
+        na = oneOf("N/A NA").setParseAction(replaceWith(math.nan))
+        term = na | num
+        
+        OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234]
+    """
+    return lambda s,l,t: [replStr]
+
+def removeQuotes(s,l,t):
+    """
+    Helper parse action for removing quotation marks from parsed quoted strings.
+
+    Example::
+        # by default, quotation marks are included in parsed results
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"]
+
+        # use removeQuotes to strip quotation marks from parsed results
+        quotedString.setParseAction(removeQuotes)
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"]
+    """
+    return t[0][1:-1]
+
+def tokenMap(func, *args):
+    """
+    Helper to define a parse action by mapping a function to all elements of a ParseResults list.If any additional 
+    args are passed, they are forwarded to the given function as additional arguments after
+    the token, as in C{hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))}, which will convert the
+    parsed data to an integer using base 16.
+
+    Example (compare the last to example in L{ParserElement.transformString}::
+        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16))
+        hex_ints.runTests('''
+            00 11 22 aa FF 0a 0d 1a
+            ''')
+        
+        upperword = Word(alphas).setParseAction(tokenMap(str.upper))
+        OneOrMore(upperword).runTests('''
+            my kingdom for a horse
+            ''')
+
+        wd = Word(alphas).setParseAction(tokenMap(str.title))
+        OneOrMore(wd).setParseAction(' '.join).runTests('''
+            now is the winter of our discontent made glorious summer by this sun of york
+            ''')
+    prints::
+        00 11 22 aa FF 0a 0d 1a
+        [0, 17, 34, 170, 255, 10, 13, 26]
+
+        my kingdom for a horse
+        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE']
+
+        now is the winter of our discontent made glorious summer by this sun of york
+        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York']
+    """
+    def pa(s,l,t):
+        return [func(tokn, *args) for tokn in t]
+
+    try:
+        func_name = getattr(func, '__name__', 
+                            getattr(func, '__class__').__name__)
+    except Exception:
+        func_name = str(func)
+    pa.__name__ = func_name
+
+    return pa
+
+upcaseTokens = tokenMap(lambda t: _ustr(t).upper())
+"""(Deprecated) Helper parse action to convert tokens to upper case. Deprecated in favor of L{pyparsing_common.upcaseTokens}"""
+
+downcaseTokens = tokenMap(lambda t: _ustr(t).lower())
+"""(Deprecated) Helper parse action to convert tokens to lower case. Deprecated in favor of L{pyparsing_common.downcaseTokens}"""
+    
+def _makeTags(tagStr, xml):
+    """Internal helper to construct opening and closing tag expressions, given a tag name"""
+    if isinstance(tagStr,basestring):
+        resname = tagStr
+        tagStr = Keyword(tagStr, caseless=not xml)
+    else:
+        resname = tagStr.name
+
+    tagAttrName = Word(alphas,alphanums+"_-:")
+    if (xml):
+        tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )
+        openTag = Suppress("<") + tagStr("tag") + \
+                Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \
+                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
+    else:
+        printablesLessRAbrack = "".join(c for c in printables if c not in ">")
+        tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)
+        openTag = Suppress("<") + tagStr("tag") + \
+                Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \
+                Optional( Suppress("=") + tagAttrValue ) ))) + \
+                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
+    closeTag = Combine(_L("</") + tagStr + ">")
+
+    openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % resname)
+    closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("</%s>" % resname)
+    openTag.tag = resname
+    closeTag.tag = resname
+    return openTag, closeTag
+
+def makeHTMLTags(tagStr):
+    """
+    Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches
+    tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values.
+
+    Example::
+        text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'
+        # makeHTMLTags returns pyparsing expressions for the opening and closing tags as a 2-tuple
+        a,a_end = makeHTMLTags("A")
+        link_expr = a + SkipTo(a_end)("link_text") + a_end
+        
+        for link in link_expr.searchString(text):
+            # attributes in the <A> tag (like "href" shown here) are also accessible as named results
+            print(link.link_text, '->', link.href)
+    prints::
+        pyparsing -> http://pyparsing.wikispaces.com
+    """
+    return _makeTags( tagStr, False )
+
+def makeXMLTags(tagStr):
+    """
+    Helper to construct opening and closing tag expressions for XML, given a tag name. Matches
+    tags only in the given upper/lower case.
+
+    Example: similar to L{makeHTMLTags}
+    """
+    return _makeTags( tagStr, True )
+
+def withAttribute(*args,**attrDict):
+    """
+    Helper to create a validating parse action to be used with start tags created
+    with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag
+    with a required attribute value, to avoid false matches on common tags such as
+    C{<TD>} or C{<DIV>}.
+
+    Call C{withAttribute} with a series of attribute names and values. Specify the list
+    of filter attributes names and values as:
+     - keyword arguments, as in C{(align="right")}, or
+     - as an explicit dict with C{**} operator, when an attribute name is also a Python
+          reserved word, as in C{**{"class":"Customer", "align":"right"}}
+     - a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") )
+    For attribute names with a namespace prefix, you must use the second form.  Attribute
+    names are matched insensitive to upper/lower case.
+       
+    If just testing for C{class} (with or without a namespace), use C{L{withClass}}.
+
+    To verify that the attribute exists, but without specifying a value, pass
+    C{withAttribute.ANY_VALUE} as the value.
+
+    Example::
+        html = '''
+            <div>
+            Some text
+            <div type="grid">1 4 0 1 0</div>
+            <div type="graph">1,3 2,3 1,1</div>
+            <div>this has no type</div>
+            </div>
+                
+        '''
+        div,div_end = makeHTMLTags("div")
+
+        # only match div tag having a type attribute with value "grid"
+        div_grid = div().setParseAction(withAttribute(type="grid"))
+        grid_expr = div_grid + SkipTo(div | div_end)("body")
+        for grid_header in grid_expr.searchString(html):
+            print(grid_header.body)
+        
+        # construct a match with any div tag having a type attribute, regardless of the value
+        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE))
+        div_expr = div_any_type + SkipTo(div | div_end)("body")
+        for div_header in div_expr.searchString(html):
+            print(div_header.body)
+    prints::
+        1 4 0 1 0
+
+        1 4 0 1 0
+        1,3 2,3 1,1
+    """
+    if args:
+        attrs = args[:]
+    else:
+        attrs = attrDict.items()
+    attrs = [(k,v) for k,v in attrs]
+    def pa(s,l,tokens):
+        for attrName,attrValue in attrs:
+            if attrName not in tokens:
+                raise ParseException(s,l,"no matching attribute " + attrName)
+            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:
+                raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" %
+                                            (attrName, tokens[attrName], attrValue))
+    return pa
+withAttribute.ANY_VALUE = object()
+
+def withClass(classname, namespace=''):
+    """
+    Simplified version of C{L{withAttribute}} when matching on a div class - made
+    difficult because C{class} is a reserved word in Python.
+
+    Example::
+        html = '''
+            <div>
+            Some text
+            <div class="grid">1 4 0 1 0</div>
+            <div class="graph">1,3 2,3 1,1</div>
+            <div>this &lt;div&gt; has no class</div>
+            </div>
+                
+        '''
+        div,div_end = makeHTMLTags("div")
+        div_grid = div().setParseAction(withClass("grid"))
+        
+        grid_expr = div_grid + SkipTo(div | div_end)("body")
+        for grid_header in grid_expr.searchString(html):
+            print(grid_header.body)
+        
+        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE))
+        div_expr = div_any_type + SkipTo(div | div_end)("body")
+        for div_header in div_expr.searchString(html):
+            print(div_header.body)
+    prints::
+        1 4 0 1 0
+
+        1 4 0 1 0
+        1,3 2,3 1,1
+    """
+    classattr = "%s:class" % namespace if namespace else "class"
+    return withAttribute(**{classattr : classname})        
+
+opAssoc = _Constants()
+opAssoc.LEFT = object()
+opAssoc.RIGHT = object()
+
+def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ):
+    """
+    Helper method for constructing grammars of expressions made up of
+    operators working in a precedence hierarchy.  Operators may be unary or
+    binary, left- or right-associative.  Parse actions can also be attached
+    to operator expressions. The generated parser will also recognize the use 
+    of parentheses to override operator precedences (see example below).
+    
+    Note: if you define a deep operator list, you may see performance issues
+    when using infixNotation. See L{ParserElement.enablePackrat} for a
+    mechanism to potentially improve your parser performance.
+
+    Parameters:
+     - baseExpr - expression representing the most basic element for the nested
+     - opList - list of tuples, one for each operator precedence level in the
+      expression grammar; each tuple is of the form
+      (opExpr, numTerms, rightLeftAssoc, parseAction), where:
+       - opExpr is the pyparsing expression for the operator;
+          may also be a string, which will be converted to a Literal;
+          if numTerms is 3, opExpr is a tuple of two expressions, for the
+          two operators separating the 3 terms
+       - numTerms is the number of terms for this operator (must
+          be 1, 2, or 3)
+       - rightLeftAssoc is the indicator whether the operator is
+          right or left associative, using the pyparsing-defined
+          constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}.
+       - parseAction is the parse action to be associated with
+          expressions matching this operator expression (the
+          parse action tuple member may be omitted); if the parse action
+          is passed a tuple or list of functions, this is equivalent to
+          calling C{setParseAction(*fn)} (L{ParserElement.setParseAction})
+     - lpar - expression for matching left-parentheses (default=C{Suppress('(')})
+     - rpar - expression for matching right-parentheses (default=C{Suppress(')')})
+
+    Example::
+        # simple example of four-function arithmetic with ints and variable names
+        integer = pyparsing_common.signed_integer
+        varname = pyparsing_common.identifier 
+        
+        arith_expr = infixNotation(integer | varname,
+            [
+            ('-', 1, opAssoc.RIGHT),
+            (oneOf('* /'), 2, opAssoc.LEFT),
+            (oneOf('+ -'), 2, opAssoc.LEFT),
+            ])
+        
+        arith_expr.runTests('''
+            5+3*6
+            (5+3)*6
+            -2--11
+            ''', fullDump=False)
+    prints::
+        5+3*6
+        [[5, '+', [3, '*', 6]]]
+
+        (5+3)*6
+        [[[5, '+', 3], '*', 6]]
+
+        -2--11
+        [[['-', 2], '-', ['-', 11]]]
+    """
+    ret = Forward()
+    lastExpr = baseExpr | ( lpar + ret + rpar )
+    for i,operDef in enumerate(opList):
+        opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]
+        termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr
+        if arity == 3:
+            if opExpr is None or len(opExpr) != 2:
+                raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions")
+            opExpr1, opExpr2 = opExpr
+        thisExpr = Forward().setName(termName)
+        if rightLeftAssoc == opAssoc.LEFT:
+            if arity == 1:
+                matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) )
+            elif arity == 2:
+                if opExpr is not None:
+                    matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) )
+                else:
+                    matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) )
+            elif arity == 3:
+                matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \
+                            Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr )
+            else:
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
+        elif rightLeftAssoc == opAssoc.RIGHT:
+            if arity == 1:
+                # try to avoid LR with this extra test
+                if not isinstance(opExpr, Optional):
+                    opExpr = Optional(opExpr)
+                matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr )
+            elif arity == 2:
+                if opExpr is not None:
+                    matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) )
+                else:
+                    matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) )
+            elif arity == 3:
+                matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \
+                            Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr )
+            else:
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
+        else:
+            raise ValueError("operator must indicate right or left associativity")
+        if pa:
+            if isinstance(pa, (tuple, list)):
+                matchExpr.setParseAction(*pa)
+            else:
+                matchExpr.setParseAction(pa)
+        thisExpr <<= ( matchExpr.setName(termName) | lastExpr )
+        lastExpr = thisExpr
+    ret <<= lastExpr
+    return ret
+
+operatorPrecedence = infixNotation
+"""(Deprecated) Former name of C{L{infixNotation}}, will be dropped in a future release."""
+
+dblQuotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"').setName("string enclosed in double quotes")
+sglQuotedString = Combine(Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("string enclosed in single quotes")
+quotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"'|
+                       Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("quotedString using single or double quotes")
+unicodeString = Combine(_L('u') + quotedString.copy()).setName("unicode string literal")
+
+def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()):
+    """
+    Helper method for defining nested lists enclosed in opening and closing
+    delimiters ("(" and ")" are the default).
+
+    Parameters:
+     - opener - opening character for a nested list (default=C{"("}); can also be a pyparsing expression
+     - closer - closing character for a nested list (default=C{")"}); can also be a pyparsing expression
+     - content - expression for items within the nested lists (default=C{None})
+     - ignoreExpr - expression for ignoring opening and closing delimiters (default=C{quotedString})
+
+    If an expression is not provided for the content argument, the nested
+    expression will capture all whitespace-delimited content between delimiters
+    as a list of separate values.
+
+    Use the C{ignoreExpr} argument to define expressions that may contain
+    opening or closing characters that should not be treated as opening
+    or closing characters for nesting, such as quotedString or a comment
+    expression.  Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}.
+    The default is L{quotedString}, but if no expressions are to be ignored,
+    then pass C{None} for this argument.
+
+    Example::
+        data_type = oneOf("void int short long char float double")
+        decl_data_type = Combine(data_type + Optional(Word('*')))
+        ident = Word(alphas+'_', alphanums+'_')
+        number = pyparsing_common.number
+        arg = Group(decl_data_type + ident)
+        LPAR,RPAR = map(Suppress, "()")
+
+        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment))
+
+        c_function = (decl_data_type("type") 
+                      + ident("name")
+                      + LPAR + Optional(delimitedList(arg), [])("args") + RPAR 
+                      + code_body("body"))
+        c_function.ignore(cStyleComment)
+        
+        source_code = '''
+            int is_odd(int x) { 
+                return (x%2); 
+            }
+                
+            int dec_to_hex(char hchar) { 
+                if (hchar >= '0' && hchar <= '9') { 
+                    return (ord(hchar)-ord('0')); 
+                } else { 
+                    return (10+ord(hchar)-ord('A'));
+                } 
+            }
+        '''
+        for func in c_function.searchString(source_code):
+            print("%(name)s (%(type)s) args: %(args)s" % func)
+
+    prints::
+        is_odd (int) args: [['int', 'x']]
+        dec_to_hex (int) args: [['char', 'hchar']]
+    """
+    if opener == closer:
+        raise ValueError("opening and closing strings cannot be the same")
+    if content is None:
+        if isinstance(opener,basestring) and isinstance(closer,basestring):
+            if len(opener) == 1 and len(closer)==1:
+                if ignoreExpr is not None:
+                    content = (Combine(OneOrMore(~ignoreExpr +
+                                    CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1))
+                                ).setParseAction(lambda t:t[0].strip()))
+                else:
+                    content = (empty.copy()+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS
+                                ).setParseAction(lambda t:t[0].strip()))
+            else:
+                if ignoreExpr is not None:
+                    content = (Combine(OneOrMore(~ignoreExpr + 
+                                    ~Literal(opener) + ~Literal(closer) +
+                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
+                                ).setParseAction(lambda t:t[0].strip()))
+                else:
+                    content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) +
+                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
+                                ).setParseAction(lambda t:t[0].strip()))
+        else:
+            raise ValueError("opening and closing arguments must be strings if no content expression is given")
+    ret = Forward()
+    if ignoreExpr is not None:
+        ret <<= Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) )
+    else:
+        ret <<= Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) )
+    ret.setName('nested %s%s expression' % (opener,closer))
+    return ret
+
+def indentedBlock(blockStatementExpr, indentStack, indent=True):
+    """
+    Helper method for defining space-delimited indentation blocks, such as
+    those used to define block statements in Python source code.
+
+    Parameters:
+     - blockStatementExpr - expression defining syntax of statement that
+            is repeated within the indented block
+     - indentStack - list created by caller to manage indentation stack
+            (multiple statementWithIndentedBlock expressions within a single grammar
+            should share a common indentStack)
+     - indent - boolean indicating whether block must be indented beyond the
+            the current level; set to False for block of left-most statements
+            (default=C{True})
+
+    A valid block must contain at least one C{blockStatement}.
+
+    Example::
+        data = '''
+        def A(z):
+          A1
+          B = 100
+          G = A2
+          A2
+          A3
+        B
+        def BB(a,b,c):
+          BB1
+          def BBA():
+            bba1
+            bba2
+            bba3
+        C
+        D
+        def spam(x,y):
+             def eggs(z):
+                 pass
+        '''
+
+
+        indentStack = [1]
+        stmt = Forward()
+
+        identifier = Word(alphas, alphanums)
+        funcDecl = ("def" + identifier + Group( "(" + Optional( delimitedList(identifier) ) + ")" ) + ":")
+        func_body = indentedBlock(stmt, indentStack)
+        funcDef = Group( funcDecl + func_body )
+
+        rvalue = Forward()
+        funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")")
+        rvalue << (funcCall | identifier | Word(nums))
+        assignment = Group(identifier + "=" + rvalue)
+        stmt << ( funcDef | assignment | identifier )
+
+        module_body = OneOrMore(stmt)
+
+        parseTree = module_body.parseString(data)
+        parseTree.pprint()
+    prints::
+        [['def',
+          'A',
+          ['(', 'z', ')'],
+          ':',
+          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],
+         'B',
+         ['def',
+          'BB',
+          ['(', 'a', 'b', 'c', ')'],
+          ':',
+          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],
+         'C',
+         'D',
+         ['def',
+          'spam',
+          ['(', 'x', 'y', ')'],
+          ':',
+          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]] 
+    """
+    def checkPeerIndent(s,l,t):
+        if l >= len(s): return
+        curCol = col(l,s)
+        if curCol != indentStack[-1]:
+            if curCol > indentStack[-1]:
+                raise ParseFatalException(s,l,"illegal nesting")
+            raise ParseException(s,l,"not a peer entry")
+
+    def checkSubIndent(s,l,t):
+        curCol = col(l,s)
+        if curCol > indentStack[-1]:
+            indentStack.append( curCol )
+        else:
+            raise ParseException(s,l,"not a subentry")
+
+    def checkUnindent(s,l,t):
+        if l >= len(s): return
+        curCol = col(l,s)
+        if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]):
+            raise ParseException(s,l,"not an unindent")
+        indentStack.pop()
+
+    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress())
+    INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName('INDENT')
+    PEER   = Empty().setParseAction(checkPeerIndent).setName('')
+    UNDENT = Empty().setParseAction(checkUnindent).setName('UNINDENT')
+    if indent:
+        smExpr = Group( Optional(NL) +
+            #~ FollowedBy(blockStatementExpr) +
+            INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT)
+    else:
+        smExpr = Group( Optional(NL) +
+            (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) )
+    blockStatementExpr.ignore(_bslash + LineEnd())
+    return smExpr.setName('indented block')
+
+alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")
+punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")
+
+anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:").setName('any tag'))
+_htmlEntityMap = dict(zip("gt lt amp nbsp quot apos".split(),'><& "\''))
+commonHTMLEntity = Regex('&(?P<entity>' + '|'.join(_htmlEntityMap.keys()) +");").setName("common HTML entity")
+def replaceHTMLEntity(t):
+    """Helper parser action to replace common HTML entities with their special characters"""
+    return _htmlEntityMap.get(t.entity)
+
+# it's easy to get these comment structures wrong - they're very common, so may as well make them available
+cStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/').setName("C style comment")
+"Comment of the form C{/* ... */}"
+
+htmlComment = Regex(r"<!--[\s\S]*?-->").setName("HTML comment")
+"Comment of the form C{<!-- ... -->}"
+
+restOfLine = Regex(r".*").leaveWhitespace().setName("rest of line")
+dblSlashComment = Regex(r"//(?:\\\n|[^\n])*").setName("// comment")
+"Comment of the form C{// ... (to end of line)}"
+
+cppStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/'| dblSlashComment).setName("C++ style comment")
+"Comment of either form C{L{cStyleComment}} or C{L{dblSlashComment}}"
+
+javaStyleComment = cppStyleComment
+"Same as C{L{cppStyleComment}}"
+
+pythonStyleComment = Regex(r"#.*").setName("Python style comment")
+"Comment of the form C{# ... (to end of line)}"
+
+_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',') +
+                                  Optional( Word(" \t") +
+                                            ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem")
+commaSeparatedList = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("commaSeparatedList")
+"""(Deprecated) Predefined expression of 1 or more printable words or quoted strings, separated by commas.
+   This expression is deprecated in favor of L{pyparsing_common.comma_separated_list}."""
+
+# some other useful expressions - using lower-case class name since we are really using this as a namespace
+class pyparsing_common:
+    """
+    Here are some common low-level expressions that may be useful in jump-starting parser development:
+     - numeric forms (L{integers<integer>}, L{reals<real>}, L{scientific notation<sci_real>})
+     - common L{programming identifiers<identifier>}
+     - network addresses (L{MAC<mac_address>}, L{IPv4<ipv4_address>}, L{IPv6<ipv6_address>})
+     - ISO8601 L{dates<iso8601_date>} and L{datetime<iso8601_datetime>}
+     - L{UUID<uuid>}
+     - L{comma-separated list<comma_separated_list>}
+    Parse actions:
+     - C{L{convertToInteger}}
+     - C{L{convertToFloat}}
+     - C{L{convertToDate}}
+     - C{L{convertToDatetime}}
+     - C{L{stripHTMLTags}}
+     - C{L{upcaseTokens}}
+     - C{L{downcaseTokens}}
+
+    Example::
+        pyparsing_common.number.runTests('''
+            # any int or real number, returned as the appropriate type
+            100
+            -100
+            +100
+            3.14159
+            6.02e23
+            1e-12
+            ''')
+
+        pyparsing_common.fnumber.runTests('''
+            # any int or real number, returned as float
+            100
+            -100
+            +100
+            3.14159
+            6.02e23
+            1e-12
+            ''')
+
+        pyparsing_common.hex_integer.runTests('''
+            # hex numbers
+            100
+            FF
+            ''')
+
+        pyparsing_common.fraction.runTests('''
+            # fractions
+            1/2
+            -3/4
+            ''')
+
+        pyparsing_common.mixed_integer.runTests('''
+            # mixed fractions
+            1
+            1/2
+            -3/4
+            1-3/4
+            ''')
+
+        import uuid
+        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
+        pyparsing_common.uuid.runTests('''
+            # uuid
+            12345678-1234-5678-1234-567812345678
+            ''')
+    prints::
+        # any int or real number, returned as the appropriate type
+        100
+        [100]
+
+        -100
+        [-100]
+
+        +100
+        [100]
+
+        3.14159
+        [3.14159]
+
+        6.02e23
+        [6.02e+23]
+
+        1e-12
+        [1e-12]
+
+        # any int or real number, returned as float
+        100
+        [100.0]
+
+        -100
+        [-100.0]
+
+        +100
+        [100.0]
+
+        3.14159
+        [3.14159]
+
+        6.02e23
+        [6.02e+23]
+
+        1e-12
+        [1e-12]
+
+        # hex numbers
+        100
+        [256]
+
+        FF
+        [255]
+
+        # fractions
+        1/2
+        [0.5]
+
+        -3/4
+        [-0.75]
+
+        # mixed fractions
+        1
+        [1]
+
+        1/2
+        [0.5]
+
+        -3/4
+        [-0.75]
+
+        1-3/4
+        [1.75]
+
+        # uuid
+        12345678-1234-5678-1234-567812345678
+        [UUID('12345678-1234-5678-1234-567812345678')]
+    """
+
+    convertToInteger = tokenMap(int)
+    """
+    Parse action for converting parsed integers to Python int
+    """
+
+    convertToFloat = tokenMap(float)
+    """
+    Parse action for converting parsed numbers to Python float
+    """
+
+    integer = Word(nums).setName("integer").setParseAction(convertToInteger)
+    """expression that parses an unsigned integer, returns an int"""
+
+    hex_integer = Word(hexnums).setName("hex integer").setParseAction(tokenMap(int,16))
+    """expression that parses a hexadecimal integer, returns an int"""
+
+    signed_integer = Regex(r'[+-]?\d+').setName("signed integer").setParseAction(convertToInteger)
+    """expression that parses an integer with optional leading sign, returns an int"""
+
+    fraction = (signed_integer().setParseAction(convertToFloat) + '/' + signed_integer().setParseAction(convertToFloat)).setName("fraction")
+    """fractional expression of an integer divided by an integer, returns a float"""
+    fraction.addParseAction(lambda t: t[0]/t[-1])
+
+    mixed_integer = (fraction | signed_integer + Optional(Optional('-').suppress() + fraction)).setName("fraction or mixed integer-fraction")
+    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float"""
+    mixed_integer.addParseAction(sum)
+
+    real = Regex(r'[+-]?\d+\.\d*').setName("real number").setParseAction(convertToFloat)
+    """expression that parses a floating point number and returns a float"""
+
+    sci_real = Regex(r'[+-]?\d+([eE][+-]?\d+|\.\d*([eE][+-]?\d+)?)').setName("real number with scientific notation").setParseAction(convertToFloat)
+    """expression that parses a floating point number with optional scientific notation and returns a float"""
+
+    # streamlining this expression makes the docs nicer-looking
+    number = (sci_real | real | signed_integer).streamline()
+    """any numeric expression, returns the corresponding Python type"""
+
+    fnumber = Regex(r'[+-]?\d+\.?\d*([eE][+-]?\d+)?').setName("fnumber").setParseAction(convertToFloat)
+    """any int or real number, returned as float"""
+    
+    identifier = Word(alphas+'_', alphanums+'_').setName("identifier")
+    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')"""
+    
+    ipv4_address = Regex(r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}').setName("IPv4 address")
+    "IPv4 address (C{0.0.0.0 - 255.255.255.255})"
+
+    _ipv6_part = Regex(r'[0-9a-fA-F]{1,4}').setName("hex_integer")
+    _full_ipv6_address = (_ipv6_part + (':' + _ipv6_part)*7).setName("full IPv6 address")
+    _short_ipv6_address = (Optional(_ipv6_part + (':' + _ipv6_part)*(0,6)) + "::" + Optional(_ipv6_part + (':' + _ipv6_part)*(0,6))).setName("short IPv6 address")
+    _short_ipv6_address.addCondition(lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8)
+    _mixed_ipv6_address = ("::ffff:" + ipv4_address).setName("mixed IPv6 address")
+    ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName("IPv6 address")).setName("IPv6 address")
+    "IPv6 address (long, short, or mixed form)"
+    
+    mac_address = Regex(r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}').setName("MAC address")
+    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)"
+
+    @staticmethod
+    def convertToDate(fmt="%Y-%m-%d"):
+        """
+        Helper to create a parse action for converting parsed date string to Python datetime.date
+
+        Params -
+         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%d"})
+
+        Example::
+            date_expr = pyparsing_common.iso8601_date.copy()
+            date_expr.setParseAction(pyparsing_common.convertToDate())
+            print(date_expr.parseString("1999-12-31"))
+        prints::
+            [datetime.date(1999, 12, 31)]
+        """
+        def cvt_fn(s,l,t):
+            try:
+                return datetime.strptime(t[0], fmt).date()
+            except ValueError as ve:
+                raise ParseException(s, l, str(ve))
+        return cvt_fn
+
+    @staticmethod
+    def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"):
+        """
+        Helper to create a parse action for converting parsed datetime string to Python datetime.datetime
+
+        Params -
+         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%dT%H:%M:%S.%f"})
+
+        Example::
+            dt_expr = pyparsing_common.iso8601_datetime.copy()
+            dt_expr.setParseAction(pyparsing_common.convertToDatetime())
+            print(dt_expr.parseString("1999-12-31T23:59:59.999"))
+        prints::
+            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]
+        """
+        def cvt_fn(s,l,t):
+            try:
+                return datetime.strptime(t[0], fmt)
+            except ValueError as ve:
+                raise ParseException(s, l, str(ve))
+        return cvt_fn
+
+    iso8601_date = Regex(r'(?P<year>\d{4})(?:-(?P<month>\d\d)(?:-(?P<day>\d\d))?)?').setName("ISO8601 date")
+    "ISO8601 date (C{yyyy-mm-dd})"
+
+    iso8601_datetime = Regex(r'(?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)[T ](?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d(\.\d*)?)?)?(?P<tz>Z|[+-]\d\d:?\d\d)?').setName("ISO8601 datetime")
+    "ISO8601 datetime (C{yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)}) - trailing seconds, milliseconds, and timezone optional; accepts separating C{'T'} or C{' '}"
+
+    uuid = Regex(r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}').setName("UUID")
+    "UUID (C{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx})"
+
+    _html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress()
+    @staticmethod
+    def stripHTMLTags(s, l, tokens):
+        """
+        Parse action to remove HTML tags from web page HTML source
+
+        Example::
+            # strip HTML links from normal text 
+            text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'
+            td,td_end = makeHTMLTags("TD")
+            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end
+            
+            print(table_text.parseString(text).body) # -> 'More info at the pyparsing wiki page'
+        """
+        return pyparsing_common._html_stripper.transformString(tokens[0])
+
+    _commasepitem = Combine(OneOrMore(~Literal(",") + ~LineEnd() + Word(printables, excludeChars=',') 
+                                        + Optional( White(" \t") ) ) ).streamline().setName("commaItem")
+    comma_separated_list = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("comma separated list")
+    """Predefined expression of 1 or more printable words or quoted strings, separated by commas."""
+
+    upcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).upper()))
+    """Parse action to convert tokens to upper case."""
+
+    downcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).lower()))
+    """Parse action to convert tokens to lower case."""
+
+
+if __name__ == "__main__":
+
+    selectToken    = CaselessLiteral("select")
+    fromToken      = CaselessLiteral("from")
+
+    ident          = Word(alphas, alphanums + "_$")
+
+    columnName     = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
+    columnNameList = Group(delimitedList(columnName)).setName("columns")
+    columnSpec     = ('*' | columnNameList)
+
+    tableName      = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
+    tableNameList  = Group(delimitedList(tableName)).setName("tables")
+    
+    simpleSQL      = selectToken("command") + columnSpec("columns") + fromToken + tableNameList("tables")
+
+    # demo runTests method, including embedded comments in test string
+    simpleSQL.runTests("""
+        # '*' as column list and dotted table name
+        select * from SYS.XYZZY
+
+        # caseless match on "SELECT", and casts back to "select"
+        SELECT * from XYZZY, ABC
+
+        # list of column names, and mixed case SELECT keyword
+        Select AA,BB,CC from Sys.dual
+
+        # multiple tables
+        Select A, B, C from Sys.dual, Table2
+
+        # invalid SELECT keyword - should fail
+        Xelect A, B, C from Sys.dual
+
+        # incomplete command - should fail
+        Select
+
+        # invalid column name - should fail
+        Select ^^^ frox Sys.dual
+
+        """)
+
+    pyparsing_common.number.runTests("""
+        100
+        -100
+        +100
+        3.14159
+        6.02e23
+        1e-12
+        """)
+
+    # any int or real number, returned as float
+    pyparsing_common.fnumber.runTests("""
+        100
+        -100
+        +100
+        3.14159
+        6.02e23
+        1e-12
+        """)
+
+    pyparsing_common.hex_integer.runTests("""
+        100
+        FF
+        """)
+
+    import uuid
+    pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
+    pyparsing_common.uuid.runTests("""
+        12345678-1234-5678-1234-567812345678
+        """)
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/six.py b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/six.py
new file mode 100644
index 0000000..190c023
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/_vendor/six.py
@@ -0,0 +1,868 @@
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+# Copyright (c) 2010-2015 Benjamin Peterson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from __future__ import absolute_import
+
+import functools
+import itertools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.10.0"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+PY34 = sys.version_info[0:2] >= (3, 4)
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result)  # Invokes __set__.
+        try:
+            # This is a bit ugly, but it avoids running this again by
+            # removing this descriptor.
+            delattr(obj.__class__, self.name)
+        except AttributeError:
+            pass
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+]
+# Add windows specific modules.
+if sys.platform == "win32":
+    _moved_attributes += [
+        MovedModule("winreg", "_winreg"),
+    ]
+
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    def create_unbound_method(func, cls):
+        return func
+
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    def create_unbound_method(func, cls):
+        return types.MethodType(func, None, cls)
+
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+
+    viewkeys = operator.methodcaller("keys")
+
+    viewvalues = operator.methodcaller("values")
+
+    viewitems = operator.methodcaller("items")
+else:
+    def iterkeys(d, **kw):
+        return d.iterkeys(**kw)
+
+    def itervalues(d, **kw):
+        return d.itervalues(**kw)
+
+    def iteritems(d, **kw):
+        return d.iteritems(**kw)
+
+    def iterlists(d, **kw):
+        return d.iterlists(**kw)
+
+    viewkeys = operator.methodcaller("viewkeys")
+
+    viewvalues = operator.methodcaller("viewvalues")
+
+    viewitems = operator.methodcaller("viewitems")
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+
+    def u(s):
+        return s
+    unichr = chr
+    import struct
+    int2byte = struct.Struct(">B").pack
+    del struct
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+    _assertCountEqual = "assertCountEqual"
+    if sys.version_info[1] <= 1:
+        _assertRaisesRegex = "assertRaisesRegexp"
+        _assertRegex = "assertRegexpMatches"
+    else:
+        _assertRaisesRegex = "assertRaisesRegex"
+        _assertRegex = "assertRegex"
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
+
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
+
+    def byte2int(bs):
+        return ord(bs[0])
+
+    def indexbytes(buf, i):
+        return ord(buf[i])
+    iterbytes = functools.partial(itertools.imap, ord)
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
+    _assertCountEqual = "assertItemsEqual"
+    _assertRaisesRegex = "assertRaisesRegexp"
+    _assertRegex = "assertRegexpMatches"
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+def assertCountEqual(self, *args, **kwargs):
+    return getattr(self, _assertCountEqual)(*args, **kwargs)
+
+
+def assertRaisesRegex(self, *args, **kwargs):
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
+
+
+def assertRegex(self, *args, **kwargs):
+    return getattr(self, _assertRegex)(*args, **kwargs)
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+    def reraise(tp, value, tb=None):
+        if value is None:
+            value = tp()
+        if value.__traceback__ is not tb:
+            raise value.with_traceback(tb)
+        raise value
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+    exec_("""def reraise(tp, value, tb=None):
+    raise tp, value, tb
+""")
+
+
+if sys.version_info[:2] == (3, 2):
+    exec_("""def raise_from(value, from_value):
+    if from_value is None:
+        raise value
+    raise value from from_value
+""")
+elif sys.version_info[:2] > (3, 2):
+    exec_("""def raise_from(value, from_value):
+    raise value from from_value
+""")
+else:
+    def raise_from(value, from_value):
+        raise value
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
+                    isinstance(data, unicode) and
+                    fp.encoding is not None):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+if sys.version_info[:2] < (3, 3):
+    _print = print_
+
+    def print_(*args, **kwargs):
+        fp = kwargs.get("file", sys.stdout)
+        flush = kwargs.pop("flush", False)
+        _print(*args, **kwargs)
+        if flush and fp is not None:
+            fp.flush()
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+              updated=functools.WRAPPER_UPDATES):
+        def wrapper(f):
+            f = functools.wraps(wrapped, assigned, updated)(f)
+            f.__wrapped__ = wrapped
+            return f
+        return wrapper
+else:
+    wraps = functools.wraps
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):
+
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
+
+def python_2_unicode_compatible(klass):
+    """
+    A decorator that defines __unicode__ and __str__ methods under Python 2.
+    Under Python 3 it does nothing.
+
+    To support Python 2 and 3 with a single code base, define a __str__ method
+    returning text and apply this decorator to the class.
+    """
+    if PY2:
+        if '__str__' not in klass.__dict__:
+            raise ValueError("@python_2_unicode_compatible cannot be applied "
+                             "to %s because it doesn't define __str__()." %
+                             klass.__name__)
+        klass.__unicode__ = klass.__str__
+        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
+    return klass
+
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
+                importer.name == __name__):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)
diff --git a/myenv/lib/python3.9/site-packages/pkg_resources/extern/__init__.py b/myenv/lib/python3.9/site-packages/pkg_resources/extern/__init__.py
new file mode 100644
index 0000000..bf98d8f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pkg_resources/extern/__init__.py
@@ -0,0 +1,66 @@
+import sys
+
+
+class VendorImporter:
+    """
+    A PEP 302 meta path importer for finding optionally-vendored
+    or otherwise naturally-installed packages from root_name.
+    """
+
+    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
+        self.root_name = root_name
+        self.vendored_names = set(vendored_names)
+        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')
+
+    @property
+    def search_path(self):
+        """
+        Search first the vendor package then as a natural package.
+        """
+        yield self.vendor_pkg + '.'
+        yield ''
+
+    def find_module(self, fullname, path=None):
+        """
+        Return self when fullname starts with root_name and the
+        target module is one vendored through this importer.
+        """
+        root, base, target = fullname.partition(self.root_name + '.')
+        if root:
+            return
+        if not any(map(target.startswith, self.vendored_names)):
+            return
+        return self
+
+    def load_module(self, fullname):
+        """
+        Iterate over the search path to locate and load fullname.
+        """
+        root, base, target = fullname.partition(self.root_name + '.')
+        for prefix in self.search_path:
+            try:
+                extant = prefix + target
+                __import__(extant)
+                mod = sys.modules[extant]
+                sys.modules[fullname] = mod
+                return mod
+            except ImportError:
+                pass
+        else:
+            raise ImportError(
+                "The '{target}' package is required; "
+                "normally this is bundled with this package so if you get "
+                "this warning, consult the packager of your "
+                "distribution.".format(**locals())
+            )
+
+    def install(self):
+        """
+        Install this importer into sys.meta_path if not already present.
+        """
+        if self not in sys.meta_path:
+            sys.meta_path.append(self)
+
+
+names = 'packaging', 'pyparsing', 'six', 'appdirs'
+VendorImporter(__name__, names).install()
diff --git a/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/METADATA b/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/METADATA
new file mode 100644
index 0000000..f9ffe28
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/METADATA
@@ -0,0 +1,250 @@
+Metadata-Version: 2.1
+Name: platformdirs
+Version: 2.5.2
+Summary: A small Python module for determining appropriate platform-specific dirs, e.g. a "user data dir".
+Project-URL: Documentation, https://platformdirs.readthedocs.io
+Project-URL: Homepage, https://github.com/platformdirs/platformdirs
+Project-URL: Source, https://github.com/platformdirs/platformdirs
+Project-URL: Tracker, https://github.com/platformdirs/platformdirs/issues
+Maintainer-email: Bernát Gábor <gaborjbernat@gmail.com>, Julian Berman <Julian@GrayVines.com>, Ofek Lev <oss@ofek.dev>, Ronny Pfannschmidt <opensource@ronnypfannschmidt.de>
+Keywords: application,cache,directory,log,user
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Provides-Extra: docs
+Requires-Dist: furo>=2021.7.5b38; extra == 'docs'
+Requires-Dist: proselint>=0.10.2; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints>=1.12; extra == 'docs'
+Requires-Dist: sphinx>=4; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: appdirs==1.4.4; extra == 'test'
+Requires-Dist: pytest-cov>=2.7; extra == 'test'
+Requires-Dist: pytest-mock>=3.6; extra == 'test'
+Requires-Dist: pytest>=6; extra == 'test'
+Description-Content-Type: text/x-rst
+
+The problem
+===========
+
+.. image:: https://github.com/platformdirs/platformdirs/workflows/Test/badge.svg
+   :target: https://github.com/platformdirs/platformdirs/actions?query=workflow%3ATest
+
+When writing desktop application, finding the right location to store user data
+and configuration varies per platform. Even for single-platform apps, there
+may by plenty of nuances in figuring out the right location.
+
+For example, if running on macOS, you should use::
+
+    ~/Library/Application Support/<AppName>
+
+If on Windows (at least English Win XP) that should be::
+
+    C:\Documents and Settings\<User>\Application Data\Local Settings\<AppAuthor>\<AppName>
+
+or possibly::
+
+    C:\Documents and Settings\<User>\Application Data\<AppAuthor>\<AppName>
+
+for `roaming profiles <https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-vista/cc766489(v=ws.10)>`_ but that is another story.
+
+On Linux (and other Unices), according to the `XDG Basedir Spec`_, it should be::
+
+    ~/.local/share/<AppName>
+
+.. _XDG Basedir Spec: https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+``platformdirs`` to the rescue
+==============================
+
+This kind of thing is what the ``platformdirs`` module is for.
+``platformdirs`` will help you choose an appropriate:
+
+- user data dir (``user_data_dir``)
+- user config dir (``user_config_dir``)
+- user cache dir (``user_cache_dir``)
+- site data dir (``site_data_dir``)
+- site config dir (``site_config_dir``)
+- user log dir (``user_log_dir``)
+- user documents dir (``user_documents_dir``)
+- user runtime dir (``user_runtime_dir``)
+
+And also:
+
+- Is a single module so other Python packages can vendor their own private copy.
+- Is slightly opinionated on the directory names used. Look for "OPINION" in
+  documentation and code for when an opinion is being applied.
+
+Example output
+==============
+
+On macOS:
+
+.. code-block:: pycon
+
+    >>> from platformdirs import *
+    >>> appname = "SuperApp"
+    >>> appauthor = "Acme"
+    >>> user_data_dir(appname, appauthor)
+    '/Users/trentm/Library/Application Support/SuperApp'
+    >>> site_data_dir(appname, appauthor)
+    '/Library/Application Support/SuperApp'
+    >>> user_cache_dir(appname, appauthor)
+    '/Users/trentm/Library/Caches/SuperApp'
+    >>> user_log_dir(appname, appauthor)
+    '/Users/trentm/Library/Logs/SuperApp'
+    >>> user_documents_dir()
+    '/Users/trentm/Documents'
+    >>> user_runtime_dir(appname, appauthor)
+    '/Users/trentm/Library/Caches/TemporaryItems/SuperApp'
+
+On Windows 7:
+
+.. code-block:: pycon
+
+    >>> from platformdirs import *
+    >>> appname = "SuperApp"
+    >>> appauthor = "Acme"
+    >>> user_data_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Acme\\SuperApp'
+    >>> user_data_dir(appname, appauthor, roaming=True)
+    'C:\\Users\\trentm\\AppData\\Roaming\\Acme\\SuperApp'
+    >>> user_cache_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Acme\\SuperApp\\Cache'
+    >>> user_log_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Acme\\SuperApp\\Logs'
+    >>> user_documents_dir()
+    'C:\\Users\\trentm\\Documents'
+    >>> user_runtime_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Temp\\Acme\\SuperApp'
+
+On Linux:
+
+.. code-block:: pycon
+
+    >>> from platformdirs import *
+    >>> appname = "SuperApp"
+    >>> appauthor = "Acme"
+    >>> user_data_dir(appname, appauthor)
+    '/home/trentm/.local/share/SuperApp'
+    >>> site_data_dir(appname, appauthor)
+    '/usr/local/share/SuperApp'
+    >>> site_data_dir(appname, appauthor, multipath=True)
+    '/usr/local/share/SuperApp:/usr/share/SuperApp'
+    >>> user_cache_dir(appname, appauthor)
+    '/home/trentm/.cache/SuperApp'
+    >>> user_log_dir(appname, appauthor)
+    '/home/trentm/.cache/SuperApp/log'
+    >>> user_config_dir(appname)
+    '/home/trentm/.config/SuperApp'
+    >>> user_documents_dir()
+    '/home/trentm/Documents'
+    >>> user_runtime_dir(appname, appauthor)
+    '/run/user/{os.getuid()}/SuperApp'
+    >>> site_config_dir(appname)
+    '/etc/xdg/SuperApp'
+    >>> os.environ["XDG_CONFIG_DIRS"] = "/etc:/usr/local/etc"
+    >>> site_config_dir(appname, multipath=True)
+    '/etc/SuperApp:/usr/local/etc/SuperApp'
+
+On Android::
+
+    >>> from platformdirs import *
+    >>> appname = "SuperApp"
+    >>> appauthor = "Acme"
+    >>> user_data_dir(appname, appauthor)
+    '/data/data/com.myApp/files/SuperApp'
+    >>> user_cache_dir(appname, appauthor)
+    '/data/data/com.myApp/cache/SuperApp'
+    >>> user_log_dir(appname, appauthor)
+    '/data/data/com.myApp/cache/SuperApp/log'
+    >>> user_config_dir(appname)
+    '/data/data/com.myApp/shared_prefs/SuperApp'
+    >>> user_documents_dir()
+    '/storage/emulated/0/Documents'
+    >>> user_runtime_dir(appname, appauthor)
+    '/data/data/com.myApp/cache/SuperApp/tmp'
+
+Note: Some android apps like Termux and Pydroid are used as shells. These
+apps are used by the end user to emulate Linux environment. Presence of
+``SHELL`` environment variable is used by Platformdirs to differentiate
+between general android apps and android apps used as shells. Shell android
+apps also support ``XDG_*`` environment variables.
+
+
+``PlatformDirs`` for convenience
+================================
+
+.. code-block:: pycon
+
+    >>> from platformdirs import PlatformDirs
+    >>> dirs = PlatformDirs("SuperApp", "Acme")
+    >>> dirs.user_data_dir
+    '/Users/trentm/Library/Application Support/SuperApp'
+    >>> dirs.site_data_dir
+    '/Library/Application Support/SuperApp'
+    >>> dirs.user_cache_dir
+    '/Users/trentm/Library/Caches/SuperApp'
+    >>> dirs.user_log_dir
+    '/Users/trentm/Library/Logs/SuperApp'
+    >>> dirs.user_documents_dir
+    '/Users/trentm/Documents'
+    >>> dirs.user_runtime_dir
+    '/Users/trentm/Library/Caches/TemporaryItems/SuperApp'
+
+Per-version isolation
+=====================
+
+If you have multiple versions of your app in use that you want to be
+able to run side-by-side, then you may want version-isolation for these
+dirs::
+
+    >>> from platformdirs import PlatformDirs
+    >>> dirs = PlatformDirs("SuperApp", "Acme", version="1.0")
+    >>> dirs.user_data_dir
+    '/Users/trentm/Library/Application Support/SuperApp/1.0'
+    >>> dirs.site_data_dir
+    '/Library/Application Support/SuperApp/1.0'
+    >>> dirs.user_cache_dir
+    '/Users/trentm/Library/Caches/SuperApp/1.0'
+    >>> dirs.user_log_dir
+    '/Users/trentm/Library/Logs/SuperApp/1.0'
+    >>> dirs.user_documents_dir
+    '/Users/trentm/Documents'
+    >>> dirs.user_runtime_dir
+    '/Users/trentm/Library/Caches/TemporaryItems/SuperApp/1.0'
+
+Be wary of using this for configuration files though; you'll need to handle
+migrating configuration files manually.
+
+Why this Fork?
+==============
+
+This repository is a friendly fork of the wonderful work started by
+`ActiveState <https://github.com/ActiveState/appdirs>`_ who created
+``appdirs``, this package's ancestor.
+
+Maintaining an open source project is no easy task, particularly
+from within an organization, and the Python community is indebted
+to ``appdirs`` (and to Trent Mick and Jeff Rouse in particular) for
+creating an incredibly useful simple module, as evidenced by the wide
+number of users it has attracted over the years.
+
+Nonetheless, given the number of long-standing open issues
+and pull requests, and no clear path towards `ensuring
+that maintenance of the package would continue or grow
+<https://github.com/ActiveState/appdirs/issues/79>`_, this fork was
+created.
+
+Contributions are most welcome.
diff --git a/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/RECORD b/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/RECORD
new file mode 100644
index 0000000..60a0f20
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/RECORD
@@ -0,0 +1,15 @@
+platformdirs/__init__.py,sha256=dSnbrJunkEvMf9qODHnKBa_-13B0k5skznLx2iNp2Mg,12759
+platformdirs/__main__.py,sha256=VsC0t5m-6f0YVr96PVks93G3EDF8MSNY4KpUMvPahDA,1164
+platformdirs/android.py,sha256=GKizhyS7ESRiU67u8UnBJLm46goau9937EchXWbPBlk,4068
+platformdirs/api.py,sha256=MXKHXOL3eh_-trSok-JUTjAR_zjmmKF3rjREVABjP8s,4910
+platformdirs/macos.py,sha256=-3UXQewbT0yMhMdkzRXfXGAntmLIH7Qt4a9Hlf8I5_Y,2655
+platformdirs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+platformdirs/unix.py,sha256=b4aVYTz0qZ50HntwOXo8r6tp82jAa3qTjxw-WlnC2yc,6910
+platformdirs/version.py,sha256=tsBKKPDX3LLh39yHXeTYauGRbRd-AmOJr9SwKldlFIU,78
+platformdirs/windows.py,sha256=ISruopR5UGBePC0BxCxXevkZYfjJsIZc49YWU5iYfQ4,6439
+platformdirs-2.5.2.dist-info/METADATA,sha256=sg3t6Jiqw3YL8BODMxWs4z0WzqrcudBqbFpSR28WnsY,9394
+platformdirs-2.5.2.dist-info/WHEEL,sha256=sb4ZHsmozXdkdXRvpMHZmhxsxQvL8DERDUEGA9tAfc8,83
+platformdirs-2.5.2.dist-info/entry_points.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+platformdirs-2.5.2.dist-info/license_files/LICENSE.txt,sha256=1l7lsqNqOR6Nau_OuArlAGMEml2xS8gk7g8eusmXDlA,1096
+platformdirs-2.5.2.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+platformdirs-2.5.2.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/WHEEL
new file mode 100644
index 0000000..32b66be
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatch 0.22.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/entry_points.txt
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/license_files/LICENSE.txt b/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/license_files/LICENSE.txt
new file mode 100644
index 0000000..f0bbd69
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs-2.5.2.dist-info/license_files/LICENSE.txt
@@ -0,0 +1,22 @@
+# This is the MIT license
+
+Copyright (c) 2010 ActiveState Software Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/platformdirs/__init__.py b/myenv/lib/python3.9/site-packages/platformdirs/__init__.py
new file mode 100644
index 0000000..a2d730c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs/__init__.py
@@ -0,0 +1,340 @@
+"""
+Utilities for determining application-specific dirs. See <https://github.com/platformdirs/platformdirs> for details and
+usage.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal  # pragma: no cover
+
+from .api import PlatformDirsABC
+from .version import __version__, __version_info__
+
+
+def _set_platform_dir_class() -> type[PlatformDirsABC]:
+    if sys.platform == "win32":
+        from platformdirs.windows import Windows as Result
+    elif sys.platform == "darwin":
+        from platformdirs.macos import MacOS as Result
+    else:
+        from platformdirs.unix import Unix as Result
+
+    if os.getenv("ANDROID_DATA") == "/data" and os.getenv("ANDROID_ROOT") == "/system":
+
+        if os.getenv("SHELL") is not None:
+            return Result
+
+        from platformdirs.android import _android_folder
+
+        if _android_folder() is not None:
+            from platformdirs.android import Android
+
+            return Android  # return to avoid redefinition of result
+
+    return Result
+
+
+PlatformDirs = _set_platform_dir_class()  #: Currently active platform
+AppDirs = PlatformDirs  #: Backwards compatibility with appdirs
+
+
+def user_data_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,
+) -> str:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param roaming: See `roaming <platformdirs.api.PlatformDirsABC.version>`.
+    :returns: data directory tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_data_dir
+
+
+def site_data_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    multipath: bool = False,
+) -> str:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param multipath: See `roaming <platformdirs.api.PlatformDirsABC.multipath>`.
+    :returns: data directory shared by users
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_data_dir
+
+
+def user_config_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,
+) -> str:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param roaming: See `roaming <platformdirs.api.PlatformDirsABC.version>`.
+    :returns: config directory tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_config_dir
+
+
+def site_config_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    multipath: bool = False,
+) -> str:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param multipath: See `roaming <platformdirs.api.PlatformDirsABC.multipath>`.
+    :returns: config directory shared by the users
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_config_dir
+
+
+def user_cache_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,
+) -> str:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param opinion: See `roaming <platformdirs.api.PlatformDirsABC.opinion>`.
+    :returns: cache directory tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_cache_dir
+
+
+def user_state_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,
+) -> str:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param roaming: See `roaming <platformdirs.api.PlatformDirsABC.version>`.
+    :returns: state directory tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_state_dir
+
+
+def user_log_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,
+) -> str:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param opinion: See `roaming <platformdirs.api.PlatformDirsABC.opinion>`.
+    :returns: log directory tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_log_dir
+
+
+def user_documents_dir() -> str:
+    """
+    :returns: documents directory tied to the user
+    """
+    return PlatformDirs().user_documents_dir
+
+
+def user_runtime_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,
+) -> str:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param opinion: See `opinion <platformdirs.api.PlatformDirsABC.opinion>`.
+    :returns: runtime directory tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_runtime_dir
+
+
+def user_data_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,
+) -> Path:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param roaming: See `roaming <platformdirs.api.PlatformDirsABC.version>`.
+    :returns: data path tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_data_path
+
+
+def site_data_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    multipath: bool = False,
+) -> Path:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param multipath: See `multipath <platformdirs.api.PlatformDirsABC.multipath>`.
+    :returns: data path shared by users
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_data_path
+
+
+def user_config_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,
+) -> Path:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param roaming: See `roaming <platformdirs.api.PlatformDirsABC.version>`.
+    :returns: config path tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_config_path
+
+
+def site_config_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    multipath: bool = False,
+) -> Path:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param multipath: See `roaming <platformdirs.api.PlatformDirsABC.multipath>`.
+    :returns: config path shared by the users
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_config_path
+
+
+def user_cache_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,
+) -> Path:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param opinion: See `roaming <platformdirs.api.PlatformDirsABC.opinion>`.
+    :returns: cache path tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_cache_path
+
+
+def user_state_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,
+) -> Path:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param roaming: See `roaming <platformdirs.api.PlatformDirsABC.version>`.
+    :returns: state path tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_state_path
+
+
+def user_log_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,
+) -> Path:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param opinion: See `roaming <platformdirs.api.PlatformDirsABC.opinion>`.
+    :returns: log path tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_log_path
+
+
+def user_documents_path() -> Path:
+    """
+    :returns: documents path tied to the user
+    """
+    return PlatformDirs().user_documents_path
+
+
+def user_runtime_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,
+) -> Path:
+    """
+    :param appname: See `appname <platformdirs.api.PlatformDirsABC.appname>`.
+    :param appauthor: See `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`.
+    :param version: See `version <platformdirs.api.PlatformDirsABC.version>`.
+    :param opinion: See `opinion <platformdirs.api.PlatformDirsABC.opinion>`.
+    :returns: runtime path tied to the user
+    """
+    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_runtime_path
+
+
+__all__ = [
+    "__version__",
+    "__version_info__",
+    "PlatformDirs",
+    "AppDirs",
+    "PlatformDirsABC",
+    "user_data_dir",
+    "user_config_dir",
+    "user_cache_dir",
+    "user_state_dir",
+    "user_log_dir",
+    "user_documents_dir",
+    "user_runtime_dir",
+    "site_data_dir",
+    "site_config_dir",
+    "user_data_path",
+    "user_config_path",
+    "user_cache_path",
+    "user_state_path",
+    "user_log_path",
+    "user_documents_path",
+    "user_runtime_path",
+    "site_data_path",
+    "site_config_path",
+]
diff --git a/myenv/lib/python3.9/site-packages/platformdirs/__main__.py b/myenv/lib/python3.9/site-packages/platformdirs/__main__.py
new file mode 100644
index 0000000..0fc1edd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs/__main__.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from platformdirs import PlatformDirs, __version__
+
+PROPS = (
+    "user_data_dir",
+    "user_config_dir",
+    "user_cache_dir",
+    "user_state_dir",
+    "user_log_dir",
+    "user_documents_dir",
+    "user_runtime_dir",
+    "site_data_dir",
+    "site_config_dir",
+)
+
+
+def main() -> None:
+    app_name = "MyApp"
+    app_author = "MyCompany"
+
+    print(f"-- platformdirs {__version__} --")
+
+    print("-- app dirs (with optional 'version')")
+    dirs = PlatformDirs(app_name, app_author, version="1.0")
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")
+
+    print("\n-- app dirs (without optional 'version')")
+    dirs = PlatformDirs(app_name, app_author)
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")
+
+    print("\n-- app dirs (without optional 'appauthor')")
+    dirs = PlatformDirs(app_name)
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")
+
+    print("\n-- app dirs (with disabled 'appauthor')")
+    dirs = PlatformDirs(app_name, appauthor=False)
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/myenv/lib/python3.9/site-packages/platformdirs/android.py b/myenv/lib/python3.9/site-packages/platformdirs/android.py
new file mode 100644
index 0000000..eda8093
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs/android.py
@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import os
+import re
+import sys
+from functools import lru_cache
+from typing import cast
+
+from .api import PlatformDirsABC
+
+
+class Android(PlatformDirsABC):
+    """
+    Follows the guidance `from here <https://android.stackexchange.com/a/216132>`_. Makes use of the
+    `appname <platformdirs.api.PlatformDirsABC.appname>` and
+    `version <platformdirs.api.PlatformDirsABC.version>`.
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """:return: data directory tied to the user, e.g. ``/data/user/<userid>/<packagename>/files/<AppName>``"""
+        return self._append_app_name_and_version(cast(str, _android_folder()), "files")
+
+    @property
+    def site_data_dir(self) -> str:
+        """:return: data directory shared by users, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_config_dir(self) -> str:
+        """
+        :return: config directory tied to the user, e.g. ``/data/user/<userid>/<packagename>/shared_prefs/<AppName>``
+        """
+        return self._append_app_name_and_version(cast(str, _android_folder()), "shared_prefs")
+
+    @property
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users, same as `user_config_dir`"""
+        return self.user_config_dir
+
+    @property
+    def user_cache_dir(self) -> str:
+        """:return: cache directory tied to the user, e.g. e.g. ``/data/user/<userid>/<packagename>/cache/<AppName>``"""
+        return self._append_app_name_and_version(cast(str, _android_folder()), "cache")
+
+    @property
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_log_dir(self) -> str:
+        """
+        :return: log directory tied to the user, same as `user_cache_dir` if not opinionated else ``log`` in it,
+          e.g. ``/data/user/<userid>/<packagename>/cache/<AppName>/log``
+        """
+        path = self.user_cache_dir
+        if self.opinion:
+            path = os.path.join(path, "log")
+        return path
+
+    @property
+    def user_documents_dir(self) -> str:
+        """
+        :return: documents directory tied to the user e.g. ``/storage/emulated/0/Documents``
+        """
+        return _android_documents_folder()
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """
+        :return: runtime directory tied to the user, same as `user_cache_dir` if not opinionated else ``tmp`` in it,
+          e.g. ``/data/user/<userid>/<packagename>/cache/<AppName>/tmp``
+        """
+        path = self.user_cache_dir
+        if self.opinion:
+            path = os.path.join(path, "tmp")
+        return path
+
+
+@lru_cache(maxsize=1)
+def _android_folder() -> str | None:
+    """:return: base folder for the Android OS or None if cannot be found"""
+    try:
+        # First try to get path to android app via pyjnius
+        from jnius import autoclass
+
+        Context = autoclass("android.content.Context")  # noqa: N806
+        result: str | None = Context.getFilesDir().getParentFile().getAbsolutePath()
+    except Exception:
+        # if fails find an android folder looking path on the sys.path
+        pattern = re.compile(r"/data/(data|user/\d+)/(.+)/files")
+        for path in sys.path:
+            if pattern.match(path):
+                result = path.split("/files")[0]
+                break
+        else:
+            result = None
+    return result
+
+
+@lru_cache(maxsize=1)
+def _android_documents_folder() -> str:
+    """:return: documents folder for the Android OS"""
+    # Get directories with pyjnius
+    try:
+        from jnius import autoclass
+
+        Context = autoclass("android.content.Context")  # noqa: N806
+        Environment = autoclass("android.os.Environment")  # noqa: N806
+        documents_dir: str = Context.getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS).getAbsolutePath()
+    except Exception:
+        documents_dir = "/storage/emulated/0/Documents"
+
+    return documents_dir
+
+
+__all__ = [
+    "Android",
+]
diff --git a/myenv/lib/python3.9/site-packages/platformdirs/api.py b/myenv/lib/python3.9/site-packages/platformdirs/api.py
new file mode 100644
index 0000000..6f6e2c2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs/api.py
@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import os
+import sys
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+if sys.version_info >= (3, 8):  # pragma: no branch
+    from typing import Literal  # pragma: no cover
+
+
+class PlatformDirsABC(ABC):
+    """
+    Abstract base class for platform directories.
+    """
+
+    def __init__(
+        self,
+        appname: str | None = None,
+        appauthor: str | None | Literal[False] = None,
+        version: str | None = None,
+        roaming: bool = False,
+        multipath: bool = False,
+        opinion: bool = True,
+    ):
+        """
+        Create a new platform directory.
+
+        :param appname: See `appname`.
+        :param appauthor: See `appauthor`.
+        :param version: See `version`.
+        :param roaming: See `roaming`.
+        :param multipath: See `multipath`.
+        :param opinion: See `opinion`.
+        """
+        self.appname = appname  #: The name of application.
+        self.appauthor = appauthor
+        """
+        The name of the app author or distributing body for this application. Typically, it is the owning company name.
+        Defaults to `appname`. You may pass ``False`` to disable it.
+        """
+        self.version = version
+        """
+        An optional version path element to append to the path. You might want to use this if you want multiple versions
+        of your app to be able to run independently. If used, this would typically be ``<major>.<minor>``.
+        """
+        self.roaming = roaming
+        """
+        Whether to use the roaming appdata directory on Windows. That means that for users on a Windows network setup
+        for roaming profiles, this user data will be synced on login (see
+        `here <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>`_).
+        """
+        self.multipath = multipath
+        """
+        An optional parameter only applicable to Unix/Linux which indicates that the entire list of data dirs should be
+        returned. By default, the first item would only be returned.
+        """
+        self.opinion = opinion  #: A flag to indicating to use opinionated values.
+
+    def _append_app_name_and_version(self, *base: str) -> str:
+        params = list(base[1:])
+        if self.appname:
+            params.append(self.appname)
+            if self.version:
+                params.append(self.version)
+        return os.path.join(base[0], *params)
+
+    @property
+    @abstractmethod
+    def user_data_dir(self) -> str:
+        """:return: data directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def site_data_dir(self) -> str:
+        """:return: data directory shared by users"""
+
+    @property
+    @abstractmethod
+    def user_config_dir(self) -> str:
+        """:return: config directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users"""
+
+    @property
+    @abstractmethod
+    def user_cache_dir(self) -> str:
+        """:return: cache directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_log_dir(self) -> str:
+        """:return: log directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_runtime_dir(self) -> str:
+        """:return: runtime directory tied to the user"""
+
+    @property
+    def user_data_path(self) -> Path:
+        """:return: data path tied to the user"""
+        return Path(self.user_data_dir)
+
+    @property
+    def site_data_path(self) -> Path:
+        """:return: data path shared by users"""
+        return Path(self.site_data_dir)
+
+    @property
+    def user_config_path(self) -> Path:
+        """:return: config path tied to the user"""
+        return Path(self.user_config_dir)
+
+    @property
+    def site_config_path(self) -> Path:
+        """:return: config path shared by the users"""
+        return Path(self.site_config_dir)
+
+    @property
+    def user_cache_path(self) -> Path:
+        """:return: cache path tied to the user"""
+        return Path(self.user_cache_dir)
+
+    @property
+    def user_state_path(self) -> Path:
+        """:return: state path tied to the user"""
+        return Path(self.user_state_dir)
+
+    @property
+    def user_log_path(self) -> Path:
+        """:return: log path tied to the user"""
+        return Path(self.user_log_dir)
+
+    @property
+    def user_documents_path(self) -> Path:
+        """:return: documents path tied to the user"""
+        return Path(self.user_documents_dir)
+
+    @property
+    def user_runtime_path(self) -> Path:
+        """:return: runtime path tied to the user"""
+        return Path(self.user_runtime_dir)
diff --git a/myenv/lib/python3.9/site-packages/platformdirs/macos.py b/myenv/lib/python3.9/site-packages/platformdirs/macos.py
new file mode 100644
index 0000000..a01337c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs/macos.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import os
+
+from .api import PlatformDirsABC
+
+
+class MacOS(PlatformDirsABC):
+    """
+    Platform directories for the macOS operating system. Follows the guidance from `Apple documentation
+    <https://developer.apple.com/library/archive/documentation/FileManagement/Conceptual/FileSystemProgrammingGuide/MacOSXDirectories/MacOSXDirectories.html>`_.
+    Makes use of the `appname <platformdirs.api.PlatformDirsABC.appname>` and
+    `version <platformdirs.api.PlatformDirsABC.version>`.
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """:return: data directory tied to the user, e.g. ``~/Library/Application Support/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Application Support/"))
+
+    @property
+    def site_data_dir(self) -> str:
+        """:return: data directory shared by users, e.g. ``/Library/Application Support/$appname/$version``"""
+        return self._append_app_name_and_version("/Library/Application Support")
+
+    @property
+    def user_config_dir(self) -> str:
+        """:return: config directory tied to the user, e.g. ``~/Library/Preferences/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Preferences/"))
+
+    @property
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users, e.g. ``/Library/Preferences/$appname``"""
+        return self._append_app_name_and_version("/Library/Preferences")
+
+    @property
+    def user_cache_dir(self) -> str:
+        """:return: cache directory tied to the user, e.g. ``~/Library/Caches/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches"))
+
+    @property
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_log_dir(self) -> str:
+        """:return: log directory tied to the user, e.g. ``~/Library/Logs/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Logs"))
+
+    @property
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user, e.g. ``~/Documents``"""
+        return os.path.expanduser("~/Documents")
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """:return: runtime directory tied to the user, e.g. ``~/Library/Caches/TemporaryItems/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches/TemporaryItems"))
+
+
+__all__ = [
+    "MacOS",
+]
diff --git a/myenv/lib/python3.9/site-packages/platformdirs/py.typed b/myenv/lib/python3.9/site-packages/platformdirs/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/platformdirs/unix.py b/myenv/lib/python3.9/site-packages/platformdirs/unix.py
new file mode 100644
index 0000000..2fbd4d4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs/unix.py
@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import os
+import sys
+from configparser import ConfigParser
+from pathlib import Path
+
+from .api import PlatformDirsABC
+
+if sys.platform.startswith("linux"):  # pragma: no branch # no op check, only to please the type checker
+    from os import getuid
+else:
+
+    def getuid() -> int:
+        raise RuntimeError("should only be used on Linux")
+
+
+class Unix(PlatformDirsABC):
+    """
+    On Unix/Linux, we follow the
+    `XDG Basedir Spec <https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html>`_. The spec allows
+    overriding directories with environment variables. The examples show are the default values, alongside the name of
+    the environment variable that overrides them. Makes use of the
+    `appname <platformdirs.api.PlatformDirsABC.appname>`,
+    `version <platformdirs.api.PlatformDirsABC.version>`,
+    `multipath <platformdirs.api.PlatformDirsABC.multipath>`,
+    `opinion <platformdirs.api.PlatformDirsABC.opinion>`.
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """
+        :return: data directory tied to the user, e.g. ``~/.local/share/$appname/$version`` or
+         ``$XDG_DATA_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_DATA_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.local/share")
+        return self._append_app_name_and_version(path)
+
+    @property
+    def site_data_dir(self) -> str:
+        """
+        :return: data directories shared by users (if `multipath <platformdirs.api.PlatformDirsABC.multipath>` is
+         enabled and ``XDG_DATA_DIR`` is set and a multi path the response is also a multi path separated by the OS
+         path separator), e.g. ``/usr/local/share/$appname/$version`` or ``/usr/share/$appname/$version``
+        """
+        # XDG default for $XDG_DATA_DIRS; only first, if multipath is False
+        path = os.environ.get("XDG_DATA_DIRS", "")
+        if not path.strip():
+            path = f"/usr/local/share{os.pathsep}/usr/share"
+        return self._with_multi_path(path)
+
+    def _with_multi_path(self, path: str) -> str:
+        path_list = path.split(os.pathsep)
+        if not self.multipath:
+            path_list = path_list[0:1]
+        path_list = [self._append_app_name_and_version(os.path.expanduser(p)) for p in path_list]
+        return os.pathsep.join(path_list)
+
+    @property
+    def user_config_dir(self) -> str:
+        """
+        :return: config directory tied to the user, e.g. ``~/.config/$appname/$version`` or
+         ``$XDG_CONFIG_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_CONFIG_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.config")
+        return self._append_app_name_and_version(path)
+
+    @property
+    def site_config_dir(self) -> str:
+        """
+        :return: config directories shared by users (if `multipath <platformdirs.api.PlatformDirsABC.multipath>`
+         is enabled and ``XDG_DATA_DIR`` is set and a multi path the response is also a multi path separated by the OS
+         path separator), e.g. ``/etc/xdg/$appname/$version``
+        """
+        # XDG default for $XDG_CONFIG_DIRS only first, if multipath is False
+        path = os.environ.get("XDG_CONFIG_DIRS", "")
+        if not path.strip():
+            path = "/etc/xdg"
+        return self._with_multi_path(path)
+
+    @property
+    def user_cache_dir(self) -> str:
+        """
+        :return: cache directory tied to the user, e.g. ``~/.cache/$appname/$version`` or
+         ``~/$XDG_CACHE_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_CACHE_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.cache")
+        return self._append_app_name_and_version(path)
+
+    @property
+    def user_state_dir(self) -> str:
+        """
+        :return: state directory tied to the user, e.g. ``~/.local/state/$appname/$version`` or
+         ``$XDG_STATE_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_STATE_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.local/state")
+        return self._append_app_name_and_version(path)
+
+    @property
+    def user_log_dir(self) -> str:
+        """
+        :return: log directory tied to the user, same as `user_data_dir` if not opinionated else ``log`` in it
+        """
+        path = self.user_cache_dir
+        if self.opinion:
+            path = os.path.join(path, "log")
+        return path
+
+    @property
+    def user_documents_dir(self) -> str:
+        """
+        :return: documents directory tied to the user, e.g. ``~/Documents``
+        """
+        documents_dir = _get_user_dirs_folder("XDG_DOCUMENTS_DIR")
+        if documents_dir is None:
+            documents_dir = os.environ.get("XDG_DOCUMENTS_DIR", "").strip()
+            if not documents_dir:
+                documents_dir = os.path.expanduser("~/Documents")
+
+        return documents_dir
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """
+        :return: runtime directory tied to the user, e.g. ``/run/user/$(id -u)/$appname/$version`` or
+         ``$XDG_RUNTIME_DIR/$appname/$version``
+        """
+        path = os.environ.get("XDG_RUNTIME_DIR", "")
+        if not path.strip():
+            path = f"/run/user/{getuid()}"
+        return self._append_app_name_and_version(path)
+
+    @property
+    def site_data_path(self) -> Path:
+        """:return: data path shared by users. Only return first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_data_dir)
+
+    @property
+    def site_config_path(self) -> Path:
+        """:return: config path shared by the users. Only return first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_config_dir)
+
+    def _first_item_as_path_if_multipath(self, directory: str) -> Path:
+        if self.multipath:
+            # If multipath is True, the first path is returned.
+            directory = directory.split(os.pathsep)[0]
+        return Path(directory)
+
+
+def _get_user_dirs_folder(key: str) -> str | None:
+    """Return directory from user-dirs.dirs config file. See https://freedesktop.org/wiki/Software/xdg-user-dirs/"""
+    user_dirs_config_path = os.path.join(Unix().user_config_dir, "user-dirs.dirs")
+    if os.path.exists(user_dirs_config_path):
+        parser = ConfigParser()
+
+        with open(user_dirs_config_path) as stream:
+            # Add fake section header, so ConfigParser doesn't complain
+            parser.read_string(f"[top]\n{stream.read()}")
+
+        if key not in parser["top"]:
+            return None
+
+        path = parser["top"][key].strip('"')
+        # Handle relative home paths
+        path = path.replace("$HOME", os.path.expanduser("~"))
+        return path
+
+    return None
+
+
+__all__ = [
+    "Unix",
+]
diff --git a/myenv/lib/python3.9/site-packages/platformdirs/version.py b/myenv/lib/python3.9/site-packages/platformdirs/version.py
new file mode 100644
index 0000000..4552c02
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs/version.py
@@ -0,0 +1,4 @@
+"""Version information"""
+
+__version__ = "2.5.2"
+__version_info__ = (2, 5, 2)
diff --git a/myenv/lib/python3.9/site-packages/platformdirs/windows.py b/myenv/lib/python3.9/site-packages/platformdirs/windows.py
new file mode 100644
index 0000000..ef972bd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/platformdirs/windows.py
@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import ctypes
+import os
+from functools import lru_cache
+from typing import Callable
+
+from .api import PlatformDirsABC
+
+
+class Windows(PlatformDirsABC):
+    """`MSDN on where to store app data files
+    <http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120>`_.
+    Makes use of the
+    `appname <platformdirs.api.PlatformDirsABC.appname>`,
+    `appauthor <platformdirs.api.PlatformDirsABC.appauthor>`,
+    `version <platformdirs.api.PlatformDirsABC.version>`,
+    `roaming <platformdirs.api.PlatformDirsABC.roaming>`,
+    `opinion <platformdirs.api.PlatformDirsABC.opinion>`."""
+
+    @property
+    def user_data_dir(self) -> str:
+        """
+        :return: data directory tied to the user, e.g.
+         ``%USERPROFILE%\\AppData\\Local\\$appauthor\\$appname`` (not roaming) or
+         ``%USERPROFILE%\\AppData\\Roaming\\$appauthor\\$appname`` (roaming)
+        """
+        const = "CSIDL_APPDATA" if self.roaming else "CSIDL_LOCAL_APPDATA"
+        path = os.path.normpath(get_win_folder(const))
+        return self._append_parts(path)
+
+    def _append_parts(self, path: str, *, opinion_value: str | None = None) -> str:
+        params = []
+        if self.appname:
+            if self.appauthor is not False:
+                author = self.appauthor or self.appname
+                params.append(author)
+            params.append(self.appname)
+            if opinion_value is not None and self.opinion:
+                params.append(opinion_value)
+            if self.version:
+                params.append(self.version)
+        return os.path.join(path, *params)
+
+    @property
+    def site_data_dir(self) -> str:
+        """:return: data directory shared by users, e.g. ``C:\\ProgramData\\$appauthor\\$appname``"""
+        path = os.path.normpath(get_win_folder("CSIDL_COMMON_APPDATA"))
+        return self._append_parts(path)
+
+    @property
+    def user_config_dir(self) -> str:
+        """:return: config directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users, same as `site_data_dir`"""
+        return self.site_data_dir
+
+    @property
+    def user_cache_dir(self) -> str:
+        """
+        :return: cache directory tied to the user (if opinionated with ``Cache`` folder within ``$appname``) e.g.
+         ``%USERPROFILE%\\AppData\\Local\\$appauthor\\$appname\\Cache\\$version``
+        """
+        path = os.path.normpath(get_win_folder("CSIDL_LOCAL_APPDATA"))
+        return self._append_parts(path, opinion_value="Cache")
+
+    @property
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_log_dir(self) -> str:
+        """
+        :return: log directory tied to the user, same as `user_data_dir` if not opinionated else ``Logs`` in it
+        """
+        path = self.user_data_dir
+        if self.opinion:
+            path = os.path.join(path, "Logs")
+        return path
+
+    @property
+    def user_documents_dir(self) -> str:
+        """
+        :return: documents directory tied to the user e.g. ``%USERPROFILE%\\Documents``
+        """
+        return os.path.normpath(get_win_folder("CSIDL_PERSONAL"))
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """
+        :return: runtime directory tied to the user, e.g.
+         ``%USERPROFILE%\\AppData\\Local\\Temp\\$appauthor\\$appname``
+        """
+        path = os.path.normpath(os.path.join(get_win_folder("CSIDL_LOCAL_APPDATA"), "Temp"))
+        return self._append_parts(path)
+
+
+def get_win_folder_from_env_vars(csidl_name: str) -> str:
+    """Get folder from environment variables."""
+    if csidl_name == "CSIDL_PERSONAL":  # does not have an environment name
+        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Documents")
+
+    env_var_name = {
+        "CSIDL_APPDATA": "APPDATA",
+        "CSIDL_COMMON_APPDATA": "ALLUSERSPROFILE",
+        "CSIDL_LOCAL_APPDATA": "LOCALAPPDATA",
+    }.get(csidl_name)
+    if env_var_name is None:
+        raise ValueError(f"Unknown CSIDL name: {csidl_name}")
+    result = os.environ.get(env_var_name)
+    if result is None:
+        raise ValueError(f"Unset environment variable: {env_var_name}")
+    return result
+
+
+def get_win_folder_from_registry(csidl_name: str) -> str:
+    """Get folder from the registry.
+
+    This is a fallback technique at best. I'm not sure if using the
+    registry for this guarantees us the correct answer for all CSIDL_*
+    names.
+    """
+    shell_folder_name = {
+        "CSIDL_APPDATA": "AppData",
+        "CSIDL_COMMON_APPDATA": "Common AppData",
+        "CSIDL_LOCAL_APPDATA": "Local AppData",
+        "CSIDL_PERSONAL": "Personal",
+    }.get(csidl_name)
+    if shell_folder_name is None:
+        raise ValueError(f"Unknown CSIDL name: {csidl_name}")
+
+    import winreg
+
+    key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
+    directory, _ = winreg.QueryValueEx(key, shell_folder_name)
+    return str(directory)
+
+
+def get_win_folder_via_ctypes(csidl_name: str) -> str:
+    """Get folder with ctypes."""
+    csidl_const = {
+        "CSIDL_APPDATA": 26,
+        "CSIDL_COMMON_APPDATA": 35,
+        "CSIDL_LOCAL_APPDATA": 28,
+        "CSIDL_PERSONAL": 5,
+    }.get(csidl_name)
+    if csidl_const is None:
+        raise ValueError(f"Unknown CSIDL name: {csidl_name}")
+
+    buf = ctypes.create_unicode_buffer(1024)
+    windll = getattr(ctypes, "windll")  # noqa: B009 # using getattr to avoid false positive with mypy type checker
+    windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+    # Downgrade to short path name if it has highbit chars.
+    if any(ord(c) > 255 for c in buf):
+        buf2 = ctypes.create_unicode_buffer(1024)
+        if windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+            buf = buf2
+
+    return buf.value
+
+
+def _pick_get_win_folder() -> Callable[[str], str]:
+    if hasattr(ctypes, "windll"):
+        return get_win_folder_via_ctypes
+    try:
+        import winreg  # noqa: F401
+    except ImportError:
+        return get_win_folder_from_env_vars
+    else:
+        return get_win_folder_from_registry
+
+
+get_win_folder = lru_cache(maxsize=None)(_pick_get_win_folder())
+
+__all__ = [
+    "Windows",
+]
diff --git a/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/LICENSE
new file mode 100644
index 0000000..85f4dd6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 holger krekel (rather uses bitbucket/hpk42)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/METADATA
new file mode 100644
index 0000000..976c06c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/METADATA
@@ -0,0 +1,143 @@
+Metadata-Version: 2.1
+Name: pluggy
+Version: 1.0.0
+Summary: plugin and hook calling mechanisms for python
+Home-page: https://github.com/pytest-dev/pluggy
+Author: Holger Krekel
+Author-email: holger@merlinux.eu
+License: MIT
+Platform: unix
+Platform: linux
+Platform: osx
+Platform: win32
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.6
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: importlib-metadata (>=0.12) ; python_version < "3.8"
+Provides-Extra: dev
+Requires-Dist: pre-commit ; extra == 'dev'
+Requires-Dist: tox ; extra == 'dev'
+Provides-Extra: testing
+Requires-Dist: pytest ; extra == 'testing'
+Requires-Dist: pytest-benchmark ; extra == 'testing'
+
+====================================================
+pluggy - A minimalist production ready plugin system
+====================================================
+
+|pypi| |conda-forge| |versions| |github-actions| |gitter| |black| |codecov|
+
+This is the core framework used by the `pytest`_, `tox`_, and `devpi`_ projects.
+
+Please `read the docs`_ to learn more!
+
+A definitive example
+====================
+.. code-block:: python
+
+    import pluggy
+
+    hookspec = pluggy.HookspecMarker("myproject")
+    hookimpl = pluggy.HookimplMarker("myproject")
+
+
+    class MySpec:
+        """A hook specification namespace."""
+
+        @hookspec
+        def myhook(self, arg1, arg2):
+            """My special little hook that you can customize."""
+
+
+    class Plugin_1:
+        """A hook implementation namespace."""
+
+        @hookimpl
+        def myhook(self, arg1, arg2):
+            print("inside Plugin_1.myhook()")
+            return arg1 + arg2
+
+
+    class Plugin_2:
+        """A 2nd hook implementation namespace."""
+
+        @hookimpl
+        def myhook(self, arg1, arg2):
+            print("inside Plugin_2.myhook()")
+            return arg1 - arg2
+
+
+    # create a manager and add the spec
+    pm = pluggy.PluginManager("myproject")
+    pm.add_hookspecs(MySpec)
+
+    # register plugins
+    pm.register(Plugin_1())
+    pm.register(Plugin_2())
+
+    # call our ``myhook`` hook
+    results = pm.hook.myhook(arg1=1, arg2=2)
+    print(results)
+
+
+Running this directly gets us::
+
+    $ python docs/examples/toy-example.py
+    inside Plugin_2.myhook()
+    inside Plugin_1.myhook()
+    [-1, 3]
+
+
+.. badges
+
+.. |pypi| image:: https://img.shields.io/pypi/v/pluggy.svg
+    :target: https://pypi.org/pypi/pluggy
+
+.. |versions| image:: https://img.shields.io/pypi/pyversions/pluggy.svg
+    :target: https://pypi.org/pypi/pluggy
+
+.. |github-actions| image:: https://github.com/pytest-dev/pluggy/workflows/main/badge.svg
+    :target: https://github.com/pytest-dev/pluggy/actions
+
+.. |conda-forge| image:: https://img.shields.io/conda/vn/conda-forge/pluggy.svg
+    :target: https://anaconda.org/conda-forge/pytest
+
+.. |gitter| image:: https://badges.gitter.im/pytest-dev/pluggy.svg
+    :alt: Join the chat at https://gitter.im/pytest-dev/pluggy
+    :target: https://gitter.im/pytest-dev/pluggy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+
+.. |black| image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/ambv/black
+
+.. |codecov| image:: https://codecov.io/gh/pytest-dev/pluggy/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/pytest-dev/pluggy
+    :alt: Code coverage Status
+
+.. links
+.. _pytest:
+    http://pytest.org
+.. _tox:
+    https://tox.readthedocs.org
+.. _devpi:
+    http://doc.devpi.net
+.. _read the docs:
+   https://pluggy.readthedocs.io/en/latest/
+
+
diff --git a/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/RECORD
new file mode 100644
index 0000000..d3d0b14
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/RECORD
@@ -0,0 +1,13 @@
+pluggy/__init__.py,sha256=4_jjNtDnnx6BewYDJ4qFZkcX4l4Jn0B3HqOtdsAQvUE,489
+pluggy/_callers.py,sha256=lq2KNXazhKr-KF_GJPw4vsY2EHwQ5ON2dSiZUCtaeQw,2097
+pluggy/_hooks.py,sha256=OQPnqv7J7ufLZVQSICHpNw4AYWdXDwTVfeYCL_ZEwRM,11496
+pluggy/_manager.py,sha256=mKQniNqj_LPtt35r6dELbRPrqEdZ_iPL6VdFyx7987o,14752
+pluggy/_result.py,sha256=sLTL034QA3Sfke8ptadUkvoWW5iQ1PvzyoC_7F2eQfg,1535
+pluggy/_tracing.py,sha256=xSv4V1pU_ik8pVCpobTH8gnjB3DQ4iing3tv-bDuHtA,1541
+pluggy/_version.py,sha256=YDhpFAXgv37cmY1pZn8kQNcYAOwj883BhWAtoaziSG4,142
+pluggy-1.0.0.dist-info/LICENSE,sha256=1rZebCE6XQtXeRHTTW5ZSbn1nXbCOMUHGi8_wWz7JgY,1110
+pluggy-1.0.0.dist-info/METADATA,sha256=Q5D7uI21VrEOPb6XD0cM4vY1Zkptyb2iOIY43MHfwXI,4345
+pluggy-1.0.0.dist-info/WHEEL,sha256=WzZ8cwjh8l0jtULNjYq1Hpr-WCqCRgPr--TX4P5I1Wo,110
+pluggy-1.0.0.dist-info/top_level.txt,sha256=xKSCRhai-v9MckvMuWqNz16c1tbsmOggoMSwTgcpYHE,7
+pluggy-1.0.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+pluggy-1.0.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/WHEEL
new file mode 100644
index 0000000..b733a60
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/top_level.txt
new file mode 100644
index 0000000..11bdb5c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy-1.0.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+pluggy
diff --git a/myenv/lib/python3.9/site-packages/pluggy/__init__.py b/myenv/lib/python3.9/site-packages/pluggy/__init__.py
new file mode 100644
index 0000000..979028f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy/__init__.py
@@ -0,0 +1,18 @@
+try:
+    from ._version import version as __version__
+except ImportError:
+    # broken installation, we don't even try
+    # unknown only works because we do poor mans version compare
+    __version__ = "unknown"
+
+__all__ = [
+    "PluginManager",
+    "PluginValidationError",
+    "HookCallError",
+    "HookspecMarker",
+    "HookimplMarker",
+]
+
+from ._manager import PluginManager, PluginValidationError
+from ._callers import HookCallError
+from ._hooks import HookspecMarker, HookimplMarker
diff --git a/myenv/lib/python3.9/site-packages/pluggy/_callers.py b/myenv/lib/python3.9/site-packages/pluggy/_callers.py
new file mode 100644
index 0000000..7a16f3b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy/_callers.py
@@ -0,0 +1,60 @@
+"""
+Call loop machinery
+"""
+import sys
+
+from ._result import HookCallError, _Result, _raise_wrapfail
+
+
+def _multicall(hook_name, hook_impls, caller_kwargs, firstresult):
+    """Execute a call into multiple python functions/methods and return the
+    result(s).
+
+    ``caller_kwargs`` comes from _HookCaller.__call__().
+    """
+    __tracebackhide__ = True
+    results = []
+    excinfo = None
+    try:  # run impl and wrapper setup functions in a loop
+        teardowns = []
+        try:
+            for hook_impl in reversed(hook_impls):
+                try:
+                    args = [caller_kwargs[argname] for argname in hook_impl.argnames]
+                except KeyError:
+                    for argname in hook_impl.argnames:
+                        if argname not in caller_kwargs:
+                            raise HookCallError(
+                                f"hook call must provide argument {argname!r}"
+                            )
+
+                if hook_impl.hookwrapper:
+                    try:
+                        gen = hook_impl.function(*args)
+                        next(gen)  # first yield
+                        teardowns.append(gen)
+                    except StopIteration:
+                        _raise_wrapfail(gen, "did not yield")
+                else:
+                    res = hook_impl.function(*args)
+                    if res is not None:
+                        results.append(res)
+                        if firstresult:  # halt further impl calls
+                            break
+        except BaseException:
+            excinfo = sys.exc_info()
+    finally:
+        if firstresult:  # first result hooks return a single value
+            outcome = _Result(results[0] if results else None, excinfo)
+        else:
+            outcome = _Result(results, excinfo)
+
+        # run all wrapper post-yield blocks
+        for gen in reversed(teardowns):
+            try:
+                gen.send(outcome)
+                _raise_wrapfail(gen, "has second yield")
+            except StopIteration:
+                pass
+
+        return outcome.get_result()
diff --git a/myenv/lib/python3.9/site-packages/pluggy/_hooks.py b/myenv/lib/python3.9/site-packages/pluggy/_hooks.py
new file mode 100644
index 0000000..1e5fbb7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy/_hooks.py
@@ -0,0 +1,325 @@
+"""
+Internal hook annotation, representation and calling machinery.
+"""
+import inspect
+import sys
+import warnings
+
+
+class HookspecMarker:
+    """Decorator helper class for marking functions as hook specifications.
+
+    You can instantiate it with a project_name to get a decorator.
+    Calling :py:meth:`.PluginManager.add_hookspecs` later will discover all marked functions
+    if the :py:class:`.PluginManager` uses the same project_name.
+    """
+
+    def __init__(self, project_name):
+        self.project_name = project_name
+
+    def __call__(
+        self, function=None, firstresult=False, historic=False, warn_on_impl=None
+    ):
+        """if passed a function, directly sets attributes on the function
+        which will make it discoverable to :py:meth:`.PluginManager.add_hookspecs`.
+        If passed no function, returns a decorator which can be applied to a function
+        later using the attributes supplied.
+
+        If ``firstresult`` is ``True`` the 1:N hook call (N being the number of registered
+        hook implementation functions) will stop at I<=N when the I'th function
+        returns a non-``None`` result.
+
+        If ``historic`` is ``True`` calls to a hook will be memorized and replayed
+        on later registered plugins.
+
+        """
+
+        def setattr_hookspec_opts(func):
+            if historic and firstresult:
+                raise ValueError("cannot have a historic firstresult hook")
+            setattr(
+                func,
+                self.project_name + "_spec",
+                dict(
+                    firstresult=firstresult,
+                    historic=historic,
+                    warn_on_impl=warn_on_impl,
+                ),
+            )
+            return func
+
+        if function is not None:
+            return setattr_hookspec_opts(function)
+        else:
+            return setattr_hookspec_opts
+
+
+class HookimplMarker:
+    """Decorator helper class for marking functions as hook implementations.
+
+    You can instantiate with a ``project_name`` to get a decorator.
+    Calling :py:meth:`.PluginManager.register` later will discover all marked functions
+    if the :py:class:`.PluginManager` uses the same project_name.
+    """
+
+    def __init__(self, project_name):
+        self.project_name = project_name
+
+    def __call__(
+        self,
+        function=None,
+        hookwrapper=False,
+        optionalhook=False,
+        tryfirst=False,
+        trylast=False,
+        specname=None,
+    ):
+
+        """if passed a function, directly sets attributes on the function
+        which will make it discoverable to :py:meth:`.PluginManager.register`.
+        If passed no function, returns a decorator which can be applied to a
+        function later using the attributes supplied.
+
+        If ``optionalhook`` is ``True`` a missing matching hook specification will not result
+        in an error (by default it is an error if no matching spec is found).
+
+        If ``tryfirst`` is ``True`` this hook implementation will run as early as possible
+        in the chain of N hook implementations for a specification.
+
+        If ``trylast`` is ``True`` this hook implementation will run as late as possible
+        in the chain of N hook implementations.
+
+        If ``hookwrapper`` is ``True`` the hook implementations needs to execute exactly
+        one ``yield``.  The code before the ``yield`` is run early before any non-hookwrapper
+        function is run.  The code after the ``yield`` is run after all non-hookwrapper
+        function have run.  The ``yield`` receives a :py:class:`.callers._Result` object
+        representing the exception or result outcome of the inner calls (including other
+        hookwrapper calls).
+
+        If ``specname`` is provided, it will be used instead of the function name when
+        matching this hook implementation to a hook specification during registration.
+
+        """
+
+        def setattr_hookimpl_opts(func):
+            setattr(
+                func,
+                self.project_name + "_impl",
+                dict(
+                    hookwrapper=hookwrapper,
+                    optionalhook=optionalhook,
+                    tryfirst=tryfirst,
+                    trylast=trylast,
+                    specname=specname,
+                ),
+            )
+            return func
+
+        if function is None:
+            return setattr_hookimpl_opts
+        else:
+            return setattr_hookimpl_opts(function)
+
+
+def normalize_hookimpl_opts(opts):
+    opts.setdefault("tryfirst", False)
+    opts.setdefault("trylast", False)
+    opts.setdefault("hookwrapper", False)
+    opts.setdefault("optionalhook", False)
+    opts.setdefault("specname", None)
+
+
+_PYPY = hasattr(sys, "pypy_version_info")
+
+
+def varnames(func):
+    """Return tuple of positional and keywrord argument names for a function,
+    method, class or callable.
+
+    In case of a class, its ``__init__`` method is considered.
+    For methods the ``self`` parameter is not included.
+    """
+    if inspect.isclass(func):
+        try:
+            func = func.__init__
+        except AttributeError:
+            return (), ()
+    elif not inspect.isroutine(func):  # callable object?
+        try:
+            func = getattr(func, "__call__", func)
+        except Exception:
+            return (), ()
+
+    try:  # func MUST be a function or method here or we won't parse any args
+        spec = inspect.getfullargspec(func)
+    except TypeError:
+        return (), ()
+
+    args, defaults = tuple(spec.args), spec.defaults
+    if defaults:
+        index = -len(defaults)
+        args, kwargs = args[:index], tuple(args[index:])
+    else:
+        kwargs = ()
+
+    # strip any implicit instance arg
+    # pypy3 uses "obj" instead of "self" for default dunder methods
+    implicit_names = ("self",) if not _PYPY else ("self", "obj")
+    if args:
+        if inspect.ismethod(func) or (
+            "." in getattr(func, "__qualname__", ()) and args[0] in implicit_names
+        ):
+            args = args[1:]
+
+    return args, kwargs
+
+
+class _HookRelay:
+    """hook holder object for performing 1:N hook calls where N is the number
+    of registered plugins.
+
+    """
+
+
+class _HookCaller:
+    def __init__(self, name, hook_execute, specmodule_or_class=None, spec_opts=None):
+        self.name = name
+        self._wrappers = []
+        self._nonwrappers = []
+        self._hookexec = hook_execute
+        self._call_history = None
+        self.spec = None
+        if specmodule_or_class is not None:
+            assert spec_opts is not None
+            self.set_specification(specmodule_or_class, spec_opts)
+
+    def has_spec(self):
+        return self.spec is not None
+
+    def set_specification(self, specmodule_or_class, spec_opts):
+        assert not self.has_spec()
+        self.spec = HookSpec(specmodule_or_class, self.name, spec_opts)
+        if spec_opts.get("historic"):
+            self._call_history = []
+
+    def is_historic(self):
+        return self._call_history is not None
+
+    def _remove_plugin(self, plugin):
+        def remove(wrappers):
+            for i, method in enumerate(wrappers):
+                if method.plugin == plugin:
+                    del wrappers[i]
+                    return True
+
+        if remove(self._wrappers) is None:
+            if remove(self._nonwrappers) is None:
+                raise ValueError(f"plugin {plugin!r} not found")
+
+    def get_hookimpls(self):
+        # Order is important for _hookexec
+        return self._nonwrappers + self._wrappers
+
+    def _add_hookimpl(self, hookimpl):
+        """Add an implementation to the callback chain."""
+        if hookimpl.hookwrapper:
+            methods = self._wrappers
+        else:
+            methods = self._nonwrappers
+
+        if hookimpl.trylast:
+            methods.insert(0, hookimpl)
+        elif hookimpl.tryfirst:
+            methods.append(hookimpl)
+        else:
+            # find last non-tryfirst method
+            i = len(methods) - 1
+            while i >= 0 and methods[i].tryfirst:
+                i -= 1
+            methods.insert(i + 1, hookimpl)
+
+    def __repr__(self):
+        return f"<_HookCaller {self.name!r}>"
+
+    def __call__(self, *args, **kwargs):
+        if args:
+            raise TypeError("hook calling supports only keyword arguments")
+        assert not self.is_historic()
+
+        # This is written to avoid expensive operations when not needed.
+        if self.spec:
+            for argname in self.spec.argnames:
+                if argname not in kwargs:
+                    notincall = tuple(set(self.spec.argnames) - kwargs.keys())
+                    warnings.warn(
+                        "Argument(s) {} which are declared in the hookspec "
+                        "can not be found in this hook call".format(notincall),
+                        stacklevel=2,
+                    )
+                    break
+
+            firstresult = self.spec.opts.get("firstresult")
+        else:
+            firstresult = False
+
+        return self._hookexec(self.name, self.get_hookimpls(), kwargs, firstresult)
+
+    def call_historic(self, result_callback=None, kwargs=None):
+        """Call the hook with given ``kwargs`` for all registered plugins and
+        for all plugins which will be registered afterwards.
+
+        If ``result_callback`` is not ``None`` it will be called for for each
+        non-``None`` result obtained from a hook implementation.
+        """
+        self._call_history.append((kwargs or {}, result_callback))
+        # Historizing hooks don't return results.
+        # Remember firstresult isn't compatible with historic.
+        res = self._hookexec(self.name, self.get_hookimpls(), kwargs, False)
+        if result_callback is None:
+            return
+        for x in res or []:
+            result_callback(x)
+
+    def call_extra(self, methods, kwargs):
+        """Call the hook with some additional temporarily participating
+        methods using the specified ``kwargs`` as call parameters."""
+        old = list(self._nonwrappers), list(self._wrappers)
+        for method in methods:
+            opts = dict(hookwrapper=False, trylast=False, tryfirst=False)
+            hookimpl = HookImpl(None, "<temp>", method, opts)
+            self._add_hookimpl(hookimpl)
+        try:
+            return self(**kwargs)
+        finally:
+            self._nonwrappers, self._wrappers = old
+
+    def _maybe_apply_history(self, method):
+        """Apply call history to a new hookimpl if it is marked as historic."""
+        if self.is_historic():
+            for kwargs, result_callback in self._call_history:
+                res = self._hookexec(self.name, [method], kwargs, False)
+                if res and result_callback is not None:
+                    result_callback(res[0])
+
+
+class HookImpl:
+    def __init__(self, plugin, plugin_name, function, hook_impl_opts):
+        self.function = function
+        self.argnames, self.kwargnames = varnames(self.function)
+        self.plugin = plugin
+        self.opts = hook_impl_opts
+        self.plugin_name = plugin_name
+        self.__dict__.update(hook_impl_opts)
+
+    def __repr__(self):
+        return f"<HookImpl plugin_name={self.plugin_name!r}, plugin={self.plugin!r}>"
+
+
+class HookSpec:
+    def __init__(self, namespace, name, opts):
+        self.namespace = namespace
+        self.function = function = getattr(namespace, name)
+        self.name = name
+        self.argnames, self.kwargnames = varnames(function)
+        self.opts = opts
+        self.warn_on_impl = opts.get("warn_on_impl")
diff --git a/myenv/lib/python3.9/site-packages/pluggy/_manager.py b/myenv/lib/python3.9/site-packages/pluggy/_manager.py
new file mode 100644
index 0000000..65f4e50
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy/_manager.py
@@ -0,0 +1,373 @@
+import inspect
+import sys
+import warnings
+
+from . import _tracing
+from ._callers import _Result, _multicall
+from ._hooks import HookImpl, _HookRelay, _HookCaller, normalize_hookimpl_opts
+
+if sys.version_info >= (3, 8):
+    from importlib import metadata as importlib_metadata
+else:
+    import importlib_metadata
+
+
+def _warn_for_function(warning, function):
+    warnings.warn_explicit(
+        warning,
+        type(warning),
+        lineno=function.__code__.co_firstlineno,
+        filename=function.__code__.co_filename,
+    )
+
+
+class PluginValidationError(Exception):
+    """plugin failed validation.
+
+    :param object plugin: the plugin which failed validation,
+        may be a module or an arbitrary object.
+    """
+
+    def __init__(self, plugin, message):
+        self.plugin = plugin
+        super(Exception, self).__init__(message)
+
+
+class DistFacade:
+    """Emulate a pkg_resources Distribution"""
+
+    def __init__(self, dist):
+        self._dist = dist
+
+    @property
+    def project_name(self):
+        return self.metadata["name"]
+
+    def __getattr__(self, attr, default=None):
+        return getattr(self._dist, attr, default)
+
+    def __dir__(self):
+        return sorted(dir(self._dist) + ["_dist", "project_name"])
+
+
+class PluginManager:
+    """Core :py:class:`.PluginManager` class which manages registration
+    of plugin objects and 1:N hook calling.
+
+    You can register new hooks by calling :py:meth:`add_hookspecs(module_or_class)
+    <.PluginManager.add_hookspecs>`.
+    You can register plugin objects (which contain hooks) by calling
+    :py:meth:`register(plugin) <.PluginManager.register>`.  The :py:class:`.PluginManager`
+    is initialized with a prefix that is searched for in the names of the dict
+    of registered plugin objects.
+
+    For debugging purposes you can call :py:meth:`.PluginManager.enable_tracing`
+    which will subsequently send debug information to the trace helper.
+    """
+
+    def __init__(self, project_name):
+        self.project_name = project_name
+        self._name2plugin = {}
+        self._plugin2hookcallers = {}
+        self._plugin_distinfo = []
+        self.trace = _tracing.TagTracer().get("pluginmanage")
+        self.hook = _HookRelay()
+        self._inner_hookexec = _multicall
+
+    def _hookexec(self, hook_name, methods, kwargs, firstresult):
+        # called from all hookcaller instances.
+        # enable_tracing will set its own wrapping function at self._inner_hookexec
+        return self._inner_hookexec(hook_name, methods, kwargs, firstresult)
+
+    def register(self, plugin, name=None):
+        """Register a plugin and return its canonical name or ``None`` if the name
+        is blocked from registering.  Raise a :py:class:`ValueError` if the plugin
+        is already registered."""
+        plugin_name = name or self.get_canonical_name(plugin)
+
+        if plugin_name in self._name2plugin or plugin in self._plugin2hookcallers:
+            if self._name2plugin.get(plugin_name, -1) is None:
+                return  # blocked plugin, return None to indicate no registration
+            raise ValueError(
+                "Plugin already registered: %s=%s\n%s"
+                % (plugin_name, plugin, self._name2plugin)
+            )
+
+        # XXX if an error happens we should make sure no state has been
+        # changed at point of return
+        self._name2plugin[plugin_name] = plugin
+
+        # register matching hook implementations of the plugin
+        self._plugin2hookcallers[plugin] = hookcallers = []
+        for name in dir(plugin):
+            hookimpl_opts = self.parse_hookimpl_opts(plugin, name)
+            if hookimpl_opts is not None:
+                normalize_hookimpl_opts(hookimpl_opts)
+                method = getattr(plugin, name)
+                hookimpl = HookImpl(plugin, plugin_name, method, hookimpl_opts)
+                name = hookimpl_opts.get("specname") or name
+                hook = getattr(self.hook, name, None)
+                if hook is None:
+                    hook = _HookCaller(name, self._hookexec)
+                    setattr(self.hook, name, hook)
+                elif hook.has_spec():
+                    self._verify_hook(hook, hookimpl)
+                    hook._maybe_apply_history(hookimpl)
+                hook._add_hookimpl(hookimpl)
+                hookcallers.append(hook)
+        return plugin_name
+
+    def parse_hookimpl_opts(self, plugin, name):
+        method = getattr(plugin, name)
+        if not inspect.isroutine(method):
+            return
+        try:
+            res = getattr(method, self.project_name + "_impl", None)
+        except Exception:
+            res = {}
+        if res is not None and not isinstance(res, dict):
+            # false positive
+            res = None
+        return res
+
+    def unregister(self, plugin=None, name=None):
+        """unregister a plugin object and all its contained hook implementations
+        from internal data structures."""
+        if name is None:
+            assert plugin is not None, "one of name or plugin needs to be specified"
+            name = self.get_name(plugin)
+
+        if plugin is None:
+            plugin = self.get_plugin(name)
+
+        # if self._name2plugin[name] == None registration was blocked: ignore
+        if self._name2plugin.get(name):
+            del self._name2plugin[name]
+
+        for hookcaller in self._plugin2hookcallers.pop(plugin, []):
+            hookcaller._remove_plugin(plugin)
+
+        return plugin
+
+    def set_blocked(self, name):
+        """block registrations of the given name, unregister if already registered."""
+        self.unregister(name=name)
+        self._name2plugin[name] = None
+
+    def is_blocked(self, name):
+        """return ``True`` if the given plugin name is blocked."""
+        return name in self._name2plugin and self._name2plugin[name] is None
+
+    def add_hookspecs(self, module_or_class):
+        """add new hook specifications defined in the given ``module_or_class``.
+        Functions are recognized if they have been decorated accordingly."""
+        names = []
+        for name in dir(module_or_class):
+            spec_opts = self.parse_hookspec_opts(module_or_class, name)
+            if spec_opts is not None:
+                hc = getattr(self.hook, name, None)
+                if hc is None:
+                    hc = _HookCaller(name, self._hookexec, module_or_class, spec_opts)
+                    setattr(self.hook, name, hc)
+                else:
+                    # plugins registered this hook without knowing the spec
+                    hc.set_specification(module_or_class, spec_opts)
+                    for hookfunction in hc.get_hookimpls():
+                        self._verify_hook(hc, hookfunction)
+                names.append(name)
+
+        if not names:
+            raise ValueError(
+                f"did not find any {self.project_name!r} hooks in {module_or_class!r}"
+            )
+
+    def parse_hookspec_opts(self, module_or_class, name):
+        method = getattr(module_or_class, name)
+        return getattr(method, self.project_name + "_spec", None)
+
+    def get_plugins(self):
+        """return the set of registered plugins."""
+        return set(self._plugin2hookcallers)
+
+    def is_registered(self, plugin):
+        """Return ``True`` if the plugin is already registered."""
+        return plugin in self._plugin2hookcallers
+
+    def get_canonical_name(self, plugin):
+        """Return canonical name for a plugin object. Note that a plugin
+        may be registered under a different name which was specified
+        by the caller of :py:meth:`register(plugin, name) <.PluginManager.register>`.
+        To obtain the name of an registered plugin use :py:meth:`get_name(plugin)
+        <.PluginManager.get_name>` instead."""
+        return getattr(plugin, "__name__", None) or str(id(plugin))
+
+    def get_plugin(self, name):
+        """Return a plugin or ``None`` for the given name."""
+        return self._name2plugin.get(name)
+
+    def has_plugin(self, name):
+        """Return ``True`` if a plugin with the given name is registered."""
+        return self.get_plugin(name) is not None
+
+    def get_name(self, plugin):
+        """Return name for registered plugin or ``None`` if not registered."""
+        for name, val in self._name2plugin.items():
+            if plugin == val:
+                return name
+
+    def _verify_hook(self, hook, hookimpl):
+        if hook.is_historic() and hookimpl.hookwrapper:
+            raise PluginValidationError(
+                hookimpl.plugin,
+                "Plugin %r\nhook %r\nhistoric incompatible to hookwrapper"
+                % (hookimpl.plugin_name, hook.name),
+            )
+
+        if hook.spec.warn_on_impl:
+            _warn_for_function(hook.spec.warn_on_impl, hookimpl.function)
+
+        # positional arg checking
+        notinspec = set(hookimpl.argnames) - set(hook.spec.argnames)
+        if notinspec:
+            raise PluginValidationError(
+                hookimpl.plugin,
+                "Plugin %r for hook %r\nhookimpl definition: %s\n"
+                "Argument(s) %s are declared in the hookimpl but "
+                "can not be found in the hookspec"
+                % (
+                    hookimpl.plugin_name,
+                    hook.name,
+                    _formatdef(hookimpl.function),
+                    notinspec,
+                ),
+            )
+
+        if hookimpl.hookwrapper and not inspect.isgeneratorfunction(hookimpl.function):
+            raise PluginValidationError(
+                hookimpl.plugin,
+                "Plugin %r for hook %r\nhookimpl definition: %s\n"
+                "Declared as hookwrapper=True but function is not a generator function"
+                % (hookimpl.plugin_name, hook.name, _formatdef(hookimpl.function)),
+            )
+
+    def check_pending(self):
+        """Verify that all hooks which have not been verified against
+        a hook specification are optional, otherwise raise :py:class:`.PluginValidationError`."""
+        for name in self.hook.__dict__:
+            if name[0] != "_":
+                hook = getattr(self.hook, name)
+                if not hook.has_spec():
+                    for hookimpl in hook.get_hookimpls():
+                        if not hookimpl.optionalhook:
+                            raise PluginValidationError(
+                                hookimpl.plugin,
+                                "unknown hook %r in plugin %r"
+                                % (name, hookimpl.plugin),
+                            )
+
+    def load_setuptools_entrypoints(self, group, name=None):
+        """Load modules from querying the specified setuptools ``group``.
+
+        :param str group: entry point group to load plugins
+        :param str name: if given, loads only plugins with the given ``name``.
+        :rtype: int
+        :return: return the number of loaded plugins by this call.
+        """
+        count = 0
+        for dist in list(importlib_metadata.distributions()):
+            for ep in dist.entry_points:
+                if (
+                    ep.group != group
+                    or (name is not None and ep.name != name)
+                    # already registered
+                    or self.get_plugin(ep.name)
+                    or self.is_blocked(ep.name)
+                ):
+                    continue
+                plugin = ep.load()
+                self.register(plugin, name=ep.name)
+                self._plugin_distinfo.append((plugin, DistFacade(dist)))
+                count += 1
+        return count
+
+    def list_plugin_distinfo(self):
+        """return list of distinfo/plugin tuples for all setuptools registered
+        plugins."""
+        return list(self._plugin_distinfo)
+
+    def list_name_plugin(self):
+        """return list of name/plugin pairs."""
+        return list(self._name2plugin.items())
+
+    def get_hookcallers(self, plugin):
+        """get all hook callers for the specified plugin."""
+        return self._plugin2hookcallers.get(plugin)
+
+    def add_hookcall_monitoring(self, before, after):
+        """add before/after tracing functions for all hooks
+        and return an undo function which, when called,
+        will remove the added tracers.
+
+        ``before(hook_name, hook_impls, kwargs)`` will be called ahead
+        of all hook calls and receive a hookcaller instance, a list
+        of HookImpl instances and the keyword arguments for the hook call.
+
+        ``after(outcome, hook_name, hook_impls, kwargs)`` receives the
+        same arguments as ``before`` but also a :py:class:`pluggy._callers._Result` object
+        which represents the result of the overall hook call.
+        """
+        oldcall = self._inner_hookexec
+
+        def traced_hookexec(hook_name, hook_impls, kwargs, firstresult):
+            before(hook_name, hook_impls, kwargs)
+            outcome = _Result.from_call(
+                lambda: oldcall(hook_name, hook_impls, kwargs, firstresult)
+            )
+            after(outcome, hook_name, hook_impls, kwargs)
+            return outcome.get_result()
+
+        self._inner_hookexec = traced_hookexec
+
+        def undo():
+            self._inner_hookexec = oldcall
+
+        return undo
+
+    def enable_tracing(self):
+        """enable tracing of hook calls and return an undo function."""
+        hooktrace = self.trace.root.get("hook")
+
+        def before(hook_name, methods, kwargs):
+            hooktrace.root.indent += 1
+            hooktrace(hook_name, kwargs)
+
+        def after(outcome, hook_name, methods, kwargs):
+            if outcome.excinfo is None:
+                hooktrace("finish", hook_name, "-->", outcome.get_result())
+            hooktrace.root.indent -= 1
+
+        return self.add_hookcall_monitoring(before, after)
+
+    def subset_hook_caller(self, name, remove_plugins):
+        """Return a new :py:class:`._hooks._HookCaller` instance for the named method
+        which manages calls to all registered plugins except the
+        ones from remove_plugins."""
+        orig = getattr(self.hook, name)
+        plugins_to_remove = [plug for plug in remove_plugins if hasattr(plug, name)]
+        if plugins_to_remove:
+            hc = _HookCaller(
+                orig.name, orig._hookexec, orig.spec.namespace, orig.spec.opts
+            )
+            for hookimpl in orig.get_hookimpls():
+                plugin = hookimpl.plugin
+                if plugin not in plugins_to_remove:
+                    hc._add_hookimpl(hookimpl)
+                    # we also keep track of this hook caller so it
+                    # gets properly removed on plugin unregistration
+                    self._plugin2hookcallers.setdefault(plugin, []).append(hc)
+            return hc
+        return orig
+
+
+def _formatdef(func):
+    return f"{func.__name__}{inspect.signature(func)}"
diff --git a/myenv/lib/python3.9/site-packages/pluggy/_result.py b/myenv/lib/python3.9/site-packages/pluggy/_result.py
new file mode 100644
index 0000000..4c1f7f1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy/_result.py
@@ -0,0 +1,60 @@
+"""
+Hook wrapper "result" utilities.
+"""
+import sys
+
+
+def _raise_wrapfail(wrap_controller, msg):
+    co = wrap_controller.gi_code
+    raise RuntimeError(
+        "wrap_controller at %r %s:%d %s"
+        % (co.co_name, co.co_filename, co.co_firstlineno, msg)
+    )
+
+
+class HookCallError(Exception):
+    """Hook was called wrongly."""
+
+
+class _Result:
+    def __init__(self, result, excinfo):
+        self._result = result
+        self._excinfo = excinfo
+
+    @property
+    def excinfo(self):
+        return self._excinfo
+
+    @classmethod
+    def from_call(cls, func):
+        __tracebackhide__ = True
+        result = excinfo = None
+        try:
+            result = func()
+        except BaseException:
+            excinfo = sys.exc_info()
+
+        return cls(result, excinfo)
+
+    def force_result(self, result):
+        """Force the result(s) to ``result``.
+
+        If the hook was marked as a ``firstresult`` a single value should
+        be set otherwise set a (modified) list of results. Any exceptions
+        found during invocation will be deleted.
+        """
+        self._result = result
+        self._excinfo = None
+
+    def get_result(self):
+        """Get the result(s) for this hook call.
+
+        If the hook was marked as a ``firstresult`` only a single value
+        will be returned otherwise a list of results.
+        """
+        __tracebackhide__ = True
+        if self._excinfo is None:
+            return self._result
+        else:
+            ex = self._excinfo
+            raise ex[1].with_traceback(ex[2])
diff --git a/myenv/lib/python3.9/site-packages/pluggy/_tracing.py b/myenv/lib/python3.9/site-packages/pluggy/_tracing.py
new file mode 100644
index 0000000..82c0162
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy/_tracing.py
@@ -0,0 +1,62 @@
+"""
+Tracing utils
+"""
+
+
+class TagTracer:
+    def __init__(self):
+        self._tags2proc = {}
+        self._writer = None
+        self.indent = 0
+
+    def get(self, name):
+        return TagTracerSub(self, (name,))
+
+    def _format_message(self, tags, args):
+        if isinstance(args[-1], dict):
+            extra = args[-1]
+            args = args[:-1]
+        else:
+            extra = {}
+
+        content = " ".join(map(str, args))
+        indent = "  " * self.indent
+
+        lines = ["{}{} [{}]\n".format(indent, content, ":".join(tags))]
+
+        for name, value in extra.items():
+            lines.append(f"{indent}    {name}: {value}\n")
+
+        return "".join(lines)
+
+    def _processmessage(self, tags, args):
+        if self._writer is not None and args:
+            self._writer(self._format_message(tags, args))
+        try:
+            processor = self._tags2proc[tags]
+        except KeyError:
+            pass
+        else:
+            processor(tags, args)
+
+    def setwriter(self, writer):
+        self._writer = writer
+
+    def setprocessor(self, tags, processor):
+        if isinstance(tags, str):
+            tags = tuple(tags.split(":"))
+        else:
+            assert isinstance(tags, tuple)
+        self._tags2proc[tags] = processor
+
+
+class TagTracerSub:
+    def __init__(self, root, tags):
+        self.root = root
+        self.tags = tags
+
+    def __call__(self, *args):
+        self.root._processmessage(self.tags, args)
+
+    def get(self, name):
+        return self.__class__(self.root, self.tags + (name,))
diff --git a/myenv/lib/python3.9/site-packages/pluggy/_version.py b/myenv/lib/python3.9/site-packages/pluggy/_version.py
new file mode 100644
index 0000000..7f0e082
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pluggy/_version.py
@@ -0,0 +1,5 @@
+# coding: utf-8
+# file generated by setuptools_scm
+# don't change, don't track in version control
+version = '1.0.0'
+version_tuple = (1, 0, 0)
diff --git a/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/LICENSE
new file mode 100644
index 0000000..31ecdfb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/LICENSE
@@ -0,0 +1,19 @@
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+     
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+ 
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+
diff --git a/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/METADATA
new file mode 100644
index 0000000..a14febe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/METADATA
@@ -0,0 +1,69 @@
+Metadata-Version: 2.1
+Name: py
+Version: 1.11.0
+Summary: library with cross-python path, ini-parsing, io, code, log facilities
+Home-page: https://py.readthedocs.io/
+Author: holger krekel, Ronny Pfannschmidt, Benjamin Peterson and others
+Author-email: pytest-dev@python.org
+License: MIT license
+Platform: unix
+Platform: linux
+Platform: osx
+Platform: cygwin
+Platform: win32
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
+
+.. image:: https://img.shields.io/pypi/v/py.svg
+    :target: https://pypi.org/project/py
+
+.. image:: https://img.shields.io/conda/vn/conda-forge/py.svg
+    :target: https://anaconda.org/conda-forge/py
+
+.. image:: https://img.shields.io/pypi/pyversions/py.svg
+  :target: https://pypi.org/project/py
+
+.. image:: https://github.com/pytest-dev/py/workflows/build/badge.svg
+  :target: https://github.com/pytest-dev/py/actions
+
+
+**NOTE**: this library is in **maintenance mode** and should not be used in new code.
+
+The py lib is a Python development support library featuring
+the following tools and modules:
+
+* ``py.path``:  uniform local and svn path objects  -> please use pathlib/pathlib2 instead
+* ``py.apipkg``:  explicit API control and lazy-importing -> please use the standalone package instead
+* ``py.iniconfig``:  easy parsing of .ini files -> please use the standalone package instead
+* ``py.code``: dynamic code generation and introspection (deprecated, moved to ``pytest`` as a implementation detail).
+
+**NOTE**: prior to the 1.4 release this distribution used to
+contain py.test which is now its own package, see https://docs.pytest.org
+
+For questions and more information please visit https://py.readthedocs.io
+
+Bugs and issues: https://github.com/pytest-dev/py
+
+Authors: Holger Krekel and others, 2004-2017
+
+
diff --git a/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/RECORD
new file mode 100644
index 0000000..7a0c488
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/RECORD
@@ -0,0 +1,65 @@
+py/__init__.py,sha256=56vBwkYKqNTj2StRTFjqa-p51_y6qVkvoyj10NyThtY,6022
+py/__init__.pyi,sha256=J0oNF3G0rcZL521oXyfWg7T053Spb2DmB5eDe40LcpY,341
+py/__metainfo.py,sha256=-APUcNtmuKgbYF8JfzlEyULMfp67uDDnRFKiu9nmxD0,55
+py/_builtin.py,sha256=c9wCmZ0nsZtFARJoZ5Ia7RxJuBo1Bp7IHjLC5uQvIug,4021
+py/_error.py,sha256=59i7uYaoQlEB1QyRakvuIHh09fKGAOC521R4Rb1KVcI,2917
+py/_std.py,sha256=JnzTePDF0TNzPKjYHIRMKwuwzE6bvLOV8q9r7FlLZZ8,668
+py/_version.py,sha256=Xs0eR54RO9PHie_bsnHE9MaEmKMBiyxDAkf-poAVEX0,144
+py/_xmlgen.py,sha256=y-PCg1hZpIozJi7GXSRZv6saT_0nnNZ2D-6ue_A2xww,8364
+py/error.pyi,sha256=fQOaF1TOx_pK1StqWC_6d6DAGzSuPJ6vR6Fd_5lRol0,3409
+py/iniconfig.pyi,sha256=-4KOctzq28ohRmTZsqlH6aylyFqsNKxYqtk1dteypi4,1205
+py/io.pyi,sha256=nuC3RIVMXOp-xsaXBbPYNZHxzcCEHgDdIpS9yRmJR-g,5277
+py/path.pyi,sha256=OmDEqkp756dcWHq10Gwaw8pXtIABAdbg9mSAUCQPPyk,7168
+py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py/test.py,sha256=1VLPdbBKEOai2WAKABJAbVdRfcJxtff2x2mXNmQgDL8,222
+py/xml.pyi,sha256=SBnALd6w7VwqrGYtEm4ESJ_u9iD7LVH7LWFZ3Y7xAoo,787
+py/_code/__init__.py,sha256=PsNXpJtPfle_IbAgLXQTO5YJyHi8N1xR8YtetmLs1Ac,46
+py/_code/_assertionnew.py,sha256=52ADFyZkW2aks5iFFKStINwz_2fFTomBBz40AplZ4vI,11450
+py/_code/_assertionold.py,sha256=HaDKP9esnh95ZUTZRH2gUcjGFHK4MAHi8Bk18rFBycA,17869
+py/_code/_py2traceback.py,sha256=QdRC-rUpHkhtfRq5EuBub-y6Tna_Z5BlXqBYtvf0-hE,2765
+py/_code/assertion.py,sha256=UgPH8qihF0qOIWGK-DR-usrJZztz-Njj-0cBuuqwjug,3174
+py/_code/code.py,sha256=5fTjcWOdqd8Xm37g82knNL2uK4ymp9yLpnmQrc9uWzI,27492
+py/_code/source.py,sha256=hZIzxUbKhgOElxeaiYlxEisxOevfg_OgxugXxpbMmGA,14050
+py/_io/__init__.py,sha256=mroFkl-vhr0GhoOU33DR8CW5a23AmWEMkYd0Xkrn9gQ,29
+py/_io/capture.py,sha256=UD23HRIjE9sZs70RaPJj5Zk8XlKSqJpqMR8-AqlOv80,11652
+py/_io/saferepr.py,sha256=vPzOq5XoGYzdTf5-zn3_2ib6w4IdPP2URwenkDkMO8s,2483
+py/_io/terminalwriter.py,sha256=bKN8Gnd5gKZeXALbCLZkfzkjF-jGbXPyID_lxCGezX4,14714
+py/_log/__init__.py,sha256=2GE1ao7mud57-K6VXgmItZJsMDJBR500Xj7_-ou_jY4,74
+py/_log/log.py,sha256=arQ8lvZUIPlwDo6ffg6lNvAQ0x8U1yPRhkMLtHUQKx8,6003
+py/_log/warning.py,sha256=wufxpNU8YBXKNNcCZsZnaJaaNuKEjuvsIa1V-HE6YIk,2565
+py/_path/__init__.py,sha256=uBkaNhYAPiTOe8cj8WWD7rpM06XR6H0E3KghK6MgBpA,32
+py/_path/cacheutil.py,sha256=jQ0wk4Goqr_bIE8wGdr-CTiMD6dpcgdqyngGmMO48pY,3333
+py/_path/common.py,sha256=EC18Pl6zYGGMzHkDgGNbLC2W23ajtDwHMJOm3jNMdOA,14818
+py/_path/local.py,sha256=-QdTI95H2gtAPAfE4WhvRQq_2qMjlNBVRSp6_reg7kE,36759
+py/_path/svnurl.py,sha256=OC0w9p_pNpSncwgvD61Pcr4r2NrFztYb-OngD8RzNi8,14715
+py/_path/svnwc.py,sha256=IKJkzNwevB7zxxW9OIhH5n4wesAnJQcJTgxjxdgcqUk,43825
+py/_process/__init__.py,sha256=e7LQPDo7Q-LR9VjcRithvT4UoszeZ80NEeUvc9j4H-o,40
+py/_process/cmdexec.py,sha256=bTtnRydYMvW5w-K_qzRRRgycU8p4IfWQB5ymzLXMdkU,1814
+py/_process/forkedfunc.py,sha256=ZTGHp8kp5Z1icj0TonoPRmpcm64pyaVVfiRC9c5TnGU,3692
+py/_process/killproc.py,sha256=0fj_w_A8Mi_ZBJd9Koy_NnmMNoNYttb713943WxTVxw,648
+py/_vendored_packages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py/_vendored_packages/apipkg/__init__.py,sha256=gpbD3O57S9f-LsO2e-XwI6IGISayicfnCq3B5y_8frg,6978
+py/_vendored_packages/apipkg/version.py,sha256=bgZFg-f3UKhgE-z2w8RoFrwqRBzJBZkM4_jKFiYB9eU,142
+py/_vendored_packages/iniconfig/__init__.py,sha256=-pBe5AF_6aAwo1CxJQ8i_zJq6ejc6IxHta7qk2tNJhY,5208
+py/_vendored_packages/iniconfig/__init__.pyi,sha256=-4KOctzq28ohRmTZsqlH6aylyFqsNKxYqtk1dteypi4,1205
+py/_vendored_packages/iniconfig/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py-1.11.0.dist-info/LICENSE,sha256=KvaAw570k_uCgwNW0dPfGstaBgM8ui3sehniHKp3qGY,1061
+py-1.11.0.dist-info/METADATA,sha256=j1AvLZH7HqTO06dYJbYYGypPxkhP9IZjlTPSOY82ehM,2811
+py-1.11.0.dist-info/WHEEL,sha256=WzZ8cwjh8l0jtULNjYq1Hpr-WCqCRgPr--TX4P5I1Wo,110
+py-1.11.0.dist-info/top_level.txt,sha256=rwh8_ukTaGscjyhGkBVcsGOMdc-Cfdz2QH7BKGENv-4,3
+py/_vendored_packages/apipkg-2.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+py/_vendored_packages/apipkg-2.0.0.dist-info/LICENSE,sha256=6J7tEHTTqUMZi6E5uAhE9bRFuGC7p0qK6twGEFZhZOo,1054
+py/_vendored_packages/apipkg-2.0.0.dist-info/METADATA,sha256=GqNwkxraK5UTxObLVXTLc2UqktOPwZnKqdk2ThzHX0A,4292
+py/_vendored_packages/apipkg-2.0.0.dist-info/RECORD,sha256=VqARwZMQSTLsSY4QcLChtdNYtH1_llKRb1sGiK7wRm4,801
+py/_vendored_packages/apipkg-2.0.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py/_vendored_packages/apipkg-2.0.0.dist-info/WHEEL,sha256=WzZ8cwjh8l0jtULNjYq1Hpr-WCqCRgPr--TX4P5I1Wo,110
+py/_vendored_packages/apipkg-2.0.0.dist-info/top_level.txt,sha256=3TGS6nmN7kjxhUK4LpPCB3QkQI34QYGrT0ZQGWajoZ8,7
+py/_vendored_packages/iniconfig-1.1.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+py/_vendored_packages/iniconfig-1.1.1.dist-info/LICENSE,sha256=KvaAw570k_uCgwNW0dPfGstaBgM8ui3sehniHKp3qGY,1061
+py/_vendored_packages/iniconfig-1.1.1.dist-info/METADATA,sha256=_4-oFKpRXuZv5rzepScpXRwhq6DzqsgbnA5ZpgMUMcs,2405
+py/_vendored_packages/iniconfig-1.1.1.dist-info/RECORD,sha256=13Pl7e4y-9Te0285E_6IMvnDQzT4NawZCXhkodtXlk4,863
+py/_vendored_packages/iniconfig-1.1.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py/_vendored_packages/iniconfig-1.1.1.dist-info/WHEEL,sha256=ADKeyaGyKF5DwBNE0sRE5pvW-bSkFMJfBuhzZ3rceP4,110
+py/_vendored_packages/iniconfig-1.1.1.dist-info/top_level.txt,sha256=7KfM0fugdlToj9UW7enKXk2HYALQD8qHiyKtjhSzgN8,10
+py-1.11.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+py-1.11.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/WHEEL
new file mode 100644
index 0000000..b733a60
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/top_level.txt
new file mode 100644
index 0000000..edfce78
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py-1.11.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+py
diff --git a/myenv/lib/python3.9/site-packages/py/__init__.py b/myenv/lib/python3.9/site-packages/py/__init__.py
new file mode 100644
index 0000000..b892ce1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/__init__.py
@@ -0,0 +1,156 @@
+"""
+pylib: rapid testing and development utils
+
+this module uses apipkg.py for lazy-loading sub modules
+and classes.  The initpkg-dictionary  below specifies
+name->value mappings where value can be another namespace
+dictionary or an import path.
+
+(c) Holger Krekel and others, 2004-2014
+"""
+from py._error import error
+
+try:
+    from py._vendored_packages import apipkg
+    lib_not_mangled_by_packagers = True
+    vendor_prefix = '._vendored_packages.'
+except ImportError:
+    import apipkg
+    lib_not_mangled_by_packagers = False
+    vendor_prefix = ''
+
+try:
+    from ._version import version as __version__
+except ImportError:
+    # broken installation, we don't even try
+    __version__ = "unknown"
+
+
+apipkg.initpkg(__name__, attr={'_apipkg': apipkg, 'error': error}, exportdefs={
+    # access to all standard lib modules
+    'std': '._std:std',
+
+    '_pydir' : '.__metainfo:pydir',
+    'version': 'py:__version__', # backward compatibility
+
+    # pytest-2.0 has a flat namespace, we use alias modules
+    # to keep old references compatible
+    'test' : 'pytest',
+
+    # hook into the top-level standard library
+    'process' : {
+        '__doc__'        : '._process:__doc__',
+        'cmdexec'        : '._process.cmdexec:cmdexec',
+        'kill'           : '._process.killproc:kill',
+        'ForkedFunc'     : '._process.forkedfunc:ForkedFunc',
+    },
+
+    'apipkg' : {
+        'initpkg'   : vendor_prefix + 'apipkg:initpkg',
+        'ApiModule' : vendor_prefix + 'apipkg:ApiModule',
+    },
+
+    'iniconfig' : {
+        'IniConfig'      : vendor_prefix + 'iniconfig:IniConfig',
+        'ParseError'     : vendor_prefix + 'iniconfig:ParseError',
+    },
+
+    'path' : {
+        '__doc__'        : '._path:__doc__',
+        'svnwc'          : '._path.svnwc:SvnWCCommandPath',
+        'svnurl'         : '._path.svnurl:SvnCommandPath',
+        'local'          : '._path.local:LocalPath',
+        'SvnAuth'        : '._path.svnwc:SvnAuth',
+    },
+
+    # python inspection/code-generation API
+    'code' : {
+        '__doc__'           : '._code:__doc__',
+        'compile'           : '._code.source:compile_',
+        'Source'            : '._code.source:Source',
+        'Code'              : '._code.code:Code',
+        'Frame'             : '._code.code:Frame',
+        'ExceptionInfo'     : '._code.code:ExceptionInfo',
+        'Traceback'         : '._code.code:Traceback',
+        'getfslineno'       : '._code.source:getfslineno',
+        'getrawcode'        : '._code.code:getrawcode',
+        'patch_builtins'    : '._code.code:patch_builtins',
+        'unpatch_builtins'  : '._code.code:unpatch_builtins',
+        '_AssertionError'   : '._code.assertion:AssertionError',
+        '_reinterpret_old'  : '._code.assertion:reinterpret_old',
+        '_reinterpret'      : '._code.assertion:reinterpret',
+        '_reprcompare'      : '._code.assertion:_reprcompare',
+        '_format_explanation' : '._code.assertion:_format_explanation',
+    },
+
+    # backports and additions of builtins
+    'builtin' : {
+        '__doc__'        : '._builtin:__doc__',
+        'enumerate'      : '._builtin:enumerate',
+        'reversed'       : '._builtin:reversed',
+        'sorted'         : '._builtin:sorted',
+        'any'            : '._builtin:any',
+        'all'            : '._builtin:all',
+        'set'            : '._builtin:set',
+        'frozenset'      : '._builtin:frozenset',
+        'BaseException'  : '._builtin:BaseException',
+        'GeneratorExit'  : '._builtin:GeneratorExit',
+        '_sysex'         : '._builtin:_sysex',
+        'print_'         : '._builtin:print_',
+        '_reraise'       : '._builtin:_reraise',
+        '_tryimport'     : '._builtin:_tryimport',
+        'exec_'          : '._builtin:exec_',
+        '_basestring'    : '._builtin:_basestring',
+        '_totext'        : '._builtin:_totext',
+        '_isbytes'       : '._builtin:_isbytes',
+        '_istext'        : '._builtin:_istext',
+        '_getimself'     : '._builtin:_getimself',
+        '_getfuncdict'   : '._builtin:_getfuncdict',
+        '_getcode'       : '._builtin:_getcode',
+        'builtins'       : '._builtin:builtins',
+        'execfile'       : '._builtin:execfile',
+        'callable'       : '._builtin:callable',
+        'bytes'       : '._builtin:bytes',
+        'text'       : '._builtin:text',
+    },
+
+    # input-output helping
+    'io' : {
+        '__doc__'             : '._io:__doc__',
+        'dupfile'             : '._io.capture:dupfile',
+        'TextIO'              : '._io.capture:TextIO',
+        'BytesIO'             : '._io.capture:BytesIO',
+        'FDCapture'           : '._io.capture:FDCapture',
+        'StdCapture'          : '._io.capture:StdCapture',
+        'StdCaptureFD'        : '._io.capture:StdCaptureFD',
+        'TerminalWriter'      : '._io.terminalwriter:TerminalWriter',
+        'ansi_print'          : '._io.terminalwriter:ansi_print',
+        'get_terminal_width'  : '._io.terminalwriter:get_terminal_width',
+        'saferepr'            : '._io.saferepr:saferepr',
+    },
+
+    # small and mean xml/html generation
+    'xml' : {
+        '__doc__'            : '._xmlgen:__doc__',
+        'html'               : '._xmlgen:html',
+        'Tag'                : '._xmlgen:Tag',
+        'raw'                : '._xmlgen:raw',
+        'Namespace'          : '._xmlgen:Namespace',
+        'escape'             : '._xmlgen:escape',
+    },
+
+    'log' : {
+        # logging API ('producers' and 'consumers' connected via keywords)
+        '__doc__'            : '._log:__doc__',
+        '_apiwarn'           : '._log.warning:_apiwarn',
+        'Producer'           : '._log.log:Producer',
+        'setconsumer'        : '._log.log:setconsumer',
+        '_setstate'          : '._log.log:setstate',
+        '_getstate'          : '._log.log:getstate',
+        'Path'               : '._log.log:Path',
+        'STDOUT'             : '._log.log:STDOUT',
+        'STDERR'             : '._log.log:STDERR',
+        'Syslog'             : '._log.log:Syslog',
+    },
+
+})
diff --git a/myenv/lib/python3.9/site-packages/py/__init__.pyi b/myenv/lib/python3.9/site-packages/py/__init__.pyi
new file mode 100644
index 0000000..96859e3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/__init__.pyi
@@ -0,0 +1,20 @@
+from typing import Any
+
+# py allows to use e.g. py.path.local even without importing py.path.
+# So import implicitly.
+from . import error
+from . import iniconfig
+from . import path
+from . import io
+from . import xml
+
+__version__: str
+
+# Untyped modules below here.
+std: Any
+test: Any
+process: Any
+apipkg: Any
+code: Any
+builtin: Any
+log: Any
diff --git a/myenv/lib/python3.9/site-packages/py/__metainfo.py b/myenv/lib/python3.9/site-packages/py/__metainfo.py
new file mode 100644
index 0000000..12581eb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/__metainfo.py
@@ -0,0 +1,2 @@
+import py
+pydir = py.path.local(py.__file__).dirpath()
diff --git a/myenv/lib/python3.9/site-packages/py/_builtin.py b/myenv/lib/python3.9/site-packages/py/_builtin.py
new file mode 100644
index 0000000..ddc89fc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_builtin.py
@@ -0,0 +1,149 @@
+import sys
+
+
+# Passthrough for builtins supported with py27.
+BaseException = BaseException
+GeneratorExit = GeneratorExit
+_sysex = (KeyboardInterrupt, SystemExit, MemoryError, GeneratorExit)
+all = all
+any = any
+callable = callable
+enumerate = enumerate
+reversed = reversed
+set, frozenset = set, frozenset
+sorted = sorted
+
+
+if sys.version_info >= (3, 0):
+    exec("print_ = print ; exec_=exec")
+    import builtins
+
+    # some backward compatibility helpers
+    _basestring = str
+    def _totext(obj, encoding=None, errors=None):
+        if isinstance(obj, bytes):
+            if errors is None:
+                obj = obj.decode(encoding)
+            else:
+                obj = obj.decode(encoding, errors)
+        elif not isinstance(obj, str):
+            obj = str(obj)
+        return obj
+
+    def _isbytes(x):
+        return isinstance(x, bytes)
+
+    def _istext(x):
+        return isinstance(x, str)
+
+    text = str
+    bytes = bytes
+
+    def _getimself(function):
+        return getattr(function, '__self__', None)
+
+    def _getfuncdict(function):
+        return getattr(function, "__dict__", None)
+
+    def _getcode(function):
+        return getattr(function, "__code__", None)
+
+    def execfile(fn, globs=None, locs=None):
+        if globs is None:
+            back = sys._getframe(1)
+            globs = back.f_globals
+            locs = back.f_locals
+            del back
+        elif locs is None:
+            locs = globs
+        fp = open(fn, "r")
+        try:
+            source = fp.read()
+        finally:
+            fp.close()
+        co = compile(source, fn, "exec", dont_inherit=True)
+        exec_(co, globs, locs)
+
+else:
+    import __builtin__ as builtins
+    _totext = unicode
+    _basestring = basestring
+    text = unicode
+    bytes = str
+    execfile = execfile
+    callable = callable
+    def _isbytes(x):
+        return isinstance(x, str)
+    def _istext(x):
+        return isinstance(x, unicode)
+
+    def _getimself(function):
+        return getattr(function, 'im_self', None)
+
+    def _getfuncdict(function):
+        return getattr(function, "__dict__", None)
+
+    def _getcode(function):
+        try:
+            return getattr(function, "__code__")
+        except AttributeError:
+            return getattr(function, "func_code", None)
+
+    def print_(*args, **kwargs):
+        """ minimal backport of py3k print statement. """
+        sep = ' '
+        if 'sep' in kwargs:
+            sep = kwargs.pop('sep')
+        end = '\n'
+        if 'end' in kwargs:
+            end = kwargs.pop('end')
+        file = 'file' in kwargs and kwargs.pop('file') or sys.stdout
+        if kwargs:
+            args = ", ".join([str(x) for x in kwargs])
+            raise TypeError("invalid keyword arguments: %s" % args)
+        at_start = True
+        for x in args:
+            if not at_start:
+                file.write(sep)
+            file.write(str(x))
+            at_start = False
+        file.write(end)
+
+    def exec_(obj, globals=None, locals=None):
+        """ minimal backport of py3k exec statement. """
+        __tracebackhide__ = True
+        if globals is None:
+            frame = sys._getframe(1)
+            globals = frame.f_globals
+            if locals is None:
+                locals = frame.f_locals
+        elif locals is None:
+            locals = globals
+        exec2(obj, globals, locals)
+
+if sys.version_info >= (3, 0):
+    def _reraise(cls, val, tb):
+        __tracebackhide__ = True
+        assert hasattr(val, '__traceback__')
+        raise cls.with_traceback(val, tb)
+else:
+    exec ("""
+def _reraise(cls, val, tb):
+    __tracebackhide__ = True
+    raise cls, val, tb
+def exec2(obj, globals, locals):
+    __tracebackhide__ = True
+    exec obj in globals, locals
+""")
+
+def _tryimport(*names):
+    """ return the first successfully imported module. """
+    assert names
+    for name in names:
+        try:
+            __import__(name)
+        except ImportError:
+            excinfo = sys.exc_info()
+        else:
+            return sys.modules[name]
+    _reraise(*excinfo)
diff --git a/myenv/lib/python3.9/site-packages/py/_code/__init__.py b/myenv/lib/python3.9/site-packages/py/_code/__init__.py
new file mode 100644
index 0000000..f15acf8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_code/__init__.py
@@ -0,0 +1 @@
+""" python inspection/code generation API """
diff --git a/myenv/lib/python3.9/site-packages/py/_code/_assertionnew.py b/myenv/lib/python3.9/site-packages/py/_code/_assertionnew.py
new file mode 100644
index 0000000..d03f29d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_code/_assertionnew.py
@@ -0,0 +1,322 @@
+"""
+Find intermediate evalutation results in assert statements through builtin AST.
+This should replace _assertionold.py eventually.
+"""
+
+import sys
+import ast
+
+import py
+from py._code.assertion import _format_explanation, BuiltinAssertionError
+
+
+def _is_ast_expr(node):
+    return isinstance(node, ast.expr)
+def _is_ast_stmt(node):
+    return isinstance(node, ast.stmt)
+
+
+class Failure(Exception):
+    """Error found while interpreting AST."""
+
+    def __init__(self, explanation=""):
+        self.cause = sys.exc_info()
+        self.explanation = explanation
+
+
+def interpret(source, frame, should_fail=False):
+    mod = ast.parse(source)
+    visitor = DebugInterpreter(frame)
+    try:
+        visitor.visit(mod)
+    except Failure:
+        failure = sys.exc_info()[1]
+        return getfailure(failure)
+    if should_fail:
+        return ("(assertion failed, but when it was re-run for "
+                "printing intermediate values, it did not fail.  Suggestions: "
+                "compute assert expression before the assert or use --no-assert)")
+
+def run(offending_line, frame=None):
+    if frame is None:
+        frame = py.code.Frame(sys._getframe(1))
+    return interpret(offending_line, frame)
+
+def getfailure(failure):
+    explanation = _format_explanation(failure.explanation)
+    value = failure.cause[1]
+    if str(value):
+        lines = explanation.splitlines()
+        if not lines:
+            lines.append("")
+        lines[0] += " << %s" % (value,)
+        explanation = "\n".join(lines)
+    text = "%s: %s" % (failure.cause[0].__name__, explanation)
+    if text.startswith("AssertionError: assert "):
+        text = text[16:]
+    return text
+
+
+operator_map = {
+    ast.BitOr : "|",
+    ast.BitXor : "^",
+    ast.BitAnd : "&",
+    ast.LShift : "<<",
+    ast.RShift : ">>",
+    ast.Add : "+",
+    ast.Sub : "-",
+    ast.Mult : "*",
+    ast.Div : "/",
+    ast.FloorDiv : "//",
+    ast.Mod : "%",
+    ast.Eq : "==",
+    ast.NotEq : "!=",
+    ast.Lt : "<",
+    ast.LtE : "<=",
+    ast.Gt : ">",
+    ast.GtE : ">=",
+    ast.Pow : "**",
+    ast.Is : "is",
+    ast.IsNot : "is not",
+    ast.In : "in",
+    ast.NotIn : "not in"
+}
+
+unary_map = {
+    ast.Not : "not %s",
+    ast.Invert : "~%s",
+    ast.USub : "-%s",
+    ast.UAdd : "+%s"
+}
+
+
+class DebugInterpreter(ast.NodeVisitor):
+    """Interpret AST nodes to gleam useful debugging information. """
+
+    def __init__(self, frame):
+        self.frame = frame
+
+    def generic_visit(self, node):
+        # Fallback when we don't have a special implementation.
+        if _is_ast_expr(node):
+            mod = ast.Expression(node)
+            co = self._compile(mod)
+            try:
+                result = self.frame.eval(co)
+            except Exception:
+                raise Failure()
+            explanation = self.frame.repr(result)
+            return explanation, result
+        elif _is_ast_stmt(node):
+            mod = ast.Module([node])
+            co = self._compile(mod, "exec")
+            try:
+                self.frame.exec_(co)
+            except Exception:
+                raise Failure()
+            return None, None
+        else:
+            raise AssertionError("can't handle %s" %(node,))
+
+    def _compile(self, source, mode="eval"):
+        return compile(source, "<assertion interpretation>", mode)
+
+    def visit_Expr(self, expr):
+        return self.visit(expr.value)
+
+    def visit_Module(self, mod):
+        for stmt in mod.body:
+            self.visit(stmt)
+
+    def visit_Name(self, name):
+        explanation, result = self.generic_visit(name)
+        # See if the name is local.
+        source = "%r in locals() is not globals()" % (name.id,)
+        co = self._compile(source)
+        try:
+            local = self.frame.eval(co)
+        except Exception:
+            # have to assume it isn't
+            local = False
+        if not local:
+            return name.id, result
+        return explanation, result
+
+    def visit_Compare(self, comp):
+        left = comp.left
+        left_explanation, left_result = self.visit(left)
+        for op, next_op in zip(comp.ops, comp.comparators):
+            next_explanation, next_result = self.visit(next_op)
+            op_symbol = operator_map[op.__class__]
+            explanation = "%s %s %s" % (left_explanation, op_symbol,
+                                        next_explanation)
+            source = "__exprinfo_left %s __exprinfo_right" % (op_symbol,)
+            co = self._compile(source)
+            try:
+                result = self.frame.eval(co, __exprinfo_left=left_result,
+                                         __exprinfo_right=next_result)
+            except Exception:
+                raise Failure(explanation)
+            try:
+                if not result:
+                    break
+            except KeyboardInterrupt:
+                raise
+            except:
+                break
+            left_explanation, left_result = next_explanation, next_result
+
+        rcomp = py.code._reprcompare
+        if rcomp:
+            res = rcomp(op_symbol, left_result, next_result)
+            if res:
+                explanation = res
+        return explanation, result
+
+    def visit_BoolOp(self, boolop):
+        is_or = isinstance(boolop.op, ast.Or)
+        explanations = []
+        for operand in boolop.values:
+            explanation, result = self.visit(operand)
+            explanations.append(explanation)
+            if result == is_or:
+                break
+        name = is_or and " or " or " and "
+        explanation = "(" + name.join(explanations) + ")"
+        return explanation, result
+
+    def visit_UnaryOp(self, unary):
+        pattern = unary_map[unary.op.__class__]
+        operand_explanation, operand_result = self.visit(unary.operand)
+        explanation = pattern % (operand_explanation,)
+        co = self._compile(pattern % ("__exprinfo_expr",))
+        try:
+            result = self.frame.eval(co, __exprinfo_expr=operand_result)
+        except Exception:
+            raise Failure(explanation)
+        return explanation, result
+
+    def visit_BinOp(self, binop):
+        left_explanation, left_result = self.visit(binop.left)
+        right_explanation, right_result = self.visit(binop.right)
+        symbol = operator_map[binop.op.__class__]
+        explanation = "(%s %s %s)" % (left_explanation, symbol,
+                                      right_explanation)
+        source = "__exprinfo_left %s __exprinfo_right" % (symbol,)
+        co = self._compile(source)
+        try:
+            result = self.frame.eval(co, __exprinfo_left=left_result,
+                                     __exprinfo_right=right_result)
+        except Exception:
+            raise Failure(explanation)
+        return explanation, result
+
+    def visit_Call(self, call):
+        func_explanation, func = self.visit(call.func)
+        arg_explanations = []
+        ns = {"__exprinfo_func" : func}
+        arguments = []
+        for arg in call.args:
+            arg_explanation, arg_result = self.visit(arg)
+            arg_name = "__exprinfo_%s" % (len(ns),)
+            ns[arg_name] = arg_result
+            arguments.append(arg_name)
+            arg_explanations.append(arg_explanation)
+        for keyword in call.keywords:
+            arg_explanation, arg_result = self.visit(keyword.value)
+            arg_name = "__exprinfo_%s" % (len(ns),)
+            ns[arg_name] = arg_result
+            keyword_source = "%s=%%s" % (keyword.arg)
+            arguments.append(keyword_source % (arg_name,))
+            arg_explanations.append(keyword_source % (arg_explanation,))
+        if call.starargs:
+            arg_explanation, arg_result = self.visit(call.starargs)
+            arg_name = "__exprinfo_star"
+            ns[arg_name] = arg_result
+            arguments.append("*%s" % (arg_name,))
+            arg_explanations.append("*%s" % (arg_explanation,))
+        if call.kwargs:
+            arg_explanation, arg_result = self.visit(call.kwargs)
+            arg_name = "__exprinfo_kwds"
+            ns[arg_name] = arg_result
+            arguments.append("**%s" % (arg_name,))
+            arg_explanations.append("**%s" % (arg_explanation,))
+        args_explained = ", ".join(arg_explanations)
+        explanation = "%s(%s)" % (func_explanation, args_explained)
+        args = ", ".join(arguments)
+        source = "__exprinfo_func(%s)" % (args,)
+        co = self._compile(source)
+        try:
+            result = self.frame.eval(co, **ns)
+        except Exception:
+            raise Failure(explanation)
+        pattern = "%s\n{%s = %s\n}"
+        rep = self.frame.repr(result)
+        explanation = pattern % (rep, rep, explanation)
+        return explanation, result
+
+    def _is_builtin_name(self, name):
+        pattern = "%r not in globals() and %r not in locals()"
+        source = pattern % (name.id, name.id)
+        co = self._compile(source)
+        try:
+            return self.frame.eval(co)
+        except Exception:
+            return False
+
+    def visit_Attribute(self, attr):
+        if not isinstance(attr.ctx, ast.Load):
+            return self.generic_visit(attr)
+        source_explanation, source_result = self.visit(attr.value)
+        explanation = "%s.%s" % (source_explanation, attr.attr)
+        source = "__exprinfo_expr.%s" % (attr.attr,)
+        co = self._compile(source)
+        try:
+            result = self.frame.eval(co, __exprinfo_expr=source_result)
+        except Exception:
+            raise Failure(explanation)
+        explanation = "%s\n{%s = %s.%s\n}" % (self.frame.repr(result),
+                                              self.frame.repr(result),
+                                              source_explanation, attr.attr)
+        # Check if the attr is from an instance.
+        source = "%r in getattr(__exprinfo_expr, '__dict__', {})"
+        source = source % (attr.attr,)
+        co = self._compile(source)
+        try:
+            from_instance = self.frame.eval(co, __exprinfo_expr=source_result)
+        except Exception:
+            from_instance = True
+        if from_instance:
+            rep = self.frame.repr(result)
+            pattern = "%s\n{%s = %s\n}"
+            explanation = pattern % (rep, rep, explanation)
+        return explanation, result
+
+    def visit_Assert(self, assrt):
+        test_explanation, test_result = self.visit(assrt.test)
+        if test_explanation.startswith("False\n{False =") and \
+                test_explanation.endswith("\n"):
+            test_explanation = test_explanation[15:-2]
+        explanation = "assert %s" % (test_explanation,)
+        if not test_result:
+            try:
+                raise BuiltinAssertionError
+            except Exception:
+                raise Failure(explanation)
+        return explanation, test_result
+
+    def visit_Assign(self, assign):
+        value_explanation, value_result = self.visit(assign.value)
+        explanation = "... = %s" % (value_explanation,)
+        name = ast.Name("__exprinfo_expr", ast.Load(),
+                        lineno=assign.value.lineno,
+                        col_offset=assign.value.col_offset)
+        new_assign = ast.Assign(assign.targets, name, lineno=assign.lineno,
+                                col_offset=assign.col_offset)
+        mod = ast.Module([new_assign])
+        co = self._compile(mod, "exec")
+        try:
+            self.frame.exec_(co, __exprinfo_expr=value_result)
+        except Exception:
+            raise Failure(explanation)
+        return explanation, value_result
diff --git a/myenv/lib/python3.9/site-packages/py/_code/_assertionold.py b/myenv/lib/python3.9/site-packages/py/_code/_assertionold.py
new file mode 100644
index 0000000..1bb70a8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_code/_assertionold.py
@@ -0,0 +1,556 @@
+import py
+import sys, inspect
+from compiler import parse, ast, pycodegen
+from py._code.assertion import BuiltinAssertionError, _format_explanation
+import types
+
+passthroughex = py.builtin._sysex
+
+class Failure:
+    def __init__(self, node):
+        self.exc, self.value, self.tb = sys.exc_info()
+        self.node = node
+
+class View(object):
+    """View base class.
+
+    If C is a subclass of View, then C(x) creates a proxy object around
+    the object x.  The actual class of the proxy is not C in general,
+    but a *subclass* of C determined by the rules below.  To avoid confusion
+    we call view class the class of the proxy (a subclass of C, so of View)
+    and object class the class of x.
+
+    Attributes and methods not found in the proxy are automatically read on x.
+    Other operations like setting attributes are performed on the proxy, as
+    determined by its view class.  The object x is available from the proxy
+    as its __obj__ attribute.
+
+    The view class selection is determined by the __view__ tuples and the
+    optional __viewkey__ method.  By default, the selected view class is the
+    most specific subclass of C whose __view__ mentions the class of x.
+    If no such subclass is found, the search proceeds with the parent
+    object classes.  For example, C(True) will first look for a subclass
+    of C with __view__ = (..., bool, ...) and only if it doesn't find any
+    look for one with __view__ = (..., int, ...), and then ..., object,...
+    If everything fails the class C itself is considered to be the default.
+
+    Alternatively, the view class selection can be driven by another aspect
+    of the object x, instead of the class of x, by overriding __viewkey__.
+    See last example at the end of this module.
+    """
+
+    _viewcache = {}
+    __view__ = ()
+
+    def __new__(rootclass, obj, *args, **kwds):
+        self = object.__new__(rootclass)
+        self.__obj__ = obj
+        self.__rootclass__ = rootclass
+        key = self.__viewkey__()
+        try:
+            self.__class__ = self._viewcache[key]
+        except KeyError:
+            self.__class__ = self._selectsubclass(key)
+        return self
+
+    def __getattr__(self, attr):
+        # attributes not found in the normal hierarchy rooted on View
+        # are looked up in the object's real class
+        return getattr(self.__obj__, attr)
+
+    def __viewkey__(self):
+        return self.__obj__.__class__
+
+    def __matchkey__(self, key, subclasses):
+        if inspect.isclass(key):
+            keys = inspect.getmro(key)
+        else:
+            keys = [key]
+        for key in keys:
+            result = [C for C in subclasses if key in C.__view__]
+            if result:
+                return result
+        return []
+
+    def _selectsubclass(self, key):
+        subclasses = list(enumsubclasses(self.__rootclass__))
+        for C in subclasses:
+            if not isinstance(C.__view__, tuple):
+                C.__view__ = (C.__view__,)
+        choices = self.__matchkey__(key, subclasses)
+        if not choices:
+            return self.__rootclass__
+        elif len(choices) == 1:
+            return choices[0]
+        else:
+            # combine the multiple choices
+            return type('?', tuple(choices), {})
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__rootclass__.__name__, self.__obj__)
+
+
+def enumsubclasses(cls):
+    for subcls in cls.__subclasses__():
+        for subsubclass in enumsubclasses(subcls):
+            yield subsubclass
+    yield cls
+
+
+class Interpretable(View):
+    """A parse tree node with a few extra methods."""
+    explanation = None
+
+    def is_builtin(self, frame):
+        return False
+
+    def eval(self, frame):
+        # fall-back for unknown expression nodes
+        try:
+            expr = ast.Expression(self.__obj__)
+            expr.filename = '<eval>'
+            self.__obj__.filename = '<eval>'
+            co = pycodegen.ExpressionCodeGenerator(expr).getCode()
+            result = frame.eval(co)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+        self.result = result
+        self.explanation = self.explanation or frame.repr(self.result)
+
+    def run(self, frame):
+        # fall-back for unknown statement nodes
+        try:
+            expr = ast.Module(None, ast.Stmt([self.__obj__]))
+            expr.filename = '<run>'
+            co = pycodegen.ModuleCodeGenerator(expr).getCode()
+            frame.exec_(co)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+
+    def nice_explanation(self):
+        return _format_explanation(self.explanation)
+
+
+class Name(Interpretable):
+    __view__ = ast.Name
+
+    def is_local(self, frame):
+        source = '%r in locals() is not globals()' % self.name
+        try:
+            return frame.is_true(frame.eval(source))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def is_global(self, frame):
+        source = '%r in globals()' % self.name
+        try:
+            return frame.is_true(frame.eval(source))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def is_builtin(self, frame):
+        source = '%r not in locals() and %r not in globals()' % (
+            self.name, self.name)
+        try:
+            return frame.is_true(frame.eval(source))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def eval(self, frame):
+        super(Name, self).eval(frame)
+        if not self.is_local(frame):
+            self.explanation = self.name
+
+class Compare(Interpretable):
+    __view__ = ast.Compare
+
+    def eval(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        for operation, expr2 in self.ops:
+            if hasattr(self, 'result'):
+                # shortcutting in chained expressions
+                if not frame.is_true(self.result):
+                    break
+            expr2 = Interpretable(expr2)
+            expr2.eval(frame)
+            self.explanation = "%s %s %s" % (
+                expr.explanation, operation, expr2.explanation)
+            source = "__exprinfo_left %s __exprinfo_right" % operation
+            try:
+                self.result = frame.eval(source,
+                                         __exprinfo_left=expr.result,
+                                         __exprinfo_right=expr2.result)
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+            expr = expr2
+
+class And(Interpretable):
+    __view__ = ast.And
+
+    def eval(self, frame):
+        explanations = []
+        for expr in self.nodes:
+            expr = Interpretable(expr)
+            expr.eval(frame)
+            explanations.append(expr.explanation)
+            self.result = expr.result
+            if not frame.is_true(expr.result):
+                break
+        self.explanation = '(' + ' and '.join(explanations) + ')'
+
+class Or(Interpretable):
+    __view__ = ast.Or
+
+    def eval(self, frame):
+        explanations = []
+        for expr in self.nodes:
+            expr = Interpretable(expr)
+            expr.eval(frame)
+            explanations.append(expr.explanation)
+            self.result = expr.result
+            if frame.is_true(expr.result):
+                break
+        self.explanation = '(' + ' or '.join(explanations) + ')'
+
+
+# == Unary operations ==
+keepalive = []
+for astclass, astpattern in {
+    ast.Not    : 'not __exprinfo_expr',
+    ast.Invert : '(~__exprinfo_expr)',
+    }.items():
+
+    class UnaryArith(Interpretable):
+        __view__ = astclass
+
+        def eval(self, frame, astpattern=astpattern):
+            expr = Interpretable(self.expr)
+            expr.eval(frame)
+            self.explanation = astpattern.replace('__exprinfo_expr',
+                                                  expr.explanation)
+            try:
+                self.result = frame.eval(astpattern,
+                                         __exprinfo_expr=expr.result)
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+
+    keepalive.append(UnaryArith)
+
+# == Binary operations ==
+for astclass, astpattern in {
+    ast.Add    : '(__exprinfo_left + __exprinfo_right)',
+    ast.Sub    : '(__exprinfo_left - __exprinfo_right)',
+    ast.Mul    : '(__exprinfo_left * __exprinfo_right)',
+    ast.Div    : '(__exprinfo_left / __exprinfo_right)',
+    ast.Mod    : '(__exprinfo_left % __exprinfo_right)',
+    ast.Power  : '(__exprinfo_left ** __exprinfo_right)',
+    }.items():
+
+    class BinaryArith(Interpretable):
+        __view__ = astclass
+
+        def eval(self, frame, astpattern=astpattern):
+            left = Interpretable(self.left)
+            left.eval(frame)
+            right = Interpretable(self.right)
+            right.eval(frame)
+            self.explanation = (astpattern
+                                .replace('__exprinfo_left',  left .explanation)
+                                .replace('__exprinfo_right', right.explanation))
+            try:
+                self.result = frame.eval(astpattern,
+                                         __exprinfo_left=left.result,
+                                         __exprinfo_right=right.result)
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+
+    keepalive.append(BinaryArith)
+
+
+class CallFunc(Interpretable):
+    __view__ = ast.CallFunc
+
+    def is_bool(self, frame):
+        source = 'isinstance(__exprinfo_value, bool)'
+        try:
+            return frame.is_true(frame.eval(source,
+                                            __exprinfo_value=self.result))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def eval(self, frame):
+        node = Interpretable(self.node)
+        node.eval(frame)
+        explanations = []
+        vars = {'__exprinfo_fn': node.result}
+        source = '__exprinfo_fn('
+        for a in self.args:
+            if isinstance(a, ast.Keyword):
+                keyword = a.name
+                a = a.expr
+            else:
+                keyword = None
+            a = Interpretable(a)
+            a.eval(frame)
+            argname = '__exprinfo_%d' % len(vars)
+            vars[argname] = a.result
+            if keyword is None:
+                source += argname + ','
+                explanations.append(a.explanation)
+            else:
+                source += '%s=%s,' % (keyword, argname)
+                explanations.append('%s=%s' % (keyword, a.explanation))
+        if self.star_args:
+            star_args = Interpretable(self.star_args)
+            star_args.eval(frame)
+            argname = '__exprinfo_star'
+            vars[argname] = star_args.result
+            source += '*' + argname + ','
+            explanations.append('*' + star_args.explanation)
+        if self.dstar_args:
+            dstar_args = Interpretable(self.dstar_args)
+            dstar_args.eval(frame)
+            argname = '__exprinfo_kwds'
+            vars[argname] = dstar_args.result
+            source += '**' + argname + ','
+            explanations.append('**' + dstar_args.explanation)
+        self.explanation = "%s(%s)" % (
+            node.explanation, ', '.join(explanations))
+        if source.endswith(','):
+            source = source[:-1]
+        source += ')'
+        try:
+            self.result = frame.eval(source, **vars)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+        if not node.is_builtin(frame) or not self.is_bool(frame):
+            r = frame.repr(self.result)
+            self.explanation = '%s\n{%s = %s\n}' % (r, r, self.explanation)
+
+class Getattr(Interpretable):
+    __view__ = ast.Getattr
+
+    def eval(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        source = '__exprinfo_expr.%s' % self.attrname
+        try:
+            self.result = frame.eval(source, __exprinfo_expr=expr.result)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+        self.explanation = '%s.%s' % (expr.explanation, self.attrname)
+        # if the attribute comes from the instance, its value is interesting
+        source = ('hasattr(__exprinfo_expr, "__dict__") and '
+                  '%r in __exprinfo_expr.__dict__' % self.attrname)
+        try:
+            from_instance = frame.is_true(
+                frame.eval(source, __exprinfo_expr=expr.result))
+        except passthroughex:
+            raise
+        except:
+            from_instance = True
+        if from_instance:
+            r = frame.repr(self.result)
+            self.explanation = '%s\n{%s = %s\n}' % (r, r, self.explanation)
+
+# == Re-interpretation of full statements ==
+
+class Assert(Interpretable):
+    __view__ = ast.Assert
+
+    def run(self, frame):
+        test = Interpretable(self.test)
+        test.eval(frame)
+        # simplify 'assert False where False = ...'
+        if (test.explanation.startswith('False\n{False = ') and
+            test.explanation.endswith('\n}')):
+            test.explanation = test.explanation[15:-2]
+        # print the result as  'assert <explanation>'
+        self.result = test.result
+        self.explanation = 'assert ' + test.explanation
+        if not frame.is_true(test.result):
+            try:
+                raise BuiltinAssertionError
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+
+class Assign(Interpretable):
+    __view__ = ast.Assign
+
+    def run(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        self.result = expr.result
+        self.explanation = '... = ' + expr.explanation
+        # fall-back-run the rest of the assignment
+        ass = ast.Assign(self.nodes, ast.Name('__exprinfo_expr'))
+        mod = ast.Module(None, ast.Stmt([ass]))
+        mod.filename = '<run>'
+        co = pycodegen.ModuleCodeGenerator(mod).getCode()
+        try:
+            frame.exec_(co, __exprinfo_expr=expr.result)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+
+class Discard(Interpretable):
+    __view__ = ast.Discard
+
+    def run(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        self.result = expr.result
+        self.explanation = expr.explanation
+
+class Stmt(Interpretable):
+    __view__ = ast.Stmt
+
+    def run(self, frame):
+        for stmt in self.nodes:
+            stmt = Interpretable(stmt)
+            stmt.run(frame)
+
+
+def report_failure(e):
+    explanation = e.node.nice_explanation()
+    if explanation:
+        explanation = ", in: " + explanation
+    else:
+        explanation = ""
+    sys.stdout.write("%s: %s%s\n" % (e.exc.__name__, e.value, explanation))
+
+def check(s, frame=None):
+    if frame is None:
+        frame = sys._getframe(1)
+        frame = py.code.Frame(frame)
+    expr = parse(s, 'eval')
+    assert isinstance(expr, ast.Expression)
+    node = Interpretable(expr.node)
+    try:
+        node.eval(frame)
+    except passthroughex:
+        raise
+    except Failure:
+        e = sys.exc_info()[1]
+        report_failure(e)
+    else:
+        if not frame.is_true(node.result):
+            sys.stderr.write("assertion failed: %s\n" % node.nice_explanation())
+
+
+###########################################################
+# API / Entry points
+# #########################################################
+
+def interpret(source, frame, should_fail=False):
+    module = Interpretable(parse(source, 'exec').node)
+    #print "got module", module
+    if isinstance(frame, types.FrameType):
+        frame = py.code.Frame(frame)
+    try:
+        module.run(frame)
+    except Failure:
+        e = sys.exc_info()[1]
+        return getfailure(e)
+    except passthroughex:
+        raise
+    except:
+        import traceback
+        traceback.print_exc()
+    if should_fail:
+        return ("(assertion failed, but when it was re-run for "
+                "printing intermediate values, it did not fail.  Suggestions: "
+                "compute assert expression before the assert or use --nomagic)")
+    else:
+        return None
+
+def getmsg(excinfo):
+    if isinstance(excinfo, tuple):
+        excinfo = py.code.ExceptionInfo(excinfo)
+    #frame, line = gettbline(tb)
+    #frame = py.code.Frame(frame)
+    #return interpret(line, frame)
+
+    tb = excinfo.traceback[-1]
+    source = str(tb.statement).strip()
+    x = interpret(source, tb.frame, should_fail=True)
+    if not isinstance(x, str):
+        raise TypeError("interpret returned non-string %r" % (x,))
+    return x
+
+def getfailure(e):
+    explanation = e.node.nice_explanation()
+    if str(e.value):
+        lines = explanation.split('\n')
+        lines[0] += "  << %s" % (e.value,)
+        explanation = '\n'.join(lines)
+    text = "%s: %s" % (e.exc.__name__, explanation)
+    if text.startswith('AssertionError: assert '):
+        text = text[16:]
+    return text
+
+def run(s, frame=None):
+    if frame is None:
+        frame = sys._getframe(1)
+        frame = py.code.Frame(frame)
+    module = Interpretable(parse(s, 'exec').node)
+    try:
+        module.run(frame)
+    except Failure:
+        e = sys.exc_info()[1]
+        report_failure(e)
+
+
+if __name__ == '__main__':
+    # example:
+    def f():
+        return 5
+    def g():
+        return 3
+    def h(x):
+        return 'never'
+    check("f() * g() == 5")
+    check("not f()")
+    check("not (f() and g() or 0)")
+    check("f() == g()")
+    i = 4
+    check("i == f()")
+    check("len(f()) == 0")
+    check("isinstance(2+3+4, float)")
+
+    run("x = i")
+    check("x == 5")
+
+    run("assert not f(), 'oops'")
+    run("a, b, c = 1, 2")
+    run("a, b, c = f()")
+
+    check("max([f(),g()]) == 4")
+    check("'hello'[g()] == 'h'")
+    run("'guk%d' % h(f())")
diff --git a/myenv/lib/python3.9/site-packages/py/_code/_py2traceback.py b/myenv/lib/python3.9/site-packages/py/_code/_py2traceback.py
new file mode 100644
index 0000000..d65e27c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_code/_py2traceback.py
@@ -0,0 +1,79 @@
+# copied from python-2.7.3's traceback.py
+# CHANGES:
+# - some_str is replaced, trying to create unicode strings
+#
+import types
+
+def format_exception_only(etype, value):
+    """Format the exception part of a traceback.
+
+    The arguments are the exception type and value such as given by
+    sys.last_type and sys.last_value. The return value is a list of
+    strings, each ending in a newline.
+
+    Normally, the list contains a single string; however, for
+    SyntaxError exceptions, it contains several lines that (when
+    printed) display detailed information about where the syntax
+    error occurred.
+
+    The message indicating which exception occurred is always the last
+    string in the list.
+
+    """
+
+    # An instance should not have a meaningful value parameter, but
+    # sometimes does, particularly for string exceptions, such as
+    # >>> raise string1, string2  # deprecated
+    #
+    # Clear these out first because issubtype(string1, SyntaxError)
+    # would throw another exception and mask the original problem.
+    if (isinstance(etype, BaseException) or
+        isinstance(etype, types.InstanceType) or
+        etype is None or type(etype) is str):
+        return [_format_final_exc_line(etype, value)]
+
+    stype = etype.__name__
+
+    if not issubclass(etype, SyntaxError):
+        return [_format_final_exc_line(stype, value)]
+
+    # It was a syntax error; show exactly where the problem was found.
+    lines = []
+    try:
+        msg, (filename, lineno, offset, badline) = value.args
+    except Exception:
+        pass
+    else:
+        filename = filename or "<string>"
+        lines.append('  File "%s", line %d\n' % (filename, lineno))
+        if badline is not None:
+            lines.append('    %s\n' % badline.strip())
+            if offset is not None:
+                caretspace = badline.rstrip('\n')[:offset].lstrip()
+                # non-space whitespace (likes tabs) must be kept for alignment
+                caretspace = ((c.isspace() and c or ' ') for c in caretspace)
+                # only three spaces to account for offset1 == pos 0
+                lines.append('   %s^\n' % ''.join(caretspace))
+        value = msg
+
+    lines.append(_format_final_exc_line(stype, value))
+    return lines
+
+def _format_final_exc_line(etype, value):
+    """Return a list of a single line -- normal case for format_exception_only"""
+    valuestr = _some_str(value)
+    if value is None or not valuestr:
+        line = "%s\n" % etype
+    else:
+        line = "%s: %s\n" % (etype, valuestr)
+    return line
+
+def _some_str(value):
+    try:
+        return unicode(value)
+    except Exception:
+        try:
+            return str(value)
+        except Exception:
+            pass
+    return '<unprintable %s object>' % type(value).__name__
diff --git a/myenv/lib/python3.9/site-packages/py/_code/assertion.py b/myenv/lib/python3.9/site-packages/py/_code/assertion.py
new file mode 100644
index 0000000..ff16437
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_code/assertion.py
@@ -0,0 +1,90 @@
+import sys
+import py
+
+BuiltinAssertionError = py.builtin.builtins.AssertionError
+
+_reprcompare = None # if set, will be called by assert reinterp for comparison ops
+
+def _format_explanation(explanation):
+    """This formats an explanation
+
+    Normally all embedded newlines are escaped, however there are
+    three exceptions: \n{, \n} and \n~.  The first two are intended
+    cover nested explanations, see function and attribute explanations
+    for examples (.visit_Call(), visit_Attribute()).  The last one is
+    for when one explanation needs to span multiple lines, e.g. when
+    displaying diffs.
+    """
+    raw_lines = (explanation or '').split('\n')
+    # escape newlines not followed by {, } and ~
+    lines = [raw_lines[0]]
+    for l in raw_lines[1:]:
+        if l.startswith('{') or l.startswith('}') or l.startswith('~'):
+            lines.append(l)
+        else:
+            lines[-1] += '\\n' + l
+
+    result = lines[:1]
+    stack = [0]
+    stackcnt = [0]
+    for line in lines[1:]:
+        if line.startswith('{'):
+            if stackcnt[-1]:
+                s = 'and   '
+            else:
+                s = 'where '
+            stack.append(len(result))
+            stackcnt[-1] += 1
+            stackcnt.append(0)
+            result.append(' +' + '  '*(len(stack)-1) + s + line[1:])
+        elif line.startswith('}'):
+            assert line.startswith('}')
+            stack.pop()
+            stackcnt.pop()
+            result[stack[-1]] += line[1:]
+        else:
+            assert line.startswith('~')
+            result.append('  '*len(stack) + line[1:])
+    assert len(stack) == 1
+    return '\n'.join(result)
+
+
+class AssertionError(BuiltinAssertionError):
+    def __init__(self, *args):
+        BuiltinAssertionError.__init__(self, *args)
+        if args:
+            try:
+                self.msg = str(args[0])
+            except py.builtin._sysex:
+                raise
+            except:
+                self.msg = "<[broken __repr__] %s at %0xd>" %(
+                    args[0].__class__, id(args[0]))
+        else:
+            f = py.code.Frame(sys._getframe(1))
+            try:
+                source = f.code.fullsource
+                if source is not None:
+                    try:
+                        source = source.getstatement(f.lineno, assertion=True)
+                    except IndexError:
+                        source = None
+                    else:
+                        source = str(source.deindent()).strip()
+            except py.error.ENOENT:
+                source = None
+                # this can also occur during reinterpretation, when the
+                # co_filename is set to "<run>".
+            if source:
+                self.msg = reinterpret(source, f, should_fail=True)
+            else:
+                self.msg = "<could not determine information>"
+            if not self.args:
+                self.args = (self.msg,)
+
+if sys.version_info > (3, 0):
+    AssertionError.__module__ = "builtins"
+    reinterpret_old = "old reinterpretation not available for py3"
+else:
+    from py._code._assertionold import interpret as reinterpret_old
+from py._code._assertionnew import interpret as reinterpret
diff --git a/myenv/lib/python3.9/site-packages/py/_code/code.py b/myenv/lib/python3.9/site-packages/py/_code/code.py
new file mode 100644
index 0000000..dad7962
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_code/code.py
@@ -0,0 +1,796 @@
+import py
+import sys
+from inspect import CO_VARARGS, CO_VARKEYWORDS, isclass
+
+builtin_repr = repr
+
+reprlib = py.builtin._tryimport('repr', 'reprlib')
+
+if sys.version_info[0] >= 3:
+    from traceback import format_exception_only
+else:
+    from py._code._py2traceback import format_exception_only
+
+import traceback
+
+
+class Code(object):
+    """ wrapper around Python code objects """
+    def __init__(self, rawcode):
+        if not hasattr(rawcode, "co_filename"):
+            rawcode = py.code.getrawcode(rawcode)
+        try:
+            self.filename = rawcode.co_filename
+            self.firstlineno = rawcode.co_firstlineno - 1
+            self.name = rawcode.co_name
+        except AttributeError:
+            raise TypeError("not a code object: %r" % (rawcode,))
+        self.raw = rawcode
+
+    def __eq__(self, other):
+        return self.raw == other.raw
+
+    def __ne__(self, other):
+        return not self == other
+
+    @property
+    def path(self):
+        """ return a path object pointing to source code (note that it
+        might not point to an actually existing file). """
+        p = py.path.local(self.raw.co_filename)
+        # maybe don't try this checking
+        if not p.check():
+            # XXX maybe try harder like the weird logic
+            # in the standard lib [linecache.updatecache] does?
+            p = self.raw.co_filename
+        return p
+
+    @property
+    def fullsource(self):
+        """ return a py.code.Source object for the full source file of the code
+        """
+        from py._code import source
+        full, _ = source.findsource(self.raw)
+        return full
+
+    def source(self):
+        """ return a py.code.Source object for the code object's source only
+        """
+        # return source only for that part of code
+        return py.code.Source(self.raw)
+
+    def getargs(self, var=False):
+        """ return a tuple with the argument names for the code object
+
+            if 'var' is set True also return the names of the variable and
+            keyword arguments when present
+        """
+        # handfull shortcut for getting args
+        raw = self.raw
+        argcount = raw.co_argcount
+        if var:
+            argcount += raw.co_flags & CO_VARARGS
+            argcount += raw.co_flags & CO_VARKEYWORDS
+        return raw.co_varnames[:argcount]
+
+class Frame(object):
+    """Wrapper around a Python frame holding f_locals and f_globals
+    in which expressions can be evaluated."""
+
+    def __init__(self, frame):
+        self.lineno = frame.f_lineno - 1
+        self.f_globals = frame.f_globals
+        self.f_locals = frame.f_locals
+        self.raw = frame
+        self.code = py.code.Code(frame.f_code)
+
+    @property
+    def statement(self):
+        """ statement this frame is at """
+        if self.code.fullsource is None:
+            return py.code.Source("")
+        return self.code.fullsource.getstatement(self.lineno)
+
+    def eval(self, code, **vars):
+        """ evaluate 'code' in the frame
+
+            'vars' are optional additional local variables
+
+            returns the result of the evaluation
+        """
+        f_locals = self.f_locals.copy()
+        f_locals.update(vars)
+        return eval(code, self.f_globals, f_locals)
+
+    def exec_(self, code, **vars):
+        """ exec 'code' in the frame
+
+            'vars' are optiona; additional local variables
+        """
+        f_locals = self.f_locals.copy()
+        f_locals.update(vars)
+        py.builtin.exec_(code, self.f_globals, f_locals)
+
+    def repr(self, object):
+        """ return a 'safe' (non-recursive, one-line) string repr for 'object'
+        """
+        return py.io.saferepr(object)
+
+    def is_true(self, object):
+        return object
+
+    def getargs(self, var=False):
+        """ return a list of tuples (name, value) for all arguments
+
+            if 'var' is set True also include the variable and keyword
+            arguments when present
+        """
+        retval = []
+        for arg in self.code.getargs(var):
+            try:
+                retval.append((arg, self.f_locals[arg]))
+            except KeyError:
+                pass     # this can occur when using Psyco
+        return retval
+
+
+class TracebackEntry(object):
+    """ a single entry in a traceback """
+
+    _repr_style = None
+    exprinfo = None
+
+    def __init__(self, rawentry):
+        self._rawentry = rawentry
+        self.lineno = rawentry.tb_lineno - 1
+
+    def set_repr_style(self, mode):
+        assert mode in ("short", "long")
+        self._repr_style = mode
+
+    @property
+    def frame(self):
+        return py.code.Frame(self._rawentry.tb_frame)
+
+    @property
+    def relline(self):
+        return self.lineno - self.frame.code.firstlineno
+
+    def __repr__(self):
+        return "<TracebackEntry %s:%d>" % (self.frame.code.path, self.lineno+1)
+
+    @property
+    def statement(self):
+        """ py.code.Source object for the current statement """
+        source = self.frame.code.fullsource
+        return source.getstatement(self.lineno)
+
+    @property
+    def path(self):
+        """ path to the source code """
+        return self.frame.code.path
+
+    def getlocals(self):
+        return self.frame.f_locals
+    locals = property(getlocals, None, None, "locals of underlaying frame")
+
+    def reinterpret(self):
+        """Reinterpret the failing statement and returns a detailed information
+           about what operations are performed."""
+        if self.exprinfo is None:
+            source = str(self.statement).strip()
+            x = py.code._reinterpret(source, self.frame, should_fail=True)
+            if not isinstance(x, str):
+                raise TypeError("interpret returned non-string %r" % (x,))
+            self.exprinfo = x
+        return self.exprinfo
+
+    def getfirstlinesource(self):
+        # on Jython this firstlineno can be -1 apparently
+        return max(self.frame.code.firstlineno, 0)
+
+    def getsource(self, astcache=None):
+        """ return failing source code. """
+        # we use the passed in astcache to not reparse asttrees
+        # within exception info printing
+        from py._code.source import getstatementrange_ast
+        source = self.frame.code.fullsource
+        if source is None:
+            return None
+        key = astnode = None
+        if astcache is not None:
+            key = self.frame.code.path
+            if key is not None:
+                astnode = astcache.get(key, None)
+        start = self.getfirstlinesource()
+        try:
+            astnode, _, end = getstatementrange_ast(self.lineno, source,
+                                                    astnode=astnode)
+        except SyntaxError:
+            end = self.lineno + 1
+        else:
+            if key is not None:
+                astcache[key] = astnode
+        return source[start:end]
+
+    source = property(getsource)
+
+    def ishidden(self):
+        """ return True if the current frame has a var __tracebackhide__
+            resolving to True
+
+            mostly for internal use
+        """
+        try:
+            return self.frame.f_locals['__tracebackhide__']
+        except KeyError:
+            try:
+                return self.frame.f_globals['__tracebackhide__']
+            except KeyError:
+                return False
+
+    def __str__(self):
+        try:
+            fn = str(self.path)
+        except py.error.Error:
+            fn = '???'
+        name = self.frame.code.name
+        try:
+            line = str(self.statement).lstrip()
+        except KeyboardInterrupt:
+            raise
+        except:
+            line = "???"
+        return "  File %r:%d in %s\n  %s\n" % (fn, self.lineno+1, name, line)
+
+    def name(self):
+        return self.frame.code.raw.co_name
+    name = property(name, None, None, "co_name of underlaying code")
+
+
+class Traceback(list):
+    """ Traceback objects encapsulate and offer higher level
+        access to Traceback entries.
+    """
+    Entry = TracebackEntry
+
+    def __init__(self, tb):
+        """ initialize from given python traceback object. """
+        if hasattr(tb, 'tb_next'):
+            def f(cur):
+                while cur is not None:
+                    yield self.Entry(cur)
+                    cur = cur.tb_next
+            list.__init__(self, f(tb))
+        else:
+            list.__init__(self, tb)
+
+    def cut(self, path=None, lineno=None, firstlineno=None, excludepath=None):
+        """ return a Traceback instance wrapping part of this Traceback
+
+            by provding any combination of path, lineno and firstlineno, the
+            first frame to start the to-be-returned traceback is determined
+
+            this allows cutting the first part of a Traceback instance e.g.
+            for formatting reasons (removing some uninteresting bits that deal
+            with handling of the exception/traceback)
+        """
+        for x in self:
+            code = x.frame.code
+            codepath = code.path
+            if ((path is None or codepath == path) and
+                (excludepath is None or not hasattr(codepath, 'relto') or
+                 not codepath.relto(excludepath)) and
+                (lineno is None or x.lineno == lineno) and
+                (firstlineno is None or x.frame.code.firstlineno == firstlineno)):
+                return Traceback(x._rawentry)
+        return self
+
+    def __getitem__(self, key):
+        val = super(Traceback, self).__getitem__(key)
+        if isinstance(key, type(slice(0))):
+            val = self.__class__(val)
+        return val
+
+    def filter(self, fn=lambda x: not x.ishidden()):
+        """ return a Traceback instance with certain items removed
+
+            fn is a function that gets a single argument, a TracebackItem
+            instance, and should return True when the item should be added
+            to the Traceback, False when not
+
+            by default this removes all the TracebackItems which are hidden
+            (see ishidden() above)
+        """
+        return Traceback(filter(fn, self))
+
+    def getcrashentry(self):
+        """ return last non-hidden traceback entry that lead
+        to the exception of a traceback.
+        """
+        for i in range(-1, -len(self)-1, -1):
+            entry = self[i]
+            if not entry.ishidden():
+                return entry
+        return self[-1]
+
+    def recursionindex(self):
+        """ return the index of the frame/TracebackItem where recursion
+            originates if appropriate, None if no recursion occurred
+        """
+        cache = {}
+        for i, entry in enumerate(self):
+            # id for the code.raw is needed to work around
+            # the strange metaprogramming in the decorator lib from pypi
+            # which generates code objects that have hash/value equality
+            #XXX needs a test
+            key = entry.frame.code.path, id(entry.frame.code.raw), entry.lineno
+            #print "checking for recursion at", key
+            l = cache.setdefault(key, [])
+            if l:
+                f = entry.frame
+                loc = f.f_locals
+                for otherloc in l:
+                    if f.is_true(f.eval(co_equal,
+                        __recursioncache_locals_1=loc,
+                        __recursioncache_locals_2=otherloc)):
+                        return i
+            l.append(entry.frame.f_locals)
+        return None
+
+co_equal = compile('__recursioncache_locals_1 == __recursioncache_locals_2',
+                   '?', 'eval')
+
+class ExceptionInfo(object):
+    """ wraps sys.exc_info() objects and offers
+        help for navigating the traceback.
+    """
+    _striptext = ''
+    def __init__(self, tup=None, exprinfo=None):
+        if tup is None:
+            tup = sys.exc_info()
+            if exprinfo is None and isinstance(tup[1], AssertionError):
+                exprinfo = getattr(tup[1], 'msg', None)
+                if exprinfo is None:
+                    exprinfo = str(tup[1])
+                if exprinfo and exprinfo.startswith('assert '):
+                    self._striptext = 'AssertionError: '
+        self._excinfo = tup
+        #: the exception class
+        self.type = tup[0]
+        #: the exception instance
+        self.value = tup[1]
+        #: the exception raw traceback
+        self.tb = tup[2]
+        #: the exception type name
+        self.typename = self.type.__name__
+        #: the exception traceback (py.code.Traceback instance)
+        self.traceback = py.code.Traceback(self.tb)
+
+    def __repr__(self):
+        return "<ExceptionInfo %s tblen=%d>" % (
+            self.typename, len(self.traceback))
+
+    def exconly(self, tryshort=False):
+        """ return the exception as a string
+
+            when 'tryshort' resolves to True, and the exception is a
+            py.code._AssertionError, only the actual exception part of
+            the exception representation is returned (so 'AssertionError: ' is
+            removed from the beginning)
+        """
+        lines = format_exception_only(self.type, self.value)
+        text = ''.join(lines)
+        text = text.rstrip()
+        if tryshort:
+            if text.startswith(self._striptext):
+                text = text[len(self._striptext):]
+        return text
+
+    def errisinstance(self, exc):
+        """ return True if the exception is an instance of exc """
+        return isinstance(self.value, exc)
+
+    def _getreprcrash(self):
+        exconly = self.exconly(tryshort=True)
+        entry = self.traceback.getcrashentry()
+        path, lineno = entry.frame.code.raw.co_filename, entry.lineno
+        return ReprFileLocation(path, lineno+1, exconly)
+
+    def getrepr(self, showlocals=False, style="long",
+                abspath=False, tbfilter=True, funcargs=False):
+        """ return str()able representation of this exception info.
+            showlocals: show locals per traceback entry
+            style: long|short|no|native traceback style
+            tbfilter: hide entries (where __tracebackhide__ is true)
+
+            in case of style==native, tbfilter and showlocals is ignored.
+        """
+        if style == 'native':
+            return ReprExceptionInfo(ReprTracebackNative(
+                traceback.format_exception(
+                    self.type,
+                    self.value,
+                    self.traceback[0]._rawentry,
+                )), self._getreprcrash())
+
+        fmt = FormattedExcinfo(
+            showlocals=showlocals, style=style,
+            abspath=abspath, tbfilter=tbfilter, funcargs=funcargs)
+        return fmt.repr_excinfo(self)
+
+    def __str__(self):
+        entry = self.traceback[-1]
+        loc = ReprFileLocation(entry.path, entry.lineno + 1, self.exconly())
+        return str(loc)
+
+    def __unicode__(self):
+        entry = self.traceback[-1]
+        loc = ReprFileLocation(entry.path, entry.lineno + 1, self.exconly())
+        return loc.__unicode__()
+
+
+class FormattedExcinfo(object):
+    """ presenting information about failing Functions and Generators. """
+    # for traceback entries
+    flow_marker = ">"
+    fail_marker = "E"
+
+    def __init__(self, showlocals=False, style="long",
+                 abspath=True, tbfilter=True, funcargs=False):
+        self.showlocals = showlocals
+        self.style = style
+        self.tbfilter = tbfilter
+        self.funcargs = funcargs
+        self.abspath = abspath
+        self.astcache = {}
+
+    def _getindent(self, source):
+        # figure out indent for given source
+        try:
+            s = str(source.getstatement(len(source)-1))
+        except KeyboardInterrupt:
+            raise
+        except:
+            try:
+                s = str(source[-1])
+            except KeyboardInterrupt:
+                raise
+            except:
+                return 0
+        return 4 + (len(s) - len(s.lstrip()))
+
+    def _getentrysource(self, entry):
+        source = entry.getsource(self.astcache)
+        if source is not None:
+            source = source.deindent()
+        return source
+
+    def _saferepr(self, obj):
+        return py.io.saferepr(obj)
+
+    def repr_args(self, entry):
+        if self.funcargs:
+            args = []
+            for argname, argvalue in entry.frame.getargs(var=True):
+                args.append((argname, self._saferepr(argvalue)))
+            return ReprFuncArgs(args)
+
+    def get_source(self, source, line_index=-1, excinfo=None, short=False):
+        """ return formatted and marked up source lines. """
+        lines = []
+        if source is None or line_index >= len(source.lines):
+            source = py.code.Source("???")
+            line_index = 0
+        if line_index < 0:
+            line_index += len(source)
+        space_prefix = "    "
+        if short:
+            lines.append(space_prefix + source.lines[line_index].strip())
+        else:
+            for line in source.lines[:line_index]:
+                lines.append(space_prefix + line)
+            lines.append(self.flow_marker + "   " + source.lines[line_index])
+            for line in source.lines[line_index+1:]:
+                lines.append(space_prefix + line)
+        if excinfo is not None:
+            indent = 4 if short else self._getindent(source)
+            lines.extend(self.get_exconly(excinfo, indent=indent, markall=True))
+        return lines
+
+    def get_exconly(self, excinfo, indent=4, markall=False):
+        lines = []
+        indent = " " * indent
+        # get the real exception information out
+        exlines = excinfo.exconly(tryshort=True).split('\n')
+        failindent = self.fail_marker + indent[1:]
+        for line in exlines:
+            lines.append(failindent + line)
+            if not markall:
+                failindent = indent
+        return lines
+
+    def repr_locals(self, locals):
+        if self.showlocals:
+            lines = []
+            keys = [loc for loc in locals if loc[0] != "@"]
+            keys.sort()
+            for name in keys:
+                value = locals[name]
+                if name == '__builtins__':
+                    lines.append("__builtins__ = <builtins>")
+                else:
+                    # This formatting could all be handled by the
+                    # _repr() function, which is only reprlib.Repr in
+                    # disguise, so is very configurable.
+                    str_repr = self._saferepr(value)
+                    #if len(str_repr) < 70 or not isinstance(value,
+                    #                            (list, tuple, dict)):
+                    lines.append("%-10s = %s" %(name, str_repr))
+                    #else:
+                    #    self._line("%-10s =\\" % (name,))
+                    #    # XXX
+                    #    pprint.pprint(value, stream=self.excinfowriter)
+            return ReprLocals(lines)
+
+    def repr_traceback_entry(self, entry, excinfo=None):
+        source = self._getentrysource(entry)
+        if source is None:
+            source = py.code.Source("???")
+            line_index = 0
+        else:
+            # entry.getfirstlinesource() can be -1, should be 0 on jython
+            line_index = entry.lineno - max(entry.getfirstlinesource(), 0)
+
+        lines = []
+        style = entry._repr_style
+        if style is None:
+            style = self.style
+        if style in ("short", "long"):
+            short = style == "short"
+            reprargs = self.repr_args(entry) if not short else None
+            s = self.get_source(source, line_index, excinfo, short=short)
+            lines.extend(s)
+            if short:
+                message = "in %s" %(entry.name)
+            else:
+                message = excinfo and excinfo.typename or ""
+            path = self._makepath(entry.path)
+            filelocrepr = ReprFileLocation(path, entry.lineno+1, message)
+            localsrepr = None
+            if not short:
+                localsrepr =  self.repr_locals(entry.locals)
+            return ReprEntry(lines, reprargs, localsrepr, filelocrepr, style)
+        if excinfo:
+            lines.extend(self.get_exconly(excinfo, indent=4))
+        return ReprEntry(lines, None, None, None, style)
+
+    def _makepath(self, path):
+        if not self.abspath:
+            try:
+                np = py.path.local().bestrelpath(path)
+            except OSError:
+                return path
+            if len(np) < len(str(path)):
+                path = np
+        return path
+
+    def repr_traceback(self, excinfo):
+        traceback = excinfo.traceback
+        if self.tbfilter:
+            traceback = traceback.filter()
+        recursionindex = None
+        if excinfo.errisinstance(RuntimeError):
+            if "maximum recursion depth exceeded" in str(excinfo.value):
+                recursionindex = traceback.recursionindex()
+        last = traceback[-1]
+        entries = []
+        extraline = None
+        for index, entry in enumerate(traceback):
+            einfo = (last == entry) and excinfo or None
+            reprentry = self.repr_traceback_entry(entry, einfo)
+            entries.append(reprentry)
+            if index == recursionindex:
+                extraline = "!!! Recursion detected (same locals & position)"
+                break
+        return ReprTraceback(entries, extraline, style=self.style)
+
+    def repr_excinfo(self, excinfo):
+        reprtraceback = self.repr_traceback(excinfo)
+        reprcrash = excinfo._getreprcrash()
+        return ReprExceptionInfo(reprtraceback, reprcrash)
+
+class TerminalRepr:
+    def __str__(self):
+        s = self.__unicode__()
+        if sys.version_info[0] < 3:
+            s = s.encode('utf-8')
+        return s
+
+    def __unicode__(self):
+        # FYI this is called from pytest-xdist's serialization of exception
+        # information.
+        io = py.io.TextIO()
+        tw = py.io.TerminalWriter(file=io)
+        self.toterminal(tw)
+        return io.getvalue().strip()
+
+    def __repr__(self):
+        return "<%s instance at %0x>" %(self.__class__, id(self))
+
+
+class ReprExceptionInfo(TerminalRepr):
+    def __init__(self, reprtraceback, reprcrash):
+        self.reprtraceback = reprtraceback
+        self.reprcrash = reprcrash
+        self.sections = []
+
+    def addsection(self, name, content, sep="-"):
+        self.sections.append((name, content, sep))
+
+    def toterminal(self, tw):
+        self.reprtraceback.toterminal(tw)
+        for name, content, sep in self.sections:
+            tw.sep(sep, name)
+            tw.line(content)
+
+class ReprTraceback(TerminalRepr):
+    entrysep = "_ "
+
+    def __init__(self, reprentries, extraline, style):
+        self.reprentries = reprentries
+        self.extraline = extraline
+        self.style = style
+
+    def toterminal(self, tw):
+        # the entries might have different styles
+        last_style = None
+        for i, entry in enumerate(self.reprentries):
+            if entry.style == "long":
+                tw.line("")
+            entry.toterminal(tw)
+            if i < len(self.reprentries) - 1:
+                next_entry = self.reprentries[i+1]
+                if entry.style == "long" or \
+                   entry.style == "short" and next_entry.style == "long":
+                    tw.sep(self.entrysep)
+
+        if self.extraline:
+            tw.line(self.extraline)
+
+class ReprTracebackNative(ReprTraceback):
+    def __init__(self, tblines):
+        self.style = "native"
+        self.reprentries = [ReprEntryNative(tblines)]
+        self.extraline = None
+
+class ReprEntryNative(TerminalRepr):
+    style = "native"
+
+    def __init__(self, tblines):
+        self.lines = tblines
+
+    def toterminal(self, tw):
+        tw.write("".join(self.lines))
+
+class ReprEntry(TerminalRepr):
+    localssep = "_ "
+
+    def __init__(self, lines, reprfuncargs, reprlocals, filelocrepr, style):
+        self.lines = lines
+        self.reprfuncargs = reprfuncargs
+        self.reprlocals = reprlocals
+        self.reprfileloc = filelocrepr
+        self.style = style
+
+    def toterminal(self, tw):
+        if self.style == "short":
+            self.reprfileloc.toterminal(tw)
+            for line in self.lines:
+                red = line.startswith("E   ")
+                tw.line(line, bold=True, red=red)
+            #tw.line("")
+            return
+        if self.reprfuncargs:
+            self.reprfuncargs.toterminal(tw)
+        for line in self.lines:
+            red = line.startswith("E   ")
+            tw.line(line, bold=True, red=red)
+        if self.reprlocals:
+            #tw.sep(self.localssep, "Locals")
+            tw.line("")
+            self.reprlocals.toterminal(tw)
+        if self.reprfileloc:
+            if self.lines:
+                tw.line("")
+            self.reprfileloc.toterminal(tw)
+
+    def __str__(self):
+        return "%s\n%s\n%s" % ("\n".join(self.lines),
+                               self.reprlocals,
+                               self.reprfileloc)
+
+class ReprFileLocation(TerminalRepr):
+    def __init__(self, path, lineno, message):
+        self.path = str(path)
+        self.lineno = lineno
+        self.message = message
+
+    def toterminal(self, tw):
+        # filename and lineno output for each entry,
+        # using an output format that most editors unterstand
+        msg = self.message
+        i = msg.find("\n")
+        if i != -1:
+            msg = msg[:i]
+        tw.line("%s:%s: %s" %(self.path, self.lineno, msg))
+
+class ReprLocals(TerminalRepr):
+    def __init__(self, lines):
+        self.lines = lines
+
+    def toterminal(self, tw):
+        for line in self.lines:
+            tw.line(line)
+
+class ReprFuncArgs(TerminalRepr):
+    def __init__(self, args):
+        self.args = args
+
+    def toterminal(self, tw):
+        if self.args:
+            linesofar = ""
+            for name, value in self.args:
+                ns = "%s = %s" %(name, value)
+                if len(ns) + len(linesofar) + 2 > tw.fullwidth:
+                    if linesofar:
+                        tw.line(linesofar)
+                    linesofar =  ns
+                else:
+                    if linesofar:
+                        linesofar += ", " + ns
+                    else:
+                        linesofar = ns
+            if linesofar:
+                tw.line(linesofar)
+            tw.line("")
+
+
+
+oldbuiltins = {}
+
+def patch_builtins(assertion=True, compile=True):
+    """ put compile and AssertionError builtins to Python's builtins. """
+    if assertion:
+        from py._code import assertion
+        l = oldbuiltins.setdefault('AssertionError', [])
+        l.append(py.builtin.builtins.AssertionError)
+        py.builtin.builtins.AssertionError = assertion.AssertionError
+    if compile:
+        l = oldbuiltins.setdefault('compile', [])
+        l.append(py.builtin.builtins.compile)
+        py.builtin.builtins.compile = py.code.compile
+
+def unpatch_builtins(assertion=True, compile=True):
+    """ remove compile and AssertionError builtins from Python builtins. """
+    if assertion:
+        py.builtin.builtins.AssertionError = oldbuiltins['AssertionError'].pop()
+    if compile:
+        py.builtin.builtins.compile = oldbuiltins['compile'].pop()
+
+def getrawcode(obj, trycall=True):
+    """ return code object for given function. """
+    try:
+        return obj.__code__
+    except AttributeError:
+        obj = getattr(obj, 'im_func', obj)
+        obj = getattr(obj, 'func_code', obj)
+        obj = getattr(obj, 'f_code', obj)
+        obj = getattr(obj, '__code__', obj)
+        if trycall and not hasattr(obj, 'co_firstlineno'):
+            if hasattr(obj, '__call__') and not isclass(obj):
+                x = getrawcode(obj.__call__, trycall=False)
+                if hasattr(x, 'co_firstlineno'):
+                    return x
+        return obj
+
diff --git a/myenv/lib/python3.9/site-packages/py/_code/source.py b/myenv/lib/python3.9/site-packages/py/_code/source.py
new file mode 100644
index 0000000..7fc7b23
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_code/source.py
@@ -0,0 +1,410 @@
+from __future__ import generators
+
+from bisect import bisect_right
+import sys
+import inspect, tokenize
+import py
+from types import ModuleType
+cpy_compile = compile
+
+try:
+    import _ast
+    from _ast import PyCF_ONLY_AST as _AST_FLAG
+except ImportError:
+    _AST_FLAG = 0
+    _ast = None
+
+
+class Source(object):
+    """ a immutable object holding a source code fragment,
+        possibly deindenting it.
+    """
+    _compilecounter = 0
+    def __init__(self, *parts, **kwargs):
+        self.lines = lines = []
+        de = kwargs.get('deindent', True)
+        rstrip = kwargs.get('rstrip', True)
+        for part in parts:
+            if not part:
+                partlines = []
+            if isinstance(part, Source):
+                partlines = part.lines
+            elif isinstance(part, (tuple, list)):
+                partlines = [x.rstrip("\n") for x in part]
+            elif isinstance(part, py.builtin._basestring):
+                partlines = part.split('\n')
+                if rstrip:
+                    while partlines:
+                        if partlines[-1].strip():
+                            break
+                        partlines.pop()
+            else:
+                partlines = getsource(part, deindent=de).lines
+            if de:
+                partlines = deindent(partlines)
+            lines.extend(partlines)
+
+    def __eq__(self, other):
+        try:
+            return self.lines == other.lines
+        except AttributeError:
+            if isinstance(other, str):
+                return str(self) == other
+            return False
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            return self.lines[key]
+        else:
+            if key.step not in (None, 1):
+                raise IndexError("cannot slice a Source with a step")
+            return self.__getslice__(key.start, key.stop)
+
+    def __len__(self):
+        return len(self.lines)
+
+    def __getslice__(self, start, end):
+        newsource = Source()
+        newsource.lines = self.lines[start:end]
+        return newsource
+
+    def strip(self):
+        """ return new source object with trailing
+            and leading blank lines removed.
+        """
+        start, end = 0, len(self)
+        while start < end and not self.lines[start].strip():
+            start += 1
+        while end > start and not self.lines[end-1].strip():
+            end -= 1
+        source = Source()
+        source.lines[:] = self.lines[start:end]
+        return source
+
+    def putaround(self, before='', after='', indent=' ' * 4):
+        """ return a copy of the source object with
+            'before' and 'after' wrapped around it.
+        """
+        before = Source(before)
+        after = Source(after)
+        newsource = Source()
+        lines = [ (indent + line) for line in self.lines]
+        newsource.lines = before.lines + lines +  after.lines
+        return newsource
+
+    def indent(self, indent=' ' * 4):
+        """ return a copy of the source object with
+            all lines indented by the given indent-string.
+        """
+        newsource = Source()
+        newsource.lines = [(indent+line) for line in self.lines]
+        return newsource
+
+    def getstatement(self, lineno, assertion=False):
+        """ return Source statement which contains the
+            given linenumber (counted from 0).
+        """
+        start, end = self.getstatementrange(lineno, assertion)
+        return self[start:end]
+
+    def getstatementrange(self, lineno, assertion=False):
+        """ return (start, end) tuple which spans the minimal
+            statement region which containing the given lineno.
+        """
+        if not (0 <= lineno < len(self)):
+            raise IndexError("lineno out of range")
+        ast, start, end = getstatementrange_ast(lineno, self)
+        return start, end
+
+    def deindent(self, offset=None):
+        """ return a new source object deindented by offset.
+            If offset is None then guess an indentation offset from
+            the first non-blank line.  Subsequent lines which have a
+            lower indentation offset will be copied verbatim as
+            they are assumed to be part of multilines.
+        """
+        # XXX maybe use the tokenizer to properly handle multiline
+        #     strings etc.pp?
+        newsource = Source()
+        newsource.lines[:] = deindent(self.lines, offset)
+        return newsource
+
+    def isparseable(self, deindent=True):
+        """ return True if source is parseable, heuristically
+            deindenting it by default.
+        """
+        try:
+            import parser
+        except ImportError:
+            syntax_checker = lambda x: compile(x, 'asd', 'exec')
+        else:
+            syntax_checker = parser.suite
+
+        if deindent:
+            source = str(self.deindent())
+        else:
+            source = str(self)
+        try:
+            #compile(source+'\n', "x", "exec")
+            syntax_checker(source+'\n')
+        except KeyboardInterrupt:
+            raise
+        except Exception:
+            return False
+        else:
+            return True
+
+    def __str__(self):
+        return "\n".join(self.lines)
+
+    def compile(self, filename=None, mode='exec',
+                flag=generators.compiler_flag,
+                dont_inherit=0, _genframe=None):
+        """ return compiled code object. if filename is None
+            invent an artificial filename which displays
+            the source/line position of the caller frame.
+        """
+        if not filename or py.path.local(filename).check(file=0):
+            if _genframe is None:
+                _genframe = sys._getframe(1) # the caller
+            fn,lineno = _genframe.f_code.co_filename, _genframe.f_lineno
+            base = "<%d-codegen " % self._compilecounter
+            self.__class__._compilecounter += 1
+            if not filename:
+                filename = base + '%s:%d>' % (fn, lineno)
+            else:
+                filename = base + '%r %s:%d>' % (filename, fn, lineno)
+        source = "\n".join(self.lines) + '\n'
+        try:
+            co = cpy_compile(source, filename, mode, flag)
+        except SyntaxError:
+            ex = sys.exc_info()[1]
+            # re-represent syntax errors from parsing python strings
+            msglines = self.lines[:ex.lineno]
+            if ex.offset:
+                msglines.append(" "*ex.offset + '^')
+            msglines.append("(code was compiled probably from here: %s)" % filename)
+            newex = SyntaxError('\n'.join(msglines))
+            newex.offset = ex.offset
+            newex.lineno = ex.lineno
+            newex.text = ex.text
+            raise newex
+        else:
+            if flag & _AST_FLAG:
+                return co
+            lines = [(x + "\n") for x in self.lines]
+            import linecache
+            linecache.cache[filename] = (1, None, lines, filename)
+            return co
+
+#
+# public API shortcut functions
+#
+
+def compile_(source, filename=None, mode='exec', flags=
+            generators.compiler_flag, dont_inherit=0):
+    """ compile the given source to a raw code object,
+        and maintain an internal cache which allows later
+        retrieval of the source code for the code object
+        and any recursively created code objects.
+    """
+    if _ast is not None and isinstance(source, _ast.AST):
+        # XXX should Source support having AST?
+        return cpy_compile(source, filename, mode, flags, dont_inherit)
+    _genframe = sys._getframe(1) # the caller
+    s = Source(source)
+    co = s.compile(filename, mode, flags, _genframe=_genframe)
+    return co
+
+
+def getfslineno(obj):
+    """ Return source location (path, lineno) for the given object.
+    If the source cannot be determined return ("", -1)
+    """
+    try:
+        code = py.code.Code(obj)
+    except TypeError:
+        try:
+            fn = (inspect.getsourcefile(obj) or
+                  inspect.getfile(obj))
+        except TypeError:
+            return "", -1
+
+        fspath = fn and py.path.local(fn) or None
+        lineno = -1
+        if fspath:
+            try:
+                _, lineno = findsource(obj)
+            except IOError:
+                pass
+    else:
+        fspath = code.path
+        lineno = code.firstlineno
+    assert isinstance(lineno, int)
+    return fspath, lineno
+
+#
+# helper functions
+#
+
+def findsource(obj):
+    try:
+        sourcelines, lineno = inspect.findsource(obj)
+    except py.builtin._sysex:
+        raise
+    except:
+        return None, -1
+    source = Source()
+    source.lines = [line.rstrip() for line in sourcelines]
+    return source, lineno
+
+def getsource(obj, **kwargs):
+    obj = py.code.getrawcode(obj)
+    try:
+        strsrc = inspect.getsource(obj)
+    except IndentationError:
+        strsrc = "\"Buggy python version consider upgrading, cannot get source\""
+    assert isinstance(strsrc, str)
+    return Source(strsrc, **kwargs)
+
+def deindent(lines, offset=None):
+    if offset is None:
+        for line in lines:
+            line = line.expandtabs()
+            s = line.lstrip()
+            if s:
+                offset = len(line)-len(s)
+                break
+        else:
+            offset = 0
+    if offset == 0:
+        return list(lines)
+    newlines = []
+    def readline_generator(lines):
+        for line in lines:
+            yield line + '\n'
+        while True:
+            yield ''
+
+    it = readline_generator(lines)
+
+    try:
+        for _, _, (sline, _), (eline, _), _ in tokenize.generate_tokens(lambda: next(it)):
+            if sline > len(lines):
+                break # End of input reached
+            if sline > len(newlines):
+                line = lines[sline - 1].expandtabs()
+                if line.lstrip() and line[:offset].isspace():
+                    line = line[offset:] # Deindent
+                newlines.append(line)
+
+            for i in range(sline, eline):
+                # Don't deindent continuing lines of
+                # multiline tokens (i.e. multiline strings)
+                newlines.append(lines[i])
+    except (IndentationError, tokenize.TokenError):
+        pass
+    # Add any lines we didn't see. E.g. if an exception was raised.
+    newlines.extend(lines[len(newlines):])
+    return newlines
+
+
+def get_statement_startend2(lineno, node):
+    import ast
+    # flatten all statements and except handlers into one lineno-list
+    # AST's line numbers start indexing at 1
+    l = []
+    for x in ast.walk(node):
+        if isinstance(x, _ast.stmt) or isinstance(x, _ast.ExceptHandler):
+            l.append(x.lineno - 1)
+            for name in "finalbody", "orelse":
+                val = getattr(x, name, None)
+                if val:
+                    # treat the finally/orelse part as its own statement
+                    l.append(val[0].lineno - 1 - 1)
+    l.sort()
+    insert_index = bisect_right(l, lineno)
+    start = l[insert_index - 1]
+    if insert_index >= len(l):
+        end = None
+    else:
+        end = l[insert_index]
+    return start, end
+
+
+def getstatementrange_ast(lineno, source, assertion=False, astnode=None):
+    if astnode is None:
+        content = str(source)
+        try:
+            astnode = compile(content, "source", "exec", 1024)  # 1024 for AST
+        except ValueError:
+            start, end = getstatementrange_old(lineno, source, assertion)
+            return None, start, end
+    start, end = get_statement_startend2(lineno, astnode)
+    # we need to correct the end:
+    # - ast-parsing strips comments
+    # - there might be empty lines
+    # - we might have lesser indented code blocks at the end
+    if end is None:
+        end = len(source.lines)
+
+    if end > start + 1:
+        # make sure we don't span differently indented code blocks
+        # by using the BlockFinder helper used which inspect.getsource() uses itself
+        block_finder = inspect.BlockFinder()
+        # if we start with an indented line, put blockfinder to "started" mode
+        block_finder.started = source.lines[start][0].isspace()
+        it = ((x + "\n") for x in source.lines[start:end])
+        try:
+            for tok in tokenize.generate_tokens(lambda: next(it)):
+                block_finder.tokeneater(*tok)
+        except (inspect.EndOfBlock, IndentationError):
+            end = block_finder.last + start
+        except Exception:
+            pass
+
+    # the end might still point to a comment or empty line, correct it
+    while end:
+        line = source.lines[end - 1].lstrip()
+        if line.startswith("#") or not line:
+            end -= 1
+        else:
+            break
+    return astnode, start, end
+
+
+def getstatementrange_old(lineno, source, assertion=False):
+    """ return (start, end) tuple which spans the minimal
+        statement region which containing the given lineno.
+        raise an IndexError if no such statementrange can be found.
+    """
+    # XXX this logic is only used on python2.4 and below
+    # 1. find the start of the statement
+    from codeop import compile_command
+    for start in range(lineno, -1, -1):
+        if assertion:
+            line = source.lines[start]
+            # the following lines are not fully tested, change with care
+            if 'super' in line and 'self' in line and '__init__' in line:
+                raise IndexError("likely a subclass")
+            if "assert" not in line and "raise" not in line:
+                continue
+        trylines = source.lines[start:lineno+1]
+        # quick hack to prepare parsing an indented line with
+        # compile_command() (which errors on "return" outside defs)
+        trylines.insert(0, 'def xxx():')
+        trysource = '\n '.join(trylines)
+        #              ^ space here
+        try:
+            compile_command(trysource)
+        except (SyntaxError, OverflowError, ValueError):
+            continue
+
+        # 2. find the end of the statement
+        for end in range(lineno+1, len(source)+1):
+            trysource = source[start:end]
+            if trysource.isparseable():
+                return start, end
+    raise SyntaxError("no valid source range around line %d " % (lineno,))
+
+
diff --git a/myenv/lib/python3.9/site-packages/py/_error.py b/myenv/lib/python3.9/site-packages/py/_error.py
new file mode 100644
index 0000000..a6375de
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_error.py
@@ -0,0 +1,91 @@
+"""
+create errno-specific classes for IO or os calls.
+
+"""
+from types import ModuleType
+import sys, os, errno
+
+class Error(EnvironmentError):
+    def __repr__(self):
+        return "%s.%s %r: %s " %(self.__class__.__module__,
+                               self.__class__.__name__,
+                               self.__class__.__doc__,
+                               " ".join(map(str, self.args)),
+                               #repr(self.args)
+                                )
+
+    def __str__(self):
+        s = "[%s]: %s" %(self.__class__.__doc__,
+                          " ".join(map(str, self.args)),
+                          )
+        return s
+
+_winerrnomap = {
+    2: errno.ENOENT,
+    3: errno.ENOENT,
+    17: errno.EEXIST,
+    18: errno.EXDEV,
+    13: errno.EBUSY, # empty cd drive, but ENOMEDIUM seems unavailiable
+    22: errno.ENOTDIR,
+    20: errno.ENOTDIR,
+    267: errno.ENOTDIR,
+    5: errno.EACCES,  # anything better?
+}
+
+class ErrorMaker(ModuleType):
+    """ lazily provides Exception classes for each possible POSIX errno
+        (as defined per the 'errno' module).  All such instances
+        subclass EnvironmentError.
+    """
+    Error = Error
+    _errno2class = {}
+
+    def __getattr__(self, name):
+        if name[0] == "_":
+            raise AttributeError(name)
+        eno = getattr(errno, name)
+        cls = self._geterrnoclass(eno)
+        setattr(self, name, cls)
+        return cls
+
+    def _geterrnoclass(self, eno):
+        try:
+            return self._errno2class[eno]
+        except KeyError:
+            clsname = errno.errorcode.get(eno, "UnknownErrno%d" %(eno,))
+            errorcls = type(Error)(clsname, (Error,),
+                    {'__module__':'py.error',
+                     '__doc__': os.strerror(eno)})
+            self._errno2class[eno] = errorcls
+            return errorcls
+
+    def checked_call(self, func, *args, **kwargs):
+        """ call a function and raise an errno-exception if applicable. """
+        __tracebackhide__ = True
+        try:
+            return func(*args, **kwargs)
+        except self.Error:
+            raise
+        except (OSError, EnvironmentError):
+            cls, value, tb = sys.exc_info()
+            if not hasattr(value, 'errno'):
+                raise
+            __tracebackhide__ = False
+            errno = value.errno
+            try:
+                if not isinstance(value, WindowsError):
+                    raise NameError
+            except NameError:
+                # we are not on Windows, or we got a proper OSError
+                cls = self._geterrnoclass(errno)
+            else:
+                try:
+                    cls = self._geterrnoclass(_winerrnomap[errno])
+                except KeyError:
+                    raise value
+            raise cls("%s%r" % (func.__name__, args))
+            __tracebackhide__ = True
+            
+
+error = ErrorMaker('py.error')
+sys.modules[error.__name__] = error
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/py/_io/__init__.py b/myenv/lib/python3.9/site-packages/py/_io/__init__.py
new file mode 100644
index 0000000..835f01f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_io/__init__.py
@@ -0,0 +1 @@
+""" input/output helping """
diff --git a/myenv/lib/python3.9/site-packages/py/_io/capture.py b/myenv/lib/python3.9/site-packages/py/_io/capture.py
new file mode 100644
index 0000000..cacf2fa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_io/capture.py
@@ -0,0 +1,371 @@
+import os
+import sys
+import py
+import tempfile
+
+try:
+    from io import StringIO
+except ImportError:
+    from StringIO import StringIO
+
+if sys.version_info < (3,0):
+    class TextIO(StringIO):
+        def write(self, data):
+            if not isinstance(data, unicode):
+                data = unicode(data, getattr(self, '_encoding', 'UTF-8'), 'replace')
+            return StringIO.write(self, data)
+else:
+    TextIO = StringIO
+
+try:
+    from io import BytesIO
+except ImportError:
+    class BytesIO(StringIO):
+        def write(self, data):
+            if isinstance(data, unicode):
+                raise TypeError("not a byte value: %r" %(data,))
+            return StringIO.write(self, data)
+
+patchsysdict = {0: 'stdin', 1: 'stdout', 2: 'stderr'}
+
+class FDCapture:
+    """ Capture IO to/from a given os-level filedescriptor. """
+
+    def __init__(self, targetfd, tmpfile=None, now=True, patchsys=False):
+        """ save targetfd descriptor, and open a new
+            temporary file there.  If no tmpfile is
+            specified a tempfile.Tempfile() will be opened
+            in text mode.
+        """
+        self.targetfd = targetfd
+        if tmpfile is None and targetfd != 0:
+            f = tempfile.TemporaryFile('wb+')
+            tmpfile = dupfile(f, encoding="UTF-8")
+            f.close()
+        self.tmpfile = tmpfile
+        self._savefd = os.dup(self.targetfd)
+        if patchsys:
+            self._oldsys = getattr(sys, patchsysdict[targetfd])
+        if now:
+            self.start()
+
+    def start(self):
+        try:
+            os.fstat(self._savefd)
+        except OSError:
+            raise ValueError("saved filedescriptor not valid, "
+                "did you call start() twice?")
+        if self.targetfd == 0 and not self.tmpfile:
+            fd = os.open(devnullpath, os.O_RDONLY)
+            os.dup2(fd, 0)
+            os.close(fd)
+            if hasattr(self, '_oldsys'):
+                setattr(sys, patchsysdict[self.targetfd], DontReadFromInput())
+        else:
+            os.dup2(self.tmpfile.fileno(), self.targetfd)
+            if hasattr(self, '_oldsys'):
+                setattr(sys, patchsysdict[self.targetfd], self.tmpfile)
+
+    def done(self):
+        """ unpatch and clean up, returns the self.tmpfile (file object)
+        """
+        os.dup2(self._savefd, self.targetfd)
+        os.close(self._savefd)
+        if self.targetfd != 0:
+            self.tmpfile.seek(0)
+        if hasattr(self, '_oldsys'):
+            setattr(sys, patchsysdict[self.targetfd], self._oldsys)
+        return self.tmpfile
+
+    def writeorg(self, data):
+        """ write a string to the original file descriptor
+        """
+        tempfp = tempfile.TemporaryFile()
+        try:
+            os.dup2(self._savefd, tempfp.fileno())
+            tempfp.write(data)
+        finally:
+            tempfp.close()
+
+
+def dupfile(f, mode=None, buffering=0, raising=False, encoding=None):
+    """ return a new open file object that's a duplicate of f
+
+        mode is duplicated if not given, 'buffering' controls
+        buffer size (defaulting to no buffering) and 'raising'
+        defines whether an exception is raised when an incompatible
+        file object is passed in (if raising is False, the file
+        object itself will be returned)
+    """
+    try:
+        fd = f.fileno()
+        mode = mode or f.mode
+    except AttributeError:
+        if raising:
+            raise
+        return f
+    newfd = os.dup(fd)
+    if sys.version_info >= (3,0):
+        if encoding is not None:
+            mode = mode.replace("b", "")
+            buffering = True
+        return os.fdopen(newfd, mode, buffering, encoding, closefd=True)
+    else:
+        f = os.fdopen(newfd, mode, buffering)
+        if encoding is not None:
+            return EncodedFile(f, encoding)
+        return f
+
+class EncodedFile(object):
+    def __init__(self, _stream, encoding):
+        self._stream = _stream
+        self.encoding = encoding
+
+    def write(self, obj):
+        if isinstance(obj, unicode):
+            obj = obj.encode(self.encoding)
+        elif isinstance(obj, str):
+            pass
+        else:
+            obj = str(obj)
+        self._stream.write(obj)
+
+    def writelines(self, linelist):
+        data = ''.join(linelist)
+        self.write(data)
+
+    def __getattr__(self, name):
+        return getattr(self._stream, name)
+
+class Capture(object):
+    def call(cls, func, *args, **kwargs):
+        """ return a (res, out, err) tuple where
+            out and err represent the output/error output
+            during function execution.
+            call the given function with args/kwargs
+            and capture output/error during its execution.
+        """
+        so = cls()
+        try:
+            res = func(*args, **kwargs)
+        finally:
+            out, err = so.reset()
+        return res, out, err
+    call = classmethod(call)
+
+    def reset(self):
+        """ reset sys.stdout/stderr and return captured output as strings. """
+        if hasattr(self, '_reset'):
+            raise ValueError("was already reset")
+        self._reset = True
+        outfile, errfile = self.done(save=False)
+        out, err = "", ""
+        if outfile and not outfile.closed:
+            out = outfile.read()
+            outfile.close()
+        if errfile and errfile != outfile and not errfile.closed:
+            err = errfile.read()
+            errfile.close()
+        return out, err
+
+    def suspend(self):
+        """ return current snapshot captures, memorize tempfiles. """
+        outerr = self.readouterr()
+        outfile, errfile = self.done()
+        return outerr
+
+
+class StdCaptureFD(Capture):
+    """ This class allows to capture writes to FD1 and FD2
+        and may connect a NULL file to FD0 (and prevent
+        reads from sys.stdin).  If any of the 0,1,2 file descriptors
+        is invalid it will not be captured.
+    """
+    def __init__(self, out=True, err=True, mixed=False,
+        in_=True, patchsys=True, now=True):
+        self._options = {
+            "out": out,
+            "err": err,
+            "mixed": mixed,
+            "in_": in_,
+            "patchsys": patchsys,
+            "now": now,
+        }
+        self._save()
+        if now:
+            self.startall()
+
+    def _save(self):
+        in_ = self._options['in_']
+        out = self._options['out']
+        err = self._options['err']
+        mixed = self._options['mixed']
+        patchsys = self._options['patchsys']
+        if in_:
+            try:
+                self.in_ = FDCapture(0, tmpfile=None, now=False,
+                    patchsys=patchsys)
+            except OSError:
+                pass
+        if out:
+            tmpfile = None
+            if hasattr(out, 'write'):
+                tmpfile = out
+            try:
+                self.out = FDCapture(1, tmpfile=tmpfile,
+                           now=False, patchsys=patchsys)
+                self._options['out'] = self.out.tmpfile
+            except OSError:
+                pass
+        if err:
+            if out and mixed:
+                tmpfile = self.out.tmpfile
+            elif hasattr(err, 'write'):
+                tmpfile = err
+            else:
+                tmpfile = None
+            try:
+                self.err = FDCapture(2, tmpfile=tmpfile,
+                           now=False, patchsys=patchsys)
+                self._options['err'] = self.err.tmpfile
+            except OSError:
+                pass
+
+    def startall(self):
+        if hasattr(self, 'in_'):
+            self.in_.start()
+        if hasattr(self, 'out'):
+            self.out.start()
+        if hasattr(self, 'err'):
+            self.err.start()
+
+    def resume(self):
+        """ resume capturing with original temp files. """
+        self.startall()
+
+    def done(self, save=True):
+        """ return (outfile, errfile) and stop capturing. """
+        outfile = errfile = None
+        if hasattr(self, 'out') and not self.out.tmpfile.closed:
+            outfile = self.out.done()
+        if hasattr(self, 'err') and not self.err.tmpfile.closed:
+            errfile = self.err.done()
+        if hasattr(self, 'in_'):
+            tmpfile = self.in_.done()
+        if save:
+            self._save()
+        return outfile, errfile
+
+    def readouterr(self):
+        """ return snapshot value of stdout/stderr capturings. """
+        if hasattr(self, "out"):
+            out = self._readsnapshot(self.out.tmpfile)
+        else:
+            out = ""
+        if hasattr(self, "err"):
+            err = self._readsnapshot(self.err.tmpfile)
+        else:
+            err = ""
+        return out, err
+
+    def _readsnapshot(self, f):
+        f.seek(0)
+        res = f.read()
+        enc = getattr(f, "encoding", None)
+        if enc:
+            res = py.builtin._totext(res, enc, "replace")
+        f.truncate(0)
+        f.seek(0)
+        return res
+
+
+class StdCapture(Capture):
+    """ This class allows to capture writes to sys.stdout|stderr "in-memory"
+        and will raise errors on tries to read from sys.stdin. It only
+        modifies sys.stdout|stderr|stdin attributes and does not
+        touch underlying File Descriptors (use StdCaptureFD for that).
+    """
+    def __init__(self, out=True, err=True, in_=True, mixed=False, now=True):
+        self._oldout = sys.stdout
+        self._olderr = sys.stderr
+        self._oldin  = sys.stdin
+        if out and not hasattr(out, 'file'):
+            out = TextIO()
+        self.out = out
+        if err:
+            if mixed:
+                err = out
+            elif not hasattr(err, 'write'):
+                err = TextIO()
+        self.err = err
+        self.in_ = in_
+        if now:
+            self.startall()
+
+    def startall(self):
+        if self.out:
+            sys.stdout = self.out
+        if self.err:
+            sys.stderr = self.err
+        if self.in_:
+            sys.stdin  = self.in_  = DontReadFromInput()
+
+    def done(self, save=True):
+        """ return (outfile, errfile) and stop capturing. """
+        outfile = errfile = None
+        if self.out and not self.out.closed:
+            sys.stdout = self._oldout
+            outfile = self.out
+            outfile.seek(0)
+        if self.err and not self.err.closed:
+            sys.stderr = self._olderr
+            errfile = self.err
+            errfile.seek(0)
+        if self.in_:
+            sys.stdin = self._oldin
+        return outfile, errfile
+
+    def resume(self):
+        """ resume capturing with original temp files. """
+        self.startall()
+
+    def readouterr(self):
+        """ return snapshot value of stdout/stderr capturings. """
+        out = err = ""
+        if self.out:
+            out = self.out.getvalue()
+            self.out.truncate(0)
+            self.out.seek(0)
+        if self.err:
+            err = self.err.getvalue()
+            self.err.truncate(0)
+            self.err.seek(0)
+        return out, err
+
+class DontReadFromInput:
+    """Temporary stub class.  Ideally when stdin is accessed, the
+    capturing should be turned off, with possibly all data captured
+    so far sent to the screen.  This should be configurable, though,
+    because in automated test runs it is better to crash than
+    hang indefinitely.
+    """
+    def read(self, *args):
+        raise IOError("reading from stdin while output is captured")
+    readline = read
+    readlines = read
+    __iter__ = read
+
+    def fileno(self):
+        raise ValueError("redirected Stdin is pseudofile, has no fileno()")
+    def isatty(self):
+        return False
+    def close(self):
+        pass
+
+try:
+    devnullpath = os.devnull
+except AttributeError:
+    if os.name == 'nt':
+        devnullpath = 'NUL'
+    else:
+        devnullpath = '/dev/null'
diff --git a/myenv/lib/python3.9/site-packages/py/_io/saferepr.py b/myenv/lib/python3.9/site-packages/py/_io/saferepr.py
new file mode 100644
index 0000000..8518290
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_io/saferepr.py
@@ -0,0 +1,71 @@
+import py
+import sys
+
+builtin_repr = repr
+
+reprlib = py.builtin._tryimport('repr', 'reprlib')
+
+class SafeRepr(reprlib.Repr):
+    """ subclass of repr.Repr that limits the resulting size of repr()
+        and includes information on exceptions raised during the call.
+    """
+    def repr(self, x):
+        return self._callhelper(reprlib.Repr.repr, self, x)
+
+    def repr_unicode(self, x, level):
+        # Strictly speaking wrong on narrow builds
+        def repr(u):
+            if "'" not in u:
+                return py.builtin._totext("'%s'") % u
+            elif '"' not in u:
+                return py.builtin._totext('"%s"') % u
+            else:
+                return py.builtin._totext("'%s'") % u.replace("'", r"\'")
+        s = repr(x[:self.maxstring])
+        if len(s) > self.maxstring:
+            i = max(0, (self.maxstring-3)//2)
+            j = max(0, self.maxstring-3-i)
+            s = repr(x[:i] + x[len(x)-j:])
+            s = s[:i] + '...' + s[len(s)-j:]
+        return s
+
+    def repr_instance(self, x, level):
+        return self._callhelper(builtin_repr, x)
+
+    def _callhelper(self, call, x, *args):
+        try:
+            # Try the vanilla repr and make sure that the result is a string
+            s = call(x, *args)
+        except py.builtin._sysex:
+            raise
+        except:
+            cls, e, tb = sys.exc_info()
+            exc_name = getattr(cls, '__name__', 'unknown')
+            try:
+                exc_info = str(e)
+            except py.builtin._sysex:
+                raise
+            except:
+                exc_info = 'unknown'
+            return '<[%s("%s") raised in repr()] %s object at 0x%x>' % (
+                exc_name, exc_info, x.__class__.__name__, id(x))
+        else:
+            if len(s) > self.maxsize:
+                i = max(0, (self.maxsize-3)//2)
+                j = max(0, self.maxsize-3-i)
+                s = s[:i] + '...' + s[len(s)-j:]
+            return s
+
+def saferepr(obj, maxsize=240):
+    """ return a size-limited safe repr-string for the given object.
+    Failing __repr__ functions of user instances will be represented
+    with a short exception info and 'saferepr' generally takes
+    care to never raise exceptions itself.  This function is a wrapper
+    around the Repr/reprlib functionality of the standard 2.6 lib.
+    """
+    # review exception handling
+    srepr = SafeRepr()
+    srepr.maxstring = maxsize
+    srepr.maxsize = maxsize
+    srepr.maxother = 160
+    return srepr.repr(obj)
diff --git a/myenv/lib/python3.9/site-packages/py/_io/terminalwriter.py b/myenv/lib/python3.9/site-packages/py/_io/terminalwriter.py
new file mode 100644
index 0000000..442ca23
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_io/terminalwriter.py
@@ -0,0 +1,423 @@
+"""
+
+Helper functions for writing to terminals and files.
+
+"""
+
+
+import sys, os, unicodedata
+import py
+py3k = sys.version_info[0] >= 3
+py33 = sys.version_info >= (3, 3)
+from py.builtin import text, bytes
+
+win32_and_ctypes = False
+colorama = None
+if sys.platform == "win32":
+    try:
+        import colorama
+    except ImportError:
+        try:
+            import ctypes
+            win32_and_ctypes = True
+        except ImportError:
+            pass
+
+
+def _getdimensions():
+    if py33:
+        import shutil
+        size = shutil.get_terminal_size()
+        return size.lines, size.columns
+    else:
+        import termios, fcntl, struct
+        call = fcntl.ioctl(1, termios.TIOCGWINSZ, "\000" * 8)
+        height, width = struct.unpack("hhhh", call)[:2]
+        return height, width
+
+
+def get_terminal_width():
+    width = 0
+    try:
+        _, width = _getdimensions()
+    except py.builtin._sysex:
+        raise
+    except:
+        # pass to fallback below
+        pass
+
+    if width == 0:
+        # FALLBACK:
+        # * some exception happened
+        # * or this is emacs terminal which reports (0,0)
+        width = int(os.environ.get('COLUMNS', 80))
+
+    # XXX the windows getdimensions may be bogus, let's sanify a bit
+    if width < 40:
+        width = 80
+    return width
+
+terminal_width = get_terminal_width()
+
+char_width = {
+    'A': 1,   # "Ambiguous"
+    'F': 2,   # Fullwidth
+    'H': 1,   # Halfwidth
+    'N': 1,   # Neutral
+    'Na': 1,  # Narrow
+    'W': 2,   # Wide
+}
+
+
+def get_line_width(text):
+    text = unicodedata.normalize('NFC', text)
+    return sum(char_width.get(unicodedata.east_asian_width(c), 1) for c in text)
+
+
+# XXX unify with _escaped func below
+def ansi_print(text, esc, file=None, newline=True, flush=False):
+    if file is None:
+        file = sys.stderr
+    text = text.rstrip()
+    if esc and not isinstance(esc, tuple):
+        esc = (esc,)
+    if esc and sys.platform != "win32" and file.isatty():
+        text = (''.join(['\x1b[%sm' % cod for cod in esc])  +
+                text +
+                '\x1b[0m')     # ANSI color code "reset"
+    if newline:
+        text += '\n'
+
+    if esc and win32_and_ctypes and file.isatty():
+        if 1 in esc:
+            bold = True
+            esc = tuple([x for x in esc if x != 1])
+        else:
+            bold = False
+        esctable = {()   : FOREGROUND_WHITE,                 # normal
+                    (31,): FOREGROUND_RED,                   # red
+                    (32,): FOREGROUND_GREEN,                 # green
+                    (33,): FOREGROUND_GREEN|FOREGROUND_RED,  # yellow
+                    (34,): FOREGROUND_BLUE,                  # blue
+                    (35,): FOREGROUND_BLUE|FOREGROUND_RED,   # purple
+                    (36,): FOREGROUND_BLUE|FOREGROUND_GREEN, # cyan
+                    (37,): FOREGROUND_WHITE,                 # white
+                    (39,): FOREGROUND_WHITE,                 # reset
+                    }
+        attr = esctable.get(esc, FOREGROUND_WHITE)
+        if bold:
+            attr |= FOREGROUND_INTENSITY
+        STD_OUTPUT_HANDLE = -11
+        STD_ERROR_HANDLE = -12
+        if file is sys.stderr:
+            handle = GetStdHandle(STD_ERROR_HANDLE)
+        else:
+            handle = GetStdHandle(STD_OUTPUT_HANDLE)
+        oldcolors = GetConsoleInfo(handle).wAttributes
+        attr |= (oldcolors & 0x0f0)
+        SetConsoleTextAttribute(handle, attr)
+        while len(text) > 32768:
+            file.write(text[:32768])
+            text = text[32768:]
+        if text:
+            file.write(text)
+        SetConsoleTextAttribute(handle, oldcolors)
+    else:
+        file.write(text)
+
+    if flush:
+        file.flush()
+
+def should_do_markup(file):
+    if os.environ.get('PY_COLORS') == '1':
+        return True
+    if os.environ.get('PY_COLORS') == '0':
+        return False
+    if 'NO_COLOR' in os.environ:
+        return False
+    return hasattr(file, 'isatty') and file.isatty() \
+           and os.environ.get('TERM') != 'dumb' \
+           and not (sys.platform.startswith('java') and os._name == 'nt')
+
+class TerminalWriter(object):
+    _esctable = dict(black=30, red=31, green=32, yellow=33,
+                     blue=34, purple=35, cyan=36, white=37,
+                     Black=40, Red=41, Green=42, Yellow=43,
+                     Blue=44, Purple=45, Cyan=46, White=47,
+                     bold=1, light=2, blink=5, invert=7)
+
+    # XXX deprecate stringio argument
+    def __init__(self, file=None, stringio=False, encoding=None):
+        if file is None:
+            if stringio:
+                self.stringio = file = py.io.TextIO()
+            else:
+                from sys import stdout as file
+        elif py.builtin.callable(file) and not (
+             hasattr(file, "write") and hasattr(file, "flush")):
+            file = WriteFile(file, encoding=encoding)
+        if hasattr(file, "isatty") and file.isatty() and colorama:
+            file = colorama.AnsiToWin32(file).stream
+        self.encoding = encoding or getattr(file, 'encoding', "utf-8")
+        self._file = file
+        self.hasmarkup = should_do_markup(file)
+        self._lastlen = 0
+        self._chars_on_current_line = 0
+        self._width_of_current_line = 0
+
+    @property
+    def fullwidth(self):
+        if hasattr(self, '_terminal_width'):
+            return self._terminal_width
+        return get_terminal_width()
+
+    @fullwidth.setter
+    def fullwidth(self, value):
+        self._terminal_width = value
+
+    @property
+    def chars_on_current_line(self):
+        """Return the number of characters written so far in the current line.
+
+        Please note that this count does not produce correct results after a reline() call,
+        see #164.
+
+        .. versionadded:: 1.5.0
+
+        :rtype: int
+        """
+        return self._chars_on_current_line
+
+    @property
+    def width_of_current_line(self):
+        """Return an estimate of the width so far in the current line.
+
+        .. versionadded:: 1.6.0
+
+        :rtype: int
+        """
+        return self._width_of_current_line
+
+    def _escaped(self, text, esc):
+        if esc and self.hasmarkup:
+            text = (''.join(['\x1b[%sm' % cod for cod in esc])  +
+                text +'\x1b[0m')
+        return text
+
+    def markup(self, text, **kw):
+        esc = []
+        for name in kw:
+            if name not in self._esctable:
+                raise ValueError("unknown markup: %r" %(name,))
+            if kw[name]:
+                esc.append(self._esctable[name])
+        return self._escaped(text, tuple(esc))
+
+    def sep(self, sepchar, title=None, fullwidth=None, **kw):
+        if fullwidth is None:
+            fullwidth = self.fullwidth
+        # the goal is to have the line be as long as possible
+        # under the condition that len(line) <= fullwidth
+        if sys.platform == "win32":
+            # if we print in the last column on windows we are on a
+            # new line but there is no way to verify/neutralize this
+            # (we may not know the exact line width)
+            # so let's be defensive to avoid empty lines in the output
+            fullwidth -= 1
+        if title is not None:
+            # we want 2 + 2*len(fill) + len(title) <= fullwidth
+            # i.e.    2 + 2*len(sepchar)*N + len(title) <= fullwidth
+            #         2*len(sepchar)*N <= fullwidth - len(title) - 2
+            #         N <= (fullwidth - len(title) - 2) // (2*len(sepchar))
+            N = max((fullwidth - len(title) - 2) // (2*len(sepchar)), 1)
+            fill = sepchar * N
+            line = "%s %s %s" % (fill, title, fill)
+        else:
+            # we want len(sepchar)*N <= fullwidth
+            # i.e.    N <= fullwidth // len(sepchar)
+            line = sepchar * (fullwidth // len(sepchar))
+        # in some situations there is room for an extra sepchar at the right,
+        # in particular if we consider that with a sepchar like "_ " the
+        # trailing space is not important at the end of the line
+        if len(line) + len(sepchar.rstrip()) <= fullwidth:
+            line += sepchar.rstrip()
+
+        self.line(line, **kw)
+
+    def write(self, msg, **kw):
+        if msg:
+            if not isinstance(msg, (bytes, text)):
+                msg = text(msg)
+
+            self._update_chars_on_current_line(msg)
+
+            if self.hasmarkup and kw:
+                markupmsg = self.markup(msg, **kw)
+            else:
+                markupmsg = msg
+            write_out(self._file, markupmsg)
+
+    def _update_chars_on_current_line(self, text_or_bytes):
+        newline = b'\n' if isinstance(text_or_bytes, bytes) else '\n'
+        current_line = text_or_bytes.rsplit(newline, 1)[-1]
+        if isinstance(current_line, bytes):
+            current_line = current_line.decode('utf-8', errors='replace')
+        if newline in text_or_bytes:
+            self._chars_on_current_line = len(current_line)
+            self._width_of_current_line = get_line_width(current_line)
+        else:
+            self._chars_on_current_line += len(current_line)
+            self._width_of_current_line += get_line_width(current_line)
+
+    def line(self, s='', **kw):
+        self.write(s, **kw)
+        self._checkfill(s)
+        self.write('\n')
+
+    def reline(self, line, **kw):
+        if not self.hasmarkup:
+            raise ValueError("cannot use rewrite-line without terminal")
+        self.write(line, **kw)
+        self._checkfill(line)
+        self.write('\r')
+        self._lastlen = len(line)
+
+    def _checkfill(self, line):
+        diff2last = self._lastlen - len(line)
+        if diff2last > 0:
+            self.write(" " * diff2last)
+
+class Win32ConsoleWriter(TerminalWriter):
+    def write(self, msg, **kw):
+        if msg:
+            if not isinstance(msg, (bytes, text)):
+                msg = text(msg)
+
+            self._update_chars_on_current_line(msg)
+
+            oldcolors = None
+            if self.hasmarkup and kw:
+                handle = GetStdHandle(STD_OUTPUT_HANDLE)
+                oldcolors = GetConsoleInfo(handle).wAttributes
+                default_bg = oldcolors & 0x00F0
+                attr = default_bg
+                if kw.pop('bold', False):
+                    attr |= FOREGROUND_INTENSITY
+
+                if kw.pop('red', False):
+                    attr |= FOREGROUND_RED
+                elif kw.pop('blue', False):
+                    attr |= FOREGROUND_BLUE
+                elif kw.pop('green', False):
+                    attr |= FOREGROUND_GREEN
+                elif kw.pop('yellow', False):
+                    attr |= FOREGROUND_GREEN|FOREGROUND_RED
+                else:
+                    attr |= oldcolors & 0x0007
+
+                SetConsoleTextAttribute(handle, attr)
+            write_out(self._file, msg)
+            if oldcolors:
+                SetConsoleTextAttribute(handle, oldcolors)
+
+class WriteFile(object):
+    def __init__(self, writemethod, encoding=None):
+        self.encoding = encoding
+        self._writemethod = writemethod
+
+    def write(self, data):
+        if self.encoding:
+            data = data.encode(self.encoding, "replace")
+        self._writemethod(data)
+
+    def flush(self):
+        return
+
+
+if win32_and_ctypes:
+    TerminalWriter = Win32ConsoleWriter
+    import ctypes
+    from ctypes import wintypes
+
+    # ctypes access to the Windows console
+    STD_OUTPUT_HANDLE = -11
+    STD_ERROR_HANDLE  = -12
+    FOREGROUND_BLACK     = 0x0000 # black text
+    FOREGROUND_BLUE      = 0x0001 # text color contains blue.
+    FOREGROUND_GREEN     = 0x0002 # text color contains green.
+    FOREGROUND_RED       = 0x0004 # text color contains red.
+    FOREGROUND_WHITE     = 0x0007
+    FOREGROUND_INTENSITY = 0x0008 # text color is intensified.
+    BACKGROUND_BLACK     = 0x0000 # background color black
+    BACKGROUND_BLUE      = 0x0010 # background color contains blue.
+    BACKGROUND_GREEN     = 0x0020 # background color contains green.
+    BACKGROUND_RED       = 0x0040 # background color contains red.
+    BACKGROUND_WHITE     = 0x0070
+    BACKGROUND_INTENSITY = 0x0080 # background color is intensified.
+
+    SHORT = ctypes.c_short
+    class COORD(ctypes.Structure):
+        _fields_ = [('X', SHORT),
+                    ('Y', SHORT)]
+    class SMALL_RECT(ctypes.Structure):
+        _fields_ = [('Left', SHORT),
+                    ('Top', SHORT),
+                    ('Right', SHORT),
+                    ('Bottom', SHORT)]
+    class CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
+        _fields_ = [('dwSize', COORD),
+                    ('dwCursorPosition', COORD),
+                    ('wAttributes', wintypes.WORD),
+                    ('srWindow', SMALL_RECT),
+                    ('dwMaximumWindowSize', COORD)]
+
+    _GetStdHandle = ctypes.windll.kernel32.GetStdHandle
+    _GetStdHandle.argtypes = [wintypes.DWORD]
+    _GetStdHandle.restype = wintypes.HANDLE
+    def GetStdHandle(kind):
+        return _GetStdHandle(kind)
+
+    SetConsoleTextAttribute = ctypes.windll.kernel32.SetConsoleTextAttribute
+    SetConsoleTextAttribute.argtypes = [wintypes.HANDLE, wintypes.WORD]
+    SetConsoleTextAttribute.restype = wintypes.BOOL
+
+    _GetConsoleScreenBufferInfo = \
+        ctypes.windll.kernel32.GetConsoleScreenBufferInfo
+    _GetConsoleScreenBufferInfo.argtypes = [wintypes.HANDLE,
+                                ctypes.POINTER(CONSOLE_SCREEN_BUFFER_INFO)]
+    _GetConsoleScreenBufferInfo.restype = wintypes.BOOL
+    def GetConsoleInfo(handle):
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        _GetConsoleScreenBufferInfo(handle, ctypes.byref(info))
+        return info
+
+    def _getdimensions():
+        handle = GetStdHandle(STD_OUTPUT_HANDLE)
+        info = GetConsoleInfo(handle)
+        # Substract one from the width, otherwise the cursor wraps
+        # and the ending \n causes an empty line to display.
+        return info.dwSize.Y, info.dwSize.X - 1
+
+def write_out(fil, msg):
+    # XXX sometimes "msg" is of type bytes, sometimes text which
+    # complicates the situation.  Should we try to enforce unicode?
+    try:
+        # on py27 and above writing out to sys.stdout with an encoding
+        # should usually work for unicode messages (if the encoding is
+        # capable of it)
+        fil.write(msg)
+    except UnicodeEncodeError:
+        # on py26 it might not work because stdout expects bytes
+        if fil.encoding:
+            try:
+                fil.write(msg.encode(fil.encoding))
+            except UnicodeEncodeError:
+                # it might still fail if the encoding is not capable
+                pass
+            else:
+                fil.flush()
+                return
+        # fallback: escape all unicode characters
+        msg = msg.encode("unicode-escape").decode("ascii")
+        fil.write(msg)
+    fil.flush()
diff --git a/myenv/lib/python3.9/site-packages/py/_log/__init__.py b/myenv/lib/python3.9/site-packages/py/_log/__init__.py
new file mode 100644
index 0000000..fad62e9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_log/__init__.py
@@ -0,0 +1,2 @@
+""" logging API ('producers' and 'consumers' connected via keywords) """
+
diff --git a/myenv/lib/python3.9/site-packages/py/_log/log.py b/myenv/lib/python3.9/site-packages/py/_log/log.py
new file mode 100644
index 0000000..56969bc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_log/log.py
@@ -0,0 +1,206 @@
+"""
+basic logging functionality based on a producer/consumer scheme.
+
+XXX implement this API: (maybe put it into slogger.py?)
+
+        log = Logger(
+                    info=py.log.STDOUT,
+                    debug=py.log.STDOUT,
+                    command=None)
+        log.info("hello", "world")
+        log.command("hello", "world")
+
+        log = Logger(info=Logger(something=...),
+                     debug=py.log.STDOUT,
+                     command=None)
+"""
+import py
+import sys
+
+
+class Message(object):
+    def __init__(self, keywords, args):
+        self.keywords = keywords
+        self.args = args
+
+    def content(self):
+        return " ".join(map(str, self.args))
+
+    def prefix(self):
+        return "[%s] " % (":".join(self.keywords))
+
+    def __str__(self):
+        return self.prefix() + self.content()
+
+
+class Producer(object):
+    """ (deprecated) Log producer API which sends messages to be logged
+        to a 'consumer' object, which then prints them to stdout,
+        stderr, files, etc. Used extensively by PyPy-1.1.
+    """
+
+    Message = Message  # to allow later customization
+    keywords2consumer = {}
+
+    def __init__(self, keywords, keywordmapper=None, **kw):
+        if hasattr(keywords, 'split'):
+            keywords = tuple(keywords.split())
+        self._keywords = keywords
+        if keywordmapper is None:
+            keywordmapper = default_keywordmapper
+        self._keywordmapper = keywordmapper
+
+    def __repr__(self):
+        return "<py.log.Producer %s>" % ":".join(self._keywords)
+
+    def __getattr__(self, name):
+        if '_' in name:
+            raise AttributeError(name)
+        producer = self.__class__(self._keywords + (name,))
+        setattr(self, name, producer)
+        return producer
+
+    def __call__(self, *args):
+        """ write a message to the appropriate consumer(s) """
+        func = self._keywordmapper.getconsumer(self._keywords)
+        if func is not None:
+            func(self.Message(self._keywords, args))
+
+class KeywordMapper:
+    def __init__(self):
+        self.keywords2consumer = {}
+
+    def getstate(self):
+        return self.keywords2consumer.copy()
+
+    def setstate(self, state):
+        self.keywords2consumer.clear()
+        self.keywords2consumer.update(state)
+
+    def getconsumer(self, keywords):
+        """ return a consumer matching the given keywords.
+
+            tries to find the most suitable consumer by walking, starting from
+            the back, the list of keywords, the first consumer matching a
+            keyword is returned (falling back to py.log.default)
+        """
+        for i in range(len(keywords), 0, -1):
+            try:
+                return self.keywords2consumer[keywords[:i]]
+            except KeyError:
+                continue
+        return self.keywords2consumer.get('default', default_consumer)
+
+    def setconsumer(self, keywords, consumer):
+        """ set a consumer for a set of keywords. """
+        # normalize to tuples
+        if isinstance(keywords, str):
+            keywords = tuple(filter(None, keywords.split()))
+        elif hasattr(keywords, '_keywords'):
+            keywords = keywords._keywords
+        elif not isinstance(keywords, tuple):
+            raise TypeError("key %r is not a string or tuple" % (keywords,))
+        if consumer is not None and not py.builtin.callable(consumer):
+            if not hasattr(consumer, 'write'):
+                raise TypeError(
+                    "%r should be None, callable or file-like" % (consumer,))
+            consumer = File(consumer)
+        self.keywords2consumer[keywords] = consumer
+
+
+def default_consumer(msg):
+    """ the default consumer, prints the message to stdout (using 'print') """
+    sys.stderr.write(str(msg)+"\n")
+
+default_keywordmapper = KeywordMapper()
+
+
+def setconsumer(keywords, consumer):
+    default_keywordmapper.setconsumer(keywords, consumer)
+
+
+def setstate(state):
+    default_keywordmapper.setstate(state)
+
+
+def getstate():
+    return default_keywordmapper.getstate()
+
+#
+# Consumers
+#
+
+
+class File(object):
+    """ log consumer wrapping a file(-like) object """
+    def __init__(self, f):
+        assert hasattr(f, 'write')
+        # assert isinstance(f, file) or not hasattr(f, 'open')
+        self._file = f
+
+    def __call__(self, msg):
+        """ write a message to the log """
+        self._file.write(str(msg) + "\n")
+        if hasattr(self._file, 'flush'):
+            self._file.flush()
+
+
+class Path(object):
+    """ log consumer that opens and writes to a Path """
+    def __init__(self, filename, append=False,
+                 delayed_create=False, buffering=False):
+        self._append = append
+        self._filename = str(filename)
+        self._buffering = buffering
+        if not delayed_create:
+            self._openfile()
+
+    def _openfile(self):
+        mode = self._append and 'a' or 'w'
+        f = open(self._filename, mode)
+        self._file = f
+
+    def __call__(self, msg):
+        """ write a message to the log """
+        if not hasattr(self, "_file"):
+            self._openfile()
+        self._file.write(str(msg) + "\n")
+        if not self._buffering:
+            self._file.flush()
+
+
+def STDOUT(msg):
+    """ consumer that writes to sys.stdout """
+    sys.stdout.write(str(msg)+"\n")
+
+
+def STDERR(msg):
+    """ consumer that writes to sys.stderr """
+    sys.stderr.write(str(msg)+"\n")
+
+
+class Syslog:
+    """ consumer that writes to the syslog daemon """
+
+    def __init__(self, priority=None):
+        if priority is None:
+            priority = self.LOG_INFO
+        self.priority = priority
+
+    def __call__(self, msg):
+        """ write a message to the log """
+        import syslog
+        syslog.syslog(self.priority, str(msg))
+
+
+try:
+    import syslog
+except ImportError:
+    pass
+else:
+    for _prio in "EMERG ALERT CRIT ERR WARNING NOTICE INFO DEBUG".split():
+        _prio = "LOG_" + _prio
+        try:
+            setattr(Syslog, _prio, getattr(syslog, _prio))
+        except AttributeError:
+            pass
diff --git a/myenv/lib/python3.9/site-packages/py/_log/warning.py b/myenv/lib/python3.9/site-packages/py/_log/warning.py
new file mode 100644
index 0000000..6ef20d9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_log/warning.py
@@ -0,0 +1,79 @@
+import py, sys
+
+class DeprecationWarning(DeprecationWarning):
+    def __init__(self, msg, path, lineno):
+        self.msg = msg
+        self.path = path
+        self.lineno = lineno
+    def __repr__(self):
+        return "%s:%d: %s" %(self.path, self.lineno+1, self.msg)
+    def __str__(self):
+        return self.msg
+
+def _apiwarn(startversion, msg, stacklevel=2, function=None):
+    # below is mostly COPIED from python2.4/warnings.py's def warn()
+    # Get context information
+    if isinstance(stacklevel, str):
+        frame = sys._getframe(1)
+        level = 1
+        found = frame.f_code.co_filename.find(stacklevel) != -1
+        while frame:
+            co = frame.f_code
+            if co.co_filename.find(stacklevel) == -1:
+                if found:
+                    stacklevel = level
+                    break
+            else:
+                found = True
+            level += 1
+            frame = frame.f_back
+        else:
+            stacklevel = 1
+    msg = "%s (since version %s)" %(msg, startversion)
+    warn(msg, stacklevel=stacklevel+1, function=function)
+
+
+def warn(msg, stacklevel=1, function=None):
+    if function is not None:
+        import inspect
+        filename = inspect.getfile(function)
+        lineno = py.code.getrawcode(function).co_firstlineno
+    else:
+        try:
+            caller = sys._getframe(stacklevel)
+        except ValueError:
+            globals = sys.__dict__
+            lineno = 1
+        else:
+            globals = caller.f_globals
+            lineno = caller.f_lineno
+        if '__name__' in globals:
+            module = globals['__name__']
+        else:
+            module = "<string>"
+        filename = globals.get('__file__')
+    if filename:
+        fnl = filename.lower()
+        if fnl.endswith(".pyc") or fnl.endswith(".pyo"):
+            filename = filename[:-1]
+        elif fnl.endswith("$py.class"):
+            filename = filename.replace('$py.class', '.py')
+    else:
+        if module == "__main__":
+            try:
+                filename = sys.argv[0]
+            except AttributeError:
+                # embedded interpreters don't have sys.argv, see bug #839151
+                filename = '__main__'
+        if not filename:
+            filename = module
+    path = py.path.local(filename)
+    warning = DeprecationWarning(msg, path, lineno)
+    import warnings
+    warnings.warn_explicit(warning, category=Warning,
+        filename=str(warning.path),
+        lineno=warning.lineno,
+        registry=warnings.__dict__.setdefault(
+            "__warningsregistry__", {})
+    )
+
diff --git a/myenv/lib/python3.9/site-packages/py/_path/__init__.py b/myenv/lib/python3.9/site-packages/py/_path/__init__.py
new file mode 100644
index 0000000..51f3246
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_path/__init__.py
@@ -0,0 +1 @@
+""" unified file system api """
diff --git a/myenv/lib/python3.9/site-packages/py/_path/cacheutil.py b/myenv/lib/python3.9/site-packages/py/_path/cacheutil.py
new file mode 100644
index 0000000..9922504
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_path/cacheutil.py
@@ -0,0 +1,114 @@
+"""
+This module contains multithread-safe cache implementations.
+
+All Caches have
+
+    getorbuild(key, builder)
+    delentry(key)
+
+methods and allow configuration when instantiating the cache class.
+"""
+from time import time as gettime
+
+class BasicCache(object):
+    def __init__(self, maxentries=128):
+        self.maxentries = maxentries
+        self.prunenum = int(maxentries - maxentries/8)
+        self._dict = {}
+
+    def clear(self):
+        self._dict.clear()
+
+    def _getentry(self, key):
+        return self._dict[key]
+
+    def _putentry(self, key, entry):
+        self._prunelowestweight()
+        self._dict[key] = entry
+
+    def delentry(self, key, raising=False):
+        try:
+            del self._dict[key]
+        except KeyError:
+            if raising:
+                raise
+
+    def getorbuild(self, key, builder):
+        try:
+            entry = self._getentry(key)
+        except KeyError:
+            entry = self._build(key, builder)
+            self._putentry(key, entry)
+        return entry.value
+
+    def _prunelowestweight(self):
+        """ prune out entries with lowest weight. """
+        numentries = len(self._dict)
+        if numentries >= self.maxentries:
+            # evict according to entry's weight
+            items = [(entry.weight, key)
+                        for key, entry in self._dict.items()]
+            items.sort()
+            index = numentries - self.prunenum
+            if index > 0:
+                for weight, key in items[:index]:
+                    # in MT situations the element might be gone
+                    self.delentry(key, raising=False)
+
+class BuildcostAccessCache(BasicCache):
+    """ A BuildTime/Access-counting cache implementation.
+        the weight of a value is computed as the product of
+
+            num-accesses-of-a-value * time-to-build-the-value
+
+        The values with the least such weights are evicted
+        if the cache maxentries threshold is superceded.
+        For implementation flexibility more than one object
+        might be evicted at a time.
+    """
+    # time function to use for measuring build-times
+
+    def _build(self, key, builder):
+        start = gettime()
+        val = builder()
+        end = gettime()
+        return WeightedCountingEntry(val, end-start)
+
+
+class WeightedCountingEntry(object):
+    def __init__(self, value, oneweight):
+        self._value = value
+        self.weight = self._oneweight = oneweight
+
+    def value(self):
+        self.weight += self._oneweight
+        return self._value
+    value = property(value)
+
+class AgingCache(BasicCache):
+    """ This cache prunes out cache entries that are too old.
+    """
+    def __init__(self, maxentries=128, maxseconds=10.0):
+        super(AgingCache, self).__init__(maxentries)
+        self.maxseconds = maxseconds
+
+    def _getentry(self, key):
+        entry = self._dict[key]
+        if entry.isexpired():
+            self.delentry(key)
+            raise KeyError(key)
+        return entry
+
+    def _build(self, key, builder):
+        val = builder()
+        entry = AgingEntry(val, gettime() + self.maxseconds)
+        return entry
+
+class AgingEntry(object):
+    def __init__(self, value, expirationtime):
+        self.value = value
+        self.weight = expirationtime
+
+    def isexpired(self):
+        t = gettime()
+        return t >= self.weight
diff --git a/myenv/lib/python3.9/site-packages/py/_path/common.py b/myenv/lib/python3.9/site-packages/py/_path/common.py
new file mode 100644
index 0000000..2364e5f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_path/common.py
@@ -0,0 +1,459 @@
+"""
+"""
+import warnings
+import os
+import sys
+import posixpath
+import fnmatch
+import py
+
+# Moved from local.py.
+iswin32 = sys.platform == "win32" or (getattr(os, '_name', False) == 'nt')
+
+try:
+    # FileNotFoundError might happen in py34, and is not available with py27.
+    import_errors = (ImportError, FileNotFoundError)
+except NameError:
+    import_errors = (ImportError,)
+
+try:
+    from os import fspath
+except ImportError:
+    def fspath(path):
+        """
+        Return the string representation of the path.
+        If str or bytes is passed in, it is returned unchanged.
+        This code comes from PEP 519, modified to support earlier versions of
+        python.
+
+        This is required for python < 3.6.
+        """
+        if isinstance(path, (py.builtin.text, py.builtin.bytes)):
+            return path
+
+        # Work from the object's type to match method resolution of other magic
+        # methods.
+        path_type = type(path)
+        try:
+            return path_type.__fspath__(path)
+        except AttributeError:
+            if hasattr(path_type, '__fspath__'):
+                raise
+            try:
+                import pathlib
+            except import_errors:
+                pass
+            else:
+                if isinstance(path, pathlib.PurePath):
+                    return py.builtin.text(path)
+
+            raise TypeError("expected str, bytes or os.PathLike object, not "
+                            + path_type.__name__)
+
+class Checkers:
+    _depend_on_existence = 'exists', 'link', 'dir', 'file'
+
+    def __init__(self, path):
+        self.path = path
+
+    def dir(self):
+        raise NotImplementedError
+
+    def file(self):
+        raise NotImplementedError
+
+    def dotfile(self):
+        return self.path.basename.startswith('.')
+
+    def ext(self, arg):
+        if not arg.startswith('.'):
+            arg = '.' + arg
+        return self.path.ext == arg
+
+    def exists(self):
+        raise NotImplementedError
+
+    def basename(self, arg):
+        return self.path.basename == arg
+
+    def basestarts(self, arg):
+        return self.path.basename.startswith(arg)
+
+    def relto(self, arg):
+        return self.path.relto(arg)
+
+    def fnmatch(self, arg):
+        return self.path.fnmatch(arg)
+
+    def endswith(self, arg):
+        return str(self.path).endswith(arg)
+
+    def _evaluate(self, kw):
+        for name, value in kw.items():
+            invert = False
+            meth = None
+            try:
+                meth = getattr(self, name)
+            except AttributeError:
+                if name[:3] == 'not':
+                    invert = True
+                    try:
+                        meth = getattr(self, name[3:])
+                    except AttributeError:
+                        pass
+            if meth is None:
+                raise TypeError(
+                    "no %r checker available for %r" % (name, self.path))
+            try:
+                if py.code.getrawcode(meth).co_argcount > 1:
+                    if (not meth(value)) ^ invert:
+                        return False
+                else:
+                    if bool(value) ^ bool(meth()) ^ invert:
+                        return False
+            except (py.error.ENOENT, py.error.ENOTDIR, py.error.EBUSY):
+                # EBUSY feels not entirely correct,
+                # but its kind of necessary since ENOMEDIUM
+                # is not accessible in python
+                for name in self._depend_on_existence:
+                    if name in kw:
+                        if kw.get(name):
+                            return False
+                    name = 'not' + name
+                    if name in kw:
+                        if not kw.get(name):
+                            return False
+        return True
+
+class NeverRaised(Exception):
+    pass
+
+class PathBase(object):
+    """ shared implementation for filesystem path objects."""
+    Checkers = Checkers
+
+    def __div__(self, other):
+        return self.join(fspath(other))
+    __truediv__ = __div__ # py3k
+
+    def basename(self):
+        """ basename part of path. """
+        return self._getbyspec('basename')[0]
+    basename = property(basename, None, None, basename.__doc__)
+
+    def dirname(self):
+        """ dirname part of path. """
+        return self._getbyspec('dirname')[0]
+    dirname = property(dirname, None, None, dirname.__doc__)
+
+    def purebasename(self):
+        """ pure base name of the path."""
+        return self._getbyspec('purebasename')[0]
+    purebasename = property(purebasename, None, None, purebasename.__doc__)
+
+    def ext(self):
+        """ extension of the path (including the '.')."""
+        return self._getbyspec('ext')[0]
+    ext = property(ext, None, None, ext.__doc__)
+
+    def dirpath(self, *args, **kwargs):
+        """ return the directory path joined with any given path arguments.  """
+        return self.new(basename='').join(*args, **kwargs)
+
+    def read_binary(self):
+        """ read and return a bytestring from reading the path. """
+        with self.open('rb') as f:
+            return f.read()
+
+    def read_text(self, encoding):
+        """ read and return a Unicode string from reading the path. """
+        with self.open("r", encoding=encoding) as f:
+            return f.read()
+
+
+    def read(self, mode='r'):
+        """ read and return a bytestring from reading the path. """
+        with self.open(mode) as f:
+            return f.read()
+
+    def readlines(self, cr=1):
+        """ read and return a list of lines from the path. if cr is False, the
+newline will be removed from the end of each line. """
+        if sys.version_info < (3, ):
+            mode = 'rU'
+        else:  # python 3 deprecates mode "U" in favor of "newline" option
+            mode = 'r'
+
+        if not cr:
+            content = self.read(mode)
+            return content.split('\n')
+        else:
+            f = self.open(mode)
+            try:
+                return f.readlines()
+            finally:
+                f.close()
+
+    def load(self):
+        """ (deprecated) return object unpickled from self.read() """
+        f = self.open('rb')
+        try:
+            import pickle
+            return py.error.checked_call(pickle.load, f)
+        finally:
+            f.close()
+
+    def move(self, target):
+        """ move this path to target. """
+        if target.relto(self):
+            raise py.error.EINVAL(
+                target,
+                "cannot move path into a subdirectory of itself")
+        try:
+            self.rename(target)
+        except py.error.EXDEV:  # invalid cross-device link
+            self.copy(target)
+            self.remove()
+
+    def __repr__(self):
+        """ return a string representation of this path. """
+        return repr(str(self))
+
+    def check(self, **kw):
+        """ check a path for existence and properties.
+
+            Without arguments, return True if the path exists, otherwise False.
+
+            valid checkers::
+
+                file=1    # is a file
+                file=0    # is not a file (may not even exist)
+                dir=1     # is a dir
+                link=1    # is a link
+                exists=1  # exists
+
+            You can specify multiple checker definitions, for example::
+
+                path.check(file=1, link=1)  # a link pointing to a file
+        """
+        if not kw:
+            kw = {'exists': 1}
+        return self.Checkers(self)._evaluate(kw)
+
+    def fnmatch(self, pattern):
+        """return true if the basename/fullname matches the glob-'pattern'.
+
+        valid pattern characters::
+
+            *       matches everything
+            ?       matches any single character
+            [seq]   matches any character in seq
+            [!seq]  matches any char not in seq
+
+        If the pattern contains a path-separator then the full path
+        is used for pattern matching and a '*' is prepended to the
+        pattern.
+
+        if the pattern doesn't contain a path-separator the pattern
+        is only matched against the basename.
+        """
+        return FNMatcher(pattern)(self)
+
+    def relto(self, relpath):
+        """ return a string which is the relative part of the path
+        to the given 'relpath'.
+        """
+        if not isinstance(relpath, (str, PathBase)):
+            raise TypeError("%r: not a string or path object" %(relpath,))
+        strrelpath = str(relpath)
+        if strrelpath and strrelpath[-1] != self.sep:
+            strrelpath += self.sep
+        #assert strrelpath[-1] == self.sep
+        #assert strrelpath[-2] != self.sep
+        strself = self.strpath
+        if sys.platform == "win32" or getattr(os, '_name', None) == 'nt':
+            if os.path.normcase(strself).startswith(
+               os.path.normcase(strrelpath)):
+                return strself[len(strrelpath):]
+        elif strself.startswith(strrelpath):
+            return strself[len(strrelpath):]
+        return ""
+
+    def ensure_dir(self, *args):
+        """ ensure the path joined with args is a directory. """
+        return self.ensure(*args, **{"dir": True})
+
+    def bestrelpath(self, dest):
+        """ return a string which is a relative path from self
+            (assumed to be a directory) to dest such that
+            self.join(bestrelpath) == dest and if not such
+            path can be determined return dest.
+        """
+        try:
+            if self == dest:
+                return os.curdir
+            base = self.common(dest)
+            if not base:  # can be the case on windows
+                return str(dest)
+            self2base = self.relto(base)
+            reldest = dest.relto(base)
+            if self2base:
+                n = self2base.count(self.sep) + 1
+            else:
+                n = 0
+            l = [os.pardir] * n
+            if reldest:
+                l.append(reldest)
+            target = dest.sep.join(l)
+            return target
+        except AttributeError:
+            return str(dest)
+
+    def exists(self):
+        return self.check()
+
+    def isdir(self):
+        return self.check(dir=1)
+
+    def isfile(self):
+        return self.check(file=1)
+
+    def parts(self, reverse=False):
+        """ return a root-first list of all ancestor directories
+            plus the path itself.
+        """
+        current = self
+        l = [self]
+        while 1:
+            last = current
+            current = current.dirpath()
+            if last == current:
+                break
+            l.append(current)
+        if not reverse:
+            l.reverse()
+        return l
+
+    def common(self, other):
+        """ return the common part shared with the other path
+            or None if there is no common part.
+        """
+        last = None
+        for x, y in zip(self.parts(), other.parts()):
+            if x != y:
+                return last
+            last = x
+        return last
+
+    def __add__(self, other):
+        """ return new path object with 'other' added to the basename"""
+        return self.new(basename=self.basename+str(other))
+
+    def __cmp__(self, other):
+        """ return sort value (-1, 0, +1). """
+        try:
+            return cmp(self.strpath, other.strpath)
+        except AttributeError:
+            return cmp(str(self), str(other)) # self.path, other.path)
+
+    def __lt__(self, other):
+        try:
+            return self.strpath < other.strpath
+        except AttributeError:
+            return str(self) < str(other)
+
+    def visit(self, fil=None, rec=None, ignore=NeverRaised, bf=False, sort=False):
+        """ yields all paths below the current one
+
+            fil is a filter (glob pattern or callable), if not matching the
+            path will not be yielded, defaulting to None (everything is
+            returned)
+
+            rec is a filter (glob pattern or callable) that controls whether
+            a node is descended, defaulting to None
+
+            ignore is an Exception class that is ignoredwhen calling dirlist()
+            on any of the paths (by default, all exceptions are reported)
+
+            bf if True will cause a breadthfirst search instead of the
+            default depthfirst. Default: False
+
+            sort if True will sort entries within each directory level.
+        """
+        for x in Visitor(fil, rec, ignore, bf, sort).gen(self):
+            yield x
+
+    def _sortlist(self, res, sort):
+        if sort:
+            if hasattr(sort, '__call__'):
+                warnings.warn(DeprecationWarning(
+                    "listdir(sort=callable) is deprecated and breaks on python3"
+                ), stacklevel=3)
+                res.sort(sort)
+            else:
+                res.sort()
+
+    def samefile(self, other):
+        """ return True if other refers to the same stat object as self. """
+        return self.strpath == str(other)
+
+    def __fspath__(self):
+        return self.strpath
+
+class Visitor:
+    def __init__(self, fil, rec, ignore, bf, sort):
+        if isinstance(fil, py.builtin._basestring):
+            fil = FNMatcher(fil)
+        if isinstance(rec, py.builtin._basestring):
+            self.rec = FNMatcher(rec)
+        elif not hasattr(rec, '__call__') and rec:
+            self.rec = lambda path: True
+        else:
+            self.rec = rec
+        self.fil = fil
+        self.ignore = ignore
+        self.breadthfirst = bf
+        self.optsort = sort and sorted or (lambda x: x)
+
+    def gen(self, path):
+        try:
+            entries = path.listdir()
+        except self.ignore:
+            return
+        rec = self.rec
+        dirs = self.optsort([p for p in entries
+                    if p.check(dir=1) and (rec is None or rec(p))])
+        if not self.breadthfirst:
+            for subdir in dirs:
+                for p in self.gen(subdir):
+                    yield p
+        for p in self.optsort(entries):
+            if self.fil is None or self.fil(p):
+                yield p
+        if self.breadthfirst:
+            for subdir in dirs:
+                for p in self.gen(subdir):
+                    yield p
+
+class FNMatcher:
+    def __init__(self, pattern):
+        self.pattern = pattern
+
+    def __call__(self, path):
+        pattern = self.pattern
+
+        if (pattern.find(path.sep) == -1 and
+        iswin32 and
+        pattern.find(posixpath.sep) != -1):
+            # Running on Windows, the pattern has no Windows path separators,
+            # and the pattern has one or more Posix path separators. Replace
+            # the Posix path separators with the Windows path separator.
+            pattern = pattern.replace(posixpath.sep, path.sep)
+
+        if pattern.find(path.sep) == -1:
+            name = path.basename
+        else:
+            name = str(path) # path.strpath # XXX svn?
+            if not os.path.isabs(pattern):
+                pattern = '*' + path.sep + pattern
+        return fnmatch.fnmatch(name, pattern)
diff --git a/myenv/lib/python3.9/site-packages/py/_path/local.py b/myenv/lib/python3.9/site-packages/py/_path/local.py
new file mode 100644
index 0000000..1385a03
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_path/local.py
@@ -0,0 +1,1030 @@
+"""
+local path implementation.
+"""
+from __future__ import with_statement
+
+from contextlib import contextmanager
+import sys, os, atexit, io, uuid
+import py
+from py._path import common
+from py._path.common import iswin32, fspath
+from stat import S_ISLNK, S_ISDIR, S_ISREG
+
+from os.path import abspath, normpath, isabs, exists, isdir, isfile, islink, dirname
+
+if sys.version_info > (3,0):
+    def map_as_list(func, iter):
+        return list(map(func, iter))
+else:
+    map_as_list = map
+
+ALLOW_IMPORTLIB_MODE = sys.version_info > (3,5)
+if ALLOW_IMPORTLIB_MODE:
+    import importlib
+
+
+class Stat(object):
+    def __getattr__(self, name):
+        return getattr(self._osstatresult, "st_" + name)
+
+    def __init__(self, path, osstatresult):
+        self.path = path
+        self._osstatresult = osstatresult
+
+    @property
+    def owner(self):
+        if iswin32:
+            raise NotImplementedError("XXX win32")
+        import pwd
+        entry = py.error.checked_call(pwd.getpwuid, self.uid)
+        return entry[0]
+
+    @property
+    def group(self):
+        """ return group name of file. """
+        if iswin32:
+            raise NotImplementedError("XXX win32")
+        import grp
+        entry = py.error.checked_call(grp.getgrgid, self.gid)
+        return entry[0]
+
+    def isdir(self):
+        return S_ISDIR(self._osstatresult.st_mode)
+
+    def isfile(self):
+        return S_ISREG(self._osstatresult.st_mode)
+
+    def islink(self):
+        st = self.path.lstat()
+        return S_ISLNK(self._osstatresult.st_mode)
+
+class PosixPath(common.PathBase):
+    def chown(self, user, group, rec=0):
+        """ change ownership to the given user and group.
+            user and group may be specified by a number or
+            by a name.  if rec is True change ownership
+            recursively.
+        """
+        uid = getuserid(user)
+        gid = getgroupid(group)
+        if rec:
+            for x in self.visit(rec=lambda x: x.check(link=0)):
+                if x.check(link=0):
+                    py.error.checked_call(os.chown, str(x), uid, gid)
+        py.error.checked_call(os.chown, str(self), uid, gid)
+
+    def readlink(self):
+        """ return value of a symbolic link. """
+        return py.error.checked_call(os.readlink, self.strpath)
+
+    def mklinkto(self, oldname):
+        """ posix style hard link to another name. """
+        py.error.checked_call(os.link, str(oldname), str(self))
+
+    def mksymlinkto(self, value, absolute=1):
+        """ create a symbolic link with the given value (pointing to another name). """
+        if absolute:
+            py.error.checked_call(os.symlink, str(value), self.strpath)
+        else:
+            base = self.common(value)
+            # with posix local paths '/' is always a common base
+            relsource = self.__class__(value).relto(base)
+            reldest = self.relto(base)
+            n = reldest.count(self.sep)
+            target = self.sep.join(('..', )*n + (relsource, ))
+            py.error.checked_call(os.symlink, target, self.strpath)
+
+def getuserid(user):
+    import pwd
+    if not isinstance(user, int):
+        user = pwd.getpwnam(user)[2]
+    return user
+
+def getgroupid(group):
+    import grp
+    if not isinstance(group, int):
+        group = grp.getgrnam(group)[2]
+    return group
+
+FSBase = not iswin32 and PosixPath or common.PathBase
+
+class LocalPath(FSBase):
+    """ object oriented interface to os.path and other local filesystem
+        related information.
+    """
+    class ImportMismatchError(ImportError):
+        """ raised on pyimport() if there is a mismatch of __file__'s"""
+
+    sep = os.sep
+    class Checkers(common.Checkers):
+        def _stat(self):
+            try:
+                return self._statcache
+            except AttributeError:
+                try:
+                    self._statcache = self.path.stat()
+                except py.error.ELOOP:
+                    self._statcache = self.path.lstat()
+                return self._statcache
+
+        def dir(self):
+            return S_ISDIR(self._stat().mode)
+
+        def file(self):
+            return S_ISREG(self._stat().mode)
+
+        def exists(self):
+            return self._stat()
+
+        def link(self):
+            st = self.path.lstat()
+            return S_ISLNK(st.mode)
+
+    def __init__(self, path=None, expanduser=False):
+        """ Initialize and return a local Path instance.
+
+        Path can be relative to the current directory.
+        If path is None it defaults to the current working directory.
+        If expanduser is True, tilde-expansion is performed.
+        Note that Path instances always carry an absolute path.
+        Note also that passing in a local path object will simply return
+        the exact same path object. Use new() to get a new copy.
+        """
+        if path is None:
+            self.strpath = py.error.checked_call(os.getcwd)
+        else:
+            try:
+                path = fspath(path)
+            except TypeError:
+                raise ValueError("can only pass None, Path instances "
+                                 "or non-empty strings to LocalPath")
+            if expanduser:
+                path = os.path.expanduser(path)
+            self.strpath = abspath(path)
+
+    def __hash__(self):
+        s = self.strpath
+        if iswin32:
+            s = s.lower()
+        return hash(s)
+
+    def __eq__(self, other):
+        s1 = fspath(self)
+        try:
+            s2 = fspath(other)
+        except TypeError:
+            return False
+        if iswin32:
+            s1 = s1.lower()
+            try:
+                s2 = s2.lower()
+            except AttributeError:
+                return False
+        return s1 == s2
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __lt__(self, other):
+        return fspath(self) < fspath(other)
+
+    def __gt__(self, other):
+        return fspath(self) > fspath(other)
+
+    def samefile(self, other):
+        """ return True if 'other' references the same file as 'self'.
+        """
+        other = fspath(other)
+        if not isabs(other):
+            other = abspath(other)
+        if self == other:
+            return True
+        if not hasattr(os.path, "samefile"):
+            return False
+        return py.error.checked_call(
+                os.path.samefile, self.strpath, other)
+
+    def remove(self, rec=1, ignore_errors=False):
+        """ remove a file or directory (or a directory tree if rec=1).
+        if ignore_errors is True, errors while removing directories will
+        be ignored.
+        """
+        if self.check(dir=1, link=0):
+            if rec:
+                # force remove of readonly files on windows
+                if iswin32:
+                    self.chmod(0o700, rec=1)
+                import shutil
+                py.error.checked_call(
+                    shutil.rmtree, self.strpath,
+                    ignore_errors=ignore_errors)
+            else:
+                py.error.checked_call(os.rmdir, self.strpath)
+        else:
+            if iswin32:
+                self.chmod(0o700)
+            py.error.checked_call(os.remove, self.strpath)
+
+    def computehash(self, hashtype="md5", chunksize=524288):
+        """ return hexdigest of hashvalue for this file. """
+        try:
+            try:
+                import hashlib as mod
+            except ImportError:
+                if hashtype == "sha1":
+                    hashtype = "sha"
+                mod = __import__(hashtype)
+            hash = getattr(mod, hashtype)()
+        except (AttributeError, ImportError):
+            raise ValueError("Don't know how to compute %r hash" %(hashtype,))
+        f = self.open('rb')
+        try:
+            while 1:
+                buf = f.read(chunksize)
+                if not buf:
+                    return hash.hexdigest()
+                hash.update(buf)
+        finally:
+            f.close()
+
+    def new(self, **kw):
+        """ create a modified version of this path.
+            the following keyword arguments modify various path parts::
+
+              a:/some/path/to/a/file.ext
+              xx                           drive
+              xxxxxxxxxxxxxxxxx            dirname
+                                xxxxxxxx   basename
+                                xxxx       purebasename
+                                     xxx   ext
+        """
+        obj = object.__new__(self.__class__)
+        if not kw:
+            obj.strpath = self.strpath
+            return obj
+        drive, dirname, basename, purebasename,ext = self._getbyspec(
+             "drive,dirname,basename,purebasename,ext")
+        if 'basename' in kw:
+            if 'purebasename' in kw or 'ext' in kw:
+                raise ValueError("invalid specification %r" % kw)
+        else:
+            pb = kw.setdefault('purebasename', purebasename)
+            try:
+                ext = kw['ext']
+            except KeyError:
+                pass
+            else:
+                if ext and not ext.startswith('.'):
+                    ext = '.' + ext
+            kw['basename'] = pb + ext
+
+        if ('dirname' in kw and not kw['dirname']):
+            kw['dirname'] = drive
+        else:
+            kw.setdefault('dirname', dirname)
+        kw.setdefault('sep', self.sep)
+        obj.strpath = normpath(
+            "%(dirname)s%(sep)s%(basename)s" % kw)
+        return obj
+
+    def _getbyspec(self, spec):
+        """ see new for what 'spec' can be. """
+        res = []
+        parts = self.strpath.split(self.sep)
+
+        args = filter(None, spec.split(',') )
+        append = res.append
+        for name in args:
+            if name == 'drive':
+                append(parts[0])
+            elif name == 'dirname':
+                append(self.sep.join(parts[:-1]))
+            else:
+                basename = parts[-1]
+                if name == 'basename':
+                    append(basename)
+                else:
+                    i = basename.rfind('.')
+                    if i == -1:
+                        purebasename, ext = basename, ''
+                    else:
+                        purebasename, ext = basename[:i], basename[i:]
+                    if name == 'purebasename':
+                        append(purebasename)
+                    elif name == 'ext':
+                        append(ext)
+                    else:
+                        raise ValueError("invalid part specification %r" % name)
+        return res
+
+    def dirpath(self, *args, **kwargs):
+        """ return the directory path joined with any given path arguments.  """
+        if not kwargs:
+            path = object.__new__(self.__class__)
+            path.strpath = dirname(self.strpath)
+            if args:
+                path = path.join(*args)
+            return path
+        return super(LocalPath, self).dirpath(*args, **kwargs)
+
+    def join(self, *args, **kwargs):
+        """ return a new path by appending all 'args' as path
+        components.  if abs=1 is used restart from root if any
+        of the args is an absolute path.
+        """
+        sep = self.sep
+        strargs = [fspath(arg) for arg in args]
+        strpath = self.strpath
+        if kwargs.get('abs'):
+            newargs = []
+            for arg in reversed(strargs):
+                if isabs(arg):
+                    strpath = arg
+                    strargs = newargs
+                    break
+                newargs.insert(0, arg)
+        # special case for when we have e.g. strpath == "/"
+        actual_sep = "" if strpath.endswith(sep) else sep
+        for arg in strargs:
+            arg = arg.strip(sep)
+            if iswin32:
+                # allow unix style paths even on windows.
+                arg = arg.strip('/')
+                arg = arg.replace('/', sep)
+            strpath = strpath + actual_sep + arg
+            actual_sep = sep
+        obj = object.__new__(self.__class__)
+        obj.strpath = normpath(strpath)
+        return obj
+
+    def open(self, mode='r', ensure=False, encoding=None):
+        """ return an opened file with the given mode.
+
+        If ensure is True, create parent directories if needed.
+        """
+        if ensure:
+            self.dirpath().ensure(dir=1)
+        if encoding:
+            return py.error.checked_call(io.open, self.strpath, mode, encoding=encoding)
+        return py.error.checked_call(open, self.strpath, mode)
+
+    def _fastjoin(self, name):
+        child = object.__new__(self.__class__)
+        child.strpath = self.strpath + self.sep + name
+        return child
+
+    def islink(self):
+        return islink(self.strpath)
+
+    def check(self, **kw):
+        if not kw:
+            return exists(self.strpath)
+        if len(kw) == 1:
+            if "dir" in kw:
+                return not kw["dir"] ^ isdir(self.strpath)
+            if "file" in kw:
+                return not kw["file"] ^ isfile(self.strpath)
+        return super(LocalPath, self).check(**kw)
+
+    _patternchars = set("*?[" + os.path.sep)
+    def listdir(self, fil=None, sort=None):
+        """ list directory contents, possibly filter by the given fil func
+            and possibly sorted.
+        """
+        if fil is None and sort is None:
+            names = py.error.checked_call(os.listdir, self.strpath)
+            return map_as_list(self._fastjoin, names)
+        if isinstance(fil, py.builtin._basestring):
+            if not self._patternchars.intersection(fil):
+                child = self._fastjoin(fil)
+                if exists(child.strpath):
+                    return [child]
+                return []
+            fil = common.FNMatcher(fil)
+        names = py.error.checked_call(os.listdir, self.strpath)
+        res = []
+        for name in names:
+            child = self._fastjoin(name)
+            if fil is None or fil(child):
+                res.append(child)
+        self._sortlist(res, sort)
+        return res
+
+    def size(self):
+        """ return size of the underlying file object """
+        return self.stat().size
+
+    def mtime(self):
+        """ return last modification time of the path. """
+        return self.stat().mtime
+
+    def copy(self, target, mode=False, stat=False):
+        """ copy path to target.
+
+            If mode is True, will copy copy permission from path to target.
+            If stat is True, copy permission, last modification
+            time, last access time, and flags from path to target.
+        """
+        if self.check(file=1):
+            if target.check(dir=1):
+                target = target.join(self.basename)
+            assert self!=target
+            copychunked(self, target)
+            if mode:
+                copymode(self.strpath, target.strpath)
+            if stat:
+                copystat(self, target)
+        else:
+            def rec(p):
+                return p.check(link=0)
+            for x in self.visit(rec=rec):
+                relpath = x.relto(self)
+                newx = target.join(relpath)
+                newx.dirpath().ensure(dir=1)
+                if x.check(link=1):
+                    newx.mksymlinkto(x.readlink())
+                    continue
+                elif x.check(file=1):
+                    copychunked(x, newx)
+                elif x.check(dir=1):
+                    newx.ensure(dir=1)
+                if mode:
+                    copymode(x.strpath, newx.strpath)
+                if stat:
+                    copystat(x, newx)
+
+    def rename(self, target):
+        """ rename this path to target. """
+        target = fspath(target)
+        return py.error.checked_call(os.rename, self.strpath, target)
+
+    def dump(self, obj, bin=1):
+        """ pickle object into path location"""
+        f = self.open('wb')
+        import pickle
+        try:
+            py.error.checked_call(pickle.dump, obj, f, bin)
+        finally:
+            f.close()
+
+    def mkdir(self, *args):
+        """ create & return the directory joined with args. """
+        p = self.join(*args)
+        py.error.checked_call(os.mkdir, fspath(p))
+        return p
+
+    def write_binary(self, data, ensure=False):
+        """ write binary data into path.   If ensure is True create
+        missing parent directories.
+        """
+        if ensure:
+            self.dirpath().ensure(dir=1)
+        with self.open('wb') as f:
+            f.write(data)
+
+    def write_text(self, data, encoding, ensure=False):
+        """ write text data into path using the specified encoding.
+        If ensure is True create missing parent directories.
+        """
+        if ensure:
+            self.dirpath().ensure(dir=1)
+        with self.open('w', encoding=encoding) as f:
+            f.write(data)
+
+    def write(self, data, mode='w', ensure=False):
+        """ write data into path.   If ensure is True create
+        missing parent directories.
+        """
+        if ensure:
+            self.dirpath().ensure(dir=1)
+        if 'b' in mode:
+            if not py.builtin._isbytes(data):
+                raise ValueError("can only process bytes")
+        else:
+            if not py.builtin._istext(data):
+                if not py.builtin._isbytes(data):
+                    data = str(data)
+                else:
+                    data = py.builtin._totext(data, sys.getdefaultencoding())
+        f = self.open(mode)
+        try:
+            f.write(data)
+        finally:
+            f.close()
+
+    def _ensuredirs(self):
+        parent = self.dirpath()
+        if parent == self:
+            return self
+        if parent.check(dir=0):
+            parent._ensuredirs()
+        if self.check(dir=0):
+            try:
+                self.mkdir()
+            except py.error.EEXIST:
+                # race condition: file/dir created by another thread/process.
+                # complain if it is not a dir
+                if self.check(dir=0):
+                    raise
+        return self
+
+    def ensure(self, *args, **kwargs):
+        """ ensure that an args-joined path exists (by default as
+            a file). if you specify a keyword argument 'dir=True'
+            then the path is forced to be a directory path.
+        """
+        p = self.join(*args)
+        if kwargs.get('dir', 0):
+            return p._ensuredirs()
+        else:
+            p.dirpath()._ensuredirs()
+            if not p.check(file=1):
+                p.open('w').close()
+            return p
+
+    def stat(self, raising=True):
+        """ Return an os.stat() tuple. """
+        if raising == True:
+            return Stat(self, py.error.checked_call(os.stat, self.strpath))
+        try:
+            return Stat(self, os.stat(self.strpath))
+        except KeyboardInterrupt:
+            raise
+        except Exception:
+            return None
+
+    def lstat(self):
+        """ Return an os.lstat() tuple. """
+        return Stat(self, py.error.checked_call(os.lstat, self.strpath))
+
+    def setmtime(self, mtime=None):
+        """ set modification time for the given path.  if 'mtime' is None
+        (the default) then the file's mtime is set to current time.
+
+        Note that the resolution for 'mtime' is platform dependent.
+        """
+        if mtime is None:
+            return py.error.checked_call(os.utime, self.strpath, mtime)
+        try:
+            return py.error.checked_call(os.utime, self.strpath, (-1, mtime))
+        except py.error.EINVAL:
+            return py.error.checked_call(os.utime, self.strpath, (self.atime(), mtime))
+
+    def chdir(self):
+        """ change directory to self and return old current directory """
+        try:
+            old = self.__class__()
+        except py.error.ENOENT:
+            old = None
+        py.error.checked_call(os.chdir, self.strpath)
+        return old
+
+
+    @contextmanager
+    def as_cwd(self):
+        """
+        Return a context manager, which changes to the path's dir during the
+        managed "with" context.
+        On __enter__ it returns the old dir, which might be ``None``.
+        """
+        old = self.chdir()
+        try:
+            yield old
+        finally:
+            if old is not None:
+                old.chdir()
+
+    def realpath(self):
+        """ return a new path which contains no symbolic links."""
+        return self.__class__(os.path.realpath(self.strpath))
+
+    def atime(self):
+        """ return last access time of the path. """
+        return self.stat().atime
+
+    def __repr__(self):
+        return 'local(%r)' % self.strpath
+
+    def __str__(self):
+        """ return string representation of the Path. """
+        return self.strpath
+
+    def chmod(self, mode, rec=0):
+        """ change permissions to the given mode. If mode is an
+            integer it directly encodes the os-specific modes.
+            if rec is True perform recursively.
+        """
+        if not isinstance(mode, int):
+            raise TypeError("mode %r must be an integer" % (mode,))
+        if rec:
+            for x in self.visit(rec=rec):
+                py.error.checked_call(os.chmod, str(x), mode)
+        py.error.checked_call(os.chmod, self.strpath, mode)
+
+    def pypkgpath(self):
+        """ return the Python package path by looking for the last
+        directory upwards which still contains an __init__.py.
+        Return None if a pkgpath can not be determined.
+        """
+        pkgpath = None
+        for parent in self.parts(reverse=True):
+            if parent.isdir():
+                if not parent.join('__init__.py').exists():
+                    break
+                if not isimportable(parent.basename):
+                    break
+                pkgpath = parent
+        return pkgpath
+
+    def _ensuresyspath(self, ensuremode, path):
+        if ensuremode:
+            s = str(path)
+            if ensuremode == "append":
+                if s not in sys.path:
+                    sys.path.append(s)
+            else:
+                if s != sys.path[0]:
+                    sys.path.insert(0, s)
+
+    def pyimport(self, modname=None, ensuresyspath=True):
+        """ return path as an imported python module.
+
+        If modname is None, look for the containing package
+        and construct an according module name.
+        The module will be put/looked up in sys.modules.
+        if ensuresyspath is True then the root dir for importing
+        the file (taking __init__.py files into account) will
+        be prepended to sys.path if it isn't there already.
+        If ensuresyspath=="append" the root dir will be appended
+        if it isn't already contained in sys.path.
+        if ensuresyspath is False no modification of syspath happens.
+
+        Special value of ensuresyspath=="importlib" is intended
+        purely for using in pytest, it is capable only of importing
+        separate .py files outside packages, e.g. for test suite
+        without any __init__.py file. It effectively allows having
+        same-named test modules in different places and offers
+        mild opt-in via this option. Note that it works only in
+        recent versions of python.
+        """
+        if not self.check():
+            raise py.error.ENOENT(self)
+
+        if ensuresyspath == 'importlib':
+            if modname is None:
+                modname = self.purebasename
+            if not ALLOW_IMPORTLIB_MODE:
+                raise ImportError(
+                    "Can't use importlib due to old version of Python")
+            spec = importlib.util.spec_from_file_location(
+                modname, str(self))
+            if spec is None:
+                raise ImportError(
+                    "Can't find module %s at location %s" %
+                    (modname, str(self))
+                )
+            mod = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(mod)
+            return mod
+
+        pkgpath = None
+        if modname is None:
+            pkgpath = self.pypkgpath()
+            if pkgpath is not None:
+                pkgroot = pkgpath.dirpath()
+                names = self.new(ext="").relto(pkgroot).split(self.sep)
+                if names[-1] == "__init__":
+                    names.pop()
+                modname = ".".join(names)
+            else:
+                pkgroot = self.dirpath()
+                modname = self.purebasename
+
+            self._ensuresyspath(ensuresyspath, pkgroot)
+            __import__(modname)
+            mod = sys.modules[modname]
+            if self.basename == "__init__.py":
+                return mod # we don't check anything as we might
+                       # be in a namespace package ... too icky to check
+            modfile = mod.__file__
+            if modfile[-4:] in ('.pyc', '.pyo'):
+                modfile = modfile[:-1]
+            elif modfile.endswith('$py.class'):
+                modfile = modfile[:-9] + '.py'
+            if modfile.endswith(os.path.sep + "__init__.py"):
+                if self.basename != "__init__.py":
+                    modfile = modfile[:-12]
+            try:
+                issame = self.samefile(modfile)
+            except py.error.ENOENT:
+                issame = False
+            if not issame:
+                ignore = os.getenv('PY_IGNORE_IMPORTMISMATCH')
+                if ignore != '1':
+                    raise self.ImportMismatchError(modname, modfile, self)
+            return mod
+        else:
+            try:
+                return sys.modules[modname]
+            except KeyError:
+                # we have a custom modname, do a pseudo-import
+                import types
+                mod = types.ModuleType(modname)
+                mod.__file__ = str(self)
+                sys.modules[modname] = mod
+                try:
+                    py.builtin.execfile(str(self), mod.__dict__)
+                except:
+                    del sys.modules[modname]
+                    raise
+                return mod
+
+    def sysexec(self, *argv, **popen_opts):
+        """ return stdout text from executing a system child process,
+            where the 'self' path points to executable.
+            The process is directly invoked and not through a system shell.
+        """
+        from subprocess import Popen, PIPE
+        argv = map_as_list(str, argv)
+        popen_opts['stdout'] = popen_opts['stderr'] = PIPE
+        proc = Popen([str(self)] + argv, **popen_opts)
+        stdout, stderr = proc.communicate()
+        ret = proc.wait()
+        if py.builtin._isbytes(stdout):
+            stdout = py.builtin._totext(stdout, sys.getdefaultencoding())
+        if ret != 0:
+            if py.builtin._isbytes(stderr):
+                stderr = py.builtin._totext(stderr, sys.getdefaultencoding())
+            raise py.process.cmdexec.Error(ret, ret, str(self),
+                                           stdout, stderr,)
+        return stdout
+
+    def sysfind(cls, name, checker=None, paths=None):
+        """ return a path object found by looking at the systems
+            underlying PATH specification. If the checker is not None
+            it will be invoked to filter matching paths.  If a binary
+            cannot be found, None is returned
+            Note: This is probably not working on plain win32 systems
+            but may work on cygwin.
+        """
+        if isabs(name):
+            p = py.path.local(name)
+            if p.check(file=1):
+                return p
+        else:
+            if paths is None:
+                if iswin32:
+                    paths = os.environ['Path'].split(';')
+                    if '' not in paths and '.' not in paths:
+                        paths.append('.')
+                    try:
+                        systemroot = os.environ['SYSTEMROOT']
+                    except KeyError:
+                        pass
+                    else:
+                        paths = [path.replace('%SystemRoot%', systemroot)
+                                 for path in paths]
+                else:
+                    paths = os.environ['PATH'].split(':')
+            tryadd = []
+            if iswin32:
+                tryadd += os.environ['PATHEXT'].split(os.pathsep)
+            tryadd.append("")
+
+            for x in paths:
+                for addext in tryadd:
+                    p = py.path.local(x).join(name, abs=True) + addext
+                    try:
+                        if p.check(file=1):
+                            if checker:
+                                if not checker(p):
+                                    continue
+                            return p
+                    except py.error.EACCES:
+                        pass
+        return None
+    sysfind = classmethod(sysfind)
+
+    def _gethomedir(cls):
+        try:
+            x = os.environ['HOME']
+        except KeyError:
+            try:
+                x = os.environ["HOMEDRIVE"] + os.environ['HOMEPATH']
+            except KeyError:
+                return None
+        return cls(x)
+    _gethomedir = classmethod(_gethomedir)
+
+    # """
+    # special class constructors for local filesystem paths
+    # """
+    @classmethod
+    def get_temproot(cls):
+        """ return the system's temporary directory
+            (where tempfiles are usually created in)
+        """
+        import tempfile
+        return py.path.local(tempfile.gettempdir())
+
+    @classmethod
+    def mkdtemp(cls, rootdir=None):
+        """ return a Path object pointing to a fresh new temporary directory
+            (which we created ourself).
+        """
+        import tempfile
+        if rootdir is None:
+            rootdir = cls.get_temproot()
+        return cls(py.error.checked_call(tempfile.mkdtemp, dir=str(rootdir)))
+
+    def make_numbered_dir(cls, prefix='session-', rootdir=None, keep=3,
+                          lock_timeout=172800):   # two days
+        """ return unique directory with a number greater than the current
+            maximum one.  The number is assumed to start directly after prefix.
+            if keep is true directories with a number less than (maxnum-keep)
+            will be removed. If .lock files are used (lock_timeout non-zero),
+            algorithm is multi-process safe.
+        """
+        if rootdir is None:
+            rootdir = cls.get_temproot()
+
+        nprefix = prefix.lower()
+        def parse_num(path):
+            """ parse the number out of a path (if it matches the prefix) """
+            nbasename = path.basename.lower()
+            if nbasename.startswith(nprefix):
+                try:
+                    return int(nbasename[len(nprefix):])
+                except ValueError:
+                    pass
+
+        def create_lockfile(path):
+            """ exclusively create lockfile. Throws when failed """
+            mypid = os.getpid()
+            lockfile = path.join('.lock')
+            if hasattr(lockfile, 'mksymlinkto'):
+                lockfile.mksymlinkto(str(mypid))
+            else:
+                fd = py.error.checked_call(os.open, str(lockfile), os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644)
+                with os.fdopen(fd, 'w') as f:
+                    f.write(str(mypid))
+            return lockfile
+
+        def atexit_remove_lockfile(lockfile):
+            """ ensure lockfile is removed at process exit """
+            mypid = os.getpid()
+            def try_remove_lockfile():
+                # in a fork() situation, only the last process should
+                # remove the .lock, otherwise the other processes run the
+                # risk of seeing their temporary dir disappear.  For now
+                # we remove the .lock in the parent only (i.e. we assume
+                # that the children finish before the parent).
+                if os.getpid() != mypid:
+                    return
+                try:
+                    lockfile.remove()
+                except py.error.Error:
+                    pass
+            atexit.register(try_remove_lockfile)
+
+        # compute the maximum number currently in use with the prefix
+        lastmax = None
+        while True:
+            maxnum = -1
+            for path in rootdir.listdir():
+                num = parse_num(path)
+                if num is not None:
+                    maxnum = max(maxnum, num)
+
+            # make the new directory
+            try:
+                udir = rootdir.mkdir(prefix + str(maxnum+1))
+                if lock_timeout:
+                    lockfile = create_lockfile(udir)
+                    atexit_remove_lockfile(lockfile)
+            except (py.error.EEXIST, py.error.ENOENT, py.error.EBUSY):
+                # race condition (1): another thread/process created the dir
+                #                     in the meantime - try again
+                # race condition (2): another thread/process spuriously acquired
+                #                     lock treating empty directory as candidate
+                #                     for removal - try again
+                # race condition (3): another thread/process tried to create the lock at
+                #                     the same time (happened in Python 3.3 on Windows)
+                # https://ci.appveyor.com/project/pytestbot/py/build/1.0.21/job/ffi85j4c0lqwsfwa
+                if lastmax == maxnum:
+                    raise
+                lastmax = maxnum
+                continue
+            break
+
+        def get_mtime(path):
+            """ read file modification time """
+            try:
+                return path.lstat().mtime
+            except py.error.Error:
+                pass
+
+        garbage_prefix = prefix + 'garbage-'
+
+        def is_garbage(path):
+            """ check if path denotes directory scheduled for removal """
+            bn = path.basename
+            return bn.startswith(garbage_prefix)
+
+        # prune old directories
+        udir_time = get_mtime(udir)
+        if keep and udir_time:
+            for path in rootdir.listdir():
+                num = parse_num(path)
+                if num is not None and num <= (maxnum - keep):
+                    try:
+                        # try acquiring lock to remove directory as exclusive user
+                        if lock_timeout:
+                            create_lockfile(path)
+                    except (py.error.EEXIST, py.error.ENOENT, py.error.EBUSY):
+                        path_time = get_mtime(path)
+                        if not path_time:
+                            # assume directory doesn't exist now
+                            continue
+                        if abs(udir_time - path_time) < lock_timeout:
+                            # assume directory with lockfile exists
+                            # and lock timeout hasn't expired yet
+                            continue
+
+                    # path dir locked for exclusive use
+                    # and scheduled for removal to avoid another thread/process
+                    # treating it as a new directory or removal candidate
+                    garbage_path = rootdir.join(garbage_prefix + str(uuid.uuid4()))
+                    try:
+                        path.rename(garbage_path)
+                        garbage_path.remove(rec=1)
+                    except KeyboardInterrupt:
+                        raise
+                    except: # this might be py.error.Error, WindowsError ...
+                        pass
+                if is_garbage(path):
+                    try:
+                        path.remove(rec=1)
+                    except KeyboardInterrupt:
+                        raise
+                    except: # this might be py.error.Error, WindowsError ...
+                        pass
+
+        # make link...
+        try:
+            username = os.environ['USER']           #linux, et al
+        except KeyError:
+            try:
+                username = os.environ['USERNAME']   #windows
+            except KeyError:
+                username = 'current'
+
+        src  = str(udir)
+        dest = src[:src.rfind('-')] + '-' + username
+        try:
+            os.unlink(dest)
+        except OSError:
+            pass
+        try:
+            os.symlink(src, dest)
+        except (OSError, AttributeError, NotImplementedError):
+            pass
+
+        return udir
+    make_numbered_dir = classmethod(make_numbered_dir)
+
+
+def copymode(src, dest):
+    """ copy permission from src to dst. """
+    import shutil
+    shutil.copymode(src, dest)
+
+
+def copystat(src, dest):
+    """ copy permission,  last modification time,
+    last access time, and flags from src to dst."""
+    import shutil
+    shutil.copystat(str(src), str(dest))
+
+
+def copychunked(src, dest):
+    chunksize = 524288  # half a meg of bytes
+    fsrc = src.open('rb')
+    try:
+        fdest = dest.open('wb')
+        try:
+            while 1:
+                buf = fsrc.read(chunksize)
+                if not buf:
+                    break
+                fdest.write(buf)
+        finally:
+            fdest.close()
+    finally:
+        fsrc.close()
+
+
+def isimportable(name):
+    if name and (name[0].isalpha() or name[0] == '_'):
+        name = name.replace("_", '')
+        return not name or name.isalnum()
diff --git a/myenv/lib/python3.9/site-packages/py/_path/svnurl.py b/myenv/lib/python3.9/site-packages/py/_path/svnurl.py
new file mode 100644
index 0000000..6589a71
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_path/svnurl.py
@@ -0,0 +1,380 @@
+"""
+module defining a subversion path object based on the external
+command 'svn'. This modules aims to work with svn 1.3 and higher
+but might also interact well with earlier versions.
+"""
+
+import os, sys, time, re
+import py
+from py import path, process
+from py._path import common
+from py._path import svnwc as svncommon
+from py._path.cacheutil import BuildcostAccessCache, AgingCache
+
+DEBUG=False
+
+class SvnCommandPath(svncommon.SvnPathBase):
+    """ path implementation that offers access to (possibly remote) subversion
+    repositories. """
+
+    _lsrevcache = BuildcostAccessCache(maxentries=128)
+    _lsnorevcache = AgingCache(maxentries=1000, maxseconds=60.0)
+
+    def __new__(cls, path, rev=None, auth=None):
+        self = object.__new__(cls)
+        if isinstance(path, cls):
+            rev = path.rev
+            auth = path.auth
+            path = path.strpath
+        svncommon.checkbadchars(path)
+        path = path.rstrip('/')
+        self.strpath = path
+        self.rev = rev
+        self.auth = auth
+        return self
+
+    def __repr__(self):
+        if self.rev == -1:
+            return 'svnurl(%r)' % self.strpath
+        else:
+            return 'svnurl(%r, %r)' % (self.strpath, self.rev)
+
+    def _svnwithrev(self, cmd, *args):
+        """ execute an svn command, append our own url and revision """
+        if self.rev is None:
+            return self._svnwrite(cmd, *args)
+        else:
+            args = ['-r', self.rev] + list(args)
+            return self._svnwrite(cmd, *args)
+
+    def _svnwrite(self, cmd, *args):
+        """ execute an svn command, append our own url """
+        l = ['svn %s' % cmd]
+        args = ['"%s"' % self._escape(item) for item in args]
+        l.extend(args)
+        l.append('"%s"' % self._encodedurl())
+        # fixing the locale because we can't otherwise parse
+        string = " ".join(l)
+        if DEBUG:
+            print("execing %s" % string)
+        out = self._svncmdexecauth(string)
+        return out
+
+    def _svncmdexecauth(self, cmd):
+        """ execute an svn command 'as is' """
+        cmd = svncommon.fixlocale() + cmd
+        if self.auth is not None:
+            cmd += ' ' + self.auth.makecmdoptions()
+        return self._cmdexec(cmd)
+
+    def _cmdexec(self, cmd):
+        try:
+            out = process.cmdexec(cmd)
+        except py.process.cmdexec.Error:
+            e = sys.exc_info()[1]
+            if (e.err.find('File Exists') != -1 or
+                            e.err.find('File already exists') != -1):
+                raise py.error.EEXIST(self)
+            raise
+        return out
+
+    def _svnpopenauth(self, cmd):
+        """ execute an svn command, return a pipe for reading stdin """
+        cmd = svncommon.fixlocale() + cmd
+        if self.auth is not None:
+            cmd += ' ' + self.auth.makecmdoptions()
+        return self._popen(cmd)
+
+    def _popen(self, cmd):
+        return os.popen(cmd)
+
+    def _encodedurl(self):
+        return self._escape(self.strpath)
+
+    def _norev_delentry(self, path):
+        auth = self.auth and self.auth.makecmdoptions() or None
+        self._lsnorevcache.delentry((str(path), auth))
+
+    def open(self, mode='r'):
+        """ return an opened file with the given mode. """
+        if mode not in ("r", "rU",):
+            raise ValueError("mode %r not supported" % (mode,))
+        assert self.check(file=1) # svn cat returns an empty file otherwise
+        if self.rev is None:
+            return self._svnpopenauth('svn cat "%s"' % (
+                                      self._escape(self.strpath), ))
+        else:
+            return self._svnpopenauth('svn cat -r %s "%s"' % (
+                                      self.rev, self._escape(self.strpath)))
+
+    def dirpath(self, *args, **kwargs):
+        """ return the directory path of the current path joined
+            with any given path arguments.
+        """
+        l = self.strpath.split(self.sep)
+        if len(l) < 4:
+            raise py.error.EINVAL(self, "base is not valid")
+        elif len(l) == 4:
+            return self.join(*args, **kwargs)
+        else:
+            return self.new(basename='').join(*args, **kwargs)
+
+    # modifying methods (cache must be invalidated)
+    def mkdir(self, *args, **kwargs):
+        """ create & return the directory joined with args.
+        pass a 'msg' keyword argument to set the commit message.
+        """
+        commit_msg = kwargs.get('msg', "mkdir by py lib invocation")
+        createpath = self.join(*args)
+        createpath._svnwrite('mkdir', '-m', commit_msg)
+        self._norev_delentry(createpath.dirpath())
+        return createpath
+
+    def copy(self, target, msg='copied by py lib invocation'):
+        """ copy path to target with checkin message msg."""
+        if getattr(target, 'rev', None) is not None:
+            raise py.error.EINVAL(target, "revisions are immutable")
+        self._svncmdexecauth('svn copy -m "%s" "%s" "%s"' %(msg,
+                             self._escape(self), self._escape(target)))
+        self._norev_delentry(target.dirpath())
+
+    def rename(self, target, msg="renamed by py lib invocation"):
+        """ rename this path to target with checkin message msg. """
+        if getattr(self, 'rev', None) is not None:
+            raise py.error.EINVAL(self, "revisions are immutable")
+        self._svncmdexecauth('svn move -m "%s" --force "%s" "%s"' %(
+                             msg, self._escape(self), self._escape(target)))
+        self._norev_delentry(self.dirpath())
+        self._norev_delentry(self)
+
+    def remove(self, rec=1, msg='removed by py lib invocation'):
+        """ remove a file or directory (or a directory tree if rec=1) with
+checkin message msg."""
+        if self.rev is not None:
+            raise py.error.EINVAL(self, "revisions are immutable")
+        self._svncmdexecauth('svn rm -m "%s" "%s"' %(msg, self._escape(self)))
+        self._norev_delentry(self.dirpath())
+
+    def export(self, topath):
+        """ export to a local path
+
+            topath should not exist prior to calling this, returns a
+            py.path.local instance
+        """
+        topath = py.path.local(topath)
+        args = ['"%s"' % (self._escape(self),),
+                '"%s"' % (self._escape(topath),)]
+        if self.rev is not None:
+            args = ['-r', str(self.rev)] + args
+        self._svncmdexecauth('svn export %s' % (' '.join(args),))
+        return topath
+
+    def ensure(self, *args, **kwargs):
+        """ ensure that an args-joined path exists (by default as
+            a file). If you specify a keyword argument 'dir=True'
+            then the path is forced to be a directory path.
+        """
+        if getattr(self, 'rev', None) is not None:
+            raise py.error.EINVAL(self, "revisions are immutable")
+        target = self.join(*args)
+        dir = kwargs.get('dir', 0)
+        for x in target.parts(reverse=True):
+            if x.check():
+                break
+        else:
+            raise py.error.ENOENT(target, "has not any valid base!")
+        if x == target:
+            if not x.check(dir=dir):
+                raise dir and py.error.ENOTDIR(x) or py.error.EISDIR(x)
+            return x
+        tocreate = target.relto(x)
+        basename = tocreate.split(self.sep, 1)[0]
+        tempdir = py.path.local.mkdtemp()
+        try:
+            tempdir.ensure(tocreate, dir=dir)
+            cmd = 'svn import -m "%s" "%s" "%s"' % (
+                    "ensure %s" % self._escape(tocreate),
+                    self._escape(tempdir.join(basename)),
+                    x.join(basename)._encodedurl())
+            self._svncmdexecauth(cmd)
+            self._norev_delentry(x)
+        finally:
+            tempdir.remove()
+        return target
+
+    # end of modifying methods
+    def _propget(self, name):
+        res = self._svnwithrev('propget', name)
+        return res[:-1] # strip trailing newline
+
+    def _proplist(self):
+        res = self._svnwithrev('proplist')
+        lines = res.split('\n')
+        lines = [x.strip() for x in lines[1:]]
+        return svncommon.PropListDict(self, lines)
+
+    def info(self):
+        """ return an Info structure with svn-provided information. """
+        parent = self.dirpath()
+        nameinfo_seq = parent._listdir_nameinfo()
+        bn = self.basename
+        for name, info in nameinfo_seq:
+            if name == bn:
+                return info
+        raise py.error.ENOENT(self)
+
+
+    def _listdir_nameinfo(self):
+        """ return sequence of name-info directory entries of self """
+        def builder():
+            try:
+                res = self._svnwithrev('ls', '-v')
+            except process.cmdexec.Error:
+                e = sys.exc_info()[1]
+                if e.err.find('non-existent in that revision') != -1:
+                    raise py.error.ENOENT(self, e.err)
+                elif e.err.find("E200009:") != -1:
+                    raise py.error.ENOENT(self, e.err)
+                elif e.err.find('File not found') != -1:
+                    raise py.error.ENOENT(self, e.err)
+                elif e.err.find('not part of a repository')!=-1:
+                    raise py.error.ENOENT(self, e.err)
+                elif e.err.find('Unable to open')!=-1:
+                    raise py.error.ENOENT(self, e.err)
+                elif e.err.lower().find('method not allowed')!=-1:
+                    raise py.error.EACCES(self, e.err)
+                raise py.error.Error(e.err)
+            lines = res.split('\n')
+            nameinfo_seq = []
+            for lsline in lines:
+                if lsline:
+                    info = InfoSvnCommand(lsline)
+                    if info._name != '.':  # svn 1.5 produces '.' dirs,
+                        nameinfo_seq.append((info._name, info))
+            nameinfo_seq.sort()
+            return nameinfo_seq
+        auth = self.auth and self.auth.makecmdoptions() or None
+        if self.rev is not None:
+            return self._lsrevcache.getorbuild((self.strpath, self.rev, auth),
+                                               builder)
+        else:
+            return self._lsnorevcache.getorbuild((self.strpath, auth),
+                                                 builder)
+
+    def listdir(self, fil=None, sort=None):
+        """ list directory contents, possibly filter by the given fil func
+            and possibly sorted.
+        """
+        if isinstance(fil, str):
+            fil = common.FNMatcher(fil)
+        nameinfo_seq = self._listdir_nameinfo()
+        if len(nameinfo_seq) == 1:
+            name, info = nameinfo_seq[0]
+            if name == self.basename and info.kind == 'file':
+                #if not self.check(dir=1):
+                raise py.error.ENOTDIR(self)
+        paths = [self.join(name) for (name, info) in nameinfo_seq]
+        if fil:
+            paths = [x for x in paths if fil(x)]
+        self._sortlist(paths, sort)
+        return paths
+
+
+    def log(self, rev_start=None, rev_end=1, verbose=False):
+        """ return a list of LogEntry instances for this path.
+rev_start is the starting revision (defaulting to the first one).
+rev_end is the last revision (defaulting to HEAD).
+if verbose is True, then the LogEntry instances also know which files changed.
+"""
+        assert self.check() #make it simpler for the pipe
+        rev_start = rev_start is None and "HEAD" or rev_start
+        rev_end = rev_end is None and "HEAD" or rev_end
+
+        if rev_start == "HEAD" and rev_end == 1:
+            rev_opt = ""
+        else:
+            rev_opt = "-r %s:%s" % (rev_start, rev_end)
+        verbose_opt = verbose and "-v" or ""
+        xmlpipe =  self._svnpopenauth('svn log --xml %s %s "%s"' %
+                                      (rev_opt, verbose_opt, self.strpath))
+        from xml.dom import minidom
+        tree = minidom.parse(xmlpipe)
+        result = []
+        for logentry in filter(None, tree.firstChild.childNodes):
+            if logentry.nodeType == logentry.ELEMENT_NODE:
+                result.append(svncommon.LogEntry(logentry))
+        return result
+
+#01234567890123456789012345678901234567890123467
+#   2256      hpk        165 Nov 24 17:55 __init__.py
+# XXX spotted by Guido, SVN 1.3.0 has different aligning, breaks the code!!!
+#   1312 johnny           1627 May 05 14:32 test_decorators.py
+#
+class InfoSvnCommand:
+    # the '0?' part in the middle is an indication of whether the resource is
+    # locked, see 'svn help ls'
+    lspattern = re.compile(
+        r'^ *(?P<rev>\d+) +(?P<author>.+?) +(0? *(?P<size>\d+))? '
+            r'*(?P<date>\w+ +\d{2} +[\d:]+) +(?P<file>.*)$')
+    def __init__(self, line):
+        # this is a typical line from 'svn ls http://...'
+        #_    1127      jum        0 Jul 13 15:28 branch/
+        match = self.lspattern.match(line)
+        data = match.groupdict()
+        self._name = data['file']
+        if self._name[-1] == '/':
+            self._name = self._name[:-1]
+            self.kind = 'dir'
+        else:
+            self.kind = 'file'
+        #self.has_props = l.pop(0) == 'P'
+        self.created_rev = int(data['rev'])
+        self.last_author = data['author']
+        self.size = data['size'] and int(data['size']) or 0
+        self.mtime = parse_time_with_missing_year(data['date'])
+        self.time = self.mtime * 1000000
+
+    def __eq__(self, other):
+        return self.__dict__ == other.__dict__
+
+
+#____________________________________________________
+#
+# helper functions
+#____________________________________________________
+def parse_time_with_missing_year(timestr):
+    """ analyze the time part from a single line of "svn ls -v"
+    the svn output doesn't show the year makes the 'timestr'
+    ambigous.
+    """
+    import calendar
+    t_now = time.gmtime()
+
+    tparts = timestr.split()
+    month = time.strptime(tparts.pop(0), '%b')[1]
+    day = time.strptime(tparts.pop(0), '%d')[2]
+    last = tparts.pop(0) # year or hour:minute
+    try:
+        if ":" in last:
+            raise ValueError()
+        year = time.strptime(last, '%Y')[0]
+        hour = minute = 0
+    except ValueError:
+        hour, minute = time.strptime(last, '%H:%M')[3:5]
+        year = t_now[0]
+
+        t_result = (year, month, day, hour, minute, 0,0,0,0)
+        if t_result > t_now:
+            year -= 1
+    t_result = (year, month, day, hour, minute, 0,0,0,0)
+    return calendar.timegm(t_result)
+
+class PathEntry:
+    def __init__(self, ppart):
+        self.strpath = ppart.firstChild.nodeValue.encode('UTF-8')
+        self.action = ppart.getAttribute('action').encode('UTF-8')
+        if self.action == 'A':
+            self.copyfrom_path = ppart.getAttribute('copyfrom-path').encode('UTF-8')
+            if self.copyfrom_path:
+                self.copyfrom_rev = int(ppart.getAttribute('copyfrom-rev'))
+
diff --git a/myenv/lib/python3.9/site-packages/py/_path/svnwc.py b/myenv/lib/python3.9/site-packages/py/_path/svnwc.py
new file mode 100644
index 0000000..b5b9d8d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_path/svnwc.py
@@ -0,0 +1,1240 @@
+"""
+svn-Command based Implementation of a Subversion WorkingCopy Path.
+
+  SvnWCCommandPath  is the main class.
+
+"""
+
+import os, sys, time, re, calendar
+import py
+import subprocess
+from py._path import common
+
+#-----------------------------------------------------------
+# Caching latest repository revision and repo-paths
+# (getting them is slow with the current implementations)
+#
+# XXX make mt-safe
+#-----------------------------------------------------------
+
+class cache:
+    proplist = {}
+    info = {}
+    entries = {}
+    prop = {}
+
+class RepoEntry:
+    def __init__(self, url, rev, timestamp):
+        self.url = url
+        self.rev = rev
+        self.timestamp = timestamp
+
+    def __str__(self):
+        return "repo: %s;%s  %s" %(self.url, self.rev, self.timestamp)
+
+class RepoCache:
+    """ The Repocache manages discovered repository paths
+    and their revisions.  If inside a timeout the cache
+    will even return the revision of the root.
+    """
+    timeout = 20 # seconds after which we forget that we know the last revision
+
+    def __init__(self):
+        self.repos = []
+
+    def clear(self):
+        self.repos = []
+
+    def put(self, url, rev, timestamp=None):
+        if rev is None:
+            return
+        if timestamp is None:
+            timestamp = time.time()
+
+        for entry in self.repos:
+            if url == entry.url:
+                entry.timestamp = timestamp
+                entry.rev = rev
+                #print "set repo", entry
+                break
+        else:
+            entry = RepoEntry(url, rev, timestamp)
+            self.repos.append(entry)
+            #print "appended repo", entry
+
+    def get(self, url):
+        now = time.time()
+        for entry in self.repos:
+            if url.startswith(entry.url):
+                if now < entry.timestamp + self.timeout:
+                    #print "returning immediate Etrny", entry
+                    return entry.url, entry.rev
+                return entry.url, -1
+        return url, -1
+
+repositories = RepoCache()
+
+
+# svn support code
+
+ALLOWED_CHARS = "_ -/\\=$.~+%" #add characters as necessary when tested
+if sys.platform == "win32":
+    ALLOWED_CHARS += ":"
+ALLOWED_CHARS_HOST = ALLOWED_CHARS + '@:'
+
+def _getsvnversion(ver=[]):
+    try:
+        return ver[0]
+    except IndexError:
+        v = py.process.cmdexec("svn -q --version")
+        v.strip()
+        v = '.'.join(v.split('.')[:2])
+        ver.append(v)
+        return v
+
+def _escape_helper(text):
+    text = str(text)
+    if sys.platform != 'win32':
+        text = str(text).replace('$', '\\$')
+    return text
+
+def _check_for_bad_chars(text, allowed_chars=ALLOWED_CHARS):
+    for c in str(text):
+        if c.isalnum():
+            continue
+        if c in allowed_chars:
+            continue
+        return True
+    return False
+
+def checkbadchars(url):
+    # (hpk) not quite sure about the exact purpose, guido w.?
+    proto, uri = url.split("://", 1)
+    if proto != "file":
+        host, uripath = uri.split('/', 1)
+        # only check for bad chars in the non-protocol parts
+        if (_check_for_bad_chars(host, ALLOWED_CHARS_HOST) \
+            or _check_for_bad_chars(uripath, ALLOWED_CHARS)):
+            raise ValueError("bad char in %r" % (url, ))
+
+
+#_______________________________________________________________
+
+class SvnPathBase(common.PathBase):
+    """ Base implementation for SvnPath implementations. """
+    sep = '/'
+
+    def _geturl(self):
+        return self.strpath
+    url = property(_geturl, None, None, "url of this svn-path.")
+
+    def __str__(self):
+        """ return a string representation (including rev-number) """
+        return self.strpath
+
+    def __hash__(self):
+        return hash(self.strpath)
+
+    def new(self, **kw):
+        """ create a modified version of this path. A 'rev' argument
+            indicates a new revision.
+            the following keyword arguments modify various path parts::
+
+              http://host.com/repo/path/file.ext
+              |-----------------------|          dirname
+                                        |------| basename
+                                        |--|     purebasename
+                                            |--| ext
+        """
+        obj = object.__new__(self.__class__)
+        obj.rev = kw.get('rev', self.rev)
+        obj.auth = kw.get('auth', self.auth)
+        dirname, basename, purebasename, ext = self._getbyspec(
+             "dirname,basename,purebasename,ext")
+        if 'basename' in kw:
+            if 'purebasename' in kw or 'ext' in kw:
+                raise ValueError("invalid specification %r" % kw)
+        else:
+            pb = kw.setdefault('purebasename', purebasename)
+            ext = kw.setdefault('ext', ext)
+            if ext and not ext.startswith('.'):
+                ext = '.' + ext
+            kw['basename'] = pb + ext
+
+        kw.setdefault('dirname', dirname)
+        kw.setdefault('sep', self.sep)
+        if kw['basename']:
+            obj.strpath = "%(dirname)s%(sep)s%(basename)s" % kw
+        else:
+            obj.strpath = "%(dirname)s" % kw
+        return obj
+
+    def _getbyspec(self, spec):
+        """ get specified parts of the path.  'arg' is a string
+            with comma separated path parts. The parts are returned
+            in exactly the order of the specification.
+
+            you may specify the following parts:
+
+            http://host.com/repo/path/file.ext
+            |-----------------------|          dirname
+                                      |------| basename
+                                      |--|     purebasename
+                                          |--| ext
+        """
+        res = []
+        parts = self.strpath.split(self.sep)
+        for name in spec.split(','):
+            name = name.strip()
+            if name == 'dirname':
+                res.append(self.sep.join(parts[:-1]))
+            elif name == 'basename':
+                res.append(parts[-1])
+            else:
+                basename = parts[-1]
+                i = basename.rfind('.')
+                if i == -1:
+                    purebasename, ext = basename, ''
+                else:
+                    purebasename, ext = basename[:i], basename[i:]
+                if name == 'purebasename':
+                    res.append(purebasename)
+                elif name == 'ext':
+                    res.append(ext)
+                else:
+                    raise NameError("Don't know part %r" % name)
+        return res
+
+    def __eq__(self, other):
+        """ return true if path and rev attributes each match """
+        return (str(self) == str(other) and
+               (self.rev == other.rev or self.rev == other.rev))
+
+    def __ne__(self, other):
+        return not self == other
+
+    def join(self, *args):
+        """ return a new Path (with the same revision) which is composed
+            of the self Path followed by 'args' path components.
+        """
+        if not args:
+            return self
+
+        args = tuple([arg.strip(self.sep) for arg in args])
+        parts = (self.strpath, ) + args
+        newpath = self.__class__(self.sep.join(parts), self.rev, self.auth)
+        return newpath
+
+    def propget(self, name):
+        """ return the content of the given property. """
+        value = self._propget(name)
+        return value
+
+    def proplist(self):
+        """ list all property names. """
+        content = self._proplist()
+        return content
+
+    def size(self):
+        """ Return the size of the file content of the Path. """
+        return self.info().size
+
+    def mtime(self):
+        """ Return the last modification time of the file. """
+        return self.info().mtime
+
+    # shared help methods
+
+    def _escape(self, cmd):
+        return _escape_helper(cmd)
+
+
+    #def _childmaxrev(self):
+    #    """ return maximum revision number of childs (or self.rev if no childs) """
+    #    rev = self.rev
+    #    for name, info in self._listdir_nameinfo():
+    #        rev = max(rev, info.created_rev)
+    #    return rev
+
+    #def _getlatestrevision(self):
+    #    """ return latest repo-revision for this path. """
+    #    url = self.strpath
+    #    path = self.__class__(url, None)
+    #
+    #    # we need a long walk to find the root-repo and revision
+    #    while 1:
+    #        try:
+    #            rev = max(rev, path._childmaxrev())
+    #            previous = path
+    #            path = path.dirpath()
+    #        except (IOError, process.cmdexec.Error):
+    #            break
+    #    if rev is None:
+    #        raise IOError, "could not determine newest repo revision for %s" % self
+    #    return rev
+
+    class Checkers(common.Checkers):
+        def dir(self):
+            try:
+                return self.path.info().kind == 'dir'
+            except py.error.Error:
+                return self._listdirworks()
+
+        def _listdirworks(self):
+            try:
+                self.path.listdir()
+            except py.error.ENOENT:
+                return False
+            else:
+                return True
+
+        def file(self):
+            try:
+                return self.path.info().kind == 'file'
+            except py.error.ENOENT:
+                return False
+
+        def exists(self):
+            try:
+                return self.path.info()
+            except py.error.ENOENT:
+                return self._listdirworks()
+
+def parse_apr_time(timestr):
+    i = timestr.rfind('.')
+    if i == -1:
+        raise ValueError("could not parse %s" % timestr)
+    timestr = timestr[:i]
+    parsedtime = time.strptime(timestr, "%Y-%m-%dT%H:%M:%S")
+    return time.mktime(parsedtime)
+
+class PropListDict(dict):
+    """ a Dictionary which fetches values (InfoSvnCommand instances) lazily"""
+    def __init__(self, path, keynames):
+        dict.__init__(self, [(x, None) for x in keynames])
+        self.path = path
+
+    def __getitem__(self, key):
+        value = dict.__getitem__(self, key)
+        if value is None:
+            value = self.path.propget(key)
+            dict.__setitem__(self, key, value)
+        return value
+
+def fixlocale():
+    if sys.platform != 'win32':
+        return 'LC_ALL=C '
+    return ''
+
+# some nasty chunk of code to solve path and url conversion and quoting issues
+ILLEGAL_CHARS = '* | \\ / : < > ? \t \n \x0b \x0c \r'.split(' ')
+if os.sep in ILLEGAL_CHARS:
+    ILLEGAL_CHARS.remove(os.sep)
+ISWINDOWS = sys.platform == 'win32'
+_reg_allow_disk = re.compile(r'^([a-z]\:\\)?[^:]+$', re.I)
+def _check_path(path):
+    illegal = ILLEGAL_CHARS[:]
+    sp = path.strpath
+    if ISWINDOWS:
+        illegal.remove(':')
+        if not _reg_allow_disk.match(sp):
+            raise ValueError('path may not contain a colon (:)')
+    for char in sp:
+        if char not in string.printable or char in illegal:
+            raise ValueError('illegal character %r in path' % (char,))
+
+def path_to_fspath(path, addat=True):
+    _check_path(path)
+    sp = path.strpath
+    if addat and path.rev != -1:
+        sp = '%s@%s' % (sp, path.rev)
+    elif addat:
+        sp = '%s@HEAD' % (sp,)
+    return sp
+
+def url_from_path(path):
+    fspath = path_to_fspath(path, False)
+    from urllib import quote
+    if ISWINDOWS:
+        match = _reg_allow_disk.match(fspath)
+        fspath = fspath.replace('\\', '/')
+        if match.group(1):
+            fspath = '/%s%s' % (match.group(1).replace('\\', '/'),
+                                quote(fspath[len(match.group(1)):]))
+        else:
+            fspath = quote(fspath)
+    else:
+        fspath = quote(fspath)
+    if path.rev != -1:
+        fspath = '%s@%s' % (fspath, path.rev)
+    else:
+        fspath = '%s@HEAD' % (fspath,)
+    return 'file://%s' % (fspath,)
+
+class SvnAuth(object):
+    """ container for auth information for Subversion """
+    def __init__(self, username, password, cache_auth=True, interactive=True):
+        self.username = username
+        self.password = password
+        self.cache_auth = cache_auth
+        self.interactive = interactive
+
+    def makecmdoptions(self):
+        uname = self.username.replace('"', '\\"')
+        passwd = self.password.replace('"', '\\"')
+        ret = []
+        if uname:
+            ret.append('--username="%s"' % (uname,))
+        if passwd:
+            ret.append('--password="%s"' % (passwd,))
+        if not self.cache_auth:
+            ret.append('--no-auth-cache')
+        if not self.interactive:
+            ret.append('--non-interactive')
+        return ' '.join(ret)
+
+    def __str__(self):
+        return "<SvnAuth username=%s ...>" %(self.username,)
+
+rex_blame = re.compile(r'\s*(\d+)\s+(\S+) (.*)')
+
+class SvnWCCommandPath(common.PathBase):
+    """ path implementation offering access/modification to svn working copies.
+        It has methods similar to the functions in os.path and similar to the
+        commands of the svn client.
+    """
+    sep = os.sep
+
+    def __new__(cls, wcpath=None, auth=None):
+        self = object.__new__(cls)
+        if isinstance(wcpath, cls):
+            if wcpath.__class__ == cls:
+                return wcpath
+            wcpath = wcpath.localpath
+        if _check_for_bad_chars(str(wcpath),
+                                          ALLOWED_CHARS):
+            raise ValueError("bad char in wcpath %s" % (wcpath, ))
+        self.localpath = py.path.local(wcpath)
+        self.auth = auth
+        return self
+
+    strpath = property(lambda x: str(x.localpath), None, None, "string path")
+    rev = property(lambda x: x.info(usecache=0).rev, None, None, "revision")
+
+    def __eq__(self, other):
+        return self.localpath == getattr(other, 'localpath', None)
+
+    def _geturl(self):
+        if getattr(self, '_url', None) is None:
+            info = self.info()
+            self._url = info.url #SvnPath(info.url, info.rev)
+        assert isinstance(self._url, py.builtin._basestring)
+        return self._url
+
+    url = property(_geturl, None, None, "url of this WC item")
+
+    def _escape(self, cmd):
+        return _escape_helper(cmd)
+
+    def dump(self, obj):
+        """ pickle object into path location"""
+        return self.localpath.dump(obj)
+
+    def svnurl(self):
+        """ return current SvnPath for this WC-item. """
+        info = self.info()
+        return py.path.svnurl(info.url)
+
+    def __repr__(self):
+        return "svnwc(%r)" % (self.strpath) # , self._url)
+
+    def __str__(self):
+        return str(self.localpath)
+
+    def _makeauthoptions(self):
+        if self.auth is None:
+            return ''
+        return self.auth.makecmdoptions()
+
+    def _authsvn(self, cmd, args=None):
+        args = args and list(args) or []
+        args.append(self._makeauthoptions())
+        return self._svn(cmd, *args)
+
+    def _svn(self, cmd, *args):
+        l = ['svn %s' % cmd]
+        args = [self._escape(item) for item in args]
+        l.extend(args)
+        l.append('"%s"' % self._escape(self.strpath))
+        # try fixing the locale because we can't otherwise parse
+        string = fixlocale() + " ".join(l)
+        try:
+            try:
+                key = 'LC_MESSAGES'
+                hold = os.environ.get(key)
+                os.environ[key] = 'C'
+                out = py.process.cmdexec(string)
+            finally:
+                if hold:
+                    os.environ[key] = hold
+                else:
+                    del os.environ[key]
+        except py.process.cmdexec.Error:
+            e = sys.exc_info()[1]
+            strerr = e.err.lower()
+            if strerr.find('not found') != -1:
+                raise py.error.ENOENT(self)
+            elif strerr.find("E200009:") != -1:
+                raise py.error.ENOENT(self)
+            if (strerr.find('file exists') != -1 or
+                strerr.find('file already exists') != -1 or
+                strerr.find('w150002:') != -1 or
+                strerr.find("can't create directory") != -1):
+                raise py.error.EEXIST(strerr) #self)
+            raise
+        return out
+
+    def switch(self, url):
+        """ switch to given URL. """
+        self._authsvn('switch', [url])
+
+    def checkout(self, url=None, rev=None):
+        """ checkout from url to local wcpath. """
+        args = []
+        if url is None:
+            url = self.url
+        if rev is None or rev == -1:
+            if (sys.platform != 'win32' and
+                    _getsvnversion() == '1.3'):
+                url += "@HEAD"
+        else:
+            if _getsvnversion() == '1.3':
+                url += "@%d" % rev
+            else:
+                args.append('-r' + str(rev))
+        args.append(url)
+        self._authsvn('co', args)
+
+    def update(self, rev='HEAD', interactive=True):
+        """ update working copy item to given revision. (None -> HEAD). """
+        opts = ['-r', rev]
+        if not interactive:
+            opts.append("--non-interactive")
+        self._authsvn('up', opts)
+
+    def write(self, content, mode='w'):
+        """ write content into local filesystem wc. """
+        self.localpath.write(content, mode)
+
+    def dirpath(self, *args):
+        """ return the directory Path of the current Path. """
+        return self.__class__(self.localpath.dirpath(*args), auth=self.auth)
+
+    def _ensuredirs(self):
+        parent = self.dirpath()
+        if parent.check(dir=0):
+            parent._ensuredirs()
+        if self.check(dir=0):
+            self.mkdir()
+        return self
+
+    def ensure(self, *args, **kwargs):
+        """ ensure that an args-joined path exists (by default as
+            a file). if you specify a keyword argument 'directory=True'
+            then the path is forced  to be a directory path.
+        """
+        p = self.join(*args)
+        if p.check():
+            if p.check(versioned=False):
+                p.add()
+            return p
+        if kwargs.get('dir', 0):
+            return p._ensuredirs()
+        parent = p.dirpath()
+        parent._ensuredirs()
+        p.write("")
+        p.add()
+        return p
+
+    def mkdir(self, *args):
+        """ create & return the directory joined with args. """
+        if args:
+            return self.join(*args).mkdir()
+        else:
+            self._svn('mkdir')
+            return self
+
+    def add(self):
+        """ add ourself to svn """
+        self._svn('add')
+
+    def remove(self, rec=1, force=1):
+        """ remove a file or a directory tree. 'rec'ursive is
+            ignored and considered always true (because of
+            underlying svn semantics.
+        """
+        assert rec, "svn cannot remove non-recursively"
+        if not self.check(versioned=True):
+            # not added to svn (anymore?), just remove
+            py.path.local(self).remove()
+            return
+        flags = []
+        if force:
+            flags.append('--force')
+        self._svn('remove', *flags)
+
+    def copy(self, target):
+        """ copy path to target."""
+        py.process.cmdexec("svn copy %s %s" %(str(self), str(target)))
+
+    def rename(self, target):
+        """ rename this path to target. """
+        py.process.cmdexec("svn move --force %s %s" %(str(self), str(target)))
+
+    def lock(self):
+        """ set a lock (exclusive) on the resource """
+        out = self._authsvn('lock').strip()
+        if not out:
+            # warning or error, raise exception
+            raise ValueError("unknown error in svn lock command")
+
+    def unlock(self):
+        """ unset a previously set lock """
+        out = self._authsvn('unlock').strip()
+        if out.startswith('svn:'):
+            # warning or error, raise exception
+            raise Exception(out[4:])
+
+    def cleanup(self):
+        """ remove any locks from the resource """
+        # XXX should be fixed properly!!!
+        try:
+            self.unlock()
+        except:
+            pass
+
+    def status(self, updates=0, rec=0, externals=0):
+        """ return (collective) Status object for this file. """
+        # http://svnbook.red-bean.com/book.html#svn-ch-3-sect-4.3.1
+        #             2201     2192        jum   test
+        # XXX
+        if externals:
+            raise ValueError("XXX cannot perform status() "
+                             "on external items yet")
+        else:
+            #1.2 supports: externals = '--ignore-externals'
+            externals = ''
+        if rec:
+            rec= ''
+        else:
+            rec = '--non-recursive'
+
+        # XXX does not work on all subversion versions
+        #if not externals:
+        #    externals = '--ignore-externals'
+
+        if updates:
+            updates = '-u'
+        else:
+            updates = ''
+
+        try:
+            cmd = 'status -v --xml --no-ignore %s %s %s' % (
+                    updates, rec, externals)
+            out = self._authsvn(cmd)
+        except py.process.cmdexec.Error:
+            cmd = 'status -v --no-ignore %s %s %s' % (
+                    updates, rec, externals)
+            out = self._authsvn(cmd)
+            rootstatus = WCStatus(self).fromstring(out, self)
+        else:
+            rootstatus = XMLWCStatus(self).fromstring(out, self)
+        return rootstatus
+
+    def diff(self, rev=None):
+        """ return a diff of the current path against revision rev (defaulting
+            to the last one).
+        """
+        args = []
+        if rev is not None:
+            args.append("-r %d" % rev)
+        out = self._authsvn('diff', args)
+        return out
+
+    def blame(self):
+        """ return a list of tuples of three elements:
+            (revision, commiter, line)
+        """
+        out = self._svn('blame')
+        result = []
+        blamelines = out.splitlines()
+        reallines = py.path.svnurl(self.url).readlines()
+        for i, (blameline, line) in enumerate(
+                zip(blamelines, reallines)):
+            m = rex_blame.match(blameline)
+            if not m:
+                raise ValueError("output line %r of svn blame does not match "
+                                 "expected format" % (line, ))
+            rev, name, _ = m.groups()
+            result.append((int(rev), name, line))
+        return result
+
+    _rex_commit = re.compile(r'.*Committed revision (\d+)\.$', re.DOTALL)
+    def commit(self, msg='', rec=1):
+        """ commit with support for non-recursive commits """
+        # XXX i guess escaping should be done better here?!?
+        cmd = 'commit -m "%s" --force-log' % (msg.replace('"', '\\"'),)
+        if not rec:
+            cmd += ' -N'
+        out = self._authsvn(cmd)
+        try:
+            del cache.info[self]
+        except KeyError:
+            pass
+        if out:
+            m = self._rex_commit.match(out)
+            return int(m.group(1))
+
+    def propset(self, name, value, *args):
+        """ set property name to value on this path. """
+        d = py.path.local.mkdtemp()
+        try:
+            p = d.join('value')
+            p.write(value)
+            self._svn('propset', name, '--file', str(p), *args)
+        finally:
+            d.remove()
+
+    def propget(self, name):
+        """ get property name on this path. """
+        res = self._svn('propget', name)
+        return res[:-1] # strip trailing newline
+
+    def propdel(self, name):
+        """ delete property name on this path. """
+        res = self._svn('propdel', name)
+        return res[:-1] # strip trailing newline
+
+    def proplist(self, rec=0):
+        """ return a mapping of property names to property values.
+If rec is True, then return a dictionary mapping sub-paths to such mappings.
+"""
+        if rec:
+            res = self._svn('proplist -R')
+            return make_recursive_propdict(self, res)
+        else:
+            res = self._svn('proplist')
+            lines = res.split('\n')
+            lines = [x.strip() for x in lines[1:]]
+            return PropListDict(self, lines)
+
+    def revert(self, rec=0):
+        """ revert the local changes of this path. if rec is True, do so
+recursively. """
+        if rec:
+            result = self._svn('revert -R')
+        else:
+            result = self._svn('revert')
+        return result
+
+    def new(self, **kw):
+        """ create a modified version of this path. A 'rev' argument
+            indicates a new revision.
+            the following keyword arguments modify various path parts:
+
+              http://host.com/repo/path/file.ext
+              |-----------------------|          dirname
+                                        |------| basename
+                                        |--|     purebasename
+                                            |--| ext
+        """
+        if kw:
+            localpath = self.localpath.new(**kw)
+        else:
+            localpath = self.localpath
+        return self.__class__(localpath, auth=self.auth)
+
+    def join(self, *args, **kwargs):
+        """ return a new Path (with the same revision) which is composed
+            of the self Path followed by 'args' path components.
+        """
+        if not args:
+            return self
+        localpath = self.localpath.join(*args, **kwargs)
+        return self.__class__(localpath, auth=self.auth)
+
+    def info(self, usecache=1):
+        """ return an Info structure with svn-provided information. """
+        info = usecache and cache.info.get(self)
+        if not info:
+            try:
+                output = self._svn('info')
+            except py.process.cmdexec.Error:
+                e = sys.exc_info()[1]
+                if e.err.find('Path is not a working copy directory') != -1:
+                    raise py.error.ENOENT(self, e.err)
+                elif e.err.find("is not under version control") != -1:
+                    raise py.error.ENOENT(self, e.err)
+                raise
+            # XXX SVN 1.3 has output on stderr instead of stdout (while it does
+            # return 0!), so a bit nasty, but we assume no output is output
+            # to stderr...
+            if (output.strip() == '' or
+                    output.lower().find('not a versioned resource') != -1):
+                raise py.error.ENOENT(self, output)
+            info = InfoSvnWCCommand(output)
+
+            # Can't reliably compare on Windows without access to win32api
+            if sys.platform != 'win32':
+                if info.path != self.localpath:
+                    raise py.error.ENOENT(self, "not a versioned resource:" +
+                            " %s != %s" % (info.path, self.localpath))
+            cache.info[self] = info
+        return info
+
+    def listdir(self, fil=None, sort=None):
+        """ return a sequence of Paths.
+
+        listdir will return either a tuple or a list of paths
+        depending on implementation choices.
+        """
+        if isinstance(fil, str):
+            fil = common.FNMatcher(fil)
+        # XXX unify argument naming with LocalPath.listdir
+        def notsvn(path):
+            return path.basename != '.svn'
+
+        paths = []
+        for localpath in self.localpath.listdir(notsvn):
+            p = self.__class__(localpath, auth=self.auth)
+            if notsvn(p) and (not fil or fil(p)):
+                paths.append(p)
+        self._sortlist(paths, sort)
+        return paths
+
+    def open(self, mode='r'):
+        """ return an opened file with the given mode. """
+        return open(self.strpath, mode)
+
+    def _getbyspec(self, spec):
+        return self.localpath._getbyspec(spec)
+
+    class Checkers(py.path.local.Checkers):
+        def __init__(self, path):
+            self.svnwcpath = path
+            self.path = path.localpath
+        def versioned(self):
+            try:
+                s = self.svnwcpath.info()
+            except (py.error.ENOENT, py.error.EEXIST):
+                return False
+            except py.process.cmdexec.Error:
+                e = sys.exc_info()[1]
+                if e.err.find('is not a working copy')!=-1:
+                    return False
+                if e.err.lower().find('not a versioned resource') != -1:
+                    return False
+                raise
+            else:
+                return True
+
+    def log(self, rev_start=None, rev_end=1, verbose=False):
+        """ return a list of LogEntry instances for this path.
+rev_start is the starting revision (defaulting to the first one).
+rev_end is the last revision (defaulting to HEAD).
+if verbose is True, then the LogEntry instances also know which files changed.
+"""
+        assert self.check()   # make it simpler for the pipe
+        rev_start = rev_start is None and "HEAD" or rev_start
+        rev_end = rev_end is None and "HEAD" or rev_end
+        if rev_start == "HEAD" and rev_end == 1:
+                rev_opt = ""
+        else:
+            rev_opt = "-r %s:%s" % (rev_start, rev_end)
+        verbose_opt = verbose and "-v" or ""
+        locale_env = fixlocale()
+        # some blather on stderr
+        auth_opt = self._makeauthoptions()
+        #stdin, stdout, stderr  = os.popen3(locale_env +
+        #                                   'svn log --xml %s %s %s "%s"' % (
+        #                                    rev_opt, verbose_opt, auth_opt,
+        #                                    self.strpath))
+        cmd = locale_env + 'svn log --xml %s %s %s "%s"' % (
+            rev_opt, verbose_opt, auth_opt, self.strpath)
+
+        popen = subprocess.Popen(cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    shell=True,
+        )
+        stdout, stderr = popen.communicate()
+        stdout = py.builtin._totext(stdout, sys.getdefaultencoding())
+        minidom,ExpatError = importxml()
+        try:
+            tree = minidom.parseString(stdout)
+        except ExpatError:
+            raise ValueError('no such revision')
+        result = []
+        for logentry in filter(None, tree.firstChild.childNodes):
+            if logentry.nodeType == logentry.ELEMENT_NODE:
+                result.append(LogEntry(logentry))
+        return result
+
+    def size(self):
+        """ Return the size of the file content of the Path. """
+        return self.info().size
+
+    def mtime(self):
+        """ Return the last modification time of the file. """
+        return self.info().mtime
+
+    def __hash__(self):
+        return hash((self.strpath, self.__class__, self.auth))
+
+
+class WCStatus:
+    attrnames = ('modified','added', 'conflict', 'unchanged', 'external',
+                'deleted', 'prop_modified', 'unknown', 'update_available',
+                'incomplete', 'kindmismatch', 'ignored', 'locked', 'replaced'
+                )
+
+    def __init__(self, wcpath, rev=None, modrev=None, author=None):
+        self.wcpath = wcpath
+        self.rev = rev
+        self.modrev = modrev
+        self.author = author
+
+        for name in self.attrnames:
+            setattr(self, name, [])
+
+    def allpath(self, sort=True, **kw):
+        d = {}
+        for name in self.attrnames:
+            if name not in kw or kw[name]:
+                for path in getattr(self, name):
+                    d[path] = 1
+        l = d.keys()
+        if sort:
+            l.sort()
+        return l
+
+    # XXX a bit scary to assume there's always 2 spaces between username and
+    # path, however with win32 allowing spaces in user names there doesn't
+    # seem to be a more solid approach :(
+    _rex_status = re.compile(r'\s+(\d+|-)\s+(\S+)\s+(.+?)\s{2,}(.*)')
+
+    def fromstring(data, rootwcpath, rev=None, modrev=None, author=None):
+        """ return a new WCStatus object from data 's'
+        """
+        rootstatus = WCStatus(rootwcpath, rev, modrev, author)
+        update_rev = None
+        for line in data.split('\n'):
+            if not line.strip():
+                continue
+            #print "processing %r" % line
+            flags, rest = line[:8], line[8:]
+            # first column
+            c0,c1,c2,c3,c4,c5,x6,c7 = flags
+            #if '*' in line:
+            #    print "flags", repr(flags), "rest", repr(rest)
+
+            if c0 in '?XI':
+                fn = line.split(None, 1)[1]
+                if c0 == '?':
+                    wcpath = rootwcpath.join(fn, abs=1)
+                    rootstatus.unknown.append(wcpath)
+                elif c0 == 'X':
+                    wcpath = rootwcpath.__class__(
+                        rootwcpath.localpath.join(fn, abs=1),
+                        auth=rootwcpath.auth)
+                    rootstatus.external.append(wcpath)
+                elif c0 == 'I':
+                    wcpath = rootwcpath.join(fn, abs=1)
+                    rootstatus.ignored.append(wcpath)
+
+                continue
+
+            #elif c0 in '~!' or c4 == 'S':
+            #    raise NotImplementedError("received flag %r" % c0)
+
+            m = WCStatus._rex_status.match(rest)
+            if not m:
+                if c7 == '*':
+                    fn = rest.strip()
+                    wcpath = rootwcpath.join(fn, abs=1)
+                    rootstatus.update_available.append(wcpath)
+                    continue
+                if line.lower().find('against revision:')!=-1:
+                    update_rev = int(rest.split(':')[1].strip())
+                    continue
+                if line.lower().find('status on external') > -1:
+                    # XXX not sure what to do here... perhaps we want to
+                    # store some state instead of just continuing, as right
+                    # now it makes the top-level external get added twice
+                    # (once as external, once as 'normal' unchanged item)
+                    # because of the way SVN presents external items
+                    continue
+                # keep trying
+                raise ValueError("could not parse line %r" % line)
+            else:
+                rev, modrev, author, fn = m.groups()
+            wcpath = rootwcpath.join(fn, abs=1)
+            #assert wcpath.check()
+            if c0 == 'M':
+                assert wcpath.check(file=1), "didn't expect a directory with changed content here"
+                rootstatus.modified.append(wcpath)
+            elif c0 == 'A' or c3 == '+' :
+                rootstatus.added.append(wcpath)
+            elif c0 == 'D':
+                rootstatus.deleted.append(wcpath)
+            elif c0 == 'C':
+                rootstatus.conflict.append(wcpath)
+            elif c0 == '~':
+                rootstatus.kindmismatch.append(wcpath)
+            elif c0 == '!':
+                rootstatus.incomplete.append(wcpath)
+            elif c0 == 'R':
+                rootstatus.replaced.append(wcpath)
+            elif not c0.strip():
+                rootstatus.unchanged.append(wcpath)
+            else:
+                raise NotImplementedError("received flag %r" % c0)
+
+            if c1 == 'M':
+                rootstatus.prop_modified.append(wcpath)
+            # XXX do we cover all client versions here?
+            if c2 == 'L' or c5 == 'K':
+                rootstatus.locked.append(wcpath)
+            if c7 == '*':
+                rootstatus.update_available.append(wcpath)
+
+            if wcpath == rootwcpath:
+                rootstatus.rev = rev
+                rootstatus.modrev = modrev
+                rootstatus.author = author
+                if update_rev:
+                    rootstatus.update_rev = update_rev
+                continue
+        return rootstatus
+    fromstring = staticmethod(fromstring)
+
+class XMLWCStatus(WCStatus):
+    def fromstring(data, rootwcpath, rev=None, modrev=None, author=None):
+        """ parse 'data' (XML string as outputted by svn st) into a status obj
+        """
+        # XXX for externals, the path is shown twice: once
+        # with external information, and once with full info as if
+        # the item was a normal non-external... the current way of
+        # dealing with this issue is by ignoring it - this does make
+        # externals appear as external items as well as 'normal',
+        # unchanged ones in the status object so this is far from ideal
+        rootstatus = WCStatus(rootwcpath, rev, modrev, author)
+        update_rev = None
+        minidom, ExpatError = importxml()
+        try:
+            doc = minidom.parseString(data)
+        except ExpatError:
+            e = sys.exc_info()[1]
+            raise ValueError(str(e))
+        urevels = doc.getElementsByTagName('against')
+        if urevels:
+            rootstatus.update_rev = urevels[-1].getAttribute('revision')
+        for entryel in doc.getElementsByTagName('entry'):
+            path = entryel.getAttribute('path')
+            statusel = entryel.getElementsByTagName('wc-status')[0]
+            itemstatus = statusel.getAttribute('item')
+
+            if itemstatus == 'unversioned':
+                wcpath = rootwcpath.join(path, abs=1)
+                rootstatus.unknown.append(wcpath)
+                continue
+            elif itemstatus == 'external':
+                wcpath = rootwcpath.__class__(
+                    rootwcpath.localpath.join(path, abs=1),
+                    auth=rootwcpath.auth)
+                rootstatus.external.append(wcpath)
+                continue
+            elif itemstatus == 'ignored':
+                wcpath = rootwcpath.join(path, abs=1)
+                rootstatus.ignored.append(wcpath)
+                continue
+            elif itemstatus == 'incomplete':
+                wcpath = rootwcpath.join(path, abs=1)
+                rootstatus.incomplete.append(wcpath)
+                continue
+
+            rev = statusel.getAttribute('revision')
+            if itemstatus == 'added' or itemstatus == 'none':
+                rev = '0'
+                modrev = '?'
+                author = '?'
+                date = ''
+            elif itemstatus == "replaced":
+                pass
+            else:
+                #print entryel.toxml()
+                commitel = entryel.getElementsByTagName('commit')[0]
+                if commitel:
+                    modrev = commitel.getAttribute('revision')
+                    author = ''
+                    author_els = commitel.getElementsByTagName('author')
+                    if author_els:
+                        for c in author_els[0].childNodes:
+                            author += c.nodeValue
+                    date = ''
+                    for c in commitel.getElementsByTagName('date')[0]\
+                            .childNodes:
+                        date += c.nodeValue
+
+            wcpath = rootwcpath.join(path, abs=1)
+
+            assert itemstatus != 'modified' or wcpath.check(file=1), (
+                'did\'t expect a directory with changed content here')
+
+            itemattrname = {
+                'normal': 'unchanged',
+                'unversioned': 'unknown',
+                'conflicted': 'conflict',
+                'none': 'added',
+            }.get(itemstatus, itemstatus)
+
+            attr = getattr(rootstatus, itemattrname)
+            attr.append(wcpath)
+
+            propsstatus = statusel.getAttribute('props')
+            if propsstatus not in ('none', 'normal'):
+                rootstatus.prop_modified.append(wcpath)
+
+            if wcpath == rootwcpath:
+                rootstatus.rev = rev
+                rootstatus.modrev = modrev
+                rootstatus.author = author
+                rootstatus.date = date
+
+            # handle repos-status element (remote info)
+            rstatusels = entryel.getElementsByTagName('repos-status')
+            if rstatusels:
+                rstatusel = rstatusels[0]
+                ritemstatus = rstatusel.getAttribute('item')
+                if ritemstatus in ('added', 'modified'):
+                    rootstatus.update_available.append(wcpath)
+
+            lockels = entryel.getElementsByTagName('lock')
+            if len(lockels):
+                rootstatus.locked.append(wcpath)
+
+        return rootstatus
+    fromstring = staticmethod(fromstring)
+
+class InfoSvnWCCommand:
+    def __init__(self, output):
+        # Path: test
+        # URL: http://codespeak.net/svn/std.path/trunk/dist/std.path/test
+        # Repository UUID: fd0d7bf2-dfb6-0310-8d31-b7ecfe96aada
+        # Revision: 2151
+        # Node Kind: directory
+        # Schedule: normal
+        # Last Changed Author: hpk
+        # Last Changed Rev: 2100
+        # Last Changed Date: 2003-10-27 20:43:14 +0100 (Mon, 27 Oct 2003)
+        # Properties Last Updated: 2003-11-03 14:47:48 +0100 (Mon, 03 Nov 2003)
+
+        d = {}
+        for line in output.split('\n'):
+            if not line.strip():
+                continue
+            key, value = line.split(':', 1)
+            key = key.lower().replace(' ', '')
+            value = value.strip()
+            d[key] = value
+        try:
+            self.url = d['url']
+        except KeyError:
+            raise  ValueError("Not a versioned resource")
+            #raise ValueError, "Not a versioned resource %r" % path
+        self.kind = d['nodekind'] == 'directory' and 'dir' or d['nodekind']
+        try:
+            self.rev = int(d['revision'])
+        except KeyError:
+            self.rev = None
+
+        self.path = py.path.local(d['path'])
+        self.size = self.path.size()
+        if 'lastchangedrev' in d:
+            self.created_rev = int(d['lastchangedrev'])
+        if 'lastchangedauthor' in d:
+            self.last_author = d['lastchangedauthor']
+        if 'lastchangeddate' in d:
+            self.mtime = parse_wcinfotime(d['lastchangeddate'])
+            self.time = self.mtime * 1000000
+
+    def __eq__(self, other):
+        return self.__dict__ == other.__dict__
+
+def parse_wcinfotime(timestr):
+    """ Returns seconds since epoch, UTC. """
+    # example: 2003-10-27 20:43:14 +0100 (Mon, 27 Oct 2003)
+    m = re.match(r'(\d+-\d+-\d+ \d+:\d+:\d+) ([+-]\d+) .*', timestr)
+    if not m:
+        raise ValueError("timestring %r does not match" % timestr)
+    timestr, timezone = m.groups()
+    # do not handle timezone specially, return value should be UTC
+    parsedtime = time.strptime(timestr, "%Y-%m-%d %H:%M:%S")
+    return calendar.timegm(parsedtime)
+
+def make_recursive_propdict(wcroot,
+                            output,
+                            rex = re.compile("Properties on '(.*)':")):
+    """ Return a dictionary of path->PropListDict mappings. """
+    lines = [x for x in output.split('\n') if x]
+    pdict = {}
+    while lines:
+        line = lines.pop(0)
+        m = rex.match(line)
+        if not m:
+            raise ValueError("could not parse propget-line: %r" % line)
+        path = m.groups()[0]
+        wcpath = wcroot.join(path, abs=1)
+        propnames = []
+        while lines and lines[0].startswith('  '):
+            propname = lines.pop(0).strip()
+            propnames.append(propname)
+        assert propnames, "must have found properties!"
+        pdict[wcpath] = PropListDict(wcpath, propnames)
+    return pdict
+
+
+def importxml(cache=[]):
+    if cache:
+        return cache
+    from xml.dom import minidom
+    from xml.parsers.expat import ExpatError
+    cache.extend([minidom, ExpatError])
+    return cache
+
+class LogEntry:
+    def __init__(self, logentry):
+        self.rev = int(logentry.getAttribute('revision'))
+        for lpart in filter(None, logentry.childNodes):
+            if lpart.nodeType == lpart.ELEMENT_NODE:
+                if lpart.nodeName == 'author':
+                    self.author = lpart.firstChild.nodeValue
+                elif lpart.nodeName == 'msg':
+                    if lpart.firstChild:
+                        self.msg = lpart.firstChild.nodeValue
+                    else:
+                        self.msg = ''
+                elif lpart.nodeName == 'date':
+                    #2003-07-29T20:05:11.598637Z
+                    timestr = lpart.firstChild.nodeValue
+                    self.date = parse_apr_time(timestr)
+                elif lpart.nodeName == 'paths':
+                    self.strpaths = []
+                    for ppart in filter(None, lpart.childNodes):
+                        if ppart.nodeType == ppart.ELEMENT_NODE:
+                            self.strpaths.append(PathEntry(ppart))
+    def __repr__(self):
+        return '<Logentry rev=%d author=%s date=%s>' % (
+            self.rev, self.author, self.date)
+
+
diff --git a/myenv/lib/python3.9/site-packages/py/_process/__init__.py b/myenv/lib/python3.9/site-packages/py/_process/__init__.py
new file mode 100644
index 0000000..86c714a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_process/__init__.py
@@ -0,0 +1 @@
+""" high-level sub-process handling """
diff --git a/myenv/lib/python3.9/site-packages/py/_process/cmdexec.py b/myenv/lib/python3.9/site-packages/py/_process/cmdexec.py
new file mode 100644
index 0000000..f83a249
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_process/cmdexec.py
@@ -0,0 +1,49 @@
+import sys
+import subprocess
+import py
+from subprocess import Popen, PIPE
+
+def cmdexec(cmd):
+    """ return unicode output of executing 'cmd' in a separate process.
+
+    raise cmdexec.Error exeception if the command failed.
+    the exception will provide an 'err' attribute containing
+    the error-output from the command.
+    if the subprocess module does not provide a proper encoding/unicode strings
+    sys.getdefaultencoding() will be used, if that does not exist, 'UTF-8'.
+    """
+    process = subprocess.Popen(cmd, shell=True,
+            universal_newlines=True,
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    out, err = process.communicate()
+    if sys.version_info[0] < 3: # on py3 we get unicode strings, on py2 not
+        try:
+            default_encoding = sys.getdefaultencoding() # jython may not have it
+        except AttributeError:
+            default_encoding = sys.stdout.encoding or 'UTF-8'
+        out = unicode(out, process.stdout.encoding or default_encoding)
+        err = unicode(err, process.stderr.encoding or default_encoding)
+    status = process.poll()
+    if status:
+        raise ExecutionFailed(status, status, cmd, out, err)
+    return out
+
+class ExecutionFailed(py.error.Error):
+    def __init__(self, status, systemstatus, cmd, out, err):
+        Exception.__init__(self)
+        self.status = status
+        self.systemstatus = systemstatus
+        self.cmd = cmd
+        self.err = err
+        self.out = out
+
+    def __str__(self):
+        return "ExecutionFailed: %d  %s\n%s" %(self.status, self.cmd, self.err)
+
+# export the exception under the name 'py.process.cmdexec.Error'
+cmdexec.Error = ExecutionFailed
+try:
+    ExecutionFailed.__module__ = 'py.process.cmdexec'
+    ExecutionFailed.__name__ = 'Error'
+except (AttributeError, TypeError):
+    pass
diff --git a/myenv/lib/python3.9/site-packages/py/_process/forkedfunc.py b/myenv/lib/python3.9/site-packages/py/_process/forkedfunc.py
new file mode 100644
index 0000000..1c28530
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_process/forkedfunc.py
@@ -0,0 +1,120 @@
+
+"""
+    ForkedFunc provides a way to run a function in a forked process
+    and get at its return value, stdout and stderr output as well
+    as signals and exitstatusus.
+"""
+
+import py
+import os
+import sys
+import marshal
+
+
+def get_unbuffered_io(fd, filename):
+    f = open(str(filename), "w")
+    if fd != f.fileno():
+        os.dup2(f.fileno(), fd)
+    class AutoFlush:
+        def write(self, data):
+            f.write(data)
+            f.flush()
+        def __getattr__(self, name):
+            return getattr(f, name)
+    return AutoFlush()
+
+
+class ForkedFunc:
+    EXITSTATUS_EXCEPTION = 3
+
+
+    def __init__(self, fun, args=None, kwargs=None, nice_level=0,
+                 child_on_start=None, child_on_exit=None):
+        if args is None:
+            args = []
+        if kwargs is None:
+            kwargs = {}
+        self.fun = fun
+        self.args = args
+        self.kwargs = kwargs
+        self.tempdir = tempdir = py.path.local.mkdtemp()
+        self.RETVAL = tempdir.ensure('retval')
+        self.STDOUT = tempdir.ensure('stdout')
+        self.STDERR = tempdir.ensure('stderr')
+
+        pid = os.fork()
+        if pid:  # in parent process
+            self.pid = pid
+        else:  # in child process
+            self.pid = None
+            self._child(nice_level, child_on_start, child_on_exit)
+
+    def _child(self, nice_level, child_on_start, child_on_exit):
+        # right now we need to call a function, but first we need to
+        # map all IO that might happen
+        sys.stdout = stdout = get_unbuffered_io(1, self.STDOUT)
+        sys.stderr = stderr = get_unbuffered_io(2, self.STDERR)
+        retvalf = self.RETVAL.open("wb")
+        EXITSTATUS = 0
+        try:
+            if nice_level:
+                os.nice(nice_level)
+            try:
+                if child_on_start is not None:
+                    child_on_start()
+                retval = self.fun(*self.args, **self.kwargs)
+                retvalf.write(marshal.dumps(retval))
+                if child_on_exit is not None:
+                    child_on_exit()
+            except:
+                excinfo = py.code.ExceptionInfo()
+                stderr.write(str(excinfo._getreprcrash()))
+                EXITSTATUS = self.EXITSTATUS_EXCEPTION
+        finally:
+            stdout.close()
+            stderr.close()
+            retvalf.close()
+        os.close(1)
+        os.close(2)
+        os._exit(EXITSTATUS)
+
+    def waitfinish(self, waiter=os.waitpid):
+        pid, systemstatus = waiter(self.pid, 0)
+        if systemstatus:
+            if os.WIFSIGNALED(systemstatus):
+                exitstatus = os.WTERMSIG(systemstatus) + 128
+            else:
+                exitstatus = os.WEXITSTATUS(systemstatus)
+        else:
+            exitstatus = 0
+        signal = systemstatus & 0x7f
+        if not exitstatus and not signal:
+            retval = self.RETVAL.open('rb')
+            try:
+                retval_data = retval.read()
+            finally:
+                retval.close()
+            retval = marshal.loads(retval_data)
+        else:
+            retval = None
+        stdout = self.STDOUT.read()
+        stderr = self.STDERR.read()
+        self._removetemp()
+        return Result(exitstatus, signal, retval, stdout, stderr)
+
+    def _removetemp(self):
+        if self.tempdir.check():
+            self.tempdir.remove()
+
+    def __del__(self):
+        if self.pid is not None:  # only clean up in main process
+            self._removetemp()
+
+
+class Result(object):
+    def __init__(self, exitstatus, signal, retval, stdout, stderr):
+        self.exitstatus = exitstatus
+        self.signal = signal
+        self.retval = retval
+        self.out = stdout
+        self.err = stderr
diff --git a/myenv/lib/python3.9/site-packages/py/_process/killproc.py b/myenv/lib/python3.9/site-packages/py/_process/killproc.py
new file mode 100644
index 0000000..18e8310
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_process/killproc.py
@@ -0,0 +1,23 @@
+import py
+import os, sys
+
+if sys.platform == "win32" or getattr(os, '_name', '') == 'nt':
+    try:
+        import ctypes
+    except ImportError:
+        def dokill(pid):
+            py.process.cmdexec("taskkill /F /PID %d" %(pid,))
+    else:
+        def dokill(pid):
+            PROCESS_TERMINATE = 1
+            handle = ctypes.windll.kernel32.OpenProcess(
+                        PROCESS_TERMINATE, False, pid)
+            ctypes.windll.kernel32.TerminateProcess(handle, -1)
+            ctypes.windll.kernel32.CloseHandle(handle)
+else:
+    def dokill(pid):
+        os.kill(pid, 15)
+
+def kill(pid):
+    """ kill process by id. """
+    dokill(pid)
diff --git a/myenv/lib/python3.9/site-packages/py/_std.py b/myenv/lib/python3.9/site-packages/py/_std.py
new file mode 100644
index 0000000..66adb7b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_std.py
@@ -0,0 +1,27 @@
+import sys
+import warnings
+
+
+class PyStdIsDeprecatedWarning(DeprecationWarning):
+    pass
+
+
+class Std(object):
+    """ makes top-level python modules available as an attribute,
+        importing them on first access.
+    """
+
+    def __init__(self):
+        self.__dict__ = sys.modules
+
+    def __getattr__(self, name):
+        warnings.warn("py.std is deprecated, please import %s directly" % name,
+                      category=PyStdIsDeprecatedWarning,
+                      stacklevel=2)
+        try:
+            m = __import__(name)
+        except ImportError:
+            raise AttributeError("py.std: could not import %s" % name)
+        return m
+
+std = Std()
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/__init__.py b/myenv/lib/python3.9/site-packages/py/_vendored_packages/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/INSTALLER
new file mode 100644
index 0000000..a1b589e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/LICENSE
new file mode 100644
index 0000000..ff33b8f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/LICENSE
@@ -0,0 +1,18 @@
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/METADATA
new file mode 100644
index 0000000..7eea770
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/METADATA
@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: apipkg
+Version: 2.0.0
+Summary: apipkg: namespace control and lazy-import mechanism
+Home-page: https://github.com/pytest-dev/apipkg
+Author: holger krekel
+Maintainer: Ronny Pfannschmidt
+Maintainer-email: opensource@ronnypfannschmidt.de
+License: MIT
+Platform: unix
+Platform: linux
+Platform: osx
+Platform: cygwin
+Platform: win32
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,>=2.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+
+Welcome to apipkg !
+-------------------
+
+With apipkg you can control the exported namespace of a Python package and
+greatly reduce the number of imports for your users.
+It is a `small pure Python module`_ that works on CPython 2.7 and 3.4+,
+Jython and PyPy. It cooperates well with Python's ``help()`` system,
+custom importers (PEP302) and common command-line completion tools.
+
+Usage is very simple: you can require 'apipkg' as a dependency or you
+can copy paste the ~200 lines of code into your project.
+
+
+Tutorial example
+-------------------
+
+Here is a simple ``mypkg`` package that specifies one namespace
+and exports two objects imported from different modules::
+
+
+    # mypkg/__init__.py
+    import apipkg
+    apipkg.initpkg(__name__, {
+        'path': {
+            'Class1': "_mypkg.somemodule:Class1",
+            'clsattr': "_mypkg.othermodule:Class2.attr",
+        }
+    }
+
+The package is initialized with a dictionary as namespace.
+
+You need to create a ``_mypkg`` package with a ``somemodule.py``
+and ``othermodule.py`` containing the respective classes.
+The ``_mypkg`` is not special - it's a completely
+regular Python package.
+
+Namespace dictionaries contain ``name: value`` mappings
+where the value may be another namespace dictionary or
+a string specifying an import location.  On accessing
+an namespace attribute an import will be performed::
+
+    >>> import mypkg
+    >>> mypkg.path
+    <ApiModule 'mypkg.path'>
+    >>> mypkg.path.Class1   # '_mypkg.somemodule' gets imported now
+    <class _mypkg.somemodule.Class1 at 0xb7d428fc>
+    >>> mypkg.path.clsattr  # '_mypkg.othermodule' gets imported now
+    4 # the value of _mypkg.othermodule.Class2.attr
+
+The ``mypkg.path`` namespace and its two entries are
+loaded when they are accessed.   This means:
+
+* lazy loading - only what is actually needed is ever loaded
+
+* only the root "mypkg" ever needs to be imported to get
+  access to the complete functionality
+
+* the underlying modules are also accessible, for example::
+
+    from mypkg.sub import Class1
+
+
+Including apipkg in your package
+--------------------------------------
+
+If you don't want to add an ``apipkg`` dependency to your package you
+can copy the `apipkg.py`_ file somewhere to your own package,
+for example ``_mypkg/apipkg.py`` in the above example.  You
+then import the ``initpkg`` function from that new place and
+are good to go.
+
+.. _`small pure Python module`:
+.. _`apipkg.py`: https://github.com/pytest-dev/apipkg/blob/master/src/apipkg/__init__.py
+
+Feedback?
+-----------------------
+
+If you have questions you are welcome to
+
+* join the **#pytest** channel on irc.libera.chat_
+  (using an IRC client, via webchat_, or via Matrix_).
+* create an issue on the bugtracker_
+
+.. _irc.libera.chat: ircs://irc.libera.chat:6697/#pytest
+.. _webchat: https://web.libera.chat/#pytest
+.. _matrix: https://matrix.to/#/%23pytest:libera.chat
+.. _bugtracker: https://github.com/pytest-dev/apipkg/issues
+
+
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/RECORD
new file mode 100644
index 0000000..357b8b9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/RECORD
@@ -0,0 +1,11 @@
+apipkg-2.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+apipkg-2.0.0.dist-info/LICENSE,sha256=6J7tEHTTqUMZi6E5uAhE9bRFuGC7p0qK6twGEFZhZOo,1054
+apipkg-2.0.0.dist-info/METADATA,sha256=GqNwkxraK5UTxObLVXTLc2UqktOPwZnKqdk2ThzHX0A,4292
+apipkg-2.0.0.dist-info/RECORD,,
+apipkg-2.0.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apipkg-2.0.0.dist-info/WHEEL,sha256=WzZ8cwjh8l0jtULNjYq1Hpr-WCqCRgPr--TX4P5I1Wo,110
+apipkg-2.0.0.dist-info/top_level.txt,sha256=3TGS6nmN7kjxhUK4LpPCB3QkQI34QYGrT0ZQGWajoZ8,7
+apipkg/__init__.py,sha256=gpbD3O57S9f-LsO2e-XwI6IGISayicfnCq3B5y_8frg,6978
+apipkg/__pycache__/__init__.cpython-39.pyc,,
+apipkg/__pycache__/version.cpython-39.pyc,,
+apipkg/version.py,sha256=bgZFg-f3UKhgE-z2w8RoFrwqRBzJBZkM4_jKFiYB9eU,142
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/REQUESTED b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/REQUESTED
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/WHEEL
new file mode 100644
index 0000000..b733a60
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/top_level.txt
new file mode 100644
index 0000000..e2221c8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg-2.0.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+apipkg
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg/__init__.py b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg/__init__.py
new file mode 100644
index 0000000..350d8c4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg/__init__.py
@@ -0,0 +1,217 @@
+"""
+apipkg: control the exported namespace of a Python package.
+
+see https://pypi.python.org/pypi/apipkg
+
+(c) holger krekel, 2009 - MIT license
+"""
+import os
+import sys
+from types import ModuleType
+
+from .version import version as __version__  # NOQA:F401
+
+
+def _py_abspath(path):
+    """
+    special version of abspath
+    that will leave paths from jython jars alone
+    """
+    if path.startswith("__pyclasspath__"):
+
+        return path
+    else:
+        return os.path.abspath(path)
+
+
+def distribution_version(name):
+    """try to get the version of the named distribution,
+    returs None on failure"""
+    from pkg_resources import get_distribution, DistributionNotFound
+
+    try:
+        dist = get_distribution(name)
+    except DistributionNotFound:
+        pass
+    else:
+        return dist.version
+
+
+def initpkg(pkgname, exportdefs, attr=None, eager=False):
+    """ initialize given package from the export definitions. """
+    attr = attr or {}
+    oldmod = sys.modules.get(pkgname)
+    d = {}
+    f = getattr(oldmod, "__file__", None)
+    if f:
+        f = _py_abspath(f)
+    d["__file__"] = f
+    if hasattr(oldmod, "__version__"):
+        d["__version__"] = oldmod.__version__
+    if hasattr(oldmod, "__loader__"):
+        d["__loader__"] = oldmod.__loader__
+    if hasattr(oldmod, "__path__"):
+        d["__path__"] = [_py_abspath(p) for p in oldmod.__path__]
+    if hasattr(oldmod, "__package__"):
+        d["__package__"] = oldmod.__package__
+    if "__doc__" not in exportdefs and getattr(oldmod, "__doc__", None):
+        d["__doc__"] = oldmod.__doc__
+    d["__spec__"] = getattr(oldmod, "__spec__", None)
+    d.update(attr)
+    if hasattr(oldmod, "__dict__"):
+        oldmod.__dict__.update(d)
+    mod = ApiModule(pkgname, exportdefs, implprefix=pkgname, attr=d)
+    sys.modules[pkgname] = mod
+    # eagerload in bypthon to avoid their monkeypatching breaking packages
+    if "bpython" in sys.modules or eager:
+        for module in list(sys.modules.values()):
+            if isinstance(module, ApiModule):
+                module.__dict__
+    return mod
+
+
+def importobj(modpath, attrname):
+    """imports a module, then resolves the attrname on it"""
+    module = __import__(modpath, None, None, ["__doc__"])
+    if not attrname:
+        return module
+
+    retval = module
+    names = attrname.split(".")
+    for x in names:
+        retval = getattr(retval, x)
+    return retval
+
+
+class ApiModule(ModuleType):
+    """the magical lazy-loading module standing"""
+
+    def __docget(self):
+        try:
+            return self.__doc
+        except AttributeError:
+            if "__doc__" in self.__map__:
+                return self.__makeattr("__doc__")
+
+    def __docset(self, value):
+        self.__doc = value
+
+    __doc__ = property(__docget, __docset)
+
+    def __init__(self, name, importspec, implprefix=None, attr=None):
+        self.__name__ = name
+        self.__all__ = [x for x in importspec if x != "__onfirstaccess__"]
+        self.__map__ = {}
+        self.__implprefix__ = implprefix or name
+        if attr:
+            for name, val in attr.items():
+                # print "setting", self.__name__, name, val
+                setattr(self, name, val)
+        for name, importspec in importspec.items():
+            if isinstance(importspec, dict):
+                subname = "{}.{}".format(self.__name__, name)
+                apimod = ApiModule(subname, importspec, implprefix)
+                sys.modules[subname] = apimod
+                setattr(self, name, apimod)
+            else:
+                parts = importspec.split(":")
+                modpath = parts.pop(0)
+                attrname = parts and parts[0] or ""
+                if modpath[0] == ".":
+                    modpath = implprefix + modpath
+
+                if not attrname:
+                    subname = "{}.{}".format(self.__name__, name)
+                    apimod = AliasModule(subname, modpath)
+                    sys.modules[subname] = apimod
+                    if "." not in name:
+                        setattr(self, name, apimod)
+                else:
+                    self.__map__[name] = (modpath, attrname)
+
+    def __repr__(self):
+        repr_list = []
+        if hasattr(self, "__version__"):
+            repr_list.append("version=" + repr(self.__version__))
+        if hasattr(self, "__file__"):
+            repr_list.append("from " + repr(self.__file__))
+        if repr_list:
+            return "<ApiModule {!r} {}>".format(self.__name__, " ".join(repr_list))
+        return "<ApiModule {!r}>".format(self.__name__)
+
+    def __makeattr(self, name):
+        """lazily compute value for name or raise AttributeError if unknown."""
+        # print "makeattr", self.__name__, name
+        target = None
+        if "__onfirstaccess__" in self.__map__:
+            target = self.__map__.pop("__onfirstaccess__")
+            importobj(*target)()
+        try:
+            modpath, attrname = self.__map__[name]
+        except KeyError:
+            if target is not None and name != "__onfirstaccess__":
+                # retry, onfirstaccess might have set attrs
+                return getattr(self, name)
+            raise AttributeError(name)
+        else:
+            result = importobj(modpath, attrname)
+            setattr(self, name, result)
+            try:
+                del self.__map__[name]
+            except KeyError:
+                pass  # in a recursive-import situation a double-del can happen
+            return result
+
+    __getattr__ = __makeattr
+
+    @property
+    def __dict__(self):
+        # force all the content of the module
+        # to be loaded when __dict__ is read
+        dictdescr = ModuleType.__dict__["__dict__"]
+        dict = dictdescr.__get__(self)
+        if dict is not None:
+            hasattr(self, "some")
+            for name in self.__all__:
+                try:
+                    self.__makeattr(name)
+                except AttributeError:
+                    pass
+        return dict
+
+
+def AliasModule(modname, modpath, attrname=None):
+    mod = []
+
+    def getmod():
+        if not mod:
+            x = importobj(modpath, None)
+            if attrname is not None:
+                x = getattr(x, attrname)
+            mod.append(x)
+        return mod[0]
+
+    x = modpath + ("." + attrname if attrname else "")
+    repr_result = "<AliasModule {!r} for {!r}>".format(modname, x)
+
+    class AliasModule(ModuleType):
+        def __repr__(self):
+            return repr_result
+
+        def __getattribute__(self, name):
+            try:
+                return getattr(getmod(), name)
+            except ImportError:
+                if modpath == "pytest" and attrname is None:
+                    # hack for pylibs py.test
+                    return None
+                else:
+                    raise
+
+        def __setattr__(self, name, value):
+            setattr(getmod(), name, value)
+
+        def __delattr__(self, name):
+            delattr(getmod(), name)
+
+    return AliasModule(str(modname))
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg/version.py b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg/version.py
new file mode 100644
index 0000000..c5b4e0e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/apipkg/version.py
@@ -0,0 +1,5 @@
+# coding: utf-8
+# file generated by setuptools_scm
+# don't change, don't track in version control
+version = '2.0.0'
+version_tuple = (2, 0, 0)
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/INSTALLER
new file mode 100644
index 0000000..a1b589e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/LICENSE
new file mode 100644
index 0000000..31ecdfb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/LICENSE
@@ -0,0 +1,19 @@
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+     
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+ 
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/METADATA
new file mode 100644
index 0000000..c078a75
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/METADATA
@@ -0,0 +1,78 @@
+Metadata-Version: 2.1
+Name: iniconfig
+Version: 1.1.1
+Summary: iniconfig: brain-dead simple config-ini parsing
+Home-page: http://github.com/RonnyPfannschmidt/iniconfig
+Author: Ronny Pfannschmidt, Holger Krekel
+Author-email: opensource@ronnypfannschmidt.de, holger.krekel@gmail.com
+License: MIT License
+Platform: unix
+Platform: linux
+Platform: osx
+Platform: cygwin
+Platform: win32
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+
+iniconfig: brain-dead simple parsing of ini files
+=======================================================
+
+iniconfig is a small and simple INI-file parser module
+having a unique set of features:
+
+* tested against Python2.4 across to Python3.2, Jython, PyPy
+* maintains order of sections and entries
+* supports multi-line values with or without line-continuations
+* supports "#" comments everywhere
+* raises errors with proper line-numbers
+* no bells and whistles like automatic substitutions
+* iniconfig raises an Error if two sections have the same name.
+
+If you encounter issues or have feature wishes please report them to:
+
+    http://github.com/RonnyPfannschmidt/iniconfig/issues
+
+Basic Example
+===================================
+
+If you have an ini file like this::
+
+    # content of example.ini
+    [section1] # comment
+    name1=value1  # comment
+    name1b=value1,value2  # comment
+
+    [section2]
+    name2=
+        line1
+        line2
+
+then you can do::
+
+    >>> import iniconfig
+    >>> ini = iniconfig.IniConfig("example.ini")
+    >>> ini['section1']['name1'] # raises KeyError if not exists
+    'value1'
+    >>> ini.get('section1', 'name1b', [], lambda x: x.split(","))
+    ['value1', 'value2']
+    >>> ini.get('section1', 'notexist', [], lambda x: x.split(","))
+    []
+    >>> [x.name for x in list(ini)]
+    ['section1', 'section2']
+    >>> list(list(ini)[0].items())
+    [('name1', 'value1'), ('name1b', 'value1,value2')]
+    >>> 'section1' in ini
+    True
+    >>> 'inexistendsection' in ini
+    False
+
+
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/RECORD
new file mode 100644
index 0000000..1682333
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/RECORD
@@ -0,0 +1,11 @@
+iniconfig-1.1.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+iniconfig-1.1.1.dist-info/LICENSE,sha256=KvaAw570k_uCgwNW0dPfGstaBgM8ui3sehniHKp3qGY,1061
+iniconfig-1.1.1.dist-info/METADATA,sha256=_4-oFKpRXuZv5rzepScpXRwhq6DzqsgbnA5ZpgMUMcs,2405
+iniconfig-1.1.1.dist-info/RECORD,,
+iniconfig-1.1.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iniconfig-1.1.1.dist-info/WHEEL,sha256=ADKeyaGyKF5DwBNE0sRE5pvW-bSkFMJfBuhzZ3rceP4,110
+iniconfig-1.1.1.dist-info/top_level.txt,sha256=7KfM0fugdlToj9UW7enKXk2HYALQD8qHiyKtjhSzgN8,10
+iniconfig/__init__.py,sha256=-pBe5AF_6aAwo1CxJQ8i_zJq6ejc6IxHta7qk2tNJhY,5208
+iniconfig/__init__.pyi,sha256=-4KOctzq28ohRmTZsqlH6aylyFqsNKxYqtk1dteypi4,1205
+iniconfig/__pycache__/__init__.cpython-39.pyc,,
+iniconfig/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/REQUESTED b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/REQUESTED
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/WHEEL
new file mode 100644
index 0000000..6d38aa0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.35.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/top_level.txt
new file mode 100644
index 0000000..9dda536
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig-1.1.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+iniconfig
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig/__init__.py b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig/__init__.py
new file mode 100644
index 0000000..6ad9eaf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig/__init__.py
@@ -0,0 +1,165 @@
+""" brain-dead simple parser for ini-style files.
+(C) Ronny Pfannschmidt, Holger Krekel -- MIT licensed
+"""
+__all__ = ['IniConfig', 'ParseError']
+
+COMMENTCHARS = "#;"
+
+
+class ParseError(Exception):
+    def __init__(self, path, lineno, msg):
+        Exception.__init__(self, path, lineno, msg)
+        self.path = path
+        self.lineno = lineno
+        self.msg = msg
+
+    def __str__(self):
+        return "%s:%s: %s" % (self.path, self.lineno+1, self.msg)
+
+
+class SectionWrapper(object):
+    def __init__(self, config, name):
+        self.config = config
+        self.name = name
+
+    def lineof(self, name):
+        return self.config.lineof(self.name, name)
+
+    def get(self, key, default=None, convert=str):
+        return self.config.get(self.name, key,
+                               convert=convert, default=default)
+
+    def __getitem__(self, key):
+        return self.config.sections[self.name][key]
+
+    def __iter__(self):
+        section = self.config.sections.get(self.name, [])
+
+        def lineof(key):
+            return self.config.lineof(self.name, key)
+        for name in sorted(section, key=lineof):
+            yield name
+
+    def items(self):
+        for name in self:
+            yield name, self[name]
+
+
+class IniConfig(object):
+    def __init__(self, path, data=None):
+        self.path = str(path)  # convenience
+        if data is None:
+            f = open(self.path)
+            try:
+                tokens = self._parse(iter(f))
+            finally:
+                f.close()
+        else:
+            tokens = self._parse(data.splitlines(True))
+
+        self._sources = {}
+        self.sections = {}
+
+        for lineno, section, name, value in tokens:
+            if section is None:
+                self._raise(lineno, 'no section header defined')
+            self._sources[section, name] = lineno
+            if name is None:
+                if section in self.sections:
+                    self._raise(lineno, 'duplicate section %r' % (section, ))
+                self.sections[section] = {}
+            else:
+                if name in self.sections[section]:
+                    self._raise(lineno, 'duplicate name %r' % (name, ))
+                self.sections[section][name] = value
+
+    def _raise(self, lineno, msg):
+        raise ParseError(self.path, lineno, msg)
+
+    def _parse(self, line_iter):
+        result = []
+        section = None
+        for lineno, line in enumerate(line_iter):
+            name, data = self._parseline(line, lineno)
+            # new value
+            if name is not None and data is not None:
+                result.append((lineno, section, name, data))
+            # new section
+            elif name is not None and data is None:
+                if not name:
+                    self._raise(lineno, 'empty section name')
+                section = name
+                result.append((lineno, section, None, None))
+            # continuation
+            elif name is None and data is not None:
+                if not result:
+                    self._raise(lineno, 'unexpected value continuation')
+                last = result.pop()
+                last_name, last_data = last[-2:]
+                if last_name is None:
+                    self._raise(lineno, 'unexpected value continuation')
+
+                if last_data:
+                    data = '%s\n%s' % (last_data, data)
+                result.append(last[:-1] + (data,))
+        return result
+
+    def _parseline(self, line, lineno):
+        # blank lines
+        if iscommentline(line):
+            line = ""
+        else:
+            line = line.rstrip()
+        if not line:
+            return None, None
+        # section
+        if line[0] == '[':
+            realline = line
+            for c in COMMENTCHARS:
+                line = line.split(c)[0].rstrip()
+            if line[-1] == "]":
+                return line[1:-1], None
+            return None, realline.strip()
+        # value
+        elif not line[0].isspace():
+            try:
+                name, value = line.split('=', 1)
+                if ":" in name:
+                    raise ValueError()
+            except ValueError:
+                try:
+                    name, value = line.split(":", 1)
+                except ValueError:
+                    self._raise(lineno, 'unexpected line: %r' % line)
+            return name.strip(), value.strip()
+        # continuation
+        else:
+            return None, line.strip()
+
+    def lineof(self, section, name=None):
+        lineno = self._sources.get((section, name))
+        if lineno is not None:
+            return lineno + 1
+
+    def get(self, section, name, default=None, convert=str):
+        try:
+            return convert(self.sections[section][name])
+        except KeyError:
+            return default
+
+    def __getitem__(self, name):
+        if name not in self.sections:
+            raise KeyError(name)
+        return SectionWrapper(self, name)
+
+    def __iter__(self):
+        for name in sorted(self.sections, key=self.lineof):
+            yield SectionWrapper(self, name)
+
+    def __contains__(self, arg):
+        return arg in self.sections
+
+
+def iscommentline(line):
+    c = line.lstrip()[:1]
+    return c in COMMENTCHARS
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig/__init__.pyi b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig/__init__.pyi
new file mode 100644
index 0000000..b6284be
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig/__init__.pyi
@@ -0,0 +1,31 @@
+from typing import Callable, Iterator, Mapping, Optional, Tuple, TypeVar, Union
+from typing_extensions import Final
+
+_D = TypeVar('_D')
+_T = TypeVar('_T')
+
+class ParseError(Exception):
+    # Private __init__.
+    path: Final[str]
+    lineno: Final[int]
+    msg: Final[str]
+
+class SectionWrapper:
+    # Private __init__.
+    config: Final[IniConfig]
+    name: Final[str]
+    def __getitem__(self, key: str) -> str: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def get(self, key: str, default: _D = ..., convert: Callable[[str], _T] = ...) -> Union[_T, _D]: ...
+    def items(self) -> Iterator[Tuple[str, str]]: ...
+    def lineof(self, name: str) -> Optional[int]: ...
+
+class IniConfig:
+    path: Final[str]
+    sections: Final[Mapping[str, Mapping[str, str]]]
+    def __init__(self, path: str, data: Optional[str] = None): ...
+    def __contains__(self, arg: str) -> bool: ...
+    def __getitem__(self, name: str) -> SectionWrapper: ...
+    def __iter__(self) -> Iterator[SectionWrapper]: ...
+    def get(self, section: str, name: str, default: _D = ..., convert: Callable[[str], _T] = ...) -> Union[_T, _D]: ...
+    def lineof(self, section: str, name: Optional[str] = ...) -> Optional[int]: ...
diff --git a/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig/py.typed b/myenv/lib/python3.9/site-packages/py/_vendored_packages/iniconfig/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/py/_version.py b/myenv/lib/python3.9/site-packages/py/_version.py
new file mode 100644
index 0000000..3d30fbe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_version.py
@@ -0,0 +1,5 @@
+# coding: utf-8
+# file generated by setuptools_scm
+# don't change, don't track in version control
+version = '1.11.0'
+version_tuple = (1, 11, 0)
diff --git a/myenv/lib/python3.9/site-packages/py/_xmlgen.py b/myenv/lib/python3.9/site-packages/py/_xmlgen.py
new file mode 100644
index 0000000..1c83545
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/_xmlgen.py
@@ -0,0 +1,255 @@
+"""
+module for generating and serializing xml and html structures
+by using simple python objects.
+
+(c) holger krekel, holger at merlinux eu. 2009
+"""
+import sys, re
+
+if sys.version_info >= (3,0):
+    def u(s):
+        return s
+    def unicode(x, errors=None):
+        if hasattr(x, '__unicode__'):
+            return x.__unicode__()
+        return str(x)
+else:
+    def u(s):
+        return unicode(s)
+    unicode = unicode
+
+
+class NamespaceMetaclass(type):
+    def __getattr__(self, name):
+        if name[:1] == '_':
+            raise AttributeError(name)
+        if self == Namespace:
+            raise ValueError("Namespace class is abstract")
+        tagspec = self.__tagspec__
+        if tagspec is not None and name not in tagspec:
+            raise AttributeError(name)
+        classattr = {}
+        if self.__stickyname__:
+            classattr['xmlname'] = name
+        cls = type(name, (self.__tagclass__,), classattr)
+        setattr(self, name, cls)
+        return cls
+
+class Tag(list):
+    class Attr(object):
+        def __init__(self, **kwargs):
+            self.__dict__.update(kwargs)
+
+    def __init__(self, *args, **kwargs):
+        super(Tag, self).__init__(args)
+        self.attr = self.Attr(**kwargs)
+
+    def __unicode__(self):
+        return self.unicode(indent=0)
+    __str__ = __unicode__
+
+    def unicode(self, indent=2):
+        l = []
+        SimpleUnicodeVisitor(l.append, indent).visit(self)
+        return u("").join(l)
+
+    def __repr__(self):
+        name = self.__class__.__name__
+        return "<%r tag object %d>" % (name, id(self))
+
+Namespace = NamespaceMetaclass('Namespace', (object, ), {
+    '__tagspec__': None,
+    '__tagclass__': Tag,
+    '__stickyname__': False,
+})
+
+class HtmlTag(Tag):
+    def unicode(self, indent=2):
+        l = []
+        HtmlVisitor(l.append, indent, shortempty=False).visit(self)
+        return u("").join(l)
+
+# exported plain html namespace
+class html(Namespace):
+    __tagclass__ = HtmlTag
+    __stickyname__ = True
+    __tagspec__ = dict([(x,1) for x in (
+        'a,abbr,acronym,address,applet,area,article,aside,audio,b,'
+        'base,basefont,bdi,bdo,big,blink,blockquote,body,br,button,'
+        'canvas,caption,center,cite,code,col,colgroup,command,comment,'
+        'datalist,dd,del,details,dfn,dir,div,dl,dt,em,embed,'
+        'fieldset,figcaption,figure,footer,font,form,frame,frameset,h1,'
+        'h2,h3,h4,h5,h6,head,header,hgroup,hr,html,i,iframe,img,input,'
+        'ins,isindex,kbd,keygen,label,legend,li,link,listing,map,mark,'
+        'marquee,menu,meta,meter,multicol,nav,nobr,noembed,noframes,'
+        'noscript,object,ol,optgroup,option,output,p,param,pre,progress,'
+        'q,rp,rt,ruby,s,samp,script,section,select,small,source,span,'
+        'strike,strong,style,sub,summary,sup,table,tbody,td,textarea,'
+        'tfoot,th,thead,time,title,tr,track,tt,u,ul,xmp,var,video,wbr'
+    ).split(',') if x])
+
+    class Style(object):
+        def __init__(self, **kw):
+            for x, y in kw.items():
+                x = x.replace('_', '-')
+                setattr(self, x, y)
+
+
+class raw(object):
+    """just a box that can contain a unicode string that will be
+    included directly in the output"""
+    def __init__(self, uniobj):
+        self.uniobj = uniobj
+
+class SimpleUnicodeVisitor(object):
+    """ recursive visitor to write unicode. """
+    def __init__(self, write, indent=0, curindent=0, shortempty=True):
+        self.write = write
+        self.cache = {}
+        self.visited = {} # for detection of recursion
+        self.indent = indent
+        self.curindent = curindent
+        self.parents = []
+        self.shortempty = shortempty  # short empty tags or not
+
+    def visit(self, node):
+        """ dispatcher on node's class/bases name. """
+        cls = node.__class__
+        try:
+            visitmethod = self.cache[cls]
+        except KeyError:
+            for subclass in cls.__mro__:
+                visitmethod = getattr(self, subclass.__name__, None)
+                if visitmethod is not None:
+                    break
+            else:
+                visitmethod = self.__object
+            self.cache[cls] = visitmethod
+        visitmethod(node)
+
+    # the default fallback handler is marked private
+    # to avoid clashes with the tag name object
+    def __object(self, obj):
+        #self.write(obj)
+        self.write(escape(unicode(obj)))
+
+    def raw(self, obj):
+        self.write(obj.uniobj)
+
+    def list(self, obj):
+        assert id(obj) not in self.visited
+        self.visited[id(obj)] = 1
+        for elem in obj:
+            self.visit(elem)
+
+    def Tag(self, tag):
+        assert id(tag) not in self.visited
+        try:
+            tag.parent = self.parents[-1]
+        except IndexError:
+            tag.parent = None
+        self.visited[id(tag)] = 1
+        tagname = getattr(tag, 'xmlname', tag.__class__.__name__)
+        if self.curindent and not self._isinline(tagname):
+            self.write("\n" + u(' ') * self.curindent)
+        if tag:
+            self.curindent += self.indent
+            self.write(u('<%s%s>') % (tagname, self.attributes(tag)))
+            self.parents.append(tag)
+            for x in tag:
+                self.visit(x)
+            self.parents.pop()
+            self.write(u('</%s>') % tagname)
+            self.curindent -= self.indent
+        else:
+            nameattr = tagname+self.attributes(tag)
+            if self._issingleton(tagname):
+                self.write(u('<%s/>') % (nameattr,))
+            else:
+                self.write(u('<%s></%s>') % (nameattr, tagname))
+
+    def attributes(self, tag):
+        # serialize attributes
+        attrlist = dir(tag.attr)
+        attrlist.sort()
+        l = []
+        for name in attrlist:
+            res = self.repr_attribute(tag.attr, name)
+            if res is not None:
+                l.append(res)
+        l.extend(self.getstyle(tag))
+        return u("").join(l)
+
+    def repr_attribute(self, attrs, name):
+        if name[:2] != '__':
+            value = getattr(attrs, name)
+            if name.endswith('_'):
+                name = name[:-1]
+            if isinstance(value, raw):
+                insert = value.uniobj
+            else:
+                insert = escape(unicode(value))
+            return ' %s="%s"' % (name, insert)
+
+    def getstyle(self, tag):
+        """ return attribute list suitable for styling. """
+        try:
+            styledict = tag.style.__dict__
+        except AttributeError:
+            return []
+        else:
+            stylelist = [x+': ' + y for x,y in styledict.items()]
+            return [u(' style="%s"') % u('; ').join(stylelist)]
+
+    def _issingleton(self, tagname):
+        """can (and will) be overridden in subclasses"""
+        return self.shortempty
+
+    def _isinline(self, tagname):
+        """can (and will) be overridden in subclasses"""
+        return False
+
+class HtmlVisitor(SimpleUnicodeVisitor):
+
+    single = dict([(x, 1) for x in
+                ('br,img,area,param,col,hr,meta,link,base,'
+                    'input,frame').split(',')])
+    inline = dict([(x, 1) for x in
+                ('a abbr acronym b basefont bdo big br cite code dfn em font '
+                 'i img input kbd label q s samp select small span strike '
+                 'strong sub sup textarea tt u var'.split(' '))])
+
+    def repr_attribute(self, attrs, name):
+        if name == 'class_':
+            value = getattr(attrs, name)
+            if value is None:
+                return
+        return super(HtmlVisitor, self).repr_attribute(attrs, name)
+
+    def _issingleton(self, tagname):
+        return tagname in self.single
+
+    def _isinline(self, tagname):
+        return tagname in self.inline
+
+
+class _escape:
+    def __init__(self):
+        self.escape = {
+            u('"') : u('&quot;'), u('<') : u('&lt;'), u('>') : u('&gt;'),
+            u('&') : u('&amp;'), u("'") : u('&apos;'),
+            }
+        self.charef_rex = re.compile(u("|").join(self.escape.keys()))
+
+    def _replacer(self, match):
+        return self.escape[match.group(0)]
+
+    def __call__(self, ustring):
+        """ xml-escape the given unicode string. """
+        try:
+            ustring = unicode(ustring)
+        except UnicodeDecodeError:
+            ustring = unicode(ustring, 'utf-8', errors='replace')
+        return self.charef_rex.sub(self._replacer, ustring)
+
+escape = _escape()
diff --git a/myenv/lib/python3.9/site-packages/py/error.pyi b/myenv/lib/python3.9/site-packages/py/error.pyi
new file mode 100644
index 0000000..034eba6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/error.pyi
@@ -0,0 +1,129 @@
+from typing import Any, Callable, TypeVar
+
+_T = TypeVar('_T')
+
+def checked_call(func: Callable[..., _T], *args: Any, **kwargs: Any) -> _T: ...
+class Error(EnvironmentError): ...
+class EPERM(Error): ...
+class ENOENT(Error): ...
+class ESRCH(Error): ...
+class EINTR(Error): ...
+class EIO(Error): ...
+class ENXIO(Error): ...
+class E2BIG(Error): ...
+class ENOEXEC(Error): ...
+class EBADF(Error): ...
+class ECHILD(Error): ...
+class EAGAIN(Error): ...
+class ENOMEM(Error): ...
+class EACCES(Error): ...
+class EFAULT(Error): ...
+class ENOTBLK(Error): ...
+class EBUSY(Error): ...
+class EEXIST(Error): ...
+class EXDEV(Error): ...
+class ENODEV(Error): ...
+class ENOTDIR(Error): ...
+class EISDIR(Error): ...
+class EINVAL(Error): ...
+class ENFILE(Error): ...
+class EMFILE(Error): ...
+class ENOTTY(Error): ...
+class ETXTBSY(Error): ...
+class EFBIG(Error): ...
+class ENOSPC(Error): ...
+class ESPIPE(Error): ...
+class EROFS(Error): ...
+class EMLINK(Error): ...
+class EPIPE(Error): ...
+class EDOM(Error): ...
+class ERANGE(Error): ...
+class EDEADLCK(Error): ...
+class ENAMETOOLONG(Error): ...
+class ENOLCK(Error): ...
+class ENOSYS(Error): ...
+class ENOTEMPTY(Error): ...
+class ELOOP(Error): ...
+class EWOULDBLOCK(Error): ...
+class ENOMSG(Error): ...
+class EIDRM(Error): ...
+class ECHRNG(Error): ...
+class EL2NSYNC(Error): ...
+class EL3HLT(Error): ...
+class EL3RST(Error): ...
+class ELNRNG(Error): ...
+class EUNATCH(Error): ...
+class ENOCSI(Error): ...
+class EL2HLT(Error): ...
+class EBADE(Error): ...
+class EBADR(Error): ...
+class EXFULL(Error): ...
+class ENOANO(Error): ...
+class EBADRQC(Error): ...
+class EBADSLT(Error): ...
+class EDEADLOCK(Error): ...
+class EBFONT(Error): ...
+class ENOSTR(Error): ...
+class ENODATA(Error): ...
+class ETIME(Error): ...
+class ENOSR(Error): ...
+class ENONET(Error): ...
+class ENOPKG(Error): ...
+class EREMOTE(Error): ...
+class ENOLINK(Error): ...
+class EADV(Error): ...
+class ESRMNT(Error): ...
+class ECOMM(Error): ...
+class EPROTO(Error): ...
+class EMULTIHOP(Error): ...
+class EDOTDOT(Error): ...
+class EBADMSG(Error): ...
+class EOVERFLOW(Error): ...
+class ENOTUNIQ(Error): ...
+class EBADFD(Error): ...
+class EREMCHG(Error): ...
+class ELIBACC(Error): ...
+class ELIBBAD(Error): ...
+class ELIBSCN(Error): ...
+class ELIBMAX(Error): ...
+class ELIBEXEC(Error): ...
+class EILSEQ(Error): ...
+class ERESTART(Error): ...
+class ESTRPIPE(Error): ...
+class EUSERS(Error): ...
+class ENOTSOCK(Error): ...
+class EDESTADDRREQ(Error): ...
+class EMSGSIZE(Error): ...
+class EPROTOTYPE(Error): ...
+class ENOPROTOOPT(Error): ...
+class EPROTONOSUPPORT(Error): ...
+class ESOCKTNOSUPPORT(Error): ...
+class ENOTSUP(Error): ...
+class EOPNOTSUPP(Error): ...
+class EPFNOSUPPORT(Error): ...
+class EAFNOSUPPORT(Error): ...
+class EADDRINUSE(Error): ...
+class EADDRNOTAVAIL(Error): ...
+class ENETDOWN(Error): ...
+class ENETUNREACH(Error): ...
+class ENETRESET(Error): ...
+class ECONNABORTED(Error): ...
+class ECONNRESET(Error): ...
+class ENOBUFS(Error): ...
+class EISCONN(Error): ...
+class ENOTCONN(Error): ...
+class ESHUTDOWN(Error): ...
+class ETOOMANYREFS(Error): ...
+class ETIMEDOUT(Error): ...
+class ECONNREFUSED(Error): ...
+class EHOSTDOWN(Error): ...
+class EHOSTUNREACH(Error): ...
+class EALREADY(Error): ...
+class EINPROGRESS(Error): ...
+class ESTALE(Error): ...
+class EUCLEAN(Error): ...
+class ENOTNAM(Error): ...
+class ENAVAIL(Error): ...
+class EISNAM(Error): ...
+class EREMOTEIO(Error): ...
+class EDQUOT(Error): ...
diff --git a/myenv/lib/python3.9/site-packages/py/iniconfig.pyi b/myenv/lib/python3.9/site-packages/py/iniconfig.pyi
new file mode 100644
index 0000000..b6284be
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/iniconfig.pyi
@@ -0,0 +1,31 @@
+from typing import Callable, Iterator, Mapping, Optional, Tuple, TypeVar, Union
+from typing_extensions import Final
+
+_D = TypeVar('_D')
+_T = TypeVar('_T')
+
+class ParseError(Exception):
+    # Private __init__.
+    path: Final[str]
+    lineno: Final[int]
+    msg: Final[str]
+
+class SectionWrapper:
+    # Private __init__.
+    config: Final[IniConfig]
+    name: Final[str]
+    def __getitem__(self, key: str) -> str: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def get(self, key: str, default: _D = ..., convert: Callable[[str], _T] = ...) -> Union[_T, _D]: ...
+    def items(self) -> Iterator[Tuple[str, str]]: ...
+    def lineof(self, name: str) -> Optional[int]: ...
+
+class IniConfig:
+    path: Final[str]
+    sections: Final[Mapping[str, Mapping[str, str]]]
+    def __init__(self, path: str, data: Optional[str] = None): ...
+    def __contains__(self, arg: str) -> bool: ...
+    def __getitem__(self, name: str) -> SectionWrapper: ...
+    def __iter__(self) -> Iterator[SectionWrapper]: ...
+    def get(self, section: str, name: str, default: _D = ..., convert: Callable[[str], _T] = ...) -> Union[_T, _D]: ...
+    def lineof(self, section: str, name: Optional[str] = ...) -> Optional[int]: ...
diff --git a/myenv/lib/python3.9/site-packages/py/io.pyi b/myenv/lib/python3.9/site-packages/py/io.pyi
new file mode 100644
index 0000000..d377e24
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/io.pyi
@@ -0,0 +1,130 @@
+from io import StringIO as TextIO
+from io import BytesIO as BytesIO
+from typing import Any, AnyStr, Callable, Generic, IO, List, Optional, Text, Tuple, TypeVar, Union, overload
+from typing_extensions import Final
+import sys
+
+_T = TypeVar("_T")
+
+class FDCapture(Generic[AnyStr]):
+    def __init__(self, targetfd: int, tmpfile: Optional[IO[AnyStr]] = ..., now: bool = ..., patchsys: bool = ...) -> None: ...
+    def start(self) -> None: ...
+    def done(self) -> IO[AnyStr]: ...
+    def writeorg(self, data: AnyStr) -> None: ...
+
+class StdCaptureFD:
+    def __init__(
+        self,
+        out: Union[bool, IO[str]] = ...,
+        err: Union[bool, IO[str]] = ...,
+        mixed: bool = ...,
+        in_: bool = ...,
+        patchsys: bool = ...,
+        now: bool = ...,
+    ) -> None: ...
+    @classmethod
+    def call(cls, func: Callable[..., _T], *args: Any, **kwargs: Any) -> Tuple[_T, str, str]: ...
+    def reset(self) -> Tuple[str, str]: ...
+    def suspend(self) -> Tuple[str, str]: ...
+    def startall(self) -> None: ...
+    def resume(self) -> None: ...
+    def done(self, save: bool = ...) -> Tuple[IO[str], IO[str]]: ...
+    def readouterr(self) -> Tuple[str, str]: ...
+
+class StdCapture:
+    def __init__(
+        self,
+        out: Union[bool, IO[str]] = ...,
+        err: Union[bool, IO[str]] = ...,
+        in_: bool = ...,
+        mixed: bool = ...,
+        now: bool = ...,
+    ) -> None: ...
+    @classmethod
+    def call(cls, func: Callable[..., _T], *args: Any, **kwargs: Any) -> Tuple[_T, str, str]: ...
+    def reset(self) -> Tuple[str, str]: ...
+    def suspend(self) -> Tuple[str, str]: ...
+    def startall(self) -> None: ...
+    def resume(self) -> None: ...
+    def done(self, save: bool = ...) -> Tuple[IO[str], IO[str]]: ...
+    def readouterr(self) -> Tuple[IO[str], IO[str]]: ...
+
+# XXX: The type here is not exactly right. If f is IO[bytes] and
+# encoding is not None, returns some weird hybrid, not exactly IO[bytes].
+def dupfile(
+    f: IO[AnyStr],
+    mode: Optional[str] = ...,
+    buffering: int = ...,
+    raising: bool = ...,
+    encoding: Optional[str] = ...,
+) -> IO[AnyStr]: ...
+def get_terminal_width() -> int: ...
+def ansi_print(
+    text: Union[str, Text],
+    esc: Union[Union[str, Text], Tuple[Union[str, Text], ...]],
+    file: Optional[IO[Any]] = ...,
+    newline: bool = ...,
+    flush: bool = ...,
+) -> None: ...
+def saferepr(obj, maxsize: int = ...) -> str: ...
+
+class TerminalWriter:
+    stringio: TextIO
+    encoding: Final[str]
+    hasmarkup: bool
+    def __init__(self, file: Optional[IO[str]] = ..., stringio: bool = ..., encoding: Optional[str] = ...) -> None: ...
+    @property
+    def fullwidth(self) -> int: ...
+    @fullwidth.setter
+    def fullwidth(self, value: int) -> None: ...
+    @property
+    def chars_on_current_line(self) -> int: ...
+    @property
+    def width_of_current_line(self) -> int: ...
+    def markup(
+        self,
+        text: str,
+        *,
+        black: int = ..., red: int = ..., green: int = ..., yellow: int = ..., blue: int = ..., purple: int = ...,
+        cyan: int = ..., white: int = ..., Black: int = ..., Red: int = ..., Green: int = ..., Yellow: int = ...,
+        Blue: int = ..., Purple: int = ..., Cyan: int = ..., White: int = ..., bold: int = ..., light: int = ...,
+        blink: int = ..., invert: int = ...,
+    ) -> str: ...
+    def sep(
+        self,
+        sepchar: str,
+        title: Optional[str] = ...,
+        fullwidth: Optional[int] = ...,
+        *,
+        black: int = ..., red: int = ..., green: int = ..., yellow: int = ..., blue: int = ..., purple: int = ...,
+        cyan: int = ..., white: int = ..., Black: int = ..., Red: int = ..., Green: int = ..., Yellow: int = ...,
+        Blue: int = ..., Purple: int = ..., Cyan: int = ..., White: int = ..., bold: int = ..., light: int = ...,
+        blink: int = ..., invert: int = ...,
+    ) -> None: ...
+    def write(
+        self,
+        msg: str,
+        *,
+        black: int = ..., red: int = ..., green: int = ..., yellow: int = ..., blue: int = ..., purple: int = ...,
+        cyan: int = ..., white: int = ..., Black: int = ..., Red: int = ..., Green: int = ..., Yellow: int = ...,
+        Blue: int = ..., Purple: int = ..., Cyan: int = ..., White: int = ..., bold: int = ..., light: int = ...,
+        blink: int = ..., invert: int = ...,
+    ) -> None: ...
+    def line(
+        self,
+        s: str = ...,
+        *,
+        black: int = ..., red: int = ..., green: int = ..., yellow: int = ..., blue: int = ..., purple: int = ...,
+        cyan: int = ..., white: int = ..., Black: int = ..., Red: int = ..., Green: int = ..., Yellow: int = ...,
+        Blue: int = ..., Purple: int = ..., Cyan: int = ..., White: int = ..., bold: int = ..., light: int = ...,
+        blink: int = ..., invert: int = ...,
+    ) -> None: ...
+    def reline(
+        self,
+        line: str,
+        *,
+        black: int = ..., red: int = ..., green: int = ..., yellow: int = ..., blue: int = ..., purple: int = ...,
+        cyan: int = ..., white: int = ..., Black: int = ..., Red: int = ..., Green: int = ..., Yellow: int = ...,
+        Blue: int = ..., Purple: int = ..., Cyan: int = ..., White: int = ..., bold: int = ..., light: int = ...,
+        blink: int = ..., invert: int = ...,
+    ) -> None: ...
diff --git a/myenv/lib/python3.9/site-packages/py/path.pyi b/myenv/lib/python3.9/site-packages/py/path.pyi
new file mode 100644
index 0000000..1ddab96
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/path.pyi
@@ -0,0 +1,197 @@
+from typing import Any, AnyStr, Callable, ContextManager, Generic, IO, Iterable, Iterator, List, Optional, Text, Type, Union
+from typing_extensions import Final, Literal
+import os
+import sys
+
+class _FNMatcher(Generic[AnyStr]):
+    pattern: AnyStr = ...
+    def __init__(self, pattern: AnyStr) -> None: ...
+    def __call__(self, path: local) -> bool: ...
+
+class _Stat:
+    path: Final[local] = ...
+    mode: Final[int]
+    ino: Final[int]
+    dev: Final[int]
+    nlink: Final[int]
+    uid: Final[int]
+    gid: Final[int]
+    size: Final[int]
+    atime: Final[float]
+    mtime: Final[float]
+    ctime: Final[float]
+    atime_ns: Final[int]
+    mtime_ns: Final[int]
+    ctime_ns: Final[int]
+    if sys.version_info >= (3, 8) and sys.platform == "win32":
+        reparse_tag: Final[int]
+    blocks: Final[int]
+    blksize: Final[int]
+    rdev: Final[int]
+    flags: Final[int]
+    gen: Final[int]
+    birthtime: Final[int]
+    rsize: Final[int]
+    creator: Final[int]
+    type: Final[int]
+    if sys.platform != 'win32':
+        @property
+        def owner(self) -> str: ...
+        @property
+        def group(self) -> str: ...
+    def isdir(self) -> bool: ...
+    def isfile(self) -> bool: ...
+    def islink(self) -> bool: ...
+
+
+if sys.version_info >= (3, 6):
+    _PathLike = os.PathLike
+else:
+    class _PathLike(Generic[AnyStr]):
+        def __fspath__(self) -> AnyStr: ...
+_PathType = Union[bytes, Text, _PathLike[str], _PathLike[bytes], local]
+
+class local(_PathLike[str]):
+    class ImportMismatchError(ImportError): ...
+
+    sep: Final[str]
+    strpath: Final[str]
+
+    def __init__(self, path: _PathType = ..., expanduser: bool = ...) -> None: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __lt__(self, other: object) -> bool: ...
+    def __gt__(self, other: object) -> bool: ...
+    def __add__(self, other: object) -> local: ...
+    def __cmp__(self, other: object) -> int: ...
+    def __div__(self, other: _PathType) -> local: ...
+    def __truediv__(self, other: _PathType) -> local: ...
+    def __fspath__(self) -> str: ...
+
+    @classmethod
+    def get_temproot(cls) -> local: ...
+    @classmethod
+    def make_numbered_dir(
+        cls,
+        prefix: str = ...,
+        rootdir: Optional[local] = ...,
+        keep: Optional[int] = ...,
+        lock_timeout: int = ...,
+    ) -> local: ...
+    @classmethod
+    def mkdtemp(cls, rootdir: Optional[local] = ...) -> local: ...
+    @classmethod
+    def sysfind(
+        cls,
+        name: _PathType,
+        checker: Optional[Callable[[local], bool]] = ...,
+        paths: Optional[Iterable[_PathType]] = ...,
+    ) -> Optional[local]: ...
+
+    @property
+    def basename(self) -> str: ...
+    @property
+    def dirname(self) -> str: ...
+    @property
+    def purebasename(self) -> str: ...
+    @property
+    def ext(self) -> str: ...
+
+    def as_cwd(self) -> ContextManager[Optional[local]]: ...
+    def atime(self) -> float: ...
+    def bestrelpath(self, dest: local) -> str: ...
+    def chdir(self) -> local: ...
+    def check(
+        self,
+        *,
+        basename: int = ..., notbasename: int = ...,
+        basestarts: int = ..., notbasestarts: int = ...,
+        dir: int = ..., notdir: int = ...,
+        dotfile: int = ..., notdotfile: int = ...,
+        endswith: int = ..., notendswith: int = ...,
+        exists: int = ..., notexists: int = ...,
+        ext: int = ..., notext: int = ...,
+        file: int = ..., notfile: int = ...,
+        fnmatch: int = ..., notfnmatch: int = ...,
+        link: int = ..., notlink: int = ...,
+        relto: int = ..., notrelto: int = ...,
+     ) -> bool: ...
+    def chmod(self, mode: int, rec: Union[int, str, Text, Callable[[local], bool]] = ...) -> None: ...
+    if sys.platform != 'win32':
+        def chown(self, user: Union[int, str], group: Union[int, str], rec: int = ...) -> None: ...
+    def common(self, other: local) -> Optional[local]: ...
+    def computehash(self, hashtype: str = ..., chunksize: int = ...) -> str: ...
+    def copy(self, target: local, mode: bool = ..., stat: bool = ...) -> None: ...
+    def dirpath(self, *args: _PathType, abs: int = ...) -> local: ...
+    def dump(self, obj: Any, bin: Optional[int] = ...) -> None: ...
+    def ensure(self, *args: _PathType, dir: int = ...) -> local: ...
+    def ensure_dir(self, *args: _PathType) -> local: ...
+    def exists(self) -> bool: ...
+    def fnmatch(self, pattern: str): _FNMatcher
+    def isdir(self) -> bool: ...
+    def isfile(self) -> bool: ...
+    def islink(self) -> bool: ...
+    def join(self, *args: _PathType, abs: int = ...) -> local: ...
+    def listdir(
+        self,
+        fil: Optional[Union[str, Text, Callable[[local], bool]]] = ...,
+        sort: Optional[bool] = ...,
+    ) -> List[local]: ...
+    def load(self) -> Any: ...
+    def lstat(self) -> _Stat: ...
+    def mkdir(self, *args: _PathType) -> local: ...
+    if sys.platform != 'win32':
+        def mklinkto(self, oldname: Union[str, local]) -> None: ...
+        def mksymlinkto(self, value: local, absolute: int = ...) -> None: ...
+    def move(self, target: local) -> None: ...
+    def mtime(self) -> float: ...
+    def new(
+        self,
+        *,
+        drive: str = ...,
+        dirname: str = ...,
+        basename: str = ...,
+        purebasename: str = ...,
+        ext: str = ...,
+    ) -> local: ...
+    def open(self, mode: str = ..., ensure: bool = ..., encoding: Optional[str] = ...) -> IO[Any]: ...
+    def parts(self, reverse: bool = ...) -> List[local]: ...
+    def pyimport(
+        self,
+        modname: Optional[str] = ...,
+        ensuresyspath: Union[bool, Literal["append", "importlib"]] = ...,
+    ) -> Any: ...
+    def pypkgpath(self) -> Optional[local]: ...
+    def read(self, mode: str = ...) -> Union[Text, bytes]: ...
+    def read_binary(self) -> bytes: ...
+    def read_text(self, encoding: str) -> Text: ...
+    def readlines(self, cr: int = ...) -> List[str]: ...
+    if sys.platform != 'win32':
+        def readlink(self) -> str: ...
+    def realpath(self) -> local: ...
+    def relto(self, relpath: Union[str, local]) -> str: ...
+    def remove(self, rec: int = ..., ignore_errors: bool = ...) -> None: ...
+    def rename(self, target: _PathType) -> None: ...
+    def samefile(self, other: _PathType) -> bool: ...
+    def setmtime(self, mtime: Optional[float] = ...) -> None: ...
+    def size(self) -> int: ...
+    def stat(self, raising: bool = ...) -> _Stat: ...
+    def sysexec(self, *argv: Any, **popen_opts: Any) -> Text: ...
+    def visit(
+        self,
+        fil: Optional[Union[str, Text, Callable[[local], bool]]] = ...,
+        rec: Optional[Union[Literal[1, True], str, Text, Callable[[local], bool]]] = ...,
+        ignore: Type[Exception] = ...,
+        bf: bool = ...,
+        sort: bool = ...,
+    ) -> Iterator[local]: ...
+    def write(self, data: Any, mode: str = ..., ensure: bool = ...) -> None: ...
+    def write_binary(self, data: bytes, ensure: bool = ...) -> None: ...
+    def write_text(self, data: Union[str, Text], encoding: str, ensure: bool = ...) -> None: ...
+
+
+# Untyped types below here.
+svnwc: Any
+svnurl: Any
+SvnAuth: Any
diff --git a/myenv/lib/python3.9/site-packages/py/py.typed b/myenv/lib/python3.9/site-packages/py/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/py/test.py b/myenv/lib/python3.9/site-packages/py/test.py
new file mode 100644
index 0000000..aa5beb1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/test.py
@@ -0,0 +1,10 @@
+import sys
+if __name__ == '__main__':
+    import pytest
+    sys.exit(pytest.main())
+else:
+    import sys, pytest
+    sys.modules['py.test'] = pytest
+
+# for more API entry points see the 'tests' definition
+# in __init__.py
diff --git a/myenv/lib/python3.9/site-packages/py/xml.pyi b/myenv/lib/python3.9/site-packages/py/xml.pyi
new file mode 100644
index 0000000..9c44480
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/py/xml.pyi
@@ -0,0 +1,25 @@
+from typing import ClassVar, Generic, Iterable, Text, Type, Union
+from typing_extensions import Final
+
+class raw:
+    uniobj: Final[Text]
+    def __init__(self, uniobj: Text) -> None: ...
+
+class _NamespaceMetaclass(type):
+    def __getattr__(self, name: str) -> Type[Tag]: ...
+
+class Namespace(metaclass=_NamespaceMetaclass): ...
+
+class Tag(list):
+    class Attr:
+        def __getattr__(self, attr: str) -> Text: ...
+    attr: Final[Attr]
+    def __init__(self, *args: Union[Text, raw, Tag, Iterable[Tag]], **kwargs: Union[Text, raw]) -> None: ...
+    def unicode(self, indent: int = ...) -> Text: ...
+
+class html(Namespace):
+    class Style:
+        def __init__(self, **kw: Union[str, Text]) -> None: ...
+    style: ClassVar[Style]
+
+def escape(ustring: Union[str, Text]) -> Text: ...
diff --git a/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/LICENSE.rst b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/LICENSE.rst
new file mode 100644
index 0000000..ac630e8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/LICENSE.rst
@@ -0,0 +1,24 @@
+Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.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.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE. 
diff --git a/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/METADATA b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/METADATA
new file mode 100644
index 0000000..d68429d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/METADATA
@@ -0,0 +1,38 @@
+Metadata-Version: 2.1
+Name: pyasn1
+Version: 0.4.8
+Summary: ASN.1 types and codecs
+Home-page: https://github.com/etingof/pyasn1
+Author: Ilya Etingof
+Author-email: etingof@gmail.com
+Maintainer: Ilya Etingof <etingof@gmail.com>
+License: BSD
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.4
+Classifier: Programming Language :: Python :: 2.5
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Topic :: Communications
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+
+Pure-Python implementation of ASN.1 types and DER/BER/CER codecs (X.208)
+
+
diff --git a/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/RECORD b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/RECORD
new file mode 100644
index 0000000..e7bac6a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/RECORD
@@ -0,0 +1,43 @@
+pyasn1/__init__.py,sha256=1Rn8wrJioqfDz7ORFwMehoT15xHOVeiiQD5pZW37D8s,175
+pyasn1/debug.py,sha256=HWGbLlEPLoCNyHqBd1Vd_KK91TppEn3CA4YgUxktT2k,3726
+pyasn1/error.py,sha256=DIn2FWY3ACYNbk_42b3ny2bevkehpK2lOqfAsfdkvBE,2257
+pyasn1/codec/__init__.py,sha256=EEDlJYS172EH39GUidN_8FbkNcWY9OVV8e30AV58pn0,59
+pyasn1/codec/ber/__init__.py,sha256=EEDlJYS172EH39GUidN_8FbkNcWY9OVV8e30AV58pn0,59
+pyasn1/codec/ber/decoder.py,sha256=7-WINr38zVEa3KUkmshh8FjK6QnFaA8Y7j7XaTgYfRk,59708
+pyasn1/codec/ber/encoder.py,sha256=xHl01PCIAiHZXev4x01sjbCgAUKcsTT6SzaLI3nt-9E,27741
+pyasn1/codec/ber/eoo.py,sha256=eZ6lEyHdayMcMmNqtceDIyzf7u5lOeZoRK-WEUxVThI,626
+pyasn1/codec/cer/__init__.py,sha256=EEDlJYS172EH39GUidN_8FbkNcWY9OVV8e30AV58pn0,59
+pyasn1/codec/cer/decoder.py,sha256=ZYBqtDGNiYmKDpKDvioMDf-TYVWoJeZY3I8TEAKuk5s,3745
+pyasn1/codec/cer/encoder.py,sha256=PGtzcIelIHj5d5Yqc5FATMEIWCJybQYFlCaK1gy-NIA,9409
+pyasn1/codec/der/__init__.py,sha256=EEDlJYS172EH39GUidN_8FbkNcWY9OVV8e30AV58pn0,59
+pyasn1/codec/der/decoder.py,sha256=kinXcogMDPGlR3f7hmAxRv2YbQyeP-UhuKM0r8gkbeA,2722
+pyasn1/codec/der/encoder.py,sha256=ZfRRxSCefQyLg0DLNb4zllaYf5_AWGIv3SPzB83Ln2I,3073
+pyasn1/codec/native/__init__.py,sha256=EEDlJYS172EH39GUidN_8FbkNcWY9OVV8e30AV58pn0,59
+pyasn1/codec/native/decoder.py,sha256=4Q29tdKyytK3Oz-m94MSWxxPi_GhcBKvUfvPNKQcL0Y,7671
+pyasn1/codec/native/encoder.py,sha256=0eMLWR49dwMA1X4si0XswR1kX1aDAWyCeUNTpEbChag,8002
+pyasn1/compat/__init__.py,sha256=EEDlJYS172EH39GUidN_8FbkNcWY9OVV8e30AV58pn0,59
+pyasn1/compat/binary.py,sha256=mgWqHmr_SMEdB2WVVr6jyYMnodSbPP6IByE5qKccWLM,698
+pyasn1/compat/calling.py,sha256=uTk3nJtGrElqJi8t34SoO8-eWFBG0gwNhXrlo1YmFEE,379
+pyasn1/compat/dateandtime.py,sha256=zHvXXBp4t3XJ6teg_tz6qgNDevzd93qnrLoEbNxZQ_E,482
+pyasn1/compat/integer.py,sha256=k6tqyxXMC0zJoU-Rz4oUPPoUpTmWXE6Prnzu0tkmmks,2988
+pyasn1/compat/octets.py,sha256=ICe-DVLBIOHmNSz-sp3ioMh--smodJ4VW3Ju0ogJMWA,1359
+pyasn1/compat/string.py,sha256=exqXJmPM6vYj4MjzsjciQdpUcJprRdgrLma8I4UcYHA,505
+pyasn1/type/__init__.py,sha256=EEDlJYS172EH39GUidN_8FbkNcWY9OVV8e30AV58pn0,59
+pyasn1/type/base.py,sha256=TX7qdOX3EPiY7-11MY4fwK2Hy6nQsrdQ_M41aUcApno,22386
+pyasn1/type/char.py,sha256=5HH8r1IqZMDCsfDlQHVCRphLlFuZ93bE2NW78CgeUTI,11397
+pyasn1/type/constraint.py,sha256=0Qsth_0JctnDMvOSe5R-vd9IosgjqkKZT_X9lBRXtuI,22132
+pyasn1/type/error.py,sha256=4_BHdjX-AL5WMTpU-tX1Nfo_P88c2z1sDvqPU-S9Bns,246
+pyasn1/type/namedtype.py,sha256=VIL3H3oPgA0zNrDSeAhKmi4CZGTb69uDBVNJzzRk3wM,16368
+pyasn1/type/namedval.py,sha256=dXYWiVTihvBy4RiebGY3AlIXsJvW78mJ1L7JSw-H7Qw,4886
+pyasn1/type/opentype.py,sha256=pUpnPqv8o4AFeIsmGHDTFfuxXAq7FvG3hrTEnoAgBO8,2848
+pyasn1/type/tag.py,sha256=nAK54C0_F_DL4_IaWRthIfIYBOTuXZoVVcbcbqgZiVA,9486
+pyasn1/type/tagmap.py,sha256=2bwm0hqxG2gvXYheOI_iasfl2Z_B93qU7y39EHteUvs,2998
+pyasn1/type/univ.py,sha256=FXc_VOStZfC-xIVTznpFO0qTq1aO4XyJFU0ayQWgPMY,108921
+pyasn1/type/useful.py,sha256=r_K6UhgcrJ0ej658X-s9522I9T7oYVdmEKcbXTkZMds,5368
+pyasn1-0.4.8.dist-info/LICENSE.rst,sha256=IsXMaSKrXWn7oy2MXuTN0UmBUIy1OvwOvYVZOEf9laU,1334
+pyasn1-0.4.8.dist-info/METADATA,sha256=Mx_DbLo2GA_t9nOIsqu-18vjHdTjMR1LtUzdcfLzE0Y,1521
+pyasn1-0.4.8.dist-info/WHEEL,sha256=8zNYZbwQSXoB9IfXOjPfeNwvAsALAjffgk27FqvCWbo,110
+pyasn1-0.4.8.dist-info/top_level.txt,sha256=dnNEQt3nIDIO5mSCCOB5obQHrjDOUsRycdBujc2vrWE,7
+pyasn1-0.4.8.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pyasn1-0.4.8.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+pyasn1-0.4.8.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/WHEEL
new file mode 100644
index 0000000..8b701e9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.33.6)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/top_level.txt
new file mode 100644
index 0000000..38fe414
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/top_level.txt
@@ -0,0 +1 @@
+pyasn1
diff --git a/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/zip-safe b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/zip-safe
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1-0.4.8.dist-info/zip-safe
@@ -0,0 +1 @@
+
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/__init__.py b/myenv/lib/python3.9/site-packages/pyasn1/__init__.py
new file mode 100644
index 0000000..5a56a70
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/__init__.py
@@ -0,0 +1,7 @@
+import sys
+
+# https://www.python.org/dev/peps/pep-0396/
+__version__ = '0.4.8'
+
+if sys.version_info[:2] < (2, 4):
+    raise RuntimeError('PyASN1 requires Python 2.4 or later')
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/__init__.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/__init__.py
new file mode 100644
index 0000000..8c3066b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/__init__.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/__init__.py
new file mode 100644
index 0000000..8c3066b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/decoder.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/decoder.py
new file mode 100644
index 0000000..5ff485f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/decoder.py
@@ -0,0 +1,1682 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from pyasn1 import debug
+from pyasn1 import error
+from pyasn1.codec.ber import eoo
+from pyasn1.compat.integer import from_bytes
+from pyasn1.compat.octets import oct2int, octs2ints, ints2octs, null
+from pyasn1.type import base
+from pyasn1.type import char
+from pyasn1.type import tag
+from pyasn1.type import tagmap
+from pyasn1.type import univ
+from pyasn1.type import useful
+
+__all__ = ['decode']
+
+LOG = debug.registerLoggee(__name__, flags=debug.DEBUG_DECODER)
+
+noValue = base.noValue
+
+
+class AbstractDecoder(object):
+    protoComponent = None
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+        raise error.PyAsn1Error('Decoder not implemented for %s' % (tagSet,))
+
+    def indefLenValueDecoder(self, substrate, asn1Spec,
+                             tagSet=None, length=None, state=None,
+                             decodeFun=None, substrateFun=None,
+                             **options):
+        raise error.PyAsn1Error('Indefinite length mode decoder not implemented for %s' % (tagSet,))
+
+
+class AbstractSimpleDecoder(AbstractDecoder):
+    @staticmethod
+    def substrateCollector(asn1Object, substrate, length):
+        return substrate[:length], substrate[length:]
+
+    def _createComponent(self, asn1Spec, tagSet, value, **options):
+        if options.get('native'):
+            return value
+        elif asn1Spec is None:
+            return self.protoComponent.clone(value, tagSet=tagSet)
+        elif value is noValue:
+            return asn1Spec
+        else:
+            return asn1Spec.clone(value)
+
+
+class ExplicitTagDecoder(AbstractSimpleDecoder):
+    protoComponent = univ.Any('')
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+        if substrateFun:
+            return substrateFun(
+                self._createComponent(asn1Spec, tagSet, '', **options),
+                substrate, length
+            )
+
+        head, tail = substrate[:length], substrate[length:]
+
+        value, _ = decodeFun(head, asn1Spec, tagSet, length, **options)
+
+        if LOG:
+            LOG('explicit tag container carries %d octets of trailing payload '
+                '(will be lost!): %s' % (len(_), debug.hexdump(_)))
+
+        return value, tail
+
+    def indefLenValueDecoder(self, substrate, asn1Spec,
+                             tagSet=None, length=None, state=None,
+                             decodeFun=None, substrateFun=None,
+                             **options):
+        if substrateFun:
+            return substrateFun(
+                self._createComponent(asn1Spec, tagSet, '', **options),
+                substrate, length
+            )
+
+        value, substrate = decodeFun(substrate, asn1Spec, tagSet, length, **options)
+
+        eooMarker, substrate = decodeFun(substrate, allowEoo=True, **options)
+
+        if eooMarker is eoo.endOfOctets:
+            return value, substrate
+        else:
+            raise error.PyAsn1Error('Missing end-of-octets terminator')
+
+
+explicitTagDecoder = ExplicitTagDecoder()
+
+
+class IntegerDecoder(AbstractSimpleDecoder):
+    protoComponent = univ.Integer(0)
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+
+        if tagSet[0].tagFormat != tag.tagFormatSimple:
+            raise error.PyAsn1Error('Simple tag format expected')
+
+        head, tail = substrate[:length], substrate[length:]
+
+        if not head:
+            return self._createComponent(asn1Spec, tagSet, 0, **options), tail
+
+        value = from_bytes(head, signed=True)
+
+        return self._createComponent(asn1Spec, tagSet, value, **options), tail
+
+
+class BooleanDecoder(IntegerDecoder):
+    protoComponent = univ.Boolean(0)
+
+    def _createComponent(self, asn1Spec, tagSet, value, **options):
+        return IntegerDecoder._createComponent(
+            self, asn1Spec, tagSet, value and 1 or 0, **options)
+
+
+class BitStringDecoder(AbstractSimpleDecoder):
+    protoComponent = univ.BitString(())
+    supportConstructedForm = True
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+        head, tail = substrate[:length], substrate[length:]
+
+        if substrateFun:
+            return substrateFun(self._createComponent(
+                asn1Spec, tagSet, noValue, **options), substrate, length)
+
+        if not head:
+            raise error.PyAsn1Error('Empty BIT STRING substrate')
+
+        if tagSet[0].tagFormat == tag.tagFormatSimple:  # XXX what tag to check?
+
+            trailingBits = oct2int(head[0])
+            if trailingBits > 7:
+                raise error.PyAsn1Error(
+                    'Trailing bits overflow %s' % trailingBits
+                )
+
+            value = self.protoComponent.fromOctetString(
+                head[1:], internalFormat=True, padding=trailingBits)
+
+            return self._createComponent(asn1Spec, tagSet, value, **options), tail
+
+        if not self.supportConstructedForm:
+            raise error.PyAsn1Error('Constructed encoding form prohibited '
+                                    'at %s' % self.__class__.__name__)
+
+        if LOG:
+            LOG('assembling constructed serialization')
+
+        # All inner fragments are of the same type, treat them as octet string
+        substrateFun = self.substrateCollector
+
+        bitString = self.protoComponent.fromOctetString(null, internalFormat=True)
+
+        while head:
+            component, head = decodeFun(head, self.protoComponent,
+                                        substrateFun=substrateFun, **options)
+
+            trailingBits = oct2int(component[0])
+            if trailingBits > 7:
+                raise error.PyAsn1Error(
+                    'Trailing bits overflow %s' % trailingBits
+                )
+
+            bitString = self.protoComponent.fromOctetString(
+                component[1:], internalFormat=True,
+                prepend=bitString, padding=trailingBits
+            )
+
+        return self._createComponent(asn1Spec, tagSet, bitString, **options), tail
+
+    def indefLenValueDecoder(self, substrate, asn1Spec,
+                             tagSet=None, length=None, state=None,
+                             decodeFun=None, substrateFun=None,
+                             **options):
+
+        if substrateFun:
+            return substrateFun(self._createComponent(asn1Spec, tagSet, noValue, **options), substrate, length)
+
+        # All inner fragments are of the same type, treat them as octet string
+        substrateFun = self.substrateCollector
+
+        bitString = self.protoComponent.fromOctetString(null, internalFormat=True)
+
+        while substrate:
+            component, substrate = decodeFun(substrate, self.protoComponent,
+                                             substrateFun=substrateFun,
+                                             allowEoo=True, **options)
+            if component is eoo.endOfOctets:
+                break
+
+            trailingBits = oct2int(component[0])
+            if trailingBits > 7:
+                raise error.PyAsn1Error(
+                    'Trailing bits overflow %s' % trailingBits
+                )
+
+            bitString = self.protoComponent.fromOctetString(
+                component[1:], internalFormat=True,
+                prepend=bitString, padding=trailingBits
+            )
+
+        else:
+            raise error.SubstrateUnderrunError('No EOO seen before substrate ends')
+
+        return self._createComponent(asn1Spec, tagSet, bitString, **options), substrate
+
+
+class OctetStringDecoder(AbstractSimpleDecoder):
+    protoComponent = univ.OctetString('')
+    supportConstructedForm = True
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+        head, tail = substrate[:length], substrate[length:]
+
+        if substrateFun:
+            return substrateFun(self._createComponent(asn1Spec, tagSet, noValue, **options),
+                                substrate, length)
+
+        if tagSet[0].tagFormat == tag.tagFormatSimple:  # XXX what tag to check?
+            return self._createComponent(asn1Spec, tagSet, head, **options), tail
+
+        if not self.supportConstructedForm:
+            raise error.PyAsn1Error('Constructed encoding form prohibited at %s' % self.__class__.__name__)
+
+        if LOG:
+            LOG('assembling constructed serialization')
+
+        # All inner fragments are of the same type, treat them as octet string
+        substrateFun = self.substrateCollector
+
+        header = null
+
+        while head:
+            component, head = decodeFun(head, self.protoComponent,
+                                        substrateFun=substrateFun,
+                                        **options)
+            header += component
+
+        return self._createComponent(asn1Spec, tagSet, header, **options), tail
+
+    def indefLenValueDecoder(self, substrate, asn1Spec,
+                             tagSet=None, length=None, state=None,
+                             decodeFun=None, substrateFun=None,
+                             **options):
+        if substrateFun and substrateFun is not self.substrateCollector:
+            asn1Object = self._createComponent(asn1Spec, tagSet, noValue, **options)
+            return substrateFun(asn1Object, substrate, length)
+
+        # All inner fragments are of the same type, treat them as octet string
+        substrateFun = self.substrateCollector
+
+        header = null
+
+        while substrate:
+            component, substrate = decodeFun(substrate,
+                                             self.protoComponent,
+                                             substrateFun=substrateFun,
+                                             allowEoo=True, **options)
+            if component is eoo.endOfOctets:
+                break
+
+            header += component
+
+        else:
+            raise error.SubstrateUnderrunError(
+                'No EOO seen before substrate ends'
+            )
+
+        return self._createComponent(asn1Spec, tagSet, header, **options), substrate
+
+
+class NullDecoder(AbstractSimpleDecoder):
+    protoComponent = univ.Null('')
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+
+        if tagSet[0].tagFormat != tag.tagFormatSimple:
+            raise error.PyAsn1Error('Simple tag format expected')
+
+        head, tail = substrate[:length], substrate[length:]
+
+        component = self._createComponent(asn1Spec, tagSet, '', **options)
+
+        if head:
+            raise error.PyAsn1Error('Unexpected %d-octet substrate for Null' % length)
+
+        return component, tail
+
+
+class ObjectIdentifierDecoder(AbstractSimpleDecoder):
+    protoComponent = univ.ObjectIdentifier(())
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+        if tagSet[0].tagFormat != tag.tagFormatSimple:
+            raise error.PyAsn1Error('Simple tag format expected')
+
+        head, tail = substrate[:length], substrate[length:]
+        if not head:
+            raise error.PyAsn1Error('Empty substrate')
+
+        head = octs2ints(head)
+
+        oid = ()
+        index = 0
+        substrateLen = len(head)
+        while index < substrateLen:
+            subId = head[index]
+            index += 1
+            if subId < 128:
+                oid += (subId,)
+            elif subId > 128:
+                # Construct subid from a number of octets
+                nextSubId = subId
+                subId = 0
+                while nextSubId >= 128:
+                    subId = (subId << 7) + (nextSubId & 0x7F)
+                    if index >= substrateLen:
+                        raise error.SubstrateUnderrunError(
+                            'Short substrate for sub-OID past %s' % (oid,)
+                        )
+                    nextSubId = head[index]
+                    index += 1
+                oid += ((subId << 7) + nextSubId,)
+            elif subId == 128:
+                # ASN.1 spec forbids leading zeros (0x80) in OID
+                # encoding, tolerating it opens a vulnerability. See
+                # https://www.esat.kuleuven.be/cosic/publications/article-1432.pdf
+                # page 7
+                raise error.PyAsn1Error('Invalid octet 0x80 in OID encoding')
+
+        # Decode two leading arcs
+        if 0 <= oid[0] <= 39:
+            oid = (0,) + oid
+        elif 40 <= oid[0] <= 79:
+            oid = (1, oid[0] - 40) + oid[1:]
+        elif oid[0] >= 80:
+            oid = (2, oid[0] - 80) + oid[1:]
+        else:
+            raise error.PyAsn1Error('Malformed first OID octet: %s' % head[0])
+
+        return self._createComponent(asn1Spec, tagSet, oid, **options), tail
+
+
+class RealDecoder(AbstractSimpleDecoder):
+    protoComponent = univ.Real()
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+        if tagSet[0].tagFormat != tag.tagFormatSimple:
+            raise error.PyAsn1Error('Simple tag format expected')
+
+        head, tail = substrate[:length], substrate[length:]
+
+        if not head:
+            return self._createComponent(asn1Spec, tagSet, 0.0, **options), tail
+
+        fo = oct2int(head[0])
+        head = head[1:]
+        if fo & 0x80:  # binary encoding
+            if not head:
+                raise error.PyAsn1Error("Incomplete floating-point value")
+
+            if LOG:
+                LOG('decoding binary encoded REAL')
+
+            n = (fo & 0x03) + 1
+
+            if n == 4:
+                n = oct2int(head[0])
+                head = head[1:]
+
+            eo, head = head[:n], head[n:]
+
+            if not eo or not head:
+                raise error.PyAsn1Error('Real exponent screwed')
+
+            e = oct2int(eo[0]) & 0x80 and -1 or 0
+
+            while eo:  # exponent
+                e <<= 8
+                e |= oct2int(eo[0])
+                eo = eo[1:]
+
+            b = fo >> 4 & 0x03  # base bits
+
+            if b > 2:
+                raise error.PyAsn1Error('Illegal Real base')
+
+            if b == 1:  # encbase = 8
+                e *= 3
+
+            elif b == 2:  # encbase = 16
+                e *= 4
+            p = 0
+
+            while head:  # value
+                p <<= 8
+                p |= oct2int(head[0])
+                head = head[1:]
+
+            if fo & 0x40:  # sign bit
+                p = -p
+
+            sf = fo >> 2 & 0x03  # scale bits
+            p *= 2 ** sf
+            value = (p, 2, e)
+
+        elif fo & 0x40:  # infinite value
+            if LOG:
+                LOG('decoding infinite REAL')
+
+            value = fo & 0x01 and '-inf' or 'inf'
+
+        elif fo & 0xc0 == 0:  # character encoding
+            if not head:
+                raise error.PyAsn1Error("Incomplete floating-point value")
+
+            if LOG:
+                LOG('decoding character encoded REAL')
+
+            try:
+                if fo & 0x3 == 0x1:  # NR1
+                    value = (int(head), 10, 0)
+
+                elif fo & 0x3 == 0x2:  # NR2
+                    value = float(head)
+
+                elif fo & 0x3 == 0x3:  # NR3
+                    value = float(head)
+
+                else:
+                    raise error.SubstrateUnderrunError(
+                        'Unknown NR (tag %s)' % fo
+                    )
+
+            except ValueError:
+                raise error.SubstrateUnderrunError(
+                    'Bad character Real syntax'
+                )
+
+        else:
+            raise error.SubstrateUnderrunError(
+                'Unknown encoding (tag %s)' % fo
+            )
+
+        return self._createComponent(asn1Spec, tagSet, value, **options), tail
+
+
+class AbstractConstructedDecoder(AbstractDecoder):
+    protoComponent = None
+
+
+class UniversalConstructedTypeDecoder(AbstractConstructedDecoder):
+    protoRecordComponent = None
+    protoSequenceComponent = None
+
+    def _getComponentTagMap(self, asn1Object, idx):
+        raise NotImplementedError()
+
+    def _getComponentPositionByType(self, asn1Object, tagSet, idx):
+        raise NotImplementedError()
+
+    def _decodeComponents(self, substrate, tagSet=None, decodeFun=None, **options):
+        components = []
+        componentTypes = set()
+
+        while substrate:
+            component, substrate = decodeFun(substrate, **options)
+            if component is eoo.endOfOctets:
+                break
+
+            components.append(component)
+            componentTypes.add(component.tagSet)
+
+        # Now we have to guess is it SEQUENCE/SET or SEQUENCE OF/SET OF
+        # The heuristics is:
+        # * 1+ components of different types -> likely SEQUENCE/SET
+        # * otherwise -> likely SEQUENCE OF/SET OF
+        if len(componentTypes) > 1:
+            protoComponent = self.protoRecordComponent
+
+        else:
+            protoComponent = self.protoSequenceComponent
+
+        asn1Object = protoComponent.clone(
+            # construct tagSet from base tag from prototype ASN.1 object
+            # and additional tags recovered from the substrate
+            tagSet=tag.TagSet(protoComponent.tagSet.baseTag, *tagSet.superTags)
+        )
+
+        if LOG:
+            LOG('guessed %r container type (pass `asn1Spec` to guide the '
+                'decoder)' % asn1Object)
+
+        for idx, component in enumerate(components):
+            asn1Object.setComponentByPosition(
+                idx, component,
+                verifyConstraints=False,
+                matchTags=False, matchConstraints=False
+            )
+
+        return asn1Object, substrate
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+        if tagSet[0].tagFormat != tag.tagFormatConstructed:
+            raise error.PyAsn1Error('Constructed tag format expected')
+
+        head, tail = substrate[:length], substrate[length:]
+
+        if substrateFun is not None:
+            if asn1Spec is not None:
+                asn1Object = asn1Spec.clone()
+
+            elif self.protoComponent is not None:
+                asn1Object = self.protoComponent.clone(tagSet=tagSet)
+
+            else:
+                asn1Object = self.protoRecordComponent, self.protoSequenceComponent
+
+            return substrateFun(asn1Object, substrate, length)
+
+        if asn1Spec is None:
+            asn1Object, trailing = self._decodeComponents(
+                head, tagSet=tagSet, decodeFun=decodeFun, **options
+            )
+
+            if trailing:
+                if LOG:
+                    LOG('Unused trailing %d octets encountered: %s' % (
+                        len(trailing), debug.hexdump(trailing)))
+
+            return asn1Object, tail
+
+        asn1Object = asn1Spec.clone()
+        asn1Object.clear()
+
+        if asn1Spec.typeId in (univ.Sequence.typeId, univ.Set.typeId):
+
+            namedTypes = asn1Spec.componentType
+
+            isSetType = asn1Spec.typeId == univ.Set.typeId
+            isDeterministic = not isSetType and not namedTypes.hasOptionalOrDefault
+
+            if LOG:
+                LOG('decoding %sdeterministic %s type %r chosen by type ID' % (
+                    not isDeterministic and 'non-' or '', isSetType and 'SET' or '',
+                    asn1Spec))
+
+            seenIndices = set()
+            idx = 0
+            while head:
+                if not namedTypes:
+                    componentType = None
+
+                elif isSetType:
+                    componentType = namedTypes.tagMapUnique
+
+                else:
+                    try:
+                        if isDeterministic:
+                            componentType = namedTypes[idx].asn1Object
+
+                        elif namedTypes[idx].isOptional or namedTypes[idx].isDefaulted:
+                            componentType = namedTypes.getTagMapNearPosition(idx)
+
+                        else:
+                            componentType = namedTypes[idx].asn1Object
+
+                    except IndexError:
+                        raise error.PyAsn1Error(
+                            'Excessive components decoded at %r' % (asn1Spec,)
+                        )
+
+                component, head = decodeFun(head, componentType, **options)
+
+                if not isDeterministic and namedTypes:
+                    if isSetType:
+                        idx = namedTypes.getPositionByType(component.effectiveTagSet)
+
+                    elif namedTypes[idx].isOptional or namedTypes[idx].isDefaulted:
+                        idx = namedTypes.getPositionNearType(component.effectiveTagSet, idx)
+
+                asn1Object.setComponentByPosition(
+                    idx, component,
+                    verifyConstraints=False,
+                    matchTags=False, matchConstraints=False
+                )
+
+                seenIndices.add(idx)
+                idx += 1
+
+            if LOG:
+                LOG('seen component indices %s' % seenIndices)
+
+            if namedTypes:
+                if not namedTypes.requiredComponents.issubset(seenIndices):
+                    raise error.PyAsn1Error(
+                        'ASN.1 object %s has uninitialized '
+                        'components' % asn1Object.__class__.__name__)
+
+                if  namedTypes.hasOpenTypes:
+
+                    openTypes = options.get('openTypes', {})
+
+                    if LOG:
+                        LOG('user-specified open types map:')
+
+                        for k, v in openTypes.items():
+                            LOG('%s -> %r' % (k, v))
+
+                    if openTypes or options.get('decodeOpenTypes', False):
+
+                        for idx, namedType in enumerate(namedTypes.namedTypes):
+                            if not namedType.openType:
+                                continue
+
+                            if namedType.isOptional and not asn1Object.getComponentByPosition(idx).isValue:
+                                continue
+
+                            governingValue = asn1Object.getComponentByName(
+                                namedType.openType.name
+                            )
+
+                            try:
+                                openType = openTypes[governingValue]
+
+                            except KeyError:
+
+                                if LOG:
+                                    LOG('default open types map of component '
+                                        '"%s.%s" governed by component "%s.%s"'
+                                        ':' % (asn1Object.__class__.__name__,
+                                               namedType.name,
+                                               asn1Object.__class__.__name__,
+                                               namedType.openType.name))
+
+                                    for k, v in namedType.openType.items():
+                                        LOG('%s -> %r' % (k, v))
+
+                                try:
+                                    openType = namedType.openType[governingValue]
+
+                                except KeyError:
+                                    if LOG:
+                                        LOG('failed to resolve open type by governing '
+                                            'value %r' % (governingValue,))
+                                    continue
+
+                            if LOG:
+                                LOG('resolved open type %r by governing '
+                                    'value %r' % (openType, governingValue))
+
+                            containerValue = asn1Object.getComponentByPosition(idx)
+
+                            if containerValue.typeId in (
+                                    univ.SetOf.typeId, univ.SequenceOf.typeId):
+
+                                for pos, containerElement in enumerate(
+                                        containerValue):
+
+                                    component, rest = decodeFun(
+                                        containerValue[pos].asOctets(),
+                                        asn1Spec=openType, **options
+                                    )
+
+                                    containerValue[pos] = component
+
+                            else:
+                                component, rest = decodeFun(
+                                    asn1Object.getComponentByPosition(idx).asOctets(),
+                                    asn1Spec=openType, **options
+                                )
+
+                                asn1Object.setComponentByPosition(idx, component)
+
+            else:
+                inconsistency = asn1Object.isInconsistent
+                if inconsistency:
+                    raise inconsistency
+
+        else:
+            asn1Object = asn1Spec.clone()
+            asn1Object.clear()
+
+            componentType = asn1Spec.componentType
+
+            if LOG:
+                LOG('decoding type %r chosen by given `asn1Spec`' % componentType)
+
+            idx = 0
+
+            while head:
+                component, head = decodeFun(head, componentType, **options)
+                asn1Object.setComponentByPosition(
+                    idx, component,
+                    verifyConstraints=False,
+                    matchTags=False, matchConstraints=False
+                )
+
+                idx += 1
+
+        return asn1Object, tail
+
+    def indefLenValueDecoder(self, substrate, asn1Spec,
+                             tagSet=None, length=None, state=None,
+                             decodeFun=None, substrateFun=None,
+                             **options):
+        if tagSet[0].tagFormat != tag.tagFormatConstructed:
+            raise error.PyAsn1Error('Constructed tag format expected')
+
+        if substrateFun is not None:
+            if asn1Spec is not None:
+                asn1Object = asn1Spec.clone()
+
+            elif self.protoComponent is not None:
+                asn1Object = self.protoComponent.clone(tagSet=tagSet)
+
+            else:
+                asn1Object = self.protoRecordComponent, self.protoSequenceComponent
+
+            return substrateFun(asn1Object, substrate, length)
+
+        if asn1Spec is None:
+            return self._decodeComponents(
+                substrate, tagSet=tagSet, decodeFun=decodeFun,
+                **dict(options, allowEoo=True)
+            )
+
+        asn1Object = asn1Spec.clone()
+        asn1Object.clear()
+
+        if asn1Spec.typeId in (univ.Sequence.typeId, univ.Set.typeId):
+
+            namedTypes = asn1Object.componentType
+
+            isSetType = asn1Object.typeId == univ.Set.typeId
+            isDeterministic = not isSetType and not namedTypes.hasOptionalOrDefault
+
+            if LOG:
+                LOG('decoding %sdeterministic %s type %r chosen by type ID' % (
+                    not isDeterministic and 'non-' or '', isSetType and 'SET' or '',
+                    asn1Spec))
+
+            seenIndices = set()
+            idx = 0
+            while substrate:
+                if len(namedTypes) <= idx:
+                    asn1Spec = None
+
+                elif isSetType:
+                    asn1Spec = namedTypes.tagMapUnique
+
+                else:
+                    try:
+                        if isDeterministic:
+                            asn1Spec = namedTypes[idx].asn1Object
+
+                        elif namedTypes[idx].isOptional or namedTypes[idx].isDefaulted:
+                            asn1Spec = namedTypes.getTagMapNearPosition(idx)
+
+                        else:
+                            asn1Spec = namedTypes[idx].asn1Object
+
+                    except IndexError:
+                        raise error.PyAsn1Error(
+                            'Excessive components decoded at %r' % (asn1Object,)
+                        )
+
+                component, substrate = decodeFun(substrate, asn1Spec, allowEoo=True, **options)
+                if component is eoo.endOfOctets:
+                    break
+
+                if not isDeterministic and namedTypes:
+                    if isSetType:
+                        idx = namedTypes.getPositionByType(component.effectiveTagSet)
+                    elif namedTypes[idx].isOptional or namedTypes[idx].isDefaulted:
+                        idx = namedTypes.getPositionNearType(component.effectiveTagSet, idx)
+
+                asn1Object.setComponentByPosition(
+                    idx, component,
+                    verifyConstraints=False,
+                    matchTags=False, matchConstraints=False
+                )
+
+                seenIndices.add(idx)
+                idx += 1
+
+            else:
+                raise error.SubstrateUnderrunError(
+                    'No EOO seen before substrate ends'
+                )
+
+            if LOG:
+                LOG('seen component indices %s' % seenIndices)
+
+            if namedTypes:
+                if not namedTypes.requiredComponents.issubset(seenIndices):
+                    raise error.PyAsn1Error('ASN.1 object %s has uninitialized components' % asn1Object.__class__.__name__)
+
+                if namedTypes.hasOpenTypes:
+
+                    openTypes = options.get('openTypes', {})
+
+                    if LOG:
+                        LOG('user-specified open types map:')
+
+                        for k, v in openTypes.items():
+                            LOG('%s -> %r' % (k, v))
+
+                    if openTypes or options.get('decodeOpenTypes', False):
+
+                        for idx, namedType in enumerate(namedTypes.namedTypes):
+                            if not namedType.openType:
+                                continue
+
+                            if namedType.isOptional and not asn1Object.getComponentByPosition(idx).isValue:
+                                continue
+
+                            governingValue = asn1Object.getComponentByName(
+                                namedType.openType.name
+                            )
+
+                            try:
+                                openType = openTypes[governingValue]
+
+                            except KeyError:
+
+                                if LOG:
+                                    LOG('default open types map of component '
+                                        '"%s.%s" governed by component "%s.%s"'
+                                        ':' % (asn1Object.__class__.__name__,
+                                               namedType.name,
+                                               asn1Object.__class__.__name__,
+                                               namedType.openType.name))
+
+                                    for k, v in namedType.openType.items():
+                                        LOG('%s -> %r' % (k, v))
+
+                                try:
+                                    openType = namedType.openType[governingValue]
+
+                                except KeyError:
+                                    if LOG:
+                                        LOG('failed to resolve open type by governing '
+                                            'value %r' % (governingValue,))
+                                    continue
+
+                            if LOG:
+                                LOG('resolved open type %r by governing '
+                                    'value %r' % (openType, governingValue))
+
+                            containerValue = asn1Object.getComponentByPosition(idx)
+
+                            if containerValue.typeId in (
+                                    univ.SetOf.typeId, univ.SequenceOf.typeId):
+
+                                for pos, containerElement in enumerate(
+                                        containerValue):
+
+                                    component, rest = decodeFun(
+                                        containerValue[pos].asOctets(),
+                                        asn1Spec=openType, **dict(options, allowEoo=True)
+                                    )
+
+                                    containerValue[pos] = component
+
+                            else:
+                                component, rest = decodeFun(
+                                    asn1Object.getComponentByPosition(idx).asOctets(),
+                                    asn1Spec=openType, **dict(options, allowEoo=True)
+                                )
+
+                                if component is not eoo.endOfOctets:
+                                    asn1Object.setComponentByPosition(idx, component)
+
+                else:
+                    inconsistency = asn1Object.isInconsistent
+                    if inconsistency:
+                        raise inconsistency
+
+        else:
+            asn1Object = asn1Spec.clone()
+            asn1Object.clear()
+
+            componentType = asn1Spec.componentType
+
+            if LOG:
+                LOG('decoding type %r chosen by given `asn1Spec`' % componentType)
+
+            idx = 0
+
+            while substrate:
+                component, substrate = decodeFun(substrate, componentType, allowEoo=True, **options)
+
+                if component is eoo.endOfOctets:
+                    break
+
+                asn1Object.setComponentByPosition(
+                    idx, component,
+                    verifyConstraints=False,
+                    matchTags=False, matchConstraints=False
+                )
+
+                idx += 1
+
+            else:
+                raise error.SubstrateUnderrunError(
+                    'No EOO seen before substrate ends'
+                )
+
+        return asn1Object, substrate
+
+
+class SequenceOrSequenceOfDecoder(UniversalConstructedTypeDecoder):
+    protoRecordComponent = univ.Sequence()
+    protoSequenceComponent = univ.SequenceOf()
+
+
+class SequenceDecoder(SequenceOrSequenceOfDecoder):
+    protoComponent = univ.Sequence()
+
+
+class SequenceOfDecoder(SequenceOrSequenceOfDecoder):
+    protoComponent = univ.SequenceOf()
+
+
+class SetOrSetOfDecoder(UniversalConstructedTypeDecoder):
+    protoRecordComponent = univ.Set()
+    protoSequenceComponent = univ.SetOf()
+
+
+class SetDecoder(SetOrSetOfDecoder):
+    protoComponent = univ.Set()
+
+
+
+class SetOfDecoder(SetOrSetOfDecoder):
+    protoComponent = univ.SetOf()
+
+
+class ChoiceDecoder(AbstractConstructedDecoder):
+    protoComponent = univ.Choice()
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+        head, tail = substrate[:length], substrate[length:]
+
+        if asn1Spec is None:
+            asn1Object = self.protoComponent.clone(tagSet=tagSet)
+
+        else:
+            asn1Object = asn1Spec.clone()
+
+        if substrateFun:
+            return substrateFun(asn1Object, substrate, length)
+
+        if asn1Object.tagSet == tagSet:
+            if LOG:
+                LOG('decoding %s as explicitly tagged CHOICE' % (tagSet,))
+
+            component, head = decodeFun(
+                head, asn1Object.componentTagMap, **options
+            )
+
+        else:
+            if LOG:
+                LOG('decoding %s as untagged CHOICE' % (tagSet,))
+
+            component, head = decodeFun(
+                head, asn1Object.componentTagMap,
+                tagSet, length, state, **options
+            )
+
+        effectiveTagSet = component.effectiveTagSet
+
+        if LOG:
+            LOG('decoded component %s, effective tag set %s' % (component, effectiveTagSet))
+
+        asn1Object.setComponentByType(
+            effectiveTagSet, component,
+            verifyConstraints=False,
+            matchTags=False, matchConstraints=False,
+            innerFlag=False
+        )
+
+        return asn1Object, tail
+
+    def indefLenValueDecoder(self, substrate, asn1Spec,
+                             tagSet=None, length=None, state=None,
+                             decodeFun=None, substrateFun=None,
+                             **options):
+        if asn1Spec is None:
+            asn1Object = self.protoComponent.clone(tagSet=tagSet)
+        else:
+            asn1Object = asn1Spec.clone()
+
+        if substrateFun:
+            return substrateFun(asn1Object, substrate, length)
+
+        if asn1Object.tagSet == tagSet:
+            if LOG:
+                LOG('decoding %s as explicitly tagged CHOICE' % (tagSet,))
+
+            component, substrate = decodeFun(
+                substrate, asn1Object.componentType.tagMapUnique, **options
+            )
+
+            # eat up EOO marker
+            eooMarker, substrate = decodeFun(
+                substrate, allowEoo=True, **options
+            )
+
+            if eooMarker is not eoo.endOfOctets:
+                raise error.PyAsn1Error('No EOO seen before substrate ends')
+
+        else:
+            if LOG:
+                LOG('decoding %s as untagged CHOICE' % (tagSet,))
+
+            component, substrate = decodeFun(
+                substrate, asn1Object.componentType.tagMapUnique,
+                tagSet, length, state, **options
+            )
+
+        effectiveTagSet = component.effectiveTagSet
+
+        if LOG:
+            LOG('decoded component %s, effective tag set %s' % (component, effectiveTagSet))
+
+        asn1Object.setComponentByType(
+            effectiveTagSet, component,
+            verifyConstraints=False,
+            matchTags=False, matchConstraints=False,
+            innerFlag=False
+        )
+
+        return asn1Object, substrate
+
+
+class AnyDecoder(AbstractSimpleDecoder):
+    protoComponent = univ.Any()
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+        if asn1Spec is None:
+            isUntagged = True
+
+        elif asn1Spec.__class__ is tagmap.TagMap:
+            isUntagged = tagSet not in asn1Spec.tagMap
+
+        else:
+            isUntagged = tagSet != asn1Spec.tagSet
+
+        if isUntagged:
+            fullSubstrate = options['fullSubstrate']
+
+            # untagged Any container, recover inner header substrate
+            length += len(fullSubstrate) - len(substrate)
+            substrate = fullSubstrate
+
+            if LOG:
+                LOG('decoding as untagged ANY, substrate %s' % debug.hexdump(substrate))
+
+        if substrateFun:
+            return substrateFun(self._createComponent(asn1Spec, tagSet, noValue, **options),
+                                substrate, length)
+
+        head, tail = substrate[:length], substrate[length:]
+
+        return self._createComponent(asn1Spec, tagSet, head, **options), tail
+
+    def indefLenValueDecoder(self, substrate, asn1Spec,
+                             tagSet=None, length=None, state=None,
+                             decodeFun=None, substrateFun=None,
+                             **options):
+        if asn1Spec is None:
+            isTagged = False
+
+        elif asn1Spec.__class__ is tagmap.TagMap:
+            isTagged = tagSet in asn1Spec.tagMap
+
+        else:
+            isTagged = tagSet == asn1Spec.tagSet
+
+        if isTagged:
+            # tagged Any type -- consume header substrate
+            header = null
+
+            if LOG:
+                LOG('decoding as tagged ANY')
+
+        else:
+            fullSubstrate = options['fullSubstrate']
+
+            # untagged Any, recover header substrate
+            header = fullSubstrate[:-len(substrate)]
+
+            if LOG:
+                LOG('decoding as untagged ANY, header substrate %s' % debug.hexdump(header))
+
+        # Any components do not inherit initial tag
+        asn1Spec = self.protoComponent
+
+        if substrateFun and substrateFun is not self.substrateCollector:
+            asn1Object = self._createComponent(asn1Spec, tagSet, noValue, **options)
+            return substrateFun(asn1Object, header + substrate, length + len(header))
+
+        if LOG:
+            LOG('assembling constructed serialization')
+
+        # All inner fragments are of the same type, treat them as octet string
+        substrateFun = self.substrateCollector
+
+        while substrate:
+            component, substrate = decodeFun(substrate, asn1Spec,
+                                             substrateFun=substrateFun,
+                                             allowEoo=True, **options)
+            if component is eoo.endOfOctets:
+                break
+
+            header += component
+
+        else:
+            raise error.SubstrateUnderrunError(
+                'No EOO seen before substrate ends'
+            )
+
+        if substrateFun:
+            return header, substrate
+
+        else:
+            return self._createComponent(asn1Spec, tagSet, header, **options), substrate
+
+
+# character string types
+class UTF8StringDecoder(OctetStringDecoder):
+    protoComponent = char.UTF8String()
+
+
+class NumericStringDecoder(OctetStringDecoder):
+    protoComponent = char.NumericString()
+
+
+class PrintableStringDecoder(OctetStringDecoder):
+    protoComponent = char.PrintableString()
+
+
+class TeletexStringDecoder(OctetStringDecoder):
+    protoComponent = char.TeletexString()
+
+
+class VideotexStringDecoder(OctetStringDecoder):
+    protoComponent = char.VideotexString()
+
+
+class IA5StringDecoder(OctetStringDecoder):
+    protoComponent = char.IA5String()
+
+
+class GraphicStringDecoder(OctetStringDecoder):
+    protoComponent = char.GraphicString()
+
+
+class VisibleStringDecoder(OctetStringDecoder):
+    protoComponent = char.VisibleString()
+
+
+class GeneralStringDecoder(OctetStringDecoder):
+    protoComponent = char.GeneralString()
+
+
+class UniversalStringDecoder(OctetStringDecoder):
+    protoComponent = char.UniversalString()
+
+
+class BMPStringDecoder(OctetStringDecoder):
+    protoComponent = char.BMPString()
+
+
+# "useful" types
+class ObjectDescriptorDecoder(OctetStringDecoder):
+    protoComponent = useful.ObjectDescriptor()
+
+
+class GeneralizedTimeDecoder(OctetStringDecoder):
+    protoComponent = useful.GeneralizedTime()
+
+
+class UTCTimeDecoder(OctetStringDecoder):
+    protoComponent = useful.UTCTime()
+
+
+tagMap = {
+    univ.Integer.tagSet: IntegerDecoder(),
+    univ.Boolean.tagSet: BooleanDecoder(),
+    univ.BitString.tagSet: BitStringDecoder(),
+    univ.OctetString.tagSet: OctetStringDecoder(),
+    univ.Null.tagSet: NullDecoder(),
+    univ.ObjectIdentifier.tagSet: ObjectIdentifierDecoder(),
+    univ.Enumerated.tagSet: IntegerDecoder(),
+    univ.Real.tagSet: RealDecoder(),
+    univ.Sequence.tagSet: SequenceOrSequenceOfDecoder(),  # conflicts with SequenceOf
+    univ.Set.tagSet: SetOrSetOfDecoder(),  # conflicts with SetOf
+    univ.Choice.tagSet: ChoiceDecoder(),  # conflicts with Any
+    # character string types
+    char.UTF8String.tagSet: UTF8StringDecoder(),
+    char.NumericString.tagSet: NumericStringDecoder(),
+    char.PrintableString.tagSet: PrintableStringDecoder(),
+    char.TeletexString.tagSet: TeletexStringDecoder(),
+    char.VideotexString.tagSet: VideotexStringDecoder(),
+    char.IA5String.tagSet: IA5StringDecoder(),
+    char.GraphicString.tagSet: GraphicStringDecoder(),
+    char.VisibleString.tagSet: VisibleStringDecoder(),
+    char.GeneralString.tagSet: GeneralStringDecoder(),
+    char.UniversalString.tagSet: UniversalStringDecoder(),
+    char.BMPString.tagSet: BMPStringDecoder(),
+    # useful types
+    useful.ObjectDescriptor.tagSet: ObjectDescriptorDecoder(),
+    useful.GeneralizedTime.tagSet: GeneralizedTimeDecoder(),
+    useful.UTCTime.tagSet: UTCTimeDecoder()
+}
+
+# Type-to-codec map for ambiguous ASN.1 types
+typeMap = {
+    univ.Set.typeId: SetDecoder(),
+    univ.SetOf.typeId: SetOfDecoder(),
+    univ.Sequence.typeId: SequenceDecoder(),
+    univ.SequenceOf.typeId: SequenceOfDecoder(),
+    univ.Choice.typeId: ChoiceDecoder(),
+    univ.Any.typeId: AnyDecoder()
+}
+
+# Put in non-ambiguous types for faster codec lookup
+for typeDecoder in tagMap.values():
+    if typeDecoder.protoComponent is not None:
+        typeId = typeDecoder.protoComponent.__class__.typeId
+        if typeId is not None and typeId not in typeMap:
+            typeMap[typeId] = typeDecoder
+
+
+(stDecodeTag,
+ stDecodeLength,
+ stGetValueDecoder,
+ stGetValueDecoderByAsn1Spec,
+ stGetValueDecoderByTag,
+ stTryAsExplicitTag,
+ stDecodeValue,
+ stDumpRawValue,
+ stErrorCondition,
+ stStop) = [x for x in range(10)]
+
+
+class Decoder(object):
+    defaultErrorState = stErrorCondition
+    #defaultErrorState = stDumpRawValue
+    defaultRawDecoder = AnyDecoder()
+    supportIndefLength = True
+
+    # noinspection PyDefaultArgument
+    def __init__(self, tagMap, typeMap={}):
+        self.__tagMap = tagMap
+        self.__typeMap = typeMap
+        # Tag & TagSet objects caches
+        self.__tagCache = {}
+        self.__tagSetCache = {}
+        self.__eooSentinel = ints2octs((0, 0))
+
+    def __call__(self, substrate, asn1Spec=None,
+                 tagSet=None, length=None, state=stDecodeTag,
+                 decodeFun=None, substrateFun=None,
+                 **options):
+
+        if LOG:
+            LOG('decoder called at scope %s with state %d, working with up to %d octets of substrate: %s' % (debug.scope, state, len(substrate), debug.hexdump(substrate)))
+
+        allowEoo = options.pop('allowEoo', False)
+
+        # Look for end-of-octets sentinel
+        if allowEoo and self.supportIndefLength:
+            if substrate[:2] == self.__eooSentinel:
+                if LOG:
+                    LOG('end-of-octets sentinel found')
+                return eoo.endOfOctets, substrate[2:]
+
+        value = noValue
+
+        tagMap = self.__tagMap
+        typeMap = self.__typeMap
+        tagCache = self.__tagCache
+        tagSetCache = self.__tagSetCache
+
+        fullSubstrate = substrate
+
+        while state is not stStop:
+
+            if state is stDecodeTag:
+                if not substrate:
+                    raise error.SubstrateUnderrunError(
+                        'Short octet stream on tag decoding'
+                    )
+
+                # Decode tag
+                isShortTag = True
+                firstOctet = substrate[0]
+                substrate = substrate[1:]
+
+                try:
+                    lastTag = tagCache[firstOctet]
+
+                except KeyError:
+                    integerTag = oct2int(firstOctet)
+                    tagClass = integerTag & 0xC0
+                    tagFormat = integerTag & 0x20
+                    tagId = integerTag & 0x1F
+
+                    if tagId == 0x1F:
+                        isShortTag = False
+                        lengthOctetIdx = 0
+                        tagId = 0
+
+                        try:
+                            while True:
+                                integerTag = oct2int(substrate[lengthOctetIdx])
+                                lengthOctetIdx += 1
+                                tagId <<= 7
+                                tagId |= (integerTag & 0x7F)
+                                if not integerTag & 0x80:
+                                    break
+
+                            substrate = substrate[lengthOctetIdx:]
+
+                        except IndexError:
+                            raise error.SubstrateUnderrunError(
+                                'Short octet stream on long tag decoding'
+                            )
+
+                    lastTag = tag.Tag(
+                        tagClass=tagClass, tagFormat=tagFormat, tagId=tagId
+                    )
+
+                    if isShortTag:
+                        # cache short tags
+                        tagCache[firstOctet] = lastTag
+
+                if tagSet is None:
+                    if isShortTag:
+                        try:
+                            tagSet = tagSetCache[firstOctet]
+
+                        except KeyError:
+                            # base tag not recovered
+                            tagSet = tag.TagSet((), lastTag)
+                            tagSetCache[firstOctet] = tagSet
+                    else:
+                        tagSet = tag.TagSet((), lastTag)
+
+                else:
+                    tagSet = lastTag + tagSet
+
+                state = stDecodeLength
+
+                if LOG:
+                    LOG('tag decoded into %s, decoding length' % tagSet)
+
+            if state is stDecodeLength:
+                # Decode length
+                if not substrate:
+                    raise error.SubstrateUnderrunError(
+                        'Short octet stream on length decoding'
+                    )
+
+                firstOctet = oct2int(substrate[0])
+
+                if firstOctet < 128:
+                    size = 1
+                    length = firstOctet
+
+                elif firstOctet > 128:
+                    size = firstOctet & 0x7F
+                    # encoded in size bytes
+                    encodedLength = octs2ints(substrate[1:size + 1])
+                    # missing check on maximum size, which shouldn't be a
+                    # problem, we can handle more than is possible
+                    if len(encodedLength) != size:
+                        raise error.SubstrateUnderrunError(
+                            '%s<%s at %s' % (size, len(encodedLength), tagSet)
+                        )
+
+                    length = 0
+                    for lengthOctet in encodedLength:
+                        length <<= 8
+                        length |= lengthOctet
+                    size += 1
+
+                else:
+                    size = 1
+                    length = -1
+
+                substrate = substrate[size:]
+
+                if length == -1:
+                    if not self.supportIndefLength:
+                        raise error.PyAsn1Error('Indefinite length encoding not supported by this codec')
+
+                else:
+                    if len(substrate) < length:
+                        raise error.SubstrateUnderrunError('%d-octet short' % (length - len(substrate)))
+
+                state = stGetValueDecoder
+
+                if LOG:
+                    LOG('value length decoded into %d, payload substrate is: %s' % (length, debug.hexdump(length == -1 and substrate or substrate[:length])))
+
+            if state is stGetValueDecoder:
+                if asn1Spec is None:
+                    state = stGetValueDecoderByTag
+
+                else:
+                    state = stGetValueDecoderByAsn1Spec
+            #
+            # There're two ways of creating subtypes in ASN.1 what influences
+            # decoder operation. These methods are:
+            # 1) Either base types used in or no IMPLICIT tagging has been
+            #    applied on subtyping.
+            # 2) Subtype syntax drops base type information (by means of
+            #    IMPLICIT tagging.
+            # The first case allows for complete tag recovery from substrate
+            # while the second one requires original ASN.1 type spec for
+            # decoding.
+            #
+            # In either case a set of tags (tagSet) is coming from substrate
+            # in an incremental, tag-by-tag fashion (this is the case of
+            # EXPLICIT tag which is most basic). Outermost tag comes first
+            # from the wire.
+            #
+            if state is stGetValueDecoderByTag:
+                try:
+                    concreteDecoder = tagMap[tagSet]
+
+                except KeyError:
+                    concreteDecoder = None
+
+                if concreteDecoder:
+                    state = stDecodeValue
+
+                else:
+                    try:
+                        concreteDecoder = tagMap[tagSet[:1]]
+
+                    except KeyError:
+                        concreteDecoder = None
+
+                    if concreteDecoder:
+                        state = stDecodeValue
+                    else:
+                        state = stTryAsExplicitTag
+
+                if LOG:
+                    LOG('codec %s chosen by a built-in type, decoding %s' % (concreteDecoder and concreteDecoder.__class__.__name__ or "<none>", state is stDecodeValue and 'value' or 'as explicit tag'))
+                    debug.scope.push(concreteDecoder is None and '?' or concreteDecoder.protoComponent.__class__.__name__)
+
+            if state is stGetValueDecoderByAsn1Spec:
+
+                if asn1Spec.__class__ is tagmap.TagMap:
+                    try:
+                        chosenSpec = asn1Spec[tagSet]
+
+                    except KeyError:
+                        chosenSpec = None
+
+                    if LOG:
+                        LOG('candidate ASN.1 spec is a map of:')
+
+                        for firstOctet, v in asn1Spec.presentTypes.items():
+                            LOG('  %s -> %s' % (firstOctet, v.__class__.__name__))
+
+                        if asn1Spec.skipTypes:
+                            LOG('but neither of: ')
+                            for firstOctet, v in asn1Spec.skipTypes.items():
+                                LOG('  %s -> %s' % (firstOctet, v.__class__.__name__))
+                        LOG('new candidate ASN.1 spec is %s, chosen by %s' % (chosenSpec is None and '<none>' or chosenSpec.prettyPrintType(), tagSet))
+
+                elif tagSet == asn1Spec.tagSet or tagSet in asn1Spec.tagMap:
+                    chosenSpec = asn1Spec
+                    if LOG:
+                        LOG('candidate ASN.1 spec is %s' % asn1Spec.__class__.__name__)
+
+                else:
+                    chosenSpec = None
+
+                if chosenSpec is not None:
+                    try:
+                        # ambiguous type or just faster codec lookup
+                        concreteDecoder = typeMap[chosenSpec.typeId]
+
+                        if LOG:
+                            LOG('value decoder chosen for an ambiguous type by type ID %s' % (chosenSpec.typeId,))
+
+                    except KeyError:
+                        # use base type for codec lookup to recover untagged types
+                        baseTagSet = tag.TagSet(chosenSpec.tagSet.baseTag,  chosenSpec.tagSet.baseTag)
+                        try:
+                            # base type or tagged subtype
+                            concreteDecoder = tagMap[baseTagSet]
+
+                            if LOG:
+                                LOG('value decoder chosen by base %s' % (baseTagSet,))
+
+                        except KeyError:
+                            concreteDecoder = None
+
+                    if concreteDecoder:
+                        asn1Spec = chosenSpec
+                        state = stDecodeValue
+
+                    else:
+                        state = stTryAsExplicitTag
+
+                else:
+                    concreteDecoder = None
+                    state = stTryAsExplicitTag
+
+                if LOG:
+                    LOG('codec %s chosen by ASN.1 spec, decoding %s' % (state is stDecodeValue and concreteDecoder.__class__.__name__ or "<none>", state is stDecodeValue and 'value' or 'as explicit tag'))
+                    debug.scope.push(chosenSpec is None and '?' or chosenSpec.__class__.__name__)
+
+            if state is stDecodeValue:
+                if not options.get('recursiveFlag', True) and not substrateFun:  # deprecate this
+                    substrateFun = lambda a, b, c: (a, b[:c])
+
+                options.update(fullSubstrate=fullSubstrate)
+
+                if length == -1:  # indef length
+                    value, substrate = concreteDecoder.indefLenValueDecoder(
+                        substrate, asn1Spec,
+                        tagSet, length, stGetValueDecoder,
+                        self, substrateFun,
+                        **options
+                    )
+
+                else:
+                    value, substrate = concreteDecoder.valueDecoder(
+                        substrate, asn1Spec,
+                        tagSet, length, stGetValueDecoder,
+                        self, substrateFun,
+                        **options
+                    )
+
+                if LOG:
+                    LOG('codec %s yields type %s, value:\n%s\n...remaining substrate is: %s' % (concreteDecoder.__class__.__name__, value.__class__.__name__, isinstance(value, base.Asn1Item) and value.prettyPrint() or value, substrate and debug.hexdump(substrate) or '<none>'))
+
+                state = stStop
+                break
+
+            if state is stTryAsExplicitTag:
+                if (tagSet and
+                        tagSet[0].tagFormat == tag.tagFormatConstructed and
+                        tagSet[0].tagClass != tag.tagClassUniversal):
+                    # Assume explicit tagging
+                    concreteDecoder = explicitTagDecoder
+                    state = stDecodeValue
+
+                else:
+                    concreteDecoder = None
+                    state = self.defaultErrorState
+
+                if LOG:
+                    LOG('codec %s chosen, decoding %s' % (concreteDecoder and concreteDecoder.__class__.__name__ or "<none>", state is stDecodeValue and 'value' or 'as failure'))
+
+            if state is stDumpRawValue:
+                concreteDecoder = self.defaultRawDecoder
+
+                if LOG:
+                    LOG('codec %s chosen, decoding value' % concreteDecoder.__class__.__name__)
+
+                state = stDecodeValue
+
+            if state is stErrorCondition:
+                raise error.PyAsn1Error(
+                    '%s not in asn1Spec: %r' % (tagSet, asn1Spec)
+                )
+
+        if LOG:
+            debug.scope.pop()
+            LOG('decoder left scope %s, call completed' % debug.scope)
+
+        return value, substrate
+
+
+#: Turns BER octet stream into an ASN.1 object.
+#:
+#: Takes BER octet-stream and decode it into an ASN.1 object
+#: (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative) which
+#: may be a scalar or an arbitrary nested structure.
+#:
+#: Parameters
+#: ----------
+#: substrate: :py:class:`bytes` (Python 3) or :py:class:`str` (Python 2)
+#:     BER octet-stream
+#:
+#: Keyword Args
+#: ------------
+#: asn1Spec: any pyasn1 type object e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+#:     A pyasn1 type object to act as a template guiding the decoder. Depending on the ASN.1 structure
+#:     being decoded, *asn1Spec* may or may not be required. Most common reason for
+#:     it to require is that ASN.1 structure is encoded in *IMPLICIT* tagging mode.
+#:
+#: Returns
+#: -------
+#: : :py:class:`tuple`
+#:     A tuple of pyasn1 object recovered from BER substrate (:py:class:`~pyasn1.type.base.PyAsn1Item` derivative)
+#:     and the unprocessed trailing portion of the *substrate* (may be empty)
+#:
+#: Raises
+#: ------
+#: ~pyasn1.error.PyAsn1Error, ~pyasn1.error.SubstrateUnderrunError
+#:     On decoding errors
+#:
+#: Examples
+#: --------
+#: Decode BER serialisation without ASN.1 schema
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> s, _ = decode(b'0\t\x02\x01\x01\x02\x01\x02\x02\x01\x03')
+#:    >>> str(s)
+#:    SequenceOf:
+#:     1 2 3
+#:
+#: Decode BER serialisation with ASN.1 schema
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> seq = SequenceOf(componentType=Integer())
+#:    >>> s, _ = decode(b'0\t\x02\x01\x01\x02\x01\x02\x02\x01\x03', asn1Spec=seq)
+#:    >>> str(s)
+#:    SequenceOf:
+#:     1 2 3
+#:
+decode = Decoder(tagMap, typeMap)
+
+# XXX
+# non-recursive decoding; return position rather than substrate
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/encoder.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/encoder.py
new file mode 100644
index 0000000..778aa86
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/encoder.py
@@ -0,0 +1,890 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+
+from pyasn1 import debug
+from pyasn1 import error
+from pyasn1.codec.ber import eoo
+from pyasn1.compat.integer import to_bytes
+from pyasn1.compat.octets import (int2oct, oct2int, ints2octs, null,
+                                  str2octs, isOctetsType)
+from pyasn1.type import char
+from pyasn1.type import tag
+from pyasn1.type import univ
+from pyasn1.type import useful
+
+__all__ = ['encode']
+
+LOG = debug.registerLoggee(__name__, flags=debug.DEBUG_ENCODER)
+
+
+class AbstractItemEncoder(object):
+    supportIndefLenMode = True
+
+    # An outcome of otherwise legit call `encodeFun(eoo.endOfOctets)`
+    eooIntegerSubstrate = (0, 0)
+    eooOctetsSubstrate = ints2octs(eooIntegerSubstrate)
+
+    # noinspection PyMethodMayBeStatic
+    def encodeTag(self, singleTag, isConstructed):
+        tagClass, tagFormat, tagId = singleTag
+        encodedTag = tagClass | tagFormat
+        if isConstructed:
+            encodedTag |= tag.tagFormatConstructed
+
+        if tagId < 31:
+            return encodedTag | tagId,
+
+        else:
+            substrate = tagId & 0x7f,
+
+            tagId >>= 7
+
+            while tagId:
+                substrate = (0x80 | (tagId & 0x7f),) + substrate
+                tagId >>= 7
+
+            return (encodedTag | 0x1F,) + substrate
+
+    def encodeLength(self, length, defMode):
+        if not defMode and self.supportIndefLenMode:
+            return (0x80,)
+
+        if length < 0x80:
+            return length,
+
+        else:
+            substrate = ()
+            while length:
+                substrate = (length & 0xff,) + substrate
+                length >>= 8
+
+            substrateLen = len(substrate)
+
+            if substrateLen > 126:
+                raise error.PyAsn1Error('Length octets overflow (%d)' % substrateLen)
+
+            return (0x80 | substrateLen,) + substrate
+
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        raise error.PyAsn1Error('Not implemented')
+
+    def encode(self, value, asn1Spec=None, encodeFun=None, **options):
+
+        if asn1Spec is None:
+            tagSet = value.tagSet
+        else:
+            tagSet = asn1Spec.tagSet
+
+        # untagged item?
+        if not tagSet:
+            substrate, isConstructed, isOctets = self.encodeValue(
+                value, asn1Spec, encodeFun, **options
+            )
+            return substrate
+
+        defMode = options.get('defMode', True)
+
+        substrate = null
+
+        for idx, singleTag in enumerate(tagSet.superTags):
+
+            defModeOverride = defMode
+
+            # base tag?
+            if not idx:
+                try:
+                    substrate, isConstructed, isOctets = self.encodeValue(
+                        value, asn1Spec, encodeFun, **options
+                    )
+
+                except error.PyAsn1Error:
+                    exc = sys.exc_info()
+                    raise error.PyAsn1Error(
+                        'Error encoding %r: %s' % (value, exc[1]))
+
+                if LOG:
+                    LOG('encoded %svalue %s into %s' % (
+                        isConstructed and 'constructed ' or '', value, substrate
+                    ))
+
+                if not substrate and isConstructed and options.get('ifNotEmpty', False):
+                    return substrate
+
+                if not isConstructed:
+                    defModeOverride = True
+
+                    if LOG:
+                        LOG('overridden encoding mode into definitive for primitive type')
+
+            header = self.encodeTag(singleTag, isConstructed)
+
+            if LOG:
+                LOG('encoded %stag %s into %s' % (
+                    isConstructed and 'constructed ' or '',
+                    singleTag, debug.hexdump(ints2octs(header))))
+
+            header += self.encodeLength(len(substrate), defModeOverride)
+
+            if LOG:
+                LOG('encoded %s octets (tag + payload) into %s' % (
+                    len(substrate), debug.hexdump(ints2octs(header))))
+
+            if isOctets:
+                substrate = ints2octs(header) + substrate
+
+                if not defModeOverride:
+                    substrate += self.eooOctetsSubstrate
+
+            else:
+                substrate = header + substrate
+
+                if not defModeOverride:
+                    substrate += self.eooIntegerSubstrate
+
+        if not isOctets:
+            substrate = ints2octs(substrate)
+
+        return substrate
+
+
+class EndOfOctetsEncoder(AbstractItemEncoder):
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        return null, False, True
+
+
+class BooleanEncoder(AbstractItemEncoder):
+    supportIndefLenMode = False
+
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        return value and (1,) or (0,), False, False
+
+
+class IntegerEncoder(AbstractItemEncoder):
+    supportIndefLenMode = False
+    supportCompactZero = False
+
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        if value == 0:
+            if LOG:
+                LOG('encoding %spayload for zero INTEGER' % (
+                    self.supportCompactZero and 'no ' or ''
+                ))
+
+            # de-facto way to encode zero
+            if self.supportCompactZero:
+                return (), False, False
+            else:
+                return (0,), False, False
+
+        return to_bytes(int(value), signed=True), False, True
+
+
+class BitStringEncoder(AbstractItemEncoder):
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        if asn1Spec is not None:
+            # TODO: try to avoid ASN.1 schema instantiation
+            value = asn1Spec.clone(value)
+
+        valueLength = len(value)
+        if valueLength % 8:
+            alignedValue = value << (8 - valueLength % 8)
+        else:
+            alignedValue = value
+
+        maxChunkSize = options.get('maxChunkSize', 0)
+        if not maxChunkSize or len(alignedValue) <= maxChunkSize * 8:
+            substrate = alignedValue.asOctets()
+            return int2oct(len(substrate) * 8 - valueLength) + substrate, False, True
+
+        if LOG:
+            LOG('encoding into up to %s-octet chunks' % maxChunkSize)
+
+        baseTag = value.tagSet.baseTag
+
+        # strip off explicit tags
+        if baseTag:
+            tagSet = tag.TagSet(baseTag, baseTag)
+
+        else:
+            tagSet = tag.TagSet()
+
+        alignedValue = alignedValue.clone(tagSet=tagSet)
+
+        stop = 0
+        substrate = null
+        while stop < valueLength:
+            start = stop
+            stop = min(start + maxChunkSize * 8, valueLength)
+            substrate += encodeFun(alignedValue[start:stop], asn1Spec, **options)
+
+        return substrate, True, True
+
+
+class OctetStringEncoder(AbstractItemEncoder):
+
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+
+        if asn1Spec is None:
+            substrate = value.asOctets()
+
+        elif not isOctetsType(value):
+            substrate = asn1Spec.clone(value).asOctets()
+
+        else:
+            substrate = value
+
+        maxChunkSize = options.get('maxChunkSize', 0)
+
+        if not maxChunkSize or len(substrate) <= maxChunkSize:
+            return substrate, False, True
+
+        if LOG:
+            LOG('encoding into up to %s-octet chunks' % maxChunkSize)
+
+        # strip off explicit tags for inner chunks
+
+        if asn1Spec is None:
+            baseTag = value.tagSet.baseTag
+
+            # strip off explicit tags
+            if baseTag:
+                tagSet = tag.TagSet(baseTag, baseTag)
+
+            else:
+                tagSet = tag.TagSet()
+
+            asn1Spec = value.clone(tagSet=tagSet)
+
+        elif not isOctetsType(value):
+            baseTag = asn1Spec.tagSet.baseTag
+
+            # strip off explicit tags
+            if baseTag:
+                tagSet = tag.TagSet(baseTag, baseTag)
+
+            else:
+                tagSet = tag.TagSet()
+
+            asn1Spec = asn1Spec.clone(tagSet=tagSet)
+
+        pos = 0
+        substrate = null
+
+        while True:
+            chunk = value[pos:pos + maxChunkSize]
+            if not chunk:
+                break
+
+            substrate += encodeFun(chunk, asn1Spec, **options)
+            pos += maxChunkSize
+
+        return substrate, True, True
+
+
+class NullEncoder(AbstractItemEncoder):
+    supportIndefLenMode = False
+
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        return null, False, True
+
+
+class ObjectIdentifierEncoder(AbstractItemEncoder):
+    supportIndefLenMode = False
+
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        if asn1Spec is not None:
+            value = asn1Spec.clone(value)
+
+        oid = value.asTuple()
+
+        # Build the first pair
+        try:
+            first = oid[0]
+            second = oid[1]
+
+        except IndexError:
+            raise error.PyAsn1Error('Short OID %s' % (value,))
+
+        if 0 <= second <= 39:
+            if first == 1:
+                oid = (second + 40,) + oid[2:]
+            elif first == 0:
+                oid = (second,) + oid[2:]
+            elif first == 2:
+                oid = (second + 80,) + oid[2:]
+            else:
+                raise error.PyAsn1Error('Impossible first/second arcs at %s' % (value,))
+
+        elif first == 2:
+            oid = (second + 80,) + oid[2:]
+
+        else:
+            raise error.PyAsn1Error('Impossible first/second arcs at %s' % (value,))
+
+        octets = ()
+
+        # Cycle through subIds
+        for subOid in oid:
+            if 0 <= subOid <= 127:
+                # Optimize for the common case
+                octets += (subOid,)
+
+            elif subOid > 127:
+                # Pack large Sub-Object IDs
+                res = (subOid & 0x7f,)
+                subOid >>= 7
+
+                while subOid:
+                    res = (0x80 | (subOid & 0x7f),) + res
+                    subOid >>= 7
+
+                # Add packed Sub-Object ID to resulted Object ID
+                octets += res
+
+            else:
+                raise error.PyAsn1Error('Negative OID arc %s at %s' % (subOid, value))
+
+        return octets, False, False
+
+
+class RealEncoder(AbstractItemEncoder):
+    supportIndefLenMode = 0
+    binEncBase = 2  # set to None to choose encoding base automatically
+
+    @staticmethod
+    def _dropFloatingPoint(m, encbase, e):
+        ms, es = 1, 1
+        if m < 0:
+            ms = -1  # mantissa sign
+
+        if e < 0:
+            es = -1  # exponent sign
+
+        m *= ms
+
+        if encbase == 8:
+            m *= 2 ** (abs(e) % 3 * es)
+            e = abs(e) // 3 * es
+
+        elif encbase == 16:
+            m *= 2 ** (abs(e) % 4 * es)
+            e = abs(e) // 4 * es
+
+        while True:
+            if int(m) != m:
+                m *= encbase
+                e -= 1
+                continue
+            break
+
+        return ms, int(m), encbase, e
+
+    def _chooseEncBase(self, value):
+        m, b, e = value
+        encBase = [2, 8, 16]
+        if value.binEncBase in encBase:
+            return self._dropFloatingPoint(m, value.binEncBase, e)
+
+        elif self.binEncBase in encBase:
+            return self._dropFloatingPoint(m, self.binEncBase, e)
+
+        # auto choosing base 2/8/16
+        mantissa = [m, m, m]
+        exponent = [e, e, e]
+        sign = 1
+        encbase = 2
+        e = float('inf')
+
+        for i in range(3):
+            (sign,
+             mantissa[i],
+             encBase[i],
+             exponent[i]) = self._dropFloatingPoint(mantissa[i], encBase[i], exponent[i])
+
+            if abs(exponent[i]) < abs(e) or (abs(exponent[i]) == abs(e) and mantissa[i] < m):
+                e = exponent[i]
+                m = int(mantissa[i])
+                encbase = encBase[i]
+
+        if LOG:
+            LOG('automatically chosen REAL encoding base %s, sign %s, mantissa %s, '
+                'exponent %s' % (encbase, sign, m, e))
+
+        return sign, m, encbase, e
+
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        if asn1Spec is not None:
+            value = asn1Spec.clone(value)
+
+        if value.isPlusInf:
+            return (0x40,), False, False
+
+        if value.isMinusInf:
+            return (0x41,), False, False
+
+        m, b, e = value
+
+        if not m:
+            return null, False, True
+
+        if b == 10:
+            if LOG:
+                LOG('encoding REAL into character form')
+
+            return str2octs('\x03%dE%s%d' % (m, e == 0 and '+' or '', e)), False, True
+
+        elif b == 2:
+            fo = 0x80  # binary encoding
+            ms, m, encbase, e = self._chooseEncBase(value)
+
+            if ms < 0:  # mantissa sign
+                fo |= 0x40  # sign bit
+
+            # exponent & mantissa normalization
+            if encbase == 2:
+                while m & 0x1 == 0:
+                    m >>= 1
+                    e += 1
+
+            elif encbase == 8:
+                while m & 0x7 == 0:
+                    m >>= 3
+                    e += 1
+                fo |= 0x10
+
+            else:  # encbase = 16
+                while m & 0xf == 0:
+                    m >>= 4
+                    e += 1
+                fo |= 0x20
+
+            sf = 0  # scale factor
+
+            while m & 0x1 == 0:
+                m >>= 1
+                sf += 1
+
+            if sf > 3:
+                raise error.PyAsn1Error('Scale factor overflow')  # bug if raised
+
+            fo |= sf << 2
+            eo = null
+            if e == 0 or e == -1:
+                eo = int2oct(e & 0xff)
+
+            else:
+                while e not in (0, -1):
+                    eo = int2oct(e & 0xff) + eo
+                    e >>= 8
+
+                if e == 0 and eo and oct2int(eo[0]) & 0x80:
+                    eo = int2oct(0) + eo
+
+                if e == -1 and eo and not (oct2int(eo[0]) & 0x80):
+                    eo = int2oct(0xff) + eo
+
+            n = len(eo)
+            if n > 0xff:
+                raise error.PyAsn1Error('Real exponent overflow')
+
+            if n == 1:
+                pass
+
+            elif n == 2:
+                fo |= 1
+
+            elif n == 3:
+                fo |= 2
+
+            else:
+                fo |= 3
+                eo = int2oct(n & 0xff) + eo
+
+            po = null
+
+            while m:
+                po = int2oct(m & 0xff) + po
+                m >>= 8
+
+            substrate = int2oct(fo) + eo + po
+
+            return substrate, False, True
+
+        else:
+            raise error.PyAsn1Error('Prohibited Real base %s' % b)
+
+
+class SequenceEncoder(AbstractItemEncoder):
+    omitEmptyOptionals = False
+
+    # TODO: handling three flavors of input is too much -- split over codecs
+
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+
+        substrate = null
+
+        omitEmptyOptionals = options.get(
+            'omitEmptyOptionals', self.omitEmptyOptionals)
+
+        if LOG:
+            LOG('%sencoding empty OPTIONAL components' % (
+                    omitEmptyOptionals and 'not ' or ''))
+
+        if asn1Spec is None:
+            # instance of ASN.1 schema
+            inconsistency = value.isInconsistent
+            if inconsistency:
+                raise inconsistency
+
+            namedTypes = value.componentType
+
+            for idx, component in enumerate(value.values()):
+                if namedTypes:
+                    namedType = namedTypes[idx]
+
+                    if namedType.isOptional and not component.isValue:
+                        if LOG:
+                            LOG('not encoding OPTIONAL component %r' % (namedType,))
+                        continue
+
+                    if namedType.isDefaulted and component == namedType.asn1Object:
+                        if LOG:
+                            LOG('not encoding DEFAULT component %r' % (namedType,))
+                        continue
+
+                    if omitEmptyOptionals:
+                        options.update(ifNotEmpty=namedType.isOptional)
+
+                # wrap open type blob if needed
+                if namedTypes and namedType.openType:
+
+                    wrapType = namedType.asn1Object
+
+                    if wrapType.typeId in (
+                            univ.SetOf.typeId, univ.SequenceOf.typeId):
+
+                        substrate += encodeFun(
+                                component, asn1Spec,
+                                **dict(options, wrapType=wrapType.componentType))
+
+                    else:
+                        chunk = encodeFun(component, asn1Spec, **options)
+
+                        if wrapType.isSameTypeWith(component):
+                            substrate += chunk
+
+                        else:
+                            substrate += encodeFun(chunk, wrapType, **options)
+
+                            if LOG:
+                                LOG('wrapped with wrap type %r' % (wrapType,))
+
+                else:
+                    substrate += encodeFun(component, asn1Spec, **options)
+
+        else:
+            # bare Python value + ASN.1 schema
+            for idx, namedType in enumerate(asn1Spec.componentType.namedTypes):
+
+                try:
+                    component = value[namedType.name]
+
+                except KeyError:
+                    raise error.PyAsn1Error('Component name "%s" not found in %r' % (
+                        namedType.name, value))
+
+                if namedType.isOptional and namedType.name not in value:
+                    if LOG:
+                        LOG('not encoding OPTIONAL component %r' % (namedType,))
+                    continue
+
+                if namedType.isDefaulted and component == namedType.asn1Object:
+                    if LOG:
+                        LOG('not encoding DEFAULT component %r' % (namedType,))
+                    continue
+
+                if omitEmptyOptionals:
+                    options.update(ifNotEmpty=namedType.isOptional)
+
+                componentSpec = namedType.asn1Object
+
+                # wrap open type blob if needed
+                if namedType.openType:
+
+                    if componentSpec.typeId in (
+                            univ.SetOf.typeId, univ.SequenceOf.typeId):
+
+                        substrate += encodeFun(
+                                component, componentSpec,
+                                **dict(options, wrapType=componentSpec.componentType))
+
+                    else:
+                        chunk = encodeFun(component, componentSpec, **options)
+
+                        if componentSpec.isSameTypeWith(component):
+                            substrate += chunk
+
+                        else:
+                            substrate += encodeFun(chunk, componentSpec, **options)
+
+                            if LOG:
+                                LOG('wrapped with wrap type %r' % (componentSpec,))
+
+                else:
+                    substrate += encodeFun(component, componentSpec, **options)
+
+        return substrate, True, True
+
+
+class SequenceOfEncoder(AbstractItemEncoder):
+    def _encodeComponents(self, value, asn1Spec, encodeFun, **options):
+
+        if asn1Spec is None:
+            inconsistency = value.isInconsistent
+            if inconsistency:
+                raise inconsistency
+
+        else:
+            asn1Spec = asn1Spec.componentType
+
+        chunks = []
+
+        wrapType = options.pop('wrapType', None)
+
+        for idx, component in enumerate(value):
+            chunk = encodeFun(component, asn1Spec, **options)
+
+            if (wrapType is not None and
+                    not wrapType.isSameTypeWith(component)):
+                # wrap encoded value with wrapper container (e.g. ANY)
+                chunk = encodeFun(chunk, wrapType, **options)
+
+                if LOG:
+                    LOG('wrapped with wrap type %r' % (wrapType,))
+
+            chunks.append(chunk)
+
+        return chunks
+
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        chunks = self._encodeComponents(
+            value, asn1Spec, encodeFun, **options)
+
+        return null.join(chunks), True, True
+
+
+class ChoiceEncoder(AbstractItemEncoder):
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        if asn1Spec is None:
+            component = value.getComponent()
+        else:
+            names = [namedType.name for namedType in asn1Spec.componentType.namedTypes
+                     if namedType.name in value]
+            if len(names) != 1:
+                raise error.PyAsn1Error('%s components for Choice at %r' % (len(names) and 'Multiple ' or 'None ', value))
+
+            name = names[0]
+
+            component = value[name]
+            asn1Spec = asn1Spec[name]
+
+        return encodeFun(component, asn1Spec, **options), True, True
+
+
+class AnyEncoder(OctetStringEncoder):
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        if asn1Spec is None:
+            value = value.asOctets()
+        elif not isOctetsType(value):
+            value = asn1Spec.clone(value).asOctets()
+
+        return value, not options.get('defMode', True), True
+
+
+tagMap = {
+    eoo.endOfOctets.tagSet: EndOfOctetsEncoder(),
+    univ.Boolean.tagSet: BooleanEncoder(),
+    univ.Integer.tagSet: IntegerEncoder(),
+    univ.BitString.tagSet: BitStringEncoder(),
+    univ.OctetString.tagSet: OctetStringEncoder(),
+    univ.Null.tagSet: NullEncoder(),
+    univ.ObjectIdentifier.tagSet: ObjectIdentifierEncoder(),
+    univ.Enumerated.tagSet: IntegerEncoder(),
+    univ.Real.tagSet: RealEncoder(),
+    # Sequence & Set have same tags as SequenceOf & SetOf
+    univ.SequenceOf.tagSet: SequenceOfEncoder(),
+    univ.SetOf.tagSet: SequenceOfEncoder(),
+    univ.Choice.tagSet: ChoiceEncoder(),
+    # character string types
+    char.UTF8String.tagSet: OctetStringEncoder(),
+    char.NumericString.tagSet: OctetStringEncoder(),
+    char.PrintableString.tagSet: OctetStringEncoder(),
+    char.TeletexString.tagSet: OctetStringEncoder(),
+    char.VideotexString.tagSet: OctetStringEncoder(),
+    char.IA5String.tagSet: OctetStringEncoder(),
+    char.GraphicString.tagSet: OctetStringEncoder(),
+    char.VisibleString.tagSet: OctetStringEncoder(),
+    char.GeneralString.tagSet: OctetStringEncoder(),
+    char.UniversalString.tagSet: OctetStringEncoder(),
+    char.BMPString.tagSet: OctetStringEncoder(),
+    # useful types
+    useful.ObjectDescriptor.tagSet: OctetStringEncoder(),
+    useful.GeneralizedTime.tagSet: OctetStringEncoder(),
+    useful.UTCTime.tagSet: OctetStringEncoder()
+}
+
+# Put in ambiguous & non-ambiguous types for faster codec lookup
+typeMap = {
+    univ.Boolean.typeId: BooleanEncoder(),
+    univ.Integer.typeId: IntegerEncoder(),
+    univ.BitString.typeId: BitStringEncoder(),
+    univ.OctetString.typeId: OctetStringEncoder(),
+    univ.Null.typeId: NullEncoder(),
+    univ.ObjectIdentifier.typeId: ObjectIdentifierEncoder(),
+    univ.Enumerated.typeId: IntegerEncoder(),
+    univ.Real.typeId: RealEncoder(),
+    # Sequence & Set have same tags as SequenceOf & SetOf
+    univ.Set.typeId: SequenceEncoder(),
+    univ.SetOf.typeId: SequenceOfEncoder(),
+    univ.Sequence.typeId: SequenceEncoder(),
+    univ.SequenceOf.typeId: SequenceOfEncoder(),
+    univ.Choice.typeId: ChoiceEncoder(),
+    univ.Any.typeId: AnyEncoder(),
+    # character string types
+    char.UTF8String.typeId: OctetStringEncoder(),
+    char.NumericString.typeId: OctetStringEncoder(),
+    char.PrintableString.typeId: OctetStringEncoder(),
+    char.TeletexString.typeId: OctetStringEncoder(),
+    char.VideotexString.typeId: OctetStringEncoder(),
+    char.IA5String.typeId: OctetStringEncoder(),
+    char.GraphicString.typeId: OctetStringEncoder(),
+    char.VisibleString.typeId: OctetStringEncoder(),
+    char.GeneralString.typeId: OctetStringEncoder(),
+    char.UniversalString.typeId: OctetStringEncoder(),
+    char.BMPString.typeId: OctetStringEncoder(),
+    # useful types
+    useful.ObjectDescriptor.typeId: OctetStringEncoder(),
+    useful.GeneralizedTime.typeId: OctetStringEncoder(),
+    useful.UTCTime.typeId: OctetStringEncoder()
+}
+
+
+class Encoder(object):
+    fixedDefLengthMode = None
+    fixedChunkSize = None
+
+    # noinspection PyDefaultArgument
+    def __init__(self, tagMap, typeMap={}):
+        self.__tagMap = tagMap
+        self.__typeMap = typeMap
+
+    def __call__(self, value, asn1Spec=None, **options):
+        try:
+            if asn1Spec is None:
+                typeId = value.typeId
+            else:
+                typeId = asn1Spec.typeId
+
+        except AttributeError:
+            raise error.PyAsn1Error('Value %r is not ASN.1 type instance '
+                                    'and "asn1Spec" not given' % (value,))
+
+        if LOG:
+            LOG('encoder called in %sdef mode, chunk size %s for '
+                   'type %s, value:\n%s' % (not options.get('defMode', True) and 'in' or '', options.get('maxChunkSize', 0), asn1Spec is None and value.prettyPrintType() or asn1Spec.prettyPrintType(), value))
+
+        if self.fixedDefLengthMode is not None:
+            options.update(defMode=self.fixedDefLengthMode)
+
+        if self.fixedChunkSize is not None:
+            options.update(maxChunkSize=self.fixedChunkSize)
+
+
+        try:
+            concreteEncoder = self.__typeMap[typeId]
+
+            if LOG:
+                LOG('using value codec %s chosen by type ID %s' % (concreteEncoder.__class__.__name__, typeId))
+
+        except KeyError:
+            if asn1Spec is None:
+                tagSet = value.tagSet
+            else:
+                tagSet = asn1Spec.tagSet
+
+            # use base type for codec lookup to recover untagged types
+            baseTagSet = tag.TagSet(tagSet.baseTag, tagSet.baseTag)
+
+            try:
+                concreteEncoder = self.__tagMap[baseTagSet]
+
+            except KeyError:
+                raise error.PyAsn1Error('No encoder for %r (%s)' % (value, tagSet))
+
+            if LOG:
+                LOG('using value codec %s chosen by tagSet %s' % (concreteEncoder.__class__.__name__, tagSet))
+
+        substrate = concreteEncoder.encode(value, asn1Spec, self, **options)
+
+        if LOG:
+            LOG('codec %s built %s octets of substrate: %s\nencoder completed' % (concreteEncoder, len(substrate), debug.hexdump(substrate)))
+
+        return substrate
+
+#: Turns ASN.1 object into BER octet stream.
+#:
+#: Takes any ASN.1 object (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative)
+#: walks all its components recursively and produces a BER octet stream.
+#:
+#: Parameters
+#: ----------
+#: value: either a Python or pyasn1 object (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative)
+#:     A Python or pyasn1 object to encode. If Python object is given, `asnSpec`
+#:     parameter is required to guide the encoding process.
+#:
+#: Keyword Args
+#: ------------
+#: asn1Spec:
+#:     Optional ASN.1 schema or value object e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+#:
+#: defMode: :py:class:`bool`
+#:     If :obj:`False`, produces indefinite length encoding
+#:
+#: maxChunkSize: :py:class:`int`
+#:     Maximum chunk size in chunked encoding mode (0 denotes unlimited chunk size)
+#:
+#: Returns
+#: -------
+#: : :py:class:`bytes` (Python 3) or :py:class:`str` (Python 2)
+#:     Given ASN.1 object encoded into BER octetstream
+#:
+#: Raises
+#: ------
+#: ~pyasn1.error.PyAsn1Error
+#:     On encoding errors
+#:
+#: Examples
+#: --------
+#: Encode Python value into BER with ASN.1 schema
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> seq = SequenceOf(componentType=Integer())
+#:    >>> encode([1, 2, 3], asn1Spec=seq)
+#:    b'0\t\x02\x01\x01\x02\x01\x02\x02\x01\x03'
+#:
+#: Encode ASN.1 value object into BER
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> seq = SequenceOf(componentType=Integer())
+#:    >>> seq.extend([1, 2, 3])
+#:    >>> encode(seq)
+#:    b'0\t\x02\x01\x01\x02\x01\x02\x02\x01\x03'
+#:
+encode = Encoder(tagMap, typeMap)
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/eoo.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/eoo.py
new file mode 100644
index 0000000..48eb859
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/ber/eoo.py
@@ -0,0 +1,28 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from pyasn1.type import base
+from pyasn1.type import tag
+
+__all__ = ['endOfOctets']
+
+
+class EndOfOctets(base.SimpleAsn1Type):
+    defaultValue = 0
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x00)
+    )
+
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = object.__new__(cls, *args, **kwargs)
+
+        return cls._instance
+
+
+endOfOctets = EndOfOctets()
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/cer/__init__.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/cer/__init__.py
new file mode 100644
index 0000000..8c3066b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/cer/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/cer/decoder.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/cer/decoder.py
new file mode 100644
index 0000000..3e86fd0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/cer/decoder.py
@@ -0,0 +1,114 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from pyasn1 import error
+from pyasn1.codec.ber import decoder
+from pyasn1.compat.octets import oct2int
+from pyasn1.type import univ
+
+__all__ = ['decode']
+
+
+class BooleanDecoder(decoder.AbstractSimpleDecoder):
+    protoComponent = univ.Boolean(0)
+
+    def valueDecoder(self, substrate, asn1Spec,
+                     tagSet=None, length=None, state=None,
+                     decodeFun=None, substrateFun=None,
+                     **options):
+        head, tail = substrate[:length], substrate[length:]
+        if not head or length != 1:
+            raise error.PyAsn1Error('Not single-octet Boolean payload')
+        byte = oct2int(head[0])
+        # CER/DER specifies encoding of TRUE as 0xFF and FALSE as 0x0, while
+        # BER allows any non-zero value as TRUE; cf. sections 8.2.2. and 11.1 
+        # in https://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
+        if byte == 0xff:
+            value = 1
+        elif byte == 0x00:
+            value = 0
+        else:
+            raise error.PyAsn1Error('Unexpected Boolean payload: %s' % byte)
+        return self._createComponent(asn1Spec, tagSet, value, **options), tail
+
+# TODO: prohibit non-canonical encoding
+BitStringDecoder = decoder.BitStringDecoder
+OctetStringDecoder = decoder.OctetStringDecoder
+RealDecoder = decoder.RealDecoder
+
+tagMap = decoder.tagMap.copy()
+tagMap.update(
+    {univ.Boolean.tagSet: BooleanDecoder(),
+     univ.BitString.tagSet: BitStringDecoder(),
+     univ.OctetString.tagSet: OctetStringDecoder(),
+     univ.Real.tagSet: RealDecoder()}
+)
+
+typeMap = decoder.typeMap.copy()
+
+# Put in non-ambiguous types for faster codec lookup
+for typeDecoder in tagMap.values():
+    if typeDecoder.protoComponent is not None:
+        typeId = typeDecoder.protoComponent.__class__.typeId
+        if typeId is not None and typeId not in typeMap:
+            typeMap[typeId] = typeDecoder
+
+
+class Decoder(decoder.Decoder):
+    pass
+
+
+#: Turns CER octet stream into an ASN.1 object.
+#:
+#: Takes CER octet-stream and decode it into an ASN.1 object
+#: (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative) which
+#: may be a scalar or an arbitrary nested structure.
+#:
+#: Parameters
+#: ----------
+#: substrate: :py:class:`bytes` (Python 3) or :py:class:`str` (Python 2)
+#:     CER octet-stream
+#:
+#: Keyword Args
+#: ------------
+#: asn1Spec: any pyasn1 type object e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+#:     A pyasn1 type object to act as a template guiding the decoder. Depending on the ASN.1 structure
+#:     being decoded, *asn1Spec* may or may not be required. Most common reason for
+#:     it to require is that ASN.1 structure is encoded in *IMPLICIT* tagging mode.
+#:
+#: Returns
+#: -------
+#: : :py:class:`tuple`
+#:     A tuple of pyasn1 object recovered from CER substrate (:py:class:`~pyasn1.type.base.PyAsn1Item` derivative)
+#:     and the unprocessed trailing portion of the *substrate* (may be empty)
+#:
+#: Raises
+#: ------
+#: ~pyasn1.error.PyAsn1Error, ~pyasn1.error.SubstrateUnderrunError
+#:     On decoding errors
+#:
+#: Examples
+#: --------
+#: Decode CER serialisation without ASN.1 schema
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> s, _ = decode(b'0\x80\x02\x01\x01\x02\x01\x02\x02\x01\x03\x00\x00')
+#:    >>> str(s)
+#:    SequenceOf:
+#:     1 2 3
+#:
+#: Decode CER serialisation with ASN.1 schema
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> seq = SequenceOf(componentType=Integer())
+#:    >>> s, _ = decode(b'0\x80\x02\x01\x01\x02\x01\x02\x02\x01\x03\x00\x00', asn1Spec=seq)
+#:    >>> str(s)
+#:    SequenceOf:
+#:     1 2 3
+#:
+decode = Decoder(tagMap, decoder.typeMap)
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/cer/encoder.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/cer/encoder.py
new file mode 100644
index 0000000..935b696
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/cer/encoder.py
@@ -0,0 +1,313 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from pyasn1 import error
+from pyasn1.codec.ber import encoder
+from pyasn1.compat.octets import str2octs, null
+from pyasn1.type import univ
+from pyasn1.type import useful
+
+__all__ = ['encode']
+
+
+class BooleanEncoder(encoder.IntegerEncoder):
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        if value == 0:
+            substrate = (0,)
+        else:
+            substrate = (255,)
+        return substrate, False, False
+
+
+class RealEncoder(encoder.RealEncoder):
+    def _chooseEncBase(self, value):
+        m, b, e = value
+        return self._dropFloatingPoint(m, b, e)
+
+
+# specialized GeneralStringEncoder here
+
+class TimeEncoderMixIn(object):
+    Z_CHAR = ord('Z')
+    PLUS_CHAR = ord('+')
+    MINUS_CHAR = ord('-')
+    COMMA_CHAR = ord(',')
+    DOT_CHAR = ord('.')
+    ZERO_CHAR = ord('0')
+
+    MIN_LENGTH = 12
+    MAX_LENGTH = 19
+
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        # CER encoding constraints:
+        # - minutes are mandatory, seconds are optional
+        # - sub-seconds must NOT be zero / no meaningless zeros
+        # - no hanging fraction dot
+        # - time in UTC (Z)
+        # - only dot is allowed for fractions
+
+        if asn1Spec is not None:
+            value = asn1Spec.clone(value)
+
+        numbers = value.asNumbers()
+
+        if self.PLUS_CHAR in numbers or self.MINUS_CHAR in numbers:
+            raise error.PyAsn1Error('Must be UTC time: %r' % value)
+
+        if numbers[-1] != self.Z_CHAR:
+            raise error.PyAsn1Error('Missing "Z" time zone specifier: %r' % value)
+
+        if self.COMMA_CHAR in numbers:
+            raise error.PyAsn1Error('Comma in fractions disallowed: %r' % value)
+
+        if self.DOT_CHAR in numbers:
+
+            isModified = False
+
+            numbers = list(numbers)
+
+            searchIndex = min(numbers.index(self.DOT_CHAR) + 4, len(numbers) - 1)
+
+            while numbers[searchIndex] != self.DOT_CHAR:
+                if numbers[searchIndex] == self.ZERO_CHAR:
+                    del numbers[searchIndex]
+                    isModified = True
+
+                searchIndex -= 1
+
+            searchIndex += 1
+
+            if searchIndex < len(numbers):
+                if numbers[searchIndex] == self.Z_CHAR:
+                    # drop hanging comma
+                    del numbers[searchIndex - 1]
+                    isModified = True
+
+            if isModified:
+                value = value.clone(numbers)
+
+        if not self.MIN_LENGTH < len(numbers) < self.MAX_LENGTH:
+            raise error.PyAsn1Error('Length constraint violated: %r' % value)
+
+        options.update(maxChunkSize=1000)
+
+        return encoder.OctetStringEncoder.encodeValue(
+            self, value, asn1Spec, encodeFun, **options
+        )
+
+
+class GeneralizedTimeEncoder(TimeEncoderMixIn, encoder.OctetStringEncoder):
+    MIN_LENGTH = 12
+    MAX_LENGTH = 20
+
+
+class UTCTimeEncoder(TimeEncoderMixIn, encoder.OctetStringEncoder):
+    MIN_LENGTH = 10
+    MAX_LENGTH = 14
+
+
+class SetOfEncoder(encoder.SequenceOfEncoder):
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+        chunks = self._encodeComponents(
+            value, asn1Spec, encodeFun, **options)
+
+        # sort by serialised and padded components
+        if len(chunks) > 1:
+            zero = str2octs('\x00')
+            maxLen = max(map(len, chunks))
+            paddedChunks = [
+                (x.ljust(maxLen, zero), x) for x in chunks
+            ]
+            paddedChunks.sort(key=lambda x: x[0])
+
+            chunks = [x[1] for x in paddedChunks]
+
+        return null.join(chunks), True, True
+
+
+class SequenceOfEncoder(encoder.SequenceOfEncoder):
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+
+        if options.get('ifNotEmpty', False) and not len(value):
+            return null, True, True
+
+        chunks = self._encodeComponents(
+            value, asn1Spec, encodeFun, **options)
+
+        return null.join(chunks), True, True
+
+
+class SetEncoder(encoder.SequenceEncoder):
+    @staticmethod
+    def _componentSortKey(componentAndType):
+        """Sort SET components by tag
+
+        Sort regardless of the Choice value (static sort)
+        """
+        component, asn1Spec = componentAndType
+
+        if asn1Spec is None:
+            asn1Spec = component
+
+        if asn1Spec.typeId == univ.Choice.typeId and not asn1Spec.tagSet:
+            if asn1Spec.tagSet:
+                return asn1Spec.tagSet
+            else:
+                return asn1Spec.componentType.minTagSet
+        else:
+            return asn1Spec.tagSet
+
+    def encodeValue(self, value, asn1Spec, encodeFun, **options):
+
+        substrate = null
+
+        comps = []
+        compsMap = {}
+
+        if asn1Spec is None:
+            # instance of ASN.1 schema
+            inconsistency = value.isInconsistent
+            if inconsistency:
+                raise inconsistency
+
+            namedTypes = value.componentType
+
+            for idx, component in enumerate(value.values()):
+                if namedTypes:
+                    namedType = namedTypes[idx]
+
+                    if namedType.isOptional and not component.isValue:
+                            continue
+
+                    if namedType.isDefaulted and component == namedType.asn1Object:
+                            continue
+
+                    compsMap[id(component)] = namedType
+
+                else:
+                    compsMap[id(component)] = None
+
+                comps.append((component, asn1Spec))
+
+        else:
+            # bare Python value + ASN.1 schema
+            for idx, namedType in enumerate(asn1Spec.componentType.namedTypes):
+
+                try:
+                    component = value[namedType.name]
+
+                except KeyError:
+                    raise error.PyAsn1Error('Component name "%s" not found in %r' % (namedType.name, value))
+
+                if namedType.isOptional and namedType.name not in value:
+                    continue
+
+                if namedType.isDefaulted and component == namedType.asn1Object:
+                    continue
+
+                compsMap[id(component)] = namedType
+                comps.append((component, asn1Spec[idx]))
+
+        for comp, compType in sorted(comps, key=self._componentSortKey):
+            namedType = compsMap[id(comp)]
+
+            if namedType:
+                options.update(ifNotEmpty=namedType.isOptional)
+
+            chunk = encodeFun(comp, compType, **options)
+
+            # wrap open type blob if needed
+            if namedType and namedType.openType:
+                wrapType = namedType.asn1Object
+                if wrapType.tagSet and not wrapType.isSameTypeWith(comp):
+                    chunk = encodeFun(chunk, wrapType, **options)
+
+            substrate += chunk
+
+        return substrate, True, True
+
+
+class SequenceEncoder(encoder.SequenceEncoder):
+    omitEmptyOptionals = True
+
+
+tagMap = encoder.tagMap.copy()
+tagMap.update({
+    univ.Boolean.tagSet: BooleanEncoder(),
+    univ.Real.tagSet: RealEncoder(),
+    useful.GeneralizedTime.tagSet: GeneralizedTimeEncoder(),
+    useful.UTCTime.tagSet: UTCTimeEncoder(),
+    # Sequence & Set have same tags as SequenceOf & SetOf
+    univ.SetOf.tagSet: SetOfEncoder(),
+    univ.Sequence.typeId: SequenceEncoder()
+})
+
+typeMap = encoder.typeMap.copy()
+typeMap.update({
+    univ.Boolean.typeId: BooleanEncoder(),
+    univ.Real.typeId: RealEncoder(),
+    useful.GeneralizedTime.typeId: GeneralizedTimeEncoder(),
+    useful.UTCTime.typeId: UTCTimeEncoder(),
+    # Sequence & Set have same tags as SequenceOf & SetOf
+    univ.Set.typeId: SetEncoder(),
+    univ.SetOf.typeId: SetOfEncoder(),
+    univ.Sequence.typeId: SequenceEncoder(),
+    univ.SequenceOf.typeId: SequenceOfEncoder()
+})
+
+
+class Encoder(encoder.Encoder):
+    fixedDefLengthMode = False
+    fixedChunkSize = 1000
+
+#: Turns ASN.1 object into CER octet stream.
+#:
+#: Takes any ASN.1 object (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative)
+#: walks all its components recursively and produces a CER octet stream.
+#:
+#: Parameters
+#: ----------
+#: value: either a Python or pyasn1 object (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative)
+#:     A Python or pyasn1 object to encode. If Python object is given, `asnSpec`
+#:     parameter is required to guide the encoding process.
+#:
+#: Keyword Args
+#: ------------
+#: asn1Spec:
+#:     Optional ASN.1 schema or value object e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+#:
+#: Returns
+#: -------
+#: : :py:class:`bytes` (Python 3) or :py:class:`str` (Python 2)
+#:     Given ASN.1 object encoded into BER octet-stream
+#:
+#: Raises
+#: ------
+#: ~pyasn1.error.PyAsn1Error
+#:     On encoding errors
+#:
+#: Examples
+#: --------
+#: Encode Python value into CER with ASN.1 schema
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> seq = SequenceOf(componentType=Integer())
+#:    >>> encode([1, 2, 3], asn1Spec=seq)
+#:    b'0\x80\x02\x01\x01\x02\x01\x02\x02\x01\x03\x00\x00'
+#:
+#: Encode ASN.1 value object into CER
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> seq = SequenceOf(componentType=Integer())
+#:    >>> seq.extend([1, 2, 3])
+#:    >>> encode(seq)
+#:    b'0\x80\x02\x01\x01\x02\x01\x02\x02\x01\x03\x00\x00'
+#:
+encode = Encoder(tagMap, typeMap)
+
+# EncoderFactory queries class instance and builds a map of tags -> encoders
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/der/__init__.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/der/__init__.py
new file mode 100644
index 0000000..8c3066b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/der/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/der/decoder.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/der/decoder.py
new file mode 100644
index 0000000..1a13fdb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/der/decoder.py
@@ -0,0 +1,94 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from pyasn1.codec.cer import decoder
+from pyasn1.type import univ
+
+__all__ = ['decode']
+
+
+class BitStringDecoder(decoder.BitStringDecoder):
+    supportConstructedForm = False
+
+
+class OctetStringDecoder(decoder.OctetStringDecoder):
+    supportConstructedForm = False
+
+# TODO: prohibit non-canonical encoding
+RealDecoder = decoder.RealDecoder
+
+tagMap = decoder.tagMap.copy()
+tagMap.update(
+    {univ.BitString.tagSet: BitStringDecoder(),
+     univ.OctetString.tagSet: OctetStringDecoder(),
+     univ.Real.tagSet: RealDecoder()}
+)
+
+typeMap = decoder.typeMap.copy()
+
+# Put in non-ambiguous types for faster codec lookup
+for typeDecoder in tagMap.values():
+    if typeDecoder.protoComponent is not None:
+        typeId = typeDecoder.protoComponent.__class__.typeId
+        if typeId is not None and typeId not in typeMap:
+            typeMap[typeId] = typeDecoder
+
+
+class Decoder(decoder.Decoder):
+    supportIndefLength = False
+
+
+#: Turns DER octet stream into an ASN.1 object.
+#:
+#: Takes DER octet-stream and decode it into an ASN.1 object
+#: (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative) which
+#: may be a scalar or an arbitrary nested structure.
+#:
+#: Parameters
+#: ----------
+#: substrate: :py:class:`bytes` (Python 3) or :py:class:`str` (Python 2)
+#:     DER octet-stream
+#:
+#: Keyword Args
+#: ------------
+#: asn1Spec: any pyasn1 type object e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+#:     A pyasn1 type object to act as a template guiding the decoder. Depending on the ASN.1 structure
+#:     being decoded, *asn1Spec* may or may not be required. Most common reason for
+#:     it to require is that ASN.1 structure is encoded in *IMPLICIT* tagging mode.
+#:
+#: Returns
+#: -------
+#: : :py:class:`tuple`
+#:     A tuple of pyasn1 object recovered from DER substrate (:py:class:`~pyasn1.type.base.PyAsn1Item` derivative)
+#:     and the unprocessed trailing portion of the *substrate* (may be empty)
+#:
+#: Raises
+#: ------
+#: ~pyasn1.error.PyAsn1Error, ~pyasn1.error.SubstrateUnderrunError
+#:     On decoding errors
+#:
+#: Examples
+#: --------
+#: Decode DER serialisation without ASN.1 schema
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> s, _ = decode(b'0\t\x02\x01\x01\x02\x01\x02\x02\x01\x03')
+#:    >>> str(s)
+#:    SequenceOf:
+#:     1 2 3
+#:
+#: Decode DER serialisation with ASN.1 schema
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> seq = SequenceOf(componentType=Integer())
+#:    >>> s, _ = decode(b'0\t\x02\x01\x01\x02\x01\x02\x02\x01\x03', asn1Spec=seq)
+#:    >>> str(s)
+#:    SequenceOf:
+#:     1 2 3
+#:
+decode = Decoder(tagMap, typeMap)
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/der/encoder.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/der/encoder.py
new file mode 100644
index 0000000..90e982d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/der/encoder.py
@@ -0,0 +1,107 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from pyasn1 import error
+from pyasn1.codec.cer import encoder
+from pyasn1.type import univ
+
+__all__ = ['encode']
+
+
+class SetEncoder(encoder.SetEncoder):
+    @staticmethod
+    def _componentSortKey(componentAndType):
+        """Sort SET components by tag
+
+        Sort depending on the actual Choice value (dynamic sort)
+        """
+        component, asn1Spec = componentAndType
+
+        if asn1Spec is None:
+            compType = component
+        else:
+            compType = asn1Spec
+
+        if compType.typeId == univ.Choice.typeId and not compType.tagSet:
+            if asn1Spec is None:
+                return component.getComponent().tagSet
+            else:
+                # TODO: move out of sorting key function
+                names = [namedType.name for namedType in asn1Spec.componentType.namedTypes
+                         if namedType.name in component]
+                if len(names) != 1:
+                    raise error.PyAsn1Error(
+                        '%s components for Choice at %r' % (len(names) and 'Multiple ' or 'None ', component))
+
+                # TODO: support nested CHOICE ordering
+                return asn1Spec[names[0]].tagSet
+
+        else:
+            return compType.tagSet
+
+tagMap = encoder.tagMap.copy()
+tagMap.update({
+    # Set & SetOf have same tags
+    univ.Set.tagSet: SetEncoder()
+})
+
+typeMap = encoder.typeMap.copy()
+typeMap.update({
+    # Set & SetOf have same tags
+    univ.Set.typeId: SetEncoder()
+})
+
+
+class Encoder(encoder.Encoder):
+    fixedDefLengthMode = True
+    fixedChunkSize = 0
+
+#: Turns ASN.1 object into DER octet stream.
+#:
+#: Takes any ASN.1 object (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative)
+#: walks all its components recursively and produces a DER octet stream.
+#:
+#: Parameters
+#: ----------
+#: value: either a Python or pyasn1 object (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative)
+#:     A Python or pyasn1 object to encode. If Python object is given, `asnSpec`
+#:     parameter is required to guide the encoding process.
+#:
+#: Keyword Args
+#: ------------
+#: asn1Spec:
+#:     Optional ASN.1 schema or value object e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+#:
+#: Returns
+#: -------
+#: : :py:class:`bytes` (Python 3) or :py:class:`str` (Python 2)
+#:     Given ASN.1 object encoded into BER octet-stream
+#:
+#: Raises
+#: ------
+#: ~pyasn1.error.PyAsn1Error
+#:     On encoding errors
+#:
+#: Examples
+#: --------
+#: Encode Python value into DER with ASN.1 schema
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> seq = SequenceOf(componentType=Integer())
+#:    >>> encode([1, 2, 3], asn1Spec=seq)
+#:    b'0\t\x02\x01\x01\x02\x01\x02\x02\x01\x03'
+#:
+#: Encode ASN.1 value object into DER
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> seq = SequenceOf(componentType=Integer())
+#:    >>> seq.extend([1, 2, 3])
+#:    >>> encode(seq)
+#:    b'0\t\x02\x01\x01\x02\x01\x02\x02\x01\x03'
+#:
+encode = Encoder(tagMap, typeMap)
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/native/__init__.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/native/__init__.py
new file mode 100644
index 0000000..8c3066b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/native/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/native/decoder.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/native/decoder.py
new file mode 100644
index 0000000..104b92e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/native/decoder.py
@@ -0,0 +1,213 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from pyasn1 import debug
+from pyasn1 import error
+from pyasn1.type import base
+from pyasn1.type import char
+from pyasn1.type import tag
+from pyasn1.type import univ
+from pyasn1.type import useful
+
+__all__ = ['decode']
+
+LOG = debug.registerLoggee(__name__, flags=debug.DEBUG_DECODER)
+
+
+class AbstractScalarDecoder(object):
+    def __call__(self, pyObject, asn1Spec, decodeFun=None, **options):
+        return asn1Spec.clone(pyObject)
+
+
+class BitStringDecoder(AbstractScalarDecoder):
+    def __call__(self, pyObject, asn1Spec, decodeFun=None, **options):
+        return asn1Spec.clone(univ.BitString.fromBinaryString(pyObject))
+
+
+class SequenceOrSetDecoder(object):
+    def __call__(self, pyObject, asn1Spec, decodeFun=None, **options):
+        asn1Value = asn1Spec.clone()
+
+        componentsTypes = asn1Spec.componentType
+
+        for field in asn1Value:
+            if field in pyObject:
+                asn1Value[field] = decodeFun(pyObject[field], componentsTypes[field].asn1Object, **options)
+
+        return asn1Value
+
+
+class SequenceOfOrSetOfDecoder(object):
+    def __call__(self, pyObject, asn1Spec, decodeFun=None, **options):
+        asn1Value = asn1Spec.clone()
+
+        for pyValue in pyObject:
+            asn1Value.append(decodeFun(pyValue, asn1Spec.componentType), **options)
+
+        return asn1Value
+
+
+class ChoiceDecoder(object):
+    def __call__(self, pyObject, asn1Spec, decodeFun=None, **options):
+        asn1Value = asn1Spec.clone()
+
+        componentsTypes = asn1Spec.componentType
+
+        for field in pyObject:
+            if field in componentsTypes:
+                asn1Value[field] = decodeFun(pyObject[field], componentsTypes[field].asn1Object, **options)
+                break
+
+        return asn1Value
+
+
+tagMap = {
+    univ.Integer.tagSet: AbstractScalarDecoder(),
+    univ.Boolean.tagSet: AbstractScalarDecoder(),
+    univ.BitString.tagSet: BitStringDecoder(),
+    univ.OctetString.tagSet: AbstractScalarDecoder(),
+    univ.Null.tagSet: AbstractScalarDecoder(),
+    univ.ObjectIdentifier.tagSet: AbstractScalarDecoder(),
+    univ.Enumerated.tagSet: AbstractScalarDecoder(),
+    univ.Real.tagSet: AbstractScalarDecoder(),
+    univ.Sequence.tagSet: SequenceOrSetDecoder(),  # conflicts with SequenceOf
+    univ.Set.tagSet: SequenceOrSetDecoder(),  # conflicts with SetOf
+    univ.Choice.tagSet: ChoiceDecoder(),  # conflicts with Any
+    # character string types
+    char.UTF8String.tagSet: AbstractScalarDecoder(),
+    char.NumericString.tagSet: AbstractScalarDecoder(),
+    char.PrintableString.tagSet: AbstractScalarDecoder(),
+    char.TeletexString.tagSet: AbstractScalarDecoder(),
+    char.VideotexString.tagSet: AbstractScalarDecoder(),
+    char.IA5String.tagSet: AbstractScalarDecoder(),
+    char.GraphicString.tagSet: AbstractScalarDecoder(),
+    char.VisibleString.tagSet: AbstractScalarDecoder(),
+    char.GeneralString.tagSet: AbstractScalarDecoder(),
+    char.UniversalString.tagSet: AbstractScalarDecoder(),
+    char.BMPString.tagSet: AbstractScalarDecoder(),
+    # useful types
+    useful.ObjectDescriptor.tagSet: AbstractScalarDecoder(),
+    useful.GeneralizedTime.tagSet: AbstractScalarDecoder(),
+    useful.UTCTime.tagSet: AbstractScalarDecoder()
+}
+
+# Put in ambiguous & non-ambiguous types for faster codec lookup
+typeMap = {
+    univ.Integer.typeId: AbstractScalarDecoder(),
+    univ.Boolean.typeId: AbstractScalarDecoder(),
+    univ.BitString.typeId: BitStringDecoder(),
+    univ.OctetString.typeId: AbstractScalarDecoder(),
+    univ.Null.typeId: AbstractScalarDecoder(),
+    univ.ObjectIdentifier.typeId: AbstractScalarDecoder(),
+    univ.Enumerated.typeId: AbstractScalarDecoder(),
+    univ.Real.typeId: AbstractScalarDecoder(),
+    # ambiguous base types
+    univ.Set.typeId: SequenceOrSetDecoder(),
+    univ.SetOf.typeId: SequenceOfOrSetOfDecoder(),
+    univ.Sequence.typeId: SequenceOrSetDecoder(),
+    univ.SequenceOf.typeId: SequenceOfOrSetOfDecoder(),
+    univ.Choice.typeId: ChoiceDecoder(),
+    univ.Any.typeId: AbstractScalarDecoder(),
+    # character string types
+    char.UTF8String.typeId: AbstractScalarDecoder(),
+    char.NumericString.typeId: AbstractScalarDecoder(),
+    char.PrintableString.typeId: AbstractScalarDecoder(),
+    char.TeletexString.typeId: AbstractScalarDecoder(),
+    char.VideotexString.typeId: AbstractScalarDecoder(),
+    char.IA5String.typeId: AbstractScalarDecoder(),
+    char.GraphicString.typeId: AbstractScalarDecoder(),
+    char.VisibleString.typeId: AbstractScalarDecoder(),
+    char.GeneralString.typeId: AbstractScalarDecoder(),
+    char.UniversalString.typeId: AbstractScalarDecoder(),
+    char.BMPString.typeId: AbstractScalarDecoder(),
+    # useful types
+    useful.ObjectDescriptor.typeId: AbstractScalarDecoder(),
+    useful.GeneralizedTime.typeId: AbstractScalarDecoder(),
+    useful.UTCTime.typeId: AbstractScalarDecoder()
+}
+
+
+class Decoder(object):
+
+    # noinspection PyDefaultArgument
+    def __init__(self, tagMap, typeMap):
+        self.__tagMap = tagMap
+        self.__typeMap = typeMap
+
+    def __call__(self, pyObject, asn1Spec, **options):
+
+        if LOG:
+            debug.scope.push(type(pyObject).__name__)
+            LOG('decoder called at scope %s, working with type %s' % (debug.scope, type(pyObject).__name__))
+
+        if asn1Spec is None or not isinstance(asn1Spec, base.Asn1Item):
+            raise error.PyAsn1Error('asn1Spec is not valid (should be an instance of an ASN.1 Item, not %s)' % asn1Spec.__class__.__name__)
+
+        try:
+            valueDecoder = self.__typeMap[asn1Spec.typeId]
+
+        except KeyError:
+            # use base type for codec lookup to recover untagged types
+            baseTagSet = tag.TagSet(asn1Spec.tagSet.baseTag, asn1Spec.tagSet.baseTag)
+
+            try:
+                valueDecoder = self.__tagMap[baseTagSet]
+            except KeyError:
+                raise error.PyAsn1Error('Unknown ASN.1 tag %s' % asn1Spec.tagSet)
+
+        if LOG:
+            LOG('calling decoder %s on Python type %s <%s>' % (type(valueDecoder).__name__, type(pyObject).__name__, repr(pyObject)))
+
+        value = valueDecoder(pyObject, asn1Spec, self, **options)
+
+        if LOG:
+            LOG('decoder %s produced ASN.1 type %s <%s>' % (type(valueDecoder).__name__, type(value).__name__, repr(value)))
+            debug.scope.pop()
+
+        return value
+
+
+#: Turns Python objects of built-in types into ASN.1 objects.
+#:
+#: Takes Python objects of built-in types and turns them into a tree of
+#: ASN.1 objects (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative) which
+#: may be a scalar or an arbitrary nested structure.
+#:
+#: Parameters
+#: ----------
+#: pyObject: :py:class:`object`
+#:     A scalar or nested Python objects
+#:
+#: Keyword Args
+#: ------------
+#: asn1Spec: any pyasn1 type object e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+#:     A pyasn1 type object to act as a template guiding the decoder. It is required
+#:     for successful interpretation of Python objects mapping into their ASN.1
+#:     representations.
+#:
+#: Returns
+#: -------
+#: : :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+#:     A scalar or constructed pyasn1 object
+#:
+#: Raises
+#: ------
+#: ~pyasn1.error.PyAsn1Error
+#:     On decoding errors
+#:
+#: Examples
+#: --------
+#: Decode native Python object into ASN.1 objects with ASN.1 schema
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> seq = SequenceOf(componentType=Integer())
+#:    >>> s, _ = decode([1, 2, 3], asn1Spec=seq)
+#:    >>> str(s)
+#:    SequenceOf:
+#:     1 2 3
+#:
+decode = Decoder(tagMap, typeMap)
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/codec/native/encoder.py b/myenv/lib/python3.9/site-packages/pyasn1/codec/native/encoder.py
new file mode 100644
index 0000000..4318abd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/codec/native/encoder.py
@@ -0,0 +1,256 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+try:
+    from collections import OrderedDict
+
+except ImportError:
+    OrderedDict = dict
+
+from pyasn1 import debug
+from pyasn1 import error
+from pyasn1.type import base
+from pyasn1.type import char
+from pyasn1.type import tag
+from pyasn1.type import univ
+from pyasn1.type import useful
+
+__all__ = ['encode']
+
+LOG = debug.registerLoggee(__name__, flags=debug.DEBUG_ENCODER)
+
+
+class AbstractItemEncoder(object):
+    def encode(self, value, encodeFun, **options):
+        raise error.PyAsn1Error('Not implemented')
+
+
+class BooleanEncoder(AbstractItemEncoder):
+    def encode(self, value, encodeFun, **options):
+        return bool(value)
+
+
+class IntegerEncoder(AbstractItemEncoder):
+    def encode(self, value, encodeFun, **options):
+        return int(value)
+
+
+class BitStringEncoder(AbstractItemEncoder):
+    def encode(self, value, encodeFun, **options):
+        return str(value)
+
+
+class OctetStringEncoder(AbstractItemEncoder):
+    def encode(self, value, encodeFun, **options):
+        return value.asOctets()
+
+
+class TextStringEncoder(AbstractItemEncoder):
+    def encode(self, value, encodeFun, **options):
+        return str(value)
+
+
+class NullEncoder(AbstractItemEncoder):
+    def encode(self, value, encodeFun, **options):
+        return None
+
+
+class ObjectIdentifierEncoder(AbstractItemEncoder):
+    def encode(self, value, encodeFun, **options):
+        return str(value)
+
+
+class RealEncoder(AbstractItemEncoder):
+    def encode(self, value, encodeFun, **options):
+        return float(value)
+
+
+class SetEncoder(AbstractItemEncoder):
+    protoDict = dict
+
+    def encode(self, value, encodeFun, **options):
+        inconsistency = value.isInconsistent
+        if inconsistency:
+            raise inconsistency
+
+        namedTypes = value.componentType
+        substrate = self.protoDict()
+
+        for idx, (key, subValue) in enumerate(value.items()):
+            if namedTypes and namedTypes[idx].isOptional and not value[idx].isValue:
+                continue
+            substrate[key] = encodeFun(subValue, **options)
+        return substrate
+
+
+class SequenceEncoder(SetEncoder):
+    protoDict = OrderedDict
+
+
+class SequenceOfEncoder(AbstractItemEncoder):
+    def encode(self, value, encodeFun, **options):
+        inconsistency = value.isInconsistent
+        if inconsistency:
+            raise inconsistency
+        return [encodeFun(x, **options) for x in value]
+
+
+class ChoiceEncoder(SequenceEncoder):
+    pass
+
+
+class AnyEncoder(AbstractItemEncoder):
+    def encode(self, value, encodeFun, **options):
+        return value.asOctets()
+
+
+tagMap = {
+    univ.Boolean.tagSet: BooleanEncoder(),
+    univ.Integer.tagSet: IntegerEncoder(),
+    univ.BitString.tagSet: BitStringEncoder(),
+    univ.OctetString.tagSet: OctetStringEncoder(),
+    univ.Null.tagSet: NullEncoder(),
+    univ.ObjectIdentifier.tagSet: ObjectIdentifierEncoder(),
+    univ.Enumerated.tagSet: IntegerEncoder(),
+    univ.Real.tagSet: RealEncoder(),
+    # Sequence & Set have same tags as SequenceOf & SetOf
+    univ.SequenceOf.tagSet: SequenceOfEncoder(),
+    univ.SetOf.tagSet: SequenceOfEncoder(),
+    univ.Choice.tagSet: ChoiceEncoder(),
+    # character string types
+    char.UTF8String.tagSet: TextStringEncoder(),
+    char.NumericString.tagSet: TextStringEncoder(),
+    char.PrintableString.tagSet: TextStringEncoder(),
+    char.TeletexString.tagSet: TextStringEncoder(),
+    char.VideotexString.tagSet: TextStringEncoder(),
+    char.IA5String.tagSet: TextStringEncoder(),
+    char.GraphicString.tagSet: TextStringEncoder(),
+    char.VisibleString.tagSet: TextStringEncoder(),
+    char.GeneralString.tagSet: TextStringEncoder(),
+    char.UniversalString.tagSet: TextStringEncoder(),
+    char.BMPString.tagSet: TextStringEncoder(),
+    # useful types
+    useful.ObjectDescriptor.tagSet: OctetStringEncoder(),
+    useful.GeneralizedTime.tagSet: OctetStringEncoder(),
+    useful.UTCTime.tagSet: OctetStringEncoder()
+}
+
+
+# Put in ambiguous & non-ambiguous types for faster codec lookup
+typeMap = {
+    univ.Boolean.typeId: BooleanEncoder(),
+    univ.Integer.typeId: IntegerEncoder(),
+    univ.BitString.typeId: BitStringEncoder(),
+    univ.OctetString.typeId: OctetStringEncoder(),
+    univ.Null.typeId: NullEncoder(),
+    univ.ObjectIdentifier.typeId: ObjectIdentifierEncoder(),
+    univ.Enumerated.typeId: IntegerEncoder(),
+    univ.Real.typeId: RealEncoder(),
+    # Sequence & Set have same tags as SequenceOf & SetOf
+    univ.Set.typeId: SetEncoder(),
+    univ.SetOf.typeId: SequenceOfEncoder(),
+    univ.Sequence.typeId: SequenceEncoder(),
+    univ.SequenceOf.typeId: SequenceOfEncoder(),
+    univ.Choice.typeId: ChoiceEncoder(),
+    univ.Any.typeId: AnyEncoder(),
+    # character string types
+    char.UTF8String.typeId: OctetStringEncoder(),
+    char.NumericString.typeId: OctetStringEncoder(),
+    char.PrintableString.typeId: OctetStringEncoder(),
+    char.TeletexString.typeId: OctetStringEncoder(),
+    char.VideotexString.typeId: OctetStringEncoder(),
+    char.IA5String.typeId: OctetStringEncoder(),
+    char.GraphicString.typeId: OctetStringEncoder(),
+    char.VisibleString.typeId: OctetStringEncoder(),
+    char.GeneralString.typeId: OctetStringEncoder(),
+    char.UniversalString.typeId: OctetStringEncoder(),
+    char.BMPString.typeId: OctetStringEncoder(),
+    # useful types
+    useful.ObjectDescriptor.typeId: OctetStringEncoder(),
+    useful.GeneralizedTime.typeId: OctetStringEncoder(),
+    useful.UTCTime.typeId: OctetStringEncoder()
+}
+
+
+class Encoder(object):
+
+    # noinspection PyDefaultArgument
+    def __init__(self, tagMap, typeMap={}):
+        self.__tagMap = tagMap
+        self.__typeMap = typeMap
+
+    def __call__(self, value, **options):
+        if not isinstance(value, base.Asn1Item):
+            raise error.PyAsn1Error('value is not valid (should be an instance of an ASN.1 Item)')
+
+        if LOG:
+            debug.scope.push(type(value).__name__)
+            LOG('encoder called for type %s <%s>' % (type(value).__name__, value.prettyPrint()))
+
+        tagSet = value.tagSet
+
+        try:
+            concreteEncoder = self.__typeMap[value.typeId]
+
+        except KeyError:
+            # use base type for codec lookup to recover untagged types
+            baseTagSet = tag.TagSet(value.tagSet.baseTag, value.tagSet.baseTag)
+
+            try:
+                concreteEncoder = self.__tagMap[baseTagSet]
+
+            except KeyError:
+                raise error.PyAsn1Error('No encoder for %s' % (value,))
+
+        if LOG:
+            LOG('using value codec %s chosen by %s' % (concreteEncoder.__class__.__name__, tagSet))
+
+        pyObject = concreteEncoder.encode(value, self, **options)
+
+        if LOG:
+            LOG('encoder %s produced: %s' % (type(concreteEncoder).__name__, repr(pyObject)))
+            debug.scope.pop()
+
+        return pyObject
+
+
+#: Turns ASN.1 object into a Python built-in type object(s).
+#:
+#: Takes any ASN.1 object (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative)
+#: walks all its components recursively and produces a Python built-in type or a tree
+#: of those.
+#:
+#: One exception is that instead of :py:class:`dict`, the :py:class:`OrderedDict`
+#: can be produced (whenever available) to preserve ordering of the components
+#: in ASN.1 SEQUENCE.
+#:
+#: Parameters
+#: ----------
+#  asn1Value: any pyasn1 object (e.g. :py:class:`~pyasn1.type.base.PyAsn1Item` derivative)
+#:     pyasn1 object to encode (or a tree of them)
+#:
+#: Returns
+#: -------
+#: : :py:class:`object`
+#:     Python built-in type instance (or a tree of them)
+#:
+#: Raises
+#: ------
+#: ~pyasn1.error.PyAsn1Error
+#:     On encoding errors
+#:
+#: Examples
+#: --------
+#: Encode ASN.1 value object into native Python types
+#:
+#: .. code-block:: pycon
+#:
+#:    >>> seq = SequenceOf(componentType=Integer())
+#:    >>> seq.extend([1, 2, 3])
+#:    >>> encode(seq)
+#:    [1, 2, 3]
+#:
+encode = Encoder(tagMap, typeMap)
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/compat/__init__.py b/myenv/lib/python3.9/site-packages/pyasn1/compat/__init__.py
new file mode 100644
index 0000000..8c3066b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/compat/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/compat/binary.py b/myenv/lib/python3.9/site-packages/pyasn1/compat/binary.py
new file mode 100644
index 0000000..addbdc9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/compat/binary.py
@@ -0,0 +1,33 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from sys import version_info
+
+if version_info[0:2] < (2, 6):
+    def bin(value):
+        bitstring = []
+
+        if value > 0:
+            prefix = '0b'
+        elif value < 0:
+            prefix = '-0b'
+            value = abs(value)
+        else:
+            prefix = '0b0'
+
+        while value:
+            if value & 1 == 1:
+                bitstring.append('1')
+            else:
+                bitstring.append('0')
+
+            value >>= 1
+
+        bitstring.reverse()
+
+        return prefix + ''.join(bitstring)
+else:
+    bin = bin
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/compat/calling.py b/myenv/lib/python3.9/site-packages/pyasn1/compat/calling.py
new file mode 100644
index 0000000..778a3d1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/compat/calling.py
@@ -0,0 +1,20 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from sys import version_info
+
+__all__ = ['callable']
+
+
+if (2, 7) < version_info[:2] < (3, 2):
+    import collections
+
+    def callable(x):
+        return isinstance(x, collections.Callable)
+
+else:
+
+    callable = callable
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/compat/dateandtime.py b/myenv/lib/python3.9/site-packages/pyasn1/compat/dateandtime.py
new file mode 100644
index 0000000..5e471bf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/compat/dateandtime.py
@@ -0,0 +1,22 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import time
+from datetime import datetime
+from sys import version_info
+
+__all__ = ['strptime']
+
+
+if version_info[:2] <= (2, 4):
+
+    def strptime(text, dateFormat):
+        return datetime(*(time.strptime(text, dateFormat)[0:6]))
+
+else:
+
+    def strptime(text, dateFormat):
+        return datetime.strptime(text, dateFormat)
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/compat/integer.py b/myenv/lib/python3.9/site-packages/pyasn1/compat/integer.py
new file mode 100644
index 0000000..4b31791
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/compat/integer.py
@@ -0,0 +1,110 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+
+try:
+    import platform
+
+    implementation = platform.python_implementation()
+
+except (ImportError, AttributeError):
+    implementation = 'CPython'
+
+from pyasn1.compat.octets import oct2int, null, ensureString
+
+if sys.version_info[0:2] < (3, 2) or implementation != 'CPython':
+    from binascii import a2b_hex, b2a_hex
+
+    if sys.version_info[0] > 2:
+        long = int
+
+    def from_bytes(octets, signed=False):
+        if not octets:
+            return 0
+
+        value = long(b2a_hex(ensureString(octets)), 16)
+
+        if signed and oct2int(octets[0]) & 0x80:
+            return value - (1 << len(octets) * 8)
+
+        return value
+
+    def to_bytes(value, signed=False, length=0):
+        if value < 0:
+            if signed:
+                bits = bitLength(value)
+
+                # two's complement form
+                maxValue = 1 << bits
+                valueToEncode = (value + maxValue) % maxValue
+
+            else:
+                raise OverflowError('can\'t convert negative int to unsigned')
+        elif value == 0 and length == 0:
+            return null
+        else:
+            bits = 0
+            valueToEncode = value
+
+        hexValue = hex(valueToEncode)[2:]
+        if hexValue.endswith('L'):
+            hexValue = hexValue[:-1]
+
+        if len(hexValue) & 1:
+            hexValue = '0' + hexValue
+
+        # padding may be needed for two's complement encoding
+        if value != valueToEncode or length:
+            hexLength = len(hexValue) * 4
+
+            padLength = max(length, bits)
+
+            if padLength > hexLength:
+                hexValue = '00' * ((padLength - hexLength - 1) // 8 + 1) + hexValue
+            elif length and hexLength - length > 7:
+                raise OverflowError('int too big to convert')
+
+        firstOctet = int(hexValue[:2], 16)
+
+        if signed:
+            if firstOctet & 0x80:
+                if value >= 0:
+                    hexValue = '00' + hexValue
+            elif value < 0:
+                hexValue = 'ff' + hexValue
+
+        octets_value = a2b_hex(hexValue)
+
+        return octets_value
+
+    def bitLength(number):
+        # bits in unsigned number
+        hexValue = hex(abs(number))
+        bits = len(hexValue) - 2
+        if hexValue.endswith('L'):
+            bits -= 1
+        if bits & 1:
+            bits += 1
+        bits *= 4
+        # TODO: strip lhs zeros
+        return bits
+
+else:
+
+    def from_bytes(octets, signed=False):
+        return int.from_bytes(bytes(octets), 'big', signed=signed)
+
+    def to_bytes(value, signed=False, length=0):
+        length = max(value.bit_length(), length)
+
+        if signed and length % 8 == 0:
+            length += 1
+
+        return value.to_bytes(length // 8 + (length % 8 and 1 or 0), 'big', signed=signed)
+
+    def bitLength(number):
+        return int(number).bit_length()
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/compat/octets.py b/myenv/lib/python3.9/site-packages/pyasn1/compat/octets.py
new file mode 100644
index 0000000..99d23bb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/compat/octets.py
@@ -0,0 +1,46 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from sys import version_info
+
+if version_info[0] <= 2:
+    int2oct = chr
+    # noinspection PyPep8
+    ints2octs = lambda s: ''.join([int2oct(x) for x in s])
+    null = ''
+    oct2int = ord
+    # TODO: refactor to return a sequence of ints
+    # noinspection PyPep8
+    octs2ints = lambda s: [oct2int(x) for x in s]
+    # noinspection PyPep8
+    str2octs = lambda x: x
+    # noinspection PyPep8
+    octs2str = lambda x: x
+    # noinspection PyPep8
+    isOctetsType = lambda s: isinstance(s, str)
+    # noinspection PyPep8
+    isStringType = lambda s: isinstance(s, (str, unicode))
+    # noinspection PyPep8
+    ensureString = str
+else:
+    ints2octs = bytes
+    # noinspection PyPep8
+    int2oct = lambda x: ints2octs((x,))
+    null = ints2octs()
+    # noinspection PyPep8
+    oct2int = lambda x: x
+    # noinspection PyPep8
+    octs2ints = lambda x: x
+    # noinspection PyPep8
+    str2octs = lambda x: x.encode('iso-8859-1')
+    # noinspection PyPep8
+    octs2str = lambda x: x.decode('iso-8859-1')
+    # noinspection PyPep8
+    isOctetsType = lambda s: isinstance(s, bytes)
+    # noinspection PyPep8
+    isStringType = lambda s: isinstance(s, str)
+    # noinspection PyPep8
+    ensureString = bytes
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/compat/string.py b/myenv/lib/python3.9/site-packages/pyasn1/compat/string.py
new file mode 100644
index 0000000..b9bc8c3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/compat/string.py
@@ -0,0 +1,26 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from sys import version_info
+
+if version_info[:2] <= (2, 5):
+
+    def partition(string, sep):
+        try:
+            a, c = string.split(sep, 1)
+
+        except ValueError:
+            a, b, c = string, '', ''
+
+        else:
+            b = sep
+
+        return a, b, c
+
+else:
+
+    def partition(string, sep):
+        return string.partition(sep)
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/debug.py b/myenv/lib/python3.9/site-packages/pyasn1/debug.py
new file mode 100644
index 0000000..8707aa8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/debug.py
@@ -0,0 +1,157 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import logging
+import sys
+
+from pyasn1 import __version__
+from pyasn1 import error
+from pyasn1.compat.octets import octs2ints
+
+__all__ = ['Debug', 'setLogger', 'hexdump']
+
+DEBUG_NONE = 0x0000
+DEBUG_ENCODER = 0x0001
+DEBUG_DECODER = 0x0002
+DEBUG_ALL = 0xffff
+
+FLAG_MAP = {
+    'none': DEBUG_NONE,
+    'encoder': DEBUG_ENCODER,
+    'decoder': DEBUG_DECODER,
+    'all': DEBUG_ALL
+}
+
+LOGGEE_MAP = {}
+
+
+class Printer(object):
+    # noinspection PyShadowingNames
+    def __init__(self, logger=None, handler=None, formatter=None):
+        if logger is None:
+            logger = logging.getLogger('pyasn1')
+
+        logger.setLevel(logging.DEBUG)
+
+        if handler is None:
+            handler = logging.StreamHandler()
+
+        if formatter is None:
+            formatter = logging.Formatter('%(asctime)s %(name)s: %(message)s')
+
+        handler.setFormatter(formatter)
+        handler.setLevel(logging.DEBUG)
+        logger.addHandler(handler)
+
+        self.__logger = logger
+
+    def __call__(self, msg):
+        self.__logger.debug(msg)
+
+    def __str__(self):
+        return '<python logging>'
+
+
+if hasattr(logging, 'NullHandler'):
+    NullHandler = logging.NullHandler
+
+else:
+    # Python 2.6 and older
+    class NullHandler(logging.Handler):
+        def emit(self, record):
+            pass
+
+
+class Debug(object):
+    defaultPrinter = Printer()
+
+    def __init__(self, *flags, **options):
+        self._flags = DEBUG_NONE
+
+        if 'loggerName' in options:
+            # route our logs to parent logger
+            self._printer = Printer(
+                logger=logging.getLogger(options['loggerName']),
+                handler=NullHandler()
+            )
+
+        elif 'printer' in options:
+            self._printer = options.get('printer')
+
+        else:
+            self._printer = self.defaultPrinter
+
+        self._printer('running pyasn1 %s, debug flags %s' % (__version__, ', '.join(flags)))
+
+        for flag in flags:
+            inverse = flag and flag[0] in ('!', '~')
+            if inverse:
+                flag = flag[1:]
+            try:
+                if inverse:
+                    self._flags &= ~FLAG_MAP[flag]
+                else:
+                    self._flags |= FLAG_MAP[flag]
+            except KeyError:
+                raise error.PyAsn1Error('bad debug flag %s' % flag)
+
+            self._printer("debug category '%s' %s" % (flag, inverse and 'disabled' or 'enabled'))
+
+    def __str__(self):
+        return 'logger %s, flags %x' % (self._printer, self._flags)
+
+    def __call__(self, msg):
+        self._printer(msg)
+
+    def __and__(self, flag):
+        return self._flags & flag
+
+    def __rand__(self, flag):
+        return flag & self._flags
+
+_LOG = DEBUG_NONE
+
+
+def setLogger(userLogger):
+    global _LOG
+
+    if userLogger:
+        _LOG = userLogger
+    else:
+        _LOG = DEBUG_NONE
+
+    # Update registered logging clients
+    for module, (name, flags) in LOGGEE_MAP.items():
+        setattr(module, name, _LOG & flags and _LOG or DEBUG_NONE)
+
+
+def registerLoggee(module, name='LOG', flags=DEBUG_NONE):
+    LOGGEE_MAP[sys.modules[module]] = name, flags
+    setLogger(_LOG)
+    return _LOG
+
+
+def hexdump(octets):
+    return ' '.join(
+        ['%s%.2X' % (n % 16 == 0 and ('\n%.5d: ' % n) or '', x)
+         for n, x in zip(range(len(octets)), octs2ints(octets))]
+    )
+
+
+class Scope(object):
+    def __init__(self):
+        self._list = []
+
+    def __str__(self): return '.'.join(self._list)
+
+    def push(self, token):
+        self._list.append(token)
+
+    def pop(self):
+        return self._list.pop()
+
+
+scope = Scope()
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/error.py b/myenv/lib/python3.9/site-packages/pyasn1/error.py
new file mode 100644
index 0000000..4f48db2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/error.py
@@ -0,0 +1,75 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+
+
+class PyAsn1Error(Exception):
+    """Base pyasn1 exception
+
+    `PyAsn1Error` is the base exception class (based on
+    :class:`Exception`) that represents all possible ASN.1 related
+    errors.
+    """
+
+
+class ValueConstraintError(PyAsn1Error):
+    """ASN.1 type constraints violation exception
+
+    The `ValueConstraintError` exception indicates an ASN.1 value
+    constraint violation.
+
+    It might happen on value object instantiation (for scalar types) or on
+    serialization (for constructed types).
+    """
+
+
+class SubstrateUnderrunError(PyAsn1Error):
+    """ASN.1 data structure deserialization error
+
+    The `SubstrateUnderrunError` exception indicates insufficient serialised
+    data on input of a de-serialization codec.
+    """
+
+
+class PyAsn1UnicodeError(PyAsn1Error, UnicodeError):
+    """Unicode text processing error
+
+    The `PyAsn1UnicodeError` exception is a base class for errors relating to
+    unicode text de/serialization.
+
+    Apart from inheriting from :class:`PyAsn1Error`, it also inherits from
+    :class:`UnicodeError` to help the caller catching unicode-related errors.
+    """
+    def __init__(self, message, unicode_error=None):
+        if isinstance(unicode_error, UnicodeError):
+            UnicodeError.__init__(self, *unicode_error.args)
+        PyAsn1Error.__init__(self, message)
+
+
+class PyAsn1UnicodeDecodeError(PyAsn1UnicodeError, UnicodeDecodeError):
+    """Unicode text decoding error
+
+    The `PyAsn1UnicodeDecodeError` exception represents a failure to
+    deserialize unicode text.
+
+    Apart from inheriting from :class:`PyAsn1UnicodeError`, it also inherits
+    from :class:`UnicodeDecodeError` to help the caller catching unicode-related
+    errors.
+    """
+
+
+class PyAsn1UnicodeEncodeError(PyAsn1UnicodeError, UnicodeEncodeError):
+    """Unicode text encoding error
+
+    The `PyAsn1UnicodeEncodeError` exception represents a failure to
+    serialize unicode text.
+
+    Apart from inheriting from :class:`PyAsn1UnicodeError`, it also inherits
+    from :class:`UnicodeEncodeError` to help the caller catching
+    unicode-related errors.
+    """
+
+
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/__init__.py b/myenv/lib/python3.9/site-packages/pyasn1/type/__init__.py
new file mode 100644
index 0000000..8c3066b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/base.py b/myenv/lib/python3.9/site-packages/pyasn1/type/base.py
new file mode 100644
index 0000000..994f1c9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/base.py
@@ -0,0 +1,707 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+
+from pyasn1 import error
+from pyasn1.compat import calling
+from pyasn1.type import constraint
+from pyasn1.type import tag
+from pyasn1.type import tagmap
+
+__all__ = ['Asn1Item', 'Asn1Type', 'SimpleAsn1Type',
+           'ConstructedAsn1Type']
+
+
+class Asn1Item(object):
+    @classmethod
+    def getTypeId(cls, increment=1):
+        try:
+            Asn1Item._typeCounter += increment
+        except AttributeError:
+            Asn1Item._typeCounter = increment
+        return Asn1Item._typeCounter
+
+
+class Asn1Type(Asn1Item):
+    """Base class for all classes representing ASN.1 types.
+
+    In the user code, |ASN.1| class is normally used only for telling
+    ASN.1 objects from others.
+
+    Note
+    ----
+    For as long as ASN.1 is concerned, a way to compare ASN.1 types
+    is to use :meth:`isSameTypeWith` and :meth:`isSuperTypeOf` methods.
+    """
+    #: Set or return a :py:class:`~pyasn1.type.tag.TagSet` object representing
+    #: ASN.1 tag(s) associated with |ASN.1| type.
+    tagSet = tag.TagSet()
+
+    #: Default :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+    #: object imposing constraints on initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    # Disambiguation ASN.1 types identification
+    typeId = None
+
+    def __init__(self, **kwargs):
+        readOnly = {
+            'tagSet': self.tagSet,
+            'subtypeSpec': self.subtypeSpec
+        }
+
+        readOnly.update(kwargs)
+
+        self.__dict__.update(readOnly)
+
+        self._readOnly = readOnly
+
+    def __setattr__(self, name, value):
+        if name[0] != '_' and name in self._readOnly:
+            raise error.PyAsn1Error('read-only instance attribute "%s"' % name)
+
+        self.__dict__[name] = value
+
+    def __str__(self):
+        return self.prettyPrint()
+
+    @property
+    def readOnly(self):
+        return self._readOnly
+
+    @property
+    def effectiveTagSet(self):
+        """For |ASN.1| type is equivalent to *tagSet*
+        """
+        return self.tagSet  # used by untagged types
+
+    @property
+    def tagMap(self):
+        """Return a :class:`~pyasn1.type.tagmap.TagMap` object mapping ASN.1 tags to ASN.1 objects within callee object.
+        """
+        return tagmap.TagMap({self.tagSet: self})
+
+    def isSameTypeWith(self, other, matchTags=True, matchConstraints=True):
+        """Examine |ASN.1| type for equality with other ASN.1 type.
+
+        ASN.1 tags (:py:mod:`~pyasn1.type.tag`) and constraints
+        (:py:mod:`~pyasn1.type.constraint`) are examined when carrying
+        out ASN.1 types comparison.
+
+        Python class inheritance relationship is NOT considered.
+
+        Parameters
+        ----------
+        other: a pyasn1 type object
+            Class instance representing ASN.1 type.
+
+        Returns
+        -------
+        : :class:`bool`
+            :obj:`True` if *other* is |ASN.1| type,
+            :obj:`False` otherwise.
+        """
+        return (self is other or
+                (not matchTags or self.tagSet == other.tagSet) and
+                (not matchConstraints or self.subtypeSpec == other.subtypeSpec))
+
+    def isSuperTypeOf(self, other, matchTags=True, matchConstraints=True):
+        """Examine |ASN.1| type for subtype relationship with other ASN.1 type.
+
+        ASN.1 tags (:py:mod:`~pyasn1.type.tag`) and constraints
+        (:py:mod:`~pyasn1.type.constraint`) are examined when carrying
+        out ASN.1 types comparison.
+
+        Python class inheritance relationship is NOT considered.
+
+        Parameters
+        ----------
+            other: a pyasn1 type object
+                Class instance representing ASN.1 type.
+
+        Returns
+        -------
+            : :class:`bool`
+                :obj:`True` if *other* is a subtype of |ASN.1| type,
+                :obj:`False` otherwise.
+        """
+        return (not matchTags or
+                (self.tagSet.isSuperTagSetOf(other.tagSet)) and
+                 (not matchConstraints or self.subtypeSpec.isSuperTypeOf(other.subtypeSpec)))
+
+    @staticmethod
+    def isNoValue(*values):
+        for value in values:
+            if value is not noValue:
+                return False
+        return True
+
+    def prettyPrint(self, scope=0):
+        raise NotImplementedError()
+
+    # backward compatibility
+
+    def getTagSet(self):
+        return self.tagSet
+
+    def getEffectiveTagSet(self):
+        return self.effectiveTagSet
+
+    def getTagMap(self):
+        return self.tagMap
+
+    def getSubtypeSpec(self):
+        return self.subtypeSpec
+
+    # backward compatibility
+    def hasValue(self):
+        return self.isValue
+
+# Backward compatibility
+Asn1ItemBase = Asn1Type
+
+
+class NoValue(object):
+    """Create a singleton instance of NoValue class.
+
+    The *NoValue* sentinel object represents an instance of ASN.1 schema
+    object as opposed to ASN.1 value object.
+
+    Only ASN.1 schema-related operations can be performed on ASN.1
+    schema objects.
+
+    Warning
+    -------
+    Any operation attempted on the *noValue* object will raise the
+    *PyAsn1Error* exception.
+    """
+    skipMethods = set(
+        ('__slots__',
+         # attributes
+         '__getattribute__',
+         '__getattr__',
+         '__setattr__',
+         '__delattr__',
+         # class instance
+         '__class__',
+         '__init__',
+         '__del__',
+         '__new__',
+         '__repr__',
+         '__qualname__',
+         '__objclass__',
+         'im_class',
+         '__sizeof__',
+         # pickle protocol
+         '__reduce__',
+         '__reduce_ex__',
+         '__getnewargs__',
+         '__getinitargs__',
+         '__getstate__',
+         '__setstate__')
+    )
+
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            def getPlug(name):
+                def plug(self, *args, **kw):
+                    raise error.PyAsn1Error('Attempted "%s" operation on ASN.1 schema object' % name)
+                return plug
+
+            op_names = [name
+                        for typ in (str, int, list, dict)
+                        for name in dir(typ)
+                        if (name not in cls.skipMethods and
+                            name.startswith('__') and
+                            name.endswith('__') and
+                            calling.callable(getattr(typ, name)))]
+
+            for name in set(op_names):
+                setattr(cls, name, getPlug(name))
+
+            cls._instance = object.__new__(cls)
+
+        return cls._instance
+
+    def __getattr__(self, attr):
+        if attr in self.skipMethods:
+            raise AttributeError('Attribute %s not present' % attr)
+
+        raise error.PyAsn1Error('Attempted "%s" operation on ASN.1 schema object' % attr)
+
+    def __repr__(self):
+        return '<%s object>' % self.__class__.__name__
+
+
+noValue = NoValue()
+
+
+class SimpleAsn1Type(Asn1Type):
+    """Base class for all simple classes representing ASN.1 types.
+
+    ASN.1 distinguishes types by their ability to hold other objects.
+    Scalar types are known as *simple* in ASN.1.
+
+    In the user code, |ASN.1| class is normally used only for telling
+    ASN.1 objects from others.
+
+    Note
+    ----
+    For as long as ASN.1 is concerned, a way to compare ASN.1 types
+    is to use :meth:`isSameTypeWith` and :meth:`isSuperTypeOf` methods.
+    """
+    #: Default payload value
+    defaultValue = noValue
+
+    def __init__(self, value=noValue, **kwargs):
+        Asn1Type.__init__(self, **kwargs)
+        if value is noValue:
+            value = self.defaultValue
+        else:
+            value = self.prettyIn(value)
+            try:
+                self.subtypeSpec(value)
+
+            except error.PyAsn1Error:
+                exType, exValue, exTb = sys.exc_info()
+                raise exType('%s at %s' % (exValue, self.__class__.__name__))
+
+        self._value = value
+
+    def __repr__(self):
+        representation = '%s %s object' % (
+            self.__class__.__name__, self.isValue and 'value' or 'schema')
+
+        for attr, value in self.readOnly.items():
+            if value:
+                representation += ', %s %s' % (attr, value)
+
+        if self.isValue:
+            value = self.prettyPrint()
+            if len(value) > 32:
+                value = value[:16] + '...' + value[-16:]
+            representation += ', payload [%s]' % value
+
+        return '<%s>' % representation
+
+    def __eq__(self, other):
+        return self is other and True or self._value == other
+
+    def __ne__(self, other):
+        return self._value != other
+
+    def __lt__(self, other):
+        return self._value < other
+
+    def __le__(self, other):
+        return self._value <= other
+
+    def __gt__(self, other):
+        return self._value > other
+
+    def __ge__(self, other):
+        return self._value >= other
+
+    if sys.version_info[0] <= 2:
+        def __nonzero__(self):
+            return self._value and True or False
+    else:
+        def __bool__(self):
+            return self._value and True or False
+
+    def __hash__(self):
+        return hash(self._value)
+
+    @property
+    def isValue(self):
+        """Indicate that |ASN.1| object represents ASN.1 value.
+
+        If *isValue* is :obj:`False` then this object represents just
+        ASN.1 schema.
+
+        If *isValue* is :obj:`True` then, in addition to its ASN.1 schema
+        features, this object can also be used like a Python built-in object
+        (e.g. :class:`int`, :class:`str`, :class:`dict` etc.).
+
+        Returns
+        -------
+        : :class:`bool`
+            :obj:`False` if object represents just ASN.1 schema.
+            :obj:`True` if object represents ASN.1 schema and can be used as a normal value.
+
+        Note
+        ----
+        There is an important distinction between PyASN1 schema and value objects.
+        The PyASN1 schema objects can only participate in ASN.1 schema-related
+        operations (e.g. defining or testing the structure of the data). Most
+        obvious uses of ASN.1 schema is to guide serialisation codecs whilst
+        encoding/decoding serialised ASN.1 contents.
+
+        The PyASN1 value objects can **additionally** participate in many operations
+        involving regular Python objects (e.g. arithmetic, comprehension etc).
+        """
+        return self._value is not noValue
+
+    def clone(self, value=noValue, **kwargs):
+        """Create a modified version of |ASN.1| schema or value object.
+
+        The `clone()` method accepts the same set arguments as |ASN.1|
+        class takes on instantiation except that all arguments
+        of the `clone()` method are optional.
+
+        Whatever arguments are supplied, they are used to create a copy
+        of `self` taking precedence over the ones used to instantiate `self`.
+
+        Note
+        ----
+        Due to the immutable nature of the |ASN.1| object, if no arguments
+        are supplied, no new |ASN.1| object will be created and `self` will
+        be returned instead.
+        """
+        if value is noValue:
+            if not kwargs:
+                return self
+
+            value = self._value
+
+        initializers = self.readOnly.copy()
+        initializers.update(kwargs)
+
+        return self.__class__(value, **initializers)
+
+    def subtype(self, value=noValue, **kwargs):
+        """Create a specialization of |ASN.1| schema or value object.
+
+        The subtype relationship between ASN.1 types has no correlation with
+        subtype relationship between Python types. ASN.1 type is mainly identified
+        by its tag(s) (:py:class:`~pyasn1.type.tag.TagSet`) and value range
+        constraints (:py:class:`~pyasn1.type.constraint.ConstraintsIntersection`).
+        These ASN.1 type properties are implemented as |ASN.1| attributes.  
+
+        The `subtype()` method accepts the same set arguments as |ASN.1|
+        class takes on instantiation except that all parameters
+        of the `subtype()` method are optional.
+
+        With the exception of the arguments described below, the rest of
+        supplied arguments they are used to create a copy of `self` taking
+        precedence over the ones used to instantiate `self`.
+
+        The following arguments to `subtype()` create a ASN.1 subtype out of
+        |ASN.1| type:
+
+        Other Parameters
+        ----------------
+        implicitTag: :py:class:`~pyasn1.type.tag.Tag`
+            Implicitly apply given ASN.1 tag object to `self`'s
+            :py:class:`~pyasn1.type.tag.TagSet`, then use the result as
+            new object's ASN.1 tag(s).
+
+        explicitTag: :py:class:`~pyasn1.type.tag.Tag`
+            Explicitly apply given ASN.1 tag object to `self`'s
+            :py:class:`~pyasn1.type.tag.TagSet`, then use the result as
+            new object's ASN.1 tag(s).
+
+        subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+            Add ASN.1 constraints object to one of the `self`'s, then
+            use the result as new object's ASN.1 constraints.
+
+        Returns
+        -------
+        :
+            new instance of |ASN.1| schema or value object
+
+        Note
+        ----
+        Due to the immutable nature of the |ASN.1| object, if no arguments
+        are supplied, no new |ASN.1| object will be created and `self` will
+        be returned instead.
+        """
+        if value is noValue:
+            if not kwargs:
+                return self
+
+            value = self._value
+
+        initializers = self.readOnly.copy()
+
+        implicitTag = kwargs.pop('implicitTag', None)
+        if implicitTag is not None:
+            initializers['tagSet'] = self.tagSet.tagImplicitly(implicitTag)
+
+        explicitTag = kwargs.pop('explicitTag', None)
+        if explicitTag is not None:
+            initializers['tagSet'] = self.tagSet.tagExplicitly(explicitTag)
+
+        for arg, option in kwargs.items():
+            initializers[arg] += option
+
+        return self.__class__(value, **initializers)
+
+    def prettyIn(self, value):
+        return value
+
+    def prettyOut(self, value):
+        return str(value)
+
+    def prettyPrint(self, scope=0):
+        return self.prettyOut(self._value)
+
+    def prettyPrintType(self, scope=0):
+        return '%s -> %s' % (self.tagSet, self.__class__.__name__)
+
+# Backward compatibility
+AbstractSimpleAsn1Item = SimpleAsn1Type
+
+#
+# Constructed types:
+# * There are five of them: Sequence, SequenceOf/SetOf, Set and Choice
+# * ASN1 types and values are represened by Python class instances
+# * Value initialization is made for defaulted components only
+# * Primary method of component addressing is by-position. Data model for base
+#   type is Python sequence. Additional type-specific addressing methods
+#   may be implemented for particular types.
+# * SequenceOf and SetOf types do not implement any additional methods
+# * Sequence, Set and Choice types also implement by-identifier addressing
+# * Sequence, Set and Choice types also implement by-asn1-type (tag) addressing
+# * Sequence and Set types may include optional and defaulted
+#   components
+# * Constructed types hold a reference to component types used for value
+#   verification and ordering.
+# * Component type is a scalar type for SequenceOf/SetOf types and a list
+#   of types for Sequence/Set/Choice.
+#
+
+
+class ConstructedAsn1Type(Asn1Type):
+    """Base class for all constructed classes representing ASN.1 types.
+
+    ASN.1 distinguishes types by their ability to hold other objects.
+    Those "nesting" types are known as *constructed* in ASN.1.
+
+    In the user code, |ASN.1| class is normally used only for telling
+    ASN.1 objects from others.
+
+    Note
+    ----
+    For as long as ASN.1 is concerned, a way to compare ASN.1 types
+    is to use :meth:`isSameTypeWith` and :meth:`isSuperTypeOf` methods.
+    """
+
+    #: If :obj:`True`, requires exact component type matching,
+    #: otherwise subtype relation is only enforced
+    strictConstraints = False
+
+    componentType = None
+
+    # backward compatibility, unused
+    sizeSpec = constraint.ConstraintsIntersection()
+
+    def __init__(self, **kwargs):
+        readOnly = {
+            'componentType': self.componentType,
+            # backward compatibility, unused
+            'sizeSpec': self.sizeSpec
+        }
+
+        # backward compatibility: preserve legacy sizeSpec support
+        kwargs = self._moveSizeSpec(**kwargs)
+
+        readOnly.update(kwargs)
+
+        Asn1Type.__init__(self, **readOnly)
+
+    def _moveSizeSpec(self, **kwargs):
+        # backward compatibility, unused
+        sizeSpec = kwargs.pop('sizeSpec', self.sizeSpec)
+        if sizeSpec:
+            subtypeSpec = kwargs.pop('subtypeSpec', self.subtypeSpec)
+            if subtypeSpec:
+                subtypeSpec = sizeSpec
+
+            else:
+                subtypeSpec += sizeSpec
+
+            kwargs['subtypeSpec'] = subtypeSpec
+
+        return kwargs
+
+    def __repr__(self):
+        representation = '%s %s object' % (
+            self.__class__.__name__, self.isValue and 'value' or 'schema'
+        )
+
+        for attr, value in self.readOnly.items():
+            if value is not noValue:
+                representation += ', %s=%r' % (attr, value)
+
+        if self.isValue and self.components:
+            representation += ', payload [%s]' % ', '.join(
+                [repr(x) for x in self.components])
+
+        return '<%s>' % representation
+
+    def __eq__(self, other):
+        return self is other or self.components == other
+
+    def __ne__(self, other):
+        return self.components != other
+
+    def __lt__(self, other):
+        return self.components < other
+
+    def __le__(self, other):
+        return self.components <= other
+
+    def __gt__(self, other):
+        return self.components > other
+
+    def __ge__(self, other):
+        return self.components >= other
+
+    if sys.version_info[0] <= 2:
+        def __nonzero__(self):
+            return bool(self.components)
+    else:
+        def __bool__(self):
+            return bool(self.components)
+
+    @property
+    def components(self):
+        raise error.PyAsn1Error('Method not implemented')
+
+    def _cloneComponentValues(self, myClone, cloneValueFlag):
+        pass
+
+    def clone(self, **kwargs):
+        """Create a modified version of |ASN.1| schema object.
+
+        The `clone()` method accepts the same set arguments as |ASN.1|
+        class takes on instantiation except that all arguments
+        of the `clone()` method are optional.
+
+        Whatever arguments are supplied, they are used to create a copy
+        of `self` taking precedence over the ones used to instantiate `self`.
+
+        Possible values of `self` are never copied over thus `clone()` can
+        only create a new schema object.
+
+        Returns
+        -------
+        :
+            new instance of |ASN.1| type/value
+
+        Note
+        ----
+        Due to the mutable nature of the |ASN.1| object, even if no arguments
+        are supplied, a new |ASN.1| object will be created and returned.
+        """
+        cloneValueFlag = kwargs.pop('cloneValueFlag', False)
+
+        initializers = self.readOnly.copy()
+        initializers.update(kwargs)
+
+        clone = self.__class__(**initializers)
+
+        if cloneValueFlag:
+            self._cloneComponentValues(clone, cloneValueFlag)
+
+        return clone
+
+    def subtype(self, **kwargs):
+        """Create a specialization of |ASN.1| schema object.
+
+        The `subtype()` method accepts the same set arguments as |ASN.1|
+        class takes on instantiation except that all parameters
+        of the `subtype()` method are optional.
+
+        With the exception of the arguments described below, the rest of
+        supplied arguments they are used to create a copy of `self` taking
+        precedence over the ones used to instantiate `self`.
+
+        The following arguments to `subtype()` create a ASN.1 subtype out of
+        |ASN.1| type.
+
+        Other Parameters
+        ----------------
+        implicitTag: :py:class:`~pyasn1.type.tag.Tag`
+            Implicitly apply given ASN.1 tag object to `self`'s
+            :py:class:`~pyasn1.type.tag.TagSet`, then use the result as
+            new object's ASN.1 tag(s).
+
+        explicitTag: :py:class:`~pyasn1.type.tag.Tag`
+            Explicitly apply given ASN.1 tag object to `self`'s
+            :py:class:`~pyasn1.type.tag.TagSet`, then use the result as
+            new object's ASN.1 tag(s).
+
+        subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+            Add ASN.1 constraints object to one of the `self`'s, then
+            use the result as new object's ASN.1 constraints.
+
+
+        Returns
+        -------
+        :
+            new instance of |ASN.1| type/value
+
+        Note
+        ----
+        Due to the mutable nature of the |ASN.1| object, even if no arguments
+        are supplied, a new |ASN.1| object will be created and returned.
+        """
+
+        initializers = self.readOnly.copy()
+
+        cloneValueFlag = kwargs.pop('cloneValueFlag', False)
+
+        implicitTag = kwargs.pop('implicitTag', None)
+        if implicitTag is not None:
+            initializers['tagSet'] = self.tagSet.tagImplicitly(implicitTag)
+
+        explicitTag = kwargs.pop('explicitTag', None)
+        if explicitTag is not None:
+            initializers['tagSet'] = self.tagSet.tagExplicitly(explicitTag)
+
+        for arg, option in kwargs.items():
+            initializers[arg] += option
+
+        clone = self.__class__(**initializers)
+
+        if cloneValueFlag:
+            self._cloneComponentValues(clone, cloneValueFlag)
+
+        return clone
+
+    def getComponentByPosition(self, idx):
+        raise error.PyAsn1Error('Method not implemented')
+
+    def setComponentByPosition(self, idx, value, verifyConstraints=True):
+        raise error.PyAsn1Error('Method not implemented')
+
+    def setComponents(self, *args, **kwargs):
+        for idx, value in enumerate(args):
+            self[idx] = value
+        for k in kwargs:
+            self[k] = kwargs[k]
+        return self
+
+    # backward compatibility
+
+    def setDefaultComponents(self):
+        pass
+
+    def getComponentType(self):
+        return self.componentType
+
+    # backward compatibility, unused
+    def verifySizeSpec(self):
+        self.subtypeSpec(self)
+
+
+        # Backward compatibility
+AbstractConstructedAsn1Item = ConstructedAsn1Type
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/char.py b/myenv/lib/python3.9/site-packages/pyasn1/type/char.py
new file mode 100644
index 0000000..06074da
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/char.py
@@ -0,0 +1,335 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+
+from pyasn1 import error
+from pyasn1.type import tag
+from pyasn1.type import univ
+
+__all__ = ['NumericString', 'PrintableString', 'TeletexString', 'T61String', 'VideotexString',
+           'IA5String', 'GraphicString', 'VisibleString', 'ISO646String',
+           'GeneralString', 'UniversalString', 'BMPString', 'UTF8String']
+
+NoValue = univ.NoValue
+noValue = univ.noValue
+
+
+class AbstractCharacterString(univ.OctetString):
+    """Creates |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`,
+    its objects are immutable and duck-type Python 2 :class:`str` or Python 3
+    :class:`bytes`. When used in octet-stream context, |ASN.1| type assumes
+    "|encoding|" encoding.
+
+    Keyword Args
+    ------------
+    value: :class:`unicode`, :class:`str`, :class:`bytes` or |ASN.1| object
+        :class:`unicode` object (Python 2) or :class:`str` (Python 3),
+        alternatively :class:`str` (Python 2) or :class:`bytes` (Python 3)
+        representing octet-stream of serialised unicode string
+        (note `encoding` parameter) or |ASN.1| class instance.
+        If `value` is not given, schema object will be created.
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s). Constraints
+        verification for |ASN.1| type occurs automatically on object
+        instantiation.
+
+    encoding: :py:class:`str`
+        Unicode codec ID to encode/decode :class:`unicode` (Python 2) or
+        :class:`str` (Python 3) the payload when |ASN.1| object is used
+        in octet-stream context.
+
+    Raises
+    ------
+    ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error
+        On constraint violation or bad initializer.
+    """
+
+    if sys.version_info[0] <= 2:
+        def __str__(self):
+            try:
+                # `str` is Py2 text representation
+                return self._value.encode(self.encoding)
+
+            except UnicodeEncodeError:
+                exc = sys.exc_info()[1]
+                raise error.PyAsn1UnicodeEncodeError(
+                    "Can't encode string '%s' with codec "
+                    "%s" % (self._value, self.encoding), exc
+                )
+
+        def __unicode__(self):
+            return unicode(self._value)
+
+        def prettyIn(self, value):
+            try:
+                if isinstance(value, unicode):
+                    return value
+                elif isinstance(value, str):
+                    return value.decode(self.encoding)
+                elif isinstance(value, (tuple, list)):
+                    return self.prettyIn(''.join([chr(x) for x in value]))
+                elif isinstance(value, univ.OctetString):
+                    return value.asOctets().decode(self.encoding)
+                else:
+                    return unicode(value)
+
+            except (UnicodeDecodeError, LookupError):
+                exc = sys.exc_info()[1]
+                raise error.PyAsn1UnicodeDecodeError(
+                    "Can't decode string '%s' with codec "
+                    "%s" % (value, self.encoding), exc
+                )
+
+        def asOctets(self, padding=True):
+            return str(self)
+
+        def asNumbers(self, padding=True):
+            return tuple([ord(x) for x in str(self)])
+
+    else:
+        def __str__(self):
+            # `unicode` is Py3 text representation
+            return str(self._value)
+
+        def __bytes__(self):
+            try:
+                return self._value.encode(self.encoding)
+            except UnicodeEncodeError:
+                exc = sys.exc_info()[1]
+                raise error.PyAsn1UnicodeEncodeError(
+                    "Can't encode string '%s' with codec "
+                    "%s" % (self._value, self.encoding), exc
+                )
+
+        def prettyIn(self, value):
+            try:
+                if isinstance(value, str):
+                    return value
+                elif isinstance(value, bytes):
+                    return value.decode(self.encoding)
+                elif isinstance(value, (tuple, list)):
+                    return self.prettyIn(bytes(value))
+                elif isinstance(value, univ.OctetString):
+                    return value.asOctets().decode(self.encoding)
+                else:
+                    return str(value)
+
+            except (UnicodeDecodeError, LookupError):
+                exc = sys.exc_info()[1]
+                raise error.PyAsn1UnicodeDecodeError(
+                    "Can't decode string '%s' with codec "
+                    "%s" % (value, self.encoding), exc
+                )
+
+        def asOctets(self, padding=True):
+            return bytes(self)
+
+        def asNumbers(self, padding=True):
+            return tuple(bytes(self))
+
+    #
+    # See OctetString.prettyPrint() for the explanation
+    #
+
+    def prettyOut(self, value):
+        return value
+
+    def prettyPrint(self, scope=0):
+        # first see if subclass has its own .prettyOut()
+        value = self.prettyOut(self._value)
+
+        if value is not self._value:
+            return value
+
+        return AbstractCharacterString.__str__(self)
+
+    def __reversed__(self):
+        return reversed(self._value)
+
+
+class NumericString(AbstractCharacterString):
+    __doc__ = AbstractCharacterString.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = AbstractCharacterString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 18)
+    )
+    encoding = 'us-ascii'
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+
+class PrintableString(AbstractCharacterString):
+    __doc__ = AbstractCharacterString.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = AbstractCharacterString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 19)
+    )
+    encoding = 'us-ascii'
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+
+class TeletexString(AbstractCharacterString):
+    __doc__ = AbstractCharacterString.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = AbstractCharacterString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 20)
+    )
+    encoding = 'iso-8859-1'
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+
+class T61String(TeletexString):
+    __doc__ = TeletexString.__doc__
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+
+class VideotexString(AbstractCharacterString):
+    __doc__ = AbstractCharacterString.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = AbstractCharacterString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 21)
+    )
+    encoding = 'iso-8859-1'
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+
+class IA5String(AbstractCharacterString):
+    __doc__ = AbstractCharacterString.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = AbstractCharacterString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 22)
+    )
+    encoding = 'us-ascii'
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+
+class GraphicString(AbstractCharacterString):
+    __doc__ = AbstractCharacterString.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = AbstractCharacterString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 25)
+    )
+    encoding = 'iso-8859-1'
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+
+class VisibleString(AbstractCharacterString):
+    __doc__ = AbstractCharacterString.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = AbstractCharacterString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 26)
+    )
+    encoding = 'us-ascii'
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+
+class ISO646String(VisibleString):
+    __doc__ = VisibleString.__doc__
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+class GeneralString(AbstractCharacterString):
+    __doc__ = AbstractCharacterString.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = AbstractCharacterString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 27)
+    )
+    encoding = 'iso-8859-1'
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+
+class UniversalString(AbstractCharacterString):
+    __doc__ = AbstractCharacterString.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = AbstractCharacterString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 28)
+    )
+    encoding = "utf-32-be"
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+
+class BMPString(AbstractCharacterString):
+    __doc__ = AbstractCharacterString.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = AbstractCharacterString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 30)
+    )
+    encoding = "utf-16-be"
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
+
+
+class UTF8String(AbstractCharacterString):
+    __doc__ = AbstractCharacterString.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = AbstractCharacterString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12)
+    )
+    encoding = "utf-8"
+
+    # Optimization for faster codec lookup
+    typeId = AbstractCharacterString.getTypeId()
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/constraint.py b/myenv/lib/python3.9/site-packages/pyasn1/type/constraint.py
new file mode 100644
index 0000000..8f152e9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/constraint.py
@@ -0,0 +1,756 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Original concept and code by Mike C. Fletcher.
+#
+import sys
+
+from pyasn1.type import error
+
+__all__ = ['SingleValueConstraint', 'ContainedSubtypeConstraint',
+           'ValueRangeConstraint', 'ValueSizeConstraint',
+           'PermittedAlphabetConstraint', 'InnerTypeConstraint',
+           'ConstraintsExclusion', 'ConstraintsIntersection',
+           'ConstraintsUnion']
+
+
+class AbstractConstraint(object):
+
+    def __init__(self, *values):
+        self._valueMap = set()
+        self._setValues(values)
+        self.__hash = hash((self.__class__.__name__, self._values))
+
+    def __call__(self, value, idx=None):
+        if not self._values:
+            return
+
+        try:
+            self._testValue(value, idx)
+
+        except error.ValueConstraintError:
+            raise error.ValueConstraintError(
+                '%s failed at: %r' % (self, sys.exc_info()[1])
+            )
+
+    def __repr__(self):
+        representation = '%s object' % (self.__class__.__name__)
+
+        if self._values:
+            representation += ', consts %s' % ', '.join(
+                [repr(x) for x in self._values])
+
+        return '<%s>' % representation
+
+    def __eq__(self, other):
+        return self is other and True or self._values == other
+
+    def __ne__(self, other):
+        return self._values != other
+
+    def __lt__(self, other):
+        return self._values < other
+
+    def __le__(self, other):
+        return self._values <= other
+
+    def __gt__(self, other):
+        return self._values > other
+
+    def __ge__(self, other):
+        return self._values >= other
+
+    if sys.version_info[0] <= 2:
+        def __nonzero__(self):
+            return self._values and True or False
+    else:
+        def __bool__(self):
+            return self._values and True or False
+
+    def __hash__(self):
+        return self.__hash
+
+    def _setValues(self, values):
+        self._values = values
+
+    def _testValue(self, value, idx):
+        raise error.ValueConstraintError(value)
+
+    # Constraints derivation logic
+    def getValueMap(self):
+        return self._valueMap
+
+    def isSuperTypeOf(self, otherConstraint):
+        # TODO: fix possible comparison of set vs scalars here
+        return (otherConstraint is self or
+                not self._values or
+                otherConstraint == self or
+                self in otherConstraint.getValueMap())
+
+    def isSubTypeOf(self, otherConstraint):
+        return (otherConstraint is self or
+                not self or
+                otherConstraint == self or
+                otherConstraint in self._valueMap)
+
+
+class SingleValueConstraint(AbstractConstraint):
+    """Create a SingleValueConstraint object.
+
+    The SingleValueConstraint satisfies any value that
+    is present in the set of permitted values.
+
+    Objects of this type are iterable (emitting constraint values) and
+    can act as operands for some arithmetic operations e.g. addition
+    and subtraction. The latter can be used for combining multiple
+    SingleValueConstraint objects into one.
+
+    The SingleValueConstraint object can be applied to
+    any ASN.1 type.
+
+    Parameters
+    ----------
+    *values: :class:`int`
+        Full set of values permitted by this constraint object.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class DivisorOfSix(Integer):
+            '''
+            ASN.1 specification:
+
+            Divisor-Of-6 ::= INTEGER (1 | 2 | 3 | 6)
+            '''
+            subtypeSpec = SingleValueConstraint(1, 2, 3, 6)
+
+        # this will succeed
+        divisor_of_six = DivisorOfSix(1)
+
+        # this will raise ValueConstraintError
+        divisor_of_six = DivisorOfSix(7)
+    """
+    def _setValues(self, values):
+        self._values = values
+        self._set = set(values)
+
+    def _testValue(self, value, idx):
+        if value not in self._set:
+            raise error.ValueConstraintError(value)
+
+    # Constrains can be merged or reduced
+
+    def __contains__(self, item):
+        return item in self._set
+
+    def __iter__(self):
+        return iter(self._set)
+
+    def __sub__(self, constraint):
+        return self.__class__(*(self._set.difference(constraint)))
+
+    def __add__(self, constraint):
+        return self.__class__(*(self._set.union(constraint)))
+
+    def __sub__(self, constraint):
+        return self.__class__(*(self._set.difference(constraint)))
+
+
+class ContainedSubtypeConstraint(AbstractConstraint):
+    """Create a ContainedSubtypeConstraint object.
+
+    The ContainedSubtypeConstraint satisfies any value that
+    is present in the set of permitted values and also
+    satisfies included constraints.
+
+    The ContainedSubtypeConstraint object can be applied to
+    any ASN.1 type.
+
+    Parameters
+    ----------
+    *values:
+        Full set of values and constraint objects permitted
+        by this constraint object.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class DivisorOfEighteen(Integer):
+            '''
+            ASN.1 specification:
+
+            Divisors-of-18 ::= INTEGER (INCLUDES Divisors-of-6 | 9 | 18)
+            '''
+            subtypeSpec = ContainedSubtypeConstraint(
+                SingleValueConstraint(1, 2, 3, 6), 9, 18
+            )
+
+        # this will succeed
+        divisor_of_eighteen = DivisorOfEighteen(9)
+
+        # this will raise ValueConstraintError
+        divisor_of_eighteen = DivisorOfEighteen(10)
+    """
+    def _testValue(self, value, idx):
+        for constraint in self._values:
+            if isinstance(constraint, AbstractConstraint):
+                constraint(value, idx)
+            elif value not in self._set:
+                raise error.ValueConstraintError(value)
+
+
+class ValueRangeConstraint(AbstractConstraint):
+    """Create a ValueRangeConstraint object.
+
+    The ValueRangeConstraint satisfies any value that
+    falls in the range of permitted values.
+
+    The ValueRangeConstraint object can only be applied
+    to :class:`~pyasn1.type.univ.Integer` and
+    :class:`~pyasn1.type.univ.Real` types.
+
+    Parameters
+    ----------
+    start: :class:`int`
+        Minimum permitted value in the range (inclusive)
+
+    end: :class:`int`
+        Maximum permitted value in the range (inclusive)
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class TeenAgeYears(Integer):
+            '''
+            ASN.1 specification:
+
+            TeenAgeYears ::= INTEGER (13 .. 19)
+            '''
+            subtypeSpec = ValueRangeConstraint(13, 19)
+
+        # this will succeed
+        teen_year = TeenAgeYears(18)
+
+        # this will raise ValueConstraintError
+        teen_year = TeenAgeYears(20)
+    """
+    def _testValue(self, value, idx):
+        if value < self.start or value > self.stop:
+            raise error.ValueConstraintError(value)
+
+    def _setValues(self, values):
+        if len(values) != 2:
+            raise error.PyAsn1Error(
+                '%s: bad constraint values' % (self.__class__.__name__,)
+            )
+        self.start, self.stop = values
+        if self.start > self.stop:
+            raise error.PyAsn1Error(
+                '%s: screwed constraint values (start > stop): %s > %s' % (
+                    self.__class__.__name__,
+                    self.start, self.stop
+                )
+            )
+        AbstractConstraint._setValues(self, values)
+
+
+class ValueSizeConstraint(ValueRangeConstraint):
+    """Create a ValueSizeConstraint object.
+
+    The ValueSizeConstraint satisfies any value for
+    as long as its size falls within the range of
+    permitted sizes.
+
+    The ValueSizeConstraint object can be applied
+    to :class:`~pyasn1.type.univ.BitString`,
+    :class:`~pyasn1.type.univ.OctetString` (including
+    all :ref:`character ASN.1 types <type.char>`),
+    :class:`~pyasn1.type.univ.SequenceOf`
+    and :class:`~pyasn1.type.univ.SetOf` types.
+
+    Parameters
+    ----------
+    minimum: :class:`int`
+        Minimum permitted size of the value (inclusive)
+
+    maximum: :class:`int`
+        Maximum permitted size of the value (inclusive)
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class BaseballTeamRoster(SetOf):
+            '''
+            ASN.1 specification:
+
+            BaseballTeamRoster ::= SET SIZE (1..25) OF PlayerNames
+            '''
+            componentType = PlayerNames()
+            subtypeSpec = ValueSizeConstraint(1, 25)
+
+        # this will succeed
+        team = BaseballTeamRoster()
+        team.extend(['Jan', 'Matej'])
+        encode(team)
+
+        # this will raise ValueConstraintError
+        team = BaseballTeamRoster()
+        team.extend(['Jan'] * 26)
+        encode(team)
+
+    Note
+    ----
+    Whenever ValueSizeConstraint is applied to mutable types
+    (e.g. :class:`~pyasn1.type.univ.SequenceOf`,
+    :class:`~pyasn1.type.univ.SetOf`), constraint
+    validation only happens at the serialisation phase rather
+    than schema instantiation phase (as it is with immutable
+    types).
+    """
+    def _testValue(self, value, idx):
+        valueSize = len(value)
+        if valueSize < self.start or valueSize > self.stop:
+            raise error.ValueConstraintError(value)
+
+
+class PermittedAlphabetConstraint(SingleValueConstraint):
+    """Create a PermittedAlphabetConstraint object.
+
+    The PermittedAlphabetConstraint satisfies any character
+    string for as long as all its characters are present in
+    the set of permitted characters.
+
+    Objects of this type are iterable (emitting constraint values) and
+    can act as operands for some arithmetic operations e.g. addition
+    and subtraction.
+
+    The PermittedAlphabetConstraint object can only be applied
+    to the :ref:`character ASN.1 types <type.char>` such as
+    :class:`~pyasn1.type.char.IA5String`.
+
+    Parameters
+    ----------
+    *alphabet: :class:`str`
+        Full set of characters permitted by this constraint object.
+
+    Example
+    -------
+    .. code-block:: python
+
+        class BooleanValue(IA5String):
+            '''
+            ASN.1 specification:
+
+            BooleanValue ::= IA5String (FROM ('T' | 'F'))
+            '''
+            subtypeSpec = PermittedAlphabetConstraint('T', 'F')
+
+        # this will succeed
+        truth = BooleanValue('T')
+        truth = BooleanValue('TF')
+
+        # this will raise ValueConstraintError
+        garbage = BooleanValue('TAF')
+
+    ASN.1 `FROM ... EXCEPT ...` clause can be modelled by combining multiple
+    PermittedAlphabetConstraint objects into one:
+
+    Example
+    -------
+    .. code-block:: python
+
+        class Lipogramme(IA5String):
+            '''
+            ASN.1 specification:
+
+            Lipogramme ::=
+                IA5String (FROM (ALL EXCEPT ("e"|"E")))
+            '''
+            subtypeSpec = (
+                PermittedAlphabetConstraint(*string.printable) -
+                PermittedAlphabetConstraint('e', 'E')
+            )
+
+        # this will succeed
+        lipogramme = Lipogramme('A work of fiction?')
+
+        # this will raise ValueConstraintError
+        lipogramme = Lipogramme('Eel')
+
+    Note
+    ----
+    Although `ConstraintsExclusion` object could seemingly be used for this
+    purpose, practically, for it to work, it needs to represent its operand
+    constraints as sets and intersect one with the other. That would require
+    the insight into the constraint values (and their types) that are otherwise
+    hidden inside the constraint object.
+
+    Therefore it's more practical to model `EXCEPT` clause at
+    `PermittedAlphabetConstraint` level instead.
+    """
+    def _setValues(self, values):
+        self._values = values
+        self._set = set(values)
+
+    def _testValue(self, value, idx):
+        if not self._set.issuperset(value):
+            raise error.ValueConstraintError(value)
+
+
+class ComponentPresentConstraint(AbstractConstraint):
+    """Create a ComponentPresentConstraint object.
+
+    The ComponentPresentConstraint is only satisfied when the value
+    is not `None`.
+
+    The ComponentPresentConstraint object is typically used with
+    `WithComponentsConstraint`.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        present = ComponentPresentConstraint()
+
+        # this will succeed
+        present('whatever')
+
+        # this will raise ValueConstraintError
+        present(None)
+    """
+    def _setValues(self, values):
+        self._values = ('<must be present>',)
+
+        if values:
+            raise error.PyAsn1Error('No arguments expected')
+
+    def _testValue(self, value, idx):
+        if value is None:
+            raise error.ValueConstraintError(
+                'Component is not present:')
+
+
+class ComponentAbsentConstraint(AbstractConstraint):
+    """Create a ComponentAbsentConstraint object.
+
+    The ComponentAbsentConstraint is only satisfied when the value
+    is `None`.
+
+    The ComponentAbsentConstraint object is typically used with
+    `WithComponentsConstraint`.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        absent = ComponentAbsentConstraint()
+
+        # this will succeed
+        absent(None)
+
+        # this will raise ValueConstraintError
+        absent('whatever')
+    """
+    def _setValues(self, values):
+        self._values = ('<must be absent>',)
+
+        if values:
+            raise error.PyAsn1Error('No arguments expected')
+
+    def _testValue(self, value, idx):
+        if value is not None:
+            raise error.ValueConstraintError(
+                'Component is not absent: %r' % value)
+
+
+class WithComponentsConstraint(AbstractConstraint):
+    """Create a WithComponentsConstraint object.
+
+    The `WithComponentsConstraint` satisfies any mapping object that has
+    constrained fields present or absent, what is indicated by
+    `ComponentPresentConstraint` and `ComponentAbsentConstraint`
+    objects respectively.
+
+    The `WithComponentsConstraint` object is typically applied
+    to  :class:`~pyasn1.type.univ.Set` or
+    :class:`~pyasn1.type.univ.Sequence` types.
+
+    Parameters
+    ----------
+    *fields: :class:`tuple`
+        Zero or more tuples of (`field`, `constraint`) indicating constrained
+        fields.
+
+    Notes
+    -----
+    On top of the primary use of `WithComponentsConstraint` (ensuring presence
+    or absence of particular components of a :class:`~pyasn1.type.univ.Set` or
+    :class:`~pyasn1.type.univ.Sequence`), it is also possible to pass any other
+    constraint objects or their combinations. In case of scalar fields, these
+    constraints will be verified in addition to the constraints belonging to
+    scalar components themselves. However, formally, these additional
+    constraints do not change the type of these ASN.1 objects.
+
+    Examples
+    --------
+
+    .. code-block:: python
+
+        class Item(Sequence):  #  Set is similar
+            '''
+            ASN.1 specification:
+
+            Item ::= SEQUENCE {
+                id    INTEGER OPTIONAL,
+                name  OCTET STRING OPTIONAL
+            } WITH COMPONENTS id PRESENT, name ABSENT | id ABSENT, name PRESENT
+            '''
+            componentType = NamedTypes(
+                OptionalNamedType('id', Integer()),
+                OptionalNamedType('name', OctetString())
+            )
+            withComponents = ConstraintsUnion(
+                WithComponentsConstraint(
+                    ('id', ComponentPresentConstraint()),
+                    ('name', ComponentAbsentConstraint())
+                ),
+                WithComponentsConstraint(
+                    ('id', ComponentAbsentConstraint()),
+                    ('name', ComponentPresentConstraint())
+                )
+            )
+
+        item = Item()
+
+        # This will succeed
+        item['id'] = 1
+
+        # This will succeed
+        item.reset()
+        item['name'] = 'John'
+
+        # This will fail (on encoding)
+        item.reset()
+        descr['id'] = 1
+        descr['name'] = 'John'
+    """
+    def _testValue(self, value, idx):
+        for field, constraint in self._values:
+            constraint(value.get(field))
+
+    def _setValues(self, values):
+        AbstractConstraint._setValues(self, values)
+
+
+# This is a bit kludgy, meaning two op modes within a single constraint
+class InnerTypeConstraint(AbstractConstraint):
+    """Value must satisfy the type and presence constraints"""
+
+    def _testValue(self, value, idx):
+        if self.__singleTypeConstraint:
+            self.__singleTypeConstraint(value)
+        elif self.__multipleTypeConstraint:
+            if idx not in self.__multipleTypeConstraint:
+                raise error.ValueConstraintError(value)
+            constraint, status = self.__multipleTypeConstraint[idx]
+            if status == 'ABSENT':  # XXX presence is not checked!
+                raise error.ValueConstraintError(value)
+            constraint(value)
+
+    def _setValues(self, values):
+        self.__multipleTypeConstraint = {}
+        self.__singleTypeConstraint = None
+        for v in values:
+            if isinstance(v, tuple):
+                self.__multipleTypeConstraint[v[0]] = v[1], v[2]
+            else:
+                self.__singleTypeConstraint = v
+        AbstractConstraint._setValues(self, values)
+
+
+# Logic operations on constraints
+
+class ConstraintsExclusion(AbstractConstraint):
+    """Create a ConstraintsExclusion logic operator object.
+
+    The ConstraintsExclusion logic operator succeeds when the
+    value does *not* satisfy the operand constraint.
+
+    The ConstraintsExclusion object can be applied to
+    any constraint and logic operator object.
+
+    Parameters
+    ----------
+    *constraints:
+        Constraint or logic operator objects.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class LuckyNumber(Integer):
+            subtypeSpec = ConstraintsExclusion(
+                SingleValueConstraint(13)
+            )
+
+        # this will succeed
+        luckyNumber = LuckyNumber(12)
+
+        # this will raise ValueConstraintError
+        luckyNumber = LuckyNumber(13)
+
+    Note
+    ----
+    The `FROM ... EXCEPT ...` ASN.1 clause should be modeled by combining
+    constraint objects into one. See `PermittedAlphabetConstraint` for more
+    information.
+    """
+    def _testValue(self, value, idx):
+        for constraint in self._values:
+            try:
+                constraint(value, idx)
+
+            except error.ValueConstraintError:
+                continue
+
+            raise error.ValueConstraintError(value)
+
+    def _setValues(self, values):
+        AbstractConstraint._setValues(self, values)
+
+
+class AbstractConstraintSet(AbstractConstraint):
+
+    def __getitem__(self, idx):
+        return self._values[idx]
+
+    def __iter__(self):
+        return iter(self._values)
+
+    def __add__(self, value):
+        return self.__class__(*(self._values + (value,)))
+
+    def __radd__(self, value):
+        return self.__class__(*((value,) + self._values))
+
+    def __len__(self):
+        return len(self._values)
+
+    # Constraints inclusion in sets
+
+    def _setValues(self, values):
+        self._values = values
+        for constraint in values:
+            if constraint:
+                self._valueMap.add(constraint)
+                self._valueMap.update(constraint.getValueMap())
+
+
+class ConstraintsIntersection(AbstractConstraintSet):
+    """Create a ConstraintsIntersection logic operator object.
+
+    The ConstraintsIntersection logic operator only succeeds
+    if *all* its operands succeed.
+
+    The ConstraintsIntersection object can be applied to
+    any constraint and logic operator objects.
+
+    The ConstraintsIntersection object duck-types the immutable
+    container object like Python :py:class:`tuple`.
+
+    Parameters
+    ----------
+    *constraints:
+        Constraint or logic operator objects.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class CapitalAndSmall(IA5String):
+            '''
+            ASN.1 specification:
+
+            CapitalAndSmall ::=
+                IA5String (FROM ("A".."Z"|"a".."z"))
+            '''
+            subtypeSpec = ConstraintsIntersection(
+                PermittedAlphabetConstraint('A', 'Z'),
+                PermittedAlphabetConstraint('a', 'z')
+            )
+
+        # this will succeed
+        capital_and_small = CapitalAndSmall('Hello')
+
+        # this will raise ValueConstraintError
+        capital_and_small = CapitalAndSmall('hello')
+    """
+    def _testValue(self, value, idx):
+        for constraint in self._values:
+            constraint(value, idx)
+
+
+class ConstraintsUnion(AbstractConstraintSet):
+    """Create a ConstraintsUnion logic operator object.
+
+    The ConstraintsUnion logic operator succeeds if
+    *at least* a single operand succeeds.
+
+    The ConstraintsUnion object can be applied to
+    any constraint and logic operator objects.
+
+    The ConstraintsUnion object duck-types the immutable
+    container object like Python :py:class:`tuple`.
+
+    Parameters
+    ----------
+    *constraints:
+        Constraint or logic operator objects.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class CapitalOrSmall(IA5String):
+            '''
+            ASN.1 specification:
+
+            CapitalOrSmall ::=
+                IA5String (FROM ("A".."Z") | FROM ("a".."z"))
+            '''
+            subtypeSpec = ConstraintsUnion(
+                PermittedAlphabetConstraint('A', 'Z'),
+                PermittedAlphabetConstraint('a', 'z')
+            )
+
+        # this will succeed
+        capital_or_small = CapitalAndSmall('Hello')
+
+        # this will raise ValueConstraintError
+        capital_or_small = CapitalOrSmall('hello!')
+    """
+    def _testValue(self, value, idx):
+        for constraint in self._values:
+            try:
+                constraint(value, idx)
+            except error.ValueConstraintError:
+                pass
+            else:
+                return
+
+        raise error.ValueConstraintError(
+            'all of %s failed for "%s"' % (self._values, value)
+        )
+
+# TODO:
+# refactor InnerTypeConstraint
+# add tests for type check
+# implement other constraint types
+# make constraint validation easy to skip
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/error.py b/myenv/lib/python3.9/site-packages/pyasn1/type/error.py
new file mode 100644
index 0000000..80fcf3b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/error.py
@@ -0,0 +1,11 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from pyasn1.error import PyAsn1Error
+
+
+class ValueConstraintError(PyAsn1Error):
+    pass
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/namedtype.py b/myenv/lib/python3.9/site-packages/pyasn1/type/namedtype.py
new file mode 100644
index 0000000..cbc1429
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/namedtype.py
@@ -0,0 +1,561 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+
+from pyasn1 import error
+from pyasn1.type import tag
+from pyasn1.type import tagmap
+
+__all__ = ['NamedType', 'OptionalNamedType', 'DefaultedNamedType',
+           'NamedTypes']
+
+try:
+    any
+
+except NameError:
+    any = lambda x: bool(filter(bool, x))
+
+
+class NamedType(object):
+    """Create named field object for a constructed ASN.1 type.
+
+    The |NamedType| object represents a single name and ASN.1 type of a constructed ASN.1 type.
+
+    |NamedType| objects are immutable and duck-type Python :class:`tuple` objects
+    holding *name* and *asn1Object* components.
+
+    Parameters
+    ----------
+    name: :py:class:`str`
+        Field name
+
+    asn1Object:
+        ASN.1 type object
+    """
+    isOptional = False
+    isDefaulted = False
+
+    def __init__(self, name, asn1Object, openType=None):
+        self.__name = name
+        self.__type = asn1Object
+        self.__nameAndType = name, asn1Object
+        self.__openType = openType
+
+    def __repr__(self):
+        representation = '%s=%r' % (self.name, self.asn1Object)
+
+        if self.openType:
+            representation += ', open type %r' % self.openType
+
+        return '<%s object, type %s>' % (
+            self.__class__.__name__, representation)
+
+    def __eq__(self, other):
+        return self.__nameAndType == other
+
+    def __ne__(self, other):
+        return self.__nameAndType != other
+
+    def __lt__(self, other):
+        return self.__nameAndType < other
+
+    def __le__(self, other):
+        return self.__nameAndType <= other
+
+    def __gt__(self, other):
+        return self.__nameAndType > other
+
+    def __ge__(self, other):
+        return self.__nameAndType >= other
+
+    def __hash__(self):
+        return hash(self.__nameAndType)
+
+    def __getitem__(self, idx):
+        return self.__nameAndType[idx]
+
+    def __iter__(self):
+        return iter(self.__nameAndType)
+
+    @property
+    def name(self):
+        return self.__name
+
+    @property
+    def asn1Object(self):
+        return self.__type
+
+    @property
+    def openType(self):
+        return self.__openType
+
+    # Backward compatibility
+
+    def getName(self):
+        return self.name
+
+    def getType(self):
+        return self.asn1Object
+
+
+class OptionalNamedType(NamedType):
+    __doc__ = NamedType.__doc__
+
+    isOptional = True
+
+
+class DefaultedNamedType(NamedType):
+    __doc__ = NamedType.__doc__
+
+    isDefaulted = True
+
+
+class NamedTypes(object):
+    """Create a collection of named fields for a constructed ASN.1 type.
+
+    The NamedTypes object represents a collection of named fields of a constructed ASN.1 type.
+
+    *NamedTypes* objects are immutable and duck-type Python :class:`dict` objects
+    holding *name* as keys and ASN.1 type object as values.
+
+    Parameters
+    ----------
+    *namedTypes: :class:`~pyasn1.type.namedtype.NamedType`
+
+    Examples
+    --------
+
+    .. code-block:: python
+
+        class Description(Sequence):
+            '''
+            ASN.1 specification:
+
+            Description ::= SEQUENCE {
+                surname    IA5String,
+                first-name IA5String OPTIONAL,
+                age        INTEGER DEFAULT 40
+            }
+            '''
+            componentType = NamedTypes(
+                NamedType('surname', IA5String()),
+                OptionalNamedType('first-name', IA5String()),
+                DefaultedNamedType('age', Integer(40))
+            )
+
+        descr = Description()
+        descr['surname'] = 'Smith'
+        descr['first-name'] = 'John'
+    """
+    def __init__(self, *namedTypes, **kwargs):
+        self.__namedTypes = namedTypes
+        self.__namedTypesLen = len(self.__namedTypes)
+        self.__minTagSet = self.__computeMinTagSet()
+        self.__nameToPosMap = self.__computeNameToPosMap()
+        self.__tagToPosMap = self.__computeTagToPosMap()
+        self.__ambiguousTypes = 'terminal' not in kwargs and self.__computeAmbiguousTypes() or {}
+        self.__uniqueTagMap = self.__computeTagMaps(unique=True)
+        self.__nonUniqueTagMap = self.__computeTagMaps(unique=False)
+        self.__hasOptionalOrDefault = any([True for namedType in self.__namedTypes
+                                           if namedType.isDefaulted or namedType.isOptional])
+        self.__hasOpenTypes = any([True for namedType in self.__namedTypes
+                                   if namedType.openType])
+
+        self.__requiredComponents = frozenset(
+                [idx for idx, nt in enumerate(self.__namedTypes) if not nt.isOptional and not nt.isDefaulted]
+            )
+        self.__keys = frozenset([namedType.name for namedType in self.__namedTypes])
+        self.__values = tuple([namedType.asn1Object for namedType in self.__namedTypes])
+        self.__items = tuple([(namedType.name, namedType.asn1Object) for namedType in self.__namedTypes])
+
+    def __repr__(self):
+        representation = ', '.join(['%r' % x for x in self.__namedTypes])
+        return '<%s object, types %s>' % (
+            self.__class__.__name__, representation)
+
+    def __eq__(self, other):
+        return self.__namedTypes == other
+
+    def __ne__(self, other):
+        return self.__namedTypes != other
+
+    def __lt__(self, other):
+        return self.__namedTypes < other
+
+    def __le__(self, other):
+        return self.__namedTypes <= other
+
+    def __gt__(self, other):
+        return self.__namedTypes > other
+
+    def __ge__(self, other):
+        return self.__namedTypes >= other
+
+    def __hash__(self):
+        return hash(self.__namedTypes)
+
+    def __getitem__(self, idx):
+        try:
+            return self.__namedTypes[idx]
+
+        except TypeError:
+            return self.__namedTypes[self.__nameToPosMap[idx]]
+
+    def __contains__(self, key):
+        return key in self.__nameToPosMap
+
+    def __iter__(self):
+        return (x[0] for x in self.__namedTypes)
+
+    if sys.version_info[0] <= 2:
+        def __nonzero__(self):
+            return self.__namedTypesLen > 0
+    else:
+        def __bool__(self):
+            return self.__namedTypesLen > 0
+
+    def __len__(self):
+        return self.__namedTypesLen
+
+    # Python dict protocol
+
+    def values(self):
+        return self.__values
+
+    def keys(self):
+        return self.__keys
+
+    def items(self):
+        return self.__items
+
+    def clone(self):
+        return self.__class__(*self.__namedTypes)
+
+    class PostponedError(object):
+        def __init__(self, errorMsg):
+            self.__errorMsg = errorMsg
+
+        def __getitem__(self, item):
+            raise  error.PyAsn1Error(self.__errorMsg)
+
+    def __computeTagToPosMap(self):
+        tagToPosMap = {}
+        for idx, namedType in enumerate(self.__namedTypes):
+            tagMap = namedType.asn1Object.tagMap
+            if isinstance(tagMap, NamedTypes.PostponedError):
+                return tagMap
+            if not tagMap:
+                continue
+            for _tagSet in tagMap.presentTypes:
+                if _tagSet in tagToPosMap:
+                    return NamedTypes.PostponedError('Duplicate component tag %s at %s' % (_tagSet, namedType))
+                tagToPosMap[_tagSet] = idx
+
+        return tagToPosMap
+
+    def __computeNameToPosMap(self):
+        nameToPosMap = {}
+        for idx, namedType in enumerate(self.__namedTypes):
+            if namedType.name in nameToPosMap:
+                return NamedTypes.PostponedError('Duplicate component name %s at %s' % (namedType.name, namedType))
+            nameToPosMap[namedType.name] = idx
+
+        return nameToPosMap
+
+    def __computeAmbiguousTypes(self):
+        ambiguousTypes = {}
+        partialAmbiguousTypes = ()
+        for idx, namedType in reversed(tuple(enumerate(self.__namedTypes))):
+            if namedType.isOptional or namedType.isDefaulted:
+                partialAmbiguousTypes = (namedType,) + partialAmbiguousTypes
+            else:
+                partialAmbiguousTypes = (namedType,)
+            if len(partialAmbiguousTypes) == len(self.__namedTypes):
+                ambiguousTypes[idx] = self
+            else:
+                ambiguousTypes[idx] = NamedTypes(*partialAmbiguousTypes, **dict(terminal=True))
+        return ambiguousTypes
+
+    def getTypeByPosition(self, idx):
+        """Return ASN.1 type object by its position in fields set.
+
+        Parameters
+        ----------
+        idx: :py:class:`int`
+            Field index
+
+        Returns
+        -------
+        :
+            ASN.1 type
+
+        Raises
+        ------
+        ~pyasn1.error.PyAsn1Error
+            If given position is out of fields range
+        """
+        try:
+            return self.__namedTypes[idx].asn1Object
+
+        except IndexError:
+            raise error.PyAsn1Error('Type position out of range')
+
+    def getPositionByType(self, tagSet):
+        """Return field position by its ASN.1 type.
+
+        Parameters
+        ----------
+        tagSet: :class:`~pysnmp.type.tag.TagSet`
+            ASN.1 tag set distinguishing one ASN.1 type from others.
+
+        Returns
+        -------
+        : :py:class:`int`
+            ASN.1 type position in fields set
+
+        Raises
+        ------
+        ~pyasn1.error.PyAsn1Error
+            If *tagSet* is not present or ASN.1 types are not unique within callee *NamedTypes*
+        """
+        try:
+            return self.__tagToPosMap[tagSet]
+
+        except KeyError:
+            raise error.PyAsn1Error('Type %s not found' % (tagSet,))
+
+    def getNameByPosition(self, idx):
+        """Return field name by its position in fields set.
+
+        Parameters
+        ----------
+        idx: :py:class:`idx`
+            Field index
+
+        Returns
+        -------
+        : :py:class:`str`
+            Field name
+
+        Raises
+        ------
+        ~pyasn1.error.PyAsn1Error
+            If given field name is not present in callee *NamedTypes*
+        """
+        try:
+            return self.__namedTypes[idx].name
+
+        except IndexError:
+            raise error.PyAsn1Error('Type position out of range')
+
+    def getPositionByName(self, name):
+        """Return field position by filed name.
+
+        Parameters
+        ----------
+        name: :py:class:`str`
+            Field name
+
+        Returns
+        -------
+        : :py:class:`int`
+            Field position in fields set
+
+        Raises
+        ------
+        ~pyasn1.error.PyAsn1Error
+            If *name* is not present or not unique within callee *NamedTypes*
+        """
+        try:
+            return self.__nameToPosMap[name]
+
+        except KeyError:
+            raise error.PyAsn1Error('Name %s not found' % (name,))
+
+    def getTagMapNearPosition(self, idx):
+        """Return ASN.1 types that are allowed at or past given field position.
+
+        Some ASN.1 serialisation allow for skipping optional and defaulted fields.
+        Some constructed ASN.1 types allow reordering of the fields. When recovering
+        such objects it may be important to know which types can possibly be
+        present at any given position in the field sets.
+
+        Parameters
+        ----------
+        idx: :py:class:`int`
+            Field index
+
+        Returns
+        -------
+        : :class:`~pyasn1.type.tagmap.TagMap`
+            Map if ASN.1 types allowed at given field position
+
+        Raises
+        ------
+        ~pyasn1.error.PyAsn1Error
+            If given position is out of fields range
+        """
+        try:
+            return self.__ambiguousTypes[idx].tagMap
+
+        except KeyError:
+            raise error.PyAsn1Error('Type position out of range')
+
+    def getPositionNearType(self, tagSet, idx):
+        """Return the closest field position where given ASN.1 type is allowed.
+
+        Some ASN.1 serialisation allow for skipping optional and defaulted fields.
+        Some constructed ASN.1 types allow reordering of the fields. When recovering
+        such objects it may be important to know at which field position, in field set,
+        given *tagSet* is allowed at or past *idx* position.
+
+        Parameters
+        ----------
+        tagSet: :class:`~pyasn1.type.tag.TagSet`
+           ASN.1 type which field position to look up
+
+        idx: :py:class:`int`
+            Field position at or past which to perform ASN.1 type look up
+
+        Returns
+        -------
+        : :py:class:`int`
+            Field position in fields set
+
+        Raises
+        ------
+        ~pyasn1.error.PyAsn1Error
+            If *tagSet* is not present or not unique within callee *NamedTypes*
+            or *idx* is out of fields range
+        """
+        try:
+            return idx + self.__ambiguousTypes[idx].getPositionByType(tagSet)
+
+        except KeyError:
+            raise error.PyAsn1Error('Type position out of range')
+
+    def __computeMinTagSet(self):
+        minTagSet = None
+        for namedType in self.__namedTypes:
+            asn1Object = namedType.asn1Object
+
+            try:
+                tagSet = asn1Object.minTagSet
+
+            except AttributeError:
+                tagSet = asn1Object.tagSet
+
+            if minTagSet is None or tagSet < minTagSet:
+                minTagSet = tagSet
+
+        return minTagSet or tag.TagSet()
+
+    @property
+    def minTagSet(self):
+        """Return the minimal TagSet among ASN.1 type in callee *NamedTypes*.
+
+        Some ASN.1 types/serialisation protocols require ASN.1 types to be
+        arranged based on their numerical tag value. The *minTagSet* property
+        returns that.
+
+        Returns
+        -------
+        : :class:`~pyasn1.type.tagset.TagSet`
+            Minimal TagSet among ASN.1 types in callee *NamedTypes*
+        """
+        return self.__minTagSet
+
+    def __computeTagMaps(self, unique):
+        presentTypes = {}
+        skipTypes = {}
+        defaultType = None
+        for namedType in self.__namedTypes:
+            tagMap = namedType.asn1Object.tagMap
+            if isinstance(tagMap, NamedTypes.PostponedError):
+                return tagMap
+            for tagSet in tagMap:
+                if unique and tagSet in presentTypes:
+                    return NamedTypes.PostponedError('Non-unique tagSet %s of %s at %s' % (tagSet, namedType, self))
+                presentTypes[tagSet] = namedType.asn1Object
+            skipTypes.update(tagMap.skipTypes)
+
+            if defaultType is None:
+                defaultType = tagMap.defaultType
+            elif tagMap.defaultType is not None:
+                return NamedTypes.PostponedError('Duplicate default ASN.1 type at %s' % (self,))
+
+        return tagmap.TagMap(presentTypes, skipTypes, defaultType)
+
+    @property
+    def tagMap(self):
+        """Return a *TagMap* object from tags and types recursively.
+
+        Return a :class:`~pyasn1.type.tagmap.TagMap` object by
+        combining tags from *TagMap* objects of children types and
+        associating them with their immediate child type.
+
+        Example
+        -------
+        .. code-block:: python
+
+           OuterType ::= CHOICE {
+               innerType INTEGER
+           }
+
+        Calling *.tagMap* on *OuterType* will yield a map like this:
+
+        .. code-block:: python
+
+           Integer.tagSet -> Choice
+        """
+        return self.__nonUniqueTagMap
+
+    @property
+    def tagMapUnique(self):
+        """Return a *TagMap* object from unique tags and types recursively.
+
+        Return a :class:`~pyasn1.type.tagmap.TagMap` object by
+        combining tags from *TagMap* objects of children types and
+        associating them with their immediate child type.
+
+        Example
+        -------
+        .. code-block:: python
+
+           OuterType ::= CHOICE {
+               innerType INTEGER
+           }
+
+        Calling *.tagMapUnique* on *OuterType* will yield a map like this:
+
+        .. code-block:: python
+
+           Integer.tagSet -> Choice
+
+        Note
+        ----
+
+        Duplicate *TagSet* objects found in the tree of children
+        types would cause error.
+        """
+        return self.__uniqueTagMap
+
+    @property
+    def hasOptionalOrDefault(self):
+        return self.__hasOptionalOrDefault
+
+    @property
+    def hasOpenTypes(self):
+        return self.__hasOpenTypes
+
+    @property
+    def namedTypes(self):
+        return tuple(self.__namedTypes)
+
+    @property
+    def requiredComponents(self):
+        return self.__requiredComponents
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/namedval.py b/myenv/lib/python3.9/site-packages/pyasn1/type/namedval.py
new file mode 100644
index 0000000..4247597
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/namedval.py
@@ -0,0 +1,192 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# ASN.1 named integers
+#
+from pyasn1 import error
+
+__all__ = ['NamedValues']
+
+
+class NamedValues(object):
+    """Create named values object.
+
+    The |NamedValues| object represents a collection of string names
+    associated with numeric IDs. These objects are used for giving
+    names to otherwise numerical values.
+
+    |NamedValues| objects are immutable and duck-type Python
+    :class:`dict` object mapping ID to name and vice-versa.
+
+    Parameters
+    ----------
+    *args: variable number of two-element :py:class:`tuple`
+
+        name: :py:class:`str`
+            Value label
+
+        value: :py:class:`int`
+            Numeric value
+
+    Keyword Args
+    ------------
+    name: :py:class:`str`
+        Value label
+
+    value: :py:class:`int`
+        Numeric value
+
+    Examples
+    --------
+
+    .. code-block:: pycon
+
+        >>> nv = NamedValues('a', 'b', ('c', 0), d=1)
+        >>> nv
+        >>> {'c': 0, 'd': 1, 'a': 2, 'b': 3}
+        >>> nv[0]
+        'c'
+        >>> nv['a']
+        2
+    """
+    def __init__(self, *args, **kwargs):
+        self.__names = {}
+        self.__numbers = {}
+
+        anonymousNames = []
+
+        for namedValue in args:
+            if isinstance(namedValue, (tuple, list)):
+                try:
+                    name, number = namedValue
+
+                except ValueError:
+                    raise error.PyAsn1Error('Not a proper attribute-value pair %r' % (namedValue,))
+
+            else:
+                anonymousNames.append(namedValue)
+                continue
+
+            if name in self.__names:
+                raise error.PyAsn1Error('Duplicate name %s' % (name,))
+
+            if number in self.__numbers:
+                raise error.PyAsn1Error('Duplicate number  %s=%s' % (name, number))
+
+            self.__names[name] = number
+            self.__numbers[number] = name
+
+        for name, number in kwargs.items():
+            if name in self.__names:
+                raise error.PyAsn1Error('Duplicate name %s' % (name,))
+
+            if number in self.__numbers:
+                raise error.PyAsn1Error('Duplicate number  %s=%s' % (name, number))
+
+            self.__names[name] = number
+            self.__numbers[number] = name
+
+        if anonymousNames:
+
+            number = self.__numbers and max(self.__numbers) + 1 or 0
+
+            for name in anonymousNames:
+
+                if name in self.__names:
+                    raise error.PyAsn1Error('Duplicate name %s' % (name,))
+
+                self.__names[name] = number
+                self.__numbers[number] = name
+
+                number += 1
+
+    def __repr__(self):
+        representation = ', '.join(['%s=%d' % x for x in self.items()])
+
+        if len(representation) > 64:
+            representation = representation[:32] + '...' + representation[-32:]
+
+        return '<%s object, enums %s>' % (
+            self.__class__.__name__, representation)
+
+    def __eq__(self, other):
+        return dict(self) == other
+
+    def __ne__(self, other):
+        return dict(self) != other
+
+    def __lt__(self, other):
+        return dict(self) < other
+
+    def __le__(self, other):
+        return dict(self) <= other
+
+    def __gt__(self, other):
+        return dict(self) > other
+
+    def __ge__(self, other):
+        return dict(self) >= other
+
+    def __hash__(self):
+        return hash(self.items())
+
+    # Python dict protocol (read-only)
+
+    def __getitem__(self, key):
+        try:
+            return self.__numbers[key]
+
+        except KeyError:
+            return self.__names[key]
+
+    def __len__(self):
+        return len(self.__names)
+
+    def __contains__(self, key):
+        return key in self.__names or key in self.__numbers
+
+    def __iter__(self):
+        return iter(self.__names)
+
+    def values(self):
+        return iter(self.__numbers)
+
+    def keys(self):
+        return iter(self.__names)
+
+    def items(self):
+        for name in self.__names:
+            yield name, self.__names[name]
+
+    # support merging
+
+    def __add__(self, namedValues):
+        return self.__class__(*tuple(self.items()) + tuple(namedValues.items()))
+
+    # XXX clone/subtype?
+
+    def clone(self, *args, **kwargs):
+        new = self.__class__(*args, **kwargs)
+        return self + new
+
+    # legacy protocol
+
+    def getName(self, value):
+        if value in self.__numbers:
+            return self.__numbers[value]
+
+    def getValue(self, name):
+        if name in self.__names:
+            return self.__names[name]
+
+    def getValues(self, *names):
+        try:
+            return [self.__names[name] for name in names]
+
+        except KeyError:
+            raise error.PyAsn1Error(
+                'Unknown bit identifier(s): %s' % (set(names).difference(self.__names),)
+            )
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/opentype.py b/myenv/lib/python3.9/site-packages/pyasn1/type/opentype.py
new file mode 100644
index 0000000..29645f0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/opentype.py
@@ -0,0 +1,104 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+
+__all__ = ['OpenType']
+
+
+class OpenType(object):
+    """Create ASN.1 type map indexed by a value
+
+    The *OpenType* object models an untyped field of a constructed ASN.1
+    type. In ASN.1 syntax it is usually represented by the
+    `ANY DEFINED BY` for scalars or `SET OF ANY DEFINED BY`,
+    `SEQUENCE OF ANY DEFINED BY` for container types clauses. Typically
+    used together with :class:`~pyasn1.type.univ.Any` object.
+
+    OpenType objects duck-type a read-only Python :class:`dict` objects,
+    however the passed `typeMap` is not copied, but stored by reference.
+    That means the user can manipulate `typeMap` at run time having this
+    reflected on *OpenType* object behavior.
+
+    The |OpenType| class models an untyped field of a constructed ASN.1
+    type. In ASN.1 syntax it is usually represented by the
+    `ANY DEFINED BY` for scalars or `SET OF ANY DEFINED BY`,
+    `SEQUENCE OF ANY DEFINED BY` for container types clauses. Typically
+    used with :class:`~pyasn1.type.univ.Any` type.
+
+    Parameters
+    ----------
+    name: :py:class:`str`
+        Field name
+
+    typeMap: :py:class:`dict`
+        A map of value->ASN.1 type. It's stored by reference and can be
+        mutated later to register new mappings.
+
+    Examples
+    --------
+
+    For untyped scalars:
+
+    .. code-block:: python
+
+        openType = OpenType(
+            'id', {1: Integer(),
+                   2: OctetString()}
+        )
+        Sequence(
+            componentType=NamedTypes(
+                NamedType('id', Integer()),
+                NamedType('blob', Any(), openType=openType)
+            )
+        )
+
+    For untyped `SET OF` or `SEQUENCE OF` vectors:
+
+    .. code-block:: python
+
+        openType = OpenType(
+            'id', {1: Integer(),
+                   2: OctetString()}
+        )
+        Sequence(
+            componentType=NamedTypes(
+                NamedType('id', Integer()),
+                NamedType('blob', SetOf(componentType=Any()),
+                          openType=openType)
+            )
+        )
+    """
+
+    def __init__(self, name, typeMap=None):
+        self.__name = name
+        if typeMap is None:
+            self.__typeMap = {}
+        else:
+            self.__typeMap = typeMap
+
+    @property
+    def name(self):
+        return self.__name
+
+    # Python dict protocol
+
+    def values(self):
+        return self.__typeMap.values()
+
+    def keys(self):
+        return self.__typeMap.keys()
+
+    def items(self):
+        return self.__typeMap.items()
+
+    def __contains__(self, key):
+        return key in self.__typeMap
+
+    def __getitem__(self, key):
+        return self.__typeMap[key]
+
+    def __iter__(self):
+        return iter(self.__typeMap)
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/tag.py b/myenv/lib/python3.9/site-packages/pyasn1/type/tag.py
new file mode 100644
index 0000000..b88a734
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/tag.py
@@ -0,0 +1,335 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from pyasn1 import error
+
+__all__ = ['tagClassUniversal', 'tagClassApplication', 'tagClassContext',
+           'tagClassPrivate', 'tagFormatSimple', 'tagFormatConstructed',
+           'tagCategoryImplicit', 'tagCategoryExplicit',
+           'tagCategoryUntagged', 'Tag', 'TagSet']
+
+#: Identifier for ASN.1 class UNIVERSAL
+tagClassUniversal = 0x00
+
+#: Identifier for ASN.1 class APPLICATION
+tagClassApplication = 0x40
+
+#: Identifier for ASN.1 class context-specific
+tagClassContext = 0x80
+
+#: Identifier for ASN.1 class private
+tagClassPrivate = 0xC0
+
+#: Identifier for "simple" ASN.1 structure (e.g. scalar)
+tagFormatSimple = 0x00
+
+#: Identifier for "constructed" ASN.1 structure (e.g. may have inner components)
+tagFormatConstructed = 0x20
+
+tagCategoryImplicit = 0x01
+tagCategoryExplicit = 0x02
+tagCategoryUntagged = 0x04
+
+
+class Tag(object):
+    """Create ASN.1 tag
+
+    Represents ASN.1 tag that can be attached to a ASN.1 type to make
+    types distinguishable from each other.
+
+    *Tag* objects are immutable and duck-type Python :class:`tuple` objects
+    holding three integer components of a tag.
+
+    Parameters
+    ----------
+    tagClass: :py:class:`int`
+        Tag *class* value
+
+    tagFormat: :py:class:`int`
+        Tag *format* value
+
+    tagId: :py:class:`int`
+        Tag ID value
+    """
+    def __init__(self, tagClass, tagFormat, tagId):
+        if tagId < 0:
+            raise error.PyAsn1Error('Negative tag ID (%s) not allowed' % tagId)
+        self.__tagClass = tagClass
+        self.__tagFormat = tagFormat
+        self.__tagId = tagId
+        self.__tagClassId = tagClass, tagId
+        self.__hash = hash(self.__tagClassId)
+
+    def __repr__(self):
+        representation = '[%s:%s:%s]' % (
+            self.__tagClass, self.__tagFormat, self.__tagId)
+        return '<%s object, tag %s>' % (
+            self.__class__.__name__, representation)
+
+    def __eq__(self, other):
+        return self.__tagClassId == other
+
+    def __ne__(self, other):
+        return self.__tagClassId != other
+
+    def __lt__(self, other):
+        return self.__tagClassId < other
+
+    def __le__(self, other):
+        return self.__tagClassId <= other
+
+    def __gt__(self, other):
+        return self.__tagClassId > other
+
+    def __ge__(self, other):
+        return self.__tagClassId >= other
+
+    def __hash__(self):
+        return self.__hash
+
+    def __getitem__(self, idx):
+        if idx == 0:
+            return self.__tagClass
+        elif idx == 1:
+            return self.__tagFormat
+        elif idx == 2:
+            return self.__tagId
+        else:
+            raise IndexError()
+
+    def __iter__(self):
+        yield self.__tagClass
+        yield self.__tagFormat
+        yield self.__tagId
+
+    def __and__(self, otherTag):
+        return self.__class__(self.__tagClass & otherTag.tagClass,
+                              self.__tagFormat & otherTag.tagFormat,
+                              self.__tagId & otherTag.tagId)
+
+    def __or__(self, otherTag):
+        return self.__class__(self.__tagClass | otherTag.tagClass,
+                              self.__tagFormat | otherTag.tagFormat,
+                              self.__tagId | otherTag.tagId)
+
+    @property
+    def tagClass(self):
+        """ASN.1 tag class
+
+        Returns
+        -------
+        : :py:class:`int`
+            Tag class
+        """
+        return self.__tagClass
+
+    @property
+    def tagFormat(self):
+        """ASN.1 tag format
+
+        Returns
+        -------
+        : :py:class:`int`
+            Tag format
+        """
+        return self.__tagFormat
+
+    @property
+    def tagId(self):
+        """ASN.1 tag ID
+
+        Returns
+        -------
+        : :py:class:`int`
+            Tag ID
+        """
+        return self.__tagId
+
+
+class TagSet(object):
+    """Create a collection of ASN.1 tags
+
+    Represents a combination of :class:`~pyasn1.type.tag.Tag` objects
+    that can be attached to a ASN.1 type to make types distinguishable
+    from each other.
+
+    *TagSet* objects are immutable and duck-type Python :class:`tuple` objects
+    holding arbitrary number of :class:`~pyasn1.type.tag.Tag` objects.
+
+    Parameters
+    ----------
+    baseTag: :class:`~pyasn1.type.tag.Tag`
+        Base *Tag* object. This tag survives IMPLICIT tagging.
+
+    *superTags: :class:`~pyasn1.type.tag.Tag`
+        Additional *Tag* objects taking part in subtyping.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class OrderNumber(NumericString):
+            '''
+            ASN.1 specification
+
+            Order-number ::=
+                [APPLICATION 5] IMPLICIT NumericString
+            '''
+            tagSet = NumericString.tagSet.tagImplicitly(
+                Tag(tagClassApplication, tagFormatSimple, 5)
+            )
+
+        orderNumber = OrderNumber('1234')
+    """
+    def __init__(self, baseTag=(), *superTags):
+        self.__baseTag = baseTag
+        self.__superTags = superTags
+        self.__superTagsClassId = tuple(
+            [(superTag.tagClass, superTag.tagId) for superTag in superTags]
+        )
+        self.__lenOfSuperTags = len(superTags)
+        self.__hash = hash(self.__superTagsClassId)
+
+    def __repr__(self):
+        representation = '-'.join(['%s:%s:%s' % (x.tagClass, x.tagFormat, x.tagId)
+                                   for x in self.__superTags])
+        if representation:
+            representation = 'tags ' + representation
+        else:
+            representation = 'untagged'
+
+        return '<%s object, %s>' % (self.__class__.__name__, representation)
+
+    def __add__(self, superTag):
+        return self.__class__(self.__baseTag, *self.__superTags + (superTag,))
+
+    def __radd__(self, superTag):
+        return self.__class__(self.__baseTag, *(superTag,) + self.__superTags)
+
+    def __getitem__(self, i):
+        if i.__class__ is slice:
+            return self.__class__(self.__baseTag, *self.__superTags[i])
+        else:
+            return self.__superTags[i]
+
+    def __eq__(self, other):
+        return self.__superTagsClassId == other
+
+    def __ne__(self, other):
+        return self.__superTagsClassId != other
+
+    def __lt__(self, other):
+        return self.__superTagsClassId < other
+
+    def __le__(self, other):
+        return self.__superTagsClassId <= other
+
+    def __gt__(self, other):
+        return self.__superTagsClassId > other
+
+    def __ge__(self, other):
+        return self.__superTagsClassId >= other
+
+    def __hash__(self):
+        return self.__hash
+
+    def __len__(self):
+        return self.__lenOfSuperTags
+
+    @property
+    def baseTag(self):
+        """Return base ASN.1 tag
+
+        Returns
+        -------
+        : :class:`~pyasn1.type.tag.Tag`
+            Base tag of this *TagSet*
+        """
+        return self.__baseTag
+
+    @property
+    def superTags(self):
+        """Return ASN.1 tags
+
+        Returns
+        -------
+        : :py:class:`tuple`
+            Tuple of :class:`~pyasn1.type.tag.Tag` objects that this *TagSet* contains
+        """
+        return self.__superTags
+
+    def tagExplicitly(self, superTag):
+        """Return explicitly tagged *TagSet*
+
+        Create a new *TagSet* representing callee *TagSet* explicitly tagged
+        with passed tag(s). With explicit tagging mode, new tags are appended
+        to existing tag(s).
+
+        Parameters
+        ----------
+        superTag: :class:`~pyasn1.type.tag.Tag`
+            *Tag* object to tag this *TagSet*
+
+        Returns
+        -------
+        : :class:`~pyasn1.type.tag.TagSet`
+            New *TagSet* object
+        """
+        if superTag.tagClass == tagClassUniversal:
+            raise error.PyAsn1Error("Can't tag with UNIVERSAL class tag")
+        if superTag.tagFormat != tagFormatConstructed:
+            superTag = Tag(superTag.tagClass, tagFormatConstructed, superTag.tagId)
+        return self + superTag
+
+    def tagImplicitly(self, superTag):
+        """Return implicitly tagged *TagSet*
+
+        Create a new *TagSet* representing callee *TagSet* implicitly tagged
+        with passed tag(s). With implicit tagging mode, new tag(s) replace the
+        last existing tag.
+
+        Parameters
+        ----------
+        superTag: :class:`~pyasn1.type.tag.Tag`
+            *Tag* object to tag this *TagSet*
+
+        Returns
+        -------
+        : :class:`~pyasn1.type.tag.TagSet`
+            New *TagSet* object
+        """
+        if self.__superTags:
+            superTag = Tag(superTag.tagClass, self.__superTags[-1].tagFormat, superTag.tagId)
+        return self[:-1] + superTag
+
+    def isSuperTagSetOf(self, tagSet):
+        """Test type relationship against given *TagSet*
+
+        The callee is considered to be a supertype of given *TagSet*
+        tag-wise if all tags in *TagSet* are present in the callee and
+        they are in the same order.
+
+        Parameters
+        ----------
+        tagSet: :class:`~pyasn1.type.tag.TagSet`
+            *TagSet* object to evaluate against the callee
+
+        Returns
+        -------
+        : :py:class:`bool`
+            :obj:`True` if callee is a supertype of *tagSet*
+        """
+        if len(tagSet) < self.__lenOfSuperTags:
+            return False
+        return self.__superTags == tagSet[:self.__lenOfSuperTags]
+
+    # Backward compatibility
+
+    def getBaseTag(self):
+        return self.__baseTag
+
+def initTagSet(tag):
+    return TagSet(tag, tag)
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/tagmap.py b/myenv/lib/python3.9/site-packages/pyasn1/type/tagmap.py
new file mode 100644
index 0000000..6f5163b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/tagmap.py
@@ -0,0 +1,96 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+from pyasn1 import error
+
+__all__ = ['TagMap']
+
+
+class TagMap(object):
+    """Map *TagSet* objects to ASN.1 types
+
+    Create an object mapping *TagSet* object to ASN.1 type.
+
+    *TagMap* objects are immutable and duck-type read-only Python
+    :class:`dict` objects holding *TagSet* objects as keys and ASN.1
+    type objects as values.
+
+    Parameters
+    ----------
+    presentTypes: :py:class:`dict`
+        Map of :class:`~pyasn1.type.tag.TagSet` to ASN.1 objects considered
+        as being unconditionally present in the *TagMap*.
+
+    skipTypes: :py:class:`dict`
+        A collection of :class:`~pyasn1.type.tag.TagSet` objects considered
+        as absent in the *TagMap* even when *defaultType* is present.
+
+    defaultType: ASN.1 type object
+        An ASN.1 type object callee *TagMap* returns for any *TagSet* key not present
+        in *presentTypes* (unless given key is present in *skipTypes*).
+    """
+    def __init__(self, presentTypes=None, skipTypes=None, defaultType=None):
+        self.__presentTypes = presentTypes or {}
+        self.__skipTypes = skipTypes or {}
+        self.__defaultType = defaultType
+
+    def __contains__(self, tagSet):
+        return (tagSet in self.__presentTypes or
+                self.__defaultType is not None and tagSet not in self.__skipTypes)
+
+    def __getitem__(self, tagSet):
+        try:
+            return self.__presentTypes[tagSet]
+        except KeyError:
+            if self.__defaultType is None:
+                raise KeyError()
+            elif tagSet in self.__skipTypes:
+                raise error.PyAsn1Error('Key in negative map')
+            else:
+                return self.__defaultType
+
+    def __iter__(self):
+        return iter(self.__presentTypes)
+
+    def __repr__(self):
+        representation = '%s object' % self.__class__.__name__
+
+        if self.__presentTypes:
+            representation += ', present %s' % repr(self.__presentTypes)
+
+        if self.__skipTypes:
+            representation += ', skip %s' % repr(self.__skipTypes)
+
+        if self.__defaultType is not None:
+            representation += ', default %s' % repr(self.__defaultType)
+
+        return '<%s>' % representation
+
+    @property
+    def presentTypes(self):
+        """Return *TagSet* to ASN.1 type map present in callee *TagMap*"""
+        return self.__presentTypes
+
+    @property
+    def skipTypes(self):
+        """Return *TagSet* collection unconditionally absent in callee *TagMap*"""
+        return self.__skipTypes
+
+    @property
+    def defaultType(self):
+        """Return default ASN.1 type being returned for any missing *TagSet*"""
+        return self.__defaultType
+
+    # Backward compatibility
+
+    def getPosMap(self):
+        return self.presentTypes
+
+    def getNegMap(self):
+        return self.skipTypes
+
+    def getDef(self):
+        return self.defaultType
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/univ.py b/myenv/lib/python3.9/site-packages/pyasn1/type/univ.py
new file mode 100644
index 0000000..aa688b2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/univ.py
@@ -0,0 +1,3321 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import math
+import sys
+
+from pyasn1 import error
+from pyasn1.codec.ber import eoo
+from pyasn1.compat import binary
+from pyasn1.compat import integer
+from pyasn1.compat import octets
+from pyasn1.type import base
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import namedval
+from pyasn1.type import tag
+from pyasn1.type import tagmap
+
+NoValue = base.NoValue
+noValue = NoValue()
+
+__all__ = ['Integer', 'Boolean', 'BitString', 'OctetString', 'Null',
+           'ObjectIdentifier', 'Real', 'Enumerated',
+           'SequenceOfAndSetOfBase', 'SequenceOf', 'SetOf',
+           'SequenceAndSetBase', 'Sequence', 'Set', 'Choice', 'Any',
+           'NoValue', 'noValue']
+
+# "Simple" ASN.1 types (yet incomplete)
+
+
+class Integer(base.SimpleAsn1Type):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its
+    objects are immutable and duck-type Python :class:`int` objects.
+
+    Keyword Args
+    ------------
+    value: :class:`int`, :class:`str` or |ASN.1| object
+        Python :class:`int` or :class:`str` literal or |ASN.1| class
+        instance. If `value` is not given, schema object will be created.
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s). Constraints
+        verification for |ASN.1| type occurs automatically on object
+        instantiation.
+
+    namedValues: :py:class:`~pyasn1.type.namedval.NamedValues`
+        Object representing non-default symbolic aliases for numbers
+
+    Raises
+    ------
+    ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error
+        On constraint violation or bad initializer.
+
+    Examples
+    --------
+
+    .. code-block:: python
+
+        class ErrorCode(Integer):
+            '''
+            ASN.1 specification:
+
+            ErrorCode ::=
+                INTEGER { disk-full(1), no-disk(-1),
+                          disk-not-formatted(2) }
+
+            error ErrorCode ::= disk-full
+            '''
+            namedValues = NamedValues(
+                ('disk-full', 1), ('no-disk', -1),
+                ('disk-not-formatted', 2)
+            )
+
+        error = ErrorCode('disk-full')
+    """
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x02)
+    )
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    #: Default :py:class:`~pyasn1.type.namedval.NamedValues` object
+    #: representing symbolic aliases for numbers
+    namedValues = namedval.NamedValues()
+
+    # Optimization for faster codec lookup
+    typeId = base.SimpleAsn1Type.getTypeId()
+
+    def __init__(self, value=noValue, **kwargs):
+        if 'namedValues' not in kwargs:
+            kwargs['namedValues'] = self.namedValues
+
+        base.SimpleAsn1Type.__init__(self, value, **kwargs)
+
+    def __and__(self, value):
+        return self.clone(self._value & value)
+
+    def __rand__(self, value):
+        return self.clone(value & self._value)
+
+    def __or__(self, value):
+        return self.clone(self._value | value)
+
+    def __ror__(self, value):
+        return self.clone(value | self._value)
+
+    def __xor__(self, value):
+        return self.clone(self._value ^ value)
+
+    def __rxor__(self, value):
+        return self.clone(value ^ self._value)
+
+    def __lshift__(self, value):
+        return self.clone(self._value << value)
+
+    def __rshift__(self, value):
+        return self.clone(self._value >> value)
+
+    def __add__(self, value):
+        return self.clone(self._value + value)
+
+    def __radd__(self, value):
+        return self.clone(value + self._value)
+
+    def __sub__(self, value):
+        return self.clone(self._value - value)
+
+    def __rsub__(self, value):
+        return self.clone(value - self._value)
+
+    def __mul__(self, value):
+        return self.clone(self._value * value)
+
+    def __rmul__(self, value):
+        return self.clone(value * self._value)
+
+    def __mod__(self, value):
+        return self.clone(self._value % value)
+
+    def __rmod__(self, value):
+        return self.clone(value % self._value)
+
+    def __pow__(self, value, modulo=None):
+        return self.clone(pow(self._value, value, modulo))
+
+    def __rpow__(self, value):
+        return self.clone(pow(value, self._value))
+
+    def __floordiv__(self, value):
+        return self.clone(self._value // value)
+
+    def __rfloordiv__(self, value):
+        return self.clone(value // self._value)
+
+    if sys.version_info[0] <= 2:
+        def __div__(self, value):
+            if isinstance(value, float):
+                return Real(self._value / value)
+            else:
+                return self.clone(self._value / value)
+
+        def __rdiv__(self, value):
+            if isinstance(value, float):
+                return Real(value / self._value)
+            else:
+                return self.clone(value / self._value)
+    else:
+        def __truediv__(self, value):
+            return Real(self._value / value)
+
+        def __rtruediv__(self, value):
+            return Real(value / self._value)
+
+        def __divmod__(self, value):
+            return self.clone(divmod(self._value, value))
+
+        def __rdivmod__(self, value):
+            return self.clone(divmod(value, self._value))
+
+        __hash__ = base.SimpleAsn1Type.__hash__
+
+    def __int__(self):
+        return int(self._value)
+
+    if sys.version_info[0] <= 2:
+        def __long__(self):
+            return long(self._value)
+
+    def __float__(self):
+        return float(self._value)
+
+    def __abs__(self):
+        return self.clone(abs(self._value))
+
+    def __index__(self):
+        return int(self._value)
+
+    def __pos__(self):
+        return self.clone(+self._value)
+
+    def __neg__(self):
+        return self.clone(-self._value)
+
+    def __invert__(self):
+        return self.clone(~self._value)
+
+    def __round__(self, n=0):
+        r = round(self._value, n)
+        if n:
+            return self.clone(r)
+        else:
+            return r
+
+    def __floor__(self):
+        return math.floor(self._value)
+
+    def __ceil__(self):
+        return math.ceil(self._value)
+
+    if sys.version_info[0:2] > (2, 5):
+        def __trunc__(self):
+            return self.clone(math.trunc(self._value))
+
+    def __lt__(self, value):
+        return self._value < value
+
+    def __le__(self, value):
+        return self._value <= value
+
+    def __eq__(self, value):
+        return self._value == value
+
+    def __ne__(self, value):
+        return self._value != value
+
+    def __gt__(self, value):
+        return self._value > value
+
+    def __ge__(self, value):
+        return self._value >= value
+
+    def prettyIn(self, value):
+        try:
+            return int(value)
+
+        except ValueError:
+            try:
+                return self.namedValues[value]
+
+            except KeyError:
+                raise error.PyAsn1Error(
+                    'Can\'t coerce %r into integer: %s' % (value, sys.exc_info()[1])
+                )
+
+    def prettyOut(self, value):
+        try:
+            return str(self.namedValues[value])
+
+        except KeyError:
+            return str(value)
+
+    # backward compatibility
+
+    def getNamedValues(self):
+        return self.namedValues
+
+
+class Boolean(Integer):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its
+    objects are immutable and duck-type Python :class:`int` objects.
+
+    Keyword Args
+    ------------
+    value: :class:`int`, :class:`str` or |ASN.1| object
+        Python :class:`int` or :class:`str` literal or |ASN.1| class
+        instance. If `value` is not given, schema object will be created.
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s).Constraints
+        verification for |ASN.1| type occurs automatically on object
+        instantiation.
+
+    namedValues: :py:class:`~pyasn1.type.namedval.NamedValues`
+        Object representing non-default symbolic aliases for numbers
+
+    Raises
+    ------
+    ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error
+        On constraint violation or bad initializer.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class RoundResult(Boolean):
+            '''
+            ASN.1 specification:
+
+            RoundResult ::= BOOLEAN
+
+            ok RoundResult ::= TRUE
+            ko RoundResult ::= FALSE
+            '''
+        ok = RoundResult(True)
+        ko = RoundResult(False)
+    """
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x01),
+    )
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = Integer.subtypeSpec + constraint.SingleValueConstraint(0, 1)
+
+    #: Default :py:class:`~pyasn1.type.namedval.NamedValues` object
+    #: representing symbolic aliases for numbers
+    namedValues = namedval.NamedValues(('False', 0), ('True', 1))
+
+    # Optimization for faster codec lookup
+    typeId = Integer.getTypeId()
+
+if sys.version_info[0] < 3:
+    SizedIntegerBase = long
+else:
+    SizedIntegerBase = int
+
+
+class SizedInteger(SizedIntegerBase):
+    bitLength = leadingZeroBits = None
+
+    def setBitLength(self, bitLength):
+        self.bitLength = bitLength
+        self.leadingZeroBits = max(bitLength - integer.bitLength(self), 0)
+        return self
+
+    def __len__(self):
+        if self.bitLength is None:
+            self.setBitLength(integer.bitLength(self))
+
+        return self.bitLength
+
+
+class BitString(base.SimpleAsn1Type):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its
+    objects are immutable and duck-type both Python :class:`tuple` (as a tuple
+    of bits) and :class:`int` objects.
+
+    Keyword Args
+    ------------
+    value: :class:`int`, :class:`str` or |ASN.1| object
+        Python :class:`int` or :class:`str` literal representing binary
+        or hexadecimal number or sequence of integer bits or |ASN.1| object.
+        If `value` is not given, schema object will be created.
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s). Constraints
+        verification for |ASN.1| type occurs automatically on object
+        instantiation.
+
+    namedValues: :py:class:`~pyasn1.type.namedval.NamedValues`
+        Object representing non-default symbolic aliases for numbers
+
+    binValue: :py:class:`str`
+        Binary string initializer to use instead of the *value*.
+        Example: '10110011'.
+
+    hexValue: :py:class:`str`
+        Hexadecimal string initializer to use instead of the *value*.
+        Example: 'DEADBEEF'.
+
+    Raises
+    ------
+    ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error
+        On constraint violation or bad initializer.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class Rights(BitString):
+            '''
+            ASN.1 specification:
+
+            Rights ::= BIT STRING { user-read(0), user-write(1),
+                                    group-read(2), group-write(3),
+                                    other-read(4), other-write(5) }
+
+            group1 Rights ::= { group-read, group-write }
+            group2 Rights ::= '0011'B
+            group3 Rights ::= '3'H
+            '''
+            namedValues = NamedValues(
+                ('user-read', 0), ('user-write', 1),
+                ('group-read', 2), ('group-write', 3),
+                ('other-read', 4), ('other-write', 5)
+            )
+
+        group1 = Rights(('group-read', 'group-write'))
+        group2 = Rights('0011')
+        group3 = Rights(0x3)
+    """
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x03)
+    )
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    #: Default :py:class:`~pyasn1.type.namedval.NamedValues` object
+    #: representing symbolic aliases for numbers
+    namedValues = namedval.NamedValues()
+
+    # Optimization for faster codec lookup
+    typeId = base.SimpleAsn1Type.getTypeId()
+
+    defaultBinValue = defaultHexValue = noValue
+
+    def __init__(self, value=noValue, **kwargs):
+        if value is noValue:
+            if kwargs:
+                try:
+                    value = self.fromBinaryString(kwargs.pop('binValue'), internalFormat=True)
+
+                except KeyError:
+                    pass
+
+                try:
+                    value = self.fromHexString(kwargs.pop('hexValue'), internalFormat=True)
+
+                except KeyError:
+                    pass
+
+        if value is noValue:
+            if self.defaultBinValue is not noValue:
+                value = self.fromBinaryString(self.defaultBinValue, internalFormat=True)
+
+            elif self.defaultHexValue is not noValue:
+                value = self.fromHexString(self.defaultHexValue, internalFormat=True)
+
+        if 'namedValues' not in kwargs:
+            kwargs['namedValues'] = self.namedValues
+
+        base.SimpleAsn1Type.__init__(self, value, **kwargs)
+
+    def __str__(self):
+        return self.asBinary()
+
+    def __eq__(self, other):
+        other = self.prettyIn(other)
+        return self is other or self._value == other and len(self._value) == len(other)
+
+    def __ne__(self, other):
+        other = self.prettyIn(other)
+        return self._value != other or len(self._value) != len(other)
+
+    def __lt__(self, other):
+        other = self.prettyIn(other)
+        return len(self._value) < len(other) or len(self._value) == len(other) and self._value < other
+
+    def __le__(self, other):
+        other = self.prettyIn(other)
+        return len(self._value) <= len(other) or len(self._value) == len(other) and self._value <= other
+
+    def __gt__(self, other):
+        other = self.prettyIn(other)
+        return len(self._value) > len(other) or len(self._value) == len(other) and self._value > other
+
+    def __ge__(self, other):
+        other = self.prettyIn(other)
+        return len(self._value) >= len(other) or len(self._value) == len(other) and self._value >= other
+
+    # Immutable sequence object protocol
+
+    def __len__(self):
+        return len(self._value)
+
+    def __getitem__(self, i):
+        if i.__class__ is slice:
+            return self.clone([self[x] for x in range(*i.indices(len(self)))])
+        else:
+            length = len(self._value) - 1
+            if i > length or i < 0:
+                raise IndexError('bit index out of range')
+            return (self._value >> (length - i)) & 1
+
+    def __iter__(self):
+        length = len(self._value)
+        while length:
+            length -= 1
+            yield (self._value >> length) & 1
+
+    def __reversed__(self):
+        return reversed(tuple(self))
+
+    # arithmetic operators
+
+    def __add__(self, value):
+        value = self.prettyIn(value)
+        return self.clone(SizedInteger(self._value << len(value) | value).setBitLength(len(self._value) + len(value)))
+
+    def __radd__(self, value):
+        value = self.prettyIn(value)
+        return self.clone(SizedInteger(value << len(self._value) | self._value).setBitLength(len(self._value) + len(value)))
+
+    def __mul__(self, value):
+        bitString = self._value
+        while value > 1:
+            bitString <<= len(self._value)
+            bitString |= self._value
+            value -= 1
+        return self.clone(bitString)
+
+    def __rmul__(self, value):
+        return self * value
+
+    def __lshift__(self, count):
+        return self.clone(SizedInteger(self._value << count).setBitLength(len(self._value) + count))
+
+    def __rshift__(self, count):
+        return self.clone(SizedInteger(self._value >> count).setBitLength(max(0, len(self._value) - count)))
+
+    def __int__(self):
+        return self._value
+
+    def __float__(self):
+        return float(self._value)
+
+    if sys.version_info[0] < 3:
+        def __long__(self):
+            return self._value
+
+    def asNumbers(self):
+        """Get |ASN.1| value as a sequence of 8-bit integers.
+
+        If |ASN.1| object length is not a multiple of 8, result
+        will be left-padded with zeros.
+        """
+        return tuple(octets.octs2ints(self.asOctets()))
+
+    def asOctets(self):
+        """Get |ASN.1| value as a sequence of octets.
+
+        If |ASN.1| object length is not a multiple of 8, result
+        will be left-padded with zeros.
+        """
+        return integer.to_bytes(self._value, length=len(self))
+
+    def asInteger(self):
+        """Get |ASN.1| value as a single integer value.
+        """
+        return self._value
+
+    def asBinary(self):
+        """Get |ASN.1| value as a text string of bits.
+        """
+        binString = binary.bin(self._value)[2:]
+        return '0' * (len(self._value) - len(binString)) + binString
+
+    @classmethod
+    def fromHexString(cls, value, internalFormat=False, prepend=None):
+        """Create a |ASN.1| object initialized from the hex string.
+
+        Parameters
+        ----------
+        value: :class:`str`
+            Text string like 'DEADBEEF'
+        """
+        try:
+            value = SizedInteger(value, 16).setBitLength(len(value) * 4)
+
+        except ValueError:
+            raise error.PyAsn1Error('%s.fromHexString() error: %s' % (cls.__name__, sys.exc_info()[1]))
+
+        if prepend is not None:
+            value = SizedInteger(
+                (SizedInteger(prepend) << len(value)) | value
+            ).setBitLength(len(prepend) + len(value))
+
+        if not internalFormat:
+            value = cls(value)
+
+        return value
+
+    @classmethod
+    def fromBinaryString(cls, value, internalFormat=False, prepend=None):
+        """Create a |ASN.1| object initialized from a string of '0' and '1'.
+
+        Parameters
+        ----------
+        value: :class:`str`
+            Text string like '1010111'
+        """
+        try:
+            value = SizedInteger(value or '0', 2).setBitLength(len(value))
+
+        except ValueError:
+            raise error.PyAsn1Error('%s.fromBinaryString() error: %s' % (cls.__name__, sys.exc_info()[1]))
+
+        if prepend is not None:
+            value = SizedInteger(
+                (SizedInteger(prepend) << len(value)) | value
+            ).setBitLength(len(prepend) + len(value))
+
+        if not internalFormat:
+            value = cls(value)
+
+        return value
+
+    @classmethod
+    def fromOctetString(cls, value, internalFormat=False, prepend=None, padding=0):
+        """Create a |ASN.1| object initialized from a string.
+
+        Parameters
+        ----------
+        value: :class:`str` (Py2) or :class:`bytes` (Py3)
+            Text string like '\\\\x01\\\\xff' (Py2) or b'\\\\x01\\\\xff' (Py3)
+        """
+        value = SizedInteger(integer.from_bytes(value) >> padding).setBitLength(len(value) * 8 - padding)
+
+        if prepend is not None:
+            value = SizedInteger(
+                (SizedInteger(prepend) << len(value)) | value
+            ).setBitLength(len(prepend) + len(value))
+
+        if not internalFormat:
+            value = cls(value)
+
+        return value
+
+    def prettyIn(self, value):
+        if isinstance(value, SizedInteger):
+            return value
+        elif octets.isStringType(value):
+            if not value:
+                return SizedInteger(0).setBitLength(0)
+
+            elif value[0] == '\'':  # "'1011'B" -- ASN.1 schema representation (deprecated)
+                if value[-2:] == '\'B':
+                    return self.fromBinaryString(value[1:-2], internalFormat=True)
+                elif value[-2:] == '\'H':
+                    return self.fromHexString(value[1:-2], internalFormat=True)
+                else:
+                    raise error.PyAsn1Error(
+                        'Bad BIT STRING value notation %s' % (value,)
+                    )
+
+            elif self.namedValues and not value.isdigit():  # named bits like 'Urgent, Active'
+                names = [x.strip() for x in value.split(',')]
+
+                try:
+
+                    bitPositions = [self.namedValues[name] for name in names]
+
+                except KeyError:
+                    raise error.PyAsn1Error('unknown bit name(s) in %r' % (names,))
+
+                rightmostPosition = max(bitPositions)
+
+                number = 0
+                for bitPosition in bitPositions:
+                    number |= 1 << (rightmostPosition - bitPosition)
+
+                return SizedInteger(number).setBitLength(rightmostPosition + 1)
+
+            elif value.startswith('0x'):
+                return self.fromHexString(value[2:], internalFormat=True)
+
+            elif value.startswith('0b'):
+                return self.fromBinaryString(value[2:], internalFormat=True)
+
+            else:  # assume plain binary string like '1011'
+                return self.fromBinaryString(value, internalFormat=True)
+
+        elif isinstance(value, (tuple, list)):
+            return self.fromBinaryString(''.join([b and '1' or '0' for b in value]), internalFormat=True)
+
+        elif isinstance(value, BitString):
+            return SizedInteger(value).setBitLength(len(value))
+
+        elif isinstance(value, intTypes):
+            return SizedInteger(value)
+
+        else:
+            raise error.PyAsn1Error(
+                'Bad BitString initializer type \'%s\'' % (value,)
+            )
+
+
+try:
+    # noinspection PyStatementEffect
+    all
+
+except NameError:  # Python 2.4
+    # noinspection PyShadowingBuiltins
+    def all(iterable):
+        for element in iterable:
+            if not element:
+                return False
+        return True
+
+
+class OctetString(base.SimpleAsn1Type):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its
+    objects are immutable and duck-type Python 2 :class:`str` or
+    Python 3 :class:`bytes`. When used in Unicode context, |ASN.1| type
+    assumes "|encoding|" serialisation.
+
+    Keyword Args
+    ------------
+    value: :class:`unicode`, :class:`str`, :class:`bytes` or |ASN.1| object
+        class:`str` (Python 2) or :class:`bytes` (Python 3), alternatively
+        class:`unicode` object (Python 2) or :class:`str` (Python 3)
+        representing character string to be serialised into octets
+        (note `encoding` parameter) or |ASN.1| object.
+        If `value` is not given, schema object will be created.
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s). Constraints
+        verification for |ASN.1| type occurs automatically on object
+        instantiation.
+
+    encoding: :py:class:`str`
+        Unicode codec ID to encode/decode :class:`unicode` (Python 2) or
+        :class:`str` (Python 3) the payload when |ASN.1| object is used
+        in text string context.
+
+    binValue: :py:class:`str`
+        Binary string initializer to use instead of the *value*.
+        Example: '10110011'.
+
+    hexValue: :py:class:`str`
+        Hexadecimal string initializer to use instead of the *value*.
+        Example: 'DEADBEEF'.
+
+    Raises
+    ------
+    ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error
+        On constraint violation or bad initializer.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class Icon(OctetString):
+            '''
+            ASN.1 specification:
+
+            Icon ::= OCTET STRING
+
+            icon1 Icon ::= '001100010011001000110011'B
+            icon2 Icon ::= '313233'H
+            '''
+        icon1 = Icon.fromBinaryString('001100010011001000110011')
+        icon2 = Icon.fromHexString('313233')
+    """
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x04)
+    )
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    # Optimization for faster codec lookup
+    typeId = base.SimpleAsn1Type.getTypeId()
+
+    defaultBinValue = defaultHexValue = noValue
+    encoding = 'iso-8859-1'
+
+    def __init__(self, value=noValue, **kwargs):
+        if kwargs:
+            if value is noValue:
+                try:
+                    value = self.fromBinaryString(kwargs.pop('binValue'))
+
+                except KeyError:
+                    pass
+
+                try:
+                    value = self.fromHexString(kwargs.pop('hexValue'))
+
+                except KeyError:
+                    pass
+
+        if value is noValue:
+            if self.defaultBinValue is not noValue:
+                value = self.fromBinaryString(self.defaultBinValue)
+
+            elif self.defaultHexValue is not noValue:
+                value = self.fromHexString(self.defaultHexValue)
+
+        if 'encoding' not in kwargs:
+            kwargs['encoding'] = self.encoding
+
+        base.SimpleAsn1Type.__init__(self, value, **kwargs)
+
+    if sys.version_info[0] <= 2:
+        def prettyIn(self, value):
+            if isinstance(value, str):
+                return value
+
+            elif isinstance(value, unicode):
+                try:
+                    return value.encode(self.encoding)
+
+                except (LookupError, UnicodeEncodeError):
+                    exc = sys.exc_info()[1]
+                    raise error.PyAsn1UnicodeEncodeError(
+                        "Can't encode string '%s' with codec "
+                        "%s" % (value, self.encoding), exc
+                    )
+
+            elif isinstance(value, (tuple, list)):
+                try:
+                    return ''.join([chr(x) for x in value])
+
+                except ValueError:
+                    raise error.PyAsn1Error(
+                        "Bad %s initializer '%s'" % (self.__class__.__name__, value)
+                    )
+
+            else:
+                return str(value)
+
+        def __str__(self):
+            return str(self._value)
+
+        def __unicode__(self):
+            try:
+                return self._value.decode(self.encoding)
+
+            except UnicodeDecodeError:
+                exc = sys.exc_info()[1]
+                raise error.PyAsn1UnicodeDecodeError(
+                    "Can't decode string '%s' with codec "
+                    "%s" % (self._value, self.encoding), exc
+                )
+
+        def asOctets(self):
+            return str(self._value)
+
+        def asNumbers(self):
+            return tuple([ord(x) for x in self._value])
+
+    else:
+        def prettyIn(self, value):
+            if isinstance(value, bytes):
+                return value
+
+            elif isinstance(value, str):
+                try:
+                    return value.encode(self.encoding)
+
+                except UnicodeEncodeError:
+                    exc = sys.exc_info()[1]
+                    raise error.PyAsn1UnicodeEncodeError(
+                        "Can't encode string '%s' with '%s' "
+                        "codec" % (value, self.encoding), exc
+                    )
+            elif isinstance(value, OctetString):  # a shortcut, bytes() would work the same way
+                return value.asOctets()
+
+            elif isinstance(value, base.SimpleAsn1Type):  # this mostly targets Integer objects
+                return self.prettyIn(str(value))
+
+            elif isinstance(value, (tuple, list)):
+                return self.prettyIn(bytes(value))
+
+            else:
+                return bytes(value)
+
+        def __str__(self):
+            try:
+                return self._value.decode(self.encoding)
+
+            except UnicodeDecodeError:
+                exc = sys.exc_info()[1]
+                raise error.PyAsn1UnicodeDecodeError(
+                    "Can't decode string '%s' with '%s' codec at "
+                    "'%s'" % (self._value, self.encoding,
+                              self.__class__.__name__), exc
+                )
+
+        def __bytes__(self):
+            return bytes(self._value)
+
+        def asOctets(self):
+            return bytes(self._value)
+
+        def asNumbers(self):
+            return tuple(self._value)
+
+    #
+    # Normally, `.prettyPrint()` is called from `__str__()`. Historically,
+    # OctetString.prettyPrint() used to return hexified payload
+    # representation in cases when non-printable content is present. At the
+    # same time `str()` used to produce either octet-stream (Py2) or
+    # text (Py3) representations.
+    #
+    # Therefore `OctetString.__str__()` -> `.prettyPrint()` call chain is
+    # reversed to preserve the original behaviour.
+    #
+    # Eventually we should deprecate `.prettyPrint()` / `.prettyOut()` harness
+    # and end up with just `__str__()` producing hexified representation while
+    # both text and octet-stream representation should only be requested via
+    # the `.asOctets()` method.
+    #
+    # Note: ASN.1 OCTET STRING is never mean to contain text!
+    #
+
+    def prettyOut(self, value):
+        return value
+
+    def prettyPrint(self, scope=0):
+        # first see if subclass has its own .prettyOut()
+        value = self.prettyOut(self._value)
+
+        if value is not self._value:
+            return value
+
+        numbers = self.asNumbers()
+
+        for x in numbers:
+            # hexify if needed
+            if x < 32 or x > 126:
+                return '0x' + ''.join(('%.2x' % x for x in numbers))
+        else:
+            # this prevents infinite recursion
+            return OctetString.__str__(self)
+
+    @staticmethod
+    def fromBinaryString(value):
+        """Create a |ASN.1| object initialized from a string of '0' and '1'.
+
+        Parameters
+        ----------
+        value: :class:`str`
+            Text string like '1010111'
+        """
+        bitNo = 8
+        byte = 0
+        r = []
+        for v in value:
+            if bitNo:
+                bitNo -= 1
+            else:
+                bitNo = 7
+                r.append(byte)
+                byte = 0
+            if v in ('0', '1'):
+                v = int(v)
+            else:
+                raise error.PyAsn1Error(
+                    'Non-binary OCTET STRING initializer %s' % (v,)
+                )
+            byte |= v << bitNo
+
+        r.append(byte)
+
+        return octets.ints2octs(r)
+
+    @staticmethod
+    def fromHexString(value):
+        """Create a |ASN.1| object initialized from the hex string.
+
+        Parameters
+        ----------
+        value: :class:`str`
+            Text string like 'DEADBEEF'
+        """
+        r = []
+        p = []
+        for v in value:
+            if p:
+                r.append(int(p + v, 16))
+                p = None
+            else:
+                p = v
+        if p:
+            r.append(int(p + '0', 16))
+
+        return octets.ints2octs(r)
+
+    # Immutable sequence object protocol
+
+    def __len__(self):
+        return len(self._value)
+
+    def __getitem__(self, i):
+        if i.__class__ is slice:
+            return self.clone(self._value[i])
+        else:
+            return self._value[i]
+
+    def __iter__(self):
+        return iter(self._value)
+
+    def __contains__(self, value):
+        return value in self._value
+
+    def __add__(self, value):
+        return self.clone(self._value + self.prettyIn(value))
+
+    def __radd__(self, value):
+        return self.clone(self.prettyIn(value) + self._value)
+
+    def __mul__(self, value):
+        return self.clone(self._value * value)
+
+    def __rmul__(self, value):
+        return self * value
+
+    def __int__(self):
+        return int(self._value)
+
+    def __float__(self):
+        return float(self._value)
+
+    def __reversed__(self):
+        return reversed(self._value)
+
+
+class Null(OctetString):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its
+    objects are immutable and duck-type Python :class:`str` objects
+    (always empty).
+
+    Keyword Args
+    ------------
+    value: :class:`str` or |ASN.1| object
+        Python empty :class:`str` literal or any object that evaluates to :obj:`False`
+        If `value` is not given, schema object will be created.
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    Raises
+    ------
+    ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error
+        On constraint violation or bad initializer.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class Ack(Null):
+            '''
+            ASN.1 specification:
+
+            Ack ::= NULL
+            '''
+        ack = Ack('')
+    """
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x05)
+    )
+    subtypeSpec = OctetString.subtypeSpec + constraint.SingleValueConstraint(octets.str2octs(''))
+
+    # Optimization for faster codec lookup
+    typeId = OctetString.getTypeId()
+
+    def prettyIn(self, value):
+        if value:
+            return value
+
+        return octets.str2octs('')
+
+if sys.version_info[0] <= 2:
+    intTypes = (int, long)
+else:
+    intTypes = (int,)
+
+numericTypes = intTypes + (float,)
+
+
+class ObjectIdentifier(base.SimpleAsn1Type):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its
+    objects are immutable and duck-type Python :class:`tuple` objects
+    (tuple of non-negative integers).
+
+    Keyword Args
+    ------------
+    value: :class:`tuple`, :class:`str` or |ASN.1| object
+        Python sequence of :class:`int` or :class:`str` literal or |ASN.1| object.
+        If `value` is not given, schema object will be created.
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s). Constraints
+        verification for |ASN.1| type occurs automatically on object
+        instantiation.
+
+    Raises
+    ------
+    ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error
+        On constraint violation or bad initializer.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class ID(ObjectIdentifier):
+            '''
+            ASN.1 specification:
+
+            ID ::= OBJECT IDENTIFIER
+
+            id-edims ID ::= { joint-iso-itu-t mhs-motif(6) edims(7) }
+            id-bp ID ::= { id-edims 11 }
+            '''
+        id_edims = ID('2.6.7')
+        id_bp = id_edims + (11,)
+    """
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x06)
+    )
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    # Optimization for faster codec lookup
+    typeId = base.SimpleAsn1Type.getTypeId()
+
+    def __add__(self, other):
+        return self.clone(self._value + other)
+
+    def __radd__(self, other):
+        return self.clone(other + self._value)
+
+    def asTuple(self):
+        return self._value
+
+    # Sequence object protocol
+
+    def __len__(self):
+        return len(self._value)
+
+    def __getitem__(self, i):
+        if i.__class__ is slice:
+            return self.clone(self._value[i])
+        else:
+            return self._value[i]
+
+    def __iter__(self):
+        return iter(self._value)
+
+    def __contains__(self, value):
+        return value in self._value
+
+    def index(self, suboid):
+        return self._value.index(suboid)
+
+    def isPrefixOf(self, other):
+        """Indicate if this |ASN.1| object is a prefix of other |ASN.1| object.
+
+        Parameters
+        ----------
+        other: |ASN.1| object
+            |ASN.1| object
+
+        Returns
+        -------
+        : :class:`bool`
+            :obj:`True` if this |ASN.1| object is a parent (e.g. prefix) of the other |ASN.1| object
+            or :obj:`False` otherwise.
+        """
+        l = len(self)
+        if l <= len(other):
+            if self._value[:l] == other[:l]:
+                return True
+        return False
+
+    def prettyIn(self, value):
+        if isinstance(value, ObjectIdentifier):
+            return tuple(value)
+        elif octets.isStringType(value):
+            if '-' in value:
+                raise error.PyAsn1Error(
+                    'Malformed Object ID %s at %s: %s' % (value, self.__class__.__name__, sys.exc_info()[1])
+                )
+            try:
+                return tuple([int(subOid) for subOid in value.split('.') if subOid])
+            except ValueError:
+                raise error.PyAsn1Error(
+                    'Malformed Object ID %s at %s: %s' % (value, self.__class__.__name__, sys.exc_info()[1])
+                )
+
+        try:
+            tupleOfInts = tuple([int(subOid) for subOid in value if subOid >= 0])
+
+        except (ValueError, TypeError):
+            raise error.PyAsn1Error(
+                'Malformed Object ID %s at %s: %s' % (value, self.__class__.__name__, sys.exc_info()[1])
+            )
+
+        if len(tupleOfInts) == len(value):
+            return tupleOfInts
+
+        raise error.PyAsn1Error('Malformed Object ID %s at %s' % (value, self.__class__.__name__))
+
+    def prettyOut(self, value):
+        return '.'.join([str(x) for x in value])
+
+
+class Real(base.SimpleAsn1Type):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its
+    objects are immutable and duck-type Python :class:`float` objects.
+    Additionally, |ASN.1| objects behave like a :class:`tuple` in which case its
+    elements are mantissa, base and exponent.
+
+    Keyword Args
+    ------------
+    value: :class:`tuple`, :class:`float` or |ASN.1| object
+        Python sequence of :class:`int` (representing mantissa, base and
+        exponent) or :class:`float` instance or |ASN.1| object.
+        If `value` is not given, schema object will be created.
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s). Constraints
+        verification for |ASN.1| type occurs automatically on object
+        instantiation.
+
+    Raises
+    ------
+    ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error
+        On constraint violation or bad initializer.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class Pi(Real):
+            '''
+            ASN.1 specification:
+
+            Pi ::= REAL
+
+            pi Pi ::= { mantissa 314159, base 10, exponent -5 }
+
+            '''
+        pi = Pi((314159, 10, -5))
+    """
+    binEncBase = None  # binEncBase = 16 is recommended for large numbers
+
+    try:
+        _plusInf = float('inf')
+        _minusInf = float('-inf')
+        _inf = _plusInf, _minusInf
+
+    except ValueError:
+        # Infinity support is platform and Python dependent
+        _plusInf = _minusInf = None
+        _inf = ()
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x09)
+    )
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    # Optimization for faster codec lookup
+    typeId = base.SimpleAsn1Type.getTypeId()
+
+    @staticmethod
+    def __normalizeBase10(value):
+        m, b, e = value
+        while m and m % 10 == 0:
+            m /= 10
+            e += 1
+        return m, b, e
+
+    def prettyIn(self, value):
+        if isinstance(value, tuple) and len(value) == 3:
+            if (not isinstance(value[0], numericTypes) or
+                    not isinstance(value[1], intTypes) or
+                    not isinstance(value[2], intTypes)):
+                raise error.PyAsn1Error('Lame Real value syntax: %s' % (value,))
+            if (isinstance(value[0], float) and
+                    self._inf and value[0] in self._inf):
+                return value[0]
+            if value[1] not in (2, 10):
+                raise error.PyAsn1Error(
+                    'Prohibited base for Real value: %s' % (value[1],)
+                )
+            if value[1] == 10:
+                value = self.__normalizeBase10(value)
+            return value
+        elif isinstance(value, intTypes):
+            return self.__normalizeBase10((value, 10, 0))
+        elif isinstance(value, float) or octets.isStringType(value):
+            if octets.isStringType(value):
+                try:
+                    value = float(value)
+                except ValueError:
+                    raise error.PyAsn1Error(
+                        'Bad real value syntax: %s' % (value,)
+                    )
+            if self._inf and value in self._inf:
+                return value
+            else:
+                e = 0
+                while int(value) != value:
+                    value *= 10
+                    e -= 1
+                return self.__normalizeBase10((int(value), 10, e))
+        elif isinstance(value, Real):
+            return tuple(value)
+        raise error.PyAsn1Error(
+            'Bad real value syntax: %s' % (value,)
+        )
+
+    def prettyPrint(self, scope=0):
+        try:
+            return self.prettyOut(float(self))
+
+        except OverflowError:
+            return '<overflow>'
+
+    @property
+    def isPlusInf(self):
+        """Indicate PLUS-INFINITY object value
+
+        Returns
+        -------
+        : :class:`bool`
+            :obj:`True` if calling object represents plus infinity
+            or :obj:`False` otherwise.
+
+        """
+        return self._value == self._plusInf
+
+    @property
+    def isMinusInf(self):
+        """Indicate MINUS-INFINITY object value
+
+        Returns
+        -------
+        : :class:`bool`
+            :obj:`True` if calling object represents minus infinity
+            or :obj:`False` otherwise.
+        """
+        return self._value == self._minusInf
+
+    @property
+    def isInf(self):
+        return self._value in self._inf
+
+    def __add__(self, value):
+        return self.clone(float(self) + value)
+
+    def __radd__(self, value):
+        return self + value
+
+    def __mul__(self, value):
+        return self.clone(float(self) * value)
+
+    def __rmul__(self, value):
+        return self * value
+
+    def __sub__(self, value):
+        return self.clone(float(self) - value)
+
+    def __rsub__(self, value):
+        return self.clone(value - float(self))
+
+    def __mod__(self, value):
+        return self.clone(float(self) % value)
+
+    def __rmod__(self, value):
+        return self.clone(value % float(self))
+
+    def __pow__(self, value, modulo=None):
+        return self.clone(pow(float(self), value, modulo))
+
+    def __rpow__(self, value):
+        return self.clone(pow(value, float(self)))
+
+    if sys.version_info[0] <= 2:
+        def __div__(self, value):
+            return self.clone(float(self) / value)
+
+        def __rdiv__(self, value):
+            return self.clone(value / float(self))
+    else:
+        def __truediv__(self, value):
+            return self.clone(float(self) / value)
+
+        def __rtruediv__(self, value):
+            return self.clone(value / float(self))
+
+        def __divmod__(self, value):
+            return self.clone(float(self) // value)
+
+        def __rdivmod__(self, value):
+            return self.clone(value // float(self))
+
+    def __int__(self):
+        return int(float(self))
+
+    if sys.version_info[0] <= 2:
+        def __long__(self):
+            return long(float(self))
+
+    def __float__(self):
+        if self._value in self._inf:
+            return self._value
+        else:
+            return float(
+                self._value[0] * pow(self._value[1], self._value[2])
+            )
+
+    def __abs__(self):
+        return self.clone(abs(float(self)))
+
+    def __pos__(self):
+        return self.clone(+float(self))
+
+    def __neg__(self):
+        return self.clone(-float(self))
+
+    def __round__(self, n=0):
+        r = round(float(self), n)
+        if n:
+            return self.clone(r)
+        else:
+            return r
+
+    def __floor__(self):
+        return self.clone(math.floor(float(self)))
+
+    def __ceil__(self):
+        return self.clone(math.ceil(float(self)))
+
+    if sys.version_info[0:2] > (2, 5):
+        def __trunc__(self):
+            return self.clone(math.trunc(float(self)))
+
+    def __lt__(self, value):
+        return float(self) < value
+
+    def __le__(self, value):
+        return float(self) <= value
+
+    def __eq__(self, value):
+        return float(self) == value
+
+    def __ne__(self, value):
+        return float(self) != value
+
+    def __gt__(self, value):
+        return float(self) > value
+
+    def __ge__(self, value):
+        return float(self) >= value
+
+    if sys.version_info[0] <= 2:
+        def __nonzero__(self):
+            return bool(float(self))
+    else:
+        def __bool__(self):
+            return bool(float(self))
+
+        __hash__ = base.SimpleAsn1Type.__hash__
+
+    def __getitem__(self, idx):
+        if self._value in self._inf:
+            raise error.PyAsn1Error('Invalid infinite value operation')
+        else:
+            return self._value[idx]
+
+    # compatibility stubs
+
+    def isPlusInfinity(self):
+        return self.isPlusInf
+
+    def isMinusInfinity(self):
+        return self.isMinusInf
+
+    def isInfinity(self):
+        return self.isInf
+
+
+class Enumerated(Integer):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its
+    objects are immutable and duck-type Python :class:`int` objects.
+
+    Keyword Args
+    ------------
+    value: :class:`int`, :class:`str` or |ASN.1| object
+        Python :class:`int` or :class:`str` literal or |ASN.1| object.
+        If `value` is not given, schema object will be created.
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s). Constraints
+        verification for |ASN.1| type occurs automatically on object
+        instantiation.
+
+    namedValues: :py:class:`~pyasn1.type.namedval.NamedValues`
+        Object representing non-default symbolic aliases for numbers
+
+    Raises
+    ------
+    ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error
+        On constraint violation or bad initializer.
+
+    Examples
+    --------
+
+    .. code-block:: python
+
+        class RadioButton(Enumerated):
+            '''
+            ASN.1 specification:
+
+            RadioButton ::= ENUMERATED { button1(0), button2(1),
+                                         button3(2) }
+
+            selected-by-default RadioButton ::= button1
+            '''
+            namedValues = NamedValues(
+                ('button1', 0), ('button2', 1),
+                ('button3', 2)
+            )
+
+        selected_by_default = RadioButton('button1')
+    """
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x0A)
+    )
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    # Optimization for faster codec lookup
+    typeId = Integer.getTypeId()
+
+    #: Default :py:class:`~pyasn1.type.namedval.NamedValues` object
+    #: representing symbolic aliases for numbers
+    namedValues = namedval.NamedValues()
+
+
+# "Structured" ASN.1 types
+
+class SequenceOfAndSetOfBase(base.ConstructedAsn1Type):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.ConstructedAsn1Type`,
+    its objects are mutable and duck-type Python :class:`list` objects.
+
+    Keyword Args
+    ------------
+    componentType : :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+        A pyasn1 object representing ASN.1 type allowed within |ASN.1| type
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s). Constraints
+        verification for |ASN.1| type can only occur on explicit
+        `.isInconsistent` call.
+
+    Examples
+    --------
+
+    .. code-block:: python
+
+        class LotteryDraw(SequenceOf):  #  SetOf is similar
+            '''
+            ASN.1 specification:
+
+            LotteryDraw ::= SEQUENCE OF INTEGER
+            '''
+            componentType = Integer()
+
+        lotteryDraw = LotteryDraw()
+        lotteryDraw.extend([123, 456, 789])
+    """
+    def __init__(self, *args, **kwargs):
+        # support positional params for backward compatibility
+        if args:
+            for key, value in zip(('componentType', 'tagSet',
+                                   'subtypeSpec'), args):
+                if key in kwargs:
+                    raise error.PyAsn1Error('Conflicting positional and keyword params!')
+                kwargs['componentType'] = value
+
+        self._componentValues = noValue
+
+        base.ConstructedAsn1Type.__init__(self, **kwargs)
+
+    # Python list protocol
+
+    def __getitem__(self, idx):
+        try:
+            return self.getComponentByPosition(idx)
+
+        except error.PyAsn1Error:
+            raise IndexError(sys.exc_info()[1])
+
+    def __setitem__(self, idx, value):
+        try:
+            self.setComponentByPosition(idx, value)
+
+        except error.PyAsn1Error:
+            raise IndexError(sys.exc_info()[1])
+
+    def append(self, value):
+        if self._componentValues is noValue:
+            pos = 0
+
+        else:
+            pos = len(self._componentValues)
+
+        self[pos] = value
+
+    def count(self, value):
+        return list(self._componentValues.values()).count(value)
+
+    def extend(self, values):
+        for value in values:
+            self.append(value)
+
+        if self._componentValues is noValue:
+            self._componentValues = {}
+
+    def index(self, value, start=0, stop=None):
+        if stop is None:
+            stop = len(self)
+
+        indices, values = zip(*self._componentValues.items())
+
+        # TODO: remove when Py2.5 support is gone
+        values = list(values)
+
+        try:
+            return indices[values.index(value, start, stop)]
+
+        except error.PyAsn1Error:
+            raise ValueError(sys.exc_info()[1])
+
+    def reverse(self):
+        self._componentValues.reverse()
+
+    def sort(self, key=None, reverse=False):
+        self._componentValues = dict(
+            enumerate(sorted(self._componentValues.values(),
+                             key=key, reverse=reverse)))
+
+    def __len__(self):
+        if self._componentValues is noValue or not self._componentValues:
+            return 0
+
+        return max(self._componentValues) + 1
+
+    def __iter__(self):
+        for idx in range(0, len(self)):
+            yield self.getComponentByPosition(idx)
+
+    def _cloneComponentValues(self, myClone, cloneValueFlag):
+        for idx, componentValue in self._componentValues.items():
+            if componentValue is not noValue:
+                if isinstance(componentValue, base.ConstructedAsn1Type):
+                    myClone.setComponentByPosition(
+                        idx, componentValue.clone(cloneValueFlag=cloneValueFlag)
+                    )
+                else:
+                    myClone.setComponentByPosition(idx, componentValue.clone())
+
+    def getComponentByPosition(self, idx, default=noValue, instantiate=True):
+        """Return |ASN.1| type component value by position.
+
+        Equivalent to Python sequence subscription operation (e.g. `[]`).
+
+        Parameters
+        ----------
+        idx : :class:`int`
+            Component index (zero-based). Must either refer to an existing
+            component or to N+1 component (if *componentType* is set). In the latter
+            case a new component type gets instantiated and appended to the |ASN.1|
+            sequence.
+
+        Keyword Args
+        ------------
+        default: :class:`object`
+            If set and requested component is a schema object, return the `default`
+            object instead of the requested component.
+
+        instantiate: :class:`bool`
+            If :obj:`True` (default), inner component will be automatically instantiated.
+            If :obj:`False` either existing component or the :class:`NoValue` object will be
+            returned.
+
+        Returns
+        -------
+        : :py:class:`~pyasn1.type.base.PyAsn1Item`
+            Instantiate |ASN.1| component type or return existing component value
+
+        Examples
+        --------
+
+        .. code-block:: python
+
+            # can also be SetOf
+            class MySequenceOf(SequenceOf):
+                componentType = OctetString()
+
+            s = MySequenceOf()
+
+            # returns component #0 with `.isValue` property False
+            s.getComponentByPosition(0)
+
+            # returns None
+            s.getComponentByPosition(0, default=None)
+
+            s.clear()
+
+            # returns noValue
+            s.getComponentByPosition(0, instantiate=False)
+
+            # sets component #0 to OctetString() ASN.1 schema
+            # object and returns it
+            s.getComponentByPosition(0, instantiate=True)
+
+            # sets component #0 to ASN.1 value object
+            s.setComponentByPosition(0, 'ABCD')
+
+            # returns OctetString('ABCD') value object
+            s.getComponentByPosition(0, instantiate=False)
+
+            s.clear()
+
+            # returns noValue
+            s.getComponentByPosition(0, instantiate=False)
+        """
+        if isinstance(idx, slice):
+            indices = tuple(range(len(self)))
+            return [self.getComponentByPosition(subidx, default, instantiate)
+                    for subidx in indices[idx]]
+
+        if idx < 0:
+            idx = len(self) + idx
+            if idx < 0:
+                raise error.PyAsn1Error(
+                    'SequenceOf/SetOf index is out of range')
+
+        try:
+            componentValue = self._componentValues[idx]
+
+        except (KeyError, error.PyAsn1Error):
+            if not instantiate:
+                return default
+
+            self.setComponentByPosition(idx)
+
+            componentValue = self._componentValues[idx]
+
+        if default is noValue or componentValue.isValue:
+            return componentValue
+        else:
+            return default
+
+    def setComponentByPosition(self, idx, value=noValue,
+                               verifyConstraints=True,
+                               matchTags=True,
+                               matchConstraints=True):
+        """Assign |ASN.1| type component by position.
+
+        Equivalent to Python sequence item assignment operation (e.g. `[]`)
+        or list.append() (when idx == len(self)).
+
+        Parameters
+        ----------
+        idx: :class:`int`
+            Component index (zero-based). Must either refer to existing
+            component or to N+1 component. In the latter case a new component
+            type gets instantiated (if *componentType* is set, or given ASN.1
+            object is taken otherwise) and appended to the |ASN.1| sequence.
+
+        Keyword Args
+        ------------
+        value: :class:`object` or :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+            A Python value to initialize |ASN.1| component with (if *componentType* is set)
+            or ASN.1 value object to assign to |ASN.1| component.
+            If `value` is not given, schema object will be set as a component.
+
+        verifyConstraints: :class:`bool`
+             If :obj:`False`, skip constraints validation
+
+        matchTags: :class:`bool`
+             If :obj:`False`, skip component tags matching
+
+        matchConstraints: :class:`bool`
+             If :obj:`False`, skip component constraints matching
+
+        Returns
+        -------
+        self
+
+        Raises
+        ------
+        ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error
+            On constraint violation or bad initializer
+        IndexError
+            When idx > len(self)
+        """
+        if isinstance(idx, slice):
+            indices = tuple(range(len(self)))
+            startIdx = indices and indices[idx][0] or 0
+            for subIdx, subValue in enumerate(value):
+                self.setComponentByPosition(
+                    startIdx + subIdx, subValue, verifyConstraints,
+                    matchTags, matchConstraints)
+            return self
+
+        if idx < 0:
+            idx = len(self) + idx
+            if idx < 0:
+                raise error.PyAsn1Error(
+                    'SequenceOf/SetOf index is out of range')
+
+        componentType = self.componentType
+
+        if self._componentValues is noValue:
+            componentValues = {}
+
+        else:
+            componentValues = self._componentValues
+
+        currentValue = componentValues.get(idx, noValue)
+
+        if value is noValue:
+            if componentType is not None:
+                value = componentType.clone()
+
+            elif currentValue is noValue:
+                raise error.PyAsn1Error('Component type not defined')
+
+        elif not isinstance(value, base.Asn1Item):
+            if (componentType is not None and
+                    isinstance(componentType, base.SimpleAsn1Type)):
+                value = componentType.clone(value=value)
+
+            elif (currentValue is not noValue and
+                    isinstance(currentValue, base.SimpleAsn1Type)):
+                value = currentValue.clone(value=value)
+
+            else:
+                raise error.PyAsn1Error(
+                    'Non-ASN.1 value %r and undefined component'
+                    ' type at %r' % (value, self))
+
+        elif componentType is not None and (matchTags or matchConstraints):
+            subtypeChecker = (
+                    self.strictConstraints and
+                    componentType.isSameTypeWith or
+                    componentType.isSuperTypeOf)
+
+            if not subtypeChecker(value, verifyConstraints and matchTags,
+                                  verifyConstraints and matchConstraints):
+                # TODO: we should wrap componentType with UnnamedType to carry
+                # additional properties associated with componentType
+                if componentType.typeId != Any.typeId:
+                    raise error.PyAsn1Error(
+                        'Component value is tag-incompatible: %r vs '
+                        '%r' % (value, componentType))
+
+        componentValues[idx] = value
+
+        self._componentValues = componentValues
+
+        return self
+
+    @property
+    def componentTagMap(self):
+        if self.componentType is not None:
+            return self.componentType.tagMap
+
+    @property
+    def components(self):
+        return [self._componentValues[idx]
+                for idx in sorted(self._componentValues)]
+
+    def clear(self):
+        """Remove all components and become an empty |ASN.1| value object.
+
+        Has the same effect on |ASN.1| object as it does on :class:`list`
+        built-in.
+        """
+        self._componentValues = {}
+        return self
+
+    def reset(self):
+        """Remove all components and become a |ASN.1| schema object.
+
+        See :meth:`isValue` property for more information on the
+        distinction between value and schema objects.
+        """
+        self._componentValues = noValue
+        return self
+
+    def prettyPrint(self, scope=0):
+        scope += 1
+        representation = self.__class__.__name__ + ':\n'
+
+        if not self.isValue:
+            return representation
+
+        for idx, componentValue in enumerate(self):
+            representation += ' ' * scope
+            if (componentValue is noValue and
+                    self.componentType is not None):
+                representation += '<empty>'
+            else:
+                representation += componentValue.prettyPrint(scope)
+
+        return representation
+
+    def prettyPrintType(self, scope=0):
+        scope += 1
+        representation = '%s -> %s {\n' % (self.tagSet, self.__class__.__name__)
+        if self.componentType is not None:
+            representation += ' ' * scope
+            representation += self.componentType.prettyPrintType(scope)
+        return representation + '\n' + ' ' * (scope - 1) + '}'
+
+
+    @property
+    def isValue(self):
+        """Indicate that |ASN.1| object represents ASN.1 value.
+
+        If *isValue* is :obj:`False` then this object represents just ASN.1 schema.
+
+        If *isValue* is :obj:`True` then, in addition to its ASN.1 schema features,
+        this object can also be used like a Python built-in object
+        (e.g. :class:`int`, :class:`str`, :class:`dict` etc.).
+
+        Returns
+        -------
+        : :class:`bool`
+            :obj:`False` if object represents just ASN.1 schema.
+            :obj:`True` if object represents ASN.1 schema and can be used as a normal value.
+
+        Note
+        ----
+        There is an important distinction between PyASN1 schema and value objects.
+        The PyASN1 schema objects can only participate in ASN.1 schema-related
+        operations (e.g. defining or testing the structure of the data). Most
+        obvious uses of ASN.1 schema is to guide serialisation codecs whilst
+        encoding/decoding serialised ASN.1 contents.
+
+        The PyASN1 value objects can **additionally** participate in many operations
+        involving regular Python objects (e.g. arithmetic, comprehension etc).
+        """
+        if self._componentValues is noValue:
+            return False
+
+        if len(self._componentValues) != len(self):
+            return False
+
+        for componentValue in self._componentValues.values():
+            if componentValue is noValue or not componentValue.isValue:
+                return False
+
+        return True
+
+    @property
+    def isInconsistent(self):
+        """Run necessary checks to ensure |ASN.1| object consistency.
+
+        Default action is to verify |ASN.1| object against constraints imposed
+        by `subtypeSpec`.
+
+        Raises
+        ------
+        :py:class:`~pyasn1.error.PyAsn1tError` on any inconsistencies found
+        """
+        if self.componentType is noValue or not self.subtypeSpec:
+            return False
+
+        if self._componentValues is noValue:
+            return True
+
+        mapping = {}
+
+        for idx, value in self._componentValues.items():
+            # Absent fields are not in the mapping
+            if value is noValue:
+                continue
+
+            mapping[idx] = value
+
+        try:
+            # Represent SequenceOf/SetOf as a bare dict to constraints chain
+            self.subtypeSpec(mapping)
+
+        except error.PyAsn1Error:
+            exc = sys.exc_info()[1]
+            return exc
+
+        return False
+
+class SequenceOf(SequenceOfAndSetOfBase):
+    __doc__ = SequenceOfAndSetOfBase.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
+    )
+
+    #: Default :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+    #: object representing ASN.1 type allowed within |ASN.1| type
+    componentType = None
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    # Disambiguation ASN.1 types identification
+    typeId = SequenceOfAndSetOfBase.getTypeId()
+
+
+class SetOf(SequenceOfAndSetOfBase):
+    __doc__ = SequenceOfAndSetOfBase.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
+    )
+
+    #: Default :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+    #: object representing ASN.1 type allowed within |ASN.1| type
+    componentType = None
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    # Disambiguation ASN.1 types identification
+    typeId = SequenceOfAndSetOfBase.getTypeId()
+
+
+class SequenceAndSetBase(base.ConstructedAsn1Type):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.ConstructedAsn1Type`,
+    its objects are mutable and duck-type Python :class:`dict` objects.
+
+    Keyword Args
+    ------------
+    componentType: :py:class:`~pyasn1.type.namedtype.NamedType`
+        Object holding named ASN.1 types allowed within this collection
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s).  Constraints
+        verification for |ASN.1| type can only occur on explicit
+        `.isInconsistent` call.
+
+    Examples
+    --------
+
+    .. code-block:: python
+
+        class Description(Sequence):  #  Set is similar
+            '''
+            ASN.1 specification:
+
+            Description ::= SEQUENCE {
+                surname    IA5String,
+                first-name IA5String OPTIONAL,
+                age        INTEGER DEFAULT 40
+            }
+            '''
+            componentType = NamedTypes(
+                NamedType('surname', IA5String()),
+                OptionalNamedType('first-name', IA5String()),
+                DefaultedNamedType('age', Integer(40))
+            )
+
+        descr = Description()
+        descr['surname'] = 'Smith'
+        descr['first-name'] = 'John'
+    """
+    #: Default :py:class:`~pyasn1.type.namedtype.NamedTypes`
+    #: object representing named ASN.1 types allowed within |ASN.1| type
+    componentType = namedtype.NamedTypes()
+
+
+    class DynamicNames(object):
+        """Fields names/positions mapping for component-less objects"""
+        def __init__(self):
+            self._keyToIdxMap = {}
+            self._idxToKeyMap = {}
+
+        def __len__(self):
+            return len(self._keyToIdxMap)
+
+        def __contains__(self, item):
+            return item in self._keyToIdxMap or item in self._idxToKeyMap
+
+        def __iter__(self):
+            return (self._idxToKeyMap[idx] for idx in range(len(self._idxToKeyMap)))
+
+        def __getitem__(self, item):
+            try:
+                return self._keyToIdxMap[item]
+
+            except KeyError:
+                return self._idxToKeyMap[item]
+
+        def getNameByPosition(self, idx):
+            try:
+                return self._idxToKeyMap[idx]
+
+            except KeyError:
+                raise error.PyAsn1Error('Type position out of range')
+
+        def getPositionByName(self, name):
+            try:
+                return self._keyToIdxMap[name]
+
+            except KeyError:
+                raise error.PyAsn1Error('Name %s not found' % (name,))
+
+        def addField(self, idx):
+            self._keyToIdxMap['field-%d' % idx] = idx
+            self._idxToKeyMap[idx] = 'field-%d' % idx
+
+
+    def __init__(self, **kwargs):
+        base.ConstructedAsn1Type.__init__(self, **kwargs)
+        self._componentTypeLen = len(self.componentType)
+        if self._componentTypeLen:
+            self._componentValues = []
+        else:
+            self._componentValues = noValue
+        self._dynamicNames = self._componentTypeLen or self.DynamicNames()
+
+    def __getitem__(self, idx):
+        if octets.isStringType(idx):
+            try:
+                return self.getComponentByName(idx)
+
+            except error.PyAsn1Error:
+                # duck-typing dict
+                raise KeyError(sys.exc_info()[1])
+
+        else:
+            try:
+                return self.getComponentByPosition(idx)
+
+            except error.PyAsn1Error:
+                # duck-typing list
+                raise IndexError(sys.exc_info()[1])
+
+    def __setitem__(self, idx, value):
+        if octets.isStringType(idx):
+            try:
+                self.setComponentByName(idx, value)
+
+            except error.PyAsn1Error:
+                # duck-typing dict
+                raise KeyError(sys.exc_info()[1])
+
+        else:
+            try:
+                self.setComponentByPosition(idx, value)
+
+            except error.PyAsn1Error:
+                # duck-typing list
+                raise IndexError(sys.exc_info()[1])
+
+    def __contains__(self, key):
+        if self._componentTypeLen:
+            return key in self.componentType
+        else:
+            return key in self._dynamicNames
+
+    def __len__(self):
+        return len(self._componentValues)
+
+    def __iter__(self):
+        return iter(self.componentType or self._dynamicNames)
+
+    # Python dict protocol
+
+    def values(self):
+        for idx in range(self._componentTypeLen or len(self._dynamicNames)):
+            yield self[idx]
+
+    def keys(self):
+        return iter(self)
+
+    def items(self):
+        for idx in range(self._componentTypeLen or len(self._dynamicNames)):
+            if self._componentTypeLen:
+                yield self.componentType[idx].name, self[idx]
+            else:
+                yield self._dynamicNames[idx], self[idx]
+
+    def update(self, *iterValue, **mappingValue):
+        for k, v in iterValue:
+            self[k] = v
+        for k in mappingValue:
+            self[k] = mappingValue[k]
+
+    def clear(self):
+        """Remove all components and become an empty |ASN.1| value object.
+
+        Has the same effect on |ASN.1| object as it does on :class:`dict`
+        built-in.
+        """
+        self._componentValues = []
+        self._dynamicNames = self.DynamicNames()
+        return self
+
+    def reset(self):
+        """Remove all components and become a |ASN.1| schema object.
+
+        See :meth:`isValue` property for more information on the
+        distinction between value and schema objects.
+        """
+        self._componentValues = noValue
+        self._dynamicNames = self.DynamicNames()
+        return self
+
+    @property
+    def components(self):
+        return self._componentValues
+
+    def _cloneComponentValues(self, myClone, cloneValueFlag):
+        if self._componentValues is noValue:
+            return
+
+        for idx, componentValue in enumerate(self._componentValues):
+            if componentValue is not noValue:
+                if isinstance(componentValue, base.ConstructedAsn1Type):
+                    myClone.setComponentByPosition(
+                        idx, componentValue.clone(cloneValueFlag=cloneValueFlag)
+                    )
+                else:
+                    myClone.setComponentByPosition(idx, componentValue.clone())
+
+    def getComponentByName(self, name, default=noValue, instantiate=True):
+        """Returns |ASN.1| type component by name.
+
+        Equivalent to Python :class:`dict` subscription operation (e.g. `[]`).
+
+        Parameters
+        ----------
+        name: :class:`str`
+            |ASN.1| type component name
+
+        Keyword Args
+        ------------
+        default: :class:`object`
+            If set and requested component is a schema object, return the `default`
+            object instead of the requested component.
+
+        instantiate: :class:`bool`
+            If :obj:`True` (default), inner component will be automatically
+            instantiated.
+            If :obj:`False` either existing component or the :class:`NoValue`
+            object will be returned.
+
+        Returns
+        -------
+        : :py:class:`~pyasn1.type.base.PyAsn1Item`
+            Instantiate |ASN.1| component type or return existing
+            component value
+        """
+        if self._componentTypeLen:
+            idx = self.componentType.getPositionByName(name)
+        else:
+            try:
+                idx = self._dynamicNames.getPositionByName(name)
+
+            except KeyError:
+                raise error.PyAsn1Error('Name %s not found' % (name,))
+
+        return self.getComponentByPosition(idx, default=default, instantiate=instantiate)
+
+    def setComponentByName(self, name, value=noValue,
+                           verifyConstraints=True,
+                           matchTags=True,
+                           matchConstraints=True):
+        """Assign |ASN.1| type component by name.
+
+        Equivalent to Python :class:`dict` item assignment operation (e.g. `[]`).
+
+        Parameters
+        ----------
+        name: :class:`str`
+            |ASN.1| type component name
+
+        Keyword Args
+        ------------
+        value: :class:`object` or :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+            A Python value to initialize |ASN.1| component with (if *componentType* is set)
+            or ASN.1 value object to assign to |ASN.1| component.
+            If `value` is not given, schema object will be set as a component.
+
+        verifyConstraints: :class:`bool`
+             If :obj:`False`, skip constraints validation
+
+        matchTags: :class:`bool`
+             If :obj:`False`, skip component tags matching
+
+        matchConstraints: :class:`bool`
+             If :obj:`False`, skip component constraints matching
+
+        Returns
+        -------
+        self
+        """
+        if self._componentTypeLen:
+            idx = self.componentType.getPositionByName(name)
+        else:
+            try:
+                idx = self._dynamicNames.getPositionByName(name)
+
+            except KeyError:
+                raise error.PyAsn1Error('Name %s not found' % (name,))
+
+        return self.setComponentByPosition(
+            idx, value, verifyConstraints, matchTags, matchConstraints
+        )
+
+    def getComponentByPosition(self, idx, default=noValue, instantiate=True):
+        """Returns |ASN.1| type component by index.
+
+        Equivalent to Python sequence subscription operation (e.g. `[]`).
+
+        Parameters
+        ----------
+        idx: :class:`int`
+            Component index (zero-based). Must either refer to an existing
+            component or (if *componentType* is set) new ASN.1 schema object gets
+            instantiated.
+
+        Keyword Args
+        ------------
+        default: :class:`object`
+            If set and requested component is a schema object, return the `default`
+            object instead of the requested component.
+
+        instantiate: :class:`bool`
+            If :obj:`True` (default), inner component will be automatically
+            instantiated.
+            If :obj:`False` either existing component or the :class:`NoValue`
+            object will be returned.
+
+        Returns
+        -------
+        : :py:class:`~pyasn1.type.base.PyAsn1Item`
+            a PyASN1 object
+
+        Examples
+        --------
+
+        .. code-block:: python
+
+            # can also be Set
+            class MySequence(Sequence):
+                componentType = NamedTypes(
+                    NamedType('id', OctetString())
+                )
+
+            s = MySequence()
+
+            # returns component #0 with `.isValue` property False
+            s.getComponentByPosition(0)
+
+            # returns None
+            s.getComponentByPosition(0, default=None)
+
+            s.clear()
+
+            # returns noValue
+            s.getComponentByPosition(0, instantiate=False)
+
+            # sets component #0 to OctetString() ASN.1 schema
+            # object and returns it
+            s.getComponentByPosition(0, instantiate=True)
+
+            # sets component #0 to ASN.1 value object
+            s.setComponentByPosition(0, 'ABCD')
+
+            # returns OctetString('ABCD') value object
+            s.getComponentByPosition(0, instantiate=False)
+
+            s.clear()
+
+            # returns noValue
+            s.getComponentByPosition(0, instantiate=False)
+        """
+        try:
+            if self._componentValues is noValue:
+                componentValue = noValue
+
+            else:
+                componentValue = self._componentValues[idx]
+
+        except IndexError:
+            componentValue = noValue
+
+        if not instantiate:
+            if componentValue is noValue or not componentValue.isValue:
+                return default
+            else:
+                return componentValue
+
+        if componentValue is noValue:
+            self.setComponentByPosition(idx)
+
+        componentValue = self._componentValues[idx]
+
+        if default is noValue or componentValue.isValue:
+            return componentValue
+        else:
+            return default
+
+    def setComponentByPosition(self, idx, value=noValue,
+                               verifyConstraints=True,
+                               matchTags=True,
+                               matchConstraints=True):
+        """Assign |ASN.1| type component by position.
+
+        Equivalent to Python sequence item assignment operation (e.g. `[]`).
+
+        Parameters
+        ----------
+        idx : :class:`int`
+            Component index (zero-based). Must either refer to existing
+            component (if *componentType* is set) or to N+1 component
+            otherwise. In the latter case a new component of given ASN.1
+            type gets instantiated and appended to |ASN.1| sequence.
+
+        Keyword Args
+        ------------
+        value: :class:`object` or :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+            A Python value to initialize |ASN.1| component with (if *componentType* is set)
+            or ASN.1 value object to assign to |ASN.1| component.
+            If `value` is not given, schema object will be set as a component.
+
+        verifyConstraints : :class:`bool`
+             If :obj:`False`, skip constraints validation
+
+        matchTags: :class:`bool`
+             If :obj:`False`, skip component tags matching
+
+        matchConstraints: :class:`bool`
+             If :obj:`False`, skip component constraints matching
+
+        Returns
+        -------
+        self
+        """
+        componentType = self.componentType
+        componentTypeLen = self._componentTypeLen
+
+        if self._componentValues is noValue:
+            componentValues = []
+
+        else:
+            componentValues = self._componentValues
+
+        try:
+            currentValue = componentValues[idx]
+
+        except IndexError:
+            currentValue = noValue
+            if componentTypeLen:
+                if componentTypeLen < idx:
+                    raise error.PyAsn1Error('component index out of range')
+
+                componentValues = [noValue] * componentTypeLen
+
+        if value is noValue:
+            if componentTypeLen:
+                value = componentType.getTypeByPosition(idx)
+                if isinstance(value, base.ConstructedAsn1Type):
+                    value = value.clone(cloneValueFlag=componentType[idx].isDefaulted)
+
+            elif currentValue is noValue:
+                raise error.PyAsn1Error('Component type not defined')
+
+        elif not isinstance(value, base.Asn1Item):
+            if componentTypeLen:
+                subComponentType = componentType.getTypeByPosition(idx)
+                if isinstance(subComponentType, base.SimpleAsn1Type):
+                    value = subComponentType.clone(value=value)
+
+                else:
+                    raise error.PyAsn1Error('%s can cast only scalar values' % componentType.__class__.__name__)
+
+            elif currentValue is not noValue and isinstance(currentValue, base.SimpleAsn1Type):
+                value = currentValue.clone(value=value)
+
+            else:
+                raise error.PyAsn1Error('%s undefined component type' % componentType.__class__.__name__)
+
+        elif ((verifyConstraints or matchTags or matchConstraints) and
+              componentTypeLen):
+            subComponentType = componentType.getTypeByPosition(idx)
+            if subComponentType is not noValue:
+                subtypeChecker = (self.strictConstraints and
+                                  subComponentType.isSameTypeWith or
+                                  subComponentType.isSuperTypeOf)
+
+                if not subtypeChecker(value, verifyConstraints and matchTags,
+                                      verifyConstraints and matchConstraints):
+                    if not componentType[idx].openType:
+                        raise error.PyAsn1Error('Component value is tag-incompatible: %r vs %r' % (value, componentType))
+
+        if componentTypeLen or idx in self._dynamicNames:
+            componentValues[idx] = value
+
+        elif len(componentValues) == idx:
+            componentValues.append(value)
+            self._dynamicNames.addField(idx)
+
+        else:
+            raise error.PyAsn1Error('Component index out of range')
+
+        self._componentValues = componentValues
+
+        return self
+
+    @property
+    def isValue(self):
+        """Indicate that |ASN.1| object represents ASN.1 value.
+
+        If *isValue* is :obj:`False` then this object represents just ASN.1 schema.
+
+        If *isValue* is :obj:`True` then, in addition to its ASN.1 schema features,
+        this object can also be used like a Python built-in object (e.g.
+        :class:`int`, :class:`str`, :class:`dict` etc.).
+
+        Returns
+        -------
+        : :class:`bool`
+            :obj:`False` if object represents just ASN.1 schema.
+            :obj:`True` if object represents ASN.1 schema and can be used as a
+            normal value.
+
+        Note
+        ----
+        There is an important distinction between PyASN1 schema and value objects.
+        The PyASN1 schema objects can only participate in ASN.1 schema-related
+        operations (e.g. defining or testing the structure of the data). Most
+        obvious uses of ASN.1 schema is to guide serialisation codecs whilst
+        encoding/decoding serialised ASN.1 contents.
+
+        The PyASN1 value objects can **additionally** participate in many operations
+        involving regular Python objects (e.g. arithmetic, comprehension etc).
+
+        It is sufficient for |ASN.1| objects to have all non-optional and non-defaulted
+        components being value objects to be considered as a value objects as a whole.
+        In other words, even having one or more optional components not turned into
+        value objects, |ASN.1| object is still considered as a value object. Defaulted
+        components are normally value objects by default.
+        """
+        if self._componentValues is noValue:
+            return False
+
+        componentType = self.componentType
+
+        if componentType:
+            for idx, subComponentType in enumerate(componentType.namedTypes):
+                if subComponentType.isDefaulted or subComponentType.isOptional:
+                    continue
+
+                if not self._componentValues:
+                    return False
+
+                componentValue = self._componentValues[idx]
+                if componentValue is noValue or not componentValue.isValue:
+                    return False
+
+        else:
+            for componentValue in self._componentValues:
+                if componentValue is noValue or not componentValue.isValue:
+                    return False
+
+        return True
+
+    @property
+    def isInconsistent(self):
+        """Run necessary checks to ensure |ASN.1| object consistency.
+
+        Default action is to verify |ASN.1| object against constraints imposed
+        by `subtypeSpec`.
+
+        Raises
+        ------
+        :py:class:`~pyasn1.error.PyAsn1tError` on any inconsistencies found
+        """
+        if self.componentType is noValue or not self.subtypeSpec:
+            return False
+
+        if self._componentValues is noValue:
+            return True
+
+        mapping = {}
+
+        for idx, value in enumerate(self._componentValues):
+            # Absent fields are not in the mapping
+            if value is noValue:
+                continue
+
+            name = self.componentType.getNameByPosition(idx)
+
+            mapping[name] = value
+
+        try:
+            # Represent Sequence/Set as a bare dict to constraints chain
+            self.subtypeSpec(mapping)
+
+        except error.PyAsn1Error:
+            exc = sys.exc_info()[1]
+            return exc
+
+        return False
+
+    def prettyPrint(self, scope=0):
+        """Return an object representation string.
+
+        Returns
+        -------
+        : :class:`str`
+            Human-friendly object representation.
+        """
+        scope += 1
+        representation = self.__class__.__name__ + ':\n'
+        for idx, componentValue in enumerate(self._componentValues):
+            if componentValue is not noValue and componentValue.isValue:
+                representation += ' ' * scope
+                if self.componentType:
+                    representation += self.componentType.getNameByPosition(idx)
+                else:
+                    representation += self._dynamicNames.getNameByPosition(idx)
+                representation = '%s=%s\n' % (
+                    representation, componentValue.prettyPrint(scope)
+                )
+        return representation
+
+    def prettyPrintType(self, scope=0):
+        scope += 1
+        representation = '%s -> %s {\n' % (self.tagSet, self.__class__.__name__)
+        for idx, componentType in enumerate(self.componentType.values() or self._componentValues):
+            representation += ' ' * scope
+            if self.componentType:
+                representation += '"%s"' % self.componentType.getNameByPosition(idx)
+            else:
+                representation += '"%s"' % self._dynamicNames.getNameByPosition(idx)
+            representation = '%s = %s\n' % (
+                representation, componentType.prettyPrintType(scope)
+            )
+        return representation + '\n' + ' ' * (scope - 1) + '}'
+
+    # backward compatibility
+
+    def setDefaultComponents(self):
+        return self
+
+    def getComponentType(self):
+        if self._componentTypeLen:
+            return self.componentType
+
+    def getNameByPosition(self, idx):
+        if self._componentTypeLen:
+            return self.componentType[idx].name
+
+class Sequence(SequenceAndSetBase):
+    __doc__ = SequenceAndSetBase.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
+    )
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    #: Default collection of ASN.1 types of component (e.g. :py:class:`~pyasn1.type.namedtype.NamedType`)
+    #: object imposing size constraint on |ASN.1| objects
+    componentType = namedtype.NamedTypes()
+
+    # Disambiguation ASN.1 types identification
+    typeId = SequenceAndSetBase.getTypeId()
+
+    # backward compatibility
+
+    def getComponentTagMapNearPosition(self, idx):
+        if self.componentType:
+            return self.componentType.getTagMapNearPosition(idx)
+
+    def getComponentPositionNearType(self, tagSet, idx):
+        if self.componentType:
+            return self.componentType.getPositionNearType(tagSet, idx)
+        else:
+            return idx
+
+
+class Set(SequenceAndSetBase):
+    __doc__ = SequenceAndSetBase.__doc__
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.initTagSet(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
+    )
+
+    #: Default collection of ASN.1 types of component (e.g. :py:class:`~pyasn1.type.namedtype.NamedType`)
+    #: object representing ASN.1 type allowed within |ASN.1| type
+    componentType = namedtype.NamedTypes()
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    # Disambiguation ASN.1 types identification
+    typeId = SequenceAndSetBase.getTypeId()
+
+    def getComponent(self, innerFlag=False):
+        return self
+
+    def getComponentByType(self, tagSet, default=noValue,
+                           instantiate=True, innerFlag=False):
+        """Returns |ASN.1| type component by ASN.1 tag.
+
+        Parameters
+        ----------
+        tagSet : :py:class:`~pyasn1.type.tag.TagSet`
+            Object representing ASN.1 tags to identify one of
+            |ASN.1| object component
+
+        Keyword Args
+        ------------
+        default: :class:`object`
+            If set and requested component is a schema object, return the `default`
+            object instead of the requested component.
+
+        instantiate: :class:`bool`
+            If :obj:`True` (default), inner component will be automatically
+            instantiated.
+            If :obj:`False` either existing component or the :class:`noValue`
+            object will be returned.
+
+        Returns
+        -------
+        : :py:class:`~pyasn1.type.base.PyAsn1Item`
+            a pyasn1 object
+        """
+        componentValue = self.getComponentByPosition(
+            self.componentType.getPositionByType(tagSet),
+            default=default, instantiate=instantiate
+        )
+        if innerFlag and isinstance(componentValue, Set):
+            # get inner component by inner tagSet
+            return componentValue.getComponent(innerFlag=True)
+        else:
+            # get outer component by inner tagSet
+            return componentValue
+
+    def setComponentByType(self, tagSet, value=noValue,
+                           verifyConstraints=True,
+                           matchTags=True,
+                           matchConstraints=True,
+                           innerFlag=False):
+        """Assign |ASN.1| type component by ASN.1 tag.
+
+        Parameters
+        ----------
+        tagSet : :py:class:`~pyasn1.type.tag.TagSet`
+            Object representing ASN.1 tags to identify one of
+            |ASN.1| object component
+
+        Keyword Args
+        ------------
+        value: :class:`object` or :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+            A Python value to initialize |ASN.1| component with (if *componentType* is set)
+            or ASN.1 value object to assign to |ASN.1| component.
+            If `value` is not given, schema object will be set as a component.
+
+        verifyConstraints : :class:`bool`
+            If :obj:`False`, skip constraints validation
+
+        matchTags: :class:`bool`
+            If :obj:`False`, skip component tags matching
+
+        matchConstraints: :class:`bool`
+            If :obj:`False`, skip component constraints matching
+
+        innerFlag: :class:`bool`
+            If :obj:`True`, search for matching *tagSet* recursively.
+
+        Returns
+        -------
+        self
+        """
+        idx = self.componentType.getPositionByType(tagSet)
+
+        if innerFlag:  # set inner component by inner tagSet
+            componentType = self.componentType.getTypeByPosition(idx)
+
+            if componentType.tagSet:
+                return self.setComponentByPosition(
+                    idx, value, verifyConstraints, matchTags, matchConstraints
+                )
+            else:
+                componentType = self.getComponentByPosition(idx)
+                return componentType.setComponentByType(
+                    tagSet, value, verifyConstraints, matchTags, matchConstraints, innerFlag=innerFlag
+                )
+        else:  # set outer component by inner tagSet
+            return self.setComponentByPosition(
+                idx, value, verifyConstraints, matchTags, matchConstraints
+            )
+
+    @property
+    def componentTagMap(self):
+        if self.componentType:
+            return self.componentType.tagMapUnique
+
+
+class Choice(Set):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.ConstructedAsn1Type`,
+    its objects are mutable and duck-type Python :class:`list` objects.
+
+    Keyword Args
+    ------------
+    componentType: :py:class:`~pyasn1.type.namedtype.NamedType`
+        Object holding named ASN.1 types allowed within this collection
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s).  Constraints
+        verification for |ASN.1| type can only occur on explicit
+        `.isInconsistent` call.
+
+    Examples
+    --------
+
+    .. code-block:: python
+
+        class Afters(Choice):
+            '''
+            ASN.1 specification:
+
+            Afters ::= CHOICE {
+                cheese  [0] IA5String,
+                dessert [1] IA5String
+            }
+            '''
+            componentType = NamedTypes(
+                NamedType('cheese', IA5String().subtype(
+                    implicitTag=Tag(tagClassContext, tagFormatSimple, 0)
+                ),
+                NamedType('dessert', IA5String().subtype(
+                    implicitTag=Tag(tagClassContext, tagFormatSimple, 1)
+                )
+            )
+
+        afters = Afters()
+        afters['cheese'] = 'Mascarpone'
+    """
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.TagSet()  # untagged
+
+    #: Default collection of ASN.1 types of component (e.g. :py:class:`~pyasn1.type.namedtype.NamedType`)
+    #: object representing ASN.1 type allowed within |ASN.1| type
+    componentType = namedtype.NamedTypes()
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection(
+        constraint.ValueSizeConstraint(1, 1)
+    )
+
+    # Disambiguation ASN.1 types identification
+    typeId = Set.getTypeId()
+
+    _currentIdx = None
+
+    def __eq__(self, other):
+        if self._componentValues:
+            return self._componentValues[self._currentIdx] == other
+        return NotImplemented
+
+    def __ne__(self, other):
+        if self._componentValues:
+            return self._componentValues[self._currentIdx] != other
+        return NotImplemented
+
+    def __lt__(self, other):
+        if self._componentValues:
+            return self._componentValues[self._currentIdx] < other
+        return NotImplemented
+
+    def __le__(self, other):
+        if self._componentValues:
+            return self._componentValues[self._currentIdx] <= other
+        return NotImplemented
+
+    def __gt__(self, other):
+        if self._componentValues:
+            return self._componentValues[self._currentIdx] > other
+        return NotImplemented
+
+    def __ge__(self, other):
+        if self._componentValues:
+            return self._componentValues[self._currentIdx] >= other
+        return NotImplemented
+
+    if sys.version_info[0] <= 2:
+        def __nonzero__(self):
+            return self._componentValues and True or False
+    else:
+        def __bool__(self):
+            return self._componentValues and True or False
+
+    def __len__(self):
+        return self._currentIdx is not None and 1 or 0
+
+    def __contains__(self, key):
+        if self._currentIdx is None:
+            return False
+        return key == self.componentType[self._currentIdx].getName()
+
+    def __iter__(self):
+        if self._currentIdx is None:
+            raise StopIteration
+        yield self.componentType[self._currentIdx].getName()
+
+    # Python dict protocol
+
+    def values(self):
+        if self._currentIdx is not None:
+            yield self._componentValues[self._currentIdx]
+
+    def keys(self):
+        if self._currentIdx is not None:
+            yield self.componentType[self._currentIdx].getName()
+
+    def items(self):
+        if self._currentIdx is not None:
+            yield self.componentType[self._currentIdx].getName(), self[self._currentIdx]
+
+    def checkConsistency(self):
+        if self._currentIdx is None:
+            raise error.PyAsn1Error('Component not chosen')
+
+    def _cloneComponentValues(self, myClone, cloneValueFlag):
+        try:
+            component = self.getComponent()
+        except error.PyAsn1Error:
+            pass
+        else:
+            if isinstance(component, Choice):
+                tagSet = component.effectiveTagSet
+            else:
+                tagSet = component.tagSet
+            if isinstance(component, base.ConstructedAsn1Type):
+                myClone.setComponentByType(
+                    tagSet, component.clone(cloneValueFlag=cloneValueFlag)
+                )
+            else:
+                myClone.setComponentByType(tagSet, component.clone())
+
+    def getComponentByPosition(self, idx, default=noValue, instantiate=True):
+        __doc__ = Set.__doc__
+
+        if self._currentIdx is None or self._currentIdx != idx:
+            return Set.getComponentByPosition(self, idx, default=default,
+                                              instantiate=instantiate)
+
+        return self._componentValues[idx]
+
+    def setComponentByPosition(self, idx, value=noValue,
+                               verifyConstraints=True,
+                               matchTags=True,
+                               matchConstraints=True):
+        """Assign |ASN.1| type component by position.
+
+        Equivalent to Python sequence item assignment operation (e.g. `[]`).
+
+        Parameters
+        ----------
+        idx: :class:`int`
+            Component index (zero-based). Must either refer to existing
+            component or to N+1 component. In the latter case a new component
+            type gets instantiated (if *componentType* is set, or given ASN.1
+            object is taken otherwise) and appended to the |ASN.1| sequence.
+
+        Keyword Args
+        ------------
+        value: :class:`object` or :py:class:`~pyasn1.type.base.PyAsn1Item` derivative
+            A Python value to initialize |ASN.1| component with (if *componentType* is set)
+            or ASN.1 value object to assign to |ASN.1| component. Once a new value is
+            set to *idx* component, previous value is dropped.
+            If `value` is not given, schema object will be set as a component.
+
+        verifyConstraints : :class:`bool`
+            If :obj:`False`, skip constraints validation
+
+        matchTags: :class:`bool`
+            If :obj:`False`, skip component tags matching
+
+        matchConstraints: :class:`bool`
+            If :obj:`False`, skip component constraints matching
+
+        Returns
+        -------
+        self
+        """
+        oldIdx = self._currentIdx
+        Set.setComponentByPosition(self, idx, value, verifyConstraints, matchTags, matchConstraints)
+        self._currentIdx = idx
+        if oldIdx is not None and oldIdx != idx:
+            self._componentValues[oldIdx] = noValue
+        return self
+
+    @property
+    def effectiveTagSet(self):
+        """Return a :class:`~pyasn1.type.tag.TagSet` object of the currently initialized component or self (if |ASN.1| is tagged)."""
+        if self.tagSet:
+            return self.tagSet
+        else:
+            component = self.getComponent()
+            return component.effectiveTagSet
+
+    @property
+    def tagMap(self):
+        """"Return a :class:`~pyasn1.type.tagmap.TagMap` object mapping
+            ASN.1 tags to ASN.1 objects contained within callee.
+        """
+        if self.tagSet:
+            return Set.tagMap.fget(self)
+        else:
+            return self.componentType.tagMapUnique
+
+    def getComponent(self, innerFlag=False):
+        """Return currently assigned component of the |ASN.1| object.
+
+        Returns
+        -------
+        : :py:class:`~pyasn1.type.base.PyAsn1Item`
+            a PyASN1 object
+        """
+        if self._currentIdx is None:
+            raise error.PyAsn1Error('Component not chosen')
+        else:
+            c = self._componentValues[self._currentIdx]
+            if innerFlag and isinstance(c, Choice):
+                return c.getComponent(innerFlag)
+            else:
+                return c
+
+    def getName(self, innerFlag=False):
+        """Return the name of currently assigned component of the |ASN.1| object.
+
+        Returns
+        -------
+        : :py:class:`str`
+            |ASN.1| component name
+        """
+        if self._currentIdx is None:
+            raise error.PyAsn1Error('Component not chosen')
+        else:
+            if innerFlag:
+                c = self._componentValues[self._currentIdx]
+                if isinstance(c, Choice):
+                    return c.getName(innerFlag)
+            return self.componentType.getNameByPosition(self._currentIdx)
+
+    @property
+    def isValue(self):
+        """Indicate that |ASN.1| object represents ASN.1 value.
+
+        If *isValue* is :obj:`False` then this object represents just ASN.1 schema.
+
+        If *isValue* is :obj:`True` then, in addition to its ASN.1 schema features,
+        this object can also be used like a Python built-in object (e.g.
+        :class:`int`, :class:`str`, :class:`dict` etc.).
+
+        Returns
+        -------
+        : :class:`bool`
+            :obj:`False` if object represents just ASN.1 schema.
+            :obj:`True` if object represents ASN.1 schema and can be used as a normal
+            value.
+
+        Note
+        ----
+        There is an important distinction between PyASN1 schema and value objects.
+        The PyASN1 schema objects can only participate in ASN.1 schema-related
+        operations (e.g. defining or testing the structure of the data). Most
+        obvious uses of ASN.1 schema is to guide serialisation codecs whilst
+        encoding/decoding serialised ASN.1 contents.
+
+        The PyASN1 value objects can **additionally** participate in many operations
+        involving regular Python objects (e.g. arithmetic, comprehension etc).
+        """
+        if self._currentIdx is None:
+            return False
+
+        componentValue = self._componentValues[self._currentIdx]
+
+        return componentValue is not noValue and componentValue.isValue
+
+    def clear(self):
+        self._currentIdx = None
+        return Set.clear(self)
+
+    # compatibility stubs
+
+    def getMinTagSet(self):
+        return self.minTagSet
+
+
+class Any(OctetString):
+    """Create |ASN.1| schema or value object.
+
+    |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`,
+    its objects are immutable and duck-type Python 2 :class:`str` or Python 3
+    :class:`bytes`. When used in Unicode context, |ASN.1| type assumes
+    "|encoding|" serialisation.
+
+    Keyword Args
+    ------------
+    value: :class:`unicode`, :class:`str`, :class:`bytes` or |ASN.1| object
+        :class:`str` (Python 2) or :class:`bytes` (Python 3), alternatively
+        :class:`unicode` object (Python 2) or :class:`str` (Python 3)
+        representing character string to be serialised into octets (note
+        `encoding` parameter) or |ASN.1| object.
+        If `value` is not given, schema object will be created.
+
+    tagSet: :py:class:`~pyasn1.type.tag.TagSet`
+        Object representing non-default ASN.1 tag(s)
+
+    subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection`
+        Object representing non-default ASN.1 subtype constraint(s). Constraints
+        verification for |ASN.1| type occurs automatically on object
+        instantiation.
+
+    encoding: :py:class:`str`
+        Unicode codec ID to encode/decode :class:`unicode` (Python 2) or
+        :class:`str` (Python 3) the payload when |ASN.1| object is used
+        in text string context.
+
+    binValue: :py:class:`str`
+        Binary string initializer to use instead of the *value*.
+        Example: '10110011'.
+
+    hexValue: :py:class:`str`
+        Hexadecimal string initializer to use instead of the *value*.
+        Example: 'DEADBEEF'.
+
+    Raises
+    ------
+    ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error
+        On constraint violation or bad initializer.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        class Error(Sequence):
+            '''
+            ASN.1 specification:
+
+            Error ::= SEQUENCE {
+                code      INTEGER,
+                parameter ANY DEFINED BY code  -- Either INTEGER or REAL
+            }
+            '''
+            componentType=NamedTypes(
+                NamedType('code', Integer()),
+                NamedType('parameter', Any(),
+                          openType=OpenType('code', {1: Integer(),
+                                                     2: Real()}))
+            )
+
+        error = Error()
+        error['code'] = 1
+        error['parameter'] = Integer(1234)
+    """
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.tag.TagSet` object representing ASN.1 tag(s)
+    #: associated with |ASN.1| type.
+    tagSet = tag.TagSet()  # untagged
+
+    #: Set (on class, not on instance) or return a
+    #: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` object
+    #: imposing constraints on |ASN.1| type initialization values.
+    subtypeSpec = constraint.ConstraintsIntersection()
+
+    # Disambiguation ASN.1 types identification
+    typeId = OctetString.getTypeId()
+
+    @property
+    def tagMap(self):
+        """"Return a :class:`~pyasn1.type.tagmap.TagMap` object mapping
+            ASN.1 tags to ASN.1 objects contained within callee.
+        """
+        try:
+            return self._tagMap
+
+        except AttributeError:
+            self._tagMap = tagmap.TagMap(
+                {self.tagSet: self},
+                {eoo.endOfOctets.tagSet: eoo.endOfOctets},
+                self
+            )
+
+            return self._tagMap
+
+# XXX
+# coercion rules?
diff --git a/myenv/lib/python3.9/site-packages/pyasn1/type/useful.py b/myenv/lib/python3.9/site-packages/pyasn1/type/useful.py
new file mode 100644
index 0000000..7536b95
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyasn1/type/useful.py
@@ -0,0 +1,191 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import datetime
+
+from pyasn1 import error
+from pyasn1.compat import dateandtime
+from pyasn1.compat import string
+from pyasn1.type import char
+from pyasn1.type import tag
+from pyasn1.type import univ
+
+__all__ = ['ObjectDescriptor', 'GeneralizedTime', 'UTCTime']
+
+NoValue = univ.NoValue
+noValue = univ.noValue
+
+
+class ObjectDescriptor(char.GraphicString):
+    __doc__ = char.GraphicString.__doc__
+
+    #: Default :py:class:`~pyasn1.type.tag.TagSet` object for |ASN.1| objects
+    tagSet = char.GraphicString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 7)
+    )
+
+    # Optimization for faster codec lookup
+    typeId = char.GraphicString.getTypeId()
+
+
+class TimeMixIn(object):
+
+    _yearsDigits = 4
+    _hasSubsecond = False
+    _optionalMinutes = False
+    _shortTZ = False
+
+    class FixedOffset(datetime.tzinfo):
+        """Fixed offset in minutes east from UTC."""
+
+        # defaulted arguments required
+        # https: // docs.python.org / 2.3 / lib / datetime - tzinfo.html
+        def __init__(self, offset=0, name='UTC'):
+            self.__offset = datetime.timedelta(minutes=offset)
+            self.__name = name
+
+        def utcoffset(self, dt):
+            return self.__offset
+
+        def tzname(self, dt):
+            return self.__name
+
+        def dst(self, dt):
+            return datetime.timedelta(0)
+
+    UTC = FixedOffset()
+
+    @property
+    def asDateTime(self):
+        """Create :py:class:`datetime.datetime` object from a |ASN.1| object.
+
+        Returns
+        -------
+        :
+            new instance of :py:class:`datetime.datetime` object
+        """
+        text = str(self)
+        if text.endswith('Z'):
+            tzinfo = TimeMixIn.UTC
+            text = text[:-1]
+
+        elif '-' in text or '+' in text:
+            if '+' in text:
+                text, plusminus, tz = string.partition(text, '+')
+            else:
+                text, plusminus, tz = string.partition(text, '-')
+
+            if self._shortTZ and len(tz) == 2:
+                tz += '00'
+
+            if len(tz) != 4:
+                raise error.PyAsn1Error('malformed time zone offset %s' % tz)
+
+            try:
+                minutes = int(tz[:2]) * 60 + int(tz[2:])
+                if plusminus == '-':
+                    minutes *= -1
+
+            except ValueError:
+                raise error.PyAsn1Error('unknown time specification %s' % self)
+
+            tzinfo = TimeMixIn.FixedOffset(minutes, '?')
+
+        else:
+            tzinfo = None
+
+        if '.' in text or ',' in text:
+            if '.' in text:
+                text, _, ms = string.partition(text, '.')
+            else:
+                text, _, ms = string.partition(text, ',')
+
+            try:
+                ms = int(ms) * 1000
+
+            except ValueError:
+                raise error.PyAsn1Error('bad sub-second time specification %s' % self)
+
+        else:
+            ms = 0
+
+        if self._optionalMinutes and len(text) - self._yearsDigits == 6:
+            text += '0000'
+        elif len(text) - self._yearsDigits == 8:
+            text += '00'
+
+        try:
+            dt = dateandtime.strptime(text, self._yearsDigits == 4 and '%Y%m%d%H%M%S' or '%y%m%d%H%M%S')
+
+        except ValueError:
+            raise error.PyAsn1Error('malformed datetime format %s' % self)
+
+        return dt.replace(microsecond=ms, tzinfo=tzinfo)
+
+    @classmethod
+    def fromDateTime(cls, dt):
+        """Create |ASN.1| object from a :py:class:`datetime.datetime` object.
+
+        Parameters
+        ----------
+        dt: :py:class:`datetime.datetime` object
+            The `datetime.datetime` object to initialize the |ASN.1| object
+            from
+
+        Returns
+        -------
+        :
+            new instance of |ASN.1| value
+        """
+        text = dt.strftime(cls._yearsDigits == 4 and '%Y%m%d%H%M%S' or '%y%m%d%H%M%S')
+        if cls._hasSubsecond:
+            text += '.%d' % (dt.microsecond // 1000)
+
+        if dt.utcoffset():
+            seconds = dt.utcoffset().seconds
+            if seconds < 0:
+                text += '-'
+            else:
+                text += '+'
+            text += '%.2d%.2d' % (seconds // 3600, seconds % 3600)
+        else:
+            text += 'Z'
+
+        return cls(text)
+
+
+class GeneralizedTime(char.VisibleString, TimeMixIn):
+    __doc__ = char.VisibleString.__doc__
+
+    #: Default :py:class:`~pyasn1.type.tag.TagSet` object for |ASN.1| objects
+    tagSet = char.VisibleString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 24)
+    )
+
+    # Optimization for faster codec lookup
+    typeId = char.VideotexString.getTypeId()
+
+    _yearsDigits = 4
+    _hasSubsecond = True
+    _optionalMinutes = True
+    _shortTZ = True
+
+
+class UTCTime(char.VisibleString, TimeMixIn):
+    __doc__ = char.VisibleString.__doc__
+
+    #: Default :py:class:`~pyasn1.type.tag.TagSet` object for |ASN.1| objects
+    tagSet = char.VisibleString.tagSet.tagImplicitly(
+        tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 23)
+    )
+
+    # Optimization for faster codec lookup
+    typeId = char.VideotexString.getTypeId()
+
+    _yearsDigits = 2
+    _hasSubsecond = False
+    _optionalMinutes = False
+    _shortTZ = False
diff --git a/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/LICENSE
new file mode 100644
index 0000000..ea215f2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/LICENSE
@@ -0,0 +1,27 @@
+pycparser -- A C parser in Python
+
+Copyright (c) 2008-2020, Eli Bendersky
+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 Eli Bendersky nor the names of its contributors may 
+  be used to endorse or promote products derived from this software without 
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
+GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 
+OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/METADATA b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/METADATA
new file mode 100644
index 0000000..1d0fbd6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/METADATA
@@ -0,0 +1,31 @@
+Metadata-Version: 2.1
+Name: pycparser
+Version: 2.21
+Summary: C parser in Python
+Home-page: https://github.com/eliben/pycparser
+Author: Eli Bendersky
+Author-email: eliben@gmail.com
+Maintainer: Eli Bendersky
+License: BSD
+Platform: Cross Platform
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
+
+
+pycparser is a complete parser of the C language, written in
+pure Python using the PLY parsing library.
+It parses C code into an AST and can serve as a front-end for
+C compilers or analysis tools.
+
+
diff --git a/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/RECORD b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/RECORD
new file mode 100644
index 0000000..2303855
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/RECORD
@@ -0,0 +1,24 @@
+pycparser/__init__.py,sha256=WUEp5D0fuHBH9Q8c1fYvR2eKWfj-CNghLf2MMlQLI1I,2815
+pycparser/_ast_gen.py,sha256=0JRVnDW-Jw-3IjVlo8je9rbAcp6Ko7toHAnB5zi7h0Q,10555
+pycparser/_build_tables.py,sha256=oZCd3Plhq-vkV-QuEsaahcf-jUI6-HgKsrAL9gvFzuU,1039
+pycparser/_c_ast.cfg,sha256=ld5ezE9yzIJFIVAUfw7ezJSlMi4nXKNCzfmqjOyQTNo,4255
+pycparser/ast_transforms.py,sha256=GTMYlUgWmXd5wJVyovXY1qzzAqjxzCpVVg0664dKGBs,5691
+pycparser/c_ast.py,sha256=HWeOrfYdCY0u5XaYhE1i60uVyE3yMWdcxzECUX-DqJw,31445
+pycparser/c_generator.py,sha256=yi6Mcqxv88J5ue8k5-mVGxh3iJ37iD4QyF-sWcGjC-8,17772
+pycparser/c_lexer.py,sha256=xCpjIb6vOUebBJpdifidb08y7XgAsO3T1gNGXJT93-w,17167
+pycparser/c_parser.py,sha256=_8y3i52bL6SUK21KmEEl0qzHxe-0eZRzjZGkWg8gQ4A,73680
+pycparser/lextab.py,sha256=fIxBAHYRC418oKF52M7xb8_KMj3K-tHx0TzZiKwxjPM,8504
+pycparser/plyparser.py,sha256=8tLOoEytcapvWrr1JfCf7Dog-wulBtS1YrDs8S7JfMo,4875
+pycparser/yacctab.py,sha256=j_fVNIyDWDRVk7eWMqQtlBw2AwUSV5JTrtT58l7zis0,205652
+pycparser/ply/__init__.py,sha256=q4s86QwRsYRa20L9ueSxfh-hPihpftBjDOvYa2_SS2Y,102
+pycparser/ply/cpp.py,sha256=UtC3ylTWp5_1MKA-PLCuwKQR8zSOnlGuGGIdzj8xS98,33282
+pycparser/ply/ctokens.py,sha256=MKksnN40TehPhgVfxCJhjj_BjL943apreABKYz-bl0Y,3177
+pycparser/ply/lex.py,sha256=7Qol57x702HZwjA3ZLp-84CUEWq1EehW-N67Wzghi-M,42918
+pycparser/ply/yacc.py,sha256=eatSDkRLgRr6X3-hoDk_SQQv065R0BdL2K7fQ54CgVM,137323
+pycparser/ply/ygen.py,sha256=2JYNeYtrPz1JzLSLO3d4GsS8zJU8jY_I_CR1VI9gWrA,2251
+pycparser-2.21.dist-info/LICENSE,sha256=Pn3yW437ZYyakVAZMNTZQ7BQh6g0fH4rQyVhavU1BHs,1536
+pycparser-2.21.dist-info/METADATA,sha256=GvTEQA9yKj0nvP4mknfoGpMvjaJXCQjQANcQHrRrAxc,1108
+pycparser-2.21.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+pycparser-2.21.dist-info/top_level.txt,sha256=c-lPcS74L_8KoH7IE6PQF5ofyirRQNV4VhkbSFIPeWM,10
+pycparser-2.21.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+pycparser-2.21.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/WHEEL
new file mode 100644
index 0000000..ef99c6c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/top_level.txt
new file mode 100644
index 0000000..dc1c9e1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser-2.21.dist-info/top_level.txt
@@ -0,0 +1 @@
+pycparser
diff --git a/myenv/lib/python3.9/site-packages/pycparser/__init__.py b/myenv/lib/python3.9/site-packages/pycparser/__init__.py
new file mode 100644
index 0000000..d82eb2d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/__init__.py
@@ -0,0 +1,90 @@
+#-----------------------------------------------------------------
+# pycparser: __init__.py
+#
+# This package file exports some convenience functions for
+# interacting with pycparser
+#
+# Eli Bendersky [https://eli.thegreenplace.net/]
+# License: BSD
+#-----------------------------------------------------------------
+__all__ = ['c_lexer', 'c_parser', 'c_ast']
+__version__ = '2.21'
+
+import io
+from subprocess import check_output
+from .c_parser import CParser
+
+
+def preprocess_file(filename, cpp_path='cpp', cpp_args=''):
+    """ Preprocess a file using cpp.
+
+        filename:
+            Name of the file you want to preprocess.
+
+        cpp_path:
+        cpp_args:
+            Refer to the documentation of parse_file for the meaning of these
+            arguments.
+
+        When successful, returns the preprocessed file's contents.
+        Errors from cpp will be printed out.
+    """
+    path_list = [cpp_path]
+    if isinstance(cpp_args, list):
+        path_list += cpp_args
+    elif cpp_args != '':
+        path_list += [cpp_args]
+    path_list += [filename]
+
+    try:
+        # Note the use of universal_newlines to treat all newlines
+        # as \n for Python's purpose
+        text = check_output(path_list, universal_newlines=True)
+    except OSError as e:
+        raise RuntimeError("Unable to invoke 'cpp'.  " +
+            'Make sure its path was passed correctly\n' +
+            ('Original error: %s' % e))
+
+    return text
+
+
+def parse_file(filename, use_cpp=False, cpp_path='cpp', cpp_args='',
+               parser=None):
+    """ Parse a C file using pycparser.
+
+        filename:
+            Name of the file you want to parse.
+
+        use_cpp:
+            Set to True if you want to execute the C pre-processor
+            on the file prior to parsing it.
+
+        cpp_path:
+            If use_cpp is True, this is the path to 'cpp' on your
+            system. If no path is provided, it attempts to just
+            execute 'cpp', so it must be in your PATH.
+
+        cpp_args:
+            If use_cpp is True, set this to the command line arguments strings
+            to cpp. Be careful with quotes - it's best to pass a raw string
+            (r'') here. For example:
+            r'-I../utils/fake_libc_include'
+            If several arguments are required, pass a list of strings.
+
+        parser:
+            Optional parser object to be used instead of the default CParser
+
+        When successful, an AST is returned. ParseError can be
+        thrown if the file doesn't parse successfully.
+
+        Errors from cpp will be printed out.
+    """
+    if use_cpp:
+        text = preprocess_file(filename, cpp_path, cpp_args)
+    else:
+        with io.open(filename) as f:
+            text = f.read()
+
+    if parser is None:
+        parser = CParser()
+    return parser.parse(text, filename)
diff --git a/myenv/lib/python3.9/site-packages/pycparser/_ast_gen.py b/myenv/lib/python3.9/site-packages/pycparser/_ast_gen.py
new file mode 100644
index 0000000..0f7d330
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/_ast_gen.py
@@ -0,0 +1,336 @@
+#-----------------------------------------------------------------
+# _ast_gen.py
+#
+# Generates the AST Node classes from a specification given in
+# a configuration file
+#
+# The design of this module was inspired by astgen.py from the
+# Python 2.5 code-base.
+#
+# Eli Bendersky [https://eli.thegreenplace.net/]
+# License: BSD
+#-----------------------------------------------------------------
+from string import Template
+
+
+class ASTCodeGenerator(object):
+    def __init__(self, cfg_filename='_c_ast.cfg'):
+        """ Initialize the code generator from a configuration
+            file.
+        """
+        self.cfg_filename = cfg_filename
+        self.node_cfg = [NodeCfg(name, contents)
+            for (name, contents) in self.parse_cfgfile(cfg_filename)]
+
+    def generate(self, file=None):
+        """ Generates the code into file, an open file buffer.
+        """
+        src = Template(_PROLOGUE_COMMENT).substitute(
+            cfg_filename=self.cfg_filename)
+
+        src += _PROLOGUE_CODE
+        for node_cfg in self.node_cfg:
+            src += node_cfg.generate_source() + '\n\n'
+
+        file.write(src)
+
+    def parse_cfgfile(self, filename):
+        """ Parse the configuration file and yield pairs of
+            (name, contents) for each node.
+        """
+        with open(filename, "r") as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith('#'):
+                    continue
+                colon_i = line.find(':')
+                lbracket_i = line.find('[')
+                rbracket_i = line.find(']')
+                if colon_i < 1 or lbracket_i <= colon_i or rbracket_i <= lbracket_i:
+                    raise RuntimeError("Invalid line in %s:\n%s\n" % (filename, line))
+
+                name = line[:colon_i]
+                val = line[lbracket_i + 1:rbracket_i]
+                vallist = [v.strip() for v in val.split(',')] if val else []
+                yield name, vallist
+
+
+class NodeCfg(object):
+    """ Node configuration.
+
+        name: node name
+        contents: a list of contents - attributes and child nodes
+        See comment at the top of the configuration file for details.
+    """
+
+    def __init__(self, name, contents):
+        self.name = name
+        self.all_entries = []
+        self.attr = []
+        self.child = []
+        self.seq_child = []
+
+        for entry in contents:
+            clean_entry = entry.rstrip('*')
+            self.all_entries.append(clean_entry)
+
+            if entry.endswith('**'):
+                self.seq_child.append(clean_entry)
+            elif entry.endswith('*'):
+                self.child.append(clean_entry)
+            else:
+                self.attr.append(entry)
+
+    def generate_source(self):
+        src = self._gen_init()
+        src += '\n' + self._gen_children()
+        src += '\n' + self._gen_iter()
+        src += '\n' + self._gen_attr_names()
+        return src
+
+    def _gen_init(self):
+        src = "class %s(Node):\n" % self.name
+
+        if self.all_entries:
+            args = ', '.join(self.all_entries)
+            slots = ', '.join("'{0}'".format(e) for e in self.all_entries)
+            slots += ", 'coord', '__weakref__'"
+            arglist = '(self, %s, coord=None)' % args
+        else:
+            slots = "'coord', '__weakref__'"
+            arglist = '(self, coord=None)'
+
+        src += "    __slots__ = (%s)\n" % slots
+        src += "    def __init__%s:\n" % arglist
+
+        for name in self.all_entries + ['coord']:
+            src += "        self.%s = %s\n" % (name, name)
+
+        return src
+
+    def _gen_children(self):
+        src = '    def children(self):\n'
+
+        if self.all_entries:
+            src += '        nodelist = []\n'
+
+            for child in self.child:
+                src += (
+                    '        if self.%(child)s is not None:' +
+                    ' nodelist.append(("%(child)s", self.%(child)s))\n') % (
+                        dict(child=child))
+
+            for seq_child in self.seq_child:
+                src += (
+                    '        for i, child in enumerate(self.%(child)s or []):\n'
+                    '            nodelist.append(("%(child)s[%%d]" %% i, child))\n') % (
+                        dict(child=seq_child))
+
+            src += '        return tuple(nodelist)\n'
+        else:
+            src += '        return ()\n'
+
+        return src
+
+    def _gen_iter(self):
+        src = '    def __iter__(self):\n'
+
+        if self.all_entries:
+            for child in self.child:
+                src += (
+                    '        if self.%(child)s is not None:\n' +
+                    '            yield self.%(child)s\n') % (dict(child=child))
+
+            for seq_child in self.seq_child:
+                src += (
+                    '        for child in (self.%(child)s or []):\n'
+                    '            yield child\n') % (dict(child=seq_child))
+
+            if not (self.child or self.seq_child):
+                # Empty generator
+                src += (
+                    '        return\n' +
+                    '        yield\n')
+        else:
+            # Empty generator
+            src += (
+                '        return\n' +
+                '        yield\n')
+
+        return src
+
+    def _gen_attr_names(self):
+        src = "    attr_names = (" + ''.join("%r, " % nm for nm in self.attr) + ')'
+        return src
+
+
+_PROLOGUE_COMMENT = \
+r'''#-----------------------------------------------------------------
+# ** ATTENTION **
+# This code was automatically generated from the file:
+# $cfg_filename
+#
+# Do not modify it directly. Modify the configuration file and
+# run the generator again.
+# ** ** *** ** **
+#
+# pycparser: c_ast.py
+#
+# AST Node classes.
+#
+# Eli Bendersky [https://eli.thegreenplace.net/]
+# License: BSD
+#-----------------------------------------------------------------
+
+'''
+
+_PROLOGUE_CODE = r'''
+import sys
+
+def _repr(obj):
+    """
+    Get the representation of an object, with dedicated pprint-like format for lists.
+    """
+    if isinstance(obj, list):
+        return '[' + (',\n '.join((_repr(e).replace('\n', '\n ') for e in obj))) + '\n]'
+    else:
+        return repr(obj)
+
+class Node(object):
+    __slots__ = ()
+    """ Abstract base class for AST nodes.
+    """
+    def __repr__(self):
+        """ Generates a python representation of the current node
+        """
+        result = self.__class__.__name__ + '('
+
+        indent = ''
+        separator = ''
+        for name in self.__slots__[:-2]:
+            result += separator
+            result += indent
+            result += name + '=' + (_repr(getattr(self, name)).replace('\n', '\n  ' + (' ' * (len(name) + len(self.__class__.__name__)))))
+
+            separator = ','
+            indent = '\n ' + (' ' * len(self.__class__.__name__))
+
+        result += indent + ')'
+
+        return result
+
+    def children(self):
+        """ A sequence of all children that are Nodes
+        """
+        pass
+
+    def show(self, buf=sys.stdout, offset=0, attrnames=False, nodenames=False, showcoord=False, _my_node_name=None):
+        """ Pretty print the Node and all its attributes and
+            children (recursively) to a buffer.
+
+            buf:
+                Open IO buffer into which the Node is printed.
+
+            offset:
+                Initial offset (amount of leading spaces)
+
+            attrnames:
+                True if you want to see the attribute names in
+                name=value pairs. False to only see the values.
+
+            nodenames:
+                True if you want to see the actual node names
+                within their parents.
+
+            showcoord:
+                Do you want the coordinates of each Node to be
+                displayed.
+        """
+        lead = ' ' * offset
+        if nodenames and _my_node_name is not None:
+            buf.write(lead + self.__class__.__name__+ ' <' + _my_node_name + '>: ')
+        else:
+            buf.write(lead + self.__class__.__name__+ ': ')
+
+        if self.attr_names:
+            if attrnames:
+                nvlist = [(n, getattr(self,n)) for n in self.attr_names]
+                attrstr = ', '.join('%s=%s' % nv for nv in nvlist)
+            else:
+                vlist = [getattr(self, n) for n in self.attr_names]
+                attrstr = ', '.join('%s' % v for v in vlist)
+            buf.write(attrstr)
+
+        if showcoord:
+            buf.write(' (at %s)' % self.coord)
+        buf.write('\n')
+
+        for (child_name, child) in self.children():
+            child.show(
+                buf,
+                offset=offset + 2,
+                attrnames=attrnames,
+                nodenames=nodenames,
+                showcoord=showcoord,
+                _my_node_name=child_name)
+
+
+class NodeVisitor(object):
+    """ A base NodeVisitor class for visiting c_ast nodes.
+        Subclass it and define your own visit_XXX methods, where
+        XXX is the class name you want to visit with these
+        methods.
+
+        For example:
+
+        class ConstantVisitor(NodeVisitor):
+            def __init__(self):
+                self.values = []
+
+            def visit_Constant(self, node):
+                self.values.append(node.value)
+
+        Creates a list of values of all the constant nodes
+        encountered below the given node. To use it:
+
+        cv = ConstantVisitor()
+        cv.visit(node)
+
+        Notes:
+
+        *   generic_visit() will be called for AST nodes for which
+            no visit_XXX method was defined.
+        *   The children of nodes for which a visit_XXX was
+            defined will not be visited - if you need this, call
+            generic_visit() on the node.
+            You can use:
+                NodeVisitor.generic_visit(self, node)
+        *   Modeled after Python's own AST visiting facilities
+            (the ast module of Python 3.0)
+    """
+
+    _method_cache = None
+
+    def visit(self, node):
+        """ Visit a node.
+        """
+
+        if self._method_cache is None:
+            self._method_cache = {}
+
+        visitor = self._method_cache.get(node.__class__.__name__, None)
+        if visitor is None:
+            method = 'visit_' + node.__class__.__name__
+            visitor = getattr(self, method, self.generic_visit)
+            self._method_cache[node.__class__.__name__] = visitor
+
+        return visitor(node)
+
+    def generic_visit(self, node):
+        """ Called if no explicit visitor function exists for a
+            node. Implements preorder visiting of the node.
+        """
+        for c in node:
+            self.visit(c)
+
+'''
diff --git a/myenv/lib/python3.9/site-packages/pycparser/_build_tables.py b/myenv/lib/python3.9/site-packages/pycparser/_build_tables.py
new file mode 100644
index 0000000..958381a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/_build_tables.py
@@ -0,0 +1,37 @@
+#-----------------------------------------------------------------
+# pycparser: _build_tables.py
+#
+# A dummy for generating the lexing/parsing tables and and
+# compiling them into .pyc for faster execution in optimized mode.
+# Also generates AST code from the configuration file.
+# Should be called from the pycparser directory.
+#
+# Eli Bendersky [https://eli.thegreenplace.net/]
+# License: BSD
+#-----------------------------------------------------------------
+
+# Insert '.' and '..' as first entries to the search path for modules.
+# Restricted environments like embeddable python do not include the
+# current working directory on startup.
+import sys
+sys.path[0:0] = ['.', '..']
+
+# Generate c_ast.py
+from _ast_gen import ASTCodeGenerator
+ast_gen = ASTCodeGenerator('_c_ast.cfg')
+ast_gen.generate(open('c_ast.py', 'w'))
+
+from pycparser import c_parser
+
+# Generates the tables
+#
+c_parser.CParser(
+    lex_optimize=True,
+    yacc_debug=False,
+    yacc_optimize=True)
+
+# Load to compile into .pyc
+#
+import lextab
+import yacctab
+import c_ast
diff --git a/myenv/lib/python3.9/site-packages/pycparser/_c_ast.cfg b/myenv/lib/python3.9/site-packages/pycparser/_c_ast.cfg
new file mode 100644
index 0000000..0626533
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/_c_ast.cfg
@@ -0,0 +1,195 @@
+#-----------------------------------------------------------------
+# pycparser: _c_ast.cfg
+#
+# Defines the AST Node classes used in pycparser.
+#
+# Each entry is a Node sub-class name, listing the attributes
+# and child nodes of the class:
+#   <name>*     - a child node
+#   <name>**    - a sequence of child nodes
+#   <name>      - an attribute
+#
+# Eli Bendersky [https://eli.thegreenplace.net/]
+# License: BSD
+#-----------------------------------------------------------------
+
+# ArrayDecl is a nested declaration of an array with the given type.
+# dim: the dimension (for example, constant 42)
+# dim_quals: list of dimension qualifiers, to support C99's allowing 'const'
+#            and 'static' within the array dimension in function declarations.
+ArrayDecl: [type*, dim*, dim_quals]
+
+ArrayRef: [name*, subscript*]
+
+# op: =, +=, /= etc.
+#
+Assignment: [op, lvalue*, rvalue*]
+
+Alignas: [alignment*]
+
+BinaryOp: [op, left*, right*]
+
+Break: []
+
+Case: [expr*, stmts**]
+
+Cast: [to_type*, expr*]
+
+# Compound statement in C99 is a list of block items (declarations or
+# statements).
+#
+Compound: [block_items**]
+
+# Compound literal (anonymous aggregate) for C99.
+# (type-name) {initializer_list}
+# type: the typename
+# init: InitList for the initializer list
+#
+CompoundLiteral: [type*, init*]
+
+# type: int, char, float, string, etc.
+#
+Constant: [type, value]
+
+Continue: []
+
+# name: the variable being declared
+# quals: list of qualifiers (const, volatile)
+# funcspec: list function specifiers (i.e. inline in C99)
+# storage: list of storage specifiers (extern, register, etc.)
+# type: declaration type (probably nested with all the modifiers)
+# init: initialization value, or None
+# bitsize: bit field size, or None
+#
+Decl: [name, quals, align, storage, funcspec, type*, init*, bitsize*]
+
+DeclList: [decls**]
+
+Default: [stmts**]
+
+DoWhile: [cond*, stmt*]
+
+# Represents the ellipsis (...) parameter in a function
+# declaration
+#
+EllipsisParam: []
+
+# An empty statement (a semicolon ';' on its own)
+#
+EmptyStatement: []
+
+# Enumeration type specifier
+# name: an optional ID
+# values: an EnumeratorList
+#
+Enum: [name, values*]
+
+# A name/value pair for enumeration values
+#
+Enumerator: [name, value*]
+
+# A list of enumerators
+#
+EnumeratorList: [enumerators**]
+
+# A list of expressions separated by the comma operator.
+#
+ExprList: [exprs**]
+
+# This is the top of the AST, representing a single C file (a
+# translation unit in K&R jargon). It contains a list of
+# "external-declaration"s, which is either declarations (Decl),
+# Typedef or function definitions (FuncDef).
+#
+FileAST: [ext**]
+
+# for (init; cond; next) stmt
+#
+For: [init*, cond*, next*, stmt*]
+
+# name: Id
+# args: ExprList
+#
+FuncCall: [name*, args*]
+
+# type <decl>(args)
+#
+FuncDecl: [args*, type*]
+
+# Function definition: a declarator for the function name and
+# a body, which is a compound statement.
+# There's an optional list of parameter declarations for old
+# K&R-style definitions
+#
+FuncDef: [decl*, param_decls**, body*]
+
+Goto: [name]
+
+ID: [name]
+
+# Holder for types that are a simple identifier (e.g. the built
+# ins void, char etc. and typedef-defined types)
+#
+IdentifierType: [names]
+
+If: [cond*, iftrue*, iffalse*]
+
+# An initialization list used for compound literals.
+#
+InitList: [exprs**]
+
+Label: [name, stmt*]
+
+# A named initializer for C99.
+# The name of a NamedInitializer is a sequence of Nodes, because
+# names can be hierarchical and contain constant expressions.
+#
+NamedInitializer: [name**, expr*]
+
+# a list of comma separated function parameter declarations
+#
+ParamList: [params**]
+
+PtrDecl: [quals, type*]
+
+Return: [expr*]
+
+StaticAssert: [cond*, message*]
+
+# name: struct tag name
+# decls: declaration of members
+#
+Struct: [name, decls**]
+
+# type: . or ->
+# name.field or name->field
+#
+StructRef: [name*, type, field*]
+
+Switch: [cond*, stmt*]
+
+# cond ? iftrue : iffalse
+#
+TernaryOp: [cond*, iftrue*, iffalse*]
+
+# A base type declaration
+#
+TypeDecl: [declname, quals, align, type*]
+
+# A typedef declaration.
+# Very similar to Decl, but without some attributes
+#
+Typedef: [name, quals, storage, type*]
+
+Typename: [name, quals, align, type*]
+
+UnaryOp: [op, expr*]
+
+# name: union tag name
+# decls: declaration of members
+#
+Union: [name, decls**]
+
+While: [cond*, stmt*]
+
+Pragma: [string]
diff --git a/myenv/lib/python3.9/site-packages/pycparser/ast_transforms.py b/myenv/lib/python3.9/site-packages/pycparser/ast_transforms.py
new file mode 100644
index 0000000..367dcf5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/ast_transforms.py
@@ -0,0 +1,164 @@
+#------------------------------------------------------------------------------
+# pycparser: ast_transforms.py
+#
+# Some utilities used by the parser to create a friendlier AST.
+#
+# Eli Bendersky [https://eli.thegreenplace.net/]
+# License: BSD
+#------------------------------------------------------------------------------
+
+from . import c_ast
+
+
+def fix_switch_cases(switch_node):
+    """ The 'case' statements in a 'switch' come out of parsing with one
+        child node, so subsequent statements are just tucked to the parent
+        Compound. Additionally, consecutive (fall-through) case statements
+        come out messy. This is a peculiarity of the C grammar. The following:
+
+            switch (myvar) {
+                case 10:
+                    k = 10;
+                    p = k + 1;
+                    return 10;
+                case 20:
+                case 30:
+                    return 20;
+                default:
+                    break;
+            }
+
+        Creates this tree (pseudo-dump):
+
+            Switch
+                ID: myvar
+                Compound:
+                    Case 10:
+                        k = 10
+                    p = k + 1
+                    return 10
+                    Case 20:
+                        Case 30:
+                            return 20
+                    Default:
+                        break
+
+        The goal of this transform is to fix this mess, turning it into the
+        following:
+
+            Switch
+                ID: myvar
+                Compound:
+                    Case 10:
+                        k = 10
+                        p = k + 1
+                        return 10
+                    Case 20:
+                    Case 30:
+                        return 20
+                    Default:
+                        break
+
+        A fixed AST node is returned. The argument may be modified.
+    """
+    assert isinstance(switch_node, c_ast.Switch)
+    if not isinstance(switch_node.stmt, c_ast.Compound):
+        return switch_node
+
+    # The new Compound child for the Switch, which will collect children in the
+    # correct order
+    new_compound = c_ast.Compound([], switch_node.stmt.coord)
+
+    # The last Case/Default node
+    last_case = None
+
+    # Goes over the children of the Compound below the Switch, adding them
+    # either directly below new_compound or below the last Case as appropriate
+    # (for `switch(cond) {}`, block_items would have been None)
+    for child in (switch_node.stmt.block_items or []):
+        if isinstance(child, (c_ast.Case, c_ast.Default)):
+            # If it's a Case/Default:
+            # 1. Add it to the Compound and mark as "last case"
+            # 2. If its immediate child is also a Case or Default, promote it
+            #    to a sibling.
+            new_compound.block_items.append(child)
+            _extract_nested_case(child, new_compound.block_items)
+            last_case = new_compound.block_items[-1]
+        else:
+            # Other statements are added as children to the last case, if it
+            # exists.
+            if last_case is None:
+                new_compound.block_items.append(child)
+            else:
+                last_case.stmts.append(child)
+
+    switch_node.stmt = new_compound
+    return switch_node
+
+
+def _extract_nested_case(case_node, stmts_list):
+    """ Recursively extract consecutive Case statements that are made nested
+        by the parser and add them to the stmts_list.
+    """
+    if isinstance(case_node.stmts[0], (c_ast.Case, c_ast.Default)):
+        stmts_list.append(case_node.stmts.pop())
+        _extract_nested_case(stmts_list[-1], stmts_list)
+
+
+def fix_atomic_specifiers(decl):
+    """ Atomic specifiers like _Atomic(type) are unusually structured,
+        conferring a qualifier upon the contained type.
+
+        This function fixes a decl with atomic specifiers to have a sane AST
+        structure, by removing spurious Typename->TypeDecl pairs and attaching
+        the _Atomic qualifier in the right place.
+    """
+    # There can be multiple levels of _Atomic in a decl; fix them until a
+    # fixed point is reached.
+    while True:
+        decl, found = _fix_atomic_specifiers_once(decl)
+        if not found:
+            break
+
+    # Make sure to add an _Atomic qual on the topmost decl if needed. Also
+    # restore the declname on the innermost TypeDecl (it gets placed in the
+    # wrong place during construction).
+    typ = decl
+    while not isinstance(typ, c_ast.TypeDecl):
+        try:
+            typ = typ.type
+        except AttributeError:
+            return decl
+    if '_Atomic' in typ.quals and '_Atomic' not in decl.quals:
+        decl.quals.append('_Atomic')
+    if typ.declname is None:
+        typ.declname = decl.name
+
+    return decl
+
+
+def _fix_atomic_specifiers_once(decl):
+    """ Performs one 'fix' round of atomic specifiers.
+        Returns (modified_decl, found) where found is True iff a fix was made.
+    """
+    parent = decl
+    grandparent = None
+    node = decl.type
+    while node is not None:
+        if isinstance(node, c_ast.Typename) and '_Atomic' in node.quals:
+            break
+        try:
+            grandparent = parent
+            parent = node
+            node = node.type
+        except AttributeError:
+            # If we've reached a node without a `type` field, it means we won't
+            # find what we're looking for at this point; give up the search
+            # and return the original decl unmodified.
+            return decl, False
+
+    assert isinstance(parent, c_ast.TypeDecl)
+    grandparent.type = node.type
+    if '_Atomic' not in node.type.quals:
+        node.type.quals.append('_Atomic')
+    return decl, True
diff --git a/myenv/lib/python3.9/site-packages/pycparser/c_ast.py b/myenv/lib/python3.9/site-packages/pycparser/c_ast.py
new file mode 100644
index 0000000..6575a2a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/c_ast.py
@@ -0,0 +1,1125 @@
+#-----------------------------------------------------------------
+# ** ATTENTION **
+# This code was automatically generated from the file:
+# _c_ast.cfg
+#
+# Do not modify it directly. Modify the configuration file and
+# run the generator again.
+# ** ** *** ** **
+#
+# pycparser: c_ast.py
+#
+# AST Node classes.
+#
+# Eli Bendersky [https://eli.thegreenplace.net/]
+# License: BSD
+#-----------------------------------------------------------------
+
+
+import sys
+
+def _repr(obj):
+    """
+    Get the representation of an object, with dedicated pprint-like format for lists.
+    """
+    if isinstance(obj, list):
+        return '[' + (',\n '.join((_repr(e).replace('\n', '\n ') for e in obj))) + '\n]'
+    else:
+        return repr(obj)
+
+class Node(object):
+    __slots__ = ()
+    """ Abstract base class for AST nodes.
+    """
+    def __repr__(self):
+        """ Generates a python representation of the current node
+        """
+        result = self.__class__.__name__ + '('
+
+        indent = ''
+        separator = ''
+        for name in self.__slots__[:-2]:
+            result += separator
+            result += indent
+            result += name + '=' + (_repr(getattr(self, name)).replace('\n', '\n  ' + (' ' * (len(name) + len(self.__class__.__name__)))))
+
+            separator = ','
+            indent = '\n ' + (' ' * len(self.__class__.__name__))
+
+        result += indent + ')'
+
+        return result
+
+    def children(self):
+        """ A sequence of all children that are Nodes
+        """
+        pass
+
+    def show(self, buf=sys.stdout, offset=0, attrnames=False, nodenames=False, showcoord=False, _my_node_name=None):
+        """ Pretty print the Node and all its attributes and
+            children (recursively) to a buffer.
+
+            buf:
+                Open IO buffer into which the Node is printed.
+
+            offset:
+                Initial offset (amount of leading spaces)
+
+            attrnames:
+                True if you want to see the attribute names in
+                name=value pairs. False to only see the values.
+
+            nodenames:
+                True if you want to see the actual node names
+                within their parents.
+
+            showcoord:
+                Do you want the coordinates of each Node to be
+                displayed.
+        """
+        lead = ' ' * offset
+        if nodenames and _my_node_name is not None:
+            buf.write(lead + self.__class__.__name__+ ' <' + _my_node_name + '>: ')
+        else:
+            buf.write(lead + self.__class__.__name__+ ': ')
+
+        if self.attr_names:
+            if attrnames:
+                nvlist = [(n, getattr(self,n)) for n in self.attr_names]
+                attrstr = ', '.join('%s=%s' % nv for nv in nvlist)
+            else:
+                vlist = [getattr(self, n) for n in self.attr_names]
+                attrstr = ', '.join('%s' % v for v in vlist)
+            buf.write(attrstr)
+
+        if showcoord:
+            buf.write(' (at %s)' % self.coord)
+        buf.write('\n')
+
+        for (child_name, child) in self.children():
+            child.show(
+                buf,
+                offset=offset + 2,
+                attrnames=attrnames,
+                nodenames=nodenames,
+                showcoord=showcoord,
+                _my_node_name=child_name)
+
+
+class NodeVisitor(object):
+    """ A base NodeVisitor class for visiting c_ast nodes.
+        Subclass it and define your own visit_XXX methods, where
+        XXX is the class name you want to visit with these
+        methods.
+
+        For example:
+
+        class ConstantVisitor(NodeVisitor):
+            def __init__(self):
+                self.values = []
+
+            def visit_Constant(self, node):
+                self.values.append(node.value)
+
+        Creates a list of values of all the constant nodes
+        encountered below the given node. To use it:
+
+        cv = ConstantVisitor()
+        cv.visit(node)
+
+        Notes:
+
+        *   generic_visit() will be called for AST nodes for which
+            no visit_XXX method was defined.
+        *   The children of nodes for which a visit_XXX was
+            defined will not be visited - if you need this, call
+            generic_visit() on the node.
+            You can use:
+                NodeVisitor.generic_visit(self, node)
+        *   Modeled after Python's own AST visiting facilities
+            (the ast module of Python 3.0)
+    """
+
+    _method_cache = None
+
+    def visit(self, node):
+        """ Visit a node.
+        """
+
+        if self._method_cache is None:
+            self._method_cache = {}
+
+        visitor = self._method_cache.get(node.__class__.__name__, None)
+        if visitor is None:
+            method = 'visit_' + node.__class__.__name__
+            visitor = getattr(self, method, self.generic_visit)
+            self._method_cache[node.__class__.__name__] = visitor
+
+        return visitor(node)
+
+    def generic_visit(self, node):
+        """ Called if no explicit visitor function exists for a
+            node. Implements preorder visiting of the node.
+        """
+        for c in node:
+            self.visit(c)
+
+class ArrayDecl(Node):
+    __slots__ = ('type', 'dim', 'dim_quals', 'coord', '__weakref__')
+    def __init__(self, type, dim, dim_quals, coord=None):
+        self.type = type
+        self.dim = dim
+        self.dim_quals = dim_quals
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.type is not None: nodelist.append(("type", self.type))
+        if self.dim is not None: nodelist.append(("dim", self.dim))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.type is not None:
+            yield self.type
+        if self.dim is not None:
+            yield self.dim
+
+    attr_names = ('dim_quals', )
+
+class ArrayRef(Node):
+    __slots__ = ('name', 'subscript', 'coord', '__weakref__')
+    def __init__(self, name, subscript, coord=None):
+        self.name = name
+        self.subscript = subscript
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.name is not None: nodelist.append(("name", self.name))
+        if self.subscript is not None: nodelist.append(("subscript", self.subscript))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.name is not None:
+            yield self.name
+        if self.subscript is not None:
+            yield self.subscript
+
+    attr_names = ()
+
+class Assignment(Node):
+    __slots__ = ('op', 'lvalue', 'rvalue', 'coord', '__weakref__')
+    def __init__(self, op, lvalue, rvalue, coord=None):
+        self.op = op
+        self.lvalue = lvalue
+        self.rvalue = rvalue
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.lvalue is not None: nodelist.append(("lvalue", self.lvalue))
+        if self.rvalue is not None: nodelist.append(("rvalue", self.rvalue))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.lvalue is not None:
+            yield self.lvalue
+        if self.rvalue is not None:
+            yield self.rvalue
+
+    attr_names = ('op', )
+
+class Alignas(Node):
+    __slots__ = ('alignment', 'coord', '__weakref__')
+    def __init__(self, alignment, coord=None):
+        self.alignment = alignment
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.alignment is not None: nodelist.append(("alignment", self.alignment))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.alignment is not None:
+            yield self.alignment
+
+    attr_names = ()
+
+class BinaryOp(Node):
+    __slots__ = ('op', 'left', 'right', 'coord', '__weakref__')
+    def __init__(self, op, left, right, coord=None):
+        self.op = op
+        self.left = left
+        self.right = right
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.left is not None: nodelist.append(("left", self.left))
+        if self.right is not None: nodelist.append(("right", self.right))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.left is not None:
+            yield self.left
+        if self.right is not None:
+            yield self.right
+
+    attr_names = ('op', )
+
+class Break(Node):
+    __slots__ = ('coord', '__weakref__')
+    def __init__(self, coord=None):
+        self.coord = coord
+
+    def children(self):
+        return ()
+
+    def __iter__(self):
+        return
+        yield
+
+    attr_names = ()
+
+class Case(Node):
+    __slots__ = ('expr', 'stmts', 'coord', '__weakref__')
+    def __init__(self, expr, stmts, coord=None):
+        self.expr = expr
+        self.stmts = stmts
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.expr is not None: nodelist.append(("expr", self.expr))
+        for i, child in enumerate(self.stmts or []):
+            nodelist.append(("stmts[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.expr is not None:
+            yield self.expr
+        for child in (self.stmts or []):
+            yield child
+
+    attr_names = ()
+
+class Cast(Node):
+    __slots__ = ('to_type', 'expr', 'coord', '__weakref__')
+    def __init__(self, to_type, expr, coord=None):
+        self.to_type = to_type
+        self.expr = expr
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.to_type is not None: nodelist.append(("to_type", self.to_type))
+        if self.expr is not None: nodelist.append(("expr", self.expr))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.to_type is not None:
+            yield self.to_type
+        if self.expr is not None:
+            yield self.expr
+
+    attr_names = ()
+
+class Compound(Node):
+    __slots__ = ('block_items', 'coord', '__weakref__')
+    def __init__(self, block_items, coord=None):
+        self.block_items = block_items
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        for i, child in enumerate(self.block_items or []):
+            nodelist.append(("block_items[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        for child in (self.block_items or []):
+            yield child
+
+    attr_names = ()
+
+class CompoundLiteral(Node):
+    __slots__ = ('type', 'init', 'coord', '__weakref__')
+    def __init__(self, type, init, coord=None):
+        self.type = type
+        self.init = init
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.type is not None: nodelist.append(("type", self.type))
+        if self.init is not None: nodelist.append(("init", self.init))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.type is not None:
+            yield self.type
+        if self.init is not None:
+            yield self.init
+
+    attr_names = ()
+
+class Constant(Node):
+    __slots__ = ('type', 'value', 'coord', '__weakref__')
+    def __init__(self, type, value, coord=None):
+        self.type = type
+        self.value = value
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        return tuple(nodelist)
+
+    def __iter__(self):
+        return
+        yield
+
+    attr_names = ('type', 'value', )
+
+class Continue(Node):
+    __slots__ = ('coord', '__weakref__')
+    def __init__(self, coord=None):
+        self.coord = coord
+
+    def children(self):
+        return ()
+
+    def __iter__(self):
+        return
+        yield
+
+    attr_names = ()
+
+class Decl(Node):
+    __slots__ = ('name', 'quals', 'align', 'storage', 'funcspec', 'type', 'init', 'bitsize', 'coord', '__weakref__')
+    def __init__(self, name, quals, align, storage, funcspec, type, init, bitsize, coord=None):
+        self.name = name
+        self.quals = quals
+        self.align = align
+        self.storage = storage
+        self.funcspec = funcspec
+        self.type = type
+        self.init = init
+        self.bitsize = bitsize
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.type is not None: nodelist.append(("type", self.type))
+        if self.init is not None: nodelist.append(("init", self.init))
+        if self.bitsize is not None: nodelist.append(("bitsize", self.bitsize))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.type is not None:
+            yield self.type
+        if self.init is not None:
+            yield self.init
+        if self.bitsize is not None:
+            yield self.bitsize
+
+    attr_names = ('name', 'quals', 'align', 'storage', 'funcspec', )
+
+class DeclList(Node):
+    __slots__ = ('decls', 'coord', '__weakref__')
+    def __init__(self, decls, coord=None):
+        self.decls = decls
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        for i, child in enumerate(self.decls or []):
+            nodelist.append(("decls[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        for child in (self.decls or []):
+            yield child
+
+    attr_names = ()
+
+class Default(Node):
+    __slots__ = ('stmts', 'coord', '__weakref__')
+    def __init__(self, stmts, coord=None):
+        self.stmts = stmts
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        for i, child in enumerate(self.stmts or []):
+            nodelist.append(("stmts[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        for child in (self.stmts or []):
+            yield child
+
+    attr_names = ()
+
+class DoWhile(Node):
+    __slots__ = ('cond', 'stmt', 'coord', '__weakref__')
+    def __init__(self, cond, stmt, coord=None):
+        self.cond = cond
+        self.stmt = stmt
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.cond is not None: nodelist.append(("cond", self.cond))
+        if self.stmt is not None: nodelist.append(("stmt", self.stmt))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.cond is not None:
+            yield self.cond
+        if self.stmt is not None:
+            yield self.stmt
+
+    attr_names = ()
+
+class EllipsisParam(Node):
+    __slots__ = ('coord', '__weakref__')
+    def __init__(self, coord=None):
+        self.coord = coord
+
+    def children(self):
+        return ()
+
+    def __iter__(self):
+        return
+        yield
+
+    attr_names = ()
+
+class EmptyStatement(Node):
+    __slots__ = ('coord', '__weakref__')
+    def __init__(self, coord=None):
+        self.coord = coord
+
+    def children(self):
+        return ()
+
+    def __iter__(self):
+        return
+        yield
+
+    attr_names = ()
+
+class Enum(Node):
+    __slots__ = ('name', 'values', 'coord', '__weakref__')
+    def __init__(self, name, values, coord=None):
+        self.name = name
+        self.values = values
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.values is not None: nodelist.append(("values", self.values))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.values is not None:
+            yield self.values
+
+    attr_names = ('name', )
+
+class Enumerator(Node):
+    __slots__ = ('name', 'value', 'coord', '__weakref__')
+    def __init__(self, name, value, coord=None):
+        self.name = name
+        self.value = value
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.value is not None: nodelist.append(("value", self.value))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.value is not None:
+            yield self.value
+
+    attr_names = ('name', )
+
+class EnumeratorList(Node):
+    __slots__ = ('enumerators', 'coord', '__weakref__')
+    def __init__(self, enumerators, coord=None):
+        self.enumerators = enumerators
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        for i, child in enumerate(self.enumerators or []):
+            nodelist.append(("enumerators[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        for child in (self.enumerators or []):
+            yield child
+
+    attr_names = ()
+
+class ExprList(Node):
+    __slots__ = ('exprs', 'coord', '__weakref__')
+    def __init__(self, exprs, coord=None):
+        self.exprs = exprs
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        for i, child in enumerate(self.exprs or []):
+            nodelist.append(("exprs[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        for child in (self.exprs or []):
+            yield child
+
+    attr_names = ()
+
+class FileAST(Node):
+    __slots__ = ('ext', 'coord', '__weakref__')
+    def __init__(self, ext, coord=None):
+        self.ext = ext
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        for i, child in enumerate(self.ext or []):
+            nodelist.append(("ext[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        for child in (self.ext or []):
+            yield child
+
+    attr_names = ()
+
+class For(Node):
+    __slots__ = ('init', 'cond', 'next', 'stmt', 'coord', '__weakref__')
+    def __init__(self, init, cond, next, stmt, coord=None):
+        self.init = init
+        self.cond = cond
+        self.next = next
+        self.stmt = stmt
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.init is not None: nodelist.append(("init", self.init))
+        if self.cond is not None: nodelist.append(("cond", self.cond))
+        if self.next is not None: nodelist.append(("next", self.next))
+        if self.stmt is not None: nodelist.append(("stmt", self.stmt))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.init is not None:
+            yield self.init
+        if self.cond is not None:
+            yield self.cond
+        if self.next is not None:
+            yield self.next
+        if self.stmt is not None:
+            yield self.stmt
+
+    attr_names = ()
+
+class FuncCall(Node):
+    __slots__ = ('name', 'args', 'coord', '__weakref__')
+    def __init__(self, name, args, coord=None):
+        self.name = name
+        self.args = args
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.name is not None: nodelist.append(("name", self.name))
+        if self.args is not None: nodelist.append(("args", self.args))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.name is not None:
+            yield self.name
+        if self.args is not None:
+            yield self.args
+
+    attr_names = ()
+
+class FuncDecl(Node):
+    __slots__ = ('args', 'type', 'coord', '__weakref__')
+    def __init__(self, args, type, coord=None):
+        self.args = args
+        self.type = type
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.args is not None: nodelist.append(("args", self.args))
+        if self.type is not None: nodelist.append(("type", self.type))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.args is not None:
+            yield self.args
+        if self.type is not None:
+            yield self.type
+
+    attr_names = ()
+
+class FuncDef(Node):
+    __slots__ = ('decl', 'param_decls', 'body', 'coord', '__weakref__')
+    def __init__(self, decl, param_decls, body, coord=None):
+        self.decl = decl
+        self.param_decls = param_decls
+        self.body = body
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.decl is not None: nodelist.append(("decl", self.decl))
+        if self.body is not None: nodelist.append(("body", self.body))
+        for i, child in enumerate(self.param_decls or []):
+            nodelist.append(("param_decls[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.decl is not None:
+            yield self.decl
+        if self.body is not None:
+            yield self.body
+        for child in (self.param_decls or []):
+            yield child
+
+    attr_names = ()
+
+class Goto(Node):
+    __slots__ = ('name', 'coord', '__weakref__')
+    def __init__(self, name, coord=None):
+        self.name = name
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        return tuple(nodelist)
+
+    def __iter__(self):
+        return
+        yield
+
+    attr_names = ('name', )
+
+class ID(Node):
+    __slots__ = ('name', 'coord', '__weakref__')
+    def __init__(self, name, coord=None):
+        self.name = name
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        return tuple(nodelist)
+
+    def __iter__(self):
+        return
+        yield
+
+    attr_names = ('name', )
+
+class IdentifierType(Node):
+    __slots__ = ('names', 'coord', '__weakref__')
+    def __init__(self, names, coord=None):
+        self.names = names
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        return tuple(nodelist)
+
+    def __iter__(self):
+        return
+        yield
+
+    attr_names = ('names', )
+
+class If(Node):
+    __slots__ = ('cond', 'iftrue', 'iffalse', 'coord', '__weakref__')
+    def __init__(self, cond, iftrue, iffalse, coord=None):
+        self.cond = cond
+        self.iftrue = iftrue
+        self.iffalse = iffalse
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.cond is not None: nodelist.append(("cond", self.cond))
+        if self.iftrue is not None: nodelist.append(("iftrue", self.iftrue))
+        if self.iffalse is not None: nodelist.append(("iffalse", self.iffalse))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.cond is not None:
+            yield self.cond
+        if self.iftrue is not None:
+            yield self.iftrue
+        if self.iffalse is not None:
+            yield self.iffalse
+
+    attr_names = ()
+
+class InitList(Node):
+    __slots__ = ('exprs', 'coord', '__weakref__')
+    def __init__(self, exprs, coord=None):
+        self.exprs = exprs
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        for i, child in enumerate(self.exprs or []):
+            nodelist.append(("exprs[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        for child in (self.exprs or []):
+            yield child
+
+    attr_names = ()
+
+class Label(Node):
+    __slots__ = ('name', 'stmt', 'coord', '__weakref__')
+    def __init__(self, name, stmt, coord=None):
+        self.name = name
+        self.stmt = stmt
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.stmt is not None: nodelist.append(("stmt", self.stmt))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.stmt is not None:
+            yield self.stmt
+
+    attr_names = ('name', )
+
+class NamedInitializer(Node):
+    __slots__ = ('name', 'expr', 'coord', '__weakref__')
+    def __init__(self, name, expr, coord=None):
+        self.name = name
+        self.expr = expr
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.expr is not None: nodelist.append(("expr", self.expr))
+        for i, child in enumerate(self.name or []):
+            nodelist.append(("name[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.expr is not None:
+            yield self.expr
+        for child in (self.name or []):
+            yield child
+
+    attr_names = ()
+
+class ParamList(Node):
+    __slots__ = ('params', 'coord', '__weakref__')
+    def __init__(self, params, coord=None):
+        self.params = params
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        for i, child in enumerate(self.params or []):
+            nodelist.append(("params[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        for child in (self.params or []):
+            yield child
+
+    attr_names = ()
+
+class PtrDecl(Node):
+    __slots__ = ('quals', 'type', 'coord', '__weakref__')
+    def __init__(self, quals, type, coord=None):
+        self.quals = quals
+        self.type = type
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.type is not None: nodelist.append(("type", self.type))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.type is not None:
+            yield self.type
+
+    attr_names = ('quals', )
+
+class Return(Node):
+    __slots__ = ('expr', 'coord', '__weakref__')
+    def __init__(self, expr, coord=None):
+        self.expr = expr
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.expr is not None: nodelist.append(("expr", self.expr))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.expr is not None:
+            yield self.expr
+
+    attr_names = ()
+
+class StaticAssert(Node):
+    __slots__ = ('cond', 'message', 'coord', '__weakref__')
+    def __init__(self, cond, message, coord=None):
+        self.cond = cond
+        self.message = message
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.cond is not None: nodelist.append(("cond", self.cond))
+        if self.message is not None: nodelist.append(("message", self.message))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.cond is not None:
+            yield self.cond
+        if self.message is not None:
+            yield self.message
+
+    attr_names = ()
+
+class Struct(Node):
+    __slots__ = ('name', 'decls', 'coord', '__weakref__')
+    def __init__(self, name, decls, coord=None):
+        self.name = name
+        self.decls = decls
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        for i, child in enumerate(self.decls or []):
+            nodelist.append(("decls[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        for child in (self.decls or []):
+            yield child
+
+    attr_names = ('name', )
+
+class StructRef(Node):
+    __slots__ = ('name', 'type', 'field', 'coord', '__weakref__')
+    def __init__(self, name, type, field, coord=None):
+        self.name = name
+        self.type = type
+        self.field = field
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.name is not None: nodelist.append(("name", self.name))
+        if self.field is not None: nodelist.append(("field", self.field))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.name is not None:
+            yield self.name
+        if self.field is not None:
+            yield self.field
+
+    attr_names = ('type', )
+
+class Switch(Node):
+    __slots__ = ('cond', 'stmt', 'coord', '__weakref__')
+    def __init__(self, cond, stmt, coord=None):
+        self.cond = cond
+        self.stmt = stmt
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.cond is not None: nodelist.append(("cond", self.cond))
+        if self.stmt is not None: nodelist.append(("stmt", self.stmt))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.cond is not None:
+            yield self.cond
+        if self.stmt is not None:
+            yield self.stmt
+
+    attr_names = ()
+
+class TernaryOp(Node):
+    __slots__ = ('cond', 'iftrue', 'iffalse', 'coord', '__weakref__')
+    def __init__(self, cond, iftrue, iffalse, coord=None):
+        self.cond = cond
+        self.iftrue = iftrue
+        self.iffalse = iffalse
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.cond is not None: nodelist.append(("cond", self.cond))
+        if self.iftrue is not None: nodelist.append(("iftrue", self.iftrue))
+        if self.iffalse is not None: nodelist.append(("iffalse", self.iffalse))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.cond is not None:
+            yield self.cond
+        if self.iftrue is not None:
+            yield self.iftrue
+        if self.iffalse is not None:
+            yield self.iffalse
+
+    attr_names = ()
+
+class TypeDecl(Node):
+    __slots__ = ('declname', 'quals', 'align', 'type', 'coord', '__weakref__')
+    def __init__(self, declname, quals, align, type, coord=None):
+        self.declname = declname
+        self.quals = quals
+        self.align = align
+        self.type = type
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.type is not None: nodelist.append(("type", self.type))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.type is not None:
+            yield self.type
+
+    attr_names = ('declname', 'quals', 'align', )
+
+class Typedef(Node):
+    __slots__ = ('name', 'quals', 'storage', 'type', 'coord', '__weakref__')
+    def __init__(self, name, quals, storage, type, coord=None):
+        self.name = name
+        self.quals = quals
+        self.storage = storage
+        self.type = type
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.type is not None: nodelist.append(("type", self.type))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.type is not None:
+            yield self.type
+
+    attr_names = ('name', 'quals', 'storage', )
+
+class Typename(Node):
+    __slots__ = ('name', 'quals', 'align', 'type', 'coord', '__weakref__')
+    def __init__(self, name, quals, align, type, coord=None):
+        self.name = name
+        self.quals = quals
+        self.align = align
+        self.type = type
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.type is not None: nodelist.append(("type", self.type))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.type is not None:
+            yield self.type
+
+    attr_names = ('name', 'quals', 'align', )
+
+class UnaryOp(Node):
+    __slots__ = ('op', 'expr', 'coord', '__weakref__')
+    def __init__(self, op, expr, coord=None):
+        self.op = op
+        self.expr = expr
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.expr is not None: nodelist.append(("expr", self.expr))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.expr is not None:
+            yield self.expr
+
+    attr_names = ('op', )
+
+class Union(Node):
+    __slots__ = ('name', 'decls', 'coord', '__weakref__')
+    def __init__(self, name, decls, coord=None):
+        self.name = name
+        self.decls = decls
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        for i, child in enumerate(self.decls or []):
+            nodelist.append(("decls[%d]" % i, child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        for child in (self.decls or []):
+            yield child
+
+    attr_names = ('name', )
+
+class While(Node):
+    __slots__ = ('cond', 'stmt', 'coord', '__weakref__')
+    def __init__(self, cond, stmt, coord=None):
+        self.cond = cond
+        self.stmt = stmt
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.cond is not None: nodelist.append(("cond", self.cond))
+        if self.stmt is not None: nodelist.append(("stmt", self.stmt))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.cond is not None:
+            yield self.cond
+        if self.stmt is not None:
+            yield self.stmt
+
+    attr_names = ()
+
+class Pragma(Node):
+    __slots__ = ('string', 'coord', '__weakref__')
+    def __init__(self, string, coord=None):
+        self.string = string
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        return tuple(nodelist)
+
+    def __iter__(self):
+        return
+        yield
+
+    attr_names = ('string', )
+
diff --git a/myenv/lib/python3.9/site-packages/pycparser/c_generator.py b/myenv/lib/python3.9/site-packages/pycparser/c_generator.py
new file mode 100644
index 0000000..1057b2c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/c_generator.py
@@ -0,0 +1,502 @@
+#------------------------------------------------------------------------------
+# pycparser: c_generator.py
+#
+# C code generator from pycparser AST nodes.
+#
+# Eli Bendersky [https://eli.thegreenplace.net/]
+# License: BSD
+#------------------------------------------------------------------------------
+from . import c_ast
+
+
+class CGenerator(object):
+    """ Uses the same visitor pattern as c_ast.NodeVisitor, but modified to
+        return a value from each visit method, using string accumulation in
+        generic_visit.
+    """
+    def __init__(self, reduce_parentheses=False):
+        """ Constructs C-code generator
+
+            reduce_parentheses:
+                if True, eliminates needless parentheses on binary operators
+        """
+        # Statements start with indentation of self.indent_level spaces, using
+        # the _make_indent method.
+        self.indent_level = 0
+        self.reduce_parentheses = reduce_parentheses
+
+    def _make_indent(self):
+        return ' ' * self.indent_level
+
+    def visit(self, node):
+        method = 'visit_' + node.__class__.__name__
+        return getattr(self, method, self.generic_visit)(node)
+
+    def generic_visit(self, node):
+        if node is None:
+            return ''
+        else:
+            return ''.join(self.visit(c) for c_name, c in node.children())
+
+    def visit_Constant(self, n):
+        return n.value
+
+    def visit_ID(self, n):
+        return n.name
+
+    def visit_Pragma(self, n):
+        ret = '#pragma'
+        if n.string:
+            ret += ' ' + n.string
+        return ret
+
+    def visit_ArrayRef(self, n):
+        arrref = self._parenthesize_unless_simple(n.name)
+        return arrref + '[' + self.visit(n.subscript) + ']'
+
+    def visit_StructRef(self, n):
+        sref = self._parenthesize_unless_simple(n.name)
+        return sref + n.type + self.visit(n.field)
+
+    def visit_FuncCall(self, n):
+        fref = self._parenthesize_unless_simple(n.name)
+        return fref + '(' + self.visit(n.args) + ')'
+
+    def visit_UnaryOp(self, n):
+        if n.op == 'sizeof':
+            # Always parenthesize the argument of sizeof since it can be
+            # a name.
+            return 'sizeof(%s)' % self.visit(n.expr)
+        else:
+            operand = self._parenthesize_unless_simple(n.expr)
+            if n.op == 'p++':
+                return '%s++' % operand
+            elif n.op == 'p--':
+                return '%s--' % operand
+            else:
+                return '%s%s' % (n.op, operand)
+
+    # Precedence map of binary operators:
+    precedence_map = {
+        # Should be in sync with c_parser.CParser.precedence
+        # Higher numbers are stronger binding
+        '||': 0,  # weakest binding
+        '&&': 1,
+        '|': 2,
+        '^': 3,
+        '&': 4,
+        '==': 5, '!=': 5,
+        '>': 6, '>=': 6, '<': 6, '<=': 6,
+        '>>': 7, '<<': 7,
+        '+': 8, '-': 8,
+        '*': 9, '/': 9, '%': 9  # strongest binding
+    }
+
+    def visit_BinaryOp(self, n):
+        # Note: all binary operators are left-to-right associative
+        #
+        # If `n.left.op` has a stronger or equally binding precedence in
+        # comparison to `n.op`, no parenthesis are needed for the left:
+        # e.g., `(a*b) + c` is equivalent to `a*b + c`, as well as
+        #       `(a+b) - c` is equivalent to `a+b - c` (same precedence).
+        # If the left operator is weaker binding than the current, then
+        # parentheses are necessary:
+        # e.g., `(a+b) * c` is NOT equivalent to `a+b * c`.
+        lval_str = self._parenthesize_if(
+            n.left,
+            lambda d: not (self._is_simple_node(d) or
+                      self.reduce_parentheses and isinstance(d, c_ast.BinaryOp) and
+                      self.precedence_map[d.op] >= self.precedence_map[n.op]))
+        # If `n.right.op` has a stronger -but not equal- binding precedence,
+        # parenthesis can be omitted on the right:
+        # e.g., `a + (b*c)` is equivalent to `a + b*c`.
+        # If the right operator is weaker or equally binding, then parentheses
+        # are necessary:
+        # e.g., `a * (b+c)` is NOT equivalent to `a * b+c` and
+        #       `a - (b+c)` is NOT equivalent to `a - b+c` (same precedence).
+        rval_str = self._parenthesize_if(
+            n.right,
+            lambda d: not (self._is_simple_node(d) or
+                      self.reduce_parentheses and isinstance(d, c_ast.BinaryOp) and
+                      self.precedence_map[d.op] > self.precedence_map[n.op]))
+        return '%s %s %s' % (lval_str, n.op, rval_str)
+
+    def visit_Assignment(self, n):
+        rval_str = self._parenthesize_if(
+                            n.rvalue,
+                            lambda n: isinstance(n, c_ast.Assignment))
+        return '%s %s %s' % (self.visit(n.lvalue), n.op, rval_str)
+
+    def visit_IdentifierType(self, n):
+        return ' '.join(n.names)
+
+    def _visit_expr(self, n):
+        if isinstance(n, c_ast.InitList):
+            return '{' + self.visit(n) + '}'
+        elif isinstance(n, c_ast.ExprList):
+            return '(' + self.visit(n) + ')'
+        else:
+            return self.visit(n)
+
+    def visit_Decl(self, n, no_type=False):
+        # no_type is used when a Decl is part of a DeclList, where the type is
+        # explicitly only for the first declaration in a list.
+        #
+        s = n.name if no_type else self._generate_decl(n)
+        if n.bitsize: s += ' : ' + self.visit(n.bitsize)
+        if n.init:
+            s += ' = ' + self._visit_expr(n.init)
+        return s
+
+    def visit_DeclList(self, n):
+        s = self.visit(n.decls[0])
+        if len(n.decls) > 1:
+            s += ', ' + ', '.join(self.visit_Decl(decl, no_type=True)
+                                    for decl in n.decls[1:])
+        return s
+
+    def visit_Typedef(self, n):
+        s = ''
+        if n.storage: s += ' '.join(n.storage) + ' '
+        s += self._generate_type(n.type)
+        return s
+
+    def visit_Cast(self, n):
+        s = '(' + self._generate_type(n.to_type, emit_declname=False) + ')'
+        return s + ' ' + self._parenthesize_unless_simple(n.expr)
+
+    def visit_ExprList(self, n):
+        visited_subexprs = []
+        for expr in n.exprs:
+            visited_subexprs.append(self._visit_expr(expr))
+        return ', '.join(visited_subexprs)
+
+    def visit_InitList(self, n):
+        visited_subexprs = []
+        for expr in n.exprs:
+            visited_subexprs.append(self._visit_expr(expr))
+        return ', '.join(visited_subexprs)
+
+    def visit_Enum(self, n):
+        return self._generate_struct_union_enum(n, name='enum')
+
+    def visit_Alignas(self, n):
+        return '_Alignas({})'.format(self.visit(n.alignment))
+
+    def visit_Enumerator(self, n):
+        if not n.value:
+            return '{indent}{name},\n'.format(
+                indent=self._make_indent(),
+                name=n.name,
+            )
+        else:
+            return '{indent}{name} = {value},\n'.format(
+                indent=self._make_indent(),
+                name=n.name,
+                value=self.visit(n.value),
+            )
+
+    def visit_FuncDef(self, n):
+        decl = self.visit(n.decl)
+        self.indent_level = 0
+        body = self.visit(n.body)
+        if n.param_decls:
+            knrdecls = ';\n'.join(self.visit(p) for p in n.param_decls)
+            return decl + '\n' + knrdecls + ';\n' + body + '\n'
+        else:
+            return decl + '\n' + body + '\n'
+
+    def visit_FileAST(self, n):
+        s = ''
+        for ext in n.ext:
+            if isinstance(ext, c_ast.FuncDef):
+                s += self.visit(ext)
+            elif isinstance(ext, c_ast.Pragma):
+                s += self.visit(ext) + '\n'
+            else:
+                s += self.visit(ext) + ';\n'
+        return s
+
+    def visit_Compound(self, n):
+        s = self._make_indent() + '{\n'
+        self.indent_level += 2
+        if n.block_items:
+            s += ''.join(self._generate_stmt(stmt) for stmt in n.block_items)
+        self.indent_level -= 2
+        s += self._make_indent() + '}\n'
+        return s
+
+    def visit_CompoundLiteral(self, n):
+        return '(' + self.visit(n.type) + '){' + self.visit(n.init) + '}'
+
+
+    def visit_EmptyStatement(self, n):
+        return ';'
+
+    def visit_ParamList(self, n):
+        return ', '.join(self.visit(param) for param in n.params)
+
+    def visit_Return(self, n):
+        s = 'return'
+        if n.expr: s += ' ' + self.visit(n.expr)
+        return s + ';'
+
+    def visit_Break(self, n):
+        return 'break;'
+
+    def visit_Continue(self, n):
+        return 'continue;'
+
+    def visit_TernaryOp(self, n):
+        s  = '(' + self._visit_expr(n.cond) + ') ? '
+        s += '(' + self._visit_expr(n.iftrue) + ') : '
+        s += '(' + self._visit_expr(n.iffalse) + ')'
+        return s
+
+    def visit_If(self, n):
+        s = 'if ('
+        if n.cond: s += self.visit(n.cond)
+        s += ')\n'
+        s += self._generate_stmt(n.iftrue, add_indent=True)
+        if n.iffalse:
+            s += self._make_indent() + 'else\n'
+            s += self._generate_stmt(n.iffalse, add_indent=True)
+        return s
+
+    def visit_For(self, n):
+        s = 'for ('
+        if n.init: s += self.visit(n.init)
+        s += ';'
+        if n.cond: s += ' ' + self.visit(n.cond)
+        s += ';'
+        if n.next: s += ' ' + self.visit(n.next)
+        s += ')\n'
+        s += self._generate_stmt(n.stmt, add_indent=True)
+        return s
+
+    def visit_While(self, n):
+        s = 'while ('
+        if n.cond: s += self.visit(n.cond)
+        s += ')\n'
+        s += self._generate_stmt(n.stmt, add_indent=True)
+        return s
+
+    def visit_DoWhile(self, n):
+        s = 'do\n'
+        s += self._generate_stmt(n.stmt, add_indent=True)
+        s += self._make_indent() + 'while ('
+        if n.cond: s += self.visit(n.cond)
+        s += ');'
+        return s
+
+    def visit_StaticAssert(self, n):
+        s = '_Static_assert('
+        s += self.visit(n.cond)
+        if n.message:
+            s += ','
+            s += self.visit(n.message)
+        s += ')'
+        return s
+
+    def visit_Switch(self, n):
+        s = 'switch (' + self.visit(n.cond) + ')\n'
+        s += self._generate_stmt(n.stmt, add_indent=True)
+        return s
+
+    def visit_Case(self, n):
+        s = 'case ' + self.visit(n.expr) + ':\n'
+        for stmt in n.stmts:
+            s += self._generate_stmt(stmt, add_indent=True)
+        return s
+
+    def visit_Default(self, n):
+        s = 'default:\n'
+        for stmt in n.stmts:
+            s += self._generate_stmt(stmt, add_indent=True)
+        return s
+
+    def visit_Label(self, n):
+        return n.name + ':\n' + self._generate_stmt(n.stmt)
+
+    def visit_Goto(self, n):
+        return 'goto ' + n.name + ';'
+
+    def visit_EllipsisParam(self, n):
+        return '...'
+
+    def visit_Struct(self, n):
+        return self._generate_struct_union_enum(n, 'struct')
+
+    def visit_Typename(self, n):
+        return self._generate_type(n.type)
+
+    def visit_Union(self, n):
+        return self._generate_struct_union_enum(n, 'union')
+
+    def visit_NamedInitializer(self, n):
+        s = ''
+        for name in n.name:
+            if isinstance(name, c_ast.ID):
+                s += '.' + name.name
+            else:
+                s += '[' + self.visit(name) + ']'
+        s += ' = ' + self._visit_expr(n.expr)
+        return s
+
+    def visit_FuncDecl(self, n):
+        return self._generate_type(n)
+
+    def visit_ArrayDecl(self, n):
+        return self._generate_type(n, emit_declname=False)
+
+    def visit_TypeDecl(self, n):
+        return self._generate_type(n, emit_declname=False)
+
+    def visit_PtrDecl(self, n):
+        return self._generate_type(n, emit_declname=False)
+
+    def _generate_struct_union_enum(self, n, name):
+        """ Generates code for structs, unions, and enums. name should be
+            'struct', 'union', or 'enum'.
+        """
+        if name in ('struct', 'union'):
+            members = n.decls
+            body_function = self._generate_struct_union_body
+        else:
+            assert name == 'enum'
+            members = None if n.values is None else n.values.enumerators
+            body_function = self._generate_enum_body
+        s = name + ' ' + (n.name or '')
+        if members is not None:
+            # None means no members
+            # Empty sequence means an empty list of members
+            s += '\n'
+            s += self._make_indent()
+            self.indent_level += 2
+            s += '{\n'
+            s += body_function(members)
+            self.indent_level -= 2
+            s += self._make_indent() + '}'
+        return s
+
+    def _generate_struct_union_body(self, members):
+        return ''.join(self._generate_stmt(decl) for decl in members)
+
+    def _generate_enum_body(self, members):
+        # `[:-2] + '\n'` removes the final `,` from the enumerator list
+        return ''.join(self.visit(value) for value in members)[:-2] + '\n'
+
+    def _generate_stmt(self, n, add_indent=False):
+        """ Generation from a statement node. This method exists as a wrapper
+            for individual visit_* methods to handle different treatment of
+            some statements in this context.
+        """
+        typ = type(n)
+        if add_indent: self.indent_level += 2
+        indent = self._make_indent()
+        if add_indent: self.indent_level -= 2
+
+        if typ in (
+                c_ast.Decl, c_ast.Assignment, c_ast.Cast, c_ast.UnaryOp,
+                c_ast.BinaryOp, c_ast.TernaryOp, c_ast.FuncCall, c_ast.ArrayRef,
+                c_ast.StructRef, c_ast.Constant, c_ast.ID, c_ast.Typedef,
+                c_ast.ExprList):
+            # These can also appear in an expression context so no semicolon
+            # is added to them automatically
+            #
+            return indent + self.visit(n) + ';\n'
+        elif typ in (c_ast.Compound,):
+            # No extra indentation required before the opening brace of a
+            # compound - because it consists of multiple lines it has to
+            # compute its own indentation.
+            #
+            return self.visit(n)
+        elif typ in (c_ast.If,):
+            return indent + self.visit(n)
+        else:
+            return indent + self.visit(n) + '\n'
+
+    def _generate_decl(self, n):
+        """ Generation from a Decl node.
+        """
+        s = ''
+        if n.funcspec: s = ' '.join(n.funcspec) + ' '
+        if n.storage: s += ' '.join(n.storage) + ' '
+        if n.align: s += self.visit(n.align[0]) + ' '
+        s += self._generate_type(n.type)
+        return s
+
+    def _generate_type(self, n, modifiers=[], emit_declname = True):
+        """ Recursive generation from a type node. n is the type node.
+            modifiers collects the PtrDecl, ArrayDecl and FuncDecl modifiers
+            encountered on the way down to a TypeDecl, to allow proper
+            generation from it.
+        """
+        typ = type(n)
+        #~ print(n, modifiers)
+
+        if typ == c_ast.TypeDecl:
+            s = ''
+            if n.quals: s += ' '.join(n.quals) + ' '
+            s += self.visit(n.type)
+
+            nstr = n.declname if n.declname and emit_declname else ''
+            # Resolve modifiers.
+            # Wrap in parens to distinguish pointer to array and pointer to
+            # function syntax.
+            #
+            for i, modifier in enumerate(modifiers):
+                if isinstance(modifier, c_ast.ArrayDecl):
+                    if (i != 0 and
+                        isinstance(modifiers[i - 1], c_ast.PtrDecl)):
+                            nstr = '(' + nstr + ')'
+                    nstr += '['
+                    if modifier.dim_quals:
+                        nstr += ' '.join(modifier.dim_quals) + ' '
+                    nstr += self.visit(modifier.dim) + ']'
+                elif isinstance(modifier, c_ast.FuncDecl):
+                    if (i != 0 and
+                        isinstance(modifiers[i - 1], c_ast.PtrDecl)):
+                            nstr = '(' + nstr + ')'
+                    nstr += '(' + self.visit(modifier.args) + ')'
+                elif isinstance(modifier, c_ast.PtrDecl):
+                    if modifier.quals:
+                        nstr = '* %s%s' % (' '.join(modifier.quals),
+                                           ' ' + nstr if nstr else '')
+                    else:
+                        nstr = '*' + nstr
+            if nstr: s += ' ' + nstr
+            return s
+        elif typ == c_ast.Decl:
+            return self._generate_decl(n.type)
+        elif typ == c_ast.Typename:
+            return self._generate_type(n.type, emit_declname = emit_declname)
+        elif typ == c_ast.IdentifierType:
+            return ' '.join(n.names) + ' '
+        elif typ in (c_ast.ArrayDecl, c_ast.PtrDecl, c_ast.FuncDecl):
+            return self._generate_type(n.type, modifiers + [n],
+                                       emit_declname = emit_declname)
+        else:
+            return self.visit(n)
+
+    def _parenthesize_if(self, n, condition):
+        """ Visits 'n' and returns its string representation, parenthesized
+            if the condition function applied to the node returns True.
+        """
+        s = self._visit_expr(n)
+        if condition(n):
+            return '(' + s + ')'
+        else:
+            return s
+
+    def _parenthesize_unless_simple(self, n):
+        """ Common use case for _parenthesize_if
+        """
+        return self._parenthesize_if(n, lambda d: not self._is_simple_node(d))
+
+    def _is_simple_node(self, n):
+        """ Returns True for nodes that are "simple" - i.e. nodes that always
+            have higher precedence than operators.
+        """
+        return isinstance(n, (c_ast.Constant, c_ast.ID, c_ast.ArrayRef,
+                              c_ast.StructRef, c_ast.FuncCall))
diff --git a/myenv/lib/python3.9/site-packages/pycparser/c_lexer.py b/myenv/lib/python3.9/site-packages/pycparser/c_lexer.py
new file mode 100644
index 0000000..d68d8eb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/c_lexer.py
@@ -0,0 +1,554 @@
+#------------------------------------------------------------------------------
+# pycparser: c_lexer.py
+#
+# CLexer class: lexer for the C language
+#
+# Eli Bendersky [https://eli.thegreenplace.net/]
+# License: BSD
+#------------------------------------------------------------------------------
+import re
+
+from .ply import lex
+from .ply.lex import TOKEN
+
+
+class CLexer(object):
+    """ A lexer for the C language. After building it, set the
+        input text with input(), and call token() to get new
+        tokens.
+
+        The public attribute filename can be set to an initial
+        filename, but the lexer will update it upon #line
+        directives.
+    """
+    def __init__(self, error_func, on_lbrace_func, on_rbrace_func,
+                 type_lookup_func):
+        """ Create a new Lexer.
+
+            error_func:
+                An error function. Will be called with an error
+                message, line and column as arguments, in case of
+                an error during lexing.
+
+            on_lbrace_func, on_rbrace_func:
+                Called when an LBRACE or RBRACE is encountered
+                (likely to push/pop type_lookup_func's scope)
+
+            type_lookup_func:
+                A type lookup function. Given a string, it must
+                return True IFF this string is a name of a type
+                that was defined with a typedef earlier.
+        """
+        self.error_func = error_func
+        self.on_lbrace_func = on_lbrace_func
+        self.on_rbrace_func = on_rbrace_func
+        self.type_lookup_func = type_lookup_func
+        self.filename = ''
+
+        # Keeps track of the last token returned from self.token()
+        self.last_token = None
+
+        # Allow either "# line" or "# <num>" to support GCC's
+        # cpp output
+        #
+        self.line_pattern = re.compile(r'([ \t]*line\W)|([ \t]*\d+)')
+        self.pragma_pattern = re.compile(r'[ \t]*pragma\W')
+
+    def build(self, **kwargs):
+        """ Builds the lexer from the specification. Must be
+            called after the lexer object is created.
+
+            This method exists separately, because the PLY
+            manual warns against calling lex.lex inside
+            __init__
+        """
+        self.lexer = lex.lex(object=self, **kwargs)
+
+    def reset_lineno(self):
+        """ Resets the internal line number counter of the lexer.
+        """
+        self.lexer.lineno = 1
+
+    def input(self, text):
+        self.lexer.input(text)
+
+    def token(self):
+        self.last_token = self.lexer.token()
+        return self.last_token
+
+    def find_tok_column(self, token):
+        """ Find the column of the token in its line.
+        """
+        last_cr = self.lexer.lexdata.rfind('\n', 0, token.lexpos)
+        return token.lexpos - last_cr
+
+    ######################--   PRIVATE   --######################
+
+    ##
+    ## Internal auxiliary methods
+    ##
+    def _error(self, msg, token):
+        location = self._make_tok_location(token)
+        self.error_func(msg, location[0], location[1])
+        self.lexer.skip(1)
+
+    def _make_tok_location(self, token):
+        return (token.lineno, self.find_tok_column(token))
+
+    ##
+    ## Reserved keywords
+    ##
+    keywords = (
+        'AUTO', 'BREAK', 'CASE', 'CHAR', 'CONST',
+        'CONTINUE', 'DEFAULT', 'DO', 'DOUBLE', 'ELSE', 'ENUM', 'EXTERN',
+        'FLOAT', 'FOR', 'GOTO', 'IF', 'INLINE', 'INT', 'LONG',
+        'REGISTER', 'OFFSETOF',
+        'RESTRICT', 'RETURN', 'SHORT', 'SIGNED', 'SIZEOF', 'STATIC', 'STRUCT',
+        'SWITCH', 'TYPEDEF', 'UNION', 'UNSIGNED', 'VOID',
+        'VOLATILE', 'WHILE', '__INT128',
+    )
+
+    keywords_new = (
+        '_BOOL', '_COMPLEX',
+        '_NORETURN', '_THREAD_LOCAL', '_STATIC_ASSERT',
+        '_ATOMIC', '_ALIGNOF', '_ALIGNAS',
+        )
+
+    keyword_map = {}
+
+    for keyword in keywords:
+        keyword_map[keyword.lower()] = keyword
+
+    for keyword in keywords_new:
+        keyword_map[keyword[:2].upper() + keyword[2:].lower()] = keyword
+
+    ##
+    ## All the tokens recognized by the lexer
+    ##
+    tokens = keywords + keywords_new + (
+        # Identifiers
+        'ID',
+
+        # Type identifiers (identifiers previously defined as
+        # types with typedef)
+        'TYPEID',
+
+        # constants
+        'INT_CONST_DEC', 'INT_CONST_OCT', 'INT_CONST_HEX', 'INT_CONST_BIN', 'INT_CONST_CHAR',
+        'FLOAT_CONST', 'HEX_FLOAT_CONST',
+        'CHAR_CONST',
+        'WCHAR_CONST',
+        'U8CHAR_CONST',
+        'U16CHAR_CONST',
+        'U32CHAR_CONST',
+
+        # String literals
+        'STRING_LITERAL',
+        'WSTRING_LITERAL',
+        'U8STRING_LITERAL',
+        'U16STRING_LITERAL',
+        'U32STRING_LITERAL',
+
+        # Operators
+        'PLUS', 'MINUS', 'TIMES', 'DIVIDE', 'MOD',
+        'OR', 'AND', 'NOT', 'XOR', 'LSHIFT', 'RSHIFT',
+        'LOR', 'LAND', 'LNOT',
+        'LT', 'LE', 'GT', 'GE', 'EQ', 'NE',
+
+        # Assignment
+        'EQUALS', 'TIMESEQUAL', 'DIVEQUAL', 'MODEQUAL',
+        'PLUSEQUAL', 'MINUSEQUAL',
+        'LSHIFTEQUAL','RSHIFTEQUAL', 'ANDEQUAL', 'XOREQUAL',
+        'OREQUAL',
+
+        # Increment/decrement
+        'PLUSPLUS', 'MINUSMINUS',
+
+        # Structure dereference (->)
+        'ARROW',
+
+        # Conditional operator (?)
+        'CONDOP',
+
+        # Delimiters
+        'LPAREN', 'RPAREN',         # ( )
+        'LBRACKET', 'RBRACKET',     # [ ]
+        'LBRACE', 'RBRACE',         # { }
+        'COMMA', 'PERIOD',          # . ,
+        'SEMI', 'COLON',            # ; :
+
+        # Ellipsis (...)
+        'ELLIPSIS',
+
+        # pre-processor
+        'PPHASH',       # '#'
+        'PPPRAGMA',     # 'pragma'
+        'PPPRAGMASTR',
+    )
+
+    ##
+    ## Regexes for use in tokens
+    ##
+    ##
+
+    # valid C identifiers (K&R2: A.2.3), plus '$' (supported by some compilers)
+    identifier = r'[a-zA-Z_$][0-9a-zA-Z_$]*'
+
+    hex_prefix = '0[xX]'
+    hex_digits = '[0-9a-fA-F]+'
+    bin_prefix = '0[bB]'
+    bin_digits = '[01]+'
+
+    # integer constants (K&R2: A.2.5.1)
+    integer_suffix_opt = r'(([uU]ll)|([uU]LL)|(ll[uU]?)|(LL[uU]?)|([uU][lL])|([lL][uU]?)|[uU])?'
+    decimal_constant = '(0'+integer_suffix_opt+')|([1-9][0-9]*'+integer_suffix_opt+')'
+    octal_constant = '0[0-7]*'+integer_suffix_opt
+    hex_constant = hex_prefix+hex_digits+integer_suffix_opt
+    bin_constant = bin_prefix+bin_digits+integer_suffix_opt
+
+    bad_octal_constant = '0[0-7]*[89]'
+
+    # character constants (K&R2: A.2.5.2)
+    # Note: a-zA-Z and '.-~^_!=&;,' are allowed as escape chars to support #line
+    # directives with Windows paths as filenames (..\..\dir\file)
+    # For the same reason, decimal_escape allows all digit sequences. We want to
+    # parse all correct code, even if it means to sometimes parse incorrect
+    # code.
+    #
+    # The original regexes were taken verbatim from the C syntax definition,
+    # and were later modified to avoid worst-case exponential running time.
+    #
+    #   simple_escape = r"""([a-zA-Z._~!=&\^\-\\?'"])"""
+    #   decimal_escape = r"""(\d+)"""
+    #   hex_escape = r"""(x[0-9a-fA-F]+)"""
+    #   bad_escape = r"""([\\][^a-zA-Z._~^!=&\^\-\\?'"x0-7])"""
+    #
+    # The following modifications were made to avoid the ambiguity that allowed backtracking:
+    # (https://github.com/eliben/pycparser/issues/61)
+    #
+    # - \x was removed from simple_escape, unless it was not followed by a hex digit, to avoid ambiguity with hex_escape.
+    # - hex_escape allows one or more hex characters, but requires that the next character(if any) is not hex
+    # - decimal_escape allows one or more decimal characters, but requires that the next character(if any) is not a decimal
+    # - bad_escape does not allow any decimals (8-9), to avoid conflicting with the permissive decimal_escape.
+    #
+    # Without this change, python's `re` module would recursively try parsing each ambiguous escape sequence in multiple ways.
+    # e.g. `\123` could be parsed as `\1`+`23`, `\12`+`3`, and `\123`.
+
+    simple_escape = r"""([a-wyzA-Z._~!=&\^\-\\?'"]|x(?![0-9a-fA-F]))"""
+    decimal_escape = r"""(\d+)(?!\d)"""
+    hex_escape = r"""(x[0-9a-fA-F]+)(?![0-9a-fA-F])"""
+    bad_escape = r"""([\\][^a-zA-Z._~^!=&\^\-\\?'"x0-9])"""
+
+    escape_sequence = r"""(\\("""+simple_escape+'|'+decimal_escape+'|'+hex_escape+'))'
+
+    # This complicated regex with lookahead might be slow for strings, so because all of the valid escapes (including \x) allowed
+    # 0 or more non-escaped characters after the first character, simple_escape+decimal_escape+hex_escape got simplified to
+
+    escape_sequence_start_in_string = r"""(\\[0-9a-zA-Z._~!=&\^\-\\?'"])"""
+
+    cconst_char = r"""([^'\\\n]|"""+escape_sequence+')'
+    char_const = "'"+cconst_char+"'"
+    wchar_const = 'L'+char_const
+    u8char_const = 'u8'+char_const
+    u16char_const = 'u'+char_const
+    u32char_const = 'U'+char_const
+    multicharacter_constant = "'"+cconst_char+"{2,4}'"
+    unmatched_quote = "('"+cconst_char+"*\\n)|('"+cconst_char+"*$)"
+    bad_char_const = r"""('"""+cconst_char+"""[^'\n]+')|('')|('"""+bad_escape+r"""[^'\n]*')"""
+
+    # string literals (K&R2: A.2.6)
+    string_char = r"""([^"\\\n]|"""+escape_sequence_start_in_string+')'
+    string_literal = '"'+string_char+'*"'
+    wstring_literal = 'L'+string_literal
+    u8string_literal = 'u8'+string_literal
+    u16string_literal = 'u'+string_literal
+    u32string_literal = 'U'+string_literal
+    bad_string_literal = '"'+string_char+'*'+bad_escape+string_char+'*"'
+
+    # floating constants (K&R2: A.2.5.3)
+    exponent_part = r"""([eE][-+]?[0-9]+)"""
+    fractional_constant = r"""([0-9]*\.[0-9]+)|([0-9]+\.)"""
+    floating_constant = '(((('+fractional_constant+')'+exponent_part+'?)|([0-9]+'+exponent_part+'))[FfLl]?)'
+    binary_exponent_part = r'''([pP][+-]?[0-9]+)'''
+    hex_fractional_constant = '((('+hex_digits+r""")?\."""+hex_digits+')|('+hex_digits+r"""\.))"""
+    hex_floating_constant = '('+hex_prefix+'('+hex_digits+'|'+hex_fractional_constant+')'+binary_exponent_part+'[FfLl]?)'
+
+    ##
+    ## Lexer states: used for preprocessor \n-terminated directives
+    ##
+    states = (
+        # ppline: preprocessor line directives
+        #
+        ('ppline', 'exclusive'),
+
+        # pppragma: pragma
+        #
+        ('pppragma', 'exclusive'),
+    )
+
+    def t_PPHASH(self, t):
+        r'[ \t]*\#'
+        if self.line_pattern.match(t.lexer.lexdata, pos=t.lexer.lexpos):
+            t.lexer.begin('ppline')
+            self.pp_line = self.pp_filename = None
+        elif self.pragma_pattern.match(t.lexer.lexdata, pos=t.lexer.lexpos):
+            t.lexer.begin('pppragma')
+        else:
+            t.type = 'PPHASH'
+            return t
+
+    ##
+    ## Rules for the ppline state
+    ##
+    @TOKEN(string_literal)
+    def t_ppline_FILENAME(self, t):
+        if self.pp_line is None:
+            self._error('filename before line number in #line', t)
+        else:
+            self.pp_filename = t.value.lstrip('"').rstrip('"')
+
+    @TOKEN(decimal_constant)
+    def t_ppline_LINE_NUMBER(self, t):
+        if self.pp_line is None:
+            self.pp_line = t.value
+        else:
+            # Ignore: GCC's cpp sometimes inserts a numeric flag
+            # after the file name
+            pass
+
+    def t_ppline_NEWLINE(self, t):
+        r'\n'
+        if self.pp_line is None:
+            self._error('line number missing in #line', t)
+        else:
+            self.lexer.lineno = int(self.pp_line)
+
+            if self.pp_filename is not None:
+                self.filename = self.pp_filename
+
+        t.lexer.begin('INITIAL')
+
+    def t_ppline_PPLINE(self, t):
+        r'line'
+        pass
+
+    t_ppline_ignore = ' \t'
+
+    def t_ppline_error(self, t):
+        self._error('invalid #line directive', t)
+
+    ##
+    ## Rules for the pppragma state
+    ##
+    def t_pppragma_NEWLINE(self, t):
+        r'\n'
+        t.lexer.lineno += 1
+        t.lexer.begin('INITIAL')
+
+    def t_pppragma_PPPRAGMA(self, t):
+        r'pragma'
+        return t
+
+    t_pppragma_ignore = ' \t'
+
+    def t_pppragma_STR(self, t):
+        '.+'
+        t.type = 'PPPRAGMASTR'
+        return t
+
+    def t_pppragma_error(self, t):
+        self._error('invalid #pragma directive', t)
+
+    ##
+    ## Rules for the normal state
+    ##
+    t_ignore = ' \t'
+
+    # Newlines
+    def t_NEWLINE(self, t):
+        r'\n+'
+        t.lexer.lineno += t.value.count("\n")
+
+    # Operators
+    t_PLUS              = r'\+'
+    t_MINUS             = r'-'
+    t_TIMES             = r'\*'
+    t_DIVIDE            = r'/'
+    t_MOD               = r'%'
+    t_OR                = r'\|'
+    t_AND               = r'&'
+    t_NOT               = r'~'
+    t_XOR               = r'\^'
+    t_LSHIFT            = r'<<'
+    t_RSHIFT            = r'>>'
+    t_LOR               = r'\|\|'
+    t_LAND              = r'&&'
+    t_LNOT              = r'!'
+    t_LT                = r'<'
+    t_GT                = r'>'
+    t_LE                = r'<='
+    t_GE                = r'>='
+    t_EQ                = r'=='
+    t_NE                = r'!='
+
+    # Assignment operators
+    t_EQUALS            = r'='
+    t_TIMESEQUAL        = r'\*='
+    t_DIVEQUAL          = r'/='
+    t_MODEQUAL          = r'%='
+    t_PLUSEQUAL         = r'\+='
+    t_MINUSEQUAL        = r'-='
+    t_LSHIFTEQUAL       = r'<<='
+    t_RSHIFTEQUAL       = r'>>='
+    t_ANDEQUAL          = r'&='
+    t_OREQUAL           = r'\|='
+    t_XOREQUAL          = r'\^='
+
+    # Increment/decrement
+    t_PLUSPLUS          = r'\+\+'
+    t_MINUSMINUS        = r'--'
+
+    # ->
+    t_ARROW             = r'->'
+
+    # ?
+    t_CONDOP            = r'\?'
+
+    # Delimiters
+    t_LPAREN            = r'\('
+    t_RPAREN            = r'\)'
+    t_LBRACKET          = r'\['
+    t_RBRACKET          = r'\]'
+    t_COMMA             = r','
+    t_PERIOD            = r'\.'
+    t_SEMI              = r';'
+    t_COLON             = r':'
+    t_ELLIPSIS          = r'\.\.\.'
+
+    # Scope delimiters
+    # To see why on_lbrace_func is needed, consider:
+    #   typedef char TT;
+    #   void foo(int TT) { TT = 10; }
+    #   TT x = 5;
+    # Outside the function, TT is a typedef, but inside (starting and ending
+    # with the braces) it's a parameter.  The trouble begins with yacc's
+    # lookahead token.  If we open a new scope in brace_open, then TT has
+    # already been read and incorrectly interpreted as TYPEID.  So, we need
+    # to open and close scopes from within the lexer.
+    # Similar for the TT immediately outside the end of the function.
+    #
+    @TOKEN(r'\{')
+    def t_LBRACE(self, t):
+        self.on_lbrace_func()
+        return t
+    @TOKEN(r'\}')
+    def t_RBRACE(self, t):
+        self.on_rbrace_func()
+        return t
+
+    t_STRING_LITERAL = string_literal
+
+    # The following floating and integer constants are defined as
+    # functions to impose a strict order (otherwise, decimal
+    # is placed before the others because its regex is longer,
+    # and this is bad)
+    #
+    @TOKEN(floating_constant)
+    def t_FLOAT_CONST(self, t):
+        return t
+
+    @TOKEN(hex_floating_constant)
+    def t_HEX_FLOAT_CONST(self, t):
+        return t
+
+    @TOKEN(hex_constant)
+    def t_INT_CONST_HEX(self, t):
+        return t
+
+    @TOKEN(bin_constant)
+    def t_INT_CONST_BIN(self, t):
+        return t
+
+    @TOKEN(bad_octal_constant)
+    def t_BAD_CONST_OCT(self, t):
+        msg = "Invalid octal constant"
+        self._error(msg, t)
+
+    @TOKEN(octal_constant)
+    def t_INT_CONST_OCT(self, t):
+        return t
+
+    @TOKEN(decimal_constant)
+    def t_INT_CONST_DEC(self, t):
+        return t
+
+    # Must come before bad_char_const, to prevent it from
+    # catching valid char constants as invalid
+    #
+    @TOKEN(multicharacter_constant)
+    def t_INT_CONST_CHAR(self, t):
+        return t
+
+    @TOKEN(char_const)
+    def t_CHAR_CONST(self, t):
+        return t
+
+    @TOKEN(wchar_const)
+    def t_WCHAR_CONST(self, t):
+        return t
+
+    @TOKEN(u8char_const)
+    def t_U8CHAR_CONST(self, t):
+        return t
+
+    @TOKEN(u16char_const)
+    def t_U16CHAR_CONST(self, t):
+        return t
+
+    @TOKEN(u32char_const)
+    def t_U32CHAR_CONST(self, t):
+        return t
+
+    @TOKEN(unmatched_quote)
+    def t_UNMATCHED_QUOTE(self, t):
+        msg = "Unmatched '"
+        self._error(msg, t)
+
+    @TOKEN(bad_char_const)
+    def t_BAD_CHAR_CONST(self, t):
+        msg = "Invalid char constant %s" % t.value
+        self._error(msg, t)
+
+    @TOKEN(wstring_literal)
+    def t_WSTRING_LITERAL(self, t):
+        return t
+
+    @TOKEN(u8string_literal)
+    def t_U8STRING_LITERAL(self, t):
+        return t
+
+    @TOKEN(u16string_literal)
+    def t_U16STRING_LITERAL(self, t):
+        return t
+
+    @TOKEN(u32string_literal)
+    def t_U32STRING_LITERAL(self, t):
+        return t
+
+    # unmatched string literals are caught by the preprocessor
+
+    @TOKEN(bad_string_literal)
+    def t_BAD_STRING_LITERAL(self, t):
+        msg = "String contains invalid escape code"
+        self._error(msg, t)
+
+    @TOKEN(identifier)
+    def t_ID(self, t):
+        t.type = self.keyword_map.get(t.value, "ID")
+        if t.type == 'ID' and self.type_lookup_func(t.value):
+            t.type = "TYPEID"
+        return t
+
+    def t_error(self, t):
+        msg = 'Illegal character %s' % repr(t.value[0])
+        self._error(msg, t)
diff --git a/myenv/lib/python3.9/site-packages/pycparser/c_parser.py b/myenv/lib/python3.9/site-packages/pycparser/c_parser.py
new file mode 100644
index 0000000..640a759
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/c_parser.py
@@ -0,0 +1,1936 @@
+#------------------------------------------------------------------------------
+# pycparser: c_parser.py
+#
+# CParser class: Parser and AST builder for the C language
+#
+# Eli Bendersky [https://eli.thegreenplace.net/]
+# License: BSD
+#------------------------------------------------------------------------------
+from .ply import yacc
+
+from . import c_ast
+from .c_lexer import CLexer
+from .plyparser import PLYParser, ParseError, parameterized, template
+from .ast_transforms import fix_switch_cases, fix_atomic_specifiers
+
+
+@template
+class CParser(PLYParser):
+    def __init__(
+            self,
+            lex_optimize=True,
+            lexer=CLexer,
+            lextab='pycparser.lextab',
+            yacc_optimize=True,
+            yacctab='pycparser.yacctab',
+            yacc_debug=False,
+            taboutputdir=''):
+        """ Create a new CParser.
+
+            Some arguments for controlling the debug/optimization
+            level of the parser are provided. The defaults are
+            tuned for release/performance mode.
+            The simple rules for using them are:
+            *) When tweaking CParser/CLexer, set these to False
+            *) When releasing a stable parser, set to True
+
+            lex_optimize:
+                Set to False when you're modifying the lexer.
+                Otherwise, changes in the lexer won't be used, if
+                some lextab.py file exists.
+                When releasing with a stable lexer, set to True
+                to save the re-generation of the lexer table on
+                each run.
+
+            lexer:
+                Set this parameter to define the lexer to use if
+                you're not using the default CLexer.
+
+            lextab:
+                Points to the lex table that's used for optimized
+                mode. Only if you're modifying the lexer and want
+                some tests to avoid re-generating the table, make
+                this point to a local lex table file (that's been
+                earlier generated with lex_optimize=True)
+
+            yacc_optimize:
+                Set to False when you're modifying the parser.
+                Otherwise, changes in the parser won't be used, if
+                some parsetab.py file exists.
+                When releasing with a stable parser, set to True
+                to save the re-generation of the parser table on
+                each run.
+
+            yacctab:
+                Points to the yacc table that's used for optimized
+                mode. Only if you're modifying the parser, make
+                this point to a local yacc table file
+
+            yacc_debug:
+                Generate a parser.out file that explains how yacc
+                built the parsing table from the grammar.
+
+            taboutputdir:
+                Set this parameter to control the location of generated
+                lextab and yacctab files.
+        """
+        self.clex = lexer(
+            error_func=self._lex_error_func,
+            on_lbrace_func=self._lex_on_lbrace_func,
+            on_rbrace_func=self._lex_on_rbrace_func,
+            type_lookup_func=self._lex_type_lookup_func)
+
+        self.clex.build(
+            optimize=lex_optimize,
+            lextab=lextab,
+            outputdir=taboutputdir)
+        self.tokens = self.clex.tokens
+
+        rules_with_opt = [
+            'abstract_declarator',
+            'assignment_expression',
+            'declaration_list',
+            'declaration_specifiers_no_type',
+            'designation',
+            'expression',
+            'identifier_list',
+            'init_declarator_list',
+            'id_init_declarator_list',
+            'initializer_list',
+            'parameter_type_list',
+            'block_item_list',
+            'type_qualifier_list',
+            'struct_declarator_list'
+        ]
+
+        for rule in rules_with_opt:
+            self._create_opt_rule(rule)
+
+        self.cparser = yacc.yacc(
+            module=self,
+            start='translation_unit_or_empty',
+            debug=yacc_debug,
+            optimize=yacc_optimize,
+            tabmodule=yacctab,
+            outputdir=taboutputdir)
+
+        # Stack of scopes for keeping track of symbols. _scope_stack[-1] is
+        # the current (topmost) scope. Each scope is a dictionary that
+        # specifies whether a name is a type. If _scope_stack[n][name] is
+        # True, 'name' is currently a type in the scope. If it's False,
+        # 'name' is used in the scope but not as a type (for instance, if we
+        # saw: int name;
+        # If 'name' is not a key in _scope_stack[n] then 'name' was not defined
+        # in this scope at all.
+        self._scope_stack = [dict()]
+
+        # Keeps track of the last token given to yacc (the lookahead token)
+        self._last_yielded_token = None
+
+    def parse(self, text, filename='', debug=False):
+        """ Parses C code and returns an AST.
+
+            text:
+                A string containing the C source code
+
+            filename:
+                Name of the file being parsed (for meaningful
+                error messages)
+
+            debug:
+                Debug flag to YACC
+        """
+        self.clex.filename = filename
+        self.clex.reset_lineno()
+        self._scope_stack = [dict()]
+        self._last_yielded_token = None
+        return self.cparser.parse(
+                input=text,
+                lexer=self.clex,
+                debug=debug)
+
+    ######################--   PRIVATE   --######################
+
+    def _push_scope(self):
+        self._scope_stack.append(dict())
+
+    def _pop_scope(self):
+        assert len(self._scope_stack) > 1
+        self._scope_stack.pop()
+
+    def _add_typedef_name(self, name, coord):
+        """ Add a new typedef name (ie a TYPEID) to the current scope
+        """
+        if not self._scope_stack[-1].get(name, True):
+            self._parse_error(
+                "Typedef %r previously declared as non-typedef "
+                "in this scope" % name, coord)
+        self._scope_stack[-1][name] = True
+
+    def _add_identifier(self, name, coord):
+        """ Add a new object, function, or enum member name (ie an ID) to the
+            current scope
+        """
+        if self._scope_stack[-1].get(name, False):
+            self._parse_error(
+                "Non-typedef %r previously declared as typedef "
+                "in this scope" % name, coord)
+        self._scope_stack[-1][name] = False
+
+    def _is_type_in_scope(self, name):
+        """ Is *name* a typedef-name in the current scope?
+        """
+        for scope in reversed(self._scope_stack):
+            # If name is an identifier in this scope it shadows typedefs in
+            # higher scopes.
+            in_scope = scope.get(name)
+            if in_scope is not None: return in_scope
+        return False
+
+    def _lex_error_func(self, msg, line, column):
+        self._parse_error(msg, self._coord(line, column))
+
+    def _lex_on_lbrace_func(self):
+        self._push_scope()
+
+    def _lex_on_rbrace_func(self):
+        self._pop_scope()
+
+    def _lex_type_lookup_func(self, name):
+        """ Looks up types that were previously defined with
+            typedef.
+            Passed to the lexer for recognizing identifiers that
+            are types.
+        """
+        is_type = self._is_type_in_scope(name)
+        return is_type
+
+    def _get_yacc_lookahead_token(self):
+        """ We need access to yacc's lookahead token in certain cases.
+            This is the last token yacc requested from the lexer, so we
+            ask the lexer.
+        """
+        return self.clex.last_token
+
+    # To understand what's going on here, read sections A.8.5 and
+    # A.8.6 of K&R2 very carefully.
+    #
+    # A C type consists of a basic type declaration, with a list
+    # of modifiers. For example:
+    #
+    # int *c[5];
+    #
+    # The basic declaration here is 'int c', and the pointer and
+    # the array are the modifiers.
+    #
+    # Basic declarations are represented by TypeDecl (from module c_ast) and the
+    # modifiers are FuncDecl, PtrDecl and ArrayDecl.
+    #
+    # The standard states that whenever a new modifier is parsed, it should be
+    # added to the end of the list of modifiers. For example:
+    #
+    # K&R2 A.8.6.2: Array Declarators
+    #
+    # In a declaration T D where D has the form
+    #   D1 [constant-expression-opt]
+    # and the type of the identifier in the declaration T D1 is
+    # "type-modifier T", the type of the
+    # identifier of D is "type-modifier array of T"
+    #
+    # This is what this method does. The declarator it receives
+    # can be a list of declarators ending with TypeDecl. It
+    # tacks the modifier to the end of this list, just before
+    # the TypeDecl.
+    #
+    # Additionally, the modifier may be a list itself. This is
+    # useful for pointers, that can come as a chain from the rule
+    # p_pointer. In this case, the whole modifier list is spliced
+    # into the new location.
+    def _type_modify_decl(self, decl, modifier):
+        """ Tacks a type modifier on a declarator, and returns
+            the modified declarator.
+
+            Note: the declarator and modifier may be modified
+        """
+        #~ print '****'
+        #~ decl.show(offset=3)
+        #~ modifier.show(offset=3)
+        #~ print '****'
+
+        modifier_head = modifier
+        modifier_tail = modifier
+
+        # The modifier may be a nested list. Reach its tail.
+        while modifier_tail.type:
+            modifier_tail = modifier_tail.type
+
+        # If the decl is a basic type, just tack the modifier onto it.
+        if isinstance(decl, c_ast.TypeDecl):
+            modifier_tail.type = decl
+            return modifier
+        else:
+            # Otherwise, the decl is a list of modifiers. Reach
+            # its tail and splice the modifier onto the tail,
+            # pointing to the underlying basic type.
+            decl_tail = decl
+
+            while not isinstance(decl_tail.type, c_ast.TypeDecl):
+                decl_tail = decl_tail.type
+
+            modifier_tail.type = decl_tail.type
+            decl_tail.type = modifier_head
+            return decl
+
+    # Due to the order in which declarators are constructed,
+    # they have to be fixed in order to look like a normal AST.
+    #
+    # When a declaration arrives from syntax construction, it has
+    # these problems:
+    # * The innermost TypeDecl has no type (because the basic
+    #   type is only known at the uppermost declaration level)
+    # * The declaration has no variable name, since that is saved
+    #   in the innermost TypeDecl
+    # * The typename of the declaration is a list of type
+    #   specifiers, and not a node. Here, basic identifier types
+    #   should be separated from more complex types like enums
+    #   and structs.
+    #
+    # This method fixes these problems.
+    def _fix_decl_name_type(self, decl, typename):
+        """ Fixes a declaration. Modifies decl.
+        """
+        # Reach the underlying basic type
+        #
+        type = decl
+        while not isinstance(type, c_ast.TypeDecl):
+            type = type.type
+
+        decl.name = type.declname
+        type.quals = decl.quals[:]
+
+        # The typename is a list of types. If any type in this
+        # list isn't an IdentifierType, it must be the only
+        # type in the list (it's illegal to declare "int enum ..")
+        # If all the types are basic, they're collected in the
+        # IdentifierType holder.
+        for tn in typename:
+            if not isinstance(tn, c_ast.IdentifierType):
+                if len(typename) > 1:
+                    self._parse_error(
+                        "Invalid multiple types specified", tn.coord)
+                else:
+                    type.type = tn
+                    return decl
+
+        if not typename:
+            # Functions default to returning int
+            #
+            if not isinstance(decl.type, c_ast.FuncDecl):
+                self._parse_error(
+                        "Missing type in declaration", decl.coord)
+            type.type = c_ast.IdentifierType(
+                    ['int'],
+                    coord=decl.coord)
+        else:
+            # At this point, we know that typename is a list of IdentifierType
+            # nodes. Concatenate all the names into a single list.
+            #
+            type.type = c_ast.IdentifierType(
+                [name for id in typename for name in id.names],
+                coord=typename[0].coord)
+        return decl
+
+    def _add_declaration_specifier(self, declspec, newspec, kind, append=False):
+        """ Declaration specifiers are represented by a dictionary
+            with the entries:
+            * qual: a list of type qualifiers
+            * storage: a list of storage type qualifiers
+            * type: a list of type specifiers
+            * function: a list of function specifiers
+            * alignment: a list of alignment specifiers
+
+            This method is given a declaration specifier, and a
+            new specifier of a given kind.
+            If `append` is True, the new specifier is added to the end of
+            the specifiers list, otherwise it's added at the beginning.
+            Returns the declaration specifier, with the new
+            specifier incorporated.
+        """
+        spec = declspec or dict(qual=[], storage=[], type=[], function=[], alignment=[])
+
+        if append:
+            spec[kind].append(newspec)
+        else:
+            spec[kind].insert(0, newspec)
+
+        return spec
+
+    def _build_declarations(self, spec, decls, typedef_namespace=False):
+        """ Builds a list of declarations all sharing the given specifiers.
+            If typedef_namespace is true, each declared name is added
+            to the "typedef namespace", which also includes objects,
+            functions, and enum constants.
+        """
+        is_typedef = 'typedef' in spec['storage']
+        declarations = []
+
+        # Bit-fields are allowed to be unnamed.
+        if decls[0].get('bitsize') is not None:
+            pass
+
+        # When redeclaring typedef names as identifiers in inner scopes, a
+        # problem can occur where the identifier gets grouped into
+        # spec['type'], leaving decl as None.  This can only occur for the
+        # first declarator.
+        elif decls[0]['decl'] is None:
+            if len(spec['type']) < 2 or len(spec['type'][-1].names) != 1 or \
+                    not self._is_type_in_scope(spec['type'][-1].names[0]):
+                coord = '?'
+                for t in spec['type']:
+                    if hasattr(t, 'coord'):
+                        coord = t.coord
+                        break
+                self._parse_error('Invalid declaration', coord)
+
+            # Make this look as if it came from "direct_declarator:ID"
+            decls[0]['decl'] = c_ast.TypeDecl(
+                declname=spec['type'][-1].names[0],
+                type=None,
+                quals=None,
+                align=spec['alignment'],
+                coord=spec['type'][-1].coord)
+            # Remove the "new" type's name from the end of spec['type']
+            del spec['type'][-1]
+
+        # A similar problem can occur where the declaration ends up looking
+        # like an abstract declarator.  Give it a name if this is the case.
+        elif not isinstance(decls[0]['decl'], (
+                c_ast.Enum, c_ast.Struct, c_ast.Union, c_ast.IdentifierType)):
+            decls_0_tail = decls[0]['decl']
+            while not isinstance(decls_0_tail, c_ast.TypeDecl):
+                decls_0_tail = decls_0_tail.type
+            if decls_0_tail.declname is None:
+                decls_0_tail.declname = spec['type'][-1].names[0]
+                del spec['type'][-1]
+
+        for decl in decls:
+            assert decl['decl'] is not None
+            if is_typedef:
+                declaration = c_ast.Typedef(
+                    name=None,
+                    quals=spec['qual'],
+                    storage=spec['storage'],
+                    type=decl['decl'],
+                    coord=decl['decl'].coord)
+            else:
+                declaration = c_ast.Decl(
+                    name=None,
+                    quals=spec['qual'],
+                    align=spec['alignment'],
+                    storage=spec['storage'],
+                    funcspec=spec['function'],
+                    type=decl['decl'],
+                    init=decl.get('init'),
+                    bitsize=decl.get('bitsize'),
+                    coord=decl['decl'].coord)
+
+            if isinstance(declaration.type, (
+                    c_ast.Enum, c_ast.Struct, c_ast.Union,
+                    c_ast.IdentifierType)):
+                fixed_decl = declaration
+            else:
+                fixed_decl = self._fix_decl_name_type(declaration, spec['type'])
+
+            # Add the type name defined by typedef to a
+            # symbol table (for usage in the lexer)
+            if typedef_namespace:
+                if is_typedef:
+                    self._add_typedef_name(fixed_decl.name, fixed_decl.coord)
+                else:
+                    self._add_identifier(fixed_decl.name, fixed_decl.coord)
+
+            fixed_decl = fix_atomic_specifiers(fixed_decl)
+            declarations.append(fixed_decl)
+
+        return declarations
+
+    def _build_function_definition(self, spec, decl, param_decls, body):
+        """ Builds a function definition.
+        """
+        if 'typedef' in spec['storage']:
+            self._parse_error("Invalid typedef", decl.coord)
+
+        declaration = self._build_declarations(
+            spec=spec,
+            decls=[dict(decl=decl, init=None)],
+            typedef_namespace=True)[0]
+
+        return c_ast.FuncDef(
+            decl=declaration,
+            param_decls=param_decls,
+            body=body,
+            coord=decl.coord)
+
+    def _select_struct_union_class(self, token):
+        """ Given a token (either STRUCT or UNION), selects the
+            appropriate AST class.
+        """
+        if token == 'struct':
+            return c_ast.Struct
+        else:
+            return c_ast.Union
+
+    ##
+    ## Precedence and associativity of operators
+    ##
+    # If this changes, c_generator.CGenerator.precedence_map needs to change as
+    # well
+    precedence = (
+        ('left', 'LOR'),
+        ('left', 'LAND'),
+        ('left', 'OR'),
+        ('left', 'XOR'),
+        ('left', 'AND'),
+        ('left', 'EQ', 'NE'),
+        ('left', 'GT', 'GE', 'LT', 'LE'),
+        ('left', 'RSHIFT', 'LSHIFT'),
+        ('left', 'PLUS', 'MINUS'),
+        ('left', 'TIMES', 'DIVIDE', 'MOD')
+    )
+
+    ##
+    ## Grammar productions
+    ## Implementation of the BNF defined in K&R2 A.13
+    ##
+
+    # Wrapper around a translation unit, to allow for empty input.
+    # Not strictly part of the C99 Grammar, but useful in practice.
+    def p_translation_unit_or_empty(self, p):
+        """ translation_unit_or_empty   : translation_unit
+                                        | empty
+        """
+        if p[1] is None:
+            p[0] = c_ast.FileAST([])
+        else:
+            p[0] = c_ast.FileAST(p[1])
+
+    def p_translation_unit_1(self, p):
+        """ translation_unit    : external_declaration
+        """
+        # Note: external_declaration is already a list
+        p[0] = p[1]
+
+    def p_translation_unit_2(self, p):
+        """ translation_unit    : translation_unit external_declaration
+        """
+        p[1].extend(p[2])
+        p[0] = p[1]
+
+    # Declarations always come as lists (because they can be
+    # several in one line), so we wrap the function definition
+    # into a list as well, to make the return value of
+    # external_declaration homogeneous.
+    def p_external_declaration_1(self, p):
+        """ external_declaration    : function_definition
+        """
+        p[0] = [p[1]]
+
+    def p_external_declaration_2(self, p):
+        """ external_declaration    : declaration
+        """
+        p[0] = p[1]
+
+    def p_external_declaration_3(self, p):
+        """ external_declaration    : pp_directive
+                                    | pppragma_directive
+        """
+        p[0] = [p[1]]
+
+    def p_external_declaration_4(self, p):
+        """ external_declaration    : SEMI
+        """
+        p[0] = []
+
+    def p_external_declaration_5(self, p):
+        """ external_declaration    : static_assert
+        """
+        p[0] = p[1]
+
+    def p_static_assert_declaration(self, p):
+        """ static_assert           : _STATIC_ASSERT LPAREN constant_expression COMMA unified_string_literal RPAREN
+                                    | _STATIC_ASSERT LPAREN constant_expression RPAREN
+        """
+        if len(p) == 5:
+            p[0] = [c_ast.StaticAssert(p[3], None, self._token_coord(p, 1))]
+        else:
+            p[0] = [c_ast.StaticAssert(p[3], p[5], self._token_coord(p, 1))]
+
+    def p_pp_directive(self, p):
+        """ pp_directive  : PPHASH
+        """
+        self._parse_error('Directives not supported yet',
+                          self._token_coord(p, 1))
+
+    def p_pppragma_directive(self, p):
+        """ pppragma_directive      : PPPRAGMA
+                                    | PPPRAGMA PPPRAGMASTR
+        """
+        if len(p) == 3:
+            p[0] = c_ast.Pragma(p[2], self._token_coord(p, 2))
+        else:
+            p[0] = c_ast.Pragma("", self._token_coord(p, 1))
+
+    # In function definitions, the declarator can be followed by
+    # a declaration list, for old "K&R style" function definitios.
+    def p_function_definition_1(self, p):
+        """ function_definition : id_declarator declaration_list_opt compound_statement
+        """
+        # no declaration specifiers - 'int' becomes the default type
+        spec = dict(
+            qual=[],
+            alignment=[],
+            storage=[],
+            type=[c_ast.IdentifierType(['int'],
+                                       coord=self._token_coord(p, 1))],
+            function=[])
+
+        p[0] = self._build_function_definition(
+            spec=spec,
+            decl=p[1],
+            param_decls=p[2],
+            body=p[3])
+
+    def p_function_definition_2(self, p):
+        """ function_definition : declaration_specifiers id_declarator declaration_list_opt compound_statement
+        """
+        spec = p[1]
+
+        p[0] = self._build_function_definition(
+            spec=spec,
+            decl=p[2],
+            param_decls=p[3],
+            body=p[4])
+
+    # Note, according to C18 A.2.2 6.7.10 static_assert-declaration _Static_assert
+    # is a declaration, not a statement. We additionally recognise it as a statement
+    # to fix parsing of _Static_assert inside the functions.
+    #
+    def p_statement(self, p):
+        """ statement   : labeled_statement
+                        | expression_statement
+                        | compound_statement
+                        | selection_statement
+                        | iteration_statement
+                        | jump_statement
+                        | pppragma_directive
+                        | static_assert
+        """
+        p[0] = p[1]
+
+    # A pragma is generally considered a decorator rather than an actual
+    # statement. Still, for the purposes of analyzing an abstract syntax tree of
+    # C code, pragma's should not be ignored and were previously treated as a
+    # statement. This presents a problem for constructs that take a statement
+    # such as labeled_statements, selection_statements, and
+    # iteration_statements, causing a misleading structure in the AST. For
+    # example, consider the following C code.
+    #
+    #   for (int i = 0; i < 3; i++)
+    #       #pragma omp critical
+    #       sum += 1;
+    #
+    # This code will compile and execute "sum += 1;" as the body of the for
+    # loop. Previous implementations of PyCParser would render the AST for this
+    # block of code as follows:
+    #
+    #   For:
+    #     DeclList:
+    #       Decl: i, [], [], []
+    #         TypeDecl: i, []
+    #           IdentifierType: ['int']
+    #         Constant: int, 0
+    #     BinaryOp: <
+    #       ID: i
+    #       Constant: int, 3
+    #     UnaryOp: p++
+    #       ID: i
+    #     Pragma: omp critical
+    #   Assignment: +=
+    #     ID: sum
+    #     Constant: int, 1
+    #
+    # This AST misleadingly takes the Pragma as the body of the loop and the
+    # assignment then becomes a sibling of the loop.
+    #
+    # To solve edge cases like these, the pragmacomp_or_statement rule groups
+    # a pragma and its following statement (which would otherwise be orphaned)
+    # using a compound block, effectively turning the above code into:
+    #
+    #   for (int i = 0; i < 3; i++) {
+    #       #pragma omp critical
+    #       sum += 1;
+    #   }
+    def p_pragmacomp_or_statement(self, p):
+        """ pragmacomp_or_statement     : pppragma_directive statement
+                                        | statement
+        """
+        if isinstance(p[1], c_ast.Pragma) and len(p) == 3:
+            p[0] = c_ast.Compound(
+                block_items=[p[1], p[2]],
+                coord=self._token_coord(p, 1))
+        else:
+            p[0] = p[1]
+
+    # In C, declarations can come several in a line:
+    #   int x, *px, romulo = 5;
+    #
+    # However, for the AST, we will split them to separate Decl
+    # nodes.
+    #
+    # This rule splits its declarations and always returns a list
+    # of Decl nodes, even if it's one element long.
+    #
+    def p_decl_body(self, p):
+        """ decl_body : declaration_specifiers init_declarator_list_opt
+                      | declaration_specifiers_no_type id_init_declarator_list_opt
+        """
+        spec = p[1]
+
+        # p[2] (init_declarator_list_opt) is either a list or None
+        #
+        if p[2] is None:
+            # By the standard, you must have at least one declarator unless
+            # declaring a structure tag, a union tag, or the members of an
+            # enumeration.
+            #
+            ty = spec['type']
+            s_u_or_e = (c_ast.Struct, c_ast.Union, c_ast.Enum)
+            if len(ty) == 1 and isinstance(ty[0], s_u_or_e):
+                decls = [c_ast.Decl(
+                    name=None,
+                    quals=spec['qual'],
+                    align=spec['alignment'],
+                    storage=spec['storage'],
+                    funcspec=spec['function'],
+                    type=ty[0],
+                    init=None,
+                    bitsize=None,
+                    coord=ty[0].coord)]
+
+            # However, this case can also occur on redeclared identifiers in
+            # an inner scope.  The trouble is that the redeclared type's name
+            # gets grouped into declaration_specifiers; _build_declarations
+            # compensates for this.
+            #
+            else:
+                decls = self._build_declarations(
+                    spec=spec,
+                    decls=[dict(decl=None, init=None)],
+                    typedef_namespace=True)
+
+        else:
+            decls = self._build_declarations(
+                spec=spec,
+                decls=p[2],
+                typedef_namespace=True)
+
+        p[0] = decls
+
+    # The declaration has been split to a decl_body sub-rule and
+    # SEMI, because having them in a single rule created a problem
+    # for defining typedefs.
+    #
+    # If a typedef line was directly followed by a line using the
+    # type defined with the typedef, the type would not be
+    # recognized. This is because to reduce the declaration rule,
+    # the parser's lookahead asked for the token after SEMI, which
+    # was the type from the next line, and the lexer had no chance
+    # to see the updated type symbol table.
+    #
+    # Splitting solves this problem, because after seeing SEMI,
+    # the parser reduces decl_body, which actually adds the new
+    # type into the table to be seen by the lexer before the next
+    # line is reached.
+    def p_declaration(self, p):
+        """ declaration : decl_body SEMI
+        """
+        p[0] = p[1]
+
+    # Since each declaration is a list of declarations, this
+    # rule will combine all the declarations and return a single
+    # list
+    #
+    def p_declaration_list(self, p):
+        """ declaration_list    : declaration
+                                | declaration_list declaration
+        """
+        p[0] = p[1] if len(p) == 2 else p[1] + p[2]
+
+    # To know when declaration-specifiers end and declarators begin,
+    # we require declaration-specifiers to have at least one
+    # type-specifier, and disallow typedef-names after we've seen any
+    # type-specifier. These are both required by the spec.
+    #
+    def p_declaration_specifiers_no_type_1(self, p):
+        """ declaration_specifiers_no_type  : type_qualifier declaration_specifiers_no_type_opt
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'qual')
+
+    def p_declaration_specifiers_no_type_2(self, p):
+        """ declaration_specifiers_no_type  : storage_class_specifier declaration_specifiers_no_type_opt
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'storage')
+
+    def p_declaration_specifiers_no_type_3(self, p):
+        """ declaration_specifiers_no_type  : function_specifier declaration_specifiers_no_type_opt
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'function')
+
+    # Without this, `typedef _Atomic(T) U` will parse incorrectly because the
+    # _Atomic qualifier will match, instead of the specifier.
+    def p_declaration_specifiers_no_type_4(self, p):
+        """ declaration_specifiers_no_type  : atomic_specifier declaration_specifiers_no_type_opt
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'type')
+
+    def p_declaration_specifiers_no_type_5(self, p):
+        """ declaration_specifiers_no_type  : alignment_specifier declaration_specifiers_no_type_opt
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'alignment')
+
+    def p_declaration_specifiers_1(self, p):
+        """ declaration_specifiers  : declaration_specifiers type_qualifier
+        """
+        p[0] = self._add_declaration_specifier(p[1], p[2], 'qual', append=True)
+
+    def p_declaration_specifiers_2(self, p):
+        """ declaration_specifiers  : declaration_specifiers storage_class_specifier
+        """
+        p[0] = self._add_declaration_specifier(p[1], p[2], 'storage', append=True)
+
+    def p_declaration_specifiers_3(self, p):
+        """ declaration_specifiers  : declaration_specifiers function_specifier
+        """
+        p[0] = self._add_declaration_specifier(p[1], p[2], 'function', append=True)
+
+    def p_declaration_specifiers_4(self, p):
+        """ declaration_specifiers  : declaration_specifiers type_specifier_no_typeid
+        """
+        p[0] = self._add_declaration_specifier(p[1], p[2], 'type', append=True)
+
+    def p_declaration_specifiers_5(self, p):
+        """ declaration_specifiers  : type_specifier
+        """
+        p[0] = self._add_declaration_specifier(None, p[1], 'type')
+
+    def p_declaration_specifiers_6(self, p):
+        """ declaration_specifiers  : declaration_specifiers_no_type type_specifier
+        """
+        p[0] = self._add_declaration_specifier(p[1], p[2], 'type', append=True)
+
+    def p_declaration_specifiers_7(self, p):
+        """ declaration_specifiers  : declaration_specifiers alignment_specifier
+        """
+        p[0] = self._add_declaration_specifier(p[1], p[2], 'alignment', append=True)
+
+    def p_storage_class_specifier(self, p):
+        """ storage_class_specifier : AUTO
+                                    | REGISTER
+                                    | STATIC
+                                    | EXTERN
+                                    | TYPEDEF
+                                    | _THREAD_LOCAL
+        """
+        p[0] = p[1]
+
+    def p_function_specifier(self, p):
+        """ function_specifier  : INLINE
+                                | _NORETURN
+        """
+        p[0] = p[1]
+
+    def p_type_specifier_no_typeid(self, p):
+        """ type_specifier_no_typeid  : VOID
+                                      | _BOOL
+                                      | CHAR
+                                      | SHORT
+                                      | INT
+                                      | LONG
+                                      | FLOAT
+                                      | DOUBLE
+                                      | _COMPLEX
+                                      | SIGNED
+                                      | UNSIGNED
+                                      | __INT128
+        """
+        p[0] = c_ast.IdentifierType([p[1]], coord=self._token_coord(p, 1))
+
+    def p_type_specifier(self, p):
+        """ type_specifier  : typedef_name
+                            | enum_specifier
+                            | struct_or_union_specifier
+                            | type_specifier_no_typeid
+                            | atomic_specifier
+        """
+        p[0] = p[1]
+
+    # See section 6.7.2.4 of the C11 standard.
+    def p_atomic_specifier(self, p):
+        """ atomic_specifier  : _ATOMIC LPAREN type_name RPAREN
+        """
+        typ = p[3]
+        typ.quals.append('_Atomic')
+        p[0] = typ
+
+    def p_type_qualifier(self, p):
+        """ type_qualifier  : CONST
+                            | RESTRICT
+                            | VOLATILE
+                            | _ATOMIC
+        """
+        p[0] = p[1]
+
+    def p_init_declarator_list(self, p):
+        """ init_declarator_list    : init_declarator
+                                    | init_declarator_list COMMA init_declarator
+        """
+        p[0] = p[1] + [p[3]] if len(p) == 4 else [p[1]]
+
+    # Returns a {decl=<declarator> : init=<initializer>} dictionary
+    # If there's no initializer, uses None
+    #
+    def p_init_declarator(self, p):
+        """ init_declarator : declarator
+                            | declarator EQUALS initializer
+        """
+        p[0] = dict(decl=p[1], init=(p[3] if len(p) > 2 else None))
+
+    def p_id_init_declarator_list(self, p):
+        """ id_init_declarator_list    : id_init_declarator
+                                       | id_init_declarator_list COMMA init_declarator
+        """
+        p[0] = p[1] + [p[3]] if len(p) == 4 else [p[1]]
+
+    def p_id_init_declarator(self, p):
+        """ id_init_declarator : id_declarator
+                               | id_declarator EQUALS initializer
+        """
+        p[0] = dict(decl=p[1], init=(p[3] if len(p) > 2 else None))
+
+    # Require at least one type specifier in a specifier-qualifier-list
+    #
+    def p_specifier_qualifier_list_1(self, p):
+        """ specifier_qualifier_list    : specifier_qualifier_list type_specifier_no_typeid
+        """
+        p[0] = self._add_declaration_specifier(p[1], p[2], 'type', append=True)
+
+    def p_specifier_qualifier_list_2(self, p):
+        """ specifier_qualifier_list    : specifier_qualifier_list type_qualifier
+        """
+        p[0] = self._add_declaration_specifier(p[1], p[2], 'qual', append=True)
+
+    def p_specifier_qualifier_list_3(self, p):
+        """ specifier_qualifier_list  : type_specifier
+        """
+        p[0] = self._add_declaration_specifier(None, p[1], 'type')
+
+    def p_specifier_qualifier_list_4(self, p):
+        """ specifier_qualifier_list  : type_qualifier_list type_specifier
+        """
+        p[0] = dict(qual=p[1], alignment=[], storage=[], type=[p[2]], function=[])
+
+    def p_specifier_qualifier_list_5(self, p):
+        """ specifier_qualifier_list  : alignment_specifier
+        """
+        p[0] = dict(qual=[], alignment=[p[1]], storage=[], type=[], function=[])
+
+    def p_specifier_qualifier_list_6(self, p):
+        """ specifier_qualifier_list  : specifier_qualifier_list alignment_specifier
+        """
+        p[0] = self._add_declaration_specifier(p[1], p[2], 'alignment')
+
+    # TYPEID is allowed here (and in other struct/enum related tag names), because
+    # struct/enum tags reside in their own namespace and can be named the same as types
+    #
+    def p_struct_or_union_specifier_1(self, p):
+        """ struct_or_union_specifier   : struct_or_union ID
+                                        | struct_or_union TYPEID
+        """
+        klass = self._select_struct_union_class(p[1])
+        # None means no list of members
+        p[0] = klass(
+            name=p[2],
+            decls=None,
+            coord=self._token_coord(p, 2))
+
+    def p_struct_or_union_specifier_2(self, p):
+        """ struct_or_union_specifier : struct_or_union brace_open struct_declaration_list brace_close
+                                      | struct_or_union brace_open brace_close
+        """
+        klass = self._select_struct_union_class(p[1])
+        if len(p) == 4:
+            # Empty sequence means an empty list of members
+            p[0] = klass(
+                name=None,
+                decls=[],
+                coord=self._token_coord(p, 2))
+        else:
+            p[0] = klass(
+                name=None,
+                decls=p[3],
+                coord=self._token_coord(p, 2))
+
+
+    def p_struct_or_union_specifier_3(self, p):
+        """ struct_or_union_specifier   : struct_or_union ID brace_open struct_declaration_list brace_close
+                                        | struct_or_union ID brace_open brace_close
+                                        | struct_or_union TYPEID brace_open struct_declaration_list brace_close
+                                        | struct_or_union TYPEID brace_open brace_close
+        """
+        klass = self._select_struct_union_class(p[1])
+        if len(p) == 5:
+            # Empty sequence means an empty list of members
+            p[0] = klass(
+                name=p[2],
+                decls=[],
+                coord=self._token_coord(p, 2))
+        else:
+            p[0] = klass(
+                name=p[2],
+                decls=p[4],
+                coord=self._token_coord(p, 2))
+
+    def p_struct_or_union(self, p):
+        """ struct_or_union : STRUCT
+                            | UNION
+        """
+        p[0] = p[1]
+
+    # Combine all declarations into a single list
+    #
+    def p_struct_declaration_list(self, p):
+        """ struct_declaration_list     : struct_declaration
+                                        | struct_declaration_list struct_declaration
+        """
+        if len(p) == 2:
+            p[0] = p[1] or []
+        else:
+            p[0] = p[1] + (p[2] or [])
+
+    def p_struct_declaration_1(self, p):
+        """ struct_declaration : specifier_qualifier_list struct_declarator_list_opt SEMI
+        """
+        spec = p[1]
+        assert 'typedef' not in spec['storage']
+
+        if p[2] is not None:
+            decls = self._build_declarations(
+                spec=spec,
+                decls=p[2])
+
+        elif len(spec['type']) == 1:
+            # Anonymous struct/union, gcc extension, C1x feature.
+            # Although the standard only allows structs/unions here, I see no
+            # reason to disallow other types since some compilers have typedefs
+            # here, and pycparser isn't about rejecting all invalid code.
+            #
+            node = spec['type'][0]
+            if isinstance(node, c_ast.Node):
+                decl_type = node
+            else:
+                decl_type = c_ast.IdentifierType(node)
+
+            decls = self._build_declarations(
+                spec=spec,
+                decls=[dict(decl=decl_type)])
+
+        else:
+            # Structure/union members can have the same names as typedefs.
+            # The trouble is that the member's name gets grouped into
+            # specifier_qualifier_list; _build_declarations compensates.
+            #
+            decls = self._build_declarations(
+                spec=spec,
+                decls=[dict(decl=None, init=None)])
+
+        p[0] = decls
+
+    def p_struct_declaration_2(self, p):
+        """ struct_declaration : SEMI
+        """
+        p[0] = None
+
+    def p_struct_declaration_3(self, p):
+        """ struct_declaration : pppragma_directive
+        """
+        p[0] = [p[1]]
+
+    def p_struct_declarator_list(self, p):
+        """ struct_declarator_list  : struct_declarator
+                                    | struct_declarator_list COMMA struct_declarator
+        """
+        p[0] = p[1] + [p[3]] if len(p) == 4 else [p[1]]
+
+    # struct_declarator passes up a dict with the keys: decl (for
+    # the underlying declarator) and bitsize (for the bitsize)
+    #
+    def p_struct_declarator_1(self, p):
+        """ struct_declarator : declarator
+        """
+        p[0] = {'decl': p[1], 'bitsize': None}
+
+    def p_struct_declarator_2(self, p):
+        """ struct_declarator   : declarator COLON constant_expression
+                                | COLON constant_expression
+        """
+        if len(p) > 3:
+            p[0] = {'decl': p[1], 'bitsize': p[3]}
+        else:
+            p[0] = {'decl': c_ast.TypeDecl(None, None, None, None), 'bitsize': p[2]}
+
+    def p_enum_specifier_1(self, p):
+        """ enum_specifier  : ENUM ID
+                            | ENUM TYPEID
+        """
+        p[0] = c_ast.Enum(p[2], None, self._token_coord(p, 1))
+
+    def p_enum_specifier_2(self, p):
+        """ enum_specifier  : ENUM brace_open enumerator_list brace_close
+        """
+        p[0] = c_ast.Enum(None, p[3], self._token_coord(p, 1))
+
+    def p_enum_specifier_3(self, p):
+        """ enum_specifier  : ENUM ID brace_open enumerator_list brace_close
+                            | ENUM TYPEID brace_open enumerator_list brace_close
+        """
+        p[0] = c_ast.Enum(p[2], p[4], self._token_coord(p, 1))
+
+    def p_enumerator_list(self, p):
+        """ enumerator_list : enumerator
+                            | enumerator_list COMMA
+                            | enumerator_list COMMA enumerator
+        """
+        if len(p) == 2:
+            p[0] = c_ast.EnumeratorList([p[1]], p[1].coord)
+        elif len(p) == 3:
+            p[0] = p[1]
+        else:
+            p[1].enumerators.append(p[3])
+            p[0] = p[1]
+
+    def p_alignment_specifier(self, p):
+        """ alignment_specifier  : _ALIGNAS LPAREN type_name RPAREN
+                                 | _ALIGNAS LPAREN constant_expression RPAREN
+        """
+        p[0] = c_ast.Alignas(p[3], self._token_coord(p, 1))
+
+    def p_enumerator(self, p):
+        """ enumerator  : ID
+                        | ID EQUALS constant_expression
+        """
+        if len(p) == 2:
+            enumerator = c_ast.Enumerator(
+                        p[1], None,
+                        self._token_coord(p, 1))
+        else:
+            enumerator = c_ast.Enumerator(
+                        p[1], p[3],
+                        self._token_coord(p, 1))
+        self._add_identifier(enumerator.name, enumerator.coord)
+
+        p[0] = enumerator
+
+    def p_declarator(self, p):
+        """ declarator  : id_declarator
+                        | typeid_declarator
+        """
+        p[0] = p[1]
+
+    @parameterized(('id', 'ID'), ('typeid', 'TYPEID'), ('typeid_noparen', 'TYPEID'))
+    def p_xxx_declarator_1(self, p):
+        """ xxx_declarator  : direct_xxx_declarator
+        """
+        p[0] = p[1]
+
+    @parameterized(('id', 'ID'), ('typeid', 'TYPEID'), ('typeid_noparen', 'TYPEID'))
+    def p_xxx_declarator_2(self, p):
+        """ xxx_declarator  : pointer direct_xxx_declarator
+        """
+        p[0] = self._type_modify_decl(p[2], p[1])
+
+    @parameterized(('id', 'ID'), ('typeid', 'TYPEID'), ('typeid_noparen', 'TYPEID'))
+    def p_direct_xxx_declarator_1(self, p):
+        """ direct_xxx_declarator   : yyy
+        """
+        p[0] = c_ast.TypeDecl(
+            declname=p[1],
+            type=None,
+            quals=None,
+            align=None,
+            coord=self._token_coord(p, 1))
+
+    @parameterized(('id', 'ID'), ('typeid', 'TYPEID'))
+    def p_direct_xxx_declarator_2(self, p):
+        """ direct_xxx_declarator   : LPAREN xxx_declarator RPAREN
+        """
+        p[0] = p[2]
+
+    @parameterized(('id', 'ID'), ('typeid', 'TYPEID'), ('typeid_noparen', 'TYPEID'))
+    def p_direct_xxx_declarator_3(self, p):
+        """ direct_xxx_declarator   : direct_xxx_declarator LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET
+        """
+        quals = (p[3] if len(p) > 5 else []) or []
+        # Accept dimension qualifiers
+        # Per C99 6.7.5.3 p7
+        arr = c_ast.ArrayDecl(
+            type=None,
+            dim=p[4] if len(p) > 5 else p[3],
+            dim_quals=quals,
+            coord=p[1].coord)
+
+        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)
+
+    @parameterized(('id', 'ID'), ('typeid', 'TYPEID'), ('typeid_noparen', 'TYPEID'))
+    def p_direct_xxx_declarator_4(self, p):
+        """ direct_xxx_declarator   : direct_xxx_declarator LBRACKET STATIC type_qualifier_list_opt assignment_expression RBRACKET
+                                    | direct_xxx_declarator LBRACKET type_qualifier_list STATIC assignment_expression RBRACKET
+        """
+        # Using slice notation for PLY objects doesn't work in Python 3 for the
+        # version of PLY embedded with pycparser; see PLY Google Code issue 30.
+        # Work around that here by listing the two elements separately.
+        listed_quals = [item if isinstance(item, list) else [item]
+            for item in [p[3],p[4]]]
+        dim_quals = [qual for sublist in listed_quals for qual in sublist
+            if qual is not None]
+        arr = c_ast.ArrayDecl(
+            type=None,
+            dim=p[5],
+            dim_quals=dim_quals,
+            coord=p[1].coord)
+
+        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)
+
+    # Special for VLAs
+    #
+    @parameterized(('id', 'ID'), ('typeid', 'TYPEID'), ('typeid_noparen', 'TYPEID'))
+    def p_direct_xxx_declarator_5(self, p):
+        """ direct_xxx_declarator   : direct_xxx_declarator LBRACKET type_qualifier_list_opt TIMES RBRACKET
+        """
+        arr = c_ast.ArrayDecl(
+            type=None,
+            dim=c_ast.ID(p[4], self._token_coord(p, 4)),
+            dim_quals=p[3] if p[3] is not None else [],
+            coord=p[1].coord)
+
+        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)
+
+    @parameterized(('id', 'ID'), ('typeid', 'TYPEID'), ('typeid_noparen', 'TYPEID'))
+    def p_direct_xxx_declarator_6(self, p):
+        """ direct_xxx_declarator   : direct_xxx_declarator LPAREN parameter_type_list RPAREN
+                                    | direct_xxx_declarator LPAREN identifier_list_opt RPAREN
+        """
+        func = c_ast.FuncDecl(
+            args=p[3],
+            type=None,
+            coord=p[1].coord)
+
+        # To see why _get_yacc_lookahead_token is needed, consider:
+        #   typedef char TT;
+        #   void foo(int TT) { TT = 10; }
+        # Outside the function, TT is a typedef, but inside (starting and
+        # ending with the braces) it's a parameter.  The trouble begins with
+        # yacc's lookahead token.  We don't know if we're declaring or
+        # defining a function until we see LBRACE, but if we wait for yacc to
+        # trigger a rule on that token, then TT will have already been read
+        # and incorrectly interpreted as TYPEID.  We need to add the
+        # parameters to the scope the moment the lexer sees LBRACE.
+        #
+        if self._get_yacc_lookahead_token().type == "LBRACE":
+            if func.args is not None:
+                for param in func.args.params:
+                    if isinstance(param, c_ast.EllipsisParam): break
+                    self._add_identifier(param.name, param.coord)
+
+        p[0] = self._type_modify_decl(decl=p[1], modifier=func)
+
+    def p_pointer(self, p):
+        """ pointer : TIMES type_qualifier_list_opt
+                    | TIMES type_qualifier_list_opt pointer
+        """
+        coord = self._token_coord(p, 1)
+        # Pointer decls nest from inside out. This is important when different
+        # levels have different qualifiers. For example:
+        #
+        #  char * const * p;
+        #
+        # Means "pointer to const pointer to char"
+        #
+        # While:
+        #
+        #  char ** const p;
+        #
+        # Means "const pointer to pointer to char"
+        #
+        # So when we construct PtrDecl nestings, the leftmost pointer goes in
+        # as the most nested type.
+        nested_type = c_ast.PtrDecl(quals=p[2] or [], type=None, coord=coord)
+        if len(p) > 3:
+            tail_type = p[3]
+            while tail_type.type is not None:
+                tail_type = tail_type.type
+            tail_type.type = nested_type
+            p[0] = p[3]
+        else:
+            p[0] = nested_type
+
+    def p_type_qualifier_list(self, p):
+        """ type_qualifier_list : type_qualifier
+                                | type_qualifier_list type_qualifier
+        """
+        p[0] = [p[1]] if len(p) == 2 else p[1] + [p[2]]
+
+    def p_parameter_type_list(self, p):
+        """ parameter_type_list : parameter_list
+                                | parameter_list COMMA ELLIPSIS
+        """
+        if len(p) > 2:
+            p[1].params.append(c_ast.EllipsisParam(self._token_coord(p, 3)))
+
+        p[0] = p[1]
+
+    def p_parameter_list(self, p):
+        """ parameter_list  : parameter_declaration
+                            | parameter_list COMMA parameter_declaration
+        """
+        if len(p) == 2: # single parameter
+            p[0] = c_ast.ParamList([p[1]], p[1].coord)
+        else:
+            p[1].params.append(p[3])
+            p[0] = p[1]
+
+    # From ISO/IEC 9899:TC2, 6.7.5.3.11:
+    # "If, in a parameter declaration, an identifier can be treated either
+    #  as a typedef name or as a parameter name, it shall be taken as a
+    #  typedef name."
+    #
+    # Inside a parameter declaration, once we've reduced declaration specifiers,
+    # if we shift in an LPAREN and see a TYPEID, it could be either an abstract
+    # declarator or a declarator nested inside parens. This rule tells us to
+    # always treat it as an abstract declarator. Therefore, we only accept
+    # `id_declarator`s and `typeid_noparen_declarator`s.
+    def p_parameter_declaration_1(self, p):
+        """ parameter_declaration   : declaration_specifiers id_declarator
+                                    | declaration_specifiers typeid_noparen_declarator
+        """
+        spec = p[1]
+        if not spec['type']:
+            spec['type'] = [c_ast.IdentifierType(['int'],
+                coord=self._token_coord(p, 1))]
+        p[0] = self._build_declarations(
+            spec=spec,
+            decls=[dict(decl=p[2])])[0]
+
+    def p_parameter_declaration_2(self, p):
+        """ parameter_declaration   : declaration_specifiers abstract_declarator_opt
+        """
+        spec = p[1]
+        if not spec['type']:
+            spec['type'] = [c_ast.IdentifierType(['int'],
+                coord=self._token_coord(p, 1))]
+
+        # Parameters can have the same names as typedefs.  The trouble is that
+        # the parameter's name gets grouped into declaration_specifiers, making
+        # it look like an old-style declaration; compensate.
+        #
+        if len(spec['type']) > 1 and len(spec['type'][-1].names) == 1 and \
+                self._is_type_in_scope(spec['type'][-1].names[0]):
+            decl = self._build_declarations(
+                    spec=spec,
+                    decls=[dict(decl=p[2], init=None)])[0]
+
+        # This truly is an old-style parameter declaration
+        #
+        else:
+            decl = c_ast.Typename(
+                name='',
+                quals=spec['qual'],
+                align=None,
+                type=p[2] or c_ast.TypeDecl(None, None, None, None),
+                coord=self._token_coord(p, 2))
+            typename = spec['type']
+            decl = self._fix_decl_name_type(decl, typename)
+
+        p[0] = decl
+
+    def p_identifier_list(self, p):
+        """ identifier_list : identifier
+                            | identifier_list COMMA identifier
+        """
+        if len(p) == 2: # single parameter
+            p[0] = c_ast.ParamList([p[1]], p[1].coord)
+        else:
+            p[1].params.append(p[3])
+            p[0] = p[1]
+
+    def p_initializer_1(self, p):
+        """ initializer : assignment_expression
+        """
+        p[0] = p[1]
+
+    def p_initializer_2(self, p):
+        """ initializer : brace_open initializer_list_opt brace_close
+                        | brace_open initializer_list COMMA brace_close
+        """
+        if p[2] is None:
+            p[0] = c_ast.InitList([], self._token_coord(p, 1))
+        else:
+            p[0] = p[2]
+
+    def p_initializer_list(self, p):
+        """ initializer_list    : designation_opt initializer
+                                | initializer_list COMMA designation_opt initializer
+        """
+        if len(p) == 3: # single initializer
+            init = p[2] if p[1] is None else c_ast.NamedInitializer(p[1], p[2])
+            p[0] = c_ast.InitList([init], p[2].coord)
+        else:
+            init = p[4] if p[3] is None else c_ast.NamedInitializer(p[3], p[4])
+            p[1].exprs.append(init)
+            p[0] = p[1]
+
+    def p_designation(self, p):
+        """ designation : designator_list EQUALS
+        """
+        p[0] = p[1]
+
+    # Designators are represented as a list of nodes, in the order in which
+    # they're written in the code.
+    #
+    def p_designator_list(self, p):
+        """ designator_list : designator
+                            | designator_list designator
+        """
+        p[0] = [p[1]] if len(p) == 2 else p[1] + [p[2]]
+
+    def p_designator(self, p):
+        """ designator  : LBRACKET constant_expression RBRACKET
+                        | PERIOD identifier
+        """
+        p[0] = p[2]
+
+    def p_type_name(self, p):
+        """ type_name   : specifier_qualifier_list abstract_declarator_opt
+        """
+        typename = c_ast.Typename(
+            name='',
+            quals=p[1]['qual'][:],
+            align=None,
+            type=p[2] or c_ast.TypeDecl(None, None, None, None),
+            coord=self._token_coord(p, 2))
+
+        p[0] = self._fix_decl_name_type(typename, p[1]['type'])
+
+    def p_abstract_declarator_1(self, p):
+        """ abstract_declarator     : pointer
+        """
+        dummytype = c_ast.TypeDecl(None, None, None, None)
+        p[0] = self._type_modify_decl(
+            decl=dummytype,
+            modifier=p[1])
+
+    def p_abstract_declarator_2(self, p):
+        """ abstract_declarator     : pointer direct_abstract_declarator
+        """
+        p[0] = self._type_modify_decl(p[2], p[1])
+
+    def p_abstract_declarator_3(self, p):
+        """ abstract_declarator     : direct_abstract_declarator
+        """
+        p[0] = p[1]
+
+    # Creating and using direct_abstract_declarator_opt here
+    # instead of listing both direct_abstract_declarator and the
+    # lack of it in the beginning of _1 and _2 caused two
+    # shift/reduce errors.
+    #
+    def p_direct_abstract_declarator_1(self, p):
+        """ direct_abstract_declarator  : LPAREN abstract_declarator RPAREN """
+        p[0] = p[2]
+
+    def p_direct_abstract_declarator_2(self, p):
+        """ direct_abstract_declarator  : direct_abstract_declarator LBRACKET assignment_expression_opt RBRACKET
+        """
+        arr = c_ast.ArrayDecl(
+            type=None,
+            dim=p[3],
+            dim_quals=[],
+            coord=p[1].coord)
+
+        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)
+
+    def p_direct_abstract_declarator_3(self, p):
+        """ direct_abstract_declarator  : LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET
+        """
+        quals = (p[2] if len(p) > 4 else []) or []
+        p[0] = c_ast.ArrayDecl(
+            type=c_ast.TypeDecl(None, None, None, None),
+            dim=p[3] if len(p) > 4 else p[2],
+            dim_quals=quals,
+            coord=self._token_coord(p, 1))
+
+    def p_direct_abstract_declarator_4(self, p):
+        """ direct_abstract_declarator  : direct_abstract_declarator LBRACKET TIMES RBRACKET
+        """
+        arr = c_ast.ArrayDecl(
+            type=None,
+            dim=c_ast.ID(p[3], self._token_coord(p, 3)),
+            dim_quals=[],
+            coord=p[1].coord)
+
+        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)
+
+    def p_direct_abstract_declarator_5(self, p):
+        """ direct_abstract_declarator  : LBRACKET TIMES RBRACKET
+        """
+        p[0] = c_ast.ArrayDecl(
+            type=c_ast.TypeDecl(None, None, None, None),
+            dim=c_ast.ID(p[3], self._token_coord(p, 3)),
+            dim_quals=[],
+            coord=self._token_coord(p, 1))
+
+    def p_direct_abstract_declarator_6(self, p):
+        """ direct_abstract_declarator  : direct_abstract_declarator LPAREN parameter_type_list_opt RPAREN
+        """
+        func = c_ast.FuncDecl(
+            args=p[3],
+            type=None,
+            coord=p[1].coord)
+
+        p[0] = self._type_modify_decl(decl=p[1], modifier=func)
+
+    def p_direct_abstract_declarator_7(self, p):
+        """ direct_abstract_declarator  : LPAREN parameter_type_list_opt RPAREN
+        """
+        p[0] = c_ast.FuncDecl(
+            args=p[2],
+            type=c_ast.TypeDecl(None, None, None, None),
+            coord=self._token_coord(p, 1))
+
+    # declaration is a list, statement isn't. To make it consistent, block_item
+    # will always be a list
+    #
+    def p_block_item(self, p):
+        """ block_item  : declaration
+                        | statement
+        """
+        p[0] = p[1] if isinstance(p[1], list) else [p[1]]
+
+    # Since we made block_item a list, this just combines lists
+    #
+    def p_block_item_list(self, p):
+        """ block_item_list : block_item
+                            | block_item_list block_item
+        """
+        # Empty block items (plain ';') produce [None], so ignore them
+        p[0] = p[1] if (len(p) == 2 or p[2] == [None]) else p[1] + p[2]
+
+    def p_compound_statement_1(self, p):
+        """ compound_statement : brace_open block_item_list_opt brace_close """
+        p[0] = c_ast.Compound(
+            block_items=p[2],
+            coord=self._token_coord(p, 1))
+
+    def p_labeled_statement_1(self, p):
+        """ labeled_statement : ID COLON pragmacomp_or_statement """
+        p[0] = c_ast.Label(p[1], p[3], self._token_coord(p, 1))
+
+    def p_labeled_statement_2(self, p):
+        """ labeled_statement : CASE constant_expression COLON pragmacomp_or_statement """
+        p[0] = c_ast.Case(p[2], [p[4]], self._token_coord(p, 1))
+
+    def p_labeled_statement_3(self, p):
+        """ labeled_statement : DEFAULT COLON pragmacomp_or_statement """
+        p[0] = c_ast.Default([p[3]], self._token_coord(p, 1))
+
+    def p_selection_statement_1(self, p):
+        """ selection_statement : IF LPAREN expression RPAREN pragmacomp_or_statement """
+        p[0] = c_ast.If(p[3], p[5], None, self._token_coord(p, 1))
+
+    def p_selection_statement_2(self, p):
+        """ selection_statement : IF LPAREN expression RPAREN statement ELSE pragmacomp_or_statement """
+        p[0] = c_ast.If(p[3], p[5], p[7], self._token_coord(p, 1))
+
+    def p_selection_statement_3(self, p):
+        """ selection_statement : SWITCH LPAREN expression RPAREN pragmacomp_or_statement """
+        p[0] = fix_switch_cases(
+                c_ast.Switch(p[3], p[5], self._token_coord(p, 1)))
+
+    def p_iteration_statement_1(self, p):
+        """ iteration_statement : WHILE LPAREN expression RPAREN pragmacomp_or_statement """
+        p[0] = c_ast.While(p[3], p[5], self._token_coord(p, 1))
+
+    def p_iteration_statement_2(self, p):
+        """ iteration_statement : DO pragmacomp_or_statement WHILE LPAREN expression RPAREN SEMI """
+        p[0] = c_ast.DoWhile(p[5], p[2], self._token_coord(p, 1))
+
+    def p_iteration_statement_3(self, p):
+        """ iteration_statement : FOR LPAREN expression_opt SEMI expression_opt SEMI expression_opt RPAREN pragmacomp_or_statement """
+        p[0] = c_ast.For(p[3], p[5], p[7], p[9], self._token_coord(p, 1))
+
+    def p_iteration_statement_4(self, p):
+        """ iteration_statement : FOR LPAREN declaration expression_opt SEMI expression_opt RPAREN pragmacomp_or_statement """
+        p[0] = c_ast.For(c_ast.DeclList(p[3], self._token_coord(p, 1)),
+                         p[4], p[6], p[8], self._token_coord(p, 1))
+
+    def p_jump_statement_1(self, p):
+        """ jump_statement  : GOTO ID SEMI """
+        p[0] = c_ast.Goto(p[2], self._token_coord(p, 1))
+
+    def p_jump_statement_2(self, p):
+        """ jump_statement  : BREAK SEMI """
+        p[0] = c_ast.Break(self._token_coord(p, 1))
+
+    def p_jump_statement_3(self, p):
+        """ jump_statement  : CONTINUE SEMI """
+        p[0] = c_ast.Continue(self._token_coord(p, 1))
+
+    def p_jump_statement_4(self, p):
+        """ jump_statement  : RETURN expression SEMI
+                            | RETURN SEMI
+        """
+        p[0] = c_ast.Return(p[2] if len(p) == 4 else None, self._token_coord(p, 1))
+
+    def p_expression_statement(self, p):
+        """ expression_statement : expression_opt SEMI """
+        if p[1] is None:
+            p[0] = c_ast.EmptyStatement(self._token_coord(p, 2))
+        else:
+            p[0] = p[1]
+
+    def p_expression(self, p):
+        """ expression  : assignment_expression
+                        | expression COMMA assignment_expression
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            if not isinstance(p[1], c_ast.ExprList):
+                p[1] = c_ast.ExprList([p[1]], p[1].coord)
+
+            p[1].exprs.append(p[3])
+            p[0] = p[1]
+
+    def p_parenthesized_compound_expression(self, p):
+        """ assignment_expression : LPAREN compound_statement RPAREN """
+        p[0] = p[2]
+
+    def p_typedef_name(self, p):
+        """ typedef_name : TYPEID """
+        p[0] = c_ast.IdentifierType([p[1]], coord=self._token_coord(p, 1))
+
+    def p_assignment_expression(self, p):
+        """ assignment_expression   : conditional_expression
+                                    | unary_expression assignment_operator assignment_expression
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            p[0] = c_ast.Assignment(p[2], p[1], p[3], p[1].coord)
+
+    # K&R2 defines these as many separate rules, to encode
+    # precedence and associativity. Why work hard ? I'll just use
+    # the built in precedence/associativity specification feature
+    # of PLY. (see precedence declaration above)
+    #
+    def p_assignment_operator(self, p):
+        """ assignment_operator : EQUALS
+                                | XOREQUAL
+                                | TIMESEQUAL
+                                | DIVEQUAL
+                                | MODEQUAL
+                                | PLUSEQUAL
+                                | MINUSEQUAL
+                                | LSHIFTEQUAL
+                                | RSHIFTEQUAL
+                                | ANDEQUAL
+                                | OREQUAL
+        """
+        p[0] = p[1]
+
+    def p_constant_expression(self, p):
+        """ constant_expression : conditional_expression """
+        p[0] = p[1]
+
+    def p_conditional_expression(self, p):
+        """ conditional_expression  : binary_expression
+                                    | binary_expression CONDOP expression COLON conditional_expression
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            p[0] = c_ast.TernaryOp(p[1], p[3], p[5], p[1].coord)
+
+    def p_binary_expression(self, p):
+        """ binary_expression   : cast_expression
+                                | binary_expression TIMES binary_expression
+                                | binary_expression DIVIDE binary_expression
+                                | binary_expression MOD binary_expression
+                                | binary_expression PLUS binary_expression
+                                | binary_expression MINUS binary_expression
+                                | binary_expression RSHIFT binary_expression
+                                | binary_expression LSHIFT binary_expression
+                                | binary_expression LT binary_expression
+                                | binary_expression LE binary_expression
+                                | binary_expression GE binary_expression
+                                | binary_expression GT binary_expression
+                                | binary_expression EQ binary_expression
+                                | binary_expression NE binary_expression
+                                | binary_expression AND binary_expression
+                                | binary_expression OR binary_expression
+                                | binary_expression XOR binary_expression
+                                | binary_expression LAND binary_expression
+                                | binary_expression LOR binary_expression
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            p[0] = c_ast.BinaryOp(p[2], p[1], p[3], p[1].coord)
+
+    def p_cast_expression_1(self, p):
+        """ cast_expression : unary_expression """
+        p[0] = p[1]
+
+    def p_cast_expression_2(self, p):
+        """ cast_expression : LPAREN type_name RPAREN cast_expression """
+        p[0] = c_ast.Cast(p[2], p[4], self._token_coord(p, 1))
+
+    def p_unary_expression_1(self, p):
+        """ unary_expression    : postfix_expression """
+        p[0] = p[1]
+
+    def p_unary_expression_2(self, p):
+        """ unary_expression    : PLUSPLUS unary_expression
+                                | MINUSMINUS unary_expression
+                                | unary_operator cast_expression
+        """
+        p[0] = c_ast.UnaryOp(p[1], p[2], p[2].coord)
+
+    def p_unary_expression_3(self, p):
+        """ unary_expression    : SIZEOF unary_expression
+                                | SIZEOF LPAREN type_name RPAREN
+                                | _ALIGNOF LPAREN type_name RPAREN
+        """
+        p[0] = c_ast.UnaryOp(
+            p[1],
+            p[2] if len(p) == 3 else p[3],
+            self._token_coord(p, 1))
+
+    def p_unary_operator(self, p):
+        """ unary_operator  : AND
+                            | TIMES
+                            | PLUS
+                            | MINUS
+                            | NOT
+                            | LNOT
+        """
+        p[0] = p[1]
+
+    def p_postfix_expression_1(self, p):
+        """ postfix_expression  : primary_expression """
+        p[0] = p[1]
+
+    def p_postfix_expression_2(self, p):
+        """ postfix_expression  : postfix_expression LBRACKET expression RBRACKET """
+        p[0] = c_ast.ArrayRef(p[1], p[3], p[1].coord)
+
+    def p_postfix_expression_3(self, p):
+        """ postfix_expression  : postfix_expression LPAREN argument_expression_list RPAREN
+                                | postfix_expression LPAREN RPAREN
+        """
+        p[0] = c_ast.FuncCall(p[1], p[3] if len(p) == 5 else None, p[1].coord)
+
+    def p_postfix_expression_4(self, p):
+        """ postfix_expression  : postfix_expression PERIOD ID
+                                | postfix_expression PERIOD TYPEID
+                                | postfix_expression ARROW ID
+                                | postfix_expression ARROW TYPEID
+        """
+        field = c_ast.ID(p[3], self._token_coord(p, 3))
+        p[0] = c_ast.StructRef(p[1], p[2], field, p[1].coord)
+
+    def p_postfix_expression_5(self, p):
+        """ postfix_expression  : postfix_expression PLUSPLUS
+                                | postfix_expression MINUSMINUS
+        """
+        p[0] = c_ast.UnaryOp('p' + p[2], p[1], p[1].coord)
+
+    def p_postfix_expression_6(self, p):
+        """ postfix_expression  : LPAREN type_name RPAREN brace_open initializer_list brace_close
+                                | LPAREN type_name RPAREN brace_open initializer_list COMMA brace_close
+        """
+        p[0] = c_ast.CompoundLiteral(p[2], p[5])
+
+    def p_primary_expression_1(self, p):
+        """ primary_expression  : identifier """
+        p[0] = p[1]
+
+    def p_primary_expression_2(self, p):
+        """ primary_expression  : constant """
+        p[0] = p[1]
+
+    def p_primary_expression_3(self, p):
+        """ primary_expression  : unified_string_literal
+                                | unified_wstring_literal
+        """
+        p[0] = p[1]
+
+    def p_primary_expression_4(self, p):
+        """ primary_expression  : LPAREN expression RPAREN """
+        p[0] = p[2]
+
+    def p_primary_expression_5(self, p):
+        """ primary_expression  : OFFSETOF LPAREN type_name COMMA offsetof_member_designator RPAREN
+        """
+        coord = self._token_coord(p, 1)
+        p[0] = c_ast.FuncCall(c_ast.ID(p[1], coord),
+                              c_ast.ExprList([p[3], p[5]], coord),
+                              coord)
+
+    def p_offsetof_member_designator(self, p):
+        """ offsetof_member_designator : identifier
+                                         | offsetof_member_designator PERIOD identifier
+                                         | offsetof_member_designator LBRACKET expression RBRACKET
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        elif len(p) == 4:
+            p[0] = c_ast.StructRef(p[1], p[2], p[3], p[1].coord)
+        elif len(p) == 5:
+            p[0] = c_ast.ArrayRef(p[1], p[3], p[1].coord)
+        else:
+            raise NotImplementedError("Unexpected parsing state. len(p): %u" % len(p))
+
+    def p_argument_expression_list(self, p):
+        """ argument_expression_list    : assignment_expression
+                                        | argument_expression_list COMMA assignment_expression
+        """
+        if len(p) == 2: # single expr
+            p[0] = c_ast.ExprList([p[1]], p[1].coord)
+        else:
+            p[1].exprs.append(p[3])
+            p[0] = p[1]
+
+    def p_identifier(self, p):
+        """ identifier  : ID """
+        p[0] = c_ast.ID(p[1], self._token_coord(p, 1))
+
+    def p_constant_1(self, p):
+        """ constant    : INT_CONST_DEC
+                        | INT_CONST_OCT
+                        | INT_CONST_HEX
+                        | INT_CONST_BIN
+                        | INT_CONST_CHAR
+        """
+        uCount = 0
+        lCount = 0
+        for x in p[1][-3:]:
+            if x in ('l', 'L'):
+                lCount += 1
+            elif x in ('u', 'U'):
+                uCount += 1
+        t = ''
+        if uCount > 1:
+             raise ValueError('Constant cannot have more than one u/U suffix.')
+        elif lCount > 2:
+             raise ValueError('Constant cannot have more than two l/L suffix.')
+        prefix = 'unsigned ' * uCount + 'long ' * lCount
+        p[0] = c_ast.Constant(
+            prefix + 'int', p[1], self._token_coord(p, 1))
+
+    def p_constant_2(self, p):
+        """ constant    : FLOAT_CONST
+                        | HEX_FLOAT_CONST
+        """
+        if 'x' in p[1].lower():
+            t = 'float'
+        else:
+            if p[1][-1] in ('f', 'F'):
+                t = 'float'
+            elif p[1][-1] in ('l', 'L'):
+                t = 'long double'
+            else:
+                t = 'double'
+
+        p[0] = c_ast.Constant(
+            t, p[1], self._token_coord(p, 1))
+
+    def p_constant_3(self, p):
+        """ constant    : CHAR_CONST
+                        | WCHAR_CONST
+                        | U8CHAR_CONST
+                        | U16CHAR_CONST
+                        | U32CHAR_CONST
+        """
+        p[0] = c_ast.Constant(
+            'char', p[1], self._token_coord(p, 1))
+
+    # The "unified" string and wstring literal rules are for supporting
+    # concatenation of adjacent string literals.
+    # I.e. "hello " "world" is seen by the C compiler as a single string literal
+    # with the value "hello world"
+    #
+    def p_unified_string_literal(self, p):
+        """ unified_string_literal  : STRING_LITERAL
+                                    | unified_string_literal STRING_LITERAL
+        """
+        if len(p) == 2: # single literal
+            p[0] = c_ast.Constant(
+                'string', p[1], self._token_coord(p, 1))
+        else:
+            p[1].value = p[1].value[:-1] + p[2][1:]
+            p[0] = p[1]
+
+    def p_unified_wstring_literal(self, p):
+        """ unified_wstring_literal : WSTRING_LITERAL
+                                    | U8STRING_LITERAL
+                                    | U16STRING_LITERAL
+                                    | U32STRING_LITERAL
+                                    | unified_wstring_literal WSTRING_LITERAL
+                                    | unified_wstring_literal U8STRING_LITERAL
+                                    | unified_wstring_literal U16STRING_LITERAL
+                                    | unified_wstring_literal U32STRING_LITERAL
+        """
+        if len(p) == 2: # single literal
+            p[0] = c_ast.Constant(
+                'string', p[1], self._token_coord(p, 1))
+        else:
+            p[1].value = p[1].value.rstrip()[:-1] + p[2][2:]
+            p[0] = p[1]
+
+    def p_brace_open(self, p):
+        """ brace_open  :   LBRACE
+        """
+        p[0] = p[1]
+        p.set_lineno(0, p.lineno(1))
+
+    def p_brace_close(self, p):
+        """ brace_close :   RBRACE
+        """
+        p[0] = p[1]
+        p.set_lineno(0, p.lineno(1))
+
+    def p_empty(self, p):
+        'empty : '
+        p[0] = None
+
+    def p_error(self, p):
+        # If error recovery is added here in the future, make sure
+        # _get_yacc_lookahead_token still works!
+        #
+        if p:
+            self._parse_error(
+                'before: %s' % p.value,
+                self._coord(lineno=p.lineno,
+                            column=self.clex.find_tok_column(p)))
+        else:
+            self._parse_error('At end of input', self.clex.filename)
diff --git a/myenv/lib/python3.9/site-packages/pycparser/lextab.py b/myenv/lib/python3.9/site-packages/pycparser/lextab.py
new file mode 100644
index 0000000..444b465
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/lextab.py
@@ -0,0 +1,10 @@
+# lextab.py. This file automatically created by PLY (version 3.10). Don't edit!
+_tabversion   = '3.10'
+_lextokens    = set(('INT_CONST_CHAR', 'VOID', 'LBRACKET', 'WCHAR_CONST', 'FLOAT_CONST', 'MINUS', 'RPAREN', 'STRUCT', 'LONG', 'PLUS', 'ELLIPSIS', 'U32STRING_LITERAL', 'GT', 'GOTO', 'ENUM', 'PERIOD', 'GE', 'INT_CONST_DEC', 'ARROW', '_STATIC_ASSERT', '__INT128', 'HEX_FLOAT_CONST', 'DOUBLE', 'MINUSEQUAL', 'INT_CONST_OCT', 'TIMESEQUAL', 'OR', 'SHORT', 'RETURN', 'RSHIFTEQUAL', '_ALIGNAS', 'RESTRICT', 'STATIC', 'SIZEOF', 'UNSIGNED', 'PLUSPLUS', 'COLON', 'WSTRING_LITERAL', 'DIVIDE', 'FOR', 'UNION', 'EQUALS', 'ELSE', 'ANDEQUAL', 'EQ', 'AND', 'TYPEID', 'LBRACE', 'PPHASH', 'INT', 'SIGNED', 'CONTINUE', 'NOT', 'OREQUAL', 'MOD', 'RSHIFT', 'DEFAULT', '_NORETURN', 'CHAR', 'WHILE', 'DIVEQUAL', '_ALIGNOF', 'EXTERN', 'LNOT', 'CASE', 'LAND', 'REGISTER', 'MODEQUAL', 'NE', 'SWITCH', 'INT_CONST_HEX', '_COMPLEX', 'PPPRAGMASTR', 'PLUSEQUAL', 'U32CHAR_CONST', 'CONDOP', 'U8STRING_LITERAL', 'BREAK', 'VOLATILE', 'PPPRAGMA', 'INLINE', 'INT_CONST_BIN', 'DO', 'U8CHAR_CONST', 'CONST', 'U16STRING_LITERAL', 'LOR', 'CHAR_CONST', 'LSHIFT', 'RBRACE', '_BOOL', 'LE', 'SEMI', '_THREAD_LOCAL', 'LT', 'COMMA', 'U16CHAR_CONST', 'OFFSETOF', '_ATOMIC', 'TYPEDEF', 'XOR', 'AUTO', 'TIMES', 'LPAREN', 'MINUSMINUS', 'ID', 'IF', 'STRING_LITERAL', 'FLOAT', 'XOREQUAL', 'LSHIFTEQUAL', 'RBRACKET'))
+_lexreflags   = 64
+_lexliterals  = ''
+_lexstateinfo = {'ppline': 'exclusive', 'pppragma': 'exclusive', 'INITIAL': 'inclusive'}
+_lexstatere   = {'ppline': [('(?P<t_ppline_FILENAME>"([^"\\\\\\n]|(\\\\[0-9a-zA-Z._~!=&\\^\\-\\\\?\'"]))*")|(?P<t_ppline_LINE_NUMBER>(0(([uU]ll)|([uU]LL)|(ll[uU]?)|(LL[uU]?)|([uU][lL])|([lL][uU]?)|[uU])?)|([1-9][0-9]*(([uU]ll)|([uU]LL)|(ll[uU]?)|(LL[uU]?)|([uU][lL])|([lL][uU]?)|[uU])?))|(?P<t_ppline_NEWLINE>\\n)|(?P<t_ppline_PPLINE>line)', [None, ('t_ppline_FILENAME', 'FILENAME'), None, None, ('t_ppline_LINE_NUMBER', 'LINE_NUMBER'), None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, ('t_ppline_NEWLINE', 'NEWLINE'), ('t_ppline_PPLINE', 'PPLINE')])], 'pppragma': [('(?P<t_pppragma_NEWLINE>\\n)|(?P<t_pppragma_PPPRAGMA>pragma)|(?P<t_pppragma_STR>.+)', [None, ('t_pppragma_NEWLINE', 'NEWLINE'), ('t_pppragma_PPPRAGMA', 'PPPRAGMA'), ('t_pppragma_STR', 'STR')])], 'INITIAL': [('(?P<t_PPHASH>[ \\t]*\\#)|(?P<t_NEWLINE>\\n+)|(?P<t_LBRACE>\\{)|(?P<t_RBRACE>\\})|(?P<t_FLOAT_CONST>((((([0-9]*\\.[0-9]+)|([0-9]+\\.))([eE][-+]?[0-9]+)?)|([0-9]+([eE][-+]?[0-9]+)))[FfLl]?))|(?P<t_HEX_FLOAT_CONST>(0[xX]([0-9a-fA-F]+|((([0-9a-fA-F]+)?\\.[0-9a-fA-F]+)|([0-9a-fA-F]+\\.)))([pP][+-]?[0-9]+)[FfLl]?))|(?P<t_INT_CONST_HEX>0[xX][0-9a-fA-F]+(([uU]ll)|([uU]LL)|(ll[uU]?)|(LL[uU]?)|([uU][lL])|([lL][uU]?)|[uU])?)|(?P<t_INT_CONST_BIN>0[bB][01]+(([uU]ll)|([uU]LL)|(ll[uU]?)|(LL[uU]?)|([uU][lL])|([lL][uU]?)|[uU])?)', [None, ('t_PPHASH', 'PPHASH'), ('t_NEWLINE', 'NEWLINE'), ('t_LBRACE', 'LBRACE'), ('t_RBRACE', 'RBRACE'), ('t_FLOAT_CONST', 'FLOAT_CONST'), None, None, None, None, None, None, None, None, None, ('t_HEX_FLOAT_CONST', 'HEX_FLOAT_CONST'), None, None, None, None, None, None, None, ('t_INT_CONST_HEX', 'INT_CONST_HEX'), None, None, None, None, None, None, None, ('t_INT_CONST_BIN', 'INT_CONST_BIN')]), ('(?P<t_BAD_CONST_OCT>0[0-7]*[89])|(?P<t_INT_CONST_OCT>0[0-7]*(([uU]ll)|([uU]LL)|(ll[uU]?)|(LL[uU]?)|([uU][lL])|([lL][uU]?)|[uU])?)|(?P<t_INT_CONST_DEC>(0(([uU]ll)|([uU]LL)|(ll[uU]?)|(LL[uU]?)|([uU][lL])|([lL][uU]?)|[uU])?)|([1-9][0-9]*(([uU]ll)|([uU]LL)|(ll[uU]?)|(LL[uU]?)|([uU][lL])|([lL][uU]?)|[uU])?))|(?P<t_INT_CONST_CHAR>\'([^\'\\\\\\n]|(\\\\(([a-wyzA-Z._~!=&\\^\\-\\\\?\'"]|x(?![0-9a-fA-F]))|(\\d+)(?!\\d)|(x[0-9a-fA-F]+)(?![0-9a-fA-F])))){2,4}\')|(?P<t_CHAR_CONST>\'([^\'\\\\\\n]|(\\\\(([a-wyzA-Z._~!=&\\^\\-\\\\?\'"]|x(?![0-9a-fA-F]))|(\\d+)(?!\\d)|(x[0-9a-fA-F]+)(?![0-9a-fA-F]))))\')|(?P<t_WCHAR_CONST>L\'([^\'\\\\\\n]|(\\\\(([a-wyzA-Z._~!=&\\^\\-\\\\?\'"]|x(?![0-9a-fA-F]))|(\\d+)(?!\\d)|(x[0-9a-fA-F]+)(?![0-9a-fA-F]))))\')|(?P<t_U8CHAR_CONST>u8\'([^\'\\\\\\n]|(\\\\(([a-wyzA-Z._~!=&\\^\\-\\\\?\'"]|x(?![0-9a-fA-F]))|(\\d+)(?!\\d)|(x[0-9a-fA-F]+)(?![0-9a-fA-F]))))\')|(?P<t_U16CHAR_CONST>u\'([^\'\\\\\\n]|(\\\\(([a-wyzA-Z._~!=&\\^\\-\\\\?\'"]|x(?![0-9a-fA-F]))|(\\d+)(?!\\d)|(x[0-9a-fA-F]+)(?![0-9a-fA-F]))))\')|(?P<t_U32CHAR_CONST>U\'([^\'\\\\\\n]|(\\\\(([a-wyzA-Z._~!=&\\^\\-\\\\?\'"]|x(?![0-9a-fA-F]))|(\\d+)(?!\\d)|(x[0-9a-fA-F]+)(?![0-9a-fA-F]))))\')', [None, ('t_BAD_CONST_OCT', 'BAD_CONST_OCT'), ('t_INT_CONST_OCT', 'INT_CONST_OCT'), None, None, None, None, None, None, None, ('t_INT_CONST_DEC', 'INT_CONST_DEC'), None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, ('t_INT_CONST_CHAR', 'INT_CONST_CHAR'), None, None, None, None, None, None, ('t_CHAR_CONST', 'CHAR_CONST'), None, None, None, None, None, None, ('t_WCHAR_CONST', 'WCHAR_CONST'), None, None, None, None, None, None, ('t_U8CHAR_CONST', 'U8CHAR_CONST'), None, None, None, None, None, None, ('t_U16CHAR_CONST', 'U16CHAR_CONST'), None, None, None, None, None, None, ('t_U32CHAR_CONST', 'U32CHAR_CONST')]), ('(?P<t_UNMATCHED_QUOTE>(\'([^\'\\\\\\n]|(\\\\(([a-wyzA-Z._~!=&\\^\\-\\\\?\'"]|x(?![0-9a-fA-F]))|(\\d+)(?!\\d)|(x[0-9a-fA-F]+)(?![0-9a-fA-F]))))*\\n)|(\'([^\'\\\\\\n]|(\\\\(([a-wyzA-Z._~!=&\\^\\-\\\\?\'"]|x(?![0-9a-fA-F]))|(\\d+)(?!\\d)|(x[0-9a-fA-F]+)(?![0-9a-fA-F]))))*$))|(?P<t_BAD_CHAR_CONST>(\'([^\'\\\\\\n]|(\\\\(([a-wyzA-Z._~!=&\\^\\-\\\\?\'"]|x(?![0-9a-fA-F]))|(\\d+)(?!\\d)|(x[0-9a-fA-F]+)(?![0-9a-fA-F]))))[^\'\n]+\')|(\'\')|(\'([\\\\][^a-zA-Z._~^!=&\\^\\-\\\\?\'"x0-9])[^\'\\n]*\'))|(?P<t_WSTRING_LITERAL>L"([^"\\\\\\n]|(\\\\[0-9a-zA-Z._~!=&\\^\\-\\\\?\'"]))*")|(?P<t_U8STRING_LITERAL>u8"([^"\\\\\\n]|(\\\\[0-9a-zA-Z._~!=&\\^\\-\\\\?\'"]))*")|(?P<t_U16STRING_LITERAL>u"([^"\\\\\\n]|(\\\\[0-9a-zA-Z._~!=&\\^\\-\\\\?\'"]))*")|(?P<t_U32STRING_LITERAL>U"([^"\\\\\\n]|(\\\\[0-9a-zA-Z._~!=&\\^\\-\\\\?\'"]))*")|(?P<t_BAD_STRING_LITERAL>"([^"\\\\\\n]|(\\\\[0-9a-zA-Z._~!=&\\^\\-\\\\?\'"]))*([\\\\][^a-zA-Z._~^!=&\\^\\-\\\\?\'"x0-9])([^"\\\\\\n]|(\\\\[0-9a-zA-Z._~!=&\\^\\-\\\\?\'"]))*")|(?P<t_ID>[a-zA-Z_$][0-9a-zA-Z_$]*)|(?P<t_STRING_LITERAL>"([^"\\\\\\n]|(\\\\[0-9a-zA-Z._~!=&\\^\\-\\\\?\'"]))*")|(?P<t_ELLIPSIS>\\.\\.\\.)|(?P<t_PLUSPLUS>\\+\\+)|(?P<t_LOR>\\|\\|)|(?P<t_XOREQUAL>\\^=)|(?P<t_OREQUAL>\\|=)|(?P<t_LSHIFTEQUAL><<=)|(?P<t_RSHIFTEQUAL>>>=)|(?P<t_PLUSEQUAL>\\+=)|(?P<t_TIMESEQUAL>\\*=)', [None, ('t_UNMATCHED_QUOTE', 'UNMATCHED_QUOTE'), None, None, None, None, None, None, None, None, None, None, None, None, None, None, ('t_BAD_CHAR_CONST', 'BAD_CHAR_CONST'), None, None, None, None, None, None, None, None, None, None, ('t_WSTRING_LITERAL', 'WSTRING_LITERAL'), None, None, ('t_U8STRING_LITERAL', 'U8STRING_LITERAL'), None, None, ('t_U16STRING_LITERAL', 'U16STRING_LITERAL'), None, None, ('t_U32STRING_LITERAL', 'U32STRING_LITERAL'), None, None, ('t_BAD_STRING_LITERAL', 'BAD_STRING_LITERAL'), None, None, None, None, None, ('t_ID', 'ID'), (None, 'STRING_LITERAL'), None, None, (None, 'ELLIPSIS'), (None, 'PLUSPLUS'), (None, 'LOR'), (None, 'XOREQUAL'), (None, 'OREQUAL'), (None, 'LSHIFTEQUAL'), (None, 'RSHIFTEQUAL'), (None, 'PLUSEQUAL'), (None, 'TIMESEQUAL')]), ('(?P<t_PLUS>\\+)|(?P<t_MODEQUAL>%=)|(?P<t_DIVEQUAL>/=)|(?P<t_RBRACKET>\\])|(?P<t_CONDOP>\\?)|(?P<t_XOR>\\^)|(?P<t_LSHIFT><<)|(?P<t_LE><=)|(?P<t_LPAREN>\\()|(?P<t_ARROW>->)|(?P<t_EQ>==)|(?P<t_NE>!=)|(?P<t_MINUSMINUS>--)|(?P<t_OR>\\|)|(?P<t_TIMES>\\*)|(?P<t_LBRACKET>\\[)|(?P<t_GE>>=)|(?P<t_RPAREN>\\))|(?P<t_LAND>&&)|(?P<t_RSHIFT>>>)|(?P<t_MINUSEQUAL>-=)|(?P<t_PERIOD>\\.)|(?P<t_ANDEQUAL>&=)|(?P<t_EQUALS>=)|(?P<t_LT><)|(?P<t_COMMA>,)|(?P<t_DIVIDE>/)|(?P<t_AND>&)|(?P<t_MOD>%)|(?P<t_SEMI>;)|(?P<t_MINUS>-)|(?P<t_GT>>)|(?P<t_COLON>:)|(?P<t_NOT>~)|(?P<t_LNOT>!)', [None, (None, 'PLUS'), (None, 'MODEQUAL'), (None, 'DIVEQUAL'), (None, 'RBRACKET'), (None, 'CONDOP'), (None, 'XOR'), (None, 'LSHIFT'), (None, 'LE'), (None, 'LPAREN'), (None, 'ARROW'), (None, 'EQ'), (None, 'NE'), (None, 'MINUSMINUS'), (None, 'OR'), (None, 'TIMES'), (None, 'LBRACKET'), (None, 'GE'), (None, 'RPAREN'), (None, 'LAND'), (None, 'RSHIFT'), (None, 'MINUSEQUAL'), (None, 'PERIOD'), (None, 'ANDEQUAL'), (None, 'EQUALS'), (None, 'LT'), (None, 'COMMA'), (None, 'DIVIDE'), (None, 'AND'), (None, 'MOD'), (None, 'SEMI'), (None, 'MINUS'), (None, 'GT'), (None, 'COLON'), (None, 'NOT'), (None, 'LNOT')])]}
+_lexstateignore = {'ppline': ' \t', 'pppragma': ' \t', 'INITIAL': ' \t'}
+_lexstateerrorf = {'ppline': 't_ppline_error', 'pppragma': 't_pppragma_error', 'INITIAL': 't_error'}
+_lexstateeoff = {}
diff --git a/myenv/lib/python3.9/site-packages/pycparser/ply/__init__.py b/myenv/lib/python3.9/site-packages/pycparser/ply/__init__.py
new file mode 100644
index 0000000..6e53cdd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/ply/__init__.py
@@ -0,0 +1,5 @@
+# PLY package
+# Author: David Beazley (dave@dabeaz.com)
+
+__version__ = '3.9'
+__all__ = ['lex','yacc']
diff --git a/myenv/lib/python3.9/site-packages/pycparser/ply/cpp.py b/myenv/lib/python3.9/site-packages/pycparser/ply/cpp.py
new file mode 100644
index 0000000..86273ea
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/ply/cpp.py
@@ -0,0 +1,905 @@
+# -----------------------------------------------------------------------------
+# cpp.py
+#
+# Author:  David Beazley (http://www.dabeaz.com)
+# Copyright (C) 2017
+# All rights reserved
+#
+# This module implements an ANSI-C style lexical preprocessor for PLY.
+# -----------------------------------------------------------------------------
+import sys
+
+# Some Python 3 compatibility shims
+if sys.version_info.major < 3:
+    STRING_TYPES = (str, unicode)
+else:
+    STRING_TYPES = str
+    xrange = range
+
+# -----------------------------------------------------------------------------
+# Default preprocessor lexer definitions.   These tokens are enough to get
+# a basic preprocessor working.   Other modules may import these if they want
+# -----------------------------------------------------------------------------
+
+tokens = (
+   'CPP_ID','CPP_INTEGER', 'CPP_FLOAT', 'CPP_STRING', 'CPP_CHAR', 'CPP_WS', 'CPP_COMMENT1', 'CPP_COMMENT2', 'CPP_POUND','CPP_DPOUND'
+)
+
+literals = "+-*/%|&~^<>=!?()[]{}.,;:\\\'\""
+
+# Whitespace
+def t_CPP_WS(t):
+    r'\s+'
+    t.lexer.lineno += t.value.count("\n")
+    return t
+
+t_CPP_POUND = r'\#'
+t_CPP_DPOUND = r'\#\#'
+
+# Identifier
+t_CPP_ID = r'[A-Za-z_][\w_]*'
+
+# Integer literal
+def CPP_INTEGER(t):
+    r'(((((0x)|(0X))[0-9a-fA-F]+)|(\d+))([uU][lL]|[lL][uU]|[uU]|[lL])?)'
+    return t
+
+t_CPP_INTEGER = CPP_INTEGER
+
+# Floating literal
+t_CPP_FLOAT = r'((\d+)(\.\d+)(e(\+|-)?(\d+))? | (\d+)e(\+|-)?(\d+))([lL]|[fF])?'
+
+# String literal
+def t_CPP_STRING(t):
+    r'\"([^\\\n]|(\\(.|\n)))*?\"'
+    t.lexer.lineno += t.value.count("\n")
+    return t
+
+# Character constant 'c' or L'c'
+def t_CPP_CHAR(t):
+    r'(L)?\'([^\\\n]|(\\(.|\n)))*?\''
+    t.lexer.lineno += t.value.count("\n")
+    return t
+
+# Comment
+def t_CPP_COMMENT1(t):
+    r'(/\*(.|\n)*?\*/)'
+    ncr = t.value.count("\n")
+    t.lexer.lineno += ncr
+    # replace with one space or a number of '\n'
+    t.type = 'CPP_WS'; t.value = '\n' * ncr if ncr else ' '
+    return t
+
+# Line comment
+def t_CPP_COMMENT2(t):
+    r'(//.*?(\n|$))'
+    # replace with '/n'
+    t.type = 'CPP_WS'; t.value = '\n'
+    return t
+
+def t_error(t):
+    t.type = t.value[0]
+    t.value = t.value[0]
+    t.lexer.skip(1)
+    return t
+
+import re
+import copy
+import time
+import os.path
+
+# -----------------------------------------------------------------------------
+# trigraph()
+#
+# Given an input string, this function replaces all trigraph sequences.
+# The following mapping is used:
+#
+#     ??=    #
+#     ??/    \
+#     ??'    ^
+#     ??(    [
+#     ??)    ]
+#     ??!    |
+#     ??<    {
+#     ??>    }
+#     ??-    ~
+# -----------------------------------------------------------------------------
+
+_trigraph_pat = re.compile(r'''\?\?[=/\'\(\)\!<>\-]''')
+_trigraph_rep = {
+    '=':'#',
+    '/':'\\',
+    "'":'^',
+    '(':'[',
+    ')':']',
+    '!':'|',
+    '<':'{',
+    '>':'}',
+    '-':'~'
+}
+
+def trigraph(input):
+    return _trigraph_pat.sub(lambda g: _trigraph_rep[g.group()[-1]],input)
+
+# ------------------------------------------------------------------
+# Macro object
+#
+# This object holds information about preprocessor macros
+#
+#    .name      - Macro name (string)
+#    .value     - Macro value (a list of tokens)
+#    .arglist   - List of argument names
+#    .variadic  - Boolean indicating whether or not variadic macro
+#    .vararg    - Name of the variadic parameter
+#
+# When a macro is created, the macro replacement token sequence is
+# pre-scanned and used to create patch lists that are later used
+# during macro expansion
+# ------------------------------------------------------------------
+
+class Macro(object):
+    def __init__(self,name,value,arglist=None,variadic=False):
+        self.name = name
+        self.value = value
+        self.arglist = arglist
+        self.variadic = variadic
+        if variadic:
+            self.vararg = arglist[-1]
+        self.source = None
+
+# ------------------------------------------------------------------
+# Preprocessor object
+#
+# Object representing a preprocessor.  Contains macro definitions,
+# include directories, and other information
+# ------------------------------------------------------------------
+
+class Preprocessor(object):
+    def __init__(self,lexer=None):
+        if lexer is None:
+            lexer = lex.lexer
+        self.lexer = lexer
+        self.macros = { }
+        self.path = []
+        self.temp_path = []
+
+        # Probe the lexer for selected tokens
+        self.lexprobe()
+
+        tm = time.localtime()
+        self.define("__DATE__ \"%s\"" % time.strftime("%b %d %Y",tm))
+        self.define("__TIME__ \"%s\"" % time.strftime("%H:%M:%S",tm))
+        self.parser = None
+
+    # -----------------------------------------------------------------------------
+    # tokenize()
+    #
+    # Utility function. Given a string of text, tokenize into a list of tokens
+    # -----------------------------------------------------------------------------
+
+    def tokenize(self,text):
+        tokens = []
+        self.lexer.input(text)
+        while True:
+            tok = self.lexer.token()
+            if not tok: break
+            tokens.append(tok)
+        return tokens
+
+    # ---------------------------------------------------------------------
+    # error()
+    #
+    # Report a preprocessor error/warning of some kind
+    # ----------------------------------------------------------------------
+
+    def error(self,file,line,msg):
+        print("%s:%d %s" % (file,line,msg))
+
+    # ----------------------------------------------------------------------
+    # lexprobe()
+    #
+    # This method probes the preprocessor lexer object to discover
+    # the token types of symbols that are important to the preprocessor.
+    # If this works right, the preprocessor will simply "work"
+    # with any suitable lexer regardless of how tokens have been named.
+    # ----------------------------------------------------------------------
+
+    def lexprobe(self):
+
+        # Determine the token type for identifiers
+        self.lexer.input("identifier")
+        tok = self.lexer.token()
+        if not tok or tok.value != "identifier":
+            print("Couldn't determine identifier type")
+        else:
+            self.t_ID = tok.type
+
+        # Determine the token type for integers
+        self.lexer.input("12345")
+        tok = self.lexer.token()
+        if not tok or int(tok.value) != 12345:
+            print("Couldn't determine integer type")
+        else:
+            self.t_INTEGER = tok.type
+            self.t_INTEGER_TYPE = type(tok.value)
+
+        # Determine the token type for strings enclosed in double quotes
+        self.lexer.input("\"filename\"")
+        tok = self.lexer.token()
+        if not tok or tok.value != "\"filename\"":
+            print("Couldn't determine string type")
+        else:
+            self.t_STRING = tok.type
+
+        # Determine the token type for whitespace--if any
+        self.lexer.input("  ")
+        tok = self.lexer.token()
+        if not tok or tok.value != "  ":
+            self.t_SPACE = None
+        else:
+            self.t_SPACE = tok.type
+
+        # Determine the token type for newlines
+        self.lexer.input("\n")
+        tok = self.lexer.token()
+        if not tok or tok.value != "\n":
+            self.t_NEWLINE = None
+            print("Couldn't determine token for newlines")
+        else:
+            self.t_NEWLINE = tok.type
+
+        self.t_WS = (self.t_SPACE, self.t_NEWLINE)
+
+        # Check for other characters used by the preprocessor
+        chars = [ '<','>','#','##','\\','(',')',',','.']
+        for c in chars:
+            self.lexer.input(c)
+            tok = self.lexer.token()
+            if not tok or tok.value != c:
+                print("Unable to lex '%s' required for preprocessor" % c)
+
+    # ----------------------------------------------------------------------
+    # add_path()
+    #
+    # Adds a search path to the preprocessor.
+    # ----------------------------------------------------------------------
+
+    def add_path(self,path):
+        self.path.append(path)
+
+    # ----------------------------------------------------------------------
+    # group_lines()
+    #
+    # Given an input string, this function splits it into lines.  Trailing whitespace
+    # is removed.   Any line ending with \ is grouped with the next line.  This
+    # function forms the lowest level of the preprocessor---grouping into text into
+    # a line-by-line format.
+    # ----------------------------------------------------------------------
+
+    def group_lines(self,input):
+        lex = self.lexer.clone()
+        lines = [x.rstrip() for x in input.splitlines()]
+        for i in xrange(len(lines)):
+            j = i+1
+            while lines[i].endswith('\\') and (j < len(lines)):
+                lines[i] = lines[i][:-1]+lines[j]
+                lines[j] = ""
+                j += 1
+
+        input = "\n".join(lines)
+        lex.input(input)
+        lex.lineno = 1
+
+        current_line = []
+        while True:
+            tok = lex.token()
+            if not tok:
+                break
+            current_line.append(tok)
+            if tok.type in self.t_WS and '\n' in tok.value:
+                yield current_line
+                current_line = []
+
+        if current_line:
+            yield current_line
+
+    # ----------------------------------------------------------------------
+    # tokenstrip()
+    #
+    # Remove leading/trailing whitespace tokens from a token list
+    # ----------------------------------------------------------------------
+
+    def tokenstrip(self,tokens):
+        i = 0
+        while i < len(tokens) and tokens[i].type in self.t_WS:
+            i += 1
+        del tokens[:i]
+        i = len(tokens)-1
+        while i >= 0 and tokens[i].type in self.t_WS:
+            i -= 1
+        del tokens[i+1:]
+        return tokens
+
+
+    # ----------------------------------------------------------------------
+    # collect_args()
+    #
+    # Collects comma separated arguments from a list of tokens.   The arguments
+    # must be enclosed in parenthesis.  Returns a tuple (tokencount,args,positions)
+    # where tokencount is the number of tokens consumed, args is a list of arguments,
+    # and positions is a list of integers containing the starting index of each
+    # argument.  Each argument is represented by a list of tokens.
+    #
+    # When collecting arguments, leading and trailing whitespace is removed
+    # from each argument.
+    #
+    # This function properly handles nested parenthesis and commas---these do not
+    # define new arguments.
+    # ----------------------------------------------------------------------
+
+    def collect_args(self,tokenlist):
+        args = []
+        positions = []
+        current_arg = []
+        nesting = 1
+        tokenlen = len(tokenlist)
+
+        # Search for the opening '('.
+        i = 0
+        while (i < tokenlen) and (tokenlist[i].type in self.t_WS):
+            i += 1
+
+        if (i < tokenlen) and (tokenlist[i].value == '('):
+            positions.append(i+1)
+        else:
+            self.error(self.source,tokenlist[0].lineno,"Missing '(' in macro arguments")
+            return 0, [], []
+
+        i += 1
+
+        while i < tokenlen:
+            t = tokenlist[i]
+            if t.value == '(':
+                current_arg.append(t)
+                nesting += 1
+            elif t.value == ')':
+                nesting -= 1
+                if nesting == 0:
+                    if current_arg:
+                        args.append(self.tokenstrip(current_arg))
+                        positions.append(i)
+                    return i+1,args,positions
+                current_arg.append(t)
+            elif t.value == ',' and nesting == 1:
+                args.append(self.tokenstrip(current_arg))
+                positions.append(i+1)
+                current_arg = []
+            else:
+                current_arg.append(t)
+            i += 1
+
+        # Missing end argument
+        self.error(self.source,tokenlist[-1].lineno,"Missing ')' in macro arguments")
+        return 0, [],[]
+
+    # ----------------------------------------------------------------------
+    # macro_prescan()
+    #
+    # Examine the macro value (token sequence) and identify patch points
+    # This is used to speed up macro expansion later on---we'll know
+    # right away where to apply patches to the value to form the expansion
+    # ----------------------------------------------------------------------
+
+    def macro_prescan(self,macro):
+        macro.patch     = []             # Standard macro arguments
+        macro.str_patch = []             # String conversion expansion
+        macro.var_comma_patch = []       # Variadic macro comma patch
+        i = 0
+        while i < len(macro.value):
+            if macro.value[i].type == self.t_ID and macro.value[i].value in macro.arglist:
+                argnum = macro.arglist.index(macro.value[i].value)
+                # Conversion of argument to a string
+                if i > 0 and macro.value[i-1].value == '#':
+                    macro.value[i] = copy.copy(macro.value[i])
+                    macro.value[i].type = self.t_STRING
+                    del macro.value[i-1]
+                    macro.str_patch.append((argnum,i-1))
+                    continue
+                # Concatenation
+                elif (i > 0 and macro.value[i-1].value == '##'):
+                    macro.patch.append(('c',argnum,i-1))
+                    del macro.value[i-1]
+                    continue
+                elif ((i+1) < len(macro.value) and macro.value[i+1].value == '##'):
+                    macro.patch.append(('c',argnum,i))
+                    i += 1
+                    continue
+                # Standard expansion
+                else:
+                    macro.patch.append(('e',argnum,i))
+            elif macro.value[i].value == '##':
+                if macro.variadic and (i > 0) and (macro.value[i-1].value == ',') and \
+                        ((i+1) < len(macro.value)) and (macro.value[i+1].type == self.t_ID) and \
+                        (macro.value[i+1].value == macro.vararg):
+                    macro.var_comma_patch.append(i-1)
+            i += 1
+        macro.patch.sort(key=lambda x: x[2],reverse=True)
+
+    # ----------------------------------------------------------------------
+    # macro_expand_args()
+    #
+    # Given a Macro and list of arguments (each a token list), this method
+    # returns an expanded version of a macro.  The return value is a token sequence
+    # representing the replacement macro tokens
+    # ----------------------------------------------------------------------
+
+    def macro_expand_args(self,macro,args):
+        # Make a copy of the macro token sequence
+        rep = [copy.copy(_x) for _x in macro.value]
+
+        # Make string expansion patches.  These do not alter the length of the replacement sequence
+
+        str_expansion = {}
+        for argnum, i in macro.str_patch:
+            if argnum not in str_expansion:
+                str_expansion[argnum] = ('"%s"' % "".join([x.value for x in args[argnum]])).replace("\\","\\\\")
+            rep[i] = copy.copy(rep[i])
+            rep[i].value = str_expansion[argnum]
+
+        # Make the variadic macro comma patch.  If the variadic macro argument is empty, we get rid
+        comma_patch = False
+        if macro.variadic and not args[-1]:
+            for i in macro.var_comma_patch:
+                rep[i] = None
+                comma_patch = True
+
+        # Make all other patches.   The order of these matters.  It is assumed that the patch list
+        # has been sorted in reverse order of patch location since replacements will cause the
+        # size of the replacement sequence to expand from the patch point.
+
+        expanded = { }
+        for ptype, argnum, i in macro.patch:
+            # Concatenation.   Argument is left unexpanded
+            if ptype == 'c':
+                rep[i:i+1] = args[argnum]
+            # Normal expansion.  Argument is macro expanded first
+            elif ptype == 'e':
+                if argnum not in expanded:
+                    expanded[argnum] = self.expand_macros(args[argnum])
+                rep[i:i+1] = expanded[argnum]
+
+        # Get rid of removed comma if necessary
+        if comma_patch:
+            rep = [_i for _i in rep if _i]
+
+        return rep
+
+
+    # ----------------------------------------------------------------------
+    # expand_macros()
+    #
+    # Given a list of tokens, this function performs macro expansion.
+    # The expanded argument is a dictionary that contains macros already
+    # expanded.  This is used to prevent infinite recursion.
+    # ----------------------------------------------------------------------
+
+    def expand_macros(self,tokens,expanded=None):
+        if expanded is None:
+            expanded = {}
+        i = 0
+        while i < len(tokens):
+            t = tokens[i]
+            if t.type == self.t_ID:
+                if t.value in self.macros and t.value not in expanded:
+                    # Yes, we found a macro match
+                    expanded[t.value] = True
+
+                    m = self.macros[t.value]
+                    if not m.arglist:
+                        # A simple macro
+                        ex = self.expand_macros([copy.copy(_x) for _x in m.value],expanded)
+                        for e in ex:
+                            e.lineno = t.lineno
+                        tokens[i:i+1] = ex
+                        i += len(ex)
+                    else:
+                        # A macro with arguments
+                        j = i + 1
+                        while j < len(tokens) and tokens[j].type in self.t_WS:
+                            j += 1
+                        if tokens[j].value == '(':
+                            tokcount,args,positions = self.collect_args(tokens[j:])
+                            if not m.variadic and len(args) !=  len(m.arglist):
+                                self.error(self.source,t.lineno,"Macro %s requires %d arguments" % (t.value,len(m.arglist)))
+                                i = j + tokcount
+                            elif m.variadic and len(args) < len(m.arglist)-1:
+                                if len(m.arglist) > 2:
+                                    self.error(self.source,t.lineno,"Macro %s must have at least %d arguments" % (t.value, len(m.arglist)-1))
+                                else:
+                                    self.error(self.source,t.lineno,"Macro %s must have at least %d argument" % (t.value, len(m.arglist)-1))
+                                i = j + tokcount
+                            else:
+                                if m.variadic:
+                                    if len(args) == len(m.arglist)-1:
+                                        args.append([])
+                                    else:
+                                        args[len(m.arglist)-1] = tokens[j+positions[len(m.arglist)-1]:j+tokcount-1]
+                                        del args[len(m.arglist):]
+
+                                # Get macro replacement text
+                                rep = self.macro_expand_args(m,args)
+                                rep = self.expand_macros(rep,expanded)
+                                for r in rep:
+                                    r.lineno = t.lineno
+                                tokens[i:j+tokcount] = rep
+                                i += len(rep)
+                    del expanded[t.value]
+                    continue
+                elif t.value == '__LINE__':
+                    t.type = self.t_INTEGER
+                    t.value = self.t_INTEGER_TYPE(t.lineno)
+
+            i += 1
+        return tokens
+
+    # ----------------------------------------------------------------------
+    # evalexpr()
+    #
+    # Evaluate an expression token sequence for the purposes of evaluating
+    # integral expressions.
+    # ----------------------------------------------------------------------
+
+    def evalexpr(self,tokens):
+        # tokens = tokenize(line)
+        # Search for defined macros
+        i = 0
+        while i < len(tokens):
+            if tokens[i].type == self.t_ID and tokens[i].value == 'defined':
+                j = i + 1
+                needparen = False
+                result = "0L"
+                while j < len(tokens):
+                    if tokens[j].type in self.t_WS:
+                        j += 1
+                        continue
+                    elif tokens[j].type == self.t_ID:
+                        if tokens[j].value in self.macros:
+                            result = "1L"
+                        else:
+                            result = "0L"
+                        if not needparen: break
+                    elif tokens[j].value == '(':
+                        needparen = True
+                    elif tokens[j].value == ')':
+                        break
+                    else:
+                        self.error(self.source,tokens[i].lineno,"Malformed defined()")
+                    j += 1
+                tokens[i].type = self.t_INTEGER
+                tokens[i].value = self.t_INTEGER_TYPE(result)
+                del tokens[i+1:j+1]
+            i += 1
+        tokens = self.expand_macros(tokens)
+        for i,t in enumerate(tokens):
+            if t.type == self.t_ID:
+                tokens[i] = copy.copy(t)
+                tokens[i].type = self.t_INTEGER
+                tokens[i].value = self.t_INTEGER_TYPE("0L")
+            elif t.type == self.t_INTEGER:
+                tokens[i] = copy.copy(t)
+                # Strip off any trailing suffixes
+                tokens[i].value = str(tokens[i].value)
+                while tokens[i].value[-1] not in "0123456789abcdefABCDEF":
+                    tokens[i].value = tokens[i].value[:-1]
+
+        expr = "".join([str(x.value) for x in tokens])
+        expr = expr.replace("&&"," and ")
+        expr = expr.replace("||"," or ")
+        expr = expr.replace("!"," not ")
+        try:
+            result = eval(expr)
+        except Exception:
+            self.error(self.source,tokens[0].lineno,"Couldn't evaluate expression")
+            result = 0
+        return result
+
+    # ----------------------------------------------------------------------
+    # parsegen()
+    #
+    # Parse an input string/
+    # ----------------------------------------------------------------------
+    def parsegen(self,input,source=None):
+
+        # Replace trigraph sequences
+        t = trigraph(input)
+        lines = self.group_lines(t)
+
+        if not source:
+            source = ""
+
+        self.define("__FILE__ \"%s\"" % source)
+
+        self.source = source
+        chunk = []
+        enable = True
+        iftrigger = False
+        ifstack = []
+
+        for x in lines:
+            for i,tok in enumerate(x):
+                if tok.type not in self.t_WS: break
+            if tok.value == '#':
+                # Preprocessor directive
+
+                # insert necessary whitespace instead of eaten tokens
+                for tok in x:
+                    if tok.type in self.t_WS and '\n' in tok.value:
+                        chunk.append(tok)
+
+                dirtokens = self.tokenstrip(x[i+1:])
+                if dirtokens:
+                    name = dirtokens[0].value
+                    args = self.tokenstrip(dirtokens[1:])
+                else:
+                    name = ""
+                    args = []
+
+                if name == 'define':
+                    if enable:
+                        for tok in self.expand_macros(chunk):
+                            yield tok
+                        chunk = []
+                        self.define(args)
+                elif name == 'include':
+                    if enable:
+                        for tok in self.expand_macros(chunk):
+                            yield tok
+                        chunk = []
+                        oldfile = self.macros['__FILE__']
+                        for tok in self.include(args):
+                            yield tok
+                        self.macros['__FILE__'] = oldfile
+                        self.source = source
+                elif name == 'undef':
+                    if enable:
+                        for tok in self.expand_macros(chunk):
+                            yield tok
+                        chunk = []
+                        self.undef(args)
+                elif name == 'ifdef':
+                    ifstack.append((enable,iftrigger))
+                    if enable:
+                        if not args[0].value in self.macros:
+                            enable = False
+                            iftrigger = False
+                        else:
+                            iftrigger = True
+                elif name == 'ifndef':
+                    ifstack.append((enable,iftrigger))
+                    if enable:
+                        if args[0].value in self.macros:
+                            enable = False
+                            iftrigger = False
+                        else:
+                            iftrigger = True
+                elif name == 'if':
+                    ifstack.append((enable,iftrigger))
+                    if enable:
+                        result = self.evalexpr(args)
+                        if not result:
+                            enable = False
+                            iftrigger = False
+                        else:
+                            iftrigger = True
+                elif name == 'elif':
+                    if ifstack:
+                        if ifstack[-1][0]:     # We only pay attention if outer "if" allows this
+                            if enable:         # If already true, we flip enable False
+                                enable = False
+                            elif not iftrigger:   # If False, but not triggered yet, we'll check expression
+                                result = self.evalexpr(args)
+                                if result:
+                                    enable  = True
+                                    iftrigger = True
+                    else:
+                        self.error(self.source,dirtokens[0].lineno,"Misplaced #elif")
+
+                elif name == 'else':
+                    if ifstack:
+                        if ifstack[-1][0]:
+                            if enable:
+                                enable = False
+                            elif not iftrigger:
+                                enable = True
+                                iftrigger = True
+                    else:
+                        self.error(self.source,dirtokens[0].lineno,"Misplaced #else")
+
+                elif name == 'endif':
+                    if ifstack:
+                        enable,iftrigger = ifstack.pop()
+                    else:
+                        self.error(self.source,dirtokens[0].lineno,"Misplaced #endif")
+                else:
+                    # Unknown preprocessor directive
+                    pass
+
+            else:
+                # Normal text
+                if enable:
+                    chunk.extend(x)
+
+        for tok in self.expand_macros(chunk):
+            yield tok
+        chunk = []
+
+    # ----------------------------------------------------------------------
+    # include()
+    #
+    # Implementation of file-inclusion
+    # ----------------------------------------------------------------------
+
+    def include(self,tokens):
+        # Try to extract the filename and then process an include file
+        if not tokens:
+            return
+        if tokens:
+            if tokens[0].value != '<' and tokens[0].type != self.t_STRING:
+                tokens = self.expand_macros(tokens)
+
+            if tokens[0].value == '<':
+                # Include <...>
+                i = 1
+                while i < len(tokens):
+                    if tokens[i].value == '>':
+                        break
+                    i += 1
+                else:
+                    print("Malformed #include <...>")
+                    return
+                filename = "".join([x.value for x in tokens[1:i]])
+                path = self.path + [""] + self.temp_path
+            elif tokens[0].type == self.t_STRING:
+                filename = tokens[0].value[1:-1]
+                path = self.temp_path + [""] + self.path
+            else:
+                print("Malformed #include statement")
+                return
+        for p in path:
+            iname = os.path.join(p,filename)
+            try:
+                data = open(iname,"r").read()
+                dname = os.path.dirname(iname)
+                if dname:
+                    self.temp_path.insert(0,dname)
+                for tok in self.parsegen(data,filename):
+                    yield tok
+                if dname:
+                    del self.temp_path[0]
+                break
+            except IOError:
+                pass
+        else:
+            print("Couldn't find '%s'" % filename)
+
+    # ----------------------------------------------------------------------
+    # define()
+    #
+    # Define a new macro
+    # ----------------------------------------------------------------------
+
+    def define(self,tokens):
+        if isinstance(tokens,STRING_TYPES):
+            tokens = self.tokenize(tokens)
+
+        linetok = tokens
+        try:
+            name = linetok[0]
+            if len(linetok) > 1:
+                mtype = linetok[1]
+            else:
+                mtype = None
+            if not mtype:
+                m = Macro(name.value,[])
+                self.macros[name.value] = m
+            elif mtype.type in self.t_WS:
+                # A normal macro
+                m = Macro(name.value,self.tokenstrip(linetok[2:]))
+                self.macros[name.value] = m
+            elif mtype.value == '(':
+                # A macro with arguments
+                tokcount, args, positions = self.collect_args(linetok[1:])
+                variadic = False
+                for a in args:
+                    if variadic:
+                        print("No more arguments may follow a variadic argument")
+                        break
+                    astr = "".join([str(_i.value) for _i in a])
+                    if astr == "...":
+                        variadic = True
+                        a[0].type = self.t_ID
+                        a[0].value = '__VA_ARGS__'
+                        variadic = True
+                        del a[1:]
+                        continue
+                    elif astr[-3:] == "..." and a[0].type == self.t_ID:
+                        variadic = True
+                        del a[1:]
+                        # If, for some reason, "." is part of the identifier, strip off the name for the purposes
+                        # of macro expansion
+                        if a[0].value[-3:] == '...':
+                            a[0].value = a[0].value[:-3]
+                        continue
+                    if len(a) > 1 or a[0].type != self.t_ID:
+                        print("Invalid macro argument")
+                        break
+                else:
+                    mvalue = self.tokenstrip(linetok[1+tokcount:])
+                    i = 0
+                    while i < len(mvalue):
+                        if i+1 < len(mvalue):
+                            if mvalue[i].type in self.t_WS and mvalue[i+1].value == '##':
+                                del mvalue[i]
+                                continue
+                            elif mvalue[i].value == '##' and mvalue[i+1].type in self.t_WS:
+                                del mvalue[i+1]
+                        i += 1
+                    m = Macro(name.value,mvalue,[x[0].value for x in args],variadic)
+                    self.macro_prescan(m)
+                    self.macros[name.value] = m
+            else:
+                print("Bad macro definition")
+        except LookupError:
+            print("Bad macro definition")
+
+    # ----------------------------------------------------------------------
+    # undef()
+    #
+    # Undefine a macro
+    # ----------------------------------------------------------------------
+
+    def undef(self,tokens):
+        id = tokens[0].value
+        try:
+            del self.macros[id]
+        except LookupError:
+            pass
+
+    # ----------------------------------------------------------------------
+    # parse()
+    #
+    # Parse input text.
+    # ----------------------------------------------------------------------
+    def parse(self,input,source=None,ignore={}):
+        self.ignore = ignore
+        self.parser = self.parsegen(input,source)
+
+    # ----------------------------------------------------------------------
+    # token()
+    #
+    # Method to return individual tokens
+    # ----------------------------------------------------------------------
+    def token(self):
+        try:
+            while True:
+                tok = next(self.parser)
+                if tok.type not in self.ignore: return tok
+        except StopIteration:
+            self.parser = None
+            return None
+
+if __name__ == '__main__':
+    import ply.lex as lex
+    lexer = lex.lex()
+
+    # Run a preprocessor
+    import sys
+    f = open(sys.argv[1])
+    input = f.read()
+
+    p = Preprocessor(lexer)
+    p.parse(input,sys.argv[1])
+    while True:
+        tok = p.token()
+        if not tok: break
+        print(p.source, tok)
diff --git a/myenv/lib/python3.9/site-packages/pycparser/ply/ctokens.py b/myenv/lib/python3.9/site-packages/pycparser/ply/ctokens.py
new file mode 100644
index 0000000..f6f6952
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/ply/ctokens.py
@@ -0,0 +1,133 @@
+# ----------------------------------------------------------------------
+# ctokens.py
+#
+# Token specifications for symbols in ANSI C and C++.  This file is
+# meant to be used as a library in other tokenizers.
+# ----------------------------------------------------------------------
+
+# Reserved words
+
+tokens = [
+    # Literals (identifier, integer constant, float constant, string constant, char const)
+    'ID', 'TYPEID', 'INTEGER', 'FLOAT', 'STRING', 'CHARACTER',
+
+    # Operators (+,-,*,/,%,|,&,~,^,<<,>>, ||, &&, !, <, <=, >, >=, ==, !=)
+    'PLUS', 'MINUS', 'TIMES', 'DIVIDE', 'MODULO',
+    'OR', 'AND', 'NOT', 'XOR', 'LSHIFT', 'RSHIFT',
+    'LOR', 'LAND', 'LNOT',
+    'LT', 'LE', 'GT', 'GE', 'EQ', 'NE',
+    
+    # Assignment (=, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=)
+    'EQUALS', 'TIMESEQUAL', 'DIVEQUAL', 'MODEQUAL', 'PLUSEQUAL', 'MINUSEQUAL',
+    'LSHIFTEQUAL','RSHIFTEQUAL', 'ANDEQUAL', 'XOREQUAL', 'OREQUAL',
+
+    # Increment/decrement (++,--)
+    'INCREMENT', 'DECREMENT',
+
+    # Structure dereference (->)
+    'ARROW',
+
+    # Ternary operator (?)
+    'TERNARY',
+    
+    # Delimeters ( ) [ ] { } , . ; :
+    'LPAREN', 'RPAREN',
+    'LBRACKET', 'RBRACKET',
+    'LBRACE', 'RBRACE',
+    'COMMA', 'PERIOD', 'SEMI', 'COLON',
+
+    # Ellipsis (...)
+    'ELLIPSIS',
+]
+    
+# Operators
+t_PLUS             = r'\+'
+t_MINUS            = r'-'
+t_TIMES            = r'\*'
+t_DIVIDE           = r'/'
+t_MODULO           = r'%'
+t_OR               = r'\|'
+t_AND              = r'&'
+t_NOT              = r'~'
+t_XOR              = r'\^'
+t_LSHIFT           = r'<<'
+t_RSHIFT           = r'>>'
+t_LOR              = r'\|\|'
+t_LAND             = r'&&'
+t_LNOT             = r'!'
+t_LT               = r'<'
+t_GT               = r'>'
+t_LE               = r'<='
+t_GE               = r'>='
+t_EQ               = r'=='
+t_NE               = r'!='
+
+# Assignment operators
+
+t_EQUALS           = r'='
+t_TIMESEQUAL       = r'\*='
+t_DIVEQUAL         = r'/='
+t_MODEQUAL         = r'%='
+t_PLUSEQUAL        = r'\+='
+t_MINUSEQUAL       = r'-='
+t_LSHIFTEQUAL      = r'<<='
+t_RSHIFTEQUAL      = r'>>='
+t_ANDEQUAL         = r'&='
+t_OREQUAL          = r'\|='
+t_XOREQUAL         = r'\^='
+
+# Increment/decrement
+t_INCREMENT        = r'\+\+'
+t_DECREMENT        = r'--'
+
+# ->
+t_ARROW            = r'->'
+
+# ?
+t_TERNARY          = r'\?'
+
+# Delimeters
+t_LPAREN           = r'\('
+t_RPAREN           = r'\)'
+t_LBRACKET         = r'\['
+t_RBRACKET         = r'\]'
+t_LBRACE           = r'\{'
+t_RBRACE           = r'\}'
+t_COMMA            = r','
+t_PERIOD           = r'\.'
+t_SEMI             = r';'
+t_COLON            = r':'
+t_ELLIPSIS         = r'\.\.\.'
+
+# Identifiers
+t_ID = r'[A-Za-z_][A-Za-z0-9_]*'
+
+# Integer literal
+t_INTEGER = r'\d+([uU]|[lL]|[uU][lL]|[lL][uU])?'
+
+# Floating literal
+t_FLOAT = r'((\d+)(\.\d+)(e(\+|-)?(\d+))? | (\d+)e(\+|-)?(\d+))([lL]|[fF])?'
+
+# String literal
+t_STRING = r'\"([^\\\n]|(\\.))*?\"'
+
+# Character constant 'c' or L'c'
+t_CHARACTER = r'(L)?\'([^\\\n]|(\\.))*?\''
+
+# Comment (C-Style)
+def t_COMMENT(t):
+    r'/\*(.|\n)*?\*/'
+    t.lexer.lineno += t.value.count('\n')
+    return t
+
+# Comment (C++-Style)
+def t_CPPCOMMENT(t):
+    r'//.*\n'
+    t.lexer.lineno += 1
+    return t
+
+
+    
+
+
+
diff --git a/myenv/lib/python3.9/site-packages/pycparser/ply/lex.py b/myenv/lib/python3.9/site-packages/pycparser/ply/lex.py
new file mode 100644
index 0000000..4bdd76c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/ply/lex.py
@@ -0,0 +1,1099 @@
+# -----------------------------------------------------------------------------
+# ply: lex.py
+#
+# Copyright (C) 2001-2017
+# David M. Beazley (Dabeaz LLC)
+# 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 David Beazley or Dabeaz LLC 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.
+# -----------------------------------------------------------------------------
+
+__version__    = '3.10'
+__tabversion__ = '3.10'
+
+import re
+import sys
+import types
+import copy
+import os
+import inspect
+
+# This tuple contains known string types
+try:
+    # Python 2.6
+    StringTypes = (types.StringType, types.UnicodeType)
+except AttributeError:
+    # Python 3.0
+    StringTypes = (str, bytes)
+
+# This regular expression is used to match valid token names
+_is_identifier = re.compile(r'^[a-zA-Z0-9_]+$')
+
+# Exception thrown when invalid token encountered and no default error
+# handler is defined.
+class LexError(Exception):
+    def __init__(self, message, s):
+        self.args = (message,)
+        self.text = s
+
+
+# Token class.  This class is used to represent the tokens produced.
+class LexToken(object):
+    def __str__(self):
+        return 'LexToken(%s,%r,%d,%d)' % (self.type, self.value, self.lineno, self.lexpos)
+
+    def __repr__(self):
+        return str(self)
+
+
+# This object is a stand-in for a logging object created by the
+# logging module.
+
+class PlyLogger(object):
+    def __init__(self, f):
+        self.f = f
+
+    def critical(self, msg, *args, **kwargs):
+        self.f.write((msg % args) + '\n')
+
+    def warning(self, msg, *args, **kwargs):
+        self.f.write('WARNING: ' + (msg % args) + '\n')
+
+    def error(self, msg, *args, **kwargs):
+        self.f.write('ERROR: ' + (msg % args) + '\n')
+
+    info = critical
+    debug = critical
+
+
+# Null logger is used when no output is generated. Does nothing.
+class NullLogger(object):
+    def __getattribute__(self, name):
+        return self
+
+    def __call__(self, *args, **kwargs):
+        return self
+
+
+# -----------------------------------------------------------------------------
+#                        === Lexing Engine ===
+#
+# The following Lexer class implements the lexer runtime.   There are only
+# a few public methods and attributes:
+#
+#    input()          -  Store a new string in the lexer
+#    token()          -  Get the next token
+#    clone()          -  Clone the lexer
+#
+#    lineno           -  Current line number
+#    lexpos           -  Current position in the input string
+# -----------------------------------------------------------------------------
+
+class Lexer:
+    def __init__(self):
+        self.lexre = None             # Master regular expression. This is a list of
+                                      # tuples (re, findex) where re is a compiled
+                                      # regular expression and findex is a list
+                                      # mapping regex group numbers to rules
+        self.lexretext = None         # Current regular expression strings
+        self.lexstatere = {}          # Dictionary mapping lexer states to master regexs
+        self.lexstateretext = {}      # Dictionary mapping lexer states to regex strings
+        self.lexstaterenames = {}     # Dictionary mapping lexer states to symbol names
+        self.lexstate = 'INITIAL'     # Current lexer state
+        self.lexstatestack = []       # Stack of lexer states
+        self.lexstateinfo = None      # State information
+        self.lexstateignore = {}      # Dictionary of ignored characters for each state
+        self.lexstateerrorf = {}      # Dictionary of error functions for each state
+        self.lexstateeoff = {}        # Dictionary of eof functions for each state
+        self.lexreflags = 0           # Optional re compile flags
+        self.lexdata = None           # Actual input data (as a string)
+        self.lexpos = 0               # Current position in input text
+        self.lexlen = 0               # Length of the input text
+        self.lexerrorf = None         # Error rule (if any)
+        self.lexeoff = None           # EOF rule (if any)
+        self.lextokens = None         # List of valid tokens
+        self.lexignore = ''           # Ignored characters
+        self.lexliterals = ''         # Literal characters that can be passed through
+        self.lexmodule = None         # Module
+        self.lineno = 1               # Current line number
+        self.lexoptimize = False      # Optimized mode
+
+    def clone(self, object=None):
+        c = copy.copy(self)
+
+        # If the object parameter has been supplied, it means we are attaching the
+        # lexer to a new object.  In this case, we have to rebind all methods in
+        # the lexstatere and lexstateerrorf tables.
+
+        if object:
+            newtab = {}
+            for key, ritem in self.lexstatere.items():
+                newre = []
+                for cre, findex in ritem:
+                    newfindex = []
+                    for f in findex:
+                        if not f or not f[0]:
+                            newfindex.append(f)
+                            continue
+                        newfindex.append((getattr(object, f[0].__name__), f[1]))
+                newre.append((cre, newfindex))
+                newtab[key] = newre
+            c.lexstatere = newtab
+            c.lexstateerrorf = {}
+            for key, ef in self.lexstateerrorf.items():
+                c.lexstateerrorf[key] = getattr(object, ef.__name__)
+            c.lexmodule = object
+        return c
+
+    # ------------------------------------------------------------
+    # writetab() - Write lexer information to a table file
+    # ------------------------------------------------------------
+    def writetab(self, lextab, outputdir=''):
+        if isinstance(lextab, types.ModuleType):
+            raise IOError("Won't overwrite existing lextab module")
+        basetabmodule = lextab.split('.')[-1]
+        filename = os.path.join(outputdir, basetabmodule) + '.py'
+        with open(filename, 'w') as tf:
+            tf.write('# %s.py. This file automatically created by PLY (version %s). Don\'t edit!\n' % (basetabmodule, __version__))
+            tf.write('_tabversion   = %s\n' % repr(__tabversion__))
+            tf.write('_lextokens    = set(%s)\n' % repr(tuple(self.lextokens)))
+            tf.write('_lexreflags   = %s\n' % repr(self.lexreflags))
+            tf.write('_lexliterals  = %s\n' % repr(self.lexliterals))
+            tf.write('_lexstateinfo = %s\n' % repr(self.lexstateinfo))
+
+            # Rewrite the lexstatere table, replacing function objects with function names
+            tabre = {}
+            for statename, lre in self.lexstatere.items():
+                titem = []
+                for (pat, func), retext, renames in zip(lre, self.lexstateretext[statename], self.lexstaterenames[statename]):
+                    titem.append((retext, _funcs_to_names(func, renames)))
+                tabre[statename] = titem
+
+            tf.write('_lexstatere   = %s\n' % repr(tabre))
+            tf.write('_lexstateignore = %s\n' % repr(self.lexstateignore))
+
+            taberr = {}
+            for statename, ef in self.lexstateerrorf.items():
+                taberr[statename] = ef.__name__ if ef else None
+            tf.write('_lexstateerrorf = %s\n' % repr(taberr))
+
+            tabeof = {}
+            for statename, ef in self.lexstateeoff.items():
+                tabeof[statename] = ef.__name__ if ef else None
+            tf.write('_lexstateeoff = %s\n' % repr(tabeof))
+
+    # ------------------------------------------------------------
+    # readtab() - Read lexer information from a tab file
+    # ------------------------------------------------------------
+    def readtab(self, tabfile, fdict):
+        if isinstance(tabfile, types.ModuleType):
+            lextab = tabfile
+        else:
+            exec('import %s' % tabfile)
+            lextab = sys.modules[tabfile]
+
+        if getattr(lextab, '_tabversion', '0.0') != __tabversion__:
+            raise ImportError('Inconsistent PLY version')
+
+        self.lextokens      = lextab._lextokens
+        self.lexreflags     = lextab._lexreflags
+        self.lexliterals    = lextab._lexliterals
+        self.lextokens_all  = self.lextokens | set(self.lexliterals)
+        self.lexstateinfo   = lextab._lexstateinfo
+        self.lexstateignore = lextab._lexstateignore
+        self.lexstatere     = {}
+        self.lexstateretext = {}
+        for statename, lre in lextab._lexstatere.items():
+            titem = []
+            txtitem = []
+            for pat, func_name in lre:
+                titem.append((re.compile(pat, lextab._lexreflags), _names_to_funcs(func_name, fdict)))
+
+            self.lexstatere[statename] = titem
+            self.lexstateretext[statename] = txtitem
+
+        self.lexstateerrorf = {}
+        for statename, ef in lextab._lexstateerrorf.items():
+            self.lexstateerrorf[statename] = fdict[ef]
+
+        self.lexstateeoff = {}
+        for statename, ef in lextab._lexstateeoff.items():
+            self.lexstateeoff[statename] = fdict[ef]
+
+        self.begin('INITIAL')
+
+    # ------------------------------------------------------------
+    # input() - Push a new string into the lexer
+    # ------------------------------------------------------------
+    def input(self, s):
+        # Pull off the first character to see if s looks like a string
+        c = s[:1]
+        if not isinstance(c, StringTypes):
+            raise ValueError('Expected a string')
+        self.lexdata = s
+        self.lexpos = 0
+        self.lexlen = len(s)
+
+    # ------------------------------------------------------------
+    # begin() - Changes the lexing state
+    # ------------------------------------------------------------
+    def begin(self, state):
+        if state not in self.lexstatere:
+            raise ValueError('Undefined state')
+        self.lexre = self.lexstatere[state]
+        self.lexretext = self.lexstateretext[state]
+        self.lexignore = self.lexstateignore.get(state, '')
+        self.lexerrorf = self.lexstateerrorf.get(state, None)
+        self.lexeoff = self.lexstateeoff.get(state, None)
+        self.lexstate = state
+
+    # ------------------------------------------------------------
+    # push_state() - Changes the lexing state and saves old on stack
+    # ------------------------------------------------------------
+    def push_state(self, state):
+        self.lexstatestack.append(self.lexstate)
+        self.begin(state)
+
+    # ------------------------------------------------------------
+    # pop_state() - Restores the previous state
+    # ------------------------------------------------------------
+    def pop_state(self):
+        self.begin(self.lexstatestack.pop())
+
+    # ------------------------------------------------------------
+    # current_state() - Returns the current lexing state
+    # ------------------------------------------------------------
+    def current_state(self):
+        return self.lexstate
+
+    # ------------------------------------------------------------
+    # skip() - Skip ahead n characters
+    # ------------------------------------------------------------
+    def skip(self, n):
+        self.lexpos += n
+
+    # ------------------------------------------------------------
+    # opttoken() - Return the next token from the Lexer
+    #
+    # Note: This function has been carefully implemented to be as fast
+    # as possible.  Don't make changes unless you really know what
+    # you are doing
+    # ------------------------------------------------------------
+    def token(self):
+        # Make local copies of frequently referenced attributes
+        lexpos    = self.lexpos
+        lexlen    = self.lexlen
+        lexignore = self.lexignore
+        lexdata   = self.lexdata
+
+        while lexpos < lexlen:
+            # This code provides some short-circuit code for whitespace, tabs, and other ignored characters
+            if lexdata[lexpos] in lexignore:
+                lexpos += 1
+                continue
+
+            # Look for a regular expression match
+            for lexre, lexindexfunc in self.lexre:
+                m = lexre.match(lexdata, lexpos)
+                if not m:
+                    continue
+
+                # Create a token for return
+                tok = LexToken()
+                tok.value = m.group()
+                tok.lineno = self.lineno
+                tok.lexpos = lexpos
+
+                i = m.lastindex
+                func, tok.type = lexindexfunc[i]
+
+                if not func:
+                    # If no token type was set, it's an ignored token
+                    if tok.type:
+                        self.lexpos = m.end()
+                        return tok
+                    else:
+                        lexpos = m.end()
+                        break
+
+                lexpos = m.end()
+
+                # If token is processed by a function, call it
+
+                tok.lexer = self      # Set additional attributes useful in token rules
+                self.lexmatch = m
+                self.lexpos = lexpos
+
+                newtok = func(tok)
+
+                # Every function must return a token, if nothing, we just move to next token
+                if not newtok:
+                    lexpos    = self.lexpos         # This is here in case user has updated lexpos.
+                    lexignore = self.lexignore      # This is here in case there was a state change
+                    break
+
+                # Verify type of the token.  If not in the token map, raise an error
+                if not self.lexoptimize:
+                    if newtok.type not in self.lextokens_all:
+                        raise LexError("%s:%d: Rule '%s' returned an unknown token type '%s'" % (
+                            func.__code__.co_filename, func.__code__.co_firstlineno,
+                            func.__name__, newtok.type), lexdata[lexpos:])
+
+                return newtok
+            else:
+                # No match, see if in literals
+                if lexdata[lexpos] in self.lexliterals:
+                    tok = LexToken()
+                    tok.value = lexdata[lexpos]
+                    tok.lineno = self.lineno
+                    tok.type = tok.value
+                    tok.lexpos = lexpos
+                    self.lexpos = lexpos + 1
+                    return tok
+
+                # No match. Call t_error() if defined.
+                if self.lexerrorf:
+                    tok = LexToken()
+                    tok.value = self.lexdata[lexpos:]
+                    tok.lineno = self.lineno
+                    tok.type = 'error'
+                    tok.lexer = self
+                    tok.lexpos = lexpos
+                    self.lexpos = lexpos
+                    newtok = self.lexerrorf(tok)
+                    if lexpos == self.lexpos:
+                        # Error method didn't change text position at all. This is an error.
+                        raise LexError("Scanning error. Illegal character '%s'" % (lexdata[lexpos]), lexdata[lexpos:])
+                    lexpos = self.lexpos
+                    if not newtok:
+                        continue
+                    return newtok
+
+                self.lexpos = lexpos
+                raise LexError("Illegal character '%s' at index %d" % (lexdata[lexpos], lexpos), lexdata[lexpos:])
+
+        if self.lexeoff:
+            tok = LexToken()
+            tok.type = 'eof'
+            tok.value = ''
+            tok.lineno = self.lineno
+            tok.lexpos = lexpos
+            tok.lexer = self
+            self.lexpos = lexpos
+            newtok = self.lexeoff(tok)
+            return newtok
+
+        self.lexpos = lexpos + 1
+        if self.lexdata is None:
+            raise RuntimeError('No input string given with input()')
+        return None
+
+    # Iterator interface
+    def __iter__(self):
+        return self
+
+    def next(self):
+        t = self.token()
+        if t is None:
+            raise StopIteration
+        return t
+
+    __next__ = next
+
+# -----------------------------------------------------------------------------
+#                           ==== Lex Builder ===
+#
+# The functions and classes below are used to collect lexing information
+# and build a Lexer object from it.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# _get_regex(func)
+#
+# Returns the regular expression assigned to a function either as a doc string
+# or as a .regex attribute attached by the @TOKEN decorator.
+# -----------------------------------------------------------------------------
+def _get_regex(func):
+    return getattr(func, 'regex', func.__doc__)
+
+# -----------------------------------------------------------------------------
+# get_caller_module_dict()
+#
+# This function returns a dictionary containing all of the symbols defined within
+# a caller further down the call stack.  This is used to get the environment
+# associated with the yacc() call if none was provided.
+# -----------------------------------------------------------------------------
+def get_caller_module_dict(levels):
+    f = sys._getframe(levels)
+    ldict = f.f_globals.copy()
+    if f.f_globals != f.f_locals:
+        ldict.update(f.f_locals)
+    return ldict
+
+# -----------------------------------------------------------------------------
+# _funcs_to_names()
+#
+# Given a list of regular expression functions, this converts it to a list
+# suitable for output to a table file
+# -----------------------------------------------------------------------------
+def _funcs_to_names(funclist, namelist):
+    result = []
+    for f, name in zip(funclist, namelist):
+        if f and f[0]:
+            result.append((name, f[1]))
+        else:
+            result.append(f)
+    return result
+
+# -----------------------------------------------------------------------------
+# _names_to_funcs()
+#
+# Given a list of regular expression function names, this converts it back to
+# functions.
+# -----------------------------------------------------------------------------
+def _names_to_funcs(namelist, fdict):
+    result = []
+    for n in namelist:
+        if n and n[0]:
+            result.append((fdict[n[0]], n[1]))
+        else:
+            result.append(n)
+    return result
+
+# -----------------------------------------------------------------------------
+# _form_master_re()
+#
+# This function takes a list of all of the regex components and attempts to
+# form the master regular expression.  Given limitations in the Python re
+# module, it may be necessary to break the master regex into separate expressions.
+# -----------------------------------------------------------------------------
+def _form_master_re(relist, reflags, ldict, toknames):
+    if not relist:
+        return []
+    regex = '|'.join(relist)
+    try:
+        lexre = re.compile(regex, reflags)
+
+        # Build the index to function map for the matching engine
+        lexindexfunc = [None] * (max(lexre.groupindex.values()) + 1)
+        lexindexnames = lexindexfunc[:]
+
+        for f, i in lexre.groupindex.items():
+            handle = ldict.get(f, None)
+            if type(handle) in (types.FunctionType, types.MethodType):
+                lexindexfunc[i] = (handle, toknames[f])
+                lexindexnames[i] = f
+            elif handle is not None:
+                lexindexnames[i] = f
+                if f.find('ignore_') > 0:
+                    lexindexfunc[i] = (None, None)
+                else:
+                    lexindexfunc[i] = (None, toknames[f])
+
+        return [(lexre, lexindexfunc)], [regex], [lexindexnames]
+    except Exception:
+        m = int(len(relist)/2)
+        if m == 0:
+            m = 1
+        llist, lre, lnames = _form_master_re(relist[:m], reflags, ldict, toknames)
+        rlist, rre, rnames = _form_master_re(relist[m:], reflags, ldict, toknames)
+        return (llist+rlist), (lre+rre), (lnames+rnames)
+
+# -----------------------------------------------------------------------------
+# def _statetoken(s,names)
+#
+# Given a declaration name s of the form "t_" and a dictionary whose keys are
+# state names, this function returns a tuple (states,tokenname) where states
+# is a tuple of state names and tokenname is the name of the token.  For example,
+# calling this with s = "t_foo_bar_SPAM" might return (('foo','bar'),'SPAM')
+# -----------------------------------------------------------------------------
+def _statetoken(s, names):
+    nonstate = 1
+    parts = s.split('_')
+    for i, part in enumerate(parts[1:], 1):
+        if part not in names and part != 'ANY':
+            break
+
+    if i > 1:
+        states = tuple(parts[1:i])
+    else:
+        states = ('INITIAL',)
+
+    if 'ANY' in states:
+        states = tuple(names)
+
+    tokenname = '_'.join(parts[i:])
+    return (states, tokenname)
+
+
+# -----------------------------------------------------------------------------
+# LexerReflect()
+#
+# This class represents information needed to build a lexer as extracted from a
+# user's input file.
+# -----------------------------------------------------------------------------
+class LexerReflect(object):
+    def __init__(self, ldict, log=None, reflags=0):
+        self.ldict      = ldict
+        self.error_func = None
+        self.tokens     = []
+        self.reflags    = reflags
+        self.stateinfo  = {'INITIAL': 'inclusive'}
+        self.modules    = set()
+        self.error      = False
+        self.log        = PlyLogger(sys.stderr) if log is None else log
+
+    # Get all of the basic information
+    def get_all(self):
+        self.get_tokens()
+        self.get_literals()
+        self.get_states()
+        self.get_rules()
+
+    # Validate all of the information
+    def validate_all(self):
+        self.validate_tokens()
+        self.validate_literals()
+        self.validate_rules()
+        return self.error
+
+    # Get the tokens map
+    def get_tokens(self):
+        tokens = self.ldict.get('tokens', None)
+        if not tokens:
+            self.log.error('No token list is defined')
+            self.error = True
+            return
+
+        if not isinstance(tokens, (list, tuple)):
+            self.log.error('tokens must be a list or tuple')
+            self.error = True
+            return
+
+        if not tokens:
+            self.log.error('tokens is empty')
+            self.error = True
+            return
+
+        self.tokens = tokens
+
+    # Validate the tokens
+    def validate_tokens(self):
+        terminals = {}
+        for n in self.tokens:
+            if not _is_identifier.match(n):
+                self.log.error("Bad token name '%s'", n)
+                self.error = True
+            if n in terminals:
+                self.log.warning("Token '%s' multiply defined", n)
+            terminals[n] = 1
+
+    # Get the literals specifier
+    def get_literals(self):
+        self.literals = self.ldict.get('literals', '')
+        if not self.literals:
+            self.literals = ''
+
+    # Validate literals
+    def validate_literals(self):
+        try:
+            for c in self.literals:
+                if not isinstance(c, StringTypes) or len(c) > 1:
+                    self.log.error('Invalid literal %s. Must be a single character', repr(c))
+                    self.error = True
+
+        except TypeError:
+            self.log.error('Invalid literals specification. literals must be a sequence of characters')
+            self.error = True
+
+    def get_states(self):
+        self.states = self.ldict.get('states', None)
+        # Build statemap
+        if self.states:
+            if not isinstance(self.states, (tuple, list)):
+                self.log.error('states must be defined as a tuple or list')
+                self.error = True
+            else:
+                for s in self.states:
+                    if not isinstance(s, tuple) or len(s) != 2:
+                        self.log.error("Invalid state specifier %s. Must be a tuple (statename,'exclusive|inclusive')", repr(s))
+                        self.error = True
+                        continue
+                    name, statetype = s
+                    if not isinstance(name, StringTypes):
+                        self.log.error('State name %s must be a string', repr(name))
+                        self.error = True
+                        continue
+                    if not (statetype == 'inclusive' or statetype == 'exclusive'):
+                        self.log.error("State type for state %s must be 'inclusive' or 'exclusive'", name)
+                        self.error = True
+                        continue
+                    if name in self.stateinfo:
+                        self.log.error("State '%s' already defined", name)
+                        self.error = True
+                        continue
+                    self.stateinfo[name] = statetype
+
+    # Get all of the symbols with a t_ prefix and sort them into various
+    # categories (functions, strings, error functions, and ignore characters)
+
+    def get_rules(self):
+        tsymbols = [f for f in self.ldict if f[:2] == 't_']
+
+        # Now build up a list of functions and a list of strings
+        self.toknames = {}        # Mapping of symbols to token names
+        self.funcsym  = {}        # Symbols defined as functions
+        self.strsym   = {}        # Symbols defined as strings
+        self.ignore   = {}        # Ignore strings by state
+        self.errorf   = {}        # Error functions by state
+        self.eoff     = {}        # EOF functions by state
+
+        for s in self.stateinfo:
+            self.funcsym[s] = []
+            self.strsym[s] = []
+
+        if len(tsymbols) == 0:
+            self.log.error('No rules of the form t_rulename are defined')
+            self.error = True
+            return
+
+        for f in tsymbols:
+            t = self.ldict[f]
+            states, tokname = _statetoken(f, self.stateinfo)
+            self.toknames[f] = tokname
+
+            if hasattr(t, '__call__'):
+                if tokname == 'error':
+                    for s in states:
+                        self.errorf[s] = t
+                elif tokname == 'eof':
+                    for s in states:
+                        self.eoff[s] = t
+                elif tokname == 'ignore':
+                    line = t.__code__.co_firstlineno
+                    file = t.__code__.co_filename
+                    self.log.error("%s:%d: Rule '%s' must be defined as a string", file, line, t.__name__)
+                    self.error = True
+                else:
+                    for s in states:
+                        self.funcsym[s].append((f, t))
+            elif isinstance(t, StringTypes):
+                if tokname == 'ignore':
+                    for s in states:
+                        self.ignore[s] = t
+                    if '\\' in t:
+                        self.log.warning("%s contains a literal backslash '\\'", f)
+
+                elif tokname == 'error':
+                    self.log.error("Rule '%s' must be defined as a function", f)
+                    self.error = True
+                else:
+                    for s in states:
+                        self.strsym[s].append((f, t))
+            else:
+                self.log.error('%s not defined as a function or string', f)
+                self.error = True
+
+        # Sort the functions by line number
+        for f in self.funcsym.values():
+            f.sort(key=lambda x: x[1].__code__.co_firstlineno)
+
+        # Sort the strings by regular expression length
+        for s in self.strsym.values():
+            s.sort(key=lambda x: len(x[1]), reverse=True)
+
+    # Validate all of the t_rules collected
+    def validate_rules(self):
+        for state in self.stateinfo:
+            # Validate all rules defined by functions
+
+            for fname, f in self.funcsym[state]:
+                line = f.__code__.co_firstlineno
+                file = f.__code__.co_filename
+                module = inspect.getmodule(f)
+                self.modules.add(module)
+
+                tokname = self.toknames[fname]
+                if isinstance(f, types.MethodType):
+                    reqargs = 2
+                else:
+                    reqargs = 1
+                nargs = f.__code__.co_argcount
+                if nargs > reqargs:
+                    self.log.error("%s:%d: Rule '%s' has too many arguments", file, line, f.__name__)
+                    self.error = True
+                    continue
+
+                if nargs < reqargs:
+                    self.log.error("%s:%d: Rule '%s' requires an argument", file, line, f.__name__)
+                    self.error = True
+                    continue
+
+                if not _get_regex(f):
+                    self.log.error("%s:%d: No regular expression defined for rule '%s'", file, line, f.__name__)
+                    self.error = True
+                    continue
+
+                try:
+                    c = re.compile('(?P<%s>%s)' % (fname, _get_regex(f)), self.reflags)
+                    if c.match(''):
+                        self.log.error("%s:%d: Regular expression for rule '%s' matches empty string", file, line, f.__name__)
+                        self.error = True
+                except re.error as e:
+                    self.log.error("%s:%d: Invalid regular expression for rule '%s'. %s", file, line, f.__name__, e)
+                    if '#' in _get_regex(f):
+                        self.log.error("%s:%d. Make sure '#' in rule '%s' is escaped with '\\#'", file, line, f.__name__)
+                    self.error = True
+
+            # Validate all rules defined by strings
+            for name, r in self.strsym[state]:
+                tokname = self.toknames[name]
+                if tokname == 'error':
+                    self.log.error("Rule '%s' must be defined as a function", name)
+                    self.error = True
+                    continue
+
+                if tokname not in self.tokens and tokname.find('ignore_') < 0:
+                    self.log.error("Rule '%s' defined for an unspecified token %s", name, tokname)
+                    self.error = True
+                    continue
+
+                try:
+                    c = re.compile('(?P<%s>%s)' % (name, r), self.reflags)
+                    if (c.match('')):
+                        self.log.error("Regular expression for rule '%s' matches empty string", name)
+                        self.error = True
+                except re.error as e:
+                    self.log.error("Invalid regular expression for rule '%s'. %s", name, e)
+                    if '#' in r:
+                        self.log.error("Make sure '#' in rule '%s' is escaped with '\\#'", name)
+                    self.error = True
+
+            if not self.funcsym[state] and not self.strsym[state]:
+                self.log.error("No rules defined for state '%s'", state)
+                self.error = True
+
+            # Validate the error function
+            efunc = self.errorf.get(state, None)
+            if efunc:
+                f = efunc
+                line = f.__code__.co_firstlineno
+                file = f.__code__.co_filename
+                module = inspect.getmodule(f)
+                self.modules.add(module)
+
+                if isinstance(f, types.MethodType):
+                    reqargs = 2
+                else:
+                    reqargs = 1
+                nargs = f.__code__.co_argcount
+                if nargs > reqargs:
+                    self.log.error("%s:%d: Rule '%s' has too many arguments", file, line, f.__name__)
+                    self.error = True
+
+                if nargs < reqargs:
+                    self.log.error("%s:%d: Rule '%s' requires an argument", file, line, f.__name__)
+                    self.error = True
+
+        for module in self.modules:
+            self.validate_module(module)
+
+    # -----------------------------------------------------------------------------
+    # validate_module()
+    #
+    # This checks to see if there are duplicated t_rulename() functions or strings
+    # in the parser input file.  This is done using a simple regular expression
+    # match on each line in the source code of the given module.
+    # -----------------------------------------------------------------------------
+
+    def validate_module(self, module):
+        try:
+            lines, linen = inspect.getsourcelines(module)
+        except IOError:
+            return
+
+        fre = re.compile(r'\s*def\s+(t_[a-zA-Z_0-9]*)\(')
+        sre = re.compile(r'\s*(t_[a-zA-Z_0-9]*)\s*=')
+
+        counthash = {}
+        linen += 1
+        for line in lines:
+            m = fre.match(line)
+            if not m:
+                m = sre.match(line)
+            if m:
+                name = m.group(1)
+                prev = counthash.get(name)
+                if not prev:
+                    counthash[name] = linen
+                else:
+                    filename = inspect.getsourcefile(module)
+                    self.log.error('%s:%d: Rule %s redefined. Previously defined on line %d', filename, linen, name, prev)
+                    self.error = True
+            linen += 1
+
+# -----------------------------------------------------------------------------
+# lex(module)
+#
+# Build all of the regular expression rules from definitions in the supplied module
+# -----------------------------------------------------------------------------
+def lex(module=None, object=None, debug=False, optimize=False, lextab='lextab',
+        reflags=int(re.VERBOSE), nowarn=False, outputdir=None, debuglog=None, errorlog=None):
+
+    if lextab is None:
+        lextab = 'lextab'
+
+    global lexer
+
+    ldict = None
+    stateinfo  = {'INITIAL': 'inclusive'}
+    lexobj = Lexer()
+    lexobj.lexoptimize = optimize
+    global token, input
+
+    if errorlog is None:
+        errorlog = PlyLogger(sys.stderr)
+
+    if debug:
+        if debuglog is None:
+            debuglog = PlyLogger(sys.stderr)
+
+    # Get the module dictionary used for the lexer
+    if object:
+        module = object
+
+    # Get the module dictionary used for the parser
+    if module:
+        _items = [(k, getattr(module, k)) for k in dir(module)]
+        ldict = dict(_items)
+        # If no __file__ attribute is available, try to obtain it from the __module__ instead
+        if '__file__' not in ldict:
+            ldict['__file__'] = sys.modules[ldict['__module__']].__file__
+    else:
+        ldict = get_caller_module_dict(2)
+
+    # Determine if the module is package of a package or not.
+    # If so, fix the tabmodule setting so that tables load correctly
+    pkg = ldict.get('__package__')
+    if pkg and isinstance(lextab, str):
+        if '.' not in lextab:
+            lextab = pkg + '.' + lextab
+
+    # Collect parser information from the dictionary
+    linfo = LexerReflect(ldict, log=errorlog, reflags=reflags)
+    linfo.get_all()
+    if not optimize:
+        if linfo.validate_all():
+            raise SyntaxError("Can't build lexer")
+
+    if optimize and lextab:
+        try:
+            lexobj.readtab(lextab, ldict)
+            token = lexobj.token
+            input = lexobj.input
+            lexer = lexobj
+            return lexobj
+
+        except ImportError:
+            pass
+
+    # Dump some basic debugging information
+    if debug:
+        debuglog.info('lex: tokens   = %r', linfo.tokens)
+        debuglog.info('lex: literals = %r', linfo.literals)
+        debuglog.info('lex: states   = %r', linfo.stateinfo)
+
+    # Build a dictionary of valid token names
+    lexobj.lextokens = set()
+    for n in linfo.tokens:
+        lexobj.lextokens.add(n)
+
+    # Get literals specification
+    if isinstance(linfo.literals, (list, tuple)):
+        lexobj.lexliterals = type(linfo.literals[0])().join(linfo.literals)
+    else:
+        lexobj.lexliterals = linfo.literals
+
+    lexobj.lextokens_all = lexobj.lextokens | set(lexobj.lexliterals)
+
+    # Get the stateinfo dictionary
+    stateinfo = linfo.stateinfo
+
+    regexs = {}
+    # Build the master regular expressions
+    for state in stateinfo:
+        regex_list = []
+
+        # Add rules defined by functions first
+        for fname, f in linfo.funcsym[state]:
+            line = f.__code__.co_firstlineno
+            file = f.__code__.co_filename
+            regex_list.append('(?P<%s>%s)' % (fname, _get_regex(f)))
+            if debug:
+                debuglog.info("lex: Adding rule %s -> '%s' (state '%s')", fname, _get_regex(f), state)
+
+        # Now add all of the simple rules
+        for name, r in linfo.strsym[state]:
+            regex_list.append('(?P<%s>%s)' % (name, r))
+            if debug:
+                debuglog.info("lex: Adding rule %s -> '%s' (state '%s')", name, r, state)
+
+        regexs[state] = regex_list
+
+    # Build the master regular expressions
+
+    if debug:
+        debuglog.info('lex: ==== MASTER REGEXS FOLLOW ====')
+
+    for state in regexs:
+        lexre, re_text, re_names = _form_master_re(regexs[state], reflags, ldict, linfo.toknames)
+        lexobj.lexstatere[state] = lexre
+        lexobj.lexstateretext[state] = re_text
+        lexobj.lexstaterenames[state] = re_names
+        if debug:
+            for i, text in enumerate(re_text):
+                debuglog.info("lex: state '%s' : regex[%d] = '%s'", state, i, text)
+
+    # For inclusive states, we need to add the regular expressions from the INITIAL state
+    for state, stype in stateinfo.items():
+        if state != 'INITIAL' and stype == 'inclusive':
+            lexobj.lexstatere[state].extend(lexobj.lexstatere['INITIAL'])
+            lexobj.lexstateretext[state].extend(lexobj.lexstateretext['INITIAL'])
+            lexobj.lexstaterenames[state].extend(lexobj.lexstaterenames['INITIAL'])
+
+    lexobj.lexstateinfo = stateinfo
+    lexobj.lexre = lexobj.lexstatere['INITIAL']
+    lexobj.lexretext = lexobj.lexstateretext['INITIAL']
+    lexobj.lexreflags = reflags
+
+    # Set up ignore variables
+    lexobj.lexstateignore = linfo.ignore
+    lexobj.lexignore = lexobj.lexstateignore.get('INITIAL', '')
+
+    # Set up error functions
+    lexobj.lexstateerrorf = linfo.errorf
+    lexobj.lexerrorf = linfo.errorf.get('INITIAL', None)
+    if not lexobj.lexerrorf:
+        errorlog.warning('No t_error rule is defined')
+
+    # Set up eof functions
+    lexobj.lexstateeoff = linfo.eoff
+    lexobj.lexeoff = linfo.eoff.get('INITIAL', None)
+
+    # Check state information for ignore and error rules
+    for s, stype in stateinfo.items():
+        if stype == 'exclusive':
+            if s not in linfo.errorf:
+                errorlog.warning("No error rule is defined for exclusive state '%s'", s)
+            if s not in linfo.ignore and lexobj.lexignore:
+                errorlog.warning("No ignore rule is defined for exclusive state '%s'", s)
+        elif stype == 'inclusive':
+            if s not in linfo.errorf:
+                linfo.errorf[s] = linfo.errorf.get('INITIAL', None)
+            if s not in linfo.ignore:
+                linfo.ignore[s] = linfo.ignore.get('INITIAL', '')
+
+    # Create global versions of the token() and input() functions
+    token = lexobj.token
+    input = lexobj.input
+    lexer = lexobj
+
+    # If in optimize mode, we write the lextab
+    if lextab and optimize:
+        if outputdir is None:
+            # If no output directory is set, the location of the output files
+            # is determined according to the following rules:
+            #     - If lextab specifies a package, files go into that package directory
+            #     - Otherwise, files go in the same directory as the specifying module
+            if isinstance(lextab, types.ModuleType):
+                srcfile = lextab.__file__
+            else:
+                if '.' not in lextab:
+                    srcfile = ldict['__file__']
+                else:
+                    parts = lextab.split('.')
+                    pkgname = '.'.join(parts[:-1])
+                    exec('import %s' % pkgname)
+                    srcfile = getattr(sys.modules[pkgname], '__file__', '')
+            outputdir = os.path.dirname(srcfile)
+        try:
+            lexobj.writetab(lextab, outputdir)
+        except IOError as e:
+            errorlog.warning("Couldn't write lextab module %r. %s" % (lextab, e))
+
+    return lexobj
+
+# -----------------------------------------------------------------------------
+# runmain()
+#
+# This runs the lexer as a main program
+# -----------------------------------------------------------------------------
+
+def runmain(lexer=None, data=None):
+    if not data:
+        try:
+            filename = sys.argv[1]
+            f = open(filename)
+            data = f.read()
+            f.close()
+        except IndexError:
+            sys.stdout.write('Reading from standard input (type EOF to end):\n')
+            data = sys.stdin.read()
+
+    if lexer:
+        _input = lexer.input
+    else:
+        _input = input
+    _input(data)
+    if lexer:
+        _token = lexer.token
+    else:
+        _token = token
+
+    while True:
+        tok = _token()
+        if not tok:
+            break
+        sys.stdout.write('(%s,%r,%d,%d)\n' % (tok.type, tok.value, tok.lineno, tok.lexpos))
+
+# -----------------------------------------------------------------------------
+# @TOKEN(regex)
+#
+# This decorator function can be used to set the regex expression on a function
+# when its docstring might need to be set in an alternative way
+# -----------------------------------------------------------------------------
+
+def TOKEN(r):
+    def set_regex(f):
+        if hasattr(r, '__call__'):
+            f.regex = _get_regex(r)
+        else:
+            f.regex = r
+        return f
+    return set_regex
+
+# Alternative spelling of the TOKEN decorator
+Token = TOKEN
diff --git a/myenv/lib/python3.9/site-packages/pycparser/ply/yacc.py b/myenv/lib/python3.9/site-packages/pycparser/ply/yacc.py
new file mode 100644
index 0000000..20b4f28
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/ply/yacc.py
@@ -0,0 +1,3494 @@
+# -----------------------------------------------------------------------------
+# ply: yacc.py
+#
+# Copyright (C) 2001-2017
+# David M. Beazley (Dabeaz LLC)
+# 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 David Beazley or Dabeaz LLC 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 implements an LR parser that is constructed from grammar rules defined
+# as Python functions. The grammer is specified by supplying the BNF inside
+# Python documentation strings.  The inspiration for this technique was borrowed
+# from John Aycock's Spark parsing system.  PLY might be viewed as cross between
+# Spark and the GNU bison utility.
+#
+# The current implementation is only somewhat object-oriented. The
+# LR parser itself is defined in terms of an object (which allows multiple
+# parsers to co-exist).  However, most of the variables used during table
+# construction are defined in terms of global variables.  Users shouldn't
+# notice unless they are trying to define multiple parsers at the same
+# time using threads (in which case they should have their head examined).
+#
+# This implementation supports both SLR and LALR(1) parsing.  LALR(1)
+# support was originally implemented by Elias Ioup (ezioup@alumni.uchicago.edu),
+# using the algorithm found in Aho, Sethi, and Ullman "Compilers: Principles,
+# Techniques, and Tools" (The Dragon Book).  LALR(1) has since been replaced
+# by the more efficient DeRemer and Pennello algorithm.
+#
+# :::::::: WARNING :::::::
+#
+# Construction of LR parsing tables is fairly complicated and expensive.
+# To make this module run fast, a *LOT* of work has been put into
+# optimization---often at the expensive of readability and what might
+# consider to be good Python "coding style."   Modify the code at your
+# own risk!
+# ----------------------------------------------------------------------------
+
+import re
+import types
+import sys
+import os.path
+import inspect
+import base64
+import warnings
+
+__version__    = '3.10'
+__tabversion__ = '3.10'
+
+#-----------------------------------------------------------------------------
+#                     === User configurable parameters ===
+#
+# Change these to modify the default behavior of yacc (if you wish)
+#-----------------------------------------------------------------------------
+
+yaccdebug   = True             # Debugging mode.  If set, yacc generates a
+                               # a 'parser.out' file in the current directory
+
+debug_file  = 'parser.out'     # Default name of the debugging file
+tab_module  = 'parsetab'       # Default name of the table module
+default_lr  = 'LALR'           # Default LR table generation method
+
+error_count = 3                # Number of symbols that must be shifted to leave recovery mode
+
+yaccdevel   = False            # Set to True if developing yacc.  This turns off optimized
+                               # implementations of certain functions.
+
+resultlimit = 40               # Size limit of results when running in debug mode.
+
+pickle_protocol = 0            # Protocol to use when writing pickle files
+
+# String type-checking compatibility
+if sys.version_info[0] < 3:
+    string_types = basestring
+else:
+    string_types = str
+
+MAXINT = sys.maxsize
+
+# This object is a stand-in for a logging object created by the
+# logging module.   PLY will use this by default to create things
+# such as the parser.out file.  If a user wants more detailed
+# information, they can create their own logging object and pass
+# it into PLY.
+
+class PlyLogger(object):
+    def __init__(self, f):
+        self.f = f
+
+    def debug(self, msg, *args, **kwargs):
+        self.f.write((msg % args) + '\n')
+
+    info = debug
+
+    def warning(self, msg, *args, **kwargs):
+        self.f.write('WARNING: ' + (msg % args) + '\n')
+
+    def error(self, msg, *args, **kwargs):
+        self.f.write('ERROR: ' + (msg % args) + '\n')
+
+    critical = debug
+
+# Null logger is used when no output is generated. Does nothing.
+class NullLogger(object):
+    def __getattribute__(self, name):
+        return self
+
+    def __call__(self, *args, **kwargs):
+        return self
+
+# Exception raised for yacc-related errors
+class YaccError(Exception):
+    pass
+
+# Format the result message that the parser produces when running in debug mode.
+def format_result(r):
+    repr_str = repr(r)
+    if '\n' in repr_str:
+        repr_str = repr(repr_str)
+    if len(repr_str) > resultlimit:
+        repr_str = repr_str[:resultlimit] + ' ...'
+    result = '<%s @ 0x%x> (%s)' % (type(r).__name__, id(r), repr_str)
+    return result
+
+# Format stack entries when the parser is running in debug mode
+def format_stack_entry(r):
+    repr_str = repr(r)
+    if '\n' in repr_str:
+        repr_str = repr(repr_str)
+    if len(repr_str) < 16:
+        return repr_str
+    else:
+        return '<%s @ 0x%x>' % (type(r).__name__, id(r))
+
+# Panic mode error recovery support.   This feature is being reworked--much of the
+# code here is to offer a deprecation/backwards compatible transition
+
+_errok = None
+_token = None
+_restart = None
+_warnmsg = '''PLY: Don't use global functions errok(), token(), and restart() in p_error().
+Instead, invoke the methods on the associated parser instance:
+
+    def p_error(p):
+        ...
+        # Use parser.errok(), parser.token(), parser.restart()
+        ...
+
+    parser = yacc.yacc()
+'''
+
+def errok():
+    warnings.warn(_warnmsg)
+    return _errok()
+
+def restart():
+    warnings.warn(_warnmsg)
+    return _restart()
+
+def token():
+    warnings.warn(_warnmsg)
+    return _token()
+
+# Utility function to call the p_error() function with some deprecation hacks
+def call_errorfunc(errorfunc, token, parser):
+    global _errok, _token, _restart
+    _errok = parser.errok
+    _token = parser.token
+    _restart = parser.restart
+    r = errorfunc(token)
+    try:
+        del _errok, _token, _restart
+    except NameError:
+        pass
+    return r
+
+#-----------------------------------------------------------------------------
+#                        ===  LR Parsing Engine ===
+#
+# The following classes are used for the LR parser itself.  These are not
+# used during table construction and are independent of the actual LR
+# table generation algorithm
+#-----------------------------------------------------------------------------
+
+# This class is used to hold non-terminal grammar symbols during parsing.
+# It normally has the following attributes set:
+#        .type       = Grammar symbol type
+#        .value      = Symbol value
+#        .lineno     = Starting line number
+#        .endlineno  = Ending line number (optional, set automatically)
+#        .lexpos     = Starting lex position
+#        .endlexpos  = Ending lex position (optional, set automatically)
+
+class YaccSymbol:
+    def __str__(self):
+        return self.type
+
+    def __repr__(self):
+        return str(self)
+
+# This class is a wrapper around the objects actually passed to each
+# grammar rule.   Index lookup and assignment actually assign the
+# .value attribute of the underlying YaccSymbol object.
+# The lineno() method returns the line number of a given
+# item (or 0 if not defined).   The linespan() method returns
+# a tuple of (startline,endline) representing the range of lines
+# for a symbol.  The lexspan() method returns a tuple (lexpos,endlexpos)
+# representing the range of positional information for a symbol.
+
+class YaccProduction:
+    def __init__(self, s, stack=None):
+        self.slice = s
+        self.stack = stack
+        self.lexer = None
+        self.parser = None
+
+    def __getitem__(self, n):
+        if isinstance(n, slice):
+            return [s.value for s in self.slice[n]]
+        elif n >= 0:
+            return self.slice[n].value
+        else:
+            return self.stack[n].value
+
+    def __setitem__(self, n, v):
+        self.slice[n].value = v
+
+    def __getslice__(self, i, j):
+        return [s.value for s in self.slice[i:j]]
+
+    def __len__(self):
+        return len(self.slice)
+
+    def lineno(self, n):
+        return getattr(self.slice[n], 'lineno', 0)
+
+    def set_lineno(self, n, lineno):
+        self.slice[n].lineno = lineno
+
+    def linespan(self, n):
+        startline = getattr(self.slice[n], 'lineno', 0)
+        endline = getattr(self.slice[n], 'endlineno', startline)
+        return startline, endline
+
+    def lexpos(self, n):
+        return getattr(self.slice[n], 'lexpos', 0)
+
+    def lexspan(self, n):
+        startpos = getattr(self.slice[n], 'lexpos', 0)
+        endpos = getattr(self.slice[n], 'endlexpos', startpos)
+        return startpos, endpos
+
+    def error(self):
+        raise SyntaxError
+
+# -----------------------------------------------------------------------------
+#                               == LRParser ==
+#
+# The LR Parsing engine.
+# -----------------------------------------------------------------------------
+
+class LRParser:
+    def __init__(self, lrtab, errorf):
+        self.productions = lrtab.lr_productions
+        self.action = lrtab.lr_action
+        self.goto = lrtab.lr_goto
+        self.errorfunc = errorf
+        self.set_defaulted_states()
+        self.errorok = True
+
+    def errok(self):
+        self.errorok = True
+
+    def restart(self):
+        del self.statestack[:]
+        del self.symstack[:]
+        sym = YaccSymbol()
+        sym.type = '$end'
+        self.symstack.append(sym)
+        self.statestack.append(0)
+
+    # Defaulted state support.
+    # This method identifies parser states where there is only one possible reduction action.
+    # For such states, the parser can make a choose to make a rule reduction without consuming
+    # the next look-ahead token.  This delayed invocation of the tokenizer can be useful in
+    # certain kinds of advanced parsing situations where the lexer and parser interact with
+    # each other or change states (i.e., manipulation of scope, lexer states, etc.).
+    #
+    # See:  https://www.gnu.org/software/bison/manual/html_node/Default-Reductions.html#Default-Reductions
+    def set_defaulted_states(self):
+        self.defaulted_states = {}
+        for state, actions in self.action.items():
+            rules = list(actions.values())
+            if len(rules) == 1 and rules[0] < 0:
+                self.defaulted_states[state] = rules[0]
+
+    def disable_defaulted_states(self):
+        self.defaulted_states = {}
+
+    def parse(self, input=None, lexer=None, debug=False, tracking=False, tokenfunc=None):
+        if debug or yaccdevel:
+            if isinstance(debug, int):
+                debug = PlyLogger(sys.stderr)
+            return self.parsedebug(input, lexer, debug, tracking, tokenfunc)
+        elif tracking:
+            return self.parseopt(input, lexer, debug, tracking, tokenfunc)
+        else:
+            return self.parseopt_notrack(input, lexer, debug, tracking, tokenfunc)
+
+
+    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+    # parsedebug().
+    #
+    # This is the debugging enabled version of parse().  All changes made to the
+    # parsing engine should be made here.   Optimized versions of this function
+    # are automatically created by the ply/ygen.py script.  This script cuts out
+    # sections enclosed in markers such as this:
+    #
+    #      #--! DEBUG
+    #      statements
+    #      #--! DEBUG
+    #
+    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+    def parsedebug(self, input=None, lexer=None, debug=False, tracking=False, tokenfunc=None):
+        #--! parsedebug-start
+        lookahead = None                         # Current lookahead symbol
+        lookaheadstack = []                      # Stack of lookahead symbols
+        actions = self.action                    # Local reference to action table (to avoid lookup on self.)
+        goto    = self.goto                      # Local reference to goto table (to avoid lookup on self.)
+        prod    = self.productions               # Local reference to production list (to avoid lookup on self.)
+        defaulted_states = self.defaulted_states # Local reference to defaulted states
+        pslice  = YaccProduction(None)           # Production object passed to grammar rules
+        errorcount = 0                           # Used during error recovery
+
+        #--! DEBUG
+        debug.info('PLY: PARSE DEBUG START')
+        #--! DEBUG
+
+        # If no lexer was given, we will try to use the lex module
+        if not lexer:
+            from . import lex
+            lexer = lex.lexer
+
+        # Set up the lexer and parser objects on pslice
+        pslice.lexer = lexer
+        pslice.parser = self
+
+        # If input was supplied, pass to lexer
+        if input is not None:
+            lexer.input(input)
+
+        if tokenfunc is None:
+            # Tokenize function
+            get_token = lexer.token
+        else:
+            get_token = tokenfunc
+
+        # Set the parser() token method (sometimes used in error recovery)
+        self.token = get_token
+
+        # Set up the state and symbol stacks
+
+        statestack = []                # Stack of parsing states
+        self.statestack = statestack
+        symstack   = []                # Stack of grammar symbols
+        self.symstack = symstack
+
+        pslice.stack = symstack         # Put in the production
+        errtoken   = None               # Err token
+
+        # The start state is assumed to be (0,$end)
+
+        statestack.append(0)
+        sym = YaccSymbol()
+        sym.type = '$end'
+        symstack.append(sym)
+        state = 0
+        while True:
+            # Get the next symbol on the input.  If a lookahead symbol
+            # is already set, we just use that. Otherwise, we'll pull
+            # the next token off of the lookaheadstack or from the lexer
+
+            #--! DEBUG
+            debug.debug('')
+            debug.debug('State  : %s', state)
+            #--! DEBUG
+
+            if state not in defaulted_states:
+                if not lookahead:
+                    if not lookaheadstack:
+                        lookahead = get_token()     # Get the next token
+                    else:
+                        lookahead = lookaheadstack.pop()
+                    if not lookahead:
+                        lookahead = YaccSymbol()
+                        lookahead.type = '$end'
+
+                # Check the action table
+                ltype = lookahead.type
+                t = actions[state].get(ltype)
+            else:
+                t = defaulted_states[state]
+                #--! DEBUG
+                debug.debug('Defaulted state %s: Reduce using %d', state, -t)
+                #--! DEBUG
+
+            #--! DEBUG
+            debug.debug('Stack  : %s',
+                        ('%s . %s' % (' '.join([xx.type for xx in symstack][1:]), str(lookahead))).lstrip())
+            #--! DEBUG
+
+            if t is not None:
+                if t > 0:
+                    # shift a symbol on the stack
+                    statestack.append(t)
+                    state = t
+
+                    #--! DEBUG
+                    debug.debug('Action : Shift and goto state %s', t)
+                    #--! DEBUG
+
+                    symstack.append(lookahead)
+                    lookahead = None
+
+                    # Decrease error count on successful shift
+                    if errorcount:
+                        errorcount -= 1
+                    continue
+
+                if t < 0:
+                    # reduce a symbol on the stack, emit a production
+                    p = prod[-t]
+                    pname = p.name
+                    plen  = p.len
+
+                    # Get production function
+                    sym = YaccSymbol()
+                    sym.type = pname       # Production name
+                    sym.value = None
+
+                    #--! DEBUG
+                    if plen:
+                        debug.info('Action : Reduce rule [%s] with %s and goto state %d', p.str,
+                                   '['+','.join([format_stack_entry(_v.value) for _v in symstack[-plen:]])+']',
+                                   goto[statestack[-1-plen]][pname])
+                    else:
+                        debug.info('Action : Reduce rule [%s] with %s and goto state %d', p.str, [],
+                                   goto[statestack[-1]][pname])
+
+                    #--! DEBUG
+
+                    if plen:
+                        targ = symstack[-plen-1:]
+                        targ[0] = sym
+
+                        #--! TRACKING
+                        if tracking:
+                            t1 = targ[1]
+                            sym.lineno = t1.lineno
+                            sym.lexpos = t1.lexpos
+                            t1 = targ[-1]
+                            sym.endlineno = getattr(t1, 'endlineno', t1.lineno)
+                            sym.endlexpos = getattr(t1, 'endlexpos', t1.lexpos)
+                        #--! TRACKING
+
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                        # The code enclosed in this section is duplicated
+                        # below as a performance optimization.  Make sure
+                        # changes get made in both locations.
+
+                        pslice.slice = targ
+
+                        try:
+                            # Call the grammar rule with our special slice object
+                            del symstack[-plen:]
+                            self.state = state
+                            p.callable(pslice)
+                            del statestack[-plen:]
+                            #--! DEBUG
+                            debug.info('Result : %s', format_result(pslice[0]))
+                            #--! DEBUG
+                            symstack.append(sym)
+                            state = goto[statestack[-1]][pname]
+                            statestack.append(state)
+                        except SyntaxError:
+                            # If an error was set. Enter error recovery state
+                            lookaheadstack.append(lookahead)    # Save the current lookahead token
+                            symstack.extend(targ[1:-1])         # Put the production slice back on the stack
+                            statestack.pop()                    # Pop back one state (before the reduce)
+                            state = statestack[-1]
+                            sym.type = 'error'
+                            sym.value = 'error'
+                            lookahead = sym
+                            errorcount = error_count
+                            self.errorok = False
+
+                        continue
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+                    else:
+
+                        #--! TRACKING
+                        if tracking:
+                            sym.lineno = lexer.lineno
+                            sym.lexpos = lexer.lexpos
+                        #--! TRACKING
+
+                        targ = [sym]
+
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                        # The code enclosed in this section is duplicated
+                        # above as a performance optimization.  Make sure
+                        # changes get made in both locations.
+
+                        pslice.slice = targ
+
+                        try:
+                            # Call the grammar rule with our special slice object
+                            self.state = state
+                            p.callable(pslice)
+                            #--! DEBUG
+                            debug.info('Result : %s', format_result(pslice[0]))
+                            #--! DEBUG
+                            symstack.append(sym)
+                            state = goto[statestack[-1]][pname]
+                            statestack.append(state)
+                        except SyntaxError:
+                            # If an error was set. Enter error recovery state
+                            lookaheadstack.append(lookahead)    # Save the current lookahead token
+                            statestack.pop()                    # Pop back one state (before the reduce)
+                            state = statestack[-1]
+                            sym.type = 'error'
+                            sym.value = 'error'
+                            lookahead = sym
+                            errorcount = error_count
+                            self.errorok = False
+
+                        continue
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+                if t == 0:
+                    n = symstack[-1]
+                    result = getattr(n, 'value', None)
+                    #--! DEBUG
+                    debug.info('Done   : Returning %s', format_result(result))
+                    debug.info('PLY: PARSE DEBUG END')
+                    #--! DEBUG
+                    return result
+
+            if t is None:
+
+                #--! DEBUG
+                debug.error('Error  : %s',
+                            ('%s . %s' % (' '.join([xx.type for xx in symstack][1:]), str(lookahead))).lstrip())
+                #--! DEBUG
+
+                # We have some kind of parsing error here.  To handle
+                # this, we are going to push the current token onto
+                # the tokenstack and replace it with an 'error' token.
+                # If there are any synchronization rules, they may
+                # catch it.
+                #
+                # In addition to pushing the error token, we call call
+                # the user defined p_error() function if this is the
+                # first syntax error.  This function is only called if
+                # errorcount == 0.
+                if errorcount == 0 or self.errorok:
+                    errorcount = error_count
+                    self.errorok = False
+                    errtoken = lookahead
+                    if errtoken.type == '$end':
+                        errtoken = None               # End of file!
+                    if self.errorfunc:
+                        if errtoken and not hasattr(errtoken, 'lexer'):
+                            errtoken.lexer = lexer
+                        self.state = state
+                        tok = call_errorfunc(self.errorfunc, errtoken, self)
+                        if self.errorok:
+                            # User must have done some kind of panic
+                            # mode recovery on their own.  The
+                            # returned token is the next lookahead
+                            lookahead = tok
+                            errtoken = None
+                            continue
+                    else:
+                        if errtoken:
+                            if hasattr(errtoken, 'lineno'):
+                                lineno = lookahead.lineno
+                            else:
+                                lineno = 0
+                            if lineno:
+                                sys.stderr.write('yacc: Syntax error at line %d, token=%s\n' % (lineno, errtoken.type))
+                            else:
+                                sys.stderr.write('yacc: Syntax error, token=%s' % errtoken.type)
+                        else:
+                            sys.stderr.write('yacc: Parse error in input. EOF\n')
+                            return
+
+                else:
+                    errorcount = error_count
+
+                # case 1:  the statestack only has 1 entry on it.  If we're in this state, the
+                # entire parse has been rolled back and we're completely hosed.   The token is
+                # discarded and we just keep going.
+
+                if len(statestack) <= 1 and lookahead.type != '$end':
+                    lookahead = None
+                    errtoken = None
+                    state = 0
+                    # Nuke the pushback stack
+                    del lookaheadstack[:]
+                    continue
+
+                # case 2: the statestack has a couple of entries on it, but we're
+                # at the end of the file. nuke the top entry and generate an error token
+
+                # Start nuking entries on the stack
+                if lookahead.type == '$end':
+                    # Whoa. We're really hosed here. Bail out
+                    return
+
+                if lookahead.type != 'error':
+                    sym = symstack[-1]
+                    if sym.type == 'error':
+                        # Hmmm. Error is on top of stack, we'll just nuke input
+                        # symbol and continue
+                        #--! TRACKING
+                        if tracking:
+                            sym.endlineno = getattr(lookahead, 'lineno', sym.lineno)
+                            sym.endlexpos = getattr(lookahead, 'lexpos', sym.lexpos)
+                        #--! TRACKING
+                        lookahead = None
+                        continue
+
+                    # Create the error symbol for the first time and make it the new lookahead symbol
+                    t = YaccSymbol()
+                    t.type = 'error'
+
+                    if hasattr(lookahead, 'lineno'):
+                        t.lineno = t.endlineno = lookahead.lineno
+                    if hasattr(lookahead, 'lexpos'):
+                        t.lexpos = t.endlexpos = lookahead.lexpos
+                    t.value = lookahead
+                    lookaheadstack.append(lookahead)
+                    lookahead = t
+                else:
+                    sym = symstack.pop()
+                    #--! TRACKING
+                    if tracking:
+                        lookahead.lineno = sym.lineno
+                        lookahead.lexpos = sym.lexpos
+                    #--! TRACKING
+                    statestack.pop()
+                    state = statestack[-1]
+
+                continue
+
+            # Call an error function here
+            raise RuntimeError('yacc: internal parser error!!!\n')
+
+        #--! parsedebug-end
+
+    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+    # parseopt().
+    #
+    # Optimized version of parse() method.  DO NOT EDIT THIS CODE DIRECTLY!
+    # This code is automatically generated by the ply/ygen.py script. Make
+    # changes to the parsedebug() method instead.
+    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+    def parseopt(self, input=None, lexer=None, debug=False, tracking=False, tokenfunc=None):
+        #--! parseopt-start
+        lookahead = None                         # Current lookahead symbol
+        lookaheadstack = []                      # Stack of lookahead symbols
+        actions = self.action                    # Local reference to action table (to avoid lookup on self.)
+        goto    = self.goto                      # Local reference to goto table (to avoid lookup on self.)
+        prod    = self.productions               # Local reference to production list (to avoid lookup on self.)
+        defaulted_states = self.defaulted_states # Local reference to defaulted states
+        pslice  = YaccProduction(None)           # Production object passed to grammar rules
+        errorcount = 0                           # Used during error recovery
+
+
+        # If no lexer was given, we will try to use the lex module
+        if not lexer:
+            from . import lex
+            lexer = lex.lexer
+
+        # Set up the lexer and parser objects on pslice
+        pslice.lexer = lexer
+        pslice.parser = self
+
+        # If input was supplied, pass to lexer
+        if input is not None:
+            lexer.input(input)
+
+        if tokenfunc is None:
+            # Tokenize function
+            get_token = lexer.token
+        else:
+            get_token = tokenfunc
+
+        # Set the parser() token method (sometimes used in error recovery)
+        self.token = get_token
+
+        # Set up the state and symbol stacks
+
+        statestack = []                # Stack of parsing states
+        self.statestack = statestack
+        symstack   = []                # Stack of grammar symbols
+        self.symstack = symstack
+
+        pslice.stack = symstack         # Put in the production
+        errtoken   = None               # Err token
+
+        # The start state is assumed to be (0,$end)
+
+        statestack.append(0)
+        sym = YaccSymbol()
+        sym.type = '$end'
+        symstack.append(sym)
+        state = 0
+        while True:
+            # Get the next symbol on the input.  If a lookahead symbol
+            # is already set, we just use that. Otherwise, we'll pull
+            # the next token off of the lookaheadstack or from the lexer
+
+
+            if state not in defaulted_states:
+                if not lookahead:
+                    if not lookaheadstack:
+                        lookahead = get_token()     # Get the next token
+                    else:
+                        lookahead = lookaheadstack.pop()
+                    if not lookahead:
+                        lookahead = YaccSymbol()
+                        lookahead.type = '$end'
+
+                # Check the action table
+                ltype = lookahead.type
+                t = actions[state].get(ltype)
+            else:
+                t = defaulted_states[state]
+
+
+            if t is not None:
+                if t > 0:
+                    # shift a symbol on the stack
+                    statestack.append(t)
+                    state = t
+
+
+                    symstack.append(lookahead)
+                    lookahead = None
+
+                    # Decrease error count on successful shift
+                    if errorcount:
+                        errorcount -= 1
+                    continue
+
+                if t < 0:
+                    # reduce a symbol on the stack, emit a production
+                    p = prod[-t]
+                    pname = p.name
+                    plen  = p.len
+
+                    # Get production function
+                    sym = YaccSymbol()
+                    sym.type = pname       # Production name
+                    sym.value = None
+
+
+                    if plen:
+                        targ = symstack[-plen-1:]
+                        targ[0] = sym
+
+                        #--! TRACKING
+                        if tracking:
+                            t1 = targ[1]
+                            sym.lineno = t1.lineno
+                            sym.lexpos = t1.lexpos
+                            t1 = targ[-1]
+                            sym.endlineno = getattr(t1, 'endlineno', t1.lineno)
+                            sym.endlexpos = getattr(t1, 'endlexpos', t1.lexpos)
+                        #--! TRACKING
+
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                        # The code enclosed in this section is duplicated
+                        # below as a performance optimization.  Make sure
+                        # changes get made in both locations.
+
+                        pslice.slice = targ
+
+                        try:
+                            # Call the grammar rule with our special slice object
+                            del symstack[-plen:]
+                            self.state = state
+                            p.callable(pslice)
+                            del statestack[-plen:]
+                            symstack.append(sym)
+                            state = goto[statestack[-1]][pname]
+                            statestack.append(state)
+                        except SyntaxError:
+                            # If an error was set. Enter error recovery state
+                            lookaheadstack.append(lookahead)    # Save the current lookahead token
+                            symstack.extend(targ[1:-1])         # Put the production slice back on the stack
+                            statestack.pop()                    # Pop back one state (before the reduce)
+                            state = statestack[-1]
+                            sym.type = 'error'
+                            sym.value = 'error'
+                            lookahead = sym
+                            errorcount = error_count
+                            self.errorok = False
+
+                        continue
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+                    else:
+
+                        #--! TRACKING
+                        if tracking:
+                            sym.lineno = lexer.lineno
+                            sym.lexpos = lexer.lexpos
+                        #--! TRACKING
+
+                        targ = [sym]
+
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                        # The code enclosed in this section is duplicated
+                        # above as a performance optimization.  Make sure
+                        # changes get made in both locations.
+
+                        pslice.slice = targ
+
+                        try:
+                            # Call the grammar rule with our special slice object
+                            self.state = state
+                            p.callable(pslice)
+                            symstack.append(sym)
+                            state = goto[statestack[-1]][pname]
+                            statestack.append(state)
+                        except SyntaxError:
+                            # If an error was set. Enter error recovery state
+                            lookaheadstack.append(lookahead)    # Save the current lookahead token
+                            statestack.pop()                    # Pop back one state (before the reduce)
+                            state = statestack[-1]
+                            sym.type = 'error'
+                            sym.value = 'error'
+                            lookahead = sym
+                            errorcount = error_count
+                            self.errorok = False
+
+                        continue
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+                if t == 0:
+                    n = symstack[-1]
+                    result = getattr(n, 'value', None)
+                    return result
+
+            if t is None:
+
+
+                # We have some kind of parsing error here.  To handle
+                # this, we are going to push the current token onto
+                # the tokenstack and replace it with an 'error' token.
+                # If there are any synchronization rules, they may
+                # catch it.
+                #
+                # In addition to pushing the error token, we call call
+                # the user defined p_error() function if this is the
+                # first syntax error.  This function is only called if
+                # errorcount == 0.
+                if errorcount == 0 or self.errorok:
+                    errorcount = error_count
+                    self.errorok = False
+                    errtoken = lookahead
+                    if errtoken.type == '$end':
+                        errtoken = None               # End of file!
+                    if self.errorfunc:
+                        if errtoken and not hasattr(errtoken, 'lexer'):
+                            errtoken.lexer = lexer
+                        self.state = state
+                        tok = call_errorfunc(self.errorfunc, errtoken, self)
+                        if self.errorok:
+                            # User must have done some kind of panic
+                            # mode recovery on their own.  The
+                            # returned token is the next lookahead
+                            lookahead = tok
+                            errtoken = None
+                            continue
+                    else:
+                        if errtoken:
+                            if hasattr(errtoken, 'lineno'):
+                                lineno = lookahead.lineno
+                            else:
+                                lineno = 0
+                            if lineno:
+                                sys.stderr.write('yacc: Syntax error at line %d, token=%s\n' % (lineno, errtoken.type))
+                            else:
+                                sys.stderr.write('yacc: Syntax error, token=%s' % errtoken.type)
+                        else:
+                            sys.stderr.write('yacc: Parse error in input. EOF\n')
+                            return
+
+                else:
+                    errorcount = error_count
+
+                # case 1:  the statestack only has 1 entry on it.  If we're in this state, the
+                # entire parse has been rolled back and we're completely hosed.   The token is
+                # discarded and we just keep going.
+
+                if len(statestack) <= 1 and lookahead.type != '$end':
+                    lookahead = None
+                    errtoken = None
+                    state = 0
+                    # Nuke the pushback stack
+                    del lookaheadstack[:]
+                    continue
+
+                # case 2: the statestack has a couple of entries on it, but we're
+                # at the end of the file. nuke the top entry and generate an error token
+
+                # Start nuking entries on the stack
+                if lookahead.type == '$end':
+                    # Whoa. We're really hosed here. Bail out
+                    return
+
+                if lookahead.type != 'error':
+                    sym = symstack[-1]
+                    if sym.type == 'error':
+                        # Hmmm. Error is on top of stack, we'll just nuke input
+                        # symbol and continue
+                        #--! TRACKING
+                        if tracking:
+                            sym.endlineno = getattr(lookahead, 'lineno', sym.lineno)
+                            sym.endlexpos = getattr(lookahead, 'lexpos', sym.lexpos)
+                        #--! TRACKING
+                        lookahead = None
+                        continue
+
+                    # Create the error symbol for the first time and make it the new lookahead symbol
+                    t = YaccSymbol()
+                    t.type = 'error'
+
+                    if hasattr(lookahead, 'lineno'):
+                        t.lineno = t.endlineno = lookahead.lineno
+                    if hasattr(lookahead, 'lexpos'):
+                        t.lexpos = t.endlexpos = lookahead.lexpos
+                    t.value = lookahead
+                    lookaheadstack.append(lookahead)
+                    lookahead = t
+                else:
+                    sym = symstack.pop()
+                    #--! TRACKING
+                    if tracking:
+                        lookahead.lineno = sym.lineno
+                        lookahead.lexpos = sym.lexpos
+                    #--! TRACKING
+                    statestack.pop()
+                    state = statestack[-1]
+
+                continue
+
+            # Call an error function here
+            raise RuntimeError('yacc: internal parser error!!!\n')
+
+        #--! parseopt-end
+
+    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+    # parseopt_notrack().
+    #
+    # Optimized version of parseopt() with line number tracking removed.
+    # DO NOT EDIT THIS CODE DIRECTLY. This code is automatically generated
+    # by the ply/ygen.py script. Make changes to the parsedebug() method instead.
+    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+    def parseopt_notrack(self, input=None, lexer=None, debug=False, tracking=False, tokenfunc=None):
+        #--! parseopt-notrack-start
+        lookahead = None                         # Current lookahead symbol
+        lookaheadstack = []                      # Stack of lookahead symbols
+        actions = self.action                    # Local reference to action table (to avoid lookup on self.)
+        goto    = self.goto                      # Local reference to goto table (to avoid lookup on self.)
+        prod    = self.productions               # Local reference to production list (to avoid lookup on self.)
+        defaulted_states = self.defaulted_states # Local reference to defaulted states
+        pslice  = YaccProduction(None)           # Production object passed to grammar rules
+        errorcount = 0                           # Used during error recovery
+
+
+        # If no lexer was given, we will try to use the lex module
+        if not lexer:
+            from . import lex
+            lexer = lex.lexer
+
+        # Set up the lexer and parser objects on pslice
+        pslice.lexer = lexer
+        pslice.parser = self
+
+        # If input was supplied, pass to lexer
+        if input is not None:
+            lexer.input(input)
+
+        if tokenfunc is None:
+            # Tokenize function
+            get_token = lexer.token
+        else:
+            get_token = tokenfunc
+
+        # Set the parser() token method (sometimes used in error recovery)
+        self.token = get_token
+
+        # Set up the state and symbol stacks
+
+        statestack = []                # Stack of parsing states
+        self.statestack = statestack
+        symstack   = []                # Stack of grammar symbols
+        self.symstack = symstack
+
+        pslice.stack = symstack         # Put in the production
+        errtoken   = None               # Err token
+
+        # The start state is assumed to be (0,$end)
+
+        statestack.append(0)
+        sym = YaccSymbol()
+        sym.type = '$end'
+        symstack.append(sym)
+        state = 0
+        while True:
+            # Get the next symbol on the input.  If a lookahead symbol
+            # is already set, we just use that. Otherwise, we'll pull
+            # the next token off of the lookaheadstack or from the lexer
+
+
+            if state not in defaulted_states:
+                if not lookahead:
+                    if not lookaheadstack:
+                        lookahead = get_token()     # Get the next token
+                    else:
+                        lookahead = lookaheadstack.pop()
+                    if not lookahead:
+                        lookahead = YaccSymbol()
+                        lookahead.type = '$end'
+
+                # Check the action table
+                ltype = lookahead.type
+                t = actions[state].get(ltype)
+            else:
+                t = defaulted_states[state]
+
+
+            if t is not None:
+                if t > 0:
+                    # shift a symbol on the stack
+                    statestack.append(t)
+                    state = t
+
+
+                    symstack.append(lookahead)
+                    lookahead = None
+
+                    # Decrease error count on successful shift
+                    if errorcount:
+                        errorcount -= 1
+                    continue
+
+                if t < 0:
+                    # reduce a symbol on the stack, emit a production
+                    p = prod[-t]
+                    pname = p.name
+                    plen  = p.len
+
+                    # Get production function
+                    sym = YaccSymbol()
+                    sym.type = pname       # Production name
+                    sym.value = None
+
+
+                    if plen:
+                        targ = symstack[-plen-1:]
+                        targ[0] = sym
+
+
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                        # The code enclosed in this section is duplicated
+                        # below as a performance optimization.  Make sure
+                        # changes get made in both locations.
+
+                        pslice.slice = targ
+
+                        try:
+                            # Call the grammar rule with our special slice object
+                            del symstack[-plen:]
+                            self.state = state
+                            p.callable(pslice)
+                            del statestack[-plen:]
+                            symstack.append(sym)
+                            state = goto[statestack[-1]][pname]
+                            statestack.append(state)
+                        except SyntaxError:
+                            # If an error was set. Enter error recovery state
+                            lookaheadstack.append(lookahead)    # Save the current lookahead token
+                            symstack.extend(targ[1:-1])         # Put the production slice back on the stack
+                            statestack.pop()                    # Pop back one state (before the reduce)
+                            state = statestack[-1]
+                            sym.type = 'error'
+                            sym.value = 'error'
+                            lookahead = sym
+                            errorcount = error_count
+                            self.errorok = False
+
+                        continue
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+                    else:
+
+
+                        targ = [sym]
+
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                        # The code enclosed in this section is duplicated
+                        # above as a performance optimization.  Make sure
+                        # changes get made in both locations.
+
+                        pslice.slice = targ
+
+                        try:
+                            # Call the grammar rule with our special slice object
+                            self.state = state
+                            p.callable(pslice)
+                            symstack.append(sym)
+                            state = goto[statestack[-1]][pname]
+                            statestack.append(state)
+                        except SyntaxError:
+                            # If an error was set. Enter error recovery state
+                            lookaheadstack.append(lookahead)    # Save the current lookahead token
+                            statestack.pop()                    # Pop back one state (before the reduce)
+                            state = statestack[-1]
+                            sym.type = 'error'
+                            sym.value = 'error'
+                            lookahead = sym
+                            errorcount = error_count
+                            self.errorok = False
+
+                        continue
+                        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+                if t == 0:
+                    n = symstack[-1]
+                    result = getattr(n, 'value', None)
+                    return result
+
+            if t is None:
+
+
+                # We have some kind of parsing error here.  To handle
+                # this, we are going to push the current token onto
+                # the tokenstack and replace it with an 'error' token.
+                # If there are any synchronization rules, they may
+                # catch it.
+                #
+                # In addition to pushing the error token, we call call
+                # the user defined p_error() function if this is the
+                # first syntax error.  This function is only called if
+                # errorcount == 0.
+                if errorcount == 0 or self.errorok:
+                    errorcount = error_count
+                    self.errorok = False
+                    errtoken = lookahead
+                    if errtoken.type == '$end':
+                        errtoken = None               # End of file!
+                    if self.errorfunc:
+                        if errtoken and not hasattr(errtoken, 'lexer'):
+                            errtoken.lexer = lexer
+                        self.state = state
+                        tok = call_errorfunc(self.errorfunc, errtoken, self)
+                        if self.errorok:
+                            # User must have done some kind of panic
+                            # mode recovery on their own.  The
+                            # returned token is the next lookahead
+                            lookahead = tok
+                            errtoken = None
+                            continue
+                    else:
+                        if errtoken:
+                            if hasattr(errtoken, 'lineno'):
+                                lineno = lookahead.lineno
+                            else:
+                                lineno = 0
+                            if lineno:
+                                sys.stderr.write('yacc: Syntax error at line %d, token=%s\n' % (lineno, errtoken.type))
+                            else:
+                                sys.stderr.write('yacc: Syntax error, token=%s' % errtoken.type)
+                        else:
+                            sys.stderr.write('yacc: Parse error in input. EOF\n')
+                            return
+
+                else:
+                    errorcount = error_count
+
+                # case 1:  the statestack only has 1 entry on it.  If we're in this state, the
+                # entire parse has been rolled back and we're completely hosed.   The token is
+                # discarded and we just keep going.
+
+                if len(statestack) <= 1 and lookahead.type != '$end':
+                    lookahead = None
+                    errtoken = None
+                    state = 0
+                    # Nuke the pushback stack
+                    del lookaheadstack[:]
+                    continue
+
+                # case 2: the statestack has a couple of entries on it, but we're
+                # at the end of the file. nuke the top entry and generate an error token
+
+                # Start nuking entries on the stack
+                if lookahead.type == '$end':
+                    # Whoa. We're really hosed here. Bail out
+                    return
+
+                if lookahead.type != 'error':
+                    sym = symstack[-1]
+                    if sym.type == 'error':
+                        # Hmmm. Error is on top of stack, we'll just nuke input
+                        # symbol and continue
+                        lookahead = None
+                        continue
+
+                    # Create the error symbol for the first time and make it the new lookahead symbol
+                    t = YaccSymbol()
+                    t.type = 'error'
+
+                    if hasattr(lookahead, 'lineno'):
+                        t.lineno = t.endlineno = lookahead.lineno
+                    if hasattr(lookahead, 'lexpos'):
+                        t.lexpos = t.endlexpos = lookahead.lexpos
+                    t.value = lookahead
+                    lookaheadstack.append(lookahead)
+                    lookahead = t
+                else:
+                    sym = symstack.pop()
+                    statestack.pop()
+                    state = statestack[-1]
+
+                continue
+
+            # Call an error function here
+            raise RuntimeError('yacc: internal parser error!!!\n')
+
+        #--! parseopt-notrack-end
+
+# -----------------------------------------------------------------------------
+#                          === Grammar Representation ===
+#
+# The following functions, classes, and variables are used to represent and
+# manipulate the rules that make up a grammar.
+# -----------------------------------------------------------------------------
+
+# regex matching identifiers
+_is_identifier = re.compile(r'^[a-zA-Z0-9_-]+$')
+
+# -----------------------------------------------------------------------------
+# class Production:
+#
+# This class stores the raw information about a single production or grammar rule.
+# A grammar rule refers to a specification such as this:
+#
+#       expr : expr PLUS term
+#
+# Here are the basic attributes defined on all productions
+#
+#       name     - Name of the production.  For example 'expr'
+#       prod     - A list of symbols on the right side ['expr','PLUS','term']
+#       prec     - Production precedence level
+#       number   - Production number.
+#       func     - Function that executes on reduce
+#       file     - File where production function is defined
+#       lineno   - Line number where production function is defined
+#
+# The following attributes are defined or optional.
+#
+#       len       - Length of the production (number of symbols on right hand side)
+#       usyms     - Set of unique symbols found in the production
+# -----------------------------------------------------------------------------
+
+class Production(object):
+    reduced = 0
+    def __init__(self, number, name, prod, precedence=('right', 0), func=None, file='', line=0):
+        self.name     = name
+        self.prod     = tuple(prod)
+        self.number   = number
+        self.func     = func
+        self.callable = None
+        self.file     = file
+        self.line     = line
+        self.prec     = precedence
+
+        # Internal settings used during table construction
+
+        self.len  = len(self.prod)   # Length of the production
+
+        # Create a list of unique production symbols used in the production
+        self.usyms = []
+        for s in self.prod:
+            if s not in self.usyms:
+                self.usyms.append(s)
+
+        # List of all LR items for the production
+        self.lr_items = []
+        self.lr_next = None
+
+        # Create a string representation
+        if self.prod:
+            self.str = '%s -> %s' % (self.name, ' '.join(self.prod))
+        else:
+            self.str = '%s -> <empty>' % self.name
+
+    def __str__(self):
+        return self.str
+
+    def __repr__(self):
+        return 'Production(' + str(self) + ')'
+
+    def __len__(self):
+        return len(self.prod)
+
+    def __nonzero__(self):
+        return 1
+
+    def __getitem__(self, index):
+        return self.prod[index]
+
+    # Return the nth lr_item from the production (or None if at the end)
+    def lr_item(self, n):
+        if n > len(self.prod):
+            return None
+        p = LRItem(self, n)
+        # Precompute the list of productions immediately following.
+        try:
+            p.lr_after = Prodnames[p.prod[n+1]]
+        except (IndexError, KeyError):
+            p.lr_after = []
+        try:
+            p.lr_before = p.prod[n-1]
+        except IndexError:
+            p.lr_before = None
+        return p
+
+    # Bind the production function name to a callable
+    def bind(self, pdict):
+        if self.func:
+            self.callable = pdict[self.func]
+
+# This class serves as a minimal standin for Production objects when
+# reading table data from files.   It only contains information
+# actually used by the LR parsing engine, plus some additional
+# debugging information.
+class MiniProduction(object):
+    def __init__(self, str, name, len, func, file, line):
+        self.name     = name
+        self.len      = len
+        self.func     = func
+        self.callable = None
+        self.file     = file
+        self.line     = line
+        self.str      = str
+
+    def __str__(self):
+        return self.str
+
+    def __repr__(self):
+        return 'MiniProduction(%s)' % self.str
+
+    # Bind the production function name to a callable
+    def bind(self, pdict):
+        if self.func:
+            self.callable = pdict[self.func]
+
+
+# -----------------------------------------------------------------------------
+# class LRItem
+#
+# This class represents a specific stage of parsing a production rule.  For
+# example:
+#
+#       expr : expr . PLUS term
+#
+# In the above, the "." represents the current location of the parse.  Here
+# basic attributes:
+#
+#       name       - Name of the production.  For example 'expr'
+#       prod       - A list of symbols on the right side ['expr','.', 'PLUS','term']
+#       number     - Production number.
+#
+#       lr_next      Next LR item. Example, if we are ' expr -> expr . PLUS term'
+#                    then lr_next refers to 'expr -> expr PLUS . term'
+#       lr_index   - LR item index (location of the ".") in the prod list.
+#       lookaheads - LALR lookahead symbols for this item
+#       len        - Length of the production (number of symbols on right hand side)
+#       lr_after    - List of all productions that immediately follow
+#       lr_before   - Grammar symbol immediately before
+# -----------------------------------------------------------------------------
+
+class LRItem(object):
+    def __init__(self, p, n):
+        self.name       = p.name
+        self.prod       = list(p.prod)
+        self.number     = p.number
+        self.lr_index   = n
+        self.lookaheads = {}
+        self.prod.insert(n, '.')
+        self.prod       = tuple(self.prod)
+        self.len        = len(self.prod)
+        self.usyms      = p.usyms
+
+    def __str__(self):
+        if self.prod:
+            s = '%s -> %s' % (self.name, ' '.join(self.prod))
+        else:
+            s = '%s -> <empty>' % self.name
+        return s
+
+    def __repr__(self):
+        return 'LRItem(' + str(self) + ')'
+
+# -----------------------------------------------------------------------------
+# rightmost_terminal()
+#
+# Return the rightmost terminal from a list of symbols.  Used in add_production()
+# -----------------------------------------------------------------------------
+def rightmost_terminal(symbols, terminals):
+    i = len(symbols) - 1
+    while i >= 0:
+        if symbols[i] in terminals:
+            return symbols[i]
+        i -= 1
+    return None
+
+# -----------------------------------------------------------------------------
+#                           === GRAMMAR CLASS ===
+#
+# The following class represents the contents of the specified grammar along
+# with various computed properties such as first sets, follow sets, LR items, etc.
+# This data is used for critical parts of the table generation process later.
+# -----------------------------------------------------------------------------
+
+class GrammarError(YaccError):
+    pass
+
+class Grammar(object):
+    def __init__(self, terminals):
+        self.Productions  = [None]  # A list of all of the productions.  The first
+                                    # entry is always reserved for the purpose of
+                                    # building an augmented grammar
+
+        self.Prodnames    = {}      # A dictionary mapping the names of nonterminals to a list of all
+                                    # productions of that nonterminal.
+
+        self.Prodmap      = {}      # A dictionary that is only used to detect duplicate
+                                    # productions.
+
+        self.Terminals    = {}      # A dictionary mapping the names of terminal symbols to a
+                                    # list of the rules where they are used.
+
+        for term in terminals:
+            self.Terminals[term] = []
+
+        self.Terminals['error'] = []
+
+        self.Nonterminals = {}      # A dictionary mapping names of nonterminals to a list
+                                    # of rule numbers where they are used.
+
+        self.First        = {}      # A dictionary of precomputed FIRST(x) symbols
+
+        self.Follow       = {}      # A dictionary of precomputed FOLLOW(x) symbols
+
+        self.Precedence   = {}      # Precedence rules for each terminal. Contains tuples of the
+                                    # form ('right',level) or ('nonassoc', level) or ('left',level)
+
+        self.UsedPrecedence = set() # Precedence rules that were actually used by the grammer.
+                                    # This is only used to provide error checking and to generate
+                                    # a warning about unused precedence rules.
+
+        self.Start = None           # Starting symbol for the grammar
+
+
+    def __len__(self):
+        return len(self.Productions)
+
+    def __getitem__(self, index):
+        return self.Productions[index]
+
+    # -----------------------------------------------------------------------------
+    # set_precedence()
+    #
+    # Sets the precedence for a given terminal. assoc is the associativity such as
+    # 'left','right', or 'nonassoc'.  level is a numeric level.
+    #
+    # -----------------------------------------------------------------------------
+
+    def set_precedence(self, term, assoc, level):
+        assert self.Productions == [None], 'Must call set_precedence() before add_production()'
+        if term in self.Precedence:
+            raise GrammarError('Precedence already specified for terminal %r' % term)
+        if assoc not in ['left', 'right', 'nonassoc']:
+            raise GrammarError("Associativity must be one of 'left','right', or 'nonassoc'")
+        self.Precedence[term] = (assoc, level)
+
+    # -----------------------------------------------------------------------------
+    # add_production()
+    #
+    # Given an action function, this function assembles a production rule and
+    # computes its precedence level.
+    #
+    # The production rule is supplied as a list of symbols.   For example,
+    # a rule such as 'expr : expr PLUS term' has a production name of 'expr' and
+    # symbols ['expr','PLUS','term'].
+    #
+    # Precedence is determined by the precedence of the right-most non-terminal
+    # or the precedence of a terminal specified by %prec.
+    #
+    # A variety of error checks are performed to make sure production symbols
+    # are valid and that %prec is used correctly.
+    # -----------------------------------------------------------------------------
+
+    def add_production(self, prodname, syms, func=None, file='', line=0):
+
+        if prodname in self.Terminals:
+            raise GrammarError('%s:%d: Illegal rule name %r. Already defined as a token' % (file, line, prodname))
+        if prodname == 'error':
+            raise GrammarError('%s:%d: Illegal rule name %r. error is a reserved word' % (file, line, prodname))
+        if not _is_identifier.match(prodname):
+            raise GrammarError('%s:%d: Illegal rule name %r' % (file, line, prodname))
+
+        # Look for literal tokens
+        for n, s in enumerate(syms):
+            if s[0] in "'\"":
+                try:
+                    c = eval(s)
+                    if (len(c) > 1):
+                        raise GrammarError('%s:%d: Literal token %s in rule %r may only be a single character' %
+                                           (file, line, s, prodname))
+                    if c not in self.Terminals:
+                        self.Terminals[c] = []
+                    syms[n] = c
+                    continue
+                except SyntaxError:
+                    pass
+            if not _is_identifier.match(s) and s != '%prec':
+                raise GrammarError('%s:%d: Illegal name %r in rule %r' % (file, line, s, prodname))
+
+        # Determine the precedence level
+        if '%prec' in syms:
+            if syms[-1] == '%prec':
+                raise GrammarError('%s:%d: Syntax error. Nothing follows %%prec' % (file, line))
+            if syms[-2] != '%prec':
+                raise GrammarError('%s:%d: Syntax error. %%prec can only appear at the end of a grammar rule' %
+                                   (file, line))
+            precname = syms[-1]
+            prodprec = self.Precedence.get(precname)
+            if not prodprec:
+                raise GrammarError('%s:%d: Nothing known about the precedence of %r' % (file, line, precname))
+            else:
+                self.UsedPrecedence.add(precname)
+            del syms[-2:]     # Drop %prec from the rule
+        else:
+            # If no %prec, precedence is determined by the rightmost terminal symbol
+            precname = rightmost_terminal(syms, self.Terminals)
+            prodprec = self.Precedence.get(precname, ('right', 0))
+
+        # See if the rule is already in the rulemap
+        map = '%s -> %s' % (prodname, syms)
+        if map in self.Prodmap:
+            m = self.Prodmap[map]
+            raise GrammarError('%s:%d: Duplicate rule %s. ' % (file, line, m) +
+                               'Previous definition at %s:%d' % (m.file, m.line))
+
+        # From this point on, everything is valid.  Create a new Production instance
+        pnumber  = len(self.Productions)
+        if prodname not in self.Nonterminals:
+            self.Nonterminals[prodname] = []
+
+        # Add the production number to Terminals and Nonterminals
+        for t in syms:
+            if t in self.Terminals:
+                self.Terminals[t].append(pnumber)
+            else:
+                if t not in self.Nonterminals:
+                    self.Nonterminals[t] = []
+                self.Nonterminals[t].append(pnumber)
+
+        # Create a production and add it to the list of productions
+        p = Production(pnumber, prodname, syms, prodprec, func, file, line)
+        self.Productions.append(p)
+        self.Prodmap[map] = p
+
+        # Add to the global productions list
+        try:
+            self.Prodnames[prodname].append(p)
+        except KeyError:
+            self.Prodnames[prodname] = [p]
+
+    # -----------------------------------------------------------------------------
+    # set_start()
+    #
+    # Sets the starting symbol and creates the augmented grammar.  Production
+    # rule 0 is S' -> start where start is the start symbol.
+    # -----------------------------------------------------------------------------
+
+    def set_start(self, start=None):
+        if not start:
+            start = self.Productions[1].name
+        if start not in self.Nonterminals:
+            raise GrammarError('start symbol %s undefined' % start)
+        self.Productions[0] = Production(0, "S'", [start])
+        self.Nonterminals[start].append(0)
+        self.Start = start
+
+    # -----------------------------------------------------------------------------
+    # find_unreachable()
+    #
+    # Find all of the nonterminal symbols that can't be reached from the starting
+    # symbol.  Returns a list of nonterminals that can't be reached.
+    # -----------------------------------------------------------------------------
+
+    def find_unreachable(self):
+
+        # Mark all symbols that are reachable from a symbol s
+        def mark_reachable_from(s):
+            if s in reachable:
+                return
+            reachable.add(s)
+            for p in self.Prodnames.get(s, []):
+                for r in p.prod:
+                    mark_reachable_from(r)
+
+        reachable = set()
+        mark_reachable_from(self.Productions[0].prod[0])
+        return [s for s in self.Nonterminals if s not in reachable]
+
+    # -----------------------------------------------------------------------------
+    # infinite_cycles()
+    #
+    # This function looks at the various parsing rules and tries to detect
+    # infinite recursion cycles (grammar rules where there is no possible way
+    # to derive a string of only terminals).
+    # -----------------------------------------------------------------------------
+
+    def infinite_cycles(self):
+        terminates = {}
+
+        # Terminals:
+        for t in self.Terminals:
+            terminates[t] = True
+
+        terminates['$end'] = True
+
+        # Nonterminals:
+
+        # Initialize to false:
+        for n in self.Nonterminals:
+            terminates[n] = False
+
+        # Then propagate termination until no change:
+        while True:
+            some_change = False
+            for (n, pl) in self.Prodnames.items():
+                # Nonterminal n terminates iff any of its productions terminates.
+                for p in pl:
+                    # Production p terminates iff all of its rhs symbols terminate.
+                    for s in p.prod:
+                        if not terminates[s]:
+                            # The symbol s does not terminate,
+                            # so production p does not terminate.
+                            p_terminates = False
+                            break
+                    else:
+                        # didn't break from the loop,
+                        # so every symbol s terminates
+                        # so production p terminates.
+                        p_terminates = True
+
+                    if p_terminates:
+                        # symbol n terminates!
+                        if not terminates[n]:
+                            terminates[n] = True
+                            some_change = True
+                        # Don't need to consider any more productions for this n.
+                        break
+
+            if not some_change:
+                break
+
+        infinite = []
+        for (s, term) in terminates.items():
+            if not term:
+                if s not in self.Prodnames and s not in self.Terminals and s != 'error':
+                    # s is used-but-not-defined, and we've already warned of that,
+                    # so it would be overkill to say that it's also non-terminating.
+                    pass
+                else:
+                    infinite.append(s)
+
+        return infinite
+
+    # -----------------------------------------------------------------------------
+    # undefined_symbols()
+    #
+    # Find all symbols that were used the grammar, but not defined as tokens or
+    # grammar rules.  Returns a list of tuples (sym, prod) where sym in the symbol
+    # and prod is the production where the symbol was used.
+    # -----------------------------------------------------------------------------
+    def undefined_symbols(self):
+        result = []
+        for p in self.Productions:
+            if not p:
+                continue
+
+            for s in p.prod:
+                if s not in self.Prodnames and s not in self.Terminals and s != 'error':
+                    result.append((s, p))
+        return result
+
+    # -----------------------------------------------------------------------------
+    # unused_terminals()
+    #
+    # Find all terminals that were defined, but not used by the grammar.  Returns
+    # a list of all symbols.
+    # -----------------------------------------------------------------------------
+    def unused_terminals(self):
+        unused_tok = []
+        for s, v in self.Terminals.items():
+            if s != 'error' and not v:
+                unused_tok.append(s)
+
+        return unused_tok
+
+    # ------------------------------------------------------------------------------
+    # unused_rules()
+    #
+    # Find all grammar rules that were defined,  but not used (maybe not reachable)
+    # Returns a list of productions.
+    # ------------------------------------------------------------------------------
+
+    def unused_rules(self):
+        unused_prod = []
+        for s, v in self.Nonterminals.items():
+            if not v:
+                p = self.Prodnames[s][0]
+                unused_prod.append(p)
+        return unused_prod
+
+    # -----------------------------------------------------------------------------
+    # unused_precedence()
+    #
+    # Returns a list of tuples (term,precedence) corresponding to precedence
+    # rules that were never used by the grammar.  term is the name of the terminal
+    # on which precedence was applied and precedence is a string such as 'left' or
+    # 'right' corresponding to the type of precedence.
+    # -----------------------------------------------------------------------------
+
+    def unused_precedence(self):
+        unused = []
+        for termname in self.Precedence:
+            if not (termname in self.Terminals or termname in self.UsedPrecedence):
+                unused.append((termname, self.Precedence[termname][0]))
+
+        return unused
+
+    # -------------------------------------------------------------------------
+    # _first()
+    #
+    # Compute the value of FIRST1(beta) where beta is a tuple of symbols.
+    #
+    # During execution of compute_first1, the result may be incomplete.
+    # Afterward (e.g., when called from compute_follow()), it will be complete.
+    # -------------------------------------------------------------------------
+    def _first(self, beta):
+
+        # We are computing First(x1,x2,x3,...,xn)
+        result = []
+        for x in beta:
+            x_produces_empty = False
+
+            # Add all the non-<empty> symbols of First[x] to the result.
+            for f in self.First[x]:
+                if f == '<empty>':
+                    x_produces_empty = True
+                else:
+                    if f not in result:
+                        result.append(f)
+
+            if x_produces_empty:
+                # We have to consider the next x in beta,
+                # i.e. stay in the loop.
+                pass
+            else:
+                # We don't have to consider any further symbols in beta.
+                break
+        else:
+            # There was no 'break' from the loop,
+            # so x_produces_empty was true for all x in beta,
+            # so beta produces empty as well.
+            result.append('<empty>')
+
+        return result
+
+    # -------------------------------------------------------------------------
+    # compute_first()
+    #
+    # Compute the value of FIRST1(X) for all symbols
+    # -------------------------------------------------------------------------
+    def compute_first(self):
+        if self.First:
+            return self.First
+
+        # Terminals:
+        for t in self.Terminals:
+            self.First[t] = [t]
+
+        self.First['$end'] = ['$end']
+
+        # Nonterminals:
+
+        # Initialize to the empty set:
+        for n in self.Nonterminals:
+            self.First[n] = []
+
+        # Then propagate symbols until no change:
+        while True:
+            some_change = False
+            for n in self.Nonterminals:
+                for p in self.Prodnames[n]:
+                    for f in self._first(p.prod):
+                        if f not in self.First[n]:
+                            self.First[n].append(f)
+                            some_change = True
+            if not some_change:
+                break
+
+        return self.First
+
+    # ---------------------------------------------------------------------
+    # compute_follow()
+    #
+    # Computes all of the follow sets for every non-terminal symbol.  The
+    # follow set is the set of all symbols that might follow a given
+    # non-terminal.  See the Dragon book, 2nd Ed. p. 189.
+    # ---------------------------------------------------------------------
+    def compute_follow(self, start=None):
+        # If already computed, return the result
+        if self.Follow:
+            return self.Follow
+
+        # If first sets not computed yet, do that first.
+        if not self.First:
+            self.compute_first()
+
+        # Add '$end' to the follow list of the start symbol
+        for k in self.Nonterminals:
+            self.Follow[k] = []
+
+        if not start:
+            start = self.Productions[1].name
+
+        self.Follow[start] = ['$end']
+
+        while True:
+            didadd = False
+            for p in self.Productions[1:]:
+                # Here is the production set
+                for i, B in enumerate(p.prod):
+                    if B in self.Nonterminals:
+                        # Okay. We got a non-terminal in a production
+                        fst = self._first(p.prod[i+1:])
+                        hasempty = False
+                        for f in fst:
+                            if f != '<empty>' and f not in self.Follow[B]:
+                                self.Follow[B].append(f)
+                                didadd = True
+                            if f == '<empty>':
+                                hasempty = True
+                        if hasempty or i == (len(p.prod)-1):
+                            # Add elements of follow(a) to follow(b)
+                            for f in self.Follow[p.name]:
+                                if f not in self.Follow[B]:
+                                    self.Follow[B].append(f)
+                                    didadd = True
+            if not didadd:
+                break
+        return self.Follow
+
+
+    # -----------------------------------------------------------------------------
+    # build_lritems()
+    #
+    # This function walks the list of productions and builds a complete set of the
+    # LR items.  The LR items are stored in two ways:  First, they are uniquely
+    # numbered and placed in the list _lritems.  Second, a linked list of LR items
+    # is built for each production.  For example:
+    #
+    #   E -> E PLUS E
+    #
+    # Creates the list
+    #
+    #  [E -> . E PLUS E, E -> E . PLUS E, E -> E PLUS . E, E -> E PLUS E . ]
+    # -----------------------------------------------------------------------------
+
+    def build_lritems(self):
+        for p in self.Productions:
+            lastlri = p
+            i = 0
+            lr_items = []
+            while True:
+                if i > len(p):
+                    lri = None
+                else:
+                    lri = LRItem(p, i)
+                    # Precompute the list of productions immediately following
+                    try:
+                        lri.lr_after = self.Prodnames[lri.prod[i+1]]
+                    except (IndexError, KeyError):
+                        lri.lr_after = []
+                    try:
+                        lri.lr_before = lri.prod[i-1]
+                    except IndexError:
+                        lri.lr_before = None
+
+                lastlri.lr_next = lri
+                if not lri:
+                    break
+                lr_items.append(lri)
+                lastlri = lri
+                i += 1
+            p.lr_items = lr_items
+
+# -----------------------------------------------------------------------------
+#                            == Class LRTable ==
+#
+# This basic class represents a basic table of LR parsing information.
+# Methods for generating the tables are not defined here.  They are defined
+# in the derived class LRGeneratedTable.
+# -----------------------------------------------------------------------------
+
+class VersionError(YaccError):
+    pass
+
+class LRTable(object):
+    def __init__(self):
+        self.lr_action = None
+        self.lr_goto = None
+        self.lr_productions = None
+        self.lr_method = None
+
+    def read_table(self, module):
+        if isinstance(module, types.ModuleType):
+            parsetab = module
+        else:
+            exec('import %s' % module)
+            parsetab = sys.modules[module]
+
+        if parsetab._tabversion != __tabversion__:
+            raise VersionError('yacc table file version is out of date')
+
+        self.lr_action = parsetab._lr_action
+        self.lr_goto = parsetab._lr_goto
+
+        self.lr_productions = []
+        for p in parsetab._lr_productions:
+            self.lr_productions.append(MiniProduction(*p))
+
+        self.lr_method = parsetab._lr_method
+        return parsetab._lr_signature
+
+    def read_pickle(self, filename):
+        try:
+            import cPickle as pickle
+        except ImportError:
+            import pickle
+
+        if not os.path.exists(filename):
+          raise ImportError
+
+        in_f = open(filename, 'rb')
+
+        tabversion = pickle.load(in_f)
+        if tabversion != __tabversion__:
+            raise VersionError('yacc table file version is out of date')
+        self.lr_method = pickle.load(in_f)
+        signature      = pickle.load(in_f)
+        self.lr_action = pickle.load(in_f)
+        self.lr_goto   = pickle.load(in_f)
+        productions    = pickle.load(in_f)
+
+        self.lr_productions = []
+        for p in productions:
+            self.lr_productions.append(MiniProduction(*p))
+
+        in_f.close()
+        return signature
+
+    # Bind all production function names to callable objects in pdict
+    def bind_callables(self, pdict):
+        for p in self.lr_productions:
+            p.bind(pdict)
+
+
+# -----------------------------------------------------------------------------
+#                           === LR Generator ===
+#
+# The following classes and functions are used to generate LR parsing tables on
+# a grammar.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# digraph()
+# traverse()
+#
+# The following two functions are used to compute set valued functions
+# of the form:
+#
+#     F(x) = F'(x) U U{F(y) | x R y}
+#
+# This is used to compute the values of Read() sets as well as FOLLOW sets
+# in LALR(1) generation.
+#
+# Inputs:  X    - An input set
+#          R    - A relation
+#          FP   - Set-valued function
+# ------------------------------------------------------------------------------
+
+def digraph(X, R, FP):
+    N = {}
+    for x in X:
+        N[x] = 0
+    stack = []
+    F = {}
+    for x in X:
+        if N[x] == 0:
+            traverse(x, N, stack, F, X, R, FP)
+    return F
+
+def traverse(x, N, stack, F, X, R, FP):
+    stack.append(x)
+    d = len(stack)
+    N[x] = d
+    F[x] = FP(x)             # F(X) <- F'(x)
+
+    rel = R(x)               # Get y's related to x
+    for y in rel:
+        if N[y] == 0:
+            traverse(y, N, stack, F, X, R, FP)
+        N[x] = min(N[x], N[y])
+        for a in F.get(y, []):
+            if a not in F[x]:
+                F[x].append(a)
+    if N[x] == d:
+        N[stack[-1]] = MAXINT
+        F[stack[-1]] = F[x]
+        element = stack.pop()
+        while element != x:
+            N[stack[-1]] = MAXINT
+            F[stack[-1]] = F[x]
+            element = stack.pop()
+
+class LALRError(YaccError):
+    pass
+
+# -----------------------------------------------------------------------------
+#                             == LRGeneratedTable ==
+#
+# This class implements the LR table generation algorithm.  There are no
+# public methods except for write()
+# -----------------------------------------------------------------------------
+
+class LRGeneratedTable(LRTable):
+    def __init__(self, grammar, method='LALR', log=None):
+        if method not in ['SLR', 'LALR']:
+            raise LALRError('Unsupported method %s' % method)
+
+        self.grammar = grammar
+        self.lr_method = method
+
+        # Set up the logger
+        if not log:
+            log = NullLogger()
+        self.log = log
+
+        # Internal attributes
+        self.lr_action     = {}        # Action table
+        self.lr_goto       = {}        # Goto table
+        self.lr_productions  = grammar.Productions    # Copy of grammar Production array
+        self.lr_goto_cache = {}        # Cache of computed gotos
+        self.lr0_cidhash   = {}        # Cache of closures
+
+        self._add_count    = 0         # Internal counter used to detect cycles
+
+        # Diagonistic information filled in by the table generator
+        self.sr_conflict   = 0
+        self.rr_conflict   = 0
+        self.conflicts     = []        # List of conflicts
+
+        self.sr_conflicts  = []
+        self.rr_conflicts  = []
+
+        # Build the tables
+        self.grammar.build_lritems()
+        self.grammar.compute_first()
+        self.grammar.compute_follow()
+        self.lr_parse_table()
+
+    # Compute the LR(0) closure operation on I, where I is a set of LR(0) items.
+
+    def lr0_closure(self, I):
+        self._add_count += 1
+
+        # Add everything in I to J
+        J = I[:]
+        didadd = True
+        while didadd:
+            didadd = False
+            for j in J:
+                for x in j.lr_after:
+                    if getattr(x, 'lr0_added', 0) == self._add_count:
+                        continue
+                    # Add B --> .G to J
+                    J.append(x.lr_next)
+                    x.lr0_added = self._add_count
+                    didadd = True
+
+        return J
+
+    # Compute the LR(0) goto function goto(I,X) where I is a set
+    # of LR(0) items and X is a grammar symbol.   This function is written
+    # in a way that guarantees uniqueness of the generated goto sets
+    # (i.e. the same goto set will never be returned as two different Python
+    # objects).  With uniqueness, we can later do fast set comparisons using
+    # id(obj) instead of element-wise comparison.
+
+    def lr0_goto(self, I, x):
+        # First we look for a previously cached entry
+        g = self.lr_goto_cache.get((id(I), x))
+        if g:
+            return g
+
+        # Now we generate the goto set in a way that guarantees uniqueness
+        # of the result
+
+        s = self.lr_goto_cache.get(x)
+        if not s:
+            s = {}
+            self.lr_goto_cache[x] = s
+
+        gs = []
+        for p in I:
+            n = p.lr_next
+            if n and n.lr_before == x:
+                s1 = s.get(id(n))
+                if not s1:
+                    s1 = {}
+                    s[id(n)] = s1
+                gs.append(n)
+                s = s1
+        g = s.get('$end')
+        if not g:
+            if gs:
+                g = self.lr0_closure(gs)
+                s['$end'] = g
+            else:
+                s['$end'] = gs
+        self.lr_goto_cache[(id(I), x)] = g
+        return g
+
+    # Compute the LR(0) sets of item function
+    def lr0_items(self):
+        C = [self.lr0_closure([self.grammar.Productions[0].lr_next])]
+        i = 0
+        for I in C:
+            self.lr0_cidhash[id(I)] = i
+            i += 1
+
+        # Loop over the items in C and each grammar symbols
+        i = 0
+        while i < len(C):
+            I = C[i]
+            i += 1
+
+            # Collect all of the symbols that could possibly be in the goto(I,X) sets
+            asyms = {}
+            for ii in I:
+                for s in ii.usyms:
+                    asyms[s] = None
+
+            for x in asyms:
+                g = self.lr0_goto(I, x)
+                if not g or id(g) in self.lr0_cidhash:
+                    continue
+                self.lr0_cidhash[id(g)] = len(C)
+                C.append(g)
+
+        return C
+
+    # -----------------------------------------------------------------------------
+    #                       ==== LALR(1) Parsing ====
+    #
+    # LALR(1) parsing is almost exactly the same as SLR except that instead of
+    # relying upon Follow() sets when performing reductions, a more selective
+    # lookahead set that incorporates the state of the LR(0) machine is utilized.
+    # Thus, we mainly just have to focus on calculating the lookahead sets.
+    #
+    # The method used here is due to DeRemer and Pennelo (1982).
+    #
+    # DeRemer, F. L., and T. J. Pennelo: "Efficient Computation of LALR(1)
+    #     Lookahead Sets", ACM Transactions on Programming Languages and Systems,
+    #     Vol. 4, No. 4, Oct. 1982, pp. 615-649
+    #
+    # Further details can also be found in:
+    #
+    #  J. Tremblay and P. Sorenson, "The Theory and Practice of Compiler Writing",
+    #      McGraw-Hill Book Company, (1985).
+    #
+    # -----------------------------------------------------------------------------
+
+    # -----------------------------------------------------------------------------
+    # compute_nullable_nonterminals()
+    #
+    # Creates a dictionary containing all of the non-terminals that might produce
+    # an empty production.
+    # -----------------------------------------------------------------------------
+
+    def compute_nullable_nonterminals(self):
+        nullable = set()
+        num_nullable = 0
+        while True:
+            for p in self.grammar.Productions[1:]:
+                if p.len == 0:
+                    nullable.add(p.name)
+                    continue
+                for t in p.prod:
+                    if t not in nullable:
+                        break
+                else:
+                    nullable.add(p.name)
+            if len(nullable) == num_nullable:
+                break
+            num_nullable = len(nullable)
+        return nullable
+
+    # -----------------------------------------------------------------------------
+    # find_nonterminal_trans(C)
+    #
+    # Given a set of LR(0) items, this functions finds all of the non-terminal
+    # transitions.    These are transitions in which a dot appears immediately before
+    # a non-terminal.   Returns a list of tuples of the form (state,N) where state
+    # is the state number and N is the nonterminal symbol.
+    #
+    # The input C is the set of LR(0) items.
+    # -----------------------------------------------------------------------------
+
+    def find_nonterminal_transitions(self, C):
+        trans = []
+        for stateno, state in enumerate(C):
+            for p in state:
+                if p.lr_index < p.len - 1:
+                    t = (stateno, p.prod[p.lr_index+1])
+                    if t[1] in self.grammar.Nonterminals:
+                        if t not in trans:
+                            trans.append(t)
+        return trans
+
+    # -----------------------------------------------------------------------------
+    # dr_relation()
+    #
+    # Computes the DR(p,A) relationships for non-terminal transitions.  The input
+    # is a tuple (state,N) where state is a number and N is a nonterminal symbol.
+    #
+    # Returns a list of terminals.
+    # -----------------------------------------------------------------------------
+
+    def dr_relation(self, C, trans, nullable):
+        dr_set = {}
+        state, N = trans
+        terms = []
+
+        g = self.lr0_goto(C[state], N)
+        for p in g:
+            if p.lr_index < p.len - 1:
+                a = p.prod[p.lr_index+1]
+                if a in self.grammar.Terminals:
+                    if a not in terms:
+                        terms.append(a)
+
+        # This extra bit is to handle the start state
+        if state == 0 and N == self.grammar.Productions[0].prod[0]:
+            terms.append('$end')
+
+        return terms
+
+    # -----------------------------------------------------------------------------
+    # reads_relation()
+    #
+    # Computes the READS() relation (p,A) READS (t,C).
+    # -----------------------------------------------------------------------------
+
+    def reads_relation(self, C, trans, empty):
+        # Look for empty transitions
+        rel = []
+        state, N = trans
+
+        g = self.lr0_goto(C[state], N)
+        j = self.lr0_cidhash.get(id(g), -1)
+        for p in g:
+            if p.lr_index < p.len - 1:
+                a = p.prod[p.lr_index + 1]
+                if a in empty:
+                    rel.append((j, a))
+
+        return rel
+
+    # -----------------------------------------------------------------------------
+    # compute_lookback_includes()
+    #
+    # Determines the lookback and includes relations
+    #
+    # LOOKBACK:
+    #
+    # This relation is determined by running the LR(0) state machine forward.
+    # For example, starting with a production "N : . A B C", we run it forward
+    # to obtain "N : A B C ."   We then build a relationship between this final
+    # state and the starting state.   These relationships are stored in a dictionary
+    # lookdict.
+    #
+    # INCLUDES:
+    #
+    # Computes the INCLUDE() relation (p,A) INCLUDES (p',B).
+    #
+    # This relation is used to determine non-terminal transitions that occur
+    # inside of other non-terminal transition states.   (p,A) INCLUDES (p', B)
+    # if the following holds:
+    #
+    #       B -> LAT, where T -> epsilon and p' -L-> p
+    #
+    # L is essentially a prefix (which may be empty), T is a suffix that must be
+    # able to derive an empty string.  State p' must lead to state p with the string L.
+    #
+    # -----------------------------------------------------------------------------
+
+    def compute_lookback_includes(self, C, trans, nullable):
+        lookdict = {}          # Dictionary of lookback relations
+        includedict = {}       # Dictionary of include relations
+
+        # Make a dictionary of non-terminal transitions
+        dtrans = {}
+        for t in trans:
+            dtrans[t] = 1
+
+        # Loop over all transitions and compute lookbacks and includes
+        for state, N in trans:
+            lookb = []
+            includes = []
+            for p in C[state]:
+                if p.name != N:
+                    continue
+
+                # Okay, we have a name match.  We now follow the production all the way
+                # through the state machine until we get the . on the right hand side
+
+                lr_index = p.lr_index
+                j = state
+                while lr_index < p.len - 1:
+                    lr_index = lr_index + 1
+                    t = p.prod[lr_index]
+
+                    # Check to see if this symbol and state are a non-terminal transition
+                    if (j, t) in dtrans:
+                        # Yes.  Okay, there is some chance that this is an includes relation
+                        # the only way to know for certain is whether the rest of the
+                        # production derives empty
+
+                        li = lr_index + 1
+                        while li < p.len:
+                            if p.prod[li] in self.grammar.Terminals:
+                                break      # No forget it
+                            if p.prod[li] not in nullable:
+                                break
+                            li = li + 1
+                        else:
+                            # Appears to be a relation between (j,t) and (state,N)
+                            includes.append((j, t))
+
+                    g = self.lr0_goto(C[j], t)               # Go to next set
+                    j = self.lr0_cidhash.get(id(g), -1)      # Go to next state
+
+                # When we get here, j is the final state, now we have to locate the production
+                for r in C[j]:
+                    if r.name != p.name:
+                        continue
+                    if r.len != p.len:
+                        continue
+                    i = 0
+                    # This look is comparing a production ". A B C" with "A B C ."
+                    while i < r.lr_index:
+                        if r.prod[i] != p.prod[i+1]:
+                            break
+                        i = i + 1
+                    else:
+                        lookb.append((j, r))
+            for i in includes:
+                if i not in includedict:
+                    includedict[i] = []
+                includedict[i].append((state, N))
+            lookdict[(state, N)] = lookb
+
+        return lookdict, includedict
+
+    # -----------------------------------------------------------------------------
+    # compute_read_sets()
+    #
+    # Given a set of LR(0) items, this function computes the read sets.
+    #
+    # Inputs:  C        =  Set of LR(0) items
+    #          ntrans   = Set of nonterminal transitions
+    #          nullable = Set of empty transitions
+    #
+    # Returns a set containing the read sets
+    # -----------------------------------------------------------------------------
+
+    def compute_read_sets(self, C, ntrans, nullable):
+        FP = lambda x: self.dr_relation(C, x, nullable)
+        R =  lambda x: self.reads_relation(C, x, nullable)
+        F = digraph(ntrans, R, FP)
+        return F
+
+    # -----------------------------------------------------------------------------
+    # compute_follow_sets()
+    #
+    # Given a set of LR(0) items, a set of non-terminal transitions, a readset,
+    # and an include set, this function computes the follow sets
+    #
+    # Follow(p,A) = Read(p,A) U U {Follow(p',B) | (p,A) INCLUDES (p',B)}
+    #
+    # Inputs:
+    #            ntrans     = Set of nonterminal transitions
+    #            readsets   = Readset (previously computed)
+    #            inclsets   = Include sets (previously computed)
+    #
+    # Returns a set containing the follow sets
+    # -----------------------------------------------------------------------------
+
+    def compute_follow_sets(self, ntrans, readsets, inclsets):
+        FP = lambda x: readsets[x]
+        R  = lambda x: inclsets.get(x, [])
+        F = digraph(ntrans, R, FP)
+        return F
+
+    # -----------------------------------------------------------------------------
+    # add_lookaheads()
+    #
+    # Attaches the lookahead symbols to grammar rules.
+    #
+    # Inputs:    lookbacks         -  Set of lookback relations
+    #            followset         -  Computed follow set
+    #
+    # This function directly attaches the lookaheads to productions contained
+    # in the lookbacks set
+    # -----------------------------------------------------------------------------
+
+    def add_lookaheads(self, lookbacks, followset):
+        for trans, lb in lookbacks.items():
+            # Loop over productions in lookback
+            for state, p in lb:
+                if state not in p.lookaheads:
+                    p.lookaheads[state] = []
+                f = followset.get(trans, [])
+                for a in f:
+                    if a not in p.lookaheads[state]:
+                        p.lookaheads[state].append(a)
+
+    # -----------------------------------------------------------------------------
+    # add_lalr_lookaheads()
+    #
+    # This function does all of the work of adding lookahead information for use
+    # with LALR parsing
+    # -----------------------------------------------------------------------------
+
+    def add_lalr_lookaheads(self, C):
+        # Determine all of the nullable nonterminals
+        nullable = self.compute_nullable_nonterminals()
+
+        # Find all non-terminal transitions
+        trans = self.find_nonterminal_transitions(C)
+
+        # Compute read sets
+        readsets = self.compute_read_sets(C, trans, nullable)
+
+        # Compute lookback/includes relations
+        lookd, included = self.compute_lookback_includes(C, trans, nullable)
+
+        # Compute LALR FOLLOW sets
+        followsets = self.compute_follow_sets(trans, readsets, included)
+
+        # Add all of the lookaheads
+        self.add_lookaheads(lookd, followsets)
+
+    # -----------------------------------------------------------------------------
+    # lr_parse_table()
+    #
+    # This function constructs the parse tables for SLR or LALR
+    # -----------------------------------------------------------------------------
+    def lr_parse_table(self):
+        Productions = self.grammar.Productions
+        Precedence  = self.grammar.Precedence
+        goto   = self.lr_goto         # Goto array
+        action = self.lr_action       # Action array
+        log    = self.log             # Logger for output
+
+        actionp = {}                  # Action production array (temporary)
+
+        log.info('Parsing method: %s', self.lr_method)
+
+        # Step 1: Construct C = { I0, I1, ... IN}, collection of LR(0) items
+        # This determines the number of states
+
+        C = self.lr0_items()
+
+        if self.lr_method == 'LALR':
+            self.add_lalr_lookaheads(C)
+
+        # Build the parser table, state by state
+        st = 0
+        for I in C:
+            # Loop over each production in I
+            actlist = []              # List of actions
+            st_action  = {}
+            st_actionp = {}
+            st_goto    = {}
+            log.info('')
+            log.info('state %d', st)
+            log.info('')
+            for p in I:
+                log.info('    (%d) %s', p.number, p)
+            log.info('')
+
+            for p in I:
+                    if p.len == p.lr_index + 1:
+                        if p.name == "S'":
+                            # Start symbol. Accept!
+                            st_action['$end'] = 0
+                            st_actionp['$end'] = p
+                        else:
+                            # We are at the end of a production.  Reduce!
+                            if self.lr_method == 'LALR':
+                                laheads = p.lookaheads[st]
+                            else:
+                                laheads = self.grammar.Follow[p.name]
+                            for a in laheads:
+                                actlist.append((a, p, 'reduce using rule %d (%s)' % (p.number, p)))
+                                r = st_action.get(a)
+                                if r is not None:
+                                    # Whoa. Have a shift/reduce or reduce/reduce conflict
+                                    if r > 0:
+                                        # Need to decide on shift or reduce here
+                                        # By default we favor shifting. Need to add
+                                        # some precedence rules here.
+
+                                        # Shift precedence comes from the token
+                                        sprec, slevel = Precedence.get(a, ('right', 0))
+
+                                        # Reduce precedence comes from rule being reduced (p)
+                                        rprec, rlevel = Productions[p.number].prec
+
+                                        if (slevel < rlevel) or ((slevel == rlevel) and (rprec == 'left')):
+                                            # We really need to reduce here.
+                                            st_action[a] = -p.number
+                                            st_actionp[a] = p
+                                            if not slevel and not rlevel:
+                                                log.info('  ! shift/reduce conflict for %s resolved as reduce', a)
+                                                self.sr_conflicts.append((st, a, 'reduce'))
+                                            Productions[p.number].reduced += 1
+                                        elif (slevel == rlevel) and (rprec == 'nonassoc'):
+                                            st_action[a] = None
+                                        else:
+                                            # Hmmm. Guess we'll keep the shift
+                                            if not rlevel:
+                                                log.info('  ! shift/reduce conflict for %s resolved as shift', a)
+                                                self.sr_conflicts.append((st, a, 'shift'))
+                                    elif r < 0:
+                                        # Reduce/reduce conflict.   In this case, we favor the rule
+                                        # that was defined first in the grammar file
+                                        oldp = Productions[-r]
+                                        pp = Productions[p.number]
+                                        if oldp.line > pp.line:
+                                            st_action[a] = -p.number
+                                            st_actionp[a] = p
+                                            chosenp, rejectp = pp, oldp
+                                            Productions[p.number].reduced += 1
+                                            Productions[oldp.number].reduced -= 1
+                                        else:
+                                            chosenp, rejectp = oldp, pp
+                                        self.rr_conflicts.append((st, chosenp, rejectp))
+                                        log.info('  ! reduce/reduce conflict for %s resolved using rule %d (%s)',
+                                                 a, st_actionp[a].number, st_actionp[a])
+                                    else:
+                                        raise LALRError('Unknown conflict in state %d' % st)
+                                else:
+                                    st_action[a] = -p.number
+                                    st_actionp[a] = p
+                                    Productions[p.number].reduced += 1
+                    else:
+                        i = p.lr_index
+                        a = p.prod[i+1]       # Get symbol right after the "."
+                        if a in self.grammar.Terminals:
+                            g = self.lr0_goto(I, a)
+                            j = self.lr0_cidhash.get(id(g), -1)
+                            if j >= 0:
+                                # We are in a shift state
+                                actlist.append((a, p, 'shift and go to state %d' % j))
+                                r = st_action.get(a)
+                                if r is not None:
+                                    # Whoa have a shift/reduce or shift/shift conflict
+                                    if r > 0:
+                                        if r != j:
+                                            raise LALRError('Shift/shift conflict in state %d' % st)
+                                    elif r < 0:
+                                        # Do a precedence check.
+                                        #   -  if precedence of reduce rule is higher, we reduce.
+                                        #   -  if precedence of reduce is same and left assoc, we reduce.
+                                        #   -  otherwise we shift
+
+                                        # Shift precedence comes from the token
+                                        sprec, slevel = Precedence.get(a, ('right', 0))
+
+                                        # Reduce precedence comes from the rule that could have been reduced
+                                        rprec, rlevel = Productions[st_actionp[a].number].prec
+
+                                        if (slevel > rlevel) or ((slevel == rlevel) and (rprec == 'right')):
+                                            # We decide to shift here... highest precedence to shift
+                                            Productions[st_actionp[a].number].reduced -= 1
+                                            st_action[a] = j
+                                            st_actionp[a] = p
+                                            if not rlevel:
+                                                log.info('  ! shift/reduce conflict for %s resolved as shift', a)
+                                                self.sr_conflicts.append((st, a, 'shift'))
+                                        elif (slevel == rlevel) and (rprec == 'nonassoc'):
+                                            st_action[a] = None
+                                        else:
+                                            # Hmmm. Guess we'll keep the reduce
+                                            if not slevel and not rlevel:
+                                                log.info('  ! shift/reduce conflict for %s resolved as reduce', a)
+                                                self.sr_conflicts.append((st, a, 'reduce'))
+
+                                    else:
+                                        raise LALRError('Unknown conflict in state %d' % st)
+                                else:
+                                    st_action[a] = j
+                                    st_actionp[a] = p
+
+            # Print the actions associated with each terminal
+            _actprint = {}
+            for a, p, m in actlist:
+                if a in st_action:
+                    if p is st_actionp[a]:
+                        log.info('    %-15s %s', a, m)
+                        _actprint[(a, m)] = 1
+            log.info('')
+            # Print the actions that were not used. (debugging)
+            not_used = 0
+            for a, p, m in actlist:
+                if a in st_action:
+                    if p is not st_actionp[a]:
+                        if not (a, m) in _actprint:
+                            log.debug('  ! %-15s [ %s ]', a, m)
+                            not_used = 1
+                            _actprint[(a, m)] = 1
+            if not_used:
+                log.debug('')
+
+            # Construct the goto table for this state
+
+            nkeys = {}
+            for ii in I:
+                for s in ii.usyms:
+                    if s in self.grammar.Nonterminals:
+                        nkeys[s] = None
+            for n in nkeys:
+                g = self.lr0_goto(I, n)
+                j = self.lr0_cidhash.get(id(g), -1)
+                if j >= 0:
+                    st_goto[n] = j
+                    log.info('    %-30s shift and go to state %d', n, j)
+
+            action[st] = st_action
+            actionp[st] = st_actionp
+            goto[st] = st_goto
+            st += 1
+
+    # -----------------------------------------------------------------------------
+    # write()
+    #
+    # This function writes the LR parsing tables to a file
+    # -----------------------------------------------------------------------------
+
+    def write_table(self, tabmodule, outputdir='', signature=''):
+        if isinstance(tabmodule, types.ModuleType):
+            raise IOError("Won't overwrite existing tabmodule")
+
+        basemodulename = tabmodule.split('.')[-1]
+        filename = os.path.join(outputdir, basemodulename) + '.py'
+        try:
+            f = open(filename, 'w')
+
+            f.write('''
+# %s
+# This file is automatically generated. Do not edit.
+_tabversion = %r
+
+_lr_method = %r
+
+_lr_signature = %r
+    ''' % (os.path.basename(filename), __tabversion__, self.lr_method, signature))
+
+            # Change smaller to 0 to go back to original tables
+            smaller = 1
+
+            # Factor out names to try and make smaller
+            if smaller:
+                items = {}
+
+                for s, nd in self.lr_action.items():
+                    for name, v in nd.items():
+                        i = items.get(name)
+                        if not i:
+                            i = ([], [])
+                            items[name] = i
+                        i[0].append(s)
+                        i[1].append(v)
+
+                f.write('\n_lr_action_items = {')
+                for k, v in items.items():
+                    f.write('%r:([' % k)
+                    for i in v[0]:
+                        f.write('%r,' % i)
+                    f.write('],[')
+                    for i in v[1]:
+                        f.write('%r,' % i)
+
+                    f.write(']),')
+                f.write('}\n')
+
+                f.write('''
+_lr_action = {}
+for _k, _v in _lr_action_items.items():
+   for _x,_y in zip(_v[0],_v[1]):
+      if not _x in _lr_action:  _lr_action[_x] = {}
+      _lr_action[_x][_k] = _y
+del _lr_action_items
+''')
+
+            else:
+                f.write('\n_lr_action = { ')
+                for k, v in self.lr_action.items():
+                    f.write('(%r,%r):%r,' % (k[0], k[1], v))
+                f.write('}\n')
+
+            if smaller:
+                # Factor out names to try and make smaller
+                items = {}
+
+                for s, nd in self.lr_goto.items():
+                    for name, v in nd.items():
+                        i = items.get(name)
+                        if not i:
+                            i = ([], [])
+                            items[name] = i
+                        i[0].append(s)
+                        i[1].append(v)
+
+                f.write('\n_lr_goto_items = {')
+                for k, v in items.items():
+                    f.write('%r:([' % k)
+                    for i in v[0]:
+                        f.write('%r,' % i)
+                    f.write('],[')
+                    for i in v[1]:
+                        f.write('%r,' % i)
+
+                    f.write(']),')
+                f.write('}\n')
+
+                f.write('''
+_lr_goto = {}
+for _k, _v in _lr_goto_items.items():
+   for _x, _y in zip(_v[0], _v[1]):
+       if not _x in _lr_goto: _lr_goto[_x] = {}
+       _lr_goto[_x][_k] = _y
+del _lr_goto_items
+''')
+            else:
+                f.write('\n_lr_goto = { ')
+                for k, v in self.lr_goto.items():
+                    f.write('(%r,%r):%r,' % (k[0], k[1], v))
+                f.write('}\n')
+
+            # Write production table
+            f.write('_lr_productions = [\n')
+            for p in self.lr_productions:
+                if p.func:
+                    f.write('  (%r,%r,%d,%r,%r,%d),\n' % (p.str, p.name, p.len,
+                                                          p.func, os.path.basename(p.file), p.line))
+                else:
+                    f.write('  (%r,%r,%d,None,None,None),\n' % (str(p), p.name, p.len))
+            f.write(']\n')
+            f.close()
+
+        except IOError as e:
+            raise
+
+
+    # -----------------------------------------------------------------------------
+    # pickle_table()
+    #
+    # This function pickles the LR parsing tables to a supplied file object
+    # -----------------------------------------------------------------------------
+
+    def pickle_table(self, filename, signature=''):
+        try:
+            import cPickle as pickle
+        except ImportError:
+            import pickle
+        with open(filename, 'wb') as outf:
+            pickle.dump(__tabversion__, outf, pickle_protocol)
+            pickle.dump(self.lr_method, outf, pickle_protocol)
+            pickle.dump(signature, outf, pickle_protocol)
+            pickle.dump(self.lr_action, outf, pickle_protocol)
+            pickle.dump(self.lr_goto, outf, pickle_protocol)
+
+            outp = []
+            for p in self.lr_productions:
+                if p.func:
+                    outp.append((p.str, p.name, p.len, p.func, os.path.basename(p.file), p.line))
+                else:
+                    outp.append((str(p), p.name, p.len, None, None, None))
+            pickle.dump(outp, outf, pickle_protocol)
+
+# -----------------------------------------------------------------------------
+#                            === INTROSPECTION ===
+#
+# The following functions and classes are used to implement the PLY
+# introspection features followed by the yacc() function itself.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# get_caller_module_dict()
+#
+# This function returns a dictionary containing all of the symbols defined within
+# a caller further down the call stack.  This is used to get the environment
+# associated with the yacc() call if none was provided.
+# -----------------------------------------------------------------------------
+
+def get_caller_module_dict(levels):
+    f = sys._getframe(levels)
+    ldict = f.f_globals.copy()
+    if f.f_globals != f.f_locals:
+        ldict.update(f.f_locals)
+    return ldict
+
+# -----------------------------------------------------------------------------
+# parse_grammar()
+#
+# This takes a raw grammar rule string and parses it into production data
+# -----------------------------------------------------------------------------
+def parse_grammar(doc, file, line):
+    grammar = []
+    # Split the doc string into lines
+    pstrings = doc.splitlines()
+    lastp = None
+    dline = line
+    for ps in pstrings:
+        dline += 1
+        p = ps.split()
+        if not p:
+            continue
+        try:
+            if p[0] == '|':
+                # This is a continuation of a previous rule
+                if not lastp:
+                    raise SyntaxError("%s:%d: Misplaced '|'" % (file, dline))
+                prodname = lastp
+                syms = p[1:]
+            else:
+                prodname = p[0]
+                lastp = prodname
+                syms   = p[2:]
+                assign = p[1]
+                if assign != ':' and assign != '::=':
+                    raise SyntaxError("%s:%d: Syntax error. Expected ':'" % (file, dline))
+
+            grammar.append((file, dline, prodname, syms))
+        except SyntaxError:
+            raise
+        except Exception:
+            raise SyntaxError('%s:%d: Syntax error in rule %r' % (file, dline, ps.strip()))
+
+    return grammar
+
+# -----------------------------------------------------------------------------
+# ParserReflect()
+#
+# This class represents information extracted for building a parser including
+# start symbol, error function, tokens, precedence list, action functions,
+# etc.
+# -----------------------------------------------------------------------------
+class ParserReflect(object):
+    def __init__(self, pdict, log=None):
+        self.pdict      = pdict
+        self.start      = None
+        self.error_func = None
+        self.tokens     = None
+        self.modules    = set()
+        self.grammar    = []
+        self.error      = False
+
+        if log is None:
+            self.log = PlyLogger(sys.stderr)
+        else:
+            self.log = log
+
+    # Get all of the basic information
+    def get_all(self):
+        self.get_start()
+        self.get_error_func()
+        self.get_tokens()
+        self.get_precedence()
+        self.get_pfunctions()
+
+    # Validate all of the information
+    def validate_all(self):
+        self.validate_start()
+        self.validate_error_func()
+        self.validate_tokens()
+        self.validate_precedence()
+        self.validate_pfunctions()
+        self.validate_modules()
+        return self.error
+
+    # Compute a signature over the grammar
+    def signature(self):
+        parts = []
+        try:
+            if self.start:
+                parts.append(self.start)
+            if self.prec:
+                parts.append(''.join([''.join(p) for p in self.prec]))
+            if self.tokens:
+                parts.append(' '.join(self.tokens))
+            for f in self.pfuncs:
+                if f[3]:
+                    parts.append(f[3])
+        except (TypeError, ValueError):
+            pass
+        return ''.join(parts)
+
+    # -----------------------------------------------------------------------------
+    # validate_modules()
+    #
+    # This method checks to see if there are duplicated p_rulename() functions
+    # in the parser module file.  Without this function, it is really easy for
+    # users to make mistakes by cutting and pasting code fragments (and it's a real
+    # bugger to try and figure out why the resulting parser doesn't work).  Therefore,
+    # we just do a little regular expression pattern matching of def statements
+    # to try and detect duplicates.
+    # -----------------------------------------------------------------------------
+
+    def validate_modules(self):
+        # Match def p_funcname(
+        fre = re.compile(r'\s*def\s+(p_[a-zA-Z_0-9]*)\(')
+
+        for module in self.modules:
+            try:
+                lines, linen = inspect.getsourcelines(module)
+            except IOError:
+                continue
+
+            counthash = {}
+            for linen, line in enumerate(lines):
+                linen += 1
+                m = fre.match(line)
+                if m:
+                    name = m.group(1)
+                    prev = counthash.get(name)
+                    if not prev:
+                        counthash[name] = linen
+                    else:
+                        filename = inspect.getsourcefile(module)
+                        self.log.warning('%s:%d: Function %s redefined. Previously defined on line %d',
+                                         filename, linen, name, prev)
+
+    # Get the start symbol
+    def get_start(self):
+        self.start = self.pdict.get('start')
+
+    # Validate the start symbol
+    def validate_start(self):
+        if self.start is not None:
+            if not isinstance(self.start, string_types):
+                self.log.error("'start' must be a string")
+
+    # Look for error handler
+    def get_error_func(self):
+        self.error_func = self.pdict.get('p_error')
+
+    # Validate the error function
+    def validate_error_func(self):
+        if self.error_func:
+            if isinstance(self.error_func, types.FunctionType):
+                ismethod = 0
+            elif isinstance(self.error_func, types.MethodType):
+                ismethod = 1
+            else:
+                self.log.error("'p_error' defined, but is not a function or method")
+                self.error = True
+                return
+
+            eline = self.error_func.__code__.co_firstlineno
+            efile = self.error_func.__code__.co_filename
+            module = inspect.getmodule(self.error_func)
+            self.modules.add(module)
+
+            argcount = self.error_func.__code__.co_argcount - ismethod
+            if argcount != 1:
+                self.log.error('%s:%d: p_error() requires 1 argument', efile, eline)
+                self.error = True
+
+    # Get the tokens map
+    def get_tokens(self):
+        tokens = self.pdict.get('tokens')
+        if not tokens:
+            self.log.error('No token list is defined')
+            self.error = True
+            return
+
+        if not isinstance(tokens, (list, tuple)):
+            self.log.error('tokens must be a list or tuple')
+            self.error = True
+            return
+
+        if not tokens:
+            self.log.error('tokens is empty')
+            self.error = True
+            return
+
+        self.tokens = tokens
+
+    # Validate the tokens
+    def validate_tokens(self):
+        # Validate the tokens.
+        if 'error' in self.tokens:
+            self.log.error("Illegal token name 'error'. Is a reserved word")
+            self.error = True
+            return
+
+        terminals = set()
+        for n in self.tokens:
+            if n in terminals:
+                self.log.warning('Token %r multiply defined', n)
+            terminals.add(n)
+
+    # Get the precedence map (if any)
+    def get_precedence(self):
+        self.prec = self.pdict.get('precedence')
+
+    # Validate and parse the precedence map
+    def validate_precedence(self):
+        preclist = []
+        if self.prec:
+            if not isinstance(self.prec, (list, tuple)):
+                self.log.error('precedence must be a list or tuple')
+                self.error = True
+                return
+            for level, p in enumerate(self.prec):
+                if not isinstance(p, (list, tuple)):
+                    self.log.error('Bad precedence table')
+                    self.error = True
+                    return
+
+                if len(p) < 2:
+                    self.log.error('Malformed precedence entry %s. Must be (assoc, term, ..., term)', p)
+                    self.error = True
+                    return
+                assoc = p[0]
+                if not isinstance(assoc, string_types):
+                    self.log.error('precedence associativity must be a string')
+                    self.error = True
+                    return
+                for term in p[1:]:
+                    if not isinstance(term, string_types):
+                        self.log.error('precedence items must be strings')
+                        self.error = True
+                        return
+                    preclist.append((term, assoc, level+1))
+        self.preclist = preclist
+
+    # Get all p_functions from the grammar
+    def get_pfunctions(self):
+        p_functions = []
+        for name, item in self.pdict.items():
+            if not name.startswith('p_') or name == 'p_error':
+                continue
+            if isinstance(item, (types.FunctionType, types.MethodType)):
+                line = getattr(item, 'co_firstlineno', item.__code__.co_firstlineno)
+                module = inspect.getmodule(item)
+                p_functions.append((line, module, name, item.__doc__))
+
+        # Sort all of the actions by line number; make sure to stringify
+        # modules to make them sortable, since `line` may not uniquely sort all
+        # p functions
+        p_functions.sort(key=lambda p_function: (
+            p_function[0],
+            str(p_function[1]),
+            p_function[2],
+            p_function[3]))
+        self.pfuncs = p_functions
+
+    # Validate all of the p_functions
+    def validate_pfunctions(self):
+        grammar = []
+        # Check for non-empty symbols
+        if len(self.pfuncs) == 0:
+            self.log.error('no rules of the form p_rulename are defined')
+            self.error = True
+            return
+
+        for line, module, name, doc in self.pfuncs:
+            file = inspect.getsourcefile(module)
+            func = self.pdict[name]
+            if isinstance(func, types.MethodType):
+                reqargs = 2
+            else:
+                reqargs = 1
+            if func.__code__.co_argcount > reqargs:
+                self.log.error('%s:%d: Rule %r has too many arguments', file, line, func.__name__)
+                self.error = True
+            elif func.__code__.co_argcount < reqargs:
+                self.log.error('%s:%d: Rule %r requires an argument', file, line, func.__name__)
+                self.error = True
+            elif not func.__doc__:
+                self.log.warning('%s:%d: No documentation string specified in function %r (ignored)',
+                                 file, line, func.__name__)
+            else:
+                try:
+                    parsed_g = parse_grammar(doc, file, line)
+                    for g in parsed_g:
+                        grammar.append((name, g))
+                except SyntaxError as e:
+                    self.log.error(str(e))
+                    self.error = True
+
+                # Looks like a valid grammar rule
+                # Mark the file in which defined.
+                self.modules.add(module)
+
+        # Secondary validation step that looks for p_ definitions that are not functions
+        # or functions that look like they might be grammar rules.
+
+        for n, v in self.pdict.items():
+            if n.startswith('p_') and isinstance(v, (types.FunctionType, types.MethodType)):
+                continue
+            if n.startswith('t_'):
+                continue
+            if n.startswith('p_') and n != 'p_error':
+                self.log.warning('%r not defined as a function', n)
+            if ((isinstance(v, types.FunctionType) and v.__code__.co_argcount == 1) or
+                   (isinstance(v, types.MethodType) and v.__func__.__code__.co_argcount == 2)):
+                if v.__doc__:
+                    try:
+                        doc = v.__doc__.split(' ')
+                        if doc[1] == ':':
+                            self.log.warning('%s:%d: Possible grammar rule %r defined without p_ prefix',
+                                             v.__code__.co_filename, v.__code__.co_firstlineno, n)
+                    except IndexError:
+                        pass
+
+        self.grammar = grammar
+
+# -----------------------------------------------------------------------------
+# yacc(module)
+#
+# Build a parser
+# -----------------------------------------------------------------------------
+
+def yacc(method='LALR', debug=yaccdebug, module=None, tabmodule=tab_module, start=None,
+         check_recursion=True, optimize=False, write_tables=True, debugfile=debug_file,
+         outputdir=None, debuglog=None, errorlog=None, picklefile=None):
+
+    if tabmodule is None:
+        tabmodule = tab_module
+
+    # Reference to the parsing method of the last built parser
+    global parse
+
+    # If pickling is enabled, table files are not created
+    if picklefile:
+        write_tables = 0
+
+    if errorlog is None:
+        errorlog = PlyLogger(sys.stderr)
+
+    # Get the module dictionary used for the parser
+    if module:
+        _items = [(k, getattr(module, k)) for k in dir(module)]
+        pdict = dict(_items)
+        # If no __file__ attribute is available, try to obtain it from the __module__ instead
+        if '__file__' not in pdict:
+            pdict['__file__'] = sys.modules[pdict['__module__']].__file__
+    else:
+        pdict = get_caller_module_dict(2)
+
+    if outputdir is None:
+        # If no output directory is set, the location of the output files
+        # is determined according to the following rules:
+        #     - If tabmodule specifies a package, files go into that package directory
+        #     - Otherwise, files go in the same directory as the specifying module
+        if isinstance(tabmodule, types.ModuleType):
+            srcfile = tabmodule.__file__
+        else:
+            if '.' not in tabmodule:
+                srcfile = pdict['__file__']
+            else:
+                parts = tabmodule.split('.')
+                pkgname = '.'.join(parts[:-1])
+                exec('import %s' % pkgname)
+                srcfile = getattr(sys.modules[pkgname], '__file__', '')
+        outputdir = os.path.dirname(srcfile)
+
+    # Determine if the module is package of a package or not.
+    # If so, fix the tabmodule setting so that tables load correctly
+    pkg = pdict.get('__package__')
+    if pkg and isinstance(tabmodule, str):
+        if '.' not in tabmodule:
+            tabmodule = pkg + '.' + tabmodule
+
+
+
+    # Set start symbol if it's specified directly using an argument
+    if start is not None:
+        pdict['start'] = start
+
+    # Collect parser information from the dictionary
+    pinfo = ParserReflect(pdict, log=errorlog)
+    pinfo.get_all()
+
+    if pinfo.error:
+        raise YaccError('Unable to build parser')
+
+    # Check signature against table files (if any)
+    signature = pinfo.signature()
+
+    # Read the tables
+    try:
+        lr = LRTable()
+        if picklefile:
+            read_signature = lr.read_pickle(picklefile)
+        else:
+            read_signature = lr.read_table(tabmodule)
+        if optimize or (read_signature == signature):
+            try:
+                lr.bind_callables(pinfo.pdict)
+                parser = LRParser(lr, pinfo.error_func)
+                parse = parser.parse
+                return parser
+            except Exception as e:
+                errorlog.warning('There was a problem loading the table file: %r', e)
+    except VersionError as e:
+        errorlog.warning(str(e))
+    except ImportError:
+        pass
+
+    if debuglog is None:
+        if debug:
+            try:
+                debuglog = PlyLogger(open(os.path.join(outputdir, debugfile), 'w'))
+            except IOError as e:
+                errorlog.warning("Couldn't open %r. %s" % (debugfile, e))
+                debuglog = NullLogger()
+        else:
+            debuglog = NullLogger()
+
+    debuglog.info('Created by PLY version %s (http://www.dabeaz.com/ply)', __version__)
+
+    errors = False
+
+    # Validate the parser information
+    if pinfo.validate_all():
+        raise YaccError('Unable to build parser')
+
+    if not pinfo.error_func:
+        errorlog.warning('no p_error() function is defined')
+
+    # Create a grammar object
+    grammar = Grammar(pinfo.tokens)
+
+    # Set precedence level for terminals
+    for term, assoc, level in pinfo.preclist:
+        try:
+            grammar.set_precedence(term, assoc, level)
+        except GrammarError as e:
+            errorlog.warning('%s', e)
+
+    # Add productions to the grammar
+    for funcname, gram in pinfo.grammar:
+        file, line, prodname, syms = gram
+        try:
+            grammar.add_production(prodname, syms, funcname, file, line)
+        except GrammarError as e:
+            errorlog.error('%s', e)
+            errors = True
+
+    # Set the grammar start symbols
+    try:
+        if start is None:
+            grammar.set_start(pinfo.start)
+        else:
+            grammar.set_start(start)
+    except GrammarError as e:
+        errorlog.error(str(e))
+        errors = True
+
+    if errors:
+        raise YaccError('Unable to build parser')
+
+    # Verify the grammar structure
+    undefined_symbols = grammar.undefined_symbols()
+    for sym, prod in undefined_symbols:
+        errorlog.error('%s:%d: Symbol %r used, but not defined as a token or a rule', prod.file, prod.line, sym)
+        errors = True
+
+    unused_terminals = grammar.unused_terminals()
+    if unused_terminals:
+        debuglog.info('')
+        debuglog.info('Unused terminals:')
+        debuglog.info('')
+        for term in unused_terminals:
+            errorlog.warning('Token %r defined, but not used', term)
+            debuglog.info('    %s', term)
+
+    # Print out all productions to the debug log
+    if debug:
+        debuglog.info('')
+        debuglog.info('Grammar')
+        debuglog.info('')
+        for n, p in enumerate(grammar.Productions):
+            debuglog.info('Rule %-5d %s', n, p)
+
+    # Find unused non-terminals
+    unused_rules = grammar.unused_rules()
+    for prod in unused_rules:
+        errorlog.warning('%s:%d: Rule %r defined, but not used', prod.file, prod.line, prod.name)
+
+    if len(unused_terminals) == 1:
+        errorlog.warning('There is 1 unused token')
+    if len(unused_terminals) > 1:
+        errorlog.warning('There are %d unused tokens', len(unused_terminals))
+
+    if len(unused_rules) == 1:
+        errorlog.warning('There is 1 unused rule')
+    if len(unused_rules) > 1:
+        errorlog.warning('There are %d unused rules', len(unused_rules))
+
+    if debug:
+        debuglog.info('')
+        debuglog.info('Terminals, with rules where they appear')
+        debuglog.info('')
+        terms = list(grammar.Terminals)
+        terms.sort()
+        for term in terms:
+            debuglog.info('%-20s : %s', term, ' '.join([str(s) for s in grammar.Terminals[term]]))
+
+        debuglog.info('')
+        debuglog.info('Nonterminals, with rules where they appear')
+        debuglog.info('')
+        nonterms = list(grammar.Nonterminals)
+        nonterms.sort()
+        for nonterm in nonterms:
+            debuglog.info('%-20s : %s', nonterm, ' '.join([str(s) for s in grammar.Nonterminals[nonterm]]))
+        debuglog.info('')
+
+    if check_recursion:
+        unreachable = grammar.find_unreachable()
+        for u in unreachable:
+            errorlog.warning('Symbol %r is unreachable', u)
+
+        infinite = grammar.infinite_cycles()
+        for inf in infinite:
+            errorlog.error('Infinite recursion detected for symbol %r', inf)
+            errors = True
+
+    unused_prec = grammar.unused_precedence()
+    for term, assoc in unused_prec:
+        errorlog.error('Precedence rule %r defined for unknown symbol %r', assoc, term)
+        errors = True
+
+    if errors:
+        raise YaccError('Unable to build parser')
+
+    # Run the LRGeneratedTable on the grammar
+    if debug:
+        errorlog.debug('Generating %s tables', method)
+
+    lr = LRGeneratedTable(grammar, method, debuglog)
+
+    if debug:
+        num_sr = len(lr.sr_conflicts)
+
+        # Report shift/reduce and reduce/reduce conflicts
+        if num_sr == 1:
+            errorlog.warning('1 shift/reduce conflict')
+        elif num_sr > 1:
+            errorlog.warning('%d shift/reduce conflicts', num_sr)
+
+        num_rr = len(lr.rr_conflicts)
+        if num_rr == 1:
+            errorlog.warning('1 reduce/reduce conflict')
+        elif num_rr > 1:
+            errorlog.warning('%d reduce/reduce conflicts', num_rr)
+
+    # Write out conflicts to the output file
+    if debug and (lr.sr_conflicts or lr.rr_conflicts):
+        debuglog.warning('')
+        debuglog.warning('Conflicts:')
+        debuglog.warning('')
+
+        for state, tok, resolution in lr.sr_conflicts:
+            debuglog.warning('shift/reduce conflict for %s in state %d resolved as %s',  tok, state, resolution)
+
+        already_reported = set()
+        for state, rule, rejected in lr.rr_conflicts:
+            if (state, id(rule), id(rejected)) in already_reported:
+                continue
+            debuglog.warning('reduce/reduce conflict in state %d resolved using rule (%s)', state, rule)
+            debuglog.warning('rejected rule (%s) in state %d', rejected, state)
+            errorlog.warning('reduce/reduce conflict in state %d resolved using rule (%s)', state, rule)
+            errorlog.warning('rejected rule (%s) in state %d', rejected, state)
+            already_reported.add((state, id(rule), id(rejected)))
+
+        warned_never = []
+        for state, rule, rejected in lr.rr_conflicts:
+            if not rejected.reduced and (rejected not in warned_never):
+                debuglog.warning('Rule (%s) is never reduced', rejected)
+                errorlog.warning('Rule (%s) is never reduced', rejected)
+                warned_never.append(rejected)
+
+    # Write the table file if requested
+    if write_tables:
+        try:
+            lr.write_table(tabmodule, outputdir, signature)
+        except IOError as e:
+            errorlog.warning("Couldn't create %r. %s" % (tabmodule, e))
+
+    # Write a pickled version of the tables
+    if picklefile:
+        try:
+            lr.pickle_table(picklefile, signature)
+        except IOError as e:
+            errorlog.warning("Couldn't create %r. %s" % (picklefile, e))
+
+    # Build the parser
+    lr.bind_callables(pinfo.pdict)
+    parser = LRParser(lr, pinfo.error_func)
+
+    parse = parser.parse
+    return parser
diff --git a/myenv/lib/python3.9/site-packages/pycparser/ply/ygen.py b/myenv/lib/python3.9/site-packages/pycparser/ply/ygen.py
new file mode 100644
index 0000000..acf5ca1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/ply/ygen.py
@@ -0,0 +1,74 @@
+# ply: ygen.py
+#
+# This is a support program that auto-generates different versions of the YACC parsing
+# function with different features removed for the purposes of performance.
+#
+# Users should edit the method LParser.parsedebug() in yacc.py.   The source code 
+# for that method is then used to create the other methods.   See the comments in
+# yacc.py for further details.
+
+import os.path
+import shutil
+
+def get_source_range(lines, tag):
+    srclines = enumerate(lines)
+    start_tag = '#--! %s-start' % tag
+    end_tag = '#--! %s-end' % tag
+
+    for start_index, line in srclines:
+        if line.strip().startswith(start_tag):
+            break
+
+    for end_index, line in srclines:
+        if line.strip().endswith(end_tag):
+            break
+
+    return (start_index + 1, end_index)
+
+def filter_section(lines, tag):
+    filtered_lines = []
+    include = True
+    tag_text = '#--! %s' % tag
+    for line in lines:
+        if line.strip().startswith(tag_text):
+            include = not include
+        elif include:
+            filtered_lines.append(line)
+    return filtered_lines
+
+def main():
+    dirname = os.path.dirname(__file__)
+    shutil.copy2(os.path.join(dirname, 'yacc.py'), os.path.join(dirname, 'yacc.py.bak'))
+    with open(os.path.join(dirname, 'yacc.py'), 'r') as f:
+        lines = f.readlines()
+
+    parse_start, parse_end = get_source_range(lines, 'parsedebug')
+    parseopt_start, parseopt_end = get_source_range(lines, 'parseopt')
+    parseopt_notrack_start, parseopt_notrack_end = get_source_range(lines, 'parseopt-notrack')
+
+    # Get the original source
+    orig_lines = lines[parse_start:parse_end]
+
+    # Filter the DEBUG sections out
+    parseopt_lines = filter_section(orig_lines, 'DEBUG')
+
+    # Filter the TRACKING sections out
+    parseopt_notrack_lines = filter_section(parseopt_lines, 'TRACKING')
+
+    # Replace the parser source sections with updated versions
+    lines[parseopt_notrack_start:parseopt_notrack_end] = parseopt_notrack_lines
+    lines[parseopt_start:parseopt_end] = parseopt_lines
+
+    lines = [line.rstrip()+'\n' for line in lines]
+    with open(os.path.join(dirname, 'yacc.py'), 'w') as f:
+        f.writelines(lines)
+
+    print('Updated yacc.py')
+
+if __name__ == '__main__':
+    main()
+
+
+
+
+
diff --git a/myenv/lib/python3.9/site-packages/pycparser/plyparser.py b/myenv/lib/python3.9/site-packages/pycparser/plyparser.py
new file mode 100644
index 0000000..b8f4c43
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/plyparser.py
@@ -0,0 +1,133 @@
+#-----------------------------------------------------------------
+# plyparser.py
+#
+# PLYParser class and other utilities for simplifying programming
+# parsers with PLY
+#
+# Eli Bendersky [https://eli.thegreenplace.net/]
+# License: BSD
+#-----------------------------------------------------------------
+
+import warnings
+
+class Coord(object):
+    """ Coordinates of a syntactic element. Consists of:
+            - File name
+            - Line number
+            - (optional) column number, for the Lexer
+    """
+    __slots__ = ('file', 'line', 'column', '__weakref__')
+    def __init__(self, file, line, column=None):
+        self.file = file
+        self.line = line
+        self.column = column
+
+    def __str__(self):
+        str = "%s:%s" % (self.file, self.line)
+        if self.column: str += ":%s" % self.column
+        return str
+
+
+class ParseError(Exception): pass
+
+
+class PLYParser(object):
+    def _create_opt_rule(self, rulename):
+        """ Given a rule name, creates an optional ply.yacc rule
+            for it. The name of the optional rule is
+            <rulename>_opt
+        """
+        optname = rulename + '_opt'
+
+        def optrule(self, p):
+            p[0] = p[1]
+
+        optrule.__doc__ = '%s : empty\n| %s' % (optname, rulename)
+        optrule.__name__ = 'p_%s' % optname
+        setattr(self.__class__, optrule.__name__, optrule)
+
+    def _coord(self, lineno, column=None):
+        return Coord(
+                file=self.clex.filename,
+                line=lineno,
+                column=column)
+
+    def _token_coord(self, p, token_idx):
+        """ Returns the coordinates for the YaccProduction object 'p' indexed
+            with 'token_idx'. The coordinate includes the 'lineno' and
+            'column'. Both follow the lex semantic, starting from 1.
+        """
+        last_cr = p.lexer.lexer.lexdata.rfind('\n', 0, p.lexpos(token_idx))
+        if last_cr < 0:
+            last_cr = -1
+        column = (p.lexpos(token_idx) - (last_cr))
+        return self._coord(p.lineno(token_idx), column)
+
+    def _parse_error(self, msg, coord):
+        raise ParseError("%s: %s" % (coord, msg))
+
+
+def parameterized(*params):
+    """ Decorator to create parameterized rules.
+
+    Parameterized rule methods must be named starting with 'p_' and contain
+    'xxx', and their docstrings may contain 'xxx' and 'yyy'. These will be
+    replaced by the given parameter tuples. For example, ``p_xxx_rule()`` with
+    docstring 'xxx_rule  : yyy' when decorated with
+    ``@parameterized(('id', 'ID'))`` produces ``p_id_rule()`` with the docstring
+    'id_rule  : ID'. Using multiple tuples produces multiple rules.
+    """
+    def decorate(rule_func):
+        rule_func._params = params
+        return rule_func
+    return decorate
+
+
+def template(cls):
+    """ Class decorator to generate rules from parameterized rule templates.
+
+    See `parameterized` for more information on parameterized rules.
+    """
+    issued_nodoc_warning = False
+    for attr_name in dir(cls):
+        if attr_name.startswith('p_'):
+            method = getattr(cls, attr_name)
+            if hasattr(method, '_params'):
+                # Remove the template method
+                delattr(cls, attr_name)
+                # Create parameterized rules from this method; only run this if
+                # the method has a docstring. This is to address an issue when
+                # pycparser's users are installed in -OO mode which strips
+                # docstrings away.
+                # See: https://github.com/eliben/pycparser/pull/198/ and
+                #      https://github.com/eliben/pycparser/issues/197
+                # for discussion.
+                if method.__doc__ is not None:
+                    _create_param_rules(cls, method)
+                elif not issued_nodoc_warning:
+                    warnings.warn(
+                        'parsing methods must have __doc__ for pycparser to work properly',
+                        RuntimeWarning,
+                        stacklevel=2)
+                    issued_nodoc_warning = True
+    return cls
+
+
+def _create_param_rules(cls, func):
+    """ Create ply.yacc rules based on a parameterized rule function
+
+    Generates new methods (one per each pair of parameters) based on the
+    template rule function `func`, and attaches them to `cls`. The rule
+    function's parameters must be accessible via its `_params` attribute.
+    """
+    for xxx, yyy in func._params:
+        # Use the template method's body for each new method
+        def param_rule(self, p):
+            func(self, p)
+
+        # Substitute in the params for the grammar rule and function name
+        param_rule.__doc__ = func.__doc__.replace('xxx', xxx).replace('yyy', yyy)
+        param_rule.__name__ = func.__name__.replace('xxx', xxx)
+
+        # Attach the new method to the class
+        setattr(cls, param_rule.__name__, param_rule)
diff --git a/myenv/lib/python3.9/site-packages/pycparser/yacctab.py b/myenv/lib/python3.9/site-packages/pycparser/yacctab.py
new file mode 100644
index 0000000..0622c36
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pycparser/yacctab.py
@@ -0,0 +1,366 @@
+
+# yacctab.py
+# This file is automatically generated. Do not edit.
+_tabversion = '3.10'
+
+_lr_method = 'LALR'
+
+_lr_signature = 'translation_unit_or_emptyleftLORleftLANDleftORleftXORleftANDleftEQNEleftGTGELTLEleftRSHIFTLSHIFTleftPLUSMINUSleftTIMESDIVIDEMODAUTO BREAK CASE CHAR CONST CONTINUE DEFAULT DO DOUBLE ELSE ENUM EXTERN FLOAT FOR GOTO IF INLINE INT LONG REGISTER OFFSETOF RESTRICT RETURN SHORT SIGNED SIZEOF STATIC STRUCT SWITCH TYPEDEF UNION UNSIGNED VOID VOLATILE WHILE __INT128 _BOOL _COMPLEX _NORETURN _THREAD_LOCAL _STATIC_ASSERT _ATOMIC _ALIGNOF _ALIGNAS ID TYPEID INT_CONST_DEC INT_CONST_OCT INT_CONST_HEX INT_CONST_BIN INT_CONST_CHAR FLOAT_CONST HEX_FLOAT_CONST CHAR_CONST WCHAR_CONST U8CHAR_CONST U16CHAR_CONST U32CHAR_CONST STRING_LITERAL WSTRING_LITERAL U8STRING_LITERAL U16STRING_LITERAL U32STRING_LITERAL PLUS MINUS TIMES DIVIDE MOD OR AND NOT XOR LSHIFT RSHIFT LOR LAND LNOT LT LE GT GE EQ NE EQUALS TIMESEQUAL DIVEQUAL MODEQUAL PLUSEQUAL MINUSEQUAL LSHIFTEQUAL RSHIFTEQUAL ANDEQUAL XOREQUAL OREQUAL PLUSPLUS MINUSMINUS ARROW CONDOP LPAREN RPAREN LBRACKET RBRACKET LBRACE RBRACE COMMA PERIOD SEMI COLON ELLIPSIS PPHASH PPPRAGMA PPPRAGMASTRabstract_declarator_opt : empty\n| abstract_declaratorassignment_expression_opt : empty\n| assignment_expressionblock_item_list_opt : empty\n| block_item_listdeclaration_list_opt : empty\n| declaration_listdeclaration_specifiers_no_type_opt : empty\n| declaration_specifiers_no_typedesignation_opt : empty\n| designationexpression_opt : empty\n| expressionid_init_declarator_list_opt : empty\n| id_init_declarator_listidentifier_list_opt : empty\n| identifier_listinit_declarator_list_opt : empty\n| init_declarator_listinitializer_list_opt : empty\n| initializer_listparameter_type_list_opt : empty\n| parameter_type_liststruct_declarator_list_opt : empty\n| struct_declarator_listtype_qualifier_list_opt : empty\n| type_qualifier_list direct_id_declarator   : ID\n         direct_id_declarator   : LPAREN id_declarator RPAREN\n         direct_id_declarator   : direct_id_declarator LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET\n         direct_id_declarator   : direct_id_declarator LBRACKET STATIC type_qualifier_list_opt assignment_expression RBRACKET\n                                    | direct_id_declarator LBRACKET type_qualifier_list STATIC assignment_expression RBRACKET\n         direct_id_declarator   : direct_id_declarator LBRACKET type_qualifier_list_opt TIMES RBRACKET\n         direct_id_declarator   : direct_id_declarator LPAREN parameter_type_list RPAREN\n                                    | direct_id_declarator LPAREN identifier_list_opt RPAREN\n         direct_typeid_declarator   : TYPEID\n         direct_typeid_declarator   : LPAREN typeid_declarator RPAREN\n         direct_typeid_declarator   : direct_typeid_declarator LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET\n         direct_typeid_declarator   : direct_typeid_declarator LBRACKET STATIC type_qualifier_list_opt assignment_expression RBRACKET\n                                    | direct_typeid_declarator LBRACKET type_qualifier_list STATIC assignment_expression RBRACKET\n         direct_typeid_declarator   : direct_typeid_declarator LBRACKET type_qualifier_list_opt TIMES RBRACKET\n         direct_typeid_declarator   : direct_typeid_declarator LPAREN parameter_type_list RPAREN\n                                    | direct_typeid_declarator LPAREN identifier_list_opt RPAREN\n         direct_typeid_noparen_declarator   : TYPEID\n         direct_typeid_noparen_declarator   : direct_typeid_noparen_declarator LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET\n         direct_typeid_noparen_declarator   : direct_typeid_noparen_declarator LBRACKET STATIC type_qualifier_list_opt assignment_expression RBRACKET\n                                    | direct_typeid_noparen_declarator LBRACKET type_qualifier_list STATIC assignment_expression RBRACKET\n         direct_typeid_noparen_declarator   : direct_typeid_noparen_declarator LBRACKET type_qualifier_list_opt TIMES RBRACKET\n         direct_typeid_noparen_declarator   : direct_typeid_noparen_declarator LPAREN parameter_type_list RPAREN\n                                    | direct_typeid_noparen_declarator LPAREN identifier_list_opt RPAREN\n         id_declarator  : direct_id_declarator\n         id_declarator  : pointer direct_id_declarator\n         typeid_declarator  : direct_typeid_declarator\n         typeid_declarator  : pointer direct_typeid_declarator\n         typeid_noparen_declarator  : direct_typeid_noparen_declarator\n         typeid_noparen_declarator  : pointer direct_typeid_noparen_declarator\n         translation_unit_or_empty   : translation_unit\n                                        | empty\n         translation_unit    : external_declaration\n         translation_unit    : translation_unit external_declaration\n         external_declaration    : function_definition\n         external_declaration    : declaration\n         external_declaration    : pp_directive\n                                    | pppragma_directive\n         external_declaration    : SEMI\n         external_declaration    : static_assert\n         static_assert           : _STATIC_ASSERT LPAREN constant_expression COMMA unified_string_literal RPAREN\n                                    | _STATIC_ASSERT LPAREN constant_expression RPAREN\n         pp_directive  : PPHASH\n         pppragma_directive      : PPPRAGMA\n                                    | PPPRAGMA PPPRAGMASTR\n         function_definition : id_declarator declaration_list_opt compound_statement\n         function_definition : declaration_specifiers id_declarator declaration_list_opt compound_statement\n         statement   : labeled_statement\n                        | expression_statement\n                        | compound_statement\n                        | selection_statement\n                        | iteration_statement\n                        | jump_statement\n                        | pppragma_directive\n                        | static_assert\n         pragmacomp_or_statement     : pppragma_directive statement\n                                        | statement\n         decl_body : declaration_specifiers init_declarator_list_opt\n                      | declaration_specifiers_no_type id_init_declarator_list_opt\n         declaration : decl_body SEMI\n         declaration_list    : declaration\n                                | declaration_list declaration\n         declaration_specifiers_no_type  : type_qualifier declaration_specifiers_no_type_opt\n         declaration_specifiers_no_type  : storage_class_specifier declaration_specifiers_no_type_opt\n         declaration_specifiers_no_type  : function_specifier declaration_specifiers_no_type_opt\n         declaration_specifiers_no_type  : atomic_specifier declaration_specifiers_no_type_opt\n         declaration_specifiers_no_type  : alignment_specifier declaration_specifiers_no_type_opt\n         declaration_specifiers  : declaration_specifiers type_qualifier\n         declaration_specifiers  : declaration_specifiers storage_class_specifier\n         declaration_specifiers  : declaration_specifiers function_specifier\n         declaration_specifiers  : declaration_specifiers type_specifier_no_typeid\n         declaration_specifiers  : type_specifier\n         declaration_specifiers  : declaration_specifiers_no_type type_specifier\n         declaration_specifiers  : declaration_specifiers alignment_specifier\n         storage_class_specifier : AUTO\n                                    | REGISTER\n                                    | STATIC\n                                    | EXTERN\n                                    | TYPEDEF\n                                    | _THREAD_LOCAL\n         function_specifier  : INLINE\n                                | _NORETURN\n         type_specifier_no_typeid  : VOID\n                                      | _BOOL\n                                      | CHAR\n                                      | SHORT\n                                      | INT\n                                      | LONG\n                                      | FLOAT\n                                      | DOUBLE\n                                      | _COMPLEX\n                                      | SIGNED\n                                      | UNSIGNED\n                                      | __INT128\n         type_specifier  : typedef_name\n                            | enum_specifier\n                            | struct_or_union_specifier\n                            | type_specifier_no_typeid\n                            | atomic_specifier\n         atomic_specifier  : _ATOMIC LPAREN type_name RPAREN\n         type_qualifier  : CONST\n                            | RESTRICT\n                            | VOLATILE\n                            | _ATOMIC\n         init_declarator_list    : init_declarator\n                                    | init_declarator_list COMMA init_declarator\n         init_declarator : declarator\n                            | declarator EQUALS initializer\n         id_init_declarator_list    : id_init_declarator\n                                       | id_init_declarator_list COMMA init_declarator\n         id_init_declarator : id_declarator\n                               | id_declarator EQUALS initializer\n         specifier_qualifier_list    : specifier_qualifier_list type_specifier_no_typeid\n         specifier_qualifier_list    : specifier_qualifier_list type_qualifier\n         specifier_qualifier_list  : type_specifier\n         specifier_qualifier_list  : type_qualifier_list type_specifier\n         specifier_qualifier_list  : alignment_specifier\n         specifier_qualifier_list  : specifier_qualifier_list alignment_specifier\n         struct_or_union_specifier   : struct_or_union ID\n                                        | struct_or_union TYPEID\n         struct_or_union_specifier : struct_or_union brace_open struct_declaration_list brace_close\n                                      | struct_or_union brace_open brace_close\n         struct_or_union_specifier   : struct_or_union ID brace_open struct_declaration_list brace_close\n                                        | struct_or_union ID brace_open brace_close\n                                        | struct_or_union TYPEID brace_open struct_declaration_list brace_close\n                                        | struct_or_union TYPEID brace_open brace_close\n         struct_or_union : STRUCT\n                            | UNION\n         struct_declaration_list     : struct_declaration\n                                        | struct_declaration_list struct_declaration\n         struct_declaration : specifier_qualifier_list struct_declarator_list_opt SEMI\n         struct_declaration : SEMI\n         struct_declaration : pppragma_directive\n         struct_declarator_list  : struct_declarator\n                                    | struct_declarator_list COMMA struct_declarator\n         struct_declarator : declarator\n         struct_declarator   : declarator COLON constant_expression\n                                | COLON constant_expression\n         enum_specifier  : ENUM ID\n                            | ENUM TYPEID\n         enum_specifier  : ENUM brace_open enumerator_list brace_close\n         enum_specifier  : ENUM ID brace_open enumerator_list brace_close\n                            | ENUM TYPEID brace_open enumerator_list brace_close\n         enumerator_list : enumerator\n                            | enumerator_list COMMA\n                            | enumerator_list COMMA enumerator\n         alignment_specifier  : _ALIGNAS LPAREN type_name RPAREN\n                                 | _ALIGNAS LPAREN constant_expression RPAREN\n         enumerator  : ID\n                        | ID EQUALS constant_expression\n         declarator  : id_declarator\n                        | typeid_declarator\n         pointer : TIMES type_qualifier_list_opt\n                    | TIMES type_qualifier_list_opt pointer\n         type_qualifier_list : type_qualifier\n                                | type_qualifier_list type_qualifier\n         parameter_type_list : parameter_list\n                                | parameter_list COMMA ELLIPSIS\n         parameter_list  : parameter_declaration\n                            | parameter_list COMMA parameter_declaration\n         parameter_declaration   : declaration_specifiers id_declarator\n                                    | declaration_specifiers typeid_noparen_declarator\n         parameter_declaration   : declaration_specifiers abstract_declarator_opt\n         identifier_list : identifier\n                            | identifier_list COMMA identifier\n         initializer : assignment_expression\n         initializer : brace_open initializer_list_opt brace_close\n                        | brace_open initializer_list COMMA brace_close\n         initializer_list    : designation_opt initializer\n                                | initializer_list COMMA designation_opt initializer\n         designation : designator_list EQUALS\n         designator_list : designator\n                            | designator_list designator\n         designator  : LBRACKET constant_expression RBRACKET\n                        | PERIOD identifier\n         type_name   : specifier_qualifier_list abstract_declarator_opt\n         abstract_declarator     : pointer\n         abstract_declarator     : pointer direct_abstract_declarator\n         abstract_declarator     : direct_abstract_declarator\n         direct_abstract_declarator  : LPAREN abstract_declarator RPAREN  direct_abstract_declarator  : direct_abstract_declarator LBRACKET assignment_expression_opt RBRACKET\n         direct_abstract_declarator  : LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET\n         direct_abstract_declarator  : direct_abstract_declarator LBRACKET TIMES RBRACKET\n         direct_abstract_declarator  : LBRACKET TIMES RBRACKET\n         direct_abstract_declarator  : direct_abstract_declarator LPAREN parameter_type_list_opt RPAREN\n         direct_abstract_declarator  : LPAREN parameter_type_list_opt RPAREN\n         block_item  : declaration\n                        | statement\n         block_item_list : block_item\n                            | block_item_list block_item\n         compound_statement : brace_open block_item_list_opt brace_close  labeled_statement : ID COLON pragmacomp_or_statement  labeled_statement : CASE constant_expression COLON pragmacomp_or_statement  labeled_statement : DEFAULT COLON pragmacomp_or_statement  selection_statement : IF LPAREN expression RPAREN pragmacomp_or_statement  selection_statement : IF LPAREN expression RPAREN statement ELSE pragmacomp_or_statement  selection_statement : SWITCH LPAREN expression RPAREN pragmacomp_or_statement  iteration_statement : WHILE LPAREN expression RPAREN pragmacomp_or_statement  iteration_statement : DO pragmacomp_or_statement WHILE LPAREN expression RPAREN SEMI  iteration_statement : FOR LPAREN expression_opt SEMI expression_opt SEMI expression_opt RPAREN pragmacomp_or_statement  iteration_statement : FOR LPAREN declaration expression_opt SEMI expression_opt RPAREN pragmacomp_or_statement  jump_statement  : GOTO ID SEMI  jump_statement  : BREAK SEMI  jump_statement  : CONTINUE SEMI  jump_statement  : RETURN expression SEMI\n                            | RETURN SEMI\n         expression_statement : expression_opt SEMI  expression  : assignment_expression\n                        | expression COMMA assignment_expression\n         assignment_expression : LPAREN compound_statement RPAREN  typedef_name : TYPEID  assignment_expression   : conditional_expression\n                                    | unary_expression assignment_operator assignment_expression\n         assignment_operator : EQUALS\n                                | XOREQUAL\n                                | TIMESEQUAL\n                                | DIVEQUAL\n                                | MODEQUAL\n                                | PLUSEQUAL\n                                | MINUSEQUAL\n                                | LSHIFTEQUAL\n                                | RSHIFTEQUAL\n                                | ANDEQUAL\n                                | OREQUAL\n         constant_expression : conditional_expression  conditional_expression  : binary_expression\n                                    | binary_expression CONDOP expression COLON conditional_expression\n         binary_expression   : cast_expression\n                                | binary_expression TIMES binary_expression\n                                | binary_expression DIVIDE binary_expression\n                                | binary_expression MOD binary_expression\n                                | binary_expression PLUS binary_expression\n                                | binary_expression MINUS binary_expression\n                                | binary_expression RSHIFT binary_expression\n                                | binary_expression LSHIFT binary_expression\n                                | binary_expression LT binary_expression\n                                | binary_expression LE binary_expression\n                                | binary_expression GE binary_expression\n                                | binary_expression GT binary_expression\n                                | binary_expression EQ binary_expression\n                                | binary_expression NE binary_expression\n                                | binary_expression AND binary_expression\n                                | binary_expression OR binary_expression\n                                | binary_expression XOR binary_expression\n                                | binary_expression LAND binary_expression\n                                | binary_expression LOR binary_expression\n         cast_expression : unary_expression  cast_expression : LPAREN type_name RPAREN cast_expression  unary_expression    : postfix_expression  unary_expression    : PLUSPLUS unary_expression\n                                | MINUSMINUS unary_expression\n                                | unary_operator cast_expression\n         unary_expression    : SIZEOF unary_expression\n                                | SIZEOF LPAREN type_name RPAREN\n                                | _ALIGNOF LPAREN type_name RPAREN\n         unary_operator  : AND\n                            | TIMES\n                            | PLUS\n                            | MINUS\n                            | NOT\n                            | LNOT\n         postfix_expression  : primary_expression  postfix_expression  : postfix_expression LBRACKET expression RBRACKET  postfix_expression  : postfix_expression LPAREN argument_expression_list RPAREN\n                                | postfix_expression LPAREN RPAREN\n         postfix_expression  : postfix_expression PERIOD ID\n                                | postfix_expression PERIOD TYPEID\n                                | postfix_expression ARROW ID\n                                | postfix_expression ARROW TYPEID\n         postfix_expression  : postfix_expression PLUSPLUS\n                                | postfix_expression MINUSMINUS\n         postfix_expression  : LPAREN type_name RPAREN brace_open initializer_list brace_close\n                                | LPAREN type_name RPAREN brace_open initializer_list COMMA brace_close\n         primary_expression  : identifier  primary_expression  : constant  primary_expression  : unified_string_literal\n                                | unified_wstring_literal\n         primary_expression  : LPAREN expression RPAREN  primary_expression  : OFFSETOF LPAREN type_name COMMA offsetof_member_designator RPAREN\n         offsetof_member_designator : identifier\n                                         | offsetof_member_designator PERIOD identifier\n                                         | offsetof_member_designator LBRACKET expression RBRACKET\n         argument_expression_list    : assignment_expression\n                                        | argument_expression_list COMMA assignment_expression\n         identifier  : ID  constant    : INT_CONST_DEC\n                        | INT_CONST_OCT\n                        | INT_CONST_HEX\n                        | INT_CONST_BIN\n                        | INT_CONST_CHAR\n         constant    : FLOAT_CONST\n                        | HEX_FLOAT_CONST\n         constant    : CHAR_CONST\n                        | WCHAR_CONST\n                        | U8CHAR_CONST\n                        | U16CHAR_CONST\n                        | U32CHAR_CONST\n         unified_string_literal  : STRING_LITERAL\n                                    | unified_string_literal STRING_LITERAL\n         unified_wstring_literal : WSTRING_LITERAL\n                                    | U8STRING_LITERAL\n                                    | U16STRING_LITERAL\n                                    | U32STRING_LITERAL\n                                    | unified_wstring_literal WSTRING_LITERAL\n                                    | unified_wstring_literal U8STRING_LITERAL\n                                    | unified_wstring_literal U16STRING_LITERAL\n                                    | unified_wstring_literal U32STRING_LITERAL\n         brace_open  :   LBRACE\n         brace_close :   RBRACE\n        empty : '
+    
+_lr_action_items = {'INT_CONST_CHAR':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,132,-335,-28,-182,-27,132,-337,-87,-72,-337,132,-286,-285,132,132,-283,-287,-288,132,-284,132,132,132,-336,-183,132,132,-28,-337,132,-28,-337,-337,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,-337,-76,-79,-82,-75,132,-77,132,132,-81,-215,-214,-80,-216,132,-78,132,132,-69,-284,132,132,-284,132,132,-244,-247,-245,-241,-242,-246,-248,132,-250,-251,-243,-249,-12,132,132,-11,132,132,132,132,-234,-233,132,-231,132,132,-217,132,-230,132,-84,-218,132,132,132,-337,-337,-198,132,132,132,-337,-284,-229,-232,132,-221,132,-83,-219,-68,132,-28,-337,132,-11,132,132,-220,132,132,132,-284,132,132,132,-337,132,-225,-224,-222,-84,132,132,132,-226,-223,132,-228,-227,]),'VOID':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[6,-337,-113,-128,6,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,6,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,6,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,6,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,6,-131,-95,-101,-97,6,-53,-126,6,-88,6,6,-93,6,-147,-335,-146,6,-167,-166,-182,-100,-126,6,-87,-90,-94,-92,-61,-72,6,-144,-142,6,6,6,-73,6,-89,6,6,6,-149,-159,-160,-156,-336,6,-183,-30,6,6,-74,6,6,6,6,-174,-175,6,-143,-140,6,-141,-145,-76,-79,-82,-75,-77,6,-81,-215,-214,-80,-216,-78,-127,6,-153,6,-151,-148,-157,-168,-69,-36,-35,6,6,6,-234,-233,6,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,6,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'LBRACKET':([2,3,5,6,7,10,11,12,13,18,20,22,23,26,27,30,33,34,35,36,39,42,43,44,46,48,49,50,54,56,58,60,62,68,71,73,76,77,80,81,82,86,96,97,98,100,101,103,104,105,106,109,111,127,132,133,134,136,138,139,140,141,142,143,145,147,148,152,153,154,156,160,161,163,164,166,167,168,169,176,177,187,191,198,199,200,211,216,227,230,235,236,237,238,240,241,261,263,269,275,276,278,279,280,283,310,312,314,316,317,328,340,341,342,344,345,347,355,356,371,376,402,403,404,405,407,411,414,442,443,448,449,453,454,457,458,464,465,470,472,474,482,483,488,489,490,492,511,512,518,519,520,526,527,529,530,531,532,544,545,547,550,551,559,560,563,565,570,571,572,],[-113,-128,-124,-110,-106,-104,-107,-125,-105,-99,-109,-120,-115,-102,-126,-108,-238,-111,-337,-122,-129,-29,-121,-116,-112,117,-123,-117,-119,-114,-130,-118,-103,-96,-98,128,-131,-37,-95,-101,-97,117,-147,-335,-146,-167,-166,-28,-180,-182,-27,-100,-126,128,-317,-321,-318,-303,-324,-330,-313,-319,-144,-301,-314,-142,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,265,-323,-312,282,-149,-336,-183,-181,-30,282,-38,373,-326,-334,-332,-331,-333,-174,-175,-298,-297,-143,-140,282,282,-141,-145,421,-312,-127,-153,-151,-148,-168,-36,-35,282,282,459,-45,-44,-43,-199,373,-296,-295,-294,-293,-292,-305,421,-152,-150,-170,-169,-31,-34,282,459,-39,-42,-202,373,-200,-290,-291,373,-213,-207,-211,-33,-32,-41,-40,-201,549,-307,-209,-208,-210,-212,-51,-50,-306,373,-299,-46,-49,-308,-300,-48,-47,-309,]),'WCHAR_CONST':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,133,-335,-28,-182,-27,133,-337,-87,-72,-337,133,-286,-285,133,133,-283,-287,-288,133,-284,133,133,133,-336,-183,133,133,-28,-337,133,-28,-337,-337,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,-337,-76,-79,-82,-75,133,-77,133,133,-81,-215,-214,-80,-216,133,-78,133,133,-69,-284,133,133,-284,133,133,-244,-247,-245,-241,-242,-246,-248,133,-250,-251,-243,-249,-12,133,133,-11,133,133,133,133,-234,-233,133,-231,133,133,-217,133,-230,133,-84,-218,133,133,133,-337,-337,-198,133,133,133,-337,-284,-229,-232,133,-221,133,-83,-219,-68,133,-28,-337,133,-11,133,133,-220,133,133,133,-284,133,133,133,-337,133,-225,-224,-222,-84,133,133,133,-226,-223,133,-228,-227,]),'FLOAT_CONST':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,134,-335,-28,-182,-27,134,-337,-87,-72,-337,134,-286,-285,134,134,-283,-287,-288,134,-284,134,134,134,-336,-183,134,134,-28,-337,134,-28,-337,-337,134,134,134,134,134,134,134,134,134,134,134,134,134,134,134,134,134,134,134,134,134,134,134,134,-337,-76,-79,-82,-75,134,-77,134,134,-81,-215,-214,-80,-216,134,-78,134,134,-69,-284,134,134,-284,134,134,-244,-247,-245,-241,-242,-246,-248,134,-250,-251,-243,-249,-12,134,134,-11,134,134,134,134,-234,-233,134,-231,134,134,-217,134,-230,134,-84,-218,134,134,134,-337,-337,-198,134,134,134,-337,-284,-229,-232,134,-221,134,-83,-219,-68,134,-28,-337,134,-11,134,134,-220,134,134,134,-284,134,134,134,-337,134,-225,-224,-222,-84,134,134,134,-226,-223,134,-228,-227,]),'MINUS':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,132,133,134,135,136,137,138,139,140,141,143,144,145,146,148,149,150,151,152,153,154,156,158,160,161,162,163,164,165,166,167,168,169,171,173,174,175,176,181,191,198,201,204,205,206,218,219,220,224,227,229,230,231,232,233,234,235,236,237,238,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,263,265,266,268,273,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,310,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,478,480,481,482,483,484,487,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,547,549,550,551,553,554,555,557,558,565,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,135,-335,-28,-182,-27,135,-337,-87,-72,-337,135,-317,-321,-318,-286,-303,-285,-324,-330,-313,-319,-301,-274,-314,135,-327,135,-283,-287,-325,-304,-322,-302,-255,-315,-289,245,-328,-316,-288,-329,-320,-276,-323,135,-284,135,135,-312,135,-336,-183,135,135,-28,-337,135,-28,-337,-274,-337,135,-326,135,-280,135,-277,-334,-332,-331,-333,135,135,135,135,135,135,135,135,135,135,135,135,135,135,135,135,135,135,135,-298,-297,135,135,-279,-278,-337,-76,-79,-82,-75,135,-77,135,135,-81,-215,-214,-80,-216,135,-78,-312,135,135,-69,-284,135,135,-284,135,135,-244,-247,-245,-241,-242,-246,-248,135,-250,-251,-243,-249,-12,135,135,-11,245,245,245,-260,245,245,245,-259,245,245,-257,-256,245,245,245,245,245,-258,-296,-295,-294,-293,-292,-305,135,135,135,135,-234,-233,135,-231,135,135,-217,135,-230,135,-84,-218,135,135,135,-337,-337,-198,135,-281,-282,135,-290,-291,135,-275,-337,-284,-229,-232,135,-221,135,-83,-219,-68,135,-28,-337,135,-11,135,135,-220,135,135,135,-284,135,135,-306,135,-337,-299,135,-225,-224,-222,-84,-300,135,135,135,-226,-223,135,-228,-227,]),'RPAREN':([2,3,5,6,7,10,11,12,13,18,20,22,23,26,27,30,33,34,35,36,39,42,43,44,46,48,49,50,54,56,58,60,62,68,71,73,76,77,80,81,82,86,96,98,100,101,103,104,105,106,107,109,111,118,125,127,129,132,133,134,136,138,139,140,141,142,143,144,145,147,148,152,153,154,156,157,158,159,160,161,162,163,164,166,167,168,169,176,177,178,183,187,191,198,199,200,203,207,208,209,210,211,212,213,215,216,221,222,224,225,230,232,234,235,236,237,238,240,241,261,263,266,268,269,270,271,272,273,274,275,276,277,278,279,280,281,283,294,312,314,316,317,328,340,341,342,343,344,345,346,347,348,355,356,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,408,409,411,414,415,416,417,418,422,433,439,442,443,448,449,452,453,454,457,458,460,461,462,463,464,465,468,476,478,480,482,483,486,487,489,490,492,495,501,503,507,511,512,516,517,518,519,524,525,526,527,529,530,531,532,544,545,547,551,553,556,559,560,563,565,566,567,570,571,572,573,],[-113,-128,-124,-110,-106,-104,-107,-125,-105,-99,-109,-120,-115,-102,-126,-108,-238,-111,-337,-122,-129,-29,-121,-116,-112,-52,-123,-117,-119,-114,-130,-118,-103,-96,-98,-54,-131,-37,-95,-101,-97,-53,-147,-146,-167,-166,-28,-180,-182,-27,200,-100,-126,-337,216,-55,-337,-317,-321,-318,-303,-324,-330,-313,-319,-144,-301,-274,-314,-142,-327,-325,-304,-322,-302,240,-255,241,-315,-289,-253,-328,-316,-329,-320,-276,-323,-312,-337,-252,312,-149,-336,-183,-181,-30,332,340,-17,341,-186,-337,-18,-184,-191,-38,355,356,-274,-239,-326,-280,-277,-334,-332,-331,-333,-174,-175,-298,-297,407,-279,-143,411,413,-235,-278,-203,-140,-204,-1,-337,-141,-145,-2,-206,-14,-127,-153,-151,-148,-168,-36,-35,-337,-190,-204,-56,-188,-45,-189,-44,-43,476,477,478,479,480,-261,-273,-262,-260,-264,-268,-263,-259,-266,-271,-257,-256,-265,-272,-267,-269,-270,-258,-296,-295,-294,-293,-292,-310,483,-305,-205,-23,-24,489,490,-337,-13,-218,-152,-150,-170,-169,510,-31,-34,-204,-57,-337,-192,-185,-187,-39,-42,-240,-237,-281,-282,-290,-291,-236,-275,-213,-207,-211,532,535,537,539,-33,-32,544,545,-41,-40,-254,-311,547,-307,-209,-208,-210,-212,-51,-50,-306,-299,-337,568,-46,-49,-308,-300,-337,574,-48,-47,-309,577,]),'STRUCT':([0,1,3,7,10,11,13,14,16,17,19,20,21,25,26,27,29,30,38,39,40,42,45,47,48,52,53,55,58,59,61,62,63,64,65,66,67,75,85,86,87,90,91,93,94,95,97,99,105,118,119,120,121,122,123,124,129,172,174,180,181,182,184,185,186,188,189,190,191,198,200,214,223,229,231,233,239,240,241,267,278,284,285,286,289,291,298,300,301,302,303,305,308,312,313,315,318,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,446,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[24,-337,-128,-106,-104,-107,-105,-64,-60,-67,-66,-109,24,-65,-102,-337,-131,-108,-63,-129,24,-29,-62,-70,-52,-337,-337,-337,-130,24,-71,-103,-337,-9,-131,-91,-10,24,24,-53,-337,-88,24,24,-93,24,-335,24,-182,24,-87,-90,-94,-92,-61,-72,24,24,24,-73,24,-89,24,24,24,-159,-160,-156,-336,-183,-30,24,-74,24,24,24,24,-174,-175,24,24,-76,-79,-82,-75,-77,24,-81,-215,-214,-80,-216,-78,-127,24,24,-157,-69,-36,-35,24,24,24,-234,-233,24,-231,-217,-230,-81,-84,-218,-158,-31,-34,24,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'LONG':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[23,-337,-113,-128,23,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,23,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,23,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,23,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,23,-131,-95,-101,-97,23,-53,-126,23,-88,23,23,-93,23,-147,-335,-146,23,-167,-166,-182,-100,-126,23,-87,-90,-94,-92,-61,-72,23,-144,-142,23,23,23,-73,23,-89,23,23,23,-149,-159,-160,-156,-336,23,-183,-30,23,23,-74,23,23,23,23,-174,-175,23,-143,-140,23,-141,-145,-76,-79,-82,-75,-77,23,-81,-215,-214,-80,-216,-78,-127,23,-153,23,-151,-148,-157,-168,-69,-36,-35,23,23,23,-234,-233,23,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,23,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'PLUS':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,132,133,134,135,136,137,138,139,140,141,143,144,145,146,148,149,150,151,152,153,154,156,158,160,161,162,163,164,165,166,167,168,169,171,173,174,175,176,181,191,198,201,204,205,206,218,219,220,224,227,229,230,231,232,233,234,235,236,237,238,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,263,265,266,268,273,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,310,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,478,480,481,482,483,484,487,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,547,549,550,551,553,554,555,557,558,565,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,137,-335,-28,-182,-27,137,-337,-87,-72,-337,137,-317,-321,-318,-286,-303,-285,-324,-330,-313,-319,-301,-274,-314,137,-327,137,-283,-287,-325,-304,-322,-302,-255,-315,-289,249,-328,-316,-288,-329,-320,-276,-323,137,-284,137,137,-312,137,-336,-183,137,137,-28,-337,137,-28,-337,-274,-337,137,-326,137,-280,137,-277,-334,-332,-331,-333,137,137,137,137,137,137,137,137,137,137,137,137,137,137,137,137,137,137,137,-298,-297,137,137,-279,-278,-337,-76,-79,-82,-75,137,-77,137,137,-81,-215,-214,-80,-216,137,-78,-312,137,137,-69,-284,137,137,-284,137,137,-244,-247,-245,-241,-242,-246,-248,137,-250,-251,-243,-249,-12,137,137,-11,249,249,249,-260,249,249,249,-259,249,249,-257,-256,249,249,249,249,249,-258,-296,-295,-294,-293,-292,-305,137,137,137,137,-234,-233,137,-231,137,137,-217,137,-230,137,-84,-218,137,137,137,-337,-337,-198,137,-281,-282,137,-290,-291,137,-275,-337,-284,-229,-232,137,-221,137,-83,-219,-68,137,-28,-337,137,-11,137,137,-220,137,137,137,-284,137,137,-306,137,-337,-299,137,-225,-224,-222,-84,-300,137,137,137,-226,-223,137,-228,-227,]),'ELLIPSIS':([350,],[462,]),'U32STRING_LITERAL':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,139,146,148,149,150,151,153,163,165,166,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,235,236,237,238,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,139,-335,-28,-182,-27,139,-337,-87,-72,-337,139,-286,-285,-330,139,-327,139,-283,-287,235,-328,-288,-329,139,-284,139,139,139,-336,-183,139,139,-28,-337,139,-28,-337,-337,139,139,139,-334,-332,-331,-333,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,-337,-76,-79,-82,-75,139,-77,139,139,-81,-215,-214,-80,-216,139,-78,139,139,-69,-284,139,139,-284,139,139,-244,-247,-245,-241,-242,-246,-248,139,-250,-251,-243,-249,-12,139,139,-11,139,139,139,139,-234,-233,139,-231,139,139,-217,139,-230,139,-84,-218,139,139,139,-337,-337,-198,139,139,139,-337,-284,-229,-232,139,-221,139,-83,-219,-68,139,-28,-337,139,-11,139,139,-220,139,139,139,-284,139,139,139,-337,139,-225,-224,-222,-84,139,139,139,-226,-223,139,-228,-227,]),'GT':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,250,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,250,-262,-260,-264,250,-263,-259,-266,250,-257,-256,-265,250,250,250,250,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'GOTO':([61,97,119,124,181,191,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[-71,-335,-87,-72,287,-336,-76,-79,-82,-75,-77,287,-81,-215,-214,-80,-216,287,-78,-69,-234,-233,-231,287,-217,-230,287,-84,-218,287,-229,-232,-221,287,-83,-219,-68,287,-220,287,287,-225,-224,-222,-84,287,287,-226,-223,287,-228,-227,]),'ENUM':([0,1,3,7,10,11,13,14,16,17,19,20,21,25,26,27,29,30,38,39,40,42,45,47,48,52,53,55,58,59,61,62,63,64,65,66,67,75,85,86,87,90,91,93,94,95,97,99,105,118,119,120,121,122,123,124,129,172,174,180,181,182,184,185,186,188,189,190,191,198,200,214,223,229,231,233,239,240,241,267,278,284,285,286,289,291,298,300,301,302,303,305,308,312,313,315,318,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,446,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[32,-337,-128,-106,-104,-107,-105,-64,-60,-67,-66,-109,32,-65,-102,-337,-131,-108,-63,-129,32,-29,-62,-70,-52,-337,-337,-337,-130,32,-71,-103,-337,-9,-131,-91,-10,32,32,-53,-337,-88,32,32,-93,32,-335,32,-182,32,-87,-90,-94,-92,-61,-72,32,32,32,-73,32,-89,32,32,32,-159,-160,-156,-336,-183,-30,32,-74,32,32,32,32,-174,-175,32,32,-76,-79,-82,-75,-77,32,-81,-215,-214,-80,-216,-78,-127,32,32,-157,-69,-36,-35,32,32,32,-234,-233,32,-231,-217,-230,-81,-84,-218,-158,-31,-34,32,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'PERIOD':([97,132,133,134,136,138,139,140,141,143,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,227,230,235,236,237,238,261,263,310,371,376,402,403,404,405,407,411,470,472,474,482,483,488,520,526,527,547,550,551,563,565,572,],[-335,-317,-321,-318,-303,-324,-330,-313,-319,-301,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,264,-323,-312,-336,372,-326,-334,-332,-331,-333,-298,-297,-312,-199,372,-296,-295,-294,-293,-292,-305,-202,372,-200,-290,-291,372,-201,548,-307,-306,372,-299,-308,-300,-309,]),'GE':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,254,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,254,-262,-260,-264,254,-263,-259,-266,254,-257,-256,-265,254,254,254,254,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'INT_CONST_DEC':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,140,-335,-28,-182,-27,140,-337,-87,-72,-337,140,-286,-285,140,140,-283,-287,-288,140,-284,140,140,140,-336,-183,140,140,-28,-337,140,-28,-337,-337,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,-337,-76,-79,-82,-75,140,-77,140,140,-81,-215,-214,-80,-216,140,-78,140,140,-69,-284,140,140,-284,140,140,-244,-247,-245,-241,-242,-246,-248,140,-250,-251,-243,-249,-12,140,140,-11,140,140,140,140,-234,-233,140,-231,140,140,-217,140,-230,140,-84,-218,140,140,140,-337,-337,-198,140,140,140,-337,-284,-229,-232,140,-221,140,-83,-219,-68,140,-28,-337,140,-11,140,140,-220,140,140,140,-284,140,140,140,-337,140,-225,-224,-222,-84,140,140,140,-226,-223,140,-228,-227,]),'ARROW':([132,133,134,136,138,139,140,141,143,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,230,235,236,237,238,261,263,310,402,403,404,405,407,411,482,483,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,262,-323,-312,-336,-326,-334,-332,-331,-333,-298,-297,-312,-296,-295,-294,-293,-292,-305,-290,-291,-306,-299,-300,]),'_STATIC_ASSERT':([0,14,16,17,19,25,38,45,47,59,61,97,119,123,124,180,181,191,223,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[41,-64,-60,-67,-66,-65,-63,-62,-70,41,-71,-335,-87,-61,-72,-73,41,-336,-74,-76,-79,-82,-75,-77,41,-81,-215,-214,-80,-216,41,-78,-69,-234,-233,-231,41,-217,-230,41,-84,-218,41,-229,-232,-221,41,-83,-219,-68,41,-220,41,41,-225,-224,-222,-84,41,41,-226,-223,41,-228,-227,]),'CHAR':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[46,-337,-113,-128,46,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,46,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,46,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,46,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,46,-131,-95,-101,-97,46,-53,-126,46,-88,46,46,-93,46,-147,-335,-146,46,-167,-166,-182,-100,-126,46,-87,-90,-94,-92,-61,-72,46,-144,-142,46,46,46,-73,46,-89,46,46,46,-149,-159,-160,-156,-336,46,-183,-30,46,46,-74,46,46,46,46,-174,-175,46,-143,-140,46,-141,-145,-76,-79,-82,-75,-77,46,-81,-215,-214,-80,-216,-78,-127,46,-153,46,-151,-148,-157,-168,-69,-36,-35,46,46,46,-234,-233,46,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,46,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'HEX_FLOAT_CONST':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,141,-335,-28,-182,-27,141,-337,-87,-72,-337,141,-286,-285,141,141,-283,-287,-288,141,-284,141,141,141,-336,-183,141,141,-28,-337,141,-28,-337,-337,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,-337,-76,-79,-82,-75,141,-77,141,141,-81,-215,-214,-80,-216,141,-78,141,141,-69,-284,141,141,-284,141,141,-244,-247,-245,-241,-242,-246,-248,141,-250,-251,-243,-249,-12,141,141,-11,141,141,141,141,-234,-233,141,-231,141,141,-217,141,-230,141,-84,-218,141,141,141,-337,-337,-198,141,141,141,-337,-284,-229,-232,141,-221,141,-83,-219,-68,141,-28,-337,141,-11,141,141,-220,141,141,141,-284,141,141,141,-337,141,-225,-224,-222,-84,141,141,141,-226,-223,141,-228,-227,]),'DOUBLE':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[50,-337,-113,-128,50,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,50,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,50,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,50,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,50,-131,-95,-101,-97,50,-53,-126,50,-88,50,50,-93,50,-147,-335,-146,50,-167,-166,-182,-100,-126,50,-87,-90,-94,-92,-61,-72,50,-144,-142,50,50,50,-73,50,-89,50,50,50,-149,-159,-160,-156,-336,50,-183,-30,50,50,-74,50,50,50,50,-174,-175,50,-143,-140,50,-141,-145,-76,-79,-82,-75,-77,50,-81,-215,-214,-80,-216,-78,-127,50,-153,50,-151,-148,-157,-168,-69,-36,-35,50,50,50,-234,-233,50,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,50,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'MINUSEQUAL':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,-276,-323,-312,-336,358,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'INT_CONST_OCT':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,145,-335,-28,-182,-27,145,-337,-87,-72,-337,145,-286,-285,145,145,-283,-287,-288,145,-284,145,145,145,-336,-183,145,145,-28,-337,145,-28,-337,-337,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,-337,-76,-79,-82,-75,145,-77,145,145,-81,-215,-214,-80,-216,145,-78,145,145,-69,-284,145,145,-284,145,145,-244,-247,-245,-241,-242,-246,-248,145,-250,-251,-243,-249,-12,145,145,-11,145,145,145,145,-234,-233,145,-231,145,145,-217,145,-230,145,-84,-218,145,145,145,-337,-337,-198,145,145,145,-337,-284,-229,-232,145,-221,145,-83,-219,-68,145,-28,-337,145,-11,145,145,-220,145,145,145,-284,145,145,145,-337,145,-225,-224,-222,-84,145,145,145,-226,-223,145,-228,-227,]),'TIMESEQUAL':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,-276,-323,-312,-336,367,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'OR':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,259,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,259,-262,-260,-264,-268,-263,-259,-266,-271,-257,-256,-265,259,-267,-269,-270,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'SHORT':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[2,-337,-113,-128,2,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,2,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,2,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,2,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,2,-131,-95,-101,-97,2,-53,-126,2,-88,2,2,-93,2,-147,-335,-146,2,-167,-166,-182,-100,-126,2,-87,-90,-94,-92,-61,-72,2,-144,-142,2,2,2,-73,2,-89,2,2,2,-149,-159,-160,-156,-336,2,-183,-30,2,2,-74,2,2,2,2,-174,-175,2,-143,-140,2,-141,-145,-76,-79,-82,-75,-77,2,-81,-215,-214,-80,-216,-78,-127,2,-153,2,-151,-148,-157,-168,-69,-36,-35,2,2,2,-234,-233,2,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,2,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'RETURN':([61,97,119,124,181,191,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[-71,-335,-87,-72,290,-336,-76,-79,-82,-75,-77,290,-81,-215,-214,-80,-216,290,-78,-69,-234,-233,-231,290,-217,-230,290,-84,-218,290,-229,-232,-221,290,-83,-219,-68,290,-220,290,290,-225,-224,-222,-84,290,290,-226,-223,290,-228,-227,]),'RSHIFTEQUAL':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,-276,-323,-312,-336,368,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'_ALIGNAS':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,85,86,87,89,90,93,95,96,97,98,99,100,101,109,111,118,119,123,124,129,142,147,174,177,180,181,182,184,185,186,187,188,189,190,191,192,200,211,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[8,8,-113,-128,8,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,8,-120,-115,-65,-102,8,-131,-108,-238,-111,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,8,8,-119,8,-114,-130,8,-118,-71,-103,8,-131,-96,-98,8,-131,-95,-101,-97,8,-53,8,8,-88,8,8,-147,-335,-146,8,-167,-166,-100,-126,8,-87,-61,-72,8,-144,-142,8,8,-73,8,-89,8,8,8,-149,-159,-160,-156,-336,8,-30,8,-74,8,8,8,8,-174,-175,8,-143,-140,8,-141,-145,-76,-79,-82,-75,-77,8,-81,-215,-214,-80,-216,-78,-127,8,-153,8,-151,-148,-157,-168,-69,-36,-35,8,8,8,-234,-233,8,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,8,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'RESTRICT':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,35,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,85,86,87,89,90,93,95,96,97,98,99,100,101,103,105,109,111,117,118,119,123,124,128,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,205,206,211,219,220,223,229,231,233,239,240,241,267,269,275,278,279,280,282,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,459,460,496,497,500,505,506,510,511,512,514,515,536,554,555,557,558,575,576,578,579,],[39,39,-113,-128,39,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,39,-120,-115,-65,-102,39,-131,-108,-238,-111,39,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,39,39,-119,39,-114,-130,39,-118,-71,-103,39,-131,-96,-98,39,-131,-95,-101,-97,39,-53,39,39,-88,39,39,-147,-335,-146,39,-167,-166,39,-182,-100,-126,39,39,-87,-61,-72,39,39,-144,-142,39,39,39,-73,39,-89,39,39,39,-149,-159,-160,-156,-336,39,-183,-30,39,39,39,39,39,-74,39,39,39,39,-174,-175,39,-143,-140,39,-141,-145,39,-76,-79,-82,-75,-77,39,-81,-215,-214,-80,-216,-78,-127,39,-153,39,-151,-148,-157,-168,-69,-36,-35,39,39,39,-234,-233,39,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,39,39,-229,-232,-221,-83,-219,-68,-33,-32,39,39,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'STATIC':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,86,87,89,90,93,96,97,98,100,101,105,109,111,117,118,119,123,124,128,129,180,181,182,187,191,198,200,205,211,219,223,240,241,278,284,285,286,289,291,298,300,301,302,303,305,308,312,314,316,317,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,448,449,453,454,459,460,496,497,500,505,506,510,511,512,514,536,554,555,557,558,575,576,578,579,],[10,10,-113,-128,10,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,10,-120,-115,-65,-102,10,-131,-108,-238,-111,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,10,10,-119,10,-114,-130,10,-118,-71,-103,10,-131,-96,-98,10,-131,-95,-101,-97,-53,10,10,-88,10,-147,-335,-146,-167,-166,-182,-100,-126,206,10,-87,-61,-72,220,10,-73,10,-89,-149,-336,-183,-30,338,10,353,-74,-174,-175,10,-76,-79,-82,-75,-77,10,-81,-215,-214,-80,-216,-78,-127,-153,-151,-148,-168,-69,-36,-35,10,10,10,-234,-233,10,-231,-217,-230,-81,-84,-218,-152,-150,-170,-169,-31,-34,515,10,-229,-232,-221,-83,-219,-68,-33,-32,542,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'SIZEOF':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,146,-335,-28,-182,-27,146,-337,-87,-72,-337,146,-286,-285,146,146,-283,-287,-288,146,-284,146,146,146,-336,-183,146,146,-28,-337,146,-28,-337,-337,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,-337,-76,-79,-82,-75,146,-77,146,146,-81,-215,-214,-80,-216,146,-78,146,146,-69,-284,146,146,-284,146,146,-244,-247,-245,-241,-242,-246,-248,146,-250,-251,-243,-249,-12,146,146,-11,146,146,146,146,-234,-233,146,-231,146,146,-217,146,-230,146,-84,-218,146,146,146,-337,-337,-198,146,146,146,-337,-284,-229,-232,146,-221,146,-83,-219,-68,146,-28,-337,146,-11,146,146,-220,146,146,146,-284,146,146,146,-337,146,-225,-224,-222,-84,146,146,146,-226,-223,146,-228,-227,]),'UNSIGNED':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[22,-337,-113,-128,22,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,22,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,22,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,22,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,22,-131,-95,-101,-97,22,-53,-126,22,-88,22,22,-93,22,-147,-335,-146,22,-167,-166,-182,-100,-126,22,-87,-90,-94,-92,-61,-72,22,-144,-142,22,22,22,-73,22,-89,22,22,22,-149,-159,-160,-156,-336,22,-183,-30,22,22,-74,22,22,22,22,-174,-175,22,-143,-140,22,-141,-145,-76,-79,-82,-75,-77,22,-81,-215,-214,-80,-216,-78,-127,22,-153,22,-151,-148,-157,-168,-69,-36,-35,22,22,22,-234,-233,22,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,22,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'UNION':([0,1,3,7,10,11,13,14,16,17,19,20,21,25,26,27,29,30,38,39,40,42,45,47,48,52,53,55,58,59,61,62,63,64,65,66,67,75,85,86,87,90,91,93,94,95,97,99,105,118,119,120,121,122,123,124,129,172,174,180,181,182,184,185,186,188,189,190,191,198,200,214,223,229,231,233,239,240,241,267,278,284,285,286,289,291,298,300,301,302,303,305,308,312,313,315,318,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,446,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[28,-337,-128,-106,-104,-107,-105,-64,-60,-67,-66,-109,28,-65,-102,-337,-131,-108,-63,-129,28,-29,-62,-70,-52,-337,-337,-337,-130,28,-71,-103,-337,-9,-131,-91,-10,28,28,-53,-337,-88,28,28,-93,28,-335,28,-182,28,-87,-90,-94,-92,-61,-72,28,28,28,-73,28,-89,28,28,28,-159,-160,-156,-336,-183,-30,28,-74,28,28,28,28,-174,-175,28,28,-76,-79,-82,-75,-77,28,-81,-215,-214,-80,-216,-78,-127,28,28,-157,-69,-36,-35,28,28,28,-234,-233,28,-231,-217,-230,-81,-84,-218,-158,-31,-34,28,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'COLON':([2,3,5,6,12,22,23,33,34,36,39,42,43,44,46,48,49,50,54,56,58,60,73,74,76,77,86,96,98,100,101,111,127,132,133,134,136,138,139,140,141,142,143,144,145,147,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,178,179,187,191,192,200,216,224,225,230,232,234,235,236,237,238,240,241,261,263,268,269,272,273,275,279,280,295,310,312,314,316,317,324,328,340,341,355,356,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,407,411,431,442,443,445,448,449,453,454,464,465,468,476,478,480,482,483,486,487,511,512,518,519,524,547,551,565,],[-113,-128,-124,-110,-125,-120,-115,-238,-111,-122,-129,-29,-121,-116,-112,-52,-123,-117,-119,-114,-130,-118,-54,-179,-131,-37,-53,-147,-146,-167,-166,-126,-55,-317,-321,-318,-303,-324,-330,-313,-319,-144,-301,-274,-314,-142,-327,-325,-304,-322,-302,-255,-315,-289,-253,-328,-316,-329,-320,-276,-323,-312,-252,-178,-149,-336,319,-30,-38,-274,-239,-326,-280,-277,-334,-332,-331,-333,-174,-175,-298,-297,-279,-143,-235,-278,-140,-141,-145,429,440,-127,-153,-151,-148,447,-168,-36,-35,-44,-43,-261,-273,-262,-260,-264,-268,-263,-259,-266,-271,-257,-256,-265,-272,-267,-269,481,-270,-258,-296,-295,-294,-293,-292,-305,502,-152,-150,319,-170,-169,-31,-34,-39,-42,-240,-237,-281,-282,-290,-291,-236,-275,-33,-32,-41,-40,-254,-306,-299,-300,]),'$end':([0,9,14,16,17,19,25,38,45,47,57,59,61,119,123,124,180,191,223,332,439,510,],[-337,0,-64,-60,-67,-66,-65,-63,-62,-70,-59,-58,-71,-87,-61,-72,-73,-336,-74,-69,-218,-68,]),'WSTRING_LITERAL':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,139,146,148,149,150,151,153,163,165,166,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,235,236,237,238,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,148,-335,-28,-182,-27,148,-337,-87,-72,-337,148,-286,-285,-330,148,-327,148,-283,-287,237,-328,-288,-329,148,-284,148,148,148,-336,-183,148,148,-28,-337,148,-28,-337,-337,148,148,148,-334,-332,-331,-333,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,-337,-76,-79,-82,-75,148,-77,148,148,-81,-215,-214,-80,-216,148,-78,148,148,-69,-284,148,148,-284,148,148,-244,-247,-245,-241,-242,-246,-248,148,-250,-251,-243,-249,-12,148,148,-11,148,148,148,148,-234,-233,148,-231,148,148,-217,148,-230,148,-84,-218,148,148,148,-337,-337,-198,148,148,148,-337,-284,-229,-232,148,-221,148,-83,-219,-68,148,-28,-337,148,-11,148,148,-220,148,148,148,-284,148,148,148,-337,148,-225,-224,-222,-84,148,148,148,-226,-223,148,-228,-227,]),'DIVIDE':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,252,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,252,252,252,252,252,252,252,252,252,252,-257,-256,252,252,252,252,252,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'FOR':([61,97,119,124,181,191,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[-71,-335,-87,-72,292,-336,-76,-79,-82,-75,-77,292,-81,-215,-214,-80,-216,292,-78,-69,-234,-233,-231,292,-217,-230,292,-84,-218,292,-229,-232,-221,292,-83,-219,-68,292,-220,292,292,-225,-224,-222,-84,292,292,-226,-223,292,-228,-227,]),'PLUSPLUS':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,132,133,134,135,136,137,138,139,140,141,143,145,146,148,149,150,151,152,153,154,156,160,161,163,164,165,166,167,168,169,171,173,174,175,176,181,191,198,201,204,205,206,218,219,220,227,229,230,231,233,235,236,237,238,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,263,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,310,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,402,403,404,405,407,411,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,482,483,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,547,549,550,551,553,554,555,557,558,565,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,149,-335,-28,-182,-27,149,-337,-87,-72,-337,149,-317,-321,-318,-286,-303,-285,-324,-330,-313,-319,-301,-314,149,-327,149,-283,-287,-325,-304,-322,-302,-315,-289,-328,-316,-288,-329,-320,263,-323,149,-284,149,149,-312,149,-336,-183,149,149,-28,-337,149,-28,-337,-337,149,-326,149,149,-334,-332,-331,-333,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,-298,-297,149,149,-337,-76,-79,-82,-75,149,-77,149,149,-81,-215,-214,-80,-216,149,-78,-312,149,149,-69,-284,149,149,-284,149,149,-244,-247,-245,-241,-242,-246,-248,149,-250,-251,-243,-249,-12,149,149,-11,-296,-295,-294,-293,-292,-305,149,149,149,149,-234,-233,149,-231,149,149,-217,149,-230,149,-84,-218,149,149,149,-337,-337,-198,149,149,-290,-291,149,-337,-284,-229,-232,149,-221,149,-83,-219,-68,149,-28,-337,149,-11,149,149,-220,149,149,149,-284,149,149,-306,149,-337,-299,149,-225,-224,-222,-84,-300,149,149,149,-226,-223,149,-228,-227,]),'EQUALS':([42,48,73,74,75,77,78,86,110,127,132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,179,191,197,200,216,224,230,232,234,235,236,237,238,261,263,268,273,310,340,341,355,356,371,376,402,403,404,405,407,411,453,454,464,465,470,474,478,480,482,483,487,511,512,518,519,520,547,551,565,],[-29,-52,-54,-179,-178,-37,131,-53,201,-55,-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,-276,-323,-312,-178,-336,329,-30,-38,360,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-36,-35,-44,-43,-199,475,-296,-295,-294,-293,-292,-305,-31,-34,-39,-42,-202,-200,-281,-282,-290,-291,-275,-33,-32,-41,-40,-201,-306,-299,-300,]),'ELSE':([61,124,191,284,285,286,289,291,300,303,308,332,424,425,428,435,437,438,439,496,497,500,505,506,510,536,554,555,557,558,575,576,578,579,],[-71,-72,-336,-76,-79,-82,-75,-77,-81,-80,-78,-69,-234,-233,-231,-230,-81,-84,-218,-229,-232,-221,-83,-219,-68,-220,-225,-224,-222,569,-226,-223,-228,-227,]),'ANDEQUAL':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,-276,-323,-312,-336,365,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'EQ':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,256,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,256,-262,-260,-264,-268,-263,-259,-266,256,-257,-256,-265,256,-267,256,256,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'AND':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,132,133,134,135,136,137,138,139,140,141,143,144,145,146,148,149,150,151,152,153,154,156,158,160,161,162,163,164,165,166,167,168,169,171,173,174,175,176,181,191,198,201,204,205,206,218,219,220,224,227,229,230,231,232,233,234,235,236,237,238,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,263,265,266,268,273,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,310,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,478,480,481,482,483,484,487,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,547,549,550,551,553,554,555,557,558,565,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,150,-335,-28,-182,-27,150,-337,-87,-72,-337,150,-317,-321,-318,-286,-303,-285,-324,-330,-313,-319,-301,-274,-314,150,-327,150,-283,-287,-325,-304,-322,-302,-255,-315,-289,257,-328,-316,-288,-329,-320,-276,-323,150,-284,150,150,-312,150,-336,-183,150,150,-28,-337,150,-28,-337,-274,-337,150,-326,150,-280,150,-277,-334,-332,-331,-333,150,150,150,150,150,150,150,150,150,150,150,150,150,150,150,150,150,150,150,-298,-297,150,150,-279,-278,-337,-76,-79,-82,-75,150,-77,150,150,-81,-215,-214,-80,-216,150,-78,-312,150,150,-69,-284,150,150,-284,150,150,-244,-247,-245,-241,-242,-246,-248,150,-250,-251,-243,-249,-12,150,150,-11,-261,257,-262,-260,-264,-268,-263,-259,-266,257,-257,-256,-265,257,-267,-269,257,-258,-296,-295,-294,-293,-292,-305,150,150,150,150,-234,-233,150,-231,150,150,-217,150,-230,150,-84,-218,150,150,150,-337,-337,-198,150,-281,-282,150,-290,-291,150,-275,-337,-284,-229,-232,150,-221,150,-83,-219,-68,150,-28,-337,150,-11,150,150,-220,150,150,150,-284,150,150,-306,150,-337,-299,150,-225,-224,-222,-84,-300,150,150,150,-226,-223,150,-228,-227,]),'TYPEID':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,69,71,72,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,103,104,105,106,109,111,118,119,120,121,122,123,124,126,129,142,147,172,174,180,181,182,184,185,186,187,188,189,190,191,192,198,199,200,202,211,214,223,229,231,233,239,240,241,262,264,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,344,350,422,424,425,427,428,432,435,437,438,439,442,443,445,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[33,-337,-113,-128,77,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,33,-120,-115,-154,-65,-102,-126,-155,-131,-108,96,100,-238,-111,-337,-122,-63,-129,33,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,33,-118,-71,-103,-337,-9,-131,-91,-10,-96,77,-98,77,33,-131,-95,-101,-97,33,-53,-126,77,-88,33,33,-93,33,-147,-335,-146,33,-167,-166,-28,-180,-182,-27,-100,-126,33,-87,-90,-94,-92,-61,-72,77,33,-144,-142,33,33,-73,33,-89,33,33,33,-149,-159,-160,-156,-336,77,-183,-181,-30,77,347,33,-74,33,33,33,33,-174,-175,402,404,33,-143,-140,33,-141,-145,-76,-79,-82,-75,-77,33,-81,-215,-214,-80,-216,-78,-127,33,-153,33,-151,-148,-157,-168,-69,-36,-35,33,347,33,33,-234,-233,33,-231,-217,-230,-81,-84,-218,-152,-150,77,-158,-170,-169,-31,-34,33,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'LBRACE':([21,24,28,31,32,42,48,61,75,86,88,90,92,93,96,97,98,100,101,119,124,130,131,181,182,191,200,201,227,229,284,285,286,289,291,298,300,301,302,303,305,307,308,332,340,341,369,375,377,413,424,425,428,429,432,435,437,438,439,440,453,454,472,475,477,478,479,488,496,497,500,502,505,506,510,511,512,521,522,535,536,537,539,550,554,555,557,558,569,574,575,576,577,578,579,],[-337,-154,-155,97,97,-29,-52,-71,-337,-53,-7,-88,97,-8,97,-335,97,97,97,-87,-72,97,97,97,-89,-336,-30,97,-337,97,-76,-79,-82,-75,-77,97,-81,-215,-214,-80,-216,97,-78,-69,-36,-35,-12,97,-11,97,-234,-233,-231,97,-217,-230,97,-84,-218,97,-31,-34,-337,-198,97,97,97,-337,-229,-232,-221,97,-83,-219,-68,-33,-32,97,-11,97,-220,97,97,-337,-225,-224,-222,-84,97,97,-226,-223,97,-228,-227,]),'PPHASH':([0,14,16,17,19,25,38,45,47,59,61,119,123,124,180,191,223,332,439,510,],[47,-64,-60,-67,-66,-65,-63,-62,-70,47,-71,-87,-61,-72,-73,-336,-74,-69,-218,-68,]),'INT':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[56,-337,-113,-128,56,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,56,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,56,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,56,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,56,-131,-95,-101,-97,56,-53,-126,56,-88,56,56,-93,56,-147,-335,-146,56,-167,-166,-182,-100,-126,56,-87,-90,-94,-92,-61,-72,56,-144,-142,56,56,56,-73,56,-89,56,56,56,-149,-159,-160,-156,-336,56,-183,-30,56,56,-74,56,56,56,56,-174,-175,56,-143,-140,56,-141,-145,-76,-79,-82,-75,-77,56,-81,-215,-214,-80,-216,-78,-127,56,-153,56,-151,-148,-157,-168,-69,-36,-35,56,56,56,-234,-233,56,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,56,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'SIGNED':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[54,-337,-113,-128,54,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,54,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,54,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,54,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,54,-131,-95,-101,-97,54,-53,-126,54,-88,54,54,-93,54,-147,-335,-146,54,-167,-166,-182,-100,-126,54,-87,-90,-94,-92,-61,-72,54,-144,-142,54,54,54,-73,54,-89,54,54,54,-149,-159,-160,-156,-336,54,-183,-30,54,54,-74,54,54,54,54,-174,-175,54,-143,-140,54,-141,-145,-76,-79,-82,-75,-77,54,-81,-215,-214,-80,-216,-78,-127,54,-153,54,-151,-148,-157,-168,-69,-36,-35,54,54,54,-234,-233,54,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,54,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'CONTINUE':([61,97,119,124,181,191,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[-71,-335,-87,-72,293,-336,-76,-79,-82,-75,-77,293,-81,-215,-214,-80,-216,293,-78,-69,-234,-233,-231,293,-217,-230,293,-84,-218,293,-229,-232,-221,293,-83,-219,-68,293,-220,293,293,-225,-224,-222,-84,293,293,-226,-223,293,-228,-227,]),'NOT':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,151,-335,-28,-182,-27,151,-337,-87,-72,-337,151,-286,-285,151,151,-283,-287,-288,151,-284,151,151,151,-336,-183,151,151,-28,-337,151,-28,-337,-337,151,151,151,151,151,151,151,151,151,151,151,151,151,151,151,151,151,151,151,151,151,151,151,151,-337,-76,-79,-82,-75,151,-77,151,151,-81,-215,-214,-80,-216,151,-78,151,151,-69,-284,151,151,-284,151,151,-244,-247,-245,-241,-242,-246,-248,151,-250,-251,-243,-249,-12,151,151,-11,151,151,151,151,-234,-233,151,-231,151,151,-217,151,-230,151,-84,-218,151,151,151,-337,-337,-198,151,151,151,-337,-284,-229,-232,151,-221,151,-83,-219,-68,151,-28,-337,151,-11,151,151,-220,151,151,151,-284,151,151,151,-337,151,-225,-224,-222,-84,151,151,151,-226,-223,151,-228,-227,]),'OREQUAL':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,-276,-323,-312,-336,366,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'MOD':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,260,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,260,260,260,260,260,260,260,260,260,260,-257,-256,260,260,260,260,260,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'RSHIFT':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,242,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,242,-262,-260,242,242,242,-259,242,242,-257,-256,242,242,242,242,242,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'DEFAULT':([61,97,119,124,181,191,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[-71,-335,-87,-72,295,-336,-76,-79,-82,-75,-77,295,-81,-215,-214,-80,-216,295,-78,-69,-234,-233,-231,295,-217,-230,295,-84,-218,295,-229,-232,-221,295,-83,-219,-68,295,-220,295,295,-225,-224,-222,-84,295,295,-226,-223,295,-228,-227,]),'_NORETURN':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,86,87,89,90,93,96,97,98,100,101,109,111,118,119,123,124,129,180,181,182,187,191,200,211,223,240,241,278,284,285,286,289,291,298,300,301,302,303,305,308,312,314,316,317,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[20,20,-113,-128,20,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,20,-120,-115,-65,-102,20,-131,-108,-238,-111,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,20,20,-119,20,-114,-130,20,-118,-71,-103,20,-131,-96,-98,20,-131,-95,-101,-97,-53,20,20,-88,20,-147,-335,-146,-167,-166,-100,-126,20,-87,-61,-72,20,-73,20,-89,-149,-336,-30,20,-74,-174,-175,20,-76,-79,-82,-75,-77,20,-81,-215,-214,-80,-216,-78,-127,-153,-151,-148,-168,-69,-36,-35,20,20,20,-234,-233,20,-231,-217,-230,-81,-84,-218,-152,-150,-170,-169,-31,-34,20,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'__INT128':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[43,-337,-113,-128,43,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,43,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,43,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,43,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,43,-131,-95,-101,-97,43,-53,-126,43,-88,43,43,-93,43,-147,-335,-146,43,-167,-166,-182,-100,-126,43,-87,-90,-94,-92,-61,-72,43,-144,-142,43,43,43,-73,43,-89,43,43,43,-149,-159,-160,-156,-336,43,-183,-30,43,43,-74,43,43,43,43,-174,-175,43,-143,-140,43,-141,-145,-76,-79,-82,-75,-77,43,-81,-215,-214,-80,-216,-78,-127,43,-153,43,-151,-148,-157,-168,-69,-36,-35,43,43,43,-234,-233,43,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,43,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'WHILE':([61,97,119,124,181,191,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,436,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[-71,-335,-87,-72,296,-336,-76,-79,-82,-75,-77,296,-81,-215,-214,-80,-216,296,-78,-69,-234,-233,-231,296,-217,-230,504,296,-84,-218,296,-229,-232,-221,296,-83,-219,-68,296,-220,296,296,-225,-224,-222,-84,296,296,-226,-223,296,-228,-227,]),'U8CHAR_CONST':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,154,-335,-28,-182,-27,154,-337,-87,-72,-337,154,-286,-285,154,154,-283,-287,-288,154,-284,154,154,154,-336,-183,154,154,-28,-337,154,-28,-337,-337,154,154,154,154,154,154,154,154,154,154,154,154,154,154,154,154,154,154,154,154,154,154,154,154,-337,-76,-79,-82,-75,154,-77,154,154,-81,-215,-214,-80,-216,154,-78,154,154,-69,-284,154,154,-284,154,154,-244,-247,-245,-241,-242,-246,-248,154,-250,-251,-243,-249,-12,154,154,-11,154,154,154,154,-234,-233,154,-231,154,154,-217,154,-230,154,-84,-218,154,154,154,-337,-337,-198,154,154,154,-337,-284,-229,-232,154,-221,154,-83,-219,-68,154,-28,-337,154,-11,154,154,-220,154,154,154,-284,154,154,154,-337,154,-225,-224,-222,-84,154,154,154,-226,-223,154,-228,-227,]),'_ALIGNOF':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,155,-335,-28,-182,-27,155,-337,-87,-72,-337,155,-286,-285,155,155,-283,-287,-288,155,-284,155,155,155,-336,-183,155,155,-28,-337,155,-28,-337,-337,155,155,155,155,155,155,155,155,155,155,155,155,155,155,155,155,155,155,155,155,155,155,155,155,-337,-76,-79,-82,-75,155,-77,155,155,-81,-215,-214,-80,-216,155,-78,155,155,-69,-284,155,155,-284,155,155,-244,-247,-245,-241,-242,-246,-248,155,-250,-251,-243,-249,-12,155,155,-11,155,155,155,155,-234,-233,155,-231,155,155,-217,155,-230,155,-84,-218,155,155,155,-337,-337,-198,155,155,155,-337,-284,-229,-232,155,-221,155,-83,-219,-68,155,-28,-337,155,-11,155,155,-220,155,155,155,-284,155,155,155,-337,155,-225,-224,-222,-84,155,155,155,-226,-223,155,-228,-227,]),'EXTERN':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,86,87,89,90,93,96,97,98,100,101,109,111,118,119,123,124,129,180,181,182,187,191,200,211,223,240,241,278,284,285,286,289,291,298,300,301,302,303,305,308,312,314,316,317,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[13,13,-113,-128,13,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,13,-120,-115,-65,-102,13,-131,-108,-238,-111,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,13,13,-119,13,-114,-130,13,-118,-71,-103,13,-131,-96,-98,13,-131,-95,-101,-97,-53,13,13,-88,13,-147,-335,-146,-167,-166,-100,-126,13,-87,-61,-72,13,-73,13,-89,-149,-336,-30,13,-74,-174,-175,13,-76,-79,-82,-75,-77,13,-81,-215,-214,-80,-216,-78,-127,-153,-151,-148,-168,-69,-36,-35,13,13,13,-234,-233,13,-231,-217,-230,-81,-84,-218,-152,-150,-170,-169,-31,-34,13,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'CASE':([61,97,119,124,181,191,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[-71,-335,-87,-72,297,-336,-76,-79,-82,-75,-77,297,-81,-215,-214,-80,-216,297,-78,-69,-234,-233,-231,297,-217,-230,297,-84,-218,297,-229,-232,-221,297,-83,-219,-68,297,-220,297,297,-225,-224,-222,-84,297,297,-226,-223,297,-228,-227,]),'LAND':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,255,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,255,-262,-260,-264,-268,-263,-259,-266,-271,-257,-256,-265,-272,-267,-269,-270,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'REGISTER':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,86,87,89,90,93,96,97,98,100,101,109,111,118,119,123,124,129,180,181,182,187,191,200,211,223,240,241,278,284,285,286,289,291,298,300,301,302,303,305,308,312,314,316,317,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[62,62,-113,-128,62,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,62,-120,-115,-65,-102,62,-131,-108,-238,-111,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,62,62,-119,62,-114,-130,62,-118,-71,-103,62,-131,-96,-98,62,-131,-95,-101,-97,-53,62,62,-88,62,-147,-335,-146,-167,-166,-100,-126,62,-87,-61,-72,62,-73,62,-89,-149,-336,-30,62,-74,-174,-175,62,-76,-79,-82,-75,-77,62,-81,-215,-214,-80,-216,-78,-127,-153,-151,-148,-168,-69,-36,-35,62,62,62,-234,-233,62,-231,-217,-230,-81,-84,-218,-152,-150,-170,-169,-31,-34,62,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'MODEQUAL':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,-276,-323,-312,-336,359,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'NE':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,247,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,247,-262,-260,-264,-268,-263,-259,-266,247,-257,-256,-265,247,-267,247,247,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'SWITCH':([61,97,119,124,181,191,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[-71,-335,-87,-72,299,-336,-76,-79,-82,-75,-77,299,-81,-215,-214,-80,-216,299,-78,-69,-234,-233,-231,299,-217,-230,299,-84,-218,299,-229,-232,-221,299,-83,-219,-68,299,-220,299,299,-225,-224,-222,-84,299,299,-226,-223,299,-228,-227,]),'INT_CONST_HEX':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,160,-335,-28,-182,-27,160,-337,-87,-72,-337,160,-286,-285,160,160,-283,-287,-288,160,-284,160,160,160,-336,-183,160,160,-28,-337,160,-28,-337,-337,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,-337,-76,-79,-82,-75,160,-77,160,160,-81,-215,-214,-80,-216,160,-78,160,160,-69,-284,160,160,-284,160,160,-244,-247,-245,-241,-242,-246,-248,160,-250,-251,-243,-249,-12,160,160,-11,160,160,160,160,-234,-233,160,-231,160,160,-217,160,-230,160,-84,-218,160,160,160,-337,-337,-198,160,160,160,-337,-284,-229,-232,160,-221,160,-83,-219,-68,160,-28,-337,160,-11,160,160,-220,160,160,160,-284,160,160,160,-337,160,-225,-224,-222,-84,160,160,160,-226,-223,160,-228,-227,]),'_COMPLEX':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[60,-337,-113,-128,60,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,60,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,60,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,60,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,60,-131,-95,-101,-97,60,-53,-126,60,-88,60,60,-93,60,-147,-335,-146,60,-167,-166,-182,-100,-126,60,-87,-90,-94,-92,-61,-72,60,-144,-142,60,60,60,-73,60,-89,60,60,60,-149,-159,-160,-156,-336,60,-183,-30,60,60,-74,60,60,60,60,-174,-175,60,-143,-140,60,-141,-145,-76,-79,-82,-75,-77,60,-81,-215,-214,-80,-216,-78,-127,60,-153,60,-151,-148,-157,-168,-69,-36,-35,60,60,60,-234,-233,60,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,60,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'PPPRAGMASTR':([61,],[124,]),'PLUSEQUAL':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,-276,-323,-312,-336,362,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'U32CHAR_CONST':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,138,-335,-28,-182,-27,138,-337,-87,-72,-337,138,-286,-285,138,138,-283,-287,-288,138,-284,138,138,138,-336,-183,138,138,-28,-337,138,-28,-337,-337,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,-337,-76,-79,-82,-75,138,-77,138,138,-81,-215,-214,-80,-216,138,-78,138,138,-69,-284,138,138,-284,138,138,-244,-247,-245,-241,-242,-246,-248,138,-250,-251,-243,-249,-12,138,138,-11,138,138,138,138,-234,-233,138,-231,138,138,-217,138,-230,138,-84,-218,138,138,138,-337,-337,-198,138,138,138,-337,-284,-229,-232,138,-221,138,-83,-219,-68,138,-28,-337,138,-11,138,138,-220,138,138,138,-284,138,138,138,-337,138,-225,-224,-222,-84,138,138,138,-226,-223,138,-228,-227,]),'CONDOP':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,258,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,-273,-262,-260,-264,-268,-263,-259,-266,-271,-257,-256,-265,-272,-267,-269,-270,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'U8STRING_LITERAL':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,139,146,148,149,150,151,153,163,165,166,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,235,236,237,238,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,163,-335,-28,-182,-27,163,-337,-87,-72,-337,163,-286,-285,-330,163,-327,163,-283,-287,236,-328,-288,-329,163,-284,163,163,163,-336,-183,163,163,-28,-337,163,-28,-337,-337,163,163,163,-334,-332,-331,-333,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,-337,-76,-79,-82,-75,163,-77,163,163,-81,-215,-214,-80,-216,163,-78,163,163,-69,-284,163,163,-284,163,163,-244,-247,-245,-241,-242,-246,-248,163,-250,-251,-243,-249,-12,163,163,-11,163,163,163,163,-234,-233,163,-231,163,163,-217,163,-230,163,-84,-218,163,163,163,-337,-337,-198,163,163,163,-337,-284,-229,-232,163,-221,163,-83,-219,-68,163,-28,-337,163,-11,163,163,-220,163,163,163,-284,163,163,163,-337,163,-225,-224,-222,-84,163,163,163,-226,-223,163,-228,-227,]),'BREAK':([61,97,119,124,181,191,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[-71,-335,-87,-72,304,-336,-76,-79,-82,-75,-77,304,-81,-215,-214,-80,-216,304,-78,-69,-234,-233,-231,304,-217,-230,304,-84,-218,304,-229,-232,-221,304,-83,-219,-68,304,-220,304,304,-225,-224,-222,-84,304,304,-226,-223,304,-228,-227,]),'VOLATILE':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,35,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,85,86,87,89,90,93,95,96,97,98,99,100,101,103,105,109,111,117,118,119,123,124,128,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,205,206,211,219,220,223,229,231,233,239,240,241,267,269,275,278,279,280,282,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,459,460,496,497,500,505,506,510,511,512,514,515,536,554,555,557,558,575,576,578,579,],[58,58,-113,-128,58,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,58,-120,-115,-65,-102,58,-131,-108,-238,-111,58,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,58,58,-119,58,-114,-130,58,-118,-71,-103,58,-131,-96,-98,58,-131,-95,-101,-97,58,-53,58,58,-88,58,58,-147,-335,-146,58,-167,-166,58,-182,-100,-126,58,58,-87,-61,-72,58,58,-144,-142,58,58,58,-73,58,-89,58,58,58,-149,-159,-160,-156,-336,58,-183,-30,58,58,58,58,58,-74,58,58,58,58,-174,-175,58,-143,-140,58,-141,-145,58,-76,-79,-82,-75,-77,58,-81,-215,-214,-80,-216,-78,-127,58,-153,58,-151,-148,-157,-168,-69,-36,-35,58,58,58,-234,-233,58,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,58,58,-229,-232,-221,-83,-219,-68,-33,-32,58,58,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'PPPRAGMA':([0,14,16,17,19,25,38,45,47,59,61,97,99,119,123,124,180,181,184,185,186,188,189,190,191,223,284,285,286,289,291,298,300,301,302,303,305,307,308,313,315,318,332,424,425,428,429,432,435,437,438,439,440,446,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[61,-64,-60,-67,-66,-65,-63,-62,-70,61,-71,-335,61,-87,-61,-72,-73,61,61,61,61,-159,-160,-156,-336,-74,-76,-79,-82,-75,-77,61,-81,-215,-214,-80,-216,61,-78,61,61,-157,-69,-234,-233,-231,61,-217,-230,61,-84,-218,61,-158,-229,-232,-221,61,-83,-219,-68,61,-220,61,61,-225,-224,-222,-84,61,61,-226,-223,61,-228,-227,]),'INLINE':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,86,87,89,90,93,96,97,98,100,101,109,111,118,119,123,124,129,180,181,182,187,191,200,211,223,240,241,278,284,285,286,289,291,298,300,301,302,303,305,308,312,314,316,317,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[30,30,-113,-128,30,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,30,-120,-115,-65,-102,30,-131,-108,-238,-111,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,30,30,-119,30,-114,-130,30,-118,-71,-103,30,-131,-96,-98,30,-131,-95,-101,-97,-53,30,30,-88,30,-147,-335,-146,-167,-166,-100,-126,30,-87,-61,-72,30,-73,30,-89,-149,-336,-30,30,-74,-174,-175,30,-76,-79,-82,-75,-77,30,-81,-215,-214,-80,-216,-78,-127,-153,-151,-148,-168,-69,-36,-35,30,30,30,-234,-233,30,-231,-217,-230,-81,-84,-218,-152,-150,-170,-169,-31,-34,30,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'INT_CONST_BIN':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,164,-335,-28,-182,-27,164,-337,-87,-72,-337,164,-286,-285,164,164,-283,-287,-288,164,-284,164,164,164,-336,-183,164,164,-28,-337,164,-28,-337,-337,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,-337,-76,-79,-82,-75,164,-77,164,164,-81,-215,-214,-80,-216,164,-78,164,164,-69,-284,164,164,-284,164,164,-244,-247,-245,-241,-242,-246,-248,164,-250,-251,-243,-249,-12,164,164,-11,164,164,164,164,-234,-233,164,-231,164,164,-217,164,-230,164,-84,-218,164,164,164,-337,-337,-198,164,164,164,-337,-284,-229,-232,164,-221,164,-83,-219,-68,164,-28,-337,164,-11,164,164,-220,164,164,164,-284,164,164,164,-337,164,-225,-224,-222,-84,164,164,164,-226,-223,164,-228,-227,]),'DO':([61,97,119,124,181,191,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[-71,-335,-87,-72,307,-336,-76,-79,-82,-75,-77,307,-81,-215,-214,-80,-216,307,-78,-69,-234,-233,-231,307,-217,-230,307,-84,-218,307,-229,-232,-221,307,-83,-219,-68,307,-220,307,307,-225,-224,-222,-84,307,307,-226,-223,307,-228,-227,]),'LNOT':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,165,-335,-28,-182,-27,165,-337,-87,-72,-337,165,-286,-285,165,165,-283,-287,-288,165,-284,165,165,165,-336,-183,165,165,-28,-337,165,-28,-337,-337,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,-337,-76,-79,-82,-75,165,-77,165,165,-81,-215,-214,-80,-216,165,-78,165,165,-69,-284,165,165,-284,165,165,-244,-247,-245,-241,-242,-246,-248,165,-250,-251,-243,-249,-12,165,165,-11,165,165,165,165,-234,-233,165,-231,165,165,-217,165,-230,165,-84,-218,165,165,165,-337,-337,-198,165,165,165,-337,-284,-229,-232,165,-221,165,-83,-219,-68,165,-28,-337,165,-11,165,165,-220,165,165,165,-284,165,165,165,-337,165,-225,-224,-222,-84,165,165,165,-226,-223,165,-228,-227,]),'CONST':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,35,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,85,86,87,89,90,93,95,96,97,98,99,100,101,103,105,109,111,117,118,119,123,124,128,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,205,206,211,219,220,223,229,231,233,239,240,241,267,269,275,278,279,280,282,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,459,460,496,497,500,505,506,510,511,512,514,515,536,554,555,557,558,575,576,578,579,],[3,3,-113,-128,3,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,3,-120,-115,-65,-102,3,-131,-108,-238,-111,3,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,3,3,-119,3,-114,-130,3,-118,-71,-103,3,-131,-96,-98,3,-131,-95,-101,-97,3,-53,3,3,-88,3,3,-147,-335,-146,3,-167,-166,3,-182,-100,-126,3,3,-87,-61,-72,3,3,-144,-142,3,3,3,-73,3,-89,3,3,3,-149,-159,-160,-156,-336,3,-183,-30,3,3,3,3,3,-74,3,3,3,3,-174,-175,3,-143,-140,3,-141,-145,3,-76,-79,-82,-75,-77,3,-81,-215,-214,-80,-216,-78,-127,3,-153,3,-151,-148,-157,-168,-69,-36,-35,3,3,3,-234,-233,3,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,3,3,-229,-232,-221,-83,-219,-68,-33,-32,3,3,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'LSHIFT':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,244,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,244,-262,-260,244,244,244,-259,244,244,-257,-256,244,244,244,244,244,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'LOR':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,243,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,-273,-262,-260,-264,-268,-263,-259,-266,-271,-257,-256,-265,-272,-267,-269,-270,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'CHAR_CONST':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,167,-335,-28,-182,-27,167,-337,-87,-72,-337,167,-286,-285,167,167,-283,-287,-288,167,-284,167,167,167,-336,-183,167,167,-28,-337,167,-28,-337,-337,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,-337,-76,-79,-82,-75,167,-77,167,167,-81,-215,-214,-80,-216,167,-78,167,167,-69,-284,167,167,-284,167,167,-244,-247,-245,-241,-242,-246,-248,167,-250,-251,-243,-249,-12,167,167,-11,167,167,167,167,-234,-233,167,-231,167,167,-217,167,-230,167,-84,-218,167,167,167,-337,-337,-198,167,167,167,-337,-284,-229,-232,167,-221,167,-83,-219,-68,167,-28,-337,167,-11,167,167,-220,167,167,167,-284,167,167,167,-337,167,-225,-224,-222,-84,167,167,167,-226,-223,167,-228,-227,]),'U16STRING_LITERAL':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,139,146,148,149,150,151,153,163,165,166,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,235,236,237,238,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,166,-335,-28,-182,-27,166,-337,-87,-72,-337,166,-286,-285,-330,166,-327,166,-283,-287,238,-328,-288,-329,166,-284,166,166,166,-336,-183,166,166,-28,-337,166,-28,-337,-337,166,166,166,-334,-332,-331,-333,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,-337,-76,-79,-82,-75,166,-77,166,166,-81,-215,-214,-80,-216,166,-78,166,166,-69,-284,166,166,-284,166,166,-244,-247,-245,-241,-242,-246,-248,166,-250,-251,-243,-249,-12,166,166,-11,166,166,166,166,-234,-233,166,-231,166,166,-217,166,-230,166,-84,-218,166,166,166,-337,-337,-198,166,166,166,-337,-284,-229,-232,166,-221,166,-83,-219,-68,166,-28,-337,166,-11,166,166,-220,166,166,166,-284,166,166,166,-337,166,-225,-224,-222,-84,166,166,166,-226,-223,166,-228,-227,]),'RBRACE':([61,97,99,119,124,132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,178,181,184,185,186,188,189,190,191,195,196,197,224,225,227,228,230,232,234,235,236,237,238,261,263,268,273,284,285,286,289,291,298,300,301,302,303,305,306,308,309,313,315,318,325,326,327,332,370,374,377,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,424,425,428,432,435,437,438,439,446,450,451,468,469,472,473,476,478,480,482,483,487,496,497,500,505,506,510,523,524,528,536,546,547,550,551,554,555,557,558,565,575,576,578,579,],[-71,-335,191,-87,-72,-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,-253,-328,-316,-329,-320,-276,-323,-312,-252,-337,191,191,191,-159,-160,-156,-336,-171,191,-176,-274,-239,-337,-193,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-76,-79,-82,-75,-77,-6,-81,-215,-214,-80,-216,-5,-78,191,191,191,-157,191,191,-172,-69,191,-22,-21,-261,-273,-262,-260,-264,-268,-263,-259,-266,-271,-257,-256,-265,-272,-267,-269,-270,-258,-296,-295,-294,-293,-292,-305,-234,-233,-231,-217,-230,-81,-84,-218,-158,-173,-177,-240,-194,191,-196,-237,-281,-282,-290,-291,-275,-229,-232,-221,-83,-219,-68,-195,-254,191,-220,-197,-306,191,-299,-225,-224,-222,-84,-300,-226,-223,-228,-227,]),'_BOOL':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[34,-337,-113,-128,34,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,34,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,34,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,34,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,34,-131,-95,-101,-97,34,-53,-126,34,-88,34,34,-93,34,-147,-335,-146,34,-167,-166,-182,-100,-126,34,-87,-90,-94,-92,-61,-72,34,-144,-142,34,34,34,-73,34,-89,34,34,34,-149,-159,-160,-156,-336,34,-183,-30,34,34,-74,34,34,34,34,-174,-175,34,-143,-140,34,-141,-145,-76,-79,-82,-75,-77,34,-81,-215,-214,-80,-216,-78,-127,34,-153,34,-151,-148,-157,-168,-69,-36,-35,34,34,34,-234,-233,34,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,34,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'LE':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,246,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,246,-262,-260,-264,246,-263,-259,-266,246,-257,-256,-265,246,246,246,246,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'SEMI':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,70,71,73,74,75,76,77,78,79,80,81,82,83,84,86,87,89,91,94,96,97,98,99,100,101,108,109,110,111,113,114,115,119,120,121,122,123,124,127,132,133,134,136,138,139,140,141,142,143,144,145,147,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,178,179,180,181,184,185,186,187,188,189,190,191,192,200,216,217,223,224,225,226,228,230,232,234,235,236,237,238,240,241,261,263,268,269,272,273,275,279,280,284,285,286,288,289,290,291,293,294,298,300,301,302,303,304,305,306,307,308,310,312,313,314,315,316,317,318,320,321,322,323,324,328,330,331,332,340,341,355,356,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,423,424,425,426,427,428,429,432,433,435,437,438,439,440,442,443,444,446,448,449,453,454,464,465,468,469,476,478,480,482,483,486,487,496,497,498,499,500,502,505,506,508,509,510,511,512,518,519,523,524,533,534,535,536,537,539,547,551,552,554,555,557,558,565,568,569,574,575,576,577,578,579,],[19,-337,-113,-128,-337,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,-337,-29,-121,-116,-62,-112,-70,-52,-123,-117,119,-337,-337,-119,-337,-114,-130,19,-118,-71,-103,-337,-9,-131,-91,-10,-96,-20,-98,-54,-179,-178,-131,-37,-134,-85,-95,-101,-97,-19,-132,-53,-126,-337,-337,-93,-147,-335,-146,188,-167,-166,-136,-100,-138,-126,-16,-86,-15,-87,-90,-94,-92,-61,-72,-55,-317,-321,-318,-303,-324,-330,-313,-319,-144,-301,-274,-314,-142,-327,-325,-304,-322,-302,-255,-315,-289,-253,-328,-316,-329,-320,-276,-323,-312,-252,-178,-73,-337,188,188,188,-149,-159,-160,-156,-336,-337,-30,-38,-133,-74,-274,-239,-135,-193,-326,-280,-277,-334,-332,-331,-333,-174,-175,-298,-297,-279,-143,-235,-278,-140,-141,-145,-76,-79,-82,424,-75,425,-77,428,-14,-337,-81,-215,-214,-80,435,-216,-13,-337,-78,-312,-127,188,-153,188,-151,-148,-157,-26,-25,446,-161,-163,-168,-139,-137,-69,-36,-35,-44,-43,-261,-273,-262,-260,-264,-268,-263,-259,-266,-271,-257,-256,-265,-272,-267,-269,-270,-258,-296,-295,-294,-293,-292,-305,496,-234,-233,497,-337,-231,-337,-217,-13,-230,-81,-84,-218,-337,-152,-150,-165,-158,-170,-169,-31,-34,-39,-42,-240,-194,-237,-281,-282,-290,-291,-236,-275,-229,-232,533,-337,-221,-337,-83,-219,-162,-164,-68,-33,-32,-41,-40,-195,-254,-337,553,-337,-220,-337,-337,-306,-299,566,-225,-224,-222,-84,-300,575,-337,-337,-226,-223,-337,-228,-227,]),'_THREAD_LOCAL':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,86,87,89,90,93,96,97,98,100,101,109,111,118,119,123,124,129,180,181,182,187,191,200,211,223,240,241,278,284,285,286,289,291,298,300,301,302,303,305,308,312,314,316,317,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[11,11,-113,-128,11,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,11,-120,-115,-65,-102,11,-131,-108,-238,-111,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,11,11,-119,11,-114,-130,11,-118,-71,-103,11,-131,-96,-98,11,-131,-95,-101,-97,-53,11,11,-88,11,-147,-335,-146,-167,-166,-100,-126,11,-87,-61,-72,11,-73,11,-89,-149,-336,-30,11,-74,-174,-175,11,-76,-79,-82,-75,-77,11,-81,-215,-214,-80,-216,-78,-127,-153,-151,-148,-168,-69,-36,-35,11,11,11,-234,-233,11,-231,-217,-230,-81,-84,-218,-152,-150,-170,-169,-31,-34,11,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'LT':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,248,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,248,-262,-260,-264,248,-263,-259,-266,248,-257,-256,-265,248,248,248,248,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'COMMA':([2,3,5,6,7,10,11,12,13,18,20,22,23,26,27,30,33,34,35,36,39,42,43,44,46,48,49,50,54,56,58,60,62,68,70,71,73,74,75,76,77,78,80,81,82,84,86,96,98,100,101,103,104,105,106,108,109,110,111,113,127,132,133,134,136,138,139,140,141,142,143,144,145,147,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,177,178,179,187,191,195,196,197,198,199,200,203,210,211,212,213,215,216,217,224,225,226,228,230,232,234,235,236,237,238,240,241,261,263,268,269,270,272,273,274,275,276,277,279,280,281,283,294,310,312,314,316,317,320,323,324,325,326,327,328,330,331,340,341,343,344,345,346,347,348,355,356,374,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,414,426,442,443,444,448,449,450,451,453,454,458,461,463,464,465,468,469,473,476,478,480,482,483,486,487,489,490,492,501,503,507,508,509,511,512,518,519,523,524,525,528,529,530,531,532,544,545,546,547,551,556,559,560,564,565,570,571,],[-113,-128,-124,-110,-106,-104,-107,-125,-105,-99,-109,-120,-115,-102,-126,-108,-238,-111,-337,-122,-129,-29,-121,-116,-112,-52,-123,-117,-119,-114,-130,-118,-103,-96,126,-98,-54,-179,-178,-131,-37,-134,-95,-101,-97,-132,-53,-147,-146,-167,-166,-28,-180,-182,-27,-136,-100,-138,-126,202,-55,-317,-321,-318,-303,-324,-330,-313,-319,-144,-301,-274,-314,-142,-327,-325,-304,-322,-302,-255,-315,-289,-253,-328,-316,-329,-320,-276,-323,-312,-337,-252,-178,-149,-336,-171,327,-176,-183,-181,-30,333,-186,-337,349,350,-191,-38,-133,-274,-239,-135,-193,-326,-280,-277,-334,-332,-331,-333,-174,-175,-298,-297,-279,-143,412,-235,-278,-203,-140,-204,-1,-141,-145,-2,-206,412,-312,-127,-153,-151,-148,445,-161,-163,327,327,-172,-168,-139,-137,-36,-35,-190,-204,-56,-188,-45,-189,-44,-43,472,-261,-273,-262,-260,-264,-268,-263,-259,-266,-271,-257,-256,-265,-272,-267,-269,412,-270,-258,-296,-295,-294,-293,412,-292,-310,484,485,-305,-205,412,-152,-150,-165,-170,-169,-173,-177,-31,-34,-57,-192,-187,-39,-42,-240,-194,-196,-237,-281,-282,-290,-291,-236,-275,-213,-207,-211,412,412,412,-162,-164,-33,-32,-41,-40,-195,-254,-311,550,-209,-208,-210,-212,-51,-50,-197,-306,-299,412,-46,-49,412,-300,-48,-47,]),'U16CHAR_CONST':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,169,-335,-28,-182,-27,169,-337,-87,-72,-337,169,-286,-285,169,169,-283,-287,-288,169,-284,169,169,169,-336,-183,169,169,-28,-337,169,-28,-337,-337,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,-337,-76,-79,-82,-75,169,-77,169,169,-81,-215,-214,-80,-216,169,-78,169,169,-69,-284,169,169,-284,169,169,-244,-247,-245,-241,-242,-246,-248,169,-250,-251,-243,-249,-12,169,169,-11,169,169,169,169,-234,-233,169,-231,169,169,-217,169,-230,169,-84,-218,169,169,169,-337,-337,-198,169,169,169,-337,-284,-229,-232,169,-221,169,-83,-219,-68,169,-28,-337,169,-11,169,169,-220,169,169,169,-284,169,169,169,-337,169,-225,-224,-222,-84,169,169,169,-226,-223,169,-228,-227,]),'OFFSETOF':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,137,146,149,150,151,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,170,-335,-28,-182,-27,170,-337,-87,-72,-337,170,-286,-285,170,170,-283,-287,-288,170,-284,170,170,170,-336,-183,170,170,-28,-337,170,-28,-337,-337,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,-337,-76,-79,-82,-75,170,-77,170,170,-81,-215,-214,-80,-216,170,-78,170,170,-69,-284,170,170,-284,170,170,-244,-247,-245,-241,-242,-246,-248,170,-250,-251,-243,-249,-12,170,170,-11,170,170,170,170,-234,-233,170,-231,170,170,-217,170,-230,170,-84,-218,170,170,170,-337,-337,-198,170,170,170,-337,-284,-229,-232,170,-221,170,-83,-219,-68,170,-28,-337,170,-11,170,170,-220,170,170,170,-284,170,170,170,-337,170,-225,-224,-222,-84,170,170,170,-226,-223,170,-228,-227,]),'_ATOMIC':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,35,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,103,105,109,111,117,118,119,120,121,122,123,124,128,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,205,206,211,214,219,220,223,229,231,233,239,240,241,267,269,275,278,279,280,282,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,459,460,496,497,500,505,506,510,511,512,514,515,536,554,555,557,558,575,576,578,579,],[29,65,-113,-128,76,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,65,-120,-115,-65,-102,65,-131,-108,-238,-111,76,-122,-63,-129,112,-29,-121,-116,-62,-112,-70,-52,-123,-117,65,65,-119,65,-114,-130,29,-118,-71,-103,65,-9,-131,-91,-10,-96,-98,65,-131,-95,-101,-97,29,-53,65,76,-88,112,65,-93,29,-147,-335,-146,29,-167,-166,76,-182,-100,-126,76,29,-87,-90,-94,-92,-61,-72,76,29,-144,-142,65,29,76,-73,65,-89,29,29,29,-149,-159,-160,-156,-336,76,-183,-30,76,76,76,112,76,76,-74,29,29,29,29,-174,-175,29,-143,-140,29,-141,-145,76,-76,-79,-82,-75,-77,65,-81,-215,-214,-80,-216,-78,-127,29,-153,29,-151,-148,-157,-168,-69,-36,-35,29,29,29,-234,-233,65,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,76,29,-229,-232,-221,-83,-219,-68,-33,-32,76,76,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'TYPEDEF':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,86,87,89,90,93,96,97,98,100,101,109,111,118,119,123,124,129,180,181,182,187,191,200,211,223,240,241,278,284,285,286,289,291,298,300,301,302,303,305,308,312,314,316,317,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[7,7,-113,-128,7,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,7,-120,-115,-65,-102,7,-131,-108,-238,-111,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,7,7,-119,7,-114,-130,7,-118,-71,-103,7,-131,-96,-98,7,-131,-95,-101,-97,-53,7,7,-88,7,-147,-335,-146,-167,-166,-100,-126,7,-87,-61,-72,7,-73,7,-89,-149,-336,-30,7,-74,-174,-175,7,-76,-79,-82,-75,-77,7,-81,-215,-214,-80,-216,-78,-127,-153,-151,-148,-168,-69,-36,-35,7,7,7,-234,-233,7,-231,-217,-230,-81,-84,-218,-152,-150,-170,-169,-31,-34,7,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'XOR':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,251,-328,-316,-329,-320,-276,-323,-312,-336,-274,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-261,251,-262,-260,-264,-268,-263,-259,-266,-271,-257,-256,-265,251,-267,-269,251,-258,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'AUTO':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,65,68,71,75,76,80,81,82,86,87,89,90,93,96,97,98,100,101,109,111,118,119,123,124,129,180,181,182,187,191,200,211,223,240,241,278,284,285,286,289,291,298,300,301,302,303,305,308,312,314,316,317,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[26,26,-113,-128,26,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,26,-120,-115,-65,-102,26,-131,-108,-238,-111,-122,-63,-129,-29,-121,-116,-62,-112,-70,-52,-123,-117,26,26,-119,26,-114,-130,26,-118,-71,-103,26,-131,-96,-98,26,-131,-95,-101,-97,-53,26,26,-88,26,-147,-335,-146,-167,-166,-100,-126,26,-87,-61,-72,26,-73,26,-89,-149,-336,-30,26,-74,-174,-175,26,-76,-79,-82,-75,-77,26,-81,-215,-214,-80,-216,-78,-127,-153,-151,-148,-168,-69,-36,-35,26,26,26,-234,-233,26,-231,-217,-230,-81,-84,-218,-152,-150,-170,-169,-31,-34,26,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'DIVEQUAL':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,-276,-323,-312,-336,357,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'TIMES':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,22,23,25,26,27,29,30,33,34,35,36,37,38,39,40,43,44,45,46,47,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,69,71,76,80,81,82,85,87,89,91,94,96,97,98,100,101,103,104,105,106,109,111,116,117,119,120,121,122,123,124,126,128,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,156,158,160,161,162,163,164,165,166,167,168,169,171,173,174,175,176,177,180,181,187,191,192,198,201,202,204,205,206,211,218,219,220,223,224,227,229,230,231,232,233,234,235,236,237,238,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,263,265,266,268,269,273,275,278,279,280,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,310,312,314,316,317,319,328,329,332,336,338,339,342,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,407,411,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,442,443,445,447,448,449,459,472,475,477,478,480,481,482,483,484,487,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,547,549,550,551,553,554,555,557,558,565,566,569,574,575,576,577,578,579,],[35,-337,-113,-128,35,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,-120,-115,-65,-102,-126,-131,-108,-238,-111,-337,-122,35,-63,-129,35,-121,-116,-62,-112,-70,-123,-117,-337,-337,-119,-337,-114,-130,35,-118,-71,-103,-337,-9,-131,-91,-10,-96,35,-98,-131,-95,-101,-97,173,-126,35,35,-93,-147,-335,-146,-167,-166,-28,35,-182,-27,-100,-126,173,-337,-87,-90,-94,-92,-61,-72,35,-337,173,-317,-321,-318,-286,-303,-285,-324,-330,-313,-319,-144,-301,-274,-314,173,-142,-327,173,-283,-287,-325,-304,-322,-302,-255,-315,-289,253,-328,-316,-288,-329,-320,-276,-323,173,-284,173,173,-312,35,-73,173,-149,-336,35,-183,173,35,336,-28,-337,35,352,-28,-337,-74,-274,-337,173,-326,173,-280,173,-277,-334,-332,-331,-333,-174,-175,173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,-298,-297,173,173,-279,-143,-278,-140,35,-141,-145,420,-76,-79,-82,-75,173,-77,173,173,-81,-215,-214,-80,-216,173,-78,-312,-127,-153,-151,-148,173,-168,173,-69,-284,173,173,35,-284,173,173,-244,-247,-245,-241,-242,-246,-248,173,-250,-251,-243,-249,-12,173,173,-11,253,253,253,253,253,253,253,253,253,253,-257,-256,253,253,253,253,253,-258,-296,-295,-294,-293,-292,-305,173,173,173,494,-234,-233,173,-231,173,173,-217,173,-230,173,-84,-218,173,173,-152,-150,35,173,-170,-169,-337,-337,-198,173,-281,-282,173,-290,-291,173,-275,-337,-284,-229,-232,173,-221,173,-83,-219,-68,541,-28,-337,173,-11,173,173,-220,173,173,173,-284,173,173,-306,173,-337,-299,173,-225,-224,-222,-84,-300,173,173,173,-226,-223,173,-228,-227,]),'LPAREN':([0,1,2,3,4,5,6,7,8,10,11,12,13,14,15,16,17,18,19,20,22,23,25,26,27,29,30,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,69,71,72,73,76,77,80,81,82,85,86,87,89,91,94,96,97,98,100,101,103,104,105,106,109,111,112,116,117,119,120,121,122,123,124,126,127,128,131,132,133,134,135,136,137,138,139,140,141,142,143,145,146,147,148,149,150,151,152,153,154,155,156,160,161,163,164,165,166,167,168,169,170,171,173,174,175,176,177,180,181,187,191,192,198,199,200,201,202,204,205,206,211,216,218,219,220,223,227,229,230,231,233,235,236,237,238,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,263,265,266,269,275,276,278,279,280,282,283,284,285,286,289,290,291,292,296,297,298,299,300,301,302,303,305,307,308,310,311,312,314,316,317,319,328,329,332,336,338,339,340,341,342,344,345,347,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,402,403,404,405,407,411,412,413,414,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,442,443,445,447,448,449,453,454,457,458,459,464,465,472,475,477,481,482,483,484,488,489,490,492,494,496,497,499,500,502,504,505,506,510,511,512,513,514,515,518,519,521,522,529,530,531,532,533,535,536,537,538,539,541,542,543,544,545,547,549,550,551,553,554,555,557,558,559,560,565,566,569,570,571,574,575,576,577,578,579,],[37,-337,-113,-128,69,-124,-110,-106,85,-104,-107,-125,-105,-64,37,-60,-67,-99,-66,-109,-120,-115,-65,-102,-126,95,-108,-238,-111,-337,-122,37,-63,-129,37,116,-29,-121,-116,-62,-112,-70,118,-123,-117,-337,-337,-119,-337,-114,-130,37,-118,-71,-103,-337,-9,95,-91,-10,-96,69,-98,69,129,-131,-37,-95,-101,-97,174,118,-126,69,37,-93,-147,-335,-146,-167,-166,-28,-180,-182,-27,-100,-126,95,174,-337,-87,-90,-94,-92,-61,-72,69,129,-337,229,-317,-321,-318,-286,-303,-285,-324,-330,-313,-319,-144,-301,-314,231,-142,-327,233,-283,-287,-325,-304,-322,239,-302,-315,-289,-328,-316,-288,-329,-320,266,-323,267,174,-284,229,233,-312,278,-73,229,-149,-336,69,-183,-181,-30,229,69,229,-28,-337,342,-38,229,-28,-337,-74,-337,229,-326,229,229,-334,-332,-331,-333,-174,-175,174,174,174,174,174,174,174,174,174,174,174,174,174,174,174,174,229,174,174,-298,-297,229,229,-143,-140,278,278,-141,-145,-337,422,-76,-79,-82,-75,229,-77,427,430,174,229,434,-81,-215,-214,-80,-216,229,-78,-312,441,-127,-153,-151,-148,174,-168,174,-69,-284,229,229,-36,-35,342,342,460,-45,-284,229,229,-44,-43,-244,-247,-245,-241,-242,-246,-248,229,-250,-251,-243,-249,-12,174,229,-11,-296,-295,-294,-293,-292,-305,229,174,422,229,229,-234,-233,229,-231,229,229,-217,229,-230,229,-84,-218,229,229,-152,-150,69,174,-170,-169,-31,-34,342,460,-337,-39,-42,-337,-198,174,174,-290,-291,229,-337,-213,-207,-211,-284,-229,-232,229,-221,229,538,-83,-219,-68,-33,-32,229,-28,-337,-41,-40,229,-11,-209,-208,-210,-212,229,229,-220,229,229,229,-284,229,229,-51,-50,-306,229,-337,-299,229,-225,-224,-222,-84,-46,-49,-300,229,229,-48,-47,229,-226,-223,229,-228,-227,]),'MINUSMINUS':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,132,133,134,135,136,137,138,139,140,141,143,145,146,148,149,150,151,152,153,154,156,160,161,163,164,165,166,167,168,169,171,173,174,175,176,181,191,198,201,204,205,206,218,219,220,227,229,230,231,233,235,236,237,238,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,263,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,310,319,329,332,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,402,403,404,405,407,411,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,459,472,475,477,481,482,483,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,547,549,550,551,553,554,555,557,558,565,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,175,-335,-28,-182,-27,175,-337,-87,-72,-337,175,-317,-321,-318,-286,-303,-285,-324,-330,-313,-319,-301,-314,175,-327,175,-283,-287,-325,-304,-322,-302,-315,-289,-328,-316,-288,-329,-320,261,-323,175,-284,175,175,-312,175,-336,-183,175,175,-28,-337,175,-28,-337,-337,175,-326,175,175,-334,-332,-331,-333,175,175,175,175,175,175,175,175,175,175,175,175,175,175,175,175,175,175,175,-298,-297,175,175,-337,-76,-79,-82,-75,175,-77,175,175,-81,-215,-214,-80,-216,175,-78,-312,175,175,-69,-284,175,175,-284,175,175,-244,-247,-245,-241,-242,-246,-248,175,-250,-251,-243,-249,-12,175,175,-11,-296,-295,-294,-293,-292,-305,175,175,175,175,-234,-233,175,-231,175,175,-217,175,-230,175,-84,-218,175,175,175,-337,-337,-198,175,175,-290,-291,175,-337,-284,-229,-232,175,-221,175,-83,-219,-68,175,-28,-337,175,-11,175,175,-220,175,175,175,-284,175,175,-306,175,-337,-299,175,-225,-224,-222,-84,-300,175,175,175,-226,-223,175,-228,-227,]),'ID':([0,1,2,3,4,5,6,7,10,11,12,13,14,15,16,17,18,19,20,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,43,44,45,46,47,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,69,71,72,76,80,81,82,85,87,89,91,94,96,97,98,100,101,102,103,104,105,106,109,111,116,117,118,119,120,121,122,123,124,126,128,129,131,135,137,142,146,147,149,150,151,165,171,173,174,175,180,181,187,191,192,193,194,198,199,201,202,204,205,206,211,218,219,220,223,227,229,231,233,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,262,264,265,266,269,275,279,280,282,284,285,286,287,289,290,291,297,298,300,301,302,303,305,307,308,312,314,316,317,319,327,328,329,332,336,338,339,342,344,349,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,372,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,442,443,445,447,448,449,457,459,460,472,475,477,481,484,485,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,548,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[42,-337,-113,-128,42,-124,-110,-106,-104,-107,-125,-105,-64,42,-60,-67,-99,-66,-109,-120,-115,-154,-65,-102,-126,-155,-131,-108,98,101,-238,-111,-337,-122,42,-63,-129,42,-121,-116,-62,-112,-70,-123,-117,-337,-337,-119,-337,-114,-130,42,-118,-71,-103,-337,-9,-131,-91,-10,-96,42,-98,42,-131,-95,-101,-97,176,-126,42,42,-93,-147,-335,-146,-167,-166,197,-28,-180,-182,-27,-100,-126,176,-337,176,-87,-90,-94,-92,-61,-72,42,-337,176,176,-286,-285,-144,176,-142,176,-283,-287,-288,176,-284,176,176,-73,310,-149,-336,42,197,197,-183,-181,176,42,176,-28,-337,42,176,-28,-337,-74,-337,176,176,176,-174,-175,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,403,405,176,176,-143,-140,-141,-145,-337,-76,-79,-82,423,-75,176,-77,176,310,-81,-215,-214,-80,-216,310,-78,-127,-153,-151,-148,176,197,-168,176,-69,-284,176,176,42,42,176,-284,176,176,-244,-247,-245,-241,-242,-246,-248,176,-250,-251,-243,-249,-12,176,176,176,-11,176,176,176,176,-234,-233,176,-231,310,176,-217,176,-230,310,-84,-218,310,176,-152,-150,42,176,-170,-169,42,-337,176,-337,-198,176,176,176,176,-337,-284,-229,-232,176,-221,310,-83,-219,-68,176,-28,-337,176,-11,176,310,-220,310,176,310,-284,176,176,176,176,-337,176,-225,-224,-222,-84,176,310,310,-226,-223,310,-228,-227,]),'IF':([61,97,119,124,181,191,284,285,286,289,291,298,300,301,302,303,305,307,308,332,424,425,428,429,432,435,437,438,439,440,496,497,500,502,505,506,510,535,536,537,539,554,555,557,558,569,574,575,576,577,578,579,],[-71,-335,-87,-72,311,-336,-76,-79,-82,-75,-77,311,-81,-215,-214,-80,-216,311,-78,-69,-234,-233,-231,311,-217,-230,311,-84,-218,311,-229,-232,-221,311,-83,-219,-68,311,-220,311,311,-225,-224,-222,-84,311,311,-226,-223,311,-228,-227,]),'STRING_LITERAL':([3,39,58,61,76,85,97,103,105,106,116,117,119,124,128,131,135,136,137,146,149,150,151,152,165,171,173,174,175,181,191,198,201,204,205,206,218,219,220,227,229,230,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,282,284,285,286,289,290,291,297,298,300,301,302,303,305,307,308,319,329,332,333,336,338,339,352,353,354,357,358,359,360,361,362,363,364,365,366,367,368,369,373,375,377,412,413,419,421,424,425,427,428,429,430,432,434,435,437,438,439,440,441,447,452,459,472,475,477,481,484,488,494,496,497,499,500,502,505,506,510,513,514,515,521,522,533,535,536,537,538,539,541,542,543,549,550,553,554,555,557,558,566,569,574,575,576,577,578,579,],[-128,-129,-130,-71,-131,152,-335,-28,-182,-27,152,-337,-87,-72,-337,152,-286,230,-285,152,152,-283,-287,-325,-288,152,-284,152,152,152,-336,-183,152,152,-28,-337,152,-28,-337,-337,152,-326,152,152,152,152,152,152,152,152,152,152,152,152,152,152,152,152,152,152,152,152,152,152,152,-337,-76,-79,-82,-75,152,-77,152,152,-81,-215,-214,-80,-216,152,-78,152,152,-69,152,-284,152,152,-284,152,152,-244,-247,-245,-241,-242,-246,-248,152,-250,-251,-243,-249,-12,152,152,-11,152,152,152,152,-234,-233,152,-231,152,152,-217,152,-230,152,-84,-218,152,152,152,230,-337,-337,-198,152,152,152,-337,-284,-229,-232,152,-221,152,-83,-219,-68,152,-28,-337,152,-11,152,152,-220,152,152,152,-284,152,152,152,-337,152,-225,-224,-222,-84,152,152,152,-226,-223,152,-228,-227,]),'FLOAT':([0,1,2,3,4,5,6,7,10,11,12,13,14,16,17,18,19,20,21,22,23,25,26,27,29,30,33,34,36,38,39,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,62,63,64,65,66,67,68,71,75,76,80,81,82,85,86,87,89,90,91,93,94,95,96,97,98,99,100,101,105,109,111,118,119,120,121,122,123,124,129,142,147,172,174,177,180,181,182,184,185,186,187,188,189,190,191,192,198,200,211,214,223,229,231,233,239,240,241,267,269,275,278,279,280,284,285,286,289,291,298,300,301,302,303,305,308,312,313,314,315,316,317,318,328,332,340,341,342,350,422,424,425,427,428,432,435,437,438,439,442,443,446,448,449,453,454,460,496,497,500,505,506,510,511,512,536,554,555,557,558,575,576,578,579,],[44,-337,-113,-128,44,-124,-110,-106,-104,-107,-125,-105,-64,-60,-67,-99,-66,-109,44,-120,-115,-65,-102,-126,-131,-108,-238,-111,-122,-63,-129,44,-29,-121,-116,-62,-112,-70,-52,-123,-117,-337,-337,-119,-337,-114,-130,44,-118,-71,-103,-337,-9,-131,-91,-10,-96,-98,44,-131,-95,-101,-97,44,-53,-126,44,-88,44,44,-93,44,-147,-335,-146,44,-167,-166,-182,-100,-126,44,-87,-90,-94,-92,-61,-72,44,-144,-142,44,44,44,-73,44,-89,44,44,44,-149,-159,-160,-156,-336,44,-183,-30,44,44,-74,44,44,44,44,-174,-175,44,-143,-140,44,-141,-145,-76,-79,-82,-75,-77,44,-81,-215,-214,-80,-216,-78,-127,44,-153,44,-151,-148,-157,-168,-69,-36,-35,44,44,44,-234,-233,44,-231,-217,-230,-81,-84,-218,-152,-150,-158,-170,-169,-31,-34,44,-229,-232,-221,-83,-219,-68,-33,-32,-220,-225,-224,-222,-84,-226,-223,-228,-227,]),'XOREQUAL':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,-276,-323,-312,-336,361,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'LSHIFTEQUAL':([132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,160,161,163,164,166,167,168,169,176,191,224,230,232,234,235,236,237,238,261,263,268,273,310,402,403,404,405,407,411,478,480,482,483,487,547,551,565,],[-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-315,-289,-328,-316,-329,-320,-276,-323,-312,-336,363,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-278,-312,-296,-295,-294,-293,-292,-305,-281,-282,-290,-291,-275,-306,-299,-300,]),'RBRACKET':([3,39,58,76,103,105,106,117,128,132,133,134,136,138,139,140,141,143,144,145,148,152,153,154,156,158,160,161,162,163,164,166,167,168,169,176,178,191,198,204,205,218,219,224,225,230,232,234,235,236,237,238,261,263,268,272,273,282,334,335,336,337,351,352,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,400,401,402,403,404,405,406,407,411,419,420,421,455,456,459,466,467,468,471,476,478,480,482,483,486,487,491,493,494,513,514,524,540,541,547,551,561,562,564,565,],[-128,-129,-130,-131,-28,-182,-27,-337,-337,-317,-321,-318,-303,-324,-330,-313,-319,-301,-274,-314,-327,-325,-304,-322,-302,-255,-315,-289,-253,-328,-316,-329,-320,-276,-323,-312,-252,-336,-183,-337,-28,-337,-28,-274,-239,-326,-280,-277,-334,-332,-331,-333,-298,-297,-279,-235,-278,-337,453,-4,454,-3,464,465,-261,-273,-262,-260,-264,-268,-263,-259,-266,-271,-257,-256,-265,-272,-267,-269,-270,-258,-296,-295,-294,-293,482,-292,-305,-337,492,-337,511,512,-337,518,519,-240,520,-237,-281,-282,-290,-291,-236,-275,529,530,531,-337,-28,-254,559,560,-306,-299,570,571,572,-300,]),}
+
+_lr_action = {}
+for _k, _v in _lr_action_items.items():
+   for _x,_y in zip(_v[0],_v[1]):
+      if not _x in _lr_action:  _lr_action[_x] = {}
+      _lr_action[_x][_k] = _y
+del _lr_action_items
+
+_lr_goto_items = {'expression_statement':([181,298,307,429,437,440,502,535,537,539,569,574,577,],[284,284,284,284,284,284,284,284,284,284,284,284,284,]),'struct_or_union_specifier':([0,21,40,59,75,85,91,93,95,99,118,129,172,174,181,184,185,186,214,229,231,233,239,267,278,298,313,315,342,350,422,427,460,],[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,]),'init_declarator_list':([4,89,],[70,70,]),'init_declarator_list_opt':([4,89,],[79,79,]),'iteration_statement':([181,298,307,429,437,440,502,535,537,539,569,574,577,],[285,285,285,285,285,285,285,285,285,285,285,285,285,]),'static_assert':([0,59,181,298,307,429,437,440,502,535,537,539,569,574,577,],[17,17,286,286,286,286,286,286,286,286,286,286,286,286,286,]),'unified_string_literal':([85,116,131,146,149,171,174,175,181,201,204,218,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,290,297,298,307,319,329,333,338,339,353,354,364,373,375,412,413,419,421,427,429,430,434,437,440,441,447,477,481,484,499,502,513,521,533,535,537,538,539,542,543,549,553,566,569,574,577,],[136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,452,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,]),'assignment_expression_opt':([204,218,419,421,513,],[334,351,491,493,540,]),'brace_open':([31,32,92,96,98,100,101,130,131,181,201,229,298,307,375,413,429,437,440,477,478,479,502,521,535,537,539,569,574,577,],[99,102,181,184,185,193,194,181,227,181,227,181,181,181,227,488,181,181,181,488,488,488,181,227,181,181,181,181,181,181,]),'enumerator':([102,193,194,327,],[195,195,195,450,]),'typeid_noparen_declarator':([211,],[348,]),'type_qualifier_list_opt':([35,117,128,206,220,282,459,515,],[104,204,218,339,354,419,513,543,]),'declaration_specifiers_no_type_opt':([1,27,52,53,55,63,87,],[66,94,120,121,122,94,94,]),'expression_opt':([181,298,307,427,429,437,440,499,502,533,535,537,539,553,566,569,574,577,],[288,288,288,498,288,288,288,534,288,552,288,288,288,567,573,288,288,288,]),'designation':([227,472,488,550,],[369,369,369,369,]),'parameter_list':([118,129,278,342,422,460,],[213,213,213,213,213,213,]),'alignment_specifier':([0,1,4,21,27,52,53,55,59,63,75,85,87,89,93,95,99,118,129,174,177,181,184,185,186,192,211,229,231,233,239,267,278,298,313,315,342,350,422,427,460,],[53,53,81,53,53,53,53,53,53,53,53,142,53,81,53,142,142,53,53,142,280,53,142,142,142,280,81,142,142,142,142,142,53,53,142,142,53,53,53,53,53,]),'labeled_statement':([181,298,307,429,437,440,502,535,537,539,569,574,577,],[289,289,289,289,289,289,289,289,289,289,289,289,289,]),'abstract_declarator':([177,211,278,342,],[281,281,418,418,]),'translation_unit':([0,],[59,]),'init_declarator':([4,89,126,202,],[84,84,217,331,]),'direct_abstract_declarator':([177,211,276,278,342,344,457,],[283,283,414,283,283,414,414,]),'designator_list':([227,472,488,550,],[376,376,376,376,]),'identifier':([85,116,118,129,131,146,149,171,174,175,181,201,204,218,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,290,297,298,307,319,329,338,339,349,353,354,364,372,373,375,412,413,419,421,427,429,430,434,437,440,441,447,460,477,481,484,485,499,502,513,521,533,535,537,538,539,542,543,548,549,553,566,569,574,577,],[143,143,215,215,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,461,143,143,143,470,143,143,143,143,143,143,143,143,143,143,143,143,143,143,215,143,143,143,527,143,143,143,143,143,143,143,143,143,143,143,563,143,143,143,143,143,143,]),'offsetof_member_designator':([485,],[526,]),'unary_expression':([85,116,131,146,149,171,174,175,181,201,204,218,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,290,297,298,307,319,329,338,339,353,354,364,373,375,412,413,419,421,427,429,430,434,437,440,441,447,477,481,484,499,502,513,521,533,535,537,538,539,542,543,549,553,566,569,574,577,],[144,144,224,232,234,144,224,273,224,224,224,224,224,224,224,144,144,144,144,144,144,144,144,144,144,144,144,144,144,144,144,224,144,144,224,224,224,144,224,224,144,144,224,224,224,224,224,144,224,224,144,224,224,224,224,224,224,224,224,224,144,144,144,224,224,224,224,224,224,224,224,224,224,224,224,224,224,224,224,224,224,]),'abstract_declarator_opt':([177,211,],[274,343,]),'initializer':([131,201,375,521,],[226,330,473,546,]),'direct_id_declarator':([0,4,15,37,40,59,69,72,89,91,126,192,202,211,342,344,445,457,],[48,48,86,48,48,48,48,86,48,48,48,48,48,48,48,86,48,86,]),'struct_declaration_list':([99,184,185,],[186,313,315,]),'pp_directive':([0,59,],[14,14,]),'declaration_list':([21,75,],[93,93,]),'id_init_declarator':([40,91,],[108,108,]),'type_specifier':([0,21,40,59,75,85,91,93,95,99,118,129,172,174,181,184,185,186,214,229,231,233,239,267,278,298,313,315,342,350,422,427,460,],[18,18,109,18,18,147,109,18,147,147,18,18,269,147,18,147,147,147,109,147,147,147,147,147,18,18,147,147,18,18,18,18,18,]),'compound_statement':([92,130,181,229,298,307,429,437,440,502,535,537,539,569,574,577,],[180,223,291,378,291,291,291,291,291,291,291,291,291,291,291,291,]),'pointer':([0,4,37,40,59,69,89,91,104,126,177,192,202,211,278,342,445,],[15,72,15,15,15,72,72,15,199,72,276,72,72,344,276,457,72,]),'typeid_declarator':([4,69,89,126,192,202,445,],[74,125,74,74,74,74,74,]),'id_init_declarator_list':([40,91,],[113,113,]),'declarator':([4,89,126,192,202,445,],[78,78,78,324,78,324,]),'argument_expression_list':([266,],[409,]),'struct_declarator_list_opt':([192,],[322,]),'block_item_list':([181,],[298,]),'parameter_type_list_opt':([278,342,422,],[417,417,495,]),'struct_declarator':([192,445,],[323,508,]),'type_qualifier':([0,1,4,21,27,35,52,53,55,59,63,75,85,87,89,93,95,99,103,117,118,128,129,172,174,177,181,184,185,186,192,205,206,211,219,220,229,231,233,239,267,278,282,298,313,315,342,350,422,427,459,460,514,515,],[52,52,80,52,52,105,52,52,52,52,52,52,105,52,80,52,105,105,198,105,52,105,52,198,105,279,52,105,105,105,279,198,105,80,198,105,105,105,105,105,105,52,105,52,105,105,52,52,52,52,105,52,198,105,]),'assignment_operator':([224,],[364,]),'expression':([174,181,229,231,233,258,265,290,298,307,427,429,430,434,437,440,441,499,502,533,535,537,538,539,549,553,566,569,574,577,],[270,294,270,270,270,399,406,426,294,294,294,294,501,503,294,294,507,294,294,294,294,294,556,294,564,294,294,294,294,294,]),'storage_class_specifier':([0,1,4,21,27,52,53,55,59,63,75,87,89,93,118,129,181,211,278,298,342,350,422,427,460,],[1,1,68,1,1,1,1,1,1,1,1,1,68,1,1,1,1,68,1,1,1,1,1,1,1,]),'unified_wstring_literal':([85,116,131,146,149,171,174,175,181,201,204,218,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,290,297,298,307,319,329,338,339,353,354,364,373,375,412,413,419,421,427,429,430,434,437,440,441,447,477,481,484,499,502,513,521,533,535,537,538,539,542,543,549,553,566,569,574,577,],[153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,153,]),'translation_unit_or_empty':([0,],[9,]),'initializer_list_opt':([227,],[370,]),'brace_close':([99,184,185,186,196,309,313,315,325,326,370,472,528,550,],[187,314,316,317,328,439,442,443,448,449,469,523,551,565,]),'direct_typeid_declarator':([4,69,72,89,126,192,202,445,],[73,73,127,73,73,73,73,73,]),'external_declaration':([0,59,],[16,123,]),'pragmacomp_or_statement':([307,429,440,502,535,537,539,569,574,577,],[436,500,506,536,554,555,557,576,578,579,]),'type_name':([85,95,174,229,231,233,239,267,],[157,183,271,379,380,381,382,410,]),'typedef_name':([0,21,40,59,75,85,91,93,95,99,118,129,172,174,181,184,185,186,214,229,231,233,239,267,278,298,313,315,342,350,422,427,460,],[36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,]),'pppragma_directive':([0,59,99,181,184,185,186,298,307,313,315,429,437,440,502,535,537,539,569,574,577,],[25,25,189,300,189,189,189,300,437,189,189,437,300,437,437,437,437,437,437,437,437,]),'statement':([181,298,307,429,437,440,502,535,537,539,569,574,577,],[301,301,438,438,505,438,438,438,438,558,438,438,438,]),'cast_expression':([85,116,131,171,174,181,201,204,218,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,290,297,298,307,319,329,338,339,353,354,364,373,375,412,413,419,421,427,429,430,434,437,440,441,447,477,481,484,499,502,513,521,533,535,537,538,539,542,543,549,553,566,569,574,577,],[158,158,158,268,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,487,158,158,158,158,158,158,158,158,158,158,487,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,158,]),'atomic_specifier':([0,1,21,27,40,52,53,55,59,63,75,85,87,91,93,95,99,118,129,172,174,181,184,185,186,214,229,231,233,239,267,278,298,313,315,342,350,422,427,460,],[27,63,87,63,111,63,63,63,27,63,87,111,63,111,87,111,111,27,27,111,111,87,111,111,111,111,111,111,111,111,111,27,87,111,111,27,27,27,87,27,]),'struct_declarator_list':([192,],[320,]),'empty':([0,1,4,21,27,35,40,52,53,55,63,75,87,89,91,117,118,128,129,177,181,192,204,206,211,218,220,227,278,282,298,307,342,419,421,422,427,429,437,440,459,460,472,488,499,502,513,515,533,535,537,539,550,553,566,569,574,577,],[57,64,83,88,64,106,115,64,64,64,64,88,64,83,115,106,208,106,208,277,306,321,337,106,277,337,106,377,415,106,433,433,415,337,337,415,433,433,433,433,106,208,522,522,433,433,337,106,433,433,433,433,522,433,433,433,433,433,]),'parameter_declaration':([118,129,278,342,350,422,460,],[210,210,210,210,463,210,210,]),'primary_expression':([85,116,131,146,149,171,174,175,181,201,204,218,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,290,297,298,307,319,329,338,339,353,354,364,373,375,412,413,419,421,427,429,430,434,437,440,441,447,477,481,484,499,502,513,521,533,535,537,538,539,542,543,549,553,566,569,574,577,],[161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,]),'declaration':([0,21,59,75,93,181,298,427,],[38,90,38,90,182,302,302,499,]),'declaration_specifiers_no_type':([0,1,21,27,52,53,55,59,63,75,87,93,118,129,181,278,298,342,350,422,427,460,],[40,67,91,67,67,67,67,40,67,91,67,91,214,214,91,214,91,214,214,214,91,214,]),'jump_statement':([181,298,307,429,437,440,502,535,537,539,569,574,577,],[303,303,303,303,303,303,303,303,303,303,303,303,303,]),'enumerator_list':([102,193,194,],[196,325,326,]),'block_item':([181,298,],[305,432,]),'constant_expression':([85,116,297,319,329,373,447,],[159,203,431,444,451,471,509,]),'identifier_list_opt':([118,129,460,],[207,221,516,]),'constant':([85,116,131,146,149,171,174,175,181,201,204,218,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,290,297,298,307,319,329,338,339,353,354,364,373,375,412,413,419,421,427,429,430,434,437,440,441,447,477,481,484,499,502,513,521,533,535,537,538,539,542,543,549,553,566,569,574,577,],[156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,]),'type_specifier_no_typeid':([0,4,21,40,59,75,85,89,91,93,95,99,118,129,172,174,177,181,184,185,186,192,211,214,229,231,233,239,267,278,298,313,315,342,350,422,427,460,],[12,71,12,12,12,12,12,71,12,12,12,12,12,12,12,12,275,12,12,12,12,275,71,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,]),'struct_declaration':([99,184,185,186,313,315,],[190,190,190,318,318,318,]),'direct_typeid_noparen_declarator':([211,344,],[345,458,]),'id_declarator':([0,4,37,40,59,69,89,91,126,192,202,211,342,445,],[21,75,107,110,21,107,179,110,179,179,179,346,107,179,]),'selection_statement':([181,298,307,429,437,440,502,535,537,539,569,574,577,],[308,308,308,308,308,308,308,308,308,308,308,308,308,]),'postfix_expression':([85,116,131,146,149,171,174,175,181,201,204,218,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,290,297,298,307,319,329,338,339,353,354,364,373,375,412,413,419,421,427,429,430,434,437,440,441,447,477,481,484,499,502,513,521,533,535,537,538,539,542,543,549,553,566,569,574,577,],[168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,]),'initializer_list':([227,488,],[374,528,]),'unary_operator':([85,116,131,146,149,171,174,175,181,201,204,218,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,290,297,298,307,319,329,338,339,353,354,364,373,375,412,413,419,421,427,429,430,434,437,440,441,447,477,481,484,499,502,513,521,533,535,537,538,539,542,543,549,553,566,569,574,577,],[171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,]),'struct_or_union':([0,21,40,59,75,85,91,93,95,99,118,129,172,174,181,184,185,186,214,229,231,233,239,267,278,298,313,315,342,350,422,427,460,],[31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,]),'block_item_list_opt':([181,],[309,]),'assignment_expression':([131,174,181,201,204,218,229,231,233,258,265,266,290,298,307,338,339,353,354,364,375,412,419,421,427,429,430,434,437,440,441,484,499,502,513,521,533,535,537,538,539,542,543,549,553,566,569,574,577,],[228,272,272,228,335,335,272,272,272,272,272,408,272,272,272,455,456,466,467,468,228,486,335,335,272,272,272,272,272,272,272,525,272,272,335,228,272,272,272,272,272,561,562,272,272,272,272,272,272,]),'designation_opt':([227,472,488,550,],[375,521,375,521,]),'parameter_type_list':([118,129,278,342,422,460,],[209,222,416,416,416,517,]),'type_qualifier_list':([35,85,95,99,117,128,174,184,185,186,206,220,229,231,233,239,267,282,313,315,459,515,],[103,172,172,172,205,219,172,172,172,172,103,103,172,172,172,172,172,103,172,172,514,103,]),'designator':([227,376,472,488,550,],[371,474,371,371,371,]),'id_init_declarator_list_opt':([40,91,],[114,114,]),'declaration_specifiers':([0,21,59,75,93,118,129,181,278,298,342,350,422,427,460,],[4,89,4,89,89,211,211,89,211,89,211,211,211,89,211,]),'identifier_list':([118,129,460,],[212,212,212,]),'declaration_list_opt':([21,75,],[92,130,]),'function_definition':([0,59,],[45,45,]),'binary_expression':([85,116,131,174,181,201,204,218,229,231,233,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,265,266,290,297,298,307,319,329,338,339,353,354,364,373,375,412,419,421,427,429,430,434,437,440,441,447,481,484,499,502,513,521,533,535,537,538,539,542,543,549,553,566,569,574,577,],[162,162,162,162,162,162,162,162,162,162,162,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,162,400,401,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,]),'enum_specifier':([0,21,40,59,75,85,91,93,95,99,118,129,172,174,181,184,185,186,214,229,231,233,239,267,278,298,313,315,342,350,422,427,460,],[49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,]),'decl_body':([0,21,59,75,93,181,298,427,],[51,51,51,51,51,51,51,51,]),'function_specifier':([0,1,4,21,27,52,53,55,59,63,75,87,89,93,118,129,181,211,278,298,342,350,422,427,460,],[55,55,82,55,55,55,55,55,55,55,55,55,82,55,55,55,55,82,55,55,55,55,55,55,55,]),'specifier_qualifier_list':([85,95,99,174,184,185,186,229,231,233,239,267,313,315,],[177,177,192,177,192,192,192,177,177,177,177,177,192,192,]),'conditional_expression':([85,116,131,174,181,201,204,218,229,231,233,258,265,266,290,297,298,307,319,329,338,339,353,354,364,373,375,412,419,421,427,429,430,434,437,440,441,447,481,484,499,502,513,521,533,535,537,538,539,542,543,549,553,566,569,574,577,],[178,178,225,225,225,225,225,225,225,225,225,225,225,225,225,178,225,225,178,178,225,225,225,225,225,178,225,225,225,225,225,225,225,225,225,225,225,178,524,225,225,225,225,225,225,225,225,225,225,225,225,225,225,225,225,225,225,]),}
+
+_lr_goto = {}
+for _k, _v in _lr_goto_items.items():
+   for _x, _y in zip(_v[0], _v[1]):
+       if not _x in _lr_goto: _lr_goto[_x] = {}
+       _lr_goto[_x][_k] = _y
+del _lr_goto_items
+_lr_productions = [
+  ("S' -> translation_unit_or_empty","S'",1,None,None,None),
+  ('abstract_declarator_opt -> empty','abstract_declarator_opt',1,'p_abstract_declarator_opt','plyparser.py',43),
+  ('abstract_declarator_opt -> abstract_declarator','abstract_declarator_opt',1,'p_abstract_declarator_opt','plyparser.py',44),
+  ('assignment_expression_opt -> empty','assignment_expression_opt',1,'p_assignment_expression_opt','plyparser.py',43),
+  ('assignment_expression_opt -> assignment_expression','assignment_expression_opt',1,'p_assignment_expression_opt','plyparser.py',44),
+  ('block_item_list_opt -> empty','block_item_list_opt',1,'p_block_item_list_opt','plyparser.py',43),
+  ('block_item_list_opt -> block_item_list','block_item_list_opt',1,'p_block_item_list_opt','plyparser.py',44),
+  ('declaration_list_opt -> empty','declaration_list_opt',1,'p_declaration_list_opt','plyparser.py',43),
+  ('declaration_list_opt -> declaration_list','declaration_list_opt',1,'p_declaration_list_opt','plyparser.py',44),
+  ('declaration_specifiers_no_type_opt -> empty','declaration_specifiers_no_type_opt',1,'p_declaration_specifiers_no_type_opt','plyparser.py',43),
+  ('declaration_specifiers_no_type_opt -> declaration_specifiers_no_type','declaration_specifiers_no_type_opt',1,'p_declaration_specifiers_no_type_opt','plyparser.py',44),
+  ('designation_opt -> empty','designation_opt',1,'p_designation_opt','plyparser.py',43),
+  ('designation_opt -> designation','designation_opt',1,'p_designation_opt','plyparser.py',44),
+  ('expression_opt -> empty','expression_opt',1,'p_expression_opt','plyparser.py',43),
+  ('expression_opt -> expression','expression_opt',1,'p_expression_opt','plyparser.py',44),
+  ('id_init_declarator_list_opt -> empty','id_init_declarator_list_opt',1,'p_id_init_declarator_list_opt','plyparser.py',43),
+  ('id_init_declarator_list_opt -> id_init_declarator_list','id_init_declarator_list_opt',1,'p_id_init_declarator_list_opt','plyparser.py',44),
+  ('identifier_list_opt -> empty','identifier_list_opt',1,'p_identifier_list_opt','plyparser.py',43),
+  ('identifier_list_opt -> identifier_list','identifier_list_opt',1,'p_identifier_list_opt','plyparser.py',44),
+  ('init_declarator_list_opt -> empty','init_declarator_list_opt',1,'p_init_declarator_list_opt','plyparser.py',43),
+  ('init_declarator_list_opt -> init_declarator_list','init_declarator_list_opt',1,'p_init_declarator_list_opt','plyparser.py',44),
+  ('initializer_list_opt -> empty','initializer_list_opt',1,'p_initializer_list_opt','plyparser.py',43),
+  ('initializer_list_opt -> initializer_list','initializer_list_opt',1,'p_initializer_list_opt','plyparser.py',44),
+  ('parameter_type_list_opt -> empty','parameter_type_list_opt',1,'p_parameter_type_list_opt','plyparser.py',43),
+  ('parameter_type_list_opt -> parameter_type_list','parameter_type_list_opt',1,'p_parameter_type_list_opt','plyparser.py',44),
+  ('struct_declarator_list_opt -> empty','struct_declarator_list_opt',1,'p_struct_declarator_list_opt','plyparser.py',43),
+  ('struct_declarator_list_opt -> struct_declarator_list','struct_declarator_list_opt',1,'p_struct_declarator_list_opt','plyparser.py',44),
+  ('type_qualifier_list_opt -> empty','type_qualifier_list_opt',1,'p_type_qualifier_list_opt','plyparser.py',43),
+  ('type_qualifier_list_opt -> type_qualifier_list','type_qualifier_list_opt',1,'p_type_qualifier_list_opt','plyparser.py',44),
+  ('direct_id_declarator -> ID','direct_id_declarator',1,'p_direct_id_declarator_1','plyparser.py',126),
+  ('direct_id_declarator -> LPAREN id_declarator RPAREN','direct_id_declarator',3,'p_direct_id_declarator_2','plyparser.py',126),
+  ('direct_id_declarator -> direct_id_declarator LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET','direct_id_declarator',5,'p_direct_id_declarator_3','plyparser.py',126),
+  ('direct_id_declarator -> direct_id_declarator LBRACKET STATIC type_qualifier_list_opt assignment_expression RBRACKET','direct_id_declarator',6,'p_direct_id_declarator_4','plyparser.py',126),
+  ('direct_id_declarator -> direct_id_declarator LBRACKET type_qualifier_list STATIC assignment_expression RBRACKET','direct_id_declarator',6,'p_direct_id_declarator_4','plyparser.py',127),
+  ('direct_id_declarator -> direct_id_declarator LBRACKET type_qualifier_list_opt TIMES RBRACKET','direct_id_declarator',5,'p_direct_id_declarator_5','plyparser.py',126),
+  ('direct_id_declarator -> direct_id_declarator LPAREN parameter_type_list RPAREN','direct_id_declarator',4,'p_direct_id_declarator_6','plyparser.py',126),
+  ('direct_id_declarator -> direct_id_declarator LPAREN identifier_list_opt RPAREN','direct_id_declarator',4,'p_direct_id_declarator_6','plyparser.py',127),
+  ('direct_typeid_declarator -> TYPEID','direct_typeid_declarator',1,'p_direct_typeid_declarator_1','plyparser.py',126),
+  ('direct_typeid_declarator -> LPAREN typeid_declarator RPAREN','direct_typeid_declarator',3,'p_direct_typeid_declarator_2','plyparser.py',126),
+  ('direct_typeid_declarator -> direct_typeid_declarator LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET','direct_typeid_declarator',5,'p_direct_typeid_declarator_3','plyparser.py',126),
+  ('direct_typeid_declarator -> direct_typeid_declarator LBRACKET STATIC type_qualifier_list_opt assignment_expression RBRACKET','direct_typeid_declarator',6,'p_direct_typeid_declarator_4','plyparser.py',126),
+  ('direct_typeid_declarator -> direct_typeid_declarator LBRACKET type_qualifier_list STATIC assignment_expression RBRACKET','direct_typeid_declarator',6,'p_direct_typeid_declarator_4','plyparser.py',127),
+  ('direct_typeid_declarator -> direct_typeid_declarator LBRACKET type_qualifier_list_opt TIMES RBRACKET','direct_typeid_declarator',5,'p_direct_typeid_declarator_5','plyparser.py',126),
+  ('direct_typeid_declarator -> direct_typeid_declarator LPAREN parameter_type_list RPAREN','direct_typeid_declarator',4,'p_direct_typeid_declarator_6','plyparser.py',126),
+  ('direct_typeid_declarator -> direct_typeid_declarator LPAREN identifier_list_opt RPAREN','direct_typeid_declarator',4,'p_direct_typeid_declarator_6','plyparser.py',127),
+  ('direct_typeid_noparen_declarator -> TYPEID','direct_typeid_noparen_declarator',1,'p_direct_typeid_noparen_declarator_1','plyparser.py',126),
+  ('direct_typeid_noparen_declarator -> direct_typeid_noparen_declarator LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET','direct_typeid_noparen_declarator',5,'p_direct_typeid_noparen_declarator_3','plyparser.py',126),
+  ('direct_typeid_noparen_declarator -> direct_typeid_noparen_declarator LBRACKET STATIC type_qualifier_list_opt assignment_expression RBRACKET','direct_typeid_noparen_declarator',6,'p_direct_typeid_noparen_declarator_4','plyparser.py',126),
+  ('direct_typeid_noparen_declarator -> direct_typeid_noparen_declarator LBRACKET type_qualifier_list STATIC assignment_expression RBRACKET','direct_typeid_noparen_declarator',6,'p_direct_typeid_noparen_declarator_4','plyparser.py',127),
+  ('direct_typeid_noparen_declarator -> direct_typeid_noparen_declarator LBRACKET type_qualifier_list_opt TIMES RBRACKET','direct_typeid_noparen_declarator',5,'p_direct_typeid_noparen_declarator_5','plyparser.py',126),
+  ('direct_typeid_noparen_declarator -> direct_typeid_noparen_declarator LPAREN parameter_type_list RPAREN','direct_typeid_noparen_declarator',4,'p_direct_typeid_noparen_declarator_6','plyparser.py',126),
+  ('direct_typeid_noparen_declarator -> direct_typeid_noparen_declarator LPAREN identifier_list_opt RPAREN','direct_typeid_noparen_declarator',4,'p_direct_typeid_noparen_declarator_6','plyparser.py',127),
+  ('id_declarator -> direct_id_declarator','id_declarator',1,'p_id_declarator_1','plyparser.py',126),
+  ('id_declarator -> pointer direct_id_declarator','id_declarator',2,'p_id_declarator_2','plyparser.py',126),
+  ('typeid_declarator -> direct_typeid_declarator','typeid_declarator',1,'p_typeid_declarator_1','plyparser.py',126),
+  ('typeid_declarator -> pointer direct_typeid_declarator','typeid_declarator',2,'p_typeid_declarator_2','plyparser.py',126),
+  ('typeid_noparen_declarator -> direct_typeid_noparen_declarator','typeid_noparen_declarator',1,'p_typeid_noparen_declarator_1','plyparser.py',126),
+  ('typeid_noparen_declarator -> pointer direct_typeid_noparen_declarator','typeid_noparen_declarator',2,'p_typeid_noparen_declarator_2','plyparser.py',126),
+  ('translation_unit_or_empty -> translation_unit','translation_unit_or_empty',1,'p_translation_unit_or_empty','c_parser.py',509),
+  ('translation_unit_or_empty -> empty','translation_unit_or_empty',1,'p_translation_unit_or_empty','c_parser.py',510),
+  ('translation_unit -> external_declaration','translation_unit',1,'p_translation_unit_1','c_parser.py',518),
+  ('translation_unit -> translation_unit external_declaration','translation_unit',2,'p_translation_unit_2','c_parser.py',524),
+  ('external_declaration -> function_definition','external_declaration',1,'p_external_declaration_1','c_parser.py',534),
+  ('external_declaration -> declaration','external_declaration',1,'p_external_declaration_2','c_parser.py',539),
+  ('external_declaration -> pp_directive','external_declaration',1,'p_external_declaration_3','c_parser.py',544),
+  ('external_declaration -> pppragma_directive','external_declaration',1,'p_external_declaration_3','c_parser.py',545),
+  ('external_declaration -> SEMI','external_declaration',1,'p_external_declaration_4','c_parser.py',550),
+  ('external_declaration -> static_assert','external_declaration',1,'p_external_declaration_5','c_parser.py',555),
+  ('static_assert -> _STATIC_ASSERT LPAREN constant_expression COMMA unified_string_literal RPAREN','static_assert',6,'p_static_assert_declaration','c_parser.py',560),
+  ('static_assert -> _STATIC_ASSERT LPAREN constant_expression RPAREN','static_assert',4,'p_static_assert_declaration','c_parser.py',561),
+  ('pp_directive -> PPHASH','pp_directive',1,'p_pp_directive','c_parser.py',569),
+  ('pppragma_directive -> PPPRAGMA','pppragma_directive',1,'p_pppragma_directive','c_parser.py',575),
+  ('pppragma_directive -> PPPRAGMA PPPRAGMASTR','pppragma_directive',2,'p_pppragma_directive','c_parser.py',576),
+  ('function_definition -> id_declarator declaration_list_opt compound_statement','function_definition',3,'p_function_definition_1','c_parser.py',586),
+  ('function_definition -> declaration_specifiers id_declarator declaration_list_opt compound_statement','function_definition',4,'p_function_definition_2','c_parser.py',604),
+  ('statement -> labeled_statement','statement',1,'p_statement','c_parser.py',619),
+  ('statement -> expression_statement','statement',1,'p_statement','c_parser.py',620),
+  ('statement -> compound_statement','statement',1,'p_statement','c_parser.py',621),
+  ('statement -> selection_statement','statement',1,'p_statement','c_parser.py',622),
+  ('statement -> iteration_statement','statement',1,'p_statement','c_parser.py',623),
+  ('statement -> jump_statement','statement',1,'p_statement','c_parser.py',624),
+  ('statement -> pppragma_directive','statement',1,'p_statement','c_parser.py',625),
+  ('statement -> static_assert','statement',1,'p_statement','c_parser.py',626),
+  ('pragmacomp_or_statement -> pppragma_directive statement','pragmacomp_or_statement',2,'p_pragmacomp_or_statement','c_parser.py',674),
+  ('pragmacomp_or_statement -> statement','pragmacomp_or_statement',1,'p_pragmacomp_or_statement','c_parser.py',675),
+  ('decl_body -> declaration_specifiers init_declarator_list_opt','decl_body',2,'p_decl_body','c_parser.py',694),
+  ('decl_body -> declaration_specifiers_no_type id_init_declarator_list_opt','decl_body',2,'p_decl_body','c_parser.py',695),
+  ('declaration -> decl_body SEMI','declaration',2,'p_declaration','c_parser.py',755),
+  ('declaration_list -> declaration','declaration_list',1,'p_declaration_list','c_parser.py',764),
+  ('declaration_list -> declaration_list declaration','declaration_list',2,'p_declaration_list','c_parser.py',765),
+  ('declaration_specifiers_no_type -> type_qualifier declaration_specifiers_no_type_opt','declaration_specifiers_no_type',2,'p_declaration_specifiers_no_type_1','c_parser.py',775),
+  ('declaration_specifiers_no_type -> storage_class_specifier declaration_specifiers_no_type_opt','declaration_specifiers_no_type',2,'p_declaration_specifiers_no_type_2','c_parser.py',780),
+  ('declaration_specifiers_no_type -> function_specifier declaration_specifiers_no_type_opt','declaration_specifiers_no_type',2,'p_declaration_specifiers_no_type_3','c_parser.py',785),
+  ('declaration_specifiers_no_type -> atomic_specifier declaration_specifiers_no_type_opt','declaration_specifiers_no_type',2,'p_declaration_specifiers_no_type_4','c_parser.py',792),
+  ('declaration_specifiers_no_type -> alignment_specifier declaration_specifiers_no_type_opt','declaration_specifiers_no_type',2,'p_declaration_specifiers_no_type_5','c_parser.py',797),
+  ('declaration_specifiers -> declaration_specifiers type_qualifier','declaration_specifiers',2,'p_declaration_specifiers_1','c_parser.py',802),
+  ('declaration_specifiers -> declaration_specifiers storage_class_specifier','declaration_specifiers',2,'p_declaration_specifiers_2','c_parser.py',807),
+  ('declaration_specifiers -> declaration_specifiers function_specifier','declaration_specifiers',2,'p_declaration_specifiers_3','c_parser.py',812),
+  ('declaration_specifiers -> declaration_specifiers type_specifier_no_typeid','declaration_specifiers',2,'p_declaration_specifiers_4','c_parser.py',817),
+  ('declaration_specifiers -> type_specifier','declaration_specifiers',1,'p_declaration_specifiers_5','c_parser.py',822),
+  ('declaration_specifiers -> declaration_specifiers_no_type type_specifier','declaration_specifiers',2,'p_declaration_specifiers_6','c_parser.py',827),
+  ('declaration_specifiers -> declaration_specifiers alignment_specifier','declaration_specifiers',2,'p_declaration_specifiers_7','c_parser.py',832),
+  ('storage_class_specifier -> AUTO','storage_class_specifier',1,'p_storage_class_specifier','c_parser.py',837),
+  ('storage_class_specifier -> REGISTER','storage_class_specifier',1,'p_storage_class_specifier','c_parser.py',838),
+  ('storage_class_specifier -> STATIC','storage_class_specifier',1,'p_storage_class_specifier','c_parser.py',839),
+  ('storage_class_specifier -> EXTERN','storage_class_specifier',1,'p_storage_class_specifier','c_parser.py',840),
+  ('storage_class_specifier -> TYPEDEF','storage_class_specifier',1,'p_storage_class_specifier','c_parser.py',841),
+  ('storage_class_specifier -> _THREAD_LOCAL','storage_class_specifier',1,'p_storage_class_specifier','c_parser.py',842),
+  ('function_specifier -> INLINE','function_specifier',1,'p_function_specifier','c_parser.py',847),
+  ('function_specifier -> _NORETURN','function_specifier',1,'p_function_specifier','c_parser.py',848),
+  ('type_specifier_no_typeid -> VOID','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',853),
+  ('type_specifier_no_typeid -> _BOOL','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',854),
+  ('type_specifier_no_typeid -> CHAR','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',855),
+  ('type_specifier_no_typeid -> SHORT','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',856),
+  ('type_specifier_no_typeid -> INT','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',857),
+  ('type_specifier_no_typeid -> LONG','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',858),
+  ('type_specifier_no_typeid -> FLOAT','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',859),
+  ('type_specifier_no_typeid -> DOUBLE','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',860),
+  ('type_specifier_no_typeid -> _COMPLEX','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',861),
+  ('type_specifier_no_typeid -> SIGNED','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',862),
+  ('type_specifier_no_typeid -> UNSIGNED','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',863),
+  ('type_specifier_no_typeid -> __INT128','type_specifier_no_typeid',1,'p_type_specifier_no_typeid','c_parser.py',864),
+  ('type_specifier -> typedef_name','type_specifier',1,'p_type_specifier','c_parser.py',869),
+  ('type_specifier -> enum_specifier','type_specifier',1,'p_type_specifier','c_parser.py',870),
+  ('type_specifier -> struct_or_union_specifier','type_specifier',1,'p_type_specifier','c_parser.py',871),
+  ('type_specifier -> type_specifier_no_typeid','type_specifier',1,'p_type_specifier','c_parser.py',872),
+  ('type_specifier -> atomic_specifier','type_specifier',1,'p_type_specifier','c_parser.py',873),
+  ('atomic_specifier -> _ATOMIC LPAREN type_name RPAREN','atomic_specifier',4,'p_atomic_specifier','c_parser.py',879),
+  ('type_qualifier -> CONST','type_qualifier',1,'p_type_qualifier','c_parser.py',886),
+  ('type_qualifier -> RESTRICT','type_qualifier',1,'p_type_qualifier','c_parser.py',887),
+  ('type_qualifier -> VOLATILE','type_qualifier',1,'p_type_qualifier','c_parser.py',888),
+  ('type_qualifier -> _ATOMIC','type_qualifier',1,'p_type_qualifier','c_parser.py',889),
+  ('init_declarator_list -> init_declarator','init_declarator_list',1,'p_init_declarator_list','c_parser.py',894),
+  ('init_declarator_list -> init_declarator_list COMMA init_declarator','init_declarator_list',3,'p_init_declarator_list','c_parser.py',895),
+  ('init_declarator -> declarator','init_declarator',1,'p_init_declarator','c_parser.py',903),
+  ('init_declarator -> declarator EQUALS initializer','init_declarator',3,'p_init_declarator','c_parser.py',904),
+  ('id_init_declarator_list -> id_init_declarator','id_init_declarator_list',1,'p_id_init_declarator_list','c_parser.py',909),
+  ('id_init_declarator_list -> id_init_declarator_list COMMA init_declarator','id_init_declarator_list',3,'p_id_init_declarator_list','c_parser.py',910),
+  ('id_init_declarator -> id_declarator','id_init_declarator',1,'p_id_init_declarator','c_parser.py',915),
+  ('id_init_declarator -> id_declarator EQUALS initializer','id_init_declarator',3,'p_id_init_declarator','c_parser.py',916),
+  ('specifier_qualifier_list -> specifier_qualifier_list type_specifier_no_typeid','specifier_qualifier_list',2,'p_specifier_qualifier_list_1','c_parser.py',923),
+  ('specifier_qualifier_list -> specifier_qualifier_list type_qualifier','specifier_qualifier_list',2,'p_specifier_qualifier_list_2','c_parser.py',928),
+  ('specifier_qualifier_list -> type_specifier','specifier_qualifier_list',1,'p_specifier_qualifier_list_3','c_parser.py',933),
+  ('specifier_qualifier_list -> type_qualifier_list type_specifier','specifier_qualifier_list',2,'p_specifier_qualifier_list_4','c_parser.py',938),
+  ('specifier_qualifier_list -> alignment_specifier','specifier_qualifier_list',1,'p_specifier_qualifier_list_5','c_parser.py',943),
+  ('specifier_qualifier_list -> specifier_qualifier_list alignment_specifier','specifier_qualifier_list',2,'p_specifier_qualifier_list_6','c_parser.py',948),
+  ('struct_or_union_specifier -> struct_or_union ID','struct_or_union_specifier',2,'p_struct_or_union_specifier_1','c_parser.py',956),
+  ('struct_or_union_specifier -> struct_or_union TYPEID','struct_or_union_specifier',2,'p_struct_or_union_specifier_1','c_parser.py',957),
+  ('struct_or_union_specifier -> struct_or_union brace_open struct_declaration_list brace_close','struct_or_union_specifier',4,'p_struct_or_union_specifier_2','c_parser.py',967),
+  ('struct_or_union_specifier -> struct_or_union brace_open brace_close','struct_or_union_specifier',3,'p_struct_or_union_specifier_2','c_parser.py',968),
+  ('struct_or_union_specifier -> struct_or_union ID brace_open struct_declaration_list brace_close','struct_or_union_specifier',5,'p_struct_or_union_specifier_3','c_parser.py',985),
+  ('struct_or_union_specifier -> struct_or_union ID brace_open brace_close','struct_or_union_specifier',4,'p_struct_or_union_specifier_3','c_parser.py',986),
+  ('struct_or_union_specifier -> struct_or_union TYPEID brace_open struct_declaration_list brace_close','struct_or_union_specifier',5,'p_struct_or_union_specifier_3','c_parser.py',987),
+  ('struct_or_union_specifier -> struct_or_union TYPEID brace_open brace_close','struct_or_union_specifier',4,'p_struct_or_union_specifier_3','c_parser.py',988),
+  ('struct_or_union -> STRUCT','struct_or_union',1,'p_struct_or_union','c_parser.py',1004),
+  ('struct_or_union -> UNION','struct_or_union',1,'p_struct_or_union','c_parser.py',1005),
+  ('struct_declaration_list -> struct_declaration','struct_declaration_list',1,'p_struct_declaration_list','c_parser.py',1012),
+  ('struct_declaration_list -> struct_declaration_list struct_declaration','struct_declaration_list',2,'p_struct_declaration_list','c_parser.py',1013),
+  ('struct_declaration -> specifier_qualifier_list struct_declarator_list_opt SEMI','struct_declaration',3,'p_struct_declaration_1','c_parser.py',1021),
+  ('struct_declaration -> SEMI','struct_declaration',1,'p_struct_declaration_2','c_parser.py',1059),
+  ('struct_declaration -> pppragma_directive','struct_declaration',1,'p_struct_declaration_3','c_parser.py',1064),
+  ('struct_declarator_list -> struct_declarator','struct_declarator_list',1,'p_struct_declarator_list','c_parser.py',1069),
+  ('struct_declarator_list -> struct_declarator_list COMMA struct_declarator','struct_declarator_list',3,'p_struct_declarator_list','c_parser.py',1070),
+  ('struct_declarator -> declarator','struct_declarator',1,'p_struct_declarator_1','c_parser.py',1078),
+  ('struct_declarator -> declarator COLON constant_expression','struct_declarator',3,'p_struct_declarator_2','c_parser.py',1083),
+  ('struct_declarator -> COLON constant_expression','struct_declarator',2,'p_struct_declarator_2','c_parser.py',1084),
+  ('enum_specifier -> ENUM ID','enum_specifier',2,'p_enum_specifier_1','c_parser.py',1092),
+  ('enum_specifier -> ENUM TYPEID','enum_specifier',2,'p_enum_specifier_1','c_parser.py',1093),
+  ('enum_specifier -> ENUM brace_open enumerator_list brace_close','enum_specifier',4,'p_enum_specifier_2','c_parser.py',1098),
+  ('enum_specifier -> ENUM ID brace_open enumerator_list brace_close','enum_specifier',5,'p_enum_specifier_3','c_parser.py',1103),
+  ('enum_specifier -> ENUM TYPEID brace_open enumerator_list brace_close','enum_specifier',5,'p_enum_specifier_3','c_parser.py',1104),
+  ('enumerator_list -> enumerator','enumerator_list',1,'p_enumerator_list','c_parser.py',1109),
+  ('enumerator_list -> enumerator_list COMMA','enumerator_list',2,'p_enumerator_list','c_parser.py',1110),
+  ('enumerator_list -> enumerator_list COMMA enumerator','enumerator_list',3,'p_enumerator_list','c_parser.py',1111),
+  ('alignment_specifier -> _ALIGNAS LPAREN type_name RPAREN','alignment_specifier',4,'p_alignment_specifier','c_parser.py',1122),
+  ('alignment_specifier -> _ALIGNAS LPAREN constant_expression RPAREN','alignment_specifier',4,'p_alignment_specifier','c_parser.py',1123),
+  ('enumerator -> ID','enumerator',1,'p_enumerator','c_parser.py',1128),
+  ('enumerator -> ID EQUALS constant_expression','enumerator',3,'p_enumerator','c_parser.py',1129),
+  ('declarator -> id_declarator','declarator',1,'p_declarator','c_parser.py',1144),
+  ('declarator -> typeid_declarator','declarator',1,'p_declarator','c_parser.py',1145),
+  ('pointer -> TIMES type_qualifier_list_opt','pointer',2,'p_pointer','c_parser.py',1257),
+  ('pointer -> TIMES type_qualifier_list_opt pointer','pointer',3,'p_pointer','c_parser.py',1258),
+  ('type_qualifier_list -> type_qualifier','type_qualifier_list',1,'p_type_qualifier_list','c_parser.py',1287),
+  ('type_qualifier_list -> type_qualifier_list type_qualifier','type_qualifier_list',2,'p_type_qualifier_list','c_parser.py',1288),
+  ('parameter_type_list -> parameter_list','parameter_type_list',1,'p_parameter_type_list','c_parser.py',1293),
+  ('parameter_type_list -> parameter_list COMMA ELLIPSIS','parameter_type_list',3,'p_parameter_type_list','c_parser.py',1294),
+  ('parameter_list -> parameter_declaration','parameter_list',1,'p_parameter_list','c_parser.py',1302),
+  ('parameter_list -> parameter_list COMMA parameter_declaration','parameter_list',3,'p_parameter_list','c_parser.py',1303),
+  ('parameter_declaration -> declaration_specifiers id_declarator','parameter_declaration',2,'p_parameter_declaration_1','c_parser.py',1322),
+  ('parameter_declaration -> declaration_specifiers typeid_noparen_declarator','parameter_declaration',2,'p_parameter_declaration_1','c_parser.py',1323),
+  ('parameter_declaration -> declaration_specifiers abstract_declarator_opt','parameter_declaration',2,'p_parameter_declaration_2','c_parser.py',1334),
+  ('identifier_list -> identifier','identifier_list',1,'p_identifier_list','c_parser.py',1366),
+  ('identifier_list -> identifier_list COMMA identifier','identifier_list',3,'p_identifier_list','c_parser.py',1367),
+  ('initializer -> assignment_expression','initializer',1,'p_initializer_1','c_parser.py',1376),
+  ('initializer -> brace_open initializer_list_opt brace_close','initializer',3,'p_initializer_2','c_parser.py',1381),
+  ('initializer -> brace_open initializer_list COMMA brace_close','initializer',4,'p_initializer_2','c_parser.py',1382),
+  ('initializer_list -> designation_opt initializer','initializer_list',2,'p_initializer_list','c_parser.py',1390),
+  ('initializer_list -> initializer_list COMMA designation_opt initializer','initializer_list',4,'p_initializer_list','c_parser.py',1391),
+  ('designation -> designator_list EQUALS','designation',2,'p_designation','c_parser.py',1402),
+  ('designator_list -> designator','designator_list',1,'p_designator_list','c_parser.py',1410),
+  ('designator_list -> designator_list designator','designator_list',2,'p_designator_list','c_parser.py',1411),
+  ('designator -> LBRACKET constant_expression RBRACKET','designator',3,'p_designator','c_parser.py',1416),
+  ('designator -> PERIOD identifier','designator',2,'p_designator','c_parser.py',1417),
+  ('type_name -> specifier_qualifier_list abstract_declarator_opt','type_name',2,'p_type_name','c_parser.py',1422),
+  ('abstract_declarator -> pointer','abstract_declarator',1,'p_abstract_declarator_1','c_parser.py',1434),
+  ('abstract_declarator -> pointer direct_abstract_declarator','abstract_declarator',2,'p_abstract_declarator_2','c_parser.py',1442),
+  ('abstract_declarator -> direct_abstract_declarator','abstract_declarator',1,'p_abstract_declarator_3','c_parser.py',1447),
+  ('direct_abstract_declarator -> LPAREN abstract_declarator RPAREN','direct_abstract_declarator',3,'p_direct_abstract_declarator_1','c_parser.py',1457),
+  ('direct_abstract_declarator -> direct_abstract_declarator LBRACKET assignment_expression_opt RBRACKET','direct_abstract_declarator',4,'p_direct_abstract_declarator_2','c_parser.py',1461),
+  ('direct_abstract_declarator -> LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET','direct_abstract_declarator',4,'p_direct_abstract_declarator_3','c_parser.py',1472),
+  ('direct_abstract_declarator -> direct_abstract_declarator LBRACKET TIMES RBRACKET','direct_abstract_declarator',4,'p_direct_abstract_declarator_4','c_parser.py',1482),
+  ('direct_abstract_declarator -> LBRACKET TIMES RBRACKET','direct_abstract_declarator',3,'p_direct_abstract_declarator_5','c_parser.py',1493),
+  ('direct_abstract_declarator -> direct_abstract_declarator LPAREN parameter_type_list_opt RPAREN','direct_abstract_declarator',4,'p_direct_abstract_declarator_6','c_parser.py',1502),
+  ('direct_abstract_declarator -> LPAREN parameter_type_list_opt RPAREN','direct_abstract_declarator',3,'p_direct_abstract_declarator_7','c_parser.py',1512),
+  ('block_item -> declaration','block_item',1,'p_block_item','c_parser.py',1523),
+  ('block_item -> statement','block_item',1,'p_block_item','c_parser.py',1524),
+  ('block_item_list -> block_item','block_item_list',1,'p_block_item_list','c_parser.py',1531),
+  ('block_item_list -> block_item_list block_item','block_item_list',2,'p_block_item_list','c_parser.py',1532),
+  ('compound_statement -> brace_open block_item_list_opt brace_close','compound_statement',3,'p_compound_statement_1','c_parser.py',1538),
+  ('labeled_statement -> ID COLON pragmacomp_or_statement','labeled_statement',3,'p_labeled_statement_1','c_parser.py',1544),
+  ('labeled_statement -> CASE constant_expression COLON pragmacomp_or_statement','labeled_statement',4,'p_labeled_statement_2','c_parser.py',1548),
+  ('labeled_statement -> DEFAULT COLON pragmacomp_or_statement','labeled_statement',3,'p_labeled_statement_3','c_parser.py',1552),
+  ('selection_statement -> IF LPAREN expression RPAREN pragmacomp_or_statement','selection_statement',5,'p_selection_statement_1','c_parser.py',1556),
+  ('selection_statement -> IF LPAREN expression RPAREN statement ELSE pragmacomp_or_statement','selection_statement',7,'p_selection_statement_2','c_parser.py',1560),
+  ('selection_statement -> SWITCH LPAREN expression RPAREN pragmacomp_or_statement','selection_statement',5,'p_selection_statement_3','c_parser.py',1564),
+  ('iteration_statement -> WHILE LPAREN expression RPAREN pragmacomp_or_statement','iteration_statement',5,'p_iteration_statement_1','c_parser.py',1569),
+  ('iteration_statement -> DO pragmacomp_or_statement WHILE LPAREN expression RPAREN SEMI','iteration_statement',7,'p_iteration_statement_2','c_parser.py',1573),
+  ('iteration_statement -> FOR LPAREN expression_opt SEMI expression_opt SEMI expression_opt RPAREN pragmacomp_or_statement','iteration_statement',9,'p_iteration_statement_3','c_parser.py',1577),
+  ('iteration_statement -> FOR LPAREN declaration expression_opt SEMI expression_opt RPAREN pragmacomp_or_statement','iteration_statement',8,'p_iteration_statement_4','c_parser.py',1581),
+  ('jump_statement -> GOTO ID SEMI','jump_statement',3,'p_jump_statement_1','c_parser.py',1586),
+  ('jump_statement -> BREAK SEMI','jump_statement',2,'p_jump_statement_2','c_parser.py',1590),
+  ('jump_statement -> CONTINUE SEMI','jump_statement',2,'p_jump_statement_3','c_parser.py',1594),
+  ('jump_statement -> RETURN expression SEMI','jump_statement',3,'p_jump_statement_4','c_parser.py',1598),
+  ('jump_statement -> RETURN SEMI','jump_statement',2,'p_jump_statement_4','c_parser.py',1599),
+  ('expression_statement -> expression_opt SEMI','expression_statement',2,'p_expression_statement','c_parser.py',1604),
+  ('expression -> assignment_expression','expression',1,'p_expression','c_parser.py',1611),
+  ('expression -> expression COMMA assignment_expression','expression',3,'p_expression','c_parser.py',1612),
+  ('assignment_expression -> LPAREN compound_statement RPAREN','assignment_expression',3,'p_parenthesized_compound_expression','c_parser.py',1624),
+  ('typedef_name -> TYPEID','typedef_name',1,'p_typedef_name','c_parser.py',1628),
+  ('assignment_expression -> conditional_expression','assignment_expression',1,'p_assignment_expression','c_parser.py',1632),
+  ('assignment_expression -> unary_expression assignment_operator assignment_expression','assignment_expression',3,'p_assignment_expression','c_parser.py',1633),
+  ('assignment_operator -> EQUALS','assignment_operator',1,'p_assignment_operator','c_parser.py',1646),
+  ('assignment_operator -> XOREQUAL','assignment_operator',1,'p_assignment_operator','c_parser.py',1647),
+  ('assignment_operator -> TIMESEQUAL','assignment_operator',1,'p_assignment_operator','c_parser.py',1648),
+  ('assignment_operator -> DIVEQUAL','assignment_operator',1,'p_assignment_operator','c_parser.py',1649),
+  ('assignment_operator -> MODEQUAL','assignment_operator',1,'p_assignment_operator','c_parser.py',1650),
+  ('assignment_operator -> PLUSEQUAL','assignment_operator',1,'p_assignment_operator','c_parser.py',1651),
+  ('assignment_operator -> MINUSEQUAL','assignment_operator',1,'p_assignment_operator','c_parser.py',1652),
+  ('assignment_operator -> LSHIFTEQUAL','assignment_operator',1,'p_assignment_operator','c_parser.py',1653),
+  ('assignment_operator -> RSHIFTEQUAL','assignment_operator',1,'p_assignment_operator','c_parser.py',1654),
+  ('assignment_operator -> ANDEQUAL','assignment_operator',1,'p_assignment_operator','c_parser.py',1655),
+  ('assignment_operator -> OREQUAL','assignment_operator',1,'p_assignment_operator','c_parser.py',1656),
+  ('constant_expression -> conditional_expression','constant_expression',1,'p_constant_expression','c_parser.py',1661),
+  ('conditional_expression -> binary_expression','conditional_expression',1,'p_conditional_expression','c_parser.py',1665),
+  ('conditional_expression -> binary_expression CONDOP expression COLON conditional_expression','conditional_expression',5,'p_conditional_expression','c_parser.py',1666),
+  ('binary_expression -> cast_expression','binary_expression',1,'p_binary_expression','c_parser.py',1674),
+  ('binary_expression -> binary_expression TIMES binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1675),
+  ('binary_expression -> binary_expression DIVIDE binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1676),
+  ('binary_expression -> binary_expression MOD binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1677),
+  ('binary_expression -> binary_expression PLUS binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1678),
+  ('binary_expression -> binary_expression MINUS binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1679),
+  ('binary_expression -> binary_expression RSHIFT binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1680),
+  ('binary_expression -> binary_expression LSHIFT binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1681),
+  ('binary_expression -> binary_expression LT binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1682),
+  ('binary_expression -> binary_expression LE binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1683),
+  ('binary_expression -> binary_expression GE binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1684),
+  ('binary_expression -> binary_expression GT binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1685),
+  ('binary_expression -> binary_expression EQ binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1686),
+  ('binary_expression -> binary_expression NE binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1687),
+  ('binary_expression -> binary_expression AND binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1688),
+  ('binary_expression -> binary_expression OR binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1689),
+  ('binary_expression -> binary_expression XOR binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1690),
+  ('binary_expression -> binary_expression LAND binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1691),
+  ('binary_expression -> binary_expression LOR binary_expression','binary_expression',3,'p_binary_expression','c_parser.py',1692),
+  ('cast_expression -> unary_expression','cast_expression',1,'p_cast_expression_1','c_parser.py',1700),
+  ('cast_expression -> LPAREN type_name RPAREN cast_expression','cast_expression',4,'p_cast_expression_2','c_parser.py',1704),
+  ('unary_expression -> postfix_expression','unary_expression',1,'p_unary_expression_1','c_parser.py',1708),
+  ('unary_expression -> PLUSPLUS unary_expression','unary_expression',2,'p_unary_expression_2','c_parser.py',1712),
+  ('unary_expression -> MINUSMINUS unary_expression','unary_expression',2,'p_unary_expression_2','c_parser.py',1713),
+  ('unary_expression -> unary_operator cast_expression','unary_expression',2,'p_unary_expression_2','c_parser.py',1714),
+  ('unary_expression -> SIZEOF unary_expression','unary_expression',2,'p_unary_expression_3','c_parser.py',1719),
+  ('unary_expression -> SIZEOF LPAREN type_name RPAREN','unary_expression',4,'p_unary_expression_3','c_parser.py',1720),
+  ('unary_expression -> _ALIGNOF LPAREN type_name RPAREN','unary_expression',4,'p_unary_expression_3','c_parser.py',1721),
+  ('unary_operator -> AND','unary_operator',1,'p_unary_operator','c_parser.py',1729),
+  ('unary_operator -> TIMES','unary_operator',1,'p_unary_operator','c_parser.py',1730),
+  ('unary_operator -> PLUS','unary_operator',1,'p_unary_operator','c_parser.py',1731),
+  ('unary_operator -> MINUS','unary_operator',1,'p_unary_operator','c_parser.py',1732),
+  ('unary_operator -> NOT','unary_operator',1,'p_unary_operator','c_parser.py',1733),
+  ('unary_operator -> LNOT','unary_operator',1,'p_unary_operator','c_parser.py',1734),
+  ('postfix_expression -> primary_expression','postfix_expression',1,'p_postfix_expression_1','c_parser.py',1739),
+  ('postfix_expression -> postfix_expression LBRACKET expression RBRACKET','postfix_expression',4,'p_postfix_expression_2','c_parser.py',1743),
+  ('postfix_expression -> postfix_expression LPAREN argument_expression_list RPAREN','postfix_expression',4,'p_postfix_expression_3','c_parser.py',1747),
+  ('postfix_expression -> postfix_expression LPAREN RPAREN','postfix_expression',3,'p_postfix_expression_3','c_parser.py',1748),
+  ('postfix_expression -> postfix_expression PERIOD ID','postfix_expression',3,'p_postfix_expression_4','c_parser.py',1753),
+  ('postfix_expression -> postfix_expression PERIOD TYPEID','postfix_expression',3,'p_postfix_expression_4','c_parser.py',1754),
+  ('postfix_expression -> postfix_expression ARROW ID','postfix_expression',3,'p_postfix_expression_4','c_parser.py',1755),
+  ('postfix_expression -> postfix_expression ARROW TYPEID','postfix_expression',3,'p_postfix_expression_4','c_parser.py',1756),
+  ('postfix_expression -> postfix_expression PLUSPLUS','postfix_expression',2,'p_postfix_expression_5','c_parser.py',1762),
+  ('postfix_expression -> postfix_expression MINUSMINUS','postfix_expression',2,'p_postfix_expression_5','c_parser.py',1763),
+  ('postfix_expression -> LPAREN type_name RPAREN brace_open initializer_list brace_close','postfix_expression',6,'p_postfix_expression_6','c_parser.py',1768),
+  ('postfix_expression -> LPAREN type_name RPAREN brace_open initializer_list COMMA brace_close','postfix_expression',7,'p_postfix_expression_6','c_parser.py',1769),
+  ('primary_expression -> identifier','primary_expression',1,'p_primary_expression_1','c_parser.py',1774),
+  ('primary_expression -> constant','primary_expression',1,'p_primary_expression_2','c_parser.py',1778),
+  ('primary_expression -> unified_string_literal','primary_expression',1,'p_primary_expression_3','c_parser.py',1782),
+  ('primary_expression -> unified_wstring_literal','primary_expression',1,'p_primary_expression_3','c_parser.py',1783),
+  ('primary_expression -> LPAREN expression RPAREN','primary_expression',3,'p_primary_expression_4','c_parser.py',1788),
+  ('primary_expression -> OFFSETOF LPAREN type_name COMMA offsetof_member_designator RPAREN','primary_expression',6,'p_primary_expression_5','c_parser.py',1792),
+  ('offsetof_member_designator -> identifier','offsetof_member_designator',1,'p_offsetof_member_designator','c_parser.py',1800),
+  ('offsetof_member_designator -> offsetof_member_designator PERIOD identifier','offsetof_member_designator',3,'p_offsetof_member_designator','c_parser.py',1801),
+  ('offsetof_member_designator -> offsetof_member_designator LBRACKET expression RBRACKET','offsetof_member_designator',4,'p_offsetof_member_designator','c_parser.py',1802),
+  ('argument_expression_list -> assignment_expression','argument_expression_list',1,'p_argument_expression_list','c_parser.py',1814),
+  ('argument_expression_list -> argument_expression_list COMMA assignment_expression','argument_expression_list',3,'p_argument_expression_list','c_parser.py',1815),
+  ('identifier -> ID','identifier',1,'p_identifier','c_parser.py',1824),
+  ('constant -> INT_CONST_DEC','constant',1,'p_constant_1','c_parser.py',1828),
+  ('constant -> INT_CONST_OCT','constant',1,'p_constant_1','c_parser.py',1829),
+  ('constant -> INT_CONST_HEX','constant',1,'p_constant_1','c_parser.py',1830),
+  ('constant -> INT_CONST_BIN','constant',1,'p_constant_1','c_parser.py',1831),
+  ('constant -> INT_CONST_CHAR','constant',1,'p_constant_1','c_parser.py',1832),
+  ('constant -> FLOAT_CONST','constant',1,'p_constant_2','c_parser.py',1851),
+  ('constant -> HEX_FLOAT_CONST','constant',1,'p_constant_2','c_parser.py',1852),
+  ('constant -> CHAR_CONST','constant',1,'p_constant_3','c_parser.py',1868),
+  ('constant -> WCHAR_CONST','constant',1,'p_constant_3','c_parser.py',1869),
+  ('constant -> U8CHAR_CONST','constant',1,'p_constant_3','c_parser.py',1870),
+  ('constant -> U16CHAR_CONST','constant',1,'p_constant_3','c_parser.py',1871),
+  ('constant -> U32CHAR_CONST','constant',1,'p_constant_3','c_parser.py',1872),
+  ('unified_string_literal -> STRING_LITERAL','unified_string_literal',1,'p_unified_string_literal','c_parser.py',1883),
+  ('unified_string_literal -> unified_string_literal STRING_LITERAL','unified_string_literal',2,'p_unified_string_literal','c_parser.py',1884),
+  ('unified_wstring_literal -> WSTRING_LITERAL','unified_wstring_literal',1,'p_unified_wstring_literal','c_parser.py',1894),
+  ('unified_wstring_literal -> U8STRING_LITERAL','unified_wstring_literal',1,'p_unified_wstring_literal','c_parser.py',1895),
+  ('unified_wstring_literal -> U16STRING_LITERAL','unified_wstring_literal',1,'p_unified_wstring_literal','c_parser.py',1896),
+  ('unified_wstring_literal -> U32STRING_LITERAL','unified_wstring_literal',1,'p_unified_wstring_literal','c_parser.py',1897),
+  ('unified_wstring_literal -> unified_wstring_literal WSTRING_LITERAL','unified_wstring_literal',2,'p_unified_wstring_literal','c_parser.py',1898),
+  ('unified_wstring_literal -> unified_wstring_literal U8STRING_LITERAL','unified_wstring_literal',2,'p_unified_wstring_literal','c_parser.py',1899),
+  ('unified_wstring_literal -> unified_wstring_literal U16STRING_LITERAL','unified_wstring_literal',2,'p_unified_wstring_literal','c_parser.py',1900),
+  ('unified_wstring_literal -> unified_wstring_literal U32STRING_LITERAL','unified_wstring_literal',2,'p_unified_wstring_literal','c_parser.py',1901),
+  ('brace_open -> LBRACE','brace_open',1,'p_brace_open','c_parser.py',1911),
+  ('brace_close -> RBRACE','brace_close',1,'p_brace_close','c_parser.py',1917),
+  ('empty -> <empty>','empty',0,'p_empty','c_parser.py',1923),
+]
diff --git a/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/LICENSE
new file mode 100644
index 0000000..411ce48
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017, 2018, 2019, 2020, 2021 Samuel Colvin and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/METADATA
new file mode 100644
index 0000000..ec84cde
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/METADATA
@@ -0,0 +1,1115 @@
+Metadata-Version: 2.1
+Name: pydantic
+Version: 1.9.1
+Summary: Data validation and settings management using python type hints
+Home-page: https://github.com/samuelcolvin/pydantic
+Author: Samuel Colvin
+Author-email: s@muelcolvin.com
+License: MIT
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Unix
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: Console
+Classifier: Environment :: MacOS X
+Classifier: Framework :: Hypothesis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet
+Requires-Python: >=3.6.1
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing-extensions (>=3.7.4.3)
+Requires-Dist: dataclasses (>=0.6) ; python_version < "3.7"
+Provides-Extra: dotenv
+Requires-Dist: python-dotenv (>=0.10.4) ; extra == 'dotenv'
+Provides-Extra: email
+Requires-Dist: email-validator (>=1.0.3) ; extra == 'email'
+
+# pydantic
+
+[![CI](https://github.com/samuelcolvin/pydantic/workflows/CI/badge.svg?event=push)](https://github.com/samuelcolvin/pydantic/actions?query=event%3Apush+branch%3Amaster+workflow%3ACI)
+[![Coverage](https://coverage-badge.samuelcolvin.workers.dev/samuelcolvin/pydantic.svg?v=1)](https://coverage-badge.samuelcolvin.workers.dev/redirect/samuelcolvin/pydantic)
+[![pypi](https://img.shields.io/pypi/v/pydantic.svg)](https://pypi.python.org/pypi/pydantic)
+[![CondaForge](https://img.shields.io/conda/v/conda-forge/pydantic.svg)](https://anaconda.org/conda-forge/pydantic)
+[![downloads](https://pepy.tech/badge/pydantic/month)](https://pepy.tech/project/pydantic)
+[![versions](https://img.shields.io/pypi/pyversions/pydantic.svg)](https://github.com/samuelcolvin/pydantic)
+[![license](https://img.shields.io/github/license/samuelcolvin/pydantic.svg)](https://github.com/samuelcolvin/pydantic/blob/master/LICENSE)
+
+Data validation and settings management using Python type hints.
+
+Fast and extensible, *pydantic* plays nicely with your linters/IDE/brain.
+Define how data should be in pure, canonical Python 3.6+; validate it with *pydantic*.
+
+## Help
+
+See [documentation](https://pydantic-docs.helpmanual.io/) for more details.
+
+## Installation
+
+Install using `pip install -U pydantic` or `conda install pydantic -c conda-forge`.
+For more installation options to make *pydantic* even faster,
+see the [Install](https://pydantic-docs.helpmanual.io/install/) section in the documentation.
+
+## A Simple Example
+
+```py
+from datetime import datetime
+from typing import List, Optional
+from pydantic import BaseModel
+
+class User(BaseModel):
+    id: int
+    name = 'John Doe'
+    signup_ts: Optional[datetime] = None
+    friends: List[int] = []
+
+external_data = {'id': '123', 'signup_ts': '2017-06-01 12:22', 'friends': [1, '2', b'3']}
+user = User(**external_data)
+print(user)
+#> User id=123 name='John Doe' signup_ts=datetime.datetime(2017, 6, 1, 12, 22) friends=[1, 2, 3]
+print(user.id)
+#> 123
+```
+
+## Contributing
+
+For guidance on setting up a development environment and how to make a
+contribution to *pydantic*, see
+[Contributing to Pydantic](https://pydantic-docs.helpmanual.io/contributing/).
+
+## Reporting a Security Vulnerability
+
+See our [security policy](https://github.com/samuelcolvin/pydantic/security/policy).
+
+
+## v1.9.1 (2022-05-19)
+
+Thank you to pydantic's sponsors:
+@tiangolo, [@stellargraph](https://github.com/stellargraph), [@JonasKs](https://github.com/JonasKs), [@grillazz](https://github.com/grillazz), [@Mazyod](https://github.com/Mazyod), [@kevinalh](https://github.com/kevinalh), [@chdsbd](https://github.com/chdsbd), [@povilasb](https://github.com/povilasb), [@povilasb](https://github.com/povilasb), [@jina-ai](https://github.com/jina-ai), 
+@mainframeindustries, [@robusta-dev](https://github.com/robusta-dev), [@SendCloud](https://github.com/SendCloud), [@rszamszur](https://github.com/rszamszur), [@jodal](https://github.com/jodal), [@hardbyte](https://github.com/hardbyte), [@corleyma](https://github.com/corleyma), [@daddycocoaman](https://github.com/daddycocoaman), 
+@Rehket, [@jokull](https://github.com/jokull), [@reillysiemens](https://github.com/reillysiemens), [@westonsteimel](https://github.com/westonsteimel), [@primer-io](https://github.com/primer-io), [@koxudaxi](https://github.com/koxudaxi), [@browniebroke](https://github.com/browniebroke), [@stradivari96](https://github.com/stradivari96), 
+@adriangb, [@kamalgill](https://github.com/kamalgill), [@jqueguiner](https://github.com/jqueguiner), [@dev-zero](https://github.com/dev-zero), [@datarootsio](https://github.com/datarootsio), [@RedCarpetUp](https://github.com/RedCarpetUp)
+for their kind support.
+
+* Limit the size of `generics._generic_types_cache` and `generics._assigned_parameters` 
+  to avoid unlimited increase in memory usage, [#4083](https://github.com/samuelcolvin/pydantic/issues/4083) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Add Jupyverse and FPS as Jupyter projects using pydantic, [#4082](https://github.com/samuelcolvin/pydantic/issues/4082) by [@davidbrochart](https://github.com/davidbrochart)
+* Speedup `__isinstancecheck__` on pydantic models when the type is not a model, may also avoid memory "leaks", [#4081](https://github.com/samuelcolvin/pydantic/issues/4081) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix in-place modification of `FieldInfo` that caused problems with PEP 593 type aliases, [#4067](https://github.com/samuelcolvin/pydantic/issues/4067) by [@adriangb](https://github.com/adriangb)
+* Add support for autocomplete in VS Code via `__dataclass_transform__` when using `pydantic.dataclasses.dataclass`, [#4006](https://github.com/samuelcolvin/pydantic/issues/4006) by [@giuliano-oliveira](https://github.com/giuliano-oliveira)
+* Remove benchmarks from codebase and docs, [#3973](https://github.com/samuelcolvin/pydantic/issues/3973) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Typing checking with pyright in CI, improve docs on vscode/pylance/pyright, [#3972](https://github.com/samuelcolvin/pydantic/issues/3972) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix nested Python dataclass schema regression, [#3819](https://github.com/samuelcolvin/pydantic/issues/3819) by [@himbeles](https://github.com/himbeles)
+* Update documentation about lazy evaluation of sources for Settings, [#3806](https://github.com/samuelcolvin/pydantic/issues/3806) by [@garyd203](https://github.com/garyd203)
+* Prevent subclasses of bytes being converted to bytes, [#3706](https://github.com/samuelcolvin/pydantic/issues/3706) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fixed "error checking inheritance of" when using PEP585 and PEP604 type hints, [#3681](https://github.com/samuelcolvin/pydantic/issues/3681) by [@aleksul](https://github.com/aleksul)
+* Allow self referencing `ClassVar`s in models, [#3679](https://github.com/samuelcolvin/pydantic/issues/3679) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix issue with self-referencing dataclass, [#3675](https://github.com/samuelcolvin/pydantic/issues/3675) by [@uriyyo](https://github.com/uriyyo)
+* Include non-standard port numbers in rendered URLs, [#3652](https://github.com/samuelcolvin/pydantic/issues/3652) by [@dolfinus](https://github.com/dolfinus)
+* `Config.copy_on_model_validation` does a deep copy and not a shallow one, [#3641](https://github.com/samuelcolvin/pydantic/issues/3641) by [@PrettyWood](https://github.com/PrettyWood)
+* fix: clarify that discriminated unions do not support singletons, [#3636](https://github.com/samuelcolvin/pydantic/issues/3636) by [@tommilligan](https://github.com/tommilligan)
+* Add `read_text(encoding='utf-8')` for `setup.py`, [#3625](https://github.com/samuelcolvin/pydantic/issues/3625) by [@hswong3i](https://github.com/hswong3i)
+* Fix JSON Schema generation for Discriminated Unions within lists, [#3608](https://github.com/samuelcolvin/pydantic/issues/3608) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v1.9.0 (2021-12-31)
+
+Thank you to pydantic's sponsors:
+@sthagen, [@timdrijvers](https://github.com/timdrijvers), [@toinbis](https://github.com/toinbis), [@koxudaxi](https://github.com/koxudaxi), [@ginomempin](https://github.com/ginomempin), [@primer-io](https://github.com/primer-io), [@and-semakin](https://github.com/and-semakin), [@westonsteimel](https://github.com/westonsteimel), [@reillysiemens](https://github.com/reillysiemens),
+@es3n1n, [@jokull](https://github.com/jokull), [@JonasKs](https://github.com/JonasKs), [@Rehket](https://github.com/Rehket), [@corleyma](https://github.com/corleyma), [@daddycocoaman](https://github.com/daddycocoaman), [@hardbyte](https://github.com/hardbyte), [@datarootsio](https://github.com/datarootsio), [@jodal](https://github.com/jodal), [@aminalaee](https://github.com/aminalaee), [@rafsaf](https://github.com/rafsaf), 
+@jqueguiner, [@chdsbd](https://github.com/chdsbd), [@kevinalh](https://github.com/kevinalh), [@Mazyod](https://github.com/Mazyod), [@grillazz](https://github.com/grillazz), [@JonasKs](https://github.com/JonasKs), [@simw](https://github.com/simw), [@leynier](https://github.com/leynier), [@xfenix](https://github.com/xfenix)
+for their kind support.
+
+### Highlights
+
+* add python 3.10 support, [#2885](https://github.com/samuelcolvin/pydantic/issues/2885) by [@PrettyWood](https://github.com/PrettyWood)
+* [Discriminated unions](https://pydantic-docs.helpmanual.io/usage/types/#discriminated-unions-aka-tagged-unions), [#619](https://github.com/samuelcolvin/pydantic/issues/619) by [@PrettyWood](https://github.com/PrettyWood)
+* [`Config.smart_union` for better union logic](https://pydantic-docs.helpmanual.io/usage/model_config/#smart-union), [#2092](https://github.com/samuelcolvin/pydantic/issues/2092) by [@PrettyWood](https://github.com/PrettyWood)
+* Binaries for Macos M1 CPUs, [#3498](https://github.com/samuelcolvin/pydantic/issues/3498) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Complex types can be set via [nested environment variables](https://pydantic-docs.helpmanual.io/usage/settings/#parsing-environment-variable-values), e.g. `foo___bar`, [#3159](https://github.com/samuelcolvin/pydantic/issues/3159) by [@Air-Mark](https://github.com/Air-Mark)
+* add a dark mode to _pydantic_ documentation, [#2913](https://github.com/samuelcolvin/pydantic/issues/2913) by [@gbdlin](https://github.com/gbdlin)
+* Add support for autocomplete in VS Code via `__dataclass_transform__`, [#2721](https://github.com/samuelcolvin/pydantic/issues/2721) by [@tiangolo](https://github.com/tiangolo)
+* Add "exclude" as a field parameter so that it can be configured using model config, [#660](https://github.com/samuelcolvin/pydantic/issues/660) by [@daviskirk](https://github.com/daviskirk)
+
+### v1.9.0 (2021-12-31) Changes
+
+* Apply `update_forward_refs` to `Config.json_encodes` prevent name clashes in types defined via strings, [#3583](https://github.com/samuelcolvin/pydantic/issues/3583) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Extend pydantic's mypy plugin to support mypy versions `0.910`, `0.920`, `0.921` & `0.930`, [#3573](https://github.com/samuelcolvin/pydantic/issues/3573) & [#3594](https://github.com/samuelcolvin/pydantic/issues/3594) by [@PrettyWood](https://github.com/PrettyWood), [@christianbundy](https://github.com/christianbundy), [@samuelcolvin](https://github.com/samuelcolvin)
+
+### v1.9.0a2 (2021-12-24) Changes
+
+* support generic models with discriminated union, [#3551](https://github.com/samuelcolvin/pydantic/issues/3551) by [@PrettyWood](https://github.com/PrettyWood)
+* keep old behaviour of `json()` by default, [#3542](https://github.com/samuelcolvin/pydantic/issues/3542) by [@PrettyWood](https://github.com/PrettyWood)
+* Removed typing-only `__root__` attribute from `BaseModel`, [#3540](https://github.com/samuelcolvin/pydantic/issues/3540) by [@layday](https://github.com/layday)
+* Build Python 3.10 wheels, [#3539](https://github.com/samuelcolvin/pydantic/issues/3539) by [@mbachry](https://github.com/mbachry)
+* Fix display of `extra` fields with model `__repr__`, [#3234](https://github.com/samuelcolvin/pydantic/issues/3234) by [@cocolman](https://github.com/cocolman)
+* models copied via `Config.copy_on_model_validation` always have all fields, [#3201](https://github.com/samuelcolvin/pydantic/issues/3201) by [@PrettyWood](https://github.com/PrettyWood)
+* nested ORM from nested dictionaries, [#3182](https://github.com/samuelcolvin/pydantic/issues/3182) by [@PrettyWood](https://github.com/PrettyWood)
+* fix link to discriminated union section by [@PrettyWood](https://github.com/PrettyWood)
+
+### v1.9.0a1 (2021-12-18) Changes
+
+* Add support for `Decimal`-specific validation configurations in `Field()`, additionally to using `condecimal()`, 
+  to allow better support from editors and tooling, [#3507](https://github.com/samuelcolvin/pydantic/issues/3507) by [@tiangolo](https://github.com/tiangolo)
+* Add `arm64` binaries suitable for MacOS with an M1 CPU to PyPI, [#3498](https://github.com/samuelcolvin/pydantic/issues/3498) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix issue where `None` was considered invalid when using a `Union` type containing `Any` or `object`, [#3444](https://github.com/samuelcolvin/pydantic/issues/3444) by [@tharradine](https://github.com/tharradine)
+* When generating field schema, pass optional `field` argument (of type
+  `pydantic.fields.ModelField`) to `__modify_schema__()` if present, [#3434](https://github.com/samuelcolvin/pydantic/issues/3434) by [@jasujm](https://github.com/jasujm)
+* Fix issue when pydantic fail to parse `typing.ClassVar` string type annotation, [#3401](https://github.com/samuelcolvin/pydantic/issues/3401) by [@uriyyo](https://github.com/uriyyo)
+* Mention Python >= 3.9.2 as an alternative to `typing_extensions.TypedDict`, [#3374](https://github.com/samuelcolvin/pydantic/issues/3374) by [@BvB93](https://github.com/BvB93)
+* Changed the validator method name in the [Custom Errors example](https://pydantic-docs.helpmanual.io/usage/models/#custom-errors) 
+  to more accurately describe what the validator is doing; changed from `name_must_contain_space` to ` value_must_equal_bar`, [#3327](https://github.com/samuelcolvin/pydantic/issues/3327) by [@michaelrios28](https://github.com/michaelrios28)
+* Add `AmqpDsn` class, [#3254](https://github.com/samuelcolvin/pydantic/issues/3254) by [@kludex](https://github.com/kludex)
+* Always use `Enum` value as default in generated JSON schema, [#3190](https://github.com/samuelcolvin/pydantic/issues/3190) by [@joaommartins](https://github.com/joaommartins)
+* Add support for Mypy 0.920, [#3175](https://github.com/samuelcolvin/pydantic/issues/3175) by [@christianbundy](https://github.com/christianbundy)
+* `validate_arguments` now supports `extra` customization (used to always be `Extra.forbid`), [#3161](https://github.com/samuelcolvin/pydantic/issues/3161) by [@PrettyWood](https://github.com/PrettyWood)
+* Complex types can be set by nested environment variables, [#3159](https://github.com/samuelcolvin/pydantic/issues/3159) by [@Air-Mark](https://github.com/Air-Mark)
+* Fix mypy plugin to collect fields based on `pydantic.utils.is_valid_field` so that it ignores untyped private variables, [#3146](https://github.com/samuelcolvin/pydantic/issues/3146) by [@hi-ogawa](https://github.com/hi-ogawa)
+* fix `validate_arguments` issue with `Config.validate_all`, [#3135](https://github.com/samuelcolvin/pydantic/issues/3135) by [@PrettyWood](https://github.com/PrettyWood)
+* avoid dict coercion when using dict subclasses as field type, [#3122](https://github.com/samuelcolvin/pydantic/issues/3122) by [@PrettyWood](https://github.com/PrettyWood)
+* add support for `object` type, [#3062](https://github.com/samuelcolvin/pydantic/issues/3062) by [@PrettyWood](https://github.com/PrettyWood)
+* Updates pydantic dataclasses to keep `_special` properties on parent classes, [#3043](https://github.com/samuelcolvin/pydantic/issues/3043) by [@zulrang](https://github.com/zulrang)
+* Add a `TypedDict` class for error objects, [#3038](https://github.com/samuelcolvin/pydantic/issues/3038) by [@matthewhughes934](https://github.com/matthewhughes934)
+* Fix support for using a subclass of an annotation as a default, [#3018](https://github.com/samuelcolvin/pydantic/issues/3018) by [@JacobHayes](https://github.com/JacobHayes)
+* make `create_model_from_typeddict` mypy compliant, [#3008](https://github.com/samuelcolvin/pydantic/issues/3008) by [@PrettyWood](https://github.com/PrettyWood)
+* Make multiple inheritance work when using `PrivateAttr`, [#2989](https://github.com/samuelcolvin/pydantic/issues/2989) by [@hmvp](https://github.com/hmvp)
+* Parse environment variables as JSON, if they have a `Union` type with a complex subfield, [#2936](https://github.com/samuelcolvin/pydantic/issues/2936) by [@cbartz](https://github.com/cbartz)
+* Prevent `StrictStr` permitting `Enum` values where the enum inherits from `str`, [#2929](https://github.com/samuelcolvin/pydantic/issues/2929) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Make `SecretsSettingsSource` parse values being assigned to fields of complex types when sourced from a secrets file, 
+  just as when sourced from environment variables, [#2917](https://github.com/samuelcolvin/pydantic/issues/2917) by [@davidmreed](https://github.com/davidmreed)
+* add a dark mode to _pydantic_ documentation, [#2913](https://github.com/samuelcolvin/pydantic/issues/2913) by [@gbdlin](https://github.com/gbdlin)
+* Make `pydantic-mypy` plugin compatible with `pyproject.toml` configuration, consistent with `mypy` changes. 
+  See the [doc](https://pydantic-docs.helpmanual.io/mypy_plugin/#configuring-the-plugin) for more information, [#2908](https://github.com/samuelcolvin/pydantic/issues/2908) by [@jrwalk](https://github.com/jrwalk)
+* add python 3.10 support, [#2885](https://github.com/samuelcolvin/pydantic/issues/2885) by [@PrettyWood](https://github.com/PrettyWood)
+* Correctly parse generic models with `Json[T]`, [#2860](https://github.com/samuelcolvin/pydantic/issues/2860) by [@geekingfrog](https://github.com/geekingfrog)
+* Update contrib docs re: python version to use for building docs, [#2856](https://github.com/samuelcolvin/pydantic/issues/2856) by [@paxcodes](https://github.com/paxcodes)
+* Clarify documentation about _pydantic_'s support for custom validation and strict type checking, 
+  despite _pydantic_ being primarily a parsing library, [#2855](https://github.com/samuelcolvin/pydantic/issues/2855) by [@paxcodes](https://github.com/paxcodes)
+* Fix schema generation for `Deque` fields, [#2810](https://github.com/samuelcolvin/pydantic/issues/2810) by [@sergejkozin](https://github.com/sergejkozin)
+* fix an edge case when mixing constraints and `Literal`, [#2794](https://github.com/samuelcolvin/pydantic/issues/2794) by [@PrettyWood](https://github.com/PrettyWood)
+* Fix postponed annotation resolution for `NamedTuple` and `TypedDict` when they're used directly as the type of fields 
+  within Pydantic models, [#2760](https://github.com/samuelcolvin/pydantic/issues/2760) by [@jameysharp](https://github.com/jameysharp)
+* Fix bug when `mypy` plugin fails on `construct` method call for `BaseSettings` derived classes, [#2753](https://github.com/samuelcolvin/pydantic/issues/2753) by [@uriyyo](https://github.com/uriyyo)
+* Add function overloading for a `pydantic.create_model` function, [#2748](https://github.com/samuelcolvin/pydantic/issues/2748) by [@uriyyo](https://github.com/uriyyo)
+* Fix mypy plugin issue with self field declaration, [#2743](https://github.com/samuelcolvin/pydantic/issues/2743) by [@uriyyo](https://github.com/uriyyo)
+* The colon at the end of the line "The fields which were supplied when user was initialised:" suggests that the code following it is related.
+  Changed it to a period, [#2733](https://github.com/samuelcolvin/pydantic/issues/2733) by [@krisaoe](https://github.com/krisaoe)
+* Renamed variable `schema` to `schema_` to avoid shadowing of global variable name, [#2724](https://github.com/samuelcolvin/pydantic/issues/2724) by [@shahriyarr](https://github.com/shahriyarr)
+* Add support for autocomplete in VS Code via `__dataclass_transform__`, [#2721](https://github.com/samuelcolvin/pydantic/issues/2721) by [@tiangolo](https://github.com/tiangolo)
+* add missing type annotations in `BaseConfig` and handle `max_length = 0`, [#2719](https://github.com/samuelcolvin/pydantic/issues/2719) by [@PrettyWood](https://github.com/PrettyWood)
+* Change `orm_mode` checking to allow recursive ORM mode parsing with dicts, [#2718](https://github.com/samuelcolvin/pydantic/issues/2718) by [@nuno-andre](https://github.com/nuno-andre)
+* Add episode 313 of the *Talk Python To Me* podcast, where Michael Kennedy and Samuel Colvin discuss *pydantic*, to the docs, [#2712](https://github.com/samuelcolvin/pydantic/issues/2712) by [@RatulMaharaj](https://github.com/RatulMaharaj)
+* fix JSON schema generation when a field is of type `NamedTuple` and has a default value, [#2707](https://github.com/samuelcolvin/pydantic/issues/2707) by [@PrettyWood](https://github.com/PrettyWood)
+* `Enum` fields now properly support extra kwargs in schema generation, [#2697](https://github.com/samuelcolvin/pydantic/issues/2697) by [@sammchardy](https://github.com/sammchardy)
+* Make serialization of referenced pydantic models possible, [#2650](https://github.com/samuelcolvin/pydantic/issues/2650) by [@PrettyWood](https://github.com/PrettyWood)
+* Add `uniqueItems` option to `ConstrainedList`, [#2618](https://github.com/samuelcolvin/pydantic/issues/2618) by [@nuno-andre](https://github.com/nuno-andre)
+* Try to evaluate forward refs automatically at model creation, [#2588](https://github.com/samuelcolvin/pydantic/issues/2588) by [@uriyyo](https://github.com/uriyyo)
+* Switch docs preview and coverage display to use [smokeshow](https://smokeshow.helpmanual.io/), [#2580](https://github.com/samuelcolvin/pydantic/issues/2580) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Add `__version__` attribute to pydantic module, [#2572](https://github.com/samuelcolvin/pydantic/issues/2572) by [@paxcodes](https://github.com/paxcodes)
+* Add `postgresql+asyncpg`, `postgresql+pg8000`, `postgresql+psycopg2`, `postgresql+psycopg2cffi`, `postgresql+py-postgresql`
+  and `postgresql+pygresql` schemes for `PostgresDsn`, [#2567](https://github.com/samuelcolvin/pydantic/issues/2567) by [@postgres-asyncpg](https://github.com/postgres-asyncpg)
+* Enable the Hypothesis plugin to generate a constrained decimal when the `decimal_places` argument is specified, [#2524](https://github.com/samuelcolvin/pydantic/issues/2524) by [@cwe5590](https://github.com/cwe5590)
+* Allow `collections.abc.Callable` to be used as type in python 3.9, [#2519](https://github.com/samuelcolvin/pydantic/issues/2519) by [@daviskirk](https://github.com/daviskirk)
+* Documentation update how to custom compile pydantic when using pip install, small change in `setup.py` 
+  to allow for custom CFLAGS when compiling, [#2517](https://github.com/samuelcolvin/pydantic/issues/2517) by [@peterroelants](https://github.com/peterroelants)
+* remove side effect of `default_factory` to run it only once even if `Config.validate_all` is set, [#2515](https://github.com/samuelcolvin/pydantic/issues/2515) by [@PrettyWood](https://github.com/PrettyWood)
+* Add lookahead to ip regexes for `AnyUrl` hosts. This allows urls with DNS labels
+  looking like IPs to validate as they are perfectly valid host names, [#2512](https://github.com/samuelcolvin/pydantic/issues/2512) by [@sbv-csis](https://github.com/sbv-csis)
+* Set `minItems` and `maxItems` in generated JSON schema for fixed-length tuples, [#2497](https://github.com/samuelcolvin/pydantic/issues/2497) by [@PrettyWood](https://github.com/PrettyWood)
+* Add `strict` argument to `conbytes`, [#2489](https://github.com/samuelcolvin/pydantic/issues/2489) by [@koxudaxi](https://github.com/koxudaxi)
+* Support user defined generic field types in generic models, [#2465](https://github.com/samuelcolvin/pydantic/issues/2465) by [@daviskirk](https://github.com/daviskirk)
+* Add an example and a short explanation of subclassing `GetterDict` to docs, [#2463](https://github.com/samuelcolvin/pydantic/issues/2463) by [@nuno-andre](https://github.com/nuno-andre)
+* add `KafkaDsn` type, `HttpUrl` now has default port 80 for http and 443 for https, [#2447](https://github.com/samuelcolvin/pydantic/issues/2447) by [@MihanixA](https://github.com/MihanixA)
+* Add `PastDate` and `FutureDate` types, [#2425](https://github.com/samuelcolvin/pydantic/issues/2425) by [@Kludex](https://github.com/Kludex)
+* Support generating schema for `Generic` fields with subtypes, [#2375](https://github.com/samuelcolvin/pydantic/issues/2375) by [@maximberg](https://github.com/maximberg)
+* fix(encoder): serialize `NameEmail` to str, [#2341](https://github.com/samuelcolvin/pydantic/issues/2341) by [@alecgerona](https://github.com/alecgerona)
+* add `Config.smart_union` to prevent coercion in `Union` if possible, see 
+ [the doc](https://pydantic-docs.helpmanual.io/usage/model_config/#smart-union) for more information, [#2092](https://github.com/samuelcolvin/pydantic/issues/2092) by [@PrettyWood](https://github.com/PrettyWood)
+* Add ability to use `typing.Counter` as a model field type, [#2060](https://github.com/samuelcolvin/pydantic/issues/2060) by [@uriyyo](https://github.com/uriyyo)
+* Add parameterised subclasses to `__bases__` when constructing new parameterised classes, so that `A <: B => A[int] <: B[int]`, [#2007](https://github.com/samuelcolvin/pydantic/issues/2007) by [@diabolo-dan](https://github.com/diabolo-dan)
+* Create `FileUrl` type that allows URLs that conform to [RFC 8089](https://tools.ietf.org/html/rfc8089#section-2).
+  Add `host_required` parameter, which is `True` by default (`AnyUrl` and subclasses), `False` in `RedisDsn`, `FileUrl`, [#1983](https://github.com/samuelcolvin/pydantic/issues/1983) by [@vgerak](https://github.com/vgerak)
+* add `confrozenset()`, analogous to `conset()` and `conlist()`, [#1897](https://github.com/samuelcolvin/pydantic/issues/1897) by [@PrettyWood](https://github.com/PrettyWood)
+* stop calling parent class `root_validator` if overridden, [#1895](https://github.com/samuelcolvin/pydantic/issues/1895) by [@PrettyWood](https://github.com/PrettyWood)
+* Add `repr` (defaults to `True`) parameter to `Field`, to hide it from the default representation of the `BaseModel`, [#1831](https://github.com/samuelcolvin/pydantic/issues/1831) by [@fnep](https://github.com/fnep)
+* Accept empty query/fragment URL parts, [#1807](https://github.com/samuelcolvin/pydantic/issues/1807) by [@xavier](https://github.com/xavier)
+
+## v1.8.2 (2021-05-11)
+
+!!! warning
+    A security vulnerability, level "moderate" is fixed in v1.8.2. Please upgrade **ASAP**.
+    See security advisory [CVE-2021-29510](https://github.com/samuelcolvin/pydantic/security/advisories/GHSA-5jqp-qgf6-3pvh)
+
+* **Security fix:** Fix `date` and `datetime` parsing so passing either `'infinity'` or `float('inf')` 
+  (or their negative values) does not cause an infinite loop, 
+  see security advisory [CVE-2021-29510](https://github.com/samuelcolvin/pydantic/security/advisories/GHSA-5jqp-qgf6-3pvh)
+* fix schema generation with Enum by generating a valid name, [#2575](https://github.com/samuelcolvin/pydantic/issues/2575) by [@PrettyWood](https://github.com/PrettyWood)
+* fix JSON schema generation with a `Literal` of an enum member, [#2536](https://github.com/samuelcolvin/pydantic/issues/2536) by [@PrettyWood](https://github.com/PrettyWood)
+* Fix bug with configurations declarations that are passed as
+  keyword arguments during class creation, [#2532](https://github.com/samuelcolvin/pydantic/issues/2532) by [@uriyyo](https://github.com/uriyyo)
+* Allow passing `json_encoders` in class kwargs, [#2521](https://github.com/samuelcolvin/pydantic/issues/2521) by [@layday](https://github.com/layday)
+* support arbitrary types with custom `__eq__`, [#2483](https://github.com/samuelcolvin/pydantic/issues/2483) by [@PrettyWood](https://github.com/PrettyWood)
+* support `Annotated` in `validate_arguments` and in generic models with python 3.9, [#2483](https://github.com/samuelcolvin/pydantic/issues/2483) by [@PrettyWood](https://github.com/PrettyWood)
+
+## v1.8.1 (2021-03-03)
+
+Bug fixes for regressions and new features from `v1.8` 
+
+* allow elements of `Config.field` to update elements of a `Field`, [#2461](https://github.com/samuelcolvin/pydantic/issues/2461) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix validation with a `BaseModel` field and a custom root type, [#2449](https://github.com/samuelcolvin/pydantic/issues/2449) by [@PrettyWood](https://github.com/PrettyWood)
+* expose `Pattern` encoder to `fastapi`, [#2444](https://github.com/samuelcolvin/pydantic/issues/2444) by [@PrettyWood](https://github.com/PrettyWood)
+* enable the Hypothesis plugin to generate a constrained float when the `multiple_of` argument is specified, [#2442](https://github.com/samuelcolvin/pydantic/issues/2442) by [@tobi-lipede-oodle](https://github.com/tobi-lipede-oodle)
+* Avoid `RecursionError` when using some types like `Enum` or `Literal` with generic models, [#2436](https://github.com/samuelcolvin/pydantic/issues/2436) by [@PrettyWood](https://github.com/PrettyWood)
+* do not overwrite declared `__hash__` in subclasses of a model, [#2422](https://github.com/samuelcolvin/pydantic/issues/2422) by [@PrettyWood](https://github.com/PrettyWood)
+* fix `mypy` complaints on `Path` and `UUID` related custom types, [#2418](https://github.com/samuelcolvin/pydantic/issues/2418) by [@PrettyWood](https://github.com/PrettyWood)
+* Support properly variable length tuples of compound types, [#2416](https://github.com/samuelcolvin/pydantic/issues/2416) by [@PrettyWood](https://github.com/PrettyWood)
+
+## v1.8 (2021-02-26)
+
+Thank you to pydantic's sponsors:
+@jorgecarleitao, [@BCarley](https://github.com/BCarley), [@chdsbd](https://github.com/chdsbd), [@tiangolo](https://github.com/tiangolo), [@matin](https://github.com/matin), [@linusg](https://github.com/linusg), [@kevinalh](https://github.com/kevinalh), [@koxudaxi](https://github.com/koxudaxi), [@timdrijvers](https://github.com/timdrijvers), [@mkeen](https://github.com/mkeen), [@meadsteve](https://github.com/meadsteve), 
+@ginomempin, [@primer-io](https://github.com/primer-io), [@and-semakin](https://github.com/and-semakin), [@tomthorogood](https://github.com/tomthorogood), [@AjitZK](https://github.com/AjitZK), [@westonsteimel](https://github.com/westonsteimel), [@Mazyod](https://github.com/Mazyod), [@christippett](https://github.com/christippett), [@CarlosDomingues](https://github.com/CarlosDomingues), 
+@Kludex, [@r-m-n](https://github.com/r-m-n)
+for their kind support.
+
+### Highlights
+
+* [Hypothesis plugin](https://pydantic-docs.helpmanual.io/hypothesis_plugin/) for testing, [#2097](https://github.com/samuelcolvin/pydantic/issues/2097) by [@Zac-HD](https://github.com/Zac-HD)
+* support for [`NamedTuple` and `TypedDict`](https://pydantic-docs.helpmanual.io/usage/types/#annotated-types), [#2216](https://github.com/samuelcolvin/pydantic/issues/2216) by [@PrettyWood](https://github.com/PrettyWood)
+* Support [`Annotated` hints on model fields](https://pydantic-docs.helpmanual.io/usage/schema/#typingannotated-fields), [#2147](https://github.com/samuelcolvin/pydantic/issues/2147) by [@JacobHayes](https://github.com/JacobHayes)
+* [`frozen` parameter on `Config`](https://pydantic-docs.helpmanual.io/usage/model_config/) to allow models to be hashed, [#1880](https://github.com/samuelcolvin/pydantic/issues/1880) by [@rhuille](https://github.com/rhuille)
+
+### Changes
+
+* **Breaking Change**, remove old deprecation aliases from v1, [#2415](https://github.com/samuelcolvin/pydantic/issues/2415) by [@samuelcolvin](https://github.com/samuelcolvin):
+  * remove notes on migrating to v1 in docs
+  * remove `Schema` which was replaced by `Field`
+  * remove `Config.case_insensitive` which was replaced by `Config.case_sensitive` (default `False`)
+  * remove `Config.allow_population_by_alias` which was replaced by `Config.allow_population_by_field_name`
+  * remove `model.fields` which was replaced by `model.__fields__`
+  * remove `model.to_string()` which was replaced by `str(model)`
+  * remove `model.__values__` which was replaced by `model.__dict__`
+* **Breaking Change:** always validate only first sublevel items with `each_item`.
+  There were indeed some edge cases with some compound types where the validated items were the last sublevel ones, [#1933](https://github.com/samuelcolvin/pydantic/issues/1933) by [@PrettyWood](https://github.com/PrettyWood)
+* Update docs extensions to fix local syntax highlighting, [#2400](https://github.com/samuelcolvin/pydantic/issues/2400) by [@daviskirk](https://github.com/daviskirk)
+* fix: allow `utils.lenient_issubclass` to handle `typing.GenericAlias` objects like `list[str]` in python >= 3.9, [#2399](https://github.com/samuelcolvin/pydantic/issues/2399) by [@daviskirk](https://github.com/daviskirk)
+* Improve field declaration for _pydantic_ `dataclass` by allowing the usage of _pydantic_ `Field` or `'metadata'` kwarg of `dataclasses.field`, [#2384](https://github.com/samuelcolvin/pydantic/issues/2384) by [@PrettyWood](https://github.com/PrettyWood)
+* Making `typing-extensions` a required dependency, [#2368](https://github.com/samuelcolvin/pydantic/issues/2368) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Make `resolve_annotations` more lenient, allowing for missing modules, [#2363](https://github.com/samuelcolvin/pydantic/issues/2363) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Allow configuring models through class kwargs, [#2356](https://github.com/samuelcolvin/pydantic/issues/2356) by [@Bobronium](https://github.com/Bobronium)
+* Prevent `Mapping` subclasses from always being coerced to `dict`, [#2325](https://github.com/samuelcolvin/pydantic/issues/2325) by [@ofek](https://github.com/ofek)
+* fix: allow `None` for type `Optional[conset / conlist]`, [#2320](https://github.com/samuelcolvin/pydantic/issues/2320) by [@PrettyWood](https://github.com/PrettyWood)
+* Support empty tuple type, [#2318](https://github.com/samuelcolvin/pydantic/issues/2318) by [@PrettyWood](https://github.com/PrettyWood)
+* fix: `python_requires` metadata to require >=3.6.1, [#2306](https://github.com/samuelcolvin/pydantic/issues/2306) by [@hukkinj1](https://github.com/hukkinj1)
+* Properly encode `Decimal` with, or without any decimal places, [#2293](https://github.com/samuelcolvin/pydantic/issues/2293) by [@hultner](https://github.com/hultner)
+* fix: update `__fields_set__` in `BaseModel.copy(update=…)`, [#2290](https://github.com/samuelcolvin/pydantic/issues/2290) by [@PrettyWood](https://github.com/PrettyWood)
+* fix: keep order of fields with `BaseModel.construct()`, [#2281](https://github.com/samuelcolvin/pydantic/issues/2281) by [@PrettyWood](https://github.com/PrettyWood)
+* Support generating schema for Generic fields, [#2262](https://github.com/samuelcolvin/pydantic/issues/2262) by [@maximberg](https://github.com/maximberg)
+* Fix `validate_decorator` so `**kwargs` doesn't exclude values when the keyword
+  has the same name as the `*args` or `**kwargs` names, [#2251](https://github.com/samuelcolvin/pydantic/issues/2251) by [@cybojenix](https://github.com/cybojenix)
+* Prevent overriding positional arguments with keyword arguments in
+  `validate_arguments`, as per behaviour with native functions, [#2249](https://github.com/samuelcolvin/pydantic/issues/2249) by [@cybojenix](https://github.com/cybojenix)
+* add documentation for `con*` type functions, [#2242](https://github.com/samuelcolvin/pydantic/issues/2242) by [@tayoogunbiyi](https://github.com/tayoogunbiyi)
+* Support custom root type (aka `__root__`) when using `parse_obj()` with nested models, [#2238](https://github.com/samuelcolvin/pydantic/issues/2238) by [@PrettyWood](https://github.com/PrettyWood)
+* Support custom root type (aka `__root__`) with `from_orm()`, [#2237](https://github.com/samuelcolvin/pydantic/issues/2237) by [@PrettyWood](https://github.com/PrettyWood)
+* ensure cythonized functions are left untouched when creating models, based on [#1944](https://github.com/samuelcolvin/pydantic/issues/1944) by [@kollmats](https://github.com/kollmats), [#2228](https://github.com/samuelcolvin/pydantic/issues/2228) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Resolve forward refs for stdlib dataclasses converted into _pydantic_ ones, [#2220](https://github.com/samuelcolvin/pydantic/issues/2220) by [@PrettyWood](https://github.com/PrettyWood)
+* Add support for `NamedTuple` and `TypedDict` types.
+  Those two types are now handled and validated when used inside `BaseModel` or _pydantic_ `dataclass`.
+  Two utils are also added `create_model_from_namedtuple` and `create_model_from_typeddict`, [#2216](https://github.com/samuelcolvin/pydantic/issues/2216) by [@PrettyWood](https://github.com/PrettyWood)
+* Do not ignore annotated fields when type is `Union[Type[...], ...]`, [#2213](https://github.com/samuelcolvin/pydantic/issues/2213) by [@PrettyWood](https://github.com/PrettyWood)
+* Raise a user-friendly `TypeError` when a `root_validator` does not return a `dict` (e.g. `None`), [#2209](https://github.com/samuelcolvin/pydantic/issues/2209) by [@masalim2](https://github.com/masalim2)
+* Add a `FrozenSet[str]` type annotation to the `allowed_schemes` argument on the `strict_url` field type, [#2198](https://github.com/samuelcolvin/pydantic/issues/2198) by [@Midnighter](https://github.com/Midnighter)
+* add `allow_mutation` constraint to `Field`, [#2195](https://github.com/samuelcolvin/pydantic/issues/2195) by [@sblack-usu](https://github.com/sblack-usu)
+* Allow `Field` with a `default_factory` to be used as an argument to a function
+  decorated with `validate_arguments`, [#2176](https://github.com/samuelcolvin/pydantic/issues/2176) by [@thomascobb](https://github.com/thomascobb)
+* Allow non-existent secrets directory by only issuing a warning, [#2175](https://github.com/samuelcolvin/pydantic/issues/2175) by [@davidolrik](https://github.com/davidolrik)
+* fix URL regex to parse fragment without query string, [#2168](https://github.com/samuelcolvin/pydantic/issues/2168) by [@andrewmwhite](https://github.com/andrewmwhite)
+* fix: ensure to always return one of the values in `Literal` field type, [#2166](https://github.com/samuelcolvin/pydantic/issues/2166) by [@PrettyWood](https://github.com/PrettyWood)
+* Support `typing.Annotated` hints on model fields. A `Field` may now be set in the type hint with `Annotated[..., Field(...)`; all other annotations are ignored but still visible with `get_type_hints(..., include_extras=True)`, [#2147](https://github.com/samuelcolvin/pydantic/issues/2147) by [@JacobHayes](https://github.com/JacobHayes)
+* Added `StrictBytes` type as well as `strict=False` option to `ConstrainedBytes`, [#2136](https://github.com/samuelcolvin/pydantic/issues/2136) by [@rlizzo](https://github.com/rlizzo)
+* added `Config.anystr_lower` and `to_lower` kwarg to `constr` and `conbytes`, [#2134](https://github.com/samuelcolvin/pydantic/issues/2134) by [@tayoogunbiyi](https://github.com/tayoogunbiyi)
+* Support plain `typing.Tuple` type, [#2132](https://github.com/samuelcolvin/pydantic/issues/2132) by [@PrettyWood](https://github.com/PrettyWood)
+* Add a bound method `validate` to functions decorated with `validate_arguments`
+  to validate parameters without actually calling the function, [#2127](https://github.com/samuelcolvin/pydantic/issues/2127) by [@PrettyWood](https://github.com/PrettyWood)
+* Add the ability to customize settings sources (add / disable / change priority order), [#2107](https://github.com/samuelcolvin/pydantic/issues/2107) by [@kozlek](https://github.com/kozlek)
+* Fix mypy complaints about most custom _pydantic_ types, [#2098](https://github.com/samuelcolvin/pydantic/issues/2098) by [@PrettyWood](https://github.com/PrettyWood)
+* Add a [Hypothesis](https://hypothesis.readthedocs.io/) plugin for easier [property-based testing](https://increment.com/testing/in-praise-of-property-based-testing/) with Pydantic's custom types - [usage details here](https://pydantic-docs.helpmanual.io/hypothesis_plugin/), [#2097](https://github.com/samuelcolvin/pydantic/issues/2097) by [@Zac-HD](https://github.com/Zac-HD)
+* add validator for `None`, `NoneType` or `Literal[None]`, [#2095](https://github.com/samuelcolvin/pydantic/issues/2095) by [@PrettyWood](https://github.com/PrettyWood)
+* Handle properly fields of type `Callable` with a default value, [#2094](https://github.com/samuelcolvin/pydantic/issues/2094) by [@PrettyWood](https://github.com/PrettyWood)
+* Updated `create_model` return type annotation to return type which inherits from `__base__` argument, [#2071](https://github.com/samuelcolvin/pydantic/issues/2071) by [@uriyyo](https://github.com/uriyyo)
+* Add merged `json_encoders` inheritance, [#2064](https://github.com/samuelcolvin/pydantic/issues/2064) by [@art049](https://github.com/art049)
+* allow overwriting `ClassVar`s in sub-models without having to re-annotate them, [#2061](https://github.com/samuelcolvin/pydantic/issues/2061) by [@layday](https://github.com/layday)
+* add default encoder for `Pattern` type, [#2045](https://github.com/samuelcolvin/pydantic/issues/2045) by [@PrettyWood](https://github.com/PrettyWood)
+* Add `NonNegativeInt`, `NonPositiveInt`, `NonNegativeFloat`, `NonPositiveFloat`, [#1975](https://github.com/samuelcolvin/pydantic/issues/1975) by [@mdavis-xyz](https://github.com/mdavis-xyz)
+* Use % for percentage in string format of colors, [#1960](https://github.com/samuelcolvin/pydantic/issues/1960) by [@EdwardBetts](https://github.com/EdwardBetts)
+* Fixed issue causing `KeyError` to be raised when building schema from multiple `BaseModel` with the same names declared in separate classes, [#1912](https://github.com/samuelcolvin/pydantic/issues/1912) by [@JSextonn](https://github.com/JSextonn)
+* Add `rediss` (Redis over SSL) protocol to `RedisDsn`
+  Allow URLs without `user` part (e.g., `rediss://:pass@localhost`), [#1911](https://github.com/samuelcolvin/pydantic/issues/1911) by [@TrDex](https://github.com/TrDex)
+* Add a new `frozen` boolean parameter to `Config` (default: `False`).
+  Setting `frozen=True` does everything that `allow_mutation=False` does, and also generates a `__hash__()` method for the model. This makes instances of the model potentially hashable if all the attributes are hashable, [#1880](https://github.com/samuelcolvin/pydantic/issues/1880) by [@rhuille](https://github.com/rhuille)
+* fix schema generation with multiple Enums having the same name, [#1857](https://github.com/samuelcolvin/pydantic/issues/1857) by [@PrettyWood](https://github.com/PrettyWood)
+* Added support for 13/19 digits VISA credit cards in `PaymentCardNumber` type, [#1416](https://github.com/samuelcolvin/pydantic/issues/1416) by [@AlexanderSov](https://github.com/AlexanderSov)
+* fix: prevent `RecursionError` while using recursive `GenericModel`s, [#1370](https://github.com/samuelcolvin/pydantic/issues/1370) by [@xppt](https://github.com/xppt)
+* use `enum` for `typing.Literal` in JSON schema, [#1350](https://github.com/samuelcolvin/pydantic/issues/1350) by [@PrettyWood](https://github.com/PrettyWood)
+* Fix: some recursive models did not require `update_forward_refs` and silently behaved incorrectly, [#1201](https://github.com/samuelcolvin/pydantic/issues/1201) by [@PrettyWood](https://github.com/PrettyWood)
+* Fix bug where generic models with fields where the typevar is nested in another type `a: List[T]` are considered to be concrete. This allows these models to be subclassed and composed as expected, [#947](https://github.com/samuelcolvin/pydantic/issues/947) by [@daviskirk](https://github.com/daviskirk)
+* Add `Config.copy_on_model_validation` flag. When set to `False`, _pydantic_ will keep models used as fields
+  untouched on validation instead of reconstructing (copying) them, [#265](https://github.com/samuelcolvin/pydantic/issues/265) by [@PrettyWood](https://github.com/PrettyWood)
+
+## v1.7.4 (2021-05-11)
+
+* **Security fix:** Fix `date` and `datetime` parsing so passing either `'infinity'` or `float('inf')` 
+  (or their negative values) does not cause an infinite loop,
+  See security advisory [CVE-2021-29510](https://github.com/samuelcolvin/pydantic/security/advisories/GHSA-5jqp-qgf6-3pvh)
+
+## v1.7.3 (2020-11-30)
+
+Thank you to pydantic's sponsors:
+@timdrijvers, [@BCarley](https://github.com/BCarley), [@chdsbd](https://github.com/chdsbd), [@tiangolo](https://github.com/tiangolo), [@matin](https://github.com/matin), [@linusg](https://github.com/linusg), [@kevinalh](https://github.com/kevinalh), [@jorgecarleitao](https://github.com/jorgecarleitao), [@koxudaxi](https://github.com/koxudaxi), [@primer-api](https://github.com/primer-api),
+@mkeen, [@meadsteve](https://github.com/meadsteve) for their kind support.
+
+* fix: set right default value for required (optional) fields, [#2142](https://github.com/samuelcolvin/pydantic/issues/2142) by [@PrettyWood](https://github.com/PrettyWood)
+* fix: support `underscore_attrs_are_private` with generic models, [#2138](https://github.com/samuelcolvin/pydantic/issues/2138) by [@PrettyWood](https://github.com/PrettyWood)
+* fix: update all modified field values in `root_validator` when `validate_assignment` is on, [#2116](https://github.com/samuelcolvin/pydantic/issues/2116) by [@PrettyWood](https://github.com/PrettyWood)
+* Allow pickling of `pydantic.dataclasses.dataclass` dynamically created from a built-in `dataclasses.dataclass`, [#2111](https://github.com/samuelcolvin/pydantic/issues/2111) by [@aimestereo](https://github.com/aimestereo)
+* Fix a regression where Enum fields would not propagate keyword arguments to the schema, [#2109](https://github.com/samuelcolvin/pydantic/issues/2109) by [@bm424](https://github.com/bm424)
+* Ignore `__doc__` as private attribute when `Config.underscore_attrs_are_private` is set, [#2090](https://github.com/samuelcolvin/pydantic/issues/2090) by [@PrettyWood](https://github.com/PrettyWood)
+
+## v1.7.2 (2020-11-01)
+
+* fix slow `GenericModel` concrete model creation, allow `GenericModel` concrete name reusing in module, [#2078](https://github.com/samuelcolvin/pydantic/issues/2078) by [@Bobronium](https://github.com/Bobronium)
+* keep the order of the fields when `validate_assignment` is set, [#2073](https://github.com/samuelcolvin/pydantic/issues/2073) by [@PrettyWood](https://github.com/PrettyWood)
+* forward all the params of the stdlib `dataclass` when converted into _pydantic_ `dataclass`, [#2065](https://github.com/samuelcolvin/pydantic/issues/2065) by [@PrettyWood](https://github.com/PrettyWood)
+
+## v1.7.1 (2020-10-28)
+
+Thank you to pydantic's sponsors:
+@timdrijvers, [@BCarley](https://github.com/BCarley), [@chdsbd](https://github.com/chdsbd), [@tiangolo](https://github.com/tiangolo), [@matin](https://github.com/matin), [@linusg](https://github.com/linusg), [@kevinalh](https://github.com/kevinalh), [@jorgecarleitao](https://github.com/jorgecarleitao), [@koxudaxi](https://github.com/koxudaxi), [@primer-api](https://github.com/primer-api), [@mkeen](https://github.com/mkeen)
+for their kind support.
+
+* fix annotation of `validate_arguments` when passing configuration as argument, [#2055](https://github.com/samuelcolvin/pydantic/issues/2055) by [@layday](https://github.com/layday)
+* Fix mypy assignment error when using `PrivateAttr`, [#2048](https://github.com/samuelcolvin/pydantic/issues/2048) by [@aphedges](https://github.com/aphedges)
+* fix `underscore_attrs_are_private` causing `TypeError` when overriding `__init__`, [#2047](https://github.com/samuelcolvin/pydantic/issues/2047) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fixed regression introduced in v1.7 involving exception handling in field validators when `validate_assignment=True`, [#2044](https://github.com/samuelcolvin/pydantic/issues/2044) by [@johnsabath](https://github.com/johnsabath)
+* fix: _pydantic_ `dataclass` can inherit from stdlib `dataclass`
+  and `Config.arbitrary_types_allowed` is supported, [#2042](https://github.com/samuelcolvin/pydantic/issues/2042) by [@PrettyWood](https://github.com/PrettyWood)
+
+## v1.7 (2020-10-26)
+
+Thank you to pydantic's sponsors:
+@timdrijvers, [@BCarley](https://github.com/BCarley), [@chdsbd](https://github.com/chdsbd), [@tiangolo](https://github.com/tiangolo), [@matin](https://github.com/matin), [@linusg](https://github.com/linusg), [@kevinalh](https://github.com/kevinalh), [@jorgecarleitao](https://github.com/jorgecarleitao), [@koxudaxi](https://github.com/koxudaxi), [@primer-api](https://github.com/primer-api) 
+for their kind support.
+
+### Highlights
+
+* python 3.9 support, thanks [@PrettyWood](https://github.com/PrettyWood)
+* [Private model attributes](https://pydantic-docs.helpmanual.io/usage/models/#private-model-attributes), thanks [@Bobronium](https://github.com/Bobronium)
+* ["secrets files" support in `BaseSettings`](https://pydantic-docs.helpmanual.io/usage/settings/#secret-support), thanks [@mdgilene](https://github.com/mdgilene)
+* [convert stdlib dataclasses to pydantic dataclasses and use stdlib dataclasses in models](https://pydantic-docs.helpmanual.io/usage/dataclasses/#stdlib-dataclasses-and-pydantic-dataclasses), thanks [@PrettyWood](https://github.com/PrettyWood)
+
+### Changes
+
+* **Breaking Change:** remove `__field_defaults__`, add `default_factory` support with `BaseModel.construct`.
+  Use `.get_default()` method on fields in `__fields__` attribute instead, [#1732](https://github.com/samuelcolvin/pydantic/issues/1732) by [@PrettyWood](https://github.com/PrettyWood)
+* Rearrange CI to run linting as a separate job, split install recipes for different tasks, [#2020](https://github.com/samuelcolvin/pydantic/issues/2020) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Allows subclasses of generic models to make some, or all, of the superclass's type parameters concrete, while 
+  also defining new type parameters in the subclass, [#2005](https://github.com/samuelcolvin/pydantic/issues/2005) by [@choogeboom](https://github.com/choogeboom)
+* Call validator with the correct `values` parameter type in `BaseModel.__setattr__`,
+  when `validate_assignment = True` in model config, [#1999](https://github.com/samuelcolvin/pydantic/issues/1999) by [@me-ransh](https://github.com/me-ransh)
+* Force `fields.Undefined` to be a singleton object, fixing inherited generic model schemas, [#1981](https://github.com/samuelcolvin/pydantic/issues/1981) by [@daviskirk](https://github.com/daviskirk)
+* Include tests in source distributions, [#1976](https://github.com/samuelcolvin/pydantic/issues/1976) by [@sbraz](https://github.com/sbraz)
+* Add ability to use `min_length/max_length` constraints with secret types, [#1974](https://github.com/samuelcolvin/pydantic/issues/1974) by [@uriyyo](https://github.com/uriyyo)
+* Also check `root_validators` when `validate_assignment` is on, [#1971](https://github.com/samuelcolvin/pydantic/issues/1971) by [@PrettyWood](https://github.com/PrettyWood)
+* Fix const validators not running when custom validators are present, [#1957](https://github.com/samuelcolvin/pydantic/issues/1957) by [@hmvp](https://github.com/hmvp)
+* add `deque` to field types, [#1935](https://github.com/samuelcolvin/pydantic/issues/1935) by [@wozniakty](https://github.com/wozniakty)
+* add basic support for python 3.9, [#1832](https://github.com/samuelcolvin/pydantic/issues/1832) by [@PrettyWood](https://github.com/PrettyWood)
+* Fix typo in the anchor of exporting_models.md#modelcopy and incorrect description, [#1821](https://github.com/samuelcolvin/pydantic/issues/1821) by [@KimMachineGun](https://github.com/KimMachineGun)
+* Added ability for `BaseSettings` to read "secret files", [#1820](https://github.com/samuelcolvin/pydantic/issues/1820) by [@mdgilene](https://github.com/mdgilene)
+* add `parse_raw_as` utility function, [#1812](https://github.com/samuelcolvin/pydantic/issues/1812) by [@PrettyWood](https://github.com/PrettyWood)
+* Support home directory relative paths for `dotenv` files (e.g. `~/.env`), [#1803](https://github.com/samuelcolvin/pydantic/issues/1803) by [@PrettyWood](https://github.com/PrettyWood)
+* Clarify documentation for `parse_file` to show that the argument
+  should be a file *path* not a file-like object, [#1794](https://github.com/samuelcolvin/pydantic/issues/1794) by [@mdavis-xyz](https://github.com/mdavis-xyz)
+* Fix false positive from mypy plugin when a class nested within a `BaseModel` is named `Model`, [#1770](https://github.com/samuelcolvin/pydantic/issues/1770) by [@selimb](https://github.com/selimb)
+* add basic support of Pattern type in schema generation, [#1767](https://github.com/samuelcolvin/pydantic/issues/1767) by [@PrettyWood](https://github.com/PrettyWood)
+* Support custom title, description and default in schema of enums, [#1748](https://github.com/samuelcolvin/pydantic/issues/1748) by [@PrettyWood](https://github.com/PrettyWood)
+* Properly represent `Literal` Enums when `use_enum_values` is True, [#1747](https://github.com/samuelcolvin/pydantic/issues/1747) by [@noelevans](https://github.com/noelevans)
+* Allows timezone information to be added to strings to be formatted as time objects. Permitted formats are `Z` for UTC 
+  or an offset for absolute positive or negative time shifts. Or the timezone data can be omitted, [#1744](https://github.com/samuelcolvin/pydantic/issues/1744) by [@noelevans](https://github.com/noelevans)
+* Add stub `__init__` with python 3.6 signature for `ForwardRef`, [#1738](https://github.com/samuelcolvin/pydantic/issues/1738) by [@sirtelemak](https://github.com/sirtelemak)
+* Fix behaviour with forward refs and optional fields in nested models, [#1736](https://github.com/samuelcolvin/pydantic/issues/1736) by [@PrettyWood](https://github.com/PrettyWood)
+* add `Enum` and `IntEnum` as valid types for fields, [#1735](https://github.com/samuelcolvin/pydantic/issues/1735) by [@PrettyWood](https://github.com/PrettyWood)
+* Change default value of `__module__` argument of `create_model` from `None` to `'pydantic.main'`. 
+  Set reference of created concrete model to it's module to allow pickling (not applied to models created in 
+  functions), [#1686](https://github.com/samuelcolvin/pydantic/issues/1686) by [@Bobronium](https://github.com/Bobronium)
+* Add private attributes support, [#1679](https://github.com/samuelcolvin/pydantic/issues/1679) by [@Bobronium](https://github.com/Bobronium)
+* add `config` to `@validate_arguments`, [#1663](https://github.com/samuelcolvin/pydantic/issues/1663) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Allow descendant Settings models to override env variable names for the fields defined in parent Settings models with 
+  `env` in their `Config`. Previously only `env_prefix` configuration option was applicable, [#1561](https://github.com/samuelcolvin/pydantic/issues/1561) by [@ojomio](https://github.com/ojomio)
+* Support `ref_template` when creating schema `$ref`s, [#1479](https://github.com/samuelcolvin/pydantic/issues/1479) by [@kilo59](https://github.com/kilo59)
+* Add a `__call__` stub to `PyObject` so that mypy will know that it is callable, [#1352](https://github.com/samuelcolvin/pydantic/issues/1352) by [@brianmaissy](https://github.com/brianmaissy)
+* `pydantic.dataclasses.dataclass` decorator now supports built-in `dataclasses.dataclass`.
+  It is hence possible to convert an existing `dataclass` easily to add *pydantic* validation.
+  Moreover nested dataclasses are also supported, [#744](https://github.com/samuelcolvin/pydantic/issues/744) by [@PrettyWood](https://github.com/PrettyWood)
+
+## v1.6.2 (2021-05-11)
+
+* **Security fix:** Fix `date` and `datetime` parsing so passing either `'infinity'` or `float('inf')` 
+  (or their negative values) does not cause an infinite loop,
+  See security advisory [CVE-2021-29510](https://github.com/samuelcolvin/pydantic/security/advisories/GHSA-5jqp-qgf6-3pvh)
+
+## v1.6.1 (2020-07-15)
+
+* fix validation and parsing of nested models with `default_factory`, [#1710](https://github.com/samuelcolvin/pydantic/issues/1710) by [@PrettyWood](https://github.com/PrettyWood)
+
+## v1.6 (2020-07-11)
+
+Thank you to pydantic's sponsors: [@matin](https://github.com/matin), [@tiangolo](https://github.com/tiangolo), [@chdsbd](https://github.com/chdsbd), [@jorgecarleitao](https://github.com/jorgecarleitao), and 1 anonymous sponsor for their kind support.
+
+* Modify validators for `conlist` and `conset` to not have `always=True`, [#1682](https://github.com/samuelcolvin/pydantic/issues/1682) by [@samuelcolvin](https://github.com/samuelcolvin)
+* add port check to `AnyUrl` (can't exceed 65536) ports are 16 insigned bits: `0 <= port <= 2**16-1` src: [rfc793 header format](https://tools.ietf.org/html/rfc793#section-3.1), [#1654](https://github.com/samuelcolvin/pydantic/issues/1654) by [@flapili](https://github.com/flapili)
+* Document default `regex` anchoring semantics, [#1648](https://github.com/samuelcolvin/pydantic/issues/1648) by [@yurikhan](https://github.com/yurikhan)
+* Use `chain.from_iterable` in class_validators.py. This is a faster and more idiomatic way of using `itertools.chain`.
+  Instead of computing all the items in the iterable and storing them in memory, they are computed one-by-one and never
+  stored as a huge list. This can save on both runtime and memory space, [#1642](https://github.com/samuelcolvin/pydantic/issues/1642) by [@cool-RR](https://github.com/cool-RR)
+* Add `conset()`, analogous to `conlist()`, [#1623](https://github.com/samuelcolvin/pydantic/issues/1623) by [@patrickkwang](https://github.com/patrickkwang)
+* make *pydantic* errors (un)pickable, [#1616](https://github.com/samuelcolvin/pydantic/issues/1616) by [@PrettyWood](https://github.com/PrettyWood)
+* Allow custom encoding for `dotenv` files, [#1615](https://github.com/samuelcolvin/pydantic/issues/1615) by [@PrettyWood](https://github.com/PrettyWood)
+* Ensure `SchemaExtraCallable` is always defined to get type hints on BaseConfig, [#1614](https://github.com/samuelcolvin/pydantic/issues/1614) by [@PrettyWood](https://github.com/PrettyWood)
+* Update datetime parser to support negative timestamps, [#1600](https://github.com/samuelcolvin/pydantic/issues/1600) by [@mlbiche](https://github.com/mlbiche)
+* Update mypy, remove `AnyType` alias for `Type[Any]`, [#1598](https://github.com/samuelcolvin/pydantic/issues/1598) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Adjust handling of root validators so that errors are aggregated from _all_ failing root validators, instead of reporting on only the first root validator to fail, [#1586](https://github.com/samuelcolvin/pydantic/issues/1586) by [@beezee](https://github.com/beezee)
+* Make `__modify_schema__` on Enums apply to the enum schema rather than fields that use the enum, [#1581](https://github.com/samuelcolvin/pydantic/issues/1581) by [@therefromhere](https://github.com/therefromhere)
+* Fix behavior of `__all__` key when used in conjunction with index keys in advanced include/exclude of fields that are sequences, [#1579](https://github.com/samuelcolvin/pydantic/issues/1579) by [@xspirus](https://github.com/xspirus)
+* Subclass validators do not run when referencing a `List` field defined in a parent class when `each_item=True`. Added an example to the docs illustrating this, [#1566](https://github.com/samuelcolvin/pydantic/issues/1566) by [@samueldeklund](https://github.com/samueldeklund)
+* change `schema.field_class_to_schema` to support `frozenset` in schema, [#1557](https://github.com/samuelcolvin/pydantic/issues/1557) by [@wangpeibao](https://github.com/wangpeibao)
+* Call `__modify_schema__` only for the field schema, [#1552](https://github.com/samuelcolvin/pydantic/issues/1552) by [@PrettyWood](https://github.com/PrettyWood)
+* Move the assignment of `field.validate_always` in `fields.py` so the `always` parameter of validators work on inheritance, [#1545](https://github.com/samuelcolvin/pydantic/issues/1545) by [@dcHHH](https://github.com/dcHHH)
+* Added support for UUID instantiation through 16 byte strings such as `b'\x12\x34\x56\x78' * 4`. This was done to support `BINARY(16)` columns in sqlalchemy, [#1541](https://github.com/samuelcolvin/pydantic/issues/1541) by [@shawnwall](https://github.com/shawnwall)
+* Add a test assertion that `default_factory` can return a singleton, [#1523](https://github.com/samuelcolvin/pydantic/issues/1523) by [@therefromhere](https://github.com/therefromhere)
+* Add `NameEmail.__eq__` so duplicate `NameEmail` instances are evaluated as equal, [#1514](https://github.com/samuelcolvin/pydantic/issues/1514) by [@stephen-bunn](https://github.com/stephen-bunn)
+* Add datamodel-code-generator link in pydantic document site, [#1500](https://github.com/samuelcolvin/pydantic/issues/1500) by [@koxudaxi](https://github.com/koxudaxi)
+* Added a "Discussion of Pydantic" section to the documentation, with a link to "Pydantic Introduction" video by Alexander Hultnér, [#1499](https://github.com/samuelcolvin/pydantic/issues/1499) by [@hultner](https://github.com/hultner)
+* Avoid some side effects of `default_factory` by calling it only once
+  if possible and by not setting a default value in the schema, [#1491](https://github.com/samuelcolvin/pydantic/issues/1491) by [@PrettyWood](https://github.com/PrettyWood)
+* Added docs about dumping dataclasses to JSON, [#1487](https://github.com/samuelcolvin/pydantic/issues/1487) by [@mikegrima](https://github.com/mikegrima)
+* Make `BaseModel.__signature__` class-only, so getting `__signature__` from model instance will raise `AttributeError`, [#1466](https://github.com/samuelcolvin/pydantic/issues/1466) by [@Bobronium](https://github.com/Bobronium)
+* include `'format': 'password'` in the schema for secret types, [#1424](https://github.com/samuelcolvin/pydantic/issues/1424) by [@atheuz](https://github.com/atheuz)
+* Modify schema constraints on `ConstrainedFloat` so that `exclusiveMinimum` and
+  minimum are not included in the schema if they are equal to `-math.inf` and
+  `exclusiveMaximum` and `maximum` are not included if they are equal to `math.inf`, [#1417](https://github.com/samuelcolvin/pydantic/issues/1417) by [@vdwees](https://github.com/vdwees)
+* Squash internal `__root__` dicts in `.dict()` (and, by extension, in `.json()`), [#1414](https://github.com/samuelcolvin/pydantic/issues/1414) by [@patrickkwang](https://github.com/patrickkwang)
+* Move `const` validator to post-validators so it validates the parsed value, [#1410](https://github.com/samuelcolvin/pydantic/issues/1410) by [@selimb](https://github.com/selimb)
+* Fix model validation to handle nested literals, e.g. `Literal['foo', Literal['bar']]`, [#1364](https://github.com/samuelcolvin/pydantic/issues/1364) by [@DBCerigo](https://github.com/DBCerigo)
+* Remove `user_required = True` from `RedisDsn`, neither user nor password are required, [#1275](https://github.com/samuelcolvin/pydantic/issues/1275) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Remove extra `allOf` from schema for fields with `Union` and custom `Field`, [#1209](https://github.com/samuelcolvin/pydantic/issues/1209) by [@mostaphaRoudsari](https://github.com/mostaphaRoudsari)
+* Updates OpenAPI schema generation to output all enums as separate models.
+  Instead of inlining the enum values in the model schema, models now use a `$ref`
+  property to point to the enum definition, [#1173](https://github.com/samuelcolvin/pydantic/issues/1173) by [@calvinwyoung](https://github.com/calvinwyoung)
+
+## v1.5.1 (2020-04-23)
+
+* Signature generation with `extra: allow` never uses a field name, [#1418](https://github.com/samuelcolvin/pydantic/issues/1418) by [@prettywood](https://github.com/prettywood)
+* Avoid mutating `Field` default value, [#1412](https://github.com/samuelcolvin/pydantic/issues/1412) by [@prettywood](https://github.com/prettywood)
+
+## v1.5 (2020-04-18)
+
+* Make includes/excludes arguments for `.dict()`, `._iter()`, ..., immutable, [#1404](https://github.com/samuelcolvin/pydantic/issues/1404) by [@AlexECX](https://github.com/AlexECX)
+* Always use a field's real name with includes/excludes in `model._iter()`, regardless of `by_alias`, [#1397](https://github.com/samuelcolvin/pydantic/issues/1397) by [@AlexECX](https://github.com/AlexECX)
+* Update constr regex example to include start and end lines, [#1396](https://github.com/samuelcolvin/pydantic/issues/1396) by [@lmcnearney](https://github.com/lmcnearney)
+* Confirm that shallow `model.copy()` does make a shallow copy of attributes, [#1383](https://github.com/samuelcolvin/pydantic/issues/1383) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Renaming `model_name` argument of `main.create_model()` to `__model_name` to allow using `model_name` as a field name, [#1367](https://github.com/samuelcolvin/pydantic/issues/1367) by [@kittipatv](https://github.com/kittipatv)
+* Replace raising of exception to silent passing  for non-Var attributes in mypy plugin, [#1345](https://github.com/samuelcolvin/pydantic/issues/1345) by [@b0g3r](https://github.com/b0g3r)
+* Remove `typing_extensions` dependency for python 3.8, [#1342](https://github.com/samuelcolvin/pydantic/issues/1342) by [@prettywood](https://github.com/prettywood)
+* Make `SecretStr` and `SecretBytes` initialization idempotent, [#1330](https://github.com/samuelcolvin/pydantic/issues/1330) by [@atheuz](https://github.com/atheuz)
+* document making secret types dumpable using the json method, [#1328](https://github.com/samuelcolvin/pydantic/issues/1328) by [@atheuz](https://github.com/atheuz)
+* Move all testing and build to github actions, add windows and macos binaries, 
+  thank you [@StephenBrown2](https://github.com/StephenBrown2) for much help, [#1326](https://github.com/samuelcolvin/pydantic/issues/1326) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix card number length check in `PaymentCardNumber`, `PaymentCardBrand` now inherits from `str`, [#1317](https://github.com/samuelcolvin/pydantic/issues/1317) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Have `BaseModel` inherit from `Representation` to make mypy happy when overriding `__str__`, [#1310](https://github.com/samuelcolvin/pydantic/issues/1310) by [@FuegoFro](https://github.com/FuegoFro)
+* Allow `None` as input to all optional list fields, [#1307](https://github.com/samuelcolvin/pydantic/issues/1307) by [@prettywood](https://github.com/prettywood)
+* Add `datetime` field to `default_factory` example, [#1301](https://github.com/samuelcolvin/pydantic/issues/1301) by [@StephenBrown2](https://github.com/StephenBrown2)
+* Allow subclasses of known types to be encoded with superclass encoder, [#1291](https://github.com/samuelcolvin/pydantic/issues/1291) by [@StephenBrown2](https://github.com/StephenBrown2)
+* Exclude exported fields from all elements of a list/tuple of submodels/dicts with `'__all__'`, [#1286](https://github.com/samuelcolvin/pydantic/issues/1286) by [@masalim2](https://github.com/masalim2)
+* Add pydantic.color.Color objects as available input for Color fields, [#1258](https://github.com/samuelcolvin/pydantic/issues/1258) by [@leosussan](https://github.com/leosussan)
+* In examples, type nullable fields as `Optional`, so that these are valid mypy annotations, [#1248](https://github.com/samuelcolvin/pydantic/issues/1248) by [@kokes](https://github.com/kokes)
+* Make `pattern_validator()` accept pre-compiled `Pattern` objects. Fix `str_validator()` return type to `str`, [#1237](https://github.com/samuelcolvin/pydantic/issues/1237) by [@adamgreg](https://github.com/adamgreg)
+* Document how to manage Generics and inheritance, [#1229](https://github.com/samuelcolvin/pydantic/issues/1229) by [@esadruhn](https://github.com/esadruhn)
+* `update_forward_refs()` method of BaseModel now copies `__dict__` of class module instead of modyfying it, [#1228](https://github.com/samuelcolvin/pydantic/issues/1228) by [@paul-ilyin](https://github.com/paul-ilyin)
+* Support instance methods and class methods with `@validate_arguments`, [#1222](https://github.com/samuelcolvin/pydantic/issues/1222) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Add `default_factory` argument to `Field` to create a dynamic default value by passing a zero-argument callable, [#1210](https://github.com/samuelcolvin/pydantic/issues/1210) by [@prettywood](https://github.com/prettywood)
+* add support for `NewType` of `List`, `Optional`, etc, [#1207](https://github.com/samuelcolvin/pydantic/issues/1207) by [@Kazy](https://github.com/Kazy)
+* fix mypy signature for `root_validator`, [#1192](https://github.com/samuelcolvin/pydantic/issues/1192) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fixed parsing of nested 'custom root type' models, [#1190](https://github.com/samuelcolvin/pydantic/issues/1190) by [@Shados](https://github.com/Shados)
+* Add `validate_arguments` function decorator which checks the arguments to a function matches type annotations, [#1179](https://github.com/samuelcolvin/pydantic/issues/1179) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Add `__signature__` to models, [#1034](https://github.com/samuelcolvin/pydantic/issues/1034) by [@Bobronium](https://github.com/Bobronium)
+* Refactor `._iter()` method, 10x speed boost for `dict(model)`, [#1017](https://github.com/samuelcolvin/pydantic/issues/1017) by [@Bobronium](https://github.com/Bobronium)
+
+## v1.4 (2020-01-24)
+
+* **Breaking Change:** alias precedence logic changed so aliases on a field always take priority over
+  an alias from `alias_generator` to avoid buggy/unexpected behaviour,
+  see [here](https://pydantic-docs.helpmanual.io/usage/model_config/#alias-precedence) for details, [#1178](https://github.com/samuelcolvin/pydantic/issues/1178) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Add support for unicode and punycode in TLDs, [#1182](https://github.com/samuelcolvin/pydantic/issues/1182) by [@jamescurtin](https://github.com/jamescurtin)
+* Fix `cls` argument in validators during assignment, [#1172](https://github.com/samuelcolvin/pydantic/issues/1172) by [@samuelcolvin](https://github.com/samuelcolvin)
+* completing Luhn algorithm for `PaymentCardNumber`, [#1166](https://github.com/samuelcolvin/pydantic/issues/1166) by [@cuencandres](https://github.com/cuencandres)
+* add support for generics that implement `__get_validators__` like a custom data type, [#1159](https://github.com/samuelcolvin/pydantic/issues/1159) by [@tiangolo](https://github.com/tiangolo)
+* add support for infinite generators with `Iterable`, [#1152](https://github.com/samuelcolvin/pydantic/issues/1152) by [@tiangolo](https://github.com/tiangolo)
+* fix `url_regex` to accept schemas with `+`, `-` and `.` after the first character, [#1142](https://github.com/samuelcolvin/pydantic/issues/1142) by [@samuelcolvin](https://github.com/samuelcolvin)
+* move `version_info()` to `version.py`, suggest its use in issues, [#1138](https://github.com/samuelcolvin/pydantic/issues/1138) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Improve pydantic import time by roughly 50% by deferring some module loading and regex compilation, [#1127](https://github.com/samuelcolvin/pydantic/issues/1127) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix `EmailStr` and `NameEmail` to accept instances of themselves in cython, [#1126](https://github.com/samuelcolvin/pydantic/issues/1126) by [@koxudaxi](https://github.com/koxudaxi)
+* Pass model class to the `Config.schema_extra` callable, [#1125](https://github.com/samuelcolvin/pydantic/issues/1125) by [@therefromhere](https://github.com/therefromhere)
+* Fix regex for username and password in URLs, [#1115](https://github.com/samuelcolvin/pydantic/issues/1115) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Add support for nested generic models, [#1104](https://github.com/samuelcolvin/pydantic/issues/1104) by [@dmontagu](https://github.com/dmontagu)
+* add `__all__` to `__init__.py` to prevent "implicit reexport" errors from mypy, [#1072](https://github.com/samuelcolvin/pydantic/issues/1072) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Add support for using "dotenv" files with `BaseSettings`, [#1011](https://github.com/samuelcolvin/pydantic/issues/1011) by [@acnebs](https://github.com/acnebs)
+
+## v1.3 (2019-12-21)
+
+* Change `schema` and `schema_model` to handle dataclasses by using their `__pydantic_model__` feature, [#792](https://github.com/samuelcolvin/pydantic/issues/792) by [@aviramha](https://github.com/aviramha)
+* Added option for `root_validator` to be skipped if values validation fails using keyword `skip_on_failure=True`, [#1049](https://github.com/samuelcolvin/pydantic/issues/1049) by [@aviramha](https://github.com/aviramha)
+* Allow `Config.schema_extra` to be a callable so that the generated schema can be post-processed, [#1054](https://github.com/samuelcolvin/pydantic/issues/1054) by [@selimb](https://github.com/selimb)
+* Update mypy to version 0.750, [#1057](https://github.com/samuelcolvin/pydantic/issues/1057) by [@dmontagu](https://github.com/dmontagu)
+* Trick Cython into allowing str subclassing, [#1061](https://github.com/samuelcolvin/pydantic/issues/1061) by [@skewty](https://github.com/skewty)
+* Prevent type attributes being added to schema unless the attribute `__schema_attributes__` is `True`, [#1064](https://github.com/samuelcolvin/pydantic/issues/1064) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Change `BaseModel.parse_file` to use `Config.json_loads`, [#1067](https://github.com/samuelcolvin/pydantic/issues/1067) by [@kierandarcy](https://github.com/kierandarcy)
+* Fix for optional `Json` fields, [#1073](https://github.com/samuelcolvin/pydantic/issues/1073) by [@volker48](https://github.com/volker48)
+* Change the default number of threads used when compiling with cython to one,
+  allow override via the `CYTHON_NTHREADS` environment variable, [#1074](https://github.com/samuelcolvin/pydantic/issues/1074) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Run FastAPI tests during Pydantic's CI tests, [#1075](https://github.com/samuelcolvin/pydantic/issues/1075) by [@tiangolo](https://github.com/tiangolo)
+* My mypy strictness constraints, and associated tweaks to type annotations, [#1077](https://github.com/samuelcolvin/pydantic/issues/1077) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Add `__eq__` to SecretStr and SecretBytes to allow "value equals", [#1079](https://github.com/samuelcolvin/pydantic/issues/1079) by [@sbv-trueenergy](https://github.com/sbv-trueenergy)
+* Fix schema generation for nested None case, [#1088](https://github.com/samuelcolvin/pydantic/issues/1088) by [@lutostag](https://github.com/lutostag)
+* Consistent checks for sequence like objects, [#1090](https://github.com/samuelcolvin/pydantic/issues/1090) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix `Config` inheritance on `BaseSettings` when used with `env_prefix`, [#1091](https://github.com/samuelcolvin/pydantic/issues/1091) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix for `__modify_schema__` when it conflicted with `field_class_to_schema*`, [#1102](https://github.com/samuelcolvin/pydantic/issues/1102) by [@samuelcolvin](https://github.com/samuelcolvin)
+* docs: Fix explanation of case sensitive environment variable names when populating `BaseSettings` subclass attributes, [#1105](https://github.com/samuelcolvin/pydantic/issues/1105) by [@tribals](https://github.com/tribals)
+* Rename django-rest-framework benchmark in documentation, [#1119](https://github.com/samuelcolvin/pydantic/issues/1119) by [@frankie567](https://github.com/frankie567)
+
+## v1.2 (2019-11-28)
+
+* **Possible Breaking Change:** Add support for required `Optional` with `name: Optional[AnyType] = Field(...)`
+  and refactor `ModelField` creation to preserve `required` parameter value, [#1031](https://github.com/samuelcolvin/pydantic/issues/1031) by [@tiangolo](https://github.com/tiangolo);
+  see [here](https://pydantic-docs.helpmanual.io/usage/models/#required-optional-fields) for details
+* Add benchmarks for `cattrs`, [#513](https://github.com/samuelcolvin/pydantic/issues/513) by [@sebastianmika](https://github.com/sebastianmika)
+* Add `exclude_none` option to `dict()` and friends, [#587](https://github.com/samuelcolvin/pydantic/issues/587) by [@niknetniko](https://github.com/niknetniko)
+* Add benchmarks for `valideer`, [#670](https://github.com/samuelcolvin/pydantic/issues/670) by [@gsakkis](https://github.com/gsakkis)
+* Add `parse_obj_as` and `parse_file_as` functions for ad-hoc parsing of data into arbitrary pydantic-compatible types, [#934](https://github.com/samuelcolvin/pydantic/issues/934) by [@dmontagu](https://github.com/dmontagu)
+* Add `allow_reuse` argument to validators, thus allowing validator reuse, [#940](https://github.com/samuelcolvin/pydantic/issues/940) by [@dmontagu](https://github.com/dmontagu)
+* Add support for mapping types for custom root models, [#958](https://github.com/samuelcolvin/pydantic/issues/958) by [@dmontagu](https://github.com/dmontagu)
+* Mypy plugin support for dataclasses, [#966](https://github.com/samuelcolvin/pydantic/issues/966) by [@koxudaxi](https://github.com/koxudaxi)
+* Add support for dataclasses default factory, [#968](https://github.com/samuelcolvin/pydantic/issues/968) by [@ahirner](https://github.com/ahirner)
+* Add a `ByteSize` type for converting byte string (`1GB`) to plain bytes, [#977](https://github.com/samuelcolvin/pydantic/issues/977) by [@dgasmith](https://github.com/dgasmith)
+* Fix mypy complaint about `@root_validator(pre=True)`, [#984](https://github.com/samuelcolvin/pydantic/issues/984) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Add manylinux binaries for python 3.8 to pypi, also support manylinux2010, [#994](https://github.com/samuelcolvin/pydantic/issues/994) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Adds ByteSize conversion to another unit, [#995](https://github.com/samuelcolvin/pydantic/issues/995) by [@dgasmith](https://github.com/dgasmith)
+* Fix `__str__` and `__repr__` inheritance for models, [#1022](https://github.com/samuelcolvin/pydantic/issues/1022) by [@samuelcolvin](https://github.com/samuelcolvin)
+* add testimonials section to docs, [#1025](https://github.com/samuelcolvin/pydantic/issues/1025) by [@sullivancolin](https://github.com/sullivancolin)
+* Add support for `typing.Literal` for Python 3.8, [#1026](https://github.com/samuelcolvin/pydantic/issues/1026) by [@dmontagu](https://github.com/dmontagu)
+
+## v1.1.1 (2019-11-20)
+
+* Fix bug where use of complex fields on sub-models could cause fields to be incorrectly configured, [#1015](https://github.com/samuelcolvin/pydantic/issues/1015) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v1.1 (2019-11-07)
+
+* Add a mypy plugin for type checking `BaseModel.__init__` and more, [#722](https://github.com/samuelcolvin/pydantic/issues/722) by [@dmontagu](https://github.com/dmontagu)
+* Change return type typehint for `GenericModel.__class_getitem__` to prevent PyCharm warnings, [#936](https://github.com/samuelcolvin/pydantic/issues/936) by [@dmontagu](https://github.com/dmontagu)
+* Fix usage of `Any` to allow `None`, also support `TypeVar` thus allowing use of un-parameterised collection types
+  e.g. `Dict` and `List`, [#962](https://github.com/samuelcolvin/pydantic/issues/962) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Set `FieldInfo` on subfields to fix schema generation for complex nested types, [#965](https://github.com/samuelcolvin/pydantic/issues/965) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v1.0 (2019-10-23)
+
+* **Breaking Change:** deprecate the `Model.fields` property, use `Model.__fields__` instead, [#883](https://github.com/samuelcolvin/pydantic/issues/883) by [@samuelcolvin](https://github.com/samuelcolvin)
+* **Breaking Change:** Change the precedence of aliases so child model aliases override parent aliases,
+  including using `alias_generator`, [#904](https://github.com/samuelcolvin/pydantic/issues/904) by [@samuelcolvin](https://github.com/samuelcolvin)
+* **Breaking change:** Rename `skip_defaults` to `exclude_unset`, and add ability to exclude actual defaults, [#915](https://github.com/samuelcolvin/pydantic/issues/915) by [@dmontagu](https://github.com/dmontagu)
+* Add `**kwargs` to `pydantic.main.ModelMetaclass.__new__` so `__init_subclass__` can take custom parameters on extended
+  `BaseModel` classes, [#867](https://github.com/samuelcolvin/pydantic/issues/867) by [@retnikt](https://github.com/retnikt)
+* Fix field of a type that has a default value, [#880](https://github.com/samuelcolvin/pydantic/issues/880) by [@koxudaxi](https://github.com/koxudaxi)
+* Use `FutureWarning` instead of `DeprecationWarning` when `alias` instead of `env` is used for settings models, [#881](https://github.com/samuelcolvin/pydantic/issues/881) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix issue with `BaseSettings` inheritance and `alias` getting set to `None`, [#882](https://github.com/samuelcolvin/pydantic/issues/882) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Modify `__repr__` and `__str__` methods to be consistent across all public classes, add `__pretty__` to support
+  python-devtools, [#884](https://github.com/samuelcolvin/pydantic/issues/884) by [@samuelcolvin](https://github.com/samuelcolvin)
+* deprecation warning for `case_insensitive` on `BaseSettings` config, [#885](https://github.com/samuelcolvin/pydantic/issues/885) by [@samuelcolvin](https://github.com/samuelcolvin)
+* For `BaseSettings` merge environment variables and in-code values recursively, as long as they create a valid object
+  when merged together, to allow splitting init arguments, [#888](https://github.com/samuelcolvin/pydantic/issues/888) by [@idmitrievsky](https://github.com/idmitrievsky)
+* change secret types example, [#890](https://github.com/samuelcolvin/pydantic/issues/890) by [@ashears](https://github.com/ashears)
+* Change the signature of `Model.construct()` to be more user-friendly, document `construct()` usage, [#898](https://github.com/samuelcolvin/pydantic/issues/898) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Add example for the `construct()` method, [#907](https://github.com/samuelcolvin/pydantic/issues/907) by [@ashears](https://github.com/ashears)
+* Improve use of `Field` constraints on complex types, raise an error if constraints are not enforceable,
+  also support tuples with an ellipsis `Tuple[X, ...]`, `Sequence` and `FrozenSet` in schema, [#909](https://github.com/samuelcolvin/pydantic/issues/909) by [@samuelcolvin](https://github.com/samuelcolvin)
+* update docs for bool missing valid value, [#911](https://github.com/samuelcolvin/pydantic/issues/911) by [@trim21](https://github.com/trim21)
+* Better `str`/`repr` logic for `ModelField`, [#912](https://github.com/samuelcolvin/pydantic/issues/912) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix `ConstrainedList`, update schema generation to reflect `min_items` and `max_items` `Field()` arguments, [#917](https://github.com/samuelcolvin/pydantic/issues/917) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Allow abstracts sets (eg. dict keys) in the `include` and `exclude` arguments of `dict()`, [#921](https://github.com/samuelcolvin/pydantic/issues/921) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix JSON serialization errors on `ValidationError.json()` by using `pydantic_encoder`, [#922](https://github.com/samuelcolvin/pydantic/issues/922) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Clarify usage of `remove_untouched`, improve error message for types with no validators, [#926](https://github.com/samuelcolvin/pydantic/issues/926) by [@retnikt](https://github.com/retnikt)
+
+## v1.0b2 (2019-10-07)
+
+* Mark `StrictBool` typecheck as `bool` to allow for default values without mypy errors, [#690](https://github.com/samuelcolvin/pydantic/issues/690) by [@dmontagu](https://github.com/dmontagu)
+* Transfer the documentation build from sphinx to mkdocs, re-write much of the documentation, [#856](https://github.com/samuelcolvin/pydantic/issues/856) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Add support for custom naming schemes for `GenericModel` subclasses, [#859](https://github.com/samuelcolvin/pydantic/issues/859) by [@dmontagu](https://github.com/dmontagu)
+* Add `if TYPE_CHECKING:` to the excluded lines for test coverage, [#874](https://github.com/samuelcolvin/pydantic/issues/874) by [@dmontagu](https://github.com/dmontagu)
+* Rename `allow_population_by_alias` to `allow_population_by_field_name`, remove unnecessary warning about it, [#875](https://github.com/samuelcolvin/pydantic/issues/875) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v1.0b1 (2019-10-01)
+
+* **Breaking Change:** rename `Schema` to `Field`, make it a function to placate mypy, [#577](https://github.com/samuelcolvin/pydantic/issues/577) by [@samuelcolvin](https://github.com/samuelcolvin)
+* **Breaking Change:** modify parsing behavior for `bool`, [#617](https://github.com/samuelcolvin/pydantic/issues/617) by [@dmontagu](https://github.com/dmontagu)
+* **Breaking Change:** `get_validators` is no longer recognised, use `__get_validators__`.
+  `Config.ignore_extra` and `Config.allow_extra` are no longer recognised, use `Config.extra`, [#720](https://github.com/samuelcolvin/pydantic/issues/720) by [@samuelcolvin](https://github.com/samuelcolvin)
+* **Breaking Change:** modify default config settings for `BaseSettings`; `case_insensitive` renamed to `case_sensitive`,
+  default changed to `case_sensitive = False`, `env_prefix` default changed to `''` - e.g. no prefix, [#721](https://github.com/samuelcolvin/pydantic/issues/721) by [@dmontagu](https://github.com/dmontagu)
+* **Breaking change:** Implement `root_validator` and rename root errors from `__obj__` to `__root__`, [#729](https://github.com/samuelcolvin/pydantic/issues/729) by [@samuelcolvin](https://github.com/samuelcolvin)
+* **Breaking Change:** alter the behaviour of `dict(model)` so that sub-models are nolonger
+  converted to dictionaries, [#733](https://github.com/samuelcolvin/pydantic/issues/733) by [@samuelcolvin](https://github.com/samuelcolvin)
+* **Breaking change:** Added `initvars` support to `post_init_post_parse`, [#748](https://github.com/samuelcolvin/pydantic/issues/748) by [@Raphael-C-Almeida](https://github.com/Raphael-C-Almeida)
+* **Breaking Change:** Make `BaseModel.json()` only serialize the `__root__` key for models with custom root, [#752](https://github.com/samuelcolvin/pydantic/issues/752) by [@dmontagu](https://github.com/dmontagu)
+* **Breaking Change:** complete rewrite of `URL` parsing logic, [#755](https://github.com/samuelcolvin/pydantic/issues/755) by [@samuelcolvin](https://github.com/samuelcolvin)
+* **Breaking Change:** preserve superclass annotations for field-determination when not provided in subclass, [#757](https://github.com/samuelcolvin/pydantic/issues/757) by [@dmontagu](https://github.com/dmontagu)
+* **Breaking Change:** `BaseSettings` now uses the special `env` settings to define which environment variables to
+  read, not aliases, [#847](https://github.com/samuelcolvin/pydantic/issues/847) by [@samuelcolvin](https://github.com/samuelcolvin)
+* add support for `assert` statements inside validators, [#653](https://github.com/samuelcolvin/pydantic/issues/653) by [@abdusco](https://github.com/abdusco)
+* Update documentation to specify the use of `pydantic.dataclasses.dataclass` and subclassing `pydantic.BaseModel`, [#710](https://github.com/samuelcolvin/pydantic/issues/710) by [@maddosaurus](https://github.com/maddosaurus)
+* Allow custom JSON decoding and encoding via `json_loads` and `json_dumps` `Config` properties, [#714](https://github.com/samuelcolvin/pydantic/issues/714) by [@samuelcolvin](https://github.com/samuelcolvin)
+* make all annotated fields occur in the order declared, [#715](https://github.com/samuelcolvin/pydantic/issues/715) by [@dmontagu](https://github.com/dmontagu)
+* use pytest to test `mypy` integration, [#735](https://github.com/samuelcolvin/pydantic/issues/735) by [@dmontagu](https://github.com/dmontagu)
+* add `__repr__` method to `ErrorWrapper`, [#738](https://github.com/samuelcolvin/pydantic/issues/738) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Added support for `FrozenSet` members in dataclasses, and a better error when attempting to use types from the `typing` module that are not supported by Pydantic, [#745](https://github.com/samuelcolvin/pydantic/issues/745) by [@djpetti](https://github.com/djpetti)
+* add documentation for Pycharm Plugin, [#750](https://github.com/samuelcolvin/pydantic/issues/750) by [@koxudaxi](https://github.com/koxudaxi)
+* fix broken examples in the docs, [#753](https://github.com/samuelcolvin/pydantic/issues/753) by [@dmontagu](https://github.com/dmontagu)
+* moving typing related objects into `pydantic.typing`, [#761](https://github.com/samuelcolvin/pydantic/issues/761) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Minor performance improvements to `ErrorWrapper`, `ValidationError` and datetime parsing, [#763](https://github.com/samuelcolvin/pydantic/issues/763) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Improvements to `datetime`/`date`/`time`/`timedelta` types: more descriptive errors,
+  change errors to `value_error` not `type_error`, support bytes, [#766](https://github.com/samuelcolvin/pydantic/issues/766) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix error messages for `Literal` types with multiple allowed values, [#770](https://github.com/samuelcolvin/pydantic/issues/770) by [@dmontagu](https://github.com/dmontagu)
+* Improved auto-generated `title` field in JSON schema by converting underscore to space, [#772](https://github.com/samuelcolvin/pydantic/issues/772) by [@skewty](https://github.com/skewty)
+* support `mypy --no-implicit-reexport` for dataclasses, also respect `--no-implicit-reexport` in pydantic itself, [#783](https://github.com/samuelcolvin/pydantic/issues/783) by [@samuelcolvin](https://github.com/samuelcolvin)
+* add the `PaymentCardNumber` type, [#790](https://github.com/samuelcolvin/pydantic/issues/790) by [@matin](https://github.com/matin)
+* Fix const validations for lists, [#794](https://github.com/samuelcolvin/pydantic/issues/794) by [@hmvp](https://github.com/hmvp)
+* Set `additionalProperties` to false in schema for models with extra fields disallowed, [#796](https://github.com/samuelcolvin/pydantic/issues/796) by [@Code0x58](https://github.com/Code0x58)
+* `EmailStr` validation method now returns local part case-sensitive per RFC 5321, [#798](https://github.com/samuelcolvin/pydantic/issues/798) by [@henriklindgren](https://github.com/henriklindgren)
+* Added ability to validate strictness to `ConstrainedFloat`, `ConstrainedInt` and `ConstrainedStr` and added
+  `StrictFloat` and `StrictInt` classes, [#799](https://github.com/samuelcolvin/pydantic/issues/799) by [@DerRidda](https://github.com/DerRidda)
+* Improve handling of `None` and `Optional`, replace `whole` with `each_item` (inverse meaning, default `False`)
+  on validators, [#803](https://github.com/samuelcolvin/pydantic/issues/803) by [@samuelcolvin](https://github.com/samuelcolvin)
+* add support for `Type[T]` type hints, [#807](https://github.com/samuelcolvin/pydantic/issues/807) by [@timonbimon](https://github.com/timonbimon)
+* Performance improvements from removing `change_exceptions`, change how pydantic error are constructed, [#819](https://github.com/samuelcolvin/pydantic/issues/819) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix the error message arising when a `BaseModel`-type model field causes a `ValidationError` during parsing, [#820](https://github.com/samuelcolvin/pydantic/issues/820) by [@dmontagu](https://github.com/dmontagu)
+* allow `getter_dict` on `Config`, modify `GetterDict` to be more like a `Mapping` object and thus easier to work with, [#821](https://github.com/samuelcolvin/pydantic/issues/821) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Only check `TypeVar` param on base `GenericModel` class, [#842](https://github.com/samuelcolvin/pydantic/issues/842) by [@zpencerq](https://github.com/zpencerq)
+* rename `Model._schema_cache` -> `Model.__schema_cache__`, `Model._json_encoder` -> `Model.__json_encoder__`,
+  `Model._custom_root_type` -> `Model.__custom_root_type__`, [#851](https://github.com/samuelcolvin/pydantic/issues/851) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.32.2 (2019-08-17)
+
+(Docs are available [here](https://5d584fcca7c9b70007d1c997--pydantic-docs.netlify.com))
+
+* fix `__post_init__` usage with dataclass inheritance, fix [#739](https://github.com/samuelcolvin/pydantic/issues/739) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix required fields validation on GenericModels classes, [#742](https://github.com/samuelcolvin/pydantic/issues/742) by [@amitbl](https://github.com/amitbl)
+* fix defining custom `Schema` on `GenericModel` fields, [#754](https://github.com/samuelcolvin/pydantic/issues/754) by [@amitbl](https://github.com/amitbl)
+
+## v0.32.1 (2019-08-08)
+
+* do not validate extra fields when `validate_assignment` is on, [#724](https://github.com/samuelcolvin/pydantic/issues/724) by [@YaraslauZhylko](https://github.com/YaraslauZhylko)
+
+## v0.32 (2019-08-06)
+
+* add model name to `ValidationError` error message, [#676](https://github.com/samuelcolvin/pydantic/issues/676) by [@dmontagu](https://github.com/dmontagu)
+* **breaking change**: remove `__getattr__` and rename `__values__` to `__dict__` on `BaseModel`,
+  deprecation warning on use `__values__` attr, attributes access speed increased up to 14 times, [#712](https://github.com/samuelcolvin/pydantic/issues/712) by [@Bobronium](https://github.com/Bobronium)
+* support `ForwardRef` (without self-referencing annotations) in Python 3.6, [#706](https://github.com/samuelcolvin/pydantic/issues/706) by [@koxudaxi](https://github.com/koxudaxi)
+* implement `schema_extra` in `Config` sub-class, [#663](https://github.com/samuelcolvin/pydantic/issues/663) by [@tiangolo](https://github.com/tiangolo)
+
+## v0.31.1 (2019-07-31)
+
+* fix json generation for `EnumError`, [#697](https://github.com/samuelcolvin/pydantic/issues/697) by [@dmontagu](https://github.com/dmontagu)
+* update numerous dependencies
+
+## v0.31 (2019-07-24)
+
+* better support for floating point `multiple_of` values, [#652](https://github.com/samuelcolvin/pydantic/issues/652) by [@justindujardin](https://github.com/justindujardin)
+* fix schema generation for `NewType` and `Literal`, [#649](https://github.com/samuelcolvin/pydantic/issues/649) by [@dmontagu](https://github.com/dmontagu)
+* fix `alias_generator` and field config conflict, [#645](https://github.com/samuelcolvin/pydantic/issues/645) by [@gmetzker](https://github.com/gmetzker) and [#658](https://github.com/samuelcolvin/pydantic/issues/658) by [@Bobronium](https://github.com/Bobronium)
+* more detailed message for `EnumError`, [#673](https://github.com/samuelcolvin/pydantic/issues/673) by [@dmontagu](https://github.com/dmontagu)
+* add advanced exclude support for `dict`, `json` and `copy`, [#648](https://github.com/samuelcolvin/pydantic/issues/648) by [@Bobronium](https://github.com/Bobronium)
+* fix bug in `GenericModel` for models with concrete parameterized fields, [#672](https://github.com/samuelcolvin/pydantic/issues/672) by [@dmontagu](https://github.com/dmontagu)
+* add documentation for `Literal` type, [#651](https://github.com/samuelcolvin/pydantic/issues/651) by [@dmontagu](https://github.com/dmontagu)
+* add `Config.keep_untouched` for custom descriptors support, [#679](https://github.com/samuelcolvin/pydantic/issues/679) by [@Bobronium](https://github.com/Bobronium)
+* use `inspect.cleandoc` internally to get model description, [#657](https://github.com/samuelcolvin/pydantic/issues/657) by [@tiangolo](https://github.com/tiangolo)
+* add `Color` to schema generation, by [@euri10](https://github.com/euri10)
+* add documentation for Literal type, [#651](https://github.com/samuelcolvin/pydantic/issues/651) by [@dmontagu](https://github.com/dmontagu)
+
+## v0.30.1 (2019-07-15)
+
+* fix so nested classes which inherit and change `__init__` are correctly processed while still allowing `self` as a
+  parameter, [#644](https://github.com/samuelcolvin/pydantic/issues/644) by [@lnaden](https://github.com/lnaden) and [@dgasmith](https://github.com/dgasmith)
+
+## v0.30 (2019-07-07)
+
+* enforce single quotes in code, [#612](https://github.com/samuelcolvin/pydantic/issues/612) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix infinite recursion with dataclass inheritance and `__post_init__`, [#606](https://github.com/samuelcolvin/pydantic/issues/606) by [@Hanaasagi](https://github.com/Hanaasagi)
+* fix default values for `GenericModel`, [#610](https://github.com/samuelcolvin/pydantic/issues/610) by [@dmontagu](https://github.com/dmontagu)
+* clarify that self-referencing models require python 3.7+, [#616](https://github.com/samuelcolvin/pydantic/issues/616) by [@vlcinsky](https://github.com/vlcinsky)
+* fix truncate for types, [#611](https://github.com/samuelcolvin/pydantic/issues/611) by [@dmontagu](https://github.com/dmontagu)
+* add `alias_generator` support, [#622](https://github.com/samuelcolvin/pydantic/issues/622) by [@Bobronium](https://github.com/Bobronium)
+* fix unparameterized generic type schema generation, [#625](https://github.com/samuelcolvin/pydantic/issues/625) by [@dmontagu](https://github.com/dmontagu)
+* fix schema generation with multiple/circular references to the same model, [#621](https://github.com/samuelcolvin/pydantic/issues/621) by [@tiangolo](https://github.com/tiangolo) and [@wongpat](https://github.com/wongpat)
+* support custom root types, [#628](https://github.com/samuelcolvin/pydantic/issues/628) by [@koxudaxi](https://github.com/koxudaxi)
+* support `self` as a field name in `parse_obj`, [#632](https://github.com/samuelcolvin/pydantic/issues/632) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.29 (2019-06-19)
+
+* support dataclasses.InitVar, [#592](https://github.com/samuelcolvin/pydantic/issues/592) by [@pfrederiks](https://github.com/pfrederiks)
+* Updated documentation to elucidate the usage of `Union` when defining multiple types under an attribute's
+  annotation and showcase how the type-order can affect marshalling of provided values, [#594](https://github.com/samuelcolvin/pydantic/issues/594) by [@somada141](https://github.com/somada141)
+* add `conlist` type, [#583](https://github.com/samuelcolvin/pydantic/issues/583) by [@hmvp](https://github.com/hmvp)
+* add support for generics, [#595](https://github.com/samuelcolvin/pydantic/issues/595) by [@dmontagu](https://github.com/dmontagu)
+
+## v0.28 (2019-06-06)
+
+* fix support for JSON Schema generation when using models with circular references in Python 3.7, [#572](https://github.com/samuelcolvin/pydantic/issues/572) by [@tiangolo](https://github.com/tiangolo)
+* support `__post_init_post_parse__` on dataclasses, [#567](https://github.com/samuelcolvin/pydantic/issues/567) by [@sevaho](https://github.com/sevaho)
+* allow dumping dataclasses to JSON, [#575](https://github.com/samuelcolvin/pydantic/issues/575) by [@samuelcolvin](https://github.com/samuelcolvin) and [@DanielOberg](https://github.com/DanielOberg)
+* ORM mode, [#562](https://github.com/samuelcolvin/pydantic/issues/562) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix `pydantic.compiled` on ipython, [#573](https://github.com/samuelcolvin/pydantic/issues/573) by [@dmontagu](https://github.com/dmontagu) and [@samuelcolvin](https://github.com/samuelcolvin)
+* add `StrictBool` type, [#579](https://github.com/samuelcolvin/pydantic/issues/579) by [@cazgp](https://github.com/cazgp)
+
+## v0.27 (2019-05-30)
+
+* **breaking change**  `_pydantic_post_init` to execute dataclass' original `__post_init__` before
+  validation, [#560](https://github.com/samuelcolvin/pydantic/issues/560) by [@HeavenVolkoff](https://github.com/HeavenVolkoff)
+* fix handling of generic types without specified parameters, [#550](https://github.com/samuelcolvin/pydantic/issues/550) by [@dmontagu](https://github.com/dmontagu)
+* **breaking change** (maybe): this is the first release compiled with **cython**, see the docs and please
+  submit an issue if you run into problems
+
+## v0.27.0a1 (2019-05-26)
+
+* fix JSON Schema for `list`, `tuple`, and `set`, [#540](https://github.com/samuelcolvin/pydantic/issues/540) by [@tiangolo](https://github.com/tiangolo)
+* compiling with cython, `manylinux` binaries, some other performance improvements, [#548](https://github.com/samuelcolvin/pydantic/issues/548) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.26 (2019-05-22)
+
+* fix to schema generation for `IPvAnyAddress`, `IPvAnyInterface`, `IPvAnyNetwork` [#498](https://github.com/samuelcolvin/pydantic/issues/498) by [@pilosus](https://github.com/pilosus)
+* fix variable length tuples support, [#495](https://github.com/samuelcolvin/pydantic/issues/495) by [@pilosus](https://github.com/pilosus)
+* fix return type hint for `create_model`, [#526](https://github.com/samuelcolvin/pydantic/issues/526) by [@dmontagu](https://github.com/dmontagu)
+* **Breaking Change:** fix `.dict(skip_keys=True)` skipping values set via alias (this involves changing
+  `validate_model()` to always returns `Tuple[Dict[str, Any], Set[str], Optional[ValidationError]]`), [#517](https://github.com/samuelcolvin/pydantic/issues/517) by [@sommd](https://github.com/sommd)
+* fix to schema generation for `IPv4Address`, `IPv6Address`, `IPv4Interface`,
+  `IPv6Interface`, `IPv4Network`, `IPv6Network` [#532](https://github.com/samuelcolvin/pydantic/issues/532) by [@euri10](https://github.com/euri10)
+* add `Color` type, [#504](https://github.com/samuelcolvin/pydantic/issues/504) by [@pilosus](https://github.com/pilosus) and [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.25 (2019-05-05)
+
+* Improve documentation on self-referencing models and annotations, [#487](https://github.com/samuelcolvin/pydantic/issues/487) by [@theenglishway](https://github.com/theenglishway)
+* fix `.dict()` with extra keys, [#490](https://github.com/samuelcolvin/pydantic/issues/490) by [@JaewonKim](https://github.com/JaewonKim)
+* support `const` keyword in `Schema`, [#434](https://github.com/samuelcolvin/pydantic/issues/434) by [@Sean1708](https://github.com/Sean1708)
+
+## v0.24 (2019-04-23)
+
+* fix handling `ForwardRef` in sub-types, like `Union`, [#464](https://github.com/samuelcolvin/pydantic/issues/464) by [@tiangolo](https://github.com/tiangolo)
+* fix secret serialization, [#465](https://github.com/samuelcolvin/pydantic/issues/465) by [@atheuz](https://github.com/atheuz)
+* Support custom validators for dataclasses, [#454](https://github.com/samuelcolvin/pydantic/issues/454) by [@primal100](https://github.com/primal100)
+* fix `parse_obj` to cope with dict-like objects, [#472](https://github.com/samuelcolvin/pydantic/issues/472) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix to schema generation in nested dataclass-based models, [#474](https://github.com/samuelcolvin/pydantic/issues/474) by [@NoAnyLove](https://github.com/NoAnyLove)
+* fix `json` for `Path`, `FilePath`, and `DirectoryPath` objects, [#473](https://github.com/samuelcolvin/pydantic/issues/473) by [@mikegoodspeed](https://github.com/mikegoodspeed)
+
+## v0.23 (2019-04-04)
+
+* improve documentation for contributing section, [#441](https://github.com/samuelcolvin/pydantic/issues/441) by [@pilosus](https://github.com/pilosus)
+* improve README.rst to include essential information about the package, [#446](https://github.com/samuelcolvin/pydantic/issues/446) by [@pilosus](https://github.com/pilosus)
+* `IntEnum` support, [#444](https://github.com/samuelcolvin/pydantic/issues/444) by [@potykion](https://github.com/potykion)
+* fix PyObject callable value, [#409](https://github.com/samuelcolvin/pydantic/issues/409) by [@pilosus](https://github.com/pilosus)
+* fix `black` deprecation warnings after update, [#451](https://github.com/samuelcolvin/pydantic/issues/451) by [@pilosus](https://github.com/pilosus)
+* fix `ForwardRef` collection bug, [#450](https://github.com/samuelcolvin/pydantic/issues/450) by [@tigerwings](https://github.com/tigerwings)
+* Support specialized `ClassVars`, [#455](https://github.com/samuelcolvin/pydantic/issues/455) by [@tyrylu](https://github.com/tyrylu)
+* fix JSON serialization for `ipaddress` types, [#333](https://github.com/samuelcolvin/pydantic/issues/333) by [@pilosus](https://github.com/pilosus)
+* add `SecretStr` and `SecretBytes` types, [#452](https://github.com/samuelcolvin/pydantic/issues/452) by [@atheuz](https://github.com/atheuz)
+
+## v0.22 (2019-03-29)
+
+* add `IPv{4,6,Any}Network` and `IPv{4,6,Any}Interface` types from `ipaddress` stdlib, [#333](https://github.com/samuelcolvin/pydantic/issues/333) by [@pilosus](https://github.com/pilosus)
+* add docs for `datetime` types, [#386](https://github.com/samuelcolvin/pydantic/issues/386) by [@pilosus](https://github.com/pilosus)
+* fix to schema generation in dataclass-based models, [#408](https://github.com/samuelcolvin/pydantic/issues/408) by [@pilosus](https://github.com/pilosus)
+* fix path in nested models, [#437](https://github.com/samuelcolvin/pydantic/issues/437) by [@kataev](https://github.com/kataev)
+* add `Sequence` support, [#304](https://github.com/samuelcolvin/pydantic/issues/304) by [@pilosus](https://github.com/pilosus)
+
+## v0.21.0 (2019-03-15)
+
+* fix typo in `NoneIsNotAllowedError` message, [#414](https://github.com/samuelcolvin/pydantic/issues/414) by [@YaraslauZhylko](https://github.com/YaraslauZhylko)
+* add `IPvAnyAddress`, `IPv4Address` and `IPv6Address` types, [#333](https://github.com/samuelcolvin/pydantic/issues/333) by [@pilosus](https://github.com/pilosus)
+
+## v0.20.1 (2019-02-26)
+
+* fix type hints of `parse_obj` and similar methods, [#405](https://github.com/samuelcolvin/pydantic/issues/405) by [@erosennin](https://github.com/erosennin)
+* fix submodel validation, [#403](https://github.com/samuelcolvin/pydantic/issues/403) by [@samuelcolvin](https://github.com/samuelcolvin)
+* correct type hints for `ValidationError.json`, [#406](https://github.com/samuelcolvin/pydantic/issues/406) by [@layday](https://github.com/layday)
+
+## v0.20.0 (2019-02-18)
+
+* fix tests for python 3.8, [#396](https://github.com/samuelcolvin/pydantic/issues/396) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Adds fields to the `dir` method for autocompletion in interactive sessions, [#398](https://github.com/samuelcolvin/pydantic/issues/398) by [@dgasmith](https://github.com/dgasmith)
+* support `ForwardRef` (and therefore `from __future__ import annotations`) with dataclasses, [#397](https://github.com/samuelcolvin/pydantic/issues/397) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.20.0a1 (2019-02-13)
+
+* **breaking change** (maybe): more sophisticated argument parsing for validators, any subset of
+  `values`, `config` and `field` is now permitted, eg. `(cls, value, field)`,
+  however the variadic key word argument ("`**kwargs`") **must** be called `kwargs`, [#388](https://github.com/samuelcolvin/pydantic/issues/388) by [@samuelcolvin](https://github.com/samuelcolvin)
+* **breaking change**: Adds `skip_defaults` argument to `BaseModel.dict()` to allow skipping of fields that
+  were not explicitly set, signature of `Model.construct()` changed, [#389](https://github.com/samuelcolvin/pydantic/issues/389) by [@dgasmith](https://github.com/dgasmith)
+* add `py.typed` marker file for PEP-561 support, [#391](https://github.com/samuelcolvin/pydantic/issues/391) by [@je-l](https://github.com/je-l)
+* Fix `extra` behaviour for multiple inheritance/mix-ins, [#394](https://github.com/samuelcolvin/pydantic/issues/394) by [@YaraslauZhylko](https://github.com/YaraslauZhylko)
+
+## v0.19.0 (2019-02-04)
+
+* Support `Callable` type hint, fix [#279](https://github.com/samuelcolvin/pydantic/issues/279) by [@proofit404](https://github.com/proofit404)
+* Fix schema for fields with `validator` decorator, fix [#375](https://github.com/samuelcolvin/pydantic/issues/375) by [@tiangolo](https://github.com/tiangolo)
+* Add `multiple_of` constraint to `ConstrainedDecimal`, `ConstrainedFloat`, `ConstrainedInt`
+  and their related types `condecimal`, `confloat`, and `conint` [#371](https://github.com/samuelcolvin/pydantic/issues/371), thanks [@StephenBrown2](https://github.com/StephenBrown2)
+* Deprecated `ignore_extra` and `allow_extra` Config fields in favor of `extra`, [#352](https://github.com/samuelcolvin/pydantic/issues/352) by [@liiight](https://github.com/liiight)
+* Add type annotations to all functions, test fully with mypy, [#373](https://github.com/samuelcolvin/pydantic/issues/373) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix for 'missing' error with `validate_all` or `validate_always`, [#381](https://github.com/samuelcolvin/pydantic/issues/381) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Change the second/millisecond watershed for date/datetime parsing to `2e10`, [#385](https://github.com/samuelcolvin/pydantic/issues/385) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.18.2 (2019-01-22)
+
+* Fix to schema generation with `Optional` fields, fix [#361](https://github.com/samuelcolvin/pydantic/issues/361) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.18.1 (2019-01-17)
+
+* add `ConstrainedBytes` and `conbytes` types, [#315](https://github.com/samuelcolvin/pydantic/issues/315) [@Gr1N](https://github.com/Gr1N)
+* adding `MANIFEST.in` to include license in package `.tar.gz`, [#358](https://github.com/samuelcolvin/pydantic/issues/358) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.18.0 (2019-01-13)
+
+* **breaking change**: don't call validators on keys of dictionaries, [#254](https://github.com/samuelcolvin/pydantic/issues/254) by [@samuelcolvin](https://github.com/samuelcolvin)
+* Fix validators with `always=True` when the default is `None` or the type is optional, also prevent
+  `whole` validators being called for sub-fields, fix [#132](https://github.com/samuelcolvin/pydantic/issues/132) by [@samuelcolvin](https://github.com/samuelcolvin)
+* improve documentation for settings priority and allow it to be easily changed, [#343](https://github.com/samuelcolvin/pydantic/issues/343) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix `ignore_extra=False` and `allow_population_by_alias=True`, fix [#257](https://github.com/samuelcolvin/pydantic/issues/257) by [@samuelcolvin](https://github.com/samuelcolvin)
+* **breaking change**: Set `BaseConfig` attributes `min_anystr_length` and `max_anystr_length` to
+  `None` by default, fix [#349](https://github.com/samuelcolvin/pydantic/issues/349) in [#350](https://github.com/samuelcolvin/pydantic/issues/350) by [@tiangolo](https://github.com/tiangolo)
+* add support for postponed annotations, [#348](https://github.com/samuelcolvin/pydantic/issues/348) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.17.0 (2018-12-27)
+
+* fix schema for `timedelta` as number, [#325](https://github.com/samuelcolvin/pydantic/issues/325) by [@tiangolo](https://github.com/tiangolo)
+* prevent validators being called repeatedly after inheritance, [#327](https://github.com/samuelcolvin/pydantic/issues/327) by [@samuelcolvin](https://github.com/samuelcolvin)
+* prevent duplicate validator check in ipython, fix [#312](https://github.com/samuelcolvin/pydantic/issues/312) by [@samuelcolvin](https://github.com/samuelcolvin)
+* add "Using Pydantic" section to docs, [#323](https://github.com/samuelcolvin/pydantic/issues/323) by [@tiangolo](https://github.com/tiangolo) & [#326](https://github.com/samuelcolvin/pydantic/issues/326) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix schema generation for fields annotated as `: dict`, `: list`,
+  `: tuple` and `: set`, [#330](https://github.com/samuelcolvin/pydantic/issues/330) & [#335](https://github.com/samuelcolvin/pydantic/issues/335) by [@nkonin](https://github.com/nkonin)
+* add support for constrained strings as dict keys in schema, [#332](https://github.com/samuelcolvin/pydantic/issues/332) by [@tiangolo](https://github.com/tiangolo)
+* support for passing Config class in dataclasses decorator, [#276](https://github.com/samuelcolvin/pydantic/issues/276) by [@jarekkar](https://github.com/jarekkar)
+  (**breaking change**: this supersedes the `validate_assignment` argument with `config`)
+* support for nested dataclasses, [#334](https://github.com/samuelcolvin/pydantic/issues/334) by [@samuelcolvin](https://github.com/samuelcolvin)
+* better errors when getting an `ImportError` with `PyObject`, [#309](https://github.com/samuelcolvin/pydantic/issues/309) by [@samuelcolvin](https://github.com/samuelcolvin)
+* rename `get_validators` to `__get_validators__`, deprecation warning on use of old name, [#338](https://github.com/samuelcolvin/pydantic/issues/338) by [@samuelcolvin](https://github.com/samuelcolvin)
+* support `ClassVar` by excluding such attributes from fields, [#184](https://github.com/samuelcolvin/pydantic/issues/184) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.16.1 (2018-12-10)
+
+* fix `create_model` to correctly use the passed `__config__`, [#320](https://github.com/samuelcolvin/pydantic/issues/320) by [@hugoduncan](https://github.com/hugoduncan)
+
+## v0.16.0 (2018-12-03)
+
+* **breaking change**: refactor schema generation to be compatible with JSON Schema and OpenAPI specs, [#308](https://github.com/samuelcolvin/pydantic/issues/308) by [@tiangolo](https://github.com/tiangolo)
+* add `schema` to `schema` module to generate top-level schemas from base models, [#308](https://github.com/samuelcolvin/pydantic/issues/308) by [@tiangolo](https://github.com/tiangolo)
+* add additional fields to `Schema` class to declare validation for `str` and numeric values, [#311](https://github.com/samuelcolvin/pydantic/issues/311) by [@tiangolo](https://github.com/tiangolo)
+* rename `_schema` to `schema` on fields, [#318](https://github.com/samuelcolvin/pydantic/issues/318) by [@samuelcolvin](https://github.com/samuelcolvin)
+* add `case_insensitive` option to `BaseSettings` `Config`, [#277](https://github.com/samuelcolvin/pydantic/issues/277) by [@jasonkuhrt](https://github.com/jasonkuhrt)
+
+## v0.15.0 (2018-11-18)
+
+* move codebase to use black, [#287](https://github.com/samuelcolvin/pydantic/issues/287) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix alias use in settings, [#286](https://github.com/samuelcolvin/pydantic/issues/286) by [@jasonkuhrt](https://github.com/jasonkuhrt) and [@samuelcolvin](https://github.com/samuelcolvin)
+* fix datetime parsing in `parse_date`, [#298](https://github.com/samuelcolvin/pydantic/issues/298) by [@samuelcolvin](https://github.com/samuelcolvin)
+* allow dataclass inheritance, fix [#293](https://github.com/samuelcolvin/pydantic/issues/293) by [@samuelcolvin](https://github.com/samuelcolvin)
+* fix `PyObject = None`, fix [#305](https://github.com/samuelcolvin/pydantic/issues/305) by [@samuelcolvin](https://github.com/samuelcolvin)
+* allow `Pattern` type, fix [#303](https://github.com/samuelcolvin/pydantic/issues/303) by [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.14.0 (2018-10-02)
+
+* dataclasses decorator, [#269](https://github.com/samuelcolvin/pydantic/issues/269) by [@Gaunt](https://github.com/Gaunt) and [@samuelcolvin](https://github.com/samuelcolvin)
+
+## v0.13.1 (2018-09-21)
+
+* fix issue where int_validator doesn't cast a `bool` to an `int` [#264](https://github.com/samuelcolvin/pydantic/issues/264) by [@nphyatt](https://github.com/nphyatt)
+* add deep copy support for `BaseModel.copy()` [#249](https://github.com/samuelcolvin/pydantic/issues/249), [@gangefors](https://github.com/gangefors)
+
+## v0.13.0 (2018-08-25)
+
+* raise an exception if a field's name shadows an existing `BaseModel` attribute [#242](https://github.com/samuelcolvin/pydantic/issues/242)
+* add `UrlStr` and `urlstr` types [#236](https://github.com/samuelcolvin/pydantic/issues/236)
+* timedelta json encoding ISO8601 and total seconds, custom json encoders [#247](https://github.com/samuelcolvin/pydantic/issues/247), by [@cfkanesan](https://github.com/cfkanesan) and [@samuelcolvin](https://github.com/samuelcolvin)
+* allow `timedelta` objects as values for properties of type `timedelta` (matches `datetime` etc. behavior) [#247](https://github.com/samuelcolvin/pydantic/issues/247)
+
+## v0.12.1 (2018-07-31)
+
+* fix schema generation for fields defined using `typing.Any` [#237](https://github.com/samuelcolvin/pydantic/issues/237)
+
+## v0.12.0 (2018-07-31)
+
+* add `by_alias` argument in `.dict()` and `.json()` model methods [#205](https://github.com/samuelcolvin/pydantic/issues/205)
+* add Json type support [#214](https://github.com/samuelcolvin/pydantic/issues/214)
+* support tuples [#227](https://github.com/samuelcolvin/pydantic/issues/227)
+* major improvements and changes to schema [#213](https://github.com/samuelcolvin/pydantic/issues/213)
+
+## v0.11.2 (2018-07-05)
+
+* add `NewType` support [#115](https://github.com/samuelcolvin/pydantic/issues/115)
+* fix `list`, `set` & `tuple` validation [#225](https://github.com/samuelcolvin/pydantic/issues/225)
+* separate out `validate_model` method, allow errors to be returned along with valid values [#221](https://github.com/samuelcolvin/pydantic/issues/221)
+
+## v0.11.1 (2018-07-02)
+
+* support Python 3.7 [#216](https://github.com/samuelcolvin/pydantic/issues/216), thanks [@layday](https://github.com/layday)
+* Allow arbitrary types in model [#209](https://github.com/samuelcolvin/pydantic/issues/209), thanks [@oldPadavan](https://github.com/oldPadavan)
+
+## v0.11.0 (2018-06-28)
+
+* make `list`, `tuple` and `set` types stricter [#86](https://github.com/samuelcolvin/pydantic/issues/86)
+* **breaking change**: remove msgpack parsing [#201](https://github.com/samuelcolvin/pydantic/issues/201)
+* add `FilePath` and `DirectoryPath` types [#10](https://github.com/samuelcolvin/pydantic/issues/10)
+* model schema generation [#190](https://github.com/samuelcolvin/pydantic/issues/190)
+* JSON serialisation of models and schemas [#133](https://github.com/samuelcolvin/pydantic/issues/133)
+
+## v0.10.0 (2018-06-11)
+
+* add `Config.allow_population_by_alias` [#160](https://github.com/samuelcolvin/pydantic/issues/160), thanks [@bendemaree](https://github.com/bendemaree)
+* **breaking change**: new errors format [#179](https://github.com/samuelcolvin/pydantic/issues/179), thanks [@Gr1N](https://github.com/Gr1N)
+* **breaking change**: removed `Config.min_number_size` and `Config.max_number_size` [#183](https://github.com/samuelcolvin/pydantic/issues/183), thanks [@Gr1N](https://github.com/Gr1N)
+* **breaking change**: correct behaviour of `lt` and `gt` arguments to `conint` etc. [#188](https://github.com/samuelcolvin/pydantic/issues/188)
+  for the old behaviour use `le` and `ge` [#194](https://github.com/samuelcolvin/pydantic/issues/194), thanks [@jaheba](https://github.com/jaheba)
+* added error context and ability to redefine error message templates using `Config.error_msg_templates` [#183](https://github.com/samuelcolvin/pydantic/issues/183),
+  thanks [@Gr1N](https://github.com/Gr1N)
+* fix typo in validator exception [#150](https://github.com/samuelcolvin/pydantic/issues/150)
+* copy defaults to model values, so different models don't share objects [#154](https://github.com/samuelcolvin/pydantic/issues/154)
+
+## v0.9.1 (2018-05-10)
+
+* allow custom `get_field_config` on config classes [#159](https://github.com/samuelcolvin/pydantic/issues/159)
+* add `UUID1`, `UUID3`, `UUID4` and `UUID5` types [#167](https://github.com/samuelcolvin/pydantic/issues/167), thanks [@Gr1N](https://github.com/Gr1N)
+* modify some inconsistent docstrings and annotations [#173](https://github.com/samuelcolvin/pydantic/issues/173), thanks [@YannLuo](https://github.com/YannLuo)
+* fix type annotations for exotic types [#171](https://github.com/samuelcolvin/pydantic/issues/171), thanks [@Gr1N](https://github.com/Gr1N)
+* re-use type validators in exotic types [#171](https://github.com/samuelcolvin/pydantic/issues/171)
+* scheduled monthly requirements updates [#168](https://github.com/samuelcolvin/pydantic/issues/168)
+* add `Decimal`, `ConstrainedDecimal` and `condecimal` types [#170](https://github.com/samuelcolvin/pydantic/issues/170), thanks [@Gr1N](https://github.com/Gr1N)
+
+## v0.9.0 (2018-04-28)
+
+* tweak email-validator import error message [#145](https://github.com/samuelcolvin/pydantic/issues/145)
+* fix parse error of `parse_date()` and `parse_datetime()` when input is 0 [#144](https://github.com/samuelcolvin/pydantic/issues/144), thanks [@YannLuo](https://github.com/YannLuo)
+* add `Config.anystr_strip_whitespace` and `strip_whitespace` kwarg to `constr`,
+  by default values is `False` [#163](https://github.com/samuelcolvin/pydantic/issues/163), thanks [@Gr1N](https://github.com/Gr1N)
+* add `ConstrainedFloat`, `confloat`, `PositiveFloat` and `NegativeFloat` types [#166](https://github.com/samuelcolvin/pydantic/issues/166), thanks [@Gr1N](https://github.com/Gr1N)
+
+## v0.8.0 (2018-03-25)
+
+* fix type annotation for `inherit_config` [#139](https://github.com/samuelcolvin/pydantic/issues/139)
+* **breaking change**: check for invalid field names in validators [#140](https://github.com/samuelcolvin/pydantic/issues/140)
+* validate attributes of parent models [#141](https://github.com/samuelcolvin/pydantic/issues/141)
+* **breaking change**: email validation now uses
+  [email-validator](https://github.com/JoshData/python-email-validator) [#142](https://github.com/samuelcolvin/pydantic/issues/142)
+
+## v0.7.1 (2018-02-07)
+
+* fix bug with `create_model` modifying the base class
+
+## v0.7.0 (2018-02-06)
+
+* added compatibility with abstract base classes (ABCs) [#123](https://github.com/samuelcolvin/pydantic/issues/123)
+* add `create_model` method [#113](https://github.com/samuelcolvin/pydantic/issues/113) [#125](https://github.com/samuelcolvin/pydantic/issues/125)
+* **breaking change**: rename `.config` to `.__config__` on a model
+* **breaking change**: remove deprecated `.values()` on a model, use `.dict()` instead
+* remove use of `OrderedDict` and use simple dict [#126](https://github.com/samuelcolvin/pydantic/issues/126)
+* add `Config.use_enum_values` [#127](https://github.com/samuelcolvin/pydantic/issues/127)
+* add wildcard validators of the form `@validate('*')` [#128](https://github.com/samuelcolvin/pydantic/issues/128)
+
+## v0.6.4 (2018-02-01)
+
+* allow python date and times objects [#122](https://github.com/samuelcolvin/pydantic/issues/122)
+
+## v0.6.3 (2017-11-26)
+
+* fix direct install without `README.rst` present
+
+## v0.6.2 (2017-11-13)
+
+* errors for invalid validator use
+* safer check for complex models in `Settings`
+
+## v0.6.1 (2017-11-08)
+
+* prevent duplicate validators, [#101](https://github.com/samuelcolvin/pydantic/issues/101)
+* add `always` kwarg to validators, [#102](https://github.com/samuelcolvin/pydantic/issues/102)
+
+## v0.6.0 (2017-11-07)
+
+* assignment validation [#94](https://github.com/samuelcolvin/pydantic/issues/94), thanks petroswork!
+* JSON in environment variables for complex types, [#96](https://github.com/samuelcolvin/pydantic/issues/96)
+* add `validator` decorators for complex validation, [#97](https://github.com/samuelcolvin/pydantic/issues/97)
+* depreciate `values(...)` and replace with `.dict(...)`, [#99](https://github.com/samuelcolvin/pydantic/issues/99)
+
+## v0.5.0 (2017-10-23)
+
+* add `UUID` validation [#89](https://github.com/samuelcolvin/pydantic/issues/89)
+* remove `index` and `track` from error object (json) if they're null [#90](https://github.com/samuelcolvin/pydantic/issues/90)
+* improve the error text when a list is provided rather than a dict [#90](https://github.com/samuelcolvin/pydantic/issues/90)
+* add benchmarks table to docs [#91](https://github.com/samuelcolvin/pydantic/issues/91)
+
+## v0.4.0 (2017-07-08)
+
+* show length in string validation error
+* fix aliases in config during inheritance [#55](https://github.com/samuelcolvin/pydantic/issues/55)
+* simplify error display
+* use unicode ellipsis in `truncate`
+* add `parse_obj`, `parse_raw` and `parse_file` helper functions [#58](https://github.com/samuelcolvin/pydantic/issues/58)
+* switch annotation only fields to come first in fields list not last
+
+## v0.3.0 (2017-06-21)
+
+* immutable models via `config.allow_mutation = False`, associated cleanup and performance improvement [#44](https://github.com/samuelcolvin/pydantic/issues/44)
+* immutable helper methods `construct()` and `copy()` [#53](https://github.com/samuelcolvin/pydantic/issues/53)
+* allow pickling of models [#53](https://github.com/samuelcolvin/pydantic/issues/53)
+* `setattr` is removed as `__setattr__` is now intelligent [#44](https://github.com/samuelcolvin/pydantic/issues/44)
+* `raise_exception` removed, Models now always raise exceptions [#44](https://github.com/samuelcolvin/pydantic/issues/44)
+* instance method validators removed
+* django-restful-framework benchmarks added [#47](https://github.com/samuelcolvin/pydantic/issues/47)
+* fix inheritance bug [#49](https://github.com/samuelcolvin/pydantic/issues/49)
+* make str type stricter so list, dict etc are not coerced to strings. [#52](https://github.com/samuelcolvin/pydantic/issues/52)
+* add `StrictStr` which only always strings as input [#52](https://github.com/samuelcolvin/pydantic/issues/52)
+
+## v0.2.1 (2017-06-07)
+
+* pypi and travis together messed up the deploy of `v0.2` this should fix it
+
+## v0.2.0 (2017-06-07)
+
+* **breaking change**: `values()` on a model is now a method not a property,
+  takes `include` and `exclude` arguments
+* allow annotation only fields to support mypy
+* add pretty `to_string(pretty=True)` method for models
+
+## v0.1.0 (2017-06-03)
+
+* add docs
+* add history
+
+
diff --git a/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/RECORD
new file mode 100644
index 0000000..34df8a7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/RECORD
@@ -0,0 +1,59 @@
+pydantic-1.9.1.dist-info/LICENSE,sha256=njlGaQrIi2tz6PABoFhq8TVovohS_VFOQ5Pzl2F2Q4c,1127
+pydantic-1.9.1.dist-info/WHEEL,sha256=pfjXB0CCNW4PSSqQc2t4Up6p3o0jxBnHy_2o38FQkyE,109
+pydantic-1.9.1.dist-info/entry_points.txt,sha256=EquH5n3pilIXg-LLa1K4evpu5-6dnvxzi6vwvkoAMns,45
+pydantic-1.9.1.dist-info/top_level.txt,sha256=cmo_5n0F_YY5td5nPZBfdjBENkmGg_pE5ShWXYbXxTM,9
+pydantic-1.9.1.dist-info/METADATA,sha256=gNM97xy0WlwJ5ogupv6iJ-4jhY4Rt-skMbfhJpFkZoc,126440
+pydantic/typing.cpython-39-darwin.so,sha256=UHyDF5rTpF9GYCBkU3WKxQp7mIpNtziZBKCAiGVNIC0,439696
+pydantic/schema.cpython-39-darwin.so,sha256=3vyKV7vMx2C2KiiiwsUX6b2wZhMB0YmlJb9IUe1roww,842224
+pydantic/color.cpython-39-darwin.so,sha256=zzZY5qr8skg9qqVcNaeUTRpCJmjVCJNfm6VVrmX5S7k,406464
+pydantic/datetime_parse.cpython-39-darwin.so,sha256=zIjrh35MoD03_dg_3bQoQv1DSbrLbM_B5gQFQexGP7E,193192
+pydantic/_hypothesis_plugin.py,sha256=GmHB9Bez36iMNJM9Xhr5q-htlC4NevkyAoM7e6IOi7s,13765
+pydantic/color.py,sha256=Qb_9abEbIE5POuoxXFkmipgCDjmRk4887GjFyFn3if0,16607
+pydantic/_hypothesis_plugin.cpython-39-darwin.so,sha256=ljsUFwbgHpb_XxpSTjADF7u4MIMMC-5OPtf-0AuVFv4,369376
+pydantic/config.py,sha256=58dTrJqWtZTVV9SpH82dHltrl6wwqSYzkd8HeWHEoDw,4174
+pydantic/version.py,sha256=MDYguLrwJKSl__8cKGU729iWC4h5_H0UCCAVVjycmsY,848
+pydantic/fields.py,sha256=4eaJXTYVehfdnM6AMgu-jGaAU2FqdWsHarb6q86UCdQ,48718
+pydantic/dataclasses.cpython-39-darwin.so,sha256=2ABYiTdCQvoU8FK1IzYvfePcR4_WA72B2YCYtOF9Mig,268248
+pydantic/error_wrappers.py,sha256=NvfemFFYx9EFLXBGeJ07MKT2MJQAJFFlx_bIoVpqgVI,5142
+pydantic/decorator.py,sha256=k2ZO3yRjRDtApX-hcldXOX-b_6YTy9cFYFzq2L7hrpQ,10040
+pydantic/validators.py,sha256=pMtN_xRh7kk-1Y3zPUMYd0dcLdnkAlAzeVhl41TmWR4,20030
+pydantic/tools.py,sha256=4Fxqp19VcCNghGSF7jq0JJd82kvGgnO0vn4qxTmKqAg,2834
+pydantic/tools.cpython-39-darwin.so,sha256=AnTfyG1p7YPgd3ImDes5UY2fdmm9Ed5oafYUCiRs2wA,141112
+pydantic/types.cpython-39-darwin.so,sha256=y8ELMXIWfceZivt-2TrO7lAZNS5eQ9PtWJ5WJYOV9E8,762120
+pydantic/decorator.cpython-39-darwin.so,sha256=PkasOrFpTVclbdfxURUwjtWaaICAJoyDfpKdPHaddKc,257608
+pydantic/env_settings.py,sha256=yOmZGWaWn8s71eb3IDCmxOWRS9ysA2TmSxr8Kx5J6Hs,12223
+pydantic/__init__.py,sha256=WdN2s18t59san3TvHFAVZjXG_5kJDPBiJmkrttGNQrA,2619
+pydantic/main.cpython-39-darwin.so,sha256=QiOanCBlnmicGax2oR5LL3anTUATmHlqyRKEtaIg3Pw,746376
+pydantic/mypy.py,sha256=UJi_TkoXILsmldYoRGaQTTvFINxwjB-EebUZ52wPdqA,29726
+pydantic/types.py,sha256=vD3hF-htG18tIkzQiT_OHWP6vk8RNsRiK6Uymht5w8g,32645
+pydantic/class_validators.py,sha256=XJ06c3UlRGoXcGuoO8d1U7Bcu36Q4_4wGSiS8yyiuLs,13555
+pydantic/mypy.cpython-39-darwin.so,sha256=jp4mlz8ZGsUSQXDTTEosDBRFBmblyFKhu-KeyW_u0sM,607640
+pydantic/version.cpython-39-darwin.so,sha256=9oZwLpf6auHU_eOYu1NEq6icz_6THXxM9aaAQJVurdk,94808
+pydantic/__init__.cpython-39-darwin.so,sha256=4TCYRbJm0hOril6bs7LsDd1lj-EFYhMIz9buwX26tXE,73592
+pydantic/parse.cpython-39-darwin.so,sha256=q78U9VSbnwB88TxMzCWruBw5SiyLhZLFg3kauOtVsXk,95528
+pydantic/networks.py,sha256=zTNLhocm_gXFcJYvm1gkNAWprYbSvGfFpLF2lQjeosg,17207
+pydantic/validators.cpython-39-darwin.so,sha256=b5tyQmU0ilm5lJrbypBi6ko8-s1AMokrDU117MO88uU,689776
+pydantic/json.cpython-39-darwin.so,sha256=ER6XrmB-sRgIeU7tY-xefo1Mla9sYxhcWBiJP26G_v8,143776
+pydantic/utils.py,sha256=qpIofetHlRZMmPzcDQLuWD99n-LauukQBr5TzMfMlw4,25668
+pydantic/errors.cpython-39-darwin.so,sha256=72JQDuo9LQ5eKtRRUvZ_6NwrGFIV98lXWyhaH3C77pI,406296
+pydantic/networks.cpython-39-darwin.so,sha256=hrlTtoXVk0AgdIvWXS7UWoBk93T1bM6uY082OS1UrIs,419464
+pydantic/env_settings.cpython-39-darwin.so,sha256=f6Ryo3smwO2ybNRlvgCdn4aRYgeH5uyAAF4v8cYh140,297904
+pydantic/annotated_types.py,sha256=R2LprYseBJlSOnn6mXMAAyi8ZA9WeX9onLgTps4uVqg,2399
+pydantic/fields.cpython-39-darwin.so,sha256=huqreUFzRYmbyHLw8n-XqUSF-_1zX9k-Ufk1N6ZuvCs,820632
+pydantic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic/config.cpython-39-darwin.so,sha256=lghMEIlgIMEe5uqbp7pmTYoelYyv1RTU5yaxky4Gq2I,125184
+pydantic/errors.py,sha256=5BJGZq3UdZoby_79mjbORKmXaHlCWkuY5RX6ua9nvpI,17547
+pydantic/dataclasses.py,sha256=X1uN8Din2v0hORjWnLRdFy_4j3suNnkAWV2i2WIvT70,10007
+pydantic/parse.py,sha256=rrVhaWLK8t03rT3oxvC6uRLuTF5iZ2NKGvGqs4iQEM0,1810
+pydantic/typing.py,sha256=E6RSs5zPnM-OBSa7rhr4Jl-2tLGHPttaKFQhYc_b4xc,19171
+pydantic/main.py,sha256=-K7wZ7zDquogQsCZMHgA5KqEe3FpihDK5xE6uvcGDCk,42122
+pydantic/utils.cpython-39-darwin.so,sha256=Y0GehbIzKTqm42ewTk2Vjx1r-u-MkeCREXRbGgEx5z8,586976
+pydantic/error_wrappers.cpython-39-darwin.so,sha256=nIx4D8NCCtR0vR8Kq7qdOg12fRleInuTk7HRsMyfgZE,206104
+pydantic/datetime_parse.py,sha256=zIukV8Gqt8SgyJ4iKklKcmuUtGfRzX73CvhlBYT6KTE,7714
+pydantic/json.py,sha256=jMmGskQTHA-m6BOpSTLdz18LmqKNUCCW9SG3p3lZyBo,3418
+pydantic/generics.py,sha256=i4S69SboAwTEntFACMJRaznDv6O3TfjMMreB7E6RVH0,16001
+pydantic/schema.py,sha256=3ytayDCyB_ThpdnewzOOP_D3lWbrXXOT1wkdIXA2hXQ,46835
+pydantic/class_validators.cpython-39-darwin.so,sha256=YQh2l_CMP-VcrF3mPRpKteT-FphEfKZFLOxwjaxcLdA,328808
+pydantic/annotated_types.cpython-39-darwin.so,sha256=-CllDjELxvGkBUIi2AyzBizsZmgb0s03Is1ziYWT8OA,91768
+pydantic-1.9.1.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+pydantic-1.9.1.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/WHEEL
new file mode 100644
index 0000000..ef5e11a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_9_x86_64
+
diff --git a/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/entry_points.txt
new file mode 100644
index 0000000..6178b39
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[hypothesis]
+_ = pydantic._hypothesis_plugin
diff --git a/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/top_level.txt
new file mode 100644
index 0000000..572b352
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic-1.9.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+pydantic
diff --git a/myenv/lib/python3.9/site-packages/pydantic/__init__.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/__init__.cpython-39-darwin.so
new file mode 100755
index 0000000..3e304a9
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/__init__.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/__init__.py b/myenv/lib/python3.9/site-packages/pydantic/__init__.py
new file mode 100644
index 0000000..982ea47
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/__init__.py
@@ -0,0 +1,124 @@
+# flake8: noqa
+from . import dataclasses
+from .annotated_types import create_model_from_namedtuple, create_model_from_typeddict
+from .class_validators import root_validator, validator
+from .config import BaseConfig, Extra
+from .decorator import validate_arguments
+from .env_settings import BaseSettings
+from .error_wrappers import ValidationError
+from .errors import *
+from .fields import Field, PrivateAttr, Required
+from .main import *
+from .networks import *
+from .parse import Protocol
+from .tools import *
+from .types import *
+from .version import VERSION
+
+__version__ = VERSION
+
+# WARNING __all__ from .errors is not included here, it will be removed as an export here in v2
+# please use "from pydantic.errors import ..." instead
+__all__ = [
+    # annotated types utils
+    'create_model_from_namedtuple',
+    'create_model_from_typeddict',
+    # dataclasses
+    'dataclasses',
+    # class_validators
+    'root_validator',
+    'validator',
+    # config
+    'BaseConfig',
+    'Extra',
+    # decorator
+    'validate_arguments',
+    # env_settings
+    'BaseSettings',
+    # error_wrappers
+    'ValidationError',
+    # fields
+    'Field',
+    'Required',
+    # main
+    'BaseModel',
+    'compiled',
+    'create_model',
+    'validate_model',
+    # network
+    'AnyUrl',
+    'AnyHttpUrl',
+    'FileUrl',
+    'HttpUrl',
+    'stricturl',
+    'EmailStr',
+    'NameEmail',
+    'IPvAnyAddress',
+    'IPvAnyInterface',
+    'IPvAnyNetwork',
+    'PostgresDsn',
+    'AmqpDsn',
+    'RedisDsn',
+    'KafkaDsn',
+    'validate_email',
+    # parse
+    'Protocol',
+    # tools
+    'parse_file_as',
+    'parse_obj_as',
+    'parse_raw_as',
+    'schema_of',
+    'schema_json_of',
+    # types
+    'NoneStr',
+    'NoneBytes',
+    'StrBytes',
+    'NoneStrBytes',
+    'StrictStr',
+    'ConstrainedBytes',
+    'conbytes',
+    'ConstrainedList',
+    'conlist',
+    'ConstrainedSet',
+    'conset',
+    'ConstrainedFrozenSet',
+    'confrozenset',
+    'ConstrainedStr',
+    'constr',
+    'PyObject',
+    'ConstrainedInt',
+    'conint',
+    'PositiveInt',
+    'NegativeInt',
+    'NonNegativeInt',
+    'NonPositiveInt',
+    'ConstrainedFloat',
+    'confloat',
+    'PositiveFloat',
+    'NegativeFloat',
+    'NonNegativeFloat',
+    'NonPositiveFloat',
+    'ConstrainedDecimal',
+    'condecimal',
+    'UUID1',
+    'UUID3',
+    'UUID4',
+    'UUID5',
+    'FilePath',
+    'DirectoryPath',
+    'Json',
+    'JsonWrapper',
+    'SecretStr',
+    'SecretBytes',
+    'StrictBool',
+    'StrictBytes',
+    'StrictInt',
+    'StrictFloat',
+    'PaymentCardNumber',
+    'PrivateAttr',
+    'ByteSize',
+    'PastDate',
+    'FutureDate',
+    # version
+    'VERSION',
+]
diff --git a/myenv/lib/python3.9/site-packages/pydantic/_hypothesis_plugin.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/_hypothesis_plugin.cpython-39-darwin.so
new file mode 100755
index 0000000..ff16118
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/_hypothesis_plugin.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/_hypothesis_plugin.py b/myenv/lib/python3.9/site-packages/pydantic/_hypothesis_plugin.py
new file mode 100644
index 0000000..890e192
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/_hypothesis_plugin.py
@@ -0,0 +1,364 @@
+"""
+Register Hypothesis strategies for Pydantic custom types.
+
+This enables fully-automatic generation of test data for most Pydantic classes.
+
+Note that this module has *no* runtime impact on Pydantic itself; instead it
+is registered as a setuptools entry point and Hypothesis will import it if
+Pydantic is installed.  See also:
+
+https://hypothesis.readthedocs.io/en/latest/strategies.html#registering-strategies-via-setuptools-entry-points
+https://hypothesis.readthedocs.io/en/latest/data.html#hypothesis.strategies.register_type_strategy
+https://hypothesis.readthedocs.io/en/latest/strategies.html#interaction-with-pytest-cov
+https://pydantic-docs.helpmanual.io/usage/types/#pydantic-types
+
+Note that because our motivation is to *improve user experience*, the strategies
+are always sound (never generate invalid data) but sacrifice completeness for
+maintainability (ie may be unable to generate some tricky but valid data).
+
+Finally, this module makes liberal use of `# type: ignore[<code>]` pragmas.
+This is because Hypothesis annotates `register_type_strategy()` with
+`(T, SearchStrategy[T])`, but in most cases we register e.g. `ConstrainedInt`
+to generate instances of the builtin `int` type which match the constraints.
+"""
+
+import contextlib
+import ipaddress
+import json
+import math
+from fractions import Fraction
+from typing import Callable, Dict, Type, Union, cast, overload
+
+import hypothesis.strategies as st
+
+import pydantic
+import pydantic.color
+import pydantic.types
+
+# FilePath and DirectoryPath are explicitly unsupported, as we'd have to create
+# them on-disk, and that's unsafe in general without being told *where* to do so.
+#
+# URLs are unsupported because it's easy for users to define their own strategy for
+# "normal" URLs, and hard for us to define a general strategy which includes "weird"
+# URLs but doesn't also have unpredictable performance problems.
+#
+# conlist() and conset() are unsupported for now, because the workarounds for
+# Cython and Hypothesis to handle parametrized generic types are incompatible.
+# Once Cython can support 'normal' generics we'll revisit this.
+
+# Emails
+try:
+    import email_validator
+except ImportError:  # pragma: no cover
+    pass
+else:
+
+    def is_valid_email(s: str) -> bool:
+        # Hypothesis' st.emails() occasionally generates emails like 0@A0--0.ac
+        # that are invalid according to email-validator, so we filter those out.
+        try:
+            email_validator.validate_email(s, check_deliverability=False)
+            return True
+        except email_validator.EmailNotValidError:  # pragma: no cover
+            return False
+
+    # Note that these strategies deliberately stay away from any tricky Unicode
+    # or other encoding issues; we're just trying to generate *something* valid.
+    st.register_type_strategy(pydantic.EmailStr, st.emails().filter(is_valid_email))  # type: ignore[arg-type]
+    st.register_type_strategy(
+        pydantic.NameEmail,
+        st.builds(
+            '{} <{}>'.format,  # type: ignore[arg-type]
+            st.from_regex('[A-Za-z0-9_]+( [A-Za-z0-9_]+){0,5}', fullmatch=True),
+            st.emails().filter(is_valid_email),
+        ),
+    )
+
+# PyObject - dotted names, in this case taken from the math module.
+st.register_type_strategy(
+    pydantic.PyObject,  # type: ignore[arg-type]
+    st.sampled_from(
+        [cast(pydantic.PyObject, f'math.{name}') for name in sorted(vars(math)) if not name.startswith('_')]
+    ),
+)
+
+# CSS3 Colors; as name, hex, rgb(a) tuples or strings, or hsl strings
+_color_regexes = (
+    '|'.join(
+        (
+            pydantic.color.r_hex_short,
+            pydantic.color.r_hex_long,
+            pydantic.color.r_rgb,
+            pydantic.color.r_rgba,
+            pydantic.color.r_hsl,
+            pydantic.color.r_hsla,
+        )
+    )
+    # Use more precise regex patterns to avoid value-out-of-range errors
+    .replace(pydantic.color._r_sl, r'(?:(\d\d?(?:\.\d+)?|100(?:\.0+)?)%)')
+    .replace(pydantic.color._r_alpha, r'(?:(0(?:\.\d+)?|1(?:\.0+)?|\.\d+|\d{1,2}%))')
+    .replace(pydantic.color._r_255, r'(?:((?:\d|\d\d|[01]\d\d|2[0-4]\d|25[0-4])(?:\.\d+)?|255(?:\.0+)?))')
+)
+st.register_type_strategy(
+    pydantic.color.Color,
+    st.one_of(
+        st.sampled_from(sorted(pydantic.color.COLORS_BY_NAME)),
+        st.tuples(
+            st.integers(0, 255),
+            st.integers(0, 255),
+            st.integers(0, 255),
+            st.none() | st.floats(0, 1) | st.floats(0, 100).map('{}%'.format),
+        ),
+        st.from_regex(_color_regexes, fullmatch=True),
+    ),
+)
+
+
+# Card numbers, valid according to the Luhn algorithm
+
+
+def add_luhn_digit(card_number: str) -> str:
+    # See https://en.wikipedia.org/wiki/Luhn_algorithm
+    for digit in '0123456789':
+        with contextlib.suppress(Exception):
+            pydantic.PaymentCardNumber.validate_luhn_check_digit(card_number + digit)
+            return card_number + digit
+    raise AssertionError('Unreachable')  # pragma: no cover
+
+
+card_patterns = (
+    # Note that these patterns omit the Luhn check digit; that's added by the function above
+    '4[0-9]{14}',  # Visa
+    '5[12345][0-9]{13}',  # Mastercard
+    '3[47][0-9]{12}',  # American Express
+    '[0-26-9][0-9]{10,17}',  # other (incomplete to avoid overlap)
+)
+st.register_type_strategy(
+    pydantic.PaymentCardNumber,
+    st.from_regex('|'.join(card_patterns), fullmatch=True).map(add_luhn_digit),  # type: ignore[arg-type]
+)
+
+# UUIDs
+st.register_type_strategy(pydantic.UUID1, st.uuids(version=1))
+st.register_type_strategy(pydantic.UUID3, st.uuids(version=3))
+st.register_type_strategy(pydantic.UUID4, st.uuids(version=4))
+st.register_type_strategy(pydantic.UUID5, st.uuids(version=5))
+
+# Secrets
+st.register_type_strategy(pydantic.SecretBytes, st.binary().map(pydantic.SecretBytes))
+st.register_type_strategy(pydantic.SecretStr, st.text().map(pydantic.SecretStr))
+
+# IP addresses, networks, and interfaces
+st.register_type_strategy(pydantic.IPvAnyAddress, st.ip_addresses())  # type: ignore[arg-type]
+st.register_type_strategy(
+    pydantic.IPvAnyInterface,
+    st.from_type(ipaddress.IPv4Interface) | st.from_type(ipaddress.IPv6Interface),  # type: ignore[arg-type]
+)
+st.register_type_strategy(
+    pydantic.IPvAnyNetwork,
+    st.from_type(ipaddress.IPv4Network) | st.from_type(ipaddress.IPv6Network),  # type: ignore[arg-type]
+)
+
+# We hook into the con***() functions and the ConstrainedNumberMeta metaclass,
+# so here we only have to register subclasses for other constrained types which
+# don't go via those mechanisms.  Then there are the registration hooks below.
+st.register_type_strategy(pydantic.StrictBool, st.booleans())
+st.register_type_strategy(pydantic.StrictStr, st.text())
+
+
+# Constrained-type resolver functions
+#
+# For these ones, we actually want to inspect the type in order to work out a
+# satisfying strategy.  First up, the machinery for tracking resolver functions:
+
+RESOLVERS: Dict[type, Callable[[type], st.SearchStrategy]] = {}  # type: ignore[type-arg]
+
+
+@overload
+def _registered(typ: Type[pydantic.types.T]) -> Type[pydantic.types.T]:
+    pass
+
+
+@overload
+def _registered(typ: pydantic.types.ConstrainedNumberMeta) -> pydantic.types.ConstrainedNumberMeta:
+    pass
+
+
+def _registered(
+    typ: Union[Type[pydantic.types.T], pydantic.types.ConstrainedNumberMeta]
+) -> Union[Type[pydantic.types.T], pydantic.types.ConstrainedNumberMeta]:
+    # This function replaces the version in `pydantic.types`, in order to
+    # effect the registration of new constrained types so that Hypothesis
+    # can generate valid examples.
+    pydantic.types._DEFINED_TYPES.add(typ)
+    for supertype, resolver in RESOLVERS.items():
+        if issubclass(typ, supertype):
+            st.register_type_strategy(typ, resolver(typ))  # type: ignore
+            return typ
+    raise NotImplementedError(f'Unknown type {typ!r} has no resolver to register')  # pragma: no cover
+
+
+def resolves(
+    typ: Union[type, pydantic.types.ConstrainedNumberMeta]
+) -> Callable[[Callable[..., st.SearchStrategy]], Callable[..., st.SearchStrategy]]:  # type: ignore[type-arg]
+    def inner(f):  # type: ignore
+        assert f not in RESOLVERS
+        RESOLVERS[typ] = f
+        return f
+
+    return inner
+
+
+# Type-to-strategy resolver functions
+
+
+@resolves(pydantic.JsonWrapper)
+def resolve_json(cls):  # type: ignore[no-untyped-def]
+    try:
+        inner = st.none() if cls.inner_type is None else st.from_type(cls.inner_type)
+    except Exception:  # pragma: no cover
+        finite = st.floats(allow_infinity=False, allow_nan=False)
+        inner = st.recursive(
+            base=st.one_of(st.none(), st.booleans(), st.integers(), finite, st.text()),
+            extend=lambda x: st.lists(x) | st.dictionaries(st.text(), x),  # type: ignore
+        )
+    return st.builds(
+        json.dumps,
+        inner,
+        ensure_ascii=st.booleans(),
+        indent=st.none() | st.integers(0, 16),
+        sort_keys=st.booleans(),
+    )
+
+
+@resolves(pydantic.ConstrainedBytes)
+def resolve_conbytes(cls):  # type: ignore[no-untyped-def]  # pragma: no cover
+    min_size = cls.min_length or 0
+    max_size = cls.max_length
+    if not cls.strip_whitespace:
+        return st.binary(min_size=min_size, max_size=max_size)
+    # Fun with regex to ensure we neither start nor end with whitespace
+    repeats = '{{{},{}}}'.format(
+        min_size - 2 if min_size > 2 else 0,
+        max_size - 2 if (max_size or 0) > 2 else '',
+    )
+    if min_size >= 2:
+        pattern = rf'\W.{repeats}\W'
+    elif min_size == 1:
+        pattern = rf'\W(.{repeats}\W)?'
+    else:
+        assert min_size == 0
+        pattern = rf'(\W(.{repeats}\W)?)?'
+    return st.from_regex(pattern.encode(), fullmatch=True)
+
+
+@resolves(pydantic.ConstrainedDecimal)
+def resolve_condecimal(cls):  # type: ignore[no-untyped-def]
+    min_value = cls.ge
+    max_value = cls.le
+    if cls.gt is not None:
+        assert min_value is None, 'Set `gt` or `ge`, but not both'
+        min_value = cls.gt
+    if cls.lt is not None:
+        assert max_value is None, 'Set `lt` or `le`, but not both'
+        max_value = cls.lt
+    s = st.decimals(min_value, max_value, allow_nan=False, places=cls.decimal_places)
+    if cls.lt is not None:
+        s = s.filter(lambda d: d < cls.lt)
+    if cls.gt is not None:
+        s = s.filter(lambda d: cls.gt < d)
+    return s
+
+
+@resolves(pydantic.ConstrainedFloat)
+def resolve_confloat(cls):  # type: ignore[no-untyped-def]
+    min_value = cls.ge
+    max_value = cls.le
+    exclude_min = False
+    exclude_max = False
+
+    if cls.gt is not None:
+        assert min_value is None, 'Set `gt` or `ge`, but not both'
+        min_value = cls.gt
+        exclude_min = True
+    if cls.lt is not None:
+        assert max_value is None, 'Set `lt` or `le`, but not both'
+        max_value = cls.lt
+        exclude_max = True
+
+    if cls.multiple_of is None:
+        return st.floats(min_value, max_value, exclude_min=exclude_min, exclude_max=exclude_max, allow_nan=False)
+
+    if min_value is not None:
+        min_value = math.ceil(min_value / cls.multiple_of)
+        if exclude_min:
+            min_value = min_value + 1
+    if max_value is not None:
+        assert max_value >= cls.multiple_of, 'Cannot build model with max value smaller than multiple of'
+        max_value = math.floor(max_value / cls.multiple_of)
+        if exclude_max:
+            max_value = max_value - 1
+
+    return st.integers(min_value, max_value).map(lambda x: x * cls.multiple_of)
+
+
+@resolves(pydantic.ConstrainedInt)
+def resolve_conint(cls):  # type: ignore[no-untyped-def]
+    min_value = cls.ge
+    max_value = cls.le
+    if cls.gt is not None:
+        assert min_value is None, 'Set `gt` or `ge`, but not both'
+        min_value = cls.gt + 1
+    if cls.lt is not None:
+        assert max_value is None, 'Set `lt` or `le`, but not both'
+        max_value = cls.lt - 1
+
+    if cls.multiple_of is None or cls.multiple_of == 1:
+        return st.integers(min_value, max_value)
+
+    # These adjustments and the .map handle integer-valued multiples, while the
+    # .filter handles trickier cases as for confloat.
+    if min_value is not None:
+        min_value = math.ceil(Fraction(min_value) / Fraction(cls.multiple_of))
+    if max_value is not None:
+        max_value = math.floor(Fraction(max_value) / Fraction(cls.multiple_of))
+    return st.integers(min_value, max_value).map(lambda x: x * cls.multiple_of)
+
+
+@resolves(pydantic.ConstrainedStr)
+def resolve_constr(cls):  # type: ignore[no-untyped-def]  # pragma: no cover
+    min_size = cls.min_length or 0
+    max_size = cls.max_length
+
+    if cls.regex is None and not cls.strip_whitespace:
+        return st.text(min_size=min_size, max_size=max_size)
+
+    if cls.regex is not None:
+        strategy = st.from_regex(cls.regex)
+        if cls.strip_whitespace:
+            strategy = strategy.filter(lambda s: s == s.strip())
+    elif cls.strip_whitespace:
+        repeats = '{{{},{}}}'.format(
+            min_size - 2 if min_size > 2 else 0,
+            max_size - 2 if (max_size or 0) > 2 else '',
+        )
+        if min_size >= 2:
+            strategy = st.from_regex(rf'\W.{repeats}\W')
+        elif min_size == 1:
+            strategy = st.from_regex(rf'\W(.{repeats}\W)?')
+        else:
+            assert min_size == 0
+            strategy = st.from_regex(rf'(\W(.{repeats}\W)?)?')
+
+    if min_size == 0 and max_size is None:
+        return strategy
+    elif max_size is None:
+        return strategy.filter(lambda s: min_size <= len(s))
+    return strategy.filter(lambda s: min_size <= len(s) <= max_size)
+
+
+# Finally, register all previously-defined types, and patch in our new function
+for typ in list(pydantic.types._DEFINED_TYPES):
+    _registered(typ)
+pydantic.types._registered = _registered
+st.register_type_strategy(pydantic.Json, resolve_json)
diff --git a/myenv/lib/python3.9/site-packages/pydantic/annotated_types.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/annotated_types.cpython-39-darwin.so
new file mode 100755
index 0000000..8d3a96e
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/annotated_types.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/annotated_types.py b/myenv/lib/python3.9/site-packages/pydantic/annotated_types.py
new file mode 100644
index 0000000..86f7934
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/annotated_types.py
@@ -0,0 +1,52 @@
+from typing import TYPE_CHECKING, Any, Dict, FrozenSet, NamedTuple, Type
+
+from .fields import Required
+from .main import BaseModel, create_model
+
+if TYPE_CHECKING:
+    from typing_extensions import TypedDict
+
+
+def create_model_from_typeddict(
+    # Mypy bug: `Type[TypedDict]` is resolved as `Any` https://github.com/python/mypy/issues/11030
+    typeddict_cls: Type['TypedDict'],  # type: ignore[valid-type]
+    **kwargs: Any,
+) -> Type['BaseModel']:
+    """
+    Create a `BaseModel` based on the fields of a `TypedDict`.
+    Since `typing.TypedDict` in Python 3.8 does not store runtime information about optional keys,
+    we raise an error if this happens (see https://bugs.python.org/issue38834).
+    """
+    field_definitions: Dict[str, Any]
+
+    # Best case scenario: with python 3.9+ or when `TypedDict` is imported from `typing_extensions`
+    if not hasattr(typeddict_cls, '__required_keys__'):
+        raise TypeError(
+            'You should use `typing_extensions.TypedDict` instead of `typing.TypedDict` with Python < 3.9.2. '
+            'Without it, there is no way to differentiate required and optional fields when subclassed.'
+        )
+
+    required_keys: FrozenSet[str] = typeddict_cls.__required_keys__  # type: ignore[attr-defined]
+    field_definitions = {
+        field_name: (field_type, Required if field_name in required_keys else None)
+        for field_name, field_type in typeddict_cls.__annotations__.items()
+    }
+
+    return create_model(typeddict_cls.__name__, **kwargs, **field_definitions)
+
+
+def create_model_from_namedtuple(namedtuple_cls: Type['NamedTuple'], **kwargs: Any) -> Type['BaseModel']:
+    """
+    Create a `BaseModel` based on the fields of a named tuple.
+    A named tuple can be created with `typing.NamedTuple` and declared annotations
+    but also with `collections.namedtuple`, in this case we consider all fields
+    to have type `Any`.
+    """
+    # With python 3.10+, `__annotations__` always exists but can be empty hence the `getattr... or...` logic
+    namedtuple_annotations: Dict[str, Type[Any]] = getattr(namedtuple_cls, '__annotations__', None) or {
+        k: Any for k in namedtuple_cls._fields
+    }
+    field_definitions: Dict[str, Any] = {
+        field_name: (field_type, Required) for field_name, field_type in namedtuple_annotations.items()
+    }
+    return create_model(namedtuple_cls.__name__, **kwargs, **field_definitions)
diff --git a/myenv/lib/python3.9/site-packages/pydantic/class_validators.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/class_validators.cpython-39-darwin.so
new file mode 100755
index 0000000..f971911
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/class_validators.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/class_validators.py b/myenv/lib/python3.9/site-packages/pydantic/class_validators.py
new file mode 100644
index 0000000..a9cd0db
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/class_validators.py
@@ -0,0 +1,337 @@
+import warnings
+from collections import ChainMap
+from functools import wraps
+from itertools import chain
+from types import FunctionType
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Optional, Set, Tuple, Type, Union, overload
+
+from .errors import ConfigError
+from .typing import AnyCallable
+from .utils import ROOT_KEY, in_ipython
+
+if TYPE_CHECKING:
+    from .typing import AnyClassMethod
+
+
+class Validator:
+    __slots__ = 'func', 'pre', 'each_item', 'always', 'check_fields', 'skip_on_failure'
+
+    def __init__(
+        self,
+        func: AnyCallable,
+        pre: bool = False,
+        each_item: bool = False,
+        always: bool = False,
+        check_fields: bool = False,
+        skip_on_failure: bool = False,
+    ):
+        self.func = func
+        self.pre = pre
+        self.each_item = each_item
+        self.always = always
+        self.check_fields = check_fields
+        self.skip_on_failure = skip_on_failure
+
+
+if TYPE_CHECKING:
+    from inspect import Signature
+
+    from .config import BaseConfig
+    from .fields import ModelField
+    from .types import ModelOrDc
+
+    ValidatorCallable = Callable[[Optional[ModelOrDc], Any, Dict[str, Any], ModelField, Type[BaseConfig]], Any]
+    ValidatorsList = List[ValidatorCallable]
+    ValidatorListDict = Dict[str, List[Validator]]
+
+_FUNCS: Set[str] = set()
+VALIDATOR_CONFIG_KEY = '__validator_config__'
+ROOT_VALIDATOR_CONFIG_KEY = '__root_validator_config__'
+
+
+def validator(
+    *fields: str,
+    pre: bool = False,
+    each_item: bool = False,
+    always: bool = False,
+    check_fields: bool = True,
+    whole: bool = None,
+    allow_reuse: bool = False,
+) -> Callable[[AnyCallable], 'AnyClassMethod']:
+    """
+    Decorate methods on the class indicating that they should be used to validate fields
+    :param fields: which field(s) the method should be called on
+    :param pre: whether or not this validator should be called before the standard validators (else after)
+    :param each_item: for complex objects (sets, lists etc.) whether to validate individual elements rather than the
+      whole object
+    :param always: whether this method and other validators should be called even if the value is missing
+    :param check_fields: whether to check that the fields actually exist on the model
+    :param allow_reuse: whether to track and raise an error if another validator refers to the decorated function
+    """
+    if not fields:
+        raise ConfigError('validator with no fields specified')
+    elif isinstance(fields[0], FunctionType):
+        raise ConfigError(
+            "validators should be used with fields and keyword arguments, not bare. "  # noqa: Q000
+            "E.g. usage should be `@validator('<field_name>', ...)`"
+        )
+
+    if whole is not None:
+        warnings.warn(
+            'The "whole" keyword argument is deprecated, use "each_item" (inverse meaning, default False) instead',
+            DeprecationWarning,
+        )
+        assert each_item is False, '"each_item" and "whole" conflict, remove "whole"'
+        each_item = not whole
+
+    def dec(f: AnyCallable) -> 'AnyClassMethod':
+        f_cls = _prepare_validator(f, allow_reuse)
+        setattr(
+            f_cls,
+            VALIDATOR_CONFIG_KEY,
+            (
+                fields,
+                Validator(func=f_cls.__func__, pre=pre, each_item=each_item, always=always, check_fields=check_fields),
+            ),
+        )
+        return f_cls
+
+    return dec
+
+
+@overload
+def root_validator(_func: AnyCallable) -> 'AnyClassMethod':
+    ...
+
+
+@overload
+def root_validator(
+    *, pre: bool = False, allow_reuse: bool = False, skip_on_failure: bool = False
+) -> Callable[[AnyCallable], 'AnyClassMethod']:
+    ...
+
+
+def root_validator(
+    _func: Optional[AnyCallable] = None, *, pre: bool = False, allow_reuse: bool = False, skip_on_failure: bool = False
+) -> Union['AnyClassMethod', Callable[[AnyCallable], 'AnyClassMethod']]:
+    """
+    Decorate methods on a model indicating that they should be used to validate (and perhaps modify) data either
+    before or after standard model parsing/validation is performed.
+    """
+    if _func:
+        f_cls = _prepare_validator(_func, allow_reuse)
+        setattr(
+            f_cls, ROOT_VALIDATOR_CONFIG_KEY, Validator(func=f_cls.__func__, pre=pre, skip_on_failure=skip_on_failure)
+        )
+        return f_cls
+
+    def dec(f: AnyCallable) -> 'AnyClassMethod':
+        f_cls = _prepare_validator(f, allow_reuse)
+        setattr(
+            f_cls, ROOT_VALIDATOR_CONFIG_KEY, Validator(func=f_cls.__func__, pre=pre, skip_on_failure=skip_on_failure)
+        )
+        return f_cls
+
+    return dec
+
+
+def _prepare_validator(function: AnyCallable, allow_reuse: bool) -> 'AnyClassMethod':
+    """
+    Avoid validators with duplicated names since without this, validators can be overwritten silently
+    which generally isn't the intended behaviour, don't run in ipython (see #312) or if allow_reuse is False.
+    """
+    f_cls = function if isinstance(function, classmethod) else classmethod(function)
+    if not in_ipython() and not allow_reuse:
+        ref = f_cls.__func__.__module__ + '.' + f_cls.__func__.__qualname__
+        if ref in _FUNCS:
+            raise ConfigError(f'duplicate validator function "{ref}"; if this is intended, set `allow_reuse=True`')
+        _FUNCS.add(ref)
+    return f_cls
+
+
+class ValidatorGroup:
+    def __init__(self, validators: 'ValidatorListDict') -> None:
+        self.validators = validators
+        self.used_validators = {'*'}
+
+    def get_validators(self, name: str) -> Optional[Dict[str, Validator]]:
+        self.used_validators.add(name)
+        validators = self.validators.get(name, [])
+        if name != ROOT_KEY:
+            validators += self.validators.get('*', [])
+        if validators:
+            return {v.func.__name__: v for v in validators}
+        else:
+            return None
+
+    def check_for_unused(self) -> None:
+        unused_validators = set(
+            chain.from_iterable(
+                (v.func.__name__ for v in self.validators[f] if v.check_fields)
+                for f in (self.validators.keys() - self.used_validators)
+            )
+        )
+        if unused_validators:
+            fn = ', '.join(unused_validators)
+            raise ConfigError(
+                f"Validators defined with incorrect fields: {fn} "  # noqa: Q000
+                f"(use check_fields=False if you're inheriting from the model and intended this)"
+            )
+
+
+def extract_validators(namespace: Dict[str, Any]) -> Dict[str, List[Validator]]:
+    validators: Dict[str, List[Validator]] = {}
+    for var_name, value in namespace.items():
+        validator_config = getattr(value, VALIDATOR_CONFIG_KEY, None)
+        if validator_config:
+            fields, v = validator_config
+            for field in fields:
+                if field in validators:
+                    validators[field].append(v)
+                else:
+                    validators[field] = [v]
+    return validators
+
+
+def extract_root_validators(namespace: Dict[str, Any]) -> Tuple[List[AnyCallable], List[Tuple[bool, AnyCallable]]]:
+    from inspect import signature
+
+    pre_validators: List[AnyCallable] = []
+    post_validators: List[Tuple[bool, AnyCallable]] = []
+    for name, value in namespace.items():
+        validator_config: Optional[Validator] = getattr(value, ROOT_VALIDATOR_CONFIG_KEY, None)
+        if validator_config:
+            sig = signature(validator_config.func)
+            args = list(sig.parameters.keys())
+            if args[0] == 'self':
+                raise ConfigError(
+                    f'Invalid signature for root validator {name}: {sig}, "self" not permitted as first argument, '
+                    f'should be: (cls, values).'
+                )
+            if len(args) != 2:
+                raise ConfigError(f'Invalid signature for root validator {name}: {sig}, should be: (cls, values).')
+            # check function signature
+            if validator_config.pre:
+                pre_validators.append(validator_config.func)
+            else:
+                post_validators.append((validator_config.skip_on_failure, validator_config.func))
+    return pre_validators, post_validators
+
+
+def inherit_validators(base_validators: 'ValidatorListDict', validators: 'ValidatorListDict') -> 'ValidatorListDict':
+    for field, field_validators in base_validators.items():
+        if field not in validators:
+            validators[field] = []
+        validators[field] += field_validators
+    return validators
+
+
+def make_generic_validator(validator: AnyCallable) -> 'ValidatorCallable':
+    """
+    Make a generic function which calls a validator with the right arguments.
+
+    Unfortunately other approaches (eg. return a partial of a function that builds the arguments) is slow,
+    hence this laborious way of doing things.
+
+    It's done like this so validators don't all need **kwargs in their signature, eg. any combination of
+    the arguments "values", "fields" and/or "config" are permitted.
+    """
+    from inspect import signature
+
+    sig = signature(validator)
+    args = list(sig.parameters.keys())
+    first_arg = args.pop(0)
+    if first_arg == 'self':
+        raise ConfigError(
+            f'Invalid signature for validator {validator}: {sig}, "self" not permitted as first argument, '
+            f'should be: (cls, value, values, config, field), "values", "config" and "field" are all optional.'
+        )
+    elif first_arg == 'cls':
+        # assume the second argument is value
+        return wraps(validator)(_generic_validator_cls(validator, sig, set(args[1:])))
+    else:
+        # assume the first argument was value which has already been removed
+        return wraps(validator)(_generic_validator_basic(validator, sig, set(args)))
+
+
+def prep_validators(v_funcs: Iterable[AnyCallable]) -> 'ValidatorsList':
+    return [make_generic_validator(f) for f in v_funcs if f]
+
+
+all_kwargs = {'values', 'field', 'config'}
+
+
+def _generic_validator_cls(validator: AnyCallable, sig: 'Signature', args: Set[str]) -> 'ValidatorCallable':
+    # assume the first argument is value
+    has_kwargs = False
+    if 'kwargs' in args:
+        has_kwargs = True
+        args -= {'kwargs'}
+
+    if not args.issubset(all_kwargs):
+        raise ConfigError(
+            f'Invalid signature for validator {validator}: {sig}, should be: '
+            f'(cls, value, values, config, field), "values", "config" and "field" are all optional.'
+        )
+
+    if has_kwargs:
+        return lambda cls, v, values, field, config: validator(cls, v, values=values, field=field, config=config)
+    elif args == set():
+        return lambda cls, v, values, field, config: validator(cls, v)
+    elif args == {'values'}:
+        return lambda cls, v, values, field, config: validator(cls, v, values=values)
+    elif args == {'field'}:
+        return lambda cls, v, values, field, config: validator(cls, v, field=field)
+    elif args == {'config'}:
+        return lambda cls, v, values, field, config: validator(cls, v, config=config)
+    elif args == {'values', 'field'}:
+        return lambda cls, v, values, field, config: validator(cls, v, values=values, field=field)
+    elif args == {'values', 'config'}:
+        return lambda cls, v, values, field, config: validator(cls, v, values=values, config=config)
+    elif args == {'field', 'config'}:
+        return lambda cls, v, values, field, config: validator(cls, v, field=field, config=config)
+    else:
+        # args == {'values', 'field', 'config'}
+        return lambda cls, v, values, field, config: validator(cls, v, values=values, field=field, config=config)
+
+
+def _generic_validator_basic(validator: AnyCallable, sig: 'Signature', args: Set[str]) -> 'ValidatorCallable':
+    has_kwargs = False
+    if 'kwargs' in args:
+        has_kwargs = True
+        args -= {'kwargs'}
+
+    if not args.issubset(all_kwargs):
+        raise ConfigError(
+            f'Invalid signature for validator {validator}: {sig}, should be: '
+            f'(value, values, config, field), "values", "config" and "field" are all optional.'
+        )
+
+    if has_kwargs:
+        return lambda cls, v, values, field, config: validator(v, values=values, field=field, config=config)
+    elif args == set():
+        return lambda cls, v, values, field, config: validator(v)
+    elif args == {'values'}:
+        return lambda cls, v, values, field, config: validator(v, values=values)
+    elif args == {'field'}:
+        return lambda cls, v, values, field, config: validator(v, field=field)
+    elif args == {'config'}:
+        return lambda cls, v, values, field, config: validator(v, config=config)
+    elif args == {'values', 'field'}:
+        return lambda cls, v, values, field, config: validator(v, values=values, field=field)
+    elif args == {'values', 'config'}:
+        return lambda cls, v, values, field, config: validator(v, values=values, config=config)
+    elif args == {'field', 'config'}:
+        return lambda cls, v, values, field, config: validator(v, field=field, config=config)
+    else:
+        # args == {'values', 'field', 'config'}
+        return lambda cls, v, values, field, config: validator(v, values=values, field=field, config=config)
+
+
+def gather_all_validators(type_: 'ModelOrDc') -> Dict[str, 'AnyClassMethod']:
+    all_attributes = ChainMap(*[cls.__dict__ for cls in type_.__mro__])  # type: ignore[arg-type,var-annotated]
+    return {
+        k: v
+        for k, v in all_attributes.items()
+        if hasattr(v, VALIDATOR_CONFIG_KEY) or hasattr(v, ROOT_VALIDATOR_CONFIG_KEY)
+    }
diff --git a/myenv/lib/python3.9/site-packages/pydantic/color.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/color.cpython-39-darwin.so
new file mode 100755
index 0000000..2d9898a
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/color.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/color.py b/myenv/lib/python3.9/site-packages/pydantic/color.py
new file mode 100644
index 0000000..b074f2e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/color.py
@@ -0,0 +1,488 @@
+"""
+Color definitions are  used as per CSS3 specification:
+http://www.w3.org/TR/css3-color/#svg-color
+
+A few colors have multiple names referring to the sames colors, eg. `grey` and `gray` or `aqua` and `cyan`.
+
+In these cases the LAST color when sorted alphabetically takes preferences,
+eg. Color((0, 255, 255)).as_named() == 'cyan' because "cyan" comes after "aqua".
+"""
+import math
+import re
+from colorsys import hls_to_rgb, rgb_to_hls
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union, cast
+
+from .errors import ColorError
+from .utils import Representation, almost_equal_floats
+
+if TYPE_CHECKING:
+    from .typing import CallableGenerator, ReprArgs
+
+ColorTuple = Union[Tuple[int, int, int], Tuple[int, int, int, float]]
+ColorType = Union[ColorTuple, str]
+HslColorTuple = Union[Tuple[float, float, float], Tuple[float, float, float, float]]
+
+
+class RGBA:
+    """
+    Internal use only as a representation of a color.
+    """
+
+    __slots__ = 'r', 'g', 'b', 'alpha', '_tuple'
+
+    def __init__(self, r: float, g: float, b: float, alpha: Optional[float]):
+        self.r = r
+        self.g = g
+        self.b = b
+        self.alpha = alpha
+
+        self._tuple: Tuple[float, float, float, Optional[float]] = (r, g, b, alpha)
+
+    def __getitem__(self, item: Any) -> Any:
+        return self._tuple[item]
+
+
+# these are not compiled here to avoid import slowdown, they'll be compiled the first time they're used, then cached
+r_hex_short = r'\s*(?:#|0x)?([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])?\s*'
+r_hex_long = r'\s*(?:#|0x)?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})?\s*'
+_r_255 = r'(\d{1,3}(?:\.\d+)?)'
+_r_comma = r'\s*,\s*'
+r_rgb = fr'\s*rgb\(\s*{_r_255}{_r_comma}{_r_255}{_r_comma}{_r_255}\)\s*'
+_r_alpha = r'(\d(?:\.\d+)?|\.\d+|\d{1,2}%)'
+r_rgba = fr'\s*rgba\(\s*{_r_255}{_r_comma}{_r_255}{_r_comma}{_r_255}{_r_comma}{_r_alpha}\s*\)\s*'
+_r_h = r'(-?\d+(?:\.\d+)?|-?\.\d+)(deg|rad|turn)?'
+_r_sl = r'(\d{1,3}(?:\.\d+)?)%'
+r_hsl = fr'\s*hsl\(\s*{_r_h}{_r_comma}{_r_sl}{_r_comma}{_r_sl}\s*\)\s*'
+r_hsla = fr'\s*hsl\(\s*{_r_h}{_r_comma}{_r_sl}{_r_comma}{_r_sl}{_r_comma}{_r_alpha}\s*\)\s*'
+
+# colors where the two hex characters are the same, if all colors match this the short version of hex colors can be used
+repeat_colors = {int(c * 2, 16) for c in '0123456789abcdef'}
+rads = 2 * math.pi
+
+
+class Color(Representation):
+    __slots__ = '_original', '_rgba'
+
+    def __init__(self, value: ColorType) -> None:
+        self._rgba: RGBA
+        self._original: ColorType
+        if isinstance(value, (tuple, list)):
+            self._rgba = parse_tuple(value)
+        elif isinstance(value, str):
+            self._rgba = parse_str(value)
+        elif isinstance(value, Color):
+            self._rgba = value._rgba
+            value = value._original
+        else:
+            raise ColorError(reason='value must be a tuple, list or string')
+
+        # if we've got here value must be a valid color
+        self._original = value
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        field_schema.update(type='string', format='color')
+
+    def original(self) -> ColorType:
+        """
+        Original value passed to Color
+        """
+        return self._original
+
+    def as_named(self, *, fallback: bool = False) -> str:
+        if self._rgba.alpha is None:
+            rgb = cast(Tuple[int, int, int], self.as_rgb_tuple())
+            try:
+                return COLORS_BY_VALUE[rgb]
+            except KeyError as e:
+                if fallback:
+                    return self.as_hex()
+                else:
+                    raise ValueError('no named color found, use fallback=True, as_hex() or as_rgb()') from e
+        else:
+            return self.as_hex()
+
+    def as_hex(self) -> str:
+        """
+        Hex string representing the color can be 3, 4, 6 or 8 characters depending on whether the string
+        a "short" representation of the color is possible and whether there's an alpha channel.
+        """
+        values = [float_to_255(c) for c in self._rgba[:3]]
+        if self._rgba.alpha is not None:
+            values.append(float_to_255(self._rgba.alpha))
+
+        as_hex = ''.join(f'{v:02x}' for v in values)
+        if all(c in repeat_colors for c in values):
+            as_hex = ''.join(as_hex[c] for c in range(0, len(as_hex), 2))
+        return '#' + as_hex
+
+    def as_rgb(self) -> str:
+        """
+        Color as an rgb(<r>, <g>, <b>) or rgba(<r>, <g>, <b>, <a>) string.
+        """
+        if self._rgba.alpha is None:
+            return f'rgb({float_to_255(self._rgba.r)}, {float_to_255(self._rgba.g)}, {float_to_255(self._rgba.b)})'
+        else:
+            return (
+                f'rgba({float_to_255(self._rgba.r)}, {float_to_255(self._rgba.g)}, {float_to_255(self._rgba.b)}, '
+                f'{round(self._alpha_float(), 2)})'
+            )
+
+    def as_rgb_tuple(self, *, alpha: Optional[bool] = None) -> ColorTuple:
+        """
+        Color as an RGB or RGBA tuple; red, green and blue are in the range 0 to 255, alpha if included is
+        in the range 0 to 1.
+
+        :param alpha: whether to include the alpha channel, options are
+          None - (default) include alpha only if it's set (e.g. not None)
+          True - always include alpha,
+          False - always omit alpha,
+        """
+        r, g, b = [float_to_255(c) for c in self._rgba[:3]]
+        if alpha is None:
+            if self._rgba.alpha is None:
+                return r, g, b
+            else:
+                return r, g, b, self._alpha_float()
+        elif alpha:
+            return r, g, b, self._alpha_float()
+        else:
+            # alpha is False
+            return r, g, b
+
+    def as_hsl(self) -> str:
+        """
+        Color as an hsl(<h>, <s>, <l>) or hsl(<h>, <s>, <l>, <a>) string.
+        """
+        if self._rgba.alpha is None:
+            h, s, li = self.as_hsl_tuple(alpha=False)  # type: ignore
+            return f'hsl({h * 360:0.0f}, {s:0.0%}, {li:0.0%})'
+        else:
+            h, s, li, a = self.as_hsl_tuple(alpha=True)  # type: ignore
+            return f'hsl({h * 360:0.0f}, {s:0.0%}, {li:0.0%}, {round(a, 2)})'
+
+    def as_hsl_tuple(self, *, alpha: Optional[bool] = None) -> HslColorTuple:
+        """
+        Color as an HSL or HSLA tuple, e.g. hue, saturation, lightness and optionally alpha; all elements are in
+        the range 0 to 1.
+
+        NOTE: this is HSL as used in HTML and most other places, not HLS as used in python's colorsys.
+
+        :param alpha: whether to include the alpha channel, options are
+          None - (default) include alpha only if it's set (e.g. not None)
+          True - always include alpha,
+          False - always omit alpha,
+        """
+        h, l, s = rgb_to_hls(self._rgba.r, self._rgba.g, self._rgba.b)
+        if alpha is None:
+            if self._rgba.alpha is None:
+                return h, s, l
+            else:
+                return h, s, l, self._alpha_float()
+        if alpha:
+            return h, s, l, self._alpha_float()
+        else:
+            # alpha is False
+            return h, s, l
+
+    def _alpha_float(self) -> float:
+        return 1 if self._rgba.alpha is None else self._rgba.alpha
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls
+
+    def __str__(self) -> str:
+        return self.as_named(fallback=True)
+
+    def __repr_args__(self) -> 'ReprArgs':
+        return [(None, self.as_named(fallback=True))] + [('rgb', self.as_rgb_tuple())]  # type: ignore
+
+
+def parse_tuple(value: Tuple[Any, ...]) -> RGBA:
+    """
+    Parse a tuple or list as a color.
+    """
+    if len(value) == 3:
+        r, g, b = [parse_color_value(v) for v in value]
+        return RGBA(r, g, b, None)
+    elif len(value) == 4:
+        r, g, b = [parse_color_value(v) for v in value[:3]]
+        return RGBA(r, g, b, parse_float_alpha(value[3]))
+    else:
+        raise ColorError(reason='tuples must have length 3 or 4')
+
+
+def parse_str(value: str) -> RGBA:
+    """
+    Parse a string to an RGBA tuple, trying the following formats (in this order):
+    * named color, see COLORS_BY_NAME below
+    * hex short eg. `<prefix>fff` (prefix can be `#`, `0x` or nothing)
+    * hex long eg. `<prefix>ffffff` (prefix can be `#`, `0x` or nothing)
+    * `rgb(<r>, <g>, <b>) `
+    * `rgba(<r>, <g>, <b>, <a>)`
+    """
+    value_lower = value.lower()
+    try:
+        r, g, b = COLORS_BY_NAME[value_lower]
+    except KeyError:
+        pass
+    else:
+        return ints_to_rgba(r, g, b, None)
+
+    m = re.fullmatch(r_hex_short, value_lower)
+    if m:
+        *rgb, a = m.groups()
+        r, g, b = [int(v * 2, 16) for v in rgb]
+        if a:
+            alpha: Optional[float] = int(a * 2, 16) / 255
+        else:
+            alpha = None
+        return ints_to_rgba(r, g, b, alpha)
+
+    m = re.fullmatch(r_hex_long, value_lower)
+    if m:
+        *rgb, a = m.groups()
+        r, g, b = [int(v, 16) for v in rgb]
+        if a:
+            alpha = int(a, 16) / 255
+        else:
+            alpha = None
+        return ints_to_rgba(r, g, b, alpha)
+
+    m = re.fullmatch(r_rgb, value_lower)
+    if m:
+        return ints_to_rgba(*m.groups(), None)  # type: ignore
+
+    m = re.fullmatch(r_rgba, value_lower)
+    if m:
+        return ints_to_rgba(*m.groups())  # type: ignore
+
+    m = re.fullmatch(r_hsl, value_lower)
+    if m:
+        h, h_units, s, l_ = m.groups()
+        return parse_hsl(h, h_units, s, l_)
+
+    m = re.fullmatch(r_hsla, value_lower)
+    if m:
+        h, h_units, s, l_, a = m.groups()
+        return parse_hsl(h, h_units, s, l_, parse_float_alpha(a))
+
+    raise ColorError(reason='string not recognised as a valid color')
+
+
+def ints_to_rgba(r: Union[int, str], g: Union[int, str], b: Union[int, str], alpha: Optional[float]) -> RGBA:
+    return RGBA(parse_color_value(r), parse_color_value(g), parse_color_value(b), parse_float_alpha(alpha))
+
+
+def parse_color_value(value: Union[int, str], max_val: int = 255) -> float:
+    """
+    Parse a value checking it's a valid int in the range 0 to max_val and divide by max_val to give a number
+    in the range 0 to 1
+    """
+    try:
+        color = float(value)
+    except ValueError:
+        raise ColorError(reason='color values must be a valid number')
+    if 0 <= color <= max_val:
+        return color / max_val
+    else:
+        raise ColorError(reason=f'color values must be in the range 0 to {max_val}')
+
+
+def parse_float_alpha(value: Union[None, str, float, int]) -> Optional[float]:
+    """
+    Parse a value checking it's a valid float in the range 0 to 1
+    """
+    if value is None:
+        return None
+    try:
+        if isinstance(value, str) and value.endswith('%'):
+            alpha = float(value[:-1]) / 100
+        else:
+            alpha = float(value)
+    except ValueError:
+        raise ColorError(reason='alpha values must be a valid float')
+
+    if almost_equal_floats(alpha, 1):
+        return None
+    elif 0 <= alpha <= 1:
+        return alpha
+    else:
+        raise ColorError(reason='alpha values must be in the range 0 to 1')
+
+
+def parse_hsl(h: str, h_units: str, sat: str, light: str, alpha: Optional[float] = None) -> RGBA:
+    """
+    Parse raw hue, saturation, lightness and alpha values and convert to RGBA.
+    """
+    s_value, l_value = parse_color_value(sat, 100), parse_color_value(light, 100)
+
+    h_value = float(h)
+    if h_units in {None, 'deg'}:
+        h_value = h_value % 360 / 360
+    elif h_units == 'rad':
+        h_value = h_value % rads / rads
+    else:
+        # turns
+        h_value = h_value % 1
+
+    r, g, b = hls_to_rgb(h_value, l_value, s_value)
+    return RGBA(r, g, b, alpha)
+
+
+def float_to_255(c: float) -> int:
+    return int(round(c * 255))
+
+
+COLORS_BY_NAME = {
+    'aliceblue': (240, 248, 255),
+    'antiquewhite': (250, 235, 215),
+    'aqua': (0, 255, 255),
+    'aquamarine': (127, 255, 212),
+    'azure': (240, 255, 255),
+    'beige': (245, 245, 220),
+    'bisque': (255, 228, 196),
+    'black': (0, 0, 0),
+    'blanchedalmond': (255, 235, 205),
+    'blue': (0, 0, 255),
+    'blueviolet': (138, 43, 226),
+    'brown': (165, 42, 42),
+    'burlywood': (222, 184, 135),
+    'cadetblue': (95, 158, 160),
+    'chartreuse': (127, 255, 0),
+    'chocolate': (210, 105, 30),
+    'coral': (255, 127, 80),
+    'cornflowerblue': (100, 149, 237),
+    'cornsilk': (255, 248, 220),
+    'crimson': (220, 20, 60),
+    'cyan': (0, 255, 255),
+    'darkblue': (0, 0, 139),
+    'darkcyan': (0, 139, 139),
+    'darkgoldenrod': (184, 134, 11),
+    'darkgray': (169, 169, 169),
+    'darkgreen': (0, 100, 0),
+    'darkgrey': (169, 169, 169),
+    'darkkhaki': (189, 183, 107),
+    'darkmagenta': (139, 0, 139),
+    'darkolivegreen': (85, 107, 47),
+    'darkorange': (255, 140, 0),
+    'darkorchid': (153, 50, 204),
+    'darkred': (139, 0, 0),
+    'darksalmon': (233, 150, 122),
+    'darkseagreen': (143, 188, 143),
+    'darkslateblue': (72, 61, 139),
+    'darkslategray': (47, 79, 79),
+    'darkslategrey': (47, 79, 79),
+    'darkturquoise': (0, 206, 209),
+    'darkviolet': (148, 0, 211),
+    'deeppink': (255, 20, 147),
+    'deepskyblue': (0, 191, 255),
+    'dimgray': (105, 105, 105),
+    'dimgrey': (105, 105, 105),
+    'dodgerblue': (30, 144, 255),
+    'firebrick': (178, 34, 34),
+    'floralwhite': (255, 250, 240),
+    'forestgreen': (34, 139, 34),
+    'fuchsia': (255, 0, 255),
+    'gainsboro': (220, 220, 220),
+    'ghostwhite': (248, 248, 255),
+    'gold': (255, 215, 0),
+    'goldenrod': (218, 165, 32),
+    'gray': (128, 128, 128),
+    'green': (0, 128, 0),
+    'greenyellow': (173, 255, 47),
+    'grey': (128, 128, 128),
+    'honeydew': (240, 255, 240),
+    'hotpink': (255, 105, 180),
+    'indianred': (205, 92, 92),
+    'indigo': (75, 0, 130),
+    'ivory': (255, 255, 240),
+    'khaki': (240, 230, 140),
+    'lavender': (230, 230, 250),
+    'lavenderblush': (255, 240, 245),
+    'lawngreen': (124, 252, 0),
+    'lemonchiffon': (255, 250, 205),
+    'lightblue': (173, 216, 230),
+    'lightcoral': (240, 128, 128),
+    'lightcyan': (224, 255, 255),
+    'lightgoldenrodyellow': (250, 250, 210),
+    'lightgray': (211, 211, 211),
+    'lightgreen': (144, 238, 144),
+    'lightgrey': (211, 211, 211),
+    'lightpink': (255, 182, 193),
+    'lightsalmon': (255, 160, 122),
+    'lightseagreen': (32, 178, 170),
+    'lightskyblue': (135, 206, 250),
+    'lightslategray': (119, 136, 153),
+    'lightslategrey': (119, 136, 153),
+    'lightsteelblue': (176, 196, 222),
+    'lightyellow': (255, 255, 224),
+    'lime': (0, 255, 0),
+    'limegreen': (50, 205, 50),
+    'linen': (250, 240, 230),
+    'magenta': (255, 0, 255),
+    'maroon': (128, 0, 0),
+    'mediumaquamarine': (102, 205, 170),
+    'mediumblue': (0, 0, 205),
+    'mediumorchid': (186, 85, 211),
+    'mediumpurple': (147, 112, 219),
+    'mediumseagreen': (60, 179, 113),
+    'mediumslateblue': (123, 104, 238),
+    'mediumspringgreen': (0, 250, 154),
+    'mediumturquoise': (72, 209, 204),
+    'mediumvioletred': (199, 21, 133),
+    'midnightblue': (25, 25, 112),
+    'mintcream': (245, 255, 250),
+    'mistyrose': (255, 228, 225),
+    'moccasin': (255, 228, 181),
+    'navajowhite': (255, 222, 173),
+    'navy': (0, 0, 128),
+    'oldlace': (253, 245, 230),
+    'olive': (128, 128, 0),
+    'olivedrab': (107, 142, 35),
+    'orange': (255, 165, 0),
+    'orangered': (255, 69, 0),
+    'orchid': (218, 112, 214),
+    'palegoldenrod': (238, 232, 170),
+    'palegreen': (152, 251, 152),
+    'paleturquoise': (175, 238, 238),
+    'palevioletred': (219, 112, 147),
+    'papayawhip': (255, 239, 213),
+    'peachpuff': (255, 218, 185),
+    'peru': (205, 133, 63),
+    'pink': (255, 192, 203),
+    'plum': (221, 160, 221),
+    'powderblue': (176, 224, 230),
+    'purple': (128, 0, 128),
+    'red': (255, 0, 0),
+    'rosybrown': (188, 143, 143),
+    'royalblue': (65, 105, 225),
+    'saddlebrown': (139, 69, 19),
+    'salmon': (250, 128, 114),
+    'sandybrown': (244, 164, 96),
+    'seagreen': (46, 139, 87),
+    'seashell': (255, 245, 238),
+    'sienna': (160, 82, 45),
+    'silver': (192, 192, 192),
+    'skyblue': (135, 206, 235),
+    'slateblue': (106, 90, 205),
+    'slategray': (112, 128, 144),
+    'slategrey': (112, 128, 144),
+    'snow': (255, 250, 250),
+    'springgreen': (0, 255, 127),
+    'steelblue': (70, 130, 180),
+    'tan': (210, 180, 140),
+    'teal': (0, 128, 128),
+    'thistle': (216, 191, 216),
+    'tomato': (255, 99, 71),
+    'turquoise': (64, 224, 208),
+    'violet': (238, 130, 238),
+    'wheat': (245, 222, 179),
+    'white': (255, 255, 255),
+    'whitesmoke': (245, 245, 245),
+    'yellow': (255, 255, 0),
+    'yellowgreen': (154, 205, 50),
+}
+
+COLORS_BY_VALUE = {v: k for k, v in COLORS_BY_NAME.items()}
diff --git a/myenv/lib/python3.9/site-packages/pydantic/config.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/config.cpython-39-darwin.so
new file mode 100755
index 0000000..8438d82
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/config.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/config.py b/myenv/lib/python3.9/site-packages/pydantic/config.py
new file mode 100644
index 0000000..b37cd98
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/config.py
@@ -0,0 +1,126 @@
+import json
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple, Type, Union
+
+from .typing import AnyCallable
+from .utils import GetterDict
+
+if TYPE_CHECKING:
+    from typing import overload
+
+    import typing_extensions
+
+    from .fields import ModelField
+    from .main import BaseModel
+
+    ConfigType = Type['BaseConfig']
+
+    class SchemaExtraCallable(typing_extensions.Protocol):
+        @overload
+        def __call__(self, schema: Dict[str, Any]) -> None:
+            pass
+
+        @overload
+        def __call__(self, schema: Dict[str, Any], model_class: Type[BaseModel]) -> None:
+            pass
+
+else:
+    SchemaExtraCallable = Callable[..., None]
+
+__all__ = 'BaseConfig', 'Extra', 'inherit_config', 'prepare_config'
+
+
+class Extra(str, Enum):
+    allow = 'allow'
+    ignore = 'ignore'
+    forbid = 'forbid'
+
+
+class BaseConfig:
+    title: Optional[str] = None
+    anystr_lower: bool = False
+    anystr_strip_whitespace: bool = False
+    min_anystr_length: int = 0
+    max_anystr_length: Optional[int] = None
+    validate_all: bool = False
+    extra: Extra = Extra.ignore
+    allow_mutation: bool = True
+    frozen: bool = False
+    allow_population_by_field_name: bool = False
+    use_enum_values: bool = False
+    fields: Dict[str, Union[str, Dict[str, str]]] = {}
+    validate_assignment: bool = False
+    error_msg_templates: Dict[str, str] = {}
+    arbitrary_types_allowed: bool = False
+    orm_mode: bool = False
+    getter_dict: Type[GetterDict] = GetterDict
+    alias_generator: Optional[Callable[[str], str]] = None
+    keep_untouched: Tuple[type, ...] = ()
+    schema_extra: Union[Dict[str, Any], 'SchemaExtraCallable'] = {}
+    json_loads: Callable[[str], Any] = json.loads
+    json_dumps: Callable[..., str] = json.dumps
+    # key type should include ForwardRef, but that breaks with python3.6
+    json_encoders: Dict[Union[Type[Any], str], AnyCallable] = {}
+    underscore_attrs_are_private: bool = False
+
+    # whether inherited models as fields should be reconstructed as base model
+    copy_on_model_validation: bool = True
+    # whether `Union` should check all allowed types before even trying to coerce
+    smart_union: bool = False
+
+    @classmethod
+    def get_field_info(cls, name: str) -> Dict[str, Any]:
+        """
+        Get properties of FieldInfo from the `fields` property of the config class.
+        """
+
+        fields_value = cls.fields.get(name)
+
+        if isinstance(fields_value, str):
+            field_info: Dict[str, Any] = {'alias': fields_value}
+        elif isinstance(fields_value, dict):
+            field_info = fields_value
+        else:
+            field_info = {}
+
+        if 'alias' in field_info:
+            field_info.setdefault('alias_priority', 2)
+
+        if field_info.get('alias_priority', 0) <= 1 and cls.alias_generator:
+            alias = cls.alias_generator(name)
+            if not isinstance(alias, str):
+                raise TypeError(f'Config.alias_generator must return str, not {alias.__class__}')
+            field_info.update(alias=alias, alias_priority=1)
+        return field_info
+
+    @classmethod
+    def prepare_field(cls, field: 'ModelField') -> None:
+        """
+        Optional hook to check or modify fields during model creation.
+        """
+        pass
+
+
+def inherit_config(self_config: 'ConfigType', parent_config: 'ConfigType', **namespace: Any) -> 'ConfigType':
+    if not self_config:
+        base_classes: Tuple['ConfigType', ...] = (parent_config,)
+    elif self_config == parent_config:
+        base_classes = (self_config,)
+    else:
+        base_classes = self_config, parent_config
+
+    namespace['json_encoders'] = {
+        **getattr(parent_config, 'json_encoders', {}),
+        **getattr(self_config, 'json_encoders', {}),
+        **namespace.get('json_encoders', {}),
+    }
+
+    return type('Config', base_classes, namespace)
+
+
+def prepare_config(config: Type[BaseConfig], cls_name: str) -> None:
+    if not isinstance(config.extra, Extra):
+        try:
+            config.extra = Extra(config.extra)
+        except ValueError:
+            raise ValueError(f'"{cls_name}": {config.extra} is not a valid value for "extra"')
diff --git a/myenv/lib/python3.9/site-packages/pydantic/dataclasses.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/dataclasses.cpython-39-darwin.so
new file mode 100755
index 0000000..8b2b0c5
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/dataclasses.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/dataclasses.py b/myenv/lib/python3.9/site-packages/pydantic/dataclasses.py
new file mode 100644
index 0000000..692bfb9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/dataclasses.py
@@ -0,0 +1,277 @@
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Dict, Optional, Type, TypeVar, Union, overload
+
+from .class_validators import gather_all_validators
+from .error_wrappers import ValidationError
+from .errors import DataclassTypeError
+from .fields import Field, FieldInfo, Required, Undefined
+from .main import __dataclass_transform__, create_model, validate_model
+from .typing import resolve_annotations
+from .utils import ClassAttribute
+
+if TYPE_CHECKING:
+    from .config import BaseConfig
+    from .main import BaseModel
+    from .typing import CallableGenerator, NoArgAnyCallable
+
+    DataclassT = TypeVar('DataclassT', bound='Dataclass')
+
+    class Dataclass:
+        __pydantic_model__: ClassVar[Type[BaseModel]]
+        __initialised__: ClassVar[bool]
+        __post_init_original__: ClassVar[Optional[Callable[..., None]]]
+        __processed__: ClassVar[Optional[ClassAttribute]]
+        __has_field_info_default__: ClassVar[bool]  # whether or not a `pydantic.Field` is used as default value
+
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            pass
+
+        @classmethod
+        def __get_validators__(cls: Type['Dataclass']) -> 'CallableGenerator':
+            pass
+
+        @classmethod
+        def __validate__(cls: Type['DataclassT'], v: Any) -> 'DataclassT':
+            pass
+
+        def __call__(self: 'DataclassT', *args: Any, **kwargs: Any) -> 'DataclassT':
+            pass
+
+
+def _validate_dataclass(cls: Type['DataclassT'], v: Any) -> 'DataclassT':
+    if isinstance(v, cls):
+        return v
+    elif isinstance(v, (list, tuple)):
+        return cls(*v)
+    elif isinstance(v, dict):
+        return cls(**v)
+    # In nested dataclasses, v can be of type `dataclasses.dataclass`.
+    # But to validate fields `cls` will be in fact a `pydantic.dataclasses.dataclass`,
+    # which inherits directly from the class of `v`.
+    elif is_builtin_dataclass(v) and cls.__bases__[0] is type(v):
+        import dataclasses
+
+        return cls(**dataclasses.asdict(v))
+    else:
+        raise DataclassTypeError(class_name=cls.__name__)
+
+
+def _get_validators(cls: Type['Dataclass']) -> 'CallableGenerator':
+    yield cls.__validate__
+
+
+def setattr_validate_assignment(self: 'Dataclass', name: str, value: Any) -> None:
+    if self.__initialised__:
+        d = dict(self.__dict__)
+        d.pop(name, None)
+        known_field = self.__pydantic_model__.__fields__.get(name, None)
+        if known_field:
+            value, error_ = known_field.validate(value, d, loc=name, cls=self.__class__)
+            if error_:
+                raise ValidationError([error_], self.__class__)
+
+    object.__setattr__(self, name, value)
+
+
+def is_builtin_dataclass(_cls: Type[Any]) -> bool:
+    """
+    `dataclasses.is_dataclass` is True if one of the class parents is a `dataclass`.
+    This is why we also add a class attribute `__processed__` to only consider 'direct' built-in dataclasses
+    """
+    import dataclasses
+
+    return not hasattr(_cls, '__processed__') and dataclasses.is_dataclass(_cls)
+
+
+def _generate_pydantic_post_init(
+    post_init_original: Optional[Callable[..., None]], post_init_post_parse: Optional[Callable[..., None]]
+) -> Callable[..., None]:
+    def _pydantic_post_init(self: 'Dataclass', *initvars: Any) -> None:
+        if post_init_original is not None:
+            post_init_original(self, *initvars)
+
+        if getattr(self, '__has_field_info_default__', False):
+            # We need to remove `FieldInfo` values since they are not valid as input
+            # It's ok to do that because they are obviously the default values!
+            input_data = {k: v for k, v in self.__dict__.items() if not isinstance(v, FieldInfo)}
+        else:
+            input_data = self.__dict__
+        d, _, validation_error = validate_model(self.__pydantic_model__, input_data, cls=self.__class__)
+        if validation_error:
+            raise validation_error
+        object.__setattr__(self, '__dict__', {**getattr(self, '__dict__', {}), **d})
+        object.__setattr__(self, '__initialised__', True)
+        if post_init_post_parse is not None:
+            post_init_post_parse(self, *initvars)
+
+    return _pydantic_post_init
+
+
+def _process_class(
+    _cls: Type[Any],
+    init: bool,
+    repr: bool,
+    eq: bool,
+    order: bool,
+    unsafe_hash: bool,
+    frozen: bool,
+    config: Optional[Type[Any]],
+) -> Type['Dataclass']:
+    import dataclasses
+
+    post_init_original = getattr(_cls, '__post_init__', None)
+    if post_init_original and post_init_original.__name__ == '_pydantic_post_init':
+        post_init_original = None
+    if not post_init_original:
+        post_init_original = getattr(_cls, '__post_init_original__', None)
+
+    post_init_post_parse = getattr(_cls, '__post_init_post_parse__', None)
+
+    _pydantic_post_init = _generate_pydantic_post_init(post_init_original, post_init_post_parse)
+
+    # If the class is already a dataclass, __post_init__ will not be called automatically
+    # so no validation will be added.
+    # We hence create dynamically a new dataclass:
+    # ```
+    # @dataclasses.dataclass
+    # class NewClass(_cls):
+    #   __post_init__ = _pydantic_post_init
+    # ```
+    # with the exact same fields as the base dataclass
+    # and register it on module level to address pickle problem:
+    # https://github.com/samuelcolvin/pydantic/issues/2111
+    if is_builtin_dataclass(_cls):
+        uniq_class_name = f'_Pydantic_{_cls.__name__}_{id(_cls)}'
+        _cls = type(
+            # for pretty output new class will have the name as original
+            _cls.__name__,
+            (_cls,),
+            {
+                '__annotations__': resolve_annotations(_cls.__annotations__, _cls.__module__),
+                '__post_init__': _pydantic_post_init,
+                # attrs for pickle to find this class
+                '__module__': __name__,
+                '__qualname__': uniq_class_name,
+            },
+        )
+        globals()[uniq_class_name] = _cls
+    else:
+        _cls.__post_init__ = _pydantic_post_init
+    cls: Type['Dataclass'] = dataclasses.dataclass(  # type: ignore
+        _cls, init=init, repr=repr, eq=eq, order=order, unsafe_hash=unsafe_hash, frozen=frozen
+    )
+    cls.__processed__ = ClassAttribute('__processed__', True)
+
+    field_definitions: Dict[str, Any] = {}
+    for field in dataclasses.fields(cls):
+        default: Any = Undefined
+        default_factory: Optional['NoArgAnyCallable'] = None
+        field_info: FieldInfo
+
+        if field.default is not dataclasses.MISSING:
+            default = field.default
+        elif field.default_factory is not dataclasses.MISSING:
+            default_factory = field.default_factory
+        else:
+            default = Required
+
+        if isinstance(default, FieldInfo):
+            field_info = default
+            cls.__has_field_info_default__ = True
+        else:
+            field_info = Field(default=default, default_factory=default_factory, **field.metadata)
+
+        field_definitions[field.name] = (field.type, field_info)
+
+    validators = gather_all_validators(cls)
+    cls.__pydantic_model__ = create_model(
+        cls.__name__,
+        __config__=config,
+        __module__=_cls.__module__,
+        __validators__=validators,
+        __cls_kwargs__={'__resolve_forward_refs__': False},
+        **field_definitions,
+    )
+
+    cls.__initialised__ = False
+    cls.__validate__ = classmethod(_validate_dataclass)  # type: ignore[assignment]
+    cls.__get_validators__ = classmethod(_get_validators)  # type: ignore[assignment]
+    if post_init_original:
+        cls.__post_init_original__ = post_init_original
+
+    if cls.__pydantic_model__.__config__.validate_assignment and not frozen:
+        cls.__setattr__ = setattr_validate_assignment  # type: ignore[assignment]
+
+    cls.__pydantic_model__.__try_update_forward_refs__(**{cls.__name__: cls})
+
+    return cls
+
+
+@__dataclass_transform__(kw_only_default=True, field_descriptors=(Field, FieldInfo))
+@overload
+def dataclass(
+    *,
+    init: bool = True,
+    repr: bool = True,
+    eq: bool = True,
+    order: bool = False,
+    unsafe_hash: bool = False,
+    frozen: bool = False,
+    config: Type[Any] = None,
+) -> Callable[[Type[Any]], Type['Dataclass']]:
+    ...
+
+
+@__dataclass_transform__(kw_only_default=True, field_descriptors=(Field, FieldInfo))
+@overload
+def dataclass(
+    _cls: Type[Any],
+    *,
+    init: bool = True,
+    repr: bool = True,
+    eq: bool = True,
+    order: bool = False,
+    unsafe_hash: bool = False,
+    frozen: bool = False,
+    config: Type[Any] = None,
+) -> Type['Dataclass']:
+    ...
+
+
+@__dataclass_transform__(kw_only_default=True, field_descriptors=(Field, FieldInfo))
+def dataclass(
+    _cls: Optional[Type[Any]] = None,
+    *,
+    init: bool = True,
+    repr: bool = True,
+    eq: bool = True,
+    order: bool = False,
+    unsafe_hash: bool = False,
+    frozen: bool = False,
+    config: Type[Any] = None,
+) -> Union[Callable[[Type[Any]], Type['Dataclass']], Type['Dataclass']]:
+    """
+    Like the python standard lib dataclasses but with type validation.
+
+    Arguments are the same as for standard dataclasses, except for validate_assignment which has the same meaning
+    as Config.validate_assignment.
+    """
+
+    def wrap(cls: Type[Any]) -> Type['Dataclass']:
+        return _process_class(cls, init, repr, eq, order, unsafe_hash, frozen, config)
+
+    if _cls is None:
+        return wrap
+
+    return wrap(_cls)
+
+
+def make_dataclass_validator(_cls: Type[Any], config: Type['BaseConfig']) -> 'CallableGenerator':
+    """
+    Create a pydantic.dataclass from a builtin dataclass to add type validation
+    and yield the validators
+    It retrieves the parameters of the dataclass and forwards them to the newly created dataclass
+    """
+    dataclass_params = _cls.__dataclass_params__
+    stdlib_dataclass_parameters = {param: getattr(dataclass_params, param) for param in dataclass_params.__slots__}
+    cls = dataclass(_cls, config=config, **stdlib_dataclass_parameters)
+    yield from _get_validators(cls)
diff --git a/myenv/lib/python3.9/site-packages/pydantic/datetime_parse.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/datetime_parse.cpython-39-darwin.so
new file mode 100755
index 0000000..be12b6b
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/datetime_parse.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/datetime_parse.py b/myenv/lib/python3.9/site-packages/pydantic/datetime_parse.py
new file mode 100644
index 0000000..024a899
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/datetime_parse.py
@@ -0,0 +1,248 @@
+"""
+Functions to parse datetime objects.
+
+We're using regular expressions rather than time.strptime because:
+- They provide both validation and parsing.
+- They're more flexible for datetimes.
+- The date/datetime/time constructors produce friendlier error messages.
+
+Stolen from https://raw.githubusercontent.com/django/django/master/django/utils/dateparse.py at
+9718fa2e8abe430c3526a9278dd976443d4ae3c6
+
+Changed to:
+* use standard python datetime types not django.utils.timezone
+* raise ValueError when regex doesn't match rather than returning None
+* support parsing unix timestamps for dates and datetimes
+"""
+import re
+from datetime import date, datetime, time, timedelta, timezone
+from typing import Dict, Optional, Type, Union
+
+from . import errors
+
+date_expr = r'(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})'
+time_expr = (
+    r'(?P<hour>\d{1,2}):(?P<minute>\d{1,2})'
+    r'(?::(?P<second>\d{1,2})(?:\.(?P<microsecond>\d{1,6})\d{0,6})?)?'
+    r'(?P<tzinfo>Z|[+-]\d{2}(?::?\d{2})?)?$'
+)
+
+date_re = re.compile(f'{date_expr}$')
+time_re = re.compile(time_expr)
+datetime_re = re.compile(f'{date_expr}[T ]{time_expr}')
+
+standard_duration_re = re.compile(
+    r'^'
+    r'(?:(?P<days>-?\d+) (days?, )?)?'
+    r'((?:(?P<hours>-?\d+):)(?=\d+:\d+))?'
+    r'(?:(?P<minutes>-?\d+):)?'
+    r'(?P<seconds>-?\d+)'
+    r'(?:\.(?P<microseconds>\d{1,6})\d{0,6})?'
+    r'$'
+)
+
+# Support the sections of ISO 8601 date representation that are accepted by timedelta
+iso8601_duration_re = re.compile(
+    r'^(?P<sign>[-+]?)'
+    r'P'
+    r'(?:(?P<days>\d+(.\d+)?)D)?'
+    r'(?:T'
+    r'(?:(?P<hours>\d+(.\d+)?)H)?'
+    r'(?:(?P<minutes>\d+(.\d+)?)M)?'
+    r'(?:(?P<seconds>\d+(.\d+)?)S)?'
+    r')?'
+    r'$'
+)
+
+EPOCH = datetime(1970, 1, 1)
+# if greater than this, the number is in ms, if less than or equal it's in seconds
+# (in seconds this is 11th October 2603, in ms it's 20th August 1970)
+MS_WATERSHED = int(2e10)
+# slightly more than datetime.max in ns - (datetime.max - EPOCH).total_seconds() * 1e9
+MAX_NUMBER = int(3e20)
+StrBytesIntFloat = Union[str, bytes, int, float]
+
+
+def get_numeric(value: StrBytesIntFloat, native_expected_type: str) -> Union[None, int, float]:
+    if isinstance(value, (int, float)):
+        return value
+    try:
+        return float(value)
+    except ValueError:
+        return None
+    except TypeError:
+        raise TypeError(f'invalid type; expected {native_expected_type}, string, bytes, int or float')
+
+
+def from_unix_seconds(seconds: Union[int, float]) -> datetime:
+    if seconds > MAX_NUMBER:
+        return datetime.max
+    elif seconds < -MAX_NUMBER:
+        return datetime.min
+
+    while abs(seconds) > MS_WATERSHED:
+        seconds /= 1000
+    dt = EPOCH + timedelta(seconds=seconds)
+    return dt.replace(tzinfo=timezone.utc)
+
+
+def _parse_timezone(value: Optional[str], error: Type[Exception]) -> Union[None, int, timezone]:
+    if value == 'Z':
+        return timezone.utc
+    elif value is not None:
+        offset_mins = int(value[-2:]) if len(value) > 3 else 0
+        offset = 60 * int(value[1:3]) + offset_mins
+        if value[0] == '-':
+            offset = -offset
+        try:
+            return timezone(timedelta(minutes=offset))
+        except ValueError:
+            raise error()
+    else:
+        return None
+
+
+def parse_date(value: Union[date, StrBytesIntFloat]) -> date:
+    """
+    Parse a date/int/float/string and return a datetime.date.
+
+    Raise ValueError if the input is well formatted but not a valid date.
+    Raise ValueError if the input isn't well formatted.
+    """
+    if isinstance(value, date):
+        if isinstance(value, datetime):
+            return value.date()
+        else:
+            return value
+
+    number = get_numeric(value, 'date')
+    if number is not None:
+        return from_unix_seconds(number).date()
+
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    match = date_re.match(value)  # type: ignore
+    if match is None:
+        raise errors.DateError()
+
+    kw = {k: int(v) for k, v in match.groupdict().items()}
+
+    try:
+        return date(**kw)
+    except ValueError:
+        raise errors.DateError()
+
+
+def parse_time(value: Union[time, StrBytesIntFloat]) -> time:
+    """
+    Parse a time/string and return a datetime.time.
+
+    Raise ValueError if the input is well formatted but not a valid time.
+    Raise ValueError if the input isn't well formatted, in particular if it contains an offset.
+    """
+    if isinstance(value, time):
+        return value
+
+    number = get_numeric(value, 'time')
+    if number is not None:
+        if number >= 86400:
+            # doesn't make sense since the time time loop back around to 0
+            raise errors.TimeError()
+        return (datetime.min + timedelta(seconds=number)).time()
+
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    match = time_re.match(value)  # type: ignore
+    if match is None:
+        raise errors.TimeError()
+
+    kw = match.groupdict()
+    if kw['microsecond']:
+        kw['microsecond'] = kw['microsecond'].ljust(6, '0')
+
+    tzinfo = _parse_timezone(kw.pop('tzinfo'), errors.TimeError)
+    kw_: Dict[str, Union[None, int, timezone]] = {k: int(v) for k, v in kw.items() if v is not None}
+    kw_['tzinfo'] = tzinfo
+
+    try:
+        return time(**kw_)  # type: ignore
+    except ValueError:
+        raise errors.TimeError()
+
+
+def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime:
+    """
+    Parse a datetime/int/float/string and return a datetime.datetime.
+
+    This function supports time zone offsets. When the input contains one,
+    the output uses a timezone with a fixed offset from UTC.
+
+    Raise ValueError if the input is well formatted but not a valid datetime.
+    Raise ValueError if the input isn't well formatted.
+    """
+    if isinstance(value, datetime):
+        return value
+
+    number = get_numeric(value, 'datetime')
+    if number is not None:
+        return from_unix_seconds(number)
+
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    match = datetime_re.match(value)  # type: ignore
+    if match is None:
+        raise errors.DateTimeError()
+
+    kw = match.groupdict()
+    if kw['microsecond']:
+        kw['microsecond'] = kw['microsecond'].ljust(6, '0')
+
+    tzinfo = _parse_timezone(kw.pop('tzinfo'), errors.DateTimeError)
+    kw_: Dict[str, Union[None, int, timezone]] = {k: int(v) for k, v in kw.items() if v is not None}
+    kw_['tzinfo'] = tzinfo
+
+    try:
+        return datetime(**kw_)  # type: ignore
+    except ValueError:
+        raise errors.DateTimeError()
+
+
+def parse_duration(value: StrBytesIntFloat) -> timedelta:
+    """
+    Parse a duration int/float/string and return a datetime.timedelta.
+
+    The preferred format for durations in Django is '%d %H:%M:%S.%f'.
+
+    Also supports ISO 8601 representation.
+    """
+    if isinstance(value, timedelta):
+        return value
+
+    if isinstance(value, (int, float)):
+        # below code requires a string
+        value = str(value)
+    elif isinstance(value, bytes):
+        value = value.decode()
+
+    try:
+        match = standard_duration_re.match(value) or iso8601_duration_re.match(value)
+    except TypeError:
+        raise TypeError('invalid type; expected timedelta, string, bytes, int or float')
+
+    if not match:
+        raise errors.DurationError()
+
+    kw = match.groupdict()
+    sign = -1 if kw.pop('sign', '+') == '-' else 1
+    if kw.get('microseconds'):
+        kw['microseconds'] = kw['microseconds'].ljust(6, '0')
+
+    if kw.get('seconds') and kw.get('microseconds') and kw['seconds'].startswith('-'):
+        kw['microseconds'] = '-' + kw['microseconds']
+
+    kw_ = {k: float(v) for k, v in kw.items() if v is not None}
+
+    return sign * timedelta(**kw_)
diff --git a/myenv/lib/python3.9/site-packages/pydantic/decorator.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/decorator.cpython-39-darwin.so
new file mode 100755
index 0000000..bff3809
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/decorator.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/decorator.py b/myenv/lib/python3.9/site-packages/pydantic/decorator.py
new file mode 100644
index 0000000..ced4953
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/decorator.py
@@ -0,0 +1,259 @@
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Tuple, Type, TypeVar, Union, overload
+
+from . import validator
+from .config import Extra
+from .errors import ConfigError
+from .main import BaseModel, create_model
+from .typing import get_all_type_hints
+from .utils import to_camel
+
+__all__ = ('validate_arguments',)
+
+if TYPE_CHECKING:
+    from .typing import AnyCallable
+
+    AnyCallableT = TypeVar('AnyCallableT', bound=AnyCallable)
+    ConfigType = Union[None, Type[Any], Dict[str, Any]]
+
+
+@overload
+def validate_arguments(func: None = None, *, config: 'ConfigType' = None) -> Callable[['AnyCallableT'], 'AnyCallableT']:
+    ...
+
+
+@overload
+def validate_arguments(func: 'AnyCallableT') -> 'AnyCallableT':
+    ...
+
+
+def validate_arguments(func: Optional['AnyCallableT'] = None, *, config: 'ConfigType' = None) -> Any:
+    """
+    Decorator to validate the arguments passed to a function.
+    """
+
+    def validate(_func: 'AnyCallable') -> 'AnyCallable':
+        vd = ValidatedFunction(_func, config)
+
+        @wraps(_func)
+        def wrapper_function(*args: Any, **kwargs: Any) -> Any:
+            return vd.call(*args, **kwargs)
+
+        wrapper_function.vd = vd  # type: ignore
+        wrapper_function.validate = vd.init_model_instance  # type: ignore
+        wrapper_function.raw_function = vd.raw_function  # type: ignore
+        wrapper_function.model = vd.model  # type: ignore
+        return wrapper_function
+
+    if func:
+        return validate(func)
+    else:
+        return validate
+
+
+ALT_V_ARGS = 'v__args'
+ALT_V_KWARGS = 'v__kwargs'
+V_POSITIONAL_ONLY_NAME = 'v__positional_only'
+V_DUPLICATE_KWARGS = 'v__duplicate_kwargs'
+
+
+class ValidatedFunction:
+    def __init__(self, function: 'AnyCallableT', config: 'ConfigType'):  # noqa C901
+        from inspect import Parameter, signature
+
+        parameters: Mapping[str, Parameter] = signature(function).parameters
+
+        if parameters.keys() & {ALT_V_ARGS, ALT_V_KWARGS, V_POSITIONAL_ONLY_NAME, V_DUPLICATE_KWARGS}:
+            raise ConfigError(
+                f'"{ALT_V_ARGS}", "{ALT_V_KWARGS}", "{V_POSITIONAL_ONLY_NAME}" and "{V_DUPLICATE_KWARGS}" '
+                f'are not permitted as argument names when using the "{validate_arguments.__name__}" decorator'
+            )
+
+        self.raw_function = function
+        self.arg_mapping: Dict[int, str] = {}
+        self.positional_only_args = set()
+        self.v_args_name = 'args'
+        self.v_kwargs_name = 'kwargs'
+
+        type_hints = get_all_type_hints(function)
+        takes_args = False
+        takes_kwargs = False
+        fields: Dict[str, Tuple[Any, Any]] = {}
+        for i, (name, p) in enumerate(parameters.items()):
+            if p.annotation is p.empty:
+                annotation = Any
+            else:
+                annotation = type_hints[name]
+
+            default = ... if p.default is p.empty else p.default
+            if p.kind == Parameter.POSITIONAL_ONLY:
+                self.arg_mapping[i] = name
+                fields[name] = annotation, default
+                fields[V_POSITIONAL_ONLY_NAME] = List[str], None
+                self.positional_only_args.add(name)
+            elif p.kind == Parameter.POSITIONAL_OR_KEYWORD:
+                self.arg_mapping[i] = name
+                fields[name] = annotation, default
+                fields[V_DUPLICATE_KWARGS] = List[str], None
+            elif p.kind == Parameter.KEYWORD_ONLY:
+                fields[name] = annotation, default
+            elif p.kind == Parameter.VAR_POSITIONAL:
+                self.v_args_name = name
+                fields[name] = Tuple[annotation, ...], None
+                takes_args = True
+            else:
+                assert p.kind == Parameter.VAR_KEYWORD, p.kind
+                self.v_kwargs_name = name
+                fields[name] = Dict[str, annotation], None  # type: ignore
+                takes_kwargs = True
+
+        # these checks avoid a clash between "args" and a field with that name
+        if not takes_args and self.v_args_name in fields:
+            self.v_args_name = ALT_V_ARGS
+
+        # same with "kwargs"
+        if not takes_kwargs and self.v_kwargs_name in fields:
+            self.v_kwargs_name = ALT_V_KWARGS
+
+        if not takes_args:
+            # we add the field so validation below can raise the correct exception
+            fields[self.v_args_name] = List[Any], None
+
+        if not takes_kwargs:
+            # same with kwargs
+            fields[self.v_kwargs_name] = Dict[Any, Any], None
+
+        self.create_model(fields, takes_args, takes_kwargs, config)
+
+    def init_model_instance(self, *args: Any, **kwargs: Any) -> BaseModel:
+        values = self.build_values(args, kwargs)
+        return self.model(**values)
+
+    def call(self, *args: Any, **kwargs: Any) -> Any:
+        m = self.init_model_instance(*args, **kwargs)
+        return self.execute(m)
+
+    def build_values(self, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Dict[str, Any]:
+        values: Dict[str, Any] = {}
+        if args:
+            arg_iter = enumerate(args)
+            while True:
+                try:
+                    i, a = next(arg_iter)
+                except StopIteration:
+                    break
+                arg_name = self.arg_mapping.get(i)
+                if arg_name is not None:
+                    values[arg_name] = a
+                else:
+                    values[self.v_args_name] = [a] + [a for _, a in arg_iter]
+                    break
+
+        var_kwargs = {}
+        wrong_positional_args = []
+        duplicate_kwargs = []
+        non_var_fields = set(self.model.__fields__) - {self.v_args_name, self.v_kwargs_name}
+        for k, v in kwargs.items():
+            if k in non_var_fields:
+                if k in self.positional_only_args:
+                    wrong_positional_args.append(k)
+                if k in values:
+                    duplicate_kwargs.append(k)
+                values[k] = v
+            else:
+                var_kwargs[k] = v
+
+        if var_kwargs:
+            values[self.v_kwargs_name] = var_kwargs
+        if wrong_positional_args:
+            values[V_POSITIONAL_ONLY_NAME] = wrong_positional_args
+        if duplicate_kwargs:
+            values[V_DUPLICATE_KWARGS] = duplicate_kwargs
+        return values
+
+    def execute(self, m: BaseModel) -> Any:
+        d = {k: v for k, v in m._iter() if k in m.__fields_set__ or m.__fields__[k].default_factory}
+        var_kwargs = d.pop(self.v_kwargs_name, {})
+
+        if self.v_args_name in d:
+            args_: List[Any] = []
+            in_kwargs = False
+            kwargs = {}
+            for name, value in d.items():
+                if in_kwargs:
+                    kwargs[name] = value
+                elif name == self.v_args_name:
+                    args_ += value
+                    in_kwargs = True
+                else:
+                    args_.append(value)
+            return self.raw_function(*args_, **kwargs, **var_kwargs)
+        elif self.positional_only_args:
+            args_ = []
+            kwargs = {}
+            for name, value in d.items():
+                if name in self.positional_only_args:
+                    args_.append(value)
+                else:
+                    kwargs[name] = value
+            return self.raw_function(*args_, **kwargs, **var_kwargs)
+        else:
+            return self.raw_function(**d, **var_kwargs)
+
+    def create_model(self, fields: Dict[str, Any], takes_args: bool, takes_kwargs: bool, config: 'ConfigType') -> None:
+        pos_args = len(self.arg_mapping)
+
+        class CustomConfig:
+            pass
+
+        if not TYPE_CHECKING:  # pragma: no branch
+            if isinstance(config, dict):
+                CustomConfig = type('Config', (), config)  # noqa: F811
+            elif config is not None:
+                CustomConfig = config  # noqa: F811
+
+        if hasattr(CustomConfig, 'fields') or hasattr(CustomConfig, 'alias_generator'):
+            raise ConfigError(
+                'Setting the "fields" and "alias_generator" property on custom Config for '
+                '@validate_arguments is not yet supported, please remove.'
+            )
+
+        class DecoratorBaseModel(BaseModel):
+            @validator(self.v_args_name, check_fields=False, allow_reuse=True)
+            def check_args(cls, v: Optional[List[Any]]) -> Optional[List[Any]]:
+                if takes_args or v is None:
+                    return v
+
+                raise TypeError(f'{pos_args} positional arguments expected but {pos_args + len(v)} given')
+
+            @validator(self.v_kwargs_name, check_fields=False, allow_reuse=True)
+            def check_kwargs(cls, v: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+                if takes_kwargs or v is None:
+                    return v
+
+                plural = '' if len(v) == 1 else 's'
+                keys = ', '.join(map(repr, v.keys()))
+                raise TypeError(f'unexpected keyword argument{plural}: {keys}')
+
+            @validator(V_POSITIONAL_ONLY_NAME, check_fields=False, allow_reuse=True)
+            def check_positional_only(cls, v: Optional[List[str]]) -> None:
+                if v is None:
+                    return
+
+                plural = '' if len(v) == 1 else 's'
+                keys = ', '.join(map(repr, v))
+                raise TypeError(f'positional-only argument{plural} passed as keyword argument{plural}: {keys}')
+
+            @validator(V_DUPLICATE_KWARGS, check_fields=False, allow_reuse=True)
+            def check_duplicate_kwargs(cls, v: Optional[List[str]]) -> None:
+                if v is None:
+                    return
+
+                plural = '' if len(v) == 1 else 's'
+                keys = ', '.join(map(repr, v))
+                raise TypeError(f'multiple values for argument{plural}: {keys}')
+
+            class Config(CustomConfig):
+                extra = getattr(CustomConfig, 'extra', Extra.forbid)
+
+        self.model = create_model(to_camel(self.raw_function.__name__), __base__=DecoratorBaseModel, **fields)
diff --git a/myenv/lib/python3.9/site-packages/pydantic/env_settings.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/env_settings.cpython-39-darwin.so
new file mode 100755
index 0000000..4f384d6
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/env_settings.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/env_settings.py b/myenv/lib/python3.9/site-packages/pydantic/env_settings.py
new file mode 100644
index 0000000..35b9697
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/env_settings.py
@@ -0,0 +1,306 @@
+import os
+import warnings
+from pathlib import Path
+from typing import AbstractSet, Any, Callable, ClassVar, Dict, List, Mapping, Optional, Tuple, Type, Union
+
+from .config import BaseConfig, Extra
+from .fields import ModelField
+from .main import BaseModel
+from .typing import StrPath, display_as_type, get_origin, is_union
+from .utils import deep_update, path_type, sequence_like
+
+env_file_sentinel = str(object())
+
+SettingsSourceCallable = Callable[['BaseSettings'], Dict[str, Any]]
+
+
+class SettingsError(ValueError):
+    pass
+
+
+class BaseSettings(BaseModel):
+    """
+    Base class for settings, allowing values to be overridden by environment variables.
+
+    This is useful in production for secrets you do not wish to save in code, it plays nicely with docker(-compose),
+    Heroku and any 12 factor app design.
+    """
+
+    def __init__(
+        __pydantic_self__,
+        _env_file: Optional[StrPath] = env_file_sentinel,
+        _env_file_encoding: Optional[str] = None,
+        _env_nested_delimiter: Optional[str] = None,
+        _secrets_dir: Optional[StrPath] = None,
+        **values: Any,
+    ) -> None:
+        # Uses something other than `self` the first arg to allow "self" as a settable attribute
+        super().__init__(
+            **__pydantic_self__._build_values(
+                values,
+                _env_file=_env_file,
+                _env_file_encoding=_env_file_encoding,
+                _env_nested_delimiter=_env_nested_delimiter,
+                _secrets_dir=_secrets_dir,
+            )
+        )
+
+    def _build_values(
+        self,
+        init_kwargs: Dict[str, Any],
+        _env_file: Optional[StrPath] = None,
+        _env_file_encoding: Optional[str] = None,
+        _env_nested_delimiter: Optional[str] = None,
+        _secrets_dir: Optional[StrPath] = None,
+    ) -> Dict[str, Any]:
+        # Configure built-in sources
+        init_settings = InitSettingsSource(init_kwargs=init_kwargs)
+        env_settings = EnvSettingsSource(
+            env_file=(_env_file if _env_file != env_file_sentinel else self.__config__.env_file),
+            env_file_encoding=(
+                _env_file_encoding if _env_file_encoding is not None else self.__config__.env_file_encoding
+            ),
+            env_nested_delimiter=(
+                _env_nested_delimiter if _env_nested_delimiter is not None else self.__config__.env_nested_delimiter
+            ),
+        )
+        file_secret_settings = SecretsSettingsSource(secrets_dir=_secrets_dir or self.__config__.secrets_dir)
+        # Provide a hook to set built-in sources priority and add / remove sources
+        sources = self.__config__.customise_sources(
+            init_settings=init_settings, env_settings=env_settings, file_secret_settings=file_secret_settings
+        )
+        if sources:
+            return deep_update(*reversed([source(self) for source in sources]))
+        else:
+            # no one should mean to do this, but I think returning an empty dict is marginally preferable
+            # to an informative error and much better than a confusing error
+            return {}
+
+    class Config(BaseConfig):
+        env_prefix = ''
+        env_file = None
+        env_file_encoding = None
+        env_nested_delimiter = None
+        secrets_dir = None
+        validate_all = True
+        extra = Extra.forbid
+        arbitrary_types_allowed = True
+        case_sensitive = False
+
+        @classmethod
+        def prepare_field(cls, field: ModelField) -> None:
+            env_names: Union[List[str], AbstractSet[str]]
+            field_info_from_config = cls.get_field_info(field.name)
+
+            env = field_info_from_config.get('env') or field.field_info.extra.get('env')
+            if env is None:
+                if field.has_alias:
+                    warnings.warn(
+                        'aliases are no longer used by BaseSettings to define which environment variables to read. '
+                        'Instead use the "env" field setting. '
+                        'See https://pydantic-docs.helpmanual.io/usage/settings/#environment-variable-names',
+                        FutureWarning,
+                    )
+                env_names = {cls.env_prefix + field.name}
+            elif isinstance(env, str):
+                env_names = {env}
+            elif isinstance(env, (set, frozenset)):
+                env_names = env
+            elif sequence_like(env):
+                env_names = list(env)
+            else:
+                raise TypeError(f'invalid field env: {env!r} ({display_as_type(env)}); should be string, list or set')
+
+            if not cls.case_sensitive:
+                env_names = env_names.__class__(n.lower() for n in env_names)
+            field.field_info.extra['env_names'] = env_names
+
+        @classmethod
+        def customise_sources(
+            cls,
+            init_settings: SettingsSourceCallable,
+            env_settings: SettingsSourceCallable,
+            file_secret_settings: SettingsSourceCallable,
+        ) -> Tuple[SettingsSourceCallable, ...]:
+            return init_settings, env_settings, file_secret_settings
+
+    # populated by the metaclass using the Config class defined above, annotated here to help IDEs only
+    __config__: ClassVar[Type[Config]]
+
+
+class InitSettingsSource:
+    __slots__ = ('init_kwargs',)
+
+    def __init__(self, init_kwargs: Dict[str, Any]):
+        self.init_kwargs = init_kwargs
+
+    def __call__(self, settings: BaseSettings) -> Dict[str, Any]:
+        return self.init_kwargs
+
+    def __repr__(self) -> str:
+        return f'InitSettingsSource(init_kwargs={self.init_kwargs!r})'
+
+
+class EnvSettingsSource:
+    __slots__ = ('env_file', 'env_file_encoding', 'env_nested_delimiter')
+
+    def __init__(
+        self, env_file: Optional[StrPath], env_file_encoding: Optional[str], env_nested_delimiter: Optional[str] = None
+    ):
+        self.env_file: Optional[StrPath] = env_file
+        self.env_file_encoding: Optional[str] = env_file_encoding
+        self.env_nested_delimiter: Optional[str] = env_nested_delimiter
+
+    def __call__(self, settings: BaseSettings) -> Dict[str, Any]:  # noqa C901
+        """
+        Build environment variables suitable for passing to the Model.
+        """
+        d: Dict[str, Any] = {}
+
+        if settings.__config__.case_sensitive:
+            env_vars: Mapping[str, Optional[str]] = os.environ
+        else:
+            env_vars = {k.lower(): v for k, v in os.environ.items()}
+
+        if self.env_file is not None:
+            env_path = Path(self.env_file).expanduser()
+            if env_path.is_file():
+                env_vars = {
+                    **read_env_file(
+                        env_path, encoding=self.env_file_encoding, case_sensitive=settings.__config__.case_sensitive
+                    ),
+                    **env_vars,
+                }
+
+        for field in settings.__fields__.values():
+            env_val: Optional[str] = None
+            for env_name in field.field_info.extra['env_names']:
+                env_val = env_vars.get(env_name)
+                if env_val is not None:
+                    break
+
+            is_complex, allow_json_failure = self.field_is_complex(field)
+            if is_complex:
+                if env_val is None:
+                    # field is complex but no value found so far, try explode_env_vars
+                    env_val_built = self.explode_env_vars(field, env_vars)
+                    if env_val_built:
+                        d[field.alias] = env_val_built
+                else:
+                    # field is complex and there's a value, decode that as JSON, then add explode_env_vars
+                    try:
+                        env_val = settings.__config__.json_loads(env_val)
+                    except ValueError as e:
+                        if not allow_json_failure:
+                            raise SettingsError(f'error parsing JSON for "{env_name}"') from e
+
+                    if isinstance(env_val, dict):
+                        d[field.alias] = deep_update(env_val, self.explode_env_vars(field, env_vars))
+                    else:
+                        d[field.alias] = env_val
+            elif env_val is not None:
+                # simplest case, field is not complex, we only need to add the value if it was found
+                d[field.alias] = env_val
+
+        return d
+
+    def field_is_complex(self, field: ModelField) -> Tuple[bool, bool]:
+        """
+        Find out if a field is complex, and if so whether JSON errors should be ignored
+        """
+        if field.is_complex():
+            allow_json_failure = False
+        elif is_union(get_origin(field.type_)) and field.sub_fields and any(f.is_complex() for f in field.sub_fields):
+            allow_json_failure = True
+        else:
+            return False, False
+
+        return True, allow_json_failure
+
+    def explode_env_vars(self, field: ModelField, env_vars: Mapping[str, Optional[str]]) -> Dict[str, Any]:
+        """
+        Process env_vars and extract the values of keys containing env_nested_delimiter into nested dictionaries.
+
+        This is applied to a single field, hence filtering by env_var prefix.
+        """
+        prefixes = [f'{env_name}{self.env_nested_delimiter}' for env_name in field.field_info.extra['env_names']]
+        result: Dict[str, Any] = {}
+        for env_name, env_val in env_vars.items():
+            if not any(env_name.startswith(prefix) for prefix in prefixes):
+                continue
+            _, *keys, last_key = env_name.split(self.env_nested_delimiter)
+            env_var = result
+            for key in keys:
+                env_var = env_var.setdefault(key, {})
+            env_var[last_key] = env_val
+
+        return result
+
+    def __repr__(self) -> str:
+        return (
+            f'EnvSettingsSource(env_file={self.env_file!r}, env_file_encoding={self.env_file_encoding!r}, '
+            f'env_nested_delimiter={self.env_nested_delimiter!r})'
+        )
+
+
+class SecretsSettingsSource:
+    __slots__ = ('secrets_dir',)
+
+    def __init__(self, secrets_dir: Optional[StrPath]):
+        self.secrets_dir: Optional[StrPath] = secrets_dir
+
+    def __call__(self, settings: BaseSettings) -> Dict[str, Any]:
+        """
+        Build fields from "secrets" files.
+        """
+        secrets: Dict[str, Optional[str]] = {}
+
+        if self.secrets_dir is None:
+            return secrets
+
+        secrets_path = Path(self.secrets_dir).expanduser()
+
+        if not secrets_path.exists():
+            warnings.warn(f'directory "{secrets_path}" does not exist')
+            return secrets
+
+        if not secrets_path.is_dir():
+            raise SettingsError(f'secrets_dir must reference a directory, not a {path_type(secrets_path)}')
+
+        for field in settings.__fields__.values():
+            for env_name in field.field_info.extra['env_names']:
+                path = secrets_path / env_name
+                if path.is_file():
+                    secret_value = path.read_text().strip()
+                    if field.is_complex():
+                        try:
+                            secret_value = settings.__config__.json_loads(secret_value)
+                        except ValueError as e:
+                            raise SettingsError(f'error parsing JSON for "{env_name}"') from e
+
+                    secrets[field.alias] = secret_value
+                elif path.exists():
+                    warnings.warn(
+                        f'attempted to load secret file "{path}" but found a {path_type(path)} instead.',
+                        stacklevel=4,
+                    )
+
+        return secrets
+
+    def __repr__(self) -> str:
+        return f'SecretsSettingsSource(secrets_dir={self.secrets_dir!r})'
+
+
+def read_env_file(
+    file_path: StrPath, *, encoding: str = None, case_sensitive: bool = False
+) -> Dict[str, Optional[str]]:
+    try:
+        from dotenv import dotenv_values
+    except ImportError as e:
+        raise ImportError('python-dotenv is not installed, run `pip install pydantic[dotenv]`') from e
+
+    file_vars: Dict[str, Optional[str]] = dotenv_values(file_path, encoding=encoding or 'utf8')
+    if not case_sensitive:
+        return {k.lower(): v for k, v in file_vars.items()}
+    else:
+        return file_vars
diff --git a/myenv/lib/python3.9/site-packages/pydantic/error_wrappers.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/error_wrappers.cpython-39-darwin.so
new file mode 100755
index 0000000..6d08706
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/error_wrappers.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/error_wrappers.py b/myenv/lib/python3.9/site-packages/pydantic/error_wrappers.py
new file mode 100644
index 0000000..5d3204f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/error_wrappers.py
@@ -0,0 +1,162 @@
+import json
+from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Sequence, Tuple, Type, Union
+
+from .json import pydantic_encoder
+from .utils import Representation
+
+if TYPE_CHECKING:
+    from typing_extensions import TypedDict
+
+    from .config import BaseConfig
+    from .types import ModelOrDc
+    from .typing import ReprArgs
+
+    Loc = Tuple[Union[int, str], ...]
+
+    class _ErrorDictRequired(TypedDict):
+        loc: Loc
+        msg: str
+        type: str
+
+    class ErrorDict(_ErrorDictRequired, total=False):
+        ctx: Dict[str, Any]
+
+
+__all__ = 'ErrorWrapper', 'ValidationError'
+
+
+class ErrorWrapper(Representation):
+    __slots__ = 'exc', '_loc'
+
+    def __init__(self, exc: Exception, loc: Union[str, 'Loc']) -> None:
+        self.exc = exc
+        self._loc = loc
+
+    def loc_tuple(self) -> 'Loc':
+        if isinstance(self._loc, tuple):
+            return self._loc
+        else:
+            return (self._loc,)
+
+    def __repr_args__(self) -> 'ReprArgs':
+        return [('exc', self.exc), ('loc', self.loc_tuple())]
+
+
+# ErrorList is something like Union[List[Union[List[ErrorWrapper], ErrorWrapper]], ErrorWrapper]
+# but recursive, therefore just use:
+ErrorList = Union[Sequence[Any], ErrorWrapper]
+
+
+class ValidationError(Representation, ValueError):
+    __slots__ = 'raw_errors', 'model', '_error_cache'
+
+    def __init__(self, errors: Sequence[ErrorList], model: 'ModelOrDc') -> None:
+        self.raw_errors = errors
+        self.model = model
+        self._error_cache: Optional[List['ErrorDict']] = None
+
+    def errors(self) -> List['ErrorDict']:
+        if self._error_cache is None:
+            try:
+                config = self.model.__config__  # type: ignore
+            except AttributeError:
+                config = self.model.__pydantic_model__.__config__  # type: ignore
+            self._error_cache = list(flatten_errors(self.raw_errors, config))
+        return self._error_cache
+
+    def json(self, *, indent: Union[None, int, str] = 2) -> str:
+        return json.dumps(self.errors(), indent=indent, default=pydantic_encoder)
+
+    def __str__(self) -> str:
+        errors = self.errors()
+        no_errors = len(errors)
+        return (
+            f'{no_errors} validation error{"" if no_errors == 1 else "s"} for {self.model.__name__}\n'
+            f'{display_errors(errors)}'
+        )
+
+    def __repr_args__(self) -> 'ReprArgs':
+        return [('model', self.model.__name__), ('errors', self.errors())]
+
+
+def display_errors(errors: List['ErrorDict']) -> str:
+    return '\n'.join(f'{_display_error_loc(e)}\n  {e["msg"]} ({_display_error_type_and_ctx(e)})' for e in errors)
+
+
+def _display_error_loc(error: 'ErrorDict') -> str:
+    return ' -> '.join(str(e) for e in error['loc'])
+
+
+def _display_error_type_and_ctx(error: 'ErrorDict') -> str:
+    t = 'type=' + error['type']
+    ctx = error.get('ctx')
+    if ctx:
+        return t + ''.join(f'; {k}={v}' for k, v in ctx.items())
+    else:
+        return t
+
+
+def flatten_errors(
+    errors: Sequence[Any], config: Type['BaseConfig'], loc: Optional['Loc'] = None
+) -> Generator['ErrorDict', None, None]:
+    for error in errors:
+        if isinstance(error, ErrorWrapper):
+
+            if loc:
+                error_loc = loc + error.loc_tuple()
+            else:
+                error_loc = error.loc_tuple()
+
+            if isinstance(error.exc, ValidationError):
+                yield from flatten_errors(error.exc.raw_errors, config, error_loc)
+            else:
+                yield error_dict(error.exc, config, error_loc)
+        elif isinstance(error, list):
+            yield from flatten_errors(error, config, loc=loc)
+        else:
+            raise RuntimeError(f'Unknown error object: {error}')
+
+
+def error_dict(exc: Exception, config: Type['BaseConfig'], loc: 'Loc') -> 'ErrorDict':
+    type_ = get_exc_type(exc.__class__)
+    msg_template = config.error_msg_templates.get(type_) or getattr(exc, 'msg_template', None)
+    ctx = exc.__dict__
+    if msg_template:
+        msg = msg_template.format(**ctx)
+    else:
+        msg = str(exc)
+
+    d: 'ErrorDict' = {'loc': loc, 'msg': msg, 'type': type_}
+
+    if ctx:
+        d['ctx'] = ctx
+
+    return d
+
+
+_EXC_TYPE_CACHE: Dict[Type[Exception], str] = {}
+
+
+def get_exc_type(cls: Type[Exception]) -> str:
+    # slightly more efficient than using lru_cache since we don't need to worry about the cache filling up
+    try:
+        return _EXC_TYPE_CACHE[cls]
+    except KeyError:
+        r = _get_exc_type(cls)
+        _EXC_TYPE_CACHE[cls] = r
+        return r
+
+
+def _get_exc_type(cls: Type[Exception]) -> str:
+    if issubclass(cls, AssertionError):
+        return 'assertion_error'
+
+    base_name = 'type_error' if issubclass(cls, TypeError) else 'value_error'
+    if cls in (TypeError, ValueError):
+        # just TypeError or ValueError, no extra code
+        return base_name
+
+    # if it's not a TypeError or ValueError, we just take the lowercase of the exception name
+    # no chaining or snake case logic, use "code" for more complex error types.
+    code = getattr(cls, 'code', None) or cls.__name__.replace('Error', '').lower()
+    return base_name + '.' + code
diff --git a/myenv/lib/python3.9/site-packages/pydantic/errors.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/errors.cpython-39-darwin.so
new file mode 100755
index 0000000..15bbddb
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/errors.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/errors.py b/myenv/lib/python3.9/site-packages/pydantic/errors.py
new file mode 100644
index 0000000..322862e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/errors.py
@@ -0,0 +1,641 @@
+from decimal import Decimal
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Sequence, Set, Tuple, Type, Union
+
+from .typing import display_as_type
+
+if TYPE_CHECKING:
+    from .typing import DictStrAny
+
+# explicitly state exports to avoid "from .errors import *" also importing Decimal, Path etc.
+__all__ = (
+    'PydanticTypeError',
+    'PydanticValueError',
+    'ConfigError',
+    'MissingError',
+    'ExtraError',
+    'NoneIsNotAllowedError',
+    'NoneIsAllowedError',
+    'WrongConstantError',
+    'NotNoneError',
+    'BoolError',
+    'BytesError',
+    'DictError',
+    'EmailError',
+    'UrlError',
+    'UrlSchemeError',
+    'UrlSchemePermittedError',
+    'UrlUserInfoError',
+    'UrlHostError',
+    'UrlHostTldError',
+    'UrlPortError',
+    'UrlExtraError',
+    'EnumError',
+    'IntEnumError',
+    'EnumMemberError',
+    'IntegerError',
+    'FloatError',
+    'PathError',
+    'PathNotExistsError',
+    'PathNotAFileError',
+    'PathNotADirectoryError',
+    'PyObjectError',
+    'SequenceError',
+    'ListError',
+    'SetError',
+    'FrozenSetError',
+    'TupleError',
+    'TupleLengthError',
+    'ListMinLengthError',
+    'ListMaxLengthError',
+    'ListUniqueItemsError',
+    'SetMinLengthError',
+    'SetMaxLengthError',
+    'FrozenSetMinLengthError',
+    'FrozenSetMaxLengthError',
+    'AnyStrMinLengthError',
+    'AnyStrMaxLengthError',
+    'StrError',
+    'StrRegexError',
+    'NumberNotGtError',
+    'NumberNotGeError',
+    'NumberNotLtError',
+    'NumberNotLeError',
+    'NumberNotMultipleError',
+    'DecimalError',
+    'DecimalIsNotFiniteError',
+    'DecimalMaxDigitsError',
+    'DecimalMaxPlacesError',
+    'DecimalWholeDigitsError',
+    'DateTimeError',
+    'DateError',
+    'DateNotInThePastError',
+    'DateNotInTheFutureError',
+    'TimeError',
+    'DurationError',
+    'HashableError',
+    'UUIDError',
+    'UUIDVersionError',
+    'ArbitraryTypeError',
+    'ClassError',
+    'SubclassError',
+    'JsonError',
+    'JsonTypeError',
+    'PatternError',
+    'DataclassTypeError',
+    'CallableError',
+    'IPvAnyAddressError',
+    'IPvAnyInterfaceError',
+    'IPvAnyNetworkError',
+    'IPv4AddressError',
+    'IPv6AddressError',
+    'IPv4NetworkError',
+    'IPv6NetworkError',
+    'IPv4InterfaceError',
+    'IPv6InterfaceError',
+    'ColorError',
+    'StrictBoolError',
+    'NotDigitError',
+    'LuhnValidationError',
+    'InvalidLengthForBrand',
+    'InvalidByteSize',
+    'InvalidByteSizeUnit',
+    'MissingDiscriminator',
+    'InvalidDiscriminator',
+)
+
+
+def cls_kwargs(cls: Type['PydanticErrorMixin'], ctx: 'DictStrAny') -> 'PydanticErrorMixin':
+    """
+    For built-in exceptions like ValueError or TypeError, we need to implement
+    __reduce__ to override the default behaviour (instead of __getstate__/__setstate__)
+    By default pickle protocol 2 calls `cls.__new__(cls, *args)`.
+    Since we only use kwargs, we need a little constructor to change that.
+    Note: the callable can't be a lambda as pickle looks in the namespace to find it
+    """
+    return cls(**ctx)
+
+
+class PydanticErrorMixin:
+    code: str
+    msg_template: str
+
+    def __init__(self, **ctx: Any) -> None:
+        self.__dict__ = ctx
+
+    def __str__(self) -> str:
+        return self.msg_template.format(**self.__dict__)
+
+    def __reduce__(self) -> Tuple[Callable[..., 'PydanticErrorMixin'], Tuple[Type['PydanticErrorMixin'], 'DictStrAny']]:
+        return cls_kwargs, (self.__class__, self.__dict__)
+
+
+class PydanticTypeError(PydanticErrorMixin, TypeError):
+    pass
+
+
+class PydanticValueError(PydanticErrorMixin, ValueError):
+    pass
+
+
+class ConfigError(RuntimeError):
+    pass
+
+
+class MissingError(PydanticValueError):
+    msg_template = 'field required'
+
+
+class ExtraError(PydanticValueError):
+    msg_template = 'extra fields not permitted'
+
+
+class NoneIsNotAllowedError(PydanticTypeError):
+    code = 'none.not_allowed'
+    msg_template = 'none is not an allowed value'
+
+
+class NoneIsAllowedError(PydanticTypeError):
+    code = 'none.allowed'
+    msg_template = 'value is not none'
+
+
+class WrongConstantError(PydanticValueError):
+    code = 'const'
+
+    def __str__(self) -> str:
+        permitted = ', '.join(repr(v) for v in self.permitted)  # type: ignore
+        return f'unexpected value; permitted: {permitted}'
+
+
+class NotNoneError(PydanticTypeError):
+    code = 'not_none'
+    msg_template = 'value is not None'
+
+
+class BoolError(PydanticTypeError):
+    msg_template = 'value could not be parsed to a boolean'
+
+
+class BytesError(PydanticTypeError):
+    msg_template = 'byte type expected'
+
+
+class DictError(PydanticTypeError):
+    msg_template = 'value is not a valid dict'
+
+
+class EmailError(PydanticValueError):
+    msg_template = 'value is not a valid email address'
+
+
+class UrlError(PydanticValueError):
+    code = 'url'
+
+
+class UrlSchemeError(UrlError):
+    code = 'url.scheme'
+    msg_template = 'invalid or missing URL scheme'
+
+
+class UrlSchemePermittedError(UrlError):
+    code = 'url.scheme'
+    msg_template = 'URL scheme not permitted'
+
+    def __init__(self, allowed_schemes: Set[str]):
+        super().__init__(allowed_schemes=allowed_schemes)
+
+
+class UrlUserInfoError(UrlError):
+    code = 'url.userinfo'
+    msg_template = 'userinfo required in URL but missing'
+
+
+class UrlHostError(UrlError):
+    code = 'url.host'
+    msg_template = 'URL host invalid'
+
+
+class UrlHostTldError(UrlError):
+    code = 'url.host'
+    msg_template = 'URL host invalid, top level domain required'
+
+
+class UrlPortError(UrlError):
+    code = 'url.port'
+    msg_template = 'URL port invalid, port cannot exceed 65535'
+
+
+class UrlExtraError(UrlError):
+    code = 'url.extra'
+    msg_template = 'URL invalid, extra characters found after valid URL: {extra!r}'
+
+
+class EnumMemberError(PydanticTypeError):
+    code = 'enum'
+
+    def __str__(self) -> str:
+        permitted = ', '.join(repr(v.value) for v in self.enum_values)  # type: ignore
+        return f'value is not a valid enumeration member; permitted: {permitted}'
+
+
+class IntegerError(PydanticTypeError):
+    msg_template = 'value is not a valid integer'
+
+
+class FloatError(PydanticTypeError):
+    msg_template = 'value is not a valid float'
+
+
+class PathError(PydanticTypeError):
+    msg_template = 'value is not a valid path'
+
+
+class _PathValueError(PydanticValueError):
+    def __init__(self, *, path: Path) -> None:
+        super().__init__(path=str(path))
+
+
+class PathNotExistsError(_PathValueError):
+    code = 'path.not_exists'
+    msg_template = 'file or directory at path "{path}" does not exist'
+
+
+class PathNotAFileError(_PathValueError):
+    code = 'path.not_a_file'
+    msg_template = 'path "{path}" does not point to a file'
+
+
+class PathNotADirectoryError(_PathValueError):
+    code = 'path.not_a_directory'
+    msg_template = 'path "{path}" does not point to a directory'
+
+
+class PyObjectError(PydanticTypeError):
+    msg_template = 'ensure this value contains valid import path or valid callable: {error_message}'
+
+
+class SequenceError(PydanticTypeError):
+    msg_template = 'value is not a valid sequence'
+
+
+class IterableError(PydanticTypeError):
+    msg_template = 'value is not a valid iterable'
+
+
+class ListError(PydanticTypeError):
+    msg_template = 'value is not a valid list'
+
+
+class SetError(PydanticTypeError):
+    msg_template = 'value is not a valid set'
+
+
+class FrozenSetError(PydanticTypeError):
+    msg_template = 'value is not a valid frozenset'
+
+
+class DequeError(PydanticTypeError):
+    msg_template = 'value is not a valid deque'
+
+
+class TupleError(PydanticTypeError):
+    msg_template = 'value is not a valid tuple'
+
+
+class TupleLengthError(PydanticValueError):
+    code = 'tuple.length'
+    msg_template = 'wrong tuple length {actual_length}, expected {expected_length}'
+
+    def __init__(self, *, actual_length: int, expected_length: int) -> None:
+        super().__init__(actual_length=actual_length, expected_length=expected_length)
+
+
+class ListMinLengthError(PydanticValueError):
+    code = 'list.min_items'
+    msg_template = 'ensure this value has at least {limit_value} items'
+
+    def __init__(self, *, limit_value: int) -> None:
+        super().__init__(limit_value=limit_value)
+
+
+class ListMaxLengthError(PydanticValueError):
+    code = 'list.max_items'
+    msg_template = 'ensure this value has at most {limit_value} items'
+
+    def __init__(self, *, limit_value: int) -> None:
+        super().__init__(limit_value=limit_value)
+
+
+class ListUniqueItemsError(PydanticValueError):
+    code = 'list.unique_items'
+    msg_template = 'the list has duplicated items'
+
+
+class SetMinLengthError(PydanticValueError):
+    code = 'set.min_items'
+    msg_template = 'ensure this value has at least {limit_value} items'
+
+    def __init__(self, *, limit_value: int) -> None:
+        super().__init__(limit_value=limit_value)
+
+
+class SetMaxLengthError(PydanticValueError):
+    code = 'set.max_items'
+    msg_template = 'ensure this value has at most {limit_value} items'
+
+    def __init__(self, *, limit_value: int) -> None:
+        super().__init__(limit_value=limit_value)
+
+
+class FrozenSetMinLengthError(PydanticValueError):
+    code = 'frozenset.min_items'
+    msg_template = 'ensure this value has at least {limit_value} items'
+
+    def __init__(self, *, limit_value: int) -> None:
+        super().__init__(limit_value=limit_value)
+
+
+class FrozenSetMaxLengthError(PydanticValueError):
+    code = 'frozenset.max_items'
+    msg_template = 'ensure this value has at most {limit_value} items'
+
+    def __init__(self, *, limit_value: int) -> None:
+        super().__init__(limit_value=limit_value)
+
+
+class AnyStrMinLengthError(PydanticValueError):
+    code = 'any_str.min_length'
+    msg_template = 'ensure this value has at least {limit_value} characters'
+
+    def __init__(self, *, limit_value: int) -> None:
+        super().__init__(limit_value=limit_value)
+
+
+class AnyStrMaxLengthError(PydanticValueError):
+    code = 'any_str.max_length'
+    msg_template = 'ensure this value has at most {limit_value} characters'
+
+    def __init__(self, *, limit_value: int) -> None:
+        super().__init__(limit_value=limit_value)
+
+
+class StrError(PydanticTypeError):
+    msg_template = 'str type expected'
+
+
+class StrRegexError(PydanticValueError):
+    code = 'str.regex'
+    msg_template = 'string does not match regex "{pattern}"'
+
+    def __init__(self, *, pattern: str) -> None:
+        super().__init__(pattern=pattern)
+
+
+class _NumberBoundError(PydanticValueError):
+    def __init__(self, *, limit_value: Union[int, float, Decimal]) -> None:
+        super().__init__(limit_value=limit_value)
+
+
+class NumberNotGtError(_NumberBoundError):
+    code = 'number.not_gt'
+    msg_template = 'ensure this value is greater than {limit_value}'
+
+
+class NumberNotGeError(_NumberBoundError):
+    code = 'number.not_ge'
+    msg_template = 'ensure this value is greater than or equal to {limit_value}'
+
+
+class NumberNotLtError(_NumberBoundError):
+    code = 'number.not_lt'
+    msg_template = 'ensure this value is less than {limit_value}'
+
+
+class NumberNotLeError(_NumberBoundError):
+    code = 'number.not_le'
+    msg_template = 'ensure this value is less than or equal to {limit_value}'
+
+
+class NumberNotMultipleError(PydanticValueError):
+    code = 'number.not_multiple'
+    msg_template = 'ensure this value is a multiple of {multiple_of}'
+
+    def __init__(self, *, multiple_of: Union[int, float, Decimal]) -> None:
+        super().__init__(multiple_of=multiple_of)
+
+
+class DecimalError(PydanticTypeError):
+    msg_template = 'value is not a valid decimal'
+
+
+class DecimalIsNotFiniteError(PydanticValueError):
+    code = 'decimal.not_finite'
+    msg_template = 'value is not a valid decimal'
+
+
+class DecimalMaxDigitsError(PydanticValueError):
+    code = 'decimal.max_digits'
+    msg_template = 'ensure that there are no more than {max_digits} digits in total'
+
+    def __init__(self, *, max_digits: int) -> None:
+        super().__init__(max_digits=max_digits)
+
+
+class DecimalMaxPlacesError(PydanticValueError):
+    code = 'decimal.max_places'
+    msg_template = 'ensure that there are no more than {decimal_places} decimal places'
+
+    def __init__(self, *, decimal_places: int) -> None:
+        super().__init__(decimal_places=decimal_places)
+
+
+class DecimalWholeDigitsError(PydanticValueError):
+    code = 'decimal.whole_digits'
+    msg_template = 'ensure that there are no more than {whole_digits} digits before the decimal point'
+
+    def __init__(self, *, whole_digits: int) -> None:
+        super().__init__(whole_digits=whole_digits)
+
+
+class DateTimeError(PydanticValueError):
+    msg_template = 'invalid datetime format'
+
+
+class DateError(PydanticValueError):
+    msg_template = 'invalid date format'
+
+
+class DateNotInThePastError(PydanticValueError):
+    code = 'date.not_in_the_past'
+    msg_template = 'date is not in the past'
+
+
+class DateNotInTheFutureError(PydanticValueError):
+    code = 'date.not_in_the_future'
+    msg_template = 'date is not in the future'
+
+
+class TimeError(PydanticValueError):
+    msg_template = 'invalid time format'
+
+
+class DurationError(PydanticValueError):
+    msg_template = 'invalid duration format'
+
+
+class HashableError(PydanticTypeError):
+    msg_template = 'value is not a valid hashable'
+
+
+class UUIDError(PydanticTypeError):
+    msg_template = 'value is not a valid uuid'
+
+
+class UUIDVersionError(PydanticValueError):
+    code = 'uuid.version'
+    msg_template = 'uuid version {required_version} expected'
+
+    def __init__(self, *, required_version: int) -> None:
+        super().__init__(required_version=required_version)
+
+
+class ArbitraryTypeError(PydanticTypeError):
+    code = 'arbitrary_type'
+    msg_template = 'instance of {expected_arbitrary_type} expected'
+
+    def __init__(self, *, expected_arbitrary_type: Type[Any]) -> None:
+        super().__init__(expected_arbitrary_type=display_as_type(expected_arbitrary_type))
+
+
+class ClassError(PydanticTypeError):
+    code = 'class'
+    msg_template = 'a class is expected'
+
+
+class SubclassError(PydanticTypeError):
+    code = 'subclass'
+    msg_template = 'subclass of {expected_class} expected'
+
+    def __init__(self, *, expected_class: Type[Any]) -> None:
+        super().__init__(expected_class=display_as_type(expected_class))
+
+
+class JsonError(PydanticValueError):
+    msg_template = 'Invalid JSON'
+
+
+class JsonTypeError(PydanticTypeError):
+    code = 'json'
+    msg_template = 'JSON object must be str, bytes or bytearray'
+
+
+class PatternError(PydanticValueError):
+    code = 'regex_pattern'
+    msg_template = 'Invalid regular expression'
+
+
+class DataclassTypeError(PydanticTypeError):
+    code = 'dataclass'
+    msg_template = 'instance of {class_name}, tuple or dict expected'
+
+
+class CallableError(PydanticTypeError):
+    msg_template = '{value} is not callable'
+
+
+class EnumError(PydanticTypeError):
+    code = 'enum_instance'
+    msg_template = '{value} is not a valid Enum instance'
+
+
+class IntEnumError(PydanticTypeError):
+    code = 'int_enum_instance'
+    msg_template = '{value} is not a valid IntEnum instance'
+
+
+class IPvAnyAddressError(PydanticValueError):
+    msg_template = 'value is not a valid IPv4 or IPv6 address'
+
+
+class IPvAnyInterfaceError(PydanticValueError):
+    msg_template = 'value is not a valid IPv4 or IPv6 interface'
+
+
+class IPvAnyNetworkError(PydanticValueError):
+    msg_template = 'value is not a valid IPv4 or IPv6 network'
+
+
+class IPv4AddressError(PydanticValueError):
+    msg_template = 'value is not a valid IPv4 address'
+
+
+class IPv6AddressError(PydanticValueError):
+    msg_template = 'value is not a valid IPv6 address'
+
+
+class IPv4NetworkError(PydanticValueError):
+    msg_template = 'value is not a valid IPv4 network'
+
+
+class IPv6NetworkError(PydanticValueError):
+    msg_template = 'value is not a valid IPv6 network'
+
+
+class IPv4InterfaceError(PydanticValueError):
+    msg_template = 'value is not a valid IPv4 interface'
+
+
+class IPv6InterfaceError(PydanticValueError):
+    msg_template = 'value is not a valid IPv6 interface'
+
+
+class ColorError(PydanticValueError):
+    msg_template = 'value is not a valid color: {reason}'
+
+
+class StrictBoolError(PydanticValueError):
+    msg_template = 'value is not a valid boolean'
+
+
+class NotDigitError(PydanticValueError):
+    code = 'payment_card_number.digits'
+    msg_template = 'card number is not all digits'
+
+
+class LuhnValidationError(PydanticValueError):
+    code = 'payment_card_number.luhn_check'
+    msg_template = 'card number is not luhn valid'
+
+
+class InvalidLengthForBrand(PydanticValueError):
+    code = 'payment_card_number.invalid_length_for_brand'
+    msg_template = 'Length for a {brand} card must be {required_length}'
+
+
+class InvalidByteSize(PydanticValueError):
+    msg_template = 'could not parse value and unit from byte string'
+
+
+class InvalidByteSizeUnit(PydanticValueError):
+    msg_template = 'could not interpret byte unit: {unit}'
+
+
+class MissingDiscriminator(PydanticValueError):
+    code = 'discriminated_union.missing_discriminator'
+    msg_template = 'Discriminator {discriminator_key!r} is missing in value'
+
+
+class InvalidDiscriminator(PydanticValueError):
+    code = 'discriminated_union.invalid_discriminator'
+    msg_template = (
+        'No match for discriminator {discriminator_key!r} and value {discriminator_value!r} '
+        '(allowed values: {allowed_values})'
+    )
+
+    def __init__(self, *, discriminator_key: str, discriminator_value: Any, allowed_values: Sequence[Any]) -> None:
+        super().__init__(
+            discriminator_key=discriminator_key,
+            discriminator_value=discriminator_value,
+            allowed_values=', '.join(map(repr, allowed_values)),
+        )
diff --git a/myenv/lib/python3.9/site-packages/pydantic/fields.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/fields.cpython-39-darwin.so
new file mode 100755
index 0000000..0cb70a6
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/fields.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/fields.py b/myenv/lib/python3.9/site-packages/pydantic/fields.py
new file mode 100644
index 0000000..df79edf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/fields.py
@@ -0,0 +1,1217 @@
+import copy
+from collections import Counter as CollectionCounter, defaultdict, deque
+from collections.abc import Hashable as CollectionsHashable, Iterable as CollectionsIterable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Counter,
+    DefaultDict,
+    Deque,
+    Dict,
+    FrozenSet,
+    Generator,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Pattern,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+from typing_extensions import Annotated
+
+from . import errors as errors_
+from .class_validators import Validator, make_generic_validator, prep_validators
+from .error_wrappers import ErrorWrapper
+from .errors import ConfigError, InvalidDiscriminator, MissingDiscriminator, NoneIsNotAllowedError
+from .types import Json, JsonWrapper
+from .typing import (
+    Callable,
+    ForwardRef,
+    NoArgAnyCallable,
+    convert_generics,
+    display_as_type,
+    get_args,
+    get_origin,
+    is_literal_type,
+    is_new_type,
+    is_none_type,
+    is_typeddict,
+    is_union,
+    new_type_supertype,
+)
+from .utils import (
+    PyObjectStr,
+    Representation,
+    ValueItems,
+    get_discriminator_alias_and_values,
+    get_unique_discriminator_alias,
+    lenient_isinstance,
+    lenient_issubclass,
+    sequence_like,
+    smart_deepcopy,
+)
+from .validators import constant_validator, dict_validator, find_validators, validate_json
+
+Required: Any = Ellipsis
+
+T = TypeVar('T')
+
+
+class UndefinedType:
+    def __repr__(self) -> str:
+        return 'PydanticUndefined'
+
+    def __copy__(self: T) -> T:
+        return self
+
+    def __reduce__(self) -> str:
+        return 'Undefined'
+
+    def __deepcopy__(self: T, _: Any) -> T:
+        return self
+
+
+Undefined = UndefinedType()
+
+if TYPE_CHECKING:
+    from .class_validators import ValidatorsList
+    from .config import BaseConfig
+    from .error_wrappers import ErrorList
+    from .types import ModelOrDc
+    from .typing import AbstractSetIntStr, MappingIntStrAny, ReprArgs
+
+    ValidateReturn = Tuple[Optional[Any], Optional[ErrorList]]
+    LocStr = Union[Tuple[Union[int, str], ...], str]
+    BoolUndefined = Union[bool, UndefinedType]
+
+
+class FieldInfo(Representation):
+    """
+    Captures extra information about a field.
+    """
+
+    __slots__ = (
+        'default',
+        'default_factory',
+        'alias',
+        'alias_priority',
+        'title',
+        'description',
+        'exclude',
+        'include',
+        'const',
+        'gt',
+        'ge',
+        'lt',
+        'le',
+        'multiple_of',
+        'max_digits',
+        'decimal_places',
+        'min_items',
+        'max_items',
+        'unique_items',
+        'min_length',
+        'max_length',
+        'allow_mutation',
+        'repr',
+        'regex',
+        'discriminator',
+        'extra',
+    )
+
+    # field constraints with the default value, it's also used in update_from_config below
+    __field_constraints__ = {
+        'min_length': None,
+        'max_length': None,
+        'regex': None,
+        'gt': None,
+        'lt': None,
+        'ge': None,
+        'le': None,
+        'multiple_of': None,
+        'max_digits': None,
+        'decimal_places': None,
+        'min_items': None,
+        'max_items': None,
+        'unique_items': None,
+        'allow_mutation': True,
+    }
+
+    def __init__(self, default: Any = Undefined, **kwargs: Any) -> None:
+        self.default = default
+        self.default_factory = kwargs.pop('default_factory', None)
+        self.alias = kwargs.pop('alias', None)
+        self.alias_priority = kwargs.pop('alias_priority', 2 if self.alias else None)
+        self.title = kwargs.pop('title', None)
+        self.description = kwargs.pop('description', None)
+        self.exclude = kwargs.pop('exclude', None)
+        self.include = kwargs.pop('include', None)
+        self.const = kwargs.pop('const', None)
+        self.gt = kwargs.pop('gt', None)
+        self.ge = kwargs.pop('ge', None)
+        self.lt = kwargs.pop('lt', None)
+        self.le = kwargs.pop('le', None)
+        self.multiple_of = kwargs.pop('multiple_of', None)
+        self.max_digits = kwargs.pop('max_digits', None)
+        self.decimal_places = kwargs.pop('decimal_places', None)
+        self.min_items = kwargs.pop('min_items', None)
+        self.max_items = kwargs.pop('max_items', None)
+        self.unique_items = kwargs.pop('unique_items', None)
+        self.min_length = kwargs.pop('min_length', None)
+        self.max_length = kwargs.pop('max_length', None)
+        self.allow_mutation = kwargs.pop('allow_mutation', True)
+        self.regex = kwargs.pop('regex', None)
+        self.discriminator = kwargs.pop('discriminator', None)
+        self.repr = kwargs.pop('repr', True)
+        self.extra = kwargs
+
+    def __repr_args__(self) -> 'ReprArgs':
+
+        field_defaults_to_hide: Dict[str, Any] = {
+            'repr': True,
+            **self.__field_constraints__,
+        }
+
+        attrs = ((s, getattr(self, s)) for s in self.__slots__)
+        return [(a, v) for a, v in attrs if v != field_defaults_to_hide.get(a, None)]
+
+    def get_constraints(self) -> Set[str]:
+        """
+        Gets the constraints set on the field by comparing the constraint value with its default value
+
+        :return: the constraints set on field_info
+        """
+        return {attr for attr, default in self.__field_constraints__.items() if getattr(self, attr) != default}
+
+    def update_from_config(self, from_config: Dict[str, Any]) -> None:
+        """
+        Update this FieldInfo based on a dict from get_field_info, only fields which have not been set are dated.
+        """
+        for attr_name, value in from_config.items():
+            try:
+                current_value = getattr(self, attr_name)
+            except AttributeError:
+                # attr_name is not an attribute of FieldInfo, it should therefore be added to extra
+                self.extra[attr_name] = value
+            else:
+                if current_value is self.__field_constraints__.get(attr_name, None):
+                    setattr(self, attr_name, value)
+                elif attr_name == 'exclude':
+                    self.exclude = ValueItems.merge(value, current_value)
+                elif attr_name == 'include':
+                    self.include = ValueItems.merge(value, current_value, intersect=True)
+
+    def _validate(self) -> None:
+        if self.default is not Undefined and self.default_factory is not None:
+            raise ValueError('cannot specify both default and default_factory')
+
+
+def Field(
+    default: Any = Undefined,
+    *,
+    default_factory: Optional[NoArgAnyCallable] = None,
+    alias: str = None,
+    title: str = None,
+    description: str = None,
+    exclude: Union['AbstractSetIntStr', 'MappingIntStrAny', Any] = None,
+    include: Union['AbstractSetIntStr', 'MappingIntStrAny', Any] = None,
+    const: bool = None,
+    gt: float = None,
+    ge: float = None,
+    lt: float = None,
+    le: float = None,
+    multiple_of: float = None,
+    max_digits: int = None,
+    decimal_places: int = None,
+    min_items: int = None,
+    max_items: int = None,
+    unique_items: bool = None,
+    min_length: int = None,
+    max_length: int = None,
+    allow_mutation: bool = True,
+    regex: str = None,
+    discriminator: str = None,
+    repr: bool = True,
+    **extra: Any,
+) -> Any:
+    """
+    Used to provide extra information about a field, either for the model schema or complex validation. Some arguments
+    apply only to number fields (``int``, ``float``, ``Decimal``) and some apply only to ``str``.
+
+    :param default: since this is replacing the field’s default, its first argument is used
+      to set the default, use ellipsis (``...``) to indicate the field is required
+    :param default_factory: callable that will be called when a default value is needed for this field
+      If both `default` and `default_factory` are set, an error is raised.
+    :param alias: the public name of the field
+    :param title: can be any string, used in the schema
+    :param description: can be any string, used in the schema
+    :param exclude: exclude this field while dumping.
+      Takes same values as the ``include`` and ``exclude`` arguments on the ``.dict`` method.
+    :param include: include this field while dumping.
+      Takes same values as the ``include`` and ``exclude`` arguments on the ``.dict`` method.
+    :param const: this field is required and *must* take it's default value
+    :param gt: only applies to numbers, requires the field to be "greater than". The schema
+      will have an ``exclusiveMinimum`` validation keyword
+    :param ge: only applies to numbers, requires the field to be "greater than or equal to". The
+      schema will have a ``minimum`` validation keyword
+    :param lt: only applies to numbers, requires the field to be "less than". The schema
+      will have an ``exclusiveMaximum`` validation keyword
+    :param le: only applies to numbers, requires the field to be "less than or equal to". The
+      schema will have a ``maximum`` validation keyword
+    :param multiple_of: only applies to numbers, requires the field to be "a multiple of". The
+      schema will have a ``multipleOf`` validation keyword
+    :param max_digits: only applies to Decimals, requires the field to have a maximum number
+      of digits within the decimal. It does not include a zero before the decimal point or trailing decimal zeroes.
+    :param decimal_places: only applies to Decimals, requires the field to have at most a number of decimal places
+      allowed. It does not include trailing decimal zeroes.
+    :param min_items: only applies to lists, requires the field to have a minimum number of
+      elements. The schema will have a ``minItems`` validation keyword
+    :param max_items: only applies to lists, requires the field to have a maximum number of
+      elements. The schema will have a ``maxItems`` validation keyword
+    :param max_items: only applies to lists, requires the field not to have duplicated
+      elements. The schema will have a ``uniqueItems`` validation keyword
+    :param min_length: only applies to strings, requires the field to have a minimum length. The
+      schema will have a ``maximum`` validation keyword
+    :param max_length: only applies to strings, requires the field to have a maximum length. The
+      schema will have a ``maxLength`` validation keyword
+    :param allow_mutation: a boolean which defaults to True. When False, the field raises a TypeError if the field is
+      assigned on an instance.  The BaseModel Config must set validate_assignment to True
+    :param regex: only applies to strings, requires the field match against a regular expression
+      pattern string. The schema will have a ``pattern`` validation keyword
+    :param discriminator: only useful with a (discriminated a.k.a. tagged) `Union` of sub models with a common field.
+      The `discriminator` is the name of this common field to shorten validation and improve generated schema
+    :param repr: show this field in the representation
+    :param **extra: any additional keyword arguments will be added as is to the schema
+    """
+    field_info = FieldInfo(
+        default,
+        default_factory=default_factory,
+        alias=alias,
+        title=title,
+        description=description,
+        exclude=exclude,
+        include=include,
+        const=const,
+        gt=gt,
+        ge=ge,
+        lt=lt,
+        le=le,
+        multiple_of=multiple_of,
+        max_digits=max_digits,
+        decimal_places=decimal_places,
+        min_items=min_items,
+        max_items=max_items,
+        unique_items=unique_items,
+        min_length=min_length,
+        max_length=max_length,
+        allow_mutation=allow_mutation,
+        regex=regex,
+        discriminator=discriminator,
+        repr=repr,
+        **extra,
+    )
+    field_info._validate()
+    return field_info
+
+
+# used to be an enum but changed to int's for small performance improvement as less access overhead
+SHAPE_SINGLETON = 1
+SHAPE_LIST = 2
+SHAPE_SET = 3
+SHAPE_MAPPING = 4
+SHAPE_TUPLE = 5
+SHAPE_TUPLE_ELLIPSIS = 6
+SHAPE_SEQUENCE = 7
+SHAPE_FROZENSET = 8
+SHAPE_ITERABLE = 9
+SHAPE_GENERIC = 10
+SHAPE_DEQUE = 11
+SHAPE_DICT = 12
+SHAPE_DEFAULTDICT = 13
+SHAPE_COUNTER = 14
+SHAPE_NAME_LOOKUP = {
+    SHAPE_LIST: 'List[{}]',
+    SHAPE_SET: 'Set[{}]',
+    SHAPE_TUPLE_ELLIPSIS: 'Tuple[{}, ...]',
+    SHAPE_SEQUENCE: 'Sequence[{}]',
+    SHAPE_FROZENSET: 'FrozenSet[{}]',
+    SHAPE_ITERABLE: 'Iterable[{}]',
+    SHAPE_DEQUE: 'Deque[{}]',
+    SHAPE_DICT: 'Dict[{}]',
+    SHAPE_DEFAULTDICT: 'DefaultDict[{}]',
+    SHAPE_COUNTER: 'Counter[{}]',
+}
+
+MAPPING_LIKE_SHAPES: Set[int] = {SHAPE_DEFAULTDICT, SHAPE_DICT, SHAPE_MAPPING, SHAPE_COUNTER}
+
+
+class ModelField(Representation):
+    __slots__ = (
+        'type_',
+        'outer_type_',
+        'sub_fields',
+        'sub_fields_mapping',
+        'key_field',
+        'validators',
+        'pre_validators',
+        'post_validators',
+        'default',
+        'default_factory',
+        'required',
+        'model_config',
+        'name',
+        'alias',
+        'has_alias',
+        'field_info',
+        'discriminator_key',
+        'discriminator_alias',
+        'validate_always',
+        'allow_none',
+        'shape',
+        'class_validators',
+        'parse_json',
+    )
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        type_: Type[Any],
+        class_validators: Optional[Dict[str, Validator]],
+        model_config: Type['BaseConfig'],
+        default: Any = None,
+        default_factory: Optional[NoArgAnyCallable] = None,
+        required: 'BoolUndefined' = Undefined,
+        alias: str = None,
+        field_info: Optional[FieldInfo] = None,
+    ) -> None:
+
+        self.name: str = name
+        self.has_alias: bool = bool(alias)
+        self.alias: str = alias or name
+        self.type_: Any = convert_generics(type_)
+        self.outer_type_: Any = type_
+        self.class_validators = class_validators or {}
+        self.default: Any = default
+        self.default_factory: Optional[NoArgAnyCallable] = default_factory
+        self.required: 'BoolUndefined' = required
+        self.model_config = model_config
+        self.field_info: FieldInfo = field_info or FieldInfo(default)
+        self.discriminator_key: Optional[str] = self.field_info.discriminator
+        self.discriminator_alias: Optional[str] = self.discriminator_key
+
+        self.allow_none: bool = False
+        self.validate_always: bool = False
+        self.sub_fields: Optional[List[ModelField]] = None
+        self.sub_fields_mapping: Optional[Dict[str, 'ModelField']] = None  # used for discriminated union
+        self.key_field: Optional[ModelField] = None
+        self.validators: 'ValidatorsList' = []
+        self.pre_validators: Optional['ValidatorsList'] = None
+        self.post_validators: Optional['ValidatorsList'] = None
+        self.parse_json: bool = False
+        self.shape: int = SHAPE_SINGLETON
+        self.model_config.prepare_field(self)
+        self.prepare()
+
+    def get_default(self) -> Any:
+        return smart_deepcopy(self.default) if self.default_factory is None else self.default_factory()
+
+    @staticmethod
+    def _get_field_info(
+        field_name: str, annotation: Any, value: Any, config: Type['BaseConfig']
+    ) -> Tuple[FieldInfo, Any]:
+        """
+        Get a FieldInfo from a root typing.Annotated annotation, value, or config default.
+
+        The FieldInfo may be set in typing.Annotated or the value, but not both. If neither contain
+        a FieldInfo, a new one will be created using the config.
+
+        :param field_name: name of the field for use in error messages
+        :param annotation: a type hint such as `str` or `Annotated[str, Field(..., min_length=5)]`
+        :param value: the field's assigned value
+        :param config: the model's config object
+        :return: the FieldInfo contained in the `annotation`, the value, or a new one from the config.
+        """
+        field_info_from_config = config.get_field_info(field_name)
+
+        field_info = None
+        if get_origin(annotation) is Annotated:
+            field_infos = [arg for arg in get_args(annotation)[1:] if isinstance(arg, FieldInfo)]
+            if len(field_infos) > 1:
+                raise ValueError(f'cannot specify multiple `Annotated` `Field`s for {field_name!r}')
+            field_info = next(iter(field_infos), None)
+            if field_info is not None:
+                field_info = copy.copy(field_info)
+                field_info.update_from_config(field_info_from_config)
+                if field_info.default is not Undefined:
+                    raise ValueError(f'`Field` default cannot be set in `Annotated` for {field_name!r}')
+                if value is not Undefined and value is not Required:
+                    # check also `Required` because of `validate_arguments` that sets `...` as default value
+                    field_info.default = value
+
+        if isinstance(value, FieldInfo):
+            if field_info is not None:
+                raise ValueError(f'cannot specify `Annotated` and value `Field`s together for {field_name!r}')
+            field_info = value
+            field_info.update_from_config(field_info_from_config)
+        elif field_info is None:
+            field_info = FieldInfo(value, **field_info_from_config)
+        value = None if field_info.default_factory is not None else field_info.default
+        field_info._validate()
+        return field_info, value
+
+    @classmethod
+    def infer(
+        cls,
+        *,
+        name: str,
+        value: Any,
+        annotation: Any,
+        class_validators: Optional[Dict[str, Validator]],
+        config: Type['BaseConfig'],
+    ) -> 'ModelField':
+        from .schema import get_annotation_from_field_info
+
+        field_info, value = cls._get_field_info(name, annotation, value, config)
+        required: 'BoolUndefined' = Undefined
+        if value is Required:
+            required = True
+            value = None
+        elif value is not Undefined:
+            required = False
+        annotation = get_annotation_from_field_info(annotation, field_info, name, config.validate_assignment)
+
+        return cls(
+            name=name,
+            type_=annotation,
+            alias=field_info.alias,
+            class_validators=class_validators,
+            default=value,
+            default_factory=field_info.default_factory,
+            required=required,
+            model_config=config,
+            field_info=field_info,
+        )
+
+    def set_config(self, config: Type['BaseConfig']) -> None:
+        self.model_config = config
+        info_from_config = config.get_field_info(self.name)
+        config.prepare_field(self)
+        new_alias = info_from_config.get('alias')
+        new_alias_priority = info_from_config.get('alias_priority') or 0
+        if new_alias and new_alias_priority >= (self.field_info.alias_priority or 0):
+            self.field_info.alias = new_alias
+            self.field_info.alias_priority = new_alias_priority
+            self.alias = new_alias
+        new_exclude = info_from_config.get('exclude')
+        if new_exclude is not None:
+            self.field_info.exclude = ValueItems.merge(self.field_info.exclude, new_exclude)
+        new_include = info_from_config.get('include')
+        if new_include is not None:
+            self.field_info.include = ValueItems.merge(self.field_info.include, new_include, intersect=True)
+
+    @property
+    def alt_alias(self) -> bool:
+        return self.name != self.alias
+
+    def prepare(self) -> None:
+        """
+        Prepare the field but inspecting self.default, self.type_ etc.
+
+        Note: this method is **not** idempotent (because _type_analysis is not idempotent),
+        e.g. calling it it multiple times may modify the field and configure it incorrectly.
+        """
+        self._set_default_and_type()
+        if self.type_.__class__ is ForwardRef or self.type_.__class__ is DeferredType:
+            # self.type_ is currently a ForwardRef and there's nothing we can do now,
+            # user will need to call model.update_forward_refs()
+            return
+
+        self._type_analysis()
+        if self.required is Undefined:
+            self.required = True
+        if self.default is Undefined and self.default_factory is None:
+            self.default = None
+        self.populate_validators()
+
+    def _set_default_and_type(self) -> None:
+        """
+        Set the default value, infer the type if needed and check if `None` value is valid.
+        """
+        if self.default_factory is not None:
+            if self.type_ is Undefined:
+                raise errors_.ConfigError(
+                    f'you need to set the type of field {self.name!r} when using `default_factory`'
+                )
+            return
+
+        default_value = self.get_default()
+
+        if default_value is not None and self.type_ is Undefined:
+            self.type_ = default_value.__class__
+            self.outer_type_ = self.type_
+
+        if self.type_ is Undefined:
+            raise errors_.ConfigError(f'unable to infer type for attribute "{self.name}"')
+
+        if self.required is False and default_value is None:
+            self.allow_none = True
+
+    def _type_analysis(self) -> None:  # noqa: C901 (ignore complexity)
+        # typing interface is horrible, we have to do some ugly checks
+        if lenient_issubclass(self.type_, JsonWrapper):
+            self.type_ = self.type_.inner_type
+            self.parse_json = True
+        elif lenient_issubclass(self.type_, Json):
+            self.type_ = Any
+            self.parse_json = True
+        elif isinstance(self.type_, TypeVar):
+            if self.type_.__bound__:
+                self.type_ = self.type_.__bound__
+            elif self.type_.__constraints__:
+                self.type_ = Union[self.type_.__constraints__]
+            else:
+                self.type_ = Any
+        elif is_new_type(self.type_):
+            self.type_ = new_type_supertype(self.type_)
+
+        if self.type_ is Any or self.type_ is object:
+            if self.required is Undefined:
+                self.required = False
+            self.allow_none = True
+            return
+        elif self.type_ is Pattern:
+            # python 3.7 only, Pattern is a typing object but without sub fields
+            return
+        elif is_literal_type(self.type_):
+            return
+        elif is_typeddict(self.type_):
+            return
+
+        origin = get_origin(self.type_)
+
+        if origin is Annotated:
+            self.type_ = get_args(self.type_)[0]
+            self._type_analysis()
+            return
+
+        if self.discriminator_key is not None and not is_union(origin):
+            raise TypeError('`discriminator` can only be used with `Union` type with more than one variant')
+
+        # add extra check for `collections.abc.Hashable` for python 3.10+ where origin is not `None`
+        if origin is None or origin is CollectionsHashable:
+            # field is not "typing" object eg. Union, Dict, List etc.
+            # allow None for virtual superclasses of NoneType, e.g. Hashable
+            if isinstance(self.type_, type) and isinstance(None, self.type_):
+                self.allow_none = True
+            return
+        elif origin is Callable:
+            return
+        elif is_union(origin):
+            types_ = []
+            for type_ in get_args(self.type_):
+                if is_none_type(type_) or type_ is Any or type_ is object:
+                    if self.required is Undefined:
+                        self.required = False
+                    self.allow_none = True
+                if is_none_type(type_):
+                    continue
+                types_.append(type_)
+
+            if len(types_) == 1:
+                # Optional[]
+                self.type_ = types_[0]
+                # this is the one case where the "outer type" isn't just the original type
+                self.outer_type_ = self.type_
+                # re-run to correctly interpret the new self.type_
+                self._type_analysis()
+            else:
+                self.sub_fields = [self._create_sub_type(t, f'{self.name}_{display_as_type(t)}') for t in types_]
+
+                if self.discriminator_key is not None:
+                    self.prepare_discriminated_union_sub_fields()
+            return
+        elif issubclass(origin, Tuple):  # type: ignore
+            # origin == Tuple without item type
+            args = get_args(self.type_)
+            if not args:  # plain tuple
+                self.type_ = Any
+                self.shape = SHAPE_TUPLE_ELLIPSIS
+            elif len(args) == 2 and args[1] is Ellipsis:  # e.g. Tuple[int, ...]
+                self.type_ = args[0]
+                self.shape = SHAPE_TUPLE_ELLIPSIS
+                self.sub_fields = [self._create_sub_type(args[0], f'{self.name}_0')]
+            elif args == ((),):  # Tuple[()] means empty tuple
+                self.shape = SHAPE_TUPLE
+                self.type_ = Any
+                self.sub_fields = []
+            else:
+                self.shape = SHAPE_TUPLE
+                self.sub_fields = [self._create_sub_type(t, f'{self.name}_{i}') for i, t in enumerate(args)]
+            return
+        elif issubclass(origin, List):
+            # Create self validators
+            get_validators = getattr(self.type_, '__get_validators__', None)
+            if get_validators:
+                self.class_validators.update(
+                    {f'list_{i}': Validator(validator, pre=True) for i, validator in enumerate(get_validators())}
+                )
+
+            self.type_ = get_args(self.type_)[0]
+            self.shape = SHAPE_LIST
+        elif issubclass(origin, Set):
+            # Create self validators
+            get_validators = getattr(self.type_, '__get_validators__', None)
+            if get_validators:
+                self.class_validators.update(
+                    {f'set_{i}': Validator(validator, pre=True) for i, validator in enumerate(get_validators())}
+                )
+
+            self.type_ = get_args(self.type_)[0]
+            self.shape = SHAPE_SET
+        elif issubclass(origin, FrozenSet):
+            # Create self validators
+            get_validators = getattr(self.type_, '__get_validators__', None)
+            if get_validators:
+                self.class_validators.update(
+                    {f'frozenset_{i}': Validator(validator, pre=True) for i, validator in enumerate(get_validators())}
+                )
+
+            self.type_ = get_args(self.type_)[0]
+            self.shape = SHAPE_FROZENSET
+        elif issubclass(origin, Deque):
+            self.type_ = get_args(self.type_)[0]
+            self.shape = SHAPE_DEQUE
+        elif issubclass(origin, Sequence):
+            self.type_ = get_args(self.type_)[0]
+            self.shape = SHAPE_SEQUENCE
+        # priority to most common mapping: dict
+        elif origin is dict or origin is Dict:
+            self.key_field = self._create_sub_type(get_args(self.type_)[0], 'key_' + self.name, for_keys=True)
+            self.type_ = get_args(self.type_)[1]
+            self.shape = SHAPE_DICT
+        elif issubclass(origin, DefaultDict):
+            self.key_field = self._create_sub_type(get_args(self.type_)[0], 'key_' + self.name, for_keys=True)
+            self.type_ = get_args(self.type_)[1]
+            self.shape = SHAPE_DEFAULTDICT
+        elif issubclass(origin, Counter):
+            self.key_field = self._create_sub_type(get_args(self.type_)[0], 'key_' + self.name, for_keys=True)
+            self.type_ = int
+            self.shape = SHAPE_COUNTER
+        elif issubclass(origin, Mapping):
+            self.key_field = self._create_sub_type(get_args(self.type_)[0], 'key_' + self.name, for_keys=True)
+            self.type_ = get_args(self.type_)[1]
+            self.shape = SHAPE_MAPPING
+        # Equality check as almost everything inherits form Iterable, including str
+        # check for Iterable and CollectionsIterable, as it could receive one even when declared with the other
+        elif origin in {Iterable, CollectionsIterable}:
+            self.type_ = get_args(self.type_)[0]
+            self.shape = SHAPE_ITERABLE
+            self.sub_fields = [self._create_sub_type(self.type_, f'{self.name}_type')]
+        elif issubclass(origin, Type):  # type: ignore
+            return
+        elif hasattr(origin, '__get_validators__') or self.model_config.arbitrary_types_allowed:
+            # Is a Pydantic-compatible generic that handles itself
+            # or we have arbitrary_types_allowed = True
+            self.shape = SHAPE_GENERIC
+            self.sub_fields = [self._create_sub_type(t, f'{self.name}_{i}') for i, t in enumerate(get_args(self.type_))]
+            self.type_ = origin
+            return
+        else:
+            raise TypeError(f'Fields of type "{origin}" are not supported.')
+
+        # type_ has been refined eg. as the type of a List and sub_fields needs to be populated
+        self.sub_fields = [self._create_sub_type(self.type_, '_' + self.name)]
+
+    def prepare_discriminated_union_sub_fields(self) -> None:
+        """
+        Prepare the mapping <discriminator key> -> <ModelField> and update `sub_fields`
+        Note that this process can be aborted if a `ForwardRef` is encountered
+        """
+        assert self.discriminator_key is not None
+
+        if self.type_.__class__ is DeferredType:
+            return
+
+        assert self.sub_fields is not None
+        sub_fields_mapping: Dict[str, 'ModelField'] = {}
+        all_aliases: Set[str] = set()
+
+        for sub_field in self.sub_fields:
+            t = sub_field.type_
+            if t.__class__ is ForwardRef:
+                # Stopping everything...will need to call `update_forward_refs`
+                return
+
+            alias, discriminator_values = get_discriminator_alias_and_values(t, self.discriminator_key)
+            all_aliases.add(alias)
+            for discriminator_value in discriminator_values:
+                sub_fields_mapping[discriminator_value] = sub_field
+
+        self.sub_fields_mapping = sub_fields_mapping
+        self.discriminator_alias = get_unique_discriminator_alias(all_aliases, self.discriminator_key)
+
+    def _create_sub_type(self, type_: Type[Any], name: str, *, for_keys: bool = False) -> 'ModelField':
+        if for_keys:
+            class_validators = None
+        else:
+            # validators for sub items should not have `each_item` as we want to check only the first sublevel
+            class_validators = {
+                k: Validator(
+                    func=v.func,
+                    pre=v.pre,
+                    each_item=False,
+                    always=v.always,
+                    check_fields=v.check_fields,
+                    skip_on_failure=v.skip_on_failure,
+                )
+                for k, v in self.class_validators.items()
+                if v.each_item
+            }
+
+        field_info, _ = self._get_field_info(name, type_, None, self.model_config)
+
+        return self.__class__(
+            type_=type_,
+            name=name,
+            class_validators=class_validators,
+            model_config=self.model_config,
+            field_info=field_info,
+        )
+
+    def populate_validators(self) -> None:
+        """
+        Prepare self.pre_validators, self.validators, and self.post_validators based on self.type_'s  __get_validators__
+        and class validators. This method should be idempotent, e.g. it should be safe to call multiple times
+        without mis-configuring the field.
+        """
+        self.validate_always = getattr(self.type_, 'validate_always', False) or any(
+            v.always for v in self.class_validators.values()
+        )
+
+        class_validators_ = self.class_validators.values()
+        if not self.sub_fields or self.shape == SHAPE_GENERIC:
+            get_validators = getattr(self.type_, '__get_validators__', None)
+            v_funcs = (
+                *[v.func for v in class_validators_ if v.each_item and v.pre],
+                *(get_validators() if get_validators else list(find_validators(self.type_, self.model_config))),
+                *[v.func for v in class_validators_ if v.each_item and not v.pre],
+            )
+            self.validators = prep_validators(v_funcs)
+
+        self.pre_validators = []
+        self.post_validators = []
+
+        if self.field_info and self.field_info.const:
+            self.post_validators.append(make_generic_validator(constant_validator))
+
+        if class_validators_:
+            self.pre_validators += prep_validators(v.func for v in class_validators_ if not v.each_item and v.pre)
+            self.post_validators += prep_validators(v.func for v in class_validators_ if not v.each_item and not v.pre)
+
+        if self.parse_json:
+            self.pre_validators.append(make_generic_validator(validate_json))
+
+        self.pre_validators = self.pre_validators or None
+        self.post_validators = self.post_validators or None
+
+    def validate(
+        self, v: Any, values: Dict[str, Any], *, loc: 'LocStr', cls: Optional['ModelOrDc'] = None
+    ) -> 'ValidateReturn':
+
+        assert self.type_.__class__ is not DeferredType
+
+        if self.type_.__class__ is ForwardRef:
+            assert cls is not None
+            raise ConfigError(
+                f'field "{self.name}" not yet prepared so type is still a ForwardRef, '
+                f'you might need to call {cls.__name__}.update_forward_refs().'
+            )
+
+        errors: Optional['ErrorList']
+        if self.pre_validators:
+            v, errors = self._apply_validators(v, values, loc, cls, self.pre_validators)
+            if errors:
+                return v, errors
+
+        if v is None:
+            if is_none_type(self.type_):
+                # keep validating
+                pass
+            elif self.allow_none:
+                if self.post_validators:
+                    return self._apply_validators(v, values, loc, cls, self.post_validators)
+                else:
+                    return None, None
+            else:
+                return v, ErrorWrapper(NoneIsNotAllowedError(), loc)
+
+        if self.shape == SHAPE_SINGLETON:
+            v, errors = self._validate_singleton(v, values, loc, cls)
+        elif self.shape in MAPPING_LIKE_SHAPES:
+            v, errors = self._validate_mapping_like(v, values, loc, cls)
+        elif self.shape == SHAPE_TUPLE:
+            v, errors = self._validate_tuple(v, values, loc, cls)
+        elif self.shape == SHAPE_ITERABLE:
+            v, errors = self._validate_iterable(v, values, loc, cls)
+        elif self.shape == SHAPE_GENERIC:
+            v, errors = self._apply_validators(v, values, loc, cls, self.validators)
+        else:
+            #  sequence, list, set, generator, tuple with ellipsis, frozen set
+            v, errors = self._validate_sequence_like(v, values, loc, cls)
+
+        if not errors and self.post_validators:
+            v, errors = self._apply_validators(v, values, loc, cls, self.post_validators)
+        return v, errors
+
+    def _validate_sequence_like(  # noqa: C901 (ignore complexity)
+        self, v: Any, values: Dict[str, Any], loc: 'LocStr', cls: Optional['ModelOrDc']
+    ) -> 'ValidateReturn':
+        """
+        Validate sequence-like containers: lists, tuples, sets and generators
+        Note that large if-else blocks are necessary to enable Cython
+        optimization, which is why we disable the complexity check above.
+        """
+        if not sequence_like(v):
+            e: errors_.PydanticTypeError
+            if self.shape == SHAPE_LIST:
+                e = errors_.ListError()
+            elif self.shape in (SHAPE_TUPLE, SHAPE_TUPLE_ELLIPSIS):
+                e = errors_.TupleError()
+            elif self.shape == SHAPE_SET:
+                e = errors_.SetError()
+            elif self.shape == SHAPE_FROZENSET:
+                e = errors_.FrozenSetError()
+            else:
+                e = errors_.SequenceError()
+            return v, ErrorWrapper(e, loc)
+
+        loc = loc if isinstance(loc, tuple) else (loc,)
+        result = []
+        errors: List[ErrorList] = []
+        for i, v_ in enumerate(v):
+            v_loc = *loc, i
+            r, ee = self._validate_singleton(v_, values, v_loc, cls)
+            if ee:
+                errors.append(ee)
+            else:
+                result.append(r)
+
+        if errors:
+            return v, errors
+
+        converted: Union[List[Any], Set[Any], FrozenSet[Any], Tuple[Any, ...], Iterator[Any], Deque[Any]] = result
+
+        if self.shape == SHAPE_SET:
+            converted = set(result)
+        elif self.shape == SHAPE_FROZENSET:
+            converted = frozenset(result)
+        elif self.shape == SHAPE_TUPLE_ELLIPSIS:
+            converted = tuple(result)
+        elif self.shape == SHAPE_DEQUE:
+            converted = deque(result)
+        elif self.shape == SHAPE_SEQUENCE:
+            if isinstance(v, tuple):
+                converted = tuple(result)
+            elif isinstance(v, set):
+                converted = set(result)
+            elif isinstance(v, Generator):
+                converted = iter(result)
+            elif isinstance(v, deque):
+                converted = deque(result)
+        return converted, None
+
+    def _validate_iterable(
+        self, v: Any, values: Dict[str, Any], loc: 'LocStr', cls: Optional['ModelOrDc']
+    ) -> 'ValidateReturn':
+        """
+        Validate Iterables.
+
+        This intentionally doesn't validate values to allow infinite generators.
+        """
+
+        try:
+            iterable = iter(v)
+        except TypeError:
+            return v, ErrorWrapper(errors_.IterableError(), loc)
+        return iterable, None
+
+    def _validate_tuple(
+        self, v: Any, values: Dict[str, Any], loc: 'LocStr', cls: Optional['ModelOrDc']
+    ) -> 'ValidateReturn':
+        e: Optional[Exception] = None
+        if not sequence_like(v):
+            e = errors_.TupleError()
+        else:
+            actual_length, expected_length = len(v), len(self.sub_fields)  # type: ignore
+            if actual_length != expected_length:
+                e = errors_.TupleLengthError(actual_length=actual_length, expected_length=expected_length)
+
+        if e:
+            return v, ErrorWrapper(e, loc)
+
+        loc = loc if isinstance(loc, tuple) else (loc,)
+        result = []
+        errors: List[ErrorList] = []
+        for i, (v_, field) in enumerate(zip(v, self.sub_fields)):  # type: ignore
+            v_loc = *loc, i
+            r, ee = field.validate(v_, values, loc=v_loc, cls=cls)
+            if ee:
+                errors.append(ee)
+            else:
+                result.append(r)
+
+        if errors:
+            return v, errors
+        else:
+            return tuple(result), None
+
+    def _validate_mapping_like(
+        self, v: Any, values: Dict[str, Any], loc: 'LocStr', cls: Optional['ModelOrDc']
+    ) -> 'ValidateReturn':
+        try:
+            v_iter = dict_validator(v)
+        except TypeError as exc:
+            return v, ErrorWrapper(exc, loc)
+
+        loc = loc if isinstance(loc, tuple) else (loc,)
+        result, errors = {}, []
+        for k, v_ in v_iter.items():
+            v_loc = *loc, '__key__'
+            key_result, key_errors = self.key_field.validate(k, values, loc=v_loc, cls=cls)  # type: ignore
+            if key_errors:
+                errors.append(key_errors)
+                continue
+
+            v_loc = *loc, k
+            value_result, value_errors = self._validate_singleton(v_, values, v_loc, cls)
+            if value_errors:
+                errors.append(value_errors)
+                continue
+
+            result[key_result] = value_result
+        if errors:
+            return v, errors
+        elif self.shape == SHAPE_DICT:
+            return result, None
+        elif self.shape == SHAPE_DEFAULTDICT:
+            return defaultdict(self.type_, result), None
+        elif self.shape == SHAPE_COUNTER:
+            return CollectionCounter(result), None
+        else:
+            return self._get_mapping_value(v, result), None
+
+    def _get_mapping_value(self, original: T, converted: Dict[Any, Any]) -> Union[T, Dict[Any, Any]]:
+        """
+        When type is `Mapping[KT, KV]` (or another unsupported mapping), we try to avoid
+        coercing to `dict` unwillingly.
+        """
+        original_cls = original.__class__
+
+        if original_cls == dict or original_cls == Dict:
+            return converted
+        elif original_cls in {defaultdict, DefaultDict}:
+            return defaultdict(self.type_, converted)
+        else:
+            try:
+                # Counter, OrderedDict, UserDict, ...
+                return original_cls(converted)  # type: ignore
+            except TypeError:
+                raise RuntimeError(f'Could not convert dictionary to {original_cls.__name__!r}') from None
+
+    def _validate_singleton(
+        self, v: Any, values: Dict[str, Any], loc: 'LocStr', cls: Optional['ModelOrDc']
+    ) -> 'ValidateReturn':
+        if self.sub_fields:
+            if self.discriminator_key is not None:
+                return self._validate_discriminated_union(v, values, loc, cls)
+
+            errors = []
+
+            if self.model_config.smart_union and is_union(get_origin(self.type_)):
+                # 1st pass: check if the value is an exact instance of one of the Union types
+                # (e.g. to avoid coercing a bool into an int)
+                for field in self.sub_fields:
+                    if v.__class__ is field.outer_type_:
+                        return v, None
+
+                # 2nd pass: check if the value is an instance of any subclass of the Union types
+                for field in self.sub_fields:
+                    # This whole logic will be improved later on to support more complex `isinstance` checks
+                    # It will probably be done once a strict mode is added and be something like:
+                    # ```
+                    #     value, error = field.validate(v, values, strict=True)
+                    #     if error is None:
+                    #         return value, None
+                    # ```
+                    try:
+                        if isinstance(v, field.outer_type_):
+                            return v, None
+                    except TypeError:
+                        # compound type
+                        if lenient_isinstance(v, get_origin(field.outer_type_)):
+                            value, error = field.validate(v, values, loc=loc, cls=cls)
+                            if not error:
+                                return value, None
+
+            # 1st pass by default or 3rd pass with `smart_union` enabled:
+            # check if the value can be coerced into one of the Union types
+            for field in self.sub_fields:
+                value, error = field.validate(v, values, loc=loc, cls=cls)
+                if error:
+                    errors.append(error)
+                else:
+                    return value, None
+            return v, errors
+        else:
+            return self._apply_validators(v, values, loc, cls, self.validators)
+
+    def _validate_discriminated_union(
+        self, v: Any, values: Dict[str, Any], loc: 'LocStr', cls: Optional['ModelOrDc']
+    ) -> 'ValidateReturn':
+        assert self.discriminator_key is not None
+        assert self.discriminator_alias is not None
+
+        try:
+            discriminator_value = v[self.discriminator_alias]
+        except KeyError:
+            return v, ErrorWrapper(MissingDiscriminator(discriminator_key=self.discriminator_key), loc)
+        except TypeError:
+            try:
+                # BaseModel or dataclass
+                discriminator_value = getattr(v, self.discriminator_alias)
+            except (AttributeError, TypeError):
+                return v, ErrorWrapper(MissingDiscriminator(discriminator_key=self.discriminator_key), loc)
+
+        try:
+            sub_field = self.sub_fields_mapping[discriminator_value]  # type: ignore[index]
+        except TypeError:
+            assert cls is not None
+            raise ConfigError(
+                f'field "{self.name}" not yet prepared so type is still a ForwardRef, '
+                f'you might need to call {cls.__name__}.update_forward_refs().'
+            )
+        except KeyError:
+            assert self.sub_fields_mapping is not None
+            return v, ErrorWrapper(
+                InvalidDiscriminator(
+                    discriminator_key=self.discriminator_key,
+                    discriminator_value=discriminator_value,
+                    allowed_values=list(self.sub_fields_mapping),
+                ),
+                loc,
+            )
+        else:
+            if not isinstance(loc, tuple):
+                loc = (loc,)
+            return sub_field.validate(v, values, loc=(*loc, display_as_type(sub_field.type_)), cls=cls)
+
+    def _apply_validators(
+        self, v: Any, values: Dict[str, Any], loc: 'LocStr', cls: Optional['ModelOrDc'], validators: 'ValidatorsList'
+    ) -> 'ValidateReturn':
+        for validator in validators:
+            try:
+                v = validator(cls, v, values, self, self.model_config)
+            except (ValueError, TypeError, AssertionError) as exc:
+                return v, ErrorWrapper(exc, loc)
+        return v, None
+
+    def is_complex(self) -> bool:
+        """
+        Whether the field is "complex" eg. env variables should be parsed as JSON.
+        """
+        from .main import BaseModel
+
+        return (
+            self.shape != SHAPE_SINGLETON
+            or lenient_issubclass(self.type_, (BaseModel, list, set, frozenset, dict))
+            or hasattr(self.type_, '__pydantic_model__')  # pydantic dataclass
+        )
+
+    def _type_display(self) -> PyObjectStr:
+        t = display_as_type(self.type_)
+
+        # have to do this since display_as_type(self.outer_type_) is different (and wrong) on python 3.6
+        if self.shape in MAPPING_LIKE_SHAPES:
+            t = f'Mapping[{display_as_type(self.key_field.type_)}, {t}]'  # type: ignore
+        elif self.shape == SHAPE_TUPLE:
+            t = 'Tuple[{}]'.format(', '.join(display_as_type(f.type_) for f in self.sub_fields))  # type: ignore
+        elif self.shape == SHAPE_GENERIC:
+            assert self.sub_fields
+            t = '{}[{}]'.format(
+                display_as_type(self.type_), ', '.join(display_as_type(f.type_) for f in self.sub_fields)
+            )
+        elif self.shape != SHAPE_SINGLETON:
+            t = SHAPE_NAME_LOOKUP[self.shape].format(t)
+
+        if self.allow_none and (self.shape != SHAPE_SINGLETON or not self.sub_fields):
+            t = f'Optional[{t}]'
+        return PyObjectStr(t)
+
+    def __repr_args__(self) -> 'ReprArgs':
+        args = [('name', self.name), ('type', self._type_display()), ('required', self.required)]
+
+        if not self.required:
+            if self.default_factory is not None:
+                args.append(('default_factory', f'<function {self.default_factory.__name__}>'))
+            else:
+                args.append(('default', self.default))
+
+        if self.alt_alias:
+            args.append(('alias', self.alias))
+        return args
+
+
+class ModelPrivateAttr(Representation):
+    __slots__ = ('default', 'default_factory')
+
+    def __init__(self, default: Any = Undefined, *, default_factory: Optional[NoArgAnyCallable] = None) -> None:
+        self.default = default
+        self.default_factory = default_factory
+
+    def get_default(self) -> Any:
+        return smart_deepcopy(self.default) if self.default_factory is None else self.default_factory()
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, self.__class__) and (self.default, self.default_factory) == (
+            other.default,
+            other.default_factory,
+        )
+
+
+def PrivateAttr(
+    default: Any = Undefined,
+    *,
+    default_factory: Optional[NoArgAnyCallable] = None,
+) -> Any:
+    """
+    Indicates that attribute is only used internally and never mixed with regular fields.
+
+    Types or values of private attrs are not checked by pydantic and it's up to you to keep them relevant.
+
+    Private attrs are stored in model __slots__.
+
+    :param default: the attribute’s default value
+    :param default_factory: callable that will be called when a default value is needed for this attribute
+      If both `default` and `default_factory` are set, an error is raised.
+    """
+    if default is not Undefined and default_factory is not None:
+        raise ValueError('cannot specify both default and default_factory')
+
+    return ModelPrivateAttr(
+        default,
+        default_factory=default_factory,
+    )
+
+
+class DeferredType:
+    """
+    Used to postpone field preparation, while creating recursive generic models.
+    """
diff --git a/myenv/lib/python3.9/site-packages/pydantic/generics.py b/myenv/lib/python3.9/site-packages/pydantic/generics.py
new file mode 100644
index 0000000..1ec9a7d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/generics.py
@@ -0,0 +1,360 @@
+import sys
+import typing
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Dict,
+    Generic,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from typing_extensions import Annotated
+
+from .class_validators import gather_all_validators
+from .fields import DeferredType
+from .main import BaseModel, create_model
+from .types import JsonWrapper
+from .typing import display_as_type, get_all_type_hints, get_args, get_origin, typing_base
+from .utils import LimitedDict, all_identical, lenient_issubclass
+
+GenericModelT = TypeVar('GenericModelT', bound='GenericModel')
+TypeVarType = Any  # since mypy doesn't allow the use of TypeVar as a type
+
+Parametrization = Mapping[TypeVarType, Type[Any]]
+
+_generic_types_cache: 'LimitedDict[Tuple[Type[Any], Union[Any, Tuple[Any, ...]]], Type[BaseModel]]' = LimitedDict()
+# _assigned_parameters is a Mapping from parametrized version of generic models to assigned types of parametrizations
+# as captured during construction of the class (not instances).
+# E.g., for generic model `Model[A, B]`, when parametrized model `Model[int, str]` is created,
+# `Model[int, str]`: {A: int, B: str}` will be stored in `_assigned_parameters`.
+# (This information is only otherwise available after creation from the class name string).
+_assigned_parameters: 'LimitedDict[Type[Any], Parametrization]' = LimitedDict()
+
+
+class GenericModel(BaseModel):
+    __slots__ = ()
+    __concrete__: ClassVar[bool] = False
+
+    if TYPE_CHECKING:
+        # Putting this in a TYPE_CHECKING block allows us to replace `if Generic not in cls.__bases__` with
+        # `not hasattr(cls, "__parameters__")`. This means we don't need to force non-concrete subclasses of
+        # `GenericModel` to also inherit from `Generic`, which would require changes to the use of `create_model` below.
+        __parameters__: ClassVar[Tuple[TypeVarType, ...]]
+
+    # Setting the return type as Type[Any] instead of Type[BaseModel] prevents PyCharm warnings
+    def __class_getitem__(cls: Type[GenericModelT], params: Union[Type[Any], Tuple[Type[Any], ...]]) -> Type[Any]:
+        """Instantiates a new class from a generic class `cls` and type variables `params`.
+
+        :param params: Tuple of types the class . Given a generic class
+            `Model` with 2 type variables and a concrete model `Model[str, int]`,
+            the value `(str, int)` would be passed to `params`.
+        :return: New model class inheriting from `cls` with instantiated
+            types described by `params`. If no parameters are given, `cls` is
+            returned as is.
+
+        """
+        cached = _generic_types_cache.get((cls, params))
+        if cached is not None:
+            return cached
+        if cls.__concrete__ and Generic not in cls.__bases__:
+            raise TypeError('Cannot parameterize a concrete instantiation of a generic model')
+        if not isinstance(params, tuple):
+            params = (params,)
+        if cls is GenericModel and any(isinstance(param, TypeVar) for param in params):
+            raise TypeError('Type parameters should be placed on typing.Generic, not GenericModel')
+        if not hasattr(cls, '__parameters__'):
+            raise TypeError(f'Type {cls.__name__} must inherit from typing.Generic before being parameterized')
+
+        check_parameters_count(cls, params)
+        # Build map from generic typevars to passed params
+        typevars_map: Dict[TypeVarType, Type[Any]] = dict(zip(cls.__parameters__, params))
+        if all_identical(typevars_map.keys(), typevars_map.values()) and typevars_map:
+            return cls  # if arguments are equal to parameters it's the same object
+
+        # Create new model with original model as parent inserting fields with DeferredType.
+        model_name = cls.__concrete_name__(params)
+        validators = gather_all_validators(cls)
+
+        type_hints = get_all_type_hints(cls).items()
+        instance_type_hints = {k: v for k, v in type_hints if get_origin(v) is not ClassVar}
+
+        fields = {k: (DeferredType(), cls.__fields__[k].field_info) for k in instance_type_hints if k in cls.__fields__}
+
+        model_module, called_globally = get_caller_frame_info()
+        created_model = cast(
+            Type[GenericModel],  # casting ensures mypy is aware of the __concrete__ and __parameters__ attributes
+            create_model(
+                model_name,
+                __module__=model_module or cls.__module__,
+                __base__=(cls,) + tuple(cls.__parameterized_bases__(typevars_map)),
+                __config__=None,
+                __validators__=validators,
+                __cls_kwargs__=None,
+                **fields,
+            ),
+        )
+
+        _assigned_parameters[created_model] = typevars_map
+
+        if called_globally:  # create global reference and therefore allow pickling
+            object_by_reference = None
+            reference_name = model_name
+            reference_module_globals = sys.modules[created_model.__module__].__dict__
+            while object_by_reference is not created_model:
+                object_by_reference = reference_module_globals.setdefault(reference_name, created_model)
+                reference_name += '_'
+
+        created_model.Config = cls.Config
+
+        # Find any typevars that are still present in the model.
+        # If none are left, the model is fully "concrete", otherwise the new
+        # class is a generic class as well taking the found typevars as
+        # parameters.
+        new_params = tuple(
+            {param: None for param in iter_contained_typevars(typevars_map.values())}
+        )  # use dict as ordered set
+        created_model.__concrete__ = not new_params
+        if new_params:
+            created_model.__parameters__ = new_params
+
+        # Save created model in cache so we don't end up creating duplicate
+        # models that should be identical.
+        _generic_types_cache[(cls, params)] = created_model
+        if len(params) == 1:
+            _generic_types_cache[(cls, params[0])] = created_model
+
+        # Recursively walk class type hints and replace generic typevars
+        # with concrete types that were passed.
+        _prepare_model_fields(created_model, fields, instance_type_hints, typevars_map)
+
+        return created_model
+
+    @classmethod
+    def __concrete_name__(cls: Type[Any], params: Tuple[Type[Any], ...]) -> str:
+        """Compute class name for child classes.
+
+        :param params: Tuple of types the class . Given a generic class
+            `Model` with 2 type variables and a concrete model `Model[str, int]`,
+            the value `(str, int)` would be passed to `params`.
+        :return: String representing a the new class where `params` are
+            passed to `cls` as type variables.
+
+        This method can be overridden to achieve a custom naming scheme for GenericModels.
+        """
+        param_names = [display_as_type(param) for param in params]
+        params_component = ', '.join(param_names)
+        return f'{cls.__name__}[{params_component}]'
+
+    @classmethod
+    def __parameterized_bases__(cls, typevars_map: Parametrization) -> Iterator[Type[Any]]:
+        """
+        Returns unbound bases of cls parameterised to given type variables
+
+        :param typevars_map: Dictionary of type applications for binding subclasses.
+            Given a generic class `Model` with 2 type variables [S, T]
+            and a concrete model `Model[str, int]`,
+            the value `{S: str, T: int}` would be passed to `typevars_map`.
+        :return: an iterator of generic sub classes, parameterised by `typevars_map`
+            and other assigned parameters of `cls`
+
+        e.g.:
+        ```
+        class A(GenericModel, Generic[T]):
+            ...
+
+        class B(A[V], Generic[V]):
+            ...
+
+        assert A[int] in B.__parameterized_bases__({V: int})
+        ```
+        """
+
+        def build_base_model(
+            base_model: Type[GenericModel], mapped_types: Parametrization
+        ) -> Iterator[Type[GenericModel]]:
+            base_parameters = tuple([mapped_types[param] for param in base_model.__parameters__])
+            parameterized_base = base_model.__class_getitem__(base_parameters)
+            if parameterized_base is base_model or parameterized_base is cls:
+                # Avoid duplication in MRO
+                return
+            yield parameterized_base
+
+        for base_model in cls.__bases__:
+            if not issubclass(base_model, GenericModel):
+                # not a class that can be meaningfully parameterized
+                continue
+            elif not getattr(base_model, '__parameters__', None):
+                # base_model is "GenericModel"  (and has no __parameters__)
+                # or
+                # base_model is already concrete, and will be included transitively via cls.
+                continue
+            elif cls in _assigned_parameters:
+                if base_model in _assigned_parameters:
+                    # cls is partially parameterised but not from base_model
+                    # e.g. cls = B[S], base_model = A[S]
+                    # B[S][int] should subclass A[int],  (and will be transitively via B[int])
+                    # but it's not viable to consistently subclass types with arbitrary construction
+                    # So don't attempt to include A[S][int]
+                    continue
+                else:  # base_model not in _assigned_parameters:
+                    # cls is partially parameterized, base_model is original generic
+                    # e.g.  cls = B[str, T], base_model = B[S, T]
+                    # Need to determine the mapping for the base_model parameters
+                    mapped_types: Parametrization = {
+                        key: typevars_map.get(value, value) for key, value in _assigned_parameters[cls].items()
+                    }
+                    yield from build_base_model(base_model, mapped_types)
+            else:
+                # cls is base generic, so base_class has a distinct base
+                # can construct the Parameterised base model using typevars_map directly
+                yield from build_base_model(base_model, typevars_map)
+
+
+def replace_types(type_: Any, type_map: Mapping[Any, Any]) -> Any:
+    """Return type with all occurrences of `type_map` keys recursively replaced with their values.
+
+    :param type_: Any type, class or generic alias
+    :param type_map: Mapping from `TypeVar` instance to concrete types.
+    :return: New type representing the basic structure of `type_` with all
+        `typevar_map` keys recursively replaced.
+
+    >>> replace_types(Tuple[str, Union[List[str], float]], {str: int})
+    Tuple[int, Union[List[int], float]]
+
+    """
+    if not type_map:
+        return type_
+
+    type_args = get_args(type_)
+    origin_type = get_origin(type_)
+
+    if origin_type is Annotated:
+        annotated_type, *annotations = type_args
+        return Annotated[replace_types(annotated_type, type_map), tuple(annotations)]
+
+    # Having type args is a good indicator that this is a typing module
+    # class instantiation or a generic alias of some sort.
+    if type_args:
+        resolved_type_args = tuple(replace_types(arg, type_map) for arg in type_args)
+        if all_identical(type_args, resolved_type_args):
+            # If all arguments are the same, there is no need to modify the
+            # type or create a new object at all
+            return type_
+        if (
+            origin_type is not None
+            and isinstance(type_, typing_base)
+            and not isinstance(origin_type, typing_base)
+            and getattr(type_, '_name', None) is not None
+        ):
+            # In python < 3.9 generic aliases don't exist so any of these like `list`,
+            # `type` or `collections.abc.Callable` need to be translated.
+            # See: https://www.python.org/dev/peps/pep-0585
+            origin_type = getattr(typing, type_._name)
+        assert origin_type is not None
+        return origin_type[resolved_type_args]
+
+    # We handle pydantic generic models separately as they don't have the same
+    # semantics as "typing" classes or generic aliases
+    if not origin_type and lenient_issubclass(type_, GenericModel) and not type_.__concrete__:
+        type_args = type_.__parameters__
+        resolved_type_args = tuple(replace_types(t, type_map) for t in type_args)
+        if all_identical(type_args, resolved_type_args):
+            return type_
+        return type_[resolved_type_args]
+
+    # Handle special case for typehints that can have lists as arguments.
+    # `typing.Callable[[int, str], int]` is an example for this.
+    if isinstance(type_, (List, list)):
+        resolved_list = list(replace_types(element, type_map) for element in type_)
+        if all_identical(type_, resolved_list):
+            return type_
+        return resolved_list
+
+    # For JsonWrapperValue, need to handle its inner type to allow correct parsing
+    # of generic Json arguments like Json[T]
+    if not origin_type and lenient_issubclass(type_, JsonWrapper):
+        type_.inner_type = replace_types(type_.inner_type, type_map)
+        return type_
+
+    # If all else fails, we try to resolve the type directly and otherwise just
+    # return the input with no modifications.
+    return type_map.get(type_, type_)
+
+
+def check_parameters_count(cls: Type[GenericModel], parameters: Tuple[Any, ...]) -> None:
+    actual = len(parameters)
+    expected = len(cls.__parameters__)
+    if actual != expected:
+        description = 'many' if actual > expected else 'few'
+        raise TypeError(f'Too {description} parameters for {cls.__name__}; actual {actual}, expected {expected}')
+
+
+DictValues: Type[Any] = {}.values().__class__
+
+
+def iter_contained_typevars(v: Any) -> Iterator[TypeVarType]:
+    """Recursively iterate through all subtypes and type args of `v` and yield any typevars that are found."""
+    if isinstance(v, TypeVar):
+        yield v
+    elif hasattr(v, '__parameters__') and not get_origin(v) and lenient_issubclass(v, GenericModel):
+        yield from v.__parameters__
+    elif isinstance(v, (DictValues, list)):
+        for var in v:
+            yield from iter_contained_typevars(var)
+    else:
+        args = get_args(v)
+        for arg in args:
+            yield from iter_contained_typevars(arg)
+
+
+def get_caller_frame_info() -> Tuple[Optional[str], bool]:
+    """
+    Used inside a function to check whether it was called globally
+
+    Will only work against non-compiled code, therefore used only in pydantic.generics
+
+    :returns Tuple[module_name, called_globally]
+    """
+    try:
+        previous_caller_frame = sys._getframe(2)
+    except ValueError as e:
+        raise RuntimeError('This function must be used inside another function') from e
+    except AttributeError:  # sys module does not have _getframe function, so there's nothing we can do about it
+        return None, False
+    frame_globals = previous_caller_frame.f_globals
+    return frame_globals.get('__name__'), previous_caller_frame.f_locals is frame_globals
+
+
+def _prepare_model_fields(
+    created_model: Type[GenericModel],
+    fields: Mapping[str, Any],
+    instance_type_hints: Mapping[str, type],
+    typevars_map: Mapping[Any, type],
+) -> None:
+    """
+    Replace DeferredType fields with concrete type hints and prepare them.
+    """
+
+    for key, field in created_model.__fields__.items():
+        if key not in fields:
+            assert field.type_.__class__ is not DeferredType
+            # https://github.com/nedbat/coveragepy/issues/198
+            continue  # pragma: no cover
+
+        assert field.type_.__class__ is DeferredType, field.type_.__class__
+
+        field_type_hint = instance_type_hints[key]
+        concrete_type = replace_types(field_type_hint, typevars_map)
+        field.type_ = concrete_type
+        field.outer_type_ = concrete_type
+        field.prepare()
+        created_model.__annotations__[key] = concrete_type
diff --git a/myenv/lib/python3.9/site-packages/pydantic/json.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/json.cpython-39-darwin.so
new file mode 100755
index 0000000..f9ca9b2
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/json.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/json.py b/myenv/lib/python3.9/site-packages/pydantic/json.py
new file mode 100644
index 0000000..cab8b80
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/json.py
@@ -0,0 +1,119 @@
+import datetime
+import re
+import sys
+from collections import deque
+from decimal import Decimal
+from enum import Enum
+from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network
+from pathlib import Path
+from types import GeneratorType
+from typing import Any, Callable, Dict, Type, Union
+from uuid import UUID
+
+if sys.version_info >= (3, 7):
+    Pattern = re.Pattern
+else:
+    # python 3.6
+    Pattern = re.compile('a').__class__
+
+from .color import Color
+from .networks import NameEmail
+from .types import SecretBytes, SecretStr
+
+__all__ = 'pydantic_encoder', 'custom_pydantic_encoder', 'timedelta_isoformat'
+
+
+def isoformat(o: Union[datetime.date, datetime.time]) -> str:
+    return o.isoformat()
+
+
+def decimal_encoder(dec_value: Decimal) -> Union[int, float]:
+    """
+    Encodes a Decimal as int of there's no exponent, otherwise float
+
+    This is useful when we use ConstrainedDecimal to represent Numeric(x,0)
+    where a integer (but not int typed) is used. Encoding this as a float
+    results in failed round-tripping between encode and parse.
+    Our Id type is a prime example of this.
+
+    >>> decimal_encoder(Decimal("1.0"))
+    1.0
+
+    >>> decimal_encoder(Decimal("1"))
+    1
+    """
+    if dec_value.as_tuple().exponent >= 0:
+        return int(dec_value)
+    else:
+        return float(dec_value)
+
+
+ENCODERS_BY_TYPE: Dict[Type[Any], Callable[[Any], Any]] = {
+    bytes: lambda o: o.decode(),
+    Color: str,
+    datetime.date: isoformat,
+    datetime.datetime: isoformat,
+    datetime.time: isoformat,
+    datetime.timedelta: lambda td: td.total_seconds(),
+    Decimal: decimal_encoder,
+    Enum: lambda o: o.value,
+    frozenset: list,
+    deque: list,
+    GeneratorType: list,
+    IPv4Address: str,
+    IPv4Interface: str,
+    IPv4Network: str,
+    IPv6Address: str,
+    IPv6Interface: str,
+    IPv6Network: str,
+    NameEmail: str,
+    Path: str,
+    Pattern: lambda o: o.pattern,
+    SecretBytes: str,
+    SecretStr: str,
+    set: list,
+    UUID: str,
+}
+
+
+def pydantic_encoder(obj: Any) -> Any:
+    from dataclasses import asdict, is_dataclass
+
+    from .main import BaseModel
+
+    if isinstance(obj, BaseModel):
+        return obj.dict()
+    elif is_dataclass(obj):
+        return asdict(obj)
+
+    # Check the class type and its superclasses for a matching encoder
+    for base in obj.__class__.__mro__[:-1]:
+        try:
+            encoder = ENCODERS_BY_TYPE[base]
+        except KeyError:
+            continue
+        return encoder(obj)
+    else:  # We have exited the for loop without finding a suitable encoder
+        raise TypeError(f"Object of type '{obj.__class__.__name__}' is not JSON serializable")
+
+
+def custom_pydantic_encoder(type_encoders: Dict[Any, Callable[[Type[Any]], Any]], obj: Any) -> Any:
+    # Check the class type and its superclasses for a matching encoder
+    for base in obj.__class__.__mro__[:-1]:
+        try:
+            encoder = type_encoders[base]
+        except KeyError:
+            continue
+
+        return encoder(obj)
+    else:  # We have exited the for loop without finding a suitable encoder
+        return pydantic_encoder(obj)
+
+
+def timedelta_isoformat(td: datetime.timedelta) -> str:
+    """
+    ISO 8601 encoding for timedeltas.
+    """
+    minutes, seconds = divmod(td.seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    return f'P{td.days}DT{hours:d}H{minutes:d}M{seconds:d}.{td.microseconds:06d}S'
diff --git a/myenv/lib/python3.9/site-packages/pydantic/main.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/main.cpython-39-darwin.so
new file mode 100755
index 0000000..398d972
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/main.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/main.py b/myenv/lib/python3.9/site-packages/pydantic/main.py
new file mode 100644
index 0000000..0c20d9e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/main.py
@@ -0,0 +1,1071 @@
+import warnings
+from abc import ABCMeta
+from copy import deepcopy
+from enum import Enum
+from functools import partial
+from pathlib import Path
+from types import FunctionType
+from typing import (
+    TYPE_CHECKING,
+    AbstractSet,
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    no_type_check,
+    overload,
+)
+
+from .class_validators import ValidatorGroup, extract_root_validators, extract_validators, inherit_validators
+from .config import BaseConfig, Extra, inherit_config, prepare_config
+from .error_wrappers import ErrorWrapper, ValidationError
+from .errors import ConfigError, DictError, ExtraError, MissingError
+from .fields import MAPPING_LIKE_SHAPES, Field, FieldInfo, ModelField, ModelPrivateAttr, PrivateAttr, Undefined
+from .json import custom_pydantic_encoder, pydantic_encoder
+from .parse import Protocol, load_file, load_str_bytes
+from .schema import default_ref_template, model_schema
+from .types import PyObject, StrBytes
+from .typing import (
+    AnyCallable,
+    get_args,
+    get_origin,
+    is_classvar,
+    is_namedtuple,
+    is_union,
+    resolve_annotations,
+    update_model_forward_refs,
+)
+from .utils import (
+    ROOT_KEY,
+    ClassAttribute,
+    GetterDict,
+    Representation,
+    ValueItems,
+    generate_model_signature,
+    is_valid_field,
+    is_valid_private_name,
+    lenient_issubclass,
+    sequence_like,
+    smart_deepcopy,
+    unique_list,
+    validate_field_name,
+)
+
+if TYPE_CHECKING:
+    from inspect import Signature
+
+    from .class_validators import ValidatorListDict
+    from .types import ModelOrDc
+    from .typing import (
+        AbstractSetIntStr,
+        AnyClassMethod,
+        CallableGenerator,
+        DictAny,
+        DictStrAny,
+        MappingIntStrAny,
+        ReprArgs,
+        SetStr,
+        TupleGenerator,
+    )
+
+    Model = TypeVar('Model', bound='BaseModel')
+
+
+try:
+    import cython  # type: ignore
+except ImportError:
+    compiled: bool = False
+else:  # pragma: no cover
+    try:
+        compiled = cython.compiled
+    except AttributeError:
+        compiled = False
+
+__all__ = 'BaseModel', 'compiled', 'create_model', 'validate_model'
+
+_T = TypeVar('_T')
+
+
+def __dataclass_transform__(
+    *,
+    eq_default: bool = True,
+    order_default: bool = False,
+    kw_only_default: bool = False,
+    field_descriptors: Tuple[Union[type, Callable[..., Any]], ...] = (()),
+) -> Callable[[_T], _T]:
+    return lambda a: a
+
+
+def validate_custom_root_type(fields: Dict[str, ModelField]) -> None:
+    if len(fields) > 1:
+        raise ValueError(f'{ROOT_KEY} cannot be mixed with other fields')
+
+
+def generate_hash_function(frozen: bool) -> Optional[Callable[[Any], int]]:
+    def hash_function(self_: Any) -> int:
+        return hash(self_.__class__) + hash(tuple(self_.__dict__.values()))
+
+    return hash_function if frozen else None
+
+
+# If a field is of type `Callable`, its default value should be a function and cannot to ignored.
+ANNOTATED_FIELD_UNTOUCHED_TYPES: Tuple[Any, ...] = (property, type, classmethod, staticmethod)
+# When creating a `BaseModel` instance, we bypass all the methods, properties... added to the model
+UNTOUCHED_TYPES: Tuple[Any, ...] = (FunctionType,) + ANNOTATED_FIELD_UNTOUCHED_TYPES
+# Note `ModelMetaclass` refers to `BaseModel`, but is also used to *create* `BaseModel`, so we need to add this extra
+# (somewhat hacky) boolean to keep track of whether we've created the `BaseModel` class yet, and therefore whether it's
+# safe to refer to it. If it *hasn't* been created, we assume that the `__new__` call we're in the middle of is for
+# the `BaseModel` class, since that's defined immediately after the metaclass.
+_is_base_model_class_defined = False
+
+
+@__dataclass_transform__(kw_only_default=True, field_descriptors=(Field, FieldInfo))
+class ModelMetaclass(ABCMeta):
+    @no_type_check  # noqa C901
+    def __new__(mcs, name, bases, namespace, **kwargs):  # noqa C901
+        fields: Dict[str, ModelField] = {}
+        config = BaseConfig
+        validators: 'ValidatorListDict' = {}
+
+        pre_root_validators, post_root_validators = [], []
+        private_attributes: Dict[str, ModelPrivateAttr] = {}
+        base_private_attributes: Dict[str, ModelPrivateAttr] = {}
+        slots: SetStr = namespace.get('__slots__', ())
+        slots = {slots} if isinstance(slots, str) else set(slots)
+        class_vars: SetStr = set()
+        hash_func: Optional[Callable[[Any], int]] = None
+
+        for base in reversed(bases):
+            if _is_base_model_class_defined and issubclass(base, BaseModel) and base != BaseModel:
+                fields.update(smart_deepcopy(base.__fields__))
+                config = inherit_config(base.__config__, config)
+                validators = inherit_validators(base.__validators__, validators)
+                pre_root_validators += base.__pre_root_validators__
+                post_root_validators += base.__post_root_validators__
+                base_private_attributes.update(base.__private_attributes__)
+                class_vars.update(base.__class_vars__)
+                hash_func = base.__hash__
+
+        resolve_forward_refs = kwargs.pop('__resolve_forward_refs__', True)
+        allowed_config_kwargs: SetStr = {
+            key
+            for key in dir(config)
+            if not (key.startswith('__') and key.endswith('__'))  # skip dunder methods and attributes
+        }
+        config_kwargs = {key: kwargs.pop(key) for key in kwargs.keys() & allowed_config_kwargs}
+        config_from_namespace = namespace.get('Config')
+        if config_kwargs and config_from_namespace:
+            raise TypeError('Specifying config in two places is ambiguous, use either Config attribute or class kwargs')
+        config = inherit_config(config_from_namespace, config, **config_kwargs)
+
+        validators = inherit_validators(extract_validators(namespace), validators)
+        vg = ValidatorGroup(validators)
+
+        for f in fields.values():
+            f.set_config(config)
+            extra_validators = vg.get_validators(f.name)
+            if extra_validators:
+                f.class_validators.update(extra_validators)
+                # re-run prepare to add extra validators
+                f.populate_validators()
+
+        prepare_config(config, name)
+
+        untouched_types = ANNOTATED_FIELD_UNTOUCHED_TYPES
+
+        def is_untouched(v: Any) -> bool:
+            return isinstance(v, untouched_types) or v.__class__.__name__ == 'cython_function_or_method'
+
+        if (namespace.get('__module__'), namespace.get('__qualname__')) != ('pydantic.main', 'BaseModel'):
+            annotations = resolve_annotations(namespace.get('__annotations__', {}), namespace.get('__module__', None))
+            # annotation only fields need to come first in fields
+            for ann_name, ann_type in annotations.items():
+                if is_classvar(ann_type):
+                    class_vars.add(ann_name)
+                elif is_valid_field(ann_name):
+                    validate_field_name(bases, ann_name)
+                    value = namespace.get(ann_name, Undefined)
+                    allowed_types = get_args(ann_type) if is_union(get_origin(ann_type)) else (ann_type,)
+                    if (
+                        is_untouched(value)
+                        and ann_type != PyObject
+                        and not any(
+                            lenient_issubclass(get_origin(allowed_type), Type) for allowed_type in allowed_types
+                        )
+                    ):
+                        continue
+                    fields[ann_name] = ModelField.infer(
+                        name=ann_name,
+                        value=value,
+                        annotation=ann_type,
+                        class_validators=vg.get_validators(ann_name),
+                        config=config,
+                    )
+                elif ann_name not in namespace and config.underscore_attrs_are_private:
+                    private_attributes[ann_name] = PrivateAttr()
+
+            untouched_types = UNTOUCHED_TYPES + config.keep_untouched
+            for var_name, value in namespace.items():
+                can_be_changed = var_name not in class_vars and not is_untouched(value)
+                if isinstance(value, ModelPrivateAttr):
+                    if not is_valid_private_name(var_name):
+                        raise NameError(
+                            f'Private attributes "{var_name}" must not be a valid field name; '
+                            f'Use sunder or dunder names, e. g. "_{var_name}" or "__{var_name}__"'
+                        )
+                    private_attributes[var_name] = value
+                elif config.underscore_attrs_are_private and is_valid_private_name(var_name) and can_be_changed:
+                    private_attributes[var_name] = PrivateAttr(default=value)
+                elif is_valid_field(var_name) and var_name not in annotations and can_be_changed:
+                    validate_field_name(bases, var_name)
+                    inferred = ModelField.infer(
+                        name=var_name,
+                        value=value,
+                        annotation=annotations.get(var_name, Undefined),
+                        class_validators=vg.get_validators(var_name),
+                        config=config,
+                    )
+                    if var_name in fields:
+                        if lenient_issubclass(inferred.type_, fields[var_name].type_):
+                            inferred.type_ = fields[var_name].type_
+                        else:
+                            raise TypeError(
+                                f'The type of {name}.{var_name} differs from the new default value; '
+                                f'if you wish to change the type of this field, please use a type annotation'
+                            )
+                    fields[var_name] = inferred
+
+        _custom_root_type = ROOT_KEY in fields
+        if _custom_root_type:
+            validate_custom_root_type(fields)
+        vg.check_for_unused()
+        if config.json_encoders:
+            json_encoder = partial(custom_pydantic_encoder, config.json_encoders)
+        else:
+            json_encoder = pydantic_encoder
+        pre_rv_new, post_rv_new = extract_root_validators(namespace)
+
+        if hash_func is None:
+            hash_func = generate_hash_function(config.frozen)
+
+        exclude_from_namespace = fields | private_attributes.keys() | {'__slots__'}
+        new_namespace = {
+            '__config__': config,
+            '__fields__': fields,
+            '__exclude_fields__': {
+                name: field.field_info.exclude for name, field in fields.items() if field.field_info.exclude is not None
+            }
+            or None,
+            '__include_fields__': {
+                name: field.field_info.include for name, field in fields.items() if field.field_info.include is not None
+            }
+            or None,
+            '__validators__': vg.validators,
+            '__pre_root_validators__': unique_list(
+                pre_root_validators + pre_rv_new,
+                name_factory=lambda v: v.__name__,
+            ),
+            '__post_root_validators__': unique_list(
+                post_root_validators + post_rv_new,
+                name_factory=lambda skip_on_failure_and_v: skip_on_failure_and_v[1].__name__,
+            ),
+            '__schema_cache__': {},
+            '__json_encoder__': staticmethod(json_encoder),
+            '__custom_root_type__': _custom_root_type,
+            '__private_attributes__': {**base_private_attributes, **private_attributes},
+            '__slots__': slots | private_attributes.keys(),
+            '__hash__': hash_func,
+            '__class_vars__': class_vars,
+            **{n: v for n, v in namespace.items() if n not in exclude_from_namespace},
+        }
+
+        cls = super().__new__(mcs, name, bases, new_namespace, **kwargs)
+        # set __signature__ attr only for model class, but not for its instances
+        cls.__signature__ = ClassAttribute('__signature__', generate_model_signature(cls.__init__, fields, config))
+        if resolve_forward_refs:
+            cls.__try_update_forward_refs__()
+
+        return cls
+
+    def __instancecheck__(self, instance: Any) -> bool:
+        """
+        Avoid calling ABC _abc_subclasscheck unless we're pretty sure.
+
+        See #3829 and python/cpython#92810
+        """
+        return hasattr(instance, '__fields__') and super().__instancecheck__(instance)
+
+
+object_setattr = object.__setattr__
+
+
+class BaseModel(Representation, metaclass=ModelMetaclass):
+    if TYPE_CHECKING:
+        # populated by the metaclass, defined here to help IDEs only
+        __fields__: ClassVar[Dict[str, ModelField]] = {}
+        __include_fields__: ClassVar[Optional[Mapping[str, Any]]] = None
+        __exclude_fields__: ClassVar[Optional[Mapping[str, Any]]] = None
+        __validators__: ClassVar[Dict[str, AnyCallable]] = {}
+        __pre_root_validators__: ClassVar[List[AnyCallable]]
+        __post_root_validators__: ClassVar[List[Tuple[bool, AnyCallable]]]
+        __config__: ClassVar[Type[BaseConfig]] = BaseConfig
+        __json_encoder__: ClassVar[Callable[[Any], Any]] = lambda x: x
+        __schema_cache__: ClassVar['DictAny'] = {}
+        __custom_root_type__: ClassVar[bool] = False
+        __signature__: ClassVar['Signature']
+        __private_attributes__: ClassVar[Dict[str, ModelPrivateAttr]]
+        __class_vars__: ClassVar[SetStr]
+        __fields_set__: ClassVar[SetStr] = set()
+
+    Config = BaseConfig
+    __slots__ = ('__dict__', '__fields_set__')
+    __doc__ = ''  # Null out the Representation docstring
+
+    def __init__(__pydantic_self__, **data: Any) -> None:
+        """
+        Create a new model by parsing and validating input data from keyword arguments.
+
+        Raises ValidationError if the input data cannot be parsed to form a valid model.
+        """
+        # Uses something other than `self` the first arg to allow "self" as a settable attribute
+        values, fields_set, validation_error = validate_model(__pydantic_self__.__class__, data)
+        if validation_error:
+            raise validation_error
+        try:
+            object_setattr(__pydantic_self__, '__dict__', values)
+        except TypeError as e:
+            raise TypeError(
+                'Model values must be a dict; you may not have returned a dictionary from a root validator'
+            ) from e
+        object_setattr(__pydantic_self__, '__fields_set__', fields_set)
+        __pydantic_self__._init_private_attributes()
+
+    @no_type_check
+    def __setattr__(self, name, value):  # noqa: C901 (ignore complexity)
+        if name in self.__private_attributes__:
+            return object_setattr(self, name, value)
+
+        if self.__config__.extra is not Extra.allow and name not in self.__fields__:
+            raise ValueError(f'"{self.__class__.__name__}" object has no field "{name}"')
+        elif not self.__config__.allow_mutation or self.__config__.frozen:
+            raise TypeError(f'"{self.__class__.__name__}" is immutable and does not support item assignment')
+        elif self.__config__.validate_assignment:
+            new_values = {**self.__dict__, name: value}
+
+            for validator in self.__pre_root_validators__:
+                try:
+                    new_values = validator(self.__class__, new_values)
+                except (ValueError, TypeError, AssertionError) as exc:
+                    raise ValidationError([ErrorWrapper(exc, loc=ROOT_KEY)], self.__class__)
+
+            known_field = self.__fields__.get(name, None)
+            if known_field:
+                # We want to
+                # - make sure validators are called without the current value for this field inside `values`
+                # - keep other values (e.g. submodels) untouched (using `BaseModel.dict()` will change them into dicts)
+                # - keep the order of the fields
+                if not known_field.field_info.allow_mutation:
+                    raise TypeError(f'"{known_field.name}" has allow_mutation set to False and cannot be assigned')
+                dict_without_original_value = {k: v for k, v in self.__dict__.items() if k != name}
+                value, error_ = known_field.validate(value, dict_without_original_value, loc=name, cls=self.__class__)
+                if error_:
+                    raise ValidationError([error_], self.__class__)
+                else:
+                    new_values[name] = value
+
+            errors = []
+            for skip_on_failure, validator in self.__post_root_validators__:
+                if skip_on_failure and errors:
+                    continue
+                try:
+                    new_values = validator(self.__class__, new_values)
+                except (ValueError, TypeError, AssertionError) as exc:
+                    errors.append(ErrorWrapper(exc, loc=ROOT_KEY))
+            if errors:
+                raise ValidationError(errors, self.__class__)
+
+            # update the whole __dict__ as other values than just `value`
+            # may be changed (e.g. with `root_validator`)
+            object_setattr(self, '__dict__', new_values)
+        else:
+            self.__dict__[name] = value
+
+        self.__fields_set__.add(name)
+
+    def __getstate__(self) -> 'DictAny':
+        private_attrs = ((k, getattr(self, k, Undefined)) for k in self.__private_attributes__)
+        return {
+            '__dict__': self.__dict__,
+            '__fields_set__': self.__fields_set__,
+            '__private_attribute_values__': {k: v for k, v in private_attrs if v is not Undefined},
+        }
+
+    def __setstate__(self, state: 'DictAny') -> None:
+        object_setattr(self, '__dict__', state['__dict__'])
+        object_setattr(self, '__fields_set__', state['__fields_set__'])
+        for name, value in state.get('__private_attribute_values__', {}).items():
+            object_setattr(self, name, value)
+
+    def _init_private_attributes(self) -> None:
+        for name, private_attr in self.__private_attributes__.items():
+            default = private_attr.get_default()
+            if default is not Undefined:
+                object_setattr(self, name, default)
+
+    def dict(
+        self,
+        *,
+        include: Union['AbstractSetIntStr', 'MappingIntStrAny'] = None,
+        exclude: Union['AbstractSetIntStr', 'MappingIntStrAny'] = None,
+        by_alias: bool = False,
+        skip_defaults: bool = None,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+    ) -> 'DictStrAny':
+        """
+        Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
+        """
+        if skip_defaults is not None:
+            warnings.warn(
+                f'{self.__class__.__name__}.dict(): "skip_defaults" is deprecated and replaced by "exclude_unset"',
+                DeprecationWarning,
+            )
+            exclude_unset = skip_defaults
+
+        return dict(
+            self._iter(
+                to_dict=True,
+                by_alias=by_alias,
+                include=include,
+                exclude=exclude,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+            )
+        )
+
+    def json(
+        self,
+        *,
+        include: Union['AbstractSetIntStr', 'MappingIntStrAny'] = None,
+        exclude: Union['AbstractSetIntStr', 'MappingIntStrAny'] = None,
+        by_alias: bool = False,
+        skip_defaults: bool = None,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        encoder: Optional[Callable[[Any], Any]] = None,
+        models_as_dict: bool = True,
+        **dumps_kwargs: Any,
+    ) -> str:
+        """
+        Generate a JSON representation of the model, `include` and `exclude` arguments as per `dict()`.
+
+        `encoder` is an optional function to supply as `default` to json.dumps(), other arguments as per `json.dumps()`.
+        """
+        if skip_defaults is not None:
+            warnings.warn(
+                f'{self.__class__.__name__}.json(): "skip_defaults" is deprecated and replaced by "exclude_unset"',
+                DeprecationWarning,
+            )
+            exclude_unset = skip_defaults
+        encoder = cast(Callable[[Any], Any], encoder or self.__json_encoder__)
+
+        # We don't directly call `self.dict()`, which does exactly this with `to_dict=True`
+        # because we want to be able to keep raw `BaseModel` instances and not as `dict`.
+        # This allows users to write custom JSON encoders for given `BaseModel` classes.
+        data = dict(
+            self._iter(
+                to_dict=models_as_dict,
+                by_alias=by_alias,
+                include=include,
+                exclude=exclude,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+            )
+        )
+        if self.__custom_root_type__:
+            data = data[ROOT_KEY]
+        return self.__config__.json_dumps(data, default=encoder, **dumps_kwargs)
+
+    @classmethod
+    def _enforce_dict_if_root(cls, obj: Any) -> Any:
+        if cls.__custom_root_type__ and (
+            not (isinstance(obj, dict) and obj.keys() == {ROOT_KEY})
+            or cls.__fields__[ROOT_KEY].shape in MAPPING_LIKE_SHAPES
+        ):
+            return {ROOT_KEY: obj}
+        else:
+            return obj
+
+    @classmethod
+    def parse_obj(cls: Type['Model'], obj: Any) -> 'Model':
+        obj = cls._enforce_dict_if_root(obj)
+        if not isinstance(obj, dict):
+            try:
+                obj = dict(obj)
+            except (TypeError, ValueError) as e:
+                exc = TypeError(f'{cls.__name__} expected dict not {obj.__class__.__name__}')
+                raise ValidationError([ErrorWrapper(exc, loc=ROOT_KEY)], cls) from e
+        return cls(**obj)
+
+    @classmethod
+    def parse_raw(
+        cls: Type['Model'],
+        b: StrBytes,
+        *,
+        content_type: str = None,
+        encoding: str = 'utf8',
+        proto: Protocol = None,
+        allow_pickle: bool = False,
+    ) -> 'Model':
+        try:
+            obj = load_str_bytes(
+                b,
+                proto=proto,
+                content_type=content_type,
+                encoding=encoding,
+                allow_pickle=allow_pickle,
+                json_loads=cls.__config__.json_loads,
+            )
+        except (ValueError, TypeError, UnicodeDecodeError) as e:
+            raise ValidationError([ErrorWrapper(e, loc=ROOT_KEY)], cls)
+        return cls.parse_obj(obj)
+
+    @classmethod
+    def parse_file(
+        cls: Type['Model'],
+        path: Union[str, Path],
+        *,
+        content_type: str = None,
+        encoding: str = 'utf8',
+        proto: Protocol = None,
+        allow_pickle: bool = False,
+    ) -> 'Model':
+        obj = load_file(
+            path,
+            proto=proto,
+            content_type=content_type,
+            encoding=encoding,
+            allow_pickle=allow_pickle,
+            json_loads=cls.__config__.json_loads,
+        )
+        return cls.parse_obj(obj)
+
+    @classmethod
+    def from_orm(cls: Type['Model'], obj: Any) -> 'Model':
+        if not cls.__config__.orm_mode:
+            raise ConfigError('You must have the config attribute orm_mode=True to use from_orm')
+        obj = {ROOT_KEY: obj} if cls.__custom_root_type__ else cls._decompose_class(obj)
+        m = cls.__new__(cls)
+        values, fields_set, validation_error = validate_model(cls, obj)
+        if validation_error:
+            raise validation_error
+        object_setattr(m, '__dict__', values)
+        object_setattr(m, '__fields_set__', fields_set)
+        m._init_private_attributes()
+        return m
+
+    @classmethod
+    def construct(cls: Type['Model'], _fields_set: Optional['SetStr'] = None, **values: Any) -> 'Model':
+        """
+        Creates a new model setting __dict__ and __fields_set__ from trusted or pre-validated data.
+        Default values are respected, but no other validation is performed.
+        Behaves as if `Config.extra = 'allow'` was set since it adds all passed values
+        """
+        m = cls.__new__(cls)
+        fields_values: Dict[str, Any] = {}
+        for name, field in cls.__fields__.items():
+            if name in values:
+                fields_values[name] = values[name]
+            elif not field.required:
+                fields_values[name] = field.get_default()
+        fields_values.update(values)
+        object_setattr(m, '__dict__', fields_values)
+        if _fields_set is None:
+            _fields_set = set(values.keys())
+        object_setattr(m, '__fields_set__', _fields_set)
+        m._init_private_attributes()
+        return m
+
+    def _copy_and_set_values(self: 'Model', values: 'DictStrAny', fields_set: 'SetStr', *, deep: bool) -> 'Model':
+        if deep:
+            # chances of having empty dict here are quite low for using smart_deepcopy
+            values = deepcopy(values)
+
+        cls = self.__class__
+        m = cls.__new__(cls)
+        object_setattr(m, '__dict__', values)
+        object_setattr(m, '__fields_set__', fields_set)
+        for name in self.__private_attributes__:
+            value = getattr(self, name, Undefined)
+            if value is not Undefined:
+                if deep:
+                    value = deepcopy(value)
+                object_setattr(m, name, value)
+
+        return m
+
+    def copy(
+        self: 'Model',
+        *,
+        include: Union['AbstractSetIntStr', 'MappingIntStrAny'] = None,
+        exclude: Union['AbstractSetIntStr', 'MappingIntStrAny'] = None,
+        update: 'DictStrAny' = None,
+        deep: bool = False,
+    ) -> 'Model':
+        """
+        Duplicate a model, optionally choose which fields to include, exclude and change.
+
+        :param include: fields to include in new model
+        :param exclude: fields to exclude from new model, as with values this takes precedence over include
+        :param update: values to change/add in the new model. Note: the data is not validated before creating
+            the new model: you should trust this data
+        :param deep: set to `True` to make a deep copy of the model
+        :return: new model instance
+        """
+
+        values = dict(
+            self._iter(to_dict=False, by_alias=False, include=include, exclude=exclude, exclude_unset=False),
+            **(update or {}),
+        )
+
+        # new `__fields_set__` can have unset optional fields with a set value in `update` kwarg
+        if update:
+            fields_set = self.__fields_set__ | update.keys()
+        else:
+            fields_set = set(self.__fields_set__)
+
+        return self._copy_and_set_values(values, fields_set, deep=deep)
+
+    @classmethod
+    def schema(cls, by_alias: bool = True, ref_template: str = default_ref_template) -> 'DictStrAny':
+        cached = cls.__schema_cache__.get((by_alias, ref_template))
+        if cached is not None:
+            return cached
+        s = model_schema(cls, by_alias=by_alias, ref_template=ref_template)
+        cls.__schema_cache__[(by_alias, ref_template)] = s
+        return s
+
+    @classmethod
+    def schema_json(
+        cls, *, by_alias: bool = True, ref_template: str = default_ref_template, **dumps_kwargs: Any
+    ) -> str:
+        from .json import pydantic_encoder
+
+        return cls.__config__.json_dumps(
+            cls.schema(by_alias=by_alias, ref_template=ref_template), default=pydantic_encoder, **dumps_kwargs
+        )
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls.validate
+
+    @classmethod
+    def validate(cls: Type['Model'], value: Any) -> 'Model':
+        if isinstance(value, cls):
+            if cls.__config__.copy_on_model_validation:
+                return value._copy_and_set_values(value.__dict__, value.__fields_set__, deep=True)
+            else:
+                return value
+
+        value = cls._enforce_dict_if_root(value)
+
+        if isinstance(value, dict):
+            return cls(**value)
+        elif cls.__config__.orm_mode:
+            return cls.from_orm(value)
+        else:
+            try:
+                value_as_dict = dict(value)
+            except (TypeError, ValueError) as e:
+                raise DictError() from e
+            return cls(**value_as_dict)
+
+    @classmethod
+    def _decompose_class(cls: Type['Model'], obj: Any) -> GetterDict:
+        if isinstance(obj, GetterDict):
+            return obj
+        return cls.__config__.getter_dict(obj)
+
+    @classmethod
+    @no_type_check
+    def _get_value(
+        cls,
+        v: Any,
+        to_dict: bool,
+        by_alias: bool,
+        include: Optional[Union['AbstractSetIntStr', 'MappingIntStrAny']],
+        exclude: Optional[Union['AbstractSetIntStr', 'MappingIntStrAny']],
+        exclude_unset: bool,
+        exclude_defaults: bool,
+        exclude_none: bool,
+    ) -> Any:
+
+        if isinstance(v, BaseModel):
+            if to_dict:
+                v_dict = v.dict(
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_defaults=exclude_defaults,
+                    include=include,
+                    exclude=exclude,
+                    exclude_none=exclude_none,
+                )
+                if ROOT_KEY in v_dict:
+                    return v_dict[ROOT_KEY]
+                return v_dict
+            else:
+                return v.copy(include=include, exclude=exclude)
+
+        value_exclude = ValueItems(v, exclude) if exclude else None
+        value_include = ValueItems(v, include) if include else None
+
+        if isinstance(v, dict):
+            return {
+                k_: cls._get_value(
+                    v_,
+                    to_dict=to_dict,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_defaults=exclude_defaults,
+                    include=value_include and value_include.for_element(k_),
+                    exclude=value_exclude and value_exclude.for_element(k_),
+                    exclude_none=exclude_none,
+                )
+                for k_, v_ in v.items()
+                if (not value_exclude or not value_exclude.is_excluded(k_))
+                and (not value_include or value_include.is_included(k_))
+            }
+
+        elif sequence_like(v):
+            seq_args = (
+                cls._get_value(
+                    v_,
+                    to_dict=to_dict,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_defaults=exclude_defaults,
+                    include=value_include and value_include.for_element(i),
+                    exclude=value_exclude and value_exclude.for_element(i),
+                    exclude_none=exclude_none,
+                )
+                for i, v_ in enumerate(v)
+                if (not value_exclude or not value_exclude.is_excluded(i))
+                and (not value_include or value_include.is_included(i))
+            )
+
+            return v.__class__(*seq_args) if is_namedtuple(v.__class__) else v.__class__(seq_args)
+
+        elif isinstance(v, Enum) and getattr(cls.Config, 'use_enum_values', False):
+            return v.value
+
+        else:
+            return v
+
+    @classmethod
+    def __try_update_forward_refs__(cls, **localns: Any) -> None:
+        """
+        Same as update_forward_refs but will not raise exception
+        when forward references are not defined.
+        """
+        update_model_forward_refs(cls, cls.__fields__.values(), cls.__config__.json_encoders, localns, (NameError,))
+
+    @classmethod
+    def update_forward_refs(cls, **localns: Any) -> None:
+        """
+        Try to update ForwardRefs on fields based on this Model, globalns and localns.
+        """
+        update_model_forward_refs(cls, cls.__fields__.values(), cls.__config__.json_encoders, localns)
+
+    def __iter__(self) -> 'TupleGenerator':
+        """
+        so `dict(model)` works
+        """
+        yield from self.__dict__.items()
+
+    def _iter(
+        self,
+        to_dict: bool = False,
+        by_alias: bool = False,
+        include: Union['AbstractSetIntStr', 'MappingIntStrAny'] = None,
+        exclude: Union['AbstractSetIntStr', 'MappingIntStrAny'] = None,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+    ) -> 'TupleGenerator':
+
+        # Merge field set excludes with explicit exclude parameter with explicit overriding field set options.
+        # The extra "is not None" guards are not logically necessary but optimizes performance for the simple case.
+        if exclude is not None or self.__exclude_fields__ is not None:
+            exclude = ValueItems.merge(self.__exclude_fields__, exclude)
+
+        if include is not None or self.__include_fields__ is not None:
+            include = ValueItems.merge(self.__include_fields__, include, intersect=True)
+
+        allowed_keys = self._calculate_keys(
+            include=include, exclude=exclude, exclude_unset=exclude_unset  # type: ignore
+        )
+        if allowed_keys is None and not (to_dict or by_alias or exclude_unset or exclude_defaults or exclude_none):
+            # huge boost for plain _iter()
+            yield from self.__dict__.items()
+            return
+
+        value_exclude = ValueItems(self, exclude) if exclude is not None else None
+        value_include = ValueItems(self, include) if include is not None else None
+
+        for field_key, v in self.__dict__.items():
+            if (allowed_keys is not None and field_key not in allowed_keys) or (exclude_none and v is None):
+                continue
+
+            if exclude_defaults:
+                model_field = self.__fields__.get(field_key)
+                if not getattr(model_field, 'required', True) and getattr(model_field, 'default', _missing) == v:
+                    continue
+
+            if by_alias and field_key in self.__fields__:
+                dict_key = self.__fields__[field_key].alias
+            else:
+                dict_key = field_key
+
+            if to_dict or value_include or value_exclude:
+                v = self._get_value(
+                    v,
+                    to_dict=to_dict,
+                    by_alias=by_alias,
+                    include=value_include and value_include.for_element(field_key),
+                    exclude=value_exclude and value_exclude.for_element(field_key),
+                    exclude_unset=exclude_unset,
+                    exclude_defaults=exclude_defaults,
+                    exclude_none=exclude_none,
+                )
+            yield dict_key, v
+
+    def _calculate_keys(
+        self,
+        include: Optional['MappingIntStrAny'],
+        exclude: Optional['MappingIntStrAny'],
+        exclude_unset: bool,
+        update: Optional['DictStrAny'] = None,
+    ) -> Optional[AbstractSet[str]]:
+        if include is None and exclude is None and exclude_unset is False:
+            return None
+
+        keys: AbstractSet[str]
+        if exclude_unset:
+            keys = self.__fields_set__.copy()
+        else:
+            keys = self.__dict__.keys()
+
+        if include is not None:
+            keys &= include.keys()
+
+        if update:
+            keys -= update.keys()
+
+        if exclude:
+            keys -= {k for k, v in exclude.items() if ValueItems.is_true(v)}
+
+        return keys
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, BaseModel):
+            return self.dict() == other.dict()
+        else:
+            return self.dict() == other
+
+    def __repr_args__(self) -> 'ReprArgs':
+        return [
+            (k, v) for k, v in self.__dict__.items() if k not in self.__fields__ or self.__fields__[k].field_info.repr
+        ]
+
+
+_is_base_model_class_defined = True
+
+
+@overload
+def create_model(
+    __model_name: str,
+    *,
+    __config__: Optional[Type[BaseConfig]] = None,
+    __base__: None = None,
+    __module__: str = __name__,
+    __validators__: Dict[str, 'AnyClassMethod'] = None,
+    __cls_kwargs__: Dict[str, Any] = None,
+    **field_definitions: Any,
+) -> Type['BaseModel']:
+    ...
+
+
+@overload
+def create_model(
+    __model_name: str,
+    *,
+    __config__: Optional[Type[BaseConfig]] = None,
+    __base__: Union[Type['Model'], Tuple[Type['Model'], ...]],
+    __module__: str = __name__,
+    __validators__: Dict[str, 'AnyClassMethod'] = None,
+    __cls_kwargs__: Dict[str, Any] = None,
+    **field_definitions: Any,
+) -> Type['Model']:
+    ...
+
+
+def create_model(
+    __model_name: str,
+    *,
+    __config__: Optional[Type[BaseConfig]] = None,
+    __base__: Union[None, Type['Model'], Tuple[Type['Model'], ...]] = None,
+    __module__: str = __name__,
+    __validators__: Dict[str, 'AnyClassMethod'] = None,
+    __cls_kwargs__: Dict[str, Any] = None,
+    **field_definitions: Any,
+) -> Type['Model']:
+    """
+    Dynamically create a model.
+    :param __model_name: name of the created model
+    :param __config__: config class to use for the new model
+    :param __base__: base class for the new model to inherit from
+    :param __module__: module of the created model
+    :param __validators__: a dict of method names and @validator class methods
+    :param __cls_kwargs__: a dict for class creation
+    :param field_definitions: fields of the model (or extra fields if a base is supplied)
+        in the format `<name>=(<type>, <default default>)` or `<name>=<default value>, e.g.
+        `foobar=(str, ...)` or `foobar=123`, or, for complex use-cases, in the format
+        `<name>=<FieldInfo>`, e.g. `foo=Field(default_factory=datetime.utcnow, alias='bar')`
+    """
+
+    if __base__ is not None:
+        if __config__ is not None:
+            raise ConfigError('to avoid confusion __config__ and __base__ cannot be used together')
+        if not isinstance(__base__, tuple):
+            __base__ = (__base__,)
+    else:
+        __base__ = (cast(Type['Model'], BaseModel),)
+
+    __cls_kwargs__ = __cls_kwargs__ or {}
+
+    fields = {}
+    annotations = {}
+
+    for f_name, f_def in field_definitions.items():
+        if not is_valid_field(f_name):
+            warnings.warn(f'fields may not start with an underscore, ignoring "{f_name}"', RuntimeWarning)
+        if isinstance(f_def, tuple):
+            try:
+                f_annotation, f_value = f_def
+            except ValueError as e:
+                raise ConfigError(
+                    'field definitions should either be a tuple of (<type>, <default>) or just a '
+                    'default value, unfortunately this means tuples as '
+                    'default values are not allowed'
+                ) from e
+        else:
+            f_annotation, f_value = None, f_def
+
+        if f_annotation:
+            annotations[f_name] = f_annotation
+        fields[f_name] = f_value
+
+    namespace: 'DictStrAny' = {'__annotations__': annotations, '__module__': __module__}
+    if __validators__:
+        namespace.update(__validators__)
+    namespace.update(fields)
+    if __config__:
+        namespace['Config'] = inherit_config(__config__, BaseConfig)
+
+    return type(__model_name, __base__, namespace, **__cls_kwargs__)
+
+
+_missing = object()
+
+
+def validate_model(  # noqa: C901 (ignore complexity)
+    model: Type[BaseModel], input_data: 'DictStrAny', cls: 'ModelOrDc' = None
+) -> Tuple['DictStrAny', 'SetStr', Optional[ValidationError]]:
+    """
+    validate data against a model.
+    """
+    values = {}
+    errors = []
+    # input_data names, possibly alias
+    names_used = set()
+    # field names, never aliases
+    fields_set = set()
+    config = model.__config__
+    check_extra = config.extra is not Extra.ignore
+    cls_ = cls or model
+
+    for validator in model.__pre_root_validators__:
+        try:
+            input_data = validator(cls_, input_data)
+        except (ValueError, TypeError, AssertionError) as exc:
+            return {}, set(), ValidationError([ErrorWrapper(exc, loc=ROOT_KEY)], cls_)
+
+    for name, field in model.__fields__.items():
+        value = input_data.get(field.alias, _missing)
+        using_name = False
+        if value is _missing and config.allow_population_by_field_name and field.alt_alias:
+            value = input_data.get(field.name, _missing)
+            using_name = True
+
+        if value is _missing:
+            if field.required:
+                errors.append(ErrorWrapper(MissingError(), loc=field.alias))
+                continue
+
+            value = field.get_default()
+
+            if not config.validate_all and not field.validate_always:
+                values[name] = value
+                continue
+        else:
+            fields_set.add(name)
+            if check_extra:
+                names_used.add(field.name if using_name else field.alias)
+
+        v_, errors_ = field.validate(value, values, loc=field.alias, cls=cls_)
+        if isinstance(errors_, ErrorWrapper):
+            errors.append(errors_)
+        elif isinstance(errors_, list):
+            errors.extend(errors_)
+        else:
+            values[name] = v_
+
+    if check_extra:
+        if isinstance(input_data, GetterDict):
+            extra = input_data.extra_keys() - names_used
+        else:
+            extra = input_data.keys() - names_used
+        if extra:
+            fields_set |= extra
+            if config.extra is Extra.allow:
+                for f in extra:
+                    values[f] = input_data[f]
+            else:
+                for f in sorted(extra):
+                    errors.append(ErrorWrapper(ExtraError(), loc=f))
+
+    for skip_on_failure, validator in model.__post_root_validators__:
+        if skip_on_failure and errors:
+            continue
+        try:
+            values = validator(cls_, values)
+        except (ValueError, TypeError, AssertionError) as exc:
+            errors.append(ErrorWrapper(exc, loc=ROOT_KEY))
+
+    if errors:
+        return values, fields_set, ValidationError(errors, cls_)
+    else:
+        return values, fields_set, None
diff --git a/myenv/lib/python3.9/site-packages/pydantic/mypy.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/mypy.cpython-39-darwin.so
new file mode 100755
index 0000000..4c06b6b
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/mypy.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/mypy.py b/myenv/lib/python3.9/site-packages/pydantic/mypy.py
new file mode 100644
index 0000000..d89fe04
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/mypy.py
@@ -0,0 +1,739 @@
+from configparser import ConfigParser
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Type as TypingType, Union
+
+from mypy.errorcodes import ErrorCode
+from mypy.nodes import (
+    ARG_NAMED,
+    ARG_NAMED_OPT,
+    ARG_OPT,
+    ARG_POS,
+    ARG_STAR2,
+    MDEF,
+    Argument,
+    AssignmentStmt,
+    Block,
+    CallExpr,
+    ClassDef,
+    Context,
+    Decorator,
+    EllipsisExpr,
+    FuncBase,
+    FuncDef,
+    JsonDict,
+    MemberExpr,
+    NameExpr,
+    PassStmt,
+    PlaceholderNode,
+    RefExpr,
+    StrExpr,
+    SymbolNode,
+    SymbolTableNode,
+    TempNode,
+    TypeInfo,
+    TypeVarExpr,
+    Var,
+)
+from mypy.options import Options
+from mypy.plugin import CheckerPluginInterface, ClassDefContext, MethodContext, Plugin, SemanticAnalyzerPluginInterface
+from mypy.plugins import dataclasses
+from mypy.semanal import set_callable_name  # type: ignore
+from mypy.server.trigger import make_wildcard_trigger
+from mypy.types import (
+    AnyType,
+    CallableType,
+    Instance,
+    NoneType,
+    Type,
+    TypeOfAny,
+    TypeType,
+    TypeVarType,
+    UnionType,
+    get_proper_type,
+)
+from mypy.typevars import fill_typevars
+from mypy.util import get_unique_redefinition_name
+from mypy.version import __version__ as mypy_version
+
+from pydantic.utils import is_valid_field
+
+try:
+    from mypy.types import TypeVarDef  # type: ignore[attr-defined]
+except ImportError:  # pragma: no cover
+    # Backward-compatible with TypeVarDef from Mypy 0.910.
+    from mypy.types import TypeVarType as TypeVarDef
+
+CONFIGFILE_KEY = 'pydantic-mypy'
+METADATA_KEY = 'pydantic-mypy-metadata'
+BASEMODEL_FULLNAME = 'pydantic.main.BaseModel'
+BASESETTINGS_FULLNAME = 'pydantic.env_settings.BaseSettings'
+FIELD_FULLNAME = 'pydantic.fields.Field'
+DATACLASS_FULLNAME = 'pydantic.dataclasses.dataclass'
+BUILTINS_NAME = 'builtins' if float(mypy_version) >= 0.930 else '__builtins__'
+
+
+def plugin(version: str) -> 'TypingType[Plugin]':
+    """
+    `version` is the mypy version string
+
+    We might want to use this to print a warning if the mypy version being used is
+    newer, or especially older, than we expect (or need).
+    """
+    return PydanticPlugin
+
+
+class PydanticPlugin(Plugin):
+    def __init__(self, options: Options) -> None:
+        self.plugin_config = PydanticPluginConfig(options)
+        super().__init__(options)
+
+    def get_base_class_hook(self, fullname: str) -> 'Optional[Callable[[ClassDefContext], None]]':
+        sym = self.lookup_fully_qualified(fullname)
+        if sym and isinstance(sym.node, TypeInfo):  # pragma: no branch
+            # No branching may occur if the mypy cache has not been cleared
+            if any(get_fullname(base) == BASEMODEL_FULLNAME for base in sym.node.mro):
+                return self._pydantic_model_class_maker_callback
+        return None
+
+    def get_method_hook(self, fullname: str) -> Optional[Callable[[MethodContext], Type]]:
+        if fullname.endswith('.from_orm'):
+            return from_orm_callback
+        return None
+
+    def get_class_decorator_hook(self, fullname: str) -> Optional[Callable[[ClassDefContext], None]]:
+        if fullname == DATACLASS_FULLNAME:
+            return dataclasses.dataclass_class_maker_callback
+        return None
+
+    def _pydantic_model_class_maker_callback(self, ctx: ClassDefContext) -> None:
+        transformer = PydanticModelTransformer(ctx, self.plugin_config)
+        transformer.transform()
+
+
+class PydanticPluginConfig:
+    __slots__ = ('init_forbid_extra', 'init_typed', 'warn_required_dynamic_aliases', 'warn_untyped_fields')
+    init_forbid_extra: bool
+    init_typed: bool
+    warn_required_dynamic_aliases: bool
+    warn_untyped_fields: bool
+
+    def __init__(self, options: Options) -> None:
+        if options.config_file is None:  # pragma: no cover
+            return
+
+        toml_config = parse_toml(options.config_file)
+        if toml_config is not None:
+            config = toml_config.get('tool', {}).get('pydantic-mypy', {})
+            for key in self.__slots__:
+                setting = config.get(key, False)
+                if not isinstance(setting, bool):
+                    raise ValueError(f'Configuration value must be a boolean for key: {key}')
+                setattr(self, key, setting)
+        else:
+            plugin_config = ConfigParser()
+            plugin_config.read(options.config_file)
+            for key in self.__slots__:
+                setting = plugin_config.getboolean(CONFIGFILE_KEY, key, fallback=False)
+                setattr(self, key, setting)
+
+
+def from_orm_callback(ctx: MethodContext) -> Type:
+    """
+    Raise an error if orm_mode is not enabled
+    """
+    model_type: Instance
+    if isinstance(ctx.type, CallableType) and isinstance(ctx.type.ret_type, Instance):
+        model_type = ctx.type.ret_type  # called on the class
+    elif isinstance(ctx.type, Instance):
+        model_type = ctx.type  # called on an instance (unusual, but still valid)
+    else:  # pragma: no cover
+        detail = f'ctx.type: {ctx.type} (of type {ctx.type.__class__.__name__})'
+        error_unexpected_behavior(detail, ctx.api, ctx.context)
+        return ctx.default_return_type
+    pydantic_metadata = model_type.type.metadata.get(METADATA_KEY)
+    if pydantic_metadata is None:
+        return ctx.default_return_type
+    orm_mode = pydantic_metadata.get('config', {}).get('orm_mode')
+    if orm_mode is not True:
+        error_from_orm(get_name(model_type.type), ctx.api, ctx.context)
+    return ctx.default_return_type
+
+
+class PydanticModelTransformer:
+    tracked_config_fields: Set[str] = {
+        'extra',
+        'allow_mutation',
+        'frozen',
+        'orm_mode',
+        'allow_population_by_field_name',
+        'alias_generator',
+    }
+
+    def __init__(self, ctx: ClassDefContext, plugin_config: PydanticPluginConfig) -> None:
+        self._ctx = ctx
+        self.plugin_config = plugin_config
+
+    def transform(self) -> None:
+        """
+        Configures the BaseModel subclass according to the plugin settings.
+
+        In particular:
+        * determines the model config and fields,
+        * adds a fields-aware signature for the initializer and construct methods
+        * freezes the class if allow_mutation = False or frozen = True
+        * stores the fields, config, and if the class is settings in the mypy metadata for access by subclasses
+        """
+        ctx = self._ctx
+        info = self._ctx.cls.info
+
+        config = self.collect_config()
+        fields = self.collect_fields(config)
+        for field in fields:
+            if info[field.name].type is None:
+                if not ctx.api.final_iteration:
+                    ctx.api.defer()
+        is_settings = any(get_fullname(base) == BASESETTINGS_FULLNAME for base in info.mro[:-1])
+        self.add_initializer(fields, config, is_settings)
+        self.add_construct_method(fields)
+        self.set_frozen(fields, frozen=config.allow_mutation is False or config.frozen is True)
+        info.metadata[METADATA_KEY] = {
+            'fields': {field.name: field.serialize() for field in fields},
+            'config': config.set_values_dict(),
+        }
+
+    def collect_config(self) -> 'ModelConfigData':
+        """
+        Collects the values of the config attributes that are used by the plugin, accounting for parent classes.
+        """
+        ctx = self._ctx
+        cls = ctx.cls
+        config = ModelConfigData()
+        for stmt in cls.defs.body:
+            if not isinstance(stmt, ClassDef):
+                continue
+            if stmt.name == 'Config':
+                for substmt in stmt.defs.body:
+                    if not isinstance(substmt, AssignmentStmt):
+                        continue
+                    config.update(self.get_config_update(substmt))
+                if (
+                    config.has_alias_generator
+                    and not config.allow_population_by_field_name
+                    and self.plugin_config.warn_required_dynamic_aliases
+                ):
+                    error_required_dynamic_aliases(ctx.api, stmt)
+        for info in cls.info.mro[1:]:  # 0 is the current class
+            if METADATA_KEY not in info.metadata:
+                continue
+
+            # Each class depends on the set of fields in its ancestors
+            ctx.api.add_plugin_dependency(make_wildcard_trigger(get_fullname(info)))
+            for name, value in info.metadata[METADATA_KEY]['config'].items():
+                config.setdefault(name, value)
+        return config
+
+    def collect_fields(self, model_config: 'ModelConfigData') -> List['PydanticModelField']:
+        """
+        Collects the fields for the model, accounting for parent classes
+        """
+        # First, collect fields belonging to the current class.
+        ctx = self._ctx
+        cls = self._ctx.cls
+        fields = []  # type: List[PydanticModelField]
+        known_fields = set()  # type: Set[str]
+        for stmt in cls.defs.body:
+            if not isinstance(stmt, AssignmentStmt):  # `and stmt.new_syntax` to require annotation
+                continue
+
+            lhs = stmt.lvalues[0]
+            if not isinstance(lhs, NameExpr) or not is_valid_field(lhs.name):
+                continue
+
+            if not stmt.new_syntax and self.plugin_config.warn_untyped_fields:
+                error_untyped_fields(ctx.api, stmt)
+
+            # if lhs.name == '__config__':  # BaseConfig not well handled; I'm not sure why yet
+            #     continue
+
+            sym = cls.info.names.get(lhs.name)
+            if sym is None:  # pragma: no cover
+                # This is likely due to a star import (see the dataclasses plugin for a more detailed explanation)
+                # This is the same logic used in the dataclasses plugin
+                continue
+
+            node = sym.node
+            if isinstance(node, PlaceholderNode):  # pragma: no cover
+                # See the PlaceholderNode docstring for more detail about how this can occur
+                # Basically, it is an edge case when dealing with complex import logic
+                # This is the same logic used in the dataclasses plugin
+                continue
+            if not isinstance(node, Var):  # pragma: no cover
+                # Don't know if this edge case still happens with the `is_valid_field` check above
+                # but better safe than sorry
+                continue
+
+            # x: ClassVar[int] is ignored by dataclasses.
+            if node.is_classvar:
+                continue
+
+            is_required = self.get_is_required(cls, stmt, lhs)
+            alias, has_dynamic_alias = self.get_alias_info(stmt)
+            if (
+                has_dynamic_alias
+                and not model_config.allow_population_by_field_name
+                and self.plugin_config.warn_required_dynamic_aliases
+            ):
+                error_required_dynamic_aliases(ctx.api, stmt)
+            fields.append(
+                PydanticModelField(
+                    name=lhs.name,
+                    is_required=is_required,
+                    alias=alias,
+                    has_dynamic_alias=has_dynamic_alias,
+                    line=stmt.line,
+                    column=stmt.column,
+                )
+            )
+            known_fields.add(lhs.name)
+        all_fields = fields.copy()
+        for info in cls.info.mro[1:]:  # 0 is the current class, -2 is BaseModel, -1 is object
+            if METADATA_KEY not in info.metadata:
+                continue
+
+            superclass_fields = []
+            # Each class depends on the set of fields in its ancestors
+            ctx.api.add_plugin_dependency(make_wildcard_trigger(get_fullname(info)))
+
+            for name, data in info.metadata[METADATA_KEY]['fields'].items():
+                if name not in known_fields:
+                    field = PydanticModelField.deserialize(info, data)
+                    known_fields.add(name)
+                    superclass_fields.append(field)
+                else:
+                    (field,) = [a for a in all_fields if a.name == name]
+                    all_fields.remove(field)
+                    superclass_fields.append(field)
+            all_fields = superclass_fields + all_fields
+        return all_fields
+
+    def add_initializer(self, fields: List['PydanticModelField'], config: 'ModelConfigData', is_settings: bool) -> None:
+        """
+        Adds a fields-aware `__init__` method to the class.
+
+        The added `__init__` will be annotated with types vs. all `Any` depending on the plugin settings.
+        """
+        ctx = self._ctx
+        typed = self.plugin_config.init_typed
+        use_alias = config.allow_population_by_field_name is not True
+        force_all_optional = is_settings or bool(
+            config.has_alias_generator and not config.allow_population_by_field_name
+        )
+        init_arguments = self.get_field_arguments(
+            fields, typed=typed, force_all_optional=force_all_optional, use_alias=use_alias
+        )
+        if not self.should_init_forbid_extra(fields, config):
+            var = Var('kwargs')
+            init_arguments.append(Argument(var, AnyType(TypeOfAny.explicit), None, ARG_STAR2))
+        add_method(ctx, '__init__', init_arguments, NoneType())
+
+    def add_construct_method(self, fields: List['PydanticModelField']) -> None:
+        """
+        Adds a fully typed `construct` classmethod to the class.
+
+        Similar to the fields-aware __init__ method, but always uses the field names (not aliases),
+        and does not treat settings fields as optional.
+        """
+        ctx = self._ctx
+        set_str = ctx.api.named_type(f'{BUILTINS_NAME}.set', [ctx.api.named_type(f'{BUILTINS_NAME}.str')])
+        optional_set_str = UnionType([set_str, NoneType()])
+        fields_set_argument = Argument(Var('_fields_set', optional_set_str), optional_set_str, None, ARG_OPT)
+        construct_arguments = self.get_field_arguments(fields, typed=True, force_all_optional=False, use_alias=False)
+        construct_arguments = [fields_set_argument] + construct_arguments
+
+        obj_type = ctx.api.named_type(f'{BUILTINS_NAME}.object')
+        self_tvar_name = '_PydanticBaseModel'  # Make sure it does not conflict with other names in the class
+        tvar_fullname = ctx.cls.fullname + '.' + self_tvar_name
+        tvd = TypeVarDef(self_tvar_name, tvar_fullname, -1, [], obj_type)
+        self_tvar_expr = TypeVarExpr(self_tvar_name, tvar_fullname, [], obj_type)
+        ctx.cls.info.names[self_tvar_name] = SymbolTableNode(MDEF, self_tvar_expr)
+
+        # Backward-compatible with TypeVarDef from Mypy 0.910.
+        if isinstance(tvd, TypeVarType):
+            self_type = tvd
+        else:
+            self_type = TypeVarType(tvd)  # type: ignore[call-arg]
+
+        add_method(
+            ctx,
+            'construct',
+            construct_arguments,
+            return_type=self_type,
+            self_type=self_type,
+            tvar_def=tvd,
+            is_classmethod=True,
+        )
+
+    def set_frozen(self, fields: List['PydanticModelField'], frozen: bool) -> None:
+        """
+        Marks all fields as properties so that attempts to set them trigger mypy errors.
+
+        This is the same approach used by the attrs and dataclasses plugins.
+        """
+        info = self._ctx.cls.info
+        for field in fields:
+            sym_node = info.names.get(field.name)
+            if sym_node is not None:
+                var = sym_node.node
+                assert isinstance(var, Var)
+                var.is_property = frozen
+            else:
+                var = field.to_var(info, use_alias=False)
+                var.info = info
+                var.is_property = frozen
+                var._fullname = get_fullname(info) + '.' + get_name(var)
+                info.names[get_name(var)] = SymbolTableNode(MDEF, var)
+
+    def get_config_update(self, substmt: AssignmentStmt) -> Optional['ModelConfigData']:
+        """
+        Determines the config update due to a single statement in the Config class definition.
+
+        Warns if a tracked config attribute is set to a value the plugin doesn't know how to interpret (e.g., an int)
+        """
+        lhs = substmt.lvalues[0]
+        if not (isinstance(lhs, NameExpr) and lhs.name in self.tracked_config_fields):
+            return None
+        if lhs.name == 'extra':
+            if isinstance(substmt.rvalue, StrExpr):
+                forbid_extra = substmt.rvalue.value == 'forbid'
+            elif isinstance(substmt.rvalue, MemberExpr):
+                forbid_extra = substmt.rvalue.name == 'forbid'
+            else:
+                error_invalid_config_value(lhs.name, self._ctx.api, substmt)
+                return None
+            return ModelConfigData(forbid_extra=forbid_extra)
+        if lhs.name == 'alias_generator':
+            has_alias_generator = True
+            if isinstance(substmt.rvalue, NameExpr) and substmt.rvalue.fullname == 'builtins.None':
+                has_alias_generator = False
+            return ModelConfigData(has_alias_generator=has_alias_generator)
+        if isinstance(substmt.rvalue, NameExpr) and substmt.rvalue.fullname in ('builtins.True', 'builtins.False'):
+            return ModelConfigData(**{lhs.name: substmt.rvalue.fullname == 'builtins.True'})
+        error_invalid_config_value(lhs.name, self._ctx.api, substmt)
+        return None
+
+    @staticmethod
+    def get_is_required(cls: ClassDef, stmt: AssignmentStmt, lhs: NameExpr) -> bool:
+        """
+        Returns a boolean indicating whether the field defined in `stmt` is a required field.
+        """
+        expr = stmt.rvalue
+        if isinstance(expr, TempNode):
+            # TempNode means annotation-only, so only non-required if Optional
+            value_type = get_proper_type(cls.info[lhs.name].type)
+            if isinstance(value_type, UnionType) and any(isinstance(item, NoneType) for item in value_type.items):
+                # Annotated as Optional, or otherwise having NoneType in the union
+                return False
+            return True
+        if isinstance(expr, CallExpr) and isinstance(expr.callee, RefExpr) and expr.callee.fullname == FIELD_FULLNAME:
+            # The "default value" is a call to `Field`; at this point, the field is
+            # only required if default is Ellipsis (i.e., `field_name: Annotation = Field(...)`)
+            return len(expr.args) > 0 and expr.args[0].__class__ is EllipsisExpr
+        # Only required if the "default value" is Ellipsis (i.e., `field_name: Annotation = ...`)
+        return isinstance(expr, EllipsisExpr)
+
+    @staticmethod
+    def get_alias_info(stmt: AssignmentStmt) -> Tuple[Optional[str], bool]:
+        """
+        Returns a pair (alias, has_dynamic_alias), extracted from the declaration of the field defined in `stmt`.
+
+        `has_dynamic_alias` is True if and only if an alias is provided, but not as a string literal.
+        If `has_dynamic_alias` is True, `alias` will be None.
+        """
+        expr = stmt.rvalue
+        if isinstance(expr, TempNode):
+            # TempNode means annotation-only
+            return None, False
+
+        if not (
+            isinstance(expr, CallExpr) and isinstance(expr.callee, RefExpr) and expr.callee.fullname == FIELD_FULLNAME
+        ):
+            # Assigned value is not a call to pydantic.fields.Field
+            return None, False
+
+        for i, arg_name in enumerate(expr.arg_names):
+            if arg_name != 'alias':
+                continue
+            arg = expr.args[i]
+            if isinstance(arg, StrExpr):
+                return arg.value, False
+            else:
+                return None, True
+        return None, False
+
+    def get_field_arguments(
+        self, fields: List['PydanticModelField'], typed: bool, force_all_optional: bool, use_alias: bool
+    ) -> List[Argument]:
+        """
+        Helper function used during the construction of the `__init__` and `construct` method signatures.
+
+        Returns a list of mypy Argument instances for use in the generated signatures.
+        """
+        info = self._ctx.cls.info
+        arguments = [
+            field.to_argument(info, typed=typed, force_optional=force_all_optional, use_alias=use_alias)
+            for field in fields
+            if not (use_alias and field.has_dynamic_alias)
+        ]
+        return arguments
+
+    def should_init_forbid_extra(self, fields: List['PydanticModelField'], config: 'ModelConfigData') -> bool:
+        """
+        Indicates whether the generated `__init__` should get a `**kwargs` at the end of its signature
+
+        We disallow arbitrary kwargs if the extra config setting is "forbid", or if the plugin config says to,
+        *unless* a required dynamic alias is present (since then we can't determine a valid signature).
+        """
+        if not config.allow_population_by_field_name:
+            if self.is_dynamic_alias_present(fields, bool(config.has_alias_generator)):
+                return False
+        if config.forbid_extra:
+            return True
+        return self.plugin_config.init_forbid_extra
+
+    @staticmethod
+    def is_dynamic_alias_present(fields: List['PydanticModelField'], has_alias_generator: bool) -> bool:
+        """
+        Returns whether any fields on the model have a "dynamic alias", i.e., an alias that cannot be
+        determined during static analysis.
+        """
+        for field in fields:
+            if field.has_dynamic_alias:
+                return True
+        if has_alias_generator:
+            for field in fields:
+                if field.alias is None:
+                    return True
+        return False
+
+
+class PydanticModelField:
+    def __init__(
+        self, name: str, is_required: bool, alias: Optional[str], has_dynamic_alias: bool, line: int, column: int
+    ):
+        self.name = name
+        self.is_required = is_required
+        self.alias = alias
+        self.has_dynamic_alias = has_dynamic_alias
+        self.line = line
+        self.column = column
+
+    def to_var(self, info: TypeInfo, use_alias: bool) -> Var:
+        name = self.name
+        if use_alias and self.alias is not None:
+            name = self.alias
+        return Var(name, info[self.name].type)
+
+    def to_argument(self, info: TypeInfo, typed: bool, force_optional: bool, use_alias: bool) -> Argument:
+        if typed and info[self.name].type is not None:
+            type_annotation = info[self.name].type
+        else:
+            type_annotation = AnyType(TypeOfAny.explicit)
+        return Argument(
+            variable=self.to_var(info, use_alias),
+            type_annotation=type_annotation,
+            initializer=None,
+            kind=ARG_NAMED_OPT if force_optional or not self.is_required else ARG_NAMED,
+        )
+
+    def serialize(self) -> JsonDict:
+        return self.__dict__
+
+    @classmethod
+    def deserialize(cls, info: TypeInfo, data: JsonDict) -> 'PydanticModelField':
+        return cls(**data)
+
+
+class ModelConfigData:
+    def __init__(
+        self,
+        forbid_extra: Optional[bool] = None,
+        allow_mutation: Optional[bool] = None,
+        frozen: Optional[bool] = None,
+        orm_mode: Optional[bool] = None,
+        allow_population_by_field_name: Optional[bool] = None,
+        has_alias_generator: Optional[bool] = None,
+    ):
+        self.forbid_extra = forbid_extra
+        self.allow_mutation = allow_mutation
+        self.frozen = frozen
+        self.orm_mode = orm_mode
+        self.allow_population_by_field_name = allow_population_by_field_name
+        self.has_alias_generator = has_alias_generator
+
+    def set_values_dict(self) -> Dict[str, Any]:
+        return {k: v for k, v in self.__dict__.items() if v is not None}
+
+    def update(self, config: Optional['ModelConfigData']) -> None:
+        if config is None:
+            return
+        for k, v in config.set_values_dict().items():
+            setattr(self, k, v)
+
+    def setdefault(self, key: str, value: Any) -> None:
+        if getattr(self, key) is None:
+            setattr(self, key, value)
+
+
+ERROR_ORM = ErrorCode('pydantic-orm', 'Invalid from_orm call', 'Pydantic')
+ERROR_CONFIG = ErrorCode('pydantic-config', 'Invalid config value', 'Pydantic')
+ERROR_ALIAS = ErrorCode('pydantic-alias', 'Dynamic alias disallowed', 'Pydantic')
+ERROR_UNEXPECTED = ErrorCode('pydantic-unexpected', 'Unexpected behavior', 'Pydantic')
+ERROR_UNTYPED = ErrorCode('pydantic-field', 'Untyped field disallowed', 'Pydantic')
+
+
+def error_from_orm(model_name: str, api: CheckerPluginInterface, context: Context) -> None:
+    api.fail(f'"{model_name}" does not have orm_mode=True', context, code=ERROR_ORM)
+
+
+def error_invalid_config_value(name: str, api: SemanticAnalyzerPluginInterface, context: Context) -> None:
+    api.fail(f'Invalid value for "Config.{name}"', context, code=ERROR_CONFIG)
+
+
+def error_required_dynamic_aliases(api: SemanticAnalyzerPluginInterface, context: Context) -> None:
+    api.fail('Required dynamic aliases disallowed', context, code=ERROR_ALIAS)
+
+
+def error_unexpected_behavior(detail: str, api: CheckerPluginInterface, context: Context) -> None:  # pragma: no cover
+    # Can't think of a good way to test this, but I confirmed it renders as desired by adding to a non-error path
+    link = 'https://github.com/samuelcolvin/pydantic/issues/new/choose'
+    full_message = f'The pydantic mypy plugin ran into unexpected behavior: {detail}\n'
+    full_message += f'Please consider reporting this bug at {link} so we can try to fix it!'
+    api.fail(full_message, context, code=ERROR_UNEXPECTED)
+
+
+def error_untyped_fields(api: SemanticAnalyzerPluginInterface, context: Context) -> None:
+    api.fail('Untyped fields disallowed', context, code=ERROR_UNTYPED)
+
+
+def add_method(
+    ctx: ClassDefContext,
+    name: str,
+    args: List[Argument],
+    return_type: Type,
+    self_type: Optional[Type] = None,
+    tvar_def: Optional[TypeVarDef] = None,
+    is_classmethod: bool = False,
+    is_new: bool = False,
+    # is_staticmethod: bool = False,
+) -> None:
+    """
+    Adds a new method to a class.
+
+    This can be dropped if/when https://github.com/python/mypy/issues/7301 is merged
+    """
+    info = ctx.cls.info
+
+    # First remove any previously generated methods with the same name
+    # to avoid clashes and problems in the semantic analyzer.
+    if name in info.names:
+        sym = info.names[name]
+        if sym.plugin_generated and isinstance(sym.node, FuncDef):
+            ctx.cls.defs.body.remove(sym.node)
+
+    self_type = self_type or fill_typevars(info)
+    if is_classmethod or is_new:
+        first = [Argument(Var('_cls'), TypeType.make_normalized(self_type), None, ARG_POS)]
+    # elif is_staticmethod:
+    #     first = []
+    else:
+        self_type = self_type or fill_typevars(info)
+        first = [Argument(Var('__pydantic_self__'), self_type, None, ARG_POS)]
+    args = first + args
+    arg_types, arg_names, arg_kinds = [], [], []
+    for arg in args:
+        assert arg.type_annotation, 'All arguments must be fully typed.'
+        arg_types.append(arg.type_annotation)
+        arg_names.append(get_name(arg.variable))
+        arg_kinds.append(arg.kind)
+
+    function_type = ctx.api.named_type(f'{BUILTINS_NAME}.function')
+    signature = CallableType(arg_types, arg_kinds, arg_names, return_type, function_type)
+    if tvar_def:
+        signature.variables = [tvar_def]
+
+    func = FuncDef(name, args, Block([PassStmt()]))
+    func.info = info
+    func.type = set_callable_name(signature, func)
+    func.is_class = is_classmethod
+    # func.is_static = is_staticmethod
+    func._fullname = get_fullname(info) + '.' + name
+    func.line = info.line
+
+    # NOTE: we would like the plugin generated node to dominate, but we still
+    # need to keep any existing definitions so they get semantically analyzed.
+    if name in info.names:
+        # Get a nice unique name instead.
+        r_name = get_unique_redefinition_name(name, info.names)
+        info.names[r_name] = info.names[name]
+
+    if is_classmethod:  # or is_staticmethod:
+        func.is_decorated = True
+        v = Var(name, func.type)
+        v.info = info
+        v._fullname = func._fullname
+        # if is_classmethod:
+        v.is_classmethod = True
+        dec = Decorator(func, [NameExpr('classmethod')], v)
+        # else:
+        #     v.is_staticmethod = True
+        #     dec = Decorator(func, [NameExpr('staticmethod')], v)
+
+        dec.line = info.line
+        sym = SymbolTableNode(MDEF, dec)
+    else:
+        sym = SymbolTableNode(MDEF, func)
+    sym.plugin_generated = True
+
+    info.names[name] = sym
+    info.defn.defs.body.append(func)
+
+
+def get_fullname(x: Union[FuncBase, SymbolNode]) -> str:
+    """
+    Used for compatibility with mypy 0.740; can be dropped once support for 0.740 is dropped.
+    """
+    fn = x.fullname
+    if callable(fn):  # pragma: no cover
+        return fn()
+    return fn
+
+
+def get_name(x: Union[FuncBase, SymbolNode]) -> str:
+    """
+    Used for compatibility with mypy 0.740; can be dropped once support for 0.740 is dropped.
+    """
+    fn = x.name
+    if callable(fn):  # pragma: no cover
+        return fn()
+    return fn
+
+
+def parse_toml(config_file: str) -> Optional[Dict[str, Any]]:
+    if not config_file.endswith('.toml'):
+        return None
+
+    read_mode = 'rb'
+    try:
+        import tomli as toml_
+    except ImportError:
+        # older versions of mypy have toml as a dependency, not tomli
+        read_mode = 'r'
+        try:
+            import toml as toml_  # type: ignore[no-redef]
+        except ImportError:  # pragma: no cover
+            import warnings
+
+            warnings.warn('No TOML parser installed, cannot read configuration from `pyproject.toml`.')
+            return None
+
+    with open(config_file, read_mode) as rf:
+        return toml_.load(rf)  # type: ignore[arg-type]
diff --git a/myenv/lib/python3.9/site-packages/pydantic/networks.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/networks.cpython-39-darwin.so
new file mode 100755
index 0000000..04bf6e0
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/networks.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/networks.py b/myenv/lib/python3.9/site-packages/pydantic/networks.py
new file mode 100644
index 0000000..0626d2c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/networks.py
@@ -0,0 +1,580 @@
+import re
+from ipaddress import (
+    IPv4Address,
+    IPv4Interface,
+    IPv4Network,
+    IPv6Address,
+    IPv6Interface,
+    IPv6Network,
+    _BaseAddress,
+    _BaseNetwork,
+)
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Collection,
+    Dict,
+    Generator,
+    Optional,
+    Pattern,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    cast,
+    no_type_check,
+)
+
+from . import errors
+from .utils import Representation, update_not_none
+from .validators import constr_length_validator, str_validator
+
+if TYPE_CHECKING:
+    import email_validator
+    from typing_extensions import TypedDict
+
+    from .config import BaseConfig
+    from .fields import ModelField
+    from .typing import AnyCallable
+
+    CallableGenerator = Generator[AnyCallable, None, None]
+
+    class Parts(TypedDict, total=False):
+        scheme: str
+        user: Optional[str]
+        password: Optional[str]
+        ipv4: Optional[str]
+        ipv6: Optional[str]
+        domain: Optional[str]
+        port: Optional[str]
+        path: Optional[str]
+        query: Optional[str]
+        fragment: Optional[str]
+
+else:
+    email_validator = None
+
+    class Parts(dict):
+        pass
+
+
+NetworkType = Union[str, bytes, int, Tuple[Union[str, bytes, int], Union[str, int]]]
+
+__all__ = [
+    'AnyUrl',
+    'AnyHttpUrl',
+    'FileUrl',
+    'HttpUrl',
+    'stricturl',
+    'EmailStr',
+    'NameEmail',
+    'IPvAnyAddress',
+    'IPvAnyInterface',
+    'IPvAnyNetwork',
+    'PostgresDsn',
+    'AmqpDsn',
+    'RedisDsn',
+    'KafkaDsn',
+    'validate_email',
+]
+
+_url_regex_cache = None
+_ascii_domain_regex_cache = None
+_int_domain_regex_cache = None
+
+
+def url_regex() -> Pattern[str]:
+    global _url_regex_cache
+    if _url_regex_cache is None:
+        _url_regex_cache = re.compile(
+            r'(?:(?P<scheme>[a-z][a-z0-9+\-.]+)://)?'  # scheme https://tools.ietf.org/html/rfc3986#appendix-A
+            r'(?:(?P<user>[^\s:/]*)(?::(?P<password>[^\s/]*))?@)?'  # user info
+            r'(?:'
+            r'(?P<ipv4>(?:\d{1,3}\.){3}\d{1,3})(?=$|[/:#?])|'  # ipv4
+            r'(?P<ipv6>\[[A-F0-9]*:[A-F0-9:]+\])(?=$|[/:#?])|'  # ipv6
+            r'(?P<domain>[^\s/:?#]+)'  # domain, validation occurs later
+            r')?'
+            r'(?::(?P<port>\d+))?'  # port
+            r'(?P<path>/[^\s?#]*)?'  # path
+            r'(?:\?(?P<query>[^\s#]*))?'  # query
+            r'(?:#(?P<fragment>[^\s#]*))?',  # fragment
+            re.IGNORECASE,
+        )
+    return _url_regex_cache
+
+
+def ascii_domain_regex() -> Pattern[str]:
+    global _ascii_domain_regex_cache
+    if _ascii_domain_regex_cache is None:
+        ascii_chunk = r'[_0-9a-z](?:[-_0-9a-z]{0,61}[_0-9a-z])?'
+        ascii_domain_ending = r'(?P<tld>\.[a-z]{2,63})?\.?'
+        _ascii_domain_regex_cache = re.compile(
+            fr'(?:{ascii_chunk}\.)*?{ascii_chunk}{ascii_domain_ending}', re.IGNORECASE
+        )
+    return _ascii_domain_regex_cache
+
+
+def int_domain_regex() -> Pattern[str]:
+    global _int_domain_regex_cache
+    if _int_domain_regex_cache is None:
+        int_chunk = r'[_0-9a-\U00040000](?:[-_0-9a-\U00040000]{0,61}[_0-9a-\U00040000])?'
+        int_domain_ending = r'(?P<tld>(\.[^\W\d_]{2,63})|(\.(?:xn--)[_0-9a-z-]{2,63}))?\.?'
+        _int_domain_regex_cache = re.compile(fr'(?:{int_chunk}\.)*?{int_chunk}{int_domain_ending}', re.IGNORECASE)
+    return _int_domain_regex_cache
+
+
+class AnyUrl(str):
+    strip_whitespace = True
+    min_length = 1
+    max_length = 2**16
+    allowed_schemes: Optional[Collection[str]] = None
+    tld_required: bool = False
+    user_required: bool = False
+    host_required: bool = True
+    hidden_parts: Set[str] = set()
+
+    __slots__ = ('scheme', 'user', 'password', 'host', 'tld', 'host_type', 'port', 'path', 'query', 'fragment')
+
+    @no_type_check
+    def __new__(cls, url: Optional[str], **kwargs) -> object:
+        return str.__new__(cls, cls.build(**kwargs) if url is None else url)
+
+    def __init__(
+        self,
+        url: str,
+        *,
+        scheme: str,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        host: Optional[str] = None,
+        tld: Optional[str] = None,
+        host_type: str = 'domain',
+        port: Optional[str] = None,
+        path: Optional[str] = None,
+        query: Optional[str] = None,
+        fragment: Optional[str] = None,
+    ) -> None:
+        str.__init__(url)
+        self.scheme = scheme
+        self.user = user
+        self.password = password
+        self.host = host
+        self.tld = tld
+        self.host_type = host_type
+        self.port = port
+        self.path = path
+        self.query = query
+        self.fragment = fragment
+
+    @classmethod
+    def build(
+        cls,
+        *,
+        scheme: str,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        host: str,
+        port: Optional[str] = None,
+        path: Optional[str] = None,
+        query: Optional[str] = None,
+        fragment: Optional[str] = None,
+        **_kwargs: str,
+    ) -> str:
+        parts = Parts(
+            scheme=scheme,
+            user=user,
+            password=password,
+            host=host,
+            port=port,
+            path=path,
+            query=query,
+            fragment=fragment,
+            **_kwargs,  # type: ignore[misc]
+        )
+
+        url = scheme + '://'
+        if user:
+            url += user
+        if password:
+            url += ':' + password
+        if user or password:
+            url += '@'
+        url += host
+        if port and ('port' not in cls.hidden_parts or cls.get_default_parts(parts).get('port') != port):
+            url += ':' + port
+        if path:
+            url += path
+        if query:
+            url += '?' + query
+        if fragment:
+            url += '#' + fragment
+        return url
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        update_not_none(field_schema, minLength=cls.min_length, maxLength=cls.max_length, format='uri')
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value: Any, field: 'ModelField', config: 'BaseConfig') -> 'AnyUrl':
+        if value.__class__ == cls:
+            return value
+        value = str_validator(value)
+        if cls.strip_whitespace:
+            value = value.strip()
+        url: str = cast(str, constr_length_validator(value, field, config))
+
+        m = url_regex().match(url)
+        # the regex should always match, if it doesn't please report with details of the URL tried
+        assert m, 'URL regex failed unexpectedly'
+
+        original_parts = cast('Parts', m.groupdict())
+        parts = cls.apply_default_parts(original_parts)
+        parts = cls.validate_parts(parts)
+
+        host, tld, host_type, rebuild = cls.validate_host(parts)
+
+        if m.end() != len(url):
+            raise errors.UrlExtraError(extra=url[m.end() :])
+
+        return cls(
+            None if rebuild else url,
+            scheme=parts['scheme'],
+            user=parts['user'],
+            password=parts['password'],
+            host=host,
+            tld=tld,
+            host_type=host_type,
+            port=parts['port'],
+            path=parts['path'],
+            query=parts['query'],
+            fragment=parts['fragment'],
+        )
+
+    @classmethod
+    def validate_parts(cls, parts: 'Parts') -> 'Parts':
+        """
+        A method used to validate parts of an URL.
+        Could be overridden to set default values for parts if missing
+        """
+        scheme = parts['scheme']
+        if scheme is None:
+            raise errors.UrlSchemeError()
+
+        if cls.allowed_schemes and scheme.lower() not in cls.allowed_schemes:
+            raise errors.UrlSchemePermittedError(set(cls.allowed_schemes))
+
+        port = parts['port']
+        if port is not None and int(port) > 65_535:
+            raise errors.UrlPortError()
+
+        user = parts['user']
+        if cls.user_required and user is None:
+            raise errors.UrlUserInfoError()
+
+        return parts
+
+    @classmethod
+    def validate_host(cls, parts: 'Parts') -> Tuple[str, Optional[str], str, bool]:
+        host, tld, host_type, rebuild = None, None, None, False
+        for f in ('domain', 'ipv4', 'ipv6'):
+            host = parts[f]  # type: ignore[literal-required]
+            if host:
+                host_type = f
+                break
+
+        if host is None:
+            if cls.host_required:
+                raise errors.UrlHostError()
+        elif host_type == 'domain':
+            is_international = False
+            d = ascii_domain_regex().fullmatch(host)
+            if d is None:
+                d = int_domain_regex().fullmatch(host)
+                if d is None:
+                    raise errors.UrlHostError()
+                is_international = True
+
+            tld = d.group('tld')
+            if tld is None and not is_international:
+                d = int_domain_regex().fullmatch(host)
+                assert d is not None
+                tld = d.group('tld')
+                is_international = True
+
+            if tld is not None:
+                tld = tld[1:]
+            elif cls.tld_required:
+                raise errors.UrlHostTldError()
+
+            if is_international:
+                host_type = 'int_domain'
+                rebuild = True
+                host = host.encode('idna').decode('ascii')
+                if tld is not None:
+                    tld = tld.encode('idna').decode('ascii')
+
+        return host, tld, host_type, rebuild  # type: ignore
+
+    @staticmethod
+    def get_default_parts(parts: 'Parts') -> 'Parts':
+        return {}
+
+    @classmethod
+    def apply_default_parts(cls, parts: 'Parts') -> 'Parts':
+        for key, value in cls.get_default_parts(parts).items():
+            if not parts[key]:  # type: ignore[literal-required]
+                parts[key] = value  # type: ignore[literal-required]
+        return parts
+
+    def __repr__(self) -> str:
+        extra = ', '.join(f'{n}={getattr(self, n)!r}' for n in self.__slots__ if getattr(self, n) is not None)
+        return f'{self.__class__.__name__}({super().__repr__()}, {extra})'
+
+
+class AnyHttpUrl(AnyUrl):
+    allowed_schemes = {'http', 'https'}
+
+
+class HttpUrl(AnyHttpUrl):
+    tld_required = True
+    # https://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers
+    max_length = 2083
+    hidden_parts = {'port'}
+
+    @staticmethod
+    def get_default_parts(parts: 'Parts') -> 'Parts':
+        return {'port': '80' if parts['scheme'] == 'http' else '443'}
+
+
+class FileUrl(AnyUrl):
+    allowed_schemes = {'file'}
+    host_required = False
+
+
+class PostgresDsn(AnyUrl):
+    allowed_schemes = {
+        'postgres',
+        'postgresql',
+        'postgresql+asyncpg',
+        'postgresql+pg8000',
+        'postgresql+psycopg2',
+        'postgresql+psycopg2cffi',
+        'postgresql+py-postgresql',
+        'postgresql+pygresql',
+    }
+    user_required = True
+
+
+class AmqpDsn(AnyUrl):
+    allowed_schemes = {'amqp', 'amqps'}
+    host_required = False
+
+
+class RedisDsn(AnyUrl):
+    allowed_schemes = {'redis', 'rediss'}
+    host_required = False
+
+    @staticmethod
+    def get_default_parts(parts: 'Parts') -> 'Parts':
+        return {
+            'domain': 'localhost' if not (parts['ipv4'] or parts['ipv6']) else '',
+            'port': '6379',
+            'path': '/0',
+        }
+
+
+class KafkaDsn(AnyUrl):
+    allowed_schemes = {'kafka'}
+
+    @staticmethod
+    def get_default_parts(parts: 'Parts') -> 'Parts':
+        return {
+            'domain': 'localhost',
+            'port': '9092',
+        }
+
+
+def stricturl(
+    *,
+    strip_whitespace: bool = True,
+    min_length: int = 1,
+    max_length: int = 2**16,
+    tld_required: bool = True,
+    host_required: bool = True,
+    allowed_schemes: Optional[Collection[str]] = None,
+) -> Type[AnyUrl]:
+    # use kwargs then define conf in a dict to aid with IDE type hinting
+    namespace = dict(
+        strip_whitespace=strip_whitespace,
+        min_length=min_length,
+        max_length=max_length,
+        tld_required=tld_required,
+        host_required=host_required,
+        allowed_schemes=allowed_schemes,
+    )
+    return type('UrlValue', (AnyUrl,), namespace)
+
+
+def import_email_validator() -> None:
+    global email_validator
+    try:
+        import email_validator
+    except ImportError as e:
+        raise ImportError('email-validator is not installed, run `pip install pydantic[email]`') from e
+
+
+class EmailStr(str):
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        field_schema.update(type='string', format='email')
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        # included here and below so the error happens straight away
+        import_email_validator()
+
+        yield str_validator
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value: Union[str]) -> str:
+        return validate_email(value)[1]
+
+
+class NameEmail(Representation):
+    __slots__ = 'name', 'email'
+
+    def __init__(self, name: str, email: str):
+        self.name = name
+        self.email = email
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, NameEmail) and (self.name, self.email) == (other.name, other.email)
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        field_schema.update(type='string', format='name-email')
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        import_email_validator()
+
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value: Any) -> 'NameEmail':
+        if value.__class__ == cls:
+            return value
+        value = str_validator(value)
+        return cls(*validate_email(value))
+
+    def __str__(self) -> str:
+        return f'{self.name} <{self.email}>'
+
+
+class IPvAnyAddress(_BaseAddress):
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        field_schema.update(type='string', format='ipvanyaddress')
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value: Union[str, bytes, int]) -> Union[IPv4Address, IPv6Address]:
+        try:
+            return IPv4Address(value)
+        except ValueError:
+            pass
+
+        try:
+            return IPv6Address(value)
+        except ValueError:
+            raise errors.IPvAnyAddressError()
+
+
+class IPvAnyInterface(_BaseAddress):
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        field_schema.update(type='string', format='ipvanyinterface')
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value: NetworkType) -> Union[IPv4Interface, IPv6Interface]:
+        try:
+            return IPv4Interface(value)
+        except ValueError:
+            pass
+
+        try:
+            return IPv6Interface(value)
+        except ValueError:
+            raise errors.IPvAnyInterfaceError()
+
+
+class IPvAnyNetwork(_BaseNetwork):  # type: ignore
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        field_schema.update(type='string', format='ipvanynetwork')
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value: NetworkType) -> Union[IPv4Network, IPv6Network]:
+        # Assume IP Network is defined with a default value for ``strict`` argument.
+        # Define your own class if you want to specify network address check strictness.
+        try:
+            return IPv4Network(value)
+        except ValueError:
+            pass
+
+        try:
+            return IPv6Network(value)
+        except ValueError:
+            raise errors.IPvAnyNetworkError()
+
+
+pretty_email_regex = re.compile(r'([\w ]*?) *<(.*)> *')
+
+
+def validate_email(value: Union[str]) -> Tuple[str, str]:
+    """
+    Brutally simple email address validation. Note unlike most email address validation
+    * raw ip address (literal) domain parts are not allowed.
+    * "John Doe <local_part@domain.com>" style "pretty" email addresses are processed
+    * the local part check is extremely basic. This raises the possibility of unicode spoofing, but no better
+        solution is really possible.
+    * spaces are striped from the beginning and end of addresses but no error is raised
+
+    See RFC 5322 but treat it with suspicion, there seems to exist no universally acknowledged test for a valid email!
+    """
+    if email_validator is None:
+        import_email_validator()
+
+    m = pretty_email_regex.fullmatch(value)
+    name: Optional[str] = None
+    if m:
+        name, value = m.groups()
+
+    email = value.strip()
+
+    try:
+        email_validator.validate_email(email, check_deliverability=False)
+    except email_validator.EmailNotValidError as e:
+        raise errors.EmailError() from e
+
+    at_index = email.index('@')
+    local_part = email[:at_index]  # RFC 5321, local part must be case-sensitive.
+    global_part = email[at_index:].lower()
+
+    return name or local_part, local_part + global_part
diff --git a/myenv/lib/python3.9/site-packages/pydantic/parse.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/parse.cpython-39-darwin.so
new file mode 100755
index 0000000..e5237c7
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/parse.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/parse.py b/myenv/lib/python3.9/site-packages/pydantic/parse.py
new file mode 100644
index 0000000..7ac330c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/parse.py
@@ -0,0 +1,66 @@
+import json
+import pickle
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Union
+
+from .types import StrBytes
+
+
+class Protocol(str, Enum):
+    json = 'json'
+    pickle = 'pickle'
+
+
+def load_str_bytes(
+    b: StrBytes,
+    *,
+    content_type: str = None,
+    encoding: str = 'utf8',
+    proto: Protocol = None,
+    allow_pickle: bool = False,
+    json_loads: Callable[[str], Any] = json.loads,
+) -> Any:
+    if proto is None and content_type:
+        if content_type.endswith(('json', 'javascript')):
+            pass
+        elif allow_pickle and content_type.endswith('pickle'):
+            proto = Protocol.pickle
+        else:
+            raise TypeError(f'Unknown content-type: {content_type}')
+
+    proto = proto or Protocol.json
+
+    if proto == Protocol.json:
+        if isinstance(b, bytes):
+            b = b.decode(encoding)
+        return json_loads(b)
+    elif proto == Protocol.pickle:
+        if not allow_pickle:
+            raise RuntimeError('Trying to decode with pickle with allow_pickle=False')
+        bb = b if isinstance(b, bytes) else b.encode()
+        return pickle.loads(bb)
+    else:
+        raise TypeError(f'Unknown protocol: {proto}')
+
+
+def load_file(
+    path: Union[str, Path],
+    *,
+    content_type: str = None,
+    encoding: str = 'utf8',
+    proto: Protocol = None,
+    allow_pickle: bool = False,
+    json_loads: Callable[[str], Any] = json.loads,
+) -> Any:
+    path = Path(path)
+    b = path.read_bytes()
+    if content_type is None:
+        if path.suffix in ('.js', '.json'):
+            proto = Protocol.json
+        elif path.suffix == '.pkl':
+            proto = Protocol.pickle
+
+    return load_str_bytes(
+        b, proto=proto, content_type=content_type, encoding=encoding, allow_pickle=allow_pickle, json_loads=json_loads
+    )
diff --git a/myenv/lib/python3.9/site-packages/pydantic/py.typed b/myenv/lib/python3.9/site-packages/pydantic/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pydantic/schema.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/schema.cpython-39-darwin.so
new file mode 100755
index 0000000..51e68d6
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/schema.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/schema.py b/myenv/lib/python3.9/site-packages/pydantic/schema.py
new file mode 100644
index 0000000..d37e822
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/schema.py
@@ -0,0 +1,1150 @@
+import re
+import warnings
+from collections import defaultdict
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from enum import Enum
+from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    FrozenSet,
+    Generic,
+    Iterable,
+    List,
+    Optional,
+    Pattern,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+from uuid import UUID
+
+from typing_extensions import Annotated, Literal
+
+from .fields import (
+    MAPPING_LIKE_SHAPES,
+    SHAPE_DEQUE,
+    SHAPE_FROZENSET,
+    SHAPE_GENERIC,
+    SHAPE_ITERABLE,
+    SHAPE_LIST,
+    SHAPE_SEQUENCE,
+    SHAPE_SET,
+    SHAPE_SINGLETON,
+    SHAPE_TUPLE,
+    SHAPE_TUPLE_ELLIPSIS,
+    FieldInfo,
+    ModelField,
+)
+from .json import pydantic_encoder
+from .networks import AnyUrl, EmailStr
+from .types import (
+    ConstrainedDecimal,
+    ConstrainedFloat,
+    ConstrainedFrozenSet,
+    ConstrainedInt,
+    ConstrainedList,
+    ConstrainedSet,
+    ConstrainedStr,
+    SecretBytes,
+    SecretStr,
+    conbytes,
+    condecimal,
+    confloat,
+    confrozenset,
+    conint,
+    conlist,
+    conset,
+    constr,
+)
+from .typing import (
+    ForwardRef,
+    all_literal_values,
+    get_args,
+    get_origin,
+    get_sub_types,
+    is_callable_type,
+    is_literal_type,
+    is_namedtuple,
+    is_none_type,
+    is_union,
+)
+from .utils import ROOT_KEY, get_model, lenient_issubclass, sequence_like
+
+if TYPE_CHECKING:
+    from .dataclasses import Dataclass
+    from .main import BaseModel
+
+default_prefix = '#/definitions/'
+default_ref_template = '#/definitions/{model}'
+
+TypeModelOrEnum = Union[Type['BaseModel'], Type[Enum]]
+TypeModelSet = Set[TypeModelOrEnum]
+
+
+def _apply_modify_schema(
+    modify_schema: Callable[..., None], field: Optional[ModelField], field_schema: Dict[str, Any]
+) -> None:
+    from inspect import signature
+
+    sig = signature(modify_schema)
+    args = set(sig.parameters.keys())
+    if 'field' in args or 'kwargs' in args:
+        modify_schema(field_schema, field=field)
+    else:
+        modify_schema(field_schema)
+
+
+def schema(
+    models: Sequence[Union[Type['BaseModel'], Type['Dataclass']]],
+    *,
+    by_alias: bool = True,
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+    ref_prefix: Optional[str] = None,
+    ref_template: str = default_ref_template,
+) -> Dict[str, Any]:
+    """
+    Process a list of models and generate a single JSON Schema with all of them defined in the ``definitions``
+    top-level JSON key, including their sub-models.
+
+    :param models: a list of models to include in the generated JSON Schema
+    :param by_alias: generate the schemas using the aliases defined, if any
+    :param title: title for the generated schema that includes the definitions
+    :param description: description for the generated schema
+    :param ref_prefix: the JSON Pointer prefix for schema references with ``$ref``, if None, will be set to the
+      default of ``#/definitions/``. Update it if you want the schemas to reference the definitions somewhere
+      else, e.g. for OpenAPI use ``#/components/schemas/``. The resulting generated schemas will still be at the
+      top-level key ``definitions``, so you can extract them from there. But all the references will have the set
+      prefix.
+    :param ref_template: Use a ``string.format()`` template for ``$ref`` instead of a prefix. This can be useful
+      for references that cannot be represented by ``ref_prefix`` such as a definition stored in another file. For
+      a sibling json file in a ``/schemas`` directory use ``"/schemas/${model}.json#"``.
+    :return: dict with the JSON Schema with a ``definitions`` top-level key including the schema definitions for
+      the models and sub-models passed in ``models``.
+    """
+    clean_models = [get_model(model) for model in models]
+    flat_models = get_flat_models_from_models(clean_models)
+    model_name_map = get_model_name_map(flat_models)
+    definitions = {}
+    output_schema: Dict[str, Any] = {}
+    if title:
+        output_schema['title'] = title
+    if description:
+        output_schema['description'] = description
+    for model in clean_models:
+        m_schema, m_definitions, m_nested_models = model_process_schema(
+            model,
+            by_alias=by_alias,
+            model_name_map=model_name_map,
+            ref_prefix=ref_prefix,
+            ref_template=ref_template,
+        )
+        definitions.update(m_definitions)
+        model_name = model_name_map[model]
+        definitions[model_name] = m_schema
+    if definitions:
+        output_schema['definitions'] = definitions
+    return output_schema
+
+
+def model_schema(
+    model: Union[Type['BaseModel'], Type['Dataclass']],
+    by_alias: bool = True,
+    ref_prefix: Optional[str] = None,
+    ref_template: str = default_ref_template,
+) -> Dict[str, Any]:
+    """
+    Generate a JSON Schema for one model. With all the sub-models defined in the ``definitions`` top-level
+    JSON key.
+
+    :param model: a Pydantic model (a class that inherits from BaseModel)
+    :param by_alias: generate the schemas using the aliases defined, if any
+    :param ref_prefix: the JSON Pointer prefix for schema references with ``$ref``, if None, will be set to the
+      default of ``#/definitions/``. Update it if you want the schemas to reference the definitions somewhere
+      else, e.g. for OpenAPI use ``#/components/schemas/``. The resulting generated schemas will still be at the
+      top-level key ``definitions``, so you can extract them from there. But all the references will have the set
+      prefix.
+    :param ref_template: Use a ``string.format()`` template for ``$ref`` instead of a prefix. This can be useful for
+      references that cannot be represented by ``ref_prefix`` such as a definition stored in another file. For a
+      sibling json file in a ``/schemas`` directory use ``"/schemas/${model}.json#"``.
+    :return: dict with the JSON Schema for the passed ``model``
+    """
+    model = get_model(model)
+    flat_models = get_flat_models_from_model(model)
+    model_name_map = get_model_name_map(flat_models)
+    model_name = model_name_map[model]
+    m_schema, m_definitions, nested_models = model_process_schema(
+        model, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix, ref_template=ref_template
+    )
+    if model_name in nested_models:
+        # model_name is in Nested models, it has circular references
+        m_definitions[model_name] = m_schema
+        m_schema = get_schema_ref(model_name, ref_prefix, ref_template, False)
+    if m_definitions:
+        m_schema.update({'definitions': m_definitions})
+    return m_schema
+
+
+def get_field_info_schema(field: ModelField, schema_overrides: bool = False) -> Tuple[Dict[str, Any], bool]:
+
+    # If no title is explicitly set, we don't set title in the schema for enums.
+    # The behaviour is the same as `BaseModel` reference, where the default title
+    # is in the definitions part of the schema.
+    schema_: Dict[str, Any] = {}
+    if field.field_info.title or not lenient_issubclass(field.type_, Enum):
+        schema_['title'] = field.field_info.title or field.alias.title().replace('_', ' ')
+
+    if field.field_info.title:
+        schema_overrides = True
+
+    if field.field_info.description:
+        schema_['description'] = field.field_info.description
+        schema_overrides = True
+
+    if (
+        not field.required
+        and not field.field_info.const
+        and field.default is not None
+        and not is_callable_type(field.outer_type_)
+    ):
+        schema_['default'] = encode_default(field.default)
+        schema_overrides = True
+
+    return schema_, schema_overrides
+
+
+def field_schema(
+    field: ModelField,
+    *,
+    by_alias: bool = True,
+    model_name_map: Dict[TypeModelOrEnum, str],
+    ref_prefix: Optional[str] = None,
+    ref_template: str = default_ref_template,
+    known_models: TypeModelSet = None,
+) -> Tuple[Dict[str, Any], Dict[str, Any], Set[str]]:
+    """
+    Process a Pydantic field and return a tuple with a JSON Schema for it as the first item.
+    Also return a dictionary of definitions with models as keys and their schemas as values. If the passed field
+    is a model and has sub-models, and those sub-models don't have overrides (as ``title``, ``default``, etc), they
+    will be included in the definitions and referenced in the schema instead of included recursively.
+
+    :param field: a Pydantic ``ModelField``
+    :param by_alias: use the defined alias (if any) in the returned schema
+    :param model_name_map: used to generate the JSON Schema references to other models included in the definitions
+    :param ref_prefix: the JSON Pointer prefix to use for references to other schemas, if None, the default of
+      #/definitions/ will be used
+    :param ref_template: Use a ``string.format()`` template for ``$ref`` instead of a prefix. This can be useful for
+      references that cannot be represented by ``ref_prefix`` such as a definition stored in another file. For a
+      sibling json file in a ``/schemas`` directory use ``"/schemas/${model}.json#"``.
+    :param known_models: used to solve circular references
+    :return: tuple of the schema for this field and additional definitions
+    """
+    s, schema_overrides = get_field_info_schema(field)
+
+    validation_schema = get_field_schema_validations(field)
+    if validation_schema:
+        s.update(validation_schema)
+        schema_overrides = True
+
+    f_schema, f_definitions, f_nested_models = field_type_schema(
+        field,
+        by_alias=by_alias,
+        model_name_map=model_name_map,
+        schema_overrides=schema_overrides,
+        ref_prefix=ref_prefix,
+        ref_template=ref_template,
+        known_models=known_models or set(),
+    )
+
+    # $ref will only be returned when there are no schema_overrides
+    if '$ref' in f_schema:
+        return f_schema, f_definitions, f_nested_models
+    else:
+        s.update(f_schema)
+        return s, f_definitions, f_nested_models
+
+
+numeric_types = (int, float, Decimal)
+_str_types_attrs: Tuple[Tuple[str, Union[type, Tuple[type, ...]], str], ...] = (
+    ('max_length', numeric_types, 'maxLength'),
+    ('min_length', numeric_types, 'minLength'),
+    ('regex', str, 'pattern'),
+)
+
+_numeric_types_attrs: Tuple[Tuple[str, Union[type, Tuple[type, ...]], str], ...] = (
+    ('gt', numeric_types, 'exclusiveMinimum'),
+    ('lt', numeric_types, 'exclusiveMaximum'),
+    ('ge', numeric_types, 'minimum'),
+    ('le', numeric_types, 'maximum'),
+    ('multiple_of', numeric_types, 'multipleOf'),
+)
+
+
+def get_field_schema_validations(field: ModelField) -> Dict[str, Any]:
+    """
+    Get the JSON Schema validation keywords for a ``field`` with an annotation of
+    a Pydantic ``FieldInfo`` with validation arguments.
+    """
+    f_schema: Dict[str, Any] = {}
+
+    if lenient_issubclass(field.type_, Enum):
+        # schema is already updated by `enum_process_schema`; just update with field extra
+        if field.field_info.extra:
+            f_schema.update(field.field_info.extra)
+        return f_schema
+
+    if lenient_issubclass(field.type_, (str, bytes)):
+        for attr_name, t, keyword in _str_types_attrs:
+            attr = getattr(field.field_info, attr_name, None)
+            if isinstance(attr, t):
+                f_schema[keyword] = attr
+    if lenient_issubclass(field.type_, numeric_types) and not issubclass(field.type_, bool):
+        for attr_name, t, keyword in _numeric_types_attrs:
+            attr = getattr(field.field_info, attr_name, None)
+            if isinstance(attr, t):
+                f_schema[keyword] = attr
+    if field.field_info is not None and field.field_info.const:
+        f_schema['const'] = field.default
+    if field.field_info.extra:
+        f_schema.update(field.field_info.extra)
+    modify_schema = getattr(field.outer_type_, '__modify_schema__', None)
+    if modify_schema:
+        _apply_modify_schema(modify_schema, field, f_schema)
+    return f_schema
+
+
+def get_model_name_map(unique_models: TypeModelSet) -> Dict[TypeModelOrEnum, str]:
+    """
+    Process a set of models and generate unique names for them to be used as keys in the JSON Schema
+    definitions. By default the names are the same as the class name. But if two models in different Python
+    modules have the same name (e.g. "users.Model" and "items.Model"), the generated names will be
+    based on the Python module path for those conflicting models to prevent name collisions.
+
+    :param unique_models: a Python set of models
+    :return: dict mapping models to names
+    """
+    name_model_map = {}
+    conflicting_names: Set[str] = set()
+    for model in unique_models:
+        model_name = normalize_name(model.__name__)
+        if model_name in conflicting_names:
+            model_name = get_long_model_name(model)
+            name_model_map[model_name] = model
+        elif model_name in name_model_map:
+            conflicting_names.add(model_name)
+            conflicting_model = name_model_map.pop(model_name)
+            name_model_map[get_long_model_name(conflicting_model)] = conflicting_model
+            name_model_map[get_long_model_name(model)] = model
+        else:
+            name_model_map[model_name] = model
+    return {v: k for k, v in name_model_map.items()}
+
+
+def get_flat_models_from_model(model: Type['BaseModel'], known_models: TypeModelSet = None) -> TypeModelSet:
+    """
+    Take a single ``model`` and generate a set with itself and all the sub-models in the tree. I.e. if you pass
+    model ``Foo`` (subclass of Pydantic ``BaseModel``) as ``model``, and it has a field of type ``Bar`` (also
+    subclass of ``BaseModel``) and that model ``Bar`` has a field of type ``Baz`` (also subclass of ``BaseModel``),
+    the return value will be ``set([Foo, Bar, Baz])``.
+
+    :param model: a Pydantic ``BaseModel`` subclass
+    :param known_models: used to solve circular references
+    :return: a set with the initial model and all its sub-models
+    """
+    known_models = known_models or set()
+    flat_models: TypeModelSet = set()
+    flat_models.add(model)
+    known_models |= flat_models
+    fields = cast(Sequence[ModelField], model.__fields__.values())
+    flat_models |= get_flat_models_from_fields(fields, known_models=known_models)
+    return flat_models
+
+
+def get_flat_models_from_field(field: ModelField, known_models: TypeModelSet) -> TypeModelSet:
+    """
+    Take a single Pydantic ``ModelField`` (from a model) that could have been declared as a sublcass of BaseModel
+    (so, it could be a submodel), and generate a set with its model and all the sub-models in the tree.
+    I.e. if you pass a field that was declared to be of type ``Foo`` (subclass of BaseModel) as ``field``, and that
+    model ``Foo`` has a field of type ``Bar`` (also subclass of ``BaseModel``) and that model ``Bar`` has a field of
+    type ``Baz`` (also subclass of ``BaseModel``), the return value will be ``set([Foo, Bar, Baz])``.
+
+    :param field: a Pydantic ``ModelField``
+    :param known_models: used to solve circular references
+    :return: a set with the model used in the declaration for this field, if any, and all its sub-models
+    """
+    from .dataclasses import dataclass, is_builtin_dataclass
+    from .main import BaseModel
+
+    flat_models: TypeModelSet = set()
+
+    # Handle dataclass-based models
+    if is_builtin_dataclass(field.type_):
+        field.type_ = dataclass(field.type_)
+        was_dataclass = True
+    else:
+        was_dataclass = False
+    field_type = field.type_
+    if lenient_issubclass(getattr(field_type, '__pydantic_model__', None), BaseModel):
+        field_type = field_type.__pydantic_model__
+    if field.sub_fields and (not lenient_issubclass(field_type, BaseModel) or was_dataclass):
+        flat_models |= get_flat_models_from_fields(field.sub_fields, known_models=known_models)
+    elif lenient_issubclass(field_type, BaseModel) and field_type not in known_models:
+        flat_models |= get_flat_models_from_model(field_type, known_models=known_models)
+    elif lenient_issubclass(field_type, Enum):
+        flat_models.add(field_type)
+    return flat_models
+
+
+def get_flat_models_from_fields(fields: Sequence[ModelField], known_models: TypeModelSet) -> TypeModelSet:
+    """
+    Take a list of Pydantic  ``ModelField``s (from a model) that could have been declared as subclasses of ``BaseModel``
+    (so, any of them could be a submodel), and generate a set with their models and all the sub-models in the tree.
+    I.e. if you pass a the fields of a model ``Foo`` (subclass of ``BaseModel``) as ``fields``, and on of them has a
+    field of type ``Bar`` (also subclass of ``BaseModel``) and that model ``Bar`` has a field of type ``Baz`` (also
+    subclass of ``BaseModel``), the return value will be ``set([Foo, Bar, Baz])``.
+
+    :param fields: a list of Pydantic ``ModelField``s
+    :param known_models: used to solve circular references
+    :return: a set with any model declared in the fields, and all their sub-models
+    """
+    flat_models: TypeModelSet = set()
+    for field in fields:
+        flat_models |= get_flat_models_from_field(field, known_models=known_models)
+    return flat_models
+
+
+def get_flat_models_from_models(models: Sequence[Type['BaseModel']]) -> TypeModelSet:
+    """
+    Take a list of ``models`` and generate a set with them and all their sub-models in their trees. I.e. if you pass
+    a list of two models, ``Foo`` and ``Bar``, both subclasses of Pydantic ``BaseModel`` as models, and ``Bar`` has
+    a field of type ``Baz`` (also subclass of ``BaseModel``), the return value will be ``set([Foo, Bar, Baz])``.
+    """
+    flat_models: TypeModelSet = set()
+    for model in models:
+        flat_models |= get_flat_models_from_model(model)
+    return flat_models
+
+
+def get_long_model_name(model: TypeModelOrEnum) -> str:
+    return f'{model.__module__}__{model.__qualname__}'.replace('.', '__')
+
+
+def field_type_schema(
+    field: ModelField,
+    *,
+    by_alias: bool,
+    model_name_map: Dict[TypeModelOrEnum, str],
+    ref_template: str,
+    schema_overrides: bool = False,
+    ref_prefix: Optional[str] = None,
+    known_models: TypeModelSet,
+) -> Tuple[Dict[str, Any], Dict[str, Any], Set[str]]:
+    """
+    Used by ``field_schema()``, you probably should be using that function.
+
+    Take a single ``field`` and generate the schema for its type only, not including additional
+    information as title, etc. Also return additional schema definitions, from sub-models.
+    """
+    from .main import BaseModel  # noqa: F811
+
+    definitions = {}
+    nested_models: Set[str] = set()
+    f_schema: Dict[str, Any]
+    if field.shape in {
+        SHAPE_LIST,
+        SHAPE_TUPLE_ELLIPSIS,
+        SHAPE_SEQUENCE,
+        SHAPE_SET,
+        SHAPE_FROZENSET,
+        SHAPE_ITERABLE,
+        SHAPE_DEQUE,
+    }:
+        items_schema, f_definitions, f_nested_models = field_singleton_schema(
+            field,
+            by_alias=by_alias,
+            model_name_map=model_name_map,
+            ref_prefix=ref_prefix,
+            ref_template=ref_template,
+            known_models=known_models,
+        )
+        definitions.update(f_definitions)
+        nested_models.update(f_nested_models)
+        f_schema = {'type': 'array', 'items': items_schema}
+        if field.shape in {SHAPE_SET, SHAPE_FROZENSET}:
+            f_schema['uniqueItems'] = True
+
+    elif field.shape in MAPPING_LIKE_SHAPES:
+        f_schema = {'type': 'object'}
+        key_field = cast(ModelField, field.key_field)
+        regex = getattr(key_field.type_, 'regex', None)
+        items_schema, f_definitions, f_nested_models = field_singleton_schema(
+            field,
+            by_alias=by_alias,
+            model_name_map=model_name_map,
+            ref_prefix=ref_prefix,
+            ref_template=ref_template,
+            known_models=known_models,
+        )
+        definitions.update(f_definitions)
+        nested_models.update(f_nested_models)
+        if regex:
+            # Dict keys have a regex pattern
+            # items_schema might be a schema or empty dict, add it either way
+            f_schema['patternProperties'] = {regex.pattern: items_schema}
+        elif items_schema:
+            # The dict values are not simply Any, so they need a schema
+            f_schema['additionalProperties'] = items_schema
+    elif field.shape == SHAPE_TUPLE or (field.shape == SHAPE_GENERIC and not issubclass(field.type_, BaseModel)):
+        sub_schema = []
+        sub_fields = cast(List[ModelField], field.sub_fields)
+        for sf in sub_fields:
+            sf_schema, sf_definitions, sf_nested_models = field_type_schema(
+                sf,
+                by_alias=by_alias,
+                model_name_map=model_name_map,
+                ref_prefix=ref_prefix,
+                ref_template=ref_template,
+                known_models=known_models,
+            )
+            definitions.update(sf_definitions)
+            nested_models.update(sf_nested_models)
+            sub_schema.append(sf_schema)
+
+        sub_fields_len = len(sub_fields)
+        if field.shape == SHAPE_GENERIC:
+            all_of_schemas = sub_schema[0] if sub_fields_len == 1 else {'type': 'array', 'items': sub_schema}
+            f_schema = {'allOf': [all_of_schemas]}
+        else:
+            f_schema = {
+                'type': 'array',
+                'minItems': sub_fields_len,
+                'maxItems': sub_fields_len,
+            }
+            if sub_fields_len >= 1:
+                f_schema['items'] = sub_schema
+    else:
+        assert field.shape in {SHAPE_SINGLETON, SHAPE_GENERIC}, field.shape
+        f_schema, f_definitions, f_nested_models = field_singleton_schema(
+            field,
+            by_alias=by_alias,
+            model_name_map=model_name_map,
+            schema_overrides=schema_overrides,
+            ref_prefix=ref_prefix,
+            ref_template=ref_template,
+            known_models=known_models,
+        )
+        definitions.update(f_definitions)
+        nested_models.update(f_nested_models)
+
+    # check field type to avoid repeated calls to the same __modify_schema__ method
+    if field.type_ != field.outer_type_:
+        if field.shape == SHAPE_GENERIC:
+            field_type = field.type_
+        else:
+            field_type = field.outer_type_
+        modify_schema = getattr(field_type, '__modify_schema__', None)
+        if modify_schema:
+            _apply_modify_schema(modify_schema, field, f_schema)
+    return f_schema, definitions, nested_models
+
+
+def model_process_schema(
+    model: TypeModelOrEnum,
+    *,
+    by_alias: bool = True,
+    model_name_map: Dict[TypeModelOrEnum, str],
+    ref_prefix: Optional[str] = None,
+    ref_template: str = default_ref_template,
+    known_models: TypeModelSet = None,
+    field: Optional[ModelField] = None,
+) -> Tuple[Dict[str, Any], Dict[str, Any], Set[str]]:
+    """
+    Used by ``model_schema()``, you probably should be using that function.
+
+    Take a single ``model`` and generate its schema. Also return additional schema definitions, from sub-models. The
+    sub-models of the returned schema will be referenced, but their definitions will not be included in the schema. All
+    the definitions are returned as the second value.
+    """
+    from inspect import getdoc, signature
+
+    known_models = known_models or set()
+    if lenient_issubclass(model, Enum):
+        model = cast(Type[Enum], model)
+        s = enum_process_schema(model, field=field)
+        return s, {}, set()
+    model = cast(Type['BaseModel'], model)
+    s = {'title': model.__config__.title or model.__name__}
+    doc = getdoc(model)
+    if doc:
+        s['description'] = doc
+    known_models.add(model)
+    m_schema, m_definitions, nested_models = model_type_schema(
+        model,
+        by_alias=by_alias,
+        model_name_map=model_name_map,
+        ref_prefix=ref_prefix,
+        ref_template=ref_template,
+        known_models=known_models,
+    )
+    s.update(m_schema)
+    schema_extra = model.__config__.schema_extra
+    if callable(schema_extra):
+        if len(signature(schema_extra).parameters) == 1:
+            schema_extra(s)
+        else:
+            schema_extra(s, model)
+    else:
+        s.update(schema_extra)
+    return s, m_definitions, nested_models
+
+
+def model_type_schema(
+    model: Type['BaseModel'],
+    *,
+    by_alias: bool,
+    model_name_map: Dict[TypeModelOrEnum, str],
+    ref_template: str,
+    ref_prefix: Optional[str] = None,
+    known_models: TypeModelSet,
+) -> Tuple[Dict[str, Any], Dict[str, Any], Set[str]]:
+    """
+    You probably should be using ``model_schema()``, this function is indirectly used by that function.
+
+    Take a single ``model`` and generate the schema for its type only, not including additional
+    information as title, etc. Also return additional schema definitions, from sub-models.
+    """
+    properties = {}
+    required = []
+    definitions: Dict[str, Any] = {}
+    nested_models: Set[str] = set()
+    for k, f in model.__fields__.items():
+        try:
+            f_schema, f_definitions, f_nested_models = field_schema(
+                f,
+                by_alias=by_alias,
+                model_name_map=model_name_map,
+                ref_prefix=ref_prefix,
+                ref_template=ref_template,
+                known_models=known_models,
+            )
+        except SkipField as skip:
+            warnings.warn(skip.message, UserWarning)
+            continue
+        definitions.update(f_definitions)
+        nested_models.update(f_nested_models)
+        if by_alias:
+            properties[f.alias] = f_schema
+            if f.required:
+                required.append(f.alias)
+        else:
+            properties[k] = f_schema
+            if f.required:
+                required.append(k)
+    if ROOT_KEY in properties:
+        out_schema = properties[ROOT_KEY]
+        out_schema['title'] = model.__config__.title or model.__name__
+    else:
+        out_schema = {'type': 'object', 'properties': properties}
+        if required:
+            out_schema['required'] = required
+    if model.__config__.extra == 'forbid':
+        out_schema['additionalProperties'] = False
+    return out_schema, definitions, nested_models
+
+
+def enum_process_schema(enum: Type[Enum], *, field: Optional[ModelField] = None) -> Dict[str, Any]:
+    """
+    Take a single `enum` and generate its schema.
+
+    This is similar to the `model_process_schema` function, but applies to ``Enum`` objects.
+    """
+    from inspect import getdoc
+
+    schema_: Dict[str, Any] = {
+        'title': enum.__name__,
+        # Python assigns all enums a default docstring value of 'An enumeration', so
+        # all enums will have a description field even if not explicitly provided.
+        'description': getdoc(enum),
+        # Add enum values and the enum field type to the schema.
+        'enum': [item.value for item in cast(Iterable[Enum], enum)],
+    }
+
+    add_field_type_to_schema(enum, schema_)
+
+    modify_schema = getattr(enum, '__modify_schema__', None)
+    if modify_schema:
+        _apply_modify_schema(modify_schema, field, schema_)
+
+    return schema_
+
+
+def field_singleton_sub_fields_schema(
+    field: ModelField,
+    *,
+    by_alias: bool,
+    model_name_map: Dict[TypeModelOrEnum, str],
+    ref_template: str,
+    schema_overrides: bool = False,
+    ref_prefix: Optional[str] = None,
+    known_models: TypeModelSet,
+) -> Tuple[Dict[str, Any], Dict[str, Any], Set[str]]:
+    """
+    This function is indirectly used by ``field_schema()``, you probably should be using that function.
+
+    Take a list of Pydantic ``ModelField`` from the declaration of a type with parameters, and generate their
+    schema. I.e., fields used as "type parameters", like ``str`` and ``int`` in ``Tuple[str, int]``.
+    """
+    sub_fields = cast(List[ModelField], field.sub_fields)
+    definitions = {}
+    nested_models: Set[str] = set()
+    if len(sub_fields) == 1:
+        return field_type_schema(
+            sub_fields[0],
+            by_alias=by_alias,
+            model_name_map=model_name_map,
+            schema_overrides=schema_overrides,
+            ref_prefix=ref_prefix,
+            ref_template=ref_template,
+            known_models=known_models,
+        )
+    else:
+        s: Dict[str, Any] = {}
+        # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#discriminator-object
+        if field.discriminator_key is not None:
+            assert field.sub_fields_mapping is not None
+
+            discriminator_models_refs: Dict[str, Union[str, Dict[str, Any]]] = {}
+
+            for discriminator_value, sub_field in field.sub_fields_mapping.items():
+                # sub_field is either a `BaseModel` or directly an `Annotated` `Union` of many
+                if is_union(get_origin(sub_field.type_)):
+                    sub_models = get_sub_types(sub_field.type_)
+                    discriminator_models_refs[discriminator_value] = {
+                        model_name_map[sub_model]: get_schema_ref(
+                            model_name_map[sub_model], ref_prefix, ref_template, False
+                        )
+                        for sub_model in sub_models
+                    }
+                else:
+                    sub_field_type = sub_field.type_
+                    if hasattr(sub_field_type, '__pydantic_model__'):
+                        sub_field_type = sub_field_type.__pydantic_model__
+
+                    discriminator_model_name = model_name_map[sub_field_type]
+                    discriminator_model_ref = get_schema_ref(discriminator_model_name, ref_prefix, ref_template, False)
+                    discriminator_models_refs[discriminator_value] = discriminator_model_ref['$ref']
+
+            s['discriminator'] = {
+                'propertyName': field.discriminator_alias,
+                'mapping': discriminator_models_refs,
+            }
+
+        sub_field_schemas = []
+        for sf in sub_fields:
+            sub_schema, sub_definitions, sub_nested_models = field_type_schema(
+                sf,
+                by_alias=by_alias,
+                model_name_map=model_name_map,
+                schema_overrides=schema_overrides,
+                ref_prefix=ref_prefix,
+                ref_template=ref_template,
+                known_models=known_models,
+            )
+            definitions.update(sub_definitions)
+            if schema_overrides and 'allOf' in sub_schema:
+                # if the sub_field is a referenced schema we only need the referenced
+                # object. Otherwise we will end up with several allOf inside anyOf.
+                # See https://github.com/samuelcolvin/pydantic/issues/1209
+                sub_schema = sub_schema['allOf'][0]
+
+            if sub_schema.keys() == {'discriminator', 'anyOf'}:
+                # we don't want discriminator information inside anyOf choices, this is dealt with elsewhere
+                sub_schema.pop('discriminator')
+            sub_field_schemas.append(sub_schema)
+            nested_models.update(sub_nested_models)
+        s['anyOf'] = sub_field_schemas
+        return s, definitions, nested_models
+
+
+# Order is important, e.g. subclasses of str must go before str
+# this is used only for standard library types, custom types should use __modify_schema__ instead
+field_class_to_schema: Tuple[Tuple[Any, Dict[str, Any]], ...] = (
+    (Path, {'type': 'string', 'format': 'path'}),
+    (datetime, {'type': 'string', 'format': 'date-time'}),
+    (date, {'type': 'string', 'format': 'date'}),
+    (time, {'type': 'string', 'format': 'time'}),
+    (timedelta, {'type': 'number', 'format': 'time-delta'}),
+    (IPv4Network, {'type': 'string', 'format': 'ipv4network'}),
+    (IPv6Network, {'type': 'string', 'format': 'ipv6network'}),
+    (IPv4Interface, {'type': 'string', 'format': 'ipv4interface'}),
+    (IPv6Interface, {'type': 'string', 'format': 'ipv6interface'}),
+    (IPv4Address, {'type': 'string', 'format': 'ipv4'}),
+    (IPv6Address, {'type': 'string', 'format': 'ipv6'}),
+    (Pattern, {'type': 'string', 'format': 'regex'}),
+    (str, {'type': 'string'}),
+    (bytes, {'type': 'string', 'format': 'binary'}),
+    (bool, {'type': 'boolean'}),
+    (int, {'type': 'integer'}),
+    (float, {'type': 'number'}),
+    (Decimal, {'type': 'number'}),
+    (UUID, {'type': 'string', 'format': 'uuid'}),
+    (dict, {'type': 'object'}),
+    (list, {'type': 'array', 'items': {}}),
+    (tuple, {'type': 'array', 'items': {}}),
+    (set, {'type': 'array', 'items': {}, 'uniqueItems': True}),
+    (frozenset, {'type': 'array', 'items': {}, 'uniqueItems': True}),
+)
+
+json_scheme = {'type': 'string', 'format': 'json-string'}
+
+
+def add_field_type_to_schema(field_type: Any, schema_: Dict[str, Any]) -> None:
+    """
+    Update the given `schema` with the type-specific metadata for the given `field_type`.
+
+    This function looks through `field_class_to_schema` for a class that matches the given `field_type`,
+    and then modifies the given `schema` with the information from that type.
+    """
+    for type_, t_schema in field_class_to_schema:
+        # Fallback for `typing.Pattern` as it is not a valid class
+        if lenient_issubclass(field_type, type_) or field_type is type_ is Pattern:
+            schema_.update(t_schema)
+            break
+
+
+def get_schema_ref(name: str, ref_prefix: Optional[str], ref_template: str, schema_overrides: bool) -> Dict[str, Any]:
+    if ref_prefix:
+        schema_ref = {'$ref': ref_prefix + name}
+    else:
+        schema_ref = {'$ref': ref_template.format(model=name)}
+    return {'allOf': [schema_ref]} if schema_overrides else schema_ref
+
+
+def field_singleton_schema(  # noqa: C901 (ignore complexity)
+    field: ModelField,
+    *,
+    by_alias: bool,
+    model_name_map: Dict[TypeModelOrEnum, str],
+    ref_template: str,
+    schema_overrides: bool = False,
+    ref_prefix: Optional[str] = None,
+    known_models: TypeModelSet,
+) -> Tuple[Dict[str, Any], Dict[str, Any], Set[str]]:
+    """
+    This function is indirectly used by ``field_schema()``, you should probably be using that function.
+
+    Take a single Pydantic ``ModelField``, and return its schema and any additional definitions from sub-models.
+    """
+    from .main import BaseModel
+
+    definitions: Dict[str, Any] = {}
+    nested_models: Set[str] = set()
+    field_type = field.type_
+
+    # Recurse into this field if it contains sub_fields and is NOT a
+    # BaseModel OR that BaseModel is a const
+    if field.sub_fields and (
+        (field.field_info and field.field_info.const) or not lenient_issubclass(field_type, BaseModel)
+    ):
+        return field_singleton_sub_fields_schema(
+            field,
+            by_alias=by_alias,
+            model_name_map=model_name_map,
+            schema_overrides=schema_overrides,
+            ref_prefix=ref_prefix,
+            ref_template=ref_template,
+            known_models=known_models,
+        )
+    if field_type is Any or field_type is object or field_type.__class__ == TypeVar:
+        return {}, definitions, nested_models  # no restrictions
+    if is_none_type(field_type):
+        return {'type': 'null'}, definitions, nested_models
+    if is_callable_type(field_type):
+        raise SkipField(f'Callable {field.name} was excluded from schema since JSON schema has no equivalent type.')
+    f_schema: Dict[str, Any] = {}
+    if field.field_info is not None and field.field_info.const:
+        f_schema['const'] = field.default
+
+    if is_literal_type(field_type):
+        values = all_literal_values(field_type)
+
+        if len({v.__class__ for v in values}) > 1:
+            return field_schema(
+                multitypes_literal_field_for_schema(values, field),
+                by_alias=by_alias,
+                model_name_map=model_name_map,
+                ref_prefix=ref_prefix,
+                ref_template=ref_template,
+                known_models=known_models,
+            )
+
+        # All values have the same type
+        field_type = values[0].__class__
+        f_schema['enum'] = list(values)
+        add_field_type_to_schema(field_type, f_schema)
+    elif lenient_issubclass(field_type, Enum):
+        enum_name = model_name_map[field_type]
+        f_schema, schema_overrides = get_field_info_schema(field, schema_overrides)
+        f_schema.update(get_schema_ref(enum_name, ref_prefix, ref_template, schema_overrides))
+        definitions[enum_name] = enum_process_schema(field_type, field=field)
+    elif is_namedtuple(field_type):
+        sub_schema, *_ = model_process_schema(
+            field_type.__pydantic_model__,
+            by_alias=by_alias,
+            model_name_map=model_name_map,
+            ref_prefix=ref_prefix,
+            ref_template=ref_template,
+            known_models=known_models,
+            field=field,
+        )
+        items_schemas = list(sub_schema['properties'].values())
+        f_schema.update(
+            {
+                'type': 'array',
+                'items': items_schemas,
+                'minItems': len(items_schemas),
+                'maxItems': len(items_schemas),
+            }
+        )
+    elif not hasattr(field_type, '__pydantic_model__'):
+        add_field_type_to_schema(field_type, f_schema)
+
+        modify_schema = getattr(field_type, '__modify_schema__', None)
+        if modify_schema:
+            _apply_modify_schema(modify_schema, field, f_schema)
+
+    if f_schema:
+        return f_schema, definitions, nested_models
+
+    # Handle dataclass-based models
+    if lenient_issubclass(getattr(field_type, '__pydantic_model__', None), BaseModel):
+        field_type = field_type.__pydantic_model__
+
+    if issubclass(field_type, BaseModel):
+        model_name = model_name_map[field_type]
+        if field_type not in known_models:
+            sub_schema, sub_definitions, sub_nested_models = model_process_schema(
+                field_type,
+                by_alias=by_alias,
+                model_name_map=model_name_map,
+                ref_prefix=ref_prefix,
+                ref_template=ref_template,
+                known_models=known_models,
+                field=field,
+            )
+            definitions.update(sub_definitions)
+            definitions[model_name] = sub_schema
+            nested_models.update(sub_nested_models)
+        else:
+            nested_models.add(model_name)
+        schema_ref = get_schema_ref(model_name, ref_prefix, ref_template, schema_overrides)
+        return schema_ref, definitions, nested_models
+
+    # For generics with no args
+    args = get_args(field_type)
+    if args is not None and not args and Generic in field_type.__bases__:
+        return f_schema, definitions, nested_models
+
+    raise ValueError(f'Value not declarable with JSON Schema, field: {field}')
+
+
+def multitypes_literal_field_for_schema(values: Tuple[Any, ...], field: ModelField) -> ModelField:
+    """
+    To support `Literal` with values of different types, we split it into multiple `Literal` with same type
+    e.g. `Literal['qwe', 'asd', 1, 2]` becomes `Union[Literal['qwe', 'asd'], Literal[1, 2]]`
+    """
+    literal_distinct_types = defaultdict(list)
+    for v in values:
+        literal_distinct_types[v.__class__].append(v)
+    distinct_literals = (Literal[tuple(same_type_values)] for same_type_values in literal_distinct_types.values())
+
+    return ModelField(
+        name=field.name,
+        type_=Union[tuple(distinct_literals)],  # type: ignore
+        class_validators=field.class_validators,
+        model_config=field.model_config,
+        default=field.default,
+        required=field.required,
+        alias=field.alias,
+        field_info=field.field_info,
+    )
+
+
+def encode_default(dft: Any) -> Any:
+    if isinstance(dft, Enum):
+        return dft.value
+    elif isinstance(dft, (int, float, str)):
+        return dft
+    elif sequence_like(dft):
+        t = dft.__class__
+        seq_args = (encode_default(v) for v in dft)
+        return t(*seq_args) if is_namedtuple(t) else t(seq_args)
+    elif isinstance(dft, dict):
+        return {encode_default(k): encode_default(v) for k, v in dft.items()}
+    elif dft is None:
+        return None
+    else:
+        return pydantic_encoder(dft)
+
+
+_map_types_constraint: Dict[Any, Callable[..., type]] = {int: conint, float: confloat, Decimal: condecimal}
+
+
+def get_annotation_from_field_info(
+    annotation: Any, field_info: FieldInfo, field_name: str, validate_assignment: bool = False
+) -> Type[Any]:
+    """
+    Get an annotation with validation implemented for numbers and strings based on the field_info.
+    :param annotation: an annotation from a field specification, as ``str``, ``ConstrainedStr``
+    :param field_info: an instance of FieldInfo, possibly with declarations for validations and JSON Schema
+    :param field_name: name of the field for use in error messages
+    :param validate_assignment: default False, flag for BaseModel Config value of validate_assignment
+    :return: the same ``annotation`` if unmodified or a new annotation with validation in place
+    """
+    constraints = field_info.get_constraints()
+    used_constraints: Set[str] = set()
+    if constraints:
+        annotation, used_constraints = get_annotation_with_constraints(annotation, field_info)
+    if validate_assignment:
+        used_constraints.add('allow_mutation')
+
+    unused_constraints = constraints - used_constraints
+    if unused_constraints:
+        raise ValueError(
+            f'On field "{field_name}" the following field constraints are set but not enforced: '
+            f'{", ".join(unused_constraints)}. '
+            f'\nFor more details see https://pydantic-docs.helpmanual.io/usage/schema/#unenforced-field-constraints'
+        )
+
+    return annotation
+
+
+def get_annotation_with_constraints(annotation: Any, field_info: FieldInfo) -> Tuple[Type[Any], Set[str]]:  # noqa: C901
+    """
+    Get an annotation with used constraints implemented for numbers and strings based on the field_info.
+
+    :param annotation: an annotation from a field specification, as ``str``, ``ConstrainedStr``
+    :param field_info: an instance of FieldInfo, possibly with declarations for validations and JSON Schema
+    :return: the same ``annotation`` if unmodified or a new annotation along with the used constraints.
+    """
+    used_constraints: Set[str] = set()
+
+    def go(type_: Any) -> Type[Any]:
+        if (
+            is_literal_type(type_)
+            or isinstance(type_, ForwardRef)
+            or lenient_issubclass(type_, (ConstrainedList, ConstrainedSet, ConstrainedFrozenSet))
+        ):
+            return type_
+        origin = get_origin(type_)
+        if origin is not None:
+            args: Tuple[Any, ...] = get_args(type_)
+            if any(isinstance(a, ForwardRef) for a in args):
+                # forward refs cause infinite recursion below
+                return type_
+
+            if origin is Annotated:
+                return go(args[0])
+            if is_union(origin):
+                return Union[tuple(go(a) for a in args)]  # type: ignore
+
+            if issubclass(origin, List) and (
+                field_info.min_items is not None
+                or field_info.max_items is not None
+                or field_info.unique_items is not None
+            ):
+                used_constraints.update({'min_items', 'max_items', 'unique_items'})
+                return conlist(
+                    go(args[0]),
+                    min_items=field_info.min_items,
+                    max_items=field_info.max_items,
+                    unique_items=field_info.unique_items,
+                )
+
+            if issubclass(origin, Set) and (field_info.min_items is not None or field_info.max_items is not None):
+                used_constraints.update({'min_items', 'max_items'})
+                return conset(go(args[0]), min_items=field_info.min_items, max_items=field_info.max_items)
+
+            if issubclass(origin, FrozenSet) and (field_info.min_items is not None or field_info.max_items is not None):
+                used_constraints.update({'min_items', 'max_items'})
+                return confrozenset(go(args[0]), min_items=field_info.min_items, max_items=field_info.max_items)
+
+            for t in (Tuple, List, Set, FrozenSet, Sequence):
+                if issubclass(origin, t):  # type: ignore
+                    return t[tuple(go(a) for a in args)]  # type: ignore
+
+            if issubclass(origin, Dict):
+                return Dict[args[0], go(args[1])]  # type: ignore
+
+        attrs: Optional[Tuple[str, ...]] = None
+        constraint_func: Optional[Callable[..., type]] = None
+        if isinstance(type_, type):
+            if issubclass(type_, (SecretStr, SecretBytes)):
+                attrs = ('max_length', 'min_length')
+
+                def constraint_func(**kw: Any) -> Type[Any]:
+                    return type(type_.__name__, (type_,), kw)
+
+            elif issubclass(type_, str) and not issubclass(type_, (EmailStr, AnyUrl, ConstrainedStr)):
+                attrs = ('max_length', 'min_length', 'regex')
+                constraint_func = constr
+            elif issubclass(type_, bytes):
+                attrs = ('max_length', 'min_length', 'regex')
+                constraint_func = conbytes
+            elif issubclass(type_, numeric_types) and not issubclass(
+                type_,
+                (
+                    ConstrainedInt,
+                    ConstrainedFloat,
+                    ConstrainedDecimal,
+                    ConstrainedList,
+                    ConstrainedSet,
+                    ConstrainedFrozenSet,
+                    bool,
+                ),
+            ):
+                # Is numeric type
+                attrs = ('gt', 'lt', 'ge', 'le', 'multiple_of')
+                if issubclass(type_, Decimal):
+                    attrs += ('max_digits', 'decimal_places')
+                numeric_type = next(t for t in numeric_types if issubclass(type_, t))  # pragma: no branch
+                constraint_func = _map_types_constraint[numeric_type]
+
+        if attrs:
+            used_constraints.update(set(attrs))
+            kwargs = {
+                attr_name: attr
+                for attr_name, attr in ((attr_name, getattr(field_info, attr_name)) for attr_name in attrs)
+                if attr is not None
+            }
+            if kwargs:
+                constraint_func = cast(Callable[..., type], constraint_func)
+                return constraint_func(**kwargs)
+        return type_
+
+    return go(annotation), used_constraints
+
+
+def normalize_name(name: str) -> str:
+    """
+    Normalizes the given name. This can be applied to either a model *or* enum.
+    """
+    return re.sub(r'[^a-zA-Z0-9.\-_]', '_', name)
+
+
+class SkipField(Exception):
+    """
+    Utility exception used to exclude fields from schema.
+    """
+
+    def __init__(self, message: str) -> None:
+        self.message = message
diff --git a/myenv/lib/python3.9/site-packages/pydantic/tools.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/tools.cpython-39-darwin.so
new file mode 100755
index 0000000..0ffc0f9
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/tools.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/tools.py b/myenv/lib/python3.9/site-packages/pydantic/tools.py
new file mode 100644
index 0000000..9cdb453
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/tools.py
@@ -0,0 +1,92 @@
+import json
+from functools import lru_cache
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Optional, Type, TypeVar, Union
+
+from .parse import Protocol, load_file, load_str_bytes
+from .types import StrBytes
+from .typing import display_as_type
+
+__all__ = ('parse_file_as', 'parse_obj_as', 'parse_raw_as', 'schema_of', 'schema_json_of')
+
+NameFactory = Union[str, Callable[[Type[Any]], str]]
+
+if TYPE_CHECKING:
+    from .typing import DictStrAny
+
+
+def _generate_parsing_type_name(type_: Any) -> str:
+    return f'ParsingModel[{display_as_type(type_)}]'
+
+
+@lru_cache(maxsize=2048)
+def _get_parsing_type(type_: Any, *, type_name: Optional[NameFactory] = None) -> Any:
+    from pydantic.main import create_model
+
+    if type_name is None:
+        type_name = _generate_parsing_type_name
+    if not isinstance(type_name, str):
+        type_name = type_name(type_)
+    return create_model(type_name, __root__=(type_, ...))
+
+
+T = TypeVar('T')
+
+
+def parse_obj_as(type_: Type[T], obj: Any, *, type_name: Optional[NameFactory] = None) -> T:
+    model_type = _get_parsing_type(type_, type_name=type_name)  # type: ignore[arg-type]
+    return model_type(__root__=obj).__root__
+
+
+def parse_file_as(
+    type_: Type[T],
+    path: Union[str, Path],
+    *,
+    content_type: str = None,
+    encoding: str = 'utf8',
+    proto: Protocol = None,
+    allow_pickle: bool = False,
+    json_loads: Callable[[str], Any] = json.loads,
+    type_name: Optional[NameFactory] = None,
+) -> T:
+    obj = load_file(
+        path,
+        proto=proto,
+        content_type=content_type,
+        encoding=encoding,
+        allow_pickle=allow_pickle,
+        json_loads=json_loads,
+    )
+    return parse_obj_as(type_, obj, type_name=type_name)
+
+
+def parse_raw_as(
+    type_: Type[T],
+    b: StrBytes,
+    *,
+    content_type: str = None,
+    encoding: str = 'utf8',
+    proto: Protocol = None,
+    allow_pickle: bool = False,
+    json_loads: Callable[[str], Any] = json.loads,
+    type_name: Optional[NameFactory] = None,
+) -> T:
+    obj = load_str_bytes(
+        b,
+        proto=proto,
+        content_type=content_type,
+        encoding=encoding,
+        allow_pickle=allow_pickle,
+        json_loads=json_loads,
+    )
+    return parse_obj_as(type_, obj, type_name=type_name)
+
+
+def schema_of(type_: Any, *, title: Optional[NameFactory] = None, **schema_kwargs: Any) -> 'DictStrAny':
+    """Generate a JSON schema (as dict) for the passed model or dynamically generated one"""
+    return _get_parsing_type(type_, type_name=title).schema(**schema_kwargs)
+
+
+def schema_json_of(type_: Any, *, title: Optional[NameFactory] = None, **schema_json_kwargs: Any) -> str:
+    """Generate a JSON schema (as JSON) for the passed model or dynamically generated one"""
+    return _get_parsing_type(type_, type_name=title).schema_json(**schema_json_kwargs)
diff --git a/myenv/lib/python3.9/site-packages/pydantic/types.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/types.cpython-39-darwin.so
new file mode 100755
index 0000000..61d71ed
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/types.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/types.py b/myenv/lib/python3.9/site-packages/pydantic/types.py
new file mode 100644
index 0000000..2d0cc18
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/types.py
@@ -0,0 +1,1118 @@
+import math
+import re
+import warnings
+from datetime import date
+from decimal import Decimal
+from enum import Enum
+from pathlib import Path
+from types import new_class
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    FrozenSet,
+    List,
+    Optional,
+    Pattern,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+from uuid import UUID
+from weakref import WeakSet
+
+from . import errors
+from .datetime_parse import parse_date
+from .utils import import_string, update_not_none
+from .validators import (
+    bytes_validator,
+    constr_length_validator,
+    constr_lower,
+    constr_strip_whitespace,
+    decimal_validator,
+    float_validator,
+    frozenset_validator,
+    int_validator,
+    list_validator,
+    number_multiple_validator,
+    number_size_validator,
+    path_exists_validator,
+    path_validator,
+    set_validator,
+    str_validator,
+    strict_bytes_validator,
+    strict_float_validator,
+    strict_int_validator,
+    strict_str_validator,
+)
+
+__all__ = [
+    'NoneStr',
+    'NoneBytes',
+    'StrBytes',
+    'NoneStrBytes',
+    'StrictStr',
+    'ConstrainedBytes',
+    'conbytes',
+    'ConstrainedList',
+    'conlist',
+    'ConstrainedSet',
+    'conset',
+    'ConstrainedFrozenSet',
+    'confrozenset',
+    'ConstrainedStr',
+    'constr',
+    'PyObject',
+    'ConstrainedInt',
+    'conint',
+    'PositiveInt',
+    'NegativeInt',
+    'NonNegativeInt',
+    'NonPositiveInt',
+    'ConstrainedFloat',
+    'confloat',
+    'PositiveFloat',
+    'NegativeFloat',
+    'NonNegativeFloat',
+    'NonPositiveFloat',
+    'ConstrainedDecimal',
+    'condecimal',
+    'UUID1',
+    'UUID3',
+    'UUID4',
+    'UUID5',
+    'FilePath',
+    'DirectoryPath',
+    'Json',
+    'JsonWrapper',
+    'SecretStr',
+    'SecretBytes',
+    'StrictBool',
+    'StrictBytes',
+    'StrictInt',
+    'StrictFloat',
+    'PaymentCardNumber',
+    'ByteSize',
+    'PastDate',
+    'FutureDate',
+]
+
+NoneStr = Optional[str]
+NoneBytes = Optional[bytes]
+StrBytes = Union[str, bytes]
+NoneStrBytes = Optional[StrBytes]
+OptionalInt = Optional[int]
+OptionalIntFloat = Union[OptionalInt, float]
+OptionalIntFloatDecimal = Union[OptionalIntFloat, Decimal]
+StrIntFloat = Union[str, int, float]
+
+if TYPE_CHECKING:
+    from .dataclasses import Dataclass
+    from .main import BaseModel
+    from .typing import CallableGenerator
+
+    ModelOrDc = Type[Union['BaseModel', 'Dataclass']]
+
+T = TypeVar('T')
+_DEFINED_TYPES: 'WeakSet[type]' = WeakSet()
+
+
+@overload
+def _registered(typ: Type[T]) -> Type[T]:
+    pass
+
+
+@overload
+def _registered(typ: 'ConstrainedNumberMeta') -> 'ConstrainedNumberMeta':
+    pass
+
+
+def _registered(typ: Union[Type[T], 'ConstrainedNumberMeta']) -> Union[Type[T], 'ConstrainedNumberMeta']:
+    # In order to generate valid examples of constrained types, Hypothesis needs
+    # to inspect the type object - so we keep a weakref to each contype object
+    # until it can be registered.  When (or if) our Hypothesis plugin is loaded,
+    # it monkeypatches this function.
+    # If Hypothesis is never used, the total effect is to keep a weak reference
+    # which has minimal memory usage and doesn't even affect garbage collection.
+    _DEFINED_TYPES.add(typ)
+    return typ
+
+
+class ConstrainedNumberMeta(type):
+    def __new__(cls, name: str, bases: Any, dct: Dict[str, Any]) -> 'ConstrainedInt':  # type: ignore
+        new_cls = cast('ConstrainedInt', type.__new__(cls, name, bases, dct))
+
+        if new_cls.gt is not None and new_cls.ge is not None:
+            raise errors.ConfigError('bounds gt and ge cannot be specified at the same time')
+        if new_cls.lt is not None and new_cls.le is not None:
+            raise errors.ConfigError('bounds lt and le cannot be specified at the same time')
+
+        return _registered(new_cls)  # type: ignore
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ BOOLEAN TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+if TYPE_CHECKING:
+    StrictBool = bool
+else:
+
+    class StrictBool(int):
+        """
+        StrictBool to allow for bools which are not type-coerced.
+        """
+
+        @classmethod
+        def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+            field_schema.update(type='boolean')
+
+        @classmethod
+        def __get_validators__(cls) -> 'CallableGenerator':
+            yield cls.validate
+
+        @classmethod
+        def validate(cls, value: Any) -> bool:
+            """
+            Ensure that we only allow bools.
+            """
+            if isinstance(value, bool):
+                return value
+
+            raise errors.StrictBoolError()
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ INTEGER TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+class ConstrainedInt(int, metaclass=ConstrainedNumberMeta):
+    strict: bool = False
+    gt: OptionalInt = None
+    ge: OptionalInt = None
+    lt: OptionalInt = None
+    le: OptionalInt = None
+    multiple_of: OptionalInt = None
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        update_not_none(
+            field_schema,
+            exclusiveMinimum=cls.gt,
+            exclusiveMaximum=cls.lt,
+            minimum=cls.ge,
+            maximum=cls.le,
+            multipleOf=cls.multiple_of,
+        )
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield strict_int_validator if cls.strict else int_validator
+        yield number_size_validator
+        yield number_multiple_validator
+
+
+def conint(
+    *, strict: bool = False, gt: int = None, ge: int = None, lt: int = None, le: int = None, multiple_of: int = None
+) -> Type[int]:
+    # use kwargs then define conf in a dict to aid with IDE type hinting
+    namespace = dict(strict=strict, gt=gt, ge=ge, lt=lt, le=le, multiple_of=multiple_of)
+    return type('ConstrainedIntValue', (ConstrainedInt,), namespace)
+
+
+if TYPE_CHECKING:
+    PositiveInt = int
+    NegativeInt = int
+    NonPositiveInt = int
+    NonNegativeInt = int
+    StrictInt = int
+else:
+
+    class PositiveInt(ConstrainedInt):
+        gt = 0
+
+    class NegativeInt(ConstrainedInt):
+        lt = 0
+
+    class NonPositiveInt(ConstrainedInt):
+        le = 0
+
+    class NonNegativeInt(ConstrainedInt):
+        ge = 0
+
+    class StrictInt(ConstrainedInt):
+        strict = True
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ FLOAT TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+class ConstrainedFloat(float, metaclass=ConstrainedNumberMeta):
+    strict: bool = False
+    gt: OptionalIntFloat = None
+    ge: OptionalIntFloat = None
+    lt: OptionalIntFloat = None
+    le: OptionalIntFloat = None
+    multiple_of: OptionalIntFloat = None
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        update_not_none(
+            field_schema,
+            exclusiveMinimum=cls.gt,
+            exclusiveMaximum=cls.lt,
+            minimum=cls.ge,
+            maximum=cls.le,
+            multipleOf=cls.multiple_of,
+        )
+        # Modify constraints to account for differences between IEEE floats and JSON
+        if field_schema.get('exclusiveMinimum') == -math.inf:
+            del field_schema['exclusiveMinimum']
+        if field_schema.get('minimum') == -math.inf:
+            del field_schema['minimum']
+        if field_schema.get('exclusiveMaximum') == math.inf:
+            del field_schema['exclusiveMaximum']
+        if field_schema.get('maximum') == math.inf:
+            del field_schema['maximum']
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield strict_float_validator if cls.strict else float_validator
+        yield number_size_validator
+        yield number_multiple_validator
+
+
+def confloat(
+    *,
+    strict: bool = False,
+    gt: float = None,
+    ge: float = None,
+    lt: float = None,
+    le: float = None,
+    multiple_of: float = None,
+) -> Type[float]:
+    # use kwargs then define conf in a dict to aid with IDE type hinting
+    namespace = dict(strict=strict, gt=gt, ge=ge, lt=lt, le=le, multiple_of=multiple_of)
+    return type('ConstrainedFloatValue', (ConstrainedFloat,), namespace)
+
+
+if TYPE_CHECKING:
+    PositiveFloat = float
+    NegativeFloat = float
+    NonPositiveFloat = float
+    NonNegativeFloat = float
+    StrictFloat = float
+else:
+
+    class PositiveFloat(ConstrainedFloat):
+        gt = 0
+
+    class NegativeFloat(ConstrainedFloat):
+        lt = 0
+
+    class NonPositiveFloat(ConstrainedFloat):
+        le = 0
+
+    class NonNegativeFloat(ConstrainedFloat):
+        ge = 0
+
+    class StrictFloat(ConstrainedFloat):
+        strict = True
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ BYTES TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+class ConstrainedBytes(bytes):
+    strip_whitespace = False
+    to_lower = False
+    min_length: OptionalInt = None
+    max_length: OptionalInt = None
+    strict: bool = False
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        update_not_none(field_schema, minLength=cls.min_length, maxLength=cls.max_length)
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield strict_bytes_validator if cls.strict else bytes_validator
+        yield constr_strip_whitespace
+        yield constr_lower
+        yield constr_length_validator
+
+
+def conbytes(
+    *,
+    strip_whitespace: bool = False,
+    to_lower: bool = False,
+    min_length: int = None,
+    max_length: int = None,
+    strict: bool = False,
+) -> Type[bytes]:
+    # use kwargs then define conf in a dict to aid with IDE type hinting
+    namespace = dict(
+        strip_whitespace=strip_whitespace,
+        to_lower=to_lower,
+        min_length=min_length,
+        max_length=max_length,
+        strict=strict,
+    )
+    return _registered(type('ConstrainedBytesValue', (ConstrainedBytes,), namespace))
+
+
+if TYPE_CHECKING:
+    StrictBytes = bytes
+else:
+
+    class StrictBytes(ConstrainedBytes):
+        strict = True
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ STRING TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+class ConstrainedStr(str):
+    strip_whitespace = False
+    to_lower = False
+    min_length: OptionalInt = None
+    max_length: OptionalInt = None
+    curtail_length: OptionalInt = None
+    regex: Optional[Pattern[str]] = None
+    strict = False
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        update_not_none(
+            field_schema,
+            minLength=cls.min_length,
+            maxLength=cls.max_length,
+            pattern=cls.regex and cls.regex.pattern,
+        )
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield strict_str_validator if cls.strict else str_validator
+        yield constr_strip_whitespace
+        yield constr_lower
+        yield constr_length_validator
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value: Union[str]) -> Union[str]:
+        if cls.curtail_length and len(value) > cls.curtail_length:
+            value = value[: cls.curtail_length]
+
+        if cls.regex:
+            if not cls.regex.match(value):
+                raise errors.StrRegexError(pattern=cls.regex.pattern)
+
+        return value
+
+
+def constr(
+    *,
+    strip_whitespace: bool = False,
+    to_lower: bool = False,
+    strict: bool = False,
+    min_length: int = None,
+    max_length: int = None,
+    curtail_length: int = None,
+    regex: str = None,
+) -> Type[str]:
+    # use kwargs then define conf in a dict to aid with IDE type hinting
+    namespace = dict(
+        strip_whitespace=strip_whitespace,
+        to_lower=to_lower,
+        strict=strict,
+        min_length=min_length,
+        max_length=max_length,
+        curtail_length=curtail_length,
+        regex=regex and re.compile(regex),
+    )
+    return _registered(type('ConstrainedStrValue', (ConstrainedStr,), namespace))
+
+
+if TYPE_CHECKING:
+    StrictStr = str
+else:
+
+    class StrictStr(ConstrainedStr):
+        strict = True
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SET TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+# This types superclass should be Set[T], but cython chokes on that...
+class ConstrainedSet(set):  # type: ignore
+    # Needed for pydantic to detect that this is a set
+    __origin__ = set
+    __args__: Set[Type[T]]  # type: ignore
+
+    min_items: Optional[int] = None
+    max_items: Optional[int] = None
+    item_type: Type[T]  # type: ignore
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls.set_length_validator
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        update_not_none(field_schema, minItems=cls.min_items, maxItems=cls.max_items)
+
+    @classmethod
+    def set_length_validator(cls, v: 'Optional[Set[T]]') -> 'Optional[Set[T]]':
+        if v is None:
+            return None
+
+        v = set_validator(v)
+        v_len = len(v)
+
+        if cls.min_items is not None and v_len < cls.min_items:
+            raise errors.SetMinLengthError(limit_value=cls.min_items)
+
+        if cls.max_items is not None and v_len > cls.max_items:
+            raise errors.SetMaxLengthError(limit_value=cls.max_items)
+
+        return v
+
+
+def conset(item_type: Type[T], *, min_items: int = None, max_items: int = None) -> Type[Set[T]]:
+    # __args__ is needed to conform to typing generics api
+    namespace = {'min_items': min_items, 'max_items': max_items, 'item_type': item_type, '__args__': [item_type]}
+    # We use new_class to be able to deal with Generic types
+    return new_class('ConstrainedSetValue', (ConstrainedSet,), {}, lambda ns: ns.update(namespace))
+
+
+# This types superclass should be FrozenSet[T], but cython chokes on that...
+class ConstrainedFrozenSet(frozenset):  # type: ignore
+    # Needed for pydantic to detect that this is a set
+    __origin__ = frozenset
+    __args__: FrozenSet[Type[T]]  # type: ignore
+
+    min_items: Optional[int] = None
+    max_items: Optional[int] = None
+    item_type: Type[T]  # type: ignore
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls.frozenset_length_validator
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        update_not_none(field_schema, minItems=cls.min_items, maxItems=cls.max_items)
+
+    @classmethod
+    def frozenset_length_validator(cls, v: 'Optional[FrozenSet[T]]') -> 'Optional[FrozenSet[T]]':
+        if v is None:
+            return None
+
+        v = frozenset_validator(v)
+        v_len = len(v)
+
+        if cls.min_items is not None and v_len < cls.min_items:
+            raise errors.FrozenSetMinLengthError(limit_value=cls.min_items)
+
+        if cls.max_items is not None and v_len > cls.max_items:
+            raise errors.FrozenSetMaxLengthError(limit_value=cls.max_items)
+
+        return v
+
+
+def confrozenset(item_type: Type[T], *, min_items: int = None, max_items: int = None) -> Type[FrozenSet[T]]:
+    # __args__ is needed to conform to typing generics api
+    namespace = {'min_items': min_items, 'max_items': max_items, 'item_type': item_type, '__args__': [item_type]}
+    # We use new_class to be able to deal with Generic types
+    return new_class('ConstrainedFrozenSetValue', (ConstrainedFrozenSet,), {}, lambda ns: ns.update(namespace))
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ LIST TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+# This types superclass should be List[T], but cython chokes on that...
+class ConstrainedList(list):  # type: ignore
+    # Needed for pydantic to detect that this is a list
+    __origin__ = list
+    __args__: Tuple[Type[T], ...]  # type: ignore
+
+    min_items: Optional[int] = None
+    max_items: Optional[int] = None
+    unique_items: Optional[bool] = None
+    item_type: Type[T]  # type: ignore
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls.list_length_validator
+        if cls.unique_items:
+            yield cls.unique_items_validator
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        update_not_none(field_schema, minItems=cls.min_items, maxItems=cls.max_items, uniqueItems=cls.unique_items)
+
+    @classmethod
+    def list_length_validator(cls, v: 'Optional[List[T]]') -> 'Optional[List[T]]':
+        if v is None:
+            return None
+
+        v = list_validator(v)
+        v_len = len(v)
+
+        if cls.min_items is not None and v_len < cls.min_items:
+            raise errors.ListMinLengthError(limit_value=cls.min_items)
+
+        if cls.max_items is not None and v_len > cls.max_items:
+            raise errors.ListMaxLengthError(limit_value=cls.max_items)
+
+        return v
+
+    @classmethod
+    def unique_items_validator(cls, v: 'List[T]') -> 'List[T]':
+        for i, value in enumerate(v, start=1):
+            if value in v[i:]:
+                raise errors.ListUniqueItemsError()
+
+        return v
+
+
+def conlist(
+    item_type: Type[T], *, min_items: int = None, max_items: int = None, unique_items: bool = None
+) -> Type[List[T]]:
+    # __args__ is needed to conform to typing generics api
+    namespace = dict(
+        min_items=min_items, max_items=max_items, unique_items=unique_items, item_type=item_type, __args__=(item_type,)
+    )
+    # We use new_class to be able to deal with Generic types
+    return new_class('ConstrainedListValue', (ConstrainedList,), {}, lambda ns: ns.update(namespace))
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ PYOBJECT TYPE ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+if TYPE_CHECKING:
+    PyObject = Callable[..., Any]
+else:
+
+    class PyObject:
+        validate_always = True
+
+        @classmethod
+        def __get_validators__(cls) -> 'CallableGenerator':
+            yield cls.validate
+
+        @classmethod
+        def validate(cls, value: Any) -> Any:
+            if isinstance(value, Callable):
+                return value
+
+            try:
+                value = str_validator(value)
+            except errors.StrError:
+                raise errors.PyObjectError(error_message='value is neither a valid import path not a valid callable')
+
+            try:
+                return import_string(value)
+            except ImportError as e:
+                raise errors.PyObjectError(error_message=str(e))
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ DECIMAL TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+class ConstrainedDecimal(Decimal, metaclass=ConstrainedNumberMeta):
+    gt: OptionalIntFloatDecimal = None
+    ge: OptionalIntFloatDecimal = None
+    lt: OptionalIntFloatDecimal = None
+    le: OptionalIntFloatDecimal = None
+    max_digits: OptionalInt = None
+    decimal_places: OptionalInt = None
+    multiple_of: OptionalIntFloatDecimal = None
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        update_not_none(
+            field_schema,
+            exclusiveMinimum=cls.gt,
+            exclusiveMaximum=cls.lt,
+            minimum=cls.ge,
+            maximum=cls.le,
+            multipleOf=cls.multiple_of,
+        )
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield decimal_validator
+        yield number_size_validator
+        yield number_multiple_validator
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value: Decimal) -> Decimal:
+        digit_tuple, exponent = value.as_tuple()[1:]
+        if exponent in {'F', 'n', 'N'}:
+            raise errors.DecimalIsNotFiniteError()
+
+        if exponent >= 0:
+            # A positive exponent adds that many trailing zeros.
+            digits = len(digit_tuple) + exponent
+            decimals = 0
+        else:
+            # If the absolute value of the negative exponent is larger than the
+            # number of digits, then it's the same as the number of digits,
+            # because it'll consume all of the digits in digit_tuple and then
+            # add abs(exponent) - len(digit_tuple) leading zeros after the
+            # decimal point.
+            if abs(exponent) > len(digit_tuple):
+                digits = decimals = abs(exponent)
+            else:
+                digits = len(digit_tuple)
+                decimals = abs(exponent)
+        whole_digits = digits - decimals
+
+        if cls.max_digits is not None and digits > cls.max_digits:
+            raise errors.DecimalMaxDigitsError(max_digits=cls.max_digits)
+
+        if cls.decimal_places is not None and decimals > cls.decimal_places:
+            raise errors.DecimalMaxPlacesError(decimal_places=cls.decimal_places)
+
+        if cls.max_digits is not None and cls.decimal_places is not None:
+            expected = cls.max_digits - cls.decimal_places
+            if whole_digits > expected:
+                raise errors.DecimalWholeDigitsError(whole_digits=expected)
+
+        return value
+
+
+def condecimal(
+    *,
+    gt: Decimal = None,
+    ge: Decimal = None,
+    lt: Decimal = None,
+    le: Decimal = None,
+    max_digits: int = None,
+    decimal_places: int = None,
+    multiple_of: Decimal = None,
+) -> Type[Decimal]:
+    # use kwargs then define conf in a dict to aid with IDE type hinting
+    namespace = dict(
+        gt=gt, ge=ge, lt=lt, le=le, max_digits=max_digits, decimal_places=decimal_places, multiple_of=multiple_of
+    )
+    return type('ConstrainedDecimalValue', (ConstrainedDecimal,), namespace)
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ UUID TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+if TYPE_CHECKING:
+    UUID1 = UUID
+    UUID3 = UUID
+    UUID4 = UUID
+    UUID5 = UUID
+else:
+
+    class UUID1(UUID):
+        _required_version = 1
+
+        @classmethod
+        def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+            field_schema.update(type='string', format=f'uuid{cls._required_version}')
+
+    class UUID3(UUID1):
+        _required_version = 3
+
+    class UUID4(UUID1):
+        _required_version = 4
+
+    class UUID5(UUID1):
+        _required_version = 5
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ PATH TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+if TYPE_CHECKING:
+    FilePath = Path
+    DirectoryPath = Path
+else:
+
+    class FilePath(Path):
+        @classmethod
+        def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+            field_schema.update(format='file-path')
+
+        @classmethod
+        def __get_validators__(cls) -> 'CallableGenerator':
+            yield path_validator
+            yield path_exists_validator
+            yield cls.validate
+
+        @classmethod
+        def validate(cls, value: Path) -> Path:
+            if not value.is_file():
+                raise errors.PathNotAFileError(path=value)
+
+            return value
+
+    class DirectoryPath(Path):
+        @classmethod
+        def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+            field_schema.update(format='directory-path')
+
+        @classmethod
+        def __get_validators__(cls) -> 'CallableGenerator':
+            yield path_validator
+            yield path_exists_validator
+            yield cls.validate
+
+        @classmethod
+        def validate(cls, value: Path) -> Path:
+            if not value.is_dir():
+                raise errors.PathNotADirectoryError(path=value)
+
+            return value
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JSON TYPE ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+class JsonWrapper:
+    pass
+
+
+class JsonMeta(type):
+    def __getitem__(self, t: Type[Any]) -> Type[JsonWrapper]:
+        return _registered(type('JsonWrapperValue', (JsonWrapper,), {'inner_type': t}))
+
+
+if TYPE_CHECKING:
+    Json = str
+else:
+
+    class Json(metaclass=JsonMeta):
+        @classmethod
+        def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+            field_schema.update(type='string', format='json-string')
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SECRET TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+class SecretStr:
+    min_length: OptionalInt = None
+    max_length: OptionalInt = None
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        update_not_none(
+            field_schema,
+            type='string',
+            writeOnly=True,
+            format='password',
+            minLength=cls.min_length,
+            maxLength=cls.max_length,
+        )
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls.validate
+        yield constr_length_validator
+
+    @classmethod
+    def validate(cls, value: Any) -> 'SecretStr':
+        if isinstance(value, cls):
+            return value
+        value = str_validator(value)
+        return cls(value)
+
+    def __init__(self, value: str):
+        self._secret_value = value
+
+    def __repr__(self) -> str:
+        return f"SecretStr('{self}')"
+
+    def __str__(self) -> str:
+        return '**********' if self._secret_value else ''
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, SecretStr) and self.get_secret_value() == other.get_secret_value()
+
+    def __len__(self) -> int:
+        return len(self._secret_value)
+
+    def display(self) -> str:
+        warnings.warn('`secret_str.display()` is deprecated, use `str(secret_str)` instead', DeprecationWarning)
+        return str(self)
+
+    def get_secret_value(self) -> str:
+        return self._secret_value
+
+
+class SecretBytes:
+    min_length: OptionalInt = None
+    max_length: OptionalInt = None
+
+    @classmethod
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+        update_not_none(
+            field_schema,
+            type='string',
+            writeOnly=True,
+            format='password',
+            minLength=cls.min_length,
+            maxLength=cls.max_length,
+        )
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls.validate
+        yield constr_length_validator
+
+    @classmethod
+    def validate(cls, value: Any) -> 'SecretBytes':
+        if isinstance(value, cls):
+            return value
+        value = bytes_validator(value)
+        return cls(value)
+
+    def __init__(self, value: bytes):
+        self._secret_value = value
+
+    def __repr__(self) -> str:
+        return f"SecretBytes(b'{self}')"
+
+    def __str__(self) -> str:
+        return '**********' if self._secret_value else ''
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, SecretBytes) and self.get_secret_value() == other.get_secret_value()
+
+    def __len__(self) -> int:
+        return len(self._secret_value)
+
+    def display(self) -> str:
+        warnings.warn('`secret_bytes.display()` is deprecated, use `str(secret_bytes)` instead', DeprecationWarning)
+        return str(self)
+
+    def get_secret_value(self) -> bytes:
+        return self._secret_value
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ PAYMENT CARD TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+class PaymentCardBrand(str, Enum):
+    # If you add another card type, please also add it to the
+    # Hypothesis strategy in `pydantic._hypothesis_plugin`.
+    amex = 'American Express'
+    mastercard = 'Mastercard'
+    visa = 'Visa'
+    other = 'other'
+
+    def __str__(self) -> str:
+        return self.value
+
+
+class PaymentCardNumber(str):
+    """
+    Based on: https://en.wikipedia.org/wiki/Payment_card_number
+    """
+
+    strip_whitespace: ClassVar[bool] = True
+    min_length: ClassVar[int] = 12
+    max_length: ClassVar[int] = 19
+    bin: str
+    last4: str
+    brand: PaymentCardBrand
+
+    def __init__(self, card_number: str):
+        self.bin = card_number[:6]
+        self.last4 = card_number[-4:]
+        self.brand = self._get_brand(card_number)
+
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield str_validator
+        yield constr_strip_whitespace
+        yield constr_length_validator
+        yield cls.validate_digits
+        yield cls.validate_luhn_check_digit
+        yield cls
+        yield cls.validate_length_for_brand
+
+    @property
+    def masked(self) -> str:
+        num_masked = len(self) - 10  # len(bin) + len(last4) == 10
+        return f'{self.bin}{"*" * num_masked}{self.last4}'
+
+    @classmethod
+    def validate_digits(cls, card_number: str) -> str:
+        if not card_number.isdigit():
+            raise errors.NotDigitError
+        return card_number
+
+    @classmethod
+    def validate_luhn_check_digit(cls, card_number: str) -> str:
+        """
+        Based on: https://en.wikipedia.org/wiki/Luhn_algorithm
+        """
+        sum_ = int(card_number[-1])
+        length = len(card_number)
+        parity = length % 2
+        for i in range(length - 1):
+            digit = int(card_number[i])
+            if i % 2 == parity:
+                digit *= 2
+            if digit > 9:
+                digit -= 9
+            sum_ += digit
+        valid = sum_ % 10 == 0
+        if not valid:
+            raise errors.LuhnValidationError
+        return card_number
+
+    @classmethod
+    def validate_length_for_brand(cls, card_number: 'PaymentCardNumber') -> 'PaymentCardNumber':
+        """
+        Validate length based on BIN for major brands:
+        https://en.wikipedia.org/wiki/Payment_card_number#Issuer_identification_number_(IIN)
+        """
+        required_length: Union[None, int, str] = None
+        if card_number.brand in PaymentCardBrand.mastercard:
+            required_length = 16
+            valid = len(card_number) == required_length
+        elif card_number.brand == PaymentCardBrand.visa:
+            required_length = '13, 16 or 19'
+            valid = len(card_number) in {13, 16, 19}
+        elif card_number.brand == PaymentCardBrand.amex:
+            required_length = 15
+            valid = len(card_number) == required_length
+        else:
+            valid = True
+        if not valid:
+            raise errors.InvalidLengthForBrand(brand=card_number.brand, required_length=required_length)
+        return card_number
+
+    @staticmethod
+    def _get_brand(card_number: str) -> PaymentCardBrand:
+        if card_number[0] == '4':
+            brand = PaymentCardBrand.visa
+        elif 51 <= int(card_number[:2]) <= 55:
+            brand = PaymentCardBrand.mastercard
+        elif card_number[:2] in {'34', '37'}:
+            brand = PaymentCardBrand.amex
+        else:
+            brand = PaymentCardBrand.other
+        return brand
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ BYTE SIZE TYPE ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+BYTE_SIZES = {
+    'b': 1,
+    'kb': 10**3,
+    'mb': 10**6,
+    'gb': 10**9,
+    'tb': 10**12,
+    'pb': 10**15,
+    'eb': 10**18,
+    'kib': 2**10,
+    'mib': 2**20,
+    'gib': 2**30,
+    'tib': 2**40,
+    'pib': 2**50,
+    'eib': 2**60,
+}
+BYTE_SIZES.update({k.lower()[0]: v for k, v in BYTE_SIZES.items() if 'i' not in k})
+byte_string_re = re.compile(r'^\s*(\d*\.?\d+)\s*(\w+)?', re.IGNORECASE)
+
+
+class ByteSize(int):
+    @classmethod
+    def __get_validators__(cls) -> 'CallableGenerator':
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, v: StrIntFloat) -> 'ByteSize':
+
+        try:
+            return cls(int(v))
+        except ValueError:
+            pass
+
+        str_match = byte_string_re.match(str(v))
+        if str_match is None:
+            raise errors.InvalidByteSize()
+
+        scalar, unit = str_match.groups()
+        if unit is None:
+            unit = 'b'
+
+        try:
+            unit_mult = BYTE_SIZES[unit.lower()]
+        except KeyError:
+            raise errors.InvalidByteSizeUnit(unit=unit)
+
+        return cls(int(float(scalar) * unit_mult))
+
+    def human_readable(self, decimal: bool = False) -> str:
+
+        if decimal:
+            divisor = 1000
+            units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
+            final_unit = 'EB'
+        else:
+            divisor = 1024
+            units = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB']
+            final_unit = 'EiB'
+
+        num = float(self)
+        for unit in units:
+            if abs(num) < divisor:
+                return f'{num:0.1f}{unit}'
+            num /= divisor
+
+        return f'{num:0.1f}{final_unit}'
+
+    def to(self, unit: str) -> float:
+
+        try:
+            unit_div = BYTE_SIZES[unit.lower()]
+        except KeyError:
+            raise errors.InvalidByteSizeUnit(unit=unit)
+
+        return self / unit_div
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ DATE TYPES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+if TYPE_CHECKING:
+    PastDate = date
+    FutureDate = date
+else:
+
+    class PastDate(date):
+        @classmethod
+        def __get_validators__(cls) -> 'CallableGenerator':
+            yield parse_date
+            yield cls.validate
+
+        @classmethod
+        def validate(cls, value: date) -> date:
+            if value >= date.today():
+                raise errors.DateNotInThePastError()
+
+            return value
+
+    class FutureDate(date):
+        @classmethod
+        def __get_validators__(cls) -> 'CallableGenerator':
+            yield parse_date
+            yield cls.validate
+
+        @classmethod
+        def validate(cls, value: date) -> date:
+            if value <= date.today():
+                raise errors.DateNotInTheFutureError()
+
+            return value
diff --git a/myenv/lib/python3.9/site-packages/pydantic/typing.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/typing.cpython-39-darwin.so
new file mode 100755
index 0000000..f13bbfb
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/typing.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/typing.py b/myenv/lib/python3.9/site-packages/pydantic/typing.py
new file mode 100644
index 0000000..f9297ba
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/typing.py
@@ -0,0 +1,600 @@
+import sys
+from os import PathLike
+from typing import (  # type: ignore
+    TYPE_CHECKING,
+    AbstractSet,
+    Any,
+    ClassVar,
+    Dict,
+    Generator,
+    Iterable,
+    List,
+    Mapping,
+    NewType,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    _eval_type,
+    cast,
+    get_type_hints,
+)
+
+from typing_extensions import Annotated, Literal
+
+try:
+    from typing import _TypingBase as typing_base  # type: ignore
+except ImportError:
+    from typing import _Final as typing_base  # type: ignore
+
+try:
+    from typing import GenericAlias as TypingGenericAlias  # type: ignore
+except ImportError:
+    # python < 3.9 does not have GenericAlias (list[int], tuple[str, ...] and so on)
+    TypingGenericAlias = ()
+
+try:
+    from types import UnionType as TypesUnionType  # type: ignore
+except ImportError:
+    # python < 3.10 does not have UnionType (str | int, byte | bool and so on)
+    TypesUnionType = ()
+
+
+if sys.version_info < (3, 7):
+    if TYPE_CHECKING:
+
+        class ForwardRef:
+            def __init__(self, arg: Any):
+                pass
+
+            def _eval_type(self, globalns: Any, localns: Any) -> Any:
+                pass
+
+    else:
+        from typing import _ForwardRef as ForwardRef
+else:
+    from typing import ForwardRef
+
+
+if sys.version_info < (3, 7):
+
+    def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
+        return type_._eval_type(globalns, localns)
+
+elif sys.version_info < (3, 9):
+
+    def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
+        return type_._evaluate(globalns, localns)
+
+else:
+
+    def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
+        # Even though it is the right signature for python 3.9, mypy complains with
+        # `error: Too many arguments for "_evaluate" of "ForwardRef"` hence the cast...
+        return cast(Any, type_)._evaluate(globalns, localns, set())
+
+
+if sys.version_info < (3, 9):
+    # Ensure we always get all the whole `Annotated` hint, not just the annotated type.
+    # For 3.6 to 3.8, `get_type_hints` doesn't recognize `typing_extensions.Annotated`,
+    # so it already returns the full annotation
+    get_all_type_hints = get_type_hints
+
+else:
+
+    def get_all_type_hints(obj: Any, globalns: Any = None, localns: Any = None) -> Any:
+        return get_type_hints(obj, globalns, localns, include_extras=True)
+
+
+if sys.version_info < (3, 7):
+    from typing import Callable as Callable
+
+    AnyCallable = Callable[..., Any]
+    NoArgAnyCallable = Callable[[], Any]
+else:
+    from collections.abc import Callable as Callable
+    from typing import Callable as TypingCallable
+
+    AnyCallable = TypingCallable[..., Any]
+    NoArgAnyCallable = TypingCallable[[], Any]
+
+
+# Annotated[...] is implemented by returning an instance of one of these classes, depending on
+# python/typing_extensions version.
+AnnotatedTypeNames = {'AnnotatedMeta', '_AnnotatedAlias'}
+
+
+if sys.version_info < (3, 8):
+
+    def get_origin(t: Type[Any]) -> Optional[Type[Any]]:
+        if type(t).__name__ in AnnotatedTypeNames:
+            return cast(Type[Any], Annotated)  # mypy complains about _SpecialForm in py3.6
+        return getattr(t, '__origin__', None)
+
+else:
+    from typing import get_origin as _typing_get_origin
+
+    def get_origin(tp: Type[Any]) -> Optional[Type[Any]]:
+        """
+        We can't directly use `typing.get_origin` since we need a fallback to support
+        custom generic classes like `ConstrainedList`
+        It should be useless once https://github.com/cython/cython/issues/3537 is
+        solved and https://github.com/samuelcolvin/pydantic/pull/1753 is merged.
+        """
+        if type(tp).__name__ in AnnotatedTypeNames:
+            return cast(Type[Any], Annotated)  # mypy complains about _SpecialForm
+        return _typing_get_origin(tp) or getattr(tp, '__origin__', None)
+
+
+if sys.version_info < (3, 7):  # noqa: C901 (ignore complexity)
+
+    def get_args(t: Type[Any]) -> Tuple[Any, ...]:
+        """Simplest get_args compatibility layer possible.
+
+        The Python 3.6 typing module does not have `_GenericAlias` so
+        this won't work for everything. In particular this will not
+        support the `generics` module (we don't support generic models in
+        python 3.6).
+
+        """
+        if type(t).__name__ in AnnotatedTypeNames:
+            return t.__args__ + t.__metadata__
+        return getattr(t, '__args__', ())
+
+elif sys.version_info < (3, 8):  # noqa: C901
+    from typing import _GenericAlias
+
+    def get_args(t: Type[Any]) -> Tuple[Any, ...]:
+        """Compatibility version of get_args for python 3.7.
+
+        Mostly compatible with the python 3.8 `typing` module version
+        and able to handle almost all use cases.
+        """
+        if type(t).__name__ in AnnotatedTypeNames:
+            return t.__args__ + t.__metadata__
+        if isinstance(t, _GenericAlias):
+            res = t.__args__
+            if t.__origin__ is Callable and res and res[0] is not Ellipsis:
+                res = (list(res[:-1]), res[-1])
+            return res
+        return getattr(t, '__args__', ())
+
+else:
+    from typing import get_args as _typing_get_args
+
+    def _generic_get_args(tp: Type[Any]) -> Tuple[Any, ...]:
+        """
+        In python 3.9, `typing.Dict`, `typing.List`, ...
+        do have an empty `__args__` by default (instead of the generic ~T for example).
+        In order to still support `Dict` for example and consider it as `Dict[Any, Any]`,
+        we retrieve the `_nparams` value that tells us how many parameters it needs.
+        """
+        if hasattr(tp, '_nparams'):
+            return (Any,) * tp._nparams
+        return ()
+
+    def get_args(tp: Type[Any]) -> Tuple[Any, ...]:
+        """Get type arguments with all substitutions performed.
+
+        For unions, basic simplifications used by Union constructor are performed.
+        Examples::
+            get_args(Dict[str, int]) == (str, int)
+            get_args(int) == ()
+            get_args(Union[int, Union[T, int], str][int]) == (int, str)
+            get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
+            get_args(Callable[[], T][int]) == ([], int)
+        """
+        if type(tp).__name__ in AnnotatedTypeNames:
+            return tp.__args__ + tp.__metadata__
+        # the fallback is needed for the same reasons as `get_origin` (see above)
+        return _typing_get_args(tp) or getattr(tp, '__args__', ()) or _generic_get_args(tp)
+
+
+if sys.version_info < (3, 9):
+
+    def convert_generics(tp: Type[Any]) -> Type[Any]:
+        """Python 3.9 and older only supports generics from `typing` module.
+        They convert strings to ForwardRef automatically.
+
+        Examples::
+            typing.List['Hero'] == typing.List[ForwardRef('Hero')]
+        """
+        return tp
+
+else:
+    from typing import _UnionGenericAlias  # type: ignore
+
+    from typing_extensions import _AnnotatedAlias
+
+    def convert_generics(tp: Type[Any]) -> Type[Any]:
+        """
+        Recursively searches for `str` type hints and replaces them with ForwardRef.
+
+        Examples::
+            convert_generics(list['Hero']) == list[ForwardRef('Hero')]
+            convert_generics(dict['Hero', 'Team']) == dict[ForwardRef('Hero'), ForwardRef('Team')]
+            convert_generics(typing.Dict['Hero', 'Team']) == typing.Dict[ForwardRef('Hero'), ForwardRef('Team')]
+            convert_generics(list[str | 'Hero'] | int) == list[str | ForwardRef('Hero')] | int
+        """
+        origin = get_origin(tp)
+        if not origin or not hasattr(tp, '__args__'):
+            return tp
+
+        args = get_args(tp)
+
+        # typing.Annotated needs special treatment
+        if origin is Annotated:
+            return _AnnotatedAlias(convert_generics(args[0]), args[1:])
+
+        # recursively replace `str` instances inside of `GenericAlias` with `ForwardRef(arg)`
+        converted = tuple(
+            ForwardRef(arg) if isinstance(arg, str) and isinstance(tp, TypingGenericAlias) else convert_generics(arg)
+            for arg in args
+        )
+
+        if converted == args:
+            return tp
+        elif isinstance(tp, TypingGenericAlias):
+            return TypingGenericAlias(origin, converted)
+        elif isinstance(tp, TypesUnionType):
+            # recreate types.UnionType (PEP604, Python >= 3.10)
+            return _UnionGenericAlias(origin, converted)
+        else:
+            try:
+                setattr(tp, '__args__', converted)
+            except AttributeError:
+                pass
+            return tp
+
+
+if sys.version_info < (3, 10):
+
+    def is_union(tp: Optional[Type[Any]]) -> bool:
+        return tp is Union
+
+    WithArgsTypes = (TypingGenericAlias,)
+
+else:
+    import types
+    import typing
+
+    def is_union(tp: Optional[Type[Any]]) -> bool:
+        return tp is Union or tp is types.UnionType  # noqa: E721
+
+    WithArgsTypes = (typing._GenericAlias, types.GenericAlias, types.UnionType)
+
+
+if sys.version_info < (3, 9):
+    StrPath = Union[str, PathLike]
+else:
+    StrPath = Union[str, PathLike]
+    # TODO: Once we switch to Cython 3 to handle generics properly
+    #  (https://github.com/cython/cython/issues/2753), use following lines instead
+    #  of the one above
+    # # os.PathLike only becomes subscriptable from Python 3.9 onwards
+    # StrPath = Union[str, PathLike[str]]
+
+
+if TYPE_CHECKING:
+    from .fields import ModelField
+
+    TupleGenerator = Generator[Tuple[str, Any], None, None]
+    DictStrAny = Dict[str, Any]
+    DictAny = Dict[Any, Any]
+    SetStr = Set[str]
+    ListStr = List[str]
+    IntStr = Union[int, str]
+    AbstractSetIntStr = AbstractSet[IntStr]
+    DictIntStrAny = Dict[IntStr, Any]
+    MappingIntStrAny = Mapping[IntStr, Any]
+    CallableGenerator = Generator[AnyCallable, None, None]
+    ReprArgs = Sequence[Tuple[Optional[str], Any]]
+    AnyClassMethod = classmethod[Any]
+
+__all__ = (
+    'ForwardRef',
+    'Callable',
+    'AnyCallable',
+    'NoArgAnyCallable',
+    'NoneType',
+    'is_none_type',
+    'display_as_type',
+    'resolve_annotations',
+    'is_callable_type',
+    'is_literal_type',
+    'all_literal_values',
+    'is_namedtuple',
+    'is_typeddict',
+    'is_new_type',
+    'new_type_supertype',
+    'is_classvar',
+    'update_field_forward_refs',
+    'update_model_forward_refs',
+    'TupleGenerator',
+    'DictStrAny',
+    'DictAny',
+    'SetStr',
+    'ListStr',
+    'IntStr',
+    'AbstractSetIntStr',
+    'DictIntStrAny',
+    'CallableGenerator',
+    'ReprArgs',
+    'AnyClassMethod',
+    'CallableGenerator',
+    'WithArgsTypes',
+    'get_args',
+    'get_origin',
+    'get_sub_types',
+    'typing_base',
+    'get_all_type_hints',
+    'is_union',
+    'StrPath',
+)
+
+
+NoneType = None.__class__
+
+
+NONE_TYPES: Tuple[Any, Any, Any] = (None, NoneType, Literal[None])
+
+
+if sys.version_info < (3, 8):
+    # Even though this implementation is slower, we need it for python 3.6/3.7:
+    # In python 3.6/3.7 "Literal" is not a builtin type and uses a different
+    # mechanism.
+    # for this reason `Literal[None] is Literal[None]` evaluates to `False`,
+    # breaking the faster implementation used for the other python versions.
+
+    def is_none_type(type_: Any) -> bool:
+        return type_ in NONE_TYPES
+
+elif sys.version_info[:2] == (3, 8):
+    # We can use the fast implementation for 3.8 but there is a very weird bug
+    # where it can fail for `Literal[None]`.
+    # We just need to redefine a useless `Literal[None]` inside the function body to fix this
+
+    def is_none_type(type_: Any) -> bool:
+        Literal[None]  # fix edge case
+        for none_type in NONE_TYPES:
+            if type_ is none_type:
+                return True
+        return False
+
+else:
+
+    def is_none_type(type_: Any) -> bool:
+        for none_type in NONE_TYPES:
+            if type_ is none_type:
+                return True
+        return False
+
+
+def display_as_type(v: Type[Any]) -> str:
+    if not isinstance(v, typing_base) and not isinstance(v, WithArgsTypes) and not isinstance(v, type):
+        v = v.__class__
+
+    if is_union(get_origin(v)):
+        return f'Union[{", ".join(map(display_as_type, get_args(v)))}]'
+
+    if isinstance(v, WithArgsTypes):
+        # Generic alias are constructs like `list[int]`
+        return str(v).replace('typing.', '')
+
+    try:
+        return v.__name__
+    except AttributeError:
+        # happens with typing objects
+        return str(v).replace('typing.', '')
+
+
+def resolve_annotations(raw_annotations: Dict[str, Type[Any]], module_name: Optional[str]) -> Dict[str, Type[Any]]:
+    """
+    Partially taken from typing.get_type_hints.
+
+    Resolve string or ForwardRef annotations into type objects if possible.
+    """
+    base_globals: Optional[Dict[str, Any]] = None
+    if module_name:
+        try:
+            module = sys.modules[module_name]
+        except KeyError:
+            # happens occasionally, see https://github.com/samuelcolvin/pydantic/issues/2363
+            pass
+        else:
+            base_globals = module.__dict__
+
+    annotations = {}
+    for name, value in raw_annotations.items():
+        if isinstance(value, str):
+            if (3, 10) > sys.version_info >= (3, 9, 8) or sys.version_info >= (3, 10, 1):
+                value = ForwardRef(value, is_argument=False, is_class=True)
+            elif sys.version_info >= (3, 7):
+                value = ForwardRef(value, is_argument=False)
+            else:
+                value = ForwardRef(value)
+        try:
+            value = _eval_type(value, base_globals, None)
+        except NameError:
+            # this is ok, it can be fixed with update_forward_refs
+            pass
+        annotations[name] = value
+    return annotations
+
+
+def is_callable_type(type_: Type[Any]) -> bool:
+    return type_ is Callable or get_origin(type_) is Callable
+
+
+if sys.version_info >= (3, 7):
+
+    def is_literal_type(type_: Type[Any]) -> bool:
+        return Literal is not None and get_origin(type_) is Literal
+
+    def literal_values(type_: Type[Any]) -> Tuple[Any, ...]:
+        return get_args(type_)
+
+else:
+
+    def is_literal_type(type_: Type[Any]) -> bool:
+        return Literal is not None and hasattr(type_, '__values__') and type_ == Literal[type_.__values__]
+
+    def literal_values(type_: Type[Any]) -> Tuple[Any, ...]:
+        return type_.__values__
+
+
+def all_literal_values(type_: Type[Any]) -> Tuple[Any, ...]:
+    """
+    This method is used to retrieve all Literal values as
+    Literal can be used recursively (see https://www.python.org/dev/peps/pep-0586)
+    e.g. `Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]`
+    """
+    if not is_literal_type(type_):
+        return (type_,)
+
+    values = literal_values(type_)
+    return tuple(x for value in values for x in all_literal_values(value))
+
+
+def is_namedtuple(type_: Type[Any]) -> bool:
+    """
+    Check if a given class is a named tuple.
+    It can be either a `typing.NamedTuple` or `collections.namedtuple`
+    """
+    from .utils import lenient_issubclass
+
+    return lenient_issubclass(type_, tuple) and hasattr(type_, '_fields')
+
+
+def is_typeddict(type_: Type[Any]) -> bool:
+    """
+    Check if a given class is a typed dict (from `typing` or `typing_extensions`)
+    In 3.10, there will be a public method (https://docs.python.org/3.10/library/typing.html#typing.is_typeddict)
+    """
+    from .utils import lenient_issubclass
+
+    return lenient_issubclass(type_, dict) and hasattr(type_, '__total__')
+
+
+test_type = NewType('test_type', str)
+
+
+def is_new_type(type_: Type[Any]) -> bool:
+    """
+    Check whether type_ was created using typing.NewType
+    """
+    return isinstance(type_, test_type.__class__) and hasattr(type_, '__supertype__')  # type: ignore
+
+
+def new_type_supertype(type_: Type[Any]) -> Type[Any]:
+    while hasattr(type_, '__supertype__'):
+        type_ = type_.__supertype__
+    return type_
+
+
+def _check_classvar(v: Optional[Type[Any]]) -> bool:
+    if v is None:
+        return False
+
+    return v.__class__ == ClassVar.__class__ and (sys.version_info < (3, 7) or getattr(v, '_name', None) == 'ClassVar')
+
+
+def is_classvar(ann_type: Type[Any]) -> bool:
+    if _check_classvar(ann_type) or _check_classvar(get_origin(ann_type)):
+        return True
+
+    # this is an ugly workaround for class vars that contain forward references and are therefore themselves
+    # forward references, see #3679
+    if ann_type.__class__ == ForwardRef and ann_type.__forward_arg__.startswith('ClassVar['):
+        return True
+
+    return False
+
+
+def update_field_forward_refs(field: 'ModelField', globalns: Any, localns: Any) -> None:
+    """
+    Try to update ForwardRefs on fields based on this ModelField, globalns and localns.
+    """
+    if field.type_.__class__ == ForwardRef:
+        field.type_ = evaluate_forwardref(field.type_, globalns, localns or None)
+        field.prepare()
+
+    if field.sub_fields:
+        for sub_f in field.sub_fields:
+            update_field_forward_refs(sub_f, globalns=globalns, localns=localns)
+
+    if field.discriminator_key is not None:
+        field.prepare_discriminated_union_sub_fields()
+
+
+def update_model_forward_refs(
+    model: Type[Any],
+    fields: Iterable['ModelField'],
+    json_encoders: Dict[Union[Type[Any], str], AnyCallable],
+    localns: 'DictStrAny',
+    exc_to_suppress: Tuple[Type[BaseException], ...] = (),
+) -> None:
+    """
+    Try to update model fields ForwardRefs based on model and localns.
+    """
+    if model.__module__ in sys.modules:
+        globalns = sys.modules[model.__module__].__dict__.copy()
+    else:
+        globalns = {}
+
+    globalns.setdefault(model.__name__, model)
+
+    for f in fields:
+        try:
+            update_field_forward_refs(f, globalns=globalns, localns=localns)
+        except exc_to_suppress:
+            pass
+
+    for key in set(json_encoders.keys()):
+        if isinstance(key, str):
+            fr: ForwardRef = ForwardRef(key)
+        elif isinstance(key, ForwardRef):
+            fr = key
+        else:
+            continue
+
+        try:
+            new_key = evaluate_forwardref(fr, globalns, localns or None)
+        except exc_to_suppress:  # pragma: no cover
+            continue
+
+        json_encoders[new_key] = json_encoders.pop(key)
+
+
+def get_class(type_: Type[Any]) -> Union[None, bool, Type[Any]]:
+    """
+    Tries to get the class of a Type[T] annotation. Returns True if Type is used
+    without brackets. Otherwise returns None.
+    """
+    try:
+        origin = get_origin(type_)
+        if origin is None:  # Python 3.6
+            origin = type_
+        if issubclass(origin, Type):  # type: ignore
+            if not get_args(type_) or not isinstance(get_args(type_)[0], type):
+                return True
+            return get_args(type_)[0]
+    except (AttributeError, TypeError):
+        pass
+    return None
+
+
+def get_sub_types(tp: Any) -> List[Any]:
+    """
+    Return all the types that are allowed by type `tp`
+    `tp` can be a `Union` of allowed types or an `Annotated` type
+    """
+    origin = get_origin(tp)
+    if origin is Annotated:
+        return get_sub_types(get_args(tp)[0])
+    elif is_union(origin):
+        return [x for t in get_args(tp) for x in get_sub_types(t)]
+    else:
+        return [tp]
diff --git a/myenv/lib/python3.9/site-packages/pydantic/utils.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/utils.cpython-39-darwin.so
new file mode 100755
index 0000000..f1f0083
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/utils.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/utils.py b/myenv/lib/python3.9/site-packages/pydantic/utils.py
new file mode 100644
index 0000000..a3c87f4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/utils.py
@@ -0,0 +1,789 @@
+import warnings
+import weakref
+from collections import OrderedDict, defaultdict, deque
+from copy import deepcopy
+from itertools import islice, zip_longest
+from types import BuiltinFunctionType, CodeType, FunctionType, GeneratorType, LambdaType, ModuleType
+from typing import (
+    TYPE_CHECKING,
+    AbstractSet,
+    Any,
+    Callable,
+    Collection,
+    Dict,
+    Generator,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+from typing_extensions import Annotated
+
+from .errors import ConfigError
+from .typing import (
+    NoneType,
+    WithArgsTypes,
+    all_literal_values,
+    display_as_type,
+    get_args,
+    get_origin,
+    is_literal_type,
+    is_union,
+)
+from .version import version_info
+
+if TYPE_CHECKING:
+    from inspect import Signature
+    from pathlib import Path
+
+    from .config import BaseConfig
+    from .dataclasses import Dataclass
+    from .fields import ModelField
+    from .main import BaseModel
+    from .typing import AbstractSetIntStr, DictIntStrAny, IntStr, MappingIntStrAny, ReprArgs
+
+__all__ = (
+    'import_string',
+    'sequence_like',
+    'validate_field_name',
+    'lenient_isinstance',
+    'lenient_issubclass',
+    'in_ipython',
+    'deep_update',
+    'update_not_none',
+    'almost_equal_floats',
+    'get_model',
+    'to_camel',
+    'is_valid_field',
+    'smart_deepcopy',
+    'PyObjectStr',
+    'Representation',
+    'GetterDict',
+    'ValueItems',
+    'version_info',  # required here to match behaviour in v1.3
+    'ClassAttribute',
+    'path_type',
+    'ROOT_KEY',
+    'get_unique_discriminator_alias',
+    'get_discriminator_alias_and_values',
+    'LimitedDict',
+)
+
+ROOT_KEY = '__root__'
+# these are types that are returned unchanged by deepcopy
+IMMUTABLE_NON_COLLECTIONS_TYPES: Set[Type[Any]] = {
+    int,
+    float,
+    complex,
+    str,
+    bool,
+    bytes,
+    type,
+    NoneType,
+    FunctionType,
+    BuiltinFunctionType,
+    LambdaType,
+    weakref.ref,
+    CodeType,
+    # note: including ModuleType will differ from behaviour of deepcopy by not producing error.
+    # It might be not a good idea in general, but considering that this function used only internally
+    # against default values of fields, this will allow to actually have a field with module as default value
+    ModuleType,
+    NotImplemented.__class__,
+    Ellipsis.__class__,
+}
+
+# these are types that if empty, might be copied with simple copy() instead of deepcopy()
+BUILTIN_COLLECTIONS: Set[Type[Any]] = {
+    list,
+    set,
+    tuple,
+    frozenset,
+    dict,
+    OrderedDict,
+    defaultdict,
+    deque,
+}
+
+
+def import_string(dotted_path: str) -> Any:
+    """
+    Stolen approximately from django. Import a dotted module path and return the attribute/class designated by the
+    last name in the path. Raise ImportError if the import fails.
+    """
+    from importlib import import_module
+
+    try:
+        module_path, class_name = dotted_path.strip(' ').rsplit('.', 1)
+    except ValueError as e:
+        raise ImportError(f'"{dotted_path}" doesn\'t look like a module path') from e
+
+    module = import_module(module_path)
+    try:
+        return getattr(module, class_name)
+    except AttributeError as e:
+        raise ImportError(f'Module "{module_path}" does not define a "{class_name}" attribute') from e
+
+
+def truncate(v: Union[str], *, max_len: int = 80) -> str:
+    """
+    Truncate a value and add a unicode ellipsis (three dots) to the end if it was too long
+    """
+    warnings.warn('`truncate` is no-longer used by pydantic and is deprecated', DeprecationWarning)
+    if isinstance(v, str) and len(v) > (max_len - 2):
+        # -3 so quote + string + … + quote has correct length
+        return (v[: (max_len - 3)] + '…').__repr__()
+    try:
+        v = v.__repr__()
+    except TypeError:
+        v = v.__class__.__repr__(v)  # in case v is a type
+    if len(v) > max_len:
+        v = v[: max_len - 1] + '…'
+    return v
+
+
+def sequence_like(v: Any) -> bool:
+    return isinstance(v, (list, tuple, set, frozenset, GeneratorType, deque))
+
+
+def validate_field_name(bases: List[Type['BaseModel']], field_name: str) -> None:
+    """
+    Ensure that the field's name does not shadow an existing attribute of the model.
+    """
+    for base in bases:
+        if getattr(base, field_name, None):
+            raise NameError(
+                f'Field name "{field_name}" shadows a BaseModel attribute; '
+                f'use a different field name with "alias=\'{field_name}\'".'
+            )
+
+
+def lenient_isinstance(o: Any, class_or_tuple: Union[Type[Any], Tuple[Type[Any], ...], None]) -> bool:
+    try:
+        return isinstance(o, class_or_tuple)  # type: ignore[arg-type]
+    except TypeError:
+        return False
+
+
+def lenient_issubclass(cls: Any, class_or_tuple: Union[Type[Any], Tuple[Type[Any], ...], None]) -> bool:
+    try:
+        return isinstance(cls, type) and issubclass(cls, class_or_tuple)  # type: ignore[arg-type]
+    except TypeError:
+        if isinstance(cls, WithArgsTypes):
+            return False
+        raise  # pragma: no cover
+
+
+def in_ipython() -> bool:
+    """
+    Check whether we're in an ipython environment, including jupyter notebooks.
+    """
+    try:
+        eval('__IPYTHON__')
+    except NameError:
+        return False
+    else:  # pragma: no cover
+        return True
+
+
+KeyType = TypeVar('KeyType')
+
+
+def deep_update(mapping: Dict[KeyType, Any], *updating_mappings: Dict[KeyType, Any]) -> Dict[KeyType, Any]:
+    updated_mapping = mapping.copy()
+    for updating_mapping in updating_mappings:
+        for k, v in updating_mapping.items():
+            if k in updated_mapping and isinstance(updated_mapping[k], dict) and isinstance(v, dict):
+                updated_mapping[k] = deep_update(updated_mapping[k], v)
+            else:
+                updated_mapping[k] = v
+    return updated_mapping
+
+
+def update_not_none(mapping: Dict[Any, Any], **update: Any) -> None:
+    mapping.update({k: v for k, v in update.items() if v is not None})
+
+
+def almost_equal_floats(value_1: float, value_2: float, *, delta: float = 1e-8) -> bool:
+    """
+    Return True if two floats are almost equal
+    """
+    return abs(value_1 - value_2) <= delta
+
+
+def generate_model_signature(
+    init: Callable[..., None], fields: Dict[str, 'ModelField'], config: Type['BaseConfig']
+) -> 'Signature':
+    """
+    Generate signature for model based on its fields
+    """
+    from inspect import Parameter, Signature, signature
+
+    from .config import Extra
+
+    present_params = signature(init).parameters.values()
+    merged_params: Dict[str, Parameter] = {}
+    var_kw = None
+    use_var_kw = False
+
+    for param in islice(present_params, 1, None):  # skip self arg
+        if param.kind is param.VAR_KEYWORD:
+            var_kw = param
+            continue
+        merged_params[param.name] = param
+
+    if var_kw:  # if custom init has no var_kw, fields which are not declared in it cannot be passed through
+        allow_names = config.allow_population_by_field_name
+        for field_name, field in fields.items():
+            param_name = field.alias
+            if field_name in merged_params or param_name in merged_params:
+                continue
+            elif not param_name.isidentifier():
+                if allow_names and field_name.isidentifier():
+                    param_name = field_name
+                else:
+                    use_var_kw = True
+                    continue
+
+            # TODO: replace annotation with actual expected types once #1055 solved
+            kwargs = {'default': field.default} if not field.required else {}
+            merged_params[param_name] = Parameter(
+                param_name, Parameter.KEYWORD_ONLY, annotation=field.outer_type_, **kwargs
+            )
+
+    if config.extra is Extra.allow:
+        use_var_kw = True
+
+    if var_kw and use_var_kw:
+        # Make sure the parameter for extra kwargs
+        # does not have the same name as a field
+        default_model_signature = [
+            ('__pydantic_self__', Parameter.POSITIONAL_OR_KEYWORD),
+            ('data', Parameter.VAR_KEYWORD),
+        ]
+        if [(p.name, p.kind) for p in present_params] == default_model_signature:
+            # if this is the standard model signature, use extra_data as the extra args name
+            var_kw_name = 'extra_data'
+        else:
+            # else start from var_kw
+            var_kw_name = var_kw.name
+
+        # generate a name that's definitely unique
+        while var_kw_name in fields:
+            var_kw_name += '_'
+        merged_params[var_kw_name] = var_kw.replace(name=var_kw_name)
+
+    return Signature(parameters=list(merged_params.values()), return_annotation=None)
+
+
+def get_model(obj: Union[Type['BaseModel'], Type['Dataclass']]) -> Type['BaseModel']:
+    from .main import BaseModel
+
+    try:
+        model_cls = obj.__pydantic_model__  # type: ignore
+    except AttributeError:
+        model_cls = obj
+
+    if not issubclass(model_cls, BaseModel):
+        raise TypeError('Unsupported type, must be either BaseModel or dataclass')
+    return model_cls
+
+
+def to_camel(string: str) -> str:
+    return ''.join(word.capitalize() for word in string.split('_'))
+
+
+T = TypeVar('T')
+
+
+def unique_list(
+    input_list: Union[List[T], Tuple[T, ...]],
+    *,
+    name_factory: Callable[[T], str] = str,
+) -> List[T]:
+    """
+    Make a list unique while maintaining order.
+    We update the list if another one with the same name is set
+    (e.g. root validator overridden in subclass)
+    """
+    result: List[T] = []
+    result_names: List[str] = []
+    for v in input_list:
+        v_name = name_factory(v)
+        if v_name not in result_names:
+            result_names.append(v_name)
+            result.append(v)
+        else:
+            result[result_names.index(v_name)] = v
+
+    return result
+
+
+class PyObjectStr(str):
+    """
+    String class where repr doesn't include quotes. Useful with Representation when you want to return a string
+    representation of something that valid (or pseudo-valid) python.
+    """
+
+    def __repr__(self) -> str:
+        return str(self)
+
+
+class Representation:
+    """
+    Mixin to provide __str__, __repr__, and __pretty__ methods. See #884 for more details.
+
+    __pretty__ is used by [devtools](https://python-devtools.helpmanual.io/) to provide human readable representations
+    of objects.
+    """
+
+    __slots__: Tuple[str, ...] = tuple()
+
+    def __repr_args__(self) -> 'ReprArgs':
+        """
+        Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden.
+
+        Can either return:
+        * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]`
+        * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]`
+        """
+        attrs = ((s, getattr(self, s)) for s in self.__slots__)
+        return [(a, v) for a, v in attrs if v is not None]
+
+    def __repr_name__(self) -> str:
+        """
+        Name of the instance's class, used in __repr__.
+        """
+        return self.__class__.__name__
+
+    def __repr_str__(self, join_str: str) -> str:
+        return join_str.join(repr(v) if a is None else f'{a}={v!r}' for a, v in self.__repr_args__())
+
+    def __pretty__(self, fmt: Callable[[Any], Any], **kwargs: Any) -> Generator[Any, None, None]:
+        """
+        Used by devtools (https://python-devtools.helpmanual.io/) to provide a human readable representations of objects
+        """
+        yield self.__repr_name__() + '('
+        yield 1
+        for name, value in self.__repr_args__():
+            if name is not None:
+                yield name + '='
+            yield fmt(value)
+            yield ','
+            yield 0
+        yield -1
+        yield ')'
+
+    def __str__(self) -> str:
+        return self.__repr_str__(' ')
+
+    def __repr__(self) -> str:
+        return f'{self.__repr_name__()}({self.__repr_str__(", ")})'
+
+
+class GetterDict(Representation):
+    """
+    Hack to make object's smell just enough like dicts for validate_model.
+
+    We can't inherit from Mapping[str, Any] because it upsets cython so we have to implement all methods ourselves.
+    """
+
+    __slots__ = ('_obj',)
+
+    def __init__(self, obj: Any):
+        self._obj = obj
+
+    def __getitem__(self, key: str) -> Any:
+        try:
+            return getattr(self._obj, key)
+        except AttributeError as e:
+            raise KeyError(key) from e
+
+    def get(self, key: Any, default: Any = None) -> Any:
+        return getattr(self._obj, key, default)
+
+    def extra_keys(self) -> Set[Any]:
+        """
+        We don't want to get any other attributes of obj if the model didn't explicitly ask for them
+        """
+        return set()
+
+    def keys(self) -> List[Any]:
+        """
+        Keys of the pseudo dictionary, uses a list not set so order information can be maintained like python
+        dictionaries.
+        """
+        return list(self)
+
+    def values(self) -> List[Any]:
+        return [self[k] for k in self]
+
+    def items(self) -> Iterator[Tuple[str, Any]]:
+        for k in self:
+            yield k, self.get(k)
+
+    def __iter__(self) -> Iterator[str]:
+        for name in dir(self._obj):
+            if not name.startswith('_'):
+                yield name
+
+    def __len__(self) -> int:
+        return sum(1 for _ in self)
+
+    def __contains__(self, item: Any) -> bool:
+        return item in self.keys()
+
+    def __eq__(self, other: Any) -> bool:
+        return dict(self) == dict(other.items())
+
+    def __repr_args__(self) -> 'ReprArgs':
+        return [(None, dict(self))]
+
+    def __repr_name__(self) -> str:
+        return f'GetterDict[{display_as_type(self._obj)}]'
+
+
+class ValueItems(Representation):
+    """
+    Class for more convenient calculation of excluded or included fields on values.
+    """
+
+    __slots__ = ('_items', '_type')
+
+    def __init__(self, value: Any, items: Union['AbstractSetIntStr', 'MappingIntStrAny']) -> None:
+        items = self._coerce_items(items)
+
+        if isinstance(value, (list, tuple)):
+            items = self._normalize_indexes(items, len(value))
+
+        self._items: 'MappingIntStrAny' = items
+
+    def is_excluded(self, item: Any) -> bool:
+        """
+        Check if item is fully excluded.
+
+        :param item: key or index of a value
+        """
+        return self.is_true(self._items.get(item))
+
+    def is_included(self, item: Any) -> bool:
+        """
+        Check if value is contained in self._items
+
+        :param item: key or index of value
+        """
+        return item in self._items
+
+    def for_element(self, e: 'IntStr') -> Optional[Union['AbstractSetIntStr', 'MappingIntStrAny']]:
+        """
+        :param e: key or index of element on value
+        :return: raw values for element if self._items is dict and contain needed element
+        """
+
+        item = self._items.get(e)
+        return item if not self.is_true(item) else None
+
+    def _normalize_indexes(self, items: 'MappingIntStrAny', v_length: int) -> 'DictIntStrAny':
+        """
+        :param items: dict or set of indexes which will be normalized
+        :param v_length: length of sequence indexes of which will be
+
+        >>> self._normalize_indexes({0: True, -2: True, -1: True}, 4)
+        {0: True, 2: True, 3: True}
+        >>> self._normalize_indexes({'__all__': True}, 4)
+        {0: True, 1: True, 2: True, 3: True}
+        """
+
+        normalized_items: 'DictIntStrAny' = {}
+        all_items = None
+        for i, v in items.items():
+            if not (isinstance(v, Mapping) or isinstance(v, AbstractSet) or self.is_true(v)):
+                raise TypeError(f'Unexpected type of exclude value for index "{i}" {v.__class__}')
+            if i == '__all__':
+                all_items = self._coerce_value(v)
+                continue
+            if not isinstance(i, int):
+                raise TypeError(
+                    'Excluding fields from a sequence of sub-models or dicts must be performed index-wise: '
+                    'expected integer keys or keyword "__all__"'
+                )
+            normalized_i = v_length + i if i < 0 else i
+            normalized_items[normalized_i] = self.merge(v, normalized_items.get(normalized_i))
+
+        if not all_items:
+            return normalized_items
+        if self.is_true(all_items):
+            for i in range(v_length):
+                normalized_items.setdefault(i, ...)
+            return normalized_items
+        for i in range(v_length):
+            normalized_item = normalized_items.setdefault(i, {})
+            if not self.is_true(normalized_item):
+                normalized_items[i] = self.merge(all_items, normalized_item)
+        return normalized_items
+
+    @classmethod
+    def merge(cls, base: Any, override: Any, intersect: bool = False) -> Any:
+        """
+        Merge a ``base`` item with an ``override`` item.
+
+        Both ``base`` and ``override`` are converted to dictionaries if possible.
+        Sets are converted to dictionaries with the sets entries as keys and
+        Ellipsis as values.
+
+        Each key-value pair existing in ``base`` is merged with ``override``,
+        while the rest of the key-value pairs are updated recursively with this function.
+
+        Merging takes place based on the "union" of keys if ``intersect`` is
+        set to ``False`` (default) and on the intersection of keys if
+        ``intersect`` is set to ``True``.
+        """
+        override = cls._coerce_value(override)
+        base = cls._coerce_value(base)
+        if override is None:
+            return base
+        if cls.is_true(base) or base is None:
+            return override
+        if cls.is_true(override):
+            return base if intersect else override
+
+        # intersection or union of keys while preserving ordering:
+        if intersect:
+            merge_keys = [k for k in base if k in override] + [k for k in override if k in base]
+        else:
+            merge_keys = list(base) + [k for k in override if k not in base]
+
+        merged: 'DictIntStrAny' = {}
+        for k in merge_keys:
+            merged_item = cls.merge(base.get(k), override.get(k), intersect=intersect)
+            if merged_item is not None:
+                merged[k] = merged_item
+
+        return merged
+
+    @staticmethod
+    def _coerce_items(items: Union['AbstractSetIntStr', 'MappingIntStrAny']) -> 'MappingIntStrAny':
+        if isinstance(items, Mapping):
+            pass
+        elif isinstance(items, AbstractSet):
+            items = dict.fromkeys(items, ...)
+        else:
+            class_name = getattr(items, '__class__', '???')
+            raise TypeError(f'Unexpected type of exclude value {class_name}')
+        return items
+
+    @classmethod
+    def _coerce_value(cls, value: Any) -> Any:
+        if value is None or cls.is_true(value):
+            return value
+        return cls._coerce_items(value)
+
+    @staticmethod
+    def is_true(v: Any) -> bool:
+        return v is True or v is ...
+
+    def __repr_args__(self) -> 'ReprArgs':
+        return [(None, self._items)]
+
+
+class ClassAttribute:
+    """
+    Hide class attribute from its instances
+    """
+
+    __slots__ = (
+        'name',
+        'value',
+    )
+
+    def __init__(self, name: str, value: Any) -> None:
+        self.name = name
+        self.value = value
+
+    def __get__(self, instance: Any, owner: Type[Any]) -> None:
+        if instance is None:
+            return self.value
+        raise AttributeError(f'{self.name!r} attribute of {owner.__name__!r} is class-only')
+
+
+path_types = {
+    'is_dir': 'directory',
+    'is_file': 'file',
+    'is_mount': 'mount point',
+    'is_symlink': 'symlink',
+    'is_block_device': 'block device',
+    'is_char_device': 'char device',
+    'is_fifo': 'FIFO',
+    'is_socket': 'socket',
+}
+
+
+def path_type(p: 'Path') -> str:
+    """
+    Find out what sort of thing a path is.
+    """
+    assert p.exists(), 'path does not exist'
+    for method, name in path_types.items():
+        if getattr(p, method)():
+            return name
+
+    return 'unknown'
+
+
+Obj = TypeVar('Obj')
+
+
+def smart_deepcopy(obj: Obj) -> Obj:
+    """
+    Return type as is for immutable built-in types
+    Use obj.copy() for built-in empty collections
+    Use copy.deepcopy() for non-empty collections and unknown objects
+    """
+
+    obj_type = obj.__class__
+    if obj_type in IMMUTABLE_NON_COLLECTIONS_TYPES:
+        return obj  # fastest case: obj is immutable and not collection therefore will not be copied anyway
+    elif not obj and obj_type in BUILTIN_COLLECTIONS:
+        # faster way for empty collections, no need to copy its members
+        return obj if obj_type is tuple else obj.copy()  # type: ignore  # tuple doesn't have copy method
+    return deepcopy(obj)  # slowest way when we actually might need a deepcopy
+
+
+def is_valid_field(name: str) -> bool:
+    if not name.startswith('_'):
+        return True
+    return ROOT_KEY == name
+
+
+def is_valid_private_name(name: str) -> bool:
+    return not is_valid_field(name) and name not in {
+        '__annotations__',
+        '__classcell__',
+        '__doc__',
+        '__module__',
+        '__orig_bases__',
+        '__qualname__',
+    }
+
+
+_EMPTY = object()
+
+
+def all_identical(left: Iterable[Any], right: Iterable[Any]) -> bool:
+    """
+    Check that the items of `left` are the same objects as those in `right`.
+
+    >>> a, b = object(), object()
+    >>> all_identical([a, b, a], [a, b, a])
+    True
+    >>> all_identical([a, b, [a]], [a, b, [a]])  # new list object, while "equal" is not "identical"
+    False
+    """
+    for left_item, right_item in zip_longest(left, right, fillvalue=_EMPTY):
+        if left_item is not right_item:
+            return False
+    return True
+
+
+def get_unique_discriminator_alias(all_aliases: Collection[str], discriminator_key: str) -> str:
+    """Validate that all aliases are the same and if that's the case return the alias"""
+    unique_aliases = set(all_aliases)
+    if len(unique_aliases) > 1:
+        raise ConfigError(
+            f'Aliases for discriminator {discriminator_key!r} must be the same (got {", ".join(sorted(all_aliases))})'
+        )
+    return unique_aliases.pop()
+
+
+def get_discriminator_alias_and_values(tp: Any, discriminator_key: str) -> Tuple[str, Tuple[str, ...]]:
+    """
+    Get alias and all valid values in the `Literal` type of the discriminator field
+    `tp` can be a `BaseModel` class or directly an `Annotated` `Union` of many.
+    """
+    is_root_model = getattr(tp, '__custom_root_type__', False)
+
+    if get_origin(tp) is Annotated:
+        tp = get_args(tp)[0]
+
+    if hasattr(tp, '__pydantic_model__'):
+        tp = tp.__pydantic_model__
+
+    if is_union(get_origin(tp)):
+        alias, all_values = _get_union_alias_and_all_values(tp, discriminator_key)
+        return alias, tuple(v for values in all_values for v in values)
+    elif is_root_model:
+        union_type = tp.__fields__[ROOT_KEY].type_
+        alias, all_values = _get_union_alias_and_all_values(union_type, discriminator_key)
+
+        if len(set(all_values)) > 1:
+            raise ConfigError(
+                f'Field {discriminator_key!r} is not the same for all submodels of {display_as_type(tp)!r}'
+            )
+
+        return alias, all_values[0]
+
+    else:
+        try:
+            t_discriminator_type = tp.__fields__[discriminator_key].type_
+        except AttributeError as e:
+            raise TypeError(f'Type {tp.__name__!r} is not a valid `BaseModel` or `dataclass`') from e
+        except KeyError as e:
+            raise ConfigError(f'Model {tp.__name__!r} needs a discriminator field for key {discriminator_key!r}') from e
+
+        if not is_literal_type(t_discriminator_type):
+            raise ConfigError(f'Field {discriminator_key!r} of model {tp.__name__!r} needs to be a `Literal`')
+
+        return tp.__fields__[discriminator_key].alias, all_literal_values(t_discriminator_type)
+
+
+def _get_union_alias_and_all_values(
+    union_type: Type[Any], discriminator_key: str
+) -> Tuple[str, Tuple[Tuple[str, ...], ...]]:
+    zipped_aliases_values = [get_discriminator_alias_and_values(t, discriminator_key) for t in get_args(union_type)]
+    # unzip: [('alias_a',('v1', 'v2)), ('alias_b', ('v3',))] => [('alias_a', 'alias_b'), (('v1', 'v2'), ('v3',))]
+    all_aliases, all_values = zip(*zipped_aliases_values)
+    return get_unique_discriminator_alias(all_aliases, discriminator_key), all_values
+
+
+KT = TypeVar('KT')
+VT = TypeVar('VT')
+if TYPE_CHECKING:
+    # Annoying inheriting from `MutableMapping` and `dict` breaks cython, hence this work around
+    class LimitedDict(dict, MutableMapping[KT, VT]):  # type: ignore[type-arg]
+        def __init__(self, size_limit: int = 1000):
+            ...
+
+else:
+
+    class LimitedDict(dict):
+        """
+        Limit the size/length of a dict used for caching to avoid unlimited increase in memory usage.
+
+        Since the dict is ordered, and we always remove elements from the beginning, this is effectively a FIFO cache.
+
+        Annoying inheriting from `MutableMapping` breaks cython.
+        """
+
+        def __init__(self, size_limit: int = 1000):
+            self.size_limit = size_limit
+            super().__init__()
+
+        def __setitem__(self, __key: Any, __value: Any) -> None:
+            super().__setitem__(__key, __value)
+            if len(self) > self.size_limit:
+                excess = len(self) - self.size_limit + self.size_limit // 10
+                to_remove = list(self.keys())[:excess]
+                for key in to_remove:
+                    del self[key]
+
+        def __class_getitem__(cls, *args: Any) -> Any:  # pragma: no cover
+            # just in case LimitedDict is used in type annotations
+            pass
diff --git a/myenv/lib/python3.9/site-packages/pydantic/validators.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/validators.cpython-39-darwin.so
new file mode 100755
index 0000000..21d13f1
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/validators.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/validators.py b/myenv/lib/python3.9/site-packages/pydantic/validators.py
new file mode 100644
index 0000000..d4783d9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/validators.py
@@ -0,0 +1,723 @@
+import re
+from collections import OrderedDict, deque
+from collections.abc import Hashable as CollectionsHashable
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal, DecimalException
+from enum import Enum, IntEnum
+from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Deque,
+    Dict,
+    FrozenSet,
+    Generator,
+    Hashable,
+    List,
+    NamedTuple,
+    Pattern,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+from uuid import UUID
+
+from . import errors
+from .datetime_parse import parse_date, parse_datetime, parse_duration, parse_time
+from .typing import (
+    AnyCallable,
+    ForwardRef,
+    all_literal_values,
+    display_as_type,
+    get_class,
+    is_callable_type,
+    is_literal_type,
+    is_namedtuple,
+    is_none_type,
+    is_typeddict,
+)
+from .utils import almost_equal_floats, lenient_issubclass, sequence_like
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal, TypedDict
+
+    from .config import BaseConfig
+    from .fields import ModelField
+    from .types import ConstrainedDecimal, ConstrainedFloat, ConstrainedInt
+
+    ConstrainedNumber = Union[ConstrainedDecimal, ConstrainedFloat, ConstrainedInt]
+    AnyOrderedDict = OrderedDict[Any, Any]
+    Number = Union[int, float, Decimal]
+    StrBytes = Union[str, bytes]
+
+
+def str_validator(v: Any) -> Union[str]:
+    if isinstance(v, str):
+        if isinstance(v, Enum):
+            return v.value
+        else:
+            return v
+    elif isinstance(v, (float, int, Decimal)):
+        # is there anything else we want to add here? If you think so, create an issue.
+        return str(v)
+    elif isinstance(v, (bytes, bytearray)):
+        return v.decode()
+    else:
+        raise errors.StrError()
+
+
+def strict_str_validator(v: Any) -> Union[str]:
+    if isinstance(v, str) and not isinstance(v, Enum):
+        return v
+    raise errors.StrError()
+
+
+def bytes_validator(v: Any) -> Union[bytes]:
+    if isinstance(v, bytes):
+        return v
+    elif isinstance(v, bytearray):
+        return bytes(v)
+    elif isinstance(v, str):
+        return v.encode()
+    elif isinstance(v, (float, int, Decimal)):
+        return str(v).encode()
+    else:
+        raise errors.BytesError()
+
+
+def strict_bytes_validator(v: Any) -> Union[bytes]:
+    if isinstance(v, bytes):
+        return v
+    elif isinstance(v, bytearray):
+        return bytes(v)
+    else:
+        raise errors.BytesError()
+
+
+BOOL_FALSE = {0, '0', 'off', 'f', 'false', 'n', 'no'}
+BOOL_TRUE = {1, '1', 'on', 't', 'true', 'y', 'yes'}
+
+
+def bool_validator(v: Any) -> bool:
+    if v is True or v is False:
+        return v
+    if isinstance(v, bytes):
+        v = v.decode()
+    if isinstance(v, str):
+        v = v.lower()
+    try:
+        if v in BOOL_TRUE:
+            return True
+        if v in BOOL_FALSE:
+            return False
+    except TypeError:
+        raise errors.BoolError()
+    raise errors.BoolError()
+
+
+def int_validator(v: Any) -> int:
+    if isinstance(v, int) and not (v is True or v is False):
+        return v
+
+    try:
+        return int(v)
+    except (TypeError, ValueError):
+        raise errors.IntegerError()
+
+
+def strict_int_validator(v: Any) -> int:
+    if isinstance(v, int) and not (v is True or v is False):
+        return v
+    raise errors.IntegerError()
+
+
+def float_validator(v: Any) -> float:
+    if isinstance(v, float):
+        return v
+
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        raise errors.FloatError()
+
+
+def strict_float_validator(v: Any) -> float:
+    if isinstance(v, float):
+        return v
+    raise errors.FloatError()
+
+
+def number_multiple_validator(v: 'Number', field: 'ModelField') -> 'Number':
+    field_type: ConstrainedNumber = field.type_
+    if field_type.multiple_of is not None:
+        mod = float(v) / float(field_type.multiple_of) % 1
+        if not almost_equal_floats(mod, 0.0) and not almost_equal_floats(mod, 1.0):
+            raise errors.NumberNotMultipleError(multiple_of=field_type.multiple_of)
+    return v
+
+
+def number_size_validator(v: 'Number', field: 'ModelField') -> 'Number':
+    field_type: ConstrainedNumber = field.type_
+    if field_type.gt is not None and not v > field_type.gt:
+        raise errors.NumberNotGtError(limit_value=field_type.gt)
+    elif field_type.ge is not None and not v >= field_type.ge:
+        raise errors.NumberNotGeError(limit_value=field_type.ge)
+
+    if field_type.lt is not None and not v < field_type.lt:
+        raise errors.NumberNotLtError(limit_value=field_type.lt)
+    if field_type.le is not None and not v <= field_type.le:
+        raise errors.NumberNotLeError(limit_value=field_type.le)
+
+    return v
+
+
+def constant_validator(v: 'Any', field: 'ModelField') -> 'Any':
+    """Validate ``const`` fields.
+
+    The value provided for a ``const`` field must be equal to the default value
+    of the field. This is to support the keyword of the same name in JSON
+    Schema.
+    """
+    if v != field.default:
+        raise errors.WrongConstantError(given=v, permitted=[field.default])
+
+    return v
+
+
+def anystr_length_validator(v: 'StrBytes', config: 'BaseConfig') -> 'StrBytes':
+    v_len = len(v)
+
+    min_length = config.min_anystr_length
+    if v_len < min_length:
+        raise errors.AnyStrMinLengthError(limit_value=min_length)
+
+    max_length = config.max_anystr_length
+    if max_length is not None and v_len > max_length:
+        raise errors.AnyStrMaxLengthError(limit_value=max_length)
+
+    return v
+
+
+def anystr_strip_whitespace(v: 'StrBytes') -> 'StrBytes':
+    return v.strip()
+
+
+def anystr_lower(v: 'StrBytes') -> 'StrBytes':
+    return v.lower()
+
+
+def ordered_dict_validator(v: Any) -> 'AnyOrderedDict':
+    if isinstance(v, OrderedDict):
+        return v
+
+    try:
+        return OrderedDict(v)
+    except (TypeError, ValueError):
+        raise errors.DictError()
+
+
+def dict_validator(v: Any) -> Dict[Any, Any]:
+    if isinstance(v, dict):
+        return v
+
+    try:
+        return dict(v)
+    except (TypeError, ValueError):
+        raise errors.DictError()
+
+
+def list_validator(v: Any) -> List[Any]:
+    if isinstance(v, list):
+        return v
+    elif sequence_like(v):
+        return list(v)
+    else:
+        raise errors.ListError()
+
+
+def tuple_validator(v: Any) -> Tuple[Any, ...]:
+    if isinstance(v, tuple):
+        return v
+    elif sequence_like(v):
+        return tuple(v)
+    else:
+        raise errors.TupleError()
+
+
+def set_validator(v: Any) -> Set[Any]:
+    if isinstance(v, set):
+        return v
+    elif sequence_like(v):
+        return set(v)
+    else:
+        raise errors.SetError()
+
+
+def frozenset_validator(v: Any) -> FrozenSet[Any]:
+    if isinstance(v, frozenset):
+        return v
+    elif sequence_like(v):
+        return frozenset(v)
+    else:
+        raise errors.FrozenSetError()
+
+
+def deque_validator(v: Any) -> Deque[Any]:
+    if isinstance(v, deque):
+        return v
+    elif sequence_like(v):
+        return deque(v)
+    else:
+        raise errors.DequeError()
+
+
+def enum_member_validator(v: Any, field: 'ModelField', config: 'BaseConfig') -> Enum:
+    try:
+        enum_v = field.type_(v)
+    except ValueError:
+        # field.type_ should be an enum, so will be iterable
+        raise errors.EnumMemberError(enum_values=list(field.type_))
+    return enum_v.value if config.use_enum_values else enum_v
+
+
+def uuid_validator(v: Any, field: 'ModelField') -> UUID:
+    try:
+        if isinstance(v, str):
+            v = UUID(v)
+        elif isinstance(v, (bytes, bytearray)):
+            try:
+                v = UUID(v.decode())
+            except ValueError:
+                # 16 bytes in big-endian order as the bytes argument fail
+                # the above check
+                v = UUID(bytes=v)
+    except ValueError:
+        raise errors.UUIDError()
+
+    if not isinstance(v, UUID):
+        raise errors.UUIDError()
+
+    required_version = getattr(field.type_, '_required_version', None)
+    if required_version and v.version != required_version:
+        raise errors.UUIDVersionError(required_version=required_version)
+
+    return v
+
+
+def decimal_validator(v: Any) -> Decimal:
+    if isinstance(v, Decimal):
+        return v
+    elif isinstance(v, (bytes, bytearray)):
+        v = v.decode()
+
+    v = str(v).strip()
+
+    try:
+        v = Decimal(v)
+    except DecimalException:
+        raise errors.DecimalError()
+
+    if not v.is_finite():
+        raise errors.DecimalIsNotFiniteError()
+
+    return v
+
+
+def hashable_validator(v: Any) -> Hashable:
+    if isinstance(v, Hashable):
+        return v
+
+    raise errors.HashableError()
+
+
+def ip_v4_address_validator(v: Any) -> IPv4Address:
+    if isinstance(v, IPv4Address):
+        return v
+
+    try:
+        return IPv4Address(v)
+    except ValueError:
+        raise errors.IPv4AddressError()
+
+
+def ip_v6_address_validator(v: Any) -> IPv6Address:
+    if isinstance(v, IPv6Address):
+        return v
+
+    try:
+        return IPv6Address(v)
+    except ValueError:
+        raise errors.IPv6AddressError()
+
+
+def ip_v4_network_validator(v: Any) -> IPv4Network:
+    """
+    Assume IPv4Network initialised with a default ``strict`` argument
+
+    See more:
+    https://docs.python.org/library/ipaddress.html#ipaddress.IPv4Network
+    """
+    if isinstance(v, IPv4Network):
+        return v
+
+    try:
+        return IPv4Network(v)
+    except ValueError:
+        raise errors.IPv4NetworkError()
+
+
+def ip_v6_network_validator(v: Any) -> IPv6Network:
+    """
+    Assume IPv6Network initialised with a default ``strict`` argument
+
+    See more:
+    https://docs.python.org/library/ipaddress.html#ipaddress.IPv6Network
+    """
+    if isinstance(v, IPv6Network):
+        return v
+
+    try:
+        return IPv6Network(v)
+    except ValueError:
+        raise errors.IPv6NetworkError()
+
+
+def ip_v4_interface_validator(v: Any) -> IPv4Interface:
+    if isinstance(v, IPv4Interface):
+        return v
+
+    try:
+        return IPv4Interface(v)
+    except ValueError:
+        raise errors.IPv4InterfaceError()
+
+
+def ip_v6_interface_validator(v: Any) -> IPv6Interface:
+    if isinstance(v, IPv6Interface):
+        return v
+
+    try:
+        return IPv6Interface(v)
+    except ValueError:
+        raise errors.IPv6InterfaceError()
+
+
+def path_validator(v: Any) -> Path:
+    if isinstance(v, Path):
+        return v
+
+    try:
+        return Path(v)
+    except TypeError:
+        raise errors.PathError()
+
+
+def path_exists_validator(v: Any) -> Path:
+    if not v.exists():
+        raise errors.PathNotExistsError(path=v)
+
+    return v
+
+
+def callable_validator(v: Any) -> AnyCallable:
+    """
+    Perform a simple check if the value is callable.
+
+    Note: complete matching of argument type hints and return types is not performed
+    """
+    if callable(v):
+        return v
+
+    raise errors.CallableError(value=v)
+
+
+def enum_validator(v: Any) -> Enum:
+    if isinstance(v, Enum):
+        return v
+
+    raise errors.EnumError(value=v)
+
+
+def int_enum_validator(v: Any) -> IntEnum:
+    if isinstance(v, IntEnum):
+        return v
+
+    raise errors.IntEnumError(value=v)
+
+
+def make_literal_validator(type_: Any) -> Callable[[Any], Any]:
+    permitted_choices = all_literal_values(type_)
+
+    # To have a O(1) complexity and still return one of the values set inside the `Literal`,
+    # we create a dict with the set values (a set causes some problems with the way intersection works).
+    # In some cases the set value and checked value can indeed be different (see `test_literal_validator_str_enum`)
+    allowed_choices = {v: v for v in permitted_choices}
+
+    def literal_validator(v: Any) -> Any:
+        try:
+            return allowed_choices[v]
+        except KeyError:
+            raise errors.WrongConstantError(given=v, permitted=permitted_choices)
+
+    return literal_validator
+
+
+def constr_length_validator(v: 'StrBytes', field: 'ModelField', config: 'BaseConfig') -> 'StrBytes':
+    v_len = len(v)
+
+    min_length = field.type_.min_length if field.type_.min_length is not None else config.min_anystr_length
+    if v_len < min_length:
+        raise errors.AnyStrMinLengthError(limit_value=min_length)
+
+    max_length = field.type_.max_length if field.type_.max_length is not None else config.max_anystr_length
+    if max_length is not None and v_len > max_length:
+        raise errors.AnyStrMaxLengthError(limit_value=max_length)
+
+    return v
+
+
+def constr_strip_whitespace(v: 'StrBytes', field: 'ModelField', config: 'BaseConfig') -> 'StrBytes':
+    strip_whitespace = field.type_.strip_whitespace or config.anystr_strip_whitespace
+    if strip_whitespace:
+        v = v.strip()
+
+    return v
+
+
+def constr_lower(v: 'StrBytes', field: 'ModelField', config: 'BaseConfig') -> 'StrBytes':
+    lower = field.type_.to_lower or config.anystr_lower
+    if lower:
+        v = v.lower()
+    return v
+
+
+def validate_json(v: Any, config: 'BaseConfig') -> Any:
+    if v is None:
+        # pass None through to other validators
+        return v
+    try:
+        return config.json_loads(v)  # type: ignore
+    except ValueError:
+        raise errors.JsonError()
+    except TypeError:
+        raise errors.JsonTypeError()
+
+
+T = TypeVar('T')
+
+
+def make_arbitrary_type_validator(type_: Type[T]) -> Callable[[T], T]:
+    def arbitrary_type_validator(v: Any) -> T:
+        if isinstance(v, type_):
+            return v
+        raise errors.ArbitraryTypeError(expected_arbitrary_type=type_)
+
+    return arbitrary_type_validator
+
+
+def make_class_validator(type_: Type[T]) -> Callable[[Any], Type[T]]:
+    def class_validator(v: Any) -> Type[T]:
+        if lenient_issubclass(v, type_):
+            return v
+        raise errors.SubclassError(expected_class=type_)
+
+    return class_validator
+
+
+def any_class_validator(v: Any) -> Type[T]:
+    if isinstance(v, type):
+        return v
+    raise errors.ClassError()
+
+
+def none_validator(v: Any) -> 'Literal[None]':
+    if v is None:
+        return v
+    raise errors.NotNoneError()
+
+
+def pattern_validator(v: Any) -> Pattern[str]:
+    if isinstance(v, Pattern):
+        return v
+
+    str_value = str_validator(v)
+
+    try:
+        return re.compile(str_value)
+    except re.error:
+        raise errors.PatternError()
+
+
+NamedTupleT = TypeVar('NamedTupleT', bound=NamedTuple)
+
+
+def make_namedtuple_validator(namedtuple_cls: Type[NamedTupleT]) -> Callable[[Tuple[Any, ...]], NamedTupleT]:
+    from .annotated_types import create_model_from_namedtuple
+
+    NamedTupleModel = create_model_from_namedtuple(
+        namedtuple_cls,
+        __module__=namedtuple_cls.__module__,
+    )
+    namedtuple_cls.__pydantic_model__ = NamedTupleModel  # type: ignore[attr-defined]
+
+    def namedtuple_validator(values: Tuple[Any, ...]) -> NamedTupleT:
+        annotations = NamedTupleModel.__annotations__
+
+        if len(values) > len(annotations):
+            raise errors.ListMaxLengthError(limit_value=len(annotations))
+
+        dict_values: Dict[str, Any] = dict(zip(annotations, values))
+        validated_dict_values: Dict[str, Any] = dict(NamedTupleModel(**dict_values))
+        return namedtuple_cls(**validated_dict_values)
+
+    return namedtuple_validator
+
+
+def make_typeddict_validator(
+    typeddict_cls: Type['TypedDict'], config: Type['BaseConfig']  # type: ignore[valid-type]
+) -> Callable[[Any], Dict[str, Any]]:
+    from .annotated_types import create_model_from_typeddict
+
+    TypedDictModel = create_model_from_typeddict(
+        typeddict_cls,
+        __config__=config,
+        __module__=typeddict_cls.__module__,
+    )
+    typeddict_cls.__pydantic_model__ = TypedDictModel  # type: ignore[attr-defined]
+
+    def typeddict_validator(values: 'TypedDict') -> Dict[str, Any]:  # type: ignore[valid-type]
+        return TypedDictModel.parse_obj(values).dict(exclude_unset=True)
+
+    return typeddict_validator
+
+
+class IfConfig:
+    def __init__(self, validator: AnyCallable, *config_attr_names: str) -> None:
+        self.validator = validator
+        self.config_attr_names = config_attr_names
+
+    def check(self, config: Type['BaseConfig']) -> bool:
+        return any(getattr(config, name) not in {None, False} for name in self.config_attr_names)
+
+
+# order is important here, for example: bool is a subclass of int so has to come first, datetime before date same,
+# IPv4Interface before IPv4Address, etc
+_VALIDATORS: List[Tuple[Type[Any], List[Any]]] = [
+    (IntEnum, [int_validator, enum_member_validator]),
+    (Enum, [enum_member_validator]),
+    (
+        str,
+        [
+            str_validator,
+            IfConfig(anystr_strip_whitespace, 'anystr_strip_whitespace'),
+            IfConfig(anystr_lower, 'anystr_lower'),
+            IfConfig(anystr_length_validator, 'min_anystr_length', 'max_anystr_length'),
+        ],
+    ),
+    (
+        bytes,
+        [
+            bytes_validator,
+            IfConfig(anystr_strip_whitespace, 'anystr_strip_whitespace'),
+            IfConfig(anystr_lower, 'anystr_lower'),
+            IfConfig(anystr_length_validator, 'min_anystr_length', 'max_anystr_length'),
+        ],
+    ),
+    (bool, [bool_validator]),
+    (int, [int_validator]),
+    (float, [float_validator]),
+    (Path, [path_validator]),
+    (datetime, [parse_datetime]),
+    (date, [parse_date]),
+    (time, [parse_time]),
+    (timedelta, [parse_duration]),
+    (OrderedDict, [ordered_dict_validator]),
+    (dict, [dict_validator]),
+    (list, [list_validator]),
+    (tuple, [tuple_validator]),
+    (set, [set_validator]),
+    (frozenset, [frozenset_validator]),
+    (deque, [deque_validator]),
+    (UUID, [uuid_validator]),
+    (Decimal, [decimal_validator]),
+    (IPv4Interface, [ip_v4_interface_validator]),
+    (IPv6Interface, [ip_v6_interface_validator]),
+    (IPv4Address, [ip_v4_address_validator]),
+    (IPv6Address, [ip_v6_address_validator]),
+    (IPv4Network, [ip_v4_network_validator]),
+    (IPv6Network, [ip_v6_network_validator]),
+]
+
+
+def find_validators(  # noqa: C901 (ignore complexity)
+    type_: Type[Any], config: Type['BaseConfig']
+) -> Generator[AnyCallable, None, None]:
+    from .dataclasses import is_builtin_dataclass, make_dataclass_validator
+
+    if type_ is Any or type_ is object:
+        return
+    type_type = type_.__class__
+    if type_type == ForwardRef or type_type == TypeVar:
+        return
+
+    if is_none_type(type_):
+        yield none_validator
+        return
+    if type_ is Pattern:
+        yield pattern_validator
+        return
+    if type_ is Hashable or type_ is CollectionsHashable:
+        yield hashable_validator
+        return
+    if is_callable_type(type_):
+        yield callable_validator
+        return
+    if is_literal_type(type_):
+        yield make_literal_validator(type_)
+        return
+    if is_builtin_dataclass(type_):
+        yield from make_dataclass_validator(type_, config)
+        return
+    if type_ is Enum:
+        yield enum_validator
+        return
+    if type_ is IntEnum:
+        yield int_enum_validator
+        return
+    if is_namedtuple(type_):
+        yield tuple_validator
+        yield make_namedtuple_validator(type_)
+        return
+    if is_typeddict(type_):
+        yield make_typeddict_validator(type_, config)
+        return
+
+    class_ = get_class(type_)
+    if class_ is not None:
+        if isinstance(class_, type):
+            yield make_class_validator(class_)
+        else:
+            yield any_class_validator
+        return
+
+    for val_type, validators in _VALIDATORS:
+        try:
+            if issubclass(type_, val_type):
+                for v in validators:
+                    if isinstance(v, IfConfig):
+                        if v.check(config):
+                            yield v.validator
+                    else:
+                        yield v
+                return
+        except TypeError:
+            raise RuntimeError(f'error checking inheritance of {type_!r} (type: {display_as_type(type_)})')
+
+    if config.arbitrary_types_allowed:
+        yield make_arbitrary_type_validator(type_)
+    else:
+        raise RuntimeError(f'no validator found for {type_}, see `arbitrary_types_allowed` in Config')
diff --git a/myenv/lib/python3.9/site-packages/pydantic/version.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/pydantic/version.cpython-39-darwin.so
new file mode 100755
index 0000000..345002b
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/pydantic/version.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/pydantic/version.py b/myenv/lib/python3.9/site-packages/pydantic/version.py
new file mode 100644
index 0000000..3c88537
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pydantic/version.py
@@ -0,0 +1,30 @@
+__all__ = 'VERSION', 'version_info'
+
+VERSION = '1.9.1'
+
+
+def version_info() -> str:
+    import platform
+    import sys
+    from importlib import import_module
+    from pathlib import Path
+
+    from .main import compiled
+
+    optional_deps = []
+    for p in ('devtools', 'dotenv', 'email-validator', 'typing-extensions'):
+        try:
+            import_module(p.replace('-', '_'))
+        except ImportError:
+            continue
+        optional_deps.append(p)
+
+    info = {
+        'pydantic version': VERSION,
+        'pydantic compiled': compiled,
+        'install path': Path(__file__).resolve().parent,
+        'python version': sys.version,
+        'platform': platform.platform(),
+        'optional deps. installed': optional_deps,
+    }
+    return '\n'.join('{:>30} {}'.format(k + ':', str(v).replace('\n', ' ')) for k, v in info.items())
diff --git a/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/CONTRIBUTORS.txt b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/CONTRIBUTORS.txt
new file mode 100644
index 0000000..42163d9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/CONTRIBUTORS.txt
@@ -0,0 +1,549 @@
+# This file is autocompleted by 'contributors-txt',
+# using the configuration in 'script/.contributors_aliases.json'.
+# Do not add new persons manually and only add information without
+# using '-' as the line first character.
+# Please verify that your change are stable if you modify manually.
+
+Ex-maintainers
+--------------
+- Claudiu Popa <pcmanticore@gmail.com>
+- Sylvain Thénault <thenault@gmail.com> : main author / maintainer
+- Torsten Marek <shlomme@gmail.com>
+
+
+Maintainers
+-----------
+
+- Pierre Sassoulas <pierre.sassoulas@gmail.com>
+- Daniël van Noord <13665637+DanielNoord@users.noreply.github.com>
+- Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+- Hippo91 <guillaume.peillex@gmail.com>
+- Jacob Walls <jacobtylerwalls@gmail.com>
+- Łukasz Rogalski <rogalski.91@gmail.com>
+- Ashley Whetter <ashley@awhetter.co.uk>
+- Bryce Guinta <bryce.paul.guinta@gmail.com>
+- Andreas Finkler <3929834+DudeNr33@users.noreply.github.com>
+- Yu Shao, Pang <36848472+yushao2@users.noreply.github.com>
+- Dimitri Prybysh <dmand@yandex.ru>
+  * multiple-imports, not-iterable, not-a-mapping, various patches.
+- Roy Williams <roy.williams.iii@gmail.com> (Lyft)
+  * added check for implementing __eq__ without implementing __hash__,
+  * Added Python 3 check for accessing Exception.message.
+  * Added Python 3 check for calling encode/decode with invalid codecs.
+  * Added Python 3 check for accessing sys.maxint.
+  * Added Python 3 check for bad import statements.
+  * Added Python 3 check for accessing deprecated methods on the 'string' module,
+    various patches.
+- Florian Bruhin <me@the-compiler.org>
+- Arianna Yang <areveny@protonmail.com>
+
+
+Contributors
+------------
+
+We would not be here without folks that contributed patches, pull requests,
+issues and their time to pylint. We're incredibly grateful to all of these
+contributors:
+
+- Emile Anclin <emile.anclin@logilab.fr> (Logilab): python 3 support
+- Michal Nowikowski <godfryd@gmail.com>:
+  * wrong-spelling-in-comment
+  * wrong-spelling-in-docstring
+  * parallel execution on multiple CPUs
+- Bruno Daniel <bruno.daniel@blue-yonder.com>: check_docs extension.
+- Sushobhit <31987769+sushobhit27@users.noreply.github.com> (sushobhit27)
+  * Added new check 'comparison-with-itself'.
+  * Added new check 'useless-import-alias'.
+  * Added support of annotations in missing-type-doc and missing-return-type-doc.
+  * Added new check 'comparison-with-callable'.
+  * Removed six package dependency.
+  * Added new check 'chained-comparison'.
+  * Added new check 'useless-object-inheritance'.
+- Brett Cannon <brett@python.org>:
+  * Port source code to be Python 2/3 compatible
+  * Python 3 checker
+- Laura Médioni <laura.medioni@logilab.fr> (Logilab, on behalf of the CNES):
+  * misplaced-comparison-constant
+  * no-classmethod-decorator
+  * no-staticmethod-decorator
+  * too-many-nested-blocks,
+  * too-many-boolean-expressions
+  * unneeded-not
+  * wrong-import-order
+  * ungrouped-imports,
+  * wrong-import-position
+  * redefined-variable-type
+- Alexandre Fayolle <alexandre.fayolle@logilab.fr> (Logilab): TkInter gui, documentation, debian support
+- Nick Drozd <nicholasdrozd@gmail.com>: performance improvements to astroid
+- Julien Cristau <julien.cristau@logilab.fr> (Logilab): python 3 support
+- Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
+- Frank Harrison <frank@doublethefish.com> (doublethefish)
+- Moisés López <moylop260@vauxoo.com> (Vauxoo):
+  * Support for deprecated-modules in modules not installed,
+  * Refactor wrong-import-order to integrate it with `isort` library
+  * Add check too-complex with mccabe for cyclomatic complexity
+  * Refactor wrong-import-position to skip try-import and nested cases
+  * Add consider-merging-isinstance, superfluous-else-return
+  * Fix consider-using-ternary for 'True and True and True or True' case
+  * Add bad-docstring-quotes and docstring-first-line-empty
+- Ville Skyttä <ville.skytta@iki.fi>
+- Matus Valo <matusvalo@users.noreply.github.com>
+- Pierre-Yves David <pierre-yves.david@logilab.fr>
+- Mark Byrne <31762852+mbyrnepr2@users.noreply.github.com>
+- David Shea <dshea@redhat.com>: invalid sequence and slice index
+- Derek Gustafson <degustaf@gmail.com>
+- Cezar Elnazli <cezar.elnazli2@gmail.com>: deprecated-method
+- Nicolas Chauvat <nicolas.chauvat@logilab.fr>
+- Radu Ciorba <radu@devrandom.ro>: not-context-manager and confusing-with-statement warnings.
+- Holger Peters <email@holger-peters.de>
+- Cosmin Poieană <cmin@ropython.org>: unichr-builtin and improvements to bad-open-mode.
+- Steven Myint <hg@stevenmyint.com>: duplicate-except.
+- Peter Kolbus <peter.kolbus@gmail.com> (Garmin)
+- Luigi Bertaco Cristofolini <lucristofolini@gmail.com> (luigibertaco)
+- Glenn Matthews <glenn@e-dad.net>:
+  * autogenerated documentation for optional extensions,
+  * bug fixes and enhancements for docparams (née check_docs) extension
+- Vlad Temian <vladtemian@gmail.com>: redundant-unittest-assert and the JSON reporter.
+- Julien Jehannet <julien.jehannet@logilab.fr>
+- Boris Feld <lothiraldan@gmail.com>
+- Anthony Sottile <asottile@umich.edu>
+- Pedro Algarvio <pedro@algarvio.me> (s0undt3ch)
+- Julien Palard <julien@palard.fr>
+- David Liu <david@cs.toronto.edu> (david-yz-liu)
+- Dan Goldsmith <djgoldsmith@googlemail.com>: support for msg-template in HTML reporter.
+- Mariatta Wijaya <Mariatta@users.noreply.github.com>
+  * Added new check `logging-fstring-interpolation`
+  * Documentation typo fixes
+- Jakub Wilk <jwilk@jwilk.net>
+- Émile Crater <emile@crater.logilab.fr>
+- Pavel Roskin <proski@gnu.org>
+- Eli Fine <ejfine@gmail.com> (eli88fine): Fixed false positive duplicate code warning for lines with symbols only
+- David Gilman <davidgilman1@gmail.com>
+- Andrew Haigh <nelfin@gmail.com> (nelfin)
+- へーさん <hira9603859504@gmail.com>
+- orSolocate <38433858+orSolocate@users.noreply.github.com>
+- Tushar Sadhwani <tushar.sadhwani000@gmail.com> (tusharsadhwani)
+- Thomas Hisch <t.hisch@gmail.com>
+- Marianna Polatoglou <mpolatoglou@bloomberg.net>: minor contribution for wildcard import check
+- Manuel Vázquez Acosta <mva.led@gmail.com>
+- Luis Escobar <lescobar@vauxoo.com> (Vauxoo): Add bad-docstring-quotes and docstring-first-line-empty
+- Jim Robertson <jrobertson98atx@gmail.com>
+- Ethan Leba <ethanleba5@gmail.com>
+- Enji Cooper <yaneurabeya@gmail.com>
+- David Lindquist <dlindquist@google.com>: logging-format-interpolation warning.
+- Buck (Yelp) <buck@yelp.com>
+- Anthony Truchet <anthony.truchet@logilab.fr>
+- Alexander Todorov <atodorov@otb.bg>:
+  * added new error conditions to 'bad-super-call',
+  * Added new check for incorrect len(SEQUENCE) usage,
+  * Added new extension for comparison against empty string constants,
+  * Added new extension which detects comparing integers to zero,
+  * Added new useless-return checker,
+  * Added new try-except-raise checker
+- Téo Bouvard <teobouvard@gmail.com>
+- Tim Martin <tim@asymptotic.co.uk>
+- Mihai Balint <balint.mihai@gmail.com>
+- Mark Bell <mark00bell@googlemail.com>
+- Konstantina Saketou <56515303+ksaketou@users.noreply.github.com>
+- Hugo van Kemenade <hugovk@users.noreply.github.com>
+- Hornwitser <github@hornwitser.no>: fix import graph
+- Fureigh <rhys.fureigh@gsa.gov>
+- David Douard <david.douard@sdfa3.org>
+- Daniel Balparda <balparda@google.com> (Google): GPyLint maintainer (Google's pylint variant)
+- Bastien Vallet <bastien.vallet@gmail.com> (Djailla)
+- Aru Sahni <arusahni@gmail.com>: Git ignoring, regex-based ignores
+- Andreas Freimuth <andreas.freimuth@united-bits.de>: fix indentation checking with tabs
+- Alexandru Coman <fcoman@bitdefender.com>
+- Takahide Nojima <nozzy123nozzy@gmail.com>
+- Taewon D. Kim <kimt33@mcmaster.ca>
+- Sneaky Pete <sneakypete81@gmail.com>
+- Rene Zhang <rz99@cornell.edu>
+- Or Bahari <or.ba402@gmail.com>
+- Mr. Senko <atodorov@mrsenko.com>
+- Martin von Gagern <gagern@google.com> (Google): Added 'raising-format-tuple' warning.
+- Martin Vielsmaier <martin@vielsmaier.net>
+- Martin Pool <mbp@google.com> (Google):
+  * warnings for anomalous backslashes
+  * symbolic names for messages (like 'unused')
+  * etc.
+- Martin Bašti <MartinBasti@users.noreply.github.com>
+  * Added new check for shallow copy of os.environ
+  * Added new check for useless `with threading.Lock():` statement
+- Marcus Näslund <naslundx@gmail.com> (naslundx)
+- Marco Forte <fortemarco.irl@gmail.com>
+- Joseph Young <80432516+jpy-git@users.noreply.github.com> (jpy-git)
+- Ionel Maries Cristian <contact@ionelmc.ro>
+- Gergely Kalmár <gergely.kalmar@logikal.jp>
+- Daniel Harding <dharding@gmail.com>
+- Damien Baty <damien.baty@polyconseil.fr>
+- Benjamin Drung <benjamin.drung@profitbricks.com>: contributing Debian Developer
+- Anubhav <35621759+anubh-v@users.noreply.github.com>
+- Antonio Quarta <sgheppy88@gmail.com> (sgheppy)
+- Andrew J. Simmons <anjsimmo@gmail.com> (anjsimmo)
+- wtracy <afishionado@gmail.com>
+- jpkotta <jpkotta@gmail.com>
+- chohner <mail@chohner.com>
+- Tiago Honorato <61059243+tiagohonorato@users.noreply.github.com>
+- Steven M. Vascellaro <svascellaro@gmail.com>
+- Sergey B Kirpichev <skirpichev@gmail.com>
+- Roberto Leinardi <leinardi@gmail.com>: PyCharm plugin maintainer
+- Ricardo Gemignani <ricardo.gemignani@gmail.com>
+- Pieter Engelbrecht <pengelbrecht@rems2.com>
+- Philipp Albrecht <flying-sheep@web.de> (pylbrecht)
+- Nicolas Dickreuter <dickreuter@gmail.com>
+- Nick Bastin <nick.bastin@gmail.com>
+- Nathaniel Manista <nathaniel@google.com>: suspicious lambda checking
+- Mike Frysinger <vapier@gmail.com>
+- Maksym Humetskyi <Humetsky@gmail.com> (mhumetskyi)
+  * Fixed ignored empty functions by similarities checker with "ignore-signatures" option enabled
+  * Ignore function decorators signatures as well by similarities checker with "ignore-signatures" option enabled
+  * Ignore class methods and nested functions signatures as well by similarities checker with "ignore-signatures" option enabled
+- Lucas Cimon <lucas.cimon@gmail.com>
+- Kylian <development@goudcode.nl>
+- Konstantin Manna <Konstantin@Manna.uno>
+- Kai Mueller <15907922+kasium@users.noreply.github.com> (kasium)
+- Joshua Cannon <joshdcannon@gmail.com>
+- John Leach <jfleach@jfleach.com>
+- James Morgensen <james.morgensen@gmail.com>: ignored-modules option applies to import errors.
+- Jaehoon Hwang <jaehoonhwang@users.noreply.github.com> (jaehoonhwang)
+- Ganden Schaffner <gschaffner@pm.me>
+- Frost Ming <frostming@tencent.com> (frostming)
+- Federico Bond <federicobond@gmail.com>
+- Erik Wright <erik.wright@shopify.com>
+- Erik Eriksson <molobrakos@users.noreply.github.com>: Added overlapping-except error check.
+- Dan Hemberger <846186+hemberger@users.noreply.github.com>
+- Chris Rebert <code@rebertia.com>: unidiomatic-typecheck.
+- Aurelien Campeas <aurelien.campeas@logilab.fr>
+- Alexander Pervakov <frost.nzcr4@jagmort.com>
+- Alain Leufroy <alain.leufroy@logilab.fr>
+- xmo-odoo <xmo-odoo@users.noreply.github.com>
+- root@clnstor.am.local <root@clnstor.am.local>
+- grizzly.nyo@gmail.com <grizzly.nyo@gmail.com>
+- craig-sh <craig-sh@users.noreply.github.com>
+- bernie gray <bfgray3@users.noreply.github.com>
+- Yilei "Dolee" Yang <yileiyang@google.com>
+- Wes Turner <westurner@google.com> (Google): added new check 'inconsistent-quotes'
+- Tyler Thieding <tyler@thieding.com>
+- Tobias Hernstig <30827238+thernstig@users.noreply.github.com>
+- Thomas Grainger <tagrain@gmail.com>
+- Simu Toni <simutoni@gmail.com>
+- Sergei Lebedev <185856+superbobry@users.noreply.github.com> (superbobry)
+- Scott Worley <scottworley@scottworley.com>
+- Rémi Cardona <remi.cardona@polyconseil.fr>
+- Raphael Gaschignard <raphael@makeleaps.com>
+- Ram Rachum <ram@rachum.com> (cool-RR)
+- Radostin Stoyanov <rst0git@users.noreply.github.com>
+- Paul Renvoisé <PaulRenvoise@users.noreply.github.com>
+- PHeanEX <github@pheanex.de>
+- Omega Weapon <OmegaPhil+hg@gmail.com>
+- Nikolai Kristiansen <nikolaik@gmail.com>
+- Nick Pesce <nickpesce22@gmail.com>
+- Nathan Marrow <nmarrow@google.com>
+- Mikhail Fesenko <m.fesenko@corp.vk.com>
+- Matthew Suozzo <msuozzo@google.com>
+- Matthew Beckers <17108752+mattlbeck@users.noreply.github.com> (mattlbeck)
+- Mark Roman Miller <mtmiller@users.noreply.github.com>: fix inline defs in too-many-statements
+- Mads Kiilerich <mads@kiilerich.com>
+- Maarten ter Huurne <maarten@treewalker.org>
+- Lefteris Karapetsas <lefteris@refu.co>
+- LCD 47 <lcd047@gmail.com>
+- Justin Li <justinnhli@gmail.com> (justinnhli)
+- John Kirkham <jakirkham@gmail.com>
+- Jens H. Nielsen <Jens.Nielsen@microsoft.com>
+- Ioana Tagirta <ioana.tagirta@gmail.com>: fix bad thread instantiation check
+- Ikraduya Edian <ikraduya@gmail.com>: Added new checks 'consider-using-generator' and 'use-a-generator'.
+- Hugues Bruant <hugues.bruant@affirm.com>
+- Harut <yes@harutune.name>
+- Grygorii Iermolenko <gyermolenko@gmail.com>
+- Gabriel R. Sezefredo <g@briel.dev>: Fixed "exception-escape" false positive with generators
+- Filipe Brandenburger <filbranden@google.com>
+- Fantix King <fantix@uchicago.edu> (UChicago)
+- Elias Dorneles <eliasdorneles@gmail.com>: minor adjust to config defaults and docs
+- Derek Harland <derek.harland@finq.co.nz>
+- David Pursehouse <david.pursehouse@gmail.com>
+- Daniel Miller <millerdev@gmail.com>
+- Chris Murray <chris@chrismurray.scot>
+- Chris Lamb <chris@chris-lamb.co.uk>
+- Charles Hebert <charles.hebert@logilab.fr>
+- Carli Freudenberg <carli.freudenberg@energymeteo.de> (CarliJoy)
+  * Fixed issue 5281, added Unicode checker
+  * Improve non-ascii-name checker
+- Buck Golemon <workitharder@gmail.com>
+- Brian Shaginaw <brian.shaginaw@warbyparker.com>: prevent error on exception check for functions
+- Benny Mueller <benny.mueller91@gmail.com>
+- Ben James <benjames1999@hotmail.co.uk>
+- Ben Green <benhgreen@icloud.com>
+- Batuhan Taskaya <batuhanosmantaskaya@gmail.com>
+- Alexander Kapshuna <kapsh@kap.sh>
+- Adam Parkin <pzelnip@users.noreply.github.com>
+- 谭九鼎 <109224573@qq.com>
+- Łukasz Sznuk <ls@rdprojekt.pl>
+- y2kbugger <y2kbugger@users.noreply.github.com>
+- vinnyrose <vinnyrose@users.noreply.github.com>
+- ttenhoeve-aa <ttenhoeve@appannie.com>
+- thinwybk <florian.k@mailbox.org>
+- syutbai <syutbai@gmail.com>
+- sdet_liang <liangway@users.noreply.github.com>
+- pyves@crater.logilab.fr <pyves@crater.logilab.fr>
+- paschich <millen@gridium.com>
+- oittaa <8972248+oittaa@users.noreply.github.com>
+- moxian <aleftmail@inbox.ru>
+- mar-chi-pan <mar.polatoglou@gmail.com>
+- ludal@logilab.fr <ludal@logilab.fr>
+- lrjball <50599110+lrjball@users.noreply.github.com>
+- laike9m <laike9m@users.noreply.github.com>
+- jpkotta@shannon <jpkotta@shannon>
+- jaydesl <35102795+jaydesl@users.noreply.github.com>
+- jab <jab@users.noreply.github.com>
+- glmdgrielson <32415403+glmdgrielson@users.noreply.github.com>
+- glegoux <gilles.legoux@gmail.com>
+- gaurikholkar <f2013002@goa.bits-pilani.ac.in>
+- flyingbot91 <flyingbot91@gmx.com>
+- fahhem <fahhem>
+- fadedDexofan <fadedDexofan@gmail.com>
+- danields <danields761@gmail.com>
+- cosven <cosven@users.noreply.github.com>
+- cordis-dev <darius@adroiti.com>
+- bluesheeptoken <louis.fruleux1@gmail.com>
+- anatoly techtonik <techtonik@gmail.com>
+- amdev@AMDEV-WS01.cisco.com <amdev@AMDEV-WS01.cisco.com>
+- agutole <toldo_carp@hotmail.com>
+- Zeckie <49095968+Zeckie@users.noreply.github.com>
+- Zeb Nicholls <zebedee.nicholls@climate-energy-college.org>
+  * Made W9011 compatible with 'of' syntax in return types
+- Yuval Langer <yuvallanger@mail.tau.ac.il>
+- Yury Gribov <tetra2005@gmail.com>
+- Yuri Bochkarev <baltazar.bz@gmail.com>: Added epytext support to docparams extension.
+- Youngsoo Sung <ysung@bepro11.com>
+- Yory <39745367+yory8@users.noreply.github.com> (yory8)
+- Yoichi Nakayama <yoichi.nakayama@gmail.com>
+- Yeting Li <liyt@ios.ac.cn> (yetingli)
+- Yannack <yannack@users.noreply.github.com>
+- Yann Dirson <ydirson@free.fr>
+- Yang Yang <y4n9squared@gmail.com>
+- Xi Shen <davidshen84@gmail.com>
+- Will Shanks <wsha@posteo.net>
+- Viorel Știrbu <viorels@gmail.com>: intern-builtin warning.
+- Victor Jiajunsu <16359131+jiajunsu@users.noreply.github.com>
+- Trevor Bekolay <tbekolay@gmail.com>
+  * Added --list-msgs-enabled command
+- Tomer Chachamu <tomer.chachamu@gmail.com>: simplifiable-if-expression
+- Tomasz Magulski <tomasz@magullab.io>
+- Tim Hatch <tim@timhatch.com>
+- Tim Gates <tim.gates@iress.com>
+- Tanvi Moharir <74228962+tanvimoharir@users.noreply.github.com>: Fix for invalid toml config
+- T.Rzepka <Tobias.Rzepka@gmail.com>
+- Svetoslav Neykov <svet@hyperscience.com>
+- Stéphane Wirtel <stephane@wirtel.be>: nonlocal-without-binding
+- Stephen Longofono <8992396+SLongofono@users.noreply.github.com>
+- Stanislav Levin <slev@altlinux.org>
+- Sorin Sbarnea <ssbarnea@redhat.com>
+- Slavfox <slavfoxman@gmail.com>
+- Skip Montanaro <skip@pobox.com>
+- Shiv Venkatasubrahmanyam <shvenkat@users.noreply.github.com>
+- Sebastian Müller <mueller.seb@posteo.de>
+- Saugat Pachhai <suagatchhetri@outlook.com>
+- Sasha Bagan <pnlbagan@gmail.com>
+- Sardorbek Imomaliev <sardorbek.imomaliev@gmail.com>
+- Santiago Castro <bryant@montevideo.com.uy>
+- Sandro Tosi <sandro.tosi@gmail.com>: Debian packaging
+- Samuel Freilich <sfreilich@google.com> (sfreilich)
+- Samuel FORESTIER <HorlogeSkynet@users.noreply.github.com>
+- Sam Vermeiren <88253337+PaaEl@users.noreply.github.com> (PaaEl)
+- Ryan McGuire <ryan@enigmacurry.com>
+- Ry4an Brase <ry4an-hg@ry4an.org>
+- Ruro <ruro.ruro@ya.ru>
+- Roman Ivanov <me@roivanov.com>
+- Robin Tweedie <70587124+robin-wayve@users.noreply.github.com>
+- Robert Schweizer <robert_schweizer@gmx.de>
+- Reverb Chu <reverbc@users.noreply.github.com>
+- Renat Galimov <renat2017@gmail.com>
+- Rebecca Turner <rbt@sent.as> (9999years)
+- Randall Leeds <randall@bleeds.info>
+- Ramiro Leal-Cavazos <ramiroleal050@gmail.com> (ramiro050): Fixed bug preventing pylint from working with emacs tramp
+- Qwiddle13 <32040075+Qwiddle13@users.noreply.github.com>
+- Quentin Young <qlyoung@users.noreply.github.com>
+- Petr Pulc <petrpulc@gmail.com>: require whitespace around annotations
+- Peter Dawyndt <Peter.Dawyndt@UGent.be>
+- Peter Bittner <django@bittner.it>
+- Peter Aronoff <peter@aronoff.org>
+- Paul Cochrane <paul@liekut.de>
+- Patrik <patrik.mrx@gmail.com>
+- Pascal Corpet <pcorpet@users.noreply.github.com>
+- Pablo Galindo Salgado <Pablogsal@gmail.com>
+  * Fix false positive 'Non-iterable value' with async comprehensions.
+- Oisín Moran <OisinMoran@users.noreply.github.com>
+- Obscuron <Abscuron@gmail.com>
+- Noam Yorav-Raphael <noamraph@gmail.com>
+- Nir Soffer <nirsof@gmail.com>
+- Niko Wenselowski <niko@nerdno.de>
+- Nikita Sobolev <mail@sobolevn.me>
+- Nick Smith <clickthisnick@users.noreply.github.com>
+- Ned Batchelder <ned@nedbatchelder.com>
+- Natalie Serebryakova <natalie.serebryakova@Natalies-MacBook-Pro.local>
+- Mitchell Young <mitchelly@gmail.com>: minor adjustment to docparams
+- Mitar <mitar.github@tnode.com>
+- Mike Fiedler <miketheman@gmail.com> (miketheman)
+- Mike Bryant <leachim@leachim.info>
+- Michka Popoff <michkapopoff@gmail.com>
+- Michal Vasilek <michal@vasilek.cz>
+- Michael Scott Cuthbert <cuthbert@mit.edu>
+- Michael Kefeder <oss@multiwave.ch>
+- Michael Hudson-Doyle <michael.hudson@canonical.com>
+- Michael Giuffrida <mgiuffrida@users.noreply.github.com>
+- Melvin Hazeleger <31448155+melvio@users.noreply.github.com> (melvio)
+- Matěj Grabovský <mgrabovs@redhat.com>
+- Matthijs Blom <19817960+MatthijsBlom@users.noreply.github.com>
+- Matej Marušák <marusak.matej@gmail.com>
+- Markus Siebenhaar <41283549+siehar@users.noreply.github.com>
+- Marco Edward Gorelli <marcogorelli@protonmail.com>: Documented Jupyter integration
+- Marcin Kurczewski <rr-@sakuya.pl> (rr-)
+- Maik Röder <maikroeder@gmail.com>
+- Louis Sautier <sautier.louis@gmail.com>
+- Lorena Buciu <46202743+lorena-b@users.noreply.github.com> (lorena-b)
+- Logan Miller <14319179+komodo472@users.noreply.github.com> (komodo472)
+- Kári Tristan Helgason <kthelgason@gmail.com>
+- Kurian Benoy <70306694+kurianbenoy-aot@users.noreply.github.com>
+- Krzysztof Czapla <k.czapla68@gmail.com>
+- Kraig Brockschmidt <kraigbr@msn.com>
+- Kound <norman.freudenberg@posteo.de>
+- Kosarchuk Sergey <sergeykosarchuk@gmail.com>
+- Konrad Weihmann <46938494+priv-kweihmann@users.noreply.github.com>
+- Kian Meng, Ang <kianmeng.ang@gmail.com>
+- Kevin Phillips <thefriendlycoder@gmail.com>
+- Kevin Jing Qiu <kevin.jing.qiu@gmail.com>
+- Kayran Schmidt <59456929+yumasheta@users.noreply.github.com>
+- Jürgen Hermann <jh@web.de>
+- Jérome Perrin <perrinjerome@gmail.com> (perrinjerome)
+- Josselin Feist <josselin@trailofbits.com>
+- Jonathan Kotta <KottaJonathan@JohnDeere.com>
+- John Paraskevopoulos <io.paraskev@gmail.com>: add 'differing-param-doc' and 'differing-type-doc'
+- John McGehee <jmcgehee@altera.com>
+- John Gabriele <jgabriele@fastmail.fm>
+- John Belmonte <john@neggie.net>
+- Joffrey Mander <joffrey.mander+pro@gmail.com>
+- Jochen Preusche <iilei@users.noreply.github.com> (iilei)
+- Jeroen Seegers <jeroenseegers@users.noreply.github.com> (jeroenseegers)
+  * Fixed `toml` dependency issue
+- Jeremy Fleischman <jeremyfleischman@gmail.com> (jfly)
+- Jason Owen <jason.a.owen@gmail.com>
+- Jared Garst <cultofjared@gmail.com>
+- Jared Deckard <jared.deckard@gmail.com>
+- Janne Rönkkö <jannero@users.noreply.github.com>
+- James Sinclair <james@nurfherder.com> (irgeek)
+- James M. Allen <james.m.allen@gmail.com>
+- James Lingard <jchl@aristanetworks.com>
+- James Broadhead <jamesbroadhead@gmail.com>
+- Jakob Normark <jakobnormark@gmail.com>
+- Jake Lishman <jake@binhbar.com> (jakelishman)
+- Jacques Kvam <jwkvam@gmail.com>
+- Jace Browning <jacebrowning@gmail.com>: updated default report format with clickable paths
+- JT Olds <jtolds@xnet5.com>
+- Hayden Richards <62866982+SupImDos@users.noreply.github.com> (SupImDos)
+  * Fixed "no-self-use" for async methods
+  * Fixed "docparams" extension for async functions and methods
+- Harshil <37377066+harshil21@users.noreply.github.com> (harshil21)
+- Grant Welch <gwelch925+github@gmail.com>
+- Giuseppe Valente <gvalente@arista.com>
+- Gary Tyler McLeod <mail@garytyler.com>
+- Felix von Drigalski <FvDrigalski@gmail.com> (felixvd)
+- Fabrice Douchant <Fabrice.Douchant@logilab.fr>
+- Fabio Natali <me@fabionatali.com>
+- Fabian Damken <fdamken+github@frisp.org>
+- Eric Froemling <ericfroemling@gmail.com>
+- Emmanuel Chaudron <manu.chaud@hotmail.fr>
+- Elizabeth Bott <52465744+elizabethbott@users.noreply.github.com>
+- Eisuke Kawashima <e-kwsm@users.noreply.github.com> (e-kwsm)
+- Edgemaster <grand.edgemaster@gmail.com>
+- Drew Risinger <drewrisinger@users.noreply.github.com>
+- Dr. Nick <das-intensity@users.noreply.github.com>
+- Don Jayamanne <don.jayamanne@yahoo.com>
+- Dmytro Kyrychuk <dmytro.kyrychuck@gmail.com>
+- Denis Laxalde <denis.laxalde@logilab.fr>
+- David Cain <davidjosephcain@gmail.com>
+- Danny Hermes <daniel.j.hermes@gmail.com>
+- Daniele Procida <daniele@vurt.org>
+- Daniela Plascencia <daplascen@gmail.com>
+- Daniel R. Neal <dan.r.neal@gmail.com> (danrneal)
+- Daniel Draper <Germandrummer92@users.noreply.github.com>
+- Daniel Dorani <ddandd@gmail.com> (doranid)
+- Daniel Brookman <53625739+dbrookman@users.noreply.github.com>
+- Dan Garrette <dhgarrette@gmail.com>
+- Damien Nozay <damien.nozay@gmail.com>
+- Craig Citro <craigcitro@gmail.com>
+- Clément Pit-Claudel <cpitclaudel@users.noreply.github.com>
+- Christopher Zurcher <zurcher@users.noreply.github.com>
+- Carl Crowder <bitbucket@carlcrowder.com>: don't evaluate the value of arguments for 'dangerous-default-value'
+- Carey Metcalfe <carey@cmetcalfe.ca>: demoted `try-except-raise` from error to warning
+- Cameron Olechowski <camsterole@users.noreply.github.com>
+- Calin Don <calin.don@gmail.com>
+- Caio Carrara <ccarrara@redhat.com>
+- C.A.M. Gerlach <WIDEnetServices@gmail.com>
+- Bruno P. Kinoshita <kinow@users.noreply.github.com>
+- Brian C. Lane <bcl@redhat.com>
+- Brandon W Maister <quodlibetor@gmail.com>
+- BioGeek <jeroen.vangoey@gmail.com>
+- Benjamin Graham <benwilliamgraham@gmail.com>
+- Benedikt Morbach <benedikt.morbach@googlemail.com>
+- Banjamin Freeman <befreeman@users.noreply.github.com>
+- Athos Ribeiro <athoscr@fedoraproject.org>: Fixed dict-keys-not-iterating false positive for inverse containment checks
+- Arun Persaud <arun@nubati.net>
+- Arthur Lutz <arthur.lutz@logilab.fr>
+- Antonio Ossa <aaossa@uc.cl>
+- Anthony VEREZ <anthony.verez.external@cassidian.com>
+- Anthony Tan <tanant@users.noreply.github.com>
+- Anthony Foglia <afoglia@users.noreply.github.com> (Google): Added simple string slots check.
+- Anentropic <ego@anentropic.com>
+- Andy Palmer <25123779+ninezerozeronine@users.noreply.github.com>
+- Andrzej Klajnert <github@aklajnert.pl>
+- Andrew Howe <howeaj@users.noreply.github.com>
+- Andres Perez Hortal <andresperezcba@gmail.com>
+- Alok Singh <8325708+alok@users.noreply.github.com>
+- Allan Chandler <95424144+allanc65@users.noreply.github.com> (allanc65)
+  * Fixed issue 5452, false positive missing-param-doc for multi-line Google-style params
+- Alex Jurkiewicz <alex@jurkiewi.cz>
+- Alex Hearn <alex.d.hearn@gmail.com>
+- Alan Evangelista <alanoe@linux.vnet.ibm.com>
+- Alan Chan <achan961117@gmail.com>
+- Aivar Annamaa <aivarannamaa@users.noreply.github.com>
+- Aidan Haase <44787650+haasea@users.noreply.github.com>
+- Ahirnish Pareek <ahirnish@gmail.com>: 'keyword-arg-before-var-arg' check
+- Adrian Chirieac <chirieacam@gmail.com>
+- Aditya Gupta <adityagupta1089@users.noreply.github.com> (adityagupta1089)
+  * Added ignore_signatures to duplicate checker
+- Adam Dangoor <adamdangoor@gmail.com>
+
+
+Co-Author
+---------
+The following persons were credited manually but did not commit themselves
+under this name, or we did not manage to find their commits in the history.
+
+- Agustin Toledo
+- Amaury Forgeot d'Arc: check names imported from a module exists in the module
+- Anthony Tan
+- Axel Muller
+- Benjamin Niemann: allow block level enabling/disabling of messages
+- Bernard Nauwelaerts
+- Bill Wendling
+- Brian van den Broek: windows installation documentation
+- Craig Henriques
+- D. Alphus (Alphadelta14)
+- Daniil Kharkov
+- Eero Vuojolahti
+- Fabio Zadrozny
+- Gauthier Sebaux
+- James DesLauriers
+- manderj
+- Mirko Friedenhagen
+- Nicholas Smith
+- Nuzula H. Yudaka (Nuzhuka)
+- Pek Chhan
+- Peter Hammond
+- Pierre Rouleau
+- Richard Goodman: simplifiable-if-expression (with Tomer Chachamu)
+- Sebastian Ulrich
+- Takashi Hirashima
+- Thomas Snowden: fix missing-docstring for inner functions
+- Wolfgang Grafen
+- Yannick Brehon
diff --git a/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/LICENSE
new file mode 100644
index 0000000..8c4c849
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/LICENSE
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+	51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 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, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year  name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/METADATA b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/METADATA
new file mode 100644
index 0000000..18474e8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/METADATA
@@ -0,0 +1,239 @@
+Metadata-Version: 2.1
+Name: pylint
+Version: 2.13.9
+Summary: python code static checker
+Author: Python Code Quality Authority
+Author-email: code-quality@python.org
+License: GPL-2.0-or-later
+Project-URL: Homepage, https://www.pylint.org/
+Project-URL: Source Code, https://github.com/PyCQA/pylint
+Project-URL: What's New, https://pylint.pycqa.org/en/latest/whatsnew/
+Project-URL: Bug Tracker, https://github.com/PyCQA/pylint/issues
+Project-URL: Discord Server, https://discord.gg/Egy6P8AMB5
+Project-URL: Docs: User Guide, https://pylint.pycqa.org/en/latest/
+Project-URL: Docs: Contributing, https://pylint.pycqa.org/en/latest/development_guide/contribute.html
+Project-URL: Docs: Technical Reference, https://pylint.pycqa.org/en/latest/technical_reference/index.html
+Keywords: static code analysis linter python lint
+Classifier: Development Status :: 6 - Mature
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.6.2
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: CONTRIBUTORS.txt
+Requires-Dist: dill (>=0.2)
+Requires-Dist: platformdirs (>=2.2.0)
+Requires-Dist: astroid (<=2.12.0-dev0,>=2.11.5)
+Requires-Dist: isort (<6,>=4.2.5)
+Requires-Dist: mccabe (<0.8,>=0.6)
+Requires-Dist: typing-extensions (>=3.10.0) ; python_version < "3.10"
+Requires-Dist: tomli (>=1.1.0) ; python_version < "3.11"
+Requires-Dist: colorama ; sys_platform == "win32"
+Provides-Extra: testutil
+Requires-Dist: gitpython (>3) ; extra == 'testutil'
+
+
+README for Pylint - https://pylint.pycqa.org/
+=============================================
+
+.. image:: https://github.com/PyCQA/pylint/actions/workflows/ci.yaml/badge.svg?branch=main
+    :target: https://github.com/PyCQA/pylint/actions
+
+.. image:: https://coveralls.io/repos/github/PyCQA/pylint/badge.svg?branch=main
+    :target: https://coveralls.io/github/PyCQA/pylint?branch=main
+
+
+.. image:: https://img.shields.io/pypi/v/pylint.svg
+    :alt: Pypi Package version
+    :target: https://pypi.python.org/pypi/pylint
+
+.. image:: https://readthedocs.org/projects/pylint/badge/?version=latest
+    :target: https://pylint.readthedocs.io/en/latest/?badge=latest
+    :alt: Documentation Status
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/ambv/black
+
+.. image:: https://results.pre-commit.ci/badge/github/PyCQA/pylint/main.svg
+   :target: https://results.pre-commit.ci/latest/github/PyCQA/pylint/main
+   :alt: pre-commit.ci status
+
+.. |tideliftlogo| image:: https://raw.githubusercontent.com/PyCQA/pylint/main/doc/media/Tidelift_Logos_RGB_Tidelift_Shorthand_On-White.png
+   :width: 75
+   :height: 60
+   :alt: Tidelift
+
+.. list-table::
+   :widths: 10 100
+
+   * - |tideliftlogo|
+     - Professional support for pylint is available as part of the `Tidelift
+       Subscription`_.  Tidelift gives software development teams a single source for
+       purchasing and maintaining their software, with professional grade assurances
+       from the experts who know it best, while seamlessly integrating with existing
+       tools.
+
+.. _Tidelift Subscription: https://tidelift.com/subscription/pkg/pypi-pylint?utm_source=pypi-pylint&utm_medium=referral&utm_campaign=readme
+
+
+======
+Pylint
+======
+
+**It's not just a linter that annoys you!**
+
+Pylint is a Python static code analysis tool which looks for programming errors,
+helps enforcing a coding standard, sniffs for code smells and offers simple refactoring
+suggestions.
+
+It's highly configurable, having special pragmas to control its errors and warnings
+from within your code, as well as from an extensive configuration file.
+It is also possible to write your own plugins for adding your own checks or for
+extending pylint in one way or another.
+
+It's a free software distributed under the GNU General Public Licence unless
+otherwise specified.
+
+Development is hosted on GitHub: https://github.com/PyCQA/pylint/
+
+You can use the code-quality@python.org mailing list to discuss about
+Pylint. Subscribe at https://mail.python.org/mailman/listinfo/code-quality/
+or read the archives at https://mail.python.org/pipermail/code-quality/
+
+Pull requests are amazing and most welcome.
+
+Install
+-------
+
+Pylint can be simply installed by running::
+
+    pip install pylint
+
+If you are using Python 3.6.2+, upgrade to get full support for your version::
+
+    pip install pylint --upgrade
+
+If you want to install from a source distribution, extract the tarball and run
+the following command ::
+
+    python setup.py install
+
+
+Do make sure to do the same for astroid, which is used internally by pylint.
+
+For debian and rpm packages, use your usual tools according to your Linux distribution.
+
+More information about installation and available distribution format
+can be found here_.
+
+Documentation
+-------------
+
+The documentation lives at https://pylint.pycqa.org/.
+
+Pylint is shipped with following additional commands:
+
+* pyreverse: an UML diagram generator
+* symilar: an independent similarities checker
+* epylint: Emacs and Flymake compatible Pylint
+
+
+Testing
+-------
+
+We use tox_ and pytest-benchmark_ for running the test suite. You should be able to install it with::
+
+    pip install tox pytest pytest-benchmark
+
+
+To run the test suite for a particular Python version, you can do::
+
+    tox -e py37
+
+
+To run individual tests with ``tox``, you can do::
+
+    tox -e py37 -- -k name_of_the_test
+
+
+We use pytest_ for testing ``pylint``, which you can use without using ``tox`` for a faster development cycle.
+
+If you want to run tests on a specific portion of the code with pytest_, (pytest-cov_) and your local python version::
+
+    # ( pip install pytest-cov )
+    # Everything:
+    python3 -m pytest tests/
+    # Everything in tests/message with coverage for the relevant code:
+    python3 -m pytest tests/message/ --cov=pylint.message
+    coverage html
+    # Only the functional test "missing_kwoa_py3":
+    python3 -m pytest "tests/test_functional.py::test_functional[missing_kwoa_py3]"
+
+
+Do not forget to clone astroid_ and install the last version::
+
+
+    git clone https://github.com/PyCQA/astroid.git
+
+    # From source
+    python3 astroid/setup.py build sdist
+    pip3 install astroid/dist/astroid*.tar.gz
+
+    # Using an editable installation
+    cd astroid
+    python3 -m pip install -e .
+
+Show your usage
+-----------------
+
+You can place this badge in your README to let others know your project uses pylint.
+
+    .. image:: https://img.shields.io/badge/linting-pylint-yellowgreen
+        :target: https://github.com/PyCQA/pylint
+
+Use the badge in your project's README.md (or any other Markdown file)::
+
+    [![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/PyCQA/pylint)
+
+Use the badge in your project's README.rst (or any other rst file)::
+
+    .. image:: https://img.shields.io/badge/linting-pylint-yellowgreen
+        :target: https://github.com/PyCQA/pylint
+
+
+If you use GitHub Actions, and one of your CI workflows begins with "name: pylint", you
+can use GitHub's `workflow status badges <https://docs.github.com/en/actions/monitoring-and-troubleshooting-workflows/adding-a-workflow-status-badge#using-the-workflow-file-name>`_
+to show an up-to-date indication of whether pushes to your default branch pass pylint.
+For more detailed information, check the documentation.
+
+.. _here: https://pylint.pycqa.org/en/latest/user_guide/installation.html
+.. _tox: https://tox.readthedocs.io/en/latest/
+.. _pytest: https://docs.pytest.org/en/latest/
+.. _pytest-benchmark: https://pytest-benchmark.readthedocs.io/en/latest/index.html
+.. _pytest-cov: https://pypi.org/project/pytest-cov/
+.. _astroid: https://github.com/PyCQA/astroid
+
+License
+-------
+
+pylint is, with a few exceptions listed below, `GPLv2 <https://github.com/PyCQA/pylint/blob/main/LICENSE>`_.
+
+The icon files are licensed under the `CC BY-SA 4.0 <https://creativecommons.org/licenses/by-sa/4.0/>`_ license:
+
+- `doc/logo.png <https://raw.githubusercontent.com/PyCQA/pylint/main/doc/logo.png>`_
+- `doc/logo.svg <https://raw.githubusercontent.com/PyCQA/pylint/main/doc/logo.svg>`_
diff --git a/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/RECORD b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/RECORD
new file mode 100644
index 0000000..040b21c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/RECORD
@@ -0,0 +1,159 @@
+../../../bin/epylint,sha256=5KIpDASgVdCj6_RgJJhv24rmIHsLZPbcreYZAdwcTS8,260
+../../../bin/pylint,sha256=XCsj0xpu8_2OQ3_kehrgreZ2QNLwvNx--ktklbVPEHg,258
+../../../bin/pyreverse,sha256=o2Gt29AOl4ZHqN6iVLC3Gw1lvVLklUFfhE0HKEY2pSU,264
+../../../bin/symilar,sha256=shtY5sey2ImK3Gxaz0slZjDlwOQueW1y_-p18nBhKco,260
+pylint/__init__.py,sha256=wowS7WjDYkFOka0WWqTPq_vOvNPDA9r2zxGoPN2izUw,2834
+pylint/__main__.py,sha256=m1y5m7Ky8HtyNnE8ftGSnRSTDgv5suq8P-B4V_KD3JY,305
+pylint/__pkginfo__.py,sha256=Gy4ceP38MwCWGkR9l4kNvz1-n2w-xRDiHb3J9hTh0_A,1042
+pylint/constants.py,sha256=WiyFgf_qePiuQsDcFyyfSjs2pZJOZGoHtt7_P04HvLs,7226
+pylint/epylint.py,sha256=Em_3VzKB9h16KTQ3PgNWmxqmEVTt73VfK-cfZfzF3ZM,6188
+pylint/exceptions.py,sha256=mSxzRHuul3CPiHWb8SBgufOS8ipeRg2eGqkZMxLjO-c,991
+pylint/graph.py,sha256=fd9AzH73PngzksIFbmErGx1rAVahYt2IGzqd-_cDoAc,6703
+pylint/interfaces.py,sha256=5KkH8aL3RKXxnDoTlPpVnJJOj_SlT0uCTY39pZC2xz4,3150
+pylint/typing.py,sha256=_k_k0navT6lF7YQ6fA9b_6zSS4fsYZHamAtTNx3kdmc,1740
+pylint/checkers/__init__.py,sha256=fybTiH5hbxtHOfdi_0HIsRwcBJcbUDkBfMjAQ2LbIQg,4203
+pylint/checkers/async.py,sha256=gTsju4TRDT56S8PRiVYaMBpNt2kayJX6OPSAjh9FZbc,3927
+pylint/checkers/base_checker.py,sha256=QGUQIvQmGsbS4I2o_PECpaXVR9_t91Won_4myyasP-M,7135
+pylint/checkers/deprecated.py,sha256=QmKXTFBF29AcbojmzW4PIH-lbNeRe6IKCl-0fg3Tplw,9172
+pylint/checkers/design_analysis.py,sha256=k8Cz7MAJg-Yt52kyIZdMqV-o7n93N_h66I6Ju4g0MBw,21940
+pylint/checkers/ellipsis_checker.py,sha256=vhEIEo6-N12ty5JUj43-aXrWU6MhpAYjdJGWuGWvi_Q,2041
+pylint/checkers/exceptions.py,sha256=AwnB3vW8H1eZWFg9EeMN0x7eNed876wmA3J-VEL3QZY,21874
+pylint/checkers/format.py,sha256=f8lHZhcxjbMbtYgEihPgWAnnHIXtJbnVWDZFZsQyd6w,28288
+pylint/checkers/imports.py,sha256=afbINXi1vaCKqkaFr_VySpXqpLiyjw5puzdfvuX2oDo,36726
+pylint/checkers/logging.py,sha256=rniPUqpopfszCF6WiYBC7EVgfQu4_4YmFxHkl3GfFv8,14699
+pylint/checkers/mapreduce_checker.py,sha256=Dw9xu8rRcYjhqMmqZajbhxAGaXxUSw6tTx5ev5KThxc,618
+pylint/checkers/misc.py,sha256=m8tArSRxH1hP-RoXfXJKLe91917oy4mfNu8Agtj51TY,6234
+pylint/checkers/modified_iterating_checker.py,sha256=RGE_RKTSuGSf5MSTXlmtECkyYm_fprre2tBjOvvsqw0,5805
+pylint/checkers/newstyle.py,sha256=lB8yHQCNFx5ay770_xMIr1lyunsCiYt24fFIEbPvuf8,4301
+pylint/checkers/non_ascii_names.py,sha256=Zf783jQo5gQPxToD8pDsOj6JIpZkbList6z65bXM6qI,7919
+pylint/checkers/raw_metrics.py,sha256=ZdCHhrZ4n1XNEayDSwKdwpXq3ib71lfxhTRMofhF-Mk,3746
+pylint/checkers/similar.py,sha256=j_UEqcb_XlDJNLliNQTk_wEy7pQNrTbxDuwVGeIt9pM,34317
+pylint/checkers/spelling.py,sha256=Yh5owAekdEw8ioEy7v3gUF9kyAS5PWH6uFj_zQ-tY0A,15062
+pylint/checkers/stdlib.py,sha256=_pyqOWm1vrkVfQVmGGaWhgu4-B4lWOg3w8suu55KMv8,29107
+pylint/checkers/strings.py,sha256=UVquIDvm1WSyriH5lAZiiwRdaF-ZxQmm6oRr-us7Ejg,39290
+pylint/checkers/threading_checker.py,sha256=mT3PBk6MY1KFQZjDRvQumFfIk48cC6TJkLCFN031S1s,1962
+pylint/checkers/typecheck.py,sha256=4C-0XcgMtWEnkxas3xBku3hPs90wucH-7AT0ZrL4d9I,79370
+pylint/checkers/unicode.py,sha256=GMiNVypRYV0XXT5NRQ_DiLCTYcbX-__DcIVEC02M_oQ,18508
+pylint/checkers/unsupported_version.py,sha256=eGrDg59SWbtxEmGRqfG4qiQQAQdl6en5SSF65LdcSX0,3066
+pylint/checkers/utils.py,sha256=gOMn2gHQ49iIg8KMoziHeNajEQA4JeQJ5870NlldZsk,58341
+pylint/checkers/variables.py,sha256=ioskm8vKIwGJtI-oSQwFn2FmSjvglADsvBk4QO1w-D4,112575
+pylint/checkers/base/__init__.py,sha256=XVwrBM1UgbpJS9_gf41eZC8KwPXIuJe6r7iAeoyAgWc,1450
+pylint/checkers/base/basic_checker.py,sha256=4fSGz8hDyXtW8LsCpcIRAesgUqaer5CBWB7JxIRNixw,33889
+pylint/checkers/base/basic_error_checker.py,sha256=-K5tfbSiJ2tDzGeAWFsDh7VmBwHLWEVp4V72sNGxJWk,21642
+pylint/checkers/base/comparison_checker.py,sha256=kCCjjRCrBhNA7ErNkMWlNYTIWa9RY2goea7Ijhk5MgU,11755
+pylint/checkers/base/docstring_checker.py,sha256=F8pDlPyfKEsP7YNajlCX4yxbsxgThfN6WW-viS4IipQ,7620
+pylint/checkers/base/pass_checker.py,sha256=aHSf1yUmcVAVN2jx0XMoFlOnLm93QnKdVc4O1G6hRv4,980
+pylint/checkers/base/name_checker/__init__.py,sha256=AKe0lfMl3OlPl7JkIJw3FATqC2XoXJ_k6hegPB13CcY,689
+pylint/checkers/base/name_checker/checker.py,sha256=dq7FIMju023hIRFF9OPoMOQ_gCfZdb9IY0OVu6OWNBE,22992
+pylint/checkers/base/name_checker/naming_style.py,sha256=o0CJ3N2SVkT6Rpgez_VlA3gaL_jm1lypNMirPeoWmTk,5734
+pylint/checkers/classes/__init__.py,sha256=fSYpKMUomn0cAtI30S1NnI8BBfa19JWDxdbRRpZVh8g,610
+pylint/checkers/classes/class_checker.py,sha256=mmCOHuzFk1YfFLByrsg52rybquAdtuAl2j8Q_CajXDw,83050
+pylint/checkers/classes/special_methods_checker.py,sha256=aUTt6thnE05ncrPkmAwX3N7PyJAMdPupoyGePGOhSE4,13972
+pylint/checkers/refactoring/__init__.py,sha256=VAKYPROaraWIlUEY1oE5ticUpFptYxUZmX9lS8fUQP8,1081
+pylint/checkers/refactoring/implicit_booleaness_checker.py,sha256=LeUCBfMIUSLp0ewcF5RJWQzqjOUbEzLAaI7KxyRK6ag,8881
+pylint/checkers/refactoring/not_checker.py,sha256=3A7gZRwvG0Rxbel09UMTHCQzlHXlaqhJpGRB1-qizlo,2869
+pylint/checkers/refactoring/recommendation_checker.py,sha256=8jt3M5PJyK40WeQ6RFuSr5Sy6syx3XAi6NwoSFQAi50,17279
+pylint/checkers/refactoring/refactoring_checker.py,sha256=PaWOkA8mwBnoopeXrKBYTL1fCzCRJlqNDUKC_X7yDxQ,80691
+pylint/config/__init__.py,sha256=B88Pw_BYI6SSzzmWBUE1xT7XS5BPT2SWlUsdQOBvjZg,4046
+pylint/config/config_initialization.py,sha256=q1kgI5t1TlkwVLPKMOrjxH-8jvymb6jBO0-saqbDtyM,2711
+pylint/config/configuration_mixin.py,sha256=rDfjBlafHXKM7K5OrQzwMNdATHF3LgFeY8BW-chSWhI,1183
+pylint/config/find_default_config_files.py,sha256=w71_1k52HiHgV-QygBlB0rlBWEgLbrYfgveRMK6rHSo,2768
+pylint/config/man_help_formatter.py,sha256=jbbxPUr3nsLdJZC3aPRiqBilvskkr3RW5zPnM5ND6MI,3678
+pylint/config/option.py,sha256=icKw2iaQxdSRLA9-wGNxY0rxFPMuFucwp8DbPFXFZwY,6810
+pylint/config/option_manager_mixin.py,sha256=vSJzSEugmuAN_fdYrudRWeyWmtEstWCTjHIdj0rak0c,15779
+pylint/config/option_parser.py,sha256=Zd1C1QkVpB28iJjaNY_5T8wKGLCH_VfsRRKV413t0_Q,1755
+pylint/config/options_provider_mixin.py,sha256=iZINbycOdOj_H_eh18iD7XaBezr7qIDvj4ceLEQj0Yc,4281
+pylint/extensions/__init__.py,sha256=aPPTyQywlFkYvUQv2Ao5mxAC3K9p2h_35qBuiMRyB7w,541
+pylint/extensions/_check_docs_utils.py,sha256=P53Y-niDLM5aSnuaiaN8LZpNajjy7XYEHAkxljne45Y,24479
+pylint/extensions/bad_builtin.py,sha256=xp6sxnDEeRB-KcWNVAbnaKZ1odG6Na7GXN0YnxqBVrM,2282
+pylint/extensions/broad_try_clause.py,sha256=YRJnIQj7j5Al6d17gvr2rHjyWIdA9NfJszHvuQD07rM,2311
+pylint/extensions/check_elif.py,sha256=am3wgnxSUJrTStqgeEa20CYfbGbgDtQ_wwXUuLGQR4A,2043
+pylint/extensions/code_style.py,sha256=d8v9ZAvs_1DDgYBHmONUgOe64vnSiITTOxciFkwEIN4,12283
+pylint/extensions/comparetozero.py,sha256=qmDGAdhKCOrXHHpZ8Aebp7NpbK_dcahRD0MAe79xWQg,2446
+pylint/extensions/comparison_placement.py,sha256=QvMFg7WsPYlUzqTTXEO2RbwH5iLHnanCaKGqq_t-RyE,2385
+pylint/extensions/confusing_elif.py,sha256=gku0rEl2GIxsAN03I6wLGAkcFeyiv6zN3gpRM6iUu2c,2035
+pylint/extensions/consider_ternary_expression.py,sha256=e6APIDaM7wcPVPAVH51xMbyFfZFqY4Ag22-LFh8AtYA,1753
+pylint/extensions/docparams.py,sha256=LT5IwYIjOD7W_9RKb3_J1JSYElHHSLHDXH3GeonWV_A,24603
+pylint/extensions/docstyle.py,sha256=sdVa-I27lXigmeVwFc2spKkMig1aywTpvlmB_Zv_1KU,2972
+pylint/extensions/empty_comment.py,sha256=DKh9vkf7uUNzVdBGb7OsNDGqL4FH2L-B6x-sbzpx07k,1982
+pylint/extensions/emptystring.py,sha256=01fbWapvipHvRb_WIX-hZc4VoUUM9b3CevT9MgNg7Yc,2447
+pylint/extensions/eq_without_hash.py,sha256=NP7R-yHkZkcKim8mnMFYjeGC1cdgDstSa0OiLSMmgw0,1492
+pylint/extensions/for_any_all.py,sha256=snpGWdCGqwpVOBzEPR301S0GWW4Em0n2_WPpbOYYQzc,2899
+pylint/extensions/mccabe.py,sha256=8EuGPe3OvGwEYwUSyT-c2o2NFGFD6tkn-VPXUXqnAOw,5965
+pylint/extensions/overlapping_exceptions.py,sha256=p1er2b0ZXufuWq8DclnohcJ_MOocr-Jn-xNibRAHhlA,3368
+pylint/extensions/private_import.py,sha256=MwAwnKmDCW0bofQTOY8A0TdG3j_qKSRAMRzluFR67AE,11039
+pylint/extensions/redefined_variable_type.py,sha256=05aQRIjJG2Esen2gwZBe7TEBHJAxyQqlb1YDwpxoYng,4033
+pylint/extensions/set_membership.py,sha256=ZgchFAyJa_Y56OXfX9tGI88YYASa6Qys6LNw31__GrA,1846
+pylint/extensions/typing.py,sha256=g1eZ_EL6z8FCDX_1rS3bulvzQ_Vv2Yj_wrbwX-gGqro,17674
+pylint/extensions/while_used.py,sha256=DvINDDVfrxpWuVWZUvVKUjT7La_YmeZQtTesb1OSElc,1036
+pylint/lint/__init__.py,sha256=QbSDo2TvkcBU7FtC9BH0rapL2BzuCP4UKtng4ezFlJ0,1230
+pylint/lint/expand_modules.py,sha256=yunPpjd0b_kxAHBK3ImlMIkD2gXgkfzgJvadevGn8Uw,5805
+pylint/lint/parallel.py,sha256=zvY7GJDukDeA7zJ8ZTMYc9Wt0GJN_EX5Ms-y8jpg2Y4,6672
+pylint/lint/pylinter.py,sha256=Rp8dlrI9-Ggx3cZw66YZ0sjIZxUp6un6YwM6p6UBbt8,72210
+pylint/lint/report_functions.py,sha256=ukqJjP8GS8e3Ot-3FRuDxQ8rHIKFtt75965kILf1z9w,2856
+pylint/lint/run.py,sha256=VUVvVCjXOGRlwyEvxC2QQVSR31IvpydLFoSVAcDlKqg,18695
+pylint/lint/utils.py,sha256=aHLH1UcSDjx45hEa583y3EaXtVI4c6Z518UZDXmV9J8,4284
+pylint/message/__init__.py,sha256=OriAknwmd-zP1XxtaAZdks1rUxwIXTLjYD-Z64SJHsU,622
+pylint/message/message.py,sha256=n8ggi7NYCdk4flv3H8IY3qdk2klBpTS7YLmnTny2-Sg,2485
+pylint/message/message_definition.py,sha256=kpm7rsJbtaedKDK-sMafQ2_w1hPLu6VW-AL9FH2vcsE,4585
+pylint/message/message_definition_store.py,sha256=5SYIv3y_HluQD0MUGs26RmtANNTAU11KfUUuEGWYvQg,4873
+pylint/message/message_id_store.py,sha256=fxwac6OAnKBn8c8E1ly7X9TL4UP6ljqhfKvG2gcp7VU,5556
+pylint/pyreverse/__init__.py,sha256=UUSMmrmRuB0ez663hA0gOeXaTsTBQaqhlR6Rzca2taM,274
+pylint/pyreverse/diadefslib.py,sha256=Ud_yeP5aGnhSd8gvmaz_JAgUD-OG9fz2CrMNpBgM1a0,8048
+pylint/pyreverse/diagrams.py,sha256=FyStHaMHeWvgCSpzcm37k73YQPkAVfJ81A24AV28URw,8943
+pylint/pyreverse/dot_printer.py,sha256=D27mynczGEJX29q_Oaq_QKC30od55TTcHX70M4WtGoo,5681
+pylint/pyreverse/inspector.py,sha256=9DTwHrKkx8ekA3RyDVNpaO9N3etRV9ReXksZviB8ayc,11553
+pylint/pyreverse/main.py,sha256=G0wRVW-We4YX8jVTcUwgLt5saivWJ_A0ovZuzG1TRHs,6643
+pylint/pyreverse/mermaidjs_printer.py,sha256=ldjTyopNtCab5WT6_yUQbkyVif7t5dUVoHd7SoU30Dk,3423
+pylint/pyreverse/plantuml_printer.py,sha256=slDfB_yY95LCp9LvIWxGab9qgj0elyQydUFiSAy56pc,3520
+pylint/pyreverse/printer.py,sha256=twQwnHylwReMVGLL1GNwuBFIyLlB9lG-c18pkUeUiZQ,3691
+pylint/pyreverse/printer_factory.py,sha256=rGcoLSOXGMTRhw1YzTRdKYH4RQ1XfYiIyaWO9CKfuis,895
+pylint/pyreverse/utils.py,sha256=jorOK1tcxIGaqjNlMaX4qeEx9NVcUStJYz7cA9fja64,9004
+pylint/pyreverse/vcg_printer.py,sha256=GvDzdDXRNSk6skYUF5z2XkcEMxST5rUgRr0pZVzTGzg,8516
+pylint/pyreverse/writer.py,sha256=pPJJitDYzRH7KCwjSpVPI9JaDkBY9kDikM1yGurDACU,6131
+pylint/reporters/__init__.py,sha256=BlhpFcaUoSfUXMW-MoNfOJZjOHY9gcB7Mqd6u7-54p0,991
+pylint/reporters/base_reporter.py,sha256=QakvuqOmw4XtP7iUIBShxs3LictEn53cgrwZlj9C_48,3177
+pylint/reporters/collecting_reporter.py,sha256=1w9ZAc-hy5lcZmkSDmObANdEAlsLWVxb0eAhM6Q8Xvk,691
+pylint/reporters/json_reporter.py,sha256=Ap99T0aoLQaCIK_f0YKyAweM3GZhEyAn40Lkzx-Emdg,1643
+pylint/reporters/multi_reporter.py,sha256=zpN5Lj570FvaEaxRLFYo-QkJpX2j2ftt-zJZAAomLLY,3680
+pylint/reporters/reports_handler_mix_in.py,sha256=V9vhkdINFxl0fg8Ha0cI-zMs3giHjnUP03L-aRURhiQ,3019
+pylint/reporters/text.py,sha256=Vg0Gxn-Hup-ysHyihKw-piG-tIsTnEDTmBXe-bi_Jzw,11050
+pylint/reporters/ureports/__init__.py,sha256=ljyZntDHXZOMHLvRnrDJMs8Ys0B9OK7YoFrDhawcOa8,310
+pylint/reporters/ureports/base_writer.py,sha256=a5yv1hS_pAf3rWGbCRSfxldmPjtvCqmYjMRjiF8KLxs,3307
+pylint/reporters/ureports/nodes.py,sha256=HBilolHGFoSumHtvz14I4mNhJxrTtqAR7LxK-s1xxso,4985
+pylint/reporters/ureports/text_writer.py,sha256=WZ4puowoTIInXVjkRGBxTdBEKil2kxwG1ZczVmdo8fU,3583
+pylint/testutils/__init__.py,sha256=1pEvouq1rITrCoLfGg1GJvKdMzyTCxvarL9gn1N3Eyo,1241
+pylint/testutils/checker_test_case.py,sha256=biPSOVU2aZPGokekRMVeMVzJ51HNYCkxWsFkYG4DzoA,4079
+pylint/testutils/configuration_test.py,sha256=dEb2TvBbajYmBhL_EJ9x67Av6NXR_cY_Ax-BoyEwHpE,6043
+pylint/testutils/constants.py,sha256=nggFYQ10qQ44P4MuxsJ4ugTQ8M8Y7Z2hy3XHV8STPhE,1145
+pylint/testutils/decorator.py,sha256=qmf_S0-iGxyd1lydI6QP674g3QLCqaGiXoMV3QD0gcc,3565
+pylint/testutils/functional_test_file.py,sha256=Uxf0OpVDNVZQ_uL68G4uDonfC3D32moApKieuu-1lsU,617
+pylint/testutils/get_test_info.py,sha256=410j9o2YbK-TbsqBg-ONRfCa1qy0E5dJX7SrYUNLvNg,2122
+pylint/testutils/global_test_linter.py,sha256=Zyh4AdIzwN7gURfdU8du9lglIwmE66Sk1oC9QBBhQO8,673
+pylint/testutils/lint_module_test.py,sha256=FusZccBYjTKotAP3W1IJvQXR6I07MXWmLFS_KVn5O98,10393
+pylint/testutils/output_line.py,sha256=TDHs4YXek7iru62Na-y156Wsa8b0hNyb8oL9YaRichc,6515
+pylint/testutils/primer.py,sha256=jnlmz6Enz5WU0zEgC67Yq_44c-ISisGNX-uMa420A8E,3914
+pylint/testutils/pyreverse.py,sha256=Er1dEj1bVp-jB1PApM7uH421fluSQWNF8XFzw7TWR6s,2011
+pylint/testutils/reporter_for_tests.py,sha256=hOcsLHBktUOTgutPGYwZKkpzoG5C74e2GuKv1MsL-X0,2485
+pylint/testutils/testing_pylintrc,sha256=wbnx5xK0-nhu1ZaFz8bVb5cdx6E6L-CuHaqSr6LV6QY,198
+pylint/testutils/tokenize_str.py,sha256=pyeV6SO7qwqdwukGVXFt2Uk9VMS5sWctKqjbEwrr5AU,435
+pylint/testutils/unittest_linter.py,sha256=MsVCnuC5UuRBS-wa3xK7xbycFGG5z88zbrAkWuM7eVI,2774
+pylint/testutils/functional/__init__.py,sha256=DaAh5XAzIhZkGUn2ZADAWJHSThraZvVaFNEU9UeL_5Y,790
+pylint/testutils/functional/find_functional_tests.py,sha256=72DOYJaS6RIfjMzEyonDd6f8qEYQjZ4V65NmRcBSeNI,2948
+pylint/testutils/functional/lint_module_output_update.py,sha256=jyi65Syvy6sj2EEszgzc0D2O8Ms_kb8IRbZleJdKoCo,2135
+pylint/testutils/functional/test_file.py,sha256=9ULIA-in7EtkPE6cqygYSFuWlxhoz1oi-I3kM6nZadU,3472
+pylint/utils/__init__.py,sha256=cfUxbZ5x4HekpNsg4HT5eusm92oxw7xIfj_nVJI-wGs,1381
+pylint/utils/ast_walker.py,sha256=WbWGKLzPcqbStTq5CWIZSLVOMHmMPVerYlbDDH6WG3w,3325
+pylint/utils/docs.py,sha256=DkyRAwF2IfdKbHPLs7qdCke9qiuj5_3zTQ8DZqY5Anw,2941
+pylint/utils/file_state.py,sha256=d-5khscjM2ZPKsNEjAlfMueMh8U-Mz-kQCcw41TCLlg,7134
+pylint/utils/linterstats.py,sha256=7WB2fiI4BKu5uiybXyRNMQFCK6GGGHyF15VDkRN2V70,12237
+pylint/utils/pragma_parser.py,sha256=wQZZSeeFrtdVv2bgSJg9C0bJfVJI_sXUvDJRv7v_O98,5026
+pylint/utils/utils.py,sha256=q2H4H7w0WRXql1YLBud5xakUg6F-q-UHvVu7x_AQle8,11998
+pylint-2.13.9.dist-info/CONTRIBUTORS.txt,sha256=1JuBT1PwetqxlOPDssIrzylD6QwoUywZuEQ9mIJzZHo,26195
+pylint-2.13.9.dist-info/LICENSE,sha256=-XsUCA3ouEkNYOs9Yg68QZlD4HeUZtHdDV1vaP4ZXc0,17984
+pylint-2.13.9.dist-info/METADATA,sha256=DW7jjZlZys0a5kLOeu_10qLoqax6xC5-gESABJhMhgY,8918
+pylint-2.13.9.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+pylint-2.13.9.dist-info/entry_points.txt,sha256=O-c09FCJw6yNmaJ65OXHH5DYx5Wugoo-3ooNm1E1adM,136
+pylint-2.13.9.dist-info/top_level.txt,sha256=j6Z9i__pIuaiCka6Ul9YIy6yI5aw5QbCtldLvZlMksE,7
+pylint-2.13.9.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+pylint-2.13.9.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/WHEEL
new file mode 100644
index 0000000..becc9a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/entry_points.txt
new file mode 100644
index 0000000..f1f7591
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/entry_points.txt
@@ -0,0 +1,5 @@
+[console_scripts]
+epylint = pylint:run_epylint
+pylint = pylint:run_pylint
+pyreverse = pylint:run_pyreverse
+symilar = pylint:run_symilar
diff --git a/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/top_level.txt
new file mode 100644
index 0000000..7fb0ea1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint-2.13.9.dist-info/top_level.txt
@@ -0,0 +1 @@
+pylint
diff --git a/myenv/lib/python3.9/site-packages/pylint/__init__.py b/myenv/lib/python3.9/site-packages/pylint/__init__.py
new file mode 100644
index 0000000..9fde923
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/__init__.py
@@ -0,0 +1,86 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import os
+import sys
+from typing import Optional, Sequence
+
+from pylint.__pkginfo__ import __version__
+
+# pylint: disable=import-outside-toplevel
+
+
+def run_pylint(argv: Optional[Sequence[str]] = None):
+    """Run pylint.
+
+    argv can be a sequence of strings normally supplied as arguments on the command line
+    """
+    from pylint.lint import Run as PylintRun
+
+    try:
+        PylintRun(argv or sys.argv[1:])
+    except KeyboardInterrupt:
+        sys.exit(1)
+
+
+def run_epylint(argv: Optional[Sequence[str]] = None):
+    """Run epylint.
+
+    argv can be a list of strings normally supplied as arguments on the command line
+    """
+    from pylint.epylint import Run as EpylintRun
+
+    EpylintRun(argv)
+
+
+def run_pyreverse(argv: Optional[Sequence[str]] = None):
+    """Run pyreverse.
+
+    argv can be a sequence of strings normally supplied as arguments on the command line
+    """
+    from pylint.pyreverse.main import Run as PyreverseRun
+
+    PyreverseRun(argv or sys.argv[1:])
+
+
+def run_symilar(argv: Optional[Sequence[str]] = None):
+    """Run symilar.
+
+    argv can be a sequence of strings normally supplied as arguments on the command line
+    """
+    from pylint.checkers.similar import Run as SimilarRun
+
+    SimilarRun(argv or sys.argv[1:])
+
+
+def modify_sys_path() -> None:
+    """Modify sys path for execution as Python module.
+
+    Strip out the current working directory from sys.path.
+    Having the working directory in `sys.path` means that `pylint` might
+    inadvertently import user code from modules having the same name as
+    stdlib or pylint's own modules.
+    CPython issue: https://bugs.python.org/issue33053
+
+    - Remove the first entry. This will always be either "" or the working directory
+    - Remove the working directory from the second and third entries
+      if PYTHONPATH includes a ":" at the beginning or the end.
+      https://github.com/PyCQA/pylint/issues/3636
+      Don't remove it if PYTHONPATH contains the cwd or '.' as the entry will
+      only be added once.
+    - Don't remove the working directory from the rest. It will be included
+      if pylint is installed in an editable configuration (as the last item).
+      https://github.com/PyCQA/pylint/issues/4161
+    """
+    sys.path.pop(0)
+    env_pythonpath = os.environ.get("PYTHONPATH", "")
+    cwd = os.getcwd()
+    if env_pythonpath.startswith(":") and env_pythonpath not in (f":{cwd}", ":."):
+        sys.path.pop(0)
+    elif env_pythonpath.endswith(":") and env_pythonpath not in (f"{cwd}:", ".:"):
+        sys.path.pop(1)
+
+
+version = __version__
+__all__ = ["__version__", "version", "modify_sys_path"]
diff --git a/myenv/lib/python3.9/site-packages/pylint/__main__.py b/myenv/lib/python3.9/site-packages/pylint/__main__.py
new file mode 100644
index 0000000..7df5805
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/__main__.py
@@ -0,0 +1,10 @@
+#!/usr/bin/env python
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import pylint
+
+pylint.modify_sys_path()
+pylint.run_pylint()
diff --git a/myenv/lib/python3.9/site-packages/pylint/__pkginfo__.py b/myenv/lib/python3.9/site-packages/pylint/__pkginfo__.py
new file mode 100644
index 0000000..91585ad
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/__pkginfo__.py
@@ -0,0 +1,37 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import Tuple
+
+__version__ = "2.13.9"
+
+
+def get_numversion_from_version(v: str) -> Tuple:
+    """Kept for compatibility reason.
+
+    See https://github.com/PyCQA/pylint/issues/4399
+    https://github.com/PyCQA/pylint/issues/4420,
+    """
+    v = v.replace("pylint-", "")
+    version = []
+    for n in v.split(".")[0:3]:
+        try:
+            version.append(int(n))
+        except ValueError:
+            num = ""
+            for c in n:
+                if c.isdigit():
+                    num += c
+                else:
+                    break
+            try:
+                version.append(int(num))
+            except ValueError:
+                version.append(0)
+    while len(version) != 3:
+        version.append(0)
+    return tuple(version)
+
+
+numversion = get_numversion_from_version(__version__)
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/__init__.py b/myenv/lib/python3.9/site-packages/pylint/checkers/__init__.py
new file mode 100644
index 0000000..2855d70
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/__init__.py
@@ -0,0 +1,138 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Utilities methods and classes for checkers.
+
+Base id of standard checkers (used in msg and report ids):
+01: base
+02: classes
+03: format
+04: import
+05: misc
+06: variables
+07: exceptions
+08: similar
+09: design_analysis
+10: newstyle
+11: typecheck
+12: logging
+13: string_format
+14: string_constant
+15: stdlib
+16: python3 (This one was deleted but needs to be reserved for consistency with old messages)
+17: refactoring
+.
+.
+.
+24: non-ascii-names
+25: unicode
+26: unsupported_version
+27: private-import
+28-50: not yet used: reserved for future internal checkers.
+This file is not updated. Use
+   script/get_unused_message_id_category.py
+to get the next free checker id.
+
+51-99: perhaps used: reserved for external checkers
+
+The raw_metrics checker has no number associated since it doesn't emit any
+messages nor reports. XXX not true, emit a 07 report !
+
+"""
+
+import sys
+from typing import List, Optional, Tuple, Union
+
+from pylint.checkers.base_checker import BaseChecker, BaseTokenChecker
+from pylint.checkers.deprecated import DeprecatedMixin
+from pylint.checkers.mapreduce_checker import MapReduceMixin
+from pylint.utils import LinterStats, diff_string, register_plugins
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+
+def table_lines_from_stats(
+    stats: LinterStats,
+    old_stats: Optional[LinterStats],
+    stat_type: Literal["duplicated_lines", "message_types"],
+) -> List[str]:
+    """Get values listed in <columns> from <stats> and <old_stats>,
+    and return a formatted list of values.
+
+    The return value is designed to be given to a ureport.Table object
+    """
+    lines: List[str] = []
+    if stat_type == "duplicated_lines":
+        new: List[Tuple[str, Union[str, int, float]]] = [
+            ("nb_duplicated_lines", stats.duplicated_lines["nb_duplicated_lines"]),
+            (
+                "percent_duplicated_lines",
+                stats.duplicated_lines["percent_duplicated_lines"],
+            ),
+        ]
+        if old_stats:
+            old: List[Tuple[str, Union[str, int, float]]] = [
+                (
+                    "nb_duplicated_lines",
+                    old_stats.duplicated_lines["nb_duplicated_lines"],
+                ),
+                (
+                    "percent_duplicated_lines",
+                    old_stats.duplicated_lines["percent_duplicated_lines"],
+                ),
+            ]
+        else:
+            old = [("nb_duplicated_lines", "NC"), ("percent_duplicated_lines", "NC")]
+    elif stat_type == "message_types":
+        new = [
+            ("convention", stats.convention),
+            ("refactor", stats.refactor),
+            ("warning", stats.warning),
+            ("error", stats.error),
+        ]
+        if old_stats:
+            old = [
+                ("convention", old_stats.convention),
+                ("refactor", old_stats.refactor),
+                ("warning", old_stats.warning),
+                ("error", old_stats.error),
+            ]
+        else:
+            old = [
+                ("convention", "NC"),
+                ("refactor", "NC"),
+                ("warning", "NC"),
+                ("error", "NC"),
+            ]
+
+    for index, value in enumerate(new):
+        new_value = value[1]
+        old_value = old[index][1]
+        diff_str = (
+            diff_string(old_value, new_value)
+            if isinstance(old_value, float)
+            else old_value
+        )
+        new_str = f"{new_value:.3f}" if isinstance(new_value, float) else str(new_value)
+        old_str = f"{old_value:.3f}" if isinstance(old_value, float) else str(old_value)
+        lines.extend((value[0].replace("_", " "), new_str, old_str, diff_str))
+    return lines
+
+
+def initialize(linter):
+    """Initialize linter with checkers in this package."""
+    register_plugins(linter, __path__[0])
+
+
+__all__ = [
+    "BaseChecker",
+    "BaseTokenChecker",
+    "initialize",
+    "MapReduceMixin",
+    "DeprecatedMixin",
+    "register_plugins",
+]
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/async.py b/myenv/lib/python3.9/site-packages/pylint/checkers/async.py
new file mode 100644
index 0000000..a85ab41
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/async.py
@@ -0,0 +1,96 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Checker for anything related to the async protocol (PEP 492)."""
+
+import sys
+from typing import TYPE_CHECKING
+
+import astroid
+from astroid import nodes
+
+from pylint import checkers, interfaces, utils
+from pylint.checkers import utils as checker_utils
+from pylint.checkers.utils import decorated_with
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class AsyncChecker(checkers.BaseChecker):
+    __implements__ = interfaces.IAstroidChecker
+    name = "async"
+    msgs = {
+        "E1700": (
+            "Yield inside async function",
+            "yield-inside-async-function",
+            "Used when an `yield` or `yield from` statement is "
+            "found inside an async function.",
+            {"minversion": (3, 5)},
+        ),
+        "E1701": (
+            "Async context manager '%s' doesn't implement __aenter__ and __aexit__.",
+            "not-async-context-manager",
+            "Used when an async context manager is used with an object "
+            "that does not implement the async context management protocol.",
+            {"minversion": (3, 5)},
+        ),
+    }
+
+    def open(self):
+        self._ignore_mixin_members = utils.get_global_option(
+            self, "ignore-mixin-members"
+        )
+        self._mixin_class_rgx = utils.get_global_option(self, "mixin-class-rgx")
+        self._async_generators = ["contextlib.asynccontextmanager"]
+
+    @checker_utils.check_messages("yield-inside-async-function")
+    def visit_asyncfunctiondef(self, node: nodes.AsyncFunctionDef) -> None:
+        for child in node.nodes_of_class(nodes.Yield):
+            if child.scope() is node and (
+                sys.version_info[:2] == (3, 5) or isinstance(child, nodes.YieldFrom)
+            ):
+                self.add_message("yield-inside-async-function", node=child)
+
+    @checker_utils.check_messages("not-async-context-manager")
+    def visit_asyncwith(self, node: nodes.AsyncWith) -> None:
+        for ctx_mgr, _ in node.items:
+            inferred = checker_utils.safe_infer(ctx_mgr)
+            if inferred is None or inferred is astroid.Uninferable:
+                continue
+
+            if isinstance(inferred, nodes.AsyncFunctionDef):
+                # Check if we are dealing with a function decorated
+                # with contextlib.asynccontextmanager.
+                if decorated_with(inferred, self._async_generators):
+                    continue
+            elif isinstance(inferred, astroid.bases.AsyncGenerator):
+                # Check if we are dealing with a function decorated
+                # with contextlib.asynccontextmanager.
+                if decorated_with(inferred.parent, self._async_generators):
+                    continue
+            else:
+                try:
+                    inferred.getattr("__aenter__")
+                    inferred.getattr("__aexit__")
+                except astroid.exceptions.NotFoundError:
+                    if isinstance(inferred, astroid.Instance):
+                        # If we do not know the bases of this class,
+                        # just skip it.
+                        if not checker_utils.has_known_bases(inferred):
+                            continue
+                        # Ignore mixin classes if they match the rgx option.
+                        if self._ignore_mixin_members and self._mixin_class_rgx.match(
+                            inferred.name
+                        ):
+                            continue
+                else:
+                    continue
+            self.add_message(
+                "not-async-context-manager", node=node, args=(inferred.name,)
+            )
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(AsyncChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/base/__init__.py b/myenv/lib/python3.9/site-packages/pylint/checkers/base/__init__.py
new file mode 100644
index 0000000..7c16244
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/base/__init__.py
@@ -0,0 +1,45 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+
+__all__ = [
+    "NameChecker",
+    "NamingStyle",
+    "KNOWN_NAME_TYPES_WITH_STYLE",
+    "SnakeCaseStyle",
+    "CamelCaseStyle",
+    "UpperCaseStyle",
+    "PascalCaseStyle",
+    "AnyStyle",
+]
+
+from typing import TYPE_CHECKING
+
+from pylint.checkers.base.basic_checker import BasicChecker
+from pylint.checkers.base.basic_error_checker import BasicErrorChecker
+from pylint.checkers.base.comparison_checker import ComparisonChecker
+from pylint.checkers.base.docstring_checker import DocStringChecker
+from pylint.checkers.base.name_checker import (
+    KNOWN_NAME_TYPES_WITH_STYLE,
+    AnyStyle,
+    CamelCaseStyle,
+    NamingStyle,
+    PascalCaseStyle,
+    SnakeCaseStyle,
+    UpperCaseStyle,
+)
+from pylint.checkers.base.name_checker.checker import NameChecker
+from pylint.checkers.base.pass_checker import PassChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(BasicErrorChecker(linter))
+    linter.register_checker(BasicChecker(linter))
+    linter.register_checker(NameChecker(linter))
+    linter.register_checker(DocStringChecker(linter))
+    linter.register_checker(PassChecker(linter))
+    linter.register_checker(ComparisonChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/base/basic_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/base/basic_checker.py
new file mode 100644
index 0000000..1e5a2a1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/base/basic_checker.py
@@ -0,0 +1,830 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Basic checker for Python code."""
+
+import collections
+import itertools
+import sys
+from typing import TYPE_CHECKING, Dict, Optional, cast
+
+import astroid
+from astroid import nodes
+
+from pylint import interfaces
+from pylint import utils as lint_utils
+from pylint.checkers import BaseChecker, utils
+from pylint.interfaces import IAstroidChecker
+from pylint.reporters.ureports import nodes as reporter_nodes
+from pylint.utils import LinterStats
+from pylint.utils.utils import get_global_option
+
+if TYPE_CHECKING:
+    pass
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+
+class _BasicChecker(BaseChecker):
+    """Permits separating multiple checks with the same checker name into classes/file."""
+
+    __implements__ = IAstroidChecker
+    name = "basic"
+
+
+REVERSED_PROTOCOL_METHOD = "__reversed__"
+SEQUENCE_PROTOCOL_METHODS = ("__getitem__", "__len__")
+REVERSED_METHODS = (SEQUENCE_PROTOCOL_METHODS, (REVERSED_PROTOCOL_METHOD,))
+# A mapping from qname -> symbol, to be used when generating messages
+# about dangerous default values as arguments
+DEFAULT_ARGUMENT_SYMBOLS = dict(
+    zip(
+        [".".join(["builtins", x]) for x in ("set", "dict", "list")],
+        ["set()", "{}", "[]"],
+    ),
+    **{
+        x: f"{x}()"
+        for x in (
+            "collections.deque",
+            "collections.ChainMap",
+            "collections.Counter",
+            "collections.OrderedDict",
+            "collections.defaultdict",
+            "collections.UserDict",
+            "collections.UserList",
+        )
+    },
+)
+
+
+def report_by_type_stats(
+    sect,
+    stats: LinterStats,
+    old_stats: Optional[LinterStats],
+):
+    """Make a report of.
+
+    * percentage of different types documented
+    * percentage of different types with a bad name
+    """
+    # percentage of different types documented and/or with a bad name
+    nice_stats: Dict[str, Dict[str, str]] = {}
+    for node_type in ("module", "class", "method", "function"):
+        node_type = cast(Literal["function", "class", "method", "module"], node_type)
+        total = stats.get_node_count(node_type)
+        nice_stats[node_type] = {}
+        if total != 0:
+            undocumented_node = stats.get_undocumented(node_type)
+            documented = total - undocumented_node
+            percent = (documented * 100.0) / total
+            nice_stats[node_type]["percent_documented"] = f"{percent:.2f}"
+            badname_node = stats.get_bad_names(node_type)
+            percent = (badname_node * 100.0) / total
+            nice_stats[node_type]["percent_badname"] = f"{percent:.2f}"
+    lines = ["type", "number", "old number", "difference", "%documented", "%badname"]
+    for node_type in ("module", "class", "method", "function"):
+        node_type = cast(Literal["function", "class", "method", "module"], node_type)
+        new = stats.get_node_count(node_type)
+        old = old_stats.get_node_count(node_type) if old_stats else None
+        diff_str = lint_utils.diff_string(old, new) if old else None
+        lines += [
+            node_type,
+            str(new),
+            str(old) if old else "NC",
+            diff_str if diff_str else "NC",
+            nice_stats[node_type].get("percent_documented", "0"),
+            nice_stats[node_type].get("percent_badname", "0"),
+        ]
+    sect.append(reporter_nodes.Table(children=lines, cols=6, rheaders=1))
+
+
+class BasicChecker(_BasicChecker):
+    """Basic checker.
+
+    Checks for :
+    * doc strings
+    * number of arguments, local variables, branches, returns and statements in
+    functions, methods
+    * required module attributes
+    * dangerous default values as arguments
+    * redefinition of function / method / class
+    * uses of the global statement
+    """
+
+    __implements__ = interfaces.IAstroidChecker
+
+    name = "basic"
+    msgs = {
+        "W0101": (
+            "Unreachable code",
+            "unreachable",
+            'Used when there is some code behind a "return" or "raise" '
+            "statement, which will never be accessed.",
+        ),
+        "W0102": (
+            "Dangerous default value %s as argument",
+            "dangerous-default-value",
+            "Used when a mutable value as list or dictionary is detected in "
+            "a default value for an argument.",
+        ),
+        "W0104": (
+            "Statement seems to have no effect",
+            "pointless-statement",
+            "Used when a statement doesn't have (or at least seems to) any effect.",
+        ),
+        "W0105": (
+            "String statement has no effect",
+            "pointless-string-statement",
+            "Used when a string is used as a statement (which of course "
+            "has no effect). This is a particular case of W0104 with its "
+            "own message so you can easily disable it if you're using "
+            "those strings as documentation, instead of comments.",
+        ),
+        "W0106": (
+            'Expression "%s" is assigned to nothing',
+            "expression-not-assigned",
+            "Used when an expression that is not a function call is assigned "
+            "to nothing. Probably something else was intended.",
+        ),
+        "W0108": (
+            "Lambda may not be necessary",
+            "unnecessary-lambda",
+            "Used when the body of a lambda expression is a function call "
+            "on the same argument list as the lambda itself; such lambda "
+            "expressions are in all but a few cases replaceable with the "
+            "function being called in the body of the lambda.",
+        ),
+        "W0109": (
+            "Duplicate key %r in dictionary",
+            "duplicate-key",
+            "Used when a dictionary expression binds the same key multiple times.",
+        ),
+        "W0122": (
+            "Use of exec",
+            "exec-used",
+            'Used when you use the "exec" statement (function for Python '
+            "3), to discourage its usage. That doesn't "
+            "mean you cannot use it !",
+        ),
+        "W0123": (
+            "Use of eval",
+            "eval-used",
+            'Used when you use the "eval" function, to discourage its '
+            "usage. Consider using `ast.literal_eval` for safely evaluating "
+            "strings containing Python expressions "
+            "from untrusted sources.",
+        ),
+        "W0150": (
+            "%s statement in finally block may swallow exception",
+            "lost-exception",
+            "Used when a break or a return statement is found inside the "
+            "finally clause of a try...finally block: the exceptions raised "
+            "in the try clause will be silently swallowed instead of being "
+            "re-raised.",
+        ),
+        "W0199": (
+            "Assert called on a 2-item-tuple. Did you mean 'assert x,y'?",
+            "assert-on-tuple",
+            "A call of assert on a tuple will always evaluate to true if "
+            "the tuple is not empty, and will always evaluate to false if "
+            "it is.",
+        ),
+        "W0124": (
+            'Following "as" with another context manager looks like a tuple.',
+            "confusing-with-statement",
+            "Emitted when a `with` statement component returns multiple values "
+            "and uses name binding with `as` only for a part of those values, "
+            "as in with ctx() as a, b. This can be misleading, since it's not "
+            "clear if the context manager returns a tuple or if the node without "
+            "a name binding is another context manager.",
+        ),
+        "W0125": (
+            "Using a conditional statement with a constant value",
+            "using-constant-test",
+            "Emitted when a conditional statement (If or ternary if) "
+            "uses a constant value for its test. This might not be what "
+            "the user intended to do.",
+        ),
+        "W0126": (
+            "Using a conditional statement with potentially wrong function or method call due to missing parentheses",
+            "missing-parentheses-for-call-in-test",
+            "Emitted when a conditional statement (If or ternary if) "
+            "seems to wrongly call a function due to missing parentheses",
+        ),
+        "W0127": (
+            "Assigning the same variable %r to itself",
+            "self-assigning-variable",
+            "Emitted when we detect that a variable is assigned to itself",
+        ),
+        "W0128": (
+            "Redeclared variable %r in assignment",
+            "redeclared-assigned-name",
+            "Emitted when we detect that a variable was redeclared in the same assignment.",
+        ),
+        "E0111": (
+            "The first reversed() argument is not a sequence",
+            "bad-reversed-sequence",
+            "Used when the first argument to reversed() builtin "
+            "isn't a sequence (does not implement __reversed__, "
+            "nor __getitem__ and __len__",
+        ),
+        "E0119": (
+            "format function is not called on str",
+            "misplaced-format-function",
+            "Emitted when format function is not called on str object. "
+            'e.g doing print("value: {}").format(123) instead of '
+            'print("value: {}".format(123)). This might not be what the user '
+            "intended to do.",
+        ),
+        "W0129": (
+            "Assert statement has a string literal as its first argument. The assert will %s fail.",
+            "assert-on-string-literal",
+            "Used when an assert statement has a string literal as its first argument, which will "
+            "cause the assert to always pass.",
+        ),
+    }
+
+    reports = (("RP0101", "Statistics by type", report_by_type_stats),)
+
+    def __init__(self, linter):
+        super().__init__(linter)
+        self._tryfinallys = None
+
+    def open(self):
+        """Initialize visit variables and statistics."""
+        py_version = get_global_option(self, "py-version")
+        self._py38_plus = py_version >= (3, 8)
+        self._tryfinallys = []
+        self.linter.stats.reset_node_count()
+
+    @utils.check_messages("using-constant-test", "missing-parentheses-for-call-in-test")
+    def visit_if(self, node: nodes.If) -> None:
+        self._check_using_constant_test(node, node.test)
+
+    @utils.check_messages("using-constant-test", "missing-parentheses-for-call-in-test")
+    def visit_ifexp(self, node: nodes.IfExp) -> None:
+        self._check_using_constant_test(node, node.test)
+
+    @utils.check_messages("using-constant-test", "missing-parentheses-for-call-in-test")
+    def visit_comprehension(self, node: nodes.Comprehension) -> None:
+        if node.ifs:
+            for if_test in node.ifs:
+                self._check_using_constant_test(node, if_test)
+
+    def _check_using_constant_test(self, node, test):
+        const_nodes = (
+            nodes.Module,
+            nodes.GeneratorExp,
+            nodes.Lambda,
+            nodes.FunctionDef,
+            nodes.ClassDef,
+            astroid.bases.Generator,
+            astroid.UnboundMethod,
+            astroid.BoundMethod,
+            nodes.Module,
+        )
+        structs = (nodes.Dict, nodes.Tuple, nodes.Set, nodes.List)
+
+        # These nodes are excepted, since they are not constant
+        # values, requiring a computation to happen.
+        except_nodes = (
+            nodes.Call,
+            nodes.BinOp,
+            nodes.BoolOp,
+            nodes.UnaryOp,
+            nodes.Subscript,
+        )
+        inferred = None
+        emit = isinstance(test, (nodes.Const,) + structs + const_nodes)
+        if not isinstance(test, except_nodes):
+            inferred = utils.safe_infer(test)
+
+        if emit:
+            self.add_message("using-constant-test", node=node)
+        elif isinstance(inferred, const_nodes):
+            # If the constant node is a FunctionDef or Lambda then
+            # it may be an illicit function call due to missing parentheses
+            call_inferred = None
+            try:
+                if isinstance(inferred, nodes.FunctionDef):
+                    call_inferred = inferred.infer_call_result()
+                elif isinstance(inferred, nodes.Lambda):
+                    call_inferred = inferred.infer_call_result(node)
+            except astroid.InferenceError:
+                call_inferred = None
+            if call_inferred:
+                try:
+                    for inf_call in call_inferred:
+                        if inf_call != astroid.Uninferable:
+                            self.add_message(
+                                "missing-parentheses-for-call-in-test", node=node
+                            )
+                            break
+                except astroid.InferenceError:
+                    pass
+            self.add_message("using-constant-test", node=node)
+
+    def visit_module(self, _: nodes.Module) -> None:
+        """Check module name, docstring and required arguments."""
+        self.linter.stats.node_count["module"] += 1
+
+    def visit_classdef(self, _: nodes.ClassDef) -> None:
+        """Check module name, docstring and redefinition
+        increment branch counter
+        """
+        self.linter.stats.node_count["klass"] += 1
+
+    @utils.check_messages(
+        "pointless-statement", "pointless-string-statement", "expression-not-assigned"
+    )
+    def visit_expr(self, node: nodes.Expr) -> None:
+        """Check for various kind of statements without effect."""
+        expr = node.value
+        if isinstance(expr, nodes.Const) and isinstance(expr.value, str):
+            # treat string statement in a separated message
+            # Handle PEP-257 attribute docstrings.
+            # An attribute docstring is defined as being a string right after
+            # an assignment at the module level, class level or __init__ level.
+            scope = expr.scope()
+            if isinstance(scope, (nodes.ClassDef, nodes.Module, nodes.FunctionDef)):
+                if isinstance(scope, nodes.FunctionDef) and scope.name != "__init__":
+                    pass
+                else:
+                    sibling = expr.previous_sibling()
+                    if (
+                        sibling is not None
+                        and sibling.scope() is scope
+                        and isinstance(sibling, (nodes.Assign, nodes.AnnAssign))
+                    ):
+                        return
+            self.add_message("pointless-string-statement", node=node)
+            return
+
+        # Ignore if this is :
+        # * a direct function call
+        # * the unique child of a try/except body
+        # * a yield statement
+        # * an ellipsis (which can be used on Python 3 instead of pass)
+        # warn W0106 if we have any underlying function call (we can't predict
+        # side effects), else pointless-statement
+        if (
+            isinstance(expr, (nodes.Yield, nodes.Await, nodes.Call))
+            or (isinstance(node.parent, nodes.TryExcept) and node.parent.body == [node])
+            or (isinstance(expr, nodes.Const) and expr.value is Ellipsis)
+        ):
+            return
+        if any(expr.nodes_of_class(nodes.Call)):
+            self.add_message(
+                "expression-not-assigned", node=node, args=expr.as_string()
+            )
+        else:
+            self.add_message("pointless-statement", node=node)
+
+    @staticmethod
+    def _filter_vararg(node, call_args):
+        # Return the arguments for the given call which are
+        # not passed as vararg.
+        for arg in call_args:
+            if isinstance(arg, nodes.Starred):
+                if (
+                    isinstance(arg.value, nodes.Name)
+                    and arg.value.name != node.args.vararg
+                ):
+                    yield arg
+            else:
+                yield arg
+
+    @staticmethod
+    def _has_variadic_argument(args, variadic_name):
+        if not args:
+            return True
+        for arg in args:
+            if isinstance(arg.value, nodes.Name):
+                if arg.value.name != variadic_name:
+                    return True
+            else:
+                return True
+        return False
+
+    @utils.check_messages("unnecessary-lambda")
+    def visit_lambda(self, node: nodes.Lambda) -> None:
+        """Check whether the lambda is suspicious."""
+        # if the body of the lambda is a call expression with the same
+        # argument list as the lambda itself, then the lambda is
+        # possibly unnecessary and at least suspicious.
+        if node.args.defaults:
+            # If the arguments of the lambda include defaults, then a
+            # judgment cannot be made because there is no way to check
+            # that the defaults defined by the lambda are the same as
+            # the defaults defined by the function called in the body
+            # of the lambda.
+            return
+        call = node.body
+        if not isinstance(call, nodes.Call):
+            # The body of the lambda must be a function call expression
+            # for the lambda to be unnecessary.
+            return
+        if isinstance(node.body.func, nodes.Attribute) and isinstance(
+            node.body.func.expr, nodes.Call
+        ):
+            # Chained call, the intermediate call might
+            # return something else (but we don't check that, yet).
+            return
+
+        call_site = astroid.arguments.CallSite.from_call(call)
+        ordinary_args = list(node.args.args)
+        new_call_args = list(self._filter_vararg(node, call.args))
+        if node.args.kwarg:
+            if self._has_variadic_argument(call.kwargs, node.args.kwarg):
+                return
+
+        if node.args.vararg:
+            if self._has_variadic_argument(call.starargs, node.args.vararg):
+                return
+        elif call.starargs:
+            return
+
+        if call.keywords:
+            # Look for additional keyword arguments that are not part
+            # of the lambda's signature
+            lambda_kwargs = {keyword.name for keyword in node.args.defaults}
+            if len(lambda_kwargs) != len(call_site.keyword_arguments):
+                # Different lengths, so probably not identical
+                return
+            if set(call_site.keyword_arguments).difference(lambda_kwargs):
+                return
+
+        # The "ordinary" arguments must be in a correspondence such that:
+        # ordinary_args[i].name == call.args[i].name.
+        if len(ordinary_args) != len(new_call_args):
+            return
+        for arg, passed_arg in zip(ordinary_args, new_call_args):
+            if not isinstance(passed_arg, nodes.Name):
+                return
+            if arg.name != passed_arg.name:
+                return
+
+        self.add_message("unnecessary-lambda", line=node.fromlineno, node=node)
+
+    @utils.check_messages("dangerous-default-value")
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        """Check function name, docstring, arguments, redefinition,
+        variable names, max locals
+        """
+        if node.is_method():
+            self.linter.stats.node_count["method"] += 1
+        else:
+            self.linter.stats.node_count["function"] += 1
+        self._check_dangerous_default(node)
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    def _check_dangerous_default(self, node):
+        """Check for dangerous default values as arguments."""
+
+        def is_iterable(internal_node):
+            return isinstance(internal_node, (nodes.List, nodes.Set, nodes.Dict))
+
+        defaults = node.args.defaults or [] + node.args.kw_defaults or []
+        for default in defaults:
+            if not default:
+                continue
+            try:
+                value = next(default.infer())
+            except astroid.InferenceError:
+                continue
+
+            if (
+                isinstance(value, astroid.Instance)
+                and value.qname() in DEFAULT_ARGUMENT_SYMBOLS
+            ):
+                if value is default:
+                    msg = DEFAULT_ARGUMENT_SYMBOLS[value.qname()]
+                elif isinstance(value, astroid.Instance) or is_iterable(value):
+                    # We are here in the following situation(s):
+                    #   * a dict/set/list/tuple call which wasn't inferred
+                    #     to a syntax node ({}, () etc.). This can happen
+                    #     when the arguments are invalid or unknown to
+                    #     the inference.
+                    #   * a variable from somewhere else, which turns out to be a list
+                    #     or a dict.
+                    if is_iterable(default):
+                        msg = value.pytype()
+                    elif isinstance(default, nodes.Call):
+                        msg = f"{value.name}() ({value.qname()})"
+                    else:
+                        msg = f"{default.as_string()} ({value.qname()})"
+                else:
+                    # this argument is a name
+                    msg = f"{default.as_string()} ({DEFAULT_ARGUMENT_SYMBOLS[value.qname()]})"
+                self.add_message("dangerous-default-value", node=node, args=(msg,))
+
+    @utils.check_messages("unreachable", "lost-exception")
+    def visit_return(self, node: nodes.Return) -> None:
+        """Return node visitor.
+
+        1 - check if the node has a right sibling (if so, that's some
+        unreachable code)
+        2 - check if the node is inside the 'finally' clause of a 'try...finally'
+        block
+        """
+        self._check_unreachable(node)
+        # Is it inside final body of a try...finally block ?
+        self._check_not_in_finally(node, "return", (nodes.FunctionDef,))
+
+    @utils.check_messages("unreachable")
+    def visit_continue(self, node: nodes.Continue) -> None:
+        """Check is the node has a right sibling (if so, that's some unreachable
+        code)
+        """
+        self._check_unreachable(node)
+
+    @utils.check_messages("unreachable", "lost-exception")
+    def visit_break(self, node: nodes.Break) -> None:
+        """Break node visitor.
+
+        1 - check if the node has a right sibling (if so, that's some
+        unreachable code)
+        2 - check if the node is inside the 'finally' clause of a 'try...finally'
+        block
+        """
+        # 1 - Is it right sibling ?
+        self._check_unreachable(node)
+        # 2 - Is it inside final body of a try...finally block ?
+        self._check_not_in_finally(node, "break", (nodes.For, nodes.While))
+
+    @utils.check_messages("unreachable")
+    def visit_raise(self, node: nodes.Raise) -> None:
+        """Check if the node has a right sibling (if so, that's some unreachable
+        code)
+        """
+        self._check_unreachable(node)
+
+    def _check_misplaced_format_function(self, call_node):
+        if not isinstance(call_node.func, nodes.Attribute):
+            return
+        if call_node.func.attrname != "format":
+            return
+
+        expr = utils.safe_infer(call_node.func.expr)
+        if expr is astroid.Uninferable:
+            return
+        if not expr:
+            # we are doubtful on inferred type of node, so here just check if format
+            # was called on print()
+            call_expr = call_node.func.expr
+            if not isinstance(call_expr, nodes.Call):
+                return
+            if (
+                isinstance(call_expr.func, nodes.Name)
+                and call_expr.func.name == "print"
+            ):
+                self.add_message("misplaced-format-function", node=call_node)
+
+    @utils.check_messages(
+        "eval-used", "exec-used", "bad-reversed-sequence", "misplaced-format-function"
+    )
+    def visit_call(self, node: nodes.Call) -> None:
+        """Visit a Call node -> check if this is not a disallowed builtin
+        call and check for * or ** use
+        """
+        self._check_misplaced_format_function(node)
+        if isinstance(node.func, nodes.Name):
+            name = node.func.name
+            # ignore the name if it's not a builtin (i.e. not defined in the
+            # locals nor globals scope)
+            if not (name in node.frame(future=True) or name in node.root()):
+                if name == "exec":
+                    self.add_message("exec-used", node=node)
+                elif name == "reversed":
+                    self._check_reversed(node)
+                elif name == "eval":
+                    self.add_message("eval-used", node=node)
+
+    @utils.check_messages("assert-on-tuple", "assert-on-string-literal")
+    def visit_assert(self, node: nodes.Assert) -> None:
+        """Check whether assert is used on a tuple or string literal."""
+        if (
+            node.fail is None
+            and isinstance(node.test, nodes.Tuple)
+            and len(node.test.elts) == 2
+        ):
+            self.add_message("assert-on-tuple", node=node)
+
+        if isinstance(node.test, nodes.Const) and isinstance(node.test.value, str):
+            if node.test.value:
+                when = "never"
+            else:
+                when = "always"
+            self.add_message("assert-on-string-literal", node=node, args=(when,))
+
+    @utils.check_messages("duplicate-key")
+    def visit_dict(self, node: nodes.Dict) -> None:
+        """Check duplicate key in dictionary."""
+        keys = set()
+        for k, _ in node.items:
+            if isinstance(k, nodes.Const):
+                key = k.value
+            elif isinstance(k, nodes.Attribute):
+                key = k.as_string()
+            else:
+                continue
+            if key in keys:
+                self.add_message("duplicate-key", node=node, args=key)
+            keys.add(key)
+
+    def visit_tryfinally(self, node: nodes.TryFinally) -> None:
+        """Update try...finally flag."""
+        self._tryfinallys.append(node)
+
+    def leave_tryfinally(self, _: nodes.TryFinally) -> None:
+        """Update try...finally flag."""
+        self._tryfinallys.pop()
+
+    def _check_unreachable(self, node):
+        """Check unreachable code."""
+        unreach_stmt = node.next_sibling()
+        if unreach_stmt is not None:
+            if (
+                isinstance(node, nodes.Return)
+                and isinstance(unreach_stmt, nodes.Expr)
+                and isinstance(unreach_stmt.value, nodes.Yield)
+            ):
+                # Don't add 'unreachable' for empty generators.
+                # Only add warning if 'yield' is followed by another node.
+                unreach_stmt = unreach_stmt.next_sibling()
+                if unreach_stmt is None:
+                    return
+            self.add_message("unreachable", node=unreach_stmt)
+
+    def _check_not_in_finally(self, node, node_name, breaker_classes=()):
+        """Check that a node is not inside a 'finally' clause of a
+        'try...finally' statement.
+
+        If we find a parent which type is in breaker_classes before
+        a 'try...finally' block we skip the whole check.
+        """
+        # if self._tryfinallys is empty, we're not an in try...finally block
+        if not self._tryfinallys:
+            return
+        # the node could be a grand-grand...-child of the 'try...finally'
+        _parent = node.parent
+        _node = node
+        while _parent and not isinstance(_parent, breaker_classes):
+            if hasattr(_parent, "finalbody") and _node in _parent.finalbody:
+                self.add_message("lost-exception", node=node, args=node_name)
+                return
+            _node = _parent
+            _parent = _node.parent
+
+    def _check_reversed(self, node):
+        """Check that the argument to `reversed` is a sequence."""
+        try:
+            argument = utils.safe_infer(utils.get_argument_from_call(node, position=0))
+        except utils.NoSuchArgumentError:
+            pass
+        else:
+            if argument is astroid.Uninferable:
+                return
+            if argument is None:
+                # Nothing was inferred.
+                # Try to see if we have iter().
+                if isinstance(node.args[0], nodes.Call):
+                    try:
+                        func = next(node.args[0].func.infer())
+                    except astroid.InferenceError:
+                        return
+                    if getattr(
+                        func, "name", None
+                    ) == "iter" and utils.is_builtin_object(func):
+                        self.add_message("bad-reversed-sequence", node=node)
+                return
+
+            if isinstance(argument, (nodes.List, nodes.Tuple)):
+                return
+
+            # dicts are reversible, but only from Python 3.8 onwards. Prior to
+            # that, any class based on dict must explicitly provide a
+            # __reversed__ method
+            if not self._py38_plus and isinstance(argument, astroid.Instance):
+                if any(
+                    ancestor.name == "dict" and utils.is_builtin_object(ancestor)
+                    for ancestor in itertools.chain(
+                        (argument._proxied,), argument._proxied.ancestors()
+                    )
+                ):
+                    try:
+                        argument.locals[REVERSED_PROTOCOL_METHOD]
+                    except KeyError:
+                        self.add_message("bad-reversed-sequence", node=node)
+                    return
+
+            if hasattr(argument, "getattr"):
+                # everything else is not a proper sequence for reversed()
+                for methods in REVERSED_METHODS:
+                    for meth in methods:
+                        try:
+                            argument.getattr(meth)
+                        except astroid.NotFoundError:
+                            break
+                    else:
+                        break
+                else:
+                    self.add_message("bad-reversed-sequence", node=node)
+            else:
+                self.add_message("bad-reversed-sequence", node=node)
+
+    @utils.check_messages("confusing-with-statement")
+    def visit_with(self, node: nodes.With) -> None:
+        # a "with" statement with multiple managers corresponds
+        # to one AST "With" node with multiple items
+        pairs = node.items
+        if pairs:
+            for prev_pair, pair in zip(pairs, pairs[1:]):
+                if isinstance(prev_pair[1], nodes.AssignName) and (
+                    pair[1] is None and not isinstance(pair[0], nodes.Call)
+                ):
+                    # Don't emit a message if the second is a function call
+                    # there's no way that can be mistaken for a name assignment.
+                    # If the line number doesn't match
+                    # we assume it's a nested "with".
+                    self.add_message("confusing-with-statement", node=node)
+
+    def _check_self_assigning_variable(self, node):
+        # Detect assigning to the same variable.
+
+        scope = node.scope()
+        scope_locals = scope.locals
+
+        rhs_names = []
+        targets = node.targets
+        if isinstance(targets[0], nodes.Tuple):
+            if len(targets) != 1:
+                # A complex assignment, so bail out early.
+                return
+            targets = targets[0].elts
+            if len(targets) == 1:
+                # Unpacking a variable into the same name.
+                return
+
+        if isinstance(node.value, nodes.Name):
+            if len(targets) != 1:
+                return
+            rhs_names = [node.value]
+        elif isinstance(node.value, nodes.Tuple):
+            rhs_count = len(node.value.elts)
+            if len(targets) != rhs_count or rhs_count == 1:
+                return
+            rhs_names = node.value.elts
+
+        for target, lhs_name in zip(targets, rhs_names):
+            if not isinstance(lhs_name, nodes.Name):
+                continue
+            if not isinstance(target, nodes.AssignName):
+                continue
+            # Check that the scope is different from a class level, which is usually
+            # a pattern to expose module level attributes as class level ones.
+            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
+                continue
+            if target.name == lhs_name.name:
+                self.add_message(
+                    "self-assigning-variable", args=(target.name,), node=target
+                )
+
+    def _check_redeclared_assign_name(self, targets):
+        dummy_variables_rgx = lint_utils.get_global_option(
+            self, "dummy-variables-rgx", default=None
+        )
+
+        for target in targets:
+            if not isinstance(target, nodes.Tuple):
+                continue
+
+            found_names = []
+            for element in target.elts:
+                if isinstance(element, nodes.Tuple):
+                    self._check_redeclared_assign_name([element])
+                elif isinstance(element, nodes.AssignName) and element.name != "_":
+                    if dummy_variables_rgx and dummy_variables_rgx.match(element.name):
+                        return
+                    found_names.append(element.name)
+
+            names = collections.Counter(found_names)
+            for name, count in names.most_common():
+                if count > 1:
+                    self.add_message(
+                        "redeclared-assigned-name", args=(name,), node=target
+                    )
+
+    @utils.check_messages("self-assigning-variable", "redeclared-assigned-name")
+    def visit_assign(self, node: nodes.Assign) -> None:
+        self._check_self_assigning_variable(node)
+        self._check_redeclared_assign_name(node.targets)
+
+    @utils.check_messages("redeclared-assigned-name")
+    def visit_for(self, node: nodes.For) -> None:
+        self._check_redeclared_assign_name([node.target])
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/base/basic_error_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/base/basic_error_checker.py
new file mode 100644
index 0000000..242c13f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/base/basic_error_checker.py
@@ -0,0 +1,572 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Basic Error checker from the basic checker."""
+
+import collections
+import itertools
+from typing import Any, Iterator
+
+import astroid
+from astroid import nodes
+
+from pylint import utils as lint_utils
+from pylint.checkers import utils
+from pylint.checkers.base.basic_checker import _BasicChecker
+from pylint.checkers.utils import infer_all
+
+ABC_METACLASSES = {"_py_abc.ABCMeta", "abc.ABCMeta"}  # Python 3.7+,
+# List of methods which can be redefined
+REDEFINABLE_METHODS = frozenset(("__module__",))
+TYPING_FORWARD_REF_QNAME = "typing.ForwardRef"
+
+
+def _get_break_loop_node(break_node):
+    """Returns the loop node that holds the break node in arguments.
+
+    Args:
+        break_node (astroid.Break): the break node of interest.
+
+    Returns:
+        astroid.For or astroid.While: the loop node holding the break node.
+    """
+    loop_nodes = (nodes.For, nodes.While)
+    parent = break_node.parent
+    while not isinstance(parent, loop_nodes) or break_node in getattr(
+        parent, "orelse", []
+    ):
+        break_node = parent
+        parent = parent.parent
+        if parent is None:
+            break
+    return parent
+
+
+def _loop_exits_early(loop):
+    """Returns true if a loop may end with a break statement.
+
+    Args:
+        loop (astroid.For, astroid.While): the loop node inspected.
+
+    Returns:
+        bool: True if the loop may end with a break statement, False otherwise.
+    """
+    loop_nodes = (nodes.For, nodes.While)
+    definition_nodes = (nodes.FunctionDef, nodes.ClassDef)
+    inner_loop_nodes = [
+        _node
+        for _node in loop.nodes_of_class(loop_nodes, skip_klass=definition_nodes)
+        if _node != loop
+    ]
+    return any(
+        _node
+        for _node in loop.nodes_of_class(nodes.Break, skip_klass=definition_nodes)
+        if _get_break_loop_node(_node) not in inner_loop_nodes
+    )
+
+
+def _has_abstract_methods(node):
+    """Determine if the given `node` has abstract methods.
+
+    The methods should be made abstract by decorating them
+    with `abc` decorators.
+    """
+    return len(utils.unimplemented_abstract_methods(node)) > 0
+
+
+def redefined_by_decorator(node):
+    """Return True if the object is a method redefined via decorator.
+
+    For example:
+        @property
+        def x(self): return self._x
+        @x.setter
+        def x(self, value): self._x = value
+    """
+    if node.decorators:
+        for decorator in node.decorators.nodes:
+            if (
+                isinstance(decorator, nodes.Attribute)
+                and getattr(decorator.expr, "name", None) == node.name
+            ):
+                return True
+    return False
+
+
+class BasicErrorChecker(_BasicChecker):
+    msgs = {
+        "E0100": (
+            "__init__ method is a generator",
+            "init-is-generator",
+            "Used when the special class method __init__ is turned into a "
+            "generator by a yield in its body.",
+        ),
+        "E0101": (
+            "Explicit return in __init__",
+            "return-in-init",
+            "Used when the special class method __init__ has an explicit "
+            "return value.",
+        ),
+        "E0102": (
+            "%s already defined line %s",
+            "function-redefined",
+            "Used when a function / class / method is redefined.",
+        ),
+        "E0103": (
+            "%r not properly in loop",
+            "not-in-loop",
+            "Used when break or continue keywords are used outside a loop.",
+        ),
+        "E0104": (
+            "Return outside function",
+            "return-outside-function",
+            'Used when a "return" statement is found outside a function or method.',
+        ),
+        "E0105": (
+            "Yield outside function",
+            "yield-outside-function",
+            'Used when a "yield" statement is found outside a function or method.',
+        ),
+        "E0106": (
+            "Return with argument inside generator",
+            "return-arg-in-generator",
+            'Used when a "return" statement with an argument is found '
+            "outside in a generator function or method (e.g. with some "
+            '"yield" statements).',
+            {"maxversion": (3, 3)},
+        ),
+        "E0107": (
+            "Use of the non-existent %s operator",
+            "nonexistent-operator",
+            "Used when you attempt to use the C-style pre-increment or "
+            "pre-decrement operator -- and ++, which doesn't exist in Python.",
+        ),
+        "E0108": (
+            "Duplicate argument name %s in function definition",
+            "duplicate-argument-name",
+            "Duplicate argument names in function definitions are syntax errors.",
+        ),
+        "E0110": (
+            "Abstract class %r with abstract methods instantiated",
+            "abstract-class-instantiated",
+            "Used when an abstract class with `abc.ABCMeta` as metaclass "
+            "has abstract methods and is instantiated.",
+        ),
+        "W0120": (
+            "Else clause on loop without a break statement, remove the else and"
+            " de-indent all the code inside it",
+            "useless-else-on-loop",
+            "Loops should only have an else clause if they can exit early "
+            "with a break statement, otherwise the statements under else "
+            "should be on the same scope as the loop itself.",
+        ),
+        "E0112": (
+            "More than one starred expression in assignment",
+            "too-many-star-expressions",
+            "Emitted when there are more than one starred "
+            "expressions (`*x`) in an assignment. This is a SyntaxError.",
+        ),
+        "E0113": (
+            "Starred assignment target must be in a list or tuple",
+            "invalid-star-assignment-target",
+            "Emitted when a star expression is used as a starred assignment target.",
+        ),
+        "E0114": (
+            "Can use starred expression only in assignment target",
+            "star-needs-assignment-target",
+            "Emitted when a star expression is not used in an assignment target.",
+        ),
+        "E0115": (
+            "Name %r is nonlocal and global",
+            "nonlocal-and-global",
+            "Emitted when a name is both nonlocal and global.",
+        ),
+        "E0116": (
+            "'continue' not supported inside 'finally' clause",
+            "continue-in-finally",
+            "Emitted when the `continue` keyword is found "
+            "inside a finally clause, which is a SyntaxError.",
+            {"maxversion": (3, 8)},
+        ),
+        "E0117": (
+            "nonlocal name %s found without binding",
+            "nonlocal-without-binding",
+            "Emitted when a nonlocal variable does not have an attached "
+            "name somewhere in the parent scopes",
+        ),
+        "E0118": (
+            "Name %r is used prior to global declaration",
+            "used-prior-global-declaration",
+            "Emitted when a name is used prior a global declaration, "
+            "which results in an error since Python 3.6.",
+            {"minversion": (3, 6)},
+        ),
+    }
+
+    @utils.check_messages("function-redefined")
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        self._check_redefinition("class", node)
+
+    def _too_many_starred_for_tuple(self, assign_tuple):
+        starred_count = 0
+        for elem in assign_tuple.itered():
+            if isinstance(elem, nodes.Tuple):
+                return self._too_many_starred_for_tuple(elem)
+            if isinstance(elem, nodes.Starred):
+                starred_count += 1
+        return starred_count > 1
+
+    @utils.check_messages("too-many-star-expressions", "invalid-star-assignment-target")
+    def visit_assign(self, node: nodes.Assign) -> None:
+        # Check *a, *b = ...
+        assign_target = node.targets[0]
+        # Check *a = b
+        if isinstance(node.targets[0], nodes.Starred):
+            self.add_message("invalid-star-assignment-target", node=node)
+
+        if not isinstance(assign_target, nodes.Tuple):
+            return
+        if self._too_many_starred_for_tuple(assign_target):
+            self.add_message("too-many-star-expressions", node=node)
+
+    @utils.check_messages("star-needs-assignment-target")
+    def visit_starred(self, node: nodes.Starred) -> None:
+        """Check that a Starred expression is used in an assignment target."""
+        if isinstance(node.parent, nodes.Call):
+            # f(*args) is converted to Call(args=[Starred]), so ignore
+            # them for this check.
+            return
+        if isinstance(node.parent, (nodes.List, nodes.Tuple, nodes.Set, nodes.Dict)):
+            # PEP 448 unpacking.
+            return
+
+        stmt = node.statement(future=True)
+        if not isinstance(stmt, nodes.Assign):
+            return
+
+        if stmt.value is node or stmt.value.parent_of(node):
+            self.add_message("star-needs-assignment-target", node=node)
+
+    @utils.check_messages(
+        "init-is-generator",
+        "return-in-init",
+        "function-redefined",
+        "return-arg-in-generator",
+        "duplicate-argument-name",
+        "nonlocal-and-global",
+        "used-prior-global-declaration",
+    )
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        self._check_nonlocal_and_global(node)
+        self._check_name_used_prior_global(node)
+        if not redefined_by_decorator(
+            node
+        ) and not utils.is_registered_in_singledispatch_function(node):
+            self._check_redefinition(node.is_method() and "method" or "function", node)
+        # checks for max returns, branch, return in __init__
+        returns = node.nodes_of_class(
+            nodes.Return, skip_klass=(nodes.FunctionDef, nodes.ClassDef)
+        )
+        if node.is_method() and node.name == "__init__":
+            if node.is_generator():
+                self.add_message("init-is-generator", node=node)
+            else:
+                values = [r.value for r in returns]
+                # Are we returning anything but None from constructors
+                if any(v for v in values if not utils.is_none(v)):
+                    self.add_message("return-in-init", node=node)
+        # Check for duplicate names by clustering args with same name for detailed report
+        arg_clusters = collections.defaultdict(list)
+        arguments: Iterator[Any] = filter(None, [node.args.args, node.args.kwonlyargs])
+
+        for arg in itertools.chain.from_iterable(arguments):
+            arg_clusters[arg.name].append(arg)
+
+        # provide detailed report about each repeated argument
+        for argument_duplicates in arg_clusters.values():
+            if len(argument_duplicates) != 1:
+                for argument in argument_duplicates:
+                    self.add_message(
+                        "duplicate-argument-name",
+                        line=argument.lineno,
+                        node=argument,
+                        args=(argument.name,),
+                    )
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    def _check_name_used_prior_global(self, node):
+
+        scope_globals = {
+            name: child
+            for child in node.nodes_of_class(nodes.Global)
+            for name in child.names
+            if child.scope() is node
+        }
+
+        if not scope_globals:
+            return
+
+        for node_name in node.nodes_of_class(nodes.Name):
+            if node_name.scope() is not node:
+                continue
+
+            name = node_name.name
+            corresponding_global = scope_globals.get(name)
+            if not corresponding_global:
+                continue
+
+            global_lineno = corresponding_global.fromlineno
+            if global_lineno and global_lineno > node_name.fromlineno:
+                self.add_message(
+                    "used-prior-global-declaration", node=node_name, args=(name,)
+                )
+
+    def _check_nonlocal_and_global(self, node):
+        """Check that a name is both nonlocal and global."""
+
+        def same_scope(current):
+            return current.scope() is node
+
+        from_iter = itertools.chain.from_iterable
+        nonlocals = set(
+            from_iter(
+                child.names
+                for child in node.nodes_of_class(nodes.Nonlocal)
+                if same_scope(child)
+            )
+        )
+
+        if not nonlocals:
+            return
+
+        global_vars = set(
+            from_iter(
+                child.names
+                for child in node.nodes_of_class(nodes.Global)
+                if same_scope(child)
+            )
+        )
+        for name in nonlocals.intersection(global_vars):
+            self.add_message("nonlocal-and-global", args=(name,), node=node)
+
+    @utils.check_messages("return-outside-function")
+    def visit_return(self, node: nodes.Return) -> None:
+        if not isinstance(node.frame(future=True), nodes.FunctionDef):
+            self.add_message("return-outside-function", node=node)
+
+    @utils.check_messages("yield-outside-function")
+    def visit_yield(self, node: nodes.Yield) -> None:
+        self._check_yield_outside_func(node)
+
+    @utils.check_messages("yield-outside-function")
+    def visit_yieldfrom(self, node: nodes.YieldFrom) -> None:
+        self._check_yield_outside_func(node)
+
+    @utils.check_messages("not-in-loop", "continue-in-finally")
+    def visit_continue(self, node: nodes.Continue) -> None:
+        self._check_in_loop(node, "continue")
+
+    @utils.check_messages("not-in-loop")
+    def visit_break(self, node: nodes.Break) -> None:
+        self._check_in_loop(node, "break")
+
+    @utils.check_messages("useless-else-on-loop")
+    def visit_for(self, node: nodes.For) -> None:
+        self._check_else_on_loop(node)
+
+    @utils.check_messages("useless-else-on-loop")
+    def visit_while(self, node: nodes.While) -> None:
+        self._check_else_on_loop(node)
+
+    @utils.check_messages("nonexistent-operator")
+    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
+        """Check use of the non-existent ++ and -- operators."""
+        if (
+            (node.op in "+-")
+            and isinstance(node.operand, nodes.UnaryOp)
+            and (node.operand.op == node.op)
+            and (node.col_offset + 1 == node.operand.col_offset)
+        ):
+            self.add_message("nonexistent-operator", node=node, args=node.op * 2)
+
+    def _check_nonlocal_without_binding(self, node, name):
+        current_scope = node.scope()
+        while True:
+            if current_scope.parent is None:
+                break
+
+            if not isinstance(current_scope, (nodes.ClassDef, nodes.FunctionDef)):
+                self.add_message("nonlocal-without-binding", args=(name,), node=node)
+                return
+
+            if name not in current_scope.locals:
+                current_scope = current_scope.parent.scope()
+                continue
+
+            # Okay, found it.
+            return
+
+        if not isinstance(current_scope, nodes.FunctionDef):
+            self.add_message("nonlocal-without-binding", args=(name,), node=node)
+
+    @utils.check_messages("nonlocal-without-binding")
+    def visit_nonlocal(self, node: nodes.Nonlocal) -> None:
+        for name in node.names:
+            self._check_nonlocal_without_binding(node, name)
+
+    @utils.check_messages("abstract-class-instantiated")
+    def visit_call(self, node: nodes.Call) -> None:
+        """Check instantiating abstract class with
+        abc.ABCMeta as metaclass.
+        """
+        for inferred in infer_all(node.func):
+            self._check_inferred_class_is_abstract(inferred, node)
+
+    def _check_inferred_class_is_abstract(self, inferred, node):
+        if not isinstance(inferred, nodes.ClassDef):
+            return
+
+        klass = utils.node_frame_class(node)
+        if klass is inferred:
+            # Don't emit the warning if the class is instantiated
+            # in its own body or if the call is not an instance
+            # creation. If the class is instantiated into its own
+            # body, we're expecting that it knows what it is doing.
+            return
+
+        # __init__ was called
+        abstract_methods = _has_abstract_methods(inferred)
+
+        if not abstract_methods:
+            return
+
+        metaclass = inferred.metaclass()
+
+        if metaclass is None:
+            # Python 3.4 has `abc.ABC`, which won't be detected
+            # by ClassNode.metaclass()
+            for ancestor in inferred.ancestors():
+                if ancestor.qname() == "abc.ABC":
+                    self.add_message(
+                        "abstract-class-instantiated", args=(inferred.name,), node=node
+                    )
+                    break
+
+            return
+
+        if metaclass.qname() in ABC_METACLASSES:
+            self.add_message(
+                "abstract-class-instantiated", args=(inferred.name,), node=node
+            )
+
+    def _check_yield_outside_func(self, node):
+        if not isinstance(node.frame(future=True), (nodes.FunctionDef, nodes.Lambda)):
+            self.add_message("yield-outside-function", node=node)
+
+    def _check_else_on_loop(self, node):
+        """Check that any loop with an else clause has a break statement."""
+        if node.orelse and not _loop_exits_early(node):
+            self.add_message(
+                "useless-else-on-loop",
+                node=node,
+                # This is not optimal, but the line previous
+                # to the first statement in the else clause
+                # will usually be the one that contains the else:.
+                line=node.orelse[0].lineno - 1,
+            )
+
+    def _check_in_loop(self, node, node_name):
+        """Check that a node is inside a for or while loop."""
+        for parent in node.node_ancestors():
+            if isinstance(parent, (nodes.For, nodes.While)):
+                if node not in parent.orelse:
+                    return
+
+            if isinstance(parent, (nodes.ClassDef, nodes.FunctionDef)):
+                break
+            if (
+                isinstance(parent, nodes.TryFinally)
+                and node in parent.finalbody
+                and isinstance(node, nodes.Continue)
+            ):
+                self.add_message("continue-in-finally", node=node)
+
+        self.add_message("not-in-loop", node=node, args=node_name)
+
+    def _check_redefinition(self, redeftype, node):
+        """Check for redefinition of a function / method / class name."""
+        parent_frame = node.parent.frame(future=True)
+
+        # Ignore function stubs created for type information
+        redefinitions = [
+            i
+            for i in parent_frame.locals[node.name]
+            if not (isinstance(i.parent, nodes.AnnAssign) and i.parent.simple)
+        ]
+        defined_self = next(
+            (local for local in redefinitions if not utils.is_overload_stub(local)),
+            node,
+        )
+        if defined_self is not node and not astroid.are_exclusive(node, defined_self):
+            # Additional checks for methods which are not considered
+            # redefined, since they are already part of the base API.
+            if (
+                isinstance(parent_frame, nodes.ClassDef)
+                and node.name in REDEFINABLE_METHODS
+            ):
+                return
+
+            # Skip typing.overload() functions.
+            if utils.is_overload_stub(node):
+                return
+
+            # Exempt functions redefined on a condition.
+            if isinstance(node.parent, nodes.If):
+                # Exempt "if not <func>" cases
+                if (
+                    isinstance(node.parent.test, nodes.UnaryOp)
+                    and node.parent.test.op == "not"
+                    and isinstance(node.parent.test.operand, nodes.Name)
+                    and node.parent.test.operand.name == node.name
+                ):
+                    return
+
+                # Exempt "if <func> is not None" cases
+                # pylint: disable=too-many-boolean-expressions
+                if (
+                    isinstance(node.parent.test, nodes.Compare)
+                    and isinstance(node.parent.test.left, nodes.Name)
+                    and node.parent.test.left.name == node.name
+                    and node.parent.test.ops[0][0] == "is"
+                    and isinstance(node.parent.test.ops[0][1], nodes.Const)
+                    and node.parent.test.ops[0][1].value is None
+                ):
+                    return
+
+            # Check if we have forward references for this node.
+            try:
+                redefinition_index = redefinitions.index(node)
+            except ValueError:
+                pass
+            else:
+                for redefinition in redefinitions[:redefinition_index]:
+                    inferred = utils.safe_infer(redefinition)
+                    if (
+                        inferred
+                        and isinstance(inferred, astroid.Instance)
+                        and inferred.qname() == TYPING_FORWARD_REF_QNAME
+                    ):
+                        return
+
+            dummy_variables_rgx = lint_utils.get_global_option(
+                self, "dummy-variables-rgx", default=None
+            )
+            if dummy_variables_rgx and dummy_variables_rgx.match(node.name):
+                return
+            self.add_message(
+                "function-redefined",
+                node=node,
+                args=(redeftype, defined_self.fromlineno),
+            )
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/base/comparison_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/base/comparison_checker.py
new file mode 100644
index 0000000..1db5076
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/base/comparison_checker.py
@@ -0,0 +1,295 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Comparison checker from the basic checker."""
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import utils
+from pylint.checkers.base.basic_checker import _BasicChecker
+
+LITERAL_NODE_TYPES = (nodes.Const, nodes.Dict, nodes.List, nodes.Set)
+COMPARISON_OPERATORS = frozenset(("==", "!=", "<", ">", "<=", ">="))
+TYPECHECK_COMPARISON_OPERATORS = frozenset(("is", "is not", "==", "!="))
+TYPE_QNAME = "builtins.type"
+
+
+def _is_one_arg_pos_call(call):
+    """Is this a call with exactly 1 positional argument ?"""
+    return isinstance(call, nodes.Call) and len(call.args) == 1 and not call.keywords
+
+
+class ComparisonChecker(_BasicChecker):
+    """Checks for comparisons.
+
+    - singleton comparison: 'expr == True', 'expr == False' and 'expr == None'
+    - yoda condition: 'const "comp" right' where comp can be '==', '!=', '<',
+      '<=', '>' or '>=', and right can be a variable, an attribute, a method or
+      a function
+    """
+
+    msgs = {
+        "C0121": (
+            "Comparison %s should be %s",
+            "singleton-comparison",
+            "Used when an expression is compared to singleton "
+            "values like True, False or None.",
+        ),
+        "C0123": (
+            "Use isinstance() rather than type() for a typecheck.",
+            "unidiomatic-typecheck",
+            "The idiomatic way to perform an explicit typecheck in "
+            "Python is to use isinstance(x, Y) rather than "
+            "type(x) == Y, type(x) is Y. Though there are unusual "
+            "situations where these give different results.",
+            {"old_names": [("W0154", "old-unidiomatic-typecheck")]},
+        ),
+        "R0123": (
+            "Comparison to literal",
+            "literal-comparison",
+            "Used when comparing an object to a literal, which is usually "
+            "what you do not want to do, since you can compare to a different "
+            "literal than what was expected altogether.",
+        ),
+        "R0124": (
+            "Redundant comparison - %s",
+            "comparison-with-itself",
+            "Used when something is compared against itself.",
+        ),
+        "W0143": (
+            "Comparing against a callable, did you omit the parenthesis?",
+            "comparison-with-callable",
+            "This message is emitted when pylint detects that a comparison with a "
+            "callable was made, which might suggest that some parenthesis were omitted, "
+            "resulting in potential unwanted behaviour.",
+        ),
+        "W0177": (
+            "Comparison %s should be %s",
+            "nan-comparison",
+            "Used when an expression is compared to NaN"
+            "values like numpy.NaN and float('nan')",
+        ),
+    }
+
+    def _check_singleton_comparison(
+        self, left_value, right_value, root_node, checking_for_absence: bool = False
+    ):
+        """Check if == or != is being used to compare a singleton value."""
+        singleton_values = (True, False, None)
+
+        def _is_singleton_const(node) -> bool:
+            return isinstance(node, nodes.Const) and any(
+                node.value is value for value in singleton_values
+            )
+
+        if _is_singleton_const(left_value):
+            singleton, other_value = left_value.value, right_value
+        elif _is_singleton_const(right_value):
+            singleton, other_value = right_value.value, left_value
+        else:
+            return
+
+        singleton_comparison_example = {False: "'{} is {}'", True: "'{} is not {}'"}
+
+        # True/False singletons have a special-cased message in case the user is
+        # mistakenly using == or != to check for truthiness
+        if singleton in {True, False}:
+            suggestion_template = (
+                "{} if checking for the singleton value {}, or {} if testing for {}"
+            )
+            truthiness_example = {False: "not {}", True: "{}"}
+            truthiness_phrase = {True: "truthiness", False: "falsiness"}
+
+            # Looks for comparisons like x == True or x != False
+            checking_truthiness = singleton is not checking_for_absence
+
+            suggestion = suggestion_template.format(
+                singleton_comparison_example[checking_for_absence].format(
+                    left_value.as_string(), right_value.as_string()
+                ),
+                singleton,
+                (
+                    "'bool({})'"
+                    if not utils.is_test_condition(root_node) and checking_truthiness
+                    else "'{}'"
+                ).format(
+                    truthiness_example[checking_truthiness].format(
+                        other_value.as_string()
+                    )
+                ),
+                truthiness_phrase[checking_truthiness],
+            )
+        else:
+            suggestion = singleton_comparison_example[checking_for_absence].format(
+                left_value.as_string(), right_value.as_string()
+            )
+        self.add_message(
+            "singleton-comparison",
+            node=root_node,
+            args=(f"'{root_node.as_string()}'", suggestion),
+        )
+
+    def _check_nan_comparison(
+        self, left_value, right_value, root_node, checking_for_absence: bool = False
+    ):
+        def _is_float_nan(node):
+            try:
+                if isinstance(node, nodes.Call) and len(node.args) == 1:
+                    if (
+                        node.args[0].value.lower() == "nan"
+                        and node.inferred()[0].pytype() == "builtins.float"
+                    ):
+                        return True
+                return False
+            except AttributeError:
+                return False
+
+        def _is_numpy_nan(node):
+            if isinstance(node, nodes.Attribute) and node.attrname == "NaN":
+                if isinstance(node.expr, nodes.Name):
+                    return node.expr.name in {"numpy", "nmp", "np"}
+            return False
+
+        def _is_nan(node) -> bool:
+            return _is_float_nan(node) or _is_numpy_nan(node)
+
+        nan_left = _is_nan(left_value)
+        if not nan_left and not _is_nan(right_value):
+            return
+
+        absence_text = ""
+        if checking_for_absence:
+            absence_text = "not "
+        if nan_left:
+            suggestion = f"'{absence_text}math.isnan({right_value.as_string()})'"
+        else:
+            suggestion = f"'{absence_text}math.isnan({left_value.as_string()})'"
+        self.add_message(
+            "nan-comparison",
+            node=root_node,
+            args=(f"'{root_node.as_string()}'", suggestion),
+        )
+
+    def _check_literal_comparison(self, literal, node: nodes.Compare):
+        """Check if we compare to a literal, which is usually what we do not want to do."""
+        is_other_literal = isinstance(literal, (nodes.List, nodes.Dict, nodes.Set))
+        is_const = False
+        if isinstance(literal, nodes.Const):
+            if isinstance(literal.value, bool) or literal.value is None:
+                # Not interested in these values.
+                return
+            is_const = isinstance(literal.value, (bytes, str, int, float))
+
+        if is_const or is_other_literal:
+            self.add_message("literal-comparison", node=node)
+
+    def _check_logical_tautology(self, node: nodes.Compare):
+        """Check if identifier is compared against itself.
+
+        :param node: Compare node
+        :Example:
+        val = 786
+        if val == val:  # [comparison-with-itself]
+            pass
+        """
+        left_operand = node.left
+        right_operand = node.ops[0][1]
+        operator = node.ops[0][0]
+        if isinstance(left_operand, nodes.Const) and isinstance(
+            right_operand, nodes.Const
+        ):
+            left_operand = left_operand.value
+            right_operand = right_operand.value
+        elif isinstance(left_operand, nodes.Name) and isinstance(
+            right_operand, nodes.Name
+        ):
+            left_operand = left_operand.name
+            right_operand = right_operand.name
+
+        if left_operand == right_operand:
+            suggestion = f"{left_operand} {operator} {right_operand}"
+            self.add_message("comparison-with-itself", node=node, args=(suggestion,))
+
+    def _check_callable_comparison(self, node):
+        operator = node.ops[0][0]
+        if operator not in COMPARISON_OPERATORS:
+            return
+
+        bare_callables = (nodes.FunctionDef, astroid.BoundMethod)
+        left_operand, right_operand = node.left, node.ops[0][1]
+        # this message should be emitted only when there is comparison of bare callable
+        # with non bare callable.
+        number_of_bare_callables = 0
+        for operand in left_operand, right_operand:
+            inferred = utils.safe_infer(operand)
+            # Ignore callables that raise, as well as typing constants
+            # implemented as functions (that raise via their decorator)
+            if (
+                isinstance(inferred, bare_callables)
+                and "typing._SpecialForm" not in inferred.decoratornames()
+                and not any(isinstance(x, nodes.Raise) for x in inferred.body)
+            ):
+                number_of_bare_callables += 1
+        if number_of_bare_callables == 1:
+            self.add_message("comparison-with-callable", node=node)
+
+    @utils.check_messages(
+        "singleton-comparison",
+        "unidiomatic-typecheck",
+        "literal-comparison",
+        "comparison-with-itself",
+        "comparison-with-callable",
+    )
+    def visit_compare(self, node: nodes.Compare) -> None:
+        self._check_callable_comparison(node)
+        self._check_logical_tautology(node)
+        self._check_unidiomatic_typecheck(node)
+        # NOTE: this checker only works with binary comparisons like 'x == 42'
+        # but not 'x == y == 42'
+        if len(node.ops) != 1:
+            return
+
+        left = node.left
+        operator, right = node.ops[0]
+
+        if operator in {"==", "!="}:
+            self._check_singleton_comparison(
+                left, right, node, checking_for_absence=operator == "!="
+            )
+
+        if operator in {"==", "!=", "is", "is not"}:
+            self._check_nan_comparison(
+                left, right, node, checking_for_absence=operator in {"!=", "is not"}
+            )
+        if operator in {"is", "is not"}:
+            self._check_literal_comparison(right, node)
+
+    def _check_unidiomatic_typecheck(self, node):
+        operator, right = node.ops[0]
+        if operator in TYPECHECK_COMPARISON_OPERATORS:
+            left = node.left
+            if _is_one_arg_pos_call(left):
+                self._check_type_x_is_y(node, left, operator, right)
+
+    def _check_type_x_is_y(self, node, left, operator, right):
+        """Check for expressions like type(x) == Y."""
+        left_func = utils.safe_infer(left.func)
+        if not (
+            isinstance(left_func, nodes.ClassDef) and left_func.qname() == TYPE_QNAME
+        ):
+            return
+
+        if operator in {"is", "is not"} and _is_one_arg_pos_call(right):
+            right_func = utils.safe_infer(right.func)
+            if (
+                isinstance(right_func, nodes.ClassDef)
+                and right_func.qname() == TYPE_QNAME
+            ):
+                # type(x) == type(a)
+                right_arg = utils.safe_infer(right.args[0])
+                if not isinstance(right_arg, LITERAL_NODE_TYPES):
+                    # not e.g. type(x) == type([])
+                    return
+        self.add_message("unidiomatic-typecheck", node=node)
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/base/docstring_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/base/docstring_checker.py
new file mode 100644
index 0000000..73a6c31
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/base/docstring_checker.py
@@ -0,0 +1,209 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Docstring checker from the basic checker."""
+
+import re
+import sys
+
+import astroid
+from astroid import nodes
+
+from pylint import interfaces
+from pylint.checkers import utils
+from pylint.checkers.base.basic_checker import _BasicChecker
+from pylint.checkers.utils import (
+    is_overload_stub,
+    is_property_deleter,
+    is_property_setter,
+)
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+# do not require a doc string on private/system methods
+NO_REQUIRED_DOC_RGX = re.compile("^_")
+
+
+def _infer_dunder_doc_attribute(node):
+    # Try to see if we have a `__doc__` attribute.
+    try:
+        docstring = node["__doc__"]
+    except KeyError:
+        return None
+
+    docstring = utils.safe_infer(docstring)
+    if not docstring:
+        return None
+    if not isinstance(docstring, nodes.Const):
+        return None
+    return docstring.value
+
+
+class DocStringChecker(_BasicChecker):
+    msgs = {
+        "C0112": (
+            "Empty %s docstring",
+            "empty-docstring",
+            "Used when a module, function, class or method has an empty "
+            "docstring (it would be too easy ;).",
+            {"old_names": [("W0132", "old-empty-docstring")]},
+        ),
+        "C0114": (
+            "Missing module docstring",
+            "missing-module-docstring",
+            "Used when a module has no docstring."
+            "Empty modules do not require a docstring.",
+            {"old_names": [("C0111", "missing-docstring")]},
+        ),
+        "C0115": (
+            "Missing class docstring",
+            "missing-class-docstring",
+            "Used when a class has no docstring."
+            "Even an empty class must have a docstring.",
+            {"old_names": [("C0111", "missing-docstring")]},
+        ),
+        "C0116": (
+            "Missing function or method docstring",
+            "missing-function-docstring",
+            "Used when a function or method has no docstring."
+            "Some special methods like __init__ do not require a "
+            "docstring.",
+            {"old_names": [("C0111", "missing-docstring")]},
+        ),
+    }
+    options = (
+        (
+            "no-docstring-rgx",
+            {
+                "default": NO_REQUIRED_DOC_RGX,
+                "type": "regexp",
+                "metavar": "<regexp>",
+                "help": "Regular expression which should only match "
+                "function or class names that do not require a "
+                "docstring.",
+            },
+        ),
+        (
+            "docstring-min-length",
+            {
+                "default": -1,
+                "type": "int",
+                "metavar": "<int>",
+                "help": (
+                    "Minimum line length for functions/classes that"
+                    " require docstrings, shorter ones are exempt."
+                ),
+            },
+        ),
+    )
+
+    def open(self):
+        self.linter.stats.reset_undocumented()
+
+    @utils.check_messages("missing-docstring", "empty-docstring")
+    def visit_module(self, node: nodes.Module) -> None:
+        self._check_docstring("module", node)
+
+    @utils.check_messages("missing-docstring", "empty-docstring")
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        if self.config.no_docstring_rgx.match(node.name) is None:
+            self._check_docstring("class", node)
+
+    @utils.check_messages("missing-docstring", "empty-docstring")
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        if self.config.no_docstring_rgx.match(node.name) is None:
+            ftype = "method" if node.is_method() else "function"
+            if (
+                is_property_setter(node)
+                or is_property_deleter(node)
+                or is_overload_stub(node)
+            ):
+                return
+
+            if isinstance(node.parent.frame(future=True), nodes.ClassDef):
+                overridden = False
+                confidence = (
+                    interfaces.INFERENCE
+                    if utils.has_known_bases(node.parent.frame(future=True))
+                    else interfaces.INFERENCE_FAILURE
+                )
+                # check if node is from a method overridden by its ancestor
+                for ancestor in node.parent.frame(future=True).ancestors():
+                    if ancestor.qname() == "builtins.object":
+                        continue
+                    if node.name in ancestor and isinstance(
+                        ancestor[node.name], nodes.FunctionDef
+                    ):
+                        overridden = True
+                        break
+                self._check_docstring(
+                    ftype, node, report_missing=not overridden, confidence=confidence  # type: ignore[arg-type]
+                )
+            elif isinstance(node.parent.frame(future=True), nodes.Module):
+                self._check_docstring(ftype, node)  # type: ignore[arg-type]
+            else:
+                return
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    def _check_docstring(
+        self,
+        node_type: Literal["class", "function", "method", "module"],
+        node,
+        report_missing=True,
+        confidence=interfaces.HIGH,
+    ):
+        """Check if the node has a non-empty docstring."""
+        docstring = node.doc_node.value if node.doc_node else None
+        if docstring is None:
+            docstring = _infer_dunder_doc_attribute(node)
+
+        if docstring is None:
+            if not report_missing:
+                return
+            lines = utils.get_node_last_lineno(node) - node.lineno
+
+            if node_type == "module" and not lines:
+                # If the module does not have a body, there's no reason
+                # to require a docstring.
+                return
+            max_lines = self.config.docstring_min_length
+
+            if node_type != "module" and max_lines > -1 and lines < max_lines:
+                return
+            if node_type == "class":
+                self.linter.stats.undocumented["klass"] += 1
+            else:
+                self.linter.stats.undocumented[node_type] += 1
+            if (
+                node.body
+                and isinstance(node.body[0], nodes.Expr)
+                and isinstance(node.body[0].value, nodes.Call)
+            ):
+                # Most likely a string with a format call. Let's see.
+                func = utils.safe_infer(node.body[0].value.func)
+                if isinstance(func, astroid.BoundMethod) and isinstance(
+                    func.bound, astroid.Instance
+                ):
+                    # Strings.
+                    if func.bound.name in {"str", "unicode", "bytes"}:
+                        return
+            if node_type == "module":
+                message = "missing-module-docstring"
+            elif node_type == "class":
+                message = "missing-class-docstring"
+            else:
+                message = "missing-function-docstring"
+            self.add_message(message, node=node, confidence=confidence)
+        elif not docstring.strip():
+            if node_type == "class":
+                self.linter.stats.undocumented["klass"] += 1
+            else:
+                self.linter.stats.undocumented[node_type] += 1
+            self.add_message(
+                "empty-docstring", node=node, args=(node_type,), confidence=confidence
+            )
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/base/name_checker/__init__.py b/myenv/lib/python3.9/site-packages/pylint/checkers/base/name_checker/__init__.py
new file mode 100644
index 0000000..3d6818b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/base/name_checker/__init__.py
@@ -0,0 +1,25 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+__all__ = [
+    "NameChecker",
+    "NamingStyle",
+    "KNOWN_NAME_TYPES_WITH_STYLE",
+    "SnakeCaseStyle",
+    "CamelCaseStyle",
+    "UpperCaseStyle",
+    "PascalCaseStyle",
+    "AnyStyle",
+]
+
+from pylint.checkers.base.name_checker.checker import NameChecker
+from pylint.checkers.base.name_checker.naming_style import (
+    KNOWN_NAME_TYPES_WITH_STYLE,
+    AnyStyle,
+    CamelCaseStyle,
+    NamingStyle,
+    PascalCaseStyle,
+    SnakeCaseStyle,
+    UpperCaseStyle,
+)
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/base/name_checker/checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/base/name_checker/checker.py
new file mode 100644
index 0000000..9527ae1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/base/name_checker/checker.py
@@ -0,0 +1,590 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Basic checker for Python code."""
+import collections
+import itertools
+import re
+import sys
+from typing import Dict, Optional, Pattern, Tuple
+
+import astroid
+from astroid import nodes
+
+from pylint import constants, interfaces
+from pylint.checkers import utils
+from pylint.checkers.base.basic_checker import _BasicChecker
+from pylint.checkers.base.name_checker.naming_style import (
+    KNOWN_NAME_TYPES,
+    KNOWN_NAME_TYPES_WITH_STYLE,
+    NAMING_STYLES,
+    _create_naming_options,
+)
+from pylint.checkers.utils import is_property_deleter, is_property_setter
+
+# Default patterns for name types that do not have styles
+DEFAULT_PATTERNS = {
+    "typevar": re.compile(
+        r"^_{0,2}(?:[^\W\da-z_]+|(?:[^\W\da-z_]+[^\WA-Z_]+)+T?(?<!Type))(?:_co(?:ntra)?)?$"
+    )
+}
+
+BUILTIN_PROPERTY = "builtins.property"
+TYPING_TYPE_VAR_QNAME = "typing.TypeVar"
+
+
+def _get_properties(config):
+    """Returns a tuple of property classes and names.
+
+    Property classes are fully qualified, such as 'abc.abstractproperty' and
+    property names are the actual names, such as 'abstract_property'.
+    """
+    property_classes = {BUILTIN_PROPERTY}
+    property_names = set()  # Not returning 'property', it has its own check.
+    if config is not None:
+        property_classes.update(config.property_classes)
+        property_names.update(
+            prop.rsplit(".", 1)[-1] for prop in config.property_classes
+        )
+    return property_classes, property_names
+
+
+def _redefines_import(node):
+    """Detect that the given node (AssignName) is inside an
+    exception handler and redefines an import from the tryexcept body.
+
+    Returns True if the node redefines an import, False otherwise.
+    """
+    current = node
+    while current and not isinstance(current.parent, nodes.ExceptHandler):
+        current = current.parent
+    if not current or not utils.error_of_type(current.parent, ImportError):
+        return False
+    try_block = current.parent.parent
+    for import_node in try_block.nodes_of_class((nodes.ImportFrom, nodes.Import)):
+        for name, alias in import_node.names:
+            if alias:
+                if alias == node.name:
+                    return True
+            elif name == node.name:
+                return True
+    return False
+
+
+def _determine_function_name_type(node: nodes.FunctionDef, config=None):
+    """Determine the name type whose regex the function's name should match.
+
+    :param node: A function node.
+    :param config: Configuration from which to pull additional property classes.
+    :type config: :class:`optparse.Values`
+
+    :returns: One of ('function', 'method', 'attr')
+    :rtype: str
+    """
+    property_classes, property_names = _get_properties(config)
+    if not node.is_method():
+        return "function"
+
+    if is_property_setter(node) or is_property_deleter(node):
+        # If the function is decorated using the prop_method.{setter,getter}
+        # form, treat it like an attribute as well.
+        return "attr"
+
+    decorators = node.decorators.nodes if node.decorators else []
+    for decorator in decorators:
+        # If the function is a property (decorated with @property
+        # or @abc.abstractproperty), the name type is 'attr'.
+        if isinstance(decorator, nodes.Name) or (
+            isinstance(decorator, nodes.Attribute)
+            and decorator.attrname in property_names
+        ):
+            inferred = utils.safe_infer(decorator)
+            if (
+                inferred
+                and hasattr(inferred, "qname")
+                and inferred.qname() in property_classes
+            ):
+                return "attr"
+    return "method"
+
+
+# Name categories that are always consistent with all naming conventions.
+EXEMPT_NAME_CATEGORIES = {"exempt", "ignore"}
+
+
+def _is_multi_naming_match(match, node_type, confidence):
+    return (
+        match is not None
+        and match.lastgroup is not None
+        and match.lastgroup not in EXEMPT_NAME_CATEGORIES
+        and (node_type != "method" or confidence != interfaces.INFERENCE_FAILURE)
+    )
+
+
+class NameChecker(_BasicChecker):
+    msgs = {
+        "C0103": (
+            '%s name "%s" doesn\'t conform to %s',
+            "invalid-name",
+            "Used when the name doesn't conform to naming rules "
+            "associated to its type (constant, variable, class...).",
+        ),
+        "C0104": (
+            'Disallowed name "%s"',
+            "disallowed-name",
+            "Used when the name matches bad-names or bad-names-rgxs- (unauthorized names).",
+            {
+                "old_names": [
+                    ("C0102", "blacklisted-name"),
+                ]
+            },
+        ),
+        "C0105": (
+            'Type variable "%s" is %s, use "%s" instead',
+            "typevar-name-incorrect-variance",
+            "Emitted when a TypeVar name doesn't reflect its type variance. "
+            "According to PEP8, it is recommended to add suffixes '_co' and "
+            "'_contra' to the variables used to declare covariant or "
+            "contravariant behaviour respectively. Invariant (default) variables "
+            "do not require a suffix. The message is also emitted when invariant "
+            "variables do have a suffix.",
+        ),
+        "W0111": (
+            "Name %s will become a keyword in Python %s",
+            "assign-to-new-keyword",
+            "Used when assignment will become invalid in future "
+            "Python release due to introducing new keyword.",
+        ),
+    }
+
+    options = (
+        (
+            "good-names",
+            {
+                "default": ("i", "j", "k", "ex", "Run", "_"),
+                "type": "csv",
+                "metavar": "<names>",
+                "help": "Good variable names which should always be accepted,"
+                " separated by a comma.",
+            },
+        ),
+        (
+            "good-names-rgxs",
+            {
+                "default": "",
+                "type": "regexp_csv",
+                "metavar": "<names>",
+                "help": "Good variable names regexes, separated by a comma. If names match any regex,"
+                " they will always be accepted",
+            },
+        ),
+        (
+            "bad-names",
+            {
+                "default": ("foo", "bar", "baz", "toto", "tutu", "tata"),
+                "type": "csv",
+                "metavar": "<names>",
+                "help": "Bad variable names which should always be refused, "
+                "separated by a comma.",
+            },
+        ),
+        (
+            "bad-names-rgxs",
+            {
+                "default": "",
+                "type": "regexp_csv",
+                "metavar": "<names>",
+                "help": "Bad variable names regexes, separated by a comma. If names match any regex,"
+                " they will always be refused",
+            },
+        ),
+        (
+            "name-group",
+            {
+                "default": (),
+                "type": "csv",
+                "metavar": "<name1:name2>",
+                "help": (
+                    "Colon-delimited sets of names that determine each"
+                    " other's naming style when the name regexes"
+                    " allow several styles."
+                ),
+            },
+        ),
+        (
+            "include-naming-hint",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Include a hint for the correct naming format with invalid-name.",
+            },
+        ),
+        (
+            "property-classes",
+            {
+                "default": ("abc.abstractproperty",),
+                "type": "csv",
+                "metavar": "<decorator names>",
+                "help": "List of decorators that produce properties, such as "
+                "abc.abstractproperty. Add to this list to register "
+                "other decorators that produce valid properties. "
+                "These decorators are taken in consideration only for invalid-name.",
+            },
+        ),
+    ) + _create_naming_options()
+
+    KEYWORD_ONSET = {(3, 7): {"async", "await"}}
+
+    def __init__(self, linter):
+        super().__init__(linter)
+        self._name_category = {}
+        self._name_group = {}
+        self._bad_names = {}
+        self._name_regexps = {}
+        self._name_hints = {}
+        self._good_names_rgxs_compiled = []
+        self._bad_names_rgxs_compiled = []
+
+    def open(self):
+        self.linter.stats.reset_bad_names()
+        for group in self.config.name_group:
+            for name_type in group.split(":"):
+                self._name_group[name_type] = f"group_{group}"
+
+        regexps, hints = self._create_naming_rules()
+        self._name_regexps = regexps
+        self._name_hints = hints
+        self._good_names_rgxs_compiled = [
+            re.compile(rgxp) for rgxp in self.config.good_names_rgxs
+        ]
+        self._bad_names_rgxs_compiled = [
+            re.compile(rgxp) for rgxp in self.config.bad_names_rgxs
+        ]
+
+    def _create_naming_rules(self) -> Tuple[Dict[str, Pattern[str]], Dict[str, str]]:
+        regexps: Dict[str, Pattern[str]] = {}
+        hints: Dict[str, str] = {}
+
+        for name_type in KNOWN_NAME_TYPES:
+            if name_type in KNOWN_NAME_TYPES_WITH_STYLE:
+                naming_style_name = getattr(self.config, f"{name_type}_naming_style")
+                regexps[name_type] = NAMING_STYLES[naming_style_name].get_regex(
+                    name_type
+                )
+            else:
+                naming_style_name = "predefined"
+                regexps[name_type] = DEFAULT_PATTERNS[name_type]
+
+            custom_regex_setting_name = f"{name_type}_rgx"
+            custom_regex = getattr(self.config, custom_regex_setting_name, None)
+            if custom_regex is not None:
+                regexps[name_type] = custom_regex
+
+            if custom_regex is not None:
+                hints[name_type] = f"{custom_regex.pattern!r} pattern"
+            else:
+                hints[name_type] = f"{naming_style_name} naming style"
+
+        return regexps, hints
+
+    @utils.check_messages("disallowed-name", "invalid-name")
+    def visit_module(self, node: nodes.Module) -> None:
+        self._check_name("module", node.name.split(".")[-1], node)
+        self._bad_names = {}
+
+    def leave_module(self, _: nodes.Module) -> None:
+        for all_groups in self._bad_names.values():
+            if len(all_groups) < 2:
+                continue
+            groups = collections.defaultdict(list)
+            min_warnings = sys.maxsize
+            prevalent_group, _ = max(all_groups.items(), key=lambda item: len(item[1]))
+            for group in all_groups.values():
+                groups[len(group)].append(group)
+                min_warnings = min(len(group), min_warnings)
+            if len(groups[min_warnings]) > 1:
+                by_line = sorted(
+                    groups[min_warnings],
+                    key=lambda group: min(warning[0].lineno for warning in group),
+                )
+                warnings = itertools.chain(*by_line[1:])
+            else:
+                warnings = groups[min_warnings][0]
+            for args in warnings:
+                self._raise_name_warning(prevalent_group, *args)
+
+    @utils.check_messages("disallowed-name", "invalid-name", "assign-to-new-keyword")
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        self._check_assign_to_new_keyword_violation(node.name, node)
+        self._check_name("class", node.name, node)
+        for attr, anodes in node.instance_attrs.items():
+            if not any(node.instance_attr_ancestors(attr)):
+                self._check_name("attr", attr, anodes[0])
+
+    @utils.check_messages("disallowed-name", "invalid-name", "assign-to-new-keyword")
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        # Do not emit any warnings if the method is just an implementation
+        # of a base class method.
+        self._check_assign_to_new_keyword_violation(node.name, node)
+        confidence = interfaces.HIGH
+        if node.is_method():
+            if utils.overrides_a_method(node.parent.frame(future=True), node.name):
+                return
+            confidence = (
+                interfaces.INFERENCE
+                if utils.has_known_bases(node.parent.frame(future=True))
+                else interfaces.INFERENCE_FAILURE
+            )
+
+        self._check_name(
+            _determine_function_name_type(node, config=self.config),
+            node.name,
+            node,
+            confidence,
+        )
+        # Check argument names
+        args = node.args.args
+        if args is not None:
+            self._recursive_check_names(args)
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    @utils.check_messages("disallowed-name", "invalid-name")
+    def visit_global(self, node: nodes.Global) -> None:
+        for name in node.names:
+            self._check_name("const", name, node)
+
+    @utils.check_messages(
+        "disallowed-name",
+        "invalid-name",
+        "assign-to-new-keyword",
+        "typevar-name-incorrect-variance",
+    )
+    def visit_assignname(self, node: nodes.AssignName) -> None:
+        """Check module level assigned names."""
+        self._check_assign_to_new_keyword_violation(node.name, node)
+        frame = node.frame(future=True)
+        assign_type = node.assign_type()
+
+        # Check names defined in comprehensions
+        if isinstance(assign_type, nodes.Comprehension):
+            self._check_name("inlinevar", node.name, node)
+
+        # Check names defined in module scope
+        elif isinstance(frame, nodes.Module):
+            # Check names defined in Assign nodes
+            if isinstance(assign_type, nodes.Assign):
+                inferred_assign_type = utils.safe_infer(assign_type.value)
+
+                # Check TypeVar's assigned alone or in tuple assignment
+                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
+                    assign_type.value
+                ):
+                    self._check_name("typevar", assign_type.targets[0].name, node)
+                elif (
+                    isinstance(node.parent, nodes.Tuple)
+                    and isinstance(assign_type.value, nodes.Tuple)
+                    # protect against unbalanced tuple unpacking
+                    and node.parent.elts.index(node) < len(assign_type.value.elts)
+                    and self._assigns_typevar(
+                        assign_type.value.elts[node.parent.elts.index(node)]
+                    )
+                ):
+                    self._check_name(
+                        "typevar",
+                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
+                        node,
+                    )
+
+                # Check classes (TypeVar's are classes so they need to be excluded first)
+                elif isinstance(inferred_assign_type, nodes.ClassDef):
+                    self._check_name("class", node.name, node)
+
+                # Don't emit if the name redefines an import in an ImportError except handler.
+                elif not _redefines_import(node) and isinstance(
+                    inferred_assign_type, nodes.Const
+                ):
+                    self._check_name("const", node.name, node)
+            # Check names defined in AnnAssign nodes
+            elif isinstance(
+                assign_type, nodes.AnnAssign
+            ) and utils.is_assign_name_annotated_with(node, "Final"):
+                self._check_name("const", node.name, node)
+
+        # Check names defined in function scopes
+        elif isinstance(frame, nodes.FunctionDef):
+            # global introduced variable aren't in the function locals
+            if node.name in frame and node.name not in frame.argnames():
+                if not _redefines_import(node):
+                    self._check_name("variable", node.name, node)
+
+        # Check names defined in class scopes
+        elif isinstance(frame, nodes.ClassDef):
+            if not list(frame.local_attr_ancestors(node.name)):
+                for ancestor in frame.ancestors():
+                    if (
+                        ancestor.name == "Enum"
+                        and ancestor.root().name == "enum"
+                        or utils.is_assign_name_annotated_with(node, "Final")
+                    ):
+                        self._check_name("class_const", node.name, node)
+                        break
+                else:
+                    self._check_name("class_attribute", node.name, node)
+
+    def _recursive_check_names(self, args):
+        """Check names in a possibly recursive list <arg>."""
+        for arg in args:
+            if isinstance(arg, nodes.AssignName):
+                self._check_name("argument", arg.name, arg)
+            else:
+                self._recursive_check_names(arg.elts)
+
+    def _find_name_group(self, node_type):
+        return self._name_group.get(node_type, node_type)
+
+    def _raise_name_warning(
+        self,
+        prevalent_group: Optional[str],
+        node: nodes.NodeNG,
+        node_type: str,
+        name: str,
+        confidence,
+        warning: str = "invalid-name",
+    ) -> None:
+        type_label = constants.HUMAN_READABLE_TYPES[node_type]
+        hint = self._name_hints[node_type]
+        if prevalent_group:
+            # This happens in the multi naming match case. The expected
+            # prevalent group needs to be spelled out to make the message
+            # correct.
+            hint = f"the `{prevalent_group}` group in the {hint}"
+        if self.config.include_naming_hint:
+            hint += f" ({self._name_regexps[node_type].pattern!r} pattern)"
+        args = (
+            (type_label.capitalize(), name, hint)
+            if warning == "invalid-name"
+            else (type_label.capitalize(), name)
+        )
+
+        self.add_message(warning, node=node, args=args, confidence=confidence)
+        self.linter.stats.increase_bad_name(node_type, 1)
+
+    def _name_allowed_by_regex(self, name: str) -> bool:
+        return name in self.config.good_names or any(
+            pattern.match(name) for pattern in self._good_names_rgxs_compiled
+        )
+
+    def _name_disallowed_by_regex(self, name: str) -> bool:
+        return name in self.config.bad_names or any(
+            pattern.match(name) for pattern in self._bad_names_rgxs_compiled
+        )
+
+    def _check_name(self, node_type, name, node, confidence=interfaces.HIGH):
+        """Check for a name using the type's regexp."""
+
+        def _should_exempt_from_invalid_name(node):
+            if node_type == "variable":
+                inferred = utils.safe_infer(node)
+                if isinstance(inferred, nodes.ClassDef):
+                    return True
+            return False
+
+        if self._name_allowed_by_regex(name=name):
+            return
+        if self._name_disallowed_by_regex(name=name):
+            self.linter.stats.increase_bad_name(node_type, 1)
+            self.add_message("disallowed-name", node=node, args=name)
+            return
+        regexp = self._name_regexps[node_type]
+        match = regexp.match(name)
+
+        if _is_multi_naming_match(match, node_type, confidence):
+            name_group = self._find_name_group(node_type)
+            bad_name_group = self._bad_names.setdefault(name_group, {})
+            warnings = bad_name_group.setdefault(match.lastgroup, [])
+            warnings.append((node, node_type, name, confidence))
+
+        if match is None and not _should_exempt_from_invalid_name(node):
+            self._raise_name_warning(None, node, node_type, name, confidence)
+
+        # Check TypeVar names for variance suffixes
+        if node_type == "typevar":
+            self._check_typevar_variance(name, node)
+
+    def _check_assign_to_new_keyword_violation(self, name, node):
+        keyword_first_version = self._name_became_keyword_in_version(
+            name, self.KEYWORD_ONSET
+        )
+        if keyword_first_version is not None:
+            self.add_message(
+                "assign-to-new-keyword",
+                node=node,
+                args=(name, keyword_first_version),
+                confidence=interfaces.HIGH,
+            )
+
+    @staticmethod
+    def _name_became_keyword_in_version(name, rules):
+        for version, keywords in rules.items():
+            if name in keywords and sys.version_info < version:
+                return ".".join(str(v) for v in version)
+        return None
+
+    @staticmethod
+    def _assigns_typevar(node: Optional[nodes.NodeNG]) -> bool:
+        """Check if a node is assigning a TypeVar."""
+        if isinstance(node, astroid.Call):
+            inferred = utils.safe_infer(node.func)
+            if (
+                isinstance(inferred, astroid.ClassDef)
+                and inferred.qname() == TYPING_TYPE_VAR_QNAME
+            ):
+                return True
+        return False
+
+    def _check_typevar_variance(self, name: str, node: nodes.AssignName) -> None:
+        """Check if a TypeVar has a variance and if it's included in the name.
+
+        Returns the args for the message to be displayed.
+        """
+        if isinstance(node.parent, nodes.Assign):
+            keywords = node.assign_type().value.keywords
+        elif isinstance(node.parent, nodes.Tuple):
+            keywords = (
+                node.assign_type().value.elts[node.parent.elts.index(node)].keywords
+            )
+
+        for kw in keywords:
+            if kw.arg == "covariant" and kw.value.value:
+                if not name.endswith("_co"):
+                    suggest_name = f"{re.sub('_contra$', '', name)}_co"
+                    self.add_message(
+                        "typevar-name-incorrect-variance",
+                        node=node,
+                        args=(name, "covariant", suggest_name),
+                        confidence=interfaces.INFERENCE,
+                    )
+                return
+
+            if kw.arg == "contravariant" and kw.value.value:
+                if not name.endswith("_contra"):
+                    suggest_name = f"{re.sub('_co$', '', name)}_contra"
+                    self.add_message(
+                        "typevar-name-incorrect-variance",
+                        node=node,
+                        args=(name, "contravariant", suggest_name),
+                        confidence=interfaces.INFERENCE,
+                    )
+                return
+
+        if name.endswith("_co") or name.endswith("_contra"):
+            suggest_name = re.sub("_contra$|_co$", "", name)
+            self.add_message(
+                "typevar-name-incorrect-variance",
+                node=node,
+                args=(name, "invariant", suggest_name),
+                confidence=interfaces.INFERENCE,
+            )
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/base/name_checker/naming_style.py b/myenv/lib/python3.9/site-packages/pylint/checkers/base/name_checker/naming_style.py
new file mode 100644
index 0000000..98bdaf7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/base/name_checker/naming_style.py
@@ -0,0 +1,175 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import re
+from typing import Pattern
+
+from pylint import constants
+
+
+class NamingStyle:
+    """It may seem counterintuitive that single naming style has multiple "accepted"
+    forms of regular expressions, but we need to special-case stuff like dunder names in method names.
+    """
+
+    ANY: Pattern[str] = re.compile(".*")
+    CLASS_NAME_RGX: Pattern[str] = ANY
+    MOD_NAME_RGX: Pattern[str] = ANY
+    CONST_NAME_RGX: Pattern[str] = ANY
+    COMP_VAR_RGX: Pattern[str] = ANY
+    DEFAULT_NAME_RGX: Pattern[str] = ANY
+    CLASS_ATTRIBUTE_RGX: Pattern[str] = ANY
+
+    @classmethod
+    def get_regex(cls, name_type):
+        return {
+            "module": cls.MOD_NAME_RGX,
+            "const": cls.CONST_NAME_RGX,
+            "class": cls.CLASS_NAME_RGX,
+            "function": cls.DEFAULT_NAME_RGX,
+            "method": cls.DEFAULT_NAME_RGX,
+            "attr": cls.DEFAULT_NAME_RGX,
+            "argument": cls.DEFAULT_NAME_RGX,
+            "variable": cls.DEFAULT_NAME_RGX,
+            "class_attribute": cls.CLASS_ATTRIBUTE_RGX,
+            "class_const": cls.CONST_NAME_RGX,
+            "inlinevar": cls.COMP_VAR_RGX,
+        }[name_type]
+
+
+class SnakeCaseStyle(NamingStyle):
+    """Regex rules for snake_case naming style."""
+
+    CLASS_NAME_RGX = re.compile(r"[^\W\dA-Z][^\WA-Z]+$")
+    MOD_NAME_RGX = re.compile(r"[^\W\dA-Z][^\WA-Z]*$")
+    CONST_NAME_RGX = re.compile(r"([^\W\dA-Z][^\WA-Z]*|__.*__)$")
+    COMP_VAR_RGX = re.compile(r"[^\W\dA-Z][^\WA-Z]*$")
+    DEFAULT_NAME_RGX = re.compile(
+        r"([^\W\dA-Z][^\WA-Z]{2,}|_[^\WA-Z]*|__[^\WA-Z\d_][^\WA-Z]+__)$"
+    )
+    CLASS_ATTRIBUTE_RGX = re.compile(r"([^\W\dA-Z][^\WA-Z]{2,}|__.*__)$")
+
+
+class CamelCaseStyle(NamingStyle):
+    """Regex rules for camelCase naming style."""
+
+    CLASS_NAME_RGX = re.compile(r"[^\W\dA-Z][^\W_]+$")
+    MOD_NAME_RGX = re.compile(r"[^\W\dA-Z][^\W_]*$")
+    CONST_NAME_RGX = re.compile(r"([^\W\dA-Z][^\W_]*|__.*__)$")
+    COMP_VAR_RGX = re.compile(r"[^\W\dA-Z][^\W_]*$")
+    DEFAULT_NAME_RGX = re.compile(r"([^\W\dA-Z][^\W_]{2,}|__[^\W\dA-Z_]\w+__)$")
+    CLASS_ATTRIBUTE_RGX = re.compile(r"([^\W\dA-Z][^\W_]{2,}|__.*__)$")
+
+
+class PascalCaseStyle(NamingStyle):
+    """Regex rules for PascalCase naming style."""
+
+    CLASS_NAME_RGX = re.compile(r"[^\W\da-z][^\W_]+$")
+    MOD_NAME_RGX = re.compile(r"[^\W\da-z][^\W_]+$")
+    CONST_NAME_RGX = re.compile(r"([^\W\da-z][^\W_]*|__.*__)$")
+    COMP_VAR_RGX = re.compile(r"[^\W\da-z][^\W_]+$")
+    DEFAULT_NAME_RGX = re.compile(r"([^\W\da-z][^\W_]{2,}|__[^\W\dA-Z_]\w+__)$")
+    CLASS_ATTRIBUTE_RGX = re.compile(r"[^\W\da-z][^\W_]{2,}$")
+
+
+class UpperCaseStyle(NamingStyle):
+    """Regex rules for UPPER_CASE naming style."""
+
+    CLASS_NAME_RGX = re.compile(r"[^\W\da-z][^\Wa-z]+$")
+    MOD_NAME_RGX = re.compile(r"[^\W\da-z][^\Wa-z]+$")
+    CONST_NAME_RGX = re.compile(r"([^\W\da-z][^\Wa-z]*|__.*__)$")
+    COMP_VAR_RGX = re.compile(r"[^\W\da-z][^\Wa-z]+$")
+    DEFAULT_NAME_RGX = re.compile(r"([^\W\da-z][^\Wa-z]{2,}|__[^\W\dA-Z_]\w+__)$")
+    CLASS_ATTRIBUTE_RGX = re.compile(r"[^\W\da-z][^\Wa-z]{2,}$")
+
+
+class AnyStyle(NamingStyle):
+    pass
+
+
+NAMING_STYLES = {
+    "snake_case": SnakeCaseStyle,
+    "camelCase": CamelCaseStyle,
+    "PascalCase": PascalCaseStyle,
+    "UPPER_CASE": UpperCaseStyle,
+    "any": AnyStyle,
+}
+
+# Name types that have a style option
+KNOWN_NAME_TYPES_WITH_STYLE = {
+    "module",
+    "const",
+    "class",
+    "function",
+    "method",
+    "attr",
+    "argument",
+    "variable",
+    "class_attribute",
+    "class_const",
+    "inlinevar",
+}
+
+
+DEFAULT_NAMING_STYLES = {
+    "module": "snake_case",
+    "const": "UPPER_CASE",
+    "class": "PascalCase",
+    "function": "snake_case",
+    "method": "snake_case",
+    "attr": "snake_case",
+    "argument": "snake_case",
+    "variable": "snake_case",
+    "class_attribute": "any",
+    "class_const": "UPPER_CASE",
+    "inlinevar": "any",
+}
+
+
+# Name types that have a 'rgx' option
+KNOWN_NAME_TYPES = {
+    *KNOWN_NAME_TYPES_WITH_STYLE,
+    "typevar",
+}
+
+
+def _create_naming_options():
+    name_options = []
+    for name_type in sorted(KNOWN_NAME_TYPES):
+        human_readable_name = constants.HUMAN_READABLE_TYPES[name_type]
+        name_type_hyphened = name_type.replace("_", "-")
+
+        help_msg = f"Regular expression matching correct {human_readable_name} names. "
+        if name_type in KNOWN_NAME_TYPES_WITH_STYLE:
+            help_msg += f"Overrides {name_type_hyphened}-naming-style. "
+        help_msg += f"If left empty, {human_readable_name} names will be checked with the set naming style."
+
+        # Add style option for names that support it
+        if name_type in KNOWN_NAME_TYPES_WITH_STYLE:
+            default_style = DEFAULT_NAMING_STYLES[name_type]
+            name_options.append(
+                (
+                    f"{name_type_hyphened}-naming-style",
+                    {
+                        "default": default_style,
+                        "type": "choice",
+                        "choices": list(NAMING_STYLES.keys()),
+                        "metavar": "<style>",
+                        "help": f"Naming style matching correct {human_readable_name} names.",
+                    },
+                )
+            )
+
+        name_options.append(
+            (
+                f"{name_type_hyphened}-rgx",
+                {
+                    "default": None,
+                    "type": "regexp",
+                    "metavar": "<regexp>",
+                    "help": help_msg,
+                },
+            )
+        )
+    return tuple(name_options)
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/base/pass_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/base/pass_checker.py
new file mode 100644
index 0000000..26b915b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/base/pass_checker.py
@@ -0,0 +1,28 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from astroid import nodes
+
+from pylint.checkers import utils
+from pylint.checkers.base.basic_checker import _BasicChecker
+
+
+class PassChecker(_BasicChecker):
+    """Check if the pass statement is really necessary."""
+
+    msgs = {
+        "W0107": (
+            "Unnecessary pass statement",
+            "unnecessary-pass",
+            'Used when a "pass" statement that can be avoided is encountered.',
+        )
+    }
+
+    @utils.check_messages("unnecessary-pass")
+    def visit_pass(self, node: nodes.Pass) -> None:
+        if len(node.parent.child_sequence(node)) > 1 or (
+            isinstance(node.parent, (nodes.ClassDef, nodes.FunctionDef))
+            and node.parent.doc_node
+        ):
+            self.add_message("unnecessary-pass", node=node)
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/base_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/base_checker.py
new file mode 100644
index 0000000..1cdc014
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/base_checker.py
@@ -0,0 +1,190 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import functools
+from inspect import cleandoc
+from typing import Any, Optional
+
+from astroid import nodes
+
+from pylint.config import OptionsProviderMixIn
+from pylint.constants import _MSG_ORDER, WarningScope
+from pylint.exceptions import InvalidMessageError
+from pylint.interfaces import Confidence, IRawChecker, ITokenChecker, implements
+from pylint.message.message_definition import MessageDefinition
+from pylint.utils import get_rst_section, get_rst_title
+
+
+@functools.total_ordering
+class BaseChecker(OptionsProviderMixIn):
+
+    # checker name (you may reuse an existing one)
+    name: str = ""
+    # options level (0 will be displaying in --help, 1 in --long-help)
+    level = 1
+    # ordered list of options to control the checker behaviour
+    options: Any = ()
+    # messages issued by this checker
+    msgs: Any = {}
+    # reports issued by this checker
+    reports: Any = ()
+    # mark this checker as enabled or not.
+    enabled: bool = True
+
+    def __init__(self, linter=None):
+        """Checker instances should have the linter as argument.
+
+        :param ILinter linter: is an object implementing ILinter.
+        """
+        if self.name is not None:
+            self.name = self.name.lower()
+        super().__init__()
+        self.linter = linter
+
+    def __gt__(self, other):
+        """Permit to sort a list of Checker by name."""
+        return f"{self.name}{self.msgs}".__gt__(f"{other.name}{other.msgs}")
+
+    def __repr__(self):
+        status = "Checker" if self.enabled else "Disabled checker"
+        msgs = "', '".join(self.msgs.keys())
+        return f"{status} '{self.name}' (responsible for '{msgs}')"
+
+    def __str__(self):
+        """This might be incomplete because multiple classes inheriting BaseChecker
+        can have the same name.
+
+        See: MessageHandlerMixIn.get_full_documentation()
+        """
+        return self.get_full_documentation(
+            msgs=self.msgs, options=self.options_and_values(), reports=self.reports
+        )
+
+    def get_full_documentation(self, msgs, options, reports, doc=None, module=None):
+        result = ""
+        checker_title = f"{self.name.replace('_', ' ').title()} checker"
+        if module:
+            # Provide anchor to link against
+            result += f".. _{module}:\n\n"
+        result += f"{get_rst_title(checker_title, '~')}\n"
+        if module:
+            result += f"This checker is provided by ``{module}``.\n"
+        result += f"Verbatim name of the checker is ``{self.name}``.\n\n"
+        if doc:
+            # Provide anchor to link against
+            result += get_rst_title(f"{checker_title} Documentation", "^")
+            result += f"{cleandoc(doc)}\n\n"
+        # options might be an empty generator and not be False when cast to boolean
+        options = list(options)
+        if options:
+            result += get_rst_title(f"{checker_title} Options", "^")
+            result += f"{get_rst_section(None, options)}\n"
+        if msgs:
+            result += get_rst_title(f"{checker_title} Messages", "^")
+            for msgid, msg in sorted(
+                msgs.items(), key=lambda kv: (_MSG_ORDER.index(kv[0][0]), kv[1])
+            ):
+                msg = self.create_message_definition_from_tuple(msgid, msg)
+                result += f"{msg.format_help(checkerref=False)}\n"
+            result += "\n"
+        if reports:
+            result += get_rst_title(f"{checker_title} Reports", "^")
+            for report in reports:
+                result += (
+                    ":%s: %s\n" % report[:2]  # pylint: disable=consider-using-f-string
+                )
+            result += "\n"
+        result += "\n"
+        return result
+
+    def add_message(
+        self,
+        msgid: str,
+        line: Optional[int] = None,
+        node: Optional[nodes.NodeNG] = None,
+        args: Any = None,
+        confidence: Optional[Confidence] = None,
+        col_offset: Optional[int] = None,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        self.linter.add_message(
+            msgid, line, node, args, confidence, col_offset, end_lineno, end_col_offset
+        )
+
+    def check_consistency(self):
+        """Check the consistency of msgid.
+
+        msg ids for a checker should be a string of len 4, where the two first
+        characters are the checker id and the two last the msg id in this
+        checker.
+
+        :raises InvalidMessageError: If the checker id in the messages are not
+        always the same.
+        """
+        checker_id = None
+        existing_ids = []
+        for message in self.messages:
+            if checker_id is not None and checker_id != message.msgid[1:3]:
+                error_msg = "Inconsistent checker part in message id "
+                error_msg += f"'{message.msgid}' (expected 'x{checker_id}xx' "
+                error_msg += f"because we already had {existing_ids})."
+                raise InvalidMessageError(error_msg)
+            checker_id = message.msgid[1:3]
+            existing_ids.append(message.msgid)
+
+    def create_message_definition_from_tuple(self, msgid, msg_tuple):
+        if implements(self, (IRawChecker, ITokenChecker)):
+            default_scope = WarningScope.LINE
+        else:
+            default_scope = WarningScope.NODE
+        options = {}
+        if len(msg_tuple) > 3:
+            (msg, symbol, descr, options) = msg_tuple
+        elif len(msg_tuple) > 2:
+            (msg, symbol, descr) = msg_tuple
+        else:
+            error_msg = """Messages should have a msgid and a symbol. Something like this :
+
+"W1234": (
+    "message",
+    "message-symbol",
+    "Message description with detail.",
+    ...
+),
+"""
+            raise InvalidMessageError(error_msg)
+        options.setdefault("scope", default_scope)
+        return MessageDefinition(self, msgid, msg, descr, symbol, **options)
+
+    @property
+    def messages(self) -> list:
+        return [
+            self.create_message_definition_from_tuple(msgid, msg_tuple)
+            for msgid, msg_tuple in sorted(self.msgs.items())
+        ]
+
+    # dummy methods implementing the IChecker interface
+
+    def get_message_definition(self, msgid):
+        for message_definition in self.messages:
+            if message_definition.msgid == msgid:
+                return message_definition
+        error_msg = f"MessageDefinition for '{msgid}' does not exists. "
+        error_msg += f"Choose from {[m.msgid for m in self.messages]}."
+        raise InvalidMessageError(error_msg)
+
+    def open(self):
+        """Called before visiting project (i.e. set of modules)."""
+
+    def close(self):
+        """Called after visiting project (i.e set of modules)."""
+
+
+class BaseTokenChecker(BaseChecker):
+    """Base class for checkers that want to have access to the token stream."""
+
+    def process_tokens(self, tokens):
+        """Should be overridden by subclasses."""
+        raise NotImplementedError()
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/classes/__init__.py b/myenv/lib/python3.9/site-packages/pylint/checkers/classes/__init__.py
new file mode 100644
index 0000000..5e9bc5a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/classes/__init__.py
@@ -0,0 +1,16 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import TYPE_CHECKING
+
+from pylint.checkers.classes.class_checker import ClassChecker
+from pylint.checkers.classes.special_methods_checker import SpecialMethodsChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(ClassChecker(linter))
+    linter.register_checker(SpecialMethodsChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/classes/class_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/classes/class_checker.py
new file mode 100644
index 0000000..fba2b6a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/classes/class_checker.py
@@ -0,0 +1,2151 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Classes checker for Python code."""
+import collections
+import sys
+from itertools import chain, zip_longest
+from typing import Dict, List, Pattern, Set
+
+import astroid
+from astroid import bases, nodes
+
+from pylint.checkers import BaseChecker, utils
+from pylint.checkers.utils import (
+    PYMETHODS,
+    check_messages,
+    class_is_abstract,
+    decorated_with,
+    decorated_with_property,
+    get_outer_class,
+    has_known_bases,
+    is_attr_private,
+    is_attr_protected,
+    is_builtin_object,
+    is_comprehension,
+    is_iterable,
+    is_overload_stub,
+    is_property_setter,
+    is_property_setter_or_deleter,
+    is_protocol_class,
+    node_frame_class,
+    overrides_a_method,
+    safe_infer,
+    unimplemented_abstract_methods,
+    uninferable_final_decorators,
+)
+from pylint.interfaces import INFERENCE, IAstroidChecker
+from pylint.utils import get_global_option
+
+if sys.version_info >= (3, 8):
+    from functools import cached_property
+else:
+    from astroid.decorators import cachedproperty as cached_property
+
+INVALID_BASE_CLASSES = {"bool", "range", "slice", "memoryview"}
+BUILTIN_DECORATORS = {"builtins.property", "builtins.classmethod"}
+ASTROID_TYPE_COMPARATORS = {
+    nodes.Const: lambda a, b: a.value == b.value,
+    nodes.ClassDef: lambda a, b: a.qname == b.qname,
+    nodes.Tuple: lambda a, b: a.elts == b.elts,
+    nodes.List: lambda a, b: a.elts == b.elts,
+    nodes.Dict: lambda a, b: a.items == b.items,
+    nodes.Name: lambda a, b: set(a.infer()) == set(b.infer()),
+}
+
+# Dealing with useless override detection, with regard
+# to parameters vs arguments
+
+_CallSignature = collections.namedtuple(
+    "_CallSignature", "args kws starred_args starred_kws"
+)
+_ParameterSignature = collections.namedtuple(
+    "_ParameterSignature", "args kwonlyargs varargs kwargs"
+)
+
+
+def _signature_from_call(call):
+    kws = {}
+    args = []
+    starred_kws = []
+    starred_args = []
+    for keyword in call.keywords or []:
+        arg, value = keyword.arg, keyword.value
+        if arg is None and isinstance(value, nodes.Name):
+            # Starred node and we are interested only in names,
+            # otherwise some transformation might occur for the parameter.
+            starred_kws.append(value.name)
+        elif isinstance(value, nodes.Name):
+            kws[arg] = value.name
+        else:
+            kws[arg] = None
+
+    for arg in call.args:
+        if isinstance(arg, nodes.Starred) and isinstance(arg.value, nodes.Name):
+            # Positional variadic and a name, otherwise some transformation
+            # might have occurred.
+            starred_args.append(arg.value.name)
+        elif isinstance(arg, nodes.Name):
+            args.append(arg.name)
+        else:
+            args.append(None)
+
+    return _CallSignature(args, kws, starred_args, starred_kws)
+
+
+def _signature_from_arguments(arguments):
+    kwarg = arguments.kwarg
+    vararg = arguments.vararg
+    args = [
+        arg.name
+        for arg in chain(arguments.posonlyargs, arguments.args)
+        if arg.name != "self"
+    ]
+    kwonlyargs = [arg.name for arg in arguments.kwonlyargs]
+    return _ParameterSignature(args, kwonlyargs, vararg, kwarg)
+
+
+def _definition_equivalent_to_call(definition, call):
+    """Check if a definition signature is equivalent to a call."""
+    if definition.kwargs:
+        if definition.kwargs not in call.starred_kws:
+            return False
+    elif call.starred_kws:
+        return False
+    if definition.varargs:
+        if definition.varargs not in call.starred_args:
+            return False
+    elif call.starred_args:
+        return False
+    if any(kw not in call.kws for kw in definition.kwonlyargs):
+        return False
+    if definition.args != call.args:
+        return False
+
+    # No extra kwargs in call.
+    return all(kw in call.args or kw in definition.kwonlyargs for kw in call.kws)
+
+
+# Deal with parameters overriding in two methods.
+
+
+def _positional_parameters(method):
+    positional = method.args.args
+    if method.is_bound() and method.type in {"classmethod", "method"}:
+        positional = positional[1:]
+    return positional
+
+
+class _DefaultMissing:
+    """Sentinel value for missing arg default, use _DEFAULT_MISSING."""
+
+
+_DEFAULT_MISSING = _DefaultMissing()
+
+
+def _has_different_parameters_default_value(original, overridden):
+    """Check if original and overridden methods arguments have different default values.
+
+    Return True if one of the overridden arguments has a default
+    value different from the default value of the original argument
+    If one of the method doesn't have argument (.args is None)
+    return False
+    """
+    if original.args is None or overridden.args is None:
+        return False
+
+    for param in chain(original.args, original.kwonlyargs):
+        try:
+            original_default = original.default_value(param.name)
+        except astroid.exceptions.NoDefault:
+            original_default = _DEFAULT_MISSING
+        try:
+            overridden_default = overridden.default_value(param.name)
+            if original_default is _DEFAULT_MISSING:
+                # Only the original has a default.
+                return True
+        except astroid.exceptions.NoDefault:
+            if original_default is _DEFAULT_MISSING:
+                # Both have a default, no difference
+                continue
+            # Only the override has a default.
+            return True
+
+        original_type = type(original_default)
+        if not isinstance(overridden_default, original_type):
+            # Two args with same name but different types
+            return True
+        is_same_fn = ASTROID_TYPE_COMPARATORS.get(original_type)
+        if is_same_fn is None:
+            # If the default value comparison is unhandled, assume the value is different
+            return True
+        if not is_same_fn(original_default, overridden_default):
+            # Two args with same type but different values
+            return True
+    return False
+
+
+def _has_different_parameters(
+    original: List[nodes.AssignName],
+    overridden: List[nodes.AssignName],
+    dummy_parameter_regex: Pattern,
+) -> List[str]:
+    result: List[str] = []
+    zipped = zip_longest(original, overridden)
+    for original_param, overridden_param in zipped:
+        if not overridden_param:
+            return ["Number of parameters "]
+
+        if not original_param:
+            try:
+                overridden_param.parent.default_value(overridden_param.name)
+                continue
+            except astroid.NoDefault:
+                return ["Number of parameters "]
+
+        # check for the arguments' name
+        names = [param.name for param in (original_param, overridden_param)]
+        if any(dummy_parameter_regex.match(name) for name in names):
+            continue
+        if original_param.name != overridden_param.name:
+            result.append(
+                f"Parameter '{original_param.name}' has been renamed "
+                f"to '{overridden_param.name}' in"
+            )
+
+    return result
+
+
+def _has_different_keyword_only_parameters(
+    original: List[nodes.AssignName],
+    overridden: List[nodes.AssignName],
+) -> List[str]:
+    """Determine if the two methods have different keyword only parameters."""
+    original_names = [i.name for i in original]
+    overridden_names = [i.name for i in overridden]
+
+    if any(name not in overridden_names for name in original_names):
+        return ["Number of parameters "]
+
+    for name in overridden_names:
+        if name in original_names:
+            continue
+
+        try:
+            overridden[0].parent.default_value(name)
+        except astroid.NoDefault:
+            return ["Number of parameters "]
+
+    return []
+
+
+def _different_parameters(
+    original: nodes.FunctionDef,
+    overridden: nodes.FunctionDef,
+    dummy_parameter_regex: Pattern,
+) -> List[str]:
+    """Determine if the two methods have different parameters.
+
+    They are considered to have different parameters if:
+
+       * they have different positional parameters, including different names
+
+       * one of the methods is having variadics, while the other is not
+
+       * they have different keyword only parameters.
+
+    """
+    output_messages = []
+    original_parameters = _positional_parameters(original)
+    overridden_parameters = _positional_parameters(overridden)
+
+    # Copy kwonlyargs list so that we don't affect later function linting
+    original_kwonlyargs = original.args.kwonlyargs
+
+    # Allow positional/keyword variadic in overridden to match against any
+    # positional/keyword argument in original.
+    # Keep any arguments that are found separately in overridden to satisfy
+    # later tests
+    if overridden.args.vararg:
+        overridden_names = [v.name for v in overridden_parameters]
+        original_parameters = [
+            v for v in original_parameters if v.name in overridden_names
+        ]
+
+    if overridden.args.kwarg:
+        overridden_names = [v.name for v in overridden.args.kwonlyargs]
+        original_kwonlyargs = [
+            v for v in original.args.kwonlyargs if v.name in overridden_names
+        ]
+
+    different_positional = _has_different_parameters(
+        original_parameters, overridden_parameters, dummy_parameter_regex
+    )
+    different_kwonly = _has_different_keyword_only_parameters(
+        original_kwonlyargs, overridden.args.kwonlyargs
+    )
+    if different_kwonly and different_positional:
+        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
+            output_messages.append("Number of parameters ")
+            output_messages += different_positional[1:]
+            output_messages += different_kwonly[1:]
+        else:
+            output_messages += different_positional
+            output_messages += different_kwonly
+    else:
+        if different_positional:
+            output_messages += different_positional
+        if different_kwonly:
+            output_messages += different_kwonly
+
+    if original.name in PYMETHODS:
+        # Ignore the difference for special methods. If the parameter
+        # numbers are different, then that is going to be caught by
+        # unexpected-special-method-signature.
+        # If the names are different, it doesn't matter, since they can't
+        # be used as keyword arguments anyway.
+        output_messages.clear()
+
+    # Arguments will only violate LSP if there are variadics in the original
+    # that are then removed from the overridden
+    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
+    vararg_lost = original.args.vararg and not overridden.args.vararg
+
+    if kwarg_lost or vararg_lost:
+        output_messages += ["Variadics removed in"]
+
+    return output_messages
+
+
+def _is_invalid_base_class(cls):
+    return cls.name in INVALID_BASE_CLASSES and is_builtin_object(cls)
+
+
+def _has_data_descriptor(cls, attr):
+    attributes = cls.getattr(attr)
+    for attribute in attributes:
+        try:
+            for inferred in attribute.infer():
+                if isinstance(inferred, astroid.Instance):
+                    try:
+                        inferred.getattr("__get__")
+                        inferred.getattr("__set__")
+                    except astroid.NotFoundError:
+                        continue
+                    else:
+                        return True
+        except astroid.InferenceError:
+            # Can't infer, avoid emitting a false positive in this case.
+            return True
+    return False
+
+
+def _called_in_methods(func, klass, methods):
+    """Check if the func was called in any of the given methods,
+    belonging to the *klass*.
+
+    Returns True if so, False otherwise.
+    """
+    if not isinstance(func, nodes.FunctionDef):
+        return False
+    for method in methods:
+        try:
+            inferred = klass.getattr(method)
+        except astroid.NotFoundError:
+            continue
+        for infer_method in inferred:
+            for call in infer_method.nodes_of_class(nodes.Call):
+                try:
+                    bound = next(call.func.infer())
+                except (astroid.InferenceError, StopIteration):
+                    continue
+                if not isinstance(bound, astroid.BoundMethod):
+                    continue
+                func_obj = bound._proxied
+                if isinstance(func_obj, astroid.UnboundMethod):
+                    func_obj = func_obj._proxied
+                if func_obj.name == func.name:
+                    return True
+    return False
+
+
+def _is_attribute_property(name, klass):
+    """Check if the given attribute *name* is a property in the given *klass*.
+
+    It will look for `property` calls or for functions
+    with the given name, decorated by `property` or `property`
+    subclasses.
+    Returns ``True`` if the name is a property in the given klass,
+    ``False`` otherwise.
+    """
+
+    try:
+        attributes = klass.getattr(name)
+    except astroid.NotFoundError:
+        return False
+    property_name = "builtins.property"
+    for attr in attributes:
+        if attr is astroid.Uninferable:
+            continue
+        try:
+            inferred = next(attr.infer())
+        except astroid.InferenceError:
+            continue
+        if isinstance(inferred, nodes.FunctionDef) and decorated_with_property(
+            inferred
+        ):
+            return True
+        if inferred.pytype() != property_name:
+            continue
+
+        cls = node_frame_class(inferred)
+        if cls == klass.declared_metaclass():
+            continue
+        return True
+    return False
+
+
+def _has_bare_super_call(fundef_node):
+    for call in fundef_node.nodes_of_class(nodes.Call):
+        func = call.func
+        if isinstance(func, nodes.Name) and func.name == "super" and not call.args:
+            return True
+    return False
+
+
+def _has_same_layout_slots(slots, assigned_value):
+    inferred = next(assigned_value.infer())
+    if isinstance(inferred, nodes.ClassDef):
+        other_slots = inferred.slots()
+        if all(
+            first_slot and second_slot and first_slot.value == second_slot.value
+            for (first_slot, second_slot) in zip_longest(slots, other_slots)
+        ):
+            return True
+    return False
+
+
+MSGS = {  # pylint: disable=consider-using-namedtuple-or-dataclass
+    "F0202": (
+        "Unable to check methods signature (%s / %s)",
+        "method-check-failed",
+        "Used when Pylint has been unable to check methods signature "
+        "compatibility for an unexpected reason. Please report this kind "
+        "if you don't make sense of it.",
+    ),
+    "E0202": (
+        "An attribute defined in %s line %s hides this method",
+        "method-hidden",
+        "Used when a class defines a method which is hidden by an "
+        "instance attribute from an ancestor class or set by some "
+        "client code.",
+    ),
+    "E0203": (
+        "Access to member %r before its definition line %s",
+        "access-member-before-definition",
+        "Used when an instance member is accessed before it's actually assigned.",
+    ),
+    "W0201": (
+        "Attribute %r defined outside __init__",
+        "attribute-defined-outside-init",
+        "Used when an instance attribute is defined outside the __init__ method.",
+    ),
+    "W0212": (
+        "Access to a protected member %s of a client class",  # E0214
+        "protected-access",
+        "Used when a protected member (i.e. class member with a name "
+        "beginning with an underscore) is access outside the class or a "
+        "descendant of the class where it's defined.",
+    ),
+    "E0211": (
+        "Method has no argument",
+        "no-method-argument",
+        "Used when a method which should have the bound instance as "
+        "first argument has no argument defined.",
+    ),
+    "E0213": (
+        'Method should have "self" as first argument',
+        "no-self-argument",
+        'Used when a method has an attribute different the "self" as '
+        "first argument. This is considered as an error since this is "
+        "a so common convention that you shouldn't break it!",
+    ),
+    "C0202": (
+        "Class method %s should have %s as first argument",
+        "bad-classmethod-argument",
+        "Used when a class method has a first argument named differently "
+        "than the value specified in valid-classmethod-first-arg option "
+        '(default to "cls"), recommended to easily differentiate them '
+        "from regular instance methods.",
+    ),
+    "C0203": (
+        "Metaclass method %s should have %s as first argument",
+        "bad-mcs-method-argument",
+        "Used when a metaclass method has a first argument named "
+        "differently than the value specified in valid-classmethod-first"
+        '-arg option (default to "cls"), recommended to easily '
+        "differentiate them from regular instance methods.",
+    ),
+    "C0204": (
+        "Metaclass class method %s should have %s as first argument",
+        "bad-mcs-classmethod-argument",
+        "Used when a metaclass class method has a first argument named "
+        "differently than the value specified in valid-metaclass-"
+        'classmethod-first-arg option (default to "mcs"), recommended to '
+        "easily differentiate them from regular instance methods.",
+    ),
+    "W0211": (
+        "Static method with %r as first argument",
+        "bad-staticmethod-argument",
+        'Used when a static method has "self" or a value specified in '
+        "valid-classmethod-first-arg option or "
+        "valid-metaclass-classmethod-first-arg option as first argument.",
+    ),
+    "R0201": (
+        "Method could be a function",
+        "no-self-use",
+        "Used when a method doesn't use its bound instance, and so could "
+        "be written as a function.",
+    ),
+    "W0221": (
+        "%s %s %r method",
+        "arguments-differ",
+        "Used when a method has a different number of arguments than in "
+        "the implemented interface or in an overridden method. Extra arguments "
+        "with default values are ignored.",
+    ),
+    "W0222": (
+        "Signature differs from %s %r method",
+        "signature-differs",
+        "Used when a method signature is different than in the "
+        "implemented interface or in an overridden method.",
+    ),
+    "W0223": (
+        "Method %r is abstract in class %r but is not overridden",
+        "abstract-method",
+        "Used when an abstract method (i.e. raise NotImplementedError) is "
+        "not overridden in concrete class.",
+    ),
+    "W0231": (
+        "__init__ method from base class %r is not called",
+        "super-init-not-called",
+        "Used when an ancestor class method has an __init__ method "
+        "which is not called by a derived class.",
+    ),
+    "W0232": (
+        "Class has no __init__ method",
+        "no-init",
+        "Used when a class has no __init__ method, neither its parent classes.",
+    ),
+    "W0233": (
+        "__init__ method from a non direct base class %r is called",
+        "non-parent-init-called",
+        "Used when an __init__ method is called on a class which is not "
+        "in the direct ancestors for the analysed class.",
+    ),
+    "W0235": (
+        "Useless super delegation in method %r",
+        "useless-super-delegation",
+        "Used whenever we can detect that an overridden method is useless, "
+        "relying on super() delegation to do the same thing as another method "
+        "from the MRO.",
+    ),
+    "W0236": (
+        "Method %r was expected to be %r, found it instead as %r",
+        "invalid-overridden-method",
+        "Used when we detect that a method was overridden in a way "
+        "that does not match its base class "
+        "which could result in potential bugs at runtime.",
+    ),
+    "W0237": (
+        "%s %s %r method",
+        "arguments-renamed",
+        "Used when a method parameter has a different name than in "
+        "the implemented interface or in an overridden method.",
+    ),
+    "W0238": (
+        "Unused private member `%s.%s`",
+        "unused-private-member",
+        "Emitted when a private member of a class is defined but not used.",
+    ),
+    "W0239": (
+        "Method %r overrides a method decorated with typing.final which is defined in class %r",
+        "overridden-final-method",
+        "Used when a method decorated with typing.final has been overridden.",
+    ),
+    "W0240": (
+        "Class %r is a subclass of a class decorated with typing.final: %r",
+        "subclassed-final-class",
+        "Used when a class decorated with typing.final has been subclassed.",
+    ),
+    "W0244": (
+        "Redefined slots %r in subclass",
+        "redefined-slots-in-subclass",
+        "Used when a slot is re-defined in a subclass.",
+    ),
+    "E0236": (
+        "Invalid object %r in __slots__, must contain only non empty strings",
+        "invalid-slots-object",
+        "Used when an invalid (non-string) object occurs in __slots__.",
+    ),
+    "E0237": (
+        "Assigning to attribute %r not defined in class slots",
+        "assigning-non-slot",
+        "Used when assigning to an attribute not defined in the class slots.",
+    ),
+    "E0238": (
+        "Invalid __slots__ object",
+        "invalid-slots",
+        "Used when an invalid __slots__ is found in class. "
+        "Only a string, an iterable or a sequence is permitted.",
+    ),
+    "E0239": (
+        "Inheriting %r, which is not a class.",
+        "inherit-non-class",
+        "Used when a class inherits from something which is not a class.",
+    ),
+    "E0240": (
+        "Inconsistent method resolution order for class %r",
+        "inconsistent-mro",
+        "Used when a class has an inconsistent method resolution order.",
+    ),
+    "E0241": (
+        "Duplicate bases for class %r",
+        "duplicate-bases",
+        "Used when a class has duplicate bases.",
+    ),
+    "E0242": (
+        "Value %r in slots conflicts with class variable",
+        "class-variable-slots-conflict",
+        "Used when a value in __slots__ conflicts with a class variable, property or method.",
+    ),
+    "E0243": (
+        "Invalid __class__ object",
+        "invalid-class-object",
+        "Used when an invalid object is assigned to a __class__ property. "
+        "Only a class is permitted.",
+    ),
+    "R0202": (
+        "Consider using a decorator instead of calling classmethod",
+        "no-classmethod-decorator",
+        "Used when a class method is defined without using the decorator syntax.",
+    ),
+    "R0203": (
+        "Consider using a decorator instead of calling staticmethod",
+        "no-staticmethod-decorator",
+        "Used when a static method is defined without using the decorator syntax.",
+    ),
+    "C0205": (
+        "Class __slots__ should be a non-string iterable",
+        "single-string-used-for-slots",
+        "Used when a class __slots__ is a simple string, rather than an iterable.",
+    ),
+    "R0205": (
+        "Class %r inherits from object, can be safely removed from bases in python3",
+        "useless-object-inheritance",
+        "Used when a class inherit from object, which under python3 is implicit, "
+        "hence can be safely removed from bases.",
+    ),
+    "R0206": (
+        "Cannot have defined parameters for properties",
+        "property-with-parameters",
+        "Used when we detect that a property also has parameters, which are useless, "
+        "given that properties cannot be called with additional arguments.",
+    ),
+}
+
+
+def _scope_default():
+    return collections.defaultdict(list)
+
+
+class ScopeAccessMap:
+    """Store the accessed variables per scope."""
+
+    def __init__(self):
+        self._scopes = collections.defaultdict(_scope_default)
+
+    def set_accessed(self, node):
+        """Set the given node as accessed."""
+
+        frame = node_frame_class(node)
+        if frame is None:
+            # The node does not live in a class.
+            return
+        self._scopes[frame][node.attrname].append(node)
+
+    def accessed(self, scope):
+        """Get the accessed variables for the given scope."""
+        return self._scopes.get(scope, {})
+
+
+class ClassChecker(BaseChecker):
+    """Checker for class nodes.
+
+    Checks for :
+    * methods without self as first argument
+    * overridden methods signature
+    * access only to existent members via self
+    * attributes not defined in the __init__ method
+    * unreachable code
+    """
+
+    __implements__ = (IAstroidChecker,)
+
+    # configuration section name
+    name = "classes"
+    # messages
+    msgs = MSGS
+    priority = -2
+    # configuration options
+    options = (
+        (
+            "defining-attr-methods",
+            {
+                "default": ("__init__", "__new__", "setUp", "__post_init__"),
+                "type": "csv",
+                "metavar": "<method names>",
+                "help": "List of method names used to declare (i.e. assign) \
+instance attributes.",
+            },
+        ),
+        (
+            "valid-classmethod-first-arg",
+            {
+                "default": ("cls",),
+                "type": "csv",
+                "metavar": "<argument names>",
+                "help": "List of valid names for the first argument in \
+a class method.",
+            },
+        ),
+        (
+            "valid-metaclass-classmethod-first-arg",
+            {
+                "default": ("cls",),
+                "type": "csv",
+                "metavar": "<argument names>",
+                "help": "List of valid names for the first argument in \
+a metaclass class method.",
+            },
+        ),
+        (
+            "exclude-protected",
+            {
+                "default": (
+                    # namedtuple public API.
+                    "_asdict",
+                    "_fields",
+                    "_replace",
+                    "_source",
+                    "_make",
+                ),
+                "type": "csv",
+                "metavar": "<protected access exclusions>",
+                "help": (
+                    "List of member names, which should be excluded "
+                    "from the protected access warning."
+                ),
+            },
+        ),
+        (
+            "check-protected-access-in-special-methods",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Warn about protected attribute access inside special methods",
+            },
+        ),
+    )
+
+    def __init__(self, linter=None):
+        super().__init__(linter)
+        self._accessed = ScopeAccessMap()
+        self._first_attrs = []
+        self._meth_could_be_func = None
+
+    def open(self) -> None:
+        self._mixin_class_rgx = get_global_option(self, "mixin-class-rgx")
+        py_version = get_global_option(self, "py-version")
+        self._py38_plus = py_version >= (3, 8)
+
+    @cached_property
+    def _dummy_rgx(self):
+        return get_global_option(self, "dummy-variables-rgx", default=None)
+
+    @cached_property
+    def _ignore_mixin(self):
+        return get_global_option(self, "ignore-mixin-members", default=True)
+
+    @check_messages(
+        "abstract-method",
+        "no-init",
+        "invalid-slots",
+        "single-string-used-for-slots",
+        "invalid-slots-object",
+        "class-variable-slots-conflict",
+        "inherit-non-class",
+        "useless-object-inheritance",
+        "inconsistent-mro",
+        "duplicate-bases",
+        "redefined-slots-in-subclass",
+        "subclassed-final-class",
+    )
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        """Init visit variable _accessed."""
+        self._check_bases_classes(node)
+        # if not an exception or a metaclass
+        if node.type == "class" and has_known_bases(node):
+            try:
+                node.local_attr("__init__")
+            except astroid.NotFoundError:
+                self.add_message("no-init", args=node, node=node)
+        self._check_slots(node)
+        self._check_proper_bases(node)
+        self._check_typing_final(node)
+        self._check_consistent_mro(node)
+
+    def _check_consistent_mro(self, node):
+        """Detect that a class has a consistent mro or duplicate bases."""
+        try:
+            node.mro()
+        except astroid.InconsistentMroError:
+            self.add_message("inconsistent-mro", args=node.name, node=node)
+        except astroid.DuplicateBasesError:
+            self.add_message("duplicate-bases", args=node.name, node=node)
+        except NotImplementedError:
+            # Old style class, there's no mro so don't do anything.
+            pass
+
+    def _check_proper_bases(self, node):
+        """Detect that a class inherits something which is not
+        a class or a type.
+        """
+        for base in node.bases:
+            ancestor = safe_infer(base)
+            if not ancestor:
+                continue
+            if isinstance(ancestor, astroid.Instance) and ancestor.is_subtype_of(
+                "builtins.type"
+            ):
+                continue
+
+            if not isinstance(ancestor, nodes.ClassDef) or _is_invalid_base_class(
+                ancestor
+            ):
+                self.add_message("inherit-non-class", args=base.as_string(), node=node)
+
+            if ancestor.name == object.__name__:
+                self.add_message(
+                    "useless-object-inheritance", args=node.name, node=node
+                )
+
+    def _check_typing_final(self, node: nodes.ClassDef) -> None:
+        """Detect that a class does not subclass a class decorated with `typing.final`."""
+        if not self._py38_plus:
+            return
+        for base in node.bases:
+            ancestor = safe_infer(base)
+            if not ancestor:
+                continue
+
+            if isinstance(ancestor, nodes.ClassDef) and (
+                decorated_with(ancestor, ["typing.final"])
+                or uninferable_final_decorators(ancestor.decorators)
+            ):
+                self.add_message(
+                    "subclassed-final-class",
+                    args=(node.name, ancestor.name),
+                    node=node,
+                )
+
+    @check_messages(
+        "unused-private-member",
+        "attribute-defined-outside-init",
+        "access-member-before-definition",
+    )
+    def leave_classdef(self, node: nodes.ClassDef) -> None:
+        """Checker for Class nodes.
+
+        check that instance attributes are defined in __init__ and check
+        access to existent members
+        """
+        self._check_unused_private_functions(node)
+        self._check_unused_private_variables(node)
+        self._check_unused_private_attributes(node)
+        self._check_attribute_defined_outside_init(node)
+
+    def _check_unused_private_functions(self, node: nodes.ClassDef) -> None:
+        for function_def in node.nodes_of_class(nodes.FunctionDef):
+            if not is_attr_private(function_def.name):
+                continue
+            parent_scope = function_def.parent.scope()
+            if isinstance(parent_scope, nodes.FunctionDef):
+                # Handle nested functions
+                if function_def.name in (
+                    n.name for n in parent_scope.nodes_of_class(nodes.Name)
+                ):
+                    continue
+            for child in node.nodes_of_class((nodes.Name, nodes.Attribute)):
+                # Check for cases where the functions are used as a variable instead of as a method call
+                if isinstance(child, nodes.Name) and child.name == function_def.name:
+                    break
+                if isinstance(child, nodes.Attribute):
+                    # Ignore recursive calls
+                    if (
+                        child.attrname != function_def.name
+                        or child.scope() == function_def
+                    ):
+                        continue
+
+                    # Check self.__attrname, cls.__attrname, node_name.__attrname
+                    if isinstance(child.expr, nodes.Name) and child.expr.name in {
+                        "self",
+                        "cls",
+                        node.name,
+                    }:
+
+                        break
+
+                    # Check type(self).__attrname
+                    if isinstance(child.expr, nodes.Call):
+                        inferred = safe_infer(child.expr)
+                        if (
+                            isinstance(inferred, nodes.ClassDef)
+                            and inferred.name == node.name
+                        ):
+                            break
+            else:
+                name_stack = []
+                curr = parent_scope
+                # Generate proper names for nested functions
+                while curr != node:
+                    name_stack.append(curr.name)
+                    curr = curr.parent.scope()
+
+                outer_level_names = f"{'.'.join(reversed(name_stack))}"
+                function_repr = f"{outer_level_names}.{function_def.name}({function_def.args.as_string()})"
+                self.add_message(
+                    "unused-private-member",
+                    node=function_def,
+                    args=(node.name, function_repr.lstrip(".")),
+                )
+
+    def _check_unused_private_variables(self, node: nodes.ClassDef) -> None:
+        """Check if private variables are never used within a class."""
+        for assign_name in node.nodes_of_class(nodes.AssignName):
+            if isinstance(assign_name.parent, nodes.Arguments):
+                continue  # Ignore function arguments
+            if not is_attr_private(assign_name.name):
+                continue
+            for child in node.nodes_of_class((nodes.Name, nodes.Attribute)):
+                if isinstance(child, nodes.Name) and child.name == assign_name.name:
+                    break
+                if isinstance(child, nodes.Attribute):
+                    if not isinstance(child.expr, nodes.Name):
+                        break
+                    if child.attrname == assign_name.name and child.expr.name in (
+                        "self",
+                        "cls",
+                        node.name,
+                    ):
+                        break
+            else:
+                args = (node.name, assign_name.name)
+                self.add_message("unused-private-member", node=assign_name, args=args)
+
+    def _check_unused_private_attributes(self, node: nodes.ClassDef) -> None:
+        for assign_attr in node.nodes_of_class(nodes.AssignAttr):
+            if not is_attr_private(assign_attr.attrname) or not isinstance(
+                assign_attr.expr, nodes.Name
+            ):
+                continue
+
+            # Logic for checking false positive when using __new__,
+            # Get the returned object names of the __new__ magic function
+            # Then check if the attribute was consumed in other instance methods
+            acceptable_obj_names: List[str] = ["self"]
+            scope = assign_attr.scope()
+            if isinstance(scope, nodes.FunctionDef) and scope.name == "__new__":
+                acceptable_obj_names.extend(
+                    [
+                        return_node.value.name
+                        for return_node in scope.nodes_of_class(nodes.Return)
+                        if isinstance(return_node.value, nodes.Name)
+                    ]
+                )
+
+            for attribute in node.nodes_of_class(nodes.Attribute):
+                if attribute.attrname != assign_attr.attrname:
+                    continue
+
+                if isinstance(attribute.expr, nodes.Call):
+                    continue
+
+                if assign_attr.expr.name in {
+                    "cls",
+                    node.name,
+                } and attribute.expr.name in {"cls", "self", node.name}:
+                    # If assigned to cls or class name, can be accessed by cls/self/class name
+                    break
+
+                if (
+                    assign_attr.expr.name in acceptable_obj_names
+                    and attribute.expr.name == "self"
+                ):
+                    # If assigned to self.attrib, can only be accessed by self
+                    # Or if __new__ was used, the returned object names are acceptable
+                    break
+
+                if assign_attr.expr.name == attribute.expr.name == node.name:
+                    # Recognise attributes which are accessed via the class name
+                    break
+
+            else:
+                args = (node.name, assign_attr.attrname)
+                self.add_message("unused-private-member", node=assign_attr, args=args)
+
+    def _check_attribute_defined_outside_init(self, cnode: nodes.ClassDef) -> None:
+        # check access to existent members on non metaclass classes
+        if self._ignore_mixin and self._mixin_class_rgx.match(cnode.name):
+            # We are in a mixin class. No need to try to figure out if
+            # something is missing, since it is most likely that it will
+            # miss.
+            return
+
+        accessed = self._accessed.accessed(cnode)
+        if cnode.type != "metaclass":
+            self._check_accessed_members(cnode, accessed)
+        # checks attributes are defined in an allowed method such as __init__
+        if not self.linter.is_message_enabled("attribute-defined-outside-init"):
+            return
+        defining_methods = self.config.defining_attr_methods
+        current_module = cnode.root()
+        for attr, nodes_lst in cnode.instance_attrs.items():
+            # Exclude `__dict__` as it is already defined.
+            if attr == "__dict__":
+                continue
+
+            # Skip nodes which are not in the current module and it may screw up
+            # the output, while it's not worth it
+            nodes_lst = [
+                n
+                for n in nodes_lst
+                if not isinstance(
+                    n.statement(future=True), (nodes.Delete, nodes.AugAssign)
+                )
+                and n.root() is current_module
+            ]
+            if not nodes_lst:
+                continue  # error detected by typechecking
+
+            # Check if any method attr is defined in is a defining method
+            # or if we have the attribute defined in a setter.
+            frames = (node.frame(future=True) for node in nodes_lst)
+            if any(
+                frame.name in defining_methods or is_property_setter(frame)
+                for frame in frames
+            ):
+                continue
+
+            # check attribute is defined in a parent's __init__
+            for parent in cnode.instance_attr_ancestors(attr):
+                attr_defined = False
+                # check if any parent method attr is defined in is a defining method
+                for node in parent.instance_attrs[attr]:
+                    if node.frame(future=True).name in defining_methods:
+                        attr_defined = True
+                if attr_defined:
+                    # we're done :)
+                    break
+            else:
+                # check attribute is defined as a class attribute
+                try:
+                    cnode.local_attr(attr)
+                except astroid.NotFoundError:
+                    for node in nodes_lst:
+                        if node.frame(future=True).name not in defining_methods:
+                            # If the attribute was set by a call in any
+                            # of the defining methods, then don't emit
+                            # the warning.
+                            if _called_in_methods(
+                                node.frame(future=True), cnode, defining_methods
+                            ):
+                                continue
+                            self.add_message(
+                                "attribute-defined-outside-init", args=attr, node=node
+                            )
+
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        """Check method arguments, overriding."""
+        # ignore actual functions
+        if not node.is_method():
+            return
+
+        self._check_useless_super_delegation(node)
+        self._check_property_with_parameters(node)
+
+        # 'is_method()' is called and makes sure that this is a 'nodes.ClassDef'
+        klass = node.parent.frame(future=True)  # type: nodes.ClassDef
+        self._meth_could_be_func = True
+        # check first argument is self if this is actually a method
+        self._check_first_arg_for_type(node, klass.type == "metaclass")
+        if node.name == "__init__":
+            self._check_init(node, klass)
+            return
+        # check signature if the method overloads inherited method
+        for overridden in klass.local_attr_ancestors(node.name):
+            # get astroid for the searched method
+            try:
+                parent_function = overridden[node.name]
+            except KeyError:
+                # we have found the method but it's not in the local
+                # dictionary.
+                # This may happen with astroid build from living objects
+                continue
+            if not isinstance(parent_function, nodes.FunctionDef):
+                continue
+            self._check_signature(node, parent_function, "overridden", klass)
+            self._check_invalid_overridden_method(node, parent_function)
+            break
+
+        if node.decorators:
+            for decorator in node.decorators.nodes:
+                if isinstance(decorator, nodes.Attribute) and decorator.attrname in {
+                    "getter",
+                    "setter",
+                    "deleter",
+                }:
+                    # attribute affectation will call this method, not hiding it
+                    return
+                if isinstance(decorator, nodes.Name):
+                    if decorator.name == "property":
+                        # attribute affectation will either call a setter or raise
+                        # an attribute error, anyway not hiding the function
+                        return
+
+                # Infer the decorator and see if it returns something useful
+                inferred = safe_infer(decorator)
+                if not inferred:
+                    return
+                if isinstance(inferred, nodes.FunctionDef):
+                    # Okay, it's a decorator, let's see what it can infer.
+                    try:
+                        inferred = next(inferred.infer_call_result(inferred))
+                    except astroid.InferenceError:
+                        return
+                try:
+                    if (
+                        isinstance(inferred, (astroid.Instance, nodes.ClassDef))
+                        and inferred.getattr("__get__")
+                        and inferred.getattr("__set__")
+                    ):
+                        return
+                except astroid.AttributeInferenceError:
+                    pass
+
+        # check if the method is hidden by an attribute
+        try:
+            overridden = klass.instance_attr(node.name)[0]
+            overridden_frame = overridden.frame(future=True)
+            if (
+                isinstance(overridden_frame, nodes.FunctionDef)
+                and overridden_frame.type == "method"
+            ):
+                overridden_frame = overridden_frame.parent.frame(future=True)
+            if not (
+                isinstance(overridden_frame, nodes.ClassDef)
+                and klass.is_subtype_of(overridden_frame.qname())
+            ):
+                return
+
+            # If a subclass defined the method then it's not our fault.
+            for ancestor in klass.ancestors():
+                if node.name in ancestor.instance_attrs and is_attr_private(node.name):
+                    return
+                for obj in ancestor.lookup(node.name)[1]:
+                    if isinstance(obj, nodes.FunctionDef):
+                        return
+            args = (overridden.root().name, overridden.fromlineno)
+            self.add_message("method-hidden", args=args, node=node)
+        except astroid.NotFoundError:
+            pass
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    def _check_useless_super_delegation(self, function):
+        """Check if the given function node is an useless method override.
+
+        We consider it *useless* if it uses the super() builtin, but having
+        nothing additional whatsoever than not implementing the method at all.
+        If the method uses super() to delegate an operation to the rest of the MRO,
+        and if the method called is the same as the current one, the arguments
+        passed to super() are the same as the parameters that were passed to
+        this method, then the method could be removed altogether, by letting
+        other implementation to take precedence.
+        """
+
+        if (
+            not function.is_method()
+            # With decorators is a change of use
+            or function.decorators
+        ):
+            return
+
+        body = function.body
+        if len(body) != 1:
+            # Multiple statements, which means this overridden method
+            # could do multiple things we are not aware of.
+            return
+
+        statement = body[0]
+        if not isinstance(statement, (nodes.Expr, nodes.Return)):
+            # Doing something else than what we are interested into.
+            return
+
+        call = statement.value
+        if (
+            not isinstance(call, nodes.Call)
+            # Not a super() attribute access.
+            or not isinstance(call.func, nodes.Attribute)
+        ):
+            return
+
+        # Should be a super call.
+        try:
+            super_call = next(call.func.expr.infer())
+        except astroid.InferenceError:
+            return
+        else:
+            if not isinstance(super_call, astroid.objects.Super):
+                return
+
+        # The name should be the same.
+        if call.func.attrname != function.name:
+            return
+
+        # Should be a super call with the MRO pointer being the
+        # current class and the type being the current instance.
+        current_scope = function.parent.scope()
+        if (
+            super_call.mro_pointer != current_scope
+            or not isinstance(super_call.type, astroid.Instance)
+            or super_call.type.name != current_scope.name
+        ):
+            return
+
+        # Check values of default args
+        klass = function.parent.frame(future=True)
+        meth_node = None
+        for overridden in klass.local_attr_ancestors(function.name):
+            # get astroid for the searched method
+            try:
+                meth_node = overridden[function.name]
+            except KeyError:
+                # we have found the method but it's not in the local
+                # dictionary.
+                # This may happen with astroid build from living objects
+                continue
+            if (
+                not isinstance(meth_node, nodes.FunctionDef)
+                # If the method have an ancestor which is not a
+                # function then it is legitimate to redefine it
+                or _has_different_parameters_default_value(
+                    meth_node.args, function.args
+                )
+            ):
+                return
+            break
+
+        # Detect if the parameters are the same as the call's arguments.
+        params = _signature_from_arguments(function.args)
+        args = _signature_from_call(call)
+
+        if meth_node is not None:
+
+            def form_annotations(arguments):
+                annotations = chain(
+                    (arguments.posonlyargs_annotations or []), arguments.annotations
+                )
+                return [ann.as_string() for ann in annotations if ann is not None]
+
+            called_annotations = form_annotations(function.args)
+            overridden_annotations = form_annotations(meth_node.args)
+            if called_annotations and overridden_annotations:
+                if called_annotations != overridden_annotations:
+                    return
+
+            if (
+                function.returns is not None
+                and meth_node.returns is not None
+                and meth_node.returns.as_string() != function.returns.as_string()
+            ):
+                # Override adds typing information to the return type
+                return
+
+        if _definition_equivalent_to_call(params, args):
+            self.add_message(
+                "useless-super-delegation", node=function, args=(function.name,)
+            )
+
+    def _check_property_with_parameters(self, node):
+        if (
+            node.args.args
+            and len(node.args.args) > 1
+            and decorated_with_property(node)
+            and not is_property_setter(node)
+        ):
+            self.add_message("property-with-parameters", node=node)
+
+    def _check_invalid_overridden_method(self, function_node, parent_function_node):
+        parent_is_property = decorated_with_property(
+            parent_function_node
+        ) or is_property_setter_or_deleter(parent_function_node)
+        current_is_property = decorated_with_property(
+            function_node
+        ) or is_property_setter_or_deleter(function_node)
+        if parent_is_property and not current_is_property:
+            self.add_message(
+                "invalid-overridden-method",
+                args=(function_node.name, "property", function_node.type),
+                node=function_node,
+            )
+        elif not parent_is_property and current_is_property:
+            self.add_message(
+                "invalid-overridden-method",
+                args=(function_node.name, "method", "property"),
+                node=function_node,
+            )
+
+        parent_is_async = isinstance(parent_function_node, nodes.AsyncFunctionDef)
+        current_is_async = isinstance(function_node, nodes.AsyncFunctionDef)
+
+        if parent_is_async and not current_is_async:
+            self.add_message(
+                "invalid-overridden-method",
+                args=(function_node.name, "async", "non-async"),
+                node=function_node,
+            )
+
+        elif not parent_is_async and current_is_async:
+            self.add_message(
+                "invalid-overridden-method",
+                args=(function_node.name, "non-async", "async"),
+                node=function_node,
+            )
+        if (
+            decorated_with(parent_function_node, ["typing.final"])
+            or uninferable_final_decorators(parent_function_node.decorators)
+        ) and self._py38_plus:
+            self.add_message(
+                "overridden-final-method",
+                args=(function_node.name, parent_function_node.parent.frame().name),
+                node=function_node,
+            )
+
+    def _check_slots(self, node: nodes.ClassDef) -> None:
+        if "__slots__" not in node.locals:
+            return
+        for slots in node.igetattr("__slots__"):
+            # check if __slots__ is a valid type
+            if slots is astroid.Uninferable:
+                continue
+            if not is_iterable(slots) and not is_comprehension(slots):
+                self.add_message("invalid-slots", node=node)
+                continue
+
+            if isinstance(slots, nodes.Const):
+                # a string, ignore the following checks
+                self.add_message("single-string-used-for-slots", node=node)
+                continue
+            if not hasattr(slots, "itered"):
+                # we can't obtain the values, maybe a .deque?
+                continue
+
+            if isinstance(slots, nodes.Dict):
+                values = [item[0] for item in slots.items]
+            else:
+                values = slots.itered()
+            if values is astroid.Uninferable:
+                return
+            for elt in values:
+                try:
+                    self._check_slots_elt(elt, node)
+                except astroid.InferenceError:
+                    continue
+            self._check_redefined_slots(node, slots, values)
+
+    def _check_redefined_slots(
+        self,
+        node: nodes.ClassDef,
+        slots_node: nodes.NodeNG,
+        slots_list: List[nodes.NodeNG],
+    ) -> None:
+        """Check if `node` redefines a slot which is defined in an ancestor class."""
+        slots_names: List[str] = []
+        for slot in slots_list:
+            if isinstance(slot, nodes.Const):
+                slots_names.append(slot.value)
+            else:
+                inferred_slot = safe_infer(slot)
+                inferred_slot_value = getattr(inferred_slot, "value", None)
+                if isinstance(inferred_slot_value, str):
+                    slots_names.append(inferred_slot_value)
+
+        # Slots of all parent classes
+        ancestors_slots_names = {
+            slot.value
+            for ancestor in node.local_attr_ancestors("__slots__")
+            for slot in ancestor.slots() or []
+        }
+
+        # Slots which are common to `node` and its parent classes
+        redefined_slots = ancestors_slots_names.intersection(slots_names)
+
+        if redefined_slots:
+            self.add_message(
+                "redefined-slots-in-subclass",
+                args=([name for name in slots_names if name in redefined_slots],),
+                node=slots_node,
+            )
+
+    def _check_slots_elt(self, elt, node):
+        for inferred in elt.infer():
+            if inferred is astroid.Uninferable:
+                continue
+            if not isinstance(inferred, nodes.Const) or not isinstance(
+                inferred.value, str
+            ):
+                self.add_message(
+                    "invalid-slots-object", args=inferred.as_string(), node=elt
+                )
+                continue
+            if not inferred.value:
+                self.add_message(
+                    "invalid-slots-object", args=inferred.as_string(), node=elt
+                )
+
+            # Check if we have a conflict with a class variable.
+            class_variable = node.locals.get(inferred.value)
+            if class_variable:
+                # Skip annotated assignments which don't conflict at all with slots.
+                if len(class_variable) == 1:
+                    parent = class_variable[0].parent
+                    if isinstance(parent, nodes.AnnAssign) and parent.value is None:
+                        return
+                self.add_message(
+                    "class-variable-slots-conflict", args=(inferred.value,), node=elt
+                )
+
+    def leave_functiondef(self, node: nodes.FunctionDef) -> None:
+        """On method node, check if this method couldn't be a function.
+
+        ignore class, static and abstract methods, initializer,
+        methods overridden from a parent class.
+        """
+        if node.is_method():
+            if node.args.args is not None:
+                self._first_attrs.pop()
+            if not self.linter.is_message_enabled("no-self-use"):
+                return
+            class_node = node.parent.frame(future=True)
+            if (
+                self._meth_could_be_func
+                and node.type == "method"
+                and node.name not in PYMETHODS
+                and not (
+                    node.is_abstract()
+                    or overrides_a_method(class_node, node.name)
+                    or decorated_with_property(node)
+                    or _has_bare_super_call(node)
+                    or is_protocol_class(class_node)
+                    or is_overload_stub(node)
+                )
+            ):
+                self.add_message("no-self-use", node=node)
+
+    leave_asyncfunctiondef = leave_functiondef
+
+    def visit_attribute(self, node: nodes.Attribute) -> None:
+        """Check if the getattr is an access to a class member
+        if so, register it
+
+        Also check for access to protected
+        class member from outside its class (but ignore __special__
+        methods)
+        """
+        # Check self
+        if self._uses_mandatory_method_param(node):
+            self._accessed.set_accessed(node)
+            return
+        if not self.linter.is_message_enabled("protected-access"):
+            return
+
+        self._check_protected_attribute_access(node)
+
+    @check_messages("assigning-non-slot", "invalid-class-object")
+    def visit_assignattr(self, node: nodes.AssignAttr) -> None:
+        if isinstance(
+            node.assign_type(), nodes.AugAssign
+        ) and self._uses_mandatory_method_param(node):
+            self._accessed.set_accessed(node)
+        self._check_in_slots(node)
+        self._check_invalid_class_object(node)
+
+    def _check_invalid_class_object(self, node: nodes.AssignAttr) -> None:
+        if not node.attrname == "__class__":
+            return
+        inferred = safe_infer(node.parent.value)
+        if (
+            isinstance(inferred, nodes.ClassDef)
+            or inferred is astroid.Uninferable
+            or inferred is None
+        ):
+            # If is uninferable, we allow it to prevent false positives
+            return
+        self.add_message("invalid-class-object", node=node)
+
+    def _check_in_slots(self, node):
+        """Check that the given AssignAttr node
+        is defined in the class slots.
+        """
+        inferred = safe_infer(node.expr)
+        if not isinstance(inferred, astroid.Instance):
+            return
+
+        klass = inferred._proxied
+        if not has_known_bases(klass):
+            return
+        if "__slots__" not in klass.locals or not klass.newstyle:
+            return
+        # If `__setattr__` is defined on the class, then we can't reason about
+        # what will happen when assigning to an attribute.
+        if any(
+            base.locals.get("__setattr__")
+            for base in klass.mro()
+            if base.qname() != "builtins.object"
+        ):
+            return
+
+        # If 'typing.Generic' is a base of bases of klass, the cached version
+        # of 'slots()' might have been evaluated incorrectly, thus deleted cache entry.
+        if any(base.qname() == "typing.Generic" for base in klass.mro()):
+            cache = getattr(klass, "__cache", None)
+            if cache and cache.get(klass.slots) is not None:
+                del cache[klass.slots]
+
+        slots = klass.slots()
+        if slots is None:
+            return
+        # If any ancestor doesn't use slots, the slots
+        # defined for this class are superfluous.
+        if any(
+            "__slots__" not in ancestor.locals and ancestor.name != "object"
+            for ancestor in klass.ancestors()
+        ):
+            return
+
+        if not any(slot.value == node.attrname for slot in slots):
+            # If we have a '__dict__' in slots, then
+            # assigning any name is valid.
+            if not any(slot.value == "__dict__" for slot in slots):
+                if _is_attribute_property(node.attrname, klass):
+                    # Properties circumvent the slots mechanism,
+                    # so we should not emit a warning for them.
+                    return
+                if node.attrname in klass.locals:
+                    for local_name in klass.locals.get(node.attrname):
+                        statement = local_name.statement(future=True)
+                        if (
+                            isinstance(statement, nodes.AnnAssign)
+                            and not statement.value
+                        ):
+                            return
+                    if _has_data_descriptor(klass, node.attrname):
+                        # Descriptors circumvent the slots mechanism as well.
+                        return
+                if node.attrname == "__class__" and _has_same_layout_slots(
+                    slots, node.parent.value
+                ):
+                    return
+                self.add_message("assigning-non-slot", args=(node.attrname,), node=node)
+
+    @check_messages(
+        "protected-access", "no-classmethod-decorator", "no-staticmethod-decorator"
+    )
+    def visit_assign(self, assign_node: nodes.Assign) -> None:
+        self._check_classmethod_declaration(assign_node)
+        node = assign_node.targets[0]
+        if not isinstance(node, nodes.AssignAttr):
+            return
+
+        if self._uses_mandatory_method_param(node):
+            return
+        self._check_protected_attribute_access(node)
+
+    def _check_classmethod_declaration(self, node):
+        """Checks for uses of classmethod() or staticmethod().
+
+        When a @classmethod or @staticmethod decorator should be used instead.
+        A message will be emitted only if the assignment is at a class scope
+        and only if the classmethod's argument belongs to the class where it
+        is defined.
+        `node` is an assign node.
+        """
+        if not isinstance(node.value, nodes.Call):
+            return
+
+        # check the function called is "classmethod" or "staticmethod"
+        func = node.value.func
+        if not isinstance(func, nodes.Name) or func.name not in (
+            "classmethod",
+            "staticmethod",
+        ):
+            return
+
+        msg = (
+            "no-classmethod-decorator"
+            if func.name == "classmethod"
+            else "no-staticmethod-decorator"
+        )
+        # assignment must be at a class scope
+        parent_class = node.scope()
+        if not isinstance(parent_class, nodes.ClassDef):
+            return
+
+        # Check if the arg passed to classmethod is a class member
+        classmeth_arg = node.value.args[0]
+        if not isinstance(classmeth_arg, nodes.Name):
+            return
+
+        method_name = classmeth_arg.name
+        if any(method_name == member.name for member in parent_class.mymethods()):
+            self.add_message(msg, node=node.targets[0])
+
+    def _check_protected_attribute_access(self, node: nodes.Attribute):
+        """Given an attribute access node (set or get), check if attribute
+        access is legitimate.
+
+        Call _check_first_attr with node before calling
+        this method. Valid cases are:
+        * self._attr in a method or cls._attr in a classmethod. Checked by
+        _check_first_attr.
+        * Klass._attr inside "Klass" class.
+        * Klass2._attr inside "Klass" class when Klass2 is a base class of
+            Klass.
+        """
+        attrname = node.attrname
+
+        if (
+            is_attr_protected(attrname)
+            and attrname not in self.config.exclude_protected
+        ):
+
+            klass = node_frame_class(node)
+
+            # In classes, check we are not getting a parent method
+            # through the class object or through super
+            callee = node.expr.as_string()
+
+            # Typing annotations in function definitions can include protected members
+            if utils.is_node_in_type_annotation_context(node):
+                return
+
+            # We are not in a class, no remaining valid case
+            if klass is None:
+                self.add_message("protected-access", node=node, args=attrname)
+                return
+
+            # If the expression begins with a call to super, that's ok.
+            if (
+                isinstance(node.expr, nodes.Call)
+                and isinstance(node.expr.func, nodes.Name)
+                and node.expr.func.name == "super"
+            ):
+                return
+
+            # If the expression begins with a call to type(self), that's ok.
+            if self._is_type_self_call(node.expr):
+                return
+
+            # Check if we are inside the scope of a class or nested inner class
+            inside_klass = True
+            outer_klass = klass
+            parents_callee = callee.split(".")
+            parents_callee.reverse()
+            for callee in parents_callee:
+                if not outer_klass or callee != outer_klass.name:
+                    inside_klass = False
+                    break
+
+                # Move up one level within the nested classes
+                outer_klass = get_outer_class(outer_klass)
+
+            # We are in a class, one remaining valid cases, Klass._attr inside
+            # Klass
+            if not (inside_klass or callee in klass.basenames):
+                # Detect property assignments in the body of the class.
+                # This is acceptable:
+                #
+                # class A:
+                #     b = property(lambda: self._b)
+
+                stmt = node.parent.statement(future=True)
+                if (
+                    isinstance(stmt, nodes.Assign)
+                    and len(stmt.targets) == 1
+                    and isinstance(stmt.targets[0], nodes.AssignName)
+                ):
+                    name = stmt.targets[0].name
+                    if _is_attribute_property(name, klass):
+                        return
+
+                if (
+                    self._is_classmethod(node.frame(future=True))
+                    and self._is_inferred_instance(node.expr, klass)
+                    and self._is_class_attribute(attrname, klass)
+                ):
+                    return
+
+                licit_protected_member = not attrname.startswith("__")
+                if (
+                    not self.config.check_protected_access_in_special_methods
+                    and licit_protected_member
+                    and self._is_called_inside_special_method(node)
+                ):
+                    return
+
+                self.add_message("protected-access", node=node, args=attrname)
+
+    @staticmethod
+    def _is_called_inside_special_method(node: nodes.NodeNG) -> bool:
+        """Returns true if the node is located inside a special (aka dunder) method."""
+        frame_name = node.frame(future=True).name
+        return frame_name and frame_name in PYMETHODS
+
+    def _is_type_self_call(self, expr: nodes.NodeNG) -> bool:
+        return (
+            isinstance(expr, nodes.Call)
+            and isinstance(expr.func, nodes.Name)
+            and expr.func.name == "type"
+            and len(expr.args) == 1
+            and self._is_mandatory_method_param(expr.args[0])
+        )
+
+    @staticmethod
+    def _is_classmethod(func):
+        """Check if the given *func* node is a class method."""
+
+        return isinstance(func, nodes.FunctionDef) and (
+            func.type == "classmethod" or func.name == "__class_getitem__"
+        )
+
+    @staticmethod
+    def _is_inferred_instance(expr, klass):
+        """Check if the inferred value of the given *expr* is an instance of *klass*."""
+
+        inferred = safe_infer(expr)
+        if not isinstance(inferred, astroid.Instance):
+            return False
+
+        return inferred._proxied is klass
+
+    @staticmethod
+    def _is_class_attribute(name, klass):
+        """Check if the given attribute *name* is a class or instance member of the given *klass*.
+
+        Returns ``True`` if the name is a property in the given klass,
+        ``False`` otherwise.
+        """
+
+        try:
+            klass.getattr(name)
+            return True
+        except astroid.NotFoundError:
+            pass
+
+        try:
+            klass.instance_attr(name)
+            return True
+        except astroid.NotFoundError:
+            return False
+
+    def visit_name(self, node: nodes.Name) -> None:
+        """Check if the name handle an access to a class member
+        if so, register it
+        """
+        if self._first_attrs and (
+            node.name == self._first_attrs[-1] or not self._first_attrs[-1]
+        ):
+            self._meth_could_be_func = False
+
+    def _check_accessed_members(self, node, accessed):
+        """Check that accessed members are defined."""
+        excs = ("AttributeError", "Exception", "BaseException")
+        for attr, nodes_lst in accessed.items():
+            try:
+                # is it a class attribute ?
+                node.local_attr(attr)
+                # yes, stop here
+                continue
+            except astroid.NotFoundError:
+                pass
+            # is it an instance attribute of a parent class ?
+            try:
+                next(node.instance_attr_ancestors(attr))
+                # yes, stop here
+                continue
+            except StopIteration:
+                pass
+            # is it an instance attribute ?
+            try:
+                defstmts = node.instance_attr(attr)
+            except astroid.NotFoundError:
+                pass
+            else:
+                # filter out augment assignment nodes
+                defstmts = [stmt for stmt in defstmts if stmt not in nodes_lst]
+                if not defstmts:
+                    # only augment assignment for this node, no-member should be
+                    # triggered by the typecheck checker
+                    continue
+                # filter defstmts to only pick the first one when there are
+                # several assignments in the same scope
+                scope = defstmts[0].scope()
+                defstmts = [
+                    stmt
+                    for i, stmt in enumerate(defstmts)
+                    if i == 0 or stmt.scope() is not scope
+                ]
+                # if there are still more than one, don't attempt to be smarter
+                # than we can be
+                if len(defstmts) == 1:
+                    defstmt = defstmts[0]
+                    # check that if the node is accessed in the same method as
+                    # it's defined, it's accessed after the initial assignment
+                    frame = defstmt.frame(future=True)
+                    lno = defstmt.fromlineno
+                    for _node in nodes_lst:
+                        if (
+                            _node.frame(future=True) is frame
+                            and _node.fromlineno < lno
+                            and not astroid.are_exclusive(
+                                _node.statement(future=True), defstmt, excs
+                            )
+                        ):
+                            self.add_message(
+                                "access-member-before-definition",
+                                node=_node,
+                                args=(attr, lno),
+                            )
+
+    def _check_first_arg_for_type(self, node, metaclass=0):
+        """Check the name of first argument, expect:.
+
+        * 'self' for a regular method
+        * 'cls' for a class method or a metaclass regular method (actually
+          valid-classmethod-first-arg value)
+        * 'mcs' for a metaclass class method (actually
+          valid-metaclass-classmethod-first-arg)
+        * not one of the above for a static method
+        """
+        # don't care about functions with unknown argument (builtins)
+        if node.args.args is None:
+            return
+        if node.args.posonlyargs:
+            first_arg = node.args.posonlyargs[0].name
+        elif node.args.args:
+            first_arg = node.argnames()[0]
+        else:
+            first_arg = None
+        self._first_attrs.append(first_arg)
+        first = self._first_attrs[-1]
+        # static method
+        if node.type == "staticmethod":
+            if (
+                first_arg == "self"
+                or first_arg in self.config.valid_classmethod_first_arg
+                or first_arg in self.config.valid_metaclass_classmethod_first_arg
+            ):
+                self.add_message("bad-staticmethod-argument", args=first, node=node)
+                return
+            self._first_attrs[-1] = None
+        # class / regular method with no args
+        elif not node.args.args and not node.args.posonlyargs:
+            self.add_message("no-method-argument", node=node)
+        # metaclass
+        elif metaclass:
+            # metaclass __new__ or classmethod
+            if node.type == "classmethod":
+                self._check_first_arg_config(
+                    first,
+                    self.config.valid_metaclass_classmethod_first_arg,
+                    node,
+                    "bad-mcs-classmethod-argument",
+                    node.name,
+                )
+            # metaclass regular method
+            else:
+                self._check_first_arg_config(
+                    first,
+                    self.config.valid_classmethod_first_arg,
+                    node,
+                    "bad-mcs-method-argument",
+                    node.name,
+                )
+        # regular class with class method
+        elif node.type == "classmethod" or node.name == "__class_getitem__":
+            self._check_first_arg_config(
+                first,
+                self.config.valid_classmethod_first_arg,
+                node,
+                "bad-classmethod-argument",
+                node.name,
+            )
+        # regular class with regular method without self as argument
+        elif first != "self":
+            self.add_message("no-self-argument", node=node)
+
+    def _check_first_arg_config(self, first, config, node, message, method_name):
+        if first not in config:
+            if len(config) == 1:
+                valid = repr(config[0])
+            else:
+                valid = ", ".join(repr(v) for v in config[:-1])
+                valid = f"{valid} or {config[-1]!r}"
+            self.add_message(message, args=(method_name, valid), node=node)
+
+    def _check_bases_classes(self, node):
+        """Check that the given class node implements abstract methods from
+        base classes
+        """
+
+        def is_abstract(method):
+            return method.is_abstract(pass_is_abstract=False)
+
+        # check if this class abstract
+        if class_is_abstract(node):
+            return
+
+        methods = sorted(
+            unimplemented_abstract_methods(node, is_abstract).items(),
+            key=lambda item: item[0],
+        )
+        for name, method in methods:
+            owner = method.parent.frame(future=True)
+            if owner is node:
+                continue
+            # owner is not this class, it must be a parent class
+            # check that the ancestor's method is not abstract
+            if name in node.locals:
+                # it is redefined as an attribute or with a descriptor
+                continue
+            self.add_message("abstract-method", node=node, args=(name, owner.name))
+
+    def _check_init(self, node: nodes.FunctionDef, klass_node: nodes.ClassDef) -> None:
+        """Check that the __init__ method call super or ancestors'__init__
+        method (unless it is used for type hinting with `typing.overload`)
+        """
+        if not self.linter.is_message_enabled(
+            "super-init-not-called"
+        ) and not self.linter.is_message_enabled("non-parent-init-called"):
+            return
+        to_call = _ancestors_to_call(klass_node)
+        not_called_yet = dict(to_call)
+        parents_with_called_inits: Set[bases.UnboundMethod] = set()
+        for stmt in node.nodes_of_class(nodes.Call):
+            expr = stmt.func
+            if not isinstance(expr, nodes.Attribute) or expr.attrname != "__init__":
+                continue
+            # skip the test if using super
+            if (
+                isinstance(expr.expr, nodes.Call)
+                and isinstance(expr.expr.func, nodes.Name)
+                and expr.expr.func.name == "super"
+            ):
+                return
+            try:
+                for klass in expr.expr.infer():
+                    if klass is astroid.Uninferable:
+                        continue
+                    # The inferred klass can be super(), which was
+                    # assigned to a variable and the `__init__`
+                    # was called later.
+                    #
+                    # base = super()
+                    # base.__init__(...)
+
+                    if (
+                        isinstance(klass, astroid.Instance)
+                        and isinstance(klass._proxied, nodes.ClassDef)
+                        and is_builtin_object(klass._proxied)
+                        and klass._proxied.name == "super"
+                    ):
+                        return
+                    if isinstance(klass, astroid.objects.Super):
+                        return
+                    try:
+                        method = not_called_yet.pop(klass)
+                        # Record that the class' init has been called
+                        parents_with_called_inits.add(node_frame_class(method))
+                    except KeyError:
+                        if klass not in to_call:
+                            self.add_message(
+                                "non-parent-init-called", node=expr, args=klass.name
+                            )
+            except astroid.InferenceError:
+                continue
+        for klass, method in not_called_yet.items():
+            # Check if the init of the class that defines this init has already
+            # been called.
+            if node_frame_class(method) in parents_with_called_inits:
+                return
+
+            # Return if klass is protocol
+            if klass.qname() in utils.TYPING_PROTOCOLS:
+                return
+
+            # Return if any of the klass' first-order bases is protocol
+            for base in klass.bases:
+                try:
+                    for inf_base in base.infer():
+                        if inf_base.qname() in utils.TYPING_PROTOCOLS:
+                            return
+                except astroid.InferenceError:
+                    continue
+
+            if decorated_with(node, ["typing.overload"]):
+                continue
+            cls = node_frame_class(method)
+            if klass.name == "object" or (cls and cls.name == "object"):
+                continue
+            self.add_message(
+                "super-init-not-called",
+                args=klass.name,
+                node=node,
+                confidence=INFERENCE,
+            )
+
+    def _check_signature(self, method1, refmethod, class_type, cls):
+        """Check that the signature of the two given methods match."""
+        if not (
+            isinstance(method1, nodes.FunctionDef)
+            and isinstance(refmethod, nodes.FunctionDef)
+        ):
+            self.add_message(
+                "method-check-failed", args=(method1, refmethod), node=method1
+            )
+            return
+
+        instance = cls.instantiate_class()
+        method1 = astroid.scoped_nodes.function_to_method(method1, instance)
+        refmethod = astroid.scoped_nodes.function_to_method(refmethod, instance)
+
+        # Don't care about functions with unknown argument (builtins).
+        if method1.args.args is None or refmethod.args.args is None:
+            return
+
+        # Ignore private to class methods.
+        if is_attr_private(method1.name):
+            return
+        # Ignore setters, they have an implicit extra argument,
+        # which shouldn't be taken in consideration.
+        if is_property_setter(method1):
+            return
+
+        arg_differ_output = _different_parameters(
+            refmethod, method1, dummy_parameter_regex=self._dummy_rgx
+        )
+        if len(arg_differ_output) > 0:
+            for msg in arg_differ_output:
+                if "Number" in msg:
+                    total_args_method1 = len(method1.args.args)
+                    if method1.args.vararg:
+                        total_args_method1 += 1
+                    if method1.args.kwarg:
+                        total_args_method1 += 1
+                    if method1.args.kwonlyargs:
+                        total_args_method1 += len(method1.args.kwonlyargs)
+                    total_args_refmethod = len(refmethod.args.args)
+                    if refmethod.args.vararg:
+                        total_args_refmethod += 1
+                    if refmethod.args.kwarg:
+                        total_args_refmethod += 1
+                    if refmethod.args.kwonlyargs:
+                        total_args_refmethod += len(refmethod.args.kwonlyargs)
+                    error_type = "arguments-differ"
+                    msg_args = (
+                        msg
+                        + f"was {total_args_refmethod} in '{refmethod.parent.frame().name}.{refmethod.name}' and "
+                        f"is now {total_args_method1} in",
+                        class_type,
+                        f"{method1.parent.frame().name}.{method1.name}",
+                    )
+                elif "renamed" in msg:
+                    error_type = "arguments-renamed"
+                    msg_args = (
+                        msg,
+                        class_type,
+                        f"{method1.parent.frame().name}.{method1.name}",
+                    )
+                else:
+                    error_type = "arguments-differ"
+                    msg_args = (
+                        msg,
+                        class_type,
+                        f"{method1.parent.frame().name}.{method1.name}",
+                    )
+                self.add_message(error_type, args=msg_args, node=method1)
+        elif (
+            len(method1.args.defaults) < len(refmethod.args.defaults)
+            and not method1.args.vararg
+        ):
+            self.add_message(
+                "signature-differs", args=(class_type, method1.name), node=method1
+            )
+
+    def _uses_mandatory_method_param(self, node):
+        """Check that attribute lookup name use first attribute variable name.
+
+        Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
+        """
+        return self._is_mandatory_method_param(node.expr)
+
+    def _is_mandatory_method_param(self, node: nodes.NodeNG) -> bool:
+        """Check if nodes.Name corresponds to first attribute variable name.
+
+        Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
+        Static methods return False.
+        """
+        if self._first_attrs:
+            first_attr = self._first_attrs[-1]
+        else:
+            # It's possible the function was already unregistered.
+            closest_func = utils.get_node_first_ancestor_of_type(
+                node, nodes.FunctionDef
+            )
+            if closest_func is None:
+                return False
+            if not closest_func.is_bound():
+                return False
+            if not closest_func.args.args:
+                return False
+            first_attr = closest_func.args.args[0].name
+        return isinstance(node, nodes.Name) and node.name == first_attr
+
+
+def _ancestors_to_call(
+    klass_node: nodes.ClassDef, method="__init__"
+) -> Dict[nodes.ClassDef, bases.UnboundMethod]:
+    """Return a dictionary where keys are the list of base classes providing
+    the queried method, and so that should/may be called from the method node
+    """
+    to_call: Dict[nodes.ClassDef, bases.UnboundMethod] = {}
+    for base_node in klass_node.ancestors(recurs=False):
+        try:
+            to_call[base_node] = next(base_node.igetattr(method))
+        except astroid.InferenceError:
+            continue
+    return to_call
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/classes/special_methods_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/classes/special_methods_checker.py
new file mode 100644
index 0000000..9a7c9a7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/classes/special_methods_checker.py
@@ -0,0 +1,391 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Special methods checker and helper function's module."""
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import (
+    PYMETHODS,
+    SPECIAL_METHODS_PARAMS,
+    check_messages,
+    decorated_with,
+    is_function_body_ellipsis,
+    safe_infer,
+)
+from pylint.interfaces import IAstroidChecker
+
+NEXT_METHOD = "__next__"
+
+
+def _safe_infer_call_result(node, caller, context=None):
+    """Safely infer the return value of a function.
+
+    Returns None if inference failed or if there is some ambiguity (more than
+    one node has been inferred). Otherwise, returns inferred value.
+    """
+    try:
+        inferit = node.infer_call_result(caller, context=context)
+        value = next(inferit)
+    except astroid.InferenceError:
+        return None  # inference failed
+    except StopIteration:
+        return None  # no values inferred
+    try:
+        next(inferit)
+        return None  # there is ambiguity on the inferred node
+    except astroid.InferenceError:
+        return None  # there is some kind of ambiguity
+    except StopIteration:
+        return value
+
+
+class SpecialMethodsChecker(BaseChecker):
+    """Checker which verifies that special methods
+    are implemented correctly.
+    """
+
+    __implements__ = (IAstroidChecker,)
+    name = "classes"
+    msgs = {
+        "E0301": (
+            "__iter__ returns non-iterator",
+            "non-iterator-returned",
+            "Used when an __iter__ method returns something which is not an "
+            f"iterable (i.e. has no `{NEXT_METHOD}` method)",
+            {
+                "old_names": [
+                    ("W0234", "old-non-iterator-returned-1"),
+                    ("E0234", "old-non-iterator-returned-2"),
+                ]
+            },
+        ),
+        "E0302": (
+            "The special method %r expects %s param(s), %d %s given",
+            "unexpected-special-method-signature",
+            "Emitted when a special method was defined with an "
+            "invalid number of parameters. If it has too few or "
+            "too many, it might not work at all.",
+            {"old_names": [("E0235", "bad-context-manager")]},
+        ),
+        "E0303": (
+            "__len__ does not return non-negative integer",
+            "invalid-length-returned",
+            "Used when a __len__ method returns something which is not a "
+            "non-negative integer",
+        ),
+        "E0304": (
+            "__bool__ does not return bool",
+            "invalid-bool-returned",
+            "Used when a __bool__ method returns something which is not a bool",
+        ),
+        "E0305": (
+            "__index__ does not return int",
+            "invalid-index-returned",
+            "Used when an __index__ method returns something which is not "
+            "an integer",
+        ),
+        "E0306": (
+            "__repr__ does not return str",
+            "invalid-repr-returned",
+            "Used when a __repr__ method returns something which is not a string",
+        ),
+        "E0307": (
+            "__str__ does not return str",
+            "invalid-str-returned",
+            "Used when a __str__ method returns something which is not a string",
+        ),
+        "E0308": (
+            "__bytes__ does not return bytes",
+            "invalid-bytes-returned",
+            "Used when a __bytes__ method returns something which is not bytes",
+        ),
+        "E0309": (
+            "__hash__ does not return int",
+            "invalid-hash-returned",
+            "Used when a __hash__ method returns something which is not an integer",
+        ),
+        "E0310": (
+            "__length_hint__ does not return non-negative integer",
+            "invalid-length-hint-returned",
+            "Used when a __length_hint__ method returns something which is not a "
+            "non-negative integer",
+        ),
+        "E0311": (
+            "__format__ does not return str",
+            "invalid-format-returned",
+            "Used when a __format__ method returns something which is not a string",
+        ),
+        "E0312": (
+            "__getnewargs__ does not return a tuple",
+            "invalid-getnewargs-returned",
+            "Used when a __getnewargs__ method returns something which is not "
+            "a tuple",
+        ),
+        "E0313": (
+            "__getnewargs_ex__ does not return a tuple containing (tuple, dict)",
+            "invalid-getnewargs-ex-returned",
+            "Used when a __getnewargs_ex__ method returns something which is not "
+            "of the form tuple(tuple, dict)",
+        ),
+    }
+    priority = -2
+
+    def __init__(self, linter=None):
+        super().__init__(linter)
+        self._protocol_map = {
+            "__iter__": self._check_iter,
+            "__len__": self._check_len,
+            "__bool__": self._check_bool,
+            "__index__": self._check_index,
+            "__repr__": self._check_repr,
+            "__str__": self._check_str,
+            "__bytes__": self._check_bytes,
+            "__hash__": self._check_hash,
+            "__length_hint__": self._check_length_hint,
+            "__format__": self._check_format,
+            "__getnewargs__": self._check_getnewargs,
+            "__getnewargs_ex__": self._check_getnewargs_ex,
+        }
+
+    @check_messages(
+        "unexpected-special-method-signature",
+        "non-iterator-returned",
+        "invalid-length-returned",
+        "invalid-bool-returned",
+        "invalid-index-returned",
+        "invalid-repr-returned",
+        "invalid-str-returned",
+        "invalid-bytes-returned",
+        "invalid-hash-returned",
+        "invalid-length-hint-returned",
+        "invalid-format-returned",
+        "invalid-getnewargs-returned",
+        "invalid-getnewargs-ex-returned",
+    )
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        if not node.is_method():
+            return
+
+        inferred = _safe_infer_call_result(node, node)
+        # Only want to check types that we are able to infer
+        if (
+            inferred
+            and node.name in self._protocol_map
+            and not is_function_body_ellipsis(node)
+        ):
+            self._protocol_map[node.name](node, inferred)
+
+        if node.name in PYMETHODS:
+            self._check_unexpected_method_signature(node)
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    def _check_unexpected_method_signature(self, node):
+        expected_params = SPECIAL_METHODS_PARAMS[node.name]
+
+        if expected_params is None:
+            # This can support a variable number of parameters.
+            return
+        if not node.args.args and not node.args.vararg:
+            # Method has no parameter, will be caught
+            # by no-method-argument.
+            return
+
+        if decorated_with(node, ["builtins.staticmethod"]):
+            # We expect to not take in consideration self.
+            all_args = node.args.args
+        else:
+            all_args = node.args.args[1:]
+        mandatory = len(all_args) - len(node.args.defaults)
+        optional = len(node.args.defaults)
+        current_params = mandatory + optional
+
+        if isinstance(expected_params, tuple):
+            # The expected number of parameters can be any value from this
+            # tuple, although the user should implement the method
+            # to take all of them in consideration.
+            emit = mandatory not in expected_params
+            # pylint: disable-next=consider-using-f-string
+            expected_params = "between %d or %d" % expected_params
+        else:
+            # If the number of mandatory parameters doesn't
+            # suffice, the expected parameters for this
+            # function will be deduced from the optional
+            # parameters.
+            rest = expected_params - mandatory
+            if rest == 0:
+                emit = False
+            elif rest < 0:
+                emit = True
+            elif rest > 0:
+                emit = not ((optional - rest) >= 0 or node.args.vararg)
+
+        if emit:
+            verb = "was" if current_params <= 1 else "were"
+            self.add_message(
+                "unexpected-special-method-signature",
+                args=(node.name, expected_params, current_params, verb),
+                node=node,
+            )
+
+    @staticmethod
+    def _is_wrapped_type(node, type_):
+        return (
+            isinstance(node, astroid.Instance)
+            and node.name == type_
+            and not isinstance(node, nodes.Const)
+        )
+
+    @staticmethod
+    def _is_int(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "int"):
+            return True
+
+        return isinstance(node, nodes.Const) and isinstance(node.value, int)
+
+    @staticmethod
+    def _is_str(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "str"):
+            return True
+
+        return isinstance(node, nodes.Const) and isinstance(node.value, str)
+
+    @staticmethod
+    def _is_bool(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "bool"):
+            return True
+
+        return isinstance(node, nodes.Const) and isinstance(node.value, bool)
+
+    @staticmethod
+    def _is_bytes(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "bytes"):
+            return True
+
+        return isinstance(node, nodes.Const) and isinstance(node.value, bytes)
+
+    @staticmethod
+    def _is_tuple(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
+            return True
+
+        return isinstance(node, nodes.Const) and isinstance(node.value, tuple)
+
+    @staticmethod
+    def _is_dict(node):
+        if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
+            return True
+
+        return isinstance(node, nodes.Const) and isinstance(node.value, dict)
+
+    @staticmethod
+    def _is_iterator(node):
+        if node is astroid.Uninferable:
+            # Just ignore Uninferable objects.
+            return True
+        if isinstance(node, astroid.bases.Generator):
+            # Generators can be iterated.
+            return True
+        # pylint: disable-next=fixme
+        # TODO: Should be covered by https://github.com/PyCQA/astroid/pull/1475
+        if isinstance(node, nodes.ComprehensionScope):
+            # Comprehensions can be iterated.
+            return True
+
+        if isinstance(node, astroid.Instance):
+            try:
+                node.local_attr(NEXT_METHOD)
+                return True
+            except astroid.NotFoundError:
+                pass
+        elif isinstance(node, nodes.ClassDef):
+            metaclass = node.metaclass()
+            if metaclass and isinstance(metaclass, nodes.ClassDef):
+                try:
+                    metaclass.local_attr(NEXT_METHOD)
+                    return True
+                except astroid.NotFoundError:
+                    pass
+        return False
+
+    def _check_iter(self, node, inferred):
+        if not self._is_iterator(inferred):
+            self.add_message("non-iterator-returned", node=node)
+
+    def _check_len(self, node, inferred):
+        if not self._is_int(inferred):
+            self.add_message("invalid-length-returned", node=node)
+        elif isinstance(inferred, nodes.Const) and inferred.value < 0:
+            self.add_message("invalid-length-returned", node=node)
+
+    def _check_bool(self, node, inferred):
+        if not self._is_bool(inferred):
+            self.add_message("invalid-bool-returned", node=node)
+
+    def _check_index(self, node, inferred):
+        if not self._is_int(inferred):
+            self.add_message("invalid-index-returned", node=node)
+
+    def _check_repr(self, node, inferred):
+        if not self._is_str(inferred):
+            self.add_message("invalid-repr-returned", node=node)
+
+    def _check_str(self, node, inferred):
+        if not self._is_str(inferred):
+            self.add_message("invalid-str-returned", node=node)
+
+    def _check_bytes(self, node, inferred):
+        if not self._is_bytes(inferred):
+            self.add_message("invalid-bytes-returned", node=node)
+
+    def _check_hash(self, node, inferred):
+        if not self._is_int(inferred):
+            self.add_message("invalid-hash-returned", node=node)
+
+    def _check_length_hint(self, node, inferred):
+        if not self._is_int(inferred):
+            self.add_message("invalid-length-hint-returned", node=node)
+        elif isinstance(inferred, nodes.Const) and inferred.value < 0:
+            self.add_message("invalid-length-hint-returned", node=node)
+
+    def _check_format(self, node, inferred):
+        if not self._is_str(inferred):
+            self.add_message("invalid-format-returned", node=node)
+
+    def _check_getnewargs(self, node, inferred):
+        if not self._is_tuple(inferred):
+            self.add_message("invalid-getnewargs-returned", node=node)
+
+    def _check_getnewargs_ex(self, node, inferred):
+        if not self._is_tuple(inferred):
+            self.add_message("invalid-getnewargs-ex-returned", node=node)
+            return
+
+        if not isinstance(inferred, nodes.Tuple):
+            # If it's not an astroid.Tuple we can't analyze it further
+            return
+
+        found_error = False
+
+        if len(inferred.elts) != 2:
+            found_error = True
+        else:
+            for arg, check in (
+                (inferred.elts[0], self._is_tuple),
+                (inferred.elts[1], self._is_dict),
+            ):
+
+                if isinstance(arg, nodes.Call):
+                    arg = safe_infer(arg)
+
+                if arg and arg is not astroid.Uninferable:
+                    if not check(arg):
+                        found_error = True
+                        break
+
+        if found_error:
+            self.add_message("invalid-getnewargs-ex-returned", node=node)
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/deprecated.py b/myenv/lib/python3.9/site-packages/pylint/checkers/deprecated.py
new file mode 100644
index 0000000..299922f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/deprecated.py
@@ -0,0 +1,247 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Checker mixin for deprecated functionality."""
+from itertools import chain
+from typing import Any, Container, Iterable, Tuple, Union
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import utils
+from pylint.checkers.base_checker import BaseChecker
+from pylint.checkers.utils import get_import_name, infer_all, safe_infer
+
+ACCEPTABLE_NODES = (
+    astroid.BoundMethod,
+    astroid.UnboundMethod,
+    nodes.FunctionDef,
+    nodes.ClassDef,
+)
+
+
+class DeprecatedMixin(BaseChecker):
+    """A mixin implementing logic for checking deprecated symbols.
+
+    A class implementing mixin must define "deprecated-method" Message.
+    """
+
+    msgs: Any = {
+        "W1505": (
+            "Using deprecated method %s()",
+            "deprecated-method",
+            "The method is marked as deprecated and will be removed in the future.",
+        ),
+        "W1511": (
+            "Using deprecated argument %s of method %s()",
+            "deprecated-argument",
+            "The argument is marked as deprecated and will be removed in the future.",
+        ),
+        "W0402": (
+            "Uses of a deprecated module %r",
+            "deprecated-module",
+            "A module marked as deprecated is imported.",
+        ),
+        "W1512": (
+            "Using deprecated class %s of module %s",
+            "deprecated-class",
+            "The class is marked as deprecated and will be removed in the future.",
+        ),
+        "W1513": (
+            "Using deprecated decorator %s()",
+            "deprecated-decorator",
+            "The decorator is marked as deprecated and will be removed in the future.",
+        ),
+    }
+
+    @utils.check_messages(
+        "deprecated-method",
+        "deprecated-argument",
+        "deprecated-class",
+    )
+    def visit_call(self, node: nodes.Call) -> None:
+        """Called when a :class:`nodes.Call` node is visited."""
+        self.check_deprecated_class_in_call(node)
+        for inferred in infer_all(node.func):
+            # Calling entry point for deprecation check logic.
+            self.check_deprecated_method(node, inferred)
+
+    @utils.check_messages(
+        "deprecated-module",
+        "deprecated-class",
+    )
+    def visit_import(self, node: nodes.Import) -> None:
+        """Triggered when an import statement is seen."""
+        for name in (name for name, _ in node.names):
+            self.check_deprecated_module(node, name)
+            if "." in name:
+                # Checking deprecation for import module with class
+                mod_name, class_name = name.split(".", 1)
+                self.check_deprecated_class(node, mod_name, (class_name,))
+
+    def deprecated_decorators(self) -> Iterable:
+        """Callback returning the deprecated decorators.
+
+        Returns:
+            collections.abc.Container of deprecated decorator names.
+        """
+        # pylint: disable=no-self-use
+        return ()
+
+    @utils.check_messages("deprecated-decorator")
+    def visit_decorators(self, node: nodes.Decorators) -> None:
+        """Triggered when a decorator statement is seen."""
+        children = list(node.get_children())
+        if not children:
+            return
+        if isinstance(children[0], nodes.Call):
+            inf = safe_infer(children[0].func)
+        else:
+            inf = safe_infer(children[0])
+        qname = inf.qname() if inf else None
+        if qname in self.deprecated_decorators():
+            self.add_message("deprecated-decorator", node=node, args=qname)
+
+    @utils.check_messages(
+        "deprecated-module",
+        "deprecated-class",
+    )
+    def visit_importfrom(self, node: nodes.ImportFrom) -> None:
+        """Triggered when a from statement is seen."""
+        basename = node.modname
+        basename = get_import_name(node, basename)
+        self.check_deprecated_module(node, basename)
+        class_names = (name for name, _ in node.names)
+        self.check_deprecated_class(node, basename, class_names)
+
+    def deprecated_methods(self) -> Container[str]:
+        """Callback returning the deprecated methods/functions.
+
+        Returns:
+            collections.abc.Container of deprecated function/method names.
+        """
+        # pylint: disable=no-self-use
+        return ()
+
+    def deprecated_arguments(
+        self, method: str
+    ) -> Iterable[Tuple[Union[int, None], str]]:
+        """Callback returning the deprecated arguments of method/function.
+
+        Args:
+            method (str): name of function/method checked for deprecated arguments
+
+        Returns:
+            collections.abc.Iterable in form:
+                ((POSITION1, PARAM1), (POSITION2: PARAM2) ...)
+            where
+                * POSITIONX - position of deprecated argument PARAMX in function definition.
+                  If argument is keyword-only, POSITIONX should be None.
+                * PARAMX - name of the deprecated argument.
+            E.g. suppose function:
+
+            .. code-block:: python
+                def bar(arg1, arg2, arg3, arg4, arg5='spam')
+
+            with deprecated arguments `arg2` and `arg4`. `deprecated_arguments` should return:
+
+            .. code-block:: python
+                ((1, 'arg2'), (3, 'arg4'))
+        """
+        # pylint: disable=no-self-use
+        # pylint: disable=unused-argument
+        return ()
+
+    def deprecated_modules(self) -> Iterable:
+        """Callback returning the deprecated modules.
+
+        Returns:
+            collections.abc.Container of deprecated module names.
+        """
+        # pylint: disable=no-self-use
+        return ()
+
+    def deprecated_classes(self, module: str) -> Iterable:
+        """Callback returning the deprecated classes of module.
+
+        Args:
+            module (str): name of module checked for deprecated classes
+
+        Returns:
+            collections.abc.Container of deprecated class names.
+        """
+        # pylint: disable=no-self-use
+        # pylint: disable=unused-argument
+        return ()
+
+    def check_deprecated_module(self, node, mod_path):
+        """Checks if the module is deprecated."""
+        for mod_name in self.deprecated_modules():
+            if mod_path == mod_name or mod_path.startswith(mod_name + "."):
+                self.add_message("deprecated-module", node=node, args=mod_path)
+
+    def check_deprecated_method(self, node, inferred):
+        """Executes the checker for the given node.
+
+        This method should be called from the checker implementing this mixin.
+        """
+
+        # Reject nodes which aren't of interest to us.
+        if not isinstance(inferred, ACCEPTABLE_NODES):
+            return
+
+        if isinstance(node.func, nodes.Attribute):
+            func_name = node.func.attrname
+        elif isinstance(node.func, nodes.Name):
+            func_name = node.func.name
+        else:
+            # Not interested in other nodes.
+            return
+
+        if hasattr(inferred.parent, "qname") and inferred.parent.qname():
+            # Handling the situation when deprecated function is
+            # alias to existing function.
+            qnames = {
+                inferred.qname(),
+                f"{inferred.parent.qname()}.{func_name}",
+                func_name,
+            }
+        else:
+            qnames = {inferred.qname(), func_name}
+        if any(name in self.deprecated_methods() for name in qnames):
+            self.add_message("deprecated-method", node=node, args=(func_name,))
+            return
+        num_of_args = len(node.args)
+        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
+        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
+        for position, arg_name in chain(*deprecated_arguments):
+            if arg_name in kwargs:
+                # function was called with deprecated argument as keyword argument
+                self.add_message(
+                    "deprecated-argument", node=node, args=(arg_name, func_name)
+                )
+            elif position is not None and position < num_of_args:
+                # function was called with deprecated argument as positional argument
+                self.add_message(
+                    "deprecated-argument", node=node, args=(arg_name, func_name)
+                )
+
+    def check_deprecated_class(self, node, mod_name, class_names):
+        """Checks if the class is deprecated."""
+
+        for class_name in class_names:
+            if class_name in self.deprecated_classes(mod_name):
+                self.add_message(
+                    "deprecated-class", node=node, args=(class_name, mod_name)
+                )
+
+    def check_deprecated_class_in_call(self, node):
+        """Checks if call the deprecated class."""
+
+        if isinstance(node.func, nodes.Attribute) and isinstance(
+            node.func.expr, nodes.Name
+        ):
+            mod_name = node.func.expr.name
+            class_name = node.func.attrname
+            self.check_deprecated_class(node, mod_name, (class_name,))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/design_analysis.py b/myenv/lib/python3.9/site-packages/pylint/checkers/design_analysis.py
new file mode 100644
index 0000000..dcc43dc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/design_analysis.py
@@ -0,0 +1,651 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Check for signs of poor design."""
+
+import re
+import sys
+from collections import defaultdict
+from typing import TYPE_CHECKING, FrozenSet, Iterator, List, Set, cast
+
+import astroid
+from astroid import nodes
+
+from pylint import utils
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker
+
+if sys.version_info >= (3, 8):
+    from functools import cached_property
+else:
+    from astroid.decorators import cachedproperty as cached_property
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+MSGS = {  # pylint: disable=consider-using-namedtuple-or-dataclass
+    "R0901": (
+        "Too many ancestors (%s/%s)",
+        "too-many-ancestors",
+        "Used when class has too many parent classes, try to reduce "
+        "this to get a simpler (and so easier to use) class.",
+    ),
+    "R0902": (
+        "Too many instance attributes (%s/%s)",
+        "too-many-instance-attributes",
+        "Used when class has too many instance attributes, try to reduce "
+        "this to get a simpler (and so easier to use) class.",
+    ),
+    "R0903": (
+        "Too few public methods (%s/%s)",
+        "too-few-public-methods",
+        "Used when class has too few public methods, so be sure it's "
+        "really worth it.",
+    ),
+    "R0904": (
+        "Too many public methods (%s/%s)",
+        "too-many-public-methods",
+        "Used when class has too many public methods, try to reduce "
+        "this to get a simpler (and so easier to use) class.",
+    ),
+    "R0911": (
+        "Too many return statements (%s/%s)",
+        "too-many-return-statements",
+        "Used when a function or method has too many return statement, "
+        "making it hard to follow.",
+    ),
+    "R0912": (
+        "Too many branches (%s/%s)",
+        "too-many-branches",
+        "Used when a function or method has too many branches, "
+        "making it hard to follow.",
+    ),
+    "R0913": (
+        "Too many arguments (%s/%s)",
+        "too-many-arguments",
+        "Used when a function or method takes too many arguments.",
+    ),
+    "R0914": (
+        "Too many local variables (%s/%s)",
+        "too-many-locals",
+        "Used when a function or method has too many local variables.",
+    ),
+    "R0915": (
+        "Too many statements (%s/%s)",
+        "too-many-statements",
+        "Used when a function or method has too many statements. You "
+        "should then split it in smaller functions / methods.",
+    ),
+    "R0916": (
+        "Too many boolean expressions in if statement (%s/%s)",
+        "too-many-boolean-expressions",
+        "Used when an if statement contains too many boolean expressions.",
+    ),
+}
+SPECIAL_OBJ = re.compile("^_{2}[a-z]+_{2}$")
+DATACLASSES_DECORATORS = frozenset({"dataclass", "attrs"})
+DATACLASS_IMPORT = "dataclasses"
+TYPING_NAMEDTUPLE = "typing.NamedTuple"
+TYPING_TYPEDDICT = "typing.TypedDict"
+
+# Set of stdlib classes to ignore when calculating number of ancestors
+STDLIB_CLASSES_IGNORE_ANCESTOR = frozenset(
+    (
+        "builtins.object",
+        "builtins.tuple",
+        "builtins.dict",
+        "builtins.list",
+        "builtins.set",
+        "bulitins.frozenset",
+        "collections.ChainMap",
+        "collections.Counter",
+        "collections.OrderedDict",
+        "collections.UserDict",
+        "collections.UserList",
+        "collections.UserString",
+        "collections.defaultdict",
+        "collections.deque",
+        "collections.namedtuple",
+        "_collections_abc.Awaitable",
+        "_collections_abc.Coroutine",
+        "_collections_abc.AsyncIterable",
+        "_collections_abc.AsyncIterator",
+        "_collections_abc.AsyncGenerator",
+        "_collections_abc.Hashable",
+        "_collections_abc.Iterable",
+        "_collections_abc.Iterator",
+        "_collections_abc.Generator",
+        "_collections_abc.Reversible",
+        "_collections_abc.Sized",
+        "_collections_abc.Container",
+        "_collections_abc.Collection",
+        "_collections_abc.Set",
+        "_collections_abc.MutableSet",
+        "_collections_abc.Mapping",
+        "_collections_abc.MutableMapping",
+        "_collections_abc.MappingView",
+        "_collections_abc.KeysView",
+        "_collections_abc.ItemsView",
+        "_collections_abc.ValuesView",
+        "_collections_abc.Sequence",
+        "_collections_abc.MutableSequence",
+        "_collections_abc.ByteString",
+        "typing.Tuple",
+        "typing.List",
+        "typing.Dict",
+        "typing.Set",
+        "typing.FrozenSet",
+        "typing.Deque",
+        "typing.DefaultDict",
+        "typing.OrderedDict",
+        "typing.Counter",
+        "typing.ChainMap",
+        "typing.Awaitable",
+        "typing.Coroutine",
+        "typing.AsyncIterable",
+        "typing.AsyncIterator",
+        "typing.AsyncGenerator",
+        "typing.Iterable",
+        "typing.Iterator",
+        "typing.Generator",
+        "typing.Reversible",
+        "typing.Container",
+        "typing.Collection",
+        "typing.AbstractSet",
+        "typing.MutableSet",
+        "typing.Mapping",
+        "typing.MutableMapping",
+        "typing.Sequence",
+        "typing.MutableSequence",
+        "typing.ByteString",
+        "typing.MappingView",
+        "typing.KeysView",
+        "typing.ItemsView",
+        "typing.ValuesView",
+        "typing.ContextManager",
+        "typing.AsyncContextManager",
+        "typing.Hashable",
+        "typing.Sized",
+    )
+)
+
+
+def _is_exempt_from_public_methods(node: astroid.ClassDef) -> bool:
+    """Check if a class is exempt from too-few-public-methods."""
+
+    # If it's a typing.Namedtuple, typing.TypedDict or an Enum
+    for ancestor in node.ancestors():
+        if ancestor.name == "Enum" and ancestor.root().name == "enum":
+            return True
+        if ancestor.qname() in (TYPING_NAMEDTUPLE, TYPING_TYPEDDICT):
+            return True
+
+    # Or if it's a dataclass
+    if not node.decorators:
+        return False
+
+    root_locals = set(node.root().locals)
+    for decorator in node.decorators.nodes:
+        if isinstance(decorator, astroid.Call):
+            decorator = decorator.func
+        if not isinstance(decorator, (astroid.Name, astroid.Attribute)):
+            continue
+        if isinstance(decorator, astroid.Name):
+            name = decorator.name
+        else:
+            name = decorator.attrname
+        if name in DATACLASSES_DECORATORS and (
+            root_locals.intersection(DATACLASSES_DECORATORS)
+            or DATACLASS_IMPORT in root_locals
+        ):
+            return True
+    return False
+
+
+def _count_boolean_expressions(bool_op):
+    """Counts the number of boolean expressions in BoolOp `bool_op` (recursive).
+
+    example: a and (b or c or (d and e)) ==> 5 boolean expressions
+    """
+    nb_bool_expr = 0
+    for bool_expr in bool_op.get_children():
+        if isinstance(bool_expr, astroid.BoolOp):
+            nb_bool_expr += _count_boolean_expressions(bool_expr)
+        else:
+            nb_bool_expr += 1
+    return nb_bool_expr
+
+
+def _count_methods_in_class(node):
+    all_methods = sum(1 for method in node.methods() if not method.name.startswith("_"))
+    # Special methods count towards the number of public methods,
+    # but don't count towards there being too many methods.
+    for method in node.mymethods():
+        if SPECIAL_OBJ.search(method.name) and method.name != "__init__":
+            all_methods += 1
+    return all_methods
+
+
+def _get_parents_iter(
+    node: nodes.ClassDef, ignored_parents: FrozenSet[str]
+) -> Iterator[nodes.ClassDef]:
+    r"""Get parents of ``node``, excluding ancestors of ``ignored_parents``.
+
+    If we have the following inheritance diagram:
+
+             F
+            /
+        D  E
+         \/
+          B  C
+           \/
+            A      # class A(B, C): ...
+
+    And ``ignored_parents`` is ``{"E"}``, then this function will return
+    ``{A, B, C, D}`` -- both ``E`` and its ancestors are excluded.
+    """
+    parents: Set[nodes.ClassDef] = set()
+    to_explore = cast(List[nodes.ClassDef], list(node.ancestors(recurs=False)))
+    while to_explore:
+        parent = to_explore.pop()
+        if parent.qname() in ignored_parents:
+            continue
+        if parent not in parents:
+            # This guard might appear to be performing the same function as
+            # adding the resolved parents to a set to eliminate duplicates
+            # (legitimate due to diamond inheritance patterns), but its
+            # additional purpose is to prevent cycles (not normally possible,
+            # but potential due to inference) and thus guarantee termination
+            # of the while-loop
+            yield parent
+            parents.add(parent)
+            to_explore.extend(parent.ancestors(recurs=False))
+
+
+def _get_parents(
+    node: nodes.ClassDef, ignored_parents: FrozenSet[str]
+) -> Set[nodes.ClassDef]:
+    return set(_get_parents_iter(node, ignored_parents))
+
+
+class MisdesignChecker(BaseChecker):
+    """Checker of potential misdesigns.
+
+    Checks for sign of poor/misdesign:
+    * number of methods, attributes, local variables...
+    * size, complexity of functions, methods
+    """
+
+    __implements__ = (IAstroidChecker,)
+
+    # configuration section name
+    name = "design"
+    # messages
+    msgs = MSGS
+    priority = -2
+    # configuration options
+    options = (
+        (
+            "max-args",
+            {
+                "default": 5,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "Maximum number of arguments for function / method.",
+            },
+        ),
+        (
+            "max-locals",
+            {
+                "default": 15,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "Maximum number of locals for function / method body.",
+            },
+        ),
+        (
+            "max-returns",
+            {
+                "default": 6,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "Maximum number of return / yield for function / "
+                "method body.",
+            },
+        ),
+        (
+            "max-branches",
+            {
+                "default": 12,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "Maximum number of branch for function / method body.",
+            },
+        ),
+        (
+            "max-statements",
+            {
+                "default": 50,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "Maximum number of statements in function / method body.",
+            },
+        ),
+        (
+            "max-parents",
+            {
+                "default": 7,
+                "type": "int",
+                "metavar": "<num>",
+                "help": "Maximum number of parents for a class (see R0901).",
+            },
+        ),
+        (
+            "ignored-parents",
+            {
+                "default": (),
+                "type": "csv",
+                "metavar": "<comma separated list of class names>",
+                "help": "List of qualified class names to ignore when counting class parents (see R0901)",
+            },
+        ),
+        (
+            "max-attributes",
+            {
+                "default": 7,
+                "type": "int",
+                "metavar": "<num>",
+                "help": "Maximum number of attributes for a class \
+(see R0902).",
+            },
+        ),
+        (
+            "min-public-methods",
+            {
+                "default": 2,
+                "type": "int",
+                "metavar": "<num>",
+                "help": "Minimum number of public methods for a class \
+(see R0903).",
+            },
+        ),
+        (
+            "max-public-methods",
+            {
+                "default": 20,
+                "type": "int",
+                "metavar": "<num>",
+                "help": "Maximum number of public methods for a class \
+(see R0904).",
+            },
+        ),
+        (
+            "max-bool-expr",
+            {
+                "default": 5,
+                "type": "int",
+                "metavar": "<num>",
+                "help": "Maximum number of boolean expressions in an if "
+                "statement (see R0916).",
+            },
+        ),
+        (
+            "exclude-too-few-public-methods",
+            {
+                "default": [],
+                "type": "regexp_csv",
+                "metavar": "<pattern>[,<pattern>...]",
+                "help": "List of regular expressions of class ancestor names "
+                "to ignore when counting public methods (see R0903)",
+            },
+        ),
+    )
+
+    def __init__(self, linter=None):
+        super().__init__(linter)
+        self._returns = None
+        self._branches = None
+        self._stmts = None
+
+    def open(self):
+        """Initialize visit variables."""
+        self.linter.stats.reset_node_count()
+        self._returns = []
+        self._branches = defaultdict(int)
+        self._stmts = []
+        self._exclude_too_few_public_methods = utils.get_global_option(
+            self, "exclude-too-few-public-methods", default=[]
+        )
+
+    def _inc_all_stmts(self, amount):
+        for i, _ in enumerate(self._stmts):
+            self._stmts[i] += amount
+
+    @cached_property
+    def _ignored_argument_names(self):
+        return utils.get_global_option(self, "ignored-argument-names", default=None)
+
+    @check_messages(
+        "too-many-ancestors",
+        "too-many-instance-attributes",
+        "too-few-public-methods",
+        "too-many-public-methods",
+    )
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        """Check size of inheritance hierarchy and number of instance attributes."""
+        parents = _get_parents(
+            node, STDLIB_CLASSES_IGNORE_ANCESTOR.union(self.config.ignored_parents)
+        )
+        nb_parents = len(parents)
+        if nb_parents > self.config.max_parents:
+            self.add_message(
+                "too-many-ancestors",
+                node=node,
+                args=(nb_parents, self.config.max_parents),
+            )
+
+        if len(node.instance_attrs) > self.config.max_attributes:
+            self.add_message(
+                "too-many-instance-attributes",
+                node=node,
+                args=(len(node.instance_attrs), self.config.max_attributes),
+            )
+
+    @check_messages("too-few-public-methods", "too-many-public-methods")
+    def leave_classdef(self, node: nodes.ClassDef) -> None:
+        """Check number of public methods."""
+        my_methods = sum(
+            1 for method in node.mymethods() if not method.name.startswith("_")
+        )
+
+        # Does the class contain less than n public methods ?
+        # This checks only the methods defined in the current class,
+        # since the user might not have control over the classes
+        # from the ancestors. It avoids some false positives
+        # for classes such as unittest.TestCase, which provides
+        # a lot of assert methods. It doesn't make sense to warn
+        # when the user subclasses TestCase to add his own tests.
+        if my_methods > self.config.max_public_methods:
+            self.add_message(
+                "too-many-public-methods",
+                node=node,
+                args=(my_methods, self.config.max_public_methods),
+            )
+
+        # Stop here if the class is excluded via configuration.
+        if node.type == "class" and self._exclude_too_few_public_methods:
+            for ancestor in node.ancestors():
+                if any(
+                    pattern.match(ancestor.qname())
+                    for pattern in self._exclude_too_few_public_methods
+                ):
+                    return
+
+        # Stop here for exception, metaclass, interface classes and other
+        # classes for which we don't need to count the methods.
+        if node.type != "class" or _is_exempt_from_public_methods(node):
+            return
+
+        # Does the class contain more than n public methods ?
+        # This checks all the methods defined by ancestors and
+        # by the current class.
+        all_methods = _count_methods_in_class(node)
+        if all_methods < self.config.min_public_methods:
+            self.add_message(
+                "too-few-public-methods",
+                node=node,
+                args=(all_methods, self.config.min_public_methods),
+            )
+
+    @check_messages(
+        "too-many-return-statements",
+        "too-many-branches",
+        "too-many-arguments",
+        "too-many-locals",
+        "too-many-statements",
+        "keyword-arg-before-vararg",
+    )
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        """Check function name, docstring, arguments, redefinition,
+        variable names, max locals
+        """
+        # init branch and returns counters
+        self._returns.append(0)
+        # check number of arguments
+        args = node.args.args
+        ignored_argument_names = self._ignored_argument_names
+        if args is not None:
+            ignored_args_num = 0
+            if ignored_argument_names:
+                ignored_args_num = sum(
+                    1 for arg in args if ignored_argument_names.match(arg.name)
+                )
+
+            argnum = len(args) - ignored_args_num
+            if argnum > self.config.max_args:
+                self.add_message(
+                    "too-many-arguments",
+                    node=node,
+                    args=(len(args), self.config.max_args),
+                )
+        else:
+            ignored_args_num = 0
+        # check number of local variables
+        locnum = len(node.locals) - ignored_args_num
+        if locnum > self.config.max_locals:
+            self.add_message(
+                "too-many-locals", node=node, args=(locnum, self.config.max_locals)
+            )
+        # init new statements counter
+        self._stmts.append(1)
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    @check_messages(
+        "too-many-return-statements",
+        "too-many-branches",
+        "too-many-arguments",
+        "too-many-locals",
+        "too-many-statements",
+    )
+    def leave_functiondef(self, node: nodes.FunctionDef) -> None:
+        """Most of the work is done here on close:
+        checks for max returns, branch, return in __init__
+        """
+        returns = self._returns.pop()
+        if returns > self.config.max_returns:
+            self.add_message(
+                "too-many-return-statements",
+                node=node,
+                args=(returns, self.config.max_returns),
+            )
+        branches = self._branches[node]
+        if branches > self.config.max_branches:
+            self.add_message(
+                "too-many-branches",
+                node=node,
+                args=(branches, self.config.max_branches),
+            )
+        # check number of statements
+        stmts = self._stmts.pop()
+        if stmts > self.config.max_statements:
+            self.add_message(
+                "too-many-statements",
+                node=node,
+                args=(stmts, self.config.max_statements),
+            )
+
+    leave_asyncfunctiondef = leave_functiondef
+
+    def visit_return(self, _: nodes.Return) -> None:
+        """Count number of returns."""
+        if not self._returns:
+            return  # return outside function, reported by the base checker
+        self._returns[-1] += 1
+
+    def visit_default(self, node: nodes.NodeNG) -> None:
+        """Default visit method -> increments the statements counter if
+        necessary
+        """
+        if node.is_statement:
+            self._inc_all_stmts(1)
+
+    def visit_tryexcept(self, node: nodes.TryExcept) -> None:
+        """Increments the branches counter."""
+        branches = len(node.handlers)
+        if node.orelse:
+            branches += 1
+        self._inc_branch(node, branches)
+        self._inc_all_stmts(branches)
+
+    def visit_tryfinally(self, node: nodes.TryFinally) -> None:
+        """Increments the branches counter."""
+        self._inc_branch(node, 2)
+        self._inc_all_stmts(2)
+
+    @check_messages("too-many-boolean-expressions")
+    def visit_if(self, node: nodes.If) -> None:
+        """Increments the branches counter and checks boolean expressions."""
+        self._check_boolean_expressions(node)
+        branches = 1
+        # don't double count If nodes coming from some 'elif'
+        if node.orelse and (
+            len(node.orelse) > 1 or not isinstance(node.orelse[0], astroid.If)
+        ):
+            branches += 1
+        self._inc_branch(node, branches)
+        self._inc_all_stmts(branches)
+
+    def _check_boolean_expressions(self, node):
+        """Go through "if" node `node` and count its boolean expressions
+        if the 'if' node test is a BoolOp node
+        """
+        condition = node.test
+        if not isinstance(condition, astroid.BoolOp):
+            return
+        nb_bool_expr = _count_boolean_expressions(condition)
+        if nb_bool_expr > self.config.max_bool_expr:
+            self.add_message(
+                "too-many-boolean-expressions",
+                node=condition,
+                args=(nb_bool_expr, self.config.max_bool_expr),
+            )
+
+    def visit_while(self, node: nodes.While) -> None:
+        """Increments the branches counter."""
+        branches = 1
+        if node.orelse:
+            branches += 1
+        self._inc_branch(node, branches)
+
+    visit_for = visit_while
+
+    def _inc_branch(self, node, branchesnum=1):
+        """Increments the branches counter."""
+        self._branches[node.scope()] += branchesnum
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(MisdesignChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/ellipsis_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/ellipsis_checker.py
new file mode 100644
index 0000000..7a1298a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/ellipsis_checker.py
@@ -0,0 +1,57 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Ellipsis checker for Python code."""
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class EllipsisChecker(BaseChecker):
+    __implements__ = (IAstroidChecker,)
+    name = "unnecessary_ellipsis"
+    msgs = {
+        "W2301": (
+            "Unnecessary ellipsis constant",
+            "unnecessary-ellipsis",
+            "Used when the ellipsis constant is encountered and can be avoided. "
+            "A line of code consisting of an ellipsis is unnecessary if "
+            "there is a docstring on the preceding line or if there is a "
+            "statement in the same scope.",
+        )
+    }
+
+    @check_messages("unnecessary-ellipsis")
+    def visit_const(self, node: nodes.Const) -> None:
+        """Check if the ellipsis constant is used unnecessarily.
+
+        Emits a warning when:
+         - A line consisting of an ellipsis is preceded by a docstring.
+         - A statement exists in the same scope as the ellipsis.
+           For example: A function consisting of an ellipsis followed by a
+           return statement on the next line.
+        """
+        if (
+            node.pytype() == "builtins.Ellipsis"
+            and isinstance(node.parent, nodes.Expr)
+            and (
+                (
+                    isinstance(node.parent.parent, (nodes.ClassDef, nodes.FunctionDef))
+                    and node.parent.parent.doc_node
+                )
+                or len(node.parent.parent.body) > 1
+            )
+        ):
+            self.add_message("unnecessary-ellipsis", node=node)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(EllipsisChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/exceptions.py b/myenv/lib/python3.9/site-packages/pylint/checkers/exceptions.py
new file mode 100644
index 0000000..9ef9ea4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/exceptions.py
@@ -0,0 +1,544 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Checks for various exception related errors."""
+import builtins
+import inspect
+from typing import TYPE_CHECKING, Any, List, Optional
+
+import astroid
+from astroid import nodes, objects
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+def _builtin_exceptions():
+    def predicate(obj):
+        return isinstance(obj, type) and issubclass(obj, BaseException)
+
+    members = inspect.getmembers(builtins, predicate)
+    return {exc.__name__ for (_, exc) in members}
+
+
+def _annotated_unpack_infer(stmt, context=None):
+    """Recursively generate nodes inferred by the given statement.
+
+    If the inferred value is a list or a tuple, recurse on the elements.
+    Returns an iterator which yields tuples in the format
+    ('original node', 'inferred node').
+    """
+    if isinstance(stmt, (nodes.List, nodes.Tuple)):
+        for elt in stmt.elts:
+            inferred = utils.safe_infer(elt)
+            if inferred and inferred is not astroid.Uninferable:
+                yield elt, inferred
+        return
+    for inferred in stmt.infer(context):
+        if inferred is astroid.Uninferable:
+            continue
+        yield stmt, inferred
+
+
+def _is_raising(body: List) -> bool:
+    """Return whether the given statement node raises an exception."""
+    return any(isinstance(node, nodes.Raise) for node in body)
+
+
+OVERGENERAL_EXCEPTIONS = ("BaseException", "Exception")
+
+MSGS = {  # pylint: disable=consider-using-namedtuple-or-dataclass
+    "E0701": (
+        "Bad except clauses order (%s)",
+        "bad-except-order",
+        "Used when except clauses are not in the correct order (from the "
+        "more specific to the more generic). If you don't fix the order, "
+        "some exceptions may not be caught by the most specific handler.",
+    ),
+    "E0702": (
+        "Raising %s while only classes or instances are allowed",
+        "raising-bad-type",
+        "Used when something which is neither a class nor an instance "
+        "is raised (i.e. a `TypeError` will be raised).",
+    ),
+    "E0703": (
+        "Exception context set to something which is not an exception, nor None",
+        "bad-exception-context",
+        'Used when using the syntax "raise ... from ...", '
+        "where the exception context is not an exception, "
+        "nor None.",
+    ),
+    "E0704": (
+        "The raise statement is not inside an except clause",
+        "misplaced-bare-raise",
+        "Used when a bare raise is not used inside an except clause. "
+        "This generates an error, since there are no active exceptions "
+        "to be reraised. An exception to this rule is represented by "
+        "a bare raise inside a finally clause, which might work, as long "
+        "as an exception is raised inside the try block, but it is "
+        "nevertheless a code smell that must not be relied upon.",
+    ),
+    "E0710": (
+        "Raising a new style class which doesn't inherit from BaseException",
+        "raising-non-exception",
+        "Used when a new style class which doesn't inherit from "
+        "BaseException is raised.",
+    ),
+    "E0711": (
+        "NotImplemented raised - should raise NotImplementedError",
+        "notimplemented-raised",
+        "Used when NotImplemented is raised instead of NotImplementedError",
+    ),
+    "E0712": (
+        "Catching an exception which doesn't inherit from Exception: %s",
+        "catching-non-exception",
+        "Used when a class which doesn't inherit from "
+        "Exception is used as an exception in an except clause.",
+    ),
+    "W0702": (
+        "No exception type(s) specified",
+        "bare-except",
+        "Used when an except clause doesn't specify exceptions type to catch.",
+    ),
+    "W0703": (
+        "Catching too general exception %s",
+        "broad-except",
+        "Used when an except catches a too general exception, "
+        "possibly burying unrelated errors.",
+    ),
+    "W0705": (
+        "Catching previously caught exception type %s",
+        "duplicate-except",
+        "Used when an except catches a type that was already caught by "
+        "a previous handler.",
+    ),
+    "W0706": (
+        "The except handler raises immediately",
+        "try-except-raise",
+        "Used when an except handler uses raise as its first or only "
+        "operator. This is useless because it raises back the exception "
+        "immediately. Remove the raise operator or the entire "
+        "try-except-raise block!",
+    ),
+    "W0707": (
+        "Consider explicitly re-raising using the 'from' keyword",
+        "raise-missing-from",
+        "Python 3's exception chaining means it shows the traceback of the "
+        "current exception, but also the original exception. Not using `raise "
+        "from` makes the traceback inaccurate, because the message implies "
+        "there is a bug in the exception-handling code itself, which is a "
+        "separate situation than wrapping an exception.",
+    ),
+    "W0711": (
+        'Exception to catch is the result of a binary "%s" operation',
+        "binary-op-exception",
+        "Used when the exception to catch is of the form "
+        '"except A or B:".  If intending to catch multiple, '
+        'rewrite as "except (A, B):"',
+    ),
+    "W0715": (
+        "Exception arguments suggest string formatting might be intended",
+        "raising-format-tuple",
+        "Used when passing multiple arguments to an exception "
+        "constructor, the first of them a string literal containing what "
+        "appears to be placeholders intended for formatting",
+    ),
+    "W0716": (
+        "Invalid exception operation. %s",
+        "wrong-exception-operation",
+        "Used when an operation is done against an exception, but the operation "
+        "is not valid for the exception in question. Usually emitted when having "
+        "binary operations between exceptions in except handlers.",
+    ),
+}
+
+
+class BaseVisitor:
+    """Base class for visitors defined in this module."""
+
+    def __init__(self, checker, node):
+        self._checker = checker
+        self._node = node
+
+    def visit(self, node):
+        name = node.__class__.__name__.lower()
+        dispatch_meth = getattr(self, "visit_" + name, None)
+        if dispatch_meth:
+            dispatch_meth(node)
+        else:
+            self.visit_default(node)
+
+    def visit_default(self, _: nodes.NodeNG) -> None:
+        """Default implementation for all the nodes."""
+
+
+class ExceptionRaiseRefVisitor(BaseVisitor):
+    """Visit references (anything that is not an AST leaf)."""
+
+    def visit_name(self, node: nodes.Name) -> None:
+        if node.name == "NotImplemented":
+            self._checker.add_message("notimplemented-raised", node=self._node)
+
+    def visit_call(self, node: nodes.Call) -> None:
+        if isinstance(node.func, nodes.Name):
+            self.visit_name(node.func)
+        if (
+            len(node.args) > 1
+            and isinstance(node.args[0], nodes.Const)
+            and isinstance(node.args[0].value, str)
+        ):
+            msg = node.args[0].value
+            if "%" in msg or ("{" in msg and "}" in msg):
+                self._checker.add_message("raising-format-tuple", node=self._node)
+
+
+class ExceptionRaiseLeafVisitor(BaseVisitor):
+    """Visitor for handling leaf kinds of a raise value."""
+
+    def visit_const(self, node: nodes.Const) -> None:
+        self._checker.add_message(
+            "raising-bad-type", node=self._node, args=node.value.__class__.__name__
+        )
+
+    def visit_instance(self, instance: objects.ExceptionInstance) -> None:
+        cls = instance._proxied
+        self.visit_classdef(cls)
+
+    # Exception instances have a particular class type
+    visit_exceptioninstance = visit_instance
+
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        if not utils.inherit_from_std_ex(node) and utils.has_known_bases(node):
+            if node.newstyle:
+                self._checker.add_message("raising-non-exception", node=self._node)
+
+    def visit_tuple(self, _: nodes.Tuple) -> None:
+        self._checker.add_message("raising-bad-type", node=self._node, args="tuple")
+
+    def visit_default(self, node: nodes.NodeNG) -> None:
+        name = getattr(node, "name", node.__class__.__name__)
+        self._checker.add_message("raising-bad-type", node=self._node, args=name)
+
+
+class ExceptionsChecker(checkers.BaseChecker):
+    """Exception related checks."""
+
+    __implements__ = interfaces.IAstroidChecker
+
+    name = "exceptions"
+    msgs = MSGS
+    priority = -4
+    options = (
+        (
+            "overgeneral-exceptions",
+            {
+                "default": OVERGENERAL_EXCEPTIONS,
+                "type": "csv",
+                "metavar": "<comma-separated class names>",
+                "help": "Exceptions that will emit a warning "  # pylint: disable=consider-using-f-string
+                'when being caught. Defaults to "%s".'
+                % (", ".join(OVERGENERAL_EXCEPTIONS),),
+            },
+        ),
+    )
+
+    def open(self):
+        self._builtin_exceptions = _builtin_exceptions()
+        super().open()
+
+    @utils.check_messages(
+        "misplaced-bare-raise",
+        "raising-bad-type",
+        "raising-non-exception",
+        "notimplemented-raised",
+        "bad-exception-context",
+        "raising-format-tuple",
+        "raise-missing-from",
+    )
+    def visit_raise(self, node: nodes.Raise) -> None:
+        if node.exc is None:
+            self._check_misplaced_bare_raise(node)
+            return
+
+        if node.cause is None:
+            self._check_raise_missing_from(node)
+        else:
+            self._check_bad_exception_context(node)
+
+        expr = node.exc
+        ExceptionRaiseRefVisitor(self, node).visit(expr)
+
+        inferred = utils.safe_infer(expr)
+        if inferred is None or inferred is astroid.Uninferable:
+            return
+        ExceptionRaiseLeafVisitor(self, node).visit(inferred)
+
+    def _check_misplaced_bare_raise(self, node):
+        # Filter out if it's present in __exit__.
+        scope = node.scope()
+        if (
+            isinstance(scope, nodes.FunctionDef)
+            and scope.is_method()
+            and scope.name == "__exit__"
+        ):
+            return
+
+        current = node
+        # Stop when a new scope is generated or when the raise
+        # statement is found inside a TryFinally.
+        ignores = (nodes.ExceptHandler, nodes.FunctionDef)
+        while current and not isinstance(current.parent, ignores):
+            current = current.parent
+
+        expected = (nodes.ExceptHandler,)
+        if not current or not isinstance(current.parent, expected):
+            self.add_message("misplaced-bare-raise", node=node)
+
+    def _check_bad_exception_context(self, node: nodes.Raise) -> None:
+        """Verify that the exception context is properly set.
+
+        An exception context can be only `None` or an exception.
+        """
+        cause = utils.safe_infer(node.cause)
+        if cause in (astroid.Uninferable, None):
+            return
+
+        if isinstance(cause, nodes.Const):
+            if cause.value is not None:
+                self.add_message("bad-exception-context", node=node)
+        elif not isinstance(cause, nodes.ClassDef) and not utils.inherit_from_std_ex(
+            cause
+        ):
+            self.add_message("bad-exception-context", node=node)
+
+    def _check_raise_missing_from(self, node: nodes.Raise) -> None:
+        if node.exc is None:
+            # This is a plain `raise`, raising the previously-caught exception. No need for a
+            # cause.
+            return
+        # We'd like to check whether we're inside an `except` clause:
+        containing_except_node = utils.find_except_wrapper_node_in_scope(node)
+        if not containing_except_node:
+            return
+        # We found a surrounding `except`! We're almost done proving there's a
+        # `raise-missing-from` here. The only thing we need to protect against is that maybe
+        # the `raise` is raising the exception that was caught, possibly with some shenanigans
+        # like `exc.with_traceback(whatever)`. We won't analyze these, we'll just assume
+        # there's a violation on two simple cases: `raise SomeException(whatever)` and `raise
+        # SomeException`.
+        if containing_except_node.name is None:
+            # The `except` doesn't have an `as exception:` part, meaning there's no way that
+            # the `raise` is raising the same exception.
+            self.add_message("raise-missing-from", node=node)
+        elif isinstance(node.exc, nodes.Call) and isinstance(node.exc.func, nodes.Name):
+            # We have a `raise SomeException(whatever)`.
+            self.add_message("raise-missing-from", node=node)
+        elif (
+            isinstance(node.exc, nodes.Name)
+            and node.exc.name != containing_except_node.name.name
+        ):
+            # We have a `raise SomeException`.
+            self.add_message("raise-missing-from", node=node)
+
+    def _check_catching_non_exception(self, handler, exc, part):
+        if isinstance(exc, nodes.Tuple):
+            # Check if it is a tuple of exceptions.
+            inferred = [utils.safe_infer(elt) for elt in exc.elts]
+            if any(node is astroid.Uninferable for node in inferred):
+                # Don't emit if we don't know every component.
+                return
+            if all(
+                node
+                and (utils.inherit_from_std_ex(node) or not utils.has_known_bases(node))
+                for node in inferred
+            ):
+                return
+
+        if not isinstance(exc, nodes.ClassDef):
+            # Don't emit the warning if the inferred stmt
+            # is None, but the exception handler is something else,
+            # maybe it was redefined.
+            if isinstance(exc, nodes.Const) and exc.value is None:
+                if (
+                    isinstance(handler.type, nodes.Const) and handler.type.value is None
+                ) or handler.type.parent_of(exc):
+                    # If the exception handler catches None or
+                    # the exception component, which is None, is
+                    # defined by the entire exception handler, then
+                    # emit a warning.
+                    self.add_message(
+                        "catching-non-exception",
+                        node=handler.type,
+                        args=(part.as_string(),),
+                    )
+            else:
+                self.add_message(
+                    "catching-non-exception",
+                    node=handler.type,
+                    args=(part.as_string(),),
+                )
+            return
+
+        if (
+            not utils.inherit_from_std_ex(exc)
+            and exc.name not in self._builtin_exceptions
+        ):
+            if utils.has_known_bases(exc):
+                self.add_message(
+                    "catching-non-exception", node=handler.type, args=(exc.name,)
+                )
+
+    def _check_try_except_raise(self, node):
+        def gather_exceptions_from_handler(
+            handler,
+        ) -> Optional[List[nodes.NodeNG]]:
+            exceptions: List[nodes.NodeNG] = []
+            if handler.type:
+                exceptions_in_handler = utils.safe_infer(handler.type)
+                if isinstance(exceptions_in_handler, nodes.Tuple):
+                    exceptions = list(
+                        {
+                            exception
+                            for exception in exceptions_in_handler.elts
+                            if isinstance(exception, nodes.Name)
+                        }
+                    )
+                elif exceptions_in_handler:
+                    exceptions = [exceptions_in_handler]
+                else:
+                    # Break when we cannot infer anything reliably.
+                    return None
+            return exceptions
+
+        bare_raise = False
+        handler_having_bare_raise = None
+        exceptions_in_bare_handler = []
+        for handler in node.handlers:
+            if bare_raise:
+                # check that subsequent handler is not parent of handler which had bare raise.
+                # since utils.safe_infer can fail for bare except, check it before.
+                # also break early if bare except is followed by bare except.
+
+                excs_in_current_handler = gather_exceptions_from_handler(handler)
+                if not excs_in_current_handler:
+                    break
+                if exceptions_in_bare_handler is None:
+                    # It can be `None` when the inference failed
+                    break
+                for exc_in_current_handler in excs_in_current_handler:
+                    inferred_current = utils.safe_infer(exc_in_current_handler)
+                    if any(
+                        utils.is_subclass_of(utils.safe_infer(e), inferred_current)
+                        for e in exceptions_in_bare_handler
+                    ):
+                        bare_raise = False
+                        break
+
+            # `raise` as the first operator inside the except handler
+            if _is_raising([handler.body[0]]):
+                # flags when there is a bare raise
+                if handler.body[0].exc is None:
+                    bare_raise = True
+                    handler_having_bare_raise = handler
+                    exceptions_in_bare_handler = gather_exceptions_from_handler(handler)
+        else:
+            if bare_raise:
+                self.add_message("try-except-raise", node=handler_having_bare_raise)
+
+    @utils.check_messages("wrong-exception-operation")
+    def visit_binop(self, node: nodes.BinOp) -> None:
+        if isinstance(node.parent, nodes.ExceptHandler):
+            # except (V | A)
+            suggestion = f"Did you mean '({node.left.as_string()}, {node.right.as_string()})' instead?"
+            self.add_message("wrong-exception-operation", node=node, args=(suggestion,))
+
+    @utils.check_messages("wrong-exception-operation")
+    def visit_compare(self, node: nodes.Compare) -> None:
+        if isinstance(node.parent, nodes.ExceptHandler):
+            # except (V < A)
+            suggestion = f"Did you mean '({node.left.as_string()}, {', '.join(operand.as_string() for _, operand in node.ops)})' instead?"
+            self.add_message("wrong-exception-operation", node=node, args=(suggestion,))
+
+    @utils.check_messages(
+        "bare-except",
+        "broad-except",
+        "try-except-raise",
+        "binary-op-exception",
+        "bad-except-order",
+        "catching-non-exception",
+        "duplicate-except",
+    )
+    def visit_tryexcept(self, node: nodes.TryExcept) -> None:
+        """Check for empty except."""
+        self._check_try_except_raise(node)
+        exceptions_classes: List[Any] = []
+        nb_handlers = len(node.handlers)
+        for index, handler in enumerate(node.handlers):
+            if handler.type is None:
+                if not _is_raising(handler.body):
+                    self.add_message("bare-except", node=handler)
+
+                # check if an "except:" is followed by some other
+                # except
+                if index < (nb_handlers - 1):
+                    msg = "empty except clause should always appear last"
+                    self.add_message("bad-except-order", node=node, args=msg)
+
+            elif isinstance(handler.type, nodes.BoolOp):
+                self.add_message(
+                    "binary-op-exception", node=handler, args=handler.type.op
+                )
+            else:
+                try:
+                    exceptions = list(_annotated_unpack_infer(handler.type))
+                except astroid.InferenceError:
+                    continue
+
+                for part, exception in exceptions:
+                    if exception is astroid.Uninferable:
+                        continue
+                    if isinstance(
+                        exception, astroid.Instance
+                    ) and utils.inherit_from_std_ex(exception):
+                        exception = exception._proxied
+
+                    self._check_catching_non_exception(handler, exception, part)
+
+                    if not isinstance(exception, nodes.ClassDef):
+                        continue
+
+                    exc_ancestors = [
+                        anc
+                        for anc in exception.ancestors()
+                        if isinstance(anc, nodes.ClassDef)
+                    ]
+
+                    for previous_exc in exceptions_classes:
+                        if previous_exc in exc_ancestors:
+                            msg = f"{previous_exc.name} is an ancestor class of {exception.name}"
+                            self.add_message(
+                                "bad-except-order", node=handler.type, args=msg
+                            )
+                    if (
+                        exception.name in self.config.overgeneral_exceptions
+                        and exception.root().name == utils.EXCEPTIONS_MODULE
+                        and not _is_raising(handler.body)
+                    ):
+                        self.add_message(
+                            "broad-except", args=exception.name, node=handler.type
+                        )
+
+                    if exception in exceptions_classes:
+                        self.add_message(
+                            "duplicate-except", args=exception.name, node=handler.type
+                        )
+
+                exceptions_classes += [exc for _, exc in exceptions]
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(ExceptionsChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/format.py b/myenv/lib/python3.9/site-packages/pylint/checkers/format.py
new file mode 100644
index 0000000..4bf174d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/format.py
@@ -0,0 +1,782 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Python code format's checker.
+
+By default, try to follow Guido's style guide :
+
+https://www.python.org/doc/essays/styleguide/
+
+Some parts of the process_token method is based from The Tab Nanny std module.
+"""
+
+import tokenize
+from functools import reduce
+from typing import TYPE_CHECKING, List
+
+from astroid import nodes
+
+from pylint.checkers import BaseTokenChecker
+from pylint.checkers.utils import (
+    check_messages,
+    is_overload_stub,
+    is_protocol_class,
+    node_frame_class,
+)
+from pylint.constants import WarningScope
+from pylint.interfaces import IAstroidChecker, IRawChecker, ITokenChecker
+from pylint.utils.pragma_parser import OPTION_PO, PragmaParserError, parse_pragma
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+_ASYNC_TOKEN = "async"
+_KEYWORD_TOKENS = [
+    "assert",
+    "del",
+    "elif",
+    "except",
+    "for",
+    "if",
+    "in",
+    "not",
+    "raise",
+    "return",
+    "while",
+    "yield",
+    "with",
+]
+
+_SPACED_OPERATORS = [
+    "==",
+    "<",
+    ">",
+    "!=",
+    "<>",
+    "<=",
+    ">=",
+    "+=",
+    "-=",
+    "*=",
+    "**=",
+    "/=",
+    "//=",
+    "&=",
+    "|=",
+    "^=",
+    "%=",
+    ">>=",
+    "<<=",
+]
+_OPENING_BRACKETS = ["(", "[", "{"]
+_CLOSING_BRACKETS = [")", "]", "}"]
+_TAB_LENGTH = 8
+
+_EOL = frozenset([tokenize.NEWLINE, tokenize.NL, tokenize.COMMENT])
+_JUNK_TOKENS = (tokenize.COMMENT, tokenize.NL)
+
+# Whitespace checking policy constants
+_MUST = 0
+_MUST_NOT = 1
+_IGNORE = 2
+
+MSGS = {
+    "C0301": (
+        "Line too long (%s/%s)",
+        "line-too-long",
+        "Used when a line is longer than a given number of characters.",
+    ),
+    "C0302": (
+        "Too many lines in module (%s/%s)",  # was W0302
+        "too-many-lines",
+        "Used when a module has too many lines, reducing its readability.",
+    ),
+    "C0303": (
+        "Trailing whitespace",
+        "trailing-whitespace",
+        "Used when there is whitespace between the end of a line and the newline.",
+    ),
+    "C0304": (
+        "Final newline missing",
+        "missing-final-newline",
+        "Used when the last line in a file is missing a newline.",
+    ),
+    "C0305": (
+        "Trailing newlines",
+        "trailing-newlines",
+        "Used when there are trailing blank lines in a file.",
+    ),
+    "W0311": (
+        "Bad indentation. Found %s %s, expected %s",
+        "bad-indentation",
+        "Used when an unexpected number of indentation's tabulations or "
+        "spaces has been found.",
+    ),
+    "W0301": (
+        "Unnecessary semicolon",  # was W0106
+        "unnecessary-semicolon",
+        'Used when a statement is ended by a semi-colon (";"), which '
+        "isn't necessary (that's python, not C ;).",
+    ),
+    "C0321": (
+        "More than one statement on a single line",
+        "multiple-statements",
+        "Used when more than on statement are found on the same line.",
+        {"scope": WarningScope.NODE},
+    ),
+    "C0325": (
+        "Unnecessary parens after %r keyword",
+        "superfluous-parens",
+        "Used when a single item in parentheses follows an if, for, or "
+        "other keyword.",
+    ),
+    "C0327": (
+        "Mixed line endings LF and CRLF",
+        "mixed-line-endings",
+        "Used when there are mixed (LF and CRLF) newline signs in a file.",
+    ),
+    "C0328": (
+        "Unexpected line ending format. There is '%s' while it should be '%s'.",
+        "unexpected-line-ending-format",
+        "Used when there is different newline than expected.",
+    ),
+}
+
+
+def _last_token_on_line_is(tokens, line_end, token):
+    return (
+        line_end > 0
+        and tokens.token(line_end - 1) == token
+        or line_end > 1
+        and tokens.token(line_end - 2) == token
+        and tokens.type(line_end - 1) == tokenize.COMMENT
+    )
+
+
+# The contexts for hanging indents.
+# A hanging indented dictionary value after :
+HANGING_DICT_VALUE = "dict-value"
+# Hanging indentation in an expression.
+HANGING = "hanging"
+# Hanging indentation in a block header.
+HANGING_BLOCK = "hanging-block"
+# Continued indentation inside an expression.
+CONTINUED = "continued"
+# Continued indentation in a block header.
+CONTINUED_BLOCK = "continued-block"
+
+SINGLE_LINE = "single"
+WITH_BODY = "multi"
+
+
+class TokenWrapper:
+    """A wrapper for readable access to token information."""
+
+    def __init__(self, tokens):
+        self._tokens = tokens
+
+    def token(self, idx):
+        return self._tokens[idx][1]
+
+    def type(self, idx):
+        return self._tokens[idx][0]
+
+    def start_line(self, idx):
+        return self._tokens[idx][2][0]
+
+    def start_col(self, idx):
+        return self._tokens[idx][2][1]
+
+    def line(self, idx):
+        return self._tokens[idx][4]
+
+
+class FormatChecker(BaseTokenChecker):
+    """Formatting checker.
+
+    Checks for :
+    * unauthorized constructions
+    * strict indentation
+    * line length
+    """
+
+    __implements__ = (ITokenChecker, IAstroidChecker, IRawChecker)
+
+    # configuration section name
+    name = "format"
+    # messages
+    msgs = MSGS
+    # configuration options
+    # for available dict keys/values see the optik parser 'add_option' method
+    options = (
+        (
+            "max-line-length",
+            {
+                "default": 100,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "Maximum number of characters on a single line.",
+            },
+        ),
+        (
+            "ignore-long-lines",
+            {
+                "type": "regexp",
+                "metavar": "<regexp>",
+                "default": r"^\s*(# )?<?https?://\S+>?$",
+                "help": (
+                    "Regexp for a line that is allowed to be longer than the limit."
+                ),
+            },
+        ),
+        (
+            "single-line-if-stmt",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": (
+                    "Allow the body of an if to be on the same "
+                    "line as the test if there is no else."
+                ),
+            },
+        ),
+        (
+            "single-line-class-stmt",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": (
+                    "Allow the body of a class to be on the same "
+                    "line as the declaration if body contains "
+                    "single statement."
+                ),
+            },
+        ),
+        (
+            "max-module-lines",
+            {
+                "default": 1000,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "Maximum number of lines in a module.",
+            },
+        ),
+        (
+            "indent-string",
+            {
+                "default": "    ",
+                "type": "non_empty_string",
+                "metavar": "<string>",
+                "help": "String used as indentation unit. This is usually "
+                '"    " (4 spaces) or "\\t" (1 tab).',
+            },
+        ),
+        (
+            "indent-after-paren",
+            {
+                "type": "int",
+                "metavar": "<int>",
+                "default": 4,
+                "help": "Number of spaces of indent required inside a hanging "
+                "or continued line.",
+            },
+        ),
+        (
+            "expected-line-ending-format",
+            {
+                "type": "choice",
+                "metavar": "<empty or LF or CRLF>",
+                "default": "",
+                "choices": ["", "LF", "CRLF"],
+                "help": (
+                    "Expected format of line ending, "
+                    "e.g. empty (any line ending), LF or CRLF."
+                ),
+            },
+        ),
+    )
+
+    def __init__(self, linter=None):
+        super().__init__(linter)
+        self._lines = None
+        self._visited_lines = None
+        self._bracket_stack = [None]
+
+    def new_line(self, tokens, line_end, line_start):
+        """A new line has been encountered, process it if necessary."""
+        if _last_token_on_line_is(tokens, line_end, ";"):
+            self.add_message("unnecessary-semicolon", line=tokens.start_line(line_end))
+
+        line_num = tokens.start_line(line_start)
+        line = tokens.line(line_start)
+        if tokens.type(line_start) not in _JUNK_TOKENS:
+            self._lines[line_num] = line.split("\n")[0]
+        self.check_lines(line, line_num)
+
+    def process_module(self, _node: nodes.Module) -> None:
+        pass
+
+    # pylint: disable-next=too-many-return-statements
+    def _check_keyword_parentheses(
+        self, tokens: List[tokenize.TokenInfo], start: int
+    ) -> None:
+        """Check that there are not unnecessary parentheses after a keyword.
+
+        Parens are unnecessary if there is exactly one balanced outer pair on a
+        line, and it is followed by a colon, and contains no commas (i.e. is not a
+        tuple).
+
+        Args:
+        tokens: list of Tokens; the entire list of Tokens.
+        start: int; the position of the keyword in the token list.
+        """
+        # If the next token is not a paren, we're fine.
+        if self._bracket_stack[-1] == ":" and tokens[start].string == "for":
+            self._bracket_stack.pop()
+        if tokens[start + 1].string != "(":
+            return
+        if (
+            tokens[start].string == "not"
+            and start > 0
+            and tokens[start - 1].string == "is"
+        ):
+            # If this is part of an `is not` expression, we have a binary operator
+            # so the parentheses are not necessarily redundant.
+            return
+        found_and_or = False
+        contains_walrus_operator = False
+        walrus_operator_depth = 0
+        contains_double_parens = 0
+        depth = 0
+        keyword_token = str(tokens[start].string)
+        line_num = tokens[start].start[0]
+        for i in range(start, len(tokens) - 1):
+            token = tokens[i]
+
+            # If we hit a newline, then assume any parens were for continuation.
+            if token.type == tokenize.NL:
+                return
+            # Since the walrus operator doesn't exist below python3.8, the tokenizer
+            # generates independent tokens
+            if (
+                token.string == ":="  # <-- python3.8+ path
+                or token.string + tokens[i + 1].string == ":="
+            ):
+                contains_walrus_operator = True
+                walrus_operator_depth = depth
+            if token.string == "(":
+                depth += 1
+                if tokens[i + 1].string == "(":
+                    contains_double_parens = 1
+            elif token.string == ")":
+                depth -= 1
+                if depth:
+                    if contains_double_parens and tokens[i + 1].string == ")":
+                        # For walrus operators in `if (not)` conditions and comprehensions
+                        if keyword_token in {"in", "if", "not"}:
+                            continue
+                        return
+                    contains_double_parens -= 1
+                    continue
+                # ')' can't happen after if (foo), since it would be a syntax error.
+                if tokens[i + 1].string in {":", ")", "]", "}", "in"} or tokens[
+                    i + 1
+                ].type in {tokenize.NEWLINE, tokenize.ENDMARKER, tokenize.COMMENT}:
+                    if contains_walrus_operator and walrus_operator_depth - 1 == depth:
+                        return
+                    # The empty tuple () is always accepted.
+                    if i == start + 2:
+                        return
+                    if found_and_or:
+                        return
+                    if keyword_token == "in":
+                        # This special case was added in https://github.com/PyCQA/pylint/pull/4948
+                        # but it could be removed in the future. Avoid churn for now.
+                        return
+                    self.add_message(
+                        "superfluous-parens", line=line_num, args=keyword_token
+                    )
+                return
+            elif depth == 1:
+                # This is a tuple, which is always acceptable.
+                if token[1] == ",":
+                    return
+                # 'and' and 'or' are the only boolean operators with lower precedence
+                # than 'not', so parens are only required when they are found.
+                if token[1] in {"and", "or"}:
+                    found_and_or = True
+                # A yield inside an expression must always be in parentheses,
+                # quit early without error.
+                elif token[1] == "yield":
+                    return
+                # A generator expression always has a 'for' token in it, and
+                # the 'for' token is only legal inside parens when it is in a
+                # generator expression.  The parens are necessary here, so bail
+                # without an error.
+                elif token[1] == "for":
+                    return
+                # A generator expression can have an 'else' token in it.
+                # We check the rest of the tokens to see if any problems occur after
+                # the 'else'.
+                elif token[1] == "else":
+                    if "(" in (i.string for i in tokens[i:]):
+                        self._check_keyword_parentheses(tokens[i:], 0)
+                    return
+
+    def _prepare_token_dispatcher(self):
+        dispatch = {}
+        for tokens, handler in ((_KEYWORD_TOKENS, self._check_keyword_parentheses),):
+            for token in tokens:
+                dispatch[token] = handler
+        return dispatch
+
+    def process_tokens(self, tokens):
+        """Process tokens and search for :
+
+        _ too long lines (i.e. longer than <max_chars>)
+        _ optionally bad construct (if given, bad_construct must be a compiled
+          regular expression).
+        """
+        self._bracket_stack = [None]
+        indents = [0]
+        check_equal = False
+        line_num = 0
+        self._lines = {}
+        self._visited_lines = {}
+        token_handlers = self._prepare_token_dispatcher()
+        self._last_line_ending = None
+        last_blank_line_num = 0
+        for idx, (tok_type, token, start, _, line) in enumerate(tokens):
+            if start[0] != line_num:
+                line_num = start[0]
+                # A tokenizer oddity: if an indented line contains a multi-line
+                # docstring, the line member of the INDENT token does not contain
+                # the full line; therefore we check the next token on the line.
+                if tok_type == tokenize.INDENT:
+                    self.new_line(TokenWrapper(tokens), idx - 1, idx + 1)
+                else:
+                    self.new_line(TokenWrapper(tokens), idx - 1, idx)
+
+            if tok_type == tokenize.NEWLINE:
+                # a program statement, or ENDMARKER, will eventually follow,
+                # after some (possibly empty) run of tokens of the form
+                #     (NL | COMMENT)* (INDENT | DEDENT+)?
+                # If an INDENT appears, setting check_equal is wrong, and will
+                # be undone when we see the INDENT.
+                check_equal = True
+                self._check_line_ending(token, line_num)
+            elif tok_type == tokenize.INDENT:
+                check_equal = False
+                self.check_indent_level(token, indents[-1] + 1, line_num)
+                indents.append(indents[-1] + 1)
+            elif tok_type == tokenize.DEDENT:
+                # there's nothing we need to check here!  what's important is
+                # that when the run of DEDENTs ends, the indentation of the
+                # program statement (or ENDMARKER) that triggered the run is
+                # equal to what's left at the top of the indents stack
+                check_equal = True
+                if len(indents) > 1:
+                    del indents[-1]
+            elif tok_type == tokenize.NL:
+                if not line.strip("\r\n"):
+                    last_blank_line_num = line_num
+            elif tok_type not in (tokenize.COMMENT, tokenize.ENCODING):
+                # This is the first concrete token following a NEWLINE, so it
+                # must be the first token of the next program statement, or an
+                # ENDMARKER; the "line" argument exposes the leading whitespace
+                # for this statement; in the case of ENDMARKER, line is an empty
+                # string, so will properly match the empty string with which the
+                # "indents" stack was seeded
+                if check_equal:
+                    check_equal = False
+                    self.check_indent_level(line, indents[-1], line_num)
+
+            if tok_type == tokenize.NUMBER and token.endswith("l"):
+                self.add_message("lowercase-l-suffix", line=line_num)
+
+            try:
+                handler = token_handlers[token]
+            except KeyError:
+                pass
+            else:
+                handler(tokens, idx)
+
+        line_num -= 1  # to be ok with "wc -l"
+        if line_num > self.config.max_module_lines:
+            # Get the line where the too-many-lines (or its message id)
+            # was disabled or default to 1.
+            message_definition = self.linter.msgs_store.get_message_definitions(
+                "too-many-lines"
+            )[0]
+            names = (message_definition.msgid, "too-many-lines")
+            line = next(
+                filter(None, (self.linter._pragma_lineno.get(name) for name in names)),
+                1,
+            )
+            self.add_message(
+                "too-many-lines",
+                args=(line_num, self.config.max_module_lines),
+                line=line,
+            )
+
+        # See if there are any trailing lines.  Do not complain about empty
+        # files like __init__.py markers.
+        if line_num == last_blank_line_num and line_num > 0:
+            self.add_message("trailing-newlines", line=line_num)
+
+    def _check_line_ending(self, line_ending, line_num):
+        # check if line endings are mixed
+        if self._last_line_ending is not None:
+            # line_ending == "" indicates a synthetic newline added at
+            # the end of a file that does not, in fact, end with a
+            # newline.
+            if line_ending and line_ending != self._last_line_ending:
+                self.add_message("mixed-line-endings", line=line_num)
+
+        self._last_line_ending = line_ending
+
+        # check if line ending is as expected
+        expected = self.config.expected_line_ending_format
+        if expected:
+            # reduce multiple \n\n\n\n to one \n
+            line_ending = reduce(lambda x, y: x + y if x != y else x, line_ending, "")
+            line_ending = "LF" if line_ending == "\n" else "CRLF"
+            if line_ending != expected:
+                self.add_message(
+                    "unexpected-line-ending-format",
+                    args=(line_ending, expected),
+                    line=line_num,
+                )
+
+    @check_messages("multiple-statements")
+    def visit_default(self, node: nodes.NodeNG) -> None:
+        """Check the node line number and check it if not yet done."""
+        if not node.is_statement:
+            return
+        if not node.root().pure_python:
+            return
+        prev_sibl = node.previous_sibling()
+        if prev_sibl is not None:
+            prev_line = prev_sibl.fromlineno
+        # The line on which a 'finally': occurs in a 'try/finally'
+        # is not directly represented in the AST. We infer it
+        # by taking the last line of the body and adding 1, which
+        # should be the line of finally:
+        elif (
+            isinstance(node.parent, nodes.TryFinally) and node in node.parent.finalbody
+        ):
+            prev_line = node.parent.body[0].tolineno + 1
+        elif isinstance(node.parent, nodes.Module):
+            prev_line = 0
+        else:
+            prev_line = node.parent.statement(future=True).fromlineno
+        line = node.fromlineno
+        assert line, node
+        if prev_line == line and self._visited_lines.get(line) != 2:
+            self._check_multi_statement_line(node, line)
+            return
+        if line in self._visited_lines:
+            return
+        try:
+            tolineno = node.blockstart_tolineno
+        except AttributeError:
+            tolineno = node.tolineno
+        assert tolineno, node
+        lines = []
+        for line in range(line, tolineno + 1):
+            self._visited_lines[line] = 1
+            try:
+                lines.append(self._lines[line].rstrip())
+            except KeyError:
+                lines.append("")
+
+    def _check_multi_statement_line(self, node, line):
+        """Check for lines containing multiple statements."""
+        # Do not warn about multiple nested context managers
+        # in with statements.
+        if isinstance(node, nodes.With):
+            return
+        # For try... except... finally..., the two nodes
+        # appear to be on the same line due to how the AST is built.
+        if isinstance(node, nodes.TryExcept) and isinstance(
+            node.parent, nodes.TryFinally
+        ):
+            return
+        if (
+            isinstance(node.parent, nodes.If)
+            and not node.parent.orelse
+            and self.config.single_line_if_stmt
+        ):
+            return
+        if (
+            isinstance(node.parent, nodes.ClassDef)
+            and len(node.parent.body) == 1
+            and self.config.single_line_class_stmt
+        ):
+            return
+
+        # Function overloads that use ``Ellipsis`` are exempted.
+        if (
+            isinstance(node, nodes.Expr)
+            and isinstance(node.value, nodes.Const)
+            and node.value.value is Ellipsis
+        ):
+            frame = node.frame(future=True)
+            if is_overload_stub(frame) or is_protocol_class(node_frame_class(frame)):
+                return
+
+        self.add_message("multiple-statements", node=node)
+        self._visited_lines[line] = 2
+
+    def check_line_ending(self, line: str, i: int) -> None:
+        """Check that the final newline is not missing and that there is no trailing whitespace."""
+        if not line.endswith("\n"):
+            self.add_message("missing-final-newline", line=i)
+            return
+        # exclude \f (formfeed) from the rstrip
+        stripped_line = line.rstrip("\t\n\r\v ")
+        if line[len(stripped_line) :] not in ("\n", "\r\n"):
+            self.add_message(
+                "trailing-whitespace", line=i, col_offset=len(stripped_line)
+            )
+
+    def check_line_length(self, line: str, i: int, checker_off: bool) -> None:
+        """Check that the line length is less than the authorized value."""
+        max_chars = self.config.max_line_length
+        ignore_long_line = self.config.ignore_long_lines
+        line = line.rstrip()
+        if len(line) > max_chars and not ignore_long_line.search(line):
+            if checker_off:
+                self.linter.add_ignored_message("line-too-long", i)
+            else:
+                self.add_message("line-too-long", line=i, args=(len(line), max_chars))
+
+    @staticmethod
+    def remove_pylint_option_from_lines(options_pattern_obj) -> str:
+        """Remove the `# pylint ...` pattern from lines."""
+        lines = options_pattern_obj.string
+        purged_lines = (
+            lines[: options_pattern_obj.start(1)].rstrip()
+            + lines[options_pattern_obj.end(1) :]
+        )
+        return purged_lines
+
+    @staticmethod
+    def is_line_length_check_activated(pylint_pattern_match_object) -> bool:
+        """Return true if the line length check is activated."""
+        try:
+            for pragma in parse_pragma(pylint_pattern_match_object.group(2)):
+                if pragma.action == "disable" and "line-too-long" in pragma.messages:
+                    return False
+        except PragmaParserError:
+            # Printing useful information dealing with this error is done in the lint package
+            pass
+        return True
+
+    @staticmethod
+    def specific_splitlines(lines: str) -> List[str]:
+        """Split lines according to universal newlines except those in a specific sets."""
+        unsplit_ends = {
+            "\v",
+            "\x0b",
+            "\f",
+            "\x0c",
+            "\x1c",
+            "\x1d",
+            "\x1e",
+            "\x85",
+            "\u2028",
+            "\u2029",
+        }
+        res = []
+        buffer = ""
+        for atomic_line in lines.splitlines(True):
+            if atomic_line[-1] not in unsplit_ends:
+                res.append(buffer + atomic_line)
+                buffer = ""
+            else:
+                buffer += atomic_line
+        return res
+
+    def check_lines(self, lines: str, lineno: int) -> None:
+        """Check given lines for potential messages.
+
+        Check lines have :
+        - a final newline
+        - no trailing whitespace
+        - less than a maximum number of characters
+        """
+        # we're first going to do a rough check whether any lines in this set
+        # go over the line limit. If none of them do, then we don't need to
+        # parse out the pylint options later on and can just assume that these
+        # lines are clean
+
+        # we'll also handle the line ending check here to avoid double-iteration
+        # unless the line lengths are suspect
+
+        max_chars = self.config.max_line_length
+
+        split_lines = self.specific_splitlines(lines)
+
+        for offset, line in enumerate(split_lines):
+            self.check_line_ending(line, lineno + offset)
+
+        # hold onto the initial lineno for later
+        potential_line_length_warning = False
+        for offset, line in enumerate(split_lines):
+            # this check is purposefully simple and doesn't rstrip
+            # since this is running on every line you're checking it's
+            # advantageous to avoid doing a lot of work
+            if len(line) > max_chars:
+                potential_line_length_warning = True
+                break
+
+        # if there were no lines passing the max_chars config, we don't bother
+        # running the full line check (as we've met an even more strict condition)
+        if not potential_line_length_warning:
+            return
+
+        # Line length check may be deactivated through `pylint: disable` comment
+        mobj = OPTION_PO.search(lines)
+        checker_off = False
+        if mobj:
+            if not self.is_line_length_check_activated(mobj):
+                checker_off = True
+            # The 'pylint: disable whatever' should not be taken into account for line length count
+            lines = self.remove_pylint_option_from_lines(mobj)
+
+        # here we re-run specific_splitlines since we have filtered out pylint options above
+        for offset, line in enumerate(self.specific_splitlines(lines)):
+            self.check_line_length(line, lineno + offset, checker_off)
+
+    def check_indent_level(self, string, expected, line_num):
+        """Return the indent level of the string."""
+        indent = self.config.indent_string
+        if indent == "\\t":  # \t is not interpreted in the configuration file
+            indent = "\t"
+        level = 0
+        unit_size = len(indent)
+        while string[:unit_size] == indent:
+            string = string[unit_size:]
+            level += 1
+        suppl = ""
+        while string and string[0] in " \t":
+            suppl += string[0]
+            string = string[1:]
+        if level != expected or suppl:
+            i_type = "spaces"
+            if indent[0] == "\t":
+                i_type = "tabs"
+            self.add_message(
+                "bad-indentation",
+                line=line_num,
+                args=(level * unit_size + len(suppl), i_type, expected * unit_size),
+            )
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(FormatChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/imports.py b/myenv/lib/python3.9/site-packages/pylint/checkers/imports.py
new file mode 100644
index 0000000..fb99bbf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/imports.py
@@ -0,0 +1,952 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Imports checkers for Python code."""
+
+import collections
+import copy
+import os
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Tuple, Union
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker, DeprecatedMixin
+from pylint.checkers.utils import (
+    check_messages,
+    get_import_name,
+    is_from_fallback_block,
+    is_node_in_guarded_import_block,
+    is_typing_guard,
+    node_ignores_exception,
+)
+from pylint.exceptions import EmptyReportError
+from pylint.graph import DotBackend, get_cycles
+from pylint.interfaces import IAstroidChecker
+from pylint.reporters.ureports.nodes import Paragraph, Section, VerbatimText
+from pylint.utils import IsortDriver, get_global_option
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+def _qualified_names(modname):
+    """Split the names of the given module into subparts.
+
+    For example,
+        _qualified_names('pylint.checkers.ImportsChecker')
+    returns
+        ['pylint', 'pylint.checkers', 'pylint.checkers.ImportsChecker']
+    """
+    names = modname.split(".")
+    return [".".join(names[0 : i + 1]) for i in range(len(names))]
+
+
+def _get_first_import(node, context, name, base, level, alias):
+    """Return the node where [base.]<name> is imported or None if not found."""
+    fullname = f"{base}.{name}" if base else name
+
+    first = None
+    found = False
+    for first in context.body:
+        if first is node:
+            continue
+        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
+            continue
+        if isinstance(first, nodes.Import):
+            if any(fullname == iname[0] for iname in first.names):
+                found = True
+                break
+        elif isinstance(first, nodes.ImportFrom):
+            if level == first.level:
+                for imported_name, imported_alias in first.names:
+                    if fullname == f"{first.modname}.{imported_name}":
+                        found = True
+                        break
+                    if (
+                        name != "*"
+                        and name == imported_name
+                        and not (alias or imported_alias)
+                    ):
+                        found = True
+                        break
+                if found:
+                    break
+    if found and not astroid.are_exclusive(first, node):
+        return first
+    return None
+
+
+def _ignore_import_failure(node, modname, ignored_modules):
+    for submodule in _qualified_names(modname):
+        if submodule in ignored_modules:
+            return True
+
+    if is_node_in_guarded_import_block(node):
+        # Ignore import failure if part of guarded import block
+        # I.e. `sys.version_info` or `typing.TYPE_CHECKING`
+        return True
+
+    return node_ignores_exception(node, ImportError)
+
+
+# utilities to represents import dependencies as tree and dot graph ###########
+
+
+def _make_tree_defs(mod_files_list):
+    """Get a list of 2-uple (module, list_of_files_which_import_this_module),
+    it will return a dictionary to represent this as a tree
+    """
+    tree_defs = {}
+    for mod, files in mod_files_list:
+        node = (tree_defs, ())
+        for prefix in mod.split("."):
+            node = node[0].setdefault(prefix, [{}, []])
+        node[1] += files
+    return tree_defs
+
+
+def _repr_tree_defs(data, indent_str=None):
+    """Return a string which represents imports as a tree."""
+    lines = []
+    nodes_items = data.items()
+    for i, (mod, (sub, files)) in enumerate(sorted(nodes_items, key=lambda x: x[0])):
+        files = "" if not files else f"({','.join(sorted(files))})"
+        if indent_str is None:
+            lines.append(f"{mod} {files}")
+            sub_indent_str = "  "
+        else:
+            lines.append(rf"{indent_str}\-{mod} {files}")
+            if i == len(nodes_items) - 1:
+                sub_indent_str = f"{indent_str}  "
+            else:
+                sub_indent_str = f"{indent_str}| "
+        if sub:
+            lines.append(_repr_tree_defs(sub, sub_indent_str))
+    return "\n".join(lines)
+
+
+def _dependencies_graph(filename: str, dep_info: Dict[str, Set[str]]) -> str:
+    """Write dependencies as a dot (graphviz) file."""
+    done = {}
+    printer = DotBackend(os.path.splitext(os.path.basename(filename))[0], rankdir="LR")
+    printer.emit('URL="." node[shape="box"]')
+    for modname, dependencies in sorted(dep_info.items()):
+        sorted_dependencies = sorted(dependencies)
+        done[modname] = 1
+        printer.emit_node(modname)
+        for depmodname in sorted_dependencies:
+            if depmodname not in done:
+                done[depmodname] = 1
+                printer.emit_node(depmodname)
+    for depmodname, dependencies in sorted(dep_info.items()):
+        for modname in sorted(dependencies):
+            printer.emit_edge(modname, depmodname)
+    return printer.generate(filename)
+
+
+def _make_graph(
+    filename: str, dep_info: Dict[str, Set[str]], sect: Section, gtype: str
+):
+    """Generate a dependencies graph and add some information about it in the
+    report's section
+    """
+    outputfile = _dependencies_graph(filename, dep_info)
+    sect.append(Paragraph((f"{gtype}imports graph has been written to {outputfile}",)))
+
+
+# the import checker itself ###################################################
+
+MSGS = {
+    "E0401": (
+        "Unable to import %s",
+        "import-error",
+        "Used when pylint has been unable to import a module.",
+        {"old_names": [("F0401", "old-import-error")]},
+    ),
+    "E0402": (
+        "Attempted relative import beyond top-level package",
+        "relative-beyond-top-level",
+        "Used when a relative import tries to access too many levels "
+        "in the current package.",
+    ),
+    "R0401": (
+        "Cyclic import (%s)",
+        "cyclic-import",
+        "Used when a cyclic import between two or more modules is detected.",
+    ),
+    "R0402": (
+        "Use 'from %s import %s' instead",
+        "consider-using-from-import",
+        "Emitted when a submodule of a package is imported and "
+        "aliased with the same name. "
+        "E.g., instead of ``import concurrent.futures as futures`` use "
+        "``from concurrent import futures``",
+    ),
+    "W0401": (
+        "Wildcard import %s",
+        "wildcard-import",
+        "Used when `from module import *` is detected.",
+    ),
+    "W0402": (
+        "Uses of a deprecated module %r",
+        "deprecated-module",
+        "Used a module marked as deprecated is imported.",
+    ),
+    "W0404": (
+        "Reimport %r (imported line %s)",
+        "reimported",
+        "Used when a module is reimported multiple times.",
+    ),
+    "W0406": (
+        "Module import itself",
+        "import-self",
+        "Used when a module is importing itself.",
+    ),
+    "W0407": (
+        "Prefer importing %r instead of %r",
+        "preferred-module",
+        "Used when a module imported has a preferred replacement module.",
+    ),
+    "W0410": (
+        "__future__ import is not the first non docstring statement",
+        "misplaced-future",
+        "Python 2.5 and greater require __future__ import to be the "
+        "first non docstring statement in the module.",
+    ),
+    "C0410": (
+        "Multiple imports on one line (%s)",
+        "multiple-imports",
+        "Used when import statement importing multiple modules is detected.",
+    ),
+    "C0411": (
+        "%s should be placed before %s",
+        "wrong-import-order",
+        "Used when PEP8 import order is not respected (standard imports "
+        "first, then third-party libraries, then local imports)",
+    ),
+    "C0412": (
+        "Imports from package %s are not grouped",
+        "ungrouped-imports",
+        "Used when imports are not grouped by packages",
+    ),
+    "C0413": (
+        'Import "%s" should be placed at the top of the module',
+        "wrong-import-position",
+        "Used when code and imports are mixed",
+    ),
+    "C0414": (
+        "Import alias does not rename original package",
+        "useless-import-alias",
+        "Used when an import alias is same as original package."
+        "e.g using import numpy as numpy instead of import numpy as np",
+    ),
+    "C0415": (
+        "Import outside toplevel (%s)",
+        "import-outside-toplevel",
+        "Used when an import statement is used anywhere other than the module "
+        "toplevel. Move this import to the top of the file.",
+    ),
+}
+
+
+DEFAULT_STANDARD_LIBRARY = ()
+DEFAULT_KNOWN_THIRD_PARTY = ("enchant",)
+DEFAULT_PREFERRED_MODULES = ()
+
+
+class ImportsChecker(DeprecatedMixin, BaseChecker):
+    """BaseChecker for import statements.
+
+    Checks for
+    * external modules dependencies
+    * relative / wildcard imports
+    * cyclic imports
+    * uses of deprecated modules
+    * uses of modules instead of preferred modules
+    """
+
+    __implements__ = IAstroidChecker
+
+    name = "imports"
+    msgs = MSGS
+    priority = -2
+    default_deprecated_modules = ()
+
+    options = (
+        (
+            "deprecated-modules",
+            {
+                "default": default_deprecated_modules,
+                "type": "csv",
+                "metavar": "<modules>",
+                "help": "Deprecated modules which should not be used,"
+                " separated by a comma.",
+            },
+        ),
+        (
+            "preferred-modules",
+            {
+                "default": DEFAULT_PREFERRED_MODULES,
+                "type": "csv",
+                "metavar": "<module:preferred-module>",
+                "help": "Couples of modules and preferred modules,"
+                " separated by a comma.",
+            },
+        ),
+        (
+            "import-graph",
+            {
+                "default": "",
+                "type": "string",
+                "metavar": "<file.gv>",
+                "help": "Output a graph (.gv or any supported image format) of"
+                " all (i.e. internal and external) dependencies to the given file"
+                " (report RP0402 must not be disabled).",
+            },
+        ),
+        (
+            "ext-import-graph",
+            {
+                "default": "",
+                "type": "string",
+                "metavar": "<file.gv>",
+                "help": "Output a graph (.gv or any supported image format)"
+                " of external dependencies to the given file"
+                " (report RP0402 must not be disabled).",
+            },
+        ),
+        (
+            "int-import-graph",
+            {
+                "default": "",
+                "type": "string",
+                "metavar": "<file.gv>",
+                "help": "Output a graph (.gv or any supported image format)"
+                " of internal dependencies to the given file"
+                " (report RP0402 must not be disabled).",
+            },
+        ),
+        (
+            "known-standard-library",
+            {
+                "default": DEFAULT_STANDARD_LIBRARY,
+                "type": "csv",
+                "metavar": "<modules>",
+                "help": "Force import order to recognize a module as part of "
+                "the standard compatibility libraries.",
+            },
+        ),
+        (
+            "known-third-party",
+            {
+                "default": DEFAULT_KNOWN_THIRD_PARTY,
+                "type": "csv",
+                "metavar": "<modules>",
+                "help": "Force import order to recognize a module as part of "
+                "a third party library.",
+            },
+        ),
+        (
+            "allow-any-import-level",
+            {
+                "default": (),
+                "type": "csv",
+                "metavar": "<modules>",
+                "help": (
+                    "List of modules that can be imported at any level, not just "
+                    "the top level one."
+                ),
+            },
+        ),
+        (
+            "analyse-fallback-blocks",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Analyse import fallback blocks. This can be used to "
+                "support both Python 2 and 3 compatible code, which "
+                "means that the block might have code that exists "
+                "only in one or another interpreter, leading to false "
+                "positives when analysed.",
+            },
+        ),
+        (
+            "allow-wildcard-with-all",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Allow wildcard imports from modules that define __all__.",
+            },
+        ),
+    )
+
+    def __init__(self, linter: Optional["PyLinter"] = None) -> None:
+        BaseChecker.__init__(self, linter)
+        self.import_graph: collections.defaultdict = collections.defaultdict(set)
+        self._imports_stack: List[Tuple[Any, Any]] = []
+        self._first_non_import_node = None
+        self._module_pkg: Dict[
+            Any, Any
+        ] = {}  # mapping of modules to the pkg they belong in
+        self._allow_any_import_level: Set[Any] = set()
+        self.reports = (
+            ("RP0401", "External dependencies", self._report_external_dependencies),
+            ("RP0402", "Modules dependencies graph", self._report_dependencies_graph),
+        )
+
+    def open(self):
+        """Called before visiting project (i.e set of modules)."""
+        self.linter.stats.dependencies = {}
+        self.linter.stats = self.linter.stats
+        self.import_graph = collections.defaultdict(set)
+        self._module_pkg = {}  # mapping of modules to the pkg they belong in
+        self._excluded_edges = collections.defaultdict(set)
+        self._ignored_modules = get_global_option(self, "ignored-modules", default=[])
+        # Build a mapping {'module': 'preferred-module'}
+        self.preferred_modules = dict(
+            module.split(":")
+            for module in self.config.preferred_modules
+            if ":" in module
+        )
+        self._allow_any_import_level = set(self.config.allow_any_import_level)
+
+    def _import_graph_without_ignored_edges(self):
+        filtered_graph = copy.deepcopy(self.import_graph)
+        for node in filtered_graph:
+            filtered_graph[node].difference_update(self._excluded_edges[node])
+        return filtered_graph
+
+    def close(self):
+        """Called before visiting project (i.e set of modules)."""
+        if self.linter.is_message_enabled("cyclic-import"):
+            graph = self._import_graph_without_ignored_edges()
+            vertices = list(graph)
+            for cycle in get_cycles(graph, vertices=vertices):
+                self.add_message("cyclic-import", args=" -> ".join(cycle))
+
+    def deprecated_modules(self):
+        """Callback returning the deprecated modules."""
+        return self.config.deprecated_modules
+
+    @check_messages(*MSGS)
+    def visit_import(self, node: nodes.Import) -> None:
+        """Triggered when an import statement is seen."""
+        self._check_reimport(node)
+        self._check_import_as_rename(node)
+        self._check_toplevel(node)
+
+        names = [name for name, _ in node.names]
+        if len(names) >= 2:
+            self.add_message("multiple-imports", args=", ".join(names), node=node)
+
+        for name in names:
+            self.check_deprecated_module(node, name)
+            self._check_preferred_module(node, name)
+            imported_module = self._get_imported_module(node, name)
+            if isinstance(node.parent, nodes.Module):
+                # Allow imports nested
+                self._check_position(node)
+            if isinstance(node.scope(), nodes.Module):
+                self._record_import(node, imported_module)
+
+            if imported_module is None:
+                continue
+
+            self._add_imported_module(node, imported_module.name)
+
+    @check_messages(*MSGS)
+    def visit_importfrom(self, node: nodes.ImportFrom) -> None:
+        """Triggered when a from statement is seen."""
+        basename = node.modname
+        imported_module = self._get_imported_module(node, basename)
+
+        self._check_import_as_rename(node)
+        self._check_misplaced_future(node)
+        self.check_deprecated_module(node, basename)
+        self._check_preferred_module(node, basename)
+        self._check_wildcard_imports(node, imported_module)
+        self._check_same_line_imports(node)
+        self._check_reimport(node, basename=basename, level=node.level)
+        self._check_toplevel(node)
+
+        if isinstance(node.parent, nodes.Module):
+            # Allow imports nested
+            self._check_position(node)
+        if isinstance(node.scope(), nodes.Module):
+            self._record_import(node, imported_module)
+        if imported_module is None:
+            return
+        for name, _ in node.names:
+            if name != "*":
+                self._add_imported_module(node, f"{imported_module.name}.{name}")
+            else:
+                self._add_imported_module(node, imported_module.name)
+
+    @check_messages(*MSGS)
+    def leave_module(self, node: nodes.Module) -> None:
+        # Check imports are grouped by category (standard, 3rd party, local)
+        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
+
+        # Check that imports are grouped by package within a given category
+        met_import: Set[str] = set()  # set for 'import x' style
+        met_from: Set[str] = set()  # set for 'from x import y' style
+        current_package = None
+        for import_node, import_name in std_imports + ext_imports + loc_imports:
+            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
+            package, _, _ = import_name.partition(".")
+            if (
+                current_package
+                and current_package != package
+                and package in met
+                and is_node_in_guarded_import_block(import_node) is False
+            ):
+                self.add_message("ungrouped-imports", node=import_node, args=package)
+            current_package = package
+            if not self.linter.is_message_enabled(
+                "ungrouped-imports", import_node.fromlineno
+            ):
+                continue
+            met.add(package)
+
+        self._imports_stack = []
+        self._first_non_import_node = None
+
+    def compute_first_non_import_node(self, node):
+        if not self.linter.is_message_enabled("wrong-import-position", node.fromlineno):
+            return
+        # if the node does not contain an import instruction, and if it is the
+        # first node of the module, keep a track of it (all the import positions
+        # of the module will be compared to the position of this first
+        # instruction)
+        if self._first_non_import_node:
+            return
+        if not isinstance(node.parent, nodes.Module):
+            return
+        nested_allowed = [nodes.TryExcept, nodes.TryFinally]
+        is_nested_allowed = [
+            allowed for allowed in nested_allowed if isinstance(node, allowed)
+        ]
+        if is_nested_allowed and any(
+            node.nodes_of_class((nodes.Import, nodes.ImportFrom))
+        ):
+            return
+        if isinstance(node, nodes.Assign):
+            # Add compatibility for module level dunder names
+            # https://www.python.org/dev/peps/pep-0008/#module-level-dunder-names
+            valid_targets = [
+                isinstance(target, nodes.AssignName)
+                and target.name.startswith("__")
+                and target.name.endswith("__")
+                for target in node.targets
+            ]
+            if all(valid_targets):
+                return
+        self._first_non_import_node = node
+
+    visit_tryfinally = (
+        visit_tryexcept
+    ) = (
+        visit_assignattr
+    ) = (
+        visit_assign
+    ) = (
+        visit_ifexp
+    ) = visit_comprehension = visit_expr = visit_if = compute_first_non_import_node
+
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        if not self.linter.is_message_enabled("wrong-import-position", node.fromlineno):
+            return
+        # If it is the first non import instruction of the module, record it.
+        if self._first_non_import_node:
+            return
+
+        # Check if the node belongs to an `If` or a `Try` block. If they
+        # contain imports, skip recording this node.
+        if not isinstance(node.parent.scope(), nodes.Module):
+            return
+
+        root = node
+        while not isinstance(root.parent, nodes.Module):
+            root = root.parent
+
+        if isinstance(root, (nodes.If, nodes.TryFinally, nodes.TryExcept)):
+            if any(root.nodes_of_class((nodes.Import, nodes.ImportFrom))):
+                return
+
+        self._first_non_import_node = node
+
+    visit_classdef = visit_for = visit_while = visit_functiondef
+
+    def _check_misplaced_future(self, node):
+        basename = node.modname
+        if basename == "__future__":
+            # check if this is the first non-docstring statement in the module
+            prev = node.previous_sibling()
+            if prev:
+                # consecutive future statements are possible
+                if not (
+                    isinstance(prev, nodes.ImportFrom) and prev.modname == "__future__"
+                ):
+                    self.add_message("misplaced-future", node=node)
+            return
+
+    def _check_same_line_imports(self, node):
+        # Detect duplicate imports on the same line.
+        names = (name for name, _ in node.names)
+        counter = collections.Counter(names)
+        for name, count in counter.items():
+            if count > 1:
+                self.add_message("reimported", node=node, args=(name, node.fromlineno))
+
+    def _check_position(self, node):
+        """Check `node` import or importfrom node position is correct.
+
+        Send a message  if `node` comes before another instruction
+        """
+        # if a first non-import instruction has already been encountered,
+        # it means the import comes after it and therefore is not well placed
+        if self._first_non_import_node:
+            self.add_message("wrong-import-position", node=node, args=node.as_string())
+
+    def _record_import(self, node, importedmodnode):
+        """Record the package `node` imports from."""
+        if isinstance(node, nodes.ImportFrom):
+            importedname = node.modname
+        else:
+            importedname = importedmodnode.name if importedmodnode else None
+        if not importedname:
+            importedname = node.names[0][0].split(".")[0]
+
+        if isinstance(node, nodes.ImportFrom) and (node.level or 0) >= 1:
+            # We need the importedname with first point to detect local package
+            # Example of node:
+            #  'from .my_package1 import MyClass1'
+            #  the output should be '.my_package1' instead of 'my_package1'
+            # Example of node:
+            #  'from . import my_package2'
+            #  the output should be '.my_package2' instead of '{pyfile}'
+            importedname = "." + importedname
+
+        self._imports_stack.append((node, importedname))
+
+    @staticmethod
+    def _is_fallback_import(node, imports):
+        imports = [import_node for (import_node, _) in imports]
+        return any(astroid.are_exclusive(import_node, node) for import_node in imports)
+
+    def _check_imports_order(self, _module_node):
+        """Checks imports of module `node` are grouped by category.
+
+        Imports must follow this order: standard, 3rd party, local
+        """
+        std_imports = []
+        third_party_imports = []
+        first_party_imports = []
+        # need of a list that holds third or first party ordered import
+        external_imports = []
+        local_imports = []
+        third_party_not_ignored = []
+        first_party_not_ignored = []
+        local_not_ignored = []
+        isort_driver = IsortDriver(self.config)
+        for node, modname in self._imports_stack:
+            if modname.startswith("."):
+                package = "." + modname.split(".")[1]
+            else:
+                package = modname.split(".")[0]
+            nested = not isinstance(node.parent, nodes.Module)
+            ignore_for_import_order = not self.linter.is_message_enabled(
+                "wrong-import-order", node.fromlineno
+            )
+            import_category = isort_driver.place_module(package)
+            node_and_package_import = (node, package)
+            if import_category in {"FUTURE", "STDLIB"}:
+                std_imports.append(node_and_package_import)
+                wrong_import = (
+                    third_party_not_ignored
+                    or first_party_not_ignored
+                    or local_not_ignored
+                )
+                if self._is_fallback_import(node, wrong_import):
+                    continue
+                if wrong_import and not nested:
+                    self.add_message(
+                        "wrong-import-order",
+                        node=node,
+                        args=(
+                            f'standard import "{node.as_string()}"',
+                            f'"{wrong_import[0][0].as_string()}"',
+                        ),
+                    )
+            elif import_category == "THIRDPARTY":
+                third_party_imports.append(node_and_package_import)
+                external_imports.append(node_and_package_import)
+                if not nested:
+                    if not ignore_for_import_order:
+                        third_party_not_ignored.append(node_and_package_import)
+                    else:
+                        self.linter.add_ignored_message(
+                            "wrong-import-order", node.fromlineno, node
+                        )
+                wrong_import = first_party_not_ignored or local_not_ignored
+                if wrong_import and not nested:
+                    self.add_message(
+                        "wrong-import-order",
+                        node=node,
+                        args=(
+                            f'third party import "{node.as_string()}"',
+                            f'"{wrong_import[0][0].as_string()}"',
+                        ),
+                    )
+            elif import_category == "FIRSTPARTY":
+                first_party_imports.append(node_and_package_import)
+                external_imports.append(node_and_package_import)
+                if not nested:
+                    if not ignore_for_import_order:
+                        first_party_not_ignored.append(node_and_package_import)
+                    else:
+                        self.linter.add_ignored_message(
+                            "wrong-import-order", node.fromlineno, node
+                        )
+                wrong_import = local_not_ignored
+                if wrong_import and not nested:
+                    self.add_message(
+                        "wrong-import-order",
+                        node=node,
+                        args=(
+                            f'first party import "{node.as_string()}"',
+                            f'"{wrong_import[0][0].as_string()}"',
+                        ),
+                    )
+            elif import_category == "LOCALFOLDER":
+                local_imports.append((node, package))
+                if not nested:
+                    if not ignore_for_import_order:
+                        local_not_ignored.append((node, package))
+                    else:
+                        self.linter.add_ignored_message(
+                            "wrong-import-order", node.fromlineno, node
+                        )
+        return std_imports, external_imports, local_imports
+
+    def _get_imported_module(self, importnode, modname):
+        try:
+            return importnode.do_import_module(modname)
+        except astroid.TooManyLevelsError:
+            if _ignore_import_failure(importnode, modname, self._ignored_modules):
+                return None
+            self.add_message("relative-beyond-top-level", node=importnode)
+        except astroid.AstroidSyntaxError as exc:
+            message = f"Cannot import {modname!r} due to syntax error {str(exc.error)!r}"  # pylint: disable=no-member; false positive
+            self.add_message("syntax-error", line=importnode.lineno, args=message)
+
+        except astroid.AstroidBuildingException:
+            if not self.linter.is_message_enabled("import-error"):
+                return None
+            if _ignore_import_failure(importnode, modname, self._ignored_modules):
+                return None
+            if not self.config.analyse_fallback_blocks and is_from_fallback_block(
+                importnode
+            ):
+                return None
+
+            dotted_modname = get_import_name(importnode, modname)
+            self.add_message("import-error", args=repr(dotted_modname), node=importnode)
+        return None
+
+    def _add_imported_module(
+        self, node: Union[nodes.Import, nodes.ImportFrom], importedmodname: str
+    ) -> None:
+        """Notify an imported module, used to analyze dependencies."""
+        module_file = node.root().file
+        context_name = node.root().name
+        base = os.path.splitext(os.path.basename(module_file))[0]
+
+        try:
+            importedmodname = astroid.modutils.get_module_part(
+                importedmodname, module_file
+            )
+        except ImportError:
+            pass
+
+        in_type_checking_block = isinstance(node.parent, nodes.If) and is_typing_guard(
+            node.parent
+        )
+
+        if context_name == importedmodname:
+            self.add_message("import-self", node=node)
+
+        elif not astroid.modutils.is_standard_module(importedmodname):
+            # if this is not a package __init__ module
+            if base != "__init__" and context_name not in self._module_pkg:
+                # record the module's parent, or the module itself if this is
+                # a top level module, as the package it belongs to
+                self._module_pkg[context_name] = context_name.rsplit(".", 1)[0]
+
+            # handle dependencies
+            dependencies_stat: Dict[str, Set[str]] = self.linter.stats.dependencies
+            importedmodnames = dependencies_stat.setdefault(importedmodname, set())
+            if context_name not in importedmodnames:
+                importedmodnames.add(context_name)
+
+            # update import graph
+            self.import_graph[context_name].add(importedmodname)
+            if (
+                not self.linter.is_message_enabled("cyclic-import", line=node.lineno)
+                or in_type_checking_block
+            ):
+                self._excluded_edges[context_name].add(importedmodname)
+
+    def _check_preferred_module(self, node, mod_path):
+        """Check if the module has a preferred replacement."""
+        if mod_path in self.preferred_modules:
+            self.add_message(
+                "preferred-module",
+                node=node,
+                args=(self.preferred_modules[mod_path], mod_path),
+            )
+
+    def _check_import_as_rename(
+        self, node: Union[nodes.Import, nodes.ImportFrom]
+    ) -> None:
+        names = node.names
+        for name in names:
+            if not all(name):
+                return
+
+            splitted_packages = name[0].rsplit(".", maxsplit=1)
+            import_name = splitted_packages[-1]
+            aliased_name = name[1]
+            if import_name != aliased_name:
+                continue
+
+            if len(splitted_packages) == 1:
+                self.add_message("useless-import-alias", node=node)
+            elif len(splitted_packages) == 2:
+                self.add_message(
+                    "consider-using-from-import",
+                    node=node,
+                    args=(splitted_packages[0], import_name),
+                )
+
+    def _check_reimport(self, node, basename=None, level=None):
+        """Check if the import is necessary (i.e. not already done)."""
+        if not self.linter.is_message_enabled("reimported"):
+            return
+
+        frame = node.frame(future=True)
+        root = node.root()
+        contexts = [(frame, level)]
+        if root is not frame:
+            contexts.append((root, None))
+
+        for known_context, known_level in contexts:
+            for name, alias in node.names:
+                first = _get_first_import(
+                    node, known_context, name, basename, known_level, alias
+                )
+                if first is not None:
+                    self.add_message(
+                        "reimported", node=node, args=(name, first.fromlineno)
+                    )
+
+    def _report_external_dependencies(self, sect, _, _dummy):
+        """Return a verbatim layout for displaying dependencies."""
+        dep_info = _make_tree_defs(self._external_dependencies_info().items())
+        if not dep_info:
+            raise EmptyReportError()
+        tree_str = _repr_tree_defs(dep_info)
+        sect.append(VerbatimText(tree_str))
+
+    def _report_dependencies_graph(self, sect, _, _dummy):
+        """Write dependencies as a dot (graphviz) file."""
+        dep_info = self.linter.stats.dependencies
+        if not dep_info or not (
+            self.config.import_graph
+            or self.config.ext_import_graph
+            or self.config.int_import_graph
+        ):
+            raise EmptyReportError()
+        filename = self.config.import_graph
+        if filename:
+            _make_graph(filename, dep_info, sect, "")
+        filename = self.config.ext_import_graph
+        if filename:
+            _make_graph(filename, self._external_dependencies_info(), sect, "external ")
+        filename = self.config.int_import_graph
+        if filename:
+            _make_graph(filename, self._internal_dependencies_info(), sect, "internal ")
+
+    def _filter_dependencies_graph(self, internal):
+        """Build the internal or the external dependency graph."""
+        graph = collections.defaultdict(set)
+        for importee, importers in self.linter.stats.dependencies.items():
+            for importer in importers:
+                package = self._module_pkg.get(importer, importer)
+                is_inside = importee.startswith(package)
+                if is_inside and internal or not is_inside and not internal:
+                    graph[importee].add(importer)
+        return graph
+
+    @astroid.decorators.cached
+    def _external_dependencies_info(self):
+        """Return cached external dependencies information or build and
+        cache them
+        """
+        return self._filter_dependencies_graph(internal=False)
+
+    @astroid.decorators.cached
+    def _internal_dependencies_info(self):
+        """Return cached internal dependencies information or build and
+        cache them
+        """
+        return self._filter_dependencies_graph(internal=True)
+
+    def _check_wildcard_imports(self, node, imported_module):
+        if node.root().package:
+            # Skip the check if in __init__.py issue #2026
+            return
+
+        wildcard_import_is_allowed = self._wildcard_import_is_allowed(imported_module)
+        for name, _ in node.names:
+            if name == "*" and not wildcard_import_is_allowed:
+                self.add_message("wildcard-import", args=node.modname, node=node)
+
+    def _wildcard_import_is_allowed(self, imported_module):
+        return (
+            self.config.allow_wildcard_with_all
+            and imported_module is not None
+            and "__all__" in imported_module.locals
+        )
+
+    def _check_toplevel(self, node):
+        """Check whether the import is made outside the module toplevel."""
+        # If the scope of the import is a module, then obviously it is
+        # not outside the module toplevel.
+        if isinstance(node.scope(), nodes.Module):
+            return
+
+        module_names = [
+            f"{node.modname}.{name[0]}"
+            if isinstance(node, nodes.ImportFrom)
+            else name[0]
+            for name in node.names
+        ]
+
+        # Get the full names of all the imports that are only allowed at the module level
+        scoped_imports = [
+            name for name in module_names if name not in self._allow_any_import_level
+        ]
+
+        if scoped_imports:
+            self.add_message(
+                "import-outside-toplevel", args=", ".join(scoped_imports), node=node
+            )
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(ImportsChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/logging.py b/myenv/lib/python3.9/site-packages/pylint/checkers/logging.py
new file mode 100644
index 0000000..743f40d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/logging.py
@@ -0,0 +1,384 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Checker for use of Python logging."""
+import string
+from typing import TYPE_CHECKING, Set
+
+import astroid
+from astroid import nodes
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+from pylint.checkers.utils import check_messages, infer_all
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+MSGS = {  # pylint: disable=consider-using-namedtuple-or-dataclass
+    "W1201": (
+        "Use %s formatting in logging functions",
+        "logging-not-lazy",
+        "Used when a logging statement has a call form of "
+        '"logging.<logging method>(format_string % (format_args...))". '
+        "Use another type of string formatting instead. "
+        "You can use % formatting but leave interpolation to "
+        "the logging function by passing the parameters as arguments. "
+        "If logging-fstring-interpolation is disabled then "
+        "you can use fstring formatting. "
+        "If logging-format-interpolation is disabled then "
+        "you can use str.format.",
+    ),
+    "W1202": (
+        "Use %s formatting in logging functions",
+        "logging-format-interpolation",
+        "Used when a logging statement has a call form of "
+        '"logging.<logging method>(format_string.format(format_args...))". '
+        "Use another type of string formatting instead. "
+        "You can use % formatting but leave interpolation to "
+        "the logging function by passing the parameters as arguments. "
+        "If logging-fstring-interpolation is disabled then "
+        "you can use fstring formatting. "
+        "If logging-not-lazy is disabled then "
+        "you can use % formatting as normal.",
+    ),
+    "W1203": (
+        "Use %s formatting in logging functions",
+        "logging-fstring-interpolation",
+        "Used when a logging statement has a call form of "
+        '"logging.<logging method>(f"...")".'
+        "Use another type of string formatting instead. "
+        "You can use % formatting but leave interpolation to "
+        "the logging function by passing the parameters as arguments. "
+        "If logging-format-interpolation is disabled then "
+        "you can use str.format. "
+        "If logging-not-lazy is disabled then "
+        "you can use % formatting as normal.",
+    ),
+    "E1200": (
+        "Unsupported logging format character %r (%#02x) at index %d",
+        "logging-unsupported-format",
+        "Used when an unsupported format character is used in a logging "
+        "statement format string.",
+    ),
+    "E1201": (
+        "Logging format string ends in middle of conversion specifier",
+        "logging-format-truncated",
+        "Used when a logging statement format string terminates before "
+        "the end of a conversion specifier.",
+    ),
+    "E1205": (
+        "Too many arguments for logging format string",
+        "logging-too-many-args",
+        "Used when a logging format string is given too many arguments.",
+    ),
+    "E1206": (
+        "Not enough arguments for logging format string",
+        "logging-too-few-args",
+        "Used when a logging format string is given too few arguments.",
+    ),
+}
+
+
+CHECKED_CONVENIENCE_FUNCTIONS = {
+    "critical",
+    "debug",
+    "error",
+    "exception",
+    "fatal",
+    "info",
+    "warn",
+    "warning",
+}
+
+
+def is_method_call(func, types=(), methods=()):
+    """Determines if a BoundMethod node represents a method call.
+
+    Args:
+      func (astroid.BoundMethod): The BoundMethod AST node to check.
+      types (Optional[String]): Optional sequence of caller type names to restrict check.
+      methods (Optional[String]): Optional sequence of method names to restrict check.
+
+    Returns:
+      bool: true if the node represents a method call for the given type and
+      method names, False otherwise.
+    """
+    return (
+        isinstance(func, astroid.BoundMethod)
+        and isinstance(func.bound, astroid.Instance)
+        and (func.bound.name in types if types else True)
+        and (func.name in methods if methods else True)
+    )
+
+
+class LoggingChecker(checkers.BaseChecker):
+    """Checks use of the logging module."""
+
+    __implements__ = interfaces.IAstroidChecker
+    name = "logging"
+    msgs = MSGS
+
+    options = (
+        (
+            "logging-modules",
+            {
+                "default": ("logging",),
+                "type": "csv",
+                "metavar": "<comma separated list>",
+                "help": "Logging modules to check that the string format "
+                "arguments are in logging function parameter format.",
+            },
+        ),
+        (
+            "logging-format-style",
+            {
+                "default": "old",
+                "type": "choice",
+                "metavar": "<old (%) or new ({)>",
+                "choices": ["old", "new"],
+                "help": "The type of string formatting that logging methods do. "
+                "`old` means using % formatting, `new` is for `{}` formatting.",
+            },
+        ),
+    )
+
+    def visit_module(self, _: nodes.Module) -> None:
+        """Clears any state left in this checker from last module checked."""
+        # The code being checked can just as easily "import logging as foo",
+        # so it is necessary to process the imports and store in this field
+        # what name the logging module is actually given.
+        self._logging_names: Set[str] = set()
+        logging_mods = self.config.logging_modules
+
+        self._format_style = self.config.logging_format_style
+
+        self._logging_modules = set(logging_mods)
+        self._from_imports = {}
+        for logging_mod in logging_mods:
+            parts = logging_mod.rsplit(".", 1)
+            if len(parts) > 1:
+                self._from_imports[parts[0]] = parts[1]
+
+    def visit_importfrom(self, node: nodes.ImportFrom) -> None:
+        """Checks to see if a module uses a non-Python logging module."""
+        try:
+            logging_name = self._from_imports[node.modname]
+            for module, as_name in node.names:
+                if module == logging_name:
+                    self._logging_names.add(as_name or module)
+        except KeyError:
+            pass
+
+    def visit_import(self, node: nodes.Import) -> None:
+        """Checks to see if this module uses Python's built-in logging."""
+        for module, as_name in node.names:
+            if module in self._logging_modules:
+                self._logging_names.add(as_name or module)
+
+    @check_messages(*MSGS)
+    def visit_call(self, node: nodes.Call) -> None:
+        """Checks calls to logging methods."""
+
+        def is_logging_name():
+            return (
+                isinstance(node.func, nodes.Attribute)
+                and isinstance(node.func.expr, nodes.Name)
+                and node.func.expr.name in self._logging_names
+            )
+
+        def is_logger_class():
+            for inferred in infer_all(node.func):
+                if isinstance(inferred, astroid.BoundMethod):
+                    parent = inferred._proxied.parent
+                    if isinstance(parent, nodes.ClassDef) and (
+                        parent.qname() == "logging.Logger"
+                        or any(
+                            ancestor.qname() == "logging.Logger"
+                            for ancestor in parent.ancestors()
+                        )
+                    ):
+                        return True, inferred._proxied.name
+            return False, None
+
+        if is_logging_name():
+            name = node.func.attrname
+        else:
+            result, name = is_logger_class()
+            if not result:
+                return
+        self._check_log_method(node, name)
+
+    def _check_log_method(self, node, name):
+        """Checks calls to logging.log(level, format, *format_args)."""
+        if name == "log":
+            if node.starargs or node.kwargs or len(node.args) < 2:
+                # Either a malformed call, star args, or double-star args. Beyond
+                # the scope of this checker.
+                return
+            format_pos = 1
+        elif name in CHECKED_CONVENIENCE_FUNCTIONS:
+            if node.starargs or node.kwargs or not node.args:
+                # Either no args, star args, or double-star args. Beyond the
+                # scope of this checker.
+                return
+            format_pos = 0
+        else:
+            return
+
+        if isinstance(node.args[format_pos], nodes.BinOp):
+            binop = node.args[format_pos]
+            emit = binop.op == "%"
+            if binop.op == "+":
+                total_number_of_strings = sum(
+                    1
+                    for operand in (binop.left, binop.right)
+                    if self._is_operand_literal_str(utils.safe_infer(operand))
+                )
+                emit = total_number_of_strings > 0
+            if emit:
+                self.add_message(
+                    "logging-not-lazy",
+                    node=node,
+                    args=(self._helper_string(node),),
+                )
+        elif isinstance(node.args[format_pos], nodes.Call):
+            self._check_call_func(node.args[format_pos])
+        elif isinstance(node.args[format_pos], nodes.Const):
+            self._check_format_string(node, format_pos)
+        elif isinstance(node.args[format_pos], nodes.JoinedStr):
+            self.add_message(
+                "logging-fstring-interpolation",
+                node=node,
+                args=(self._helper_string(node),),
+            )
+
+    def _helper_string(self, node):
+        """Create a string that lists the valid types of formatting for this node."""
+        valid_types = ["lazy %"]
+
+        if not self.linter.is_message_enabled(
+            "logging-fstring-formatting", node.fromlineno
+        ):
+            valid_types.append("fstring")
+        if not self.linter.is_message_enabled(
+            "logging-format-interpolation", node.fromlineno
+        ):
+            valid_types.append(".format()")
+        if not self.linter.is_message_enabled("logging-not-lazy", node.fromlineno):
+            valid_types.append("%")
+
+        return " or ".join(valid_types)
+
+    @staticmethod
+    def _is_operand_literal_str(operand):
+        """Return True if the operand in argument is a literal string."""
+        return isinstance(operand, nodes.Const) and operand.name == "str"
+
+    def _check_call_func(self, node: nodes.Call):
+        """Checks that function call is not format_string.format()."""
+        func = utils.safe_infer(node.func)
+        types = ("str", "unicode")
+        methods = ("format",)
+        if (
+            isinstance(func, astroid.BoundMethod)
+            and is_method_call(func, types, methods)
+            and not is_complex_format_str(func.bound)
+        ):
+            self.add_message(
+                "logging-format-interpolation",
+                node=node,
+                args=(self._helper_string(node),),
+            )
+
+    def _check_format_string(self, node, format_arg):
+        """Checks that format string tokens match the supplied arguments.
+
+        Args:
+          node (nodes.NodeNG): AST node to be checked.
+          format_arg (int): Index of the format string in the node arguments.
+        """
+        num_args = _count_supplied_tokens(node.args[format_arg + 1 :])
+        if not num_args:
+            # If no args were supplied the string is not interpolated and can contain
+            # formatting characters - it's used verbatim. Don't check any further.
+            return
+
+        format_string = node.args[format_arg].value
+        required_num_args = 0
+        if isinstance(format_string, bytes):
+            format_string = format_string.decode()
+        if isinstance(format_string, str):
+            try:
+                if self._format_style == "old":
+                    keyword_args, required_num_args, _, _ = utils.parse_format_string(
+                        format_string
+                    )
+                    if keyword_args:
+                        # Keyword checking on logging strings is complicated by
+                        # special keywords - out of scope.
+                        return
+                elif self._format_style == "new":
+                    (
+                        keyword_arguments,
+                        implicit_pos_args,
+                        explicit_pos_args,
+                    ) = utils.parse_format_method_string(format_string)
+
+                    keyword_args_cnt = len(
+                        {k for k, l in keyword_arguments if not isinstance(k, int)}
+                    )
+                    required_num_args = (
+                        keyword_args_cnt + implicit_pos_args + explicit_pos_args
+                    )
+            except utils.UnsupportedFormatCharacter as ex:
+                char = format_string[ex.index]
+                self.add_message(
+                    "logging-unsupported-format",
+                    node=node,
+                    args=(char, ord(char), ex.index),
+                )
+                return
+            except utils.IncompleteFormatString:
+                self.add_message("logging-format-truncated", node=node)
+                return
+        if num_args > required_num_args:
+            self.add_message("logging-too-many-args", node=node)
+        elif num_args < required_num_args:
+            self.add_message("logging-too-few-args", node=node)
+
+
+def is_complex_format_str(node: nodes.NodeNG) -> bool:
+    """Return whether the node represents a string with complex formatting specs."""
+    inferred = utils.safe_infer(node)
+    if inferred is None or not (
+        isinstance(inferred, nodes.Const) and isinstance(inferred.value, str)
+    ):
+        return True
+    try:
+        parsed = list(string.Formatter().parse(inferred.value))
+    except ValueError:
+        # This format string is invalid
+        return False
+    return any(format_spec for (_, _, format_spec, _) in parsed)
+
+
+def _count_supplied_tokens(args):
+    """Counts the number of tokens in an args list.
+
+    The Python log functions allow for special keyword arguments: func,
+    exc_info and extra. To handle these cases correctly, we only count
+    arguments that aren't keywords.
+
+    Args:
+      args (list): AST nodes that are arguments for a log format string.
+
+    Returns:
+      int: Number of AST nodes that aren't keywords.
+    """
+    return sum(1 for arg in args if not isinstance(arg, nodes.Keyword))
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(LoggingChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/mapreduce_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/mapreduce_checker.py
new file mode 100644
index 0000000..d6ee875
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/mapreduce_checker.py
@@ -0,0 +1,17 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import abc
+
+
+class MapReduceMixin(metaclass=abc.ABCMeta):
+    """A mixin design to allow multiprocess/threaded runs of a Checker."""
+
+    @abc.abstractmethod
+    def get_map_data(self):
+        """Returns mergeable/reducible data that will be examined."""
+
+    @abc.abstractmethod
+    def reduce_map_data(self, linter, data):
+        """For a given Checker, receives data for all mapped runs."""
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/misc.py b/myenv/lib/python3.9/site-packages/pylint/checkers/misc.py
new file mode 100644
index 0000000..e5e77bb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/misc.py
@@ -0,0 +1,182 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Check source code is ascii only or has an encoding declaration (PEP 263)."""
+
+import re
+import tokenize
+from typing import TYPE_CHECKING, List, Optional
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.interfaces import IRawChecker, ITokenChecker
+from pylint.typing import ManagedMessage
+from pylint.utils.pragma_parser import OPTION_PO, PragmaParserError, parse_pragma
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class ByIdManagedMessagesChecker(BaseChecker):
+
+    """Checks for messages that are enabled or disabled by id instead of symbol."""
+
+    __implements__ = IRawChecker
+    name = "miscellaneous"
+    msgs = {
+        "I0023": (
+            "%s",
+            "use-symbolic-message-instead",
+            "Used when a message is enabled or disabled by id.",
+        )
+    }
+    options = ()
+
+    def _clear_by_id_managed_msgs(self) -> None:
+        self.linter._by_id_managed_msgs.clear()
+
+    def _get_by_id_managed_msgs(self) -> List[ManagedMessage]:
+        return self.linter._by_id_managed_msgs
+
+    def process_module(self, node: nodes.Module) -> None:
+        """Inspect the source file to find messages activated or deactivated by id."""
+        managed_msgs = self._get_by_id_managed_msgs()
+        for (mod_name, msgid, symbol, lineno, is_disabled) in managed_msgs:
+            if mod_name == node.name:
+                verb = "disable" if is_disabled else "enable"
+                txt = f"'{msgid}' is cryptic: use '# pylint: {verb}={symbol}' instead"
+                self.add_message("use-symbolic-message-instead", line=lineno, args=txt)
+        self._clear_by_id_managed_msgs()
+
+
+class EncodingChecker(BaseChecker):
+
+    """BaseChecker for encoding issues.
+
+    Checks for:
+    * warning notes in the code like FIXME, XXX
+    * encoding issues.
+    """
+
+    __implements__ = (IRawChecker, ITokenChecker)
+
+    # configuration section name
+    name = "miscellaneous"
+    msgs = {
+        "W0511": (
+            "%s",
+            "fixme",
+            "Used when a warning note as FIXME or XXX is detected.",
+        )
+    }
+
+    options = (
+        (
+            "notes",
+            {
+                "type": "csv",
+                "metavar": "<comma separated values>",
+                "default": ("FIXME", "XXX", "TODO"),
+                "help": (
+                    "List of note tags to take in consideration, "
+                    "separated by a comma."
+                ),
+            },
+        ),
+        (
+            "notes-rgx",
+            {
+                "type": "string",
+                "metavar": "<regexp>",
+                "help": "Regular expression of note tags to take in consideration.",
+            },
+        ),
+    )
+
+    def open(self):
+        super().open()
+
+        notes = "|".join(re.escape(note) for note in self.config.notes)
+        if self.config.notes_rgx:
+            regex_string = rf"#\s*({notes}|{self.config.notes_rgx})(?=(:|\s|\Z))"
+        else:
+            regex_string = rf"#\s*({notes})(?=(:|\s|\Z))"
+
+        self._fixme_pattern = re.compile(regex_string, re.I)
+
+    def _check_encoding(
+        self, lineno: int, line: bytes, file_encoding: str
+    ) -> Optional[str]:
+        try:
+            return line.decode(file_encoding)
+        except UnicodeDecodeError:
+            pass
+        except LookupError:
+            if (
+                line.startswith(b"#")
+                and "coding" in str(line)
+                and file_encoding in str(line)
+            ):
+                msg = f"Cannot decode using encoding '{file_encoding}', bad encoding"
+                self.add_message("syntax-error", line=lineno, args=msg)
+        return None
+
+    def process_module(self, node: nodes.Module) -> None:
+        """Inspect the source file to find encoding problem."""
+        encoding = node.file_encoding if node.file_encoding else "ascii"
+
+        with node.stream() as stream:
+            for lineno, line in enumerate(stream):
+                self._check_encoding(lineno + 1, line, encoding)
+
+    def process_tokens(self, tokens):
+        """Inspect the source to find fixme problems."""
+        if not self.config.notes:
+            return
+        comments = (
+            token_info for token_info in tokens if token_info.type == tokenize.COMMENT
+        )
+        for comment in comments:
+            comment_text = comment.string[1:].lstrip()  # trim '#' and whitespaces
+
+            # handle pylint disable clauses
+            disable_option_match = OPTION_PO.search(comment_text)
+            if disable_option_match:
+                try:
+                    values = []
+                    try:
+                        for pragma_repr in (
+                            p_rep
+                            for p_rep in parse_pragma(disable_option_match.group(2))
+                            if p_rep.action == "disable"
+                        ):
+                            values.extend(pragma_repr.messages)
+                    except PragmaParserError:
+                        # Printing useful information dealing with this error is done in the lint package
+                        pass
+                    if set(values) & set(self.config.notes):
+                        continue
+                except ValueError:
+                    self.add_message(
+                        "bad-inline-option",
+                        args=disable_option_match.group(1).strip(),
+                        line=comment.start[0],
+                    )
+                    continue
+
+            # emit warnings if necessary
+            match = self._fixme_pattern.search("#" + comment_text.lower())
+            if match:
+                self.add_message(
+                    "fixme",
+                    col_offset=comment.start[1] + 1,
+                    args=comment_text,
+                    line=comment.start[0],
+                )
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(EncodingChecker(linter))
+    linter.register_checker(ByIdManagedMessagesChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/modified_iterating_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/modified_iterating_checker.py
new file mode 100644
index 0000000..ca2a0c9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/modified_iterating_checker.py
@@ -0,0 +1,156 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import TYPE_CHECKING, Union
+
+from astroid import nodes
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+_LIST_MODIFIER_METHODS = {"append", "remove"}
+_SET_MODIFIER_METHODS = {"add", "remove"}
+
+
+class ModifiedIterationChecker(checkers.BaseChecker):
+    """Checks for modified iterators in for loops iterations.
+
+    Currently supports `for` loops for Sets, Dictionaries and Lists.
+    """
+
+    __implements__ = interfaces.IAstroidChecker
+
+    name = "modified_iteration"
+
+    msgs = {
+        "W4701": (
+            "Iterated list '%s' is being modified inside for loop body, consider iterating through a copy of it "
+            "instead.",
+            "modified-iterating-list",
+            "Emitted when items are added or removed to a list being iterated through. "
+            "Doing so can result in unexpected behaviour, that is why it is preferred to use a copy of the list.",
+        ),
+        "E4702": (
+            "Iterated dict '%s' is being modified inside for loop body, iterate through a copy of it instead.",
+            "modified-iterating-dict",
+            "Emitted when items are added or removed to a dict being iterated through. "
+            "Doing so raises a RuntimeError.",
+        ),
+        "E4703": (
+            "Iterated set '%s' is being modified inside for loop body, iterate through a copy of it instead.",
+            "modified-iterating-set",
+            "Emitted when items are added or removed to a set being iterated through. "
+            "Doing so raises a RuntimeError.",
+        ),
+    }
+
+    options = ()
+    priority = -2
+
+    @utils.check_messages(
+        "modified-iterating-list", "modified-iterating-dict", "modified-iterating-set"
+    )
+    def visit_for(self, node: nodes.For) -> None:
+        iter_obj = node.iter
+        if isinstance(iter_obj, nodes.Name):
+            for body_node in node.body:
+                self._modified_iterating_check_on_node_and_children(body_node, iter_obj)
+
+    def _modified_iterating_check_on_node_and_children(
+        self, body_node: nodes.NodeNG, iter_obj: nodes.NodeNG
+    ) -> None:
+        """See if node or any of its children raises modified iterating messages."""
+        self._modified_iterating_check(body_node, iter_obj)
+        for child in body_node.get_children():
+            self._modified_iterating_check_on_node_and_children(child, iter_obj)
+
+    def _modified_iterating_check(
+        self, node: nodes.NodeNG, iter_obj: nodes.NodeNG
+    ) -> None:
+        msg_id = None
+        if self._modified_iterating_list_cond(node, iter_obj):
+            msg_id = "modified-iterating-list"
+        elif self._modified_iterating_dict_cond(node, iter_obj):
+            msg_id = "modified-iterating-dict"
+        elif self._modified_iterating_set_cond(node, iter_obj):
+            msg_id = "modified-iterating-set"
+        if msg_id:
+            self.add_message(
+                msg_id,
+                node=node,
+                args=(iter_obj.name,),
+                confidence=interfaces.INFERENCE,
+            )
+
+    @staticmethod
+    def _is_node_expr_that_calls_attribute_name(node: nodes.NodeNG) -> bool:
+        return (
+            isinstance(node, nodes.Expr)
+            and isinstance(node.value, nodes.Call)
+            and isinstance(node.value.func, nodes.Attribute)
+            and isinstance(node.value.func.expr, nodes.Name)
+        )
+
+    @staticmethod
+    def _common_cond_list_set(
+        node: nodes.Expr,
+        iter_obj: nodes.NodeNG,
+        infer_val: Union[nodes.List, nodes.Set],
+    ) -> bool:
+        return (infer_val == utils.safe_infer(iter_obj)) and (
+            node.value.func.expr.name == iter_obj.name
+        )
+
+    @staticmethod
+    def _is_node_assigns_subscript_name(node: nodes.NodeNG) -> bool:
+        return isinstance(node, nodes.Assign) and (
+            isinstance(node.targets[0], nodes.Subscript)
+            and (isinstance(node.targets[0].value, nodes.Name))
+        )
+
+    def _modified_iterating_list_cond(
+        self, node: nodes.NodeNG, iter_obj: nodes.NodeNG
+    ) -> bool:
+        if not self._is_node_expr_that_calls_attribute_name(node):
+            return False
+        infer_val = utils.safe_infer(node.value.func.expr)
+        if not isinstance(infer_val, nodes.List):
+            return False
+        return (
+            self._common_cond_list_set(node, iter_obj, infer_val)
+            and node.value.func.attrname in _LIST_MODIFIER_METHODS
+        )
+
+    def _modified_iterating_dict_cond(
+        self, node: nodes.NodeNG, iter_obj: nodes.NodeNG
+    ) -> bool:
+        if not self._is_node_assigns_subscript_name(node):
+            return False
+        infer_val = utils.safe_infer(node.targets[0].value)
+        if not isinstance(infer_val, nodes.Dict):
+            return False
+        if infer_val != utils.safe_infer(iter_obj):
+            return False
+        return node.targets[0].value.name == iter_obj.name
+
+    def _modified_iterating_set_cond(
+        self, node: nodes.NodeNG, iter_obj: nodes.NodeNG
+    ) -> bool:
+        if not self._is_node_expr_that_calls_attribute_name(node):
+            return False
+        infer_val = utils.safe_infer(node.value.func.expr)
+        if not isinstance(infer_val, nodes.Set):
+            return False
+        return (
+            self._common_cond_list_set(node, iter_obj, infer_val)
+            and node.value.func.attrname in _SET_MODIFIER_METHODS
+        )
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(ModifiedIterationChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/newstyle.py b/myenv/lib/python3.9/site-packages/pylint/checkers/newstyle.py
new file mode 100644
index 0000000..15833f2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/newstyle.py
@@ -0,0 +1,123 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Check for new / old style related problems."""
+from typing import TYPE_CHECKING
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages, has_known_bases, node_frame_class
+from pylint.interfaces import IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+MSGS = {
+    "E1003": (
+        "Bad first argument %r given to super()",
+        "bad-super-call",
+        "Used when another argument than the current class is given as "
+        "first argument of the super builtin.",
+    )
+}
+
+
+class NewStyleConflictChecker(BaseChecker):
+    """Checks for usage of new style capabilities on old style classes and
+    other new/old styles conflicts problems.
+
+    * use of property, __slots__, super
+    * "super" usage
+    """
+
+    __implements__ = (IAstroidChecker,)
+
+    # configuration section name
+    name = "newstyle"
+    # messages
+    msgs = MSGS
+    priority = -2
+    # configuration options
+    options = ()
+
+    @check_messages("bad-super-call")
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        """Check use of super."""
+        # ignore actual functions or method within a new style class
+        if not node.is_method():
+            return
+        klass = node.parent.frame(future=True)
+        for stmt in node.nodes_of_class(nodes.Call):
+            if node_frame_class(stmt) != node_frame_class(node):
+                # Don't look down in other scopes.
+                continue
+
+            expr = stmt.func
+            if not isinstance(expr, nodes.Attribute):
+                continue
+
+            call = expr.expr
+            # skip the test if using super
+            if not (
+                isinstance(call, nodes.Call)
+                and isinstance(call.func, nodes.Name)
+                and call.func.name == "super"
+            ):
+                continue
+
+            # super should not be used on an old style class
+            if klass.newstyle or not has_known_bases(klass):
+                # super first arg should not be the class
+                if not call.args:
+                    continue
+
+                # calling super(type(self), self) can lead to recursion loop
+                # in derived classes
+                arg0 = call.args[0]
+                if (
+                    isinstance(arg0, nodes.Call)
+                    and isinstance(arg0.func, nodes.Name)
+                    and arg0.func.name == "type"
+                ):
+                    self.add_message("bad-super-call", node=call, args=("type",))
+                    continue
+
+                # calling super(self.__class__, self) can lead to recursion loop
+                # in derived classes
+                if (
+                    len(call.args) >= 2
+                    and isinstance(call.args[1], nodes.Name)
+                    and call.args[1].name == "self"
+                    and isinstance(arg0, nodes.Attribute)
+                    and arg0.attrname == "__class__"
+                ):
+                    self.add_message(
+                        "bad-super-call", node=call, args=("self.__class__",)
+                    )
+                    continue
+
+                try:
+                    supcls = call.args and next(call.args[0].infer(), None)
+                except astroid.InferenceError:
+                    continue
+
+                if klass is not supcls:
+                    name = None
+                    # if supcls is not Uninferable, then supcls was inferred
+                    # and use its name. Otherwise, try to look
+                    # for call.args[0].name
+                    if supcls:
+                        name = supcls.name
+                    elif call.args and hasattr(call.args[0], "name"):
+                        name = call.args[0].name
+                    if name:
+                        self.add_message("bad-super-call", node=call, args=(name,))
+
+    visit_asyncfunctiondef = visit_functiondef
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(NewStyleConflictChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/non_ascii_names.py b/myenv/lib/python3.9/site-packages/pylint/checkers/non_ascii_names.py
new file mode 100644
index 0000000..ece663a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/non_ascii_names.py
@@ -0,0 +1,201 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""All alphanumeric unicode character are allowed in Python but due
+to similarities in how they look they can be confused.
+
+See: https://www.python.org/dev/peps/pep-0672/#confusable-characters-in-identifiers
+
+The following checkers are intended to make users are aware of these issues.
+"""
+
+import sys
+from typing import Optional, Union
+
+from astroid import nodes
+
+from pylint import constants, interfaces, lint
+from pylint.checkers import base_checker, utils
+
+if sys.version_info[:2] >= (3, 7):
+    # pylint: disable-next=fixme
+    # TODO: Remove after 3.6 has been deprecated
+    Py37Str = str
+else:
+
+    class Py37Str(str):
+        # Allow Python 3.6 compatibility
+        def isascii(self: str) -> bool:
+            return all("\u0000" <= x <= "\u007F" for x in self)
+
+
+NON_ASCII_HELP = (
+    "Used when the name contains at least one non-ASCII unicode character. "
+    "See https://www.python.org/dev/peps/pep-0672/#confusable-characters-in-identifiers"
+    " for a background why this could be bad. \n"
+    "If your programming guideline defines that you are programming in "
+    "English, then there should be no need for non ASCII characters in "
+    "Python Names. If not you can simply disable this check."
+)
+
+
+class NonAsciiNameChecker(base_checker.BaseChecker):
+    """A strict name checker only allowing ASCII.
+
+    Note: This check only checks Names, so it ignores the content of
+          docstrings and comments!
+    """
+
+    __implements__ = interfaces.IAstroidChecker
+    priority = -1
+
+    msgs = {
+        "C2401": (
+            '%s name "%s" contains a non-ASCII character, consider renaming it.',
+            "non-ascii-name",
+            NON_ASCII_HELP,
+            {"old_names": [("C0144", "old-non-ascii-name")]},
+        ),
+        # First %s will always be "file"
+        "W2402": (
+            (
+                '%s name "%s" contains a non-ASCII character. PEP 3131 only allows '
+                "non-ascii identifiers, not file names."
+            ),
+            "non-ascii-file-name",
+            (
+                # Some = PyCharm at the time of writing didn't display the non_ascii_name_loł
+                # files and had big troubles with git.
+                # Probably only a bug shows the problem quite good.
+                # That's also why this is a warning and not only a convention!
+                "Some editors don't support non-ASCII file names properly. "
+                "Even though Python supports UTF-8 files since Python 3.5 this isn't "
+                "recommended for interoperability. Further reading:\n"
+                "- https://www.python.org/dev/peps/pep-0489/#export-hook-name\n"
+                "- https://www.python.org/dev/peps/pep-0672/#confusable-characters-in-identifiers\n"
+                "- https://bugs.python.org/issue20485"
+            ),
+        ),
+        # First %s will always be "module"
+        "C2403": (
+            '%s name "%s" contains a non-ASCII character, use an ASCII-only alias for import.',
+            "non-ascii-module-import",
+            NON_ASCII_HELP,
+        ),
+    }
+
+    name = "NonASCII-Checker"
+
+    def _check_name(
+        self, node_type: str, name: Optional[str], node: nodes.NodeNG
+    ) -> None:
+        """Check whether a name is using non-ASCII characters."""
+
+        if name is None:
+            # For some nodes i.e. *kwargs from a dict, the name will be empty
+            return
+
+        if not (Py37Str(name).isascii()):
+            type_label = constants.HUMAN_READABLE_TYPES[node_type]
+            args = (type_label.capitalize(), name)
+
+            msg = "non-ascii-name"
+
+            # Some node types have customized messages
+            if node_type == "file":
+                msg = "non-ascii-file-name"
+            elif node_type == "module":
+                msg = "non-ascii-module-import"
+
+            self.add_message(msg, node=node, args=args, confidence=interfaces.HIGH)
+
+    @utils.check_messages("non-ascii-name")
+    def visit_module(self, node: nodes.Module) -> None:
+        self._check_name("file", node.name.split(".")[-1], node)
+
+    @utils.check_messages("non-ascii-name")
+    def visit_functiondef(
+        self, node: Union[nodes.FunctionDef, nodes.AsyncFunctionDef]
+    ) -> None:
+        self._check_name("function", node.name, node)
+
+        # Check argument names
+        arguments = node.args
+
+        # Check position only arguments
+        if arguments.posonlyargs:
+            for pos_only_arg in arguments.posonlyargs:
+                self._check_name("argument", pos_only_arg.name, pos_only_arg)
+
+        # Check "normal" arguments
+        if arguments.args:
+            for arg in arguments.args:
+                self._check_name("argument", arg.name, arg)
+
+        # Check key word only arguments
+        if arguments.kwonlyargs:
+            for kwarg in arguments.kwonlyargs:
+                self._check_name("argument", kwarg.name, kwarg)
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    @utils.check_messages("non-ascii-name")
+    def visit_global(self, node: nodes.Global) -> None:
+        for name in node.names:
+            self._check_name("const", name, node)
+
+    @utils.check_messages("non-ascii-name")
+    def visit_assignname(self, node: nodes.AssignName) -> None:
+        """Check module level assigned names."""
+        # The NameChecker from which this Checker originates knows a lot of different
+        # versions of variables, i.e. constants, inline variables etc.
+        # To simplify we use only `variable` here, as we don't need to apply different
+        # rules to different types of variables.
+        frame = node.frame()
+
+        if isinstance(frame, nodes.FunctionDef):
+            if node.parent in frame.body:
+                # Only perform the check if the assignment was done in within the body
+                # of the function (and not the function parameter definition
+                # (will be handled in visit_functiondef)
+                # or within a decorator (handled in visit_call)
+                self._check_name("variable", node.name, node)
+        elif isinstance(frame, nodes.ClassDef):
+            self._check_name("attr", node.name, node)
+        else:
+            # Possibilities here:
+            # - isinstance(node.assign_type(), nodes.Comprehension) == inlinevar
+            # - isinstance(frame, nodes.Module) == variable (constant?)
+            # - some other kind of assigment missed but still most likely a variable
+            self._check_name("variable", node.name, node)
+
+    @utils.check_messages("non-ascii-name")
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        self._check_name("class", node.name, node)
+        for attr, anodes in node.instance_attrs.items():
+            if not any(node.instance_attr_ancestors(attr)):
+                self._check_name("attr", attr, anodes[0])
+
+    def _check_module_import(self, node: Union[nodes.ImportFrom, nodes.Import]) -> None:
+        for module_name, alias in node.names:
+            name = alias or module_name
+            self._check_name("module", name, node)
+
+    @utils.check_messages("non-ascii-name")
+    def visit_import(self, node: nodes.Import) -> None:
+        self._check_module_import(node)
+
+    @utils.check_messages("non-ascii-name")
+    def visit_importfrom(self, node: nodes.ImportFrom) -> None:
+        self._check_module_import(node)
+
+    @utils.check_messages("non-ascii-name")
+    def visit_call(self, node: nodes.Call) -> None:
+        """Check if the used keyword args are correct."""
+        for keyword in node.keywords:
+            self._check_name("argument", keyword.arg, keyword)
+
+
+def register(linter: lint.PyLinter) -> None:
+    linter.register_checker(NonAsciiNameChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/raw_metrics.py b/myenv/lib/python3.9/site-packages/pylint/checkers/raw_metrics.py
new file mode 100644
index 0000000..524ecbf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/raw_metrics.py
@@ -0,0 +1,117 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import sys
+import tokenize
+from typing import TYPE_CHECKING, Any, Optional, cast
+
+from pylint.checkers import BaseTokenChecker
+from pylint.interfaces import ITokenChecker
+from pylint.reporters.ureports.nodes import Table
+from pylint.utils import LinterStats, diff_string
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+def report_raw_stats(
+    sect,
+    stats: LinterStats,
+    old_stats: Optional[LinterStats],
+) -> None:
+    """Calculate percentage of code / doc / comment / empty."""
+    total_lines = stats.code_type_count["total"]
+    sect.description = f"{total_lines} lines have been analyzed"
+    lines = ["type", "number", "%", "previous", "difference"]
+    for node_type in ("code", "docstring", "comment", "empty"):
+        node_type = cast(Literal["code", "docstring", "comment", "empty"], node_type)
+        total = stats.code_type_count[node_type]
+        percent = float(total * 100) / total_lines if total_lines else None
+        old = old_stats.code_type_count[node_type] if old_stats else None
+        diff_str = diff_string(old, total) if old else None
+        lines += [
+            node_type,
+            str(total),
+            f"{percent:.2f}" if percent is not None else "NC",
+            str(old) if old else "NC",
+            diff_str if diff_str else "NC",
+        ]
+    sect.append(Table(children=lines, cols=5, rheaders=1))
+
+
+class RawMetricsChecker(BaseTokenChecker):
+    """Checker that provides raw metrics instead of checking anything.
+
+    Provides:
+    * total number of lines
+    * total number of code lines
+    * total number of docstring lines
+    * total number of comments lines
+    * total number of empty lines
+    """
+
+    __implements__ = (ITokenChecker,)
+
+    # configuration section name
+    name = "metrics"
+    # configuration options
+    options = ()
+    # messages
+    msgs: Any = {}
+    # reports
+    reports = (("RP0701", "Raw metrics", report_raw_stats),)
+
+    def __init__(self, linter):
+        super().__init__(linter)
+
+    def open(self):
+        """Init statistics."""
+        self.linter.stats.reset_code_count()
+
+    def process_tokens(self, tokens):
+        """Update stats."""
+        i = 0
+        tokens = list(tokens)
+        while i < len(tokens):
+            i, lines_number, line_type = get_type(tokens, i)
+            self.linter.stats.code_type_count["total"] += lines_number
+            self.linter.stats.code_type_count[line_type] += lines_number
+
+
+JUNK = (tokenize.NL, tokenize.INDENT, tokenize.NEWLINE, tokenize.ENDMARKER)
+
+
+def get_type(tokens, start_index):
+    """Return the line type : docstring, comment, code, empty."""
+    i = start_index
+    start = tokens[i][2]
+    pos = start
+    line_type = None
+    while i < len(tokens) and tokens[i][2][0] == start[0]:
+        tok_type = tokens[i][0]
+        pos = tokens[i][3]
+        if line_type is None:
+            if tok_type == tokenize.STRING:
+                line_type = "docstring"
+            elif tok_type == tokenize.COMMENT:
+                line_type = "comment"
+            elif tok_type in JUNK:
+                pass
+            else:
+                line_type = "code"
+        i += 1
+    if line_type is None:
+        line_type = "empty"
+    elif i < len(tokens) and tokens[i][0] == tokenize.NEWLINE:
+        i += 1
+    return i, pos[0] - start[0] + 1, line_type
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(RawMetricsChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/__init__.py b/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/__init__.py
new file mode 100644
index 0000000..481845f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/__init__.py
@@ -0,0 +1,32 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Looks for code which can be refactored."""
+
+
+from typing import TYPE_CHECKING
+
+from pylint.checkers.refactoring.implicit_booleaness_checker import (
+    ImplicitBooleanessChecker,
+)
+from pylint.checkers.refactoring.not_checker import NotChecker
+from pylint.checkers.refactoring.recommendation_checker import RecommendationChecker
+from pylint.checkers.refactoring.refactoring_checker import RefactoringChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+__all__ = [
+    "ImplicitBooleanessChecker",
+    "NotChecker",
+    "RecommendationChecker",
+    "RefactoringChecker",
+]
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(RefactoringChecker(linter))
+    linter.register_checker(NotChecker(linter))
+    linter.register_checker(RecommendationChecker(linter))
+    linter.register_checker(ImplicitBooleanessChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/implicit_booleaness_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/implicit_booleaness_checker.py
new file mode 100644
index 0000000..e52b972
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/implicit_booleaness_checker.py
@@ -0,0 +1,222 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import List, Union
+
+import astroid
+from astroid import bases, nodes
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+
+class ImplicitBooleanessChecker(checkers.BaseChecker):
+    """Checks for incorrect usage of comparisons or len() inside conditions.
+
+    Incorrect usage of len()
+    Pep8 states:
+    For sequences, (strings, lists, tuples), use the fact that empty sequences are false.
+
+        Yes: if not seq:
+             if seq:
+
+        No: if len(seq):
+            if not len(seq):
+
+    Problems detected:
+    * if len(sequence):
+    * if not len(sequence):
+    * elif len(sequence):
+    * elif not len(sequence):
+    * while len(sequence):
+    * while not len(sequence):
+    * assert len(sequence):
+    * assert not len(sequence):
+    * bool(len(sequence))
+
+    Incorrect usage of empty literal sequences; (), [], {},
+
+    For empty sequences, (dicts, lists, tuples), use the fact that empty sequences are false.
+
+        Yes: if variable:
+             if not variable
+
+        No: if variable == empty_literal:
+            if variable != empty_literal:
+
+    Problems detected:
+    * comparison such as variable == empty_literal:
+    * comparison such as variable != empty_literal:
+    """
+
+    __implements__ = (interfaces.IAstroidChecker,)
+
+    # configuration section name
+    name = "refactoring"
+    msgs = {
+        "C1802": (
+            "Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty",
+            "use-implicit-booleaness-not-len",
+            "Used when Pylint detects that len(sequence) is being used "
+            "without explicit comparison inside a condition to determine if a sequence is empty. "
+            "Instead of coercing the length to a boolean, either "
+            "rely on the fact that empty sequences are false or "
+            "compare the length against a scalar.",
+            {"old_names": [("C1801", "len-as-condition")]},
+        ),
+        "C1803": (
+            "'%s' can be simplified to '%s' as an empty sequence is falsey",
+            "use-implicit-booleaness-not-comparison",
+            "Used when Pylint detects that collection literal comparison is being "
+            "used to check for emptiness; Use implicit booleaness instead"
+            "of a collection classes; empty collections are considered as false",
+        ),
+    }
+
+    priority = -2
+    options = ()
+
+    @utils.check_messages("use-implicit-booleaness-not-len")
+    def visit_call(self, node: nodes.Call) -> None:
+        # a len(S) call is used inside a test condition
+        # could be if, while, assert or if expression statement
+        # e.g. `if len(S):`
+        if not utils.is_call_of_name(node, "len"):
+            return
+        # the len() call could also be nested together with other
+        # boolean operations, e.g. `if z or len(x):`
+        parent = node.parent
+        while isinstance(parent, nodes.BoolOp):
+            parent = parent.parent
+        # we're finally out of any nested boolean operations so check if
+        # this len() call is part of a test condition
+        if not utils.is_test_condition(node, parent):
+            return
+        len_arg = node.args[0]
+        generator_or_comprehension = (
+            nodes.ListComp,
+            nodes.SetComp,
+            nodes.DictComp,
+            nodes.GeneratorExp,
+        )
+        if isinstance(len_arg, generator_or_comprehension):
+            # The node is a generator or comprehension as in len([x for x in ...])
+            self.add_message("use-implicit-booleaness-not-len", node=node)
+            return
+        try:
+            instance = next(len_arg.infer())
+        except astroid.InferenceError:
+            # Probably undefined-variable, abort check
+            return
+        mother_classes = self.base_names_of_instance(instance)
+        affected_by_pep8 = any(
+            t in mother_classes for t in ("str", "tuple", "list", "set")
+        )
+        if "range" in mother_classes or (
+            affected_by_pep8 and not self.instance_has_bool(instance)
+        ):
+            self.add_message("use-implicit-booleaness-not-len", node=node)
+
+    @staticmethod
+    def instance_has_bool(class_def: nodes.ClassDef) -> bool:
+        try:
+            class_def.getattr("__bool__")
+            return True
+        except astroid.AttributeInferenceError:
+            ...
+        return False
+
+    @utils.check_messages("use-implicit-booleaness-not-len")
+    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
+        """`not len(S)` must become `not S` regardless if the parent block
+        is a test condition or something else (boolean expression) e.g. `if not len(S):`
+        """
+        if (
+            isinstance(node, nodes.UnaryOp)
+            and node.op == "not"
+            and utils.is_call_of_name(node.operand, "len")
+        ):
+            self.add_message("use-implicit-booleaness-not-len", node=node)
+
+    @utils.check_messages("use-implicit-booleaness-not-comparison")
+    def visit_compare(self, node: nodes.Compare) -> None:
+        self._check_use_implicit_booleaness_not_comparison(node)
+
+    def _check_use_implicit_booleaness_not_comparison(
+        self, node: nodes.Compare
+    ) -> None:
+        """Check for left side and right side of the node for empty literals."""
+        is_left_empty_literal = utils.is_base_container(
+            node.left
+        ) or utils.is_empty_dict_literal(node.left)
+
+        # Check both left-hand side and right-hand side for literals
+        for operator, comparator in node.ops:
+            is_right_empty_literal = utils.is_base_container(
+                comparator
+            ) or utils.is_empty_dict_literal(comparator)
+            # Using Exclusive OR (XOR) to compare between two side.
+            # If two sides are both literal, it should be different error.
+            if is_right_empty_literal ^ is_left_empty_literal:
+                # set target_node to opposite side of literal
+                target_node = node.left if is_right_empty_literal else comparator
+                literal_node = comparator if is_right_empty_literal else node.left
+                # Infer node to check
+                target_instance = utils.safe_infer(target_node)
+                if target_instance is None:
+                    continue
+                mother_classes = self.base_names_of_instance(target_instance)
+                is_base_comprehension_type = any(
+                    t in mother_classes for t in ("tuple", "list", "dict", "set")
+                )
+
+                # Only time we bypass check is when target_node is not inherited by
+                # collection literals and have its own __bool__ implementation.
+                if not is_base_comprehension_type and self.instance_has_bool(
+                    target_instance
+                ):
+                    continue
+
+                # No need to check for operator when visiting compare node
+                if operator in {"==", "!=", ">=", ">", "<=", "<"}:
+                    collection_literal = "{}"
+                    if isinstance(literal_node, nodes.List):
+                        collection_literal = "[]"
+                    if isinstance(literal_node, nodes.Tuple):
+                        collection_literal = "()"
+
+                    instance_name = "x"
+                    if isinstance(target_node, nodes.Call) and target_node.func:
+                        instance_name = f"{target_node.func.as_string()}(...)"
+                    elif isinstance(target_node, (nodes.Attribute, nodes.Name)):
+                        instance_name = target_node.as_string()
+
+                    original_comparison = (
+                        f"{instance_name} {operator} {collection_literal}"
+                    )
+                    suggestion = (
+                        f"{instance_name}"
+                        if operator == "!="
+                        else f"not {instance_name}"
+                    )
+                    self.add_message(
+                        "use-implicit-booleaness-not-comparison",
+                        args=(
+                            original_comparison,
+                            suggestion,
+                        ),
+                        node=node,
+                    )
+
+    @staticmethod
+    def base_names_of_instance(
+        node: Union[bases.Uninferable, bases.Instance]
+    ) -> List[str]:
+        """Return all names inherited by a class instance or those returned by a function.
+
+        The inherited names include 'object'.
+        """
+        if isinstance(node, bases.Instance):
+            return [node.name] + [x.name for x in node.ancestors()]
+        return []
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/not_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/not_checker.py
new file mode 100644
index 0000000..85d33bf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/not_checker.py
@@ -0,0 +1,83 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import astroid
+from astroid import nodes
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+
+class NotChecker(checkers.BaseChecker):
+    """Checks for too many not in comparison expressions.
+
+    - "not not" should trigger a warning
+    - "not" followed by a comparison should trigger a warning
+    """
+
+    __implements__ = (interfaces.IAstroidChecker,)
+    msgs = {
+        "C0113": (
+            'Consider changing "%s" to "%s"',
+            "unneeded-not",
+            "Used when a boolean expression contains an unneeded negation.",
+        )
+    }
+    name = "refactoring"
+    reverse_op = {
+        "<": ">=",
+        "<=": ">",
+        ">": "<=",
+        ">=": "<",
+        "==": "!=",
+        "!=": "==",
+        "in": "not in",
+        "is": "is not",
+    }
+    # sets are not ordered, so for example "not set(LEFT_VALS) <= set(RIGHT_VALS)" is
+    # not equivalent to "set(LEFT_VALS) > set(RIGHT_VALS)"
+    skipped_nodes = (nodes.Set,)
+    # 'builtins' py3, '__builtin__' py2
+    skipped_classnames = [f"builtins.{qname}" for qname in ("set", "frozenset")]
+
+    @utils.check_messages("unneeded-not")
+    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
+        if node.op != "not":
+            return
+        operand = node.operand
+
+        if isinstance(operand, nodes.UnaryOp) and operand.op == "not":
+            self.add_message(
+                "unneeded-not",
+                node=node,
+                args=(node.as_string(), operand.operand.as_string()),
+            )
+        elif isinstance(operand, nodes.Compare):
+            left = operand.left
+            # ignore multiple comparisons
+            if len(operand.ops) > 1:
+                return
+            operator, right = operand.ops[0]
+            if operator not in self.reverse_op:
+                return
+            # Ignore __ne__ as function of __eq__
+            frame = node.frame(future=True)
+            if frame.name == "__ne__" and operator == "==":
+                return
+            for _type in (utils.node_type(left), utils.node_type(right)):
+                if not _type:
+                    return
+                if isinstance(_type, self.skipped_nodes):
+                    return
+                if (
+                    isinstance(_type, astroid.Instance)
+                    and _type.qname() in self.skipped_classnames
+                ):
+                    return
+            suggestion = (
+                f"{left.as_string()} {self.reverse_op[operator]} {right.as_string()}"
+            )
+            self.add_message(
+                "unneeded-not", node=node, args=(node.as_string(), suggestion)
+            )
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/recommendation_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/recommendation_checker.py
new file mode 100644
index 0000000..1fb7e72
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/recommendation_checker.py
@@ -0,0 +1,411 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import Union
+
+import astroid
+from astroid import nodes
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+from pylint.utils.utils import get_global_option
+
+
+class RecommendationChecker(checkers.BaseChecker):
+
+    __implements__ = (interfaces.IAstroidChecker,)
+    name = "refactoring"
+    msgs = {
+        "C0200": (
+            "Consider using enumerate instead of iterating with range and len",
+            "consider-using-enumerate",
+            "Emitted when code that iterates with range and len is "
+            "encountered. Such code can be simplified by using the "
+            "enumerate builtin.",
+        ),
+        "C0201": (
+            "Consider iterating the dictionary directly instead of calling .keys()",
+            "consider-iterating-dictionary",
+            "Emitted when the keys of a dictionary are iterated through the ``.keys()`` "
+            "method or when ``.keys()`` is used for a membership check. "
+            "It is enough to iterate through the dictionary itself, "
+            "``for key in dictionary``. For membership checks, "
+            "``if key in dictionary`` is faster.",
+        ),
+        "C0206": (
+            "Consider iterating with .items()",
+            "consider-using-dict-items",
+            "Emitted when iterating over the keys of a dictionary and accessing the "
+            "value by index lookup. "
+            "Both the key and value can be accessed by iterating using the .items() "
+            "method of the dictionary instead.",
+        ),
+        "C0207": (
+            "Use %s instead",
+            "use-maxsplit-arg",
+            "Emitted when accessing only the first or last element of str.split(). "
+            "The first and last element can be accessed by using "
+            "str.split(sep, maxsplit=1)[0] or str.rsplit(sep, maxsplit=1)[-1] "
+            "instead.",
+        ),
+        "C0208": (
+            "Use a sequence type when iterating over values",
+            "use-sequence-for-iteration",
+            "When iterating over values, sequence types (e.g., ``lists``, ``tuples``, ``ranges``) "
+            "are more efficient than ``sets``.",
+        ),
+        "C0209": (
+            "Formatting a regular string which could be a f-string",
+            "consider-using-f-string",
+            "Used when we detect a string that is being formatted with format() or % "
+            "which could potentially be a f-string. The use of f-strings is preferred. "
+            "Requires Python 3.6 and ``py-version >= 3.6``.",
+        ),
+    }
+
+    def open(self) -> None:
+        py_version = get_global_option(self, "py-version")
+        self._py36_plus = py_version >= (3, 6)
+
+    @staticmethod
+    def _is_builtin(node, function):
+        inferred = utils.safe_infer(node)
+        if not inferred:
+            return False
+        return utils.is_builtin_object(inferred) and inferred.name == function
+
+    @utils.check_messages("consider-iterating-dictionary", "use-maxsplit-arg")
+    def visit_call(self, node: nodes.Call) -> None:
+        self._check_consider_iterating_dictionary(node)
+        self._check_use_maxsplit_arg(node)
+
+    def _check_consider_iterating_dictionary(self, node: nodes.Call) -> None:
+        if not isinstance(node.func, nodes.Attribute):
+            return
+        if node.func.attrname != "keys":
+            return
+        comp_ancestor = utils.get_node_first_ancestor_of_type(node, nodes.Compare)
+        if (
+            isinstance(node.parent, (nodes.For, nodes.Comprehension))
+            or comp_ancestor
+            and any(
+                op
+                for op, comparator in comp_ancestor.ops
+                if op in {"in", "not in"}
+                and (comparator in node.node_ancestors() or comparator is node)
+            )
+        ):
+            inferred = utils.safe_infer(node.func)
+            if not isinstance(inferred, astroid.BoundMethod) or not isinstance(
+                inferred.bound, nodes.Dict
+            ):
+                return
+            self.add_message("consider-iterating-dictionary", node=node)
+
+    def _check_use_maxsplit_arg(self, node: nodes.Call) -> None:
+        """Add message when accessing first or last elements of a str.split() or str.rsplit()."""
+
+        # Check if call is split() or rsplit()
+        if not (
+            isinstance(node.func, nodes.Attribute)
+            and node.func.attrname in {"split", "rsplit"}
+            and isinstance(utils.safe_infer(node.func), astroid.BoundMethod)
+        ):
+            return
+
+        try:
+            sep = utils.get_argument_from_call(node, 0, "sep")
+        except utils.NoSuchArgumentError:
+            return
+
+        try:
+            # Ignore if maxsplit arg has been set
+            utils.get_argument_from_call(node, 1, "maxsplit")
+            return
+        except utils.NoSuchArgumentError:
+            pass
+
+        if isinstance(node.parent, nodes.Subscript):
+            try:
+                subscript_value = utils.get_subscript_const_value(node.parent).value
+            except utils.InferredTypeError:
+                return
+
+            # Check for cases where variable (Name) subscripts may be mutated within a loop
+            if isinstance(node.parent.slice, nodes.Name):
+                # Check if loop present within the scope of the node
+                scope = node.scope()
+                for loop_node in scope.nodes_of_class((nodes.For, nodes.While)):
+                    if not loop_node.parent_of(node):
+                        continue
+
+                    # Check if var is mutated within loop (Assign/AugAssign)
+                    for assignment_node in loop_node.nodes_of_class(nodes.AugAssign):
+                        if node.parent.slice.name == assignment_node.target.name:
+                            return
+                    for assignment_node in loop_node.nodes_of_class(nodes.Assign):
+                        if node.parent.slice.name in [
+                            n.name for n in assignment_node.targets
+                        ]:
+                            return
+
+            if subscript_value in (-1, 0):
+                fn_name = node.func.attrname
+                new_fn = "rsplit" if subscript_value == -1 else "split"
+                new_name = (
+                    node.func.as_string().rsplit(fn_name, maxsplit=1)[0]
+                    + new_fn
+                    + f"({sep.as_string()}, maxsplit=1)[{subscript_value}]"
+                )
+                self.add_message("use-maxsplit-arg", node=node, args=(new_name,))
+
+    @utils.check_messages(
+        "consider-using-enumerate",
+        "consider-using-dict-items",
+        "use-sequence-for-iteration",
+    )
+    def visit_for(self, node: nodes.For) -> None:
+        self._check_consider_using_enumerate(node)
+        self._check_consider_using_dict_items(node)
+        self._check_use_sequence_for_iteration(node)
+
+    def _check_consider_using_enumerate(self, node: nodes.For) -> None:
+        """Emit a convention whenever range and len are used for indexing."""
+        # Verify that we have a `range([start], len(...), [stop])` call and
+        # that the object which is iterated is used as a subscript in the
+        # body of the for.
+
+        # Is it a proper range call?
+        if not isinstance(node.iter, nodes.Call):
+            return
+        if not self._is_builtin(node.iter.func, "range"):
+            return
+        if not node.iter.args:
+            return
+        is_constant_zero = (
+            isinstance(node.iter.args[0], nodes.Const) and node.iter.args[0].value == 0
+        )
+        if len(node.iter.args) == 2 and not is_constant_zero:
+            return
+        if len(node.iter.args) > 2:
+            return
+
+        # Is it a proper len call?
+        if not isinstance(node.iter.args[-1], nodes.Call):
+            return
+        second_func = node.iter.args[-1].func
+        if not self._is_builtin(second_func, "len"):
+            return
+        len_args = node.iter.args[-1].args
+        if not len_args or len(len_args) != 1:
+            return
+        iterating_object = len_args[0]
+        if isinstance(iterating_object, nodes.Name):
+            expected_subscript_val_type = nodes.Name
+        elif isinstance(iterating_object, nodes.Attribute):
+            expected_subscript_val_type = nodes.Attribute
+        else:
+            return
+        # If we're defining __iter__ on self, enumerate won't work
+        scope = node.scope()
+        if (
+            isinstance(iterating_object, nodes.Name)
+            and iterating_object.name == "self"
+            and scope.name == "__iter__"
+        ):
+            return
+
+        # Verify that the body of the for loop uses a subscript
+        # with the object that was iterated. This uses some heuristics
+        # in order to make sure that the same object is used in the
+        # for body.
+        for child in node.body:
+            for subscript in child.nodes_of_class(nodes.Subscript):
+                if not isinstance(subscript.value, expected_subscript_val_type):
+                    continue
+
+                value = subscript.slice
+                if not isinstance(value, nodes.Name):
+                    continue
+                if subscript.value.scope() != node.scope():
+                    # Ignore this subscript if it's not in the same
+                    # scope. This means that in the body of the for
+                    # loop, another scope was created, where the same
+                    # name for the iterating object was used.
+                    continue
+                if value.name == node.target.name and (
+                    isinstance(subscript.value, nodes.Name)
+                    and iterating_object.name == subscript.value.name
+                    or isinstance(subscript.value, nodes.Attribute)
+                    and iterating_object.attrname == subscript.value.attrname
+                ):
+                    self.add_message("consider-using-enumerate", node=node)
+                    return
+
+    def _check_consider_using_dict_items(self, node: nodes.For) -> None:
+        """Add message when accessing dict values by index lookup."""
+        # Verify that we have a .keys() call and
+        # that the object which is iterated is used as a subscript in the
+        # body of the for.
+
+        iterating_object_name = utils.get_iterating_dictionary_name(node)
+        if iterating_object_name is None:
+            return
+
+        # Verify that the body of the for loop uses a subscript
+        # with the object that was iterated. This uses some heuristics
+        # in order to make sure that the same object is used in the
+        # for body.
+        for child in node.body:
+            for subscript in child.nodes_of_class(nodes.Subscript):
+                if not isinstance(subscript.value, (nodes.Name, nodes.Attribute)):
+                    continue
+
+                value = subscript.slice
+                if (
+                    not isinstance(value, nodes.Name)
+                    or value.name != node.target.name
+                    or iterating_object_name != subscript.value.as_string()
+                ):
+                    continue
+                last_definition_lineno = value.lookup(value.name)[1][-1].lineno
+                if last_definition_lineno > node.lineno:
+                    # Ignore this subscript if it has been redefined after
+                    # the for loop. This checks for the line number using .lookup()
+                    # to get the line number where the iterating object was last
+                    # defined and compare that to the for loop's line number
+                    continue
+                if (
+                    isinstance(subscript.parent, nodes.Assign)
+                    and subscript in subscript.parent.targets
+                    or isinstance(subscript.parent, nodes.AugAssign)
+                    and subscript == subscript.parent.target
+                ):
+                    # Ignore this subscript if it is the target of an assignment
+                    # Early termination as dict index lookup is necessary
+                    return
+
+                self.add_message("consider-using-dict-items", node=node)
+                return
+
+    @utils.check_messages(
+        "consider-using-dict-items",
+        "use-sequence-for-iteration",
+    )
+    def visit_comprehension(self, node: nodes.Comprehension) -> None:
+        self._check_consider_using_dict_items_comprehension(node)
+        self._check_use_sequence_for_iteration(node)
+
+    def _check_consider_using_dict_items_comprehension(
+        self, node: nodes.Comprehension
+    ) -> None:
+        """Add message when accessing dict values by index lookup."""
+        iterating_object_name = utils.get_iterating_dictionary_name(node)
+        if iterating_object_name is None:
+            return
+
+        for child in node.parent.get_children():
+            for subscript in child.nodes_of_class(nodes.Subscript):
+                if not isinstance(subscript.value, (nodes.Name, nodes.Attribute)):
+                    continue
+
+                value = subscript.slice
+                if (
+                    not isinstance(value, nodes.Name)
+                    or value.name != node.target.name
+                    or iterating_object_name != subscript.value.as_string()
+                ):
+                    continue
+
+                self.add_message("consider-using-dict-items", node=node)
+                return
+
+    def _check_use_sequence_for_iteration(
+        self, node: Union[nodes.For, nodes.Comprehension]
+    ) -> None:
+        """Check if code iterates over an in-place defined set."""
+        if isinstance(node.iter, nodes.Set):
+            self.add_message("use-sequence-for-iteration", node=node.iter)
+
+    @utils.check_messages("consider-using-f-string")
+    def visit_const(self, node: nodes.Const) -> None:
+        if self._py36_plus:
+            # f-strings require Python 3.6
+            if node.pytype() == "builtins.str" and not isinstance(
+                node.parent, nodes.JoinedStr
+            ):
+                self._detect_replacable_format_call(node)
+
+    def _detect_replacable_format_call(self, node: nodes.Const) -> None:
+        """Check whether a string is used in a call to format() or '%' and whether it
+        can be replaced by an f-string
+        """
+        if (
+            isinstance(node.parent, nodes.Attribute)
+            and node.parent.attrname == "format"
+        ):
+            # Don't warn on referencing / assigning .format without calling it
+            if not isinstance(node.parent.parent, nodes.Call):
+                return
+
+            if node.parent.parent.args:
+                for arg in node.parent.parent.args:
+                    # If star expressions with more than 1 element are being used
+                    if isinstance(arg, nodes.Starred):
+                        inferred = utils.safe_infer(arg.value)
+                        if (
+                            isinstance(inferred, astroid.List)
+                            and len(inferred.elts) > 1
+                        ):
+                            return
+                    # Backslashes can't be in f-string expressions
+                    if "\\" in arg.as_string():
+                        return
+
+            elif node.parent.parent.keywords:
+                keyword_args = [
+                    i[0] for i in utils.parse_format_method_string(node.value)[0]
+                ]
+                for keyword in node.parent.parent.keywords:
+                    # If keyword is used multiple times
+                    if keyword_args.count(keyword.arg) > 1:
+                        return
+
+                    keyword = utils.safe_infer(keyword.value)
+
+                    # If lists of more than one element are being unpacked
+                    if isinstance(keyword, nodes.Dict):
+                        if len(keyword.items) > 1 and len(keyword_args) > 1:
+                            return
+
+            # If all tests pass, then raise message
+            self.add_message(
+                "consider-using-f-string",
+                node=node,
+                line=node.lineno,
+                col_offset=node.col_offset,
+            )
+
+        elif isinstance(node.parent, nodes.BinOp) and node.parent.op == "%":
+            # Backslashes can't be in f-string expressions
+            if "\\" in node.parent.right.as_string():
+                return
+
+            inferred_right = utils.safe_infer(node.parent.right)
+
+            # If dicts or lists of length > 1 are used
+            if isinstance(inferred_right, nodes.Dict):
+                if len(inferred_right.items) > 1:
+                    return
+            elif isinstance(inferred_right, nodes.List):
+                if len(inferred_right.elts) > 1:
+                    return
+
+            # If all tests pass, then raise message
+            self.add_message(
+                "consider-using-f-string",
+                node=node,
+                line=node.lineno,
+                col_offset=node.col_offset,
+            )
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/refactoring_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/refactoring_checker.py
new file mode 100644
index 0000000..730f1ae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/refactoring/refactoring_checker.py
@@ -0,0 +1,1966 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import collections
+import copy
+import itertools
+import sys
+import tokenize
+from functools import reduce
+from typing import Dict, Iterator, List, NamedTuple, Optional, Tuple, Union
+
+import astroid
+from astroid import nodes
+from astroid.util import Uninferable
+
+from pylint import checkers, interfaces
+from pylint import utils as lint_utils
+from pylint.checkers import utils
+from pylint.checkers.utils import node_frame_class
+
+if sys.version_info >= (3, 8):
+    from functools import cached_property
+else:
+    from astroid.decorators import cachedproperty as cached_property
+
+KNOWN_INFINITE_ITERATORS = {"itertools.count"}
+BUILTIN_EXIT_FUNCS = frozenset(("quit", "exit"))
+CALLS_THAT_COULD_BE_REPLACED_BY_WITH = frozenset(
+    (
+        "threading.lock.acquire",
+        "threading._RLock.acquire",
+        "threading.Semaphore.acquire",
+        "multiprocessing.managers.BaseManager.start",
+        "multiprocessing.managers.SyncManager.start",
+    )
+)
+CALLS_RETURNING_CONTEXT_MANAGERS = frozenset(
+    (
+        "_io.open",  # regular 'open()' call
+        "codecs.open",
+        "urllib.request.urlopen",
+        "tempfile.NamedTemporaryFile",
+        "tempfile.SpooledTemporaryFile",
+        "tempfile.TemporaryDirectory",
+        "tempfile.TemporaryFile",
+        "zipfile.ZipFile",
+        "zipfile.PyZipFile",
+        "zipfile.ZipFile.open",
+        "zipfile.PyZipFile.open",
+        "tarfile.TarFile",
+        "tarfile.TarFile.open",
+        "multiprocessing.context.BaseContext.Pool",
+        "subprocess.Popen",
+    )
+)
+
+
+def _if_statement_is_always_returning(if_node, returning_node_class) -> bool:
+    return any(isinstance(node, returning_node_class) for node in if_node.body)
+
+
+def _is_trailing_comma(tokens: List[tokenize.TokenInfo], index: int) -> bool:
+    """Check if the given token is a trailing comma.
+
+    :param tokens: Sequence of modules tokens
+    :type tokens: list[tokenize.TokenInfo]
+    :param int index: Index of token under check in tokens
+    :returns: True if the token is a comma which trails an expression
+    :rtype: bool
+    """
+    token = tokens[index]
+    if token.exact_type != tokenize.COMMA:
+        return False
+    # Must have remaining tokens on the same line such as NEWLINE
+    left_tokens = list(itertools.islice(tokens, index + 1, None))
+
+    more_tokens_on_line = False
+    for remaining_token in left_tokens:
+        if remaining_token.start[0] == token.start[0]:
+            more_tokens_on_line = True
+            # If one of the remaining same line tokens is not NEWLINE or COMMENT
+            # the comma is not trailing.
+            if remaining_token.type not in (tokenize.NEWLINE, tokenize.COMMENT):
+                return False
+
+    if not more_tokens_on_line:
+        return False
+
+    def get_curline_index_start():
+        """Get the index denoting the start of the current line."""
+        for subindex, token in enumerate(reversed(tokens[:index])):
+            # See Lib/tokenize.py and Lib/token.py in cpython for more info
+            if token.type == tokenize.NEWLINE:
+                return index - subindex
+        return 0
+
+    curline_start = get_curline_index_start()
+    expected_tokens = {"return", "yield"}
+    return any(
+        "=" in prevtoken.string or prevtoken.string in expected_tokens
+        for prevtoken in tokens[curline_start:index]
+    )
+
+
+def _is_inside_context_manager(node: nodes.Call) -> bool:
+    frame = node.frame(future=True)
+    if not isinstance(
+        frame, (nodes.FunctionDef, astroid.BoundMethod, astroid.UnboundMethod)
+    ):
+        return False
+    return frame.name == "__enter__" or utils.decorated_with(
+        frame, "contextlib.contextmanager"
+    )
+
+
+def _is_a_return_statement(node: nodes.Call) -> bool:
+    frame = node.frame(future=True)
+    for parent in node.node_ancestors():
+        if parent is frame:
+            break
+        if isinstance(parent, nodes.Return):
+            return True
+    return False
+
+
+def _is_part_of_with_items(node: nodes.Call) -> bool:
+    """Checks if one of the node's parents is a ``nodes.With`` node and that the node itself is located
+    somewhere under its ``items``.
+    """
+    frame = node.frame(future=True)
+    current = node
+    while current != frame:
+        if isinstance(current, nodes.With):
+            items_start = current.items[0][0].lineno
+            items_end = current.items[-1][0].tolineno
+            return items_start <= node.lineno <= items_end
+        current = current.parent
+    return False
+
+
+def _will_be_released_automatically(node: nodes.Call) -> bool:
+    """Checks if a call that could be used in a ``with`` statement is used in an alternative
+    construct which would ensure that its __exit__ method is called.
+    """
+    callables_taking_care_of_exit = frozenset(
+        (
+            "contextlib._BaseExitStack.enter_context",
+            "contextlib.ExitStack.enter_context",  # necessary for Python 3.6 compatibility
+        )
+    )
+    if not isinstance(node.parent, nodes.Call):
+        return False
+    func = utils.safe_infer(node.parent.func)
+    if not func:
+        return False
+    return func.qname() in callables_taking_care_of_exit
+
+
+class ConsiderUsingWithStack(NamedTuple):
+    """Stack for objects that may potentially trigger a R1732 message
+    if they are not used in a ``with`` block later on.
+    """
+
+    module_scope: Dict[str, nodes.NodeNG] = {}
+    class_scope: Dict[str, nodes.NodeNG] = {}
+    function_scope: Dict[str, nodes.NodeNG] = {}
+
+    def __iter__(self) -> Iterator[Dict[str, nodes.NodeNG]]:
+        yield from (self.function_scope, self.class_scope, self.module_scope)
+
+    def get_stack_for_frame(
+        self, frame: Union[nodes.FunctionDef, nodes.ClassDef, nodes.Module]
+    ):
+        """Get the stack corresponding to the scope of the given frame."""
+        if isinstance(frame, nodes.FunctionDef):
+            return self.function_scope
+        if isinstance(frame, nodes.ClassDef):
+            return self.class_scope
+        return self.module_scope
+
+    def clear_all(self) -> None:
+        """Convenience method to clear all stacks."""
+        for stack in self:
+            stack.clear()
+
+
+class RefactoringChecker(checkers.BaseTokenChecker):
+    """Looks for code which can be refactored.
+
+    This checker also mixes the astroid and the token approaches
+    in order to create knowledge about whether an "else if" node
+    is a true "else if" node, or an "elif" node.
+    """
+
+    __implements__ = (interfaces.ITokenChecker, interfaces.IAstroidChecker)
+
+    name = "refactoring"
+
+    msgs = {
+        "R1701": (
+            "Consider merging these isinstance calls to isinstance(%s, (%s))",
+            "consider-merging-isinstance",
+            "Used when multiple consecutive isinstance calls can be merged into one.",
+        ),
+        "R1706": (
+            "Consider using ternary (%s)",
+            "consider-using-ternary",
+            "Used when one of known pre-python 2.5 ternary syntax is used.",
+        ),
+        "R1709": (
+            "Boolean expression may be simplified to %s",
+            "simplify-boolean-expression",
+            "Emitted when redundant pre-python 2.5 ternary syntax is used.",
+        ),
+        "R1726": (
+            "Boolean condition '%s' may be simplified to '%s'",
+            "simplifiable-condition",
+            "Emitted when a boolean condition is able to be simplified.",
+        ),
+        "R1727": (
+            "Boolean condition '%s' will always evaluate to '%s'",
+            "condition-evals-to-constant",
+            "Emitted when a boolean condition can be simplified to a constant value.",
+        ),
+        "R1702": (
+            "Too many nested blocks (%s/%s)",
+            "too-many-nested-blocks",
+            "Used when a function or a method has too many nested "
+            "blocks. This makes the code less understandable and "
+            "maintainable.",
+            {"old_names": [("R0101", "old-too-many-nested-blocks")]},
+        ),
+        "R1703": (
+            "The if statement can be replaced with %s",
+            "simplifiable-if-statement",
+            "Used when an if statement can be replaced with 'bool(test)'.",
+            {"old_names": [("R0102", "old-simplifiable-if-statement")]},
+        ),
+        "R1704": (
+            "Redefining argument with the local name %r",
+            "redefined-argument-from-local",
+            "Used when a local name is redefining an argument, which might "
+            "suggest a potential error. This is taken in account only for "
+            "a handful of name binding operations, such as for iteration, "
+            "with statement assignment and exception handler assignment.",
+        ),
+        "R1705": (
+            'Unnecessary "%s" after "return", %s',
+            "no-else-return",
+            "Used in order to highlight an unnecessary block of "
+            "code following an if containing a return statement. "
+            "As such, it will warn when it encounters an else "
+            "following a chain of ifs, all of them containing a "
+            "return statement.",
+        ),
+        "R1707": (
+            "Disallow trailing comma tuple",
+            "trailing-comma-tuple",
+            "In Python, a tuple is actually created by the comma symbol, "
+            "not by the parentheses. Unfortunately, one can actually create a "
+            "tuple by misplacing a trailing comma, which can lead to potential "
+            "weird bugs in your code. You should always use parentheses "
+            "explicitly for creating a tuple.",
+        ),
+        "R1708": (
+            "Do not raise StopIteration in generator, use return statement instead",
+            "stop-iteration-return",
+            "According to PEP479, the raise of StopIteration to end the loop of "
+            "a generator may lead to hard to find bugs. This PEP specify that "
+            "raise StopIteration has to be replaced by a simple return statement",
+        ),
+        "R1710": (
+            "Either all return statements in a function should return an expression, "
+            "or none of them should.",
+            "inconsistent-return-statements",
+            "According to PEP8, if any return statement returns an expression, "
+            "any return statements where no value is returned should explicitly "
+            "state this as return None, and an explicit return statement "
+            "should be present at the end of the function (if reachable)",
+        ),
+        "R1711": (
+            "Useless return at end of function or method",
+            "useless-return",
+            'Emitted when a single "return" or "return None" statement is found '
+            "at the end of function or method definition. This statement can safely be "
+            "removed because Python will implicitly return None",
+        ),
+        "R1712": (
+            "Consider using tuple unpacking for swapping variables",
+            "consider-swap-variables",
+            "You do not have to use a temporary variable in order to "
+            'swap variables. Using "tuple unpacking" to directly swap '
+            "variables makes the intention more clear.",
+        ),
+        "R1713": (
+            "Consider using str.join(sequence) for concatenating "
+            "strings from an iterable",
+            "consider-using-join",
+            "Using str.join(sequence) is faster, uses less memory "
+            "and increases readability compared to for-loop iteration.",
+        ),
+        "R1714": (
+            'Consider merging these comparisons with "in" to %r',
+            "consider-using-in",
+            "To check if a variable is equal to one of many values,"
+            'combine the values into a tuple and check if the variable is contained "in" it '
+            "instead of checking for equality against each of the values."
+            "This is faster and less verbose.",
+        ),
+        "R1715": (
+            "Consider using dict.get for getting values from a dict "
+            "if a key is present or a default if not",
+            "consider-using-get",
+            "Using the builtin dict.get for getting a value from a dictionary "
+            "if a key is present or a default if not, is simpler and considered "
+            "more idiomatic, although sometimes a bit slower",
+        ),
+        "R1716": (
+            "Simplify chained comparison between the operands",
+            "chained-comparison",
+            "This message is emitted when pylint encounters boolean operation like"
+            '"a < b and b < c", suggesting instead to refactor it to "a < b < c"',
+        ),
+        "R1717": (
+            "Consider using a dictionary comprehension",
+            "consider-using-dict-comprehension",
+            "Emitted when we detect the creation of a dictionary "
+            "using the dict() callable and a transient list. "
+            "Although there is nothing syntactically wrong with this code, "
+            "it is hard to read and can be simplified to a dict comprehension."
+            "Also it is faster since you don't need to create another "
+            "transient list",
+        ),
+        "R1718": (
+            "Consider using a set comprehension",
+            "consider-using-set-comprehension",
+            "Although there is nothing syntactically wrong with this code, "
+            "it is hard to read and can be simplified to a set comprehension."
+            "Also it is faster since you don't need to create another "
+            "transient list",
+        ),
+        "R1719": (
+            "The if expression can be replaced with %s",
+            "simplifiable-if-expression",
+            "Used when an if expression can be replaced with 'bool(test)'.",
+        ),
+        "R1720": (
+            'Unnecessary "%s" after "raise", %s',
+            "no-else-raise",
+            "Used in order to highlight an unnecessary block of "
+            "code following an if containing a raise statement. "
+            "As such, it will warn when it encounters an else "
+            "following a chain of ifs, all of them containing a "
+            "raise statement.",
+        ),
+        "R1721": (
+            "Unnecessary use of a comprehension, use %s instead.",
+            "unnecessary-comprehension",
+            "Instead of using an identity comprehension, "
+            "consider using the list, dict or set constructor. "
+            "It is faster and simpler.",
+        ),
+        "R1722": (
+            "Consider using sys.exit()",
+            "consider-using-sys-exit",
+            "Instead of using exit() or quit(), consider using the sys.exit().",
+        ),
+        "R1723": (
+            'Unnecessary "%s" after "break", %s',
+            "no-else-break",
+            "Used in order to highlight an unnecessary block of "
+            "code following an if containing a break statement. "
+            "As such, it will warn when it encounters an else "
+            "following a chain of ifs, all of them containing a "
+            "break statement.",
+        ),
+        "R1724": (
+            'Unnecessary "%s" after "continue", %s',
+            "no-else-continue",
+            "Used in order to highlight an unnecessary block of "
+            "code following an if containing a continue statement. "
+            "As such, it will warn when it encounters an else "
+            "following a chain of ifs, all of them containing a "
+            "continue statement.",
+        ),
+        "R1725": (
+            "Consider using Python 3 style super() without arguments",
+            "super-with-arguments",
+            "Emitted when calling the super() builtin with the current class "
+            "and instance. On Python 3 these arguments are the default and they can be omitted.",
+        ),
+        "R1728": (
+            "Consider using a generator instead '%s(%s)'",
+            "consider-using-generator",
+            "If your container can be large using "
+            "a generator will bring better performance.",
+        ),
+        "R1729": (
+            "Use a generator instead '%s(%s)'",
+            "use-a-generator",
+            "Comprehension inside of 'any' or 'all' is unnecessary. "
+            "A generator would be sufficient and faster.",
+        ),
+        "R1730": (
+            "Consider using '%s' instead of unnecessary if block",
+            "consider-using-min-builtin",
+            "Using the min builtin instead of a conditional improves readability and conciseness.",
+        ),
+        "R1731": (
+            "Consider using '%s' instead of unnecessary if block",
+            "consider-using-max-builtin",
+            "Using the max builtin instead of a conditional improves readability and conciseness.",
+        ),
+        "R1732": (
+            "Consider using 'with' for resource-allocating operations",
+            "consider-using-with",
+            "Emitted if a resource-allocating assignment or call may be replaced by a 'with' block. "
+            "By using 'with' the release of the allocated resources is ensured even in the case of an exception.",
+        ),
+        "R1733": (
+            "Unnecessary dictionary index lookup, use '%s' instead",
+            "unnecessary-dict-index-lookup",
+            "Emitted when iterating over the dictionary items (key-item pairs) and accessing the "
+            "value by index lookup. "
+            "The value can be accessed directly instead.",
+        ),
+        "R1734": (
+            "Consider using [] instead of list()",
+            "use-list-literal",
+            "Emitted when using list() to create an empty list instead of the literal []. "
+            "The literal is faster as it avoids an additional function call.",
+        ),
+        "R1735": (
+            "Consider using {} instead of dict()",
+            "use-dict-literal",
+            "Emitted when using dict() to create an empty dictionary instead of the literal {}. "
+            "The literal is faster as it avoids an additional function call.",
+        ),
+    }
+    options = (
+        (
+            "max-nested-blocks",
+            {
+                "default": 5,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "Maximum number of nested blocks for function / method body",
+            },
+        ),
+        (
+            "never-returning-functions",
+            {
+                "default": ("sys.exit", "argparse.parse_error"),
+                "type": "csv",
+                "help": "Complete name of functions that never returns. When checking "
+                "for inconsistent-return-statements if a never returning function is "
+                "called then it will be considered as an explicit return statement "
+                "and no message will be printed.",
+            },
+        ),
+    )
+
+    priority = 0
+
+    def __init__(self, linter=None):
+        super().__init__(linter)
+        self._return_nodes = {}
+        self._consider_using_with_stack = ConsiderUsingWithStack()
+        self._init()
+        self._never_returning_functions = None
+
+    def _init(self):
+        self._nested_blocks = []
+        self._elifs = []
+        self._nested_blocks_msg = None
+        self._reported_swap_nodes = set()
+        self._can_simplify_bool_op = False
+        self._consider_using_with_stack.clear_all()
+
+    def open(self):
+        # do this in open since config not fully initialized in __init__
+        self._never_returning_functions = set(self.config.never_returning_functions)
+
+    @cached_property
+    def _dummy_rgx(self):
+        return lint_utils.get_global_option(self, "dummy-variables-rgx", default=None)
+
+    @staticmethod
+    def _is_bool_const(node):
+        return isinstance(node.value, nodes.Const) and isinstance(
+            node.value.value, bool
+        )
+
+    def _is_actual_elif(self, node):
+        """Check if the given node is an actual elif.
+
+        This is a problem we're having with the builtin ast module,
+        which splits `elif` branches into a separate if statement.
+        Unfortunately we need to know the exact type in certain
+        cases.
+        """
+        if isinstance(node.parent, nodes.If):
+            orelse = node.parent.orelse
+            # current if node must directly follow an "else"
+            if orelse and orelse == [node]:
+                if (node.lineno, node.col_offset) in self._elifs:
+                    return True
+        return False
+
+    def _check_simplifiable_if(self, node):
+        """Check if the given if node can be simplified.
+
+        The if statement can be reduced to a boolean expression
+        in some cases. For instance, if there are two branches
+        and both of them return a boolean value that depends on
+        the result of the statement's test, then this can be reduced
+        to `bool(test)` without losing any functionality.
+        """
+
+        if self._is_actual_elif(node):
+            # Not interested in if statements with multiple branches.
+            return
+        if len(node.orelse) != 1 or len(node.body) != 1:
+            return
+
+        # Check if both branches can be reduced.
+        first_branch = node.body[0]
+        else_branch = node.orelse[0]
+        if isinstance(first_branch, nodes.Return):
+            if not isinstance(else_branch, nodes.Return):
+                return
+            first_branch_is_bool = self._is_bool_const(first_branch)
+            else_branch_is_bool = self._is_bool_const(else_branch)
+            reduced_to = "'return bool(test)'"
+        elif isinstance(first_branch, nodes.Assign):
+            if not isinstance(else_branch, nodes.Assign):
+                return
+
+            # Check if we assign to the same value
+            first_branch_targets = [
+                target.name
+                for target in first_branch.targets
+                if isinstance(target, nodes.AssignName)
+            ]
+            else_branch_targets = [
+                target.name
+                for target in else_branch.targets
+                if isinstance(target, nodes.AssignName)
+            ]
+            if not first_branch_targets or not else_branch_targets:
+                return
+            if sorted(first_branch_targets) != sorted(else_branch_targets):
+                return
+
+            first_branch_is_bool = self._is_bool_const(first_branch)
+            else_branch_is_bool = self._is_bool_const(else_branch)
+            reduced_to = "'var = bool(test)'"
+        else:
+            return
+
+        if not first_branch_is_bool or not else_branch_is_bool:
+            return
+        if not first_branch.value.value:
+            # This is a case that can't be easily simplified and
+            # if it can be simplified, it will usually result in a
+            # code that's harder to understand and comprehend.
+            # Let's take for instance `arg and arg <= 3`. This could theoretically be
+            # reduced to `not arg or arg > 3`, but the net result is that now the
+            # condition is harder to understand, because it requires understanding of
+            # an extra clause:
+            #   * first, there is the negation of truthness with `not arg`
+            #   * the second clause is `arg > 3`, which occurs when arg has a
+            #     a truth value, but it implies that `arg > 3` is equivalent
+            #     with `arg and arg > 3`, which means that the user must
+            #     think about this assumption when evaluating `arg > 3`.
+            #     The original form is easier to grasp.
+            return
+
+        self.add_message("simplifiable-if-statement", node=node, args=(reduced_to,))
+
+    def process_tokens(self, tokens):
+        # Process tokens and look for 'if' or 'elif'
+        for index, token in enumerate(tokens):
+            token_string = token[1]
+            if token_string == "elif":
+                # AST exists by the time process_tokens is called, so
+                # it's safe to assume tokens[index+1] exists.
+                # tokens[index+1][2] is the elif's position as
+                # reported by CPython and PyPy,
+                # token[2] is the actual position and also is
+                # reported by IronPython.
+                self._elifs.extend([token[2], tokens[index + 1][2]])
+            elif _is_trailing_comma(tokens, index):
+                if self.linter.is_message_enabled("trailing-comma-tuple"):
+                    self.add_message("trailing-comma-tuple", line=token.start[0])
+
+    @utils.check_messages("consider-using-with")
+    def leave_module(self, _: nodes.Module) -> None:
+        # check for context managers that have been created but not used
+        self._emit_consider_using_with_if_needed(
+            self._consider_using_with_stack.module_scope
+        )
+        self._init()
+
+    @utils.check_messages("too-many-nested-blocks")
+    def visit_tryexcept(self, node: nodes.TryExcept) -> None:
+        self._check_nested_blocks(node)
+
+    visit_tryfinally = visit_tryexcept
+    visit_while = visit_tryexcept
+
+    def _check_redefined_argument_from_local(self, name_node):
+        if self._dummy_rgx and self._dummy_rgx.match(name_node.name):
+            return
+        if not name_node.lineno:
+            # Unknown position, maybe it is a manually built AST?
+            return
+
+        scope = name_node.scope()
+        if not isinstance(scope, nodes.FunctionDef):
+            return
+
+        for defined_argument in scope.args.nodes_of_class(
+            nodes.AssignName, skip_klass=(nodes.Lambda,)
+        ):
+            if defined_argument.name == name_node.name:
+                self.add_message(
+                    "redefined-argument-from-local",
+                    node=name_node,
+                    args=(name_node.name,),
+                )
+
+    @utils.check_messages(
+        "redefined-argument-from-local",
+        "too-many-nested-blocks",
+        "unnecessary-dict-index-lookup",
+    )
+    def visit_for(self, node: nodes.For) -> None:
+        self._check_nested_blocks(node)
+        self._check_unnecessary_dict_index_lookup(node)
+
+        for name in node.target.nodes_of_class(nodes.AssignName):
+            self._check_redefined_argument_from_local(name)
+
+    @utils.check_messages("redefined-argument-from-local")
+    def visit_excepthandler(self, node: nodes.ExceptHandler) -> None:
+        if node.name and isinstance(node.name, nodes.AssignName):
+            self._check_redefined_argument_from_local(node.name)
+
+    @utils.check_messages("redefined-argument-from-local")
+    def visit_with(self, node: nodes.With) -> None:
+        for var, names in node.items:
+            if isinstance(var, nodes.Name):
+                for stack in self._consider_using_with_stack:
+                    # We don't need to restrict the stacks we search to the current scope and outer scopes,
+                    # as e.g. the function_scope stack will be empty when we check a ``with`` on the class level.
+                    if var.name in stack:
+                        del stack[var.name]
+                        break
+            if not names:
+                continue
+            for name in names.nodes_of_class(nodes.AssignName):
+                self._check_redefined_argument_from_local(name)
+
+    def _check_superfluous_else(self, node, msg_id, returning_node_class):
+        if not node.orelse:
+            # Not interested in if statements without else.
+            return
+
+        if self._is_actual_elif(node):
+            # Not interested in elif nodes; only if
+            return
+
+        if _if_statement_is_always_returning(node, returning_node_class):
+            orelse = node.orelse[0]
+            if (orelse.lineno, orelse.col_offset) in self._elifs:
+                args = ("elif", 'remove the leading "el" from "elif"')
+            else:
+                args = ("else", 'remove the "else" and de-indent the code inside it')
+            self.add_message(msg_id, node=node, args=args)
+
+    def _check_superfluous_else_return(self, node):
+        return self._check_superfluous_else(
+            node, msg_id="no-else-return", returning_node_class=nodes.Return
+        )
+
+    def _check_superfluous_else_raise(self, node):
+        return self._check_superfluous_else(
+            node, msg_id="no-else-raise", returning_node_class=nodes.Raise
+        )
+
+    def _check_superfluous_else_break(self, node):
+        return self._check_superfluous_else(
+            node, msg_id="no-else-break", returning_node_class=nodes.Break
+        )
+
+    def _check_superfluous_else_continue(self, node):
+        return self._check_superfluous_else(
+            node, msg_id="no-else-continue", returning_node_class=nodes.Continue
+        )
+
+    @staticmethod
+    def _type_and_name_are_equal(node_a, node_b):
+        for _type in (nodes.Name, nodes.AssignName):
+            if all(isinstance(_node, _type) for _node in (node_a, node_b)):
+                return node_a.name == node_b.name
+        if all(isinstance(_node, nodes.Const) for _node in (node_a, node_b)):
+            return node_a.value == node_b.value
+        return False
+
+    def _is_dict_get_block(self, node):
+
+        # "if <compare node>"
+        if not isinstance(node.test, nodes.Compare):
+            return False
+
+        # Does not have a single statement in the guard's body
+        if len(node.body) != 1:
+            return False
+
+        # Look for a single variable assignment on the LHS and a subscript on RHS
+        stmt = node.body[0]
+        if not (
+            isinstance(stmt, nodes.Assign)
+            and len(node.body[0].targets) == 1
+            and isinstance(node.body[0].targets[0], nodes.AssignName)
+            and isinstance(stmt.value, nodes.Subscript)
+        ):
+            return False
+
+        # The subscript's slice needs to be the same as the test variable.
+        slice_value = stmt.value.slice
+        if not (
+            self._type_and_name_are_equal(stmt.value.value, node.test.ops[0][1])
+            and self._type_and_name_are_equal(slice_value, node.test.left)
+        ):
+            return False
+
+        # The object needs to be a dictionary instance
+        return isinstance(utils.safe_infer(node.test.ops[0][1]), nodes.Dict)
+
+    def _check_consider_get(self, node):
+        if_block_ok = self._is_dict_get_block(node)
+        if if_block_ok and not node.orelse:
+            self.add_message("consider-using-get", node=node)
+        elif (
+            if_block_ok
+            and len(node.orelse) == 1
+            and isinstance(node.orelse[0], nodes.Assign)
+            and self._type_and_name_are_equal(
+                node.orelse[0].targets[0], node.body[0].targets[0]
+            )
+            and len(node.orelse[0].targets) == 1
+        ):
+            self.add_message("consider-using-get", node=node)
+
+    @utils.check_messages(
+        "too-many-nested-blocks",
+        "simplifiable-if-statement",
+        "no-else-return",
+        "no-else-raise",
+        "no-else-break",
+        "no-else-continue",
+        "consider-using-get",
+    )
+    def visit_if(self, node: nodes.If) -> None:
+        self._check_simplifiable_if(node)
+        self._check_nested_blocks(node)
+        self._check_superfluous_else_return(node)
+        self._check_superfluous_else_raise(node)
+        self._check_superfluous_else_break(node)
+        self._check_superfluous_else_continue(node)
+        self._check_consider_get(node)
+        self._check_consider_using_min_max_builtin(node)
+
+    def _check_consider_using_min_max_builtin(self, node: nodes.If):
+        """Check if the given if node can be refactored as a min/max python builtin."""
+        if self._is_actual_elif(node) or node.orelse:
+            # Not interested in if statements with multiple branches.
+            return
+
+        if len(node.body) != 1:
+            return
+
+        body = node.body[0]
+        # Check if condition can be reduced.
+        if not hasattr(body, "targets") or len(body.targets) != 1:
+            return
+
+        target = body.targets[0]
+        if not (
+            isinstance(node.test, nodes.Compare)
+            and not isinstance(target, nodes.Subscript)
+            and not isinstance(node.test.left, nodes.Subscript)
+            and isinstance(body, nodes.Assign)
+        ):
+            return
+
+        # Check that the assignation is on the same variable.
+        if hasattr(node.test.left, "name"):
+            left_operand = node.test.left.name
+        elif hasattr(node.test.left, "attrname"):
+            left_operand = node.test.left.attrname
+        else:
+            return
+
+        if hasattr(target, "name"):
+            target_assignation = target.name
+        elif hasattr(target, "attrname"):
+            target_assignation = target.attrname
+        else:
+            return
+
+        if not (left_operand == target_assignation):
+            return
+
+        if len(node.test.ops) > 1:
+            return
+
+        if not isinstance(body.value, (nodes.Name, nodes.Const)):
+            return
+
+        operator, right_statement = node.test.ops[0]
+        if isinstance(body.value, nodes.Name):
+            body_value = body.value.name
+        else:
+            body_value = body.value.value
+
+        if isinstance(right_statement, nodes.Name):
+            right_statement_value = right_statement.name
+        elif isinstance(right_statement, nodes.Const):
+            right_statement_value = right_statement.value
+        else:
+            return
+
+        # Verify the right part of the statement is the same.
+        if right_statement_value != body_value:
+            return
+
+        if operator in {"<", "<="}:
+            reduced_to = "{target} = max({target}, {item})".format(
+                target=target_assignation, item=body_value
+            )
+            self.add_message(
+                "consider-using-max-builtin", node=node, args=(reduced_to,)
+            )
+        elif operator in {">", ">="}:
+            reduced_to = "{target} = min({target}, {item})".format(
+                target=target_assignation, item=body_value
+            )
+            self.add_message(
+                "consider-using-min-builtin", node=node, args=(reduced_to,)
+            )
+
+    @utils.check_messages("simplifiable-if-expression")
+    def visit_ifexp(self, node: nodes.IfExp) -> None:
+        self._check_simplifiable_ifexp(node)
+
+    def _check_simplifiable_ifexp(self, node):
+        if not isinstance(node.body, nodes.Const) or not isinstance(
+            node.orelse, nodes.Const
+        ):
+            return
+
+        if not isinstance(node.body.value, bool) or not isinstance(
+            node.orelse.value, bool
+        ):
+            return
+
+        if isinstance(node.test, nodes.Compare):
+            test_reduced_to = "test"
+        else:
+            test_reduced_to = "bool(test)"
+
+        if (node.body.value, node.orelse.value) == (True, False):
+            reduced_to = f"'{test_reduced_to}'"
+        elif (node.body.value, node.orelse.value) == (False, True):
+            reduced_to = "'not test'"
+        else:
+            return
+
+        self.add_message("simplifiable-if-expression", node=node, args=(reduced_to,))
+
+    @utils.check_messages(
+        "too-many-nested-blocks",
+        "inconsistent-return-statements",
+        "useless-return",
+        "consider-using-with",
+    )
+    def leave_functiondef(self, node: nodes.FunctionDef) -> None:
+        # check left-over nested blocks stack
+        self._emit_nested_blocks_message_if_needed(self._nested_blocks)
+        # new scope = reinitialize the stack of nested blocks
+        self._nested_blocks = []
+        # check consistent return statements
+        self._check_consistent_returns(node)
+        # check for single return or return None at the end
+        self._check_return_at_the_end(node)
+        self._return_nodes[node.name] = []
+        # check for context managers that have been created but not used
+        self._emit_consider_using_with_if_needed(
+            self._consider_using_with_stack.function_scope
+        )
+        self._consider_using_with_stack.function_scope.clear()
+
+    @utils.check_messages("consider-using-with")
+    def leave_classdef(self, _: nodes.ClassDef) -> None:
+        # check for context managers that have been created but not used
+        self._emit_consider_using_with_if_needed(
+            self._consider_using_with_stack.class_scope
+        )
+        self._consider_using_with_stack.class_scope.clear()
+
+    @utils.check_messages("stop-iteration-return")
+    def visit_raise(self, node: nodes.Raise) -> None:
+        self._check_stop_iteration_inside_generator(node)
+
+    def _check_stop_iteration_inside_generator(self, node):
+        """Check if an exception of type StopIteration is raised inside a generator."""
+        frame = node.frame(future=True)
+        if not isinstance(frame, nodes.FunctionDef) or not frame.is_generator():
+            return
+        if utils.node_ignores_exception(node, StopIteration):
+            return
+        if not node.exc:
+            return
+        exc = utils.safe_infer(node.exc)
+        if not exc or not isinstance(exc, (astroid.Instance, nodes.ClassDef)):
+            return
+        if self._check_exception_inherit_from_stopiteration(exc):
+            self.add_message("stop-iteration-return", node=node)
+
+    @staticmethod
+    def _check_exception_inherit_from_stopiteration(exc):
+        """Return True if the exception node in argument inherit from StopIteration."""
+        stopiteration_qname = f"{utils.EXCEPTIONS_MODULE}.StopIteration"
+        return any(_class.qname() == stopiteration_qname for _class in exc.mro())
+
+    def _check_consider_using_comprehension_constructor(self, node):
+        if (
+            isinstance(node.func, nodes.Name)
+            and node.args
+            and isinstance(node.args[0], nodes.ListComp)
+        ):
+            if node.func.name == "dict":
+                element = node.args[0].elt
+                if isinstance(element, nodes.Call):
+                    return
+
+                # If we have an `IfExp` here where both the key AND value
+                # are different, then don't raise the issue. See #5588
+                if (
+                    isinstance(element, nodes.IfExp)
+                    and isinstance(element.body, (nodes.Tuple, nodes.List))
+                    and len(element.body.elts) == 2
+                    and isinstance(element.orelse, (nodes.Tuple, nodes.List))
+                    and len(element.orelse.elts) == 2
+                ):
+                    key1, value1 = element.body.elts
+                    key2, value2 = element.orelse.elts
+                    if (
+                        key1.as_string() != key2.as_string()
+                        and value1.as_string() != value2.as_string()
+                    ):
+                        return
+
+                message_name = "consider-using-dict-comprehension"
+                self.add_message(message_name, node=node)
+            elif node.func.name == "set":
+                message_name = "consider-using-set-comprehension"
+                self.add_message(message_name, node=node)
+
+    def _check_consider_using_generator(self, node):
+        # 'any' and 'all' definitely should use generator, while 'list' and 'tuple' need to be considered first
+        # See https://github.com/PyCQA/pylint/pull/3309#discussion_r576683109
+        checked_call = ["any", "all", "list", "tuple"]
+        if (
+            isinstance(node, nodes.Call)
+            and node.func
+            and isinstance(node.func, nodes.Name)
+            and node.func.name in checked_call
+        ):
+            # functions in checked_calls take exactly one argument
+            # check whether the argument is list comprehension
+            if len(node.args) == 1 and isinstance(node.args[0], nodes.ListComp):
+                # remove square brackets '[]'
+                inside_comp = node.args[0].as_string()[1:-1]
+                call_name = node.func.name
+                if call_name in {"any", "all"}:
+                    self.add_message(
+                        "use-a-generator",
+                        node=node,
+                        args=(call_name, inside_comp),
+                    )
+                else:
+                    self.add_message(
+                        "consider-using-generator",
+                        node=node,
+                        args=(call_name, inside_comp),
+                    )
+
+    @utils.check_messages(
+        "stop-iteration-return",
+        "consider-using-dict-comprehension",
+        "consider-using-set-comprehension",
+        "consider-using-sys-exit",
+        "super-with-arguments",
+        "consider-using-generator",
+        "consider-using-with",
+        "use-list-literal",
+        "use-dict-literal",
+    )
+    def visit_call(self, node: nodes.Call) -> None:
+        self._check_raising_stopiteration_in_generator_next_call(node)
+        self._check_consider_using_comprehension_constructor(node)
+        self._check_quit_exit_call(node)
+        self._check_super_with_arguments(node)
+        self._check_consider_using_generator(node)
+        self._check_consider_using_with(node)
+        self._check_use_list_or_dict_literal(node)
+
+    @staticmethod
+    def _has_exit_in_scope(scope):
+        exit_func = scope.locals.get("exit")
+        return bool(
+            exit_func and isinstance(exit_func[0], (nodes.ImportFrom, nodes.Import))
+        )
+
+    def _check_quit_exit_call(self, node):
+
+        if isinstance(node.func, nodes.Name) and node.func.name in BUILTIN_EXIT_FUNCS:
+            # If we have `exit` imported from `sys` in the current or global scope, exempt this instance.
+            local_scope = node.scope()
+            if self._has_exit_in_scope(local_scope) or self._has_exit_in_scope(
+                node.root()
+            ):
+                return
+            self.add_message("consider-using-sys-exit", node=node)
+
+    def _check_super_with_arguments(self, node):
+        if not isinstance(node.func, nodes.Name) or node.func.name != "super":
+            return
+
+        # pylint: disable=too-many-boolean-expressions
+        if (
+            len(node.args) != 2
+            or not isinstance(node.args[1], nodes.Name)
+            or node.args[1].name != "self"
+            or not isinstance(node.args[0], nodes.Name)
+            or not isinstance(node.args[1], nodes.Name)
+            or node_frame_class(node) is None
+            or node.args[0].name != node_frame_class(node).name
+        ):
+            return
+
+        self.add_message("super-with-arguments", node=node)
+
+    def _check_raising_stopiteration_in_generator_next_call(self, node):
+        """Check if a StopIteration exception is raised by the call to next function.
+
+        If the next value has a default value, then do not add message.
+
+        :param node: Check to see if this Call node is a next function
+        :type node: :class:`nodes.Call`
+        """
+
+        def _looks_like_infinite_iterator(param):
+            inferred = utils.safe_infer(param)
+            if inferred:
+                return inferred.qname() in KNOWN_INFINITE_ITERATORS
+            return False
+
+        if isinstance(node.func, nodes.Attribute):
+            # A next() method, which is now what we want.
+            return
+
+        inferred = utils.safe_infer(node.func)
+        if getattr(inferred, "name", "") == "next":
+            frame = node.frame(future=True)
+            # The next builtin can only have up to two
+            # positional arguments and no keyword arguments
+            has_sentinel_value = len(node.args) > 1
+            if (
+                isinstance(frame, nodes.FunctionDef)
+                and frame.is_generator()
+                and not has_sentinel_value
+                and not utils.node_ignores_exception(node, StopIteration)
+                and not _looks_like_infinite_iterator(node.args[0])
+            ):
+                self.add_message("stop-iteration-return", node=node)
+
+    def _check_nested_blocks(self, node):
+        """Update and check the number of nested blocks."""
+        # only check block levels inside functions or methods
+        if not isinstance(node.scope(), nodes.FunctionDef):
+            return
+        # messages are triggered on leaving the nested block. Here we save the
+        # stack in case the current node isn't nested in the previous one
+        nested_blocks = self._nested_blocks[:]
+        if node.parent == node.scope():
+            self._nested_blocks = [node]
+        else:
+            # go through ancestors from the most nested to the less
+            for ancestor_node in reversed(self._nested_blocks):
+                if ancestor_node == node.parent:
+                    break
+                self._nested_blocks.pop()
+            # if the node is an elif, this should not be another nesting level
+            if isinstance(node, nodes.If) and self._is_actual_elif(node):
+                if self._nested_blocks:
+                    self._nested_blocks.pop()
+            self._nested_blocks.append(node)
+
+        # send message only once per group of nested blocks
+        if len(nested_blocks) > len(self._nested_blocks):
+            self._emit_nested_blocks_message_if_needed(nested_blocks)
+
+    def _emit_nested_blocks_message_if_needed(self, nested_blocks):
+        if len(nested_blocks) > self.config.max_nested_blocks:
+            self.add_message(
+                "too-many-nested-blocks",
+                node=nested_blocks[0],
+                args=(len(nested_blocks), self.config.max_nested_blocks),
+            )
+
+    def _emit_consider_using_with_if_needed(self, stack: Dict[str, nodes.NodeNG]):
+        for node in stack.values():
+            self.add_message("consider-using-with", node=node)
+
+    @staticmethod
+    def _duplicated_isinstance_types(node):
+        """Get the duplicated types from the underlying isinstance calls.
+
+        :param nodes.BoolOp node: Node which should contain a bunch of isinstance calls.
+        :returns: Dictionary of the comparison objects from the isinstance calls,
+                  to duplicate values from consecutive calls.
+        :rtype: dict
+        """
+        duplicated_objects = set()
+        all_types = collections.defaultdict(set)
+
+        for call in node.values:
+            if not isinstance(call, nodes.Call) or len(call.args) != 2:
+                continue
+
+            inferred = utils.safe_infer(call.func)
+            if not inferred or not utils.is_builtin_object(inferred):
+                continue
+
+            if inferred.name != "isinstance":
+                continue
+
+            isinstance_object = call.args[0].as_string()
+            isinstance_types = call.args[1]
+
+            if isinstance_object in all_types:
+                duplicated_objects.add(isinstance_object)
+
+            if isinstance(isinstance_types, nodes.Tuple):
+                elems = [
+                    class_type.as_string() for class_type in isinstance_types.itered()
+                ]
+            else:
+                elems = [isinstance_types.as_string()]
+            all_types[isinstance_object].update(elems)
+
+        # Remove all keys which not duplicated
+        return {
+            key: value for key, value in all_types.items() if key in duplicated_objects
+        }
+
+    def _check_consider_merging_isinstance(self, node):
+        """Check isinstance calls which can be merged together."""
+        if node.op != "or":
+            return
+
+        first_args = self._duplicated_isinstance_types(node)
+        for duplicated_name, class_names in first_args.items():
+            names = sorted(name for name in class_names)
+            self.add_message(
+                "consider-merging-isinstance",
+                node=node,
+                args=(duplicated_name, ", ".join(names)),
+            )
+
+    def _check_consider_using_in(self, node):
+        allowed_ops = {"or": "==", "and": "!="}
+
+        if node.op not in allowed_ops or len(node.values) < 2:
+            return
+
+        for value in node.values:
+            if (
+                not isinstance(value, nodes.Compare)
+                or len(value.ops) != 1
+                or value.ops[0][0] not in allowed_ops[node.op]
+            ):
+                return
+            for comparable in value.left, value.ops[0][1]:
+                if isinstance(comparable, nodes.Call):
+                    return
+
+        # Gather variables and values from comparisons
+        variables, values = [], []
+        for value in node.values:
+            variable_set = set()
+            for comparable in value.left, value.ops[0][1]:
+                if isinstance(comparable, (nodes.Name, nodes.Attribute)):
+                    variable_set.add(comparable.as_string())
+                values.append(comparable.as_string())
+            variables.append(variable_set)
+
+        # Look for (common-)variables that occur in all comparisons
+        common_variables = reduce(lambda a, b: a.intersection(b), variables)
+
+        if not common_variables:
+            return
+
+        # Gather information for the suggestion
+        common_variable = sorted(list(common_variables))[0]
+        comprehension = "in" if node.op == "or" else "not in"
+        values = list(collections.OrderedDict.fromkeys(values))
+        values.remove(common_variable)
+        values_string = ", ".join(values) if len(values) != 1 else values[0] + ","
+        suggestion = f"{common_variable} {comprehension} ({values_string})"
+
+        self.add_message("consider-using-in", node=node, args=(suggestion,))
+
+    def _check_chained_comparison(self, node):
+        """Check if there is any chained comparison in the expression.
+
+        Add a refactoring message if a boolOp contains comparison like a < b and b < c,
+        which can be chained as a < b < c.
+
+        Care is taken to avoid simplifying a < b < c and b < d.
+        """
+        if node.op != "and" or len(node.values) < 2:
+            return
+
+        def _find_lower_upper_bounds(comparison_node, uses):
+            left_operand = comparison_node.left
+            for operator, right_operand in comparison_node.ops:
+                for operand in (left_operand, right_operand):
+                    value = None
+                    if isinstance(operand, nodes.Name):
+                        value = operand.name
+                    elif isinstance(operand, nodes.Const):
+                        value = operand.value
+
+                    if value is None:
+                        continue
+
+                    if operator in {"<", "<="}:
+                        if operand is left_operand:
+                            uses[value]["lower_bound"].add(comparison_node)
+                        elif operand is right_operand:
+                            uses[value]["upper_bound"].add(comparison_node)
+                    elif operator in {">", ">="}:
+                        if operand is left_operand:
+                            uses[value]["upper_bound"].add(comparison_node)
+                        elif operand is right_operand:
+                            uses[value]["lower_bound"].add(comparison_node)
+                left_operand = right_operand
+
+        uses = collections.defaultdict(
+            lambda: {"lower_bound": set(), "upper_bound": set()}
+        )
+        for comparison_node in node.values:
+            if isinstance(comparison_node, nodes.Compare):
+                _find_lower_upper_bounds(comparison_node, uses)
+
+        for _, bounds in uses.items():
+            num_shared = len(bounds["lower_bound"].intersection(bounds["upper_bound"]))
+            num_lower_bounds = len(bounds["lower_bound"])
+            num_upper_bounds = len(bounds["upper_bound"])
+            if num_shared < num_lower_bounds and num_shared < num_upper_bounds:
+                self.add_message("chained-comparison", node=node)
+                break
+
+    @staticmethod
+    def _apply_boolean_simplification_rules(operator, values):
+        """Removes irrelevant values or returns shortcircuiting values.
+
+        This function applies the following two rules:
+        1) an OR expression with True in it will always be true, and the
+           reverse for AND
+
+        2) False values in OR expressions are only relevant if all values are
+           false, and the reverse for AND
+        """
+        simplified_values = []
+
+        for subnode in values:
+            inferred_bool = None
+            if not next(subnode.nodes_of_class(nodes.Name), False):
+                inferred = utils.safe_infer(subnode)
+                if inferred:
+                    inferred_bool = inferred.bool_value()
+
+            if not isinstance(inferred_bool, bool):
+                simplified_values.append(subnode)
+            elif (operator == "or") == inferred_bool:
+                return [subnode]
+
+        return simplified_values or [nodes.Const(operator == "and")]
+
+    def _simplify_boolean_operation(self, bool_op):
+        """Attempts to simplify a boolean operation.
+
+        Recursively applies simplification on the operator terms,
+        and keeps track of whether reductions have been made.
+        """
+        children = list(bool_op.get_children())
+        intermediate = [
+            self._simplify_boolean_operation(child)
+            if isinstance(child, nodes.BoolOp)
+            else child
+            for child in children
+        ]
+        result = self._apply_boolean_simplification_rules(bool_op.op, intermediate)
+        if len(result) < len(children):
+            self._can_simplify_bool_op = True
+        if len(result) == 1:
+            return result[0]
+        simplified_bool_op = copy.copy(bool_op)
+        simplified_bool_op.postinit(result)
+        return simplified_bool_op
+
+    def _check_simplifiable_condition(self, node):
+        """Check if a boolean condition can be simplified.
+
+        Variables will not be simplified, even in the value can be inferred,
+        and expressions like '3 + 4' will remain expanded.
+        """
+        if not utils.is_test_condition(node):
+            return
+
+        self._can_simplify_bool_op = False
+        simplified_expr = self._simplify_boolean_operation(node)
+
+        if not self._can_simplify_bool_op:
+            return
+
+        if not next(simplified_expr.nodes_of_class(nodes.Name), False):
+            self.add_message(
+                "condition-evals-to-constant",
+                node=node,
+                args=(node.as_string(), simplified_expr.as_string()),
+            )
+        else:
+            self.add_message(
+                "simplifiable-condition",
+                node=node,
+                args=(node.as_string(), simplified_expr.as_string()),
+            )
+
+    @utils.check_messages(
+        "consider-merging-isinstance",
+        "consider-using-in",
+        "chained-comparison",
+        "simplifiable-condition",
+        "condition-evals-to-constant",
+    )
+    def visit_boolop(self, node: nodes.BoolOp) -> None:
+        self._check_consider_merging_isinstance(node)
+        self._check_consider_using_in(node)
+        self._check_chained_comparison(node)
+        self._check_simplifiable_condition(node)
+
+    @staticmethod
+    def _is_simple_assignment(node):
+        return (
+            isinstance(node, nodes.Assign)
+            and len(node.targets) == 1
+            and isinstance(node.targets[0], nodes.AssignName)
+            and isinstance(node.value, nodes.Name)
+        )
+
+    def _check_swap_variables(self, node):
+        if not node.next_sibling() or not node.next_sibling().next_sibling():
+            return
+        assignments = [node, node.next_sibling(), node.next_sibling().next_sibling()]
+        if not all(self._is_simple_assignment(node) for node in assignments):
+            return
+        if any(node in self._reported_swap_nodes for node in assignments):
+            return
+        left = [node.targets[0].name for node in assignments]
+        right = [node.value.name for node in assignments]
+        if left[0] == right[-1] and left[1:] == right[:-1]:
+            self._reported_swap_nodes.update(assignments)
+            message = "consider-swap-variables"
+            self.add_message(message, node=node)
+
+    @utils.check_messages(
+        "simplify-boolean-expression",
+        "consider-using-ternary",
+        "consider-swap-variables",
+        "consider-using-with",
+    )
+    def visit_assign(self, node: nodes.Assign) -> None:
+        self._append_context_managers_to_stack(node)
+        self.visit_return(node)  # remaining checks are identical as for return nodes
+
+    @utils.check_messages(
+        "simplify-boolean-expression",
+        "consider-using-ternary",
+        "consider-swap-variables",
+    )
+    def visit_return(self, node: nodes.Return) -> None:
+        self._check_swap_variables(node)
+        if self._is_and_or_ternary(node.value):
+            cond, truth_value, false_value = self._and_or_ternary_arguments(node.value)
+        else:
+            return
+
+        if all(
+            isinstance(value, nodes.Compare) for value in (truth_value, false_value)
+        ):
+            return
+
+        inferred_truth_value = utils.safe_infer(truth_value)
+        if inferred_truth_value is None or inferred_truth_value == astroid.Uninferable:
+            truth_boolean_value = True
+        else:
+            truth_boolean_value = inferred_truth_value.bool_value()
+
+        if truth_boolean_value is False:
+            message = "simplify-boolean-expression"
+            suggestion = false_value.as_string()
+        else:
+            message = "consider-using-ternary"
+            suggestion = f"{truth_value.as_string()} if {cond.as_string()} else {false_value.as_string()}"
+        self.add_message(message, node=node, args=(suggestion,))
+
+    def _append_context_managers_to_stack(self, node: nodes.Assign) -> None:
+        if _is_inside_context_manager(node):
+            # if we are inside a context manager itself, we assume that it will handle the resource management itself.
+            return
+        if isinstance(node.targets[0], (nodes.Tuple, nodes.List, nodes.Set)):
+            assignees = node.targets[0].elts
+            value = utils.safe_infer(node.value)
+            if value is None or not hasattr(value, "elts"):
+                # We cannot deduce what values are assigned, so we have to skip this
+                return
+            values = value.elts
+        else:
+            assignees = [node.targets[0]]
+            values = [node.value]
+        if Uninferable in (assignees, values):
+            return
+        for assignee, value in zip(assignees, values):
+            if not isinstance(value, nodes.Call):
+                continue
+            inferred = utils.safe_infer(value.func)
+            if (
+                not inferred
+                or inferred.qname() not in CALLS_RETURNING_CONTEXT_MANAGERS
+                or not isinstance(assignee, (nodes.AssignName, nodes.AssignAttr))
+            ):
+                continue
+            stack = self._consider_using_with_stack.get_stack_for_frame(
+                node.frame(future=True)
+            )
+            varname = (
+                assignee.name
+                if isinstance(assignee, nodes.AssignName)
+                else assignee.attrname
+            )
+            if varname in stack:
+                existing_node = stack[varname]
+                if astroid.are_exclusive(node, existing_node):
+                    # only one of the two assignments can be executed at runtime, thus it is fine
+                    stack[varname] = value
+                    continue
+                # variable was redefined before it was used in a ``with`` block
+                self.add_message(
+                    "consider-using-with",
+                    node=existing_node,
+                )
+            stack[varname] = value
+
+    def _check_consider_using_with(self, node: nodes.Call):
+        if _is_inside_context_manager(node) or _is_a_return_statement(node):
+            # If we are inside a context manager itself, we assume that it will handle the resource management itself.
+            # If the node is a child of a return, we assume that the caller knows he is getting a context manager
+            # he should use properly (i.e. in a ``with``).
+            return
+        if (
+            node
+            in self._consider_using_with_stack.get_stack_for_frame(
+                node.frame(future=True)
+            ).values()
+        ):
+            # the result of this call was already assigned to a variable and will be checked when leaving the scope.
+            return
+        inferred = utils.safe_infer(node.func)
+        if not inferred:
+            return
+        could_be_used_in_with = (
+            # things like ``lock.acquire()``
+            inferred.qname() in CALLS_THAT_COULD_BE_REPLACED_BY_WITH
+            or (
+                # things like ``open("foo")`` which are not already inside a ``with`` statement
+                inferred.qname() in CALLS_RETURNING_CONTEXT_MANAGERS
+                and not _is_part_of_with_items(node)
+            )
+        )
+        if could_be_used_in_with and not _will_be_released_automatically(node):
+            self.add_message("consider-using-with", node=node)
+
+    def _check_use_list_or_dict_literal(self, node: nodes.Call) -> None:
+        """Check if empty list or dict is created by using the literal [] or {}."""
+        if node.as_string() in {"list()", "dict()"}:
+            inferred = utils.safe_infer(node.func)
+            if isinstance(inferred, nodes.ClassDef) and not node.args:
+                if inferred.qname() == "builtins.list":
+                    self.add_message("use-list-literal", node=node)
+                elif inferred.qname() == "builtins.dict" and not node.keywords:
+                    self.add_message("use-dict-literal", node=node)
+
+    def _check_consider_using_join(self, aug_assign):
+        """We start with the augmented assignment and work our way upwards.
+
+        Names of variables for nodes if match successful:
+        result = ''  # assign
+        for number in ['1', '2', '3']  # for_loop
+            result += number  # aug_assign
+        """
+        for_loop = aug_assign.parent
+        if not isinstance(for_loop, nodes.For) or len(for_loop.body) > 1:
+            return
+        assign = for_loop.previous_sibling()
+        if not isinstance(assign, nodes.Assign):
+            return
+        result_assign_names = {
+            target.name
+            for target in assign.targets
+            if isinstance(target, nodes.AssignName)
+        }
+
+        is_concat_loop = (
+            aug_assign.op == "+="
+            and isinstance(aug_assign.target, nodes.AssignName)
+            and len(for_loop.body) == 1
+            and aug_assign.target.name in result_assign_names
+            and isinstance(assign.value, nodes.Const)
+            and isinstance(assign.value.value, str)
+            and isinstance(aug_assign.value, nodes.Name)
+            and aug_assign.value.name == for_loop.target.name
+        )
+        if is_concat_loop:
+            self.add_message("consider-using-join", node=aug_assign)
+
+    @utils.check_messages("consider-using-join")
+    def visit_augassign(self, node: nodes.AugAssign) -> None:
+        self._check_consider_using_join(node)
+
+    @utils.check_messages("unnecessary-comprehension", "unnecessary-dict-index-lookup")
+    def visit_comprehension(self, node: nodes.Comprehension) -> None:
+        self._check_unnecessary_comprehension(node)
+        self._check_unnecessary_dict_index_lookup(node)
+
+    def _check_unnecessary_comprehension(self, node: nodes.Comprehension) -> None:
+        if (
+            isinstance(node.parent, nodes.GeneratorExp)
+            or len(node.ifs) != 0
+            or len(node.parent.generators) != 1
+            or node.is_async
+        ):
+            return
+
+        if (
+            isinstance(node.parent, nodes.DictComp)
+            and isinstance(node.parent.key, nodes.Name)
+            and isinstance(node.parent.value, nodes.Name)
+            and isinstance(node.target, nodes.Tuple)
+            and all(isinstance(elt, nodes.AssignName) for elt in node.target.elts)
+        ):
+            expr_list = [node.parent.key.name, node.parent.value.name]
+            target_list = [elt.name for elt in node.target.elts]
+
+        elif isinstance(node.parent, (nodes.ListComp, nodes.SetComp)):
+            expr = node.parent.elt
+            if isinstance(expr, nodes.Name):
+                expr_list = expr.name
+            elif isinstance(expr, nodes.Tuple):
+                if any(not isinstance(elt, nodes.Name) for elt in expr.elts):
+                    return
+                expr_list = [elt.name for elt in expr.elts]
+            else:
+                expr_list = []
+            target = node.parent.generators[0].target
+            target_list = (
+                target.name
+                if isinstance(target, nodes.AssignName)
+                else (
+                    [
+                        elt.name
+                        for elt in target.elts
+                        if isinstance(elt, nodes.AssignName)
+                    ]
+                    if isinstance(target, nodes.Tuple)
+                    else []
+                )
+            )
+        else:
+            return
+        if expr_list == target_list and expr_list:
+            args: Optional[Tuple[str]] = None
+            inferred = utils.safe_infer(node.iter)
+            if isinstance(node.parent, nodes.DictComp) and isinstance(
+                inferred, astroid.objects.DictItems
+            ):
+                args = (f"{node.iter.func.expr.as_string()}",)
+            elif (
+                isinstance(node.parent, nodes.ListComp)
+                and isinstance(inferred, nodes.List)
+            ) or (
+                isinstance(node.parent, nodes.SetComp)
+                and isinstance(inferred, nodes.Set)
+            ):
+                args = (f"{node.iter.as_string()}",)
+            if args:
+                self.add_message(
+                    "unnecessary-comprehension", node=node.parent, args=args
+                )
+                return
+
+            if isinstance(node.parent, nodes.DictComp):
+                func = "dict"
+            elif isinstance(node.parent, nodes.ListComp):
+                func = "list"
+            elif isinstance(node.parent, nodes.SetComp):
+                func = "set"
+            else:
+                return
+
+            self.add_message(
+                "unnecessary-comprehension",
+                node=node.parent,
+                args=(f"{func}({node.iter.as_string()})",),
+            )
+
+    @staticmethod
+    def _is_and_or_ternary(node):
+        """Returns true if node is 'condition and true_value or false_value' form.
+
+        All of: condition, true_value and false_value should not be a complex boolean expression
+        """
+        return (
+            isinstance(node, nodes.BoolOp)
+            and node.op == "or"
+            and len(node.values) == 2
+            and isinstance(node.values[0], nodes.BoolOp)
+            and not isinstance(node.values[1], nodes.BoolOp)
+            and node.values[0].op == "and"
+            and not isinstance(node.values[0].values[1], nodes.BoolOp)
+            and len(node.values[0].values) == 2
+        )
+
+    @staticmethod
+    def _and_or_ternary_arguments(node):
+        false_value = node.values[1]
+        condition, true_value = node.values[0].values
+        return condition, true_value, false_value
+
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        self._return_nodes[node.name] = list(
+            node.nodes_of_class(nodes.Return, skip_klass=nodes.FunctionDef)
+        )
+
+    def _check_consistent_returns(self, node: nodes.FunctionDef) -> None:
+        """Check that all return statements inside a function are consistent.
+
+        Return statements are consistent if:
+            - all returns are explicit and if there is no implicit return;
+            - all returns are empty and if there is, possibly, an implicit return.
+
+        Args:
+            node (nodes.FunctionDef): the function holding the return statements.
+
+        """
+        # explicit return statements are those with a not None value
+        explicit_returns = [
+            _node for _node in self._return_nodes[node.name] if _node.value is not None
+        ]
+        if not explicit_returns:
+            return
+        if len(explicit_returns) == len(
+            self._return_nodes[node.name]
+        ) and self._is_node_return_ended(node):
+            return
+        self.add_message("inconsistent-return-statements", node=node)
+
+    def _is_if_node_return_ended(self, node: nodes.If) -> bool:
+        """Check if the If node ends with an explicit return statement.
+
+        Args:
+            node (nodes.If): If node to be checked.
+
+        Returns:
+            bool: True if the node ends with an explicit statement, False otherwise.
+        """
+        # Do not check if inner function definition are return ended.
+        is_if_returning = any(
+            self._is_node_return_ended(_ifn)
+            for _ifn in node.body
+            if not isinstance(_ifn, nodes.FunctionDef)
+        )
+        if not node.orelse:
+            # If there is not orelse part then the if statement is returning if :
+            # - there is at least one return statement in its siblings;
+            # - the if body is itself returning.
+            if not self._has_return_in_siblings(node):
+                return False
+            return is_if_returning
+        # If there is an orelse part then both if body and orelse part should return.
+        is_orelse_returning = any(
+            self._is_node_return_ended(_ore)
+            for _ore in node.orelse
+            if not isinstance(_ore, nodes.FunctionDef)
+        )
+        return is_if_returning and is_orelse_returning
+
+    def _is_raise_node_return_ended(self, node: nodes.Raise) -> bool:
+        """Check if the Raise node ends with an explicit return statement.
+
+        Args:
+            node (nodes.Raise): Raise node to be checked.
+
+        Returns:
+            bool: True if the node ends with an explicit statement, False otherwise.
+        """
+        # a Raise statement doesn't need to end with a return statement
+        # but if the exception raised is handled, then the handler has to
+        # ends with a return statement
+        if not node.exc:
+            # Ignore bare raises
+            return True
+        if not utils.is_node_inside_try_except(node):
+            # If the raise statement is not inside a try/except statement
+            # then the exception is raised and cannot be caught. No need
+            # to infer it.
+            return True
+        exc = utils.safe_infer(node.exc)
+        if exc is None or exc is astroid.Uninferable or not hasattr(exc, "pytype"):
+            return False
+        exc_name = exc.pytype().split(".")[-1]
+        handlers = utils.get_exception_handlers(node, exc_name)
+        handlers = list(handlers) if handlers is not None else []
+        if handlers:
+            # among all the handlers handling the exception at least one
+            # must end with a return statement
+            return any(self._is_node_return_ended(_handler) for _handler in handlers)
+        # if no handlers handle the exception then it's ok
+        return True
+
+    def _is_node_return_ended(self, node: nodes.NodeNG) -> bool:
+        """Check if the node ends with an explicit return statement.
+
+        Args:
+            node (nodes.NodeNG): node to be checked.
+
+        Returns:
+            bool: True if the node ends with an explicit statement, False otherwise.
+
+        """
+        # Recursion base case
+        if isinstance(node, nodes.Return):
+            return True
+        if isinstance(node, nodes.Call):
+            try:
+                funcdef_node = node.func.inferred()[0]
+                if self._is_function_def_never_returning(funcdef_node):
+                    return True
+            except astroid.InferenceError:
+                pass
+        # Avoid the check inside while loop as we don't know
+        # if they will be completed
+        if isinstance(node, nodes.While):
+            return True
+        if isinstance(node, nodes.Raise):
+            return self._is_raise_node_return_ended(node)
+        if isinstance(node, nodes.If):
+            return self._is_if_node_return_ended(node)
+        if isinstance(node, nodes.TryExcept):
+            handlers = {
+                _child
+                for _child in node.get_children()
+                if isinstance(_child, nodes.ExceptHandler)
+            }
+            all_but_handler = set(node.get_children()) - handlers
+            return any(
+                self._is_node_return_ended(_child) for _child in all_but_handler
+            ) and all(self._is_node_return_ended(_child) for _child in handlers)
+        if (
+            isinstance(node, nodes.Assert)
+            and isinstance(node.test, nodes.Const)
+            and not node.test.value
+        ):
+            # consider assert False as a return node
+            return True
+        # recurses on the children of the node
+        return any(self._is_node_return_ended(_child) for _child in node.get_children())
+
+    @staticmethod
+    def _has_return_in_siblings(node: nodes.NodeNG) -> bool:
+        """Returns True if there is at least one return in the node's siblings."""
+        next_sibling = node.next_sibling()
+        while next_sibling:
+            if isinstance(next_sibling, nodes.Return):
+                return True
+            next_sibling = next_sibling.next_sibling()
+        return False
+
+    def _is_function_def_never_returning(self, node: nodes.FunctionDef) -> bool:
+        """Return True if the function never returns, False otherwise.
+
+        Args:
+            node (nodes.FunctionDef): function definition node to be analyzed.
+
+        Returns:
+            bool: True if the function never returns, False otherwise.
+        """
+        if isinstance(node, nodes.FunctionDef) and node.returns:
+            return (
+                isinstance(node.returns, nodes.Attribute)
+                and node.returns.attrname == "NoReturn"
+                or isinstance(node.returns, nodes.Name)
+                and node.returns.name == "NoReturn"
+            )
+        try:
+            return node.qname() in self._never_returning_functions
+        except TypeError:
+            return False
+
+    def _check_return_at_the_end(self, node):
+        """Check for presence of a *single* return statement at the end of a
+        function.
+
+        "return" or "return None" are useless because None is the
+        default return type if they are missing.
+
+        NOTE: produces a message only if there is a single return statement
+        in the function body. Otherwise _check_consistent_returns() is called!
+        Per its implementation and PEP8 we can have a "return None" at the end
+        of the function body if there are other return statements before that!
+        """
+        if len(self._return_nodes[node.name]) > 1:
+            return
+        if len(node.body) <= 1:
+            return
+
+        last = node.body[-1]
+        if isinstance(last, nodes.Return):
+            # e.g. "return"
+            if last.value is None:
+                self.add_message("useless-return", node=node)
+            # return None"
+            elif isinstance(last.value, nodes.Const) and (last.value.value is None):
+                self.add_message("useless-return", node=node)
+
+    def _check_unnecessary_dict_index_lookup(
+        self, node: Union[nodes.For, nodes.Comprehension]
+    ) -> None:
+        """Add message when accessing dict values by index lookup."""
+        # Verify that we have an .items() call and
+        # that the object which is iterated is used as a subscript in the
+        # body of the for.
+        # Is it a proper items call?
+        if (
+            isinstance(node.iter, nodes.Call)
+            and isinstance(node.iter.func, nodes.Attribute)
+            and node.iter.func.attrname == "items"
+        ):
+            inferred = utils.safe_infer(node.iter.func)
+            if not isinstance(inferred, astroid.BoundMethod):
+                return
+            iterating_object_name = node.iter.func.expr.as_string()
+
+            # Verify that the body of the for loop uses a subscript
+            # with the object that was iterated. This uses some heuristics
+            # in order to make sure that the same object is used in the
+            # for body.
+
+            children = (
+                node.body if isinstance(node, nodes.For) else node.parent.get_children()
+            )
+            for child in children:
+                for subscript in child.nodes_of_class(nodes.Subscript):
+                    if not isinstance(subscript.value, (nodes.Name, nodes.Attribute)):
+                        continue
+
+                    value = subscript.slice
+
+                    if isinstance(node, nodes.For) and (
+                        isinstance(subscript.parent, nodes.Assign)
+                        and subscript in subscript.parent.targets
+                        or isinstance(subscript.parent, nodes.AugAssign)
+                        and subscript == subscript.parent.target
+                    ):
+                        # Ignore this subscript if it is the target of an assignment
+                        # Early termination; after reassignment dict index lookup will be necessary
+                        return
+                    if isinstance(subscript.parent, nodes.Delete):
+                        # Ignore this subscript if it's used with the delete keyword
+                        return
+
+                    # Case where .items is assigned to k,v (i.e., for k, v in d.items())
+                    if isinstance(value, nodes.Name):
+                        if (
+                            not isinstance(node.target, nodes.Tuple)
+                            # Ignore 1-tuples: for k, in d.items()
+                            or len(node.target.elts) < 2
+                            or value.name != node.target.elts[0].name
+                            or iterating_object_name != subscript.value.as_string()
+                        ):
+                            continue
+
+                        if (
+                            isinstance(node, nodes.For)
+                            and value.lookup(value.name)[1][-1].lineno > node.lineno
+                        ):
+                            # Ignore this subscript if it has been redefined after
+                            # the for loop. This checks for the line number using .lookup()
+                            # to get the line number where the iterating object was last
+                            # defined and compare that to the for loop's line number
+                            continue
+
+                        self.add_message(
+                            "unnecessary-dict-index-lookup",
+                            node=subscript,
+                            args=(node.target.elts[1].as_string()),
+                        )
+
+                    # Case where .items is assigned to single var (i.e., for item in d.items())
+                    elif isinstance(value, nodes.Subscript):
+                        if (
+                            not isinstance(node.target, nodes.AssignName)
+                            or not isinstance(value.value, nodes.Name)
+                            or node.target.name != value.value.name
+                            or iterating_object_name != subscript.value.as_string()
+                        ):
+                            continue
+
+                        if (
+                            isinstance(node, nodes.For)
+                            and value.value.lookup(value.value.name)[1][-1].lineno
+                            > node.lineno
+                        ):
+                            # Ignore this subscript if it has been redefined after
+                            # the for loop. This checks for the line number using .lookup()
+                            # to get the line number where the iterating object was last
+                            # defined and compare that to the for loop's line number
+                            continue
+
+                        # check if subscripted by 0 (key)
+                        inferred = utils.safe_infer(value.slice)
+                        if not isinstance(inferred, nodes.Const) or inferred.value != 0:
+                            continue
+                        self.add_message(
+                            "unnecessary-dict-index-lookup",
+                            node=subscript,
+                            args=("1".join(value.as_string().rsplit("0", maxsplit=1)),),
+                        )
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/similar.py b/myenv/lib/python3.9/site-packages/pylint/checkers/similar.py
new file mode 100644
index 0000000..e85bac5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/similar.py
@@ -0,0 +1,946 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""A similarities / code duplication command line tool and pylint checker.
+
+The algorithm is based on comparing the hash value of n successive lines of a file.
+First the files are read and any line that doesn't fulfill requirement are removed (comments, docstrings...)
+Those stripped lines are stored in the LineSet class which gives access to them.
+Then each index of the stripped lines collection is associated with the hash of n successive entries of the stripped lines starting at the current index
+(n is the minimum common lines option).
+The common hashes between both linesets are then looked for. If there are matches, then the match indices in both linesets are stored and associated
+with the corresponding couples (start line number/end line number) in both files.
+This association is then postprocessed to handle the case of successive matches. For example if the minimum common lines setting is set to four, then
+the hashes are computed with four lines. If one of match indices couple (12, 34) is the successor of another one (11, 33) then it means that there are
+in fact five lines which are common.
+Once postprocessed the values of association table are the result looked for, i.e start and end lines numbers of common lines in both files.
+"""
+import copy
+import functools
+import itertools
+import operator
+import re
+import sys
+import warnings
+from collections import defaultdict
+from getopt import getopt
+from io import BufferedIOBase, BufferedReader, BytesIO
+from itertools import chain, groupby
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    FrozenSet,
+    Generator,
+    Iterable,
+    List,
+    NamedTuple,
+    NewType,
+    Optional,
+    Set,
+    TextIO,
+    Tuple,
+    Union,
+)
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker, MapReduceMixin, table_lines_from_stats
+from pylint.interfaces import IRawChecker
+from pylint.reporters.ureports.nodes import Table
+from pylint.utils import LinterStats, decoding_stream
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+DEFAULT_MIN_SIMILARITY_LINE = 4
+
+REGEX_FOR_LINES_WITH_CONTENT = re.compile(r".*\w+")
+
+# Index defines a location in a LineSet stripped lines collection
+Index = NewType("Index", int)
+
+# LineNumber defines a location in a LinesSet real lines collection (the whole file lines)
+LineNumber = NewType("LineNumber", int)
+
+
+# LineSpecifs holds characteristics of a line in a file
+class LineSpecifs(NamedTuple):
+    line_number: LineNumber
+    text: str
+
+
+# Links LinesChunk object to the starting indices (in lineset's stripped lines)
+# of the different chunk of lines that are used to compute the hash
+HashToIndex_T = Dict["LinesChunk", List[Index]]
+
+# Links index in the lineset's stripped lines to the real lines in the file
+IndexToLines_T = Dict[Index, "SuccessiveLinesLimits"]
+
+# The types the streams read by pylint can take. Originating from astroid.nodes.Module.stream() and open()
+STREAM_TYPES = Union[TextIO, BufferedReader, BytesIO]
+
+
+class CplSuccessiveLinesLimits:
+    """Holds a SuccessiveLinesLimits object for each file compared and a
+    counter on the number of common lines between both stripped lines collections extracted from both files
+    """
+
+    __slots__ = ("first_file", "second_file", "effective_cmn_lines_nb")
+
+    def __init__(
+        self,
+        first_file: "SuccessiveLinesLimits",
+        second_file: "SuccessiveLinesLimits",
+        effective_cmn_lines_nb: int,
+    ) -> None:
+        self.first_file = first_file
+        self.second_file = second_file
+        self.effective_cmn_lines_nb = effective_cmn_lines_nb
+
+
+# Links the indices to the starting line in both lineset's stripped lines to
+# the start and end lines in both files
+CplIndexToCplLines_T = Dict["LineSetStartCouple", CplSuccessiveLinesLimits]
+
+
+class LinesChunk:
+    """The LinesChunk object computes and stores the hash of some consecutive stripped lines of a lineset."""
+
+    __slots__ = ("_fileid", "_index", "_hash")
+
+    def __init__(self, fileid: str, num_line: int, *lines: Iterable[str]) -> None:
+        self._fileid: str = fileid
+        """The name of the file from which the LinesChunk object is generated."""
+
+        self._index: Index = Index(num_line)
+        """The index in the stripped lines that is the starting of consecutive lines."""
+
+        self._hash: int = sum(hash(lin) for lin in lines)
+        """The hash of some consecutive lines."""
+
+    def __eq__(self, o: Any) -> bool:
+        if not isinstance(o, LinesChunk):
+            return NotImplemented
+        return self._hash == o._hash
+
+    def __hash__(self) -> int:
+        return self._hash
+
+    def __repr__(self) -> str:
+        return (
+            f"<LinesChunk object for file {self._fileid} ({self._index}, {self._hash})>"
+        )
+
+    def __str__(self) -> str:
+        return (
+            f"LinesChunk object for file {self._fileid}, starting at line {self._index} \n"
+            f"Hash is {self._hash}"
+        )
+
+
+class SuccessiveLinesLimits:
+    """A class to handle the numbering of begin and end of successive lines.
+
+    :note: Only the end line number can be updated.
+    """
+
+    __slots__ = ("_start", "_end")
+
+    def __init__(self, start: LineNumber, end: LineNumber) -> None:
+        self._start: LineNumber = start
+        self._end: LineNumber = end
+
+    @property
+    def start(self) -> LineNumber:
+        return self._start
+
+    @property
+    def end(self) -> LineNumber:
+        return self._end
+
+    @end.setter
+    def end(self, value: LineNumber) -> None:
+        self._end = value
+
+    def __repr__(self) -> str:
+        return f"<SuccessiveLinesLimits <{self._start};{self._end}>>"
+
+
+class LineSetStartCouple(NamedTuple):
+    """Indices in both linesets that mark the beginning of successive lines."""
+
+    fst_lineset_index: Index
+    snd_lineset_index: Index
+
+    def __repr__(self) -> str:
+        return (
+            f"<LineSetStartCouple <{self.fst_lineset_index};{self.snd_lineset_index}>>"
+        )
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, LineSetStartCouple):
+            return NotImplemented
+        return (
+            self.fst_lineset_index == other.fst_lineset_index
+            and self.snd_lineset_index == other.snd_lineset_index
+        )
+
+    def __hash__(self) -> int:
+        return hash(self.fst_lineset_index) + hash(self.snd_lineset_index)
+
+    def increment(self, value: Index) -> "LineSetStartCouple":
+        return LineSetStartCouple(
+            Index(self.fst_lineset_index + value),
+            Index(self.snd_lineset_index + value),
+        )
+
+
+LinesChunkLimits_T = Tuple["LineSet", LineNumber, LineNumber]
+
+
+def hash_lineset(
+    lineset: "LineSet", min_common_lines: int = DEFAULT_MIN_SIMILARITY_LINE
+) -> Tuple[HashToIndex_T, IndexToLines_T]:
+    """Return two dicts.
+
+    The first associates the hash of successive stripped lines of a lineset
+    to the indices of the starting lines.
+    The second dict, associates the index of the starting line in the lineset's stripped lines to the
+    couple [start, end] lines number in the corresponding file.
+
+    :param lineset: lineset object (i.e the lines in a file)
+    :param min_common_lines: number of successive lines that are used to compute the hash
+    :return: a dict linking hashes to corresponding start index and a dict that links this
+             index to the start and end lines in the file
+    """
+    hash2index = defaultdict(list)
+    index2lines = {}
+    # Comments, docstring and other specific patterns maybe excluded -> call to stripped_lines
+    # to get only what is desired
+    lines = tuple(x.text for x in lineset.stripped_lines)
+    # Need different iterators on same lines but each one is shifted 1 from the precedent
+    shifted_lines = [iter(lines[i:]) for i in range(min_common_lines)]
+
+    for index_i, *succ_lines in enumerate(zip(*shifted_lines)):
+        start_linenumber = lineset.stripped_lines[index_i].line_number
+        try:
+            end_linenumber = lineset.stripped_lines[
+                index_i + min_common_lines
+            ].line_number
+        except IndexError:
+            end_linenumber = lineset.stripped_lines[-1].line_number + 1
+
+        index = Index(index_i)
+        index2lines[index] = SuccessiveLinesLimits(
+            start=LineNumber(start_linenumber), end=LineNumber(end_linenumber)
+        )
+
+        l_c = LinesChunk(lineset.name, index, *succ_lines)
+        hash2index[l_c].append(index)
+
+    return hash2index, index2lines
+
+
+def remove_successives(all_couples: CplIndexToCplLines_T) -> None:
+    """Removes all successive entries in the dictionary in argument.
+
+    :param all_couples: collection that has to be cleaned up from successives entries.
+                        The keys are couples of indices that mark the beginning of common entries
+                        in both linesets. The values have two parts. The first one is the couple
+                        of starting and ending line numbers of common successives lines in the first file.
+                        The second part is the same for the second file.
+
+    For example consider the following dict:
+
+    >>> all_couples
+    {(11, 34): ([5, 9], [27, 31]),
+     (23, 79): ([15, 19], [45, 49]),
+     (12, 35): ([6, 10], [28, 32])}
+
+    There are two successives keys (11, 34) and (12, 35).
+    It means there are two consecutive similar chunks of lines in both files.
+    Thus remove last entry and update the last line numbers in the first entry
+
+    >>> remove_successives(all_couples)
+    >>> all_couples
+    {(11, 34): ([5, 10], [27, 32]),
+     (23, 79): ([15, 19], [45, 49])}
+    """
+    couple: LineSetStartCouple
+    for couple in tuple(all_couples.keys()):
+        to_remove = []
+        test = couple.increment(Index(1))
+        while test in all_couples:
+            all_couples[couple].first_file.end = all_couples[test].first_file.end
+            all_couples[couple].second_file.end = all_couples[test].second_file.end
+            all_couples[couple].effective_cmn_lines_nb += 1
+            to_remove.append(test)
+            test = test.increment(Index(1))
+
+        for target in to_remove:
+            try:
+                all_couples.pop(target)
+            except KeyError:
+                pass
+
+
+def filter_noncode_lines(
+    ls_1: "LineSet",
+    stindex_1: Index,
+    ls_2: "LineSet",
+    stindex_2: Index,
+    common_lines_nb: int,
+) -> int:
+    """Return the effective number of common lines between lineset1
+    and lineset2 filtered from non code lines.
+
+    That is to say the number of common successive stripped
+    lines except those that do not contain code (for example
+    a line with only an ending parathensis)
+
+    :param ls_1: first lineset
+    :param stindex_1: first lineset starting index
+    :param ls_2: second lineset
+    :param stindex_2: second lineset starting index
+    :param common_lines_nb: number of common successive stripped lines before being filtered from non code lines
+    :return: the number of common successives stripped lines that contain code
+    """
+    stripped_l1 = [
+        lspecif.text
+        for lspecif in ls_1.stripped_lines[stindex_1 : stindex_1 + common_lines_nb]
+        if REGEX_FOR_LINES_WITH_CONTENT.match(lspecif.text)
+    ]
+    stripped_l2 = [
+        lspecif.text
+        for lspecif in ls_2.stripped_lines[stindex_2 : stindex_2 + common_lines_nb]
+        if REGEX_FOR_LINES_WITH_CONTENT.match(lspecif.text)
+    ]
+    return sum(sline_1 == sline_2 for sline_1, sline_2 in zip(stripped_l1, stripped_l2))
+
+
+class Commonality(NamedTuple):
+    cmn_lines_nb: int
+    fst_lset: "LineSet"
+    fst_file_start: LineNumber
+    fst_file_end: LineNumber
+    snd_lset: "LineSet"
+    snd_file_start: LineNumber
+    snd_file_end: LineNumber
+
+
+class Similar:
+    """Finds copy-pasted lines of code in a project."""
+
+    def __init__(
+        self,
+        min_lines: int = DEFAULT_MIN_SIMILARITY_LINE,
+        ignore_comments: bool = False,
+        ignore_docstrings: bool = False,
+        ignore_imports: bool = False,
+        ignore_signatures: bool = False,
+    ) -> None:
+        self.min_lines = min_lines
+        self.ignore_comments = ignore_comments
+        self.ignore_docstrings = ignore_docstrings
+        self.ignore_imports = ignore_imports
+        self.ignore_signatures = ignore_signatures
+        self.linesets: List["LineSet"] = []
+
+    def append_stream(
+        self, streamid: str, stream: STREAM_TYPES, encoding: Optional[str] = None
+    ) -> None:
+        """Append a file to search for similarities."""
+        if isinstance(stream, BufferedIOBase):
+            if encoding is None:
+                raise ValueError
+            readlines = decoding_stream(stream, encoding).readlines
+        else:
+            readlines = stream.readlines  # type: ignore[assignment] # hint parameter is incorrectly typed as non-optional
+
+        try:
+            lines = readlines()
+        except UnicodeDecodeError:
+            lines = []
+
+        self.linesets.append(
+            LineSet(
+                streamid,
+                lines,
+                self.ignore_comments,
+                self.ignore_docstrings,
+                self.ignore_imports,
+                self.ignore_signatures,
+                line_enabled_callback=self.linter._is_one_message_enabled  # type: ignore[attr-defined]
+                if hasattr(self, "linter")
+                else None,
+            )
+        )
+
+    def run(self) -> None:
+        """Start looking for similarities and display results on stdout."""
+        if self.min_lines == 0:
+            return
+        self._display_sims(self._compute_sims())
+
+    def _compute_sims(self) -> List[Tuple[int, Set[LinesChunkLimits_T]]]:
+        """Compute similarities in appended files."""
+        no_duplicates: Dict[int, List[Set[LinesChunkLimits_T]]] = defaultdict(list)
+
+        for commonality in self._iter_sims():
+            num = commonality.cmn_lines_nb
+            lineset1 = commonality.fst_lset
+            start_line_1 = commonality.fst_file_start
+            end_line_1 = commonality.fst_file_end
+            lineset2 = commonality.snd_lset
+            start_line_2 = commonality.snd_file_start
+            end_line_2 = commonality.snd_file_end
+
+            duplicate = no_duplicates[num]
+            couples: Set[LinesChunkLimits_T]
+            for couples in duplicate:
+                if (lineset1, start_line_1, end_line_1) in couples or (
+                    lineset2,
+                    start_line_2,
+                    end_line_2,
+                ) in couples:
+                    break
+            else:
+                duplicate.append(
+                    {
+                        (lineset1, start_line_1, end_line_1),
+                        (lineset2, start_line_2, end_line_2),
+                    }
+                )
+        sims: List[Tuple[int, Set[LinesChunkLimits_T]]] = []
+        ensembles: List[Set[LinesChunkLimits_T]]
+        for num, ensembles in no_duplicates.items():
+            cpls: Set[LinesChunkLimits_T]
+            for cpls in ensembles:
+                sims.append((num, cpls))
+        sims.sort()
+        sims.reverse()
+        return sims
+
+    def _display_sims(
+        self, similarities: List[Tuple[int, Set[LinesChunkLimits_T]]]
+    ) -> None:
+        """Display computed similarities on stdout."""
+        report = self._get_similarity_report(similarities)
+        print(report)
+
+    def _get_similarity_report(
+        self, similarities: List[Tuple[int, Set[LinesChunkLimits_T]]]
+    ) -> str:
+        """Create a report from similarities."""
+        report: str = ""
+        duplicated_line_number: int = 0
+        for number, couples in similarities:
+            report += f"\n{number} similar lines in {len(couples)} files\n"
+            couples_l = sorted(couples)
+            line_set = start_line = end_line = None
+            for line_set, start_line, end_line in couples_l:
+                report += f"=={line_set.name}:[{start_line}:{end_line}]\n"
+            if line_set:
+                for line in line_set._real_lines[start_line:end_line]:
+                    report += f"   {line.rstrip()}\n" if line.rstrip() else "\n"
+            duplicated_line_number += number * (len(couples_l) - 1)
+        total_line_number: int = sum(len(lineset) for lineset in self.linesets)
+        report += f"TOTAL lines={total_line_number} duplicates={duplicated_line_number} percent={duplicated_line_number * 100.0 / total_line_number:.2f}\n"
+        return report
+
+    def _find_common(
+        self, lineset1: "LineSet", lineset2: "LineSet"
+    ) -> Generator[Commonality, None, None]:
+        """Find similarities in the two given linesets.
+
+        This the core of the algorithm.
+        The idea is to compute the hashes of a minimal number of successive lines of each lineset and then compare the hashes.
+        Every match of such comparison is stored in a dict that links the couple of starting indices in both linesets to
+        the couple of corresponding starting and ending lines in both files.
+        Last regroups all successive couples in a bigger one. It allows to take into account common chunk of lines that have more
+        than the minimal number of successive lines required.
+        """
+        hash_to_index_1: HashToIndex_T
+        hash_to_index_2: HashToIndex_T
+        index_to_lines_1: IndexToLines_T
+        index_to_lines_2: IndexToLines_T
+        hash_to_index_1, index_to_lines_1 = hash_lineset(lineset1, self.min_lines)
+        hash_to_index_2, index_to_lines_2 = hash_lineset(lineset2, self.min_lines)
+
+        hash_1: FrozenSet[LinesChunk] = frozenset(hash_to_index_1.keys())
+        hash_2: FrozenSet[LinesChunk] = frozenset(hash_to_index_2.keys())
+
+        common_hashes: Iterable[LinesChunk] = sorted(
+            hash_1 & hash_2, key=lambda m: hash_to_index_1[m][0]
+        )
+
+        # all_couples is a dict that links the couple of indices in both linesets that mark the beginning of
+        # successive common lines, to the corresponding starting and ending number lines in both files
+        all_couples: CplIndexToCplLines_T = {}
+
+        for c_hash in sorted(common_hashes, key=operator.attrgetter("_index")):
+            for indices_in_linesets in itertools.product(
+                hash_to_index_1[c_hash], hash_to_index_2[c_hash]
+            ):
+                index_1 = indices_in_linesets[0]
+                index_2 = indices_in_linesets[1]
+                all_couples[
+                    LineSetStartCouple(index_1, index_2)
+                ] = CplSuccessiveLinesLimits(
+                    copy.copy(index_to_lines_1[index_1]),
+                    copy.copy(index_to_lines_2[index_2]),
+                    effective_cmn_lines_nb=self.min_lines,
+                )
+
+        remove_successives(all_couples)
+
+        for cml_stripped_l, cmn_l in all_couples.items():
+            start_index_1 = cml_stripped_l.fst_lineset_index
+            start_index_2 = cml_stripped_l.snd_lineset_index
+            nb_common_lines = cmn_l.effective_cmn_lines_nb
+
+            com = Commonality(
+                cmn_lines_nb=nb_common_lines,
+                fst_lset=lineset1,
+                fst_file_start=cmn_l.first_file.start,
+                fst_file_end=cmn_l.first_file.end,
+                snd_lset=lineset2,
+                snd_file_start=cmn_l.second_file.start,
+                snd_file_end=cmn_l.second_file.end,
+            )
+
+            eff_cmn_nb = filter_noncode_lines(
+                lineset1, start_index_1, lineset2, start_index_2, nb_common_lines
+            )
+
+            if eff_cmn_nb > self.min_lines:
+                yield com
+
+    def _iter_sims(self) -> Generator[Commonality, None, None]:
+        """Iterate on similarities among all files, by making a cartesian
+        product
+        """
+        for idx, lineset in enumerate(self.linesets[:-1]):
+            for lineset2 in self.linesets[idx + 1 :]:
+                yield from self._find_common(lineset, lineset2)
+
+    def get_map_data(self):
+        """Returns the data we can use for a map/reduce process.
+
+        In this case we are returning this instance's Linesets, that is all file
+        information that will later be used for vectorisation.
+        """
+        return self.linesets
+
+    def combine_mapreduce_data(self, linesets_collection):
+        """Reduces and recombines data into a format that we can report on.
+
+        The partner function of get_map_data()
+        """
+        self.linesets = [line for lineset in linesets_collection for line in lineset]
+
+
+def stripped_lines(
+    lines: Iterable[str],
+    ignore_comments: bool,
+    ignore_docstrings: bool,
+    ignore_imports: bool,
+    ignore_signatures: bool,
+    line_enabled_callback: Union[Callable[[str, int], bool], None] = None,
+) -> List[LineSpecifs]:
+    """Return tuples of line/line number/line type with leading/trailing whitespace and any ignored code features removed.
+
+    :param lines: a collection of lines
+    :param ignore_comments: if true, any comment in the lines collection is removed from the result
+    :param ignore_docstrings: if true, any line that is a docstring is removed from the result
+    :param ignore_imports: if true, any line that is an import is removed from the result
+    :param ignore_signatures: if true, any line that is part of a function signature is removed from the result
+    :param line_enabled_callback: If called with "R0801" and a line number, a return value of False will disregard the line
+    :return: the collection of line/line number/line type tuples
+    """
+    if ignore_imports or ignore_signatures:
+        tree = astroid.parse("".join(lines))
+    if ignore_imports:
+        node_is_import_by_lineno = (
+            (node.lineno, isinstance(node, (nodes.Import, nodes.ImportFrom)))
+            for node in tree.body
+        )
+        line_begins_import = {
+            lineno: all(is_import for _, is_import in node_is_import_group)
+            for lineno, node_is_import_group in groupby(
+                node_is_import_by_lineno, key=lambda x: x[0]
+            )
+        }
+        current_line_is_import = False
+    if ignore_signatures:
+
+        def _get_functions(
+            functions: List[nodes.NodeNG], tree: nodes.NodeNG
+        ) -> List[nodes.NodeNG]:
+            """Recursively get all functions including nested in the classes from the tree."""
+
+            for node in tree.body:
+                if isinstance(node, (nodes.FunctionDef, nodes.AsyncFunctionDef)):
+                    functions.append(node)
+
+                if isinstance(
+                    node,
+                    (nodes.ClassDef, nodes.FunctionDef, nodes.AsyncFunctionDef),
+                ):
+                    _get_functions(functions, node)
+
+            return functions
+
+        functions = _get_functions([], tree)
+        signature_lines = set(
+            chain(
+                *(
+                    range(
+                        func.lineno,
+                        func.body[0].lineno if func.body else func.tolineno + 1,
+                    )
+                    for func in functions
+                )
+            )
+        )
+
+    strippedlines = []
+    docstring = None
+    for lineno, line in enumerate(lines, start=1):
+        if line_enabled_callback is not None and not line_enabled_callback(
+            "R0801", lineno
+        ):
+            continue
+        line = line.strip()
+        if ignore_docstrings:
+            if not docstring:
+                if line.startswith('"""') or line.startswith("'''"):
+                    docstring = line[:3]
+                    line = line[3:]
+                elif line.startswith('r"""') or line.startswith("r'''"):
+                    docstring = line[1:4]
+                    line = line[4:]
+            if docstring:
+                if line.endswith(docstring):
+                    docstring = None
+                line = ""
+        if ignore_imports:
+            current_line_is_import = line_begins_import.get(
+                lineno, current_line_is_import
+            )
+            if current_line_is_import:
+                line = ""
+        if ignore_comments:
+            line = line.split("#", 1)[0].strip()
+        if ignore_signatures and lineno in signature_lines:
+            line = ""
+        if line:
+            strippedlines.append(
+                LineSpecifs(text=line, line_number=LineNumber(lineno - 1))
+            )
+    return strippedlines
+
+
+@functools.total_ordering
+class LineSet:
+    """Holds and indexes all the lines of a single source file.
+
+    Allows for correspondence between real lines of the source file and stripped ones, which
+    are the real ones from which undesired patterns have been removed.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        lines: List[str],
+        ignore_comments: bool = False,
+        ignore_docstrings: bool = False,
+        ignore_imports: bool = False,
+        ignore_signatures: bool = False,
+        line_enabled_callback: Union[Callable[[str, int], bool], None] = None,
+    ) -> None:
+        self.name = name
+        self._real_lines = lines
+        self._stripped_lines = stripped_lines(
+            lines,
+            ignore_comments,
+            ignore_docstrings,
+            ignore_imports,
+            ignore_signatures,
+            line_enabled_callback=line_enabled_callback,
+        )
+
+    def __str__(self):
+        return f"<Lineset for {self.name}>"
+
+    def __len__(self):
+        return len(self._real_lines)
+
+    def __getitem__(self, index):
+        return self._stripped_lines[index]
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+    def __hash__(self):
+        return id(self)
+
+    def __eq__(self, other):
+        if not isinstance(other, LineSet):
+            return False
+        return self.__dict__ == other.__dict__
+
+    @property
+    def stripped_lines(self):
+        return self._stripped_lines
+
+    @property
+    def real_lines(self):
+        return self._real_lines
+
+
+MSGS = {
+    "R0801": (
+        "Similar lines in %s files\n%s",
+        "duplicate-code",
+        "Indicates that a set of similar lines has been detected "
+        "among multiple file. This usually means that the code should "
+        "be refactored to avoid this duplication.",
+    )
+}
+
+
+def report_similarities(
+    sect,
+    stats: LinterStats,
+    old_stats: Optional[LinterStats],
+) -> None:
+    """Make a layout with some stats about duplication."""
+    lines = ["", "now", "previous", "difference"]
+    lines += table_lines_from_stats(stats, old_stats, "duplicated_lines")
+    sect.append(Table(children=lines, cols=4, rheaders=1, cheaders=1))
+
+
+# wrapper to get a pylint checker from the similar class
+class SimilarChecker(BaseChecker, Similar, MapReduceMixin):
+    """Checks for similarities and duplicated code.
+
+    This computation may be memory / CPU intensive, so you
+    should disable it if you experiment some problems.
+    """
+
+    __implements__ = (IRawChecker,)
+    # configuration section name
+    name = "similarities"
+    # messages
+    msgs = MSGS
+    # configuration options
+    # for available dict keys/values see the optik parser 'add_option' method
+    options = (
+        (
+            "min-similarity-lines",
+            {
+                "default": DEFAULT_MIN_SIMILARITY_LINE,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "Minimum lines number of a similarity.",
+            },
+        ),
+        (
+            "ignore-comments",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Comments are removed from the similarity computation",
+            },
+        ),
+        (
+            "ignore-docstrings",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Docstrings are removed from the similarity computation",
+            },
+        ),
+        (
+            "ignore-imports",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Imports are removed from the similarity computation",
+            },
+        ),
+        (
+            "ignore-signatures",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Signatures are removed from the similarity computation",
+            },
+        ),
+    )
+    # reports
+    reports = (("RP0801", "Duplication", report_similarities),)
+
+    def __init__(self, linter=None) -> None:
+        BaseChecker.__init__(self, linter)
+        Similar.__init__(
+            self,
+            min_lines=self.config.min_similarity_lines,
+            ignore_comments=self.config.ignore_comments,
+            ignore_docstrings=self.config.ignore_docstrings,
+            ignore_imports=self.config.ignore_imports,
+            ignore_signatures=self.config.ignore_signatures,
+        )
+
+    def set_option(self, optname, value, action=None, optdict=None):
+        """Method called to set an option (registered in the options list).
+
+        Overridden to report options setting to Similar
+        """
+        BaseChecker.set_option(self, optname, value, action, optdict)
+        if optname == "min-similarity-lines":
+            self.min_lines = self.config.min_similarity_lines
+        elif optname == "ignore-comments":
+            self.ignore_comments = self.config.ignore_comments
+        elif optname == "ignore-docstrings":
+            self.ignore_docstrings = self.config.ignore_docstrings
+        elif optname == "ignore-imports":
+            self.ignore_imports = self.config.ignore_imports
+        elif optname == "ignore-signatures":
+            self.ignore_signatures = self.config.ignore_signatures
+
+    def open(self):
+        """Init the checkers: reset linesets and statistics information."""
+        self.linesets = []
+        self.linter.stats.reset_duplicated_lines()
+
+    def process_module(self, node: nodes.Module) -> None:
+        """Process a module.
+
+        the module's content is accessible via the stream object
+
+        stream must implement the readlines method
+        """
+        if self.linter.current_name is None:
+            warnings.warn(
+                (
+                    "In pylint 3.0 the current_name attribute of the linter object should be a string. "
+                    "If unknown it should be initialized as an empty string."
+                ),
+                DeprecationWarning,
+            )
+        with node.stream() as stream:
+            self.append_stream(self.linter.current_name, stream, node.file_encoding)  # type: ignore[arg-type]
+
+    def close(self):
+        """Compute and display similarities on closing (i.e. end of parsing)."""
+        total = sum(len(lineset) for lineset in self.linesets)
+        duplicated = 0
+        stats = self.linter.stats
+        for num, couples in self._compute_sims():
+            msg = []
+            lineset = start_line = end_line = None
+            for lineset, start_line, end_line in couples:
+                msg.append(f"=={lineset.name}:[{start_line}:{end_line}]")
+            msg.sort()
+
+            if lineset:
+                for line in lineset.real_lines[start_line:end_line]:
+                    msg.append(line.rstrip())
+
+            self.add_message("R0801", args=(len(couples), "\n".join(msg)))
+            duplicated += num * (len(couples) - 1)
+        stats.nb_duplicated_lines += int(duplicated)
+        stats.percent_duplicated_lines += float(total and duplicated * 100.0 / total)
+
+    def get_map_data(self):
+        """Passthru override."""
+        return Similar.get_map_data(self)
+
+    def reduce_map_data(self, linter, data):
+        """Reduces and recombines data into a format that we can report on.
+
+        The partner function of get_map_data()
+        """
+        recombined = SimilarChecker(linter)
+        recombined.min_lines = self.min_lines
+        recombined.ignore_comments = self.ignore_comments
+        recombined.ignore_docstrings = self.ignore_docstrings
+        recombined.ignore_imports = self.ignore_imports
+        recombined.ignore_signatures = self.ignore_signatures
+        recombined.open()
+        Similar.combine_mapreduce_data(recombined, linesets_collection=data)
+        recombined.close()
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(SimilarChecker(linter))
+
+
+def usage(status=0):
+    """Display command line usage information."""
+    print("finds copy pasted blocks in a set of files")
+    print()
+    print(
+        "Usage: symilar [-d|--duplicates min_duplicated_lines] \
+[-i|--ignore-comments] [--ignore-docstrings] [--ignore-imports] [--ignore-signatures] file1..."
+    )
+    sys.exit(status)
+
+
+def Run(argv=None):
+    """Standalone command line access point."""
+    if argv is None:
+        argv = sys.argv[1:]
+
+    s_opts = "hdi"
+    l_opts = (
+        "help",
+        "duplicates=",
+        "ignore-comments",
+        "ignore-imports",
+        "ignore-docstrings",
+        "ignore-signatures",
+    )
+    min_lines = DEFAULT_MIN_SIMILARITY_LINE
+    ignore_comments = False
+    ignore_docstrings = False
+    ignore_imports = False
+    ignore_signatures = False
+    opts, args = getopt(argv, s_opts, l_opts)
+    for opt, val in opts:
+        if opt in {"-d", "--duplicates"}:
+            min_lines = int(val)
+        elif opt in {"-h", "--help"}:
+            usage()
+        elif opt in {"-i", "--ignore-comments"}:
+            ignore_comments = True
+        elif opt in {"--ignore-docstrings"}:
+            ignore_docstrings = True
+        elif opt in {"--ignore-imports"}:
+            ignore_imports = True
+        elif opt in {"--ignore-signatures"}:
+            ignore_signatures = True
+    if not args:
+        usage(1)
+    sim = Similar(
+        min_lines, ignore_comments, ignore_docstrings, ignore_imports, ignore_signatures
+    )
+    for filename in args:
+        with open(filename, encoding="utf-8") as stream:
+            sim.append_stream(filename, stream)
+    sim.run()
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    Run()
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/spelling.py b/myenv/lib/python3.9/site-packages/pylint/checkers/spelling.py
new file mode 100644
index 0000000..f0c5eff
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/spelling.py
@@ -0,0 +1,448 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Checker for spelling errors in comments and docstrings."""
+import os
+import re
+import tokenize
+from typing import TYPE_CHECKING, Pattern
+
+from astroid import nodes
+
+from pylint.checkers import BaseTokenChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker, ITokenChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+try:
+    import enchant
+    from enchant.tokenize import (
+        Chunker,
+        EmailFilter,
+        Filter,
+        URLFilter,
+        WikiWordFilter,
+        get_tokenizer,
+    )
+except ImportError:
+    enchant = None
+
+    class EmailFilter:  # type: ignore[no-redef]
+        ...
+
+    class URLFilter:  # type: ignore[no-redef]
+        ...
+
+    class WikiWordFilter:  # type: ignore[no-redef]
+        ...
+
+    class Filter:  # type: ignore[no-redef]
+        def _skip(self, word):
+            raise NotImplementedError
+
+    class Chunker:  # type: ignore[no-redef]
+        pass
+
+    def get_tokenizer(
+        tag=None, chunkers=None, filters=None
+    ):  # pylint: disable=unused-argument
+        return Filter()
+
+
+if enchant is not None:
+    br = enchant.Broker()
+    dicts = br.list_dicts()
+    dict_choices = [""] + [d[0] for d in dicts]
+    dicts = [f"{d[0]} ({d[1].name})" for d in dicts]
+    dicts = ", ".join(dicts)
+    instr = ""
+else:
+    dicts = "none"
+    dict_choices = [""]
+    instr = " To make it work, install the 'python-enchant' package."
+
+
+class WordsWithDigitsFilter(Filter):
+    """Skips words with digits."""
+
+    def _skip(self, word):
+        return any(char.isdigit() for char in word)
+
+
+class WordsWithUnderscores(Filter):
+    """Skips words with underscores.
+
+    They are probably function parameter names.
+    """
+
+    def _skip(self, word):
+        return "_" in word
+
+
+class RegExFilter(Filter):
+    """Parent class for filters using regular expressions.
+
+    This filter skips any words the match the expression
+    assigned to the class attribute ``_pattern``.
+
+    """
+
+    _pattern: Pattern[str]
+
+    def _skip(self, word) -> bool:
+        return bool(self._pattern.match(word))
+
+
+class CamelCasedWord(RegExFilter):
+    r"""Filter skipping over camelCasedWords.
+    This filter skips any words matching the following regular expression:
+
+           ^([a-z]\w+[A-Z]+\w+)
+
+    That is, any words that are camelCasedWords.
+    """
+    _pattern = re.compile(r"^([a-z]+([\d]|[A-Z])(?:\w+)?)")
+
+
+class SphinxDirectives(RegExFilter):
+    r"""Filter skipping over Sphinx Directives.
+    This filter skips any words matching the following regular expression:
+
+           ^(:([a-z]+)){1,2}:`([^`]+)(`)?
+
+    That is, for example, :class:`BaseQuery`
+    """
+    # The final ` in the pattern is optional because enchant strips it out
+    _pattern = re.compile(r"^(:([a-z]+)){1,2}:`([^`]+)(`)?")
+
+
+class ForwardSlashChunker(Chunker):
+    """This chunker allows splitting words like 'before/after' into 'before' and 'after'."""
+
+    def next(self):
+        while True:
+            if not self._text:
+                raise StopIteration()
+            if "/" not in self._text:
+                text = self._text
+                self._offset = 0
+                self._text = ""
+                return (text, 0)
+            pre_text, post_text = self._text.split("/", 1)
+            self._text = post_text
+            self._offset = 0
+            if (
+                not pre_text
+                or not post_text
+                or not pre_text[-1].isalpha()
+                or not post_text[0].isalpha()
+            ):
+                self._text = ""
+                self._offset = 0
+                return (pre_text + "/" + post_text, 0)
+            return (pre_text, 0)
+
+    def _next(self):
+        while True:
+            if "/" not in self._text:
+                return (self._text, 0)
+            pre_text, post_text = self._text.split("/", 1)
+            if not pre_text or not post_text:
+                break
+            if not pre_text[-1].isalpha() or not post_text[0].isalpha():
+                raise StopIteration()
+            self._text = pre_text + " " + post_text
+        raise StopIteration()
+
+
+CODE_FLANKED_IN_BACKTICK_REGEX = re.compile(r"(\s|^)(`{1,2})([^`]+)(\2)([^`]|$)")
+
+
+def _strip_code_flanked_in_backticks(line: str) -> str:
+    """Alter line so code flanked in backticks is ignored.
+
+    Pyenchant automatically strips backticks when parsing tokens,
+    so this cannot be done at the individual filter level.
+    """
+
+    def replace_code_but_leave_surrounding_characters(match_obj) -> str:
+        return match_obj.group(1) + match_obj.group(5)
+
+    return CODE_FLANKED_IN_BACKTICK_REGEX.sub(
+        replace_code_but_leave_surrounding_characters, line
+    )
+
+
+class SpellingChecker(BaseTokenChecker):
+    """Check spelling in comments and docstrings."""
+
+    __implements__ = (ITokenChecker, IAstroidChecker)
+    name = "spelling"
+    msgs = {
+        "C0401": (
+            "Wrong spelling of a word '%s' in a comment:\n%s\n"
+            "%s\nDid you mean: '%s'?",
+            "wrong-spelling-in-comment",
+            "Used when a word in comment is not spelled correctly.",
+        ),
+        "C0402": (
+            "Wrong spelling of a word '%s' in a docstring:\n%s\n"
+            "%s\nDid you mean: '%s'?",
+            "wrong-spelling-in-docstring",
+            "Used when a word in docstring is not spelled correctly.",
+        ),
+        "C0403": (
+            "Invalid characters %r in a docstring",
+            "invalid-characters-in-docstring",
+            "Used when a word in docstring cannot be checked by enchant.",
+        ),
+    }
+    options = (
+        (
+            "spelling-dict",
+            {
+                "default": "",
+                "type": "choice",
+                "metavar": "<dict name>",
+                "choices": dict_choices,
+                "help": "Spelling dictionary name. "
+                f"Available dictionaries: {dicts}.{instr}",
+            },
+        ),
+        (
+            "spelling-ignore-words",
+            {
+                "default": "",
+                "type": "string",
+                "metavar": "<comma separated words>",
+                "help": "List of comma separated words that should not be checked.",
+            },
+        ),
+        (
+            "spelling-private-dict-file",
+            {
+                "default": "",
+                "type": "string",
+                "metavar": "<path to file>",
+                "help": "A path to a file that contains the private "
+                "dictionary; one word per line.",
+            },
+        ),
+        (
+            "spelling-store-unknown-words",
+            {
+                "default": "n",
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Tells whether to store unknown words to the "
+                "private dictionary (see the "
+                "--spelling-private-dict-file option) instead of "
+                "raising a message.",
+            },
+        ),
+        (
+            "max-spelling-suggestions",
+            {
+                "default": 4,
+                "type": "int",
+                "metavar": "N",
+                "help": "Limits count of emitted suggestions for spelling mistakes.",
+            },
+        ),
+        (
+            "spelling-ignore-comment-directives",
+            {
+                "default": "fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:",
+                "type": "string",
+                "metavar": "<comma separated words>",
+                "help": "List of comma separated words that should be considered directives if they appear and the beginning of a comment and should not be checked.",
+            },
+        ),
+    )
+
+    def open(self):
+        self.initialized = False
+        self.private_dict_file = None
+
+        if enchant is None:
+            return
+        dict_name = self.config.spelling_dict
+        if not dict_name:
+            return
+
+        self.ignore_list = [
+            w.strip() for w in self.config.spelling_ignore_words.split(",")
+        ]
+        # "param" appears in docstring in param description and
+        # "pylint" appears in comments in pylint pragmas.
+        self.ignore_list.extend(["param", "pylint"])
+
+        self.ignore_comment_directive_list = [
+            w.strip() for w in self.config.spelling_ignore_comment_directives.split(",")
+        ]
+
+        # Expand tilde to allow e.g. spelling-private-dict-file = ~/.pylintdict
+        if self.config.spelling_private_dict_file:
+            self.config.spelling_private_dict_file = os.path.expanduser(
+                self.config.spelling_private_dict_file
+            )
+
+        if self.config.spelling_private_dict_file:
+            self.spelling_dict = enchant.DictWithPWL(
+                dict_name, self.config.spelling_private_dict_file
+            )
+            self.private_dict_file = open(  # pylint: disable=consider-using-with
+                self.config.spelling_private_dict_file, "a", encoding="utf-8"
+            )
+        else:
+            self.spelling_dict = enchant.Dict(dict_name)
+
+        if self.config.spelling_store_unknown_words:
+            self.unknown_words = set()
+
+        self.tokenizer = get_tokenizer(
+            dict_name,
+            chunkers=[ForwardSlashChunker],
+            filters=[
+                EmailFilter,
+                URLFilter,
+                WikiWordFilter,
+                WordsWithDigitsFilter,
+                WordsWithUnderscores,
+                CamelCasedWord,
+                SphinxDirectives,
+            ],
+        )
+        self.initialized = True
+
+    def close(self):
+        if self.private_dict_file:
+            self.private_dict_file.close()
+
+    def _check_spelling(self, msgid, line, line_num):
+        original_line = line
+        try:
+            initial_space = re.search(r"^[^\S]\s*", line).regs[0][1]
+        except (IndexError, AttributeError):
+            initial_space = 0
+        if line.strip().startswith("#") and "docstring" not in msgid:
+            line = line.strip()[1:]
+            # A ``Filter`` cannot determine if the directive is at the beginning of a line,
+            #   nor determine if a colon is present or not (``pyenchant`` strips trailing colons).
+            #   So implementing this here.
+            for iter_directive in self.ignore_comment_directive_list:
+                if line.startswith(" " + iter_directive):
+                    line = line[(len(iter_directive) + 1) :]
+                    break
+            starts_with_comment = True
+        else:
+            starts_with_comment = False
+
+        line = _strip_code_flanked_in_backticks(line)
+
+        for word, word_start_at in self.tokenizer(line.strip()):
+            word_start_at += initial_space
+            lower_cased_word = word.casefold()
+
+            # Skip words from ignore list.
+            if word in self.ignore_list or lower_cased_word in self.ignore_list:
+                continue
+
+            # Strip starting u' from unicode literals and r' from raw strings.
+            if word.startswith(("u'", 'u"', "r'", 'r"')) and len(word) > 2:
+                word = word[2:]
+                lower_cased_word = lower_cased_word[2:]
+
+            # If it is a known word, then continue.
+            try:
+                if self.spelling_dict.check(lower_cased_word):
+                    # The lower cased version of word passed spell checking
+                    continue
+
+                # If we reached this far, it means there was a spelling mistake.
+                # Let's retry with the original work because 'unicode' is a
+                # spelling mistake but 'Unicode' is not
+                if self.spelling_dict.check(word):
+                    continue
+            except enchant.errors.Error:
+                self.add_message(
+                    "invalid-characters-in-docstring", line=line_num, args=(word,)
+                )
+                continue
+
+            # Store word to private dict or raise a message.
+            if self.config.spelling_store_unknown_words:
+                if lower_cased_word not in self.unknown_words:
+                    self.private_dict_file.write(f"{lower_cased_word}\n")
+                    self.unknown_words.add(lower_cased_word)
+            else:
+                # Present up to N suggestions.
+                suggestions = self.spelling_dict.suggest(word)
+                del suggestions[self.config.max_spelling_suggestions :]
+                line_segment = line[word_start_at:]
+                match = re.search(rf"(\W|^)({word})(\W|$)", line_segment)
+                if match:
+                    # Start position of second group in regex.
+                    col = match.regs[2][0]
+                else:
+                    col = line_segment.index(word)
+                col += word_start_at
+                if starts_with_comment:
+                    col += 1
+                indicator = (" " * col) + ("^" * len(word))
+                all_suggestion = "' or '".join(suggestions)
+                args = (word, original_line, indicator, f"'{all_suggestion}'")
+                self.add_message(msgid, line=line_num, args=args)
+
+    def process_tokens(self, tokens):
+        if not self.initialized:
+            return
+
+        # Process tokens and look for comments.
+        for (tok_type, token, (start_row, _), _, _) in tokens:
+            if tok_type == tokenize.COMMENT:
+                if start_row == 1 and token.startswith("#!/"):
+                    # Skip shebang lines
+                    continue
+                if token.startswith("# pylint:"):
+                    # Skip pylint enable/disable comments
+                    continue
+                self._check_spelling("wrong-spelling-in-comment", token, start_row)
+
+    @check_messages("wrong-spelling-in-docstring")
+    def visit_module(self, node: nodes.Module) -> None:
+        if not self.initialized:
+            return
+        self._check_docstring(node)
+
+    @check_messages("wrong-spelling-in-docstring")
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        if not self.initialized:
+            return
+        self._check_docstring(node)
+
+    @check_messages("wrong-spelling-in-docstring")
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        if not self.initialized:
+            return
+        self._check_docstring(node)
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    def _check_docstring(self, node):
+        """Check the node has any spelling errors."""
+        if not node.doc_node:
+            return
+
+        start_line = node.lineno + 1
+
+        # Go through lines of docstring
+        for idx, line in enumerate(node.doc_node.value.splitlines()):
+            self._check_spelling("wrong-spelling-in-docstring", line, start_line + idx)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(SpellingChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/stdlib.py b/myenv/lib/python3.9/site-packages/pylint/checkers/stdlib.py
new file mode 100644
index 0000000..daf9324
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/stdlib.py
@@ -0,0 +1,770 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Checkers for various standard library functions."""
+
+import sys
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
+
+import astroid
+from astroid import nodes
+
+from pylint import interfaces
+from pylint.checkers import BaseChecker, DeprecatedMixin, utils
+from pylint.interfaces import IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+OPEN_FILES_MODE = ("open", "file")
+OPEN_FILES_ENCODING = ("open", "read_text", "write_text")
+UNITTEST_CASE = "unittest.case"
+THREADING_THREAD = "threading.Thread"
+COPY_COPY = "copy.copy"
+OS_ENVIRON = "os._Environ"
+ENV_GETTERS = ("os.getenv",)
+SUBPROCESS_POPEN = "subprocess.Popen"
+SUBPROCESS_RUN = "subprocess.run"
+OPEN_MODULE = {"_io", "pathlib"}
+DEBUG_BREAKPOINTS = ("builtins.breakpoint", "sys.breakpointhook", "pdb.set_trace")
+LRU_CACHE = {
+    "functools.lru_cache",  # Inferred for @lru_cache
+    "functools._lru_cache_wrapper.wrapper",  # Inferred for @lru_cache() on >= Python 3.8
+    "functools.lru_cache.decorating_function",  # Inferred for @lru_cache() on <= Python 3.7
+}
+NON_INSTANCE_METHODS = {"builtins.staticmethod", "builtins.classmethod"}
+
+
+DEPRECATED_MODULES = {
+    (0, 0, 0): {"tkinter.tix", "fpectl"},
+    (3, 2, 0): {"optparse"},
+    (3, 3, 0): {"xml.etree.cElementTree"},
+    (3, 4, 0): {"imp"},
+    (3, 5, 0): {"formatter"},
+    (3, 6, 0): {"asynchat", "asyncore"},
+    (3, 7, 0): {"macpath"},
+    (3, 9, 0): {"lib2to3", "parser", "symbol", "binhex"},
+    (3, 10, 0): {"distutils"},
+}
+
+DEPRECATED_ARGUMENTS = {
+    (0, 0, 0): {
+        "int": ((None, "x"),),
+        "bool": ((None, "x"),),
+        "float": ((None, "x"),),
+    },
+    (3, 8, 0): {
+        "asyncio.tasks.sleep": ((None, "loop"),),
+        "asyncio.tasks.gather": ((None, "loop"),),
+        "asyncio.tasks.shield": ((None, "loop"),),
+        "asyncio.tasks.wait_for": ((None, "loop"),),
+        "asyncio.tasks.wait": ((None, "loop"),),
+        "asyncio.tasks.as_completed": ((None, "loop"),),
+        "asyncio.subprocess.create_subprocess_exec": ((None, "loop"),),
+        "asyncio.subprocess.create_subprocess_shell": ((4, "loop"),),
+        "gettext.translation": ((5, "codeset"),),
+        "gettext.install": ((2, "codeset"),),
+        "functools.partialmethod": ((None, "func"),),
+        "weakref.finalize": ((None, "func"), (None, "obj")),
+        "profile.Profile.runcall": ((None, "func"),),
+        "cProfile.Profile.runcall": ((None, "func"),),
+        "bdb.Bdb.runcall": ((None, "func"),),
+        "trace.Trace.runfunc": ((None, "func"),),
+        "curses.wrapper": ((None, "func"),),
+        "unittest.case.TestCase.addCleanup": ((None, "function"),),
+        "concurrent.futures.thread.ThreadPoolExecutor.submit": ((None, "fn"),),
+        "concurrent.futures.process.ProcessPoolExecutor.submit": ((None, "fn"),),
+        "contextlib._BaseExitStack.callback": ((None, "callback"),),
+        "contextlib.AsyncExitStack.push_async_callback": ((None, "callback"),),
+        "multiprocessing.managers.Server.create": ((None, "c"), (None, "typeid")),
+        "multiprocessing.managers.SharedMemoryServer.create": (
+            (None, "c"),
+            (None, "typeid"),
+        ),
+    },
+    (3, 9, 0): {"random.Random.shuffle": ((1, "random"),)},
+}
+
+DEPRECATED_DECORATORS = {
+    (3, 8, 0): {"asyncio.coroutine"},
+    (3, 3, 0): {
+        "abc.abstractclassmethod",
+        "abc.abstractstaticmethod",
+        "abc.abstractproperty",
+    },
+    (3, 4, 0): {"importlib.util.module_for_loader"},
+}
+
+
+DEPRECATED_METHODS: Dict = {
+    0: {
+        "cgi.parse_qs",
+        "cgi.parse_qsl",
+        "ctypes.c_buffer",
+        "distutils.command.register.register.check_metadata",
+        "distutils.command.sdist.sdist.check_metadata",
+        "tkinter.Misc.tk_menuBar",
+        "tkinter.Menu.tk_bindForTraversal",
+    },
+    2: {
+        (2, 6, 0): {
+            "commands.getstatus",
+            "os.popen2",
+            "os.popen3",
+            "os.popen4",
+            "macostools.touched",
+        },
+        (2, 7, 0): {
+            "unittest.case.TestCase.assertEquals",
+            "unittest.case.TestCase.assertNotEquals",
+            "unittest.case.TestCase.assertAlmostEquals",
+            "unittest.case.TestCase.assertNotAlmostEquals",
+            "unittest.case.TestCase.assert_",
+            "xml.etree.ElementTree.Element.getchildren",
+            "xml.etree.ElementTree.Element.getiterator",
+            "xml.etree.ElementTree.XMLParser.getiterator",
+            "xml.etree.ElementTree.XMLParser.doctype",
+        },
+    },
+    3: {
+        (3, 0, 0): {
+            "inspect.getargspec",
+            "failUnlessEqual",
+            "assertEquals",
+            "failIfEqual",
+            "assertNotEquals",
+            "failUnlessAlmostEqual",
+            "assertAlmostEquals",
+            "failIfAlmostEqual",
+            "assertNotAlmostEquals",
+            "failUnless",
+            "assert_",
+            "failUnlessRaises",
+            "failIf",
+            "assertRaisesRegexp",
+            "assertRegexpMatches",
+            "assertNotRegexpMatches",
+        },
+        (3, 1, 0): {
+            "base64.encodestring",
+            "base64.decodestring",
+            "ntpath.splitunc",
+            "os.path.splitunc",
+            "os.stat_float_times",
+        },
+        (3, 2, 0): {
+            "cgi.escape",
+            "configparser.RawConfigParser.readfp",
+            "xml.etree.ElementTree.Element.getchildren",
+            "xml.etree.ElementTree.Element.getiterator",
+            "xml.etree.ElementTree.XMLParser.getiterator",
+            "xml.etree.ElementTree.XMLParser.doctype",
+        },
+        (3, 3, 0): {
+            "inspect.getmoduleinfo",
+            "logging.warn",
+            "logging.Logger.warn",
+            "logging.LoggerAdapter.warn",
+            "nntplib._NNTPBase.xpath",
+            "platform.popen",
+            "sqlite3.OptimizedUnicode",
+            "time.clock",
+        },
+        (3, 4, 0): {
+            "importlib.find_loader",
+            "importlib.abc.Loader.load_module",
+            "importlib.abc.Loader.module_repr",
+            "importlib.abc.PathEntryFinder.find_loader",
+            "importlib.abc.PathEntryFinder.find_module",
+            "plistlib.readPlist",
+            "plistlib.writePlist",
+            "plistlib.readPlistFromBytes",
+            "plistlib.writePlistToBytes",
+        },
+        (3, 4, 4): {"asyncio.tasks.async"},
+        (3, 5, 0): {
+            "fractions.gcd",
+            "inspect.formatargspec",
+            "inspect.getcallargs",
+            "platform.linux_distribution",
+            "platform.dist",
+        },
+        (3, 6, 0): {
+            "importlib._bootstrap_external.FileLoader.load_module",
+            "_ssl.RAND_pseudo_bytes",
+        },
+        (3, 7, 0): {
+            "sys.set_coroutine_wrapper",
+            "sys.get_coroutine_wrapper",
+            "aifc.openfp",
+            "threading.Thread.isAlive",
+            "asyncio.Task.current_task",
+            "asyncio.Task.all_task",
+            "locale.format",
+            "ssl.wrap_socket",
+            "ssl.match_hostname",
+            "sunau.openfp",
+            "wave.openfp",
+        },
+        (3, 8, 0): {
+            "gettext.lgettext",
+            "gettext.ldgettext",
+            "gettext.lngettext",
+            "gettext.ldngettext",
+            "gettext.bind_textdomain_codeset",
+            "gettext.NullTranslations.output_charset",
+            "gettext.NullTranslations.set_output_charset",
+            "threading.Thread.isAlive",
+        },
+        (3, 9, 0): {
+            "binascii.b2a_hqx",
+            "binascii.a2b_hqx",
+            "binascii.rlecode_hqx",
+            "binascii.rledecode_hqx",
+        },
+        (3, 10, 0): {
+            "_sqlite3.enable_shared_cache",
+            "importlib.abc.Finder.find_module",
+            "pathlib.Path.link_to",
+            "zipimport.zipimporter.load_module",
+            "zipimport.zipimporter.find_module",
+            "zipimport.zipimporter.find_loader",
+            "threading.currentThread",
+            "threading.activeCount",
+            "threading.Condition.notifyAll",
+            "threading.Event.isSet",
+            "threading.Thread.setName",
+            "threading.Thread.getName",
+            "threading.Thread.isDaemon",
+            "threading.Thread.setDaemon",
+            "cgi.log",
+        },
+    },
+}
+
+
+DEPRECATED_CLASSES = {
+    (3, 3, 0): {
+        "importlib.abc": {
+            "Finder",
+        },
+        "pkgutil": {
+            "ImpImporter",
+            "ImpLoader",
+        },
+        "collections": {
+            "Awaitable",
+            "Coroutine",
+            "AsyncIterable",
+            "AsyncIterator",
+            "AsyncGenerator",
+            "Hashable",
+            "Iterable",
+            "Iterator",
+            "Generator",
+            "Reversible",
+            "Sized",
+            "Container",
+            "Callable",
+            "Collection",
+            "Set",
+            "MutableSet",
+            "Mapping",
+            "MutableMapping",
+            "MappingView",
+            "KeysView",
+            "ItemsView",
+            "ValuesView",
+            "Sequence",
+            "MutableSequence",
+            "ByteString",
+        },
+    },
+    (3, 9, 0): {
+        "smtpd": {
+            "MailmanProxy",
+        }
+    },
+}
+
+
+def _check_mode_str(mode):
+    # check type
+    if not isinstance(mode, str):
+        return False
+    # check syntax
+    modes = set(mode)
+    _mode = "rwatb+Ux"
+    creating = "x" in modes
+    if modes - set(_mode) or len(mode) > len(modes):
+        return False
+    # check logic
+    reading = "r" in modes
+    writing = "w" in modes
+    appending = "a" in modes
+    text = "t" in modes
+    binary = "b" in modes
+    if "U" in modes:
+        if writing or appending or creating:
+            return False
+        reading = True
+    if text and binary:
+        return False
+    total = reading + writing + appending + creating
+    if total > 1:
+        return False
+    if not (reading or writing or appending or creating):
+        return False
+    return True
+
+
+class StdlibChecker(DeprecatedMixin, BaseChecker):
+    __implements__ = (IAstroidChecker,)
+    name = "stdlib"
+
+    msgs = {
+        "W1501": (
+            '"%s" is not a valid mode for open.',
+            "bad-open-mode",
+            "Python supports: r, w, a[, x] modes with b, +, "
+            "and U (only with r) options. "
+            "See https://docs.python.org/3/library/functions.html#open",
+        ),
+        "W1502": (
+            "Using datetime.time in a boolean context.",
+            "boolean-datetime",
+            "Using datetime.time in a boolean context can hide "
+            "subtle bugs when the time they represent matches "
+            "midnight UTC. This behaviour was fixed in Python 3.5. "
+            "See https://bugs.python.org/issue13936 for reference.",
+            {"maxversion": (3, 5)},
+        ),
+        "W1503": (
+            "Redundant use of %s with constant value %r",
+            "redundant-unittest-assert",
+            "The first argument of assertTrue and assertFalse is "
+            "a condition. If a constant is passed as parameter, that "
+            "condition will be always true. In this case a warning "
+            "should be emitted.",
+        ),
+        "W1505": (
+            "Using deprecated method %s()",
+            "deprecated-method",
+            "The method is marked as deprecated and will be removed in "
+            "a future version of Python. Consider looking for an "
+            "alternative in the documentation.",
+        ),
+        "W1506": (
+            "threading.Thread needs the target function",
+            "bad-thread-instantiation",
+            "The warning is emitted when a threading.Thread class "
+            "is instantiated without the target function being passed. "
+            "By default, the first parameter is the group param, not the target param.",
+        ),
+        "W1507": (
+            "Using copy.copy(os.environ). Use os.environ.copy() instead. ",
+            "shallow-copy-environ",
+            "os.environ is not a dict object but proxy object, so "
+            "shallow copy has still effects on original object. "
+            "See https://bugs.python.org/issue15373 for reference.",
+        ),
+        "E1507": (
+            "%s does not support %s type argument",
+            "invalid-envvar-value",
+            "Env manipulation functions support only string type arguments. "
+            "See https://docs.python.org/3/library/os.html#os.getenv.",
+        ),
+        "W1508": (
+            "%s default type is %s. Expected str or None.",
+            "invalid-envvar-default",
+            "Env manipulation functions return None or str values. "
+            "Supplying anything different as a default may cause bugs. "
+            "See https://docs.python.org/3/library/os.html#os.getenv.",
+        ),
+        "W1509": (
+            "Using preexec_fn keyword which may be unsafe in the presence "
+            "of threads",
+            "subprocess-popen-preexec-fn",
+            "The preexec_fn parameter is not safe to use in the presence "
+            "of threads in your application. The child process could "
+            "deadlock before exec is called. If you must use it, keep it "
+            "trivial! Minimize the number of libraries you call into."
+            "https://docs.python.org/3/library/subprocess.html#popen-constructor",
+        ),
+        "W1510": (
+            "Using subprocess.run without explicitly set `check` is not recommended.",
+            "subprocess-run-check",
+            "The check parameter should always be used with explicitly set "
+            "`check` keyword to make clear what the error-handling behavior is."
+            "https://docs.python.org/3/library/subprocess.html#subprocess.run",
+        ),
+        "W1511": (
+            "Using deprecated argument %s of method %s()",
+            "deprecated-argument",
+            "The argument is marked as deprecated and will be removed in the future.",
+        ),
+        "W1512": (
+            "Using deprecated class %s of module %s",
+            "deprecated-class",
+            "The class is marked as deprecated and will be removed in the future.",
+        ),
+        "W1513": (
+            "Using deprecated decorator %s()",
+            "deprecated-decorator",
+            "The decorator is marked as deprecated and will be removed in the future.",
+        ),
+        "W1514": (
+            "Using open without explicitly specifying an encoding",
+            "unspecified-encoding",
+            "It is better to specify an encoding when opening documents. "
+            "Using the system default implicitly can create problems on other operating systems. "
+            "See https://www.python.org/dev/peps/pep-0597/",
+        ),
+        "W1515": (
+            "Leaving functions creating breakpoints in production code is not recommended",
+            "forgotten-debug-statement",
+            "Calls to breakpoint(), sys.breakpointhook() and pdb.set_trace() should be removed "
+            "from code that is not actively being debugged.",
+        ),
+        "W1517": (
+            "'lru_cache(maxsize=None)' will keep all method args alive indefinitely, including 'self'",
+            "cache-max-size-none",
+            "By decorating a method with lru_cache the 'self' argument will be linked to "
+            "the lru_cache function and therefore never garbage collected. Unless your instance "
+            "will never need to be garbage collected (singleton) it is recommended to refactor "
+            "code to avoid this pattern or add a maxsize to the cache."
+            "The default value for maxsize is 128.",
+            {"old_names": [("W1516", "lru-cache-decorating-method")]},
+        ),
+    }
+
+    def __init__(self, linter: Optional["PyLinter"] = None) -> None:
+        BaseChecker.__init__(self, linter)
+        self._deprecated_methods: Set[str] = set()
+        self._deprecated_arguments: Dict[
+            str, Tuple[Tuple[Optional[int], str], ...]
+        ] = {}
+        self._deprecated_classes: Dict[str, Set[str]] = {}
+        self._deprecated_modules: Set[str] = set()
+        self._deprecated_decorators: Set[str] = set()
+
+        for since_vers, func_list in DEPRECATED_METHODS[sys.version_info[0]].items():
+            if since_vers <= sys.version_info:
+                self._deprecated_methods.update(func_list)
+        for since_vers, func_list in DEPRECATED_ARGUMENTS.items():
+            if since_vers <= sys.version_info:
+                self._deprecated_arguments.update(func_list)
+        for since_vers, class_list in DEPRECATED_CLASSES.items():
+            if since_vers <= sys.version_info:
+                self._deprecated_classes.update(class_list)
+        for since_vers, mod_list in DEPRECATED_MODULES.items():
+            if since_vers <= sys.version_info:
+                self._deprecated_modules.update(mod_list)
+        for since_vers, decorator_list in DEPRECATED_DECORATORS.items():
+            if since_vers <= sys.version_info:
+                self._deprecated_decorators.update(decorator_list)
+
+    def _check_bad_thread_instantiation(self, node):
+        if not node.kwargs and not node.keywords and len(node.args) <= 1:
+            self.add_message("bad-thread-instantiation", node=node)
+
+    def _check_for_preexec_fn_in_popen(self, node):
+        if node.keywords:
+            for keyword in node.keywords:
+                if keyword.arg == "preexec_fn":
+                    self.add_message("subprocess-popen-preexec-fn", node=node)
+
+    def _check_for_check_kw_in_run(self, node):
+        kwargs = {keyword.arg for keyword in (node.keywords or ())}
+        if "check" not in kwargs:
+            self.add_message("subprocess-run-check", node=node)
+
+    def _check_shallow_copy_environ(self, node: nodes.Call) -> None:
+        arg = utils.get_argument_from_call(node, position=0)
+        try:
+            inferred_args = arg.inferred()
+        except astroid.InferenceError:
+            return
+        for inferred in inferred_args:
+            if inferred.qname() == OS_ENVIRON:
+                self.add_message("shallow-copy-environ", node=node)
+                break
+
+    @utils.check_messages(
+        "bad-open-mode",
+        "redundant-unittest-assert",
+        "deprecated-method",
+        "deprecated-argument",
+        "bad-thread-instantiation",
+        "shallow-copy-environ",
+        "invalid-envvar-value",
+        "invalid-envvar-default",
+        "subprocess-popen-preexec-fn",
+        "subprocess-run-check",
+        "deprecated-class",
+        "unspecified-encoding",
+        "forgotten-debug-statement",
+    )
+    def visit_call(self, node: nodes.Call) -> None:
+        """Visit a Call node."""
+        self.check_deprecated_class_in_call(node)
+        for inferred in utils.infer_all(node.func):
+            if inferred is astroid.Uninferable:
+                continue
+            if inferred.root().name in OPEN_MODULE:
+                if (
+                    isinstance(node.func, nodes.Name)
+                    and node.func.name in OPEN_FILES_MODE
+                ):
+                    self._check_open_mode(node)
+                if (
+                    isinstance(node.func, nodes.Name)
+                    and node.func.name in OPEN_FILES_ENCODING
+                    or isinstance(node.func, nodes.Attribute)
+                    and node.func.attrname in OPEN_FILES_ENCODING
+                ):
+                    self._check_open_encoded(node, inferred.root().name)
+            elif inferred.root().name == UNITTEST_CASE:
+                self._check_redundant_assert(node, inferred)
+            elif isinstance(inferred, nodes.ClassDef):
+                if inferred.qname() == THREADING_THREAD:
+                    self._check_bad_thread_instantiation(node)
+                elif inferred.qname() == SUBPROCESS_POPEN:
+                    self._check_for_preexec_fn_in_popen(node)
+            elif isinstance(inferred, nodes.FunctionDef):
+                name = inferred.qname()
+                if name == COPY_COPY:
+                    self._check_shallow_copy_environ(node)
+                elif name in ENV_GETTERS:
+                    self._check_env_function(node, inferred)
+                elif name == SUBPROCESS_RUN:
+                    self._check_for_check_kw_in_run(node)
+                elif name in DEBUG_BREAKPOINTS:
+                    self.add_message("forgotten-debug-statement", node=node)
+            self.check_deprecated_method(node, inferred)
+
+    @utils.check_messages("boolean-datetime")
+    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
+        if node.op == "not":
+            self._check_datetime(node.operand)
+
+    @utils.check_messages("boolean-datetime")
+    def visit_if(self, node: nodes.If) -> None:
+        self._check_datetime(node.test)
+
+    @utils.check_messages("boolean-datetime")
+    def visit_ifexp(self, node: nodes.IfExp) -> None:
+        self._check_datetime(node.test)
+
+    @utils.check_messages("boolean-datetime")
+    def visit_boolop(self, node: nodes.BoolOp) -> None:
+        for value in node.values:
+            self._check_datetime(value)
+
+    @utils.check_messages("cache-max-size-none")
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        if node.decorators and isinstance(node.parent, nodes.ClassDef):
+            self._check_lru_cache_decorators(node.decorators)
+
+    def _check_lru_cache_decorators(self, decorators: nodes.Decorators) -> None:
+        """Check if instance methods are decorated with functools.lru_cache."""
+        lru_cache_nodes: List[nodes.NodeNG] = []
+        for d_node in decorators.nodes:
+            try:
+                for infered_node in d_node.infer():
+                    q_name = infered_node.qname()
+                    if q_name in NON_INSTANCE_METHODS or q_name not in LRU_CACHE:
+                        return
+
+                    # Check if there is a maxsize argument set to None in the call
+                    if isinstance(d_node, nodes.Call):
+                        try:
+                            arg = utils.get_argument_from_call(
+                                d_node, position=0, keyword="maxsize"
+                            )
+                        except utils.NoSuchArgumentError:
+                            return
+
+                        if not isinstance(arg, nodes.Const) or arg.value is not None:
+                            return
+
+                    lru_cache_nodes.append(d_node)
+                    break
+            except astroid.InferenceError:
+                pass
+        for lru_cache_node in lru_cache_nodes:
+            self.add_message(
+                "cache-max-size-none",
+                node=lru_cache_node,
+                confidence=interfaces.INFERENCE,
+            )
+
+    def _check_redundant_assert(self, node, infer):
+        if (
+            isinstance(infer, astroid.BoundMethod)
+            and node.args
+            and isinstance(node.args[0], nodes.Const)
+            and infer.name in {"assertTrue", "assertFalse"}
+        ):
+            self.add_message(
+                "redundant-unittest-assert",
+                args=(infer.name, node.args[0].value),
+                node=node,
+            )
+
+    def _check_datetime(self, node):
+        """Check that a datetime was inferred, if so, emit boolean-datetime warning."""
+        try:
+            inferred = next(node.infer())
+        except astroid.InferenceError:
+            return
+        if (
+            isinstance(inferred, astroid.Instance)
+            and inferred.qname() == "datetime.time"
+        ):
+            self.add_message("boolean-datetime", node=node)
+
+    def _check_open_mode(self, node):
+        """Check that the mode argument of an open or file call is valid."""
+        try:
+            mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
+        except utils.NoSuchArgumentError:
+            return
+        if mode_arg:
+            mode_arg = utils.safe_infer(mode_arg)
+            if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
+                mode_arg.value
+            ):
+                self.add_message(
+                    "bad-open-mode",
+                    node=node,
+                    args=mode_arg.value or str(mode_arg.value),
+                )
+
+    def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
+        """Check that the encoded argument of an open call is valid."""
+        mode_arg = None
+        try:
+            if open_module == "_io":
+                mode_arg = utils.get_argument_from_call(
+                    node, position=1, keyword="mode"
+                )
+            elif open_module == "pathlib":
+                mode_arg = utils.get_argument_from_call(
+                    node, position=0, keyword="mode"
+                )
+        except utils.NoSuchArgumentError:
+            pass
+
+        if mode_arg:
+            mode_arg = utils.safe_infer(mode_arg)
+
+        if (
+            not mode_arg
+            or isinstance(mode_arg, nodes.Const)
+            and (not mode_arg.value or "b" not in str(mode_arg.value))
+        ):
+            encoding_arg = None
+            try:
+                if open_module == "pathlib":
+                    if node.func.attrname == "read_text":
+                        encoding_arg = utils.get_argument_from_call(
+                            node, position=0, keyword="encoding"
+                        )
+                    elif node.func.attrname == "write_text":
+                        encoding_arg = utils.get_argument_from_call(
+                            node, position=1, keyword="encoding"
+                        )
+                    else:
+                        encoding_arg = utils.get_argument_from_call(
+                            node, position=2, keyword="encoding"
+                        )
+                else:
+                    encoding_arg = utils.get_argument_from_call(
+                        node, position=3, keyword="encoding"
+                    )
+            except utils.NoSuchArgumentError:
+                self.add_message("unspecified-encoding", node=node)
+
+            if encoding_arg:
+                encoding_arg = utils.safe_infer(encoding_arg)
+
+                if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
+                    self.add_message("unspecified-encoding", node=node)
+
+    def _check_env_function(self, node, infer):
+        env_name_kwarg = "key"
+        env_value_kwarg = "default"
+        if node.keywords:
+            kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
+        else:
+            kwargs = None
+        if node.args:
+            env_name_arg = node.args[0]
+        elif kwargs and env_name_kwarg in kwargs:
+            env_name_arg = kwargs[env_name_kwarg]
+        else:
+            env_name_arg = None
+
+        if env_name_arg:
+            self._check_invalid_envvar_value(
+                node=node,
+                message="invalid-envvar-value",
+                call_arg=utils.safe_infer(env_name_arg),
+                infer=infer,
+                allow_none=False,
+            )
+
+        if len(node.args) == 2:
+            env_value_arg = node.args[1]
+        elif kwargs and env_value_kwarg in kwargs:
+            env_value_arg = kwargs[env_value_kwarg]
+        else:
+            env_value_arg = None
+
+        if env_value_arg:
+            self._check_invalid_envvar_value(
+                node=node,
+                infer=infer,
+                message="invalid-envvar-default",
+                call_arg=utils.safe_infer(env_value_arg),
+                allow_none=True,
+            )
+
+    def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
+        if call_arg in (astroid.Uninferable, None):
+            return
+
+        name = infer.qname()
+        if isinstance(call_arg, nodes.Const):
+            emit = False
+            if call_arg.value is None:
+                emit = not allow_none
+            elif not isinstance(call_arg.value, str):
+                emit = True
+            if emit:
+                self.add_message(message, node=node, args=(name, call_arg.pytype()))
+        else:
+            self.add_message(message, node=node, args=(name, call_arg.pytype()))
+
+    def deprecated_modules(self):
+        """Callback returning the deprecated modules."""
+        return self._deprecated_modules
+
+    def deprecated_methods(self):
+        return self._deprecated_methods
+
+    def deprecated_arguments(self, method: str):
+        return self._deprecated_arguments.get(method, ())
+
+    def deprecated_classes(self, module: str):
+        return self._deprecated_classes.get(module, ())
+
+    def deprecated_decorators(self) -> Iterable:
+        return self._deprecated_decorators
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(StdlibChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/strings.py b/myenv/lib/python3.9/site-packages/pylint/checkers/strings.py
new file mode 100644
index 0000000..dd9f188
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/strings.py
@@ -0,0 +1,980 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Checker for string formatting operations."""
+
+import collections
+import numbers
+import re
+import tokenize
+from typing import TYPE_CHECKING, Counter, Iterable
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker, BaseTokenChecker, utils
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker, IRawChecker, ITokenChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+_AST_NODE_STR_TYPES = ("__builtin__.unicode", "__builtin__.str", "builtins.str")
+# Prefixes for both strings and bytes literals per
+# https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals
+_PREFIXES = {
+    "r",
+    "u",
+    "R",
+    "U",
+    "f",
+    "F",
+    "fr",
+    "Fr",
+    "fR",
+    "FR",
+    "rf",
+    "rF",
+    "Rf",
+    "RF",
+    "b",
+    "B",
+    "br",
+    "Br",
+    "bR",
+    "BR",
+    "rb",
+    "rB",
+    "Rb",
+    "RB",
+}
+SINGLE_QUOTED_REGEX = re.compile(f"({'|'.join(_PREFIXES)})?'''")
+DOUBLE_QUOTED_REGEX = re.compile(f"({'|'.join(_PREFIXES)})?\"\"\"")
+QUOTE_DELIMITER_REGEX = re.compile(f"({'|'.join(_PREFIXES)})?(\"|')", re.DOTALL)
+
+MSGS = {  # pylint: disable=consider-using-namedtuple-or-dataclass
+    "E1300": (
+        "Unsupported format character %r (%#02x) at index %d",
+        "bad-format-character",
+        "Used when an unsupported format character is used in a format string.",
+    ),
+    "E1301": (
+        "Format string ends in middle of conversion specifier",
+        "truncated-format-string",
+        "Used when a format string terminates before the end of a "
+        "conversion specifier.",
+    ),
+    "E1302": (
+        "Mixing named and unnamed conversion specifiers in format string",
+        "mixed-format-string",
+        "Used when a format string contains both named (e.g. '%(foo)d') "
+        "and unnamed (e.g. '%d') conversion specifiers.  This is also "
+        "used when a named conversion specifier contains * for the "
+        "minimum field width and/or precision.",
+    ),
+    "E1303": (
+        "Expected mapping for format string, not %s",
+        "format-needs-mapping",
+        "Used when a format string that uses named conversion specifiers "
+        "is used with an argument that is not a mapping.",
+    ),
+    "W1300": (
+        "Format string dictionary key should be a string, not %s",
+        "bad-format-string-key",
+        "Used when a format string that uses named conversion specifiers "
+        "is used with a dictionary whose keys are not all strings.",
+    ),
+    "W1301": (
+        "Unused key %r in format string dictionary",
+        "unused-format-string-key",
+        "Used when a format string that uses named conversion specifiers "
+        "is used with a dictionary that contains keys not required by the "
+        "format string.",
+    ),
+    "E1304": (
+        "Missing key %r in format string dictionary",
+        "missing-format-string-key",
+        "Used when a format string that uses named conversion specifiers "
+        "is used with a dictionary that doesn't contain all the keys "
+        "required by the format string.",
+    ),
+    "E1305": (
+        "Too many arguments for format string",
+        "too-many-format-args",
+        "Used when a format string that uses unnamed conversion "
+        "specifiers is given too many arguments.",
+    ),
+    "E1306": (
+        "Not enough arguments for format string",
+        "too-few-format-args",
+        "Used when a format string that uses unnamed conversion "
+        "specifiers is given too few arguments",
+    ),
+    "E1307": (
+        "Argument %r does not match format type %r",
+        "bad-string-format-type",
+        "Used when a type required by format string "
+        "is not suitable for actual argument type",
+    ),
+    "E1310": (
+        "Suspicious argument in %s.%s call",
+        "bad-str-strip-call",
+        "The argument to a str.{l,r,}strip call contains a duplicate character,",
+    ),
+    "W1302": (
+        "Invalid format string",
+        "bad-format-string",
+        "Used when a PEP 3101 format string is invalid.",
+    ),
+    "W1303": (
+        "Missing keyword argument %r for format string",
+        "missing-format-argument-key",
+        "Used when a PEP 3101 format string that uses named fields "
+        "doesn't receive one or more required keywords.",
+    ),
+    "W1304": (
+        "Unused format argument %r",
+        "unused-format-string-argument",
+        "Used when a PEP 3101 format string that uses named "
+        "fields is used with an argument that "
+        "is not required by the format string.",
+    ),
+    "W1305": (
+        "Format string contains both automatic field numbering "
+        "and manual field specification",
+        "format-combined-specification",
+        "Used when a PEP 3101 format string contains both automatic "
+        "field numbering (e.g. '{}') and manual field "
+        "specification (e.g. '{0}').",
+    ),
+    "W1306": (
+        "Missing format attribute %r in format specifier %r",
+        "missing-format-attribute",
+        "Used when a PEP 3101 format string uses an "
+        "attribute specifier ({0.length}), but the argument "
+        "passed for formatting doesn't have that attribute.",
+    ),
+    "W1307": (
+        "Using invalid lookup key %r in format specifier %r",
+        "invalid-format-index",
+        "Used when a PEP 3101 format string uses a lookup specifier "
+        "({a[1]}), but the argument passed for formatting "
+        "doesn't contain or doesn't have that key as an attribute.",
+    ),
+    "W1308": (
+        "Duplicate string formatting argument %r, consider passing as named argument",
+        "duplicate-string-formatting-argument",
+        "Used when we detect that a string formatting is "
+        "repeating an argument instead of using named string arguments",
+    ),
+    "W1309": (
+        "Using an f-string that does not have any interpolated variables",
+        "f-string-without-interpolation",
+        "Used when we detect an f-string that does not use any interpolation variables, "
+        "in which case it can be either a normal string or a bug in the code.",
+    ),
+    "W1310": (
+        "Using formatting for a string that does not have any interpolated variables",
+        "format-string-without-interpolation",
+        "Used when we detect a string that does not have any interpolation variables, "
+        "in which case it can be either a normal string without formatting or a bug in the code.",
+    ),
+}
+
+OTHER_NODES = (
+    nodes.Const,
+    nodes.List,
+    nodes.Lambda,
+    nodes.FunctionDef,
+    nodes.ListComp,
+    nodes.SetComp,
+    nodes.GeneratorExp,
+)
+
+
+def get_access_path(key, parts):
+    """Given a list of format specifiers, returns
+    the final access path (e.g. a.b.c[0][1]).
+    """
+    path = []
+    for is_attribute, specifier in parts:
+        if is_attribute:
+            path.append(f".{specifier}")
+        else:
+            path.append(f"[{specifier!r}]")
+    return str(key) + "".join(path)
+
+
+def arg_matches_format_type(arg_type, format_type):
+    if format_type in "sr":
+        # All types can be printed with %s and %r
+        return True
+    if isinstance(arg_type, astroid.Instance):
+        arg_type = arg_type.pytype()
+        if arg_type == "builtins.str":
+            return format_type == "c"
+        if arg_type == "builtins.float":
+            return format_type in "deEfFgGn%"
+        if arg_type == "builtins.int":
+            # Integers allow all types
+            return True
+        return False
+    return True
+
+
+class StringFormatChecker(BaseChecker):
+    """Checks string formatting operations to ensure that the format string
+    is valid and the arguments match the format string.
+    """
+
+    __implements__ = (IAstroidChecker,)
+    name = "string"
+    msgs = MSGS
+
+    # pylint: disable=too-many-branches
+    @check_messages(
+        "bad-format-character",
+        "truncated-format-string",
+        "mixed-format-string",
+        "bad-format-string-key",
+        "missing-format-string-key",
+        "unused-format-string-key",
+        "bad-string-format-type",
+        "format-needs-mapping",
+        "too-many-format-args",
+        "too-few-format-args",
+        "bad-string-format-type",
+        "format-string-without-interpolation",
+    )
+    def visit_binop(self, node: nodes.BinOp) -> None:
+        if node.op != "%":
+            return
+        left = node.left
+        args = node.right
+
+        if not (isinstance(left, nodes.Const) and isinstance(left.value, str)):
+            return
+        format_string = left.value
+        try:
+            (
+                required_keys,
+                required_num_args,
+                required_key_types,
+                required_arg_types,
+            ) = utils.parse_format_string(format_string)
+        except utils.UnsupportedFormatCharacter as exc:
+            formatted = format_string[exc.index]
+            self.add_message(
+                "bad-format-character",
+                node=node,
+                args=(formatted, ord(formatted), exc.index),
+            )
+            return
+        except utils.IncompleteFormatString:
+            self.add_message("truncated-format-string", node=node)
+            return
+        if not required_keys and not required_num_args:
+            self.add_message("format-string-without-interpolation", node=node)
+            return
+        if required_keys and required_num_args:
+            # The format string uses both named and unnamed format
+            # specifiers.
+            self.add_message("mixed-format-string", node=node)
+        elif required_keys:
+            # The format string uses only named format specifiers.
+            # Check that the RHS of the % operator is a mapping object
+            # that contains precisely the set of keys required by the
+            # format string.
+            if isinstance(args, nodes.Dict):
+                keys = set()
+                unknown_keys = False
+                for k, _ in args.items:
+                    if isinstance(k, nodes.Const):
+                        key = k.value
+                        if isinstance(key, str):
+                            keys.add(key)
+                        else:
+                            self.add_message(
+                                "bad-format-string-key", node=node, args=key
+                            )
+                    else:
+                        # One of the keys was something other than a
+                        # constant.  Since we can't tell what it is,
+                        # suppress checks for missing keys in the
+                        # dictionary.
+                        unknown_keys = True
+                if not unknown_keys:
+                    for key in required_keys:
+                        if key not in keys:
+                            self.add_message(
+                                "missing-format-string-key", node=node, args=key
+                            )
+                for key in keys:
+                    if key not in required_keys:
+                        self.add_message(
+                            "unused-format-string-key", node=node, args=key
+                        )
+                for key, arg in args.items:
+                    if not isinstance(key, nodes.Const):
+                        continue
+                    format_type = required_key_types.get(key.value, None)
+                    arg_type = utils.safe_infer(arg)
+                    if (
+                        format_type is not None
+                        and arg_type
+                        and arg_type != astroid.Uninferable
+                        and not arg_matches_format_type(arg_type, format_type)
+                    ):
+                        self.add_message(
+                            "bad-string-format-type",
+                            node=node,
+                            args=(arg_type.pytype(), format_type),
+                        )
+            elif isinstance(args, (OTHER_NODES, nodes.Tuple)):
+                type_name = type(args).__name__
+                self.add_message("format-needs-mapping", node=node, args=type_name)
+            # else:
+            # The RHS of the format specifier is a name or
+            # expression.  It may be a mapping object, so
+            # there's nothing we can check.
+        else:
+            # The format string uses only unnamed format specifiers.
+            # Check that the number of arguments passed to the RHS of
+            # the % operator matches the number required by the format
+            # string.
+            args_elts = []
+            if isinstance(args, nodes.Tuple):
+                rhs_tuple = utils.safe_infer(args)
+                num_args = None
+                if isinstance(rhs_tuple, nodes.BaseContainer):
+                    args_elts = rhs_tuple.elts
+                    num_args = len(args_elts)
+            elif isinstance(args, (OTHER_NODES, (nodes.Dict, nodes.DictComp))):
+                args_elts = [args]
+                num_args = 1
+            else:
+                # The RHS of the format specifier is a name or
+                # expression.  It could be a tuple of unknown size, so
+                # there's nothing we can check.
+                num_args = None
+            if num_args is not None:
+                if num_args > required_num_args:
+                    self.add_message("too-many-format-args", node=node)
+                elif num_args < required_num_args:
+                    self.add_message("too-few-format-args", node=node)
+                for arg, format_type in zip(args_elts, required_arg_types):
+                    if not arg:
+                        continue
+                    arg_type = utils.safe_infer(arg)
+                    if (
+                        arg_type
+                        and arg_type != astroid.Uninferable
+                        and not arg_matches_format_type(arg_type, format_type)
+                    ):
+                        self.add_message(
+                            "bad-string-format-type",
+                            node=node,
+                            args=(arg_type.pytype(), format_type),
+                        )
+
+    @check_messages("f-string-without-interpolation")
+    def visit_joinedstr(self, node: nodes.JoinedStr) -> None:
+        self._check_interpolation(node)
+
+    def _check_interpolation(self, node: nodes.JoinedStr) -> None:
+        if isinstance(node.parent, nodes.FormattedValue):
+            return
+        for value in node.values:
+            if isinstance(value, nodes.FormattedValue):
+                return
+        self.add_message("f-string-without-interpolation", node=node)
+
+    @check_messages(*MSGS)
+    def visit_call(self, node: nodes.Call) -> None:
+        func = utils.safe_infer(node.func)
+        if (
+            isinstance(func, astroid.BoundMethod)
+            and isinstance(func.bound, astroid.Instance)
+            and func.bound.name in {"str", "unicode", "bytes"}
+        ):
+            if func.name in {"strip", "lstrip", "rstrip"} and node.args:
+                arg = utils.safe_infer(node.args[0])
+                if not isinstance(arg, nodes.Const) or not isinstance(arg.value, str):
+                    return
+                if len(arg.value) != len(set(arg.value)):
+                    self.add_message(
+                        "bad-str-strip-call",
+                        node=node,
+                        args=(func.bound.name, func.name),
+                    )
+            elif func.name == "format":
+                self._check_new_format(node, func)
+
+    def _detect_vacuous_formatting(self, node, positional_arguments):
+        counter = collections.Counter(
+            arg.name for arg in positional_arguments if isinstance(arg, nodes.Name)
+        )
+        for name, count in counter.items():
+            if count == 1:
+                continue
+            self.add_message(
+                "duplicate-string-formatting-argument", node=node, args=(name,)
+            )
+
+    def _check_new_format(self, node, func):
+        """Check the new string formatting."""
+        # Skip format nodes which don't have an explicit string on the
+        # left side of the format operation.
+        # We do this because our inference engine can't properly handle
+        # redefinitions of the original string.
+        # Note that there may not be any left side at all, if the format method
+        # has been assigned to another variable. See issue 351. For example:
+        #
+        #    fmt = 'some string {}'.format
+        #    fmt('arg')
+        if isinstance(node.func, nodes.Attribute) and not isinstance(
+            node.func.expr, nodes.Const
+        ):
+            return
+        if node.starargs or node.kwargs:
+            return
+        try:
+            strnode = next(func.bound.infer())
+        except astroid.InferenceError:
+            return
+        if not (isinstance(strnode, nodes.Const) and isinstance(strnode.value, str)):
+            return
+        try:
+            call_site = astroid.arguments.CallSite.from_call(node)
+        except astroid.InferenceError:
+            return
+
+        try:
+            fields, num_args, manual_pos = utils.parse_format_method_string(
+                strnode.value
+            )
+        except utils.IncompleteFormatString:
+            self.add_message("bad-format-string", node=node)
+            return
+
+        positional_arguments = call_site.positional_arguments
+        named_arguments = call_site.keyword_arguments
+        named_fields = {field[0] for field in fields if isinstance(field[0], str)}
+        if num_args and manual_pos:
+            self.add_message("format-combined-specification", node=node)
+            return
+
+        check_args = False
+        # Consider "{[0]} {[1]}" as num_args.
+        num_args += sum(1 for field in named_fields if field == "")
+        if named_fields:
+            for field in named_fields:
+                if field and field not in named_arguments:
+                    self.add_message(
+                        "missing-format-argument-key", node=node, args=(field,)
+                    )
+            for field in named_arguments:
+                if field not in named_fields:
+                    self.add_message(
+                        "unused-format-string-argument", node=node, args=(field,)
+                    )
+            # num_args can be 0 if manual_pos is not.
+            num_args = num_args or manual_pos
+            if positional_arguments or num_args:
+                empty = any(field == "" for field in named_fields)
+                if named_arguments or empty:
+                    # Verify the required number of positional arguments
+                    # only if the .format got at least one keyword argument.
+                    # This means that the format strings accepts both
+                    # positional and named fields and we should warn
+                    # when one of them is missing or is extra.
+                    check_args = True
+        else:
+            check_args = True
+        if check_args:
+            # num_args can be 0 if manual_pos is not.
+            num_args = num_args or manual_pos
+            if not num_args:
+                self.add_message("format-string-without-interpolation", node=node)
+                return
+            if len(positional_arguments) > num_args:
+                self.add_message("too-many-format-args", node=node)
+            elif len(positional_arguments) < num_args:
+                self.add_message("too-few-format-args", node=node)
+
+        self._detect_vacuous_formatting(node, positional_arguments)
+        self._check_new_format_specifiers(node, fields, named_arguments)
+
+    def _check_new_format_specifiers(self, node, fields, named):
+        """Check attribute and index access in the format
+        string ("{0.a}" and "{0[a]}").
+        """
+        for key, specifiers in fields:
+            # Obtain the argument. If it can't be obtained
+            # or inferred, skip this check.
+            if key == "":
+                # {[0]} will have an unnamed argument, defaulting
+                # to 0. It will not be present in `named`, so use the value
+                # 0 for it.
+                key = 0
+            if isinstance(key, numbers.Number):
+                try:
+                    argname = utils.get_argument_from_call(node, key)
+                except utils.NoSuchArgumentError:
+                    continue
+            else:
+                if key not in named:
+                    continue
+                argname = named[key]
+            if argname in (astroid.Uninferable, None):
+                continue
+            try:
+                argument = utils.safe_infer(argname)
+            except astroid.InferenceError:
+                continue
+            if not specifiers or not argument:
+                # No need to check this key if it doesn't
+                # use attribute / item access
+                continue
+            if argument.parent and isinstance(argument.parent, nodes.Arguments):
+                # Ignore any object coming from an argument,
+                # because we can't infer its value properly.
+                continue
+            previous = argument
+            parsed = []
+            for is_attribute, specifier in specifiers:
+                if previous is astroid.Uninferable:
+                    break
+                parsed.append((is_attribute, specifier))
+                if is_attribute:
+                    try:
+                        previous = previous.getattr(specifier)[0]
+                    except astroid.NotFoundError:
+                        if (
+                            hasattr(previous, "has_dynamic_getattr")
+                            and previous.has_dynamic_getattr()
+                        ):
+                            # Don't warn if the object has a custom __getattr__
+                            break
+                        path = get_access_path(key, parsed)
+                        self.add_message(
+                            "missing-format-attribute",
+                            args=(specifier, path),
+                            node=node,
+                        )
+                        break
+                else:
+                    warn_error = False
+                    if hasattr(previous, "getitem"):
+                        try:
+                            previous = previous.getitem(nodes.Const(specifier))
+                        except (
+                            astroid.AstroidIndexError,
+                            astroid.AstroidTypeError,
+                            astroid.AttributeInferenceError,
+                        ):
+                            warn_error = True
+                        except astroid.InferenceError:
+                            break
+                        if previous is astroid.Uninferable:
+                            break
+                    else:
+                        try:
+                            # Lookup __getitem__ in the current node,
+                            # but skip further checks, because we can't
+                            # retrieve the looked object
+                            previous.getattr("__getitem__")
+                            break
+                        except astroid.NotFoundError:
+                            warn_error = True
+                    if warn_error:
+                        path = get_access_path(key, parsed)
+                        self.add_message(
+                            "invalid-format-index", args=(specifier, path), node=node
+                        )
+                        break
+
+                try:
+                    previous = next(previous.infer())
+                except astroid.InferenceError:
+                    # can't check further if we can't infer it
+                    break
+
+
+class StringConstantChecker(BaseTokenChecker):
+    """Check string literals."""
+
+    __implements__ = (IAstroidChecker, ITokenChecker, IRawChecker)
+    name = "string"
+    msgs = {
+        "W1401": (
+            "Anomalous backslash in string: '%s'. "
+            "String constant might be missing an r prefix.",
+            "anomalous-backslash-in-string",
+            "Used when a backslash is in a literal string but not as an escape.",
+        ),
+        "W1402": (
+            "Anomalous Unicode escape in byte string: '%s'. "
+            "String constant might be missing an r or u prefix.",
+            "anomalous-unicode-escape-in-string",
+            "Used when an escape like \\u is encountered in a byte "
+            "string where it has no effect.",
+        ),
+        "W1404": (
+            "Implicit string concatenation found in %s",
+            "implicit-str-concat",
+            "String literals are implicitly concatenated in a "
+            "literal iterable definition : "
+            "maybe a comma is missing ?",
+            {"old_names": [("W1403", "implicit-str-concat-in-sequence")]},
+        ),
+        "W1405": (
+            "Quote delimiter %s is inconsistent with the rest of the file",
+            "inconsistent-quotes",
+            "Quote delimiters are not used consistently throughout a module "
+            "(with allowances made for avoiding unnecessary escaping).",
+        ),
+        "W1406": (
+            "The u prefix for strings is no longer necessary in Python >=3.0",
+            "redundant-u-string-prefix",
+            "Used when we detect a string with a u prefix. These prefixes were necessary "
+            "in Python 2 to indicate a string was Unicode, but since Python 3.0 strings "
+            "are Unicode by default.",
+        ),
+    }
+    options = (
+        (
+            "check-str-concat-over-line-jumps",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "This flag controls whether the "
+                "implicit-str-concat should generate a warning "
+                "on implicit string concatenation in sequences defined over "
+                "several lines.",
+            },
+        ),
+        (
+            "check-quote-consistency",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "This flag controls whether inconsistent-quotes generates a "
+                "warning when the character used as a quote delimiter is used "
+                "inconsistently within a module.",
+            },
+        ),
+    )
+
+    # Characters that have a special meaning after a backslash in either
+    # Unicode or byte strings.
+    ESCAPE_CHARACTERS = "abfnrtvx\n\r\t\\'\"01234567"
+
+    # Characters that have a special meaning after a backslash but only in
+    # Unicode strings.
+    UNICODE_ESCAPE_CHARACTERS = "uUN"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.string_tokens = {}  # token position -> (token value, next token)
+
+    def process_module(self, node: nodes.Module) -> None:
+        self._unicode_literals = "unicode_literals" in node.future_imports
+
+    def process_tokens(self, tokens):
+        encoding = "ascii"
+        for i, (tok_type, token, start, _, line) in enumerate(tokens):
+            if tok_type == tokenize.ENCODING:
+                # this is always the first token processed
+                encoding = token
+            elif tok_type == tokenize.STRING:
+                # 'token' is the whole un-parsed token; we can look at the start
+                # of it to see whether it's a raw or unicode string etc.
+                self.process_string_token(token, start[0], start[1])
+                # We figure the next token, ignoring comments & newlines:
+                j = i + 1
+                while j < len(tokens) and tokens[j].type in (
+                    tokenize.NEWLINE,
+                    tokenize.NL,
+                    tokenize.COMMENT,
+                ):
+                    j += 1
+                next_token = tokens[j] if j < len(tokens) else None
+                if encoding != "ascii":
+                    # We convert `tokenize` character count into a byte count,
+                    # to match with astroid `.col_offset`
+                    start = (start[0], len(line[: start[1]].encode(encoding)))
+                self.string_tokens[start] = (str_eval(token), next_token)
+
+        if self.config.check_quote_consistency:
+            self.check_for_consistent_string_delimiters(tokens)
+
+    @check_messages("implicit-str-concat")
+    def visit_list(self, node: nodes.List) -> None:
+        self.check_for_concatenated_strings(node.elts, "list")
+
+    @check_messages("implicit-str-concat")
+    def visit_set(self, node: nodes.Set) -> None:
+        self.check_for_concatenated_strings(node.elts, "set")
+
+    @check_messages("implicit-str-concat")
+    def visit_tuple(self, node: nodes.Tuple) -> None:
+        self.check_for_concatenated_strings(node.elts, "tuple")
+
+    def visit_assign(self, node: nodes.Assign) -> None:
+        if isinstance(node.value, nodes.Const) and isinstance(node.value.value, str):
+            self.check_for_concatenated_strings([node.value], "assignment")
+
+    def check_for_consistent_string_delimiters(
+        self, tokens: Iterable[tokenize.TokenInfo]
+    ) -> None:
+        """Adds a message for each string using inconsistent quote delimiters.
+
+        Quote delimiters are used inconsistently if " and ' are mixed in a module's
+        shortstrings without having done so to avoid escaping an internal quote
+        character.
+
+        Args:
+          tokens: The tokens to be checked against for consistent usage.
+        """
+        string_delimiters: Counter[str] = collections.Counter()
+
+        # First, figure out which quote character predominates in the module
+        for tok_type, token, _, _, _ in tokens:
+            if tok_type == tokenize.STRING and _is_quote_delimiter_chosen_freely(token):
+                string_delimiters[_get_quote_delimiter(token)] += 1
+
+        if len(string_delimiters) > 1:
+            # Ties are broken arbitrarily
+            most_common_delimiter = string_delimiters.most_common(1)[0][0]
+            for tok_type, token, start, _, _ in tokens:
+                if tok_type != tokenize.STRING:
+                    continue
+                quote_delimiter = _get_quote_delimiter(token)
+                if (
+                    _is_quote_delimiter_chosen_freely(token)
+                    and quote_delimiter != most_common_delimiter
+                ):
+                    self.add_message(
+                        "inconsistent-quotes", line=start[0], args=(quote_delimiter,)
+                    )
+
+    def check_for_concatenated_strings(self, elements, iterable_type):
+        for elt in elements:
+            if not (
+                isinstance(elt, nodes.Const) and elt.pytype() in _AST_NODE_STR_TYPES
+            ):
+                continue
+            if elt.col_offset < 0:
+                # This can happen in case of escaped newlines
+                continue
+            if (elt.lineno, elt.col_offset) not in self.string_tokens:
+                # This may happen with Latin1 encoding
+                # cf. https://github.com/PyCQA/pylint/issues/2610
+                continue
+            matching_token, next_token = self.string_tokens[
+                (elt.lineno, elt.col_offset)
+            ]
+            # We detect string concatenation: the AST Const is the
+            # combination of 2 string tokens
+            if matching_token != elt.value and next_token is not None:
+                if next_token.type == tokenize.STRING and (
+                    next_token.start[0] == elt.lineno
+                    or self.config.check_str_concat_over_line_jumps
+                ):
+                    self.add_message(
+                        "implicit-str-concat", line=elt.lineno, args=(iterable_type,)
+                    )
+
+    def process_string_token(self, token, start_row, start_col):
+        quote_char = None
+        index = None
+        for index, char in enumerate(token):
+            if char in "'\"":
+                quote_char = char
+                break
+        if quote_char is None:
+            return
+
+        prefix = token[:index].lower()  # markers like u, b, r.
+        after_prefix = token[index:]
+        # Chop off quotes
+        quote_length = (
+            3 if after_prefix[:3] == after_prefix[-3:] == 3 * quote_char else 1
+        )
+        string_body = after_prefix[quote_length:-quote_length]
+        # No special checks on raw strings at the moment.
+        if "r" not in prefix:
+            self.process_non_raw_string_token(
+                prefix,
+                string_body,
+                start_row,
+                start_col + len(prefix) + quote_length,
+            )
+
+    def process_non_raw_string_token(
+        self, prefix, string_body, start_row, string_start_col
+    ):
+        """Check for bad escapes in a non-raw string.
+
+        prefix: lowercase string of eg 'ur' string prefix markers.
+        string_body: the un-parsed body of the string, not including the quote
+        marks.
+        start_row: integer line number in the source.
+        string_start_col: integer col number of the string start in the source.
+        """
+        # Walk through the string; if we see a backslash then escape the next
+        # character, and skip over it.  If we see a non-escaped character,
+        # alert, and continue.
+        #
+        # Accept a backslash when it escapes a backslash, or a quote, or
+        # end-of-line, or one of the letters that introduce a special escape
+        # sequence <https://docs.python.org/reference/lexical_analysis.html>
+        #
+        index = 0
+        while True:
+            index = string_body.find("\\", index)
+            if index == -1:
+                break
+            # There must be a next character; having a backslash at the end
+            # of the string would be a SyntaxError.
+            next_char = string_body[index + 1]
+            match = string_body[index : index + 2]
+            # The column offset will vary depending on whether the string token
+            # is broken across lines. Calculate relative to the nearest line
+            # break or relative to the start of the token's line.
+            last_newline = string_body.rfind("\n", 0, index)
+            if last_newline == -1:
+                line = start_row
+                col_offset = index + string_start_col
+            else:
+                line = start_row + string_body.count("\n", 0, index)
+                col_offset = index - last_newline - 1
+            if next_char in self.UNICODE_ESCAPE_CHARACTERS:
+                if "u" in prefix:
+                    pass
+                elif "b" not in prefix:
+                    pass  # unicode by default
+                else:
+                    self.add_message(
+                        "anomalous-unicode-escape-in-string",
+                        line=line,
+                        args=(match,),
+                        col_offset=col_offset,
+                    )
+            elif next_char not in self.ESCAPE_CHARACTERS:
+                self.add_message(
+                    "anomalous-backslash-in-string",
+                    line=line,
+                    args=(match,),
+                    col_offset=col_offset,
+                )
+            # Whether it was a valid escape or not, backslash followed by
+            # another character can always be consumed whole: the second
+            # character can never be the start of a new backslash escape.
+            index += 2
+
+    @check_messages("redundant-u-string-prefix")
+    def visit_const(self, node: nodes.Const) -> None:
+        if node.pytype() == "builtins.str" and not isinstance(
+            node.parent, nodes.JoinedStr
+        ):
+            self._detect_u_string_prefix(node)
+
+    def _detect_u_string_prefix(self, node: nodes.Const):
+        """Check whether strings include a 'u' prefix like u'String'."""
+        if node.kind == "u":
+            self.add_message(
+                "redundant-u-string-prefix",
+                line=node.lineno,
+                col_offset=node.col_offset,
+            )
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(StringFormatChecker(linter))
+    linter.register_checker(StringConstantChecker(linter))
+
+
+def str_eval(token):
+    """Mostly replicate `ast.literal_eval(token)` manually to avoid any performance hit.
+
+    This supports f-strings, contrary to `ast.literal_eval`.
+    We have to support all string literal notations:
+    https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals
+    """
+    if token[0:2].lower() in {"fr", "rf"}:
+        token = token[2:]
+    elif token[0].lower() in {"r", "u", "f"}:
+        token = token[1:]
+    if token[0:3] in {'"""', "'''"}:
+        return token[3:-3]
+    return token[1:-1]
+
+
+def _is_long_string(string_token: str) -> bool:
+    """Is this string token a "longstring" (is it triple-quoted)?
+
+    Long strings are triple-quoted as defined in
+    https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals
+
+    This function only checks characters up through the open quotes.  Because it's meant
+    to be applied only to tokens that represent string literals, it doesn't bother to
+    check for close-quotes (demonstrating that the literal is a well-formed string).
+
+    Args:
+        string_token: The string token to be parsed.
+
+    Returns:
+        A boolean representing whether this token matches a longstring
+        regex.
+    """
+    return bool(
+        SINGLE_QUOTED_REGEX.match(string_token)
+        or DOUBLE_QUOTED_REGEX.match(string_token)
+    )
+
+
+def _get_quote_delimiter(string_token: str) -> str:
+    """Returns the quote character used to delimit this token string.
+
+    This function checks whether the token is a well-formed string.
+
+    Args:
+        string_token: The token to be parsed.
+
+    Returns:
+        A string containing solely the first quote delimiter character in the
+        given string.
+
+    Raises:
+      ValueError: No quote delimiter characters are present.
+    """
+    match = QUOTE_DELIMITER_REGEX.match(string_token)
+    if not match:
+        raise ValueError(f"string token {string_token} is not a well-formed string")
+    return match.group(2)
+
+
+def _is_quote_delimiter_chosen_freely(string_token: str) -> bool:
+    """Was there a non-awkward option for the quote delimiter?
+
+    Args:
+        string_token: The quoted string whose delimiters are to be checked.
+
+    Returns:
+        Whether there was a choice in this token's quote character that would
+        not have involved backslash-escaping an interior quote character.  Long
+        strings are excepted from this analysis under the assumption that their
+        quote characters are set by policy.
+    """
+    quote_delimiter = _get_quote_delimiter(string_token)
+    unchosen_delimiter = '"' if quote_delimiter == "'" else "'"
+    return bool(
+        quote_delimiter
+        and not _is_long_string(string_token)
+        and unchosen_delimiter not in str_eval(string_token)
+    )
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/threading_checker.py b/myenv/lib/python3.9/site-packages/pylint/checkers/threading_checker.py
new file mode 100644
index 0000000..6a720d3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/threading_checker.py
@@ -0,0 +1,60 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint import interfaces
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages, safe_infer
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class ThreadingChecker(BaseChecker):
+    """Checks for threading module.
+
+    - useless with lock - locking used in wrong way that has no effect (with threading.Lock():)
+    """
+
+    __implements__ = interfaces.IAstroidChecker
+    name = "threading"
+
+    LOCKS = frozenset(
+        (
+            "threading.Lock",
+            "threading.RLock",
+            "threading.Condition",
+            "threading.Semaphore",
+            "threading.BoundedSemaphore",
+        )
+    )
+
+    msgs = {
+        "W2101": (
+            "'%s()' directly created in 'with' has no effect",
+            "useless-with-lock",
+            "Used when a new lock instance is created by using with statement "
+            "which has no effect. Instead, an existing instance should be used to acquire lock.",
+        ),
+    }
+
+    @check_messages("useless-with-lock")
+    def visit_with(self, node: nodes.With) -> None:
+
+        context_managers = (c for c, _ in node.items if isinstance(c, nodes.Call))
+        for context_manager in context_managers:
+            if isinstance(context_manager, nodes.Call):
+                infered_function = safe_infer(context_manager.func)
+                if infered_function is None:
+                    continue
+                qname = infered_function.qname()
+                if qname in self.LOCKS:
+                    self.add_message("useless-with-lock", node=node, args=qname)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(ThreadingChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/typecheck.py b/myenv/lib/python3.9/site-packages/pylint/checkers/typecheck.py
new file mode 100644
index 0000000..f1ef992
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/typecheck.py
@@ -0,0 +1,2080 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Try to find more bugs in the code using astroid inference capabilities."""
+
+import fnmatch
+import heapq
+import itertools
+import operator
+import re
+import shlex
+import sys
+import types
+from collections import deque
+from collections.abc import Sequence
+from functools import singledispatch
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Iterator,
+    List,
+    Optional,
+    Pattern,
+    Tuple,
+    Union,
+)
+
+import astroid
+import astroid.exceptions
+from astroid import bases, nodes
+
+from pylint.checkers import BaseChecker, utils
+from pylint.checkers.utils import (
+    check_messages,
+    decorated_with,
+    decorated_with_property,
+    has_known_bases,
+    is_builtin_object,
+    is_classdef_type,
+    is_comprehension,
+    is_inside_abstract_class,
+    is_iterable,
+    is_mapping,
+    is_overload_stub,
+    is_postponed_evaluation_enabled,
+    is_super,
+    node_ignores_exception,
+    safe_infer,
+    supports_delitem,
+    supports_getitem,
+    supports_membership_test,
+    supports_setitem,
+)
+from pylint.interfaces import INFERENCE, IAstroidChecker
+from pylint.utils import get_global_option
+
+if sys.version_info >= (3, 8):
+    from functools import cached_property
+else:
+    from astroid.decorators import cachedproperty as cached_property
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+CallableObjects = Union[
+    bases.BoundMethod,
+    bases.UnboundMethod,
+    nodes.FunctionDef,
+    nodes.Lambda,
+    nodes.ClassDef,
+]
+
+STR_FORMAT = {"builtins.str.format"}
+ASYNCIO_COROUTINE = "asyncio.coroutines.coroutine"
+BUILTIN_TUPLE = "builtins.tuple"
+TYPE_ANNOTATION_NODES_TYPES = (
+    nodes.AnnAssign,
+    nodes.Arguments,
+    nodes.FunctionDef,
+)
+
+
+def _unflatten(iterable):
+    for index, elem in enumerate(iterable):
+        if isinstance(elem, Sequence) and not isinstance(elem, str):
+            yield from _unflatten(elem)
+        elif elem and not index:
+            # We're interested only in the first element.
+            yield elem
+
+
+def _flatten_container(iterable):
+    # Flatten nested containers into a single iterable
+    for item in iterable:
+        if isinstance(item, (list, tuple, types.GeneratorType)):
+            yield from _flatten_container(item)
+        else:
+            yield item
+
+
+def _is_owner_ignored(owner, attrname, ignored_classes, ignored_modules):
+    """Check if the given owner should be ignored.
+
+    This will verify if the owner's module is in *ignored_modules*
+    or the owner's module fully qualified name is in *ignored_modules*
+    or if the *ignored_modules* contains a pattern which catches
+    the fully qualified name of the module.
+
+    Also, similar checks are done for the owner itself, if its name
+    matches any name from the *ignored_classes* or if its qualified
+    name can be found in *ignored_classes*.
+    """
+    ignored_modules = set(ignored_modules)
+    module_name = owner.root().name
+    module_qname = owner.root().qname()
+
+    for ignore in ignored_modules:
+        # Try to match the module name / fully qualified name directly
+        if module_qname in ignored_modules or module_name in ignored_modules:
+            return True
+
+        # Try to see if the ignores pattern match against the module name.
+        if fnmatch.fnmatch(module_qname, ignore):
+            return True
+
+        # Otherwise, we might have a root module name being ignored,
+        # and the qualified owner has more levels of depth.
+        parts = deque(module_name.split("."))
+        current_module = ""
+
+        while parts:
+            part = parts.popleft()
+            if not current_module:
+                current_module = part
+            else:
+                current_module += f".{part}"
+            if current_module in ignored_modules:
+                return True
+
+    # Match against ignored classes.
+    ignored_classes = set(ignored_classes)
+    qname = owner.qname() if hasattr(owner, "qname") else ""
+    return any(ignore in (attrname, qname) for ignore in ignored_classes)
+
+
+@singledispatch
+def _node_names(node):
+    if not hasattr(node, "locals"):
+        return []
+    return node.locals.keys()
+
+
+@_node_names.register(nodes.ClassDef)
+@_node_names.register(astroid.Instance)
+def _(node):
+    values = itertools.chain(node.instance_attrs.keys(), node.locals.keys())
+
+    try:
+        mro = node.mro()[1:]
+    except (NotImplementedError, TypeError, astroid.MroError):
+        mro = node.ancestors()
+
+    other_values = [value for cls in mro for value in _node_names(cls)]
+    return itertools.chain(values, other_values)
+
+
+def _string_distance(seq1, seq2):
+    seq2_length = len(seq2)
+
+    row = list(range(1, seq2_length + 1)) + [0]
+    for seq1_index, seq1_char in enumerate(seq1):
+        last_row = row
+        row = [0] * seq2_length + [seq1_index + 1]
+
+        for seq2_index, seq2_char in enumerate(seq2):
+            row[seq2_index] = min(
+                last_row[seq2_index] + 1,
+                row[seq2_index - 1] + 1,
+                last_row[seq2_index - 1] + (seq1_char != seq2_char),
+            )
+
+    return row[seq2_length - 1]
+
+
+def _similar_names(owner, attrname, distance_threshold, max_choices):
+    """Given an owner and a name, try to find similar names.
+
+    The similar names are searched given a distance metric and only
+    a given number of choices will be returned.
+    """
+    possible_names = []
+    names = _node_names(owner)
+
+    for name in names:
+        if name == attrname:
+            continue
+
+        distance = _string_distance(attrname, name)
+        if distance <= distance_threshold:
+            possible_names.append((name, distance))
+
+    # Now get back the values with a minimum, up to the given
+    # limit or choices.
+    picked = [
+        name
+        for (name, _) in heapq.nsmallest(
+            max_choices, possible_names, key=operator.itemgetter(1)
+        )
+    ]
+    return sorted(picked)
+
+
+def _missing_member_hint(owner, attrname, distance_threshold, max_choices):
+    names = _similar_names(owner, attrname, distance_threshold, max_choices)
+    if not names:
+        # No similar name.
+        return ""
+
+    names = [repr(name) for name in names]
+    if len(names) == 1:
+        names_hint = ", ".join(names)
+    else:
+        names_hint = f"one of {', '.join(names[:-1])} or {names[-1]}"
+
+    return f"; maybe {names_hint}?"
+
+
+MSGS = {
+    "E1101": (
+        "%s %r has no %r member%s",
+        "no-member",
+        "Used when a variable is accessed for an unexistent member.",
+        {"old_names": [("E1103", "maybe-no-member")]},
+    ),
+    "I1101": (
+        "%s %r has no %r member%s, but source is unavailable. Consider "
+        "adding this module to extension-pkg-allow-list if you want "
+        "to perform analysis based on run-time introspection of living objects.",
+        "c-extension-no-member",
+        "Used when a variable is accessed for non-existent member of C "
+        "extension. Due to unavailability of source static analysis is impossible, "
+        "but it may be performed by introspecting living objects in run-time.",
+    ),
+    "E1102": (
+        "%s is not callable",
+        "not-callable",
+        "Used when an object being called has been inferred to a non "
+        "callable object.",
+    ),
+    "E1111": (
+        "Assigning result of a function call, where the function has no return",
+        "assignment-from-no-return",
+        "Used when an assignment is done on a function call but the "
+        "inferred function doesn't return anything.",
+    ),
+    "E1120": (
+        "No value for argument %s in %s call",
+        "no-value-for-parameter",
+        "Used when a function call passes too few arguments.",
+    ),
+    "E1121": (
+        "Too many positional arguments for %s call",
+        "too-many-function-args",
+        "Used when a function call passes too many positional arguments.",
+    ),
+    "E1123": (
+        "Unexpected keyword argument %r in %s call",
+        "unexpected-keyword-arg",
+        "Used when a function call passes a keyword argument that "
+        "doesn't correspond to one of the function's parameter names.",
+    ),
+    "E1124": (
+        "Argument %r passed by position and keyword in %s call",
+        "redundant-keyword-arg",
+        "Used when a function call would result in assigning multiple "
+        "values to a function parameter, one value from a positional "
+        "argument and one from a keyword argument.",
+    ),
+    "E1125": (
+        "Missing mandatory keyword argument %r in %s call",
+        "missing-kwoa",
+        (
+            "Used when a function call does not pass a mandatory"
+            " keyword-only argument."
+        ),
+    ),
+    "E1126": (
+        "Sequence index is not an int, slice, or instance with __index__",
+        "invalid-sequence-index",
+        "Used when a sequence type is indexed with an invalid type. "
+        "Valid types are ints, slices, and objects with an __index__ "
+        "method.",
+    ),
+    "E1127": (
+        "Slice index is not an int, None, or instance with __index__",
+        "invalid-slice-index",
+        "Used when a slice index is not an integer, None, or an object "
+        "with an __index__ method.",
+    ),
+    "E1128": (
+        "Assigning result of a function call, where the function returns None",
+        "assignment-from-none",
+        "Used when an assignment is done on a function call but the "
+        "inferred function returns nothing but None.",
+        {"old_names": [("W1111", "old-assignment-from-none")]},
+    ),
+    "E1129": (
+        "Context manager '%s' doesn't implement __enter__ and __exit__.",
+        "not-context-manager",
+        "Used when an instance in a with statement doesn't implement "
+        "the context manager protocol(__enter__/__exit__).",
+    ),
+    "E1130": (
+        "%s",
+        "invalid-unary-operand-type",
+        "Emitted when a unary operand is used on an object which does not "
+        "support this type of operation.",
+    ),
+    "E1131": (
+        "%s",
+        "unsupported-binary-operation",
+        "Emitted when a binary arithmetic operation between two "
+        "operands is not supported.",
+    ),
+    "E1132": (
+        "Got multiple values for keyword argument %r in function call",
+        "repeated-keyword",
+        "Emitted when a function call got multiple values for a keyword.",
+    ),
+    "E1135": (
+        "Value '%s' doesn't support membership test",
+        "unsupported-membership-test",
+        "Emitted when an instance in membership test expression doesn't "
+        "implement membership protocol (__contains__/__iter__/__getitem__).",
+    ),
+    "E1136": (
+        "Value '%s' is unsubscriptable",
+        "unsubscriptable-object",
+        "Emitted when a subscripted value doesn't support subscription "
+        "(i.e. doesn't define __getitem__ method or __class_getitem__ for a class).",
+    ),
+    "E1137": (
+        "%r does not support item assignment",
+        "unsupported-assignment-operation",
+        "Emitted when an object does not support item assignment "
+        "(i.e. doesn't define __setitem__ method).",
+    ),
+    "E1138": (
+        "%r does not support item deletion",
+        "unsupported-delete-operation",
+        "Emitted when an object does not support item deletion "
+        "(i.e. doesn't define __delitem__ method).",
+    ),
+    "E1139": (
+        "Invalid metaclass %r used",
+        "invalid-metaclass",
+        "Emitted whenever we can detect that a class is using, "
+        "as a metaclass, something which might be invalid for using as "
+        "a metaclass.",
+    ),
+    "E1140": (
+        "Dict key is unhashable",
+        "unhashable-dict-key",
+        "Emitted when a dict key is not hashable "
+        "(i.e. doesn't define __hash__ method).",
+    ),
+    "E1141": (
+        "Unpacking a dictionary in iteration without calling .items()",
+        "dict-iter-missing-items",
+        "Emitted when trying to iterate through a dict without calling .items()",
+    ),
+    "E1142": (
+        "'await' should be used within an async function",
+        "await-outside-async",
+        "Emitted when await is used outside an async function.",
+    ),
+    "W1113": (
+        "Keyword argument before variable positional arguments list "
+        "in the definition of %s function",
+        "keyword-arg-before-vararg",
+        "When defining a keyword argument before variable positional arguments, one can "
+        "end up in having multiple values passed for the aforementioned parameter in "
+        "case the method is called with keyword arguments.",
+    ),
+    "W1114": (
+        "Positional arguments appear to be out of order",
+        "arguments-out-of-order",
+        "Emitted  when the caller's argument names fully match the parameter "
+        "names in the function signature but do not have the same order.",
+    ),
+    "W1115": (
+        "Non-string value assigned to __name__",
+        "non-str-assignment-to-dunder-name",
+        "Emitted when a non-string value is assigned to __name__",
+    ),
+    "W1116": (
+        "Second argument of isinstance is not a type",
+        "isinstance-second-argument-not-valid-type",
+        "Emitted when the second argument of an isinstance call is not a type.",
+    ),
+}
+
+# builtin sequence types in Python 2 and 3.
+SEQUENCE_TYPES = {
+    "str",
+    "unicode",
+    "list",
+    "tuple",
+    "bytearray",
+    "xrange",
+    "range",
+    "bytes",
+    "memoryview",
+}
+
+
+def _emit_no_member(
+    node,
+    owner,
+    owner_name,
+    mixin_class_rgx: Pattern[str],
+    ignored_mixins=True,
+    ignored_none=True,
+):
+    """Try to see if no-member should be emitted for the given owner.
+
+    The following cases are ignored:
+
+        * the owner is a function and it has decorators.
+        * the owner is an instance and it has __getattr__, __getattribute__ implemented
+        * the module is explicitly ignored from no-member checks
+        * the owner is a class and the name can be found in its metaclass.
+        * The access node is protected by an except handler, which handles
+          AttributeError, Exception or bare except.
+        * The node is guarded behind and `IF` or `IFExp` node
+    """
+    # pylint: disable=too-many-return-statements
+    if node_ignores_exception(node, AttributeError):
+        return False
+    if ignored_none and isinstance(owner, nodes.Const) and owner.value is None:
+        return False
+    if is_super(owner) or getattr(owner, "type", None) == "metaclass":
+        return False
+    if owner_name and ignored_mixins and mixin_class_rgx.match(owner_name):
+        return False
+    if isinstance(owner, nodes.FunctionDef) and (
+        owner.decorators or owner.is_abstract()
+    ):
+        return False
+    if isinstance(owner, (astroid.Instance, nodes.ClassDef)):
+        if owner.has_dynamic_getattr():
+            # Issue #2565: Don't ignore enums, as they have a `__getattr__` but it's not
+            # invoked at this point.
+            try:
+                metaclass = owner.metaclass()
+            except astroid.MroError:
+                return False
+            if metaclass:
+                # Renamed in Python 3.10 to `EnumType`
+                return metaclass.qname() in {"enum.EnumMeta", "enum.EnumType"}
+            return False
+        if not has_known_bases(owner):
+            return False
+
+        # Exclude typed annotations, since these might actually exist
+        # at some point during the runtime of the program.
+        if utils.is_attribute_typed_annotation(owner, node.attrname):
+            return False
+    if isinstance(owner, astroid.objects.Super):
+        # Verify if we are dealing with an invalid Super object.
+        # If it is invalid, then there's no point in checking that
+        # it has the required attribute. Also, don't fail if the
+        # MRO is invalid.
+        try:
+            owner.super_mro()
+        except (astroid.MroError, astroid.SuperError):
+            return False
+        if not all(has_known_bases(base) for base in owner.type.mro()):
+            return False
+    if isinstance(owner, nodes.Module):
+        try:
+            owner.getattr("__getattr__")
+            return False
+        except astroid.NotFoundError:
+            pass
+    if owner_name and node.attrname.startswith("_" + owner_name):
+        # Test if an attribute has been mangled ('private' attribute)
+        unmangled_name = node.attrname.split("_" + owner_name)[-1]
+        try:
+            if owner.getattr(unmangled_name, context=None) is not None:
+                return False
+        except astroid.NotFoundError:
+            return True
+    if (
+        owner.parent
+        and isinstance(owner.parent, nodes.ClassDef)
+        and owner.parent.name == "EnumMeta"
+        and owner_name == "__members__"
+        and node.attrname in {"items", "values", "keys"}
+    ):
+        # Avoid false positive on Enum.__members__.{items(), values, keys}
+        # See https://github.com/PyCQA/pylint/issues/4123
+        return False
+    # Don't emit no-member if guarded behind `IF` or `IFExp`
+    #   * Walk up recursively until if statement is found.
+    #   * Check if condition can be inferred as `Const`,
+    #       would evaluate as `False`,
+    #       and wheater the node is part of the `body`.
+    #   * Continue checking until scope of node is reached.
+    scope: nodes.NodeNG = node.scope()
+    node_origin: nodes.NodeNG = node
+    parent: nodes.NodeNG = node.parent
+    while parent != scope:
+        if isinstance(parent, (nodes.If, nodes.IfExp)):
+            inferred = safe_infer(parent.test)
+            if (  # pylint: disable=too-many-boolean-expressions
+                isinstance(inferred, nodes.Const)
+                and inferred.bool_value() is False
+                and (
+                    isinstance(parent, nodes.If)
+                    and node_origin in parent.body
+                    or isinstance(parent, nodes.IfExp)
+                    and node_origin == parent.body
+                )
+            ):
+                return False
+        node_origin, parent = parent, parent.parent
+
+    return True
+
+
+def _determine_callable(
+    callable_obj: nodes.NodeNG,
+) -> Tuple[CallableObjects, int, str]:
+    # pylint: disable=fixme
+    # TODO: The typing of the second return variable is actually Literal[0,1]
+    # We need typing on astroid.NodeNG.implicit_parameters for this
+    # TODO: The typing of the third return variable can be narrowed to a Literal
+    # We need typing on astroid.NodeNG.type for this
+
+    # Ordering is important, since BoundMethod is a subclass of UnboundMethod,
+    # and Function inherits Lambda.
+    parameters = 0
+    if hasattr(callable_obj, "implicit_parameters"):
+        parameters = callable_obj.implicit_parameters()
+    if isinstance(callable_obj, bases.BoundMethod):
+        # Bound methods have an extra implicit 'self' argument.
+        return callable_obj, parameters, callable_obj.type
+    if isinstance(callable_obj, bases.UnboundMethod):
+        return callable_obj, parameters, "unbound method"
+    if isinstance(callable_obj, nodes.FunctionDef):
+        return callable_obj, parameters, callable_obj.type
+    if isinstance(callable_obj, nodes.Lambda):
+        return callable_obj, parameters, "lambda"
+    if isinstance(callable_obj, nodes.ClassDef):
+        # Class instantiation, lookup __new__ instead.
+        # If we only find object.__new__, we can safely check __init__
+        # instead. If __new__ belongs to builtins, then we look
+        # again for __init__ in the locals, since we won't have
+        # argument information for the builtin __new__ function.
+        try:
+            # Use the last definition of __new__.
+            new = callable_obj.local_attr("__new__")[-1]
+        except astroid.NotFoundError:
+            new = None
+
+        from_object = new and new.parent.scope().name == "object"
+        from_builtins = new and new.root().name in sys.builtin_module_names
+
+        if not new or from_object or from_builtins:
+            try:
+                # Use the last definition of __init__.
+                callable_obj = callable_obj.local_attr("__init__")[-1]
+            except astroid.NotFoundError as e:
+                # do nothing, covered by no-init.
+                raise ValueError from e
+        else:
+            callable_obj = new
+
+        if not isinstance(callable_obj, nodes.FunctionDef):
+            raise ValueError
+        # both have an extra implicit 'cls'/'self' argument.
+        return callable_obj, parameters, "constructor"
+
+    raise ValueError
+
+
+def _has_parent_of_type(node, node_type, statement):
+    """Check if the given node has a parent of the given type."""
+    parent = node.parent
+    while not isinstance(parent, node_type) and statement.parent_of(parent):
+        parent = parent.parent
+    return isinstance(parent, node_type)
+
+
+def _no_context_variadic_keywords(node, scope):
+    statement = node.statement(future=True)
+    variadics = ()
+
+    if isinstance(scope, nodes.Lambda) and not isinstance(scope, nodes.FunctionDef):
+        variadics = list(node.keywords or []) + node.kwargs
+    elif isinstance(statement, (nodes.Return, nodes.Expr, nodes.Assign)) and isinstance(
+        statement.value, nodes.Call
+    ):
+        call = statement.value
+        variadics = list(call.keywords or []) + call.kwargs
+
+    return _no_context_variadic(node, scope.args.kwarg, nodes.Keyword, variadics)
+
+
+def _no_context_variadic_positional(node, scope):
+    variadics = node.starargs + node.kwargs
+    return _no_context_variadic(node, scope.args.vararg, nodes.Starred, variadics)
+
+
+def _no_context_variadic(node, variadic_name, variadic_type, variadics):
+    """Verify if the given call node has variadic nodes without context.
+
+    This is a workaround for handling cases of nested call functions
+    which don't have the specific call context at hand.
+    Variadic arguments (variable positional arguments and variable
+    keyword arguments) are inferred, inherently wrong, by astroid
+    as a Tuple, respectively a Dict with empty elements.
+    This can lead pylint to believe that a function call receives
+    too few arguments.
+    """
+    scope = node.scope()
+    is_in_lambda_scope = not isinstance(scope, nodes.FunctionDef) and isinstance(
+        scope, nodes.Lambda
+    )
+    statement = node.statement(future=True)
+    for name in statement.nodes_of_class(nodes.Name):
+        if name.name != variadic_name:
+            continue
+
+        inferred = safe_infer(name)
+        if isinstance(inferred, (nodes.List, nodes.Tuple)):
+            length = len(inferred.elts)
+        elif isinstance(inferred, nodes.Dict):
+            length = len(inferred.items)
+        else:
+            continue
+
+        if is_in_lambda_scope and isinstance(inferred.parent, nodes.Arguments):
+            # The statement of the variadic will be the assignment itself,
+            # so we need to go the lambda instead
+            inferred_statement = inferred.parent.parent
+        else:
+            inferred_statement = inferred.statement(future=True)
+
+        if not length and isinstance(inferred_statement, nodes.Lambda):
+            is_in_starred_context = _has_parent_of_type(node, variadic_type, statement)
+            used_as_starred_argument = any(
+                variadic.value == name or variadic.value.parent_of(name)
+                for variadic in variadics
+            )
+            if is_in_starred_context or used_as_starred_argument:
+                return True
+    return False
+
+
+def _is_invalid_metaclass(metaclass):
+    try:
+        mro = metaclass.mro()
+    except NotImplementedError:
+        # Cannot have a metaclass which is not a newstyle class.
+        return True
+    else:
+        if not any(is_builtin_object(cls) and cls.name == "type" for cls in mro):
+            return True
+    return False
+
+
+def _infer_from_metaclass_constructor(cls, func: nodes.FunctionDef):
+    """Try to infer what the given *func* constructor is building.
+
+    :param astroid.FunctionDef func:
+        A metaclass constructor. Metaclass definitions can be
+        functions, which should accept three arguments, the name of
+        the class, the bases of the class and the attributes.
+        The function could return anything, but usually it should
+        be a proper metaclass.
+    :param astroid.ClassDef cls:
+        The class for which the *func* parameter should generate
+        a metaclass.
+    :returns:
+        The class generated by the function or None,
+        if we couldn't infer it.
+    :rtype: astroid.ClassDef
+    """
+    context = astroid.context.InferenceContext()
+
+    class_bases = nodes.List()
+    class_bases.postinit(elts=cls.bases)
+
+    attrs = nodes.Dict()
+    local_names = [(name, values[-1]) for name, values in cls.locals.items()]
+    attrs.postinit(local_names)
+
+    builder_args = nodes.Tuple()
+    builder_args.postinit([cls.name, class_bases, attrs])
+
+    context.callcontext = astroid.context.CallContext(builder_args)
+    try:
+        inferred = next(func.infer_call_result(func, context), None)
+    except astroid.InferenceError:
+        return None
+    return inferred or None
+
+
+def _is_c_extension(module_node):
+    return (
+        not astroid.modutils.is_standard_module(module_node.name)
+        and not module_node.fully_defined()
+    )
+
+
+def _is_invalid_isinstance_type(arg):
+    # Return True if we are sure that arg is not a type
+    inferred = utils.safe_infer(arg)
+    if not inferred:
+        # Cannot infer it so skip it.
+        return False
+    if isinstance(inferred, nodes.Tuple):
+        return any(_is_invalid_isinstance_type(elt) for elt in inferred.elts)
+    if isinstance(inferred, nodes.ClassDef):
+        return False
+    if isinstance(inferred, astroid.Instance) and inferred.qname() == BUILTIN_TUPLE:
+        return False
+    return True
+
+
+class TypeChecker(BaseChecker):
+    """Try to find bugs in the code using type inference."""
+
+    __implements__ = (IAstroidChecker,)
+
+    # configuration section name
+    name = "typecheck"
+    # messages
+    msgs = MSGS
+    priority = -1
+    # configuration options
+    options = (
+        (
+            "ignore-on-opaque-inference",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "This flag controls whether pylint should warn about "
+                "no-member and similar checks whenever an opaque object "
+                "is returned when inferring. The inference can return "
+                "multiple potential results while evaluating a Python object, "
+                "but some branches might not be evaluated, which results in "
+                "partial inference. In that case, it might be useful to still emit "
+                "no-member and other checks for the rest of the inferred objects.",
+            },
+        ),
+        (
+            "mixin-class-rgx",
+            {
+                "default": ".*[Mm]ixin",
+                "type": "regexp",
+                "metavar": "<regexp>",
+                "help": "Regex pattern to define which classes are considered mixins "
+                "ignore-mixin-members is set to 'yes'",
+            },
+        ),
+        (
+            "ignore-mixin-members",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Tells whether missing members accessed in mixin "
+                "class should be ignored. A class is considered mixin if its name matches "
+                "the mixin-class-rgx option.",
+            },
+        ),
+        (
+            "ignore-none",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Tells whether to warn about missing members when the owner "
+                "of the attribute is inferred to be None.",
+            },
+        ),
+        (
+            "ignored-modules",
+            {
+                "default": (),
+                "type": "csv",
+                "metavar": "<module names>",
+                "help": "List of module names for which member attributes "
+                "should not be checked (useful for modules/projects "
+                "where namespaces are manipulated during runtime and "
+                "thus existing member attributes cannot be "
+                "deduced by static analysis). It supports qualified "
+                "module names, as well as Unix pattern matching.",
+            },
+        ),
+        # the defaults here are *stdlib* names that (almost) always
+        # lead to false positives, since their idiomatic use is
+        # 'too dynamic' for pylint to grok.
+        (
+            "ignored-classes",
+            {
+                "default": ("optparse.Values", "thread._local", "_thread._local"),
+                "type": "csv",
+                "metavar": "<members names>",
+                "help": "List of class names for which member attributes "
+                "should not be checked (useful for classes with "
+                "dynamically set attributes). This supports "
+                "the use of qualified names.",
+            },
+        ),
+        (
+            "generated-members",
+            {
+                "default": (),
+                "type": "string",
+                "metavar": "<members names>",
+                "help": "List of members which are set dynamically and \
+missed by pylint inference system, and so shouldn't trigger E1101 when \
+accessed. Python regular expressions are accepted.",
+            },
+        ),
+        (
+            "contextmanager-decorators",
+            {
+                "default": ["contextlib.contextmanager"],
+                "type": "csv",
+                "metavar": "<decorator names>",
+                "help": "List of decorators that produce context managers, "
+                "such as contextlib.contextmanager. Add to this list "
+                "to register other decorators that produce valid "
+                "context managers.",
+            },
+        ),
+        (
+            "missing-member-hint-distance",
+            {
+                "default": 1,
+                "type": "int",
+                "metavar": "<member hint edit distance>",
+                "help": "The minimum edit distance a name should have in order "
+                "to be considered a similar match for a missing member name.",
+            },
+        ),
+        (
+            "missing-member-max-choices",
+            {
+                "default": 1,
+                "type": "int",
+                "metavar": "<member hint max choices>",
+                "help": "The total number of similar names that should be taken in "
+                "consideration when showing a hint for a missing member.",
+            },
+        ),
+        (
+            "missing-member-hint",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<missing member hint>",
+                "help": "Show a hint with possible names when a member name was not "
+                "found. The aspect of finding the hint is based on edit distance.",
+            },
+        ),
+        (
+            "signature-mutators",
+            {
+                "default": [],
+                "type": "csv",
+                "metavar": "<decorator names>",
+                "help": "List of decorators that change the signature of "
+                "a decorated function.",
+            },
+        ),
+    )
+
+    def open(self) -> None:
+        py_version = get_global_option(self, "py-version")
+        self._py310_plus = py_version >= (3, 10)
+        self._mixin_class_rgx = get_global_option(self, "mixin-class-rgx")
+
+    @cached_property
+    def _suggestion_mode(self):
+        return get_global_option(self, "suggestion-mode", default=True)
+
+    @cached_property
+    def _compiled_generated_members(self) -> Tuple[Pattern, ...]:
+        # do this lazily since config not fully initialized in __init__
+        # generated_members may contain regular expressions
+        # (surrounded by quote `"` and followed by a comma `,`)
+        # REQUEST,aq_parent,"[a-zA-Z]+_set{1,2}"' =>
+        # ('REQUEST', 'aq_parent', '[a-zA-Z]+_set{1,2}')
+        generated_members = self.config.generated_members
+        if isinstance(generated_members, str):
+            gen = shlex.shlex(generated_members)
+            gen.whitespace += ","
+            gen.wordchars += r"[]-+\.*?()|"
+            generated_members = tuple(tok.strip('"') for tok in gen)
+        return tuple(re.compile(exp) for exp in generated_members)
+
+    @check_messages("keyword-arg-before-vararg")
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        # check for keyword arg before varargs
+        if node.args.vararg and node.args.defaults:
+            self.add_message("keyword-arg-before-vararg", node=node, args=(node.name))
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    @check_messages("invalid-metaclass")
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        def _metaclass_name(metaclass):
+            # pylint: disable=unidiomatic-typecheck
+            if isinstance(metaclass, (nodes.ClassDef, nodes.FunctionDef)):
+                return metaclass.name
+            if type(metaclass) is bases.Instance:
+                # Really do mean type, not isinstance, since subclasses of bases.Instance
+                # like Const or Dict should use metaclass.as_string below.
+                return str(metaclass)
+            return metaclass.as_string()
+
+        metaclass = node.declared_metaclass()
+        if not metaclass:
+            return
+
+        if isinstance(metaclass, nodes.FunctionDef):
+            # Try to infer the result.
+            metaclass = _infer_from_metaclass_constructor(node, metaclass)
+            if not metaclass:
+                # Don't do anything if we cannot infer the result.
+                return
+
+        if isinstance(metaclass, nodes.ClassDef):
+            if _is_invalid_metaclass(metaclass):
+                self.add_message(
+                    "invalid-metaclass", node=node, args=(_metaclass_name(metaclass),)
+                )
+        else:
+            self.add_message(
+                "invalid-metaclass", node=node, args=(_metaclass_name(metaclass),)
+            )
+
+    def visit_assignattr(self, node: nodes.AssignAttr) -> None:
+        if isinstance(node.assign_type(), nodes.AugAssign):
+            self.visit_attribute(node)
+
+    def visit_delattr(self, node: nodes.DelAttr) -> None:
+        self.visit_attribute(node)
+
+    @check_messages("no-member", "c-extension-no-member")
+    def visit_attribute(self, node: nodes.Attribute) -> None:
+        """Check that the accessed attribute exists.
+
+        to avoid too much false positives for now, we'll consider the code as
+        correct if a single of the inferred nodes has the accessed attribute.
+
+        function/method, super call and metaclasses are ignored
+        """
+        if any(
+            pattern.match(name)
+            for name in (node.attrname, node.as_string())
+            for pattern in self._compiled_generated_members
+        ):
+            return
+
+        try:
+            inferred = list(node.expr.infer())
+        except astroid.InferenceError:
+            return
+
+        # list of (node, nodename) which are missing the attribute
+        missingattr = set()
+
+        non_opaque_inference_results = [
+            owner
+            for owner in inferred
+            if owner is not astroid.Uninferable and not isinstance(owner, nodes.Unknown)
+        ]
+        if (
+            len(non_opaque_inference_results) != len(inferred)
+            and self.config.ignore_on_opaque_inference
+        ):
+            # There is an ambiguity in the inference. Since we can't
+            # make sure that we won't emit a false positive, we just stop
+            # whenever the inference returns an opaque inference object.
+            return
+        for owner in non_opaque_inference_results:
+            name = getattr(owner, "name", None)
+            if _is_owner_ignored(
+                owner, name, self.config.ignored_classes, self.config.ignored_modules
+            ):
+                continue
+
+            qualname = f"{owner.pytype()}.{node.attrname}"
+            if any(
+                pattern.match(qualname) for pattern in self._compiled_generated_members
+            ):
+                return
+
+            try:
+                if not [
+                    n
+                    for n in owner.getattr(node.attrname)
+                    if not isinstance(n.statement(future=True), nodes.AugAssign)
+                ]:
+                    missingattr.add((owner, name))
+                    continue
+            except astroid.exceptions.StatementMissing:
+                continue
+            except AttributeError:
+                continue
+            except astroid.DuplicateBasesError:
+                continue
+            except astroid.NotFoundError:
+                # This can't be moved before the actual .getattr call,
+                # because there can be more values inferred and we are
+                # stopping after the first one which has the attribute in question.
+                # The problem is that if the first one has the attribute,
+                # but we continue to the next values which doesn't have the
+                # attribute, then we'll have a false positive.
+                # So call this only after the call has been made.
+                if not _emit_no_member(
+                    node,
+                    owner,
+                    name,
+                    self._mixin_class_rgx,
+                    ignored_mixins=self.config.ignore_mixin_members,
+                    ignored_none=self.config.ignore_none,
+                ):
+                    continue
+                missingattr.add((owner, name))
+                continue
+            # stop on the first found
+            break
+        else:
+            # we have not found any node with the attributes, display the
+            # message for inferred nodes
+            done = set()
+            for owner, name in missingattr:
+                if isinstance(owner, astroid.Instance):
+                    actual = owner._proxied
+                else:
+                    actual = owner
+                if actual in done:
+                    continue
+                done.add(actual)
+
+                msg, hint = self._get_nomember_msgid_hint(node, owner)
+                self.add_message(
+                    msg,
+                    node=node,
+                    args=(owner.display_type(), name, node.attrname, hint),
+                    confidence=INFERENCE,
+                )
+
+    def _get_nomember_msgid_hint(self, node, owner):
+        suggestions_are_possible = self._suggestion_mode and isinstance(
+            owner, nodes.Module
+        )
+        if suggestions_are_possible and _is_c_extension(owner):
+            msg = "c-extension-no-member"
+            hint = ""
+        else:
+            msg = "no-member"
+            if self.config.missing_member_hint:
+                hint = _missing_member_hint(
+                    owner,
+                    node.attrname,
+                    self.config.missing_member_hint_distance,
+                    self.config.missing_member_max_choices,
+                )
+            else:
+                hint = ""
+        return msg, hint
+
+    @check_messages(
+        "assignment-from-no-return",
+        "assignment-from-none",
+        "non-str-assignment-to-dunder-name",
+    )
+    def visit_assign(self, node: nodes.Assign) -> None:
+        """Process assignments in the AST."""
+
+        self._check_assignment_from_function_call(node)
+        self._check_dundername_is_string(node)
+
+    def _check_assignment_from_function_call(self, node: nodes.Assign) -> None:
+        """When assigning to a function call, check that the function returns a valid value."""
+        if not isinstance(node.value, nodes.Call):
+            return
+
+        function_node = safe_infer(node.value.func)
+        funcs = (nodes.FunctionDef, astroid.UnboundMethod, astroid.BoundMethod)
+        if not isinstance(function_node, funcs):
+            return
+
+        # Unwrap to get the actual function node object
+        if isinstance(function_node, astroid.BoundMethod) and isinstance(
+            function_node._proxied, astroid.UnboundMethod
+        ):
+            function_node = function_node._proxied._proxied
+
+        # Make sure that it's a valid function that we can analyze.
+        # Ordered from less expensive to more expensive checks.
+        if (
+            not function_node.is_function
+            or function_node.decorators
+            or self._is_ignored_function(function_node)
+        ):
+            return
+
+        # Fix a false-negative for list.sort(), see issue #5722
+        if self._is_list_sort_method(node.value):
+            self.add_message("assignment-from-none", node=node, confidence=INFERENCE)
+            return
+
+        if not function_node.root().fully_defined():
+            return
+
+        return_nodes = list(
+            function_node.nodes_of_class(nodes.Return, skip_klass=nodes.FunctionDef)
+        )
+        if not return_nodes:
+            self.add_message("assignment-from-no-return", node=node)
+        else:
+            for ret_node in return_nodes:
+                if not (
+                    isinstance(ret_node.value, nodes.Const)
+                    and ret_node.value.value is None
+                    or ret_node.value is None
+                ):
+                    break
+            else:
+                self.add_message("assignment-from-none", node=node)
+
+    @staticmethod
+    def _is_ignored_function(
+        function_node: Union[nodes.FunctionDef, bases.UnboundMethod]
+    ) -> bool:
+        return (
+            isinstance(function_node, nodes.AsyncFunctionDef)
+            or utils.is_error(function_node)
+            or function_node.is_generator()
+            or function_node.is_abstract(pass_is_abstract=False)
+        )
+
+    @staticmethod
+    def _is_list_sort_method(node: nodes.Call) -> bool:
+        return (
+            isinstance(node.func, nodes.Attribute)
+            and node.func.attrname == "sort"
+            and isinstance(utils.safe_infer(node.func.expr), nodes.List)
+        )
+
+    def _check_dundername_is_string(self, node) -> None:
+        """Check a string is assigned to self.__name__."""
+
+        # Check the left-hand side of the assignment is <something>.__name__
+        lhs = node.targets[0]
+        if not isinstance(lhs, nodes.AssignAttr):
+            return
+        if not lhs.attrname == "__name__":
+            return
+
+        # If the right-hand side is not a string
+        rhs = node.value
+        if isinstance(rhs, nodes.Const) and isinstance(rhs.value, str):
+            return
+        inferred = utils.safe_infer(rhs)
+        if not inferred:
+            return
+        if not (isinstance(inferred, nodes.Const) and isinstance(inferred.value, str)):
+            # Add the message
+            self.add_message("non-str-assignment-to-dunder-name", node=node)
+
+    def _check_uninferable_call(self, node):
+        """Check that the given uninferable Call node does not
+        call an actual function.
+        """
+        if not isinstance(node.func, nodes.Attribute):
+            return
+
+        # Look for properties. First, obtain
+        # the lhs of the Attribute node and search the attribute
+        # there. If that attribute is a property or a subclass of properties,
+        # then most likely it's not callable.
+
+        expr = node.func.expr
+        klass = safe_infer(expr)
+        if (
+            klass is None
+            or klass is astroid.Uninferable
+            or not isinstance(klass, astroid.Instance)
+        ):
+            return
+
+        try:
+            attrs = klass._proxied.getattr(node.func.attrname)
+        except astroid.NotFoundError:
+            return
+
+        for attr in attrs:
+            if attr is astroid.Uninferable:
+                continue
+            if not isinstance(attr, nodes.FunctionDef):
+                continue
+
+            # Decorated, see if it is decorated with a property.
+            # Also, check the returns and see if they are callable.
+            if decorated_with_property(attr):
+                try:
+                    call_results = list(attr.infer_call_result(node))
+                except astroid.InferenceError:
+                    continue
+
+                if all(
+                    return_node is astroid.Uninferable for return_node in call_results
+                ):
+                    # We were unable to infer return values of the call, skipping
+                    continue
+
+                if any(return_node.callable() for return_node in call_results):
+                    # Only raise this issue if *all* the inferred values are not callable
+                    continue
+
+                self.add_message("not-callable", node=node, args=node.func.as_string())
+
+    def _check_argument_order(self, node, call_site, called, called_param_names):
+        """Match the supplied argument names against the function parameters.
+
+        Warn if some argument names are not in the same order as they are in
+        the function signature.
+        """
+        # Check for called function being an object instance function
+        # If so, ignore the initial 'self' argument in the signature
+        try:
+            is_classdef = isinstance(called.parent, nodes.ClassDef)
+            if is_classdef and called_param_names[0] == "self":
+                called_param_names = called_param_names[1:]
+        except IndexError:
+            return
+
+        try:
+            # extract argument names, if they have names
+            calling_parg_names = [p.name for p in call_site.positional_arguments]
+
+            # Additionally, get names of keyword arguments to use in a full match
+            # against parameters
+            calling_kwarg_names = [
+                arg.name for arg in call_site.keyword_arguments.values()
+            ]
+        except AttributeError:
+            # the type of arg does not provide a `.name`. In this case we
+            # stop checking for out-of-order arguments because it is only relevant
+            # for named variables.
+            return
+
+        # Don't check for ordering if there is an unmatched arg or param
+        arg_set = set(calling_parg_names) | set(calling_kwarg_names)
+        param_set = set(called_param_names)
+        if arg_set != param_set:
+            return
+
+        # Warn based on the equality of argument ordering
+        if calling_parg_names != called_param_names[: len(calling_parg_names)]:
+            self.add_message("arguments-out-of-order", node=node, args=())
+
+    def _check_isinstance_args(self, node):
+        if len(node.args) != 2:
+            # isinstance called with wrong number of args
+            return
+
+        second_arg = node.args[1]
+        if _is_invalid_isinstance_type(second_arg):
+            self.add_message("isinstance-second-argument-not-valid-type", node=node)
+
+    # pylint: disable=too-many-branches,too-many-locals
+    @check_messages(*(list(MSGS.keys())))
+    def visit_call(self, node: nodes.Call) -> None:
+        """Check that called functions/methods are inferred to callable objects,
+        and that passed arguments match the parameters in the inferred function.
+        """
+        called = safe_infer(node.func)
+
+        self._check_not_callable(node, called)
+
+        try:
+            called, implicit_args, callable_name = _determine_callable(called)
+        except ValueError:
+            # Any error occurred during determining the function type, most of
+            # those errors are handled by different warnings.
+            return
+
+        if called.args.args is None:
+            if called.name == "isinstance":
+                # Verify whether second argument of isinstance is a valid type
+                self._check_isinstance_args(node)
+            # Built-in functions have no argument information.
+            return
+
+        if len(called.argnames()) != len(set(called.argnames())):
+            # Duplicate parameter name (see duplicate-argument).  We can't really
+            # make sense of the function call in this case, so just return.
+            return
+
+        # Build the set of keyword arguments, checking for duplicate keywords,
+        # and count the positional arguments.
+        call_site = astroid.arguments.CallSite.from_call(node)
+
+        # Warn about duplicated keyword arguments, such as `f=24, **{'f': 24}`
+        for keyword in call_site.duplicated_keywords:
+            self.add_message("repeated-keyword", node=node, args=(keyword,))
+
+        if call_site.has_invalid_arguments() or call_site.has_invalid_keywords():
+            # Can't make sense of this.
+            return
+
+        # Has the function signature changed in ways we cannot reliably detect?
+        if hasattr(called, "decorators") and decorated_with(
+            called, self.config.signature_mutators
+        ):
+            return
+
+        num_positional_args = len(call_site.positional_arguments)
+        keyword_args = list(call_site.keyword_arguments.keys())
+        overload_function = is_overload_stub(called)
+
+        # Determine if we don't have a context for our call and we use variadics.
+        node_scope = node.scope()
+        if isinstance(node_scope, (nodes.Lambda, nodes.FunctionDef)):
+            has_no_context_positional_variadic = _no_context_variadic_positional(
+                node, node_scope
+            )
+            has_no_context_keywords_variadic = _no_context_variadic_keywords(
+                node, node_scope
+            )
+        else:
+            has_no_context_positional_variadic = (
+                has_no_context_keywords_variadic
+            ) = False
+
+        # These are coming from the functools.partial implementation in astroid
+        already_filled_positionals = getattr(called, "filled_positionals", 0)
+        already_filled_keywords = getattr(called, "filled_keywords", {})
+
+        keyword_args += list(already_filled_keywords)
+        num_positional_args += implicit_args + already_filled_positionals
+
+        # Analyze the list of formal parameters.
+        args = list(itertools.chain(called.args.posonlyargs or (), called.args.args))
+        num_mandatory_parameters = len(args) - len(called.args.defaults)
+        parameters: List[List[Any]] = []
+        parameter_name_to_index = {}
+        for i, arg in enumerate(args):
+            if isinstance(arg, nodes.Tuple):
+                name = None
+                # Don't store any parameter names within the tuple, since those
+                # are not assignable from keyword arguments.
+            else:
+                assert isinstance(arg, nodes.AssignName)
+                # This occurs with:
+                #    def f( (a), (b) ): pass
+                name = arg.name
+                parameter_name_to_index[name] = i
+            if i >= num_mandatory_parameters:
+                defval = called.args.defaults[i - num_mandatory_parameters]
+            else:
+                defval = None
+            parameters.append([(name, defval), False])
+
+        kwparams = {}
+        for i, arg in enumerate(called.args.kwonlyargs):
+            if isinstance(arg, nodes.Keyword):
+                name = arg.arg
+            else:
+                assert isinstance(arg, nodes.AssignName)
+                name = arg.name
+            kwparams[name] = [called.args.kw_defaults[i], False]
+
+        self._check_argument_order(
+            node, call_site, called, [p[0][0] for p in parameters]
+        )
+
+        # 1. Match the positional arguments.
+        for i in range(num_positional_args):
+            if i < len(parameters):
+                parameters[i][1] = True
+            elif called.args.vararg is not None:
+                # The remaining positional arguments get assigned to the *args
+                # parameter.
+                break
+            elif not overload_function:
+                # Too many positional arguments.
+                self.add_message(
+                    "too-many-function-args", node=node, args=(callable_name,)
+                )
+                break
+
+        # 2. Match the keyword arguments.
+        for keyword in keyword_args:
+            if keyword in parameter_name_to_index:
+                i = parameter_name_to_index[keyword]
+                if parameters[i][1]:
+                    # Duplicate definition of function parameter.
+
+                    # Might be too hardcoded, but this can actually
+                    # happen when using str.format and `self` is passed
+                    # by keyword argument, as in `.format(self=self)`.
+                    # It's perfectly valid to so, so we're just skipping
+                    # it if that's the case.
+                    if not (keyword == "self" and called.qname() in STR_FORMAT):
+                        self.add_message(
+                            "redundant-keyword-arg",
+                            node=node,
+                            args=(keyword, callable_name),
+                        )
+                else:
+                    parameters[i][1] = True
+            elif keyword in kwparams:
+                if kwparams[keyword][1]:
+                    # Duplicate definition of function parameter.
+                    self.add_message(
+                        "redundant-keyword-arg",
+                        node=node,
+                        args=(keyword, callable_name),
+                    )
+                else:
+                    kwparams[keyword][1] = True
+            elif called.args.kwarg is not None:
+                # The keyword argument gets assigned to the **kwargs parameter.
+                pass
+            elif isinstance(
+                called, nodes.FunctionDef
+            ) and self._keyword_argument_is_in_all_decorator_returns(called, keyword):
+                pass
+            elif not overload_function:
+                # Unexpected keyword argument.
+                self.add_message(
+                    "unexpected-keyword-arg", node=node, args=(keyword, callable_name)
+                )
+
+        # 3. Match the **kwargs, if any.
+        if node.kwargs:
+            for i, [(name, defval), assigned] in enumerate(parameters):
+                # Assume that *kwargs provides values for all remaining
+                # unassigned named parameters.
+                if name is not None:
+                    parameters[i][1] = True
+                else:
+                    # **kwargs can't assign to tuples.
+                    pass
+
+        # Check that any parameters without a default have been assigned
+        # values.
+        for [(name, defval), assigned] in parameters:
+            if (defval is None) and not assigned:
+                display_name = "<tuple>" if name is None else repr(name)
+                if not has_no_context_positional_variadic and not overload_function:
+                    self.add_message(
+                        "no-value-for-parameter",
+                        node=node,
+                        args=(display_name, callable_name),
+                    )
+
+        for name, val in kwparams.items():
+            defval, assigned = val
+            if (
+                defval is None
+                and not assigned
+                and not has_no_context_keywords_variadic
+                and not overload_function
+            ):
+                self.add_message("missing-kwoa", node=node, args=(name, callable_name))
+
+    @staticmethod
+    def _keyword_argument_is_in_all_decorator_returns(
+        func: nodes.FunctionDef, keyword: str
+    ) -> bool:
+        """Check if the keyword argument exists in all signatures of the
+        return values of all decorators of the function.
+        """
+        if not func.decorators:
+            return False
+
+        for decorator in func.decorators.nodes:
+            inferred = safe_infer(decorator)
+
+            # If we can't infer the decorator we assume it satisfies consumes
+            # the keyword, so we don't raise false positives
+            if not inferred:
+                return True
+
+            # We only check arguments of function decorators
+            if not isinstance(inferred, nodes.FunctionDef):
+                return False
+
+            for return_value in inferred.infer_call_result():
+                # infer_call_result() returns nodes.Const.None for None return values
+                # so this also catches non-returning decorators
+                if not isinstance(return_value, nodes.FunctionDef):
+                    return False
+
+                # If the return value uses a kwarg the keyword will be consumed
+                if return_value.args.kwarg:
+                    continue
+
+                # Check if the keyword is another type of argument
+                if return_value.args.is_argument(keyword):
+                    continue
+
+                return False
+
+        return True
+
+    def _check_invalid_sequence_index(self, subscript: nodes.Subscript):
+        # Look for index operations where the parent is a sequence type.
+        # If the types can be determined, only allow indices to be int,
+        # slice or instances with __index__.
+        parent_type = safe_infer(subscript.value)
+        if not isinstance(
+            parent_type, (nodes.ClassDef, astroid.Instance)
+        ) or not has_known_bases(parent_type):
+            return None
+
+        # Determine what method on the parent this index will use
+        # The parent of this node will be a Subscript, and the parent of that
+        # node determines if the Subscript is a get, set, or delete operation.
+        if subscript.ctx is astroid.Store:
+            methodname = "__setitem__"
+        elif subscript.ctx is astroid.Del:
+            methodname = "__delitem__"
+        else:
+            methodname = "__getitem__"
+
+        # Check if this instance's __getitem__, __setitem__, or __delitem__, as
+        # appropriate to the statement, is implemented in a builtin sequence
+        # type. This way we catch subclasses of sequence types but skip classes
+        # that override __getitem__ and which may allow non-integer indices.
+        try:
+            methods = astroid.interpreter.dunder_lookup.lookup(parent_type, methodname)
+            if methods is astroid.Uninferable:
+                return None
+            itemmethod = methods[0]
+        except (
+            astroid.AttributeInferenceError,
+            IndexError,
+        ):
+            return None
+        if (
+            not isinstance(itemmethod, nodes.FunctionDef)
+            or itemmethod.root().name != "builtins"
+            or not itemmethod.parent
+            or itemmethod.parent.frame().name not in SEQUENCE_TYPES
+        ):
+            return None
+
+        # For ExtSlice objects coming from visit_extslice, no further
+        # inference is necessary, since if we got this far the ExtSlice
+        # is an error.
+        if isinstance(subscript.value, nodes.ExtSlice):
+            index_type = subscript.value
+        else:
+            index_type = safe_infer(subscript.slice)
+        if index_type is None or index_type is astroid.Uninferable:
+            return None
+        # Constants must be of type int
+        if isinstance(index_type, nodes.Const):
+            if isinstance(index_type.value, int):
+                return None
+        # Instance values must be int, slice, or have an __index__ method
+        elif isinstance(index_type, astroid.Instance):
+            if index_type.pytype() in {"builtins.int", "builtins.slice"}:
+                return None
+            try:
+                index_type.getattr("__index__")
+                return None
+            except astroid.NotFoundError:
+                pass
+        elif isinstance(index_type, nodes.Slice):
+            # A slice can be present
+            # here after inferring the index node, which could
+            # be a `slice(...)` call for instance.
+            return self._check_invalid_slice_index(index_type)
+
+        # Anything else is an error
+        self.add_message("invalid-sequence-index", node=subscript)
+        return None
+
+    def _check_not_callable(
+        self, node: nodes.Call, inferred_call: Optional[nodes.NodeNG]
+    ) -> None:
+        """Checks to see if the not-callable message should be emitted.
+
+        Only functions, generators and objects defining __call__ are "callable"
+        We ignore instances of descriptors since astroid cannot properly handle them yet
+        """
+        # Handle uninferable calls
+        if not inferred_call or inferred_call.callable():
+            self._check_uninferable_call(node)
+            return
+
+        if not isinstance(inferred_call, astroid.Instance):
+            self.add_message("not-callable", node=node, args=node.func.as_string())
+            return
+
+        # Don't emit if we can't make sure this object is callable.
+        if not has_known_bases(inferred_call):
+            return
+
+        if inferred_call.parent and isinstance(inferred_call.scope(), nodes.ClassDef):
+            # Ignore descriptor instances
+            if "__get__" in inferred_call.locals:
+                return
+            # NamedTuple instances are callable
+            if inferred_call.qname() == "typing.NamedTuple":
+                return
+
+        self.add_message("not-callable", node=node, args=node.func.as_string())
+
+    @check_messages("invalid-sequence-index")
+    def visit_extslice(self, node: nodes.ExtSlice) -> None:
+        if not node.parent or not hasattr(node.parent, "value"):
+            return None
+        # Check extended slice objects as if they were used as a sequence
+        # index to check if the object being sliced can support them
+        return self._check_invalid_sequence_index(node.parent)
+
+    def _check_invalid_slice_index(self, node: nodes.Slice) -> None:
+        # Check the type of each part of the slice
+        invalid_slices_nodes: List[nodes.NodeNG] = []
+        for index in (node.lower, node.upper, node.step):
+            if index is None:
+                continue
+
+            index_type = safe_infer(index)
+            if index_type is None or index_type is astroid.Uninferable:
+                continue
+
+            # Constants must be of type int or None
+            if isinstance(index_type, nodes.Const):
+                if isinstance(index_type.value, (int, type(None))):
+                    continue
+            # Instance values must be of type int, None or an object
+            # with __index__
+            elif isinstance(index_type, astroid.Instance):
+                if index_type.pytype() in {"builtins.int", "builtins.NoneType"}:
+                    continue
+
+                try:
+                    index_type.getattr("__index__")
+                    return
+                except astroid.NotFoundError:
+                    pass
+            invalid_slices_nodes.append(index)
+
+        if not invalid_slices_nodes:
+            return
+
+        # Anything else is an error, unless the object that is indexed
+        # is a custom object, which knows how to handle this kind of slices
+        parent = node.parent
+        if isinstance(parent, nodes.ExtSlice):
+            parent = parent.parent
+        if isinstance(parent, nodes.Subscript):
+            inferred = safe_infer(parent.value)
+            if inferred is None or inferred is astroid.Uninferable:
+                # Don't know what this is
+                return
+            known_objects = (
+                nodes.List,
+                nodes.Dict,
+                nodes.Tuple,
+                astroid.objects.FrozenSet,
+                nodes.Set,
+            )
+            if not isinstance(inferred, known_objects):
+                # Might be an instance that knows how to handle this slice object
+                return
+        for snode in invalid_slices_nodes:
+            self.add_message("invalid-slice-index", node=snode)
+
+    @check_messages("not-context-manager")
+    def visit_with(self, node: nodes.With) -> None:
+        for ctx_mgr, _ in node.items:
+            context = astroid.context.InferenceContext()
+            inferred = safe_infer(ctx_mgr, context=context)
+            if inferred is None or inferred is astroid.Uninferable:
+                continue
+
+            if isinstance(inferred, astroid.bases.Generator):
+                # Check if we are dealing with a function decorated
+                # with contextlib.contextmanager.
+                if decorated_with(
+                    inferred.parent, self.config.contextmanager_decorators
+                ):
+                    continue
+                # If the parent of the generator is not the context manager itself,
+                # that means that it could have been returned from another
+                # function which was the real context manager.
+                # The following approach is more of a hack rather than a real
+                # solution: walk all the inferred statements for the
+                # given *ctx_mgr* and if you find one function scope
+                # which is decorated, consider it to be the real
+                # manager and give up, otherwise emit not-context-manager.
+                # See the test file for not_context_manager for a couple
+                # of self explaining tests.
+
+                # Retrieve node from all previously visited nodes in the
+                # inference history
+                context_path_names: Iterator[Any] = filter(
+                    None, _unflatten(context.path)
+                )
+                inferred_paths = _flatten_container(
+                    safe_infer(path) for path in context_path_names
+                )
+                for inferred_path in inferred_paths:
+                    if not inferred_path:
+                        continue
+                    scope = inferred_path.scope()
+                    if not isinstance(scope, nodes.FunctionDef):
+                        continue
+                    if decorated_with(scope, self.config.contextmanager_decorators):
+                        break
+                else:
+                    self.add_message(
+                        "not-context-manager", node=node, args=(inferred.name,)
+                    )
+            else:
+                try:
+                    inferred.getattr("__enter__")
+                    inferred.getattr("__exit__")
+                except astroid.NotFoundError:
+                    if isinstance(inferred, astroid.Instance):
+                        # If we do not know the bases of this class,
+                        # just skip it.
+                        if not has_known_bases(inferred):
+                            continue
+                        # Just ignore mixin classes.
+                        if self.config.ignore_mixin_members:
+                            if inferred.name[-5:].lower() == "mixin":
+                                continue
+
+                    self.add_message(
+                        "not-context-manager", node=node, args=(inferred.name,)
+                    )
+
+    @check_messages("invalid-unary-operand-type")
+    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
+        """Detect TypeErrors for unary operands."""
+
+        for error in node.type_errors():
+            # Let the error customize its output.
+            self.add_message("invalid-unary-operand-type", args=str(error), node=node)
+
+    @check_messages("unsupported-binary-operation")
+    def visit_binop(self, node: nodes.BinOp) -> None:
+        if node.op == "|":
+            self._detect_unsupported_alternative_union_syntax(node)
+
+    def _detect_unsupported_alternative_union_syntax(self, node: nodes.BinOp) -> None:
+        """Detect if unsupported alternative Union syntax (PEP 604) was used."""
+        if self._py310_plus:  # 310+ supports the new syntax
+            return
+
+        if isinstance(
+            node.parent, TYPE_ANNOTATION_NODES_TYPES
+        ) and not is_postponed_evaluation_enabled(node):
+            # Use in type annotations only allowed if
+            # postponed evaluation is enabled.
+            self._check_unsupported_alternative_union_syntax(node)
+
+        if isinstance(
+            node.parent,
+            (
+                nodes.Assign,
+                nodes.Call,
+                nodes.Keyword,
+                nodes.Dict,
+                nodes.Tuple,
+                nodes.Set,
+                nodes.List,
+                nodes.BinOp,
+            ),
+        ):
+            # Check other contexts the syntax might appear, but are invalid.
+            # Make sure to filter context if postponed evaluation is enabled
+            # and parent is allowed node type.
+            allowed_nested_syntax = False
+            if is_postponed_evaluation_enabled(node):
+                parent_node = node.parent
+                while True:
+                    if isinstance(parent_node, TYPE_ANNOTATION_NODES_TYPES):
+                        allowed_nested_syntax = True
+                        break
+                    parent_node = parent_node.parent
+                    if isinstance(parent_node, nodes.Module):
+                        break
+            if not allowed_nested_syntax:
+                self._check_unsupported_alternative_union_syntax(node)
+
+    def _check_unsupported_alternative_union_syntax(self, node: nodes.BinOp) -> None:
+        """Check if left or right node is of type `type`."""
+        msg = "unsupported operand type(s) for |"
+        for n in (node.left, node.right):
+            n = astroid.helpers.object_type(n)
+            if isinstance(n, nodes.ClassDef) and is_classdef_type(n):
+                self.add_message("unsupported-binary-operation", args=msg, node=node)
+                break
+
+    @check_messages("unsupported-binary-operation")
+    def _visit_binop(self, node: nodes.BinOp) -> None:
+        """Detect TypeErrors for binary arithmetic operands."""
+        self._check_binop_errors(node)
+
+    @check_messages("unsupported-binary-operation")
+    def _visit_augassign(self, node: nodes.AugAssign) -> None:
+        """Detect TypeErrors for augmented binary arithmetic operands."""
+        self._check_binop_errors(node)
+
+    def _check_binop_errors(self, node):
+        for error in node.type_errors():
+            # Let the error customize its output.
+            if any(
+                isinstance(obj, nodes.ClassDef) and not has_known_bases(obj)
+                for obj in (error.left_type, error.right_type)
+            ):
+                continue
+            self.add_message("unsupported-binary-operation", args=str(error), node=node)
+
+    def _check_membership_test(self, node):
+        if is_inside_abstract_class(node):
+            return
+        if is_comprehension(node):
+            return
+        inferred = safe_infer(node)
+        if inferred is None or inferred is astroid.Uninferable:
+            return
+        if not supports_membership_test(inferred):
+            self.add_message(
+                "unsupported-membership-test", args=node.as_string(), node=node
+            )
+
+    @check_messages("unsupported-membership-test")
+    def visit_compare(self, node: nodes.Compare) -> None:
+        if len(node.ops) != 1:
+            return
+
+        op, right = node.ops[0]
+        if op in {"in", "not in"}:
+            self._check_membership_test(right)
+
+    @check_messages(
+        "unsubscriptable-object",
+        "unsupported-assignment-operation",
+        "unsupported-delete-operation",
+        "unhashable-dict-key",
+        "invalid-sequence-index",
+        "invalid-slice-index",
+    )
+    def visit_subscript(self, node: nodes.Subscript) -> None:
+        self._check_invalid_sequence_index(node)
+
+        supported_protocol: Optional[Callable[[Any, Any], bool]] = None
+        if isinstance(node.value, (nodes.ListComp, nodes.DictComp)):
+            return
+
+        if isinstance(node.value, nodes.Dict):
+            # Assert dict key is hashable
+            inferred = safe_infer(node.slice)
+            if inferred and inferred != astroid.Uninferable:
+                try:
+                    hash_fn = next(inferred.igetattr("__hash__"))
+                except astroid.InferenceError:
+                    pass
+                else:
+                    if getattr(hash_fn, "value", True) is None:
+                        self.add_message("unhashable-dict-key", node=node.value)
+
+        if node.ctx == astroid.Load:
+            supported_protocol = supports_getitem
+            msg = "unsubscriptable-object"
+        elif node.ctx == astroid.Store:
+            supported_protocol = supports_setitem
+            msg = "unsupported-assignment-operation"
+        elif node.ctx == astroid.Del:
+            supported_protocol = supports_delitem
+            msg = "unsupported-delete-operation"
+
+        if isinstance(node.value, nodes.SetComp):
+            self.add_message(msg, args=node.value.as_string(), node=node.value)
+            return
+
+        if is_inside_abstract_class(node):
+            return
+
+        inferred = safe_infer(node.value)
+
+        if inferred is None or inferred is astroid.Uninferable:
+            return
+
+        if getattr(inferred, "decorators", None):
+            first_decorator = astroid.helpers.safe_infer(inferred.decorators.nodes[0])
+            if isinstance(first_decorator, nodes.ClassDef):
+                inferred = first_decorator.instantiate_class()
+            else:
+                return  # It would be better to handle function
+                # decorators, but let's start slow.
+
+        if (
+            supported_protocol
+            and not supported_protocol(inferred, node)
+            and not utils.in_type_checking_block(node)
+        ):
+            self.add_message(msg, args=node.value.as_string(), node=node.value)
+
+    @check_messages("dict-items-missing-iter")
+    def visit_for(self, node: nodes.For) -> None:
+        if not isinstance(node.target, nodes.Tuple):
+            # target is not a tuple
+            return
+        if not len(node.target.elts) == 2:
+            # target is not a tuple of two elements
+            return
+
+        iterable = node.iter
+        if not isinstance(iterable, nodes.Name):
+            # it's not a bare variable
+            return
+
+        inferred = safe_infer(iterable)
+        if not inferred:
+            return
+        if not isinstance(inferred, nodes.Dict):
+            # the iterable is not a dict
+            return
+
+        if all(isinstance(i[0], nodes.Tuple) for i in inferred.items):
+            # if all keys are tuples
+            return
+
+        self.add_message("dict-iter-missing-items", node=node)
+
+
+class IterableChecker(BaseChecker):
+    """Checks for non-iterables used in an iterable context.
+
+    Contexts include:
+    - for-statement
+    - starargs in function call
+    - `yield from`-statement
+    - list, dict and set comprehensions
+    - generator expressions
+    Also checks for non-mappings in function call kwargs.
+    """
+
+    __implements__ = (IAstroidChecker,)
+    name = "typecheck"
+
+    msgs = {
+        "E1133": (
+            "Non-iterable value %s is used in an iterating context",
+            "not-an-iterable",
+            "Used when a non-iterable value is used in place where "
+            "iterable is expected",
+        ),
+        "E1134": (
+            "Non-mapping value %s is used in a mapping context",
+            "not-a-mapping",
+            "Used when a non-mapping value is used in place where "
+            "mapping is expected",
+        ),
+    }
+
+    @staticmethod
+    def _is_asyncio_coroutine(node):
+        if not isinstance(node, nodes.Call):
+            return False
+
+        inferred_func = safe_infer(node.func)
+        if not isinstance(inferred_func, nodes.FunctionDef):
+            return False
+        if not inferred_func.decorators:
+            return False
+        for decorator in inferred_func.decorators.nodes:
+            inferred_decorator = safe_infer(decorator)
+            if not isinstance(inferred_decorator, nodes.FunctionDef):
+                continue
+            if inferred_decorator.qname() != ASYNCIO_COROUTINE:
+                continue
+            return True
+        return False
+
+    def _check_iterable(self, node, check_async=False):
+        if is_inside_abstract_class(node):
+            return
+        inferred = safe_infer(node)
+        if not inferred or is_comprehension(inferred):
+            return
+        if not is_iterable(inferred, check_async=check_async):
+            self.add_message("not-an-iterable", args=node.as_string(), node=node)
+
+    def _check_mapping(self, node):
+        if is_inside_abstract_class(node):
+            return
+        if isinstance(node, nodes.DictComp):
+            return
+        inferred = safe_infer(node)
+        if inferred is None or inferred is astroid.Uninferable:
+            return
+        if not is_mapping(inferred):
+            self.add_message("not-a-mapping", args=node.as_string(), node=node)
+
+    @check_messages("not-an-iterable")
+    def visit_for(self, node: nodes.For) -> None:
+        self._check_iterable(node.iter)
+
+    @check_messages("not-an-iterable")
+    def visit_asyncfor(self, node: nodes.AsyncFor) -> None:
+        self._check_iterable(node.iter, check_async=True)
+
+    @check_messages("not-an-iterable")
+    def visit_yieldfrom(self, node: nodes.YieldFrom) -> None:
+        if self._is_asyncio_coroutine(node.value):
+            return
+        self._check_iterable(node.value)
+
+    @check_messages("not-an-iterable", "not-a-mapping")
+    def visit_call(self, node: nodes.Call) -> None:
+        for stararg in node.starargs:
+            self._check_iterable(stararg.value)
+        for kwarg in node.kwargs:
+            self._check_mapping(kwarg.value)
+
+    @check_messages("not-an-iterable")
+    def visit_listcomp(self, node: nodes.ListComp) -> None:
+        for gen in node.generators:
+            self._check_iterable(gen.iter, check_async=gen.is_async)
+
+    @check_messages("not-an-iterable")
+    def visit_dictcomp(self, node: nodes.DictComp) -> None:
+        for gen in node.generators:
+            self._check_iterable(gen.iter, check_async=gen.is_async)
+
+    @check_messages("not-an-iterable")
+    def visit_setcomp(self, node: nodes.SetComp) -> None:
+        for gen in node.generators:
+            self._check_iterable(gen.iter, check_async=gen.is_async)
+
+    @check_messages("not-an-iterable")
+    def visit_generatorexp(self, node: nodes.GeneratorExp) -> None:
+        for gen in node.generators:
+            self._check_iterable(gen.iter, check_async=gen.is_async)
+
+    @check_messages("await-outside-async")
+    def visit_await(self, node: nodes.Await) -> None:
+        self._check_await_outside_coroutine(node)
+
+    def _check_await_outside_coroutine(self, node: nodes.Await) -> None:
+        node_scope = node.scope()
+        while not isinstance(node_scope, nodes.Module):
+            if isinstance(node_scope, nodes.AsyncFunctionDef):
+                return
+            if isinstance(node_scope, nodes.FunctionDef):
+                break
+            node_scope = node_scope.parent.scope()
+        self.add_message("await-outside-async", node=node)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(TypeChecker(linter))
+    linter.register_checker(IterableChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/unicode.py b/myenv/lib/python3.9/site-packages/pylint/checkers/unicode.py
new file mode 100644
index 0000000..8939524
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/unicode.py
@@ -0,0 +1,536 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Unicode and some other ASCII characters can be used to create programs that run
+much different compared to what a human reader would expect from them.
+
+PEP 672 lists some examples.
+See: https://www.python.org/dev/peps/pep-0672/
+
+The following checkers are intended to make users are aware of these issues.
+"""
+import codecs
+import contextlib
+import io
+import re
+from collections import OrderedDict
+from functools import lru_cache
+from tokenize import detect_encoding
+from typing import Dict, Iterable, NamedTuple, Tuple, TypeVar
+
+from astroid import nodes
+
+import pylint.checkers
+import pylint.interfaces
+import pylint.lint
+
+_StrLike = TypeVar("_StrLike", str, bytes)
+
+# Based on:
+# https://golangexample.com/go-linter-which-checks-for-dangerous-unicode-character-sequences/
+# We use '\u' because it doesn't require a map lookup and is therefore faster
+BIDI_UNICODE = [
+    "\u202A",  # \N{LEFT-TO-RIGHT EMBEDDING}
+    "\u202B",  # \N{RIGHT-TO-LEFT EMBEDDING}
+    "\u202C",  # \N{POP DIRECTIONAL FORMATTING}
+    "\u202D",  # \N{LEFT-TO-RIGHT OVERRIDE}
+    "\u202E",  # \N{RIGHT-TO-LEFT OVERRIDE}
+    "\u2066",  # \N{LEFT-TO-RIGHT ISOLATE}
+    "\u2067",  # \N{RIGHT-TO-LEFT ISOLATE}
+    "\u2068",  # \N{FIRST STRONG ISOLATE}
+    "\u2069",  # \N{POP DIRECTIONAL ISOLATE}
+    # The following was part of PEP 672:
+    # https://www.python.org/dev/peps/pep-0672/
+    # so the list above might not be complete
+    "\u200F",  # \n{RIGHT-TO-LEFT MARK}
+    # We don't use
+    #   "\u200E" # \n{LEFT-TO-RIGHT MARK}
+    # as this is the default for latin files and can't be used
+    # to hide code
+]
+
+
+class _BadChar(NamedTuple):
+    """Representation of an ASCII char considered bad."""
+
+    name: str
+    unescaped: str
+    escaped: str
+    code: str
+    help_text: str
+
+    def description(self) -> str:
+        """Used for the detailed error message description."""
+        return (
+            f"Invalid unescaped character {self.name}, "
+            f'use "{self.escaped}" instead.'
+        )
+
+    def human_code(self) -> str:
+        """Used to generate the human readable error message."""
+        return f"invalid-character-{self.name}"
+
+
+# Based on https://www.python.org/dev/peps/pep-0672/
+BAD_CHARS = [
+    _BadChar(
+        "backspace",
+        "\b",
+        "\\b",
+        "E2510",
+        (
+            "Moves the cursor back, so the character after it will overwrite the "
+            "character before."
+        ),
+    ),
+    _BadChar(
+        "carriage-return",
+        "\r",
+        "\\r",
+        "E2511",
+        (
+            "Moves the cursor to the start of line, subsequent characters overwrite "
+            "the start of the line."
+        ),
+    ),
+    _BadChar(
+        "sub",
+        "\x1A",
+        "\\x1A",
+        "E2512",
+        (
+            "Ctrl+Z “End of text” on Windows. Some programs (such as type) ignore "
+            "the rest of the file after it."
+        ),
+    ),
+    _BadChar(
+        "esc",
+        "\x1B",
+        "\\x1B",
+        "E2513",
+        (
+            "Commonly initiates escape codes which allow arbitrary control "
+            "of the terminal."
+        ),
+    ),
+    _BadChar(
+        "nul",
+        "\0",
+        "\\0",
+        "E2514",
+        "Mostly end of input for python.",
+    ),
+    _BadChar(
+        # Zero Width with Space. At the time of writing not accepted by Python.
+        # But used in Trojan Source Examples, so still included and tested for.
+        "zero-width-space",
+        "\u200B",  # \n{ZERO WIDTH SPACE}
+        "\\u200B",
+        "E2515",
+        "Invisible space character could hide real code execution.",
+    ),
+]
+BAD_ASCII_SEARCH_DICT = {char.unescaped: char for char in BAD_CHARS}
+
+
+def _line_length(line: _StrLike, codec: str) -> int:
+    """Get the length of a string like line as displayed in an editor."""
+    if isinstance(line, bytes):
+        decoded = _remove_bom(line, codec).decode(codec, "replace")
+    else:
+        decoded = line
+
+    stripped = decoded.rstrip("\n")
+
+    if stripped != decoded:
+        stripped = stripped.rstrip("\r")
+
+    return len(stripped)
+
+
+def _map_positions_to_result(
+    line: _StrLike,
+    search_dict: Dict[_StrLike, _BadChar],
+    new_line: _StrLike,
+    byte_str_length: int = 1,
+) -> Dict[int, _BadChar]:
+    """Get all occurrences of search dict keys within line.
+
+    Ignores Windows end of line and can handle bytes as well as string.
+    Also takes care of encodings for which the length of an encoded code point does not
+    default to 8 Bit.
+    """
+
+    result: Dict[int, _BadChar] = {}
+
+    for search_for, char in search_dict.items():
+        if search_for not in line:
+            continue
+
+        # Special Handling for Windows '\r\n'
+        if char.unescaped == "\r" and line.endswith(new_line):
+            ignore_pos = len(line) - 2 * byte_str_length
+        else:
+            ignore_pos = None
+
+        start = 0
+        pos = line.find(search_for, start)
+        while pos > 0:
+            if pos != ignore_pos:
+                # Calculate the column
+                col = int(pos / byte_str_length)
+                result[col] = char
+            start = pos + 1
+            pos = line.find(search_for, start)
+
+    return result
+
+
+UNICODE_BOMS = {
+    "utf-8": codecs.BOM_UTF8,
+    "utf-16": codecs.BOM_UTF16,
+    "utf-32": codecs.BOM_UTF32,
+    "utf-16le": codecs.BOM_UTF16_LE,
+    "utf-16be": codecs.BOM_UTF16_BE,
+    "utf-32le": codecs.BOM_UTF32_LE,
+    "utf-32be": codecs.BOM_UTF32_BE,
+}
+BOM_SORTED_TO_CODEC = OrderedDict(
+    # Sorted by length of BOM of each codec
+    (UNICODE_BOMS[codec], codec)
+    for codec in ("utf-32le", "utf-32be", "utf-8", "utf-16le", "utf-16be")
+)
+
+UTF_NAME_REGEX_COMPILED = re.compile(
+    "utf[ -]?(8|16|32)[ -]?(le|be|)?(sig)?", flags=re.IGNORECASE
+)
+
+
+def _normalize_codec_name(codec: str) -> str:
+    """Make sure the codec name is always given as defined in the BOM dict."""
+    return UTF_NAME_REGEX_COMPILED.sub(r"utf-\1\2", codec).lower()
+
+
+def _remove_bom(encoded: bytes, encoding: str) -> bytes:
+    """Remove the bom if given from a line."""
+    if not encoding.startswith("utf"):
+        return encoded
+    bom = UNICODE_BOMS[encoding]
+    if encoded.startswith(bom):
+        return encoded[len(bom) :]
+    return encoded
+
+
+def _encode_without_bom(string: str, encoding: str) -> bytes:
+    """Encode a string but remove the BOM."""
+    return _remove_bom(string.encode(encoding), encoding)
+
+
+def _byte_to_str_length(codec: str) -> int:
+    """Return how many byte are usually(!) a character point."""
+    if codec.startswith("utf-32"):
+        return 4
+    if codec.startswith("utf-16"):
+        return 2
+
+    return 1
+
+
+@lru_cache(maxsize=1000)
+def _cached_encode_search(string: str, encoding: str) -> bytes:
+    """A cached version of encode used for search pattern."""
+    return _encode_without_bom(string, encoding)
+
+
+def _fix_utf16_32_line_stream(steam: Iterable[bytes], codec: str) -> Iterable[bytes]:
+    """Handle line ending for UTF16 and UTF32 correctly.
+
+    Currently Python simply strips the required zeros after \n after the
+    line ending. Leading to lines that can't be decoded propery
+    """
+    if not codec.startswith("utf-16") and not codec.startswith("utf-32"):
+        yield from steam
+    else:
+        # First we get all the bytes in memory
+        content = b"".join(line for line in steam)
+
+        new_line = _cached_encode_search("\n", codec)
+
+        # Now we split the line by the real new line in the correct encoding
+        # we can't use split as it would strip the \n that we need
+        start = 0
+        while True:
+            pos = content.find(new_line, start)
+            if pos >= 0:
+                yield content[start : pos + len(new_line)]
+            else:
+                # Yield the rest and finish
+                if content[start:]:
+                    yield content[start:]
+                break
+
+            start = pos + len(new_line)
+
+
+def extract_codec_from_bom(first_line: bytes) -> str:
+    """Try to extract the codec (unicode only) by checking for the BOM.
+
+    For details about BOM see https://unicode.org/faq/utf_bom.html#BOM
+
+    Args:
+        first_line: the first line of a file
+
+    Returns:
+        a codec name
+
+    Raises:
+        ValueError: if no codec was found
+    """
+    for bom, codec in BOM_SORTED_TO_CODEC.items():
+        if first_line.startswith(bom):
+            return codec
+
+    raise ValueError("No BOM found. Could not detect Unicode codec.")
+
+
+class UnicodeChecker(pylint.checkers.BaseChecker):
+    """Check characters that could be used to hide bad code to humans.
+
+    This includes:
+
+    - Bidirectional Unicode (see https://trojansource.codes/)
+
+    - Bad ASCII characters (see PEP672)
+
+        If a programmer requires to use such a character they should use the escaped
+        version, that is also much easier to read and does not depend on the editor used.
+
+    The Checker also includes a check that UTF-16 and UTF-32 are not used to encode
+    Python files.
+
+    At the time of writing Python supported only UTF-8. See
+    https://stackoverflow.com/questions/69897842/ and https://bugs.python.org/issue1503789
+    for background.
+    """
+
+    __implements__ = pylint.interfaces.IRawChecker
+    priority = -1
+
+    name = "unicode_checker"
+
+    msgs = {
+        "E2501": (
+            # This error will be only displayed to users once Python Supports
+            # UTF-16/UTF-32 (if at all)
+            "UTF-16 and UTF-32 aren't backward compatible. Use UTF-8 instead",
+            "invalid-unicode-codec",
+            (
+                "For compatibility use UTF-8 instead of UTF-16/UTF-32. "
+                "See also https://bugs.python.org/issue1503789 for a history "
+                "of this issue. And "
+                "https://softwareengineering.stackexchange.com/questions/102205/should-utf-16-be-considered-harmful "
+                "for some possible problems when using UTF-16 for instance."
+            ),
+        ),
+        "E2502": (
+            (
+                "Contains control characters that can permit obfuscated code "
+                "executed differently than displayed"
+            ),
+            "bidirectional-unicode",
+            (
+                "bidirectional unicode are typically not displayed characters required "
+                "to display right-to-left (RTL) script "
+                "(i.e. Chinese, Japanese, Arabic, Hebrew, ...) correctly. "
+                "So can you trust this code? "
+                "Are you sure it displayed correctly in all editors? "
+                "If you did not write it or your language is not RTL,"
+                " remove the special characters, as they could be used to trick you into executing code, "
+                "that does something else than what it looks like.\n"
+                "More Information:\n"
+                "https://en.wikipedia.org/wiki/Bidirectional_text\n"
+                "https://trojansource.codes/"
+            ),
+        ),
+        "C2503": (
+            "PEP8 recommends UTF-8 as encoding for Python files",
+            "bad-file-encoding",
+            (
+                "PEP8 recommends UTF-8 default encoding for Python files. See "
+                "https://www.python.org/dev/peps/pep-0008/#id20"
+            ),
+        ),
+        **{
+            bad_char.code: (
+                bad_char.description(),
+                bad_char.human_code(),
+                bad_char.help_text,
+            )
+            for bad_char in BAD_CHARS
+        },
+    }
+
+    @staticmethod
+    def _is_invalid_codec(codec: str) -> bool:
+        return codec.startswith("utf-16") or codec.startswith("utf-32")
+
+    @staticmethod
+    def _is_unicode(codec: str) -> bool:
+        return codec.startswith("utf")
+
+    @classmethod
+    def _find_line_matches(cls, line: bytes, codec: str) -> Dict[int, _BadChar]:
+        """Find all matches of BAD_CHARS within line.
+
+        Args:
+            line: the input
+            codec: that will be used to convert line/or search string into
+
+        Return:
+            A dictionary with the column offset and the BadASCIIChar
+        """
+        # We try to decode in Unicode to get the correct column offset
+        # if we would use bytes, it could be off because UTF-8 has no fixed length
+        try:
+            line_search = line.decode(codec, errors="strict")
+            search_dict = BAD_ASCII_SEARCH_DICT
+            return _map_positions_to_result(line_search, search_dict, "\n")
+        except UnicodeDecodeError:
+            # If we can't decode properly, we simply use bytes, even so the column offsets
+            # might be wrong a bit, but it is still better then nothing
+            line_search_byte = line
+            search_dict_byte: Dict[bytes, _BadChar] = {}
+            for char in BAD_CHARS:
+                # Some characters might not exist in all encodings
+                with contextlib.suppress(UnicodeDecodeError):
+                    search_dict_byte[
+                        _cached_encode_search(char.unescaped, codec)
+                    ] = char
+
+            return _map_positions_to_result(
+                line_search_byte,
+                search_dict_byte,
+                _cached_encode_search("\n", codec),
+                byte_str_length=_byte_to_str_length(codec),
+            )
+
+    @staticmethod
+    def _determine_codec(stream: io.BytesIO) -> Tuple[str, int]:
+        """Determine the codec from the given stream.
+
+        first tries https://www.python.org/dev/peps/pep-0263/
+        and if this fails also checks for BOMs of UTF-16 and UTF-32
+        to be future-proof.
+
+        Args:
+            stream: The byte stream to analyse
+
+        Returns: A tuple consisting of:
+                  - normalized codec name
+                  - the line in which the codec was found
+
+        Raises:
+            SyntaxError: if failing to detect codec
+        """
+        try:
+            # First try to detect encoding with PEP 263
+            # Doesn't work with UTF-16/32 at the time of writing
+            # see https://bugs.python.org/issue1503789
+            codec, lines = detect_encoding(stream.readline)
+
+            # lines are empty if UTF-8 BOM is found
+            codec_definition_line = len(lines) or 1
+        except SyntaxError as e:
+            # Codec could not be detected by Python, we try manually to check for
+            # UTF 16/32 BOMs, which aren't supported by Python at the time of writing.
+            # This is only included to be future save and handle these codecs as well
+            stream.seek(0)
+            try:
+                codec = extract_codec_from_bom(stream.readline())
+                codec_definition_line = 1
+            except ValueError as ve:
+                # Failed to detect codec, so the syntax error originated not from
+                # UTF16/32 codec usage. So simply raise the error again.
+                raise e from ve
+
+        return _normalize_codec_name(codec), codec_definition_line
+
+    def _check_codec(self, codec: str, codec_definition_line: int) -> None:
+        """Check validity of the codec."""
+        if codec != "utf-8":
+            msg = "bad-file-encoding"
+            if self._is_invalid_codec(codec):
+                msg = "invalid-unicode-codec"
+            self.add_message(
+                msg,
+                # Currently Nodes will lead to crashes of pylint
+                # node=node,
+                line=codec_definition_line,
+                end_lineno=codec_definition_line,
+                confidence=pylint.interfaces.HIGH,
+                col_offset=None,
+                end_col_offset=None,
+            )
+
+    def _check_invalid_chars(self, line: bytes, lineno: int, codec: str) -> None:
+        """Look for chars considered bad."""
+        matches = self._find_line_matches(line, codec)
+        for col, char in matches.items():
+            self.add_message(
+                char.human_code(),
+                # Currently Nodes will lead to crashes of pylint
+                # node=node,
+                line=lineno,
+                end_lineno=lineno,
+                confidence=pylint.interfaces.HIGH,
+                col_offset=col + 1,
+                end_col_offset=col + len(char.unescaped) + 1,
+            )
+
+    def _check_bidi_chars(self, line: bytes, lineno: int, codec: str) -> None:
+        """Look for Bidirectional Unicode, if we use unicode."""
+        if not self._is_unicode(codec):
+            return
+        for dangerous in BIDI_UNICODE:
+            if _cached_encode_search(dangerous, codec) in line:
+                # Note that we don't add a col_offset on purpose:
+                #   Using these unicode characters it depends on the editor
+                #   how it displays the location of characters in the line.
+                #   So we mark the complete line.
+                self.add_message(
+                    "bidirectional-unicode",
+                    # Currently Nodes will lead to crashes of pylint
+                    # node=node,
+                    line=lineno,
+                    end_lineno=lineno,
+                    # We mark the complete line, as bidi controls make it hard
+                    # to determine the correct cursor position within an editor
+                    col_offset=0,
+                    end_col_offset=_line_length(line, codec),
+                    confidence=pylint.interfaces.HIGH,
+                )
+                # We look for bidirectional unicode only once per line
+                # as we mark the complete line anyway
+                break
+
+    def process_module(self, node: nodes.Module) -> None:
+        """Perform the actual check by checking module stream."""
+        with node.stream() as stream:
+            codec, codec_line = self._determine_codec(stream)
+            self._check_codec(codec, codec_line)
+
+            stream.seek(0)
+
+            # Check for invalid content (controls/chars)
+            for (lineno, line) in enumerate(
+                _fix_utf16_32_line_stream(stream, codec), start=1
+            ):
+                if lineno == 1:
+                    line = _remove_bom(line, codec)
+                self._check_bidi_chars(line, lineno, codec)
+                self._check_invalid_chars(line, lineno, codec)
+
+
+def register(linter: pylint.lint.PyLinter) -> None:
+    linter.register_checker(UnicodeChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/unsupported_version.py b/myenv/lib/python3.9/site-packages/pylint/checkers/unsupported_version.py
new file mode 100644
index 0000000..d63d4fb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/unsupported_version.py
@@ -0,0 +1,86 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Checker for features used that are not supported by all python versions
+indicated by the py-version setting.
+"""
+
+
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import (
+    check_messages,
+    safe_infer,
+    uninferable_final_decorators,
+)
+from pylint.interfaces import IAstroidChecker
+from pylint.utils import get_global_option
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class UnsupportedVersionChecker(BaseChecker):
+    """Checker for features that are not supported by all python versions
+    indicated by the py-version setting.
+    """
+
+    __implements__ = (IAstroidChecker,)
+    name = "unsupported_version"
+    msgs = {
+        "W2601": (
+            "F-strings are not supported by all versions included in the py-version setting",
+            "using-f-string-in-unsupported-version",
+            "Used when the py-version set by the user is lower than 3.6 and pylint encounters "
+            "a f-string.",
+        ),
+        "W2602": (
+            "typing.final is not supported by all versions included in the py-version setting",
+            "using-final-decorator-in-unsupported-version",
+            "Used when the py-version set by the user is lower than 3.8 and pylint encounters "
+            "a ``typing.final`` decorator.",
+        ),
+    }
+
+    def open(self) -> None:
+        """Initialize visit variables and statistics."""
+        py_version = get_global_option(self, "py-version")
+        self._py36_plus = py_version >= (3, 6)
+        self._py38_plus = py_version >= (3, 8)
+
+    @check_messages("using-f-string-in-unsupported-version")
+    def visit_joinedstr(self, node: nodes.JoinedStr) -> None:
+        """Check f-strings."""
+        if not self._py36_plus:
+            self.add_message("using-f-string-in-unsupported-version", node=node)
+
+    @check_messages("using-final-decorator-in-unsupported-version")
+    def visit_decorators(self, node: nodes.Decorators) -> None:
+        """Check decorators."""
+        self._check_typing_final(node)
+
+    def _check_typing_final(self, node: nodes.Decorators) -> None:
+        """Add a message when the `typing.final` decorator is used and the
+        py-version is lower than 3.8
+        """
+        if self._py38_plus:
+            return
+
+        decorators = []
+        for decorator in node.get_children():
+            inferred = safe_infer(decorator)
+            if inferred and inferred.qname() == "typing.final":
+                decorators.append(decorator)
+
+        for decorator in decorators or uninferable_final_decorators(node):
+            self.add_message(
+                "using-final-decorator-in-unsupported-version", node=decorator
+            )
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(UnsupportedVersionChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/utils.py b/myenv/lib/python3.9/site-packages/pylint/checkers/utils.py
new file mode 100644
index 0000000..5f00734
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/utils.py
@@ -0,0 +1,1738 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Some functions that may be useful for various checkers."""
+import builtins
+import itertools
+import numbers
+import re
+import string
+import warnings
+from functools import lru_cache, partial
+from typing import (
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Match,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+import _string
+import astroid
+import astroid.objects
+from astroid import TooManyLevelsError, nodes
+from astroid.context import InferenceContext
+
+from pylint.constants import TYPING_TYPE_CHECKS_GUARDS
+
+COMP_NODE_TYPES = (
+    nodes.ListComp,
+    nodes.SetComp,
+    nodes.DictComp,
+    nodes.GeneratorExp,
+)
+EXCEPTIONS_MODULE = "builtins"
+ABC_MODULES = {"abc", "_py_abc"}
+ABC_METHODS = {
+    "abc.abstractproperty",
+    "abc.abstractmethod",
+    "abc.abstractclassmethod",
+    "abc.abstractstaticmethod",
+}
+TYPING_PROTOCOLS = frozenset(
+    {"typing.Protocol", "typing_extensions.Protocol", ".Protocol"}
+)
+ITER_METHOD = "__iter__"
+AITER_METHOD = "__aiter__"
+NEXT_METHOD = "__next__"
+GETITEM_METHOD = "__getitem__"
+CLASS_GETITEM_METHOD = "__class_getitem__"
+SETITEM_METHOD = "__setitem__"
+DELITEM_METHOD = "__delitem__"
+CONTAINS_METHOD = "__contains__"
+KEYS_METHOD = "keys"
+
+# Dictionary which maps the number of expected parameters a
+# special method can have to a set of special methods.
+# The following keys are used to denote the parameters restrictions:
+#
+# * None: variable number of parameters
+# * number: exactly that number of parameters
+# * tuple: these are the odd ones. Basically it means that the function
+#          can work with any number of arguments from that tuple,
+#          although it's best to implement it in order to accept
+#          all of them.
+_SPECIAL_METHODS_PARAMS = {
+    None: ("__new__", "__init__", "__call__"),
+    0: (
+        "__del__",
+        "__repr__",
+        "__str__",
+        "__bytes__",
+        "__hash__",
+        "__bool__",
+        "__dir__",
+        "__len__",
+        "__length_hint__",
+        "__iter__",
+        "__reversed__",
+        "__neg__",
+        "__pos__",
+        "__abs__",
+        "__invert__",
+        "__complex__",
+        "__int__",
+        "__float__",
+        "__index__",
+        "__trunc__",
+        "__floor__",
+        "__ceil__",
+        "__enter__",
+        "__aenter__",
+        "__getnewargs_ex__",
+        "__getnewargs__",
+        "__getstate__",
+        "__reduce__",
+        "__copy__",
+        "__unicode__",
+        "__nonzero__",
+        "__await__",
+        "__aiter__",
+        "__anext__",
+        "__fspath__",
+        "__subclasses__",
+        "__init_subclass__",
+    ),
+    1: (
+        "__format__",
+        "__lt__",
+        "__le__",
+        "__eq__",
+        "__ne__",
+        "__gt__",
+        "__ge__",
+        "__getattr__",
+        "__getattribute__",
+        "__delattr__",
+        "__delete__",
+        "__instancecheck__",
+        "__subclasscheck__",
+        "__getitem__",
+        "__missing__",
+        "__delitem__",
+        "__contains__",
+        "__add__",
+        "__sub__",
+        "__mul__",
+        "__truediv__",
+        "__floordiv__",
+        "__rfloordiv__",
+        "__mod__",
+        "__divmod__",
+        "__lshift__",
+        "__rshift__",
+        "__and__",
+        "__xor__",
+        "__or__",
+        "__radd__",
+        "__rsub__",
+        "__rmul__",
+        "__rtruediv__",
+        "__rmod__",
+        "__rdivmod__",
+        "__rpow__",
+        "__rlshift__",
+        "__rrshift__",
+        "__rand__",
+        "__rxor__",
+        "__ror__",
+        "__iadd__",
+        "__isub__",
+        "__imul__",
+        "__itruediv__",
+        "__ifloordiv__",
+        "__imod__",
+        "__ilshift__",
+        "__irshift__",
+        "__iand__",
+        "__ixor__",
+        "__ior__",
+        "__ipow__",
+        "__setstate__",
+        "__reduce_ex__",
+        "__deepcopy__",
+        "__cmp__",
+        "__matmul__",
+        "__rmatmul__",
+        "__imatmul__",
+        "__div__",
+    ),
+    2: ("__setattr__", "__get__", "__set__", "__setitem__", "__set_name__"),
+    3: ("__exit__", "__aexit__"),
+    (0, 1): ("__round__",),
+    (1, 2): ("__pow__",),
+}
+
+SPECIAL_METHODS_PARAMS = {
+    name: params
+    for params, methods in _SPECIAL_METHODS_PARAMS.items()
+    for name in methods
+}
+PYMETHODS = set(SPECIAL_METHODS_PARAMS)
+
+SUBSCRIPTABLE_CLASSES_PEP585 = frozenset(
+    (
+        "builtins.tuple",
+        "builtins.list",
+        "builtins.dict",
+        "builtins.set",
+        "builtins.frozenset",
+        "builtins.type",
+        "collections.deque",
+        "collections.defaultdict",
+        "collections.OrderedDict",
+        "collections.Counter",
+        "collections.ChainMap",
+        "_collections_abc.Awaitable",
+        "_collections_abc.Coroutine",
+        "_collections_abc.AsyncIterable",
+        "_collections_abc.AsyncIterator",
+        "_collections_abc.AsyncGenerator",
+        "_collections_abc.Iterable",
+        "_collections_abc.Iterator",
+        "_collections_abc.Generator",
+        "_collections_abc.Reversible",
+        "_collections_abc.Container",
+        "_collections_abc.Collection",
+        "_collections_abc.Callable",
+        "_collections_abc.Set",
+        "_collections_abc.MutableSet",
+        "_collections_abc.Mapping",
+        "_collections_abc.MutableMapping",
+        "_collections_abc.Sequence",
+        "_collections_abc.MutableSequence",
+        "_collections_abc.ByteString",
+        "_collections_abc.MappingView",
+        "_collections_abc.KeysView",
+        "_collections_abc.ItemsView",
+        "_collections_abc.ValuesView",
+        "contextlib.AbstractContextManager",
+        "contextlib.AbstractAsyncContextManager",
+        "re.Pattern",
+        "re.Match",
+    )
+)
+
+T_Node = TypeVar("T_Node", bound=nodes.NodeNG)
+
+
+class NoSuchArgumentError(Exception):
+    pass
+
+
+class InferredTypeError(Exception):
+    pass
+
+
+def is_inside_lambda(node: nodes.NodeNG) -> bool:
+    """Return whether the given node is inside a lambda."""
+    warnings.warn(
+        "utils.is_inside_lambda will be removed in favour of calling "
+        "utils.get_node_first_ancestor_of_type(x, nodes.Lambda) in pylint 3.0",
+        DeprecationWarning,
+    )
+    return any(isinstance(parent, nodes.Lambda) for parent in node.node_ancestors())
+
+
+def get_all_elements(
+    node: nodes.NodeNG,
+) -> Iterable[nodes.NodeNG]:
+    """Recursively returns all atoms in nested lists and tuples."""
+    if isinstance(node, (nodes.Tuple, nodes.List)):
+        for child in node.elts:
+            yield from get_all_elements(child)
+    else:
+        yield node
+
+
+def is_super(node: nodes.NodeNG) -> bool:
+    """Return True if the node is referencing the "super" builtin function."""
+    if getattr(node, "name", None) == "super" and node.root().name == "builtins":
+        return True
+    return False
+
+
+def is_error(node: nodes.FunctionDef) -> bool:
+    """Return true if the given function node only raises an exception."""
+    return len(node.body) == 1 and isinstance(node.body[0], nodes.Raise)
+
+
+builtins = builtins.__dict__.copy()  # type: ignore[assignment]
+SPECIAL_BUILTINS = ("__builtins__",)  # '__path__', '__file__')
+
+
+def is_builtin_object(node: nodes.NodeNG) -> bool:
+    """Returns True if the given node is an object from the __builtin__ module."""
+    return node and node.root().name == "builtins"
+
+
+def is_builtin(name: str) -> bool:
+    """Return true if <name> could be considered as a builtin defined by python."""
+    return name in builtins or name in SPECIAL_BUILTINS  # type: ignore[attr-defined]
+
+
+def is_defined_in_scope(
+    var_node: nodes.NodeNG,
+    varname: str,
+    scope: nodes.NodeNG,
+) -> bool:
+    if isinstance(scope, nodes.If):
+        for node in scope.body:
+            if (
+                isinstance(node, nodes.Assign)
+                and any(
+                    isinstance(target, nodes.AssignName) and target.name == varname
+                    for target in node.targets
+                )
+            ) or (isinstance(node, nodes.Nonlocal) and varname in node.names):
+                return True
+    elif isinstance(scope, (COMP_NODE_TYPES, nodes.For)):
+        for ass_node in scope.nodes_of_class(nodes.AssignName):
+            if ass_node.name == varname:
+                return True
+    elif isinstance(scope, nodes.With):
+        for expr, ids in scope.items:
+            if expr.parent_of(var_node):
+                break
+            if ids and isinstance(ids, nodes.AssignName) and ids.name == varname:
+                return True
+    elif isinstance(scope, (nodes.Lambda, nodes.FunctionDef)):
+        if scope.args.is_argument(varname):
+            # If the name is found inside a default value
+            # of a function, then let the search continue
+            # in the parent's tree.
+            if scope.args.parent_of(var_node):
+                try:
+                    scope.args.default_value(varname)
+                    scope = scope.parent
+                    is_defined_in_scope(var_node, varname, scope)
+                except astroid.NoDefault:
+                    pass
+            return True
+        if getattr(scope, "name", None) == varname:
+            return True
+    elif isinstance(scope, nodes.ExceptHandler):
+        if isinstance(scope.name, nodes.AssignName):
+            ass_node = scope.name
+            if ass_node.name == varname:
+                return True
+    return False
+
+
+def is_defined_before(var_node: nodes.Name) -> bool:
+    """Check if the given variable node is defined before.
+
+    Verify that the variable node is defined by a parent node
+    (list, set, dict, or generator comprehension, lambda)
+    or in a previous sibling node on the same line
+    (statement_defining ; statement_using).
+    """
+    varname = var_node.name
+    for parent in var_node.node_ancestors():
+        if is_defined_in_scope(var_node, varname, parent):
+            return True
+    # possibly multiple statements on the same line using semicolon separator
+    stmt = var_node.statement(future=True)
+    _node = stmt.previous_sibling()
+    lineno = stmt.fromlineno
+    while _node and _node.fromlineno == lineno:
+        for assign_node in _node.nodes_of_class(nodes.AssignName):
+            if assign_node.name == varname:
+                return True
+        for imp_node in _node.nodes_of_class((nodes.ImportFrom, nodes.Import)):
+            if varname in [name[1] or name[0] for name in imp_node.names]:
+                return True
+        _node = _node.previous_sibling()
+    return False
+
+
+def is_default_argument(
+    node: nodes.NodeNG, scope: Optional[nodes.NodeNG] = None
+) -> bool:
+    """Return true if the given Name node is used in function or lambda
+    default argument's value
+    """
+    if not scope:
+        scope = node.scope()
+    if isinstance(scope, (nodes.FunctionDef, nodes.Lambda)):
+        all_defaults = itertools.chain(
+            scope.args.defaults, (d for d in scope.args.kw_defaults if d is not None)
+        )
+        return any(
+            default_name_node is node
+            for default_node in all_defaults
+            for default_name_node in default_node.nodes_of_class(nodes.Name)
+        )
+
+    return False
+
+
+def is_func_decorator(node: nodes.NodeNG) -> bool:
+    """Return true if the name is used in function decorator."""
+    for parent in node.node_ancestors():
+        if isinstance(parent, nodes.Decorators):
+            return True
+        if parent.is_statement or isinstance(
+            parent,
+            (
+                nodes.Lambda,
+                nodes.ComprehensionScope,
+                nodes.ListComp,
+            ),
+        ):
+            break
+    return False
+
+
+def is_ancestor_name(frame: nodes.ClassDef, node: nodes.NodeNG) -> bool:
+    """Return whether `frame` is an astroid.Class node with `node` in the
+    subtree of its bases attribute
+    """
+    if not isinstance(frame, nodes.ClassDef):
+        return False
+    return any(node in base.nodes_of_class(nodes.Name) for base in frame.bases)
+
+
+def is_being_called(node: nodes.NodeNG) -> bool:
+    """Return True if node is the function being called in a Call node."""
+    return isinstance(node.parent, nodes.Call) and node.parent.func is node
+
+
+def assign_parent(node: nodes.NodeNG) -> nodes.NodeNG:
+    """Return the higher parent which is not an AssignName, Tuple or List node."""
+    while node and isinstance(node, (nodes.AssignName, nodes.Tuple, nodes.List)):
+        node = node.parent
+    return node
+
+
+def overrides_a_method(class_node: nodes.ClassDef, name: str) -> bool:
+    """Return True if <name> is a method overridden from an ancestor
+    which is not the base object class
+    """
+    for ancestor in class_node.ancestors():
+        if ancestor.name == "object":
+            continue
+        if name in ancestor and isinstance(ancestor[name], nodes.FunctionDef):
+            return True
+    return False
+
+
+def check_messages(*messages: str) -> Callable:
+    """Decorator to store messages that are handled by a checker method."""
+
+    def store_messages(func):
+        func.checks_msgs = messages
+        return func
+
+    return store_messages
+
+
+class IncompleteFormatString(Exception):
+    """A format string ended in the middle of a format specifier."""
+
+
+class UnsupportedFormatCharacter(Exception):
+    """A format character in a format string is not one of the supported
+    format characters.
+    """
+
+    def __init__(self, index):
+        super().__init__(index)
+        self.index = index
+
+
+def parse_format_string(
+    format_string: str,
+) -> Tuple[Set[str], int, Dict[str, str], List[str]]:
+    """Parses a format string, returning a tuple (keys, num_args).
+
+    Where 'keys' is the set of mapping keys in the format string, and 'num_args' is the number
+    of arguments required by the format string. Raises IncompleteFormatString or
+    UnsupportedFormatCharacter if a parse error occurs.
+    """
+    keys = set()
+    key_types = {}
+    pos_types = []
+    num_args = 0
+
+    def next_char(i):
+        i += 1
+        if i == len(format_string):
+            raise IncompleteFormatString
+        return (i, format_string[i])
+
+    i = 0
+    while i < len(format_string):
+        char = format_string[i]
+        if char == "%":
+            i, char = next_char(i)
+            # Parse the mapping key (optional).
+            key = None
+            if char == "(":
+                depth = 1
+                i, char = next_char(i)
+                key_start = i
+                while depth != 0:
+                    if char == "(":
+                        depth += 1
+                    elif char == ")":
+                        depth -= 1
+                    i, char = next_char(i)
+                key_end = i - 1
+                key = format_string[key_start:key_end]
+
+            # Parse the conversion flags (optional).
+            while char in "#0- +":
+                i, char = next_char(i)
+            # Parse the minimum field width (optional).
+            if char == "*":
+                num_args += 1
+                i, char = next_char(i)
+            else:
+                while char in string.digits:
+                    i, char = next_char(i)
+            # Parse the precision (optional).
+            if char == ".":
+                i, char = next_char(i)
+                if char == "*":
+                    num_args += 1
+                    i, char = next_char(i)
+                else:
+                    while char in string.digits:
+                        i, char = next_char(i)
+            # Parse the length modifier (optional).
+            if char in "hlL":
+                i, char = next_char(i)
+            # Parse the conversion type (mandatory).
+            flags = "diouxXeEfFgGcrs%a"
+            if char not in flags:
+                raise UnsupportedFormatCharacter(i)
+            if key:
+                keys.add(key)
+                key_types[key] = char
+            elif char != "%":
+                num_args += 1
+                pos_types.append(char)
+        i += 1
+    return keys, num_args, key_types, pos_types
+
+
+def split_format_field_names(format_string) -> Tuple[str, Iterable[Tuple[bool, str]]]:
+    try:
+        return _string.formatter_field_name_split(format_string)
+    except ValueError as e:
+        raise IncompleteFormatString() from e
+
+
+def collect_string_fields(format_string) -> Iterable[Optional[str]]:
+    """Given a format string, return an iterator
+    of all the valid format fields.
+
+    It handles nested fields as well.
+    """
+    formatter = string.Formatter()
+    try:
+        parseiterator = formatter.parse(format_string)
+        for result in parseiterator:
+            if all(item is None for item in result[1:]):
+                # not a replacement format
+                continue
+            name = result[1]
+            nested = result[2]
+            yield name
+            if nested:
+                yield from collect_string_fields(nested)
+    except ValueError as exc:
+        # Probably the format string is invalid.
+        if exc.args[0].startswith("cannot switch from manual"):
+            # On Jython, parsing a string with both manual
+            # and automatic positions will fail with a ValueError,
+            # while on CPython it will simply return the fields,
+            # the validation being done in the interpreter (?).
+            # We're just returning two mixed fields in order
+            # to trigger the format-combined-specification check.
+            yield ""
+            yield "1"
+            return
+        raise IncompleteFormatString(format_string) from exc
+
+
+def parse_format_method_string(
+    format_string: str,
+) -> Tuple[List[Tuple[str, List[Tuple[bool, str]]]], int, int]:
+    """Parses a PEP 3101 format string, returning a tuple of
+    (keyword_arguments, implicit_pos_args_cnt, explicit_pos_args).
+
+    keyword_arguments is the set of mapping keys in the format string, implicit_pos_args_cnt
+    is the number of arguments required by the format string and
+    explicit_pos_args is the number of arguments passed with the position.
+    """
+    keyword_arguments = []
+    implicit_pos_args_cnt = 0
+    explicit_pos_args = set()
+    for name in collect_string_fields(format_string):
+        if name and str(name).isdigit():
+            explicit_pos_args.add(str(name))
+        elif name:
+            keyname, fielditerator = split_format_field_names(name)
+            if isinstance(keyname, numbers.Number):
+                explicit_pos_args.add(str(keyname))
+            try:
+                keyword_arguments.append((keyname, list(fielditerator)))
+            except ValueError as e:
+                raise IncompleteFormatString() from e
+        else:
+            implicit_pos_args_cnt += 1
+    return keyword_arguments, implicit_pos_args_cnt, len(explicit_pos_args)
+
+
+def is_attr_protected(attrname: str) -> bool:
+    """Return True if attribute name is protected (start with _ and some other
+    details), False otherwise.
+    """
+    return (
+        attrname[0] == "_"
+        and attrname != "_"
+        and not (attrname.startswith("__") and attrname.endswith("__"))
+    )
+
+
+def node_frame_class(node: nodes.NodeNG) -> Optional[nodes.ClassDef]:
+    """Return the class that is wrapping the given node.
+
+    The function returns a class for a method node (or a staticmethod or a
+    classmethod), otherwise it returns `None`.
+    """
+    klass = node.frame(future=True)
+    nodes_to_check = (
+        nodes.NodeNG,
+        astroid.UnboundMethod,
+        astroid.BaseInstance,
+    )
+    while (
+        klass
+        and isinstance(klass, nodes_to_check)
+        and not isinstance(klass, nodes.ClassDef)
+    ):
+        if klass.parent is None:
+            return None
+
+        klass = klass.parent.frame(future=True)
+
+    return klass
+
+
+def get_outer_class(class_node: astroid.ClassDef) -> Optional[astroid.ClassDef]:
+    """Return the class that is the outer class of given (nested) class_node."""
+    parent_klass = class_node.parent.frame(future=True)
+
+    return parent_klass if isinstance(parent_klass, astroid.ClassDef) else None
+
+
+def is_attr_private(attrname: str) -> Optional[Match[str]]:
+    """Check that attribute name is private (at least two leading underscores,
+    at most one trailing underscore)
+    """
+    regex = re.compile("^_{2,}.*[^_]+_?$")
+    return regex.match(attrname)
+
+
+def get_argument_from_call(
+    call_node: nodes.Call, position: Optional[int] = None, keyword: Optional[str] = None
+) -> nodes.Name:
+    """Returns the specified argument from a function call.
+
+    :param nodes.Call call_node: Node representing a function call to check.
+    :param int position: position of the argument.
+    :param str keyword: the keyword of the argument.
+
+    :returns: The node representing the argument, None if the argument is not found.
+    :rtype: nodes.Name
+    :raises ValueError: if both position and keyword are None.
+    :raises NoSuchArgumentError: if no argument at the provided position or with
+    the provided keyword.
+    """
+    if position is None and keyword is None:
+        raise ValueError("Must specify at least one of: position or keyword.")
+    if position is not None:
+        try:
+            return call_node.args[position]
+        except IndexError:
+            pass
+    if keyword and call_node.keywords:
+        for arg in call_node.keywords:
+            if arg.arg == keyword:
+                return arg.value
+
+    raise NoSuchArgumentError
+
+
+def inherit_from_std_ex(node: nodes.NodeNG) -> bool:
+    """Return whether the given class node is subclass of
+    exceptions.Exception.
+    """
+    ancestors = node.ancestors() if hasattr(node, "ancestors") else []
+    return any(
+        ancestor.name in {"Exception", "BaseException"}
+        and ancestor.root().name == EXCEPTIONS_MODULE
+        for ancestor in itertools.chain([node], ancestors)
+    )
+
+
+def error_of_type(handler: nodes.ExceptHandler, error_type) -> bool:
+    """Check if the given exception handler catches
+    the given error_type.
+
+    The *handler* parameter is a node, representing an ExceptHandler node.
+    The *error_type* can be an exception, such as AttributeError,
+    the name of an exception, or it can be a tuple of errors.
+    The function will return True if the handler catches any of the
+    given errors.
+    """
+
+    def stringify_error(error):
+        if not isinstance(error, str):
+            return error.__name__
+        return error
+
+    if not isinstance(error_type, tuple):
+        error_type = (error_type,)
+    expected_errors = {stringify_error(error) for error in error_type}
+    if not handler.type:
+        return False
+    return handler.catch(expected_errors)
+
+
+def decorated_with_property(node: nodes.FunctionDef) -> bool:
+    """Detect if the given function node is decorated with a property."""
+    if not node.decorators:
+        return False
+    for decorator in node.decorators.nodes:
+        try:
+            if _is_property_decorator(decorator):
+                return True
+        except astroid.InferenceError:
+            pass
+    return False
+
+
+def _is_property_kind(node, *kinds):
+    if not isinstance(node, (astroid.UnboundMethod, nodes.FunctionDef)):
+        return False
+    if node.decorators:
+        for decorator in node.decorators.nodes:
+            if isinstance(decorator, nodes.Attribute) and decorator.attrname in kinds:
+                return True
+    return False
+
+
+def is_property_setter(node: nodes.FunctionDef) -> bool:
+    """Check if the given node is a property setter."""
+    return _is_property_kind(node, "setter")
+
+
+def is_property_deleter(node: nodes.FunctionDef) -> bool:
+    """Check if the given node is a property deleter."""
+    return _is_property_kind(node, "deleter")
+
+
+def is_property_setter_or_deleter(node: nodes.FunctionDef) -> bool:
+    """Check if the given node is either a property setter or a deleter."""
+    return _is_property_kind(node, "setter", "deleter")
+
+
+def _is_property_decorator(decorator: nodes.Name) -> bool:
+    for inferred in decorator.infer():
+        if isinstance(inferred, nodes.ClassDef):
+            if inferred.qname() in {"builtins.property", "functools.cached_property"}:
+                return True
+            for ancestor in inferred.ancestors():
+                if ancestor.name == "property" and ancestor.root().name == "builtins":
+                    return True
+        elif isinstance(inferred, nodes.FunctionDef):
+            # If decorator is function, check if it has exactly one return
+            # and the return is itself a function decorated with property
+            returns: List[nodes.Return] = list(
+                inferred._get_return_nodes_skip_functions()
+            )
+            if len(returns) == 1 and isinstance(
+                returns[0].value, (nodes.Name, nodes.Attribute)
+            ):
+                inferred = safe_infer(returns[0].value)
+                if (
+                    inferred
+                    and isinstance(inferred, astroid.objects.Property)
+                    and isinstance(inferred.function, nodes.FunctionDef)
+                ):
+                    return decorated_with_property(inferred.function)
+    return False
+
+
+def decorated_with(
+    func: Union[
+        nodes.ClassDef, nodes.FunctionDef, astroid.BoundMethod, astroid.UnboundMethod
+    ],
+    qnames: Iterable[str],
+) -> bool:
+    """Determine if the `func` node has a decorator with the qualified name `qname`."""
+    decorators = func.decorators.nodes if func.decorators else []
+    for decorator_node in decorators:
+        if isinstance(decorator_node, nodes.Call):
+            # We only want to infer the function name
+            decorator_node = decorator_node.func
+        try:
+            if any(
+                i.name in qnames or i.qname() in qnames
+                for i in decorator_node.infer()
+                if i is not None and i != astroid.Uninferable
+            ):
+                return True
+        except astroid.InferenceError:
+            continue
+    return False
+
+
+def uninferable_final_decorators(
+    node: nodes.Decorators,
+) -> List[Optional[Union[nodes.Attribute, nodes.Name]]]:
+    """Return a list of uninferable `typing.final` decorators in `node`.
+
+    This function is used to determine if the `typing.final` decorator is used
+    with an unsupported Python version; the decorator cannot be inferred when
+    using a Python version lower than 3.8.
+    """
+    decorators = []
+    for decorator in getattr(node, "nodes", []):
+        import_nodes = None
+
+        # Get the `Import` node. The decorator is of the form: @module.name
+        if isinstance(decorator, nodes.Attribute):
+            inferred = safe_infer(decorator.expr)
+            if isinstance(inferred, nodes.Module) and inferred.qname() == "typing":
+                _, import_nodes = decorator.expr.lookup(decorator.expr.name)
+
+        # Get the `ImportFrom` node. The decorator is of the form: @name
+        elif isinstance(decorator, nodes.Name):
+            _, import_nodes = decorator.lookup(decorator.name)
+
+        # The `final` decorator is expected to be found in the
+        # import_nodes. Continue if we don't find any `Import` or `ImportFrom`
+        # nodes for this decorator.
+        if not import_nodes:
+            continue
+        import_node = import_nodes[0]
+
+        if not isinstance(import_node, (astroid.Import, astroid.ImportFrom)):
+            continue
+
+        import_names = dict(import_node.names)
+
+        # Check if the import is of the form: `from typing import final`
+        is_from_import = ("final" in import_names) and import_node.modname == "typing"
+
+        # Check if the import is of the form: `import typing`
+        is_import = ("typing" in import_names) and getattr(
+            decorator, "attrname", None
+        ) == "final"
+
+        if (is_from_import or is_import) and safe_infer(decorator) in [
+            astroid.Uninferable,
+            None,
+        ]:
+            decorators.append(decorator)
+    return decorators
+
+
+@lru_cache(maxsize=1024)
+def unimplemented_abstract_methods(
+    node: nodes.ClassDef, is_abstract_cb: nodes.FunctionDef = None
+) -> Dict[str, nodes.NodeNG]:
+    """Get the unimplemented abstract methods for the given *node*.
+
+    A method can be considered abstract if the callback *is_abstract_cb*
+    returns a ``True`` value. The check defaults to verifying that
+    a method is decorated with abstract methods.
+    The function will work only for new-style classes. For old-style
+    classes, it will simply return an empty dictionary.
+    For the rest of them, it will return a dictionary of abstract method
+    names and their inferred objects.
+    """
+    if is_abstract_cb is None:
+        is_abstract_cb = partial(decorated_with, qnames=ABC_METHODS)
+    visited: Dict[str, nodes.NodeNG] = {}
+    try:
+        mro = reversed(node.mro())
+    except NotImplementedError:
+        # Old style class, it will not have a mro.
+        return {}
+    except astroid.ResolveError:
+        # Probably inconsistent hierarchy, don't try to figure this out here.
+        return {}
+    for ancestor in mro:
+        for obj in ancestor.values():
+            inferred = obj
+            if isinstance(obj, nodes.AssignName):
+                inferred = safe_infer(obj)
+                if not inferred:
+                    # Might be an abstract function,
+                    # but since we don't have enough information
+                    # in order to take this decision, we're taking
+                    # the *safe* decision instead.
+                    if obj.name in visited:
+                        del visited[obj.name]
+                    continue
+                if not isinstance(inferred, nodes.FunctionDef):
+                    if obj.name in visited:
+                        del visited[obj.name]
+            if isinstance(inferred, nodes.FunctionDef):
+                # It's critical to use the original name,
+                # since after inferring, an object can be something
+                # else than expected, as in the case of the
+                # following assignment.
+                #
+                # class A:
+                #     def keys(self): pass
+                #     __iter__ = keys
+                abstract = is_abstract_cb(inferred)
+                if abstract:
+                    visited[obj.name] = inferred
+                elif not abstract and obj.name in visited:
+                    del visited[obj.name]
+    return visited
+
+
+def find_try_except_wrapper_node(
+    node: nodes.NodeNG,
+) -> Optional[Union[nodes.ExceptHandler, nodes.TryExcept]]:
+    """Return the ExceptHandler or the TryExcept node in which the node is."""
+    current = node
+    ignores = (nodes.ExceptHandler, nodes.TryExcept)
+    while current and not isinstance(current.parent, ignores):
+        current = current.parent
+
+    if current and isinstance(current.parent, ignores):
+        return current.parent
+    return None
+
+
+def find_except_wrapper_node_in_scope(
+    node: nodes.NodeNG,
+) -> Optional[Union[nodes.ExceptHandler, nodes.TryExcept]]:
+    """Return the ExceptHandler in which the node is, without going out of scope."""
+    for current in node.node_ancestors():
+        if isinstance(current, astroid.scoped_nodes.LocalsDictNodeNG):
+            # If we're inside a function/class definition, we don't want to keep checking
+            # higher ancestors for `except` clauses, because if these exist, it means our
+            # function/class was defined in an `except` clause, rather than the current code
+            # actually running in an `except` clause.
+            return None
+        if isinstance(current, nodes.ExceptHandler):
+            return current
+    return None
+
+
+def is_from_fallback_block(node: nodes.NodeNG) -> bool:
+    """Check if the given node is from a fallback import block."""
+    context = find_try_except_wrapper_node(node)
+    if not context:
+        return False
+
+    if isinstance(context, nodes.ExceptHandler):
+        other_body = context.parent.body
+        handlers = context.parent.handlers
+    else:
+        other_body = itertools.chain.from_iterable(
+            handler.body for handler in context.handlers
+        )
+        handlers = context.handlers
+
+    has_fallback_imports = any(
+        isinstance(import_node, (nodes.ImportFrom, nodes.Import))
+        for import_node in other_body
+    )
+    ignores_import_error = _except_handlers_ignores_exceptions(
+        handlers, (ImportError, ModuleNotFoundError)
+    )
+    return ignores_import_error or has_fallback_imports
+
+
+def _except_handlers_ignores_exceptions(
+    handlers: nodes.ExceptHandler,
+    exceptions: Tuple[Type[ImportError], Type[ModuleNotFoundError]],
+) -> bool:
+    func = partial(error_of_type, error_type=exceptions)
+    return any(func(handler) for handler in handlers)
+
+
+def get_exception_handlers(
+    node: nodes.NodeNG, exception=Exception
+) -> Optional[List[nodes.ExceptHandler]]:
+    """Return the collections of handlers handling the exception in arguments.
+
+    Args:
+        node (nodes.NodeNG): A node that is potentially wrapped in a try except.
+        exception (builtin.Exception or str): exception or name of the exception.
+
+    Returns:
+        list: the collection of handlers that are handling the exception or None.
+
+    """
+    context = find_try_except_wrapper_node(node)
+    if isinstance(context, nodes.TryExcept):
+        return [
+            handler for handler in context.handlers if error_of_type(handler, exception)
+        ]
+    return []
+
+
+def is_node_inside_try_except(node: nodes.Raise) -> bool:
+    """Check if the node is directly under a Try/Except statement
+    (but not under an ExceptHandler!).
+
+    Args:
+        node (nodes.Raise): the node raising the exception.
+
+    Returns:
+        bool: True if the node is inside a try/except statement, False otherwise.
+    """
+    context = find_try_except_wrapper_node(node)
+    return isinstance(context, nodes.TryExcept)
+
+
+def node_ignores_exception(node: nodes.NodeNG, exception=Exception) -> bool:
+    """Check if the node is in a TryExcept which handles the given exception.
+
+    If the exception is not given, the function is going to look for bare
+    excepts.
+    """
+    managing_handlers = get_exception_handlers(node, exception)
+    if not managing_handlers:
+        return False
+    return any(managing_handlers)
+
+
+def class_is_abstract(node: nodes.ClassDef) -> bool:
+    """Return true if the given class node should be considered as an abstract
+    class
+    """
+    # Only check for explicit metaclass=ABCMeta on this specific class
+    meta = node.declared_metaclass()
+    if meta is not None:
+        if meta.name == "ABCMeta" and meta.root().name in ABC_MODULES:
+            return True
+
+    for ancestor in node.ancestors():
+        if ancestor.name == "ABC" and ancestor.root().name in ABC_MODULES:
+            # abc.ABC inheritance
+            return True
+
+    for method in node.methods():
+        if method.parent.frame(future=True) is node:
+            if method.is_abstract(pass_is_abstract=False):
+                return True
+    return False
+
+
+def _supports_protocol_method(value: nodes.NodeNG, attr: str) -> bool:
+    try:
+        attributes = value.getattr(attr)
+    except astroid.NotFoundError:
+        return False
+
+    first = attributes[0]
+
+    # Return False if a constant is assigned
+    if isinstance(first, nodes.AssignName):
+        this_assign_parent = get_node_first_ancestor_of_type(
+            first, (nodes.Assign, nodes.NamedExpr)
+        )
+        if this_assign_parent is None:  # pragma: no cover
+            # Cannot imagine this being None, but return True to avoid false positives
+            return True
+        if isinstance(this_assign_parent.value, nodes.BaseContainer):
+            if all(isinstance(n, nodes.Const) for n in this_assign_parent.value.elts):
+                return False
+        if isinstance(this_assign_parent.value, nodes.Const):
+            return False
+    return True
+
+
+def is_comprehension(node: nodes.NodeNG) -> bool:
+    comprehensions = (
+        nodes.ListComp,
+        nodes.SetComp,
+        nodes.DictComp,
+        nodes.GeneratorExp,
+    )
+    return isinstance(node, comprehensions)
+
+
+def _supports_mapping_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(
+        value, GETITEM_METHOD
+    ) and _supports_protocol_method(value, KEYS_METHOD)
+
+
+def _supports_membership_test_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(value, CONTAINS_METHOD)
+
+
+def _supports_iteration_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(value, ITER_METHOD) or _supports_protocol_method(
+        value, GETITEM_METHOD
+    )
+
+
+def _supports_async_iteration_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(value, AITER_METHOD)
+
+
+def _supports_getitem_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(value, GETITEM_METHOD)
+
+
+def _supports_setitem_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(value, SETITEM_METHOD)
+
+
+def _supports_delitem_protocol(value: nodes.NodeNG) -> bool:
+    return _supports_protocol_method(value, DELITEM_METHOD)
+
+
+def _is_abstract_class_name(name: str) -> bool:
+    lname = name.lower()
+    is_mixin = lname.endswith("mixin")
+    is_abstract = lname.startswith("abstract")
+    is_base = lname.startswith("base") or lname.endswith("base")
+    return is_mixin or is_abstract or is_base
+
+
+def is_inside_abstract_class(node: nodes.NodeNG) -> bool:
+    while node is not None:
+        if isinstance(node, nodes.ClassDef):
+            if class_is_abstract(node):
+                return True
+            name = getattr(node, "name", None)
+            if name is not None and _is_abstract_class_name(name):
+                return True
+        node = node.parent
+    return False
+
+
+def _supports_protocol(
+    value: nodes.NodeNG, protocol_callback: nodes.FunctionDef
+) -> bool:
+    if isinstance(value, nodes.ClassDef):
+        if not has_known_bases(value):
+            return True
+        # classobj can only be iterable if it has an iterable metaclass
+        meta = value.metaclass()
+        if meta is not None:
+            if protocol_callback(meta):
+                return True
+    if isinstance(value, astroid.BaseInstance):
+        if not has_known_bases(value):
+            return True
+        if value.has_dynamic_getattr():
+            return True
+        if protocol_callback(value):
+            return True
+
+    # pylint: disable-next=fixme
+    # TODO: Should be covered by https://github.com/PyCQA/astroid/pull/1475
+    if isinstance(value, nodes.ComprehensionScope):
+        return True
+
+    if (
+        isinstance(value, astroid.bases.Proxy)
+        and isinstance(value._proxied, astroid.BaseInstance)
+        and has_known_bases(value._proxied)
+    ):
+        value = value._proxied
+        return protocol_callback(value)
+
+    return False
+
+
+def is_iterable(value: nodes.NodeNG, check_async: bool = False) -> bool:
+    if check_async:
+        protocol_check = _supports_async_iteration_protocol
+    else:
+        protocol_check = _supports_iteration_protocol
+    return _supports_protocol(value, protocol_check)
+
+
+def is_mapping(value: nodes.NodeNG) -> bool:
+    return _supports_protocol(value, _supports_mapping_protocol)
+
+
+def supports_membership_test(value: nodes.NodeNG) -> bool:
+    supported = _supports_protocol(value, _supports_membership_test_protocol)
+    return supported or is_iterable(value)
+
+
+def supports_getitem(value: nodes.NodeNG, node: nodes.NodeNG) -> bool:
+    if isinstance(value, nodes.ClassDef):
+        if _supports_protocol_method(value, CLASS_GETITEM_METHOD):
+            return True
+        if is_class_subscriptable_pep585_with_postponed_evaluation_enabled(value, node):
+            return True
+    return _supports_protocol(value, _supports_getitem_protocol)
+
+
+def supports_setitem(value: nodes.NodeNG, _: nodes.NodeNG) -> bool:
+    return _supports_protocol(value, _supports_setitem_protocol)
+
+
+def supports_delitem(value: nodes.NodeNG, _: nodes.NodeNG) -> bool:
+    return _supports_protocol(value, _supports_delitem_protocol)
+
+
+def _get_python_type_of_node(node: nodes.NodeNG) -> Optional[str]:
+    pytype = getattr(node, "pytype", None)
+    if callable(pytype):
+        return pytype()
+    return None
+
+
+@lru_cache(maxsize=1024)
+def safe_infer(
+    node: nodes.NodeNG, context: Optional[InferenceContext] = None
+) -> Union[nodes.NodeNG, Type[astroid.Uninferable], None]:
+    """Return the inferred value for the given node.
+
+    Return None if inference failed or if there is some ambiguity (more than
+    one node has been inferred of different types).
+    """
+    inferred_types: Set[Optional[str]] = set()
+    try:
+        infer_gen = node.infer(context=context)
+        value = next(infer_gen)
+    except astroid.InferenceError:
+        return None
+
+    if value is not astroid.Uninferable:
+        inferred_types.add(_get_python_type_of_node(value))
+
+    try:
+        for inferred in infer_gen:
+            inferred_type = _get_python_type_of_node(inferred)
+            if inferred_type not in inferred_types:
+                return None  # If there is ambiguity on the inferred node.
+            if (
+                isinstance(inferred, nodes.FunctionDef)
+                and inferred.args.args is not None
+                and isinstance(value, nodes.FunctionDef)
+                and value.args.args is not None
+                and len(inferred.args.args) != len(value.args.args)
+            ):
+                return None  # Different number of arguments indicates ambiguity
+    except astroid.InferenceError:
+        return None  # There is some kind of ambiguity
+    except StopIteration:
+        return value
+    return value if len(inferred_types) <= 1 else None
+
+
+@lru_cache(maxsize=512)
+def infer_all(
+    node: nodes.NodeNG, context: InferenceContext = None
+) -> List[nodes.NodeNG]:
+    try:
+        return list(node.infer(context=context))
+    except astroid.InferenceError:
+        return []
+
+
+def has_known_bases(klass: nodes.ClassDef, context=None) -> bool:
+    """Return true if all base classes of a class could be inferred."""
+    try:
+        return klass._all_bases_known
+    except AttributeError:
+        pass
+    for base in klass.bases:
+        result = safe_infer(base, context=context)
+        if (
+            not isinstance(result, nodes.ClassDef)
+            or result is klass
+            or not has_known_bases(result, context=context)
+        ):
+            klass._all_bases_known = False
+            return False
+    klass._all_bases_known = True
+    return True
+
+
+def is_none(node: nodes.NodeNG) -> bool:
+    return (
+        node is None
+        or (isinstance(node, nodes.Const) and node.value is None)
+        or (isinstance(node, nodes.Name) and node.name == "None")
+    )
+
+
+def node_type(node: nodes.NodeNG) -> Optional[nodes.NodeNG]:
+    """Return the inferred type for `node`.
+
+    If there is more than one possible type, or if inferred type is Uninferable or None,
+    return None
+    """
+    # check there is only one possible type for the assign node. Else we
+    # don't handle it for now
+    types: Set[nodes.NodeNG] = set()
+    try:
+        for var_type in node.infer():
+            if var_type == astroid.Uninferable or is_none(var_type):
+                continue
+            types.add(var_type)
+            if len(types) > 1:
+                return None
+    except astroid.InferenceError:
+        return None
+    return types.pop() if types else None
+
+
+def is_registered_in_singledispatch_function(node: nodes.FunctionDef) -> bool:
+    """Check if the given function node is a singledispatch function."""
+
+    singledispatch_qnames = (
+        "functools.singledispatch",
+        "singledispatch.singledispatch",
+    )
+
+    if not isinstance(node, nodes.FunctionDef):
+        return False
+
+    decorators = node.decorators.nodes if node.decorators else []
+    for decorator in decorators:
+        # func.register are function calls
+        if not isinstance(decorator, nodes.Call):
+            continue
+
+        func = decorator.func
+        if not isinstance(func, nodes.Attribute) or func.attrname != "register":
+            continue
+
+        try:
+            func_def = next(func.expr.infer())
+        except astroid.InferenceError:
+            continue
+
+        if isinstance(func_def, nodes.FunctionDef):
+            return decorated_with(func_def, singledispatch_qnames)
+
+    return False
+
+
+def get_node_last_lineno(node: nodes.NodeNG) -> int:
+    """Get the last lineno of the given node.
+
+    For a simple statement this will just be node.lineno,
+    but for a node that has child statements (e.g. a method) this will be the lineno of the last
+    child statement recursively.
+    """
+    # 'finalbody' is always the last clause in a try statement, if present
+    if getattr(node, "finalbody", False):
+        return get_node_last_lineno(node.finalbody[-1])
+    # For if, while, and for statements 'orelse' is always the last clause.
+    # For try statements 'orelse' is the last in the absence of a 'finalbody'
+    if getattr(node, "orelse", False):
+        return get_node_last_lineno(node.orelse[-1])
+    # try statements have the 'handlers' last if there is no 'orelse' or 'finalbody'
+    if getattr(node, "handlers", False):
+        return get_node_last_lineno(node.handlers[-1])
+    # All compound statements have a 'body'
+    if getattr(node, "body", False):
+        return get_node_last_lineno(node.body[-1])
+    # Not a compound statement
+    return node.lineno
+
+
+def is_postponed_evaluation_enabled(node: nodes.NodeNG) -> bool:
+    """Check if the postponed evaluation of annotations is enabled."""
+    module = node.root()
+    return "annotations" in module.future_imports
+
+
+def is_class_subscriptable_pep585_with_postponed_evaluation_enabled(
+    value: nodes.ClassDef, node: nodes.NodeNG
+) -> bool:
+    """Check if class is subscriptable with PEP 585 and
+    postponed evaluation enabled.
+    """
+    return (
+        is_postponed_evaluation_enabled(node)
+        and value.qname() in SUBSCRIPTABLE_CLASSES_PEP585
+        and is_node_in_type_annotation_context(node)
+    )
+
+
+def is_node_in_type_annotation_context(node: nodes.NodeNG) -> bool:
+    """Check if node is in type annotation context.
+
+    Check for 'AnnAssign', function 'Arguments',
+    or part of function return type anntation.
+    """
+    # pylint: disable=too-many-boolean-expressions
+    current_node, parent_node = node, node.parent
+    while True:
+        if (
+            isinstance(parent_node, nodes.AnnAssign)
+            and parent_node.annotation == current_node
+            or isinstance(parent_node, nodes.Arguments)
+            and current_node
+            in (
+                *parent_node.annotations,
+                *parent_node.posonlyargs_annotations,
+                *parent_node.kwonlyargs_annotations,
+                parent_node.varargannotation,
+                parent_node.kwargannotation,
+            )
+            or isinstance(parent_node, nodes.FunctionDef)
+            and parent_node.returns == current_node
+        ):
+            return True
+        current_node, parent_node = parent_node, parent_node.parent
+        if isinstance(parent_node, nodes.Module):
+            return False
+
+
+def is_subclass_of(child: nodes.ClassDef, parent: nodes.ClassDef) -> bool:
+    """Check if first node is a subclass of second node.
+
+    :param child: Node to check for subclass.
+    :param parent: Node to check for superclass.
+    :returns: True if child is derived from parent. False otherwise.
+    """
+    if not all(isinstance(node, nodes.ClassDef) for node in (child, parent)):
+        return False
+
+    for ancestor in child.ancestors():
+        try:
+            if astroid.helpers.is_subtype(ancestor, parent):
+                return True
+        except astroid.exceptions._NonDeducibleTypeHierarchy:
+            continue
+    return False
+
+
+@lru_cache(maxsize=1024)
+def is_overload_stub(node: nodes.NodeNG) -> bool:
+    """Check if a node is a function stub decorated with typing.overload.
+
+    :param node: Node to check.
+    :returns: True if node is an overload function stub. False otherwise.
+    """
+    decorators = getattr(node, "decorators", None)
+    return bool(decorators and decorated_with(node, ["typing.overload", "overload"]))
+
+
+def is_protocol_class(cls: nodes.NodeNG) -> bool:
+    """Check if the given node represents a protocol class.
+
+    :param cls: The node to check
+    :returns: True if the node is a typing protocol class, false otherwise.
+    """
+    if not isinstance(cls, nodes.ClassDef):
+        return False
+
+    # Use .ancestors() since not all protocol classes can have
+    # their mro deduced.
+    return any(parent.qname() in TYPING_PROTOCOLS for parent in cls.ancestors())
+
+
+def is_call_of_name(node: nodes.NodeNG, name: str) -> bool:
+    """Checks if node is a function call with the given name."""
+    return (
+        isinstance(node, nodes.Call)
+        and isinstance(node.func, nodes.Name)
+        and node.func.name == name
+    )
+
+
+def is_test_condition(
+    node: nodes.NodeNG,
+    parent: Optional[nodes.NodeNG] = None,
+) -> bool:
+    """Returns true if the given node is being tested for truthiness."""
+    parent = parent or node.parent
+    if isinstance(parent, (nodes.While, nodes.If, nodes.IfExp, nodes.Assert)):
+        return node is parent.test or parent.test.parent_of(node)
+    if isinstance(parent, nodes.Comprehension):
+        return node in parent.ifs
+    return is_call_of_name(parent, "bool") and parent.parent_of(node)
+
+
+def is_classdef_type(node: nodes.ClassDef) -> bool:
+    """Test if ClassDef node is Type."""
+    if node.name == "type":
+        return True
+    return any(isinstance(b, nodes.Name) and b.name == "type" for b in node.bases)
+
+
+def is_attribute_typed_annotation(
+    node: Union[nodes.ClassDef, astroid.Instance], attr_name: str
+) -> bool:
+    """Test if attribute is typed annotation in current node
+    or any base nodes.
+    """
+    attribute = node.locals.get(attr_name, [None])[0]
+    if (
+        attribute
+        and isinstance(attribute, nodes.AssignName)
+        and isinstance(attribute.parent, nodes.AnnAssign)
+    ):
+        return True
+    for base in node.bases:
+        inferred = safe_infer(base)
+        if (
+            inferred
+            and isinstance(inferred, nodes.ClassDef)
+            and is_attribute_typed_annotation(inferred, attr_name)
+        ):
+            return True
+    return False
+
+
+def is_assign_name_annotated_with(node: nodes.AssignName, typing_name: str) -> bool:
+    """Test if AssignName node has `typing_name` annotation.
+
+    Especially useful to check for `typing._SpecialForm` instances
+    like: `Union`, `Optional`, `Literal`, `ClassVar`, `Final`.
+    """
+    if not isinstance(node.parent, nodes.AnnAssign):
+        return False
+    annotation = node.parent.annotation
+    if isinstance(annotation, nodes.Subscript):
+        annotation = annotation.value
+    if (
+        isinstance(annotation, nodes.Name)
+        and annotation.name == typing_name
+        or isinstance(annotation, nodes.Attribute)
+        and annotation.attrname == typing_name
+    ):
+        return True
+    return False
+
+
+def get_iterating_dictionary_name(
+    node: Union[nodes.For, nodes.Comprehension]
+) -> Optional[str]:
+    """Get the name of the dictionary which keys are being iterated over on
+    a ``nodes.For`` or ``nodes.Comprehension`` node.
+
+    If the iterating object is not either the keys method of a dictionary
+    or a dictionary itself, this returns None.
+    """
+    # Is it a proper keys call?
+    if (
+        isinstance(node.iter, nodes.Call)
+        and isinstance(node.iter.func, nodes.Attribute)
+        and node.iter.func.attrname == "keys"
+    ):
+        inferred = safe_infer(node.iter.func)
+        if not isinstance(inferred, astroid.BoundMethod):
+            return None
+        return node.iter.as_string().rpartition(".keys")[0]
+
+    # Is it a dictionary?
+    if isinstance(node.iter, (nodes.Name, nodes.Attribute)):
+        inferred = safe_infer(node.iter)
+        if not isinstance(inferred, nodes.Dict):
+            return None
+        return node.iter.as_string()
+
+    return None
+
+
+def get_subscript_const_value(node: nodes.Subscript) -> nodes.Const:
+    """Returns the value 'subscript.slice' of a Subscript node.
+
+    :param node: Subscript Node to extract value from
+    :returns: Const Node containing subscript value
+    :raises InferredTypeError: if the subscript node cannot be inferred as a Const
+    """
+    inferred = safe_infer(node.slice)
+    if not isinstance(inferred, nodes.Const):
+        raise InferredTypeError("Subscript.slice cannot be inferred as a nodes.Const")
+
+    return inferred
+
+
+def get_import_name(
+    importnode: Union[nodes.Import, nodes.ImportFrom], modname: str
+) -> str:
+    """Get a prepared module name from the given import node.
+
+    In the case of relative imports, this will return the
+    absolute qualified module name, which might be useful
+    for debugging. Otherwise, the initial module name
+    is returned unchanged.
+
+    :param importnode: node representing import statement.
+    :param modname: module name from import statement.
+    :returns: absolute qualified module name of the module
+        used in import.
+    """
+    if isinstance(importnode, nodes.ImportFrom) and importnode.level:
+        root = importnode.root()
+        if isinstance(root, nodes.Module):
+            try:
+                return root.relative_to_absolute_name(modname, level=importnode.level)
+            except TooManyLevelsError:
+                return modname
+    return modname
+
+
+def is_sys_guard(node: nodes.If) -> bool:
+    """Return True if IF stmt is a sys.version_info guard.
+
+    >>> import sys
+    >>> if sys.version_info > (3, 8):
+    >>>     from typing import Literal
+    >>> else:
+    >>>     from typing_extensions import Literal
+    """
+    if isinstance(node.test, nodes.Compare):
+        value = node.test.left
+        if isinstance(value, nodes.Subscript):
+            value = value.value
+        if (
+            isinstance(value, nodes.Attribute)
+            and value.as_string() == "sys.version_info"
+        ):
+            return True
+
+    return False
+
+
+def is_typing_guard(node: nodes.If) -> bool:
+    """Return True if IF stmt is a typing guard.
+
+    >>> from typing import TYPE_CHECKING
+    >>> if TYPE_CHECKING:
+    >>>     from xyz import a
+    """
+    return isinstance(
+        node.test, (nodes.Name, nodes.Attribute)
+    ) and node.test.as_string().endswith("TYPE_CHECKING")
+
+
+def is_node_in_typing_guarded_import_block(node: nodes.NodeNG) -> bool:
+    """Return True if node is part for guarded `typing.TYPE_CHECKING` if block."""
+    return isinstance(node.parent, nodes.If) and is_typing_guard(node.parent)
+
+
+def is_node_in_guarded_import_block(node: nodes.NodeNG) -> bool:
+    """Return True if node is part for guarded if block.
+
+    I.e. `sys.version_info` or `typing.TYPE_CHECKING`
+    """
+    return isinstance(node.parent, nodes.If) and (
+        is_sys_guard(node.parent) or is_typing_guard(node.parent)
+    )
+
+
+def is_reassigned_after_current(node: nodes.NodeNG, varname: str) -> bool:
+    """Check if the given variable name is reassigned in the same scope after the current node."""
+    return any(
+        a.name == varname and a.lineno > node.lineno
+        for a in node.scope().nodes_of_class(
+            (nodes.AssignName, nodes.ClassDef, nodes.FunctionDef)
+        )
+    )
+
+
+def is_deleted_after_current(node: nodes.NodeNG, varname: str) -> bool:
+    """Check if the given variable name is deleted in the same scope after the current node."""
+    return any(
+        getattr(target, "name", None) == varname and target.lineno > node.lineno
+        for del_node in node.scope().nodes_of_class(nodes.Delete)
+        for target in del_node.targets
+    )
+
+
+def is_function_body_ellipsis(node: nodes.FunctionDef) -> bool:
+    """Checks whether a function body only consists of a single Ellipsis."""
+    return (
+        len(node.body) == 1
+        and isinstance(node.body[0], nodes.Expr)
+        and isinstance(node.body[0].value, nodes.Const)
+        and node.body[0].value.value == Ellipsis
+    )
+
+
+def is_base_container(node: Optional[nodes.NodeNG]) -> bool:
+    return isinstance(node, nodes.BaseContainer) and not node.elts
+
+
+def is_empty_dict_literal(node: Optional[nodes.NodeNG]) -> bool:
+    return isinstance(node, nodes.Dict) and not node.items
+
+
+def is_empty_str_literal(node: Optional[nodes.NodeNG]) -> bool:
+    return (
+        isinstance(node, nodes.Const) and isinstance(node.value, str) and not node.value
+    )
+
+
+def returns_bool(node: nodes.NodeNG) -> bool:
+    """Returns true if a node is a return that returns a constant boolean."""
+    return (
+        isinstance(node, nodes.Return)
+        and isinstance(node.value, nodes.Const)
+        and node.value.value in {True, False}
+    )
+
+
+def get_node_first_ancestor_of_type(
+    node: nodes.NodeNG, ancestor_type: Union[Type[T_Node], Tuple[Type[T_Node], ...]]
+) -> Optional[T_Node]:
+    """Return the first parent node that is any of the provided types (or None)."""
+    for ancestor in node.node_ancestors():
+        if isinstance(ancestor, ancestor_type):
+            return ancestor
+    return None
+
+
+def get_node_first_ancestor_of_type_and_its_child(
+    node: nodes.NodeNG, ancestor_type: Union[Type[T_Node], Tuple[Type[T_Node], ...]]
+) -> Union[Tuple[None, None], Tuple[T_Node, nodes.NodeNG]]:
+    """Modified version of get_node_first_ancestor_of_type to also return the
+    descendant visited directly before reaching the sought ancestor
+
+    Useful for extracting whether a statement is guarded by a try, except, or finally
+    when searching for a TryFinally ancestor.
+    """
+    child = node
+    for ancestor in node.node_ancestors():
+        if isinstance(ancestor, ancestor_type):
+            return (ancestor, child)
+        child = ancestor
+    return None, None
+
+
+def in_type_checking_block(node: nodes.NodeNG) -> bool:
+    """Check if a node is guarded by a TYPE_CHECKS guard."""
+    return any(
+        isinstance(ancestor, nodes.If)
+        and ancestor.test.as_string() in TYPING_TYPE_CHECKS_GUARDS
+        for ancestor in node.node_ancestors()
+    )
diff --git a/myenv/lib/python3.9/site-packages/pylint/checkers/variables.py b/myenv/lib/python3.9/site-packages/pylint/checkers/variables.py
new file mode 100644
index 0000000..fb50f45
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/checkers/variables.py
@@ -0,0 +1,2871 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Variables checkers for Python code."""
+import collections
+import copy
+import itertools
+import os
+import re
+import sys
+from enum import Enum
+from functools import lru_cache
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    DefaultDict,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    NamedTuple,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker, utils
+from pylint.checkers.utils import (
+    in_type_checking_block,
+    is_postponed_evaluation_enabled,
+)
+from pylint.constants import PY39_PLUS, TYPING_TYPE_CHECKS_GUARDS
+from pylint.interfaces import (
+    CONTROL_FLOW,
+    HIGH,
+    INFERENCE,
+    INFERENCE_FAILURE,
+    IAstroidChecker,
+)
+from pylint.utils import get_global_option
+
+if sys.version_info >= (3, 8):
+    from functools import cached_property
+else:
+    from astroid.decorators import cachedproperty as cached_property
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+SPECIAL_OBJ = re.compile("^_{2}[a-z]+_{2}$")
+FUTURE = "__future__"
+# regexp for ignored argument name
+IGNORED_ARGUMENT_NAMES = re.compile("_.*|^ignored_|^unused_")
+# In Python 3.7 abc has a Python implementation which is preferred
+# by astroid. Unfortunately this also messes up our explicit checks
+# for `abc`
+METACLASS_NAME_TRANSFORMS = {"_py_abc": "abc"}
+BUILTIN_RANGE = "builtins.range"
+TYPING_MODULE = "typing"
+TYPING_NAMES = frozenset(
+    {
+        "Any",
+        "Callable",
+        "ClassVar",
+        "Generic",
+        "Optional",
+        "Tuple",
+        "Type",
+        "TypeVar",
+        "Union",
+        "AbstractSet",
+        "ByteString",
+        "Container",
+        "ContextManager",
+        "Hashable",
+        "ItemsView",
+        "Iterable",
+        "Iterator",
+        "KeysView",
+        "Mapping",
+        "MappingView",
+        "MutableMapping",
+        "MutableSequence",
+        "MutableSet",
+        "Sequence",
+        "Sized",
+        "ValuesView",
+        "Awaitable",
+        "AsyncIterator",
+        "AsyncIterable",
+        "Coroutine",
+        "Collection",
+        "AsyncGenerator",
+        "AsyncContextManager",
+        "Reversible",
+        "SupportsAbs",
+        "SupportsBytes",
+        "SupportsComplex",
+        "SupportsFloat",
+        "SupportsInt",
+        "SupportsRound",
+        "Counter",
+        "Deque",
+        "Dict",
+        "DefaultDict",
+        "List",
+        "Set",
+        "FrozenSet",
+        "NamedTuple",
+        "Generator",
+        "AnyStr",
+        "Text",
+        "Pattern",
+        "BinaryIO",
+    }
+)
+
+
+class VariableVisitConsumerAction(Enum):
+    """Reported by _check_consumer() and its sub-methods to determine the
+    subsequent action to take in _undefined_and_used_before_checker().
+
+    Continue -> continue loop to next consumer
+    Return -> return and thereby break the loop
+    """
+
+    CONTINUE = 0
+    RETURN = 1
+
+
+def _is_from_future_import(stmt, name):
+    """Check if the name is a future import from another module."""
+    try:
+        module = stmt.do_import_module(stmt.modname)
+    except astroid.AstroidBuildingException:
+        return None
+
+    for local_node in module.locals.get(name, []):
+        if isinstance(local_node, nodes.ImportFrom) and local_node.modname == FUTURE:
+            return True
+    return None
+
+
+def in_for_else_branch(parent, stmt):
+    """Returns True if stmt in inside the else branch for a parent For stmt."""
+    return isinstance(parent, nodes.For) and any(
+        else_stmt.parent_of(stmt) or else_stmt == stmt for else_stmt in parent.orelse
+    )
+
+
+@lru_cache(maxsize=1000)
+def overridden_method(klass, name):
+    """Get overridden method if any."""
+    try:
+        parent = next(klass.local_attr_ancestors(name))
+    except (StopIteration, KeyError):
+        return None
+    try:
+        meth_node = parent[name]
+    except KeyError:
+        # We have found an ancestor defining <name> but it's not in the local
+        # dictionary. This may happen with astroid built from living objects.
+        return None
+    if isinstance(meth_node, nodes.FunctionDef):
+        return meth_node
+    return None
+
+
+def _get_unpacking_extra_info(node, inferred):
+    """Return extra information to add to the message for unpacking-non-sequence
+    and unbalanced-tuple-unpacking errors
+    """
+    more = ""
+    inferred_module = inferred.root().name
+    if node.root().name == inferred_module:
+        if node.lineno == inferred.lineno:
+            more = f" {inferred.as_string()}"
+        elif inferred.lineno:
+            more = f" defined at line {inferred.lineno}"
+    elif inferred.lineno:
+        more = f" defined at line {inferred.lineno} of {inferred_module}"
+    return more
+
+
+def _detect_global_scope(node, frame, defframe):
+    """Detect that the given frames share a global scope.
+
+    Two frames share a global scope when neither
+    of them are hidden under a function scope, as well
+    as any parent scope of them, until the root scope.
+    In this case, depending from something defined later on
+    will only work if guarded by a nested function definition.
+
+    Example:
+        class A:
+            # B has the same global scope as `C`, leading to a NameError.
+            # Return True to indicate a shared scope.
+            class B(C): ...
+        class C: ...
+
+    Whereas this does not lead to a NameError:
+        class A:
+            def guard():
+                # Return False to indicate no scope sharing.
+                class B(C): ...
+        class C: ...
+    """
+    def_scope = scope = None
+    if frame and frame.parent:
+        scope = frame.parent.scope()
+    if defframe and defframe.parent:
+        def_scope = defframe.parent.scope()
+    if (
+        isinstance(frame, nodes.ClassDef)
+        and scope is not def_scope
+        and scope is utils.get_node_first_ancestor_of_type(node, nodes.FunctionDef)
+    ):
+        # If the current node's scope is a class nested under a function,
+        # and the def_scope is something else, then they aren't shared.
+        return False
+    if isinstance(frame, nodes.FunctionDef):
+        # If the parent of the current node is a
+        # function, then it can be under its scope
+        # (defined in, which doesn't concern us) or
+        # the `->` part of annotations. The same goes
+        # for annotations of function arguments, they'll have
+        # their parent the Arguments node.
+        if not isinstance(node.parent, (nodes.FunctionDef, nodes.Arguments)):
+            return False
+    elif any(
+        not isinstance(f, (nodes.ClassDef, nodes.Module)) for f in (frame, defframe)
+    ):
+        # Not interested in other frames, since they are already
+        # not in a global scope.
+        return False
+
+    break_scopes = []
+    for current_scope in (scope, def_scope):
+        # Look for parent scopes. If there is anything different
+        # than a module or a class scope, then they frames don't
+        # share a global scope.
+        parent_scope = current_scope
+        while parent_scope:
+            if not isinstance(parent_scope, (nodes.ClassDef, nodes.Module)):
+                break_scopes.append(parent_scope)
+                break
+            if parent_scope.parent:
+                parent_scope = parent_scope.parent.scope()
+            else:
+                break
+    if break_scopes and len(set(break_scopes)) != 1:
+        # Store different scopes than expected.
+        # If the stored scopes are, in fact, the very same, then it means
+        # that the two frames (frame and defframe) share the same scope,
+        # and we could apply our lineno analysis over them.
+        # For instance, this works when they are inside a function, the node
+        # that uses a definition and the definition itself.
+        return False
+    # At this point, we are certain that frame and defframe share a scope
+    # and the definition of the first depends on the second.
+    return frame.lineno < defframe.lineno
+
+
+def _infer_name_module(node, name):
+    context = astroid.context.InferenceContext()
+    context.lookupname = name
+    return node.infer(context, asname=False)
+
+
+def _fix_dot_imports(not_consumed):
+    """Try to fix imports with multiple dots, by returning a dictionary
+    with the import names expanded.
+
+    The function unflattens root imports,
+    like 'xml' (when we have both 'xml.etree' and 'xml.sax'), to 'xml.etree'
+    and 'xml.sax' respectively.
+    """
+    names = {}
+    for name, stmts in not_consumed.items():
+        if any(
+            isinstance(stmt, nodes.AssignName)
+            and isinstance(stmt.assign_type(), nodes.AugAssign)
+            for stmt in stmts
+        ):
+            continue
+        for stmt in stmts:
+            if not isinstance(stmt, (nodes.ImportFrom, nodes.Import)):
+                continue
+            for imports in stmt.names:
+                second_name = None
+                import_module_name = imports[0]
+                if import_module_name == "*":
+                    # In case of wildcard imports,
+                    # pick the name from inside the imported module.
+                    second_name = name
+                else:
+                    name_matches_dotted_import = False
+                    if (
+                        import_module_name.startswith(name)
+                        and import_module_name.find(".") > -1
+                    ):
+                        name_matches_dotted_import = True
+
+                    if name_matches_dotted_import or name in imports:
+                        # Most likely something like 'xml.etree',
+                        # which will appear in the .locals as 'xml'.
+                        # Only pick the name if it wasn't consumed.
+                        second_name = import_module_name
+                if second_name and second_name not in names:
+                    names[second_name] = stmt
+    return sorted(names.items(), key=lambda a: a[1].fromlineno)
+
+
+def _find_frame_imports(name, frame):
+    """Detect imports in the frame, with the required *name*.
+
+    Such imports can be considered assignments.
+    Returns True if an import for the given name was found.
+    """
+    imports = frame.nodes_of_class((nodes.Import, nodes.ImportFrom))
+    for import_node in imports:
+        for import_name, import_alias in import_node.names:
+            # If the import uses an alias, check only that.
+            # Otherwise, check only the import name.
+            if import_alias:
+                if import_alias == name:
+                    return True
+            elif import_name and import_name == name:
+                return True
+    return None
+
+
+def _import_name_is_global(stmt, global_names):
+    for import_name, import_alias in stmt.names:
+        # If the import uses an alias, check only that.
+        # Otherwise, check only the import name.
+        if import_alias:
+            if import_alias in global_names:
+                return True
+        elif import_name in global_names:
+            return True
+    return False
+
+
+def _flattened_scope_names(
+    iterator: Iterator[Union[nodes.Global, nodes.Nonlocal]]
+) -> Set[str]:
+    values = (set(stmt.names) for stmt in iterator)
+    return set(itertools.chain.from_iterable(values))
+
+
+def _assigned_locally(name_node):
+    """Checks if name_node has corresponding assign statement in same scope."""
+    assign_stmts = name_node.scope().nodes_of_class(nodes.AssignName)
+    return any(a.name == name_node.name for a in assign_stmts)
+
+
+def _has_locals_call_after_node(stmt, scope):
+    skip_nodes = (
+        nodes.FunctionDef,
+        nodes.ClassDef,
+        nodes.Import,
+        nodes.ImportFrom,
+    )
+    for call in scope.nodes_of_class(nodes.Call, skip_klass=skip_nodes):
+        inferred = utils.safe_infer(call.func)
+        if (
+            utils.is_builtin_object(inferred)
+            and getattr(inferred, "name", None) == "locals"
+        ):
+            if stmt.lineno < call.lineno:
+                return True
+    return False
+
+
+MSGS = {
+    "E0601": (
+        "Using variable %r before assignment",
+        "used-before-assignment",
+        "Emitted when a local variable is accessed before its assignment took place. "
+        "Assignments in try blocks are assumed not to have occurred when evaluating "
+        "associated except/finally blocks. Assignments in except blocks are assumed "
+        "not to have occurred when evaluating statements outside the block, except "
+        "when the associated try block contains a return statement.",
+    ),
+    "E0602": (
+        "Undefined variable %r",
+        "undefined-variable",
+        "Used when an undefined variable is accessed.",
+    ),
+    "E0603": (
+        "Undefined variable name %r in __all__",
+        "undefined-all-variable",
+        "Used when an undefined variable name is referenced in __all__.",
+    ),
+    "E0604": (
+        "Invalid object %r in __all__, must contain only strings",
+        "invalid-all-object",
+        "Used when an invalid (non-string) object occurs in __all__.",
+    ),
+    "E0605": (
+        "Invalid format for __all__, must be tuple or list",
+        "invalid-all-format",
+        "Used when __all__ has an invalid format.",
+    ),
+    "E0611": (
+        "No name %r in module %r",
+        "no-name-in-module",
+        "Used when a name cannot be found in a module.",
+    ),
+    "W0601": (
+        "Global variable %r undefined at the module level",
+        "global-variable-undefined",
+        'Used when a variable is defined through the "global" statement '
+        "but the variable is not defined in the module scope.",
+    ),
+    "W0602": (
+        "Using global for %r but no assignment is done",
+        "global-variable-not-assigned",
+        'Used when a variable is defined through the "global" statement '
+        "but no assignment to this variable is done.",
+    ),
+    "W0603": (
+        "Using the global statement",  # W0121
+        "global-statement",
+        'Used when you use the "global" statement to update a global '
+        "variable. Pylint just try to discourage this "
+        "usage. That doesn't mean you cannot use it !",
+    ),
+    "W0604": (
+        "Using the global statement at the module level",  # W0103
+        "global-at-module-level",
+        'Used when you use the "global" statement at the module level '
+        "since it has no effect",
+    ),
+    "W0611": (
+        "Unused %s",
+        "unused-import",
+        "Used when an imported module or variable is not used.",
+    ),
+    "W0612": (
+        "Unused variable %r",
+        "unused-variable",
+        "Used when a variable is defined but not used.",
+    ),
+    "W0613": (
+        "Unused argument %r",
+        "unused-argument",
+        "Used when a function or method argument is not used.",
+    ),
+    "W0614": (
+        "Unused import(s) %s from wildcard import of %s",
+        "unused-wildcard-import",
+        "Used when an imported module or variable is not used from a "
+        "`'from X import *'` style import.",
+    ),
+    "W0621": (
+        "Redefining name %r from outer scope (line %s)",
+        "redefined-outer-name",
+        "Used when a variable's name hides a name defined in the outer scope.",
+    ),
+    "W0622": (
+        "Redefining built-in %r",
+        "redefined-builtin",
+        "Used when a variable or function override a built-in.",
+    ),
+    "W0631": (
+        "Using possibly undefined loop variable %r",
+        "undefined-loop-variable",
+        "Used when a loop variable (i.e. defined by a for loop or "
+        "a list comprehension or a generator expression) is used outside "
+        "the loop.",
+    ),
+    "W0632": (
+        "Possible unbalanced tuple unpacking with "
+        "sequence%s: "
+        "left side has %d label(s), right side has %d value(s)",
+        "unbalanced-tuple-unpacking",
+        "Used when there is an unbalanced tuple unpacking in assignment",
+        {"old_names": [("E0632", "old-unbalanced-tuple-unpacking")]},
+    ),
+    "E0633": (
+        "Attempting to unpack a non-sequence%s",
+        "unpacking-non-sequence",
+        "Used when something which is not "
+        "a sequence is used in an unpack assignment",
+        {"old_names": [("W0633", "old-unpacking-non-sequence")]},
+    ),
+    "W0640": (
+        "Cell variable %s defined in loop",
+        "cell-var-from-loop",
+        "A variable used in a closure is defined in a loop. "
+        "This will result in all closures using the same value for "
+        "the closed-over variable.",
+    ),
+    "W0641": (
+        "Possibly unused variable %r",
+        "possibly-unused-variable",
+        "Used when a variable is defined but might not be used. "
+        "The possibility comes from the fact that locals() might be used, "
+        "which could consume or not the said variable",
+    ),
+    "W0642": (
+        "Invalid assignment to %s in method",
+        "self-cls-assignment",
+        "Invalid assignment to self or cls in instance or class method "
+        "respectively.",
+    ),
+}
+
+
+class ScopeConsumer(NamedTuple):
+    """Store nodes and their consumption states."""
+
+    to_consume: Dict[str, List[nodes.NodeNG]]
+    consumed: Dict[str, List[nodes.NodeNG]]
+    consumed_uncertain: DefaultDict[str, List[nodes.NodeNG]]
+    scope_type: str
+
+
+class NamesConsumer:
+    """A simple class to handle consumed, to consume and scope type info of node locals."""
+
+    def __init__(self, node, scope_type):
+        self._atomic = ScopeConsumer(
+            copy.copy(node.locals), {}, collections.defaultdict(list), scope_type
+        )
+        self.node = node
+
+    def __repr__(self):
+        to_consumes = [f"{k}->{v}" for k, v in self._atomic.to_consume.items()]
+        consumed = [f"{k}->{v}" for k, v in self._atomic.consumed.items()]
+        consumed_uncertain = [
+            f"{k}->{v}" for k, v in self._atomic.consumed_uncertain.items()
+        ]
+        to_consumes = ", ".join(to_consumes)
+        consumed = ", ".join(consumed)
+        consumed_uncertain = ", ".join(consumed_uncertain)
+        return f"""
+to_consume : {to_consumes}
+consumed : {consumed}
+consumed_uncertain: {consumed_uncertain}
+scope_type : {self._atomic.scope_type}
+"""
+
+    def __iter__(self):
+        return iter(self._atomic)
+
+    @property
+    def to_consume(self):
+        return self._atomic.to_consume
+
+    @property
+    def consumed(self):
+        return self._atomic.consumed
+
+    @property
+    def consumed_uncertain(self) -> DefaultDict[str, List[nodes.NodeNG]]:
+        """Retrieves nodes filtered out by get_next_to_consume() that may not
+        have executed, such as statements in except blocks, or statements
+
+        in try blocks (when evaluating their corresponding except and finally
+        blocks). Checkers that want to treat the statements as executed
+        (e.g. for unused-variable) may need to add them back.
+        """
+        return self._atomic.consumed_uncertain
+
+    @property
+    def scope_type(self):
+        return self._atomic.scope_type
+
+    def mark_as_consumed(self, name, consumed_nodes):
+        """Mark the given nodes as consumed for the name.
+
+        If all of the nodes for the name were consumed, delete the name from
+        the to_consume dictionary
+        """
+        unconsumed = [n for n in self.to_consume[name] if n not in set(consumed_nodes)]
+        self.consumed[name] = consumed_nodes
+
+        if unconsumed:
+            self.to_consume[name] = unconsumed
+        else:
+            del self.to_consume[name]
+
+    def get_next_to_consume(self, node: nodes.Name) -> Optional[List[nodes.NodeNG]]:
+        """Return a list of the nodes that define `node` from this scope.
+
+        If it is uncertain whether a node will be consumed, such as for statements in
+        except blocks, add it to self.consumed_uncertain instead of returning it.
+        Return None to indicate a special case that needs to be handled by the caller.
+        """
+        name = node.name
+        parent_node = node.parent
+        found_nodes = self.to_consume.get(name)
+        node_statement = node.statement(future=True)
+        if (
+            found_nodes
+            and isinstance(parent_node, nodes.Assign)
+            and parent_node == found_nodes[0].parent
+        ):
+            lhs = found_nodes[0].parent.targets[0]
+            if lhs.name == name:  # this name is defined in this very statement
+                found_nodes = None
+
+        if (
+            found_nodes
+            and isinstance(parent_node, nodes.For)
+            and parent_node.iter == node
+            and parent_node.target in found_nodes
+        ):
+            found_nodes = None
+
+        # Before filtering, check that this node's name is not a nonlocal
+        if any(
+            isinstance(child, nodes.Nonlocal) and node.name in child.names
+            for child in node.frame(future=True).get_children()
+        ):
+            return found_nodes
+
+        # And no comprehension is under the node's frame
+        if VariablesChecker._comprehension_between_frame_and_node(node):
+            return found_nodes
+
+        # Filter out assignments in ExceptHandlers that node is not contained in
+        if found_nodes:
+            found_nodes = [
+                n
+                for n in found_nodes
+                if not isinstance(n.statement(future=True), nodes.ExceptHandler)
+                or n.statement(future=True).parent_of(node)
+            ]
+
+        # Filter out assignments in an Except clause that the node is not
+        # contained in, assuming they may fail
+        if found_nodes:
+            uncertain_nodes = self._uncertain_nodes_in_except_blocks(
+                found_nodes, node, node_statement
+            )
+            self.consumed_uncertain[node.name] += uncertain_nodes
+            uncertain_nodes_set = set(uncertain_nodes)
+            found_nodes = [n for n in found_nodes if n not in uncertain_nodes_set]
+
+        # If this node is in a Finally block of a Try/Finally,
+        # filter out assignments in the try portion, assuming they may fail
+        if found_nodes:
+            uncertain_nodes = (
+                self._uncertain_nodes_in_try_blocks_when_evaluating_finally_blocks(
+                    found_nodes, node_statement
+                )
+            )
+            self.consumed_uncertain[node.name] += uncertain_nodes
+            uncertain_nodes_set = set(uncertain_nodes)
+            found_nodes = [n for n in found_nodes if n not in uncertain_nodes_set]
+
+        # If this node is in an ExceptHandler,
+        # filter out assignments in the try portion, assuming they may fail
+        if found_nodes:
+            uncertain_nodes = (
+                self._uncertain_nodes_in_try_blocks_when_evaluating_except_blocks(
+                    found_nodes, node_statement
+                )
+            )
+            self.consumed_uncertain[node.name] += uncertain_nodes
+            uncertain_nodes_set = set(uncertain_nodes)
+            found_nodes = [n for n in found_nodes if n not in uncertain_nodes_set]
+
+        return found_nodes
+
+    @staticmethod
+    def _uncertain_nodes_in_except_blocks(
+        found_nodes: List[nodes.NodeNG],
+        node: nodes.NodeNG,
+        node_statement: nodes.Statement,
+    ) -> List[nodes.NodeNG]:
+        """Return any nodes in ``found_nodes`` that should be treated as uncertain
+        because they are in an except block.
+        """
+        uncertain_nodes = []
+        for other_node in found_nodes:
+            other_node_statement = other_node.statement(future=True)
+            # Only testing for statements in the except block of TryExcept
+            closest_except_handler = utils.get_node_first_ancestor_of_type(
+                other_node_statement, nodes.ExceptHandler
+            )
+            if not closest_except_handler:
+                continue
+            # If the other node is in the same scope as this node, assume it executes
+            if closest_except_handler.parent_of(node):
+                continue
+            closest_try_except: nodes.TryExcept = closest_except_handler.parent
+            try_block_returns = any(
+                isinstance(try_statement, nodes.Return)
+                for try_statement in closest_try_except.body
+            )
+            # If the try block returns, assume the except blocks execute.
+            if try_block_returns:
+                # Exception: if this node is in the final block of the other_node_statement,
+                # it will execute before returning. Assume the except statements are uncertain.
+                if (
+                    isinstance(node_statement.parent, nodes.TryFinally)
+                    and node_statement in node_statement.parent.finalbody
+                    and closest_try_except.parent.parent_of(node_statement)
+                ):
+                    uncertain_nodes.append(other_node)
+                # Assume the except blocks execute, so long as each handler
+                # defines the name, raises, or returns.
+                elif all(
+                    NamesConsumer._defines_name_raises_or_returns(node.name, handler)
+                    for handler in closest_try_except.handlers
+                ):
+                    continue
+
+            if NamesConsumer._check_loop_finishes_via_except(node, closest_try_except):
+                continue
+
+            # Passed all tests for uncertain execution
+            uncertain_nodes.append(other_node)
+        return uncertain_nodes
+
+    @staticmethod
+    def _defines_name_raises_or_returns(
+        name: str, handler: nodes.ExceptHandler
+    ) -> bool:
+        """Return True if some child of `handler` defines the name `name`,
+        raises, or returns.
+        """
+
+        def _define_raise_or_return(stmt: nodes.NodeNG) -> bool:
+            if isinstance(stmt, (nodes.Raise, nodes.Return)):
+                return True
+            if isinstance(stmt, nodes.Assign):
+                for target in stmt.targets:
+                    for elt in utils.get_all_elements(target):
+                        if isinstance(elt, nodes.AssignName) and elt.name == name:
+                            return True
+            if isinstance(stmt, nodes.If):
+                # Check for assignments inside the test
+                if (
+                    isinstance(stmt.test, nodes.NamedExpr)
+                    and stmt.test.target.name == name
+                ):
+                    return True
+                if isinstance(stmt.test, nodes.Call):
+                    for arg_or_kwarg in stmt.test.args + [
+                        kw.value for kw in stmt.test.keywords
+                    ]:
+                        if (
+                            isinstance(arg_or_kwarg, nodes.NamedExpr)
+                            and arg_or_kwarg.target.name == name
+                        ):
+                            return True
+            return False
+
+        for stmt in handler.get_children():
+            if _define_raise_or_return(stmt):
+                return True
+            if isinstance(stmt, (nodes.If, nodes.With)):
+                if any(
+                    _define_raise_or_return(nested_stmt)
+                    for nested_stmt in stmt.get_children()
+                ):
+                    return True
+        return False
+
+    @staticmethod
+    def _check_loop_finishes_via_except(
+        node: nodes.NodeNG, other_node_try_except: nodes.TryExcept
+    ) -> bool:
+        """Check for a case described in https://github.com/PyCQA/pylint/issues/5683.
+
+        It consists of a specific control flow scenario where the only
+        non-break exit from a loop consists of the very except handler we are
+        examining, such that code in the `else` branch of the loop can depend on it
+        being assigned.
+
+        Example:
+
+        for _ in range(3):
+            try:
+                do_something()
+            except:
+                name = 1  <-- only non-break exit from loop
+            else:
+                break
+        else:
+            print(name)
+        """
+        if not other_node_try_except.orelse:
+            return False
+        closest_loop: Optional[
+            Union[nodes.For, nodes.While]
+        ] = utils.get_node_first_ancestor_of_type(node, (nodes.For, nodes.While))
+        if closest_loop is None:
+            return False
+        if not any(
+            else_statement is node or else_statement.parent_of(node)
+            for else_statement in closest_loop.orelse
+        ):
+            # `node` not guarded by `else`
+            return False
+        for inner_else_statement in other_node_try_except.orelse:
+            if isinstance(inner_else_statement, nodes.Break):
+                break_stmt = inner_else_statement
+                break
+        else:
+            # No break statement
+            return False
+
+        def _try_in_loop_body(
+            other_node_try_except: nodes.TryExcept, loop: Union[nodes.For, nodes.While]
+        ) -> bool:
+            """Return True if `other_node_try_except` is a descendant of `loop`."""
+            return any(
+                loop_body_statement is other_node_try_except
+                or loop_body_statement.parent_of(other_node_try_except)
+                for loop_body_statement in loop.body
+            )
+
+        if not _try_in_loop_body(other_node_try_except, closest_loop):
+            for ancestor in closest_loop.node_ancestors():
+                if isinstance(ancestor, (nodes.For, nodes.While)):
+                    if _try_in_loop_body(other_node_try_except, ancestor):
+                        break
+            else:
+                # `other_node_try_except` didn't have a shared ancestor loop
+                return False
+
+        for loop_stmt in closest_loop.body:
+            if NamesConsumer._recursive_search_for_continue_before_break(
+                loop_stmt, break_stmt
+            ):
+                break
+        else:
+            # No continue found, so we arrived at our special case!
+            return True
+        return False
+
+    @staticmethod
+    def _recursive_search_for_continue_before_break(
+        stmt: nodes.Statement, break_stmt: nodes.Break
+    ) -> bool:
+        """Return True if any Continue node can be found in descendants of `stmt`
+        before encountering `break_stmt`, ignoring any nested loops.
+        """
+        if stmt is break_stmt:
+            return False
+        if isinstance(stmt, nodes.Continue):
+            return True
+        for child in stmt.get_children():
+            if isinstance(stmt, (nodes.For, nodes.While)):
+                continue
+            if NamesConsumer._recursive_search_for_continue_before_break(
+                child, break_stmt
+            ):
+                return True
+        return False
+
+    @staticmethod
+    def _uncertain_nodes_in_try_blocks_when_evaluating_except_blocks(
+        found_nodes: List[nodes.NodeNG], node_statement: nodes.Statement
+    ) -> List[nodes.NodeNG]:
+        """Return any nodes in ``found_nodes`` that should be treated as uncertain because they
+        are in a try block and the ``node_statement`` being evaluated is in one of its except handlers.
+        """
+        uncertain_nodes: List[nodes.NodeNG] = []
+        closest_except_handler = utils.get_node_first_ancestor_of_type(
+            node_statement, nodes.ExceptHandler
+        )
+        if closest_except_handler is None:
+            return uncertain_nodes
+        for other_node in found_nodes:
+            other_node_statement = other_node.statement(future=True)
+            # If the other statement is the except handler guarding `node`, it executes
+            if other_node_statement is closest_except_handler:
+                continue
+            # Ensure other_node is in a try block
+            (
+                other_node_try_ancestor,
+                other_node_try_ancestor_visited_child,
+            ) = utils.get_node_first_ancestor_of_type_and_its_child(
+                other_node_statement, nodes.TryExcept
+            )
+            if other_node_try_ancestor is None:
+                continue
+            if (
+                other_node_try_ancestor_visited_child
+                not in other_node_try_ancestor.body
+            ):
+                continue
+            # Make sure nesting is correct -- there should be at least one
+            # except handler that is a sibling attached to the try ancestor,
+            # or is an ancestor of the try ancestor.
+            if not any(
+                closest_except_handler in other_node_try_ancestor.handlers
+                or other_node_try_ancestor_except_handler
+                in closest_except_handler.node_ancestors()
+                for other_node_try_ancestor_except_handler in other_node_try_ancestor.handlers
+            ):
+                continue
+            # Passed all tests for uncertain execution
+            uncertain_nodes.append(other_node)
+        return uncertain_nodes
+
+    @staticmethod
+    def _uncertain_nodes_in_try_blocks_when_evaluating_finally_blocks(
+        found_nodes: List[nodes.NodeNG], node_statement: nodes.Statement
+    ) -> List[nodes.NodeNG]:
+        uncertain_nodes: List[nodes.NodeNG] = []
+        (
+            closest_try_finally_ancestor,
+            child_of_closest_try_finally_ancestor,
+        ) = utils.get_node_first_ancestor_of_type_and_its_child(
+            node_statement, nodes.TryFinally
+        )
+        if closest_try_finally_ancestor is None:
+            return uncertain_nodes
+        if (
+            child_of_closest_try_finally_ancestor
+            not in closest_try_finally_ancestor.finalbody
+        ):
+            return uncertain_nodes
+        for other_node in found_nodes:
+            other_node_statement = other_node.statement(future=True)
+            (
+                other_node_try_finally_ancestor,
+                child_of_other_node_try_finally_ancestor,
+            ) = utils.get_node_first_ancestor_of_type_and_its_child(
+                other_node_statement, nodes.TryFinally
+            )
+            if other_node_try_finally_ancestor is None:
+                continue
+            # other_node needs to descend from the try of a try/finally.
+            if (
+                child_of_other_node_try_finally_ancestor
+                not in other_node_try_finally_ancestor.body
+            ):
+                continue
+            # If the two try/finally ancestors are not the same, then
+            # node_statement's closest try/finally ancestor needs to be in
+            # the final body of other_node's try/finally ancestor, or
+            # descend from one of the statements in that final body.
+            if (
+                other_node_try_finally_ancestor is not closest_try_finally_ancestor
+                and not any(
+                    other_node_final_statement is closest_try_finally_ancestor
+                    or other_node_final_statement.parent_of(
+                        closest_try_finally_ancestor
+                    )
+                    for other_node_final_statement in other_node_try_finally_ancestor.finalbody
+                )
+            ):
+                continue
+            # Passed all tests for uncertain execution
+            uncertain_nodes.append(other_node)
+        return uncertain_nodes
+
+
+# pylint: disable=too-many-public-methods
+class VariablesChecker(BaseChecker):
+    """BaseChecker for variables.
+
+    Checks for
+    * unused variables / imports
+    * undefined variables
+    * redefinition of variable from builtins or from an outer scope
+    * use of variable before assignment
+    * __all__ consistency
+    * self/cls assignment
+    """
+
+    __implements__ = IAstroidChecker
+
+    name = "variables"
+    msgs = MSGS
+    priority = -1
+    options = (
+        (
+            "init-import",
+            {
+                "default": 0,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Tells whether we should check for unused import in "
+                "__init__ files.",
+            },
+        ),
+        (
+            "dummy-variables-rgx",
+            {
+                "default": "_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_",
+                "type": "regexp",
+                "metavar": "<regexp>",
+                "help": "A regular expression matching the name of dummy "
+                "variables (i.e. expected to not be used).",
+            },
+        ),
+        (
+            "additional-builtins",
+            {
+                "default": (),
+                "type": "csv",
+                "metavar": "<comma separated list>",
+                "help": "List of additional names supposed to be defined in "
+                "builtins. Remember that you should avoid defining new builtins "
+                "when possible.",
+            },
+        ),
+        (
+            "callbacks",
+            {
+                "default": ("cb_", "_cb"),
+                "type": "csv",
+                "metavar": "<callbacks>",
+                "help": "List of strings which can identify a callback "
+                "function by name. A callback name must start or "
+                "end with one of those strings.",
+            },
+        ),
+        (
+            "redefining-builtins-modules",
+            {
+                "default": (
+                    "six.moves",
+                    "past.builtins",
+                    "future.builtins",
+                    "builtins",
+                    "io",
+                ),
+                "type": "csv",
+                "metavar": "<comma separated list>",
+                "help": "List of qualified module names which can have objects "
+                "that can redefine builtins.",
+            },
+        ),
+        (
+            "ignored-argument-names",
+            {
+                "default": IGNORED_ARGUMENT_NAMES,
+                "type": "regexp",
+                "metavar": "<regexp>",
+                "help": "Argument names that match this expression will be "
+                "ignored. Default to name with leading underscore.",
+            },
+        ),
+        (
+            "allow-global-unused-variables",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Tells whether unused global variables should be treated as a violation.",
+            },
+        ),
+        (
+            "allowed-redefined-builtins",
+            {
+                "default": (),
+                "type": "csv",
+                "metavar": "<comma separated list>",
+                "help": "List of names allowed to shadow builtins",
+            },
+        ),
+    )
+
+    def __init__(self, linter=None):
+        super().__init__(linter)
+        self._to_consume: List[NamesConsumer] = []
+        self._checking_mod_attr = None
+        self._loop_variables = []
+        self._type_annotation_names = []
+        self._except_handler_names_queue: List[
+            Tuple[nodes.ExceptHandler, nodes.AssignName]
+        ] = []
+        """This is a queue, last in first out."""
+        self._postponed_evaluation_enabled = False
+
+    def open(self) -> None:
+        """Called when loading the checker."""
+        self._is_undefined_variable_enabled = self.linter.is_message_enabled(
+            "undefined-variable"
+        )
+        self._is_undefined_loop_variable_enabled = self.linter.is_message_enabled(
+            "undefined-loop-variable"
+        )
+
+    @utils.check_messages("redefined-outer-name")
+    def visit_for(self, node: nodes.For) -> None:
+        assigned_to = [a.name for a in node.target.nodes_of_class(nodes.AssignName)]
+
+        # Only check variables that are used
+        dummy_rgx = self.config.dummy_variables_rgx
+        assigned_to = [var for var in assigned_to if not dummy_rgx.match(var)]
+
+        for variable in assigned_to:
+            for outer_for, outer_variables in self._loop_variables:
+                if variable in outer_variables and not in_for_else_branch(
+                    outer_for, node
+                ):
+                    self.add_message(
+                        "redefined-outer-name",
+                        args=(variable, outer_for.fromlineno),
+                        node=node,
+                    )
+                    break
+
+        self._loop_variables.append((node, assigned_to))
+
+    @utils.check_messages("redefined-outer-name")
+    def leave_for(self, node: nodes.For) -> None:
+        self._loop_variables.pop()
+        self._store_type_annotation_names(node)
+
+    def visit_module(self, node: nodes.Module) -> None:
+        """Visit module : update consumption analysis variable
+        checks globals doesn't overrides builtins
+        """
+        self._to_consume = [NamesConsumer(node, "module")]
+        self._postponed_evaluation_enabled = is_postponed_evaluation_enabled(node)
+
+        for name, stmts in node.locals.items():
+            if utils.is_builtin(name):
+                if self._should_ignore_redefined_builtin(stmts[0]) or name == "__doc__":
+                    continue
+                self.add_message("redefined-builtin", args=name, node=stmts[0])
+
+    @utils.check_messages(
+        "unused-import",
+        "unused-wildcard-import",
+        "redefined-builtin",
+        "undefined-all-variable",
+        "invalid-all-object",
+        "invalid-all-format",
+        "unused-variable",
+    )
+    def leave_module(self, node: nodes.Module) -> None:
+        """Leave module: check globals."""
+        assert len(self._to_consume) == 1
+
+        self._check_metaclasses(node)
+        not_consumed = self._to_consume.pop().to_consume
+        # attempt to check for __all__ if defined
+        if "__all__" in node.locals:
+            self._check_all(node, not_consumed)
+
+        # check for unused globals
+        self._check_globals(not_consumed)
+
+        # don't check unused imports in __init__ files
+        if not self.config.init_import and node.package:
+            return
+
+        self._check_imports(not_consumed)
+
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        """Visit class: update consumption analysis variable."""
+        self._to_consume.append(NamesConsumer(node, "class"))
+
+    def leave_classdef(self, _: nodes.ClassDef) -> None:
+        """Leave class: update consumption analysis variable."""
+        # do not check for not used locals here (no sense)
+        self._to_consume.pop()
+
+    def visit_lambda(self, node: nodes.Lambda) -> None:
+        """Visit lambda: update consumption analysis variable."""
+        self._to_consume.append(NamesConsumer(node, "lambda"))
+
+    def leave_lambda(self, _: nodes.Lambda) -> None:
+        """Leave lambda: update consumption analysis variable."""
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_generatorexp(self, node: nodes.GeneratorExp) -> None:
+        """Visit genexpr: update consumption analysis variable."""
+        self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+    def leave_generatorexp(self, _: nodes.GeneratorExp) -> None:
+        """Leave genexpr: update consumption analysis variable."""
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_dictcomp(self, node: nodes.DictComp) -> None:
+        """Visit dictcomp: update consumption analysis variable."""
+        self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+    def leave_dictcomp(self, _: nodes.DictComp) -> None:
+        """Leave dictcomp: update consumption analysis variable."""
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_setcomp(self, node: nodes.SetComp) -> None:
+        """Visit setcomp: update consumption analysis variable."""
+        self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+    def leave_setcomp(self, _: nodes.SetComp) -> None:
+        """Leave setcomp: update consumption analysis variable."""
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        """Visit function: update consumption analysis variable and check locals."""
+        self._to_consume.append(NamesConsumer(node, "function"))
+        if not (
+            self.linter.is_message_enabled("redefined-outer-name")
+            or self.linter.is_message_enabled("redefined-builtin")
+        ):
+            return
+        globs = node.root().globals
+        for name, stmt in node.items():
+            if name in globs and not isinstance(stmt, nodes.Global):
+                definition = globs[name][0]
+                if (
+                    isinstance(definition, nodes.ImportFrom)
+                    and definition.modname == FUTURE
+                ):
+                    # It is a __future__ directive, not a symbol.
+                    continue
+
+                # Do not take in account redefined names for the purpose
+                # of type checking.:
+                if any(
+                    isinstance(definition.parent, nodes.If)
+                    and definition.parent.test.as_string() in TYPING_TYPE_CHECKS_GUARDS
+                    for definition in globs[name]
+                ):
+                    continue
+
+                line = definition.fromlineno
+                if not self._is_name_ignored(stmt, name):
+                    self.add_message(
+                        "redefined-outer-name", args=(name, line), node=stmt
+                    )
+
+            elif (
+                utils.is_builtin(name)
+                and not self._allowed_redefined_builtin(name)
+                and not self._should_ignore_redefined_builtin(stmt)
+            ):
+                # do not print Redefining builtin for additional builtins
+                self.add_message("redefined-builtin", args=name, node=stmt)
+
+    def leave_functiondef(self, node: nodes.FunctionDef) -> None:
+        """Leave function: check function's locals are consumed."""
+        self._check_metaclasses(node)
+
+        if node.type_comment_returns:
+            self._store_type_annotation_node(node.type_comment_returns)
+        if node.type_comment_args:
+            for argument_annotation in node.type_comment_args:
+                self._store_type_annotation_node(argument_annotation)
+
+        not_consumed = self._to_consume.pop().to_consume
+        if not (
+            self.linter.is_message_enabled("unused-variable")
+            or self.linter.is_message_enabled("possibly-unused-variable")
+            or self.linter.is_message_enabled("unused-argument")
+        ):
+            return
+
+        # Don't check arguments of function which are only raising an exception.
+        if utils.is_error(node):
+            return
+
+        # Don't check arguments of abstract methods or within an interface.
+        is_method = node.is_method()
+        if is_method and node.is_abstract():
+            return
+
+        global_names = _flattened_scope_names(node.nodes_of_class(nodes.Global))
+        nonlocal_names = _flattened_scope_names(node.nodes_of_class(nodes.Nonlocal))
+        comprehension_target_names: List[str] = []
+
+        for comprehension_scope in node.nodes_of_class(nodes.ComprehensionScope):
+            for generator in comprehension_scope.generators:
+                self._find_assigned_names_recursive(
+                    generator.target, comprehension_target_names
+                )
+
+        for name, stmts in not_consumed.items():
+            self._check_is_unused(
+                name,
+                node,
+                stmts[0],
+                global_names,
+                nonlocal_names,
+                comprehension_target_names,
+            )
+
+    visit_asyncfunctiondef = visit_functiondef
+    leave_asyncfunctiondef = leave_functiondef
+
+    @utils.check_messages(
+        "global-variable-undefined",
+        "global-variable-not-assigned",
+        "global-statement",
+        "global-at-module-level",
+        "redefined-builtin",
+    )
+    def visit_global(self, node: nodes.Global) -> None:
+        """Check names imported exists in the global scope."""
+        frame = node.frame(future=True)
+        if isinstance(frame, nodes.Module):
+            self.add_message("global-at-module-level", node=node)
+            return
+
+        module = frame.root()
+        default_message = True
+        locals_ = node.scope().locals
+        for name in node.names:
+            try:
+                assign_nodes = module.getattr(name)
+            except astroid.NotFoundError:
+                # unassigned global, skip
+                assign_nodes = []
+
+            not_defined_locally_by_import = not any(
+                isinstance(local, nodes.Import) for local in locals_.get(name, ())
+            )
+            if (
+                not utils.is_reassigned_after_current(node, name)
+                and not utils.is_deleted_after_current(node, name)
+                and not_defined_locally_by_import
+            ):
+                self.add_message("global-variable-not-assigned", args=name, node=node)
+                default_message = False
+                continue
+
+            for anode in assign_nodes:
+                if (
+                    isinstance(anode, nodes.AssignName)
+                    and anode.name in module.special_attributes
+                ):
+                    self.add_message("redefined-builtin", args=name, node=node)
+                    break
+                if anode.frame(future=True) is module:
+                    # module level assignment
+                    break
+                if (
+                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
+                    and anode.parent is module
+                ):
+                    # module level function assignment
+                    break
+            else:
+                if not_defined_locally_by_import:
+                    # global undefined at the module scope
+                    self.add_message("global-variable-undefined", args=name, node=node)
+                    default_message = False
+
+        if default_message:
+            self.add_message("global-statement", node=node)
+
+    def visit_assignname(self, node: nodes.AssignName) -> None:
+        if isinstance(node.assign_type(), nodes.AugAssign):
+            self.visit_name(node)
+
+    def visit_delname(self, node: nodes.DelName) -> None:
+        self.visit_name(node)
+
+    def visit_name(self, node: nodes.Name) -> None:
+        """Don't add the 'utils.check_messages' decorator here!
+
+        It's important that all 'Name' nodes are visited, otherwise the
+        'NamesConsumers' won't be correct.
+        """
+        stmt = node.statement(future=True)
+        if stmt.fromlineno is None:
+            # name node from an astroid built from live code, skip
+            assert not stmt.root().file.endswith(".py")
+            return
+
+        self._undefined_and_used_before_checker(node, stmt)
+        if self._is_undefined_loop_variable_enabled:
+            self._loopvar_name(node)
+
+    @utils.check_messages("redefined-outer-name")
+    def visit_excepthandler(self, node: nodes.ExceptHandler) -> None:
+        if not node.name or not isinstance(node.name, nodes.AssignName):
+            return
+
+        for outer_except, outer_except_assign_name in self._except_handler_names_queue:
+            if node.name.name == outer_except_assign_name.name:
+                self.add_message(
+                    "redefined-outer-name",
+                    args=(outer_except_assign_name.name, outer_except.fromlineno),
+                    node=node,
+                )
+                break
+
+        self._except_handler_names_queue.append((node, node.name))
+
+    @utils.check_messages("redefined-outer-name")
+    def leave_excepthandler(self, node: nodes.ExceptHandler) -> None:
+        if not node.name or not isinstance(node.name, nodes.AssignName):
+            return
+        self._except_handler_names_queue.pop()
+
+    def _undefined_and_used_before_checker(
+        self, node: nodes.Name, stmt: nodes.NodeNG
+    ) -> None:
+        frame = stmt.scope()
+        start_index = len(self._to_consume) - 1
+
+        # iterates through parent scopes, from the inner to the outer
+        base_scope_type = self._to_consume[start_index].scope_type
+
+        for i in range(start_index, -1, -1):
+            current_consumer = self._to_consume[i]
+
+            # Certain nodes shouldn't be checked as they get checked another time
+            if self._should_node_be_skipped(node, current_consumer, i == start_index):
+                continue
+
+            action, nodes_to_consume = self._check_consumer(
+                node, stmt, frame, current_consumer, base_scope_type
+            )
+            if nodes_to_consume:
+                # Any nodes added to consumed_uncertain by get_next_to_consume()
+                # should be added back so that they are marked as used.
+                # They will have already had a chance to emit used-before-assignment.
+                # We check here instead of before every single return in _check_consumer()
+                nodes_to_consume += current_consumer.consumed_uncertain[node.name]
+                current_consumer.mark_as_consumed(node.name, nodes_to_consume)
+            if action is VariableVisitConsumerAction.CONTINUE:
+                continue
+            if action is VariableVisitConsumerAction.RETURN:
+                return
+
+        # we have not found the name, if it isn't a builtin, that's an
+        # undefined name !
+        if (
+            self._is_undefined_variable_enabled
+            and not (
+                node.name in nodes.Module.scope_attrs
+                or utils.is_builtin(node.name)
+                or node.name in self.config.additional_builtins
+                or (
+                    node.name == "__class__"
+                    and isinstance(frame, nodes.FunctionDef)
+                    and frame.is_method()
+                )
+            )
+            and not utils.node_ignores_exception(node, NameError)
+        ):
+            self.add_message("undefined-variable", args=node.name, node=node)
+
+    def _should_node_be_skipped(
+        self, node: nodes.Name, consumer: NamesConsumer, is_start_index: bool
+    ) -> bool:
+        """Tests a consumer and node for various conditions in which the node
+        shouldn't be checked for the undefined-variable and used-before-assignment checks.
+        """
+        if consumer.scope_type == "class":
+            # The list of base classes in the class definition is not part
+            # of the class body.
+            # If the current scope is a class scope but it's not the inner
+            # scope, ignore it. This prevents to access this scope instead of
+            # the globals one in function members when there are some common
+            # names.
+            if utils.is_ancestor_name(consumer.node, node) or (
+                not is_start_index and self._ignore_class_scope(node)
+            ):
+                return True
+
+            # Ignore inner class scope for keywords in class definition
+            if isinstance(node.parent, nodes.Keyword) and isinstance(
+                node.parent.parent, nodes.ClassDef
+            ):
+                return True
+
+        elif consumer.scope_type == "function" and self._defined_in_function_definition(
+            node, consumer.node
+        ):
+            # If the name node is used as a function default argument's value or as
+            # a decorator, then start from the parent frame of the function instead
+            # of the function frame - and thus open an inner class scope
+            return True
+
+        elif consumer.scope_type == "lambda" and utils.is_default_argument(
+            node, consumer.node
+        ):
+            return True
+
+        return False
+
+    def _find_assigned_names_recursive(
+        self,
+        target: Union[nodes.AssignName, nodes.BaseContainer],
+        target_names: List[str],
+    ) -> None:
+        """Update `target_names` in place with the names of assignment
+        targets, recursively (to account for nested assignments).
+        """
+        if isinstance(target, nodes.AssignName):
+            target_names.append(target.name)
+        elif isinstance(target, nodes.BaseContainer):
+            for elt in target.elts:
+                self._find_assigned_names_recursive(elt, target_names)
+
+    # pylint: disable=too-many-return-statements
+    def _check_consumer(
+        self,
+        node: nodes.Name,
+        stmt: nodes.NodeNG,
+        frame: nodes.LocalsDictNodeNG,
+        current_consumer: NamesConsumer,
+        base_scope_type: Any,
+    ) -> Tuple[VariableVisitConsumerAction, Optional[List[nodes.NodeNG]]]:
+        """Checks a consumer for conditions that should trigger messages."""
+        # If the name has already been consumed, only check it's not a loop
+        # variable used outside the loop.
+        if node.name in current_consumer.consumed:
+            # Avoid the case where there are homonyms inside function scope and
+            # comprehension current scope (avoid bug #1731)
+            if utils.is_func_decorator(current_consumer.node) or not isinstance(
+                node, nodes.ComprehensionScope
+            ):
+                self._check_late_binding_closure(node)
+                self._loopvar_name(node)
+                return (VariableVisitConsumerAction.RETURN, None)
+
+        found_nodes = current_consumer.get_next_to_consume(node)
+        if found_nodes is None:
+            return (VariableVisitConsumerAction.CONTINUE, None)
+        if not found_nodes:
+            if node.name in current_consumer.consumed_uncertain:
+                confidence = CONTROL_FLOW
+            else:
+                confidence = HIGH
+            self.add_message(
+                "used-before-assignment",
+                args=node.name,
+                node=node,
+                confidence=confidence,
+            )
+            # Mark for consumption any nodes added to consumed_uncertain by
+            # get_next_to_consume() because they might not have executed.
+            return (
+                VariableVisitConsumerAction.RETURN,
+                current_consumer.consumed_uncertain[node.name],
+            )
+
+        self._check_late_binding_closure(node)
+
+        defnode = utils.assign_parent(found_nodes[0])
+        defstmt = defnode.statement(future=True)
+        defframe = defstmt.frame(future=True)
+
+        # The class reuses itself in the class scope.
+        is_recursive_klass = (
+            frame is defframe
+            and defframe.parent_of(node)
+            and isinstance(defframe, nodes.ClassDef)
+            and node.name == defframe.name
+        )
+
+        if (
+            is_recursive_klass
+            and utils.get_node_first_ancestor_of_type(node, nodes.Lambda)
+            and (
+                not utils.is_default_argument(node)
+                or node.scope().parent.scope() is not defframe
+            )
+        ):
+            # Self-referential class references are fine in lambda's --
+            # As long as they are not part of the default argument directly
+            # under the scope of the parent self-referring class.
+            # Example of valid default argument:
+            # class MyName3:
+            #     myattr = 1
+            #     mylambda3 = lambda: lambda a=MyName3: a
+            # Example of invalid default argument:
+            # class MyName4:
+            #     myattr = 1
+            #     mylambda4 = lambda a=MyName4: lambda: a
+
+            # If the above conditional is True,
+            # there is no possibility of undefined-variable
+            # Also do not consume class name
+            # (since consuming blocks subsequent checks)
+            # -- quit
+            return (VariableVisitConsumerAction.RETURN, None)
+
+        (
+            maybe_before_assign,
+            annotation_return,
+            use_outer_definition,
+        ) = self._is_variable_violation(
+            node,
+            defnode,
+            stmt,
+            defstmt,
+            frame,
+            defframe,
+            base_scope_type,
+            is_recursive_klass,
+        )
+
+        if use_outer_definition:
+            return (VariableVisitConsumerAction.CONTINUE, None)
+
+        if (
+            maybe_before_assign
+            and not utils.is_defined_before(node)
+            and not astroid.are_exclusive(stmt, defstmt, ("NameError",))
+        ):
+
+            # Used and defined in the same place, e.g `x += 1` and `del x`
+            defined_by_stmt = defstmt is stmt and isinstance(
+                node, (nodes.DelName, nodes.AssignName)
+            )
+            if (
+                is_recursive_klass
+                or defined_by_stmt
+                or annotation_return
+                or isinstance(defstmt, nodes.Delete)
+            ):
+                if not utils.node_ignores_exception(node, NameError):
+
+                    # Handle postponed evaluation of annotations
+                    if not (
+                        self._postponed_evaluation_enabled
+                        and isinstance(
+                            stmt,
+                            (
+                                nodes.AnnAssign,
+                                nodes.FunctionDef,
+                                nodes.Arguments,
+                            ),
+                        )
+                        and node.name in node.root().locals
+                    ):
+                        if defined_by_stmt:
+                            return (VariableVisitConsumerAction.CONTINUE, [node])
+                        return (VariableVisitConsumerAction.CONTINUE, None)
+
+            elif base_scope_type != "lambda":
+                # E0601 may *not* occurs in lambda scope.
+
+                # Handle postponed evaluation of annotations
+                if not (
+                    self._postponed_evaluation_enabled
+                    and isinstance(stmt, (nodes.AnnAssign, nodes.FunctionDef))
+                ):
+                    self.add_message(
+                        "used-before-assignment",
+                        args=node.name,
+                        node=node,
+                        confidence=HIGH,
+                    )
+                    return (VariableVisitConsumerAction.RETURN, found_nodes)
+
+            elif base_scope_type == "lambda":
+                # E0601 can occur in class-level scope in lambdas, as in
+                # the following example:
+                #   class A:
+                #      x = lambda attr: f + attr
+                #      f = 42
+                # We check lineno because doing the following is fine:
+                #   class A:
+                #      x = 42
+                #      y = lambda attr: x + attr
+                if (
+                    isinstance(frame, nodes.ClassDef)
+                    and node.name in frame.locals
+                    and stmt.fromlineno <= defstmt.fromlineno
+                ):
+                    self.add_message(
+                        "used-before-assignment",
+                        args=node.name,
+                        node=node,
+                        confidence=HIGH,
+                    )
+
+        elif self._is_only_type_assignment(node, defstmt):
+            if node.scope().locals.get(node.name):
+                self.add_message(
+                    "used-before-assignment", args=node.name, node=node, confidence=HIGH
+                )
+            else:
+                self.add_message(
+                    "undefined-variable", args=node.name, node=node, confidence=HIGH
+                )
+            return (VariableVisitConsumerAction.RETURN, found_nodes)
+
+        elif isinstance(defstmt, nodes.ClassDef):
+            return self._is_first_level_self_reference(node, defstmt, found_nodes)
+
+        elif isinstance(defnode, nodes.NamedExpr):
+            if isinstance(defnode.parent, nodes.IfExp):
+                if self._is_never_evaluated(defnode, defnode.parent):
+                    self.add_message(
+                        "undefined-variable",
+                        args=node.name,
+                        node=node,
+                        confidence=INFERENCE,
+                    )
+                    return (VariableVisitConsumerAction.RETURN, found_nodes)
+
+        return (VariableVisitConsumerAction.RETURN, found_nodes)
+
+    @utils.check_messages("no-name-in-module")
+    def visit_import(self, node: nodes.Import) -> None:
+        """Check modules attribute accesses."""
+        if not self._analyse_fallback_blocks and utils.is_from_fallback_block(node):
+            # No need to verify this, since ImportError is already
+            # handled by the client code.
+            return
+        if utils.is_node_in_guarded_import_block(node) is True:
+            # Don't verify import if part of guarded import block
+            # I.e. `sys.version_info` or `typing.TYPE_CHECKING`
+            return
+
+        for name, _ in node.names:
+            parts = name.split(".")
+            try:
+                module = next(_infer_name_module(node, parts[0]))
+            except astroid.ResolveError:
+                continue
+            if not isinstance(module, nodes.Module):
+                continue
+            self._check_module_attrs(node, module, parts[1:])
+
+    @utils.check_messages("no-name-in-module")
+    def visit_importfrom(self, node: nodes.ImportFrom) -> None:
+        """Check modules attribute accesses."""
+        if not self._analyse_fallback_blocks and utils.is_from_fallback_block(node):
+            # No need to verify this, since ImportError is already
+            # handled by the client code.
+            return
+        if utils.is_node_in_guarded_import_block(node) is True:
+            # Don't verify import if part of guarded import block
+            # I.e. `sys.version_info` or `typing.TYPE_CHECKING`
+            return
+
+        name_parts = node.modname.split(".")
+        try:
+            module = node.do_import_module(name_parts[0])
+        except astroid.AstroidBuildingException:
+            return
+        module = self._check_module_attrs(node, module, name_parts[1:])
+        if not module:
+            return
+        for name, _ in node.names:
+            if name == "*":
+                continue
+            self._check_module_attrs(node, module, name.split("."))
+
+    @utils.check_messages(
+        "unbalanced-tuple-unpacking", "unpacking-non-sequence", "self-cls-assignment"
+    )
+    def visit_assign(self, node: nodes.Assign) -> None:
+        """Check unbalanced tuple unpacking for assignments and unpacking
+        non-sequences as well as in case self/cls get assigned.
+        """
+        self._check_self_cls_assign(node)
+        if not isinstance(node.targets[0], (nodes.Tuple, nodes.List)):
+            return
+
+        targets = node.targets[0].itered()
+        try:
+            inferred = utils.safe_infer(node.value)
+            if inferred is not None:
+                self._check_unpacking(inferred, node, targets)
+        except astroid.InferenceError:
+            return
+
+    # listcomp have now also their scope
+    def visit_listcomp(self, node: nodes.ListComp) -> None:
+        """Visit dictcomp: update consumption analysis variable."""
+        self._to_consume.append(NamesConsumer(node, "comprehension"))
+
+    def leave_listcomp(self, _: nodes.ListComp) -> None:
+        """Leave dictcomp: update consumption analysis variable."""
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def leave_assign(self, node: nodes.Assign) -> None:
+        self._store_type_annotation_names(node)
+
+    def leave_with(self, node: nodes.With) -> None:
+        self._store_type_annotation_names(node)
+
+    def visit_arguments(self, node: nodes.Arguments) -> None:
+        for annotation in node.type_comment_args:
+            self._store_type_annotation_node(annotation)
+
+    # Relying on other checker's options, which might not have been initialized yet.
+    @cached_property
+    def _analyse_fallback_blocks(self):
+        return get_global_option(self, "analyse-fallback-blocks", default=False)
+
+    @cached_property
+    def _ignored_modules(self):
+        return get_global_option(self, "ignored-modules", default=[])
+
+    @cached_property
+    def _allow_global_unused_variables(self):
+        return get_global_option(self, "allow-global-unused-variables", default=True)
+
+    @staticmethod
+    def _defined_in_function_definition(node, frame):
+        in_annotation_or_default_or_decorator = False
+        if (
+            isinstance(frame, nodes.FunctionDef)
+            and node.statement(future=True) is frame
+        ):
+            in_annotation_or_default_or_decorator = (
+                (
+                    node in frame.args.annotations
+                    or node in frame.args.posonlyargs_annotations
+                    or node in frame.args.kwonlyargs_annotations
+                    or node is frame.args.varargannotation
+                    or node is frame.args.kwargannotation
+                )
+                or frame.args.parent_of(node)
+                or (frame.decorators and frame.decorators.parent_of(node))
+                or (
+                    frame.returns
+                    and (node is frame.returns or frame.returns.parent_of(node))
+                )
+            )
+        return in_annotation_or_default_or_decorator
+
+    @staticmethod
+    def _in_lambda_or_comprehension_body(
+        node: nodes.NodeNG, frame: nodes.NodeNG
+    ) -> bool:
+        """Return True if node within a lambda/comprehension body (or similar) and thus should not have access to class attributes in frame."""
+        child = node
+        parent = node.parent
+        while parent is not None:
+            if parent is frame:
+                return False
+            if isinstance(parent, nodes.Lambda) and child is not parent.args:
+                # Body of lambda should not have access to class attributes.
+                return True
+            if isinstance(parent, nodes.Comprehension) and child is not parent.iter:
+                # Only iter of list/set/dict/generator comprehension should have access.
+                return True
+            if isinstance(parent, nodes.ComprehensionScope) and not (
+                parent.generators and child is parent.generators[0]
+            ):
+                # Body of list/set/dict/generator comprehension should not have access to class attributes.
+                # Furthermore, only the first generator (if multiple) in comprehension should have access.
+                return True
+            child = parent
+            parent = parent.parent
+        return False
+
+    @staticmethod
+    def _is_variable_violation(
+        node: nodes.Name,
+        defnode,
+        stmt: nodes.Statement,
+        defstmt: nodes.Statement,
+        frame,  # scope of statement of node
+        defframe,
+        base_scope_type,
+        is_recursive_klass,
+    ) -> Tuple[bool, bool, bool]:
+        # pylint: disable=too-many-nested-blocks
+        maybe_before_assign = True
+        annotation_return = False
+        use_outer_definition = False
+        if frame is not defframe:
+            maybe_before_assign = _detect_global_scope(node, frame, defframe)
+        elif defframe.parent is None:
+            # we are at the module level, check the name is not
+            # defined in builtins
+            if (
+                node.name in defframe.scope_attrs
+                or astroid.builtin_lookup(node.name)[1]
+            ):
+                maybe_before_assign = False
+        else:
+            # we are in a local scope, check the name is not
+            # defined in global or builtin scope
+            # skip this lookup if name is assigned later in function scope/lambda
+            # Note: the node.frame() is not the same as the `frame` argument which is
+            # equivalent to frame.statement().scope()
+            forbid_lookup = (
+                isinstance(frame, nodes.FunctionDef)
+                or isinstance(node.frame(future=True), nodes.Lambda)
+            ) and _assigned_locally(node)
+            if not forbid_lookup and defframe.root().lookup(node.name)[1]:
+                maybe_before_assign = False
+                use_outer_definition = stmt == defstmt and not isinstance(
+                    defnode, nodes.Comprehension
+                )
+            # check if we have a nonlocal
+            elif node.name in defframe.locals:
+                maybe_before_assign = not any(
+                    isinstance(child, nodes.Nonlocal) and node.name in child.names
+                    for child in defframe.get_children()
+                )
+
+        if (
+            base_scope_type == "lambda"
+            and isinstance(frame, nodes.ClassDef)
+            and node.name in frame.locals
+        ):
+
+            # This rule verifies that if the definition node of the
+            # checked name is an Arguments node and if the name
+            # is used a default value in the arguments defaults
+            # and the actual definition of the variable label
+            # is happening before the Arguments definition.
+            #
+            # bar = None
+            # foo = lambda bar=bar: bar
+            #
+            # In this case, maybe_before_assign should be False, otherwise
+            # it should be True.
+            maybe_before_assign = not (
+                isinstance(defnode, nodes.Arguments)
+                and node in defnode.defaults
+                and frame.locals[node.name][0].fromlineno < defstmt.fromlineno
+            )
+        elif isinstance(defframe, nodes.ClassDef) and isinstance(
+            frame, nodes.FunctionDef
+        ):
+            # Special rule for function return annotations,
+            # using a name defined earlier in the class containing the function.
+            if node is frame.returns and defframe.parent_of(frame.returns):
+                annotation_return = True
+                if (
+                    frame.returns.name in defframe.locals
+                    and defframe.locals[node.name][0].lineno < frame.lineno
+                ):
+                    # Detect class assignments with a name defined earlier in the
+                    # class. In this case, no warning should be raised.
+                    maybe_before_assign = False
+                else:
+                    maybe_before_assign = True
+            if isinstance(node.parent, nodes.Arguments):
+                maybe_before_assign = stmt.fromlineno <= defstmt.fromlineno
+        elif is_recursive_klass:
+            maybe_before_assign = True
+        else:
+            maybe_before_assign = (
+                maybe_before_assign and stmt.fromlineno <= defstmt.fromlineno
+            )
+            if maybe_before_assign and stmt.fromlineno == defstmt.fromlineno:
+                if (
+                    isinstance(defframe, nodes.FunctionDef)
+                    and frame is defframe
+                    and defframe.parent_of(node)
+                    and stmt is not defstmt
+                ):
+                    # Single statement function, with the statement on the
+                    # same line as the function definition
+                    maybe_before_assign = False
+                elif (
+                    isinstance(
+                        defstmt,
+                        (
+                            nodes.Assign,
+                            nodes.AnnAssign,
+                            nodes.AugAssign,
+                            nodes.Expr,
+                            nodes.Return,
+                        ),
+                    )
+                    and VariablesChecker._maybe_used_and_assigned_at_once(defstmt)
+                    and frame is defframe
+                    and defframe.parent_of(node)
+                    and stmt is defstmt
+                ):
+                    # Single statement if, with assignment expression on same
+                    # line as assignment
+                    # x = b if (b := True) else False
+                    maybe_before_assign = False
+                elif (
+                    isinstance(  # pylint: disable=too-many-boolean-expressions
+                        defnode, nodes.NamedExpr
+                    )
+                    and frame is defframe
+                    and defframe.parent_of(stmt)
+                    and stmt is defstmt
+                    and (
+                        (
+                            defnode.lineno == node.lineno
+                            and defnode.col_offset < node.col_offset
+                        )
+                        or (defnode.lineno < node.lineno)
+                        or (
+                            # Issue in the `ast` module until py39
+                            # Nodes in a multiline string have the same lineno
+                            # Could be false-positive without check
+                            not PY39_PLUS
+                            and defnode.lineno == node.lineno
+                            and isinstance(
+                                defstmt,
+                                (
+                                    nodes.Assign,
+                                    nodes.AnnAssign,
+                                    nodes.AugAssign,
+                                    nodes.Return,
+                                ),
+                            )
+                            and isinstance(defstmt.value, nodes.JoinedStr)
+                        )
+                    )
+                ):
+                    # Expressions, with assignment expressions
+                    # Use only after assignment
+                    # b = (c := 2) and c
+                    maybe_before_assign = False
+
+            # Look for type checking definitions inside a type checking guard.
+            if isinstance(defstmt, (nodes.Import, nodes.ImportFrom)):
+                defstmt_parent = defstmt.parent
+
+                if (
+                    isinstance(defstmt_parent, nodes.If)
+                    and defstmt_parent.test.as_string() in TYPING_TYPE_CHECKS_GUARDS
+                ):
+                    # Exempt those definitions that are used inside the type checking
+                    # guard or that are defined in both type checking guard branches.
+                    used_in_branch = defstmt_parent.parent_of(node)
+                    defined_in_or_else = False
+
+                    for definition in defstmt_parent.orelse:
+                        if isinstance(definition, nodes.Assign):
+                            defined_in_or_else = any(
+                                target.name == node.name
+                                for target in definition.targets
+                                if isinstance(target, nodes.AssignName)
+                            )
+                            if defined_in_or_else:
+                                break
+
+                    if not used_in_branch and not defined_in_or_else:
+                        maybe_before_assign = True
+
+        return maybe_before_assign, annotation_return, use_outer_definition
+
+    @staticmethod
+    def _maybe_used_and_assigned_at_once(defstmt: nodes.Statement) -> bool:
+        """Check if `defstmt` has the potential to use and assign a name in the
+        same statement.
+        """
+        if isinstance(defstmt.value, nodes.BaseContainer) and defstmt.value.elts:
+            # The assignment must happen as part of the first element
+            # e.g. "assert (x:= True), x"
+            # NOT "assert x, (x:= True)"
+            value = defstmt.value.elts[0]
+        else:
+            value = defstmt.value
+        if isinstance(value, nodes.IfExp):
+            return True
+        if isinstance(value, nodes.Lambda) and isinstance(value.body, nodes.IfExp):
+            return True
+        return isinstance(value, nodes.Call) and (
+            any(isinstance(kwarg.value, nodes.IfExp) for kwarg in value.keywords)
+            or any(isinstance(arg, nodes.IfExp) for arg in value.args)
+        )
+
+    def _is_only_type_assignment(
+        self, node: nodes.Name, defstmt: nodes.Statement
+    ) -> bool:
+        """Check if variable only gets assigned a type and never a value."""
+        if not isinstance(defstmt, nodes.AnnAssign) or defstmt.value:
+            return False
+
+        if node.name in self.config.additional_builtins or utils.is_builtin(node.name):
+            return False
+
+        defstmt_frame = defstmt.frame(future=True)
+        node_frame = node.frame(future=True)
+
+        parent = node
+        while parent is not defstmt_frame.parent:
+            parent_scope = parent.scope()
+
+            # Find out if any nonlocals receive values in nested functions
+            for inner_func in parent_scope.nodes_of_class(nodes.FunctionDef):
+                if inner_func is parent_scope:
+                    continue
+                if any(
+                    node.name in nl.names
+                    for nl in inner_func.nodes_of_class(nodes.Nonlocal)
+                ) and any(
+                    node.name == an.name
+                    for an in inner_func.nodes_of_class(nodes.AssignName)
+                ):
+                    return False
+
+            local_refs = parent_scope.locals.get(node.name, [])
+            for ref_node in local_refs:
+                # If local ref is in the same frame as our node, but on a later lineno
+                # we don't actually care about this local ref.
+                # Local refs are ordered, so we break.
+                #     print(var)
+                #     var = 1  # <- irrelevant
+                if defstmt_frame == node_frame and ref_node.lineno > node.lineno:
+                    break
+
+                # If the parent of the local reference is anything but an AnnAssign
+                # Or if the AnnAssign adds a value the variable will now have a value
+                #     var = 1  # OR
+                #     var: int = 1
+                if (
+                    not isinstance(ref_node.parent, nodes.AnnAssign)
+                    or ref_node.parent.value
+                ):
+                    return False
+            parent = parent_scope.parent
+        return True
+
+    @staticmethod
+    def _is_first_level_self_reference(
+        node: nodes.Name, defstmt: nodes.ClassDef, found_nodes: List[nodes.NodeNG]
+    ) -> Tuple[VariableVisitConsumerAction, Optional[List[nodes.NodeNG]]]:
+        """Check if a first level method's annotation or default values
+        refers to its own class, and return a consumer action
+        """
+        if node.frame(future=True).parent == defstmt and node.statement(
+            future=True
+        ) == node.frame(future=True):
+            # Check if used as type annotation
+            # Break if postponed evaluation is enabled
+            if utils.is_node_in_type_annotation_context(node):
+                if not utils.is_postponed_evaluation_enabled(node):
+                    return (VariableVisitConsumerAction.CONTINUE, None)
+                return (VariableVisitConsumerAction.RETURN, None)
+            # Check if used as default value by calling the class
+            if isinstance(node.parent, nodes.Call) and isinstance(
+                node.parent.parent, nodes.Arguments
+            ):
+                return (VariableVisitConsumerAction.CONTINUE, None)
+        return (VariableVisitConsumerAction.RETURN, found_nodes)
+
+    @staticmethod
+    def _is_never_evaluated(
+        defnode: nodes.NamedExpr, defnode_parent: nodes.IfExp
+    ) -> bool:
+        """Check if a NamedExpr is inside a side of if ... else that never
+        gets evaluated
+        """
+        inferred_test = utils.safe_infer(defnode_parent.test)
+        if isinstance(inferred_test, nodes.Const):
+            if inferred_test.value is True and defnode == defnode_parent.orelse:
+                return True
+            if inferred_test.value is False and defnode == defnode_parent.body:
+                return True
+        return False
+
+    def _ignore_class_scope(self, node):
+        """Return True if the node is in a local class scope, as an assignment.
+
+        :param node: Node considered
+        :type node: astroid.Node
+        :return: True if the node is in a local class scope, as an assignment. False otherwise.
+        :rtype: bool
+        """
+        # Detect if we are in a local class scope, as an assignment.
+        # For example, the following is fair game.
+        #
+        # class A:
+        #    b = 1
+        #    c = lambda b=b: b * b
+        #
+        # class B:
+        #    tp = 1
+        #    def func(self, arg: tp):
+        #        ...
+        # class C:
+        #    tp = 2
+        #    def func(self, arg=tp):
+        #        ...
+        # class C:
+        #    class Tp:
+        #        pass
+        #    class D(Tp):
+        #        ...
+
+        name = node.name
+        frame = node.statement(future=True).scope()
+        in_annotation_or_default_or_decorator = self._defined_in_function_definition(
+            node, frame
+        )
+        in_ancestor_list = utils.is_ancestor_name(frame, node)
+        if in_annotation_or_default_or_decorator or in_ancestor_list:
+            frame_locals = frame.parent.scope().locals
+        else:
+            frame_locals = frame.locals
+        return not (
+            (isinstance(frame, nodes.ClassDef) or in_annotation_or_default_or_decorator)
+            and not self._in_lambda_or_comprehension_body(node, frame)
+            and name in frame_locals
+        )
+
+    def _loopvar_name(self, node: astroid.Name) -> None:
+        # filter variables according to node's scope
+        astmts = [s for s in node.lookup(node.name)[1] if hasattr(s, "assign_type")]
+        # If this variable usage exists inside a function definition
+        # that exists in the same loop,
+        # the usage is safe because the function will not be defined either if
+        # the variable is not defined.
+        scope = node.scope()
+        # FunctionDef subclasses Lambda due to a curious ontology. Check both.
+        # See https://github.com/PyCQA/astroid/issues/291
+        # pylint: disable-next=fixme
+        # TODO: Revisit when astroid 3.0 includes the change
+        if isinstance(scope, nodes.Lambda) and any(
+            asmt.scope().parent_of(scope) for asmt in astmts
+        ):
+            return
+        # Filter variables according to their respective scope. Test parent
+        # and statement to avoid #74747. This is not a total fix, which would
+        # introduce a mechanism similar to special attribute lookup in
+        # modules. Also, in order to get correct inference in this case, the
+        # scope lookup rules would need to be changed to return the initial
+        # assignment (which does not exist in code per se) as well as any later
+        # modifications.
+        # pylint: disable-next=too-many-boolean-expressions
+        if (
+            not astmts
+            or (
+                astmts[0].parent == astmts[0].root()
+                and astmts[0].parent.parent_of(node)
+            )
+            or (
+                astmts[0].is_statement
+                or not isinstance(astmts[0].parent, nodes.Module)
+                and astmts[0].statement(future=True).parent_of(node)
+            )
+        ):
+            _astmts = []
+        else:
+            _astmts = astmts[:1]
+        for i, stmt in enumerate(astmts[1:]):
+            if astmts[i].statement(future=True).parent_of(
+                stmt
+            ) and not in_for_else_branch(astmts[i].statement(future=True), stmt):
+                continue
+            _astmts.append(stmt)
+        astmts = _astmts
+        if len(astmts) != 1:
+            return
+
+        assign = astmts[0].assign_type()
+        if not (
+            isinstance(assign, (nodes.For, nodes.Comprehension, nodes.GeneratorExp))
+            and assign.statement(future=True) is not node.statement(future=True)
+        ):
+            return
+
+        if not isinstance(assign, nodes.For):
+            self.add_message("undefined-loop-variable", args=node.name, node=node)
+            return
+        if any(
+            isinstance(else_stmt, (nodes.Return, nodes.Raise))
+            for else_stmt in assign.orelse
+        ):
+            return
+
+        # For functions we can do more by inferring the length of the itered object
+        try:
+            inferred = next(assign.iter.infer())
+            # Prefer the target of enumerate() rather than the enumerate object itself
+            if (
+                isinstance(inferred, astroid.Instance)
+                and inferred.qname() == "builtins.enumerate"
+                and assign.iter.args
+            ):
+                inferred = next(assign.iter.args[0].infer())
+        except astroid.InferenceError:
+            self.add_message("undefined-loop-variable", args=node.name, node=node)
+        else:
+            if (
+                isinstance(inferred, astroid.Instance)
+                and inferred.qname() == BUILTIN_RANGE
+            ):
+                # Consider range() objects safe, even if they might not yield any results.
+                return
+
+            # Consider sequences.
+            sequences = (
+                nodes.List,
+                nodes.Tuple,
+                nodes.Dict,
+                nodes.Set,
+                astroid.objects.FrozenSet,
+            )
+            if not isinstance(inferred, sequences):
+                self.add_message("undefined-loop-variable", args=node.name, node=node)
+                return
+
+            elements = getattr(inferred, "elts", getattr(inferred, "items", []))
+            if not elements:
+                self.add_message("undefined-loop-variable", args=node.name, node=node)
+
+    def _check_is_unused(
+        self,
+        name,
+        node,
+        stmt,
+        global_names,
+        nonlocal_names: Iterable[str],
+        comprehension_target_names: List[str],
+    ) -> None:
+        # Ignore some special names specified by user configuration.
+        if self._is_name_ignored(stmt, name):
+            return
+        # Ignore names that were added dynamically to the Function scope
+        if (
+            isinstance(node, nodes.FunctionDef)
+            and name == "__class__"
+            and len(node.locals["__class__"]) == 1
+            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
+        ):
+            return
+
+        # Ignore names imported by the global statement.
+        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
+            # Detect imports, assigned to global statements.
+            if global_names and _import_name_is_global(stmt, global_names):
+                return
+
+        # Ignore names in comprehension targets
+        if name in comprehension_target_names:
+            return
+
+        argnames = node.argnames()
+        # Care about functions with unknown argument (builtins)
+        if name in argnames:
+            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
+        else:
+            if stmt.parent and isinstance(
+                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple)
+            ):
+                if name in nonlocal_names:
+                    return
+
+            qname = asname = None
+            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
+                # Need the complete name, which we don't have in .locals.
+                if len(stmt.names) > 1:
+                    import_names = next(
+                        (names for names in stmt.names if name in names), None
+                    )
+                else:
+                    import_names = stmt.names[0]
+                if import_names:
+                    qname, asname = import_names
+                    name = asname or qname
+
+            if _has_locals_call_after_node(stmt, node.scope()):
+                message_name = "possibly-unused-variable"
+            else:
+                if isinstance(stmt, nodes.Import):
+                    if asname is not None:
+                        msg = f"{qname} imported as {asname}"
+                    else:
+                        msg = f"import {name}"
+                    self.add_message("unused-import", args=msg, node=stmt)
+                    return
+                if isinstance(stmt, nodes.ImportFrom):
+                    if asname is not None:
+                        msg = f"{qname} imported from {stmt.modname} as {asname}"
+                    else:
+                        msg = f"{name} imported from {stmt.modname}"
+                    self.add_message("unused-import", args=msg, node=stmt)
+                    return
+                message_name = "unused-variable"
+
+            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
+                return
+
+            # Don't check function stubs created only for type information
+            if utils.is_overload_stub(node):
+                return
+
+            # Special case for exception variable
+            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
+                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
+            ):
+                return
+
+            self.add_message(message_name, args=name, node=stmt)
+
+    def _is_name_ignored(self, stmt, name):
+        authorized_rgx = self.config.dummy_variables_rgx
+        if (
+            isinstance(stmt, nodes.AssignName)
+            and isinstance(stmt.parent, nodes.Arguments)
+            or isinstance(stmt, nodes.Arguments)
+        ):
+            regex = self.config.ignored_argument_names
+        else:
+            regex = authorized_rgx
+        return regex and regex.match(name)
+
+    def _check_unused_arguments(
+        self, name, node, stmt, argnames, nonlocal_names: Iterable[str]
+    ):
+        is_method = node.is_method()
+        klass = node.parent.frame(future=True)
+        if is_method and isinstance(klass, nodes.ClassDef):
+            confidence = (
+                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
+            )
+        else:
+            confidence = HIGH
+
+        if is_method:
+            # Don't warn for the first argument of a (non static) method
+            if node.type != "staticmethod" and name == argnames[0]:
+                return
+            # Don't warn for argument of an overridden method
+            overridden = overridden_method(klass, node.name)
+            if overridden is not None and name in overridden.argnames():
+                return
+            if node.name in utils.PYMETHODS and node.name not in (
+                "__init__",
+                "__new__",
+            ):
+                return
+        # Don't check callback arguments
+        if any(
+            node.name.startswith(cb) or node.name.endswith(cb)
+            for cb in self.config.callbacks
+        ):
+            return
+        # Don't check arguments of singledispatch.register function.
+        if utils.is_registered_in_singledispatch_function(node):
+            return
+
+        # Don't check function stubs created only for type information
+        if utils.is_overload_stub(node):
+            return
+
+        # Don't check protocol classes
+        if utils.is_protocol_class(klass):
+            return
+
+        if name in nonlocal_names:
+            return
+
+        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
+
+    def _check_late_binding_closure(self, node: nodes.Name) -> None:
+        """Check whether node is a cell var that is assigned within a containing loop.
+
+        Special cases where we don't care about the error:
+        1. When the node's function is immediately called, e.g. (lambda: i)()
+        2. When the node's function is returned from within the loop, e.g. return lambda: i
+        """
+        if not self.linter.is_message_enabled("cell-var-from-loop"):
+            return
+
+        node_scope = node.frame(future=True)
+
+        # If node appears in a default argument expression,
+        # look at the next enclosing frame instead
+        if utils.is_default_argument(node, node_scope):
+            node_scope = node_scope.parent.frame(future=True)
+
+        # Check if node is a cell var
+        if (
+            not isinstance(node_scope, (nodes.Lambda, nodes.FunctionDef))
+            or node.name in node_scope.locals
+        ):
+            return
+
+        assign_scope, stmts = node.lookup(node.name)
+        if not stmts or not assign_scope.parent_of(node_scope):
+            return
+
+        if utils.is_comprehension(assign_scope):
+            self.add_message("cell-var-from-loop", node=node, args=node.name)
+        else:
+            # Look for an enclosing For loop.
+            # Currently, we only consider the first assignment
+            assignment_node = stmts[0]
+
+            maybe_for = assignment_node
+            while maybe_for and not isinstance(maybe_for, nodes.For):
+                if maybe_for is assign_scope:
+                    break
+                maybe_for = maybe_for.parent
+            else:
+                if (
+                    maybe_for
+                    and maybe_for.parent_of(node_scope)
+                    and not utils.is_being_called(node_scope)
+                    and node_scope.parent
+                    and not isinstance(node_scope.statement(future=True), nodes.Return)
+                ):
+                    self.add_message("cell-var-from-loop", node=node, args=node.name)
+
+    def _should_ignore_redefined_builtin(self, stmt):
+        if not isinstance(stmt, nodes.ImportFrom):
+            return False
+        return stmt.modname in self.config.redefining_builtins_modules
+
+    def _allowed_redefined_builtin(self, name):
+        return name in self.config.allowed_redefined_builtins
+
+    @staticmethod
+    def _comprehension_between_frame_and_node(node: nodes.Name) -> bool:
+        """Return True if a ComprehensionScope intervenes between `node` and its frame."""
+        closest_comprehension_scope = utils.get_node_first_ancestor_of_type(
+            node, nodes.ComprehensionScope
+        )
+        return closest_comprehension_scope is not None and node.frame(
+            future=True
+        ).parent_of(closest_comprehension_scope)
+
+    def _store_type_annotation_node(self, type_annotation):
+        """Given a type annotation, store all the name nodes it refers to."""
+        if isinstance(type_annotation, nodes.Name):
+            self._type_annotation_names.append(type_annotation.name)
+            return
+
+        if isinstance(type_annotation, nodes.Attribute):
+            self._store_type_annotation_node(type_annotation.expr)
+            return
+
+        if not isinstance(type_annotation, nodes.Subscript):
+            return
+
+        if (
+            isinstance(type_annotation.value, nodes.Attribute)
+            and isinstance(type_annotation.value.expr, nodes.Name)
+            and type_annotation.value.expr.name == TYPING_MODULE
+        ):
+            self._type_annotation_names.append(TYPING_MODULE)
+            return
+
+        self._type_annotation_names.extend(
+            annotation.name for annotation in type_annotation.nodes_of_class(nodes.Name)
+        )
+
+    def _store_type_annotation_names(self, node):
+        type_annotation = node.type_annotation
+        if not type_annotation:
+            return
+        self._store_type_annotation_node(node.type_annotation)
+
+    def _check_self_cls_assign(self, node: nodes.Assign) -> None:
+        """Check that self/cls don't get assigned."""
+        assign_names: Set[Optional[str]] = set()
+        for target in node.targets:
+            if isinstance(target, nodes.AssignName):
+                assign_names.add(target.name)
+            elif isinstance(target, nodes.Tuple):
+                assign_names.update(
+                    elt.name for elt in target.elts if isinstance(elt, nodes.AssignName)
+                )
+        scope = node.scope()
+        nonlocals_with_same_name = any(
+            child for child in scope.body if isinstance(child, nodes.Nonlocal)
+        )
+        if nonlocals_with_same_name:
+            scope = node.scope().parent.scope()
+
+        if not (
+            isinstance(scope, nodes.FunctionDef)
+            and scope.is_method()
+            and "builtins.staticmethod" not in scope.decoratornames()
+        ):
+            return
+        argument_names = scope.argnames()
+        if not argument_names:
+            return
+        self_cls_name = argument_names[0]
+        if self_cls_name in assign_names:
+            self.add_message("self-cls-assignment", node=node, args=(self_cls_name,))
+
+    def _check_unpacking(self, inferred, node, targets):
+        """Check for unbalanced tuple unpacking
+        and unpacking non sequences.
+        """
+        if utils.is_inside_abstract_class(node):
+            return
+        if utils.is_comprehension(node):
+            return
+        if inferred is astroid.Uninferable:
+            return
+        if (
+            isinstance(inferred.parent, nodes.Arguments)
+            and isinstance(node.value, nodes.Name)
+            and node.value.name == inferred.parent.vararg
+        ):
+            # Variable-length argument, we can't determine the length.
+            return
+
+        # Attempt to check unpacking is properly balanced
+        values = self._nodes_to_unpack(inferred)
+        if values is not None:
+            if len(targets) != len(values):
+                # Check if we have starred nodes.
+                if any(isinstance(target, nodes.Starred) for target in targets):
+                    return
+                self.add_message(
+                    "unbalanced-tuple-unpacking",
+                    node=node,
+                    args=(
+                        _get_unpacking_extra_info(node, inferred),
+                        len(targets),
+                        len(values),
+                    ),
+                )
+        # attempt to check unpacking may be possible (ie RHS is iterable)
+        elif not utils.is_iterable(inferred):
+            self.add_message(
+                "unpacking-non-sequence",
+                node=node,
+                args=(_get_unpacking_extra_info(node, inferred),),
+            )
+
+    @staticmethod
+    def _nodes_to_unpack(node: nodes.NodeNG) -> Optional[List[nodes.NodeNG]]:
+        """Return the list of values of the `Assign` node."""
+        if isinstance(node, (nodes.Tuple, nodes.List)):
+            return node.itered()
+        if isinstance(node, astroid.Instance) and any(
+            ancestor.qname() == "typing.NamedTuple" for ancestor in node.ancestors()
+        ):
+            return [i for i in node.values() if isinstance(i, nodes.AssignName)]
+        return None
+
+    def _check_module_attrs(self, node, module, module_names):
+        """Check that module_names (list of string) are accessible through the
+        given module, if the latest access name corresponds to a module, return it
+        """
+        while module_names:
+            name = module_names.pop(0)
+            if name == "__dict__":
+                module = None
+                break
+            try:
+                module = next(module.getattr(name)[0].infer())
+                if module is astroid.Uninferable:
+                    return None
+            except astroid.NotFoundError:
+                if module.name in self._ignored_modules:
+                    return None
+                self.add_message(
+                    "no-name-in-module", args=(name, module.name), node=node
+                )
+                return None
+            except astroid.InferenceError:
+                return None
+        if module_names:
+            modname = module.name if module else "__dict__"
+            self.add_message(
+                "no-name-in-module", node=node, args=(".".join(module_names), modname)
+            )
+            return None
+        if isinstance(module, nodes.Module):
+            return module
+        return None
+
+    def _check_all(self, node: nodes.Module, not_consumed):
+        assigned = next(node.igetattr("__all__"))
+        if assigned is astroid.Uninferable:
+            return
+        if not assigned.pytype() in {"builtins.list", "builtins.tuple"}:
+            line, col = assigned.tolineno, assigned.col_offset
+            self.add_message("invalid-all-format", line=line, col_offset=col, node=node)
+            return
+        for elt in getattr(assigned, "elts", ()):
+            try:
+                elt_name = next(elt.infer())
+            except astroid.InferenceError:
+                continue
+            if elt_name is astroid.Uninferable:
+                continue
+            if not elt_name.parent:
+                continue
+
+            if not isinstance(elt_name, nodes.Const) or not isinstance(
+                elt_name.value, str
+            ):
+                self.add_message("invalid-all-object", args=elt.as_string(), node=elt)
+                continue
+
+            elt_name = elt_name.value
+            # If elt is in not_consumed, remove it from not_consumed
+            if elt_name in not_consumed:
+                del not_consumed[elt_name]
+                continue
+
+            if elt_name not in node.locals:
+                if not node.package:
+                    self.add_message(
+                        "undefined-all-variable", args=(elt_name,), node=elt
+                    )
+                else:
+                    basename = os.path.splitext(node.file)[0]
+                    if os.path.basename(basename) == "__init__":
+                        name = node.name + "." + elt_name
+                        try:
+                            astroid.modutils.file_from_modpath(name.split("."))
+                        except ImportError:
+                            self.add_message(
+                                "undefined-all-variable", args=(elt_name,), node=elt
+                            )
+                        except SyntaxError:
+                            # don't yield a syntax-error warning,
+                            # because it will be later yielded
+                            # when the file will be checked
+                            pass
+
+    def _check_globals(self, not_consumed):
+        if self._allow_global_unused_variables:
+            return
+        for name, node_lst in not_consumed.items():
+            for node in node_lst:
+                self.add_message("unused-variable", args=(name,), node=node)
+
+    def _check_imports(self, not_consumed):
+        local_names = _fix_dot_imports(not_consumed)
+        checked = set()
+        unused_wildcard_imports: DefaultDict[
+            Tuple[str, nodes.ImportFrom], List[str]
+        ] = collections.defaultdict(list)
+        for name, stmt in local_names:
+            for imports in stmt.names:
+                real_name = imported_name = imports[0]
+                if imported_name == "*":
+                    real_name = name
+                as_name = imports[1]
+                if real_name in checked:
+                    continue
+                if name not in (real_name, as_name):
+                    continue
+                checked.add(real_name)
+
+                is_type_annotation_import = (
+                    imported_name in self._type_annotation_names
+                    or as_name in self._type_annotation_names
+                )
+                if isinstance(stmt, nodes.Import) or (
+                    isinstance(stmt, nodes.ImportFrom) and not stmt.modname
+                ):
+                    if isinstance(stmt, nodes.ImportFrom) and SPECIAL_OBJ.search(
+                        imported_name
+                    ):
+                        # Filter special objects (__doc__, __all__) etc.,
+                        # because they can be imported for exporting.
+                        continue
+
+                    if is_type_annotation_import:
+                        # Most likely a typing import if it wasn't used so far.
+                        continue
+
+                    if as_name == "_":
+                        continue
+                    if as_name is None:
+                        msg = f"import {imported_name}"
+                    else:
+                        msg = f"{imported_name} imported as {as_name}"
+                    if not in_type_checking_block(stmt):
+                        self.add_message("unused-import", args=msg, node=stmt)
+                elif isinstance(stmt, nodes.ImportFrom) and stmt.modname != FUTURE:
+                    if SPECIAL_OBJ.search(imported_name):
+                        # Filter special objects (__doc__, __all__) etc.,
+                        # because they can be imported for exporting.
+                        continue
+
+                    if _is_from_future_import(stmt, name):
+                        # Check if the name is in fact loaded from a
+                        # __future__ import in another module.
+                        continue
+
+                    if is_type_annotation_import:
+                        # Most likely a typing import if it wasn't used so far.
+                        continue
+
+                    if imported_name == "*":
+                        unused_wildcard_imports[(stmt.modname, stmt)].append(name)
+                    else:
+                        if as_name is None:
+                            msg = f"{imported_name} imported from {stmt.modname}"
+                        else:
+                            msg = f"{imported_name} imported from {stmt.modname} as {as_name}"
+                        if not in_type_checking_block(stmt):
+                            self.add_message("unused-import", args=msg, node=stmt)
+
+        # Construct string for unused-wildcard-import message
+        for module, unused_list in unused_wildcard_imports.items():
+            if len(unused_list) == 1:
+                arg_string = unused_list[0]
+            else:
+                arg_string = (
+                    f"{', '.join(i for i in unused_list[:-1])} and {unused_list[-1]}"
+                )
+            self.add_message(
+                "unused-wildcard-import", args=(arg_string, module[0]), node=module[1]
+            )
+        del self._to_consume
+
+    def _check_metaclasses(self, node):
+        """Update consumption analysis for metaclasses."""
+        consumed = []  # [(scope_locals, consumed_key)]
+
+        for child_node in node.get_children():
+            if isinstance(child_node, nodes.ClassDef):
+                consumed.extend(self._check_classdef_metaclasses(child_node, node))
+
+        # Pop the consumed items, in order to avoid having
+        # unused-import and unused-variable false positives
+        for scope_locals, name in consumed:
+            scope_locals.pop(name, None)
+
+    def _check_classdef_metaclasses(self, klass, parent_node):
+        if not klass._metaclass:
+            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
+            return []
+
+        consumed = []  # [(scope_locals, consumed_key)]
+        metaclass = klass.metaclass()
+        name = None
+        if isinstance(klass._metaclass, nodes.Name):
+            name = klass._metaclass.name
+        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
+            attr = klass._metaclass.expr
+            while not isinstance(attr, nodes.Name):
+                attr = attr.expr
+            name = attr.name
+        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
+            klass._metaclass.func, nodes.Name
+        ):
+            name = klass._metaclass.func.name
+        elif metaclass:
+            name = metaclass.root().name
+
+        found = False
+        name = METACLASS_NAME_TRANSFORMS.get(name, name)
+        if name:
+            # check enclosing scopes starting from most local
+            for scope_locals, _, _, _ in self._to_consume[::-1]:
+                found_nodes = scope_locals.get(name, [])
+                for found_node in found_nodes:
+                    if found_node.lineno <= klass.lineno:
+                        consumed.append((scope_locals, name))
+                        found = True
+                        break
+            # Check parent scope
+            nodes_in_parent_scope = parent_node.locals.get(name, [])
+            for found_node_parent in nodes_in_parent_scope:
+                if found_node_parent.lineno <= klass.lineno:
+                    found = True
+                    break
+        if (
+            not found
+            and not metaclass
+            and not (
+                name in nodes.Module.scope_attrs
+                or utils.is_builtin(name)
+                or name in self.config.additional_builtins
+            )
+        ):
+            self.add_message("undefined-variable", node=klass, args=(name,))
+
+        return consumed
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(VariablesChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/config/__init__.py b/myenv/lib/python3.9/site-packages/pylint/config/__init__.py
new file mode 100644
index 0000000..16df5fd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/config/__init__.py
@@ -0,0 +1,112 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import os
+import pathlib
+import pickle
+import sys
+from datetime import datetime
+
+from pylint.config.configuration_mixin import ConfigurationMixIn
+from pylint.config.find_default_config_files import (
+    find_default_config_files,
+    find_pylintrc,
+)
+from pylint.config.man_help_formatter import _ManHelpFormatter
+from pylint.config.option import Option
+from pylint.config.option_manager_mixin import OptionsManagerMixIn
+from pylint.config.option_parser import OptionParser
+from pylint.config.options_provider_mixin import OptionsProviderMixIn, UnsupportedAction
+from pylint.constants import DEFAULT_PYLINT_HOME, OLD_DEFAULT_PYLINT_HOME
+from pylint.utils import LinterStats
+
+__all__ = [
+    "ConfigurationMixIn",
+    "find_default_config_files",
+    "_ManHelpFormatter",
+    "Option",
+    "OptionsManagerMixIn",
+    "OptionParser",
+    "OptionsProviderMixIn",
+    "UnsupportedAction",
+]
+
+USER_HOME = os.path.expanduser("~")
+if "PYLINTHOME" in os.environ:
+    PYLINT_HOME = os.environ["PYLINTHOME"]
+    if USER_HOME == "~":
+        USER_HOME = os.path.dirname(PYLINT_HOME)
+elif USER_HOME == "~":
+    PYLINT_HOME = OLD_DEFAULT_PYLINT_HOME
+else:
+    PYLINT_HOME = DEFAULT_PYLINT_HOME
+    # The spam prevention is due to pylint being used in parallel by
+    # pre-commit, and the message being spammy in this context
+    # Also if you work with old version of pylint that recreate the
+    # old pylint home, you can get the old message for a long time.
+    prefix_spam_prevention = "pylint_warned_about_old_cache_already"
+    spam_prevention_file = os.path.join(
+        PYLINT_HOME,
+        datetime.now().strftime(prefix_spam_prevention + "_%Y-%m-%d.temp"),
+    )
+    old_home = os.path.join(USER_HOME, OLD_DEFAULT_PYLINT_HOME)
+    if os.path.exists(old_home) and not os.path.exists(spam_prevention_file):
+        print(
+            f"PYLINTHOME is now '{PYLINT_HOME}' but obsolescent '{old_home}' is found; "
+            "you can safely remove the latter",
+            file=sys.stderr,
+        )
+        # Remove old spam prevention file
+        if os.path.exists(PYLINT_HOME):
+            for filename in os.listdir(PYLINT_HOME):
+                if prefix_spam_prevention in filename:
+                    try:
+                        os.remove(os.path.join(PYLINT_HOME, filename))
+                    except OSError:
+                        pass
+
+        # Create spam prevention file for today
+        try:
+            pathlib.Path(PYLINT_HOME).mkdir(parents=True, exist_ok=True)
+            with open(spam_prevention_file, "w", encoding="utf8") as f:
+                f.write("")
+        except Exception as exc:  # pylint: disable=broad-except
+            print(
+                "Can't write the file that was supposed to "
+                f"prevent 'pylint.d' deprecation spam in {PYLINT_HOME} because of {exc}."
+            )
+
+
+def _get_pdata_path(base_name, recurs):
+    base_name = base_name.replace(os.sep, "_")
+    return os.path.join(PYLINT_HOME, f"{base_name}{recurs}.stats")
+
+
+def load_results(base):
+    data_file = _get_pdata_path(base, 1)
+    try:
+        with open(data_file, "rb") as stream:
+            data = pickle.load(stream)
+            if not isinstance(data, LinterStats):
+                raise TypeError
+            return data
+    except Exception:  # pylint: disable=broad-except
+        return None
+
+
+def save_results(results, base):
+    if not os.path.exists(PYLINT_HOME):
+        try:
+            os.makedirs(PYLINT_HOME)
+        except OSError:
+            print(f"Unable to create directory {PYLINT_HOME}", file=sys.stderr)
+    data_file = _get_pdata_path(base, 1)
+    try:
+        with open(data_file, "wb") as stream:
+            pickle.dump(results, stream)
+    except OSError as ex:
+        print(f"Unable to create file {data_file}: {ex}", file=sys.stderr)
+
+
+PYLINTRC = find_pylintrc()
diff --git a/myenv/lib/python3.9/site-packages/pylint/config/config_initialization.py b/myenv/lib/python3.9/site-packages/pylint/config/config_initialization.py
new file mode 100644
index 0000000..6be0ab8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/config/config_initialization.py
@@ -0,0 +1,77 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Optional, Union
+
+from pylint import reporters
+from pylint.utils import utils
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+def _config_initialization(
+    linter: "PyLinter",
+    args_list: List[str],
+    reporter: Union[reporters.BaseReporter, reporters.MultiReporter, None] = None,
+    config_file: Union[None, str, Path] = None,
+    verbose_mode: Optional[bool] = None,
+) -> List[str]:
+    """Parse all available options, read config files and command line arguments and
+    set options accordingly.
+    """
+
+    # Read the config file. The parser is stored on linter.cfgfile_parser
+    try:
+        linter.read_config_file(config_file=config_file, verbose=verbose_mode)
+    except OSError as ex:
+        print(ex, file=sys.stderr)
+        sys.exit(32)
+    config_parser = linter.cfgfile_parser
+
+    # Run init hook, if present, before loading plugins
+    if config_parser.has_option("MASTER", "init-hook"):
+        exec(  # pylint: disable=exec-used
+            utils._unquote(config_parser.get("MASTER", "init-hook"))
+        )
+
+    # Load plugins if specified in the config file
+    if config_parser.has_option("MASTER", "load-plugins"):
+        plugins = utils._splitstrip(config_parser.get("MASTER", "load-plugins"))
+        linter.load_plugin_modules(plugins)
+
+    # Now we can load file config, plugins (which can
+    # provide options) have been registered
+    linter.load_config_file()
+
+    if reporter:
+        # If a custom reporter is provided as argument, it may be overridden
+        # by file parameters, so re-set it here, but before command line
+        # parsing, so it's still overridable by command line option
+        linter.set_reporter(reporter)
+
+    # Load command line arguments
+    try:
+        args_list = linter.load_command_line_configuration(args_list)
+    except SystemExit as exc:
+        if exc.code == 2:  # bad options
+            exc.code = 32
+        raise
+
+    # args_list should now only be a list of files/directories to lint. All options have
+    # been removed from the list
+    if not args_list:
+        print(linter.help())
+        sys.exit(32)
+
+    # We have loaded configuration from config file and command line. Now, we can
+    # load plugin specific configuration.
+    linter.load_plugin_configuration()
+
+    # Now that plugins are loaded, get list of all fail_on messages, and enable them
+    linter.enable_fail_on_messages()
+
+    return args_list
diff --git a/myenv/lib/python3.9/site-packages/pylint/config/configuration_mixin.py b/myenv/lib/python3.9/site-packages/pylint/config/configuration_mixin.py
new file mode 100644
index 0000000..3db9aca
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/config/configuration_mixin.py
@@ -0,0 +1,28 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from pylint.config.option_manager_mixin import OptionsManagerMixIn
+from pylint.config.options_provider_mixin import OptionsProviderMixIn
+
+
+class ConfigurationMixIn(OptionsManagerMixIn, OptionsProviderMixIn):
+    """Basic mixin for simple configurations which don't need the
+    manager / providers model
+    """
+
+    def __init__(self, *args, **kwargs):
+        if not args:
+            kwargs.setdefault("usage", "")
+        OptionsManagerMixIn.__init__(self, *args, **kwargs)
+        OptionsProviderMixIn.__init__(self)
+        if not getattr(self, "option_groups", None):
+            self.option_groups = []
+            for _, optdict in self.options:
+                try:
+                    gdef = (optdict["group"].upper(), "")
+                except KeyError:
+                    continue
+                if gdef not in self.option_groups:
+                    self.option_groups.append(gdef)
+        self.register_options_provider(self, own_group=False)
diff --git a/myenv/lib/python3.9/site-packages/pylint/config/find_default_config_files.py b/myenv/lib/python3.9/site-packages/pylint/config/find_default_config_files.py
new file mode 100644
index 0000000..7538f5b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/config/find_default_config_files.py
@@ -0,0 +1,82 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import configparser
+import os
+import sys
+from typing import Iterator, Optional
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+
+def _toml_has_config(path):
+    with open(path, mode="rb") as toml_handle:
+        try:
+            content = tomllib.load(toml_handle)
+        except tomllib.TOMLDecodeError as error:
+            print(f"Failed to load '{path}': {error}")
+            return False
+
+        try:
+            content["tool"]["pylint"]
+        except KeyError:
+            return False
+
+    return True
+
+
+def _cfg_has_config(path):
+    parser = configparser.ConfigParser()
+    parser.read(path, encoding="utf-8")
+    return any(section.startswith("pylint.") for section in parser.sections())
+
+
+def find_default_config_files() -> Iterator[str]:
+    """Find all possible config files."""
+    rc_names = ("pylintrc", ".pylintrc")
+    config_names = rc_names + ("pyproject.toml", "setup.cfg")
+    for config_name in config_names:
+        if os.path.isfile(config_name):
+            if config_name.endswith(".toml") and not _toml_has_config(config_name):
+                continue
+            if config_name.endswith(".cfg") and not _cfg_has_config(config_name):
+                continue
+
+            yield os.path.abspath(config_name)
+
+    if os.path.isfile("__init__.py"):
+        curdir = os.path.abspath(os.getcwd())
+        while os.path.isfile(os.path.join(curdir, "__init__.py")):
+            curdir = os.path.abspath(os.path.join(curdir, ".."))
+            for rc_name in rc_names:
+                rc_path = os.path.join(curdir, rc_name)
+                if os.path.isfile(rc_path):
+                    yield rc_path
+
+    if "PYLINTRC" in os.environ and os.path.exists(os.environ["PYLINTRC"]):
+        if os.path.isfile(os.environ["PYLINTRC"]):
+            yield os.environ["PYLINTRC"]
+    else:
+        user_home = os.path.expanduser("~")
+        if user_home not in ("~", "/root"):
+            home_rc = os.path.join(user_home, ".pylintrc")
+            if os.path.isfile(home_rc):
+                yield home_rc
+            home_rc = os.path.join(user_home, ".config", "pylintrc")
+            if os.path.isfile(home_rc):
+                yield home_rc
+
+    if os.path.isfile("/etc/pylintrc"):
+        yield "/etc/pylintrc"
+
+
+def find_pylintrc() -> Optional[str]:
+    """Search the pylint rc file and return its path if it finds it, else return None."""
+    for config_file in find_default_config_files():
+        if config_file.endswith("pylintrc"):
+            return config_file
+    return None
diff --git a/myenv/lib/python3.9/site-packages/pylint/config/man_help_formatter.py b/myenv/lib/python3.9/site-packages/pylint/config/man_help_formatter.py
new file mode 100644
index 0000000..84837cc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/config/man_help_formatter.py
@@ -0,0 +1,121 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import optparse  # pylint: disable=deprecated-module
+import sys
+import time
+
+
+class _ManHelpFormatter(optparse.HelpFormatter):
+    def __init__(
+        self, indent_increment=0, max_help_position=24, width=79, short_first=0
+    ):
+        super().__init__(indent_increment, max_help_position, width, short_first)
+        self.output_level: int
+
+    def format_heading(self, heading):
+        return f".SH {heading.upper()}\n"
+
+    def format_description(self, description):
+        return description
+
+    def format_option(self, option):
+        try:
+            optstring = option.option_strings
+        except AttributeError:
+            optstring = self.format_option_strings(option)
+        if option.help:
+            help_text = self.expand_default(option)
+            help_string = " ".join(line.strip() for line in help_text.splitlines())
+            help_string = help_string.replace("\\", "\\\\")
+            help_string = help_string.replace("[current:", "[default:")
+        else:
+            help_string = ""
+        return f""".IP "{optstring}"
+{help_string}
+"""
+
+    def format_head(self, optparser, pkginfo, section=1):
+        long_desc = ""
+        try:
+            pgm = optparser._get_prog_name()
+        except AttributeError:
+            # py >= 2.4.X (dunno which X exactly, at least 2)
+            pgm = optparser.get_prog_name()
+        short_desc = self.format_short_description(pgm, pkginfo.description)
+        if hasattr(pkginfo, "long_desc"):
+            long_desc = self.format_long_description(pgm, pkginfo.long_desc)
+        return f"""{self.format_title(pgm, section)}
+{short_desc}
+{self.format_synopsis(pgm)}
+{long_desc}"""
+
+    @staticmethod
+    def format_title(pgm, section):
+        date = (
+            "%d-%02d-%02d"  # pylint: disable=consider-using-f-string
+            % time.localtime()[:3]
+        )
+        return f'.TH {pgm} {section} "{date}" {pgm}'
+
+    @staticmethod
+    def format_short_description(pgm, short_desc):
+        return f""".SH NAME
+.B {pgm}
+\\- {short_desc.strip()}
+"""
+
+    @staticmethod
+    def format_synopsis(pgm):
+        return f""".SH SYNOPSIS
+.B  {pgm}
+[
+.I OPTIONS
+] [
+.I <arguments>
+]
+"""
+
+    @staticmethod
+    def format_long_description(pgm, long_desc):
+        long_desc = "\n".join(line.lstrip() for line in long_desc.splitlines())
+        long_desc = long_desc.replace("\n.\n", "\n\n")
+        if long_desc.lower().startswith(pgm):
+            long_desc = long_desc[len(pgm) :]
+        return f""".SH DESCRIPTION
+.B {pgm}
+{long_desc.strip()}
+"""
+
+    @staticmethod
+    def format_tail(pkginfo):
+        tail = f""".SH SEE ALSO
+/usr/share/doc/pythonX.Y-{getattr(pkginfo, "debian_name", "pylint")}/
+
+.SH BUGS
+Please report bugs on the project\'s mailing list:
+{pkginfo.mailinglist}
+
+.SH AUTHOR
+{pkginfo.author} <{pkginfo.author_email}>
+"""
+        if hasattr(pkginfo, "copyright"):
+            tail += f"""
+.SH COPYRIGHT
+{pkginfo.copyright}
+"""
+        return tail
+
+    def format_usage(self, usage):
+        """Taken from optparse.IndentedHelpFormatter."""
+        return f"Usage: {usage}\n"
+
+
+def _generate_manpage(optparser, pkginfo, section=1, stream=sys.stdout, level=0):
+    formatter = _ManHelpFormatter()
+    formatter.output_level = level
+    formatter.parser = optparser
+    print(formatter.format_head(optparser, pkginfo, section), file=stream)
+    print(optparser.format_option_help(formatter), file=stream)
+    print(formatter.format_tail(pkginfo), file=stream)
diff --git a/myenv/lib/python3.9/site-packages/pylint/config/option.py b/myenv/lib/python3.9/site-packages/pylint/config/option.py
new file mode 100644
index 0000000..260e0a2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/config/option.py
@@ -0,0 +1,203 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import copy
+import optparse  # pylint: disable=deprecated-module
+import pathlib
+import re
+from typing import List, Pattern, Union
+
+from pylint import utils
+
+
+# pylint: disable=unused-argument
+def _csv_validator(_, name, value):
+    return utils._check_csv(value)
+
+
+# pylint: disable=unused-argument
+def _regexp_validator(_, name, value):
+    if hasattr(value, "pattern"):
+        return value
+    return re.compile(value)
+
+
+# pylint: disable=unused-argument
+def _regexp_csv_validator(_, name, value):
+    return [_regexp_validator(_, name, val) for val in _csv_validator(_, name, value)]
+
+
+def _regexp_paths_csv_validator(
+    _, name: str, value: Union[str, List[Pattern[str]]]
+) -> List[Pattern[str]]:
+    if isinstance(value, list):
+        return value
+    patterns = []
+    for val in _csv_validator(_, name, value):
+        patterns.append(
+            re.compile(
+                str(pathlib.PureWindowsPath(val)).replace("\\", "\\\\")
+                + "|"
+                + pathlib.PureWindowsPath(val).as_posix()
+            )
+        )
+    return patterns
+
+
+def _choice_validator(choices, name, value):
+    if value not in choices:
+        msg = "option %s: invalid value: %r, should be in %s"
+        raise optparse.OptionValueError(msg % (name, value, choices))
+    return value
+
+
+def _yn_validator(opt, _, value):
+    if isinstance(value, int):
+        return bool(value)
+    if isinstance(value, str):
+        value = value.lower()
+    if value in {"y", "yes", "true"}:
+        return True
+    if value in {"n", "no", "false"}:
+        return False
+    msg = "option %s: invalid yn value %r, should be in (y, yes, true, n, no, false)"
+    raise optparse.OptionValueError(msg % (opt, value))
+
+
+def _multiple_choice_validator(choices, name, value):
+    values = utils._check_csv(value)
+    for csv_value in values:
+        if csv_value not in choices:
+            msg = "option %s: invalid value: %r, should be in %s"
+            raise optparse.OptionValueError(msg % (name, csv_value, choices))
+    return values
+
+
+def _non_empty_string_validator(opt, _, value):
+    if not value:
+        msg = "indent string can't be empty."
+        raise optparse.OptionValueError(msg)
+    return utils._unquote(value)
+
+
+def _multiple_choices_validating_option(opt, name, value):
+    return _multiple_choice_validator(opt.choices, name, value)
+
+
+def _py_version_validator(_, name, value):
+    if not isinstance(value, tuple):
+        try:
+            value = tuple(int(val) for val in value.split("."))
+        except (ValueError, AttributeError):
+            raise optparse.OptionValueError(
+                f"Invalid format for {name}, should be version string. E.g., '3.8'"
+            ) from None
+    return value
+
+
+VALIDATORS = {
+    "string": utils._unquote,
+    "int": int,
+    "float": float,
+    "regexp": lambda pattern: re.compile(pattern or ""),
+    "regexp_csv": _regexp_csv_validator,
+    "regexp_paths_csv": _regexp_paths_csv_validator,
+    "csv": _csv_validator,
+    "yn": _yn_validator,
+    "choice": lambda opt, name, value: _choice_validator(opt["choices"], name, value),
+    "multiple_choice": lambda opt, name, value: _multiple_choice_validator(
+        opt["choices"], name, value
+    ),
+    "non_empty_string": _non_empty_string_validator,
+    "py_version": _py_version_validator,
+}
+
+
+def _call_validator(opttype, optdict, option, value):
+    if opttype not in VALIDATORS:
+        raise Exception(f'Unsupported type "{opttype}"')
+    try:
+        return VALIDATORS[opttype](optdict, option, value)
+    except TypeError:
+        try:
+            return VALIDATORS[opttype](value)
+        except Exception as e:
+            raise optparse.OptionValueError(
+                f"{option} value ({value!r}) should be of type {opttype}"
+            ) from e
+
+
+def _validate(value, optdict, name=""):
+    """Return a validated value for an option according to its type.
+
+    optional argument name is only used for error message formatting
+    """
+    try:
+        _type = optdict["type"]
+    except KeyError:
+        return value
+    return _call_validator(_type, optdict, name, value)
+
+
+# pylint: disable=no-member
+class Option(optparse.Option):
+    TYPES = optparse.Option.TYPES + (
+        "regexp",
+        "regexp_csv",
+        "regexp_paths_csv",
+        "csv",
+        "yn",
+        "multiple_choice",
+        "non_empty_string",
+        "py_version",
+    )
+    ATTRS = optparse.Option.ATTRS + ["hide", "level"]
+    TYPE_CHECKER = copy.copy(optparse.Option.TYPE_CHECKER)
+    TYPE_CHECKER["regexp"] = _regexp_validator
+    TYPE_CHECKER["regexp_csv"] = _regexp_csv_validator
+    TYPE_CHECKER["regexp_paths_csv"] = _regexp_paths_csv_validator
+    TYPE_CHECKER["csv"] = _csv_validator
+    TYPE_CHECKER["yn"] = _yn_validator
+    TYPE_CHECKER["multiple_choice"] = _multiple_choices_validating_option
+    TYPE_CHECKER["non_empty_string"] = _non_empty_string_validator
+    TYPE_CHECKER["py_version"] = _py_version_validator
+
+    def __init__(self, *opts, **attrs):
+        super().__init__(*opts, **attrs)
+        if hasattr(self, "hide") and self.hide:
+            self.help = optparse.SUPPRESS_HELP
+
+    def _check_choice(self):
+        if self.type in {"choice", "multiple_choice"}:
+            if self.choices is None:
+                raise optparse.OptionError(
+                    "must supply a list of choices for type 'choice'", self
+                )
+            if not isinstance(self.choices, (tuple, list)):
+                raise optparse.OptionError(
+                    # pylint: disable-next=consider-using-f-string
+                    "choices must be a list of strings ('%s' supplied)"
+                    % str(type(self.choices)).split("'")[1],
+                    self,
+                )
+        elif self.choices is not None:
+            raise optparse.OptionError(
+                f"must not supply choices for type {self.type!r}", self
+            )
+
+    optparse.Option.CHECK_METHODS[2] = _check_choice  # type: ignore[index]
+
+    def process(self, opt, value, values, parser):
+        # First, convert the value(s) to the right type.  Howl if any
+        # value(s) are bogus.
+        value = self.convert_value(opt, value)
+        if self.type == "named":
+            existent = getattr(values, self.dest)
+            if existent:
+                existent.update(value)
+                value = existent
+        # And then take whatever action is expected of us.
+        # This is a separate method to make life easier for
+        # subclasses to add new actions.
+        return self.take_action(self.action, self.dest, opt, value, values, parser)
diff --git a/myenv/lib/python3.9/site-packages/pylint/config/option_manager_mixin.py b/myenv/lib/python3.9/site-packages/pylint/config/option_manager_mixin.py
new file mode 100644
index 0000000..44e1127
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/config/option_manager_mixin.py
@@ -0,0 +1,392 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import collections
+import configparser
+import contextlib
+import copy
+import functools
+import optparse  # pylint: disable=deprecated-module
+import os
+import sys
+from pathlib import Path
+from types import ModuleType
+from typing import Dict, List, Optional, TextIO, Tuple, Union
+
+from pylint import utils
+from pylint.config.man_help_formatter import _ManHelpFormatter
+from pylint.config.option import Option
+from pylint.config.option_parser import OptionParser
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+
+def _expand_default(self, option):
+    """Patch OptionParser.expand_default with custom behaviour.
+
+    This will handle defaults to avoid overriding values in the
+    configuration file.
+    """
+    if self.parser is None or not self.default_tag:
+        return option.help
+    optname = option._long_opts[0][2:]
+    try:
+        provider = self.parser.options_manager._all_options[optname]
+    except KeyError:
+        value = None
+    else:
+        optdict = provider.get_option_def(optname)
+        optname = provider.option_attrname(optname, optdict)
+        value = getattr(provider.config, optname, optdict)
+        value = utils._format_option_value(optdict, value)
+    if value is optparse.NO_DEFAULT or not value:
+        value = self.NO_DEFAULT_VALUE
+    return option.help.replace(self.default_tag, str(value))
+
+
+@contextlib.contextmanager
+def _patch_optparse():
+    # pylint: disable = redefined-variable-type
+    orig_default = optparse.HelpFormatter
+    try:
+        optparse.HelpFormatter.expand_default = _expand_default
+        yield
+    finally:
+        optparse.HelpFormatter.expand_default = orig_default
+
+
+class OptionsManagerMixIn:
+    """Handle configuration from both a configuration file and command line options."""
+
+    def __init__(self, usage, config_file=None):
+        self.config_file = config_file
+        self.reset_parsers(usage)
+        # list of registered options providers
+        self.options_providers = []
+        # dictionary associating option name to checker
+        self._all_options = collections.OrderedDict()
+        self._short_options = {}
+        self._nocallback_options = {}
+        self._mygroups = {}
+        # verbosity
+        self._maxlevel = 0
+
+    def reset_parsers(self, usage=""):
+        # configuration file parser
+        self.cfgfile_parser = configparser.ConfigParser(
+            inline_comment_prefixes=("#", ";")
+        )
+        # command line parser
+        self.cmdline_parser = OptionParser(Option, usage=usage)
+        self.cmdline_parser.options_manager = self
+        self._optik_option_attrs = set(self.cmdline_parser.option_class.ATTRS)
+
+    def register_options_provider(self, provider, own_group=True):
+        """Register an options provider."""
+        assert provider.priority <= 0, "provider's priority can't be >= 0"
+        for i, options_provider in enumerate(self.options_providers):
+            if provider.priority > options_provider.priority:
+                self.options_providers.insert(i, provider)
+                break
+        else:
+            self.options_providers.append(provider)
+        non_group_spec_options = [
+            option for option in provider.options if "group" not in option[1]
+        ]
+        groups = getattr(provider, "option_groups", ())
+        if own_group and non_group_spec_options:
+            self.add_option_group(
+                provider.name.upper(),
+                provider.__doc__,
+                non_group_spec_options,
+                provider,
+            )
+        else:
+            for opt, optdict in non_group_spec_options:
+                self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
+        for gname, gdoc in groups:
+            gname = gname.upper()
+            goptions = [
+                option
+                for option in provider.options
+                if option[1].get("group", "").upper() == gname
+            ]
+            self.add_option_group(gname, gdoc, goptions, provider)
+
+    def add_option_group(self, group_name, _, options, provider):
+        # add option group to the command line parser
+        if group_name in self._mygroups:
+            group = self._mygroups[group_name]
+        else:
+            group = optparse.OptionGroup(
+                self.cmdline_parser, title=group_name.capitalize()
+            )
+            self.cmdline_parser.add_option_group(group)
+            group.level = provider.level
+            self._mygroups[group_name] = group
+            # add section to the config file
+            if (
+                group_name != "DEFAULT"
+                and group_name not in self.cfgfile_parser._sections
+            ):
+                self.cfgfile_parser.add_section(group_name)
+        # add provider's specific options
+        for opt, optdict in options:
+            self.add_optik_option(provider, group, opt, optdict)
+
+    def add_optik_option(self, provider, optikcontainer, opt, optdict):
+        args, optdict = self.optik_option(provider, opt, optdict)
+        option = optikcontainer.add_option(*args, **optdict)
+        self._all_options[opt] = provider
+        self._maxlevel = max(self._maxlevel, option.level or 0)
+
+    def optik_option(self, provider, opt, optdict):
+        """Get our personal option definition and return a suitable form for
+        use with optik/optparse
+        """
+        optdict = copy.copy(optdict)
+        if "action" in optdict:
+            self._nocallback_options[provider] = opt
+        else:
+            optdict["action"] = "callback"
+            optdict["callback"] = self.cb_set_provider_option
+        # default is handled here and *must not* be given to optik if you
+        # want the whole machinery to work
+        if "default" in optdict:
+            if (
+                "help" in optdict
+                and optdict.get("default") is not None
+                and optdict["action"] not in ("store_true", "store_false")
+            ):
+                optdict["help"] += " [current: %default]"
+            del optdict["default"]
+        args = ["--" + str(opt)]
+        if "short" in optdict:
+            self._short_options[optdict["short"]] = opt
+            args.append("-" + optdict["short"])
+            del optdict["short"]
+        # cleanup option definition dict before giving it to optik
+        for key in list(optdict.keys()):
+            if key not in self._optik_option_attrs:
+                optdict.pop(key)
+        return args, optdict
+
+    def cb_set_provider_option(self, option, opt, value, parser):
+        """Optik callback for option setting."""
+        if opt.startswith("--"):
+            # remove -- on long option
+            opt = opt[2:]
+        else:
+            # short option, get its long equivalent
+            opt = self._short_options[opt[1:]]
+        # trick since we can't set action='store_true' on options
+        if value is None:
+            value = 1
+        self.global_set_option(opt, value)
+
+    def global_set_option(self, opt, value):
+        """Set option on the correct option provider."""
+        self._all_options[opt].set_option(opt, value)
+
+    def generate_config(
+        self, stream: Optional[TextIO] = None, skipsections: Tuple[str, ...] = ()
+    ) -> None:
+        """Write a configuration file according to the current configuration
+        into the given stream or stdout
+        """
+        options_by_section: Dict[str, List[Tuple]] = {}
+        sections = []
+        for provider in self.options_providers:
+            for section, options in provider.options_by_section():
+                if section is None:
+                    section = provider.name
+                if section in skipsections:
+                    continue
+                options = [
+                    (n, d, v)
+                    for (n, d, v) in options
+                    if d.get("type") is not None and not d.get("deprecated")
+                ]
+                if not options:
+                    continue
+                if section not in sections:
+                    sections.append(section)
+                all_options = options_by_section.setdefault(section, [])
+                all_options += options
+        stream = stream or sys.stdout
+        printed = False
+        for section in sections:
+            if printed:
+                print("\n", file=stream)
+            utils.format_section(
+                stream, section.upper(), sorted(options_by_section[section])
+            )
+            printed = True
+
+    def generate_manpage(
+        self, pkginfo: ModuleType, section: int = 1, stream: TextIO = sys.stdout
+    ) -> None:
+        with _patch_optparse():
+            formatter = _ManHelpFormatter()
+            formatter.output_level = self._maxlevel
+            formatter.parser = self.cmdline_parser
+            print(
+                formatter.format_head(self.cmdline_parser, pkginfo, section),
+                file=stream,
+            )
+            print(self.cmdline_parser.format_option_help(formatter), file=stream)
+            print(formatter.format_tail(pkginfo), file=stream)
+
+    def load_provider_defaults(self):
+        """Initialize configuration using default values."""
+        for provider in self.options_providers:
+            provider.load_defaults()
+
+    def read_config_file(self, config_file=None, verbose=None):
+        """Read the configuration file but do not load it (i.e. dispatching
+        values to each option's provider)
+        """
+        for help_level in range(1, self._maxlevel + 1):
+            opt = "-".join(["long"] * help_level) + "-help"
+            if opt in self._all_options:
+                break  # already processed
+            help_function = functools.partial(self.helpfunc, level=help_level)
+            help_msg = f"{' '.join(['more'] * help_level)} verbose help."
+            optdict = {
+                "action": "callback",
+                "callback": help_function,
+                "help": help_msg,
+            }
+            provider = self.options_providers[0]
+            self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
+            provider.options += ((opt, optdict),)
+
+        if config_file is None:
+            config_file = self.config_file
+        if config_file is not None:
+            config_file = os.path.expandvars(os.path.expanduser(config_file))
+            if not os.path.exists(config_file):
+                raise OSError(f"The config file {config_file} doesn't exist!")
+
+        use_config_file = config_file and os.path.exists(config_file)
+        if use_config_file:
+            self.set_current_module(config_file)
+            parser = self.cfgfile_parser
+            if config_file.endswith(".toml"):
+                try:
+                    self._parse_toml(config_file, parser)
+                except tomllib.TOMLDecodeError as e:
+                    self.add_message("config-parse-error", line=0, args=str(e))
+            else:
+                # Use this encoding in order to strip the BOM marker, if any.
+                with open(config_file, encoding="utf_8_sig") as fp:
+                    parser.read_file(fp)
+                # normalize each section's title
+                for sect, values in list(parser._sections.items()):
+                    if sect.startswith("pylint."):
+                        sect = sect[len("pylint.") :]
+                    if not sect.isupper() and values:
+                        parser._sections[sect.upper()] = values
+        if not verbose:
+            return
+        if use_config_file:
+            msg = f"Using config file {os.path.abspath(config_file)}"
+        else:
+            msg = "No config file found, using default configuration"
+        print(msg, file=sys.stderr)
+
+    def _parse_toml(
+        self, config_file: Union[Path, str], parser: configparser.ConfigParser
+    ) -> None:
+        """Parse and handle errors of a toml configuration file."""
+        with open(config_file, mode="rb") as fp:
+            content = tomllib.load(fp)
+        try:
+            sections_values = content["tool"]["pylint"]
+        except KeyError:
+            return
+        for section, values in sections_values.items():
+            section_name = section.upper()
+            # TOML has rich types, convert values to
+            # strings as ConfigParser expects.
+            if not isinstance(values, dict):
+                # This class is a mixin: add_message comes from the `PyLinter` class
+                self.add_message(  # type: ignore[attr-defined]
+                    "bad-configuration-section", line=0, args=(section, values)
+                )
+                continue
+            for option, value in values.items():
+                if isinstance(value, bool):
+                    values[option] = "yes" if value else "no"
+                elif isinstance(value, list):
+                    values[option] = ",".join(value)
+                else:
+                    values[option] = str(value)
+            for option, value in values.items():
+                try:
+                    parser.set(section_name, option, value=value)
+                except configparser.NoSectionError:
+                    parser.add_section(section_name)
+                    parser.set(section_name, option, value=value)
+
+    def load_config_file(self):
+        """Dispatch values previously read from a configuration file to each
+        option's provider
+        """
+        parser = self.cfgfile_parser
+        for section in parser.sections():
+            for option, value in parser.items(section):
+                try:
+                    self.global_set_option(option, value)
+                except (KeyError, optparse.OptionError):
+                    continue
+
+    def load_configuration(self, **kwargs):
+        """Override configuration according to given parameters."""
+        return self.load_configuration_from_config(kwargs)
+
+    def load_configuration_from_config(self, config):
+        for opt, opt_value in config.items():
+            opt = opt.replace("_", "-")
+            provider = self._all_options[opt]
+            provider.set_option(opt, opt_value)
+
+    def load_command_line_configuration(self, args=None) -> List[str]:
+        """Override configuration according to command line parameters.
+
+        return additional arguments
+        """
+        with _patch_optparse():
+            args = sys.argv[1:] if args is None else list(args)
+            (options, args) = self.cmdline_parser.parse_args(args=args)
+            for provider in self._nocallback_options:
+                config = provider.config
+                for attr in config.__dict__.keys():
+                    value = getattr(options, attr, None)
+                    if value is None:
+                        continue
+                    setattr(config, attr, value)
+            return args
+
+    def add_help_section(self, title, description, level=0):
+        """Add a dummy option section for help purpose."""
+        group = optparse.OptionGroup(
+            self.cmdline_parser, title=title.capitalize(), description=description
+        )
+        group.level = level
+        self._maxlevel = max(self._maxlevel, level)
+        self.cmdline_parser.add_option_group(group)
+
+    def help(self, level=0):
+        """Return the usage string for available options."""
+        self.cmdline_parser.formatter.output_level = level
+        with _patch_optparse():
+            return self.cmdline_parser.format_help()
+
+    def helpfunc(self, option, opt, val, p, level):  # pylint: disable=unused-argument
+        print(self.help(level))
+        sys.exit(0)
diff --git a/myenv/lib/python3.9/site-packages/pylint/config/option_parser.py b/myenv/lib/python3.9/site-packages/pylint/config/option_parser.py
new file mode 100644
index 0000000..b5d228e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/config/option_parser.py
@@ -0,0 +1,47 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import optparse  # pylint: disable=deprecated-module
+
+from pylint.config.option import Option
+
+
+def _level_options(group, outputlevel):
+    return [
+        option
+        for option in group.option_list
+        if (getattr(option, "level", 0) or 0) <= outputlevel
+        and option.help is not optparse.SUPPRESS_HELP
+    ]
+
+
+class OptionParser(optparse.OptionParser):
+    def __init__(self, option_class, *args, **kwargs):
+        super().__init__(option_class=Option, *args, **kwargs)
+
+    def format_option_help(self, formatter=None):
+        if formatter is None:
+            formatter = self.formatter
+        outputlevel = getattr(formatter, "output_level", 0)
+        formatter.store_option_strings(self)
+        result = [formatter.format_heading("Options")]
+        formatter.indent()
+        if self.option_list:
+            result.append(optparse.OptionContainer.format_option_help(self, formatter))
+            result.append("\n")
+        for group in self.option_groups:
+            if group.level <= outputlevel and (
+                group.description or _level_options(group, outputlevel)
+            ):
+                result.append(group.format_help(formatter))
+                result.append("\n")
+        formatter.dedent()
+        # Drop the last "\n", or the header if no options or option groups:
+        return "".join(result[:-1])
+
+    def _match_long_opt(self, opt):
+        """Disable abbreviations."""
+        if opt not in self._long_opt:
+            raise optparse.BadOptionError(opt)
+        return opt
diff --git a/myenv/lib/python3.9/site-packages/pylint/config/options_provider_mixin.py b/myenv/lib/python3.9/site-packages/pylint/config/options_provider_mixin.py
new file mode 100644
index 0000000..e937fee
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/config/options_provider_mixin.py
@@ -0,0 +1,111 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import optparse  # pylint: disable=deprecated-module
+from typing import Any, Dict, Tuple
+
+from pylint.config.option import _validate
+
+
+class UnsupportedAction(Exception):
+    """Raised by set_option when it doesn't know what to do for an action."""
+
+
+class OptionsProviderMixIn:
+    """Mixin to provide options to an OptionsManager."""
+
+    # those attributes should be overridden
+    priority = -1
+    name = "default"
+    options: Tuple[Tuple[str, Dict[str, Any]], ...] = ()
+    level = 0
+
+    def __init__(self):
+        self.config = optparse.Values()
+        self.load_defaults()
+
+    def load_defaults(self):
+        """Initialize the provider using default values."""
+        for opt, optdict in self.options:
+            action = optdict.get("action")
+            if action != "callback":
+                # callback action have no default
+                if optdict is None:
+                    optdict = self.get_option_def(opt)
+                default = optdict.get("default")
+                self.set_option(opt, default, action, optdict)
+
+    def option_attrname(self, opt, optdict=None):
+        """Get the config attribute corresponding to opt."""
+        if optdict is None:
+            optdict = self.get_option_def(opt)
+        return optdict.get("dest", opt.replace("-", "_"))
+
+    def option_value(self, opt):
+        """Get the current value for the given option."""
+        return getattr(self.config, self.option_attrname(opt), None)
+
+    def set_option(self, optname, value, action=None, optdict=None):
+        """Method called to set an option (registered in the options list)."""
+        if optdict is None:
+            optdict = self.get_option_def(optname)
+        if value is not None:
+            value = _validate(value, optdict, optname)
+        if action is None:
+            action = optdict.get("action", "store")
+        if action == "store":
+            setattr(self.config, self.option_attrname(optname, optdict), value)
+        elif action in {"store_true", "count"}:
+            setattr(self.config, self.option_attrname(optname, optdict), 0)
+        elif action == "store_false":
+            setattr(self.config, self.option_attrname(optname, optdict), 1)
+        elif action == "append":
+            optname = self.option_attrname(optname, optdict)
+            _list = getattr(self.config, optname, None)
+            if _list is None:
+                if isinstance(value, (list, tuple)):
+                    _list = value
+                elif value is not None:
+                    _list = []
+                    _list.append(value)
+                setattr(self.config, optname, _list)
+            elif isinstance(_list, tuple):
+                setattr(self.config, optname, _list + (value,))
+            else:
+                _list.append(value)
+        elif action == "callback":
+            optdict["callback"](None, optname, value, None)
+        else:
+            raise UnsupportedAction(action)
+
+    def get_option_def(self, opt):
+        """Return the dictionary defining an option given its name."""
+        assert self.options
+        for option in self.options:
+            if option[0] == opt:
+                return option[1]
+        raise optparse.OptionError(
+            f"no such option {opt} in section {self.name!r}", opt
+        )
+
+    def options_by_section(self):
+        """Return an iterator on options grouped by section.
+
+        (section, [list of (optname, optdict, optvalue)])
+        """
+        sections = {}
+        for optname, optdict in self.options:
+            sections.setdefault(optdict.get("group"), []).append(
+                (optname, optdict, self.option_value(optname))
+            )
+        if None in sections:
+            yield None, sections.pop(None)
+        for section, options in sorted(sections.items()):
+            yield section.upper(), options
+
+    def options_and_values(self, options=None):
+        if options is None:
+            options = self.options
+        for optname, optdict in options:
+            yield (optname, optdict, self.option_value(optname))
diff --git a/myenv/lib/python3.9/site-packages/pylint/constants.py b/myenv/lib/python3.9/site-packages/pylint/constants.py
new file mode 100644
index 0000000..adb8f5c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/constants.py
@@ -0,0 +1,198 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import platform
+import sys
+from typing import Dict, List, NamedTuple, Tuple
+
+import astroid
+import platformdirs
+
+from pylint.__pkginfo__ import __version__
+from pylint.typing import MessageTypesFullName
+
+PY37_PLUS = sys.version_info[:2] >= (3, 7)
+PY38_PLUS = sys.version_info[:2] >= (3, 8)
+PY39_PLUS = sys.version_info[:2] >= (3, 9)
+
+IS_PYPY = platform.python_implementation() == "PyPy"
+
+PY_EXTS = (".py", ".pyc", ".pyo", ".pyw", ".so", ".dll")
+
+MSG_STATE_CONFIDENCE = 2
+_MSG_ORDER = "EWRCIF"
+MSG_STATE_SCOPE_CONFIG = 0
+MSG_STATE_SCOPE_MODULE = 1
+
+# The line/node distinction does not apply to fatal errors and reports.
+_SCOPE_EXEMPT = "FR"
+
+MSG_TYPES: Dict[str, MessageTypesFullName] = {
+    "I": "info",
+    "C": "convention",
+    "R": "refactor",
+    "W": "warning",
+    "E": "error",
+    "F": "fatal",
+}
+MSG_TYPES_LONG: Dict[str, str] = {v: k for k, v in MSG_TYPES.items()}
+
+MSG_TYPES_STATUS = {"I": 0, "C": 16, "R": 8, "W": 4, "E": 2, "F": 1}
+
+# You probably don't want to change the MAIN_CHECKER_NAME
+# This would affect rcfile generation and retro-compatibility
+# on all project using [MASTER] in their rcfile.
+MAIN_CHECKER_NAME = "master"
+
+# pylint: disable-next=fixme
+# TODO Remove in 3.0 with all the surrounding code
+OLD_DEFAULT_PYLINT_HOME = ".pylint.d"
+DEFAULT_PYLINT_HOME = platformdirs.user_cache_dir("pylint")
+
+
+class WarningScope:
+    LINE = "line-based-msg"
+    NODE = "node-based-msg"
+
+
+full_version = f"""pylint {__version__}
+astroid {astroid.__version__}
+Python {sys.version}"""
+
+HUMAN_READABLE_TYPES = {
+    "file": "file",
+    "module": "module",
+    "const": "constant",
+    "class": "class",
+    "function": "function",
+    "method": "method",
+    "attr": "attribute",
+    "argument": "argument",
+    "variable": "variable",
+    "class_attribute": "class attribute",
+    "class_const": "class constant",
+    "inlinevar": "inline iteration",
+    "typevar": "type variable",
+}
+
+
+class DeletedMessage(NamedTuple):
+    msgid: str
+    symbol: str
+    old_names: List[Tuple[str, str]] = []
+
+
+DELETED_MSGID_PREFIXES: List[int] = []
+
+DELETED_MESSAGES = [
+    # Everything until the next comment is from the
+    # PY3K+ checker, see https://github.com/PyCQA/pylint/pull/4942
+    DeletedMessage("W1601", "apply-builtin"),
+    DeletedMessage("E1601", "print-statement"),
+    DeletedMessage("E1602", "parameter-unpacking"),
+    DeletedMessage(
+        "E1603", "unpacking-in-except", [("W0712", "old-unpacking-in-except")]
+    ),
+    DeletedMessage("E1604", "old-raise-syntax", [("W0121", "old-old-raise-syntax")]),
+    DeletedMessage("E1605", "backtick", [("W0333", "old-backtick")]),
+    DeletedMessage("E1609", "import-star-module-level"),
+    DeletedMessage("W1601", "apply-builtin"),
+    DeletedMessage("W1602", "basestring-builtin"),
+    DeletedMessage("W1603", "buffer-builtin"),
+    DeletedMessage("W1604", "cmp-builtin"),
+    DeletedMessage("W1605", "coerce-builtin"),
+    DeletedMessage("W1606", "execfile-builtin"),
+    DeletedMessage("W1607", "file-builtin"),
+    DeletedMessage("W1608", "long-builtin"),
+    DeletedMessage("W1609", "raw_input-builtin"),
+    DeletedMessage("W1610", "reduce-builtin"),
+    DeletedMessage("W1611", "standarderror-builtin"),
+    DeletedMessage("W1612", "unicode-builtin"),
+    DeletedMessage("W1613", "xrange-builtin"),
+    DeletedMessage("W1614", "coerce-method"),
+    DeletedMessage("W1615", "delslice-method"),
+    DeletedMessage("W1616", "getslice-method"),
+    DeletedMessage("W1617", "setslice-method"),
+    DeletedMessage("W1618", "no-absolute-import"),
+    DeletedMessage("W1619", "old-division"),
+    DeletedMessage("W1620", "dict-iter-method"),
+    DeletedMessage("W1621", "dict-view-method"),
+    DeletedMessage("W1622", "next-method-called"),
+    DeletedMessage("W1623", "metaclass-assignment"),
+    DeletedMessage(
+        "W1624", "indexing-exception", [("W0713", "old-indexing-exception")]
+    ),
+    DeletedMessage("W1625", "raising-string", [("W0701", "old-raising-string")]),
+    DeletedMessage("W1626", "reload-builtin"),
+    DeletedMessage("W1627", "oct-method"),
+    DeletedMessage("W1628", "hex-method"),
+    DeletedMessage("W1629", "nonzero-method"),
+    DeletedMessage("W1630", "cmp-method"),
+    DeletedMessage("W1632", "input-builtin"),
+    DeletedMessage("W1633", "round-builtin"),
+    DeletedMessage("W1634", "intern-builtin"),
+    DeletedMessage("W1635", "unichr-builtin"),
+    DeletedMessage(
+        "W1636", "map-builtin-not-iterating", [("W1631", "implicit-map-evaluation")]
+    ),
+    DeletedMessage("W1637", "zip-builtin-not-iterating"),
+    DeletedMessage("W1638", "range-builtin-not-iterating"),
+    DeletedMessage("W1639", "filter-builtin-not-iterating"),
+    DeletedMessage("W1640", "using-cmp-argument"),
+    DeletedMessage("W1642", "div-method"),
+    DeletedMessage("W1643", "idiv-method"),
+    DeletedMessage("W1644", "rdiv-method"),
+    DeletedMessage("W1645", "exception-message-attribute"),
+    DeletedMessage("W1646", "invalid-str-codec"),
+    DeletedMessage("W1647", "sys-max-int"),
+    DeletedMessage("W1648", "bad-python3-import"),
+    DeletedMessage("W1649", "deprecated-string-function"),
+    DeletedMessage("W1650", "deprecated-str-translate-call"),
+    DeletedMessage("W1651", "deprecated-itertools-function"),
+    DeletedMessage("W1652", "deprecated-types-field"),
+    DeletedMessage("W1653", "next-method-defined"),
+    DeletedMessage("W1654", "dict-items-not-iterating"),
+    DeletedMessage("W1655", "dict-keys-not-iterating"),
+    DeletedMessage("W1656", "dict-values-not-iterating"),
+    DeletedMessage("W1657", "deprecated-operator-function"),
+    DeletedMessage("W1658", "deprecated-urllib-function"),
+    DeletedMessage("W1659", "xreadlines-attribute"),
+    DeletedMessage("W1660", "deprecated-sys-function"),
+    DeletedMessage("W1661", "exception-escape"),
+    DeletedMessage("W1662", "comprehension-escape"),
+    # https://github.com/PyCQA/pylint/pull/3578
+    DeletedMessage("W0312", "mixed-indentation"),
+    # https://github.com/PyCQA/pylint/pull/3577
+    DeletedMessage(
+        "C0326",
+        "bad-whitespace",
+        [
+            ("C0323", "no-space-after-operator"),
+            ("C0324", "no-space-after-comma"),
+            ("C0322", "no-space-before-operator"),
+        ],
+    ),
+    # https://github.com/PyCQA/pylint/pull/3571
+    DeletedMessage("C0330", "bad-continuation"),
+]
+
+
+# ignore some messages when emitting useless-suppression:
+# - cyclic-import: can show false positives due to incomplete context
+# - deprecated-{module, argument, class, method, decorator}:
+#   can cause false positives for multi-interpreter projects
+#   when linting with an interpreter on a lower python version
+INCOMPATIBLE_WITH_USELESS_SUPPRESSION = frozenset(
+    [
+        "R0401",  # cyclic-import
+        "W0402",  # deprecated-module
+        "W1505",  # deprecated-method
+        "W1511",  # deprecated-argument
+        "W1512",  # deprecated-class
+        "W1513",  # deprecated-decorator
+    ]
+)
+
+
+TYPING_TYPE_CHECKS_GUARDS = frozenset({"typing.TYPE_CHECKING", "TYPE_CHECKING"})
diff --git a/myenv/lib/python3.9/site-packages/pylint/epylint.py b/myenv/lib/python3.9/site-packages/pylint/epylint.py
new file mode 100644
index 0000000..2eade40
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/epylint.py
@@ -0,0 +1,181 @@
+# mode: python; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4
+# -*- vim:fenc=utf-8:ft=python:et:sw=4:ts=4:sts=4
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Emacs and Flymake compatible Pylint.
+
+This script is for integration with emacs and is compatible with flymake mode.
+
+epylint walks out of python packages before invoking pylint. This avoids
+reporting import errors that occur when a module within a package uses the
+absolute import path to get another module within this package.
+
+For example:
+    - Suppose a package is structured as
+
+        a/__init__.py
+        a/b/x.py
+        a/c/y.py
+
+   - Then if y.py imports x as "from a.b import x" the following produces pylint
+     errors
+
+       cd a/c; pylint y.py
+
+   - The following obviously doesn't
+
+       pylint a/c/y.py
+
+   - As this script will be invoked by emacs within the directory of the file
+     we are checking we need to go out of it to avoid these false positives.
+
+
+You may also use py_run to run pylint with desired options and get back (or not)
+its output.
+"""
+import os
+import shlex
+import sys
+from io import StringIO
+from subprocess import PIPE, Popen
+from typing import Optional, Sequence
+
+
+def _get_env():
+    """Extracts the environment PYTHONPATH and appends the current 'sys.path'
+    to it.
+    """
+    env = dict(os.environ)
+    env["PYTHONPATH"] = os.pathsep.join(sys.path)
+    return env
+
+
+def lint(filename, options=()):
+    """Pylint the given file.
+
+    When run from emacs we will be in the directory of a file, and passed its
+    filename.  If this file is part of a package and is trying to import other
+    modules from within its own package or another package rooted in a directory
+    below it, pylint will classify it as a failed import.
+
+    To get around this, we traverse down the directory tree to find the root of
+    the package this module is in.  We then invoke pylint from this directory.
+
+    Finally, we must correct the filenames in the output generated by pylint so
+    Emacs doesn't become confused (it will expect just the original filename,
+    while pylint may extend it with extra directories if we've traversed down
+    the tree)
+    """
+    # traverse downwards until we are out of a python package
+    full_path = os.path.abspath(filename)
+    parent_path = os.path.dirname(full_path)
+    child_path = os.path.basename(full_path)
+
+    while parent_path != "/" and os.path.exists(
+        os.path.join(parent_path, "__init__.py")
+    ):
+        child_path = os.path.join(os.path.basename(parent_path), child_path)
+        parent_path = os.path.dirname(parent_path)
+
+    # Start pylint
+    # Ensure we use the python and pylint associated with the running epylint
+    run_cmd = "import sys; from pylint.lint import Run; Run(sys.argv[1:])"
+    cmd = (
+        [sys.executable, "-c", run_cmd]
+        + [
+            "--msg-template",
+            "{path}:{line}: {category} ({msg_id}, {symbol}, {obj}) {msg}",
+            "-r",
+            "n",
+            child_path,
+        ]
+        + list(options)
+    )
+
+    with Popen(
+        cmd, stdout=PIPE, cwd=parent_path, env=_get_env(), universal_newlines=True
+    ) as process:
+
+        for line in process.stdout:
+            # remove pylintrc warning
+            if line.startswith("No config file found"):
+                continue
+
+            # modify the file name that's put out to reverse the path traversal we made
+            parts = line.split(":")
+            if parts and parts[0] == child_path:
+                line = ":".join([filename] + parts[1:])
+            print(line, end=" ")
+
+        process.wait()
+        return process.returncode
+
+
+def py_run(command_options="", return_std=False, stdout=None, stderr=None):
+    """Run pylint from python.
+
+    ``command_options`` is a string containing ``pylint`` command line options;
+    ``return_std`` (boolean) indicates return of created standard output
+    and error (see below);
+    ``stdout`` and ``stderr`` are 'file-like' objects in which standard output
+    could be written.
+
+    Calling agent is responsible for stdout/err management (creation, close).
+    Default standard output and error are those from sys,
+    or standalone ones (``subprocess.PIPE``) are used
+    if they are not set and ``return_std``.
+
+    If ``return_std`` is set to ``True``, this function returns a 2-uple
+    containing standard output and error related to created process,
+    as follows: ``(stdout, stderr)``.
+
+    To silently run Pylint on a module, and get its standard output and error:
+        >>> (pylint_stdout, pylint_stderr) = py_run( 'module_name.py', True)
+    """
+    # Detect if we use Python as executable or not, else default to `python`
+    executable = sys.executable if "python" in sys.executable else "python"
+
+    # Create command line to call pylint
+    epylint_part = [executable, "-c", "from pylint import epylint;epylint.Run()"]
+    options = shlex.split(command_options, posix=not sys.platform.startswith("win"))
+    cli = epylint_part + options
+
+    # Providing standard output and/or error if not set
+    if stdout is None:
+        stdout = PIPE if return_std else sys.stdout
+    if stderr is None:
+        stderr = PIPE if return_std else sys.stderr
+    # Call pylint in a subprocess
+    with Popen(
+        cli,
+        shell=False,
+        stdout=stdout,
+        stderr=stderr,
+        env=_get_env(),
+        universal_newlines=True,
+    ) as process:
+        proc_stdout, proc_stderr = process.communicate()
+        # Return standard output and error
+        if return_std:
+            return StringIO(proc_stdout), StringIO(proc_stderr)
+        return None
+
+
+def Run(argv: Optional[Sequence[str]] = None):
+    if not argv and len(sys.argv) == 1:
+        print(f"Usage: {sys.argv[0]} <filename> [options]")
+        sys.exit(1)
+
+    argv = argv or sys.argv[1:]
+    if not os.path.exists(argv[0]):
+        print(f"{argv[0]} does not exist")
+        sys.exit(1)
+    else:
+        sys.exit(lint(argv[0], argv[1:]))
+
+
+if __name__ == "__main__":
+    Run()
diff --git a/myenv/lib/python3.9/site-packages/pylint/exceptions.py b/myenv/lib/python3.9/site-packages/pylint/exceptions.py
new file mode 100644
index 0000000..06ed21a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/exceptions.py
@@ -0,0 +1,29 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Exception classes raised by various operations within pylint."""
+
+
+class InvalidMessageError(Exception):
+    """Raised when a message creation, registration or addition is rejected."""
+
+
+class UnknownMessageError(Exception):
+    """Raised when an unregistered message id is encountered."""
+
+
+class EmptyReportError(Exception):
+    """Raised when a report is empty and so should not be displayed."""
+
+
+class InvalidReporterError(Exception):
+    """Raised when selected reporter is invalid (e.g. not found)."""
+
+
+class InvalidArgsError(ValueError):
+    """Raised when passed arguments are invalid, e.g., have the wrong length."""
+
+
+class NoLineSuppliedError(Exception):
+    """Raised when trying to disable a message on a next line without supplying a line number."""
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/__init__.py b/myenv/lib/python3.9/site-packages/pylint/extensions/__init__.py
new file mode 100644
index 0000000..393fe5e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/__init__.py
@@ -0,0 +1,18 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import TYPE_CHECKING
+
+from pylint.utils import register_plugins
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+def initialize(linter: "PyLinter") -> None:
+    """Initialize linter with checkers in the extensions' directory."""
+    register_plugins(linter, __path__[0])
+
+
+__all__ = ["initialize"]
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/_check_docs_utils.py b/myenv/lib/python3.9/site-packages/pylint/extensions/_check_docs_utils.py
new file mode 100644
index 0000000..0e2774b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/_check_docs_utils.py
@@ -0,0 +1,821 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Utility methods for docstring checking."""
+
+import re
+from typing import List, Optional, Set, Tuple
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import utils
+
+
+def space_indentation(s):
+    """The number of leading spaces in a string.
+
+    :param str s: input string
+
+    :rtype: int
+    :return: number of leading spaces
+    """
+    return len(s) - len(s.lstrip(" "))
+
+
+def get_setters_property_name(node):
+    """Get the name of the property that the given node is a setter for.
+
+    :param node: The node to get the property name for.
+    :type node: str
+
+    :rtype: str or None
+    :returns: The name of the property that the node is a setter for,
+        or None if one could not be found.
+    """
+    decorators = node.decorators.nodes if node.decorators else []
+    for decorator in decorators:
+        if (
+            isinstance(decorator, nodes.Attribute)
+            and decorator.attrname == "setter"
+            and isinstance(decorator.expr, nodes.Name)
+        ):
+            return decorator.expr.name
+    return None
+
+
+def get_setters_property(node):
+    """Get the property node for the given setter node.
+
+    :param node: The node to get the property for.
+    :type node: nodes.FunctionDef
+
+    :rtype: nodes.FunctionDef or None
+    :returns: The node relating to the property of the given setter node,
+        or None if one could not be found.
+    """
+    property_ = None
+
+    property_name = get_setters_property_name(node)
+    class_node = utils.node_frame_class(node)
+    if property_name and class_node:
+        class_attrs = class_node.getattr(node.name)
+        for attr in class_attrs:
+            if utils.decorated_with_property(attr):
+                property_ = attr
+                break
+
+    return property_
+
+
+def returns_something(return_node):
+    """Check if a return node returns a value other than None.
+
+    :param return_node: The return node to check.
+    :type return_node: astroid.Return
+
+    :rtype: bool
+    :return: True if the return node returns a value other than None,
+        False otherwise.
+    """
+    returns = return_node.value
+
+    if returns is None:
+        return False
+
+    return not (isinstance(returns, nodes.Const) and returns.value is None)
+
+
+def _get_raise_target(node):
+    if isinstance(node.exc, nodes.Call):
+        func = node.exc.func
+        if isinstance(func, (nodes.Name, nodes.Attribute)):
+            return utils.safe_infer(func)
+    return None
+
+
+def _split_multiple_exc_types(target: str) -> List[str]:
+    delimiters = r"(\s*,(?:\s*or\s)?\s*|\s+or\s+)"
+    return re.split(delimiters, target)
+
+
+def possible_exc_types(node: nodes.NodeNG) -> Set[nodes.ClassDef]:
+    """Gets all the possible raised exception types for the given raise node.
+
+    .. note::
+
+        Caught exception types are ignored.
+
+
+    :param node: The raise node to find exception types for.
+
+    :returns: A list of exception types possibly raised by :param:`node`.
+    """
+    exceptions = []
+    if isinstance(node.exc, nodes.Name):
+        inferred = utils.safe_infer(node.exc)
+        if inferred:
+            exceptions = [inferred]
+    elif node.exc is None:
+        handler = node.parent
+        while handler and not isinstance(handler, nodes.ExceptHandler):
+            handler = handler.parent
+
+        if handler and handler.type:
+            try:
+                for exception in astroid.unpack_infer(handler.type):
+                    if exception is not astroid.Uninferable:
+                        exceptions.append(exception)
+            except astroid.InferenceError:
+                pass
+    else:
+        target = _get_raise_target(node)
+        if isinstance(target, nodes.ClassDef):
+            exceptions = [target]
+        elif isinstance(target, nodes.FunctionDef):
+            for ret in target.nodes_of_class(nodes.Return):
+                if ret.frame(future=True) != target:
+                    # return from inner function - ignore it
+                    continue
+
+                val = utils.safe_infer(ret.value)
+                if val and utils.inherit_from_std_ex(val):
+                    if isinstance(val, nodes.ClassDef):
+                        exceptions.append(val)
+                    elif isinstance(val, astroid.Instance):
+                        exceptions.append(val.getattr("__class__")[0])
+
+    try:
+        return {
+            exc
+            for exc in exceptions
+            if not utils.node_ignores_exception(node, exc.name)
+        }
+    except astroid.InferenceError:
+        return set()
+
+
+def docstringify(
+    docstring: Optional[nodes.Const], default_type: str = "default"
+) -> "Docstring":
+    best_match = (0, DOCSTRING_TYPES.get(default_type, Docstring)(docstring))
+    for docstring_type in (
+        SphinxDocstring,
+        EpytextDocstring,
+        GoogleDocstring,
+        NumpyDocstring,
+    ):
+        instance = docstring_type(docstring)
+        matching_sections = instance.matching_sections()
+        if matching_sections > best_match[0]:
+            best_match = (matching_sections, instance)
+
+    return best_match[1]
+
+
+class Docstring:
+    re_for_parameters_see = re.compile(
+        r"""
+        For\s+the\s+(other)?\s*parameters\s*,\s+see
+        """,
+        re.X | re.S,
+    )
+
+    supports_yields: bool = False
+    """True if the docstring supports a "yield" section.
+
+    False if the docstring uses the returns section to document generators.
+    """
+
+    # These methods are designed to be overridden
+    # pylint: disable=no-self-use
+    def __init__(self, doc: Optional[nodes.Const]) -> None:
+        docstring = doc.value if doc else ""
+        self.doc = docstring.expandtabs()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}:'''{self.doc}'''>"
+
+    def matching_sections(self) -> int:
+        """Returns the number of matching docstring sections."""
+        return 0
+
+    def exceptions(self):
+        return set()
+
+    def has_params(self):
+        return False
+
+    def has_returns(self):
+        return False
+
+    def has_rtype(self):
+        return False
+
+    def has_property_returns(self):
+        return False
+
+    def has_property_type(self):
+        return False
+
+    def has_yields(self):
+        return False
+
+    def has_yields_type(self):
+        return False
+
+    def match_param_docs(self):
+        return set(), set()
+
+    def params_documented_elsewhere(self):
+        return self.re_for_parameters_see.search(self.doc) is not None
+
+
+class SphinxDocstring(Docstring):
+    re_type = r"""
+        [~!.]?               # Optional link style prefix
+        \w(?:\w|\.[^\.])*    # Valid python name
+        """
+
+    re_simple_container_type = rf"""
+        {re_type}                     # a container type
+        [\(\[] [^\n\s]+ [\)\]]        # with the contents of the container
+    """
+
+    re_multiple_simple_type = r"""
+        (?:{container_type}|{type})
+        (?:(?:\s+(?:of|or)\s+|\s*,\s*)(?:{container_type}|{type}))*
+    """.format(
+        type=re_type, container_type=re_simple_container_type
+    )
+
+    re_xref = rf"""
+        (?::\w+:)?                    # optional tag
+        `{re_type}`                   # what to reference
+        """
+
+    re_param_raw = rf"""
+        :                       # initial colon
+        (?:                     # Sphinx keywords
+        param|parameter|
+        arg|argument|
+        key|keyword
+        )
+        \s+                     # whitespace
+
+        (?:                     # optional type declaration
+        ({re_type}|{re_simple_container_type})
+        \s+
+        )?
+
+        ((\\\*{{0,2}}\w+)|(\w+))  # Parameter name with potential asterisks
+        \s*                       # whitespace
+        :                         # final colon
+        """
+    re_param_in_docstring = re.compile(re_param_raw, re.X | re.S)
+
+    re_type_raw = rf"""
+        :type                           # Sphinx keyword
+        \s+                             # whitespace
+        ({re_multiple_simple_type})     # Parameter name
+        \s*                             # whitespace
+        :                               # final colon
+        """
+    re_type_in_docstring = re.compile(re_type_raw, re.X | re.S)
+
+    re_property_type_raw = rf"""
+        :type:                      # Sphinx keyword
+        \s+                         # whitespace
+        {re_multiple_simple_type}   # type declaration
+        """
+    re_property_type_in_docstring = re.compile(re_property_type_raw, re.X | re.S)
+
+    re_raise_raw = rf"""
+        :                               # initial colon
+        (?:                             # Sphinx keyword
+        raises?|
+        except|exception
+        )
+        \s+                             # whitespace
+        ({re_multiple_simple_type})     # exception type
+        \s*                             # whitespace
+        :                               # final colon
+        """
+    re_raise_in_docstring = re.compile(re_raise_raw, re.X | re.S)
+
+    re_rtype_in_docstring = re.compile(r":rtype:")
+
+    re_returns_in_docstring = re.compile(r":returns?:")
+
+    supports_yields = False
+
+    def matching_sections(self) -> int:
+        """Returns the number of matching docstring sections."""
+        return sum(
+            bool(i)
+            for i in (
+                self.re_param_in_docstring.search(self.doc),
+                self.re_raise_in_docstring.search(self.doc),
+                self.re_rtype_in_docstring.search(self.doc),
+                self.re_returns_in_docstring.search(self.doc),
+                self.re_property_type_in_docstring.search(self.doc),
+            )
+        )
+
+    def exceptions(self):
+        types = set()
+
+        for match in re.finditer(self.re_raise_in_docstring, self.doc):
+            raise_type = match.group(1)
+            types.update(_split_multiple_exc_types(raise_type))
+
+        return types
+
+    def has_params(self):
+        if not self.doc:
+            return False
+
+        return self.re_param_in_docstring.search(self.doc) is not None
+
+    def has_returns(self):
+        if not self.doc:
+            return False
+
+        return bool(self.re_returns_in_docstring.search(self.doc))
+
+    def has_rtype(self):
+        if not self.doc:
+            return False
+
+        return bool(self.re_rtype_in_docstring.search(self.doc))
+
+    def has_property_returns(self):
+        if not self.doc:
+            return False
+
+        # The summary line is the return doc,
+        # so the first line must not be a known directive.
+        return not self.doc.lstrip().startswith(":")
+
+    def has_property_type(self):
+        if not self.doc:
+            return False
+
+        return bool(self.re_property_type_in_docstring.search(self.doc))
+
+    def match_param_docs(self):
+        params_with_doc = set()
+        params_with_type = set()
+
+        for match in re.finditer(self.re_param_in_docstring, self.doc):
+            name = match.group(2)
+            # Remove escape characters necessary for asterisks
+            name = name.replace("\\", "")
+            params_with_doc.add(name)
+            param_type = match.group(1)
+            if param_type is not None:
+                params_with_type.add(name)
+
+        params_with_type.update(re.findall(self.re_type_in_docstring, self.doc))
+        return params_with_doc, params_with_type
+
+
+class EpytextDocstring(SphinxDocstring):
+    """Epytext is similar to Sphinx.
+
+    See the docs:
+        http://epydoc.sourceforge.net/epytext.html
+        http://epydoc.sourceforge.net/fields.html#fields
+
+    It's used in PyCharm:
+        https://www.jetbrains.com/help/pycharm/2016.1/creating-documentation-comments.html#d848203e314
+        https://www.jetbrains.com/help/pycharm/2016.1/using-docstrings-to-specify-types.html
+    """
+
+    re_param_in_docstring = re.compile(
+        SphinxDocstring.re_param_raw.replace(":", "@", 1), re.X | re.S
+    )
+
+    re_type_in_docstring = re.compile(
+        SphinxDocstring.re_type_raw.replace(":", "@", 1), re.X | re.S
+    )
+
+    re_property_type_in_docstring = re.compile(
+        SphinxDocstring.re_property_type_raw.replace(":", "@", 1), re.X | re.S
+    )
+
+    re_raise_in_docstring = re.compile(
+        SphinxDocstring.re_raise_raw.replace(":", "@", 1), re.X | re.S
+    )
+
+    re_rtype_in_docstring = re.compile(
+        r"""
+        @                       # initial "at" symbol
+        (?:                     # Epytext keyword
+        rtype|returntype
+        )
+        :                       # final colon
+        """,
+        re.X | re.S,
+    )
+
+    re_returns_in_docstring = re.compile(r"@returns?:")
+
+    def has_property_returns(self):
+        if not self.doc:
+            return False
+
+        # If this is a property docstring, the summary is the return doc.
+        if self.has_property_type():
+            # The summary line is the return doc,
+            # so the first line must not be a known directive.
+            return not self.doc.lstrip().startswith("@")
+
+        return False
+
+
+class GoogleDocstring(Docstring):
+    re_type = SphinxDocstring.re_type
+
+    re_xref = SphinxDocstring.re_xref
+
+    re_container_type = rf"""
+        (?:{re_type}|{re_xref})       # a container type
+        [\(\[] [^\n]+ [\)\]]          # with the contents of the container
+    """
+
+    re_multiple_type = r"""
+        (?:{container_type}|{type}|{xref})
+        (?:(?:\s+(?:of|or)\s+|\s*,\s*)(?:{container_type}|{type}|{xref}))*
+    """.format(
+        type=re_type, xref=re_xref, container_type=re_container_type
+    )
+
+    _re_section_template = r"""
+        ^([ ]*)   {0} \s*:   \s*$     # Google parameter header
+        (  .* )                       # section
+        """
+
+    re_param_section = re.compile(
+        _re_section_template.format(r"(?:Args|Arguments|Parameters)"),
+        re.X | re.S | re.M,
+    )
+
+    re_keyword_param_section = re.compile(
+        _re_section_template.format(r"Keyword\s(?:Args|Arguments|Parameters)"),
+        re.X | re.S | re.M,
+    )
+
+    re_param_line = re.compile(
+        rf"""
+        \s*  ((?:\\?\*{{0,2}})?\w+)     # identifier potentially with asterisks
+        \s*  ( [(]
+            {re_multiple_type}
+            (?:,\s+optional)?
+            [)] )? \s* :                # optional type declaration
+        \s*  (.*)                       # beginning of optional description
+    """,
+        re.X | re.S | re.M,
+    )
+
+    re_raise_section = re.compile(
+        _re_section_template.format(r"Raises"), re.X | re.S | re.M
+    )
+
+    re_raise_line = re.compile(
+        rf"""
+        \s*  ({re_multiple_type}) \s* :  # identifier
+        \s*  (.*)                        # beginning of optional description
+    """,
+        re.X | re.S | re.M,
+    )
+
+    re_returns_section = re.compile(
+        _re_section_template.format(r"Returns?"), re.X | re.S | re.M
+    )
+
+    re_returns_line = re.compile(
+        rf"""
+        \s* ({re_multiple_type}:)?        # identifier
+        \s* (.*)                          # beginning of description
+    """,
+        re.X | re.S | re.M,
+    )
+
+    re_property_returns_line = re.compile(
+        rf"""
+        ^{re_multiple_type}:           # identifier
+        \s* (.*)                       # Summary line / description
+    """,
+        re.X | re.S | re.M,
+    )
+
+    re_yields_section = re.compile(
+        _re_section_template.format(r"Yields?"), re.X | re.S | re.M
+    )
+
+    re_yields_line = re_returns_line
+
+    supports_yields = True
+
+    def matching_sections(self) -> int:
+        """Returns the number of matching docstring sections."""
+        return sum(
+            bool(i)
+            for i in (
+                self.re_param_section.search(self.doc),
+                self.re_raise_section.search(self.doc),
+                self.re_returns_section.search(self.doc),
+                self.re_yields_section.search(self.doc),
+                self.re_property_returns_line.search(self._first_line()),
+            )
+        )
+
+    def has_params(self):
+        if not self.doc:
+            return False
+
+        return self.re_param_section.search(self.doc) is not None
+
+    def has_returns(self):
+        if not self.doc:
+            return False
+
+        entries = self._parse_section(self.re_returns_section)
+        for entry in entries:
+            match = self.re_returns_line.match(entry)
+            if not match:
+                continue
+
+            return_desc = match.group(2)
+            if return_desc:
+                return True
+
+        return False
+
+    def has_rtype(self):
+        if not self.doc:
+            return False
+
+        entries = self._parse_section(self.re_returns_section)
+        for entry in entries:
+            match = self.re_returns_line.match(entry)
+            if not match:
+                continue
+
+            return_type = match.group(1)
+            if return_type:
+                return True
+
+        return False
+
+    def has_property_returns(self):
+        # The summary line is the return doc,
+        # so the first line must not be a known directive.
+        first_line = self._first_line()
+        return not bool(
+            self.re_param_section.search(first_line)
+            or self.re_raise_section.search(first_line)
+            or self.re_returns_section.search(first_line)
+            or self.re_yields_section.search(first_line)
+        )
+
+    def has_property_type(self):
+        if not self.doc:
+            return False
+
+        return bool(self.re_property_returns_line.match(self._first_line()))
+
+    def has_yields(self):
+        if not self.doc:
+            return False
+
+        entries = self._parse_section(self.re_yields_section)
+        for entry in entries:
+            match = self.re_yields_line.match(entry)
+            if not match:
+                continue
+
+            yield_desc = match.group(2)
+            if yield_desc:
+                return True
+
+        return False
+
+    def has_yields_type(self):
+        if not self.doc:
+            return False
+
+        entries = self._parse_section(self.re_yields_section)
+        for entry in entries:
+            match = self.re_yields_line.match(entry)
+            if not match:
+                continue
+
+            yield_type = match.group(1)
+            if yield_type:
+                return True
+
+        return False
+
+    def exceptions(self):
+        types = set()
+
+        entries = self._parse_section(self.re_raise_section)
+        for entry in entries:
+            match = self.re_raise_line.match(entry)
+            if not match:
+                continue
+
+            exc_type = match.group(1)
+            exc_desc = match.group(2)
+            if exc_desc:
+                types.update(_split_multiple_exc_types(exc_type))
+
+        return types
+
+    def match_param_docs(self):
+        params_with_doc = set()
+        params_with_type = set()
+
+        entries = self._parse_section(self.re_param_section)
+        entries.extend(self._parse_section(self.re_keyword_param_section))
+        for entry in entries:
+            match = self.re_param_line.match(entry)
+            if not match:
+                continue
+
+            param_name = match.group(1)
+            # Remove escape characters necessary for asterisks
+            param_name = param_name.replace("\\", "")
+
+            param_type = match.group(2)
+            param_desc = match.group(3)
+
+            if param_type:
+                params_with_type.add(param_name)
+
+            if param_desc:
+                params_with_doc.add(param_name)
+
+        return params_with_doc, params_with_type
+
+    def _first_line(self):
+        return self.doc.lstrip().split("\n", 1)[0]
+
+    @staticmethod
+    def min_section_indent(section_match):
+        return len(section_match.group(1)) + 1
+
+    @staticmethod
+    def _is_section_header(_):
+        # Google parsing does not need to detect section headers,
+        # because it works off of indentation level only
+        return False
+
+    def _parse_section(self, section_re):
+        section_match = section_re.search(self.doc)
+        if section_match is None:
+            return []
+
+        min_indentation = self.min_section_indent(section_match)
+
+        entries = []
+        entry = []
+        is_first = True
+        for line in section_match.group(2).splitlines():
+            if not line.strip():
+                continue
+            indentation = space_indentation(line)
+            if indentation < min_indentation:
+                break
+
+            # The first line after the header defines the minimum
+            # indentation.
+            if is_first:
+                min_indentation = indentation
+                is_first = False
+
+            if indentation == min_indentation:
+                if self._is_section_header(line):
+                    break
+                # Lines with minimum indentation must contain the beginning
+                # of a new parameter documentation.
+                if entry:
+                    entries.append("\n".join(entry))
+                    entry = []
+
+            entry.append(line)
+
+        if entry:
+            entries.append("\n".join(entry))
+
+        return entries
+
+
+class NumpyDocstring(GoogleDocstring):
+    _re_section_template = r"""
+        ^([ ]*)   {0}   \s*?$          # Numpy parameters header
+        \s*     [-=]+   \s*?$          # underline
+        (  .* )                        # section
+    """
+
+    re_param_section = re.compile(
+        _re_section_template.format(r"(?:Args|Arguments|Parameters)"),
+        re.X | re.S | re.M,
+    )
+
+    re_param_line = re.compile(
+        rf"""
+        \s*  (\*{{0,2}}\w+)(\s?(:|\n))                                      # identifier with potential asterisks
+        \s*  (?:({GoogleDocstring.re_multiple_type})(?:,\s+optional)?\n)?   # optional type declaration
+        \s* (.*)                                                            # optional description
+    """,
+        re.X | re.S,
+    )
+
+    re_raise_section = re.compile(
+        _re_section_template.format(r"Raises"), re.X | re.S | re.M
+    )
+
+    re_raise_line = re.compile(
+        rf"""
+        \s* ({GoogleDocstring.re_type})$   # type declaration
+        \s* (.*)                           # optional description
+    """,
+        re.X | re.S | re.M,
+    )
+
+    re_returns_section = re.compile(
+        _re_section_template.format(r"Returns?"), re.X | re.S | re.M
+    )
+
+    re_returns_line = re.compile(
+        rf"""
+        \s* (?:\w+\s+:\s+)? # optional name
+        ({GoogleDocstring.re_multiple_type})$   # type declaration
+        \s* (.*)                                # optional description
+    """,
+        re.X | re.S | re.M,
+    )
+
+    re_yields_section = re.compile(
+        _re_section_template.format(r"Yields?"), re.X | re.S | re.M
+    )
+
+    re_yields_line = re_returns_line
+
+    supports_yields = True
+
+    def match_param_docs(self) -> Tuple[Set[str], Set[str]]:
+        """Matches parameter documentation section to parameter documentation rules."""
+        params_with_doc = set()
+        params_with_type = set()
+
+        entries = self._parse_section(self.re_param_section)
+        entries.extend(self._parse_section(self.re_keyword_param_section))
+        for entry in entries:
+            match = self.re_param_line.match(entry)
+            if not match:
+                continue
+
+            # check if parameter has description only
+            re_only_desc = re.match(r"\s*  (\*{0,2}\w+)\s*:?\n", entry)
+            if re_only_desc:
+                param_name = match.group(1)
+                param_desc = match.group(2)
+                param_type = None
+            else:
+                param_name = match.group(1)
+                param_type = match.group(3)
+                param_desc = match.group(4)
+
+            if param_type:
+                params_with_type.add(param_name)
+
+            if param_desc:
+                params_with_doc.add(param_name)
+
+        return params_with_doc, params_with_type
+
+    @staticmethod
+    def min_section_indent(section_match):
+        return len(section_match.group(1))
+
+    @staticmethod
+    def _is_section_header(line):
+        return bool(re.match(r"\s*-+$", line))
+
+
+DOCSTRING_TYPES = {
+    "sphinx": SphinxDocstring,
+    "epytext": EpytextDocstring,
+    "google": GoogleDocstring,
+    "numpy": NumpyDocstring,
+    "default": Docstring,
+}
+"""A map of the name of the docstring type to its class.
+
+:type: dict(str, type)
+"""
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/bad_builtin.py b/myenv/lib/python3.9/site-packages/pylint/extensions/bad_builtin.py
new file mode 100644
index 0000000..259df6e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/bad_builtin.py
@@ -0,0 +1,65 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Checker for deprecated builtins."""
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+BAD_FUNCTIONS = ["map", "filter"]
+# Some hints regarding the use of bad builtins.
+BUILTIN_HINTS = {"map": "Using a list comprehension can be clearer."}
+BUILTIN_HINTS["filter"] = BUILTIN_HINTS["map"]
+
+
+class BadBuiltinChecker(BaseChecker):
+
+    __implements__ = (IAstroidChecker,)
+    name = "deprecated_builtins"
+    msgs = {
+        "W0141": (
+            "Used builtin function %s",
+            "bad-builtin",
+            "Used when a disallowed builtin function is used (see the "
+            "bad-function option). Usual disallowed functions are the ones "
+            "like map, or filter , where Python offers now some cleaner "
+            "alternative like list comprehension.",
+        )
+    }
+
+    options = (
+        (
+            "bad-functions",
+            {
+                "default": BAD_FUNCTIONS,
+                "type": "csv",
+                "metavar": "<builtin function names>",
+                "help": "List of builtins function names that should not be "
+                "used, separated by a comma",
+            },
+        ),
+    )
+
+    @check_messages("bad-builtin")
+    def visit_call(self, node: nodes.Call) -> None:
+        if isinstance(node.func, nodes.Name):
+            name = node.func.name
+            # ignore the name if it's not a builtin (i.e. not defined in the
+            # locals nor globals scope)
+            if not (name in node.frame(future=True) or name in node.root()):
+                if name in self.config.bad_functions:
+                    hint = BUILTIN_HINTS.get(name)
+                    args = f"{name!r}. {hint}" if hint else repr(name)
+                    self.add_message("bad-builtin", node=node, args=args)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(BadBuiltinChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/broad_try_clause.py b/myenv/lib/python3.9/site-packages/pylint/extensions/broad_try_clause.py
new file mode 100644
index 0000000..ddb7f75
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/broad_try_clause.py
@@ -0,0 +1,72 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Looks for try/except statements with too much code in the try clause."""
+from typing import TYPE_CHECKING, Union
+
+from astroid import nodes
+
+from pylint import checkers, interfaces
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class BroadTryClauseChecker(checkers.BaseChecker):
+    """Checks for try clauses with too many lines.
+
+    According to PEP 8, ``try`` clauses shall contain the absolute minimum
+    amount of code. This checker enforces a maximum number of statements within
+    ``try`` clauses.
+
+    """
+
+    __implements__ = interfaces.IAstroidChecker
+
+    # configuration section name
+    name = "broad_try_clause"
+    msgs = {
+        "W0717": (
+            "%s",
+            "too-many-try-statements",
+            "Try clause contains too many statements.",
+        )
+    }
+
+    priority = -2
+    options = (
+        (
+            "max-try-statements",
+            {
+                "default": 1,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "Maximum number of statements allowed in a try clause",
+            },
+        ),
+    )
+
+    def _count_statements(self, try_node):
+        statement_count = len(try_node.body)
+
+        for body_node in try_node.body:
+            if isinstance(body_node, (nodes.For, nodes.If, nodes.While, nodes.With)):
+                statement_count += self._count_statements(body_node)
+
+        return statement_count
+
+    def visit_tryexcept(self, node: Union[nodes.TryExcept, nodes.TryFinally]) -> None:
+        try_clause_statements = self._count_statements(node)
+        if try_clause_statements > self.config.max_try_statements:
+            msg = f"try clause contains {try_clause_statements} statements, expected at most {self.config.max_try_statements}"
+            self.add_message(
+                "too-many-try-statements", node.lineno, node=node, args=msg
+            )
+
+    def visit_tryfinally(self, node: nodes.TryFinally) -> None:
+        self.visit_tryexcept(node)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(BroadTryClauseChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/check_elif.py b/myenv/lib/python3.9/site-packages/pylint/extensions/check_elif.py
new file mode 100644
index 0000000..6ffc320
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/check_elif.py
@@ -0,0 +1,61 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint.checkers import BaseTokenChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import HIGH, IAstroidChecker, ITokenChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class ElseifUsedChecker(BaseTokenChecker):
+    """Checks for use of "else if" when an "elif" could be used."""
+
+    __implements__ = (ITokenChecker, IAstroidChecker)
+    name = "else_if_used"
+    msgs = {
+        "R5501": (
+            'Consider using "elif" instead of "else" then "if" to remove one indentation level',
+            "else-if-used",
+            "Used when an else statement is immediately followed by "
+            "an if statement and does not contain statements that "
+            "would be unrelated to it.",
+        )
+    }
+
+    def __init__(self, linter=None):
+        super().__init__(linter)
+        self._init()
+
+    def _init(self):
+        self._elifs = {}
+
+    def process_tokens(self, tokens):
+        """Process tokens and look for 'if' or 'elif'."""
+        self._elifs = {
+            begin: token for _, token, begin, _, _ in tokens if token in {"elif", "if"}
+        }
+
+    def leave_module(self, _: nodes.Module) -> None:
+        self._init()
+
+    @check_messages("else-if-used")
+    def visit_if(self, node: nodes.If) -> None:
+        """Current if node must directly follow an 'else'."""
+        if (
+            isinstance(node.parent, nodes.If)
+            and node.parent.orelse == [node]
+            and (node.lineno, node.col_offset) in self._elifs
+            and self._elifs[(node.lineno, node.col_offset)] == "if"
+        ):
+            self.add_message("else-if-used", node=node, confidence=HIGH)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(ElseifUsedChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/code_style.py b/myenv/lib/python3.9/site-packages/pylint/extensions/code_style.py
new file mode 100644
index 0000000..74e838e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/code_style.py
@@ -0,0 +1,314 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import sys
+from typing import TYPE_CHECKING, List, Optional, Set, Tuple, Type, Union, cast
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker, utils
+from pylint.checkers.utils import check_messages, safe_infer
+from pylint.interfaces import IAstroidChecker
+from pylint.utils.utils import get_global_option
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+if sys.version_info >= (3, 10):
+    from typing import TypeGuard
+else:
+    from typing_extensions import TypeGuard
+
+
+class CodeStyleChecker(BaseChecker):
+    """Checkers that can improve code consistency.
+
+    As such they don't necessarily provide a performance benefit and
+    are often times opinionated.
+
+    Before adding another checker here, consider this:
+    1. Does the checker provide a clear benefit,
+       i.e. detect a common issue or improve performance
+       => it should probably be part of the core checker classes
+    2. Is it something that would improve code consistency,
+       maybe because it's slightly better with regard to performance
+       and therefore preferred => this is the right place
+    3. Everything else should go into another extension
+    """
+
+    __implements__ = (IAstroidChecker,)
+
+    name = "code_style"
+    priority = -1
+    msgs = {
+        "R6101": (
+            "Consider using namedtuple or dataclass for dictionary values",
+            "consider-using-namedtuple-or-dataclass",
+            "Emitted when dictionary values can be replaced by namedtuples or dataclass instances.",
+        ),
+        "R6102": (
+            "Consider using an in-place tuple instead of list",
+            "consider-using-tuple",
+            "Only for style consistency! "
+            "Emitted where an in-place defined ``list`` can be replaced by a ``tuple``. "
+            "Due to optimizations by CPython, there is no performance benefit from it.",
+        ),
+        "R6103": (
+            "Use '%s' instead",
+            "consider-using-assignment-expr",
+            "Emitted when an if assignment is directly followed by an if statement and "
+            "both can be combined by using an assignment expression ``:=``. "
+            "Requires Python 3.8 and ``py-version >= 3.8``.",
+        ),
+    }
+    options = (
+        (
+            "max-line-length-suggestions",
+            {
+                "type": "int",
+                "metavar": "<int>",
+                "help": (
+                    "Max line length for which to sill emit suggestions. "
+                    "Used to prevent optional suggestions which would get split "
+                    "by a code formatter (e.g., black). "
+                    "Will default to the setting for ``max-line-length``."
+                ),
+            },
+        ),
+    )
+
+    def __init__(self, linter: "PyLinter") -> None:
+        """Initialize checker instance."""
+        super().__init__(linter=linter)
+
+    def open(self) -> None:
+        py_version = get_global_option(self, "py-version")
+        self._py38_plus = py_version >= (3, 8)
+        self._max_length: int = (
+            self.config.max_line_length_suggestions
+            or get_global_option(self, "max-line-length")
+        )
+
+    @check_messages("consider-using-namedtuple-or-dataclass")
+    def visit_dict(self, node: nodes.Dict) -> None:
+        self._check_dict_consider_namedtuple_dataclass(node)
+
+    @check_messages("consider-using-tuple")
+    def visit_for(self, node: nodes.For) -> None:
+        if isinstance(node.iter, nodes.List):
+            self.add_message("consider-using-tuple", node=node.iter)
+
+    @check_messages("consider-using-tuple")
+    def visit_comprehension(self, node: nodes.Comprehension) -> None:
+        if isinstance(node.iter, nodes.List):
+            self.add_message("consider-using-tuple", node=node.iter)
+
+    @check_messages("consider-using-assignment-expr")
+    def visit_if(self, node: nodes.If) -> None:
+        if self._py38_plus:
+            self._check_consider_using_assignment_expr(node)
+
+    def _check_dict_consider_namedtuple_dataclass(self, node: nodes.Dict) -> None:
+        """Check if dictionary values can be replaced by Namedtuple or Dataclass."""
+        if not (
+            isinstance(node.parent, (nodes.Assign, nodes.AnnAssign))
+            and isinstance(node.parent.parent, nodes.Module)
+            or isinstance(node.parent, nodes.AnnAssign)
+            and isinstance(node.parent.target, nodes.AssignName)
+            and utils.is_assign_name_annotated_with(node.parent.target, "Final")
+        ):
+            # If dict is not part of an 'Assign' or 'AnnAssign' node in
+            # a module context OR 'AnnAssign' with 'Final' annotation, skip check.
+            return
+
+        # All dict_values are itself dict nodes
+        if len(node.items) > 1 and all(
+            isinstance(dict_value, nodes.Dict) for _, dict_value in node.items
+        ):
+            KeyTupleT = Tuple[Type[nodes.NodeNG], str]
+
+            # Makes sure all keys are 'Const' string nodes
+            keys_checked: Set[KeyTupleT] = set()
+            for _, dict_value in node.items:
+                dict_value = cast(nodes.Dict, dict_value)
+                for key, _ in dict_value.items:
+                    key_tuple = (type(key), key.as_string())
+                    if key_tuple in keys_checked:
+                        continue
+                    inferred = safe_infer(key)
+                    if not (
+                        isinstance(inferred, nodes.Const)
+                        and inferred.pytype() == "builtins.str"
+                    ):
+                        return
+                    keys_checked.add(key_tuple)
+
+            # Makes sure all subdicts have at least 1 common key
+            key_tuples: List[Tuple[KeyTupleT, ...]] = []
+            for _, dict_value in node.items:
+                dict_value = cast(nodes.Dict, dict_value)
+                key_tuples.append(
+                    tuple((type(key), key.as_string()) for key, _ in dict_value.items)
+                )
+            keys_intersection: Set[KeyTupleT] = set(key_tuples[0])
+            for sub_key_tuples in key_tuples[1:]:
+                keys_intersection.intersection_update(sub_key_tuples)
+            if not keys_intersection:
+                return
+
+            self.add_message("consider-using-namedtuple-or-dataclass", node=node)
+            return
+
+        # All dict_values are itself either list or tuple nodes
+        if len(node.items) > 1 and all(
+            isinstance(dict_value, (nodes.List, nodes.Tuple))
+            for _, dict_value in node.items
+        ):
+            # Make sure all sublists have the same length > 0
+            list_length = len(node.items[0][1].elts)
+            if list_length == 0:
+                return
+            for _, dict_value in node.items[1:]:
+                dict_value = cast(Union[nodes.List, nodes.Tuple], dict_value)
+                if len(dict_value.elts) != list_length:
+                    return
+
+            # Make sure at least one list entry isn't a dict
+            for _, dict_value in node.items:
+                dict_value = cast(Union[nodes.List, nodes.Tuple], dict_value)
+                if all(isinstance(entry, nodes.Dict) for entry in dict_value.elts):
+                    return
+
+            self.add_message("consider-using-namedtuple-or-dataclass", node=node)
+            return
+
+    def _check_consider_using_assignment_expr(self, node: nodes.If) -> None:
+        """Check if an assignment expression (walrus operator) can be used.
+
+        For example if an assignment is directly followed by an if statement:
+        >>> x = 2
+        >>> if x:
+        >>>     ...
+
+        Can be replaced by:
+        >>> if (x := 2):
+        >>>     ...
+
+        Note: Assignment expressions were added in Python 3.8
+        """
+        # Check if `node.test` contains a `Name` node
+        node_name: Optional[nodes.Name] = None
+        if isinstance(node.test, nodes.Name):
+            node_name = node.test
+        elif (
+            isinstance(node.test, nodes.UnaryOp)
+            and node.test.op == "not"
+            and isinstance(node.test.operand, nodes.Name)
+        ):
+            node_name = node.test.operand
+        elif (
+            isinstance(node.test, nodes.Compare)
+            and isinstance(node.test.left, nodes.Name)
+            and len(node.test.ops) == 1
+        ):
+            node_name = node.test.left
+        else:
+            return
+
+        # Make sure the previous node is an assignment to the same name
+        # used in `node.test`. Furthermore, ignore if assignment spans multiple lines.
+        prev_sibling = node.previous_sibling()
+        if CodeStyleChecker._check_prev_sibling_to_if_stmt(
+            prev_sibling, node_name.name
+        ):
+
+            # Check if match statement would be a better fit.
+            # I.e. multiple ifs that test the same name.
+            if CodeStyleChecker._check_ignore_assignment_expr_suggestion(
+                node, node_name.name
+            ):
+                return
+
+            # Build suggestion string. Check length of suggestion
+            # does not exceed max-line-length-suggestions
+            test_str = node.test.as_string().replace(
+                node_name.name,
+                f"({node_name.name} := {prev_sibling.value.as_string()})",
+                1,
+            )
+            suggestion = f"if {test_str}:"
+            if (
+                node.col_offset is not None
+                and len(suggestion) + node.col_offset > self._max_length
+                or len(suggestion) > self._max_length
+            ):
+                return
+
+            self.add_message(
+                "consider-using-assignment-expr",
+                node=node_name,
+                args=(suggestion,),
+            )
+
+    @staticmethod
+    def _check_prev_sibling_to_if_stmt(
+        prev_sibling: Optional[nodes.NodeNG], name: Optional[str]
+    ) -> TypeGuard[Union[nodes.Assign, nodes.AnnAssign]]:
+        """Check if previous sibling is an assignment with the same name.
+
+        Ignore statements which span multiple lines.
+        """
+        if prev_sibling is None or prev_sibling.tolineno - prev_sibling.fromlineno != 0:
+            return False
+
+        if (
+            isinstance(prev_sibling, nodes.Assign)
+            and len(prev_sibling.targets) == 1
+            and isinstance(prev_sibling.targets[0], nodes.AssignName)
+            and prev_sibling.targets[0].name == name
+        ):
+            return True
+        if (
+            isinstance(prev_sibling, nodes.AnnAssign)
+            and isinstance(prev_sibling.target, nodes.AssignName)
+            and prev_sibling.target.name == name
+        ):
+            return True
+        return False
+
+    @staticmethod
+    def _check_ignore_assignment_expr_suggestion(
+        node: nodes.If, name: Optional[str]
+    ) -> bool:
+        """Return True if suggestion for assignment expr should be ignored.
+
+        E.g., in cases where a match statement would be a better fit
+        (multiple conditions).
+        """
+        if isinstance(node.test, nodes.Compare):
+            next_if_node: Optional[nodes.If] = None
+            next_sibling = node.next_sibling()
+            if len(node.orelse) == 1 and isinstance(node.orelse[0], nodes.If):
+                # elif block
+                next_if_node = node.orelse[0]
+            elif isinstance(next_sibling, nodes.If):
+                # separate if block
+                next_if_node = next_sibling
+
+            if (  # pylint: disable=too-many-boolean-expressions
+                next_if_node is not None
+                and (
+                    isinstance(next_if_node.test, nodes.Compare)
+                    and isinstance(next_if_node.test.left, nodes.Name)
+                    and next_if_node.test.left.name == name
+                    or isinstance(next_if_node.test, nodes.Name)
+                    and next_if_node.test.name == name
+                )
+            ):
+                return True
+        return False
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(CodeStyleChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/comparetozero.py b/myenv/lib/python3.9/site-packages/pylint/extensions/comparetozero.py
new file mode 100644
index 0000000..a1db3e5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/comparetozero.py
@@ -0,0 +1,77 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Looks for comparisons to zero."""
+
+import itertools
+from typing import TYPE_CHECKING, Any, Iterable
+
+import astroid
+from astroid import nodes
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+def _is_constant_zero(node):
+    return isinstance(node, astroid.Const) and node.value == 0
+
+
+class CompareToZeroChecker(checkers.BaseChecker):
+    """Checks for comparisons to zero.
+
+    Most of the time you should use the fact that integers with a value of 0 are false.
+    An exception to this rule is when 0 is allowed in the program and has a
+    different meaning than None!
+    """
+
+    __implements__ = (interfaces.IAstroidChecker,)
+
+    # configuration section name
+    name = "compare-to-zero"
+    msgs = {
+        "C2001": (
+            "Avoid comparisons to zero",
+            "compare-to-zero",
+            "Used when Pylint detects comparison to a 0 constant.",
+        )
+    }
+
+    priority = -2
+    options = ()
+
+    @utils.check_messages("compare-to-zero")
+    def visit_compare(self, node: nodes.Compare) -> None:
+        _operators = ["!=", "==", "is not", "is"]
+        # note: astroid.Compare has the left most operand in node.left
+        # while the rest are a list of tuples in node.ops
+        # the format of the tuple is ('compare operator sign', node)
+        # here we squash everything into `ops` to make it easier for processing later
+        ops = [("", node.left)]
+        ops.extend(node.ops)
+        iter_ops: Iterable[Any] = iter(ops)
+        ops = list(itertools.chain(*iter_ops))
+
+        for ops_idx in range(len(ops) - 2):
+            op_1 = ops[ops_idx]
+            op_2 = ops[ops_idx + 1]
+            op_3 = ops[ops_idx + 2]
+            error_detected = False
+
+            # 0 ?? X
+            if _is_constant_zero(op_1) and op_2 in _operators:
+                error_detected = True
+            # X ?? 0
+            elif op_2 in _operators and _is_constant_zero(op_3):
+                error_detected = True
+
+            if error_detected:
+                self.add_message("compare-to-zero", node=node)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(CompareToZeroChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/comparison_placement.py b/myenv/lib/python3.9/site-packages/pylint/extensions/comparison_placement.py
new file mode 100644
index 0000000..8156f98
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/comparison_placement.py
@@ -0,0 +1,71 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Checks for yoda comparisons (variable before constant)
+See https://en.wikipedia.org/wiki/Yoda_conditions
+"""
+
+
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker, utils
+from pylint.interfaces import IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+REVERSED_COMPS = {"<": ">", "<=": ">=", ">": "<", ">=": "<="}
+COMPARISON_OPERATORS = frozenset(("==", "!=", "<", ">", "<=", ">="))
+
+
+class MisplacedComparisonConstantChecker(BaseChecker):
+    """Checks the placement of constants in comparisons."""
+
+    __implements__ = (IAstroidChecker,)
+
+    # configuration section name
+    name = "comparison-placement"
+    msgs = {
+        "C2201": (
+            "Comparison should be %s",
+            "misplaced-comparison-constant",
+            "Used when the constant is placed on the left side "
+            "of a comparison. It is usually clearer in intent to "
+            "place it in the right hand side of the comparison.",
+            {"old_names": [("C0122", "old-misplaced-comparison-constant")]},
+        )
+    }
+
+    options = ()
+
+    def _check_misplaced_constant(
+        self,
+        node: nodes.Compare,
+        left: nodes.NodeNG,
+        right: nodes.NodeNG,
+        operator: str,
+    ):
+        if isinstance(right, nodes.Const):
+            return
+        operator = REVERSED_COMPS.get(operator, operator)
+        suggestion = f"{right.as_string()} {operator} {left.value!r}"
+        self.add_message("misplaced-comparison-constant", node=node, args=(suggestion,))
+
+    @utils.check_messages("misplaced-comparison-constant")
+    def visit_compare(self, node: nodes.Compare) -> None:
+        # NOTE: this checker only works with binary comparisons like 'x == 42'
+        # but not 'x == y == 42'
+        if len(node.ops) != 1:
+            return
+
+        left = node.left
+        operator, right = node.ops[0]
+        if operator in COMPARISON_OPERATORS and isinstance(left, nodes.Const):
+            self._check_misplaced_constant(node, left, right, operator)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(MisplacedComparisonConstantChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/confusing_elif.py b/myenv/lib/python3.9/site-packages/pylint/extensions/confusing_elif.py
new file mode 100644
index 0000000..9f815da
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/confusing_elif.py
@@ -0,0 +1,53 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class ConfusingConsecutiveElifChecker(BaseChecker):
+    """Checks if "elif" is used right after an indented block that finishes with "if" or "elif" itself."""
+
+    __implements__ = IAstroidChecker
+
+    name = "confusing_elif"
+    priority = -1
+    msgs = {
+        "R5601": (
+            "Consecutive elif with differing indentation level, consider creating a function to separate the inner elif",
+            "confusing-consecutive-elif",
+            "Used when an elif statement follows right after an indented block which itself ends with if or elif. "
+            "It may not be ovious if the elif statement was willingly or mistakenly unindented. "
+            "Extracting the indented if statement into a separate function might avoid confusion and prevent errors.",
+        )
+    }
+
+    @check_messages("confusing-consecutive-elif")
+    def visit_if(self, node: nodes.If) -> None:
+        body_ends_with_if = isinstance(
+            node.body[-1], nodes.If
+        ) and self._has_no_else_clause(node.body[-1])
+        if node.has_elif_block() and body_ends_with_if:
+            self.add_message("confusing-consecutive-elif", node=node.orelse[0])
+
+    @staticmethod
+    def _has_no_else_clause(node: nodes.If):
+        orelse = node.orelse
+        while orelse and isinstance(orelse[0], nodes.If):
+            orelse = orelse[0].orelse
+        if not orelse or isinstance(orelse[0], nodes.If):
+            return True
+        return False
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(ConfusingConsecutiveElifChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/consider_ternary_expression.py b/myenv/lib/python3.9/site-packages/pylint/extensions/consider_ternary_expression.py
new file mode 100644
index 0000000..aece514
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/consider_ternary_expression.py
@@ -0,0 +1,57 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Check for if / assign blocks that can be rewritten with if-expressions."""
+
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.interfaces import IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class ConsiderTernaryExpressionChecker(BaseChecker):
+
+    __implements__ = (IAstroidChecker,)
+    name = "consider_ternary_expression"
+    msgs = {
+        "W0160": (
+            "Consider rewriting as a ternary expression",
+            "consider-ternary-expression",
+            "Multiple assign statements spread across if/else blocks can be "
+            "rewritten with a single assignment and ternary expression",
+        )
+    }
+
+    def visit_if(self, node: nodes.If) -> None:
+        if isinstance(node.parent, nodes.If):
+            return
+
+        if len(node.body) != 1 or len(node.orelse) != 1:
+            return
+
+        bst = node.body[0]
+        ost = node.orelse[0]
+
+        if not isinstance(bst, nodes.Assign) or not isinstance(ost, nodes.Assign):
+            return
+
+        for (bname, oname) in zip(bst.targets, ost.targets):
+            if not isinstance(bname, nodes.AssignName) or not isinstance(
+                oname, nodes.AssignName
+            ):
+                return
+
+            if bname.name != oname.name:
+                return
+
+        self.add_message("consider-ternary-expression", node=node)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(ConsiderTernaryExpressionChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/docparams.py b/myenv/lib/python3.9/site-packages/pylint/extensions/docparams.py
new file mode 100644
index 0000000..ff38ce8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/docparams.py
@@ -0,0 +1,649 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Pylint plugin for checking in Sphinx, Google, or Numpy style docstrings."""
+import re
+from typing import TYPE_CHECKING, Optional, Set
+
+import astroid
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers import utils as checker_utils
+from pylint.extensions import _check_docs_utils as utils
+from pylint.extensions._check_docs_utils import Docstring
+from pylint.interfaces import IAstroidChecker
+from pylint.utils import get_global_option
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class DocstringParameterChecker(BaseChecker):
+    """Checker for Sphinx, Google, or Numpy style docstrings.
+
+    * Check that all function, method and constructor parameters are mentioned
+      in the params and types part of the docstring.  Constructor parameters
+      can be documented in either the class docstring or ``__init__`` docstring,
+      but not both.
+    * Check that there are no naming inconsistencies between the signature and
+      the documentation, i.e. also report documented parameters that are missing
+      in the signature. This is important to find cases where parameters are
+      renamed only in the code, not in the documentation.
+    * Check that all explicitly raised exceptions in a function are documented
+      in the function docstring. Caught exceptions are ignored.
+
+    Activate this checker by adding the line::
+
+        load-plugins=pylint.extensions.docparams
+
+    to the ``MASTER`` section of your ``.pylintrc``.
+    """
+
+    __implements__ = IAstroidChecker
+
+    name = "parameter_documentation"
+    msgs = {
+        "W9005": (
+            '"%s" has constructor parameters documented in class and __init__',
+            "multiple-constructor-doc",
+            "Please remove parameter declarations in the class or constructor.",
+        ),
+        "W9006": (
+            '"%s" not documented as being raised',
+            "missing-raises-doc",
+            "Please document exceptions for all raised exception types.",
+        ),
+        "W9008": (
+            "Redundant returns documentation",
+            "redundant-returns-doc",
+            "Please remove the return/rtype documentation from this method.",
+        ),
+        "W9010": (
+            "Redundant yields documentation",
+            "redundant-yields-doc",
+            "Please remove the yields documentation from this method.",
+        ),
+        "W9011": (
+            "Missing return documentation",
+            "missing-return-doc",
+            "Please add documentation about what this method returns.",
+            {"old_names": [("W9007", "old-missing-returns-doc")]},
+        ),
+        "W9012": (
+            "Missing return type documentation",
+            "missing-return-type-doc",
+            "Please document the type returned by this method.",
+            # we can't use the same old_name for two different warnings
+            # {'old_names': [('W9007', 'missing-returns-doc')]},
+        ),
+        "W9013": (
+            "Missing yield documentation",
+            "missing-yield-doc",
+            "Please add documentation about what this generator yields.",
+            {"old_names": [("W9009", "old-missing-yields-doc")]},
+        ),
+        "W9014": (
+            "Missing yield type documentation",
+            "missing-yield-type-doc",
+            "Please document the type yielded by this method.",
+            # we can't use the same old_name for two different warnings
+            # {'old_names': [('W9009', 'missing-yields-doc')]},
+        ),
+        "W9015": (
+            '"%s" missing in parameter documentation',
+            "missing-param-doc",
+            "Please add parameter declarations for all parameters.",
+            {"old_names": [("W9003", "old-missing-param-doc")]},
+        ),
+        "W9016": (
+            '"%s" missing in parameter type documentation',
+            "missing-type-doc",
+            "Please add parameter type declarations for all parameters.",
+            {"old_names": [("W9004", "old-missing-type-doc")]},
+        ),
+        "W9017": (
+            '"%s" differing in parameter documentation',
+            "differing-param-doc",
+            "Please check parameter names in declarations.",
+        ),
+        "W9018": (
+            '"%s" differing in parameter type documentation',
+            "differing-type-doc",
+            "Please check parameter names in type declarations.",
+        ),
+        "W9019": (
+            '"%s" useless ignored parameter documentation',
+            "useless-param-doc",
+            "Please remove the ignored parameter documentation.",
+        ),
+        "W9020": (
+            '"%s" useless ignored parameter type documentation',
+            "useless-type-doc",
+            "Please remove the ignored parameter type documentation.",
+        ),
+        "W9021": (
+            'Missing any documentation in "%s"',
+            "missing-any-param-doc",
+            "Please add parameter and/or type documentation.",
+        ),
+    }
+
+    options = (
+        (
+            "accept-no-param-doc",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Whether to accept totally missing parameter "
+                "documentation in the docstring of a function that has "
+                "parameters.",
+            },
+        ),
+        (
+            "accept-no-raise-doc",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Whether to accept totally missing raises "
+                "documentation in the docstring of a function that "
+                "raises an exception.",
+            },
+        ),
+        (
+            "accept-no-return-doc",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Whether to accept totally missing return "
+                "documentation in the docstring of a function that "
+                "returns a statement.",
+            },
+        ),
+        (
+            "accept-no-yields-doc",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Whether to accept totally missing yields "
+                "documentation in the docstring of a generator.",
+            },
+        ),
+        (
+            "default-docstring-type",
+            {
+                "type": "choice",
+                "default": "default",
+                "choices": list(utils.DOCSTRING_TYPES),
+                "help": "If the docstring type cannot be guessed "
+                "the specified docstring type will be used.",
+            },
+        ),
+    )
+
+    priority = -2
+
+    constructor_names = {"__init__", "__new__"}
+    not_needed_param_in_docstring = {"self", "cls"}
+
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        """Called for function and method definitions (def).
+
+        :param node: Node for a function or method definition in the AST
+        :type node: :class:`astroid.scoped_nodes.Function`
+        """
+        node_doc = utils.docstringify(node.doc_node, self.config.default_docstring_type)
+
+        # skip functions that match the 'no-docstring-rgx' config option
+        no_docstring_rgx = get_global_option(self, "no-docstring-rgx")
+        if no_docstring_rgx and re.match(no_docstring_rgx, node.name):
+            return
+
+        # skip functions smaller than 'docstring-min-length'
+        lines = checker_utils.get_node_last_lineno(node) - node.lineno
+        max_lines = get_global_option(self, "docstring-min-length")
+        if max_lines > -1 and lines < max_lines:
+            return
+
+        self.check_functiondef_params(node, node_doc)
+        self.check_functiondef_returns(node, node_doc)
+        self.check_functiondef_yields(node, node_doc)
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    def check_functiondef_params(self, node, node_doc):
+        node_allow_no_param = None
+        if node.name in self.constructor_names:
+            class_node = checker_utils.node_frame_class(node)
+            if class_node is not None:
+                class_doc = utils.docstringify(
+                    class_node.doc_node, self.config.default_docstring_type
+                )
+                self.check_single_constructor_params(class_doc, node_doc, class_node)
+
+                # __init__ or class docstrings can have no parameters documented
+                # as long as the other documents them.
+                node_allow_no_param = (
+                    class_doc.has_params()
+                    or class_doc.params_documented_elsewhere()
+                    or None
+                )
+                class_allow_no_param = (
+                    node_doc.has_params()
+                    or node_doc.params_documented_elsewhere()
+                    or None
+                )
+
+                self.check_arguments_in_docstring(
+                    class_doc, node.args, class_node, class_allow_no_param
+                )
+
+        self.check_arguments_in_docstring(
+            node_doc, node.args, node, node_allow_no_param
+        )
+
+    def check_functiondef_returns(self, node, node_doc):
+        if (not node_doc.supports_yields and node.is_generator()) or node.is_abstract():
+            return
+
+        return_nodes = node.nodes_of_class(astroid.Return)
+        if (node_doc.has_returns() or node_doc.has_rtype()) and not any(
+            utils.returns_something(ret_node) for ret_node in return_nodes
+        ):
+            self.add_message("redundant-returns-doc", node=node)
+
+    def check_functiondef_yields(self, node, node_doc):
+        if not node_doc.supports_yields or node.is_abstract():
+            return
+
+        if (
+            node_doc.has_yields() or node_doc.has_yields_type()
+        ) and not node.is_generator():
+            self.add_message("redundant-yields-doc", node=node)
+
+    def visit_raise(self, node: nodes.Raise) -> None:
+        func_node = node.frame(future=True)
+        if not isinstance(func_node, astroid.FunctionDef):
+            return
+
+        expected_excs = utils.possible_exc_types(node)
+
+        if not expected_excs:
+            return
+
+        if not func_node.doc_node:
+            # If this is a property setter,
+            # the property should have the docstring instead.
+            property_ = utils.get_setters_property(func_node)
+            if property_:
+                func_node = property_
+
+        doc = utils.docstringify(func_node.doc_node, self.config.default_docstring_type)
+        if not doc.matching_sections():
+            if doc.doc:
+                missing = {exc.name for exc in expected_excs}
+                self._handle_no_raise_doc(missing, func_node)
+            return
+
+        found_excs_full_names = doc.exceptions()
+
+        # Extract just the class name, e.g. "error" from "re.error"
+        found_excs_class_names = {exc.split(".")[-1] for exc in found_excs_full_names}
+
+        missing_excs = set()
+        for expected in expected_excs:
+            for found_exc in found_excs_class_names:
+                if found_exc == expected.name:
+                    break
+                if any(found_exc == ancestor.name for ancestor in expected.ancestors()):
+                    break
+            else:
+                missing_excs.add(expected.name)
+
+        self._add_raise_message(missing_excs, func_node)
+
+    def visit_return(self, node: nodes.Return) -> None:
+        if not utils.returns_something(node):
+            return
+
+        if self.config.accept_no_return_doc:
+            return
+
+        func_node = node.frame(future=True)
+        if not isinstance(func_node, astroid.FunctionDef):
+            return
+
+        doc = utils.docstringify(func_node.doc_node, self.config.default_docstring_type)
+
+        is_property = checker_utils.decorated_with_property(func_node)
+
+        if not (doc.has_returns() or (doc.has_property_returns() and is_property)):
+            self.add_message("missing-return-doc", node=func_node)
+
+        if func_node.returns:
+            return
+
+        if not (doc.has_rtype() or (doc.has_property_type() and is_property)):
+            self.add_message("missing-return-type-doc", node=func_node)
+
+    def visit_yield(self, node: nodes.Yield) -> None:
+        if self.config.accept_no_yields_doc:
+            return
+
+        func_node = node.frame(future=True)
+        if not isinstance(func_node, astroid.FunctionDef):
+            return
+
+        doc = utils.docstringify(func_node.doc_node, self.config.default_docstring_type)
+
+        if doc.supports_yields:
+            doc_has_yields = doc.has_yields()
+            doc_has_yields_type = doc.has_yields_type()
+        else:
+            doc_has_yields = doc.has_returns()
+            doc_has_yields_type = doc.has_rtype()
+
+        if not doc_has_yields:
+            self.add_message("missing-yield-doc", node=func_node)
+
+        if not (doc_has_yields_type or func_node.returns):
+            self.add_message("missing-yield-type-doc", node=func_node)
+
+    def visit_yieldfrom(self, node: nodes.YieldFrom) -> None:
+        self.visit_yield(node)
+
+    def _compare_missing_args(
+        self,
+        found_argument_names: Set[str],
+        message_id: str,
+        not_needed_names: Set[str],
+        expected_argument_names: Set[str],
+        warning_node: nodes.NodeNG,
+    ) -> None:
+        """Compare the found argument names with the expected ones and
+        generate a message if there are arguments missing.
+
+        :param found_argument_names: argument names found in the docstring
+
+        :param message_id: pylint message id
+
+        :param not_needed_names: names that may be omitted
+
+        :param expected_argument_names: Expected argument names
+
+        :param warning_node: The node to be analyzed
+        """
+        potential_missing_argument_names = (
+            expected_argument_names - found_argument_names
+        ) - not_needed_names
+
+        # Handle variadic and keyword args without asterisks
+        missing_argument_names = set()
+        for name in potential_missing_argument_names:
+            if name.replace("*", "") in found_argument_names:
+                continue
+            missing_argument_names.add(name)
+
+        if missing_argument_names:
+            self.add_message(
+                message_id,
+                args=(", ".join(sorted(missing_argument_names)),),
+                node=warning_node,
+            )
+
+    def _compare_different_args(
+        self,
+        found_argument_names: Set[str],
+        message_id: str,
+        not_needed_names: Set[str],
+        expected_argument_names: Set[str],
+        warning_node: nodes.NodeNG,
+    ) -> None:
+        """Compare the found argument names with the expected ones and
+        generate a message if there are extra arguments found.
+
+        :param found_argument_names: argument names found in the docstring
+
+        :param message_id: pylint message id
+
+        :param not_needed_names: names that may be omitted
+
+        :param expected_argument_names: Expected argument names
+
+        :param warning_node: The node to be analyzed
+        """
+        # Handle variadic and keyword args without asterisks
+        modified_expected_argument_names: Set[str] = set()
+        for name in expected_argument_names:
+            if name.replace("*", "") in found_argument_names:
+                modified_expected_argument_names.add(name.replace("*", ""))
+            else:
+                modified_expected_argument_names.add(name)
+
+        differing_argument_names = (
+            (modified_expected_argument_names ^ found_argument_names)
+            - not_needed_names
+            - expected_argument_names
+        )
+
+        if differing_argument_names:
+            self.add_message(
+                message_id,
+                args=(", ".join(sorted(differing_argument_names)),),
+                node=warning_node,
+            )
+
+    def _compare_ignored_args(
+        self,
+        found_argument_names,
+        message_id,
+        ignored_argument_names,
+        warning_node,
+    ):
+        """Compare the found argument names with the ignored ones and
+        generate a message if there are ignored arguments found.
+
+        :param found_argument_names: argument names found in the docstring
+        :type found_argument_names: set
+
+        :param message_id: pylint message id
+        :type message_id: str
+
+        :param ignored_argument_names: Expected argument names
+        :type ignored_argument_names: set
+
+        :param warning_node: The node to be analyzed
+        :type warning_node: :class:`astroid.scoped_nodes.Node`
+        """
+        existing_ignored_argument_names = ignored_argument_names & found_argument_names
+
+        if existing_ignored_argument_names:
+            self.add_message(
+                message_id,
+                args=(", ".join(sorted(existing_ignored_argument_names)),),
+                node=warning_node,
+            )
+
+    def check_arguments_in_docstring(
+        self,
+        doc: Docstring,
+        arguments_node: astroid.Arguments,
+        warning_node: astroid.NodeNG,
+        accept_no_param_doc: Optional[bool] = None,
+    ):
+        """Check that all parameters are consistent with the parameters mentioned
+        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
+
+        * Undocumented parameters except 'self' are noticed.
+        * Undocumented parameter types except for 'self' and the ``*<args>``
+          and ``**<kwargs>`` parameters are noticed.
+        * Parameters mentioned in the parameter documentation that don't or no
+          longer exist in the function parameter list are noticed.
+        * If the text "For the parameters, see" or "For the other parameters,
+          see" (ignoring additional whitespace) is mentioned in the docstring,
+          missing parameter documentation is tolerated.
+        * If there's no Sphinx style, Google style or NumPy style parameter
+          documentation at all, i.e. ``:param`` is never mentioned etc., the
+          checker assumes that the parameters are documented in another format
+          and the absence is tolerated.
+
+        :param doc: Docstring for the function, method or class.
+        :type doc: :class:`Docstring`
+
+        :param arguments_node: Arguments node for the function, method or
+            class constructor.
+        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
+
+        :param warning_node: The node to assign the warnings to
+        :type warning_node: :class:`astroid.scoped_nodes.Node`
+
+        :param accept_no_param_doc: Whether to allow no parameters to be
+            documented. If None then this value is read from the configuration.
+        :type accept_no_param_doc: bool or None
+        """
+        # Tolerate missing param or type declarations if there is a link to
+        # another method carrying the same name.
+        if not doc.doc:
+            return
+
+        if accept_no_param_doc is None:
+            accept_no_param_doc = self.config.accept_no_param_doc
+        tolerate_missing_params = doc.params_documented_elsewhere()
+
+        # Collect the function arguments.
+        expected_argument_names = {arg.name for arg in arguments_node.args}
+        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
+        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
+
+        expected_but_ignored_argument_names = set()
+        ignored_argument_names = get_global_option(self, "ignored-argument-names")
+        if ignored_argument_names:
+            expected_but_ignored_argument_names = {
+                arg
+                for arg in expected_argument_names
+                if ignored_argument_names.match(arg)
+            }
+
+        if arguments_node.vararg is not None:
+            expected_argument_names.add(f"*{arguments_node.vararg}")
+            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
+        if arguments_node.kwarg is not None:
+            expected_argument_names.add(f"**{arguments_node.kwarg}")
+            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
+        params_with_doc, params_with_type = doc.match_param_docs()
+        # Tolerate no parameter documentation at all.
+        if not params_with_doc and not params_with_type and accept_no_param_doc:
+            tolerate_missing_params = True
+
+        # This is before the update of param_with_type because this must check only
+        # the type documented in a docstring, not the one using pep484
+        # See #4117 and #4593
+        self._compare_ignored_args(
+            params_with_type,
+            "useless-type-doc",
+            expected_but_ignored_argument_names,
+            warning_node,
+        )
+        for index, arg_name in enumerate(arguments_node.args):
+            if arguments_node.annotations[index]:
+                params_with_type.add(arg_name.name)
+        for index, arg_name in enumerate(arguments_node.kwonlyargs):
+            if arguments_node.kwonlyargs_annotations[index]:
+                params_with_type.add(arg_name.name)
+
+        if not tolerate_missing_params:
+            missing_param_doc = (expected_argument_names - params_with_doc) - (
+                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
+            )
+            missing_type_doc = (expected_argument_names - params_with_type) - (
+                not_needed_type_in_docstring | expected_but_ignored_argument_names
+            )
+            if (
+                missing_param_doc == expected_argument_names == missing_type_doc
+                and len(expected_argument_names) != 0
+            ):
+                self.add_message(
+                    "missing-any-param-doc",
+                    args=(warning_node.name,),
+                    node=warning_node,
+                )
+            else:
+                self._compare_missing_args(
+                    params_with_doc,
+                    "missing-param-doc",
+                    self.not_needed_param_in_docstring
+                    | expected_but_ignored_argument_names,
+                    expected_argument_names,
+                    warning_node,
+                )
+                self._compare_missing_args(
+                    params_with_type,
+                    "missing-type-doc",
+                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
+                    expected_argument_names,
+                    warning_node,
+                )
+
+        self._compare_different_args(
+            params_with_doc,
+            "differing-param-doc",
+            self.not_needed_param_in_docstring,
+            expected_argument_names,
+            warning_node,
+        )
+        self._compare_different_args(
+            params_with_type,
+            "differing-type-doc",
+            not_needed_type_in_docstring,
+            expected_argument_names,
+            warning_node,
+        )
+        self._compare_ignored_args(
+            params_with_doc,
+            "useless-param-doc",
+            expected_but_ignored_argument_names,
+            warning_node,
+        )
+
+    def check_single_constructor_params(self, class_doc, init_doc, class_node):
+        if class_doc.has_params() and init_doc.has_params():
+            self.add_message(
+                "multiple-constructor-doc", args=(class_node.name,), node=class_node
+            )
+
+    def _handle_no_raise_doc(self, excs, node):
+        if self.config.accept_no_raise_doc:
+            return
+
+        self._add_raise_message(excs, node)
+
+    def _add_raise_message(self, missing_excs, node):
+        """Adds a message on :param:`node` for the missing exception type.
+
+        :param missing_excs: A list of missing exception types.
+        :type missing_excs: set(str)
+
+        :param node: The node show the message on.
+        :type node: nodes.NodeNG
+        """
+        if node.is_abstract():
+            try:
+                missing_excs.remove("NotImplementedError")
+            except KeyError:
+                pass
+
+        if not missing_excs:
+            return
+
+        self.add_message(
+            "missing-raises-doc", args=(", ".join(sorted(missing_excs)),), node=node
+        )
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(DocstringParameterChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/docstyle.py b/myenv/lib/python3.9/site-packages/pylint/extensions/docstyle.py
new file mode 100644
index 0000000..537f110
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/docstyle.py
@@ -0,0 +1,88 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import linecache
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint import checkers
+from pylint.checkers.utils import check_messages
+from pylint.constants import PY38_PLUS
+from pylint.interfaces import HIGH, IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class DocStringStyleChecker(checkers.BaseChecker):
+    """Checks format of docstrings based on PEP 0257."""
+
+    __implements__ = IAstroidChecker
+    name = "docstyle"
+
+    msgs = {
+        "C0198": (
+            'Bad docstring quotes in %s, expected """, given %s',
+            "bad-docstring-quotes",
+            "Used when a docstring does not have triple double quotes. "
+            "This checker only works on Python 3.8+.",
+        ),
+        "C0199": (
+            "First line empty in %s docstring",
+            "docstring-first-line-empty",
+            "Used when a blank line is found at the beginning of a docstring.",
+        ),
+    }
+
+    @check_messages("docstring-first-line-empty", "bad-docstring-quotes")
+    def visit_module(self, node: nodes.Module) -> None:
+        self._check_docstring("module", node)
+
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        self._check_docstring("class", node)
+
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        ftype = "method" if node.is_method() else "function"
+        self._check_docstring(ftype, node)
+
+    visit_asyncfunctiondef = visit_functiondef
+
+    def _check_docstring(self, node_type, node):
+        docstring = node.doc_node.value if node.doc_node else None
+        if docstring and docstring[0] == "\n":
+            self.add_message(
+                "docstring-first-line-empty",
+                node=node,
+                args=(node_type,),
+                confidence=HIGH,
+            )
+
+        # Use "linecache", instead of node.as_string(), because the latter
+        # looses the original form of the docstrings.
+
+        if docstring:
+            lineno = node.fromlineno + 1
+            line = linecache.getline(node.root().file, lineno).lstrip()
+            if line and line.find('"""') == 0:
+                return
+            if line and "'''" in line:
+                quotes = "'''"
+            elif line and line[0] == '"':
+                quotes = '"'
+            elif line and line[0] == "'":
+                quotes = "'"
+            else:
+                quotes = False
+            if quotes and PY38_PLUS:
+                self.add_message(
+                    "bad-docstring-quotes",
+                    node=node,
+                    args=(node_type, quotes),
+                    confidence=HIGH,
+                )
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(DocStringStyleChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/empty_comment.py b/myenv/lib/python3.9/site-packages/pylint/extensions/empty_comment.py
new file mode 100644
index 0000000..4308364
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/empty_comment.py
@@ -0,0 +1,67 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.interfaces import IRawChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+def is_line_commented(line):
+    """Checks if a `# symbol that is not part of a string was found in line."""
+
+    comment_idx = line.find(b"#")
+    if comment_idx == -1:
+        return False
+    if comment_part_of_string(line, comment_idx):
+        return is_line_commented(line[:comment_idx] + line[comment_idx + 1 :])
+    return True
+
+
+def comment_part_of_string(line, comment_idx):
+    """Checks if the symbol at comment_idx is part of a string."""
+
+    if (
+        line[:comment_idx].count(b"'") % 2 == 1
+        and line[comment_idx:].count(b"'") % 2 == 1
+    ) or (
+        line[:comment_idx].count(b'"') % 2 == 1
+        and line[comment_idx:].count(b'"') % 2 == 1
+    ):
+        return True
+    return False
+
+
+class CommentChecker(BaseChecker):
+    __implements__ = IRawChecker
+
+    name = "refactoring"
+    msgs = {
+        "R2044": (
+            "Line with empty comment",
+            "empty-comment",
+            (
+                "Used when a # symbol appears on a line not followed by an actual comment"
+            ),
+        )
+    }
+    options = ()
+    priority = -1  # low priority
+
+    def process_module(self, node: nodes.Module) -> None:
+        with node.stream() as stream:
+            for (line_num, line) in enumerate(stream):
+                line = line.rstrip()
+                if line.endswith(b"#"):
+                    if not is_line_commented(line[:-1]):
+                        self.add_message("empty-comment", line=line_num + 1)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(CommentChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/emptystring.py b/myenv/lib/python3.9/site-packages/pylint/extensions/emptystring.py
new file mode 100644
index 0000000..68f086f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/emptystring.py
@@ -0,0 +1,72 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Looks for  comparisons to empty string."""
+
+import itertools
+from typing import TYPE_CHECKING, Any, Iterable
+
+from astroid import nodes
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class CompareToEmptyStringChecker(checkers.BaseChecker):
+    """Checks for comparisons to empty string.
+
+    Most of the time you should use the fact that empty strings are false.
+    An exception to this rule is when an empty string value is allowed in the program
+    and has a different meaning than None!
+    """
+
+    __implements__ = (interfaces.IAstroidChecker,)
+
+    # configuration section name
+    name = "compare-to-empty-string"
+    msgs = {
+        "C1901": (
+            "Avoid comparisons to empty string",
+            "compare-to-empty-string",
+            "Used when Pylint detects comparison to an empty string constant.",
+        )
+    }
+
+    priority = -2
+    options = ()
+
+    @utils.check_messages("compare-to-empty-string")
+    def visit_compare(self, node: nodes.Compare) -> None:
+        _operators = ["!=", "==", "is not", "is"]
+        # note: astroid.Compare has the left most operand in node.left
+        # while the rest are a list of tuples in node.ops
+        # the format of the tuple is ('compare operator sign', node)
+        # here we squash everything into `ops` to make it easier for processing later
+        ops = [("", node.left)]
+        ops.extend(node.ops)
+        iter_ops: Iterable[Any] = iter(ops)
+        ops = list(itertools.chain(*iter_ops))
+
+        for ops_idx in range(len(ops) - 2):
+            op_1 = ops[ops_idx]
+            op_2 = ops[ops_idx + 1]
+            op_3 = ops[ops_idx + 2]
+            error_detected = False
+
+            # x ?? ""
+            if utils.is_empty_str_literal(op_1) and op_2 in _operators:
+                error_detected = True
+            # '' ?? X
+            elif op_2 in _operators and utils.is_empty_str_literal(op_3):
+                error_detected = True
+
+            if error_detected:
+                self.add_message("compare-to-empty-string", node=node)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(CompareToEmptyStringChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/eq_without_hash.py b/myenv/lib/python3.9/site-packages/pylint/extensions/eq_without_hash.py
new file mode 100644
index 0000000..9cbbb54
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/eq_without_hash.py
@@ -0,0 +1,41 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""This is the remnant of the python3 checker.
+
+It was removed because the transition from python 2 to python3 is
+behind us, but some checks are still useful in python3 after all.
+See https://github.com/PyCQA/pylint/issues/5025
+"""
+
+from astroid import nodes
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+from pylint.lint import PyLinter
+
+
+class EqWithoutHash(checkers.BaseChecker):
+
+    __implements__ = interfaces.IAstroidChecker
+    name = "eq-without-hash"
+
+    msgs = {
+        "W1641": (
+            "Implementing __eq__ without also implementing __hash__",
+            "eq-without-hash",
+            "Used when a class implements __eq__ but not __hash__. Objects get "
+            "None as their default __hash__ implementation if they also implement __eq__.",
+        ),
+    }
+
+    @utils.check_messages("eq-without-hash")
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        locals_and_methods = set(node.locals).union(x.name for x in node.mymethods())
+        if "__eq__" in locals_and_methods and "__hash__" not in locals_and_methods:
+            self.add_message("eq-without-hash", node=node, confidence=interfaces.HIGH)
+
+
+def register(linter: PyLinter) -> None:
+    linter.register_checker(EqWithoutHash(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/for_any_all.py b/myenv/lib/python3.9/site-packages/pylint/extensions/for_any_all.py
new file mode 100644
index 0000000..078c204
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/for_any_all.py
@@ -0,0 +1,73 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Check for use of for loops that only check for a condition."""
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages, returns_bool
+from pylint.interfaces import IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint.pylinter import PyLinter
+
+
+class ConsiderUsingAnyOrAllChecker(BaseChecker):
+
+    __implements__ = (IAstroidChecker,)
+    name = "consider-using-any-or-all"
+    msgs = {
+        "C0501": (
+            "`for` loop could be `%s`",
+            "consider-using-any-or-all",
+            "A for loop that checks for a condition and return a bool can be replaced with any or all.",
+        )
+    }
+
+    @check_messages("consider-using-any-or-all")
+    def visit_for(self, node: nodes.For) -> None:
+        if len(node.body) != 1:  # Only If node with no Else
+            return
+        if not isinstance(node.body[0], nodes.If):
+            return
+
+        if_children = list(node.body[0].get_children())
+        if not len(if_children) == 2:  # The If node has only a comparison and return
+            return
+        if not returns_bool(if_children[1]):
+            return
+
+        # Check for terminating boolean return right after the loop
+        node_after_loop = node.next_sibling()
+        if returns_bool(node_after_loop):
+            final_return_bool = node_after_loop.value.value
+            suggested_string = self._build_suggested_string(node, final_return_bool)
+            self.add_message(
+                "consider-using-any-or-all", node=node, args=suggested_string
+            )
+
+    @staticmethod
+    def _build_suggested_string(node: nodes.For, final_return_bool: bool) -> str:
+        """When a nodes.For node can be rewritten as an any/all statement, return a suggestion for that statement
+        final_return_bool is the boolean literal returned after the for loop if all conditions fail
+        """
+        loop_var = node.target.as_string()
+        loop_iter = node.iter.as_string()
+        test_node = next(node.body[0].get_children())
+
+        if isinstance(test_node, nodes.UnaryOp) and test_node.op == "not":
+            # The condition is negated. Advance the node to the operand and modify the suggestion
+            test_node = test_node.operand
+            suggested_function = "all" if final_return_bool else "not all"
+        else:
+            suggested_function = "not any" if final_return_bool else "any"
+
+        test = test_node.as_string()
+        return f"{suggested_function}({test} for {loop_var} in {loop_iter})"
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(ConsiderUsingAnyOrAllChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/mccabe.py b/myenv/lib/python3.9/site-packages/pylint/extensions/mccabe.py
new file mode 100644
index 0000000..5d2e2fc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/mccabe.py
@@ -0,0 +1,195 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Module to add McCabe checker class for pylint."""
+
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+from mccabe import PathGraph as Mccabe_PathGraph
+from mccabe import PathGraphingAstVisitor as Mccabe_PathGraphingAstVisitor
+
+from pylint import checkers
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import HIGH, IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class PathGraph(Mccabe_PathGraph):
+    def __init__(self, node):
+        super().__init__(name="", entity="", lineno=1)
+        self.root = node
+
+
+class PathGraphingAstVisitor(Mccabe_PathGraphingAstVisitor):
+    def __init__(self):
+        super().__init__()
+        self._bottom_counter = 0
+
+    def default(self, node, *args):
+        for child in node.get_children():
+            self.dispatch(child, *args)
+
+    def dispatch(self, node, *args):
+        self.node = node
+        klass = node.__class__
+        meth = self._cache.get(klass)
+        if meth is None:
+            class_name = klass.__name__
+            meth = getattr(self.visitor, "visit" + class_name, self.default)
+            self._cache[klass] = meth
+        return meth(node, *args)
+
+    def visitFunctionDef(self, node):
+        if self.graph is not None:
+            # closure
+            pathnode = self._append_node(node)
+            self.tail = pathnode
+            self.dispatch_list(node.body)
+            bottom = f"{self._bottom_counter}"
+            self._bottom_counter += 1
+            self.graph.connect(self.tail, bottom)
+            self.graph.connect(node, bottom)
+            self.tail = bottom
+        else:
+            self.graph = PathGraph(node)
+            self.tail = node
+            self.dispatch_list(node.body)
+            self.graphs[f"{self.classname}{node.name}"] = self.graph
+            self.reset()
+
+    visitAsyncFunctionDef = visitFunctionDef
+
+    def visitSimpleStatement(self, node):
+        self._append_node(node)
+
+    visitAssert = (
+        visitAssign
+    ) = (
+        visitAugAssign
+    ) = (
+        visitDelete
+    ) = (
+        visitPrint
+    ) = (
+        visitRaise
+    ) = (
+        visitYield
+    ) = (
+        visitImport
+    ) = (
+        visitCall
+    ) = (
+        visitSubscript
+    ) = (
+        visitPass
+    ) = (
+        visitContinue
+    ) = (
+        visitBreak
+    ) = visitGlobal = visitReturn = visitExpr = visitAwait = visitSimpleStatement
+
+    def visitWith(self, node):
+        self._append_node(node)
+        self.dispatch_list(node.body)
+
+    visitAsyncWith = visitWith
+
+    def _append_node(self, node):
+        if not self.tail:
+            return None
+        self.graph.connect(self.tail, node)
+        self.tail = node
+        return node
+
+    def _subgraph(self, node, name, extra_blocks=()):
+        """Create the subgraphs representing any `if` and `for` statements."""
+        if self.graph is None:
+            # global loop
+            self.graph = PathGraph(node)
+            self._subgraph_parse(node, node, extra_blocks)
+            self.graphs[f"{self.classname}{name}"] = self.graph
+            self.reset()
+        else:
+            self._append_node(node)
+            self._subgraph_parse(node, node, extra_blocks)
+
+    def _subgraph_parse(self, node, pathnode, extra_blocks):
+        """Parse the body and any `else` block of `if` and `for` statements."""
+        loose_ends = []
+        self.tail = node
+        self.dispatch_list(node.body)
+        loose_ends.append(self.tail)
+        for extra in extra_blocks:
+            self.tail = node
+            self.dispatch_list(extra.body)
+            loose_ends.append(self.tail)
+        if node.orelse:
+            self.tail = node
+            self.dispatch_list(node.orelse)
+            loose_ends.append(self.tail)
+        else:
+            loose_ends.append(node)
+        if node:
+            bottom = f"{self._bottom_counter}"
+            self._bottom_counter += 1
+            for end in loose_ends:
+                self.graph.connect(end, bottom)
+            self.tail = bottom
+
+
+class McCabeMethodChecker(checkers.BaseChecker):
+    """Checks McCabe complexity cyclomatic threshold in methods and functions
+    to validate a too complex code.
+    """
+
+    __implements__ = IAstroidChecker
+    name = "design"
+
+    msgs = {
+        "R1260": (
+            "%s is too complex. The McCabe rating is %d",
+            "too-complex",
+            "Used when a method or function is too complex based on "
+            "McCabe Complexity Cyclomatic",
+        )
+    }
+    options = (
+        (
+            "max-complexity",
+            {
+                "default": 10,
+                "type": "int",
+                "metavar": "<int>",
+                "help": "McCabe complexity cyclomatic threshold",
+            },
+        ),
+    )
+
+    @check_messages("too-complex")
+    def visit_module(self, node: nodes.Module) -> None:
+        """Visit an astroid.Module node to check too complex rating and
+        add message if is greater than max_complexity stored from options
+        """
+        visitor = PathGraphingAstVisitor()
+        for child in node.body:
+            visitor.preorder(child, visitor)
+        for graph in visitor.graphs.values():
+            complexity = graph.complexity()
+            node = graph.root
+            if hasattr(node, "name"):
+                node_name = f"'{node.name}'"
+            else:
+                node_name = f"This '{node.__class__.__name__.lower()}'"
+            if complexity <= self.config.max_complexity:
+                continue
+            self.add_message(
+                "too-complex", node=node, confidence=HIGH, args=(node_name, complexity)
+            )
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(McCabeMethodChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/overlapping_exceptions.py b/myenv/lib/python3.9/site-packages/pylint/extensions/overlapping_exceptions.py
new file mode 100644
index 0000000..17eaa6d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/overlapping_exceptions.py
@@ -0,0 +1,91 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Looks for overlapping exceptions."""
+
+from typing import TYPE_CHECKING, Any, List, Tuple
+
+import astroid
+from astroid import nodes
+
+from pylint import checkers, interfaces
+from pylint.checkers import utils
+from pylint.checkers.exceptions import _annotated_unpack_infer
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class OverlappingExceptionsChecker(checkers.BaseChecker):
+    """Checks for two or more exceptions in the same exception handler
+    clause that are identical or parts of the same inheritance hierarchy
+
+    (i.e. overlapping).
+    """
+
+    __implements__ = interfaces.IAstroidChecker
+
+    name = "overlap-except"
+    msgs = {
+        "W0714": (
+            "Overlapping exceptions (%s)",
+            "overlapping-except",
+            "Used when exceptions in handler overlap or are identical",
+        )
+    }
+    priority = -2
+    options = ()
+
+    @utils.check_messages("overlapping-except")
+    def visit_tryexcept(self, node: nodes.TryExcept) -> None:
+        """Check for empty except."""
+        for handler in node.handlers:
+            if handler.type is None:
+                continue
+            if isinstance(handler.type, astroid.BoolOp):
+                continue
+            try:
+                excs = list(_annotated_unpack_infer(handler.type))
+            except astroid.InferenceError:
+                continue
+
+            handled_in_clause: List[Tuple[Any, Any]] = []
+            for part, exc in excs:
+                if exc is astroid.Uninferable:
+                    continue
+                if isinstance(exc, astroid.Instance) and utils.inherit_from_std_ex(exc):
+                    exc = exc._proxied
+
+                if not isinstance(exc, astroid.ClassDef):
+                    continue
+
+                exc_ancestors = [
+                    anc for anc in exc.ancestors() if isinstance(anc, astroid.ClassDef)
+                ]
+
+                for prev_part, prev_exc in handled_in_clause:
+                    prev_exc_ancestors = [
+                        anc
+                        for anc in prev_exc.ancestors()
+                        if isinstance(anc, astroid.ClassDef)
+                    ]
+                    if exc == prev_exc:
+                        self.add_message(
+                            "overlapping-except",
+                            node=handler.type,
+                            args=f"{prev_part.as_string()} and {part.as_string()} are the same",
+                        )
+                    elif prev_exc in exc_ancestors or exc in prev_exc_ancestors:
+                        ancestor = part if exc in prev_exc_ancestors else prev_part
+                        descendant = part if prev_exc in exc_ancestors else prev_part
+                        self.add_message(
+                            "overlapping-except",
+                            node=handler.type,
+                            args=f"{ancestor.as_string()} is an ancestor class of {descendant.as_string()}",
+                        )
+                handled_in_clause += [(part, exc)]
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(OverlappingExceptionsChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/private_import.py b/myenv/lib/python3.9/site-packages/pylint/extensions/private_import.py
new file mode 100644
index 0000000..8d57eca
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/private_import.py
@@ -0,0 +1,252 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Check for imports on private external modules and names."""
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict, List, Union
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker, utils
+from pylint.interfaces import HIGH, IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint.pylinter import PyLinter
+
+
+class PrivateImportChecker(BaseChecker):
+
+    __implements__ = (IAstroidChecker,)
+    name = "import-private-name"
+    msgs = {
+        "C2701": (
+            "Imported private %s (%s)",
+            "import-private-name",
+            "Used when a private module or object prefixed with _ is imported. "
+            "PEP8 guidance on Naming Conventions states that public attributes with "
+            "leading underscores should be considered private.",
+        ),
+    }
+
+    def __init__(self, linter: "PyLinter") -> None:
+        BaseChecker.__init__(self, linter)
+
+        # A mapping of private names used as a type annotation to whether it is an acceptable import
+        self.all_used_type_annotations: Dict[str, bool] = {}
+        self.populated_annotations = False
+
+    @utils.check_messages("import-private-name")
+    def visit_import(self, node: nodes.Import) -> None:
+        if utils.is_node_in_typing_guarded_import_block(node):
+            return
+        names = [name[0] for name in node.names]
+        private_names = self._get_private_imports(names)
+        private_names = self._get_type_annotation_names(node, private_names)
+        if private_names:
+            imported_identifier = "modules" if len(private_names) > 1 else "module"
+            private_name_string = ", ".join(private_names)
+            self.add_message(
+                "import-private-name",
+                node=node,
+                args=(imported_identifier, private_name_string),
+                confidence=HIGH,
+            )
+
+    @utils.check_messages("import-private-name")
+    def visit_importfrom(self, node: nodes.ImportFrom) -> None:
+        if utils.is_node_in_typing_guarded_import_block(node):
+            return
+        # Only check imported names if the module is external
+        if self.same_root_dir(node, node.modname):
+            return
+
+        names = [n[0] for n in node.names]
+
+        # Check the imported objects first. If they are all valid type annotations, the package can be private
+        private_names = self._get_type_annotation_names(node, names)
+        if not private_names:
+            return
+
+        # There are invalid imported objects, so check the name of the package
+        private_module_imports = self._get_private_imports([node.modname])
+        private_module_imports = self._get_type_annotation_names(
+            node, private_module_imports
+        )
+        if private_module_imports:
+            self.add_message(
+                "import-private-name",
+                node=node,
+                args=("module", private_module_imports[0]),
+                confidence=HIGH,
+            )
+            return  # Do not emit messages on the objects if the package is private
+
+        private_names = self._get_private_imports(private_names)
+
+        if private_names:
+            imported_identifier = "objects" if len(private_names) > 1 else "object"
+            private_name_string = ", ".join(private_names)
+            self.add_message(
+                "import-private-name",
+                node=node,
+                args=(imported_identifier, private_name_string),
+                confidence=HIGH,
+            )
+
+    def _get_private_imports(self, names: List[str]) -> List[str]:
+        """Returns the private names from input names by a simple string check."""
+        return [name for name in names if self._name_is_private(name)]
+
+    @staticmethod
+    def _name_is_private(name: str) -> bool:
+        """Returns true if the name exists, starts with `_`, and if len(name) > 4
+        it is not a dunder, i.e. it does not begin and end with two underscores.
+        """
+        return (
+            bool(name)
+            and name[0] == "_"
+            and (len(name) <= 4 or name[1] != "_" or name[-2:] != "__")
+        )
+
+    def _get_type_annotation_names(
+        self, node: nodes.Import, names: List[str]
+    ) -> List[str]:
+        """Removes from names any names that are used as type annotations with no other illegal usages."""
+        if names and not self.populated_annotations:
+            self._populate_type_annotations(node.root(), self.all_used_type_annotations)
+            self.populated_annotations = True
+
+        return [
+            n
+            for n in names
+            if n not in self.all_used_type_annotations
+            or (
+                n in self.all_used_type_annotations
+                and not self.all_used_type_annotations[n]
+            )
+        ]
+
+    def _populate_type_annotations(
+        self, node: nodes.LocalsDictNodeNG, all_used_type_annotations: Dict[str, bool]
+    ) -> None:
+        """Adds into the dict `all_used_type_annotations` the names of all names ever used as a type annotation
+        in the scope and nested scopes of node and whether these names are only used for type checking.
+        """
+        for name in node.locals:
+            # If we find a private type annotation, make sure we do not mask illegal usages
+            private_name = None
+            # All the assignments using this variable that we might have to check for illegal usages later
+            name_assignments = []
+            for usage_node in node.locals[name]:
+                if isinstance(usage_node, nodes.AssignName) and isinstance(
+                    usage_node.parent, (nodes.AnnAssign, nodes.Assign)
+                ):
+                    assign_parent = usage_node.parent
+                    if isinstance(assign_parent, nodes.AnnAssign):
+                        name_assignments.append(assign_parent)
+                        private_name = self._populate_type_annotations_annotation(
+                            usage_node.parent.annotation, all_used_type_annotations
+                        )
+                    elif isinstance(assign_parent, nodes.Assign):
+                        name_assignments.append(assign_parent)
+
+                if isinstance(usage_node, nodes.FunctionDef):
+                    self._populate_type_annotations_function(
+                        usage_node, all_used_type_annotations
+                    )
+                if isinstance(usage_node, nodes.LocalsDictNodeNG):
+                    self._populate_type_annotations(
+                        usage_node, all_used_type_annotations
+                    )
+            if private_name is not None:
+                # Found a new private annotation, make sure we are not accessing it elsewhere
+                all_used_type_annotations[
+                    private_name
+                ] = self._assignments_call_private_name(name_assignments, private_name)
+
+    def _populate_type_annotations_function(
+        self, node: nodes.FunctionDef, all_used_type_annotations: Dict[str, bool]
+    ) -> None:
+        """Adds into the dict `all_used_type_annotations` the names of all names used as a type annotation
+        in the arguments and return type of the function node.
+        """
+        if node.args and node.args.annotations:
+            for annotation in node.args.annotations:
+                self._populate_type_annotations_annotation(
+                    annotation, all_used_type_annotations
+                )
+        if node.returns:
+            self._populate_type_annotations_annotation(
+                node.returns, all_used_type_annotations
+            )
+
+    def _populate_type_annotations_annotation(
+        self,
+        node: Union[nodes.Attribute, nodes.Subscript, nodes.Name],
+        all_used_type_annotations: Dict[str, bool],
+    ) -> Union[str, None]:
+        """Handles the possiblity of an annotation either being a Name, i.e. just type,
+        or a Subscript e.g. `Optional[type]` or an Attribute, e.g. `pylint.lint.linter`.
+        """
+        if isinstance(node, nodes.Name) and node.name not in all_used_type_annotations:
+            all_used_type_annotations[node.name] = True
+            return node.name
+        if isinstance(node, nodes.Subscript):  # e.g. Optional[List[str]]
+            # slice is the next nested type
+            self._populate_type_annotations_annotation(
+                node.slice, all_used_type_annotations
+            )
+            # value is the current type name: could be a Name or Attribute
+            return self._populate_type_annotations_annotation(
+                node.value, all_used_type_annotations
+            )
+        if isinstance(node, nodes.Attribute):
+            # An attribute is a type like `pylint.lint.pylinter`. node.expr is the next level up, could be another attribute
+            return self._populate_type_annotations_annotation(
+                node.expr, all_used_type_annotations
+            )
+        return None
+
+    @staticmethod
+    def _assignments_call_private_name(
+        assignments: List[Union[nodes.AnnAssign, nodes.Assign]], private_name: str
+    ) -> bool:
+        """Returns True if no assignments involve accessing `private_name`."""
+        if all(not assignment.value for assignment in assignments):
+            # Variable annotated but unassigned is unallowed because there may be a possible illegal access elsewhere
+            return False
+        for assignment in assignments:
+            current_attribute = None
+            if isinstance(assignment.value, nodes.Call):
+                current_attribute = assignment.value.func
+            elif isinstance(assignment.value, nodes.Attribute):
+                current_attribute = assignment.value
+            elif isinstance(assignment.value, nodes.Name):
+                current_attribute = assignment.value.name
+            if not current_attribute:
+                continue
+            while isinstance(current_attribute, (nodes.Attribute, nodes.Call)):
+                if isinstance(current_attribute, nodes.Call):
+                    current_attribute = current_attribute.func
+                current_attribute = current_attribute.expr
+            if (
+                isinstance(current_attribute, nodes.Name)
+                and current_attribute.name == private_name
+            ):
+                return False
+        return True
+
+    @staticmethod
+    def same_root_dir(node: nodes.Import, import_mod_name: str) -> bool:
+        """Does the node's file's path contain the base name of `import_mod_name`?"""
+        if not import_mod_name:  # from . import ...
+            return True
+
+        base_import_package = import_mod_name.split(".")[0]
+
+        return base_import_package in Path(node.root().file).parent.parts
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(PrivateImportChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/redefined_variable_type.py b/myenv/lib/python3.9/site-packages/pylint/extensions/redefined_variable_type.py
new file mode 100644
index 0000000..4146463
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/redefined_variable_type.py
@@ -0,0 +1,109 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import TYPE_CHECKING, List
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages, is_none, node_type
+from pylint.interfaces import IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class MultipleTypesChecker(BaseChecker):
+    """Checks for variable type redefinitions (NoneType excepted).
+
+    At a function, method, class or module scope
+
+    This rule could be improved:
+
+    - Currently, if an attribute is set to different types in 2 methods of a
+      same class, it won't be detected (see functional test)
+    - One could improve the support for inference on assignment with tuples,
+      ifexpr, etc. Also, it would be great to have support for inference on
+      str.split()
+    """
+
+    __implements__ = IAstroidChecker
+
+    name = "multiple_types"
+    msgs = {
+        "R0204": (
+            "Redefinition of %s type from %s to %s",
+            "redefined-variable-type",
+            "Used when the type of a variable changes inside a "
+            "method or a function.",
+        )
+    }
+
+    def visit_classdef(self, _: nodes.ClassDef) -> None:
+        self._assigns.append({})
+
+    @check_messages("redefined-variable-type")
+    def leave_classdef(self, _: nodes.ClassDef) -> None:
+        self._check_and_add_messages()
+
+    visit_functiondef = visit_classdef
+    leave_functiondef = leave_module = leave_classdef
+
+    def visit_module(self, _: nodes.Module) -> None:
+        self._assigns: List[dict] = [{}]
+
+    def _check_and_add_messages(self):
+        assigns = self._assigns.pop()
+        for name, args in assigns.items():
+            if len(args) <= 1:
+                continue
+            orig_node, orig_type = args[0]
+            # Check if there is a type in the following nodes that would be
+            # different from orig_type.
+            for redef_node, redef_type in args[1:]:
+                if redef_type == orig_type:
+                    continue
+                # if a variable is defined to several types in an if node,
+                # this is not actually redefining.
+                orig_parent = orig_node.parent
+                redef_parent = redef_node.parent
+                if isinstance(orig_parent, nodes.If):
+                    if orig_parent == redef_parent:
+                        if (
+                            redef_node in orig_parent.orelse
+                            and orig_node not in orig_parent.orelse
+                        ):
+                            orig_node, orig_type = redef_node, redef_type
+                            continue
+                    elif isinstance(
+                        redef_parent, nodes.If
+                    ) and redef_parent in orig_parent.nodes_of_class(nodes.If):
+                        orig_node, orig_type = redef_node, redef_type
+                        continue
+                orig_type = orig_type.replace("builtins.", "")
+                redef_type = redef_type.replace("builtins.", "")
+                self.add_message(
+                    "redefined-variable-type",
+                    node=redef_node,
+                    args=(name, orig_type, redef_type),
+                )
+                break
+
+    def visit_assign(self, node: nodes.Assign) -> None:
+        # we don't handle multiple assignment nor slice assignment
+        target = node.targets[0]
+        if isinstance(target, (nodes.Tuple, nodes.Subscript)):
+            return
+        # ignore NoneType
+        if is_none(node):
+            return
+        _type = node_type(node.value)
+        if _type:
+            self._assigns[-1].setdefault(target.as_string(), []).append(
+                (node, _type.pytype())
+            )
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(MultipleTypesChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/set_membership.py b/myenv/lib/python3.9/site-packages/pylint/extensions/set_membership.py
new file mode 100644
index 0000000..57089dc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/set_membership.py
@@ -0,0 +1,55 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class SetMembershipChecker(BaseChecker):
+
+    __implements__ = (IAstroidChecker,)
+
+    name = "set_membership"
+    priority = -1
+    msgs = {
+        "R6201": (
+            "Consider using set for membership test",
+            "use-set-for-membership",
+            "Membership tests are more efficient when performed on "
+            "a lookup optimized datatype like ``sets``.",
+        ),
+    }
+
+    def __init__(self, linter: "PyLinter") -> None:
+        """Initialize checker instance."""
+        super().__init__(linter=linter)
+
+    @check_messages("use-set-for-membership")
+    def visit_compare(self, node: nodes.Compare) -> None:
+        for op, comparator in node.ops:
+            if op == "in":
+                self._check_in_comparison(comparator)
+
+    def _check_in_comparison(self, comparator: nodes.NodeNG) -> None:
+        """Checks for membership comparisons with in-place container objects."""
+        if not isinstance(comparator, nodes.BaseContainer) or isinstance(
+            comparator, nodes.Set
+        ):
+            return
+
+        # Heuristic - We need to be sure all items in set are hashable
+        if all(isinstance(item, nodes.Const) for item in comparator.elts):
+            self.add_message("use-set-for-membership", node=comparator)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(SetMembershipChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/typing.py b/myenv/lib/python3.9/site-packages/pylint/extensions/typing.py
new file mode 100644
index 0000000..ce25ff7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/typing.py
@@ -0,0 +1,436 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import TYPE_CHECKING, Dict, List, NamedTuple, Set, Union
+
+import astroid.bases
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import (
+    check_messages,
+    in_type_checking_block,
+    is_node_in_type_annotation_context,
+    is_postponed_evaluation_enabled,
+    safe_infer,
+)
+from pylint.interfaces import INFERENCE, IAstroidChecker
+from pylint.utils.utils import get_global_option
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class TypingAlias(NamedTuple):
+    name: str
+    name_collision: bool
+
+
+DEPRECATED_TYPING_ALIASES: Dict[str, TypingAlias] = {
+    "typing.Tuple": TypingAlias("tuple", False),
+    "typing.List": TypingAlias("list", False),
+    "typing.Dict": TypingAlias("dict", False),
+    "typing.Set": TypingAlias("set", False),
+    "typing.FrozenSet": TypingAlias("frozenset", False),
+    "typing.Type": TypingAlias("type", False),
+    "typing.Deque": TypingAlias("collections.deque", True),
+    "typing.DefaultDict": TypingAlias("collections.defaultdict", True),
+    "typing.OrderedDict": TypingAlias("collections.OrderedDict", True),
+    "typing.Counter": TypingAlias("collections.Counter", True),
+    "typing.ChainMap": TypingAlias("collections.ChainMap", True),
+    "typing.Awaitable": TypingAlias("collections.abc.Awaitable", True),
+    "typing.Coroutine": TypingAlias("collections.abc.Coroutine", True),
+    "typing.AsyncIterable": TypingAlias("collections.abc.AsyncIterable", True),
+    "typing.AsyncIterator": TypingAlias("collections.abc.AsyncIterator", True),
+    "typing.AsyncGenerator": TypingAlias("collections.abc.AsyncGenerator", True),
+    "typing.Iterable": TypingAlias("collections.abc.Iterable", True),
+    "typing.Iterator": TypingAlias("collections.abc.Iterator", True),
+    "typing.Generator": TypingAlias("collections.abc.Generator", True),
+    "typing.Reversible": TypingAlias("collections.abc.Reversible", True),
+    "typing.Container": TypingAlias("collections.abc.Container", True),
+    "typing.Collection": TypingAlias("collections.abc.Collection", True),
+    "typing.Callable": TypingAlias("collections.abc.Callable", True),
+    "typing.AbstractSet": TypingAlias("collections.abc.Set", False),
+    "typing.MutableSet": TypingAlias("collections.abc.MutableSet", True),
+    "typing.Mapping": TypingAlias("collections.abc.Mapping", True),
+    "typing.MutableMapping": TypingAlias("collections.abc.MutableMapping", True),
+    "typing.Sequence": TypingAlias("collections.abc.Sequence", True),
+    "typing.MutableSequence": TypingAlias("collections.abc.MutableSequence", True),
+    "typing.ByteString": TypingAlias("collections.abc.ByteString", True),
+    "typing.MappingView": TypingAlias("collections.abc.MappingView", True),
+    "typing.KeysView": TypingAlias("collections.abc.KeysView", True),
+    "typing.ItemsView": TypingAlias("collections.abc.ItemsView", True),
+    "typing.ValuesView": TypingAlias("collections.abc.ValuesView", True),
+    "typing.ContextManager": TypingAlias("contextlib.AbstractContextManager", False),
+    "typing.AsyncContextManager": TypingAlias(
+        "contextlib.AbstractAsyncContextManager", False
+    ),
+    "typing.Pattern": TypingAlias("re.Pattern", True),
+    "typing.Match": TypingAlias("re.Match", True),
+    "typing.Hashable": TypingAlias("collections.abc.Hashable", True),
+    "typing.Sized": TypingAlias("collections.abc.Sized", True),
+}
+
+ALIAS_NAMES = frozenset(key.split(".")[1] for key in DEPRECATED_TYPING_ALIASES)
+UNION_NAMES = ("Optional", "Union")
+TYPING_NORETURN = frozenset(
+    (
+        "typing.NoReturn",
+        "typing_extensions.NoReturn",
+    )
+)
+
+
+class DeprecatedTypingAliasMsg(NamedTuple):
+    node: Union[nodes.Name, nodes.Attribute]
+    qname: str
+    alias: str
+    parent_subscript: bool = False
+
+
+class TypingChecker(BaseChecker):
+    """Find issue specifically related to type annotations."""
+
+    __implements__ = (IAstroidChecker,)
+
+    name = "typing"
+    priority = -1
+    msgs = {
+        "W6001": (
+            "'%s' is deprecated, use '%s' instead",
+            "deprecated-typing-alias",
+            "Emitted when a deprecated typing alias is used.",
+        ),
+        "R6002": (
+            "'%s' will be deprecated with PY39, consider using '%s' instead%s",
+            "consider-using-alias",
+            "Only emitted if 'runtime-typing=no' and a deprecated "
+            "typing alias is used in a type annotation context in "
+            "Python 3.7 or 3.8.",
+        ),
+        "R6003": (
+            "Consider using alternative Union syntax instead of '%s'%s",
+            "consider-alternative-union-syntax",
+            "Emitted when 'typing.Union' or 'typing.Optional' is used "
+            "instead of the alternative Union syntax 'int | None'.",
+        ),
+        "E6004": (
+            "'NoReturn' inside compound types is broken in 3.7.0 / 3.7.1",
+            "broken-noreturn",
+            "``typing.NoReturn`` inside compound types is broken in "
+            "Python 3.7.0 and 3.7.1. If not dependent on runtime introspection, "
+            "use string annotation instead. E.g. "
+            "``Callable[..., 'NoReturn']``. https://bugs.python.org/issue34921",
+        ),
+        "E6005": (
+            "'collections.abc.Callable' inside Optional and Union is broken in "
+            "3.9.0 / 3.9.1 (use 'typing.Callable' instead)",
+            "broken-collections-callable",
+            "``collections.abc.Callable`` inside Optional and Union is broken in "
+            "Python 3.9.0 and 3.9.1. Use ``typing.Callable`` for these cases instead. "
+            "https://bugs.python.org/issue42965",
+        ),
+    }
+    options = (
+        (
+            "runtime-typing",
+            {
+                "default": True,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": (
+                    "Set to ``no`` if the app / library does **NOT** need to "
+                    "support runtime introspection of type annotations. "
+                    "If you use type annotations **exclusively** for type checking "
+                    "of an application, you're probably fine. For libraries, "
+                    "evaluate if some users what to access the type hints "
+                    "at runtime first, e.g., through ``typing.get_type_hints``. "
+                    "Applies to Python versions 3.7 - 3.9"
+                ),
+            },
+        ),
+    )
+
+    _should_check_typing_alias: bool
+    """The use of type aliases (PEP 585) requires Python 3.9
+    or Python 3.7+ with postponed evaluation.
+    """
+
+    _should_check_alternative_union_syntax: bool
+    """The use of alternative union syntax (PEP 604) requires Python 3.10
+    or Python 3.7+ with postponed evaluation.
+    """
+
+    def __init__(self, linter: "PyLinter") -> None:
+        """Initialize checker instance."""
+        super().__init__(linter=linter)
+        self._found_broken_callable_location: bool = False
+        self._alias_name_collisions: Set[str] = set()
+        self._deprecated_typing_alias_msgs: List[DeprecatedTypingAliasMsg] = []
+        self._consider_using_alias_msgs: List[DeprecatedTypingAliasMsg] = []
+
+    def open(self) -> None:
+        py_version = get_global_option(self, "py-version")
+        self._py37_plus = py_version >= (3, 7)
+        self._py39_plus = py_version >= (3, 9)
+        self._py310_plus = py_version >= (3, 10)
+
+        self._should_check_typing_alias = self._py39_plus or (
+            self._py37_plus and self.config.runtime_typing is False
+        )
+        self._should_check_alternative_union_syntax = self._py310_plus or (
+            self._py37_plus and self.config.runtime_typing is False
+        )
+
+        self._should_check_noreturn = py_version < (3, 7, 2)
+        self._should_check_callable = py_version < (3, 9, 2)
+
+    def _msg_postponed_eval_hint(self, node: nodes.NodeNG) -> str:
+        """Message hint if postponed evaluation isn't enabled."""
+        if self._py310_plus or "annotations" in node.root().future_imports:
+            return ""
+        return ". Add 'from __future__ import annotations' as well"
+
+    @check_messages(
+        "deprecated-typing-alias",
+        "consider-using-alias",
+        "consider-alternative-union-syntax",
+        "broken-noreturn",
+        "broken-collections-callable",
+    )
+    def visit_name(self, node: nodes.Name) -> None:
+        if self._should_check_typing_alias and node.name in ALIAS_NAMES:
+            self._check_for_typing_alias(node)
+        if self._should_check_alternative_union_syntax and node.name in UNION_NAMES:
+            self._check_for_alternative_union_syntax(node, node.name)
+        if self._should_check_noreturn and node.name == "NoReturn":
+            self._check_broken_noreturn(node)
+        if self._should_check_callable and node.name == "Callable":
+            self._check_broken_callable(node)
+
+    @check_messages(
+        "deprecated-typing-alias",
+        "consider-using-alias",
+        "consider-alternative-union-syntax",
+        "broken-noreturn",
+        "broken-collections-callable",
+    )
+    def visit_attribute(self, node: nodes.Attribute) -> None:
+        if self._should_check_typing_alias and node.attrname in ALIAS_NAMES:
+            self._check_for_typing_alias(node)
+        if self._should_check_alternative_union_syntax and node.attrname in UNION_NAMES:
+            self._check_for_alternative_union_syntax(node, node.attrname)
+        if self._should_check_noreturn and node.attrname == "NoReturn":
+            self._check_broken_noreturn(node)
+        if self._should_check_callable and node.attrname == "Callable":
+            self._check_broken_callable(node)
+
+    def _check_for_alternative_union_syntax(
+        self,
+        node: Union[nodes.Name, nodes.Attribute],
+        name: str,
+    ) -> None:
+        """Check if alternative union syntax could be used.
+
+        Requires
+        - Python 3.10
+        - OR: Python 3.7+ with postponed evaluation in
+              a type annotation context
+        """
+        inferred = safe_infer(node)
+        if not (
+            isinstance(inferred, nodes.FunctionDef)
+            and inferred.qname() in {"typing.Optional", "typing.Union"}
+            or isinstance(inferred, astroid.bases.Instance)
+            and inferred.qname() == "typing._SpecialForm"
+        ):
+            return
+        if not (self._py310_plus or is_node_in_type_annotation_context(node)):
+            return
+        self.add_message(
+            "consider-alternative-union-syntax",
+            node=node,
+            args=(name, self._msg_postponed_eval_hint(node)),
+            confidence=INFERENCE,
+        )
+
+    def _check_for_typing_alias(
+        self,
+        node: Union[nodes.Name, nodes.Attribute],
+    ) -> None:
+        """Check if typing alias is deprecated or could be replaced.
+
+        Requires
+        - Python 3.9
+        - OR: Python 3.7+ with postponed evaluation in
+              a type annotation context
+
+        For Python 3.7+: Only emit message if change doesn't create
+            any name collisions, only ever used in a type annotation
+            context, and can safely be replaced.
+        """
+        inferred = safe_infer(node)
+        if not isinstance(inferred, nodes.ClassDef):
+            return
+        alias = DEPRECATED_TYPING_ALIASES.get(inferred.qname(), None)
+        if alias is None:
+            return
+
+        if self._py39_plus:
+            if inferred.qname() == "typing.Callable" and self._broken_callable_location(
+                node
+            ):
+                self._found_broken_callable_location = True
+            self._deprecated_typing_alias_msgs.append(
+                DeprecatedTypingAliasMsg(
+                    node,
+                    inferred.qname(),
+                    alias.name,
+                )
+            )
+            return
+
+        # For PY37+, check for type annotation context first
+        if not is_node_in_type_annotation_context(node) and isinstance(
+            node.parent, nodes.Subscript
+        ):
+            if alias.name_collision is True:
+                self._alias_name_collisions.add(inferred.qname())
+            return
+        self._consider_using_alias_msgs.append(
+            DeprecatedTypingAliasMsg(
+                node,
+                inferred.qname(),
+                alias.name,
+                isinstance(node.parent, nodes.Subscript),
+            )
+        )
+
+    @check_messages("consider-using-alias")
+    def leave_module(self, node: nodes.Module) -> None:
+        """After parsing of module is complete, add messages for
+        'consider-using-alias' check.
+
+        Make sure results are safe to recommend / collision free.
+        """
+        if self._py39_plus:
+            for msg in self._deprecated_typing_alias_msgs:
+                if (
+                    self._found_broken_callable_location
+                    and msg.qname == "typing.Callable"
+                ):
+                    continue
+                self.add_message(
+                    "deprecated-typing-alias",
+                    node=msg.node,
+                    args=(msg.qname, msg.alias),
+                    confidence=INFERENCE,
+                )
+
+        elif self._py37_plus:
+            msg_future_import = self._msg_postponed_eval_hint(node)
+            for msg in self._consider_using_alias_msgs:
+                if msg.qname in self._alias_name_collisions:
+                    continue
+                self.add_message(
+                    "consider-using-alias",
+                    node=msg.node,
+                    args=(
+                        msg.qname,
+                        msg.alias,
+                        msg_future_import if msg.parent_subscript else "",
+                    ),
+                    confidence=INFERENCE,
+                )
+
+        # Clear all module cache variables
+        self._found_broken_callable_location = False
+        self._deprecated_typing_alias_msgs.clear()
+        self._alias_name_collisions.clear()
+        self._consider_using_alias_msgs.clear()
+
+    def _check_broken_noreturn(self, node: Union[nodes.Name, nodes.Attribute]) -> None:
+        """Check for 'NoReturn' inside compound types."""
+        if not isinstance(node.parent, nodes.BaseContainer):
+            # NoReturn not part of a Union or Callable type
+            return
+
+        if (
+            in_type_checking_block(node)
+            or is_postponed_evaluation_enabled(node)
+            and is_node_in_type_annotation_context(node)
+        ):
+            return
+
+        for inferred in node.infer():
+            # To deal with typing_extensions, don't use safe_infer
+            if (
+                isinstance(inferred, (nodes.FunctionDef, nodes.ClassDef))
+                and inferred.qname() in TYPING_NORETURN
+                # In Python 3.6, NoReturn is alias of '_NoReturn'
+                # In Python 3.7 - 3.8, NoReturn is alias of '_SpecialForm'
+                or isinstance(inferred, astroid.bases.BaseInstance)
+                and isinstance(inferred._proxied, nodes.ClassDef)
+                and inferred._proxied.qname()
+                in {"typing._NoReturn", "typing._SpecialForm"}
+            ):
+                self.add_message("broken-noreturn", node=node, confidence=INFERENCE)
+                break
+
+    def _check_broken_callable(self, node: Union[nodes.Name, nodes.Attribute]) -> None:
+        """Check for 'collections.abc.Callable' inside Optional and Union."""
+        inferred = safe_infer(node)
+        if not (
+            isinstance(inferred, nodes.ClassDef)
+            and inferred.qname() == "_collections_abc.Callable"
+            and self._broken_callable_location(node)
+        ):
+            return
+
+        self.add_message("broken-collections-callable", node=node, confidence=INFERENCE)
+
+    def _broken_callable_location(  # pylint: disable=no-self-use
+        self, node: Union[nodes.Name, nodes.Attribute]
+    ) -> bool:
+        """Check if node would be a broken location for collections.abc.Callable."""
+        if (
+            in_type_checking_block(node)
+            or is_postponed_evaluation_enabled(node)
+            and is_node_in_type_annotation_context(node)
+        ):
+            return False
+
+        # Check first Callable arg is a list of arguments -> Callable[[int], None]
+        if not (
+            isinstance(node.parent, nodes.Subscript)
+            and isinstance(node.parent.slice, nodes.Tuple)
+            and len(node.parent.slice.elts) == 2
+            and isinstance(node.parent.slice.elts[0], nodes.List)
+        ):
+            return False
+
+        # Check nested inside Optional or Union
+        parent_subscript = node.parent.parent
+        if isinstance(parent_subscript, nodes.BaseContainer):
+            parent_subscript = parent_subscript.parent
+        if not (
+            isinstance(parent_subscript, nodes.Subscript)
+            and isinstance(parent_subscript.value, (nodes.Name, nodes.Attribute))
+        ):
+            return False
+
+        inferred_parent = safe_infer(parent_subscript.value)
+        if not (
+            isinstance(inferred_parent, nodes.FunctionDef)
+            and inferred_parent.qname() in {"typing.Optional", "typing.Union"}
+            or isinstance(inferred_parent, astroid.bases.Instance)
+            and inferred_parent.qname() == "typing._SpecialForm"
+        ):
+            return False
+
+        return True
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(TypingChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/extensions/while_used.py b/myenv/lib/python3.9/site-packages/pylint/extensions/while_used.py
new file mode 100644
index 0000000..4c41510
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/extensions/while_used.py
@@ -0,0 +1,36 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Check for use of while loops."""
+from typing import TYPE_CHECKING
+
+from astroid import nodes
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import IAstroidChecker
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+
+class WhileChecker(BaseChecker):
+
+    __implements__ = (IAstroidChecker,)
+    name = "while_used"
+    msgs = {
+        "W0149": (
+            "Used `while` loop",
+            "while-used",
+            "Unbounded `while` loops can often be rewritten as bounded `for` loops.",
+        )
+    }
+
+    @check_messages("while-used")
+    def visit_while(self, node: nodes.While) -> None:
+        self.add_message("while-used", node=node)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_checker(WhileChecker(linter))
diff --git a/myenv/lib/python3.9/site-packages/pylint/graph.py b/myenv/lib/python3.9/site-packages/pylint/graph.py
new file mode 100644
index 0000000..8191847
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/graph.py
@@ -0,0 +1,201 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Graph manipulation utilities.
+
+(dot generation adapted from pypy/translator/tool/make_dot.py)
+"""
+import codecs
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from typing import Optional
+
+
+def target_info_from_filename(filename):
+    """Transforms /some/path/foo.png into ('/some/path', 'foo.png', 'png')."""
+    basename = os.path.basename(filename)
+    storedir = os.path.dirname(os.path.abspath(filename))
+    target = os.path.splitext(filename)[-1][1:]
+    return storedir, basename, target
+
+
+class DotBackend:
+    """Dot File backend."""
+
+    def __init__(
+        self,
+        graphname,
+        rankdir=None,
+        size=None,
+        ratio=None,
+        charset="utf-8",
+        renderer="dot",
+        additional_param=None,
+    ):
+        if additional_param is None:
+            additional_param = {}
+        self.graphname = graphname
+        self.renderer = renderer
+        self.lines = []
+        self._source = None
+        self.emit(f"digraph {normalize_node_id(graphname)} {{")
+        if rankdir:
+            self.emit(f"rankdir={rankdir}")
+        if ratio:
+            self.emit(f"ratio={ratio}")
+        if size:
+            self.emit(f'size="{size}"')
+        if charset:
+            assert charset.lower() in {
+                "utf-8",
+                "iso-8859-1",
+                "latin1",
+            }, f"unsupported charset {charset}"
+            self.emit(f'charset="{charset}"')
+        for param in additional_param.items():
+            self.emit("=".join(param))
+
+    def get_source(self):
+        """Returns self._source."""
+        if self._source is None:
+            self.emit("}\n")
+            self._source = "\n".join(self.lines)
+            del self.lines
+        return self._source
+
+    source = property(get_source)
+
+    def generate(
+        self, outputfile: Optional[str] = None, mapfile: Optional[str] = None
+    ) -> str:
+        """Generates a graph file.
+
+        :param str outputfile: filename and path [defaults to graphname.png]
+        :param str mapfile: filename and path
+
+        :rtype: str
+        :return: a path to the generated file
+        :raises RuntimeError: if the executable for rendering was not found
+        """
+        graphviz_extensions = ("dot", "gv")
+        name = self.graphname
+        if outputfile is None:
+            target = "png"
+            pdot, dot_sourcepath = tempfile.mkstemp(".gv", name)
+            ppng, outputfile = tempfile.mkstemp(".png", name)
+            os.close(pdot)
+            os.close(ppng)
+        else:
+            _, _, target = target_info_from_filename(outputfile)
+            if not target:
+                target = "png"
+                outputfile = outputfile + "." + target
+            if target not in graphviz_extensions:
+                pdot, dot_sourcepath = tempfile.mkstemp(".gv", name)
+                os.close(pdot)
+            else:
+                dot_sourcepath = outputfile
+        with codecs.open(dot_sourcepath, "w", encoding="utf8") as file:
+            file.write(self.source)
+        if target not in graphviz_extensions:
+            if shutil.which(self.renderer) is None:
+                raise RuntimeError(
+                    f"Cannot generate `{outputfile}` because '{self.renderer}' "
+                    "executable not found. Install graphviz, or specify a `.gv` "
+                    "outputfile to produce the DOT source code."
+                )
+            use_shell = sys.platform == "win32"
+            if mapfile:
+                subprocess.call(
+                    [
+                        self.renderer,
+                        "-Tcmapx",
+                        "-o",
+                        mapfile,
+                        "-T",
+                        target,
+                        dot_sourcepath,
+                        "-o",
+                        outputfile,
+                    ],
+                    shell=use_shell,
+                )
+            else:
+                subprocess.call(
+                    [self.renderer, "-T", target, dot_sourcepath, "-o", outputfile],
+                    shell=use_shell,
+                )
+            os.unlink(dot_sourcepath)
+        return outputfile
+
+    def emit(self, line):
+        """Adds <line> to final output."""
+        self.lines.append(line)
+
+    def emit_edge(self, name1, name2, **props):
+        """Emit an edge from <name1> to <name2>.
+
+        For edge properties: see https://www.graphviz.org/doc/info/attrs.html
+        """
+        attrs = [f'{prop}="{value}"' for prop, value in props.items()]
+        n_from, n_to = normalize_node_id(name1), normalize_node_id(name2)
+        self.emit(f"{n_from} -> {n_to} [{', '.join(sorted(attrs))}];")
+
+    def emit_node(self, name, **props):
+        """Emit a node with given properties.
+
+        For node properties: see https://www.graphviz.org/doc/info/attrs.html
+        """
+        attrs = [f'{prop}="{value}"' for prop, value in props.items()]
+        self.emit(f"{normalize_node_id(name)} [{', '.join(sorted(attrs))}];")
+
+
+def normalize_node_id(nid):
+    """Returns a suitable DOT node id for `nid`."""
+    return f'"{nid}"'
+
+
+def get_cycles(graph_dict, vertices=None):
+    """Return a list of detected cycles in a dictionary representing an ordered graph
+    (i.e. key are vertices and values is a list of destination vertices representing edges)
+    """
+    if not graph_dict:
+        return ()
+    result = []
+    if vertices is None:
+        vertices = graph_dict.keys()
+    for vertice in vertices:
+        _get_cycles(graph_dict, [], set(), result, vertice)
+    return result
+
+
+def _get_cycles(graph_dict, path, visited, result, vertice):
+    """Recursive function doing the real work for get_cycles."""
+    if vertice in path:
+        cycle = [vertice]
+        for node in path[::-1]:
+            if node == vertice:
+                break
+            cycle.insert(0, node)
+        # make a canonical representation
+        start_from = min(cycle)
+        index = cycle.index(start_from)
+        cycle = cycle[index:] + cycle[0:index]
+        # append it to result if not already in
+        if cycle not in result:
+            result.append(cycle)
+        return
+    path.append(vertice)
+    try:
+        for node in graph_dict[vertice]:
+            # don't check already visited nodes again
+            if node not in visited:
+                _get_cycles(graph_dict, path, visited, result, node)
+                visited.add(node)
+    except KeyError:
+        pass
+    path.pop()
diff --git a/myenv/lib/python3.9/site-packages/pylint/interfaces.py b/myenv/lib/python3.9/site-packages/pylint/interfaces.py
new file mode 100644
index 0000000..7f6edbd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/interfaces.py
@@ -0,0 +1,106 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Interfaces for Pylint objects."""
+from collections import namedtuple
+from typing import TYPE_CHECKING, Tuple, Type, Union
+
+from astroid import nodes
+
+if TYPE_CHECKING:
+    from pylint.checkers import BaseChecker
+    from pylint.reporters.ureports.nodes import Section
+
+__all__ = (
+    "IRawChecker",
+    "IAstroidChecker",
+    "ITokenChecker",
+    "IReporter",
+    "IChecker",
+    "HIGH",
+    "CONTROL_FLOW",
+    "INFERENCE",
+    "INFERENCE_FAILURE",
+    "UNDEFINED",
+    "CONFIDENCE_LEVELS",
+)
+
+Confidence = namedtuple("Confidence", ["name", "description"])
+# Warning Certainties
+HIGH = Confidence("HIGH", "Warning that is not based on inference result.")
+CONTROL_FLOW = Confidence(
+    "CONTROL_FLOW", "Warning based on assumptions about control flow."
+)
+INFERENCE = Confidence("INFERENCE", "Warning based on inference result.")
+INFERENCE_FAILURE = Confidence(
+    "INFERENCE_FAILURE", "Warning based on inference with failures."
+)
+UNDEFINED = Confidence("UNDEFINED", "Warning without any associated confidence level.")
+
+CONFIDENCE_LEVELS = [HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE, UNDEFINED]
+
+
+class Interface:
+    """Base class for interfaces."""
+
+    @classmethod
+    def is_implemented_by(cls, instance):
+        return implements(instance, cls)
+
+
+def implements(
+    obj: "BaseChecker",
+    interface: Union[Type["Interface"], Tuple[Type["Interface"], ...]],
+) -> bool:
+    """Does the given object (maybe an instance or class) implement the interface."""
+    implements_ = getattr(obj, "__implements__", ())
+    if not isinstance(implements_, (list, tuple)):
+        implements_ = (implements_,)
+    return any(issubclass(i, interface) for i in implements_)
+
+
+class IChecker(Interface):
+    """Base interface, to be used only for sub interfaces definition."""
+
+    def open(self):
+        """Called before visiting project (i.e. set of modules)."""
+
+    def close(self):
+        """Called after visiting project (i.e. set of modules)."""
+
+
+class IRawChecker(IChecker):
+    """Interface for checker which need to parse the raw file."""
+
+    def process_module(self, node: nodes.Module) -> None:
+        """Process a module.
+
+        The module's content is accessible via ``astroid.stream``
+        """
+
+
+class ITokenChecker(IChecker):
+    """Interface for checkers that need access to the token list."""
+
+    def process_tokens(self, tokens):
+        """Process a module.
+
+        Tokens is a list of all source code tokens in the file.
+        """
+
+
+class IAstroidChecker(IChecker):
+    """Interface for checker which prefers receive events according to
+    statement type
+    """
+
+
+class IReporter(Interface):
+    """Reporter collect messages and display results encapsulated in a layout."""
+
+    def handle_message(self, msg) -> None:
+        """Handle the given message object."""
+
+    def display_reports(self, layout: "Section") -> None:
+        """Display results encapsulated in the layout tree."""
diff --git a/myenv/lib/python3.9/site-packages/pylint/lint/__init__.py b/myenv/lib/python3.9/site-packages/pylint/lint/__init__.py
new file mode 100644
index 0000000..7cfa7f5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/lint/__init__.py
@@ -0,0 +1,48 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Pylint [options] modules_or_packages.
+
+  Check that module(s) satisfy a coding standard (and more !).
+
+    pylint --help
+
+  Display this help message and exit.
+
+    pylint --help-msg <msg-id>[,<msg-id>]
+
+  Display help messages about given message identifiers and exit.
+"""
+import sys
+
+from pylint.lint.parallel import check_parallel
+from pylint.lint.pylinter import PyLinter
+from pylint.lint.report_functions import (
+    report_messages_by_module_stats,
+    report_messages_stats,
+    report_total_messages_stats,
+)
+from pylint.lint.run import Run
+from pylint.lint.utils import (
+    ArgumentPreprocessingError,
+    _patch_sys_path,
+    fix_import_path,
+    preprocess_options,
+)
+
+__all__ = [
+    "check_parallel",
+    "PyLinter",
+    "report_messages_by_module_stats",
+    "report_messages_stats",
+    "report_total_messages_stats",
+    "Run",
+    "ArgumentPreprocessingError",
+    "_patch_sys_path",
+    "fix_import_path",
+    "preprocess_options",
+]
+
+if __name__ == "__main__":
+    Run(sys.argv[1:])
diff --git a/myenv/lib/python3.9/site-packages/pylint/lint/expand_modules.py b/myenv/lib/python3.9/site-packages/pylint/lint/expand_modules.py
new file mode 100644
index 0000000..302eea9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/lint/expand_modules.py
@@ -0,0 +1,158 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import os
+import sys
+from typing import List, Pattern, Tuple
+
+from astroid import modutils
+
+from pylint.typing import ErrorDescriptionDict, ModuleDescriptionDict
+
+
+def _modpath_from_file(filename, is_namespace, path=None):
+    def _is_package_cb(inner_path, parts):
+        return modutils.check_modpath_has_init(inner_path, parts) or is_namespace
+
+    return modutils.modpath_from_file_with_callback(
+        filename, path=path, is_package_cb=_is_package_cb
+    )
+
+
+def get_python_path(filepath: str) -> str:
+    """TODO This get the python path with the (bad) assumption that there is always
+    an __init__.py
+
+    This is not true since python 3.3 and is causing problem.
+    """
+    dirname = os.path.realpath(os.path.expanduser(filepath))
+    if not os.path.isdir(dirname):
+        dirname = os.path.dirname(dirname)
+    while True:
+        if not os.path.exists(os.path.join(dirname, "__init__.py")):
+            return dirname
+        old_dirname = dirname
+        dirname = os.path.dirname(dirname)
+        if old_dirname == dirname:
+            return os.getcwd()
+
+
+def _is_in_ignore_list_re(element: str, ignore_list_re: List[Pattern]) -> bool:
+    """Determines if the element is matched in a regex ignore-list."""
+    return any(file_pattern.match(element) for file_pattern in ignore_list_re)
+
+
+def _is_ignored_file(
+    element: str,
+    ignore_list,
+    ignore_list_re,
+    ignore_list_paths_re,
+) -> bool:
+    basename = os.path.basename(element)
+    return (
+        basename in ignore_list
+        or _is_in_ignore_list_re(basename, ignore_list_re)
+        or _is_in_ignore_list_re(element, ignore_list_paths_re)
+    )
+
+
+def expand_modules(
+    files_or_modules: List[str],
+    ignore_list: List[str],
+    ignore_list_re: List[Pattern],
+    ignore_list_paths_re: List[Pattern[str]],
+) -> Tuple[List[ModuleDescriptionDict], List[ErrorDescriptionDict]]:
+    """Take a list of files/modules/packages and return the list of tuple
+    (file, module name) which have to be actually checked
+    """
+    result: List[ModuleDescriptionDict] = []
+    errors: List[ErrorDescriptionDict] = []
+    path = sys.path.copy()
+
+    for something in files_or_modules:
+        basename = os.path.basename(something)
+        if _is_ignored_file(
+            something, ignore_list, ignore_list_re, ignore_list_paths_re
+        ):
+            continue
+        module_path = get_python_path(something)
+        additional_search_path = [".", module_path] + path
+        if os.path.exists(something):
+            # this is a file or a directory
+            try:
+                modname = ".".join(
+                    modutils.modpath_from_file(something, path=additional_search_path)
+                )
+            except ImportError:
+                modname = os.path.splitext(basename)[0]
+            if os.path.isdir(something):
+                filepath = os.path.join(something, "__init__.py")
+            else:
+                filepath = something
+        else:
+            # suppose it's a module or package
+            modname = something
+            try:
+                filepath = modutils.file_from_modpath(
+                    modname.split("."), path=additional_search_path
+                )
+                if filepath is None:
+                    continue
+            except (ImportError, SyntaxError) as ex:
+                # The SyntaxError is a Python bug and should be
+                # removed once we move away from imp.find_module: https://bugs.python.org/issue10588
+                errors.append({"key": "fatal", "mod": modname, "ex": ex})
+                continue
+        filepath = os.path.normpath(filepath)
+        modparts = (modname or something).split(".")
+        try:
+            spec = modutils.file_info_from_modpath(
+                modparts, path=additional_search_path
+            )
+        except ImportError:
+            # Might not be acceptable, don't crash.
+            is_namespace = False
+            is_directory = os.path.isdir(something)
+        else:
+            is_namespace = modutils.is_namespace(spec)
+            is_directory = modutils.is_directory(spec)
+        if not is_namespace:
+            result.append(
+                {
+                    "path": filepath,
+                    "name": modname,
+                    "isarg": True,
+                    "basepath": filepath,
+                    "basename": modname,
+                }
+            )
+        has_init = (
+            not (modname.endswith(".__init__") or modname == "__init__")
+            and os.path.basename(filepath) == "__init__.py"
+        )
+        if has_init or is_namespace or is_directory:
+            for subfilepath in modutils.get_module_files(
+                os.path.dirname(filepath), ignore_list, list_all=is_namespace
+            ):
+                if filepath == subfilepath:
+                    continue
+                if _is_in_ignore_list_re(
+                    os.path.basename(subfilepath), ignore_list_re
+                ) or _is_in_ignore_list_re(subfilepath, ignore_list_paths_re):
+                    continue
+
+                modpath = _modpath_from_file(
+                    subfilepath, is_namespace, path=additional_search_path
+                )
+                submodname = ".".join(modpath)
+                result.append(
+                    {
+                        "path": subfilepath,
+                        "name": submodname,
+                        "isarg": False,
+                        "basepath": filepath,
+                        "basename": modname,
+                    }
+                )
+    return result, errors
diff --git a/myenv/lib/python3.9/site-packages/pylint/lint/parallel.py b/myenv/lib/python3.9/site-packages/pylint/lint/parallel.py
new file mode 100644
index 0000000..ea5d7ab
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/lint/parallel.py
@@ -0,0 +1,184 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import collections
+import functools
+import warnings
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    DefaultDict,
+    Iterable,
+    List,
+    Sequence,
+    Tuple,
+    Union,
+)
+
+import dill
+
+from pylint import reporters
+from pylint.lint.utils import _patch_sys_path
+from pylint.message import Message
+from pylint.typing import FileItem, MessageLocationTuple
+from pylint.utils import LinterStats, merge_stats
+
+try:
+    import multiprocessing
+except ImportError:
+    multiprocessing = None  # type: ignore[assignment]
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+
+# PyLinter object used by worker processes when checking files using multiprocessing
+# should only be used by the worker processes
+_worker_linter = None
+
+
+def _get_new_args(message):
+    location = (
+        message.abspath,
+        message.path,
+        message.module,
+        message.obj,
+        message.line,
+        message.column,
+    )
+    return (message.msg_id, message.symbol, location, message.msg, message.confidence)
+
+
+def _worker_initialize(
+    linter: bytes, arguments: Union[None, str, Sequence[str]] = None
+) -> None:
+    """Function called to initialize a worker for a Process within a multiprocessing Pool.
+
+    :param linter: A linter-class (PyLinter) instance pickled with dill
+    :param arguments: File or module name(s) to lint and to be added to sys.path
+    """
+    global _worker_linter  # pylint: disable=global-statement
+    _worker_linter = dill.loads(linter)
+
+    # On the worker process side the messages are just collected and passed back to
+    # parent process as _worker_check_file function's return value
+    _worker_linter.set_reporter(reporters.CollectingReporter())
+    _worker_linter.open()
+
+    # Patch sys.path so that each argument is importable just like in single job mode
+    _patch_sys_path(arguments or ())
+
+
+def _worker_check_single_file(
+    file_item: FileItem,
+) -> Tuple[
+    int, Any, str, Any, List[Tuple[Any, ...]], LinterStats, Any, DefaultDict[Any, List]
+]:
+    if not _worker_linter:
+        raise Exception("Worker linter not yet initialised")
+    _worker_linter.open()
+    _worker_linter.check_single_file_item(file_item)
+    mapreduce_data = collections.defaultdict(list)
+    for checker in _worker_linter.get_checkers():
+        try:
+            data = checker.get_map_data()
+        except AttributeError:
+            continue
+        mapreduce_data[checker.name].append(data)
+    msgs = [_get_new_args(m) for m in _worker_linter.reporter.messages]
+    _worker_linter.reporter.reset()
+    if _worker_linter.current_name is None:
+        warnings.warn(
+            (
+                "In pylint 3.0 the current_name attribute of the linter object should be a string. "
+                "If unknown it should be initialized as an empty string."
+            ),
+            DeprecationWarning,
+        )
+    return (
+        id(multiprocessing.current_process()),
+        _worker_linter.current_name,
+        file_item.filepath,
+        _worker_linter.file_state.base_name,
+        msgs,
+        _worker_linter.stats,
+        _worker_linter.msg_status,
+        mapreduce_data,
+    )
+
+
+def _merge_mapreduce_data(linter, all_mapreduce_data):
+    """Merges map/reduce data across workers, invoking relevant APIs on checkers."""
+    # First collate the data and prepare it, so we can send it to the checkers for
+    # validation. The intent here is to collect all the mapreduce data for all checker-
+    # runs across processes - that will then be passed to a static method on the
+    # checkers to be reduced and further processed.
+    collated_map_reduce_data = collections.defaultdict(list)
+    for linter_data in all_mapreduce_data.values():
+        for run_data in linter_data:
+            for checker_name, data in run_data.items():
+                collated_map_reduce_data[checker_name].extend(data)
+
+    # Send the data to checkers that support/require consolidated data
+    original_checkers = linter.get_checkers()
+    for checker in original_checkers:
+        if checker.name in collated_map_reduce_data:
+            # Assume that if the check has returned map/reduce data that it has the
+            # reducer function
+            checker.reduce_map_data(linter, collated_map_reduce_data[checker.name])
+
+
+def check_parallel(
+    linter: "PyLinter",
+    jobs: int,
+    files: Iterable[FileItem],
+    arguments: Union[None, str, Sequence[str]] = None,
+) -> None:
+    """Use the given linter to lint the files with given amount of workers (jobs).
+
+    This splits the work filestream-by-filestream. If you need to do work across
+    multiple files, as in the similarity-checker, then inherit from MapReduceMixin and
+    implement the map/reduce mixin functionality.
+    """
+    # The linter is inherited by all the pool's workers, i.e. the linter
+    # is identical to the linter object here. This is required so that
+    # a custom PyLinter object can be used.
+    initializer = functools.partial(_worker_initialize, arguments=arguments)
+    with multiprocessing.Pool(
+        jobs, initializer=initializer, initargs=[dill.dumps(linter)]
+    ) as pool:
+        linter.open()
+        all_stats = []
+        all_mapreduce_data = collections.defaultdict(list)
+
+        # Maps each file to be worked on by a single _worker_check_single_file() call,
+        # collecting any map/reduce data by checker module so that we can 'reduce' it
+        # later.
+        for (
+            worker_idx,  # used to merge map/reduce data across workers
+            module,
+            file_path,
+            base_name,
+            messages,
+            stats,
+            msg_status,
+            mapreduce_data,
+        ) in pool.imap_unordered(_worker_check_single_file, files):
+            linter.file_state.base_name = base_name
+            linter.set_current_module(module, file_path)
+            for msg in messages:
+                msg = Message(
+                    msg[0], msg[1], MessageLocationTuple(*msg[2]), msg[3], msg[4]
+                )
+                linter.reporter.handle_message(msg)
+            all_stats.append(stats)
+            all_mapreduce_data[worker_idx].append(mapreduce_data)
+            linter.msg_status |= msg_status
+
+    _merge_mapreduce_data(linter, all_mapreduce_data)
+    linter.stats = merge_stats([linter.stats] + all_stats)
+
+    # Insert stats data to local checkers.
+    for checker in linter.get_checkers():
+        if checker is not linter:
+            checker.stats = linter.stats
diff --git a/myenv/lib/python3.9/site-packages/pylint/lint/pylinter.py b/myenv/lib/python3.9/site-packages/pylint/lint/pylinter.py
new file mode 100644
index 0000000..a021893
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/lint/pylinter.py
@@ -0,0 +1,1842 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import collections
+import contextlib
+import functools
+import operator
+import os
+import sys
+import tokenize
+import traceback
+import warnings
+from io import TextIOWrapper
+from typing import (
+    Any,
+    DefaultDict,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
+
+import astroid
+from astroid import AstroidError, nodes
+
+from pylint import checkers, config, exceptions, interfaces, reporters
+from pylint.constants import (
+    MAIN_CHECKER_NAME,
+    MSG_STATE_CONFIDENCE,
+    MSG_STATE_SCOPE_CONFIG,
+    MSG_STATE_SCOPE_MODULE,
+    MSG_TYPES,
+    MSG_TYPES_LONG,
+    MSG_TYPES_STATUS,
+)
+from pylint.lint.expand_modules import _is_ignored_file, expand_modules
+from pylint.lint.parallel import check_parallel
+from pylint.lint.report_functions import (
+    report_messages_by_module_stats,
+    report_messages_stats,
+    report_total_messages_stats,
+)
+from pylint.lint.utils import (
+    fix_import_path,
+    get_fatal_error_message,
+    prepare_crash_report,
+)
+from pylint.message import Message, MessageDefinition, MessageDefinitionStore
+from pylint.reporters.text import TextReporter
+from pylint.reporters.ureports import nodes as report_nodes
+from pylint.typing import (
+    FileItem,
+    ManagedMessage,
+    MessageLocationTuple,
+    ModuleDescriptionDict,
+)
+from pylint.utils import ASTWalker, FileState, LinterStats, get_global_option, utils
+from pylint.utils.pragma_parser import (
+    OPTION_PO,
+    InvalidPragmaError,
+    UnRecognizedOptionError,
+    parse_pragma,
+)
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+OptionDict = Dict[str, Union[str, bool, int, Iterable[Union[str, int]]]]
+
+MANAGER = astroid.MANAGER
+
+
+def _read_stdin():
+    # https://mail.python.org/pipermail/python-list/2012-November/634424.html
+    sys.stdin = TextIOWrapper(sys.stdin.detach(), encoding="utf-8")
+    return sys.stdin.read()
+
+
+def _load_reporter_by_class(reporter_class: str) -> type:
+    qname = reporter_class
+    module_part = astroid.modutils.get_module_part(qname)
+    module = astroid.modutils.load_module_from_name(module_part)
+    class_name = qname.split(".")[-1]
+    return getattr(module, class_name)
+
+
+# Python Linter class #########################################################
+
+MSGS = {
+    "F0001": (
+        "%s",
+        "fatal",
+        "Used when an error occurred preventing the analysis of a \
+              module (unable to find it for instance).",
+    ),
+    "F0002": (
+        "%s: %s",
+        "astroid-error",
+        "Used when an unexpected error occurred while building the "
+        "Astroid  representation. This is usually accompanied by a "
+        "traceback. Please report such errors !",
+    ),
+    "F0010": (
+        "error while code parsing: %s",
+        "parse-error",
+        "Used when an exception occurred while building the Astroid "
+        "representation which could be handled by astroid.",
+    ),
+    "F0011": (
+        "error while parsing the configuration: %s",
+        "config-parse-error",
+        "Used when an exception occurred while parsing a pylint configuration file.",
+    ),
+    "I0001": (
+        "Unable to run raw checkers on built-in module %s",
+        "raw-checker-failed",
+        "Used to inform that a built-in module has not been checked "
+        "using the raw checkers.",
+    ),
+    "I0010": (
+        "Unable to consider inline option %r",
+        "bad-inline-option",
+        "Used when an inline option is either badly formatted or can't "
+        "be used inside modules.",
+    ),
+    "I0011": (
+        "Locally disabling %s (%s)",
+        "locally-disabled",
+        "Used when an inline option disables a message or a messages category.",
+    ),
+    "I0013": (
+        "Ignoring entire file",
+        "file-ignored",
+        "Used to inform that the file will not be checked",
+    ),
+    "I0020": (
+        "Suppressed %s (from line %d)",
+        "suppressed-message",
+        "A message was triggered on a line, but suppressed explicitly "
+        "by a disable= comment in the file. This message is not "
+        "generated for messages that are ignored due to configuration "
+        "settings.",
+    ),
+    "I0021": (
+        "Useless suppression of %s",
+        "useless-suppression",
+        "Reported when a message is explicitly disabled for a line or "
+        "a block of code, but never triggered.",
+    ),
+    "I0022": (
+        'Pragma "%s" is deprecated, use "%s" instead',
+        "deprecated-pragma",
+        "Some inline pylint options have been renamed or reworked, "
+        "only the most recent form should be used. "
+        "NOTE:skip-all is only available with pylint >= 0.26",
+        {"old_names": [("I0014", "deprecated-disable-all")]},
+    ),
+    "E0001": ("%s", "syntax-error", "Used when a syntax error is raised for a module."),
+    "E0011": (
+        "Unrecognized file option %r",
+        "unrecognized-inline-option",
+        "Used when an unknown inline option is encountered.",
+    ),
+    "E0012": (
+        "Bad option value %r",
+        "bad-option-value",
+        "Used when a bad value for an inline option is encountered.",
+    ),
+    "E0013": (
+        "Plugin '%s' is impossible to load, is it installed ? ('%s')",
+        "bad-plugin-value",
+        "Used when a bad value is used in 'load-plugins'.",
+    ),
+    "E0014": (
+        "Out-of-place setting encountered in top level configuration-section '%s' : '%s'",
+        "bad-configuration-section",
+        "Used when we detect a setting in the top level of a toml configuration that shouldn't be there.",
+    ),
+}
+
+
+# pylint: disable=too-many-instance-attributes,too-many-public-methods
+class PyLinter(
+    config.OptionsManagerMixIn,
+    reporters.ReportsHandlerMixIn,
+    checkers.BaseTokenChecker,
+):
+    """Lint Python modules using external checkers.
+
+    This is the main checker controlling the other ones and the reports
+    generation. It is itself both a raw checker and an astroid checker in order
+    to:
+    * handle message activation / deactivation at the module level
+    * handle some basic but necessary stats'data (number of classes, methods...)
+
+    IDE plugin developers: you may have to call
+    `astroid.builder.MANAGER.astroid_cache.clear()` across runs if you want
+    to ensure the latest code version is actually checked.
+
+    This class needs to support pickling for parallel linting to work. The exception
+    is reporter member; see check_parallel function for more details.
+    """
+
+    __implements__ = (interfaces.ITokenChecker,)
+
+    name = MAIN_CHECKER_NAME
+    priority = 0
+    level = 0
+    msgs = MSGS
+    # Will be used like this : datetime.now().strftime(crash_file_path)
+    crash_file_path: str = "pylint-crash-%Y-%m-%d-%H.txt"
+
+    @staticmethod
+    def make_options() -> Tuple[Tuple[str, OptionDict], ...]:
+        return (
+            (
+                "ignore",
+                {
+                    "type": "csv",
+                    "metavar": "<file>[,<file>...]",
+                    "dest": "black_list",
+                    "default": ("CVS",),
+                    "help": "Files or directories to be skipped. "
+                    "They should be base names, not paths.",
+                },
+            ),
+            (
+                "ignore-patterns",
+                {
+                    "type": "regexp_csv",
+                    "metavar": "<pattern>[,<pattern>...]",
+                    "dest": "black_list_re",
+                    "default": (r"^\.#",),
+                    "help": "Files or directories matching the regex patterns are"
+                    " skipped. The regex matches against base names, not paths. The default value "
+                    "ignores emacs file locks",
+                },
+            ),
+            (
+                "ignore-paths",
+                {
+                    "type": "regexp_paths_csv",
+                    "metavar": "<pattern>[,<pattern>...]",
+                    "default": [],
+                    "dest": "ignore_paths",
+                    "help": "Add files or directories matching the regex patterns to the "
+                    "ignore-list. The regex matches against paths and can be in "
+                    "Posix or Windows format.",
+                },
+            ),
+            (
+                "persistent",
+                {
+                    "default": True,
+                    "type": "yn",
+                    "metavar": "<y or n>",
+                    "level": 1,
+                    "help": "Pickle collected data for later comparisons.",
+                },
+            ),
+            (
+                "load-plugins",
+                {
+                    "type": "csv",
+                    "metavar": "<modules>",
+                    "default": (),
+                    "level": 1,
+                    "help": "List of plugins (as comma separated values of "
+                    "python module names) to load, usually to register "
+                    "additional checkers.",
+                },
+            ),
+            (
+                "output-format",
+                {
+                    "default": "text",
+                    "type": "string",
+                    "metavar": "<format>",
+                    "short": "f",
+                    "group": "Reports",
+                    "help": "Set the output format. Available formats are text,"
+                    " parseable, colorized, json and msvs (visual studio)."
+                    " You can also give a reporter class, e.g. mypackage.mymodule."
+                    "MyReporterClass.",
+                },
+            ),
+            (
+                "reports",
+                {
+                    "default": False,
+                    "type": "yn",
+                    "metavar": "<y or n>",
+                    "short": "r",
+                    "group": "Reports",
+                    "help": "Tells whether to display a full report or only the "
+                    "messages.",
+                },
+            ),
+            (
+                "evaluation",
+                {
+                    "type": "string",
+                    "metavar": "<python_expression>",
+                    "group": "Reports",
+                    "level": 1,
+                    "default": "max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + "
+                    "convention) / statement) * 10))",
+                    "help": "Python expression which should return a score less "
+                    "than or equal to 10. You have access to the variables 'fatal', "
+                    "'error', 'warning', 'refactor', 'convention', and 'info' which "
+                    "contain the number of messages in each category, as well as "
+                    "'statement' which is the total number of statements "
+                    "analyzed. This score is used by the global "
+                    "evaluation report (RP0004).",
+                },
+            ),
+            (
+                "score",
+                {
+                    "default": True,
+                    "type": "yn",
+                    "metavar": "<y or n>",
+                    "short": "s",
+                    "group": "Reports",
+                    "help": "Activate the evaluation score.",
+                },
+            ),
+            (
+                "fail-under",
+                {
+                    "default": 10,
+                    "type": "float",
+                    "metavar": "<score>",
+                    "help": "Specify a score threshold to be exceeded before program exits with error.",
+                },
+            ),
+            (
+                "fail-on",
+                {
+                    "default": "",
+                    "type": "csv",
+                    "metavar": "<msg ids>",
+                    "help": "Return non-zero exit code if any of these messages/categories are detected,"
+                    " even if score is above --fail-under value. Syntax same as enable."
+                    " Messages specified are enabled, while categories only check already-enabled messages.",
+                },
+            ),
+            (
+                "confidence",
+                {
+                    "type": "multiple_choice",
+                    "metavar": "<levels>",
+                    "default": "",
+                    "choices": [c.name for c in interfaces.CONFIDENCE_LEVELS],
+                    "group": "Messages control",
+                    "help": "Only show warnings with the listed confidence levels."
+                    f" Leave empty to show all. Valid levels: {', '.join(c.name for c in interfaces.CONFIDENCE_LEVELS)}.",
+                },
+            ),
+            (
+                "enable",
+                {
+                    "type": "csv",
+                    "metavar": "<msg ids>",
+                    "short": "e",
+                    "group": "Messages control",
+                    "help": "Enable the message, report, category or checker with the "
+                    "given id(s). You can either give multiple identifier "
+                    "separated by comma (,) or put this option multiple time "
+                    "(only on the command line, not in the configuration file "
+                    "where it should appear only once). "
+                    'See also the "--disable" option for examples.',
+                },
+            ),
+            (
+                "disable",
+                {
+                    "type": "csv",
+                    "metavar": "<msg ids>",
+                    "short": "d",
+                    "group": "Messages control",
+                    "help": "Disable the message, report, category or checker "
+                    "with the given id(s). You can either give multiple identifiers "
+                    "separated by comma (,) or put this option multiple times "
+                    "(only on the command line, not in the configuration file "
+                    "where it should appear only once). "
+                    'You can also use "--disable=all" to disable everything first '
+                    "and then re-enable specific checks. For example, if you want "
+                    "to run only the similarities checker, you can use "
+                    '"--disable=all --enable=similarities". '
+                    "If you want to run only the classes checker, but have no "
+                    "Warning level messages displayed, use "
+                    '"--disable=all --enable=classes --disable=W".',
+                },
+            ),
+            (
+                "msg-template",
+                {
+                    "type": "string",
+                    "metavar": "<template>",
+                    "group": "Reports",
+                    "help": (
+                        "Template used to display messages. "
+                        "This is a python new-style format string "
+                        "used to format the message information. "
+                        "See doc for all details."
+                    ),
+                },
+            ),
+            (
+                "jobs",
+                {
+                    "type": "int",
+                    "metavar": "<n-processes>",
+                    "short": "j",
+                    "default": 1,
+                    "help": "Use multiple processes to speed up Pylint. Specifying 0 will "
+                    "auto-detect the number of processors available to use.",
+                },
+            ),
+            (
+                "unsafe-load-any-extension",
+                {
+                    "type": "yn",
+                    "metavar": "<y or n>",
+                    "default": False,
+                    "hide": True,
+                    "help": (
+                        "Allow loading of arbitrary C extensions. Extensions"
+                        " are imported into the active Python interpreter and"
+                        " may run arbitrary code."
+                    ),
+                },
+            ),
+            (
+                "limit-inference-results",
+                {
+                    "type": "int",
+                    "metavar": "<number-of-results>",
+                    "default": 100,
+                    "help": (
+                        "Control the amount of potential inferred values when inferring "
+                        "a single object. This can help the performance when dealing with "
+                        "large functions or complex, nested conditions. "
+                    ),
+                },
+            ),
+            (
+                "extension-pkg-allow-list",
+                {
+                    "type": "csv",
+                    "metavar": "<pkg[,pkg]>",
+                    "default": [],
+                    "help": (
+                        "A comma-separated list of package or module names"
+                        " from where C extensions may be loaded. Extensions are"
+                        " loading into the active Python interpreter and may run"
+                        " arbitrary code."
+                    ),
+                },
+            ),
+            (
+                "extension-pkg-whitelist",
+                {
+                    "type": "csv",
+                    "metavar": "<pkg[,pkg]>",
+                    "default": [],
+                    "help": (
+                        "A comma-separated list of package or module names"
+                        " from where C extensions may be loaded. Extensions are"
+                        " loading into the active Python interpreter and may run"
+                        " arbitrary code. (This is an alternative name to"
+                        " extension-pkg-allow-list for backward compatibility.)"
+                    ),
+                },
+            ),
+            (
+                "suggestion-mode",
+                {
+                    "type": "yn",
+                    "metavar": "<y or n>",
+                    "default": True,
+                    "help": (
+                        "When enabled, pylint would attempt to guess common "
+                        "misconfiguration and emit user-friendly hints instead "
+                        "of false-positive error messages."
+                    ),
+                },
+            ),
+            (
+                "exit-zero",
+                {
+                    "action": "store_true",
+                    "help": (
+                        "Always return a 0 (non-error) status code, even if "
+                        "lint errors are found. This is primarily useful in "
+                        "continuous integration scripts."
+                    ),
+                },
+            ),
+            (
+                "from-stdin",
+                {
+                    "action": "store_true",
+                    "help": (
+                        "Interpret the stdin as a python script, whose filename "
+                        "needs to be passed as the module_or_package argument."
+                    ),
+                },
+            ),
+            (
+                "recursive",
+                {
+                    "type": "yn",
+                    "metavar": "<yn>",
+                    "default": False,
+                    "help": "Discover python modules and packages in the file system subtree.",
+                },
+            ),
+            (
+                "py-version",
+                {
+                    "default": sys.version_info[:2],
+                    "type": "py_version",
+                    "metavar": "<py_version>",
+                    "help": (
+                        "Minimum Python version to use for version dependent checks. "
+                        "Will default to the version used to run pylint."
+                    ),
+                },
+            ),
+        )
+
+    base_option_groups = (
+        ("Messages control", "Options controlling analysis messages"),
+        ("Reports", "Options related to output formatting and reporting"),
+    )
+
+    def __init__(
+        self,
+        options: Tuple[Tuple[str, OptionDict], ...] = (),
+        reporter: Union[reporters.BaseReporter, reporters.MultiReporter, None] = None,
+        option_groups: Tuple[Tuple[str, str], ...] = (),
+        pylintrc: Optional[str] = None,
+    ) -> None:
+        """Some stuff has to be done before ancestors initialization...
+        messages store / checkers / reporter / astroid manager
+        """
+        # Attributes for reporters
+        self.reporter: Union[reporters.BaseReporter, reporters.MultiReporter]
+        if reporter:
+            self.set_reporter(reporter)
+        else:
+            self.set_reporter(TextReporter())
+        self._reporters: Dict[str, Type[reporters.BaseReporter]] = {}
+        """Dictionary of possible but non-initialized reporters."""
+
+        # Attributes for checkers and plugins
+        self._checkers: DefaultDict[
+            str, List[checkers.BaseChecker]
+        ] = collections.defaultdict(list)
+        """Dictionary of registered and initialized checkers."""
+        self._dynamic_plugins: Set[str] = set()
+        """Set of loaded plugin names."""
+
+        # Attributes related to visiting files
+        self.file_state = FileState()
+        self.current_name: Optional[str] = None
+        self.current_file: Optional[str] = None
+        self._ignore_file = False
+        self._pragma_lineno: Dict[str, int] = {}
+
+        # Attributes related to stats
+        self.stats = LinterStats()
+
+        # Attributes related to (command-line) options and their parsing
+        self._external_opts = options
+        self.options: Tuple[Tuple[str, OptionDict], ...] = (
+            options + PyLinter.make_options()
+        )
+        self.option_groups: Tuple[Tuple[str, str], ...] = (
+            option_groups + PyLinter.base_option_groups
+        )
+        self._options_methods = {
+            "enable": self.enable,
+            "disable": self.disable,
+            "disable-next": self.disable_next,
+        }
+        self._bw_options_methods = {
+            "disable-msg": self._options_methods["disable"],
+            "enable-msg": self._options_methods["enable"],
+        }
+        self.fail_on_symbols: List[str] = []
+        """List of message symbols on which pylint should fail, set by --fail-on."""
+        self._error_mode = False
+
+        # Attributes related to messages (states) and their handling
+        self.msgs_store = MessageDefinitionStore()
+        self.msg_status = 0
+        self._msgs_state: Dict[str, bool] = {}
+        self._by_id_managed_msgs: List[ManagedMessage] = []
+
+        reporters.ReportsHandlerMixIn.__init__(self)
+        super().__init__(
+            usage=__doc__,
+            config_file=pylintrc or next(config.find_default_config_files(), None),
+        )
+        checkers.BaseTokenChecker.__init__(self)
+        # provided reports
+        self.reports = (
+            ("RP0001", "Messages by category", report_total_messages_stats),
+            (
+                "RP0002",
+                "% errors / warnings by module",
+                report_messages_by_module_stats,
+            ),
+            ("RP0003", "Messages", report_messages_stats),
+        )
+        self.register_checker(self)
+        self.load_provider_defaults()
+
+    def load_default_plugins(self):
+        checkers.initialize(self)
+        reporters.initialize(self)
+
+    def load_plugin_modules(self, modnames):
+        """Take a list of module names which are pylint plugins and load
+        and register them
+        """
+        for modname in modnames:
+            if modname in self._dynamic_plugins:
+                continue
+            self._dynamic_plugins.add(modname)
+            try:
+                module = astroid.modutils.load_module_from_name(modname)
+                module.register(self)
+            except ModuleNotFoundError:
+                pass
+
+    def load_plugin_configuration(self):
+        """Call the configuration hook for plugins.
+
+        This walks through the list of plugins, grabs the "load_configuration"
+        hook, if exposed, and calls it to allow plugins to configure specific
+        settings.
+        """
+        for modname in self._dynamic_plugins:
+            try:
+                module = astroid.modutils.load_module_from_name(modname)
+                if hasattr(module, "load_configuration"):
+                    module.load_configuration(self)
+            except ModuleNotFoundError as e:
+                self.add_message("bad-plugin-value", args=(modname, e), line=0)
+
+    def _load_reporters(self, reporter_names: str) -> None:
+        """Load the reporters if they are available on _reporters."""
+        if not self._reporters:
+            return
+        sub_reporters = []
+        output_files = []
+        with contextlib.ExitStack() as stack:
+            for reporter_name in reporter_names.split(","):
+                reporter_name, *reporter_output = reporter_name.split(":", 1)
+
+                reporter = self._load_reporter_by_name(reporter_name)
+                sub_reporters.append(reporter)
+                if reporter_output:
+                    output_file = stack.enter_context(
+                        open(reporter_output[0], "w", encoding="utf-8")
+                    )
+                    reporter.out = output_file
+                    output_files.append(output_file)
+
+            # Extend the lifetime of all opened output files
+            close_output_files = stack.pop_all().close
+
+        if len(sub_reporters) > 1 or output_files:
+            self.set_reporter(
+                reporters.MultiReporter(
+                    sub_reporters,
+                    close_output_files,
+                )
+            )
+        else:
+            self.set_reporter(sub_reporters[0])
+
+    def _load_reporter_by_name(self, reporter_name: str) -> reporters.BaseReporter:
+        name = reporter_name.lower()
+        if name in self._reporters:
+            return self._reporters[name]()
+
+        try:
+            reporter_class = _load_reporter_by_class(reporter_name)
+        except (ImportError, AttributeError) as e:
+            raise exceptions.InvalidReporterError(name) from e
+        else:
+            return reporter_class()
+
+    def set_reporter(
+        self, reporter: Union[reporters.BaseReporter, reporters.MultiReporter]
+    ) -> None:
+        """Set the reporter used to display messages and reports."""
+        self.reporter = reporter
+        reporter.linter = self
+
+    def set_option(self, optname, value, action=None, optdict=None):
+        """Overridden from config.OptionsProviderMixin to handle some
+        special options
+        """
+        if optname in self._options_methods or optname in self._bw_options_methods:
+            if value:
+                try:
+                    meth = self._options_methods[optname]
+                except KeyError:
+                    meth = self._bw_options_methods[optname]
+                    warnings.warn(
+                        f"{optname} is deprecated, replace it by {optname.split('-')[0]}",
+                        DeprecationWarning,
+                    )
+                value = utils._check_csv(value)
+                if isinstance(value, (list, tuple)):
+                    for _id in value:
+                        meth(_id, ignore_unknown=True)
+                else:
+                    meth(value)
+                return  # no need to call set_option, disable/enable methods do it
+        elif optname == "output-format":
+            assert isinstance(
+                value, str
+            ), "'output-format' should be a comma separated string of reporters"
+            self._load_reporters(value)
+        try:
+            checkers.BaseTokenChecker.set_option(self, optname, value, action, optdict)
+        except config.UnsupportedAction:
+            print(f"option {optname} can't be read from config file", file=sys.stderr)
+
+    def register_reporter(self, reporter_class: Type[reporters.BaseReporter]) -> None:
+        """Registers a reporter class on the _reporters attribute."""
+        self._reporters[reporter_class.name] = reporter_class
+
+    def report_order(self):
+        reports = sorted(self._reports, key=lambda x: getattr(x, "name", ""))
+        try:
+            # Remove the current reporter and add it
+            # at the end of the list.
+            reports.pop(reports.index(self))
+        except ValueError:
+            pass
+        else:
+            reports.append(self)
+        return reports
+
+    # checkers manipulation methods ############################################
+
+    def register_checker(self, checker: checkers.BaseChecker) -> None:
+        """This method auto registers the checker."""
+        assert checker.priority <= 0, "checker priority can't be >= 0"
+        self._checkers[checker.name].append(checker)
+        for r_id, r_title, r_cb in checker.reports:
+            self.register_report(r_id, r_title, r_cb, checker)
+        self.register_options_provider(checker)
+        if hasattr(checker, "msgs"):
+            self.msgs_store.register_messages_from_checker(checker)
+        checker.load_defaults()
+        # Register the checker, but disable all of its messages.
+        if not getattr(checker, "enabled", True):
+            self.disable(checker.name)
+
+    def enable_fail_on_messages(self):
+        """Enable 'fail on' msgs.
+
+        Convert values in config.fail_on (which might be msg category, msg id,
+        or symbol) to specific msgs, then enable and flag them for later.
+        """
+        fail_on_vals = self.config.fail_on
+        if not fail_on_vals:
+            return
+
+        fail_on_cats = set()
+        fail_on_msgs = set()
+        for val in fail_on_vals:
+            # If value is a category, add category, else add message
+            if val in MSG_TYPES:
+                fail_on_cats.add(val)
+            else:
+                fail_on_msgs.add(val)
+
+        # For every message in every checker, if cat or msg flagged, enable check
+        for all_checkers in self._checkers.values():
+            for checker in all_checkers:
+                for msg in checker.messages:
+                    if msg.msgid in fail_on_msgs or msg.symbol in fail_on_msgs:
+                        # message id/symbol matched, enable and flag it
+                        self.enable(msg.msgid)
+                        self.fail_on_symbols.append(msg.symbol)
+                    elif msg.msgid[0] in fail_on_cats:
+                        # message starts with a category value, flag (but do not enable) it
+                        self.fail_on_symbols.append(msg.symbol)
+
+    def any_fail_on_issues(self):
+        return self.stats and any(
+            x in self.fail_on_symbols for x in self.stats.by_msg.keys()
+        )
+
+    def disable_noerror_messages(self):
+        for msgcat, msgids in self.msgs_store._msgs_by_category.items():
+            # enable only messages with 'error' severity and above ('fatal')
+            if msgcat in {"E", "F"}:
+                for msgid in msgids:
+                    self.enable(msgid)
+            else:
+                for msgid in msgids:
+                    self.disable(msgid)
+
+    def disable_reporters(self):
+        """Disable all reporters."""
+        for _reporters in self._reports.values():
+            for report_id, _, _ in _reporters:
+                self.disable_report(report_id)
+
+    def error_mode(self):
+        """Error mode: enable only errors; no reports, no persistent."""
+        self._error_mode = True
+        self.disable_noerror_messages()
+        self.disable("miscellaneous")
+        self.set_option("reports", False)
+        self.set_option("persistent", False)
+        self.set_option("score", False)
+
+    def list_messages_enabled(self):
+        emittable, non_emittable = self.msgs_store.find_emittable_messages()
+        enabled = []
+        disabled = []
+        for message in emittable:
+            if self.is_message_enabled(message.msgid):
+                enabled.append(f"  {message.symbol} ({message.msgid})")
+            else:
+                disabled.append(f"  {message.symbol} ({message.msgid})")
+        print("Enabled messages:")
+        for msg in enabled:
+            print(msg)
+        print("\nDisabled messages:")
+        for msg in disabled:
+            print(msg)
+        print("\nNon-emittable messages with current interpreter:")
+        for msg in non_emittable:
+            print(f"  {msg.symbol} ({msg.msgid})")
+        print("")
+
+    # block level option handling #############################################
+    # see func_block_disable_msg.py test case for expected behaviour
+
+    def process_tokens(self, tokens):
+        """Process tokens from the current module to search for module/block level
+        options.
+        """
+        control_pragmas = {"disable", "disable-next", "enable"}
+        prev_line = None
+        saw_newline = True
+        seen_newline = True
+        for (tok_type, content, start, _, _) in tokens:
+            if prev_line and prev_line != start[0]:
+                saw_newline = seen_newline
+                seen_newline = False
+
+            prev_line = start[0]
+            if tok_type in (tokenize.NL, tokenize.NEWLINE):
+                seen_newline = True
+
+            if tok_type != tokenize.COMMENT:
+                continue
+            match = OPTION_PO.search(content)
+            if match is None:
+                continue
+            try:
+                for pragma_repr in parse_pragma(match.group(2)):
+                    if pragma_repr.action in {"disable-all", "skip-file"}:
+                        if pragma_repr.action == "disable-all":
+                            self.add_message(
+                                "deprecated-pragma",
+                                line=start[0],
+                                args=("disable-all", "skip-file"),
+                            )
+                        self.add_message("file-ignored", line=start[0])
+                        self._ignore_file = True
+                        return
+                    try:
+                        meth = self._options_methods[pragma_repr.action]
+                    except KeyError:
+                        meth = self._bw_options_methods[pragma_repr.action]
+                        # found a "(dis|en)able-msg" pragma deprecated suppression
+                        self.add_message(
+                            "deprecated-pragma",
+                            line=start[0],
+                            args=(
+                                pragma_repr.action,
+                                pragma_repr.action.replace("-msg", ""),
+                            ),
+                        )
+                    for msgid in pragma_repr.messages:
+                        # Add the line where a control pragma was encountered.
+                        if pragma_repr.action in control_pragmas:
+                            self._pragma_lineno[msgid] = start[0]
+
+                        if (pragma_repr.action, msgid) == ("disable", "all"):
+                            self.add_message(
+                                "deprecated-pragma",
+                                line=start[0],
+                                args=("disable=all", "skip-file"),
+                            )
+                            self.add_message("file-ignored", line=start[0])
+                            self._ignore_file = True
+                            return
+                            # If we did not see a newline between the previous line and now,
+                            # we saw a backslash so treat the two lines as one.
+                        l_start = start[0]
+                        if not saw_newline:
+                            l_start -= 1
+                        try:
+                            meth(msgid, "module", l_start)
+                        except exceptions.UnknownMessageError:
+                            self.add_message(
+                                "bad-option-value", args=msgid, line=start[0]
+                            )
+            except UnRecognizedOptionError as err:
+                self.add_message(
+                    "unrecognized-inline-option", args=err.token, line=start[0]
+                )
+                continue
+            except InvalidPragmaError as err:
+                self.add_message("bad-inline-option", args=err.token, line=start[0])
+                continue
+
+    # code checking methods ###################################################
+
+    def get_checkers(self):
+        """Return all available checkers as a list."""
+        return [self] + [
+            c
+            for _checkers in self._checkers.values()
+            for c in _checkers
+            if c is not self
+        ]
+
+    def get_checker_names(self):
+        """Get all the checker names that this linter knows about."""
+        current_checkers = self.get_checkers()
+        return sorted(
+            {
+                checker.name
+                for checker in current_checkers
+                if checker.name != MAIN_CHECKER_NAME
+            }
+        )
+
+    def prepare_checkers(self):
+        """Return checkers needed for activated messages and reports."""
+        if not self.config.reports:
+            self.disable_reporters()
+        # get needed checkers
+        needed_checkers = [self]
+        for checker in self.get_checkers()[1:]:
+            messages = {msg for msg in checker.msgs if self.is_message_enabled(msg)}
+            if messages or any(self.report_is_enabled(r[0]) for r in checker.reports):
+                needed_checkers.append(checker)
+        # Sort checkers by priority
+        needed_checkers = sorted(
+            needed_checkers, key=operator.attrgetter("priority"), reverse=True
+        )
+        return needed_checkers
+
+    # pylint: disable=unused-argument
+    @staticmethod
+    def should_analyze_file(modname, path, is_argument=False):
+        """Returns whether a module should be checked.
+
+        This implementation returns True for all python source file, indicating
+        that all files should be linted.
+
+        Subclasses may override this method to indicate that modules satisfying
+        certain conditions should not be linted.
+
+        :param str modname: The name of the module to be checked.
+        :param str path: The full path to the source code of the module.
+        :param bool is_argument: Whether the file is an argument to pylint or not.
+                                 Files which respect this property are always
+                                 checked, since the user requested it explicitly.
+        :returns: True if the module should be checked.
+        :rtype: bool
+        """
+        if is_argument:
+            return True
+        return path.endswith(".py")
+
+    # pylint: enable=unused-argument
+
+    def initialize(self):
+        """Initialize linter for linting.
+
+        This method is called before any linting is done.
+        """
+        # initialize msgs_state now that all messages have been registered into
+        # the store
+        for msg in self.msgs_store.messages:
+            if not msg.may_be_emitted():
+                self._msgs_state[msg.msgid] = False
+
+    def _discover_files(self, files_or_modules: Sequence[str]) -> Iterator[str]:
+        """Discover python modules and packages in sub-directory.
+
+        Returns iterator of paths to discovered modules and packages.
+        """
+        for something in files_or_modules:
+            if os.path.isdir(something) and not os.path.isfile(
+                os.path.join(something, "__init__.py")
+            ):
+                skip_subtrees: List[str] = []
+                for root, _, files in os.walk(something):
+                    if any(root.startswith(s) for s in skip_subtrees):
+                        # Skip subtree of already discovered package.
+                        continue
+
+                    if _is_ignored_file(
+                        root,
+                        self.config.black_list,
+                        self.config.black_list_re,
+                        self.config.ignore_paths,
+                    ):
+                        skip_subtrees.append(root)
+                        continue
+
+                    if "__init__.py" in files:
+                        skip_subtrees.append(root)
+                        yield root
+                    else:
+                        yield from (
+                            os.path.join(root, file)
+                            for file in files
+                            if file.endswith(".py")
+                        )
+            else:
+                yield something
+
+    def check(self, files_or_modules: Union[Sequence[str], str]) -> None:
+        """Main checking entry: check a list of files or modules from their name.
+
+        files_or_modules is either a string or list of strings presenting modules to check.
+        """
+        self.initialize()
+        if not isinstance(files_or_modules, (list, tuple)):
+            # pylint: disable-next=fixme
+            # TODO: Update typing and docstring for 'files_or_modules' when removing the deprecation
+            warnings.warn(
+                "In pylint 3.0, the checkers check function will only accept sequence of string",
+                DeprecationWarning,
+            )
+            files_or_modules = (files_or_modules,)  # type: ignore[assignment]
+        if self.config.recursive:
+            files_or_modules = tuple(self._discover_files(files_or_modules))
+        if self.config.from_stdin:
+            if len(files_or_modules) != 1:
+                raise exceptions.InvalidArgsError(
+                    "Missing filename required for --from-stdin"
+                )
+
+            filepath = files_or_modules[0]
+            with fix_import_path(files_or_modules):
+                self._check_files(
+                    functools.partial(self.get_ast, data=_read_stdin()),
+                    [self._get_file_descr_from_stdin(filepath)],
+                )
+        elif self.config.jobs == 1:
+            with fix_import_path(files_or_modules):
+                self._check_files(
+                    self.get_ast, self._iterate_file_descrs(files_or_modules)
+                )
+        else:
+            check_parallel(
+                self,
+                self.config.jobs,
+                self._iterate_file_descrs(files_or_modules),
+                files_or_modules,
+            )
+
+    def check_single_file(self, name: str, filepath: str, modname: str) -> None:
+        warnings.warn(
+            "In pylint 3.0, the checkers check_single_file function will be removed. "
+            "Use check_single_file_item instead.",
+            DeprecationWarning,
+        )
+        self.check_single_file_item(FileItem(name, filepath, modname))
+
+    def check_single_file_item(self, file: FileItem) -> None:
+        """Check single file item.
+
+        The arguments are the same that are documented in _check_files
+
+        initialize() should be called before calling this method
+        """
+        with self._astroid_module_checker() as check_astroid_module:
+            self._check_file(self.get_ast, check_astroid_module, file)
+
+    def _check_files(
+        self,
+        get_ast,
+        file_descrs: Iterable[FileItem],
+    ) -> None:
+        """Check all files from file_descrs."""
+        with self._astroid_module_checker() as check_astroid_module:
+            for file in file_descrs:
+                try:
+                    self._check_file(get_ast, check_astroid_module, file)
+                except Exception as ex:  # pylint: disable=broad-except
+                    template_path = prepare_crash_report(
+                        ex, file.filepath, self.crash_file_path
+                    )
+                    msg = get_fatal_error_message(file.filepath, template_path)
+                    if isinstance(ex, AstroidError):
+                        symbol = "astroid-error"
+                        self.add_message(symbol, args=(file.filepath, msg))
+                    else:
+                        symbol = "fatal"
+                        self.add_message(symbol, args=msg)
+
+    def _check_file(self, get_ast, check_astroid_module, file: FileItem):
+        """Check a file using the passed utility functions (get_ast and check_astroid_module).
+
+        :param callable get_ast: callable returning AST from defined file taking the following arguments
+        - filepath: path to the file to check
+        - name: Python module name
+        :param callable check_astroid_module: callable checking an AST taking the following arguments
+        - ast: AST of the module
+        :param FileItem file: data about the file
+        """
+        self.set_current_module(file.name, file.filepath)
+        # get the module representation
+        ast_node = get_ast(file.filepath, file.name)
+        if ast_node is None:
+            return
+
+        self._ignore_file = False
+
+        self.file_state = FileState(file.modpath)
+        # fix the current file (if the source file was not available or
+        # if it's actually a c extension)
+        self.current_file = ast_node.file
+        check_astroid_module(ast_node)
+        # warn about spurious inline messages handling
+        spurious_messages = self.file_state.iter_spurious_suppression_messages(
+            self.msgs_store
+        )
+        for msgid, line, args in spurious_messages:
+            self.add_message(msgid, line, None, args)
+
+    @staticmethod
+    def _get_file_descr_from_stdin(filepath: str) -> FileItem:
+        """Return file description (tuple of module name, file path, base name) from given file path.
+
+        This method is used for creating suitable file description for _check_files when the
+        source is standard input.
+        """
+        try:
+            # Note that this function does not really perform an
+            # __import__ but may raise an ImportError exception, which
+            # we want to catch here.
+            modname = ".".join(astroid.modutils.modpath_from_file(filepath))
+        except ImportError:
+            modname = os.path.splitext(os.path.basename(filepath))[0]
+
+        return FileItem(modname, filepath, filepath)
+
+    def _iterate_file_descrs(self, files_or_modules) -> Iterator[FileItem]:
+        """Return generator yielding file descriptions (tuples of module name, file path, base name).
+
+        The returned generator yield one item for each Python module that should be linted.
+        """
+        for descr in self._expand_files(files_or_modules):
+            name, filepath, is_arg = descr["name"], descr["path"], descr["isarg"]
+            if self.should_analyze_file(name, filepath, is_argument=is_arg):
+                yield FileItem(name, filepath, descr["basename"])
+
+    def _expand_files(self, modules) -> List[ModuleDescriptionDict]:
+        """Get modules and errors from a list of modules and handle errors."""
+        result, errors = expand_modules(
+            modules,
+            self.config.black_list,
+            self.config.black_list_re,
+            self.config.ignore_paths,
+        )
+        for error in errors:
+            message = modname = error["mod"]
+            key = error["key"]
+            self.set_current_module(modname)
+            if key == "fatal":
+                message = str(error["ex"]).replace(os.getcwd() + os.sep, "")
+            self.add_message(key, args=message)
+        return result
+
+    def set_current_module(self, modname, filepath: Optional[str] = None):
+        """Set the name of the currently analyzed module and
+        init statistics for it
+        """
+        if not modname and filepath is None:
+            return
+        self.reporter.on_set_current_module(modname, filepath)
+        if modname is None:
+            warnings.warn(
+                (
+                    "In pylint 3.0 modname should be a string so that it can be used to "
+                    "correctly set the current_name attribute of the linter instance. "
+                    "If unknown it should be initialized as an empty string."
+                ),
+                DeprecationWarning,
+            )
+        self.current_name = modname
+        self.current_file = filepath or modname
+        self.stats.init_single_module(modname)
+
+    @contextlib.contextmanager
+    def _astroid_module_checker(self):
+        """Context manager for checking ASTs.
+
+        The value in the context is callable accepting AST as its only argument.
+        """
+        walker = ASTWalker(self)
+        _checkers = self.prepare_checkers()
+        tokencheckers = [
+            c
+            for c in _checkers
+            if interfaces.implements(c, interfaces.ITokenChecker) and c is not self
+        ]
+        rawcheckers = [
+            c for c in _checkers if interfaces.implements(c, interfaces.IRawChecker)
+        ]
+        # notify global begin
+        for checker in _checkers:
+            checker.open()
+            if interfaces.implements(checker, interfaces.IAstroidChecker):
+                walker.add_checker(checker)
+
+        yield functools.partial(
+            self.check_astroid_module,
+            walker=walker,
+            tokencheckers=tokencheckers,
+            rawcheckers=rawcheckers,
+        )
+
+        # notify global end
+        self.stats.statement = walker.nbstatements
+        for checker in reversed(_checkers):
+            checker.close()
+
+    def get_ast(
+        self, filepath: str, modname: str, data: Optional[str] = None
+    ) -> nodes.Module:
+        """Return an ast(roid) representation of a module or a string.
+
+        :param str filepath: path to checked file.
+        :param str modname: The name of the module to be checked.
+        :param str data: optional contents of the checked file.
+        :returns: the AST
+        :rtype: astroid.nodes.Module
+        :raises AstroidBuildingError: Whenever we encounter an unexpected exception
+        """
+        try:
+            if data is None:
+                return MANAGER.ast_from_file(filepath, modname, source=True)
+            return astroid.builder.AstroidBuilder(MANAGER).string_build(
+                data, modname, filepath
+            )
+        except astroid.AstroidSyntaxError as ex:
+            # pylint: disable=no-member
+            self.add_message(
+                "syntax-error",
+                line=getattr(ex.error, "lineno", 0),
+                col_offset=getattr(ex.error, "offset", None),
+                args=str(ex.error),
+            )
+        except astroid.AstroidBuildingError as ex:
+            self.add_message("parse-error", args=ex)
+        except Exception as ex:
+            traceback.print_exc()
+            # We raise BuildingError here as this is essentially an astroid issue
+            # Creating an issue template and adding the 'astroid-error' message is handled
+            # by caller: _check_files
+            raise astroid.AstroidBuildingError(
+                "Building error when trying to create ast representation of module '{modname}'",
+                modname=modname,
+            ) from ex
+        return None
+
+    def check_astroid_module(self, ast_node, walker, rawcheckers, tokencheckers):
+        """Check a module from its astroid representation.
+
+        For return value see _check_astroid_module
+        """
+        before_check_statements = walker.nbstatements
+
+        retval = self._check_astroid_module(
+            ast_node, walker, rawcheckers, tokencheckers
+        )
+
+        self.stats.by_module[self.current_name]["statement"] = (
+            walker.nbstatements - before_check_statements
+        )
+
+        return retval
+
+    def _check_astroid_module(
+        self, node: nodes.Module, walker, rawcheckers, tokencheckers
+    ):
+        """Check given AST node with given walker and checkers.
+
+        :param astroid.nodes.Module node: AST node of the module to check
+        :param pylint.utils.ast_walker.ASTWalker walker: AST walker
+        :param list rawcheckers: List of token checkers to use
+        :param list tokencheckers: List of raw checkers to use
+
+        :returns: True if the module was checked, False if ignored,
+            None if the module contents could not be parsed
+        :rtype: bool
+        """
+        try:
+            tokens = utils.tokenize_module(node)
+        except tokenize.TokenError as ex:
+            self.add_message("syntax-error", line=ex.args[1][0], args=ex.args[0])
+            return None
+
+        if not node.pure_python:
+            self.add_message("raw-checker-failed", args=node.name)
+        else:
+            # assert astroid.file.endswith('.py')
+            # invoke ITokenChecker interface on self to fetch module/block
+            # level options
+            self.process_tokens(tokens)
+            if self._ignore_file:
+                return False
+            # walk ast to collect line numbers
+            self.file_state.collect_block_lines(self.msgs_store, node)
+            # run raw and tokens checkers
+            for checker in rawcheckers:
+                checker.process_module(node)
+            for checker in tokencheckers:
+                checker.process_tokens(tokens)
+        # generate events to astroid checkers
+        walker.walk(node)
+        return True
+
+    # IAstroidChecker interface #################################################
+
+    def open(self):
+        """Initialize counters."""
+        self.stats = LinterStats()
+        MANAGER.always_load_extensions = self.config.unsafe_load_any_extension
+        MANAGER.max_inferable_values = self.config.limit_inference_results
+        MANAGER.extension_package_whitelist.update(self.config.extension_pkg_allow_list)
+        if self.config.extension_pkg_whitelist:
+            MANAGER.extension_package_whitelist.update(
+                self.config.extension_pkg_whitelist
+            )
+        self.stats.reset_message_count()
+        self._ignore_paths = get_global_option(self, "ignore-paths")
+
+    def generate_reports(self):
+        """Close the whole package /module, it's time to make reports !
+
+        if persistent run, pickle results for later comparison
+        """
+        # Display whatever messages are left on the reporter.
+        self.reporter.display_messages(report_nodes.Section())
+
+        if self.file_state.base_name is not None:
+            # load previous results if any
+            previous_stats = config.load_results(self.file_state.base_name)
+            self.reporter.on_close(self.stats, previous_stats)
+            if self.config.reports:
+                sect = self.make_reports(self.stats, previous_stats)
+            else:
+                sect = report_nodes.Section()
+
+            if self.config.reports:
+                self.reporter.display_reports(sect)
+            score_value = self._report_evaluation()
+            # save results if persistent run
+            if self.config.persistent:
+                config.save_results(self.stats, self.file_state.base_name)
+        else:
+            self.reporter.on_close(self.stats, LinterStats())
+            score_value = None
+        return score_value
+
+    def _report_evaluation(self):
+        """Make the global evaluation report."""
+        # check with at least check 1 statements (usually 0 when there is a
+        # syntax error preventing pylint from further processing)
+        note = None
+        previous_stats = config.load_results(self.file_state.base_name)
+        if self.stats.statement == 0:
+            return note
+
+        # get a global note for the code
+        evaluation = self.config.evaluation
+        try:
+            stats_dict = {
+                "fatal": self.stats.fatal,
+                "error": self.stats.error,
+                "warning": self.stats.warning,
+                "refactor": self.stats.refactor,
+                "convention": self.stats.convention,
+                "statement": self.stats.statement,
+                "info": self.stats.info,
+            }
+            note = eval(evaluation, {}, stats_dict)  # pylint: disable=eval-used
+        except Exception as ex:  # pylint: disable=broad-except
+            msg = f"An exception occurred while rating: {ex}"
+        else:
+            self.stats.global_note = note
+            msg = f"Your code has been rated at {note:.2f}/10"
+            if previous_stats:
+                pnote = previous_stats.global_note
+                if pnote is not None:
+                    msg += f" (previous run: {pnote:.2f}/10, {note - pnote:+.2f})"
+
+        if self.config.score:
+            sect = report_nodes.EvaluationSection(msg)
+            self.reporter.display_reports(sect)
+        return note
+
+    # Adding (ignored) messages to the Message Reporter
+
+    def _get_message_state_scope(
+        self,
+        msgid: str,
+        line: Optional[int] = None,
+        confidence: Optional[interfaces.Confidence] = None,
+    ) -> Optional[Literal[0, 1, 2]]:
+        """Returns the scope at which a message was enabled/disabled."""
+        if confidence is None:
+            confidence = interfaces.UNDEFINED
+        if self.config.confidence and confidence.name not in self.config.confidence:
+            return MSG_STATE_CONFIDENCE  # type: ignore[return-value] # mypy does not infer Literal correctly
+        try:
+            if line in self.file_state._module_msgs_state[msgid]:
+                return MSG_STATE_SCOPE_MODULE  # type: ignore[return-value]
+        except (KeyError, TypeError):
+            return MSG_STATE_SCOPE_CONFIG  # type: ignore[return-value]
+        return None
+
+    def _is_one_message_enabled(self, msgid: str, line: Optional[int]) -> bool:
+        """Checks state of a single message for the current file.
+
+        This function can't be cached as it depends on self.file_state which can
+        change.
+        """
+        if line is None:
+            return self._msgs_state.get(msgid, True)
+        try:
+            return self.file_state._module_msgs_state[msgid][line]
+        except KeyError:
+            # Check if the message's line is after the maximum line existing in ast tree.
+            # This line won't appear in the ast tree and won't be referred in
+            # self.file_state._module_msgs_state
+            # This happens for example with a commented line at the end of a module.
+            max_line_number = self.file_state.get_effective_max_line_number()
+            if max_line_number and line > max_line_number:
+                fallback = True
+                lines = self.file_state._raw_module_msgs_state.get(msgid, {})
+
+                # Doesn't consider scopes, as a 'disable' can be in a
+                # different scope than that of the current line.
+                closest_lines = reversed(
+                    [
+                        (message_line, enable)
+                        for message_line, enable in lines.items()
+                        if message_line <= line
+                    ]
+                )
+                _, fallback_iter = next(closest_lines, (None, None))
+                if fallback_iter is not None:
+                    fallback = fallback_iter
+
+                return self._msgs_state.get(msgid, fallback)
+            return self._msgs_state.get(msgid, True)
+
+    def is_message_enabled(
+        self,
+        msg_descr: str,
+        line: Optional[int] = None,
+        confidence: Optional[interfaces.Confidence] = None,
+    ) -> bool:
+        """Return whether this message is enabled for the current file, line and confidence level.
+
+        This function can't be cached right now as the line is the line of
+        the currently analysed file (self.file_state), if it changes, then the
+        result for the same msg_descr/line might need to change.
+
+        :param msg_descr: Either the msgid or the symbol for a MessageDefinition
+        :param line: The line of the currently analysed file
+        :param confidence: The confidence of the message
+        """
+        if self.config.confidence and confidence:
+            if confidence.name not in self.config.confidence:
+                return False
+        try:
+            msgids = self.msgs_store.message_id_store.get_active_msgids(msg_descr)
+        except exceptions.UnknownMessageError:
+            # The linter checks for messages that are not registered
+            # due to version mismatch, just treat them as message IDs
+            # for now.
+            msgids = [msg_descr]
+        return any(self._is_one_message_enabled(msgid, line) for msgid in msgids)
+
+    def _add_one_message(
+        self,
+        message_definition: MessageDefinition,
+        line: Optional[int],
+        node: Optional[nodes.NodeNG],
+        args: Optional[Any],
+        confidence: Optional[interfaces.Confidence],
+        col_offset: Optional[int],
+        end_lineno: Optional[int],
+        end_col_offset: Optional[int],
+    ) -> None:
+        """After various checks have passed a single Message is
+        passed to the reporter and added to stats
+        """
+        message_definition.check_message_definition(line, node)
+
+        # Look up "location" data of node if not yet supplied
+        if node:
+            if node.position:
+                if not line:
+                    line = node.position.lineno
+                if not col_offset:
+                    col_offset = node.position.col_offset
+                if not end_lineno:
+                    end_lineno = node.position.end_lineno
+                if not end_col_offset:
+                    end_col_offset = node.position.end_col_offset
+            else:
+                if not line:
+                    line = node.fromlineno
+                if not col_offset:
+                    col_offset = node.col_offset
+                if not end_lineno:
+                    end_lineno = node.end_lineno
+                if not end_col_offset:
+                    end_col_offset = node.end_col_offset
+
+        # should this message be displayed
+        if not self.is_message_enabled(message_definition.msgid, line, confidence):
+            self.file_state.handle_ignored_message(
+                self._get_message_state_scope(
+                    message_definition.msgid, line, confidence
+                ),
+                message_definition.msgid,
+                line,
+            )
+            return
+
+        # update stats
+        msg_cat = MSG_TYPES[message_definition.msgid[0]]
+        self.msg_status |= MSG_TYPES_STATUS[message_definition.msgid[0]]
+        self.stats.increase_single_message_count(msg_cat, 1)
+        self.stats.increase_single_module_message_count(
+            self.current_name,  # type: ignore[arg-type] # Should be removable after https://github.com/PyCQA/pylint/pull/5580
+            msg_cat,
+            1,
+        )
+        try:
+            self.stats.by_msg[message_definition.symbol] += 1
+        except KeyError:
+            self.stats.by_msg[message_definition.symbol] = 1
+        # Interpolate arguments into message string
+        msg = message_definition.msg
+        if args:
+            msg %= args
+        # get module and object
+        if node is None:
+            module, obj = self.current_name, ""
+            abspath = self.current_file
+        else:
+            module, obj = utils.get_module_and_frameid(node)
+            abspath = node.root().file
+        if abspath is not None:
+            path = abspath.replace(self.reporter.path_strip_prefix, "", 1)
+        else:
+            path = "configuration"
+        # add the message
+        self.reporter.handle_message(
+            Message(
+                message_definition.msgid,
+                message_definition.symbol,
+                MessageLocationTuple(
+                    abspath or "",
+                    path,
+                    module or "",
+                    obj,
+                    line or 1,
+                    col_offset or 0,
+                    end_lineno,
+                    end_col_offset,
+                ),
+                msg,
+                confidence,
+            )
+        )
+
+    def add_message(
+        self,
+        msgid: str,
+        line: Optional[int] = None,
+        node: Optional[nodes.NodeNG] = None,
+        args: Optional[Any] = None,
+        confidence: Optional[interfaces.Confidence] = None,
+        col_offset: Optional[int] = None,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """Adds a message given by ID or name.
+
+        If provided, the message string is expanded using args.
+
+        AST checkers must provide the node argument (but may optionally
+        provide line if the line number is different), raw and token checkers
+        must provide the line argument.
+        """
+        if confidence is None:
+            confidence = interfaces.UNDEFINED
+        message_definitions = self.msgs_store.get_message_definitions(msgid)
+        for message_definition in message_definitions:
+            self._add_one_message(
+                message_definition,
+                line,
+                node,
+                args,
+                confidence,
+                col_offset,
+                end_lineno,
+                end_col_offset,
+            )
+
+    def add_ignored_message(
+        self,
+        msgid: str,
+        line: int,
+        node: Optional[nodes.NodeNG] = None,
+        confidence: Optional[interfaces.Confidence] = interfaces.UNDEFINED,
+    ) -> None:
+        """Prepares a message to be added to the ignored message storage.
+
+        Some checks return early in special cases and never reach add_message(),
+        even though they would normally issue a message.
+        This creates false positives for useless-suppression.
+        This function avoids this by adding those message to the ignored msgs attribute
+        """
+        message_definitions = self.msgs_store.get_message_definitions(msgid)
+        for message_definition in message_definitions:
+            message_definition.check_message_definition(line, node)
+            self.file_state.handle_ignored_message(
+                self._get_message_state_scope(
+                    message_definition.msgid, line, confidence
+                ),
+                message_definition.msgid,
+                line,
+            )
+
+    # Setting the state (disabled/enabled) of messages and registering them
+
+    def _message_symbol(self, msgid: str) -> List[str]:
+        """Get the message symbol of the given message id.
+
+        Return the original message id if the message does not
+        exist.
+        """
+        try:
+            return [md.symbol for md in self.msgs_store.get_message_definitions(msgid)]
+        except exceptions.UnknownMessageError:
+            return [msgid]
+
+    def _set_one_msg_status(
+        self, scope: str, msg: MessageDefinition, line: Optional[int], enable: bool
+    ) -> None:
+        """Set the status of an individual message."""
+        if scope == "module":
+            assert isinstance(line, int)  # should always be int inside module scope
+
+            self.file_state.set_msg_status(msg, line, enable)
+            if not enable and msg.symbol != "locally-disabled":
+                self.add_message(
+                    "locally-disabled", line=line, args=(msg.symbol, msg.msgid)
+                )
+        else:
+            msgs = self._msgs_state
+            msgs[msg.msgid] = enable
+
+    def _get_messages_to_set(
+        self, msgid: str, enable: bool, ignore_unknown: bool = False
+    ) -> List[MessageDefinition]:
+        """Do some tests and find the actual messages of which the status should be set."""
+        message_definitions = []
+        if msgid == "all":
+            for _msgid in MSG_TYPES:
+                message_definitions.extend(
+                    self._get_messages_to_set(_msgid, enable, ignore_unknown)
+                )
+            return message_definitions
+
+        # msgid is a category?
+        category_id = msgid.upper()
+        if category_id not in MSG_TYPES:
+            category_id_formatted = MSG_TYPES_LONG.get(category_id)
+        else:
+            category_id_formatted = category_id
+        if category_id_formatted is not None:
+            for _msgid in self.msgs_store._msgs_by_category[category_id_formatted]:
+                message_definitions.extend(
+                    self._get_messages_to_set(_msgid, enable, ignore_unknown)
+                )
+            return message_definitions
+
+        # msgid is a checker name?
+        if msgid.lower() in self._checkers:
+            for checker in self._checkers[msgid.lower()]:
+                for _msgid in checker.msgs:
+                    message_definitions.extend(
+                        self._get_messages_to_set(_msgid, enable, ignore_unknown)
+                    )
+            return message_definitions
+
+        # msgid is report id?
+        if msgid.lower().startswith("rp"):
+            if enable:
+                self.enable_report(msgid)
+            else:
+                self.disable_report(msgid)
+            return message_definitions
+
+        try:
+            # msgid is a symbolic or numeric msgid.
+            message_definitions = self.msgs_store.get_message_definitions(msgid)
+        except exceptions.UnknownMessageError:
+            if not ignore_unknown:
+                raise
+        return message_definitions
+
+    def _set_msg_status(
+        self,
+        msgid: str,
+        enable: bool,
+        scope: str = "package",
+        line: Optional[int] = None,
+        ignore_unknown: bool = False,
+    ) -> None:
+        """Do some tests and then iterate over message definitions to set state."""
+        assert scope in {"package", "module"}
+
+        message_definitions = self._get_messages_to_set(msgid, enable, ignore_unknown)
+
+        for message_definition in message_definitions:
+            self._set_one_msg_status(scope, message_definition, line, enable)
+
+        # sync configuration object
+        self.config.enable = []
+        self.config.disable = []
+        for mid, val in self._msgs_state.items():
+            if val:
+                self.config.enable.append(self._message_symbol(mid))
+            else:
+                self.config.disable.append(self._message_symbol(mid))
+
+    def _register_by_id_managed_msg(
+        self, msgid_or_symbol: str, line: Optional[int], is_disabled: bool = True
+    ) -> None:
+        """If the msgid is a numeric one, then register it to inform the user
+        it could furnish instead a symbolic msgid.
+        """
+        if msgid_or_symbol[1:].isdigit():
+            try:
+                symbol = self.msgs_store.message_id_store.get_symbol(
+                    msgid=msgid_or_symbol
+                )
+            except exceptions.UnknownMessageError:
+                return
+            managed = ManagedMessage(
+                self.current_name, msgid_or_symbol, symbol, line, is_disabled
+            )
+            self._by_id_managed_msgs.append(managed)
+
+    def disable(
+        self,
+        msgid: str,
+        scope: str = "package",
+        line: Optional[int] = None,
+        ignore_unknown: bool = False,
+    ) -> None:
+        """Disable a message for a scope."""
+        self._set_msg_status(
+            msgid, enable=False, scope=scope, line=line, ignore_unknown=ignore_unknown
+        )
+        self._register_by_id_managed_msg(msgid, line)
+
+    def disable_next(
+        self,
+        msgid: str,
+        scope: str = "package",
+        line: Optional[int] = None,
+        ignore_unknown: bool = False,
+    ) -> None:
+        """Disable a message for the next line."""
+        if not line:
+            raise exceptions.NoLineSuppliedError
+        self._set_msg_status(
+            msgid,
+            enable=False,
+            scope=scope,
+            line=line + 1,
+            ignore_unknown=ignore_unknown,
+        )
+        self._register_by_id_managed_msg(msgid, line + 1)
+
+    def enable(
+        self,
+        msgid: str,
+        scope: str = "package",
+        line: Optional[int] = None,
+        ignore_unknown: bool = False,
+    ) -> None:
+        """Enable a message for a scope."""
+        self._set_msg_status(
+            msgid, enable=True, scope=scope, line=line, ignore_unknown=ignore_unknown
+        )
+        self._register_by_id_managed_msg(msgid, line, is_disabled=False)
diff --git a/myenv/lib/python3.9/site-packages/pylint/lint/report_functions.py b/myenv/lib/python3.9/site-packages/pylint/lint/report_functions.py
new file mode 100644
index 0000000..f4c0a57
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/lint/report_functions.py
@@ -0,0 +1,85 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import collections
+from typing import DefaultDict, Dict, Union
+
+from pylint import checkers, exceptions
+from pylint.reporters.ureports.nodes import Table
+from pylint.utils import LinterStats
+
+
+def report_total_messages_stats(
+    sect,
+    stats: LinterStats,
+    previous_stats: LinterStats,
+):
+    """Make total errors / warnings report."""
+    lines = ["type", "number", "previous", "difference"]
+    lines += checkers.table_lines_from_stats(stats, previous_stats, "message_types")
+    sect.append(Table(children=lines, cols=4, rheaders=1))
+
+
+def report_messages_stats(
+    sect,
+    stats: LinterStats,
+    _: LinterStats,
+):
+    """Make messages type report."""
+    by_msg_stats = stats.by_msg
+    in_order = sorted(
+        (value, msg_id)
+        for msg_id, value in by_msg_stats.items()
+        if not msg_id.startswith("I")
+    )
+    in_order.reverse()
+    lines = ["message id", "occurrences"]
+    for value, msg_id in in_order:
+        lines += [msg_id, str(value)]
+    sect.append(Table(children=lines, cols=2, rheaders=1))
+
+
+def report_messages_by_module_stats(
+    sect,
+    stats: LinterStats,
+    _: LinterStats,
+):
+    """Make errors / warnings by modules report."""
+    module_stats = stats.by_module
+    if len(module_stats) == 1:
+        # don't print this report when we are analysing a single module
+        raise exceptions.EmptyReportError()
+    by_mod: DefaultDict[str, Dict[str, Union[int, float]]] = collections.defaultdict(
+        dict
+    )
+    for m_type in ("fatal", "error", "warning", "refactor", "convention"):
+        total = stats.get_global_message_count(m_type)
+        for module in module_stats.keys():
+            mod_total = stats.get_module_message_count(module, m_type)
+            percent = 0 if total == 0 else float(mod_total * 100) / total
+            by_mod[module][m_type] = percent
+    sorted_result = []
+    for module, mod_info in by_mod.items():
+        sorted_result.append(
+            (
+                mod_info["error"],
+                mod_info["warning"],
+                mod_info["refactor"],
+                mod_info["convention"],
+                module,
+            )
+        )
+    sorted_result.sort()
+    sorted_result.reverse()
+    lines = ["module", "error", "warning", "refactor", "convention"]
+    for line in sorted_result:
+        # Don't report clean modules.
+        if all(entry == 0 for entry in line[:-1]):
+            continue
+        lines.append(line[-1])
+        for val in line[:-1]:
+            lines.append(f"{val:.2f}")
+    if len(lines) == 5:
+        raise exceptions.EmptyReportError()
+    sect.append(Table(children=lines, cols=5, rheaders=1))
diff --git a/myenv/lib/python3.9/site-packages/pylint/lint/run.py b/myenv/lib/python3.9/site-packages/pylint/lint/run.py
new file mode 100644
index 0000000..2d28cc4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/lint/run.py
@@ -0,0 +1,462 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import os
+import sys
+import warnings
+
+from pylint import __pkginfo__, extensions, interfaces
+from pylint.config.config_initialization import _config_initialization
+from pylint.constants import DEFAULT_PYLINT_HOME, OLD_DEFAULT_PYLINT_HOME, full_version
+from pylint.lint.pylinter import PyLinter
+from pylint.lint.utils import ArgumentPreprocessingError, preprocess_options
+from pylint.utils import print_full_documentation, utils
+
+try:
+    import multiprocessing
+    from multiprocessing import synchronize  # noqa pylint: disable=unused-import
+except ImportError:
+    multiprocessing = None  # type: ignore[assignment]
+
+
+def _cpu_count() -> int:
+    """Use sched_affinity if available for virtualized or containerized environments."""
+    sched_getaffinity = getattr(os, "sched_getaffinity", None)
+    # pylint: disable=not-callable,using-constant-test,useless-suppression
+    if sched_getaffinity:
+        return len(sched_getaffinity(0))
+    if multiprocessing:
+        return multiprocessing.cpu_count()
+    return 1
+
+
+def cb_list_extensions(option, optname, value, parser):
+    """List all the extensions under pylint.extensions."""
+
+    for filename in os.listdir(os.path.dirname(extensions.__file__)):
+        if filename.endswith(".py") and not filename.startswith("_"):
+            extension_name, _, _ = filename.partition(".")
+            print(f"pylint.extensions.{extension_name}")
+    sys.exit(0)
+
+
+def cb_list_confidence_levels(option, optname, value, parser):
+    for level in interfaces.CONFIDENCE_LEVELS:
+        print(f"%-18s: {level}")
+    sys.exit(0)
+
+
+def cb_init_hook(optname, value):
+    """Execute arbitrary code to set 'sys.path' for instance."""
+    exec(value)  # pylint: disable=exec-used
+
+
+UNUSED_PARAM_SENTINEL = object()
+
+
+class Run:
+    """Helper class to use as main for pylint with 'run(*sys.argv[1:])'."""
+
+    LinterClass = PyLinter
+    option_groups = (
+        (
+            "Commands",
+            "Options which are actually commands. Options in this \
+group are mutually exclusive.",
+        ),
+    )
+
+    @staticmethod
+    def _return_one(*args):  # pylint: disable=unused-argument
+        return 1
+
+    def __init__(
+        self,
+        args,
+        reporter=None,
+        exit=True,
+        do_exit=UNUSED_PARAM_SENTINEL,
+    ):  # pylint: disable=redefined-builtin
+        self._rcfile = None
+        self._output = None
+        self._version_asked = False
+        self._plugins = []
+        self.verbose = None
+        try:
+            preprocess_options(
+                args,
+                {
+                    # option: (callback, takearg)
+                    "version": (self.version_asked, False),
+                    "init-hook": (cb_init_hook, True),
+                    "rcfile": (self.cb_set_rcfile, True),
+                    "load-plugins": (self.cb_add_plugins, True),
+                    "enable-all-extensions": (self.cb_enable_all_extensions, False),
+                    "verbose": (self.cb_verbose_mode, False),
+                    "output": (self.cb_set_output, True),
+                },
+            )
+        except ArgumentPreprocessingError as ex:
+            print(ex, file=sys.stderr)
+            sys.exit(32)
+
+        self.linter = linter = self.LinterClass(
+            (
+                (
+                    "rcfile",
+                    {
+                        "action": "callback",
+                        "callback": Run._return_one,
+                        "group": "Commands",
+                        "type": "string",
+                        "metavar": "<file>",
+                        "help": "Specify a configuration file to load.",
+                    },
+                ),
+                (
+                    "output",
+                    {
+                        "action": "callback",
+                        "callback": Run._return_one,
+                        "group": "Commands",
+                        "type": "string",
+                        "metavar": "<file>",
+                        "help": "Specify an output file.",
+                    },
+                ),
+                (
+                    "init-hook",
+                    {
+                        "action": "callback",
+                        "callback": Run._return_one,
+                        "type": "string",
+                        "metavar": "<code>",
+                        "level": 1,
+                        "help": "Python code to execute, usually for sys.path "
+                        "manipulation such as pygtk.require().",
+                    },
+                ),
+                (
+                    "help-msg",
+                    {
+                        "action": "callback",
+                        "type": "string",
+                        "metavar": "<msg-id>",
+                        "callback": self.cb_help_message,
+                        "group": "Commands",
+                        "help": "Display a help message for the given message id and "
+                        "exit. The value may be a comma separated list of message ids.",
+                    },
+                ),
+                (
+                    "list-msgs",
+                    {
+                        "action": "callback",
+                        "metavar": "<msg-id>",
+                        "callback": self.cb_list_messages,
+                        "group": "Commands",
+                        "level": 1,
+                        "help": "Display a list of all pylint's messages divided by whether "
+                        "they are emittable with the given interpreter.",
+                    },
+                ),
+                (
+                    "list-msgs-enabled",
+                    {
+                        "action": "callback",
+                        "metavar": "<msg-id>",
+                        "callback": self.cb_list_messages_enabled,
+                        "group": "Commands",
+                        "level": 1,
+                        "help": "Display a list of what messages are enabled, "
+                        "disabled and non-emittable with the given configuration.",
+                    },
+                ),
+                (
+                    "list-groups",
+                    {
+                        "action": "callback",
+                        "metavar": "<msg-id>",
+                        "callback": self.cb_list_groups,
+                        "group": "Commands",
+                        "level": 1,
+                        "help": "List pylint's message groups.",
+                    },
+                ),
+                (
+                    "list-conf-levels",
+                    {
+                        "action": "callback",
+                        "callback": cb_list_confidence_levels,
+                        "group": "Commands",
+                        "level": 1,
+                        "help": "Generate pylint's confidence levels.",
+                    },
+                ),
+                (
+                    "list-extensions",
+                    {
+                        "action": "callback",
+                        "callback": cb_list_extensions,
+                        "group": "Commands",
+                        "level": 1,
+                        "help": "List available extensions.",
+                    },
+                ),
+                (
+                    "full-documentation",
+                    {
+                        "action": "callback",
+                        "metavar": "<msg-id>",
+                        "callback": self.cb_full_documentation,
+                        "group": "Commands",
+                        "level": 1,
+                        "help": "Generate pylint's full documentation.",
+                    },
+                ),
+                (
+                    "generate-rcfile",
+                    {
+                        "action": "callback",
+                        "callback": self.cb_generate_config,
+                        "group": "Commands",
+                        "help": "Generate a sample configuration file according to "
+                        "the current configuration. You can put other options "
+                        "before this one to get them in the generated "
+                        "configuration.",
+                    },
+                ),
+                (
+                    "generate-man",
+                    {
+                        "action": "callback",
+                        "callback": self.cb_generate_manpage,
+                        "group": "Commands",
+                        "help": "Generate pylint's man page.",
+                        "hide": True,
+                    },
+                ),
+                (
+                    "errors-only",
+                    {
+                        "action": "callback",
+                        "callback": self.cb_error_mode,
+                        "short": "E",
+                        "help": "In error mode, checkers without error messages are "
+                        "disabled and for others, only the ERROR messages are "
+                        "displayed, and no reports are done by default.",
+                    },
+                ),
+                (
+                    "verbose",
+                    {
+                        "action": "callback",
+                        "callback": self.cb_verbose_mode,
+                        "short": "v",
+                        "help": "In verbose mode, extra non-checker-related info "
+                        "will be displayed.",
+                    },
+                ),
+                (
+                    "enable-all-extensions",
+                    {
+                        "action": "callback",
+                        "callback": self.cb_enable_all_extensions,
+                        "help": "Load and enable all available extensions. "
+                        "Use --list-extensions to see a list all available extensions.",
+                    },
+                ),
+            ),
+            option_groups=self.option_groups,
+            pylintrc=self._rcfile,
+        )
+        # register standard checkers
+        if self._version_asked:
+            print(full_version)
+            sys.exit(0)
+        linter.load_default_plugins()
+        # load command line plugins
+        linter.load_plugin_modules(self._plugins)
+        # add some help section
+        linter.add_help_section(
+            "Environment variables",
+            f"""
+The following environment variables are used:
+    * PYLINTHOME
+    Path to the directory where persistent data for the run will be stored. If
+not found, it defaults to '{DEFAULT_PYLINT_HOME}' or '{OLD_DEFAULT_PYLINT_HOME}'
+(in the current working directory).
+    * PYLINTRC
+    Path to the configuration file. See the documentation for the method used
+to search for configuration file.
+""",
+            level=1,
+        )
+        linter.add_help_section(
+            "Output",
+            "Using the default text output, the message format is :                          \n"
+            "                                                                                \n"
+            "        MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE                                \n"
+            "                                                                                \n"
+            "There are 5 kind of message types :                                             \n"
+            "    * (C) convention, for programming standard violation                        \n"
+            "    * (R) refactor, for bad code smell                                          \n"
+            "    * (W) warning, for python specific problems                                 \n"
+            "    * (E) error, for probable bugs in the code                                  \n"
+            "    * (F) fatal, if an error occurred which prevented pylint from doing further\n"
+            "processing.\n",
+            level=1,
+        )
+        linter.add_help_section(
+            "Output status code",
+            "Pylint should leave with following status code:                                 \n"
+            "    * 0 if everything went fine                                                 \n"
+            "    * 1 if a fatal message was issued                                           \n"
+            "    * 2 if an error message was issued                                          \n"
+            "    * 4 if a warning message was issued                                         \n"
+            "    * 8 if a refactor message was issued                                        \n"
+            "    * 16 if a convention message was issued                                     \n"
+            "    * 32 on usage error                                                         \n"
+            "                                                                                \n"
+            "status 1 to 16 will be bit-ORed so you can know which different categories has\n"
+            "been issued by analysing pylint output status code\n",
+            level=1,
+        )
+        # read configuration
+        linter.disable("I")
+        linter.enable("c-extension-no-member")
+
+        args = _config_initialization(linter, args, reporter, verbose_mode=self.verbose)
+
+        if linter.config.jobs < 0:
+            print(
+                f"Jobs number ({linter.config.jobs}) should be greater than or equal to 0",
+                file=sys.stderr,
+            )
+            sys.exit(32)
+        if linter.config.jobs > 1 or linter.config.jobs == 0:
+            if multiprocessing is None:
+                print(
+                    "Multiprocessing library is missing, fallback to single process",
+                    file=sys.stderr,
+                )
+                linter.set_option("jobs", 1)
+            elif linter.config.jobs == 0:
+                linter.config.jobs = _cpu_count()
+
+        if self._output:
+            try:
+                with open(self._output, "w", encoding="utf-8") as output:
+                    linter.reporter.out = output
+                    linter.check(args)
+                    score_value = linter.generate_reports()
+            except OSError as ex:
+                print(ex, file=sys.stderr)
+                sys.exit(32)
+        else:
+            linter.check(args)
+            score_value = linter.generate_reports()
+
+        if do_exit is not UNUSED_PARAM_SENTINEL:
+            warnings.warn(
+                "do_exit is deprecated and it is going to be removed in a future version.",
+                DeprecationWarning,
+            )
+            exit = do_exit
+
+        if exit:
+            if linter.config.exit_zero:
+                sys.exit(0)
+            elif linter.any_fail_on_issues():
+                # We need to make sure we return a failing exit code in this case.
+                # So we use self.linter.msg_status if that is non-zero, otherwise we just return 1.
+                sys.exit(self.linter.msg_status or 1)
+            elif score_value is not None:
+                if score_value >= linter.config.fail_under:
+                    sys.exit(0)
+                else:
+                    # We need to make sure we return a failing exit code in this case.
+                    # So we use self.linter.msg_status if that is non-zero, otherwise we just return 1.
+                    sys.exit(self.linter.msg_status or 1)
+            else:
+                sys.exit(self.linter.msg_status)
+
+    def version_asked(self, _, __):
+        """Callback for version (i.e. before option parsing)."""
+        self._version_asked = True
+
+    def cb_set_rcfile(self, name, value):
+        """Callback for option preprocessing (i.e. before option parsing)."""
+        self._rcfile = value
+
+    def cb_set_output(self, name, value):
+        """Callback for option preprocessing (i.e. before option parsing)."""
+        self._output = value
+
+    def cb_add_plugins(self, name, value):
+        """Callback for option preprocessing (i.e. before option parsing)."""
+        self._plugins.extend(utils._splitstrip(value))
+
+    def cb_error_mode(self, *args, **kwargs):
+        """Callback for --errors-only.
+
+        Error mode:
+        * disable all but error messages
+        * disable the 'miscellaneous' checker which can be safely deactivated in
+          debug
+        * disable reports
+        * do not save execution information
+        """
+        self.linter.error_mode()
+
+    def cb_generate_config(self, *args, **kwargs):
+        """Optik callback for sample config file generation."""
+        self.linter.generate_config(skipsections=("COMMANDS",))
+        sys.exit(0)
+
+    def cb_generate_manpage(self, *args, **kwargs):
+        """Optik callback for sample config file generation."""
+        self.linter.generate_manpage(__pkginfo__)
+        sys.exit(0)
+
+    def cb_help_message(self, option, optname, value, parser):
+        """Optik callback for printing some help about a particular message."""
+        self.linter.msgs_store.help_message(utils._splitstrip(value))
+        sys.exit(0)
+
+    def cb_full_documentation(self, option, optname, value, parser):
+        """Optik callback for printing full documentation."""
+        print_full_documentation(self.linter)
+        sys.exit(0)
+
+    def cb_list_messages(self, option, optname, value, parser):
+        """Optik callback for printing available messages."""
+        self.linter.msgs_store.list_messages()
+        sys.exit(0)
+
+    def cb_list_messages_enabled(self, option, optname, value, parser):
+        """Optik callback for printing available messages."""
+        self.linter.list_messages_enabled()
+        sys.exit(0)
+
+    def cb_list_groups(self, *args, **kwargs):
+        """List all the check groups that pylint knows about.
+
+        These should be useful to know what check groups someone can disable
+        or enable.
+        """
+        for check in self.linter.get_checker_names():
+            print(check)
+        sys.exit(0)
+
+    def cb_verbose_mode(self, *args, **kwargs):
+        self.verbose = True
+
+    def cb_enable_all_extensions(self, option_name: str, value: None) -> None:
+        """Callback to load and enable all available extensions."""
+        for filename in os.listdir(os.path.dirname(extensions.__file__)):
+            if filename.endswith(".py") and not filename.startswith("_"):
+                extension_name = f"pylint.extensions.{filename[:-3]}"
+                if extension_name not in self._plugins:
+                    self._plugins.append(extension_name)
diff --git a/myenv/lib/python3.9/site-packages/pylint/lint/utils.py b/myenv/lib/python3.9/site-packages/pylint/lint/utils.py
new file mode 100644
index 0000000..7d402a0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/lint/utils.py
@@ -0,0 +1,137 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import contextlib
+import sys
+import traceback
+from datetime import datetime
+from pathlib import Path
+
+from pylint.config import PYLINT_HOME
+from pylint.lint.expand_modules import get_python_path
+
+
+class ArgumentPreprocessingError(Exception):
+    """Raised if an error occurs during argument preprocessing."""
+
+
+def prepare_crash_report(ex: Exception, filepath: str, crash_file_path: str) -> Path:
+    issue_template_path = (
+        Path(PYLINT_HOME) / datetime.now().strftime(str(crash_file_path))
+    ).resolve()
+    with open(filepath, encoding="utf8") as f:
+        file_content = f.read()
+    template = ""
+    if not issue_template_path.exists():
+        template = """\
+First, please verify that the bug is not already filled:
+https://github.com/PyCQA/pylint/issues/
+
+Then create a new crash issue:
+https://github.com/PyCQA/pylint/issues/new?assignees=&labels=crash%2Cneeds+triage&template=BUG-REPORT.yml
+
+"""
+    template += f"""\
+
+Issue title:
+Crash ``{ex}`` (if possible, be more specific about what made pylint crash)
+Content:
+When parsing the following file:
+
+<!--
+ If sharing the code is not an option, please state so,
+ but providing only the stacktrace would still be helpful.
+ -->
+
+```python
+{file_content}
+```
+
+pylint crashed with a ``{ex.__class__.__name__}`` and with the following stacktrace:
+```
+"""
+    template += traceback.format_exc()
+    template += "```\n"
+    try:
+        with open(issue_template_path, "a", encoding="utf8") as f:
+            f.write(template)
+    except Exception as exc:  # pylint: disable=broad-except
+        print(
+            f"Can't write the issue template for the crash in {issue_template_path} "
+            f"because of: '{exc}'\nHere's the content anyway:\n{template}."
+        )
+    return issue_template_path
+
+
+def get_fatal_error_message(filepath: str, issue_template_path: Path) -> str:
+    return (
+        f"Fatal error while checking '{filepath}'. "
+        f"Please open an issue in our bug tracker so we address this. "
+        f"There is a pre-filled template that you can use in '{issue_template_path}'."
+    )
+
+
+def preprocess_options(args, search_for):
+    """Look for some options (keys of <search_for>) which have to be processed
+    before others
+
+    values of <search_for> are callback functions to call when the option is
+    found
+    """
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if not arg.startswith("--"):
+            i += 1
+        else:
+            try:
+                option, val = arg[2:].split("=", 1)
+            except ValueError:
+                option, val = arg[2:], None
+            try:
+                cb, takearg = search_for[option]
+            except KeyError:
+                i += 1
+            else:
+                del args[i]
+                if takearg and val is None:
+                    if i >= len(args) or args[i].startswith("-"):
+                        msg = f"Option {option} expects a value"
+                        raise ArgumentPreprocessingError(msg)
+                    val = args[i]
+                    del args[i]
+                elif not takearg and val is not None:
+                    msg = f"Option {option} doesn't expects a value"
+                    raise ArgumentPreprocessingError(msg)
+                cb(option, val)
+
+
+def _patch_sys_path(args):
+    original = list(sys.path)
+    changes = []
+    seen = set()
+    for arg in args:
+        path = get_python_path(arg)
+        if path not in seen:
+            changes.append(path)
+            seen.add(path)
+
+    sys.path[:] = changes + sys.path
+    return original
+
+
+@contextlib.contextmanager
+def fix_import_path(args):
+    """Prepare 'sys.path' for running the linter checks.
+
+    Within this context, each of the given arguments is importable.
+    Paths are added to 'sys.path' in corresponding order to the arguments.
+    We avoid adding duplicate directories to sys.path.
+    `sys.path` is reset to its original value upon exiting this context.
+    """
+    original = _patch_sys_path(args)
+    try:
+        yield
+    finally:
+        sys.path[:] = original
diff --git a/myenv/lib/python3.9/site-packages/pylint/message/__init__.py b/myenv/lib/python3.9/site-packages/pylint/message/__init__.py
new file mode 100644
index 0000000..11d2b17
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/message/__init__.py
@@ -0,0 +1,17 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""All the classes related to Message handling."""
+
+from pylint.message.message import Message
+from pylint.message.message_definition import MessageDefinition
+from pylint.message.message_definition_store import MessageDefinitionStore
+from pylint.message.message_id_store import MessageIdStore
+
+__all__ = [
+    "Message",
+    "MessageDefinition",
+    "MessageDefinitionStore",
+    "MessageIdStore",
+]
diff --git a/myenv/lib/python3.9/site-packages/pylint/message/message.py b/myenv/lib/python3.9/site-packages/pylint/message/message.py
new file mode 100644
index 0000000..297442e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/message/message.py
@@ -0,0 +1,94 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import collections
+from typing import Optional, Tuple, Union, overload
+from warnings import warn
+
+from pylint.constants import MSG_TYPES
+from pylint.interfaces import Confidence
+from pylint.typing import MessageLocationTuple
+
+_MsgBase = collections.namedtuple(
+    "_MsgBase",
+    [
+        "msg_id",
+        "symbol",
+        "msg",
+        "C",
+        "category",
+        "confidence",
+        "abspath",
+        "path",
+        "module",
+        "obj",
+        "line",
+        "column",
+        "end_line",
+        "end_column",
+    ],
+)
+
+
+class Message(_MsgBase):
+    """This class represent a message to be issued by the reporters."""
+
+    @overload
+    def __new__(
+        cls,
+        msg_id: str,
+        symbol: str,
+        location: MessageLocationTuple,
+        msg: str,
+        confidence: Optional[Confidence],
+    ) -> "Message":
+        ...
+
+    @overload
+    def __new__(
+        cls,
+        msg_id: str,
+        symbol: str,
+        location: Tuple[str, str, str, str, int, int],
+        msg: str,
+        confidence: Optional[Confidence],
+    ) -> "Message":
+        # Remove for pylint 3.0
+        ...
+
+    def __new__(
+        cls,
+        msg_id: str,
+        symbol: str,
+        location: Union[
+            Tuple[str, str, str, str, int, int],
+            MessageLocationTuple,
+        ],
+        msg: str,
+        confidence: Optional[Confidence],
+    ) -> "Message":
+        if not isinstance(location, MessageLocationTuple):
+            warn(
+                "In pylint 3.0, Messages will only accept a MessageLocationTuple as location parameter",
+                DeprecationWarning,
+            )
+            location = location + (None, None)  # type: ignore[assignment] # Temporary fix until deprecation
+        return _MsgBase.__new__(
+            cls,
+            msg_id,
+            symbol,
+            msg,
+            msg_id[0],
+            MSG_TYPES[msg_id[0]],
+            confidence,
+            *location
+        )
+
+    def format(self, template: str) -> str:
+        """Format the message according to the given template.
+
+        The template format is the one of the format method :
+        cf. https://docs.python.org/2/library/string.html#formatstrings
+        """
+        return template.format(**self._asdict())
diff --git a/myenv/lib/python3.9/site-packages/pylint/message/message_definition.py b/myenv/lib/python3.9/site-packages/pylint/message/message_definition.py
new file mode 100644
index 0000000..a729e59
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/message/message_definition.py
@@ -0,0 +1,117 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import sys
+from typing import TYPE_CHECKING, List, Optional, Tuple
+
+from astroid import nodes
+
+from pylint.constants import _SCOPE_EXEMPT, MSG_TYPES, WarningScope
+from pylint.exceptions import InvalidMessageError
+from pylint.utils import normalize_text
+
+if TYPE_CHECKING:
+    from pylint.checkers import BaseChecker
+
+
+class MessageDefinition:
+    def __init__(
+        self,
+        checker: "BaseChecker",
+        msgid: str,
+        msg: str,
+        description: str,
+        symbol: str,
+        scope: str,
+        minversion: Optional[Tuple[int, int]] = None,
+        maxversion: Optional[Tuple[int, int]] = None,
+        old_names: Optional[List[Tuple[str, str]]] = None,
+    ) -> None:
+        self.checker_name = checker.name
+        self.check_msgid(msgid)
+        self.msgid = msgid
+        self.symbol = symbol
+        self.msg = msg
+        self.description = description
+        self.scope = scope
+        self.minversion = minversion
+        self.maxversion = maxversion
+        self.old_names: List[Tuple[str, str]] = []
+        if old_names:
+            for old_msgid, old_symbol in old_names:
+                self.check_msgid(old_msgid)
+                self.old_names.append(
+                    (old_msgid, old_symbol),
+                )
+
+    @staticmethod
+    def check_msgid(msgid: str) -> None:
+        if len(msgid) != 5:
+            raise InvalidMessageError(f"Invalid message id {msgid!r}")
+        if msgid[0] not in MSG_TYPES:
+            raise InvalidMessageError(f"Bad message type {msgid[0]} in {msgid!r}")
+
+    def __repr__(self) -> str:
+        return f"MessageDefinition:{self.symbol} ({self.msgid})"
+
+    def __str__(self) -> str:
+        return f"{repr(self)}:\n{self.msg} {self.description}"
+
+    def may_be_emitted(self) -> bool:
+        """Return True if message may be emitted using the current interpreter."""
+        if self.minversion is not None and self.minversion > sys.version_info:
+            return False
+        if self.maxversion is not None and self.maxversion <= sys.version_info:
+            return False
+        return True
+
+    def format_help(self, checkerref: bool = False) -> str:
+        """Return the help string for the given message id."""
+        desc = self.description
+        if checkerref:
+            desc += f" This message belongs to the {self.checker_name} checker."
+        title = self.msg
+        if self.minversion or self.maxversion:
+            restr = []
+            if self.minversion:
+                restr.append(f"< {'.'.join(str(n) for n in self.minversion)}")
+            if self.maxversion:
+                restr.append(f">= {'.'.join(str(n) for n in self.maxversion)}")
+            restriction = " or ".join(restr)
+            if checkerref:
+                desc += f" It can't be emitted when using Python {restriction}."
+            else:
+                desc += (
+                    f" This message can't be emitted when using Python {restriction}."
+                )
+        msg_help = normalize_text(" ".join(desc.split()), indent="  ")
+        message_id = f"{self.symbol} ({self.msgid})"
+        if title != "%s":
+            title = title.splitlines()[0]
+            return f":{message_id}: *{title.rstrip(' ')}*\n{msg_help}"
+        return f":{message_id}:\n{msg_help}"
+
+    def check_message_definition(
+        self, line: Optional[int], node: Optional[nodes.NodeNG]
+    ) -> None:
+        """Check MessageDefinition for possible errors."""
+        if self.msgid[0] not in _SCOPE_EXEMPT:
+            # Fatal messages and reports are special, the node/scope distinction
+            # does not apply to them.
+            if self.scope == WarningScope.LINE:
+                if line is None:
+                    raise InvalidMessageError(
+                        f"Message {self.msgid} must provide line, got None"
+                    )
+                if node is not None:
+                    raise InvalidMessageError(
+                        f"Message {self.msgid} must only provide line, "
+                        f"got line={line}, node={node}"
+                    )
+            elif self.scope == WarningScope.NODE:
+                # Node-based warnings may provide an override line.
+                if node is None:
+                    raise InvalidMessageError(
+                        f"Message {self.msgid} must provide Node, got None"
+                    )
diff --git a/myenv/lib/python3.9/site-packages/pylint/message/message_definition_store.py b/myenv/lib/python3.9/site-packages/pylint/message/message_definition_store.py
new file mode 100644
index 0000000..8974517
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/message/message_definition_store.py
@@ -0,0 +1,112 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import collections
+import functools
+from typing import TYPE_CHECKING, Dict, List, Tuple, ValuesView
+
+from pylint.exceptions import UnknownMessageError
+from pylint.message.message_definition import MessageDefinition
+from pylint.message.message_id_store import MessageIdStore
+
+if TYPE_CHECKING:
+    from pylint.checkers import BaseChecker
+
+
+class MessageDefinitionStore:
+
+    """The messages store knows information about every possible message definition but has
+    no particular state during analysis.
+    """
+
+    def __init__(self) -> None:
+        self.message_id_store: MessageIdStore = MessageIdStore()
+        # Primary registry for all active messages definitions.
+        # It contains the 1:1 mapping from msgid to MessageDefinition.
+        # Keys are msgid, values are MessageDefinition
+        self._messages_definitions: Dict[str, MessageDefinition] = {}
+        # MessageDefinition kept by category
+        self._msgs_by_category: Dict[str, List[str]] = collections.defaultdict(list)
+
+    @property
+    def messages(self) -> ValuesView[MessageDefinition]:
+        """The list of all active messages."""
+        return self._messages_definitions.values()
+
+    def register_messages_from_checker(self, checker: "BaseChecker") -> None:
+        """Register all messages definitions from a checker."""
+        checker.check_consistency()
+        for message in checker.messages:
+            self.register_message(message)
+
+    def register_message(self, message: MessageDefinition) -> None:
+        """Register a MessageDefinition with consistency in mind."""
+        self.message_id_store.register_message_definition(
+            message.msgid, message.symbol, message.old_names
+        )
+        self._messages_definitions[message.msgid] = message
+        self._msgs_by_category[message.msgid[0]].append(message.msgid)
+
+    # Since MessageDefinitionStore is only initialized once
+    # and the arguments are relatively small in size we do not run the
+    # risk of creating a large memory leak.
+    # See discussion in: https://github.com/PyCQA/pylint/pull/5673
+    @functools.lru_cache(maxsize=None)  # pylint: disable=cache-max-size-none
+    def get_message_definitions(self, msgid_or_symbol: str) -> List[MessageDefinition]:
+        """Returns the Message definition for either a numeric or symbolic id.
+
+        The cache has no limit as its size will likely stay minimal. For each message we store
+        about 1000 characters, so even if we would have 1000 messages the cache would only
+        take up ~= 1 Mb.
+        """
+        return [
+            self._messages_definitions[m]
+            for m in self.message_id_store.get_active_msgids(msgid_or_symbol)
+        ]
+
+    def get_msg_display_string(self, msgid_or_symbol: str) -> str:
+        """Generates a user-consumable representation of a message."""
+        message_definitions = self.get_message_definitions(msgid_or_symbol)
+        if len(message_definitions) == 1:
+            return repr(message_definitions[0].symbol)
+        return repr([md.symbol for md in message_definitions])
+
+    def help_message(self, msgids_or_symbols: List[str]) -> None:
+        """Display help messages for the given message identifiers."""
+        for msgids_or_symbol in msgids_or_symbols:
+            try:
+                for message_definition in self.get_message_definitions(
+                    msgids_or_symbol
+                ):
+                    print(message_definition.format_help(checkerref=True))
+                    print("")
+            except UnknownMessageError as ex:
+                print(ex)
+                print("")
+                continue
+
+    def list_messages(self) -> None:
+        """Output full messages list documentation in ReST format."""
+        emittable, non_emittable = self.find_emittable_messages()
+        print("Emittable messages with current interpreter:")
+        for msg in emittable:
+            print(msg.format_help(checkerref=False))
+        print("\nNon-emittable messages with current interpreter:")
+        for msg in non_emittable:
+            print(msg.format_help(checkerref=False))
+        print("")
+
+    def find_emittable_messages(
+        self,
+    ) -> Tuple[List[MessageDefinition], List[MessageDefinition]]:
+        """Finds all emittable and non-emittable messages."""
+        messages = sorted(self._messages_definitions.values(), key=lambda m: m.msgid)
+        emittable = []
+        non_emittable = []
+        for message in messages:
+            if message.may_be_emitted():
+                emittable.append(message)
+            else:
+                non_emittable.append(message)
+        return emittable, non_emittable
diff --git a/myenv/lib/python3.9/site-packages/pylint/message/message_id_store.py b/myenv/lib/python3.9/site-packages/pylint/message/message_id_store.py
new file mode 100644
index 0000000..d4ccbe6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/message/message_id_store.py
@@ -0,0 +1,135 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import Dict, List, NoReturn, Optional, Tuple
+
+from pylint.exceptions import InvalidMessageError, UnknownMessageError
+
+
+class MessageIdStore:
+
+    """The MessageIdStore store MessageId and make sure that there is a 1-1 relation between msgid and symbol."""
+
+    def __init__(self) -> None:
+        self.__msgid_to_symbol: Dict[str, str] = {}
+        self.__symbol_to_msgid: Dict[str, str] = {}
+        self.__old_names: Dict[str, List[str]] = {}
+        self.__active_msgids: Dict[str, List[str]] = {}
+
+    def __len__(self) -> int:
+        return len(self.__msgid_to_symbol)
+
+    def __repr__(self) -> str:
+        result = "MessageIdStore: [\n"
+        for msgid, symbol in self.__msgid_to_symbol.items():
+            result += f"  - {msgid} ({symbol})\n"
+        result += "]"
+        return result
+
+    def get_symbol(self, msgid: str) -> str:
+        try:
+            return self.__msgid_to_symbol[msgid.upper()]
+        except KeyError as e:
+            msg = f"'{msgid}' is not stored in the message store."
+            raise UnknownMessageError(msg) from e
+
+    def get_msgid(self, symbol: str) -> str:
+        try:
+            return self.__symbol_to_msgid[symbol]
+        except KeyError as e:
+            msg = f"'{symbol}' is not stored in the message store."
+            raise UnknownMessageError(msg) from e
+
+    def register_message_definition(
+        self, msgid: str, symbol: str, old_names: List[Tuple[str, str]]
+    ) -> None:
+        self.check_msgid_and_symbol(msgid, symbol)
+        self.add_msgid_and_symbol(msgid, symbol)
+        for old_msgid, old_symbol in old_names:
+            self.check_msgid_and_symbol(old_msgid, old_symbol)
+            self.add_legacy_msgid_and_symbol(old_msgid, old_symbol, msgid)
+
+    def add_msgid_and_symbol(self, msgid: str, symbol: str) -> None:
+        """Add valid message id.
+
+        There is a little duplication with add_legacy_msgid_and_symbol to avoid a function call,
+        this is called a lot at initialization.
+        """
+        self.__msgid_to_symbol[msgid] = symbol
+        self.__symbol_to_msgid[symbol] = msgid
+
+    def add_legacy_msgid_and_symbol(
+        self, msgid: str, symbol: str, new_msgid: str
+    ) -> None:
+        """Add valid legacy message id.
+
+        There is a little duplication with add_msgid_and_symbol to avoid a function call,
+        this is called a lot at initialization.
+        """
+        self.__msgid_to_symbol[msgid] = symbol
+        self.__symbol_to_msgid[symbol] = msgid
+        existing_old_names = self.__old_names.get(msgid, [])
+        existing_old_names.append(new_msgid)
+        self.__old_names[msgid] = existing_old_names
+
+    def check_msgid_and_symbol(self, msgid: str, symbol: str) -> None:
+        existing_msgid: Optional[str] = self.__symbol_to_msgid.get(symbol)
+        existing_symbol: Optional[str] = self.__msgid_to_symbol.get(msgid)
+        if existing_symbol is None and existing_msgid is None:
+            return  # both symbol and msgid are usable
+        if existing_msgid is not None:
+            if existing_msgid != msgid:
+                self._raise_duplicate_msgid(symbol, msgid, existing_msgid)
+        if existing_symbol and existing_symbol != symbol:
+            # See https://github.com/python/mypy/issues/10559
+            self._raise_duplicate_symbol(msgid, symbol, existing_symbol)
+
+    @staticmethod
+    def _raise_duplicate_symbol(msgid: str, symbol: str, other_symbol: str) -> NoReturn:
+        """Raise an error when a symbol is duplicated."""
+        symbols = [symbol, other_symbol]
+        symbols.sort()
+        error_message = f"Message id '{msgid}' cannot have both "
+        error_message += f"'{symbols[0]}' and '{symbols[1]}' as symbolic name."
+        raise InvalidMessageError(error_message)
+
+    @staticmethod
+    def _raise_duplicate_msgid(symbol: str, msgid: str, other_msgid: str) -> NoReturn:
+        """Raise an error when a msgid is duplicated."""
+        msgids = [msgid, other_msgid]
+        msgids.sort()
+        error_message = (
+            f"Message symbol '{symbol}' cannot be used for "
+            f"'{msgids[0]}' and '{msgids[1]}' at the same time."
+            f" If you're creating an 'old_names' use 'old-{symbol}' as the old symbol."
+        )
+        raise InvalidMessageError(error_message)
+
+    def get_active_msgids(self, msgid_or_symbol: str) -> List[str]:
+        """Return msgids but the input can be a symbol.
+
+        self.__active_msgids is used to implement a primitive cache for this function.
+        """
+        try:
+            return self.__active_msgids[msgid_or_symbol]
+        except KeyError:
+            pass
+
+        # If we don't have a cached value yet we compute it
+        msgid: Optional[str]
+        if msgid_or_symbol[1:].isdigit():
+            # Only msgid can have a digit as second letter
+            msgid = msgid_or_symbol.upper()
+            symbol = self.__msgid_to_symbol.get(msgid)
+        else:
+            msgid = self.__symbol_to_msgid.get(msgid_or_symbol)
+            symbol = msgid_or_symbol
+        if not msgid or not symbol:
+            error_msg = f"No such message id or symbol '{msgid_or_symbol}'."
+            raise UnknownMessageError(error_msg)
+        ids = self.__old_names.get(msgid, [msgid])
+
+        # Add to cache
+        self.__active_msgids[msgid_or_symbol] = ids
+        return ids
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/__init__.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/__init__.py
new file mode 100644
index 0000000..458c0f3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/__init__.py
@@ -0,0 +1,7 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Pyreverse.extensions."""
+
+__revision__ = "$Id $"
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/diadefslib.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/diadefslib.py
new file mode 100644
index 0000000..b5dd3fb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/diadefslib.py
@@ -0,0 +1,222 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Handle diagram generation options for class diagram or default diagrams."""
+
+from typing import Any, Optional
+
+import astroid
+from astroid import nodes
+
+from pylint.pyreverse.diagrams import ClassDiagram, PackageDiagram
+from pylint.pyreverse.inspector import Project
+from pylint.pyreverse.utils import LocalsVisitor
+
+# diagram generators ##########################################################
+
+
+class DiaDefGenerator:
+    """Handle diagram generation options."""
+
+    def __init__(self, linker, handler):
+        """Common Diagram Handler initialization."""
+        self.config = handler.config
+        self._set_default_options()
+        self.linker = linker
+        self.classdiagram = None  # defined by subclasses
+
+    def get_title(self, node):
+        """Get title for objects."""
+        title = node.name
+        if self.module_names:
+            title = f"{node.root().name}.{title}"
+        return title
+
+    def _set_option(self, option):
+        """Activate some options if not explicitly deactivated."""
+        # if we have a class diagram, we want more information by default;
+        # so if the option is None, we return True
+        if option is None:
+            return bool(self.config.classes)
+        return option
+
+    def _set_default_options(self):
+        """Set different default options with _default dictionary."""
+        self.module_names = self._set_option(self.config.module_names)
+        all_ancestors = self._set_option(self.config.all_ancestors)
+        all_associated = self._set_option(self.config.all_associated)
+        anc_level, association_level = (0, 0)
+        if all_ancestors:
+            anc_level = -1
+        if all_associated:
+            association_level = -1
+        if self.config.show_ancestors is not None:
+            anc_level = self.config.show_ancestors
+        if self.config.show_associated is not None:
+            association_level = self.config.show_associated
+        self.anc_level, self.association_level = anc_level, association_level
+
+    def _get_levels(self):
+        """Help function for search levels."""
+        return self.anc_level, self.association_level
+
+    def show_node(self, node):
+        """True if builtins and not show_builtins."""
+        if self.config.show_builtin:
+            return True
+        return node.root().name != "builtins"
+
+    def add_class(self, node):
+        """Visit one class and add it to diagram."""
+        self.linker.visit(node)
+        self.classdiagram.add_object(self.get_title(node), node)
+
+    def get_ancestors(self, node, level):
+        """Return ancestor nodes of a class node."""
+        if level == 0:
+            return
+        for ancestor in node.ancestors(recurs=False):
+            if not self.show_node(ancestor):
+                continue
+            yield ancestor
+
+    def get_associated(self, klass_node, level):
+        """Return associated nodes of a class node."""
+        if level == 0:
+            return
+        for association_nodes in list(klass_node.instance_attrs_type.values()) + list(
+            klass_node.locals_type.values()
+        ):
+            for node in association_nodes:
+                if isinstance(node, astroid.Instance):
+                    node = node._proxied
+                if not (isinstance(node, nodes.ClassDef) and self.show_node(node)):
+                    continue
+                yield node
+
+    def extract_classes(self, klass_node, anc_level, association_level):
+        """Extract recursively classes related to klass_node."""
+        if self.classdiagram.has_node(klass_node) or not self.show_node(klass_node):
+            return
+        self.add_class(klass_node)
+
+        for ancestor in self.get_ancestors(klass_node, anc_level):
+            self.extract_classes(ancestor, anc_level - 1, association_level)
+
+        for node in self.get_associated(klass_node, association_level):
+            self.extract_classes(node, anc_level, association_level - 1)
+
+
+class DefaultDiadefGenerator(LocalsVisitor, DiaDefGenerator):
+    """Generate minimum diagram definition for the project :
+
+    * a package diagram including project's modules
+    * a class diagram including project's classes
+    """
+
+    def __init__(self, linker, handler):
+        DiaDefGenerator.__init__(self, linker, handler)
+        LocalsVisitor.__init__(self)
+
+    def visit_project(self, node: Project) -> None:
+        """Visit a pyreverse.utils.Project node.
+
+        create a diagram definition for packages
+        """
+        mode = self.config.mode
+        if len(node.modules) > 1:
+            self.pkgdiagram: Optional[PackageDiagram] = PackageDiagram(
+                f"packages {node.name}", mode
+            )
+        else:
+            self.pkgdiagram = None
+        self.classdiagram = ClassDiagram(f"classes {node.name}", mode)
+
+    def leave_project(self, _: Project) -> Any:
+        """Leave the pyreverse.utils.Project node.
+
+        return the generated diagram definition
+        """
+        if self.pkgdiagram:
+            return self.pkgdiagram, self.classdiagram
+        return (self.classdiagram,)
+
+    def visit_module(self, node: nodes.Module) -> None:
+        """Visit an astroid.Module node.
+
+        add this class to the package diagram definition
+        """
+        if self.pkgdiagram:
+            self.linker.visit(node)
+            self.pkgdiagram.add_object(node.name, node)
+
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        """Visit an astroid.Class node.
+
+        add this class to the class diagram definition
+        """
+        anc_level, association_level = self._get_levels()
+        self.extract_classes(node, anc_level, association_level)
+
+    def visit_importfrom(self, node: nodes.ImportFrom) -> None:
+        """Visit astroid.ImportFrom  and catch modules for package diagram."""
+        if self.pkgdiagram:
+            self.pkgdiagram.add_from_depend(node, node.modname)
+
+
+class ClassDiadefGenerator(DiaDefGenerator):
+    """Generate a class diagram definition including all classes related to a
+    given class
+    """
+
+    def class_diagram(self, project, klass):
+        """Return a class diagram definition for the given klass and its
+        related klasses
+        """
+
+        self.classdiagram = ClassDiagram(klass, self.config.mode)
+        if len(project.modules) > 1:
+            module, klass = klass.rsplit(".", 1)
+            module = project.get_module(module)
+        else:
+            module = project.modules[0]
+            klass = klass.split(".")[-1]
+        klass = next(module.ilookup(klass))
+
+        anc_level, association_level = self._get_levels()
+        self.extract_classes(klass, anc_level, association_level)
+        return self.classdiagram
+
+
+# diagram handler #############################################################
+
+
+class DiadefsHandler:
+    """Get diagram definitions from user (i.e. xml files) or generate them."""
+
+    def __init__(self, config):
+        self.config = config
+
+    def get_diadefs(self, project, linker):
+        """Get the diagram's configuration data.
+
+        :param project:The pyreverse project
+        :type project: pyreverse.utils.Project
+        :param linker: The linker
+        :type linker: pyreverse.inspector.Linker(IdGeneratorMixIn, LocalsVisitor)
+
+        :returns: The list of diagram definitions
+        :rtype: list(:class:`pylint.pyreverse.diagrams.ClassDiagram`)
+        """
+
+        #  read and interpret diagram definitions (Diadefs)
+        diagrams = []
+        generator = ClassDiadefGenerator(linker, self)
+        for klass in self.config.classes:
+            diagrams.append(generator.class_diagram(project, klass))
+        if not diagrams:
+            diagrams = DefaultDiadefGenerator(linker, self).visit(project)
+        for diagram in diagrams:
+            diagram.extract_relationships()
+        return diagrams
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/diagrams.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/diagrams.py
new file mode 100644
index 0000000..2ad5091
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/diagrams.py
@@ -0,0 +1,260 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Diagram objects."""
+import astroid
+from astroid import nodes
+
+from pylint.checkers.utils import decorated_with_property
+from pylint.pyreverse.utils import FilterMixIn, is_interface
+
+
+class Figure:
+    """Base class for counter handling."""
+
+
+class Relationship(Figure):
+    """A relationship from an object in the diagram to another."""
+
+    def __init__(self, from_object, to_object, relation_type, name=None):
+        super().__init__()
+        self.from_object = from_object
+        self.to_object = to_object
+        self.type = relation_type
+        self.name = name
+
+
+class DiagramEntity(Figure):
+    """A diagram object, i.e. a label associated to an astroid node."""
+
+    def __init__(self, title="No name", node=None):
+        super().__init__()
+        self.title = title
+        self.node = node
+
+
+class PackageEntity(DiagramEntity):
+    """A diagram object representing a package."""
+
+
+class ClassEntity(DiagramEntity):
+    """A diagram object representing a class."""
+
+    def __init__(self, title, node):
+        super().__init__(title=title, node=node)
+        self.attrs = None
+        self.methods = None
+
+
+class ClassDiagram(Figure, FilterMixIn):
+    """Main class diagram handling."""
+
+    TYPE = "class"
+
+    def __init__(self, title, mode):
+        FilterMixIn.__init__(self, mode)
+        Figure.__init__(self)
+        self.title = title
+        self.objects = []
+        self.relationships = {}
+        self._nodes = {}
+        self.depends = []
+
+    def get_relationships(self, role):
+        # sorted to get predictable (hence testable) results
+        return sorted(
+            self.relationships.get(role, ()),
+            key=lambda x: (x.from_object.fig_id, x.to_object.fig_id),
+        )
+
+    def add_relationship(self, from_object, to_object, relation_type, name=None):
+        """Create a relationship."""
+        rel = Relationship(from_object, to_object, relation_type, name)
+        self.relationships.setdefault(relation_type, []).append(rel)
+
+    def get_relationship(self, from_object, relation_type):
+        """Return a relationship or None."""
+        for rel in self.relationships.get(relation_type, ()):
+            if rel.from_object is from_object:
+                return rel
+        raise KeyError(relation_type)
+
+    def get_attrs(self, node):
+        """Return visible attributes, possibly with class name."""
+        attrs = []
+        properties = [
+            (n, m)
+            for n, m in node.items()
+            if isinstance(m, nodes.FunctionDef) and decorated_with_property(m)
+        ]
+        for node_name, associated_nodes in (
+            list(node.instance_attrs_type.items())
+            + list(node.locals_type.items())
+            + properties
+        ):
+            if not self.show_attr(node_name):
+                continue
+            names = self.class_names(associated_nodes)
+            if names:
+                node_name = f"{node_name} : {', '.join(names)}"
+            attrs.append(node_name)
+        return sorted(attrs)
+
+    def get_methods(self, node):
+        """Return visible methods."""
+        methods = [
+            m
+            for m in node.values()
+            if isinstance(m, nodes.FunctionDef)
+            and not isinstance(m, astroid.objects.Property)
+            and not decorated_with_property(m)
+            and self.show_attr(m.name)
+        ]
+        return sorted(methods, key=lambda n: n.name)
+
+    def add_object(self, title, node):
+        """Create a diagram object."""
+        assert node not in self._nodes
+        ent = DiagramEntity(title, node)
+        self._nodes[node] = ent
+        self.objects.append(ent)
+
+    def class_names(self, nodes_lst):
+        """Return class names if needed in diagram."""
+        names = []
+        for node in nodes_lst:
+            if isinstance(node, astroid.Instance):
+                node = node._proxied
+            if (
+                isinstance(node, (nodes.ClassDef, nodes.Name, nodes.Subscript))
+                and hasattr(node, "name")
+                and not self.has_node(node)
+            ):
+                if node.name not in names:
+                    node_name = node.name
+                    names.append(node_name)
+        return names
+
+    def nodes(self):
+        """Return the list of underlying nodes."""
+        return self._nodes.keys()
+
+    def has_node(self, node):
+        """Return true if the given node is included in the diagram."""
+        return node in self._nodes
+
+    def object_from_node(self, node):
+        """Return the diagram object mapped to node."""
+        return self._nodes[node]
+
+    def classes(self):
+        """Return all class nodes in the diagram."""
+        return [o for o in self.objects if isinstance(o.node, nodes.ClassDef)]
+
+    def classe(self, name):
+        """Return a class by its name, raise KeyError if not found."""
+        for klass in self.classes():
+            if klass.node.name == name:
+                return klass
+        raise KeyError(name)
+
+    def extract_relationships(self):
+        """Extract relationships between nodes in the diagram."""
+        for obj in self.classes():
+            node = obj.node
+            obj.attrs = self.get_attrs(node)
+            obj.methods = self.get_methods(node)
+            # shape
+            if is_interface(node):
+                obj.shape = "interface"
+            else:
+                obj.shape = "class"
+            # inheritance link
+            for par_node in node.ancestors(recurs=False):
+                try:
+                    par_obj = self.object_from_node(par_node)
+                    self.add_relationship(obj, par_obj, "specialization")
+                except KeyError:
+                    continue
+            # implements link
+            for impl_node in node.implements:
+                try:
+                    impl_obj = self.object_from_node(impl_node)
+                    self.add_relationship(obj, impl_obj, "implements")
+                except KeyError:
+                    continue
+            # associations link
+            for name, values in list(node.instance_attrs_type.items()) + list(
+                node.locals_type.items()
+            ):
+                for value in values:
+                    if value is astroid.Uninferable:
+                        continue
+                    if isinstance(value, astroid.Instance):
+                        value = value._proxied
+                    try:
+                        associated_obj = self.object_from_node(value)
+                        self.add_relationship(associated_obj, obj, "association", name)
+                    except KeyError:
+                        continue
+
+
+class PackageDiagram(ClassDiagram):
+    """Package diagram handling."""
+
+    TYPE = "package"
+
+    def modules(self):
+        """Return all module nodes in the diagram."""
+        return [o for o in self.objects if isinstance(o.node, nodes.Module)]
+
+    def module(self, name):
+        """Return a module by its name, raise KeyError if not found."""
+        for mod in self.modules():
+            if mod.node.name == name:
+                return mod
+        raise KeyError(name)
+
+    def get_module(self, name, node):
+        """Return a module by its name, looking also for relative imports;
+        raise KeyError if not found
+        """
+        for mod in self.modules():
+            mod_name = mod.node.name
+            if mod_name == name:
+                return mod
+            # search for fullname of relative import modules
+            package = node.root().name
+            if mod_name == f"{package}.{name}":
+                return mod
+            if mod_name == f"{package.rsplit('.', 1)[0]}.{name}":
+                return mod
+        raise KeyError(name)
+
+    def add_from_depend(self, node, from_module):
+        """Add dependencies created by from-imports."""
+        mod_name = node.root().name
+        obj = self.module(mod_name)
+        if from_module not in obj.node.depends:
+            obj.node.depends.append(from_module)
+
+    def extract_relationships(self):
+        """Extract relationships between nodes in the diagram."""
+        super().extract_relationships()
+        for obj in self.classes():
+            # ownership
+            try:
+                mod = self.object_from_node(obj.node.root())
+                self.add_relationship(obj, mod, "ownership")
+            except KeyError:
+                continue
+        for obj in self.modules():
+            obj.shape = "package"
+            # dependencies
+            for dep_name in obj.node.depends:
+                try:
+                    dep = self.get_module(dep_name, obj.node)
+                except KeyError:
+                    continue
+                self.add_relationship(obj, dep, "depends")
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/dot_printer.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/dot_printer.py
new file mode 100644
index 0000000..0cca0ab
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/dot_printer.py
@@ -0,0 +1,158 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Class to generate files in dot format and image formats supported by Graphviz."""
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Dict, FrozenSet, List, Optional
+
+from astroid import nodes
+
+from pylint.pyreverse.printer import EdgeType, Layout, NodeProperties, NodeType, Printer
+from pylint.pyreverse.utils import get_annotation_label
+
+ALLOWED_CHARSETS: FrozenSet[str] = frozenset(("utf-8", "iso-8859-1", "latin1"))
+SHAPES: Dict[NodeType, str] = {
+    NodeType.PACKAGE: "box",
+    NodeType.INTERFACE: "record",
+    NodeType.CLASS: "record",
+}
+ARROWS: Dict[EdgeType, Dict[str, str]] = {
+    EdgeType.INHERITS: dict(arrowtail="none", arrowhead="empty"),
+    EdgeType.IMPLEMENTS: dict(arrowtail="node", arrowhead="empty", style="dashed"),
+    EdgeType.ASSOCIATION: dict(
+        fontcolor="green", arrowtail="none", arrowhead="diamond", style="solid"
+    ),
+    EdgeType.USES: dict(arrowtail="none", arrowhead="open"),
+}
+
+
+class DotPrinter(Printer):
+    DEFAULT_COLOR = "black"
+
+    def __init__(
+        self,
+        title: str,
+        layout: Optional[Layout] = None,
+        use_automatic_namespace: Optional[bool] = None,
+    ):
+        layout = layout or Layout.BOTTOM_TO_TOP
+        self.charset = "utf-8"
+        super().__init__(title, layout, use_automatic_namespace)
+
+    def _open_graph(self) -> None:
+        """Emit the header lines."""
+        self.emit(f'digraph "{self.title}" {{')
+        if self.layout:
+            self.emit(f"rankdir={self.layout.value}")
+        if self.charset:
+            assert (
+                self.charset.lower() in ALLOWED_CHARSETS
+            ), f"unsupported charset {self.charset}"
+            self.emit(f'charset="{self.charset}"')
+
+    def emit_node(
+        self,
+        name: str,
+        type_: NodeType,
+        properties: Optional[NodeProperties] = None,
+    ) -> None:
+        """Create a new node.
+
+        Nodes can be classes, packages, participants etc.
+        """
+        if properties is None:
+            properties = NodeProperties(label=name)
+        shape = SHAPES[type_]
+        color = properties.color if properties.color is not None else self.DEFAULT_COLOR
+        style = "filled" if color != self.DEFAULT_COLOR else "solid"
+        label = self._build_label_for_node(properties)
+        label_part = f', label="{label}"' if label else ""
+        fontcolor_part = (
+            f', fontcolor="{properties.fontcolor}"' if properties.fontcolor else ""
+        )
+        self.emit(
+            f'"{name}" [color="{color}"{fontcolor_part}{label_part}, shape="{shape}", style="{style}"];'
+        )
+
+    def _build_label_for_node(
+        self, properties: NodeProperties, is_interface: Optional[bool] = False
+    ) -> str:
+        if not properties.label:
+            return ""
+
+        label: str = properties.label
+        if is_interface:
+            # add a stereotype
+            label = "<<interface>>\\n" + label
+
+        if properties.attrs is None and properties.methods is None:
+            # return a "compact" form which only displays the class name in a box
+            return label
+
+        # Add class attributes
+        attrs: List[str] = properties.attrs or []
+        label = "{" + label + "|" + r"\l".join(attrs) + r"\l|"
+
+        # Add class methods
+        methods: List[nodes.FunctionDef] = properties.methods or []
+        for func in methods:
+            args = self._get_method_arguments(func)
+            label += rf"{func.name}({', '.join(args)})"
+            if func.returns:
+                label += ": " + get_annotation_label(func.returns)
+            label += r"\l"
+        label += "}"
+        return label
+
+    def emit_edge(
+        self,
+        from_node: str,
+        to_node: str,
+        type_: EdgeType,
+        label: Optional[str] = None,
+    ) -> None:
+        """Create an edge from one node to another to display relationships."""
+        arrowstyle = ARROWS[type_]
+        attrs = [f'{prop}="{value}"' for prop, value in arrowstyle.items()]
+        if label:
+            attrs.append(f'label="{label}"')
+        self.emit(f'"{from_node}" -> "{to_node}" [{", ".join(sorted(attrs))}];')
+
+    def generate(self, outputfile: str) -> None:
+        self._close_graph()
+        graphviz_extensions = ("dot", "gv")
+        name = self.title
+        if outputfile is None:
+            target = "png"
+            pdot, dot_sourcepath = tempfile.mkstemp(".gv", name)
+            ppng, outputfile = tempfile.mkstemp(".png", name)
+            os.close(pdot)
+            os.close(ppng)
+        else:
+            target = Path(outputfile).suffix.lstrip(".")
+            if not target:
+                target = "png"
+                outputfile = outputfile + "." + target
+            if target not in graphviz_extensions:
+                pdot, dot_sourcepath = tempfile.mkstemp(".gv", name)
+                os.close(pdot)
+            else:
+                dot_sourcepath = outputfile
+        with open(dot_sourcepath, "w", encoding="utf8") as outfile:
+            outfile.writelines(self.lines)
+        if target not in graphviz_extensions:
+            use_shell = sys.platform == "win32"
+            subprocess.call(
+                ["dot", "-T", target, dot_sourcepath, "-o", outputfile],
+                shell=use_shell,
+            )
+            os.unlink(dot_sourcepath)
+
+    def _close_graph(self) -> None:
+        """Emit the lines needed to properly close the graph."""
+        self.emit("}\n")
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/inspector.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/inspector.py
new file mode 100644
index 0000000..91d2199
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/inspector.py
@@ -0,0 +1,333 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Visitor doing some postprocessing on the astroid tree.
+
+Try to resolve definitions (namespace) dictionary, relationship...
+"""
+import collections
+import os
+import traceback
+
+import astroid
+from astroid import nodes
+
+from pylint.pyreverse import utils
+
+
+def _iface_hdlr(_):
+    """Handler used by interfaces to handle suspicious interface nodes."""
+    return True
+
+
+def _astroid_wrapper(func, modname):
+    print(f"parsing {modname}...")
+    try:
+        return func(modname)
+    except astroid.exceptions.AstroidBuildingException as exc:
+        print(exc)
+    except Exception:  # pylint: disable=broad-except
+        traceback.print_exc()
+    return None
+
+
+def interfaces(node, herited=True, handler_func=_iface_hdlr):
+    """Return an iterator on interfaces implemented by the given class node."""
+    try:
+        implements = astroid.bases.Instance(node).getattr("__implements__")[0]
+    except astroid.exceptions.NotFoundError:
+        return
+    if not herited and implements.frame(future=True) is not node:
+        return
+    found = set()
+    missing = False
+    for iface in nodes.unpack_infer(implements):
+        if iface is astroid.Uninferable:
+            missing = True
+            continue
+        if iface not in found and handler_func(iface):
+            found.add(iface)
+            yield iface
+    if missing:
+        raise astroid.exceptions.InferenceError()
+
+
+class IdGeneratorMixIn:
+    """Mixin adding the ability to generate integer uid."""
+
+    def __init__(self, start_value=0):
+        self.id_count = start_value
+
+    def init_counter(self, start_value=0):
+        """Init the id counter."""
+        self.id_count = start_value
+
+    def generate_id(self):
+        """Generate a new identifier."""
+        self.id_count += 1
+        return self.id_count
+
+
+class Project:
+    """A project handle a set of modules / packages."""
+
+    def __init__(self, name=""):
+        self.name = name
+        self.uid = None
+        self.path = None
+        self.modules = []
+        self.locals = {}
+        self.__getitem__ = self.locals.__getitem__
+        self.__iter__ = self.locals.__iter__
+        self.values = self.locals.values
+        self.keys = self.locals.keys
+        self.items = self.locals.items
+
+    def add_module(self, node):
+        self.locals[node.name] = node
+        self.modules.append(node)
+
+    def get_module(self, name):
+        return self.locals[name]
+
+    def get_children(self):
+        return self.modules
+
+    def __repr__(self):
+        return f"<Project {self.name!r} at {id(self)} ({len(self.modules)} modules)>"
+
+
+class Linker(IdGeneratorMixIn, utils.LocalsVisitor):
+    """Walk on the project tree and resolve relationships.
+
+    According to options the following attributes may be
+    added to visited nodes:
+
+    * uid,
+      a unique identifier for the node (on astroid.Project, astroid.Module,
+      astroid.Class and astroid.locals_type). Only if the linker
+      has been instantiated with tag=True parameter (False by default).
+
+    * Function
+      a mapping from locals names to their bounded value, which may be a
+      constant like a string or an integer, or an astroid node
+      (on astroid.Module, astroid.Class and astroid.Function).
+
+    * instance_attrs_type
+      as locals_type but for klass member attributes (only on astroid.Class)
+
+    * implements,
+      list of implemented interface _objects_ (only on astroid.Class nodes)
+    """
+
+    def __init__(self, project, inherited_interfaces=0, tag=False):
+        IdGeneratorMixIn.__init__(self)
+        utils.LocalsVisitor.__init__(self)
+        # take inherited interface in consideration or not
+        self.inherited_interfaces = inherited_interfaces
+        # tag nodes or not
+        self.tag = tag
+        # visited project
+        self.project = project
+
+    def visit_project(self, node: Project) -> None:
+        """Visit a pyreverse.utils.Project node.
+
+        * optionally tag the node with a unique id
+        """
+        if self.tag:
+            node.uid = self.generate_id()
+        for module in node.modules:
+            self.visit(module)
+
+    def visit_module(self, node: nodes.Module) -> None:
+        """Visit an astroid.Module node.
+
+        * set the locals_type mapping
+        * set the depends mapping
+        * optionally tag the node with a unique id
+        """
+        if hasattr(node, "locals_type"):
+            return
+        node.locals_type = collections.defaultdict(list)
+        node.depends = []
+        if self.tag:
+            node.uid = self.generate_id()
+
+    def visit_classdef(self, node: nodes.ClassDef) -> None:
+        """Visit an astroid.Class node.
+
+        * set the locals_type and instance_attrs_type mappings
+        * set the implements list and build it
+        * optionally tag the node with a unique id
+        """
+        if hasattr(node, "locals_type"):
+            return
+        node.locals_type = collections.defaultdict(list)
+        if self.tag:
+            node.uid = self.generate_id()
+        # resolve ancestors
+        for baseobj in node.ancestors(recurs=False):
+            specializations = getattr(baseobj, "specializations", [])
+            specializations.append(node)
+            baseobj.specializations = specializations
+        # resolve instance attributes
+        node.instance_attrs_type = collections.defaultdict(list)
+        for assignattrs in node.instance_attrs.values():
+            for assignattr in assignattrs:
+                if not isinstance(assignattr, nodes.Unknown):
+                    self.handle_assignattr_type(assignattr, node)
+        # resolve implemented interface
+        try:
+            node.implements = list(interfaces(node, self.inherited_interfaces))
+        except astroid.InferenceError:
+            node.implements = []
+
+    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
+        """Visit an astroid.Function node.
+
+        * set the locals_type mapping
+        * optionally tag the node with a unique id
+        """
+        if hasattr(node, "locals_type"):
+            return
+        node.locals_type = collections.defaultdict(list)
+        if self.tag:
+            node.uid = self.generate_id()
+
+    link_project = visit_project
+    link_module = visit_module
+    link_class = visit_classdef
+    link_function = visit_functiondef
+
+    def visit_assignname(self, node: nodes.AssignName) -> None:
+        """Visit an astroid.AssignName node.
+
+        handle locals_type
+        """
+        # avoid double parsing done by different Linkers.visit
+        # running over the same project:
+        if hasattr(node, "_handled"):
+            return
+        node._handled = True
+        if node.name in node.frame(future=True):
+            frame = node.frame(future=True)
+        else:
+            # the name has been defined as 'global' in the frame and belongs
+            # there.
+            frame = node.root()
+        if not hasattr(frame, "locals_type"):
+            # If the frame doesn't have a locals_type yet,
+            # it means it wasn't yet visited. Visit it now
+            # to add what's missing from it.
+            if isinstance(frame, nodes.ClassDef):
+                self.visit_classdef(frame)
+            elif isinstance(frame, nodes.FunctionDef):
+                self.visit_functiondef(frame)
+            else:
+                self.visit_module(frame)
+
+        current = frame.locals_type[node.name]
+        frame.locals_type[node.name] = list(set(current) | utils.infer_node(node))
+
+    @staticmethod
+    def handle_assignattr_type(node, parent):
+        """Handle an astroid.assignattr node.
+
+        handle instance_attrs_type
+        """
+        current = set(parent.instance_attrs_type[node.attrname])
+        parent.instance_attrs_type[node.attrname] = list(
+            current | utils.infer_node(node)
+        )
+
+    def visit_import(self, node: nodes.Import) -> None:
+        """Visit an astroid.Import node.
+
+        resolve module dependencies
+        """
+        context_file = node.root().file
+        for name in node.names:
+            relative = astroid.modutils.is_relative(name[0], context_file)
+            self._imported_module(node, name[0], relative)
+
+    def visit_importfrom(self, node: nodes.ImportFrom) -> None:
+        """Visit an astroid.ImportFrom node.
+
+        resolve module dependencies
+        """
+        basename = node.modname
+        context_file = node.root().file
+        if context_file is not None:
+            relative = astroid.modutils.is_relative(basename, context_file)
+        else:
+            relative = False
+        for name in node.names:
+            if name[0] == "*":
+                continue
+            # analyze dependencies
+            fullname = f"{basename}.{name[0]}"
+            if fullname.find(".") > -1:
+                try:
+                    fullname = astroid.modutils.get_module_part(fullname, context_file)
+                except ImportError:
+                    continue
+            if fullname != basename:
+                self._imported_module(node, fullname, relative)
+
+    def compute_module(self, context_name, mod_path):
+        """Return true if the module should be added to dependencies."""
+        package_dir = os.path.dirname(self.project.path)
+        if context_name == mod_path:
+            return 0
+        if astroid.modutils.is_standard_module(mod_path, (package_dir,)):
+            return 1
+        return 0
+
+    def _imported_module(self, node, mod_path, relative):
+        """Notify an imported module, used to analyze dependencies."""
+        module = node.root()
+        context_name = module.name
+        if relative:
+            mod_path = f"{'.'.join(context_name.split('.')[:-1])}.{mod_path}"
+        if self.compute_module(context_name, mod_path):
+            # handle dependencies
+            if not hasattr(module, "depends"):
+                module.depends = []
+            mod_paths = module.depends
+            if mod_path not in mod_paths:
+                mod_paths.append(mod_path)
+
+
+def project_from_files(
+    files, func_wrapper=_astroid_wrapper, project_name="no name", black_list=("CVS",)
+):
+    """Return a Project from a list of files or modules."""
+    # build the project representation
+    astroid_manager = astroid.manager.AstroidManager()
+    project = Project(project_name)
+    for something in files:
+        if not os.path.exists(something):
+            fpath = astroid.modutils.file_from_modpath(something.split("."))
+        elif os.path.isdir(something):
+            fpath = os.path.join(something, "__init__.py")
+        else:
+            fpath = something
+        ast = func_wrapper(astroid_manager.ast_from_file, fpath)
+        if ast is None:
+            continue
+        project.path = project.path or ast.file
+        project.add_module(ast)
+        base_name = ast.name
+        # recurse in package except if __init__ was explicitly given
+        if ast.package and something.find("__init__") == -1:
+            # recurse on others packages / modules if this is a package
+            for fpath in astroid.modutils.get_module_files(
+                os.path.dirname(ast.file), black_list
+            ):
+                ast = func_wrapper(astroid_manager.ast_from_file, fpath)
+                if ast is None or ast.name == base_name:
+                    continue
+                project.add_module(ast)
+    return project
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/main.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/main.py
new file mode 100644
index 0000000..ceaa123
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/main.py
@@ -0,0 +1,234 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""%prog [options] <packages>.
+
+  create UML diagrams for classes and modules in <packages>
+"""
+import sys
+from typing import Iterable
+
+from pylint.config import ConfigurationMixIn
+from pylint.lint.utils import fix_import_path
+from pylint.pyreverse import writer
+from pylint.pyreverse.diadefslib import DiadefsHandler
+from pylint.pyreverse.inspector import Linker, project_from_files
+from pylint.pyreverse.utils import (
+    check_graphviz_availability,
+    check_if_graphviz_supports_format,
+    insert_default_options,
+)
+
+DIRECTLY_SUPPORTED_FORMATS = (
+    "dot",
+    "vcg",
+    "puml",
+    "plantuml",
+    "mmd",
+    "html",
+)
+
+OPTIONS = (
+    (
+        "filter-mode",
+        dict(
+            short="f",
+            default="PUB_ONLY",
+            dest="mode",
+            type="string",
+            action="store",
+            metavar="<mode>",
+            help="""filter attributes and functions according to
+    <mode>. Correct modes are :
+                            'PUB_ONLY' filter all non public attributes
+                                [DEFAULT], equivalent to PRIVATE+SPECIAL_A
+                            'ALL' no filter
+                            'SPECIAL' filter Python special functions
+                                except constructor
+                            'OTHER' filter protected and private
+                                attributes""",
+        ),
+    ),
+    (
+        "class",
+        dict(
+            short="c",
+            action="append",
+            metavar="<class>",
+            dest="classes",
+            default=[],
+            help="create a class diagram with all classes related to <class>;\
+ this uses by default the options -ASmy",
+        ),
+    ),
+    (
+        "show-ancestors",
+        dict(
+            short="a",
+            action="store",
+            metavar="<ancestor>",
+            type="int",
+            help="show <ancestor> generations of ancestor classes not in <projects>",
+        ),
+    ),
+    (
+        "all-ancestors",
+        dict(
+            short="A",
+            default=None,
+            help="show all ancestors off all classes in <projects>",
+        ),
+    ),
+    (
+        "show-associated",
+        dict(
+            short="s",
+            action="store",
+            metavar="<association_level>",
+            type="int",
+            help="show <association_level> levels of associated classes not in <projects>",
+        ),
+    ),
+    (
+        "all-associated",
+        dict(
+            short="S",
+            default=None,
+            help="show recursively all associated off all associated classes",
+        ),
+    ),
+    (
+        "show-builtin",
+        dict(
+            short="b",
+            action="store_true",
+            default=False,
+            help="include builtin objects in representation of classes",
+        ),
+    ),
+    (
+        "module-names",
+        dict(
+            short="m",
+            default=None,
+            type="yn",
+            metavar="<y or n>",
+            help="include module name in representation of classes",
+        ),
+    ),
+    (
+        "only-classnames",
+        dict(
+            short="k",
+            action="store_true",
+            default=False,
+            help="don't show attributes and methods in the class boxes; this disables -f values",
+        ),
+    ),
+    (
+        "output",
+        dict(
+            short="o",
+            dest="output_format",
+            action="store",
+            default="dot",
+            metavar="<format>",
+            help=(
+                f"create a *.<format> output file if format is available. Available formats are: {', '.join(DIRECTLY_SUPPORTED_FORMATS)}. "
+                f"Any other format will be tried to create by means of the 'dot' command line tool, which requires a graphviz installation."
+            ),
+        ),
+    ),
+    (
+        "colorized",
+        dict(
+            dest="colorized",
+            action="store_true",
+            default=False,
+            help="Use colored output. Classes/modules of the same package get the same color.",
+        ),
+    ),
+    (
+        "max-color-depth",
+        dict(
+            dest="max_color_depth",
+            action="store",
+            default=2,
+            metavar="<depth>",
+            type="int",
+            help="Use separate colors up to package depth of <depth>",
+        ),
+    ),
+    (
+        "ignore",
+        dict(
+            type="csv",
+            metavar="<file[,file...]>",
+            dest="ignore_list",
+            default=("CVS",),
+            help="Files or directories to be skipped. They should be base names, not paths.",
+        ),
+    ),
+    (
+        "project",
+        dict(
+            default="",
+            type="string",
+            short="p",
+            metavar="<project name>",
+            help="set the project name.",
+        ),
+    ),
+    (
+        "output-directory",
+        dict(
+            default="",
+            type="string",
+            short="d",
+            action="store",
+            metavar="<output_directory>",
+            help="set the output directory path.",
+        ),
+    ),
+)
+
+
+class Run(ConfigurationMixIn):
+    """Base class providing common behaviour for pyreverse commands."""
+
+    options = OPTIONS
+
+    def __init__(self, args: Iterable[str]):
+        super().__init__(usage=__doc__)
+        insert_default_options()
+        args = self.load_command_line_configuration(args)
+        if self.config.output_format not in DIRECTLY_SUPPORTED_FORMATS:
+            check_graphviz_availability()
+            print(
+                f"Format {self.config.output_format} is not supported natively. Pyreverse will try to generate it using Graphviz..."
+            )
+            check_if_graphviz_supports_format(self.config.output_format)
+
+        sys.exit(self.run(args))
+
+    def run(self, args):
+        """Checking arguments and run project."""
+        if not args:
+            print(self.help())
+            return 1
+        with fix_import_path(args):
+            project = project_from_files(
+                args,
+                project_name=self.config.project,
+                black_list=self.config.ignore_list,
+            )
+        linker = Linker(project, tag=True)
+        handler = DiadefsHandler(self.config)
+        diadefs = handler.get_diadefs(project, linker)
+        writer.DiagramWriter(self.config).write(diadefs)
+        return 0
+
+
+if __name__ == "__main__":
+    Run(sys.argv[1:])
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/mermaidjs_printer.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/mermaidjs_printer.py
new file mode 100644
index 0000000..b1b56fc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/mermaidjs_printer.py
@@ -0,0 +1,110 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Class to generate files in mermaidjs format."""
+from typing import Dict, Optional
+
+from pylint.pyreverse.printer import EdgeType, NodeProperties, NodeType, Printer
+from pylint.pyreverse.utils import get_annotation_label
+
+
+class MermaidJSPrinter(Printer):
+    """Printer for MermaidJS diagrams."""
+
+    DEFAULT_COLOR = "black"
+
+    NODES: Dict[NodeType, str] = {
+        NodeType.CLASS: "class",
+        NodeType.INTERFACE: "class",
+        NodeType.PACKAGE: "class",
+    }
+    ARROWS: Dict[EdgeType, str] = {
+        EdgeType.INHERITS: "--|>",
+        EdgeType.IMPLEMENTS: "..|>",
+        EdgeType.ASSOCIATION: "--*",
+        EdgeType.USES: "-->",
+    }
+
+    def _open_graph(self) -> None:
+        """Emit the header lines."""
+        self.emit("classDiagram")
+        self._inc_indent()
+
+    def emit_node(
+        self,
+        name: str,
+        type_: NodeType,
+        properties: Optional[NodeProperties] = None,
+    ) -> None:
+        """Create a new node.
+
+        Nodes can be classes, packages, participants etc.
+        """
+        if properties is None:
+            properties = NodeProperties(label=name)
+        stereotype = "~~Interface~~" if type_ is NodeType.INTERFACE else ""
+        nodetype = self.NODES[type_]
+        body = []
+        if properties.attrs:
+            body.extend(properties.attrs)
+        if properties.methods:
+            for func in properties.methods:
+                args = self._get_method_arguments(func)
+                line = f"{func.name}({', '.join(args)})"
+                if func.returns:
+                    line += " -> " + get_annotation_label(func.returns)
+                body.append(line)
+        name = name.split(".")[-1]
+        self.emit(f"{nodetype} {name}{stereotype} {{")
+        self._inc_indent()
+        for line in body:
+            self.emit(line)
+        self._dec_indent()
+        self.emit("}")
+
+    def emit_edge(
+        self,
+        from_node: str,
+        to_node: str,
+        type_: EdgeType,
+        label: Optional[str] = None,
+    ) -> None:
+        """Create an edge from one node to another to display relationships."""
+        from_node = from_node.split(".")[-1]
+        to_node = to_node.split(".")[-1]
+        edge = f"{from_node} {self.ARROWS[type_]} {to_node}"
+        if label:
+            edge += f" : {label}"
+        self.emit(edge)
+
+    def _close_graph(self) -> None:
+        """Emit the lines needed to properly close the graph."""
+        self._dec_indent()
+
+
+class HTMLMermaidJSPrinter(MermaidJSPrinter):
+    """Printer for MermaidJS diagrams wrapped in a html boilerplate."""
+
+    HTML_OPEN_BOILERPLATE = """<html>
+  <body>
+    <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
+      <div class="mermaid">
+    """
+    HTML_CLOSE_BOILERPLATE = """
+       </div>
+  </body>
+</html>
+"""
+    GRAPH_INDENT_LEVEL = 4
+
+    def _open_graph(self) -> None:
+        self.emit(self.HTML_OPEN_BOILERPLATE)
+        for _ in range(self.GRAPH_INDENT_LEVEL):
+            self._inc_indent()
+        super()._open_graph()
+
+    def _close_graph(self) -> None:
+        for _ in range(self.GRAPH_INDENT_LEVEL):
+            self._dec_indent()
+        self.emit(self.HTML_CLOSE_BOILERPLATE)
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/plantuml_printer.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/plantuml_printer.py
new file mode 100644
index 0000000..57fe3a9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/plantuml_printer.py
@@ -0,0 +1,97 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Class to generate files in dot format and image formats supported by Graphviz."""
+from typing import Dict, Optional
+
+from pylint.pyreverse.printer import EdgeType, Layout, NodeProperties, NodeType, Printer
+from pylint.pyreverse.utils import get_annotation_label
+
+
+class PlantUmlPrinter(Printer):
+    """Printer for PlantUML diagrams."""
+
+    DEFAULT_COLOR = "black"
+
+    NODES: Dict[NodeType, str] = {
+        NodeType.CLASS: "class",
+        NodeType.INTERFACE: "class",
+        NodeType.PACKAGE: "package",
+    }
+    ARROWS: Dict[EdgeType, str] = {
+        EdgeType.INHERITS: "--|>",
+        EdgeType.IMPLEMENTS: "..|>",
+        EdgeType.ASSOCIATION: "--*",
+        EdgeType.USES: "-->",
+    }
+
+    def _open_graph(self) -> None:
+        """Emit the header lines."""
+        self.emit("@startuml " + self.title)
+        if not self.use_automatic_namespace:
+            self.emit("set namespaceSeparator none")
+        if self.layout:
+            if self.layout is Layout.LEFT_TO_RIGHT:
+                self.emit("left to right direction")
+            elif self.layout is Layout.TOP_TO_BOTTOM:
+                self.emit("top to bottom direction")
+            else:
+                raise ValueError(
+                    f"Unsupported layout {self.layout}. PlantUmlPrinter only supports left to right and top to bottom layout."
+                )
+
+    def emit_node(
+        self,
+        name: str,
+        type_: NodeType,
+        properties: Optional[NodeProperties] = None,
+    ) -> None:
+        """Create a new node.
+
+        Nodes can be classes, packages, participants etc.
+        """
+        if properties is None:
+            properties = NodeProperties(label=name)
+        stereotype = " << interface >>" if type_ is NodeType.INTERFACE else ""
+        nodetype = self.NODES[type_]
+        if properties.color and properties.color != self.DEFAULT_COLOR:
+            color = f" #{properties.color}"
+        else:
+            color = ""
+        body = []
+        if properties.attrs:
+            body.extend(properties.attrs)
+        if properties.methods:
+            for func in properties.methods:
+                args = self._get_method_arguments(func)
+                line = f"{func.name}({', '.join(args)})"
+                if func.returns:
+                    line += " -> " + get_annotation_label(func.returns)
+                body.append(line)
+        label = properties.label if properties.label is not None else name
+        if properties.fontcolor and properties.fontcolor != self.DEFAULT_COLOR:
+            label = f"<color:{properties.fontcolor}>{label}</color>"
+        self.emit(f'{nodetype} "{label}" as {name}{stereotype}{color} {{')
+        self._inc_indent()
+        for line in body:
+            self.emit(line)
+        self._dec_indent()
+        self.emit("}")
+
+    def emit_edge(
+        self,
+        from_node: str,
+        to_node: str,
+        type_: EdgeType,
+        label: Optional[str] = None,
+    ) -> None:
+        """Create an edge from one node to another to display relationships."""
+        edge = f"{from_node} {self.ARROWS[type_]} {to_node}"
+        if label:
+            edge += f" : {label}"
+        self.emit(edge)
+
+    def _close_graph(self) -> None:
+        """Emit the lines needed to properly close the graph."""
+        self.emit("@enduml")
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/printer.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/printer.py
new file mode 100644
index 0000000..43cc534
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/printer.py
@@ -0,0 +1,127 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Base class defining the interface for a printer."""
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import List, NamedTuple, Optional
+
+from astroid import nodes
+
+from pylint.pyreverse.utils import get_annotation_label
+
+
+class NodeType(Enum):
+    CLASS = "class"
+    INTERFACE = "interface"
+    PACKAGE = "package"
+
+
+class EdgeType(Enum):
+    INHERITS = "inherits"
+    IMPLEMENTS = "implements"
+    ASSOCIATION = "association"
+    USES = "uses"
+
+
+class Layout(Enum):
+    LEFT_TO_RIGHT = "LR"
+    RIGHT_TO_LEFT = "RL"
+    TOP_TO_BOTTOM = "TB"
+    BOTTOM_TO_TOP = "BT"
+
+
+class NodeProperties(NamedTuple):
+    label: str
+    attrs: Optional[List[str]] = None
+    methods: Optional[List[nodes.FunctionDef]] = None
+    color: Optional[str] = None
+    fontcolor: Optional[str] = None
+
+
+class Printer(ABC):
+    """Base class defining the interface for a printer."""
+
+    def __init__(
+        self,
+        title: str,
+        layout: Optional[Layout] = None,
+        use_automatic_namespace: Optional[bool] = None,
+    ) -> None:
+        self.title: str = title
+        self.layout = layout
+        self.use_automatic_namespace = use_automatic_namespace
+        self.lines: List[str] = []
+        self._indent = ""
+        self._open_graph()
+
+    def _inc_indent(self) -> None:
+        """Increment indentation."""
+        self._indent += "  "
+
+    def _dec_indent(self) -> None:
+        """Decrement indentation."""
+        self._indent = self._indent[:-2]
+
+    @abstractmethod
+    def _open_graph(self) -> None:
+        """Emit the header lines, i.e. all boilerplate code that defines things like layout etc."""
+
+    def emit(self, line: str, force_newline: Optional[bool] = True) -> None:
+        if force_newline and not line.endswith("\n"):
+            line += "\n"
+        self.lines.append(self._indent + line)
+
+    @abstractmethod
+    def emit_node(
+        self,
+        name: str,
+        type_: NodeType,
+        properties: Optional[NodeProperties] = None,
+    ) -> None:
+        """Create a new node.
+
+        Nodes can be classes, packages, participants etc.
+        """
+
+    @abstractmethod
+    def emit_edge(
+        self,
+        from_node: str,
+        to_node: str,
+        type_: EdgeType,
+        label: Optional[str] = None,
+    ) -> None:
+        """Create an edge from one node to another to display relationships."""
+
+    @staticmethod
+    def _get_method_arguments(method: nodes.FunctionDef) -> List[str]:
+        if method.args.args is None:
+            return []
+
+        first_arg = 0 if method.type in {"function", "staticmethod"} else 1
+        arguments: List[nodes.AssignName] = method.args.args[first_arg:]
+
+        annotations = dict(zip(arguments, method.args.annotations[first_arg:]))
+        for arg in arguments:
+            annotation_label = ""
+            ann = annotations.get(arg)
+            if ann:
+                annotation_label = get_annotation_label(ann)
+            annotations[arg] = annotation_label
+
+        return [
+            f"{arg.name}: {ann}" if ann else f"{arg.name}"
+            for arg, ann in annotations.items()
+        ]
+
+    def generate(self, outputfile: str) -> None:
+        """Generate and save the final outputfile."""
+        self._close_graph()
+        with open(outputfile, "w", encoding="utf-8") as outfile:
+            outfile.writelines(self.lines)
+
+    @abstractmethod
+    def _close_graph(self) -> None:
+        """Emit the lines needed to properly close the graph."""
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/printer_factory.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/printer_factory.py
new file mode 100644
index 0000000..29a406b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/printer_factory.py
@@ -0,0 +1,24 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import Dict, Type
+
+from pylint.pyreverse.dot_printer import DotPrinter
+from pylint.pyreverse.mermaidjs_printer import HTMLMermaidJSPrinter, MermaidJSPrinter
+from pylint.pyreverse.plantuml_printer import PlantUmlPrinter
+from pylint.pyreverse.printer import Printer
+from pylint.pyreverse.vcg_printer import VCGPrinter
+
+filetype_to_printer: Dict[str, Type[Printer]] = {
+    "vcg": VCGPrinter,
+    "plantuml": PlantUmlPrinter,
+    "puml": PlantUmlPrinter,
+    "mmd": MermaidJSPrinter,
+    "html": HTMLMermaidJSPrinter,
+    "dot": DotPrinter,
+}
+
+
+def get_printer_for_filetype(filetype: str) -> Type[Printer]:
+    return filetype_to_printer.get(filetype, DotPrinter)
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/utils.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/utils.py
new file mode 100644
index 0000000..8b27928
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/utils.py
@@ -0,0 +1,306 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Generic classes/functions for pyreverse core/extensions."""
+import os
+import re
+import shutil
+import subprocess
+import sys
+from typing import Optional, Union
+
+import astroid
+from astroid import nodes
+
+RCFILE = ".pyreverserc"
+
+
+def get_default_options():
+    """Read config file and return list of options."""
+    options = []
+    home = os.environ.get("HOME", "")
+    if home:
+        rcfile = os.path.join(home, RCFILE)
+        try:
+            with open(rcfile, encoding="utf-8") as file_handle:
+                options = file_handle.read().split()
+        except OSError:
+            pass  # ignore if no config file found
+    return options
+
+
+def insert_default_options():
+    """Insert default options to sys.argv."""
+    options = get_default_options()
+    options.reverse()
+    for arg in options:
+        sys.argv.insert(1, arg)
+
+
+# astroid utilities ###########################################################
+SPECIAL = re.compile(r"^__([^\W_]_*)+__$")
+PRIVATE = re.compile(r"^__(_*[^\W_])+_?$")
+PROTECTED = re.compile(r"^_\w*$")
+
+
+def get_visibility(name):
+    """Return the visibility from a name: public, protected, private or special."""
+    if SPECIAL.match(name):
+        visibility = "special"
+    elif PRIVATE.match(name):
+        visibility = "private"
+    elif PROTECTED.match(name):
+        visibility = "protected"
+
+    else:
+        visibility = "public"
+    return visibility
+
+
+ABSTRACT = re.compile(r"^.*Abstract.*")
+FINAL = re.compile(r"^[^\W\da-z]*$")
+
+
+def is_abstract(node):
+    """Return true if the given class node correspond to an abstract class
+    definition
+    """
+    return ABSTRACT.match(node.name)
+
+
+def is_final(node):
+    """Return true if the given class/function node correspond to final
+    definition
+    """
+    return FINAL.match(node.name)
+
+
+def is_interface(node):
+    # bw compat
+    return node.type == "interface"
+
+
+def is_exception(node):
+    # bw compat
+    return node.type == "exception"
+
+
+# Helpers #####################################################################
+
+_CONSTRUCTOR = 1
+_SPECIAL = 2
+_PROTECTED = 4
+_PRIVATE = 8
+MODES = {
+    "ALL": 0,
+    "PUB_ONLY": _SPECIAL + _PROTECTED + _PRIVATE,
+    "SPECIAL": _SPECIAL,
+    "OTHER": _PROTECTED + _PRIVATE,
+}
+VIS_MOD = {
+    "special": _SPECIAL,
+    "protected": _PROTECTED,
+    "private": _PRIVATE,
+    "public": 0,
+}
+
+
+class FilterMixIn:
+    """Filter nodes according to a mode and nodes' visibility."""
+
+    def __init__(self, mode):
+        """Init filter modes."""
+        __mode = 0
+        for nummod in mode.split("+"):
+            try:
+                __mode += MODES[nummod]
+            except KeyError as ex:
+                print(f"Unknown filter mode {ex}", file=sys.stderr)
+        self.__mode = __mode
+
+    def show_attr(self, node):
+        """Return true if the node should be treated."""
+        visibility = get_visibility(getattr(node, "name", node))
+        return not self.__mode & VIS_MOD[visibility]
+
+
+class ASTWalker:
+    """A walker visiting a tree in preorder, calling on the handler:.
+
+    * visit_<class name> on entering a node, where class name is the class of
+    the node in lower case
+
+    * leave_<class name> on leaving a node, where class name is the class of
+    the node in lower case
+    """
+
+    def __init__(self, handler):
+        self.handler = handler
+        self._cache = {}
+
+    def walk(self, node, _done=None):
+        """Walk on the tree from <node>, getting callbacks from handler."""
+        if _done is None:
+            _done = set()
+        if node in _done:
+            raise AssertionError((id(node), node, node.parent))
+        _done.add(node)
+        self.visit(node)
+        for child_node in node.get_children():
+            assert child_node is not node
+            self.walk(child_node, _done)
+        self.leave(node)
+        assert node.parent is not node
+
+    def get_callbacks(self, node):
+        """Get callbacks from handler for the visited node."""
+        klass = node.__class__
+        methods = self._cache.get(klass)
+        if methods is None:
+            handler = self.handler
+            kid = klass.__name__.lower()
+            e_method = getattr(
+                handler, f"visit_{kid}", getattr(handler, "visit_default", None)
+            )
+            l_method = getattr(
+                handler, f"leave_{kid}", getattr(handler, "leave_default", None)
+            )
+            self._cache[klass] = (e_method, l_method)
+        else:
+            e_method, l_method = methods
+        return e_method, l_method
+
+    def visit(self, node):
+        """Walk on the tree from <node>, getting callbacks from handler."""
+        method = self.get_callbacks(node)[0]
+        if method is not None:
+            method(node)
+
+    def leave(self, node):
+        """Walk on the tree from <node>, getting callbacks from handler."""
+        method = self.get_callbacks(node)[1]
+        if method is not None:
+            method(node)
+
+
+class LocalsVisitor(ASTWalker):
+    """Visit a project by traversing the locals dictionary."""
+
+    def __init__(self):
+        super().__init__(self)
+        self._visited = set()
+
+    def visit(self, node):
+        """Launch the visit starting from the given node."""
+        if node in self._visited:
+            return None
+
+        self._visited.add(node)
+        methods = self.get_callbacks(node)
+        if methods[0] is not None:
+            methods[0](node)
+        if hasattr(node, "locals"):  # skip Instance and other proxy
+            for local_node in node.values():
+                self.visit(local_node)
+        if methods[1] is not None:
+            return methods[1](node)
+        return None
+
+
+def get_annotation_label(ann: Union[nodes.Name, nodes.NodeNG]) -> str:
+    if isinstance(ann, nodes.Name) and ann.name is not None:
+        return ann.name
+    if isinstance(ann, nodes.NodeNG):
+        return ann.as_string()
+    return ""
+
+
+def get_annotation(
+    node: Union[nodes.AssignAttr, nodes.AssignName]
+) -> Optional[Union[nodes.Name, nodes.Subscript]]:
+    """Return the annotation for `node`."""
+    ann = None
+    if isinstance(node.parent, nodes.AnnAssign):
+        ann = node.parent.annotation
+    elif isinstance(node, nodes.AssignAttr):
+        init_method = node.parent.parent
+        try:
+            annotations = dict(zip(init_method.locals, init_method.args.annotations))
+            ann = annotations.get(node.parent.value.name)
+        except AttributeError:
+            pass
+    else:
+        return ann
+
+    try:
+        default, *_ = node.infer()
+    except astroid.InferenceError:
+        default = ""
+
+    label = get_annotation_label(ann)
+    if ann:
+        label = (
+            rf"Optional[{label}]"
+            if getattr(default, "value", "value") is None
+            and not label.startswith("Optional")
+            else label
+        )
+    if label:
+        ann.name = label
+    return ann
+
+
+def infer_node(node: Union[nodes.AssignAttr, nodes.AssignName]) -> set:
+    """Return a set containing the node annotation if it exists
+    otherwise return a set of the inferred types using the NodeNG.infer method
+    """
+
+    ann = get_annotation(node)
+    try:
+        if ann:
+            if isinstance(ann, nodes.Subscript):
+                return {ann}
+            return set(ann.infer())
+        return set(node.infer())
+    except astroid.InferenceError:
+        return {ann} if ann else set()
+
+
+def check_graphviz_availability():
+    """Check if the ``dot`` command is available on the machine.
+
+    This is needed if image output is desired and ``dot`` is used to convert
+    from *.dot or *.gv into the final output format.
+    """
+    if shutil.which("dot") is None:
+        print("'Graphviz' needs to be installed for your chosen output format.")
+        sys.exit(32)
+
+
+def check_if_graphviz_supports_format(output_format: str) -> None:
+    """Check if the ``dot`` command supports the requested output format.
+
+    This is needed if image output is desired and ``dot`` is used to convert
+    from *.gv into the final output format.
+    """
+    dot_output = subprocess.run(
+        ["dot", "-T?"], capture_output=True, check=False, encoding="utf-8"
+    )
+    match = re.match(
+        pattern=r".*Use one of: (?P<formats>(\S*\s?)+)",
+        string=dot_output.stderr.strip(),
+    )
+    if not match:
+        print(
+            "Unable to determine Graphviz supported output formats. "
+            "Pyreverse will continue, but subsequent error messages "
+            "regarding the output format may come from Graphviz directly."
+        )
+        return
+    supported_formats = match.group("formats")
+    if output_format not in supported_formats.split():
+        print(
+            f"Format {output_format} is not supported by Graphviz. It supports: {supported_formats}"
+        )
+        sys.exit(32)
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/vcg_printer.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/vcg_printer.py
new file mode 100644
index 0000000..fa5e90a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/vcg_printer.py
@@ -0,0 +1,283 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Functions to generate files readable with Georg Sander's vcg
+(Visualization of Compiler Graphs).
+
+You can download vcg at https://rw4.cs.uni-sb.de/~sander/html/gshome.html
+Note that vcg exists as a debian package.
+See vcg's documentation for explanation about the different values that
+maybe used for the functions parameters.
+"""
+from typing import Any, Dict, Mapping, Optional
+
+from pylint.pyreverse.printer import EdgeType, Layout, NodeProperties, NodeType, Printer
+
+ATTRS_VAL = {
+    "algos": (
+        "dfs",
+        "tree",
+        "minbackward",
+        "left_to_right",
+        "right_to_left",
+        "top_to_bottom",
+        "bottom_to_top",
+        "maxdepth",
+        "maxdepthslow",
+        "mindepth",
+        "mindepthslow",
+        "mindegree",
+        "minindegree",
+        "minoutdegree",
+        "maxdegree",
+        "maxindegree",
+        "maxoutdegree",
+    ),
+    "booleans": ("yes", "no"),
+    "colors": (
+        "black",
+        "white",
+        "blue",
+        "red",
+        "green",
+        "yellow",
+        "magenta",
+        "lightgrey",
+        "cyan",
+        "darkgrey",
+        "darkblue",
+        "darkred",
+        "darkgreen",
+        "darkyellow",
+        "darkmagenta",
+        "darkcyan",
+        "gold",
+        "lightblue",
+        "lightred",
+        "lightgreen",
+        "lightyellow",
+        "lightmagenta",
+        "lightcyan",
+        "lilac",
+        "turquoise",
+        "aquamarine",
+        "khaki",
+        "purple",
+        "yellowgreen",
+        "pink",
+        "orange",
+        "orchid",
+    ),
+    "shapes": ("box", "ellipse", "rhomb", "triangle"),
+    "textmodes": ("center", "left_justify", "right_justify"),
+    "arrowstyles": ("solid", "line", "none"),
+    "linestyles": ("continuous", "dashed", "dotted", "invisible"),
+}
+
+# meaning of possible values:
+#   O    -> string
+#   1    -> int
+#   list -> value in list
+GRAPH_ATTRS = {
+    "title": 0,
+    "label": 0,
+    "color": ATTRS_VAL["colors"],
+    "textcolor": ATTRS_VAL["colors"],
+    "bordercolor": ATTRS_VAL["colors"],
+    "width": 1,
+    "height": 1,
+    "borderwidth": 1,
+    "textmode": ATTRS_VAL["textmodes"],
+    "shape": ATTRS_VAL["shapes"],
+    "shrink": 1,
+    "stretch": 1,
+    "orientation": ATTRS_VAL["algos"],
+    "vertical_order": 1,
+    "horizontal_order": 1,
+    "xspace": 1,
+    "yspace": 1,
+    "layoutalgorithm": ATTRS_VAL["algos"],
+    "late_edge_labels": ATTRS_VAL["booleans"],
+    "display_edge_labels": ATTRS_VAL["booleans"],
+    "dirty_edge_labels": ATTRS_VAL["booleans"],
+    "finetuning": ATTRS_VAL["booleans"],
+    "manhattan_edges": ATTRS_VAL["booleans"],
+    "smanhattan_edges": ATTRS_VAL["booleans"],
+    "port_sharing": ATTRS_VAL["booleans"],
+    "edges": ATTRS_VAL["booleans"],
+    "nodes": ATTRS_VAL["booleans"],
+    "splines": ATTRS_VAL["booleans"],
+}
+NODE_ATTRS = {
+    "title": 0,
+    "label": 0,
+    "color": ATTRS_VAL["colors"],
+    "textcolor": ATTRS_VAL["colors"],
+    "bordercolor": ATTRS_VAL["colors"],
+    "width": 1,
+    "height": 1,
+    "borderwidth": 1,
+    "textmode": ATTRS_VAL["textmodes"],
+    "shape": ATTRS_VAL["shapes"],
+    "shrink": 1,
+    "stretch": 1,
+    "vertical_order": 1,
+    "horizontal_order": 1,
+}
+EDGE_ATTRS = {
+    "sourcename": 0,
+    "targetname": 0,
+    "label": 0,
+    "linestyle": ATTRS_VAL["linestyles"],
+    "class": 1,
+    "thickness": 0,
+    "color": ATTRS_VAL["colors"],
+    "textcolor": ATTRS_VAL["colors"],
+    "arrowcolor": ATTRS_VAL["colors"],
+    "backarrowcolor": ATTRS_VAL["colors"],
+    "arrowsize": 1,
+    "backarrowsize": 1,
+    "arrowstyle": ATTRS_VAL["arrowstyles"],
+    "backarrowstyle": ATTRS_VAL["arrowstyles"],
+    "textmode": ATTRS_VAL["textmodes"],
+    "priority": 1,
+    "anchor": 1,
+    "horizontal_order": 1,
+}
+SHAPES: Dict[NodeType, str] = {
+    NodeType.PACKAGE: "box",
+    NodeType.CLASS: "box",
+    NodeType.INTERFACE: "ellipse",
+}
+ARROWS: Dict[EdgeType, Dict] = {
+    EdgeType.USES: dict(arrowstyle="solid", backarrowstyle="none", backarrowsize=0),
+    EdgeType.INHERITS: dict(
+        arrowstyle="solid", backarrowstyle="none", backarrowsize=10
+    ),
+    EdgeType.IMPLEMENTS: dict(
+        arrowstyle="solid",
+        backarrowstyle="none",
+        linestyle="dotted",
+        backarrowsize=10,
+    ),
+    EdgeType.ASSOCIATION: dict(
+        arrowstyle="solid", backarrowstyle="none", textcolor="green"
+    ),
+}
+ORIENTATION: Dict[Layout, str] = {
+    Layout.LEFT_TO_RIGHT: "left_to_right",
+    Layout.RIGHT_TO_LEFT: "right_to_left",
+    Layout.TOP_TO_BOTTOM: "top_to_bottom",
+    Layout.BOTTOM_TO_TOP: "bottom_to_top",
+}
+
+# Misc utilities ###############################################################
+
+
+class VCGPrinter(Printer):
+    def _open_graph(self) -> None:
+        """Emit the header lines."""
+        self.emit("graph:{\n")
+        self._inc_indent()
+        self._write_attributes(
+            GRAPH_ATTRS,
+            title=self.title,
+            layoutalgorithm="dfs",
+            late_edge_labels="yes",
+            port_sharing="no",
+            manhattan_edges="yes",
+        )
+        if self.layout:
+            self._write_attributes(GRAPH_ATTRS, orientation=ORIENTATION[self.layout])
+
+    def _close_graph(self) -> None:
+        """Emit the lines needed to properly close the graph."""
+        self._dec_indent()
+        self.emit("}")
+
+    def emit_node(
+        self,
+        name: str,
+        type_: NodeType,
+        properties: Optional[NodeProperties] = None,
+    ) -> None:
+        """Create a new node.
+
+        Nodes can be classes, packages, participants etc.
+        """
+        if properties is None:
+            properties = NodeProperties(label=name)
+        elif properties.label is None:
+            properties.label = name
+        self.emit(f'node: {{title:"{name}"', force_newline=False)
+        self._write_attributes(
+            NODE_ATTRS,
+            label=self._build_label_for_node(properties),
+            shape=SHAPES[type_],
+        )
+        self.emit("}")
+
+    @staticmethod
+    def _build_label_for_node(properties: NodeProperties) -> str:
+        fontcolor = "\f09" if properties.fontcolor == "red" else ""
+        label = rf"\fb{fontcolor}{properties.label}\fn"
+        if properties.attrs is None and properties.methods is None:
+            # return a compact form which only displays the classname in a box
+            return label
+        attrs = properties.attrs or []
+        methods = properties.methods or []
+        method_names = [func.name for func in methods]
+        # box width for UML like diagram
+        maxlen = max(len(name) for name in [properties.label] + method_names + attrs)
+        line = "_" * (maxlen + 2)
+        label = rf"{label}\n\f{line}"
+        for attr in attrs:
+            label = rf"{label}\n\f08{attr}"
+        if attrs:
+            label = rf"{label}\n\f{line}"
+        for func in method_names:
+            label = rf"{label}\n\f10{func}()"
+        return label
+
+    def emit_edge(
+        self,
+        from_node: str,
+        to_node: str,
+        type_: EdgeType,
+        label: Optional[str] = None,
+    ) -> None:
+        """Create an edge from one node to another to display relationships."""
+        self.emit(
+            f'edge: {{sourcename:"{from_node}" targetname:"{to_node}"',
+            force_newline=False,
+        )
+        attributes = ARROWS[type_]
+        if label:
+            attributes["label"] = label
+        self._write_attributes(
+            EDGE_ATTRS,
+            **attributes,
+        )
+        self.emit("}")
+
+    def _write_attributes(self, attributes_dict: Mapping[str, Any], **args) -> None:
+        """Write graph, node or edge attributes."""
+        for key, value in args.items():
+            try:
+                _type = attributes_dict[key]
+            except KeyError as e:
+                raise Exception(
+                    f"no such attribute {key}\npossible attributes are {attributes_dict.keys()}"
+                ) from e
+
+            if not _type:
+                self.emit(f'{key}:"{value}"\n')
+            elif _type == 1:
+                self.emit(f"{key}:{int(value)}\n")
+            elif value in _type:
+                self.emit(f"{key}:{value}\n")
+            else:
+                raise Exception(
+                    f"value {value} isn't correct for attribute {key} correct values are {type}"
+                )
diff --git a/myenv/lib/python3.9/site-packages/pylint/pyreverse/writer.py b/myenv/lib/python3.9/site-packages/pylint/pyreverse/writer.py
new file mode 100644
index 0000000..a3120e6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/pyreverse/writer.py
@@ -0,0 +1,161 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Utilities for creating VCG and Dot diagrams."""
+
+import itertools
+import os
+
+from astroid import modutils, nodes
+
+from pylint.pyreverse.diagrams import (
+    ClassDiagram,
+    ClassEntity,
+    DiagramEntity,
+    PackageDiagram,
+    PackageEntity,
+)
+from pylint.pyreverse.printer import EdgeType, NodeProperties, NodeType
+from pylint.pyreverse.printer_factory import get_printer_for_filetype
+from pylint.pyreverse.utils import is_exception
+
+
+class DiagramWriter:
+    """Base class for writing project diagrams."""
+
+    def __init__(self, config):
+        self.config = config
+        self.printer_class = get_printer_for_filetype(self.config.output_format)
+        self.printer = None  # defined in set_printer
+        self.file_name = ""  # defined in set_printer
+        self.depth = self.config.max_color_depth
+        self.available_colors = itertools.cycle(
+            [
+                "aliceblue",
+                "antiquewhite",
+                "aquamarine",
+                "burlywood",
+                "cadetblue",
+                "chartreuse",
+                "chocolate",
+                "coral",
+                "cornflowerblue",
+                "cyan",
+                "darkgoldenrod",
+                "darkseagreen",
+                "dodgerblue",
+                "forestgreen",
+                "gold",
+                "hotpink",
+                "mediumspringgreen",
+            ]
+        )
+        self.used_colors = {}
+
+    def write(self, diadefs):
+        """Write files for <project> according to <diadefs>."""
+        for diagram in diadefs:
+            basename = diagram.title.strip().replace(" ", "_")
+            file_name = f"{basename}.{self.config.output_format}"
+            if os.path.exists(self.config.output_directory):
+                file_name = os.path.join(self.config.output_directory, file_name)
+            self.set_printer(file_name, basename)
+            if diagram.TYPE == "class":
+                self.write_classes(diagram)
+            else:
+                self.write_packages(diagram)
+            self.save()
+
+    def write_packages(self, diagram: PackageDiagram) -> None:
+        """Write a package diagram."""
+        # sorted to get predictable (hence testable) results
+        for module in sorted(diagram.modules(), key=lambda x: x.title):
+            module.fig_id = module.node.qname()
+            self.printer.emit_node(
+                module.fig_id,
+                type_=NodeType.PACKAGE,
+                properties=self.get_package_properties(module),
+            )
+        # package dependencies
+        for rel in diagram.get_relationships("depends"):
+            self.printer.emit_edge(
+                rel.from_object.fig_id,
+                rel.to_object.fig_id,
+                type_=EdgeType.USES,
+            )
+
+    def write_classes(self, diagram: ClassDiagram) -> None:
+        """Write a class diagram."""
+        # sorted to get predictable (hence testable) results
+        for obj in sorted(diagram.objects, key=lambda x: x.title):
+            obj.fig_id = obj.node.qname()
+            type_ = NodeType.INTERFACE if obj.shape == "interface" else NodeType.CLASS
+            self.printer.emit_node(
+                obj.fig_id, type_=type_, properties=self.get_class_properties(obj)
+            )
+        # inheritance links
+        for rel in diagram.get_relationships("specialization"):
+            self.printer.emit_edge(
+                rel.from_object.fig_id,
+                rel.to_object.fig_id,
+                type_=EdgeType.INHERITS,
+            )
+        # implementation links
+        for rel in diagram.get_relationships("implements"):
+            self.printer.emit_edge(
+                rel.from_object.fig_id,
+                rel.to_object.fig_id,
+                type_=EdgeType.IMPLEMENTS,
+            )
+        # generate associations
+        for rel in diagram.get_relationships("association"):
+            self.printer.emit_edge(
+                rel.from_object.fig_id,
+                rel.to_object.fig_id,
+                label=rel.name,
+                type_=EdgeType.ASSOCIATION,
+            )
+
+    def set_printer(self, file_name: str, basename: str) -> None:
+        """Set printer."""
+        self.printer = self.printer_class(basename)
+        self.file_name = file_name
+
+    def get_package_properties(self, obj: PackageEntity) -> NodeProperties:
+        """Get label and shape for packages."""
+        return NodeProperties(
+            label=obj.title,
+            color=self.get_shape_color(obj) if self.config.colorized else "black",
+        )
+
+    def get_class_properties(self, obj: ClassEntity) -> NodeProperties:
+        """Get label and shape for classes."""
+        properties = NodeProperties(
+            label=obj.title,
+            attrs=obj.attrs if not self.config.only_classnames else None,
+            methods=obj.methods if not self.config.only_classnames else None,
+            fontcolor="red" if is_exception(obj.node) else "black",
+            color=self.get_shape_color(obj) if self.config.colorized else "black",
+        )
+        return properties
+
+    def get_shape_color(self, obj: DiagramEntity) -> str:
+        """Get shape color."""
+        qualified_name = obj.node.qname()
+        if modutils.is_standard_module(qualified_name.split(".", maxsplit=1)[0]):
+            return "grey"
+        if isinstance(obj.node, nodes.ClassDef):
+            package = qualified_name.rsplit(".", maxsplit=2)[0]
+        elif obj.node.package:
+            package = qualified_name
+        else:
+            package = qualified_name.rsplit(".", maxsplit=1)[0]
+        base_name = ".".join(package.split(".", self.depth)[: self.depth])
+        if base_name not in self.used_colors:
+            self.used_colors[base_name] = next(self.available_colors)
+        return self.used_colors[base_name]
+
+    def save(self) -> None:
+        """Write to disk."""
+        self.printer.generate(self.file_name)
diff --git a/myenv/lib/python3.9/site-packages/pylint/reporters/__init__.py b/myenv/lib/python3.9/site-packages/pylint/reporters/__init__.py
new file mode 100644
index 0000000..47bb680
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/reporters/__init__.py
@@ -0,0 +1,30 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Utilities methods and classes for reporters."""
+from typing import TYPE_CHECKING
+
+from pylint import utils
+from pylint.reporters.base_reporter import BaseReporter
+from pylint.reporters.collecting_reporter import CollectingReporter
+from pylint.reporters.json_reporter import JSONReporter
+from pylint.reporters.multi_reporter import MultiReporter
+from pylint.reporters.reports_handler_mix_in import ReportsHandlerMixIn
+
+if TYPE_CHECKING:
+    from pylint.lint.pylinter import PyLinter
+
+
+def initialize(linter: "PyLinter") -> None:
+    """Initialize linter with reporters in this package."""
+    utils.register_plugins(linter, __path__[0])
+
+
+__all__ = [
+    "BaseReporter",
+    "ReportsHandlerMixIn",
+    "JSONReporter",
+    "CollectingReporter",
+    "MultiReporter",
+]
diff --git a/myenv/lib/python3.9/site-packages/pylint/reporters/base_reporter.py b/myenv/lib/python3.9/site-packages/pylint/reporters/base_reporter.py
new file mode 100644
index 0000000..b45be0d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/reporters/base_reporter.py
@@ -0,0 +1,91 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import os
+import sys
+from typing import TYPE_CHECKING, List, Optional, TextIO
+from warnings import warn
+
+from pylint.message import Message
+from pylint.reporters.ureports.nodes import Text
+from pylint.utils import LinterStats
+
+if TYPE_CHECKING:
+    from pylint.lint.pylinter import PyLinter
+    from pylint.reporters.ureports.nodes import Section
+
+
+class BaseReporter:
+    """Base class for reporters.
+
+    symbols: show short symbolic names for messages.
+    """
+
+    extension = ""
+
+    name = "base"
+    """Name of the reporter."""
+
+    def __init__(self, output: Optional[TextIO] = None) -> None:
+        self.linter: "PyLinter"
+        self.section = 0
+        self.out: TextIO = output or sys.stdout
+        self.messages: List[Message] = []
+        # Build the path prefix to strip to get relative paths
+        self.path_strip_prefix = os.getcwd() + os.sep
+
+    def handle_message(self, msg: Message) -> None:
+        """Handle a new message triggered on the current file."""
+        self.messages.append(msg)
+
+    def set_output(self, output: Optional[TextIO] = None) -> None:
+        """Set output stream."""
+        # pylint: disable-next=fixme
+        # TODO: Remove this method after depreciation
+        warn(
+            "'set_output' will be removed in 3.0, please use 'reporter.out = stream' instead",
+            DeprecationWarning,
+        )
+        self.out = output or sys.stdout
+
+    def writeln(self, string: str = "") -> None:
+        """Write a line in the output buffer."""
+        print(string, file=self.out)
+
+    def display_reports(self, layout: "Section") -> None:
+        """Display results encapsulated in the layout tree."""
+        self.section = 0
+        if layout.report_id:
+            if isinstance(layout.children[0].children[0], Text):
+                layout.children[0].children[0].data += f" ({layout.report_id})"
+            else:
+                raise ValueError(f"Incorrect child for {layout.children[0].children}")
+        self._display(layout)
+
+    def _display(self, layout: "Section") -> None:
+        """Display the layout."""
+        raise NotImplementedError()
+
+    def display_messages(self, layout: Optional["Section"]) -> None:
+        """Hook for displaying the messages of the reporter.
+
+        This will be called whenever the underlying messages
+        needs to be displayed. For some reporters, it probably
+        doesn't make sense to display messages as soon as they
+        are available, so some mechanism of storing them could be used.
+        This method can be implemented to display them after they've
+        been aggregated.
+        """
+
+    # Event callbacks
+
+    def on_set_current_module(self, module: str, filepath: Optional[str]) -> None:
+        """Hook called when a module starts to be analysed."""
+
+    def on_close(
+        self,
+        stats: LinterStats,
+        previous_stats: LinterStats,
+    ) -> None:
+        """Hook called when a module finished analyzing."""
diff --git a/myenv/lib/python3.9/site-packages/pylint/reporters/collecting_reporter.py b/myenv/lib/python3.9/site-packages/pylint/reporters/collecting_reporter.py
new file mode 100644
index 0000000..1562ab1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/reporters/collecting_reporter.py
@@ -0,0 +1,26 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import TYPE_CHECKING
+
+from pylint.reporters.base_reporter import BaseReporter
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+
+class CollectingReporter(BaseReporter):
+    """Collects messages."""
+
+    name = "collector"
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.messages = []
+
+    def reset(self) -> None:
+        self.messages = []
+
+    def _display(self, layout: "Section") -> None:
+        pass
diff --git a/myenv/lib/python3.9/site-packages/pylint/reporters/json_reporter.py b/myenv/lib/python3.9/site-packages/pylint/reporters/json_reporter.py
new file mode 100644
index 0000000..f7e782c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/reporters/json_reporter.py
@@ -0,0 +1,52 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""JSON reporter."""
+import json
+from typing import TYPE_CHECKING, Optional
+
+from pylint.interfaces import IReporter
+from pylint.reporters.base_reporter import BaseReporter
+
+if TYPE_CHECKING:
+    from pylint.lint.pylinter import PyLinter
+    from pylint.reporters.ureports.nodes import Section
+
+
+class JSONReporter(BaseReporter):
+    """Report messages and layouts in JSON."""
+
+    __implements__ = IReporter
+    name = "json"
+    extension = "json"
+
+    def display_messages(self, layout: Optional["Section"]) -> None:
+        """Launch layouts display."""
+        json_dumpable = [
+            {
+                "type": msg.category,
+                "module": msg.module,
+                "obj": msg.obj,
+                "line": msg.line,
+                "column": msg.column,
+                "endLine": msg.end_line,
+                "endColumn": msg.end_column,
+                "path": msg.path,
+                "symbol": msg.symbol,
+                "message": msg.msg or "",
+                "message-id": msg.msg_id,
+            }
+            for msg in self.messages
+        ]
+        print(json.dumps(json_dumpable, indent=4), file=self.out)
+
+    def display_reports(self, layout: "Section") -> None:
+        """Don't do anything in this reporter."""
+
+    def _display(self, layout: "Section") -> None:
+        """Do nothing."""
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_reporter(JSONReporter)
diff --git a/myenv/lib/python3.9/site-packages/pylint/reporters/multi_reporter.py b/myenv/lib/python3.9/site-packages/pylint/reporters/multi_reporter.py
new file mode 100644
index 0000000..43822f0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/reporters/multi_reporter.py
@@ -0,0 +1,110 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import os
+from typing import IO, TYPE_CHECKING, Any, AnyStr, Callable, List, Optional
+
+from pylint.interfaces import IReporter
+from pylint.message import Message
+from pylint.reporters.base_reporter import BaseReporter
+from pylint.utils import LinterStats
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+AnyFile = IO[AnyStr]
+PyLinter = Any
+
+
+class MultiReporter:
+    """Reports messages and layouts in plain text."""
+
+    __implements__ = IReporter
+    name = "_internal_multi_reporter"
+    # Note: do not register this reporter with linter.register_reporter as it is
+    #       not intended to be used directly like a regular reporter, but is
+    #       instead used to implement the
+    #       `--output-format=json:somefile.json,colorized`
+    #       multiple output formats feature
+
+    extension = ""
+
+    def __init__(
+        self,
+        sub_reporters: List[BaseReporter],
+        close_output_files: Callable[[], None],
+        output: Optional[AnyFile] = None,
+    ):
+        self._sub_reporters = sub_reporters
+        self.close_output_files = close_output_files
+        self._path_strip_prefix = os.getcwd() + os.sep
+        self._linter: Optional[PyLinter] = None
+        self.out = output
+        self.messages: List[Message] = []
+
+    @property
+    def out(self):
+        return self.__out
+
+    @out.setter
+    def out(self, output: Optional[AnyFile] = None):
+        """MultiReporter doesn't have its own output.
+
+        This method is only provided for API parity with BaseReporter
+        and should not be called with non-None values for 'output'.
+        """
+        self.__out = None
+        if output is not None:
+            raise NotImplementedError("MultiReporter does not support direct output.")
+
+    def __del__(self) -> None:
+        self.close_output_files()
+
+    @property
+    def path_strip_prefix(self) -> str:
+        return self._path_strip_prefix
+
+    @property
+    def linter(self) -> Optional[PyLinter]:
+        return self._linter
+
+    @linter.setter
+    def linter(self, value: PyLinter) -> None:
+        self._linter = value
+        for rep in self._sub_reporters:
+            rep.linter = value
+
+    def handle_message(self, msg: Message) -> None:
+        """Handle a new message triggered on the current file."""
+        for rep in self._sub_reporters:
+            rep.handle_message(msg)
+
+    def writeln(self, string: str = "") -> None:
+        """Write a line in the output buffer."""
+        for rep in self._sub_reporters:
+            rep.writeln(string)
+
+    def display_reports(self, layout: "Section") -> None:
+        """Display results encapsulated in the layout tree."""
+        for rep in self._sub_reporters:
+            rep.display_reports(layout)
+
+    def display_messages(self, layout: Optional["Section"]) -> None:
+        """Hook for displaying the messages of the reporter."""
+        for rep in self._sub_reporters:
+            rep.display_messages(layout)
+
+    def on_set_current_module(self, module: str, filepath: Optional[str]) -> None:
+        """Hook called when a module starts to be analysed."""
+        for rep in self._sub_reporters:
+            rep.on_set_current_module(module, filepath)
+
+    def on_close(
+        self,
+        stats: LinterStats,
+        previous_stats: LinterStats,
+    ) -> None:
+        """Hook called when a module finished analyzing."""
+        for rep in self._sub_reporters:
+            rep.on_close(stats, previous_stats)
diff --git a/myenv/lib/python3.9/site-packages/pylint/reporters/reports_handler_mix_in.py b/myenv/lib/python3.9/site-packages/pylint/reporters/reports_handler_mix_in.py
new file mode 100644
index 0000000..890d586
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/reporters/reports_handler_mix_in.py
@@ -0,0 +1,86 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import collections
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    DefaultDict,
+    Dict,
+    List,
+    MutableSequence,
+    Optional,
+    Tuple,
+)
+
+from pylint.exceptions import EmptyReportError
+from pylint.reporters.ureports.nodes import Section
+from pylint.utils import LinterStats
+
+if TYPE_CHECKING:
+    from pylint.checkers import BaseChecker
+    from pylint.lint.pylinter import PyLinter
+
+ReportsDict = DefaultDict["BaseChecker", List[Tuple[str, str, Callable]]]
+
+
+class ReportsHandlerMixIn:
+    """A mix-in class containing all the reports and stats manipulation
+    related methods for the main lint class
+    """
+
+    def __init__(self) -> None:
+        self._reports: ReportsDict = collections.defaultdict(list)
+        self._reports_state: Dict[str, bool] = {}
+
+    def report_order(self) -> MutableSequence["BaseChecker"]:
+        """Return a list of reporters."""
+        return list(self._reports)
+
+    def register_report(
+        self, reportid: str, r_title: str, r_cb: Callable, checker: "BaseChecker"
+    ) -> None:
+        """Register a report.
+
+        :param reportid: The unique identifier for the report
+        :param r_title: The report's title
+        :param r_cb: The method to call to make the report
+        :param checker: The checker defining the report
+        """
+        reportid = reportid.upper()
+        self._reports[checker].append((reportid, r_title, r_cb))
+
+    def enable_report(self, reportid: str) -> None:
+        """Enable the report of the given id."""
+        reportid = reportid.upper()
+        self._reports_state[reportid] = True
+
+    def disable_report(self, reportid: str) -> None:
+        """Disable the report of the given id."""
+        reportid = reportid.upper()
+        self._reports_state[reportid] = False
+
+    def report_is_enabled(self, reportid: str) -> bool:
+        """Is the report associated to the given identifier enabled ?"""
+        return self._reports_state.get(reportid, True)
+
+    def make_reports(  # type: ignore[misc] # ReportsHandlerMixIn is always mixed with PyLinter
+        self: "PyLinter",
+        stats: LinterStats,
+        old_stats: Optional[LinterStats],
+    ) -> Section:
+        """Render registered reports."""
+        sect = Section("Report", f"{self.stats.statement} statements analysed.")
+        for checker in self.report_order():
+            for reportid, r_title, r_cb in self._reports[checker]:
+                if not self.report_is_enabled(reportid):
+                    continue
+                report_sect = Section(r_title)
+                try:
+                    r_cb(report_sect, stats, old_stats)
+                except EmptyReportError:
+                    continue
+                report_sect.report_id = reportid
+                sect.append(report_sect)
+        return sect
diff --git a/myenv/lib/python3.9/site-packages/pylint/reporters/text.py b/myenv/lib/python3.9/site-packages/pylint/reporters/text.py
new file mode 100644
index 0000000..d37de5b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/reporters/text.py
@@ -0,0 +1,340 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Plain text reporters:.
+
+:text: the default one grouping messages by module
+:colorized: an ANSI colorized text reporter
+"""
+import os
+import re
+import sys
+import warnings
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    NamedTuple,
+    Optional,
+    Set,
+    TextIO,
+    Tuple,
+    Union,
+    cast,
+    overload,
+)
+
+from pylint.interfaces import IReporter
+from pylint.message import Message
+from pylint.reporters import BaseReporter
+from pylint.reporters.ureports.text_writer import TextWriter
+from pylint.utils import _splitstrip
+
+if TYPE_CHECKING:
+    from pylint.lint import PyLinter
+    from pylint.reporters.ureports.nodes import Section
+
+
+class MessageStyle(NamedTuple):
+    """Styling of a message."""
+
+    color: Optional[str]
+    """The color name (see `ANSI_COLORS` for available values)
+    or the color number when 256 colors are available
+    """
+    style: Tuple[str, ...] = ()
+    """Tuple of style strings (see `ANSI_COLORS` for available values)."""
+
+
+ColorMappingDict = Dict[str, MessageStyle]
+
+TITLE_UNDERLINES = ["", "=", "-", "."]
+
+ANSI_PREFIX = "\033["
+ANSI_END = "m"
+ANSI_RESET = "\033[0m"
+ANSI_STYLES = {
+    "reset": "0",
+    "bold": "1",
+    "italic": "3",
+    "underline": "4",
+    "blink": "5",
+    "inverse": "7",
+    "strike": "9",
+}
+ANSI_COLORS = {
+    "reset": "0",
+    "black": "30",
+    "red": "31",
+    "green": "32",
+    "yellow": "33",
+    "blue": "34",
+    "magenta": "35",
+    "cyan": "36",
+    "white": "37",
+}
+
+
+def _get_ansi_code(msg_style: MessageStyle) -> str:
+    """Return ansi escape code corresponding to color and style.
+
+    :param msg_style: the message style
+
+    :raise KeyError: if an unexistent color or style identifier is given
+
+    :return: the built escape code
+    """
+    ansi_code = [ANSI_STYLES[effect] for effect in msg_style.style]
+    if msg_style.color:
+        if msg_style.color.isdigit():
+            ansi_code.extend(["38", "5"])
+            ansi_code.append(msg_style.color)
+        else:
+            ansi_code.append(ANSI_COLORS[msg_style.color])
+    if ansi_code:
+        return ANSI_PREFIX + ";".join(ansi_code) + ANSI_END
+    return ""
+
+
+@overload
+def colorize_ansi(
+    msg: str,
+    msg_style: Optional[MessageStyle] = None,
+) -> str:
+    ...
+
+
+@overload
+def colorize_ansi(
+    msg: str,
+    msg_style: Optional[str] = None,
+    style: Optional[str] = None,
+    *,
+    color: Optional[str] = None,
+) -> str:
+    # Remove for pylint 3.0
+    ...
+
+
+def colorize_ansi(
+    msg: str,
+    msg_style: Union[MessageStyle, str, None] = None,
+    style: Optional[str] = None,
+    **kwargs: Optional[str],
+) -> str:
+    r"""colorize message by wrapping it with ansi escape codes
+
+    :param msg: the message string to colorize
+
+    :param msg_style: the message style
+        or color (for backwards compatibility): the color of the message style
+
+    :param style: the message's style elements, this will be deprecated
+
+    :param \**kwargs: used to accept `color` parameter while it is being deprecated
+
+    :return: the ansi escaped string
+    """
+    # pylint: disable-next=fixme
+    # TODO: Remove DeprecationWarning and only accept MessageStyle as parameter
+    if not isinstance(msg_style, MessageStyle):
+        warnings.warn(
+            "In pylint 3.0, the colorize_ansi function of Text reporters will only accept a MessageStyle parameter",
+            DeprecationWarning,
+        )
+        color = kwargs.get("color")
+        style_attrs = tuple(_splitstrip(style))
+        msg_style = MessageStyle(color or msg_style, style_attrs)
+    # If both color and style are not defined, then leave the text as is
+    if msg_style.color is None and len(msg_style.style) == 0:
+        return msg
+    escape_code = _get_ansi_code(msg_style)
+    # If invalid (or unknown) color, don't wrap msg with ansi codes
+    if escape_code:
+        return f"{escape_code}{msg}{ANSI_RESET}"
+    return msg
+
+
+class TextReporter(BaseReporter):
+    """Reports messages and layouts in plain text."""
+
+    __implements__ = IReporter
+    name = "text"
+    extension = "txt"
+    line_format = "{path}:{line}:{column}: {msg_id}: {msg} ({symbol})"
+
+    def __init__(self, output: Optional[TextIO] = None) -> None:
+        super().__init__(output)
+        self._modules: Set[str] = set()
+        self._template = self.line_format
+        self._fixed_template = self.line_format
+        """The output format template with any unrecognized arguments removed."""
+
+    def on_set_current_module(self, module: str, filepath: Optional[str]) -> None:
+        """Set the format template to be used and check for unrecognized arguments."""
+        template = str(self.linter.config.msg_template or self._template)
+
+        # Return early if the template is the same as the previous one
+        if template == self._template:
+            return
+
+        # Set template to the currently selected template
+        self._template = template
+
+        # Check to see if all parameters in the template are attributes of the Message
+        arguments = re.findall(r"\{(.+?)(:.*)?\}", template)
+        for argument in arguments:
+            if argument[0] not in Message._fields:
+                warnings.warn(
+                    f"Don't recognize the argument '{argument[0]}' in the --msg-template. "
+                    "Are you sure it is supported on the current version of pylint?"
+                )
+                template = re.sub(r"\{" + argument[0] + r"(:.*?)?\}", "", template)
+        self._fixed_template = template
+
+    def write_message(self, msg: Message) -> None:
+        """Convenience method to write a formatted message with class default template."""
+        self_dict = msg._asdict()
+        for key in ("end_line", "end_column"):
+            self_dict[key] = self_dict[key] or ""
+
+        self.writeln(self._fixed_template.format(**self_dict))
+
+    def handle_message(self, msg: Message) -> None:
+        """Manage message of different type and in the context of path."""
+        if msg.module not in self._modules:
+            if msg.module:
+                self.writeln(f"************* Module {msg.module}")
+                self._modules.add(msg.module)
+            else:
+                self.writeln("************* ")
+        self.write_message(msg)
+
+    def _display(self, layout: "Section") -> None:
+        """Launch layouts display."""
+        print(file=self.out)
+        TextWriter().format(layout, self.out)
+
+
+class ParseableTextReporter(TextReporter):
+    """A reporter very similar to TextReporter, but display messages in a form
+    recognized by most text editors :
+
+    <filename>:<linenum>:<msg>
+    """
+
+    name = "parseable"
+    line_format = "{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}"
+
+    def __init__(self, output: Optional[TextIO] = None) -> None:
+        warnings.warn(
+            f"{self.name} output format is deprecated. This is equivalent to --msg-template={self.line_format}",
+            DeprecationWarning,
+        )
+        super().__init__(output)
+
+
+class VSTextReporter(ParseableTextReporter):
+    """Visual studio text reporter."""
+
+    name = "msvs"
+    line_format = "{path}({line}): [{msg_id}({symbol}){obj}] {msg}"
+
+
+class ColorizedTextReporter(TextReporter):
+    """Simple TextReporter that colorizes text output."""
+
+    name = "colorized"
+    COLOR_MAPPING: ColorMappingDict = {
+        "I": MessageStyle("green"),
+        "C": MessageStyle(None, ("bold",)),
+        "R": MessageStyle("magenta", ("bold", "italic")),
+        "W": MessageStyle("magenta"),
+        "E": MessageStyle("red", ("bold",)),
+        "F": MessageStyle("red", ("bold", "underline")),
+        "S": MessageStyle("yellow", ("inverse",)),  # S stands for module Separator
+    }
+
+    @overload
+    def __init__(
+        self,
+        output: Optional[TextIO] = None,
+        color_mapping: Optional[ColorMappingDict] = None,
+    ) -> None:
+        ...
+
+    @overload
+    def __init__(
+        self,
+        output: Optional[TextIO] = None,
+        color_mapping: Optional[Dict[str, Tuple[Optional[str], Optional[str]]]] = None,
+    ) -> None:
+        # Remove for pylint 3.0
+        ...
+
+    def __init__(
+        self,
+        output: Optional[TextIO] = None,
+        color_mapping: Union[
+            ColorMappingDict, Dict[str, Tuple[Optional[str], Optional[str]]], None
+        ] = None,
+    ) -> None:
+        super().__init__(output)
+        # pylint: disable-next=fixme
+        # TODO: Remove DeprecationWarning and only accept ColorMappingDict as color_mapping parameter
+        if color_mapping and not isinstance(
+            list(color_mapping.values())[0], MessageStyle
+        ):
+            warnings.warn(
+                "In pylint 3.0, the ColorizedTextReporter will only accept ColorMappingDict as color_mapping parameter",
+                DeprecationWarning,
+            )
+            temp_color_mapping: ColorMappingDict = {}
+            for key, value in color_mapping.items():
+                color = value[0]
+                style_attrs = tuple(_splitstrip(value[1]))
+                temp_color_mapping[key] = MessageStyle(color, style_attrs)
+            color_mapping = temp_color_mapping
+        else:
+            color_mapping = cast(Optional[ColorMappingDict], color_mapping)
+        self.color_mapping = color_mapping or ColorizedTextReporter.COLOR_MAPPING
+        ansi_terms = ["xterm-16color", "xterm-256color"]
+        if os.environ.get("TERM") not in ansi_terms:
+            if sys.platform == "win32":
+                # pylint: disable=import-outside-toplevel
+                import colorama
+
+                self.out = colorama.AnsiToWin32(self.out)
+
+    def _get_decoration(self, msg_id: str) -> MessageStyle:
+        """Returns the message style as defined in self.color_mapping."""
+        return self.color_mapping.get(msg_id[0]) or MessageStyle(None)
+
+    def handle_message(self, msg: Message) -> None:
+        """Manage message of different types, and colorize output
+        using ansi escape codes
+        """
+        if msg.module not in self._modules:
+            msg_style = self._get_decoration("S")
+            if msg.module:
+                modsep = colorize_ansi(f"************* Module {msg.module}", msg_style)
+            else:
+                modsep = colorize_ansi(f"************* {msg.module}", msg_style)
+            self.writeln(modsep)
+            self._modules.add(msg.module)
+        msg_style = self._get_decoration(msg.C)
+
+        msg = msg._replace(
+            **{
+                attr: colorize_ansi(getattr(msg, attr), msg_style)
+                for attr in ("msg", "symbol", "category", "C")
+            }
+        )
+        self.write_message(msg)
+
+
+def register(linter: "PyLinter") -> None:
+    linter.register_reporter(TextReporter)
+    linter.register_reporter(ParseableTextReporter)
+    linter.register_reporter(VSTextReporter)
+    linter.register_reporter(ColorizedTextReporter)
diff --git a/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/__init__.py b/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/__init__.py
new file mode 100644
index 0000000..a6a0946
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/__init__.py
@@ -0,0 +1,7 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+__all__ = ("BaseWriter",)
+
+from pylint.reporters.ureports.base_writer import BaseWriter
diff --git a/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/base_writer.py b/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/base_writer.py
new file mode 100644
index 0000000..4f0ce55
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/base_writer.py
@@ -0,0 +1,99 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Universal report objects and some formatting drivers.
+
+A way to create simple reports using python objects, primarily designed to be
+formatted as text and html.
+"""
+import sys
+from io import StringIO
+from typing import TYPE_CHECKING, Iterator, List, TextIO, Union
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import (
+        EvaluationSection,
+        Paragraph,
+        Section,
+        Table,
+    )
+
+
+class BaseWriter:
+    """Base class for ureport writers."""
+
+    def format(self, layout, stream: TextIO = sys.stdout, encoding=None) -> None:
+        """Format and write the given layout into the stream object.
+
+        unicode policy: unicode strings may be found in the layout;
+        try to call 'stream.write' with it, but give it back encoded using
+        the given encoding if it fails
+        """
+        if not encoding:
+            encoding = getattr(stream, "encoding", "UTF-8")
+        self.encoding = encoding or "UTF-8"
+        self.out = stream
+        self.begin_format()
+        layout.accept(self)
+        self.end_format()
+
+    def format_children(
+        self, layout: Union["EvaluationSection", "Paragraph", "Section"]
+    ) -> None:
+        """Recurse on the layout children and call their accept method
+        (see the Visitor pattern)
+        """
+        for child in getattr(layout, "children", ()):
+            child.accept(self)
+
+    def writeln(self, string: str = "") -> None:
+        """Write a line in the output buffer."""
+        self.write(string + "\n")
+
+    def write(self, string: str) -> None:
+        """Write a string in the output buffer."""
+        self.out.write(string)
+
+    def begin_format(self) -> None:
+        """Begin to format a layout."""
+        self.section = 0
+
+    def end_format(self) -> None:
+        """Finished formatting a layout."""
+
+    def get_table_content(self, table: "Table") -> List[List[str]]:
+        """Trick to get table content without actually writing it.
+
+        return an aligned list of lists containing table cells values as string
+        """
+        result: List[List[str]] = [[]]
+        cols = table.cols
+        for cell in self.compute_content(table):
+            if cols == 0:
+                result.append([])
+                cols = table.cols
+            cols -= 1
+            result[-1].append(cell)
+        # fill missing cells
+        result[-1] += [""] * (cols - len(result[-1]))
+        return result
+
+    def compute_content(self, layout) -> Iterator[str]:
+        """Trick to compute the formatting of children layout before actually
+        writing it
+
+        return an iterator on strings (one for each child element)
+        """
+        # Patch the underlying output stream with a fresh-generated stream,
+        # which is used to store a temporary representation of a child
+        # node.
+        out = self.out
+        try:
+            for child in layout.children:
+                stream = StringIO()
+                self.out = stream
+                child.accept(self)
+                yield stream.getvalue()
+        finally:
+            self.out = out
diff --git a/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/nodes.py b/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/nodes.py
new file mode 100644
index 0000000..543082a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/nodes.py
@@ -0,0 +1,180 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Micro reports objects.
+
+A micro report is a tree of layout and content objects.
+"""
+from typing import Any, Iterable, Iterator, List, Optional, Union
+
+from pylint.reporters.ureports.text_writer import TextWriter
+
+
+class VNode:
+    def __init__(self) -> None:
+        self.parent: Optional["BaseLayout"] = None
+        self.children: List["VNode"] = []
+        self.visitor_name: str = self.__class__.__name__.lower()
+
+    def __iter__(self) -> Iterator["VNode"]:
+        return iter(self.children)
+
+    def accept(self, visitor: TextWriter, *args: Any, **kwargs: Any) -> None:
+        func = getattr(visitor, f"visit_{self.visitor_name}")
+        return func(self, *args, **kwargs)
+
+    def leave(self, visitor, *args, **kwargs):
+        func = getattr(visitor, f"leave_{self.visitor_name}")
+        return func(self, *args, **kwargs)
+
+
+class BaseLayout(VNode):
+    """Base container node.
+
+    attributes
+    * children : components in this table (i.e. the table's cells)
+    """
+
+    def __init__(self, children: Iterable[Union["Text", str]] = ()) -> None:
+        super().__init__()
+        for child in children:
+            if isinstance(child, VNode):
+                self.append(child)
+            else:
+                self.add_text(child)
+
+    def append(self, child: VNode) -> None:
+        """Add a node to children."""
+        assert child not in self.parents()
+        self.children.append(child)
+        child.parent = self
+
+    def insert(self, index: int, child: VNode) -> None:
+        """Insert a child node."""
+        self.children.insert(index, child)
+        child.parent = self
+
+    def parents(self) -> List["BaseLayout"]:
+        """Return the ancestor nodes."""
+        assert self.parent is not self
+        if self.parent is None:
+            return []
+        return [self.parent] + self.parent.parents()
+
+    def add_text(self, text: str) -> None:
+        """Shortcut to add text data."""
+        self.children.append(Text(text))
+
+
+# non container nodes #########################################################
+
+
+class Text(VNode):
+    """A text portion.
+
+    attributes :
+    * data : the text value as an encoded or unicode string
+    """
+
+    def __init__(self, data: str, escaped: bool = True) -> None:
+        super().__init__()
+        self.escaped = escaped
+        self.data = data
+
+
+class VerbatimText(Text):
+    """A verbatim text, display the raw data.
+
+    attributes :
+    * data : the text value as an encoded or unicode string
+    """
+
+
+# container nodes #############################################################
+
+
+class Section(BaseLayout):
+    """A section.
+
+    attributes :
+    * BaseLayout attributes
+
+    a title may also be given to the constructor, it'll be added
+    as a first element
+    a description may also be given to the constructor, it'll be added
+    as a first paragraph
+    """
+
+    def __init__(
+        self,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        children: Iterable[Union["Text", str]] = (),
+    ) -> None:
+        super().__init__(children=children)
+        if description:
+            self.insert(0, Paragraph([Text(description)]))
+        if title:
+            self.insert(0, Title(children=(title,)))
+        self.report_id: str = ""  # Used in ReportHandlerMixin.make_reports
+
+
+class EvaluationSection(Section):
+    def __init__(
+        self, message: str, children: Iterable[Union["Text", str]] = ()
+    ) -> None:
+        super().__init__(children=children)
+        title = Paragraph()
+        title.append(Text("-" * len(message)))
+        self.append(title)
+        message_body = Paragraph()
+        message_body.append(Text(message))
+        self.append(message_body)
+
+
+class Title(BaseLayout):
+    """A title.
+
+    attributes :
+    * BaseLayout attributes
+
+    A title must not contain a section nor a paragraph!
+    """
+
+
+class Paragraph(BaseLayout):
+    """A simple text paragraph.
+
+    attributes :
+    * BaseLayout attributes
+
+    A paragraph must not contains a section !
+    """
+
+
+class Table(BaseLayout):
+    """Some tabular data.
+
+    attributes :
+    * BaseLayout attributes
+    * cols : the number of columns of the table (REQUIRED)
+    * rheaders : the first row's elements are table's header
+    * cheaders : the first col's elements are table's header
+    * title : the table's optional title
+    """
+
+    def __init__(
+        self,
+        cols: int,
+        title: Optional[str] = None,
+        rheaders: int = 0,
+        cheaders: int = 0,
+        children: Iterable[Union["Text", str]] = (),
+    ) -> None:
+        super().__init__(children=children)
+        assert isinstance(cols, int)
+        self.cols = cols
+        self.title = title
+        self.rheaders = rheaders
+        self.cheaders = cheaders
diff --git a/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/text_writer.py b/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/text_writer.py
new file mode 100644
index 0000000..fc4ce67
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/reporters/ureports/text_writer.py
@@ -0,0 +1,106 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Text formatting drivers for ureports."""
+
+from typing import TYPE_CHECKING, List
+
+from pylint.reporters.ureports.base_writer import BaseWriter
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import (
+        EvaluationSection,
+        Paragraph,
+        Section,
+        Table,
+        Text,
+        Title,
+        VerbatimText,
+    )
+
+TITLE_UNDERLINES = ["", "=", "-", "`", ".", "~", "^"]
+BULLETS = ["*", "-"]
+
+
+class TextWriter(BaseWriter):
+    """Format layouts as text
+    (ReStructured inspiration but not totally handled yet)
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.list_level = 0
+
+    def visit_section(self, layout: "Section") -> None:
+        """Display a section as text."""
+        self.section += 1
+        self.writeln()
+        self.format_children(layout)
+        self.section -= 1
+        self.writeln()
+
+    def visit_evaluationsection(self, layout: "EvaluationSection") -> None:
+        """Display an evaluation section as a text."""
+        self.section += 1
+        self.format_children(layout)
+        self.section -= 1
+        self.writeln()
+
+    def visit_title(self, layout: "Title") -> None:
+        title = "".join(list(self.compute_content(layout)))
+        self.writeln(title)
+        try:
+            self.writeln(TITLE_UNDERLINES[self.section] * len(title))
+        except IndexError:
+            print("FIXME TITLE TOO DEEP. TURNING TITLE INTO TEXT")
+
+    def visit_paragraph(self, layout: "Paragraph") -> None:
+        """Enter a paragraph."""
+        self.format_children(layout)
+        self.writeln()
+
+    def visit_table(self, layout: "Table") -> None:
+        """Display a table as text."""
+        table_content = self.get_table_content(layout)
+        # get columns width
+        cols_width = [0] * len(table_content[0])
+        for row in table_content:
+            for index, col in enumerate(row):
+                cols_width[index] = max(cols_width[index], len(col))
+        self.default_table(layout, table_content, cols_width)
+        self.writeln()
+
+    def default_table(
+        self, layout: "Table", table_content: List[List[str]], cols_width: List[int]
+    ) -> None:
+        """Format a table."""
+        cols_width = [size + 1 for size in cols_width]
+        format_strings = " ".join(["%%-%ss"] * len(cols_width))
+        format_strings %= tuple(cols_width)
+
+        table_linesep = "\n+" + "+".join("-" * w for w in cols_width) + "+\n"
+        headsep = "\n+" + "+".join("=" * w for w in cols_width) + "+\n"
+
+        self.write(table_linesep)
+        split_strings = format_strings.split(" ")
+        for index, line in enumerate(table_content):
+            self.write("|")
+            for line_index, at_index in enumerate(line):
+                self.write(split_strings[line_index] % at_index)
+                self.write("|")
+            if index == 0 and layout.rheaders:
+                self.write(headsep)
+            else:
+                self.write(table_linesep)
+
+    def visit_verbatimtext(self, layout: "VerbatimText") -> None:
+        """Display a verbatim layout as text (so difficult ;)."""
+        self.writeln("::\n")
+        for line in layout.data.splitlines():
+            self.writeln("    " + line)
+        self.writeln()
+
+    def visit_text(self, layout: "Text") -> None:
+        """Add some text."""
+        self.write(f"{layout.data}")
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/__init__.py b/myenv/lib/python3.9/site-packages/pylint/testutils/__init__.py
new file mode 100644
index 0000000..0b55fc8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/__init__.py
@@ -0,0 +1,33 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Functional/non regression tests for pylint."""
+
+__all__ = [
+    "_get_tests_info",
+    "_tokenize_str",
+    "CheckerTestCase",
+    "FunctionalTestFile",
+    "linter",
+    "LintModuleTest",
+    "MessageTest",
+    "MinimalTestReporter",
+    "set_config",
+    "GenericTestReporter",
+    "UPDATE_FILE",
+    "UPDATE_OPTION",
+    "UnittestLinter",
+]
+
+from pylint.testutils.checker_test_case import CheckerTestCase
+from pylint.testutils.constants import UPDATE_FILE, UPDATE_OPTION
+from pylint.testutils.decorator import set_config
+from pylint.testutils.functional import FunctionalTestFile
+from pylint.testutils.get_test_info import _get_tests_info
+from pylint.testutils.global_test_linter import linter
+from pylint.testutils.lint_module_test import LintModuleTest
+from pylint.testutils.output_line import MessageTest
+from pylint.testutils.reporter_for_tests import GenericTestReporter, MinimalTestReporter
+from pylint.testutils.tokenize_str import _tokenize_str
+from pylint.testutils.unittest_linter import UnittestLinter
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/checker_test_case.py b/myenv/lib/python3.9/site-packages/pylint/testutils/checker_test_case.py
new file mode 100644
index 0000000..b6e10fb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/checker_test_case.py
@@ -0,0 +1,95 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import contextlib
+import warnings
+from typing import Dict, Generator, Optional, Type
+
+from pylint.constants import PY38_PLUS
+from pylint.testutils.global_test_linter import linter
+from pylint.testutils.output_line import MessageTest
+from pylint.testutils.unittest_linter import UnittestLinter
+from pylint.utils import ASTWalker
+
+
+class CheckerTestCase:
+    """A base testcase class for unit testing individual checker classes."""
+
+    CHECKER_CLASS: Optional[Type] = None
+    CONFIG: Dict = {}
+
+    def setup_method(self):
+        self.linter = UnittestLinter()
+        self.checker = self.CHECKER_CLASS(self.linter)  # pylint: disable=not-callable
+        for key, value in self.CONFIG.items():
+            setattr(self.checker.config, key, value)
+        self.checker.open()
+
+    @contextlib.contextmanager
+    def assertNoMessages(self):
+        """Assert that no messages are added by the given method."""
+        with self.assertAddsMessages():
+            yield
+
+    @contextlib.contextmanager
+    def assertAddsMessages(
+        self, *messages: MessageTest, ignore_position: bool = False
+    ) -> Generator[None, None, None]:
+        """Assert that exactly the given method adds the given messages.
+
+        The list of messages must exactly match *all* the messages added by the
+        method. Additionally, we check to see whether the args in each message can
+        actually be substituted into the message string.
+
+        Using the keyword argument `ignore_position`, all checks for position
+        arguments (line, col_offset, ...) will be skipped. This can be used to
+        just test messages for the correct node.
+        """
+        yield
+        got = self.linter.release_messages()
+        no_msg = "No message."
+        expected = "\n".join(repr(m) for m in messages) or no_msg
+        got_str = "\n".join(repr(m) for m in got) or no_msg
+        msg = (
+            "Expected messages did not match actual.\n"
+            f"\nExpected:\n{expected}\n\nGot:\n{got_str}\n"
+        )
+
+        assert len(messages) == len(got), msg
+
+        for expected_msg, gotten_msg in zip(messages, got):
+            assert expected_msg.msg_id == gotten_msg.msg_id, msg
+            assert expected_msg.node == gotten_msg.node, msg
+            assert expected_msg.args == gotten_msg.args, msg
+            assert expected_msg.confidence == gotten_msg.confidence, msg
+
+            if ignore_position:
+                # Do not check for line, col_offset etc...
+                continue
+
+            assert expected_msg.line == gotten_msg.line, msg
+            assert expected_msg.col_offset == gotten_msg.col_offset, msg
+            if PY38_PLUS:
+                # pylint: disable=fixme
+                # TODO: Require end_line and end_col_offset and remove the warning
+                if not expected_msg.end_line == gotten_msg.end_line:
+                    warnings.warn(  # pragma: no cover
+                        f"The end_line attribute of {gotten_msg} does not match "
+                        f"the expected value in {expected_msg}. In pylint 3.0 correct end_line "
+                        "attributes will be required for MessageTest.",
+                        DeprecationWarning,
+                    )
+                if not expected_msg.end_col_offset == gotten_msg.end_col_offset:
+                    warnings.warn(  # pragma: no cover
+                        f"The end_col_offset attribute of {gotten_msg} does not match "
+                        f"the expected value in {expected_msg}. In pylint 3.0 correct end_col_offset "
+                        "attributes will be required for MessageTest.",
+                        DeprecationWarning,
+                    )
+
+    def walk(self, node):
+        """Recursive walk on the given node."""
+        walker = ASTWalker(linter)
+        walker.add_checker(self.checker)
+        walker.walk(node)
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/configuration_test.py b/myenv/lib/python3.9/site-packages/pylint/testutils/configuration_test.py
new file mode 100644
index 0000000..c6241f3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/configuration_test.py
@@ -0,0 +1,158 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Utility functions for configuration testing."""
+import copy
+import json
+import logging
+import re
+import unittest
+from pathlib import Path
+from typing import Any, Dict, List, Tuple, Union
+from unittest.mock import Mock
+
+from pylint.constants import PY38_PLUS
+from pylint.lint import Run
+
+# We use Any in this typing because the configuration contains real objects and constants
+# that could be a lot of things.
+ConfigurationValue = Any
+PylintConfiguration = Dict[str, ConfigurationValue]
+
+
+if not PY38_PLUS:
+    # We need to deepcopy a compiled regex pattern
+    # In python 3.6 and 3.7 this requires a hack
+    # See https://stackoverflow.com/a/56935186
+    copy._deepcopy_dispatch[type(re.compile(""))] = lambda r, _: r  # type: ignore[attr-defined]
+
+
+def get_expected_or_default(
+    tested_configuration_file: Union[str, Path],
+    suffix: str,
+    default: str,
+) -> str:
+    """Return the expected value from the file if it exists, or the given default."""
+    expected = default
+    path = Path(tested_configuration_file)
+    expected_result_path = path.parent / f"{path.stem}.{suffix}"
+    if expected_result_path.exists():
+        with open(expected_result_path, encoding="utf8") as f:
+            expected = f.read()
+        # logging is helpful to realize your file is not taken into
+        # account after a misspelling of the file name. The output of the
+        # program is checked during the test so printing messes with the result.
+        logging.info("%s exists.", expected_result_path)
+    else:
+        logging.info("%s not found, using '%s'.", expected_result_path, default)
+    return expected
+
+
+EXPECTED_CONF_APPEND_KEY = "functional_append"
+EXPECTED_CONF_REMOVE_KEY = "functional_remove"
+
+
+def get_expected_configuration(
+    configuration_path: str, default_configuration: PylintConfiguration
+) -> PylintConfiguration:
+    """Get the expected parsed configuration of a configuration functional test."""
+    result = copy.deepcopy(default_configuration)
+    config_as_json = get_expected_or_default(
+        configuration_path, suffix="result.json", default="{}"
+    )
+    to_override = json.loads(config_as_json)
+    for key, value in to_override.items():
+        if key == EXPECTED_CONF_APPEND_KEY:
+            for fkey, fvalue in value.items():
+                result[fkey] += fvalue
+        elif key == EXPECTED_CONF_REMOVE_KEY:
+            for fkey, fvalue in value.items():
+                new_value = []
+                for old_value in result[fkey]:
+                    if old_value not in fvalue:
+                        new_value.append(old_value)
+                result[fkey] = new_value
+        else:
+            result[key] = value
+    return result
+
+
+def get_related_files(
+    tested_configuration_file: Union[str, Path], suffix_filter: str
+) -> List[Path]:
+    """Return all the file related to a test conf file endind with a suffix."""
+    conf_path = Path(tested_configuration_file)
+    return [
+        p
+        for p in conf_path.parent.iterdir()
+        if str(p.stem).startswith(conf_path.stem) and str(p).endswith(suffix_filter)
+    ]
+
+
+def get_expected_output(
+    configuration_path: Union[str, Path], user_specific_path: Path
+) -> Tuple[int, str]:
+    """Get the expected output of a functional test."""
+    exit_code = 0
+    msg = (
+        "we expect a single file of the form 'filename.32.out' where 'filename' represents "
+        "the name of the configuration file, and '32' the expected error code."
+    )
+    possible_out_files = get_related_files(configuration_path, suffix_filter="out")
+    if len(possible_out_files) > 1:
+        logging.error(
+            "Too much .out files for %s %s.",
+            configuration_path,
+            msg,
+        )
+        return -1, "out file is broken"
+    if not possible_out_files:
+        # logging is helpful to see what the expected exit code is and why.
+        # The output of the program is checked during the test so printing
+        # messes with the result.
+        logging.info(".out file does not exists, so the expected exit code is 0")
+        return 0, ""
+    path = possible_out_files[0]
+    try:
+        exit_code = int(str(path.stem).rsplit(".", maxsplit=1)[-1])
+    except Exception as e:  # pylint: disable=broad-except
+        logging.error(
+            "Wrong format for .out file name for %s %s: %s",
+            configuration_path,
+            msg,
+            e,
+        )
+        return -1, "out file is broken"
+
+    output = get_expected_or_default(
+        configuration_path, suffix=f"{exit_code}.out", default=""
+    )
+    logging.info(
+        "Output exists for %s so the expected exit code is %s",
+        configuration_path,
+        exit_code,
+    )
+    return exit_code, output.format(
+        abspath=configuration_path,
+        relpath=Path(configuration_path).relative_to(user_specific_path),
+    )
+
+
+def run_using_a_configuration_file(
+    configuration_path: Union[Path, str], file_to_lint: str = __file__
+) -> Tuple[Mock, Mock, Run]:
+    """Simulate a run with a configuration without really launching the checks."""
+    configuration_path = str(configuration_path)
+    args = ["--rcfile", configuration_path, file_to_lint]
+    # We do not capture the `SystemExit` as then the `runner` variable
+    # would not be accessible outside the `with` block.
+    with unittest.mock.patch("sys.exit") as mocked_exit:
+        # Do not actually run checks, that could be slow. We don't mock
+        # `PyLinter.check`: it calls `PyLinter.initialize` which is
+        # needed to properly set up messages inclusion/exclusion
+        # in `_msg_states`, used by `is_message_enabled`.
+        check = "pylint.lint.pylinter.check_parallel"
+        with unittest.mock.patch(check) as mocked_check_parallel:
+            runner = Run(args)
+    return mocked_exit, mocked_check_parallel, runner
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/constants.py b/myenv/lib/python3.9/site-packages/pylint/testutils/constants.py
new file mode 100644
index 0000000..1c3c69d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/constants.py
@@ -0,0 +1,29 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import operator
+import re
+import sys
+from pathlib import Path
+
+SYS_VERS_STR = (
+    "%d%d%d" % sys.version_info[:3]  # pylint: disable=consider-using-f-string
+)
+TITLE_UNDERLINES = ["", "=", "-", "."]
+UPDATE_OPTION = "--update-functional-output"
+UPDATE_FILE = Path("pylint-functional-test-update")
+# Common sub-expressions.
+_MESSAGE = {"msg": r"[a-z][a-z\-]+"}
+# Matches a #,
+#  - followed by a comparison operator and a Python version (optional),
+#  - followed by a line number with a +/- (optional),
+#  - followed by a list of bracketed message symbols.
+# Used to extract expected messages from testdata files.
+_EXPECTED_RE = re.compile(
+    r"\s*#\s*(?:(?P<line>[+-]?[0-9]+):)?"  # pylint: disable=consider-using-f-string
+    r"(?:(?P<op>[><=]+) *(?P<version>[0-9.]+):)?"
+    r"\s*\[(?P<msgs>%(msg)s(?:,\s*%(msg)s)*)]" % _MESSAGE
+)
+
+_OPERATORS = {">": operator.gt, "<": operator.lt, ">=": operator.ge, "<=": operator.le}
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/decorator.py b/myenv/lib/python3.9/site-packages/pylint/testutils/decorator.py
new file mode 100644
index 0000000..b2a790c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/decorator.py
@@ -0,0 +1,89 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import functools
+import optparse  # pylint: disable=deprecated-module
+import warnings
+
+from pylint.lint import PyLinter
+from pylint.testutils.checker_test_case import CheckerTestCase
+
+
+def set_config(**kwargs):
+    """Decorator for setting config values on a checker.
+
+    Passing the args and kwargs back to the test function itself
+    allows this decorator to be used on parametrized test cases.
+    """
+
+    def _wrapper(fun):
+        @functools.wraps(fun)
+        def _forward(self, *args, **test_function_kwargs):
+            try:
+                for key, value in kwargs.items():
+                    self.checker.set_option(key.replace("_", "-"), value)
+            except optparse.OptionError:
+                # Check if option is one of the base options of the PyLinter class
+                for key, value in kwargs.items():
+                    try:
+                        self.checker.set_option(
+                            key.replace("_", "-"),
+                            value,
+                            optdict=dict(PyLinter.make_options())[
+                                key.replace("_", "-")
+                            ],
+                        )
+                    except KeyError:
+                        # pylint: disable-next=fixme
+                        # TODO: Find good way to double load checkers in unittests
+                        # When options are used by multiple checkers we need to load both of them
+                        # to be able to get an optdict
+                        self.checker.set_option(
+                            key.replace("_", "-"),
+                            value,
+                            optdict={},
+                        )
+            if isinstance(self, CheckerTestCase):
+                # reopen checker in case, it may be interested in configuration change
+                self.checker.open()
+            fun(self, *args, **test_function_kwargs)
+
+        return _forward
+
+    return _wrapper
+
+
+def set_config_directly(**kwargs):
+    """Decorator for setting config values on a checker without validation.
+
+    Some options should be declared in two different checkers. This is
+    impossible without duplicating the option key. For example:
+    "no-docstring-rgx" in DocstringParameterChecker & DocStringChecker
+    This decorator allows to directly set such options.
+
+    Passing the args and kwargs back to the test function itself
+    allows this decorator to be used on parametrized test cases.
+    """
+    # pylint: disable=fixme
+    # TODO: Remove this function in 2.14
+    warnings.warn(
+        "The set_config_directly decorator will be removed in 2.14. To decorate "
+        "unittests you can use set_config. If this causes a duplicate KeyError "
+        "you can consider writing the tests using the functional test framework.",
+        DeprecationWarning,
+    )
+
+    def _wrapper(fun):
+        @functools.wraps(fun)
+        def _forward(self, *args, **test_function_kwargs):
+            for key, value in kwargs.items():
+                setattr(self.checker.config, key, value)
+            if isinstance(self, CheckerTestCase):
+                # reopen checker in case, it may be interested in configuration change
+                self.checker.open()
+            fun(self, *args, **test_function_kwargs)
+
+        return _forward
+
+    return _wrapper
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/functional/__init__.py b/myenv/lib/python3.9/site-packages/pylint/testutils/functional/__init__.py
new file mode 100644
index 0000000..4840e1b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/functional/__init__.py
@@ -0,0 +1,23 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+__all__ = [
+    "FunctionalTestFile",
+    "REASONABLY_DISPLAYABLE_VERTICALLY",
+    "get_functional_test_files_from_directory",
+    "NoFileError",
+    "parse_python_version",
+    "LintModuleOutputUpdate",
+]
+
+from pylint.testutils.functional.find_functional_tests import (
+    REASONABLY_DISPLAYABLE_VERTICALLY,
+    get_functional_test_files_from_directory,
+)
+from pylint.testutils.functional.lint_module_output_update import LintModuleOutputUpdate
+from pylint.testutils.functional.test_file import (
+    FunctionalTestFile,
+    NoFileError,
+    parse_python_version,
+)
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/functional/find_functional_tests.py b/myenv/lib/python3.9/site-packages/pylint/testutils/functional/find_functional_tests.py
new file mode 100644
index 0000000..78d821e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/functional/find_functional_tests.py
@@ -0,0 +1,84 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import os
+from pathlib import Path
+from typing import List, Set, Union
+
+from pylint.testutils.functional.test_file import FunctionalTestFile
+
+REASONABLY_DISPLAYABLE_VERTICALLY = 48
+"""'Wet finger' number of files that are reasonable to display by an IDE."""
+SHOULD_BE_IN_THE_SAME_DIRECTORY = 5
+"""'Wet finger' as in 'in my settings there are precisely this many'."""
+
+IGNORED_PARENT_DIRS = {
+    "deprecated_relative_import",
+    "ext",
+    "regression",
+    "regression_02",
+}
+"""Direct parent directories that should be ignored."""
+
+IGNORED_PARENT_PARENT_DIRS = {
+    "docparams",
+    "deprecated_relative_import",
+    "ext",
+}
+"""Parents of direct parent directories that should be ignored."""
+
+
+def get_functional_test_files_from_directory(
+    input_dir: Union[Path, str]
+) -> List[FunctionalTestFile]:
+    """Get all functional tests in the input_dir."""
+    suite = []
+
+    _check_functional_tests_structure(Path(input_dir))
+
+    for dirpath, _, filenames in os.walk(input_dir):
+        if dirpath.endswith("__pycache__"):
+            continue
+        for filename in filenames:
+            if filename != "__init__.py" and filename.endswith(".py"):
+                suite.append(FunctionalTestFile(dirpath, filename))
+    return suite
+
+
+def _check_functional_tests_structure(directory: Path) -> None:
+    """Check if test directories follow correct file/folder structure."""
+    # Ignore underscored directories
+    if Path(directory).stem.startswith("_"):
+        return
+
+    files: Set[Path] = set()
+    dirs: Set[Path] = set()
+
+    # Collect all subdirectories and files in directory
+    for file_or_dir in directory.iterdir():
+        if file_or_dir.is_file():
+            if file_or_dir.suffix == ".py" and not file_or_dir.stem.startswith("_"):
+                files.add(file_or_dir)
+        elif file_or_dir.is_dir():
+            dirs.add(file_or_dir)
+            _check_functional_tests_structure(file_or_dir)
+
+    assert len(files) <= REASONABLY_DISPLAYABLE_VERTICALLY, (
+        f"{directory} contains too many functional tests files "
+        + f"({len(files)} > {REASONABLY_DISPLAYABLE_VERTICALLY})."
+    )
+
+    for file in files:
+        possible_dir = file.parent / file.stem.split("_")[0]
+        assert not possible_dir.exists(), f"{file} should go in {possible_dir}."
+
+        # Exclude some directories as they follow a different structure
+        if (
+            not len(file.parent.stem) == 1  # First letter subdirectories
+            and file.parent.stem not in IGNORED_PARENT_DIRS
+            and file.parent.parent.stem not in IGNORED_PARENT_PARENT_DIRS
+        ):
+            assert file.stem.startswith(
+                file.parent.stem
+            ), f"{file} should not go in {file.parent}"
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/functional/lint_module_output_update.py b/myenv/lib/python3.9/site-packages/pylint/testutils/functional/lint_module_output_update.py
new file mode 100644
index 0000000..ae57791
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/functional/lint_module_output_update.py
@@ -0,0 +1,55 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import csv
+import os
+from typing import List, Optional
+
+from _pytest.config import Config
+
+from pylint.constants import PY38_PLUS
+from pylint.testutils.functional.test_file import FunctionalTestFile
+from pylint.testutils.lint_module_test import LintModuleTest, MessageCounter
+from pylint.testutils.output_line import OutputLine
+
+
+class LintModuleOutputUpdate(LintModuleTest):
+    """Class to be used if expected output files should be updated instead of checked."""
+
+    class TestDialect(csv.excel):
+        """Dialect used by the csv writer."""
+
+        delimiter = ":"
+        lineterminator = "\n"
+
+    csv.register_dialect("test", TestDialect)
+
+    def __init__(
+        self, test_file: FunctionalTestFile, config: Optional[Config] = None
+    ) -> None:
+        if not PY38_PLUS:
+            raise RuntimeError(
+                "You need at least python 3.8 for the functional test updater to work. "
+                "This is because python 3.8 includes a new AST parser, which amongst others "
+                "returns the end line and end column of most nodes."
+            )
+        super().__init__(test_file, config)
+
+    def _check_output_text(
+        self,
+        _: MessageCounter,
+        expected_output: List[OutputLine],
+        actual_output: List[OutputLine],
+    ) -> None:
+        """Overwrite or remove the expected output file based on actual output."""
+        # Remove the file if no output is actually expected and a file exists
+        if not expected_output and not actual_output:
+            if os.path.exists(self._test_file.expected_output):
+                os.remove(self._test_file.expected_output)
+            return
+        # Write file with expected output
+        with open(self._test_file.expected_output, "w", encoding="utf-8") as f:
+            writer = csv.writer(f, dialect="test")
+            for line in actual_output:
+                writer.writerow(line.to_csv())
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/functional/test_file.py b/myenv/lib/python3.9/site-packages/pylint/testutils/functional/test_file.py
new file mode 100644
index 0000000..ae8d0f2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/functional/test_file.py
@@ -0,0 +1,111 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import configparser
+import sys
+from os.path import basename, exists, join
+from typing import Callable, Dict, List, Tuple, Union
+
+
+def parse_python_version(ver_str: str) -> Tuple[int, ...]:
+    """Convert python version to a tuple of integers for easy comparison."""
+    return tuple(int(digit) for digit in ver_str.split("."))
+
+
+class NoFileError(Exception):
+    pass
+
+
+if sys.version_info >= (3, 8):
+    from typing import TypedDict
+else:
+    from typing_extensions import TypedDict
+
+
+class TestFileOptions(TypedDict):
+    min_pyver: Tuple[int, ...]
+    max_pyver: Tuple[int, ...]
+    min_pyver_end_position: Tuple[int, ...]
+    requires: List[str]
+    except_implementations: List[str]
+    exclude_platforms: List[str]
+
+
+# mypy need something literal, we can't create this dynamically from TestFileOptions
+POSSIBLE_TEST_OPTIONS = {
+    "min_pyver",
+    "max_pyver",
+    "min_pyver_end_position",
+    "requires",
+    "except_implementations",
+    "exclude_platforms",
+}
+
+
+class FunctionalTestFile:
+    """A single functional test case file with options."""
+
+    _CONVERTERS: Dict[str, Callable[[str], Union[Tuple[int, ...], List[str]]]] = {
+        "min_pyver": parse_python_version,
+        "max_pyver": parse_python_version,
+        "min_pyver_end_position": parse_python_version,
+        "requires": lambda s: [i.strip() for i in s.split(",")],
+        "except_implementations": lambda s: [i.strip() for i in s.split(",")],
+        "exclude_platforms": lambda s: [i.strip() for i in s.split(",")],
+    }
+
+    def __init__(self, directory: str, filename: str) -> None:
+        self._directory = directory
+        self.base = filename.replace(".py", "")
+        self.options: TestFileOptions = {
+            "min_pyver": (2, 5),
+            "max_pyver": (4, 0),
+            "min_pyver_end_position": (3, 8),
+            "requires": [],
+            "except_implementations": [],
+            "exclude_platforms": [],
+        }
+        self._parse_options()
+
+    def __repr__(self) -> str:
+        return f"FunctionalTest:{self.base}"
+
+    def _parse_options(self) -> None:
+        cp = configparser.ConfigParser()
+        cp.add_section("testoptions")
+        try:
+            cp.read(self.option_file)
+        except NoFileError:
+            pass
+
+        for name, value in cp.items("testoptions"):
+            conv = self._CONVERTERS.get(name, lambda v: v)
+
+            assert (
+                name in POSSIBLE_TEST_OPTIONS
+            ), f"[testoptions]' can only contains one of {POSSIBLE_TEST_OPTIONS}"
+            self.options[name] = conv(value)  # type: ignore[literal-required]
+
+    @property
+    def option_file(self) -> str:
+        return self._file_type(".rc")
+
+    @property
+    def module(self) -> str:
+        package = basename(self._directory)
+        return ".".join([package, self.base])
+
+    @property
+    def expected_output(self) -> str:
+        return self._file_type(".txt", check_exists=False)
+
+    @property
+    def source(self) -> str:
+        return self._file_type(".py")
+
+    def _file_type(self, ext: str, check_exists: bool = True) -> str:
+        name = join(self._directory, self.base + ext)
+        if not check_exists or exists(name):
+            return name
+        raise NoFileError(f"Cannot find '{name}'.")
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/functional_test_file.py b/myenv/lib/python3.9/site-packages/pylint/testutils/functional_test_file.py
new file mode 100644
index 0000000..fc1cdcb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/functional_test_file.py
@@ -0,0 +1,23 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+__all__ = [
+    "FunctionalTestFile",
+    "NoFileError",
+    "parse_python_version",
+]
+
+import warnings
+
+from pylint.testutils.functional import (
+    FunctionalTestFile,
+    NoFileError,
+    parse_python_version,
+)
+
+warnings.warn(
+    "'pylint.testutils.functional_test_file' will be accessible from"
+    " the 'pylint.testutils.functional' namespace in pylint 3.0.",
+    DeprecationWarning,
+)
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/get_test_info.py b/myenv/lib/python3.9/site-packages/pylint/testutils/get_test_info.py
new file mode 100644
index 0000000..d0bf8f4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/get_test_info.py
@@ -0,0 +1,49 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from glob import glob
+from os.path import basename, join, splitext
+from typing import List, Tuple
+
+from pylint.testutils.constants import SYS_VERS_STR
+
+
+def _get_tests_info(
+    input_dir: str, msg_dir: str, prefix: str, suffix: str
+) -> List[Tuple[str, str]]:
+    """Get python input examples and output messages.
+
+    We use following conventions for input files and messages:
+    for different inputs:
+        test for python  >= x.y    ->  input   =  <name>_pyxy.py
+        test for python  <  x.y    ->  input   =  <name>_py_xy.py
+    for one input and different messages:
+        message for python >=  x.y ->  message =  <name>_pyxy.txt
+        lower versions             ->  message with highest num
+    """
+    result = []
+    for fname in glob(join(input_dir, prefix + "*" + suffix)):
+        infile = basename(fname)
+        fbase = splitext(infile)[0]
+        # filter input files :
+        pyrestr = fbase.rsplit("_py", 1)[-1]  # like _26 or 26
+        if pyrestr.isdigit():  # '24', '25'...
+            if pyrestr.isdigit() and int(SYS_VERS_STR) < int(pyrestr):
+                continue
+        if pyrestr.startswith("_") and pyrestr[1:].isdigit():
+            # skip test for higher python versions
+            if pyrestr[1:].isdigit() and int(SYS_VERS_STR) >= int(pyrestr[1:]):
+                continue
+        messages = glob(join(msg_dir, fbase + "*.txt"))
+        # the last one will be without ext, i.e. for all or upper versions:
+        if messages:
+            for outfile in sorted(messages, reverse=True):
+                py_rest = outfile.rsplit("_py", 1)[-1][:-4]
+                if py_rest.isdigit() and int(SYS_VERS_STR) >= int(py_rest):
+                    break
+        else:
+            # This will provide an error message indicating the missing filename.
+            outfile = join(msg_dir, fbase + ".txt")
+        result.append((infile, outfile))
+    return result
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/global_test_linter.py b/myenv/lib/python3.9/site-packages/pylint/testutils/global_test_linter.py
new file mode 100644
index 0000000..f6f421d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/global_test_linter.py
@@ -0,0 +1,20 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from pylint import checkers
+from pylint.lint import PyLinter
+from pylint.testutils.reporter_for_tests import GenericTestReporter
+
+
+def create_test_linter():
+    test_reporter = GenericTestReporter()
+    linter_ = PyLinter()
+    linter_.set_reporter(test_reporter)
+    linter_.config.persistent = 0
+    checkers.initialize(linter_)
+    return linter_
+
+
+# Can't be renamed to a constant (easily), it breaks countless tests
+linter = create_test_linter()
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/lint_module_test.py b/myenv/lib/python3.9/site-packages/pylint/testutils/lint_module_test.py
new file mode 100644
index 0000000..3bac078
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/lint_module_test.py
@@ -0,0 +1,266 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import csv
+import operator
+import platform
+import sys
+from collections import Counter
+from io import StringIO
+from pathlib import Path
+from typing import Counter as CounterType
+from typing import Dict, List, Optional, TextIO, Tuple, Union
+
+import pytest
+from _pytest.config import Config
+
+from pylint import checkers
+from pylint.config.config_initialization import _config_initialization
+from pylint.lint import PyLinter
+from pylint.message.message import Message
+from pylint.testutils.constants import _EXPECTED_RE, _OPERATORS, UPDATE_OPTION
+from pylint.testutils.functional.test_file import (  # need to import from functional.test_file to avoid cyclic import
+    FunctionalTestFile,
+    NoFileError,
+    parse_python_version,
+)
+from pylint.testutils.output_line import OutputLine
+from pylint.testutils.reporter_for_tests import FunctionalTestReporter
+
+MessageCounter = CounterType[Tuple[int, str]]
+
+PYLINTRC = Path(__file__).parent / "testing_pylintrc"
+
+
+class LintModuleTest:
+    maxDiff = None
+
+    def __init__(
+        self, test_file: FunctionalTestFile, config: Optional[Config] = None
+    ) -> None:
+        _test_reporter = FunctionalTestReporter()
+        self._linter = PyLinter()
+        self._linter.config.persistent = 0
+        checkers.initialize(self._linter)
+
+        # See if test has its own .rc file, if so we use that one
+        rc_file: Union[Path, str] = PYLINTRC
+        try:
+            rc_file = test_file.option_file
+            self._linter.disable("suppressed-message")
+            self._linter.disable("locally-disabled")
+            self._linter.disable("useless-suppression")
+        except NoFileError:
+            pass
+
+        try:
+            args = [test_file.source]
+        except NoFileError:
+            # If we're still raising NoFileError the actual source file doesn't exist
+            args = [""]
+        _config_initialization(
+            self._linter, args_list=args, config_file=rc_file, reporter=_test_reporter
+        )
+        self._test_file = test_file
+        self._config = config
+        self._check_end_position = (
+            sys.version_info >= self._test_file.options["min_pyver_end_position"]
+        )
+
+    def setUp(self) -> None:
+        if self._should_be_skipped_due_to_version():
+            pytest.skip(
+                f"Test cannot run with Python {sys.version.split(' ', maxsplit=1)[0]}."
+            )
+        missing = []
+        for requirement in self._test_file.options["requires"]:
+            try:
+                __import__(requirement)
+            except ImportError:
+                missing.append(requirement)
+        if missing:
+            pytest.skip(f"Requires {','.join(missing)} to be present.")
+        except_implementations = self._test_file.options["except_implementations"]
+        if except_implementations:
+            if platform.python_implementation() in except_implementations:
+                msg = "Test cannot run with Python implementation %r"
+                pytest.skip(msg % platform.python_implementation())
+        excluded_platforms = self._test_file.options["exclude_platforms"]
+        if excluded_platforms:
+            if sys.platform.lower() in excluded_platforms:
+                pytest.skip(f"Test cannot run on platform {sys.platform!r}")
+
+    def runTest(self) -> None:
+        self._runTest()
+
+    def _should_be_skipped_due_to_version(self) -> bool:
+        return (
+            sys.version_info < self._test_file.options["min_pyver"]
+            or sys.version_info > self._test_file.options["max_pyver"]
+        )
+
+    def __str__(self) -> str:
+        return f"{self._test_file.base} ({self.__class__.__module__}.{self.__class__.__name__})"
+
+    @staticmethod
+    def get_expected_messages(stream: TextIO) -> MessageCounter:
+        """Parses a file and get expected messages.
+
+        :param stream: File-like input stream.
+        :type stream: enumerable
+        :returns: A dict mapping line,msg-symbol tuples to the count on this line.
+        :rtype: dict
+        """
+        messages: MessageCounter = Counter()
+        for i, line in enumerate(stream):
+            match = _EXPECTED_RE.search(line)
+            if match is None:
+                continue
+            line = match.group("line")
+            if line is None:
+                lineno = i + 1
+            elif line.startswith("+") or line.startswith("-"):
+                lineno = i + 1 + int(line)
+            else:
+                lineno = int(line)
+
+            version = match.group("version")
+            op = match.group("op")
+            if version:
+                required = parse_python_version(version)
+                if not _OPERATORS[op](sys.version_info, required):
+                    continue
+
+            for msg_id in match.group("msgs").split(","):
+                messages[lineno, msg_id.strip()] += 1
+        return messages
+
+    @staticmethod
+    def multiset_difference(
+        expected_entries: MessageCounter,
+        actual_entries: MessageCounter,
+    ) -> Tuple[MessageCounter, Dict[Tuple[int, str], int]]:
+        """Takes two multisets and compares them.
+
+        A multiset is a dict with the cardinality of the key as the value.
+        """
+        missing = expected_entries.copy()
+        missing.subtract(actual_entries)
+        unexpected = {}
+        for key, value in list(missing.items()):
+            if value <= 0:
+                missing.pop(key)
+                if value < 0:
+                    unexpected[key] = -value
+        return missing, unexpected
+
+    def _open_expected_file(self) -> TextIO:
+        try:
+            return open(self._test_file.expected_output, encoding="utf-8")
+        except FileNotFoundError:
+            return StringIO("")
+
+    def _open_source_file(self) -> TextIO:
+        if self._test_file.base == "invalid_encoded_data":
+            return open(self._test_file.source, encoding="utf-8")
+        if "latin1" in self._test_file.base:
+            return open(self._test_file.source, encoding="latin1")
+        return open(self._test_file.source, encoding="utf8")
+
+    def _get_expected(self) -> Tuple[MessageCounter, List[OutputLine]]:
+        with self._open_source_file() as f:
+            expected_msgs = self.get_expected_messages(f)
+        if not expected_msgs:
+            expected_msgs = Counter()
+        with self._open_expected_file() as f:
+            expected_output_lines = [
+                OutputLine.from_csv(row, self._check_end_position)
+                for row in csv.reader(f, "test")
+            ]
+        return expected_msgs, expected_output_lines
+
+    def _get_actual(self) -> Tuple[MessageCounter, List[OutputLine]]:
+        messages: List[Message] = self._linter.reporter.messages
+        messages.sort(key=lambda m: (m.line, m.symbol, m.msg))
+        received_msgs: MessageCounter = Counter()
+        received_output_lines = []
+        for msg in messages:
+            assert (
+                msg.symbol != "fatal"
+            ), f"Pylint analysis failed because of '{msg.msg}'"
+            received_msgs[msg.line, msg.symbol] += 1
+            received_output_lines.append(
+                OutputLine.from_msg(msg, self._check_end_position)
+            )
+        return received_msgs, received_output_lines
+
+    def _runTest(self) -> None:
+        __tracebackhide__ = True  # pylint: disable=unused-variable
+        modules_to_check = [self._test_file.source]
+        self._linter.check(modules_to_check)
+        expected_messages, expected_output = self._get_expected()
+        actual_messages, actual_output = self._get_actual()
+        assert (
+            expected_messages == actual_messages
+        ), self.error_msg_for_unequal_messages(
+            actual_messages, expected_messages, actual_output
+        )
+        self._check_output_text(expected_messages, expected_output, actual_output)
+
+    def error_msg_for_unequal_messages(
+        self,
+        actual_messages: MessageCounter,
+        expected_messages: MessageCounter,
+        actual_output: List[OutputLine],
+    ) -> str:
+        msg = [f'Wrong results for file "{self._test_file.base}":']
+        missing, unexpected = self.multiset_difference(
+            expected_messages, actual_messages
+        )
+        if missing:
+            msg.append("\nExpected in testdata:")
+            msg.extend(f" {msg[0]:3}: {msg[1]}" for msg in sorted(missing))
+        if unexpected:
+            msg.append("\nUnexpected in testdata:")
+            msg.extend(f" {msg[0]:3}: {msg[1]}" for msg in sorted(unexpected))
+        error_msg = "\n".join(msg)
+        if self._config and self._config.getoption("verbose") > 0:
+            error_msg += "\n\nActual pylint output for this file:\n"
+            error_msg += "\n".join(str(o) for o in actual_output)
+        return error_msg
+
+    def error_msg_for_unequal_output(
+        self,
+        expected_lines: List[OutputLine],
+        received_lines: List[OutputLine],
+    ) -> str:
+        missing = set(expected_lines) - set(received_lines)
+        unexpected = set(received_lines) - set(expected_lines)
+        error_msg = (
+            f"Wrong output for '{self._test_file.base}.txt':\n"
+            "You can update the expected output automatically with: '"
+            f"python tests/test_functional.py {UPDATE_OPTION} -k "
+            f'"test_functional[{self._test_file.base}]"\'\n\n'
+        )
+        sort_by_line_number = operator.attrgetter("lineno")
+        if missing:
+            error_msg += "\n- Missing lines:\n"
+            for line in sorted(missing, key=sort_by_line_number):
+                error_msg += f"{line}\n"
+        if unexpected:
+            error_msg += "\n- Unexpected lines:\n"
+            for line in sorted(unexpected, key=sort_by_line_number):
+                error_msg += f"{line}\n"
+        return error_msg
+
+    def _check_output_text(
+        self,
+        _: MessageCounter,
+        expected_output: List[OutputLine],
+        actual_output: List[OutputLine],
+    ) -> None:
+        """This is a function because we want to be able to update the text in LintModuleOutputUpdate."""
+        assert expected_output == actual_output, self.error_msg_for_unequal_output(
+            expected_output, actual_output
+        )
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/output_line.py b/myenv/lib/python3.9/site-packages/pylint/testutils/output_line.py
new file mode 100644
index 0000000..f6461ad
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/output_line.py
@@ -0,0 +1,193 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import warnings
+from typing import Any, NamedTuple, Optional, Sequence, Tuple, TypeVar, Union
+
+from astroid import nodes
+
+from pylint.constants import PY38_PLUS
+from pylint.interfaces import UNDEFINED, Confidence
+from pylint.message.message import Message
+from pylint.testutils.constants import UPDATE_OPTION
+
+T = TypeVar("T")
+
+
+class MessageTest(NamedTuple):
+    msg_id: str
+    line: Optional[int] = None
+    node: Optional[nodes.NodeNG] = None
+    args: Optional[Any] = None
+    confidence: Optional[Confidence] = UNDEFINED
+    col_offset: Optional[int] = None
+    end_line: Optional[int] = None
+    end_col_offset: Optional[int] = None
+    """Used to test messages produced by pylint.
+
+    Class name cannot start with Test as pytest doesn't allow constructors in test classes.
+    """
+
+
+class MalformedOutputLineException(Exception):
+    def __init__(
+        self,
+        row: Union[Sequence[str], str],
+        exception: Exception,
+    ) -> None:
+        example = "msg-symbolic-name:42:27:MyClass.my_function:The message"
+        other_example = "msg-symbolic-name:7:42::The message"
+        expected = [
+            "symbol",
+            "line",
+            "column",
+            "end_line",
+            "end_column",
+            "MyClass.myFunction, (or '')",
+            "Message",
+            "confidence",
+        ]
+        reconstructed_row = ""
+        i = 0
+        try:
+            for i, column in enumerate(row):
+                reconstructed_row += f"\t{expected[i]}='{column}' ?\n"
+            for missing in expected[i + 1 :]:
+                reconstructed_row += f"\t{missing}= Nothing provided !\n"
+        except IndexError:
+            pass
+        raw = ":".join(row)
+        msg = f"""\
+{exception}
+
+Expected '{example}' or '{other_example}' but we got '{raw}':
+{reconstructed_row}
+
+Try updating it with: 'python tests/test_functional.py {UPDATE_OPTION}'"""
+        super().__init__(msg)
+
+
+class OutputLine(NamedTuple):
+    symbol: str
+    lineno: int
+    column: int
+    end_lineno: Optional[int]
+    end_column: Optional[int]
+    object: str
+    msg: str
+    confidence: str
+
+    @classmethod
+    def from_msg(cls, msg: Message, check_endline: bool = True) -> "OutputLine":
+        """Create an OutputLine from a Pylint Message."""
+        column = cls._get_column(msg.column)
+        end_line = cls._get_py38_none_value(msg.end_line, check_endline)
+        end_column = cls._get_py38_none_value(msg.end_column, check_endline)
+        return cls(
+            msg.symbol,
+            msg.line,
+            column,
+            end_line,
+            end_column,
+            msg.obj or "",
+            msg.msg.replace("\r\n", "\n"),
+            msg.confidence.name,
+        )
+
+    @staticmethod
+    def _get_column(column: str) -> int:
+        """Handle column numbers except for python < 3.8.
+
+        The ast parser in those versions doesn't return them.
+        """
+        if not PY38_PLUS:
+            # We check the column only for the new better ast parser introduced in python 3.8
+            return 0  # pragma: no cover
+        return int(column)
+
+    @staticmethod
+    def _get_py38_none_value(value: T, check_endline: bool) -> Optional[T]:
+        """Used to make end_line and end_column None as indicated by our version compared to
+        `min_pyver_end_position`.
+        """
+        if not check_endline:
+            return None  # pragma: no cover
+        return value
+
+    @classmethod
+    def from_csv(
+        cls, row: Union[Sequence[str], str], check_endline: bool = True
+    ) -> "OutputLine":
+        """Create an OutputLine from a comma separated list (the functional tests expected
+        output .txt files).
+        """
+        if isinstance(row, str):
+            row = row.split(",")
+        try:
+            column = cls._get_column(row[2])
+            if len(row) == 5:
+                warnings.warn(
+                    "In pylint 3.0 functional tests expected output should always include the "
+                    "expected confidence level, expected end_line and expected end_column. "
+                    "An OutputLine should thus have a length of 8.",
+                    DeprecationWarning,
+                )
+                return cls(
+                    row[0],
+                    int(row[1]),
+                    column,
+                    None,
+                    None,
+                    row[3],
+                    row[4],
+                    UNDEFINED.name,
+                )
+            if len(row) == 6:
+                warnings.warn(
+                    "In pylint 3.0 functional tests expected output should always include the "
+                    "expected end_line and expected end_column. An OutputLine should thus have "
+                    "a length of 8.",
+                    DeprecationWarning,
+                )
+                return cls(
+                    row[0], int(row[1]), column, None, None, row[3], row[4], row[5]
+                )
+            if len(row) == 8:
+                end_line = cls._get_py38_none_value(row[3], check_endline)
+                end_column = cls._get_py38_none_value(row[4], check_endline)
+                return cls(
+                    row[0],
+                    int(row[1]),
+                    column,
+                    cls._value_to_optional_int(end_line),
+                    cls._value_to_optional_int(end_column),
+                    row[5],
+                    row[6],
+                    row[7],
+                )
+            raise IndexError
+        except Exception as e:
+            raise MalformedOutputLineException(row, e) from e
+
+    def to_csv(self) -> Tuple[str, str, str, str, str, str, str, str]:
+        """Convert an OutputLine to a tuple of string to be written by a
+        csv-writer.
+        """
+        return (
+            str(self.symbol),
+            str(self.lineno),
+            str(self.column),
+            str(self.end_lineno),
+            str(self.end_column),
+            str(self.object),
+            str(self.msg),
+            str(self.confidence),
+        )
+
+    @staticmethod
+    def _value_to_optional_int(value: Optional[str]) -> Optional[int]:
+        """Checks if a (stringified) value should be None or a Python integer."""
+        if value == "None" or not value:
+            return None
+        return int(value)
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/primer.py b/myenv/lib/python3.9/site-packages/pylint/testutils/primer.py
new file mode 100644
index 0000000..e0f6f2e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/primer.py
@@ -0,0 +1,111 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+import git
+
+PRIMER_DIRECTORY_PATH = Path(".pylint_primer_tests")
+
+
+class PackageToLint:
+    """Represents data about a package to be tested during primer tests."""
+
+    url: str
+    """URL of the repository to clone."""
+
+    branch: str
+    """Branch of the repository to clone."""
+
+    directories: List[str]
+    """Directories within the repository to run pylint over."""
+
+    commit: Optional[str]
+    """Commit hash to pin the repository on."""
+
+    pylint_additional_args: List[str]
+    """Arguments to give to pylint."""
+
+    pylintrc_relpath: Optional[str]
+    """Path relative to project's main directory to the pylintrc if it exists."""
+
+    def __init__(
+        self,
+        url: str,
+        branch: str,
+        directories: List[str],
+        commit: Optional[str] = None,
+        pylint_additional_args: Optional[List[str]] = None,
+        pylintrc_relpath: Optional[str] = None,
+    ) -> None:
+        self.url = url
+        self.branch = branch
+        self.directories = directories
+        self.commit = commit
+        self.pylint_additional_args = pylint_additional_args or []
+        self.pylintrc_relpath = pylintrc_relpath
+
+    @property
+    def pylintrc(self) -> Optional[Path]:
+        if self.pylintrc_relpath is None:
+            return None
+        return self.clone_directory / self.pylintrc_relpath
+
+    @property
+    def clone_directory(self) -> Path:
+        """Directory to clone repository into."""
+        clone_name = "/".join(self.url.split("/")[-2:]).replace(".git", "")
+        return PRIMER_DIRECTORY_PATH / clone_name
+
+    @property
+    def paths_to_lint(self) -> List[str]:
+        """The paths we need to lint."""
+        return [str(self.clone_directory / path) for path in self.directories]
+
+    @property
+    def pylint_args(self) -> List[str]:
+        options: List[str] = []
+        if self.pylintrc is not None:
+            # There is an error if rcfile is given but does not exist
+            options += [f"--rcfile={self.pylintrc}"]
+        return self.paths_to_lint + options + self.pylint_additional_args
+
+    def lazy_clone(self) -> None:  # pragma: no cover
+        """Concatenates the target directory and clones the file.
+
+        Not expected to be tested as the primer won't work if it doesn't.
+        It's tested in the continuous integration primers, only the coverage
+        is not calculated on everything. If lazy clone breaks for local use
+        we'll probably notice because we'll have a fatal when launching the
+        primer locally.
+        """
+        logging.info("Lazy cloning %s", self.url)
+        if not self.clone_directory.exists():
+            options: Dict[str, Union[str, int]] = {
+                "url": self.url,
+                "to_path": str(self.clone_directory),
+                "branch": self.branch,
+                "depth": 1,
+            }
+            logging.info("Directory does not exists, cloning: %s", options)
+            git.Repo.clone_from(**options)
+            return
+
+        remote_sha1_commit = (
+            git.cmd.Git().ls_remote(self.url, self.branch).split("\t")[0]
+        )
+        local_sha1_commit = git.Repo(self.clone_directory).head.object.hexsha
+        if remote_sha1_commit != local_sha1_commit:
+            logging.info(
+                "Remote sha is '%s' while local sha is '%s': pulling new commits",
+                remote_sha1_commit,
+                local_sha1_commit,
+            )
+            repo = git.Repo(self.clone_directory)
+            origin = repo.remotes.origin
+            origin.pull()
+        else:
+            logging.info("Repository already up to date.")
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/pyreverse.py b/myenv/lib/python3.9/site-packages/pylint/testutils/pyreverse.py
new file mode 100644
index 0000000..f4e9bc7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/pyreverse.py
@@ -0,0 +1,51 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import List, Optional, Tuple
+
+
+# This class could and should be replaced with a simple dataclass when support for Python < 3.7 is dropped.
+# A NamedTuple is not possible as some tests need to modify attributes during the test.
+class PyreverseConfig:  # pylint: disable=too-many-instance-attributes, too-many-arguments
+    """Holds the configuration options for Pyreverse.
+
+    The default values correspond to the defaults of the options' parser.
+    """
+
+    def __init__(
+        self,
+        mode: str = "PUB_ONLY",
+        classes: Optional[List[str]] = None,
+        show_ancestors: Optional[int] = None,
+        all_ancestors: Optional[bool] = None,
+        show_associated: Optional[int] = None,
+        all_associated: Optional[bool] = None,
+        show_builtin: bool = False,
+        module_names: Optional[bool] = None,
+        only_classnames: bool = False,
+        output_format: str = "dot",
+        colorized: bool = False,
+        max_color_depth: int = 2,
+        ignore_list: Tuple[str, ...] = tuple(),
+        project: str = "",
+        output_directory: str = "",
+    ) -> None:
+        self.mode = mode
+        if classes:
+            self.classes = classes
+        else:
+            self.classes = []
+        self.show_ancestors = show_ancestors
+        self.all_ancestors = all_ancestors
+        self.show_associated = show_associated
+        self.all_associated = all_associated
+        self.show_builtin = show_builtin
+        self.module_names = module_names
+        self.only_classnames = only_classnames
+        self.output_format = output_format
+        self.colorized = colorized
+        self.max_color_depth = max_color_depth
+        self.ignore_list = ignore_list
+        self.project = project
+        self.output_directory = output_directory
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/reporter_for_tests.py b/myenv/lib/python3.9/site-packages/pylint/testutils/reporter_for_tests.py
new file mode 100644
index 0000000..47c12a3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/reporter_for_tests.py
@@ -0,0 +1,82 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from io import StringIO
+from os import getcwd, sep
+from typing import TYPE_CHECKING, List, Optional
+
+from pylint import interfaces
+from pylint.message import Message
+from pylint.reporters import BaseReporter
+
+if TYPE_CHECKING:
+    from pylint.reporters.ureports.nodes import Section
+
+
+class GenericTestReporter(BaseReporter):
+    """Reporter storing plain text messages."""
+
+    __implements__ = interfaces.IReporter
+    out: StringIO
+
+    def __init__(  # pylint: disable=super-init-not-called # See https://github.com/PyCQA/pylint/issues/4941
+        self,
+    ) -> None:
+        self.path_strip_prefix: str = getcwd() + sep
+        self.reset()
+
+    def reset(self) -> None:
+        self.out = StringIO()
+        self.messages: List[Message] = []
+
+    def handle_message(self, msg: Message) -> None:
+        """Append messages to the list of messages of the reporter."""
+        self.messages.append(msg)
+
+    def finalize(self) -> str:
+        """Format and print messages in the context of the path."""
+        messages: List[str] = []
+        for msg in self.messages:
+            obj = ""
+            if msg.obj:
+                obj = f":{msg.obj}"
+            messages.append(f"{msg.msg_id[0]}:{msg.line:>3}{obj}: {msg.msg}")
+
+        messages.sort()
+        for message in messages:
+            print(message, file=self.out)
+
+        result = self.out.getvalue()
+        self.reset()
+        return result
+
+    def on_set_current_module(self, module: str, filepath: Optional[str]) -> None:
+        pass
+
+    # pylint: enable=unused-argument
+
+    def display_reports(self, layout: "Section") -> None:
+        """Ignore layouts."""
+
+    def _display(self, layout: "Section") -> None:
+        pass
+
+
+class MinimalTestReporter(BaseReporter):
+    def on_set_current_module(self, module: str, filepath: Optional[str]) -> None:
+        self.messages = []
+
+    def _display(self, layout: "Section") -> None:
+        pass
+
+
+class FunctionalTestReporter(BaseReporter):
+    def on_set_current_module(self, module: str, filepath: Optional[str]) -> None:
+        self.messages = []
+
+    def display_reports(self, layout: "Section") -> None:
+        """Ignore layouts and don't call self._display()."""
+
+    def _display(self, layout: "Section") -> None:
+        pass
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/testing_pylintrc b/myenv/lib/python3.9/site-packages/pylint/testutils/testing_pylintrc
new file mode 100644
index 0000000..ba5318b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/testing_pylintrc
@@ -0,0 +1,9 @@
+# A bare minimum pylintrc used for the functional tests that don't specify
+# their own settings.
+
+[MESSAGES CONTROL]
+
+disable=
+    suppressed-message,
+    locally-disabled,
+    useless-suppression,
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/tokenize_str.py b/myenv/lib/python3.9/site-packages/pylint/testutils/tokenize_str.py
new file mode 100644
index 0000000..0b478c3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/tokenize_str.py
@@ -0,0 +1,12 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import tokenize
+from io import StringIO
+from tokenize import TokenInfo
+from typing import List
+
+
+def _tokenize_str(code: str) -> List[TokenInfo]:
+    return list(tokenize.generate_tokens(StringIO(code).readline))
diff --git a/myenv/lib/python3.9/site-packages/pylint/testutils/unittest_linter.py b/myenv/lib/python3.9/site-packages/pylint/testutils/unittest_linter.py
new file mode 100644
index 0000000..a7d7fc0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/testutils/unittest_linter.py
@@ -0,0 +1,88 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+from typing import Any, Optional
+
+from astroid import nodes
+
+from pylint.interfaces import UNDEFINED, Confidence
+from pylint.testutils.global_test_linter import linter
+from pylint.testutils.output_line import MessageTest
+from pylint.utils import LinterStats
+
+
+class UnittestLinter:
+    """A fake linter class to capture checker messages."""
+
+    # pylint: disable=unused-argument
+
+    def __init__(self):
+        self._messages = []
+        self.stats = LinterStats()
+
+    def release_messages(self):
+        try:
+            return self._messages
+        finally:
+            self._messages = []
+
+    def add_message(
+        self,
+        msg_id: str,
+        line: Optional[int] = None,
+        # pylint: disable=fixme
+        # TODO: Make node non optional
+        node: Optional[nodes.NodeNG] = None,
+        args: Any = None,
+        confidence: Optional[Confidence] = None,
+        col_offset: Optional[int] = None,
+        end_lineno: Optional[int] = None,
+        end_col_offset: Optional[int] = None,
+    ) -> None:
+        """Add a MessageTest to the _messages attribute of the linter class."""
+        # If confidence is None we set it to UNDEFINED as well in PyLinter
+        if confidence is None:
+            confidence = UNDEFINED
+
+        # Look up "location" data of node if not yet supplied
+        if node:
+            if node.position:
+                if not line:
+                    line = node.position.lineno
+                if not col_offset:
+                    col_offset = node.position.col_offset
+                if not end_lineno:
+                    end_lineno = node.position.end_lineno
+                if not end_col_offset:
+                    end_col_offset = node.position.end_col_offset
+            else:
+                if not line:
+                    line = node.fromlineno
+                if not col_offset:
+                    col_offset = node.col_offset
+                if not end_lineno:
+                    end_lineno = node.end_lineno
+                if not end_col_offset:
+                    end_col_offset = node.end_col_offset
+
+        self._messages.append(
+            MessageTest(
+                msg_id,
+                line,
+                node,
+                args,
+                confidence,
+                col_offset,
+                end_lineno,
+                end_col_offset,
+            )
+        )
+
+    @staticmethod
+    def is_message_enabled(*unused_args, **unused_kwargs):
+        return True
+
+    @property
+    def options_providers(self):
+        return linter.options_providers
diff --git a/myenv/lib/python3.9/site-packages/pylint/typing.py b/myenv/lib/python3.9/site-packages/pylint/typing.py
new file mode 100644
index 0000000..32b2ac4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/typing.py
@@ -0,0 +1,73 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""A collection of typing utilities."""
+import sys
+from typing import NamedTuple, Optional, Union
+
+if sys.version_info >= (3, 8):
+    from typing import Literal, TypedDict
+else:
+    from typing_extensions import Literal, TypedDict
+
+
+class FileItem(NamedTuple):
+    """Represents data about a file handled by pylint.
+
+    Each file item has:
+    - name: full name of the module
+    - filepath: path of the file
+    - modname: module name
+    """
+
+    name: str
+    filepath: str
+    modpath: str
+
+
+class ModuleDescriptionDict(TypedDict):
+    """Represents data about a checked module."""
+
+    path: str
+    name: str
+    isarg: bool
+    basepath: str
+    basename: str
+
+
+class ErrorDescriptionDict(TypedDict):
+    """Represents data about errors collected during checking of a module."""
+
+    key: Literal["fatal"]
+    mod: str
+    ex: Union[ImportError, SyntaxError]
+
+
+class MessageLocationTuple(NamedTuple):
+    """Tuple with information about the location of a to-be-displayed message."""
+
+    abspath: str
+    path: str
+    module: str
+    obj: str
+    line: int
+    column: int
+    end_line: Optional[int] = None
+    end_column: Optional[int] = None
+
+
+class ManagedMessage(NamedTuple):
+    """Tuple with information about a managed message of the linter."""
+
+    name: Optional[str]
+    msgid: str
+    symbol: str
+    line: Optional[int]
+    is_disabled: bool
+
+
+MessageTypesFullName = Literal[
+    "convention", "error", "fatal", "info", "refactor", "statement", "warning"
+]
+"""All possible message categories."""
diff --git a/myenv/lib/python3.9/site-packages/pylint/utils/__init__.py b/myenv/lib/python3.9/site-packages/pylint/utils/__init__.py
new file mode 100644
index 0000000..51813f9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/utils/__init__.py
@@ -0,0 +1,55 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Some various utilities and helper classes, most of them used in the
+main pylint class
+"""
+
+from pylint.utils.ast_walker import ASTWalker
+from pylint.utils.docs import print_full_documentation
+from pylint.utils.file_state import FileState
+from pylint.utils.linterstats import LinterStats, ModuleStats, merge_stats
+from pylint.utils.utils import (
+    HAS_ISORT_5,
+    IsortDriver,
+    _check_csv,
+    _format_option_value,
+    _splitstrip,
+    _unquote,
+    decoding_stream,
+    diff_string,
+    format_section,
+    get_global_option,
+    get_module_and_frameid,
+    get_rst_section,
+    get_rst_title,
+    normalize_text,
+    register_plugins,
+    tokenize_module,
+)
+
+__all__ = [
+    "ASTWalker",
+    "HAS_ISORT_5",
+    "IsortDriver",
+    "_check_csv",
+    "_format_option_value",
+    "_splitstrip",
+    "_unquote",
+    "decoding_stream",
+    "diff_string",
+    "FileState",
+    "format_section",
+    "get_global_option",
+    "get_module_and_frameid",
+    "get_rst_section",
+    "get_rst_title",
+    "normalize_text",
+    "register_plugins",
+    "tokenize_module",
+    "merge_stats",
+    "LinterStats",
+    "ModuleStats",
+    "print_full_documentation",
+]
diff --git a/myenv/lib/python3.9/site-packages/pylint/utils/ast_walker.py b/myenv/lib/python3.9/site-packages/pylint/utils/ast_walker.py
new file mode 100644
index 0000000..415bd97
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/utils/ast_walker.py
@@ -0,0 +1,85 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import collections
+import traceback
+
+from astroid import nodes
+
+
+class ASTWalker:
+    def __init__(self, linter):
+        # callbacks per node types
+        self.nbstatements = 0
+        self.visit_events = collections.defaultdict(list)
+        self.leave_events = collections.defaultdict(list)
+        self.linter = linter
+        self.exception_msg = False
+
+    def _is_method_enabled(self, method):
+        if not hasattr(method, "checks_msgs"):
+            return True
+        return any(self.linter.is_message_enabled(m) for m in method.checks_msgs)
+
+    def add_checker(self, checker):
+        """Walk to the checker's dir and collect visit and leave methods."""
+        vcids = set()
+        lcids = set()
+        visits = self.visit_events
+        leaves = self.leave_events
+        for member in dir(checker):
+            cid = member[6:]
+            if cid == "default":
+                continue
+            if member.startswith("visit_"):
+                v_meth = getattr(checker, member)
+                # don't use visit_methods with no activated message:
+                if self._is_method_enabled(v_meth):
+                    visits[cid].append(v_meth)
+                    vcids.add(cid)
+            elif member.startswith("leave_"):
+                l_meth = getattr(checker, member)
+                # don't use leave_methods with no activated message:
+                if self._is_method_enabled(l_meth):
+                    leaves[cid].append(l_meth)
+                    lcids.add(cid)
+        visit_default = getattr(checker, "visit_default", None)
+        if visit_default:
+            for cls in nodes.ALL_NODE_CLASSES:
+                cid = cls.__name__.lower()
+                if cid not in vcids:
+                    visits[cid].append(visit_default)
+        # For now, we have no "leave_default" method in Pylint
+
+    def walk(self, astroid):
+        """Call visit events of astroid checkers for the given node, recurse on
+        its children, then leave events.
+        """
+        cid = astroid.__class__.__name__.lower()
+
+        # Detect if the node is a new name for a deprecated alias.
+        # In this case, favour the methods for the deprecated
+        # alias if any,  in order to maintain backwards
+        # compatibility.
+        visit_events = self.visit_events.get(cid, ())
+        leave_events = self.leave_events.get(cid, ())
+
+        try:
+            if astroid.is_statement:
+                self.nbstatements += 1
+            # generate events for this node on each checker
+            for callback in visit_events or ():
+                callback(astroid)
+            # recurse on children
+            for child in astroid.get_children():
+                self.walk(child)
+            for callback in leave_events or ():
+                callback(astroid)
+        except Exception:
+            if self.exception_msg is False:
+                file = getattr(astroid.root(), "file", None)
+                print(f"Exception on node {repr(astroid)} in file '{file}'")
+                traceback.print_exc()
+                self.exception_msg = True
+            raise
diff --git a/myenv/lib/python3.9/site-packages/pylint/utils/docs.py b/myenv/lib/python3.9/site-packages/pylint/utils/docs.py
new file mode 100644
index 0000000..b6fb877
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/utils/docs.py
@@ -0,0 +1,79 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+"""Various helper functions to create the docs of a linter object."""
+
+import sys
+from typing import TYPE_CHECKING, Dict, TextIO
+
+from pylint.constants import MAIN_CHECKER_NAME
+from pylint.utils.utils import get_rst_section, get_rst_title
+
+if TYPE_CHECKING:
+    from pylint.lint.pylinter import PyLinter
+
+
+def _get_checkers_infos(linter: "PyLinter") -> Dict[str, Dict]:
+    """Get info from a checker and handle KeyError."""
+    by_checker: Dict[str, Dict] = {}
+    for checker in linter.get_checkers():
+        name = checker.name
+        if name != "master":
+            try:
+                by_checker[name]["checker"] = checker
+                by_checker[name]["options"] += checker.options_and_values()
+                by_checker[name]["msgs"].update(checker.msgs)
+                by_checker[name]["reports"] += checker.reports
+            except KeyError:
+                by_checker[name] = {
+                    "checker": checker,
+                    "options": list(checker.options_and_values()),
+                    "msgs": dict(checker.msgs),
+                    "reports": list(checker.reports),
+                }
+    return by_checker
+
+
+def _get_checkers_documentation(linter: "PyLinter") -> str:
+    """Get documentation for individual checkers."""
+    result = get_rst_title("Pylint global options and switches", "-")
+    result += """
+Pylint provides global options and switches.
+
+"""
+    for checker in linter.get_checkers():
+        name = checker.name
+        if name == MAIN_CHECKER_NAME:
+            if checker.options:
+                for section, options in checker.options_by_section():
+                    if section is None:
+                        title = "General options"
+                    else:
+                        title = f"{section.capitalize()} options"
+                    result += get_rst_title(title, "~")
+                    result += f"{get_rst_section(None, options)}\n"
+    result += get_rst_title("Pylint checkers' options and switches", "-")
+    result += """\
+
+Pylint checkers can provide three set of features:
+
+* options that control their execution,
+* messages that they can raise,
+* reports that they can generate.
+
+Below is a list of all checkers and their features.
+
+"""
+    by_checker = _get_checkers_infos(linter)
+    for checker in sorted(by_checker):
+        information = by_checker[checker]
+        checker = information["checker"]
+        del information["checker"]
+        result += checker.get_full_documentation(**information)
+    return result
+
+
+def print_full_documentation(linter: "PyLinter", stream: TextIO = sys.stdout) -> None:
+    """Output a full documentation in ReST format."""
+    print(_get_checkers_documentation(linter)[:-1], file=stream)
diff --git a/myenv/lib/python3.9/site-packages/pylint/utils/file_state.py b/myenv/lib/python3.9/site-packages/pylint/utils/file_state.py
new file mode 100644
index 0000000..b820aff
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/utils/file_state.py
@@ -0,0 +1,184 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import collections
+import sys
+from typing import (
+    TYPE_CHECKING,
+    DefaultDict,
+    Dict,
+    Iterator,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
+
+from astroid import nodes
+
+from pylint.constants import (
+    INCOMPATIBLE_WITH_USELESS_SUPPRESSION,
+    MSG_STATE_SCOPE_MODULE,
+    WarningScope,
+)
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+if TYPE_CHECKING:
+    from pylint.message import MessageDefinition, MessageDefinitionStore
+
+
+MessageStateDict = Dict[str, Dict[int, bool]]
+
+
+class FileState:
+    """Hold internal state specific to the currently analyzed file."""
+
+    def __init__(self, modname: Optional[str] = None) -> None:
+        self.base_name = modname
+        self._module_msgs_state: MessageStateDict = {}
+        self._raw_module_msgs_state: MessageStateDict = {}
+        self._ignored_msgs: DefaultDict[
+            Tuple[str, int], Set[int]
+        ] = collections.defaultdict(set)
+        self._suppression_mapping: Dict[Tuple[str, int], int] = {}
+        self._effective_max_line_number: Optional[int] = None
+
+    def collect_block_lines(
+        self, msgs_store: "MessageDefinitionStore", module_node: nodes.Module
+    ) -> None:
+        """Walk the AST to collect block level options line numbers."""
+        for msg, lines in self._module_msgs_state.items():
+            self._raw_module_msgs_state[msg] = lines.copy()
+        orig_state = self._module_msgs_state.copy()
+        self._module_msgs_state = {}
+        self._suppression_mapping = {}
+        self._effective_max_line_number = module_node.tolineno
+        self._collect_block_lines(msgs_store, module_node, orig_state)
+
+    def _collect_block_lines(
+        self,
+        msgs_store: "MessageDefinitionStore",
+        node: nodes.NodeNG,
+        msg_state: MessageStateDict,
+    ) -> None:
+        """Recursively walk (depth first) AST to collect block level options
+        line numbers.
+        """
+        for child in node.get_children():
+            self._collect_block_lines(msgs_store, child, msg_state)
+        first = node.fromlineno
+        last = node.tolineno
+        # first child line number used to distinguish between disable
+        # which are the first child of scoped node with those defined later.
+        # For instance in the code below:
+        #
+        # 1.   def meth8(self):
+        # 2.        """test late disabling"""
+        # 3.        pylint: disable=not-callable, useless-suppression
+        # 4.        print(self.blip)
+        # 5.        pylint: disable=no-member, useless-suppression
+        # 6.        print(self.bla)
+        #
+        # E1102 should be disabled from line 1 to 6 while E1101 from line 5 to 6
+        #
+        # this is necessary to disable locally messages applying to class /
+        # function using their fromlineno
+        if (
+            isinstance(node, (nodes.Module, nodes.ClassDef, nodes.FunctionDef))
+            and node.body
+        ):
+            firstchildlineno = node.body[0].fromlineno
+        else:
+            firstchildlineno = last
+        for msgid, lines in msg_state.items():
+            for lineno, state in list(lines.items()):
+                original_lineno = lineno
+                if first > lineno or last < lineno:
+                    continue
+                # Set state for all lines for this block, if the
+                # warning is applied to nodes.
+                message_definitions = msgs_store.get_message_definitions(msgid)
+                for message_definition in message_definitions:
+                    if message_definition.scope == WarningScope.NODE:
+                        if lineno > firstchildlineno:
+                            state = True
+                        first_, last_ = node.block_range(lineno)
+                    else:
+                        first_ = lineno
+                        last_ = last
+                for line in range(first_, last_ + 1):
+                    # do not override existing entries
+                    if line in self._module_msgs_state.get(msgid, ()):
+                        continue
+                    if line in lines:  # state change in the same block
+                        state = lines[line]
+                        original_lineno = line
+                    if not state:
+                        self._suppression_mapping[(msgid, line)] = original_lineno
+                    try:
+                        self._module_msgs_state[msgid][line] = state
+                    except KeyError:
+                        self._module_msgs_state[msgid] = {line: state}
+                del lines[lineno]
+
+    def set_msg_status(self, msg: "MessageDefinition", line: int, status: bool) -> None:
+        """Set status (enabled/disable) for a given message at a given line."""
+        assert line > 0
+        try:
+            self._module_msgs_state[msg.msgid][line] = status
+        except KeyError:
+            self._module_msgs_state[msg.msgid] = {line: status}
+
+    def handle_ignored_message(
+        self, state_scope: Optional[Literal[0, 1, 2]], msgid: str, line: Optional[int]
+    ) -> None:
+        """Report an ignored message.
+
+        state_scope is either MSG_STATE_SCOPE_MODULE or MSG_STATE_SCOPE_CONFIG,
+        depending on whether the message was disabled locally in the module,
+        or globally.
+        """
+        if state_scope == MSG_STATE_SCOPE_MODULE:
+            assert isinstance(line, int)  # should always be int inside module scope
+
+            try:
+                orig_line = self._suppression_mapping[(msgid, line)]
+                self._ignored_msgs[(msgid, orig_line)].add(line)
+            except KeyError:
+                pass
+
+    def iter_spurious_suppression_messages(
+        self,
+        msgs_store: "MessageDefinitionStore",
+    ) -> Iterator[
+        Tuple[
+            Literal["useless-suppression", "suppressed-message"],
+            int,
+            Union[Tuple[str], Tuple[str, int]],
+        ]
+    ]:
+        for warning, lines in self._raw_module_msgs_state.items():
+            for line, enable in lines.items():
+                if (
+                    not enable
+                    and (warning, line) not in self._ignored_msgs
+                    and warning not in INCOMPATIBLE_WITH_USELESS_SUPPRESSION
+                ):
+                    yield "useless-suppression", line, (
+                        msgs_store.get_msg_display_string(warning),
+                    )
+        # don't use iteritems here, _ignored_msgs may be modified by add_message
+        for (warning, from_), ignored_lines in list(self._ignored_msgs.items()):
+            for line in ignored_lines:
+                yield "suppressed-message", line, (
+                    msgs_store.get_msg_display_string(warning),
+                    from_,
+                )
+
+    def get_effective_max_line_number(self) -> Optional[int]:
+        return self._effective_max_line_number
diff --git a/myenv/lib/python3.9/site-packages/pylint/utils/linterstats.py b/myenv/lib/python3.9/site-packages/pylint/utils/linterstats.py
new file mode 100644
index 0000000..82895ec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/utils/linterstats.py
@@ -0,0 +1,376 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import sys
+from typing import Dict, List, Optional, Set, cast
+
+from pylint.typing import MessageTypesFullName
+
+if sys.version_info >= (3, 8):
+    from typing import Literal, TypedDict
+else:
+    from typing_extensions import Literal, TypedDict
+
+
+class BadNames(TypedDict):
+    """TypedDict to store counts of node types with bad names."""
+
+    argument: int
+    attr: int
+    klass: int
+    class_attribute: int
+    class_const: int
+    const: int
+    inlinevar: int
+    function: int
+    method: int
+    module: int
+    variable: int
+    typevar: int
+
+
+class CodeTypeCount(TypedDict):
+    """TypedDict to store counts of lines of code types."""
+
+    code: int
+    comment: int
+    docstring: int
+    empty: int
+    total: int
+
+
+class DuplicatedLines(TypedDict):
+    """TypedDict to store counts of lines of duplicated code."""
+
+    nb_duplicated_lines: int
+    percent_duplicated_lines: float
+
+
+class NodeCount(TypedDict):
+    """TypedDict to store counts of different types of nodes."""
+
+    function: int
+    klass: int
+    method: int
+    module: int
+
+
+class UndocumentedNodes(TypedDict):
+    """TypedDict to store counts of undocumented node types."""
+
+    function: int
+    klass: int
+    method: int
+    module: int
+
+
+class ModuleStats(TypedDict):
+    """TypedDict to store counts of types of messages and statements."""
+
+    convention: int
+    error: int
+    fatal: int
+    info: int
+    refactor: int
+    statement: int
+    warning: int
+
+
+# pylint: disable-next=too-many-instance-attributes
+class LinterStats:
+    """Class used to linter stats."""
+
+    def __init__(
+        self,
+        bad_names: Optional[BadNames] = None,
+        by_module: Optional[Dict[str, ModuleStats]] = None,
+        by_msg: Optional[Dict[str, int]] = None,
+        code_type_count: Optional[CodeTypeCount] = None,
+        dependencies: Optional[Dict[str, Set[str]]] = None,
+        duplicated_lines: Optional[DuplicatedLines] = None,
+        node_count: Optional[NodeCount] = None,
+        undocumented: Optional[UndocumentedNodes] = None,
+    ) -> None:
+        self.bad_names = bad_names or BadNames(
+            argument=0,
+            attr=0,
+            klass=0,
+            class_attribute=0,
+            class_const=0,
+            const=0,
+            inlinevar=0,
+            function=0,
+            method=0,
+            module=0,
+            variable=0,
+            typevar=0,
+        )
+        self.by_module: Dict[str, ModuleStats] = by_module or {}
+        self.by_msg: Dict[str, int] = by_msg or {}
+        self.code_type_count = code_type_count or CodeTypeCount(
+            code=0, comment=0, docstring=0, empty=0, total=0
+        )
+
+        self.dependencies: Dict[str, Set[str]] = dependencies or {}
+        self.duplicated_lines = duplicated_lines or DuplicatedLines(
+            nb_duplicated_lines=0, percent_duplicated_lines=0.0
+        )
+        self.node_count = node_count or NodeCount(
+            function=0, klass=0, method=0, module=0
+        )
+        self.undocumented = undocumented or UndocumentedNodes(
+            function=0, klass=0, method=0, module=0
+        )
+
+        self.convention = 0
+        self.error = 0
+        self.fatal = 0
+        self.info = 0
+        self.refactor = 0
+        self.statement = 0
+        self.warning = 0
+
+        self.global_note = 0
+        self.nb_duplicated_lines = 0
+        self.percent_duplicated_lines = 0.0
+
+    def __str__(self) -> str:
+        return f"""{self.bad_names}
+        {sorted(self.by_module.items())}
+        {sorted(self.by_msg.items())}
+        {self.code_type_count}
+        {sorted(self.dependencies.items())}
+        {self.duplicated_lines}
+        {self.undocumented}
+        {self.convention}
+        {self.error}
+        {self.fatal}
+        {self.info}
+        {self.refactor}
+        {self.statement}
+        {self.warning}
+        {self.global_note}
+        {self.nb_duplicated_lines}
+        {self.percent_duplicated_lines}"""
+
+    def init_single_module(self, module_name: str) -> None:
+        """Use through PyLinter.set_current_module so PyLinter.current_name is consistent."""
+        self.by_module[module_name] = ModuleStats(
+            convention=0, error=0, fatal=0, info=0, refactor=0, statement=0, warning=0
+        )
+
+    def get_bad_names(
+        self,
+        node_name: Literal[
+            "argument",
+            "attr",
+            "class",
+            "class_attribute",
+            "class_const",
+            "const",
+            "inlinevar",
+            "function",
+            "method",
+            "module",
+            "variable",
+            "typevar",
+        ],
+    ) -> int:
+        """Get a bad names node count."""
+        if node_name == "class":
+            return self.bad_names.get("klass", 0)
+        return self.bad_names.get(node_name, 0)
+
+    def increase_bad_name(self, node_name: str, increase: int) -> None:
+        """Increase a bad names node count."""
+        if node_name not in {
+            "argument",
+            "attr",
+            "class",
+            "class_attribute",
+            "class_const",
+            "const",
+            "inlinevar",
+            "function",
+            "method",
+            "module",
+            "variable",
+            "typevar",
+        }:
+            raise ValueError("Node type not part of the bad_names stat")
+
+        node_name = cast(
+            Literal[
+                "argument",
+                "attr",
+                "class",
+                "class_attribute",
+                "class_const",
+                "const",
+                "inlinevar",
+                "function",
+                "method",
+                "module",
+                "variable",
+                "typevar",
+            ],
+            node_name,
+        )
+        if node_name == "class":
+            self.bad_names["klass"] += increase
+        else:
+            self.bad_names[node_name] += increase
+
+    def reset_bad_names(self) -> None:
+        """Resets the bad_names attribute."""
+        self.bad_names = BadNames(
+            argument=0,
+            attr=0,
+            klass=0,
+            class_attribute=0,
+            class_const=0,
+            const=0,
+            inlinevar=0,
+            function=0,
+            method=0,
+            module=0,
+            variable=0,
+            typevar=0,
+        )
+
+    def get_code_count(
+        self, type_name: Literal["code", "comment", "docstring", "empty", "total"]
+    ) -> int:
+        """Get a code type count."""
+        return self.code_type_count.get(type_name, 0)
+
+    def reset_code_count(self) -> None:
+        """Resets the code_type_count attribute."""
+        self.code_type_count = CodeTypeCount(
+            code=0, comment=0, docstring=0, empty=0, total=0
+        )
+
+    def reset_duplicated_lines(self) -> None:
+        """Resets the duplicated_lines attribute."""
+        self.duplicated_lines = DuplicatedLines(
+            nb_duplicated_lines=0, percent_duplicated_lines=0.0
+        )
+
+    def get_node_count(
+        self, node_name: Literal["function", "class", "method", "module"]
+    ) -> int:
+        """Get a node count while handling some extra conditions."""
+        if node_name == "class":
+            return self.node_count.get("klass", 0)
+        return self.node_count.get(node_name, 0)
+
+    def reset_node_count(self) -> None:
+        """Resets the node count attribute."""
+        self.node_count = NodeCount(function=0, klass=0, method=0, module=0)
+
+    def get_undocumented(
+        self, node_name: Literal["function", "class", "method", "module"]
+    ) -> float:
+        """Get a undocumented node count."""
+        if node_name == "class":
+            return self.undocumented["klass"]
+        return self.undocumented[node_name]
+
+    def reset_undocumented(self) -> None:
+        """Resets the undocumented attribute."""
+        self.undocumented = UndocumentedNodes(function=0, klass=0, method=0, module=0)
+
+    def get_global_message_count(self, type_name: str) -> int:
+        """Get a global message count."""
+        return getattr(self, type_name, 0)
+
+    def get_module_message_count(self, modname: str, type_name: str) -> int:
+        """Get a module message count."""
+        return getattr(self.by_module[modname], type_name, 0)
+
+    def increase_single_message_count(self, type_name: str, increase: int) -> None:
+        """Increase the message type count of an individual message type."""
+        setattr(self, type_name, getattr(self, type_name) + increase)
+
+    def increase_single_module_message_count(
+        self, modname: str, type_name: MessageTypesFullName, increase: int
+    ) -> None:
+        """Increase the message type count of an individual message type of a module."""
+        self.by_module[modname][type_name] += increase
+
+    def reset_message_count(self) -> None:
+        """Resets the message type count of the stats object."""
+        self.convention = 0
+        self.error = 0
+        self.fatal = 0
+        self.info = 0
+        self.refactor = 0
+        self.warning = 0
+
+
+def merge_stats(stats: List[LinterStats]):
+    """Used to merge multiple stats objects into a new one when pylint is run in parallel mode."""
+    merged = LinterStats()
+    for stat in stats:
+        merged.bad_names["argument"] += stat.bad_names["argument"]
+        merged.bad_names["attr"] += stat.bad_names["attr"]
+        merged.bad_names["klass"] += stat.bad_names["klass"]
+        merged.bad_names["class_attribute"] += stat.bad_names["class_attribute"]
+        merged.bad_names["class_const"] += stat.bad_names["class_const"]
+        merged.bad_names["const"] += stat.bad_names["const"]
+        merged.bad_names["inlinevar"] += stat.bad_names["inlinevar"]
+        merged.bad_names["function"] += stat.bad_names["function"]
+        merged.bad_names["method"] += stat.bad_names["method"]
+        merged.bad_names["module"] += stat.bad_names["module"]
+        merged.bad_names["variable"] += stat.bad_names["variable"]
+        merged.bad_names["typevar"] += stat.bad_names["typevar"]
+
+        for mod_key, mod_value in stat.by_module.items():
+            merged.by_module[mod_key] = mod_value
+
+        for msg_key, msg_value in stat.by_msg.items():
+            try:
+                merged.by_msg[msg_key] += msg_value
+            except KeyError:
+                merged.by_msg[msg_key] = msg_value
+
+        merged.code_type_count["code"] += stat.code_type_count["code"]
+        merged.code_type_count["comment"] += stat.code_type_count["comment"]
+        merged.code_type_count["docstring"] += stat.code_type_count["docstring"]
+        merged.code_type_count["empty"] += stat.code_type_count["empty"]
+        merged.code_type_count["total"] += stat.code_type_count["total"]
+
+        for dep_key, dep_value in stat.dependencies.items():
+            try:
+                merged.dependencies[dep_key].update(dep_value)
+            except KeyError:
+                merged.dependencies[dep_key] = dep_value
+
+        merged.duplicated_lines["nb_duplicated_lines"] += stat.duplicated_lines[
+            "nb_duplicated_lines"
+        ]
+        merged.duplicated_lines["percent_duplicated_lines"] += stat.duplicated_lines[
+            "percent_duplicated_lines"
+        ]
+
+        merged.node_count["function"] += stat.node_count["function"]
+        merged.node_count["klass"] += stat.node_count["klass"]
+        merged.node_count["method"] += stat.node_count["method"]
+        merged.node_count["module"] += stat.node_count["module"]
+
+        merged.undocumented["function"] += stat.undocumented["function"]
+        merged.undocumented["klass"] += stat.undocumented["klass"]
+        merged.undocumented["method"] += stat.undocumented["method"]
+        merged.undocumented["module"] += stat.undocumented["module"]
+
+        merged.convention += stat.convention
+        merged.error += stat.error
+        merged.fatal += stat.fatal
+        merged.info += stat.info
+        merged.refactor += stat.refactor
+        merged.statement += stat.statement
+        merged.warning += stat.warning
+
+        merged.global_note += stat.global_note
+    return merged
diff --git a/myenv/lib/python3.9/site-packages/pylint/utils/pragma_parser.py b/myenv/lib/python3.9/site-packages/pylint/utils/pragma_parser.py
new file mode 100644
index 0000000..01cdf44
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/utils/pragma_parser.py
@@ -0,0 +1,131 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+import re
+from collections import namedtuple
+from typing import Generator, List, Optional
+
+# Allow stopping after the first semicolon/hash encountered,
+# so that an option can be continued with the reasons
+# why it is active or disabled.
+OPTION_RGX = r"""
+    (?:^\s*\#.*|\s*|               # Comment line, or whitespaces,
+       \s*\#.*(?=\#.*?\bpylint:))  # or a beginning of an inline comment
+                                   # followed by "pylint:" pragma
+    (\#                            # Beginning of comment
+    .*?                            # Anything (as little as possible)
+    \bpylint:                      # pylint word and column
+    \s*                            # Any number of whitespaces
+    ([^;#\n]+))                    # Anything except semicolon or hash or
+                                   # newline (it is the second matched group)
+                                   # and end of the first matched group
+    [;#]{0,1}                      # From 0 to 1 repetition of semicolon or hash
+"""
+OPTION_PO = re.compile(OPTION_RGX, re.VERBOSE)
+
+
+PragmaRepresenter = namedtuple("PragmaRepresenter", "action messages")
+
+
+ATOMIC_KEYWORDS = frozenset(("disable-all", "skip-file"))
+MESSAGE_KEYWORDS = frozenset(
+    ("disable-next", "disable-msg", "enable-msg", "disable", "enable")
+)
+# sorted is necessary because sets are unordered collections and ALL_KEYWORDS
+# string should not vary between executions
+# reverse is necessary in order to have the longest keywords first, so that, for example,
+# 'disable' string should not be matched instead of 'disable-all'
+ALL_KEYWORDS = "|".join(
+    sorted(ATOMIC_KEYWORDS | MESSAGE_KEYWORDS, key=len, reverse=True)
+)
+
+
+TOKEN_SPECIFICATION = [
+    ("KEYWORD", rf"\b({ALL_KEYWORDS:s})\b"),
+    ("MESSAGE_STRING", r"[0-9A-Za-z\-\_]{2,}"),  # Identifiers
+    ("ASSIGN", r"="),  # Assignment operator
+    ("MESSAGE_NUMBER", r"[CREIWF]{1}\d*"),
+]
+
+TOK_REGEX = "|".join(
+    f"(?P<{token_name:s}>{token_rgx:s})"
+    for token_name, token_rgx in TOKEN_SPECIFICATION
+)
+
+
+def emit_pragma_representer(action: str, messages: List[str]) -> PragmaRepresenter:
+    if not messages and action in MESSAGE_KEYWORDS:
+        raise InvalidPragmaError(
+            "The keyword is not followed by message identifier", action
+        )
+    return PragmaRepresenter(action, messages)
+
+
+class PragmaParserError(Exception):
+    """A class for exceptions thrown by pragma_parser module."""
+
+    def __init__(self, message: str, token: str) -> None:
+        """:args message: explain the reason why the exception has been thrown
+        :args token: token concerned by the exception
+        """
+        self.message = message
+        self.token = token
+        super().__init__(self.message)
+
+
+class UnRecognizedOptionError(PragmaParserError):
+    """Thrown in case the of a valid but unrecognized option."""
+
+
+class InvalidPragmaError(PragmaParserError):
+    """Thrown in case the pragma is invalid."""
+
+
+def parse_pragma(pylint_pragma: str) -> Generator[PragmaRepresenter, None, None]:
+    action: Optional[str] = None
+    messages: List[str] = []
+    assignment_required = False
+    previous_token = ""
+
+    for mo in re.finditer(TOK_REGEX, pylint_pragma):
+        kind = mo.lastgroup
+        value = mo.group()
+
+        if kind == "ASSIGN":
+            if not assignment_required:
+                if action:
+                    # A keyword has been found previously but doesn't support assignment
+                    raise UnRecognizedOptionError(
+                        "The keyword doesn't support assignment", action
+                    )
+                if previous_token:
+                    # Something found previously but not a known keyword
+                    raise UnRecognizedOptionError(
+                        "The keyword is unknown", previous_token
+                    )
+                # Nothing at all detected before this assignment
+                raise InvalidPragmaError("Missing keyword before assignment", "")
+            assignment_required = False
+        elif assignment_required:
+            raise InvalidPragmaError(
+                "The = sign is missing after the keyword", action or ""
+            )
+        elif kind == "KEYWORD":
+            if action:
+                yield emit_pragma_representer(action, messages)
+            action = value
+            messages = []
+            assignment_required = action in MESSAGE_KEYWORDS
+        elif kind in {"MESSAGE_STRING", "MESSAGE_NUMBER"}:
+            messages.append(value)
+            assignment_required = False
+        else:
+            raise RuntimeError("Token not recognized")
+
+        previous_token = value
+
+    if action:
+        yield emit_pragma_representer(action, messages)
+    else:
+        raise UnRecognizedOptionError("The keyword is unknown", previous_token)
diff --git a/myenv/lib/python3.9/site-packages/pylint/utils/utils.py b/myenv/lib/python3.9/site-packages/pylint/utils/utils.py
new file mode 100644
index 0000000..6a60cd8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pylint/utils/utils.py
@@ -0,0 +1,406 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
+
+try:
+    import isort.api
+
+    HAS_ISORT_5 = True
+except ImportError:  # isort < 5
+    import isort
+
+    HAS_ISORT_5 = False
+
+import codecs
+import os
+import re
+import sys
+import textwrap
+import tokenize
+from io import BufferedReader, BytesIO
+from typing import (
+    TYPE_CHECKING,
+    List,
+    Optional,
+    Pattern,
+    TextIO,
+    Tuple,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from astroid import Module, modutils, nodes
+
+from pylint.constants import PY_EXTS
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+if TYPE_CHECKING:
+    from pylint.checkers.base_checker import BaseChecker
+
+DEFAULT_LINE_LENGTH = 79
+
+# These are types used to overload get_global_option() and refer to the options type
+GLOBAL_OPTION_BOOL = Literal[
+    "ignore-mixin-members",
+    "suggestion-mode",
+    "analyse-fallback-blocks",
+    "allow-global-unused-variables",
+]
+GLOBAL_OPTION_INT = Literal["max-line-length", "docstring-min-length"]
+GLOBAL_OPTION_LIST = Literal["ignored-modules"]
+GLOBAL_OPTION_PATTERN = Literal[
+    "no-docstring-rgx",
+    "dummy-variables-rgx",
+    "ignored-argument-names",
+    "mixin-class-rgx",
+]
+GLOBAL_OPTION_PATTERN_LIST = Literal["exclude-too-few-public-methods", "ignore-paths"]
+GLOBAL_OPTION_TUPLE_INT = Literal["py-version"]
+GLOBAL_OPTION_NAMES = Union[
+    GLOBAL_OPTION_BOOL,
+    GLOBAL_OPTION_INT,
+    GLOBAL_OPTION_LIST,
+    GLOBAL_OPTION_PATTERN,
+    GLOBAL_OPTION_PATTERN_LIST,
+    GLOBAL_OPTION_TUPLE_INT,
+]
+T_GlobalOptionReturnTypes = TypeVar(
+    "T_GlobalOptionReturnTypes",
+    bool,
+    int,
+    List[str],
+    Pattern[str],
+    List[Pattern[str]],
+    Tuple[int, ...],
+)
+
+
+def normalize_text(text, line_len=DEFAULT_LINE_LENGTH, indent=""):
+    """Wrap the text on the given line length."""
+    return "\n".join(
+        textwrap.wrap(
+            text, width=line_len, initial_indent=indent, subsequent_indent=indent
+        )
+    )
+
+
+CMPS = ["=", "-", "+"]
+
+
+# py3k has no more cmp builtin
+def cmp(a, b):
+    return (a > b) - (a < b)
+
+
+def diff_string(old, new):
+    """Given an old and new int value, return a string representing the
+    difference
+    """
+    diff = abs(old - new)
+    diff_str = f"{CMPS[cmp(old, new)]}{diff and f'{diff:.2f}' or ''}"
+    return diff_str
+
+
+def get_module_and_frameid(node):
+    """Return the module name and the frame id in the module."""
+    frame = node.frame(future=True)
+    module, obj = "", []
+    while frame:
+        if isinstance(frame, Module):
+            module = frame.name
+        else:
+            obj.append(getattr(frame, "name", "<lambda>"))
+        try:
+            frame = frame.parent.frame(future=True)
+        except AttributeError:
+            break
+    obj.reverse()
+    return module, ".".join(obj)
+
+
+def get_rst_title(title, character):
+    """Permit to get a title formatted as ReStructuredText test (underlined with a chosen character)."""
+    return f"{title}\n{character * len(title)}\n"
+
+
+def get_rst_section(section, options, doc=None):
+    """Format an option's section using as a ReStructuredText formatted output."""
+    result = ""
+    if section:
+        result += get_rst_title(section, "'")
+    if doc:
+        formatted_doc = normalize_text(doc)
+        result += f"{formatted_doc}\n\n"
+    for optname, optdict, value in options:
+        help_opt = optdict.get("help")
+        result += f":{optname}:\n"
+        if help_opt:
+            formatted_help = normalize_text(help_opt, indent="  ")
+            result += f"{formatted_help}\n"
+        if value and optname != "py-version":
+            value = str(_format_option_value(optdict, value))
+            result += f"\n  Default: ``{value.replace('`` ', '```` ``')}``\n"
+    return result
+
+
+def decoding_stream(
+    stream: Union[BufferedReader, BytesIO],
+    encoding: str,
+    errors: Literal["strict"] = "strict",
+) -> codecs.StreamReader:
+    try:
+        reader_cls = codecs.getreader(encoding or sys.getdefaultencoding())
+    except LookupError:
+        reader_cls = codecs.getreader(sys.getdefaultencoding())
+    return reader_cls(stream, errors)
+
+
+def tokenize_module(node: nodes.Module) -> List[tokenize.TokenInfo]:
+    with node.stream() as stream:
+        readline = stream.readline
+        return list(tokenize.tokenize(readline))
+
+
+def register_plugins(linter, directory):
+    """Load all module and package in the given directory, looking for a
+    'register' function in each one, used to register pylint checkers
+    """
+    imported = {}
+    for filename in os.listdir(directory):
+        base, extension = os.path.splitext(filename)
+        if base in imported or base == "__pycache__":
+            continue
+        if (
+            extension in PY_EXTS
+            and base != "__init__"
+            or (
+                not extension
+                and os.path.isdir(os.path.join(directory, base))
+                and not filename.startswith(".")
+            )
+        ):
+            try:
+                module = modutils.load_module_from_file(
+                    os.path.join(directory, filename)
+                )
+            except ValueError:
+                # empty module name (usually emacs auto-save files)
+                continue
+            except ImportError as exc:
+                print(f"Problem importing module {filename}: {exc}", file=sys.stderr)
+            else:
+                if hasattr(module, "register"):
+                    module.register(linter)
+                    imported[base] = 1
+
+
+@overload
+def get_global_option(
+    checker: "BaseChecker", option: GLOBAL_OPTION_BOOL, default: Optional[bool] = None
+) -> bool:
+    ...
+
+
+@overload
+def get_global_option(
+    checker: "BaseChecker", option: GLOBAL_OPTION_INT, default: Optional[int] = None
+) -> int:
+    ...
+
+
+@overload
+def get_global_option(
+    checker: "BaseChecker",
+    option: GLOBAL_OPTION_LIST,
+    default: Optional[List[str]] = None,
+) -> List[str]:
+    ...
+
+
+@overload
+def get_global_option(
+    checker: "BaseChecker",
+    option: GLOBAL_OPTION_PATTERN,
+    default: Optional[Pattern[str]] = None,
+) -> Pattern[str]:
+    ...
+
+
+@overload
+def get_global_option(
+    checker: "BaseChecker",
+    option: GLOBAL_OPTION_PATTERN_LIST,
+    default: Optional[List[Pattern[str]]] = None,
+) -> List[Pattern[str]]:
+    ...
+
+
+@overload
+def get_global_option(
+    checker: "BaseChecker",
+    option: GLOBAL_OPTION_TUPLE_INT,
+    default: Optional[Tuple[int, ...]] = None,
+) -> Tuple[int, ...]:
+    ...
+
+
+def get_global_option(
+    checker: "BaseChecker",
+    option: GLOBAL_OPTION_NAMES,
+    default: Optional[T_GlobalOptionReturnTypes] = None,
+) -> Optional[T_GlobalOptionReturnTypes]:
+    """Retrieve an option defined by the given *checker* or
+    by all known option providers.
+
+    It will look in the list of all options providers
+    until the given *option* will be found.
+    If the option wasn't found, the *default* value will be returned.
+    """
+    # First, try in the given checker's config.
+    # After that, look in the options providers.
+
+    try:
+        return getattr(checker.config, option.replace("-", "_"))
+    except AttributeError:
+        pass
+    for provider in checker.linter.options_providers:
+        for options in provider.options:
+            if options[0] == option:
+                return getattr(provider.config, option.replace("-", "_"))
+    return default
+
+
+def _splitstrip(string, sep=","):
+    """Return a list of stripped string by splitting the string given as
+    argument on `sep` (',' by default), empty strings are discarded.
+
+    >>> _splitstrip('a, b, c   ,  4,,')
+    ['a', 'b', 'c', '4']
+    >>> _splitstrip('a')
+    ['a']
+    >>> _splitstrip('a,\nb,\nc,')
+    ['a', 'b', 'c']
+
+    :type string: str or unicode
+    :param string: a csv line
+
+    :type sep: str or unicode
+    :param sep: field separator, default to the comma (',')
+
+    :rtype: str or unicode
+    :return: the unquoted string (or the input string if it wasn't quoted)
+    """
+    return [word.strip() for word in string.split(sep) if word.strip()]
+
+
+def _unquote(string):
+    """Remove optional quotes (simple or double) from the string.
+
+    :type string: str or unicode
+    :param string: an optionally quoted string
+
+    :rtype: str or unicode
+    :return: the unquoted string (or the input string if it wasn't quoted)
+    """
+    if not string:
+        return string
+    if string[0] in "\"'":
+        string = string[1:]
+    if string[-1] in "\"'":
+        string = string[:-1]
+    return string
+
+
+def _check_csv(value):
+    if isinstance(value, (list, tuple)):
+        return value
+    return _splitstrip(value)
+
+
+def _comment(string: str) -> str:
+    """Return string as a comment."""
+    lines = [line.strip() for line in string.splitlines()]
+    sep = "\n"
+    return "# " + f"{sep}# ".join(lines)
+
+
+def _format_option_value(optdict, value):
+    """Return the user input's value from a 'compiled' value."""
+    if optdict.get("type", None) == "py_version":
+        value = ".".join(str(item) for item in value)
+    elif isinstance(value, (list, tuple)):
+        value = ",".join(_format_option_value(optdict, item) for item in value)
+    elif isinstance(value, dict):
+        value = ",".join(f"{k}:{v}" for k, v in value.items())
+    elif hasattr(value, "match"):  # optdict.get('type') == 'regexp'
+        # compiled regexp
+        value = value.pattern
+    elif optdict.get("type") == "yn":
+        value = "yes" if value else "no"
+    elif isinstance(value, str) and value.isspace():
+        value = f"'{value}'"
+    return value
+
+
+def format_section(
+    stream: TextIO, section: str, options: List[Tuple], doc: Optional[str] = None
+) -> None:
+    """Format an option's section using the INI format."""
+    if doc:
+        print(_comment(doc), file=stream)
+    print(f"[{section}]", file=stream)
+    _ini_format(stream, options)
+
+
+def _ini_format(stream: TextIO, options: List[Tuple]) -> None:
+    """Format options using the INI format."""
+    for optname, optdict, value in options:
+        value = _format_option_value(optdict, value)
+        help_opt = optdict.get("help")
+        if help_opt:
+            help_opt = normalize_text(help_opt, indent="# ")
+            print(file=stream)
+            print(help_opt, file=stream)
+        else:
+            print(file=stream)
+        if value is None:
+            print(f"#{optname}=", file=stream)
+        else:
+            value = str(value).strip()
+            if re.match(r"^([\w-]+,)+[\w-]+$", str(value)):
+                separator = "\n " + " " * len(optname)
+                value = separator.join(x + "," for x in str(value).split(","))
+                # remove trailing ',' from last element of the list
+                value = value[:-1]
+            print(f"{optname}={value}", file=stream)
+
+
+class IsortDriver:
+    """A wrapper around isort API that changed between versions 4 and 5."""
+
+    def __init__(self, config):
+        if HAS_ISORT_5:
+            self.isort5_config = isort.api.Config(
+                # There is no typo here. EXTRA_standard_library is
+                # what most users want. The option has been named
+                # KNOWN_standard_library for ages in pylint, and we
+                # don't want to break compatibility.
+                extra_standard_library=config.known_standard_library,
+                known_third_party=config.known_third_party,
+            )
+        else:
+            self.isort4_obj = isort.SortImports(  # pylint: disable=no-member
+                file_contents="",
+                known_standard_library=config.known_standard_library,
+                known_third_party=config.known_third_party,
+            )
+
+    def place_module(self, package):
+        if HAS_ISORT_5:
+            return isort.api.place_module(package, self.isort5_config)
+        return self.isort4_obj.place_module(package)
diff --git a/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/LICENSE
new file mode 100644
index 0000000..1bf9852
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/LICENSE
@@ -0,0 +1,18 @@
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/METADATA b/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/METADATA
new file mode 100644
index 0000000..33e5194
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/METADATA
@@ -0,0 +1,105 @@
+Metadata-Version: 2.1
+Name: pyparsing
+Version: 3.0.9
+Summary: pyparsing module - Classes and methods to define and execute parsing grammars
+Author-email: Paul McGuire <ptmcg.gm+pyparsing@gmail.com>
+Requires-Python: >=3.6.8
+Description-Content-Type: text/x-rst
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Typing :: Typed
+Requires-Dist: railroad-diagrams ; extra == "diagrams"
+Requires-Dist: jinja2 ; extra == "diagrams"
+Project-URL: Homepage, https://github.com/pyparsing/pyparsing/
+Provides-Extra: diagrams
+
+PyParsing -- A Python Parsing Module
+====================================
+
+|Build Status| |Coverage|
+
+Introduction
+============
+
+The pyparsing module is an alternative approach to creating and
+executing simple grammars, vs. the traditional lex/yacc approach, or the
+use of regular expressions. The pyparsing module provides a library of
+classes that client code uses to construct the grammar directly in
+Python code.
+
+*[Since first writing this description of pyparsing in late 2003, this
+technique for developing parsers has become more widespread, under the
+name Parsing Expression Grammars - PEGs. See more information on PEGs*
+`here <https://en.wikipedia.org/wiki/Parsing_expression_grammar>`__
+*.]*
+
+Here is a program to parse ``"Hello, World!"`` (or any greeting of the form
+``"salutation, addressee!"``):
+
+.. code:: python
+
+    from pyparsing import Word, alphas
+    greet = Word(alphas) + "," + Word(alphas) + "!"
+    hello = "Hello, World!"
+    print(hello, "->", greet.parseString(hello))
+
+The program outputs the following::
+
+    Hello, World! -> ['Hello', ',', 'World', '!']
+
+The Python representation of the grammar is quite readable, owing to the
+self-explanatory class names, and the use of '+', '|' and '^' operator
+definitions.
+
+The parsed results returned from ``parseString()`` is a collection of type
+``ParseResults``, which can be accessed as a
+nested list, a dictionary, or an object with named attributes.
+
+The pyparsing module handles some of the problems that are typically
+vexing when writing text parsers:
+
+- extra or missing whitespace (the above program will also handle ``"Hello,World!"``, ``"Hello , World !"``, etc.)
+- quoted strings
+- embedded comments
+
+The examples directory includes a simple SQL parser, simple CORBA IDL
+parser, a config file parser, a chemical formula parser, and a four-
+function algebraic notation parser, among many others.
+
+Documentation
+=============
+
+There are many examples in the online docstrings of the classes
+and methods in pyparsing. You can find them compiled into `online docs <https://pyparsing-docs.readthedocs.io/en/latest/>`__. Additional
+documentation resources and project info are listed in the online
+`GitHub wiki <https://github.com/pyparsing/pyparsing/wiki>`__. An
+entire directory of examples can be found `here <https://github.com/pyparsing/pyparsing/tree/master/examples>`__.
+
+License
+=======
+
+MIT License. See header of the `pyparsing.py <https://github.com/pyparsing/pyparsing/blob/master/pyparsing/__init__.py#L1-L23>`__ file.
+
+History
+=======
+
+See `CHANGES <https://github.com/pyparsing/pyparsing/blob/master/CHANGES>`__ file.
+
+.. |Build Status| image:: https://github.com/pyparsing/pyparsing/actions/workflows/ci.yml/badge.svg
+   :target: https://github.com/pyparsing/pyparsing/actions/workflows/ci.yml
+.. |Coverage| image:: https://codecov.io/gh/pyparsing/pyparsing/branch/master/graph/badge.svg
+  :target: https://codecov.io/gh/pyparsing/pyparsing
+
diff --git a/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/RECORD b/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/RECORD
new file mode 100644
index 0000000..417190d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/RECORD
@@ -0,0 +1,17 @@
+pyparsing/__init__.py,sha256=52QH3lgPbJhba0estckoGPHRH8JvQSSCGoWiEn2m0bU,9159
+pyparsing/actions.py,sha256=wU9i32e0y1ymxKE3OUwSHO-SFIrt1h_wv6Ws0GQjpNU,6426
+pyparsing/common.py,sha256=lFL97ooIeR75CmW5hjURZqwDCTgruqltcTCZ-ulLO2Q,12936
+pyparsing/core.py,sha256=u8GptQE_H6wMkl8OZhxeK1aAPIDXXNgwdShORBwBVS4,213310
+pyparsing/exceptions.py,sha256=3LbSafD32NYb1Tzt85GHNkhEAU1eZkTtNSk24cPMemo,9023
+pyparsing/helpers.py,sha256=QpUOjW0-psvueMwWb9bQpU2noqKCv98_wnw1VSzSdVo,39129
+pyparsing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyparsing/results.py,sha256=HgNvWVXBdQP-Q6PtJfoCEeOJk2nwEvG-2KVKC5sGA30,25341
+pyparsing/testing.py,sha256=7tu4Abp4uSeJV0N_yEPRmmNUhpd18ZQP3CrX41DM814,13402
+pyparsing/unicode.py,sha256=fwuhMj30SQ165Cv7HJpu-rSxGbRm93kN9L4Ei7VGc1Y,10787
+pyparsing/util.py,sha256=kq772O5YSeXOSdP-M31EWpbH_ayj7BMHImBYo9xPD5M,6805
+pyparsing/diagram/__init__.py,sha256=f_EfxahqrdkRVahmTwLJXkZ9EEDKNd-O7lBbpJYlE1g,23668
+pyparsing-3.0.9.dist-info/LICENSE,sha256=ENUSChaAWAT_2otojCIL-06POXQbVzIGBNRVowngGXI,1023
+pyparsing-3.0.9.dist-info/WHEEL,sha256=jPMR_Dzkc4X4icQtmz81lnNY_kAsfog7ry7qoRvYLXw,81
+pyparsing-3.0.9.dist-info/METADATA,sha256=h_fpm9rwvgZsE8v5YNF4IAo-IpaFWCOfUEm5MMByIiM,4207
+pyparsing-3.0.9.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+pyparsing-3.0.9.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/WHEEL
new file mode 100644
index 0000000..c727d14
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing-3.0.9.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.6.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/__init__.py b/myenv/lib/python3.9/site-packages/pyparsing/__init__.py
new file mode 100644
index 0000000..7802ff1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing/__init__.py
@@ -0,0 +1,331 @@
+# module pyparsing.py
+#
+# Copyright (c) 2003-2022  Paul T. McGuire
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__doc__ = """
+pyparsing module - Classes and methods to define and execute parsing grammars
+=============================================================================
+
+The pyparsing module is an alternative approach to creating and
+executing simple grammars, vs. the traditional lex/yacc approach, or the
+use of regular expressions.  With pyparsing, you don't need to learn
+a new syntax for defining grammars or matching expressions - the parsing
+module provides a library of classes that you use to construct the
+grammar directly in Python.
+
+Here is a program to parse "Hello, World!" (or any greeting of the form
+``"<salutation>, <addressee>!"``), built up using :class:`Word`,
+:class:`Literal`, and :class:`And` elements
+(the :meth:`'+'<ParserElement.__add__>` operators create :class:`And` expressions,
+and the strings are auto-converted to :class:`Literal` expressions)::
+
+    from pyparsing import Word, alphas
+
+    # define grammar of a greeting
+    greet = Word(alphas) + "," + Word(alphas) + "!"
+
+    hello = "Hello, World!"
+    print(hello, "->", greet.parse_string(hello))
+
+The program outputs the following::
+
+    Hello, World! -> ['Hello', ',', 'World', '!']
+
+The Python representation of the grammar is quite readable, owing to the
+self-explanatory class names, and the use of :class:`'+'<And>`,
+:class:`'|'<MatchFirst>`, :class:`'^'<Or>` and :class:`'&'<Each>` operators.
+
+The :class:`ParseResults` object returned from
+:class:`ParserElement.parseString` can be
+accessed as a nested list, a dictionary, or an object with named
+attributes.
+
+The pyparsing module handles some of the problems that are typically
+vexing when writing text parsers:
+
+  - extra or missing whitespace (the above program will also handle
+    "Hello,World!", "Hello  ,  World  !", etc.)
+  - quoted strings
+  - embedded comments
+
+
+Getting Started -
+-----------------
+Visit the classes :class:`ParserElement` and :class:`ParseResults` to
+see the base classes that most other pyparsing
+classes inherit from. Use the docstrings for examples of how to:
+
+ - construct literal match expressions from :class:`Literal` and
+   :class:`CaselessLiteral` classes
+ - construct character word-group expressions using the :class:`Word`
+   class
+ - see how to create repetitive expressions using :class:`ZeroOrMore`
+   and :class:`OneOrMore` classes
+ - use :class:`'+'<And>`, :class:`'|'<MatchFirst>`, :class:`'^'<Or>`,
+   and :class:`'&'<Each>` operators to combine simple expressions into
+   more complex ones
+ - associate names with your parsed results using
+   :class:`ParserElement.setResultsName`
+ - access the parsed data, which is returned as a :class:`ParseResults`
+   object
+ - find some helpful expression short-cuts like :class:`delimitedList`
+   and :class:`oneOf`
+ - find more useful common expressions in the :class:`pyparsing_common`
+   namespace class
+"""
+from typing import NamedTuple
+
+
+class version_info(NamedTuple):
+    major: int
+    minor: int
+    micro: int
+    releaselevel: str
+    serial: int
+
+    @property
+    def __version__(self):
+        return (
+            "{}.{}.{}".format(self.major, self.minor, self.micro)
+            + (
+                "{}{}{}".format(
+                    "r" if self.releaselevel[0] == "c" else "",
+                    self.releaselevel[0],
+                    self.serial,
+                ),
+                "",
+            )[self.releaselevel == "final"]
+        )
+
+    def __str__(self):
+        return "{} {} / {}".format(__name__, self.__version__, __version_time__)
+
+    def __repr__(self):
+        return "{}.{}({})".format(
+            __name__,
+            type(self).__name__,
+            ", ".join("{}={!r}".format(*nv) for nv in zip(self._fields, self)),
+        )
+
+
+__version_info__ = version_info(3, 0, 9, "final", 0)
+__version_time__ = "05 May 2022 07:02 UTC"
+__version__ = __version_info__.__version__
+__versionTime__ = __version_time__
+__author__ = "Paul McGuire <ptmcg.gm+pyparsing@gmail.com>"
+
+from .util import *
+from .exceptions import *
+from .actions import *
+from .core import __diag__, __compat__
+from .results import *
+from .core import *
+from .core import _builtin_exprs as core_builtin_exprs
+from .helpers import *
+from .helpers import _builtin_exprs as helper_builtin_exprs
+
+from .unicode import unicode_set, UnicodeRangeList, pyparsing_unicode as unicode
+from .testing import pyparsing_test as testing
+from .common import (
+    pyparsing_common as common,
+    _builtin_exprs as common_builtin_exprs,
+)
+
+# define backward compat synonyms
+if "pyparsing_unicode" not in globals():
+    pyparsing_unicode = unicode
+if "pyparsing_common" not in globals():
+    pyparsing_common = common
+if "pyparsing_test" not in globals():
+    pyparsing_test = testing
+
+core_builtin_exprs += common_builtin_exprs + helper_builtin_exprs
+
+
+__all__ = [
+    "__version__",
+    "__version_time__",
+    "__author__",
+    "__compat__",
+    "__diag__",
+    "And",
+    "AtLineStart",
+    "AtStringStart",
+    "CaselessKeyword",
+    "CaselessLiteral",
+    "CharsNotIn",
+    "Combine",
+    "Dict",
+    "Each",
+    "Empty",
+    "FollowedBy",
+    "Forward",
+    "GoToColumn",
+    "Group",
+    "IndentedBlock",
+    "Keyword",
+    "LineEnd",
+    "LineStart",
+    "Literal",
+    "Located",
+    "PrecededBy",
+    "MatchFirst",
+    "NoMatch",
+    "NotAny",
+    "OneOrMore",
+    "OnlyOnce",
+    "OpAssoc",
+    "Opt",
+    "Optional",
+    "Or",
+    "ParseBaseException",
+    "ParseElementEnhance",
+    "ParseException",
+    "ParseExpression",
+    "ParseFatalException",
+    "ParseResults",
+    "ParseSyntaxException",
+    "ParserElement",
+    "PositionToken",
+    "QuotedString",
+    "RecursiveGrammarException",
+    "Regex",
+    "SkipTo",
+    "StringEnd",
+    "StringStart",
+    "Suppress",
+    "Token",
+    "TokenConverter",
+    "White",
+    "Word",
+    "WordEnd",
+    "WordStart",
+    "ZeroOrMore",
+    "Char",
+    "alphanums",
+    "alphas",
+    "alphas8bit",
+    "any_close_tag",
+    "any_open_tag",
+    "c_style_comment",
+    "col",
+    "common_html_entity",
+    "counted_array",
+    "cpp_style_comment",
+    "dbl_quoted_string",
+    "dbl_slash_comment",
+    "delimited_list",
+    "dict_of",
+    "empty",
+    "hexnums",
+    "html_comment",
+    "identchars",
+    "identbodychars",
+    "java_style_comment",
+    "line",
+    "line_end",
+    "line_start",
+    "lineno",
+    "make_html_tags",
+    "make_xml_tags",
+    "match_only_at_col",
+    "match_previous_expr",
+    "match_previous_literal",
+    "nested_expr",
+    "null_debug_action",
+    "nums",
+    "one_of",
+    "printables",
+    "punc8bit",
+    "python_style_comment",
+    "quoted_string",
+    "remove_quotes",
+    "replace_with",
+    "replace_html_entity",
+    "rest_of_line",
+    "sgl_quoted_string",
+    "srange",
+    "string_end",
+    "string_start",
+    "trace_parse_action",
+    "unicode_string",
+    "with_attribute",
+    "indentedBlock",
+    "original_text_for",
+    "ungroup",
+    "infix_notation",
+    "locatedExpr",
+    "with_class",
+    "CloseMatch",
+    "token_map",
+    "pyparsing_common",
+    "pyparsing_unicode",
+    "unicode_set",
+    "condition_as_parse_action",
+    "pyparsing_test",
+    # pre-PEP8 compatibility names
+    "__versionTime__",
+    "anyCloseTag",
+    "anyOpenTag",
+    "cStyleComment",
+    "commonHTMLEntity",
+    "countedArray",
+    "cppStyleComment",
+    "dblQuotedString",
+    "dblSlashComment",
+    "delimitedList",
+    "dictOf",
+    "htmlComment",
+    "javaStyleComment",
+    "lineEnd",
+    "lineStart",
+    "makeHTMLTags",
+    "makeXMLTags",
+    "matchOnlyAtCol",
+    "matchPreviousExpr",
+    "matchPreviousLiteral",
+    "nestedExpr",
+    "nullDebugAction",
+    "oneOf",
+    "opAssoc",
+    "pythonStyleComment",
+    "quotedString",
+    "removeQuotes",
+    "replaceHTMLEntity",
+    "replaceWith",
+    "restOfLine",
+    "sglQuotedString",
+    "stringEnd",
+    "stringStart",
+    "traceParseAction",
+    "unicodeString",
+    "withAttribute",
+    "indentedBlock",
+    "originalTextFor",
+    "infixNotation",
+    "locatedExpr",
+    "withClass",
+    "tokenMap",
+    "conditionAsParseAction",
+    "autoname_elements",
+]
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/actions.py b/myenv/lib/python3.9/site-packages/pyparsing/actions.py
new file mode 100644
index 0000000..f72c66e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing/actions.py
@@ -0,0 +1,207 @@
+# actions.py
+
+from .exceptions import ParseException
+from .util import col
+
+
+class OnlyOnce:
+    """
+    Wrapper for parse actions, to ensure they are only called once.
+    """
+
+    def __init__(self, method_call):
+        from .core import _trim_arity
+
+        self.callable = _trim_arity(method_call)
+        self.called = False
+
+    def __call__(self, s, l, t):
+        if not self.called:
+            results = self.callable(s, l, t)
+            self.called = True
+            return results
+        raise ParseException(s, l, "OnlyOnce obj called multiple times w/out reset")
+
+    def reset(self):
+        """
+        Allow the associated parse action to be called once more.
+        """
+
+        self.called = False
+
+
+def match_only_at_col(n):
+    """
+    Helper method for defining parse actions that require matching at
+    a specific column in the input text.
+    """
+
+    def verify_col(strg, locn, toks):
+        if col(locn, strg) != n:
+            raise ParseException(strg, locn, "matched token not at column {}".format(n))
+
+    return verify_col
+
+
+def replace_with(repl_str):
+    """
+    Helper method for common parse actions that simply return
+    a literal value.  Especially useful when used with
+    :class:`transform_string<ParserElement.transform_string>` ().
+
+    Example::
+
+        num = Word(nums).set_parse_action(lambda toks: int(toks[0]))
+        na = one_of("N/A NA").set_parse_action(replace_with(math.nan))
+        term = na | num
+
+        term[1, ...].parse_string("324 234 N/A 234") # -> [324, 234, nan, 234]
+    """
+    return lambda s, l, t: [repl_str]
+
+
+def remove_quotes(s, l, t):
+    """
+    Helper parse action for removing quotation marks from parsed
+    quoted strings.
+
+    Example::
+
+        # by default, quotation marks are included in parsed results
+        quoted_string.parse_string("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"]
+
+        # use remove_quotes to strip quotation marks from parsed results
+        quoted_string.set_parse_action(remove_quotes)
+        quoted_string.parse_string("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"]
+    """
+    return t[0][1:-1]
+
+
+def with_attribute(*args, **attr_dict):
+    """
+    Helper to create a validating parse action to be used with start
+    tags created with :class:`make_xml_tags` or
+    :class:`make_html_tags`. Use ``with_attribute`` to qualify
+    a starting tag with a required attribute value, to avoid false
+    matches on common tags such as ``<TD>`` or ``<DIV>``.
+
+    Call ``with_attribute`` with a series of attribute names and
+    values. Specify the list of filter attributes names and values as:
+
+    - keyword arguments, as in ``(align="right")``, or
+    - as an explicit dict with ``**`` operator, when an attribute
+      name is also a Python reserved word, as in ``**{"class":"Customer", "align":"right"}``
+    - a list of name-value tuples, as in ``(("ns1:class", "Customer"), ("ns2:align", "right"))``
+
+    For attribute names with a namespace prefix, you must use the second
+    form.  Attribute names are matched insensitive to upper/lower case.
+
+    If just testing for ``class`` (with or without a namespace), use
+    :class:`with_class`.
+
+    To verify that the attribute exists, but without specifying a value,
+    pass ``with_attribute.ANY_VALUE`` as the value.
+
+    Example::
+
+        html = '''
+            <div>
+            Some text
+            <div type="grid">1 4 0 1 0</div>
+            <div type="graph">1,3 2,3 1,1</div>
+            <div>this has no type</div>
+            </div>
+
+        '''
+        div,div_end = make_html_tags("div")
+
+        # only match div tag having a type attribute with value "grid"
+        div_grid = div().set_parse_action(with_attribute(type="grid"))
+        grid_expr = div_grid + SkipTo(div | div_end)("body")
+        for grid_header in grid_expr.search_string(html):
+            print(grid_header.body)
+
+        # construct a match with any div tag having a type attribute, regardless of the value
+        div_any_type = div().set_parse_action(with_attribute(type=with_attribute.ANY_VALUE))
+        div_expr = div_any_type + SkipTo(div | div_end)("body")
+        for div_header in div_expr.search_string(html):
+            print(div_header.body)
+
+    prints::
+
+        1 4 0 1 0
+
+        1 4 0 1 0
+        1,3 2,3 1,1
+    """
+    if args:
+        attrs = args[:]
+    else:
+        attrs = attr_dict.items()
+    attrs = [(k, v) for k, v in attrs]
+
+    def pa(s, l, tokens):
+        for attrName, attrValue in attrs:
+            if attrName not in tokens:
+                raise ParseException(s, l, "no matching attribute " + attrName)
+            if attrValue != with_attribute.ANY_VALUE and tokens[attrName] != attrValue:
+                raise ParseException(
+                    s,
+                    l,
+                    "attribute {!r} has value {!r}, must be {!r}".format(
+                        attrName, tokens[attrName], attrValue
+                    ),
+                )
+
+    return pa
+
+
+with_attribute.ANY_VALUE = object()
+
+
+def with_class(classname, namespace=""):
+    """
+    Simplified version of :class:`with_attribute` when
+    matching on a div class - made difficult because ``class`` is
+    a reserved word in Python.
+
+    Example::
+
+        html = '''
+            <div>
+            Some text
+            <div class="grid">1 4 0 1 0</div>
+            <div class="graph">1,3 2,3 1,1</div>
+            <div>this &lt;div&gt; has no class</div>
+            </div>
+
+        '''
+        div,div_end = make_html_tags("div")
+        div_grid = div().set_parse_action(with_class("grid"))
+
+        grid_expr = div_grid + SkipTo(div | div_end)("body")
+        for grid_header in grid_expr.search_string(html):
+            print(grid_header.body)
+
+        div_any_type = div().set_parse_action(with_class(withAttribute.ANY_VALUE))
+        div_expr = div_any_type + SkipTo(div | div_end)("body")
+        for div_header in div_expr.search_string(html):
+            print(div_header.body)
+
+    prints::
+
+        1 4 0 1 0
+
+        1 4 0 1 0
+        1,3 2,3 1,1
+    """
+    classattr = "{}:class".format(namespace) if namespace else "class"
+    return with_attribute(**{classattr: classname})
+
+
+# pre-PEP8 compatibility symbols
+replaceWith = replace_with
+removeQuotes = remove_quotes
+withAttribute = with_attribute
+withClass = with_class
+matchOnlyAtCol = match_only_at_col
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/common.py b/myenv/lib/python3.9/site-packages/pyparsing/common.py
new file mode 100644
index 0000000..1859fb7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing/common.py
@@ -0,0 +1,424 @@
+# common.py
+from .core import *
+from .helpers import delimited_list, any_open_tag, any_close_tag
+from datetime import datetime
+
+
+# some other useful expressions - using lower-case class name since we are really using this as a namespace
+class pyparsing_common:
+    """Here are some common low-level expressions that may be useful in
+    jump-starting parser development:
+
+    - numeric forms (:class:`integers<integer>`, :class:`reals<real>`,
+      :class:`scientific notation<sci_real>`)
+    - common :class:`programming identifiers<identifier>`
+    - network addresses (:class:`MAC<mac_address>`,
+      :class:`IPv4<ipv4_address>`, :class:`IPv6<ipv6_address>`)
+    - ISO8601 :class:`dates<iso8601_date>` and
+      :class:`datetime<iso8601_datetime>`
+    - :class:`UUID<uuid>`
+    - :class:`comma-separated list<comma_separated_list>`
+    - :class:`url`
+
+    Parse actions:
+
+    - :class:`convertToInteger`
+    - :class:`convertToFloat`
+    - :class:`convertToDate`
+    - :class:`convertToDatetime`
+    - :class:`stripHTMLTags`
+    - :class:`upcaseTokens`
+    - :class:`downcaseTokens`
+
+    Example::
+
+        pyparsing_common.number.runTests('''
+            # any int or real number, returned as the appropriate type
+            100
+            -100
+            +100
+            3.14159
+            6.02e23
+            1e-12
+            ''')
+
+        pyparsing_common.fnumber.runTests('''
+            # any int or real number, returned as float
+            100
+            -100
+            +100
+            3.14159
+            6.02e23
+            1e-12
+            ''')
+
+        pyparsing_common.hex_integer.runTests('''
+            # hex numbers
+            100
+            FF
+            ''')
+
+        pyparsing_common.fraction.runTests('''
+            # fractions
+            1/2
+            -3/4
+            ''')
+
+        pyparsing_common.mixed_integer.runTests('''
+            # mixed fractions
+            1
+            1/2
+            -3/4
+            1-3/4
+            ''')
+
+        import uuid
+        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
+        pyparsing_common.uuid.runTests('''
+            # uuid
+            12345678-1234-5678-1234-567812345678
+            ''')
+
+    prints::
+
+        # any int or real number, returned as the appropriate type
+        100
+        [100]
+
+        -100
+        [-100]
+
+        +100
+        [100]
+
+        3.14159
+        [3.14159]
+
+        6.02e23
+        [6.02e+23]
+
+        1e-12
+        [1e-12]
+
+        # any int or real number, returned as float
+        100
+        [100.0]
+
+        -100
+        [-100.0]
+
+        +100
+        [100.0]
+
+        3.14159
+        [3.14159]
+
+        6.02e23
+        [6.02e+23]
+
+        1e-12
+        [1e-12]
+
+        # hex numbers
+        100
+        [256]
+
+        FF
+        [255]
+
+        # fractions
+        1/2
+        [0.5]
+
+        -3/4
+        [-0.75]
+
+        # mixed fractions
+        1
+        [1]
+
+        1/2
+        [0.5]
+
+        -3/4
+        [-0.75]
+
+        1-3/4
+        [1.75]
+
+        # uuid
+        12345678-1234-5678-1234-567812345678
+        [UUID('12345678-1234-5678-1234-567812345678')]
+    """
+
+    convert_to_integer = token_map(int)
+    """
+    Parse action for converting parsed integers to Python int
+    """
+
+    convert_to_float = token_map(float)
+    """
+    Parse action for converting parsed numbers to Python float
+    """
+
+    integer = Word(nums).set_name("integer").set_parse_action(convert_to_integer)
+    """expression that parses an unsigned integer, returns an int"""
+
+    hex_integer = (
+        Word(hexnums).set_name("hex integer").set_parse_action(token_map(int, 16))
+    )
+    """expression that parses a hexadecimal integer, returns an int"""
+
+    signed_integer = (
+        Regex(r"[+-]?\d+")
+        .set_name("signed integer")
+        .set_parse_action(convert_to_integer)
+    )
+    """expression that parses an integer with optional leading sign, returns an int"""
+
+    fraction = (
+        signed_integer().set_parse_action(convert_to_float)
+        + "/"
+        + signed_integer().set_parse_action(convert_to_float)
+    ).set_name("fraction")
+    """fractional expression of an integer divided by an integer, returns a float"""
+    fraction.add_parse_action(lambda tt: tt[0] / tt[-1])
+
+    mixed_integer = (
+        fraction | signed_integer + Opt(Opt("-").suppress() + fraction)
+    ).set_name("fraction or mixed integer-fraction")
+    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float"""
+    mixed_integer.add_parse_action(sum)
+
+    real = (
+        Regex(r"[+-]?(?:\d+\.\d*|\.\d+)")
+        .set_name("real number")
+        .set_parse_action(convert_to_float)
+    )
+    """expression that parses a floating point number and returns a float"""
+
+    sci_real = (
+        Regex(r"[+-]?(?:\d+(?:[eE][+-]?\d+)|(?:\d+\.\d*|\.\d+)(?:[eE][+-]?\d+)?)")
+        .set_name("real number with scientific notation")
+        .set_parse_action(convert_to_float)
+    )
+    """expression that parses a floating point number with optional
+    scientific notation and returns a float"""
+
+    # streamlining this expression makes the docs nicer-looking
+    number = (sci_real | real | signed_integer).setName("number").streamline()
+    """any numeric expression, returns the corresponding Python type"""
+
+    fnumber = (
+        Regex(r"[+-]?\d+\.?\d*([eE][+-]?\d+)?")
+        .set_name("fnumber")
+        .set_parse_action(convert_to_float)
+    )
+    """any int or real number, returned as float"""
+
+    identifier = Word(identchars, identbodychars).set_name("identifier")
+    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')"""
+
+    ipv4_address = Regex(
+        r"(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}"
+    ).set_name("IPv4 address")
+    "IPv4 address (``0.0.0.0 - 255.255.255.255``)"
+
+    _ipv6_part = Regex(r"[0-9a-fA-F]{1,4}").set_name("hex_integer")
+    _full_ipv6_address = (_ipv6_part + (":" + _ipv6_part) * 7).set_name(
+        "full IPv6 address"
+    )
+    _short_ipv6_address = (
+        Opt(_ipv6_part + (":" + _ipv6_part) * (0, 6))
+        + "::"
+        + Opt(_ipv6_part + (":" + _ipv6_part) * (0, 6))
+    ).set_name("short IPv6 address")
+    _short_ipv6_address.add_condition(
+        lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8
+    )
+    _mixed_ipv6_address = ("::ffff:" + ipv4_address).set_name("mixed IPv6 address")
+    ipv6_address = Combine(
+        (_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).set_name(
+            "IPv6 address"
+        )
+    ).set_name("IPv6 address")
+    "IPv6 address (long, short, or mixed form)"
+
+    mac_address = Regex(
+        r"[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}"
+    ).set_name("MAC address")
+    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)"
+
+    @staticmethod
+    def convert_to_date(fmt: str = "%Y-%m-%d"):
+        """
+        Helper to create a parse action for converting parsed date string to Python datetime.date
+
+        Params -
+        - fmt - format to be passed to datetime.strptime (default= ``"%Y-%m-%d"``)
+
+        Example::
+
+            date_expr = pyparsing_common.iso8601_date.copy()
+            date_expr.setParseAction(pyparsing_common.convertToDate())
+            print(date_expr.parseString("1999-12-31"))
+
+        prints::
+
+            [datetime.date(1999, 12, 31)]
+        """
+
+        def cvt_fn(ss, ll, tt):
+            try:
+                return datetime.strptime(tt[0], fmt).date()
+            except ValueError as ve:
+                raise ParseException(ss, ll, str(ve))
+
+        return cvt_fn
+
+    @staticmethod
+    def convert_to_datetime(fmt: str = "%Y-%m-%dT%H:%M:%S.%f"):
+        """Helper to create a parse action for converting parsed
+        datetime string to Python datetime.datetime
+
+        Params -
+        - fmt - format to be passed to datetime.strptime (default= ``"%Y-%m-%dT%H:%M:%S.%f"``)
+
+        Example::
+
+            dt_expr = pyparsing_common.iso8601_datetime.copy()
+            dt_expr.setParseAction(pyparsing_common.convertToDatetime())
+            print(dt_expr.parseString("1999-12-31T23:59:59.999"))
+
+        prints::
+
+            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]
+        """
+
+        def cvt_fn(s, l, t):
+            try:
+                return datetime.strptime(t[0], fmt)
+            except ValueError as ve:
+                raise ParseException(s, l, str(ve))
+
+        return cvt_fn
+
+    iso8601_date = Regex(
+        r"(?P<year>\d{4})(?:-(?P<month>\d\d)(?:-(?P<day>\d\d))?)?"
+    ).set_name("ISO8601 date")
+    "ISO8601 date (``yyyy-mm-dd``)"
+
+    iso8601_datetime = Regex(
+        r"(?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)[T ](?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d(\.\d*)?)?)?(?P<tz>Z|[+-]\d\d:?\d\d)?"
+    ).set_name("ISO8601 datetime")
+    "ISO8601 datetime (``yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)``) - trailing seconds, milliseconds, and timezone optional; accepts separating ``'T'`` or ``' '``"
+
+    uuid = Regex(r"[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}").set_name("UUID")
+    "UUID (``xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx``)"
+
+    _html_stripper = any_open_tag.suppress() | any_close_tag.suppress()
+
+    @staticmethod
+    def strip_html_tags(s: str, l: int, tokens: ParseResults):
+        """Parse action to remove HTML tags from web page HTML source
+
+        Example::
+
+            # strip HTML links from normal text
+            text = '<td>More info at the <a href="https://github.com/pyparsing/pyparsing/wiki">pyparsing</a> wiki page</td>'
+            td, td_end = makeHTMLTags("TD")
+            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end
+            print(table_text.parseString(text).body)
+
+        Prints::
+
+            More info at the pyparsing wiki page
+        """
+        return pyparsing_common._html_stripper.transform_string(tokens[0])
+
+    _commasepitem = (
+        Combine(
+            OneOrMore(
+                ~Literal(",")
+                + ~LineEnd()
+                + Word(printables, exclude_chars=",")
+                + Opt(White(" \t") + ~FollowedBy(LineEnd() | ","))
+            )
+        )
+        .streamline()
+        .set_name("commaItem")
+    )
+    comma_separated_list = delimited_list(
+        Opt(quoted_string.copy() | _commasepitem, default="")
+    ).set_name("comma separated list")
+    """Predefined expression of 1 or more printable words or quoted strings, separated by commas."""
+
+    upcase_tokens = staticmethod(token_map(lambda t: t.upper()))
+    """Parse action to convert tokens to upper case."""
+
+    downcase_tokens = staticmethod(token_map(lambda t: t.lower()))
+    """Parse action to convert tokens to lower case."""
+
+    # fmt: off
+    url = Regex(
+        # https://mathiasbynens.be/demo/url-regex
+        # https://gist.github.com/dperini/729294
+        r"^" +
+        # protocol identifier (optional)
+        # short syntax // still required
+        r"(?:(?:(?P<scheme>https?|ftp):)?\/\/)" +
+        # user:pass BasicAuth (optional)
+        r"(?:(?P<auth>\S+(?::\S*)?)@)?" +
+        r"(?P<host>" +
+        # IP address exclusion
+        # private & local networks
+        r"(?!(?:10|127)(?:\.\d{1,3}){3})" +
+        r"(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})" +
+        r"(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})" +
+        # IP address dotted notation octets
+        # excludes loopback network 0.0.0.0
+        # excludes reserved space >= 224.0.0.0
+        # excludes network & broadcast addresses
+        # (first & last IP address of each class)
+        r"(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])" +
+        r"(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}" +
+        r"(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))" +
+        r"|" +
+        # host & domain names, may end with dot
+        # can be replaced by a shortest alternative
+        # (?![-_])(?:[-\w\u00a1-\uffff]{0,63}[^-_]\.)+
+        r"(?:" +
+        r"(?:" +
+        r"[a-z0-9\u00a1-\uffff]" +
+        r"[a-z0-9\u00a1-\uffff_-]{0,62}" +
+        r")?" +
+        r"[a-z0-9\u00a1-\uffff]\." +
+        r")+" +
+        # TLD identifier name, may end with dot
+        r"(?:[a-z\u00a1-\uffff]{2,}\.?)" +
+        r")" +
+        # port number (optional)
+        r"(:(?P<port>\d{2,5}))?" +
+        # resource path (optional)
+        r"(?P<path>\/[^?# ]*)?" +
+        # query string (optional)
+        r"(\?(?P<query>[^#]*))?" +
+        # fragment (optional)
+        r"(#(?P<fragment>\S*))?" +
+        r"$"
+    ).set_name("url")
+    # fmt: on
+
+    # pre-PEP8 compatibility names
+    convertToInteger = convert_to_integer
+    convertToFloat = convert_to_float
+    convertToDate = convert_to_date
+    convertToDatetime = convert_to_datetime
+    stripHTMLTags = strip_html_tags
+    upcaseTokens = upcase_tokens
+    downcaseTokens = downcase_tokens
+
+
+_builtin_exprs = [
+    v for v in vars(pyparsing_common).values() if isinstance(v, ParserElement)
+]
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/core.py b/myenv/lib/python3.9/site-packages/pyparsing/core.py
new file mode 100644
index 0000000..9acba3f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing/core.py
@@ -0,0 +1,5814 @@
+#
+# core.py
+#
+import os
+import typing
+from typing import (
+    NamedTuple,
+    Union,
+    Callable,
+    Any,
+    Generator,
+    Tuple,
+    List,
+    TextIO,
+    Set,
+    Sequence,
+)
+from abc import ABC, abstractmethod
+from enum import Enum
+import string
+import copy
+import warnings
+import re
+import sys
+from collections.abc import Iterable
+import traceback
+import types
+from operator import itemgetter
+from functools import wraps
+from threading import RLock
+from pathlib import Path
+
+from .util import (
+    _FifoCache,
+    _UnboundedCache,
+    __config_flags,
+    _collapse_string_to_ranges,
+    _escape_regex_range_chars,
+    _bslash,
+    _flatten,
+    LRUMemo as _LRUMemo,
+    UnboundedMemo as _UnboundedMemo,
+)
+from .exceptions import *
+from .actions import *
+from .results import ParseResults, _ParseResultsWithOffset
+from .unicode import pyparsing_unicode
+
+_MAX_INT = sys.maxsize
+str_type: Tuple[type, ...] = (str, bytes)
+
+#
+# Copyright (c) 2003-2022  Paul T. McGuire
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+
+if sys.version_info >= (3, 8):
+    from functools import cached_property
+else:
+
+    class cached_property:
+        def __init__(self, func):
+            self._func = func
+
+        def __get__(self, instance, owner=None):
+            ret = instance.__dict__[self._func.__name__] = self._func(instance)
+            return ret
+
+
+class __compat__(__config_flags):
+    """
+    A cross-version compatibility configuration for pyparsing features that will be
+    released in a future version. By setting values in this configuration to True,
+    those features can be enabled in prior versions for compatibility development
+    and testing.
+
+    - ``collect_all_And_tokens`` - flag to enable fix for Issue #63 that fixes erroneous grouping
+      of results names when an :class:`And` expression is nested within an :class:`Or` or :class:`MatchFirst`;
+      maintained for compatibility, but setting to ``False`` no longer restores pre-2.3.1
+      behavior
+    """
+
+    _type_desc = "compatibility"
+
+    collect_all_And_tokens = True
+
+    _all_names = [__ for __ in locals() if not __.startswith("_")]
+    _fixed_names = """
+        collect_all_And_tokens
+        """.split()
+
+
+class __diag__(__config_flags):
+    _type_desc = "diagnostic"
+
+    warn_multiple_tokens_in_named_alternation = False
+    warn_ungrouped_named_tokens_in_collection = False
+    warn_name_set_on_empty_Forward = False
+    warn_on_parse_using_empty_Forward = False
+    warn_on_assignment_to_Forward = False
+    warn_on_multiple_string_args_to_oneof = False
+    warn_on_match_first_with_lshift_operator = False
+    enable_debug_on_named_expressions = False
+
+    _all_names = [__ for __ in locals() if not __.startswith("_")]
+    _warning_names = [name for name in _all_names if name.startswith("warn")]
+    _debug_names = [name for name in _all_names if name.startswith("enable_debug")]
+
+    @classmethod
+    def enable_all_warnings(cls) -> None:
+        for name in cls._warning_names:
+            cls.enable(name)
+
+
+class Diagnostics(Enum):
+    """
+    Diagnostic configuration (all default to disabled)
+    - ``warn_multiple_tokens_in_named_alternation`` - flag to enable warnings when a results
+      name is defined on a :class:`MatchFirst` or :class:`Or` expression with one or more :class:`And` subexpressions
+    - ``warn_ungrouped_named_tokens_in_collection`` - flag to enable warnings when a results
+      name is defined on a containing expression with ungrouped subexpressions that also
+      have results names
+    - ``warn_name_set_on_empty_Forward`` - flag to enable warnings when a :class:`Forward` is defined
+      with a results name, but has no contents defined
+    - ``warn_on_parse_using_empty_Forward`` - flag to enable warnings when a :class:`Forward` is
+      defined in a grammar but has never had an expression attached to it
+    - ``warn_on_assignment_to_Forward`` - flag to enable warnings when a :class:`Forward` is defined
+      but is overwritten by assigning using ``'='`` instead of ``'<<='`` or ``'<<'``
+    - ``warn_on_multiple_string_args_to_oneof`` - flag to enable warnings when :class:`one_of` is
+      incorrectly called with multiple str arguments
+    - ``enable_debug_on_named_expressions`` - flag to auto-enable debug on all subsequent
+      calls to :class:`ParserElement.set_name`
+
+    Diagnostics are enabled/disabled by calling :class:`enable_diag` and :class:`disable_diag`.
+    All warnings can be enabled by calling :class:`enable_all_warnings`.
+    """
+
+    warn_multiple_tokens_in_named_alternation = 0
+    warn_ungrouped_named_tokens_in_collection = 1
+    warn_name_set_on_empty_Forward = 2
+    warn_on_parse_using_empty_Forward = 3
+    warn_on_assignment_to_Forward = 4
+    warn_on_multiple_string_args_to_oneof = 5
+    warn_on_match_first_with_lshift_operator = 6
+    enable_debug_on_named_expressions = 7
+
+
+def enable_diag(diag_enum: Diagnostics) -> None:
+    """
+    Enable a global pyparsing diagnostic flag (see :class:`Diagnostics`).
+    """
+    __diag__.enable(diag_enum.name)
+
+
+def disable_diag(diag_enum: Diagnostics) -> None:
+    """
+    Disable a global pyparsing diagnostic flag (see :class:`Diagnostics`).
+    """
+    __diag__.disable(diag_enum.name)
+
+
+def enable_all_warnings() -> None:
+    """
+    Enable all global pyparsing diagnostic warnings (see :class:`Diagnostics`).
+    """
+    __diag__.enable_all_warnings()
+
+
+# hide abstract class
+del __config_flags
+
+
+def _should_enable_warnings(
+    cmd_line_warn_options: typing.Iterable[str], warn_env_var: typing.Optional[str]
+) -> bool:
+    enable = bool(warn_env_var)
+    for warn_opt in cmd_line_warn_options:
+        w_action, w_message, w_category, w_module, w_line = (warn_opt + "::::").split(
+            ":"
+        )[:5]
+        if not w_action.lower().startswith("i") and (
+            not (w_message or w_category or w_module) or w_module == "pyparsing"
+        ):
+            enable = True
+        elif w_action.lower().startswith("i") and w_module in ("pyparsing", ""):
+            enable = False
+    return enable
+
+
+if _should_enable_warnings(
+    sys.warnoptions, os.environ.get("PYPARSINGENABLEALLWARNINGS")
+):
+    enable_all_warnings()
+
+
+# build list of single arg builtins, that can be used as parse actions
+_single_arg_builtins = {
+    sum,
+    len,
+    sorted,
+    reversed,
+    list,
+    tuple,
+    set,
+    any,
+    all,
+    min,
+    max,
+}
+
+_generatorType = types.GeneratorType
+ParseAction = Union[
+    Callable[[], Any],
+    Callable[[ParseResults], Any],
+    Callable[[int, ParseResults], Any],
+    Callable[[str, int, ParseResults], Any],
+]
+ParseCondition = Union[
+    Callable[[], bool],
+    Callable[[ParseResults], bool],
+    Callable[[int, ParseResults], bool],
+    Callable[[str, int, ParseResults], bool],
+]
+ParseFailAction = Callable[[str, int, "ParserElement", Exception], None]
+DebugStartAction = Callable[[str, int, "ParserElement", bool], None]
+DebugSuccessAction = Callable[
+    [str, int, int, "ParserElement", ParseResults, bool], None
+]
+DebugExceptionAction = Callable[[str, int, "ParserElement", Exception, bool], None]
+
+
+alphas = string.ascii_uppercase + string.ascii_lowercase
+identchars = pyparsing_unicode.Latin1.identchars
+identbodychars = pyparsing_unicode.Latin1.identbodychars
+nums = "0123456789"
+hexnums = nums + "ABCDEFabcdef"
+alphanums = alphas + nums
+printables = "".join([c for c in string.printable if c not in string.whitespace])
+
+_trim_arity_call_line: traceback.StackSummary = None
+
+
+def _trim_arity(func, max_limit=3):
+    """decorator to trim function calls to match the arity of the target"""
+    global _trim_arity_call_line
+
+    if func in _single_arg_builtins:
+        return lambda s, l, t: func(t)
+
+    limit = 0
+    found_arity = False
+
+    def extract_tb(tb, limit=0):
+        frames = traceback.extract_tb(tb, limit=limit)
+        frame_summary = frames[-1]
+        return [frame_summary[:2]]
+
+    # synthesize what would be returned by traceback.extract_stack at the call to
+    # user's parse action 'func', so that we don't incur call penalty at parse time
+
+    # fmt: off
+    LINE_DIFF = 7
+    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND
+    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!!
+    _trim_arity_call_line = (_trim_arity_call_line or traceback.extract_stack(limit=2)[-1])
+    pa_call_line_synth = (_trim_arity_call_line[0], _trim_arity_call_line[1] + LINE_DIFF)
+
+    def wrapper(*args):
+        nonlocal found_arity, limit
+        while 1:
+            try:
+                ret = func(*args[limit:])
+                found_arity = True
+                return ret
+            except TypeError as te:
+                # re-raise TypeErrors if they did not come from our arity testing
+                if found_arity:
+                    raise
+                else:
+                    tb = te.__traceback__
+                    trim_arity_type_error = (
+                        extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth
+                    )
+                    del tb
+
+                    if trim_arity_type_error:
+                        if limit < max_limit:
+                            limit += 1
+                            continue
+
+                    raise
+    # fmt: on
+
+    # copy func name to wrapper for sensible debug output
+    # (can't use functools.wraps, since that messes with function signature)
+    func_name = getattr(func, "__name__", getattr(func, "__class__").__name__)
+    wrapper.__name__ = func_name
+    wrapper.__doc__ = func.__doc__
+
+    return wrapper
+
+
+def condition_as_parse_action(
+    fn: ParseCondition, message: str = None, fatal: bool = False
+) -> ParseAction:
+    """
+    Function to convert a simple predicate function that returns ``True`` or ``False``
+    into a parse action. Can be used in places when a parse action is required
+    and :class:`ParserElement.add_condition` cannot be used (such as when adding a condition
+    to an operator level in :class:`infix_notation`).
+
+    Optional keyword arguments:
+
+    - ``message`` - define a custom message to be used in the raised exception
+    - ``fatal`` - if True, will raise :class:`ParseFatalException` to stop parsing immediately;
+      otherwise will raise :class:`ParseException`
+
+    """
+    msg = message if message is not None else "failed user-defined condition"
+    exc_type = ParseFatalException if fatal else ParseException
+    fn = _trim_arity(fn)
+
+    @wraps(fn)
+    def pa(s, l, t):
+        if not bool(fn(s, l, t)):
+            raise exc_type(s, l, msg)
+
+    return pa
+
+
+def _default_start_debug_action(
+    instring: str, loc: int, expr: "ParserElement", cache_hit: bool = False
+):
+    cache_hit_str = "*" if cache_hit else ""
+    print(
+        (
+            "{}Match {} at loc {}({},{})\n  {}\n  {}^".format(
+                cache_hit_str,
+                expr,
+                loc,
+                lineno(loc, instring),
+                col(loc, instring),
+                line(loc, instring),
+                " " * (col(loc, instring) - 1),
+            )
+        )
+    )
+
+
+def _default_success_debug_action(
+    instring: str,
+    startloc: int,
+    endloc: int,
+    expr: "ParserElement",
+    toks: ParseResults,
+    cache_hit: bool = False,
+):
+    cache_hit_str = "*" if cache_hit else ""
+    print("{}Matched {} -> {}".format(cache_hit_str, expr, toks.as_list()))
+
+
+def _default_exception_debug_action(
+    instring: str,
+    loc: int,
+    expr: "ParserElement",
+    exc: Exception,
+    cache_hit: bool = False,
+):
+    cache_hit_str = "*" if cache_hit else ""
+    print(
+        "{}Match {} failed, {} raised: {}".format(
+            cache_hit_str, expr, type(exc).__name__, exc
+        )
+    )
+
+
+def null_debug_action(*args):
+    """'Do-nothing' debug action, to suppress debugging output during parsing."""
+
+
+class ParserElement(ABC):
+    """Abstract base level parser element class."""
+
+    DEFAULT_WHITE_CHARS: str = " \n\t\r"
+    verbose_stacktrace: bool = False
+    _literalStringClass: typing.Optional[type] = None
+
+    @staticmethod
+    def set_default_whitespace_chars(chars: str) -> None:
+        r"""
+        Overrides the default whitespace chars
+
+        Example::
+
+            # default whitespace chars are space, <TAB> and newline
+            Word(alphas)[1, ...].parse_string("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl']
+
+            # change to just treat newline as significant
+            ParserElement.set_default_whitespace_chars(" \t")
+            Word(alphas)[1, ...].parse_string("abc def\nghi jkl")  # -> ['abc', 'def']
+        """
+        ParserElement.DEFAULT_WHITE_CHARS = chars
+
+        # update whitespace all parse expressions defined in this module
+        for expr in _builtin_exprs:
+            if expr.copyDefaultWhiteChars:
+                expr.whiteChars = set(chars)
+
+    @staticmethod
+    def inline_literals_using(cls: type) -> None:
+        """
+        Set class to be used for inclusion of string literals into a parser.
+
+        Example::
+
+            # default literal class used is Literal
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+            date_str.parse_string("1999/12/31")  # -> ['1999', '/', '12', '/', '31']
+
+
+            # change to Suppress
+            ParserElement.inline_literals_using(Suppress)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+            date_str.parse_string("1999/12/31")  # -> ['1999', '12', '31']
+        """
+        ParserElement._literalStringClass = cls
+
+    class DebugActions(NamedTuple):
+        debug_try: typing.Optional[DebugStartAction]
+        debug_match: typing.Optional[DebugSuccessAction]
+        debug_fail: typing.Optional[DebugExceptionAction]
+
+    def __init__(self, savelist: bool = False):
+        self.parseAction: List[ParseAction] = list()
+        self.failAction: typing.Optional[ParseFailAction] = None
+        self.customName = None
+        self._defaultName = None
+        self.resultsName = None
+        self.saveAsList = savelist
+        self.skipWhitespace = True
+        self.whiteChars = set(ParserElement.DEFAULT_WHITE_CHARS)
+        self.copyDefaultWhiteChars = True
+        # used when checking for left-recursion
+        self.mayReturnEmpty = False
+        self.keepTabs = False
+        self.ignoreExprs: List["ParserElement"] = list()
+        self.debug = False
+        self.streamlined = False
+        # optimize exception handling for subclasses that don't advance parse index
+        self.mayIndexError = True
+        self.errmsg = ""
+        # mark results names as modal (report only last) or cumulative (list all)
+        self.modalResults = True
+        # custom debug actions
+        self.debugActions = self.DebugActions(None, None, None)
+        # avoid redundant calls to preParse
+        self.callPreparse = True
+        self.callDuringTry = False
+        self.suppress_warnings_: List[Diagnostics] = []
+
+    def suppress_warning(self, warning_type: Diagnostics) -> "ParserElement":
+        """
+        Suppress warnings emitted for a particular diagnostic on this expression.
+
+        Example::
+
+            base = pp.Forward()
+            base.suppress_warning(Diagnostics.warn_on_parse_using_empty_Forward)
+
+            # statement would normally raise a warning, but is now suppressed
+            print(base.parseString("x"))
+
+        """
+        self.suppress_warnings_.append(warning_type)
+        return self
+
+    def copy(self) -> "ParserElement":
+        """
+        Make a copy of this :class:`ParserElement`.  Useful for defining
+        different parse actions for the same parsing pattern, using copies of
+        the original parse element.
+
+        Example::
+
+            integer = Word(nums).set_parse_action(lambda toks: int(toks[0]))
+            integerK = integer.copy().add_parse_action(lambda toks: toks[0] * 1024) + Suppress("K")
+            integerM = integer.copy().add_parse_action(lambda toks: toks[0] * 1024 * 1024) + Suppress("M")
+
+            print((integerK | integerM | integer)[1, ...].parse_string("5K 100 640K 256M"))
+
+        prints::
+
+            [5120, 100, 655360, 268435456]
+
+        Equivalent form of ``expr.copy()`` is just ``expr()``::
+
+            integerM = integer().add_parse_action(lambda toks: toks[0] * 1024 * 1024) + Suppress("M")
+        """
+        cpy = copy.copy(self)
+        cpy.parseAction = self.parseAction[:]
+        cpy.ignoreExprs = self.ignoreExprs[:]
+        if self.copyDefaultWhiteChars:
+            cpy.whiteChars = set(ParserElement.DEFAULT_WHITE_CHARS)
+        return cpy
+
+    def set_results_name(
+        self, name: str, list_all_matches: bool = False, *, listAllMatches: bool = False
+    ) -> "ParserElement":
+        """
+        Define name for referencing matching tokens as a nested attribute
+        of the returned parse results.
+
+        Normally, results names are assigned as you would assign keys in a dict:
+        any existing value is overwritten by later values. If it is necessary to
+        keep all values captured for a particular results name, call ``set_results_name``
+        with ``list_all_matches`` = True.
+
+        NOTE: ``set_results_name`` returns a *copy* of the original :class:`ParserElement` object;
+        this is so that the client can define a basic element, such as an
+        integer, and reference it in multiple places with different names.
+
+        You can also set results names using the abbreviated syntax,
+        ``expr("name")`` in place of ``expr.set_results_name("name")``
+        - see :class:`__call__`. If ``list_all_matches`` is required, use
+        ``expr("name*")``.
+
+        Example::
+
+            date_str = (integer.set_results_name("year") + '/'
+                        + integer.set_results_name("month") + '/'
+                        + integer.set_results_name("day"))
+
+            # equivalent form:
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+        """
+        listAllMatches = listAllMatches or list_all_matches
+        return self._setResultsName(name, listAllMatches)
+
+    def _setResultsName(self, name, listAllMatches=False):
+        if name is None:
+            return self
+        newself = self.copy()
+        if name.endswith("*"):
+            name = name[:-1]
+            listAllMatches = True
+        newself.resultsName = name
+        newself.modalResults = not listAllMatches
+        return newself
+
+    def set_break(self, break_flag: bool = True) -> "ParserElement":
+        """
+        Method to invoke the Python pdb debugger when this element is
+        about to be parsed. Set ``break_flag`` to ``True`` to enable, ``False`` to
+        disable.
+        """
+        if break_flag:
+            _parseMethod = self._parse
+
+            def breaker(instring, loc, doActions=True, callPreParse=True):
+                import pdb
+
+                # this call to pdb.set_trace() is intentional, not a checkin error
+                pdb.set_trace()
+                return _parseMethod(instring, loc, doActions, callPreParse)
+
+            breaker._originalParseMethod = _parseMethod
+            self._parse = breaker
+        else:
+            if hasattr(self._parse, "_originalParseMethod"):
+                self._parse = self._parse._originalParseMethod
+        return self
+
+    def set_parse_action(self, *fns: ParseAction, **kwargs) -> "ParserElement":
+        """
+        Define one or more actions to perform when successfully matching parse element definition.
+
+        Parse actions can be called to perform data conversions, do extra validation,
+        update external data structures, or enhance or replace the parsed tokens.
+        Each parse action ``fn`` is a callable method with 0-3 arguments, called as
+        ``fn(s, loc, toks)`` , ``fn(loc, toks)`` , ``fn(toks)`` , or just ``fn()`` , where:
+
+        - s   = the original string being parsed (see note below)
+        - loc = the location of the matching substring
+        - toks = a list of the matched tokens, packaged as a :class:`ParseResults` object
+
+        The parsed tokens are passed to the parse action as ParseResults. They can be
+        modified in place using list-style append, extend, and pop operations to update
+        the parsed list elements; and with dictionary-style item set and del operations
+        to add, update, or remove any named results. If the tokens are modified in place,
+        it is not necessary to return them with a return statement.
+
+        Parse actions can also completely replace the given tokens, with another ``ParseResults``
+        object, or with some entirely different object (common for parse actions that perform data
+        conversions). A convenient way to build a new parse result is to define the values
+        using a dict, and then create the return value using :class:`ParseResults.from_dict`.
+
+        If None is passed as the ``fn`` parse action, all previously added parse actions for this
+        expression are cleared.
+
+        Optional keyword arguments:
+
+        - call_during_try = (default= ``False``) indicate if parse action should be run during
+          lookaheads and alternate testing. For parse actions that have side effects, it is
+          important to only call the parse action once it is determined that it is being
+          called as part of a successful parse. For parse actions that perform additional
+          validation, then call_during_try should be passed as True, so that the validation
+          code is included in the preliminary "try" parses.
+
+        Note: the default parsing behavior is to expand tabs in the input string
+        before starting the parsing process.  See :class:`parse_string` for more
+        information on parsing strings containing ``<TAB>`` s, and suggested
+        methods to maintain a consistent view of the parsed string, the parse
+        location, and line and column positions within the parsed string.
+
+        Example::
+
+            # parse dates in the form YYYY/MM/DD
+
+            # use parse action to convert toks from str to int at parse time
+            def convert_to_int(toks):
+                return int(toks[0])
+
+            # use a parse action to verify that the date is a valid date
+            def is_valid_date(instring, loc, toks):
+                from datetime import date
+                year, month, day = toks[::2]
+                try:
+                    date(year, month, day)
+                except ValueError:
+                    raise ParseException(instring, loc, "invalid date given")
+
+            integer = Word(nums)
+            date_str = integer + '/' + integer + '/' + integer
+
+            # add parse actions
+            integer.set_parse_action(convert_to_int)
+            date_str.set_parse_action(is_valid_date)
+
+            # note that integer fields are now ints, not strings
+            date_str.run_tests('''
+                # successful parse - note that integer fields were converted to ints
+                1999/12/31
+
+                # fail - invalid date
+                1999/13/31
+                ''')
+        """
+        if list(fns) == [None]:
+            self.parseAction = []
+        else:
+            if not all(callable(fn) for fn in fns):
+                raise TypeError("parse actions must be callable")
+            self.parseAction = [_trim_arity(fn) for fn in fns]
+            self.callDuringTry = kwargs.get(
+                "call_during_try", kwargs.get("callDuringTry", False)
+            )
+        return self
+
+    def add_parse_action(self, *fns: ParseAction, **kwargs) -> "ParserElement":
+        """
+        Add one or more parse actions to expression's list of parse actions. See :class:`set_parse_action`.
+
+        See examples in :class:`copy`.
+        """
+        self.parseAction += [_trim_arity(fn) for fn in fns]
+        self.callDuringTry = self.callDuringTry or kwargs.get(
+            "call_during_try", kwargs.get("callDuringTry", False)
+        )
+        return self
+
+    def add_condition(self, *fns: ParseCondition, **kwargs) -> "ParserElement":
+        """Add a boolean predicate function to expression's list of parse actions. See
+        :class:`set_parse_action` for function call signatures. Unlike ``set_parse_action``,
+        functions passed to ``add_condition`` need to return boolean success/fail of the condition.
+
+        Optional keyword arguments:
+
+        - message = define a custom message to be used in the raised exception
+        - fatal = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise
+          ParseException
+        - call_during_try = boolean to indicate if this method should be called during internal tryParse calls,
+          default=False
+
+        Example::
+
+            integer = Word(nums).set_parse_action(lambda toks: int(toks[0]))
+            year_int = integer.copy()
+            year_int.add_condition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later")
+            date_str = year_int + '/' + integer + '/' + integer
+
+            result = date_str.parse_string("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0),
+                                                                         (line:1, col:1)
+        """
+        for fn in fns:
+            self.parseAction.append(
+                condition_as_parse_action(
+                    fn, message=kwargs.get("message"), fatal=kwargs.get("fatal", False)
+                )
+            )
+
+        self.callDuringTry = self.callDuringTry or kwargs.get(
+            "call_during_try", kwargs.get("callDuringTry", False)
+        )
+        return self
+
+    def set_fail_action(self, fn: ParseFailAction) -> "ParserElement":
+        """
+        Define action to perform if parsing fails at this expression.
+        Fail acton fn is a callable function that takes the arguments
+        ``fn(s, loc, expr, err)`` where:
+
+        - s = string being parsed
+        - loc = location where expression match was attempted and failed
+        - expr = the parse expression that failed
+        - err = the exception thrown
+
+        The function returns no value.  It may throw :class:`ParseFatalException`
+        if it is desired to stop parsing immediately."""
+        self.failAction = fn
+        return self
+
+    def _skipIgnorables(self, instring, loc):
+        exprsFound = True
+        while exprsFound:
+            exprsFound = False
+            for e in self.ignoreExprs:
+                try:
+                    while 1:
+                        loc, dummy = e._parse(instring, loc)
+                        exprsFound = True
+                except ParseException:
+                    pass
+        return loc
+
+    def preParse(self, instring, loc):
+        if self.ignoreExprs:
+            loc = self._skipIgnorables(instring, loc)
+
+        if self.skipWhitespace:
+            instrlen = len(instring)
+            white_chars = self.whiteChars
+            while loc < instrlen and instring[loc] in white_chars:
+                loc += 1
+
+        return loc
+
+    def parseImpl(self, instring, loc, doActions=True):
+        return loc, []
+
+    def postParse(self, instring, loc, tokenlist):
+        return tokenlist
+
+    # @profile
+    def _parseNoCache(
+        self, instring, loc, doActions=True, callPreParse=True
+    ) -> Tuple[int, ParseResults]:
+        TRY, MATCH, FAIL = 0, 1, 2
+        debugging = self.debug  # and doActions)
+        len_instring = len(instring)
+
+        if debugging or self.failAction:
+            # print("Match {} at loc {}({}, {})".format(self, loc, lineno(loc, instring), col(loc, instring)))
+            try:
+                if callPreParse and self.callPreparse:
+                    pre_loc = self.preParse(instring, loc)
+                else:
+                    pre_loc = loc
+                tokens_start = pre_loc
+                if self.debugActions.debug_try:
+                    self.debugActions.debug_try(instring, tokens_start, self, False)
+                if self.mayIndexError or pre_loc >= len_instring:
+                    try:
+                        loc, tokens = self.parseImpl(instring, pre_loc, doActions)
+                    except IndexError:
+                        raise ParseException(instring, len_instring, self.errmsg, self)
+                else:
+                    loc, tokens = self.parseImpl(instring, pre_loc, doActions)
+            except Exception as err:
+                # print("Exception raised:", err)
+                if self.debugActions.debug_fail:
+                    self.debugActions.debug_fail(
+                        instring, tokens_start, self, err, False
+                    )
+                if self.failAction:
+                    self.failAction(instring, tokens_start, self, err)
+                raise
+        else:
+            if callPreParse and self.callPreparse:
+                pre_loc = self.preParse(instring, loc)
+            else:
+                pre_loc = loc
+            tokens_start = pre_loc
+            if self.mayIndexError or pre_loc >= len_instring:
+                try:
+                    loc, tokens = self.parseImpl(instring, pre_loc, doActions)
+                except IndexError:
+                    raise ParseException(instring, len_instring, self.errmsg, self)
+            else:
+                loc, tokens = self.parseImpl(instring, pre_loc, doActions)
+
+        tokens = self.postParse(instring, loc, tokens)
+
+        ret_tokens = ParseResults(
+            tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults
+        )
+        if self.parseAction and (doActions or self.callDuringTry):
+            if debugging:
+                try:
+                    for fn in self.parseAction:
+                        try:
+                            tokens = fn(instring, tokens_start, ret_tokens)
+                        except IndexError as parse_action_exc:
+                            exc = ParseException("exception raised in parse action")
+                            raise exc from parse_action_exc
+
+                        if tokens is not None and tokens is not ret_tokens:
+                            ret_tokens = ParseResults(
+                                tokens,
+                                self.resultsName,
+                                asList=self.saveAsList
+                                and isinstance(tokens, (ParseResults, list)),
+                                modal=self.modalResults,
+                            )
+                except Exception as err:
+                    # print "Exception raised in user parse action:", err
+                    if self.debugActions.debug_fail:
+                        self.debugActions.debug_fail(
+                            instring, tokens_start, self, err, False
+                        )
+                    raise
+            else:
+                for fn in self.parseAction:
+                    try:
+                        tokens = fn(instring, tokens_start, ret_tokens)
+                    except IndexError as parse_action_exc:
+                        exc = ParseException("exception raised in parse action")
+                        raise exc from parse_action_exc
+
+                    if tokens is not None and tokens is not ret_tokens:
+                        ret_tokens = ParseResults(
+                            tokens,
+                            self.resultsName,
+                            asList=self.saveAsList
+                            and isinstance(tokens, (ParseResults, list)),
+                            modal=self.modalResults,
+                        )
+        if debugging:
+            # print("Matched", self, "->", ret_tokens.as_list())
+            if self.debugActions.debug_match:
+                self.debugActions.debug_match(
+                    instring, tokens_start, loc, self, ret_tokens, False
+                )
+
+        return loc, ret_tokens
+
+    def try_parse(self, instring: str, loc: int, raise_fatal: bool = False) -> int:
+        try:
+            return self._parse(instring, loc, doActions=False)[0]
+        except ParseFatalException:
+            if raise_fatal:
+                raise
+            raise ParseException(instring, loc, self.errmsg, self)
+
+    def can_parse_next(self, instring: str, loc: int) -> bool:
+        try:
+            self.try_parse(instring, loc)
+        except (ParseException, IndexError):
+            return False
+        else:
+            return True
+
+    # cache for left-recursion in Forward references
+    recursion_lock = RLock()
+    recursion_memos: typing.Dict[
+        Tuple[int, "Forward", bool], Tuple[int, Union[ParseResults, Exception]]
+    ] = {}
+
+    # argument cache for optimizing repeated calls when backtracking through recursive expressions
+    packrat_cache = (
+        {}
+    )  # this is set later by enabled_packrat(); this is here so that reset_cache() doesn't fail
+    packrat_cache_lock = RLock()
+    packrat_cache_stats = [0, 0]
+
+    # this method gets repeatedly called during backtracking with the same arguments -
+    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression
+    def _parseCache(
+        self, instring, loc, doActions=True, callPreParse=True
+    ) -> Tuple[int, ParseResults]:
+        HIT, MISS = 0, 1
+        TRY, MATCH, FAIL = 0, 1, 2
+        lookup = (self, instring, loc, callPreParse, doActions)
+        with ParserElement.packrat_cache_lock:
+            cache = ParserElement.packrat_cache
+            value = cache.get(lookup)
+            if value is cache.not_in_cache:
+                ParserElement.packrat_cache_stats[MISS] += 1
+                try:
+                    value = self._parseNoCache(instring, loc, doActions, callPreParse)
+                except ParseBaseException as pe:
+                    # cache a copy of the exception, without the traceback
+                    cache.set(lookup, pe.__class__(*pe.args))
+                    raise
+                else:
+                    cache.set(lookup, (value[0], value[1].copy(), loc))
+                    return value
+            else:
+                ParserElement.packrat_cache_stats[HIT] += 1
+                if self.debug and self.debugActions.debug_try:
+                    try:
+                        self.debugActions.debug_try(instring, loc, self, cache_hit=True)
+                    except TypeError:
+                        pass
+                if isinstance(value, Exception):
+                    if self.debug and self.debugActions.debug_fail:
+                        try:
+                            self.debugActions.debug_fail(
+                                instring, loc, self, value, cache_hit=True
+                            )
+                        except TypeError:
+                            pass
+                    raise value
+
+                loc_, result, endloc = value[0], value[1].copy(), value[2]
+                if self.debug and self.debugActions.debug_match:
+                    try:
+                        self.debugActions.debug_match(
+                            instring, loc_, endloc, self, result, cache_hit=True
+                        )
+                    except TypeError:
+                        pass
+
+                return loc_, result
+
+    _parse = _parseNoCache
+
+    @staticmethod
+    def reset_cache() -> None:
+        ParserElement.packrat_cache.clear()
+        ParserElement.packrat_cache_stats[:] = [0] * len(
+            ParserElement.packrat_cache_stats
+        )
+        ParserElement.recursion_memos.clear()
+
+    _packratEnabled = False
+    _left_recursion_enabled = False
+
+    @staticmethod
+    def disable_memoization() -> None:
+        """
+        Disables active Packrat or Left Recursion parsing and their memoization
+
+        This method also works if neither Packrat nor Left Recursion are enabled.
+        This makes it safe to call before activating Packrat nor Left Recursion
+        to clear any previous settings.
+        """
+        ParserElement.reset_cache()
+        ParserElement._left_recursion_enabled = False
+        ParserElement._packratEnabled = False
+        ParserElement._parse = ParserElement._parseNoCache
+
+    @staticmethod
+    def enable_left_recursion(
+        cache_size_limit: typing.Optional[int] = None, *, force=False
+    ) -> None:
+        """
+        Enables "bounded recursion" parsing, which allows for both direct and indirect
+        left-recursion. During parsing, left-recursive :class:`Forward` elements are
+        repeatedly matched with a fixed recursion depth that is gradually increased
+        until finding the longest match.
+
+        Example::
+
+            import pyparsing as pp
+            pp.ParserElement.enable_left_recursion()
+
+            E = pp.Forward("E")
+            num = pp.Word(pp.nums)
+            # match `num`, or `num '+' num`, or `num '+' num '+' num`, ...
+            E <<= E + '+' - num | num
+
+            print(E.parse_string("1+2+3"))
+
+        Recursion search naturally memoizes matches of ``Forward`` elements and may
+        thus skip reevaluation of parse actions during backtracking. This may break
+        programs with parse actions which rely on strict ordering of side-effects.
+
+        Parameters:
+
+        - cache_size_limit - (default=``None``) - memoize at most this many
+          ``Forward`` elements during matching; if ``None`` (the default),
+          memoize all ``Forward`` elements.
+
+        Bounded Recursion parsing works similar but not identical to Packrat parsing,
+        thus the two cannot be used together. Use ``force=True`` to disable any
+        previous, conflicting settings.
+        """
+        if force:
+            ParserElement.disable_memoization()
+        elif ParserElement._packratEnabled:
+            raise RuntimeError("Packrat and Bounded Recursion are not compatible")
+        if cache_size_limit is None:
+            ParserElement.recursion_memos = _UnboundedMemo()
+        elif cache_size_limit > 0:
+            ParserElement.recursion_memos = _LRUMemo(capacity=cache_size_limit)
+        else:
+            raise NotImplementedError("Memo size of %s" % cache_size_limit)
+        ParserElement._left_recursion_enabled = True
+
+    @staticmethod
+    def enable_packrat(cache_size_limit: int = 128, *, force: bool = False) -> None:
+        """
+        Enables "packrat" parsing, which adds memoizing to the parsing logic.
+        Repeated parse attempts at the same string location (which happens
+        often in many complex grammars) can immediately return a cached value,
+        instead of re-executing parsing/validating code.  Memoizing is done of
+        both valid results and parsing exceptions.
+
+        Parameters:
+
+        - cache_size_limit - (default= ``128``) - if an integer value is provided
+          will limit the size of the packrat cache; if None is passed, then
+          the cache size will be unbounded; if 0 is passed, the cache will
+          be effectively disabled.
+
+        This speedup may break existing programs that use parse actions that
+        have side-effects.  For this reason, packrat parsing is disabled when
+        you first import pyparsing.  To activate the packrat feature, your
+        program must call the class method :class:`ParserElement.enable_packrat`.
+        For best results, call ``enable_packrat()`` immediately after
+        importing pyparsing.
+
+        Example::
+
+            import pyparsing
+            pyparsing.ParserElement.enable_packrat()
+
+        Packrat parsing works similar but not identical to Bounded Recursion parsing,
+        thus the two cannot be used together. Use ``force=True`` to disable any
+        previous, conflicting settings.
+        """
+        if force:
+            ParserElement.disable_memoization()
+        elif ParserElement._left_recursion_enabled:
+            raise RuntimeError("Packrat and Bounded Recursion are not compatible")
+        if not ParserElement._packratEnabled:
+            ParserElement._packratEnabled = True
+            if cache_size_limit is None:
+                ParserElement.packrat_cache = _UnboundedCache()
+            else:
+                ParserElement.packrat_cache = _FifoCache(cache_size_limit)
+            ParserElement._parse = ParserElement._parseCache
+
+    def parse_string(
+        self, instring: str, parse_all: bool = False, *, parseAll: bool = False
+    ) -> ParseResults:
+        """
+        Parse a string with respect to the parser definition. This function is intended as the primary interface to the
+        client code.
+
+        :param instring: The input string to be parsed.
+        :param parse_all: If set, the entire input string must match the grammar.
+        :param parseAll: retained for pre-PEP8 compatibility, will be removed in a future release.
+        :raises ParseException: Raised if ``parse_all`` is set and the input string does not match the whole grammar.
+        :returns: the parsed data as a :class:`ParseResults` object, which may be accessed as a `list`, a `dict`, or
+          an object with attributes if the given parser includes results names.
+
+        If the input string is required to match the entire grammar, ``parse_all`` flag must be set to ``True``. This
+        is also equivalent to ending the grammar with :class:`StringEnd`().
+
+        To report proper column numbers, ``parse_string`` operates on a copy of the input string where all tabs are
+        converted to spaces (8 spaces per tab, as per the default in ``string.expandtabs``). If the input string
+        contains tabs and the grammar uses parse actions that use the ``loc`` argument to index into the string
+        being parsed, one can ensure a consistent view of the input string by doing one of the following:
+
+        - calling ``parse_with_tabs`` on your grammar before calling ``parse_string`` (see :class:`parse_with_tabs`),
+        - define your parse action using the full ``(s,loc,toks)`` signature, and reference the input string using the
+          parse action's ``s`` argument, or
+        - explicitly expand the tabs in your input string before calling ``parse_string``.
+
+        Examples:
+
+        By default, partial matches are OK.
+
+        >>> res = Word('a').parse_string('aaaaabaaa')
+        >>> print(res)
+        ['aaaaa']
+
+        The parsing behavior varies by the inheriting class of this abstract class. Please refer to the children
+        directly to see more examples.
+
+        It raises an exception if parse_all flag is set and instring does not match the whole grammar.
+
+        >>> res = Word('a').parse_string('aaaaabaaa', parse_all=True)
+        Traceback (most recent call last):
+        ...
+        pyparsing.ParseException: Expected end of text, found 'b'  (at char 5), (line:1, col:6)
+        """
+        parseAll = parse_all or parseAll
+
+        ParserElement.reset_cache()
+        if not self.streamlined:
+            self.streamline()
+        for e in self.ignoreExprs:
+            e.streamline()
+        if not self.keepTabs:
+            instring = instring.expandtabs()
+        try:
+            loc, tokens = self._parse(instring, 0)
+            if parseAll:
+                loc = self.preParse(instring, loc)
+                se = Empty() + StringEnd()
+                se._parse(instring, loc)
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clearing out pyparsing internal stack trace
+                raise exc.with_traceback(None)
+        else:
+            return tokens
+
+    def scan_string(
+        self,
+        instring: str,
+        max_matches: int = _MAX_INT,
+        overlap: bool = False,
+        *,
+        debug: bool = False,
+        maxMatches: int = _MAX_INT,
+    ) -> Generator[Tuple[ParseResults, int, int], None, None]:
+        """
+        Scan the input string for expression matches.  Each match will return the
+        matching tokens, start location, and end location.  May be called with optional
+        ``max_matches`` argument, to clip scanning after 'n' matches are found.  If
+        ``overlap`` is specified, then overlapping matches will be reported.
+
+        Note that the start and end locations are reported relative to the string
+        being parsed.  See :class:`parse_string` for more information on parsing
+        strings with embedded tabs.
+
+        Example::
+
+            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987"
+            print(source)
+            for tokens, start, end in Word(alphas).scan_string(source):
+                print(' '*start + '^'*(end-start))
+                print(' '*start + tokens[0])
+
+        prints::
+
+            sldjf123lsdjjkf345sldkjf879lkjsfd987
+            ^^^^^
+            sldjf
+                    ^^^^^^^
+                    lsdjjkf
+                              ^^^^^^
+                              sldkjf
+                                       ^^^^^^
+                                       lkjsfd
+        """
+        maxMatches = min(maxMatches, max_matches)
+        if not self.streamlined:
+            self.streamline()
+        for e in self.ignoreExprs:
+            e.streamline()
+
+        if not self.keepTabs:
+            instring = str(instring).expandtabs()
+        instrlen = len(instring)
+        loc = 0
+        preparseFn = self.preParse
+        parseFn = self._parse
+        ParserElement.resetCache()
+        matches = 0
+        try:
+            while loc <= instrlen and matches < maxMatches:
+                try:
+                    preloc = preparseFn(instring, loc)
+                    nextLoc, tokens = parseFn(instring, preloc, callPreParse=False)
+                except ParseException:
+                    loc = preloc + 1
+                else:
+                    if nextLoc > loc:
+                        matches += 1
+                        if debug:
+                            print(
+                                {
+                                    "tokens": tokens.asList(),
+                                    "start": preloc,
+                                    "end": nextLoc,
+                                }
+                            )
+                        yield tokens, preloc, nextLoc
+                        if overlap:
+                            nextloc = preparseFn(instring, loc)
+                            if nextloc > loc:
+                                loc = nextLoc
+                            else:
+                                loc += 1
+                        else:
+                            loc = nextLoc
+                    else:
+                        loc = preloc + 1
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc.with_traceback(None)
+
+    def transform_string(self, instring: str, *, debug: bool = False) -> str:
+        """
+        Extension to :class:`scan_string`, to modify matching text with modified tokens that may
+        be returned from a parse action.  To use ``transform_string``, define a grammar and
+        attach a parse action to it that modifies the returned token list.
+        Invoking ``transform_string()`` on a target string will then scan for matches,
+        and replace the matched text patterns according to the logic in the parse
+        action.  ``transform_string()`` returns the resulting transformed string.
+
+        Example::
+
+            wd = Word(alphas)
+            wd.set_parse_action(lambda toks: toks[0].title())
+
+            print(wd.transform_string("now is the winter of our discontent made glorious summer by this sun of york."))
+
+        prints::
+
+            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York.
+        """
+        out: List[str] = []
+        lastE = 0
+        # force preservation of <TAB>s, to minimize unwanted transformation of string, and to
+        # keep string locs straight between transform_string and scan_string
+        self.keepTabs = True
+        try:
+            for t, s, e in self.scan_string(instring, debug=debug):
+                out.append(instring[lastE:s])
+                if t:
+                    if isinstance(t, ParseResults):
+                        out += t.as_list()
+                    elif isinstance(t, Iterable) and not isinstance(t, str_type):
+                        out.extend(t)
+                    else:
+                        out.append(t)
+                lastE = e
+            out.append(instring[lastE:])
+            out = [o for o in out if o]
+            return "".join([str(s) for s in _flatten(out)])
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc.with_traceback(None)
+
+    def search_string(
+        self,
+        instring: str,
+        max_matches: int = _MAX_INT,
+        *,
+        debug: bool = False,
+        maxMatches: int = _MAX_INT,
+    ) -> ParseResults:
+        """
+        Another extension to :class:`scan_string`, simplifying the access to the tokens found
+        to match the given parse expression.  May be called with optional
+        ``max_matches`` argument, to clip searching after 'n' matches are found.
+
+        Example::
+
+            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters
+            cap_word = Word(alphas.upper(), alphas.lower())
+
+            print(cap_word.search_string("More than Iron, more than Lead, more than Gold I need Electricity"))
+
+            # the sum() builtin can be used to merge results into a single ParseResults object
+            print(sum(cap_word.search_string("More than Iron, more than Lead, more than Gold I need Electricity")))
+
+        prints::
+
+            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']]
+            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity']
+        """
+        maxMatches = min(maxMatches, max_matches)
+        try:
+            return ParseResults(
+                [t for t, s, e in self.scan_string(instring, maxMatches, debug=debug)]
+            )
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc.with_traceback(None)
+
+    def split(
+        self,
+        instring: str,
+        maxsplit: int = _MAX_INT,
+        include_separators: bool = False,
+        *,
+        includeSeparators=False,
+    ) -> Generator[str, None, None]:
+        """
+        Generator method to split a string using the given expression as a separator.
+        May be called with optional ``maxsplit`` argument, to limit the number of splits;
+        and the optional ``include_separators`` argument (default= ``False``), if the separating
+        matching text should be included in the split results.
+
+        Example::
+
+            punc = one_of(list(".,;:/-!?"))
+            print(list(punc.split("This, this?, this sentence, is badly punctuated!")))
+
+        prints::
+
+            ['This', ' this', '', ' this sentence', ' is badly punctuated', '']
+        """
+        includeSeparators = includeSeparators or include_separators
+        last = 0
+        for t, s, e in self.scan_string(instring, max_matches=maxsplit):
+            yield instring[last:s]
+            if includeSeparators:
+                yield t[0]
+            last = e
+        yield instring[last:]
+
+    def __add__(self, other) -> "ParserElement":
+        """
+        Implementation of ``+`` operator - returns :class:`And`. Adding strings to a :class:`ParserElement`
+        converts them to :class:`Literal`s by default.
+
+        Example::
+
+            greet = Word(alphas) + "," + Word(alphas) + "!"
+            hello = "Hello, World!"
+            print(hello, "->", greet.parse_string(hello))
+
+        prints::
+
+            Hello, World! -> ['Hello', ',', 'World', '!']
+
+        ``...`` may be used as a parse expression as a short form of :class:`SkipTo`.
+
+            Literal('start') + ... + Literal('end')
+
+        is equivalent to:
+
+            Literal('start') + SkipTo('end')("_skipped*") + Literal('end')
+
+        Note that the skipped text is returned with '_skipped' as a results name,
+        and to support having multiple skips in the same parser, the value returned is
+        a list of all skipped text.
+        """
+        if other is Ellipsis:
+            return _PendingSkip(self)
+
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            raise TypeError(
+                "Cannot combine element of type {} with ParserElement".format(
+                    type(other).__name__
+                )
+            )
+        return And([self, other])
+
+    def __radd__(self, other) -> "ParserElement":
+        """
+        Implementation of ``+`` operator when left operand is not a :class:`ParserElement`
+        """
+        if other is Ellipsis:
+            return SkipTo(self)("_skipped*") + self
+
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            raise TypeError(
+                "Cannot combine element of type {} with ParserElement".format(
+                    type(other).__name__
+                )
+            )
+        return other + self
+
+    def __sub__(self, other) -> "ParserElement":
+        """
+        Implementation of ``-`` operator, returns :class:`And` with error stop
+        """
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            raise TypeError(
+                "Cannot combine element of type {} with ParserElement".format(
+                    type(other).__name__
+                )
+            )
+        return self + And._ErrorStop() + other
+
+    def __rsub__(self, other) -> "ParserElement":
+        """
+        Implementation of ``-`` operator when left operand is not a :class:`ParserElement`
+        """
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            raise TypeError(
+                "Cannot combine element of type {} with ParserElement".format(
+                    type(other).__name__
+                )
+            )
+        return other - self
+
+    def __mul__(self, other) -> "ParserElement":
+        """
+        Implementation of ``*`` operator, allows use of ``expr * 3`` in place of
+        ``expr + expr + expr``.  Expressions may also be multiplied by a 2-integer
+        tuple, similar to ``{min, max}`` multipliers in regular expressions.  Tuples
+        may also include ``None`` as in:
+        - ``expr*(n, None)`` or ``expr*(n, )`` is equivalent
+             to ``expr*n + ZeroOrMore(expr)``
+             (read as "at least n instances of ``expr``")
+        - ``expr*(None, n)`` is equivalent to ``expr*(0, n)``
+             (read as "0 to n instances of ``expr``")
+        - ``expr*(None, None)`` is equivalent to ``ZeroOrMore(expr)``
+        - ``expr*(1, None)`` is equivalent to ``OneOrMore(expr)``
+
+        Note that ``expr*(None, n)`` does not raise an exception if
+        more than n exprs exist in the input stream; that is,
+        ``expr*(None, n)`` does not enforce a maximum number of expr
+        occurrences.  If this behavior is desired, then write
+        ``expr*(None, n) + ~expr``
+        """
+        if other is Ellipsis:
+            other = (0, None)
+        elif isinstance(other, tuple) and other[:1] == (Ellipsis,):
+            other = ((0,) + other[1:] + (None,))[:2]
+
+        if isinstance(other, int):
+            minElements, optElements = other, 0
+        elif isinstance(other, tuple):
+            other = tuple(o if o is not Ellipsis else None for o in other)
+            other = (other + (None, None))[:2]
+            if other[0] is None:
+                other = (0, other[1])
+            if isinstance(other[0], int) and other[1] is None:
+                if other[0] == 0:
+                    return ZeroOrMore(self)
+                if other[0] == 1:
+                    return OneOrMore(self)
+                else:
+                    return self * other[0] + ZeroOrMore(self)
+            elif isinstance(other[0], int) and isinstance(other[1], int):
+                minElements, optElements = other
+                optElements -= minElements
+            else:
+                raise TypeError(
+                    "cannot multiply ParserElement and ({}) objects".format(
+                        ",".join(type(item).__name__ for item in other)
+                    )
+                )
+        else:
+            raise TypeError(
+                "cannot multiply ParserElement and {} objects".format(
+                    type(other).__name__
+                )
+            )
+
+        if minElements < 0:
+            raise ValueError("cannot multiply ParserElement by negative value")
+        if optElements < 0:
+            raise ValueError(
+                "second tuple value must be greater or equal to first tuple value"
+            )
+        if minElements == optElements == 0:
+            return And([])
+
+        if optElements:
+
+            def makeOptionalList(n):
+                if n > 1:
+                    return Opt(self + makeOptionalList(n - 1))
+                else:
+                    return Opt(self)
+
+            if minElements:
+                if minElements == 1:
+                    ret = self + makeOptionalList(optElements)
+                else:
+                    ret = And([self] * minElements) + makeOptionalList(optElements)
+            else:
+                ret = makeOptionalList(optElements)
+        else:
+            if minElements == 1:
+                ret = self
+            else:
+                ret = And([self] * minElements)
+        return ret
+
+    def __rmul__(self, other) -> "ParserElement":
+        return self.__mul__(other)
+
+    def __or__(self, other) -> "ParserElement":
+        """
+        Implementation of ``|`` operator - returns :class:`MatchFirst`
+        """
+        if other is Ellipsis:
+            return _PendingSkip(self, must_skip=True)
+
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            raise TypeError(
+                "Cannot combine element of type {} with ParserElement".format(
+                    type(other).__name__
+                )
+            )
+        return MatchFirst([self, other])
+
+    def __ror__(self, other) -> "ParserElement":
+        """
+        Implementation of ``|`` operator when left operand is not a :class:`ParserElement`
+        """
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            raise TypeError(
+                "Cannot combine element of type {} with ParserElement".format(
+                    type(other).__name__
+                )
+            )
+        return other | self
+
+    def __xor__(self, other) -> "ParserElement":
+        """
+        Implementation of ``^`` operator - returns :class:`Or`
+        """
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            raise TypeError(
+                "Cannot combine element of type {} with ParserElement".format(
+                    type(other).__name__
+                )
+            )
+        return Or([self, other])
+
+    def __rxor__(self, other) -> "ParserElement":
+        """
+        Implementation of ``^`` operator when left operand is not a :class:`ParserElement`
+        """
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            raise TypeError(
+                "Cannot combine element of type {} with ParserElement".format(
+                    type(other).__name__
+                )
+            )
+        return other ^ self
+
+    def __and__(self, other) -> "ParserElement":
+        """
+        Implementation of ``&`` operator - returns :class:`Each`
+        """
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            raise TypeError(
+                "Cannot combine element of type {} with ParserElement".format(
+                    type(other).__name__
+                )
+            )
+        return Each([self, other])
+
+    def __rand__(self, other) -> "ParserElement":
+        """
+        Implementation of ``&`` operator when left operand is not a :class:`ParserElement`
+        """
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        if not isinstance(other, ParserElement):
+            raise TypeError(
+                "Cannot combine element of type {} with ParserElement".format(
+                    type(other).__name__
+                )
+            )
+        return other & self
+
+    def __invert__(self) -> "ParserElement":
+        """
+        Implementation of ``~`` operator - returns :class:`NotAny`
+        """
+        return NotAny(self)
+
+    # disable __iter__ to override legacy use of sequential access to __getitem__ to
+    # iterate over a sequence
+    __iter__ = None
+
+    def __getitem__(self, key):
+        """
+        use ``[]`` indexing notation as a short form for expression repetition:
+
+        - ``expr[n]`` is equivalent to ``expr*n``
+        - ``expr[m, n]`` is equivalent to ``expr*(m, n)``
+        - ``expr[n, ...]`` or ``expr[n,]`` is equivalent
+             to ``expr*n + ZeroOrMore(expr)``
+             (read as "at least n instances of ``expr``")
+        - ``expr[..., n]`` is equivalent to ``expr*(0, n)``
+             (read as "0 to n instances of ``expr``")
+        - ``expr[...]`` and ``expr[0, ...]`` are equivalent to ``ZeroOrMore(expr)``
+        - ``expr[1, ...]`` is equivalent to ``OneOrMore(expr)``
+
+        ``None`` may be used in place of ``...``.
+
+        Note that ``expr[..., n]`` and ``expr[m, n]``do not raise an exception
+        if more than ``n`` ``expr``s exist in the input stream.  If this behavior is
+        desired, then write ``expr[..., n] + ~expr``.
+        """
+
+        # convert single arg keys to tuples
+        try:
+            if isinstance(key, str_type):
+                key = (key,)
+            iter(key)
+        except TypeError:
+            key = (key, key)
+
+        if len(key) > 2:
+            raise TypeError(
+                "only 1 or 2 index arguments supported ({}{})".format(
+                    key[:5], "... [{}]".format(len(key)) if len(key) > 5 else ""
+                )
+            )
+
+        # clip to 2 elements
+        ret = self * tuple(key[:2])
+        return ret
+
+    def __call__(self, name: str = None) -> "ParserElement":
+        """
+        Shortcut for :class:`set_results_name`, with ``list_all_matches=False``.
+
+        If ``name`` is given with a trailing ``'*'`` character, then ``list_all_matches`` will be
+        passed as ``True``.
+
+        If ``name` is omitted, same as calling :class:`copy`.
+
+        Example::
+
+            # these are equivalent
+            userdata = Word(alphas).set_results_name("name") + Word(nums + "-").set_results_name("socsecno")
+            userdata = Word(alphas)("name") + Word(nums + "-")("socsecno")
+        """
+        if name is not None:
+            return self._setResultsName(name)
+        else:
+            return self.copy()
+
+    def suppress(self) -> "ParserElement":
+        """
+        Suppresses the output of this :class:`ParserElement`; useful to keep punctuation from
+        cluttering up returned output.
+        """
+        return Suppress(self)
+
+    def ignore_whitespace(self, recursive: bool = True) -> "ParserElement":
+        """
+        Enables the skipping of whitespace before matching the characters in the
+        :class:`ParserElement`'s defined pattern.
+
+        :param recursive: If ``True`` (the default), also enable whitespace skipping in child elements (if any)
+        """
+        self.skipWhitespace = True
+        return self
+
+    def leave_whitespace(self, recursive: bool = True) -> "ParserElement":
+        """
+        Disables the skipping of whitespace before matching the characters in the
+        :class:`ParserElement`'s defined pattern.  This is normally only used internally by
+        the pyparsing module, but may be needed in some whitespace-sensitive grammars.
+
+        :param recursive: If true (the default), also disable whitespace skipping in child elements (if any)
+        """
+        self.skipWhitespace = False
+        return self
+
+    def set_whitespace_chars(
+        self, chars: Union[Set[str], str], copy_defaults: bool = False
+    ) -> "ParserElement":
+        """
+        Overrides the default whitespace chars
+        """
+        self.skipWhitespace = True
+        self.whiteChars = set(chars)
+        self.copyDefaultWhiteChars = copy_defaults
+        return self
+
+    def parse_with_tabs(self) -> "ParserElement":
+        """
+        Overrides default behavior to expand ``<TAB>`` s to spaces before parsing the input string.
+        Must be called before ``parse_string`` when the input grammar contains elements that
+        match ``<TAB>`` characters.
+        """
+        self.keepTabs = True
+        return self
+
+    def ignore(self, other: "ParserElement") -> "ParserElement":
+        """
+        Define expression to be ignored (e.g., comments) while doing pattern
+        matching; may be called repeatedly, to define multiple comment or other
+        ignorable patterns.
+
+        Example::
+
+            patt = Word(alphas)[1, ...]
+            patt.parse_string('ablaj /* comment */ lskjd')
+            # -> ['ablaj']
+
+            patt.ignore(c_style_comment)
+            patt.parse_string('ablaj /* comment */ lskjd')
+            # -> ['ablaj', 'lskjd']
+        """
+        import typing
+
+        if isinstance(other, str_type):
+            other = Suppress(other)
+
+        if isinstance(other, Suppress):
+            if other not in self.ignoreExprs:
+                self.ignoreExprs.append(other)
+        else:
+            self.ignoreExprs.append(Suppress(other.copy()))
+        return self
+
+    def set_debug_actions(
+        self,
+        start_action: DebugStartAction,
+        success_action: DebugSuccessAction,
+        exception_action: DebugExceptionAction,
+    ) -> "ParserElement":
+        """
+        Customize display of debugging messages while doing pattern matching:
+
+        - ``start_action`` - method to be called when an expression is about to be parsed;
+          should have the signature ``fn(input_string: str, location: int, expression: ParserElement, cache_hit: bool)``
+
+        - ``success_action`` - method to be called when an expression has successfully parsed;
+          should have the signature ``fn(input_string: str, start_location: int, end_location: int, expression: ParserELement, parsed_tokens: ParseResults, cache_hit: bool)``
+
+        - ``exception_action`` - method to be called when expression fails to parse;
+          should have the signature ``fn(input_string: str, location: int, expression: ParserElement, exception: Exception, cache_hit: bool)``
+        """
+        self.debugActions = self.DebugActions(
+            start_action or _default_start_debug_action,
+            success_action or _default_success_debug_action,
+            exception_action or _default_exception_debug_action,
+        )
+        self.debug = True
+        return self
+
+    def set_debug(self, flag: bool = True) -> "ParserElement":
+        """
+        Enable display of debugging messages while doing pattern matching.
+        Set ``flag`` to ``True`` to enable, ``False`` to disable.
+
+        Example::
+
+            wd = Word(alphas).set_name("alphaword")
+            integer = Word(nums).set_name("numword")
+            term = wd | integer
+
+            # turn on debugging for wd
+            wd.set_debug()
+
+            term[1, ...].parse_string("abc 123 xyz 890")
+
+        prints::
+
+            Match alphaword at loc 0(1,1)
+            Matched alphaword -> ['abc']
+            Match alphaword at loc 3(1,4)
+            Exception raised:Expected alphaword (at char 4), (line:1, col:5)
+            Match alphaword at loc 7(1,8)
+            Matched alphaword -> ['xyz']
+            Match alphaword at loc 11(1,12)
+            Exception raised:Expected alphaword (at char 12), (line:1, col:13)
+            Match alphaword at loc 15(1,16)
+            Exception raised:Expected alphaword (at char 15), (line:1, col:16)
+
+        The output shown is that produced by the default debug actions - custom debug actions can be
+        specified using :class:`set_debug_actions`. Prior to attempting
+        to match the ``wd`` expression, the debugging message ``"Match <exprname> at loc <n>(<line>,<col>)"``
+        is shown. Then if the parse succeeds, a ``"Matched"`` message is shown, or an ``"Exception raised"``
+        message is shown. Also note the use of :class:`set_name` to assign a human-readable name to the expression,
+        which makes debugging and exception messages easier to understand - for instance, the default
+        name created for the :class:`Word` expression without calling ``set_name`` is ``"W:(A-Za-z)"``.
+        """
+        if flag:
+            self.set_debug_actions(
+                _default_start_debug_action,
+                _default_success_debug_action,
+                _default_exception_debug_action,
+            )
+        else:
+            self.debug = False
+        return self
+
+    @property
+    def default_name(self) -> str:
+        if self._defaultName is None:
+            self._defaultName = self._generateDefaultName()
+        return self._defaultName
+
+    @abstractmethod
+    def _generateDefaultName(self):
+        """
+        Child classes must define this method, which defines how the ``default_name`` is set.
+        """
+
+    def set_name(self, name: str) -> "ParserElement":
+        """
+        Define name for this expression, makes debugging and exception messages clearer.
+        Example::
+            Word(nums).parse_string("ABC")  # -> Exception: Expected W:(0-9) (at char 0), (line:1, col:1)
+            Word(nums).set_name("integer").parse_string("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1)
+        """
+        self.customName = name
+        self.errmsg = "Expected " + self.name
+        if __diag__.enable_debug_on_named_expressions:
+            self.set_debug()
+        return self
+
+    @property
+    def name(self) -> str:
+        # This will use a user-defined name if available, but otherwise defaults back to the auto-generated name
+        return self.customName if self.customName is not None else self.default_name
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def streamline(self) -> "ParserElement":
+        self.streamlined = True
+        self._defaultName = None
+        return self
+
+    def recurse(self) -> Sequence["ParserElement"]:
+        return []
+
+    def _checkRecursion(self, parseElementList):
+        subRecCheckList = parseElementList[:] + [self]
+        for e in self.recurse():
+            e._checkRecursion(subRecCheckList)
+
+    def validate(self, validateTrace=None) -> None:
+        """
+        Check defined expressions for valid structure, check for infinite recursive definitions.
+        """
+        self._checkRecursion([])
+
+    def parse_file(
+        self,
+        file_or_filename: Union[str, Path, TextIO],
+        encoding: str = "utf-8",
+        parse_all: bool = False,
+        *,
+        parseAll: bool = False,
+    ) -> ParseResults:
+        """
+        Execute the parse expression on the given file or filename.
+        If a filename is specified (instead of a file object),
+        the entire file is opened, read, and closed before parsing.
+        """
+        parseAll = parseAll or parse_all
+        try:
+            file_contents = file_or_filename.read()
+        except AttributeError:
+            with open(file_or_filename, "r", encoding=encoding) as f:
+                file_contents = f.read()
+        try:
+            return self.parse_string(file_contents, parseAll)
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc.with_traceback(None)
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif isinstance(other, str_type):
+            return self.matches(other, parse_all=True)
+        elif isinstance(other, ParserElement):
+            return vars(self) == vars(other)
+        return False
+
+    def __hash__(self):
+        return id(self)
+
+    def matches(
+        self, test_string: str, parse_all: bool = True, *, parseAll: bool = True
+    ) -> bool:
+        """
+        Method for quick testing of a parser against a test string. Good for simple
+        inline microtests of sub expressions while building up larger parser.
+
+        Parameters:
+        - ``test_string`` - to test against this expression for a match
+        - ``parse_all`` - (default= ``True``) - flag to pass to :class:`parse_string` when running tests
+
+        Example::
+
+            expr = Word(nums)
+            assert expr.matches("100")
+        """
+        parseAll = parseAll and parse_all
+        try:
+            self.parse_string(str(test_string), parse_all=parseAll)
+            return True
+        except ParseBaseException:
+            return False
+
+    def run_tests(
+        self,
+        tests: Union[str, List[str]],
+        parse_all: bool = True,
+        comment: typing.Optional[Union["ParserElement", str]] = "#",
+        full_dump: bool = True,
+        print_results: bool = True,
+        failure_tests: bool = False,
+        post_parse: Callable[[str, ParseResults], str] = None,
+        file: typing.Optional[TextIO] = None,
+        with_line_numbers: bool = False,
+        *,
+        parseAll: bool = True,
+        fullDump: bool = True,
+        printResults: bool = True,
+        failureTests: bool = False,
+        postParse: Callable[[str, ParseResults], str] = None,
+    ) -> Tuple[bool, List[Tuple[str, Union[ParseResults, Exception]]]]:
+        """
+        Execute the parse expression on a series of test strings, showing each
+        test, the parsed results or where the parse failed. Quick and easy way to
+        run a parse expression against a list of sample strings.
+
+        Parameters:
+        - ``tests`` - a list of separate test strings, or a multiline string of test strings
+        - ``parse_all`` - (default= ``True``) - flag to pass to :class:`parse_string` when running tests
+        - ``comment`` - (default= ``'#'``) - expression for indicating embedded comments in the test
+          string; pass None to disable comment filtering
+        - ``full_dump`` - (default= ``True``) - dump results as list followed by results names in nested outline;
+          if False, only dump nested list
+        - ``print_results`` - (default= ``True``) prints test output to stdout
+        - ``failure_tests`` - (default= ``False``) indicates if these tests are expected to fail parsing
+        - ``post_parse`` - (default= ``None``) optional callback for successful parse results; called as
+          `fn(test_string, parse_results)` and returns a string to be added to the test output
+        - ``file`` - (default= ``None``) optional file-like object to which test output will be written;
+          if None, will default to ``sys.stdout``
+        - ``with_line_numbers`` - default= ``False``) show test strings with line and column numbers
+
+        Returns: a (success, results) tuple, where success indicates that all tests succeeded
+        (or failed if ``failure_tests`` is True), and the results contain a list of lines of each
+        test's output
+
+        Example::
+
+            number_expr = pyparsing_common.number.copy()
+
+            result = number_expr.run_tests('''
+                # unsigned integer
+                100
+                # negative integer
+                -100
+                # float with scientific notation
+                6.02e23
+                # integer with scientific notation
+                1e-12
+                ''')
+            print("Success" if result[0] else "Failed!")
+
+            result = number_expr.run_tests('''
+                # stray character
+                100Z
+                # missing leading digit before '.'
+                -.100
+                # too many '.'
+                3.14.159
+                ''', failure_tests=True)
+            print("Success" if result[0] else "Failed!")
+
+        prints::
+
+            # unsigned integer
+            100
+            [100]
+
+            # negative integer
+            -100
+            [-100]
+
+            # float with scientific notation
+            6.02e23
+            [6.02e+23]
+
+            # integer with scientific notation
+            1e-12
+            [1e-12]
+
+            Success
+
+            # stray character
+            100Z
+               ^
+            FAIL: Expected end of text (at char 3), (line:1, col:4)
+
+            # missing leading digit before '.'
+            -.100
+            ^
+            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1)
+
+            # too many '.'
+            3.14.159
+                ^
+            FAIL: Expected end of text (at char 4), (line:1, col:5)
+
+            Success
+
+        Each test string must be on a single line. If you want to test a string that spans multiple
+        lines, create a test like this::
+
+            expr.run_tests(r"this is a test\\n of strings that spans \\n 3 lines")
+
+        (Note that this is a raw string literal, you must include the leading ``'r'``.)
+        """
+        from .testing import pyparsing_test
+
+        parseAll = parseAll and parse_all
+        fullDump = fullDump and full_dump
+        printResults = printResults and print_results
+        failureTests = failureTests or failure_tests
+        postParse = postParse or post_parse
+        if isinstance(tests, str_type):
+            line_strip = type(tests).strip
+            tests = [line_strip(test_line) for test_line in tests.rstrip().splitlines()]
+        if isinstance(comment, str_type):
+            comment = Literal(comment)
+        if file is None:
+            file = sys.stdout
+        print_ = file.write
+
+        result: Union[ParseResults, Exception]
+        allResults = []
+        comments = []
+        success = True
+        NL = Literal(r"\n").add_parse_action(replace_with("\n")).ignore(quoted_string)
+        BOM = "\ufeff"
+        for t in tests:
+            if comment is not None and comment.matches(t, False) or comments and not t:
+                comments.append(
+                    pyparsing_test.with_line_numbers(t) if with_line_numbers else t
+                )
+                continue
+            if not t:
+                continue
+            out = [
+                "\n" + "\n".join(comments) if comments else "",
+                pyparsing_test.with_line_numbers(t) if with_line_numbers else t,
+            ]
+            comments = []
+            try:
+                # convert newline marks to actual newlines, and strip leading BOM if present
+                t = NL.transform_string(t.lstrip(BOM))
+                result = self.parse_string(t, parse_all=parseAll)
+            except ParseBaseException as pe:
+                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else ""
+                out.append(pe.explain())
+                out.append("FAIL: " + str(pe))
+                if ParserElement.verbose_stacktrace:
+                    out.extend(traceback.format_tb(pe.__traceback__))
+                success = success and failureTests
+                result = pe
+            except Exception as exc:
+                out.append("FAIL-EXCEPTION: {}: {}".format(type(exc).__name__, exc))
+                if ParserElement.verbose_stacktrace:
+                    out.extend(traceback.format_tb(exc.__traceback__))
+                success = success and failureTests
+                result = exc
+            else:
+                success = success and not failureTests
+                if postParse is not None:
+                    try:
+                        pp_value = postParse(t, result)
+                        if pp_value is not None:
+                            if isinstance(pp_value, ParseResults):
+                                out.append(pp_value.dump())
+                            else:
+                                out.append(str(pp_value))
+                        else:
+                            out.append(result.dump())
+                    except Exception as e:
+                        out.append(result.dump(full=fullDump))
+                        out.append(
+                            "{} failed: {}: {}".format(
+                                postParse.__name__, type(e).__name__, e
+                            )
+                        )
+                else:
+                    out.append(result.dump(full=fullDump))
+            out.append("")
+
+            if printResults:
+                print_("\n".join(out))
+
+            allResults.append((t, result))
+
+        return success, allResults
+
+    def create_diagram(
+        self,
+        output_html: Union[TextIO, Path, str],
+        vertical: int = 3,
+        show_results_names: bool = False,
+        show_groups: bool = False,
+        **kwargs,
+    ) -> None:
+        """
+        Create a railroad diagram for the parser.
+
+        Parameters:
+        - output_html (str or file-like object) - output target for generated
+          diagram HTML
+        - vertical (int) - threshold for formatting multiple alternatives vertically
+          instead of horizontally (default=3)
+        - show_results_names - bool flag whether diagram should show annotations for
+          defined results names
+        - show_groups - bool flag whether groups should be highlighted with an unlabeled surrounding box
+        Additional diagram-formatting keyword arguments can also be included;
+        see railroad.Diagram class.
+        """
+
+        try:
+            from .diagram import to_railroad, railroad_to_html
+        except ImportError as ie:
+            raise Exception(
+                "must ``pip install pyparsing[diagrams]`` to generate parser railroad diagrams"
+            ) from ie
+
+        self.streamline()
+
+        railroad = to_railroad(
+            self,
+            vertical=vertical,
+            show_results_names=show_results_names,
+            show_groups=show_groups,
+            diagram_kwargs=kwargs,
+        )
+        if isinstance(output_html, (str, Path)):
+            with open(output_html, "w", encoding="utf-8") as diag_file:
+                diag_file.write(railroad_to_html(railroad))
+        else:
+            # we were passed a file-like object, just write to it
+            output_html.write(railroad_to_html(railroad))
+
+    setDefaultWhitespaceChars = set_default_whitespace_chars
+    inlineLiteralsUsing = inline_literals_using
+    setResultsName = set_results_name
+    setBreak = set_break
+    setParseAction = set_parse_action
+    addParseAction = add_parse_action
+    addCondition = add_condition
+    setFailAction = set_fail_action
+    tryParse = try_parse
+    canParseNext = can_parse_next
+    resetCache = reset_cache
+    enableLeftRecursion = enable_left_recursion
+    enablePackrat = enable_packrat
+    parseString = parse_string
+    scanString = scan_string
+    searchString = search_string
+    transformString = transform_string
+    setWhitespaceChars = set_whitespace_chars
+    parseWithTabs = parse_with_tabs
+    setDebugActions = set_debug_actions
+    setDebug = set_debug
+    defaultName = default_name
+    setName = set_name
+    parseFile = parse_file
+    runTests = run_tests
+    ignoreWhitespace = ignore_whitespace
+    leaveWhitespace = leave_whitespace
+
+
+class _PendingSkip(ParserElement):
+    # internal placeholder class to hold a place were '...' is added to a parser element,
+    # once another ParserElement is added, this placeholder will be replaced with a SkipTo
+    def __init__(self, expr: ParserElement, must_skip: bool = False):
+        super().__init__()
+        self.anchor = expr
+        self.must_skip = must_skip
+
+    def _generateDefaultName(self):
+        return str(self.anchor + Empty()).replace("Empty", "...")
+
+    def __add__(self, other) -> "ParserElement":
+        skipper = SkipTo(other).set_name("...")("_skipped*")
+        if self.must_skip:
+
+            def must_skip(t):
+                if not t._skipped or t._skipped.as_list() == [""]:
+                    del t[0]
+                    t.pop("_skipped", None)
+
+            def show_skip(t):
+                if t._skipped.as_list()[-1:] == [""]:
+                    t.pop("_skipped")
+                    t["_skipped"] = "missing <" + repr(self.anchor) + ">"
+
+            return (
+                self.anchor + skipper().add_parse_action(must_skip)
+                | skipper().add_parse_action(show_skip)
+            ) + other
+
+        return self.anchor + skipper + other
+
+    def __repr__(self):
+        return self.defaultName
+
+    def parseImpl(self, *args):
+        raise Exception(
+            "use of `...` expression without following SkipTo target expression"
+        )
+
+
+class Token(ParserElement):
+    """Abstract :class:`ParserElement` subclass, for defining atomic
+    matching patterns.
+    """
+
+    def __init__(self):
+        super().__init__(savelist=False)
+
+    def _generateDefaultName(self):
+        return type(self).__name__
+
+
+class Empty(Token):
+    """
+    An empty token, will always match.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+
+
+class NoMatch(Token):
+    """
+    A token that will never match.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.errmsg = "Unmatchable token"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class Literal(Token):
+    """
+    Token to exactly match a specified string.
+
+    Example::
+
+        Literal('blah').parse_string('blah')  # -> ['blah']
+        Literal('blah').parse_string('blahfooblah')  # -> ['blah']
+        Literal('blah').parse_string('bla')  # -> Exception: Expected "blah"
+
+    For case-insensitive matching, use :class:`CaselessLiteral`.
+
+    For keyword matching (force word break before and after the matched string),
+    use :class:`Keyword` or :class:`CaselessKeyword`.
+    """
+
+    def __init__(self, match_string: str = "", *, matchString: str = ""):
+        super().__init__()
+        match_string = matchString or match_string
+        self.match = match_string
+        self.matchLen = len(match_string)
+        try:
+            self.firstMatchChar = match_string[0]
+        except IndexError:
+            raise ValueError("null string passed to Literal; use Empty() instead")
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = False
+        self.mayIndexError = False
+
+        # Performance tuning: modify __class__ to select
+        # a parseImpl optimized for single-character check
+        if self.matchLen == 1 and type(self) is Literal:
+            self.__class__ = _SingleCharLiteral
+
+    def _generateDefaultName(self):
+        return repr(self.match)
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if instring[loc] == self.firstMatchChar and instring.startswith(
+            self.match, loc
+        ):
+            return loc + self.matchLen, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class _SingleCharLiteral(Literal):
+    def parseImpl(self, instring, loc, doActions=True):
+        if instring[loc] == self.firstMatchChar:
+            return loc + 1, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+ParserElement._literalStringClass = Literal
+
+
+class Keyword(Token):
+    """
+    Token to exactly match a specified string as a keyword, that is,
+    it must be immediately followed by a non-keyword character.  Compare
+    with :class:`Literal`:
+
+    - ``Literal("if")`` will match the leading ``'if'`` in
+      ``'ifAndOnlyIf'``.
+    - ``Keyword("if")`` will not; it will only match the leading
+      ``'if'`` in ``'if x=1'``, or ``'if(y==2)'``
+
+    Accepts two optional constructor arguments in addition to the
+    keyword string:
+
+    - ``identChars`` is a string of characters that would be valid
+      identifier characters, defaulting to all alphanumerics + "_" and
+      "$"
+    - ``caseless`` allows case-insensitive matching, default is ``False``.
+
+    Example::
+
+        Keyword("start").parse_string("start")  # -> ['start']
+        Keyword("start").parse_string("starting")  # -> Exception
+
+    For case-insensitive matching, use :class:`CaselessKeyword`.
+    """
+
+    DEFAULT_KEYWORD_CHARS = alphanums + "_$"
+
+    def __init__(
+        self,
+        match_string: str = "",
+        ident_chars: typing.Optional[str] = None,
+        caseless: bool = False,
+        *,
+        matchString: str = "",
+        identChars: typing.Optional[str] = None,
+    ):
+        super().__init__()
+        identChars = identChars or ident_chars
+        if identChars is None:
+            identChars = Keyword.DEFAULT_KEYWORD_CHARS
+        match_string = matchString or match_string
+        self.match = match_string
+        self.matchLen = len(match_string)
+        try:
+            self.firstMatchChar = match_string[0]
+        except IndexError:
+            raise ValueError("null string passed to Keyword; use Empty() instead")
+        self.errmsg = "Expected {} {}".format(type(self).__name__, self.name)
+        self.mayReturnEmpty = False
+        self.mayIndexError = False
+        self.caseless = caseless
+        if caseless:
+            self.caselessmatch = match_string.upper()
+            identChars = identChars.upper()
+        self.identChars = set(identChars)
+
+    def _generateDefaultName(self):
+        return repr(self.match)
+
+    def parseImpl(self, instring, loc, doActions=True):
+        errmsg = self.errmsg
+        errloc = loc
+        if self.caseless:
+            if instring[loc : loc + self.matchLen].upper() == self.caselessmatch:
+                if loc == 0 or instring[loc - 1].upper() not in self.identChars:
+                    if (
+                        loc >= len(instring) - self.matchLen
+                        or instring[loc + self.matchLen].upper() not in self.identChars
+                    ):
+                        return loc + self.matchLen, self.match
+                    else:
+                        # followed by keyword char
+                        errmsg += ", was immediately followed by keyword character"
+                        errloc = loc + self.matchLen
+                else:
+                    # preceded by keyword char
+                    errmsg += ", keyword was immediately preceded by keyword character"
+                    errloc = loc - 1
+            # else no match just raise plain exception
+
+        else:
+            if (
+                instring[loc] == self.firstMatchChar
+                and self.matchLen == 1
+                or instring.startswith(self.match, loc)
+            ):
+                if loc == 0 or instring[loc - 1] not in self.identChars:
+                    if (
+                        loc >= len(instring) - self.matchLen
+                        or instring[loc + self.matchLen] not in self.identChars
+                    ):
+                        return loc + self.matchLen, self.match
+                    else:
+                        # followed by keyword char
+                        errmsg += (
+                            ", keyword was immediately followed by keyword character"
+                        )
+                        errloc = loc + self.matchLen
+                else:
+                    # preceded by keyword char
+                    errmsg += ", keyword was immediately preceded by keyword character"
+                    errloc = loc - 1
+            # else no match just raise plain exception
+
+        raise ParseException(instring, errloc, errmsg, self)
+
+    @staticmethod
+    def set_default_keyword_chars(chars) -> None:
+        """
+        Overrides the default characters used by :class:`Keyword` expressions.
+        """
+        Keyword.DEFAULT_KEYWORD_CHARS = chars
+
+    setDefaultKeywordChars = set_default_keyword_chars
+
+
+class CaselessLiteral(Literal):
+    """
+    Token to match a specified string, ignoring case of letters.
+    Note: the matched results will always be in the case of the given
+    match string, NOT the case of the input text.
+
+    Example::
+
+        CaselessLiteral("CMD")[1, ...].parse_string("cmd CMD Cmd10")
+        # -> ['CMD', 'CMD', 'CMD']
+
+    (Contrast with example for :class:`CaselessKeyword`.)
+    """
+
+    def __init__(self, match_string: str = "", *, matchString: str = ""):
+        match_string = matchString or match_string
+        super().__init__(match_string.upper())
+        # Preserve the defining literal.
+        self.returnString = match_string
+        self.errmsg = "Expected " + self.name
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if instring[loc : loc + self.matchLen].upper() == self.match:
+            return loc + self.matchLen, self.returnString
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class CaselessKeyword(Keyword):
+    """
+    Caseless version of :class:`Keyword`.
+
+    Example::
+
+        CaselessKeyword("CMD")[1, ...].parse_string("cmd CMD Cmd10")
+        # -> ['CMD', 'CMD']
+
+    (Contrast with example for :class:`CaselessLiteral`.)
+    """
+
+    def __init__(
+        self,
+        match_string: str = "",
+        ident_chars: typing.Optional[str] = None,
+        *,
+        matchString: str = "",
+        identChars: typing.Optional[str] = None,
+    ):
+        identChars = identChars or ident_chars
+        match_string = matchString or match_string
+        super().__init__(match_string, identChars, caseless=True)
+
+
+class CloseMatch(Token):
+    """A variation on :class:`Literal` which matches "close" matches,
+    that is, strings with at most 'n' mismatching characters.
+    :class:`CloseMatch` takes parameters:
+
+    - ``match_string`` - string to be matched
+    - ``caseless`` - a boolean indicating whether to ignore casing when comparing characters
+    - ``max_mismatches`` - (``default=1``) maximum number of
+      mismatches allowed to count as a match
+
+    The results from a successful parse will contain the matched text
+    from the input string and the following named results:
+
+    - ``mismatches`` - a list of the positions within the
+      match_string where mismatches were found
+    - ``original`` - the original match_string used to compare
+      against the input string
+
+    If ``mismatches`` is an empty list, then the match was an exact
+    match.
+
+    Example::
+
+        patt = CloseMatch("ATCATCGAATGGA")
+        patt.parse_string("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})
+        patt.parse_string("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)
+
+        # exact match
+        patt.parse_string("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})
+
+        # close match allowing up to 2 mismatches
+        patt = CloseMatch("ATCATCGAATGGA", max_mismatches=2)
+        patt.parse_string("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})
+    """
+
+    def __init__(
+        self,
+        match_string: str,
+        max_mismatches: int = None,
+        *,
+        maxMismatches: int = 1,
+        caseless=False,
+    ):
+        maxMismatches = max_mismatches if max_mismatches is not None else maxMismatches
+        super().__init__()
+        self.match_string = match_string
+        self.maxMismatches = maxMismatches
+        self.errmsg = "Expected {!r} (with up to {} mismatches)".format(
+            self.match_string, self.maxMismatches
+        )
+        self.caseless = caseless
+        self.mayIndexError = False
+        self.mayReturnEmpty = False
+
+    def _generateDefaultName(self):
+        return "{}:{!r}".format(type(self).__name__, self.match_string)
+
+    def parseImpl(self, instring, loc, doActions=True):
+        start = loc
+        instrlen = len(instring)
+        maxloc = start + len(self.match_string)
+
+        if maxloc <= instrlen:
+            match_string = self.match_string
+            match_stringloc = 0
+            mismatches = []
+            maxMismatches = self.maxMismatches
+
+            for match_stringloc, s_m in enumerate(
+                zip(instring[loc:maxloc], match_string)
+            ):
+                src, mat = s_m
+                if self.caseless:
+                    src, mat = src.lower(), mat.lower()
+
+                if src != mat:
+                    mismatches.append(match_stringloc)
+                    if len(mismatches) > maxMismatches:
+                        break
+            else:
+                loc = start + match_stringloc + 1
+                results = ParseResults([instring[start:loc]])
+                results["original"] = match_string
+                results["mismatches"] = mismatches
+                return loc, results
+
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class Word(Token):
+    """Token for matching words composed of allowed character sets.
+    Parameters:
+    - ``init_chars`` - string of all characters that should be used to
+      match as a word; "ABC" will match "AAA", "ABAB", "CBAC", etc.;
+      if ``body_chars`` is also specified, then this is the string of
+      initial characters
+    - ``body_chars`` - string of characters that
+      can be used for matching after a matched initial character as
+      given in ``init_chars``; if omitted, same as the initial characters
+      (default=``None``)
+    - ``min`` - minimum number of characters to match (default=1)
+    - ``max`` - maximum number of characters to match (default=0)
+    - ``exact`` - exact number of characters to match (default=0)
+    - ``as_keyword`` - match as a keyword (default=``False``)
+    - ``exclude_chars`` - characters that might be
+      found in the input ``body_chars`` string but which should not be
+      accepted for matching ;useful to define a word of all
+      printables except for one or two characters, for instance
+      (default=``None``)
+
+    :class:`srange` is useful for defining custom character set strings
+    for defining :class:`Word` expressions, using range notation from
+    regular expression character sets.
+
+    A common mistake is to use :class:`Word` to match a specific literal
+    string, as in ``Word("Address")``. Remember that :class:`Word`
+    uses the string argument to define *sets* of matchable characters.
+    This expression would match "Add", "AAA", "dAred", or any other word
+    made up of the characters 'A', 'd', 'r', 'e', and 's'. To match an
+    exact literal string, use :class:`Literal` or :class:`Keyword`.
+
+    pyparsing includes helper strings for building Words:
+
+    - :class:`alphas`
+    - :class:`nums`
+    - :class:`alphanums`
+    - :class:`hexnums`
+    - :class:`alphas8bit` (alphabetic characters in ASCII range 128-255
+      - accented, tilded, umlauted, etc.)
+    - :class:`punc8bit` (non-alphabetic characters in ASCII range
+      128-255 - currency, symbols, superscripts, diacriticals, etc.)
+    - :class:`printables` (any non-whitespace character)
+
+    ``alphas``, ``nums``, and ``printables`` are also defined in several
+    Unicode sets - see :class:`pyparsing_unicode``.
+
+    Example::
+
+        # a word composed of digits
+        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))
+
+        # a word with a leading capital, and zero or more lowercase
+        capital_word = Word(alphas.upper(), alphas.lower())
+
+        # hostnames are alphanumeric, with leading alpha, and '-'
+        hostname = Word(alphas, alphanums + '-')
+
+        # roman numeral (not a strict parser, accepts invalid mix of characters)
+        roman = Word("IVXLCDM")
+
+        # any string of non-whitespace characters, except for ','
+        csv_value = Word(printables, exclude_chars=",")
+    """
+
+    def __init__(
+        self,
+        init_chars: str = "",
+        body_chars: typing.Optional[str] = None,
+        min: int = 1,
+        max: int = 0,
+        exact: int = 0,
+        as_keyword: bool = False,
+        exclude_chars: typing.Optional[str] = None,
+        *,
+        initChars: typing.Optional[str] = None,
+        bodyChars: typing.Optional[str] = None,
+        asKeyword: bool = False,
+        excludeChars: typing.Optional[str] = None,
+    ):
+        initChars = initChars or init_chars
+        bodyChars = bodyChars or body_chars
+        asKeyword = asKeyword or as_keyword
+        excludeChars = excludeChars or exclude_chars
+        super().__init__()
+        if not initChars:
+            raise ValueError(
+                "invalid {}, initChars cannot be empty string".format(
+                    type(self).__name__
+                )
+            )
+
+        initChars = set(initChars)
+        self.initChars = initChars
+        if excludeChars:
+            excludeChars = set(excludeChars)
+            initChars -= excludeChars
+            if bodyChars:
+                bodyChars = set(bodyChars) - excludeChars
+        self.initCharsOrig = "".join(sorted(initChars))
+
+        if bodyChars:
+            self.bodyCharsOrig = "".join(sorted(bodyChars))
+            self.bodyChars = set(bodyChars)
+        else:
+            self.bodyCharsOrig = "".join(sorted(initChars))
+            self.bodyChars = set(initChars)
+
+        self.maxSpecified = max > 0
+
+        if min < 1:
+            raise ValueError(
+                "cannot specify a minimum length < 1; use Opt(Word()) if zero-length word is permitted"
+            )
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.asKeyword = asKeyword
+
+        # see if we can make a regex for this Word
+        if " " not in self.initChars | self.bodyChars and (min == 1 and exact == 0):
+            if self.bodyChars == self.initChars:
+                if max == 0:
+                    repeat = "+"
+                elif max == 1:
+                    repeat = ""
+                else:
+                    repeat = "{{{},{}}}".format(
+                        self.minLen, "" if self.maxLen == _MAX_INT else self.maxLen
+                    )
+                self.reString = "[{}]{}".format(
+                    _collapse_string_to_ranges(self.initChars),
+                    repeat,
+                )
+            elif len(self.initChars) == 1:
+                if max == 0:
+                    repeat = "*"
+                else:
+                    repeat = "{{0,{}}}".format(max - 1)
+                self.reString = "{}[{}]{}".format(
+                    re.escape(self.initCharsOrig),
+                    _collapse_string_to_ranges(self.bodyChars),
+                    repeat,
+                )
+            else:
+                if max == 0:
+                    repeat = "*"
+                elif max == 2:
+                    repeat = ""
+                else:
+                    repeat = "{{0,{}}}".format(max - 1)
+                self.reString = "[{}][{}]{}".format(
+                    _collapse_string_to_ranges(self.initChars),
+                    _collapse_string_to_ranges(self.bodyChars),
+                    repeat,
+                )
+            if self.asKeyword:
+                self.reString = r"\b" + self.reString + r"\b"
+
+            try:
+                self.re = re.compile(self.reString)
+            except re.error:
+                self.re = None
+            else:
+                self.re_match = self.re.match
+                self.__class__ = _WordRegex
+
+    def _generateDefaultName(self):
+        def charsAsStr(s):
+            max_repr_len = 16
+            s = _collapse_string_to_ranges(s, re_escape=False)
+            if len(s) > max_repr_len:
+                return s[: max_repr_len - 3] + "..."
+            else:
+                return s
+
+        if self.initChars != self.bodyChars:
+            base = "W:({}, {})".format(
+                charsAsStr(self.initChars), charsAsStr(self.bodyChars)
+            )
+        else:
+            base = "W:({})".format(charsAsStr(self.initChars))
+
+        # add length specification
+        if self.minLen > 1 or self.maxLen != _MAX_INT:
+            if self.minLen == self.maxLen:
+                if self.minLen == 1:
+                    return base[2:]
+                else:
+                    return base + "{{{}}}".format(self.minLen)
+            elif self.maxLen == _MAX_INT:
+                return base + "{{{},...}}".format(self.minLen)
+            else:
+                return base + "{{{},{}}}".format(self.minLen, self.maxLen)
+        return base
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if instring[loc] not in self.initChars:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        start = loc
+        loc += 1
+        instrlen = len(instring)
+        bodychars = self.bodyChars
+        maxloc = start + self.maxLen
+        maxloc = min(maxloc, instrlen)
+        while loc < maxloc and instring[loc] in bodychars:
+            loc += 1
+
+        throwException = False
+        if loc - start < self.minLen:
+            throwException = True
+        elif self.maxSpecified and loc < instrlen and instring[loc] in bodychars:
+            throwException = True
+        elif self.asKeyword:
+            if (
+                start > 0
+                and instring[start - 1] in bodychars
+                or loc < instrlen
+                and instring[loc] in bodychars
+            ):
+                throwException = True
+
+        if throwException:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+
+class _WordRegex(Word):
+    def parseImpl(self, instring, loc, doActions=True):
+        result = self.re_match(instring, loc)
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        return loc, result.group()
+
+
+class Char(_WordRegex):
+    """A short-cut class for defining :class:`Word` ``(characters, exact=1)``,
+    when defining a match of any single character in a string of
+    characters.
+    """
+
+    def __init__(
+        self,
+        charset: str,
+        as_keyword: bool = False,
+        exclude_chars: typing.Optional[str] = None,
+        *,
+        asKeyword: bool = False,
+        excludeChars: typing.Optional[str] = None,
+    ):
+        asKeyword = asKeyword or as_keyword
+        excludeChars = excludeChars or exclude_chars
+        super().__init__(
+            charset, exact=1, asKeyword=asKeyword, excludeChars=excludeChars
+        )
+        self.reString = "[{}]".format(_collapse_string_to_ranges(self.initChars))
+        if asKeyword:
+            self.reString = r"\b{}\b".format(self.reString)
+        self.re = re.compile(self.reString)
+        self.re_match = self.re.match
+
+
+class Regex(Token):
+    r"""Token for matching strings that match a given regular
+    expression. Defined with string specifying the regular expression in
+    a form recognized by the stdlib Python  `re module <https://docs.python.org/3/library/re.html>`_.
+    If the given regex contains named groups (defined using ``(?P<name>...)``),
+    these will be preserved as named :class:`ParseResults`.
+
+    If instead of the Python stdlib ``re`` module you wish to use a different RE module
+    (such as the ``regex`` module), you can do so by building your ``Regex`` object with
+    a compiled RE that was compiled using ``regex``.
+
+    Example::
+
+        realnum = Regex(r"[+-]?\d+\.\d*")
+        # ref: https://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression
+        roman = Regex(r"M{0,4}(CM|CD|D?{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
+
+        # named fields in a regex will be returned as named results
+        date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)')
+
+        # the Regex class will accept re's compiled using the regex module
+        import regex
+        parser = pp.Regex(regex.compile(r'[0-9]'))
+    """
+
+    def __init__(
+        self,
+        pattern: Any,
+        flags: Union[re.RegexFlag, int] = 0,
+        as_group_list: bool = False,
+        as_match: bool = False,
+        *,
+        asGroupList: bool = False,
+        asMatch: bool = False,
+    ):
+        """The parameters ``pattern`` and ``flags`` are passed
+        to the ``re.compile()`` function as-is. See the Python
+        `re module <https://docs.python.org/3/library/re.html>`_ module for an
+        explanation of the acceptable patterns and flags.
+        """
+        super().__init__()
+        asGroupList = asGroupList or as_group_list
+        asMatch = asMatch or as_match
+
+        if isinstance(pattern, str_type):
+            if not pattern:
+                raise ValueError("null string passed to Regex; use Empty() instead")
+
+            self._re = None
+            self.reString = self.pattern = pattern
+            self.flags = flags
+
+        elif hasattr(pattern, "pattern") and hasattr(pattern, "match"):
+            self._re = pattern
+            self.pattern = self.reString = pattern.pattern
+            self.flags = flags
+
+        else:
+            raise TypeError(
+                "Regex may only be constructed with a string or a compiled RE object"
+            )
+
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.asGroupList = asGroupList
+        self.asMatch = asMatch
+        if self.asGroupList:
+            self.parseImpl = self.parseImplAsGroupList
+        if self.asMatch:
+            self.parseImpl = self.parseImplAsMatch
+
+    @cached_property
+    def re(self):
+        if self._re:
+            return self._re
+        else:
+            try:
+                return re.compile(self.pattern, self.flags)
+            except re.error:
+                raise ValueError(
+                    "invalid pattern ({!r}) passed to Regex".format(self.pattern)
+                )
+
+    @cached_property
+    def re_match(self):
+        return self.re.match
+
+    @cached_property
+    def mayReturnEmpty(self):
+        return self.re_match("") is not None
+
+    def _generateDefaultName(self):
+        return "Re:({})".format(repr(self.pattern).replace("\\\\", "\\"))
+
+    def parseImpl(self, instring, loc, doActions=True):
+        result = self.re_match(instring, loc)
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        ret = ParseResults(result.group())
+        d = result.groupdict()
+        if d:
+            for k, v in d.items():
+                ret[k] = v
+        return loc, ret
+
+    def parseImplAsGroupList(self, instring, loc, doActions=True):
+        result = self.re_match(instring, loc)
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        ret = result.groups()
+        return loc, ret
+
+    def parseImplAsMatch(self, instring, loc, doActions=True):
+        result = self.re_match(instring, loc)
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        ret = result
+        return loc, ret
+
+    def sub(self, repl: str) -> ParserElement:
+        r"""
+        Return :class:`Regex` with an attached parse action to transform the parsed
+        result as if called using `re.sub(expr, repl, string) <https://docs.python.org/3/library/re.html#re.sub>`_.
+
+        Example::
+
+            make_html = Regex(r"(\w+):(.*?):").sub(r"<\1>\2</\1>")
+            print(make_html.transform_string("h1:main title:"))
+            # prints "<h1>main title</h1>"
+        """
+        if self.asGroupList:
+            raise TypeError("cannot use sub() with Regex(asGroupList=True)")
+
+        if self.asMatch and callable(repl):
+            raise TypeError("cannot use sub() with a callable with Regex(asMatch=True)")
+
+        if self.asMatch:
+
+            def pa(tokens):
+                return tokens[0].expand(repl)
+
+        else:
+
+            def pa(tokens):
+                return self.re.sub(repl, tokens[0])
+
+        return self.add_parse_action(pa)
+
+
+class QuotedString(Token):
+    r"""
+    Token for matching strings that are delimited by quoting characters.
+
+    Defined with the following parameters:
+
+    - ``quote_char`` - string of one or more characters defining the
+      quote delimiting string
+    - ``esc_char`` - character to re_escape quotes, typically backslash
+      (default= ``None``)
+    - ``esc_quote`` - special quote sequence to re_escape an embedded quote
+      string (such as SQL's ``""`` to re_escape an embedded ``"``)
+      (default= ``None``)
+    - ``multiline`` - boolean indicating whether quotes can span
+      multiple lines (default= ``False``)
+    - ``unquote_results`` - boolean indicating whether the matched text
+      should be unquoted (default= ``True``)
+    - ``end_quote_char`` - string of one or more characters defining the
+      end of the quote delimited string (default= ``None``  => same as
+      quote_char)
+    - ``convert_whitespace_escapes`` - convert escaped whitespace
+      (``'\t'``, ``'\n'``, etc.) to actual whitespace
+      (default= ``True``)
+
+    Example::
+
+        qs = QuotedString('"')
+        print(qs.search_string('lsjdf "This is the quote" sldjf'))
+        complex_qs = QuotedString('{{', end_quote_char='}}')
+        print(complex_qs.search_string('lsjdf {{This is the "quote"}} sldjf'))
+        sql_qs = QuotedString('"', esc_quote='""')
+        print(sql_qs.search_string('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))
+
+    prints::
+
+        [['This is the quote']]
+        [['This is the "quote"']]
+        [['This is the quote with "embedded" quotes']]
+    """
+    ws_map = ((r"\t", "\t"), (r"\n", "\n"), (r"\f", "\f"), (r"\r", "\r"))
+
+    def __init__(
+        self,
+        quote_char: str = "",
+        esc_char: typing.Optional[str] = None,
+        esc_quote: typing.Optional[str] = None,
+        multiline: bool = False,
+        unquote_results: bool = True,
+        end_quote_char: typing.Optional[str] = None,
+        convert_whitespace_escapes: bool = True,
+        *,
+        quoteChar: str = "",
+        escChar: typing.Optional[str] = None,
+        escQuote: typing.Optional[str] = None,
+        unquoteResults: bool = True,
+        endQuoteChar: typing.Optional[str] = None,
+        convertWhitespaceEscapes: bool = True,
+    ):
+        super().__init__()
+        escChar = escChar or esc_char
+        escQuote = escQuote or esc_quote
+        unquoteResults = unquoteResults and unquote_results
+        endQuoteChar = endQuoteChar or end_quote_char
+        convertWhitespaceEscapes = (
+            convertWhitespaceEscapes and convert_whitespace_escapes
+        )
+        quote_char = quoteChar or quote_char
+
+        # remove white space from quote chars - wont work anyway
+        quote_char = quote_char.strip()
+        if not quote_char:
+            raise ValueError("quote_char cannot be the empty string")
+
+        if endQuoteChar is None:
+            endQuoteChar = quote_char
+        else:
+            endQuoteChar = endQuoteChar.strip()
+            if not endQuoteChar:
+                raise ValueError("endQuoteChar cannot be the empty string")
+
+        self.quoteChar = quote_char
+        self.quoteCharLen = len(quote_char)
+        self.firstQuoteChar = quote_char[0]
+        self.endQuoteChar = endQuoteChar
+        self.endQuoteCharLen = len(endQuoteChar)
+        self.escChar = escChar
+        self.escQuote = escQuote
+        self.unquoteResults = unquoteResults
+        self.convertWhitespaceEscapes = convertWhitespaceEscapes
+
+        sep = ""
+        inner_pattern = ""
+
+        if escQuote:
+            inner_pattern += r"{}(?:{})".format(sep, re.escape(escQuote))
+            sep = "|"
+
+        if escChar:
+            inner_pattern += r"{}(?:{}.)".format(sep, re.escape(escChar))
+            sep = "|"
+            self.escCharReplacePattern = re.escape(self.escChar) + "(.)"
+
+        if len(self.endQuoteChar) > 1:
+            inner_pattern += (
+                "{}(?:".format(sep)
+                + "|".join(
+                    "(?:{}(?!{}))".format(
+                        re.escape(self.endQuoteChar[:i]),
+                        re.escape(self.endQuoteChar[i:]),
+                    )
+                    for i in range(len(self.endQuoteChar) - 1, 0, -1)
+                )
+                + ")"
+            )
+            sep = "|"
+
+        if multiline:
+            self.flags = re.MULTILINE | re.DOTALL
+            inner_pattern += r"{}(?:[^{}{}])".format(
+                sep,
+                _escape_regex_range_chars(self.endQuoteChar[0]),
+                (_escape_regex_range_chars(escChar) if escChar is not None else ""),
+            )
+        else:
+            self.flags = 0
+            inner_pattern += r"{}(?:[^{}\n\r{}])".format(
+                sep,
+                _escape_regex_range_chars(self.endQuoteChar[0]),
+                (_escape_regex_range_chars(escChar) if escChar is not None else ""),
+            )
+
+        self.pattern = "".join(
+            [
+                re.escape(self.quoteChar),
+                "(?:",
+                inner_pattern,
+                ")*",
+                re.escape(self.endQuoteChar),
+            ]
+        )
+
+        try:
+            self.re = re.compile(self.pattern, self.flags)
+            self.reString = self.pattern
+            self.re_match = self.re.match
+        except re.error:
+            raise ValueError(
+                "invalid pattern {!r} passed to Regex".format(self.pattern)
+            )
+
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.mayReturnEmpty = True
+
+    def _generateDefaultName(self):
+        if self.quoteChar == self.endQuoteChar and isinstance(self.quoteChar, str_type):
+            return "string enclosed in {!r}".format(self.quoteChar)
+
+        return "quoted string, starting with {} ending with {}".format(
+            self.quoteChar, self.endQuoteChar
+        )
+
+    def parseImpl(self, instring, loc, doActions=True):
+        result = (
+            instring[loc] == self.firstQuoteChar
+            and self.re_match(instring, loc)
+            or None
+        )
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        ret = result.group()
+
+        if self.unquoteResults:
+
+            # strip off quotes
+            ret = ret[self.quoteCharLen : -self.endQuoteCharLen]
+
+            if isinstance(ret, str_type):
+                # replace escaped whitespace
+                if "\\" in ret and self.convertWhitespaceEscapes:
+                    for wslit, wschar in self.ws_map:
+                        ret = ret.replace(wslit, wschar)
+
+                # replace escaped characters
+                if self.escChar:
+                    ret = re.sub(self.escCharReplacePattern, r"\g<1>", ret)
+
+                # replace escaped quotes
+                if self.escQuote:
+                    ret = ret.replace(self.escQuote, self.endQuoteChar)
+
+        return loc, ret
+
+
+class CharsNotIn(Token):
+    """Token for matching words composed of characters *not* in a given
+    set (will include whitespace in matched characters if not listed in
+    the provided exclusion set - see example). Defined with string
+    containing all disallowed characters, and an optional minimum,
+    maximum, and/or exact length.  The default value for ``min`` is
+    1 (a minimum value < 1 is not valid); the default values for
+    ``max`` and ``exact`` are 0, meaning no maximum or exact
+    length restriction.
+
+    Example::
+
+        # define a comma-separated-value as anything that is not a ','
+        csv_value = CharsNotIn(',')
+        print(delimited_list(csv_value).parse_string("dkls,lsdkjf,s12 34,@!#,213"))
+
+    prints::
+
+        ['dkls', 'lsdkjf', 's12 34', '@!#', '213']
+    """
+
+    def __init__(
+        self,
+        not_chars: str = "",
+        min: int = 1,
+        max: int = 0,
+        exact: int = 0,
+        *,
+        notChars: str = "",
+    ):
+        super().__init__()
+        self.skipWhitespace = False
+        self.notChars = not_chars or notChars
+        self.notCharsSet = set(self.notChars)
+
+        if min < 1:
+            raise ValueError(
+                "cannot specify a minimum length < 1; use "
+                "Opt(CharsNotIn()) if zero-length char group is permitted"
+            )
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = self.minLen == 0
+        self.mayIndexError = False
+
+    def _generateDefaultName(self):
+        not_chars_str = _collapse_string_to_ranges(self.notChars)
+        if len(not_chars_str) > 16:
+            return "!W:({}...)".format(self.notChars[: 16 - 3])
+        else:
+            return "!W:({})".format(self.notChars)
+
+    def parseImpl(self, instring, loc, doActions=True):
+        notchars = self.notCharsSet
+        if instring[loc] in notchars:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        start = loc
+        loc += 1
+        maxlen = min(start + self.maxLen, len(instring))
+        while loc < maxlen and instring[loc] not in notchars:
+            loc += 1
+
+        if loc - start < self.minLen:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+
+class White(Token):
+    """Special matching class for matching whitespace.  Normally,
+    whitespace is ignored by pyparsing grammars.  This class is included
+    when some whitespace structures are significant.  Define with
+    a string containing the whitespace characters to be matched; default
+    is ``" \\t\\r\\n"``.  Also takes optional ``min``,
+    ``max``, and ``exact`` arguments, as defined for the
+    :class:`Word` class.
+    """
+
+    whiteStrs = {
+        " ": "<SP>",
+        "\t": "<TAB>",
+        "\n": "<LF>",
+        "\r": "<CR>",
+        "\f": "<FF>",
+        "\u00A0": "<NBSP>",
+        "\u1680": "<OGHAM_SPACE_MARK>",
+        "\u180E": "<MONGOLIAN_VOWEL_SEPARATOR>",
+        "\u2000": "<EN_QUAD>",
+        "\u2001": "<EM_QUAD>",
+        "\u2002": "<EN_SPACE>",
+        "\u2003": "<EM_SPACE>",
+        "\u2004": "<THREE-PER-EM_SPACE>",
+        "\u2005": "<FOUR-PER-EM_SPACE>",
+        "\u2006": "<SIX-PER-EM_SPACE>",
+        "\u2007": "<FIGURE_SPACE>",
+        "\u2008": "<PUNCTUATION_SPACE>",
+        "\u2009": "<THIN_SPACE>",
+        "\u200A": "<HAIR_SPACE>",
+        "\u200B": "<ZERO_WIDTH_SPACE>",
+        "\u202F": "<NNBSP>",
+        "\u205F": "<MMSP>",
+        "\u3000": "<IDEOGRAPHIC_SPACE>",
+    }
+
+    def __init__(self, ws: str = " \t\r\n", min: int = 1, max: int = 0, exact: int = 0):
+        super().__init__()
+        self.matchWhite = ws
+        self.set_whitespace_chars(
+            "".join(c for c in self.whiteStrs if c not in self.matchWhite),
+            copy_defaults=True,
+        )
+        # self.leave_whitespace()
+        self.mayReturnEmpty = True
+        self.errmsg = "Expected " + self.name
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+    def _generateDefaultName(self):
+        return "".join(White.whiteStrs[c] for c in self.matchWhite)
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if instring[loc] not in self.matchWhite:
+            raise ParseException(instring, loc, self.errmsg, self)
+        start = loc
+        loc += 1
+        maxloc = start + self.maxLen
+        maxloc = min(maxloc, len(instring))
+        while loc < maxloc and instring[loc] in self.matchWhite:
+            loc += 1
+
+        if loc - start < self.minLen:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+
+class PositionToken(Token):
+    def __init__(self):
+        super().__init__()
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+
+
+class GoToColumn(PositionToken):
+    """Token to advance to a specific column of input text; useful for
+    tabular report scraping.
+    """
+
+    def __init__(self, colno: int):
+        super().__init__()
+        self.col = colno
+
+    def preParse(self, instring, loc):
+        if col(loc, instring) != self.col:
+            instrlen = len(instring)
+            if self.ignoreExprs:
+                loc = self._skipIgnorables(instring, loc)
+            while (
+                loc < instrlen
+                and instring[loc].isspace()
+                and col(loc, instring) != self.col
+            ):
+                loc += 1
+        return loc
+
+    def parseImpl(self, instring, loc, doActions=True):
+        thiscol = col(loc, instring)
+        if thiscol > self.col:
+            raise ParseException(instring, loc, "Text not in expected column", self)
+        newloc = loc + self.col - thiscol
+        ret = instring[loc:newloc]
+        return newloc, ret
+
+
+class LineStart(PositionToken):
+    r"""Matches if current position is at the beginning of a line within
+    the parse string
+
+    Example::
+
+        test = '''\
+        AAA this line
+        AAA and this line
+          AAA but not this one
+        B AAA and definitely not this one
+        '''
+
+        for t in (LineStart() + 'AAA' + restOfLine).search_string(test):
+            print(t)
+
+    prints::
+
+        ['AAA', ' this line']
+        ['AAA', ' and this line']
+
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.leave_whitespace()
+        self.orig_whiteChars = set() | self.whiteChars
+        self.whiteChars.discard("\n")
+        self.skipper = Empty().set_whitespace_chars(self.whiteChars)
+        self.errmsg = "Expected start of line"
+
+    def preParse(self, instring, loc):
+        if loc == 0:
+            return loc
+        else:
+            ret = self.skipper.preParse(instring, loc)
+            if "\n" in self.orig_whiteChars:
+                while instring[ret : ret + 1] == "\n":
+                    ret = self.skipper.preParse(instring, ret + 1)
+            return ret
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if col(loc, instring) == 1:
+            return loc, []
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class LineEnd(PositionToken):
+    """Matches if current position is at the end of a line within the
+    parse string
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.whiteChars.discard("\n")
+        self.set_whitespace_chars(self.whiteChars, copy_defaults=False)
+        self.errmsg = "Expected end of line"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if loc < len(instring):
+            if instring[loc] == "\n":
+                return loc + 1, "\n"
+            else:
+                raise ParseException(instring, loc, self.errmsg, self)
+        elif loc == len(instring):
+            return loc + 1, []
+        else:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+
+class StringStart(PositionToken):
+    """Matches if current position is at the beginning of the parse
+    string
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.errmsg = "Expected start of text"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if loc != 0:
+            # see if entire string up to here is just whitespace and ignoreables
+            if loc != self.preParse(instring, 0):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+
+class StringEnd(PositionToken):
+    """
+    Matches if current position is at the end of the parse string
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.errmsg = "Expected end of text"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if loc < len(instring):
+            raise ParseException(instring, loc, self.errmsg, self)
+        elif loc == len(instring):
+            return loc + 1, []
+        elif loc > len(instring):
+            return loc, []
+        else:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+
+class WordStart(PositionToken):
+    """Matches if the current position is at the beginning of a
+    :class:`Word`, and is not preceded by any character in a given
+    set of ``word_chars`` (default= ``printables``). To emulate the
+    ``\b`` behavior of regular expressions, use
+    ``WordStart(alphanums)``. ``WordStart`` will also match at
+    the beginning of the string being parsed, or at the beginning of
+    a line.
+    """
+
+    def __init__(self, word_chars: str = printables, *, wordChars: str = printables):
+        wordChars = word_chars if wordChars == printables else wordChars
+        super().__init__()
+        self.wordChars = set(wordChars)
+        self.errmsg = "Not at the start of a word"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if loc != 0:
+            if (
+                instring[loc - 1] in self.wordChars
+                or instring[loc] not in self.wordChars
+            ):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+
+class WordEnd(PositionToken):
+    """Matches if the current position is at the end of a :class:`Word`,
+    and is not followed by any character in a given set of ``word_chars``
+    (default= ``printables``). To emulate the ``\b`` behavior of
+    regular expressions, use ``WordEnd(alphanums)``. ``WordEnd``
+    will also match at the end of the string being parsed, or at the end
+    of a line.
+    """
+
+    def __init__(self, word_chars: str = printables, *, wordChars: str = printables):
+        wordChars = word_chars if wordChars == printables else wordChars
+        super().__init__()
+        self.wordChars = set(wordChars)
+        self.skipWhitespace = False
+        self.errmsg = "Not at the end of a word"
+
+    def parseImpl(self, instring, loc, doActions=True):
+        instrlen = len(instring)
+        if instrlen > 0 and loc < instrlen:
+            if (
+                instring[loc] in self.wordChars
+                or instring[loc - 1] not in self.wordChars
+            ):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+
+class ParseExpression(ParserElement):
+    """Abstract subclass of ParserElement, for combining and
+    post-processing parsed tokens.
+    """
+
+    def __init__(self, exprs: typing.Iterable[ParserElement], savelist: bool = False):
+        super().__init__(savelist)
+        self.exprs: List[ParserElement]
+        if isinstance(exprs, _generatorType):
+            exprs = list(exprs)
+
+        if isinstance(exprs, str_type):
+            self.exprs = [self._literalStringClass(exprs)]
+        elif isinstance(exprs, ParserElement):
+            self.exprs = [exprs]
+        elif isinstance(exprs, Iterable):
+            exprs = list(exprs)
+            # if sequence of strings provided, wrap with Literal
+            if any(isinstance(expr, str_type) for expr in exprs):
+                exprs = (
+                    self._literalStringClass(e) if isinstance(e, str_type) else e
+                    for e in exprs
+                )
+            self.exprs = list(exprs)
+        else:
+            try:
+                self.exprs = list(exprs)
+            except TypeError:
+                self.exprs = [exprs]
+        self.callPreparse = False
+
+    def recurse(self) -> Sequence[ParserElement]:
+        return self.exprs[:]
+
+    def append(self, other) -> ParserElement:
+        self.exprs.append(other)
+        self._defaultName = None
+        return self
+
+    def leave_whitespace(self, recursive: bool = True) -> ParserElement:
+        """
+        Extends ``leave_whitespace`` defined in base class, and also invokes ``leave_whitespace`` on
+           all contained expressions.
+        """
+        super().leave_whitespace(recursive)
+
+        if recursive:
+            self.exprs = [e.copy() for e in self.exprs]
+            for e in self.exprs:
+                e.leave_whitespace(recursive)
+        return self
+
+    def ignore_whitespace(self, recursive: bool = True) -> ParserElement:
+        """
+        Extends ``ignore_whitespace`` defined in base class, and also invokes ``leave_whitespace`` on
+           all contained expressions.
+        """
+        super().ignore_whitespace(recursive)
+        if recursive:
+            self.exprs = [e.copy() for e in self.exprs]
+            for e in self.exprs:
+                e.ignore_whitespace(recursive)
+        return self
+
+    def ignore(self, other) -> ParserElement:
+        if isinstance(other, Suppress):
+            if other not in self.ignoreExprs:
+                super().ignore(other)
+                for e in self.exprs:
+                    e.ignore(self.ignoreExprs[-1])
+        else:
+            super().ignore(other)
+            for e in self.exprs:
+                e.ignore(self.ignoreExprs[-1])
+        return self
+
+    def _generateDefaultName(self):
+        return "{}:({})".format(self.__class__.__name__, str(self.exprs))
+
+    def streamline(self) -> ParserElement:
+        if self.streamlined:
+            return self
+
+        super().streamline()
+
+        for e in self.exprs:
+            e.streamline()
+
+        # collapse nested :class:`And`'s of the form ``And(And(And(a, b), c), d)`` to ``And(a, b, c, d)``
+        # but only if there are no parse actions or resultsNames on the nested And's
+        # (likewise for :class:`Or`'s and :class:`MatchFirst`'s)
+        if len(self.exprs) == 2:
+            other = self.exprs[0]
+            if (
+                isinstance(other, self.__class__)
+                and not other.parseAction
+                and other.resultsName is None
+                and not other.debug
+            ):
+                self.exprs = other.exprs[:] + [self.exprs[1]]
+                self._defaultName = None
+                self.mayReturnEmpty |= other.mayReturnEmpty
+                self.mayIndexError |= other.mayIndexError
+
+            other = self.exprs[-1]
+            if (
+                isinstance(other, self.__class__)
+                and not other.parseAction
+                and other.resultsName is None
+                and not other.debug
+            ):
+                self.exprs = self.exprs[:-1] + other.exprs[:]
+                self._defaultName = None
+                self.mayReturnEmpty |= other.mayReturnEmpty
+                self.mayIndexError |= other.mayIndexError
+
+        self.errmsg = "Expected " + str(self)
+
+        return self
+
+    def validate(self, validateTrace=None) -> None:
+        tmp = (validateTrace if validateTrace is not None else [])[:] + [self]
+        for e in self.exprs:
+            e.validate(tmp)
+        self._checkRecursion([])
+
+    def copy(self) -> ParserElement:
+        ret = super().copy()
+        ret.exprs = [e.copy() for e in self.exprs]
+        return ret
+
+    def _setResultsName(self, name, listAllMatches=False):
+        if (
+            __diag__.warn_ungrouped_named_tokens_in_collection
+            and Diagnostics.warn_ungrouped_named_tokens_in_collection
+            not in self.suppress_warnings_
+        ):
+            for e in self.exprs:
+                if (
+                    isinstance(e, ParserElement)
+                    and e.resultsName
+                    and Diagnostics.warn_ungrouped_named_tokens_in_collection
+                    not in e.suppress_warnings_
+                ):
+                    warnings.warn(
+                        "{}: setting results name {!r} on {} expression "
+                        "collides with {!r} on contained expression".format(
+                            "warn_ungrouped_named_tokens_in_collection",
+                            name,
+                            type(self).__name__,
+                            e.resultsName,
+                        ),
+                        stacklevel=3,
+                    )
+
+        return super()._setResultsName(name, listAllMatches)
+
+    ignoreWhitespace = ignore_whitespace
+    leaveWhitespace = leave_whitespace
+
+
+class And(ParseExpression):
+    """
+    Requires all given :class:`ParseExpression` s to be found in the given order.
+    Expressions may be separated by whitespace.
+    May be constructed using the ``'+'`` operator.
+    May also be constructed using the ``'-'`` operator, which will
+    suppress backtracking.
+
+    Example::
+
+        integer = Word(nums)
+        name_expr = Word(alphas)[1, ...]
+
+        expr = And([integer("id"), name_expr("name"), integer("age")])
+        # more easily written as:
+        expr = integer("id") + name_expr("name") + integer("age")
+    """
+
+    class _ErrorStop(Empty):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.leave_whitespace()
+
+        def _generateDefaultName(self):
+            return "-"
+
+    def __init__(
+        self, exprs_arg: typing.Iterable[ParserElement], savelist: bool = True
+    ):
+        exprs: List[ParserElement] = list(exprs_arg)
+        if exprs and Ellipsis in exprs:
+            tmp = []
+            for i, expr in enumerate(exprs):
+                if expr is Ellipsis:
+                    if i < len(exprs) - 1:
+                        skipto_arg: ParserElement = (Empty() + exprs[i + 1]).exprs[-1]
+                        tmp.append(SkipTo(skipto_arg)("_skipped*"))
+                    else:
+                        raise Exception(
+                            "cannot construct And with sequence ending in ..."
+                        )
+                else:
+                    tmp.append(expr)
+            exprs[:] = tmp
+        super().__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+            if not isinstance(self.exprs[0], White):
+                self.set_whitespace_chars(
+                    self.exprs[0].whiteChars,
+                    copy_defaults=self.exprs[0].copyDefaultWhiteChars,
+                )
+                self.skipWhitespace = self.exprs[0].skipWhitespace
+            else:
+                self.skipWhitespace = False
+        else:
+            self.mayReturnEmpty = True
+        self.callPreparse = True
+
+    def streamline(self) -> ParserElement:
+        # collapse any _PendingSkip's
+        if self.exprs:
+            if any(
+                isinstance(e, ParseExpression)
+                and e.exprs
+                and isinstance(e.exprs[-1], _PendingSkip)
+                for e in self.exprs[:-1]
+            ):
+                for i, e in enumerate(self.exprs[:-1]):
+                    if e is None:
+                        continue
+                    if (
+                        isinstance(e, ParseExpression)
+                        and e.exprs
+                        and isinstance(e.exprs[-1], _PendingSkip)
+                    ):
+                        e.exprs[-1] = e.exprs[-1] + self.exprs[i + 1]
+                        self.exprs[i + 1] = None
+                self.exprs = [e for e in self.exprs if e is not None]
+
+        super().streamline()
+
+        # link any IndentedBlocks to the prior expression
+        for prev, cur in zip(self.exprs, self.exprs[1:]):
+            # traverse cur or any first embedded expr of cur looking for an IndentedBlock
+            # (but watch out for recursive grammar)
+            seen = set()
+            while cur:
+                if id(cur) in seen:
+                    break
+                seen.add(id(cur))
+                if isinstance(cur, IndentedBlock):
+                    prev.add_parse_action(
+                        lambda s, l, t, cur_=cur: setattr(
+                            cur_, "parent_anchor", col(l, s)
+                        )
+                    )
+                    break
+                subs = cur.recurse()
+                cur = next(iter(subs), None)
+
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        return self
+
+    def parseImpl(self, instring, loc, doActions=True):
+        # pass False as callPreParse arg to _parse for first element, since we already
+        # pre-parsed the string as part of our And pre-parsing
+        loc, resultlist = self.exprs[0]._parse(
+            instring, loc, doActions, callPreParse=False
+        )
+        errorStop = False
+        for e in self.exprs[1:]:
+            # if isinstance(e, And._ErrorStop):
+            if type(e) is And._ErrorStop:
+                errorStop = True
+                continue
+            if errorStop:
+                try:
+                    loc, exprtokens = e._parse(instring, loc, doActions)
+                except ParseSyntaxException:
+                    raise
+                except ParseBaseException as pe:
+                    pe.__traceback__ = None
+                    raise ParseSyntaxException._from_exception(pe)
+                except IndexError:
+                    raise ParseSyntaxException(
+                        instring, len(instring), self.errmsg, self
+                    )
+            else:
+                loc, exprtokens = e._parse(instring, loc, doActions)
+            if exprtokens or exprtokens.haskeys():
+                resultlist += exprtokens
+        return loc, resultlist
+
+    def __iadd__(self, other):
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        return self.append(other)  # And([self, other])
+
+    def _checkRecursion(self, parseElementList):
+        subRecCheckList = parseElementList[:] + [self]
+        for e in self.exprs:
+            e._checkRecursion(subRecCheckList)
+            if not e.mayReturnEmpty:
+                break
+
+    def _generateDefaultName(self):
+        inner = " ".join(str(e) for e in self.exprs)
+        # strip off redundant inner {}'s
+        while len(inner) > 1 and inner[0 :: len(inner) - 1] == "{}":
+            inner = inner[1:-1]
+        return "{" + inner + "}"
+
+
+class Or(ParseExpression):
+    """Requires that at least one :class:`ParseExpression` is found. If
+    two expressions match, the expression that matches the longest
+    string will be used. May be constructed using the ``'^'``
+    operator.
+
+    Example::
+
+        # construct Or using '^' operator
+
+        number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums))
+        print(number.search_string("123 3.1416 789"))
+
+    prints::
+
+        [['123'], ['3.1416'], ['789']]
+    """
+
+    def __init__(self, exprs: typing.Iterable[ParserElement], savelist: bool = False):
+        super().__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+            self.skipWhitespace = all(e.skipWhitespace for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+
+    def streamline(self) -> ParserElement:
+        super().streamline()
+        if self.exprs:
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+            self.saveAsList = any(e.saveAsList for e in self.exprs)
+            self.skipWhitespace = all(
+                e.skipWhitespace and not isinstance(e, White) for e in self.exprs
+            )
+        else:
+            self.saveAsList = False
+        return self
+
+    def parseImpl(self, instring, loc, doActions=True):
+        maxExcLoc = -1
+        maxException = None
+        matches = []
+        fatals = []
+        if all(e.callPreparse for e in self.exprs):
+            loc = self.preParse(instring, loc)
+        for e in self.exprs:
+            try:
+                loc2 = e.try_parse(instring, loc, raise_fatal=True)
+            except ParseFatalException as pfe:
+                pfe.__traceback__ = None
+                pfe.parserElement = e
+                fatals.append(pfe)
+                maxException = None
+                maxExcLoc = -1
+            except ParseException as err:
+                if not fatals:
+                    err.__traceback__ = None
+                    if err.loc > maxExcLoc:
+                        maxException = err
+                        maxExcLoc = err.loc
+            except IndexError:
+                if len(instring) > maxExcLoc:
+                    maxException = ParseException(
+                        instring, len(instring), e.errmsg, self
+                    )
+                    maxExcLoc = len(instring)
+            else:
+                # save match among all matches, to retry longest to shortest
+                matches.append((loc2, e))
+
+        if matches:
+            # re-evaluate all matches in descending order of length of match, in case attached actions
+            # might change whether or how much they match of the input.
+            matches.sort(key=itemgetter(0), reverse=True)
+
+            if not doActions:
+                # no further conditions or parse actions to change the selection of
+                # alternative, so the first match will be the best match
+                best_expr = matches[0][1]
+                return best_expr._parse(instring, loc, doActions)
+
+            longest = -1, None
+            for loc1, expr1 in matches:
+                if loc1 <= longest[0]:
+                    # already have a longer match than this one will deliver, we are done
+                    return longest
+
+                try:
+                    loc2, toks = expr1._parse(instring, loc, doActions)
+                except ParseException as err:
+                    err.__traceback__ = None
+                    if err.loc > maxExcLoc:
+                        maxException = err
+                        maxExcLoc = err.loc
+                else:
+                    if loc2 >= loc1:
+                        return loc2, toks
+                    # didn't match as much as before
+                    elif loc2 > longest[0]:
+                        longest = loc2, toks
+
+            if longest != (-1, None):
+                return longest
+
+        if fatals:
+            if len(fatals) > 1:
+                fatals.sort(key=lambda e: -e.loc)
+                if fatals[0].loc == fatals[1].loc:
+                    fatals.sort(key=lambda e: (-e.loc, -len(str(e.parserElement))))
+            max_fatal = fatals[0]
+            raise max_fatal
+
+        if maxException is not None:
+            maxException.msg = self.errmsg
+            raise maxException
+        else:
+            raise ParseException(
+                instring, loc, "no defined alternatives to match", self
+            )
+
+    def __ixor__(self, other):
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        return self.append(other)  # Or([self, other])
+
+    def _generateDefaultName(self):
+        return "{" + " ^ ".join(str(e) for e in self.exprs) + "}"
+
+    def _setResultsName(self, name, listAllMatches=False):
+        if (
+            __diag__.warn_multiple_tokens_in_named_alternation
+            and Diagnostics.warn_multiple_tokens_in_named_alternation
+            not in self.suppress_warnings_
+        ):
+            if any(
+                isinstance(e, And)
+                and Diagnostics.warn_multiple_tokens_in_named_alternation
+                not in e.suppress_warnings_
+                for e in self.exprs
+            ):
+                warnings.warn(
+                    "{}: setting results name {!r} on {} expression "
+                    "will return a list of all parsed tokens in an And alternative, "
+                    "in prior versions only the first token was returned; enclose "
+                    "contained argument in Group".format(
+                        "warn_multiple_tokens_in_named_alternation",
+                        name,
+                        type(self).__name__,
+                    ),
+                    stacklevel=3,
+                )
+
+        return super()._setResultsName(name, listAllMatches)
+
+
+class MatchFirst(ParseExpression):
+    """Requires that at least one :class:`ParseExpression` is found. If
+    more than one expression matches, the first one listed is the one that will
+    match. May be constructed using the ``'|'`` operator.
+
+    Example::
+
+        # construct MatchFirst using '|' operator
+
+        # watch the order of expressions to match
+        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))
+        print(number.search_string("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']]
+
+        # put more selective expression first
+        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)
+        print(number.search_string("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']]
+    """
+
+    def __init__(self, exprs: typing.Iterable[ParserElement], savelist: bool = False):
+        super().__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+            self.skipWhitespace = all(e.skipWhitespace for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+
+    def streamline(self) -> ParserElement:
+        if self.streamlined:
+            return self
+
+        super().streamline()
+        if self.exprs:
+            self.saveAsList = any(e.saveAsList for e in self.exprs)
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+            self.skipWhitespace = all(
+                e.skipWhitespace and not isinstance(e, White) for e in self.exprs
+            )
+        else:
+            self.saveAsList = False
+            self.mayReturnEmpty = True
+        return self
+
+    def parseImpl(self, instring, loc, doActions=True):
+        maxExcLoc = -1
+        maxException = None
+
+        for e in self.exprs:
+            try:
+                return e._parse(
+                    instring,
+                    loc,
+                    doActions,
+                )
+            except ParseFatalException as pfe:
+                pfe.__traceback__ = None
+                pfe.parserElement = e
+                raise
+            except ParseException as err:
+                if err.loc > maxExcLoc:
+                    maxException = err
+                    maxExcLoc = err.loc
+            except IndexError:
+                if len(instring) > maxExcLoc:
+                    maxException = ParseException(
+                        instring, len(instring), e.errmsg, self
+                    )
+                    maxExcLoc = len(instring)
+
+        if maxException is not None:
+            maxException.msg = self.errmsg
+            raise maxException
+        else:
+            raise ParseException(
+                instring, loc, "no defined alternatives to match", self
+            )
+
+    def __ior__(self, other):
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        return self.append(other)  # MatchFirst([self, other])
+
+    def _generateDefaultName(self):
+        return "{" + " | ".join(str(e) for e in self.exprs) + "}"
+
+    def _setResultsName(self, name, listAllMatches=False):
+        if (
+            __diag__.warn_multiple_tokens_in_named_alternation
+            and Diagnostics.warn_multiple_tokens_in_named_alternation
+            not in self.suppress_warnings_
+        ):
+            if any(
+                isinstance(e, And)
+                and Diagnostics.warn_multiple_tokens_in_named_alternation
+                not in e.suppress_warnings_
+                for e in self.exprs
+            ):
+                warnings.warn(
+                    "{}: setting results name {!r} on {} expression "
+                    "will return a list of all parsed tokens in an And alternative, "
+                    "in prior versions only the first token was returned; enclose "
+                    "contained argument in Group".format(
+                        "warn_multiple_tokens_in_named_alternation",
+                        name,
+                        type(self).__name__,
+                    ),
+                    stacklevel=3,
+                )
+
+        return super()._setResultsName(name, listAllMatches)
+
+
+class Each(ParseExpression):
+    """Requires all given :class:`ParseExpression` s to be found, but in
+    any order. Expressions may be separated by whitespace.
+
+    May be constructed using the ``'&'`` operator.
+
+    Example::
+
+        color = one_of("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")
+        shape_type = one_of("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")
+        integer = Word(nums)
+        shape_attr = "shape:" + shape_type("shape")
+        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")
+        color_attr = "color:" + color("color")
+        size_attr = "size:" + integer("size")
+
+        # use Each (using operator '&') to accept attributes in any order
+        # (shape and posn are required, color and size are optional)
+        shape_spec = shape_attr & posn_attr & Opt(color_attr) & Opt(size_attr)
+
+        shape_spec.run_tests('''
+            shape: SQUARE color: BLACK posn: 100, 120
+            shape: CIRCLE size: 50 color: BLUE posn: 50,80
+            color:GREEN size:20 shape:TRIANGLE posn:20,40
+            '''
+            )
+
+    prints::
+
+        shape: SQUARE color: BLACK posn: 100, 120
+        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]
+        - color: BLACK
+        - posn: ['100', ',', '120']
+          - x: 100
+          - y: 120
+        - shape: SQUARE
+
+
+        shape: CIRCLE size: 50 color: BLUE posn: 50,80
+        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]
+        - color: BLUE
+        - posn: ['50', ',', '80']
+          - x: 50
+          - y: 80
+        - shape: CIRCLE
+        - size: 50
+
+
+        color: GREEN size: 20 shape: TRIANGLE posn: 20,40
+        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]
+        - color: GREEN
+        - posn: ['20', ',', '40']
+          - x: 20
+          - y: 40
+        - shape: TRIANGLE
+        - size: 20
+    """
+
+    def __init__(self, exprs: typing.Iterable[ParserElement], savelist: bool = True):
+        super().__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+        self.skipWhitespace = True
+        self.initExprGroups = True
+        self.saveAsList = True
+
+    def streamline(self) -> ParserElement:
+        super().streamline()
+        if self.exprs:
+            self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+        return self
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if self.initExprGroups:
+            self.opt1map = dict(
+                (id(e.expr), e) for e in self.exprs if isinstance(e, Opt)
+            )
+            opt1 = [e.expr for e in self.exprs if isinstance(e, Opt)]
+            opt2 = [
+                e
+                for e in self.exprs
+                if e.mayReturnEmpty and not isinstance(e, (Opt, Regex, ZeroOrMore))
+            ]
+            self.optionals = opt1 + opt2
+            self.multioptionals = [
+                e.expr.set_results_name(e.resultsName, list_all_matches=True)
+                for e in self.exprs
+                if isinstance(e, _MultipleMatch)
+            ]
+            self.multirequired = [
+                e.expr.set_results_name(e.resultsName, list_all_matches=True)
+                for e in self.exprs
+                if isinstance(e, OneOrMore)
+            ]
+            self.required = [
+                e for e in self.exprs if not isinstance(e, (Opt, ZeroOrMore, OneOrMore))
+            ]
+            self.required += self.multirequired
+            self.initExprGroups = False
+
+        tmpLoc = loc
+        tmpReqd = self.required[:]
+        tmpOpt = self.optionals[:]
+        multis = self.multioptionals[:]
+        matchOrder = []
+
+        keepMatching = True
+        failed = []
+        fatals = []
+        while keepMatching:
+            tmpExprs = tmpReqd + tmpOpt + multis
+            failed.clear()
+            fatals.clear()
+            for e in tmpExprs:
+                try:
+                    tmpLoc = e.try_parse(instring, tmpLoc, raise_fatal=True)
+                except ParseFatalException as pfe:
+                    pfe.__traceback__ = None
+                    pfe.parserElement = e
+                    fatals.append(pfe)
+                    failed.append(e)
+                except ParseException:
+                    failed.append(e)
+                else:
+                    matchOrder.append(self.opt1map.get(id(e), e))
+                    if e in tmpReqd:
+                        tmpReqd.remove(e)
+                    elif e in tmpOpt:
+                        tmpOpt.remove(e)
+            if len(failed) == len(tmpExprs):
+                keepMatching = False
+
+        # look for any ParseFatalExceptions
+        if fatals:
+            if len(fatals) > 1:
+                fatals.sort(key=lambda e: -e.loc)
+                if fatals[0].loc == fatals[1].loc:
+                    fatals.sort(key=lambda e: (-e.loc, -len(str(e.parserElement))))
+            max_fatal = fatals[0]
+            raise max_fatal
+
+        if tmpReqd:
+            missing = ", ".join([str(e) for e in tmpReqd])
+            raise ParseException(
+                instring,
+                loc,
+                "Missing one or more required elements ({})".format(missing),
+            )
+
+        # add any unmatched Opts, in case they have default values defined
+        matchOrder += [e for e in self.exprs if isinstance(e, Opt) and e.expr in tmpOpt]
+
+        total_results = ParseResults([])
+        for e in matchOrder:
+            loc, results = e._parse(instring, loc, doActions)
+            total_results += results
+
+        return loc, total_results
+
+    def _generateDefaultName(self):
+        return "{" + " & ".join(str(e) for e in self.exprs) + "}"
+
+
+class ParseElementEnhance(ParserElement):
+    """Abstract subclass of :class:`ParserElement`, for combining and
+    post-processing parsed tokens.
+    """
+
+    def __init__(self, expr: Union[ParserElement, str], savelist: bool = False):
+        super().__init__(savelist)
+        if isinstance(expr, str_type):
+            if issubclass(self._literalStringClass, Token):
+                expr = self._literalStringClass(expr)
+            elif issubclass(type(self), self._literalStringClass):
+                expr = Literal(expr)
+            else:
+                expr = self._literalStringClass(Literal(expr))
+        self.expr = expr
+        if expr is not None:
+            self.mayIndexError = expr.mayIndexError
+            self.mayReturnEmpty = expr.mayReturnEmpty
+            self.set_whitespace_chars(
+                expr.whiteChars, copy_defaults=expr.copyDefaultWhiteChars
+            )
+            self.skipWhitespace = expr.skipWhitespace
+            self.saveAsList = expr.saveAsList
+            self.callPreparse = expr.callPreparse
+            self.ignoreExprs.extend(expr.ignoreExprs)
+
+    def recurse(self) -> Sequence[ParserElement]:
+        return [self.expr] if self.expr is not None else []
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if self.expr is not None:
+            return self.expr._parse(instring, loc, doActions, callPreParse=False)
+        else:
+            raise ParseException(instring, loc, "No expression defined", self)
+
+    def leave_whitespace(self, recursive: bool = True) -> ParserElement:
+        super().leave_whitespace(recursive)
+
+        if recursive:
+            self.expr = self.expr.copy()
+            if self.expr is not None:
+                self.expr.leave_whitespace(recursive)
+        return self
+
+    def ignore_whitespace(self, recursive: bool = True) -> ParserElement:
+        super().ignore_whitespace(recursive)
+
+        if recursive:
+            self.expr = self.expr.copy()
+            if self.expr is not None:
+                self.expr.ignore_whitespace(recursive)
+        return self
+
+    def ignore(self, other) -> ParserElement:
+        if isinstance(other, Suppress):
+            if other not in self.ignoreExprs:
+                super().ignore(other)
+                if self.expr is not None:
+                    self.expr.ignore(self.ignoreExprs[-1])
+        else:
+            super().ignore(other)
+            if self.expr is not None:
+                self.expr.ignore(self.ignoreExprs[-1])
+        return self
+
+    def streamline(self) -> ParserElement:
+        super().streamline()
+        if self.expr is not None:
+            self.expr.streamline()
+        return self
+
+    def _checkRecursion(self, parseElementList):
+        if self in parseElementList:
+            raise RecursiveGrammarException(parseElementList + [self])
+        subRecCheckList = parseElementList[:] + [self]
+        if self.expr is not None:
+            self.expr._checkRecursion(subRecCheckList)
+
+    def validate(self, validateTrace=None) -> None:
+        if validateTrace is None:
+            validateTrace = []
+        tmp = validateTrace[:] + [self]
+        if self.expr is not None:
+            self.expr.validate(tmp)
+        self._checkRecursion([])
+
+    def _generateDefaultName(self):
+        return "{}:({})".format(self.__class__.__name__, str(self.expr))
+
+    ignoreWhitespace = ignore_whitespace
+    leaveWhitespace = leave_whitespace
+
+
+class IndentedBlock(ParseElementEnhance):
+    """
+    Expression to match one or more expressions at a given indentation level.
+    Useful for parsing text where structure is implied by indentation (like Python source code).
+    """
+
+    class _Indent(Empty):
+        def __init__(self, ref_col: int):
+            super().__init__()
+            self.errmsg = "expected indent at column {}".format(ref_col)
+            self.add_condition(lambda s, l, t: col(l, s) == ref_col)
+
+    class _IndentGreater(Empty):
+        def __init__(self, ref_col: int):
+            super().__init__()
+            self.errmsg = "expected indent at column greater than {}".format(ref_col)
+            self.add_condition(lambda s, l, t: col(l, s) > ref_col)
+
+    def __init__(
+        self, expr: ParserElement, *, recursive: bool = False, grouped: bool = True
+    ):
+        super().__init__(expr, savelist=True)
+        # if recursive:
+        #     raise NotImplementedError("IndentedBlock with recursive is not implemented")
+        self._recursive = recursive
+        self._grouped = grouped
+        self.parent_anchor = 1
+
+    def parseImpl(self, instring, loc, doActions=True):
+        # advance parse position to non-whitespace by using an Empty()
+        # this should be the column to be used for all subsequent indented lines
+        anchor_loc = Empty().preParse(instring, loc)
+
+        # see if self.expr matches at the current location - if not it will raise an exception
+        # and no further work is necessary
+        self.expr.try_parse(instring, anchor_loc, doActions)
+
+        indent_col = col(anchor_loc, instring)
+        peer_detect_expr = self._Indent(indent_col)
+
+        inner_expr = Empty() + peer_detect_expr + self.expr
+        if self._recursive:
+            sub_indent = self._IndentGreater(indent_col)
+            nested_block = IndentedBlock(
+                self.expr, recursive=self._recursive, grouped=self._grouped
+            )
+            nested_block.set_debug(self.debug)
+            nested_block.parent_anchor = indent_col
+            inner_expr += Opt(sub_indent + nested_block)
+
+        inner_expr.set_name(f"inner {hex(id(inner_expr))[-4:].upper()}@{indent_col}")
+        block = OneOrMore(inner_expr)
+
+        trailing_undent = self._Indent(self.parent_anchor) | StringEnd()
+
+        if self._grouped:
+            wrapper = Group
+        else:
+            wrapper = lambda expr: expr
+        return (wrapper(block) + Optional(trailing_undent)).parseImpl(
+            instring, anchor_loc, doActions
+        )
+
+
+class AtStringStart(ParseElementEnhance):
+    """Matches if expression matches at the beginning of the parse
+    string::
+
+        AtStringStart(Word(nums)).parse_string("123")
+        # prints ["123"]
+
+        AtStringStart(Word(nums)).parse_string("    123")
+        # raises ParseException
+    """
+
+    def __init__(self, expr: Union[ParserElement, str]):
+        super().__init__(expr)
+        self.callPreparse = False
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if loc != 0:
+            raise ParseException(instring, loc, "not found at string start")
+        return super().parseImpl(instring, loc, doActions)
+
+
+class AtLineStart(ParseElementEnhance):
+    r"""Matches if an expression matches at the beginning of a line within
+    the parse string
+
+    Example::
+
+        test = '''\
+        AAA this line
+        AAA and this line
+          AAA but not this one
+        B AAA and definitely not this one
+        '''
+
+        for t in (AtLineStart('AAA') + restOfLine).search_string(test):
+            print(t)
+
+    prints::
+
+        ['AAA', ' this line']
+        ['AAA', ' and this line']
+
+    """
+
+    def __init__(self, expr: Union[ParserElement, str]):
+        super().__init__(expr)
+        self.callPreparse = False
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if col(loc, instring) != 1:
+            raise ParseException(instring, loc, "not found at line start")
+        return super().parseImpl(instring, loc, doActions)
+
+
+class FollowedBy(ParseElementEnhance):
+    """Lookahead matching of the given parse expression.
+    ``FollowedBy`` does *not* advance the parsing position within
+    the input string, it only verifies that the specified parse
+    expression matches at the current position.  ``FollowedBy``
+    always returns a null token list. If any results names are defined
+    in the lookahead expression, those *will* be returned for access by
+    name.
+
+    Example::
+
+        # use FollowedBy to match a label only if it is followed by a ':'
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join))
+
+        attr_expr[1, ...].parse_string("shape: SQUARE color: BLACK posn: upper left").pprint()
+
+    prints::
+
+        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]
+    """
+
+    def __init__(self, expr: Union[ParserElement, str]):
+        super().__init__(expr)
+        self.mayReturnEmpty = True
+
+    def parseImpl(self, instring, loc, doActions=True):
+        # by using self._expr.parse and deleting the contents of the returned ParseResults list
+        # we keep any named results that were defined in the FollowedBy expression
+        _, ret = self.expr._parse(instring, loc, doActions=doActions)
+        del ret[:]
+
+        return loc, ret
+
+
+class PrecededBy(ParseElementEnhance):
+    """Lookbehind matching of the given parse expression.
+    ``PrecededBy`` does not advance the parsing position within the
+    input string, it only verifies that the specified parse expression
+    matches prior to the current position.  ``PrecededBy`` always
+    returns a null token list, but if a results name is defined on the
+    given expression, it is returned.
+
+    Parameters:
+
+    - expr - expression that must match prior to the current parse
+      location
+    - retreat - (default= ``None``) - (int) maximum number of characters
+      to lookbehind prior to the current parse location
+
+    If the lookbehind expression is a string, :class:`Literal`,
+    :class:`Keyword`, or a :class:`Word` or :class:`CharsNotIn`
+    with a specified exact or maximum length, then the retreat
+    parameter is not required. Otherwise, retreat must be specified to
+    give a maximum number of characters to look back from
+    the current parse position for a lookbehind match.
+
+    Example::
+
+        # VB-style variable names with type prefixes
+        int_var = PrecededBy("#") + pyparsing_common.identifier
+        str_var = PrecededBy("$") + pyparsing_common.identifier
+
+    """
+
+    def __init__(
+        self, expr: Union[ParserElement, str], retreat: typing.Optional[int] = None
+    ):
+        super().__init__(expr)
+        self.expr = self.expr().leave_whitespace()
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.exact = False
+        if isinstance(expr, str_type):
+            retreat = len(expr)
+            self.exact = True
+        elif isinstance(expr, (Literal, Keyword)):
+            retreat = expr.matchLen
+            self.exact = True
+        elif isinstance(expr, (Word, CharsNotIn)) and expr.maxLen != _MAX_INT:
+            retreat = expr.maxLen
+            self.exact = True
+        elif isinstance(expr, PositionToken):
+            retreat = 0
+            self.exact = True
+        self.retreat = retreat
+        self.errmsg = "not preceded by " + str(expr)
+        self.skipWhitespace = False
+        self.parseAction.append(lambda s, l, t: t.__delitem__(slice(None, None)))
+
+    def parseImpl(self, instring, loc=0, doActions=True):
+        if self.exact:
+            if loc < self.retreat:
+                raise ParseException(instring, loc, self.errmsg)
+            start = loc - self.retreat
+            _, ret = self.expr._parse(instring, start)
+        else:
+            # retreat specified a maximum lookbehind window, iterate
+            test_expr = self.expr + StringEnd()
+            instring_slice = instring[max(0, loc - self.retreat) : loc]
+            last_expr = ParseException(instring, loc, self.errmsg)
+            for offset in range(1, min(loc, self.retreat + 1) + 1):
+                try:
+                    # print('trying', offset, instring_slice, repr(instring_slice[loc - offset:]))
+                    _, ret = test_expr._parse(
+                        instring_slice, len(instring_slice) - offset
+                    )
+                except ParseBaseException as pbe:
+                    last_expr = pbe
+                else:
+                    break
+            else:
+                raise last_expr
+        return loc, ret
+
+
+class Located(ParseElementEnhance):
+    """
+    Decorates a returned token with its starting and ending
+    locations in the input string.
+
+    This helper adds the following results names:
+
+    - ``locn_start`` - location where matched expression begins
+    - ``locn_end`` - location where matched expression ends
+    - ``value`` - the actual parsed results
+
+    Be careful if the input text contains ``<TAB>`` characters, you
+    may want to call :class:`ParserElement.parse_with_tabs`
+
+    Example::
+
+        wd = Word(alphas)
+        for match in Located(wd).search_string("ljsdf123lksdjjf123lkkjj1222"):
+            print(match)
+
+    prints::
+
+        [0, ['ljsdf'], 5]
+        [8, ['lksdjjf'], 15]
+        [18, ['lkkjj'], 23]
+
+    """
+
+    def parseImpl(self, instring, loc, doActions=True):
+        start = loc
+        loc, tokens = self.expr._parse(instring, start, doActions, callPreParse=False)
+        ret_tokens = ParseResults([start, tokens, loc])
+        ret_tokens["locn_start"] = start
+        ret_tokens["value"] = tokens
+        ret_tokens["locn_end"] = loc
+        if self.resultsName:
+            # must return as a list, so that the name will be attached to the complete group
+            return loc, [ret_tokens]
+        else:
+            return loc, ret_tokens
+
+
+class NotAny(ParseElementEnhance):
+    """
+    Lookahead to disallow matching with the given parse expression.
+    ``NotAny`` does *not* advance the parsing position within the
+    input string, it only verifies that the specified parse expression
+    does *not* match at the current position.  Also, ``NotAny`` does
+    *not* skip over leading whitespace. ``NotAny`` always returns
+    a null token list.  May be constructed using the ``'~'`` operator.
+
+    Example::
+
+        AND, OR, NOT = map(CaselessKeyword, "AND OR NOT".split())
+
+        # take care not to mistake keywords for identifiers
+        ident = ~(AND | OR | NOT) + Word(alphas)
+        boolean_term = Opt(NOT) + ident
+
+        # very crude boolean expression - to support parenthesis groups and
+        # operation hierarchy, use infix_notation
+        boolean_expr = boolean_term + ((AND | OR) + boolean_term)[...]
+
+        # integers that are followed by "." are actually floats
+        integer = Word(nums) + ~Char(".")
+    """
+
+    def __init__(self, expr: Union[ParserElement, str]):
+        super().__init__(expr)
+        # do NOT use self.leave_whitespace(), don't want to propagate to exprs
+        # self.leave_whitespace()
+        self.skipWhitespace = False
+
+        self.mayReturnEmpty = True
+        self.errmsg = "Found unwanted token, " + str(self.expr)
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if self.expr.can_parse_next(instring, loc):
+            raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+    def _generateDefaultName(self):
+        return "~{" + str(self.expr) + "}"
+
+
+class _MultipleMatch(ParseElementEnhance):
+    def __init__(
+        self,
+        expr: ParserElement,
+        stop_on: typing.Optional[Union[ParserElement, str]] = None,
+        *,
+        stopOn: typing.Optional[Union[ParserElement, str]] = None,
+    ):
+        super().__init__(expr)
+        stopOn = stopOn or stop_on
+        self.saveAsList = True
+        ender = stopOn
+        if isinstance(ender, str_type):
+            ender = self._literalStringClass(ender)
+        self.stopOn(ender)
+
+    def stopOn(self, ender) -> ParserElement:
+        if isinstance(ender, str_type):
+            ender = self._literalStringClass(ender)
+        self.not_ender = ~ender if ender is not None else None
+        return self
+
+    def parseImpl(self, instring, loc, doActions=True):
+        self_expr_parse = self.expr._parse
+        self_skip_ignorables = self._skipIgnorables
+        check_ender = self.not_ender is not None
+        if check_ender:
+            try_not_ender = self.not_ender.tryParse
+
+        # must be at least one (but first see if we are the stopOn sentinel;
+        # if so, fail)
+        if check_ender:
+            try_not_ender(instring, loc)
+        loc, tokens = self_expr_parse(instring, loc, doActions)
+        try:
+            hasIgnoreExprs = not not self.ignoreExprs
+            while 1:
+                if check_ender:
+                    try_not_ender(instring, loc)
+                if hasIgnoreExprs:
+                    preloc = self_skip_ignorables(instring, loc)
+                else:
+                    preloc = loc
+                loc, tmptokens = self_expr_parse(instring, preloc, doActions)
+                if tmptokens or tmptokens.haskeys():
+                    tokens += tmptokens
+        except (ParseException, IndexError):
+            pass
+
+        return loc, tokens
+
+    def _setResultsName(self, name, listAllMatches=False):
+        if (
+            __diag__.warn_ungrouped_named_tokens_in_collection
+            and Diagnostics.warn_ungrouped_named_tokens_in_collection
+            not in self.suppress_warnings_
+        ):
+            for e in [self.expr] + self.expr.recurse():
+                if (
+                    isinstance(e, ParserElement)
+                    and e.resultsName
+                    and Diagnostics.warn_ungrouped_named_tokens_in_collection
+                    not in e.suppress_warnings_
+                ):
+                    warnings.warn(
+                        "{}: setting results name {!r} on {} expression "
+                        "collides with {!r} on contained expression".format(
+                            "warn_ungrouped_named_tokens_in_collection",
+                            name,
+                            type(self).__name__,
+                            e.resultsName,
+                        ),
+                        stacklevel=3,
+                    )
+
+        return super()._setResultsName(name, listAllMatches)
+
+
+class OneOrMore(_MultipleMatch):
+    """
+    Repetition of one or more of the given expression.
+
+    Parameters:
+    - expr - expression that must match one or more times
+    - stop_on - (default= ``None``) - expression for a terminating sentinel
+         (only required if the sentinel would ordinarily match the repetition
+         expression)
+
+    Example::
+
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).set_parse_action(' '.join))
+
+        text = "shape: SQUARE posn: upper left color: BLACK"
+        attr_expr[1, ...].parse_string(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]
+
+        # use stop_on attribute for OneOrMore to avoid reading label string as part of the data
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join))
+        OneOrMore(attr_expr).parse_string(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]
+
+        # could also be written as
+        (attr_expr * (1,)).parse_string(text).pprint()
+    """
+
+    def _generateDefaultName(self):
+        return "{" + str(self.expr) + "}..."
+
+
+class ZeroOrMore(_MultipleMatch):
+    """
+    Optional repetition of zero or more of the given expression.
+
+    Parameters:
+    - ``expr`` - expression that must match zero or more times
+    - ``stop_on`` - expression for a terminating sentinel
+      (only required if the sentinel would ordinarily match the repetition
+      expression) - (default= ``None``)
+
+    Example: similar to :class:`OneOrMore`
+    """
+
+    def __init__(
+        self,
+        expr: ParserElement,
+        stop_on: typing.Optional[Union[ParserElement, str]] = None,
+        *,
+        stopOn: typing.Optional[Union[ParserElement, str]] = None,
+    ):
+        super().__init__(expr, stopOn=stopOn or stop_on)
+        self.mayReturnEmpty = True
+
+    def parseImpl(self, instring, loc, doActions=True):
+        try:
+            return super().parseImpl(instring, loc, doActions)
+        except (ParseException, IndexError):
+            return loc, ParseResults([], name=self.resultsName)
+
+    def _generateDefaultName(self):
+        return "[" + str(self.expr) + "]..."
+
+
+class _NullToken:
+    def __bool__(self):
+        return False
+
+    def __str__(self):
+        return ""
+
+
+class Opt(ParseElementEnhance):
+    """
+    Optional matching of the given expression.
+
+    Parameters:
+    - ``expr`` - expression that must match zero or more times
+    - ``default`` (optional) - value to be returned if the optional expression is not found.
+
+    Example::
+
+        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier
+        zip = Combine(Word(nums, exact=5) + Opt('-' + Word(nums, exact=4)))
+        zip.run_tests('''
+            # traditional ZIP code
+            12345
+
+            # ZIP+4 form
+            12101-0001
+
+            # invalid ZIP
+            98765-
+            ''')
+
+    prints::
+
+        # traditional ZIP code
+        12345
+        ['12345']
+
+        # ZIP+4 form
+        12101-0001
+        ['12101-0001']
+
+        # invalid ZIP
+        98765-
+             ^
+        FAIL: Expected end of text (at char 5), (line:1, col:6)
+    """
+
+    __optionalNotMatched = _NullToken()
+
+    def __init__(
+        self, expr: Union[ParserElement, str], default: Any = __optionalNotMatched
+    ):
+        super().__init__(expr, savelist=False)
+        self.saveAsList = self.expr.saveAsList
+        self.defaultValue = default
+        self.mayReturnEmpty = True
+
+    def parseImpl(self, instring, loc, doActions=True):
+        self_expr = self.expr
+        try:
+            loc, tokens = self_expr._parse(instring, loc, doActions, callPreParse=False)
+        except (ParseException, IndexError):
+            default_value = self.defaultValue
+            if default_value is not self.__optionalNotMatched:
+                if self_expr.resultsName:
+                    tokens = ParseResults([default_value])
+                    tokens[self_expr.resultsName] = default_value
+                else:
+                    tokens = [default_value]
+            else:
+                tokens = []
+        return loc, tokens
+
+    def _generateDefaultName(self):
+        inner = str(self.expr)
+        # strip off redundant inner {}'s
+        while len(inner) > 1 and inner[0 :: len(inner) - 1] == "{}":
+            inner = inner[1:-1]
+        return "[" + inner + "]"
+
+
+Optional = Opt
+
+
+class SkipTo(ParseElementEnhance):
+    """
+    Token for skipping over all undefined text until the matched
+    expression is found.
+
+    Parameters:
+    - ``expr`` - target expression marking the end of the data to be skipped
+    - ``include`` - if ``True``, the target expression is also parsed
+      (the skipped text and target expression are returned as a 2-element
+      list) (default= ``False``).
+    - ``ignore`` - (default= ``None``) used to define grammars (typically quoted strings and
+      comments) that might contain false matches to the target expression
+    - ``fail_on`` - (default= ``None``) define expressions that are not allowed to be
+      included in the skipped test; if found before the target expression is found,
+      the :class:`SkipTo` is not a match
+
+    Example::
+
+        report = '''
+            Outstanding Issues Report - 1 Jan 2000
+
+               # | Severity | Description                               |  Days Open
+            -----+----------+-------------------------------------------+-----------
+             101 | Critical | Intermittent system crash                 |          6
+              94 | Cosmetic | Spelling error on Login ('log|n')         |         14
+              79 | Minor    | System slow when running too many reports |         47
+            '''
+        integer = Word(nums)
+        SEP = Suppress('|')
+        # use SkipTo to simply match everything up until the next SEP
+        # - ignore quoted strings, so that a '|' character inside a quoted string does not match
+        # - parse action will call token.strip() for each matched token, i.e., the description body
+        string_data = SkipTo(SEP, ignore=quoted_string)
+        string_data.set_parse_action(token_map(str.strip))
+        ticket_expr = (integer("issue_num") + SEP
+                      + string_data("sev") + SEP
+                      + string_data("desc") + SEP
+                      + integer("days_open"))
+
+        for tkt in ticket_expr.search_string(report):
+            print tkt.dump()
+
+    prints::
+
+        ['101', 'Critical', 'Intermittent system crash', '6']
+        - days_open: '6'
+        - desc: 'Intermittent system crash'
+        - issue_num: '101'
+        - sev: 'Critical'
+        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']
+        - days_open: '14'
+        - desc: "Spelling error on Login ('log|n')"
+        - issue_num: '94'
+        - sev: 'Cosmetic'
+        ['79', 'Minor', 'System slow when running too many reports', '47']
+        - days_open: '47'
+        - desc: 'System slow when running too many reports'
+        - issue_num: '79'
+        - sev: 'Minor'
+    """
+
+    def __init__(
+        self,
+        other: Union[ParserElement, str],
+        include: bool = False,
+        ignore: bool = None,
+        fail_on: typing.Optional[Union[ParserElement, str]] = None,
+        *,
+        failOn: Union[ParserElement, str] = None,
+    ):
+        super().__init__(other)
+        failOn = failOn or fail_on
+        self.ignoreExpr = ignore
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.includeMatch = include
+        self.saveAsList = False
+        if isinstance(failOn, str_type):
+            self.failOn = self._literalStringClass(failOn)
+        else:
+            self.failOn = failOn
+        self.errmsg = "No match found for " + str(self.expr)
+
+    def parseImpl(self, instring, loc, doActions=True):
+        startloc = loc
+        instrlen = len(instring)
+        self_expr_parse = self.expr._parse
+        self_failOn_canParseNext = (
+            self.failOn.canParseNext if self.failOn is not None else None
+        )
+        self_ignoreExpr_tryParse = (
+            self.ignoreExpr.tryParse if self.ignoreExpr is not None else None
+        )
+
+        tmploc = loc
+        while tmploc <= instrlen:
+            if self_failOn_canParseNext is not None:
+                # break if failOn expression matches
+                if self_failOn_canParseNext(instring, tmploc):
+                    break
+
+            if self_ignoreExpr_tryParse is not None:
+                # advance past ignore expressions
+                while 1:
+                    try:
+                        tmploc = self_ignoreExpr_tryParse(instring, tmploc)
+                    except ParseBaseException:
+                        break
+
+            try:
+                self_expr_parse(instring, tmploc, doActions=False, callPreParse=False)
+            except (ParseException, IndexError):
+                # no match, advance loc in string
+                tmploc += 1
+            else:
+                # matched skipto expr, done
+                break
+
+        else:
+            # ran off the end of the input string without matching skipto expr, fail
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        # build up return values
+        loc = tmploc
+        skiptext = instring[startloc:loc]
+        skipresult = ParseResults(skiptext)
+
+        if self.includeMatch:
+            loc, mat = self_expr_parse(instring, loc, doActions, callPreParse=False)
+            skipresult += mat
+
+        return loc, skipresult
+
+
+class Forward(ParseElementEnhance):
+    """
+    Forward declaration of an expression to be defined later -
+    used for recursive grammars, such as algebraic infix notation.
+    When the expression is known, it is assigned to the ``Forward``
+    variable using the ``'<<'`` operator.
+
+    Note: take care when assigning to ``Forward`` not to overlook
+    precedence of operators.
+
+    Specifically, ``'|'`` has a lower precedence than ``'<<'``, so that::
+
+        fwd_expr << a | b | c
+
+    will actually be evaluated as::
+
+        (fwd_expr << a) | b | c
+
+    thereby leaving b and c out as parseable alternatives.  It is recommended that you
+    explicitly group the values inserted into the ``Forward``::
+
+        fwd_expr << (a | b | c)
+
+    Converting to use the ``'<<='`` operator instead will avoid this problem.
+
+    See :class:`ParseResults.pprint` for an example of a recursive
+    parser created using ``Forward``.
+    """
+
+    def __init__(self, other: typing.Optional[Union[ParserElement, str]] = None):
+        self.caller_frame = traceback.extract_stack(limit=2)[0]
+        super().__init__(other, savelist=False)
+        self.lshift_line = None
+
+    def __lshift__(self, other):
+        if hasattr(self, "caller_frame"):
+            del self.caller_frame
+        if isinstance(other, str_type):
+            other = self._literalStringClass(other)
+        self.expr = other
+        self.mayIndexError = self.expr.mayIndexError
+        self.mayReturnEmpty = self.expr.mayReturnEmpty
+        self.set_whitespace_chars(
+            self.expr.whiteChars, copy_defaults=self.expr.copyDefaultWhiteChars
+        )
+        self.skipWhitespace = self.expr.skipWhitespace
+        self.saveAsList = self.expr.saveAsList
+        self.ignoreExprs.extend(self.expr.ignoreExprs)
+        self.lshift_line = traceback.extract_stack(limit=2)[-2]
+        return self
+
+    def __ilshift__(self, other):
+        return self << other
+
+    def __or__(self, other):
+        caller_line = traceback.extract_stack(limit=2)[-2]
+        if (
+            __diag__.warn_on_match_first_with_lshift_operator
+            and caller_line == self.lshift_line
+            and Diagnostics.warn_on_match_first_with_lshift_operator
+            not in self.suppress_warnings_
+        ):
+            warnings.warn(
+                "using '<<' operator with '|' is probably an error, use '<<='",
+                stacklevel=2,
+            )
+        ret = super().__or__(other)
+        return ret
+
+    def __del__(self):
+        # see if we are getting dropped because of '=' reassignment of var instead of '<<=' or '<<'
+        if (
+            self.expr is None
+            and __diag__.warn_on_assignment_to_Forward
+            and Diagnostics.warn_on_assignment_to_Forward not in self.suppress_warnings_
+        ):
+            warnings.warn_explicit(
+                "Forward defined here but no expression attached later using '<<=' or '<<'",
+                UserWarning,
+                filename=self.caller_frame.filename,
+                lineno=self.caller_frame.lineno,
+            )
+
+    def parseImpl(self, instring, loc, doActions=True):
+        if (
+            self.expr is None
+            and __diag__.warn_on_parse_using_empty_Forward
+            and Diagnostics.warn_on_parse_using_empty_Forward
+            not in self.suppress_warnings_
+        ):
+            # walk stack until parse_string, scan_string, search_string, or transform_string is found
+            parse_fns = [
+                "parse_string",
+                "scan_string",
+                "search_string",
+                "transform_string",
+            ]
+            tb = traceback.extract_stack(limit=200)
+            for i, frm in enumerate(reversed(tb), start=1):
+                if frm.name in parse_fns:
+                    stacklevel = i + 1
+                    break
+            else:
+                stacklevel = 2
+            warnings.warn(
+                "Forward expression was never assigned a value, will not parse any input",
+                stacklevel=stacklevel,
+            )
+        if not ParserElement._left_recursion_enabled:
+            return super().parseImpl(instring, loc, doActions)
+        # ## Bounded Recursion algorithm ##
+        # Recursion only needs to be processed at ``Forward`` elements, since they are
+        # the only ones that can actually refer to themselves. The general idea is
+        # to handle recursion stepwise: We start at no recursion, then recurse once,
+        # recurse twice, ..., until more recursion offers no benefit (we hit the bound).
+        #
+        # The "trick" here is that each ``Forward`` gets evaluated in two contexts
+        # - to *match* a specific recursion level, and
+        # - to *search* the bounded recursion level
+        # and the two run concurrently. The *search* must *match* each recursion level
+        # to find the best possible match. This is handled by a memo table, which
+        # provides the previous match to the next level match attempt.
+        #
+        # See also "Left Recursion in Parsing Expression Grammars", Medeiros et al.
+        #
+        # There is a complication since we not only *parse* but also *transform* via
+        # actions: We do not want to run the actions too often while expanding. Thus,
+        # we expand using `doActions=False` and only run `doActions=True` if the next
+        # recursion level is acceptable.
+        with ParserElement.recursion_lock:
+            memo = ParserElement.recursion_memos
+            try:
+                # we are parsing at a specific recursion expansion - use it as-is
+                prev_loc, prev_result = memo[loc, self, doActions]
+                if isinstance(prev_result, Exception):
+                    raise prev_result
+                return prev_loc, prev_result.copy()
+            except KeyError:
+                act_key = (loc, self, True)
+                peek_key = (loc, self, False)
+                # we are searching for the best recursion expansion - keep on improving
+                # both `doActions` cases must be tracked separately here!
+                prev_loc, prev_peek = memo[peek_key] = (
+                    loc - 1,
+                    ParseException(
+                        instring, loc, "Forward recursion without base case", self
+                    ),
+                )
+                if doActions:
+                    memo[act_key] = memo[peek_key]
+                while True:
+                    try:
+                        new_loc, new_peek = super().parseImpl(instring, loc, False)
+                    except ParseException:
+                        # we failed before getting any match – do not hide the error
+                        if isinstance(prev_peek, Exception):
+                            raise
+                        new_loc, new_peek = prev_loc, prev_peek
+                    # the match did not get better: we are done
+                    if new_loc <= prev_loc:
+                        if doActions:
+                            # replace the match for doActions=False as well,
+                            # in case the action did backtrack
+                            prev_loc, prev_result = memo[peek_key] = memo[act_key]
+                            del memo[peek_key], memo[act_key]
+                            return prev_loc, prev_result.copy()
+                        del memo[peek_key]
+                        return prev_loc, prev_peek.copy()
+                    # the match did get better: see if we can improve further
+                    else:
+                        if doActions:
+                            try:
+                                memo[act_key] = super().parseImpl(instring, loc, True)
+                            except ParseException as e:
+                                memo[peek_key] = memo[act_key] = (new_loc, e)
+                                raise
+                        prev_loc, prev_peek = memo[peek_key] = new_loc, new_peek
+
+    def leave_whitespace(self, recursive: bool = True) -> ParserElement:
+        self.skipWhitespace = False
+        return self
+
+    def ignore_whitespace(self, recursive: bool = True) -> ParserElement:
+        self.skipWhitespace = True
+        return self
+
+    def streamline(self) -> ParserElement:
+        if not self.streamlined:
+            self.streamlined = True
+            if self.expr is not None:
+                self.expr.streamline()
+        return self
+
+    def validate(self, validateTrace=None) -> None:
+        if validateTrace is None:
+            validateTrace = []
+
+        if self not in validateTrace:
+            tmp = validateTrace[:] + [self]
+            if self.expr is not None:
+                self.expr.validate(tmp)
+        self._checkRecursion([])
+
+    def _generateDefaultName(self):
+        # Avoid infinite recursion by setting a temporary _defaultName
+        self._defaultName = ": ..."
+
+        # Use the string representation of main expression.
+        retString = "..."
+        try:
+            if self.expr is not None:
+                retString = str(self.expr)[:1000]
+            else:
+                retString = "None"
+        finally:
+            return self.__class__.__name__ + ": " + retString
+
+    def copy(self) -> ParserElement:
+        if self.expr is not None:
+            return super().copy()
+        else:
+            ret = Forward()
+            ret <<= self
+            return ret
+
+    def _setResultsName(self, name, list_all_matches=False):
+        if (
+            __diag__.warn_name_set_on_empty_Forward
+            and Diagnostics.warn_name_set_on_empty_Forward
+            not in self.suppress_warnings_
+        ):
+            if self.expr is None:
+                warnings.warn(
+                    "{}: setting results name {!r} on {} expression "
+                    "that has no contained expression".format(
+                        "warn_name_set_on_empty_Forward", name, type(self).__name__
+                    ),
+                    stacklevel=3,
+                )
+
+        return super()._setResultsName(name, list_all_matches)
+
+    ignoreWhitespace = ignore_whitespace
+    leaveWhitespace = leave_whitespace
+
+
+class TokenConverter(ParseElementEnhance):
+    """
+    Abstract subclass of :class:`ParseExpression`, for converting parsed results.
+    """
+
+    def __init__(self, expr: Union[ParserElement, str], savelist=False):
+        super().__init__(expr)  # , savelist)
+        self.saveAsList = False
+
+
+class Combine(TokenConverter):
+    """Converter to concatenate all matching tokens to a single string.
+    By default, the matching patterns must also be contiguous in the
+    input string; this can be disabled by specifying
+    ``'adjacent=False'`` in the constructor.
+
+    Example::
+
+        real = Word(nums) + '.' + Word(nums)
+        print(real.parse_string('3.1416')) # -> ['3', '.', '1416']
+        # will also erroneously match the following
+        print(real.parse_string('3. 1416')) # -> ['3', '.', '1416']
+
+        real = Combine(Word(nums) + '.' + Word(nums))
+        print(real.parse_string('3.1416')) # -> ['3.1416']
+        # no match when there are internal spaces
+        print(real.parse_string('3. 1416')) # -> Exception: Expected W:(0123...)
+    """
+
+    def __init__(
+        self,
+        expr: ParserElement,
+        join_string: str = "",
+        adjacent: bool = True,
+        *,
+        joinString: typing.Optional[str] = None,
+    ):
+        super().__init__(expr)
+        joinString = joinString if joinString is not None else join_string
+        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself
+        if adjacent:
+            self.leave_whitespace()
+        self.adjacent = adjacent
+        self.skipWhitespace = True
+        self.joinString = joinString
+        self.callPreparse = True
+
+    def ignore(self, other) -> ParserElement:
+        if self.adjacent:
+            ParserElement.ignore(self, other)
+        else:
+            super().ignore(other)
+        return self
+
+    def postParse(self, instring, loc, tokenlist):
+        retToks = tokenlist.copy()
+        del retToks[:]
+        retToks += ParseResults(
+            ["".join(tokenlist._asStringList(self.joinString))], modal=self.modalResults
+        )
+
+        if self.resultsName and retToks.haskeys():
+            return [retToks]
+        else:
+            return retToks
+
+
+class Group(TokenConverter):
+    """Converter to return the matched tokens as a list - useful for
+    returning tokens of :class:`ZeroOrMore` and :class:`OneOrMore` expressions.
+
+    The optional ``aslist`` argument when set to True will return the
+    parsed tokens as a Python list instead of a pyparsing ParseResults.
+
+    Example::
+
+        ident = Word(alphas)
+        num = Word(nums)
+        term = ident | num
+        func = ident + Opt(delimited_list(term))
+        print(func.parse_string("fn a, b, 100"))
+        # -> ['fn', 'a', 'b', '100']
+
+        func = ident + Group(Opt(delimited_list(term)))
+        print(func.parse_string("fn a, b, 100"))
+        # -> ['fn', ['a', 'b', '100']]
+    """
+
+    def __init__(self, expr: ParserElement, aslist: bool = False):
+        super().__init__(expr)
+        self.saveAsList = True
+        self._asPythonList = aslist
+
+    def postParse(self, instring, loc, tokenlist):
+        if self._asPythonList:
+            return ParseResults.List(
+                tokenlist.asList()
+                if isinstance(tokenlist, ParseResults)
+                else list(tokenlist)
+            )
+        else:
+            return [tokenlist]
+
+
+class Dict(TokenConverter):
+    """Converter to return a repetitive expression as a list, but also
+    as a dictionary. Each element can also be referenced using the first
+    token in the expression as its key. Useful for tabular report
+    scraping when the first column can be used as a item key.
+
+    The optional ``asdict`` argument when set to True will return the
+    parsed tokens as a Python dict instead of a pyparsing ParseResults.
+
+    Example::
+
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join))
+
+        # print attributes as plain groups
+        print(attr_expr[1, ...].parse_string(text).dump())
+
+        # instead of OneOrMore(expr), parse using Dict(Group(expr)[1, ...]) - Dict will auto-assign names
+        result = Dict(Group(attr_expr)[1, ...]).parse_string(text)
+        print(result.dump())
+
+        # access named fields as dict entries, or output as dict
+        print(result['shape'])
+        print(result.as_dict())
+
+    prints::
+
+        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
+        - color: 'light blue'
+        - posn: 'upper left'
+        - shape: 'SQUARE'
+        - texture: 'burlap'
+        SQUARE
+        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}
+
+    See more examples at :class:`ParseResults` of accessing fields by results name.
+    """
+
+    def __init__(self, expr: ParserElement, asdict: bool = False):
+        super().__init__(expr)
+        self.saveAsList = True
+        self._asPythonDict = asdict
+
+    def postParse(self, instring, loc, tokenlist):
+        for i, tok in enumerate(tokenlist):
+            if len(tok) == 0:
+                continue
+
+            ikey = tok[0]
+            if isinstance(ikey, int):
+                ikey = str(ikey).strip()
+
+            if len(tok) == 1:
+                tokenlist[ikey] = _ParseResultsWithOffset("", i)
+
+            elif len(tok) == 2 and not isinstance(tok[1], ParseResults):
+                tokenlist[ikey] = _ParseResultsWithOffset(tok[1], i)
+
+            else:
+                try:
+                    dictvalue = tok.copy()  # ParseResults(i)
+                except Exception:
+                    exc = TypeError(
+                        "could not extract dict values from parsed results"
+                        " - Dict expression must contain Grouped expressions"
+                    )
+                    raise exc from None
+
+                del dictvalue[0]
+
+                if len(dictvalue) != 1 or (
+                    isinstance(dictvalue, ParseResults) and dictvalue.haskeys()
+                ):
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue, i)
+                else:
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0], i)
+
+        if self._asPythonDict:
+            return [tokenlist.as_dict()] if self.resultsName else tokenlist.as_dict()
+        else:
+            return [tokenlist] if self.resultsName else tokenlist
+
+
+class Suppress(TokenConverter):
+    """Converter for ignoring the results of a parsed expression.
+
+    Example::
+
+        source = "a, b, c,d"
+        wd = Word(alphas)
+        wd_list1 = wd + (',' + wd)[...]
+        print(wd_list1.parse_string(source))
+
+        # often, delimiters that are useful during parsing are just in the
+        # way afterward - use Suppress to keep them out of the parsed output
+        wd_list2 = wd + (Suppress(',') + wd)[...]
+        print(wd_list2.parse_string(source))
+
+        # Skipped text (using '...') can be suppressed as well
+        source = "lead in START relevant text END trailing text"
+        start_marker = Keyword("START")
+        end_marker = Keyword("END")
+        find_body = Suppress(...) + start_marker + ... + end_marker
+        print(find_body.parse_string(source)
+
+    prints::
+
+        ['a', ',', 'b', ',', 'c', ',', 'd']
+        ['a', 'b', 'c', 'd']
+        ['START', 'relevant text ', 'END']
+
+    (See also :class:`delimited_list`.)
+    """
+
+    def __init__(self, expr: Union[ParserElement, str], savelist: bool = False):
+        if expr is ...:
+            expr = _PendingSkip(NoMatch())
+        super().__init__(expr)
+
+    def __add__(self, other) -> "ParserElement":
+        if isinstance(self.expr, _PendingSkip):
+            return Suppress(SkipTo(other)) + other
+        else:
+            return super().__add__(other)
+
+    def __sub__(self, other) -> "ParserElement":
+        if isinstance(self.expr, _PendingSkip):
+            return Suppress(SkipTo(other)) - other
+        else:
+            return super().__sub__(other)
+
+    def postParse(self, instring, loc, tokenlist):
+        return []
+
+    def suppress(self) -> ParserElement:
+        return self
+
+
+def trace_parse_action(f: ParseAction) -> ParseAction:
+    """Decorator for debugging parse actions.
+
+    When the parse action is called, this decorator will print
+    ``">> entering method-name(line:<current_source_line>, <parse_location>, <matched_tokens>)"``.
+    When the parse action completes, the decorator will print
+    ``"<<"`` followed by the returned value, or any exception that the parse action raised.
+
+    Example::
+
+        wd = Word(alphas)
+
+        @trace_parse_action
+        def remove_duplicate_chars(tokens):
+            return ''.join(sorted(set(''.join(tokens))))
+
+        wds = wd[1, ...].set_parse_action(remove_duplicate_chars)
+        print(wds.parse_string("slkdjs sld sldd sdlf sdljf"))
+
+    prints::
+
+        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))
+        <<leaving remove_duplicate_chars (ret: 'dfjkls')
+        ['dfjkls']
+    """
+    f = _trim_arity(f)
+
+    def z(*paArgs):
+        thisFunc = f.__name__
+        s, l, t = paArgs[-3:]
+        if len(paArgs) > 3:
+            thisFunc = paArgs[0].__class__.__name__ + "." + thisFunc
+        sys.stderr.write(
+            ">>entering {}(line: {!r}, {}, {!r})\n".format(thisFunc, line(l, s), l, t)
+        )
+        try:
+            ret = f(*paArgs)
+        except Exception as exc:
+            sys.stderr.write("<<leaving {} (exception: {})\n".format(thisFunc, exc))
+            raise
+        sys.stderr.write("<<leaving {} (ret: {!r})\n".format(thisFunc, ret))
+        return ret
+
+    z.__name__ = f.__name__
+    return z
+
+
+# convenience constants for positional expressions
+empty = Empty().set_name("empty")
+line_start = LineStart().set_name("line_start")
+line_end = LineEnd().set_name("line_end")
+string_start = StringStart().set_name("string_start")
+string_end = StringEnd().set_name("string_end")
+
+_escapedPunc = Word(_bslash, r"\[]-*.$+^?()~ ", exact=2).set_parse_action(
+    lambda s, l, t: t[0][1]
+)
+_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").set_parse_action(
+    lambda s, l, t: chr(int(t[0].lstrip(r"\0x"), 16))
+)
+_escapedOctChar = Regex(r"\\0[0-7]+").set_parse_action(
+    lambda s, l, t: chr(int(t[0][1:], 8))
+)
+_singleChar = (
+    _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r"\]", exact=1)
+)
+_charRange = Group(_singleChar + Suppress("-") + _singleChar)
+_reBracketExpr = (
+    Literal("[")
+    + Opt("^").set_results_name("negate")
+    + Group(OneOrMore(_charRange | _singleChar)).set_results_name("body")
+    + "]"
+)
+
+
+def srange(s: str) -> str:
+    r"""Helper to easily define string ranges for use in :class:`Word`
+    construction. Borrows syntax from regexp ``'[]'`` string range
+    definitions::
+
+        srange("[0-9]")   -> "0123456789"
+        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz"
+        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"
+
+    The input string must be enclosed in []'s, and the returned string
+    is the expanded character set joined into a single string. The
+    values enclosed in the []'s may be:
+
+    - a single character
+    - an escaped character with a leading backslash (such as ``\-``
+      or ``\]``)
+    - an escaped hex character with a leading ``'\x'``
+      (``\x21``, which is a ``'!'`` character) (``\0x##``
+      is also supported for backwards compatibility)
+    - an escaped octal character with a leading ``'\0'``
+      (``\041``, which is a ``'!'`` character)
+    - a range of any of the above, separated by a dash (``'a-z'``,
+      etc.)
+    - any combination of the above (``'aeiouy'``,
+      ``'a-zA-Z0-9_$'``, etc.)
+    """
+    _expanded = (
+        lambda p: p
+        if not isinstance(p, ParseResults)
+        else "".join(chr(c) for c in range(ord(p[0]), ord(p[1]) + 1))
+    )
+    try:
+        return "".join(_expanded(part) for part in _reBracketExpr.parse_string(s).body)
+    except Exception:
+        return ""
+
+
+def token_map(func, *args) -> ParseAction:
+    """Helper to define a parse action by mapping a function to all
+    elements of a :class:`ParseResults` list. If any additional args are passed,
+    they are forwarded to the given function as additional arguments
+    after the token, as in
+    ``hex_integer = Word(hexnums).set_parse_action(token_map(int, 16))``,
+    which will convert the parsed data to an integer using base 16.
+
+    Example (compare the last to example in :class:`ParserElement.transform_string`::
+
+        hex_ints = Word(hexnums)[1, ...].set_parse_action(token_map(int, 16))
+        hex_ints.run_tests('''
+            00 11 22 aa FF 0a 0d 1a
+            ''')
+
+        upperword = Word(alphas).set_parse_action(token_map(str.upper))
+        upperword[1, ...].run_tests('''
+            my kingdom for a horse
+            ''')
+
+        wd = Word(alphas).set_parse_action(token_map(str.title))
+        wd[1, ...].set_parse_action(' '.join).run_tests('''
+            now is the winter of our discontent made glorious summer by this sun of york
+            ''')
+
+    prints::
+
+        00 11 22 aa FF 0a 0d 1a
+        [0, 17, 34, 170, 255, 10, 13, 26]
+
+        my kingdom for a horse
+        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE']
+
+        now is the winter of our discontent made glorious summer by this sun of york
+        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York']
+    """
+
+    def pa(s, l, t):
+        return [func(tokn, *args) for tokn in t]
+
+    func_name = getattr(func, "__name__", getattr(func, "__class__").__name__)
+    pa.__name__ = func_name
+
+    return pa
+
+
+def autoname_elements() -> None:
+    """
+    Utility to simplify mass-naming of parser elements, for
+    generating railroad diagram with named subdiagrams.
+    """
+    for name, var in sys._getframe().f_back.f_locals.items():
+        if isinstance(var, ParserElement) and not var.customName:
+            var.set_name(name)
+
+
+dbl_quoted_string = Combine(
+    Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*') + '"'
+).set_name("string enclosed in double quotes")
+
+sgl_quoted_string = Combine(
+    Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*") + "'"
+).set_name("string enclosed in single quotes")
+
+quoted_string = Combine(
+    Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*') + '"'
+    | Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*") + "'"
+).set_name("quotedString using single or double quotes")
+
+unicode_string = Combine("u" + quoted_string.copy()).set_name("unicode string literal")
+
+
+alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")
+punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")
+
+# build list of built-in expressions, for future reference if a global default value
+# gets updated
+_builtin_exprs: List[ParserElement] = [
+    v for v in vars().values() if isinstance(v, ParserElement)
+]
+
+# backward compatibility names
+tokenMap = token_map
+conditionAsParseAction = condition_as_parse_action
+nullDebugAction = null_debug_action
+sglQuotedString = sgl_quoted_string
+dblQuotedString = dbl_quoted_string
+quotedString = quoted_string
+unicodeString = unicode_string
+lineStart = line_start
+lineEnd = line_end
+stringStart = string_start
+stringEnd = string_end
+traceParseAction = trace_parse_action
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/diagram/__init__.py b/myenv/lib/python3.9/site-packages/pyparsing/diagram/__init__.py
new file mode 100644
index 0000000..8986447
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing/diagram/__init__.py
@@ -0,0 +1,642 @@
+import railroad
+import pyparsing
+import typing
+from typing import (
+    List,
+    NamedTuple,
+    Generic,
+    TypeVar,
+    Dict,
+    Callable,
+    Set,
+    Iterable,
+)
+from jinja2 import Template
+from io import StringIO
+import inspect
+
+
+jinja2_template_source = """\
+<!DOCTYPE html>
+<html>
+<head>
+    {% if not head %}
+        <style type="text/css">
+            .railroad-heading {
+                font-family: monospace;
+            }
+        </style>
+    {% else %}
+        {{ head | safe }}
+    {% endif %}
+</head>
+<body>
+{{ body | safe }}
+{% for diagram in diagrams %}
+    <div class="railroad-group">
+        <h1 class="railroad-heading">{{ diagram.title }}</h1>
+        <div class="railroad-description">{{ diagram.text }}</div>
+        <div class="railroad-svg">
+            {{ diagram.svg }}
+        </div>
+    </div>
+{% endfor %}
+</body>
+</html>
+"""
+
+template = Template(jinja2_template_source)
+
+# Note: ideally this would be a dataclass, but we're supporting Python 3.5+ so we can't do this yet
+NamedDiagram = NamedTuple(
+    "NamedDiagram",
+    [("name", str), ("diagram", typing.Optional[railroad.DiagramItem]), ("index", int)],
+)
+"""
+A simple structure for associating a name with a railroad diagram
+"""
+
+T = TypeVar("T")
+
+
+class EachItem(railroad.Group):
+    """
+    Custom railroad item to compose a:
+    - Group containing a
+      - OneOrMore containing a
+        - Choice of the elements in the Each
+    with the group label indicating that all must be matched
+    """
+
+    all_label = "[ALL]"
+
+    def __init__(self, *items):
+        choice_item = railroad.Choice(len(items) - 1, *items)
+        one_or_more_item = railroad.OneOrMore(item=choice_item)
+        super().__init__(one_or_more_item, label=self.all_label)
+
+
+class AnnotatedItem(railroad.Group):
+    """
+    Simple subclass of Group that creates an annotation label
+    """
+
+    def __init__(self, label: str, item):
+        super().__init__(item=item, label="[{}]".format(label) if label else label)
+
+
+class EditablePartial(Generic[T]):
+    """
+    Acts like a functools.partial, but can be edited. In other words, it represents a type that hasn't yet been
+    constructed.
+    """
+
+    # We need this here because the railroad constructors actually transform the data, so can't be called until the
+    # entire tree is assembled
+
+    def __init__(self, func: Callable[..., T], args: list, kwargs: dict):
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+
+    @classmethod
+    def from_call(cls, func: Callable[..., T], *args, **kwargs) -> "EditablePartial[T]":
+        """
+        If you call this function in the same way that you would call the constructor, it will store the arguments
+        as you expect. For example EditablePartial.from_call(Fraction, 1, 3)() == Fraction(1, 3)
+        """
+        return EditablePartial(func=func, args=list(args), kwargs=kwargs)
+
+    @property
+    def name(self):
+        return self.kwargs["name"]
+
+    def __call__(self) -> T:
+        """
+        Evaluate the partial and return the result
+        """
+        args = self.args.copy()
+        kwargs = self.kwargs.copy()
+
+        # This is a helpful hack to allow you to specify varargs parameters (e.g. *args) as keyword args (e.g.
+        # args=['list', 'of', 'things'])
+        arg_spec = inspect.getfullargspec(self.func)
+        if arg_spec.varargs in self.kwargs:
+            args += kwargs.pop(arg_spec.varargs)
+
+        return self.func(*args, **kwargs)
+
+
+def railroad_to_html(diagrams: List[NamedDiagram], **kwargs) -> str:
+    """
+    Given a list of NamedDiagram, produce a single HTML string that visualises those diagrams
+    :params kwargs: kwargs to be passed in to the template
+    """
+    data = []
+    for diagram in diagrams:
+        if diagram.diagram is None:
+            continue
+        io = StringIO()
+        diagram.diagram.writeSvg(io.write)
+        title = diagram.name
+        if diagram.index == 0:
+            title += " (root)"
+        data.append({"title": title, "text": "", "svg": io.getvalue()})
+
+    return template.render(diagrams=data, **kwargs)
+
+
+def resolve_partial(partial: "EditablePartial[T]") -> T:
+    """
+    Recursively resolves a collection of Partials into whatever type they are
+    """
+    if isinstance(partial, EditablePartial):
+        partial.args = resolve_partial(partial.args)
+        partial.kwargs = resolve_partial(partial.kwargs)
+        return partial()
+    elif isinstance(partial, list):
+        return [resolve_partial(x) for x in partial]
+    elif isinstance(partial, dict):
+        return {key: resolve_partial(x) for key, x in partial.items()}
+    else:
+        return partial
+
+
+def to_railroad(
+    element: pyparsing.ParserElement,
+    diagram_kwargs: typing.Optional[dict] = None,
+    vertical: int = 3,
+    show_results_names: bool = False,
+    show_groups: bool = False,
+) -> List[NamedDiagram]:
+    """
+    Convert a pyparsing element tree into a list of diagrams. This is the recommended entrypoint to diagram
+    creation if you want to access the Railroad tree before it is converted to HTML
+    :param element: base element of the parser being diagrammed
+    :param diagram_kwargs: kwargs to pass to the Diagram() constructor
+    :param vertical: (optional) - int - limit at which number of alternatives should be
+       shown vertically instead of horizontally
+    :param show_results_names - bool to indicate whether results name annotations should be
+       included in the diagram
+    :param show_groups - bool to indicate whether groups should be highlighted with an unlabeled
+       surrounding box
+    """
+    # Convert the whole tree underneath the root
+    lookup = ConverterState(diagram_kwargs=diagram_kwargs or {})
+    _to_diagram_element(
+        element,
+        lookup=lookup,
+        parent=None,
+        vertical=vertical,
+        show_results_names=show_results_names,
+        show_groups=show_groups,
+    )
+
+    root_id = id(element)
+    # Convert the root if it hasn't been already
+    if root_id in lookup:
+        if not element.customName:
+            lookup[root_id].name = ""
+        lookup[root_id].mark_for_extraction(root_id, lookup, force=True)
+
+    # Now that we're finished, we can convert from intermediate structures into Railroad elements
+    diags = list(lookup.diagrams.values())
+    if len(diags) > 1:
+        # collapse out duplicate diags with the same name
+        seen = set()
+        deduped_diags = []
+        for d in diags:
+            # don't extract SkipTo elements, they are uninformative as subdiagrams
+            if d.name == "...":
+                continue
+            if d.name is not None and d.name not in seen:
+                seen.add(d.name)
+                deduped_diags.append(d)
+        resolved = [resolve_partial(partial) for partial in deduped_diags]
+    else:
+        # special case - if just one diagram, always display it, even if
+        # it has no name
+        resolved = [resolve_partial(partial) for partial in diags]
+    return sorted(resolved, key=lambda diag: diag.index)
+
+
+def _should_vertical(
+    specification: int, exprs: Iterable[pyparsing.ParserElement]
+) -> bool:
+    """
+    Returns true if we should return a vertical list of elements
+    """
+    if specification is None:
+        return False
+    else:
+        return len(_visible_exprs(exprs)) >= specification
+
+
+class ElementState:
+    """
+    State recorded for an individual pyparsing Element
+    """
+
+    # Note: this should be a dataclass, but we have to support Python 3.5
+    def __init__(
+        self,
+        element: pyparsing.ParserElement,
+        converted: EditablePartial,
+        parent: EditablePartial,
+        number: int,
+        name: str = None,
+        parent_index: typing.Optional[int] = None,
+    ):
+        #: The pyparsing element that this represents
+        self.element: pyparsing.ParserElement = element
+        #: The name of the element
+        self.name: typing.Optional[str] = name
+        #: The output Railroad element in an unconverted state
+        self.converted: EditablePartial = converted
+        #: The parent Railroad element, which we store so that we can extract this if it's duplicated
+        self.parent: EditablePartial = parent
+        #: The order in which we found this element, used for sorting diagrams if this is extracted into a diagram
+        self.number: int = number
+        #: The index of this inside its parent
+        self.parent_index: typing.Optional[int] = parent_index
+        #: If true, we should extract this out into a subdiagram
+        self.extract: bool = False
+        #: If true, all of this element's children have been filled out
+        self.complete: bool = False
+
+    def mark_for_extraction(
+        self, el_id: int, state: "ConverterState", name: str = None, force: bool = False
+    ):
+        """
+        Called when this instance has been seen twice, and thus should eventually be extracted into a sub-diagram
+        :param el_id: id of the element
+        :param state: element/diagram state tracker
+        :param name: name to use for this element's text
+        :param force: If true, force extraction now, regardless of the state of this. Only useful for extracting the
+        root element when we know we're finished
+        """
+        self.extract = True
+
+        # Set the name
+        if not self.name:
+            if name:
+                # Allow forcing a custom name
+                self.name = name
+            elif self.element.customName:
+                self.name = self.element.customName
+            else:
+                self.name = ""
+
+        # Just because this is marked for extraction doesn't mean we can do it yet. We may have to wait for children
+        # to be added
+        # Also, if this is just a string literal etc, don't bother extracting it
+        if force or (self.complete and _worth_extracting(self.element)):
+            state.extract_into_diagram(el_id)
+
+
+class ConverterState:
+    """
+    Stores some state that persists between recursions into the element tree
+    """
+
+    def __init__(self, diagram_kwargs: typing.Optional[dict] = None):
+        #: A dictionary mapping ParserElements to state relating to them
+        self._element_diagram_states: Dict[int, ElementState] = {}
+        #: A dictionary mapping ParserElement IDs to subdiagrams generated from them
+        self.diagrams: Dict[int, EditablePartial[NamedDiagram]] = {}
+        #: The index of the next unnamed element
+        self.unnamed_index: int = 1
+        #: The index of the next element. This is used for sorting
+        self.index: int = 0
+        #: Shared kwargs that are used to customize the construction of diagrams
+        self.diagram_kwargs: dict = diagram_kwargs or {}
+        self.extracted_diagram_names: Set[str] = set()
+
+    def __setitem__(self, key: int, value: ElementState):
+        self._element_diagram_states[key] = value
+
+    def __getitem__(self, key: int) -> ElementState:
+        return self._element_diagram_states[key]
+
+    def __delitem__(self, key: int):
+        del self._element_diagram_states[key]
+
+    def __contains__(self, key: int):
+        return key in self._element_diagram_states
+
+    def generate_unnamed(self) -> int:
+        """
+        Generate a number used in the name of an otherwise unnamed diagram
+        """
+        self.unnamed_index += 1
+        return self.unnamed_index
+
+    def generate_index(self) -> int:
+        """
+        Generate a number used to index a diagram
+        """
+        self.index += 1
+        return self.index
+
+    def extract_into_diagram(self, el_id: int):
+        """
+        Used when we encounter the same token twice in the same tree. When this
+        happens, we replace all instances of that token with a terminal, and
+        create a new subdiagram for the token
+        """
+        position = self[el_id]
+
+        # Replace the original definition of this element with a regular block
+        if position.parent:
+            ret = EditablePartial.from_call(railroad.NonTerminal, text=position.name)
+            if "item" in position.parent.kwargs:
+                position.parent.kwargs["item"] = ret
+            elif "items" in position.parent.kwargs:
+                position.parent.kwargs["items"][position.parent_index] = ret
+
+        # If the element we're extracting is a group, skip to its content but keep the title
+        if position.converted.func == railroad.Group:
+            content = position.converted.kwargs["item"]
+        else:
+            content = position.converted
+
+        self.diagrams[el_id] = EditablePartial.from_call(
+            NamedDiagram,
+            name=position.name,
+            diagram=EditablePartial.from_call(
+                railroad.Diagram, content, **self.diagram_kwargs
+            ),
+            index=position.number,
+        )
+
+        del self[el_id]
+
+
+def _worth_extracting(element: pyparsing.ParserElement) -> bool:
+    """
+    Returns true if this element is worth having its own sub-diagram. Simply, if any of its children
+    themselves have children, then its complex enough to extract
+    """
+    children = element.recurse()
+    return any(child.recurse() for child in children)
+
+
+def _apply_diagram_item_enhancements(fn):
+    """
+    decorator to ensure enhancements to a diagram item (such as results name annotations)
+    get applied on return from _to_diagram_element (we do this since there are several
+    returns in _to_diagram_element)
+    """
+
+    def _inner(
+        element: pyparsing.ParserElement,
+        parent: typing.Optional[EditablePartial],
+        lookup: ConverterState = None,
+        vertical: int = None,
+        index: int = 0,
+        name_hint: str = None,
+        show_results_names: bool = False,
+        show_groups: bool = False,
+    ) -> typing.Optional[EditablePartial]:
+
+        ret = fn(
+            element,
+            parent,
+            lookup,
+            vertical,
+            index,
+            name_hint,
+            show_results_names,
+            show_groups,
+        )
+
+        # apply annotation for results name, if present
+        if show_results_names and ret is not None:
+            element_results_name = element.resultsName
+            if element_results_name:
+                # add "*" to indicate if this is a "list all results" name
+                element_results_name += "" if element.modalResults else "*"
+                ret = EditablePartial.from_call(
+                    railroad.Group, item=ret, label=element_results_name
+                )
+
+        return ret
+
+    return _inner
+
+
+def _visible_exprs(exprs: Iterable[pyparsing.ParserElement]):
+    non_diagramming_exprs = (
+        pyparsing.ParseElementEnhance,
+        pyparsing.PositionToken,
+        pyparsing.And._ErrorStop,
+    )
+    return [
+        e
+        for e in exprs
+        if not (e.customName or e.resultsName or isinstance(e, non_diagramming_exprs))
+    ]
+
+
+@_apply_diagram_item_enhancements
+def _to_diagram_element(
+    element: pyparsing.ParserElement,
+    parent: typing.Optional[EditablePartial],
+    lookup: ConverterState = None,
+    vertical: int = None,
+    index: int = 0,
+    name_hint: str = None,
+    show_results_names: bool = False,
+    show_groups: bool = False,
+) -> typing.Optional[EditablePartial]:
+    """
+    Recursively converts a PyParsing Element to a railroad Element
+    :param lookup: The shared converter state that keeps track of useful things
+    :param index: The index of this element within the parent
+    :param parent: The parent of this element in the output tree
+    :param vertical: Controls at what point we make a list of elements vertical. If this is an integer (the default),
+    it sets the threshold of the number of items before we go vertical. If True, always go vertical, if False, never
+    do so
+    :param name_hint: If provided, this will override the generated name
+    :param show_results_names: bool flag indicating whether to add annotations for results names
+    :returns: The converted version of the input element, but as a Partial that hasn't yet been constructed
+    :param show_groups: bool flag indicating whether to show groups using bounding box
+    """
+    exprs = element.recurse()
+    name = name_hint or element.customName or element.__class__.__name__
+
+    # Python's id() is used to provide a unique identifier for elements
+    el_id = id(element)
+
+    element_results_name = element.resultsName
+
+    # Here we basically bypass processing certain wrapper elements if they contribute nothing to the diagram
+    if not element.customName:
+        if isinstance(
+            element,
+            (
+                # pyparsing.TokenConverter,
+                # pyparsing.Forward,
+                pyparsing.Located,
+            ),
+        ):
+            # However, if this element has a useful custom name, and its child does not, we can pass it on to the child
+            if exprs:
+                if not exprs[0].customName:
+                    propagated_name = name
+                else:
+                    propagated_name = None
+
+                return _to_diagram_element(
+                    element.expr,
+                    parent=parent,
+                    lookup=lookup,
+                    vertical=vertical,
+                    index=index,
+                    name_hint=propagated_name,
+                    show_results_names=show_results_names,
+                    show_groups=show_groups,
+                )
+
+    # If the element isn't worth extracting, we always treat it as the first time we say it
+    if _worth_extracting(element):
+        if el_id in lookup:
+            # If we've seen this element exactly once before, we are only just now finding out that it's a duplicate,
+            # so we have to extract it into a new diagram.
+            looked_up = lookup[el_id]
+            looked_up.mark_for_extraction(el_id, lookup, name=name_hint)
+            ret = EditablePartial.from_call(railroad.NonTerminal, text=looked_up.name)
+            return ret
+
+        elif el_id in lookup.diagrams:
+            # If we have seen the element at least twice before, and have already extracted it into a subdiagram, we
+            # just put in a marker element that refers to the sub-diagram
+            ret = EditablePartial.from_call(
+                railroad.NonTerminal, text=lookup.diagrams[el_id].kwargs["name"]
+            )
+            return ret
+
+    # Recursively convert child elements
+    # Here we find the most relevant Railroad element for matching pyparsing Element
+    # We use ``items=[]`` here to hold the place for where the child elements will go once created
+    if isinstance(element, pyparsing.And):
+        # detect And's created with ``expr*N`` notation - for these use a OneOrMore with a repeat
+        # (all will have the same name, and resultsName)
+        if not exprs:
+            return None
+        if len(set((e.name, e.resultsName) for e in exprs)) == 1:
+            ret = EditablePartial.from_call(
+                railroad.OneOrMore, item="", repeat=str(len(exprs))
+            )
+        elif _should_vertical(vertical, exprs):
+            ret = EditablePartial.from_call(railroad.Stack, items=[])
+        else:
+            ret = EditablePartial.from_call(railroad.Sequence, items=[])
+    elif isinstance(element, (pyparsing.Or, pyparsing.MatchFirst)):
+        if not exprs:
+            return None
+        if _should_vertical(vertical, exprs):
+            ret = EditablePartial.from_call(railroad.Choice, 0, items=[])
+        else:
+            ret = EditablePartial.from_call(railroad.HorizontalChoice, items=[])
+    elif isinstance(element, pyparsing.Each):
+        if not exprs:
+            return None
+        ret = EditablePartial.from_call(EachItem, items=[])
+    elif isinstance(element, pyparsing.NotAny):
+        ret = EditablePartial.from_call(AnnotatedItem, label="NOT", item="")
+    elif isinstance(element, pyparsing.FollowedBy):
+        ret = EditablePartial.from_call(AnnotatedItem, label="LOOKAHEAD", item="")
+    elif isinstance(element, pyparsing.PrecededBy):
+        ret = EditablePartial.from_call(AnnotatedItem, label="LOOKBEHIND", item="")
+    elif isinstance(element, pyparsing.Group):
+        if show_groups:
+            ret = EditablePartial.from_call(AnnotatedItem, label="", item="")
+        else:
+            ret = EditablePartial.from_call(railroad.Group, label="", item="")
+    elif isinstance(element, pyparsing.TokenConverter):
+        ret = EditablePartial.from_call(
+            AnnotatedItem, label=type(element).__name__.lower(), item=""
+        )
+    elif isinstance(element, pyparsing.Opt):
+        ret = EditablePartial.from_call(railroad.Optional, item="")
+    elif isinstance(element, pyparsing.OneOrMore):
+        ret = EditablePartial.from_call(railroad.OneOrMore, item="")
+    elif isinstance(element, pyparsing.ZeroOrMore):
+        ret = EditablePartial.from_call(railroad.ZeroOrMore, item="")
+    elif isinstance(element, pyparsing.Group):
+        ret = EditablePartial.from_call(
+            railroad.Group, item=None, label=element_results_name
+        )
+    elif isinstance(element, pyparsing.Empty) and not element.customName:
+        # Skip unnamed "Empty" elements
+        ret = None
+    elif len(exprs) > 1:
+        ret = EditablePartial.from_call(railroad.Sequence, items=[])
+    elif len(exprs) > 0 and not element_results_name:
+        ret = EditablePartial.from_call(railroad.Group, item="", label=name)
+    else:
+        terminal = EditablePartial.from_call(railroad.Terminal, element.defaultName)
+        ret = terminal
+
+    if ret is None:
+        return
+
+    # Indicate this element's position in the tree so we can extract it if necessary
+    lookup[el_id] = ElementState(
+        element=element,
+        converted=ret,
+        parent=parent,
+        parent_index=index,
+        number=lookup.generate_index(),
+    )
+    if element.customName:
+        lookup[el_id].mark_for_extraction(el_id, lookup, element.customName)
+
+    i = 0
+    for expr in exprs:
+        # Add a placeholder index in case we have to extract the child before we even add it to the parent
+        if "items" in ret.kwargs:
+            ret.kwargs["items"].insert(i, None)
+
+        item = _to_diagram_element(
+            expr,
+            parent=ret,
+            lookup=lookup,
+            vertical=vertical,
+            index=i,
+            show_results_names=show_results_names,
+            show_groups=show_groups,
+        )
+
+        # Some elements don't need to be shown in the diagram
+        if item is not None:
+            if "item" in ret.kwargs:
+                ret.kwargs["item"] = item
+            elif "items" in ret.kwargs:
+                # If we've already extracted the child, don't touch this index, since it's occupied by a nonterminal
+                ret.kwargs["items"][i] = item
+                i += 1
+        elif "items" in ret.kwargs:
+            # If we're supposed to skip this element, remove it from the parent
+            del ret.kwargs["items"][i]
+
+    # If all this items children are none, skip this item
+    if ret and (
+        ("items" in ret.kwargs and len(ret.kwargs["items"]) == 0)
+        or ("item" in ret.kwargs and ret.kwargs["item"] is None)
+    ):
+        ret = EditablePartial.from_call(railroad.Terminal, name)
+
+    # Mark this element as "complete", ie it has all of its children
+    if el_id in lookup:
+        lookup[el_id].complete = True
+
+    if el_id in lookup and lookup[el_id].extract and lookup[el_id].complete:
+        lookup.extract_into_diagram(el_id)
+        if ret is not None:
+            ret = EditablePartial.from_call(
+                railroad.NonTerminal, text=lookup.diagrams[el_id].kwargs["name"]
+            )
+
+    return ret
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/exceptions.py b/myenv/lib/python3.9/site-packages/pyparsing/exceptions.py
new file mode 100644
index 0000000..a38447b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing/exceptions.py
@@ -0,0 +1,267 @@
+# exceptions.py
+
+import re
+import sys
+import typing
+
+from .util import col, line, lineno, _collapse_string_to_ranges
+from .unicode import pyparsing_unicode as ppu
+
+
+class ExceptionWordUnicode(ppu.Latin1, ppu.LatinA, ppu.LatinB, ppu.Greek, ppu.Cyrillic):
+    pass
+
+
+_extract_alphanums = _collapse_string_to_ranges(ExceptionWordUnicode.alphanums)
+_exception_word_extractor = re.compile("([" + _extract_alphanums + "]{1,16})|.")
+
+
+class ParseBaseException(Exception):
+    """base exception class for all parsing runtime exceptions"""
+
+    # Performance tuning: we construct a *lot* of these, so keep this
+    # constructor as small and fast as possible
+    def __init__(
+        self,
+        pstr: str,
+        loc: int = 0,
+        msg: typing.Optional[str] = None,
+        elem=None,
+    ):
+        self.loc = loc
+        if msg is None:
+            self.msg = pstr
+            self.pstr = ""
+        else:
+            self.msg = msg
+            self.pstr = pstr
+        self.parser_element = self.parserElement = elem
+        self.args = (pstr, loc, msg)
+
+    @staticmethod
+    def explain_exception(exc, depth=16):
+        """
+        Method to take an exception and translate the Python internal traceback into a list
+        of the pyparsing expressions that caused the exception to be raised.
+
+        Parameters:
+
+        - exc - exception raised during parsing (need not be a ParseException, in support
+          of Python exceptions that might be raised in a parse action)
+        - depth (default=16) - number of levels back in the stack trace to list expression
+          and function names; if None, the full stack trace names will be listed; if 0, only
+          the failing input line, marker, and exception string will be shown
+
+        Returns a multi-line string listing the ParserElements and/or function names in the
+        exception's stack trace.
+        """
+        import inspect
+        from .core import ParserElement
+
+        if depth is None:
+            depth = sys.getrecursionlimit()
+        ret = []
+        if isinstance(exc, ParseBaseException):
+            ret.append(exc.line)
+            ret.append(" " * (exc.column - 1) + "^")
+        ret.append("{}: {}".format(type(exc).__name__, exc))
+
+        if depth > 0:
+            callers = inspect.getinnerframes(exc.__traceback__, context=depth)
+            seen = set()
+            for i, ff in enumerate(callers[-depth:]):
+                frm = ff[0]
+
+                f_self = frm.f_locals.get("self", None)
+                if isinstance(f_self, ParserElement):
+                    if frm.f_code.co_name not in ("parseImpl", "_parseNoCache"):
+                        continue
+                    if id(f_self) in seen:
+                        continue
+                    seen.add(id(f_self))
+
+                    self_type = type(f_self)
+                    ret.append(
+                        "{}.{} - {}".format(
+                            self_type.__module__, self_type.__name__, f_self
+                        )
+                    )
+
+                elif f_self is not None:
+                    self_type = type(f_self)
+                    ret.append("{}.{}".format(self_type.__module__, self_type.__name__))
+
+                else:
+                    code = frm.f_code
+                    if code.co_name in ("wrapper", "<module>"):
+                        continue
+
+                    ret.append("{}".format(code.co_name))
+
+                depth -= 1
+                if not depth:
+                    break
+
+        return "\n".join(ret)
+
+    @classmethod
+    def _from_exception(cls, pe):
+        """
+        internal factory method to simplify creating one type of ParseException
+        from another - avoids having __init__ signature conflicts among subclasses
+        """
+        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement)
+
+    @property
+    def line(self) -> str:
+        """
+        Return the line of text where the exception occurred.
+        """
+        return line(self.loc, self.pstr)
+
+    @property
+    def lineno(self) -> int:
+        """
+        Return the 1-based line number of text where the exception occurred.
+        """
+        return lineno(self.loc, self.pstr)
+
+    @property
+    def col(self) -> int:
+        """
+        Return the 1-based column on the line of text where the exception occurred.
+        """
+        return col(self.loc, self.pstr)
+
+    @property
+    def column(self) -> int:
+        """
+        Return the 1-based column on the line of text where the exception occurred.
+        """
+        return col(self.loc, self.pstr)
+
+    def __str__(self) -> str:
+        if self.pstr:
+            if self.loc >= len(self.pstr):
+                foundstr = ", found end of text"
+            else:
+                # pull out next word at error location
+                found_match = _exception_word_extractor.match(self.pstr, self.loc)
+                if found_match is not None:
+                    found = found_match.group(0)
+                else:
+                    found = self.pstr[self.loc : self.loc + 1]
+                foundstr = (", found %r" % found).replace(r"\\", "\\")
+        else:
+            foundstr = ""
+        return "{}{}  (at char {}), (line:{}, col:{})".format(
+            self.msg, foundstr, self.loc, self.lineno, self.column
+        )
+
+    def __repr__(self):
+        return str(self)
+
+    def mark_input_line(self, marker_string: str = None, *, markerString=">!<") -> str:
+        """
+        Extracts the exception line from the input string, and marks
+        the location of the exception with a special symbol.
+        """
+        markerString = marker_string if marker_string is not None else markerString
+        line_str = self.line
+        line_column = self.column - 1
+        if markerString:
+            line_str = "".join(
+                (line_str[:line_column], markerString, line_str[line_column:])
+            )
+        return line_str.strip()
+
+    def explain(self, depth=16) -> str:
+        """
+        Method to translate the Python internal traceback into a list
+        of the pyparsing expressions that caused the exception to be raised.
+
+        Parameters:
+
+        - depth (default=16) - number of levels back in the stack trace to list expression
+          and function names; if None, the full stack trace names will be listed; if 0, only
+          the failing input line, marker, and exception string will be shown
+
+        Returns a multi-line string listing the ParserElements and/or function names in the
+        exception's stack trace.
+
+        Example::
+
+            expr = pp.Word(pp.nums) * 3
+            try:
+                expr.parse_string("123 456 A789")
+            except pp.ParseException as pe:
+                print(pe.explain(depth=0))
+
+        prints::
+
+            123 456 A789
+                    ^
+            ParseException: Expected W:(0-9), found 'A'  (at char 8), (line:1, col:9)
+
+        Note: the diagnostic output will include string representations of the expressions
+        that failed to parse. These representations will be more helpful if you use `set_name` to
+        give identifiable names to your expressions. Otherwise they will use the default string
+        forms, which may be cryptic to read.
+
+        Note: pyparsing's default truncation of exception tracebacks may also truncate the
+        stack of expressions that are displayed in the ``explain`` output. To get the full listing
+        of parser expressions, you may have to set ``ParserElement.verbose_stacktrace = True``
+        """
+        return self.explain_exception(self, depth)
+
+    markInputline = mark_input_line
+
+
+class ParseException(ParseBaseException):
+    """
+    Exception thrown when a parse expression doesn't match the input string
+
+    Example::
+
+        try:
+            Word(nums).set_name("integer").parse_string("ABC")
+        except ParseException as pe:
+            print(pe)
+            print("column: {}".format(pe.column))
+
+    prints::
+
+       Expected integer (at char 0), (line:1, col:1)
+        column: 1
+
+    """
+
+
+class ParseFatalException(ParseBaseException):
+    """
+    User-throwable exception thrown when inconsistent parse content
+    is found; stops all parsing immediately
+    """
+
+
+class ParseSyntaxException(ParseFatalException):
+    """
+    Just like :class:`ParseFatalException`, but thrown internally
+    when an :class:`ErrorStop<And._ErrorStop>` ('-' operator) indicates
+    that parsing is to stop immediately because an unbacktrackable
+    syntax error has been found.
+    """
+
+
+class RecursiveGrammarException(Exception):
+    """
+    Exception thrown by :class:`ParserElement.validate` if the
+    grammar could be left-recursive; parser may need to enable
+    left recursion using :class:`ParserElement.enable_left_recursion<ParserElement.enable_left_recursion>`
+    """
+
+    def __init__(self, parseElementList):
+        self.parseElementTrace = parseElementList
+
+    def __str__(self) -> str:
+        return "RecursiveGrammarException: {}".format(self.parseElementTrace)
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/helpers.py b/myenv/lib/python3.9/site-packages/pyparsing/helpers.py
new file mode 100644
index 0000000..9588b3b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing/helpers.py
@@ -0,0 +1,1088 @@
+# helpers.py
+import html.entities
+import re
+import typing
+
+from . import __diag__
+from .core import *
+from .util import _bslash, _flatten, _escape_regex_range_chars
+
+
+#
+# global helpers
+#
+def delimited_list(
+    expr: Union[str, ParserElement],
+    delim: Union[str, ParserElement] = ",",
+    combine: bool = False,
+    min: typing.Optional[int] = None,
+    max: typing.Optional[int] = None,
+    *,
+    allow_trailing_delim: bool = False,
+) -> ParserElement:
+    """Helper to define a delimited list of expressions - the delimiter
+    defaults to ','. By default, the list elements and delimiters can
+    have intervening whitespace, and comments, but this can be
+    overridden by passing ``combine=True`` in the constructor. If
+    ``combine`` is set to ``True``, the matching tokens are
+    returned as a single token string, with the delimiters included;
+    otherwise, the matching tokens are returned as a list of tokens,
+    with the delimiters suppressed.
+
+    If ``allow_trailing_delim`` is set to True, then the list may end with
+    a delimiter.
+
+    Example::
+
+        delimited_list(Word(alphas)).parse_string("aa,bb,cc") # -> ['aa', 'bb', 'cc']
+        delimited_list(Word(hexnums), delim=':', combine=True).parse_string("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
+    """
+    if isinstance(expr, str_type):
+        expr = ParserElement._literalStringClass(expr)
+
+    dlName = "{expr} [{delim} {expr}]...{end}".format(
+        expr=str(expr.copy().streamline()),
+        delim=str(delim),
+        end=" [{}]".format(str(delim)) if allow_trailing_delim else "",
+    )
+
+    if not combine:
+        delim = Suppress(delim)
+
+    if min is not None:
+        if min < 1:
+            raise ValueError("min must be greater than 0")
+        min -= 1
+    if max is not None:
+        if min is not None and max <= min:
+            raise ValueError("max must be greater than, or equal to min")
+        max -= 1
+    delimited_list_expr = expr + (delim + expr)[min, max]
+
+    if allow_trailing_delim:
+        delimited_list_expr += Opt(delim)
+
+    if combine:
+        return Combine(delimited_list_expr).set_name(dlName)
+    else:
+        return delimited_list_expr.set_name(dlName)
+
+
+def counted_array(
+    expr: ParserElement,
+    int_expr: typing.Optional[ParserElement] = None,
+    *,
+    intExpr: typing.Optional[ParserElement] = None,
+) -> ParserElement:
+    """Helper to define a counted list of expressions.
+
+    This helper defines a pattern of the form::
+
+        integer expr expr expr...
+
+    where the leading integer tells how many expr expressions follow.
+    The matched tokens returns the array of expr tokens as a list - the
+    leading count token is suppressed.
+
+    If ``int_expr`` is specified, it should be a pyparsing expression
+    that produces an integer value.
+
+    Example::
+
+        counted_array(Word(alphas)).parse_string('2 ab cd ef')  # -> ['ab', 'cd']
+
+        # in this parser, the leading integer value is given in binary,
+        # '10' indicating that 2 values are in the array
+        binary_constant = Word('01').set_parse_action(lambda t: int(t[0], 2))
+        counted_array(Word(alphas), int_expr=binary_constant).parse_string('10 ab cd ef')  # -> ['ab', 'cd']
+
+        # if other fields must be parsed after the count but before the
+        # list items, give the fields results names and they will
+        # be preserved in the returned ParseResults:
+        count_with_metadata = integer + Word(alphas)("type")
+        typed_array = counted_array(Word(alphanums), int_expr=count_with_metadata)("items")
+        result = typed_array.parse_string("3 bool True True False")
+        print(result.dump())
+
+        # prints
+        # ['True', 'True', 'False']
+        # - items: ['True', 'True', 'False']
+        # - type: 'bool'
+    """
+    intExpr = intExpr or int_expr
+    array_expr = Forward()
+
+    def count_field_parse_action(s, l, t):
+        nonlocal array_expr
+        n = t[0]
+        array_expr <<= (expr * n) if n else Empty()
+        # clear list contents, but keep any named results
+        del t[:]
+
+    if intExpr is None:
+        intExpr = Word(nums).set_parse_action(lambda t: int(t[0]))
+    else:
+        intExpr = intExpr.copy()
+    intExpr.set_name("arrayLen")
+    intExpr.add_parse_action(count_field_parse_action, call_during_try=True)
+    return (intExpr + array_expr).set_name("(len) " + str(expr) + "...")
+
+
+def match_previous_literal(expr: ParserElement) -> ParserElement:
+    """Helper to define an expression that is indirectly defined from
+    the tokens matched in a previous expression, that is, it looks for
+    a 'repeat' of a previous expression.  For example::
+
+        first = Word(nums)
+        second = match_previous_literal(first)
+        match_expr = first + ":" + second
+
+    will match ``"1:1"``, but not ``"1:2"``.  Because this
+    matches a previous literal, will also match the leading
+    ``"1:1"`` in ``"1:10"``. If this is not desired, use
+    :class:`match_previous_expr`. Do *not* use with packrat parsing
+    enabled.
+    """
+    rep = Forward()
+
+    def copy_token_to_repeater(s, l, t):
+        if t:
+            if len(t) == 1:
+                rep << t[0]
+            else:
+                # flatten t tokens
+                tflat = _flatten(t.as_list())
+                rep << And(Literal(tt) for tt in tflat)
+        else:
+            rep << Empty()
+
+    expr.add_parse_action(copy_token_to_repeater, callDuringTry=True)
+    rep.set_name("(prev) " + str(expr))
+    return rep
+
+
+def match_previous_expr(expr: ParserElement) -> ParserElement:
+    """Helper to define an expression that is indirectly defined from
+    the tokens matched in a previous expression, that is, it looks for
+    a 'repeat' of a previous expression.  For example::
+
+        first = Word(nums)
+        second = match_previous_expr(first)
+        match_expr = first + ":" + second
+
+    will match ``"1:1"``, but not ``"1:2"``.  Because this
+    matches by expressions, will *not* match the leading ``"1:1"``
+    in ``"1:10"``; the expressions are evaluated first, and then
+    compared, so ``"1"`` is compared with ``"10"``. Do *not* use
+    with packrat parsing enabled.
+    """
+    rep = Forward()
+    e2 = expr.copy()
+    rep <<= e2
+
+    def copy_token_to_repeater(s, l, t):
+        matchTokens = _flatten(t.as_list())
+
+        def must_match_these_tokens(s, l, t):
+            theseTokens = _flatten(t.as_list())
+            if theseTokens != matchTokens:
+                raise ParseException(
+                    s, l, "Expected {}, found{}".format(matchTokens, theseTokens)
+                )
+
+        rep.set_parse_action(must_match_these_tokens, callDuringTry=True)
+
+    expr.add_parse_action(copy_token_to_repeater, callDuringTry=True)
+    rep.set_name("(prev) " + str(expr))
+    return rep
+
+
+def one_of(
+    strs: Union[typing.Iterable[str], str],
+    caseless: bool = False,
+    use_regex: bool = True,
+    as_keyword: bool = False,
+    *,
+    useRegex: bool = True,
+    asKeyword: bool = False,
+) -> ParserElement:
+    """Helper to quickly define a set of alternative :class:`Literal` s,
+    and makes sure to do longest-first testing when there is a conflict,
+    regardless of the input order, but returns
+    a :class:`MatchFirst` for best performance.
+
+    Parameters:
+
+    - ``strs`` - a string of space-delimited literals, or a collection of
+      string literals
+    - ``caseless`` - treat all literals as caseless - (default= ``False``)
+    - ``use_regex`` - as an optimization, will
+      generate a :class:`Regex` object; otherwise, will generate
+      a :class:`MatchFirst` object (if ``caseless=True`` or ``asKeyword=True``, or if
+      creating a :class:`Regex` raises an exception) - (default= ``True``)
+    - ``as_keyword`` - enforce :class:`Keyword`-style matching on the
+      generated expressions - (default= ``False``)
+    - ``asKeyword`` and ``useRegex`` are retained for pre-PEP8 compatibility,
+      but will be removed in a future release
+
+    Example::
+
+        comp_oper = one_of("< = > <= >= !=")
+        var = Word(alphas)
+        number = Word(nums)
+        term = var | number
+        comparison_expr = term + comp_oper + term
+        print(comparison_expr.search_string("B = 12  AA=23 B<=AA AA>12"))
+
+    prints::
+
+        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
+    """
+    asKeyword = asKeyword or as_keyword
+    useRegex = useRegex and use_regex
+
+    if (
+        isinstance(caseless, str_type)
+        and __diag__.warn_on_multiple_string_args_to_oneof
+    ):
+        warnings.warn(
+            "More than one string argument passed to one_of, pass"
+            " choices as a list or space-delimited string",
+            stacklevel=2,
+        )
+
+    if caseless:
+        isequal = lambda a, b: a.upper() == b.upper()
+        masks = lambda a, b: b.upper().startswith(a.upper())
+        parseElementClass = CaselessKeyword if asKeyword else CaselessLiteral
+    else:
+        isequal = lambda a, b: a == b
+        masks = lambda a, b: b.startswith(a)
+        parseElementClass = Keyword if asKeyword else Literal
+
+    symbols: List[str] = []
+    if isinstance(strs, str_type):
+        symbols = strs.split()
+    elif isinstance(strs, Iterable):
+        symbols = list(strs)
+    else:
+        raise TypeError("Invalid argument to one_of, expected string or iterable")
+    if not symbols:
+        return NoMatch()
+
+    # reorder given symbols to take care to avoid masking longer choices with shorter ones
+    # (but only if the given symbols are not just single characters)
+    if any(len(sym) > 1 for sym in symbols):
+        i = 0
+        while i < len(symbols) - 1:
+            cur = symbols[i]
+            for j, other in enumerate(symbols[i + 1 :]):
+                if isequal(other, cur):
+                    del symbols[i + j + 1]
+                    break
+                elif masks(cur, other):
+                    del symbols[i + j + 1]
+                    symbols.insert(i, other)
+                    break
+            else:
+                i += 1
+
+    if useRegex:
+        re_flags: int = re.IGNORECASE if caseless else 0
+
+        try:
+            if all(len(sym) == 1 for sym in symbols):
+                # symbols are just single characters, create range regex pattern
+                patt = "[{}]".format(
+                    "".join(_escape_regex_range_chars(sym) for sym in symbols)
+                )
+            else:
+                patt = "|".join(re.escape(sym) for sym in symbols)
+
+            # wrap with \b word break markers if defining as keywords
+            if asKeyword:
+                patt = r"\b(?:{})\b".format(patt)
+
+            ret = Regex(patt, flags=re_flags).set_name(" | ".join(symbols))
+
+            if caseless:
+                # add parse action to return symbols as specified, not in random
+                # casing as found in input string
+                symbol_map = {sym.lower(): sym for sym in symbols}
+                ret.add_parse_action(lambda s, l, t: symbol_map[t[0].lower()])
+
+            return ret
+
+        except re.error:
+            warnings.warn(
+                "Exception creating Regex for one_of, building MatchFirst", stacklevel=2
+            )
+
+    # last resort, just use MatchFirst
+    return MatchFirst(parseElementClass(sym) for sym in symbols).set_name(
+        " | ".join(symbols)
+    )
+
+
+def dict_of(key: ParserElement, value: ParserElement) -> ParserElement:
+    """Helper to easily and clearly define a dictionary by specifying
+    the respective patterns for the key and value.  Takes care of
+    defining the :class:`Dict`, :class:`ZeroOrMore`, and
+    :class:`Group` tokens in the proper order.  The key pattern
+    can include delimiting markers or punctuation, as long as they are
+    suppressed, thereby leaving the significant key text.  The value
+    pattern can include named results, so that the :class:`Dict` results
+    can include named token fields.
+
+    Example::
+
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join))
+        print(attr_expr[1, ...].parse_string(text).dump())
+
+        attr_label = label
+        attr_value = Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join)
+
+        # similar to Dict, but simpler call format
+        result = dict_of(attr_label, attr_value).parse_string(text)
+        print(result.dump())
+        print(result['shape'])
+        print(result.shape)  # object attribute access works too
+        print(result.as_dict())
+
+    prints::
+
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
+        - color: 'light blue'
+        - posn: 'upper left'
+        - shape: 'SQUARE'
+        - texture: 'burlap'
+        SQUARE
+        SQUARE
+        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
+    """
+    return Dict(OneOrMore(Group(key + value)))
+
+
+def original_text_for(
+    expr: ParserElement, as_string: bool = True, *, asString: bool = True
+) -> ParserElement:
+    """Helper to return the original, untokenized text for a given
+    expression.  Useful to restore the parsed fields of an HTML start
+    tag into the raw tag text itself, or to revert separate tokens with
+    intervening whitespace back to the original matching input text. By
+    default, returns astring containing the original parsed text.
+
+    If the optional ``as_string`` argument is passed as
+    ``False``, then the return value is
+    a :class:`ParseResults` containing any results names that
+    were originally matched, and a single token containing the original
+    matched text from the input string.  So if the expression passed to
+    :class:`original_text_for` contains expressions with defined
+    results names, you must set ``as_string`` to ``False`` if you
+    want to preserve those results name values.
+
+    The ``asString`` pre-PEP8 argument is retained for compatibility,
+    but will be removed in a future release.
+
+    Example::
+
+        src = "this is test <b> bold <i>text</i> </b> normal text "
+        for tag in ("b", "i"):
+            opener, closer = make_html_tags(tag)
+            patt = original_text_for(opener + SkipTo(closer) + closer)
+            print(patt.search_string(src)[0])
+
+    prints::
+
+        ['<b> bold <i>text</i> </b>']
+        ['<i>text</i>']
+    """
+    asString = asString and as_string
+
+    locMarker = Empty().set_parse_action(lambda s, loc, t: loc)
+    endlocMarker = locMarker.copy()
+    endlocMarker.callPreparse = False
+    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")
+    if asString:
+        extractText = lambda s, l, t: s[t._original_start : t._original_end]
+    else:
+
+        def extractText(s, l, t):
+            t[:] = [s[t.pop("_original_start") : t.pop("_original_end")]]
+
+    matchExpr.set_parse_action(extractText)
+    matchExpr.ignoreExprs = expr.ignoreExprs
+    matchExpr.suppress_warning(Diagnostics.warn_ungrouped_named_tokens_in_collection)
+    return matchExpr
+
+
+def ungroup(expr: ParserElement) -> ParserElement:
+    """Helper to undo pyparsing's default grouping of And expressions,
+    even if all but one are non-empty.
+    """
+    return TokenConverter(expr).add_parse_action(lambda t: t[0])
+
+
+def locatedExpr(expr: ParserElement) -> ParserElement:
+    """
+    (DEPRECATED - future code should use the Located class)
+    Helper to decorate a returned token with its starting and ending
+    locations in the input string.
+
+    This helper adds the following results names:
+
+    - ``locn_start`` - location where matched expression begins
+    - ``locn_end`` - location where matched expression ends
+    - ``value`` - the actual parsed results
+
+    Be careful if the input text contains ``<TAB>`` characters, you
+    may want to call :class:`ParserElement.parseWithTabs`
+
+    Example::
+
+        wd = Word(alphas)
+        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
+            print(match)
+
+    prints::
+
+        [[0, 'ljsdf', 5]]
+        [[8, 'lksdjjf', 15]]
+        [[18, 'lkkjj', 23]]
+    """
+    locator = Empty().set_parse_action(lambda ss, ll, tt: ll)
+    return Group(
+        locator("locn_start")
+        + expr("value")
+        + locator.copy().leaveWhitespace()("locn_end")
+    )
+
+
+def nested_expr(
+    opener: Union[str, ParserElement] = "(",
+    closer: Union[str, ParserElement] = ")",
+    content: typing.Optional[ParserElement] = None,
+    ignore_expr: ParserElement = quoted_string(),
+    *,
+    ignoreExpr: ParserElement = quoted_string(),
+) -> ParserElement:
+    """Helper method for defining nested lists enclosed in opening and
+    closing delimiters (``"("`` and ``")"`` are the default).
+
+    Parameters:
+    - ``opener`` - opening character for a nested list
+      (default= ``"("``); can also be a pyparsing expression
+    - ``closer`` - closing character for a nested list
+      (default= ``")"``); can also be a pyparsing expression
+    - ``content`` - expression for items within the nested lists
+      (default= ``None``)
+    - ``ignore_expr`` - expression for ignoring opening and closing delimiters
+      (default= :class:`quoted_string`)
+    - ``ignoreExpr`` - this pre-PEP8 argument is retained for compatibility
+      but will be removed in a future release
+
+    If an expression is not provided for the content argument, the
+    nested expression will capture all whitespace-delimited content
+    between delimiters as a list of separate values.
+
+    Use the ``ignore_expr`` argument to define expressions that may
+    contain opening or closing characters that should not be treated as
+    opening or closing characters for nesting, such as quoted_string or
+    a comment expression.  Specify multiple expressions using an
+    :class:`Or` or :class:`MatchFirst`. The default is
+    :class:`quoted_string`, but if no expressions are to be ignored, then
+    pass ``None`` for this argument.
+
+    Example::
+
+        data_type = one_of("void int short long char float double")
+        decl_data_type = Combine(data_type + Opt(Word('*')))
+        ident = Word(alphas+'_', alphanums+'_')
+        number = pyparsing_common.number
+        arg = Group(decl_data_type + ident)
+        LPAR, RPAR = map(Suppress, "()")
+
+        code_body = nested_expr('{', '}', ignore_expr=(quoted_string | c_style_comment))
+
+        c_function = (decl_data_type("type")
+                      + ident("name")
+                      + LPAR + Opt(delimited_list(arg), [])("args") + RPAR
+                      + code_body("body"))
+        c_function.ignore(c_style_comment)
+
+        source_code = '''
+            int is_odd(int x) {
+                return (x%2);
+            }
+
+            int dec_to_hex(char hchar) {
+                if (hchar >= '0' && hchar <= '9') {
+                    return (ord(hchar)-ord('0'));
+                } else {
+                    return (10+ord(hchar)-ord('A'));
+                }
+            }
+        '''
+        for func in c_function.search_string(source_code):
+            print("%(name)s (%(type)s) args: %(args)s" % func)
+
+
+    prints::
+
+        is_odd (int) args: [['int', 'x']]
+        dec_to_hex (int) args: [['char', 'hchar']]
+    """
+    if ignoreExpr != ignore_expr:
+        ignoreExpr = ignore_expr if ignoreExpr == quoted_string() else ignoreExpr
+    if opener == closer:
+        raise ValueError("opening and closing strings cannot be the same")
+    if content is None:
+        if isinstance(opener, str_type) and isinstance(closer, str_type):
+            if len(opener) == 1 and len(closer) == 1:
+                if ignoreExpr is not None:
+                    content = Combine(
+                        OneOrMore(
+                            ~ignoreExpr
+                            + CharsNotIn(
+                                opener + closer + ParserElement.DEFAULT_WHITE_CHARS,
+                                exact=1,
+                            )
+                        )
+                    ).set_parse_action(lambda t: t[0].strip())
+                else:
+                    content = empty.copy() + CharsNotIn(
+                        opener + closer + ParserElement.DEFAULT_WHITE_CHARS
+                    ).set_parse_action(lambda t: t[0].strip())
+            else:
+                if ignoreExpr is not None:
+                    content = Combine(
+                        OneOrMore(
+                            ~ignoreExpr
+                            + ~Literal(opener)
+                            + ~Literal(closer)
+                            + CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS, exact=1)
+                        )
+                    ).set_parse_action(lambda t: t[0].strip())
+                else:
+                    content = Combine(
+                        OneOrMore(
+                            ~Literal(opener)
+                            + ~Literal(closer)
+                            + CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS, exact=1)
+                        )
+                    ).set_parse_action(lambda t: t[0].strip())
+        else:
+            raise ValueError(
+                "opening and closing arguments must be strings if no content expression is given"
+            )
+    ret = Forward()
+    if ignoreExpr is not None:
+        ret <<= Group(
+            Suppress(opener) + ZeroOrMore(ignoreExpr | ret | content) + Suppress(closer)
+        )
+    else:
+        ret <<= Group(Suppress(opener) + ZeroOrMore(ret | content) + Suppress(closer))
+    ret.set_name("nested %s%s expression" % (opener, closer))
+    return ret
+
+
+def _makeTags(tagStr, xml, suppress_LT=Suppress("<"), suppress_GT=Suppress(">")):
+    """Internal helper to construct opening and closing tag expressions, given a tag name"""
+    if isinstance(tagStr, str_type):
+        resname = tagStr
+        tagStr = Keyword(tagStr, caseless=not xml)
+    else:
+        resname = tagStr.name
+
+    tagAttrName = Word(alphas, alphanums + "_-:")
+    if xml:
+        tagAttrValue = dbl_quoted_string.copy().set_parse_action(remove_quotes)
+        openTag = (
+            suppress_LT
+            + tagStr("tag")
+            + Dict(ZeroOrMore(Group(tagAttrName + Suppress("=") + tagAttrValue)))
+            + Opt("/", default=[False])("empty").set_parse_action(
+                lambda s, l, t: t[0] == "/"
+            )
+            + suppress_GT
+        )
+    else:
+        tagAttrValue = quoted_string.copy().set_parse_action(remove_quotes) | Word(
+            printables, exclude_chars=">"
+        )
+        openTag = (
+            suppress_LT
+            + tagStr("tag")
+            + Dict(
+                ZeroOrMore(
+                    Group(
+                        tagAttrName.set_parse_action(lambda t: t[0].lower())
+                        + Opt(Suppress("=") + tagAttrValue)
+                    )
+                )
+            )
+            + Opt("/", default=[False])("empty").set_parse_action(
+                lambda s, l, t: t[0] == "/"
+            )
+            + suppress_GT
+        )
+    closeTag = Combine(Literal("</") + tagStr + ">", adjacent=False)
+
+    openTag.set_name("<%s>" % resname)
+    # add start<tagname> results name in parse action now that ungrouped names are not reported at two levels
+    openTag.add_parse_action(
+        lambda t: t.__setitem__(
+            "start" + "".join(resname.replace(":", " ").title().split()), t.copy()
+        )
+    )
+    closeTag = closeTag(
+        "end" + "".join(resname.replace(":", " ").title().split())
+    ).set_name("</%s>" % resname)
+    openTag.tag = resname
+    closeTag.tag = resname
+    openTag.tag_body = SkipTo(closeTag())
+    return openTag, closeTag
+
+
+def make_html_tags(
+    tag_str: Union[str, ParserElement]
+) -> Tuple[ParserElement, ParserElement]:
+    """Helper to construct opening and closing tag expressions for HTML,
+    given a tag name. Matches tags in either upper or lower case,
+    attributes with namespaces and with quoted or unquoted values.
+
+    Example::
+
+        text = '<td>More info at the <a href="https://github.com/pyparsing/pyparsing/wiki">pyparsing</a> wiki page</td>'
+        # make_html_tags returns pyparsing expressions for the opening and
+        # closing tags as a 2-tuple
+        a, a_end = make_html_tags("A")
+        link_expr = a + SkipTo(a_end)("link_text") + a_end
+
+        for link in link_expr.search_string(text):
+            # attributes in the <A> tag (like "href" shown here) are
+            # also accessible as named results
+            print(link.link_text, '->', link.href)
+
+    prints::
+
+        pyparsing -> https://github.com/pyparsing/pyparsing/wiki
+    """
+    return _makeTags(tag_str, False)
+
+
+def make_xml_tags(
+    tag_str: Union[str, ParserElement]
+) -> Tuple[ParserElement, ParserElement]:
+    """Helper to construct opening and closing tag expressions for XML,
+    given a tag name. Matches tags only in the given upper/lower case.
+
+    Example: similar to :class:`make_html_tags`
+    """
+    return _makeTags(tag_str, True)
+
+
+any_open_tag: ParserElement
+any_close_tag: ParserElement
+any_open_tag, any_close_tag = make_html_tags(
+    Word(alphas, alphanums + "_:").set_name("any tag")
+)
+
+_htmlEntityMap = {k.rstrip(";"): v for k, v in html.entities.html5.items()}
+common_html_entity = Regex("&(?P<entity>" + "|".join(_htmlEntityMap) + ");").set_name(
+    "common HTML entity"
+)
+
+
+def replace_html_entity(t):
+    """Helper parser action to replace common HTML entities with their special characters"""
+    return _htmlEntityMap.get(t.entity)
+
+
+class OpAssoc(Enum):
+    LEFT = 1
+    RIGHT = 2
+
+
+InfixNotationOperatorArgType = Union[
+    ParserElement, str, Tuple[Union[ParserElement, str], Union[ParserElement, str]]
+]
+InfixNotationOperatorSpec = Union[
+    Tuple[
+        InfixNotationOperatorArgType,
+        int,
+        OpAssoc,
+        typing.Optional[ParseAction],
+    ],
+    Tuple[
+        InfixNotationOperatorArgType,
+        int,
+        OpAssoc,
+    ],
+]
+
+
+def infix_notation(
+    base_expr: ParserElement,
+    op_list: List[InfixNotationOperatorSpec],
+    lpar: Union[str, ParserElement] = Suppress("("),
+    rpar: Union[str, ParserElement] = Suppress(")"),
+) -> ParserElement:
+    """Helper method for constructing grammars of expressions made up of
+    operators working in a precedence hierarchy.  Operators may be unary
+    or binary, left- or right-associative.  Parse actions can also be
+    attached to operator expressions. The generated parser will also
+    recognize the use of parentheses to override operator precedences
+    (see example below).
+
+    Note: if you define a deep operator list, you may see performance
+    issues when using infix_notation. See
+    :class:`ParserElement.enable_packrat` for a mechanism to potentially
+    improve your parser performance.
+
+    Parameters:
+    - ``base_expr`` - expression representing the most basic operand to
+      be used in the expression
+    - ``op_list`` - list of tuples, one for each operator precedence level
+      in the expression grammar; each tuple is of the form ``(op_expr,
+      num_operands, right_left_assoc, (optional)parse_action)``, where:
+
+      - ``op_expr`` is the pyparsing expression for the operator; may also
+        be a string, which will be converted to a Literal; if ``num_operands``
+        is 3, ``op_expr`` is a tuple of two expressions, for the two
+        operators separating the 3 terms
+      - ``num_operands`` is the number of terms for this operator (must be 1,
+        2, or 3)
+      - ``right_left_assoc`` is the indicator whether the operator is right
+        or left associative, using the pyparsing-defined constants
+        ``OpAssoc.RIGHT`` and ``OpAssoc.LEFT``.
+      - ``parse_action`` is the parse action to be associated with
+        expressions matching this operator expression (the parse action
+        tuple member may be omitted); if the parse action is passed
+        a tuple or list of functions, this is equivalent to calling
+        ``set_parse_action(*fn)``
+        (:class:`ParserElement.set_parse_action`)
+    - ``lpar`` - expression for matching left-parentheses; if passed as a
+      str, then will be parsed as Suppress(lpar). If lpar is passed as
+      an expression (such as ``Literal('(')``), then it will be kept in
+      the parsed results, and grouped with them. (default= ``Suppress('(')``)
+    - ``rpar`` - expression for matching right-parentheses; if passed as a
+      str, then will be parsed as Suppress(rpar). If rpar is passed as
+      an expression (such as ``Literal(')')``), then it will be kept in
+      the parsed results, and grouped with them. (default= ``Suppress(')')``)
+
+    Example::
+
+        # simple example of four-function arithmetic with ints and
+        # variable names
+        integer = pyparsing_common.signed_integer
+        varname = pyparsing_common.identifier
+
+        arith_expr = infix_notation(integer | varname,
+            [
+            ('-', 1, OpAssoc.RIGHT),
+            (one_of('* /'), 2, OpAssoc.LEFT),
+            (one_of('+ -'), 2, OpAssoc.LEFT),
+            ])
+
+        arith_expr.run_tests('''
+            5+3*6
+            (5+3)*6
+            -2--11
+            ''', full_dump=False)
+
+    prints::
+
+        5+3*6
+        [[5, '+', [3, '*', 6]]]
+
+        (5+3)*6
+        [[[5, '+', 3], '*', 6]]
+
+        -2--11
+        [[['-', 2], '-', ['-', 11]]]
+    """
+    # captive version of FollowedBy that does not do parse actions or capture results names
+    class _FB(FollowedBy):
+        def parseImpl(self, instring, loc, doActions=True):
+            self.expr.try_parse(instring, loc)
+            return loc, []
+
+    _FB.__name__ = "FollowedBy>"
+
+    ret = Forward()
+    if isinstance(lpar, str):
+        lpar = Suppress(lpar)
+    if isinstance(rpar, str):
+        rpar = Suppress(rpar)
+
+    # if lpar and rpar are not suppressed, wrap in group
+    if not (isinstance(rpar, Suppress) and isinstance(rpar, Suppress)):
+        lastExpr = base_expr | Group(lpar + ret + rpar)
+    else:
+        lastExpr = base_expr | (lpar + ret + rpar)
+
+    for i, operDef in enumerate(op_list):
+        opExpr, arity, rightLeftAssoc, pa = (operDef + (None,))[:4]
+        if isinstance(opExpr, str_type):
+            opExpr = ParserElement._literalStringClass(opExpr)
+        if arity == 3:
+            if not isinstance(opExpr, (tuple, list)) or len(opExpr) != 2:
+                raise ValueError(
+                    "if numterms=3, opExpr must be a tuple or list of two expressions"
+                )
+            opExpr1, opExpr2 = opExpr
+            term_name = "{}{} term".format(opExpr1, opExpr2)
+        else:
+            term_name = "{} term".format(opExpr)
+
+        if not 1 <= arity <= 3:
+            raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
+
+        if rightLeftAssoc not in (OpAssoc.LEFT, OpAssoc.RIGHT):
+            raise ValueError("operator must indicate right or left associativity")
+
+        thisExpr: Forward = Forward().set_name(term_name)
+        if rightLeftAssoc is OpAssoc.LEFT:
+            if arity == 1:
+                matchExpr = _FB(lastExpr + opExpr) + Group(lastExpr + opExpr[1, ...])
+            elif arity == 2:
+                if opExpr is not None:
+                    matchExpr = _FB(lastExpr + opExpr + lastExpr) + Group(
+                        lastExpr + (opExpr + lastExpr)[1, ...]
+                    )
+                else:
+                    matchExpr = _FB(lastExpr + lastExpr) + Group(lastExpr[2, ...])
+            elif arity == 3:
+                matchExpr = _FB(
+                    lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr
+                ) + Group(lastExpr + OneOrMore(opExpr1 + lastExpr + opExpr2 + lastExpr))
+        elif rightLeftAssoc is OpAssoc.RIGHT:
+            if arity == 1:
+                # try to avoid LR with this extra test
+                if not isinstance(opExpr, Opt):
+                    opExpr = Opt(opExpr)
+                matchExpr = _FB(opExpr.expr + thisExpr) + Group(opExpr + thisExpr)
+            elif arity == 2:
+                if opExpr is not None:
+                    matchExpr = _FB(lastExpr + opExpr + thisExpr) + Group(
+                        lastExpr + (opExpr + thisExpr)[1, ...]
+                    )
+                else:
+                    matchExpr = _FB(lastExpr + thisExpr) + Group(
+                        lastExpr + thisExpr[1, ...]
+                    )
+            elif arity == 3:
+                matchExpr = _FB(
+                    lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr
+                ) + Group(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr)
+        if pa:
+            if isinstance(pa, (tuple, list)):
+                matchExpr.set_parse_action(*pa)
+            else:
+                matchExpr.set_parse_action(pa)
+        thisExpr <<= (matchExpr | lastExpr).setName(term_name)
+        lastExpr = thisExpr
+    ret <<= lastExpr
+    return ret
+
+
+def indentedBlock(blockStatementExpr, indentStack, indent=True, backup_stacks=[]):
+    """
+    (DEPRECATED - use IndentedBlock class instead)
+    Helper method for defining space-delimited indentation blocks,
+    such as those used to define block statements in Python source code.
+
+    Parameters:
+
+    - ``blockStatementExpr`` - expression defining syntax of statement that
+      is repeated within the indented block
+    - ``indentStack`` - list created by caller to manage indentation stack
+      (multiple ``statementWithIndentedBlock`` expressions within a single
+      grammar should share a common ``indentStack``)
+    - ``indent`` - boolean indicating whether block must be indented beyond
+      the current level; set to ``False`` for block of left-most statements
+      (default= ``True``)
+
+    A valid block must contain at least one ``blockStatement``.
+
+    (Note that indentedBlock uses internal parse actions which make it
+    incompatible with packrat parsing.)
+
+    Example::
+
+        data = '''
+        def A(z):
+          A1
+          B = 100
+          G = A2
+          A2
+          A3
+        B
+        def BB(a,b,c):
+          BB1
+          def BBA():
+            bba1
+            bba2
+            bba3
+        C
+        D
+        def spam(x,y):
+             def eggs(z):
+                 pass
+        '''
+
+
+        indentStack = [1]
+        stmt = Forward()
+
+        identifier = Word(alphas, alphanums)
+        funcDecl = ("def" + identifier + Group("(" + Opt(delimitedList(identifier)) + ")") + ":")
+        func_body = indentedBlock(stmt, indentStack)
+        funcDef = Group(funcDecl + func_body)
+
+        rvalue = Forward()
+        funcCall = Group(identifier + "(" + Opt(delimitedList(rvalue)) + ")")
+        rvalue << (funcCall | identifier | Word(nums))
+        assignment = Group(identifier + "=" + rvalue)
+        stmt << (funcDef | assignment | identifier)
+
+        module_body = stmt[1, ...]
+
+        parseTree = module_body.parseString(data)
+        parseTree.pprint()
+
+    prints::
+
+        [['def',
+          'A',
+          ['(', 'z', ')'],
+          ':',
+          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],
+         'B',
+         ['def',
+          'BB',
+          ['(', 'a', 'b', 'c', ')'],
+          ':',
+          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],
+         'C',
+         'D',
+         ['def',
+          'spam',
+          ['(', 'x', 'y', ')'],
+          ':',
+          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]]
+    """
+    backup_stacks.append(indentStack[:])
+
+    def reset_stack():
+        indentStack[:] = backup_stacks[-1]
+
+    def checkPeerIndent(s, l, t):
+        if l >= len(s):
+            return
+        curCol = col(l, s)
+        if curCol != indentStack[-1]:
+            if curCol > indentStack[-1]:
+                raise ParseException(s, l, "illegal nesting")
+            raise ParseException(s, l, "not a peer entry")
+
+    def checkSubIndent(s, l, t):
+        curCol = col(l, s)
+        if curCol > indentStack[-1]:
+            indentStack.append(curCol)
+        else:
+            raise ParseException(s, l, "not a subentry")
+
+    def checkUnindent(s, l, t):
+        if l >= len(s):
+            return
+        curCol = col(l, s)
+        if not (indentStack and curCol in indentStack):
+            raise ParseException(s, l, "not an unindent")
+        if curCol < indentStack[-1]:
+            indentStack.pop()
+
+    NL = OneOrMore(LineEnd().set_whitespace_chars("\t ").suppress())
+    INDENT = (Empty() + Empty().set_parse_action(checkSubIndent)).set_name("INDENT")
+    PEER = Empty().set_parse_action(checkPeerIndent).set_name("")
+    UNDENT = Empty().set_parse_action(checkUnindent).set_name("UNINDENT")
+    if indent:
+        smExpr = Group(
+            Opt(NL)
+            + INDENT
+            + OneOrMore(PEER + Group(blockStatementExpr) + Opt(NL))
+            + UNDENT
+        )
+    else:
+        smExpr = Group(
+            Opt(NL)
+            + OneOrMore(PEER + Group(blockStatementExpr) + Opt(NL))
+            + Opt(UNDENT)
+        )
+
+    # add a parse action to remove backup_stack from list of backups
+    smExpr.add_parse_action(
+        lambda: backup_stacks.pop(-1) and None if backup_stacks else None
+    )
+    smExpr.set_fail_action(lambda a, b, c, d: reset_stack())
+    blockStatementExpr.ignore(_bslash + LineEnd())
+    return smExpr.set_name("indented block")
+
+
+# it's easy to get these comment structures wrong - they're very common, so may as well make them available
+c_style_comment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + "*/").set_name(
+    "C style comment"
+)
+"Comment of the form ``/* ... */``"
+
+html_comment = Regex(r"<!--[\s\S]*?-->").set_name("HTML comment")
+"Comment of the form ``<!-- ... -->``"
+
+rest_of_line = Regex(r".*").leave_whitespace().set_name("rest of line")
+dbl_slash_comment = Regex(r"//(?:\\\n|[^\n])*").set_name("// comment")
+"Comment of the form ``// ... (to end of line)``"
+
+cpp_style_comment = Combine(
+    Regex(r"/\*(?:[^*]|\*(?!/))*") + "*/" | dbl_slash_comment
+).set_name("C++ style comment")
+"Comment of either form :class:`c_style_comment` or :class:`dbl_slash_comment`"
+
+java_style_comment = cpp_style_comment
+"Same as :class:`cpp_style_comment`"
+
+python_style_comment = Regex(r"#.*").set_name("Python style comment")
+"Comment of the form ``# ... (to end of line)``"
+
+
+# build list of built-in expressions, for future reference if a global default value
+# gets updated
+_builtin_exprs: List[ParserElement] = [
+    v for v in vars().values() if isinstance(v, ParserElement)
+]
+
+
+# pre-PEP8 compatible names
+delimitedList = delimited_list
+countedArray = counted_array
+matchPreviousLiteral = match_previous_literal
+matchPreviousExpr = match_previous_expr
+oneOf = one_of
+dictOf = dict_of
+originalTextFor = original_text_for
+nestedExpr = nested_expr
+makeHTMLTags = make_html_tags
+makeXMLTags = make_xml_tags
+anyOpenTag, anyCloseTag = any_open_tag, any_close_tag
+commonHTMLEntity = common_html_entity
+replaceHTMLEntity = replace_html_entity
+opAssoc = OpAssoc
+infixNotation = infix_notation
+cStyleComment = c_style_comment
+htmlComment = html_comment
+restOfLine = rest_of_line
+dblSlashComment = dbl_slash_comment
+cppStyleComment = cpp_style_comment
+javaStyleComment = java_style_comment
+pythonStyleComment = python_style_comment
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/py.typed b/myenv/lib/python3.9/site-packages/pyparsing/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/results.py b/myenv/lib/python3.9/site-packages/pyparsing/results.py
new file mode 100644
index 0000000..00c9421
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing/results.py
@@ -0,0 +1,760 @@
+# results.py
+from collections.abc import MutableMapping, Mapping, MutableSequence, Iterator
+import pprint
+from weakref import ref as wkref
+from typing import Tuple, Any
+
+str_type: Tuple[type, ...] = (str, bytes)
+_generator_type = type((_ for _ in ()))
+
+
+class _ParseResultsWithOffset:
+    __slots__ = ["tup"]
+
+    def __init__(self, p1, p2):
+        self.tup = (p1, p2)
+
+    def __getitem__(self, i):
+        return self.tup[i]
+
+    def __getstate__(self):
+        return self.tup
+
+    def __setstate__(self, *args):
+        self.tup = args[0]
+
+
+class ParseResults:
+    """Structured parse results, to provide multiple means of access to
+    the parsed data:
+
+    - as a list (``len(results)``)
+    - by list index (``results[0], results[1]``, etc.)
+    - by attribute (``results.<results_name>`` - see :class:`ParserElement.set_results_name`)
+
+    Example::
+
+        integer = Word(nums)
+        date_str = (integer.set_results_name("year") + '/'
+                    + integer.set_results_name("month") + '/'
+                    + integer.set_results_name("day"))
+        # equivalent form:
+        # date_str = (integer("year") + '/'
+        #             + integer("month") + '/'
+        #             + integer("day"))
+
+        # parse_string returns a ParseResults object
+        result = date_str.parse_string("1999/12/31")
+
+        def test(s, fn=repr):
+            print("{} -> {}".format(s, fn(eval(s))))
+        test("list(result)")
+        test("result[0]")
+        test("result['month']")
+        test("result.day")
+        test("'month' in result")
+        test("'minutes' in result")
+        test("result.dump()", str)
+
+    prints::
+
+        list(result) -> ['1999', '/', '12', '/', '31']
+        result[0] -> '1999'
+        result['month'] -> '12'
+        result.day -> '31'
+        'month' in result -> True
+        'minutes' in result -> False
+        result.dump() -> ['1999', '/', '12', '/', '31']
+        - day: '31'
+        - month: '12'
+        - year: '1999'
+    """
+
+    _null_values: Tuple[Any, ...] = (None, [], "", ())
+
+    __slots__ = [
+        "_name",
+        "_parent",
+        "_all_names",
+        "_modal",
+        "_toklist",
+        "_tokdict",
+        "__weakref__",
+    ]
+
+    class List(list):
+        """
+        Simple wrapper class to distinguish parsed list results that should be preserved
+        as actual Python lists, instead of being converted to :class:`ParseResults`:
+
+            LBRACK, RBRACK = map(pp.Suppress, "[]")
+            element = pp.Forward()
+            item = ppc.integer
+            element_list = LBRACK + pp.delimited_list(element) + RBRACK
+
+            # add parse actions to convert from ParseResults to actual Python collection types
+            def as_python_list(t):
+                return pp.ParseResults.List(t.as_list())
+            element_list.add_parse_action(as_python_list)
+
+            element <<= item | element_list
+
+            element.run_tests('''
+                100
+                [2,3,4]
+                [[2, 1],3,4]
+                [(2, 1),3,4]
+                (2,3,4)
+                ''', post_parse=lambda s, r: (r[0], type(r[0])))
+
+        prints:
+
+            100
+            (100, <class 'int'>)
+
+            [2,3,4]
+            ([2, 3, 4], <class 'list'>)
+
+            [[2, 1],3,4]
+            ([[2, 1], 3, 4], <class 'list'>)
+
+        (Used internally by :class:`Group` when `aslist=True`.)
+        """
+
+        def __new__(cls, contained=None):
+            if contained is None:
+                contained = []
+
+            if not isinstance(contained, list):
+                raise TypeError(
+                    "{} may only be constructed with a list,"
+                    " not {}".format(cls.__name__, type(contained).__name__)
+                )
+
+            return list.__new__(cls)
+
+    def __new__(cls, toklist=None, name=None, **kwargs):
+        if isinstance(toklist, ParseResults):
+            return toklist
+        self = object.__new__(cls)
+        self._name = None
+        self._parent = None
+        self._all_names = set()
+
+        if toklist is None:
+            self._toklist = []
+        elif isinstance(toklist, (list, _generator_type)):
+            self._toklist = (
+                [toklist[:]]
+                if isinstance(toklist, ParseResults.List)
+                else list(toklist)
+            )
+        else:
+            self._toklist = [toklist]
+        self._tokdict = dict()
+        return self
+
+    # Performance tuning: we construct a *lot* of these, so keep this
+    # constructor as small and fast as possible
+    def __init__(
+        self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance
+    ):
+        self._modal = modal
+        if name is not None and name != "":
+            if isinstance(name, int):
+                name = str(name)
+            if not modal:
+                self._all_names = {name}
+            self._name = name
+            if toklist not in self._null_values:
+                if isinstance(toklist, (str_type, type)):
+                    toklist = [toklist]
+                if asList:
+                    if isinstance(toklist, ParseResults):
+                        self[name] = _ParseResultsWithOffset(
+                            ParseResults(toklist._toklist), 0
+                        )
+                    else:
+                        self[name] = _ParseResultsWithOffset(
+                            ParseResults(toklist[0]), 0
+                        )
+                    self[name]._name = name
+                else:
+                    try:
+                        self[name] = toklist[0]
+                    except (KeyError, TypeError, IndexError):
+                        if toklist is not self:
+                            self[name] = toklist
+                        else:
+                            self._name = name
+
+    def __getitem__(self, i):
+        if isinstance(i, (int, slice)):
+            return self._toklist[i]
+        else:
+            if i not in self._all_names:
+                return self._tokdict[i][-1][0]
+            else:
+                return ParseResults([v[0] for v in self._tokdict[i]])
+
+    def __setitem__(self, k, v, isinstance=isinstance):
+        if isinstance(v, _ParseResultsWithOffset):
+            self._tokdict[k] = self._tokdict.get(k, list()) + [v]
+            sub = v[0]
+        elif isinstance(k, (int, slice)):
+            self._toklist[k] = v
+            sub = v
+        else:
+            self._tokdict[k] = self._tokdict.get(k, list()) + [
+                _ParseResultsWithOffset(v, 0)
+            ]
+            sub = v
+        if isinstance(sub, ParseResults):
+            sub._parent = wkref(self)
+
+    def __delitem__(self, i):
+        if isinstance(i, (int, slice)):
+            mylen = len(self._toklist)
+            del self._toklist[i]
+
+            # convert int to slice
+            if isinstance(i, int):
+                if i < 0:
+                    i += mylen
+                i = slice(i, i + 1)
+            # get removed indices
+            removed = list(range(*i.indices(mylen)))
+            removed.reverse()
+            # fixup indices in token dictionary
+            for name, occurrences in self._tokdict.items():
+                for j in removed:
+                    for k, (value, position) in enumerate(occurrences):
+                        occurrences[k] = _ParseResultsWithOffset(
+                            value, position - (position > j)
+                        )
+        else:
+            del self._tokdict[i]
+
+    def __contains__(self, k) -> bool:
+        return k in self._tokdict
+
+    def __len__(self) -> int:
+        return len(self._toklist)
+
+    def __bool__(self) -> bool:
+        return not not (self._toklist or self._tokdict)
+
+    def __iter__(self) -> Iterator:
+        return iter(self._toklist)
+
+    def __reversed__(self) -> Iterator:
+        return iter(self._toklist[::-1])
+
+    def keys(self):
+        return iter(self._tokdict)
+
+    def values(self):
+        return (self[k] for k in self.keys())
+
+    def items(self):
+        return ((k, self[k]) for k in self.keys())
+
+    def haskeys(self) -> bool:
+        """
+        Since ``keys()`` returns an iterator, this method is helpful in bypassing
+        code that looks for the existence of any defined results names."""
+        return bool(self._tokdict)
+
+    def pop(self, *args, **kwargs):
+        """
+        Removes and returns item at specified index (default= ``last``).
+        Supports both ``list`` and ``dict`` semantics for ``pop()``. If
+        passed no argument or an integer argument, it will use ``list``
+        semantics and pop tokens from the list of parsed tokens. If passed
+        a non-integer argument (most likely a string), it will use ``dict``
+        semantics and pop the corresponding value from any defined results
+        names. A second default return value argument is supported, just as in
+        ``dict.pop()``.
+
+        Example::
+
+            numlist = Word(nums)[...]
+            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']
+
+            def remove_first(tokens):
+                tokens.pop(0)
+            numlist.add_parse_action(remove_first)
+            print(numlist.parse_string("0 123 321")) # -> ['123', '321']
+
+            label = Word(alphas)
+            patt = label("LABEL") + Word(nums)[1, ...]
+            print(patt.parse_string("AAB 123 321").dump())
+
+            # Use pop() in a parse action to remove named result (note that corresponding value is not
+            # removed from list form of results)
+            def remove_LABEL(tokens):
+                tokens.pop("LABEL")
+                return tokens
+            patt.add_parse_action(remove_LABEL)
+            print(patt.parse_string("AAB 123 321").dump())
+
+        prints::
+
+            ['AAB', '123', '321']
+            - LABEL: 'AAB'
+
+            ['AAB', '123', '321']
+        """
+        if not args:
+            args = [-1]
+        for k, v in kwargs.items():
+            if k == "default":
+                args = (args[0], v)
+            else:
+                raise TypeError(
+                    "pop() got an unexpected keyword argument {!r}".format(k)
+                )
+        if isinstance(args[0], int) or len(args) == 1 or args[0] in self:
+            index = args[0]
+            ret = self[index]
+            del self[index]
+            return ret
+        else:
+            defaultvalue = args[1]
+            return defaultvalue
+
+    def get(self, key, default_value=None):
+        """
+        Returns named result matching the given key, or if there is no
+        such name, then returns the given ``default_value`` or ``None`` if no
+        ``default_value`` is specified.
+
+        Similar to ``dict.get()``.
+
+        Example::
+
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+            result = date_str.parse_string("1999/12/31")
+            print(result.get("year")) # -> '1999'
+            print(result.get("hour", "not specified")) # -> 'not specified'
+            print(result.get("hour")) # -> None
+        """
+        if key in self:
+            return self[key]
+        else:
+            return default_value
+
+    def insert(self, index, ins_string):
+        """
+        Inserts new element at location index in the list of parsed tokens.
+
+        Similar to ``list.insert()``.
+
+        Example::
+
+            numlist = Word(nums)[...]
+            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']
+
+            # use a parse action to insert the parse location in the front of the parsed results
+            def insert_locn(locn, tokens):
+                tokens.insert(0, locn)
+            numlist.add_parse_action(insert_locn)
+            print(numlist.parse_string("0 123 321")) # -> [0, '0', '123', '321']
+        """
+        self._toklist.insert(index, ins_string)
+        # fixup indices in token dictionary
+        for name, occurrences in self._tokdict.items():
+            for k, (value, position) in enumerate(occurrences):
+                occurrences[k] = _ParseResultsWithOffset(
+                    value, position + (position > index)
+                )
+
+    def append(self, item):
+        """
+        Add single element to end of ``ParseResults`` list of elements.
+
+        Example::
+
+            numlist = Word(nums)[...]
+            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']
+
+            # use a parse action to compute the sum of the parsed integers, and add it to the end
+            def append_sum(tokens):
+                tokens.append(sum(map(int, tokens)))
+            numlist.add_parse_action(append_sum)
+            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321', 444]
+        """
+        self._toklist.append(item)
+
+    def extend(self, itemseq):
+        """
+        Add sequence of elements to end of ``ParseResults`` list of elements.
+
+        Example::
+
+            patt = Word(alphas)[1, ...]
+
+            # use a parse action to append the reverse of the matched strings, to make a palindrome
+            def make_palindrome(tokens):
+                tokens.extend(reversed([t[::-1] for t in tokens]))
+                return ''.join(tokens)
+            patt.add_parse_action(make_palindrome)
+            print(patt.parse_string("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
+        """
+        if isinstance(itemseq, ParseResults):
+            self.__iadd__(itemseq)
+        else:
+            self._toklist.extend(itemseq)
+
+    def clear(self):
+        """
+        Clear all elements and results names.
+        """
+        del self._toklist[:]
+        self._tokdict.clear()
+
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError:
+            if name.startswith("__"):
+                raise AttributeError(name)
+            return ""
+
+    def __add__(self, other) -> "ParseResults":
+        ret = self.copy()
+        ret += other
+        return ret
+
+    def __iadd__(self, other) -> "ParseResults":
+        if other._tokdict:
+            offset = len(self._toklist)
+            addoffset = lambda a: offset if a < 0 else a + offset
+            otheritems = other._tokdict.items()
+            otherdictitems = [
+                (k, _ParseResultsWithOffset(v[0], addoffset(v[1])))
+                for k, vlist in otheritems
+                for v in vlist
+            ]
+            for k, v in otherdictitems:
+                self[k] = v
+                if isinstance(v[0], ParseResults):
+                    v[0]._parent = wkref(self)
+
+        self._toklist += other._toklist
+        self._all_names |= other._all_names
+        return self
+
+    def __radd__(self, other) -> "ParseResults":
+        if isinstance(other, int) and other == 0:
+            # useful for merging many ParseResults using sum() builtin
+            return self.copy()
+        else:
+            # this may raise a TypeError - so be it
+            return other + self
+
+    def __repr__(self) -> str:
+        return "{}({!r}, {})".format(type(self).__name__, self._toklist, self.as_dict())
+
+    def __str__(self) -> str:
+        return (
+            "["
+            + ", ".join(
+                [
+                    str(i) if isinstance(i, ParseResults) else repr(i)
+                    for i in self._toklist
+                ]
+            )
+            + "]"
+        )
+
+    def _asStringList(self, sep=""):
+        out = []
+        for item in self._toklist:
+            if out and sep:
+                out.append(sep)
+            if isinstance(item, ParseResults):
+                out += item._asStringList()
+            else:
+                out.append(str(item))
+        return out
+
+    def as_list(self) -> list:
+        """
+        Returns the parse results as a nested list of matching tokens, all converted to strings.
+
+        Example::
+
+            patt = Word(alphas)[1, ...]
+            result = patt.parse_string("sldkj lsdkj sldkj")
+            # even though the result prints in string-like form, it is actually a pyparsing ParseResults
+            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']
+
+            # Use as_list() to create an actual list
+            result_list = result.as_list()
+            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']
+        """
+        return [
+            res.as_list() if isinstance(res, ParseResults) else res
+            for res in self._toklist
+        ]
+
+    def as_dict(self) -> dict:
+        """
+        Returns the named parse results as a nested dictionary.
+
+        Example::
+
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+            result = date_str.parse_string('12/31/1999')
+            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
+
+            result_dict = result.as_dict()
+            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}
+
+            # even though a ParseResults supports dict-like access, sometime you just need to have a dict
+            import json
+            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
+            print(json.dumps(result.as_dict())) # -> {"month": "31", "day": "1999", "year": "12"}
+        """
+
+        def to_item(obj):
+            if isinstance(obj, ParseResults):
+                return obj.as_dict() if obj.haskeys() else [to_item(v) for v in obj]
+            else:
+                return obj
+
+        return dict((k, to_item(v)) for k, v in self.items())
+
+    def copy(self) -> "ParseResults":
+        """
+        Returns a new copy of a :class:`ParseResults` object.
+        """
+        ret = ParseResults(self._toklist)
+        ret._tokdict = self._tokdict.copy()
+        ret._parent = self._parent
+        ret._all_names |= self._all_names
+        ret._name = self._name
+        return ret
+
+    def get_name(self):
+        r"""
+        Returns the results name for this token expression. Useful when several
+        different expressions might match at a particular location.
+
+        Example::
+
+            integer = Word(nums)
+            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
+            house_number_expr = Suppress('#') + Word(nums, alphanums)
+            user_data = (Group(house_number_expr)("house_number")
+                        | Group(ssn_expr)("ssn")
+                        | Group(integer)("age"))
+            user_info = user_data[1, ...]
+
+            result = user_info.parse_string("22 111-22-3333 #221B")
+            for item in result:
+                print(item.get_name(), ':', item[0])
+
+        prints::
+
+            age : 22
+            ssn : 111-22-3333
+            house_number : 221B
+        """
+        if self._name:
+            return self._name
+        elif self._parent:
+            par = self._parent()
+
+            def find_in_parent(sub):
+                return next(
+                    (
+                        k
+                        for k, vlist in par._tokdict.items()
+                        for v, loc in vlist
+                        if sub is v
+                    ),
+                    None,
+                )
+
+            return find_in_parent(self) if par else None
+        elif (
+            len(self) == 1
+            and len(self._tokdict) == 1
+            and next(iter(self._tokdict.values()))[0][1] in (0, -1)
+        ):
+            return next(iter(self._tokdict.keys()))
+        else:
+            return None
+
+    def dump(self, indent="", full=True, include_list=True, _depth=0) -> str:
+        """
+        Diagnostic method for listing out the contents of
+        a :class:`ParseResults`. Accepts an optional ``indent`` argument so
+        that this string can be embedded in a nested display of other data.
+
+        Example::
+
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+            result = date_str.parse_string('1999/12/31')
+            print(result.dump())
+
+        prints::
+
+            ['1999', '/', '12', '/', '31']
+            - day: '31'
+            - month: '12'
+            - year: '1999'
+        """
+        out = []
+        NL = "\n"
+        out.append(indent + str(self.as_list()) if include_list else "")
+
+        if full:
+            if self.haskeys():
+                items = sorted((str(k), v) for k, v in self.items())
+                for k, v in items:
+                    if out:
+                        out.append(NL)
+                    out.append("{}{}- {}: ".format(indent, ("  " * _depth), k))
+                    if isinstance(v, ParseResults):
+                        if v:
+                            out.append(
+                                v.dump(
+                                    indent=indent,
+                                    full=full,
+                                    include_list=include_list,
+                                    _depth=_depth + 1,
+                                )
+                            )
+                        else:
+                            out.append(str(v))
+                    else:
+                        out.append(repr(v))
+            if any(isinstance(vv, ParseResults) for vv in self):
+                v = self
+                for i, vv in enumerate(v):
+                    if isinstance(vv, ParseResults):
+                        out.append(
+                            "\n{}{}[{}]:\n{}{}{}".format(
+                                indent,
+                                ("  " * (_depth)),
+                                i,
+                                indent,
+                                ("  " * (_depth + 1)),
+                                vv.dump(
+                                    indent=indent,
+                                    full=full,
+                                    include_list=include_list,
+                                    _depth=_depth + 1,
+                                ),
+                            )
+                        )
+                    else:
+                        out.append(
+                            "\n%s%s[%d]:\n%s%s%s"
+                            % (
+                                indent,
+                                ("  " * (_depth)),
+                                i,
+                                indent,
+                                ("  " * (_depth + 1)),
+                                str(vv),
+                            )
+                        )
+
+        return "".join(out)
+
+    def pprint(self, *args, **kwargs):
+        """
+        Pretty-printer for parsed results as a list, using the
+        `pprint <https://docs.python.org/3/library/pprint.html>`_ module.
+        Accepts additional positional or keyword args as defined for
+        `pprint.pprint <https://docs.python.org/3/library/pprint.html#pprint.pprint>`_ .
+
+        Example::
+
+            ident = Word(alphas, alphanums)
+            num = Word(nums)
+            func = Forward()
+            term = ident | num | Group('(' + func + ')')
+            func <<= ident + Group(Optional(delimited_list(term)))
+            result = func.parse_string("fna a,b,(fnb c,d,200),100")
+            result.pprint(width=40)
+
+        prints::
+
+            ['fna',
+             ['a',
+              'b',
+              ['(', 'fnb', ['c', 'd', '200'], ')'],
+              '100']]
+        """
+        pprint.pprint(self.as_list(), *args, **kwargs)
+
+    # add support for pickle protocol
+    def __getstate__(self):
+        return (
+            self._toklist,
+            (
+                self._tokdict.copy(),
+                self._parent is not None and self._parent() or None,
+                self._all_names,
+                self._name,
+            ),
+        )
+
+    def __setstate__(self, state):
+        self._toklist, (self._tokdict, par, inAccumNames, self._name) = state
+        self._all_names = set(inAccumNames)
+        if par is not None:
+            self._parent = wkref(par)
+        else:
+            self._parent = None
+
+    def __getnewargs__(self):
+        return self._toklist, self._name
+
+    def __dir__(self):
+        return dir(type(self)) + list(self.keys())
+
+    @classmethod
+    def from_dict(cls, other, name=None) -> "ParseResults":
+        """
+        Helper classmethod to construct a ``ParseResults`` from a ``dict``, preserving the
+        name-value relations as results names. If an optional ``name`` argument is
+        given, a nested ``ParseResults`` will be returned.
+        """
+
+        def is_iterable(obj):
+            try:
+                iter(obj)
+            except Exception:
+                return False
+            else:
+                return not isinstance(obj, str_type)
+
+        ret = cls([])
+        for k, v in other.items():
+            if isinstance(v, Mapping):
+                ret += cls.from_dict(v, name=k)
+            else:
+                ret += cls([v], name=k, asList=is_iterable(v))
+        if name is not None:
+            ret = cls([ret], name=name)
+        return ret
+
+    asList = as_list
+    asDict = as_dict
+    getName = get_name
+
+
+MutableMapping.register(ParseResults)
+MutableSequence.register(ParseResults)
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/testing.py b/myenv/lib/python3.9/site-packages/pyparsing/testing.py
new file mode 100644
index 0000000..84a0ef1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing/testing.py
@@ -0,0 +1,331 @@
+# testing.py
+
+from contextlib import contextmanager
+import typing
+
+from .core import (
+    ParserElement,
+    ParseException,
+    Keyword,
+    __diag__,
+    __compat__,
+)
+
+
+class pyparsing_test:
+    """
+    namespace class for classes useful in writing unit tests
+    """
+
+    class reset_pyparsing_context:
+        """
+        Context manager to be used when writing unit tests that modify pyparsing config values:
+        - packrat parsing
+        - bounded recursion parsing
+        - default whitespace characters.
+        - default keyword characters
+        - literal string auto-conversion class
+        - __diag__ settings
+
+        Example::
+
+            with reset_pyparsing_context():
+                # test that literals used to construct a grammar are automatically suppressed
+                ParserElement.inlineLiteralsUsing(Suppress)
+
+                term = Word(alphas) | Word(nums)
+                group = Group('(' + term[...] + ')')
+
+                # assert that the '()' characters are not included in the parsed tokens
+                self.assertParseAndCheckList(group, "(abc 123 def)", ['abc', '123', 'def'])
+
+            # after exiting context manager, literals are converted to Literal expressions again
+        """
+
+        def __init__(self):
+            self._save_context = {}
+
+        def save(self):
+            self._save_context["default_whitespace"] = ParserElement.DEFAULT_WHITE_CHARS
+            self._save_context["default_keyword_chars"] = Keyword.DEFAULT_KEYWORD_CHARS
+
+            self._save_context[
+                "literal_string_class"
+            ] = ParserElement._literalStringClass
+
+            self._save_context["verbose_stacktrace"] = ParserElement.verbose_stacktrace
+
+            self._save_context["packrat_enabled"] = ParserElement._packratEnabled
+            if ParserElement._packratEnabled:
+                self._save_context[
+                    "packrat_cache_size"
+                ] = ParserElement.packrat_cache.size
+            else:
+                self._save_context["packrat_cache_size"] = None
+            self._save_context["packrat_parse"] = ParserElement._parse
+            self._save_context[
+                "recursion_enabled"
+            ] = ParserElement._left_recursion_enabled
+
+            self._save_context["__diag__"] = {
+                name: getattr(__diag__, name) for name in __diag__._all_names
+            }
+
+            self._save_context["__compat__"] = {
+                "collect_all_And_tokens": __compat__.collect_all_And_tokens
+            }
+
+            return self
+
+        def restore(self):
+            # reset pyparsing global state
+            if (
+                ParserElement.DEFAULT_WHITE_CHARS
+                != self._save_context["default_whitespace"]
+            ):
+                ParserElement.set_default_whitespace_chars(
+                    self._save_context["default_whitespace"]
+                )
+
+            ParserElement.verbose_stacktrace = self._save_context["verbose_stacktrace"]
+
+            Keyword.DEFAULT_KEYWORD_CHARS = self._save_context["default_keyword_chars"]
+            ParserElement.inlineLiteralsUsing(
+                self._save_context["literal_string_class"]
+            )
+
+            for name, value in self._save_context["__diag__"].items():
+                (__diag__.enable if value else __diag__.disable)(name)
+
+            ParserElement._packratEnabled = False
+            if self._save_context["packrat_enabled"]:
+                ParserElement.enable_packrat(self._save_context["packrat_cache_size"])
+            else:
+                ParserElement._parse = self._save_context["packrat_parse"]
+            ParserElement._left_recursion_enabled = self._save_context[
+                "recursion_enabled"
+            ]
+
+            __compat__.collect_all_And_tokens = self._save_context["__compat__"]
+
+            return self
+
+        def copy(self):
+            ret = type(self)()
+            ret._save_context.update(self._save_context)
+            return ret
+
+        def __enter__(self):
+            return self.save()
+
+        def __exit__(self, *args):
+            self.restore()
+
+    class TestParseResultsAsserts:
+        """
+        A mixin class to add parse results assertion methods to normal unittest.TestCase classes.
+        """
+
+        def assertParseResultsEquals(
+            self, result, expected_list=None, expected_dict=None, msg=None
+        ):
+            """
+            Unit test assertion to compare a :class:`ParseResults` object with an optional ``expected_list``,
+            and compare any defined results names with an optional ``expected_dict``.
+            """
+            if expected_list is not None:
+                self.assertEqual(expected_list, result.as_list(), msg=msg)
+            if expected_dict is not None:
+                self.assertEqual(expected_dict, result.as_dict(), msg=msg)
+
+        def assertParseAndCheckList(
+            self, expr, test_string, expected_list, msg=None, verbose=True
+        ):
+            """
+            Convenience wrapper assert to test a parser element and input string, and assert that
+            the resulting ``ParseResults.asList()`` is equal to the ``expected_list``.
+            """
+            result = expr.parse_string(test_string, parse_all=True)
+            if verbose:
+                print(result.dump())
+            else:
+                print(result.as_list())
+            self.assertParseResultsEquals(result, expected_list=expected_list, msg=msg)
+
+        def assertParseAndCheckDict(
+            self, expr, test_string, expected_dict, msg=None, verbose=True
+        ):
+            """
+            Convenience wrapper assert to test a parser element and input string, and assert that
+            the resulting ``ParseResults.asDict()`` is equal to the ``expected_dict``.
+            """
+            result = expr.parse_string(test_string, parseAll=True)
+            if verbose:
+                print(result.dump())
+            else:
+                print(result.as_list())
+            self.assertParseResultsEquals(result, expected_dict=expected_dict, msg=msg)
+
+        def assertRunTestResults(
+            self, run_tests_report, expected_parse_results=None, msg=None
+        ):
+            """
+            Unit test assertion to evaluate output of ``ParserElement.runTests()``. If a list of
+            list-dict tuples is given as the ``expected_parse_results`` argument, then these are zipped
+            with the report tuples returned by ``runTests`` and evaluated using ``assertParseResultsEquals``.
+            Finally, asserts that the overall ``runTests()`` success value is ``True``.
+
+            :param run_tests_report: tuple(bool, [tuple(str, ParseResults or Exception)]) returned from runTests
+            :param expected_parse_results (optional): [tuple(str, list, dict, Exception)]
+            """
+            run_test_success, run_test_results = run_tests_report
+
+            if expected_parse_results is not None:
+                merged = [
+                    (*rpt, expected)
+                    for rpt, expected in zip(run_test_results, expected_parse_results)
+                ]
+                for test_string, result, expected in merged:
+                    # expected should be a tuple containing a list and/or a dict or an exception,
+                    # and optional failure message string
+                    # an empty tuple will skip any result validation
+                    fail_msg = next(
+                        (exp for exp in expected if isinstance(exp, str)), None
+                    )
+                    expected_exception = next(
+                        (
+                            exp
+                            for exp in expected
+                            if isinstance(exp, type) and issubclass(exp, Exception)
+                        ),
+                        None,
+                    )
+                    if expected_exception is not None:
+                        with self.assertRaises(
+                            expected_exception=expected_exception, msg=fail_msg or msg
+                        ):
+                            if isinstance(result, Exception):
+                                raise result
+                    else:
+                        expected_list = next(
+                            (exp for exp in expected if isinstance(exp, list)), None
+                        )
+                        expected_dict = next(
+                            (exp for exp in expected if isinstance(exp, dict)), None
+                        )
+                        if (expected_list, expected_dict) != (None, None):
+                            self.assertParseResultsEquals(
+                                result,
+                                expected_list=expected_list,
+                                expected_dict=expected_dict,
+                                msg=fail_msg or msg,
+                            )
+                        else:
+                            # warning here maybe?
+                            print("no validation for {!r}".format(test_string))
+
+            # do this last, in case some specific test results can be reported instead
+            self.assertTrue(
+                run_test_success, msg=msg if msg is not None else "failed runTests"
+            )
+
+        @contextmanager
+        def assertRaisesParseException(self, exc_type=ParseException, msg=None):
+            with self.assertRaises(exc_type, msg=msg):
+                yield
+
+    @staticmethod
+    def with_line_numbers(
+        s: str,
+        start_line: typing.Optional[int] = None,
+        end_line: typing.Optional[int] = None,
+        expand_tabs: bool = True,
+        eol_mark: str = "|",
+        mark_spaces: typing.Optional[str] = None,
+        mark_control: typing.Optional[str] = None,
+    ) -> str:
+        """
+        Helpful method for debugging a parser - prints a string with line and column numbers.
+        (Line and column numbers are 1-based.)
+
+        :param s: tuple(bool, str - string to be printed with line and column numbers
+        :param start_line: int - (optional) starting line number in s to print (default=1)
+        :param end_line: int - (optional) ending line number in s to print (default=len(s))
+        :param expand_tabs: bool - (optional) expand tabs to spaces, to match the pyparsing default
+        :param eol_mark: str - (optional) string to mark the end of lines, helps visualize trailing spaces (default="|")
+        :param mark_spaces: str - (optional) special character to display in place of spaces
+        :param mark_control: str - (optional) convert non-printing control characters to a placeholding
+                                 character; valid values:
+                                 - "unicode" - replaces control chars with Unicode symbols, such as "␍" and "␊"
+                                 - any single character string - replace control characters with given string
+                                 - None (default) - string is displayed as-is
+
+        :return: str - input string with leading line numbers and column number headers
+        """
+        if expand_tabs:
+            s = s.expandtabs()
+        if mark_control is not None:
+            if mark_control == "unicode":
+                tbl = str.maketrans(
+                    {c: u for c, u in zip(range(0, 33), range(0x2400, 0x2433))}
+                    | {127: 0x2421}
+                )
+                eol_mark = ""
+            else:
+                tbl = str.maketrans(
+                    {c: mark_control for c in list(range(0, 32)) + [127]}
+                )
+            s = s.translate(tbl)
+        if mark_spaces is not None and mark_spaces != " ":
+            if mark_spaces == "unicode":
+                tbl = str.maketrans({9: 0x2409, 32: 0x2423})
+                s = s.translate(tbl)
+            else:
+                s = s.replace(" ", mark_spaces)
+        if start_line is None:
+            start_line = 1
+        if end_line is None:
+            end_line = len(s)
+        end_line = min(end_line, len(s))
+        start_line = min(max(1, start_line), end_line)
+
+        if mark_control != "unicode":
+            s_lines = s.splitlines()[start_line - 1 : end_line]
+        else:
+            s_lines = [line + "␊" for line in s.split("␊")[start_line - 1 : end_line]]
+        if not s_lines:
+            return ""
+
+        lineno_width = len(str(end_line))
+        max_line_len = max(len(line) for line in s_lines)
+        lead = " " * (lineno_width + 1)
+        if max_line_len >= 99:
+            header0 = (
+                lead
+                + "".join(
+                    "{}{}".format(" " * 99, (i + 1) % 100)
+                    for i in range(max(max_line_len // 100, 1))
+                )
+                + "\n"
+            )
+        else:
+            header0 = ""
+        header1 = (
+            header0
+            + lead
+            + "".join(
+                "         {}".format((i + 1) % 10)
+                for i in range(-(-max_line_len // 10))
+            )
+            + "\n"
+        )
+        header2 = lead + "1234567890" * (-(-max_line_len // 10)) + "\n"
+        return (
+            header1
+            + header2
+            + "\n".join(
+                "{:{}d}:{}{}".format(i, lineno_width, line, eol_mark)
+                for i, line in enumerate(s_lines, start=start_line)
+            )
+            + "\n"
+        )
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/unicode.py b/myenv/lib/python3.9/site-packages/pyparsing/unicode.py
new file mode 100644
index 0000000..0652620
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing/unicode.py
@@ -0,0 +1,352 @@
+# unicode.py
+
+import sys
+from itertools import filterfalse
+from typing import List, Tuple, Union
+
+
+class _lazyclassproperty:
+    def __init__(self, fn):
+        self.fn = fn
+        self.__doc__ = fn.__doc__
+        self.__name__ = fn.__name__
+
+    def __get__(self, obj, cls):
+        if cls is None:
+            cls = type(obj)
+        if not hasattr(cls, "_intern") or any(
+            cls._intern is getattr(superclass, "_intern", [])
+            for superclass in cls.__mro__[1:]
+        ):
+            cls._intern = {}
+        attrname = self.fn.__name__
+        if attrname not in cls._intern:
+            cls._intern[attrname] = self.fn(cls)
+        return cls._intern[attrname]
+
+
+UnicodeRangeList = List[Union[Tuple[int, int], Tuple[int]]]
+
+
+class unicode_set:
+    """
+    A set of Unicode characters, for language-specific strings for
+    ``alphas``, ``nums``, ``alphanums``, and ``printables``.
+    A unicode_set is defined by a list of ranges in the Unicode character
+    set, in a class attribute ``_ranges``. Ranges can be specified using
+    2-tuples or a 1-tuple, such as::
+
+        _ranges = [
+            (0x0020, 0x007e),
+            (0x00a0, 0x00ff),
+            (0x0100,),
+            ]
+
+    Ranges are left- and right-inclusive. A 1-tuple of (x,) is treated as (x, x).
+
+    A unicode set can also be defined using multiple inheritance of other unicode sets::
+
+        class CJK(Chinese, Japanese, Korean):
+            pass
+    """
+
+    _ranges: UnicodeRangeList = []
+
+    @_lazyclassproperty
+    def _chars_for_ranges(cls):
+        ret = []
+        for cc in cls.__mro__:
+            if cc is unicode_set:
+                break
+            for rr in getattr(cc, "_ranges", ()):
+                ret.extend(range(rr[0], rr[-1] + 1))
+        return [chr(c) for c in sorted(set(ret))]
+
+    @_lazyclassproperty
+    def printables(cls):
+        "all non-whitespace characters in this range"
+        return "".join(filterfalse(str.isspace, cls._chars_for_ranges))
+
+    @_lazyclassproperty
+    def alphas(cls):
+        "all alphabetic characters in this range"
+        return "".join(filter(str.isalpha, cls._chars_for_ranges))
+
+    @_lazyclassproperty
+    def nums(cls):
+        "all numeric digit characters in this range"
+        return "".join(filter(str.isdigit, cls._chars_for_ranges))
+
+    @_lazyclassproperty
+    def alphanums(cls):
+        "all alphanumeric characters in this range"
+        return cls.alphas + cls.nums
+
+    @_lazyclassproperty
+    def identchars(cls):
+        "all characters in this range that are valid identifier characters, plus underscore '_'"
+        return "".join(
+            sorted(
+                set(
+                    "".join(filter(str.isidentifier, cls._chars_for_ranges))
+                    + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzªµº"
+                    + "ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ"
+                    + "_"
+                )
+            )
+        )
+
+    @_lazyclassproperty
+    def identbodychars(cls):
+        """
+        all characters in this range that are valid identifier body characters,
+        plus the digits 0-9
+        """
+        return "".join(
+            sorted(
+                set(
+                    cls.identchars
+                    + "0123456789"
+                    + "".join(
+                        [c for c in cls._chars_for_ranges if ("_" + c).isidentifier()]
+                    )
+                )
+            )
+        )
+
+
+class pyparsing_unicode(unicode_set):
+    """
+    A namespace class for defining common language unicode_sets.
+    """
+
+    # fmt: off
+
+    # define ranges in language character sets
+    _ranges: UnicodeRangeList = [
+        (0x0020, sys.maxunicode),
+    ]
+
+    class BasicMultilingualPlane(unicode_set):
+        "Unicode set for the Basic Multilingual Plane"
+        _ranges: UnicodeRangeList = [
+            (0x0020, 0xFFFF),
+        ]
+
+    class Latin1(unicode_set):
+        "Unicode set for Latin-1 Unicode Character Range"
+        _ranges: UnicodeRangeList = [
+            (0x0020, 0x007E),
+            (0x00A0, 0x00FF),
+        ]
+
+    class LatinA(unicode_set):
+        "Unicode set for Latin-A Unicode Character Range"
+        _ranges: UnicodeRangeList = [
+            (0x0100, 0x017F),
+        ]
+
+    class LatinB(unicode_set):
+        "Unicode set for Latin-B Unicode Character Range"
+        _ranges: UnicodeRangeList = [
+            (0x0180, 0x024F),
+        ]
+
+    class Greek(unicode_set):
+        "Unicode set for Greek Unicode Character Ranges"
+        _ranges: UnicodeRangeList = [
+            (0x0342, 0x0345),
+            (0x0370, 0x0377),
+            (0x037A, 0x037F),
+            (0x0384, 0x038A),
+            (0x038C,),
+            (0x038E, 0x03A1),
+            (0x03A3, 0x03E1),
+            (0x03F0, 0x03FF),
+            (0x1D26, 0x1D2A),
+            (0x1D5E,),
+            (0x1D60,),
+            (0x1D66, 0x1D6A),
+            (0x1F00, 0x1F15),
+            (0x1F18, 0x1F1D),
+            (0x1F20, 0x1F45),
+            (0x1F48, 0x1F4D),
+            (0x1F50, 0x1F57),
+            (0x1F59,),
+            (0x1F5B,),
+            (0x1F5D,),
+            (0x1F5F, 0x1F7D),
+            (0x1F80, 0x1FB4),
+            (0x1FB6, 0x1FC4),
+            (0x1FC6, 0x1FD3),
+            (0x1FD6, 0x1FDB),
+            (0x1FDD, 0x1FEF),
+            (0x1FF2, 0x1FF4),
+            (0x1FF6, 0x1FFE),
+            (0x2129,),
+            (0x2719, 0x271A),
+            (0xAB65,),
+            (0x10140, 0x1018D),
+            (0x101A0,),
+            (0x1D200, 0x1D245),
+            (0x1F7A1, 0x1F7A7),
+        ]
+
+    class Cyrillic(unicode_set):
+        "Unicode set for Cyrillic Unicode Character Range"
+        _ranges: UnicodeRangeList = [
+            (0x0400, 0x052F),
+            (0x1C80, 0x1C88),
+            (0x1D2B,),
+            (0x1D78,),
+            (0x2DE0, 0x2DFF),
+            (0xA640, 0xA672),
+            (0xA674, 0xA69F),
+            (0xFE2E, 0xFE2F),
+        ]
+
+    class Chinese(unicode_set):
+        "Unicode set for Chinese Unicode Character Range"
+        _ranges: UnicodeRangeList = [
+            (0x2E80, 0x2E99),
+            (0x2E9B, 0x2EF3),
+            (0x31C0, 0x31E3),
+            (0x3400, 0x4DB5),
+            (0x4E00, 0x9FEF),
+            (0xA700, 0xA707),
+            (0xF900, 0xFA6D),
+            (0xFA70, 0xFAD9),
+            (0x16FE2, 0x16FE3),
+            (0x1F210, 0x1F212),
+            (0x1F214, 0x1F23B),
+            (0x1F240, 0x1F248),
+            (0x20000, 0x2A6D6),
+            (0x2A700, 0x2B734),
+            (0x2B740, 0x2B81D),
+            (0x2B820, 0x2CEA1),
+            (0x2CEB0, 0x2EBE0),
+            (0x2F800, 0x2FA1D),
+        ]
+
+    class Japanese(unicode_set):
+        "Unicode set for Japanese Unicode Character Range, combining Kanji, Hiragana, and Katakana ranges"
+        _ranges: UnicodeRangeList = []
+
+        class Kanji(unicode_set):
+            "Unicode set for Kanji Unicode Character Range"
+            _ranges: UnicodeRangeList = [
+                (0x4E00, 0x9FBF),
+                (0x3000, 0x303F),
+            ]
+
+        class Hiragana(unicode_set):
+            "Unicode set for Hiragana Unicode Character Range"
+            _ranges: UnicodeRangeList = [
+                (0x3041, 0x3096),
+                (0x3099, 0x30A0),
+                (0x30FC,),
+                (0xFF70,),
+                (0x1B001,),
+                (0x1B150, 0x1B152),
+                (0x1F200,),
+            ]
+
+        class Katakana(unicode_set):
+            "Unicode set for Katakana  Unicode Character Range"
+            _ranges: UnicodeRangeList = [
+                (0x3099, 0x309C),
+                (0x30A0, 0x30FF),
+                (0x31F0, 0x31FF),
+                (0x32D0, 0x32FE),
+                (0xFF65, 0xFF9F),
+                (0x1B000,),
+                (0x1B164, 0x1B167),
+                (0x1F201, 0x1F202),
+                (0x1F213,),
+            ]
+
+    class Hangul(unicode_set):
+        "Unicode set for Hangul (Korean) Unicode Character Range"
+        _ranges: UnicodeRangeList = [
+            (0x1100, 0x11FF),
+            (0x302E, 0x302F),
+            (0x3131, 0x318E),
+            (0x3200, 0x321C),
+            (0x3260, 0x327B),
+            (0x327E,),
+            (0xA960, 0xA97C),
+            (0xAC00, 0xD7A3),
+            (0xD7B0, 0xD7C6),
+            (0xD7CB, 0xD7FB),
+            (0xFFA0, 0xFFBE),
+            (0xFFC2, 0xFFC7),
+            (0xFFCA, 0xFFCF),
+            (0xFFD2, 0xFFD7),
+            (0xFFDA, 0xFFDC),
+        ]
+
+    Korean = Hangul
+
+    class CJK(Chinese, Japanese, Hangul):
+        "Unicode set for combined Chinese, Japanese, and Korean (CJK) Unicode Character Range"
+
+    class Thai(unicode_set):
+        "Unicode set for Thai Unicode Character Range"
+        _ranges: UnicodeRangeList = [
+            (0x0E01, 0x0E3A),
+            (0x0E3F, 0x0E5B)
+        ]
+
+    class Arabic(unicode_set):
+        "Unicode set for Arabic Unicode Character Range"
+        _ranges: UnicodeRangeList = [
+            (0x0600, 0x061B),
+            (0x061E, 0x06FF),
+            (0x0700, 0x077F),
+        ]
+
+    class Hebrew(unicode_set):
+        "Unicode set for Hebrew Unicode Character Range"
+        _ranges: UnicodeRangeList = [
+            (0x0591, 0x05C7),
+            (0x05D0, 0x05EA),
+            (0x05EF, 0x05F4),
+            (0xFB1D, 0xFB36),
+            (0xFB38, 0xFB3C),
+            (0xFB3E,),
+            (0xFB40, 0xFB41),
+            (0xFB43, 0xFB44),
+            (0xFB46, 0xFB4F),
+        ]
+
+    class Devanagari(unicode_set):
+        "Unicode set for Devanagari Unicode Character Range"
+        _ranges: UnicodeRangeList = [
+            (0x0900, 0x097F),
+            (0xA8E0, 0xA8FF)
+        ]
+
+    # fmt: on
+
+
+pyparsing_unicode.Japanese._ranges = (
+    pyparsing_unicode.Japanese.Kanji._ranges
+    + pyparsing_unicode.Japanese.Hiragana._ranges
+    + pyparsing_unicode.Japanese.Katakana._ranges
+)
+
+pyparsing_unicode.BMP = pyparsing_unicode.BasicMultilingualPlane
+
+# add language identifiers using language Unicode
+pyparsing_unicode.العربية = pyparsing_unicode.Arabic
+pyparsing_unicode.中文 = pyparsing_unicode.Chinese
+pyparsing_unicode.кириллица = pyparsing_unicode.Cyrillic
+pyparsing_unicode.Ελληνικά = pyparsing_unicode.Greek
+pyparsing_unicode.עִברִית = pyparsing_unicode.Hebrew
+pyparsing_unicode.日本語 = pyparsing_unicode.Japanese
+pyparsing_unicode.Japanese.漢字 = pyparsing_unicode.Japanese.Kanji
+pyparsing_unicode.Japanese.カタカナ = pyparsing_unicode.Japanese.Katakana
+pyparsing_unicode.Japanese.ひらがな = pyparsing_unicode.Japanese.Hiragana
+pyparsing_unicode.한국어 = pyparsing_unicode.Korean
+pyparsing_unicode.ไทย = pyparsing_unicode.Thai
+pyparsing_unicode.देवनागरी = pyparsing_unicode.Devanagari
diff --git a/myenv/lib/python3.9/site-packages/pyparsing/util.py b/myenv/lib/python3.9/site-packages/pyparsing/util.py
new file mode 100644
index 0000000..34ce092
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pyparsing/util.py
@@ -0,0 +1,235 @@
+# util.py
+import warnings
+import types
+import collections
+import itertools
+from functools import lru_cache
+from typing import List, Union, Iterable
+
+_bslash = chr(92)
+
+
+class __config_flags:
+    """Internal class for defining compatibility and debugging flags"""
+
+    _all_names: List[str] = []
+    _fixed_names: List[str] = []
+    _type_desc = "configuration"
+
+    @classmethod
+    def _set(cls, dname, value):
+        if dname in cls._fixed_names:
+            warnings.warn(
+                "{}.{} {} is {} and cannot be overridden".format(
+                    cls.__name__,
+                    dname,
+                    cls._type_desc,
+                    str(getattr(cls, dname)).upper(),
+                )
+            )
+            return
+        if dname in cls._all_names:
+            setattr(cls, dname, value)
+        else:
+            raise ValueError("no such {} {!r}".format(cls._type_desc, dname))
+
+    enable = classmethod(lambda cls, name: cls._set(name, True))
+    disable = classmethod(lambda cls, name: cls._set(name, False))
+
+
+@lru_cache(maxsize=128)
+def col(loc: int, strg: str) -> int:
+    """
+    Returns current column within a string, counting newlines as line separators.
+    The first column is number 1.
+
+    Note: the default parsing behavior is to expand tabs in the input string
+    before starting the parsing process.  See
+    :class:`ParserElement.parseString` for more
+    information on parsing strings containing ``<TAB>`` s, and suggested
+    methods to maintain a consistent view of the parsed string, the parse
+    location, and line and column positions within the parsed string.
+    """
+    s = strg
+    return 1 if 0 < loc < len(s) and s[loc - 1] == "\n" else loc - s.rfind("\n", 0, loc)
+
+
+@lru_cache(maxsize=128)
+def lineno(loc: int, strg: str) -> int:
+    """Returns current line number within a string, counting newlines as line separators.
+    The first line is number 1.
+
+    Note - the default parsing behavior is to expand tabs in the input string
+    before starting the parsing process.  See :class:`ParserElement.parseString`
+    for more information on parsing strings containing ``<TAB>`` s, and
+    suggested methods to maintain a consistent view of the parsed string, the
+    parse location, and line and column positions within the parsed string.
+    """
+    return strg.count("\n", 0, loc) + 1
+
+
+@lru_cache(maxsize=128)
+def line(loc: int, strg: str) -> str:
+    """
+    Returns the line of text containing loc within a string, counting newlines as line separators.
+    """
+    last_cr = strg.rfind("\n", 0, loc)
+    next_cr = strg.find("\n", loc)
+    return strg[last_cr + 1 : next_cr] if next_cr >= 0 else strg[last_cr + 1 :]
+
+
+class _UnboundedCache:
+    def __init__(self):
+        cache = {}
+        cache_get = cache.get
+        self.not_in_cache = not_in_cache = object()
+
+        def get(_, key):
+            return cache_get(key, not_in_cache)
+
+        def set_(_, key, value):
+            cache[key] = value
+
+        def clear(_):
+            cache.clear()
+
+        self.size = None
+        self.get = types.MethodType(get, self)
+        self.set = types.MethodType(set_, self)
+        self.clear = types.MethodType(clear, self)
+
+
+class _FifoCache:
+    def __init__(self, size):
+        self.not_in_cache = not_in_cache = object()
+        cache = collections.OrderedDict()
+        cache_get = cache.get
+
+        def get(_, key):
+            return cache_get(key, not_in_cache)
+
+        def set_(_, key, value):
+            cache[key] = value
+            while len(cache) > size:
+                cache.popitem(last=False)
+
+        def clear(_):
+            cache.clear()
+
+        self.size = size
+        self.get = types.MethodType(get, self)
+        self.set = types.MethodType(set_, self)
+        self.clear = types.MethodType(clear, self)
+
+
+class LRUMemo:
+    """
+    A memoizing mapping that retains `capacity` deleted items
+
+    The memo tracks retained items by their access order; once `capacity` items
+    are retained, the least recently used item is discarded.
+    """
+
+    def __init__(self, capacity):
+        self._capacity = capacity
+        self._active = {}
+        self._memory = collections.OrderedDict()
+
+    def __getitem__(self, key):
+        try:
+            return self._active[key]
+        except KeyError:
+            self._memory.move_to_end(key)
+            return self._memory[key]
+
+    def __setitem__(self, key, value):
+        self._memory.pop(key, None)
+        self._active[key] = value
+
+    def __delitem__(self, key):
+        try:
+            value = self._active.pop(key)
+        except KeyError:
+            pass
+        else:
+            while len(self._memory) >= self._capacity:
+                self._memory.popitem(last=False)
+            self._memory[key] = value
+
+    def clear(self):
+        self._active.clear()
+        self._memory.clear()
+
+
+class UnboundedMemo(dict):
+    """
+    A memoizing mapping that retains all deleted items
+    """
+
+    def __delitem__(self, key):
+        pass
+
+
+def _escape_regex_range_chars(s: str) -> str:
+    # escape these chars: ^-[]
+    for c in r"\^-[]":
+        s = s.replace(c, _bslash + c)
+    s = s.replace("\n", r"\n")
+    s = s.replace("\t", r"\t")
+    return str(s)
+
+
+def _collapse_string_to_ranges(
+    s: Union[str, Iterable[str]], re_escape: bool = True
+) -> str:
+    def is_consecutive(c):
+        c_int = ord(c)
+        is_consecutive.prev, prev = c_int, is_consecutive.prev
+        if c_int - prev > 1:
+            is_consecutive.value = next(is_consecutive.counter)
+        return is_consecutive.value
+
+    is_consecutive.prev = 0
+    is_consecutive.counter = itertools.count()
+    is_consecutive.value = -1
+
+    def escape_re_range_char(c):
+        return "\\" + c if c in r"\^-][" else c
+
+    def no_escape_re_range_char(c):
+        return c
+
+    if not re_escape:
+        escape_re_range_char = no_escape_re_range_char
+
+    ret = []
+    s = "".join(sorted(set(s)))
+    if len(s) > 3:
+        for _, chars in itertools.groupby(s, key=is_consecutive):
+            first = last = next(chars)
+            last = collections.deque(
+                itertools.chain(iter([last]), chars), maxlen=1
+            ).pop()
+            if first == last:
+                ret.append(escape_re_range_char(first))
+            else:
+                sep = "" if ord(last) == ord(first) + 1 else "-"
+                ret.append(
+                    "{}{}{}".format(
+                        escape_re_range_char(first), sep, escape_re_range_char(last)
+                    )
+                )
+    else:
+        ret = [escape_re_range_char(c) for c in s]
+
+    return "".join(ret)
+
+
+def _flatten(ll: list) -> list:
+    ret = []
+    for i in ll:
+        if isinstance(i, list):
+            ret.extend(_flatten(i))
+        else:
+            ret.append(i)
+    return ret
diff --git a/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/LICENSE
new file mode 100644
index 0000000..d14fb7f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2004-2020 Holger Krekel and others
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/METADATA b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/METADATA
new file mode 100644
index 0000000..ee9a695
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/METADATA
@@ -0,0 +1,215 @@
+Metadata-Version: 2.1
+Name: pytest
+Version: 6.2.5
+Summary: pytest: simple powerful testing with Python
+Home-page: https://docs.pytest.org/en/latest/
+Author: Holger Krekel, Bruno Oliveira, Ronny Pfannschmidt, Floris Bruynooghe, Brianna Laugher, Florian Bruhin and others
+License: MIT
+Project-URL: Changelog, https://docs.pytest.org/en/stable/changelog.html
+Project-URL: Twitter, https://twitter.com/pytestdotorg
+Project-URL: Source, https://github.com/pytest-dev/pytest
+Project-URL: Tracker, https://github.com/pytest-dev/pytest/issues
+Keywords: test,unittest
+Platform: unix
+Platform: linux
+Platform: osx
+Platform: cygwin
+Platform: win32
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.6
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: attrs (>=19.2.0)
+Requires-Dist: iniconfig
+Requires-Dist: packaging
+Requires-Dist: pluggy (<2.0,>=0.12)
+Requires-Dist: py (>=1.8.2)
+Requires-Dist: toml
+Requires-Dist: importlib-metadata (>=0.12) ; python_version < "3.8"
+Requires-Dist: atomicwrites (>=1.0) ; sys_platform == "win32"
+Requires-Dist: colorama ; sys_platform == "win32"
+Provides-Extra: testing
+Requires-Dist: argcomplete ; extra == 'testing'
+Requires-Dist: hypothesis (>=3.56) ; extra == 'testing'
+Requires-Dist: mock ; extra == 'testing'
+Requires-Dist: nose ; extra == 'testing'
+Requires-Dist: requests ; extra == 'testing'
+Requires-Dist: xmlschema ; extra == 'testing'
+
+.. image:: https://github.com/pytest-dev/pytest/raw/main/doc/en/img/pytest_logo_curves.svg
+   :target: https://docs.pytest.org/en/stable/
+   :align: center
+   :alt: pytest
+
+
+------
+
+.. image:: https://img.shields.io/pypi/v/pytest.svg
+    :target: https://pypi.org/project/pytest/
+
+.. image:: https://img.shields.io/conda/vn/conda-forge/pytest.svg
+    :target: https://anaconda.org/conda-forge/pytest
+
+.. image:: https://img.shields.io/pypi/pyversions/pytest.svg
+    :target: https://pypi.org/project/pytest/
+
+.. image:: https://codecov.io/gh/pytest-dev/pytest/branch/main/graph/badge.svg
+    :target: https://codecov.io/gh/pytest-dev/pytest
+    :alt: Code coverage Status
+
+.. image:: https://travis-ci.org/pytest-dev/pytest.svg?branch=master
+    :target: https://travis-ci.org/pytest-dev/pytest
+
+.. image:: https://github.com/pytest-dev/pytest/workflows/main/badge.svg
+    :target: https://github.com/pytest-dev/pytest/actions?query=workflow%3Amain
+
+.. image:: https://results.pre-commit.ci/badge/github/pytest-dev/pytest/main.svg
+   :target: https://results.pre-commit.ci/latest/github/pytest-dev/pytest/master
+   :alt: pre-commit.ci status
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/psf/black
+
+.. image:: https://www.codetriage.com/pytest-dev/pytest/badges/users.svg
+    :target: https://www.codetriage.com/pytest-dev/pytest
+
+.. image:: https://readthedocs.org/projects/pytest/badge/?version=latest
+    :target: https://pytest.readthedocs.io/en/latest/?badge=latest
+    :alt: Documentation Status
+
+The ``pytest`` framework makes it easy to write small tests, yet
+scales to support complex functional testing for applications and libraries.
+
+An example of a simple test:
+
+.. code-block:: python
+
+    # content of test_sample.py
+    def inc(x):
+        return x + 1
+
+
+    def test_answer():
+        assert inc(3) == 5
+
+
+To execute it::
+
+    $ pytest
+    ============================= test session starts =============================
+    collected 1 items
+
+    test_sample.py F
+
+    ================================== FAILURES ===================================
+    _________________________________ test_answer _________________________________
+
+        def test_answer():
+    >       assert inc(3) == 5
+    E       assert 4 == 5
+    E        +  where 4 = inc(3)
+
+    test_sample.py:5: AssertionError
+    ========================== 1 failed in 0.04 seconds ===========================
+
+
+Due to ``pytest``'s detailed assertion introspection, only plain ``assert`` statements are used. See `getting-started <https://docs.pytest.org/en/stable/getting-started.html#our-first-test-run>`_ for more examples.
+
+
+Features
+--------
+
+- Detailed info on failing `assert statements <https://docs.pytest.org/en/stable/assert.html>`_ (no need to remember ``self.assert*`` names)
+
+- `Auto-discovery
+  <https://docs.pytest.org/en/stable/goodpractices.html#python-test-discovery>`_
+  of test modules and functions
+
+- `Modular fixtures <https://docs.pytest.org/en/stable/fixture.html>`_ for
+  managing small or parametrized long-lived test resources
+
+- Can run `unittest <https://docs.pytest.org/en/stable/unittest.html>`_ (or trial),
+  `nose <https://docs.pytest.org/en/stable/nose.html>`_ test suites out of the box
+
+- Python 3.6+ and PyPy3
+
+- Rich plugin architecture, with over 850+ `external plugins <http://plugincompat.herokuapp.com>`_ and thriving community
+
+
+Documentation
+-------------
+
+For full documentation, including installation, tutorials and PDF documents, please see https://docs.pytest.org/en/stable/.
+
+
+Bugs/Requests
+-------------
+
+Please use the `GitHub issue tracker <https://github.com/pytest-dev/pytest/issues>`_ to submit bugs or request features.
+
+
+Changelog
+---------
+
+Consult the `Changelog <https://docs.pytest.org/en/stable/changelog.html>`__ page for fixes and enhancements of each version.
+
+
+Support pytest
+--------------
+
+`Open Collective`_ is an online funding platform for open and transparent communities.
+It provides tools to raise money and share your finances in full transparency.
+
+It is the platform of choice for individuals and companies that want to make one-time or
+monthly donations directly to the project.
+
+See more details in the `pytest collective`_.
+
+.. _Open Collective: https://opencollective.com
+.. _pytest collective: https://opencollective.com/pytest
+
+
+pytest for enterprise
+---------------------
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of pytest and thousands of other packages are working with Tidelift to deliver commercial support and
+maintenance for the open source dependencies you use to build your applications.
+Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use.
+
+`Learn more. <https://tidelift.com/subscription/pkg/pypi-pytest?utm_source=pypi-pytest&utm_medium=referral&utm_campaign=enterprise&utm_term=repo>`_
+
+Security
+^^^^^^^^
+
+pytest has never been associated with a security vulnerability, but in any case, to report a
+security vulnerability please use the `Tidelift security contact <https://tidelift.com/security>`_.
+Tidelift will coordinate the fix and disclosure.
+
+
+License
+-------
+
+Copyright Holger Krekel and others, 2004-2021.
+
+Distributed under the terms of the `MIT`_ license, pytest is free and open source software.
+
+.. _`MIT`: https://github.com/pytest-dev/pytest/blob/main/LICENSE
+
+
diff --git a/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/RECORD b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/RECORD
new file mode 100644
index 0000000..e67bb25
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/RECORD
@@ -0,0 +1,75 @@
+../../../bin/py.test,sha256=Hb7MWrVPNkadoN-g6e-qf91kH8ESeC05Boyh4SQDKus,262
+../../../bin/pytest,sha256=Hb7MWrVPNkadoN-g6e-qf91kH8ESeC05Boyh4SQDKus,262
+_pytest/__init__.py,sha256=6Ff5v_9CZKpy1l87AT5cIHOfMA9kdTtzhl2G3QjYC9Q,239
+_pytest/_argcomplete.py,sha256=R15Lz9g_AXkoCKec5f_Qu8JKq2G3EIj0Y1HIercpbgM,3810
+_pytest/_version.py,sha256=X4T2mJrPFs5MLUkmaWbuqT2WfD10Wc1QeNmLlRTlUrY,142
+_pytest/cacheprovider.py,sha256=er-S7OFW8g6WgZFlUPOXOSqm3_pF0qzmFGjE8kb95Ws,20709
+_pytest/capture.py,sha256=ZUjqTBB1lVoOEmfw2l3_EA4CbC96d4iLUYirzkpZGMA,32173
+_pytest/compat.py,sha256=ONVpT75yFYUT_GQkUFb39nO2ROBUIBaVYyGhXWzKEmE,12114
+_pytest/debugging.py,sha256=FFhS5H7wcsvG7oywEDtRB6wOwvMZJ2UGZsuSC4hEZUY,13407
+_pytest/deprecated.py,sha256=R_YY3ERWCHJo7JLNqtUsWtuMCtqTGVCrSA_9cuxJOMU,2805
+_pytest/doctest.py,sha256=qOFLv23xkkRqArsoZaGd9PDZLQ9MtoyqH-84Bwy_ags,25271
+_pytest/faulthandler.py,sha256=-OqdQmS1NNiuaD23fvwE_-sj3lDhPLhPqXS4lUbNisA,4364
+_pytest/fixtures.py,sha256=JMXgi2JGZCXzl379-DScF4XDoeumZkqYOB36TdnaU6U,65239
+_pytest/freeze_support.py,sha256=3p0xrQLfSWNo0QSOVwbUZt_mWRBujgaJ-sjkq1TJhN8,1391
+_pytest/helpconfig.py,sha256=Vj0N4ZjBVYeY-iOWDoztj9npUv94uKocp6swahGXGnA,8343
+_pytest/hookspec.py,sha256=83JizyN9XlAp4_ViY-_TAWiACHZsI6MZpQHjwPSwy0A,31471
+_pytest/junitxml.py,sha256=AFi34yIYOgA4o3C7GAwbtimhIkcwPf-5dIEBP0NuYWs,25628
+_pytest/logging.py,sha256=A2G7UQr999JajFeJfTb9aVs8yYCqsfE2AWLFCxEN-n8,29781
+_pytest/main.py,sha256=gw2XldmRbhnGQjQrdn4MjO3xODPo7zWpzmQDhmFtjhE,31788
+_pytest/monkeypatch.py,sha256=VcxrfvvDSAI28GMMwQrZGC_MS588D6M8QbcONc6Yn8U,12979
+_pytest/nodes.py,sha256=QZrd_G7fau9KkR3UqsnR-jOrDveVCRbD2YXfdEUpcpU,19880
+_pytest/nose.py,sha256=m0YQWYAlp92lZVbWrcyvNTfoEY9tSKWjAa9ZoMTaMhk,1359
+_pytest/outcomes.py,sha256=zI-4vi_REA6hME1Xqsdd5Nw5OFXVTNP-eh7ZqJwUYwQ,7420
+_pytest/pastebin.py,sha256=TLtoXHNb6t4rrOzN0SHiib4xosq3nAnvJcqpcQobyqk,3969
+_pytest/pathlib.py,sha256=Ym1q5lNKVjxZHllyWnclVvlbNYHCRm58a-L2gBpMFKQ,21411
+_pytest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+_pytest/pytester.py,sha256=jL9KTEGu-VEO9Z6TA0HJW7rFGJF_nFjVL5JWgNcSdLw,67472
+_pytest/pytester_assertions.py,sha256=FXsMapezaPXyQFi786CSWoV7aZDlpYxffh8Zy18LhtM,1959
+_pytest/python.py,sha256=7zNJ4FIFERsBy3HnPs6H-pPHzmK14OYwkiE7CSYD7T4,64125
+_pytest/python_api.py,sha256=ZuLuYv87_qqESq4cDnqS9cBtPIqhc26FTLjPSSwzcSQ,30442
+_pytest/recwarn.py,sha256=-dHcEWyx_vPyO3C1EbAjYLYGMM8L1a26gk_E5R_69M4,10288
+_pytest/reports.py,sha256=mNMz8MBuKQxlMVTultHHZ0wyMwNRyBvu306xP8yFqnw,19004
+_pytest/runner.py,sha256=L8BU_SIVJ3ORf1woUK4-y0hbTeVtrY06Ks5oUrFYPzE,15837
+_pytest/setuponly.py,sha256=MqjzkEaYTOf41hAeyhLzXl5foeTViwjUsLG0hMmYCwE,3097
+_pytest/setupplan.py,sha256=gVOO35Ge9Mp-FZX8M4Czyva2CMogFh3f4iswcl8xHws,1215
+_pytest/skipping.py,sha256=YV83_q9MvhjhqLOao62TEC-i86nfHkNH7LDt_dkxd9U,11232
+_pytest/stepwise.py,sha256=vaAeGHhv9ZtTc0TJOLlGK7o81CwibhEdlkAT7A5GEZs,4242
+_pytest/store.py,sha256=76_VJsEp7qp3xvn_orDIRCcyKfzTUOb3eLuS2Ol_BhM,3633
+_pytest/terminal.py,sha256=2SU8qrGTzBLogVqDHnMvD9ixCH8gTizoSciZq6wrNnY,50810
+_pytest/threadexception.py,sha256=2XaQL_T_mKKoLl4_Ve5E1N5_V3INLr5XNF1bzp2nzbs,3029
+_pytest/timing.py,sha256=vufB2Wrk_Bf4uol6U16WfpikCBttEmmtGKBNBshPN_k,375
+_pytest/tmpdir.py,sha256=Xn1UeYTNg_14xjYdseiJ6DJhMga2LKbWZD03gawSRS8,9441
+_pytest/unittest.py,sha256=Xhq4xHeDzByMWosyQC0TXLsyeUek8rEt4vHGbzB8viU,13935
+_pytest/unraisableexception.py,sha256=FJmftKtjMHmUnlYyg1o9B_oQjvA_U0p1ABSNlKx1K2I,3191
+_pytest/warning_types.py,sha256=m61Ce6axljzOqSOcRXorSOj0TUs72MFM5dwJM-C7fTE,3148
+_pytest/warnings.py,sha256=75r-dRRekGpvpJY7AzTklA740E54GSeUWpduurSO2UM,4488
+_pytest/_code/__init__.py,sha256=S_sBUyBt-DdDWGJKJviYTWFHhhDFBM7pIMaENaocwaM,483
+_pytest/_code/code.py,sha256=OCB-msupBV3sH1w41usNjbrCrbK-sYD_X_KQZ8syeBs,43460
+_pytest/_code/source.py,sha256=c7AyhwoKuAGMHaNcsoIsj90eMHxgqlfsCkpN3jXo1JU,7054
+_pytest/_io/__init__.py,sha256=NWs125Ln6IqP5BZNw-V2iN_yYPwGM7vfrAP5ta6MhPA,154
+_pytest/_io/saferepr.py,sha256=jo9ci-9-ms0H12jvC2ZZ6e9pxtYO6hH6qiw3FaFD2T4,3767
+_pytest/_io/terminalwriter.py,sha256=VnW1gYmOuS9kNaPkZlQ4DijXW_XCchYZQevL0eGd-ak,7182
+_pytest/_io/wcwidth.py,sha256=YhE3To-vBI7udLtV4B-g-04S3l8VoRD5ki935QipmJA,1253
+_pytest/assertion/__init__.py,sha256=uwOWsYJfv6sHMqIKotqCW-pOSybygs9_EUT6yeDIDlU,6424
+_pytest/assertion/rewrite.py,sha256=DzWWqUjzPS-f9RYMs0ArQ_4VABHxhZvaGnzeJMEiRMk,43620
+_pytest/assertion/truncate.py,sha256=fQdGvAIiWbBJb5kQzV8_4o-rCGmmdqCr0dmSH6Q9OZo,3440
+_pytest/assertion/util.py,sha256=h2-wtXFckP6g3r_p7IkpbdoObGDLWWTbXO87oSZmDM8,16249
+_pytest/config/__init__.py,sha256=RyvXJqnNYRfNazqAukpDveWiHAWpbXhASxZMKg9CMU0,56940
+_pytest/config/argparsing.py,sha256=-xtOU0k_vxFbECyyer3P8KZrPWIsU6QAbOFkMCLHx94,20577
+_pytest/config/exceptions.py,sha256=21I5MARt26OLRmgvaAPu0BblFgYZXp2cxNZBpRRciAE,260
+_pytest/config/findpaths.py,sha256=az6abBKjHTyvZJTmlwwE75lZh9h_JQ45t8Hh4a-bqZA,7423
+_pytest/mark/__init__.py,sha256=Rd3W2zwQiYwPa7IGImFGpMyBVKK2zDyHO0IkySvLN2s,8955
+_pytest/mark/expression.py,sha256=adA7gk16eX9X3Zk4lLIuUztn3B3VMINnLyyIICE_Otc,6372
+_pytest/mark/structures.py,sha256=7jKtWyoHpDxJONsdh-UJ8QF5_I4iYJqiiThmB3-EL5Q,18763
+pytest/__init__.py,sha256=mY_gGTrbViMBx-RQR1qzzbBaMW72nCnJh1F_qiWev9s,3713
+pytest/__main__.py,sha256=PJoBBgRxbsenpjfDenJmkO0-UGzTad7Htcxgstu4g30,116
+pytest/collect.py,sha256=wgXRvzuOUE61mNvCDouvW6QNZGQqJoEpBtNVRTq-qV0,918
+pytest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest-6.2.5.dist-info/LICENSE,sha256=eJi5sWTU-T_ZpWL9D1kpNVGLSMR0UwOWQRDrf3_mT68,1096
+pytest-6.2.5.dist-info/METADATA,sha256=99fdkTuVpdGnKs10UD1Xw_hfjJo3EMdsFHCvjRRQ5wo,7538
+pytest-6.2.5.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+pytest-6.2.5.dist-info/entry_points.txt,sha256=0yUOQ7R7BVugNpBSSbTGBNaEtMvencuMKiBdK4s5c58,78
+pytest-6.2.5.dist-info/top_level.txt,sha256=ENE0IeZV1I1R61DOt8gs5KmSXwitaq2zstF0az5f9PA,15
+pytest-6.2.5.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+pytest-6.2.5.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/WHEEL
new file mode 100644
index 0000000..5bad85f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/entry_points.txt
new file mode 100644
index 0000000..0267c75
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/entry_points.txt
@@ -0,0 +1,4 @@
+[console_scripts]
+py.test = pytest:console_main
+pytest = pytest:console_main
+
diff --git a/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/top_level.txt
new file mode 100644
index 0000000..e94857a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest-6.2.5.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+_pytest
+pytest
diff --git a/myenv/lib/python3.9/site-packages/pytest/__init__.py b/myenv/lib/python3.9/site-packages/pytest/__init__.py
new file mode 100644
index 0000000..70177f9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest/__init__.py
@@ -0,0 +1,121 @@
+# PYTHON_ARGCOMPLETE_OK
+"""pytest: unit and functional testing with Python."""
+from . import collect
+from _pytest import __version__
+from _pytest.assertion import register_assert_rewrite
+from _pytest.cacheprovider import Cache
+from _pytest.capture import CaptureFixture
+from _pytest.config import cmdline
+from _pytest.config import console_main
+from _pytest.config import ExitCode
+from _pytest.config import hookimpl
+from _pytest.config import hookspec
+from _pytest.config import main
+from _pytest.config import UsageError
+from _pytest.debugging import pytestPDB as __pytestPDB
+from _pytest.fixtures import _fillfuncargs
+from _pytest.fixtures import fixture
+from _pytest.fixtures import FixtureLookupError
+from _pytest.fixtures import FixtureRequest
+from _pytest.fixtures import yield_fixture
+from _pytest.freeze_support import freeze_includes
+from _pytest.logging import LogCaptureFixture
+from _pytest.main import Session
+from _pytest.mark import MARK_GEN as mark
+from _pytest.mark import param
+from _pytest.monkeypatch import MonkeyPatch
+from _pytest.nodes import Collector
+from _pytest.nodes import File
+from _pytest.nodes import Item
+from _pytest.outcomes import exit
+from _pytest.outcomes import fail
+from _pytest.outcomes import importorskip
+from _pytest.outcomes import skip
+from _pytest.outcomes import xfail
+from _pytest.pytester import Pytester
+from _pytest.pytester import Testdir
+from _pytest.python import Class
+from _pytest.python import Function
+from _pytest.python import Instance
+from _pytest.python import Module
+from _pytest.python import Package
+from _pytest.python_api import approx
+from _pytest.python_api import raises
+from _pytest.recwarn import deprecated_call
+from _pytest.recwarn import WarningsRecorder
+from _pytest.recwarn import warns
+from _pytest.tmpdir import TempdirFactory
+from _pytest.tmpdir import TempPathFactory
+from _pytest.warning_types import PytestAssertRewriteWarning
+from _pytest.warning_types import PytestCacheWarning
+from _pytest.warning_types import PytestCollectionWarning
+from _pytest.warning_types import PytestConfigWarning
+from _pytest.warning_types import PytestDeprecationWarning
+from _pytest.warning_types import PytestExperimentalApiWarning
+from _pytest.warning_types import PytestUnhandledCoroutineWarning
+from _pytest.warning_types import PytestUnhandledThreadExceptionWarning
+from _pytest.warning_types import PytestUnknownMarkWarning
+from _pytest.warning_types import PytestUnraisableExceptionWarning
+from _pytest.warning_types import PytestWarning
+
+set_trace = __pytestPDB.set_trace
+
+__all__ = [
+    "__version__",
+    "_fillfuncargs",
+    "approx",
+    "Cache",
+    "CaptureFixture",
+    "Class",
+    "cmdline",
+    "collect",
+    "Collector",
+    "console_main",
+    "deprecated_call",
+    "exit",
+    "ExitCode",
+    "fail",
+    "File",
+    "fixture",
+    "FixtureLookupError",
+    "FixtureRequest",
+    "freeze_includes",
+    "Function",
+    "hookimpl",
+    "hookspec",
+    "importorskip",
+    "Instance",
+    "Item",
+    "LogCaptureFixture",
+    "main",
+    "mark",
+    "Module",
+    "MonkeyPatch",
+    "Package",
+    "param",
+    "PytestAssertRewriteWarning",
+    "PytestCacheWarning",
+    "PytestCollectionWarning",
+    "PytestConfigWarning",
+    "PytestDeprecationWarning",
+    "PytestExperimentalApiWarning",
+    "Pytester",
+    "PytestUnhandledCoroutineWarning",
+    "PytestUnhandledThreadExceptionWarning",
+    "PytestUnknownMarkWarning",
+    "PytestUnraisableExceptionWarning",
+    "PytestWarning",
+    "raises",
+    "register_assert_rewrite",
+    "Session",
+    "set_trace",
+    "skip",
+    "TempPathFactory",
+    "Testdir",
+    "TempdirFactory",
+    "UsageError",
+    "WarningsRecorder",
+    "warns",
+    "xfail",
+    "yield_fixture",
+]
diff --git a/myenv/lib/python3.9/site-packages/pytest/__main__.py b/myenv/lib/python3.9/site-packages/pytest/__main__.py
new file mode 100644
index 0000000..b170152
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest/__main__.py
@@ -0,0 +1,5 @@
+"""The pytest entry point."""
+import pytest
+
+if __name__ == "__main__":
+    raise SystemExit(pytest.console_main())
diff --git a/myenv/lib/python3.9/site-packages/pytest/collect.py b/myenv/lib/python3.9/site-packages/pytest/collect.py
new file mode 100644
index 0000000..2edf447
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest/collect.py
@@ -0,0 +1,39 @@
+import sys
+import warnings
+from types import ModuleType
+from typing import Any
+from typing import List
+
+import pytest
+from _pytest.deprecated import PYTEST_COLLECT_MODULE
+
+COLLECT_FAKEMODULE_ATTRIBUTES = [
+    "Collector",
+    "Module",
+    "Function",
+    "Instance",
+    "Session",
+    "Item",
+    "Class",
+    "File",
+    "_fillfuncargs",
+]
+
+
+class FakeCollectModule(ModuleType):
+    def __init__(self) -> None:
+        super().__init__("pytest.collect")
+        self.__all__ = list(COLLECT_FAKEMODULE_ATTRIBUTES)
+        self.__pytest = pytest
+
+    def __dir__(self) -> List[str]:
+        return dir(super()) + self.__all__
+
+    def __getattr__(self, name: str) -> Any:
+        if name not in self.__all__:
+            raise AttributeError(name)
+        warnings.warn(PYTEST_COLLECT_MODULE.format(name=name), stacklevel=2)
+        return getattr(pytest, name)
+
+
+sys.modules["pytest.collect"] = FakeCollectModule()
diff --git a/myenv/lib/python3.9/site-packages/pytest/py.typed b/myenv/lib/python3.9/site-packages/pytest/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/LICENSE
new file mode 100644
index 0000000..e06d208
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/LICENSE
@@ -0,0 +1,202 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
diff --git a/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/METADATA
new file mode 100644
index 0000000..20779ff
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/METADATA
@@ -0,0 +1,317 @@
+Metadata-Version: 2.1
+Name: pytest-asyncio
+Version: 0.16.0
+Summary: Pytest support for asyncio.
+Home-page: https://github.com/pytest-dev/pytest-asyncio
+Author: Tin Tvrtković
+Author-email: tinchester@gmail.com
+License: Apache 2.0
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Testing
+Classifier: Framework :: Pytest
+Requires-Python: >= 3.6
+License-File: LICENSE
+Requires-Dist: pytest (>=5.4.0)
+Provides-Extra: testing
+Requires-Dist: coverage ; extra == 'testing'
+Requires-Dist: hypothesis (>=5.7.1) ; extra == 'testing'
+
+pytest-asyncio: pytest support for asyncio
+==========================================
+
+.. image:: https://img.shields.io/pypi/v/pytest-asyncio.svg
+    :target: https://pypi.python.org/pypi/pytest-asyncio
+.. image:: https://travis-ci.org/pytest-dev/pytest-asyncio.svg?branch=master
+    :target: https://travis-ci.org/pytest-dev/pytest-asyncio
+.. image:: https://codecov.io/gh/pytest-dev/pytest-asyncio/branch/master/graph/badge.svg
+        :target: https://codecov.io/gh/pytest-dev/pytest-asyncio
+.. image:: https://img.shields.io/pypi/pyversions/pytest-asyncio.svg
+    :target: https://github.com/pytest-dev/pytest-asyncio
+    :alt: Supported Python versions
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/ambv/black
+
+pytest-asyncio is an Apache2 licensed library, written in Python, for testing
+asyncio code with pytest.
+
+asyncio code is usually written in the form of coroutines, which makes it
+slightly more difficult to test using normal testing tools. pytest-asyncio
+provides useful fixtures and markers to make testing easier.
+
+.. code-block:: python
+
+    @pytest.mark.asyncio
+    async def test_some_asyncio_code():
+        res = await library.do_something()
+        assert b'expected result' == res
+
+pytest-asyncio has been strongly influenced by pytest-tornado_.
+
+.. _pytest-tornado: https://github.com/eugeniy/pytest-tornado
+
+Features
+--------
+
+- fixtures for creating and injecting versions of the asyncio event loop
+- fixtures for injecting unused tcp ports
+- pytest markers for treating tests as asyncio coroutines
+- easy testing with non-default event loops
+- support for `async def` fixtures and async generator fixtures
+
+Installation
+------------
+
+To install pytest-asyncio, simply:
+
+.. code-block:: bash
+
+    $ pip install pytest-asyncio
+
+This is enough for pytest to pick up pytest-asyncio.
+
+Fixtures
+--------
+
+``event_loop``
+~~~~~~~~~~~~~~
+Creates and injects a new instance of the default asyncio event loop. By
+default, the loop will be closed at the end of the test (i.e. the default
+fixture scope is ``function``).
+
+Note that just using the ``event_loop`` fixture won't make your test function
+a coroutine. You'll need to interact with the event loop directly, using methods
+like ``event_loop.run_until_complete``. See the ``pytest.mark.asyncio`` marker
+for treating test functions like coroutines.
+
+Simply using this fixture will not set the generated event loop as the
+default asyncio event loop, or change the asyncio event loop policy in any way.
+Use ``pytest.mark.asyncio`` for this purpose.
+
+.. code-block:: python
+
+    def test_http_client(event_loop):
+        url = 'http://httpbin.org/get'
+        resp = event_loop.run_until_complete(http_client(url))
+        assert b'HTTP/1.1 200 OK' in resp
+
+This fixture can be easily overridden in any of the standard pytest locations
+(e.g. directly in the test file, or in ``conftest.py``) to use a non-default
+event loop. This will take effect even if you're using the
+``pytest.mark.asyncio`` marker and not the ``event_loop`` fixture directly.
+
+.. code-block:: python
+
+    @pytest.fixture
+    def event_loop():
+        loop = MyCustomLoop()
+        yield loop
+        loop.close()
+
+If the ``pytest.mark.asyncio`` marker is applied, a pytest hook will
+ensure the produced loop is set as the default global loop.
+Fixtures depending on the ``event_loop`` fixture can expect the policy to be properly modified when they run.
+
+``unused_tcp_port``
+~~~~~~~~~~~~~~~~~~~
+Finds and yields a single unused TCP port on the localhost interface. Useful for
+binding temporary test servers.
+
+``unused_tcp_port_factory``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+A callable which returns a different unused TCP port each invocation. Useful
+when several unused TCP ports are required in a test.
+
+.. code-block:: python
+
+    def a_test(unused_tcp_port_factory):
+        port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
+        ...
+
+Async fixtures
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be coroutines or asynchronous generators.
+
+.. code-block:: python3
+
+    @pytest.fixture
+    async def async_gen_fixture():
+        await asyncio.sleep(0.1)
+        yield 'a value'
+
+    @pytest.fixture(scope='module')
+    async def async_fixture():
+        return await asyncio.sleep(0.1)
+
+All scopes are supported, but if you use a non-function scope you will need
+to redefine the ``event_loop`` fixture to have the same or broader scope.
+Async fixtures need the event loop, and so must have the same or narrower scope
+than the ``event_loop`` fixture.
+
+
+Markers
+-------
+
+``pytest.mark.asyncio``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Mark your test coroutine with this marker and pytest will execute it as an
+asyncio task using the event loop provided by the ``event_loop`` fixture. See
+the introductory section for an example.
+
+The event loop used can be overriden by overriding the ``event_loop`` fixture
+(see above).
+
+In order to make your test code a little more concise, the pytest |pytestmark|_
+feature can be used to mark entire modules or classes with this marker.
+Only test coroutines will be affected (by default, coroutines prefixed by
+``test_``), so, for example, fixtures are safe to define.
+
+.. code-block:: python
+
+    import asyncio
+    import pytest
+
+    # All test coroutines will be treated as marked.
+    pytestmark = pytest.mark.asyncio
+
+    async def test_example(event_loop):
+        """No marker!"""
+        await asyncio.sleep(0, loop=event_loop)
+
+.. |pytestmark| replace:: ``pytestmark``
+.. _pytestmark: http://doc.pytest.org/en/latest/example/markers.html#marking-whole-classes-or-modules
+
+Changelog
+---------
+0.16.0 (2021-10-16)
+~~~~~~~~~~~~~~~~~~~
+- Add support for Python 3.10
+
+0.15.1 (2021-04-22)
+~~~~~~~~~~~~~~~~~~~
+- Hotfix for errors while closing event loops while replacing them.
+  `#209 <https://github.com/pytest-dev/pytest-asyncio/issues/209>`_
+  `#210 <https://github.com/pytest-dev/pytest-asyncio/issues/210>`_
+
+0.15.0 (2021-04-19)
+~~~~~~~~~~~~~~~~~~~
+- Add support for Python 3.9
+- Abandon support for Python 3.5. If you still require support for Python 3.5, please use pytest-asyncio v0.14 or earlier.
+- Set ``unused_tcp_port_factory`` fixture scope to 'session'.
+  `#163 <https://github.com/pytest-dev/pytest-asyncio/pull/163>`_
+- Properly close event loops when replacing them.
+  `#208 <https://github.com/pytest-dev/pytest-asyncio/issues/208>`_
+
+0.14.0 (2020-06-24)
+~~~~~~~~~~~~~~~~~~~
+- Fix `#162 <https://github.com/pytest-dev/pytest-asyncio/issues/162>`_, and ``event_loop`` fixture behavior now is coherent on all scopes.
+  `#164 <https://github.com/pytest-dev/pytest-asyncio/pull/164>`_
+
+0.12.0 (2020-05-04)
+~~~~~~~~~~~~~~~~~~~
+- Run the event loop fixture as soon as possible. This helps with fixtures that have an implicit dependency on the event loop.
+  `#156 <https://github.com/pytest-dev/pytest-asyncio/pull/156>`_
+
+0.11.0 (2020-04-20)
+~~~~~~~~~~~~~~~~~~~
+- Test on 3.8, drop 3.3 and 3.4. Stick to 0.10 for these versions.
+  `#152 <https://github.com/pytest-dev/pytest-asyncio/pull/152>`_
+- Use the new Pytest 5.4.0 Function API. We therefore depend on pytest >= 5.4.0.
+  `#142 <https://github.com/pytest-dev/pytest-asyncio/pull/142>`_
+- Better ``pytest.skip`` support.
+  `#126 <https://github.com/pytest-dev/pytest-asyncio/pull/126>`_
+
+0.10.0 (2019-01-08)
+~~~~~~~~~~~~~~~~~~~~
+- ``pytest-asyncio`` integrates with `Hypothesis <https://hypothesis.readthedocs.io>`_
+  to support ``@given`` on async test functions using ``asyncio``.
+  `#102 <https://github.com/pytest-dev/pytest-asyncio/pull/102>`_
+- Pytest 4.1 support.
+  `#105 <https://github.com/pytest-dev/pytest-asyncio/pull/105>`_
+
+0.9.0 (2018-07-28)
+~~~~~~~~~~~~~~~~~~
+- Python 3.7 support.
+- Remove ``event_loop_process_pool`` fixture and
+  ``pytest.mark.asyncio_process_pool`` marker (see
+  https://bugs.python.org/issue34075 for deprecation and removal details)
+
+0.8.0 (2017-09-23)
+~~~~~~~~~~~~~~~~~~
+- Improve integration with other packages (like aiohttp) with more careful event loop handling.
+  `#64 <https://github.com/pytest-dev/pytest-asyncio/pull/64>`_
+
+0.7.0 (2017-09-08)
+~~~~~~~~~~~~~~~~~~
+- Python versions pre-3.6 can use the async_generator library for async fixtures.
+  `#62 <https://github.com/pytest-dev/pytest-asyncio/pull/62>`
+
+
+0.6.0 (2017-05-28)
+~~~~~~~~~~~~~~~~~~
+- Support for Python versions pre-3.5 has been dropped.
+- ``pytestmark`` now works on both module and class level.
+- The ``forbid_global_loop`` parameter has been removed.
+- Support for async and async gen fixtures has been added.
+  `#45 <https://github.com/pytest-dev/pytest-asyncio/pull/45>`_
+- The deprecation warning regarding ``asyncio.async()`` has been fixed.
+  `#51 <https://github.com/pytest-dev/pytest-asyncio/pull/51>`_
+
+0.5.0 (2016-09-07)
+~~~~~~~~~~~~~~~~~~
+- Introduced a changelog.
+  `#31 <https://github.com/pytest-dev/pytest-asyncio/issues/31>`_
+- The ``event_loop`` fixture is again responsible for closing itself.
+  This makes the fixture slightly harder to correctly override, but enables
+  other fixtures to depend on it correctly.
+  `#30 <https://github.com/pytest-dev/pytest-asyncio/issues/30>`_
+- Deal with the event loop policy by wrapping a special pytest hook,
+  ``pytest_fixture_setup``. This allows setting the policy before fixtures
+  dependent on the ``event_loop`` fixture run, thus allowing them to take
+  advantage of the ``forbid_global_loop`` parameter. As a consequence of this,
+  we now depend on pytest 3.0.
+  `#29 <https://github.com/pytest-dev/pytest-asyncio/issues/29>`_
+
+
+0.4.1 (2016-06-01)
+~~~~~~~~~~~~~~~~~~
+- Fix a bug preventing the propagation of exceptions from the plugin.
+  `#25 <https://github.com/pytest-dev/pytest-asyncio/issues/25>`_
+
+0.4.0 (2016-05-30)
+~~~~~~~~~~~~~~~~~~
+- Make ``event_loop`` fixtures simpler to override by closing them in the
+  plugin, instead of directly in the fixture.
+  `#21 <https://github.com/pytest-dev/pytest-asyncio/pull/21>`_
+- Introduce the ``forbid_global_loop`` parameter.
+  `#21 <https://github.com/pytest-dev/pytest-asyncio/pull/21>`_
+
+0.3.0 (2015-12-19)
+~~~~~~~~~~~~~~~~~~
+- Support for Python 3.5 ``async``/``await`` syntax.
+  `#17 <https://github.com/pytest-dev/pytest-asyncio/pull/17>`_
+
+0.2.0 (2015-08-01)
+~~~~~~~~~~~~~~~~~~
+- ``unused_tcp_port_factory`` fixture.
+  `#10 <https://github.com/pytest-dev/pytest-asyncio/issues/10>`_
+
+
+0.1.1 (2015-04-23)
+~~~~~~~~~~~~~~~~~~
+Initial release.
+
+
+Contributing
+------------
+Contributions are very welcome. Tests can be run with ``tox``, please ensure
+the coverage at least stays the same before you submit a pull request.
+
+
diff --git a/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/RECORD
new file mode 100644
index 0000000..79f1f75
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/RECORD
@@ -0,0 +1,9 @@
+pytest_asyncio/__init__.py,sha256=SwPEyO0NgsWIIay0qfbBJB565e8evhW3afShF2MXDDc,80
+pytest_asyncio/plugin.py,sha256=Yaz1EMgI2mQ7LijK9jODFEz2aq3BvMNEXqEPRc6O15U,8065
+pytest_asyncio-0.16.0.dist-info/LICENSE,sha256=y16Ofl9KOYjhBjwULGDcLfdWBfTEZRXnduOspt-XbhQ,11325
+pytest_asyncio-0.16.0.dist-info/METADATA,sha256=WVG3ZNxcEcLkB1ni6z4HEfBtvi9csAaRwu1nmlj01MY,11592
+pytest_asyncio-0.16.0.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+pytest_asyncio-0.16.0.dist-info/entry_points.txt,sha256=jqCteMhekGwOev2kQPTt_yxqYcX6-pLs-qeom8Zcw40,44
+pytest_asyncio-0.16.0.dist-info/top_level.txt,sha256=J4BTi9IZbfghCsiVybot1y0AaLUgxp3NMaNpH9fghNI,15
+pytest_asyncio-0.16.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+pytest_asyncio-0.16.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/WHEEL
new file mode 100644
index 0000000..5bad85f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/entry_points.txt
new file mode 100644
index 0000000..69c53be
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/entry_points.txt
@@ -0,0 +1,3 @@
+[pytest11]
+asyncio = pytest_asyncio.plugin
+
diff --git a/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/top_level.txt
new file mode 100644
index 0000000..08d05d1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_asyncio-0.16.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+pytest_asyncio
diff --git a/myenv/lib/python3.9/site-packages/pytest_asyncio/__init__.py b/myenv/lib/python3.9/site-packages/pytest_asyncio/__init__.py
new file mode 100644
index 0000000..b16159e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_asyncio/__init__.py
@@ -0,0 +1,2 @@
+"""The main point for importing pytest-asyncio items."""
+__version__ = "0.16.0"
diff --git a/myenv/lib/python3.9/site-packages/pytest_asyncio/plugin.py b/myenv/lib/python3.9/site-packages/pytest_asyncio/plugin.py
new file mode 100644
index 0000000..7665ff4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_asyncio/plugin.py
@@ -0,0 +1,260 @@
+"""pytest-asyncio implementation."""
+import asyncio
+import contextlib
+import functools
+import inspect
+import socket
+
+import pytest
+
+try:
+    from _pytest.python import transfer_markers
+except ImportError:  # Pytest 4.1.0 removes the transfer_marker api (#104)
+
+    def transfer_markers(*args, **kwargs):  # noqa
+        """Noop when over pytest 4.1.0"""
+        pass
+
+
+from inspect import isasyncgenfunction
+
+
+def _is_coroutine(obj):
+    """Check to see if an object is really an asyncio coroutine."""
+    return asyncio.iscoroutinefunction(obj) or inspect.isgeneratorfunction(obj)
+
+
+def pytest_configure(config):
+    """Inject documentation."""
+    config.addinivalue_line(
+        "markers",
+        "asyncio: "
+        "mark the test as a coroutine, it will be "
+        "run using an asyncio event loop",
+    )
+
+
+@pytest.mark.tryfirst
+def pytest_pycollect_makeitem(collector, name, obj):
+    """A pytest hook to collect asyncio coroutines."""
+    if collector.funcnamefilter(name) and _is_coroutine(obj):
+        item = pytest.Function.from_parent(collector, name=name)
+
+        # Due to how pytest test collection works, module-level pytestmarks
+        # are applied after the collection step. Since this is the collection
+        # step, we look ourselves.
+        transfer_markers(obj, item.cls, item.module)
+        item = pytest.Function.from_parent(collector, name=name)  # To reload keywords.
+
+        if "asyncio" in item.keywords:
+            return list(collector._genfunctions(name, obj))
+
+
+class FixtureStripper:
+    """Include additional Fixture, and then strip them"""
+
+    REQUEST = "request"
+    EVENT_LOOP = "event_loop"
+
+    def __init__(self, fixturedef):
+        self.fixturedef = fixturedef
+        self.to_strip = set()
+
+    def add(self, name):
+        """Add fixture name to fixturedef
+        and record in to_strip list (If not previously included)"""
+        if name in self.fixturedef.argnames:
+            return
+        self.fixturedef.argnames += (name,)
+        self.to_strip.add(name)
+
+    def get_and_strip_from(self, name, data_dict):
+        """Strip name from data, and return value"""
+        result = data_dict[name]
+        if name in self.to_strip:
+            del data_dict[name]
+        return result
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_fixture_post_finalizer(fixturedef, request):
+    """Called after fixture teardown"""
+    if fixturedef.argname == "event_loop":
+        # Set empty loop policy, so that subsequent get_event_loop() provides a new loop
+        asyncio.set_event_loop_policy(None)
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_fixture_setup(fixturedef, request):
+    """Adjust the event loop policy when an event loop is produced."""
+    if fixturedef.argname == "event_loop":
+        outcome = yield
+        loop = outcome.get_result()
+        policy = asyncio.get_event_loop_policy()
+        try:
+            old_loop = policy.get_event_loop()
+            if old_loop is not loop:
+                old_loop.close()
+        except RuntimeError:
+            # Swallow this, since it's probably bad event loop hygiene.
+            pass
+        policy.set_event_loop(loop)
+        return
+
+    if isasyncgenfunction(fixturedef.func):
+        # This is an async generator function. Wrap it accordingly.
+        generator = fixturedef.func
+
+        fixture_stripper = FixtureStripper(fixturedef)
+        fixture_stripper.add(FixtureStripper.EVENT_LOOP)
+        fixture_stripper.add(FixtureStripper.REQUEST)
+
+        def wrapper(*args, **kwargs):
+            loop = fixture_stripper.get_and_strip_from(
+                FixtureStripper.EVENT_LOOP, kwargs
+            )
+            request = fixture_stripper.get_and_strip_from(
+                FixtureStripper.REQUEST, kwargs
+            )
+
+            gen_obj = generator(*args, **kwargs)
+
+            async def setup():
+                res = await gen_obj.__anext__()
+                return res
+
+            def finalizer():
+                """Yield again, to finalize."""
+
+                async def async_finalizer():
+                    try:
+                        await gen_obj.__anext__()
+                    except StopAsyncIteration:
+                        pass
+                    else:
+                        msg = "Async generator fixture didn't stop."
+                        msg += "Yield only once."
+                        raise ValueError(msg)
+
+                loop.run_until_complete(async_finalizer())
+
+            request.addfinalizer(finalizer)
+            return loop.run_until_complete(setup())
+
+        fixturedef.func = wrapper
+    elif inspect.iscoroutinefunction(fixturedef.func):
+        coro = fixturedef.func
+
+        fixture_stripper = FixtureStripper(fixturedef)
+        fixture_stripper.add(FixtureStripper.EVENT_LOOP)
+
+        def wrapper(*args, **kwargs):
+            loop = fixture_stripper.get_and_strip_from(
+                FixtureStripper.EVENT_LOOP, kwargs
+            )
+
+            async def setup():
+                res = await coro(*args, **kwargs)
+                return res
+
+            return loop.run_until_complete(setup())
+
+        fixturedef.func = wrapper
+    yield
+
+
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_pyfunc_call(pyfuncitem):
+    """
+    Run asyncio marked test functions in an event loop instead of a normal
+    function call.
+    """
+    if "asyncio" in pyfuncitem.keywords:
+        if getattr(pyfuncitem.obj, "is_hypothesis_test", False):
+            pyfuncitem.obj.hypothesis.inner_test = wrap_in_sync(
+                pyfuncitem.obj.hypothesis.inner_test,
+                _loop=pyfuncitem.funcargs["event_loop"],
+            )
+        else:
+            pyfuncitem.obj = wrap_in_sync(
+                pyfuncitem.obj, _loop=pyfuncitem.funcargs["event_loop"]
+            )
+    yield
+
+
+def wrap_in_sync(func, _loop):
+    """Return a sync wrapper around an async function executing it in the
+    current event loop."""
+
+    @functools.wraps(func)
+    def inner(**kwargs):
+        coro = func(**kwargs)
+        if coro is not None:
+            task = asyncio.ensure_future(coro, loop=_loop)
+            try:
+                _loop.run_until_complete(task)
+            except BaseException:
+                # run_until_complete doesn't get the result from exceptions
+                # that are not subclasses of `Exception`. Consume all
+                # exceptions to prevent asyncio's warning from logging.
+                if task.done() and not task.cancelled():
+                    task.exception()
+                raise
+
+    return inner
+
+
+def pytest_runtest_setup(item):
+    if "asyncio" in item.keywords:
+        # inject an event loop fixture for all async tests
+        if "event_loop" in item.fixturenames:
+            item.fixturenames.remove("event_loop")
+        item.fixturenames.insert(0, "event_loop")
+    if (
+        item.get_closest_marker("asyncio") is not None
+        and not getattr(item.obj, "hypothesis", False)
+        and getattr(item.obj, "is_hypothesis_test", False)
+    ):
+        pytest.fail(
+            "test function `%r` is using Hypothesis, but pytest-asyncio "
+            "only works with Hypothesis 3.64.0 or later." % item
+        )
+
+
+@pytest.fixture
+def event_loop(request):
+    """Create an instance of the default event loop for each test case."""
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()
+
+
+def _unused_tcp_port():
+    """Find an unused localhost TCP port from 1024-65535 and return it."""
+    with contextlib.closing(socket.socket()) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return sock.getsockname()[1]
+
+
+@pytest.fixture
+def unused_tcp_port():
+    return _unused_tcp_port()
+
+
+@pytest.fixture(scope="session")
+def unused_tcp_port_factory():
+    """A factory function, producing different unused TCP ports."""
+    produced = set()
+
+    def factory():
+        """Return an unused port."""
+        port = _unused_tcp_port()
+
+        while port in produced:
+            port = _unused_tcp_port()
+
+        produced.add(port)
+
+        return port
+
+    return factory
diff --git a/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/LICENSE
new file mode 100644
index 0000000..7c2c0b7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Michon van Dooren
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/METADATA
new file mode 100644
index 0000000..b5f152d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/METADATA
@@ -0,0 +1,151 @@
+Metadata-Version: 2.1
+Name: pytest-depends
+Version: 1.0.1
+Summary: Tests that depend on other tests
+Home-page: https://gitlab.com/maienm/pytest-depends
+Author: Michon van Dooren
+Author-email: michon1992@gmail.com
+License: MIT
+Keywords: pytest
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+Requires-Dist: colorama
+Requires-Dist: future-fstrings
+Requires-Dist: networkx
+Requires-Dist: pytest (>=3)
+
+# pytest-depends
+
+This pytest plugin allows you to declare dependencies between pytest tests, where dependent tests will not run if the
+tests they depend on did not succeed.
+
+Of course, tests should be self contained whenever possible, but that doesn't mean this doesn't have good uses.
+
+This can be useful for when the failing of a test means that another test cannot possibly succeed either, especially
+with slower tests. This isn't a dependency in the sense of test A sets up stuff for test B, but more in the sense of if
+test A failed there's no reason to bother with test B either.
+
+## Installation
+
+Simply install using `pip` (or `easy_install`):
+
+```
+pip install pytest-depends
+```
+
+## Usage
+
+``` python
+BUILD_PATH = 'build'
+
+def test_build_exists():
+    assert os.path.exists(BUILD_PATH)
+
+@pytest.mark.depends(on=['test_build_exists'])
+def test_build_version():
+    result = subprocess.run([BUILD_PATH, '--version'], stdout=subprocess.PIPE)
+    assert result.returncode == 0
+    assert '1.2.3' in result.stdout
+```
+
+This is a simple example of the situation mentioned earlier. In this case, the first test checks whether the build file
+even exists. If this fails, the other test will not be ran, as there is no point in doing to.
+
+## Order
+
+This plugin will automatically re-order the tests so that tests are run after the tests they depend on. If another
+plugin also reorders tests (such as `pytest-randomly`), this may cause problems, as dependencies that haven't ran yet
+are considered failures.
+
+This plugin attempts to make sure it runs last to prevent this issue, but there are no guarantees this is successful. If
+you run into issues with this in combination with another plugin, feel free to open an issue.
+
+## Naming
+
+There are multiple ways to refer to each test. Let's start with an example, which we'll call `test_file.py`:
+
+``` python
+class TestClass(object):
+    @pytest.mark.depends(name='foo')
+    def test_in_class(self):
+        pass
+
+@pytest.mark.depends(name='foo')
+def test_outside_class():
+    pass
+
+def test_without_name(num):
+    pass
+```
+
+The `test_in_class` test will be available under the following names:
+
+- `test_file.py::TestClass::test_in_class`
+- `test_file.py::TestClass`
+- `test_file.py`
+- `foo`
+
+The `test_outside_class` test will be available under the following names:
+
+- `test_file.py::test_outside_class`
+- `test_file.py`
+- `foo`
+
+The `test_without_name` test will be available under the following names:
+
+- `test_file.py::test_without_name`
+- `test_file.py`
+
+Note how some names apply to multiple tests. Depending on `foo` in this case would mean depending on both
+`test_in_class` and `test_outside_class`, and depending on `test_file.py` would mean depending on all 3 tests in this
+file.
+
+Another example, with parametrization. We'll call this one `test_params.py`:
+
+``` python
+@pytest.mark.depends(name='bar')
+@pytest.mark.parametrize('num', [
+    pytest.param(1, marks=pytest.mark.depends(name='baz')),
+    2,
+])
+def test_with_params(num):
+    pass
+```
+
+The first run of the test, with `num = 1`, will be available under the following names:
+
+- `test_params.py::test_with_params[num0]`
+- `test_params.py::test_with_params`
+- `test_params.py`
+- `bar`
+- `baz`
+
+The second run of the test, with `num = 2`, will be available under the following names:
+
+- `test_params.py::test_with_params[num1]`
+- `test_params.py::test_with_params`
+- `test_params.py`
+- `bar`
+
+Note that the first name has a partially autogenerated name. If you want to depend on a single instance of a
+parametrized test, it's recommended to use the `pytest.depends` syntax to give it a name rather than depending on the
+autogenerated one.
+
+
diff --git a/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/RECORD
new file mode 100644
index 0000000..f466f3e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/RECORD
@@ -0,0 +1,11 @@
+pytest_depends/__init__.py,sha256=314xx_BLd1U0ND-AuJAvabnr1RIcVYDaGr6OSlOd_n8,5292
+pytest_depends/constants.py,sha256=8n0ldypybepvuQv-nIsqpEPhogGWt8yxFEgqx7CRtfE,331
+pytest_depends/main.py,sha256=1cii5a0Draw5spkGAsQaFhQmK9RDcD3uYXc7ky8Kq_U,7372
+pytest_depends/util.py,sha256=dbVJ-V-8xZ0NWaZNPMP0X9sUOHLsj_KAGyIIozGU61A,3293
+pytest_depends-1.0.1.dist-info/LICENSE,sha256=kURcSZLrAm767IRSlXKWH0oqtpQ-PXgaQJCtrrNzdPE,1074
+pytest_depends-1.0.1.dist-info/METADATA,sha256=M4zMMyOOc1J9h2N9jRdDowwVypC5vL5xJJ6MWW55BOs,4929
+pytest_depends-1.0.1.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
+pytest_depends-1.0.1.dist-info/entry_points.txt,sha256=Fhuds9J6A23PuKOkeF46kO4PTY4ccCuUc9iHq69pwn8,37
+pytest_depends-1.0.1.dist-info/top_level.txt,sha256=Vur-FP1NMbcaFRuie0FcqWW9ZqDC-ysu7atPMRWVeek,15
+pytest_depends-1.0.1.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+pytest_depends-1.0.1.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/WHEEL
new file mode 100644
index 0000000..b552003
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/entry_points.txt
new file mode 100644
index 0000000..46838f5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/entry_points.txt
@@ -0,0 +1,3 @@
+[pytest11]
+depends = pytest_depends
+
diff --git a/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/top_level.txt
new file mode 100644
index 0000000..138cc12
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_depends-1.0.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+pytest_depends
diff --git a/myenv/lib/python3.9/site-packages/pytest_depends/__init__.py b/myenv/lib/python3.9/site-packages/pytest_depends/__init__.py
new file mode 100644
index 0000000..9a751b0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_depends/__init__.py
@@ -0,0 +1,159 @@
+# -*- coding: future_fstrings -*-
+
+"""
+A module that provides the pytest hooks for this plugin.
+
+The logic itself is in main.py.
+"""
+
+import pytest
+
+from pytest_depends.main import DependencyManager
+from pytest_depends.util import clean_nodeid
+
+
+# Each test suite run should have a single manager object. For regular runs, a simple singleton would suffice, but for
+# our own tests this causes problems, as the nested pytest runs get the same instance. This can be worked around by
+# running them all in subprocesses, but this slows the tests down massively. Instead, keep a stack of managers, so each
+# test suite will have its own manager, even nested ones.
+managers = []
+
+
+DEPENDENCY_PROBLEM_ACTIONS = {
+	'run': None,
+	'skip': lambda m: pytest.skip(m),
+	'fail': lambda m: pytest.fail(m, False),
+}
+
+
+def _add_ini_and_option(parser, group, name, help, default, **kwargs):
+	""" Add an option to both the ini file as well as the command line flags, with the latter overriding the former. """
+	parser.addini(name, help + ' This overrides the similarly named option from the config.', default = default)
+	group.addoption(f'--{name.replace("_", "-")}', help = help, default = None, **kwargs)
+
+
+def _get_ini_or_option(config, name, choices):
+	""" Get an option from either the ini file or the command line flags, the latter taking precedence. """
+	value = config.getini(name)
+	if value is not None and choices is not None and value not in choices:
+		raise ValueError(f'Invalid ini value for {name}, choose from {", ".join(choices)}')
+	return config.getoption(name) or value
+
+
+def pytest_addoption(parser):  # noqa: D103
+	group = parser.getgroup('depends')
+
+	# Add a flag to list all names + the tests they resolve to
+	group.addoption(
+		'--list-dependency-names',
+		action = 'store_true',
+		default = False,
+		help = (
+			'List all non-nodeid dependency names + the tests they resolve to. '
+			'Will also list all nodeid dependency names when verbosity is high enough.'
+		),
+	)
+
+	# Add a flag to list all (resolved) dependencies for all tests + unresolvable names
+	group.addoption(
+		'--list-processed-dependencies',
+		action = 'store_true',
+		default = False,
+		help = 'List all dependencies of all tests as a list of nodeids + the names that could not be resolved.',
+	)
+
+	# Add an ini option + flag to choose the action to take for failed dependencies
+	_add_ini_and_option(
+		parser,
+		group,
+		name = 'failed_dependency_action',
+		help = (
+			'The action to take when a test has dependencies that failed. '
+			'Use "run" to run the test anyway, "skip" to skip the test, and "fail" to fail the test.'
+		),
+		default = 'skip',
+		choices = DEPENDENCY_PROBLEM_ACTIONS.keys(),
+	)
+
+	# Add an ini option + flag to choose the action to take for unresolved dependencies
+	_add_ini_and_option(
+		parser,
+		group,
+		name = 'missing_dependency_action',
+		help = (
+			'The action to take when a test has dependencies that cannot be found within the current scope. '
+			'Use "run" to run the test anyway, "skip" to skip the test, and "fail" to fail the test.'
+		),
+		default = 'skip',
+		choices = DEPENDENCY_PROBLEM_ACTIONS.keys(),
+	)
+
+
+def pytest_configure(config):  # noqa: D103
+	manager = DependencyManager()
+	managers.append(manager)
+
+	# Setup the handling of problems with dependencies
+	manager.options['failed_dependency_action'] = _get_ini_or_option(
+		config,
+		'failed_dependency_action',
+		DEPENDENCY_PROBLEM_ACTIONS.keys(),
+	)
+	manager.options['missing_dependency_action'] = _get_ini_or_option(
+		config,
+		'missing_dependency_action',
+		DEPENDENCY_PROBLEM_ACTIONS.keys(),
+	)
+
+	# Register marker
+	config.addinivalue_line("markers", "depends(name='name', on=['other_name']): marks depencies between tests.")
+
+
+@pytest.hookimpl(trylast = True)
+def pytest_collection_modifyitems(config, items):  # noqa: D103
+	manager = managers[-1]
+
+	# Register the founds tests on the manager
+	manager.items = items
+
+	# Show the extra information if requested
+	if config.getoption('list_dependency_names'):
+		verbose = config.getoption('verbose') > 1
+		manager.print_name_map(verbose)
+	if config.getoption('list_processed_dependencies'):
+		color = config.getoption('color')
+		manager.print_processed_dependencies(color)
+
+	# Reorder the items so that tests run after their dependencies
+	items[:] = manager.sorted_items
+
+
+@pytest.hookimpl(tryfirst = True, hookwrapper = True)
+def pytest_runtest_makereport(item, call):  # noqa: D103
+	manager = managers[-1]
+
+	# Run the step
+	outcome = yield
+
+	# Store the result on the manager
+	manager.register_result(item, outcome.get_result())
+
+
+def pytest_runtest_call(item):  # noqa: D103
+	manager = managers[-1]
+
+	# Handle missing dependencies
+	missing_dependency_action = DEPENDENCY_PROBLEM_ACTIONS[manager.options['missing_dependency_action']]
+	missing = manager.get_missing(item)
+	if missing_dependency_action and missing:
+		missing_dependency_action(f'{item.nodeid} depends on {", ".join(missing)}, which was not found')
+
+	# Check whether all dependencies succeeded
+	failed_dependency_action = DEPENDENCY_PROBLEM_ACTIONS[manager.options['failed_dependency_action']]
+	failed = manager.get_failed(item)
+	if failed_dependency_action and failed:
+		failed_dependency_action(f'{item.nodeid} depends on {", ".join(failed)}')
+
+
+def pytest_unconfigure():  # noqa: D103
+	managers.pop()
diff --git a/myenv/lib/python3.9/site-packages/pytest_depends/constants.py b/myenv/lib/python3.9/site-packages/pytest_depends/constants.py
new file mode 100644
index 0000000..e2e1571
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_depends/constants.py
@@ -0,0 +1,10 @@
+""" Constants for this module. """
+
+# The name of the marker used
+MARKER_NAME = 'depends'
+
+# The name of the keyword argument for the marker that contains custom name(s) for the tests
+MARKER_KWARG_ID = 'name'
+
+# The name of the keyword argument for the marker that specifies the tests to depend on
+MARKER_KWARG_DEPENDENCIES = 'on'
diff --git a/myenv/lib/python3.9/site-packages/pytest_depends/main.py b/myenv/lib/python3.9/site-packages/pytest_depends/main.py
new file mode 100644
index 0000000..c490711
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_depends/main.py
@@ -0,0 +1,224 @@
+# -*- coding: future_fstrings -*-
+
+"""
+A module to manage dependencies between pytest tests.
+
+This module provides the methods implementing the main logic. These are used in the pytest hooks that are in
+__init__.py.
+"""
+
+import collections
+
+import colorama
+import networkx
+
+from pytest_depends.constants import MARKER_NAME
+from pytest_depends.constants import MARKER_KWARG_DEPENDENCIES
+from pytest_depends.util import as_list
+from pytest_depends.util import clean_nodeid
+from pytest_depends.util import get_absolute_nodeid
+from pytest_depends.util import get_markers
+from pytest_depends.util import get_names
+
+
+class TestResult(object):
+	""" Keeps track of the results of a single test. """
+
+	STEPS = ['setup', 'call', 'teardown']
+	GOOD_OUTCOMES = ['passed']
+
+	def __init__(self, nodeid):
+		""" Create a new instance for a test with a given node id. """
+		self.nodeid = nodeid
+		self.results = {}
+
+	def register_result(self, result):
+		""" Register a result of this test. """
+		if result.when not in self.STEPS:
+			raise ValueError(f'Received result for unknown step {result.when} of test {self.nodeid}')
+		if result.when in self.results:
+			raise AttributeError(f'Received multiple results for step {result.when} of test {self.nodeid}')
+		self.results[result.when] = result.outcome
+
+	@property
+	def success(self):
+		""" Whether the entire test was successful. """
+		return all(self.results.get(step, None) in self.GOOD_OUTCOMES for step in self.STEPS)
+
+
+class TestDependencies(object):
+	""" Information about the resolved dependencies of a single test. """
+
+	def __init__(self, item, manager):
+		""" Create a new instance for a given test. """
+		self.nodeid = clean_nodeid(item.nodeid)
+		self.dependencies = set()
+		self.unresolved = set()
+
+		markers = get_markers(item, MARKER_NAME)
+		dependencies = [dep for marker in markers for dep in as_list(marker.kwargs.get(MARKER_KWARG_DEPENDENCIES, []))]
+		for dependency in dependencies:
+			# If the name is not known, try to make it absolute (ie file::[class::]method)
+			if dependency not in manager.name_to_nodeids:
+				absolute_dependency = get_absolute_nodeid(dependency, self.nodeid)
+				if absolute_dependency in manager.name_to_nodeids:
+					dependency = absolute_dependency
+
+			# Add all items matching the name
+			if dependency in manager.name_to_nodeids:
+				for nodeid in manager.name_to_nodeids[dependency]:
+					self.dependencies.add(nodeid)
+			else:
+				self.unresolved.add(dependency)
+
+
+class DependencyManager(object):
+	""" Keep track of tests, their names and their dependencies. """
+
+	def __init__(self):
+		""" Create a new DependencyManager. """
+		self.options = {}
+		self._items = None
+		self._name_to_nodeids = None
+		self._nodeid_to_item = None
+		self._results = None
+
+	@property
+	def items(self):  # noqa: D401
+		""" The collected tests that are managed by this instance. """
+		if self._items is None:
+			raise AttributeError('The items attribute has not been set yet')
+		return self._items
+
+	@items.setter
+	def items(self, items):
+		if self._items is not None:
+			raise AttributeError('The items attribute has already been set')
+		self._items = items
+
+		self._name_to_nodeids = collections.defaultdict(list)
+		self._nodeid_to_item = {}
+		self._results = {}
+		self._dependencies = {}
+
+		for item in items:
+			nodeid = clean_nodeid(item.nodeid)
+			# Add the mapping from nodeid to the test item
+			self._nodeid_to_item[nodeid] = item
+			# Add the mappings from all names to the node id
+			for name in get_names(item):
+				self._name_to_nodeids[name].append(nodeid)
+			# Create the object that will contain the results of this test
+			self._results[nodeid] = TestResult(clean_nodeid(item.nodeid))
+
+		# Don't allow using unknown keys on the name_to_nodeids mapping
+		self._name_to_nodeids.default_factory = None
+
+		for item in items:
+			nodeid = clean_nodeid(item.nodeid)
+			# Process the dependencies of this test
+			# This uses the mappings created in the previous loop, and can thus not be merged into that loop
+			self._dependencies[nodeid] = TestDependencies(item, self)
+
+	@property
+	def name_to_nodeids(self):  # noqa: D401
+		""" A mapping from names to matching node id(s). """
+		assert self.items is not None
+		return self._name_to_nodeids
+
+	@property
+	def nodeid_to_item(self):  # noqa: D401
+		""" A mapping from node ids to test items. """
+		assert self.items is not None
+		return self._nodeid_to_item
+
+	@property
+	def results(self):  # noqa: D401
+		""" The results of the tests. """
+		assert self.items is not None
+		return self._results
+
+	@property
+	def dependencies(self):  # noqa: D401
+		""" The dependencies of the tests. """
+		assert self.items is not None
+		return self._dependencies
+
+	def print_name_map(self, verbose = False):
+		""" Print a human-readable version of the name -> test mapping. """
+		print('Available dependency names:')
+		for name, nodeids in sorted(self.name_to_nodeids.items(), key = lambda x: x[0]):
+			if len(nodeids) == 1:
+				if name == nodeids[0]:
+					# This is just the base name, only print this when verbose
+					if verbose:
+						print(f'  {name}')
+				else:
+					# Name refers to a single node id, so use the short format
+					print(f'  {name} -> {nodeids[0]}')
+			else:
+				# Name refers to multiple node ids, so use the long format
+				print(f'  {name} ->')
+				for nodeid in sorted(nodeids):
+					print(f'    {nodeid}')
+
+	def print_processed_dependencies(self, colors = False):
+		""" Print a human-readable list of the processed dependencies. """
+		missing = 'MISSING'
+		if colors:
+			missing = f'{colorama.Fore.RED}{missing}{colorama.Fore.RESET}'
+			colorama.init()
+		try:
+			print('Dependencies:')
+			for nodeid, info in sorted(self.dependencies.items(), key = lambda x: x[0]):
+				descriptions = []
+				for dependency in info.dependencies:
+					descriptions.append(dependency)
+				for dependency in info.unresolved:
+					descriptions.append(f'{dependency} ({missing})')
+				if descriptions:
+					print(f'  {nodeid} depends on')
+					for description in sorted(descriptions):
+						print(f'    {description}')
+		finally:
+			if colors:
+				colorama.deinit()
+
+	@property
+	def sorted_items(self):
+		""" Get a sorted list of tests where all tests are sorted after their dependencies. """
+		# Build a directed graph for sorting
+		dag = networkx.DiGraph()
+
+		# Insert all items as nodes, to prevent items that have no dependencies and are not dependencies themselves from
+		# being lost
+		dag.add_nodes_from(self.items)
+
+		# Insert edges for all the dependencies
+		for item in self.items:
+			nodeid = clean_nodeid(item.nodeid)
+			for dependency in self.dependencies[nodeid].dependencies:
+				dag.add_edge(self.nodeid_to_item[dependency], item)
+
+		# Return the sorted list
+		return networkx.topological_sort(dag)
+
+	def register_result(self, item, result):
+		""" Register a result of a test. """
+		nodeid = clean_nodeid(item.nodeid)
+		self.results[nodeid].register_result(result)
+
+	def get_failed(self, item):
+		""" Get a list of unfulfilled dependencies for a test. """
+		nodeid = clean_nodeid(item.nodeid)
+		failed = []
+		for dependency in self.dependencies[nodeid].dependencies:
+			result = self.results[dependency]
+			if not result.success:
+				failed.append(dependency)
+		return failed
+
+	def get_missing(self, item):
+		""" Get a list of missing dependencies for a test. """
+		nodeid = clean_nodeid(item.nodeid)
+		return self.dependencies[nodeid].unresolved
diff --git a/myenv/lib/python3.9/site-packages/pytest_depends/util.py b/myenv/lib/python3.9/site-packages/pytest_depends/util.py
new file mode 100644
index 0000000..7d3e2f3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/pytest_depends/util.py
@@ -0,0 +1,124 @@
+# -*- coding: future_fstrings -*-
+
+""" Utility functions to process the identifiers of tests. """
+
+import re
+
+from pytest_depends.constants import MARKER_NAME
+from pytest_depends.constants import MARKER_KWARG_ID
+
+
+try:
+	basestring
+except NameError:
+	basestring = str
+
+
+REGEX_PARAMETERS = re.compile(r'\[.+\]$')
+
+
+def clean_nodeid(nodeid):
+	"""
+	Remove any superfluous ::() from a node id.
+
+	>>> clean_nodeid('test_file.py::TestClass::()::test')
+	'test_file.py::TestClass::test'
+	>>> clean_nodeid('test_file.py::TestClass::test')
+	'test_file.py::TestClass::test'
+	>>> clean_nodeid('test_file.py::test')
+	'test_file.py::test'
+	"""
+	return nodeid.replace('::()::', '::')
+
+
+def strip_nodeid_parameters(nodeid):
+	"""
+	Strip parameters from a node id.
+
+	>>> strip_nodeid_parameters('test_file.py::TestClass::test[foo]')
+	'test_file.py::TestClass::test'
+	>>> strip_nodeid_parameters('test_file.py::TestClass::test')
+	'test_file.py::TestClass::test'
+	"""
+	return REGEX_PARAMETERS.sub('', nodeid)
+
+
+def get_absolute_nodeid(nodeid, scope):
+	"""
+	Transform a possibly relative node id to an absolute one using the scope in which it is used.
+
+	>>> scope = 'test_file.py::TestClass::test'
+	>>> get_absolute_nodeid('test2', scope)
+	'test_file.py::TestClass::test2'
+	>>> get_absolute_nodeid('TestClass2::test2', scope)
+	'test_file.py::TestClass2::test2'
+	>>> get_absolute_nodeid('test_file2.py::TestClass2::test2', scope)
+	'test_file2.py::TestClass2::test2'
+	"""
+	parts = nodeid.split('::')
+	# Completely relative (test_name), so add the full current scope (either file::class or file)
+	if len(parts) == 1:
+		base_nodeid = scope.rsplit('::', 1)[0]
+		nodeid = f'{base_nodeid}::{nodeid}'
+	# Contains some scope already (Class::test_name), so only add the current file scope
+	elif '.' not in parts[0]:
+		base_nodeid = scope.split('::', 1)[0]
+		nodeid = f'{base_nodeid}::{nodeid}'
+	return clean_nodeid(nodeid)
+
+
+def get_names(item):
+	"""
+	Get all names for a test.
+
+	This will use the following methods to determine the name of the test:
+		- If given, the custom name(s) passed to the keyword argument name on the marker
+		- The full node id of the test
+		- The node id of the test with any parameters removed, if it had any
+		- All 'scope' parts of the node id. For example, for a test test_file.py::TestClass::test, this would be
+		test_file.py and test_file.py::TestClass
+	"""
+	names = set()
+
+	# Node id
+	nodeid = clean_nodeid(item.nodeid)
+	names.add(nodeid)
+
+	# Node id without parameter
+	nodeid = strip_nodeid_parameters(nodeid)
+	names.add(nodeid)
+
+	# Node id scopes
+	while '::' in nodeid:
+		nodeid = nodeid.rsplit('::', 1)[0]
+		names.add(nodeid)
+
+	# Custom name
+	markers = get_markers(item, MARKER_NAME)
+	for marker in markers:
+		if MARKER_KWARG_ID in marker.kwargs:
+			for name in as_list(marker.kwargs[MARKER_KWARG_ID]):
+				names.add(name)
+
+	return names
+
+
+def get_markers(item, name):
+	""" Get all markers with the given name for a given item. """
+	for marker in item.iter_markers():
+		if marker.name == name:
+			yield marker
+
+
+def as_list(lst):
+	"""
+	Convert the input to a list of strings.
+
+	If the input is a single string, it will be wrapped in a list instead of iterated over.
+
+	>>> as_list(['foo'])
+	['foo']
+	>>> as_list('foo')
+	['foo']
+	"""
+	return [lst] if isinstance(lst, basestring) else lst
diff --git a/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/LICENSE
new file mode 100644
index 0000000..39372fe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/LICENSE
@@ -0,0 +1,87 @@
+python-dotenv
+Copyright (c) 2014, Saurabh Kumar
+
+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 python-dotenv nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+django-dotenv-rw
+Copyright (c) 2013, Ted Tieken
+
+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 django-dotenv nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Original django-dotenv
+Copyright (c) 2013, Jacob Kaplan-Moss
+
+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 django-dotenv nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/METADATA
new file mode 100644
index 0000000..5d16fa8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/METADATA
@@ -0,0 +1,594 @@
+Metadata-Version: 2.1
+Name: python-dotenv
+Version: 0.20.0
+Summary: Read key-value pairs from a .env file and set them as environment variables
+Home-page: https://github.com/theskumar/python-dotenv
+Author: Saurabh Kumar
+Author-email: me+github@saurabh-kumar.com
+License: BSD-3-Clause
+Keywords: environment variables,deployments,settings,env,dotenv,configurations,python
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Classifier: Environment :: Web Environment
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: cli
+Requires-Dist: click (>=5.0) ; extra == 'cli'
+
+# python-dotenv
+
+[![Build Status][build_status_badge]][build_status_link]
+[![PyPI version][pypi_badge]][pypi_link]
+
+Python-dotenv reads key-value pairs from a `.env` file and can set them as environment
+variables. It helps in the development of applications following the
+[12-factor](http://12factor.net/) principles.
+
+- [Getting Started](#getting-started)
+- [Other Use Cases](#other-use-cases)
+  * [Load configuration without altering the environment](#load-configuration-without-altering-the-environment)
+  * [Parse configuration as a stream](#parse-configuration-as-a-stream)
+  * [Load .env files in IPython](#load-env-files-in-ipython)
+- [Command-line Interface](#command-line-interface)
+- [File format](#file-format)
+  * [Multiline values](#multiline-values)
+  * [Variable expansion](#variable-expansion)
+- [Related Projects](#related-projects)
+- [Acknowledgements](#acknowledgements)
+
+## Getting Started
+
+```shell
+pip install python-dotenv
+```
+
+If your application takes its configuration from environment variables, like a 12-factor
+application, launching it in development is not very practical because you have to set
+those environment variables yourself.
+
+To help you with that, you can add Python-dotenv to your application to make it load the
+configuration from a `.env` file when it is present (e.g. in development) while remaining
+configurable via the environment:
+
+```python
+from dotenv import load_dotenv
+
+load_dotenv()  # take environment variables from .env.
+
+# Code of your application, which uses environment variables (e.g. from `os.environ` or
+# `os.getenv`) as if they came from the actual environment.
+```
+
+By default, `load_dotenv` doesn't override existing environment variables.
+
+To configure the development environment, add a `.env` in the root directory of your
+project:
+
+```
+.
+├── .env
+└── foo.py
+```
+
+The syntax of `.env` files supported by python-dotenv is similar to that of Bash:
+
+```bash
+# Development settings
+DOMAIN=example.org
+ADMIN_EMAIL=admin@${DOMAIN}
+ROOT_URL=${DOMAIN}/app
+```
+
+If you use variables in values, ensure they are surrounded with `{` and `}`, like
+`${DOMAIN}`, as bare variables such as `$DOMAIN` are not expanded.
+
+You will probably want to add `.env` to your `.gitignore`, especially if it contains
+secrets like a password.
+
+See the section "File format" below for more information about what you can write in a
+`.env` file.
+
+## Other Use Cases
+
+### Load configuration without altering the environment
+
+The function `dotenv_values` works more or less the same way as `load_dotenv`, except it
+doesn't touch the environment, it just returns a `dict` with the values parsed from the
+`.env` file.
+
+```python
+from dotenv import dotenv_values
+
+config = dotenv_values(".env")  # config = {"USER": "foo", "EMAIL": "foo@example.org"}
+```
+
+This notably enables advanced configuration management:
+
+```python
+import os
+from dotenv import dotenv_values
+
+config = {
+    **dotenv_values(".env.shared"),  # load shared development variables
+    **dotenv_values(".env.secret"),  # load sensitive variables
+    **os.environ,  # override loaded values with environment variables
+}
+```
+
+### Parse configuration as a stream
+
+`load_dotenv` and `dotenv_values` accept [streams][python_streams] via their `stream`
+argument.  It is thus possible to load the variables from sources other than the
+filesystem (e.g. the network).
+
+```python
+from io import StringIO
+
+from dotenv import load_dotenv
+
+config = StringIO("USER=foo\nEMAIL=foo@example.org")
+load_dotenv(stream=config)
+```
+
+### Load .env files in IPython
+
+You can use dotenv in IPython.  By default, it will use `find_dotenv` to search for a
+`.env` file:
+
+```python
+%load_ext dotenv
+%dotenv
+```
+
+You can also specify a path:
+
+```python
+%dotenv relative/or/absolute/path/to/.env
+```
+
+Optional flags:
+
+- `-o` to override existing variables.
+- `-v` for increased verbosity.
+
+## Command-line Interface
+
+A CLI interface `dotenv` is also included, which helps you manipulate the `.env` file
+without manually opening it.
+
+```shell
+$ pip install "python-dotenv[cli]"
+$ dotenv set USER foo
+$ dotenv set EMAIL foo@example.org
+$ dotenv list
+USER=foo
+EMAIL=foo@example.org
+$ dotenv run -- python foo.py
+```
+
+Run `dotenv --help` for more information about the options and subcommands.
+
+## File format
+
+The format is not formally specified and still improves over time.  That being said,
+`.env` files should mostly look like Bash files.
+
+Keys can be unquoted or single-quoted. Values can be unquoted, single- or double-quoted.
+Spaces before and after keys, equal signs, and values are ignored. Values can be followed
+by a comment.  Lines can start with the `export` directive, which has no effect on their
+interpretation.
+
+Allowed escape sequences:
+
+- in single-quoted values: `\\`, `\'`
+- in double-quoted values: `\\`, `\'`, `\"`, `\a`, `\b`, `\f`, `\n`, `\r`, `\t`, `\v`
+
+### Multiline values
+
+It is possible for single- or double-quoted values to span multiple lines.  The following
+examples are equivalent:
+
+```bash
+FOO="first line
+second line"
+```
+
+```bash
+FOO="first line\nsecond line"
+```
+
+### Variable expansion
+
+Python-dotenv can interpolate variables using POSIX variable expansion.
+
+With `load_dotenv(override=True)` or `dotenv_values()`, the value of a variable is the
+first of the values defined in the following list:
+
+- Value of that variable in the `.env` file.
+- Value of that variable in the environment.
+- Default value, if provided.
+- Empty string.
+
+With `load_dotenv(override=False)`, the value of a variable is the first of the values
+defined in the following list:
+
+- Value of that variable in the environment.
+- Value of that variable in the `.env` file.
+- Default value, if provided.
+- Empty string.
+
+## Related Projects
+
+-   [Honcho](https://github.com/nickstenning/honcho) - For managing
+    Procfile-based applications.
+-   [django-dotenv](https://github.com/jpadilla/django-dotenv)
+-   [django-environ](https://github.com/joke2k/django-environ)
+-   [django-environ-2](https://github.com/sergeyklay/django-environ-2)
+-   [django-configuration](https://github.com/jezdez/django-configurations)
+-   [dump-env](https://github.com/sobolevn/dump-env)
+-   [environs](https://github.com/sloria/environs)
+-   [dynaconf](https://github.com/rochacbruno/dynaconf)
+
+## Acknowledgements
+
+This project is currently maintained by [Saurabh Kumar](https://saurabh-kumar.com) and
+[Bertrand Bonnefoy-Claudet](https://github.com/bbc2) and would not have been possible
+without the support of these [awesome
+people](https://github.com/theskumar/python-dotenv/graphs/contributors).
+
+[build_status_badge]: https://github.com/theskumar/python-dotenv/actions/workflows/test.yml/badge.svg
+[build_status_link]: https://github.com/theskumar/python-dotenv/actions/workflows/test.yml
+[pypi_badge]: https://badge.fury.io/py/python-dotenv.svg
+[pypi_link]: http://badge.fury.io/py/python-dotenv
+[python_streams]: https://docs.python.org/3/library/io.html
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this
+project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.20.0] - 2022-03-24
+
+### Added
+
+- Add `encoding` (`Optional[str]`) parameter to `get_key`, `set_key` and `unset_key`.
+  (#379 by [@bbc2])
+
+### Fixed
+
+- Use dict to specify the `entry_points` parameter of `setuptools.setup` (#376 by
+  [@mgorny]).
+- Don't build universal wheels (#387 by [@bbc2]).
+
+## [0.19.2] - 2021-11-11
+
+### Fixed
+
+- In `set_key`, add missing newline character before new entry if necessary. (#361 by
+  [@bbc2])
+
+## [0.19.1] - 2021-08-09
+
+### Added
+
+- Add support for Python 3.10. (#359 by [@theskumar])
+
+## [0.19.0] - 2021-07-24
+
+### Changed
+
+- Require Python 3.5 or a later version.  Python 2 and 3.4 are no longer supported. (#341
+  by [@bbc2]).
+
+### Added
+
+- The `dotenv_path` argument of `set_key` and `unset_key` now has a type of `Union[str,
+  os.PathLike]` instead of just `os.PathLike` (#347 by [@bbc2]).
+- The `stream` argument of `load_dotenv` and `dotenv_values` can now be a text stream
+  (`IO[str]`), which includes values like `io.StringIO("foo")` and `open("file.env",
+  "r")` (#348 by [@bbc2]).
+
+## [0.18.0] - 2021-06-20
+
+### Changed
+
+- Raise `ValueError` if `quote_mode` isn't one of `always`, `auto` or `never` in
+  `set_key` (#330 by [@bbc2]).
+- When writing a value to a .env file with `set_key` or `dotenv set <key> <value>` (#330
+  by [@bbc2]):
+  - Use single quotes instead of double quotes.
+  - Don't strip surrounding quotes.
+  - In `auto` mode, don't add quotes if the value is only made of alphanumeric characters
+    (as determined by `string.isalnum`).
+
+## [0.17.1] - 2021-04-29
+
+### Fixed
+
+- Fixed tests for build environments relying on `PYTHONPATH` (#318 by [@befeleme]).
+
+## [0.17.0] - 2021-04-02
+
+### Changed
+
+- Make `dotenv get <key>` only show the value, not `key=value` (#313 by [@bbc2]).
+
+### Added
+
+- Add `--override`/`--no-override` option to `dotenv run` (#312 by [@zueve] and [@bbc2]).
+
+## [0.16.0] - 2021-03-27
+
+### Changed
+
+- The default value of the `encoding` parameter for `load_dotenv` and `dotenv_values` is
+  now `"utf-8"` instead of `None` (#306 by [@bbc2]).
+- Fix resolution order in variable expansion with `override=False` (#287 by [@bbc2]).
+
+## [0.15.0] - 2020-10-28
+
+### Added
+
+- Add `--export` option to `set` to make it prepend the binding with `export` (#270 by
+  [@jadutter]).
+
+### Changed
+
+- Make `set` command create the `.env` file in the current directory if no `.env` file was
+  found (#270 by [@jadutter]).
+
+### Fixed
+
+- Fix potentially empty expanded value for duplicate key (#260 by [@bbc2]).
+- Fix import error on Python 3.5.0 and 3.5.1 (#267 by [@gongqingkui]).
+- Fix parsing of unquoted values containing several adjacent space or tab characters
+  (#277 by [@bbc2], review by [@x-yuri]).
+
+## [0.14.0] - 2020-07-03
+
+### Changed
+
+- Privilege definition in file over the environment in variable expansion (#256 by
+  [@elbehery95]).
+
+### Fixed
+
+- Improve error message for when file isn't found (#245 by [@snobu]).
+- Use HTTPS URL in package meta data (#251 by [@ekohl]).
+
+## [0.13.0] - 2020-04-16
+
+### Added
+
+- Add support for a Bash-like default value in variable expansion (#248 by [@bbc2]).
+
+## [0.12.0] - 2020-02-28
+
+### Changed
+
+- Use current working directory to find `.env` when bundled by PyInstaller (#213 by
+  [@gergelyk]).
+
+### Fixed
+
+- Fix escaping of quoted values written by `set_key` (#236 by [@bbc2]).
+- Fix `dotenv run` crashing on environment variables without values (#237 by [@yannham]).
+- Remove warning when last line is empty (#238 by [@bbc2]).
+
+## [0.11.0] - 2020-02-07
+
+### Added
+
+- Add `interpolate` argument to `load_dotenv` and `dotenv_values` to disable interpolation
+  (#232 by [@ulyssessouza]).
+
+### Changed
+
+- Use logging instead of warnings (#231 by [@bbc2]).
+
+### Fixed
+
+- Fix installation in non-UTF-8 environments (#225 by [@altendky]).
+- Fix PyPI classifiers (#228 by [@bbc2]).
+
+## [0.10.5] - 2020-01-19
+
+### Fixed
+
+- Fix handling of malformed lines and lines without a value (#222 by [@bbc2]):
+  - Don't print warning when key has no value.
+  - Reject more malformed lines (e.g. "A: B", "a='b',c").
+- Fix handling of lines with just a comment (#224 by [@bbc2]).
+
+## [0.10.4] - 2020-01-17
+
+### Added
+
+- Make typing optional (#179 by [@techalchemy]).
+- Print a warning on malformed line (#211 by [@bbc2]).
+- Support keys without a value (#220 by [@ulyssessouza]).
+
+## 0.10.3
+
+- Improve interactive mode detection ([@andrewsmith])([#183]).
+- Refactor parser to fix parsing inconsistencies ([@bbc2])([#170]).
+  - Interpret escapes as control characters only in double-quoted strings.
+  - Interpret `#` as start of comment only if preceded by whitespace.
+
+## 0.10.2
+
+- Add type hints and expose them to users ([@qnighy])([#172])
+- `load_dotenv` and `dotenv_values` now accept an `encoding` parameter, defaults to `None`
+  ([@theskumar])([@earlbread])([#161])
+- Fix `str`/`unicode` inconsistency in Python 2: values are always `str` now. ([@bbc2])([#121])
+- Fix Unicode error in Python 2, introduced in 0.10.0. ([@bbc2])([#176])
+
+## 0.10.1
+- Fix parsing of variable without a value ([@asyncee])([@bbc2])([#158])
+
+## 0.10.0
+
+- Add support for UTF-8 in unquoted values ([@bbc2])([#148])
+- Add support for trailing comments ([@bbc2])([#148])
+- Add backslashes support in values ([@bbc2])([#148])
+- Add support for newlines in values ([@bbc2])([#148])
+- Force environment variables to str with Python2 on Windows ([@greyli])
+- Drop Python 3.3 support ([@greyli])
+- Fix stderr/-out/-in redirection ([@venthur])
+
+
+## 0.9.0
+
+- Add `--version` parameter to cli ([@venthur])
+- Enable loading from current directory ([@cjauvin])
+- Add 'dotenv run' command for calling arbitrary shell script with .env ([@venthur])
+
+## 0.8.1
+
+-   Add tests for docs ([@Flimm])
+-   Make 'cli' support optional. Use `pip install python-dotenv[cli]`. ([@theskumar])
+
+## 0.8.0
+
+-   `set_key` and `unset_key` only modified the affected file instead of
+    parsing and re-writing file, this causes comments and other file
+    entact as it is.
+-   Add support for `export` prefix in the line.
+-   Internal refractoring ([@theskumar])
+-   Allow `load_dotenv` and `dotenv_values` to work with `StringIO())` ([@alanjds])([@theskumar])([#78])
+
+## 0.7.1
+
+-   Remove hard dependency on iPython ([@theskumar])
+
+## 0.7.0
+
+-   Add support to override system environment variable via .env.
+    ([@milonimrod](https://github.com/milonimrod))
+    ([\#63](https://github.com/theskumar/python-dotenv/issues/63))
+-   Disable ".env not found" warning by default
+    ([@maxkoryukov](https://github.com/maxkoryukov))
+    ([\#57](https://github.com/theskumar/python-dotenv/issues/57))
+
+## 0.6.5
+
+-   Add support for special characters `\`.
+    ([@pjona](https://github.com/pjona))
+    ([\#60](https://github.com/theskumar/python-dotenv/issues/60))
+
+## 0.6.4
+
+-   Fix issue with single quotes ([@Flimm])
+    ([\#52](https://github.com/theskumar/python-dotenv/issues/52))
+
+## 0.6.3
+
+-   Handle unicode exception in setup.py
+    ([\#46](https://github.com/theskumar/python-dotenv/issues/46))
+
+## 0.6.2
+
+-   Fix dotenv list command ([@ticosax](https://github.com/ticosax))
+-   Add iPython Support
+    ([@tillahoffmann](https://github.com/tillahoffmann))
+
+## 0.6.0
+
+-   Drop support for Python 2.6
+-   Handle escaped characters and newlines in quoted values. (Thanks
+    [@iameugenejo](https://github.com/iameugenejo))
+-   Remove any spaces around unquoted key/value. (Thanks
+    [@paulochf](https://github.com/paulochf))
+-   Added POSIX variable expansion. (Thanks
+    [@hugochinchilla](https://github.com/hugochinchilla))
+
+## 0.5.1
+
+-   Fix find\_dotenv - it now start search from the file where this
+    function is called from.
+
+## 0.5.0
+
+-   Add `find_dotenv` method that will try to find a `.env` file.
+    (Thanks [@isms](https://github.com/isms))
+
+## 0.4.0
+
+-   cli: Added `-q/--quote` option to control the behaviour of quotes
+    around values in `.env`. (Thanks
+    [@hugochinchilla](https://github.com/hugochinchilla)).
+-   Improved test coverage.
+
+[#78]: https://github.com/theskumar/python-dotenv/issues/78
+[#121]: https://github.com/theskumar/python-dotenv/issues/121
+[#148]: https://github.com/theskumar/python-dotenv/issues/148
+[#158]: https://github.com/theskumar/python-dotenv/issues/158
+[#170]: https://github.com/theskumar/python-dotenv/issues/170
+[#172]: https://github.com/theskumar/python-dotenv/issues/172
+[#176]: https://github.com/theskumar/python-dotenv/issues/176
+[#183]: https://github.com/theskumar/python-dotenv/issues/183
+[#359]: https://github.com/theskumar/python-dotenv/issues/359
+
+[@Flimm]: https://github.com/Flimm
+[@alanjds]: https://github.com/alanjds
+[@altendky]: https://github.com/altendky
+[@andrewsmith]: https://github.com/andrewsmith
+[@asyncee]: https://github.com/asyncee
+[@bbc2]: https://github.com/bbc2
+[@befeleme]: https://github.com/befeleme
+[@cjauvin]: https://github.com/cjauvin
+[@earlbread]: https://github.com/earlbread
+[@ekohl]: https://github.com/ekohl
+[@elbehery95]: https://github.com/elbehery95
+[@gergelyk]: https://github.com/gergelyk
+[@gongqingkui]: https://github.com/gongqingkui
+[@greyli]: https://github.com/greyli
+[@jadutter]: https://github.com/jadutter
+[@mgorny]: https://github.com/mgorny
+[@qnighy]: https://github.com/qnighy
+[@snobu]: https://github.com/snobu
+[@techalchemy]: https://github.com/techalchemy
+[@theskumar]: https://github.com/theskumar
+[@ulyssessouza]: https://github.com/ulyssessouza
+[@venthur]: https://github.com/venthur
+[@x-yuri]: https://github.com/x-yuri
+[@yannham]: https://github.com/yannham
+[@zueve]: https://github.com/zueve
+
+[Unreleased]: https://github.com/theskumar/python-dotenv/compare/v0.20.0...HEAD
+[0.19.2]: https://github.com/theskumar/python-dotenv/compare/v0.19.2...v0.20.0
+[0.19.2]: https://github.com/theskumar/python-dotenv/compare/v0.19.1...v0.19.2
+[0.19.1]: https://github.com/theskumar/python-dotenv/compare/v0.19.0...v0.19.1
+[0.19.0]: https://github.com/theskumar/python-dotenv/compare/v0.18.0...v0.19.0
+[0.18.0]: https://github.com/theskumar/python-dotenv/compare/v0.17.1...v0.18.0
+[0.17.1]: https://github.com/theskumar/python-dotenv/compare/v0.17.0...v0.17.1
+[0.17.0]: https://github.com/theskumar/python-dotenv/compare/v0.16.0...v0.17.0
+[0.16.0]: https://github.com/theskumar/python-dotenv/compare/v0.15.0...v0.16.0
+[0.15.0]: https://github.com/theskumar/python-dotenv/compare/v0.14.0...v0.15.0
+[0.14.0]: https://github.com/theskumar/python-dotenv/compare/v0.13.0...v0.14.0
+[0.13.0]: https://github.com/theskumar/python-dotenv/compare/v0.12.0...v0.13.0
+[0.12.0]: https://github.com/theskumar/python-dotenv/compare/v0.11.0...v0.12.0
+[0.11.0]: https://github.com/theskumar/python-dotenv/compare/v0.10.5...v0.11.0
+[0.10.5]: https://github.com/theskumar/python-dotenv/compare/v0.10.4...v0.10.5
+[0.10.4]: https://github.com/theskumar/python-dotenv/compare/v0.10.3...v0.10.4
+
+
diff --git a/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/RECORD
new file mode 100644
index 0000000..8291881
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/RECORD
@@ -0,0 +1,16 @@
+../../../bin/dotenv,sha256=1s11Sf6KcYLPE2ZuFJP1B-SydlLjcaM97MJyoOjzFGM,248
+dotenv/__init__.py,sha256=bdAGaaBAOc_Hyqqy8UOVjedJDgUNqMTLlmqcOrMCdC8,1298
+dotenv/cli.py,sha256=MfmIEYbhDhANP7CzAkgDJUahjKcY5mOjCbDEnJNvqhI,4777
+dotenv/ipython.py,sha256=avI6aez_RxnBptYgchIquF2TSgKI-GOhY3ppiu3VuWE,1303
+dotenv/main.py,sha256=wBUr-lDnDo7fKAi8oHJLxRlna4wvoGTgJdJNTikrGw0,11692
+dotenv/parser.py,sha256=HMB0VVy_fejMuGZ_Fdigzln_dBE9nsAAaZ7olwoAZSw,5298
+dotenv/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+dotenv/variables.py,sha256=HtvYMOOyyogGGZv-YkGzeMOKtovvqqGzh_kIB9xuAto,2404
+dotenv/version.py,sha256=NGIecTe1EEM7UeBjKSJ4vCWuGDWF1ZX4PckW2Eguxps,23
+python_dotenv-0.20.0.dist-info/LICENSE,sha256=0nIJqz0WJ4Ko-OOHK5s1PEngksmqRnpkUiiDQH2NEDA,4600
+python_dotenv-0.20.0.dist-info/METADATA,sha256=fPA8H1g_zWafVdlx7u-TCw3mFyBDJxZh6JmuOdJDxY0,19376
+python_dotenv-0.20.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+python_dotenv-0.20.0.dist-info/entry_points.txt,sha256=Ta6e0xl3qUUz_ZZ1D1YAR6SKDHNGBPLcHqfzyXq4TVk,43
+python_dotenv-0.20.0.dist-info/top_level.txt,sha256=eyqUH4SHJNr6ahOYlxIunTr4XinE8Z5ajWLdrK3r0D8,7
+python_dotenv-0.20.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+python_dotenv-0.20.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/WHEEL
new file mode 100644
index 0000000..becc9a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/entry_points.txt
new file mode 100644
index 0000000..deb9ff4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/entry_points.txt
@@ -0,0 +1,3 @@
+[console_scripts]
+dotenv = dotenv.cli:cli
+
diff --git a/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/top_level.txt
new file mode 100644
index 0000000..fe7c01a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_dotenv-0.20.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+dotenv
diff --git a/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/LICENSE
new file mode 100644
index 0000000..8e99ab9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Michael Davis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/METADATA
new file mode 100644
index 0000000..314d09b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/METADATA
@@ -0,0 +1,148 @@
+Metadata-Version: 2.1
+Name: python-jose
+Version: 3.3.0
+Summary: JOSE implementation in Python
+Home-page: http://github.com/mpdavis/python-jose
+Author: Michael Davis
+Author-email: mike.philip.davis@gmail.com
+License: MIT
+Project-URL: Documentation, https://python-jose.readthedocs.io/en/latest/
+Project-URL: Source, https://github.com/mpdavis/python-jose/
+Project-URL: Tracker, https://github.com/mpdavis/python-jose/issues/
+Project-URL: Changelog, https://github.com/mpdavis/python-jose/blob/master/CHANGELOG.md
+Keywords: jose jws jwe jwt json web token security signing
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Utilities
+License-File: LICENSE
+Requires-Dist: ecdsa (!=0.15)
+Requires-Dist: rsa
+Requires-Dist: pyasn1
+Provides-Extra: cryptography
+Requires-Dist: cryptography (>=3.4.0) ; extra == 'cryptography'
+Provides-Extra: pycrypto
+Requires-Dist: pycrypto (<2.7.0,>=2.6.0) ; extra == 'pycrypto'
+Requires-Dist: pyasn1 ; extra == 'pycrypto'
+Provides-Extra: pycryptodome
+Requires-Dist: pycryptodome (<4.0.0,>=3.3.1) ; extra == 'pycryptodome'
+Requires-Dist: pyasn1 ; extra == 'pycryptodome'
+
+python-jose
+===========
+
+A JOSE implementation in Python
+
+|pypi| |Github Actions CI Status| |Coverage Status| |Docs| |style|
+
+Docs are available on ReadTheDocs_.
+
+The JavaScript Object Signing and Encryption (JOSE) technologies - JSON
+Web Signature (JWS), JSON Web Encryption (JWE), JSON Web Key (JWK), and
+JSON Web Algorithms (JWA) - collectively can be used to encrypt and/or
+sign content using a variety of algorithms. While the full set of
+permutations is extremely large, and might be daunting to some, it is
+expected that most applications will only use a small set of algorithms
+to meet their needs.
+
+
+Installation
+------------
+
+::
+
+    $ pip install python-jose[cryptography]
+
+
+Cryptographic Backends
+----------------------
+
+As of 3.3.0, python-jose implements three different cryptographic backends.
+The backend must be selected as an extra when installing python-jose.
+If you do not select a backend, the native-python backend will be installed.
+
+Unless otherwise noted, all backends support all operations.
+
+Due to complexities with setuptools, the native-python backend is always installed,
+even if you select a different backend on install.
+We recommend that you remove unnecessary dependencies in production.
+
+#. cryptography
+
+   * This backend uses `pyca/cryptography`_ for all cryptographic operations.
+     This is the recommended backend and is selected over all other backends if any others are present.
+   * Installation: ``pip install python-jose[cryptography]``
+   * Unused dependencies:
+
+     * ``rsa``
+     * ``ecdsa``
+     * ``pyasn1``
+
+#. pycryptodome
+
+   * This backend uses `pycryptodome`_ for all cryptographic operations.
+   * Installation: ``pip install python-jose[pycryptodome]``
+   * Unused dependencies:
+
+     * ``rsa``
+
+#. native-python
+
+   * This backend uses `python-rsa`_ and `python-ecdsa`_ for all cryptographic operations.
+     This backend is always installed but any other backend will take precedence if one is installed.
+   * Installation: ``pip install python-jose``
+
+   .. note::
+
+       The native-python backend cannot process certificates.
+
+Usage
+-----
+
+.. code-block:: python
+
+    >>> from jose import jwt
+    >>> token = jwt.encode({'key': 'value'}, 'secret', algorithm='HS256')
+    u'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJrZXkiOiJ2YWx1ZSJ9.FG-8UppwHaFp1LgRYQQeS6EDQF7_6-bMFegNucHjmWg'
+
+    >>> jwt.decode(token, 'secret', algorithms=['HS256'])
+    {u'key': u'value'}
+
+
+Thanks
+------
+
+This library was originally based heavily on the work of the folks over at PyJWT_.
+
+.. |pypi| image:: https://img.shields.io/pypi/v/python-jose?style=flat-square
+   :target: https://pypi.org/project/python-jose/
+   :alt: PyPI
+.. |Github Actions CI Status| image:: https://github.com/mpdavis/python-jose/workflows/main/badge.svg?branch=master
+   :target: https://github.com/mpdavis/python-jose/actions?workflow=main
+   :alt: Github Actions CI Status
+.. |Coverage Status| image:: http://codecov.io/github/mpdavis/python-jose/coverage.svg?branch=master
+   :target: http://codecov.io/github/mpdavis/python-jose?branch=master
+.. |Docs| image:: https://readthedocs.org/projects/python-jose/badge/
+   :target: https://python-jose.readthedocs.org/en/latest/
+.. _ReadTheDocs: https://python-jose.readthedocs.org/en/latest/
+.. _PyJWT: https://github.com/jpadilla/pyjwt
+.. _pyca/cryptography: http://cryptography.io/
+.. _pycryptodome: https://pycryptodome.readthedocs.io/en/latest/
+.. _pycrypto: https://www.dlitz.net/software/pycrypto/
+.. _python-ecdsa: https://github.com/warner/python-ecdsa
+.. _python-rsa: https://stuvel.eu/rsa
+.. |style| image:: https://img.shields.io/badge/code%20style-black-000000.svg
+   :target: https://github.com/psf/black
+   :alt: Code style: black
+
+
diff --git a/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/RECORD
new file mode 100644
index 0000000..5cd4fed
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/RECORD
@@ -0,0 +1,21 @@
+jose/__init__.py,sha256=0XQau8AXQwNwztdDWVr6l7PyWq9w0qN1R0PGcrsMIGM,322
+jose/constants.py,sha256=A0yHNjsby-YVOeKhcoN0rxoM8bai1JlVDvZx82UCZeE,2596
+jose/exceptions.py,sha256=K_ueFBsmTwQySE0CU09iMthOAdPaTQ_HvzRz9lYT1ls,791
+jose/jwe.py,sha256=jSBN3aT2D7xAQ3D-5cVf_9kZebchAI3qoaf-3yMLanY,21976
+jose/jwk.py,sha256=3A1dXXfhGIMQvT43EBAQgiShQZuqLpUZk_xWvW7c9cs,2024
+jose/jws.py,sha256=qgMDRIlyGbGfAGApQfuAL5Qr66Qqa8aYUC3qUO8qM_g,7820
+jose/jwt.py,sha256=7czQxPsfOavLpY6jJTetdPN_FQDcZmmkaZ2QtV3bVPw,17310
+jose/utils.py,sha256=_doSyRne-OygjSI3Iz1kWTSGnwVHHMA6_wYHOS1rhCw,3190
+jose/backends/__init__.py,sha256=yDExDpMlV6U4IBgk2Emov6cpQ2zQftFEh0J3yGaV2Lo,1091
+jose/backends/_asn1.py,sha256=etzWxBjkt0Et19_IQ92Pj61bAe0nCgPN7bTvSuz8W3s,2655
+jose/backends/base.py,sha256=0kuposKfixAR2W3enKuYdqEZpVG56ODOQDEdgq_pmvs,2224
+jose/backends/cryptography_backend.py,sha256=28-792EKVGjjq2nUoCWdfyPGkoXfWN5vHFO7uolCtog,22763
+jose/backends/ecdsa_backend.py,sha256=ORORepIpIS9D4s6Vtmhli5GZV9kj3CJj2_Mv0ARKGqE,5055
+jose/backends/native.py,sha256=9zyounmjG1ZgVJYkseMcDosJOBILLRyu_UbzhH7ZZ1o,2289
+jose/backends/rsa_backend.py,sha256=RKIC_bphhe52t2D_jEINO_ngj50ty9wXnv7cVO1EmdE,10942
+python_jose-3.3.0.dist-info/LICENSE,sha256=peYY7ubUlvd62K5w_qbt8UgVlVji0ih4fZB2yQCi-SY,1081
+python_jose-3.3.0.dist-info/METADATA,sha256=Sk_zCqxtDfFMG5lAL6EG7Br3KP0yhtw_IsJBwZaDliM,5403
+python_jose-3.3.0.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
+python_jose-3.3.0.dist-info/top_level.txt,sha256=WIdGzeaROX_xI9hGqyB3h4KKXKGKU2XmV1XphZWIrD8,19
+python_jose-3.3.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+python_jose-3.3.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/WHEEL
new file mode 100644
index 0000000..01b8fc7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/top_level.txt
new file mode 100644
index 0000000..3ac440a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_jose-3.3.0.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+jose
+jose/backends
diff --git a/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/LICENSE.txt b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/LICENSE.txt
new file mode 100644
index 0000000..7ff9d40
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/LICENSE.txt
@@ -0,0 +1,14 @@
+Copyright 2012, Andrew Dunham
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
diff --git a/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/METADATA b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/METADATA
new file mode 100644
index 0000000..307cdd4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/METADATA
@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: python-multipart
+Version: 0.0.5
+Summary: A streaming multipart parser for Python
+Home-page: http://github.com/andrew-d/python-multipart
+Author: Andrew Dunham
+License: Apache
+Platform: any
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+License-File: LICENSE.txt
+Requires-Dist: six >=1.4.0
+
diff --git a/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/RECORD b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/RECORD
new file mode 100644
index 0000000..f8417de
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/RECORD
@@ -0,0 +1,14 @@
+multipart/__init__.py,sha256=erf9OhZ96QtPqiiWgB41EfkJjMLpc08bhZ5NUWJlEq4,470
+multipart/_version.py,sha256=eB5tEg_BNHHsJgQexgmpZJr4c2VbfooQZMXAWuDHoIg,22
+multipart/decoders.py,sha256=j3LuR2D13mz2sBV2gpff22C7t-cyyo_3xcwSWO5NV8Y,6141
+multipart/exceptions.py,sha256=JlDRKldSb680_PLfchzImgGGrNVrN_GUeLvX_ff9WoA,1720
+multipart/multipart.py,sha256=UwBpY8hsX6c_MVbYQ7Vmw4_gngo4E-VKEzwXiy_wh0k,71891
+multipart/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+multipart/tests/compat.py,sha256=zsJ0Da14wJY2Ie84FBxL0BCtBXnjTJ0hdexn3Xnpmws,4357
+multipart/tests/test_multipart.py,sha256=DPb8FbKGc-lOOWqtpQtjCXqKpfaIVhy4wbJs3L6SMqc,38675
+python_multipart-0.0.5.dist-info/LICENSE.txt,sha256=doB-ZGQ8OKSxzyn9MWPBjcvUagrIaX2X2shl8eDaj8s,555
+python_multipart-0.0.5.dist-info/METADATA,sha256=VIhNB3KG9gMue5MaDboDP9-Sp9mvTkdHSc2l-hrMrVg,834
+python_multipart-0.0.5.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+python_multipart-0.0.5.dist-info/top_level.txt,sha256=9_bz8LGTeiaOOmsn6icdMVZyC-fsqz48NJxLt93RBto,10
+python_multipart-0.0.5.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+python_multipart-0.0.5.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/WHEEL
new file mode 100644
index 0000000..7e68873
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/top_level.txt
new file mode 100644
index 0000000..d0b324b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/python_multipart-0.0.5.dist-info/top_level.txt
@@ -0,0 +1 @@
+multipart
diff --git a/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/AUTHORS.rst b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/AUTHORS.rst
new file mode 100644
index 0000000..54cb3c9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/AUTHORS.rst
@@ -0,0 +1,14 @@
+Development Lead
+----------------
+
+- Ian Stapleton Cordasco <graffatcolmingov@gmail.com>
+
+Contributors
+------------
+
+- Thomas Weißschuh
+- Kostya Esmukov
+- Derek Higgins
+- Victor Stinner
+- Viktor Haag
+- Seth Michael Larson
diff --git a/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/LICENSE
new file mode 100644
index 0000000..72ce24c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/LICENSE
@@ -0,0 +1,13 @@
+Copyright 2014 Ian Cordasco, Rackspace
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/METADATA
new file mode 100644
index 0000000..2ddcde0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/METADATA
@@ -0,0 +1,230 @@
+Metadata-Version: 2.1
+Name: rfc3986
+Version: 1.5.0
+Summary: Validating URI References per RFC 3986
+Home-page: http://rfc3986.readthedocs.io
+Author: Ian Stapleton Cordasco
+Author-email: graffatcolmingov@gmail.com
+License: Apache 2.0
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Provides-Extra: idna2008
+Requires-Dist: idna ; extra == 'idna2008'
+
+rfc3986
+=======
+
+A Python implementation of `RFC 3986`_ including validation and authority 
+parsing.
+
+Installation
+------------
+
+Use pip to install ``rfc3986`` like so::
+
+    pip install rfc3986
+
+License
+-------
+
+`Apache License Version 2.0`_
+
+Example Usage
+-------------
+
+The following are the two most common use cases envisioned for ``rfc3986``.
+
+Replacing ``urlparse``
+``````````````````````
+
+To parse a URI and receive something very similar to the standard library's
+``urllib.parse.urlparse``
+
+.. code-block:: python
+
+    from rfc3986 import urlparse
+
+    ssh = urlparse('ssh://user@git.openstack.org:29418/openstack/glance.git')
+    print(ssh.scheme)  # => ssh
+    print(ssh.userinfo)  # => user
+    print(ssh.params)  # => None
+    print(ssh.port)  # => 29418
+
+To create a copy of it with new pieces you can use ``copy_with``:
+
+.. code-block:: python
+
+    new_ssh = ssh.copy_with(
+        scheme='https'
+        userinfo='',
+        port=443,
+        path='/openstack/glance'
+    )
+    print(new_ssh.scheme)  # => https
+    print(new_ssh.userinfo)  # => None
+    # etc.
+
+Strictly Parsing a URI and Applying Validation
+``````````````````````````````````````````````
+
+To parse a URI into a convenient named tuple, you can simply:
+
+.. code-block:: python
+
+    from rfc3986 import uri_reference
+
+    example = uri_reference('http://example.com')
+    email = uri_reference('mailto:user@domain.com')
+    ssh = uri_reference('ssh://user@git.openstack.org:29418/openstack/keystone.git')
+
+With a parsed URI you can access data about the components:
+
+.. code-block:: python
+
+    print(example.scheme)  # => http
+    print(email.path)  # => user@domain.com
+    print(ssh.userinfo)  # => user
+    print(ssh.host)  # => git.openstack.org
+    print(ssh.port)  # => 29418
+
+It can also parse URIs with unicode present:
+
+.. code-block:: python
+
+    uni = uri_reference(b'http://httpbin.org/get?utf8=\xe2\x98\x83')  # ☃
+    print(uni.query)  # utf8=%E2%98%83
+
+With a parsed URI you can also validate it:
+
+.. code-block:: python
+
+    if ssh.is_valid():
+        subprocess.call(['git', 'clone', ssh.unsplit()])
+
+You can also take a parsed URI and normalize it:
+
+.. code-block:: python
+
+    mangled = uri_reference('hTTp://exAMPLe.COM')
+    print(mangled.scheme)  # => hTTp
+    print(mangled.authority)  # => exAMPLe.COM
+
+    normal = mangled.normalize()
+    print(normal.scheme)  # => http
+    print(mangled.authority)  # => example.com
+
+But these two URIs are (functionally) equivalent:
+
+.. code-block:: python
+
+    if normal == mangled:
+        webbrowser.open(normal.unsplit())
+
+Your paths, queries, and fragments are safe with us though:
+
+.. code-block:: python
+
+    mangled = uri_reference('hTTp://exAMPLe.COM/Some/reallY/biZZare/pAth')
+    normal = mangled.normalize()
+    assert normal == 'hTTp://exAMPLe.COM/Some/reallY/biZZare/pAth'
+    assert normal == 'http://example.com/Some/reallY/biZZare/pAth'
+    assert normal != 'http://example.com/some/really/bizzare/path'
+
+If you do not actually need a real reference object and just want to normalize
+your URI:
+
+.. code-block:: python
+
+    from rfc3986 import normalize_uri
+
+    assert (normalize_uri('hTTp://exAMPLe.COM/Some/reallY/biZZare/pAth') ==
+            'http://example.com/Some/reallY/biZZare/pAth')
+
+You can also very simply validate a URI:
+
+.. code-block:: python
+
+    from rfc3986 import is_valid_uri
+
+    assert is_valid_uri('hTTp://exAMPLe.COM/Some/reallY/biZZare/pAth')
+
+Requiring Components
+~~~~~~~~~~~~~~~~~~~~
+
+You can validate that a particular string is a valid URI and require
+independent components:
+
+.. code-block:: python
+
+    from rfc3986 import is_valid_uri
+
+    assert is_valid_uri('http://localhost:8774/v2/resource',
+                        require_scheme=True,
+                        require_authority=True,
+                        require_path=True)
+
+    # Assert that a mailto URI is invalid if you require an authority
+    # component
+    assert is_valid_uri('mailto:user@example.com', require_authority=True) is False
+
+If you have an instance of a ``URIReference``, you can pass the same arguments
+to ``URIReference#is_valid``, e.g.,
+
+.. code-block:: python
+
+    from rfc3986 import uri_reference
+
+    http = uri_reference('http://localhost:8774/v2/resource')
+    assert uri.is_valid(require_scheme=True,
+                        require_authority=True,
+                        require_path=True)
+
+    # Assert that a mailto URI is invalid if you require an authority
+    # component
+    mailto = uri_reference('mailto:user@example.com')
+    assert uri.is_valid(require_authority=True) is False
+
+Alternatives
+------------
+
+- `rfc3987 <https://pypi.python.org/pypi/rfc3987/1.3.4>`_
+
+  This is a direct competitor to this library, with extra features,
+  licensed under the GPL.
+
+- `uritools <https://pypi.python.org/pypi/uritools/0.5.1>`_
+
+  This can parse URIs in the manner of RFC 3986 but provides no validation and
+  only recently added Python 3 support.
+
+- Standard library's `urlparse`/`urllib.parse`
+
+  The functions in these libraries can only split a URI (valid or not) and
+  provide no validation.
+
+Contributing
+------------
+
+This project follows and enforces the Python Software Foundation's `Code of
+Conduct <https://www.python.org/psf/codeofconduct/>`_.
+
+If you would like to contribute but do not have a bug or feature in mind, feel
+free to email Ian and find out how you can help.
+
+The git repository for this project is maintained at
+https://github.com/python-hyper/rfc3986
+
+.. _RFC 3986: http://tools.ietf.org/html/rfc3986
+.. _Apache License Version 2.0: https://www.apache.org/licenses/LICENSE-2.0
+
+
diff --git a/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/RECORD
new file mode 100644
index 0000000..814a066
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/RECORD
@@ -0,0 +1,20 @@
+rfc3986/__init__.py,sha256=Yc1nYWLNwBn1XUCt3lPMC6cPD3S82FKPPc4IpTaFjCE,1591
+rfc3986/_mixin.py,sha256=iFnLyRbd-QMQv9LlYwglAt-vNA4CxpBhnZMu-XyKP4w,13280
+rfc3986/abnf_regexp.py,sha256=hTIxwQQcngkTmmDn0T0m0_6dZZIiMovYEsITUrZIL3Q,9121
+rfc3986/api.py,sha256=UzjPnQ4_G0ludMVXEeq6CVYmFQ55rDpKvHakGZMxVe8,3887
+rfc3986/builder.py,sha256=vuI6u7B3UQbVrh47xDF7X5sducTxzkLQeuvW7vPavok,12757
+rfc3986/compat.py,sha256=51xDR7kfVhaM7GqTLmw-lQY4jv2mw2MbCNuBnG4PnbA,1644
+rfc3986/exceptions.py,sha256=dFYnm-TabVYpWUEPXqtGp8xfSg1wWYk09TaUjCetWYI,3847
+rfc3986/iri.py,sha256=BX1nFD0JyZnUfAHxDFqyz0hN8J-YfKxIhYJLyBZGAZo,5520
+rfc3986/misc.py,sha256=bye9xhySD_GshuL_MD0VTledl6jBw_ErG8kXtTNXzXQ,4163
+rfc3986/normalizers.py,sha256=f6oLvNUadxZDJDtx3JvqF_exGGD7PvLaibYQBUfh2NE,5294
+rfc3986/parseresult.py,sha256=NvbPpPzuuputHpJc4J2cjcNy6B7c6rscFqzSnksDWmc,14742
+rfc3986/uri.py,sha256=LYNAlr2ujVfCa6jcV8o1I1hOuviuuXsSRHpST2DyvAw,5225
+rfc3986/validators.py,sha256=qcvNnrpk2el-otJN-ZRGZ0PE4xaSEP97lKREXG_YtpM,13839
+rfc3986-1.5.0.dist-info/AUTHORS.rst,sha256=QjlDdMHiNeQv1lPqHeGQ4OtiEPCwFafJLu7t23AXDHo,223
+rfc3986-1.5.0.dist-info/LICENSE,sha256=wN3OM7-sSApmveQMWQ7eJkekyKcp3LDSzkbAFEc9Xdg,564
+rfc3986-1.5.0.dist-info/METADATA,sha256=qkuCB_ifgypthNS6-M-IOKli-F3YPR8xzOOXPHEu2Wo,6458
+rfc3986-1.5.0.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
+rfc3986-1.5.0.dist-info/top_level.txt,sha256=Z10Qesb0UV9AbxlTIV9AnOAwk-343WnE85K8xfN4OmA,8
+rfc3986-1.5.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+rfc3986-1.5.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/WHEEL
new file mode 100644
index 0000000..01b8fc7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/top_level.txt
new file mode 100644
index 0000000..af30258
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986-1.5.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+rfc3986
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/__init__.py b/myenv/lib/python3.9/site-packages/rfc3986/__init__.py
new file mode 100644
index 0000000..a052299
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/__init__.py
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+An implementation of semantics and validations described in RFC 3986.
+
+See http://rfc3986.readthedocs.io/ for detailed documentation.
+
+:copyright: (c) 2014 Rackspace
+:license: Apache v2.0, see LICENSE for details
+"""
+
+from .api import iri_reference
+from .api import IRIReference
+from .api import is_valid_uri
+from .api import normalize_uri
+from .api import uri_reference
+from .api import URIReference
+from .api import urlparse
+from .parseresult import ParseResult
+
+__title__ = "rfc3986"
+__author__ = "Ian Stapleton Cordasco"
+__author_email__ = "graffatcolmingov@gmail.com"
+__license__ = "Apache v2.0"
+__copyright__ = "Copyright 2014 Rackspace; 2016 Ian Stapleton Cordasco"
+__version__ = "1.5.0"
+
+__all__ = (
+    "ParseResult",
+    "URIReference",
+    "IRIReference",
+    "is_valid_uri",
+    "normalize_uri",
+    "uri_reference",
+    "iri_reference",
+    "urlparse",
+    "__title__",
+    "__author__",
+    "__author_email__",
+    "__license__",
+    "__copyright__",
+    "__version__",
+)
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/_mixin.py b/myenv/lib/python3.9/site-packages/rfc3986/_mixin.py
new file mode 100644
index 0000000..46e200e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/_mixin.py
@@ -0,0 +1,373 @@
+"""Module containing the implementation of the URIMixin class."""
+import warnings
+
+from . import exceptions as exc
+from . import misc
+from . import normalizers
+from . import validators
+
+
+class URIMixin(object):
+    """Mixin with all shared methods for URIs and IRIs."""
+
+    __hash__ = tuple.__hash__
+
+    def authority_info(self):
+        """Return a dictionary with the ``userinfo``, ``host``, and ``port``.
+
+        If the authority is not valid, it will raise a
+        :class:`~rfc3986.exceptions.InvalidAuthority` Exception.
+
+        :returns:
+            ``{'userinfo': 'username:password', 'host': 'www.example.com',
+            'port': '80'}``
+        :rtype: dict
+        :raises rfc3986.exceptions.InvalidAuthority:
+            If the authority is not ``None`` and can not be parsed.
+        """
+        if not self.authority:
+            return {"userinfo": None, "host": None, "port": None}
+
+        match = self._match_subauthority()
+
+        if match is None:
+            # In this case, we have an authority that was parsed from the URI
+            # Reference, but it cannot be further parsed by our
+            # misc.SUBAUTHORITY_MATCHER. In this case it must not be a valid
+            # authority.
+            raise exc.InvalidAuthority(self.authority.encode(self.encoding))
+
+        # We had a match, now let's ensure that it is actually a valid host
+        # address if it is IPv4
+        matches = match.groupdict()
+        host = matches.get("host")
+
+        if (
+            host
+            and misc.IPv4_MATCHER.match(host)
+            and not validators.valid_ipv4_host_address(host)
+        ):
+            # If we have a host, it appears to be IPv4 and it does not have
+            # valid bytes, it is an InvalidAuthority.
+            raise exc.InvalidAuthority(self.authority.encode(self.encoding))
+
+        return matches
+
+    def _match_subauthority(self):
+        return misc.SUBAUTHORITY_MATCHER.match(self.authority)
+
+    @property
+    def host(self):
+        """If present, a string representing the host."""
+        try:
+            authority = self.authority_info()
+        except exc.InvalidAuthority:
+            return None
+        return authority["host"]
+
+    @property
+    def port(self):
+        """If present, the port extracted from the authority."""
+        try:
+            authority = self.authority_info()
+        except exc.InvalidAuthority:
+            return None
+        return authority["port"]
+
+    @property
+    def userinfo(self):
+        """If present, the userinfo extracted from the authority."""
+        try:
+            authority = self.authority_info()
+        except exc.InvalidAuthority:
+            return None
+        return authority["userinfo"]
+
+    def is_absolute(self):
+        """Determine if this URI Reference is an absolute URI.
+
+        See http://tools.ietf.org/html/rfc3986#section-4.3 for explanation.
+
+        :returns: ``True`` if it is an absolute URI, ``False`` otherwise.
+        :rtype: bool
+        """
+        return bool(misc.ABSOLUTE_URI_MATCHER.match(self.unsplit()))
+
+    def is_valid(self, **kwargs):
+        """Determine if the URI is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the :class:`~rfc3986.validators.Validator` object instead.
+
+        :param bool require_scheme: Set to ``True`` if you wish to require the
+            presence of the scheme component.
+        :param bool require_authority: Set to ``True`` if you wish to require
+            the presence of the authority component.
+        :param bool require_path: Set to ``True`` if you wish to require the
+            presence of the path component.
+        :param bool require_query: Set to ``True`` if you wish to require the
+            presence of the query component.
+        :param bool require_fragment: Set to ``True`` if you wish to require
+            the presence of the fragment component.
+        :returns: ``True`` if the URI is valid. ``False`` otherwise.
+        :rtype: bool
+        """
+        warnings.warn(
+            "Please use rfc3986.validators.Validator instead. "
+            "This method will be eventually removed.",
+            DeprecationWarning,
+        )
+        validators = [
+            (self.scheme_is_valid, kwargs.get("require_scheme", False)),
+            (self.authority_is_valid, kwargs.get("require_authority", False)),
+            (self.path_is_valid, kwargs.get("require_path", False)),
+            (self.query_is_valid, kwargs.get("require_query", False)),
+            (self.fragment_is_valid, kwargs.get("require_fragment", False)),
+        ]
+        return all(v(r) for v, r in validators)
+
+    def authority_is_valid(self, require=False):
+        """Determine if the authority component is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the :class:`~rfc3986.validators.Validator` object instead.
+
+        :param bool require:
+            Set to ``True`` to require the presence of this component.
+        :returns:
+            ``True`` if the authority is valid. ``False`` otherwise.
+        :rtype:
+            bool
+        """
+        warnings.warn(
+            "Please use rfc3986.validators.Validator instead. "
+            "This method will be eventually removed.",
+            DeprecationWarning,
+        )
+        try:
+            self.authority_info()
+        except exc.InvalidAuthority:
+            return False
+
+        return validators.authority_is_valid(
+            self.authority,
+            host=self.host,
+            require=require,
+        )
+
+    def scheme_is_valid(self, require=False):
+        """Determine if the scheme component is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the :class:`~rfc3986.validators.Validator` object instead.
+
+        :param str require: Set to ``True`` to require the presence of this
+            component.
+        :returns: ``True`` if the scheme is valid. ``False`` otherwise.
+        :rtype: bool
+        """
+        warnings.warn(
+            "Please use rfc3986.validators.Validator instead. "
+            "This method will be eventually removed.",
+            DeprecationWarning,
+        )
+        return validators.scheme_is_valid(self.scheme, require)
+
+    def path_is_valid(self, require=False):
+        """Determine if the path component is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the :class:`~rfc3986.validators.Validator` object instead.
+
+        :param str require: Set to ``True`` to require the presence of this
+            component.
+        :returns: ``True`` if the path is valid. ``False`` otherwise.
+        :rtype: bool
+        """
+        warnings.warn(
+            "Please use rfc3986.validators.Validator instead. "
+            "This method will be eventually removed.",
+            DeprecationWarning,
+        )
+        return validators.path_is_valid(self.path, require)
+
+    def query_is_valid(self, require=False):
+        """Determine if the query component is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the :class:`~rfc3986.validators.Validator` object instead.
+
+        :param str require: Set to ``True`` to require the presence of this
+            component.
+        :returns: ``True`` if the query is valid. ``False`` otherwise.
+        :rtype: bool
+        """
+        warnings.warn(
+            "Please use rfc3986.validators.Validator instead. "
+            "This method will be eventually removed.",
+            DeprecationWarning,
+        )
+        return validators.query_is_valid(self.query, require)
+
+    def fragment_is_valid(self, require=False):
+        """Determine if the fragment component is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the Validator object instead.
+
+        :param str require: Set to ``True`` to require the presence of this
+            component.
+        :returns: ``True`` if the fragment is valid. ``False`` otherwise.
+        :rtype: bool
+        """
+        warnings.warn(
+            "Please use rfc3986.validators.Validator instead. "
+            "This method will be eventually removed.",
+            DeprecationWarning,
+        )
+        return validators.fragment_is_valid(self.fragment, require)
+
+    def normalized_equality(self, other_ref):
+        """Compare this URIReference to another URIReference.
+
+        :param URIReference other_ref: (required), The reference with which
+            we're comparing.
+        :returns: ``True`` if the references are equal, ``False`` otherwise.
+        :rtype: bool
+        """
+        return tuple(self.normalize()) == tuple(other_ref.normalize())
+
+    def resolve_with(self, base_uri, strict=False):
+        """Use an absolute URI Reference to resolve this relative reference.
+
+        Assuming this is a relative reference that you would like to resolve,
+        use the provided base URI to resolve it.
+
+        See http://tools.ietf.org/html/rfc3986#section-5 for more information.
+
+        :param base_uri: Either a string or URIReference. It must be an
+            absolute URI or it will raise an exception.
+        :returns: A new URIReference which is the result of resolving this
+            reference using ``base_uri``.
+        :rtype: :class:`URIReference`
+        :raises rfc3986.exceptions.ResolutionError:
+            If the ``base_uri`` is not an absolute URI.
+        """
+        if not isinstance(base_uri, URIMixin):
+            base_uri = type(self).from_string(base_uri)
+
+        if not base_uri.is_absolute():
+            raise exc.ResolutionError(base_uri)
+
+        # This is optional per
+        # http://tools.ietf.org/html/rfc3986#section-5.2.1
+        base_uri = base_uri.normalize()
+
+        # The reference we're resolving
+        resolving = self
+
+        if not strict and resolving.scheme == base_uri.scheme:
+            resolving = resolving.copy_with(scheme=None)
+
+        # http://tools.ietf.org/html/rfc3986#page-32
+        if resolving.scheme is not None:
+            target = resolving.copy_with(
+                path=normalizers.normalize_path(resolving.path)
+            )
+        else:
+            if resolving.authority is not None:
+                target = resolving.copy_with(
+                    scheme=base_uri.scheme,
+                    path=normalizers.normalize_path(resolving.path),
+                )
+            else:
+                if resolving.path is None:
+                    if resolving.query is not None:
+                        query = resolving.query
+                    else:
+                        query = base_uri.query
+                    target = resolving.copy_with(
+                        scheme=base_uri.scheme,
+                        authority=base_uri.authority,
+                        path=base_uri.path,
+                        query=query,
+                    )
+                else:
+                    if resolving.path.startswith("/"):
+                        path = normalizers.normalize_path(resolving.path)
+                    else:
+                        path = normalizers.normalize_path(
+                            misc.merge_paths(base_uri, resolving.path)
+                        )
+                    target = resolving.copy_with(
+                        scheme=base_uri.scheme,
+                        authority=base_uri.authority,
+                        path=path,
+                        query=resolving.query,
+                    )
+        return target
+
+    def unsplit(self):
+        """Create a URI string from the components.
+
+        :returns: The URI Reference reconstituted as a string.
+        :rtype: str
+        """
+        # See http://tools.ietf.org/html/rfc3986#section-5.3
+        result_list = []
+        if self.scheme:
+            result_list.extend([self.scheme, ":"])
+        if self.authority:
+            result_list.extend(["//", self.authority])
+        if self.path:
+            result_list.append(self.path)
+        if self.query is not None:
+            result_list.extend(["?", self.query])
+        if self.fragment is not None:
+            result_list.extend(["#", self.fragment])
+        return "".join(result_list)
+
+    def copy_with(
+        self,
+        scheme=misc.UseExisting,
+        authority=misc.UseExisting,
+        path=misc.UseExisting,
+        query=misc.UseExisting,
+        fragment=misc.UseExisting,
+    ):
+        """Create a copy of this reference with the new components.
+
+        :param str scheme:
+            (optional) The scheme to use for the new reference.
+        :param str authority:
+            (optional) The authority to use for the new reference.
+        :param str path:
+            (optional) The path to use for the new reference.
+        :param str query:
+            (optional) The query to use for the new reference.
+        :param str fragment:
+            (optional) The fragment to use for the new reference.
+        :returns:
+            New URIReference with provided components.
+        :rtype:
+            URIReference
+        """
+        attributes = {
+            "scheme": scheme,
+            "authority": authority,
+            "path": path,
+            "query": query,
+            "fragment": fragment,
+        }
+        for key, value in list(attributes.items()):
+            if value is misc.UseExisting:
+                del attributes[key]
+        uri = self._replace(**attributes)
+        uri.encoding = self.encoding
+        return uri
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/abnf_regexp.py b/myenv/lib/python3.9/site-packages/rfc3986/abnf_regexp.py
new file mode 100644
index 0000000..a2e7ee7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/abnf_regexp.py
@@ -0,0 +1,282 @@
+# -*- coding: utf-8 -*-
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module for the regular expressions crafted from ABNF."""
+
+import sys
+
+# https://tools.ietf.org/html/rfc3986#page-13
+GEN_DELIMS = GENERIC_DELIMITERS = ":/?#[]@"
+GENERIC_DELIMITERS_SET = set(GENERIC_DELIMITERS)
+# https://tools.ietf.org/html/rfc3986#page-13
+SUB_DELIMS = SUB_DELIMITERS = "!$&'()*+,;="
+SUB_DELIMITERS_SET = set(SUB_DELIMITERS)
+# Escape the '*' for use in regular expressions
+SUB_DELIMITERS_RE = r"!$&'()\*+,;="
+RESERVED_CHARS_SET = GENERIC_DELIMITERS_SET.union(SUB_DELIMITERS_SET)
+ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+DIGIT = "0123456789"
+# https://tools.ietf.org/html/rfc3986#section-2.3
+UNRESERVED = UNRESERVED_CHARS = ALPHA + DIGIT + r"._!-~"
+UNRESERVED_CHARS_SET = set(UNRESERVED_CHARS)
+NON_PCT_ENCODED_SET = RESERVED_CHARS_SET.union(UNRESERVED_CHARS_SET)
+# We need to escape the '-' in this case:
+UNRESERVED_RE = r"A-Za-z0-9._~\-"
+
+# Percent encoded character values
+PERCENT_ENCODED = PCT_ENCODED = "%[A-Fa-f0-9]{2}"
+PCHAR = "([" + UNRESERVED_RE + SUB_DELIMITERS_RE + ":@]|%s)" % PCT_ENCODED
+
+# NOTE(sigmavirus24): We're going to use more strict regular expressions
+# than appear in Appendix B for scheme. This will prevent over-eager
+# consuming of items that aren't schemes.
+SCHEME_RE = "[a-zA-Z][a-zA-Z0-9+.-]*"
+_AUTHORITY_RE = "[^\\\\/?#]*"
+_PATH_RE = "[^?#]*"
+_QUERY_RE = "[^#]*"
+_FRAGMENT_RE = ".*"
+
+# Extracted from http://tools.ietf.org/html/rfc3986#appendix-B
+COMPONENT_PATTERN_DICT = {
+    "scheme": SCHEME_RE,
+    "authority": _AUTHORITY_RE,
+    "path": _PATH_RE,
+    "query": _QUERY_RE,
+    "fragment": _FRAGMENT_RE,
+}
+
+# See http://tools.ietf.org/html/rfc3986#appendix-B
+# In this case, we name each of the important matches so we can use
+# SRE_Match#groupdict to parse the values out if we so choose. This is also
+# modified to ignore other matches that are not important to the parsing of
+# the reference so we can also simply use SRE_Match#groups.
+URL_PARSING_RE = (
+    r"(?:(?P<scheme>{scheme}):)?(?://(?P<authority>{authority}))?"
+    r"(?P<path>{path})(?:\?(?P<query>{query}))?"
+    r"(?:#(?P<fragment>{fragment}))?"
+).format(**COMPONENT_PATTERN_DICT)
+
+
+# #########################
+# Authority Matcher Section
+# #########################
+
+# Host patterns, see: http://tools.ietf.org/html/rfc3986#section-3.2.2
+# The pattern for a regular name, e.g.,  www.google.com, api.github.com
+REGULAR_NAME_RE = REG_NAME = "((?:{0}|[{1}])*)".format(
+    "%[0-9A-Fa-f]{2}", SUB_DELIMITERS_RE + UNRESERVED_RE
+)
+# The pattern for an IPv4 address, e.g., 192.168.255.255, 127.0.0.1,
+IPv4_RE = r"([0-9]{1,3}\.){3}[0-9]{1,3}"
+# Hexadecimal characters used in each piece of an IPv6 address
+HEXDIG_RE = "[0-9A-Fa-f]{1,4}"
+# Least-significant 32 bits of an IPv6 address
+LS32_RE = "({hex}:{hex}|{ipv4})".format(hex=HEXDIG_RE, ipv4=IPv4_RE)
+# Substitutions into the following patterns for IPv6 patterns defined
+# http://tools.ietf.org/html/rfc3986#page-20
+_subs = {"hex": HEXDIG_RE, "ls32": LS32_RE}
+
+# Below: h16 = hexdig, see: https://tools.ietf.org/html/rfc5234 for details
+# about ABNF (Augmented Backus-Naur Form) use in the comments
+variations = [
+    #                            6( h16 ":" ) ls32
+    "(%(hex)s:){6}%(ls32)s" % _subs,
+    #                       "::" 5( h16 ":" ) ls32
+    "::(%(hex)s:){5}%(ls32)s" % _subs,
+    # [               h16 ] "::" 4( h16 ":" ) ls32
+    "(%(hex)s)?::(%(hex)s:){4}%(ls32)s" % _subs,
+    # [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
+    "((%(hex)s:)?%(hex)s)?::(%(hex)s:){3}%(ls32)s" % _subs,
+    # [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
+    "((%(hex)s:){0,2}%(hex)s)?::(%(hex)s:){2}%(ls32)s" % _subs,
+    # [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32
+    "((%(hex)s:){0,3}%(hex)s)?::%(hex)s:%(ls32)s" % _subs,
+    # [ *4( h16 ":" ) h16 ] "::"              ls32
+    "((%(hex)s:){0,4}%(hex)s)?::%(ls32)s" % _subs,
+    # [ *5( h16 ":" ) h16 ] "::"              h16
+    "((%(hex)s:){0,5}%(hex)s)?::%(hex)s" % _subs,
+    # [ *6( h16 ":" ) h16 ] "::"
+    "((%(hex)s:){0,6}%(hex)s)?::" % _subs,
+]
+
+IPv6_RE = "(({0})|({1})|({2})|({3})|({4})|({5})|({6})|({7})|({8}))".format(
+    *variations
+)
+
+IPv_FUTURE_RE = r"v[0-9A-Fa-f]+\.[%s]+" % (
+    UNRESERVED_RE + SUB_DELIMITERS_RE + ":"
+)
+
+# RFC 6874 Zone ID ABNF
+ZONE_ID = "(?:[" + UNRESERVED_RE + "]|" + PCT_ENCODED + ")+"
+
+IPv6_ADDRZ_RFC4007_RE = IPv6_RE + "(?:(?:%25|%)" + ZONE_ID + ")?"
+IPv6_ADDRZ_RE = IPv6_RE + "(?:%25" + ZONE_ID + ")?"
+
+IP_LITERAL_RE = r"\[({0}|{1})\]".format(
+    IPv6_ADDRZ_RFC4007_RE,
+    IPv_FUTURE_RE,
+)
+
+# Pattern for matching the host piece of the authority
+HOST_RE = HOST_PATTERN = "({0}|{1}|{2})".format(
+    REG_NAME,
+    IPv4_RE,
+    IP_LITERAL_RE,
+)
+USERINFO_RE = (
+    "^([" + UNRESERVED_RE + SUB_DELIMITERS_RE + ":]|%s)+" % (PCT_ENCODED)
+)
+PORT_RE = "[0-9]{1,5}"
+
+# ####################
+# Path Matcher Section
+# ####################
+
+# See http://tools.ietf.org/html/rfc3986#section-3.3 for more information
+# about the path patterns defined below.
+segments = {
+    "segment": PCHAR + "*",
+    # Non-zero length segment
+    "segment-nz": PCHAR + "+",
+    # Non-zero length segment without ":"
+    "segment-nz-nc": PCHAR.replace(":", "") + "+",
+}
+
+# Path types taken from Section 3.3 (linked above)
+PATH_EMPTY = "^$"
+PATH_ROOTLESS = "%(segment-nz)s(/%(segment)s)*" % segments
+PATH_NOSCHEME = "%(segment-nz-nc)s(/%(segment)s)*" % segments
+PATH_ABSOLUTE = "/(%s)?" % PATH_ROOTLESS
+PATH_ABEMPTY = "(/%(segment)s)*" % segments
+PATH_RE = "^(%s|%s|%s|%s|%s)$" % (
+    PATH_ABEMPTY,
+    PATH_ABSOLUTE,
+    PATH_NOSCHEME,
+    PATH_ROOTLESS,
+    PATH_EMPTY,
+)
+
+FRAGMENT_RE = QUERY_RE = (
+    "^([/?:@" + UNRESERVED_RE + SUB_DELIMITERS_RE + "]|%s)*$" % PCT_ENCODED
+)
+
+# ##########################
+# Relative reference matcher
+# ##########################
+
+# See http://tools.ietf.org/html/rfc3986#section-4.2 for details
+RELATIVE_PART_RE = "(//%s%s|%s|%s|%s)" % (
+    COMPONENT_PATTERN_DICT["authority"],
+    PATH_ABEMPTY,
+    PATH_ABSOLUTE,
+    PATH_NOSCHEME,
+    PATH_EMPTY,
+)
+
+# See http://tools.ietf.org/html/rfc3986#section-3 for definition
+HIER_PART_RE = "(//%s%s|%s|%s|%s)" % (
+    COMPONENT_PATTERN_DICT["authority"],
+    PATH_ABEMPTY,
+    PATH_ABSOLUTE,
+    PATH_ROOTLESS,
+    PATH_EMPTY,
+)
+
+# ###############
+# IRIs / RFC 3987
+# ###############
+
+# Only wide-unicode gets the high-ranges of UCSCHAR
+if sys.maxunicode > 0xFFFF:  # pragma: no cover
+    IPRIVATE = u"\uE000-\uF8FF\U000F0000-\U000FFFFD\U00100000-\U0010FFFD"
+    UCSCHAR_RE = (
+        u"\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF"
+        u"\U00010000-\U0001FFFD\U00020000-\U0002FFFD"
+        u"\U00030000-\U0003FFFD\U00040000-\U0004FFFD"
+        u"\U00050000-\U0005FFFD\U00060000-\U0006FFFD"
+        u"\U00070000-\U0007FFFD\U00080000-\U0008FFFD"
+        u"\U00090000-\U0009FFFD\U000A0000-\U000AFFFD"
+        u"\U000B0000-\U000BFFFD\U000C0000-\U000CFFFD"
+        u"\U000D0000-\U000DFFFD\U000E1000-\U000EFFFD"
+    )
+else:  # pragma: no cover
+    IPRIVATE = u"\uE000-\uF8FF"
+    UCSCHAR_RE = u"\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF"
+
+IUNRESERVED_RE = u"A-Za-z0-9\\._~\\-" + UCSCHAR_RE
+IPCHAR = u"([" + IUNRESERVED_RE + SUB_DELIMITERS_RE + u":@]|%s)" % PCT_ENCODED
+
+isegments = {
+    "isegment": IPCHAR + u"*",
+    # Non-zero length segment
+    "isegment-nz": IPCHAR + u"+",
+    # Non-zero length segment without ":"
+    "isegment-nz-nc": IPCHAR.replace(":", "") + u"+",
+}
+
+IPATH_ROOTLESS = u"%(isegment-nz)s(/%(isegment)s)*" % isegments
+IPATH_NOSCHEME = u"%(isegment-nz-nc)s(/%(isegment)s)*" % isegments
+IPATH_ABSOLUTE = u"/(?:%s)?" % IPATH_ROOTLESS
+IPATH_ABEMPTY = u"(?:/%(isegment)s)*" % isegments
+IPATH_RE = u"^(?:%s|%s|%s|%s|%s)$" % (
+    IPATH_ABEMPTY,
+    IPATH_ABSOLUTE,
+    IPATH_NOSCHEME,
+    IPATH_ROOTLESS,
+    PATH_EMPTY,
+)
+
+IREGULAR_NAME_RE = IREG_NAME = u"(?:{0}|[{1}])*".format(
+    u"%[0-9A-Fa-f]{2}", SUB_DELIMITERS_RE + IUNRESERVED_RE
+)
+
+IHOST_RE = IHOST_PATTERN = u"({0}|{1}|{2})".format(
+    IREG_NAME,
+    IPv4_RE,
+    IP_LITERAL_RE,
+)
+
+IUSERINFO_RE = (
+    u"^(?:[" + IUNRESERVED_RE + SUB_DELIMITERS_RE + u":]|%s)+" % (PCT_ENCODED)
+)
+
+IFRAGMENT_RE = (
+    u"^(?:[/?:@"
+    + IUNRESERVED_RE
+    + SUB_DELIMITERS_RE
+    + u"]|%s)*$" % PCT_ENCODED
+)
+IQUERY_RE = (
+    u"^(?:[/?:@"
+    + IUNRESERVED_RE
+    + SUB_DELIMITERS_RE
+    + IPRIVATE
+    + u"]|%s)*$" % PCT_ENCODED
+)
+
+IRELATIVE_PART_RE = u"(//%s%s|%s|%s|%s)" % (
+    COMPONENT_PATTERN_DICT["authority"],
+    IPATH_ABEMPTY,
+    IPATH_ABSOLUTE,
+    IPATH_NOSCHEME,
+    PATH_EMPTY,
+)
+
+IHIER_PART_RE = u"(//%s%s|%s|%s|%s)" % (
+    COMPONENT_PATTERN_DICT["authority"],
+    IPATH_ABEMPTY,
+    IPATH_ABSOLUTE,
+    IPATH_ROOTLESS,
+    PATH_EMPTY,
+)
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/api.py b/myenv/lib/python3.9/site-packages/rfc3986/api.py
new file mode 100644
index 0000000..1e098b3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/api.py
@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Module containing the simple and functional API for rfc3986.
+
+This module defines functions and provides access to the public attributes
+and classes of rfc3986.
+"""
+
+from .iri import IRIReference
+from .parseresult import ParseResult
+from .uri import URIReference
+
+
+def uri_reference(uri, encoding="utf-8"):
+    """Parse a URI string into a URIReference.
+
+    This is a convenience function. You could achieve the same end by using
+    ``URIReference.from_string(uri)``.
+
+    :param str uri: The URI which needs to be parsed into a reference.
+    :param str encoding: The encoding of the string provided
+    :returns: A parsed URI
+    :rtype: :class:`URIReference`
+    """
+    return URIReference.from_string(uri, encoding)
+
+
+def iri_reference(iri, encoding="utf-8"):
+    """Parse a IRI string into an IRIReference.
+
+    This is a convenience function. You could achieve the same end by using
+    ``IRIReference.from_string(iri)``.
+
+    :param str iri: The IRI which needs to be parsed into a reference.
+    :param str encoding: The encoding of the string provided
+    :returns: A parsed IRI
+    :rtype: :class:`IRIReference`
+    """
+    return IRIReference.from_string(iri, encoding)
+
+
+def is_valid_uri(uri, encoding="utf-8", **kwargs):
+    """Determine if the URI given is valid.
+
+    This is a convenience function. You could use either
+    ``uri_reference(uri).is_valid()`` or
+    ``URIReference.from_string(uri).is_valid()`` to achieve the same result.
+
+    :param str uri: The URI to be validated.
+    :param str encoding: The encoding of the string provided
+    :param bool require_scheme: Set to ``True`` if you wish to require the
+        presence of the scheme component.
+    :param bool require_authority: Set to ``True`` if you wish to require the
+        presence of the authority component.
+    :param bool require_path: Set to ``True`` if you wish to require the
+        presence of the path component.
+    :param bool require_query: Set to ``True`` if you wish to require the
+        presence of the query component.
+    :param bool require_fragment: Set to ``True`` if you wish to require the
+        presence of the fragment component.
+    :returns: ``True`` if the URI is valid, ``False`` otherwise.
+    :rtype: bool
+    """
+    return URIReference.from_string(uri, encoding).is_valid(**kwargs)
+
+
+def normalize_uri(uri, encoding="utf-8"):
+    """Normalize the given URI.
+
+    This is a convenience function. You could use either
+    ``uri_reference(uri).normalize().unsplit()`` or
+    ``URIReference.from_string(uri).normalize().unsplit()`` instead.
+
+    :param str uri: The URI to be normalized.
+    :param str encoding: The encoding of the string provided
+    :returns: The normalized URI.
+    :rtype: str
+    """
+    normalized_reference = URIReference.from_string(uri, encoding).normalize()
+    return normalized_reference.unsplit()
+
+
+def urlparse(uri, encoding="utf-8"):
+    """Parse a given URI and return a ParseResult.
+
+    This is a partial replacement of the standard library's urlparse function.
+
+    :param str uri: The URI to be parsed.
+    :param str encoding: The encoding of the string provided.
+    :returns: A parsed URI
+    :rtype: :class:`~rfc3986.parseresult.ParseResult`
+    """
+    return ParseResult.from_string(uri, encoding, strict=False)
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/builder.py b/myenv/lib/python3.9/site-packages/rfc3986/builder.py
new file mode 100644
index 0000000..8fc178c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/builder.py
@@ -0,0 +1,389 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2017 Ian Stapleton Cordasco
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module containing the logic for the URIBuilder object."""
+from . import compat
+from . import normalizers
+from . import uri
+from . import uri_reference
+
+
+class URIBuilder(object):
+    """Object to aid in building up a URI Reference from parts.
+
+    .. note::
+
+        This object should be instantiated by the user, but it's recommended
+        that it is not provided with arguments. Instead, use the available
+        method to populate the fields.
+
+    """
+
+    def __init__(
+        self,
+        scheme=None,
+        userinfo=None,
+        host=None,
+        port=None,
+        path=None,
+        query=None,
+        fragment=None,
+    ):
+        """Initialize our URI builder.
+
+        :param str scheme:
+            (optional)
+        :param str userinfo:
+            (optional)
+        :param str host:
+            (optional)
+        :param int port:
+            (optional)
+        :param str path:
+            (optional)
+        :param str query:
+            (optional)
+        :param str fragment:
+            (optional)
+        """
+        self.scheme = scheme
+        self.userinfo = userinfo
+        self.host = host
+        self.port = port
+        self.path = path
+        self.query = query
+        self.fragment = fragment
+
+    def __repr__(self):
+        """Provide a convenient view of our builder object."""
+        formatstr = (
+            "URIBuilder(scheme={b.scheme}, userinfo={b.userinfo}, "
+            "host={b.host}, port={b.port}, path={b.path}, "
+            "query={b.query}, fragment={b.fragment})"
+        )
+        return formatstr.format(b=self)
+
+    @classmethod
+    def from_uri(cls, reference):
+        """Initialize the URI builder from another URI.
+
+        Takes the given URI reference and creates a new URI builder instance
+        populated with the values from the reference. If given a string it will
+        try to convert it to a reference before constructing the builder.
+        """
+        if not isinstance(reference, uri.URIReference):
+            reference = uri_reference(reference)
+        return cls(
+            scheme=reference.scheme,
+            userinfo=reference.userinfo,
+            host=reference.host,
+            port=reference.port,
+            path=reference.path,
+            query=reference.query,
+            fragment=reference.fragment,
+        )
+
+    def add_scheme(self, scheme):
+        """Add a scheme to our builder object.
+
+        After normalizing, this will generate a new URIBuilder instance with
+        the specified scheme and all other attributes the same.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_scheme('HTTPS')
+            URIBuilder(scheme='https', userinfo=None, host=None, port=None,
+                    path=None, query=None, fragment=None)
+
+        """
+        scheme = normalizers.normalize_scheme(scheme)
+        return URIBuilder(
+            scheme=scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port=self.port,
+            path=self.path,
+            query=self.query,
+            fragment=self.fragment,
+        )
+
+    def add_credentials(self, username, password):
+        """Add credentials as the userinfo portion of the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_credentials('root', 's3crete')
+            URIBuilder(scheme=None, userinfo='root:s3crete', host=None,
+                    port=None, path=None, query=None, fragment=None)
+
+            >>> URIBuilder().add_credentials('root', None)
+            URIBuilder(scheme=None, userinfo='root', host=None,
+                    port=None, path=None, query=None, fragment=None)
+        """
+        if username is None:
+            raise ValueError("Username cannot be None")
+        userinfo = normalizers.normalize_username(username)
+
+        if password is not None:
+            userinfo = "{}:{}".format(
+                userinfo,
+                normalizers.normalize_password(password),
+            )
+
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=userinfo,
+            host=self.host,
+            port=self.port,
+            path=self.path,
+            query=self.query,
+            fragment=self.fragment,
+        )
+
+    def add_host(self, host):
+        """Add hostname to the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_host('google.com')
+            URIBuilder(scheme=None, userinfo=None, host='google.com',
+                    port=None, path=None, query=None, fragment=None)
+
+        """
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=normalizers.normalize_host(host),
+            port=self.port,
+            path=self.path,
+            query=self.query,
+            fragment=self.fragment,
+        )
+
+    def add_port(self, port):
+        """Add port to the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_port(80)
+            URIBuilder(scheme=None, userinfo=None, host=None, port='80',
+                    path=None, query=None, fragment=None)
+
+            >>> URIBuilder().add_port(443)
+            URIBuilder(scheme=None, userinfo=None, host=None, port='443',
+                    path=None, query=None, fragment=None)
+
+        """
+        port_int = int(port)
+        if port_int < 0:
+            raise ValueError(
+                "ports are not allowed to be negative. You provided {}".format(
+                    port_int,
+                )
+            )
+        if port_int > 65535:
+            raise ValueError(
+                "ports are not allowed to be larger than 65535. "
+                "You provided {}".format(
+                    port_int,
+                )
+            )
+
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port="{}".format(port_int),
+            path=self.path,
+            query=self.query,
+            fragment=self.fragment,
+        )
+
+    def add_path(self, path):
+        """Add a path to the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_path('sigmavirus24/rfc3985')
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path='/sigmavirus24/rfc3986', query=None, fragment=None)
+
+            >>> URIBuilder().add_path('/checkout.php')
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path='/checkout.php', query=None, fragment=None)
+
+        """
+        if not path.startswith("/"):
+            path = "/{}".format(path)
+
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port=self.port,
+            path=normalizers.normalize_path(path),
+            query=self.query,
+            fragment=self.fragment,
+        )
+
+    def extend_path(self, path):
+        """Extend the existing path value with the provided value.
+
+        .. versionadded:: 1.5.0
+
+        .. code-block:: python
+
+            >>> URIBuilder(path="/users").extend_path("/sigmavirus24")
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path='/users/sigmavirus24', query=None, fragment=None)
+
+            >>> URIBuilder(path="/users/").extend_path("/sigmavirus24")
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path='/users/sigmavirus24', query=None, fragment=None)
+
+            >>> URIBuilder(path="/users/").extend_path("sigmavirus24")
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path='/users/sigmavirus24', query=None, fragment=None)
+
+            >>> URIBuilder(path="/users").extend_path("sigmavirus24")
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path='/users/sigmavirus24', query=None, fragment=None)
+
+        """
+        existing_path = self.path or ""
+        path = "{}/{}".format(existing_path.rstrip("/"), path.lstrip("/"))
+
+        return self.add_path(path)
+
+    def add_query_from(self, query_items):
+        """Generate and add a query a dictionary or list of tuples.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_query_from({'a': 'b c'})
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path=None, query='a=b+c', fragment=None)
+
+            >>> URIBuilder().add_query_from([('a', 'b c')])
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path=None, query='a=b+c', fragment=None)
+
+        """
+        query = normalizers.normalize_query(compat.urlencode(query_items))
+
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port=self.port,
+            path=self.path,
+            query=query,
+            fragment=self.fragment,
+        )
+
+    def extend_query_with(self, query_items):
+        """Extend the existing query string with the new query items.
+
+        .. versionadded:: 1.5.0
+
+        .. code-block:: python
+
+            >>> URIBuilder(query='a=b+c').extend_query_with({'a': 'b c'})
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path=None, query='a=b+c&a=b+c', fragment=None)
+
+            >>> URIBuilder(query='a=b+c').extend_query_with([('a', 'b c')])
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path=None, query='a=b+c&a=b+c', fragment=None)
+        """
+        original_query_items = compat.parse_qsl(self.query or "")
+        if not isinstance(query_items, list):
+            query_items = list(query_items.items())
+
+        return self.add_query_from(original_query_items + query_items)
+
+    def add_query(self, query):
+        """Add a pre-formated query string to the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_query('a=b&c=d')
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path=None, query='a=b&c=d', fragment=None)
+
+        """
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port=self.port,
+            path=self.path,
+            query=normalizers.normalize_query(query),
+            fragment=self.fragment,
+        )
+
+    def add_fragment(self, fragment):
+        """Add a fragment to the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_fragment('section-2.6.1')
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path=None, query=None, fragment='section-2.6.1')
+
+        """
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port=self.port,
+            path=self.path,
+            query=self.query,
+            fragment=normalizers.normalize_fragment(fragment),
+        )
+
+    def finalize(self):
+        """Create a URIReference from our builder.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_scheme('https').add_host('github.com'
+            ...     ).add_path('sigmavirus24/rfc3986').finalize().unsplit()
+            'https://github.com/sigmavirus24/rfc3986'
+
+            >>> URIBuilder().add_scheme('https').add_host('github.com'
+            ...     ).add_path('sigmavirus24/rfc3986').add_credentials(
+            ...     'sigmavirus24', 'not-re@l').finalize().unsplit()
+            'https://sigmavirus24:not-re%40l@github.com/sigmavirus24/rfc3986'
+
+        """
+        return uri.URIReference(
+            self.scheme,
+            normalizers.normalize_authority(
+                (self.userinfo, self.host, self.port)
+            ),
+            self.path,
+            self.query,
+            self.fragment,
+        )
+
+    def geturl(self):
+        """Generate the URL from this builder.
+
+        .. versionadded:: 1.5.0
+
+        This is an alternative to calling :meth:`finalize` and keeping the
+        :class:`rfc3986.uri.URIReference` around.
+        """
+        return self.finalize().unsplit()
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/compat.py b/myenv/lib/python3.9/site-packages/rfc3986/compat.py
new file mode 100644
index 0000000..83e5c78
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/compat.py
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Compatibility module for Python 2 and 3 support."""
+import sys
+
+try:
+    from urllib.parse import quote as urlquote
+except ImportError:  # Python 2.x
+    from urllib import quote as urlquote
+
+try:
+    from urllib.parse import parse_qsl
+except ImportError:  # Python 2.x
+    from urlparse import parse_qsl
+
+try:
+    from urllib.parse import urlencode
+except ImportError:  # Python 2.x
+    from urllib import urlencode
+
+__all__ = (
+    "to_bytes",
+    "to_str",
+    "urlquote",
+    "urlencode",
+    "parse_qsl",
+)
+
+PY3 = (3, 0) <= sys.version_info < (4, 0)
+PY2 = (2, 6) <= sys.version_info < (2, 8)
+
+
+if PY3:
+    unicode = str  # Python 3.x
+
+
+def to_str(b, encoding="utf-8"):
+    """Ensure that b is text in the specified encoding."""
+    if hasattr(b, "decode") and not isinstance(b, unicode):
+        b = b.decode(encoding)
+    return b
+
+
+def to_bytes(s, encoding="utf-8"):
+    """Ensure that s is converted to bytes from the encoding."""
+    if hasattr(s, "encode") and not isinstance(s, bytes):
+        s = s.encode(encoding)
+    return s
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/exceptions.py b/myenv/lib/python3.9/site-packages/rfc3986/exceptions.py
new file mode 100644
index 0000000..b117bc9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/exceptions.py
@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+"""Exceptions module for rfc3986."""
+
+from . import compat
+
+
+class RFC3986Exception(Exception):
+    """Base class for all rfc3986 exception classes."""
+
+    pass
+
+
+class InvalidAuthority(RFC3986Exception):
+    """Exception when the authority string is invalid."""
+
+    def __init__(self, authority):
+        """Initialize the exception with the invalid authority."""
+        super(InvalidAuthority, self).__init__(
+            u"The authority ({0}) is not valid.".format(
+                compat.to_str(authority)
+            )
+        )
+
+
+class InvalidPort(RFC3986Exception):
+    """Exception when the port is invalid."""
+
+    def __init__(self, port):
+        """Initialize the exception with the invalid port."""
+        super(InvalidPort, self).__init__(
+            'The port ("{0}") is not valid.'.format(port)
+        )
+
+
+class ResolutionError(RFC3986Exception):
+    """Exception to indicate a failure to resolve a URI."""
+
+    def __init__(self, uri):
+        """Initialize the error with the failed URI."""
+        super(ResolutionError, self).__init__(
+            "{0} is not an absolute URI.".format(uri.unsplit())
+        )
+
+
+class ValidationError(RFC3986Exception):
+    """Exception raised during Validation of a URI."""
+
+    pass
+
+
+class MissingComponentError(ValidationError):
+    """Exception raised when a required component is missing."""
+
+    def __init__(self, uri, *component_names):
+        """Initialize the error with the missing component name."""
+        verb = "was"
+        if len(component_names) > 1:
+            verb = "were"
+
+        self.uri = uri
+        self.components = sorted(component_names)
+        components = ", ".join(self.components)
+        super(MissingComponentError, self).__init__(
+            "{} {} required but missing".format(components, verb),
+            uri,
+            self.components,
+        )
+
+
+class UnpermittedComponentError(ValidationError):
+    """Exception raised when a component has an unpermitted value."""
+
+    def __init__(self, component_name, component_value, allowed_values):
+        """Initialize the error with the unpermitted component."""
+        super(UnpermittedComponentError, self).__init__(
+            "{} was required to be one of {!r} but was {!r}".format(
+                component_name,
+                list(sorted(allowed_values)),
+                component_value,
+            ),
+            component_name,
+            component_value,
+            allowed_values,
+        )
+        self.component_name = component_name
+        self.component_value = component_value
+        self.allowed_values = allowed_values
+
+
+class PasswordForbidden(ValidationError):
+    """Exception raised when a URL has a password in the userinfo section."""
+
+    def __init__(self, uri):
+        """Initialize the error with the URI that failed validation."""
+        unsplit = getattr(uri, "unsplit", lambda: uri)
+        super(PasswordForbidden, self).__init__(
+            '"{}" contained a password when validation forbade it'.format(
+                unsplit()
+            )
+        )
+        self.uri = uri
+
+
+class InvalidComponentsError(ValidationError):
+    """Exception raised when one or more components are invalid."""
+
+    def __init__(self, uri, *component_names):
+        """Initialize the error with the invalid component name(s)."""
+        verb = "was"
+        if len(component_names) > 1:
+            verb = "were"
+
+        self.uri = uri
+        self.components = sorted(component_names)
+        components = ", ".join(self.components)
+        super(InvalidComponentsError, self).__init__(
+            "{} {} found to be invalid".format(components, verb),
+            uri,
+            self.components,
+        )
+
+
+class MissingDependencyError(RFC3986Exception):
+    """Exception raised when an IRI is encoded without the 'idna' module."""
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/iri.py b/myenv/lib/python3.9/site-packages/rfc3986/iri.py
new file mode 100644
index 0000000..540aa7b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/iri.py
@@ -0,0 +1,162 @@
+"""Module containing the implementation of the IRIReference class."""
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Copyright (c) 2015 Ian Stapleton Cordasco
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from collections import namedtuple
+
+from . import compat
+from . import exceptions
+from . import misc
+from . import normalizers
+from . import uri
+
+
+try:
+    import idna
+except ImportError:  # pragma: no cover
+    idna = None
+
+
+class IRIReference(
+    namedtuple("IRIReference", misc.URI_COMPONENTS), uri.URIMixin
+):
+    """Immutable object representing a parsed IRI Reference.
+
+    Can be encoded into an URIReference object via the procedure
+    specified in RFC 3987 Section 3.1
+
+     .. note::
+        The IRI submodule is a new interface and may possibly change in
+        the future. Check for changes to the interface when upgrading.
+    """
+
+    slots = ()
+
+    def __new__(
+        cls, scheme, authority, path, query, fragment, encoding="utf-8"
+    ):
+        """Create a new IRIReference."""
+        ref = super(IRIReference, cls).__new__(
+            cls,
+            scheme or None,
+            authority or None,
+            path or None,
+            query,
+            fragment,
+        )
+        ref.encoding = encoding
+        return ref
+
+    def __eq__(self, other):
+        """Compare this reference to another."""
+        other_ref = other
+        if isinstance(other, tuple):
+            other_ref = self.__class__(*other)
+        elif not isinstance(other, IRIReference):
+            try:
+                other_ref = self.__class__.from_string(other)
+            except TypeError:
+                raise TypeError(
+                    "Unable to compare {0}() to {1}()".format(
+                        type(self).__name__, type(other).__name__
+                    )
+                )
+
+        # See http://tools.ietf.org/html/rfc3986#section-6.2
+        return tuple(self) == tuple(other_ref)
+
+    def _match_subauthority(self):
+        return misc.ISUBAUTHORITY_MATCHER.match(self.authority)
+
+    @classmethod
+    def from_string(cls, iri_string, encoding="utf-8"):
+        """Parse a IRI reference from the given unicode IRI string.
+
+        :param str iri_string: Unicode IRI to be parsed into a reference.
+        :param str encoding: The encoding of the string provided
+        :returns: :class:`IRIReference` or subclass thereof
+        """
+        iri_string = compat.to_str(iri_string, encoding)
+
+        split_iri = misc.IRI_MATCHER.match(iri_string).groupdict()
+        return cls(
+            split_iri["scheme"],
+            split_iri["authority"],
+            normalizers.encode_component(split_iri["path"], encoding),
+            normalizers.encode_component(split_iri["query"], encoding),
+            normalizers.encode_component(split_iri["fragment"], encoding),
+            encoding,
+        )
+
+    def encode(self, idna_encoder=None):  # noqa: C901
+        """Encode an IRIReference into a URIReference instance.
+
+        If the ``idna`` module is installed or the ``rfc3986[idna]``
+        extra is used then unicode characters in the IRI host
+        component will be encoded with IDNA2008.
+
+        :param idna_encoder:
+            Function that encodes each part of the host component
+            If not given will raise an exception if the IRI
+            contains a host component.
+        :rtype: uri.URIReference
+        :returns: A URI reference
+        """
+        authority = self.authority
+        if authority:
+            if idna_encoder is None:
+                if idna is None:  # pragma: no cover
+                    raise exceptions.MissingDependencyError(
+                        "Could not import the 'idna' module "
+                        "and the IRI hostname requires encoding"
+                    )
+
+                def idna_encoder(name):
+                    if any(ord(c) > 128 for c in name):
+                        try:
+                            return idna.encode(
+                                name.lower(), strict=True, std3_rules=True
+                            )
+                        except idna.IDNAError:
+                            raise exceptions.InvalidAuthority(self.authority)
+                    return name
+
+            authority = ""
+            if self.host:
+                authority = ".".join(
+                    [
+                        compat.to_str(idna_encoder(part))
+                        for part in self.host.split(".")
+                    ]
+                )
+
+            if self.userinfo is not None:
+                authority = (
+                    normalizers.encode_component(self.userinfo, self.encoding)
+                    + "@"
+                    + authority
+                )
+
+            if self.port is not None:
+                authority += ":" + str(self.port)
+
+        return uri.URIReference(
+            self.scheme,
+            authority,
+            path=self.path,
+            query=self.query,
+            fragment=self.fragment,
+            encoding=self.encoding,
+        )
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/misc.py b/myenv/lib/python3.9/site-packages/rfc3986/misc.py
new file mode 100644
index 0000000..338b187
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/misc.py
@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Module containing compiled regular expressions and constants.
+
+This module contains important constants, patterns, and compiled regular
+expressions for parsing and validating URIs and their components.
+"""
+
+import re
+
+from . import abnf_regexp
+
+# These are enumerated for the named tuple used as a superclass of
+# URIReference
+URI_COMPONENTS = ["scheme", "authority", "path", "query", "fragment"]
+
+important_characters = {
+    "generic_delimiters": abnf_regexp.GENERIC_DELIMITERS,
+    "sub_delimiters": abnf_regexp.SUB_DELIMITERS,
+    # We need to escape the '*' in this case
+    "re_sub_delimiters": abnf_regexp.SUB_DELIMITERS_RE,
+    "unreserved_chars": abnf_regexp.UNRESERVED_CHARS,
+    # We need to escape the '-' in this case:
+    "re_unreserved": abnf_regexp.UNRESERVED_RE,
+}
+
+# For details about delimiters and reserved characters, see:
+# http://tools.ietf.org/html/rfc3986#section-2.2
+GENERIC_DELIMITERS = abnf_regexp.GENERIC_DELIMITERS_SET
+SUB_DELIMITERS = abnf_regexp.SUB_DELIMITERS_SET
+RESERVED_CHARS = abnf_regexp.RESERVED_CHARS_SET
+# For details about unreserved characters, see:
+# http://tools.ietf.org/html/rfc3986#section-2.3
+UNRESERVED_CHARS = abnf_regexp.UNRESERVED_CHARS_SET
+NON_PCT_ENCODED = abnf_regexp.NON_PCT_ENCODED_SET
+
+URI_MATCHER = re.compile(abnf_regexp.URL_PARSING_RE)
+
+SUBAUTHORITY_MATCHER = re.compile(
+    (
+        "^(?:(?P<userinfo>{0})@)?"  # userinfo
+        "(?P<host>{1})"  # host
+        ":?(?P<port>{2})?$"  # port
+    ).format(
+        abnf_regexp.USERINFO_RE, abnf_regexp.HOST_PATTERN, abnf_regexp.PORT_RE
+    )
+)
+
+
+HOST_MATCHER = re.compile("^" + abnf_regexp.HOST_RE + "$")
+IPv4_MATCHER = re.compile("^" + abnf_regexp.IPv4_RE + "$")
+IPv6_MATCHER = re.compile(r"^\[" + abnf_regexp.IPv6_ADDRZ_RFC4007_RE + r"\]$")
+
+# Used by host validator
+IPv6_NO_RFC4007_MATCHER = re.compile(
+    r"^\[%s\]$" % (abnf_regexp.IPv6_ADDRZ_RE)
+)
+
+# Matcher used to validate path components
+PATH_MATCHER = re.compile(abnf_regexp.PATH_RE)
+
+
+# ##################################
+# Query and Fragment Matcher Section
+# ##################################
+
+QUERY_MATCHER = re.compile(abnf_regexp.QUERY_RE)
+
+FRAGMENT_MATCHER = QUERY_MATCHER
+
+# Scheme validation, see: http://tools.ietf.org/html/rfc3986#section-3.1
+SCHEME_MATCHER = re.compile("^{0}$".format(abnf_regexp.SCHEME_RE))
+
+RELATIVE_REF_MATCHER = re.compile(
+    r"^%s(\?%s)?(#%s)?$"
+    % (
+        abnf_regexp.RELATIVE_PART_RE,
+        abnf_regexp.QUERY_RE,
+        abnf_regexp.FRAGMENT_RE,
+    )
+)
+
+# See http://tools.ietf.org/html/rfc3986#section-4.3
+ABSOLUTE_URI_MATCHER = re.compile(
+    r"^%s:%s(\?%s)?$"
+    % (
+        abnf_regexp.COMPONENT_PATTERN_DICT["scheme"],
+        abnf_regexp.HIER_PART_RE,
+        abnf_regexp.QUERY_RE[1:-1],
+    )
+)
+
+# ###############
+# IRIs / RFC 3987
+# ###############
+
+IRI_MATCHER = re.compile(abnf_regexp.URL_PARSING_RE, re.UNICODE)
+
+ISUBAUTHORITY_MATCHER = re.compile(
+    (
+        u"^(?:(?P<userinfo>{0})@)?"  # iuserinfo
+        u"(?P<host>{1})"  # ihost
+        u":?(?P<port>{2})?$"  # port
+    ).format(
+        abnf_regexp.IUSERINFO_RE, abnf_regexp.IHOST_RE, abnf_regexp.PORT_RE
+    ),
+    re.UNICODE,
+)
+
+
+# Path merger as defined in http://tools.ietf.org/html/rfc3986#section-5.2.3
+def merge_paths(base_uri, relative_path):
+    """Merge a base URI's path with a relative URI's path."""
+    if base_uri.path is None and base_uri.authority is not None:
+        return "/" + relative_path
+    else:
+        path = base_uri.path or ""
+        index = path.rfind("/")
+        return path[:index] + "/" + relative_path
+
+
+UseExisting = object()
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/normalizers.py b/myenv/lib/python3.9/site-packages/rfc3986/normalizers.py
new file mode 100644
index 0000000..0d702b6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/normalizers.py
@@ -0,0 +1,172 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module with functions to normalize components."""
+import re
+
+from . import compat
+from . import misc
+
+
+def normalize_scheme(scheme):
+    """Normalize the scheme component."""
+    return scheme.lower()
+
+
+def normalize_authority(authority):
+    """Normalize an authority tuple to a string."""
+    userinfo, host, port = authority
+    result = ""
+    if userinfo:
+        result += normalize_percent_characters(userinfo) + "@"
+    if host:
+        result += normalize_host(host)
+    if port:
+        result += ":" + port
+    return result
+
+
+def normalize_username(username):
+    """Normalize a username to make it safe to include in userinfo."""
+    return compat.urlquote(username)
+
+
+def normalize_password(password):
+    """Normalize a password to make safe for userinfo."""
+    return compat.urlquote(password)
+
+
+def normalize_host(host):
+    """Normalize a host string."""
+    if misc.IPv6_MATCHER.match(host):
+        percent = host.find("%")
+        if percent != -1:
+            percent_25 = host.find("%25")
+
+            # Replace RFC 4007 IPv6 Zone ID delimiter '%' with '%25'
+            # from RFC 6874. If the host is '[<IPv6 addr>%25]' then we
+            # assume RFC 4007 and normalize to '[<IPV6 addr>%2525]'
+            if (
+                percent_25 == -1
+                or percent < percent_25
+                or (percent == percent_25 and percent_25 == len(host) - 4)
+            ):
+                host = host.replace("%", "%25", 1)
+
+            # Don't normalize the casing of the Zone ID
+            return host[:percent].lower() + host[percent:]
+
+    return host.lower()
+
+
+def normalize_path(path):
+    """Normalize the path string."""
+    if not path:
+        return path
+
+    path = normalize_percent_characters(path)
+    return remove_dot_segments(path)
+
+
+def normalize_query(query):
+    """Normalize the query string."""
+    if not query:
+        return query
+    return normalize_percent_characters(query)
+
+
+def normalize_fragment(fragment):
+    """Normalize the fragment string."""
+    if not fragment:
+        return fragment
+    return normalize_percent_characters(fragment)
+
+
+PERCENT_MATCHER = re.compile("%[A-Fa-f0-9]{2}")
+
+
+def normalize_percent_characters(s):
+    """All percent characters should be upper-cased.
+
+    For example, ``"%3afoo%DF%ab"`` should be turned into ``"%3Afoo%DF%AB"``.
+    """
+    matches = set(PERCENT_MATCHER.findall(s))
+    for m in matches:
+        if not m.isupper():
+            s = s.replace(m, m.upper())
+    return s
+
+
+def remove_dot_segments(s):
+    """Remove dot segments from the string.
+
+    See also Section 5.2.4 of :rfc:`3986`.
+    """
+    # See http://tools.ietf.org/html/rfc3986#section-5.2.4 for pseudo-code
+    segments = s.split("/")  # Turn the path into a list of segments
+    output = []  # Initialize the variable to use to store output
+
+    for segment in segments:
+        # '.' is the current directory, so ignore it, it is superfluous
+        if segment == ".":
+            continue
+        # Anything other than '..', should be appended to the output
+        elif segment != "..":
+            output.append(segment)
+        # In this case segment == '..', if we can, we should pop the last
+        # element
+        elif output:
+            output.pop()
+
+    # If the path starts with '/' and the output is empty or the first string
+    # is non-empty
+    if s.startswith("/") and (not output or output[0]):
+        output.insert(0, "")
+
+    # If the path starts with '/.' or '/..' ensure we add one more empty
+    # string to add a trailing '/'
+    if s.endswith(("/.", "/..")):
+        output.append("")
+
+    return "/".join(output)
+
+
+def encode_component(uri_component, encoding):
+    """Encode the specific component in the provided encoding."""
+    if uri_component is None:
+        return uri_component
+
+    # Try to see if the component we're encoding is already percent-encoded
+    # so we can skip all '%' characters but still encode all others.
+    percent_encodings = len(
+        PERCENT_MATCHER.findall(compat.to_str(uri_component, encoding))
+    )
+
+    uri_bytes = compat.to_bytes(uri_component, encoding)
+    is_percent_encoded = percent_encodings == uri_bytes.count(b"%")
+
+    encoded_uri = bytearray()
+
+    for i in range(0, len(uri_bytes)):
+        # Will return a single character bytestring on both Python 2 & 3
+        byte = uri_bytes[i : i + 1]
+        byte_ord = ord(byte)
+        if (is_percent_encoded and byte == b"%") or (
+            byte_ord < 128 and byte.decode() in misc.NON_PCT_ENCODED
+        ):
+            encoded_uri.extend(byte)
+            continue
+        encoded_uri.extend("%{0:02x}".format(byte_ord).encode().upper())
+
+    return encoded_uri.decode(encoding)
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/parseresult.py b/myenv/lib/python3.9/site-packages/rfc3986/parseresult.py
new file mode 100644
index 0000000..8887e8f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/parseresult.py
@@ -0,0 +1,479 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2015 Ian Stapleton Cordasco
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module containing the urlparse compatibility logic."""
+from collections import namedtuple
+
+from . import compat
+from . import exceptions
+from . import misc
+from . import normalizers
+from . import uri
+
+__all__ = ("ParseResult", "ParseResultBytes")
+
+PARSED_COMPONENTS = (
+    "scheme",
+    "userinfo",
+    "host",
+    "port",
+    "path",
+    "query",
+    "fragment",
+)
+
+
+class ParseResultMixin(object):
+    def _generate_authority(self, attributes):
+        # I swear I did not align the comparisons below. That's just how they
+        # happened to align based on pep8 and attribute lengths.
+        userinfo, host, port = (
+            attributes[p] for p in ("userinfo", "host", "port")
+        )
+        if (
+            self.userinfo != userinfo
+            or self.host != host
+            or self.port != port
+        ):
+            if port:
+                port = "{0}".format(port)
+            return normalizers.normalize_authority(
+                (
+                    compat.to_str(userinfo, self.encoding),
+                    compat.to_str(host, self.encoding),
+                    port,
+                )
+            )
+        if isinstance(self.authority, bytes):
+            return self.authority.decode("utf-8")
+        return self.authority
+
+    def geturl(self):
+        """Shim to match the standard library method."""
+        return self.unsplit()
+
+    @property
+    def hostname(self):
+        """Shim to match the standard library."""
+        return self.host
+
+    @property
+    def netloc(self):
+        """Shim to match the standard library."""
+        return self.authority
+
+    @property
+    def params(self):
+        """Shim to match the standard library."""
+        return self.query
+
+
+class ParseResult(
+    namedtuple("ParseResult", PARSED_COMPONENTS), ParseResultMixin
+):
+    """Implementation of urlparse compatibility class.
+
+    This uses the URIReference logic to handle compatibility with the
+    urlparse.ParseResult class.
+    """
+
+    slots = ()
+
+    def __new__(
+        cls,
+        scheme,
+        userinfo,
+        host,
+        port,
+        path,
+        query,
+        fragment,
+        uri_ref,
+        encoding="utf-8",
+    ):
+        """Create a new ParseResult."""
+        parse_result = super(ParseResult, cls).__new__(
+            cls,
+            scheme or None,
+            userinfo or None,
+            host,
+            port or None,
+            path or None,
+            query,
+            fragment,
+        )
+        parse_result.encoding = encoding
+        parse_result.reference = uri_ref
+        return parse_result
+
+    @classmethod
+    def from_parts(
+        cls,
+        scheme=None,
+        userinfo=None,
+        host=None,
+        port=None,
+        path=None,
+        query=None,
+        fragment=None,
+        encoding="utf-8",
+    ):
+        """Create a ParseResult instance from its parts."""
+        authority = ""
+        if userinfo is not None:
+            authority += userinfo + "@"
+        if host is not None:
+            authority += host
+        if port is not None:
+            authority += ":{0}".format(port)
+        uri_ref = uri.URIReference(
+            scheme=scheme,
+            authority=authority,
+            path=path,
+            query=query,
+            fragment=fragment,
+            encoding=encoding,
+        ).normalize()
+        userinfo, host, port = authority_from(uri_ref, strict=True)
+        return cls(
+            scheme=uri_ref.scheme,
+            userinfo=userinfo,
+            host=host,
+            port=port,
+            path=uri_ref.path,
+            query=uri_ref.query,
+            fragment=uri_ref.fragment,
+            uri_ref=uri_ref,
+            encoding=encoding,
+        )
+
+    @classmethod
+    def from_string(
+        cls, uri_string, encoding="utf-8", strict=True, lazy_normalize=True
+    ):
+        """Parse a URI from the given unicode URI string.
+
+        :param str uri_string: Unicode URI to be parsed into a reference.
+        :param str encoding: The encoding of the string provided
+        :param bool strict: Parse strictly according to :rfc:`3986` if True.
+            If False, parse similarly to the standard library's urlparse
+            function.
+        :returns: :class:`ParseResult` or subclass thereof
+        """
+        reference = uri.URIReference.from_string(uri_string, encoding)
+        if not lazy_normalize:
+            reference = reference.normalize()
+        userinfo, host, port = authority_from(reference, strict)
+
+        return cls(
+            scheme=reference.scheme,
+            userinfo=userinfo,
+            host=host,
+            port=port,
+            path=reference.path,
+            query=reference.query,
+            fragment=reference.fragment,
+            uri_ref=reference,
+            encoding=encoding,
+        )
+
+    @property
+    def authority(self):
+        """Return the normalized authority."""
+        return self.reference.authority
+
+    def copy_with(
+        self,
+        scheme=misc.UseExisting,
+        userinfo=misc.UseExisting,
+        host=misc.UseExisting,
+        port=misc.UseExisting,
+        path=misc.UseExisting,
+        query=misc.UseExisting,
+        fragment=misc.UseExisting,
+    ):
+        """Create a copy of this instance replacing with specified parts."""
+        attributes = zip(
+            PARSED_COMPONENTS,
+            (scheme, userinfo, host, port, path, query, fragment),
+        )
+        attrs_dict = {}
+        for name, value in attributes:
+            if value is misc.UseExisting:
+                value = getattr(self, name)
+            attrs_dict[name] = value
+        authority = self._generate_authority(attrs_dict)
+        ref = self.reference.copy_with(
+            scheme=attrs_dict["scheme"],
+            authority=authority,
+            path=attrs_dict["path"],
+            query=attrs_dict["query"],
+            fragment=attrs_dict["fragment"],
+        )
+        return ParseResult(uri_ref=ref, encoding=self.encoding, **attrs_dict)
+
+    def encode(self, encoding=None):
+        """Convert to an instance of ParseResultBytes."""
+        encoding = encoding or self.encoding
+        attrs = dict(
+            zip(
+                PARSED_COMPONENTS,
+                (
+                    attr.encode(encoding) if hasattr(attr, "encode") else attr
+                    for attr in self
+                ),
+            )
+        )
+        return ParseResultBytes(
+            uri_ref=self.reference, encoding=encoding, **attrs
+        )
+
+    def unsplit(self, use_idna=False):
+        """Create a URI string from the components.
+
+        :returns: The parsed URI reconstituted as a string.
+        :rtype: str
+        """
+        parse_result = self
+        if use_idna and self.host:
+            hostbytes = self.host.encode("idna")
+            host = hostbytes.decode(self.encoding)
+            parse_result = self.copy_with(host=host)
+        return parse_result.reference.unsplit()
+
+
+class ParseResultBytes(
+    namedtuple("ParseResultBytes", PARSED_COMPONENTS), ParseResultMixin
+):
+    """Compatibility shim for the urlparse.ParseResultBytes object."""
+
+    def __new__(
+        cls,
+        scheme,
+        userinfo,
+        host,
+        port,
+        path,
+        query,
+        fragment,
+        uri_ref,
+        encoding="utf-8",
+        lazy_normalize=True,
+    ):
+        """Create a new ParseResultBytes instance."""
+        parse_result = super(ParseResultBytes, cls).__new__(
+            cls,
+            scheme or None,
+            userinfo or None,
+            host,
+            port or None,
+            path or None,
+            query or None,
+            fragment or None,
+        )
+        parse_result.encoding = encoding
+        parse_result.reference = uri_ref
+        parse_result.lazy_normalize = lazy_normalize
+        return parse_result
+
+    @classmethod
+    def from_parts(
+        cls,
+        scheme=None,
+        userinfo=None,
+        host=None,
+        port=None,
+        path=None,
+        query=None,
+        fragment=None,
+        encoding="utf-8",
+        lazy_normalize=True,
+    ):
+        """Create a ParseResult instance from its parts."""
+        authority = ""
+        if userinfo is not None:
+            authority += userinfo + "@"
+        if host is not None:
+            authority += host
+        if port is not None:
+            authority += ":{0}".format(int(port))
+        uri_ref = uri.URIReference(
+            scheme=scheme,
+            authority=authority,
+            path=path,
+            query=query,
+            fragment=fragment,
+            encoding=encoding,
+        )
+        if not lazy_normalize:
+            uri_ref = uri_ref.normalize()
+        to_bytes = compat.to_bytes
+        userinfo, host, port = authority_from(uri_ref, strict=True)
+        return cls(
+            scheme=to_bytes(scheme, encoding),
+            userinfo=to_bytes(userinfo, encoding),
+            host=to_bytes(host, encoding),
+            port=port,
+            path=to_bytes(path, encoding),
+            query=to_bytes(query, encoding),
+            fragment=to_bytes(fragment, encoding),
+            uri_ref=uri_ref,
+            encoding=encoding,
+            lazy_normalize=lazy_normalize,
+        )
+
+    @classmethod
+    def from_string(
+        cls, uri_string, encoding="utf-8", strict=True, lazy_normalize=True
+    ):
+        """Parse a URI from the given unicode URI string.
+
+        :param str uri_string: Unicode URI to be parsed into a reference.
+        :param str encoding: The encoding of the string provided
+        :param bool strict: Parse strictly according to :rfc:`3986` if True.
+            If False, parse similarly to the standard library's urlparse
+            function.
+        :returns: :class:`ParseResultBytes` or subclass thereof
+        """
+        reference = uri.URIReference.from_string(uri_string, encoding)
+        if not lazy_normalize:
+            reference = reference.normalize()
+        userinfo, host, port = authority_from(reference, strict)
+
+        to_bytes = compat.to_bytes
+        return cls(
+            scheme=to_bytes(reference.scheme, encoding),
+            userinfo=to_bytes(userinfo, encoding),
+            host=to_bytes(host, encoding),
+            port=port,
+            path=to_bytes(reference.path, encoding),
+            query=to_bytes(reference.query, encoding),
+            fragment=to_bytes(reference.fragment, encoding),
+            uri_ref=reference,
+            encoding=encoding,
+            lazy_normalize=lazy_normalize,
+        )
+
+    @property
+    def authority(self):
+        """Return the normalized authority."""
+        return self.reference.authority.encode(self.encoding)
+
+    def copy_with(
+        self,
+        scheme=misc.UseExisting,
+        userinfo=misc.UseExisting,
+        host=misc.UseExisting,
+        port=misc.UseExisting,
+        path=misc.UseExisting,
+        query=misc.UseExisting,
+        fragment=misc.UseExisting,
+        lazy_normalize=True,
+    ):
+        """Create a copy of this instance replacing with specified parts."""
+        attributes = zip(
+            PARSED_COMPONENTS,
+            (scheme, userinfo, host, port, path, query, fragment),
+        )
+        attrs_dict = {}
+        for name, value in attributes:
+            if value is misc.UseExisting:
+                value = getattr(self, name)
+            if not isinstance(value, bytes) and hasattr(value, "encode"):
+                value = value.encode(self.encoding)
+            attrs_dict[name] = value
+        authority = self._generate_authority(attrs_dict)
+        to_str = compat.to_str
+        ref = self.reference.copy_with(
+            scheme=to_str(attrs_dict["scheme"], self.encoding),
+            authority=to_str(authority, self.encoding),
+            path=to_str(attrs_dict["path"], self.encoding),
+            query=to_str(attrs_dict["query"], self.encoding),
+            fragment=to_str(attrs_dict["fragment"], self.encoding),
+        )
+        if not lazy_normalize:
+            ref = ref.normalize()
+        return ParseResultBytes(
+            uri_ref=ref,
+            encoding=self.encoding,
+            lazy_normalize=lazy_normalize,
+            **attrs_dict
+        )
+
+    def unsplit(self, use_idna=False):
+        """Create a URI bytes object from the components.
+
+        :returns: The parsed URI reconstituted as a string.
+        :rtype: bytes
+        """
+        parse_result = self
+        if use_idna and self.host:
+            # self.host is bytes, to encode to idna, we need to decode it
+            # first
+            host = self.host.decode(self.encoding)
+            hostbytes = host.encode("idna")
+            parse_result = self.copy_with(host=hostbytes)
+        if self.lazy_normalize:
+            parse_result = parse_result.copy_with(lazy_normalize=False)
+        uri = parse_result.reference.unsplit()
+        return uri.encode(self.encoding)
+
+
+def split_authority(authority):
+    # Initialize our expected return values
+    userinfo = host = port = None
+    # Initialize an extra var we may need to use
+    extra_host = None
+    # Set-up rest in case there is no userinfo portion
+    rest = authority
+
+    if "@" in authority:
+        userinfo, rest = authority.rsplit("@", 1)
+
+    # Handle IPv6 host addresses
+    if rest.startswith("["):
+        host, rest = rest.split("]", 1)
+        host += "]"
+
+    if ":" in rest:
+        extra_host, port = rest.split(":", 1)
+    elif not host and rest:
+        host = rest
+
+    if extra_host and not host:
+        host = extra_host
+
+    return userinfo, host, port
+
+
+def authority_from(reference, strict):
+    try:
+        subauthority = reference.authority_info()
+    except exceptions.InvalidAuthority:
+        if strict:
+            raise
+        userinfo, host, port = split_authority(reference.authority)
+    else:
+        # Thanks to Richard Barrell for this idea:
+        # https://twitter.com/0x2ba22e11/status/617338811975139328
+        userinfo, host, port = (
+            subauthority.get(p) for p in ("userinfo", "host", "port")
+        )
+
+    if port:
+        try:
+            port = int(port)
+        except ValueError:
+            raise exceptions.InvalidPort(port)
+    return userinfo, host, port
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/uri.py b/myenv/lib/python3.9/site-packages/rfc3986/uri.py
new file mode 100644
index 0000000..75c617d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/uri.py
@@ -0,0 +1,161 @@
+"""Module containing the implementation of the URIReference class."""
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Copyright (c) 2015 Ian Stapleton Cordasco
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from collections import namedtuple
+
+from . import compat
+from . import misc
+from . import normalizers
+from ._mixin import URIMixin
+
+
+class URIReference(namedtuple("URIReference", misc.URI_COMPONENTS), URIMixin):
+    """Immutable object representing a parsed URI Reference.
+
+    .. note::
+
+        This class is not intended to be directly instantiated by the user.
+
+    This object exposes attributes for the following components of a
+    URI:
+
+    - scheme
+    - authority
+    - path
+    - query
+    - fragment
+
+    .. attribute:: scheme
+
+        The scheme that was parsed for the URI Reference. For example,
+        ``http``, ``https``, ``smtp``, ``imap``, etc.
+
+    .. attribute:: authority
+
+        Component of the URI that contains the user information, host,
+        and port sub-components. For example,
+        ``google.com``, ``127.0.0.1:5000``, ``username@[::1]``,
+        ``username:password@example.com:443``, etc.
+
+    .. attribute:: path
+
+        The path that was parsed for the given URI Reference. For example,
+        ``/``, ``/index.php``, etc.
+
+    .. attribute:: query
+
+        The query component for a given URI Reference. For example, ``a=b``,
+        ``a=b%20c``, ``a=b+c``, ``a=b,c=d,e=%20f``, etc.
+
+    .. attribute:: fragment
+
+        The fragment component of a URI. For example, ``section-3.1``.
+
+    This class also provides extra attributes for easier access to information
+    like the subcomponents of the authority component.
+
+    .. attribute:: userinfo
+
+        The user information parsed from the authority.
+
+    .. attribute:: host
+
+        The hostname, IPv4, or IPv6 address parsed from the authority.
+
+    .. attribute:: port
+
+        The port parsed from the authority.
+    """
+
+    slots = ()
+
+    def __new__(
+        cls, scheme, authority, path, query, fragment, encoding="utf-8"
+    ):
+        """Create a new URIReference."""
+        ref = super(URIReference, cls).__new__(
+            cls,
+            scheme or None,
+            authority or None,
+            path or None,
+            query,
+            fragment,
+        )
+        ref.encoding = encoding
+        return ref
+
+    __hash__ = tuple.__hash__
+
+    def __eq__(self, other):
+        """Compare this reference to another."""
+        other_ref = other
+        if isinstance(other, tuple):
+            other_ref = URIReference(*other)
+        elif not isinstance(other, URIReference):
+            try:
+                other_ref = URIReference.from_string(other)
+            except TypeError:
+                raise TypeError(
+                    "Unable to compare URIReference() to {0}()".format(
+                        type(other).__name__
+                    )
+                )
+
+        # See http://tools.ietf.org/html/rfc3986#section-6.2
+        naive_equality = tuple(self) == tuple(other_ref)
+        return naive_equality or self.normalized_equality(other_ref)
+
+    def normalize(self):
+        """Normalize this reference as described in Section 6.2.2.
+
+        This is not an in-place normalization. Instead this creates a new
+        URIReference.
+
+        :returns: A new reference object with normalized components.
+        :rtype: URIReference
+        """
+        # See http://tools.ietf.org/html/rfc3986#section-6.2.2 for logic in
+        # this method.
+        return URIReference(
+            normalizers.normalize_scheme(self.scheme or ""),
+            normalizers.normalize_authority(
+                (self.userinfo, self.host, self.port)
+            ),
+            normalizers.normalize_path(self.path or ""),
+            normalizers.normalize_query(self.query),
+            normalizers.normalize_fragment(self.fragment),
+            self.encoding,
+        )
+
+    @classmethod
+    def from_string(cls, uri_string, encoding="utf-8"):
+        """Parse a URI reference from the given unicode URI string.
+
+        :param str uri_string: Unicode URI to be parsed into a reference.
+        :param str encoding: The encoding of the string provided
+        :returns: :class:`URIReference` or subclass thereof
+        """
+        uri_string = compat.to_str(uri_string, encoding)
+
+        split_uri = misc.URI_MATCHER.match(uri_string).groupdict()
+        return cls(
+            split_uri["scheme"],
+            split_uri["authority"],
+            normalizers.encode_component(split_uri["path"], encoding),
+            normalizers.encode_component(split_uri["query"], encoding),
+            normalizers.encode_component(split_uri["fragment"], encoding),
+            encoding,
+        )
diff --git a/myenv/lib/python3.9/site-packages/rfc3986/validators.py b/myenv/lib/python3.9/site-packages/rfc3986/validators.py
new file mode 100644
index 0000000..f375248
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rfc3986/validators.py
@@ -0,0 +1,447 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2017 Ian Stapleton Cordasco
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module containing the validation logic for rfc3986."""
+from . import exceptions
+from . import misc
+from . import normalizers
+
+
+class Validator(object):
+    """Object used to configure validation of all objects in rfc3986.
+
+    .. versionadded:: 1.0
+
+    Example usage::
+
+         >>> from rfc3986 import api, validators
+         >>> uri = api.uri_reference('https://github.com/')
+         >>> validator = validators.Validator().require_presence_of(
+         ...    'scheme', 'host', 'path',
+         ... ).allow_schemes(
+         ...    'http', 'https',
+         ... ).allow_hosts(
+         ...    '127.0.0.1', 'github.com',
+         ... )
+         >>> validator.validate(uri)
+         >>> invalid_uri = rfc3986.uri_reference('imap://mail.google.com')
+         >>> validator.validate(invalid_uri)
+         Traceback (most recent call last):
+         ...
+         rfc3986.exceptions.MissingComponentError: ('path was required but
+         missing', URIReference(scheme=u'imap', authority=u'mail.google.com',
+         path=None, query=None, fragment=None), ['path'])
+
+    """
+
+    COMPONENT_NAMES = frozenset(
+        ["scheme", "userinfo", "host", "port", "path", "query", "fragment"]
+    )
+
+    def __init__(self):
+        """Initialize our default validations."""
+        self.allowed_schemes = set()
+        self.allowed_hosts = set()
+        self.allowed_ports = set()
+        self.allow_password = True
+        self.required_components = {
+            "scheme": False,
+            "userinfo": False,
+            "host": False,
+            "port": False,
+            "path": False,
+            "query": False,
+            "fragment": False,
+        }
+        self.validated_components = self.required_components.copy()
+
+    def allow_schemes(self, *schemes):
+        """Require the scheme to be one of the provided schemes.
+
+        .. versionadded:: 1.0
+
+        :param schemes:
+            Schemes, without ``://`` that are allowed.
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        for scheme in schemes:
+            self.allowed_schemes.add(normalizers.normalize_scheme(scheme))
+        return self
+
+    def allow_hosts(self, *hosts):
+        """Require the host to be one of the provided hosts.
+
+        .. versionadded:: 1.0
+
+        :param hosts:
+            Hosts that are allowed.
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        for host in hosts:
+            self.allowed_hosts.add(normalizers.normalize_host(host))
+        return self
+
+    def allow_ports(self, *ports):
+        """Require the port to be one of the provided ports.
+
+        .. versionadded:: 1.0
+
+        :param ports:
+            Ports that are allowed.
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        for port in ports:
+            port_int = int(port, base=10)
+            if 0 <= port_int <= 65535:
+                self.allowed_ports.add(port)
+        return self
+
+    def allow_use_of_password(self):
+        """Allow passwords to be present in the URI.
+
+        .. versionadded:: 1.0
+
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        self.allow_password = True
+        return self
+
+    def forbid_use_of_password(self):
+        """Prevent passwords from being included in the URI.
+
+        .. versionadded:: 1.0
+
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        self.allow_password = False
+        return self
+
+    def check_validity_of(self, *components):
+        """Check the validity of the components provided.
+
+        This can be specified repeatedly.
+
+        .. versionadded:: 1.1
+
+        :param components:
+            Names of components from :attr:`Validator.COMPONENT_NAMES`.
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        components = [c.lower() for c in components]
+        for component in components:
+            if component not in self.COMPONENT_NAMES:
+                raise ValueError(
+                    '"{}" is not a valid component'.format(component)
+                )
+        self.validated_components.update(
+            {component: True for component in components}
+        )
+        return self
+
+    def require_presence_of(self, *components):
+        """Require the components provided.
+
+        This can be specified repeatedly.
+
+        .. versionadded:: 1.0
+
+        :param components:
+            Names of components from :attr:`Validator.COMPONENT_NAMES`.
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        components = [c.lower() for c in components]
+        for component in components:
+            if component not in self.COMPONENT_NAMES:
+                raise ValueError(
+                    '"{}" is not a valid component'.format(component)
+                )
+        self.required_components.update(
+            {component: True for component in components}
+        )
+        return self
+
+    def validate(self, uri):
+        """Check a URI for conditions specified on this validator.
+
+        .. versionadded:: 1.0
+
+        :param uri:
+            Parsed URI to validate.
+        :type uri:
+            rfc3986.uri.URIReference
+        :raises MissingComponentError:
+            When a required component is missing.
+        :raises UnpermittedComponentError:
+            When a component is not one of those allowed.
+        :raises PasswordForbidden:
+            When a password is present in the userinfo component but is
+            not permitted by configuration.
+        :raises InvalidComponentsError:
+            When a component was found to be invalid.
+        """
+        if not self.allow_password:
+            check_password(uri)
+
+        required_components = [
+            component
+            for component, required in self.required_components.items()
+            if required
+        ]
+        validated_components = [
+            component
+            for component, required in self.validated_components.items()
+            if required
+        ]
+        if required_components:
+            ensure_required_components_exist(uri, required_components)
+        if validated_components:
+            ensure_components_are_valid(uri, validated_components)
+
+        ensure_one_of(self.allowed_schemes, uri, "scheme")
+        ensure_one_of(self.allowed_hosts, uri, "host")
+        ensure_one_of(self.allowed_ports, uri, "port")
+
+
+def check_password(uri):
+    """Assert that there is no password present in the uri."""
+    userinfo = uri.userinfo
+    if not userinfo:
+        return
+    credentials = userinfo.split(":", 1)
+    if len(credentials) <= 1:
+        return
+    raise exceptions.PasswordForbidden(uri)
+
+
+def ensure_one_of(allowed_values, uri, attribute):
+    """Assert that the uri's attribute is one of the allowed values."""
+    value = getattr(uri, attribute)
+    if value is not None and allowed_values and value not in allowed_values:
+        raise exceptions.UnpermittedComponentError(
+            attribute,
+            value,
+            allowed_values,
+        )
+
+
+def ensure_required_components_exist(uri, required_components):
+    """Assert that all required components are present in the URI."""
+    missing_components = sorted(
+        [
+            component
+            for component in required_components
+            if getattr(uri, component) is None
+        ]
+    )
+    if missing_components:
+        raise exceptions.MissingComponentError(uri, *missing_components)
+
+
+def is_valid(value, matcher, require):
+    """Determine if a value is valid based on the provided matcher.
+
+    :param str value:
+        Value to validate.
+    :param matcher:
+        Compiled regular expression to use to validate the value.
+    :param require:
+        Whether or not the value is required.
+    """
+    if require:
+        return value is not None and matcher.match(value)
+
+    # require is False and value is not None
+    return value is None or matcher.match(value)
+
+
+def authority_is_valid(authority, host=None, require=False):
+    """Determine if the authority string is valid.
+
+    :param str authority:
+        The authority to validate.
+    :param str host:
+        (optional) The host portion of the authority to validate.
+    :param bool require:
+        (optional) Specify if authority must not be None.
+    :returns:
+        ``True`` if valid, ``False`` otherwise
+    :rtype:
+        bool
+    """
+    validated = is_valid(authority, misc.SUBAUTHORITY_MATCHER, require)
+    if validated and host is not None:
+        return host_is_valid(host, require)
+    return validated
+
+
+def host_is_valid(host, require=False):
+    """Determine if the host string is valid.
+
+    :param str host:
+        The host to validate.
+    :param bool require:
+        (optional) Specify if host must not be None.
+    :returns:
+        ``True`` if valid, ``False`` otherwise
+    :rtype:
+        bool
+    """
+    validated = is_valid(host, misc.HOST_MATCHER, require)
+    if validated and host is not None and misc.IPv4_MATCHER.match(host):
+        return valid_ipv4_host_address(host)
+    elif validated and host is not None and misc.IPv6_MATCHER.match(host):
+        return misc.IPv6_NO_RFC4007_MATCHER.match(host) is not None
+    return validated
+
+
+def scheme_is_valid(scheme, require=False):
+    """Determine if the scheme is valid.
+
+    :param str scheme:
+        The scheme string to validate.
+    :param bool require:
+        (optional) Set to ``True`` to require the presence of a scheme.
+    :returns:
+        ``True`` if the scheme is valid. ``False`` otherwise.
+    :rtype:
+        bool
+    """
+    return is_valid(scheme, misc.SCHEME_MATCHER, require)
+
+
+def path_is_valid(path, require=False):
+    """Determine if the path component is valid.
+
+    :param str path:
+        The path string to validate.
+    :param bool require:
+        (optional) Set to ``True`` to require the presence of a path.
+    :returns:
+        ``True`` if the path is valid. ``False`` otherwise.
+    :rtype:
+        bool
+    """
+    return is_valid(path, misc.PATH_MATCHER, require)
+
+
+def query_is_valid(query, require=False):
+    """Determine if the query component is valid.
+
+    :param str query:
+        The query string to validate.
+    :param bool require:
+        (optional) Set to ``True`` to require the presence of a query.
+    :returns:
+        ``True`` if the query is valid. ``False`` otherwise.
+    :rtype:
+        bool
+    """
+    return is_valid(query, misc.QUERY_MATCHER, require)
+
+
+def fragment_is_valid(fragment, require=False):
+    """Determine if the fragment component is valid.
+
+    :param str fragment:
+        The fragment string to validate.
+    :param bool require:
+        (optional) Set to ``True`` to require the presence of a fragment.
+    :returns:
+        ``True`` if the fragment is valid. ``False`` otherwise.
+    :rtype:
+        bool
+    """
+    return is_valid(fragment, misc.FRAGMENT_MATCHER, require)
+
+
+def valid_ipv4_host_address(host):
+    """Determine if the given host is a valid IPv4 address."""
+    # If the host exists, and it might be IPv4, check each byte in the
+    # address.
+    return all([0 <= int(byte, base=10) <= 255 for byte in host.split(".")])
+
+
+_COMPONENT_VALIDATORS = {
+    "scheme": scheme_is_valid,
+    "path": path_is_valid,
+    "query": query_is_valid,
+    "fragment": fragment_is_valid,
+}
+
+_SUBAUTHORITY_VALIDATORS = set(["userinfo", "host", "port"])
+
+
+def subauthority_component_is_valid(uri, component):
+    """Determine if the userinfo, host, and port are valid."""
+    try:
+        subauthority_dict = uri.authority_info()
+    except exceptions.InvalidAuthority:
+        return False
+
+    # If we can parse the authority into sub-components and we're not
+    # validating the port, we can assume it's valid.
+    if component == "host":
+        return host_is_valid(subauthority_dict["host"])
+    elif component != "port":
+        return True
+
+    try:
+        port = int(subauthority_dict["port"])
+    except TypeError:
+        # If the port wasn't provided it'll be None and int(None) raises a
+        # TypeError
+        return True
+
+    return 0 <= port <= 65535
+
+
+def ensure_components_are_valid(uri, validated_components):
+    """Assert that all components are valid in the URI."""
+    invalid_components = set([])
+    for component in validated_components:
+        if component in _SUBAUTHORITY_VALIDATORS:
+            if not subauthority_component_is_valid(uri, component):
+                invalid_components.add(component)
+            # Python's peephole optimizer means that while this continue *is*
+            # actually executed, coverage.py cannot detect that. See also,
+            # https://bitbucket.org/ned/coveragepy/issues/198/continue-marked-as-not-covered
+            continue  # nocov: Python 2.7, 3.3, 3.4
+
+        validator = _COMPONENT_VALIDATORS[component]
+        if not validator(getattr(uri, component)):
+            invalid_components.add(component)
+
+    if invalid_components:
+        raise exceptions.InvalidComponentsError(uri, *invalid_components)
diff --git a/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/LICENSE
new file mode 100644
index 0000000..67589cb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/LICENSE
@@ -0,0 +1,13 @@
+Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/METADATA b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/METADATA
new file mode 100644
index 0000000..e3e5a7c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/METADATA
@@ -0,0 +1,72 @@
+Metadata-Version: 2.1
+Name: rsa
+Version: 4.8
+Summary: Pure-Python RSA implementation
+Home-page: https://stuvel.eu/rsa
+License: Apache-2.0
+Author: Sybren A. Stüvel
+Author-email: sybren@stuvel.eu
+Requires-Python: >=3.6,<4
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Security :: Cryptography
+Requires-Dist: pyasn1 (>=0.1.3)
+Description-Content-Type: text/markdown
+
+# Pure Python RSA implementation
+
+[![PyPI](https://img.shields.io/pypi/v/rsa.svg)](https://pypi.org/project/rsa/)
+[![Build Status](https://travis-ci.org/sybrenstuvel/python-rsa.svg?branch=master)](https://travis-ci.org/sybrenstuvel/python-rsa)
+[![Coverage Status](https://coveralls.io/repos/github/sybrenstuvel/python-rsa/badge.svg?branch=master)](https://coveralls.io/github/sybrenstuvel/python-rsa?branch=master)
+[![Code Climate](https://api.codeclimate.com/v1/badges/a99a88d28ad37a79dbf6/maintainability)](https://codeclimate.com/github/codeclimate/codeclimate/maintainability)
+
+[Python-RSA](https://stuvel.eu/rsa) is a pure-Python RSA implementation. It supports
+encryption and decryption, signing and verifying signatures, and key
+generation according to PKCS#1 version 1.5. It can be used as a Python
+library as well as on the commandline. The code was mostly written by
+Sybren A.  Stüvel.
+
+Documentation can be found at the [Python-RSA homepage](https://stuvel.eu/rsa). For all changes, check [the changelog](https://github.com/sybrenstuvel/python-rsa/blob/master/CHANGELOG.md).
+
+Download and install using:
+
+    pip install rsa
+
+or download it from the [Python Package Index](https://pypi.org/project/rsa/).
+
+The source code is maintained at [GitHub](https://github.com/sybrenstuvel/python-rsa/) and is
+licensed under the [Apache License, version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+## Security
+
+Because of how Python internally stores numbers, it is very hard (if not impossible) to make a pure-Python program secure against timing attacks. This library is no exception, so use it with care. See https://securitypitfalls.wordpress.com/2018/08/03/constant-time-compare-in-python/ for more info.
+
+## Setup of Development Environment
+
+```
+python3 -m venv .venv
+. ./.venv/bin/activate
+pip install poetry
+poetry install
+```
+
+## Publishing a New Release
+
+```
+. ./.venv/bin/activate
+poetry publish --build
+```
+
diff --git a/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/RECORD b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/RECORD
new file mode 100644
index 0000000..6a44ab9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/RECORD
@@ -0,0 +1,31 @@
+../../../bin/pyrsa-decrypt,sha256=EjEXPboNKlVVg7E7TLK2WxfD9YSIyZxMYXa_m-HFO6A,253
+../../../bin/pyrsa-encrypt,sha256=sU1dUZX-iEAMHrV5kYkUeMYFmJeoxmQB6aY8fnC0y0w,253
+../../../bin/pyrsa-keygen,sha256=5qoFjG4M2lzLsJqUv7YvvUWOasdpKb7tDuuKHsfJDQQ,251
+../../../bin/pyrsa-priv2pub,sha256=fpIOvlSKsJGDKO2a2vPeWT66SomJYM0qrYvwQ65L6ao,274
+../../../bin/pyrsa-sign,sha256=f2kafJ9LHoK53qf5s_SUJ0i7X10ioBmcZdYZDDWw8TY,247
+../../../bin/pyrsa-verify,sha256=PoxuEvNgPrC25LFDfkkwxCY5aHjHjyUPFYXSjhU0rmo,251
+CHANGELOG.md,sha256=6Pv7qhlt3f9CeS3DyBSOXXnztIJabKqeuu6DUAwS5PU,8731
+LICENSE,sha256=Bz8ot9OJyP509gfhfCf4HqpazmntxDqITyP0G0HFxyY,577
+README.md,sha256=IDaV9Kl49NdvzNd21KOIk0wv3oqoCoI_d0n39e6FLcg,1928
+rsa/__init__.py,sha256=S4GMOa0EFaJCavhAUjiedWCmTJccbGWpMH1fntL3_9w,1605
+rsa/_compat.py,sha256=TxeP2UMfzzBLIonvsOAJeUjGUss5Jqzxf_OBZ_-U55U,1486
+rsa/asn1.py,sha256=fZPoHdVV-8ERZacGM6Wa2pW2l3F31HghGfqT9qIfs9Y,1740
+rsa/cli.py,sha256=K4tCTgNaY1h8H9c9UVRiSgeyvHsyi6Mxkgj8m55bnvI,9862
+rsa/common.py,sha256=w0UuV5HNvkFC4sBMjMDO8JTUJCoXvsLzcoJrAuqzLpA,4679
+rsa/core.py,sha256=yAj0Lg2G0HNxsa6xHMI-RF-OcIlE7GHzoBgWO7_2z5g,1661
+rsa/key.py,sha256=fpzO2aEi-01yNSOcxG6_ToQKf7Zr-a0A1GLRqU-vgUA,27531
+rsa/parallel.py,sha256=lp8ln5nEw5mWbBr9yoegvHEcawbR96GVkgCKjwPHYbk,2309
+rsa/pem.py,sha256=7eZt4U9im0hLuCMQOAMaPHi2FexxQ-a7FVXyzbJS_HM,3989
+rsa/pkcs1.py,sha256=SHBjJ0uOw9qPIm9QbP5X_kPXpMrxMtY7DR0KxPw88tE,16149
+rsa/pkcs1_v2.py,sha256=pY22h-EJHV7jaeeNjqjlen0CbMgl-UP7d9CsQceHpek,3449
+rsa/prime.py,sha256=OFpVIF3JjXzeMWdYeGEnXt1Fy3cYnHQystcltgpfoR0,5106
+rsa/py.typed,sha256=bzd2a8c8TpHiUMxJz1pUd7d9LKFo71w1NxpG1fR73JA,63
+rsa/randnum.py,sha256=23l2gOUY9Vv9f67md_16tANrbBDpUP7dW1EuDdEklUs,2657
+rsa/transform.py,sha256=n44DPrO1CZLgKXYtJkTkvhwyFTcIt1hrbD_jM0KRBu0,2200
+rsa/util.py,sha256=DC27D6LR5E9pOPvxMwlTA1Y46Irx30Yh5gW3tCyp43E,2993
+rsa-4.8.dist-info/entry_points.txt,sha256=p0nVsezmPSjm5x4GDMD4a9Sshc9ukdfw1kkmOmpaAu0,201
+rsa-4.8.dist-info/LICENSE,sha256=Bz8ot9OJyP509gfhfCf4HqpazmntxDqITyP0G0HFxyY,577
+rsa-4.8.dist-info/WHEEL,sha256=V7iVckP-GYreevsTDnv1eAinQt_aArwnAxmnP0gygBY,83
+rsa-4.8.dist-info/METADATA,sha256=A8B7kfXOU7I4Y65CFNwLYhhvbuYZlu95WS3kL-pp_jk,3061
+rsa-4.8.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+rsa-4.8.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/WHEEL
new file mode 100644
index 0000000..862df1f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry 1.0.3
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/entry_points.txt
new file mode 100644
index 0000000..bf058e3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa-4.8.dist-info/entry_points.txt
@@ -0,0 +1,8 @@
+[console_scripts]
+pyrsa-decrypt=rsa.cli:decrypt
+pyrsa-encrypt=rsa.cli:encrypt
+pyrsa-keygen=rsa.cli:keygen
+pyrsa-priv2pub=rsa.util:private_to_public
+pyrsa-sign=rsa.cli:sign
+pyrsa-verify=rsa.cli:verify
+
diff --git a/myenv/lib/python3.9/site-packages/rsa/__init__.py b/myenv/lib/python3.9/site-packages/rsa/__init__.py
new file mode 100644
index 0000000..5703023
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/__init__.py
@@ -0,0 +1,60 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""RSA module
+
+Module for calculating large primes, and RSA encryption, decryption, signing
+and verification. Includes generating public and private keys.
+
+WARNING: this implementation does not use compression of the cleartext input to
+prevent repetitions, or other common security improvements. Use with care.
+
+"""
+
+from rsa.key import newkeys, PrivateKey, PublicKey
+from rsa.pkcs1 import (
+    encrypt,
+    decrypt,
+    sign,
+    verify,
+    DecryptionError,
+    VerificationError,
+    find_signature_hash,
+    sign_hash,
+    compute_hash,
+)
+
+__author__ = "Sybren Stuvel, Barry Mead and Yesudeep Mangalapilly"
+__date__ = "2021-11-24"
+__version__ = "4.8"
+
+# Do doctest if we're run directly
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+
+__all__ = [
+    "newkeys",
+    "encrypt",
+    "decrypt",
+    "sign",
+    "verify",
+    "PublicKey",
+    "PrivateKey",
+    "DecryptionError",
+    "VerificationError",
+    "find_signature_hash",
+    "compute_hash",
+    "sign_hash",
+]
diff --git a/myenv/lib/python3.9/site-packages/rsa/_compat.py b/myenv/lib/python3.9/site-packages/rsa/_compat.py
new file mode 100644
index 0000000..050e81b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/_compat.py
@@ -0,0 +1,48 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Python compatibility wrappers."""
+
+from struct import pack
+
+
+def byte(num: int) -> bytes:
+    """
+    Converts a number between 0 and 255 (both inclusive) to a base-256 (byte)
+    representation.
+
+    :param num:
+        An unsigned integer between 0 and 255 (both inclusive).
+    :returns:
+        A single byte.
+    """
+    return pack("B", num)
+
+
+def xor_bytes(b1: bytes, b2: bytes) -> bytes:
+    """
+    Returns the bitwise XOR result between two bytes objects, b1 ^ b2.
+
+    Bitwise XOR operation is commutative, so order of parameters doesn't
+    generate different results. If parameters have different length, extra
+    length of the largest one is ignored.
+
+    :param b1:
+        First bytes object.
+    :param b2:
+        Second bytes object.
+    :returns:
+        Bytes object, result of XOR operation.
+    """
+    return bytes(x ^ y for x, y in zip(b1, b2))
diff --git a/myenv/lib/python3.9/site-packages/rsa/asn1.py b/myenv/lib/python3.9/site-packages/rsa/asn1.py
new file mode 100644
index 0000000..4cc4dd3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/asn1.py
@@ -0,0 +1,52 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""ASN.1 definitions.
+
+Not all ASN.1-handling code use these definitions, but when it does, they should be here.
+"""
+
+from pyasn1.type import univ, namedtype, tag
+
+
+class PubKeyHeader(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("oid", univ.ObjectIdentifier()),
+        namedtype.NamedType("parameters", univ.Null()),
+    )
+
+
+class OpenSSLPubKey(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("header", PubKeyHeader()),
+        # This little hack (the implicit tag) allows us to get a Bit String as Octet String
+        namedtype.NamedType(
+            "key",
+            univ.OctetString().subtype(implicitTag=tag.Tag(tagClass=0, tagFormat=0, tagId=3)),
+        ),
+    )
+
+
+class AsnPubKey(univ.Sequence):
+    """ASN.1 contents of DER encoded public key:
+
+    RSAPublicKey ::= SEQUENCE {
+         modulus           INTEGER,  -- n
+         publicExponent    INTEGER,  -- e
+    """
+
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("modulus", univ.Integer()),
+        namedtype.NamedType("publicExponent", univ.Integer()),
+    )
diff --git a/myenv/lib/python3.9/site-packages/rsa/cli.py b/myenv/lib/python3.9/site-packages/rsa/cli.py
new file mode 100644
index 0000000..4db3f0b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/cli.py
@@ -0,0 +1,321 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Commandline scripts.
+
+These scripts are called by the executables defined in setup.py.
+"""
+
+import abc
+import sys
+import typing
+import optparse
+
+import rsa
+import rsa.key
+import rsa.pkcs1
+
+HASH_METHODS = sorted(rsa.pkcs1.HASH_METHODS.keys())
+Indexable = typing.Union[typing.Tuple, typing.List[str]]
+
+
+def keygen() -> None:
+    """Key generator."""
+
+    # Parse the CLI options
+    parser = optparse.OptionParser(
+        usage="usage: %prog [options] keysize",
+        description='Generates a new RSA key pair of "keysize" bits.',
+    )
+
+    parser.add_option(
+        "--pubout",
+        type="string",
+        help="Output filename for the public key. The public key is "
+        "not saved if this option is not present. You can use "
+        "pyrsa-priv2pub to create the public key file later.",
+    )
+
+    parser.add_option(
+        "-o",
+        "--out",
+        type="string",
+        help="Output filename for the private key. The key is "
+        "written to stdout if this option is not present.",
+    )
+
+    parser.add_option(
+        "--form",
+        help="key format of the private and public keys - default PEM",
+        choices=("PEM", "DER"),
+        default="PEM",
+    )
+
+    (cli, cli_args) = parser.parse_args(sys.argv[1:])
+
+    if len(cli_args) != 1:
+        parser.print_help()
+        raise SystemExit(1)
+
+    try:
+        keysize = int(cli_args[0])
+    except ValueError as ex:
+        parser.print_help()
+        print("Not a valid number: %s" % cli_args[0], file=sys.stderr)
+        raise SystemExit(1) from ex
+
+    print("Generating %i-bit key" % keysize, file=sys.stderr)
+    (pub_key, priv_key) = rsa.newkeys(keysize)
+
+    # Save public key
+    if cli.pubout:
+        print("Writing public key to %s" % cli.pubout, file=sys.stderr)
+        data = pub_key.save_pkcs1(format=cli.form)
+        with open(cli.pubout, "wb") as outfile:
+            outfile.write(data)
+
+    # Save private key
+    data = priv_key.save_pkcs1(format=cli.form)
+
+    if cli.out:
+        print("Writing private key to %s" % cli.out, file=sys.stderr)
+        with open(cli.out, "wb") as outfile:
+            outfile.write(data)
+    else:
+        print("Writing private key to stdout", file=sys.stderr)
+        sys.stdout.buffer.write(data)
+
+
+class CryptoOperation(metaclass=abc.ABCMeta):
+    """CLI callable that operates with input, output, and a key."""
+
+    keyname = "public"  # or 'private'
+    usage = "usage: %%prog [options] %(keyname)s_key"
+    description = ""
+    operation = "decrypt"
+    operation_past = "decrypted"
+    operation_progressive = "decrypting"
+    input_help = "Name of the file to %(operation)s. Reads from stdin if " "not specified."
+    output_help = (
+        "Name of the file to write the %(operation_past)s file "
+        "to. Written to stdout if this option is not present."
+    )
+    expected_cli_args = 1
+    has_output = True
+
+    key_class = rsa.PublicKey  # type: typing.Type[rsa.key.AbstractKey]
+
+    def __init__(self) -> None:
+        self.usage = self.usage % self.__class__.__dict__
+        self.input_help = self.input_help % self.__class__.__dict__
+        self.output_help = self.output_help % self.__class__.__dict__
+
+    @abc.abstractmethod
+    def perform_operation(
+        self, indata: bytes, key: rsa.key.AbstractKey, cli_args: Indexable
+    ) -> typing.Any:
+        """Performs the program's operation.
+
+        Implement in a subclass.
+
+        :returns: the data to write to the output.
+        """
+
+    def __call__(self) -> None:
+        """Runs the program."""
+
+        (cli, cli_args) = self.parse_cli()
+
+        key = self.read_key(cli_args[0], cli.keyform)
+
+        indata = self.read_infile(cli.input)
+
+        print(self.operation_progressive.title(), file=sys.stderr)
+        outdata = self.perform_operation(indata, key, cli_args)
+
+        if self.has_output:
+            self.write_outfile(outdata, cli.output)
+
+    def parse_cli(self) -> typing.Tuple[optparse.Values, typing.List[str]]:
+        """Parse the CLI options
+
+        :returns: (cli_opts, cli_args)
+        """
+
+        parser = optparse.OptionParser(usage=self.usage, description=self.description)
+
+        parser.add_option("-i", "--input", type="string", help=self.input_help)
+
+        if self.has_output:
+            parser.add_option("-o", "--output", type="string", help=self.output_help)
+
+        parser.add_option(
+            "--keyform",
+            help="Key format of the %s key - default PEM" % self.keyname,
+            choices=("PEM", "DER"),
+            default="PEM",
+        )
+
+        (cli, cli_args) = parser.parse_args(sys.argv[1:])
+
+        if len(cli_args) != self.expected_cli_args:
+            parser.print_help()
+            raise SystemExit(1)
+
+        return cli, cli_args
+
+    def read_key(self, filename: str, keyform: str) -> rsa.key.AbstractKey:
+        """Reads a public or private key."""
+
+        print("Reading %s key from %s" % (self.keyname, filename), file=sys.stderr)
+        with open(filename, "rb") as keyfile:
+            keydata = keyfile.read()
+
+        return self.key_class.load_pkcs1(keydata, keyform)
+
+    def read_infile(self, inname: str) -> bytes:
+        """Read the input file"""
+
+        if inname:
+            print("Reading input from %s" % inname, file=sys.stderr)
+            with open(inname, "rb") as infile:
+                return infile.read()
+
+        print("Reading input from stdin", file=sys.stderr)
+        return sys.stdin.buffer.read()
+
+    def write_outfile(self, outdata: bytes, outname: str) -> None:
+        """Write the output file"""
+
+        if outname:
+            print("Writing output to %s" % outname, file=sys.stderr)
+            with open(outname, "wb") as outfile:
+                outfile.write(outdata)
+        else:
+            print("Writing output to stdout", file=sys.stderr)
+            sys.stdout.buffer.write(outdata)
+
+
+class EncryptOperation(CryptoOperation):
+    """Encrypts a file."""
+
+    keyname = "public"
+    description = (
+        "Encrypts a file. The file must be shorter than the key " "length in order to be encrypted."
+    )
+    operation = "encrypt"
+    operation_past = "encrypted"
+    operation_progressive = "encrypting"
+
+    def perform_operation(
+        self, indata: bytes, pub_key: rsa.key.AbstractKey, cli_args: Indexable = ()
+    ) -> bytes:
+        """Encrypts files."""
+        assert isinstance(pub_key, rsa.key.PublicKey)
+        return rsa.encrypt(indata, pub_key)
+
+
+class DecryptOperation(CryptoOperation):
+    """Decrypts a file."""
+
+    keyname = "private"
+    description = (
+        "Decrypts a file. The original file must be shorter than "
+        "the key length in order to have been encrypted."
+    )
+    operation = "decrypt"
+    operation_past = "decrypted"
+    operation_progressive = "decrypting"
+    key_class = rsa.PrivateKey
+
+    def perform_operation(
+        self, indata: bytes, priv_key: rsa.key.AbstractKey, cli_args: Indexable = ()
+    ) -> bytes:
+        """Decrypts files."""
+        assert isinstance(priv_key, rsa.key.PrivateKey)
+        return rsa.decrypt(indata, priv_key)
+
+
+class SignOperation(CryptoOperation):
+    """Signs a file."""
+
+    keyname = "private"
+    usage = "usage: %%prog [options] private_key hash_method"
+    description = (
+        "Signs a file, outputs the signature. Choose the hash "
+        "method from %s" % ", ".join(HASH_METHODS)
+    )
+    operation = "sign"
+    operation_past = "signature"
+    operation_progressive = "Signing"
+    key_class = rsa.PrivateKey
+    expected_cli_args = 2
+
+    output_help = (
+        "Name of the file to write the signature to. Written "
+        "to stdout if this option is not present."
+    )
+
+    def perform_operation(
+        self, indata: bytes, priv_key: rsa.key.AbstractKey, cli_args: Indexable
+    ) -> bytes:
+        """Signs files."""
+        assert isinstance(priv_key, rsa.key.PrivateKey)
+
+        hash_method = cli_args[1]
+        if hash_method not in HASH_METHODS:
+            raise SystemExit("Invalid hash method, choose one of %s" % ", ".join(HASH_METHODS))
+
+        return rsa.sign(indata, priv_key, hash_method)
+
+
+class VerifyOperation(CryptoOperation):
+    """Verify a signature."""
+
+    keyname = "public"
+    usage = "usage: %%prog [options] public_key signature_file"
+    description = (
+        "Verifies a signature, exits with status 0 upon success, "
+        "prints an error message and exits with status 1 upon error."
+    )
+    operation = "verify"
+    operation_past = "verified"
+    operation_progressive = "Verifying"
+    key_class = rsa.PublicKey
+    expected_cli_args = 2
+    has_output = False
+
+    def perform_operation(
+        self, indata: bytes, pub_key: rsa.key.AbstractKey, cli_args: Indexable
+    ) -> None:
+        """Verifies files."""
+        assert isinstance(pub_key, rsa.key.PublicKey)
+
+        signature_file = cli_args[1]
+
+        with open(signature_file, "rb") as sigfile:
+            signature = sigfile.read()
+
+        try:
+            rsa.verify(indata, signature, pub_key)
+        except rsa.VerificationError as ex:
+            raise SystemExit("Verification failed.") from ex
+
+        print("Verification OK", file=sys.stderr)
+
+
+encrypt = EncryptOperation()
+decrypt = DecryptOperation()
+sign = SignOperation()
+verify = VerifyOperation()
diff --git a/myenv/lib/python3.9/site-packages/rsa/common.py b/myenv/lib/python3.9/site-packages/rsa/common.py
new file mode 100644
index 0000000..ca732e5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/common.py
@@ -0,0 +1,184 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Common functionality shared by several modules."""
+
+import typing
+
+
+class NotRelativePrimeError(ValueError):
+    def __init__(self, a: int, b: int, d: int, msg: str = "") -> None:
+        super().__init__(msg or "%d and %d are not relatively prime, divider=%i" % (a, b, d))
+        self.a = a
+        self.b = b
+        self.d = d
+
+
+def bit_size(num: int) -> int:
+    """
+    Number of bits needed to represent a integer excluding any prefix
+    0 bits.
+
+    Usage::
+
+        >>> bit_size(1023)
+        10
+        >>> bit_size(1024)
+        11
+        >>> bit_size(1025)
+        11
+
+    :param num:
+        Integer value. If num is 0, returns 0. Only the absolute value of the
+        number is considered. Therefore, signed integers will be abs(num)
+        before the number's bit length is determined.
+    :returns:
+        Returns the number of bits in the integer.
+    """
+
+    try:
+        return num.bit_length()
+    except AttributeError as ex:
+        raise TypeError("bit_size(num) only supports integers, not %r" % type(num)) from ex
+
+
+def byte_size(number: int) -> int:
+    """
+    Returns the number of bytes required to hold a specific long number.
+
+    The number of bytes is rounded up.
+
+    Usage::
+
+        >>> byte_size(1 << 1023)
+        128
+        >>> byte_size((1 << 1024) - 1)
+        128
+        >>> byte_size(1 << 1024)
+        129
+
+    :param number:
+        An unsigned integer
+    :returns:
+        The number of bytes required to hold a specific long number.
+    """
+    if number == 0:
+        return 1
+    return ceil_div(bit_size(number), 8)
+
+
+def ceil_div(num: int, div: int) -> int:
+    """
+    Returns the ceiling function of a division between `num` and `div`.
+
+    Usage::
+
+        >>> ceil_div(100, 7)
+        15
+        >>> ceil_div(100, 10)
+        10
+        >>> ceil_div(1, 4)
+        1
+
+    :param num: Division's numerator, a number
+    :param div: Division's divisor, a number
+
+    :return: Rounded up result of the division between the parameters.
+    """
+    quanta, mod = divmod(num, div)
+    if mod:
+        quanta += 1
+    return quanta
+
+
+def extended_gcd(a: int, b: int) -> typing.Tuple[int, int, int]:
+    """Returns a tuple (r, i, j) such that r = gcd(a, b) = ia + jb"""
+    # r = gcd(a,b) i = multiplicitive inverse of a mod b
+    #      or      j = multiplicitive inverse of b mod a
+    # Neg return values for i or j are made positive mod b or a respectively
+    # Iterateive Version is faster and uses much less stack space
+    x = 0
+    y = 1
+    lx = 1
+    ly = 0
+    oa = a  # Remember original a/b to remove
+    ob = b  # negative values from return results
+    while b != 0:
+        q = a // b
+        (a, b) = (b, a % b)
+        (x, lx) = ((lx - (q * x)), x)
+        (y, ly) = ((ly - (q * y)), y)
+    if lx < 0:
+        lx += ob  # If neg wrap modulo original b
+    if ly < 0:
+        ly += oa  # If neg wrap modulo original a
+    return a, lx, ly  # Return only positive values
+
+
+def inverse(x: int, n: int) -> int:
+    """Returns the inverse of x % n under multiplication, a.k.a x^-1 (mod n)
+
+    >>> inverse(7, 4)
+    3
+    >>> (inverse(143, 4) * 143) % 4
+    1
+    """
+
+    (divider, inv, _) = extended_gcd(x, n)
+
+    if divider != 1:
+        raise NotRelativePrimeError(x, n, divider)
+
+    return inv
+
+
+def crt(a_values: typing.Iterable[int], modulo_values: typing.Iterable[int]) -> int:
+    """Chinese Remainder Theorem.
+
+    Calculates x such that x = a[i] (mod m[i]) for each i.
+
+    :param a_values: the a-values of the above equation
+    :param modulo_values: the m-values of the above equation
+    :returns: x such that x = a[i] (mod m[i]) for each i
+
+
+    >>> crt([2, 3], [3, 5])
+    8
+
+    >>> crt([2, 3, 2], [3, 5, 7])
+    23
+
+    >>> crt([2, 3, 0], [7, 11, 15])
+    135
+    """
+
+    m = 1
+    x = 0
+
+    for modulo in modulo_values:
+        m *= modulo
+
+    for (m_i, a_i) in zip(modulo_values, a_values):
+        M_i = m // m_i
+        inv = inverse(M_i, m_i)
+
+        x = (x + a_i * M_i * inv) % m
+
+    return x
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
diff --git a/myenv/lib/python3.9/site-packages/rsa/core.py b/myenv/lib/python3.9/site-packages/rsa/core.py
new file mode 100644
index 0000000..84ed3f8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/core.py
@@ -0,0 +1,53 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Core mathematical operations.
+
+This is the actual core RSA implementation, which is only defined
+mathematically on integers.
+"""
+
+
+def assert_int(var: int, name: str) -> None:
+    if isinstance(var, int):
+        return
+
+    raise TypeError("%s should be an integer, not %s" % (name, var.__class__))
+
+
+def encrypt_int(message: int, ekey: int, n: int) -> int:
+    """Encrypts a message using encryption key 'ekey', working modulo n"""
+
+    assert_int(message, "message")
+    assert_int(ekey, "ekey")
+    assert_int(n, "n")
+
+    if message < 0:
+        raise ValueError("Only non-negative numbers are supported")
+
+    if message > n:
+        raise OverflowError("The message %i is too long for n=%i" % (message, n))
+
+    return pow(message, ekey, n)
+
+
+def decrypt_int(cyphertext: int, dkey: int, n: int) -> int:
+    """Decrypts a cypher text using the decryption key 'dkey', working modulo n"""
+
+    assert_int(cyphertext, "cyphertext")
+    assert_int(dkey, "dkey")
+    assert_int(n, "n")
+
+    message = pow(cyphertext, dkey, n)
+    return message
diff --git a/myenv/lib/python3.9/site-packages/rsa/key.py b/myenv/lib/python3.9/site-packages/rsa/key.py
new file mode 100644
index 0000000..1284ffc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/key.py
@@ -0,0 +1,859 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""RSA key generation code.
+
+Create new keys with the newkeys() function. It will give you a PublicKey and a
+PrivateKey object.
+
+Loading and saving keys requires the pyasn1 module. This module is imported as
+late as possible, such that other functionality will remain working in absence
+of pyasn1.
+
+.. note::
+
+    Storing public and private keys via the `pickle` module is possible.
+    However, it is insecure to load a key from an untrusted source.
+    The pickle module is not secure against erroneous or maliciously
+    constructed data. Never unpickle data received from an untrusted
+    or unauthenticated source.
+
+"""
+
+import logging
+import threading
+import typing
+import warnings
+
+import rsa.prime
+import rsa.pem
+import rsa.common
+import rsa.randnum
+import rsa.core
+
+
+log = logging.getLogger(__name__)
+DEFAULT_EXPONENT = 65537
+
+
+class AbstractKey:
+    """Abstract superclass for private and public keys."""
+
+    __slots__ = ("n", "e", "blindfac", "blindfac_inverse", "mutex")
+
+    def __init__(self, n: int, e: int) -> None:
+        self.n = n
+        self.e = e
+
+        # These will be computed properly on the first call to blind().
+        self.blindfac = self.blindfac_inverse = -1
+
+        # Used to protect updates to the blinding factor in multi-threaded
+        # environments.
+        self.mutex = threading.Lock()
+
+    @classmethod
+    def _load_pkcs1_pem(cls, keyfile: bytes) -> "AbstractKey":
+        """Loads a key in PKCS#1 PEM format, implement in a subclass.
+
+        :param keyfile: contents of a PEM-encoded file that contains
+            the public key.
+        :type keyfile: bytes
+
+        :return: the loaded key
+        :rtype: AbstractKey
+        """
+
+    @classmethod
+    def _load_pkcs1_der(cls, keyfile: bytes) -> "AbstractKey":
+        """Loads a key in PKCS#1 PEM format, implement in a subclass.
+
+        :param keyfile: contents of a DER-encoded file that contains
+            the public key.
+        :type keyfile: bytes
+
+        :return: the loaded key
+        :rtype: AbstractKey
+        """
+
+    def _save_pkcs1_pem(self) -> bytes:
+        """Saves the key in PKCS#1 PEM format, implement in a subclass.
+
+        :returns: the PEM-encoded key.
+        :rtype: bytes
+        """
+
+    def _save_pkcs1_der(self) -> bytes:
+        """Saves the key in PKCS#1 DER format, implement in a subclass.
+
+        :returns: the DER-encoded key.
+        :rtype: bytes
+        """
+
+    @classmethod
+    def load_pkcs1(cls, keyfile: bytes, format: str = "PEM") -> "AbstractKey":
+        """Loads a key in PKCS#1 DER or PEM format.
+
+        :param keyfile: contents of a DER- or PEM-encoded file that contains
+            the key.
+        :type keyfile: bytes
+        :param format: the format of the file to load; 'PEM' or 'DER'
+        :type format: str
+
+        :return: the loaded key
+        :rtype: AbstractKey
+        """
+
+        methods = {
+            "PEM": cls._load_pkcs1_pem,
+            "DER": cls._load_pkcs1_der,
+        }
+
+        method = cls._assert_format_exists(format, methods)
+        return method(keyfile)
+
+    @staticmethod
+    def _assert_format_exists(
+        file_format: str, methods: typing.Mapping[str, typing.Callable]
+    ) -> typing.Callable:
+        """Checks whether the given file format exists in 'methods'."""
+
+        try:
+            return methods[file_format]
+        except KeyError as ex:
+            formats = ", ".join(sorted(methods.keys()))
+            raise ValueError(
+                "Unsupported format: %r, try one of %s" % (file_format, formats)
+            ) from ex
+
+    def save_pkcs1(self, format: str = "PEM") -> bytes:
+        """Saves the key in PKCS#1 DER or PEM format.
+
+        :param format: the format to save; 'PEM' or 'DER'
+        :type format: str
+        :returns: the DER- or PEM-encoded key.
+        :rtype: bytes
+        """
+
+        methods = {
+            "PEM": self._save_pkcs1_pem,
+            "DER": self._save_pkcs1_der,
+        }
+
+        method = self._assert_format_exists(format, methods)
+        return method()
+
+    def blind(self, message: int) -> typing.Tuple[int, int]:
+        """Performs blinding on the message.
+
+        :param message: the message, as integer, to blind.
+        :param r: the random number to blind with.
+        :return: tuple (the blinded message, the inverse of the used blinding factor)
+
+        The blinding is such that message = unblind(decrypt(blind(encrypt(message))).
+
+        See https://en.wikipedia.org/wiki/Blinding_%28cryptography%29
+        """
+        blindfac, blindfac_inverse = self._update_blinding_factor()
+        blinded = (message * pow(blindfac, self.e, self.n)) % self.n
+        return blinded, blindfac_inverse
+
+    def unblind(self, blinded: int, blindfac_inverse: int) -> int:
+        """Performs blinding on the message using random number 'blindfac_inverse'.
+
+        :param blinded: the blinded message, as integer, to unblind.
+        :param blindfac: the factor to unblind with.
+        :return: the original message.
+
+        The blinding is such that message = unblind(decrypt(blind(encrypt(message))).
+
+        See https://en.wikipedia.org/wiki/Blinding_%28cryptography%29
+        """
+        return (blindfac_inverse * blinded) % self.n
+
+    def _initial_blinding_factor(self) -> int:
+        for _ in range(1000):
+            blind_r = rsa.randnum.randint(self.n - 1)
+            if rsa.prime.are_relatively_prime(self.n, blind_r):
+                return blind_r
+        raise RuntimeError("unable to find blinding factor")
+
+    def _update_blinding_factor(self) -> typing.Tuple[int, int]:
+        """Update blinding factors.
+
+        Computing a blinding factor is expensive, so instead this function
+        does this once, then updates the blinding factor as per section 9
+        of 'A Timing Attack against RSA with the Chinese Remainder Theorem'
+        by Werner Schindler.
+        See https://tls.mbed.org/public/WSchindler-RSA_Timing_Attack.pdf
+
+        :return: the new blinding factor and its inverse.
+        """
+
+        with self.mutex:
+            if self.blindfac < 0:
+                # Compute initial blinding factor, which is rather slow to do.
+                self.blindfac = self._initial_blinding_factor()
+                self.blindfac_inverse = rsa.common.inverse(self.blindfac, self.n)
+            else:
+                # Reuse previous blinding factor.
+                self.blindfac = pow(self.blindfac, 2, self.n)
+                self.blindfac_inverse = pow(self.blindfac_inverse, 2, self.n)
+
+            return self.blindfac, self.blindfac_inverse
+
+
+class PublicKey(AbstractKey):
+    """Represents a public RSA key.
+
+    This key is also known as the 'encryption key'. It contains the 'n' and 'e'
+    values.
+
+    Supports attributes as well as dictionary-like access. Attribute access is
+    faster, though.
+
+    >>> PublicKey(5, 3)
+    PublicKey(5, 3)
+
+    >>> key = PublicKey(5, 3)
+    >>> key.n
+    5
+    >>> key['n']
+    5
+    >>> key.e
+    3
+    >>> key['e']
+    3
+
+    """
+
+    __slots__ = ("n", "e")
+
+    def __getitem__(self, key: str) -> int:
+        return getattr(self, key)
+
+    def __repr__(self) -> str:
+        return "PublicKey(%i, %i)" % (self.n, self.e)
+
+    def __getstate__(self) -> typing.Tuple[int, int]:
+        """Returns the key as tuple for pickling."""
+        return self.n, self.e
+
+    def __setstate__(self, state: typing.Tuple[int, int]) -> None:
+        """Sets the key from tuple."""
+        self.n, self.e = state
+        AbstractKey.__init__(self, self.n, self.e)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if other is None:
+            return False
+
+        if not isinstance(other, PublicKey):
+            return False
+
+        return self.n == other.n and self.e == other.e
+
+    def __ne__(self, other: typing.Any) -> bool:
+        return not (self == other)
+
+    def __hash__(self) -> int:
+        return hash((self.n, self.e))
+
+    @classmethod
+    def _load_pkcs1_der(cls, keyfile: bytes) -> "PublicKey":
+        """Loads a key in PKCS#1 DER format.
+
+        :param keyfile: contents of a DER-encoded file that contains the public
+            key.
+        :return: a PublicKey object
+
+        First let's construct a DER encoded key:
+
+        >>> import base64
+        >>> b64der = 'MAwCBQCNGmYtAgMBAAE='
+        >>> der = base64.standard_b64decode(b64der)
+
+        This loads the file:
+
+        >>> PublicKey._load_pkcs1_der(der)
+        PublicKey(2367317549, 65537)
+
+        """
+
+        from pyasn1.codec.der import decoder
+        from rsa.asn1 import AsnPubKey
+
+        (priv, _) = decoder.decode(keyfile, asn1Spec=AsnPubKey())
+        return cls(n=int(priv["modulus"]), e=int(priv["publicExponent"]))
+
+    def _save_pkcs1_der(self) -> bytes:
+        """Saves the public key in PKCS#1 DER format.
+
+        :returns: the DER-encoded public key.
+        :rtype: bytes
+        """
+
+        from pyasn1.codec.der import encoder
+        from rsa.asn1 import AsnPubKey
+
+        # Create the ASN object
+        asn_key = AsnPubKey()
+        asn_key.setComponentByName("modulus", self.n)
+        asn_key.setComponentByName("publicExponent", self.e)
+
+        return encoder.encode(asn_key)
+
+    @classmethod
+    def _load_pkcs1_pem(cls, keyfile: bytes) -> "PublicKey":
+        """Loads a PKCS#1 PEM-encoded public key file.
+
+        The contents of the file before the "-----BEGIN RSA PUBLIC KEY-----" and
+        after the "-----END RSA PUBLIC KEY-----" lines is ignored.
+
+        :param keyfile: contents of a PEM-encoded file that contains the public
+            key.
+        :return: a PublicKey object
+        """
+
+        der = rsa.pem.load_pem(keyfile, "RSA PUBLIC KEY")
+        return cls._load_pkcs1_der(der)
+
+    def _save_pkcs1_pem(self) -> bytes:
+        """Saves a PKCS#1 PEM-encoded public key file.
+
+        :return: contents of a PEM-encoded file that contains the public key.
+        :rtype: bytes
+        """
+
+        der = self._save_pkcs1_der()
+        return rsa.pem.save_pem(der, "RSA PUBLIC KEY")
+
+    @classmethod
+    def load_pkcs1_openssl_pem(cls, keyfile: bytes) -> "PublicKey":
+        """Loads a PKCS#1.5 PEM-encoded public key file from OpenSSL.
+
+        These files can be recognised in that they start with BEGIN PUBLIC KEY
+        rather than BEGIN RSA PUBLIC KEY.
+
+        The contents of the file before the "-----BEGIN PUBLIC KEY-----" and
+        after the "-----END PUBLIC KEY-----" lines is ignored.
+
+        :param keyfile: contents of a PEM-encoded file that contains the public
+            key, from OpenSSL.
+        :type keyfile: bytes
+        :return: a PublicKey object
+        """
+
+        der = rsa.pem.load_pem(keyfile, "PUBLIC KEY")
+        return cls.load_pkcs1_openssl_der(der)
+
+    @classmethod
+    def load_pkcs1_openssl_der(cls, keyfile: bytes) -> "PublicKey":
+        """Loads a PKCS#1 DER-encoded public key file from OpenSSL.
+
+        :param keyfile: contents of a DER-encoded file that contains the public
+            key, from OpenSSL.
+        :return: a PublicKey object
+        """
+
+        from rsa.asn1 import OpenSSLPubKey
+        from pyasn1.codec.der import decoder
+        from pyasn1.type import univ
+
+        (keyinfo, _) = decoder.decode(keyfile, asn1Spec=OpenSSLPubKey())
+
+        if keyinfo["header"]["oid"] != univ.ObjectIdentifier("1.2.840.113549.1.1.1"):
+            raise TypeError("This is not a DER-encoded OpenSSL-compatible public key")
+
+        return cls._load_pkcs1_der(keyinfo["key"][1:])
+
+
+class PrivateKey(AbstractKey):
+    """Represents a private RSA key.
+
+    This key is also known as the 'decryption key'. It contains the 'n', 'e',
+    'd', 'p', 'q' and other values.
+
+    Supports attributes as well as dictionary-like access. Attribute access is
+    faster, though.
+
+    >>> PrivateKey(3247, 65537, 833, 191, 17)
+    PrivateKey(3247, 65537, 833, 191, 17)
+
+    exp1, exp2 and coef will be calculated:
+
+    >>> pk = PrivateKey(3727264081, 65537, 3349121513, 65063, 57287)
+    >>> pk.exp1
+    55063
+    >>> pk.exp2
+    10095
+    >>> pk.coef
+    50797
+
+    """
+
+    __slots__ = ("n", "e", "d", "p", "q", "exp1", "exp2", "coef")
+
+    def __init__(self, n: int, e: int, d: int, p: int, q: int) -> None:
+        AbstractKey.__init__(self, n, e)
+        self.d = d
+        self.p = p
+        self.q = q
+
+        # Calculate exponents and coefficient.
+        self.exp1 = int(d % (p - 1))
+        self.exp2 = int(d % (q - 1))
+        self.coef = rsa.common.inverse(q, p)
+
+    def __getitem__(self, key: str) -> int:
+        return getattr(self, key)
+
+    def __repr__(self) -> str:
+        return "PrivateKey(%i, %i, %i, %i, %i)" % (
+            self.n,
+            self.e,
+            self.d,
+            self.p,
+            self.q,
+        )
+
+    def __getstate__(self) -> typing.Tuple[int, int, int, int, int, int, int, int]:
+        """Returns the key as tuple for pickling."""
+        return self.n, self.e, self.d, self.p, self.q, self.exp1, self.exp2, self.coef
+
+    def __setstate__(self, state: typing.Tuple[int, int, int, int, int, int, int, int]) -> None:
+        """Sets the key from tuple."""
+        self.n, self.e, self.d, self.p, self.q, self.exp1, self.exp2, self.coef = state
+        AbstractKey.__init__(self, self.n, self.e)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if other is None:
+            return False
+
+        if not isinstance(other, PrivateKey):
+            return False
+
+        return (
+            self.n == other.n
+            and self.e == other.e
+            and self.d == other.d
+            and self.p == other.p
+            and self.q == other.q
+            and self.exp1 == other.exp1
+            and self.exp2 == other.exp2
+            and self.coef == other.coef
+        )
+
+    def __ne__(self, other: typing.Any) -> bool:
+        return not (self == other)
+
+    def __hash__(self) -> int:
+        return hash((self.n, self.e, self.d, self.p, self.q, self.exp1, self.exp2, self.coef))
+
+    def blinded_decrypt(self, encrypted: int) -> int:
+        """Decrypts the message using blinding to prevent side-channel attacks.
+
+        :param encrypted: the encrypted message
+        :type encrypted: int
+
+        :returns: the decrypted message
+        :rtype: int
+        """
+
+        # Blinding and un-blinding should be using the same factor
+        blinded, blindfac_inverse = self.blind(encrypted)
+
+        # Instead of using the core functionality, use the Chinese Remainder
+        # Theorem and be 2-4x faster. This the same as:
+        #
+        # decrypted = rsa.core.decrypt_int(blinded, self.d, self.n)
+        s1 = pow(blinded, self.exp1, self.p)
+        s2 = pow(blinded, self.exp2, self.q)
+        h = ((s1 - s2) * self.coef) % self.p
+        decrypted = s2 + self.q * h
+
+        return self.unblind(decrypted, blindfac_inverse)
+
+    def blinded_encrypt(self, message: int) -> int:
+        """Encrypts the message using blinding to prevent side-channel attacks.
+
+        :param message: the message to encrypt
+        :type message: int
+
+        :returns: the encrypted message
+        :rtype: int
+        """
+
+        blinded, blindfac_inverse = self.blind(message)
+        encrypted = rsa.core.encrypt_int(blinded, self.d, self.n)
+        return self.unblind(encrypted, blindfac_inverse)
+
+    @classmethod
+    def _load_pkcs1_der(cls, keyfile: bytes) -> "PrivateKey":
+        """Loads a key in PKCS#1 DER format.
+
+        :param keyfile: contents of a DER-encoded file that contains the private
+            key.
+        :type keyfile: bytes
+        :return: a PrivateKey object
+
+        First let's construct a DER encoded key:
+
+        >>> import base64
+        >>> b64der = 'MC4CAQACBQDeKYlRAgMBAAECBQDHn4npAgMA/icCAwDfxwIDANcXAgInbwIDAMZt'
+        >>> der = base64.standard_b64decode(b64der)
+
+        This loads the file:
+
+        >>> PrivateKey._load_pkcs1_der(der)
+        PrivateKey(3727264081, 65537, 3349121513, 65063, 57287)
+
+        """
+
+        from pyasn1.codec.der import decoder
+
+        (priv, _) = decoder.decode(keyfile)
+
+        # ASN.1 contents of DER encoded private key:
+        #
+        # RSAPrivateKey ::= SEQUENCE {
+        #     version           Version,
+        #     modulus           INTEGER,  -- n
+        #     publicExponent    INTEGER,  -- e
+        #     privateExponent   INTEGER,  -- d
+        #     prime1            INTEGER,  -- p
+        #     prime2            INTEGER,  -- q
+        #     exponent1         INTEGER,  -- d mod (p-1)
+        #     exponent2         INTEGER,  -- d mod (q-1)
+        #     coefficient       INTEGER,  -- (inverse of q) mod p
+        #     otherPrimeInfos   OtherPrimeInfos OPTIONAL
+        # }
+
+        if priv[0] != 0:
+            raise ValueError("Unable to read this file, version %s != 0" % priv[0])
+
+        as_ints = map(int, priv[1:6])
+        key = cls(*as_ints)
+
+        exp1, exp2, coef = map(int, priv[6:9])
+
+        if (key.exp1, key.exp2, key.coef) != (exp1, exp2, coef):
+            warnings.warn(
+                "You have provided a malformed keyfile. Either the exponents "
+                "or the coefficient are incorrect. Using the correct values "
+                "instead.",
+                UserWarning,
+            )
+
+        return key
+
+    def _save_pkcs1_der(self) -> bytes:
+        """Saves the private key in PKCS#1 DER format.
+
+        :returns: the DER-encoded private key.
+        :rtype: bytes
+        """
+
+        from pyasn1.type import univ, namedtype
+        from pyasn1.codec.der import encoder
+
+        class AsnPrivKey(univ.Sequence):
+            componentType = namedtype.NamedTypes(
+                namedtype.NamedType("version", univ.Integer()),
+                namedtype.NamedType("modulus", univ.Integer()),
+                namedtype.NamedType("publicExponent", univ.Integer()),
+                namedtype.NamedType("privateExponent", univ.Integer()),
+                namedtype.NamedType("prime1", univ.Integer()),
+                namedtype.NamedType("prime2", univ.Integer()),
+                namedtype.NamedType("exponent1", univ.Integer()),
+                namedtype.NamedType("exponent2", univ.Integer()),
+                namedtype.NamedType("coefficient", univ.Integer()),
+            )
+
+        # Create the ASN object
+        asn_key = AsnPrivKey()
+        asn_key.setComponentByName("version", 0)
+        asn_key.setComponentByName("modulus", self.n)
+        asn_key.setComponentByName("publicExponent", self.e)
+        asn_key.setComponentByName("privateExponent", self.d)
+        asn_key.setComponentByName("prime1", self.p)
+        asn_key.setComponentByName("prime2", self.q)
+        asn_key.setComponentByName("exponent1", self.exp1)
+        asn_key.setComponentByName("exponent2", self.exp2)
+        asn_key.setComponentByName("coefficient", self.coef)
+
+        return encoder.encode(asn_key)
+
+    @classmethod
+    def _load_pkcs1_pem(cls, keyfile: bytes) -> "PrivateKey":
+        """Loads a PKCS#1 PEM-encoded private key file.
+
+        The contents of the file before the "-----BEGIN RSA PRIVATE KEY-----" and
+        after the "-----END RSA PRIVATE KEY-----" lines is ignored.
+
+        :param keyfile: contents of a PEM-encoded file that contains the private
+            key.
+        :type keyfile: bytes
+        :return: a PrivateKey object
+        """
+
+        der = rsa.pem.load_pem(keyfile, b"RSA PRIVATE KEY")
+        return cls._load_pkcs1_der(der)
+
+    def _save_pkcs1_pem(self) -> bytes:
+        """Saves a PKCS#1 PEM-encoded private key file.
+
+        :return: contents of a PEM-encoded file that contains the private key.
+        :rtype: bytes
+        """
+
+        der = self._save_pkcs1_der()
+        return rsa.pem.save_pem(der, b"RSA PRIVATE KEY")
+
+
+def find_p_q(
+    nbits: int,
+    getprime_func: typing.Callable[[int], int] = rsa.prime.getprime,
+    accurate: bool = True,
+) -> typing.Tuple[int, int]:
+    """Returns a tuple of two different primes of nbits bits each.
+
+    The resulting p * q has exactly 2 * nbits bits, and the returned p and q
+    will not be equal.
+
+    :param nbits: the number of bits in each of p and q.
+    :param getprime_func: the getprime function, defaults to
+        :py:func:`rsa.prime.getprime`.
+
+        *Introduced in Python-RSA 3.1*
+
+    :param accurate: whether to enable accurate mode or not.
+    :returns: (p, q), where p > q
+
+    >>> (p, q) = find_p_q(128)
+    >>> from rsa import common
+    >>> common.bit_size(p * q)
+    256
+
+    When not in accurate mode, the number of bits can be slightly less
+
+    >>> (p, q) = find_p_q(128, accurate=False)
+    >>> from rsa import common
+    >>> common.bit_size(p * q) <= 256
+    True
+    >>> common.bit_size(p * q) > 240
+    True
+
+    """
+
+    total_bits = nbits * 2
+
+    # Make sure that p and q aren't too close or the factoring programs can
+    # factor n.
+    shift = nbits // 16
+    pbits = nbits + shift
+    qbits = nbits - shift
+
+    # Choose the two initial primes
+    log.debug("find_p_q(%i): Finding p", nbits)
+    p = getprime_func(pbits)
+    log.debug("find_p_q(%i): Finding q", nbits)
+    q = getprime_func(qbits)
+
+    def is_acceptable(p: int, q: int) -> bool:
+        """Returns True iff p and q are acceptable:
+
+        - p and q differ
+        - (p * q) has the right nr of bits (when accurate=True)
+        """
+
+        if p == q:
+            return False
+
+        if not accurate:
+            return True
+
+        # Make sure we have just the right amount of bits
+        found_size = rsa.common.bit_size(p * q)
+        return total_bits == found_size
+
+    # Keep choosing other primes until they match our requirements.
+    change_p = False
+    while not is_acceptable(p, q):
+        # Change p on one iteration and q on the other
+        if change_p:
+            p = getprime_func(pbits)
+        else:
+            q = getprime_func(qbits)
+
+        change_p = not change_p
+
+    # We want p > q as described on
+    # http://www.di-mgt.com.au/rsa_alg.html#crt
+    return max(p, q), min(p, q)
+
+
+def calculate_keys_custom_exponent(p: int, q: int, exponent: int) -> typing.Tuple[int, int]:
+    """Calculates an encryption and a decryption key given p, q and an exponent,
+    and returns them as a tuple (e, d)
+
+    :param p: the first large prime
+    :param q: the second large prime
+    :param exponent: the exponent for the key; only change this if you know
+        what you're doing, as the exponent influences how difficult your
+        private key can be cracked. A very common choice for e is 65537.
+    :type exponent: int
+
+    """
+
+    phi_n = (p - 1) * (q - 1)
+
+    try:
+        d = rsa.common.inverse(exponent, phi_n)
+    except rsa.common.NotRelativePrimeError as ex:
+        raise rsa.common.NotRelativePrimeError(
+            exponent,
+            phi_n,
+            ex.d,
+            msg="e (%d) and phi_n (%d) are not relatively prime (divider=%i)"
+            % (exponent, phi_n, ex.d),
+        ) from ex
+
+    if (exponent * d) % phi_n != 1:
+        raise ValueError(
+            "e (%d) and d (%d) are not mult. inv. modulo " "phi_n (%d)" % (exponent, d, phi_n)
+        )
+
+    return exponent, d
+
+
+def calculate_keys(p: int, q: int) -> typing.Tuple[int, int]:
+    """Calculates an encryption and a decryption key given p and q, and
+    returns them as a tuple (e, d)
+
+    :param p: the first large prime
+    :param q: the second large prime
+
+    :return: tuple (e, d) with the encryption and decryption exponents.
+    """
+
+    return calculate_keys_custom_exponent(p, q, DEFAULT_EXPONENT)
+
+
+def gen_keys(
+    nbits: int,
+    getprime_func: typing.Callable[[int], int],
+    accurate: bool = True,
+    exponent: int = DEFAULT_EXPONENT,
+) -> typing.Tuple[int, int, int, int]:
+    """Generate RSA keys of nbits bits. Returns (p, q, e, d).
+
+    Note: this can take a long time, depending on the key size.
+
+    :param nbits: the total number of bits in ``p`` and ``q``. Both ``p`` and
+        ``q`` will use ``nbits/2`` bits.
+    :param getprime_func: either :py:func:`rsa.prime.getprime` or a function
+        with similar signature.
+    :param exponent: the exponent for the key; only change this if you know
+        what you're doing, as the exponent influences how difficult your
+        private key can be cracked. A very common choice for e is 65537.
+    :type exponent: int
+    """
+
+    # Regenerate p and q values, until calculate_keys doesn't raise a
+    # ValueError.
+    while True:
+        (p, q) = find_p_q(nbits // 2, getprime_func, accurate)
+        try:
+            (e, d) = calculate_keys_custom_exponent(p, q, exponent=exponent)
+            break
+        except ValueError:
+            pass
+
+    return p, q, e, d
+
+
+def newkeys(
+    nbits: int,
+    accurate: bool = True,
+    poolsize: int = 1,
+    exponent: int = DEFAULT_EXPONENT,
+) -> typing.Tuple[PublicKey, PrivateKey]:
+    """Generates public and private keys, and returns them as (pub, priv).
+
+    The public key is also known as the 'encryption key', and is a
+    :py:class:`rsa.PublicKey` object. The private key is also known as the
+    'decryption key' and is a :py:class:`rsa.PrivateKey` object.
+
+    :param nbits: the number of bits required to store ``n = p*q``.
+    :param accurate: when True, ``n`` will have exactly the number of bits you
+        asked for. However, this makes key generation much slower. When False,
+        `n`` may have slightly less bits.
+    :param poolsize: the number of processes to use to generate the prime
+        numbers. If set to a number > 1, a parallel algorithm will be used.
+        This requires Python 2.6 or newer.
+    :param exponent: the exponent for the key; only change this if you know
+        what you're doing, as the exponent influences how difficult your
+        private key can be cracked. A very common choice for e is 65537.
+    :type exponent: int
+
+    :returns: a tuple (:py:class:`rsa.PublicKey`, :py:class:`rsa.PrivateKey`)
+
+    The ``poolsize`` parameter was added in *Python-RSA 3.1* and requires
+    Python 2.6 or newer.
+
+    """
+
+    if nbits < 16:
+        raise ValueError("Key too small")
+
+    if poolsize < 1:
+        raise ValueError("Pool size (%i) should be >= 1" % poolsize)
+
+    # Determine which getprime function to use
+    if poolsize > 1:
+        from rsa import parallel
+
+        def getprime_func(nbits: int) -> int:
+            return parallel.getprime(nbits, poolsize=poolsize)
+
+    else:
+        getprime_func = rsa.prime.getprime
+
+    # Generate the key components
+    (p, q, e, d) = gen_keys(nbits, getprime_func, accurate=accurate, exponent=exponent)
+
+    # Create the key objects
+    n = p * q
+
+    return (PublicKey(n, e), PrivateKey(n, e, d, p, q))
+
+
+__all__ = ["PublicKey", "PrivateKey", "newkeys"]
+
+if __name__ == "__main__":
+    import doctest
+
+    try:
+        for count in range(100):
+            (failures, tests) = doctest.testmod()
+            if failures:
+                break
+
+            if (count % 10 == 0 and count) or count == 1:
+                print("%i times" % count)
+    except KeyboardInterrupt:
+        print("Aborted")
+    else:
+        print("Doctests done")
diff --git a/myenv/lib/python3.9/site-packages/rsa/parallel.py b/myenv/lib/python3.9/site-packages/rsa/parallel.py
new file mode 100644
index 0000000..5020edb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/parallel.py
@@ -0,0 +1,96 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Functions for parallel computation on multiple cores.
+
+Introduced in Python-RSA 3.1.
+
+.. note::
+
+    Requires Python 2.6 or newer.
+
+"""
+
+import multiprocessing as mp
+from multiprocessing.connection import Connection
+
+import rsa.prime
+import rsa.randnum
+
+
+def _find_prime(nbits: int, pipe: Connection) -> None:
+    while True:
+        integer = rsa.randnum.read_random_odd_int(nbits)
+
+        # Test for primeness
+        if rsa.prime.is_prime(integer):
+            pipe.send(integer)
+            return
+
+
+def getprime(nbits: int, poolsize: int) -> int:
+    """Returns a prime number that can be stored in 'nbits' bits.
+
+    Works in multiple threads at the same time.
+
+    >>> p = getprime(128, 3)
+    >>> rsa.prime.is_prime(p-1)
+    False
+    >>> rsa.prime.is_prime(p)
+    True
+    >>> rsa.prime.is_prime(p+1)
+    False
+
+    >>> from rsa import common
+    >>> common.bit_size(p) == 128
+    True
+
+    """
+
+    (pipe_recv, pipe_send) = mp.Pipe(duplex=False)
+
+    # Create processes
+    try:
+        procs = [mp.Process(target=_find_prime, args=(nbits, pipe_send)) for _ in range(poolsize)]
+        # Start processes
+        for p in procs:
+            p.start()
+
+        result = pipe_recv.recv()
+    finally:
+        pipe_recv.close()
+        pipe_send.close()
+
+    # Terminate processes
+    for p in procs:
+        p.terminate()
+
+    return result
+
+
+__all__ = ["getprime"]
+
+if __name__ == "__main__":
+    print("Running doctests 1000x or until failure")
+    import doctest
+
+    for count in range(100):
+        (failures, tests) = doctest.testmod()
+        if failures:
+            break
+
+        if count % 10 == 0 and count:
+            print("%i times" % count)
+
+    print("Doctests done")
diff --git a/myenv/lib/python3.9/site-packages/rsa/pem.py b/myenv/lib/python3.9/site-packages/rsa/pem.py
new file mode 100644
index 0000000..5d26e6e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/pem.py
@@ -0,0 +1,134 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Functions that load and write PEM-encoded files."""
+
+import base64
+import typing
+
+# Should either be ASCII strings or bytes.
+FlexiText = typing.Union[str, bytes]
+
+
+def _markers(pem_marker: FlexiText) -> typing.Tuple[bytes, bytes]:
+    """
+    Returns the start and end PEM markers, as bytes.
+    """
+
+    if not isinstance(pem_marker, bytes):
+        pem_marker = pem_marker.encode("ascii")
+
+    return (
+        b"-----BEGIN " + pem_marker + b"-----",
+        b"-----END " + pem_marker + b"-----",
+    )
+
+
+def _pem_lines(contents: bytes, pem_start: bytes, pem_end: bytes) -> typing.Iterator[bytes]:
+    """Generator over PEM lines between pem_start and pem_end."""
+
+    in_pem_part = False
+    seen_pem_start = False
+
+    for line in contents.splitlines():
+        line = line.strip()
+
+        # Skip empty lines
+        if not line:
+            continue
+
+        # Handle start marker
+        if line == pem_start:
+            if in_pem_part:
+                raise ValueError('Seen start marker "%r" twice' % pem_start)
+
+            in_pem_part = True
+            seen_pem_start = True
+            continue
+
+        # Skip stuff before first marker
+        if not in_pem_part:
+            continue
+
+        # Handle end marker
+        if in_pem_part and line == pem_end:
+            in_pem_part = False
+            break
+
+        # Load fields
+        if b":" in line:
+            continue
+
+        yield line
+
+    # Do some sanity checks
+    if not seen_pem_start:
+        raise ValueError('No PEM start marker "%r" found' % pem_start)
+
+    if in_pem_part:
+        raise ValueError('No PEM end marker "%r" found' % pem_end)
+
+
+def load_pem(contents: FlexiText, pem_marker: FlexiText) -> bytes:
+    """Loads a PEM file.
+
+    :param contents: the contents of the file to interpret
+    :param pem_marker: the marker of the PEM content, such as 'RSA PRIVATE KEY'
+        when your file has '-----BEGIN RSA PRIVATE KEY-----' and
+        '-----END RSA PRIVATE KEY-----' markers.
+
+    :return: the base64-decoded content between the start and end markers.
+
+    @raise ValueError: when the content is invalid, for example when the start
+        marker cannot be found.
+
+    """
+
+    # We want bytes, not text. If it's text, it can be converted to ASCII bytes.
+    if not isinstance(contents, bytes):
+        contents = contents.encode("ascii")
+
+    (pem_start, pem_end) = _markers(pem_marker)
+    pem_lines = [line for line in _pem_lines(contents, pem_start, pem_end)]
+
+    # Base64-decode the contents
+    pem = b"".join(pem_lines)
+    return base64.standard_b64decode(pem)
+
+
+def save_pem(contents: bytes, pem_marker: FlexiText) -> bytes:
+    """Saves a PEM file.
+
+    :param contents: the contents to encode in PEM format
+    :param pem_marker: the marker of the PEM content, such as 'RSA PRIVATE KEY'
+        when your file has '-----BEGIN RSA PRIVATE KEY-----' and
+        '-----END RSA PRIVATE KEY-----' markers.
+
+    :return: the base64-encoded content between the start and end markers, as bytes.
+
+    """
+
+    (pem_start, pem_end) = _markers(pem_marker)
+
+    b64 = base64.standard_b64encode(contents).replace(b"\n", b"")
+    pem_lines = [pem_start]
+
+    for block_start in range(0, len(b64), 64):
+        block = b64[block_start : block_start + 64]
+        pem_lines.append(block)
+
+    pem_lines.append(pem_end)
+    pem_lines.append(b"")
+
+    return b"\n".join(pem_lines)
diff --git a/myenv/lib/python3.9/site-packages/rsa/pkcs1.py b/myenv/lib/python3.9/site-packages/rsa/pkcs1.py
new file mode 100644
index 0000000..3837a69
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/pkcs1.py
@@ -0,0 +1,484 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Functions for PKCS#1 version 1.5 encryption and signing
+
+This module implements certain functionality from PKCS#1 version 1.5. For a
+very clear example, read http://www.di-mgt.com.au/rsa_alg.html#pkcs1schemes
+
+At least 8 bytes of random padding is used when encrypting a message. This makes
+these methods much more secure than the ones in the ``rsa`` module.
+
+WARNING: this module leaks information when decryption fails. The exceptions
+that are raised contain the Python traceback information, which can be used to
+deduce where in the process the failure occurred. DO NOT PASS SUCH INFORMATION
+to your users.
+"""
+
+import hashlib
+import os
+import sys
+import typing
+from hmac import compare_digest
+
+from . import common, transform, core, key
+
+if typing.TYPE_CHECKING:
+    HashType = hashlib._Hash
+else:
+    HashType = typing.Any
+
+# ASN.1 codes that describe the hash algorithm used.
+HASH_ASN1 = {
+    "MD5": b"\x30\x20\x30\x0c\x06\x08\x2a\x86\x48\x86\xf7\x0d\x02\x05\x05\x00\x04\x10",
+    "SHA-1": b"\x30\x21\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x04\x14",
+    "SHA-224": b"\x30\x2d\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x04\x05\x00\x04\x1c",
+    "SHA-256": b"\x30\x31\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x01\x05\x00\x04\x20",
+    "SHA-384": b"\x30\x41\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x02\x05\x00\x04\x30",
+    "SHA-512": b"\x30\x51\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x03\x05\x00\x04\x40",
+}
+
+HASH_METHODS: typing.Dict[str, typing.Callable[[], HashType]] = {
+    "MD5": hashlib.md5,
+    "SHA-1": hashlib.sha1,
+    "SHA-224": hashlib.sha224,
+    "SHA-256": hashlib.sha256,
+    "SHA-384": hashlib.sha384,
+    "SHA-512": hashlib.sha512,
+}
+
+
+if sys.version_info >= (3, 6):
+    # Python 3.6 introduced SHA3 support.
+    HASH_ASN1.update(
+        {
+            "SHA3-256": b"\x30\x31\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x08\x05\x00\x04\x20",
+            "SHA3-384": b"\x30\x41\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x09\x05\x00\x04\x30",
+            "SHA3-512": b"\x30\x51\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x0a\x05\x00\x04\x40",
+        }
+    )
+
+    HASH_METHODS.update(
+        {
+            "SHA3-256": hashlib.sha3_256,
+            "SHA3-384": hashlib.sha3_384,
+            "SHA3-512": hashlib.sha3_512,
+        }
+    )
+
+
+class CryptoError(Exception):
+    """Base class for all exceptions in this module."""
+
+
+class DecryptionError(CryptoError):
+    """Raised when decryption fails."""
+
+
+class VerificationError(CryptoError):
+    """Raised when verification fails."""
+
+
+def _pad_for_encryption(message: bytes, target_length: int) -> bytes:
+    r"""Pads the message for encryption, returning the padded message.
+
+    :return: 00 02 RANDOM_DATA 00 MESSAGE
+
+    >>> block = _pad_for_encryption(b'hello', 16)
+    >>> len(block)
+    16
+    >>> block[0:2]
+    b'\x00\x02'
+    >>> block[-6:]
+    b'\x00hello'
+
+    """
+
+    max_msglength = target_length - 11
+    msglength = len(message)
+
+    if msglength > max_msglength:
+        raise OverflowError(
+            "%i bytes needed for message, but there is only"
+            " space for %i" % (msglength, max_msglength)
+        )
+
+    # Get random padding
+    padding = b""
+    padding_length = target_length - msglength - 3
+
+    # We remove 0-bytes, so we'll end up with less padding than we've asked for,
+    # so keep adding data until we're at the correct length.
+    while len(padding) < padding_length:
+        needed_bytes = padding_length - len(padding)
+
+        # Always read at least 8 bytes more than we need, and trim off the rest
+        # after removing the 0-bytes. This increases the chance of getting
+        # enough bytes, especially when needed_bytes is small
+        new_padding = os.urandom(needed_bytes + 5)
+        new_padding = new_padding.replace(b"\x00", b"")
+        padding = padding + new_padding[:needed_bytes]
+
+    assert len(padding) == padding_length
+
+    return b"".join([b"\x00\x02", padding, b"\x00", message])
+
+
+def _pad_for_signing(message: bytes, target_length: int) -> bytes:
+    r"""Pads the message for signing, returning the padded message.
+
+    The padding is always a repetition of FF bytes.
+
+    :return: 00 01 PADDING 00 MESSAGE
+
+    >>> block = _pad_for_signing(b'hello', 16)
+    >>> len(block)
+    16
+    >>> block[0:2]
+    b'\x00\x01'
+    >>> block[-6:]
+    b'\x00hello'
+    >>> block[2:-6]
+    b'\xff\xff\xff\xff\xff\xff\xff\xff'
+
+    """
+
+    max_msglength = target_length - 11
+    msglength = len(message)
+
+    if msglength > max_msglength:
+        raise OverflowError(
+            "%i bytes needed for message, but there is only"
+            " space for %i" % (msglength, max_msglength)
+        )
+
+    padding_length = target_length - msglength - 3
+
+    return b"".join([b"\x00\x01", padding_length * b"\xff", b"\x00", message])
+
+
+def encrypt(message: bytes, pub_key: key.PublicKey) -> bytes:
+    """Encrypts the given message using PKCS#1 v1.5
+
+    :param message: the message to encrypt. Must be a byte string no longer than
+        ``k-11`` bytes, where ``k`` is the number of bytes needed to encode
+        the ``n`` component of the public key.
+    :param pub_key: the :py:class:`rsa.PublicKey` to encrypt with.
+    :raise OverflowError: when the message is too large to fit in the padded
+        block.
+
+    >>> from rsa import key, common
+    >>> (pub_key, priv_key) = key.newkeys(256)
+    >>> message = b'hello'
+    >>> crypto = encrypt(message, pub_key)
+
+    The crypto text should be just as long as the public key 'n' component:
+
+    >>> len(crypto) == common.byte_size(pub_key.n)
+    True
+
+    """
+
+    keylength = common.byte_size(pub_key.n)
+    padded = _pad_for_encryption(message, keylength)
+
+    payload = transform.bytes2int(padded)
+    encrypted = core.encrypt_int(payload, pub_key.e, pub_key.n)
+    block = transform.int2bytes(encrypted, keylength)
+
+    return block
+
+
+def decrypt(crypto: bytes, priv_key: key.PrivateKey) -> bytes:
+    r"""Decrypts the given message using PKCS#1 v1.5
+
+    The decryption is considered 'failed' when the resulting cleartext doesn't
+    start with the bytes 00 02, or when the 00 byte between the padding and
+    the message cannot be found.
+
+    :param crypto: the crypto text as returned by :py:func:`rsa.encrypt`
+    :param priv_key: the :py:class:`rsa.PrivateKey` to decrypt with.
+    :raise DecryptionError: when the decryption fails. No details are given as
+        to why the code thinks the decryption fails, as this would leak
+        information about the private key.
+
+
+    >>> import rsa
+    >>> (pub_key, priv_key) = rsa.newkeys(256)
+
+    It works with strings:
+
+    >>> crypto = encrypt(b'hello', pub_key)
+    >>> decrypt(crypto, priv_key)
+    b'hello'
+
+    And with binary data:
+
+    >>> crypto = encrypt(b'\x00\x00\x00\x00\x01', pub_key)
+    >>> decrypt(crypto, priv_key)
+    b'\x00\x00\x00\x00\x01'
+
+    Altering the encrypted information will *likely* cause a
+    :py:class:`rsa.pkcs1.DecryptionError`. If you want to be *sure*, use
+    :py:func:`rsa.sign`.
+
+
+    .. warning::
+
+        Never display the stack trace of a
+        :py:class:`rsa.pkcs1.DecryptionError` exception. It shows where in the
+        code the exception occurred, and thus leaks information about the key.
+        It's only a tiny bit of information, but every bit makes cracking the
+        keys easier.
+
+    >>> crypto = encrypt(b'hello', pub_key)
+    >>> crypto = crypto[0:5] + b'X' + crypto[6:] # change a byte
+    >>> decrypt(crypto, priv_key)
+    Traceback (most recent call last):
+    ...
+    rsa.pkcs1.DecryptionError: Decryption failed
+
+    """
+
+    blocksize = common.byte_size(priv_key.n)
+    encrypted = transform.bytes2int(crypto)
+    decrypted = priv_key.blinded_decrypt(encrypted)
+    cleartext = transform.int2bytes(decrypted, blocksize)
+
+    # Detect leading zeroes in the crypto. These are not reflected in the
+    # encrypted value (as leading zeroes do not influence the value of an
+    # integer). This fixes CVE-2020-13757.
+    if len(crypto) > blocksize:
+        # This is operating on public information, so doesn't need to be constant-time.
+        raise DecryptionError("Decryption failed")
+
+    # If we can't find the cleartext marker, decryption failed.
+    cleartext_marker_bad = not compare_digest(cleartext[:2], b"\x00\x02")
+
+    # Find the 00 separator between the padding and the message
+    sep_idx = cleartext.find(b"\x00", 2)
+
+    # sep_idx indicates the position of the `\x00` separator that separates the
+    # padding from the actual message. The padding should be at least 8 bytes
+    # long (see https://tools.ietf.org/html/rfc8017#section-7.2.2 step 3), which
+    # means the separator should be at least at index 10 (because of the
+    # `\x00\x02` marker that precedes it).
+    sep_idx_bad = sep_idx < 10
+
+    anything_bad = cleartext_marker_bad | sep_idx_bad
+    if anything_bad:
+        raise DecryptionError("Decryption failed")
+
+    return cleartext[sep_idx + 1 :]
+
+
+def sign_hash(hash_value: bytes, priv_key: key.PrivateKey, hash_method: str) -> bytes:
+    """Signs a precomputed hash with the private key.
+
+    Hashes the message, then signs the hash with the given key. This is known
+    as a "detached signature", because the message itself isn't altered.
+
+    :param hash_value: A precomputed hash to sign (ignores message).
+    :param priv_key: the :py:class:`rsa.PrivateKey` to sign with
+    :param hash_method: the hash method used on the message. Use 'MD5', 'SHA-1',
+        'SHA-224', SHA-256', 'SHA-384' or 'SHA-512'.
+    :return: a message signature block.
+    :raise OverflowError: if the private key is too small to contain the
+        requested hash.
+
+    """
+
+    # Get the ASN1 code for this hash method
+    if hash_method not in HASH_ASN1:
+        raise ValueError("Invalid hash method: %s" % hash_method)
+    asn1code = HASH_ASN1[hash_method]
+
+    # Encrypt the hash with the private key
+    cleartext = asn1code + hash_value
+    keylength = common.byte_size(priv_key.n)
+    padded = _pad_for_signing(cleartext, keylength)
+
+    payload = transform.bytes2int(padded)
+    encrypted = priv_key.blinded_encrypt(payload)
+    block = transform.int2bytes(encrypted, keylength)
+
+    return block
+
+
+def sign(message: bytes, priv_key: key.PrivateKey, hash_method: str) -> bytes:
+    """Signs the message with the private key.
+
+    Hashes the message, then signs the hash with the given key. This is known
+    as a "detached signature", because the message itself isn't altered.
+
+    :param message: the message to sign. Can be an 8-bit string or a file-like
+        object. If ``message`` has a ``read()`` method, it is assumed to be a
+        file-like object.
+    :param priv_key: the :py:class:`rsa.PrivateKey` to sign with
+    :param hash_method: the hash method used on the message. Use 'MD5', 'SHA-1',
+        'SHA-224', SHA-256', 'SHA-384' or 'SHA-512'.
+    :return: a message signature block.
+    :raise OverflowError: if the private key is too small to contain the
+        requested hash.
+
+    """
+
+    msg_hash = compute_hash(message, hash_method)
+    return sign_hash(msg_hash, priv_key, hash_method)
+
+
+def verify(message: bytes, signature: bytes, pub_key: key.PublicKey) -> str:
+    """Verifies that the signature matches the message.
+
+    The hash method is detected automatically from the signature.
+
+    :param message: the signed message. Can be an 8-bit string or a file-like
+        object. If ``message`` has a ``read()`` method, it is assumed to be a
+        file-like object.
+    :param signature: the signature block, as created with :py:func:`rsa.sign`.
+    :param pub_key: the :py:class:`rsa.PublicKey` of the person signing the message.
+    :raise VerificationError: when the signature doesn't match the message.
+    :returns: the name of the used hash.
+
+    """
+
+    keylength = common.byte_size(pub_key.n)
+    encrypted = transform.bytes2int(signature)
+    decrypted = core.decrypt_int(encrypted, pub_key.e, pub_key.n)
+    clearsig = transform.int2bytes(decrypted, keylength)
+
+    # Get the hash method
+    method_name = _find_method_hash(clearsig)
+    message_hash = compute_hash(message, method_name)
+
+    # Reconstruct the expected padded hash
+    cleartext = HASH_ASN1[method_name] + message_hash
+    expected = _pad_for_signing(cleartext, keylength)
+
+    if len(signature) != keylength:
+        raise VerificationError("Verification failed")
+
+    # Compare with the signed one
+    if expected != clearsig:
+        raise VerificationError("Verification failed")
+
+    return method_name
+
+
+def find_signature_hash(signature: bytes, pub_key: key.PublicKey) -> str:
+    """Returns the hash name detected from the signature.
+
+    If you also want to verify the message, use :py:func:`rsa.verify()` instead.
+    It also returns the name of the used hash.
+
+    :param signature: the signature block, as created with :py:func:`rsa.sign`.
+    :param pub_key: the :py:class:`rsa.PublicKey` of the person signing the message.
+    :returns: the name of the used hash.
+    """
+
+    keylength = common.byte_size(pub_key.n)
+    encrypted = transform.bytes2int(signature)
+    decrypted = core.decrypt_int(encrypted, pub_key.e, pub_key.n)
+    clearsig = transform.int2bytes(decrypted, keylength)
+
+    return _find_method_hash(clearsig)
+
+
+def yield_fixedblocks(infile: typing.BinaryIO, blocksize: int) -> typing.Iterator[bytes]:
+    """Generator, yields each block of ``blocksize`` bytes in the input file.
+
+    :param infile: file to read and separate in blocks.
+    :param blocksize: block size in bytes.
+    :returns: a generator that yields the contents of each block
+    """
+
+    while True:
+        block = infile.read(blocksize)
+
+        read_bytes = len(block)
+        if read_bytes == 0:
+            break
+
+        yield block
+
+        if read_bytes < blocksize:
+            break
+
+
+def compute_hash(message: typing.Union[bytes, typing.BinaryIO], method_name: str) -> bytes:
+    """Returns the message digest.
+
+    :param message: the signed message. Can be an 8-bit string or a file-like
+        object. If ``message`` has a ``read()`` method, it is assumed to be a
+        file-like object.
+    :param method_name: the hash method, must be a key of
+        :py:const:`HASH_METHODS`.
+
+    """
+
+    if method_name not in HASH_METHODS:
+        raise ValueError("Invalid hash method: %s" % method_name)
+
+    method = HASH_METHODS[method_name]
+    hasher = method()
+
+    if isinstance(message, bytes):
+        hasher.update(message)
+    else:
+        assert hasattr(message, "read") and hasattr(message.read, "__call__")
+        # read as 1K blocks
+        for block in yield_fixedblocks(message, 1024):
+            hasher.update(block)
+
+    return hasher.digest()
+
+
+def _find_method_hash(clearsig: bytes) -> str:
+    """Finds the hash method.
+
+    :param clearsig: full padded ASN1 and hash.
+    :return: the used hash method.
+    :raise VerificationFailed: when the hash method cannot be found
+    """
+
+    for (hashname, asn1code) in HASH_ASN1.items():
+        if asn1code in clearsig:
+            return hashname
+
+    raise VerificationError("Verification failed")
+
+
+__all__ = [
+    "encrypt",
+    "decrypt",
+    "sign",
+    "verify",
+    "DecryptionError",
+    "VerificationError",
+    "CryptoError",
+]
+
+if __name__ == "__main__":
+    print("Running doctests 1000x or until failure")
+    import doctest
+
+    for count in range(1000):
+        (failures, tests) = doctest.testmod()
+        if failures:
+            break
+
+        if count % 100 == 0 and count:
+            print("%i times" % count)
+
+    print("Doctests done")
diff --git a/myenv/lib/python3.9/site-packages/rsa/pkcs1_v2.py b/myenv/lib/python3.9/site-packages/rsa/pkcs1_v2.py
new file mode 100644
index 0000000..d68b907
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/pkcs1_v2.py
@@ -0,0 +1,100 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Functions for PKCS#1 version 2 encryption and signing
+
+This module implements certain functionality from PKCS#1 version 2. Main
+documentation is RFC 2437: https://tools.ietf.org/html/rfc2437
+"""
+
+from rsa import (
+    common,
+    pkcs1,
+    transform,
+)
+
+
+def mgf1(seed: bytes, length: int, hasher: str = "SHA-1") -> bytes:
+    """
+    MGF1 is a Mask Generation Function based on a hash function.
+
+    A mask generation function takes an octet string of variable length and a
+    desired output length as input, and outputs an octet string of the desired
+    length. The plaintext-awareness of RSAES-OAEP relies on the random nature of
+    the output of the mask generation function, which in turn relies on the
+    random nature of the underlying hash.
+
+    :param bytes seed: seed from which mask is generated, an octet string
+    :param int length: intended length in octets of the mask, at most 2^32(hLen)
+    :param str hasher: hash function (hLen denotes the length in octets of the hash
+        function output)
+
+    :return: mask, an octet string of length `length`
+    :rtype: bytes
+
+    :raise OverflowError: when `length` is too large for the specified `hasher`
+    :raise ValueError: when specified `hasher` is invalid
+    """
+
+    try:
+        hash_length = pkcs1.HASH_METHODS[hasher]().digest_size
+    except KeyError as ex:
+        raise ValueError(
+            "Invalid `hasher` specified. Please select one of: {hash_list}".format(
+                hash_list=", ".join(sorted(pkcs1.HASH_METHODS.keys()))
+            )
+        ) from ex
+
+    # If l > 2^32(hLen), output "mask too long" and stop.
+    if length > (2 ** 32 * hash_length):
+        raise OverflowError(
+            "Desired length should be at most 2**32 times the hasher's output "
+            "length ({hash_length} for {hasher} function)".format(
+                hash_length=hash_length,
+                hasher=hasher,
+            )
+        )
+
+    # Looping `counter` from 0 to ceil(l / hLen)-1, build `output` based on the
+    # hashes formed by (`seed` + C), being `C` an octet string of length 4
+    # generated by converting `counter` with the primitive I2OSP
+    output = b"".join(
+        pkcs1.compute_hash(
+            seed + transform.int2bytes(counter, fill_size=4),
+            method_name=hasher,
+        )
+        for counter in range(common.ceil_div(length, hash_length) + 1)
+    )
+
+    # Output the leading `length` octets of `output` as the octet string mask.
+    return output[:length]
+
+
+__all__ = [
+    "mgf1",
+]
+
+if __name__ == "__main__":
+    print("Running doctests 1000x or until failure")
+    import doctest
+
+    for count in range(1000):
+        (failures, tests) = doctest.testmod()
+        if failures:
+            break
+
+        if count % 100 == 0 and count:
+            print("%i times" % count)
+
+    print("Doctests done")
diff --git a/myenv/lib/python3.9/site-packages/rsa/prime.py b/myenv/lib/python3.9/site-packages/rsa/prime.py
new file mode 100644
index 0000000..ec486bc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/prime.py
@@ -0,0 +1,198 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Numerical functions related to primes.
+
+Implementation based on the book Algorithm Design by Michael T. Goodrich and
+Roberto Tamassia, 2002.
+"""
+
+import rsa.common
+import rsa.randnum
+
+__all__ = ["getprime", "are_relatively_prime"]
+
+
+def gcd(p: int, q: int) -> int:
+    """Returns the greatest common divisor of p and q
+
+    >>> gcd(48, 180)
+    12
+    """
+
+    while q != 0:
+        (p, q) = (q, p % q)
+    return p
+
+
+def get_primality_testing_rounds(number: int) -> int:
+    """Returns minimum number of rounds for Miller-Rabing primality testing,
+    based on number bitsize.
+
+    According to NIST FIPS 186-4, Appendix C, Table C.3, minimum number of
+    rounds of M-R testing, using an error probability of 2 ** (-100), for
+    different p, q bitsizes are:
+      * p, q bitsize: 512; rounds: 7
+      * p, q bitsize: 1024; rounds: 4
+      * p, q bitsize: 1536; rounds: 3
+    See: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
+    """
+
+    # Calculate number bitsize.
+    bitsize = rsa.common.bit_size(number)
+    # Set number of rounds.
+    if bitsize >= 1536:
+        return 3
+    if bitsize >= 1024:
+        return 4
+    if bitsize >= 512:
+        return 7
+    # For smaller bitsizes, set arbitrary number of rounds.
+    return 10
+
+
+def miller_rabin_primality_testing(n: int, k: int) -> bool:
+    """Calculates whether n is composite (which is always correct) or prime
+    (which theoretically is incorrect with error probability 4**-k), by
+    applying Miller-Rabin primality testing.
+
+    For reference and implementation example, see:
+    https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
+
+    :param n: Integer to be tested for primality.
+    :type n: int
+    :param k: Number of rounds (witnesses) of Miller-Rabin testing.
+    :type k: int
+    :return: False if the number is composite, True if it's probably prime.
+    :rtype: bool
+    """
+
+    # prevent potential infinite loop when d = 0
+    if n < 2:
+        return False
+
+    # Decompose (n - 1) to write it as (2 ** r) * d
+    # While d is even, divide it by 2 and increase the exponent.
+    d = n - 1
+    r = 0
+
+    while not (d & 1):
+        r += 1
+        d >>= 1
+
+    # Test k witnesses.
+    for _ in range(k):
+        # Generate random integer a, where 2 <= a <= (n - 2)
+        a = rsa.randnum.randint(n - 3) + 1
+
+        x = pow(a, d, n)
+        if x == 1 or x == n - 1:
+            continue
+
+        for _ in range(r - 1):
+            x = pow(x, 2, n)
+            if x == 1:
+                # n is composite.
+                return False
+            if x == n - 1:
+                # Exit inner loop and continue with next witness.
+                break
+        else:
+            # If loop doesn't break, n is composite.
+            return False
+
+    return True
+
+
+def is_prime(number: int) -> bool:
+    """Returns True if the number is prime, and False otherwise.
+
+    >>> is_prime(2)
+    True
+    >>> is_prime(42)
+    False
+    >>> is_prime(41)
+    True
+    """
+
+    # Check for small numbers.
+    if number < 10:
+        return number in {2, 3, 5, 7}
+
+    # Check for even numbers.
+    if not (number & 1):
+        return False
+
+    # Calculate minimum number of rounds.
+    k = get_primality_testing_rounds(number)
+
+    # Run primality testing with (minimum + 1) rounds.
+    return miller_rabin_primality_testing(number, k + 1)
+
+
+def getprime(nbits: int) -> int:
+    """Returns a prime number that can be stored in 'nbits' bits.
+
+    >>> p = getprime(128)
+    >>> is_prime(p-1)
+    False
+    >>> is_prime(p)
+    True
+    >>> is_prime(p+1)
+    False
+
+    >>> from rsa import common
+    >>> common.bit_size(p) == 128
+    True
+    """
+
+    assert nbits > 3  # the loop will hang on too small numbers
+
+    while True:
+        integer = rsa.randnum.read_random_odd_int(nbits)
+
+        # Test for primeness
+        if is_prime(integer):
+            return integer
+
+            # Retry if not prime
+
+
+def are_relatively_prime(a: int, b: int) -> bool:
+    """Returns True if a and b are relatively prime, and False if they
+    are not.
+
+    >>> are_relatively_prime(2, 3)
+    True
+    >>> are_relatively_prime(2, 4)
+    False
+    """
+
+    d = gcd(a, b)
+    return d == 1
+
+
+if __name__ == "__main__":
+    print("Running doctests 1000x or until failure")
+    import doctest
+
+    for count in range(1000):
+        (failures, tests) = doctest.testmod()
+        if failures:
+            break
+
+        if count % 100 == 0 and count:
+            print("%i times" % count)
+
+    print("Doctests done")
diff --git a/myenv/lib/python3.9/site-packages/rsa/py.typed b/myenv/lib/python3.9/site-packages/rsa/py.typed
new file mode 100644
index 0000000..6c27071
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/py.typed
@@ -0,0 +1 @@
+# Marker file for PEP 561.  The rsa package uses inline types.
diff --git a/myenv/lib/python3.9/site-packages/rsa/randnum.py b/myenv/lib/python3.9/site-packages/rsa/randnum.py
new file mode 100644
index 0000000..c65facd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/randnum.py
@@ -0,0 +1,95 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Functions for generating random numbers."""
+
+# Source inspired by code by Yesudeep Mangalapilly <yesudeep@gmail.com>
+
+import os
+import struct
+
+from rsa import common, transform
+
+
+def read_random_bits(nbits: int) -> bytes:
+    """Reads 'nbits' random bits.
+
+    If nbits isn't a whole number of bytes, an extra byte will be appended with
+    only the lower bits set.
+    """
+
+    nbytes, rbits = divmod(nbits, 8)
+
+    # Get the random bytes
+    randomdata = os.urandom(nbytes)
+
+    # Add the remaining random bits
+    if rbits > 0:
+        randomvalue = ord(os.urandom(1))
+        randomvalue >>= 8 - rbits
+        randomdata = struct.pack("B", randomvalue) + randomdata
+
+    return randomdata
+
+
+def read_random_int(nbits: int) -> int:
+    """Reads a random integer of approximately nbits bits."""
+
+    randomdata = read_random_bits(nbits)
+    value = transform.bytes2int(randomdata)
+
+    # Ensure that the number is large enough to just fill out the required
+    # number of bits.
+    value |= 1 << (nbits - 1)
+
+    return value
+
+
+def read_random_odd_int(nbits: int) -> int:
+    """Reads a random odd integer of approximately nbits bits.
+
+    >>> read_random_odd_int(512) & 1
+    1
+    """
+
+    value = read_random_int(nbits)
+
+    # Make sure it's odd
+    return value | 1
+
+
+def randint(maxvalue: int) -> int:
+    """Returns a random integer x with 1 <= x <= maxvalue
+
+    May take a very long time in specific situations. If maxvalue needs N bits
+    to store, the closer maxvalue is to (2 ** N) - 1, the faster this function
+    is.
+    """
+
+    bit_size = common.bit_size(maxvalue)
+
+    tries = 0
+    while True:
+        value = read_random_int(bit_size)
+        if value <= maxvalue:
+            break
+
+        if tries % 10 == 0 and tries:
+            # After a lot of tries to get the right number of bits but still
+            # smaller than maxvalue, decrease the number of bits by 1. That'll
+            # dramatically increase the chances to get a large enough number.
+            bit_size -= 1
+        tries += 1
+
+    return value
diff --git a/myenv/lib/python3.9/site-packages/rsa/transform.py b/myenv/lib/python3.9/site-packages/rsa/transform.py
new file mode 100644
index 0000000..c609b65
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/transform.py
@@ -0,0 +1,72 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Data transformation functions.
+
+From bytes to a number, number to bytes, etc.
+"""
+
+import math
+
+
+def bytes2int(raw_bytes: bytes) -> int:
+    r"""Converts a list of bytes or an 8-bit string to an integer.
+
+    When using unicode strings, encode it to some encoding like UTF8 first.
+
+    >>> (((128 * 256) + 64) * 256) + 15
+    8405007
+    >>> bytes2int(b'\x80@\x0f')
+    8405007
+
+    """
+    return int.from_bytes(raw_bytes, "big", signed=False)
+
+
+def int2bytes(number: int, fill_size: int = 0) -> bytes:
+    """
+    Convert an unsigned integer to bytes (big-endian)::
+
+    Does not preserve leading zeros if you don't specify a fill size.
+
+    :param number:
+        Integer value
+    :param fill_size:
+        If the optional fill size is given the length of the resulting
+        byte string is expected to be the fill size and will be padded
+        with prefix zero bytes to satisfy that length.
+    :returns:
+        Raw bytes (base-256 representation).
+    :raises:
+        ``OverflowError`` when fill_size is given and the number takes up more
+        bytes than fit into the block. This requires the ``overflow``
+        argument to this function to be set to ``False`` otherwise, no
+        error will be raised.
+    """
+
+    if number < 0:
+        raise ValueError("Number must be an unsigned integer: %d" % number)
+
+    bytes_required = max(1, math.ceil(number.bit_length() / 8))
+
+    if fill_size > 0:
+        return number.to_bytes(fill_size, "big")
+
+    return number.to_bytes(bytes_required, "big")
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
diff --git a/myenv/lib/python3.9/site-packages/rsa/util.py b/myenv/lib/python3.9/site-packages/rsa/util.py
new file mode 100644
index 0000000..087caf8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/rsa/util.py
@@ -0,0 +1,97 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Utility functions."""
+
+import sys
+from optparse import OptionParser
+
+import rsa.key
+
+
+def private_to_public() -> None:
+    """Reads a private key and outputs the corresponding public key."""
+
+    # Parse the CLI options
+    parser = OptionParser(
+        usage="usage: %prog [options]",
+        description="Reads a private key and outputs the "
+        "corresponding public key. Both private and public keys use "
+        "the format described in PKCS#1 v1.5",
+    )
+
+    parser.add_option(
+        "-i",
+        "--input",
+        dest="infilename",
+        type="string",
+        help="Input filename. Reads from stdin if not specified",
+    )
+    parser.add_option(
+        "-o",
+        "--output",
+        dest="outfilename",
+        type="string",
+        help="Output filename. Writes to stdout of not specified",
+    )
+
+    parser.add_option(
+        "--inform",
+        dest="inform",
+        help="key format of input - default PEM",
+        choices=("PEM", "DER"),
+        default="PEM",
+    )
+
+    parser.add_option(
+        "--outform",
+        dest="outform",
+        help="key format of output - default PEM",
+        choices=("PEM", "DER"),
+        default="PEM",
+    )
+
+    (cli, cli_args) = parser.parse_args(sys.argv)
+
+    # Read the input data
+    if cli.infilename:
+        print(
+            "Reading private key from %s in %s format" % (cli.infilename, cli.inform),
+            file=sys.stderr,
+        )
+        with open(cli.infilename, "rb") as infile:
+            in_data = infile.read()
+    else:
+        print("Reading private key from stdin in %s format" % cli.inform, file=sys.stderr)
+        in_data = sys.stdin.read().encode("ascii")
+
+    assert type(in_data) == bytes, type(in_data)
+
+    # Take the public fields and create a public key
+    priv_key = rsa.key.PrivateKey.load_pkcs1(in_data, cli.inform)
+    pub_key = rsa.key.PublicKey(priv_key.n, priv_key.e)
+
+    # Save to the output file
+    out_data = pub_key.save_pkcs1(cli.outform)
+
+    if cli.outfilename:
+        print(
+            "Writing public key to %s in %s format" % (cli.outfilename, cli.outform),
+            file=sys.stderr,
+        )
+        with open(cli.outfilename, "wb") as outfile:
+            outfile.write(out_data)
+    else:
+        print("Writing public key to stdout in %s format" % cli.outform, file=sys.stderr)
+        sys.stdout.write(out_data.decode("ascii"))
diff --git a/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/INSTALLER
new file mode 100644
index 0000000..a1b589e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/LICENSE
new file mode 100644
index 0000000..6e0693b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/LICENSE
@@ -0,0 +1,19 @@
+Copyright (C) 2016 Jason R Coombs <jaraco@jaraco.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/METADATA
new file mode 100644
index 0000000..7c7f0f5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/METADATA
@@ -0,0 +1,109 @@
+Metadata-Version: 2.1
+Name: setuptools
+Version: 49.2.1
+Summary: Easily download, build, install, upgrade, and uninstall Python packages
+Home-page: https://github.com/pypa/setuptools
+Author: Python Packaging Authority
+Author-email: distutils-sig@python.org
+License: UNKNOWN
+Project-URL: Documentation, https://setuptools.readthedocs.io/
+Keywords: CPAN PyPI distutils eggs package management
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Archiving :: Packaging
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.5
+Description-Content-Type: text/x-rst; charset=UTF-8
+Provides-Extra: certs
+Requires-Dist: certifi (==2016.9.26) ; extra == 'certs'
+Provides-Extra: docs
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: jaraco.packaging (>=6.1) ; extra == 'docs'
+Requires-Dist: rst.linker (>=1.9) ; extra == 'docs'
+Requires-Dist: pygments-github-lexers (==0.0.5) ; extra == 'docs'
+Provides-Extra: ssl
+Requires-Dist: wincertstore (==0.2) ; (sys_platform == "win32") and extra == 'ssl'
+Provides-Extra: tests
+Requires-Dist: mock ; extra == 'tests'
+Requires-Dist: pytest-flake8 ; extra == 'tests'
+Requires-Dist: virtualenv (>=13.0.0) ; extra == 'tests'
+Requires-Dist: pytest-virtualenv (>=1.2.7) ; extra == 'tests'
+Requires-Dist: pytest (>=3.7) ; extra == 'tests'
+Requires-Dist: wheel ; extra == 'tests'
+Requires-Dist: coverage (>=4.5.1) ; extra == 'tests'
+Requires-Dist: pytest-cov (>=2.5.1) ; extra == 'tests'
+Requires-Dist: pip (>=19.1) ; extra == 'tests'
+Requires-Dist: futures ; (python_version == "2.7") and extra == 'tests'
+Requires-Dist: flake8-2020 ; (python_version >= "3.6") and extra == 'tests'
+Requires-Dist: paver ; (python_version >= "3.6") and extra == 'tests'
+
+.. image:: https://img.shields.io/pypi/v/setuptools.svg
+   :target: `PyPI link`_
+
+.. image:: https://img.shields.io/pypi/pyversions/setuptools.svg
+   :target: `PyPI link`_
+
+.. _PyPI link: https://pypi.org/project/setuptools
+
+.. image:: https://dev.azure.com/jaraco/setuptools/_apis/build/status/pypa.setuptools?branchName=master
+   :target: https://dev.azure.com/jaraco/setuptools/_build/latest?definitionId=1&branchName=master
+
+.. image:: https://img.shields.io/travis/pypa/setuptools/master.svg?label=Linux%20CI&logo=travis&logoColor=white
+   :target: https://travis-ci.org/pypa/setuptools
+
+.. image:: https://img.shields.io/appveyor/ci/pypa/setuptools/master.svg?label=Windows%20CI&logo=appveyor&logoColor=white
+   :target: https://ci.appveyor.com/project/pypa/setuptools/branch/master
+
+.. image:: https://img.shields.io/readthedocs/setuptools/latest.svg
+    :target: https://setuptools.readthedocs.io
+
+.. image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white
+   :target: https://codecov.io/gh/pypa/setuptools
+
+.. image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat
+   :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme
+
+See the `Installation Instructions
+<https://packaging.python.org/installing/>`_ in the Python Packaging
+User's Guide for instructions on installing, upgrading, and uninstalling
+Setuptools.
+
+Questions and comments should be directed to the `distutils-sig
+mailing list <http://mail.python.org/pipermail/distutils-sig/>`_.
+Bug reports and especially tested patches may be
+submitted directly to the `bug tracker
+<https://github.com/pypa/setuptools/issues>`_.
+
+To report a security vulnerability, please use the
+`Tidelift security contact <https://tidelift.com/security>`_.
+Tidelift will coordinate the fix and disclosure.
+
+
+For Enterprise
+==============
+
+Available as part of the Tidelift Subscription.
+
+Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.
+
+`Learn more <https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=referral&utm_campaign=github>`_.
+
+Code of Conduct
+===============
+
+Everyone interacting in the setuptools project's codebases, issue trackers,
+chat rooms, and mailing lists is expected to follow the
+`PSF Code of Conduct <https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md>`_.
+
+
diff --git a/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/RECORD
new file mode 100644
index 0000000..e519665
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/RECORD
@@ -0,0 +1,297 @@
+../../../bin/easy_install,sha256=_uNkiheHupy0j5m2OLlxua5EDmOvaPtHPLagTXfZjCg,274
+../../../bin/easy_install-3.9,sha256=_uNkiheHupy0j5m2OLlxua5EDmOvaPtHPLagTXfZjCg,274
+__pycache__/easy_install.cpython-39.pyc,,
+easy_install.py,sha256=MDC9vt5AxDsXX5qcKlBz2TnW6Tpuv_AobnfhCJ9X3PM,126
+pkg_resources/__init__.py,sha256=44G2LkL_lXbDzjTukLmR5baLQtE3S4IaFciSZPDcOM8,108481
+pkg_resources/__pycache__/__init__.cpython-39.pyc,,
+pkg_resources/_vendor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pkg_resources/_vendor/__pycache__/__init__.cpython-39.pyc,,
+pkg_resources/_vendor/__pycache__/appdirs.cpython-39.pyc,,
+pkg_resources/_vendor/__pycache__/pyparsing.cpython-39.pyc,,
+pkg_resources/_vendor/__pycache__/six.cpython-39.pyc,,
+pkg_resources/_vendor/appdirs.py,sha256=MievUEuv3l_mQISH5SF0shDk_BNhHHzYiAPrT3ITN4I,24701
+pkg_resources/_vendor/packaging/__about__.py,sha256=CpuMSyh1V7adw8QMjWKkY3LtdqRUkRX4MgJ6nF4stM0,744
+pkg_resources/_vendor/packaging/__init__.py,sha256=6enbp5XgRfjBjsI9-bn00HjHf5TH21PDMOKkJW8xw-w,562
+pkg_resources/_vendor/packaging/__pycache__/__about__.cpython-39.pyc,,
+pkg_resources/_vendor/packaging/__pycache__/__init__.cpython-39.pyc,,
+pkg_resources/_vendor/packaging/__pycache__/_compat.cpython-39.pyc,,
+pkg_resources/_vendor/packaging/__pycache__/_structures.cpython-39.pyc,,
+pkg_resources/_vendor/packaging/__pycache__/markers.cpython-39.pyc,,
+pkg_resources/_vendor/packaging/__pycache__/requirements.cpython-39.pyc,,
+pkg_resources/_vendor/packaging/__pycache__/specifiers.cpython-39.pyc,,
+pkg_resources/_vendor/packaging/__pycache__/tags.cpython-39.pyc,,
+pkg_resources/_vendor/packaging/__pycache__/utils.cpython-39.pyc,,
+pkg_resources/_vendor/packaging/__pycache__/version.cpython-39.pyc,,
+pkg_resources/_vendor/packaging/_compat.py,sha256=Ugdm-qcneSchW25JrtMIKgUxfEEBcCAz6WrEeXeqz9o,865
+pkg_resources/_vendor/packaging/_structures.py,sha256=pVd90XcXRGwpZRB_qdFuVEibhCHpX_bL5zYr9-N0mc8,1416
+pkg_resources/_vendor/packaging/markers.py,sha256=-3GbxB_JjpWPBlTjvo_rCMJZ17i96VvHjtZ3URklwhg,8277
+pkg_resources/_vendor/packaging/requirements.py,sha256=syt3EodrY6_UtlfeJDuhVYXcEDEweTSt2pyslLYlX3I,4757
+pkg_resources/_vendor/packaging/specifiers.py,sha256=0ZzQpcUnvrQ6LjR-mQRLzMr8G6hdRv-mY0VSf_amFtI,27778
+pkg_resources/_vendor/packaging/tags.py,sha256=EPLXhO6GTD7_oiWEO1U0l0PkfR8R_xivpMDHXnsTlts,12933
+pkg_resources/_vendor/packaging/utils.py,sha256=VaTC0Ei7zO2xl9ARiWmz2YFLFt89PuuhLbAlXMyAGms,1520
+pkg_resources/_vendor/packaging/version.py,sha256=Npdwnb8OHedj_2L86yiUqscujb7w_i5gmSK1PhOAFzg,11978
+pkg_resources/_vendor/pyparsing.py,sha256=tmrp-lu-qO1i75ZzIN5A12nKRRD1Cm4Vpk-5LR9rims,232055
+pkg_resources/_vendor/six.py,sha256=A6hdJZVjI3t_geebZ9BzUvwRrIXo0lfwzQlM2LcKyas,30098
+pkg_resources/extern/__init__.py,sha256=w_3T8ntsvFFioQYOgYoGGqafDiv4sLzecQRDjsB5yeE,2101
+pkg_resources/extern/__pycache__/__init__.cpython-39.pyc,,
+setuptools-49.2.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools-49.2.1.dist-info/LICENSE,sha256=wyo6w5WvYyHv0ovnPQagDw22q4h9HCHU_sRhKNIFbVo,1078
+setuptools-49.2.1.dist-info/METADATA,sha256=BpVxLXLg7oFfk05RuRuAea4JPTfYrVCX0nfW4A9S9w8,4819
+setuptools-49.2.1.dist-info/RECORD,,
+setuptools-49.2.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools-49.2.1.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
+setuptools-49.2.1.dist-info/dependency_links.txt,sha256=HlkCFkoK5TbZ5EMLbLKYhLcY_E31kBWD8TqW2EgmatQ,239
+setuptools-49.2.1.dist-info/entry_points.txt,sha256=1K5Fr0-5Ph3ZRZFuwNaw8ERGiNLVqHvdKDNt3oXGS6w,3143
+setuptools-49.2.1.dist-info/top_level.txt,sha256=2HUXVVwA4Pff1xgTFr3GsTXXKaPaO6vlG6oNJ_4u4Tg,38
+setuptools-49.2.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+setuptools/__init__.py,sha256=MeXBA4OH_MiIlHhecZLuoNjYbQP2CrMof2wS5qfKDNg,7943
+setuptools/__pycache__/__init__.cpython-39.pyc,,
+setuptools/__pycache__/_deprecation_warning.cpython-39.pyc,,
+setuptools/__pycache__/_imp.cpython-39.pyc,,
+setuptools/__pycache__/archive_util.cpython-39.pyc,,
+setuptools/__pycache__/build_meta.cpython-39.pyc,,
+setuptools/__pycache__/config.cpython-39.pyc,,
+setuptools/__pycache__/dep_util.cpython-39.pyc,,
+setuptools/__pycache__/depends.cpython-39.pyc,,
+setuptools/__pycache__/dist.cpython-39.pyc,,
+setuptools/__pycache__/distutils_patch.cpython-39.pyc,,
+setuptools/__pycache__/errors.cpython-39.pyc,,
+setuptools/__pycache__/extension.cpython-39.pyc,,
+setuptools/__pycache__/glob.cpython-39.pyc,,
+setuptools/__pycache__/installer.cpython-39.pyc,,
+setuptools/__pycache__/launch.cpython-39.pyc,,
+setuptools/__pycache__/lib2to3_ex.cpython-39.pyc,,
+setuptools/__pycache__/monkey.cpython-39.pyc,,
+setuptools/__pycache__/msvc.cpython-39.pyc,,
+setuptools/__pycache__/namespaces.cpython-39.pyc,,
+setuptools/__pycache__/package_index.cpython-39.pyc,,
+setuptools/__pycache__/py27compat.cpython-39.pyc,,
+setuptools/__pycache__/py31compat.cpython-39.pyc,,
+setuptools/__pycache__/py33compat.cpython-39.pyc,,
+setuptools/__pycache__/py34compat.cpython-39.pyc,,
+setuptools/__pycache__/sandbox.cpython-39.pyc,,
+setuptools/__pycache__/ssl_support.cpython-39.pyc,,
+setuptools/__pycache__/unicode_utils.cpython-39.pyc,,
+setuptools/__pycache__/version.cpython-39.pyc,,
+setuptools/__pycache__/wheel.cpython-39.pyc,,
+setuptools/__pycache__/windows_support.cpython-39.pyc,,
+setuptools/_deprecation_warning.py,sha256=jU9-dtfv6cKmtQJOXN8nP1mm7gONw5kKEtiPtbwnZyI,218
+setuptools/_distutils/__init__.py,sha256=lpQAphR_7uhWC2fbSEps4Ja9W4YwezN_IX_LJEt3khU,250
+setuptools/_distutils/__pycache__/__init__.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/_msvccompiler.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/archive_util.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/bcppcompiler.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/ccompiler.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/cmd.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/config.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/core.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/cygwinccompiler.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/debug.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/dep_util.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/dir_util.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/dist.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/errors.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/extension.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/fancy_getopt.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/file_util.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/filelist.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/log.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/msvc9compiler.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/msvccompiler.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/spawn.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/sysconfig.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/text_file.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/unixccompiler.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/util.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/version.cpython-39.pyc,,
+setuptools/_distutils/__pycache__/versionpredicate.cpython-39.pyc,,
+setuptools/_distutils/_msvccompiler.py,sha256=RHCjIg5d2O6BxWDRotab1dgX-lhcSglHtzF2ZZgHwbA,19968
+setuptools/_distutils/archive_util.py,sha256=qW-uiGwYexTvK5e-iSel_31Dshx-CqTanNPK6snwf98,8572
+setuptools/_distutils/bcppcompiler.py,sha256=OJDVpCUmX6H8v_7lV1zifV1fcx92Cr2dhiUh6989UJI,14894
+setuptools/_distutils/ccompiler.py,sha256=4cqQgq06NbGo0vazGMT2aPZ6K2Z-HcuRn9Pfz_bQUPw,47437
+setuptools/_distutils/cmd.py,sha256=eco6LAGUtobLuPafuhmgKgkwRRL_WY8KJ4YeDCHpcls,18079
+setuptools/_distutils/command/__init__.py,sha256=2TA-rlNDlzeI-csbWHXFjGD8uOYqALMfyWOhT49nC6g,799
+setuptools/_distutils/command/__pycache__/__init__.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/bdist.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/bdist_dumb.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/bdist_msi.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/bdist_rpm.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/bdist_wininst.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/build.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/build_clib.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/build_ext.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/build_py.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/build_scripts.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/check.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/clean.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/config.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/install.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/install_data.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/install_egg_info.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/install_headers.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/install_lib.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/install_scripts.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/register.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/sdist.cpython-39.pyc,,
+setuptools/_distutils/command/__pycache__/upload.cpython-39.pyc,,
+setuptools/_distutils/command/bdist.py,sha256=2z4eudRl_n7m3lG9leL0IYqes4bsm8c0fxfZuiafjMg,5562
+setuptools/_distutils/command/bdist_dumb.py,sha256=BTur9jcIppyP7Piavjfsk7YjElqvxeYO2npUyPPOekc,4913
+setuptools/_distutils/command/bdist_msi.py,sha256=EVFQYN_X-ExeeP8gmdV9JcINsuUGsLJUz9afMU0Rt8c,35579
+setuptools/_distutils/command/bdist_rpm.py,sha256=gjOw22GhDSbcq0bdq25cTb-n6HWWm0bShLQad_mkJ4k,21537
+setuptools/_distutils/command/bdist_wininst.py,sha256=iGlaI-VfElHOneeczKHWnSN5a10-7IMcJaXuR1mdS3c,16030
+setuptools/_distutils/command/build.py,sha256=11NyR2UAUzalrkTZ2ph0BAHFWFC2jtSsN7gIaF-NC08,5767
+setuptools/_distutils/command/build_clib.py,sha256=bgVTHh28eLQA2Gkw68amApd_j7qQBX4MTI-zTvAK_J4,8022
+setuptools/_distutils/command/build_ext.py,sha256=MMJPCxHlf9rgUkizn4Kjq9vYeAEfxyqfq8XsTE-EpWM,31635
+setuptools/_distutils/command/build_py.py,sha256=S_Nlw4hZE8PnIgqX5OFMdmt-GSmOhPQQ4f2jr1uBnoU,17190
+setuptools/_distutils/command/build_scripts.py,sha256=aKycJJPx3LfZ1cvZgSJaxnD2LnvRM5WJ-8xkpdgcLsI,6232
+setuptools/_distutils/command/check.py,sha256=5qDtI75ccZg3sAItQWeaIu8y3FR314O4rr9Smz4HsEo,5637
+setuptools/_distutils/command/clean.py,sha256=2TCt47ru4hZZM0RfVfUYj5bbpicpGLP4Qhw5jBtvp9k,2776
+setuptools/_distutils/command/config.py,sha256=2aTjww3PwjMB8-ZibCe4P7B-qG1hM1gn_rJXYyxRz6c,13117
+setuptools/_distutils/command/install.py,sha256=oOM2rD7l_SglARNVDmiZn8u6DAfidXRF_yE5QS328B4,27482
+setuptools/_distutils/command/install_data.py,sha256=YhGOAwh3gJPqF7em5XA0rmpR42z1bLh80ooElzDyUvk,2822
+setuptools/_distutils/command/install_egg_info.py,sha256=0kW0liVMeadkjX0ZcRfMptKFen07Gw6gyw1VHT5KIwc,2603
+setuptools/_distutils/command/install_headers.py,sha256=XQ6idkbIDfr1ljXCOznuVUMvOFpHBn6cK0Wz9gIM2b4,1298
+setuptools/_distutils/command/install_lib.py,sha256=9AofR-MO9lAtjwwuukCptepOaJEKMZW2VHiyR5hU7HA,8397
+setuptools/_distutils/command/install_scripts.py,sha256=_CLUeQwGJRcY2kik7azPMn5IdtDCrjWdUvZ1khlG6ck,2017
+setuptools/_distutils/command/register.py,sha256=2jaq9968rt2puRVDBx1HbNiXv27uOk8idE_4lPf_3VM,11712
+setuptools/_distutils/command/sdist.py,sha256=qotJjAOzyhJjq2-oDImjNFrOtaSneEFDJTB-sEk1wnU,19005
+setuptools/_distutils/command/upload.py,sha256=BLO1w7eSAqsCjCLXtf_CRVSjwF1WmyOByGVGNdcQ8oY,7597
+setuptools/_distutils/config.py,sha256=dtHgblx9JhfyrKx1-J7Jlxw_f7s8ZbPFQii2UWMTZpY,4827
+setuptools/_distutils/core.py,sha256=jbdOkpOK09xi-56vhhwvn3fYdhLb5DJO8q3K1fnQz0Q,8876
+setuptools/_distutils/cygwinccompiler.py,sha256=9U4JAusUzlAGJl0Y5nToPkQ3ldzseAtiye434mwJ0ow,16380
+setuptools/_distutils/debug.py,sha256=N6MrTAqK6l9SVk6tWweR108PM8Ol7qNlfyV-nHcLhsY,139
+setuptools/_distutils/dep_util.py,sha256=GuR9Iw_jzZRkyemJ5HX8rB_wRGxkIBcBm1qh54r7zhk,3491
+setuptools/_distutils/dir_util.py,sha256=UwhBOUTcV65GTwce4SPuTXR8Z8q3LYEcmttqcGb0bYo,7778
+setuptools/_distutils/dist.py,sha256=Biuf6ca8uiFfMScRFsYUKtb5neMPtxKxRtXn50_1f3U,50421
+setuptools/_distutils/errors.py,sha256=Yr6tKZGdzBoNi53vBtiq0UJ__X05CmxSdQJqOWaw6SY,3577
+setuptools/_distutils/extension.py,sha256=bTb3Q0CoevGKYv5dX1ls--Ln8tlB0-UEOsi9BwzlZ-s,10515
+setuptools/_distutils/fancy_getopt.py,sha256=OPxp2CxHi1Yp_d1D8JxW4Ueq9fC71tegQFaafh58GGU,17784
+setuptools/_distutils/file_util.py,sha256=0hUqfItN_x2DVihR0MHdA4KCMVCOO8VoByaFp_a6MDg,8148
+setuptools/_distutils/filelist.py,sha256=8bRxhzp2FsaoHT7TuKD4Qjcuh_B9Ow_xTt_htZJvN2Q,12832
+setuptools/_distutils/log.py,sha256=hWBmdUC2K927QcVv3REMW3HMPclxccPQngxLSuUXQl0,1969
+setuptools/_distutils/msvc9compiler.py,sha256=uv0TAfoWrxEBOQL-Z2uws5g4AXoTPahUEMuq6FLkCYY,30453
+setuptools/_distutils/msvccompiler.py,sha256=ZYsnUgIC4tZT2WkJbTkTUyVSCAc2nFM9DVKIuIfPBU0,23540
+setuptools/_distutils/spawn.py,sha256=XBmUqzhxXfay_JE18RkaalHf9kgi7NvXeBPW9BfTqmw,4408
+setuptools/_distutils/sysconfig.py,sha256=5z55MU7gXeceL_G9FK6ex-2OvdeIXJRZJafrtthJcfU,21349
+setuptools/_distutils/text_file.py,sha256=PsuAJeWdKJoLSV_6N6IpB5-0Pa84KzLUucJMFRazw3I,12483
+setuptools/_distutils/unixccompiler.py,sha256=E65edChYLoHY8wi4OxFu_wKt3hJe3GySF6v51G_ZzL0,14696
+setuptools/_distutils/util.py,sha256=Z-FtpvCo1szNkssI-it-uWhA35996XHcttLZiUzc1_Y,20913
+setuptools/_distutils/version.py,sha256=8NogP6NPPQpp3EUMZcT9czEHia-ehqPo8spo_e7AgUU,12514
+setuptools/_distutils/versionpredicate.py,sha256=ZxpEA-TQv88mUWc6hetUO4qSqA2sa7ipjZ3QEK5evDk,5133
+setuptools/_imp.py,sha256=Qx0LJzEBaWk_6PfICamJtfBN2rh5K9sJq1wXvtZW-mc,2388
+setuptools/_vendor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/__pycache__/__init__.cpython-39.pyc,,
+setuptools/_vendor/__pycache__/ordered_set.cpython-39.pyc,,
+setuptools/_vendor/__pycache__/pyparsing.cpython-39.pyc,,
+setuptools/_vendor/__pycache__/six.cpython-39.pyc,,
+setuptools/_vendor/ordered_set.py,sha256=dbaCcs27dyN9gnMWGF5nA_BrVn6Q-NrjKYJpV9_fgBs,15130
+setuptools/_vendor/packaging/__about__.py,sha256=CpuMSyh1V7adw8QMjWKkY3LtdqRUkRX4MgJ6nF4stM0,744
+setuptools/_vendor/packaging/__init__.py,sha256=6enbp5XgRfjBjsI9-bn00HjHf5TH21PDMOKkJW8xw-w,562
+setuptools/_vendor/packaging/__pycache__/__about__.cpython-39.pyc,,
+setuptools/_vendor/packaging/__pycache__/__init__.cpython-39.pyc,,
+setuptools/_vendor/packaging/__pycache__/_compat.cpython-39.pyc,,
+setuptools/_vendor/packaging/__pycache__/_structures.cpython-39.pyc,,
+setuptools/_vendor/packaging/__pycache__/markers.cpython-39.pyc,,
+setuptools/_vendor/packaging/__pycache__/requirements.cpython-39.pyc,,
+setuptools/_vendor/packaging/__pycache__/specifiers.cpython-39.pyc,,
+setuptools/_vendor/packaging/__pycache__/tags.cpython-39.pyc,,
+setuptools/_vendor/packaging/__pycache__/utils.cpython-39.pyc,,
+setuptools/_vendor/packaging/__pycache__/version.cpython-39.pyc,,
+setuptools/_vendor/packaging/_compat.py,sha256=Ugdm-qcneSchW25JrtMIKgUxfEEBcCAz6WrEeXeqz9o,865
+setuptools/_vendor/packaging/_structures.py,sha256=pVd90XcXRGwpZRB_qdFuVEibhCHpX_bL5zYr9-N0mc8,1416
+setuptools/_vendor/packaging/markers.py,sha256=-meFl9Fr9V8rF5Rduzgett5EHK9wBYRUqssAV2pj0lw,8268
+setuptools/_vendor/packaging/requirements.py,sha256=3dwIJekt8RRGCUbgxX8reeAbgmZYjb0wcCRtmH63kxI,4742
+setuptools/_vendor/packaging/specifiers.py,sha256=0ZzQpcUnvrQ6LjR-mQRLzMr8G6hdRv-mY0VSf_amFtI,27778
+setuptools/_vendor/packaging/tags.py,sha256=EPLXhO6GTD7_oiWEO1U0l0PkfR8R_xivpMDHXnsTlts,12933
+setuptools/_vendor/packaging/utils.py,sha256=VaTC0Ei7zO2xl9ARiWmz2YFLFt89PuuhLbAlXMyAGms,1520
+setuptools/_vendor/packaging/version.py,sha256=Npdwnb8OHedj_2L86yiUqscujb7w_i5gmSK1PhOAFzg,11978
+setuptools/_vendor/pyparsing.py,sha256=tmrp-lu-qO1i75ZzIN5A12nKRRD1Cm4Vpk-5LR9rims,232055
+setuptools/_vendor/six.py,sha256=A6hdJZVjI3t_geebZ9BzUvwRrIXo0lfwzQlM2LcKyas,30098
+setuptools/archive_util.py,sha256=F1-XrQJTdXHRPRA09kxPWwm9Z2Ms1lE_IQZKG_JZ7rM,6638
+setuptools/build_meta.py,sha256=qFxrLAwgKPS3TxEi8NNbFxfEvb192pzSgARS8nZZ_Ek,9917
+setuptools/cli-32.exe,sha256=dfEuovMNnA2HLa3jRfMPVi5tk4R7alCbpTvuxtCyw0Y,65536
+setuptools/cli-64.exe,sha256=KLABu5pyrnokJCv6skjXZ6GsXeyYHGcqOUT3oHI3Xpo,74752
+setuptools/cli.exe,sha256=dfEuovMNnA2HLa3jRfMPVi5tk4R7alCbpTvuxtCyw0Y,65536
+setuptools/command/__init__.py,sha256=QCAuA9whnq8Bnoc0bBaS6Lw_KAUO0DiHYZQXEMNn5hg,568
+setuptools/command/__pycache__/__init__.cpython-39.pyc,,
+setuptools/command/__pycache__/alias.cpython-39.pyc,,
+setuptools/command/__pycache__/bdist_egg.cpython-39.pyc,,
+setuptools/command/__pycache__/bdist_rpm.cpython-39.pyc,,
+setuptools/command/__pycache__/bdist_wininst.cpython-39.pyc,,
+setuptools/command/__pycache__/build_clib.cpython-39.pyc,,
+setuptools/command/__pycache__/build_ext.cpython-39.pyc,,
+setuptools/command/__pycache__/build_py.cpython-39.pyc,,
+setuptools/command/__pycache__/develop.cpython-39.pyc,,
+setuptools/command/__pycache__/dist_info.cpython-39.pyc,,
+setuptools/command/__pycache__/easy_install.cpython-39.pyc,,
+setuptools/command/__pycache__/egg_info.cpython-39.pyc,,
+setuptools/command/__pycache__/install.cpython-39.pyc,,
+setuptools/command/__pycache__/install_egg_info.cpython-39.pyc,,
+setuptools/command/__pycache__/install_lib.cpython-39.pyc,,
+setuptools/command/__pycache__/install_scripts.cpython-39.pyc,,
+setuptools/command/__pycache__/py36compat.cpython-39.pyc,,
+setuptools/command/__pycache__/register.cpython-39.pyc,,
+setuptools/command/__pycache__/rotate.cpython-39.pyc,,
+setuptools/command/__pycache__/saveopts.cpython-39.pyc,,
+setuptools/command/__pycache__/sdist.cpython-39.pyc,,
+setuptools/command/__pycache__/setopt.cpython-39.pyc,,
+setuptools/command/__pycache__/test.cpython-39.pyc,,
+setuptools/command/__pycache__/upload.cpython-39.pyc,,
+setuptools/command/__pycache__/upload_docs.cpython-39.pyc,,
+setuptools/command/alias.py,sha256=KjpE0sz_SDIHv3fpZcIQK-sCkJz-SrC6Gmug6b9Nkc8,2426
+setuptools/command/bdist_egg.py,sha256=pVY95-nsM0U1_QmK01eLRedjWDw9ruEwrZxBae8FyZA,18482
+setuptools/command/bdist_rpm.py,sha256=B7l0TnzCGb-0nLlm6rS00jWLkojASwVmdhW2w5Qz_Ak,1508
+setuptools/command/bdist_wininst.py,sha256=Tmqa9wW0F8i_72KHWpu9pDdnCN6Er_8uJUs2UmCAwTA,922
+setuptools/command/build_clib.py,sha256=fWHSFGkk10VCddBWCszvNhowbG9Z9CZXVjQ2uSInoOs,4415
+setuptools/command/build_ext.py,sha256=RYS8cJvCwvusFnbKllvLtd6-HcR0dVIzX6zVrtw1Vc8,13187
+setuptools/command/build_py.py,sha256=fho10QRGOaJcc3vttQ5vk5KYMV6HdZwj9HUIob6NHDM,9737
+setuptools/command/develop.py,sha256=wF2CiU9wjCF8ZcfFzn02j2ylez8r13z_fEco6vWx3DM,8118
+setuptools/command/dist_info.py,sha256=5t6kOfrdgALT-P3ogss6PF9k-Leyesueycuk3dUyZnI,960
+setuptools/command/easy_install.py,sha256=T1d_3uQFLur6qNrNtEiiRVzleECvHBe9etr7o3Imquw,86924
+setuptools/command/egg_info.py,sha256=LKrhZuy-IoRJZ59orIB2-_Gj7NBj9MHm5uu16zZdE7U,25560
+setuptools/command/install.py,sha256=8doMxeQEDoK4Eco0mO2WlXXzzp9QnsGJQ7Z7yWkZPG8,4705
+setuptools/command/install_egg_info.py,sha256=bMgeIeRiXzQ4DAGPV1328kcjwQjHjOWU4FngAWLV78Q,2203
+setuptools/command/install_lib.py,sha256=Uz42McsyHZAjrB6cw9E7Bz0xsaTbzxnM1PI9CBhiPtE,3875
+setuptools/command/install_scripts.py,sha256=x7sdEICuyFpaf5LuWXcTp49oYt8EeNbwKkW2Pv-TVXI,2519
+setuptools/command/launcher manifest.xml,sha256=xlLbjWrB01tKC0-hlVkOKkiSPbzMml2eOPtJ_ucCnbE,628
+setuptools/command/py36compat.py,sha256=TKqF6CPv-vsEFpOJUYmjBzmck-mCv_zHJMXO500PEAI,4994
+setuptools/command/register.py,sha256=kk3DxXCb5lXTvqnhfwx2g6q7iwbUmgTyXUCaBooBOUk,468
+setuptools/command/rotate.py,sha256=1KD9hHoDWpyvsbc2L7ULrQxUpJsG5zIMlPfx8yLowk4,2176
+setuptools/command/saveopts.py,sha256=za7QCBcQimKKriWcoCcbhxPjUz30gSB74zuTL47xpP4,658
+setuptools/command/sdist.py,sha256=14kBw_QOZ9L_RQDqgf9DAlEuoj0zC30X5mfDWeiyZwU,8092
+setuptools/command/setopt.py,sha256=NTWDyx-gjDF-txf4dO577s7LOzHVoKR0Mq33rFxaRr8,5085
+setuptools/command/test.py,sha256=okVw2id6qYh8hFAVGziX6dEYekAbaYfMtEx7XhgsSbg,9623
+setuptools/command/upload.py,sha256=XT3YFVfYPAmA5qhGg0euluU98ftxRUW-PzKcODMLxUs,462
+setuptools/command/upload_docs.py,sha256=G2gHjeNPcUGe_pr3EEk_6AoVD0E6nCp52mZgU2nkCpU,7314
+setuptools/config.py,sha256=Ncxt5IQTVyM9qvX3PxB-Eb67-zoZLq5WbDuyu3I2gd0,21782
+setuptools/dep_util.py,sha256=BDx1BkzNQntvAB4alypHbW5UVBzjqths000PrUL4Zqc,949
+setuptools/depends.py,sha256=qt2RWllArRvhnm8lxsyRpcthEZYp4GHQgREl1q0LkFw,5517
+setuptools/dist.py,sha256=Of69bBpUzFWt9o_RTptPt-3MWVc3k_LId3b7hh8rBQs,39350
+setuptools/distutils_patch.py,sha256=r8LauqtVguTUFxguvU7tDhF8HTgAkIBHg5-hgPeSJ5c,1754
+setuptools/errors.py,sha256=MVOcv381HNSajDgEUWzOQ4J6B5BHCBMSjHfaWcEwA1o,524
+setuptools/extension.py,sha256=uc6nHI-MxwmNCNPbUiBnybSyqhpJqjbhvOQ-emdvt_E,1729
+setuptools/extern/__init__.py,sha256=BilMS9Hq18nBaUOzcCrzoI9HnIhju45iVJBscqTqlDI,2128
+setuptools/extern/__pycache__/__init__.cpython-39.pyc,,
+setuptools/glob.py,sha256=o75cHrOxYsvn854thSxE0x9k8JrKDuhP_rRXlVB00Q4,5084
+setuptools/gui-32.exe,sha256=XBr0bHMA6Hpz2s9s9Bzjl-PwXfa9nH4ie0rFn4V2kWA,65536
+setuptools/gui-64.exe,sha256=aYKMhX1IJLn4ULHgWX0sE0yREUt6B3TEHf_jOw6yNyE,75264
+setuptools/gui.exe,sha256=XBr0bHMA6Hpz2s9s9Bzjl-PwXfa9nH4ie0rFn4V2kWA,65536
+setuptools/installer.py,sha256=mJ6SdRmhWpZ1Cg3H_LWd1IoZoeC2t4BSkkXMuvhYeKw,5343
+setuptools/launch.py,sha256=TyPT-Ic1T2EnYvGO26gfNRP4ysBlrhpbRjQxWsiO414,812
+setuptools/lib2to3_ex.py,sha256=lrjhfs4QVtWp65PuATWjPBcXxwubg9d81e0qrv0qOpI,2384
+setuptools/monkey.py,sha256=FGc9fffh7gAxMLFmJs2DW_OYWpBjkdbNS2n14UAK4NA,5264
+setuptools/msvc.py,sha256=8xIqn20nZ_poynw6sDvZuUECN_KlOjdTNfossrlSMcY,51225
+setuptools/namespaces.py,sha256=QuvIR8S5-u_S8_fLjPpn_utruUIsu2twdRu_KJPrKU0,3223
+setuptools/package_index.py,sha256=oKRvghWBzlqlQV4iRUERwbpBs_rXL5mwlzNZdKI2yXs,40777
+setuptools/py27compat.py,sha256=CWHkWWAYodu3QgiIAr8-34T-G6fiSgiVF0y7h11Ld7U,1504
+setuptools/py31compat.py,sha256=h2rtZghOfwoGYd8sQ0-auaKiF3TcL3qX0bX3VessqcE,838
+setuptools/py33compat.py,sha256=SMF9Z8wnGicTOkU1uRNwZ_kz5Z_bj29PUBbqdqeeNsc,1330
+setuptools/py34compat.py,sha256=KYOd6ybRxjBW8NJmYD8t_UyyVmysppFXqHpFLdslGXU,245
+setuptools/sandbox.py,sha256=KOWl011mwUX2OdLmcTM690CTOneZEJxK9RIXbXyGL_o,14251
+setuptools/script (dev).tmpl,sha256=RUzQzCQUaXtwdLtYHWYbIQmOaES5Brqq1FvUA_tu-5I,218
+setuptools/script.tmpl,sha256=WGTt5piezO27c-Dbx6l5Q4T3Ff20A5z7872hv3aAhYY,138
+setuptools/ssl_support.py,sha256=TNNOq3VyV-4wkRwm0dmyIzF-iXBeWv4yIQ99eWa_bV8,8543
+setuptools/unicode_utils.py,sha256=NOiZ_5hD72A6w-4wVj8awHFM3n51Kmw1Ic_vx15XFqw,996
+setuptools/version.py,sha256=og_cuZQb0QI6ukKZFfZWPlr1HgJBPPn2vO2m_bI9ZTE,144
+setuptools/wheel.py,sha256=YLN2fczDVxkX3wjHlt_EMh-4MfHO6Ns6ldRpnkn-aa8,8371
+setuptools/windows_support.py,sha256=5GrfqSP2-dLGJoZTq2g6dCKkyQxxa2n5IQiXlJCoYEE,714
diff --git a/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/REQUESTED b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/REQUESTED
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/WHEEL
new file mode 100644
index 0000000..b552003
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/dependency_links.txt b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/dependency_links.txt
new file mode 100644
index 0000000..e87d021
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/dependency_links.txt
@@ -0,0 +1,2 @@
+https://files.pythonhosted.org/packages/source/c/certifi/certifi-2016.9.26.tar.gz#md5=baa81e951a29958563689d868ef1064d
+https://files.pythonhosted.org/packages/source/w/wincertstore/wincertstore-0.2.zip#md5=ae728f2f007185648d0c7a8679b361e2
diff --git a/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/entry_points.txt
new file mode 100644
index 0000000..f57c6d2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/entry_points.txt
@@ -0,0 +1,68 @@
+[console_scripts]
+easy_install = setuptools.command.easy_install:main
+easy_install-3.8 = setuptools.command.easy_install:main
+
+[distutils.commands]
+alias = setuptools.command.alias:alias
+bdist_egg = setuptools.command.bdist_egg:bdist_egg
+bdist_rpm = setuptools.command.bdist_rpm:bdist_rpm
+bdist_wininst = setuptools.command.bdist_wininst:bdist_wininst
+build_clib = setuptools.command.build_clib:build_clib
+build_ext = setuptools.command.build_ext:build_ext
+build_py = setuptools.command.build_py:build_py
+develop = setuptools.command.develop:develop
+dist_info = setuptools.command.dist_info:dist_info
+easy_install = setuptools.command.easy_install:easy_install
+egg_info = setuptools.command.egg_info:egg_info
+install = setuptools.command.install:install
+install_egg_info = setuptools.command.install_egg_info:install_egg_info
+install_lib = setuptools.command.install_lib:install_lib
+install_scripts = setuptools.command.install_scripts:install_scripts
+rotate = setuptools.command.rotate:rotate
+saveopts = setuptools.command.saveopts:saveopts
+sdist = setuptools.command.sdist:sdist
+setopt = setuptools.command.setopt:setopt
+test = setuptools.command.test:test
+upload_docs = setuptools.command.upload_docs:upload_docs
+
+[distutils.setup_keywords]
+convert_2to3_doctests = setuptools.dist:assert_string_list
+dependency_links = setuptools.dist:assert_string_list
+eager_resources = setuptools.dist:assert_string_list
+entry_points = setuptools.dist:check_entry_points
+exclude_package_data = setuptools.dist:check_package_data
+extras_require = setuptools.dist:check_extras
+include_package_data = setuptools.dist:assert_bool
+install_requires = setuptools.dist:check_requirements
+namespace_packages = setuptools.dist:check_nsp
+package_data = setuptools.dist:check_package_data
+packages = setuptools.dist:check_packages
+python_requires = setuptools.dist:check_specifier
+setup_requires = setuptools.dist:check_requirements
+test_loader = setuptools.dist:check_importable
+test_runner = setuptools.dist:check_importable
+test_suite = setuptools.dist:check_test_suite
+tests_require = setuptools.dist:check_requirements
+use_2to3 = setuptools.dist:assert_bool
+use_2to3_exclude_fixers = setuptools.dist:assert_string_list
+use_2to3_fixers = setuptools.dist:assert_string_list
+zip_safe = setuptools.dist:assert_bool
+
+[egg_info.writers]
+PKG-INFO = setuptools.command.egg_info:write_pkg_info
+dependency_links.txt = setuptools.command.egg_info:overwrite_arg
+depends.txt = setuptools.command.egg_info:warn_depends_obsolete
+eager_resources.txt = setuptools.command.egg_info:overwrite_arg
+entry_points.txt = setuptools.command.egg_info:write_entries
+namespace_packages.txt = setuptools.command.egg_info:overwrite_arg
+requires.txt = setuptools.command.egg_info:write_requirements
+top_level.txt = setuptools.command.egg_info:write_toplevel_names
+
+[setuptools.finalize_distribution_options]
+2to3_doctests = setuptools.dist:Distribution._finalize_2to3_doctests
+keywords = setuptools.dist:Distribution._finalize_setup_keywords
+parent_finalize = setuptools.dist:_Distribution.finalize_options
+
+[setuptools.installation]
+eggsecutable = setuptools.command.easy_install:bootstrap
+
diff --git a/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/top_level.txt
new file mode 100644
index 0000000..4577c6a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/top_level.txt
@@ -0,0 +1,3 @@
+easy_install
+pkg_resources
+setuptools
diff --git a/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/zip-safe b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/zip-safe
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools-49.2.1.dist-info/zip-safe
@@ -0,0 +1 @@
+
diff --git a/myenv/lib/python3.9/site-packages/setuptools/__init__.py b/myenv/lib/python3.9/site-packages/setuptools/__init__.py
new file mode 100644
index 0000000..8388251
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/__init__.py
@@ -0,0 +1,253 @@
+"""Extensions to the 'distutils' for large or complex distributions"""
+
+import os
+import functools
+
+# Disabled for now due to: #2228, #2230
+import setuptools.distutils_patch  # noqa: F401
+
+import distutils.core
+import distutils.filelist
+import re
+from distutils.errors import DistutilsOptionError
+from distutils.util import convert_path
+from fnmatch import fnmatchcase
+
+from ._deprecation_warning import SetuptoolsDeprecationWarning
+
+from setuptools.extern.six import PY3, string_types
+from setuptools.extern.six.moves import filter, map
+
+import setuptools.version
+from setuptools.extension import Extension
+from setuptools.dist import Distribution
+from setuptools.depends import Require
+from . import monkey
+
+__metaclass__ = type
+
+
+__all__ = [
+    'setup', 'Distribution', 'Command', 'Extension', 'Require',
+    'SetuptoolsDeprecationWarning',
+    'find_packages'
+]
+
+if PY3:
+    __all__.append('find_namespace_packages')
+
+__version__ = setuptools.version.__version__
+
+bootstrap_install_from = None
+
+# If we run 2to3 on .py files, should we also convert docstrings?
+# Default: yes; assume that we can detect doctests reliably
+run_2to3_on_doctests = True
+# Standard package names for fixer packages
+lib2to3_fixer_packages = ['lib2to3.fixes']
+
+
+class PackageFinder:
+    """
+    Generate a list of all Python packages found within a directory
+    """
+
+    @classmethod
+    def find(cls, where='.', exclude=(), include=('*',)):
+        """Return a list all Python packages found within directory 'where'
+
+        'where' is the root directory which will be searched for packages.  It
+        should be supplied as a "cross-platform" (i.e. URL-style) path; it will
+        be converted to the appropriate local path syntax.
+
+        'exclude' is a sequence of package names to exclude; '*' can be used
+        as a wildcard in the names, such that 'foo.*' will exclude all
+        subpackages of 'foo' (but not 'foo' itself).
+
+        'include' is a sequence of package names to include.  If it's
+        specified, only the named packages will be included.  If it's not
+        specified, all found packages will be included.  'include' can contain
+        shell style wildcard patterns just like 'exclude'.
+        """
+
+        return list(cls._find_packages_iter(
+            convert_path(where),
+            cls._build_filter('ez_setup', '*__pycache__', *exclude),
+            cls._build_filter(*include)))
+
+    @classmethod
+    def _find_packages_iter(cls, where, exclude, include):
+        """
+        All the packages found in 'where' that pass the 'include' filter, but
+        not the 'exclude' filter.
+        """
+        for root, dirs, files in os.walk(where, followlinks=True):
+            # Copy dirs to iterate over it, then empty dirs.
+            all_dirs = dirs[:]
+            dirs[:] = []
+
+            for dir in all_dirs:
+                full_path = os.path.join(root, dir)
+                rel_path = os.path.relpath(full_path, where)
+                package = rel_path.replace(os.path.sep, '.')
+
+                # Skip directory trees that are not valid packages
+                if ('.' in dir or not cls._looks_like_package(full_path)):
+                    continue
+
+                # Should this package be included?
+                if include(package) and not exclude(package):
+                    yield package
+
+                # Keep searching subdirectories, as there may be more packages
+                # down there, even if the parent was excluded.
+                dirs.append(dir)
+
+    @staticmethod
+    def _looks_like_package(path):
+        """Does a directory look like a package?"""
+        return os.path.isfile(os.path.join(path, '__init__.py'))
+
+    @staticmethod
+    def _build_filter(*patterns):
+        """
+        Given a list of patterns, return a callable that will be true only if
+        the input matches at least one of the patterns.
+        """
+        return lambda name: any(fnmatchcase(name, pat=pat) for pat in patterns)
+
+
+class PEP420PackageFinder(PackageFinder):
+    @staticmethod
+    def _looks_like_package(path):
+        return True
+
+
+find_packages = PackageFinder.find
+
+if PY3:
+    find_namespace_packages = PEP420PackageFinder.find
+
+
+def _install_setup_requires(attrs):
+    # Note: do not use `setuptools.Distribution` directly, as
+    # our PEP 517 backend patch `distutils.core.Distribution`.
+    class MinimalDistribution(distutils.core.Distribution):
+        """
+        A minimal version of a distribution for supporting the
+        fetch_build_eggs interface.
+        """
+        def __init__(self, attrs):
+            _incl = 'dependency_links', 'setup_requires'
+            filtered = {
+                k: attrs[k]
+                for k in set(_incl) & set(attrs)
+            }
+            distutils.core.Distribution.__init__(self, filtered)
+
+        def finalize_options(self):
+            """
+            Disable finalize_options to avoid building the working set.
+            Ref #2158.
+            """
+
+    dist = MinimalDistribution(attrs)
+
+    # Honor setup.cfg's options.
+    dist.parse_config_files(ignore_option_errors=True)
+    if dist.setup_requires:
+        dist.fetch_build_eggs(dist.setup_requires)
+
+
+def setup(**attrs):
+    # Make sure we have any requirements needed to interpret 'attrs'.
+    _install_setup_requires(attrs)
+    return distutils.core.setup(**attrs)
+
+
+setup.__doc__ = distutils.core.setup.__doc__
+
+
+_Command = monkey.get_unpatched(distutils.core.Command)
+
+
+class Command(_Command):
+    __doc__ = _Command.__doc__
+
+    command_consumes_arguments = False
+
+    def __init__(self, dist, **kw):
+        """
+        Construct the command for dist, updating
+        vars(self) with any keyword parameters.
+        """
+        _Command.__init__(self, dist)
+        vars(self).update(kw)
+
+    def _ensure_stringlike(self, option, what, default=None):
+        val = getattr(self, option)
+        if val is None:
+            setattr(self, option, default)
+            return default
+        elif not isinstance(val, string_types):
+            raise DistutilsOptionError("'%s' must be a %s (got `%s`)"
+                                       % (option, what, val))
+        return val
+
+    def ensure_string_list(self, option):
+        r"""Ensure that 'option' is a list of strings.  If 'option' is
+        currently a string, we split it either on /,\s*/ or /\s+/, so
+        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
+        ["foo", "bar", "baz"].
+        """
+        val = getattr(self, option)
+        if val is None:
+            return
+        elif isinstance(val, string_types):
+            setattr(self, option, re.split(r',\s*|\s+', val))
+        else:
+            if isinstance(val, list):
+                ok = all(isinstance(v, string_types) for v in val)
+            else:
+                ok = False
+            if not ok:
+                raise DistutilsOptionError(
+                    "'%s' must be a list of strings (got %r)"
+                    % (option, val))
+
+    def reinitialize_command(self, command, reinit_subcommands=0, **kw):
+        cmd = _Command.reinitialize_command(self, command, reinit_subcommands)
+        vars(cmd).update(kw)
+        return cmd
+
+
+def _find_all_simple(path):
+    """
+    Find all files under 'path'
+    """
+    results = (
+        os.path.join(base, file)
+        for base, dirs, files in os.walk(path, followlinks=True)
+        for file in files
+    )
+    return filter(os.path.isfile, results)
+
+
+def findall(dir=os.curdir):
+    """
+    Find all files under 'dir' and return the list of full filenames.
+    Unless dir is '.', return full filenames with dir prepended.
+    """
+    files = _find_all_simple(dir)
+    if dir == os.curdir:
+        make_rel = functools.partial(os.path.relpath, start=dir)
+        files = map(make_rel, files)
+    return list(files)
+
+
+class sic(str):
+    """Treat this string as-is (https://en.wikipedia.org/wiki/Sic)"""
+
+
+# Apply monkey patches
+monkey.patch_all()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_deprecation_warning.py b/myenv/lib/python3.9/site-packages/setuptools/_deprecation_warning.py
new file mode 100644
index 0000000..086b64d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_deprecation_warning.py
@@ -0,0 +1,7 @@
+class SetuptoolsDeprecationWarning(Warning):
+    """
+    Base class for warning deprecations in ``setuptools``
+
+    This class is not derived from ``DeprecationWarning``, and as such is
+    visible by default.
+    """
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/__init__.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/__init__.py
new file mode 100644
index 0000000..7dac55b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/__init__.py
@@ -0,0 +1,15 @@
+"""distutils
+
+The main package for the Python Module Distribution Utilities.  Normally
+used from a setup script as
+
+   from distutils.core import setup
+
+   setup (...)
+"""
+
+import sys
+
+__version__ = sys.version[:sys.version.index(' ')]
+
+local = True
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/_msvccompiler.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/_msvccompiler.py
new file mode 100644
index 0000000..2d56ee0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/_msvccompiler.py
@@ -0,0 +1,537 @@
+"""distutils._msvccompiler
+
+Contains MSVCCompiler, an implementation of the abstract CCompiler class
+for Microsoft Visual Studio 2015.
+
+The module is compatible with VS 2015 and later. You can find legacy support
+for older versions in distutils.msvc9compiler and distutils.msvccompiler.
+"""
+
+# Written by Perry Stoll
+# hacked by Robin Becker and Thomas Heller to do a better job of
+#   finding DevStudio (through the registry)
+# ported to VS 2005 and VS 2008 by Christian Heimes
+# ported to VS 2015 by Steve Dower
+
+import os
+import subprocess
+import contextlib
+with contextlib.suppress(ImportError):
+    import winreg
+
+from distutils.errors import DistutilsExecError, DistutilsPlatformError, \
+                             CompileError, LibError, LinkError
+from distutils.ccompiler import CCompiler, gen_lib_options
+from distutils import log
+from distutils.util import get_platform
+
+from itertools import count
+
+def _find_vc2015():
+    try:
+        key = winreg.OpenKeyEx(
+            winreg.HKEY_LOCAL_MACHINE,
+            r"Software\Microsoft\VisualStudio\SxS\VC7",
+            access=winreg.KEY_READ | winreg.KEY_WOW64_32KEY
+        )
+    except OSError:
+        log.debug("Visual C++ is not registered")
+        return None, None
+
+    best_version = 0
+    best_dir = None
+    with key:
+        for i in count():
+            try:
+                v, vc_dir, vt = winreg.EnumValue(key, i)
+            except OSError:
+                break
+            if v and vt == winreg.REG_SZ and os.path.isdir(vc_dir):
+                try:
+                    version = int(float(v))
+                except (ValueError, TypeError):
+                    continue
+                if version >= 14 and version > best_version:
+                    best_version, best_dir = version, vc_dir
+    return best_version, best_dir
+
+def _find_vc2017():
+    """Returns "15, path" based on the result of invoking vswhere.exe
+    If no install is found, returns "None, None"
+
+    The version is returned to avoid unnecessarily changing the function
+    result. It may be ignored when the path is not None.
+
+    If vswhere.exe is not available, by definition, VS 2017 is not
+    installed.
+    """
+    root = os.environ.get("ProgramFiles(x86)") or os.environ.get("ProgramFiles")
+    if not root:
+        return None, None
+
+    try:
+        path = subprocess.check_output([
+            os.path.join(root, "Microsoft Visual Studio", "Installer", "vswhere.exe"),
+            "-latest",
+            "-prerelease",
+            "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
+            "-property", "installationPath",
+            "-products", "*",
+        ], encoding="mbcs", errors="strict").strip()
+    except (subprocess.CalledProcessError, OSError, UnicodeDecodeError):
+        return None, None
+
+    path = os.path.join(path, "VC", "Auxiliary", "Build")
+    if os.path.isdir(path):
+        return 15, path
+
+    return None, None
+
+PLAT_SPEC_TO_RUNTIME = {
+    'x86' : 'x86',
+    'x86_amd64' : 'x64',
+    'x86_arm' : 'arm',
+    'x86_arm64' : 'arm64'
+}
+
+def _find_vcvarsall(plat_spec):
+    # bpo-38597: Removed vcruntime return value
+    _, best_dir = _find_vc2017()
+
+    if not best_dir:
+        best_version, best_dir = _find_vc2015()
+
+    if not best_dir:
+        log.debug("No suitable Visual C++ version found")
+        return None, None
+
+    vcvarsall = os.path.join(best_dir, "vcvarsall.bat")
+    if not os.path.isfile(vcvarsall):
+        log.debug("%s cannot be found", vcvarsall)
+        return None, None
+
+    return vcvarsall, None
+
+def _get_vc_env(plat_spec):
+    if os.getenv("DISTUTILS_USE_SDK"):
+        return {
+            key.lower(): value
+            for key, value in os.environ.items()
+        }
+
+    vcvarsall, _ = _find_vcvarsall(plat_spec)
+    if not vcvarsall:
+        raise DistutilsPlatformError("Unable to find vcvarsall.bat")
+
+    try:
+        out = subprocess.check_output(
+            'cmd /u /c "{}" {} && set'.format(vcvarsall, plat_spec),
+            stderr=subprocess.STDOUT,
+        ).decode('utf-16le', errors='replace')
+    except subprocess.CalledProcessError as exc:
+        log.error(exc.output)
+        raise DistutilsPlatformError("Error executing {}"
+                .format(exc.cmd))
+
+    env = {
+        key.lower(): value
+        for key, _, value in
+        (line.partition('=') for line in out.splitlines())
+        if key and value
+    }
+
+    return env
+
+def _find_exe(exe, paths=None):
+    """Return path to an MSVC executable program.
+
+    Tries to find the program in several places: first, one of the
+    MSVC program search paths from the registry; next, the directories
+    in the PATH environment variable.  If any of those work, return an
+    absolute path that is known to exist.  If none of them work, just
+    return the original program name, 'exe'.
+    """
+    if not paths:
+        paths = os.getenv('path').split(os.pathsep)
+    for p in paths:
+        fn = os.path.join(os.path.abspath(p), exe)
+        if os.path.isfile(fn):
+            return fn
+    return exe
+
+# A map keyed by get_platform() return values to values accepted by
+# 'vcvarsall.bat'. Always cross-compile from x86 to work with the
+# lighter-weight MSVC installs that do not include native 64-bit tools.
+PLAT_TO_VCVARS = {
+    'win32' : 'x86',
+    'win-amd64' : 'x86_amd64',
+    'win-arm32' : 'x86_arm',
+    'win-arm64' : 'x86_arm64'
+}
+
+class MSVCCompiler(CCompiler) :
+    """Concrete class that implements an interface to Microsoft Visual C++,
+       as defined by the CCompiler abstract class."""
+
+    compiler_type = 'msvc'
+
+    # Just set this so CCompiler's constructor doesn't barf.  We currently
+    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
+    # as it really isn't necessary for this sort of single-compiler class.
+    # Would be nice to have a consistent interface with UnixCCompiler,
+    # though, so it's worth thinking about.
+    executables = {}
+
+    # Private class data (need to distinguish C from C++ source for compiler)
+    _c_extensions = ['.c']
+    _cpp_extensions = ['.cc', '.cpp', '.cxx']
+    _rc_extensions = ['.rc']
+    _mc_extensions = ['.mc']
+
+    # Needed for the filename generation methods provided by the
+    # base class, CCompiler.
+    src_extensions = (_c_extensions + _cpp_extensions +
+                      _rc_extensions + _mc_extensions)
+    res_extension = '.res'
+    obj_extension = '.obj'
+    static_lib_extension = '.lib'
+    shared_lib_extension = '.dll'
+    static_lib_format = shared_lib_format = '%s%s'
+    exe_extension = '.exe'
+
+
+    def __init__(self, verbose=0, dry_run=0, force=0):
+        CCompiler.__init__ (self, verbose, dry_run, force)
+        # target platform (.plat_name is consistent with 'bdist')
+        self.plat_name = None
+        self.initialized = False
+
+    def initialize(self, plat_name=None):
+        # multi-init means we would need to check platform same each time...
+        assert not self.initialized, "don't init multiple times"
+        if plat_name is None:
+            plat_name = get_platform()
+        # sanity check for platforms to prevent obscure errors later.
+        if plat_name not in PLAT_TO_VCVARS:
+            raise DistutilsPlatformError("--plat-name must be one of {}"
+                                         .format(tuple(PLAT_TO_VCVARS)))
+
+        # Get the vcvarsall.bat spec for the requested platform.
+        plat_spec = PLAT_TO_VCVARS[plat_name]
+
+        vc_env = _get_vc_env(plat_spec)
+        if not vc_env:
+            raise DistutilsPlatformError("Unable to find a compatible "
+                "Visual Studio installation.")
+
+        self._paths = vc_env.get('path', '')
+        paths = self._paths.split(os.pathsep)
+        self.cc = _find_exe("cl.exe", paths)
+        self.linker = _find_exe("link.exe", paths)
+        self.lib = _find_exe("lib.exe", paths)
+        self.rc = _find_exe("rc.exe", paths)   # resource compiler
+        self.mc = _find_exe("mc.exe", paths)   # message compiler
+        self.mt = _find_exe("mt.exe", paths)   # message compiler
+
+        for dir in vc_env.get('include', '').split(os.pathsep):
+            if dir:
+                self.add_include_dir(dir.rstrip(os.sep))
+
+        for dir in vc_env.get('lib', '').split(os.pathsep):
+            if dir:
+                self.add_library_dir(dir.rstrip(os.sep))
+
+        self.preprocess_options = None
+        # bpo-38597: Always compile with dynamic linking
+        # Future releases of Python 3.x will include all past
+        # versions of vcruntime*.dll for compatibility.
+        self.compile_options = [
+            '/nologo', '/Ox', '/W3', '/GL', '/DNDEBUG', '/MD'
+        ]
+
+        self.compile_options_debug = [
+            '/nologo', '/Od', '/MDd', '/Zi', '/W3', '/D_DEBUG'
+        ]
+
+        ldflags = [
+            '/nologo', '/INCREMENTAL:NO', '/LTCG'
+        ]
+
+        ldflags_debug = [
+            '/nologo', '/INCREMENTAL:NO', '/LTCG', '/DEBUG:FULL'
+        ]
+
+        self.ldflags_exe = [*ldflags, '/MANIFEST:EMBED,ID=1']
+        self.ldflags_exe_debug = [*ldflags_debug, '/MANIFEST:EMBED,ID=1']
+        self.ldflags_shared = [*ldflags, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO']
+        self.ldflags_shared_debug = [*ldflags_debug, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO']
+        self.ldflags_static = [*ldflags]
+        self.ldflags_static_debug = [*ldflags_debug]
+
+        self._ldflags = {
+            (CCompiler.EXECUTABLE, None): self.ldflags_exe,
+            (CCompiler.EXECUTABLE, False): self.ldflags_exe,
+            (CCompiler.EXECUTABLE, True): self.ldflags_exe_debug,
+            (CCompiler.SHARED_OBJECT, None): self.ldflags_shared,
+            (CCompiler.SHARED_OBJECT, False): self.ldflags_shared,
+            (CCompiler.SHARED_OBJECT, True): self.ldflags_shared_debug,
+            (CCompiler.SHARED_LIBRARY, None): self.ldflags_static,
+            (CCompiler.SHARED_LIBRARY, False): self.ldflags_static,
+            (CCompiler.SHARED_LIBRARY, True): self.ldflags_static_debug,
+        }
+
+        self.initialized = True
+
+    # -- Worker methods ------------------------------------------------
+
+    def object_filenames(self,
+                         source_filenames,
+                         strip_dir=0,
+                         output_dir=''):
+        ext_map = {
+            **{ext: self.obj_extension for ext in self.src_extensions},
+            **{ext: self.res_extension for ext in self._rc_extensions + self._mc_extensions},
+        }
+
+        output_dir = output_dir or ''
+
+        def make_out_path(p):
+            base, ext = os.path.splitext(p)
+            if strip_dir:
+                base = os.path.basename(base)
+            else:
+                _, base = os.path.splitdrive(base)
+                if base.startswith((os.path.sep, os.path.altsep)):
+                    base = base[1:]
+            try:
+                # XXX: This may produce absurdly long paths. We should check
+                # the length of the result and trim base until we fit within
+                # 260 characters.
+                return os.path.join(output_dir, base + ext_map[ext])
+            except LookupError:
+                # Better to raise an exception instead of silently continuing
+                # and later complain about sources and targets having
+                # different lengths
+                raise CompileError("Don't know how to compile {}".format(p))
+
+        return list(map(make_out_path, source_filenames))
+
+
+    def compile(self, sources,
+                output_dir=None, macros=None, include_dirs=None, debug=0,
+                extra_preargs=None, extra_postargs=None, depends=None):
+
+        if not self.initialized:
+            self.initialize()
+        compile_info = self._setup_compile(output_dir, macros, include_dirs,
+                                           sources, depends, extra_postargs)
+        macros, objects, extra_postargs, pp_opts, build = compile_info
+
+        compile_opts = extra_preargs or []
+        compile_opts.append('/c')
+        if debug:
+            compile_opts.extend(self.compile_options_debug)
+        else:
+            compile_opts.extend(self.compile_options)
+
+
+        add_cpp_opts = False
+
+        for obj in objects:
+            try:
+                src, ext = build[obj]
+            except KeyError:
+                continue
+            if debug:
+                # pass the full pathname to MSVC in debug mode,
+                # this allows the debugger to find the source file
+                # without asking the user to browse for it
+                src = os.path.abspath(src)
+
+            if ext in self._c_extensions:
+                input_opt = "/Tc" + src
+            elif ext in self._cpp_extensions:
+                input_opt = "/Tp" + src
+                add_cpp_opts = True
+            elif ext in self._rc_extensions:
+                # compile .RC to .RES file
+                input_opt = src
+                output_opt = "/fo" + obj
+                try:
+                    self.spawn([self.rc] + pp_opts + [output_opt, input_opt])
+                except DistutilsExecError as msg:
+                    raise CompileError(msg)
+                continue
+            elif ext in self._mc_extensions:
+                # Compile .MC to .RC file to .RES file.
+                #   * '-h dir' specifies the directory for the
+                #     generated include file
+                #   * '-r dir' specifies the target directory of the
+                #     generated RC file and the binary message resource
+                #     it includes
+                #
+                # For now (since there are no options to change this),
+                # we use the source-directory for the include file and
+                # the build directory for the RC file and message
+                # resources. This works at least for win32all.
+                h_dir = os.path.dirname(src)
+                rc_dir = os.path.dirname(obj)
+                try:
+                    # first compile .MC to .RC and .H file
+                    self.spawn([self.mc, '-h', h_dir, '-r', rc_dir, src])
+                    base, _ = os.path.splitext(os.path.basename (src))
+                    rc_file = os.path.join(rc_dir, base + '.rc')
+                    # then compile .RC to .RES file
+                    self.spawn([self.rc, "/fo" + obj, rc_file])
+
+                except DistutilsExecError as msg:
+                    raise CompileError(msg)
+                continue
+            else:
+                # how to handle this file?
+                raise CompileError("Don't know how to compile {} to {}"
+                                   .format(src, obj))
+
+            args = [self.cc] + compile_opts + pp_opts
+            if add_cpp_opts:
+                args.append('/EHsc')
+            args.append(input_opt)
+            args.append("/Fo" + obj)
+            args.extend(extra_postargs)
+
+            try:
+                self.spawn(args)
+            except DistutilsExecError as msg:
+                raise CompileError(msg)
+
+        return objects
+
+
+    def create_static_lib(self,
+                          objects,
+                          output_libname,
+                          output_dir=None,
+                          debug=0,
+                          target_lang=None):
+
+        if not self.initialized:
+            self.initialize()
+        objects, output_dir = self._fix_object_args(objects, output_dir)
+        output_filename = self.library_filename(output_libname,
+                                                output_dir=output_dir)
+
+        if self._need_link(objects, output_filename):
+            lib_args = objects + ['/OUT:' + output_filename]
+            if debug:
+                pass # XXX what goes here?
+            try:
+                log.debug('Executing "%s" %s', self.lib, ' '.join(lib_args))
+                self.spawn([self.lib] + lib_args)
+            except DistutilsExecError as msg:
+                raise LibError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+
+    def link(self,
+             target_desc,
+             objects,
+             output_filename,
+             output_dir=None,
+             libraries=None,
+             library_dirs=None,
+             runtime_library_dirs=None,
+             export_symbols=None,
+             debug=0,
+             extra_preargs=None,
+             extra_postargs=None,
+             build_temp=None,
+             target_lang=None):
+
+        if not self.initialized:
+            self.initialize()
+        objects, output_dir = self._fix_object_args(objects, output_dir)
+        fixed_args = self._fix_lib_args(libraries, library_dirs,
+                                        runtime_library_dirs)
+        libraries, library_dirs, runtime_library_dirs = fixed_args
+
+        if runtime_library_dirs:
+            self.warn("I don't know what to do with 'runtime_library_dirs': "
+                       + str(runtime_library_dirs))
+
+        lib_opts = gen_lib_options(self,
+                                   library_dirs, runtime_library_dirs,
+                                   libraries)
+        if output_dir is not None:
+            output_filename = os.path.join(output_dir, output_filename)
+
+        if self._need_link(objects, output_filename):
+            ldflags = self._ldflags[target_desc, debug]
+
+            export_opts = ["/EXPORT:" + sym for sym in (export_symbols or [])]
+
+            ld_args = (ldflags + lib_opts + export_opts +
+                       objects + ['/OUT:' + output_filename])
+
+            # The MSVC linker generates .lib and .exp files, which cannot be
+            # suppressed by any linker switches. The .lib files may even be
+            # needed! Make sure they are generated in the temporary build
+            # directory. Since they have different names for debug and release
+            # builds, they can go into the same directory.
+            build_temp = os.path.dirname(objects[0])
+            if export_symbols is not None:
+                (dll_name, dll_ext) = os.path.splitext(
+                    os.path.basename(output_filename))
+                implib_file = os.path.join(
+                    build_temp,
+                    self.library_filename(dll_name))
+                ld_args.append ('/IMPLIB:' + implib_file)
+
+            if extra_preargs:
+                ld_args[:0] = extra_preargs
+            if extra_postargs:
+                ld_args.extend(extra_postargs)
+
+            output_dir = os.path.dirname(os.path.abspath(output_filename))
+            self.mkpath(output_dir)
+            try:
+                log.debug('Executing "%s" %s', self.linker, ' '.join(ld_args))
+                self.spawn([self.linker] + ld_args)
+            except DistutilsExecError as msg:
+                raise LinkError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+    def spawn(self, cmd):
+        env = dict(os.environ, PATH=self._paths)
+        return super().spawn(cmd, env=env)
+
+    # -- Miscellaneous methods -----------------------------------------
+    # These are all used by the 'gen_lib_options() function, in
+    # ccompiler.py.
+
+    def library_dir_option(self, dir):
+        return "/LIBPATH:" + dir
+
+    def runtime_library_dir_option(self, dir):
+        raise DistutilsPlatformError(
+              "don't know how to set runtime library search path for MSVC")
+
+    def library_option(self, lib):
+        return self.library_filename(lib)
+
+    def find_library_file(self, dirs, lib, debug=0):
+        # Prefer a debugging library if found (and requested), but deal
+        # with it if we don't have one.
+        if debug:
+            try_names = [lib + "_d", lib]
+        else:
+            try_names = [lib]
+        for dir in dirs:
+            for name in try_names:
+                libfile = os.path.join(dir, self.library_filename(name))
+                if os.path.isfile(libfile):
+                    return libfile
+        else:
+            # Oops, didn't find it in *any* of 'dirs'
+            return None
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/archive_util.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/archive_util.py
new file mode 100644
index 0000000..565a311
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/archive_util.py
@@ -0,0 +1,256 @@
+"""distutils.archive_util
+
+Utility functions for creating archive files (tarballs, zip files,
+that sort of thing)."""
+
+import os
+from warnings import warn
+import sys
+
+try:
+    import zipfile
+except ImportError:
+    zipfile = None
+
+
+from distutils.errors import DistutilsExecError
+from distutils.spawn import spawn
+from distutils.dir_util import mkpath
+from distutils import log
+
+try:
+    from pwd import getpwnam
+except ImportError:
+    getpwnam = None
+
+try:
+    from grp import getgrnam
+except ImportError:
+    getgrnam = None
+
+def _get_gid(name):
+    """Returns a gid, given a group name."""
+    if getgrnam is None or name is None:
+        return None
+    try:
+        result = getgrnam(name)
+    except KeyError:
+        result = None
+    if result is not None:
+        return result[2]
+    return None
+
+def _get_uid(name):
+    """Returns an uid, given a user name."""
+    if getpwnam is None or name is None:
+        return None
+    try:
+        result = getpwnam(name)
+    except KeyError:
+        result = None
+    if result is not None:
+        return result[2]
+    return None
+
+def make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0,
+                 owner=None, group=None):
+    """Create a (possibly compressed) tar file from all the files under
+    'base_dir'.
+
+    'compress' must be "gzip" (the default), "bzip2", "xz", "compress", or
+    None.  ("compress" will be deprecated in Python 3.2)
+
+    'owner' and 'group' can be used to define an owner and a group for the
+    archive that is being built. If not provided, the current owner and group
+    will be used.
+
+    The output tar file will be named 'base_dir' +  ".tar", possibly plus
+    the appropriate compression extension (".gz", ".bz2", ".xz" or ".Z").
+
+    Returns the output filename.
+    """
+    tar_compression = {'gzip': 'gz', 'bzip2': 'bz2', 'xz': 'xz', None: '',
+                       'compress': ''}
+    compress_ext = {'gzip': '.gz', 'bzip2': '.bz2', 'xz': '.xz',
+                    'compress': '.Z'}
+
+    # flags for compression program, each element of list will be an argument
+    if compress is not None and compress not in compress_ext.keys():
+        raise ValueError(
+              "bad value for 'compress': must be None, 'gzip', 'bzip2', "
+              "'xz' or 'compress'")
+
+    archive_name = base_name + '.tar'
+    if compress != 'compress':
+        archive_name += compress_ext.get(compress, '')
+
+    mkpath(os.path.dirname(archive_name), dry_run=dry_run)
+
+    # creating the tarball
+    import tarfile  # late import so Python build itself doesn't break
+
+    log.info('Creating tar archive')
+
+    uid = _get_uid(owner)
+    gid = _get_gid(group)
+
+    def _set_uid_gid(tarinfo):
+        if gid is not None:
+            tarinfo.gid = gid
+            tarinfo.gname = group
+        if uid is not None:
+            tarinfo.uid = uid
+            tarinfo.uname = owner
+        return tarinfo
+
+    if not dry_run:
+        tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
+        try:
+            tar.add(base_dir, filter=_set_uid_gid)
+        finally:
+            tar.close()
+
+    # compression using `compress`
+    if compress == 'compress':
+        warn("'compress' will be deprecated.", PendingDeprecationWarning)
+        # the option varies depending on the platform
+        compressed_name = archive_name + compress_ext[compress]
+        if sys.platform == 'win32':
+            cmd = [compress, archive_name, compressed_name]
+        else:
+            cmd = [compress, '-f', archive_name]
+        spawn(cmd, dry_run=dry_run)
+        return compressed_name
+
+    return archive_name
+
+def make_zipfile(base_name, base_dir, verbose=0, dry_run=0):
+    """Create a zip file from all the files under 'base_dir'.
+
+    The output zip file will be named 'base_name' + ".zip".  Uses either the
+    "zipfile" Python module (if available) or the InfoZIP "zip" utility
+    (if installed and found on the default search path).  If neither tool is
+    available, raises DistutilsExecError.  Returns the name of the output zip
+    file.
+    """
+    zip_filename = base_name + ".zip"
+    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
+
+    # If zipfile module is not available, try spawning an external
+    # 'zip' command.
+    if zipfile is None:
+        if verbose:
+            zipoptions = "-r"
+        else:
+            zipoptions = "-rq"
+
+        try:
+            spawn(["zip", zipoptions, zip_filename, base_dir],
+                  dry_run=dry_run)
+        except DistutilsExecError:
+            # XXX really should distinguish between "couldn't find
+            # external 'zip' command" and "zip failed".
+            raise DistutilsExecError(("unable to create zip file '%s': "
+                   "could neither import the 'zipfile' module nor "
+                   "find a standalone zip utility") % zip_filename)
+
+    else:
+        log.info("creating '%s' and adding '%s' to it",
+                 zip_filename, base_dir)
+
+        if not dry_run:
+            try:
+                zip = zipfile.ZipFile(zip_filename, "w",
+                                      compression=zipfile.ZIP_DEFLATED)
+            except RuntimeError:
+                zip = zipfile.ZipFile(zip_filename, "w",
+                                      compression=zipfile.ZIP_STORED)
+
+            with zip:
+                if base_dir != os.curdir:
+                    path = os.path.normpath(os.path.join(base_dir, ''))
+                    zip.write(path, path)
+                    log.info("adding '%s'", path)
+                for dirpath, dirnames, filenames in os.walk(base_dir):
+                    for name in dirnames:
+                        path = os.path.normpath(os.path.join(dirpath, name, ''))
+                        zip.write(path, path)
+                        log.info("adding '%s'", path)
+                    for name in filenames:
+                        path = os.path.normpath(os.path.join(dirpath, name))
+                        if os.path.isfile(path):
+                            zip.write(path, path)
+                            log.info("adding '%s'", path)
+
+    return zip_filename
+
+ARCHIVE_FORMATS = {
+    'gztar': (make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
+    'bztar': (make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"),
+    'xztar': (make_tarball, [('compress', 'xz')], "xz'ed tar-file"),
+    'ztar':  (make_tarball, [('compress', 'compress')], "compressed tar file"),
+    'tar':   (make_tarball, [('compress', None)], "uncompressed tar file"),
+    'zip':   (make_zipfile, [],"ZIP file")
+    }
+
+def check_archive_formats(formats):
+    """Returns the first format from the 'format' list that is unknown.
+
+    If all formats are known, returns None
+    """
+    for format in formats:
+        if format not in ARCHIVE_FORMATS:
+            return format
+    return None
+
+def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
+                 dry_run=0, owner=None, group=None):
+    """Create an archive file (eg. zip or tar).
+
+    'base_name' is the name of the file to create, minus any format-specific
+    extension; 'format' is the archive format: one of "zip", "tar", "gztar",
+    "bztar", "xztar", or "ztar".
+
+    'root_dir' is a directory that will be the root directory of the
+    archive; ie. we typically chdir into 'root_dir' before creating the
+    archive.  'base_dir' is the directory where we start archiving from;
+    ie. 'base_dir' will be the common prefix of all files and
+    directories in the archive.  'root_dir' and 'base_dir' both default
+    to the current directory.  Returns the name of the archive file.
+
+    'owner' and 'group' are used when creating a tar archive. By default,
+    uses the current owner and group.
+    """
+    save_cwd = os.getcwd()
+    if root_dir is not None:
+        log.debug("changing into '%s'", root_dir)
+        base_name = os.path.abspath(base_name)
+        if not dry_run:
+            os.chdir(root_dir)
+
+    if base_dir is None:
+        base_dir = os.curdir
+
+    kwargs = {'dry_run': dry_run}
+
+    try:
+        format_info = ARCHIVE_FORMATS[format]
+    except KeyError:
+        raise ValueError("unknown archive format '%s'" % format)
+
+    func = format_info[0]
+    for arg, val in format_info[1]:
+        kwargs[arg] = val
+
+    if format != 'zip':
+        kwargs['owner'] = owner
+        kwargs['group'] = group
+
+    try:
+        filename = func(base_name, base_dir, **kwargs)
+    finally:
+        if root_dir is not None:
+            log.debug("changing back to '%s'", save_cwd)
+            os.chdir(save_cwd)
+
+    return filename
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/bcppcompiler.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/bcppcompiler.py
new file mode 100644
index 0000000..071fea5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/bcppcompiler.py
@@ -0,0 +1,393 @@
+"""distutils.bcppcompiler
+
+Contains BorlandCCompiler, an implementation of the abstract CCompiler class
+for the Borland C++ compiler.
+"""
+
+# This implementation by Lyle Johnson, based on the original msvccompiler.py
+# module and using the directions originally published by Gordon Williams.
+
+# XXX looks like there's a LOT of overlap between these two classes:
+# someone should sit down and factor out the common code as
+# WindowsCCompiler!  --GPW
+
+
+import os
+from distutils.errors import \
+     DistutilsExecError, \
+     CompileError, LibError, LinkError, UnknownFileError
+from distutils.ccompiler import \
+     CCompiler, gen_preprocess_options
+from distutils.file_util import write_file
+from distutils.dep_util import newer
+from distutils import log
+
+class BCPPCompiler(CCompiler) :
+    """Concrete class that implements an interface to the Borland C/C++
+    compiler, as defined by the CCompiler abstract class.
+    """
+
+    compiler_type = 'bcpp'
+
+    # Just set this so CCompiler's constructor doesn't barf.  We currently
+    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
+    # as it really isn't necessary for this sort of single-compiler class.
+    # Would be nice to have a consistent interface with UnixCCompiler,
+    # though, so it's worth thinking about.
+    executables = {}
+
+    # Private class data (need to distinguish C from C++ source for compiler)
+    _c_extensions = ['.c']
+    _cpp_extensions = ['.cc', '.cpp', '.cxx']
+
+    # Needed for the filename generation methods provided by the
+    # base class, CCompiler.
+    src_extensions = _c_extensions + _cpp_extensions
+    obj_extension = '.obj'
+    static_lib_extension = '.lib'
+    shared_lib_extension = '.dll'
+    static_lib_format = shared_lib_format = '%s%s'
+    exe_extension = '.exe'
+
+
+    def __init__ (self,
+                  verbose=0,
+                  dry_run=0,
+                  force=0):
+
+        CCompiler.__init__ (self, verbose, dry_run, force)
+
+        # These executables are assumed to all be in the path.
+        # Borland doesn't seem to use any special registry settings to
+        # indicate their installation locations.
+
+        self.cc = "bcc32.exe"
+        self.linker = "ilink32.exe"
+        self.lib = "tlib.exe"
+
+        self.preprocess_options = None
+        self.compile_options = ['/tWM', '/O2', '/q', '/g0']
+        self.compile_options_debug = ['/tWM', '/Od', '/q', '/g0']
+
+        self.ldflags_shared = ['/Tpd', '/Gn', '/q', '/x']
+        self.ldflags_shared_debug = ['/Tpd', '/Gn', '/q', '/x']
+        self.ldflags_static = []
+        self.ldflags_exe = ['/Gn', '/q', '/x']
+        self.ldflags_exe_debug = ['/Gn', '/q', '/x','/r']
+
+
+    # -- Worker methods ------------------------------------------------
+
+    def compile(self, sources,
+                output_dir=None, macros=None, include_dirs=None, debug=0,
+                extra_preargs=None, extra_postargs=None, depends=None):
+
+        macros, objects, extra_postargs, pp_opts, build = \
+                self._setup_compile(output_dir, macros, include_dirs, sources,
+                                    depends, extra_postargs)
+        compile_opts = extra_preargs or []
+        compile_opts.append ('-c')
+        if debug:
+            compile_opts.extend (self.compile_options_debug)
+        else:
+            compile_opts.extend (self.compile_options)
+
+        for obj in objects:
+            try:
+                src, ext = build[obj]
+            except KeyError:
+                continue
+            # XXX why do the normpath here?
+            src = os.path.normpath(src)
+            obj = os.path.normpath(obj)
+            # XXX _setup_compile() did a mkpath() too but before the normpath.
+            # Is it possible to skip the normpath?
+            self.mkpath(os.path.dirname(obj))
+
+            if ext == '.res':
+                # This is already a binary file -- skip it.
+                continue # the 'for' loop
+            if ext == '.rc':
+                # This needs to be compiled to a .res file -- do it now.
+                try:
+                    self.spawn (["brcc32", "-fo", obj, src])
+                except DistutilsExecError as msg:
+                    raise CompileError(msg)
+                continue # the 'for' loop
+
+            # The next two are both for the real compiler.
+            if ext in self._c_extensions:
+                input_opt = ""
+            elif ext in self._cpp_extensions:
+                input_opt = "-P"
+            else:
+                # Unknown file type -- no extra options.  The compiler
+                # will probably fail, but let it just in case this is a
+                # file the compiler recognizes even if we don't.
+                input_opt = ""
+
+            output_opt = "-o" + obj
+
+            # Compiler command line syntax is: "bcc32 [options] file(s)".
+            # Note that the source file names must appear at the end of
+            # the command line.
+            try:
+                self.spawn ([self.cc] + compile_opts + pp_opts +
+                            [input_opt, output_opt] +
+                            extra_postargs + [src])
+            except DistutilsExecError as msg:
+                raise CompileError(msg)
+
+        return objects
+
+    # compile ()
+
+
+    def create_static_lib (self,
+                           objects,
+                           output_libname,
+                           output_dir=None,
+                           debug=0,
+                           target_lang=None):
+
+        (objects, output_dir) = self._fix_object_args (objects, output_dir)
+        output_filename = \
+            self.library_filename (output_libname, output_dir=output_dir)
+
+        if self._need_link (objects, output_filename):
+            lib_args = [output_filename, '/u'] + objects
+            if debug:
+                pass                    # XXX what goes here?
+            try:
+                self.spawn ([self.lib] + lib_args)
+            except DistutilsExecError as msg:
+                raise LibError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+    # create_static_lib ()
+
+
+    def link (self,
+              target_desc,
+              objects,
+              output_filename,
+              output_dir=None,
+              libraries=None,
+              library_dirs=None,
+              runtime_library_dirs=None,
+              export_symbols=None,
+              debug=0,
+              extra_preargs=None,
+              extra_postargs=None,
+              build_temp=None,
+              target_lang=None):
+
+        # XXX this ignores 'build_temp'!  should follow the lead of
+        # msvccompiler.py
+
+        (objects, output_dir) = self._fix_object_args (objects, output_dir)
+        (libraries, library_dirs, runtime_library_dirs) = \
+            self._fix_lib_args (libraries, library_dirs, runtime_library_dirs)
+
+        if runtime_library_dirs:
+            log.warn("I don't know what to do with 'runtime_library_dirs': %s",
+                     str(runtime_library_dirs))
+
+        if output_dir is not None:
+            output_filename = os.path.join (output_dir, output_filename)
+
+        if self._need_link (objects, output_filename):
+
+            # Figure out linker args based on type of target.
+            if target_desc == CCompiler.EXECUTABLE:
+                startup_obj = 'c0w32'
+                if debug:
+                    ld_args = self.ldflags_exe_debug[:]
+                else:
+                    ld_args = self.ldflags_exe[:]
+            else:
+                startup_obj = 'c0d32'
+                if debug:
+                    ld_args = self.ldflags_shared_debug[:]
+                else:
+                    ld_args = self.ldflags_shared[:]
+
+
+            # Create a temporary exports file for use by the linker
+            if export_symbols is None:
+                def_file = ''
+            else:
+                head, tail = os.path.split (output_filename)
+                modname, ext = os.path.splitext (tail)
+                temp_dir = os.path.dirname(objects[0]) # preserve tree structure
+                def_file = os.path.join (temp_dir, '%s.def' % modname)
+                contents = ['EXPORTS']
+                for sym in (export_symbols or []):
+                    contents.append('  %s=_%s' % (sym, sym))
+                self.execute(write_file, (def_file, contents),
+                             "writing %s" % def_file)
+
+            # Borland C++ has problems with '/' in paths
+            objects2 = map(os.path.normpath, objects)
+            # split objects in .obj and .res files
+            # Borland C++ needs them at different positions in the command line
+            objects = [startup_obj]
+            resources = []
+            for file in objects2:
+                (base, ext) = os.path.splitext(os.path.normcase(file))
+                if ext == '.res':
+                    resources.append(file)
+                else:
+                    objects.append(file)
+
+
+            for l in library_dirs:
+                ld_args.append("/L%s" % os.path.normpath(l))
+            ld_args.append("/L.") # we sometimes use relative paths
+
+            # list of object files
+            ld_args.extend(objects)
+
+            # XXX the command-line syntax for Borland C++ is a bit wonky;
+            # certain filenames are jammed together in one big string, but
+            # comma-delimited.  This doesn't mesh too well with the
+            # Unix-centric attitude (with a DOS/Windows quoting hack) of
+            # 'spawn()', so constructing the argument list is a bit
+            # awkward.  Note that doing the obvious thing and jamming all
+            # the filenames and commas into one argument would be wrong,
+            # because 'spawn()' would quote any filenames with spaces in
+            # them.  Arghghh!.  Apparently it works fine as coded...
+
+            # name of dll/exe file
+            ld_args.extend([',',output_filename])
+            # no map file and start libraries
+            ld_args.append(',,')
+
+            for lib in libraries:
+                # see if we find it and if there is a bcpp specific lib
+                # (xxx_bcpp.lib)
+                libfile = self.find_library_file(library_dirs, lib, debug)
+                if libfile is None:
+                    ld_args.append(lib)
+                    # probably a BCPP internal library -- don't warn
+                else:
+                    # full name which prefers bcpp_xxx.lib over xxx.lib
+                    ld_args.append(libfile)
+
+            # some default libraries
+            ld_args.append ('import32')
+            ld_args.append ('cw32mt')
+
+            # def file for export symbols
+            ld_args.extend([',',def_file])
+            # add resource files
+            ld_args.append(',')
+            ld_args.extend(resources)
+
+
+            if extra_preargs:
+                ld_args[:0] = extra_preargs
+            if extra_postargs:
+                ld_args.extend(extra_postargs)
+
+            self.mkpath (os.path.dirname (output_filename))
+            try:
+                self.spawn ([self.linker] + ld_args)
+            except DistutilsExecError as msg:
+                raise LinkError(msg)
+
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+    # link ()
+
+    # -- Miscellaneous methods -----------------------------------------
+
+
+    def find_library_file (self, dirs, lib, debug=0):
+        # List of effective library names to try, in order of preference:
+        # xxx_bcpp.lib is better than xxx.lib
+        # and xxx_d.lib is better than xxx.lib if debug is set
+        #
+        # The "_bcpp" suffix is to handle a Python installation for people
+        # with multiple compilers (primarily Distutils hackers, I suspect
+        # ;-).  The idea is they'd have one static library for each
+        # compiler they care about, since (almost?) every Windows compiler
+        # seems to have a different format for static libraries.
+        if debug:
+            dlib = (lib + "_d")
+            try_names = (dlib + "_bcpp", lib + "_bcpp", dlib, lib)
+        else:
+            try_names = (lib + "_bcpp", lib)
+
+        for dir in dirs:
+            for name in try_names:
+                libfile = os.path.join(dir, self.library_filename(name))
+                if os.path.exists(libfile):
+                    return libfile
+        else:
+            # Oops, didn't find it in *any* of 'dirs'
+            return None
+
+    # overwrite the one from CCompiler to support rc and res-files
+    def object_filenames (self,
+                          source_filenames,
+                          strip_dir=0,
+                          output_dir=''):
+        if output_dir is None: output_dir = ''
+        obj_names = []
+        for src_name in source_filenames:
+            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
+            (base, ext) = os.path.splitext (os.path.normcase(src_name))
+            if ext not in (self.src_extensions + ['.rc','.res']):
+                raise UnknownFileError("unknown file type '%s' (from '%s')" % \
+                      (ext, src_name))
+            if strip_dir:
+                base = os.path.basename (base)
+            if ext == '.res':
+                # these can go unchanged
+                obj_names.append (os.path.join (output_dir, base + ext))
+            elif ext == '.rc':
+                # these need to be compiled to .res-files
+                obj_names.append (os.path.join (output_dir, base + '.res'))
+            else:
+                obj_names.append (os.path.join (output_dir,
+                                            base + self.obj_extension))
+        return obj_names
+
+    # object_filenames ()
+
+    def preprocess (self,
+                    source,
+                    output_file=None,
+                    macros=None,
+                    include_dirs=None,
+                    extra_preargs=None,
+                    extra_postargs=None):
+
+        (_, macros, include_dirs) = \
+            self._fix_compile_args(None, macros, include_dirs)
+        pp_opts = gen_preprocess_options(macros, include_dirs)
+        pp_args = ['cpp32.exe'] + pp_opts
+        if output_file is not None:
+            pp_args.append('-o' + output_file)
+        if extra_preargs:
+            pp_args[:0] = extra_preargs
+        if extra_postargs:
+            pp_args.extend(extra_postargs)
+        pp_args.append(source)
+
+        # We need to preprocess: either we're being forced to, or the
+        # source file is newer than the target (or the target doesn't
+        # exist).
+        if self.force or output_file is None or newer(source, output_file):
+            if output_file:
+                self.mkpath(os.path.dirname(output_file))
+            try:
+                self.spawn(pp_args)
+            except DistutilsExecError as msg:
+                print(msg)
+                raise CompileError(msg)
+
+    # preprocess()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/ccompiler.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/ccompiler.py
new file mode 100644
index 0000000..57bb94e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/ccompiler.py
@@ -0,0 +1,1116 @@
+"""distutils.ccompiler
+
+Contains CCompiler, an abstract base class that defines the interface
+for the Distutils compiler abstraction model."""
+
+import sys, os, re
+from distutils.errors import *
+from distutils.spawn import spawn
+from distutils.file_util import move_file
+from distutils.dir_util import mkpath
+from distutils.dep_util import newer_group
+from distutils.util import split_quoted, execute
+from distutils import log
+
+class CCompiler:
+    """Abstract base class to define the interface that must be implemented
+    by real compiler classes.  Also has some utility methods used by
+    several compiler classes.
+
+    The basic idea behind a compiler abstraction class is that each
+    instance can be used for all the compile/link steps in building a
+    single project.  Thus, attributes common to all of those compile and
+    link steps -- include directories, macros to define, libraries to link
+    against, etc. -- are attributes of the compiler instance.  To allow for
+    variability in how individual files are treated, most of those
+    attributes may be varied on a per-compilation or per-link basis.
+    """
+
+    # 'compiler_type' is a class attribute that identifies this class.  It
+    # keeps code that wants to know what kind of compiler it's dealing with
+    # from having to import all possible compiler classes just to do an
+    # 'isinstance'.  In concrete CCompiler subclasses, 'compiler_type'
+    # should really, really be one of the keys of the 'compiler_class'
+    # dictionary (see below -- used by the 'new_compiler()' factory
+    # function) -- authors of new compiler interface classes are
+    # responsible for updating 'compiler_class'!
+    compiler_type = None
+
+    # XXX things not handled by this compiler abstraction model:
+    #   * client can't provide additional options for a compiler,
+    #     e.g. warning, optimization, debugging flags.  Perhaps this
+    #     should be the domain of concrete compiler abstraction classes
+    #     (UnixCCompiler, MSVCCompiler, etc.) -- or perhaps the base
+    #     class should have methods for the common ones.
+    #   * can't completely override the include or library searchg
+    #     path, ie. no "cc -I -Idir1 -Idir2" or "cc -L -Ldir1 -Ldir2".
+    #     I'm not sure how widely supported this is even by Unix
+    #     compilers, much less on other platforms.  And I'm even less
+    #     sure how useful it is; maybe for cross-compiling, but
+    #     support for that is a ways off.  (And anyways, cross
+    #     compilers probably have a dedicated binary with the
+    #     right paths compiled in.  I hope.)
+    #   * can't do really freaky things with the library list/library
+    #     dirs, e.g. "-Ldir1 -lfoo -Ldir2 -lfoo" to link against
+    #     different versions of libfoo.a in different locations.  I
+    #     think this is useless without the ability to null out the
+    #     library search path anyways.
+
+
+    # Subclasses that rely on the standard filename generation methods
+    # implemented below should override these; see the comment near
+    # those methods ('object_filenames()' et. al.) for details:
+    src_extensions = None               # list of strings
+    obj_extension = None                # string
+    static_lib_extension = None
+    shared_lib_extension = None         # string
+    static_lib_format = None            # format string
+    shared_lib_format = None            # prob. same as static_lib_format
+    exe_extension = None                # string
+
+    # Default language settings. language_map is used to detect a source
+    # file or Extension target language, checking source filenames.
+    # language_order is used to detect the language precedence, when deciding
+    # what language to use when mixing source types. For example, if some
+    # extension has two files with ".c" extension, and one with ".cpp", it
+    # is still linked as c++.
+    language_map = {".c"   : "c",
+                    ".cc"  : "c++",
+                    ".cpp" : "c++",
+                    ".cxx" : "c++",
+                    ".m"   : "objc",
+                   }
+    language_order = ["c++", "objc", "c"]
+
+    def __init__(self, verbose=0, dry_run=0, force=0):
+        self.dry_run = dry_run
+        self.force = force
+        self.verbose = verbose
+
+        # 'output_dir': a common output directory for object, library,
+        # shared object, and shared library files
+        self.output_dir = None
+
+        # 'macros': a list of macro definitions (or undefinitions).  A
+        # macro definition is a 2-tuple (name, value), where the value is
+        # either a string or None (no explicit value).  A macro
+        # undefinition is a 1-tuple (name,).
+        self.macros = []
+
+        # 'include_dirs': a list of directories to search for include files
+        self.include_dirs = []
+
+        # 'libraries': a list of libraries to include in any link
+        # (library names, not filenames: eg. "foo" not "libfoo.a")
+        self.libraries = []
+
+        # 'library_dirs': a list of directories to search for libraries
+        self.library_dirs = []
+
+        # 'runtime_library_dirs': a list of directories to search for
+        # shared libraries/objects at runtime
+        self.runtime_library_dirs = []
+
+        # 'objects': a list of object files (or similar, such as explicitly
+        # named library files) to include on any link
+        self.objects = []
+
+        for key in self.executables.keys():
+            self.set_executable(key, self.executables[key])
+
+    def set_executables(self, **kwargs):
+        """Define the executables (and options for them) that will be run
+        to perform the various stages of compilation.  The exact set of
+        executables that may be specified here depends on the compiler
+        class (via the 'executables' class attribute), but most will have:
+          compiler      the C/C++ compiler
+          linker_so     linker used to create shared objects and libraries
+          linker_exe    linker used to create binary executables
+          archiver      static library creator
+
+        On platforms with a command-line (Unix, DOS/Windows), each of these
+        is a string that will be split into executable name and (optional)
+        list of arguments.  (Splitting the string is done similarly to how
+        Unix shells operate: words are delimited by spaces, but quotes and
+        backslashes can override this.  See
+        'distutils.util.split_quoted()'.)
+        """
+
+        # Note that some CCompiler implementation classes will define class
+        # attributes 'cpp', 'cc', etc. with hard-coded executable names;
+        # this is appropriate when a compiler class is for exactly one
+        # compiler/OS combination (eg. MSVCCompiler).  Other compiler
+        # classes (UnixCCompiler, in particular) are driven by information
+        # discovered at run-time, since there are many different ways to do
+        # basically the same things with Unix C compilers.
+
+        for key in kwargs:
+            if key not in self.executables:
+                raise ValueError("unknown executable '%s' for class %s" %
+                      (key, self.__class__.__name__))
+            self.set_executable(key, kwargs[key])
+
+    def set_executable(self, key, value):
+        if isinstance(value, str):
+            setattr(self, key, split_quoted(value))
+        else:
+            setattr(self, key, value)
+
+    def _find_macro(self, name):
+        i = 0
+        for defn in self.macros:
+            if defn[0] == name:
+                return i
+            i += 1
+        return None
+
+    def _check_macro_definitions(self, definitions):
+        """Ensures that every element of 'definitions' is a valid macro
+        definition, ie. either (name,value) 2-tuple or a (name,) tuple.  Do
+        nothing if all definitions are OK, raise TypeError otherwise.
+        """
+        for defn in definitions:
+            if not (isinstance(defn, tuple) and
+                    (len(defn) in (1, 2) and
+                      (isinstance (defn[1], str) or defn[1] is None)) and
+                    isinstance (defn[0], str)):
+                raise TypeError(("invalid macro definition '%s': " % defn) + \
+                      "must be tuple (string,), (string, string), or " + \
+                      "(string, None)")
+
+
+    # -- Bookkeeping methods -------------------------------------------
+
+    def define_macro(self, name, value=None):
+        """Define a preprocessor macro for all compilations driven by this
+        compiler object.  The optional parameter 'value' should be a
+        string; if it is not supplied, then the macro will be defined
+        without an explicit value and the exact outcome depends on the
+        compiler used (XXX true? does ANSI say anything about this?)
+        """
+        # Delete from the list of macro definitions/undefinitions if
+        # already there (so that this one will take precedence).
+        i = self._find_macro (name)
+        if i is not None:
+            del self.macros[i]
+
+        self.macros.append((name, value))
+
+    def undefine_macro(self, name):
+        """Undefine a preprocessor macro for all compilations driven by
+        this compiler object.  If the same macro is defined by
+        'define_macro()' and undefined by 'undefine_macro()' the last call
+        takes precedence (including multiple redefinitions or
+        undefinitions).  If the macro is redefined/undefined on a
+        per-compilation basis (ie. in the call to 'compile()'), then that
+        takes precedence.
+        """
+        # Delete from the list of macro definitions/undefinitions if
+        # already there (so that this one will take precedence).
+        i = self._find_macro (name)
+        if i is not None:
+            del self.macros[i]
+
+        undefn = (name,)
+        self.macros.append(undefn)
+
+    def add_include_dir(self, dir):
+        """Add 'dir' to the list of directories that will be searched for
+        header files.  The compiler is instructed to search directories in
+        the order in which they are supplied by successive calls to
+        'add_include_dir()'.
+        """
+        self.include_dirs.append(dir)
+
+    def set_include_dirs(self, dirs):
+        """Set the list of directories that will be searched to 'dirs' (a
+        list of strings).  Overrides any preceding calls to
+        'add_include_dir()'; subsequence calls to 'add_include_dir()' add
+        to the list passed to 'set_include_dirs()'.  This does not affect
+        any list of standard include directories that the compiler may
+        search by default.
+        """
+        self.include_dirs = dirs[:]
+
+    def add_library(self, libname):
+        """Add 'libname' to the list of libraries that will be included in
+        all links driven by this compiler object.  Note that 'libname'
+        should *not* be the name of a file containing a library, but the
+        name of the library itself: the actual filename will be inferred by
+        the linker, the compiler, or the compiler class (depending on the
+        platform).
+
+        The linker will be instructed to link against libraries in the
+        order they were supplied to 'add_library()' and/or
+        'set_libraries()'.  It is perfectly valid to duplicate library
+        names; the linker will be instructed to link against libraries as
+        many times as they are mentioned.
+        """
+        self.libraries.append(libname)
+
+    def set_libraries(self, libnames):
+        """Set the list of libraries to be included in all links driven by
+        this compiler object to 'libnames' (a list of strings).  This does
+        not affect any standard system libraries that the linker may
+        include by default.
+        """
+        self.libraries = libnames[:]
+
+    def add_library_dir(self, dir):
+        """Add 'dir' to the list of directories that will be searched for
+        libraries specified to 'add_library()' and 'set_libraries()'.  The
+        linker will be instructed to search for libraries in the order they
+        are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.
+        """
+        self.library_dirs.append(dir)
+
+    def set_library_dirs(self, dirs):
+        """Set the list of library search directories to 'dirs' (a list of
+        strings).  This does not affect any standard library search path
+        that the linker may search by default.
+        """
+        self.library_dirs = dirs[:]
+
+    def add_runtime_library_dir(self, dir):
+        """Add 'dir' to the list of directories that will be searched for
+        shared libraries at runtime.
+        """
+        self.runtime_library_dirs.append(dir)
+
+    def set_runtime_library_dirs(self, dirs):
+        """Set the list of directories to search for shared libraries at
+        runtime to 'dirs' (a list of strings).  This does not affect any
+        standard search path that the runtime linker may search by
+        default.
+        """
+        self.runtime_library_dirs = dirs[:]
+
+    def add_link_object(self, object):
+        """Add 'object' to the list of object files (or analogues, such as
+        explicitly named library files or the output of "resource
+        compilers") to be included in every link driven by this compiler
+        object.
+        """
+        self.objects.append(object)
+
+    def set_link_objects(self, objects):
+        """Set the list of object files (or analogues) to be included in
+        every link to 'objects'.  This does not affect any standard object
+        files that the linker may include by default (such as system
+        libraries).
+        """
+        self.objects = objects[:]
+
+
+    # -- Private utility methods --------------------------------------
+    # (here for the convenience of subclasses)
+
+    # Helper method to prep compiler in subclass compile() methods
+
+    def _setup_compile(self, outdir, macros, incdirs, sources, depends,
+                       extra):
+        """Process arguments and decide which source files to compile."""
+        if outdir is None:
+            outdir = self.output_dir
+        elif not isinstance(outdir, str):
+            raise TypeError("'output_dir' must be a string or None")
+
+        if macros is None:
+            macros = self.macros
+        elif isinstance(macros, list):
+            macros = macros + (self.macros or [])
+        else:
+            raise TypeError("'macros' (if supplied) must be a list of tuples")
+
+        if incdirs is None:
+            incdirs = self.include_dirs
+        elif isinstance(incdirs, (list, tuple)):
+            incdirs = list(incdirs) + (self.include_dirs or [])
+        else:
+            raise TypeError(
+                  "'include_dirs' (if supplied) must be a list of strings")
+
+        if extra is None:
+            extra = []
+
+        # Get the list of expected output (object) files
+        objects = self.object_filenames(sources, strip_dir=0,
+                                        output_dir=outdir)
+        assert len(objects) == len(sources)
+
+        pp_opts = gen_preprocess_options(macros, incdirs)
+
+        build = {}
+        for i in range(len(sources)):
+            src = sources[i]
+            obj = objects[i]
+            ext = os.path.splitext(src)[1]
+            self.mkpath(os.path.dirname(obj))
+            build[obj] = (src, ext)
+
+        return macros, objects, extra, pp_opts, build
+
+    def _get_cc_args(self, pp_opts, debug, before):
+        # works for unixccompiler, cygwinccompiler
+        cc_args = pp_opts + ['-c']
+        if debug:
+            cc_args[:0] = ['-g']
+        if before:
+            cc_args[:0] = before
+        return cc_args
+
+    def _fix_compile_args(self, output_dir, macros, include_dirs):
+        """Typecheck and fix-up some of the arguments to the 'compile()'
+        method, and return fixed-up values.  Specifically: if 'output_dir'
+        is None, replaces it with 'self.output_dir'; ensures that 'macros'
+        is a list, and augments it with 'self.macros'; ensures that
+        'include_dirs' is a list, and augments it with 'self.include_dirs'.
+        Guarantees that the returned values are of the correct type,
+        i.e. for 'output_dir' either string or None, and for 'macros' and
+        'include_dirs' either list or None.
+        """
+        if output_dir is None:
+            output_dir = self.output_dir
+        elif not isinstance(output_dir, str):
+            raise TypeError("'output_dir' must be a string or None")
+
+        if macros is None:
+            macros = self.macros
+        elif isinstance(macros, list):
+            macros = macros + (self.macros or [])
+        else:
+            raise TypeError("'macros' (if supplied) must be a list of tuples")
+
+        if include_dirs is None:
+            include_dirs = self.include_dirs
+        elif isinstance(include_dirs, (list, tuple)):
+            include_dirs = list(include_dirs) + (self.include_dirs or [])
+        else:
+            raise TypeError(
+                  "'include_dirs' (if supplied) must be a list of strings")
+
+        return output_dir, macros, include_dirs
+
+    def _prep_compile(self, sources, output_dir, depends=None):
+        """Decide which souce files must be recompiled.
+
+        Determine the list of object files corresponding to 'sources',
+        and figure out which ones really need to be recompiled.
+        Return a list of all object files and a dictionary telling
+        which source files can be skipped.
+        """
+        # Get the list of expected output (object) files
+        objects = self.object_filenames(sources, output_dir=output_dir)
+        assert len(objects) == len(sources)
+
+        # Return an empty dict for the "which source files can be skipped"
+        # return value to preserve API compatibility.
+        return objects, {}
+
+    def _fix_object_args(self, objects, output_dir):
+        """Typecheck and fix up some arguments supplied to various methods.
+        Specifically: ensure that 'objects' is a list; if output_dir is
+        None, replace with self.output_dir.  Return fixed versions of
+        'objects' and 'output_dir'.
+        """
+        if not isinstance(objects, (list, tuple)):
+            raise TypeError("'objects' must be a list or tuple of strings")
+        objects = list(objects)
+
+        if output_dir is None:
+            output_dir = self.output_dir
+        elif not isinstance(output_dir, str):
+            raise TypeError("'output_dir' must be a string or None")
+
+        return (objects, output_dir)
+
+    def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs):
+        """Typecheck and fix up some of the arguments supplied to the
+        'link_*' methods.  Specifically: ensure that all arguments are
+        lists, and augment them with their permanent versions
+        (eg. 'self.libraries' augments 'libraries').  Return a tuple with
+        fixed versions of all arguments.
+        """
+        if libraries is None:
+            libraries = self.libraries
+        elif isinstance(libraries, (list, tuple)):
+            libraries = list (libraries) + (self.libraries or [])
+        else:
+            raise TypeError(
+                  "'libraries' (if supplied) must be a list of strings")
+
+        if library_dirs is None:
+            library_dirs = self.library_dirs
+        elif isinstance(library_dirs, (list, tuple)):
+            library_dirs = list (library_dirs) + (self.library_dirs or [])
+        else:
+            raise TypeError(
+                  "'library_dirs' (if supplied) must be a list of strings")
+
+        if runtime_library_dirs is None:
+            runtime_library_dirs = self.runtime_library_dirs
+        elif isinstance(runtime_library_dirs, (list, tuple)):
+            runtime_library_dirs = (list(runtime_library_dirs) +
+                                    (self.runtime_library_dirs or []))
+        else:
+            raise TypeError("'runtime_library_dirs' (if supplied) "
+                            "must be a list of strings")
+
+        return (libraries, library_dirs, runtime_library_dirs)
+
+    def _need_link(self, objects, output_file):
+        """Return true if we need to relink the files listed in 'objects'
+        to recreate 'output_file'.
+        """
+        if self.force:
+            return True
+        else:
+            if self.dry_run:
+                newer = newer_group (objects, output_file, missing='newer')
+            else:
+                newer = newer_group (objects, output_file)
+            return newer
+
+    def detect_language(self, sources):
+        """Detect the language of a given file, or list of files. Uses
+        language_map, and language_order to do the job.
+        """
+        if not isinstance(sources, list):
+            sources = [sources]
+        lang = None
+        index = len(self.language_order)
+        for source in sources:
+            base, ext = os.path.splitext(source)
+            extlang = self.language_map.get(ext)
+            try:
+                extindex = self.language_order.index(extlang)
+                if extindex < index:
+                    lang = extlang
+                    index = extindex
+            except ValueError:
+                pass
+        return lang
+
+
+    # -- Worker methods ------------------------------------------------
+    # (must be implemented by subclasses)
+
+    def preprocess(self, source, output_file=None, macros=None,
+                   include_dirs=None, extra_preargs=None, extra_postargs=None):
+        """Preprocess a single C/C++ source file, named in 'source'.
+        Output will be written to file named 'output_file', or stdout if
+        'output_file' not supplied.  'macros' is a list of macro
+        definitions as for 'compile()', which will augment the macros set
+        with 'define_macro()' and 'undefine_macro()'.  'include_dirs' is a
+        list of directory names that will be added to the default list.
+
+        Raises PreprocessError on failure.
+        """
+        pass
+
+    def compile(self, sources, output_dir=None, macros=None,
+                include_dirs=None, debug=0, extra_preargs=None,
+                extra_postargs=None, depends=None):
+        """Compile one or more source files.
+
+        'sources' must be a list of filenames, most likely C/C++
+        files, but in reality anything that can be handled by a
+        particular compiler and compiler class (eg. MSVCCompiler can
+        handle resource files in 'sources').  Return a list of object
+        filenames, one per source filename in 'sources'.  Depending on
+        the implementation, not all source files will necessarily be
+        compiled, but all corresponding object filenames will be
+        returned.
+
+        If 'output_dir' is given, object files will be put under it, while
+        retaining their original path component.  That is, "foo/bar.c"
+        normally compiles to "foo/bar.o" (for a Unix implementation); if
+        'output_dir' is "build", then it would compile to
+        "build/foo/bar.o".
+
+        'macros', if given, must be a list of macro definitions.  A macro
+        definition is either a (name, value) 2-tuple or a (name,) 1-tuple.
+        The former defines a macro; if the value is None, the macro is
+        defined without an explicit value.  The 1-tuple case undefines a
+        macro.  Later definitions/redefinitions/ undefinitions take
+        precedence.
+
+        'include_dirs', if given, must be a list of strings, the
+        directories to add to the default include file search path for this
+        compilation only.
+
+        'debug' is a boolean; if true, the compiler will be instructed to
+        output debug symbols in (or alongside) the object file(s).
+
+        'extra_preargs' and 'extra_postargs' are implementation- dependent.
+        On platforms that have the notion of a command-line (e.g. Unix,
+        DOS/Windows), they are most likely lists of strings: extra
+        command-line arguments to prepend/append to the compiler command
+        line.  On other platforms, consult the implementation class
+        documentation.  In any event, they are intended as an escape hatch
+        for those occasions when the abstract compiler framework doesn't
+        cut the mustard.
+
+        'depends', if given, is a list of filenames that all targets
+        depend on.  If a source file is older than any file in
+        depends, then the source file will be recompiled.  This
+        supports dependency tracking, but only at a coarse
+        granularity.
+
+        Raises CompileError on failure.
+        """
+        # A concrete compiler class can either override this method
+        # entirely or implement _compile().
+        macros, objects, extra_postargs, pp_opts, build = \
+                self._setup_compile(output_dir, macros, include_dirs, sources,
+                                    depends, extra_postargs)
+        cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)
+
+        for obj in objects:
+            try:
+                src, ext = build[obj]
+            except KeyError:
+                continue
+            self._compile(obj, src, ext, cc_args, extra_postargs, pp_opts)
+
+        # Return *all* object filenames, not just the ones we just built.
+        return objects
+
+    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
+        """Compile 'src' to product 'obj'."""
+        # A concrete compiler class that does not override compile()
+        # should implement _compile().
+        pass
+
+    def create_static_lib(self, objects, output_libname, output_dir=None,
+                          debug=0, target_lang=None):
+        """Link a bunch of stuff together to create a static library file.
+        The "bunch of stuff" consists of the list of object files supplied
+        as 'objects', the extra object files supplied to
+        'add_link_object()' and/or 'set_link_objects()', the libraries
+        supplied to 'add_library()' and/or 'set_libraries()', and the
+        libraries supplied as 'libraries' (if any).
+
+        'output_libname' should be a library name, not a filename; the
+        filename will be inferred from the library name.  'output_dir' is
+        the directory where the library file will be put.
+
+        'debug' is a boolean; if true, debugging information will be
+        included in the library (note that on most platforms, it is the
+        compile step where this matters: the 'debug' flag is included here
+        just for consistency).
+
+        'target_lang' is the target language for which the given objects
+        are being compiled. This allows specific linkage time treatment of
+        certain languages.
+
+        Raises LibError on failure.
+        """
+        pass
+
+
+    # values for target_desc parameter in link()
+    SHARED_OBJECT = "shared_object"
+    SHARED_LIBRARY = "shared_library"
+    EXECUTABLE = "executable"
+
+    def link(self,
+             target_desc,
+             objects,
+             output_filename,
+             output_dir=None,
+             libraries=None,
+             library_dirs=None,
+             runtime_library_dirs=None,
+             export_symbols=None,
+             debug=0,
+             extra_preargs=None,
+             extra_postargs=None,
+             build_temp=None,
+             target_lang=None):
+        """Link a bunch of stuff together to create an executable or
+        shared library file.
+
+        The "bunch of stuff" consists of the list of object files supplied
+        as 'objects'.  'output_filename' should be a filename.  If
+        'output_dir' is supplied, 'output_filename' is relative to it
+        (i.e. 'output_filename' can provide directory components if
+        needed).
+
+        'libraries' is a list of libraries to link against.  These are
+        library names, not filenames, since they're translated into
+        filenames in a platform-specific way (eg. "foo" becomes "libfoo.a"
+        on Unix and "foo.lib" on DOS/Windows).  However, they can include a
+        directory component, which means the linker will look in that
+        specific directory rather than searching all the normal locations.
+
+        'library_dirs', if supplied, should be a list of directories to
+        search for libraries that were specified as bare library names
+        (ie. no directory component).  These are on top of the system
+        default and those supplied to 'add_library_dir()' and/or
+        'set_library_dirs()'.  'runtime_library_dirs' is a list of
+        directories that will be embedded into the shared library and used
+        to search for other shared libraries that *it* depends on at
+        run-time.  (This may only be relevant on Unix.)
+
+        'export_symbols' is a list of symbols that the shared library will
+        export.  (This appears to be relevant only on Windows.)
+
+        'debug' is as for 'compile()' and 'create_static_lib()', with the
+        slight distinction that it actually matters on most platforms (as
+        opposed to 'create_static_lib()', which includes a 'debug' flag
+        mostly for form's sake).
+
+        'extra_preargs' and 'extra_postargs' are as for 'compile()' (except
+        of course that they supply command-line arguments for the
+        particular linker being used).
+
+        'target_lang' is the target language for which the given objects
+        are being compiled. This allows specific linkage time treatment of
+        certain languages.
+
+        Raises LinkError on failure.
+        """
+        raise NotImplementedError
+
+
+    # Old 'link_*()' methods, rewritten to use the new 'link()' method.
+
+    def link_shared_lib(self,
+                        objects,
+                        output_libname,
+                        output_dir=None,
+                        libraries=None,
+                        library_dirs=None,
+                        runtime_library_dirs=None,
+                        export_symbols=None,
+                        debug=0,
+                        extra_preargs=None,
+                        extra_postargs=None,
+                        build_temp=None,
+                        target_lang=None):
+        self.link(CCompiler.SHARED_LIBRARY, objects,
+                  self.library_filename(output_libname, lib_type='shared'),
+                  output_dir,
+                  libraries, library_dirs, runtime_library_dirs,
+                  export_symbols, debug,
+                  extra_preargs, extra_postargs, build_temp, target_lang)
+
+
+    def link_shared_object(self,
+                           objects,
+                           output_filename,
+                           output_dir=None,
+                           libraries=None,
+                           library_dirs=None,
+                           runtime_library_dirs=None,
+                           export_symbols=None,
+                           debug=0,
+                           extra_preargs=None,
+                           extra_postargs=None,
+                           build_temp=None,
+                           target_lang=None):
+        self.link(CCompiler.SHARED_OBJECT, objects,
+                  output_filename, output_dir,
+                  libraries, library_dirs, runtime_library_dirs,
+                  export_symbols, debug,
+                  extra_preargs, extra_postargs, build_temp, target_lang)
+
+
+    def link_executable(self,
+                        objects,
+                        output_progname,
+                        output_dir=None,
+                        libraries=None,
+                        library_dirs=None,
+                        runtime_library_dirs=None,
+                        debug=0,
+                        extra_preargs=None,
+                        extra_postargs=None,
+                        target_lang=None):
+        self.link(CCompiler.EXECUTABLE, objects,
+                  self.executable_filename(output_progname), output_dir,
+                  libraries, library_dirs, runtime_library_dirs, None,
+                  debug, extra_preargs, extra_postargs, None, target_lang)
+
+
+    # -- Miscellaneous methods -----------------------------------------
+    # These are all used by the 'gen_lib_options() function; there is
+    # no appropriate default implementation so subclasses should
+    # implement all of these.
+
+    def library_dir_option(self, dir):
+        """Return the compiler option to add 'dir' to the list of
+        directories searched for libraries.
+        """
+        raise NotImplementedError
+
+    def runtime_library_dir_option(self, dir):
+        """Return the compiler option to add 'dir' to the list of
+        directories searched for runtime libraries.
+        """
+        raise NotImplementedError
+
+    def library_option(self, lib):
+        """Return the compiler option to add 'lib' to the list of libraries
+        linked into the shared library or executable.
+        """
+        raise NotImplementedError
+
+    def has_function(self, funcname, includes=None, include_dirs=None,
+                     libraries=None, library_dirs=None):
+        """Return a boolean indicating whether funcname is supported on
+        the current platform.  The optional arguments can be used to
+        augment the compilation environment.
+        """
+        # this can't be included at module scope because it tries to
+        # import math which might not be available at that point - maybe
+        # the necessary logic should just be inlined?
+        import tempfile
+        if includes is None:
+            includes = []
+        if include_dirs is None:
+            include_dirs = []
+        if libraries is None:
+            libraries = []
+        if library_dirs is None:
+            library_dirs = []
+        fd, fname = tempfile.mkstemp(".c", funcname, text=True)
+        f = os.fdopen(fd, "w")
+        try:
+            for incl in includes:
+                f.write("""#include "%s"\n""" % incl)
+            f.write("""\
+int main (int argc, char **argv) {
+    %s();
+    return 0;
+}
+""" % funcname)
+        finally:
+            f.close()
+        try:
+            objects = self.compile([fname], include_dirs=include_dirs)
+        except CompileError:
+            return False
+
+        try:
+            self.link_executable(objects, "a.out",
+                                 libraries=libraries,
+                                 library_dirs=library_dirs)
+        except (LinkError, TypeError):
+            return False
+        return True
+
+    def find_library_file (self, dirs, lib, debug=0):
+        """Search the specified list of directories for a static or shared
+        library file 'lib' and return the full path to that file.  If
+        'debug' true, look for a debugging version (if that makes sense on
+        the current platform).  Return None if 'lib' wasn't found in any of
+        the specified directories.
+        """
+        raise NotImplementedError
+
+    # -- Filename generation methods -----------------------------------
+
+    # The default implementation of the filename generating methods are
+    # prejudiced towards the Unix/DOS/Windows view of the world:
+    #   * object files are named by replacing the source file extension
+    #     (eg. .c/.cpp -> .o/.obj)
+    #   * library files (shared or static) are named by plugging the
+    #     library name and extension into a format string, eg.
+    #     "lib%s.%s" % (lib_name, ".a") for Unix static libraries
+    #   * executables are named by appending an extension (possibly
+    #     empty) to the program name: eg. progname + ".exe" for
+    #     Windows
+    #
+    # To reduce redundant code, these methods expect to find
+    # several attributes in the current object (presumably defined
+    # as class attributes):
+    #   * src_extensions -
+    #     list of C/C++ source file extensions, eg. ['.c', '.cpp']
+    #   * obj_extension -
+    #     object file extension, eg. '.o' or '.obj'
+    #   * static_lib_extension -
+    #     extension for static library files, eg. '.a' or '.lib'
+    #   * shared_lib_extension -
+    #     extension for shared library/object files, eg. '.so', '.dll'
+    #   * static_lib_format -
+    #     format string for generating static library filenames,
+    #     eg. 'lib%s.%s' or '%s.%s'
+    #   * shared_lib_format
+    #     format string for generating shared library filenames
+    #     (probably same as static_lib_format, since the extension
+    #     is one of the intended parameters to the format string)
+    #   * exe_extension -
+    #     extension for executable files, eg. '' or '.exe'
+
+    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
+        if output_dir is None:
+            output_dir = ''
+        obj_names = []
+        for src_name in source_filenames:
+            base, ext = os.path.splitext(src_name)
+            base = os.path.splitdrive(base)[1] # Chop off the drive
+            base = base[os.path.isabs(base):]  # If abs, chop off leading /
+            if ext not in self.src_extensions:
+                raise UnknownFileError(
+                      "unknown file type '%s' (from '%s')" % (ext, src_name))
+            if strip_dir:
+                base = os.path.basename(base)
+            obj_names.append(os.path.join(output_dir,
+                                          base + self.obj_extension))
+        return obj_names
+
+    def shared_object_filename(self, basename, strip_dir=0, output_dir=''):
+        assert output_dir is not None
+        if strip_dir:
+            basename = os.path.basename(basename)
+        return os.path.join(output_dir, basename + self.shared_lib_extension)
+
+    def executable_filename(self, basename, strip_dir=0, output_dir=''):
+        assert output_dir is not None
+        if strip_dir:
+            basename = os.path.basename(basename)
+        return os.path.join(output_dir, basename + (self.exe_extension or ''))
+
+    def library_filename(self, libname, lib_type='static',     # or 'shared'
+                         strip_dir=0, output_dir=''):
+        assert output_dir is not None
+        if lib_type not in ("static", "shared", "dylib", "xcode_stub"):
+            raise ValueError(
+                  "'lib_type' must be \"static\", \"shared\", \"dylib\", or \"xcode_stub\"")
+        fmt = getattr(self, lib_type + "_lib_format")
+        ext = getattr(self, lib_type + "_lib_extension")
+
+        dir, base = os.path.split(libname)
+        filename = fmt % (base, ext)
+        if strip_dir:
+            dir = ''
+
+        return os.path.join(output_dir, dir, filename)
+
+
+    # -- Utility methods -----------------------------------------------
+
+    def announce(self, msg, level=1):
+        log.debug(msg)
+
+    def debug_print(self, msg):
+        from distutils.debug import DEBUG
+        if DEBUG:
+            print(msg)
+
+    def warn(self, msg):
+        sys.stderr.write("warning: %s\n" % msg)
+
+    def execute(self, func, args, msg=None, level=1):
+        execute(func, args, msg, self.dry_run)
+
+    def spawn(self, cmd, **kwargs):
+        spawn(cmd, dry_run=self.dry_run, **kwargs)
+
+    def move_file(self, src, dst):
+        return move_file(src, dst, dry_run=self.dry_run)
+
+    def mkpath (self, name, mode=0o777):
+        mkpath(name, mode, dry_run=self.dry_run)
+
+
+# Map a sys.platform/os.name ('posix', 'nt') to the default compiler
+# type for that platform. Keys are interpreted as re match
+# patterns. Order is important; platform mappings are preferred over
+# OS names.
+_default_compilers = (
+
+    # Platform string mappings
+
+    # on a cygwin built python we can use gcc like an ordinary UNIXish
+    # compiler
+    ('cygwin.*', 'unix'),
+
+    # OS name mappings
+    ('posix', 'unix'),
+    ('nt', 'msvc'),
+
+    )
+
+def get_default_compiler(osname=None, platform=None):
+    """Determine the default compiler to use for the given platform.
+
+       osname should be one of the standard Python OS names (i.e. the
+       ones returned by os.name) and platform the common value
+       returned by sys.platform for the platform in question.
+
+       The default values are os.name and sys.platform in case the
+       parameters are not given.
+    """
+    if osname is None:
+        osname = os.name
+    if platform is None:
+        platform = sys.platform
+    for pattern, compiler in _default_compilers:
+        if re.match(pattern, platform) is not None or \
+           re.match(pattern, osname) is not None:
+            return compiler
+    # Default to Unix compiler
+    return 'unix'
+
+# Map compiler types to (module_name, class_name) pairs -- ie. where to
+# find the code that implements an interface to this compiler.  (The module
+# is assumed to be in the 'distutils' package.)
+compiler_class = { 'unix':    ('unixccompiler', 'UnixCCompiler',
+                               "standard UNIX-style compiler"),
+                   'msvc':    ('_msvccompiler', 'MSVCCompiler',
+                               "Microsoft Visual C++"),
+                   'cygwin':  ('cygwinccompiler', 'CygwinCCompiler',
+                               "Cygwin port of GNU C Compiler for Win32"),
+                   'mingw32': ('cygwinccompiler', 'Mingw32CCompiler',
+                               "Mingw32 port of GNU C Compiler for Win32"),
+                   'bcpp':    ('bcppcompiler', 'BCPPCompiler',
+                               "Borland C++ Compiler"),
+                 }
+
+def show_compilers():
+    """Print list of available compilers (used by the "--help-compiler"
+    options to "build", "build_ext", "build_clib").
+    """
+    # XXX this "knows" that the compiler option it's describing is
+    # "--compiler", which just happens to be the case for the three
+    # commands that use it.
+    from distutils.fancy_getopt import FancyGetopt
+    compilers = []
+    for compiler in compiler_class.keys():
+        compilers.append(("compiler="+compiler, None,
+                          compiler_class[compiler][2]))
+    compilers.sort()
+    pretty_printer = FancyGetopt(compilers)
+    pretty_printer.print_help("List of available compilers:")
+
+
+def new_compiler(plat=None, compiler=None, verbose=0, dry_run=0, force=0):
+    """Generate an instance of some CCompiler subclass for the supplied
+    platform/compiler combination.  'plat' defaults to 'os.name'
+    (eg. 'posix', 'nt'), and 'compiler' defaults to the default compiler
+    for that platform.  Currently only 'posix' and 'nt' are supported, and
+    the default compilers are "traditional Unix interface" (UnixCCompiler
+    class) and Visual C++ (MSVCCompiler class).  Note that it's perfectly
+    possible to ask for a Unix compiler object under Windows, and a
+    Microsoft compiler object under Unix -- if you supply a value for
+    'compiler', 'plat' is ignored.
+    """
+    if plat is None:
+        plat = os.name
+
+    try:
+        if compiler is None:
+            compiler = get_default_compiler(plat)
+
+        (module_name, class_name, long_description) = compiler_class[compiler]
+    except KeyError:
+        msg = "don't know how to compile C/C++ code on platform '%s'" % plat
+        if compiler is not None:
+            msg = msg + " with '%s' compiler" % compiler
+        raise DistutilsPlatformError(msg)
+
+    try:
+        module_name = "distutils." + module_name
+        __import__ (module_name)
+        module = sys.modules[module_name]
+        klass = vars(module)[class_name]
+    except ImportError:
+        raise DistutilsModuleError(
+              "can't compile C/C++ code: unable to load module '%s'" % \
+              module_name)
+    except KeyError:
+        raise DistutilsModuleError(
+               "can't compile C/C++ code: unable to find class '%s' "
+               "in module '%s'" % (class_name, module_name))
+
+    # XXX The None is necessary to preserve backwards compatibility
+    # with classes that expect verbose to be the first positional
+    # argument.
+    return klass(None, dry_run, force)
+
+
+def gen_preprocess_options(macros, include_dirs):
+    """Generate C pre-processor options (-D, -U, -I) as used by at least
+    two types of compilers: the typical Unix compiler and Visual C++.
+    'macros' is the usual thing, a list of 1- or 2-tuples, where (name,)
+    means undefine (-U) macro 'name', and (name,value) means define (-D)
+    macro 'name' to 'value'.  'include_dirs' is just a list of directory
+    names to be added to the header file search path (-I).  Returns a list
+    of command-line options suitable for either Unix compilers or Visual
+    C++.
+    """
+    # XXX it would be nice (mainly aesthetic, and so we don't generate
+    # stupid-looking command lines) to go over 'macros' and eliminate
+    # redundant definitions/undefinitions (ie. ensure that only the
+    # latest mention of a particular macro winds up on the command
+    # line).  I don't think it's essential, though, since most (all?)
+    # Unix C compilers only pay attention to the latest -D or -U
+    # mention of a macro on their command line.  Similar situation for
+    # 'include_dirs'.  I'm punting on both for now.  Anyways, weeding out
+    # redundancies like this should probably be the province of
+    # CCompiler, since the data structures used are inherited from it
+    # and therefore common to all CCompiler classes.
+    pp_opts = []
+    for macro in macros:
+        if not (isinstance(macro, tuple) and 1 <= len(macro) <= 2):
+            raise TypeError(
+                  "bad macro definition '%s': "
+                  "each element of 'macros' list must be a 1- or 2-tuple"
+                  % macro)
+
+        if len(macro) == 1:        # undefine this macro
+            pp_opts.append("-U%s" % macro[0])
+        elif len(macro) == 2:
+            if macro[1] is None:    # define with no explicit value
+                pp_opts.append("-D%s" % macro[0])
+            else:
+                # XXX *don't* need to be clever about quoting the
+                # macro value here, because we're going to avoid the
+                # shell at all costs when we spawn the command!
+                pp_opts.append("-D%s=%s" % macro)
+
+    for dir in include_dirs:
+        pp_opts.append("-I%s" % dir)
+    return pp_opts
+
+
+def gen_lib_options (compiler, library_dirs, runtime_library_dirs, libraries):
+    """Generate linker options for searching library directories and
+    linking with specific libraries.  'libraries' and 'library_dirs' are,
+    respectively, lists of library names (not filenames!) and search
+    directories.  Returns a list of command-line options suitable for use
+    with some compiler (depending on the two format strings passed in).
+    """
+    lib_opts = []
+
+    for dir in library_dirs:
+        lib_opts.append(compiler.library_dir_option(dir))
+
+    for dir in runtime_library_dirs:
+        opt = compiler.runtime_library_dir_option(dir)
+        if isinstance(opt, list):
+            lib_opts = lib_opts + opt
+        else:
+            lib_opts.append(opt)
+
+    # XXX it's important that we *not* remove redundant library mentions!
+    # sometimes you really do have to say "-lfoo -lbar -lfoo" in order to
+    # resolve all symbols.  I just hope we never have to say "-lfoo obj.o
+    # -lbar" to get things to work -- that's certainly a possibility, but a
+    # pretty nasty way to arrange your C code.
+
+    for lib in libraries:
+        (lib_dir, lib_name) = os.path.split(lib)
+        if lib_dir:
+            lib_file = compiler.find_library_file([lib_dir], lib_name)
+            if lib_file:
+                lib_opts.append(lib_file)
+            else:
+                compiler.warn("no library file corresponding to "
+                              "'%s' found (skipping)" % lib)
+        else:
+            lib_opts.append(compiler.library_option (lib))
+    return lib_opts
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/cmd.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/cmd.py
new file mode 100644
index 0000000..dba3191
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/cmd.py
@@ -0,0 +1,403 @@
+"""distutils.cmd
+
+Provides the Command class, the base class for the command classes
+in the distutils.command package.
+"""
+
+import sys, os, re
+from distutils.errors import DistutilsOptionError
+from distutils import util, dir_util, file_util, archive_util, dep_util
+from distutils import log
+
+class Command:
+    """Abstract base class for defining command classes, the "worker bees"
+    of the Distutils.  A useful analogy for command classes is to think of
+    them as subroutines with local variables called "options".  The options
+    are "declared" in 'initialize_options()' and "defined" (given their
+    final values, aka "finalized") in 'finalize_options()', both of which
+    must be defined by every command class.  The distinction between the
+    two is necessary because option values might come from the outside
+    world (command line, config file, ...), and any options dependent on
+    other options must be computed *after* these outside influences have
+    been processed -- hence 'finalize_options()'.  The "body" of the
+    subroutine, where it does all its work based on the values of its
+    options, is the 'run()' method, which must also be implemented by every
+    command class.
+    """
+
+    # 'sub_commands' formalizes the notion of a "family" of commands,
+    # eg. "install" as the parent with sub-commands "install_lib",
+    # "install_headers", etc.  The parent of a family of commands
+    # defines 'sub_commands' as a class attribute; it's a list of
+    #    (command_name : string, predicate : unbound_method | string | None)
+    # tuples, where 'predicate' is a method of the parent command that
+    # determines whether the corresponding command is applicable in the
+    # current situation.  (Eg. we "install_headers" is only applicable if
+    # we have any C header files to install.)  If 'predicate' is None,
+    # that command is always applicable.
+    #
+    # 'sub_commands' is usually defined at the *end* of a class, because
+    # predicates can be unbound methods, so they must already have been
+    # defined.  The canonical example is the "install" command.
+    sub_commands = []
+
+
+    # -- Creation/initialization methods -------------------------------
+
+    def __init__(self, dist):
+        """Create and initialize a new Command object.  Most importantly,
+        invokes the 'initialize_options()' method, which is the real
+        initializer and depends on the actual command being
+        instantiated.
+        """
+        # late import because of mutual dependence between these classes
+        from distutils.dist import Distribution
+
+        if not isinstance(dist, Distribution):
+            raise TypeError("dist must be a Distribution instance")
+        if self.__class__ is Command:
+            raise RuntimeError("Command is an abstract class")
+
+        self.distribution = dist
+        self.initialize_options()
+
+        # Per-command versions of the global flags, so that the user can
+        # customize Distutils' behaviour command-by-command and let some
+        # commands fall back on the Distribution's behaviour.  None means
+        # "not defined, check self.distribution's copy", while 0 or 1 mean
+        # false and true (duh).  Note that this means figuring out the real
+        # value of each flag is a touch complicated -- hence "self._dry_run"
+        # will be handled by __getattr__, below.
+        # XXX This needs to be fixed.
+        self._dry_run = None
+
+        # verbose is largely ignored, but needs to be set for
+        # backwards compatibility (I think)?
+        self.verbose = dist.verbose
+
+        # Some commands define a 'self.force' option to ignore file
+        # timestamps, but methods defined *here* assume that
+        # 'self.force' exists for all commands.  So define it here
+        # just to be safe.
+        self.force = None
+
+        # The 'help' flag is just used for command-line parsing, so
+        # none of that complicated bureaucracy is needed.
+        self.help = 0
+
+        # 'finalized' records whether or not 'finalize_options()' has been
+        # called.  'finalize_options()' itself should not pay attention to
+        # this flag: it is the business of 'ensure_finalized()', which
+        # always calls 'finalize_options()', to respect/update it.
+        self.finalized = 0
+
+    # XXX A more explicit way to customize dry_run would be better.
+    def __getattr__(self, attr):
+        if attr == 'dry_run':
+            myval = getattr(self, "_" + attr)
+            if myval is None:
+                return getattr(self.distribution, attr)
+            else:
+                return myval
+        else:
+            raise AttributeError(attr)
+
+    def ensure_finalized(self):
+        if not self.finalized:
+            self.finalize_options()
+        self.finalized = 1
+
+    # Subclasses must define:
+    #   initialize_options()
+    #     provide default values for all options; may be customized by
+    #     setup script, by options from config file(s), or by command-line
+    #     options
+    #   finalize_options()
+    #     decide on the final values for all options; this is called
+    #     after all possible intervention from the outside world
+    #     (command-line, option file, etc.) has been processed
+    #   run()
+    #     run the command: do whatever it is we're here to do,
+    #     controlled by the command's various option values
+
+    def initialize_options(self):
+        """Set default values for all the options that this command
+        supports.  Note that these defaults may be overridden by other
+        commands, by the setup script, by config files, or by the
+        command-line.  Thus, this is not the place to code dependencies
+        between options; generally, 'initialize_options()' implementations
+        are just a bunch of "self.foo = None" assignments.
+
+        This method must be implemented by all command classes.
+        """
+        raise RuntimeError("abstract method -- subclass %s must override"
+                           % self.__class__)
+
+    def finalize_options(self):
+        """Set final values for all the options that this command supports.
+        This is always called as late as possible, ie.  after any option
+        assignments from the command-line or from other commands have been
+        done.  Thus, this is the place to code option dependencies: if
+        'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as
+        long as 'foo' still has the same value it was assigned in
+        'initialize_options()'.
+
+        This method must be implemented by all command classes.
+        """
+        raise RuntimeError("abstract method -- subclass %s must override"
+                           % self.__class__)
+
+
+    def dump_options(self, header=None, indent=""):
+        from distutils.fancy_getopt import longopt_xlate
+        if header is None:
+            header = "command options for '%s':" % self.get_command_name()
+        self.announce(indent + header, level=log.INFO)
+        indent = indent + "  "
+        for (option, _, _) in self.user_options:
+            option = option.translate(longopt_xlate)
+            if option[-1] == "=":
+                option = option[:-1]
+            value = getattr(self, option)
+            self.announce(indent + "%s = %s" % (option, value),
+                          level=log.INFO)
+
+    def run(self):
+        """A command's raison d'etre: carry out the action it exists to
+        perform, controlled by the options initialized in
+        'initialize_options()', customized by other commands, the setup
+        script, the command-line, and config files, and finalized in
+        'finalize_options()'.  All terminal output and filesystem
+        interaction should be done by 'run()'.
+
+        This method must be implemented by all command classes.
+        """
+        raise RuntimeError("abstract method -- subclass %s must override"
+                           % self.__class__)
+
+    def announce(self, msg, level=1):
+        """If the current verbosity level is of greater than or equal to
+        'level' print 'msg' to stdout.
+        """
+        log.log(level, msg)
+
+    def debug_print(self, msg):
+        """Print 'msg' to stdout if the global DEBUG (taken from the
+        DISTUTILS_DEBUG environment variable) flag is true.
+        """
+        from distutils.debug import DEBUG
+        if DEBUG:
+            print(msg)
+            sys.stdout.flush()
+
+
+    # -- Option validation methods -------------------------------------
+    # (these are very handy in writing the 'finalize_options()' method)
+    #
+    # NB. the general philosophy here is to ensure that a particular option
+    # value meets certain type and value constraints.  If not, we try to
+    # force it into conformance (eg. if we expect a list but have a string,
+    # split the string on comma and/or whitespace).  If we can't force the
+    # option into conformance, raise DistutilsOptionError.  Thus, command
+    # classes need do nothing more than (eg.)
+    #   self.ensure_string_list('foo')
+    # and they can be guaranteed that thereafter, self.foo will be
+    # a list of strings.
+
+    def _ensure_stringlike(self, option, what, default=None):
+        val = getattr(self, option)
+        if val is None:
+            setattr(self, option, default)
+            return default
+        elif not isinstance(val, str):
+            raise DistutilsOptionError("'%s' must be a %s (got `%s`)"
+                                       % (option, what, val))
+        return val
+
+    def ensure_string(self, option, default=None):
+        """Ensure that 'option' is a string; if not defined, set it to
+        'default'.
+        """
+        self._ensure_stringlike(option, "string", default)
+
+    def ensure_string_list(self, option):
+        r"""Ensure that 'option' is a list of strings.  If 'option' is
+        currently a string, we split it either on /,\s*/ or /\s+/, so
+        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
+        ["foo", "bar", "baz"].
+        """
+        val = getattr(self, option)
+        if val is None:
+            return
+        elif isinstance(val, str):
+            setattr(self, option, re.split(r',\s*|\s+', val))
+        else:
+            if isinstance(val, list):
+                ok = all(isinstance(v, str) for v in val)
+            else:
+                ok = False
+            if not ok:
+                raise DistutilsOptionError(
+                      "'%s' must be a list of strings (got %r)"
+                      % (option, val))
+
+    def _ensure_tested_string(self, option, tester, what, error_fmt,
+                              default=None):
+        val = self._ensure_stringlike(option, what, default)
+        if val is not None and not tester(val):
+            raise DistutilsOptionError(("error in '%s' option: " + error_fmt)
+                                       % (option, val))
+
+    def ensure_filename(self, option):
+        """Ensure that 'option' is the name of an existing file."""
+        self._ensure_tested_string(option, os.path.isfile,
+                                   "filename",
+                                   "'%s' does not exist or is not a file")
+
+    def ensure_dirname(self, option):
+        self._ensure_tested_string(option, os.path.isdir,
+                                   "directory name",
+                                   "'%s' does not exist or is not a directory")
+
+
+    # -- Convenience methods for commands ------------------------------
+
+    def get_command_name(self):
+        if hasattr(self, 'command_name'):
+            return self.command_name
+        else:
+            return self.__class__.__name__
+
+    def set_undefined_options(self, src_cmd, *option_pairs):
+        """Set the values of any "undefined" options from corresponding
+        option values in some other command object.  "Undefined" here means
+        "is None", which is the convention used to indicate that an option
+        has not been changed between 'initialize_options()' and
+        'finalize_options()'.  Usually called from 'finalize_options()' for
+        options that depend on some other command rather than another
+        option of the same command.  'src_cmd' is the other command from
+        which option values will be taken (a command object will be created
+        for it if necessary); the remaining arguments are
+        '(src_option,dst_option)' tuples which mean "take the value of
+        'src_option' in the 'src_cmd' command object, and copy it to
+        'dst_option' in the current command object".
+        """
+        # Option_pairs: list of (src_option, dst_option) tuples
+        src_cmd_obj = self.distribution.get_command_obj(src_cmd)
+        src_cmd_obj.ensure_finalized()
+        for (src_option, dst_option) in option_pairs:
+            if getattr(self, dst_option) is None:
+                setattr(self, dst_option, getattr(src_cmd_obj, src_option))
+
+    def get_finalized_command(self, command, create=1):
+        """Wrapper around Distribution's 'get_command_obj()' method: find
+        (create if necessary and 'create' is true) the command object for
+        'command', call its 'ensure_finalized()' method, and return the
+        finalized command object.
+        """
+        cmd_obj = self.distribution.get_command_obj(command, create)
+        cmd_obj.ensure_finalized()
+        return cmd_obj
+
+    # XXX rename to 'get_reinitialized_command()'? (should do the
+    # same in dist.py, if so)
+    def reinitialize_command(self, command, reinit_subcommands=0):
+        return self.distribution.reinitialize_command(command,
+                                                      reinit_subcommands)
+
+    def run_command(self, command):
+        """Run some other command: uses the 'run_command()' method of
+        Distribution, which creates and finalizes the command object if
+        necessary and then invokes its 'run()' method.
+        """
+        self.distribution.run_command(command)
+
+    def get_sub_commands(self):
+        """Determine the sub-commands that are relevant in the current
+        distribution (ie., that need to be run).  This is based on the
+        'sub_commands' class attribute: each tuple in that list may include
+        a method that we call to determine if the subcommand needs to be
+        run for the current distribution.  Return a list of command names.
+        """
+        commands = []
+        for (cmd_name, method) in self.sub_commands:
+            if method is None or method(self):
+                commands.append(cmd_name)
+        return commands
+
+
+    # -- External world manipulation -----------------------------------
+
+    def warn(self, msg):
+        log.warn("warning: %s: %s\n", self.get_command_name(), msg)
+
+    def execute(self, func, args, msg=None, level=1):
+        util.execute(func, args, msg, dry_run=self.dry_run)
+
+    def mkpath(self, name, mode=0o777):
+        dir_util.mkpath(name, mode, dry_run=self.dry_run)
+
+    def copy_file(self, infile, outfile, preserve_mode=1, preserve_times=1,
+                  link=None, level=1):
+        """Copy a file respecting verbose, dry-run and force flags.  (The
+        former two default to whatever is in the Distribution object, and
+        the latter defaults to false for commands that don't define it.)"""
+        return file_util.copy_file(infile, outfile, preserve_mode,
+                                   preserve_times, not self.force, link,
+                                   dry_run=self.dry_run)
+
+    def copy_tree(self, infile, outfile, preserve_mode=1, preserve_times=1,
+                   preserve_symlinks=0, level=1):
+        """Copy an entire directory tree respecting verbose, dry-run,
+        and force flags.
+        """
+        return dir_util.copy_tree(infile, outfile, preserve_mode,
+                                  preserve_times, preserve_symlinks,
+                                  not self.force, dry_run=self.dry_run)
+
+    def move_file (self, src, dst, level=1):
+        """Move a file respecting dry-run flag."""
+        return file_util.move_file(src, dst, dry_run=self.dry_run)
+
+    def spawn(self, cmd, search_path=1, level=1):
+        """Spawn an external command respecting dry-run flag."""
+        from distutils.spawn import spawn
+        spawn(cmd, search_path, dry_run=self.dry_run)
+
+    def make_archive(self, base_name, format, root_dir=None, base_dir=None,
+                     owner=None, group=None):
+        return archive_util.make_archive(base_name, format, root_dir, base_dir,
+                                         dry_run=self.dry_run,
+                                         owner=owner, group=group)
+
+    def make_file(self, infiles, outfile, func, args,
+                  exec_msg=None, skip_msg=None, level=1):
+        """Special case of 'execute()' for operations that process one or
+        more input files and generate one output file.  Works just like
+        'execute()', except the operation is skipped and a different
+        message printed if 'outfile' already exists and is newer than all
+        files listed in 'infiles'.  If the command defined 'self.force',
+        and it is true, then the command is unconditionally run -- does no
+        timestamp checks.
+        """
+        if skip_msg is None:
+            skip_msg = "skipping %s (inputs unchanged)" % outfile
+
+        # Allow 'infiles' to be a single string
+        if isinstance(infiles, str):
+            infiles = (infiles,)
+        elif not isinstance(infiles, (list, tuple)):
+            raise TypeError(
+                  "'infiles' must be a string, or a list or tuple of strings")
+
+        if exec_msg is None:
+            exec_msg = "generating %s from %s" % (outfile, ', '.join(infiles))
+
+        # If 'outfile' must be regenerated (either because it doesn't
+        # exist, is out-of-date, or the 'force' flag is true) then
+        # perform the action that presumably regenerates it
+        if self.force or dep_util.newer_group(infiles, outfile):
+            self.execute(func, args, exec_msg, level)
+        # Otherwise, print the "skip" message
+        else:
+            log.debug(skip_msg)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/__init__.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/__init__.py
new file mode 100644
index 0000000..481eea9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/__init__.py
@@ -0,0 +1,31 @@
+"""distutils.command
+
+Package containing implementation of all the standard Distutils
+commands."""
+
+__all__ = ['build',
+           'build_py',
+           'build_ext',
+           'build_clib',
+           'build_scripts',
+           'clean',
+           'install',
+           'install_lib',
+           'install_headers',
+           'install_scripts',
+           'install_data',
+           'sdist',
+           'register',
+           'bdist',
+           'bdist_dumb',
+           'bdist_rpm',
+           'bdist_wininst',
+           'check',
+           'upload',
+           # These two are reserved for future use:
+           #'bdist_sdux',
+           #'bdist_pkgtool',
+           # Note:
+           # bdist_packager is not included because it only provides
+           # an abstract base class
+          ]
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist.py
new file mode 100644
index 0000000..014871d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist.py
@@ -0,0 +1,143 @@
+"""distutils.command.bdist
+
+Implements the Distutils 'bdist' command (create a built [binary]
+distribution)."""
+
+import os
+from distutils.core import Command
+from distutils.errors import *
+from distutils.util import get_platform
+
+
+def show_formats():
+    """Print list of available formats (arguments to "--format" option).
+    """
+    from distutils.fancy_getopt import FancyGetopt
+    formats = []
+    for format in bdist.format_commands:
+        formats.append(("formats=" + format, None,
+                        bdist.format_command[format][1]))
+    pretty_printer = FancyGetopt(formats)
+    pretty_printer.print_help("List of available distribution formats:")
+
+
+class bdist(Command):
+
+    description = "create a built (binary) distribution"
+
+    user_options = [('bdist-base=', 'b',
+                     "temporary directory for creating built distributions"),
+                    ('plat-name=', 'p',
+                     "platform name to embed in generated filenames "
+                     "(default: %s)" % get_platform()),
+                    ('formats=', None,
+                     "formats for distribution (comma-separated list)"),
+                    ('dist-dir=', 'd',
+                     "directory to put final built distributions in "
+                     "[default: dist]"),
+                    ('skip-build', None,
+                     "skip rebuilding everything (for testing/debugging)"),
+                    ('owner=', 'u',
+                     "Owner name used when creating a tar file"
+                     " [default: current user]"),
+                    ('group=', 'g',
+                     "Group name used when creating a tar file"
+                     " [default: current group]"),
+                   ]
+
+    boolean_options = ['skip-build']
+
+    help_options = [
+        ('help-formats', None,
+         "lists available distribution formats", show_formats),
+        ]
+
+    # The following commands do not take a format option from bdist
+    no_format_option = ('bdist_rpm',)
+
+    # This won't do in reality: will need to distinguish RPM-ish Linux,
+    # Debian-ish Linux, Solaris, FreeBSD, ..., Windows, Mac OS.
+    default_format = {'posix': 'gztar',
+                      'nt': 'zip'}
+
+    # Establish the preferred order (for the --help-formats option).
+    format_commands = ['rpm', 'gztar', 'bztar', 'xztar', 'ztar', 'tar',
+                       'wininst', 'zip', 'msi']
+
+    # And the real information.
+    format_command = {'rpm':   ('bdist_rpm',  "RPM distribution"),
+                      'gztar': ('bdist_dumb', "gzip'ed tar file"),
+                      'bztar': ('bdist_dumb', "bzip2'ed tar file"),
+                      'xztar': ('bdist_dumb', "xz'ed tar file"),
+                      'ztar':  ('bdist_dumb', "compressed tar file"),
+                      'tar':   ('bdist_dumb', "tar file"),
+                      'wininst': ('bdist_wininst',
+                                  "Windows executable installer"),
+                      'zip':   ('bdist_dumb', "ZIP file"),
+                      'msi':   ('bdist_msi',  "Microsoft Installer")
+                      }
+
+
+    def initialize_options(self):
+        self.bdist_base = None
+        self.plat_name = None
+        self.formats = None
+        self.dist_dir = None
+        self.skip_build = 0
+        self.group = None
+        self.owner = None
+
+    def finalize_options(self):
+        # have to finalize 'plat_name' before 'bdist_base'
+        if self.plat_name is None:
+            if self.skip_build:
+                self.plat_name = get_platform()
+            else:
+                self.plat_name = self.get_finalized_command('build').plat_name
+
+        # 'bdist_base' -- parent of per-built-distribution-format
+        # temporary directories (eg. we'll probably have
+        # "build/bdist.<plat>/dumb", "build/bdist.<plat>/rpm", etc.)
+        if self.bdist_base is None:
+            build_base = self.get_finalized_command('build').build_base
+            self.bdist_base = os.path.join(build_base,
+                                           'bdist.' + self.plat_name)
+
+        self.ensure_string_list('formats')
+        if self.formats is None:
+            try:
+                self.formats = [self.default_format[os.name]]
+            except KeyError:
+                raise DistutilsPlatformError(
+                      "don't know how to create built distributions "
+                      "on platform %s" % os.name)
+
+        if self.dist_dir is None:
+            self.dist_dir = "dist"
+
+    def run(self):
+        # Figure out which sub-commands we need to run.
+        commands = []
+        for format in self.formats:
+            try:
+                commands.append(self.format_command[format][0])
+            except KeyError:
+                raise DistutilsOptionError("invalid format '%s'" % format)
+
+        # Reinitialize and run each command.
+        for i in range(len(self.formats)):
+            cmd_name = commands[i]
+            sub_cmd = self.reinitialize_command(cmd_name)
+            if cmd_name not in self.no_format_option:
+                sub_cmd.format = self.formats[i]
+
+            # passing the owner and group names for tar archiving
+            if cmd_name == 'bdist_dumb':
+                sub_cmd.owner = self.owner
+                sub_cmd.group = self.group
+
+            # If we're going to need to run this command again, tell it to
+            # keep its temporary files around so subsequent runs go faster.
+            if cmd_name in commands[i+1:]:
+                sub_cmd.keep_temp = 1
+            self.run_command(cmd_name)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_dumb.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_dumb.py
new file mode 100644
index 0000000..f0d6b5b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_dumb.py
@@ -0,0 +1,123 @@
+"""distutils.command.bdist_dumb
+
+Implements the Distutils 'bdist_dumb' command (create a "dumb" built
+distribution -- i.e., just an archive to be unpacked under $prefix or
+$exec_prefix)."""
+
+import os
+from distutils.core import Command
+from distutils.util import get_platform
+from distutils.dir_util import remove_tree, ensure_relative
+from distutils.errors import *
+from distutils.sysconfig import get_python_version
+from distutils import log
+
+class bdist_dumb(Command):
+
+    description = "create a \"dumb\" built distribution"
+
+    user_options = [('bdist-dir=', 'd',
+                     "temporary directory for creating the distribution"),
+                    ('plat-name=', 'p',
+                     "platform name to embed in generated filenames "
+                     "(default: %s)" % get_platform()),
+                    ('format=', 'f',
+                     "archive format to create (tar, gztar, bztar, xztar, "
+                     "ztar, zip)"),
+                    ('keep-temp', 'k',
+                     "keep the pseudo-installation tree around after " +
+                     "creating the distribution archive"),
+                    ('dist-dir=', 'd',
+                     "directory to put final built distributions in"),
+                    ('skip-build', None,
+                     "skip rebuilding everything (for testing/debugging)"),
+                    ('relative', None,
+                     "build the archive using relative paths "
+                     "(default: false)"),
+                    ('owner=', 'u',
+                     "Owner name used when creating a tar file"
+                     " [default: current user]"),
+                    ('group=', 'g',
+                     "Group name used when creating a tar file"
+                     " [default: current group]"),
+                   ]
+
+    boolean_options = ['keep-temp', 'skip-build', 'relative']
+
+    default_format = { 'posix': 'gztar',
+                       'nt': 'zip' }
+
+    def initialize_options(self):
+        self.bdist_dir = None
+        self.plat_name = None
+        self.format = None
+        self.keep_temp = 0
+        self.dist_dir = None
+        self.skip_build = None
+        self.relative = 0
+        self.owner = None
+        self.group = None
+
+    def finalize_options(self):
+        if self.bdist_dir is None:
+            bdist_base = self.get_finalized_command('bdist').bdist_base
+            self.bdist_dir = os.path.join(bdist_base, 'dumb')
+
+        if self.format is None:
+            try:
+                self.format = self.default_format[os.name]
+            except KeyError:
+                raise DistutilsPlatformError(
+                       "don't know how to create dumb built distributions "
+                       "on platform %s" % os.name)
+
+        self.set_undefined_options('bdist',
+                                   ('dist_dir', 'dist_dir'),
+                                   ('plat_name', 'plat_name'),
+                                   ('skip_build', 'skip_build'))
+
+    def run(self):
+        if not self.skip_build:
+            self.run_command('build')
+
+        install = self.reinitialize_command('install', reinit_subcommands=1)
+        install.root = self.bdist_dir
+        install.skip_build = self.skip_build
+        install.warn_dir = 0
+
+        log.info("installing to %s", self.bdist_dir)
+        self.run_command('install')
+
+        # And make an archive relative to the root of the
+        # pseudo-installation tree.
+        archive_basename = "%s.%s" % (self.distribution.get_fullname(),
+                                      self.plat_name)
+
+        pseudoinstall_root = os.path.join(self.dist_dir, archive_basename)
+        if not self.relative:
+            archive_root = self.bdist_dir
+        else:
+            if (self.distribution.has_ext_modules() and
+                (install.install_base != install.install_platbase)):
+                raise DistutilsPlatformError(
+                       "can't make a dumb built distribution where "
+                       "base and platbase are different (%s, %s)"
+                       % (repr(install.install_base),
+                          repr(install.install_platbase)))
+            else:
+                archive_root = os.path.join(self.bdist_dir,
+                                   ensure_relative(install.install_base))
+
+        # Make the archive
+        filename = self.make_archive(pseudoinstall_root,
+                                     self.format, root_dir=archive_root,
+                                     owner=self.owner, group=self.group)
+        if self.distribution.has_ext_modules():
+            pyversion = get_python_version()
+        else:
+            pyversion = 'any'
+        self.distribution.dist_files.append(('bdist_dumb', pyversion,
+                                             filename))
+
+        if not self.keep_temp:
+            remove_tree(self.bdist_dir, dry_run=self.dry_run)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_msi.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_msi.py
new file mode 100644
index 0000000..0863a18
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_msi.py
@@ -0,0 +1,749 @@
+# Copyright (C) 2005, 2006 Martin von Löwis
+# Licensed to PSF under a Contributor Agreement.
+# The bdist_wininst command proper
+# based on bdist_wininst
+"""
+Implements the bdist_msi command.
+"""
+
+import os
+import sys
+import warnings
+from distutils.core import Command
+from distutils.dir_util import remove_tree
+from distutils.sysconfig import get_python_version
+from distutils.version import StrictVersion
+from distutils.errors import DistutilsOptionError
+from distutils.util import get_platform
+from distutils import log
+import msilib
+from msilib import schema, sequence, text
+from msilib import Directory, Feature, Dialog, add_data
+
+class PyDialog(Dialog):
+    """Dialog class with a fixed layout: controls at the top, then a ruler,
+    then a list of buttons: back, next, cancel. Optionally a bitmap at the
+    left."""
+    def __init__(self, *args, **kw):
+        """Dialog(database, name, x, y, w, h, attributes, title, first,
+        default, cancel, bitmap=true)"""
+        Dialog.__init__(self, *args)
+        ruler = self.h - 36
+        bmwidth = 152*ruler/328
+        #if kw.get("bitmap", True):
+        #    self.bitmap("Bitmap", 0, 0, bmwidth, ruler, "PythonWin")
+        self.line("BottomLine", 0, ruler, self.w, 0)
+
+    def title(self, title):
+        "Set the title text of the dialog at the top."
+        # name, x, y, w, h, flags=Visible|Enabled|Transparent|NoPrefix,
+        # text, in VerdanaBold10
+        self.text("Title", 15, 10, 320, 60, 0x30003,
+                  r"{\VerdanaBold10}%s" % title)
+
+    def back(self, title, next, name = "Back", active = 1):
+        """Add a back button with a given title, the tab-next button,
+        its name in the Control table, possibly initially disabled.
+
+        Return the button, so that events can be associated"""
+        if active:
+            flags = 3 # Visible|Enabled
+        else:
+            flags = 1 # Visible
+        return self.pushbutton(name, 180, self.h-27 , 56, 17, flags, title, next)
+
+    def cancel(self, title, next, name = "Cancel", active = 1):
+        """Add a cancel button with a given title, the tab-next button,
+        its name in the Control table, possibly initially disabled.
+
+        Return the button, so that events can be associated"""
+        if active:
+            flags = 3 # Visible|Enabled
+        else:
+            flags = 1 # Visible
+        return self.pushbutton(name, 304, self.h-27, 56, 17, flags, title, next)
+
+    def next(self, title, next, name = "Next", active = 1):
+        """Add a Next button with a given title, the tab-next button,
+        its name in the Control table, possibly initially disabled.
+
+        Return the button, so that events can be associated"""
+        if active:
+            flags = 3 # Visible|Enabled
+        else:
+            flags = 1 # Visible
+        return self.pushbutton(name, 236, self.h-27, 56, 17, flags, title, next)
+
+    def xbutton(self, name, title, next, xpos):
+        """Add a button with a given title, the tab-next button,
+        its name in the Control table, giving its x position; the
+        y-position is aligned with the other buttons.
+
+        Return the button, so that events can be associated"""
+        return self.pushbutton(name, int(self.w*xpos - 28), self.h-27, 56, 17, 3, title, next)
+
+class bdist_msi(Command):
+
+    description = "create a Microsoft Installer (.msi) binary distribution"
+
+    user_options = [('bdist-dir=', None,
+                     "temporary directory for creating the distribution"),
+                    ('plat-name=', 'p',
+                     "platform name to embed in generated filenames "
+                     "(default: %s)" % get_platform()),
+                    ('keep-temp', 'k',
+                     "keep the pseudo-installation tree around after " +
+                     "creating the distribution archive"),
+                    ('target-version=', None,
+                     "require a specific python version" +
+                     " on the target system"),
+                    ('no-target-compile', 'c',
+                     "do not compile .py to .pyc on the target system"),
+                    ('no-target-optimize', 'o',
+                     "do not compile .py to .pyo (optimized) "
+                     "on the target system"),
+                    ('dist-dir=', 'd',
+                     "directory to put final built distributions in"),
+                    ('skip-build', None,
+                     "skip rebuilding everything (for testing/debugging)"),
+                    ('install-script=', None,
+                     "basename of installation script to be run after "
+                     "installation or before deinstallation"),
+                    ('pre-install-script=', None,
+                     "Fully qualified filename of a script to be run before "
+                     "any files are installed.  This script need not be in the "
+                     "distribution"),
+                   ]
+
+    boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
+                       'skip-build']
+
+    all_versions = ['2.0', '2.1', '2.2', '2.3', '2.4',
+                    '2.5', '2.6', '2.7', '2.8', '2.9',
+                    '3.0', '3.1', '3.2', '3.3', '3.4',
+                    '3.5', '3.6', '3.7', '3.8', '3.9']
+    other_version = 'X'
+
+    def __init__(self, *args, **kw):
+        super().__init__(*args, **kw)
+        warnings.warn("bdist_msi command is deprecated since Python 3.9, "
+                      "use bdist_wheel (wheel packages) instead",
+                      DeprecationWarning, 2)
+
+    def initialize_options(self):
+        self.bdist_dir = None
+        self.plat_name = None
+        self.keep_temp = 0
+        self.no_target_compile = 0
+        self.no_target_optimize = 0
+        self.target_version = None
+        self.dist_dir = None
+        self.skip_build = None
+        self.install_script = None
+        self.pre_install_script = None
+        self.versions = None
+
+    def finalize_options(self):
+        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))
+
+        if self.bdist_dir is None:
+            bdist_base = self.get_finalized_command('bdist').bdist_base
+            self.bdist_dir = os.path.join(bdist_base, 'msi')
+
+        short_version = get_python_version()
+        if (not self.target_version) and self.distribution.has_ext_modules():
+            self.target_version = short_version
+
+        if self.target_version:
+            self.versions = [self.target_version]
+            if not self.skip_build and self.distribution.has_ext_modules()\
+               and self.target_version != short_version:
+                raise DistutilsOptionError(
+                      "target version can only be %s, or the '--skip-build'"
+                      " option must be specified" % (short_version,))
+        else:
+            self.versions = list(self.all_versions)
+
+        self.set_undefined_options('bdist',
+                                   ('dist_dir', 'dist_dir'),
+                                   ('plat_name', 'plat_name'),
+                                   )
+
+        if self.pre_install_script:
+            raise DistutilsOptionError(
+                  "the pre-install-script feature is not yet implemented")
+
+        if self.install_script:
+            for script in self.distribution.scripts:
+                if self.install_script == os.path.basename(script):
+                    break
+            else:
+                raise DistutilsOptionError(
+                      "install_script '%s' not found in scripts"
+                      % self.install_script)
+        self.install_script_key = None
+
+    def run(self):
+        if not self.skip_build:
+            self.run_command('build')
+
+        install = self.reinitialize_command('install', reinit_subcommands=1)
+        install.prefix = self.bdist_dir
+        install.skip_build = self.skip_build
+        install.warn_dir = 0
+
+        install_lib = self.reinitialize_command('install_lib')
+        # we do not want to include pyc or pyo files
+        install_lib.compile = 0
+        install_lib.optimize = 0
+
+        if self.distribution.has_ext_modules():
+            # If we are building an installer for a Python version other
+            # than the one we are currently running, then we need to ensure
+            # our build_lib reflects the other Python version rather than ours.
+            # Note that for target_version!=sys.version, we must have skipped the
+            # build step, so there is no issue with enforcing the build of this
+            # version.
+            target_version = self.target_version
+            if not target_version:
+                assert self.skip_build, "Should have already checked this"
+                target_version = '%d.%d' % sys.version_info[:2]
+            plat_specifier = ".%s-%s" % (self.plat_name, target_version)
+            build = self.get_finalized_command('build')
+            build.build_lib = os.path.join(build.build_base,
+                                           'lib' + plat_specifier)
+
+        log.info("installing to %s", self.bdist_dir)
+        install.ensure_finalized()
+
+        # avoid warning of 'install_lib' about installing
+        # into a directory not in sys.path
+        sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))
+
+        install.run()
+
+        del sys.path[0]
+
+        self.mkpath(self.dist_dir)
+        fullname = self.distribution.get_fullname()
+        installer_name = self.get_installer_filename(fullname)
+        installer_name = os.path.abspath(installer_name)
+        if os.path.exists(installer_name): os.unlink(installer_name)
+
+        metadata = self.distribution.metadata
+        author = metadata.author
+        if not author:
+            author = metadata.maintainer
+        if not author:
+            author = "UNKNOWN"
+        version = metadata.get_version()
+        # ProductVersion must be strictly numeric
+        # XXX need to deal with prerelease versions
+        sversion = "%d.%d.%d" % StrictVersion(version).version
+        # Prefix ProductName with Python x.y, so that
+        # it sorts together with the other Python packages
+        # in Add-Remove-Programs (APR)
+        fullname = self.distribution.get_fullname()
+        if self.target_version:
+            product_name = "Python %s %s" % (self.target_version, fullname)
+        else:
+            product_name = "Python %s" % (fullname)
+        self.db = msilib.init_database(installer_name, schema,
+                product_name, msilib.gen_uuid(),
+                sversion, author)
+        msilib.add_tables(self.db, sequence)
+        props = [('DistVersion', version)]
+        email = metadata.author_email or metadata.maintainer_email
+        if email:
+            props.append(("ARPCONTACT", email))
+        if metadata.url:
+            props.append(("ARPURLINFOABOUT", metadata.url))
+        if props:
+            add_data(self.db, 'Property', props)
+
+        self.add_find_python()
+        self.add_files()
+        self.add_scripts()
+        self.add_ui()
+        self.db.Commit()
+
+        if hasattr(self.distribution, 'dist_files'):
+            tup = 'bdist_msi', self.target_version or 'any', fullname
+            self.distribution.dist_files.append(tup)
+
+        if not self.keep_temp:
+            remove_tree(self.bdist_dir, dry_run=self.dry_run)
+
+    def add_files(self):
+        db = self.db
+        cab = msilib.CAB("distfiles")
+        rootdir = os.path.abspath(self.bdist_dir)
+
+        root = Directory(db, cab, None, rootdir, "TARGETDIR", "SourceDir")
+        f = Feature(db, "Python", "Python", "Everything",
+                    0, 1, directory="TARGETDIR")
+
+        items = [(f, root, '')]
+        for version in self.versions + [self.other_version]:
+            target = "TARGETDIR" + version
+            name = default = "Python" + version
+            desc = "Everything"
+            if version is self.other_version:
+                title = "Python from another location"
+                level = 2
+            else:
+                title = "Python %s from registry" % version
+                level = 1
+            f = Feature(db, name, title, desc, 1, level, directory=target)
+            dir = Directory(db, cab, root, rootdir, target, default)
+            items.append((f, dir, version))
+        db.Commit()
+
+        seen = {}
+        for feature, dir, version in items:
+            todo = [dir]
+            while todo:
+                dir = todo.pop()
+                for file in os.listdir(dir.absolute):
+                    afile = os.path.join(dir.absolute, file)
+                    if os.path.isdir(afile):
+                        short = "%s|%s" % (dir.make_short(file), file)
+                        default = file + version
+                        newdir = Directory(db, cab, dir, file, default, short)
+                        todo.append(newdir)
+                    else:
+                        if not dir.component:
+                            dir.start_component(dir.logical, feature, 0)
+                        if afile not in seen:
+                            key = seen[afile] = dir.add_file(file)
+                            if file==self.install_script:
+                                if self.install_script_key:
+                                    raise DistutilsOptionError(
+                                          "Multiple files with name %s" % file)
+                                self.install_script_key = '[#%s]' % key
+                        else:
+                            key = seen[afile]
+                            add_data(self.db, "DuplicateFile",
+                                [(key + version, dir.component, key, None, dir.logical)])
+            db.Commit()
+        cab.commit(db)
+
+    def add_find_python(self):
+        """Adds code to the installer to compute the location of Python.
+
+        Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
+        registry for each version of Python.
+
+        Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
+        else from PYTHON.MACHINE.X.Y.
+
+        Properties PYTHONX.Y will be set to TARGETDIRX.Y\\python.exe"""
+
+        start = 402
+        for ver in self.versions:
+            install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % ver
+            machine_reg = "python.machine." + ver
+            user_reg = "python.user." + ver
+            machine_prop = "PYTHON.MACHINE." + ver
+            user_prop = "PYTHON.USER." + ver
+            machine_action = "PythonFromMachine" + ver
+            user_action = "PythonFromUser" + ver
+            exe_action = "PythonExe" + ver
+            target_dir_prop = "TARGETDIR" + ver
+            exe_prop = "PYTHON" + ver
+            if msilib.Win64:
+                # type: msidbLocatorTypeRawValue + msidbLocatorType64bit
+                Type = 2+16
+            else:
+                Type = 2
+            add_data(self.db, "RegLocator",
+                    [(machine_reg, 2, install_path, None, Type),
+                     (user_reg, 1, install_path, None, Type)])
+            add_data(self.db, "AppSearch",
+                    [(machine_prop, machine_reg),
+                     (user_prop, user_reg)])
+            add_data(self.db, "CustomAction",
+                    [(machine_action, 51+256, target_dir_prop, "[" + machine_prop + "]"),
+                     (user_action, 51+256, target_dir_prop, "[" + user_prop + "]"),
+                     (exe_action, 51+256, exe_prop, "[" + target_dir_prop + "]\\python.exe"),
+                    ])
+            add_data(self.db, "InstallExecuteSequence",
+                    [(machine_action, machine_prop, start),
+                     (user_action, user_prop, start + 1),
+                     (exe_action, None, start + 2),
+                    ])
+            add_data(self.db, "InstallUISequence",
+                    [(machine_action, machine_prop, start),
+                     (user_action, user_prop, start + 1),
+                     (exe_action, None, start + 2),
+                    ])
+            add_data(self.db, "Condition",
+                    [("Python" + ver, 0, "NOT TARGETDIR" + ver)])
+            start += 4
+            assert start < 500
+
+    def add_scripts(self):
+        if self.install_script:
+            start = 6800
+            for ver in self.versions + [self.other_version]:
+                install_action = "install_script." + ver
+                exe_prop = "PYTHON" + ver
+                add_data(self.db, "CustomAction",
+                        [(install_action, 50, exe_prop, self.install_script_key)])
+                add_data(self.db, "InstallExecuteSequence",
+                        [(install_action, "&Python%s=3" % ver, start)])
+                start += 1
+        # XXX pre-install scripts are currently refused in finalize_options()
+        #     but if this feature is completed, it will also need to add
+        #     entries for each version as the above code does
+        if self.pre_install_script:
+            scriptfn = os.path.join(self.bdist_dir, "preinstall.bat")
+            with open(scriptfn, "w") as f:
+                # The batch file will be executed with [PYTHON], so that %1
+                # is the path to the Python interpreter; %0 will be the path
+                # of the batch file.
+                # rem ="""
+                # %1 %0
+                # exit
+                # """
+                # <actual script>
+                f.write('rem ="""\n%1 %0\nexit\n"""\n')
+                with open(self.pre_install_script) as fin:
+                    f.write(fin.read())
+            add_data(self.db, "Binary",
+                [("PreInstall", msilib.Binary(scriptfn))
+                ])
+            add_data(self.db, "CustomAction",
+                [("PreInstall", 2, "PreInstall", None)
+                ])
+            add_data(self.db, "InstallExecuteSequence",
+                    [("PreInstall", "NOT Installed", 450)])
+
+
+    def add_ui(self):
+        db = self.db
+        x = y = 50
+        w = 370
+        h = 300
+        title = "[ProductName] Setup"
+
+        # see "Dialog Style Bits"
+        modal = 3      # visible | modal
+        modeless = 1   # visible
+        track_disk_space = 32
+
+        # UI customization properties
+        add_data(db, "Property",
+                 # See "DefaultUIFont Property"
+                 [("DefaultUIFont", "DlgFont8"),
+                  # See "ErrorDialog Style Bit"
+                  ("ErrorDialog", "ErrorDlg"),
+                  ("Progress1", "Install"),   # modified in maintenance type dlg
+                  ("Progress2", "installs"),
+                  ("MaintenanceForm_Action", "Repair"),
+                  # possible values: ALL, JUSTME
+                  ("WhichUsers", "ALL")
+                 ])
+
+        # Fonts, see "TextStyle Table"
+        add_data(db, "TextStyle",
+                 [("DlgFont8", "Tahoma", 9, None, 0),
+                  ("DlgFontBold8", "Tahoma", 8, None, 1), #bold
+                  ("VerdanaBold10", "Verdana", 10, None, 1),
+                  ("VerdanaRed9", "Verdana", 9, 255, 0),
+                 ])
+
+        # UI Sequences, see "InstallUISequence Table", "Using a Sequence Table"
+        # Numbers indicate sequence; see sequence.py for how these action integrate
+        add_data(db, "InstallUISequence",
+                 [("PrepareDlg", "Not Privileged or Windows9x or Installed", 140),
+                  ("WhichUsersDlg", "Privileged and not Windows9x and not Installed", 141),
+                  # In the user interface, assume all-users installation if privileged.
+                  ("SelectFeaturesDlg", "Not Installed", 1230),
+                  # XXX no support for resume installations yet
+                  #("ResumeDlg", "Installed AND (RESUME OR Preselected)", 1240),
+                  ("MaintenanceTypeDlg", "Installed AND NOT RESUME AND NOT Preselected", 1250),
+                  ("ProgressDlg", None, 1280)])
+
+        add_data(db, 'ActionText', text.ActionText)
+        add_data(db, 'UIText', text.UIText)
+        #####################################################################
+        # Standard dialogs: FatalError, UserExit, ExitDialog
+        fatal=PyDialog(db, "FatalError", x, y, w, h, modal, title,
+                     "Finish", "Finish", "Finish")
+        fatal.title("[ProductName] Installer ended prematurely")
+        fatal.back("< Back", "Finish", active = 0)
+        fatal.cancel("Cancel", "Back", active = 0)
+        fatal.text("Description1", 15, 70, 320, 80, 0x30003,
+                   "[ProductName] setup ended prematurely because of an error.  Your system has not been modified.  To install this program at a later time, please run the installation again.")
+        fatal.text("Description2", 15, 155, 320, 20, 0x30003,
+                   "Click the Finish button to exit the Installer.")
+        c=fatal.next("Finish", "Cancel", name="Finish")
+        c.event("EndDialog", "Exit")
+
+        user_exit=PyDialog(db, "UserExit", x, y, w, h, modal, title,
+                     "Finish", "Finish", "Finish")
+        user_exit.title("[ProductName] Installer was interrupted")
+        user_exit.back("< Back", "Finish", active = 0)
+        user_exit.cancel("Cancel", "Back", active = 0)
+        user_exit.text("Description1", 15, 70, 320, 80, 0x30003,
+                   "[ProductName] setup was interrupted.  Your system has not been modified.  "
+                   "To install this program at a later time, please run the installation again.")
+        user_exit.text("Description2", 15, 155, 320, 20, 0x30003,
+                   "Click the Finish button to exit the Installer.")
+        c = user_exit.next("Finish", "Cancel", name="Finish")
+        c.event("EndDialog", "Exit")
+
+        exit_dialog = PyDialog(db, "ExitDialog", x, y, w, h, modal, title,
+                             "Finish", "Finish", "Finish")
+        exit_dialog.title("Completing the [ProductName] Installer")
+        exit_dialog.back("< Back", "Finish", active = 0)
+        exit_dialog.cancel("Cancel", "Back", active = 0)
+        exit_dialog.text("Description", 15, 235, 320, 20, 0x30003,
+                   "Click the Finish button to exit the Installer.")
+        c = exit_dialog.next("Finish", "Cancel", name="Finish")
+        c.event("EndDialog", "Return")
+
+        #####################################################################
+        # Required dialog: FilesInUse, ErrorDlg
+        inuse = PyDialog(db, "FilesInUse",
+                         x, y, w, h,
+                         19,                # KeepModeless|Modal|Visible
+                         title,
+                         "Retry", "Retry", "Retry", bitmap=False)
+        inuse.text("Title", 15, 6, 200, 15, 0x30003,
+                   r"{\DlgFontBold8}Files in Use")
+        inuse.text("Description", 20, 23, 280, 20, 0x30003,
+               "Some files that need to be updated are currently in use.")
+        inuse.text("Text", 20, 55, 330, 50, 3,
+                   "The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.")
+        inuse.control("List", "ListBox", 20, 107, 330, 130, 7, "FileInUseProcess",
+                      None, None, None)
+        c=inuse.back("Exit", "Ignore", name="Exit")
+        c.event("EndDialog", "Exit")
+        c=inuse.next("Ignore", "Retry", name="Ignore")
+        c.event("EndDialog", "Ignore")
+        c=inuse.cancel("Retry", "Exit", name="Retry")
+        c.event("EndDialog","Retry")
+
+        # See "Error Dialog". See "ICE20" for the required names of the controls.
+        error = Dialog(db, "ErrorDlg",
+                       50, 10, 330, 101,
+                       65543,       # Error|Minimize|Modal|Visible
+                       title,
+                       "ErrorText", None, None)
+        error.text("ErrorText", 50,9,280,48,3, "")
+        #error.control("ErrorIcon", "Icon", 15, 9, 24, 24, 5242881, None, "py.ico", None, None)
+        error.pushbutton("N",120,72,81,21,3,"No",None).event("EndDialog","ErrorNo")
+        error.pushbutton("Y",240,72,81,21,3,"Yes",None).event("EndDialog","ErrorYes")
+        error.pushbutton("A",0,72,81,21,3,"Abort",None).event("EndDialog","ErrorAbort")
+        error.pushbutton("C",42,72,81,21,3,"Cancel",None).event("EndDialog","ErrorCancel")
+        error.pushbutton("I",81,72,81,21,3,"Ignore",None).event("EndDialog","ErrorIgnore")
+        error.pushbutton("O",159,72,81,21,3,"Ok",None).event("EndDialog","ErrorOk")
+        error.pushbutton("R",198,72,81,21,3,"Retry",None).event("EndDialog","ErrorRetry")
+
+        #####################################################################
+        # Global "Query Cancel" dialog
+        cancel = Dialog(db, "CancelDlg", 50, 10, 260, 85, 3, title,
+                        "No", "No", "No")
+        cancel.text("Text", 48, 15, 194, 30, 3,
+                    "Are you sure you want to cancel [ProductName] installation?")
+        #cancel.control("Icon", "Icon", 15, 15, 24, 24, 5242881, None,
+        #               "py.ico", None, None)
+        c=cancel.pushbutton("Yes", 72, 57, 56, 17, 3, "Yes", "No")
+        c.event("EndDialog", "Exit")
+
+        c=cancel.pushbutton("No", 132, 57, 56, 17, 3, "No", "Yes")
+        c.event("EndDialog", "Return")
+
+        #####################################################################
+        # Global "Wait for costing" dialog
+        costing = Dialog(db, "WaitForCostingDlg", 50, 10, 260, 85, modal, title,
+                         "Return", "Return", "Return")
+        costing.text("Text", 48, 15, 194, 30, 3,
+                     "Please wait while the installer finishes determining your disk space requirements.")
+        c = costing.pushbutton("Return", 102, 57, 56, 17, 3, "Return", None)
+        c.event("EndDialog", "Exit")
+
+        #####################################################################
+        # Preparation dialog: no user input except cancellation
+        prep = PyDialog(db, "PrepareDlg", x, y, w, h, modeless, title,
+                        "Cancel", "Cancel", "Cancel")
+        prep.text("Description", 15, 70, 320, 40, 0x30003,
+                  "Please wait while the Installer prepares to guide you through the installation.")
+        prep.title("Welcome to the [ProductName] Installer")
+        c=prep.text("ActionText", 15, 110, 320, 20, 0x30003, "Pondering...")
+        c.mapping("ActionText", "Text")
+        c=prep.text("ActionData", 15, 135, 320, 30, 0x30003, None)
+        c.mapping("ActionData", "Text")
+        prep.back("Back", None, active=0)
+        prep.next("Next", None, active=0)
+        c=prep.cancel("Cancel", None)
+        c.event("SpawnDialog", "CancelDlg")
+
+        #####################################################################
+        # Feature (Python directory) selection
+        seldlg = PyDialog(db, "SelectFeaturesDlg", x, y, w, h, modal, title,
+                        "Next", "Next", "Cancel")
+        seldlg.title("Select Python Installations")
+
+        seldlg.text("Hint", 15, 30, 300, 20, 3,
+                    "Select the Python locations where %s should be installed."
+                    % self.distribution.get_fullname())
+
+        seldlg.back("< Back", None, active=0)
+        c = seldlg.next("Next >", "Cancel")
+        order = 1
+        c.event("[TARGETDIR]", "[SourceDir]", ordering=order)
+        for version in self.versions + [self.other_version]:
+            order += 1
+            c.event("[TARGETDIR]", "[TARGETDIR%s]" % version,
+                    "FEATURE_SELECTED AND &Python%s=3" % version,
+                    ordering=order)
+        c.event("SpawnWaitDialog", "WaitForCostingDlg", ordering=order + 1)
+        c.event("EndDialog", "Return", ordering=order + 2)
+        c = seldlg.cancel("Cancel", "Features")
+        c.event("SpawnDialog", "CancelDlg")
+
+        c = seldlg.control("Features", "SelectionTree", 15, 60, 300, 120, 3,
+                           "FEATURE", None, "PathEdit", None)
+        c.event("[FEATURE_SELECTED]", "1")
+        ver = self.other_version
+        install_other_cond = "FEATURE_SELECTED AND &Python%s=3" % ver
+        dont_install_other_cond = "FEATURE_SELECTED AND &Python%s<>3" % ver
+
+        c = seldlg.text("Other", 15, 200, 300, 15, 3,
+                        "Provide an alternate Python location")
+        c.condition("Enable", install_other_cond)
+        c.condition("Show", install_other_cond)
+        c.condition("Disable", dont_install_other_cond)
+        c.condition("Hide", dont_install_other_cond)
+
+        c = seldlg.control("PathEdit", "PathEdit", 15, 215, 300, 16, 1,
+                           "TARGETDIR" + ver, None, "Next", None)
+        c.condition("Enable", install_other_cond)
+        c.condition("Show", install_other_cond)
+        c.condition("Disable", dont_install_other_cond)
+        c.condition("Hide", dont_install_other_cond)
+
+        #####################################################################
+        # Disk cost
+        cost = PyDialog(db, "DiskCostDlg", x, y, w, h, modal, title,
+                        "OK", "OK", "OK", bitmap=False)
+        cost.text("Title", 15, 6, 200, 15, 0x30003,
+                 r"{\DlgFontBold8}Disk Space Requirements")
+        cost.text("Description", 20, 20, 280, 20, 0x30003,
+                  "The disk space required for the installation of the selected features.")
+        cost.text("Text", 20, 53, 330, 60, 3,
+                  "The highlighted volumes (if any) do not have enough disk space "
+              "available for the currently selected features.  You can either "
+              "remove some files from the highlighted volumes, or choose to "
+              "install less features onto local drive(s), or select different "
+              "destination drive(s).")
+        cost.control("VolumeList", "VolumeCostList", 20, 100, 330, 150, 393223,
+                     None, "{120}{70}{70}{70}{70}", None, None)
+        cost.xbutton("OK", "Ok", None, 0.5).event("EndDialog", "Return")
+
+        #####################################################################
+        # WhichUsers Dialog. Only available on NT, and for privileged users.
+        # This must be run before FindRelatedProducts, because that will
+        # take into account whether the previous installation was per-user
+        # or per-machine. We currently don't support going back to this
+        # dialog after "Next" was selected; to support this, we would need to
+        # find how to reset the ALLUSERS property, and how to re-run
+        # FindRelatedProducts.
+        # On Windows9x, the ALLUSERS property is ignored on the command line
+        # and in the Property table, but installer fails according to the documentation
+        # if a dialog attempts to set ALLUSERS.
+        whichusers = PyDialog(db, "WhichUsersDlg", x, y, w, h, modal, title,
+                            "AdminInstall", "Next", "Cancel")
+        whichusers.title("Select whether to install [ProductName] for all users of this computer.")
+        # A radio group with two options: allusers, justme
+        g = whichusers.radiogroup("AdminInstall", 15, 60, 260, 50, 3,
+                                  "WhichUsers", "", "Next")
+        g.add("ALL", 0, 5, 150, 20, "Install for all users")
+        g.add("JUSTME", 0, 25, 150, 20, "Install just for me")
+
+        whichusers.back("Back", None, active=0)
+
+        c = whichusers.next("Next >", "Cancel")
+        c.event("[ALLUSERS]", "1", 'WhichUsers="ALL"', 1)
+        c.event("EndDialog", "Return", ordering = 2)
+
+        c = whichusers.cancel("Cancel", "AdminInstall")
+        c.event("SpawnDialog", "CancelDlg")
+
+        #####################################################################
+        # Installation Progress dialog (modeless)
+        progress = PyDialog(db, "ProgressDlg", x, y, w, h, modeless, title,
+                            "Cancel", "Cancel", "Cancel", bitmap=False)
+        progress.text("Title", 20, 15, 200, 15, 0x30003,
+                     r"{\DlgFontBold8}[Progress1] [ProductName]")
+        progress.text("Text", 35, 65, 300, 30, 3,
+                      "Please wait while the Installer [Progress2] [ProductName]. "
+                      "This may take several minutes.")
+        progress.text("StatusLabel", 35, 100, 35, 20, 3, "Status:")
+
+        c=progress.text("ActionText", 70, 100, w-70, 20, 3, "Pondering...")
+        c.mapping("ActionText", "Text")
+
+        #c=progress.text("ActionData", 35, 140, 300, 20, 3, None)
+        #c.mapping("ActionData", "Text")
+
+        c=progress.control("ProgressBar", "ProgressBar", 35, 120, 300, 10, 65537,
+                           None, "Progress done", None, None)
+        c.mapping("SetProgress", "Progress")
+
+        progress.back("< Back", "Next", active=False)
+        progress.next("Next >", "Cancel", active=False)
+        progress.cancel("Cancel", "Back").event("SpawnDialog", "CancelDlg")
+
+        ###################################################################
+        # Maintenance type: repair/uninstall
+        maint = PyDialog(db, "MaintenanceTypeDlg", x, y, w, h, modal, title,
+                         "Next", "Next", "Cancel")
+        maint.title("Welcome to the [ProductName] Setup Wizard")
+        maint.text("BodyText", 15, 63, 330, 42, 3,
+                   "Select whether you want to repair or remove [ProductName].")
+        g=maint.radiogroup("RepairRadioGroup", 15, 108, 330, 60, 3,
+                            "MaintenanceForm_Action", "", "Next")
+        #g.add("Change", 0, 0, 200, 17, "&Change [ProductName]")
+        g.add("Repair", 0, 18, 200, 17, "&Repair [ProductName]")
+        g.add("Remove", 0, 36, 200, 17, "Re&move [ProductName]")
+
+        maint.back("< Back", None, active=False)
+        c=maint.next("Finish", "Cancel")
+        # Change installation: Change progress dialog to "Change", then ask
+        # for feature selection
+        #c.event("[Progress1]", "Change", 'MaintenanceForm_Action="Change"', 1)
+        #c.event("[Progress2]", "changes", 'MaintenanceForm_Action="Change"', 2)
+
+        # Reinstall: Change progress dialog to "Repair", then invoke reinstall
+        # Also set list of reinstalled features to "ALL"
+        c.event("[REINSTALL]", "ALL", 'MaintenanceForm_Action="Repair"', 5)
+        c.event("[Progress1]", "Repairing", 'MaintenanceForm_Action="Repair"', 6)
+        c.event("[Progress2]", "repairs", 'MaintenanceForm_Action="Repair"', 7)
+        c.event("Reinstall", "ALL", 'MaintenanceForm_Action="Repair"', 8)
+
+        # Uninstall: Change progress to "Remove", then invoke uninstall
+        # Also set list of removed features to "ALL"
+        c.event("[REMOVE]", "ALL", 'MaintenanceForm_Action="Remove"', 11)
+        c.event("[Progress1]", "Removing", 'MaintenanceForm_Action="Remove"', 12)
+        c.event("[Progress2]", "removes", 'MaintenanceForm_Action="Remove"', 13)
+        c.event("Remove", "ALL", 'MaintenanceForm_Action="Remove"', 14)
+
+        # Close dialog when maintenance action scheduled
+        c.event("EndDialog", "Return", 'MaintenanceForm_Action<>"Change"', 20)
+        #c.event("NewDialog", "SelectFeaturesDlg", 'MaintenanceForm_Action="Change"', 21)
+
+        maint.cancel("Cancel", "RepairRadioGroup").event("SpawnDialog", "CancelDlg")
+
+    def get_installer_filename(self, fullname):
+        # Factored out to allow overriding in subclasses
+        if self.target_version:
+            base_name = "%s.%s-py%s.msi" % (fullname, self.plat_name,
+                                            self.target_version)
+        else:
+            base_name = "%s.%s.msi" % (fullname, self.plat_name)
+        installer_name = os.path.join(self.dist_dir, base_name)
+        return installer_name
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_rpm.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_rpm.py
new file mode 100644
index 0000000..550cbfa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_rpm.py
@@ -0,0 +1,579 @@
+"""distutils.command.bdist_rpm
+
+Implements the Distutils 'bdist_rpm' command (create RPM source and binary
+distributions)."""
+
+import subprocess, sys, os
+from distutils.core import Command
+from distutils.debug import DEBUG
+from distutils.file_util import write_file
+from distutils.errors import *
+from distutils.sysconfig import get_python_version
+from distutils import log
+
+class bdist_rpm(Command):
+
+    description = "create an RPM distribution"
+
+    user_options = [
+        ('bdist-base=', None,
+         "base directory for creating built distributions"),
+        ('rpm-base=', None,
+         "base directory for creating RPMs (defaults to \"rpm\" under "
+         "--bdist-base; must be specified for RPM 2)"),
+        ('dist-dir=', 'd',
+         "directory to put final RPM files in "
+         "(and .spec files if --spec-only)"),
+        ('python=', None,
+         "path to Python interpreter to hard-code in the .spec file "
+         "(default: \"python\")"),
+        ('fix-python', None,
+         "hard-code the exact path to the current Python interpreter in "
+         "the .spec file"),
+        ('spec-only', None,
+         "only regenerate spec file"),
+        ('source-only', None,
+         "only generate source RPM"),
+        ('binary-only', None,
+         "only generate binary RPM"),
+        ('use-bzip2', None,
+         "use bzip2 instead of gzip to create source distribution"),
+
+        # More meta-data: too RPM-specific to put in the setup script,
+        # but needs to go in the .spec file -- so we make these options
+        # to "bdist_rpm".  The idea is that packagers would put this
+        # info in setup.cfg, although they are of course free to
+        # supply it on the command line.
+        ('distribution-name=', None,
+         "name of the (Linux) distribution to which this "
+         "RPM applies (*not* the name of the module distribution!)"),
+        ('group=', None,
+         "package classification [default: \"Development/Libraries\"]"),
+        ('release=', None,
+         "RPM release number"),
+        ('serial=', None,
+         "RPM serial number"),
+        ('vendor=', None,
+         "RPM \"vendor\" (eg. \"Joe Blow <joe@example.com>\") "
+         "[default: maintainer or author from setup script]"),
+        ('packager=', None,
+         "RPM packager (eg. \"Jane Doe <jane@example.net>\") "
+         "[default: vendor]"),
+        ('doc-files=', None,
+         "list of documentation files (space or comma-separated)"),
+        ('changelog=', None,
+         "RPM changelog"),
+        ('icon=', None,
+         "name of icon file"),
+        ('provides=', None,
+         "capabilities provided by this package"),
+        ('requires=', None,
+         "capabilities required by this package"),
+        ('conflicts=', None,
+         "capabilities which conflict with this package"),
+        ('build-requires=', None,
+         "capabilities required to build this package"),
+        ('obsoletes=', None,
+         "capabilities made obsolete by this package"),
+        ('no-autoreq', None,
+         "do not automatically calculate dependencies"),
+
+        # Actions to take when building RPM
+        ('keep-temp', 'k',
+         "don't clean up RPM build directory"),
+        ('no-keep-temp', None,
+         "clean up RPM build directory [default]"),
+        ('use-rpm-opt-flags', None,
+         "compile with RPM_OPT_FLAGS when building from source RPM"),
+        ('no-rpm-opt-flags', None,
+         "do not pass any RPM CFLAGS to compiler"),
+        ('rpm3-mode', None,
+         "RPM 3 compatibility mode (default)"),
+        ('rpm2-mode', None,
+         "RPM 2 compatibility mode"),
+
+        # Add the hooks necessary for specifying custom scripts
+        ('prep-script=', None,
+         "Specify a script for the PREP phase of RPM building"),
+        ('build-script=', None,
+         "Specify a script for the BUILD phase of RPM building"),
+
+        ('pre-install=', None,
+         "Specify a script for the pre-INSTALL phase of RPM building"),
+        ('install-script=', None,
+         "Specify a script for the INSTALL phase of RPM building"),
+        ('post-install=', None,
+         "Specify a script for the post-INSTALL phase of RPM building"),
+
+        ('pre-uninstall=', None,
+         "Specify a script for the pre-UNINSTALL phase of RPM building"),
+        ('post-uninstall=', None,
+         "Specify a script for the post-UNINSTALL phase of RPM building"),
+
+        ('clean-script=', None,
+         "Specify a script for the CLEAN phase of RPM building"),
+
+        ('verify-script=', None,
+         "Specify a script for the VERIFY phase of the RPM build"),
+
+        # Allow a packager to explicitly force an architecture
+        ('force-arch=', None,
+         "Force an architecture onto the RPM build process"),
+
+        ('quiet', 'q',
+         "Run the INSTALL phase of RPM building in quiet mode"),
+        ]
+
+    boolean_options = ['keep-temp', 'use-rpm-opt-flags', 'rpm3-mode',
+                       'no-autoreq', 'quiet']
+
+    negative_opt = {'no-keep-temp': 'keep-temp',
+                    'no-rpm-opt-flags': 'use-rpm-opt-flags',
+                    'rpm2-mode': 'rpm3-mode'}
+
+
+    def initialize_options(self):
+        self.bdist_base = None
+        self.rpm_base = None
+        self.dist_dir = None
+        self.python = None
+        self.fix_python = None
+        self.spec_only = None
+        self.binary_only = None
+        self.source_only = None
+        self.use_bzip2 = None
+
+        self.distribution_name = None
+        self.group = None
+        self.release = None
+        self.serial = None
+        self.vendor = None
+        self.packager = None
+        self.doc_files = None
+        self.changelog = None
+        self.icon = None
+
+        self.prep_script = None
+        self.build_script = None
+        self.install_script = None
+        self.clean_script = None
+        self.verify_script = None
+        self.pre_install = None
+        self.post_install = None
+        self.pre_uninstall = None
+        self.post_uninstall = None
+        self.prep = None
+        self.provides = None
+        self.requires = None
+        self.conflicts = None
+        self.build_requires = None
+        self.obsoletes = None
+
+        self.keep_temp = 0
+        self.use_rpm_opt_flags = 1
+        self.rpm3_mode = 1
+        self.no_autoreq = 0
+
+        self.force_arch = None
+        self.quiet = 0
+
+    def finalize_options(self):
+        self.set_undefined_options('bdist', ('bdist_base', 'bdist_base'))
+        if self.rpm_base is None:
+            if not self.rpm3_mode:
+                raise DistutilsOptionError(
+                      "you must specify --rpm-base in RPM 2 mode")
+            self.rpm_base = os.path.join(self.bdist_base, "rpm")
+
+        if self.python is None:
+            if self.fix_python:
+                self.python = sys.executable
+            else:
+                self.python = "python3"
+        elif self.fix_python:
+            raise DistutilsOptionError(
+                  "--python and --fix-python are mutually exclusive options")
+
+        if os.name != 'posix':
+            raise DistutilsPlatformError("don't know how to create RPM "
+                   "distributions on platform %s" % os.name)
+        if self.binary_only and self.source_only:
+            raise DistutilsOptionError(
+                  "cannot supply both '--source-only' and '--binary-only'")
+
+        # don't pass CFLAGS to pure python distributions
+        if not self.distribution.has_ext_modules():
+            self.use_rpm_opt_flags = 0
+
+        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
+        self.finalize_package_data()
+
+    def finalize_package_data(self):
+        self.ensure_string('group', "Development/Libraries")
+        self.ensure_string('vendor',
+                           "%s <%s>" % (self.distribution.get_contact(),
+                                        self.distribution.get_contact_email()))
+        self.ensure_string('packager')
+        self.ensure_string_list('doc_files')
+        if isinstance(self.doc_files, list):
+            for readme in ('README', 'README.txt'):
+                if os.path.exists(readme) and readme not in self.doc_files:
+                    self.doc_files.append(readme)
+
+        self.ensure_string('release', "1")
+        self.ensure_string('serial')   # should it be an int?
+
+        self.ensure_string('distribution_name')
+
+        self.ensure_string('changelog')
+          # Format changelog correctly
+        self.changelog = self._format_changelog(self.changelog)
+
+        self.ensure_filename('icon')
+
+        self.ensure_filename('prep_script')
+        self.ensure_filename('build_script')
+        self.ensure_filename('install_script')
+        self.ensure_filename('clean_script')
+        self.ensure_filename('verify_script')
+        self.ensure_filename('pre_install')
+        self.ensure_filename('post_install')
+        self.ensure_filename('pre_uninstall')
+        self.ensure_filename('post_uninstall')
+
+        # XXX don't forget we punted on summaries and descriptions -- they
+        # should be handled here eventually!
+
+        # Now *this* is some meta-data that belongs in the setup script...
+        self.ensure_string_list('provides')
+        self.ensure_string_list('requires')
+        self.ensure_string_list('conflicts')
+        self.ensure_string_list('build_requires')
+        self.ensure_string_list('obsoletes')
+
+        self.ensure_string('force_arch')
+
+    def run(self):
+        if DEBUG:
+            print("before _get_package_data():")
+            print("vendor =", self.vendor)
+            print("packager =", self.packager)
+            print("doc_files =", self.doc_files)
+            print("changelog =", self.changelog)
+
+        # make directories
+        if self.spec_only:
+            spec_dir = self.dist_dir
+            self.mkpath(spec_dir)
+        else:
+            rpm_dir = {}
+            for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'):
+                rpm_dir[d] = os.path.join(self.rpm_base, d)
+                self.mkpath(rpm_dir[d])
+            spec_dir = rpm_dir['SPECS']
+
+        # Spec file goes into 'dist_dir' if '--spec-only specified',
+        # build/rpm.<plat> otherwise.
+        spec_path = os.path.join(spec_dir,
+                                 "%s.spec" % self.distribution.get_name())
+        self.execute(write_file,
+                     (spec_path,
+                      self._make_spec_file()),
+                     "writing '%s'" % spec_path)
+
+        if self.spec_only: # stop if requested
+            return
+
+        # Make a source distribution and copy to SOURCES directory with
+        # optional icon.
+        saved_dist_files = self.distribution.dist_files[:]
+        sdist = self.reinitialize_command('sdist')
+        if self.use_bzip2:
+            sdist.formats = ['bztar']
+        else:
+            sdist.formats = ['gztar']
+        self.run_command('sdist')
+        self.distribution.dist_files = saved_dist_files
+
+        source = sdist.get_archive_files()[0]
+        source_dir = rpm_dir['SOURCES']
+        self.copy_file(source, source_dir)
+
+        if self.icon:
+            if os.path.exists(self.icon):
+                self.copy_file(self.icon, source_dir)
+            else:
+                raise DistutilsFileError(
+                      "icon file '%s' does not exist" % self.icon)
+
+        # build package
+        log.info("building RPMs")
+        rpm_cmd = ['rpmbuild']
+
+        if self.source_only: # what kind of RPMs?
+            rpm_cmd.append('-bs')
+        elif self.binary_only:
+            rpm_cmd.append('-bb')
+        else:
+            rpm_cmd.append('-ba')
+        rpm_cmd.extend(['--define', '__python %s' % self.python])
+        if self.rpm3_mode:
+            rpm_cmd.extend(['--define',
+                             '_topdir %s' % os.path.abspath(self.rpm_base)])
+        if not self.keep_temp:
+            rpm_cmd.append('--clean')
+
+        if self.quiet:
+            rpm_cmd.append('--quiet')
+
+        rpm_cmd.append(spec_path)
+        # Determine the binary rpm names that should be built out of this spec
+        # file
+        # Note that some of these may not be really built (if the file
+        # list is empty)
+        nvr_string = "%{name}-%{version}-%{release}"
+        src_rpm = nvr_string + ".src.rpm"
+        non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm"
+        q_cmd = r"rpm -q --qf '%s %s\n' --specfile '%s'" % (
+            src_rpm, non_src_rpm, spec_path)
+
+        out = os.popen(q_cmd)
+        try:
+            binary_rpms = []
+            source_rpm = None
+            while True:
+                line = out.readline()
+                if not line:
+                    break
+                l = line.strip().split()
+                assert(len(l) == 2)
+                binary_rpms.append(l[1])
+                # The source rpm is named after the first entry in the spec file
+                if source_rpm is None:
+                    source_rpm = l[0]
+
+            status = out.close()
+            if status:
+                raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))
+
+        finally:
+            out.close()
+
+        self.spawn(rpm_cmd)
+
+        if not self.dry_run:
+            if self.distribution.has_ext_modules():
+                pyversion = get_python_version()
+            else:
+                pyversion = 'any'
+
+            if not self.binary_only:
+                srpm = os.path.join(rpm_dir['SRPMS'], source_rpm)
+                assert(os.path.exists(srpm))
+                self.move_file(srpm, self.dist_dir)
+                filename = os.path.join(self.dist_dir, source_rpm)
+                self.distribution.dist_files.append(
+                    ('bdist_rpm', pyversion, filename))
+
+            if not self.source_only:
+                for rpm in binary_rpms:
+                    rpm = os.path.join(rpm_dir['RPMS'], rpm)
+                    if os.path.exists(rpm):
+                        self.move_file(rpm, self.dist_dir)
+                        filename = os.path.join(self.dist_dir,
+                                                os.path.basename(rpm))
+                        self.distribution.dist_files.append(
+                            ('bdist_rpm', pyversion, filename))
+
+    def _dist_path(self, path):
+        return os.path.join(self.dist_dir, os.path.basename(path))
+
+    def _make_spec_file(self):
+        """Generate the text of an RPM spec file and return it as a
+        list of strings (one per line).
+        """
+        # definitions and headers
+        spec_file = [
+            '%define name ' + self.distribution.get_name(),
+            '%define version ' + self.distribution.get_version().replace('-','_'),
+            '%define unmangled_version ' + self.distribution.get_version(),
+            '%define release ' + self.release.replace('-','_'),
+            '',
+            'Summary: ' + self.distribution.get_description(),
+            ]
+
+        # Workaround for #14443 which affects some RPM based systems such as
+        # RHEL6 (and probably derivatives)
+        vendor_hook = subprocess.getoutput('rpm --eval %{__os_install_post}')
+        # Generate a potential replacement value for __os_install_post (whilst
+        # normalizing the whitespace to simplify the test for whether the
+        # invocation of brp-python-bytecompile passes in __python):
+        vendor_hook = '\n'.join(['  %s \\' % line.strip()
+                                 for line in vendor_hook.splitlines()])
+        problem = "brp-python-bytecompile \\\n"
+        fixed = "brp-python-bytecompile %{__python} \\\n"
+        fixed_hook = vendor_hook.replace(problem, fixed)
+        if fixed_hook != vendor_hook:
+            spec_file.append('# Workaround for http://bugs.python.org/issue14443')
+            spec_file.append('%define __os_install_post ' + fixed_hook + '\n')
+
+        # put locale summaries into spec file
+        # XXX not supported for now (hard to put a dictionary
+        # in a config file -- arg!)
+        #for locale in self.summaries.keys():
+        #    spec_file.append('Summary(%s): %s' % (locale,
+        #                                          self.summaries[locale]))
+
+        spec_file.extend([
+            'Name: %{name}',
+            'Version: %{version}',
+            'Release: %{release}',])
+
+        # XXX yuck! this filename is available from the "sdist" command,
+        # but only after it has run: and we create the spec file before
+        # running "sdist", in case of --spec-only.
+        if self.use_bzip2:
+            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.bz2')
+        else:
+            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.gz')
+
+        spec_file.extend([
+            'License: ' + self.distribution.get_license(),
+            'Group: ' + self.group,
+            'BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot',
+            'Prefix: %{_prefix}', ])
+
+        if not self.force_arch:
+            # noarch if no extension modules
+            if not self.distribution.has_ext_modules():
+                spec_file.append('BuildArch: noarch')
+        else:
+            spec_file.append( 'BuildArch: %s' % self.force_arch )
+
+        for field in ('Vendor',
+                      'Packager',
+                      'Provides',
+                      'Requires',
+                      'Conflicts',
+                      'Obsoletes',
+                      ):
+            val = getattr(self, field.lower())
+            if isinstance(val, list):
+                spec_file.append('%s: %s' % (field, ' '.join(val)))
+            elif val is not None:
+                spec_file.append('%s: %s' % (field, val))
+
+
+        if self.distribution.get_url() != 'UNKNOWN':
+            spec_file.append('Url: ' + self.distribution.get_url())
+
+        if self.distribution_name:
+            spec_file.append('Distribution: ' + self.distribution_name)
+
+        if self.build_requires:
+            spec_file.append('BuildRequires: ' +
+                             ' '.join(self.build_requires))
+
+        if self.icon:
+            spec_file.append('Icon: ' + os.path.basename(self.icon))
+
+        if self.no_autoreq:
+            spec_file.append('AutoReq: 0')
+
+        spec_file.extend([
+            '',
+            '%description',
+            self.distribution.get_long_description()
+            ])
+
+        # put locale descriptions into spec file
+        # XXX again, suppressed because config file syntax doesn't
+        # easily support this ;-(
+        #for locale in self.descriptions.keys():
+        #    spec_file.extend([
+        #        '',
+        #        '%description -l ' + locale,
+        #        self.descriptions[locale],
+        #        ])
+
+        # rpm scripts
+        # figure out default build script
+        def_setup_call = "%s %s" % (self.python,os.path.basename(sys.argv[0]))
+        def_build = "%s build" % def_setup_call
+        if self.use_rpm_opt_flags:
+            def_build = 'env CFLAGS="$RPM_OPT_FLAGS" ' + def_build
+
+        # insert contents of files
+
+        # XXX this is kind of misleading: user-supplied options are files
+        # that we open and interpolate into the spec file, but the defaults
+        # are just text that we drop in as-is.  Hmmm.
+
+        install_cmd = ('%s install -O1 --root=$RPM_BUILD_ROOT '
+                       '--record=INSTALLED_FILES') % def_setup_call
+
+        script_options = [
+            ('prep', 'prep_script', "%setup -n %{name}-%{unmangled_version}"),
+            ('build', 'build_script', def_build),
+            ('install', 'install_script', install_cmd),
+            ('clean', 'clean_script', "rm -rf $RPM_BUILD_ROOT"),
+            ('verifyscript', 'verify_script', None),
+            ('pre', 'pre_install', None),
+            ('post', 'post_install', None),
+            ('preun', 'pre_uninstall', None),
+            ('postun', 'post_uninstall', None),
+        ]
+
+        for (rpm_opt, attr, default) in script_options:
+            # Insert contents of file referred to, if no file is referred to
+            # use 'default' as contents of script
+            val = getattr(self, attr)
+            if val or default:
+                spec_file.extend([
+                    '',
+                    '%' + rpm_opt,])
+                if val:
+                    with open(val) as f:
+                        spec_file.extend(f.read().split('\n'))
+                else:
+                    spec_file.append(default)
+
+
+        # files section
+        spec_file.extend([
+            '',
+            '%files -f INSTALLED_FILES',
+            '%defattr(-,root,root)',
+            ])
+
+        if self.doc_files:
+            spec_file.append('%doc ' + ' '.join(self.doc_files))
+
+        if self.changelog:
+            spec_file.extend([
+                '',
+                '%changelog',])
+            spec_file.extend(self.changelog)
+
+        return spec_file
+
+    def _format_changelog(self, changelog):
+        """Format the changelog correctly and convert it to a list of strings
+        """
+        if not changelog:
+            return changelog
+        new_changelog = []
+        for line in changelog.strip().split('\n'):
+            line = line.strip()
+            if line[0] == '*':
+                new_changelog.extend(['', line])
+            elif line[0] == '-':
+                new_changelog.append(line)
+            else:
+                new_changelog.append('  ' + line)
+
+        # strip trailing newline inserted by first changelog entry
+        if not new_changelog[0]:
+            del new_changelog[0]
+
+        return new_changelog
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_wininst.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_wininst.py
new file mode 100644
index 0000000..0e9ddaa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/bdist_wininst.py
@@ -0,0 +1,377 @@
+"""distutils.command.bdist_wininst
+
+Implements the Distutils 'bdist_wininst' command: create a windows installer
+exe-program."""
+
+import os
+import sys
+import warnings
+from distutils.core import Command
+from distutils.util import get_platform
+from distutils.dir_util import remove_tree
+from distutils.errors import *
+from distutils.sysconfig import get_python_version
+from distutils import log
+
+class bdist_wininst(Command):
+
+    description = "create an executable installer for MS Windows"
+
+    user_options = [('bdist-dir=', None,
+                     "temporary directory for creating the distribution"),
+                    ('plat-name=', 'p',
+                     "platform name to embed in generated filenames "
+                     "(default: %s)" % get_platform()),
+                    ('keep-temp', 'k',
+                     "keep the pseudo-installation tree around after " +
+                     "creating the distribution archive"),
+                    ('target-version=', None,
+                     "require a specific python version" +
+                     " on the target system"),
+                    ('no-target-compile', 'c',
+                     "do not compile .py to .pyc on the target system"),
+                    ('no-target-optimize', 'o',
+                     "do not compile .py to .pyo (optimized) "
+                     "on the target system"),
+                    ('dist-dir=', 'd',
+                     "directory to put final built distributions in"),
+                    ('bitmap=', 'b',
+                     "bitmap to use for the installer instead of python-powered logo"),
+                    ('title=', 't',
+                     "title to display on the installer background instead of default"),
+                    ('skip-build', None,
+                     "skip rebuilding everything (for testing/debugging)"),
+                    ('install-script=', None,
+                     "basename of installation script to be run after "
+                     "installation or before deinstallation"),
+                    ('pre-install-script=', None,
+                     "Fully qualified filename of a script to be run before "
+                     "any files are installed.  This script need not be in the "
+                     "distribution"),
+                    ('user-access-control=', None,
+                     "specify Vista's UAC handling - 'none'/default=no "
+                     "handling, 'auto'=use UAC if target Python installed for "
+                     "all users, 'force'=always use UAC"),
+                   ]
+
+    boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
+                       'skip-build']
+
+    # bpo-10945: bdist_wininst requires mbcs encoding only available on Windows
+    _unsupported = (sys.platform != "win32")
+
+    def __init__(self, *args, **kw):
+        super().__init__(*args, **kw)
+        warnings.warn("bdist_wininst command is deprecated since Python 3.8, "
+                      "use bdist_wheel (wheel packages) instead",
+                      DeprecationWarning, 2)
+
+    def initialize_options(self):
+        self.bdist_dir = None
+        self.plat_name = None
+        self.keep_temp = 0
+        self.no_target_compile = 0
+        self.no_target_optimize = 0
+        self.target_version = None
+        self.dist_dir = None
+        self.bitmap = None
+        self.title = None
+        self.skip_build = None
+        self.install_script = None
+        self.pre_install_script = None
+        self.user_access_control = None
+
+
+    def finalize_options(self):
+        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))
+
+        if self.bdist_dir is None:
+            if self.skip_build and self.plat_name:
+                # If build is skipped and plat_name is overridden, bdist will
+                # not see the correct 'plat_name' - so set that up manually.
+                bdist = self.distribution.get_command_obj('bdist')
+                bdist.plat_name = self.plat_name
+                # next the command will be initialized using that name
+            bdist_base = self.get_finalized_command('bdist').bdist_base
+            self.bdist_dir = os.path.join(bdist_base, 'wininst')
+
+        if not self.target_version:
+            self.target_version = ""
+
+        if not self.skip_build and self.distribution.has_ext_modules():
+            short_version = get_python_version()
+            if self.target_version and self.target_version != short_version:
+                raise DistutilsOptionError(
+                      "target version can only be %s, or the '--skip-build'" \
+                      " option must be specified" % (short_version,))
+            self.target_version = short_version
+
+        self.set_undefined_options('bdist',
+                                   ('dist_dir', 'dist_dir'),
+                                   ('plat_name', 'plat_name'),
+                                  )
+
+        if self.install_script:
+            for script in self.distribution.scripts:
+                if self.install_script == os.path.basename(script):
+                    break
+            else:
+                raise DistutilsOptionError(
+                      "install_script '%s' not found in scripts"
+                      % self.install_script)
+
+    def run(self):
+        if (sys.platform != "win32" and
+            (self.distribution.has_ext_modules() or
+             self.distribution.has_c_libraries())):
+            raise DistutilsPlatformError \
+                  ("distribution contains extensions and/or C libraries; "
+                   "must be compiled on a Windows 32 platform")
+
+        if not self.skip_build:
+            self.run_command('build')
+
+        install = self.reinitialize_command('install', reinit_subcommands=1)
+        install.root = self.bdist_dir
+        install.skip_build = self.skip_build
+        install.warn_dir = 0
+        install.plat_name = self.plat_name
+
+        install_lib = self.reinitialize_command('install_lib')
+        # we do not want to include pyc or pyo files
+        install_lib.compile = 0
+        install_lib.optimize = 0
+
+        if self.distribution.has_ext_modules():
+            # If we are building an installer for a Python version other
+            # than the one we are currently running, then we need to ensure
+            # our build_lib reflects the other Python version rather than ours.
+            # Note that for target_version!=sys.version, we must have skipped the
+            # build step, so there is no issue with enforcing the build of this
+            # version.
+            target_version = self.target_version
+            if not target_version:
+                assert self.skip_build, "Should have already checked this"
+                target_version = '%d.%d' % sys.version_info[:2]
+            plat_specifier = ".%s-%s" % (self.plat_name, target_version)
+            build = self.get_finalized_command('build')
+            build.build_lib = os.path.join(build.build_base,
+                                           'lib' + plat_specifier)
+
+        # Use a custom scheme for the zip-file, because we have to decide
+        # at installation time which scheme to use.
+        for key in ('purelib', 'platlib', 'headers', 'scripts', 'data'):
+            value = key.upper()
+            if key == 'headers':
+                value = value + '/Include/$dist_name'
+            setattr(install,
+                    'install_' + key,
+                    value)
+
+        log.info("installing to %s", self.bdist_dir)
+        install.ensure_finalized()
+
+        # avoid warning of 'install_lib' about installing
+        # into a directory not in sys.path
+        sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))
+
+        install.run()
+
+        del sys.path[0]
+
+        # And make an archive relative to the root of the
+        # pseudo-installation tree.
+        from tempfile import mktemp
+        archive_basename = mktemp()
+        fullname = self.distribution.get_fullname()
+        arcname = self.make_archive(archive_basename, "zip",
+                                    root_dir=self.bdist_dir)
+        # create an exe containing the zip-file
+        self.create_exe(arcname, fullname, self.bitmap)
+        if self.distribution.has_ext_modules():
+            pyversion = get_python_version()
+        else:
+            pyversion = 'any'
+        self.distribution.dist_files.append(('bdist_wininst', pyversion,
+                                             self.get_installer_filename(fullname)))
+        # remove the zip-file again
+        log.debug("removing temporary file '%s'", arcname)
+        os.remove(arcname)
+
+        if not self.keep_temp:
+            remove_tree(self.bdist_dir, dry_run=self.dry_run)
+
+    def get_inidata(self):
+        # Return data describing the installation.
+        lines = []
+        metadata = self.distribution.metadata
+
+        # Write the [metadata] section.
+        lines.append("[metadata]")
+
+        # 'info' will be displayed in the installer's dialog box,
+        # describing the items to be installed.
+        info = (metadata.long_description or '') + '\n'
+
+        # Escape newline characters
+        def escape(s):
+            return s.replace("\n", "\\n")
+
+        for name in ["author", "author_email", "description", "maintainer",
+                     "maintainer_email", "name", "url", "version"]:
+            data = getattr(metadata, name, "")
+            if data:
+                info = info + ("\n    %s: %s" % \
+                               (name.capitalize(), escape(data)))
+                lines.append("%s=%s" % (name, escape(data)))
+
+        # The [setup] section contains entries controlling
+        # the installer runtime.
+        lines.append("\n[Setup]")
+        if self.install_script:
+            lines.append("install_script=%s" % self.install_script)
+        lines.append("info=%s" % escape(info))
+        lines.append("target_compile=%d" % (not self.no_target_compile))
+        lines.append("target_optimize=%d" % (not self.no_target_optimize))
+        if self.target_version:
+            lines.append("target_version=%s" % self.target_version)
+        if self.user_access_control:
+            lines.append("user_access_control=%s" % self.user_access_control)
+
+        title = self.title or self.distribution.get_fullname()
+        lines.append("title=%s" % escape(title))
+        import time
+        import distutils
+        build_info = "Built %s with distutils-%s" % \
+                     (time.ctime(time.time()), distutils.__version__)
+        lines.append("build_info=%s" % build_info)
+        return "\n".join(lines)
+
+    def create_exe(self, arcname, fullname, bitmap=None):
+        import struct
+
+        self.mkpath(self.dist_dir)
+
+        cfgdata = self.get_inidata()
+
+        installer_name = self.get_installer_filename(fullname)
+        self.announce("creating %s" % installer_name)
+
+        if bitmap:
+            with open(bitmap, "rb") as f:
+                bitmapdata = f.read()
+            bitmaplen = len(bitmapdata)
+        else:
+            bitmaplen = 0
+
+        with open(installer_name, "wb") as file:
+            file.write(self.get_exe_bytes())
+            if bitmap:
+                file.write(bitmapdata)
+
+            # Convert cfgdata from unicode to ascii, mbcs encoded
+            if isinstance(cfgdata, str):
+                cfgdata = cfgdata.encode("mbcs")
+
+            # Append the pre-install script
+            cfgdata = cfgdata + b"\0"
+            if self.pre_install_script:
+                # We need to normalize newlines, so we open in text mode and
+                # convert back to bytes. "latin-1" simply avoids any possible
+                # failures.
+                with open(self.pre_install_script, "r",
+                          encoding="latin-1") as script:
+                    script_data = script.read().encode("latin-1")
+                cfgdata = cfgdata + script_data + b"\n\0"
+            else:
+                # empty pre-install script
+                cfgdata = cfgdata + b"\0"
+            file.write(cfgdata)
+
+            # The 'magic number' 0x1234567B is used to make sure that the
+            # binary layout of 'cfgdata' is what the wininst.exe binary
+            # expects.  If the layout changes, increment that number, make
+            # the corresponding changes to the wininst.exe sources, and
+            # recompile them.
+            header = struct.pack("<iii",
+                                0x1234567B,       # tag
+                                len(cfgdata),     # length
+                                bitmaplen,        # number of bytes in bitmap
+                                )
+            file.write(header)
+            with open(arcname, "rb") as f:
+                file.write(f.read())
+
+    def get_installer_filename(self, fullname):
+        # Factored out to allow overriding in subclasses
+        if self.target_version:
+            # if we create an installer for a specific python version,
+            # it's better to include this in the name
+            installer_name = os.path.join(self.dist_dir,
+                                          "%s.%s-py%s.exe" %
+                                           (fullname, self.plat_name, self.target_version))
+        else:
+            installer_name = os.path.join(self.dist_dir,
+                                          "%s.%s.exe" % (fullname, self.plat_name))
+        return installer_name
+
+    def get_exe_bytes(self):
+        # If a target-version other than the current version has been
+        # specified, then using the MSVC version from *this* build is no good.
+        # Without actually finding and executing the target version and parsing
+        # its sys.version, we just hard-code our knowledge of old versions.
+        # NOTE: Possible alternative is to allow "--target-version" to
+        # specify a Python executable rather than a simple version string.
+        # We can then execute this program to obtain any info we need, such
+        # as the real sys.version string for the build.
+        cur_version = get_python_version()
+
+        # If the target version is *later* than us, then we assume they
+        # use what we use
+        # string compares seem wrong, but are what sysconfig.py itself uses
+        if self.target_version and self.target_version < cur_version:
+            if self.target_version < "2.4":
+                bv = '6.0'
+            elif self.target_version == "2.4":
+                bv = '7.1'
+            elif self.target_version == "2.5":
+                bv = '8.0'
+            elif self.target_version <= "3.2":
+                bv = '9.0'
+            elif self.target_version <= "3.4":
+                bv = '10.0'
+            else:
+                bv = '14.0'
+        else:
+            # for current version - use authoritative check.
+            try:
+                from msvcrt import CRT_ASSEMBLY_VERSION
+            except ImportError:
+                # cross-building, so assume the latest version
+                bv = '14.0'
+            else:
+                # as far as we know, CRT is binary compatible based on
+                # the first field, so assume 'x.0' until proven otherwise
+                major = CRT_ASSEMBLY_VERSION.partition('.')[0]
+                bv = major + '.0'
+
+
+        # wininst-x.y.exe is in the same directory as this file
+        directory = os.path.dirname(__file__)
+        # we must use a wininst-x.y.exe built with the same C compiler
+        # used for python.  XXX What about mingw, borland, and so on?
+
+        # if plat_name starts with "win" but is not "win32"
+        # we want to strip "win" and leave the rest (e.g. -amd64)
+        # for all other cases, we don't want any suffix
+        if self.plat_name != 'win32' and self.plat_name[:3] == 'win':
+            sfix = self.plat_name[3:]
+        else:
+            sfix = ''
+
+        filename = os.path.join(directory, "wininst-%s%s.exe" % (bv, sfix))
+        f = open(filename, "rb")
+        try:
+            return f.read()
+        finally:
+            f.close()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build.py
new file mode 100644
index 0000000..a86df0b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build.py
@@ -0,0 +1,157 @@
+"""distutils.command.build
+
+Implements the Distutils 'build' command."""
+
+import sys, os
+from distutils.core import Command
+from distutils.errors import DistutilsOptionError
+from distutils.util import get_platform
+
+
+def show_compilers():
+    from distutils.ccompiler import show_compilers
+    show_compilers()
+
+
+class build(Command):
+
+    description = "build everything needed to install"
+
+    user_options = [
+        ('build-base=', 'b',
+         "base directory for build library"),
+        ('build-purelib=', None,
+         "build directory for platform-neutral distributions"),
+        ('build-platlib=', None,
+         "build directory for platform-specific distributions"),
+        ('build-lib=', None,
+         "build directory for all distribution (defaults to either " +
+         "build-purelib or build-platlib"),
+        ('build-scripts=', None,
+         "build directory for scripts"),
+        ('build-temp=', 't',
+         "temporary build directory"),
+        ('plat-name=', 'p',
+         "platform name to build for, if supported "
+         "(default: %s)" % get_platform()),
+        ('compiler=', 'c',
+         "specify the compiler type"),
+        ('parallel=', 'j',
+         "number of parallel build jobs"),
+        ('debug', 'g',
+         "compile extensions and libraries with debugging information"),
+        ('force', 'f',
+         "forcibly build everything (ignore file timestamps)"),
+        ('executable=', 'e',
+         "specify final destination interpreter path (build.py)"),
+        ]
+
+    boolean_options = ['debug', 'force']
+
+    help_options = [
+        ('help-compiler', None,
+         "list available compilers", show_compilers),
+        ]
+
+    def initialize_options(self):
+        self.build_base = 'build'
+        # these are decided only after 'build_base' has its final value
+        # (unless overridden by the user or client)
+        self.build_purelib = None
+        self.build_platlib = None
+        self.build_lib = None
+        self.build_temp = None
+        self.build_scripts = None
+        self.compiler = None
+        self.plat_name = None
+        self.debug = None
+        self.force = 0
+        self.executable = None
+        self.parallel = None
+
+    def finalize_options(self):
+        if self.plat_name is None:
+            self.plat_name = get_platform()
+        else:
+            # plat-name only supported for windows (other platforms are
+            # supported via ./configure flags, if at all).  Avoid misleading
+            # other platforms.
+            if os.name != 'nt':
+                raise DistutilsOptionError(
+                            "--plat-name only supported on Windows (try "
+                            "using './configure --help' on your platform)")
+
+        plat_specifier = ".%s-%d.%d" % (self.plat_name, *sys.version_info[:2])
+
+        # Make it so Python 2.x and Python 2.x with --with-pydebug don't
+        # share the same build directories. Doing so confuses the build
+        # process for C modules
+        if hasattr(sys, 'gettotalrefcount'):
+            plat_specifier += '-pydebug'
+
+        # 'build_purelib' and 'build_platlib' just default to 'lib' and
+        # 'lib.<plat>' under the base build directory.  We only use one of
+        # them for a given distribution, though --
+        if self.build_purelib is None:
+            self.build_purelib = os.path.join(self.build_base, 'lib')
+        if self.build_platlib is None:
+            self.build_platlib = os.path.join(self.build_base,
+                                              'lib' + plat_specifier)
+
+        # 'build_lib' is the actual directory that we will use for this
+        # particular module distribution -- if user didn't supply it, pick
+        # one of 'build_purelib' or 'build_platlib'.
+        if self.build_lib is None:
+            if self.distribution.ext_modules:
+                self.build_lib = self.build_platlib
+            else:
+                self.build_lib = self.build_purelib
+
+        # 'build_temp' -- temporary directory for compiler turds,
+        # "build/temp.<plat>"
+        if self.build_temp is None:
+            self.build_temp = os.path.join(self.build_base,
+                                           'temp' + plat_specifier)
+        if self.build_scripts is None:
+            self.build_scripts = os.path.join(self.build_base,
+                                              'scripts-%d.%d' % sys.version_info[:2])
+
+        if self.executable is None and sys.executable:
+            self.executable = os.path.normpath(sys.executable)
+
+        if isinstance(self.parallel, str):
+            try:
+                self.parallel = int(self.parallel)
+            except ValueError:
+                raise DistutilsOptionError("parallel should be an integer")
+
+    def run(self):
+        # Run all relevant sub-commands.  This will be some subset of:
+        #  - build_py      - pure Python modules
+        #  - build_clib    - standalone C libraries
+        #  - build_ext     - Python extensions
+        #  - build_scripts - (Python) scripts
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+
+    # -- Predicates for the sub-command list ---------------------------
+
+    def has_pure_modules(self):
+        return self.distribution.has_pure_modules()
+
+    def has_c_libraries(self):
+        return self.distribution.has_c_libraries()
+
+    def has_ext_modules(self):
+        return self.distribution.has_ext_modules()
+
+    def has_scripts(self):
+        return self.distribution.has_scripts()
+
+
+    sub_commands = [('build_py',      has_pure_modules),
+                    ('build_clib',    has_c_libraries),
+                    ('build_ext',     has_ext_modules),
+                    ('build_scripts', has_scripts),
+                   ]
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_clib.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_clib.py
new file mode 100644
index 0000000..3e20ef2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_clib.py
@@ -0,0 +1,209 @@
+"""distutils.command.build_clib
+
+Implements the Distutils 'build_clib' command, to build a C/C++ library
+that is included in the module distribution and needed by an extension
+module."""
+
+
+# XXX this module has *lots* of code ripped-off quite transparently from
+# build_ext.py -- not surprisingly really, as the work required to build
+# a static library from a collection of C source files is not really all
+# that different from what's required to build a shared object file from
+# a collection of C source files.  Nevertheless, I haven't done the
+# necessary refactoring to account for the overlap in code between the
+# two modules, mainly because a number of subtle details changed in the
+# cut 'n paste.  Sigh.
+
+import os
+from distutils.core import Command
+from distutils.errors import *
+from distutils.sysconfig import customize_compiler
+from distutils import log
+
+def show_compilers():
+    from distutils.ccompiler import show_compilers
+    show_compilers()
+
+
+class build_clib(Command):
+
+    description = "build C/C++ libraries used by Python extensions"
+
+    user_options = [
+        ('build-clib=', 'b',
+         "directory to build C/C++ libraries to"),
+        ('build-temp=', 't',
+         "directory to put temporary build by-products"),
+        ('debug', 'g',
+         "compile with debugging information"),
+        ('force', 'f',
+         "forcibly build everything (ignore file timestamps)"),
+        ('compiler=', 'c',
+         "specify the compiler type"),
+        ]
+
+    boolean_options = ['debug', 'force']
+
+    help_options = [
+        ('help-compiler', None,
+         "list available compilers", show_compilers),
+        ]
+
+    def initialize_options(self):
+        self.build_clib = None
+        self.build_temp = None
+
+        # List of libraries to build
+        self.libraries = None
+
+        # Compilation options for all libraries
+        self.include_dirs = None
+        self.define = None
+        self.undef = None
+        self.debug = None
+        self.force = 0
+        self.compiler = None
+
+
+    def finalize_options(self):
+        # This might be confusing: both build-clib and build-temp default
+        # to build-temp as defined by the "build" command.  This is because
+        # I think that C libraries are really just temporary build
+        # by-products, at least from the point of view of building Python
+        # extensions -- but I want to keep my options open.
+        self.set_undefined_options('build',
+                                   ('build_temp', 'build_clib'),
+                                   ('build_temp', 'build_temp'),
+                                   ('compiler', 'compiler'),
+                                   ('debug', 'debug'),
+                                   ('force', 'force'))
+
+        self.libraries = self.distribution.libraries
+        if self.libraries:
+            self.check_library_list(self.libraries)
+
+        if self.include_dirs is None:
+            self.include_dirs = self.distribution.include_dirs or []
+        if isinstance(self.include_dirs, str):
+            self.include_dirs = self.include_dirs.split(os.pathsep)
+
+        # XXX same as for build_ext -- what about 'self.define' and
+        # 'self.undef' ?
+
+
+    def run(self):
+        if not self.libraries:
+            return
+
+        # Yech -- this is cut 'n pasted from build_ext.py!
+        from distutils.ccompiler import new_compiler
+        self.compiler = new_compiler(compiler=self.compiler,
+                                     dry_run=self.dry_run,
+                                     force=self.force)
+        customize_compiler(self.compiler)
+
+        if self.include_dirs is not None:
+            self.compiler.set_include_dirs(self.include_dirs)
+        if self.define is not None:
+            # 'define' option is a list of (name,value) tuples
+            for (name,value) in self.define:
+                self.compiler.define_macro(name, value)
+        if self.undef is not None:
+            for macro in self.undef:
+                self.compiler.undefine_macro(macro)
+
+        self.build_libraries(self.libraries)
+
+
+    def check_library_list(self, libraries):
+        """Ensure that the list of libraries is valid.
+
+        `library` is presumably provided as a command option 'libraries'.
+        This method checks that it is a list of 2-tuples, where the tuples
+        are (library_name, build_info_dict).
+
+        Raise DistutilsSetupError if the structure is invalid anywhere;
+        just returns otherwise.
+        """
+        if not isinstance(libraries, list):
+            raise DistutilsSetupError(
+                  "'libraries' option must be a list of tuples")
+
+        for lib in libraries:
+            if not isinstance(lib, tuple) and len(lib) != 2:
+                raise DistutilsSetupError(
+                      "each element of 'libraries' must a 2-tuple")
+
+            name, build_info = lib
+
+            if not isinstance(name, str):
+                raise DistutilsSetupError(
+                      "first element of each tuple in 'libraries' "
+                      "must be a string (the library name)")
+
+            if '/' in name or (os.sep != '/' and os.sep in name):
+                raise DistutilsSetupError("bad library name '%s': "
+                       "may not contain directory separators" % lib[0])
+
+            if not isinstance(build_info, dict):
+                raise DistutilsSetupError(
+                      "second element of each tuple in 'libraries' "
+                      "must be a dictionary (build info)")
+
+
+    def get_library_names(self):
+        # Assume the library list is valid -- 'check_library_list()' is
+        # called from 'finalize_options()', so it should be!
+        if not self.libraries:
+            return None
+
+        lib_names = []
+        for (lib_name, build_info) in self.libraries:
+            lib_names.append(lib_name)
+        return lib_names
+
+
+    def get_source_files(self):
+        self.check_library_list(self.libraries)
+        filenames = []
+        for (lib_name, build_info) in self.libraries:
+            sources = build_info.get('sources')
+            if sources is None or not isinstance(sources, (list, tuple)):
+                raise DistutilsSetupError(
+                       "in 'libraries' option (library '%s'), "
+                       "'sources' must be present and must be "
+                       "a list of source filenames" % lib_name)
+
+            filenames.extend(sources)
+        return filenames
+
+
+    def build_libraries(self, libraries):
+        for (lib_name, build_info) in libraries:
+            sources = build_info.get('sources')
+            if sources is None or not isinstance(sources, (list, tuple)):
+                raise DistutilsSetupError(
+                       "in 'libraries' option (library '%s'), "
+                       "'sources' must be present and must be "
+                       "a list of source filenames" % lib_name)
+            sources = list(sources)
+
+            log.info("building '%s' library", lib_name)
+
+            # First, compile the source code to object files in the library
+            # directory.  (This should probably change to putting object
+            # files in a temporary build directory.)
+            macros = build_info.get('macros')
+            include_dirs = build_info.get('include_dirs')
+            objects = self.compiler.compile(sources,
+                                            output_dir=self.build_temp,
+                                            macros=macros,
+                                            include_dirs=include_dirs,
+                                            debug=self.debug)
+
+            # Now "link" the object files together into a static library.
+            # (On Unix at least, this isn't really linking -- it just
+            # builds an archive.  Whatever.)
+            self.compiler.create_static_lib(objects, lib_name,
+                                            output_dir=self.build_clib,
+                                            debug=self.debug)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_ext.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_ext.py
new file mode 100644
index 0000000..1a9bd12
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_ext.py
@@ -0,0 +1,754 @@
+"""distutils.command.build_ext
+
+Implements the Distutils 'build_ext' command, for building extension
+modules (currently limited to C extensions, should accommodate C++
+extensions ASAP)."""
+
+import contextlib
+import os
+import re
+import sys
+from distutils.core import Command
+from distutils.errors import *
+from distutils.sysconfig import customize_compiler, get_python_version
+from distutils.sysconfig import get_config_h_filename
+from distutils.dep_util import newer_group
+from distutils.extension import Extension
+from distutils.util import get_platform
+from distutils import log
+
+from site import USER_BASE
+
+# An extension name is just a dot-separated list of Python NAMEs (ie.
+# the same as a fully-qualified module name).
+extension_name_re = re.compile \
+    (r'^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$')
+
+
+def show_compilers ():
+    from distutils.ccompiler import show_compilers
+    show_compilers()
+
+
+class build_ext(Command):
+
+    description = "build C/C++ extensions (compile/link to build directory)"
+
+    # XXX thoughts on how to deal with complex command-line options like
+    # these, i.e. how to make it so fancy_getopt can suck them off the
+    # command line and make it look like setup.py defined the appropriate
+    # lists of tuples of what-have-you.
+    #   - each command needs a callback to process its command-line options
+    #   - Command.__init__() needs access to its share of the whole
+    #     command line (must ultimately come from
+    #     Distribution.parse_command_line())
+    #   - it then calls the current command class' option-parsing
+    #     callback to deal with weird options like -D, which have to
+    #     parse the option text and churn out some custom data
+    #     structure
+    #   - that data structure (in this case, a list of 2-tuples)
+    #     will then be present in the command object by the time
+    #     we get to finalize_options() (i.e. the constructor
+    #     takes care of both command-line and client options
+    #     in between initialize_options() and finalize_options())
+
+    sep_by = " (separated by '%s')" % os.pathsep
+    user_options = [
+        ('build-lib=', 'b',
+         "directory for compiled extension modules"),
+        ('build-temp=', 't',
+         "directory for temporary files (build by-products)"),
+        ('plat-name=', 'p',
+         "platform name to cross-compile for, if supported "
+         "(default: %s)" % get_platform()),
+        ('inplace', 'i',
+         "ignore build-lib and put compiled extensions into the source " +
+         "directory alongside your pure Python modules"),
+        ('include-dirs=', 'I',
+         "list of directories to search for header files" + sep_by),
+        ('define=', 'D',
+         "C preprocessor macros to define"),
+        ('undef=', 'U',
+         "C preprocessor macros to undefine"),
+        ('libraries=', 'l',
+         "external C libraries to link with"),
+        ('library-dirs=', 'L',
+         "directories to search for external C libraries" + sep_by),
+        ('rpath=', 'R',
+         "directories to search for shared C libraries at runtime"),
+        ('link-objects=', 'O',
+         "extra explicit link objects to include in the link"),
+        ('debug', 'g',
+         "compile/link with debugging information"),
+        ('force', 'f',
+         "forcibly build everything (ignore file timestamps)"),
+        ('compiler=', 'c',
+         "specify the compiler type"),
+        ('parallel=', 'j',
+         "number of parallel build jobs"),
+        ('swig-cpp', None,
+         "make SWIG create C++ files (default is C)"),
+        ('swig-opts=', None,
+         "list of SWIG command line options"),
+        ('swig=', None,
+         "path to the SWIG executable"),
+        ('user', None,
+         "add user include, library and rpath")
+        ]
+
+    boolean_options = ['inplace', 'debug', 'force', 'swig-cpp', 'user']
+
+    help_options = [
+        ('help-compiler', None,
+         "list available compilers", show_compilers),
+        ]
+
+    def initialize_options(self):
+        self.extensions = None
+        self.build_lib = None
+        self.plat_name = None
+        self.build_temp = None
+        self.inplace = 0
+        self.package = None
+
+        self.include_dirs = None
+        self.define = None
+        self.undef = None
+        self.libraries = None
+        self.library_dirs = None
+        self.rpath = None
+        self.link_objects = None
+        self.debug = None
+        self.force = None
+        self.compiler = None
+        self.swig = None
+        self.swig_cpp = None
+        self.swig_opts = None
+        self.user = None
+        self.parallel = None
+
+    def finalize_options(self):
+        from distutils import sysconfig
+
+        self.set_undefined_options('build',
+                                   ('build_lib', 'build_lib'),
+                                   ('build_temp', 'build_temp'),
+                                   ('compiler', 'compiler'),
+                                   ('debug', 'debug'),
+                                   ('force', 'force'),
+                                   ('parallel', 'parallel'),
+                                   ('plat_name', 'plat_name'),
+                                   )
+
+        if self.package is None:
+            self.package = self.distribution.ext_package
+
+        self.extensions = self.distribution.ext_modules
+
+        # Make sure Python's include directories (for Python.h, pyconfig.h,
+        # etc.) are in the include search path.
+        py_include = sysconfig.get_python_inc()
+        plat_py_include = sysconfig.get_python_inc(plat_specific=1)
+        if self.include_dirs is None:
+            self.include_dirs = self.distribution.include_dirs or []
+        if isinstance(self.include_dirs, str):
+            self.include_dirs = self.include_dirs.split(os.pathsep)
+
+        # If in a virtualenv, add its include directory
+        # Issue 16116
+        if sys.exec_prefix != sys.base_exec_prefix:
+            self.include_dirs.append(os.path.join(sys.exec_prefix, 'include'))
+
+        # Put the Python "system" include dir at the end, so that
+        # any local include dirs take precedence.
+        self.include_dirs.extend(py_include.split(os.path.pathsep))
+        if plat_py_include != py_include:
+            self.include_dirs.extend(
+                plat_py_include.split(os.path.pathsep))
+
+        self.ensure_string_list('libraries')
+        self.ensure_string_list('link_objects')
+
+        # Life is easier if we're not forever checking for None, so
+        # simplify these options to empty lists if unset
+        if self.libraries is None:
+            self.libraries = []
+        if self.library_dirs is None:
+            self.library_dirs = []
+        elif isinstance(self.library_dirs, str):
+            self.library_dirs = self.library_dirs.split(os.pathsep)
+
+        if self.rpath is None:
+            self.rpath = []
+        elif isinstance(self.rpath, str):
+            self.rpath = self.rpath.split(os.pathsep)
+
+        # for extensions under windows use different directories
+        # for Release and Debug builds.
+        # also Python's library directory must be appended to library_dirs
+        if os.name == 'nt':
+            # the 'libs' directory is for binary installs - we assume that
+            # must be the *native* platform.  But we don't really support
+            # cross-compiling via a binary install anyway, so we let it go.
+            self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
+            if sys.base_exec_prefix != sys.prefix:  # Issue 16116
+                self.library_dirs.append(os.path.join(sys.base_exec_prefix, 'libs'))
+            if self.debug:
+                self.build_temp = os.path.join(self.build_temp, "Debug")
+            else:
+                self.build_temp = os.path.join(self.build_temp, "Release")
+
+            # Append the source distribution include and library directories,
+            # this allows distutils on windows to work in the source tree
+            self.include_dirs.append(os.path.dirname(get_config_h_filename()))
+            _sys_home = getattr(sys, '_home', None)
+            if _sys_home:
+                self.library_dirs.append(_sys_home)
+
+            # Use the .lib files for the correct architecture
+            if self.plat_name == 'win32':
+                suffix = 'win32'
+            else:
+                # win-amd64
+                suffix = self.plat_name[4:]
+            new_lib = os.path.join(sys.exec_prefix, 'PCbuild')
+            if suffix:
+                new_lib = os.path.join(new_lib, suffix)
+            self.library_dirs.append(new_lib)
+
+        # For extensions under Cygwin, Python's library directory must be
+        # appended to library_dirs
+        if sys.platform[:6] == 'cygwin':
+            if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")):
+                # building third party extensions
+                self.library_dirs.append(os.path.join(sys.prefix, "lib",
+                                                      "python" + get_python_version(),
+                                                      "config"))
+            else:
+                # building python standard extensions
+                self.library_dirs.append('.')
+
+        # For building extensions with a shared Python library,
+        # Python's library directory must be appended to library_dirs
+        # See Issues: #1600860, #4366
+        if (sysconfig.get_config_var('Py_ENABLE_SHARED')):
+            if not sysconfig.python_build:
+                # building third party extensions
+                self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))
+            else:
+                # building python standard extensions
+                self.library_dirs.append('.')
+
+        # The argument parsing will result in self.define being a string, but
+        # it has to be a list of 2-tuples.  All the preprocessor symbols
+        # specified by the 'define' option will be set to '1'.  Multiple
+        # symbols can be separated with commas.
+
+        if self.define:
+            defines = self.define.split(',')
+            self.define = [(symbol, '1') for symbol in defines]
+
+        # The option for macros to undefine is also a string from the
+        # option parsing, but has to be a list.  Multiple symbols can also
+        # be separated with commas here.
+        if self.undef:
+            self.undef = self.undef.split(',')
+
+        if self.swig_opts is None:
+            self.swig_opts = []
+        else:
+            self.swig_opts = self.swig_opts.split(' ')
+
+        # Finally add the user include and library directories if requested
+        if self.user:
+            user_include = os.path.join(USER_BASE, "include")
+            user_lib = os.path.join(USER_BASE, "lib")
+            if os.path.isdir(user_include):
+                self.include_dirs.append(user_include)
+            if os.path.isdir(user_lib):
+                self.library_dirs.append(user_lib)
+                self.rpath.append(user_lib)
+
+        if isinstance(self.parallel, str):
+            try:
+                self.parallel = int(self.parallel)
+            except ValueError:
+                raise DistutilsOptionError("parallel should be an integer")
+
+    def run(self):
+        from distutils.ccompiler import new_compiler
+
+        # 'self.extensions', as supplied by setup.py, is a list of
+        # Extension instances.  See the documentation for Extension (in
+        # distutils.extension) for details.
+        #
+        # For backwards compatibility with Distutils 0.8.2 and earlier, we
+        # also allow the 'extensions' list to be a list of tuples:
+        #    (ext_name, build_info)
+        # where build_info is a dictionary containing everything that
+        # Extension instances do except the name, with a few things being
+        # differently named.  We convert these 2-tuples to Extension
+        # instances as needed.
+
+        if not self.extensions:
+            return
+
+        # If we were asked to build any C/C++ libraries, make sure that the
+        # directory where we put them is in the library search path for
+        # linking extensions.
+        if self.distribution.has_c_libraries():
+            build_clib = self.get_finalized_command('build_clib')
+            self.libraries.extend(build_clib.get_library_names() or [])
+            self.library_dirs.append(build_clib.build_clib)
+
+        # Setup the CCompiler object that we'll use to do all the
+        # compiling and linking
+        self.compiler = new_compiler(compiler=self.compiler,
+                                     verbose=self.verbose,
+                                     dry_run=self.dry_run,
+                                     force=self.force)
+        customize_compiler(self.compiler)
+        # If we are cross-compiling, init the compiler now (if we are not
+        # cross-compiling, init would not hurt, but people may rely on
+        # late initialization of compiler even if they shouldn't...)
+        if os.name == 'nt' and self.plat_name != get_platform():
+            self.compiler.initialize(self.plat_name)
+
+        # And make sure that any compile/link-related options (which might
+        # come from the command-line or from the setup script) are set in
+        # that CCompiler object -- that way, they automatically apply to
+        # all compiling and linking done here.
+        if self.include_dirs is not None:
+            self.compiler.set_include_dirs(self.include_dirs)
+        if self.define is not None:
+            # 'define' option is a list of (name,value) tuples
+            for (name, value) in self.define:
+                self.compiler.define_macro(name, value)
+        if self.undef is not None:
+            for macro in self.undef:
+                self.compiler.undefine_macro(macro)
+        if self.libraries is not None:
+            self.compiler.set_libraries(self.libraries)
+        if self.library_dirs is not None:
+            self.compiler.set_library_dirs(self.library_dirs)
+        if self.rpath is not None:
+            self.compiler.set_runtime_library_dirs(self.rpath)
+        if self.link_objects is not None:
+            self.compiler.set_link_objects(self.link_objects)
+
+        # Now actually compile and link everything.
+        self.build_extensions()
+
+    def check_extensions_list(self, extensions):
+        """Ensure that the list of extensions (presumably provided as a
+        command option 'extensions') is valid, i.e. it is a list of
+        Extension objects.  We also support the old-style list of 2-tuples,
+        where the tuples are (ext_name, build_info), which are converted to
+        Extension instances here.
+
+        Raise DistutilsSetupError if the structure is invalid anywhere;
+        just returns otherwise.
+        """
+        if not isinstance(extensions, list):
+            raise DistutilsSetupError(
+                  "'ext_modules' option must be a list of Extension instances")
+
+        for i, ext in enumerate(extensions):
+            if isinstance(ext, Extension):
+                continue                # OK! (assume type-checking done
+                                        # by Extension constructor)
+
+            if not isinstance(ext, tuple) or len(ext) != 2:
+                raise DistutilsSetupError(
+                       "each element of 'ext_modules' option must be an "
+                       "Extension instance or 2-tuple")
+
+            ext_name, build_info = ext
+
+            log.warn("old-style (ext_name, build_info) tuple found in "
+                     "ext_modules for extension '%s' "
+                     "-- please convert to Extension instance", ext_name)
+
+            if not (isinstance(ext_name, str) and
+                    extension_name_re.match(ext_name)):
+                raise DistutilsSetupError(
+                       "first element of each tuple in 'ext_modules' "
+                       "must be the extension name (a string)")
+
+            if not isinstance(build_info, dict):
+                raise DistutilsSetupError(
+                       "second element of each tuple in 'ext_modules' "
+                       "must be a dictionary (build info)")
+
+            # OK, the (ext_name, build_info) dict is type-safe: convert it
+            # to an Extension instance.
+            ext = Extension(ext_name, build_info['sources'])
+
+            # Easy stuff: one-to-one mapping from dict elements to
+            # instance attributes.
+            for key in ('include_dirs', 'library_dirs', 'libraries',
+                        'extra_objects', 'extra_compile_args',
+                        'extra_link_args'):
+                val = build_info.get(key)
+                if val is not None:
+                    setattr(ext, key, val)
+
+            # Medium-easy stuff: same syntax/semantics, different names.
+            ext.runtime_library_dirs = build_info.get('rpath')
+            if 'def_file' in build_info:
+                log.warn("'def_file' element of build info dict "
+                         "no longer supported")
+
+            # Non-trivial stuff: 'macros' split into 'define_macros'
+            # and 'undef_macros'.
+            macros = build_info.get('macros')
+            if macros:
+                ext.define_macros = []
+                ext.undef_macros = []
+                for macro in macros:
+                    if not (isinstance(macro, tuple) and len(macro) in (1, 2)):
+                        raise DistutilsSetupError(
+                              "'macros' element of build info dict "
+                              "must be 1- or 2-tuple")
+                    if len(macro) == 1:
+                        ext.undef_macros.append(macro[0])
+                    elif len(macro) == 2:
+                        ext.define_macros.append(macro)
+
+            extensions[i] = ext
+
+    def get_source_files(self):
+        self.check_extensions_list(self.extensions)
+        filenames = []
+
+        # Wouldn't it be neat if we knew the names of header files too...
+        for ext in self.extensions:
+            filenames.extend(ext.sources)
+        return filenames
+
+    def get_outputs(self):
+        # Sanity check the 'extensions' list -- can't assume this is being
+        # done in the same run as a 'build_extensions()' call (in fact, we
+        # can probably assume that it *isn't*!).
+        self.check_extensions_list(self.extensions)
+
+        # And build the list of output (built) filenames.  Note that this
+        # ignores the 'inplace' flag, and assumes everything goes in the
+        # "build" tree.
+        outputs = []
+        for ext in self.extensions:
+            outputs.append(self.get_ext_fullpath(ext.name))
+        return outputs
+
+    def build_extensions(self):
+        # First, sanity-check the 'extensions' list
+        self.check_extensions_list(self.extensions)
+        if self.parallel:
+            self._build_extensions_parallel()
+        else:
+            self._build_extensions_serial()
+
+    def _build_extensions_parallel(self):
+        workers = self.parallel
+        if self.parallel is True:
+            workers = os.cpu_count()  # may return None
+        try:
+            from concurrent.futures import ThreadPoolExecutor
+        except ImportError:
+            workers = None
+
+        if workers is None:
+            self._build_extensions_serial()
+            return
+
+        with ThreadPoolExecutor(max_workers=workers) as executor:
+            futures = [executor.submit(self.build_extension, ext)
+                       for ext in self.extensions]
+            for ext, fut in zip(self.extensions, futures):
+                with self._filter_build_errors(ext):
+                    fut.result()
+
+    def _build_extensions_serial(self):
+        for ext in self.extensions:
+            with self._filter_build_errors(ext):
+                self.build_extension(ext)
+
+    @contextlib.contextmanager
+    def _filter_build_errors(self, ext):
+        try:
+            yield
+        except (CCompilerError, DistutilsError, CompileError) as e:
+            if not ext.optional:
+                raise
+            self.warn('building extension "%s" failed: %s' %
+                      (ext.name, e))
+
+    def build_extension(self, ext):
+        sources = ext.sources
+        if sources is None or not isinstance(sources, (list, tuple)):
+            raise DistutilsSetupError(
+                  "in 'ext_modules' option (extension '%s'), "
+                  "'sources' must be present and must be "
+                  "a list of source filenames" % ext.name)
+        # sort to make the resulting .so file build reproducible
+        sources = sorted(sources)
+
+        ext_path = self.get_ext_fullpath(ext.name)
+        depends = sources + ext.depends
+        if not (self.force or newer_group(depends, ext_path, 'newer')):
+            log.debug("skipping '%s' extension (up-to-date)", ext.name)
+            return
+        else:
+            log.info("building '%s' extension", ext.name)
+
+        # First, scan the sources for SWIG definition files (.i), run
+        # SWIG on 'em to create .c files, and modify the sources list
+        # accordingly.
+        sources = self.swig_sources(sources, ext)
+
+        # Next, compile the source code to object files.
+
+        # XXX not honouring 'define_macros' or 'undef_macros' -- the
+        # CCompiler API needs to change to accommodate this, and I
+        # want to do one thing at a time!
+
+        # Two possible sources for extra compiler arguments:
+        #   - 'extra_compile_args' in Extension object
+        #   - CFLAGS environment variable (not particularly
+        #     elegant, but people seem to expect it and I
+        #     guess it's useful)
+        # The environment variable should take precedence, and
+        # any sensible compiler will give precedence to later
+        # command line args.  Hence we combine them in order:
+        extra_args = ext.extra_compile_args or []
+
+        macros = ext.define_macros[:]
+        for undef in ext.undef_macros:
+            macros.append((undef,))
+
+        objects = self.compiler.compile(sources,
+                                         output_dir=self.build_temp,
+                                         macros=macros,
+                                         include_dirs=ext.include_dirs,
+                                         debug=self.debug,
+                                         extra_postargs=extra_args,
+                                         depends=ext.depends)
+
+        # XXX outdated variable, kept here in case third-part code
+        # needs it.
+        self._built_objects = objects[:]
+
+        # Now link the object files together into a "shared object" --
+        # of course, first we have to figure out all the other things
+        # that go into the mix.
+        if ext.extra_objects:
+            objects.extend(ext.extra_objects)
+        extra_args = ext.extra_link_args or []
+
+        # Detect target language, if not provided
+        language = ext.language or self.compiler.detect_language(sources)
+
+        self.compiler.link_shared_object(
+            objects, ext_path,
+            libraries=self.get_libraries(ext),
+            library_dirs=ext.library_dirs,
+            runtime_library_dirs=ext.runtime_library_dirs,
+            extra_postargs=extra_args,
+            export_symbols=self.get_export_symbols(ext),
+            debug=self.debug,
+            build_temp=self.build_temp,
+            target_lang=language)
+
+    def swig_sources(self, sources, extension):
+        """Walk the list of source files in 'sources', looking for SWIG
+        interface (.i) files.  Run SWIG on all that are found, and
+        return a modified 'sources' list with SWIG source files replaced
+        by the generated C (or C++) files.
+        """
+        new_sources = []
+        swig_sources = []
+        swig_targets = {}
+
+        # XXX this drops generated C/C++ files into the source tree, which
+        # is fine for developers who want to distribute the generated
+        # source -- but there should be an option to put SWIG output in
+        # the temp dir.
+
+        if self.swig_cpp:
+            log.warn("--swig-cpp is deprecated - use --swig-opts=-c++")
+
+        if self.swig_cpp or ('-c++' in self.swig_opts) or \
+           ('-c++' in extension.swig_opts):
+            target_ext = '.cpp'
+        else:
+            target_ext = '.c'
+
+        for source in sources:
+            (base, ext) = os.path.splitext(source)
+            if ext == ".i":             # SWIG interface file
+                new_sources.append(base + '_wrap' + target_ext)
+                swig_sources.append(source)
+                swig_targets[source] = new_sources[-1]
+            else:
+                new_sources.append(source)
+
+        if not swig_sources:
+            return new_sources
+
+        swig = self.swig or self.find_swig()
+        swig_cmd = [swig, "-python"]
+        swig_cmd.extend(self.swig_opts)
+        if self.swig_cpp:
+            swig_cmd.append("-c++")
+
+        # Do not override commandline arguments
+        if not self.swig_opts:
+            for o in extension.swig_opts:
+                swig_cmd.append(o)
+
+        for source in swig_sources:
+            target = swig_targets[source]
+            log.info("swigging %s to %s", source, target)
+            self.spawn(swig_cmd + ["-o", target, source])
+
+        return new_sources
+
+    def find_swig(self):
+        """Return the name of the SWIG executable.  On Unix, this is
+        just "swig" -- it should be in the PATH.  Tries a bit harder on
+        Windows.
+        """
+        if os.name == "posix":
+            return "swig"
+        elif os.name == "nt":
+            # Look for SWIG in its standard installation directory on
+            # Windows (or so I presume!).  If we find it there, great;
+            # if not, act like Unix and assume it's in the PATH.
+            for vers in ("1.3", "1.2", "1.1"):
+                fn = os.path.join("c:\\swig%s" % vers, "swig.exe")
+                if os.path.isfile(fn):
+                    return fn
+            else:
+                return "swig.exe"
+        else:
+            raise DistutilsPlatformError(
+                  "I don't know how to find (much less run) SWIG "
+                  "on platform '%s'" % os.name)
+
+    # -- Name generators -----------------------------------------------
+    # (extension names, filenames, whatever)
+    def get_ext_fullpath(self, ext_name):
+        """Returns the path of the filename for a given extension.
+
+        The file is located in `build_lib` or directly in the package
+        (inplace option).
+        """
+        fullname = self.get_ext_fullname(ext_name)
+        modpath = fullname.split('.')
+        filename = self.get_ext_filename(modpath[-1])
+
+        if not self.inplace:
+            # no further work needed
+            # returning :
+            #   build_dir/package/path/filename
+            filename = os.path.join(*modpath[:-1]+[filename])
+            return os.path.join(self.build_lib, filename)
+
+        # the inplace option requires to find the package directory
+        # using the build_py command for that
+        package = '.'.join(modpath[0:-1])
+        build_py = self.get_finalized_command('build_py')
+        package_dir = os.path.abspath(build_py.get_package_dir(package))
+
+        # returning
+        #   package_dir/filename
+        return os.path.join(package_dir, filename)
+
+    def get_ext_fullname(self, ext_name):
+        """Returns the fullname of a given extension name.
+
+        Adds the `package.` prefix"""
+        if self.package is None:
+            return ext_name
+        else:
+            return self.package + '.' + ext_name
+
+    def get_ext_filename(self, ext_name):
+        r"""Convert the name of an extension (eg. "foo.bar") into the name
+        of the file from which it will be loaded (eg. "foo/bar.so", or
+        "foo\bar.pyd").
+        """
+        from distutils.sysconfig import get_config_var
+        ext_path = ext_name.split('.')
+        ext_suffix = get_config_var('EXT_SUFFIX')
+        return os.path.join(*ext_path) + ext_suffix
+
+    def get_export_symbols(self, ext):
+        """Return the list of symbols that a shared extension has to
+        export.  This either uses 'ext.export_symbols' or, if it's not
+        provided, "PyInit_" + module_name.  Only relevant on Windows, where
+        the .pyd file (DLL) must export the module "PyInit_" function.
+        """
+        suffix = '_' + ext.name.split('.')[-1]
+        try:
+            # Unicode module name support as defined in PEP-489
+            # https://www.python.org/dev/peps/pep-0489/#export-hook-name
+            suffix.encode('ascii')
+        except UnicodeEncodeError:
+            suffix = 'U' + suffix.encode('punycode').replace(b'-', b'_').decode('ascii')
+
+        initfunc_name = "PyInit" + suffix
+        if initfunc_name not in ext.export_symbols:
+            ext.export_symbols.append(initfunc_name)
+        return ext.export_symbols
+
+    def get_libraries(self, ext):
+        """Return the list of libraries to link against when building a
+        shared extension.  On most platforms, this is just 'ext.libraries';
+        on Windows, we add the Python library (eg. python20.dll).
+        """
+        # The python library is always needed on Windows.  For MSVC, this
+        # is redundant, since the library is mentioned in a pragma in
+        # pyconfig.h that MSVC groks.  The other Windows compilers all seem
+        # to need it mentioned explicitly, though, so that's what we do.
+        # Append '_d' to the python import library on debug builds.
+        if sys.platform == "win32":
+            from distutils._msvccompiler import MSVCCompiler
+            if not isinstance(self.compiler, MSVCCompiler):
+                template = "python%d%d"
+                if self.debug:
+                    template = template + '_d'
+                pythonlib = (template %
+                       (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
+                # don't extend ext.libraries, it may be shared with other
+                # extensions, it is a reference to the original list
+                return ext.libraries + [pythonlib]
+        else:
+            # On Android only the main executable and LD_PRELOADs are considered
+            # to be RTLD_GLOBAL, all the dependencies of the main executable
+            # remain RTLD_LOCAL and so the shared libraries must be linked with
+            # libpython when python is built with a shared python library (issue
+            # bpo-21536).
+            # On Cygwin (and if required, other POSIX-like platforms based on
+            # Windows like MinGW) it is simply necessary that all symbols in
+            # shared libraries are resolved at link time.
+            from distutils.sysconfig import get_config_var
+            link_libpython = False
+            if get_config_var('Py_ENABLE_SHARED'):
+                # A native build on an Android device or on Cygwin
+                if hasattr(sys, 'getandroidapilevel'):
+                    link_libpython = True
+                elif sys.platform == 'cygwin':
+                    link_libpython = True
+                elif '_PYTHON_HOST_PLATFORM' in os.environ:
+                    # We are cross-compiling for one of the relevant platforms
+                    if get_config_var('ANDROID_API_LEVEL') != 0:
+                        link_libpython = True
+                    elif get_config_var('MACHDEP') == 'cygwin':
+                        link_libpython = True
+
+            if link_libpython:
+                ldversion = get_config_var('LDVERSION')
+                return ext.libraries + ['python' + ldversion]
+
+        return ext.libraries
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_py.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_py.py
new file mode 100644
index 0000000..edc2171
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_py.py
@@ -0,0 +1,416 @@
+"""distutils.command.build_py
+
+Implements the Distutils 'build_py' command."""
+
+import os
+import importlib.util
+import sys
+import glob
+
+from distutils.core import Command
+from distutils.errors import *
+from distutils.util import convert_path, Mixin2to3
+from distutils import log
+
+class build_py (Command):
+
+    description = "\"build\" pure Python modules (copy to build directory)"
+
+    user_options = [
+        ('build-lib=', 'd', "directory to \"build\" (copy) to"),
+        ('compile', 'c', "compile .py to .pyc"),
+        ('no-compile', None, "don't compile .py files [default]"),
+        ('optimize=', 'O',
+         "also compile with optimization: -O1 for \"python -O\", "
+         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
+        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
+        ]
+
+    boolean_options = ['compile', 'force']
+    negative_opt = {'no-compile' : 'compile'}
+
+    def initialize_options(self):
+        self.build_lib = None
+        self.py_modules = None
+        self.package = None
+        self.package_data = None
+        self.package_dir = None
+        self.compile = 0
+        self.optimize = 0
+        self.force = None
+
+    def finalize_options(self):
+        self.set_undefined_options('build',
+                                   ('build_lib', 'build_lib'),
+                                   ('force', 'force'))
+
+        # Get the distribution options that are aliases for build_py
+        # options -- list of packages and list of modules.
+        self.packages = self.distribution.packages
+        self.py_modules = self.distribution.py_modules
+        self.package_data = self.distribution.package_data
+        self.package_dir = {}
+        if self.distribution.package_dir:
+            for name, path in self.distribution.package_dir.items():
+                self.package_dir[name] = convert_path(path)
+        self.data_files = self.get_data_files()
+
+        # Ick, copied straight from install_lib.py (fancy_getopt needs a
+        # type system!  Hell, *everything* needs a type system!!!)
+        if not isinstance(self.optimize, int):
+            try:
+                self.optimize = int(self.optimize)
+                assert 0 <= self.optimize <= 2
+            except (ValueError, AssertionError):
+                raise DistutilsOptionError("optimize must be 0, 1, or 2")
+
+    def run(self):
+        # XXX copy_file by default preserves atime and mtime.  IMHO this is
+        # the right thing to do, but perhaps it should be an option -- in
+        # particular, a site administrator might want installed files to
+        # reflect the time of installation rather than the last
+        # modification time before the installed release.
+
+        # XXX copy_file by default preserves mode, which appears to be the
+        # wrong thing to do: if a file is read-only in the working
+        # directory, we want it to be installed read/write so that the next
+        # installation of the same module distribution can overwrite it
+        # without problems.  (This might be a Unix-specific issue.)  Thus
+        # we turn off 'preserve_mode' when copying to the build directory,
+        # since the build directory is supposed to be exactly what the
+        # installation will look like (ie. we preserve mode when
+        # installing).
+
+        # Two options control which modules will be installed: 'packages'
+        # and 'py_modules'.  The former lets us work with whole packages, not
+        # specifying individual modules at all; the latter is for
+        # specifying modules one-at-a-time.
+
+        if self.py_modules:
+            self.build_modules()
+        if self.packages:
+            self.build_packages()
+            self.build_package_data()
+
+        self.byte_compile(self.get_outputs(include_bytecode=0))
+
+    def get_data_files(self):
+        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
+        data = []
+        if not self.packages:
+            return data
+        for package in self.packages:
+            # Locate package source directory
+            src_dir = self.get_package_dir(package)
+
+            # Compute package build directory
+            build_dir = os.path.join(*([self.build_lib] + package.split('.')))
+
+            # Length of path to strip from found files
+            plen = 0
+            if src_dir:
+                plen = len(src_dir)+1
+
+            # Strip directory from globbed filenames
+            filenames = [
+                file[plen:] for file in self.find_data_files(package, src_dir)
+                ]
+            data.append((package, src_dir, build_dir, filenames))
+        return data
+
+    def find_data_files(self, package, src_dir):
+        """Return filenames for package's data files in 'src_dir'"""
+        globs = (self.package_data.get('', [])
+                 + self.package_data.get(package, []))
+        files = []
+        for pattern in globs:
+            # Each pattern has to be converted to a platform-specific path
+            filelist = glob.glob(os.path.join(glob.escape(src_dir), convert_path(pattern)))
+            # Files that match more than one pattern are only added once
+            files.extend([fn for fn in filelist if fn not in files
+                and os.path.isfile(fn)])
+        return files
+
+    def build_package_data(self):
+        """Copy data files into build directory"""
+        lastdir = None
+        for package, src_dir, build_dir, filenames in self.data_files:
+            for filename in filenames:
+                target = os.path.join(build_dir, filename)
+                self.mkpath(os.path.dirname(target))
+                self.copy_file(os.path.join(src_dir, filename), target,
+                               preserve_mode=False)
+
+    def get_package_dir(self, package):
+        """Return the directory, relative to the top of the source
+           distribution, where package 'package' should be found
+           (at least according to the 'package_dir' option, if any)."""
+        path = package.split('.')
+
+        if not self.package_dir:
+            if path:
+                return os.path.join(*path)
+            else:
+                return ''
+        else:
+            tail = []
+            while path:
+                try:
+                    pdir = self.package_dir['.'.join(path)]
+                except KeyError:
+                    tail.insert(0, path[-1])
+                    del path[-1]
+                else:
+                    tail.insert(0, pdir)
+                    return os.path.join(*tail)
+            else:
+                # Oops, got all the way through 'path' without finding a
+                # match in package_dir.  If package_dir defines a directory
+                # for the root (nameless) package, then fallback on it;
+                # otherwise, we might as well have not consulted
+                # package_dir at all, as we just use the directory implied
+                # by 'tail' (which should be the same as the original value
+                # of 'path' at this point).
+                pdir = self.package_dir.get('')
+                if pdir is not None:
+                    tail.insert(0, pdir)
+
+                if tail:
+                    return os.path.join(*tail)
+                else:
+                    return ''
+
+    def check_package(self, package, package_dir):
+        # Empty dir name means current directory, which we can probably
+        # assume exists.  Also, os.path.exists and isdir don't know about
+        # my "empty string means current dir" convention, so we have to
+        # circumvent them.
+        if package_dir != "":
+            if not os.path.exists(package_dir):
+                raise DistutilsFileError(
+                      "package directory '%s' does not exist" % package_dir)
+            if not os.path.isdir(package_dir):
+                raise DistutilsFileError(
+                       "supposed package directory '%s' exists, "
+                       "but is not a directory" % package_dir)
+
+        # Require __init__.py for all but the "root package"
+        if package:
+            init_py = os.path.join(package_dir, "__init__.py")
+            if os.path.isfile(init_py):
+                return init_py
+            else:
+                log.warn(("package init file '%s' not found " +
+                          "(or not a regular file)"), init_py)
+
+        # Either not in a package at all (__init__.py not expected), or
+        # __init__.py doesn't exist -- so don't return the filename.
+        return None
+
+    def check_module(self, module, module_file):
+        if not os.path.isfile(module_file):
+            log.warn("file %s (for module %s) not found", module_file, module)
+            return False
+        else:
+            return True
+
+    def find_package_modules(self, package, package_dir):
+        self.check_package(package, package_dir)
+        module_files = glob.glob(os.path.join(glob.escape(package_dir), "*.py"))
+        modules = []
+        setup_script = os.path.abspath(self.distribution.script_name)
+
+        for f in module_files:
+            abs_f = os.path.abspath(f)
+            if abs_f != setup_script:
+                module = os.path.splitext(os.path.basename(f))[0]
+                modules.append((package, module, f))
+            else:
+                self.debug_print("excluding %s" % setup_script)
+        return modules
+
+    def find_modules(self):
+        """Finds individually-specified Python modules, ie. those listed by
+        module name in 'self.py_modules'.  Returns a list of tuples (package,
+        module_base, filename): 'package' is a tuple of the path through
+        package-space to the module; 'module_base' is the bare (no
+        packages, no dots) module name, and 'filename' is the path to the
+        ".py" file (relative to the distribution root) that implements the
+        module.
+        """
+        # Map package names to tuples of useful info about the package:
+        #    (package_dir, checked)
+        # package_dir - the directory where we'll find source files for
+        #   this package
+        # checked - true if we have checked that the package directory
+        #   is valid (exists, contains __init__.py, ... ?)
+        packages = {}
+
+        # List of (package, module, filename) tuples to return
+        modules = []
+
+        # We treat modules-in-packages almost the same as toplevel modules,
+        # just the "package" for a toplevel is empty (either an empty
+        # string or empty list, depending on context).  Differences:
+        #   - don't check for __init__.py in directory for empty package
+        for module in self.py_modules:
+            path = module.split('.')
+            package = '.'.join(path[0:-1])
+            module_base = path[-1]
+
+            try:
+                (package_dir, checked) = packages[package]
+            except KeyError:
+                package_dir = self.get_package_dir(package)
+                checked = 0
+
+            if not checked:
+                init_py = self.check_package(package, package_dir)
+                packages[package] = (package_dir, 1)
+                if init_py:
+                    modules.append((package, "__init__", init_py))
+
+            # XXX perhaps we should also check for just .pyc files
+            # (so greedy closed-source bastards can distribute Python
+            # modules too)
+            module_file = os.path.join(package_dir, module_base + ".py")
+            if not self.check_module(module, module_file):
+                continue
+
+            modules.append((package, module_base, module_file))
+
+        return modules
+
+    def find_all_modules(self):
+        """Compute the list of all modules that will be built, whether
+        they are specified one-module-at-a-time ('self.py_modules') or
+        by whole packages ('self.packages').  Return a list of tuples
+        (package, module, module_file), just like 'find_modules()' and
+        'find_package_modules()' do."""
+        modules = []
+        if self.py_modules:
+            modules.extend(self.find_modules())
+        if self.packages:
+            for package in self.packages:
+                package_dir = self.get_package_dir(package)
+                m = self.find_package_modules(package, package_dir)
+                modules.extend(m)
+        return modules
+
+    def get_source_files(self):
+        return [module[-1] for module in self.find_all_modules()]
+
+    def get_module_outfile(self, build_dir, package, module):
+        outfile_path = [build_dir] + list(package) + [module + ".py"]
+        return os.path.join(*outfile_path)
+
+    def get_outputs(self, include_bytecode=1):
+        modules = self.find_all_modules()
+        outputs = []
+        for (package, module, module_file) in modules:
+            package = package.split('.')
+            filename = self.get_module_outfile(self.build_lib, package, module)
+            outputs.append(filename)
+            if include_bytecode:
+                if self.compile:
+                    outputs.append(importlib.util.cache_from_source(
+                        filename, optimization=''))
+                if self.optimize > 0:
+                    outputs.append(importlib.util.cache_from_source(
+                        filename, optimization=self.optimize))
+
+        outputs += [
+            os.path.join(build_dir, filename)
+            for package, src_dir, build_dir, filenames in self.data_files
+            for filename in filenames
+            ]
+
+        return outputs
+
+    def build_module(self, module, module_file, package):
+        if isinstance(package, str):
+            package = package.split('.')
+        elif not isinstance(package, (list, tuple)):
+            raise TypeError(
+                  "'package' must be a string (dot-separated), list, or tuple")
+
+        # Now put the module source file into the "build" area -- this is
+        # easy, we just copy it somewhere under self.build_lib (the build
+        # directory for Python source).
+        outfile = self.get_module_outfile(self.build_lib, package, module)
+        dir = os.path.dirname(outfile)
+        self.mkpath(dir)
+        return self.copy_file(module_file, outfile, preserve_mode=0)
+
+    def build_modules(self):
+        modules = self.find_modules()
+        for (package, module, module_file) in modules:
+            # Now "build" the module -- ie. copy the source file to
+            # self.build_lib (the build directory for Python source).
+            # (Actually, it gets copied to the directory for this package
+            # under self.build_lib.)
+            self.build_module(module, module_file, package)
+
+    def build_packages(self):
+        for package in self.packages:
+            # Get list of (package, module, module_file) tuples based on
+            # scanning the package directory.  'package' is only included
+            # in the tuple so that 'find_modules()' and
+            # 'find_package_tuples()' have a consistent interface; it's
+            # ignored here (apart from a sanity check).  Also, 'module' is
+            # the *unqualified* module name (ie. no dots, no package -- we
+            # already know its package!), and 'module_file' is the path to
+            # the .py file, relative to the current directory
+            # (ie. including 'package_dir').
+            package_dir = self.get_package_dir(package)
+            modules = self.find_package_modules(package, package_dir)
+
+            # Now loop over the modules we found, "building" each one (just
+            # copy it to self.build_lib).
+            for (package_, module, module_file) in modules:
+                assert package == package_
+                self.build_module(module, module_file, package)
+
+    def byte_compile(self, files):
+        if sys.dont_write_bytecode:
+            self.warn('byte-compiling is disabled, skipping.')
+            return
+
+        from distutils.util import byte_compile
+        prefix = self.build_lib
+        if prefix[-1] != os.sep:
+            prefix = prefix + os.sep
+
+        # XXX this code is essentially the same as the 'byte_compile()
+        # method of the "install_lib" command, except for the determination
+        # of the 'prefix' string.  Hmmm.
+        if self.compile:
+            byte_compile(files, optimize=0,
+                         force=self.force, prefix=prefix, dry_run=self.dry_run)
+        if self.optimize > 0:
+            byte_compile(files, optimize=self.optimize,
+                         force=self.force, prefix=prefix, dry_run=self.dry_run)
+
+class build_py_2to3(build_py, Mixin2to3):
+    def run(self):
+        self.updated_files = []
+
+        # Base class code
+        if self.py_modules:
+            self.build_modules()
+        if self.packages:
+            self.build_packages()
+            self.build_package_data()
+
+        # 2to3
+        self.run_2to3(self.updated_files)
+
+        # Remaining base class code
+        self.byte_compile(self.get_outputs(include_bytecode=0))
+
+    def build_module(self, module, module_file, package):
+        res = build_py.build_module(self, module, module_file, package)
+        if res[1]:
+            # file was copied
+            self.updated_files.append(res[0])
+        return res
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_scripts.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_scripts.py
new file mode 100644
index 0000000..ccc70e6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/build_scripts.py
@@ -0,0 +1,160 @@
+"""distutils.command.build_scripts
+
+Implements the Distutils 'build_scripts' command."""
+
+import os, re
+from stat import ST_MODE
+from distutils import sysconfig
+from distutils.core import Command
+from distutils.dep_util import newer
+from distutils.util import convert_path, Mixin2to3
+from distutils import log
+import tokenize
+
+# check if Python is called on the first line with this expression
+first_line_re = re.compile(b'^#!.*python[0-9.]*([ \t].*)?$')
+
+class build_scripts(Command):
+
+    description = "\"build\" scripts (copy and fixup #! line)"
+
+    user_options = [
+        ('build-dir=', 'd', "directory to \"build\" (copy) to"),
+        ('force', 'f', "forcibly build everything (ignore file timestamps"),
+        ('executable=', 'e', "specify final destination interpreter path"),
+        ]
+
+    boolean_options = ['force']
+
+
+    def initialize_options(self):
+        self.build_dir = None
+        self.scripts = None
+        self.force = None
+        self.executable = None
+        self.outfiles = None
+
+    def finalize_options(self):
+        self.set_undefined_options('build',
+                                   ('build_scripts', 'build_dir'),
+                                   ('force', 'force'),
+                                   ('executable', 'executable'))
+        self.scripts = self.distribution.scripts
+
+    def get_source_files(self):
+        return self.scripts
+
+    def run(self):
+        if not self.scripts:
+            return
+        self.copy_scripts()
+
+
+    def copy_scripts(self):
+        r"""Copy each script listed in 'self.scripts'; if it's marked as a
+        Python script in the Unix way (first line matches 'first_line_re',
+        ie. starts with "\#!" and contains "python"), then adjust the first
+        line to refer to the current Python interpreter as we copy.
+        """
+        self.mkpath(self.build_dir)
+        outfiles = []
+        updated_files = []
+        for script in self.scripts:
+            adjust = False
+            script = convert_path(script)
+            outfile = os.path.join(self.build_dir, os.path.basename(script))
+            outfiles.append(outfile)
+
+            if not self.force and not newer(script, outfile):
+                log.debug("not copying %s (up-to-date)", script)
+                continue
+
+            # Always open the file, but ignore failures in dry-run mode --
+            # that way, we'll get accurate feedback if we can read the
+            # script.
+            try:
+                f = open(script, "rb")
+            except OSError:
+                if not self.dry_run:
+                    raise
+                f = None
+            else:
+                encoding, lines = tokenize.detect_encoding(f.readline)
+                f.seek(0)
+                first_line = f.readline()
+                if not first_line:
+                    self.warn("%s is an empty file (skipping)" % script)
+                    continue
+
+                match = first_line_re.match(first_line)
+                if match:
+                    adjust = True
+                    post_interp = match.group(1) or b''
+
+            if adjust:
+                log.info("copying and adjusting %s -> %s", script,
+                         self.build_dir)
+                updated_files.append(outfile)
+                if not self.dry_run:
+                    if not sysconfig.python_build:
+                        executable = self.executable
+                    else:
+                        executable = os.path.join(
+                            sysconfig.get_config_var("BINDIR"),
+                           "python%s%s" % (sysconfig.get_config_var("VERSION"),
+                                           sysconfig.get_config_var("EXE")))
+                    executable = os.fsencode(executable)
+                    shebang = b"#!" + executable + post_interp + b"\n"
+                    # Python parser starts to read a script using UTF-8 until
+                    # it gets a #coding:xxx cookie. The shebang has to be the
+                    # first line of a file, the #coding:xxx cookie cannot be
+                    # written before. So the shebang has to be decodable from
+                    # UTF-8.
+                    try:
+                        shebang.decode('utf-8')
+                    except UnicodeDecodeError:
+                        raise ValueError(
+                            "The shebang ({!r}) is not decodable "
+                            "from utf-8".format(shebang))
+                    # If the script is encoded to a custom encoding (use a
+                    # #coding:xxx cookie), the shebang has to be decodable from
+                    # the script encoding too.
+                    try:
+                        shebang.decode(encoding)
+                    except UnicodeDecodeError:
+                        raise ValueError(
+                            "The shebang ({!r}) is not decodable "
+                            "from the script encoding ({})"
+                            .format(shebang, encoding))
+                    with open(outfile, "wb") as outf:
+                        outf.write(shebang)
+                        outf.writelines(f.readlines())
+                if f:
+                    f.close()
+            else:
+                if f:
+                    f.close()
+                updated_files.append(outfile)
+                self.copy_file(script, outfile)
+
+        if os.name == 'posix':
+            for file in outfiles:
+                if self.dry_run:
+                    log.info("changing mode of %s", file)
+                else:
+                    oldmode = os.stat(file)[ST_MODE] & 0o7777
+                    newmode = (oldmode | 0o555) & 0o7777
+                    if newmode != oldmode:
+                        log.info("changing mode of %s from %o to %o",
+                                 file, oldmode, newmode)
+                        os.chmod(file, newmode)
+        # XXX should we modify self.outfiles?
+        return outfiles, updated_files
+
+class build_scripts_2to3(build_scripts, Mixin2to3):
+
+    def copy_scripts(self):
+        outfiles, updated_files = build_scripts.copy_scripts(self)
+        if not self.dry_run:
+            self.run_2to3(updated_files)
+        return outfiles, updated_files
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/check.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/check.py
new file mode 100644
index 0000000..ada2500
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/check.py
@@ -0,0 +1,148 @@
+"""distutils.command.check
+
+Implements the Distutils 'check' command.
+"""
+from distutils.core import Command
+from distutils.errors import DistutilsSetupError
+
+try:
+    # docutils is installed
+    from docutils.utils import Reporter
+    from docutils.parsers.rst import Parser
+    from docutils import frontend
+    from docutils import nodes
+
+    class SilentReporter(Reporter):
+
+        def __init__(self, source, report_level, halt_level, stream=None,
+                     debug=0, encoding='ascii', error_handler='replace'):
+            self.messages = []
+            Reporter.__init__(self, source, report_level, halt_level, stream,
+                              debug, encoding, error_handler)
+
+        def system_message(self, level, message, *children, **kwargs):
+            self.messages.append((level, message, children, kwargs))
+            return nodes.system_message(message, level=level,
+                                        type=self.levels[level],
+                                        *children, **kwargs)
+
+    HAS_DOCUTILS = True
+except Exception:
+    # Catch all exceptions because exceptions besides ImportError probably
+    # indicate that docutils is not ported to Py3k.
+    HAS_DOCUTILS = False
+
+class check(Command):
+    """This command checks the meta-data of the package.
+    """
+    description = ("perform some checks on the package")
+    user_options = [('metadata', 'm', 'Verify meta-data'),
+                    ('restructuredtext', 'r',
+                     ('Checks if long string meta-data syntax '
+                      'are reStructuredText-compliant')),
+                    ('strict', 's',
+                     'Will exit with an error if a check fails')]
+
+    boolean_options = ['metadata', 'restructuredtext', 'strict']
+
+    def initialize_options(self):
+        """Sets default values for options."""
+        self.restructuredtext = 0
+        self.metadata = 1
+        self.strict = 0
+        self._warnings = 0
+
+    def finalize_options(self):
+        pass
+
+    def warn(self, msg):
+        """Counts the number of warnings that occurs."""
+        self._warnings += 1
+        return Command.warn(self, msg)
+
+    def run(self):
+        """Runs the command."""
+        # perform the various tests
+        if self.metadata:
+            self.check_metadata()
+        if self.restructuredtext:
+            if HAS_DOCUTILS:
+                self.check_restructuredtext()
+            elif self.strict:
+                raise DistutilsSetupError('The docutils package is needed.')
+
+        # let's raise an error in strict mode, if we have at least
+        # one warning
+        if self.strict and self._warnings > 0:
+            raise DistutilsSetupError('Please correct your package.')
+
+    def check_metadata(self):
+        """Ensures that all required elements of meta-data are supplied.
+
+        Required fields:
+            name, version, URL
+
+        Recommended fields:
+            (author and author_email) or (maintainer and maintainer_email))
+
+        Warns if any are missing.
+        """
+        metadata = self.distribution.metadata
+
+        missing = []
+        for attr in ('name', 'version', 'url'):
+            if not (hasattr(metadata, attr) and getattr(metadata, attr)):
+                missing.append(attr)
+
+        if missing:
+            self.warn("missing required meta-data: %s"  % ', '.join(missing))
+        if metadata.author:
+            if not metadata.author_email:
+                self.warn("missing meta-data: if 'author' supplied, " +
+                          "'author_email' should be supplied too")
+        elif metadata.maintainer:
+            if not metadata.maintainer_email:
+                self.warn("missing meta-data: if 'maintainer' supplied, " +
+                          "'maintainer_email' should be supplied too")
+        else:
+            self.warn("missing meta-data: either (author and author_email) " +
+                      "or (maintainer and maintainer_email) " +
+                      "should be supplied")
+
+    def check_restructuredtext(self):
+        """Checks if the long string fields are reST-compliant."""
+        data = self.distribution.get_long_description()
+        for warning in self._check_rst_data(data):
+            line = warning[-1].get('line')
+            if line is None:
+                warning = warning[1]
+            else:
+                warning = '%s (line %s)' % (warning[1], line)
+            self.warn(warning)
+
+    def _check_rst_data(self, data):
+        """Returns warnings when the provided data doesn't compile."""
+        # the include and csv_table directives need this to be a path
+        source_path = self.distribution.script_name or 'setup.py'
+        parser = Parser()
+        settings = frontend.OptionParser(components=(Parser,)).get_default_values()
+        settings.tab_width = 4
+        settings.pep_references = None
+        settings.rfc_references = None
+        reporter = SilentReporter(source_path,
+                          settings.report_level,
+                          settings.halt_level,
+                          stream=settings.warning_stream,
+                          debug=settings.debug,
+                          encoding=settings.error_encoding,
+                          error_handler=settings.error_encoding_error_handler)
+
+        document = nodes.document(settings, reporter, source=source_path)
+        document.note_source(source_path, -1)
+        try:
+            parser.parse(data, document)
+        except AttributeError as e:
+            reporter.messages.append(
+                (-1, 'Could not finish the parsing: %s.' % e, '', {}))
+
+        return reporter.messages
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/clean.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/clean.py
new file mode 100644
index 0000000..0cb2701
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/clean.py
@@ -0,0 +1,76 @@
+"""distutils.command.clean
+
+Implements the Distutils 'clean' command."""
+
+# contributed by Bastian Kleineidam <calvin@cs.uni-sb.de>, added 2000-03-18
+
+import os
+from distutils.core import Command
+from distutils.dir_util import remove_tree
+from distutils import log
+
+class clean(Command):
+
+    description = "clean up temporary files from 'build' command"
+    user_options = [
+        ('build-base=', 'b',
+         "base build directory (default: 'build.build-base')"),
+        ('build-lib=', None,
+         "build directory for all modules (default: 'build.build-lib')"),
+        ('build-temp=', 't',
+         "temporary build directory (default: 'build.build-temp')"),
+        ('build-scripts=', None,
+         "build directory for scripts (default: 'build.build-scripts')"),
+        ('bdist-base=', None,
+         "temporary directory for built distributions"),
+        ('all', 'a',
+         "remove all build output, not just temporary by-products")
+    ]
+
+    boolean_options = ['all']
+
+    def initialize_options(self):
+        self.build_base = None
+        self.build_lib = None
+        self.build_temp = None
+        self.build_scripts = None
+        self.bdist_base = None
+        self.all = None
+
+    def finalize_options(self):
+        self.set_undefined_options('build',
+                                   ('build_base', 'build_base'),
+                                   ('build_lib', 'build_lib'),
+                                   ('build_scripts', 'build_scripts'),
+                                   ('build_temp', 'build_temp'))
+        self.set_undefined_options('bdist',
+                                   ('bdist_base', 'bdist_base'))
+
+    def run(self):
+        # remove the build/temp.<plat> directory (unless it's already
+        # gone)
+        if os.path.exists(self.build_temp):
+            remove_tree(self.build_temp, dry_run=self.dry_run)
+        else:
+            log.debug("'%s' does not exist -- can't clean it",
+                      self.build_temp)
+
+        if self.all:
+            # remove build directories
+            for directory in (self.build_lib,
+                              self.bdist_base,
+                              self.build_scripts):
+                if os.path.exists(directory):
+                    remove_tree(directory, dry_run=self.dry_run)
+                else:
+                    log.warn("'%s' does not exist -- can't clean it",
+                             directory)
+
+        # just for the heck of it, try to remove the base build directory:
+        # we might have emptied it right now, but if not we don't care
+        if not self.dry_run:
+            try:
+                os.rmdir(self.build_base)
+                log.info("removing '%s'", self.build_base)
+            except OSError:
+                pass
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/config.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/config.py
new file mode 100644
index 0000000..aeda408
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/config.py
@@ -0,0 +1,344 @@
+"""distutils.command.config
+
+Implements the Distutils 'config' command, a (mostly) empty command class
+that exists mainly to be sub-classed by specific module distributions and
+applications.  The idea is that while every "config" command is different,
+at least they're all named the same, and users always see "config" in the
+list of standard commands.  Also, this is a good place to put common
+configure-like tasks: "try to compile this C code", or "figure out where
+this header file lives".
+"""
+
+import os, re
+
+from distutils.core import Command
+from distutils.errors import DistutilsExecError
+from distutils.sysconfig import customize_compiler
+from distutils import log
+
+LANG_EXT = {"c": ".c", "c++": ".cxx"}
+
+class config(Command):
+
+    description = "prepare to build"
+
+    user_options = [
+        ('compiler=', None,
+         "specify the compiler type"),
+        ('cc=', None,
+         "specify the compiler executable"),
+        ('include-dirs=', 'I',
+         "list of directories to search for header files"),
+        ('define=', 'D',
+         "C preprocessor macros to define"),
+        ('undef=', 'U',
+         "C preprocessor macros to undefine"),
+        ('libraries=', 'l',
+         "external C libraries to link with"),
+        ('library-dirs=', 'L',
+         "directories to search for external C libraries"),
+
+        ('noisy', None,
+         "show every action (compile, link, run, ...) taken"),
+        ('dump-source', None,
+         "dump generated source files before attempting to compile them"),
+        ]
+
+
+    # The three standard command methods: since the "config" command
+    # does nothing by default, these are empty.
+
+    def initialize_options(self):
+        self.compiler = None
+        self.cc = None
+        self.include_dirs = None
+        self.libraries = None
+        self.library_dirs = None
+
+        # maximal output for now
+        self.noisy = 1
+        self.dump_source = 1
+
+        # list of temporary files generated along-the-way that we have
+        # to clean at some point
+        self.temp_files = []
+
+    def finalize_options(self):
+        if self.include_dirs is None:
+            self.include_dirs = self.distribution.include_dirs or []
+        elif isinstance(self.include_dirs, str):
+            self.include_dirs = self.include_dirs.split(os.pathsep)
+
+        if self.libraries is None:
+            self.libraries = []
+        elif isinstance(self.libraries, str):
+            self.libraries = [self.libraries]
+
+        if self.library_dirs is None:
+            self.library_dirs = []
+        elif isinstance(self.library_dirs, str):
+            self.library_dirs = self.library_dirs.split(os.pathsep)
+
+    def run(self):
+        pass
+
+    # Utility methods for actual "config" commands.  The interfaces are
+    # loosely based on Autoconf macros of similar names.  Sub-classes
+    # may use these freely.
+
+    def _check_compiler(self):
+        """Check that 'self.compiler' really is a CCompiler object;
+        if not, make it one.
+        """
+        # We do this late, and only on-demand, because this is an expensive
+        # import.
+        from distutils.ccompiler import CCompiler, new_compiler
+        if not isinstance(self.compiler, CCompiler):
+            self.compiler = new_compiler(compiler=self.compiler,
+                                         dry_run=self.dry_run, force=1)
+            customize_compiler(self.compiler)
+            if self.include_dirs:
+                self.compiler.set_include_dirs(self.include_dirs)
+            if self.libraries:
+                self.compiler.set_libraries(self.libraries)
+            if self.library_dirs:
+                self.compiler.set_library_dirs(self.library_dirs)
+
+    def _gen_temp_sourcefile(self, body, headers, lang):
+        filename = "_configtest" + LANG_EXT[lang]
+        with open(filename, "w") as file:
+            if headers:
+                for header in headers:
+                    file.write("#include <%s>\n" % header)
+                file.write("\n")
+            file.write(body)
+            if body[-1] != "\n":
+                file.write("\n")
+        return filename
+
+    def _preprocess(self, body, headers, include_dirs, lang):
+        src = self._gen_temp_sourcefile(body, headers, lang)
+        out = "_configtest.i"
+        self.temp_files.extend([src, out])
+        self.compiler.preprocess(src, out, include_dirs=include_dirs)
+        return (src, out)
+
+    def _compile(self, body, headers, include_dirs, lang):
+        src = self._gen_temp_sourcefile(body, headers, lang)
+        if self.dump_source:
+            dump_file(src, "compiling '%s':" % src)
+        (obj,) = self.compiler.object_filenames([src])
+        self.temp_files.extend([src, obj])
+        self.compiler.compile([src], include_dirs=include_dirs)
+        return (src, obj)
+
+    def _link(self, body, headers, include_dirs, libraries, library_dirs,
+              lang):
+        (src, obj) = self._compile(body, headers, include_dirs, lang)
+        prog = os.path.splitext(os.path.basename(src))[0]
+        self.compiler.link_executable([obj], prog,
+                                      libraries=libraries,
+                                      library_dirs=library_dirs,
+                                      target_lang=lang)
+
+        if self.compiler.exe_extension is not None:
+            prog = prog + self.compiler.exe_extension
+        self.temp_files.append(prog)
+
+        return (src, obj, prog)
+
+    def _clean(self, *filenames):
+        if not filenames:
+            filenames = self.temp_files
+            self.temp_files = []
+        log.info("removing: %s", ' '.join(filenames))
+        for filename in filenames:
+            try:
+                os.remove(filename)
+            except OSError:
+                pass
+
+
+    # XXX these ignore the dry-run flag: what to do, what to do? even if
+    # you want a dry-run build, you still need some sort of configuration
+    # info.  My inclination is to make it up to the real config command to
+    # consult 'dry_run', and assume a default (minimal) configuration if
+    # true.  The problem with trying to do it here is that you'd have to
+    # return either true or false from all the 'try' methods, neither of
+    # which is correct.
+
+    # XXX need access to the header search path and maybe default macros.
+
+    def try_cpp(self, body=None, headers=None, include_dirs=None, lang="c"):
+        """Construct a source file from 'body' (a string containing lines
+        of C/C++ code) and 'headers' (a list of header files to include)
+        and run it through the preprocessor.  Return true if the
+        preprocessor succeeded, false if there were any errors.
+        ('body' probably isn't of much use, but what the heck.)
+        """
+        from distutils.ccompiler import CompileError
+        self._check_compiler()
+        ok = True
+        try:
+            self._preprocess(body, headers, include_dirs, lang)
+        except CompileError:
+            ok = False
+
+        self._clean()
+        return ok
+
+    def search_cpp(self, pattern, body=None, headers=None, include_dirs=None,
+                   lang="c"):
+        """Construct a source file (just like 'try_cpp()'), run it through
+        the preprocessor, and return true if any line of the output matches
+        'pattern'.  'pattern' should either be a compiled regex object or a
+        string containing a regex.  If both 'body' and 'headers' are None,
+        preprocesses an empty file -- which can be useful to determine the
+        symbols the preprocessor and compiler set by default.
+        """
+        self._check_compiler()
+        src, out = self._preprocess(body, headers, include_dirs, lang)
+
+        if isinstance(pattern, str):
+            pattern = re.compile(pattern)
+
+        with open(out) as file:
+            match = False
+            while True:
+                line = file.readline()
+                if line == '':
+                    break
+                if pattern.search(line):
+                    match = True
+                    break
+
+        self._clean()
+        return match
+
+    def try_compile(self, body, headers=None, include_dirs=None, lang="c"):
+        """Try to compile a source file built from 'body' and 'headers'.
+        Return true on success, false otherwise.
+        """
+        from distutils.ccompiler import CompileError
+        self._check_compiler()
+        try:
+            self._compile(body, headers, include_dirs, lang)
+            ok = True
+        except CompileError:
+            ok = False
+
+        log.info(ok and "success!" or "failure.")
+        self._clean()
+        return ok
+
+    def try_link(self, body, headers=None, include_dirs=None, libraries=None,
+                 library_dirs=None, lang="c"):
+        """Try to compile and link a source file, built from 'body' and
+        'headers', to executable form.  Return true on success, false
+        otherwise.
+        """
+        from distutils.ccompiler import CompileError, LinkError
+        self._check_compiler()
+        try:
+            self._link(body, headers, include_dirs,
+                       libraries, library_dirs, lang)
+            ok = True
+        except (CompileError, LinkError):
+            ok = False
+
+        log.info(ok and "success!" or "failure.")
+        self._clean()
+        return ok
+
+    def try_run(self, body, headers=None, include_dirs=None, libraries=None,
+                library_dirs=None, lang="c"):
+        """Try to compile, link to an executable, and run a program
+        built from 'body' and 'headers'.  Return true on success, false
+        otherwise.
+        """
+        from distutils.ccompiler import CompileError, LinkError
+        self._check_compiler()
+        try:
+            src, obj, exe = self._link(body, headers, include_dirs,
+                                       libraries, library_dirs, lang)
+            self.spawn([exe])
+            ok = True
+        except (CompileError, LinkError, DistutilsExecError):
+            ok = False
+
+        log.info(ok and "success!" or "failure.")
+        self._clean()
+        return ok
+
+
+    # -- High-level methods --------------------------------------------
+    # (these are the ones that are actually likely to be useful
+    # when implementing a real-world config command!)
+
+    def check_func(self, func, headers=None, include_dirs=None,
+                   libraries=None, library_dirs=None, decl=0, call=0):
+        """Determine if function 'func' is available by constructing a
+        source file that refers to 'func', and compiles and links it.
+        If everything succeeds, returns true; otherwise returns false.
+
+        The constructed source file starts out by including the header
+        files listed in 'headers'.  If 'decl' is true, it then declares
+        'func' (as "int func()"); you probably shouldn't supply 'headers'
+        and set 'decl' true in the same call, or you might get errors about
+        a conflicting declarations for 'func'.  Finally, the constructed
+        'main()' function either references 'func' or (if 'call' is true)
+        calls it.  'libraries' and 'library_dirs' are used when
+        linking.
+        """
+        self._check_compiler()
+        body = []
+        if decl:
+            body.append("int %s ();" % func)
+        body.append("int main () {")
+        if call:
+            body.append("  %s();" % func)
+        else:
+            body.append("  %s;" % func)
+        body.append("}")
+        body = "\n".join(body) + "\n"
+
+        return self.try_link(body, headers, include_dirs,
+                             libraries, library_dirs)
+
+    def check_lib(self, library, library_dirs=None, headers=None,
+                  include_dirs=None, other_libraries=[]):
+        """Determine if 'library' is available to be linked against,
+        without actually checking that any particular symbols are provided
+        by it.  'headers' will be used in constructing the source file to
+        be compiled, but the only effect of this is to check if all the
+        header files listed are available.  Any libraries listed in
+        'other_libraries' will be included in the link, in case 'library'
+        has symbols that depend on other libraries.
+        """
+        self._check_compiler()
+        return self.try_link("int main (void) { }", headers, include_dirs,
+                             [library] + other_libraries, library_dirs)
+
+    def check_header(self, header, include_dirs=None, library_dirs=None,
+                     lang="c"):
+        """Determine if the system header file named by 'header_file'
+        exists and can be found by the preprocessor; return true if so,
+        false otherwise.
+        """
+        return self.try_cpp(body="/* No body */", headers=[header],
+                            include_dirs=include_dirs)
+
+def dump_file(filename, head=None):
+    """Dumps a file content into log.info.
+
+    If head is not None, will be dumped before the file content.
+    """
+    if head is None:
+        log.info('%s', filename)
+    else:
+        log.info(head)
+    file = open(filename)
+    try:
+        log.info(file.read())
+    finally:
+        file.close()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install.py
new file mode 100644
index 0000000..13feeb8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install.py
@@ -0,0 +1,677 @@
+"""distutils.command.install
+
+Implements the Distutils 'install' command."""
+
+import sys
+import os
+
+from distutils import log
+from distutils.core import Command
+from distutils.debug import DEBUG
+from distutils.sysconfig import get_config_vars
+from distutils.errors import DistutilsPlatformError
+from distutils.file_util import write_file
+from distutils.util import convert_path, subst_vars, change_root
+from distutils.util import get_platform
+from distutils.errors import DistutilsOptionError
+
+from site import USER_BASE
+from site import USER_SITE
+HAS_USER_SITE = True
+
+WINDOWS_SCHEME = {
+    'purelib': '$base/Lib/site-packages',
+    'platlib': '$base/Lib/site-packages',
+    'headers': '$base/Include/$dist_name',
+    'scripts': '$base/Scripts',
+    'data'   : '$base',
+}
+
+INSTALL_SCHEMES = {
+    'unix_prefix': {
+        'purelib': '$base/lib/python$py_version_short/site-packages',
+        'platlib': '$platbase/$platlibdir/python$py_version_short/site-packages',
+        'headers': '$base/include/python$py_version_short$abiflags/$dist_name',
+        'scripts': '$base/bin',
+        'data'   : '$base',
+        },
+    'unix_home': {
+        'purelib': '$base/lib/python',
+        'platlib': '$base/$platlibdir/python',
+        'headers': '$base/include/python/$dist_name',
+        'scripts': '$base/bin',
+        'data'   : '$base',
+        },
+    'nt': WINDOWS_SCHEME,
+    'pypy': {
+        'purelib': '$base/site-packages',
+        'platlib': '$base/site-packages',
+        'headers': '$base/include/$dist_name',
+        'scripts': '$base/bin',
+        'data'   : '$base',
+        },
+    'pypy_nt': {
+        'purelib': '$base/site-packages',
+        'platlib': '$base/site-packages',
+        'headers': '$base/include/$dist_name',
+        'scripts': '$base/Scripts',
+        'data'   : '$base',
+        },
+    }
+
+# user site schemes
+if HAS_USER_SITE:
+    INSTALL_SCHEMES['nt_user'] = {
+        'purelib': '$usersite',
+        'platlib': '$usersite',
+        'headers': '$userbase/Python$py_version_nodot/Include/$dist_name',
+        'scripts': '$userbase/Python$py_version_nodot/Scripts',
+        'data'   : '$userbase',
+        }
+
+    INSTALL_SCHEMES['unix_user'] = {
+        'purelib': '$usersite',
+        'platlib': '$usersite',
+        'headers':
+            '$userbase/include/python$py_version_short$abiflags/$dist_name',
+        'scripts': '$userbase/bin',
+        'data'   : '$userbase',
+        }
+
+# The keys to an installation scheme; if any new types of files are to be
+# installed, be sure to add an entry to every installation scheme above,
+# and to SCHEME_KEYS here.
+SCHEME_KEYS = ('purelib', 'platlib', 'headers', 'scripts', 'data')
+
+
+class install(Command):
+
+    description = "install everything from build directory"
+
+    user_options = [
+        # Select installation scheme and set base director(y|ies)
+        ('prefix=', None,
+         "installation prefix"),
+        ('exec-prefix=', None,
+         "(Unix only) prefix for platform-specific files"),
+        ('home=', None,
+         "(Unix only) home directory to install under"),
+
+        # Or, just set the base director(y|ies)
+        ('install-base=', None,
+         "base installation directory (instead of --prefix or --home)"),
+        ('install-platbase=', None,
+         "base installation directory for platform-specific files " +
+         "(instead of --exec-prefix or --home)"),
+        ('root=', None,
+         "install everything relative to this alternate root directory"),
+
+        # Or, explicitly set the installation scheme
+        ('install-purelib=', None,
+         "installation directory for pure Python module distributions"),
+        ('install-platlib=', None,
+         "installation directory for non-pure module distributions"),
+        ('install-lib=', None,
+         "installation directory for all module distributions " +
+         "(overrides --install-purelib and --install-platlib)"),
+
+        ('install-headers=', None,
+         "installation directory for C/C++ headers"),
+        ('install-scripts=', None,
+         "installation directory for Python scripts"),
+        ('install-data=', None,
+         "installation directory for data files"),
+
+        # Byte-compilation options -- see install_lib.py for details, as
+        # these are duplicated from there (but only install_lib does
+        # anything with them).
+        ('compile', 'c', "compile .py to .pyc [default]"),
+        ('no-compile', None, "don't compile .py files"),
+        ('optimize=', 'O',
+         "also compile with optimization: -O1 for \"python -O\", "
+         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
+
+        # Miscellaneous control options
+        ('force', 'f',
+         "force installation (overwrite any existing files)"),
+        ('skip-build', None,
+         "skip rebuilding everything (for testing/debugging)"),
+
+        # Where to install documentation (eventually!)
+        #('doc-format=', None, "format of documentation to generate"),
+        #('install-man=', None, "directory for Unix man pages"),
+        #('install-html=', None, "directory for HTML documentation"),
+        #('install-info=', None, "directory for GNU info files"),
+
+        ('record=', None,
+         "filename in which to record list of installed files"),
+        ]
+
+    boolean_options = ['compile', 'force', 'skip-build']
+
+    if HAS_USER_SITE:
+        user_options.append(('user', None,
+                             "install in user site-package '%s'" % USER_SITE))
+        boolean_options.append('user')
+
+    negative_opt = {'no-compile' : 'compile'}
+
+
+    def initialize_options(self):
+        """Initializes options."""
+        # High-level options: these select both an installation base
+        # and scheme.
+        self.prefix = None
+        self.exec_prefix = None
+        self.home = None
+        self.user = 0
+
+        # These select only the installation base; it's up to the user to
+        # specify the installation scheme (currently, that means supplying
+        # the --install-{platlib,purelib,scripts,data} options).
+        self.install_base = None
+        self.install_platbase = None
+        self.root = None
+
+        # These options are the actual installation directories; if not
+        # supplied by the user, they are filled in using the installation
+        # scheme implied by prefix/exec-prefix/home and the contents of
+        # that installation scheme.
+        self.install_purelib = None     # for pure module distributions
+        self.install_platlib = None     # non-pure (dists w/ extensions)
+        self.install_headers = None     # for C/C++ headers
+        self.install_lib = None         # set to either purelib or platlib
+        self.install_scripts = None
+        self.install_data = None
+        self.install_userbase = USER_BASE
+        self.install_usersite = USER_SITE
+
+        self.compile = None
+        self.optimize = None
+
+        # Deprecated
+        # These two are for putting non-packagized distributions into their
+        # own directory and creating a .pth file if it makes sense.
+        # 'extra_path' comes from the setup file; 'install_path_file' can
+        # be turned off if it makes no sense to install a .pth file.  (But
+        # better to install it uselessly than to guess wrong and not
+        # install it when it's necessary and would be used!)  Currently,
+        # 'install_path_file' is always true unless some outsider meddles
+        # with it.
+        self.extra_path = None
+        self.install_path_file = 1
+
+        # 'force' forces installation, even if target files are not
+        # out-of-date.  'skip_build' skips running the "build" command,
+        # handy if you know it's not necessary.  'warn_dir' (which is *not*
+        # a user option, it's just there so the bdist_* commands can turn
+        # it off) determines whether we warn about installing to a
+        # directory not in sys.path.
+        self.force = 0
+        self.skip_build = 0
+        self.warn_dir = 1
+
+        # These are only here as a conduit from the 'build' command to the
+        # 'install_*' commands that do the real work.  ('build_base' isn't
+        # actually used anywhere, but it might be useful in future.)  They
+        # are not user options, because if the user told the install
+        # command where the build directory is, that wouldn't affect the
+        # build command.
+        self.build_base = None
+        self.build_lib = None
+
+        # Not defined yet because we don't know anything about
+        # documentation yet.
+        #self.install_man = None
+        #self.install_html = None
+        #self.install_info = None
+
+        self.record = None
+
+
+    # -- Option finalizing methods -------------------------------------
+    # (This is rather more involved than for most commands,
+    # because this is where the policy for installing third-
+    # party Python modules on various platforms given a wide
+    # array of user input is decided.  Yes, it's quite complex!)
+
+    def finalize_options(self):
+        """Finalizes options."""
+        # This method (and its helpers, like 'finalize_unix()',
+        # 'finalize_other()', and 'select_scheme()') is where the default
+        # installation directories for modules, extension modules, and
+        # anything else we care to install from a Python module
+        # distribution.  Thus, this code makes a pretty important policy
+        # statement about how third-party stuff is added to a Python
+        # installation!  Note that the actual work of installation is done
+        # by the relatively simple 'install_*' commands; they just take
+        # their orders from the installation directory options determined
+        # here.
+
+        # Check for errors/inconsistencies in the options; first, stuff
+        # that's wrong on any platform.
+
+        if ((self.prefix or self.exec_prefix or self.home) and
+            (self.install_base or self.install_platbase)):
+            raise DistutilsOptionError(
+                   "must supply either prefix/exec-prefix/home or " +
+                   "install-base/install-platbase -- not both")
+
+        if self.home and (self.prefix or self.exec_prefix):
+            raise DistutilsOptionError(
+                  "must supply either home or prefix/exec-prefix -- not both")
+
+        if self.user and (self.prefix or self.exec_prefix or self.home or
+                self.install_base or self.install_platbase):
+            raise DistutilsOptionError("can't combine user with prefix, "
+                                       "exec_prefix/home, or install_(plat)base")
+
+        # Next, stuff that's wrong (or dubious) only on certain platforms.
+        if os.name != "posix":
+            if self.exec_prefix:
+                self.warn("exec-prefix option ignored on this platform")
+                self.exec_prefix = None
+
+        # Now the interesting logic -- so interesting that we farm it out
+        # to other methods.  The goal of these methods is to set the final
+        # values for the install_{lib,scripts,data,...}  options, using as
+        # input a heady brew of prefix, exec_prefix, home, install_base,
+        # install_platbase, user-supplied versions of
+        # install_{purelib,platlib,lib,scripts,data,...}, and the
+        # INSTALL_SCHEME dictionary above.  Phew!
+
+        self.dump_dirs("pre-finalize_{unix,other}")
+
+        if os.name == 'posix':
+            self.finalize_unix()
+        else:
+            self.finalize_other()
+
+        self.dump_dirs("post-finalize_{unix,other}()")
+
+        # Expand configuration variables, tilde, etc. in self.install_base
+        # and self.install_platbase -- that way, we can use $base or
+        # $platbase in the other installation directories and not worry
+        # about needing recursive variable expansion (shudder).
+
+        py_version = sys.version.split()[0]
+        (prefix, exec_prefix) = get_config_vars('prefix', 'exec_prefix')
+        try:
+            abiflags = sys.abiflags
+        except AttributeError:
+            # sys.abiflags may not be defined on all platforms.
+            abiflags = ''
+        self.config_vars = {'dist_name': self.distribution.get_name(),
+                            'dist_version': self.distribution.get_version(),
+                            'dist_fullname': self.distribution.get_fullname(),
+                            'py_version': py_version,
+                            'py_version_short': '%d.%d' % sys.version_info[:2],
+                            'py_version_nodot': '%d%d' % sys.version_info[:2],
+                            'sys_prefix': prefix,
+                            'prefix': prefix,
+                            'sys_exec_prefix': exec_prefix,
+                            'exec_prefix': exec_prefix,
+                            'abiflags': abiflags,
+                            'platlibdir': getattr(sys, 'platlibdir', 'lib'),
+                           }
+
+        if HAS_USER_SITE:
+            self.config_vars['userbase'] = self.install_userbase
+            self.config_vars['usersite'] = self.install_usersite
+
+        self.expand_basedirs()
+
+        self.dump_dirs("post-expand_basedirs()")
+
+        # Now define config vars for the base directories so we can expand
+        # everything else.
+        self.config_vars['base'] = self.install_base
+        self.config_vars['platbase'] = self.install_platbase
+
+        if DEBUG:
+            from pprint import pprint
+            print("config vars:")
+            pprint(self.config_vars)
+
+        # Expand "~" and configuration variables in the installation
+        # directories.
+        self.expand_dirs()
+
+        self.dump_dirs("post-expand_dirs()")
+
+        # Create directories in the home dir:
+        if self.user:
+            self.create_home_path()
+
+        # Pick the actual directory to install all modules to: either
+        # install_purelib or install_platlib, depending on whether this
+        # module distribution is pure or not.  Of course, if the user
+        # already specified install_lib, use their selection.
+        if self.install_lib is None:
+            if self.distribution.ext_modules: # has extensions: non-pure
+                self.install_lib = self.install_platlib
+            else:
+                self.install_lib = self.install_purelib
+
+
+        # Convert directories from Unix /-separated syntax to the local
+        # convention.
+        self.convert_paths('lib', 'purelib', 'platlib',
+                           'scripts', 'data', 'headers',
+                           'userbase', 'usersite')
+
+        # Deprecated
+        # Well, we're not actually fully completely finalized yet: we still
+        # have to deal with 'extra_path', which is the hack for allowing
+        # non-packagized module distributions (hello, Numerical Python!) to
+        # get their own directories.
+        self.handle_extra_path()
+        self.install_libbase = self.install_lib # needed for .pth file
+        self.install_lib = os.path.join(self.install_lib, self.extra_dirs)
+
+        # If a new root directory was supplied, make all the installation
+        # dirs relative to it.
+        if self.root is not None:
+            self.change_roots('libbase', 'lib', 'purelib', 'platlib',
+                              'scripts', 'data', 'headers')
+
+        self.dump_dirs("after prepending root")
+
+        # Find out the build directories, ie. where to install from.
+        self.set_undefined_options('build',
+                                   ('build_base', 'build_base'),
+                                   ('build_lib', 'build_lib'))
+
+        # Punt on doc directories for now -- after all, we're punting on
+        # documentation completely!
+
+    def dump_dirs(self, msg):
+        """Dumps the list of user options."""
+        if not DEBUG:
+            return
+        from distutils.fancy_getopt import longopt_xlate
+        log.debug(msg + ":")
+        for opt in self.user_options:
+            opt_name = opt[0]
+            if opt_name[-1] == "=":
+                opt_name = opt_name[0:-1]
+            if opt_name in self.negative_opt:
+                opt_name = self.negative_opt[opt_name]
+                opt_name = opt_name.translate(longopt_xlate)
+                val = not getattr(self, opt_name)
+            else:
+                opt_name = opt_name.translate(longopt_xlate)
+                val = getattr(self, opt_name)
+            log.debug("  %s: %s", opt_name, val)
+
+    def finalize_unix(self):
+        """Finalizes options for posix platforms."""
+        if self.install_base is not None or self.install_platbase is not None:
+            if ((self.install_lib is None and
+                 self.install_purelib is None and
+                 self.install_platlib is None) or
+                self.install_headers is None or
+                self.install_scripts is None or
+                self.install_data is None):
+                raise DistutilsOptionError(
+                      "install-base or install-platbase supplied, but "
+                      "installation scheme is incomplete")
+            return
+
+        if self.user:
+            if self.install_userbase is None:
+                raise DistutilsPlatformError(
+                    "User base directory is not specified")
+            self.install_base = self.install_platbase = self.install_userbase
+            self.select_scheme("unix_user")
+        elif self.home is not None:
+            self.install_base = self.install_platbase = self.home
+            self.select_scheme("unix_home")
+        else:
+            if self.prefix is None:
+                if self.exec_prefix is not None:
+                    raise DistutilsOptionError(
+                          "must not supply exec-prefix without prefix")
+
+                self.prefix = os.path.normpath(sys.prefix)
+                self.exec_prefix = os.path.normpath(sys.exec_prefix)
+
+            else:
+                if self.exec_prefix is None:
+                    self.exec_prefix = self.prefix
+
+            self.install_base = self.prefix
+            self.install_platbase = self.exec_prefix
+            self.select_scheme("unix_prefix")
+
+    def finalize_other(self):
+        """Finalizes options for non-posix platforms"""
+        if self.user:
+            if self.install_userbase is None:
+                raise DistutilsPlatformError(
+                    "User base directory is not specified")
+            self.install_base = self.install_platbase = self.install_userbase
+            self.select_scheme(os.name + "_user")
+        elif self.home is not None:
+            self.install_base = self.install_platbase = self.home
+            self.select_scheme("unix_home")
+        else:
+            if self.prefix is None:
+                self.prefix = os.path.normpath(sys.prefix)
+
+            self.install_base = self.install_platbase = self.prefix
+            try:
+                self.select_scheme(os.name)
+            except KeyError:
+                raise DistutilsPlatformError(
+                      "I don't know how to install stuff on '%s'" % os.name)
+
+    def select_scheme(self, name):
+        """Sets the install directories by applying the install schemes."""
+        # it's the caller's problem if they supply a bad name!
+        if (hasattr(sys, 'pypy_version_info') and
+                not name.endswith(('_user', '_home'))):
+            if os.name == 'nt':
+                name = 'pypy_nt'
+            else:
+                name = 'pypy'
+        scheme = INSTALL_SCHEMES[name]
+        for key in SCHEME_KEYS:
+            attrname = 'install_' + key
+            if getattr(self, attrname) is None:
+                setattr(self, attrname, scheme[key])
+
+    def _expand_attrs(self, attrs):
+        for attr in attrs:
+            val = getattr(self, attr)
+            if val is not None:
+                if os.name == 'posix' or os.name == 'nt':
+                    val = os.path.expanduser(val)
+                val = subst_vars(val, self.config_vars)
+                setattr(self, attr, val)
+
+    def expand_basedirs(self):
+        """Calls `os.path.expanduser` on install_base, install_platbase and
+        root."""
+        self._expand_attrs(['install_base', 'install_platbase', 'root'])
+
+    def expand_dirs(self):
+        """Calls `os.path.expanduser` on install dirs."""
+        self._expand_attrs(['install_purelib', 'install_platlib',
+                            'install_lib', 'install_headers',
+                            'install_scripts', 'install_data',])
+
+    def convert_paths(self, *names):
+        """Call `convert_path` over `names`."""
+        for name in names:
+            attr = "install_" + name
+            setattr(self, attr, convert_path(getattr(self, attr)))
+
+    def handle_extra_path(self):
+        """Set `path_file` and `extra_dirs` using `extra_path`."""
+        if self.extra_path is None:
+            self.extra_path = self.distribution.extra_path
+
+        if self.extra_path is not None:
+            log.warn(
+                "Distribution option extra_path is deprecated. "
+                "See issue27919 for details."
+            )
+            if isinstance(self.extra_path, str):
+                self.extra_path = self.extra_path.split(',')
+
+            if len(self.extra_path) == 1:
+                path_file = extra_dirs = self.extra_path[0]
+            elif len(self.extra_path) == 2:
+                path_file, extra_dirs = self.extra_path
+            else:
+                raise DistutilsOptionError(
+                      "'extra_path' option must be a list, tuple, or "
+                      "comma-separated string with 1 or 2 elements")
+
+            # convert to local form in case Unix notation used (as it
+            # should be in setup scripts)
+            extra_dirs = convert_path(extra_dirs)
+        else:
+            path_file = None
+            extra_dirs = ''
+
+        # XXX should we warn if path_file and not extra_dirs? (in which
+        # case the path file would be harmless but pointless)
+        self.path_file = path_file
+        self.extra_dirs = extra_dirs
+
+    def change_roots(self, *names):
+        """Change the install directories pointed by name using root."""
+        for name in names:
+            attr = "install_" + name
+            setattr(self, attr, change_root(self.root, getattr(self, attr)))
+
+    def create_home_path(self):
+        """Create directories under ~."""
+        if not self.user:
+            return
+        home = convert_path(os.path.expanduser("~"))
+        for name, path in self.config_vars.items():
+            if path.startswith(home) and not os.path.isdir(path):
+                self.debug_print("os.makedirs('%s', 0o700)" % path)
+                os.makedirs(path, 0o700)
+
+    # -- Command execution methods -------------------------------------
+
+    def run(self):
+        """Runs the command."""
+        # Obviously have to build before we can install
+        if not self.skip_build:
+            self.run_command('build')
+            # If we built for any other platform, we can't install.
+            build_plat = self.distribution.get_command_obj('build').plat_name
+            # check warn_dir - it is a clue that the 'install' is happening
+            # internally, and not to sys.path, so we don't check the platform
+            # matches what we are running.
+            if self.warn_dir and build_plat != get_platform():
+                raise DistutilsPlatformError("Can't install when "
+                                             "cross-compiling")
+
+        # Run all sub-commands (at least those that need to be run)
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+        if self.path_file:
+            self.create_path_file()
+
+        # write list of installed files, if requested.
+        if self.record:
+            outputs = self.get_outputs()
+            if self.root:               # strip any package prefix
+                root_len = len(self.root)
+                for counter in range(len(outputs)):
+                    outputs[counter] = outputs[counter][root_len:]
+            self.execute(write_file,
+                         (self.record, outputs),
+                         "writing list of installed files to '%s'" %
+                         self.record)
+
+        sys_path = map(os.path.normpath, sys.path)
+        sys_path = map(os.path.normcase, sys_path)
+        install_lib = os.path.normcase(os.path.normpath(self.install_lib))
+        if (self.warn_dir and
+            not (self.path_file and self.install_path_file) and
+            install_lib not in sys_path):
+            log.debug(("modules installed to '%s', which is not in "
+                       "Python's module search path (sys.path) -- "
+                       "you'll have to change the search path yourself"),
+                       self.install_lib)
+
+    def create_path_file(self):
+        """Creates the .pth file"""
+        filename = os.path.join(self.install_libbase,
+                                self.path_file + ".pth")
+        if self.install_path_file:
+            self.execute(write_file,
+                         (filename, [self.extra_dirs]),
+                         "creating %s" % filename)
+        else:
+            self.warn("path file '%s' not created" % filename)
+
+
+    # -- Reporting methods ---------------------------------------------
+
+    def get_outputs(self):
+        """Assembles the outputs of all the sub-commands."""
+        outputs = []
+        for cmd_name in self.get_sub_commands():
+            cmd = self.get_finalized_command(cmd_name)
+            # Add the contents of cmd.get_outputs(), ensuring
+            # that outputs doesn't contain duplicate entries
+            for filename in cmd.get_outputs():
+                if filename not in outputs:
+                    outputs.append(filename)
+
+        if self.path_file and self.install_path_file:
+            outputs.append(os.path.join(self.install_libbase,
+                                        self.path_file + ".pth"))
+
+        return outputs
+
+    def get_inputs(self):
+        """Returns the inputs of all the sub-commands"""
+        # XXX gee, this looks familiar ;-(
+        inputs = []
+        for cmd_name in self.get_sub_commands():
+            cmd = self.get_finalized_command(cmd_name)
+            inputs.extend(cmd.get_inputs())
+
+        return inputs
+
+    # -- Predicates for sub-command list -------------------------------
+
+    def has_lib(self):
+        """Returns true if the current distribution has any Python
+        modules to install."""
+        return (self.distribution.has_pure_modules() or
+                self.distribution.has_ext_modules())
+
+    def has_headers(self):
+        """Returns true if the current distribution has any headers to
+        install."""
+        return self.distribution.has_headers()
+
+    def has_scripts(self):
+        """Returns true if the current distribution has any scripts to.
+        install."""
+        return self.distribution.has_scripts()
+
+    def has_data(self):
+        """Returns true if the current distribution has any data to.
+        install."""
+        return self.distribution.has_data_files()
+
+    # 'sub_commands': a list of commands this command might have to run to
+    # get its work done.  See cmd.py for more info.
+    sub_commands = [('install_lib',     has_lib),
+                    ('install_headers', has_headers),
+                    ('install_scripts', has_scripts),
+                    ('install_data',    has_data),
+                    ('install_egg_info', lambda self:True),
+                   ]
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_data.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_data.py
new file mode 100644
index 0000000..947cd76
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_data.py
@@ -0,0 +1,79 @@
+"""distutils.command.install_data
+
+Implements the Distutils 'install_data' command, for installing
+platform-independent data files."""
+
+# contributed by Bastian Kleineidam
+
+import os
+from distutils.core import Command
+from distutils.util import change_root, convert_path
+
+class install_data(Command):
+
+    description = "install data files"
+
+    user_options = [
+        ('install-dir=', 'd',
+         "base directory for installing data files "
+         "(default: installation base dir)"),
+        ('root=', None,
+         "install everything relative to this alternate root directory"),
+        ('force', 'f', "force installation (overwrite existing files)"),
+        ]
+
+    boolean_options = ['force']
+
+    def initialize_options(self):
+        self.install_dir = None
+        self.outfiles = []
+        self.root = None
+        self.force = 0
+        self.data_files = self.distribution.data_files
+        self.warn_dir = 1
+
+    def finalize_options(self):
+        self.set_undefined_options('install',
+                                   ('install_data', 'install_dir'),
+                                   ('root', 'root'),
+                                   ('force', 'force'),
+                                  )
+
+    def run(self):
+        self.mkpath(self.install_dir)
+        for f in self.data_files:
+            if isinstance(f, str):
+                # it's a simple file, so copy it
+                f = convert_path(f)
+                if self.warn_dir:
+                    self.warn("setup script did not provide a directory for "
+                              "'%s' -- installing right in '%s'" %
+                              (f, self.install_dir))
+                (out, _) = self.copy_file(f, self.install_dir)
+                self.outfiles.append(out)
+            else:
+                # it's a tuple with path to install to and a list of files
+                dir = convert_path(f[0])
+                if not os.path.isabs(dir):
+                    dir = os.path.join(self.install_dir, dir)
+                elif self.root:
+                    dir = change_root(self.root, dir)
+                self.mkpath(dir)
+
+                if f[1] == []:
+                    # If there are no files listed, the user must be
+                    # trying to create an empty directory, so add the
+                    # directory to the list of output files.
+                    self.outfiles.append(dir)
+                else:
+                    # Copy files, adding them to the list of output files.
+                    for data in f[1]:
+                        data = convert_path(data)
+                        (out, _) = self.copy_file(data, dir)
+                        self.outfiles.append(out)
+
+    def get_inputs(self):
+        return self.data_files or []
+
+    def get_outputs(self):
+        return self.outfiles
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_egg_info.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_egg_info.py
new file mode 100644
index 0000000..0ddc736
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_egg_info.py
@@ -0,0 +1,77 @@
+"""distutils.command.install_egg_info
+
+Implements the Distutils 'install_egg_info' command, for installing
+a package's PKG-INFO metadata."""
+
+
+from distutils.cmd import Command
+from distutils import log, dir_util
+import os, sys, re
+
+class install_egg_info(Command):
+    """Install an .egg-info file for the package"""
+
+    description = "Install package's PKG-INFO metadata as an .egg-info file"
+    user_options = [
+        ('install-dir=', 'd', "directory to install to"),
+    ]
+
+    def initialize_options(self):
+        self.install_dir = None
+
+    def finalize_options(self):
+        self.set_undefined_options('install_lib',('install_dir','install_dir'))
+        basename = "%s-%s-py%d.%d.egg-info" % (
+            to_filename(safe_name(self.distribution.get_name())),
+            to_filename(safe_version(self.distribution.get_version())),
+            *sys.version_info[:2]
+        )
+        self.target = os.path.join(self.install_dir, basename)
+        self.outputs = [self.target]
+
+    def run(self):
+        target = self.target
+        if os.path.isdir(target) and not os.path.islink(target):
+            dir_util.remove_tree(target, dry_run=self.dry_run)
+        elif os.path.exists(target):
+            self.execute(os.unlink,(self.target,),"Removing "+target)
+        elif not os.path.isdir(self.install_dir):
+            self.execute(os.makedirs, (self.install_dir,),
+                         "Creating "+self.install_dir)
+        log.info("Writing %s", target)
+        if not self.dry_run:
+            with open(target, 'w', encoding='UTF-8') as f:
+                self.distribution.metadata.write_pkg_file(f)
+
+    def get_outputs(self):
+        return self.outputs
+
+
+# The following routines are taken from setuptools' pkg_resources module and
+# can be replaced by importing them from pkg_resources once it is included
+# in the stdlib.
+
+def safe_name(name):
+    """Convert an arbitrary string to a standard distribution name
+
+    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
+    """
+    return re.sub('[^A-Za-z0-9.]+', '-', name)
+
+
+def safe_version(version):
+    """Convert an arbitrary string to a standard version string
+
+    Spaces become dots, and all other non-alphanumeric characters become
+    dashes, with runs of multiple dashes condensed to a single dash.
+    """
+    version = version.replace(' ','.')
+    return re.sub('[^A-Za-z0-9.]+', '-', version)
+
+
+def to_filename(name):
+    """Convert a project or version name to its filename-escaped form
+
+    Any '-' characters are currently replaced with '_'.
+    """
+    return name.replace('-','_')
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_headers.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_headers.py
new file mode 100644
index 0000000..9bb0b18
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_headers.py
@@ -0,0 +1,47 @@
+"""distutils.command.install_headers
+
+Implements the Distutils 'install_headers' command, to install C/C++ header
+files to the Python include directory."""
+
+from distutils.core import Command
+
+
+# XXX force is never used
+class install_headers(Command):
+
+    description = "install C/C++ header files"
+
+    user_options = [('install-dir=', 'd',
+                     "directory to install header files to"),
+                    ('force', 'f',
+                     "force installation (overwrite existing files)"),
+                   ]
+
+    boolean_options = ['force']
+
+    def initialize_options(self):
+        self.install_dir = None
+        self.force = 0
+        self.outfiles = []
+
+    def finalize_options(self):
+        self.set_undefined_options('install',
+                                   ('install_headers', 'install_dir'),
+                                   ('force', 'force'))
+
+
+    def run(self):
+        headers = self.distribution.headers
+        if not headers:
+            return
+
+        self.mkpath(self.install_dir)
+        for header in headers:
+            (out, _) = self.copy_file(header, self.install_dir)
+            self.outfiles.append(out)
+
+    def get_inputs(self):
+        return self.distribution.headers or []
+
+    def get_outputs(self):
+        return self.outfiles
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_lib.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_lib.py
new file mode 100644
index 0000000..6154cf0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_lib.py
@@ -0,0 +1,217 @@
+"""distutils.command.install_lib
+
+Implements the Distutils 'install_lib' command
+(install all Python modules)."""
+
+import os
+import importlib.util
+import sys
+
+from distutils.core import Command
+from distutils.errors import DistutilsOptionError
+
+
+# Extension for Python source files.
+PYTHON_SOURCE_EXTENSION = ".py"
+
+class install_lib(Command):
+
+    description = "install all Python modules (extensions and pure Python)"
+
+    # The byte-compilation options are a tad confusing.  Here are the
+    # possible scenarios:
+    #   1) no compilation at all (--no-compile --no-optimize)
+    #   2) compile .pyc only (--compile --no-optimize; default)
+    #   3) compile .pyc and "opt-1" .pyc (--compile --optimize)
+    #   4) compile "opt-1" .pyc only (--no-compile --optimize)
+    #   5) compile .pyc and "opt-2" .pyc (--compile --optimize-more)
+    #   6) compile "opt-2" .pyc only (--no-compile --optimize-more)
+    #
+    # The UI for this is two options, 'compile' and 'optimize'.
+    # 'compile' is strictly boolean, and only decides whether to
+    # generate .pyc files.  'optimize' is three-way (0, 1, or 2), and
+    # decides both whether to generate .pyc files and what level of
+    # optimization to use.
+
+    user_options = [
+        ('install-dir=', 'd', "directory to install to"),
+        ('build-dir=','b', "build directory (where to install from)"),
+        ('force', 'f', "force installation (overwrite existing files)"),
+        ('compile', 'c', "compile .py to .pyc [default]"),
+        ('no-compile', None, "don't compile .py files"),
+        ('optimize=', 'O',
+         "also compile with optimization: -O1 for \"python -O\", "
+         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
+        ('skip-build', None, "skip the build steps"),
+        ]
+
+    boolean_options = ['force', 'compile', 'skip-build']
+    negative_opt = {'no-compile' : 'compile'}
+
+    def initialize_options(self):
+        # let the 'install' command dictate our installation directory
+        self.install_dir = None
+        self.build_dir = None
+        self.force = 0
+        self.compile = None
+        self.optimize = None
+        self.skip_build = None
+
+    def finalize_options(self):
+        # Get all the information we need to install pure Python modules
+        # from the umbrella 'install' command -- build (source) directory,
+        # install (target) directory, and whether to compile .py files.
+        self.set_undefined_options('install',
+                                   ('build_lib', 'build_dir'),
+                                   ('install_lib', 'install_dir'),
+                                   ('force', 'force'),
+                                   ('compile', 'compile'),
+                                   ('optimize', 'optimize'),
+                                   ('skip_build', 'skip_build'),
+                                  )
+
+        if self.compile is None:
+            self.compile = True
+        if self.optimize is None:
+            self.optimize = False
+
+        if not isinstance(self.optimize, int):
+            try:
+                self.optimize = int(self.optimize)
+                if self.optimize not in (0, 1, 2):
+                    raise AssertionError
+            except (ValueError, AssertionError):
+                raise DistutilsOptionError("optimize must be 0, 1, or 2")
+
+    def run(self):
+        # Make sure we have built everything we need first
+        self.build()
+
+        # Install everything: simply dump the entire contents of the build
+        # directory to the installation directory (that's the beauty of
+        # having a build directory!)
+        outfiles = self.install()
+
+        # (Optionally) compile .py to .pyc
+        if outfiles is not None and self.distribution.has_pure_modules():
+            self.byte_compile(outfiles)
+
+    # -- Top-level worker functions ------------------------------------
+    # (called from 'run()')
+
+    def build(self):
+        if not self.skip_build:
+            if self.distribution.has_pure_modules():
+                self.run_command('build_py')
+            if self.distribution.has_ext_modules():
+                self.run_command('build_ext')
+
+    def install(self):
+        if os.path.isdir(self.build_dir):
+            outfiles = self.copy_tree(self.build_dir, self.install_dir)
+        else:
+            self.warn("'%s' does not exist -- no Python modules to install" %
+                      self.build_dir)
+            return
+        return outfiles
+
+    def byte_compile(self, files):
+        if sys.dont_write_bytecode:
+            self.warn('byte-compiling is disabled, skipping.')
+            return
+
+        from distutils.util import byte_compile
+
+        # Get the "--root" directory supplied to the "install" command,
+        # and use it as a prefix to strip off the purported filename
+        # encoded in bytecode files.  This is far from complete, but it
+        # should at least generate usable bytecode in RPM distributions.
+        install_root = self.get_finalized_command('install').root
+
+        if self.compile:
+            byte_compile(files, optimize=0,
+                         force=self.force, prefix=install_root,
+                         dry_run=self.dry_run)
+        if self.optimize > 0:
+            byte_compile(files, optimize=self.optimize,
+                         force=self.force, prefix=install_root,
+                         verbose=self.verbose, dry_run=self.dry_run)
+
+
+    # -- Utility methods -----------------------------------------------
+
+    def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir):
+        if not has_any:
+            return []
+
+        build_cmd = self.get_finalized_command(build_cmd)
+        build_files = build_cmd.get_outputs()
+        build_dir = getattr(build_cmd, cmd_option)
+
+        prefix_len = len(build_dir) + len(os.sep)
+        outputs = []
+        for file in build_files:
+            outputs.append(os.path.join(output_dir, file[prefix_len:]))
+
+        return outputs
+
+    def _bytecode_filenames(self, py_filenames):
+        bytecode_files = []
+        for py_file in py_filenames:
+            # Since build_py handles package data installation, the
+            # list of outputs can contain more than just .py files.
+            # Make sure we only report bytecode for the .py files.
+            ext = os.path.splitext(os.path.normcase(py_file))[1]
+            if ext != PYTHON_SOURCE_EXTENSION:
+                continue
+            if self.compile:
+                bytecode_files.append(importlib.util.cache_from_source(
+                    py_file, optimization=''))
+            if self.optimize > 0:
+                bytecode_files.append(importlib.util.cache_from_source(
+                    py_file, optimization=self.optimize))
+
+        return bytecode_files
+
+
+    # -- External interface --------------------------------------------
+    # (called by outsiders)
+
+    def get_outputs(self):
+        """Return the list of files that would be installed if this command
+        were actually run.  Not affected by the "dry-run" flag or whether
+        modules have actually been built yet.
+        """
+        pure_outputs = \
+            self._mutate_outputs(self.distribution.has_pure_modules(),
+                                 'build_py', 'build_lib',
+                                 self.install_dir)
+        if self.compile:
+            bytecode_outputs = self._bytecode_filenames(pure_outputs)
+        else:
+            bytecode_outputs = []
+
+        ext_outputs = \
+            self._mutate_outputs(self.distribution.has_ext_modules(),
+                                 'build_ext', 'build_lib',
+                                 self.install_dir)
+
+        return pure_outputs + bytecode_outputs + ext_outputs
+
+    def get_inputs(self):
+        """Get the list of files that are input to this command, ie. the
+        files that get installed as they are named in the build tree.
+        The files in this list correspond one-to-one to the output
+        filenames returned by 'get_outputs()'.
+        """
+        inputs = []
+
+        if self.distribution.has_pure_modules():
+            build_py = self.get_finalized_command('build_py')
+            inputs.extend(build_py.get_outputs())
+
+        if self.distribution.has_ext_modules():
+            build_ext = self.get_finalized_command('build_ext')
+            inputs.extend(build_ext.get_outputs())
+
+        return inputs
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_scripts.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_scripts.py
new file mode 100644
index 0000000..31a1130
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/install_scripts.py
@@ -0,0 +1,60 @@
+"""distutils.command.install_scripts
+
+Implements the Distutils 'install_scripts' command, for installing
+Python scripts."""
+
+# contributed by Bastian Kleineidam
+
+import os
+from distutils.core import Command
+from distutils import log
+from stat import ST_MODE
+
+
+class install_scripts(Command):
+
+    description = "install scripts (Python or otherwise)"
+
+    user_options = [
+        ('install-dir=', 'd', "directory to install scripts to"),
+        ('build-dir=','b', "build directory (where to install from)"),
+        ('force', 'f', "force installation (overwrite existing files)"),
+        ('skip-build', None, "skip the build steps"),
+    ]
+
+    boolean_options = ['force', 'skip-build']
+
+    def initialize_options(self):
+        self.install_dir = None
+        self.force = 0
+        self.build_dir = None
+        self.skip_build = None
+
+    def finalize_options(self):
+        self.set_undefined_options('build', ('build_scripts', 'build_dir'))
+        self.set_undefined_options('install',
+                                   ('install_scripts', 'install_dir'),
+                                   ('force', 'force'),
+                                   ('skip_build', 'skip_build'),
+                                  )
+
+    def run(self):
+        if not self.skip_build:
+            self.run_command('build_scripts')
+        self.outfiles = self.copy_tree(self.build_dir, self.install_dir)
+        if os.name == 'posix':
+            # Set the executable bits (owner, group, and world) on
+            # all the scripts we just installed.
+            for file in self.get_outputs():
+                if self.dry_run:
+                    log.info("changing mode of %s", file)
+                else:
+                    mode = ((os.stat(file)[ST_MODE]) | 0o555) & 0o7777
+                    log.info("changing mode of %s to %o", file, mode)
+                    os.chmod(file, mode)
+
+    def get_inputs(self):
+        return self.distribution.scripts or []
+
+    def get_outputs(self):
+        return self.outfiles or []
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/register.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/register.py
new file mode 100644
index 0000000..0fac94e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/register.py
@@ -0,0 +1,304 @@
+"""distutils.command.register
+
+Implements the Distutils 'register' command (register with the repository).
+"""
+
+# created 2002/10/21, Richard Jones
+
+import getpass
+import io
+import urllib.parse, urllib.request
+from warnings import warn
+
+from distutils.core import PyPIRCCommand
+from distutils.errors import *
+from distutils import log
+
+class register(PyPIRCCommand):
+
+    description = ("register the distribution with the Python package index")
+    user_options = PyPIRCCommand.user_options + [
+        ('list-classifiers', None,
+         'list the valid Trove classifiers'),
+        ('strict', None ,
+         'Will stop the registering if the meta-data are not fully compliant')
+        ]
+    boolean_options = PyPIRCCommand.boolean_options + [
+        'verify', 'list-classifiers', 'strict']
+
+    sub_commands = [('check', lambda self: True)]
+
+    def initialize_options(self):
+        PyPIRCCommand.initialize_options(self)
+        self.list_classifiers = 0
+        self.strict = 0
+
+    def finalize_options(self):
+        PyPIRCCommand.finalize_options(self)
+        # setting options for the `check` subcommand
+        check_options = {'strict': ('register', self.strict),
+                         'restructuredtext': ('register', 1)}
+        self.distribution.command_options['check'] = check_options
+
+    def run(self):
+        self.finalize_options()
+        self._set_config()
+
+        # Run sub commands
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+        if self.dry_run:
+            self.verify_metadata()
+        elif self.list_classifiers:
+            self.classifiers()
+        else:
+            self.send_metadata()
+
+    def check_metadata(self):
+        """Deprecated API."""
+        warn("distutils.command.register.check_metadata is deprecated, \
+              use the check command instead", PendingDeprecationWarning)
+        check = self.distribution.get_command_obj('check')
+        check.ensure_finalized()
+        check.strict = self.strict
+        check.restructuredtext = 1
+        check.run()
+
+    def _set_config(self):
+        ''' Reads the configuration file and set attributes.
+        '''
+        config = self._read_pypirc()
+        if config != {}:
+            self.username = config['username']
+            self.password = config['password']
+            self.repository = config['repository']
+            self.realm = config['realm']
+            self.has_config = True
+        else:
+            if self.repository not in ('pypi', self.DEFAULT_REPOSITORY):
+                raise ValueError('%s not found in .pypirc' % self.repository)
+            if self.repository == 'pypi':
+                self.repository = self.DEFAULT_REPOSITORY
+            self.has_config = False
+
+    def classifiers(self):
+        ''' Fetch the list of classifiers from the server.
+        '''
+        url = self.repository+'?:action=list_classifiers'
+        response = urllib.request.urlopen(url)
+        log.info(self._read_pypi_response(response))
+
+    def verify_metadata(self):
+        ''' Send the metadata to the package index server to be checked.
+        '''
+        # send the info to the server and report the result
+        (code, result) = self.post_to_server(self.build_post_data('verify'))
+        log.info('Server response (%s): %s', code, result)
+
+    def send_metadata(self):
+        ''' Send the metadata to the package index server.
+
+            Well, do the following:
+            1. figure who the user is, and then
+            2. send the data as a Basic auth'ed POST.
+
+            First we try to read the username/password from $HOME/.pypirc,
+            which is a ConfigParser-formatted file with a section
+            [distutils] containing username and password entries (both
+            in clear text). Eg:
+
+                [distutils]
+                index-servers =
+                    pypi
+
+                [pypi]
+                username: fred
+                password: sekrit
+
+            Otherwise, to figure who the user is, we offer the user three
+            choices:
+
+             1. use existing login,
+             2. register as a new user, or
+             3. set the password to a random string and email the user.
+
+        '''
+        # see if we can short-cut and get the username/password from the
+        # config
+        if self.has_config:
+            choice = '1'
+            username = self.username
+            password = self.password
+        else:
+            choice = 'x'
+            username = password = ''
+
+        # get the user's login info
+        choices = '1 2 3 4'.split()
+        while choice not in choices:
+            self.announce('''\
+We need to know who you are, so please choose either:
+ 1. use your existing login,
+ 2. register as a new user,
+ 3. have the server generate a new password for you (and email it to you), or
+ 4. quit
+Your selection [default 1]: ''', log.INFO)
+            choice = input()
+            if not choice:
+                choice = '1'
+            elif choice not in choices:
+                print('Please choose one of the four options!')
+
+        if choice == '1':
+            # get the username and password
+            while not username:
+                username = input('Username: ')
+            while not password:
+                password = getpass.getpass('Password: ')
+
+            # set up the authentication
+            auth = urllib.request.HTTPPasswordMgr()
+            host = urllib.parse.urlparse(self.repository)[1]
+            auth.add_password(self.realm, host, username, password)
+            # send the info to the server and report the result
+            code, result = self.post_to_server(self.build_post_data('submit'),
+                auth)
+            self.announce('Server response (%s): %s' % (code, result),
+                          log.INFO)
+
+            # possibly save the login
+            if code == 200:
+                if self.has_config:
+                    # sharing the password in the distribution instance
+                    # so the upload command can reuse it
+                    self.distribution.password = password
+                else:
+                    self.announce(('I can store your PyPI login so future '
+                                   'submissions will be faster.'), log.INFO)
+                    self.announce('(the login will be stored in %s)' % \
+                                  self._get_rc_file(), log.INFO)
+                    choice = 'X'
+                    while choice.lower() not in 'yn':
+                        choice = input('Save your login (y/N)?')
+                        if not choice:
+                            choice = 'n'
+                    if choice.lower() == 'y':
+                        self._store_pypirc(username, password)
+
+        elif choice == '2':
+            data = {':action': 'user'}
+            data['name'] = data['password'] = data['email'] = ''
+            data['confirm'] = None
+            while not data['name']:
+                data['name'] = input('Username: ')
+            while data['password'] != data['confirm']:
+                while not data['password']:
+                    data['password'] = getpass.getpass('Password: ')
+                while not data['confirm']:
+                    data['confirm'] = getpass.getpass(' Confirm: ')
+                if data['password'] != data['confirm']:
+                    data['password'] = ''
+                    data['confirm'] = None
+                    print("Password and confirm don't match!")
+            while not data['email']:
+                data['email'] = input('   EMail: ')
+            code, result = self.post_to_server(data)
+            if code != 200:
+                log.info('Server response (%s): %s', code, result)
+            else:
+                log.info('You will receive an email shortly.')
+                log.info(('Follow the instructions in it to '
+                          'complete registration.'))
+        elif choice == '3':
+            data = {':action': 'password_reset'}
+            data['email'] = ''
+            while not data['email']:
+                data['email'] = input('Your email address: ')
+            code, result = self.post_to_server(data)
+            log.info('Server response (%s): %s', code, result)
+
+    def build_post_data(self, action):
+        # figure the data to send - the metadata plus some additional
+        # information used by the package server
+        meta = self.distribution.metadata
+        data = {
+            ':action': action,
+            'metadata_version' : '1.0',
+            'name': meta.get_name(),
+            'version': meta.get_version(),
+            'summary': meta.get_description(),
+            'home_page': meta.get_url(),
+            'author': meta.get_contact(),
+            'author_email': meta.get_contact_email(),
+            'license': meta.get_licence(),
+            'description': meta.get_long_description(),
+            'keywords': meta.get_keywords(),
+            'platform': meta.get_platforms(),
+            'classifiers': meta.get_classifiers(),
+            'download_url': meta.get_download_url(),
+            # PEP 314
+            'provides': meta.get_provides(),
+            'requires': meta.get_requires(),
+            'obsoletes': meta.get_obsoletes(),
+        }
+        if data['provides'] or data['requires'] or data['obsoletes']:
+            data['metadata_version'] = '1.1'
+        return data
+
+    def post_to_server(self, data, auth=None):
+        ''' Post a query to the server, and return a string response.
+        '''
+        if 'name' in data:
+            self.announce('Registering %s to %s' % (data['name'],
+                                                    self.repository),
+                                                    log.INFO)
+        # Build up the MIME payload for the urllib2 POST data
+        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
+        sep_boundary = '\n--' + boundary
+        end_boundary = sep_boundary + '--'
+        body = io.StringIO()
+        for key, value in data.items():
+            # handle multiple entries for the same name
+            if type(value) not in (type([]), type( () )):
+                value = [value]
+            for value in value:
+                value = str(value)
+                body.write(sep_boundary)
+                body.write('\nContent-Disposition: form-data; name="%s"'%key)
+                body.write("\n\n")
+                body.write(value)
+                if value and value[-1] == '\r':
+                    body.write('\n')  # write an extra newline (lurve Macs)
+        body.write(end_boundary)
+        body.write("\n")
+        body = body.getvalue().encode("utf-8")
+
+        # build the Request
+        headers = {
+            'Content-type': 'multipart/form-data; boundary=%s; charset=utf-8'%boundary,
+            'Content-length': str(len(body))
+        }
+        req = urllib.request.Request(self.repository, body, headers)
+
+        # handle HTTP and include the Basic Auth handler
+        opener = urllib.request.build_opener(
+            urllib.request.HTTPBasicAuthHandler(password_mgr=auth)
+        )
+        data = ''
+        try:
+            result = opener.open(req)
+        except urllib.error.HTTPError as e:
+            if self.show_response:
+                data = e.fp.read()
+            result = e.code, e.msg
+        except urllib.error.URLError as e:
+            result = 500, str(e)
+        else:
+            if self.show_response:
+                data = self._read_pypi_response(result)
+            result = 200, 'OK'
+        if self.show_response:
+            msg = '\n'.join(('-' * 75, data, '-' * 75))
+            self.announce(msg, log.INFO)
+        return result
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/sdist.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/sdist.py
new file mode 100644
index 0000000..b4996fc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/sdist.py
@@ -0,0 +1,494 @@
+"""distutils.command.sdist
+
+Implements the Distutils 'sdist' command (create a source distribution)."""
+
+import os
+import sys
+from glob import glob
+from warnings import warn
+
+from distutils.core import Command
+from distutils import dir_util
+from distutils import file_util
+from distutils import archive_util
+from distutils.text_file import TextFile
+from distutils.filelist import FileList
+from distutils import log
+from distutils.util import convert_path
+from distutils.errors import DistutilsTemplateError, DistutilsOptionError
+
+
+def show_formats():
+    """Print all possible values for the 'formats' option (used by
+    the "--help-formats" command-line option).
+    """
+    from distutils.fancy_getopt import FancyGetopt
+    from distutils.archive_util import ARCHIVE_FORMATS
+    formats = []
+    for format in ARCHIVE_FORMATS.keys():
+        formats.append(("formats=" + format, None,
+                        ARCHIVE_FORMATS[format][2]))
+    formats.sort()
+    FancyGetopt(formats).print_help(
+        "List of available source distribution formats:")
+
+
+class sdist(Command):
+
+    description = "create a source distribution (tarball, zip file, etc.)"
+
+    def checking_metadata(self):
+        """Callable used for the check sub-command.
+
+        Placed here so user_options can view it"""
+        return self.metadata_check
+
+    user_options = [
+        ('template=', 't',
+         "name of manifest template file [default: MANIFEST.in]"),
+        ('manifest=', 'm',
+         "name of manifest file [default: MANIFEST]"),
+        ('use-defaults', None,
+         "include the default file set in the manifest "
+         "[default; disable with --no-defaults]"),
+        ('no-defaults', None,
+         "don't include the default file set"),
+        ('prune', None,
+         "specifically exclude files/directories that should not be "
+         "distributed (build tree, RCS/CVS dirs, etc.) "
+         "[default; disable with --no-prune]"),
+        ('no-prune', None,
+         "don't automatically exclude anything"),
+        ('manifest-only', 'o',
+         "just regenerate the manifest and then stop "
+         "(implies --force-manifest)"),
+        ('force-manifest', 'f',
+         "forcibly regenerate the manifest and carry on as usual. "
+         "Deprecated: now the manifest is always regenerated."),
+        ('formats=', None,
+         "formats for source distribution (comma-separated list)"),
+        ('keep-temp', 'k',
+         "keep the distribution tree around after creating " +
+         "archive file(s)"),
+        ('dist-dir=', 'd',
+         "directory to put the source distribution archive(s) in "
+         "[default: dist]"),
+        ('metadata-check', None,
+         "Ensure that all required elements of meta-data "
+         "are supplied. Warn if any missing. [default]"),
+        ('owner=', 'u',
+         "Owner name used when creating a tar file [default: current user]"),
+        ('group=', 'g',
+         "Group name used when creating a tar file [default: current group]"),
+        ]
+
+    boolean_options = ['use-defaults', 'prune',
+                       'manifest-only', 'force-manifest',
+                       'keep-temp', 'metadata-check']
+
+    help_options = [
+        ('help-formats', None,
+         "list available distribution formats", show_formats),
+        ]
+
+    negative_opt = {'no-defaults': 'use-defaults',
+                    'no-prune': 'prune' }
+
+    sub_commands = [('check', checking_metadata)]
+
+    READMES = ('README', 'README.txt', 'README.rst')
+
+    def initialize_options(self):
+        # 'template' and 'manifest' are, respectively, the names of
+        # the manifest template and manifest file.
+        self.template = None
+        self.manifest = None
+
+        # 'use_defaults': if true, we will include the default file set
+        # in the manifest
+        self.use_defaults = 1
+        self.prune = 1
+
+        self.manifest_only = 0
+        self.force_manifest = 0
+
+        self.formats = ['gztar']
+        self.keep_temp = 0
+        self.dist_dir = None
+
+        self.archive_files = None
+        self.metadata_check = 1
+        self.owner = None
+        self.group = None
+
+    def finalize_options(self):
+        if self.manifest is None:
+            self.manifest = "MANIFEST"
+        if self.template is None:
+            self.template = "MANIFEST.in"
+
+        self.ensure_string_list('formats')
+
+        bad_format = archive_util.check_archive_formats(self.formats)
+        if bad_format:
+            raise DistutilsOptionError(
+                  "unknown archive format '%s'" % bad_format)
+
+        if self.dist_dir is None:
+            self.dist_dir = "dist"
+
+    def run(self):
+        # 'filelist' contains the list of files that will make up the
+        # manifest
+        self.filelist = FileList()
+
+        # Run sub commands
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+        # Do whatever it takes to get the list of files to process
+        # (process the manifest template, read an existing manifest,
+        # whatever).  File list is accumulated in 'self.filelist'.
+        self.get_file_list()
+
+        # If user just wanted us to regenerate the manifest, stop now.
+        if self.manifest_only:
+            return
+
+        # Otherwise, go ahead and create the source distribution tarball,
+        # or zipfile, or whatever.
+        self.make_distribution()
+
+    def check_metadata(self):
+        """Deprecated API."""
+        warn("distutils.command.sdist.check_metadata is deprecated, \
+              use the check command instead", PendingDeprecationWarning)
+        check = self.distribution.get_command_obj('check')
+        check.ensure_finalized()
+        check.run()
+
+    def get_file_list(self):
+        """Figure out the list of files to include in the source
+        distribution, and put it in 'self.filelist'.  This might involve
+        reading the manifest template (and writing the manifest), or just
+        reading the manifest, or just using the default file set -- it all
+        depends on the user's options.
+        """
+        # new behavior when using a template:
+        # the file list is recalculated every time because
+        # even if MANIFEST.in or setup.py are not changed
+        # the user might have added some files in the tree that
+        # need to be included.
+        #
+        #  This makes --force the default and only behavior with templates.
+        template_exists = os.path.isfile(self.template)
+        if not template_exists and self._manifest_is_not_generated():
+            self.read_manifest()
+            self.filelist.sort()
+            self.filelist.remove_duplicates()
+            return
+
+        if not template_exists:
+            self.warn(("manifest template '%s' does not exist " +
+                        "(using default file list)") %
+                        self.template)
+        self.filelist.findall()
+
+        if self.use_defaults:
+            self.add_defaults()
+
+        if template_exists:
+            self.read_template()
+
+        if self.prune:
+            self.prune_file_list()
+
+        self.filelist.sort()
+        self.filelist.remove_duplicates()
+        self.write_manifest()
+
+    def add_defaults(self):
+        """Add all the default files to self.filelist:
+          - README or README.txt
+          - setup.py
+          - test/test*.py
+          - all pure Python modules mentioned in setup script
+          - all files pointed by package_data (build_py)
+          - all files defined in data_files.
+          - all files defined as scripts.
+          - all C sources listed as part of extensions or C libraries
+            in the setup script (doesn't catch C headers!)
+        Warns if (README or README.txt) or setup.py are missing; everything
+        else is optional.
+        """
+        self._add_defaults_standards()
+        self._add_defaults_optional()
+        self._add_defaults_python()
+        self._add_defaults_data_files()
+        self._add_defaults_ext()
+        self._add_defaults_c_libs()
+        self._add_defaults_scripts()
+
+    @staticmethod
+    def _cs_path_exists(fspath):
+        """
+        Case-sensitive path existence check
+
+        >>> sdist._cs_path_exists(__file__)
+        True
+        >>> sdist._cs_path_exists(__file__.upper())
+        False
+        """
+        if not os.path.exists(fspath):
+            return False
+        # make absolute so we always have a directory
+        abspath = os.path.abspath(fspath)
+        directory, filename = os.path.split(abspath)
+        return filename in os.listdir(directory)
+
+    def _add_defaults_standards(self):
+        standards = [self.READMES, self.distribution.script_name]
+        for fn in standards:
+            if isinstance(fn, tuple):
+                alts = fn
+                got_it = False
+                for fn in alts:
+                    if self._cs_path_exists(fn):
+                        got_it = True
+                        self.filelist.append(fn)
+                        break
+
+                if not got_it:
+                    self.warn("standard file not found: should have one of " +
+                              ', '.join(alts))
+            else:
+                if self._cs_path_exists(fn):
+                    self.filelist.append(fn)
+                else:
+                    self.warn("standard file '%s' not found" % fn)
+
+    def _add_defaults_optional(self):
+        optional = ['test/test*.py', 'setup.cfg']
+        for pattern in optional:
+            files = filter(os.path.isfile, glob(pattern))
+            self.filelist.extend(files)
+
+    def _add_defaults_python(self):
+        # build_py is used to get:
+        #  - python modules
+        #  - files defined in package_data
+        build_py = self.get_finalized_command('build_py')
+
+        # getting python files
+        if self.distribution.has_pure_modules():
+            self.filelist.extend(build_py.get_source_files())
+
+        # getting package_data files
+        # (computed in build_py.data_files by build_py.finalize_options)
+        for pkg, src_dir, build_dir, filenames in build_py.data_files:
+            for filename in filenames:
+                self.filelist.append(os.path.join(src_dir, filename))
+
+    def _add_defaults_data_files(self):
+        # getting distribution.data_files
+        if self.distribution.has_data_files():
+            for item in self.distribution.data_files:
+                if isinstance(item, str):
+                    # plain file
+                    item = convert_path(item)
+                    if os.path.isfile(item):
+                        self.filelist.append(item)
+                else:
+                    # a (dirname, filenames) tuple
+                    dirname, filenames = item
+                    for f in filenames:
+                        f = convert_path(f)
+                        if os.path.isfile(f):
+                            self.filelist.append(f)
+
+    def _add_defaults_ext(self):
+        if self.distribution.has_ext_modules():
+            build_ext = self.get_finalized_command('build_ext')
+            self.filelist.extend(build_ext.get_source_files())
+
+    def _add_defaults_c_libs(self):
+        if self.distribution.has_c_libraries():
+            build_clib = self.get_finalized_command('build_clib')
+            self.filelist.extend(build_clib.get_source_files())
+
+    def _add_defaults_scripts(self):
+        if self.distribution.has_scripts():
+            build_scripts = self.get_finalized_command('build_scripts')
+            self.filelist.extend(build_scripts.get_source_files())
+
+    def read_template(self):
+        """Read and parse manifest template file named by self.template.
+
+        (usually "MANIFEST.in") The parsing and processing is done by
+        'self.filelist', which updates itself accordingly.
+        """
+        log.info("reading manifest template '%s'", self.template)
+        template = TextFile(self.template, strip_comments=1, skip_blanks=1,
+                            join_lines=1, lstrip_ws=1, rstrip_ws=1,
+                            collapse_join=1)
+
+        try:
+            while True:
+                line = template.readline()
+                if line is None:            # end of file
+                    break
+
+                try:
+                    self.filelist.process_template_line(line)
+                # the call above can raise a DistutilsTemplateError for
+                # malformed lines, or a ValueError from the lower-level
+                # convert_path function
+                except (DistutilsTemplateError, ValueError) as msg:
+                    self.warn("%s, line %d: %s" % (template.filename,
+                                                   template.current_line,
+                                                   msg))
+        finally:
+            template.close()
+
+    def prune_file_list(self):
+        """Prune off branches that might slip into the file list as created
+        by 'read_template()', but really don't belong there:
+          * the build tree (typically "build")
+          * the release tree itself (only an issue if we ran "sdist"
+            previously with --keep-temp, or it aborted)
+          * any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
+        """
+        build = self.get_finalized_command('build')
+        base_dir = self.distribution.get_fullname()
+
+        self.filelist.exclude_pattern(None, prefix=build.build_base)
+        self.filelist.exclude_pattern(None, prefix=base_dir)
+
+        if sys.platform == 'win32':
+            seps = r'/|\\'
+        else:
+            seps = '/'
+
+        vcs_dirs = ['RCS', 'CVS', r'\.svn', r'\.hg', r'\.git', r'\.bzr',
+                    '_darcs']
+        vcs_ptrn = r'(^|%s)(%s)(%s).*' % (seps, '|'.join(vcs_dirs), seps)
+        self.filelist.exclude_pattern(vcs_ptrn, is_regex=1)
+
+    def write_manifest(self):
+        """Write the file list in 'self.filelist' (presumably as filled in
+        by 'add_defaults()' and 'read_template()') to the manifest file
+        named by 'self.manifest'.
+        """
+        if self._manifest_is_not_generated():
+            log.info("not writing to manually maintained "
+                     "manifest file '%s'" % self.manifest)
+            return
+
+        content = self.filelist.files[:]
+        content.insert(0, '# file GENERATED by distutils, do NOT edit')
+        self.execute(file_util.write_file, (self.manifest, content),
+                     "writing manifest file '%s'" % self.manifest)
+
+    def _manifest_is_not_generated(self):
+        # check for special comment used in 3.1.3 and higher
+        if not os.path.isfile(self.manifest):
+            return False
+
+        fp = open(self.manifest)
+        try:
+            first_line = fp.readline()
+        finally:
+            fp.close()
+        return first_line != '# file GENERATED by distutils, do NOT edit\n'
+
+    def read_manifest(self):
+        """Read the manifest file (named by 'self.manifest') and use it to
+        fill in 'self.filelist', the list of files to include in the source
+        distribution.
+        """
+        log.info("reading manifest file '%s'", self.manifest)
+        with open(self.manifest) as manifest:
+            for line in manifest:
+                # ignore comments and blank lines
+                line = line.strip()
+                if line.startswith('#') or not line:
+                    continue
+                self.filelist.append(line)
+
+    def make_release_tree(self, base_dir, files):
+        """Create the directory tree that will become the source
+        distribution archive.  All directories implied by the filenames in
+        'files' are created under 'base_dir', and then we hard link or copy
+        (if hard linking is unavailable) those files into place.
+        Essentially, this duplicates the developer's source tree, but in a
+        directory named after the distribution, containing only the files
+        to be distributed.
+        """
+        # Create all the directories under 'base_dir' necessary to
+        # put 'files' there; the 'mkpath()' is just so we don't die
+        # if the manifest happens to be empty.
+        self.mkpath(base_dir)
+        dir_util.create_tree(base_dir, files, dry_run=self.dry_run)
+
+        # And walk over the list of files, either making a hard link (if
+        # os.link exists) to each one that doesn't already exist in its
+        # corresponding location under 'base_dir', or copying each file
+        # that's out-of-date in 'base_dir'.  (Usually, all files will be
+        # out-of-date, because by default we blow away 'base_dir' when
+        # we're done making the distribution archives.)
+
+        if hasattr(os, 'link'):        # can make hard links on this system
+            link = 'hard'
+            msg = "making hard links in %s..." % base_dir
+        else:                           # nope, have to copy
+            link = None
+            msg = "copying files to %s..." % base_dir
+
+        if not files:
+            log.warn("no files to distribute -- empty manifest?")
+        else:
+            log.info(msg)
+        for file in files:
+            if not os.path.isfile(file):
+                log.warn("'%s' not a regular file -- skipping", file)
+            else:
+                dest = os.path.join(base_dir, file)
+                self.copy_file(file, dest, link=link)
+
+        self.distribution.metadata.write_pkg_info(base_dir)
+
+    def make_distribution(self):
+        """Create the source distribution(s).  First, we create the release
+        tree with 'make_release_tree()'; then, we create all required
+        archive files (according to 'self.formats') from the release tree.
+        Finally, we clean up by blowing away the release tree (unless
+        'self.keep_temp' is true).  The list of archive files created is
+        stored so it can be retrieved later by 'get_archive_files()'.
+        """
+        # Don't warn about missing meta-data here -- should be (and is!)
+        # done elsewhere.
+        base_dir = self.distribution.get_fullname()
+        base_name = os.path.join(self.dist_dir, base_dir)
+
+        self.make_release_tree(base_dir, self.filelist.files)
+        archive_files = []              # remember names of files we create
+        # tar archive must be created last to avoid overwrite and remove
+        if 'tar' in self.formats:
+            self.formats.append(self.formats.pop(self.formats.index('tar')))
+
+        for fmt in self.formats:
+            file = self.make_archive(base_name, fmt, base_dir=base_dir,
+                                     owner=self.owner, group=self.group)
+            archive_files.append(file)
+            self.distribution.dist_files.append(('sdist', '', file))
+
+        self.archive_files = archive_files
+
+        if not self.keep_temp:
+            dir_util.remove_tree(base_dir, dry_run=self.dry_run)
+
+    def get_archive_files(self):
+        """Return the list of archive files created when the command
+        was run, or None if the command hasn't run yet.
+        """
+        return self.archive_files
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/upload.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/upload.py
new file mode 100644
index 0000000..95e9fda
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/command/upload.py
@@ -0,0 +1,214 @@
+"""
+distutils.command.upload
+
+Implements the Distutils 'upload' subcommand (upload package to a package
+index).
+"""
+
+import os
+import io
+import hashlib
+from base64 import standard_b64encode
+from urllib.request import urlopen, Request, HTTPError
+from urllib.parse import urlparse
+from distutils.errors import DistutilsError, DistutilsOptionError
+from distutils.core import PyPIRCCommand
+from distutils.spawn import spawn
+from distutils import log
+
+
+# PyPI Warehouse supports MD5, SHA256, and Blake2 (blake2-256)
+# https://bugs.python.org/issue40698
+_FILE_CONTENT_DIGESTS = {
+    "md5_digest": getattr(hashlib, "md5", None),
+    "sha256_digest": getattr(hashlib, "sha256", None),
+    "blake2_256_digest": getattr(hashlib, "blake2b", None),
+}
+
+
+class upload(PyPIRCCommand):
+
+    description = "upload binary package to PyPI"
+
+    user_options = PyPIRCCommand.user_options + [
+        ('sign', 's',
+         'sign files to upload using gpg'),
+        ('identity=', 'i', 'GPG identity used to sign files'),
+        ]
+
+    boolean_options = PyPIRCCommand.boolean_options + ['sign']
+
+    def initialize_options(self):
+        PyPIRCCommand.initialize_options(self)
+        self.username = ''
+        self.password = ''
+        self.show_response = 0
+        self.sign = False
+        self.identity = None
+
+    def finalize_options(self):
+        PyPIRCCommand.finalize_options(self)
+        if self.identity and not self.sign:
+            raise DistutilsOptionError(
+                "Must use --sign for --identity to have meaning"
+            )
+        config = self._read_pypirc()
+        if config != {}:
+            self.username = config['username']
+            self.password = config['password']
+            self.repository = config['repository']
+            self.realm = config['realm']
+
+        # getting the password from the distribution
+        # if previously set by the register command
+        if not self.password and self.distribution.password:
+            self.password = self.distribution.password
+
+    def run(self):
+        if not self.distribution.dist_files:
+            msg = ("Must create and upload files in one command "
+                   "(e.g. setup.py sdist upload)")
+            raise DistutilsOptionError(msg)
+        for command, pyversion, filename in self.distribution.dist_files:
+            self.upload_file(command, pyversion, filename)
+
+    def upload_file(self, command, pyversion, filename):
+        # Makes sure the repository URL is compliant
+        schema, netloc, url, params, query, fragments = \
+            urlparse(self.repository)
+        if params or query or fragments:
+            raise AssertionError("Incompatible url %s" % self.repository)
+
+        if schema not in ('http', 'https'):
+            raise AssertionError("unsupported schema " + schema)
+
+        # Sign if requested
+        if self.sign:
+            gpg_args = ["gpg", "--detach-sign", "-a", filename]
+            if self.identity:
+                gpg_args[2:2] = ["--local-user", self.identity]
+            spawn(gpg_args,
+                  dry_run=self.dry_run)
+
+        # Fill in the data - send all the meta-data in case we need to
+        # register a new release
+        f = open(filename,'rb')
+        try:
+            content = f.read()
+        finally:
+            f.close()
+
+        meta = self.distribution.metadata
+        data = {
+            # action
+            ':action': 'file_upload',
+            'protocol_version': '1',
+
+            # identify release
+            'name': meta.get_name(),
+            'version': meta.get_version(),
+
+            # file content
+            'content': (os.path.basename(filename),content),
+            'filetype': command,
+            'pyversion': pyversion,
+
+            # additional meta-data
+            'metadata_version': '1.0',
+            'summary': meta.get_description(),
+            'home_page': meta.get_url(),
+            'author': meta.get_contact(),
+            'author_email': meta.get_contact_email(),
+            'license': meta.get_licence(),
+            'description': meta.get_long_description(),
+            'keywords': meta.get_keywords(),
+            'platform': meta.get_platforms(),
+            'classifiers': meta.get_classifiers(),
+            'download_url': meta.get_download_url(),
+            # PEP 314
+            'provides': meta.get_provides(),
+            'requires': meta.get_requires(),
+            'obsoletes': meta.get_obsoletes(),
+            }
+
+        data['comment'] = ''
+
+        # file content digests
+        for digest_name, digest_cons in _FILE_CONTENT_DIGESTS.items():
+            if digest_cons is None:
+                continue
+            try:
+                data[digest_name] = digest_cons(content).hexdigest()
+            except ValueError:
+                # hash digest not available or blocked by security policy
+                pass
+
+        if self.sign:
+            with open(filename + ".asc", "rb") as f:
+                data['gpg_signature'] = (os.path.basename(filename) + ".asc",
+                                         f.read())
+
+        # set up the authentication
+        user_pass = (self.username + ":" + self.password).encode('ascii')
+        # The exact encoding of the authentication string is debated.
+        # Anyway PyPI only accepts ascii for both username or password.
+        auth = "Basic " + standard_b64encode(user_pass).decode('ascii')
+
+        # Build up the MIME payload for the POST data
+        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
+        sep_boundary = b'\r\n--' + boundary.encode('ascii')
+        end_boundary = sep_boundary + b'--\r\n'
+        body = io.BytesIO()
+        for key, value in data.items():
+            title = '\r\nContent-Disposition: form-data; name="%s"' % key
+            # handle multiple entries for the same name
+            if not isinstance(value, list):
+                value = [value]
+            for value in value:
+                if type(value) is tuple:
+                    title += '; filename="%s"' % value[0]
+                    value = value[1]
+                else:
+                    value = str(value).encode('utf-8')
+                body.write(sep_boundary)
+                body.write(title.encode('utf-8'))
+                body.write(b"\r\n\r\n")
+                body.write(value)
+        body.write(end_boundary)
+        body = body.getvalue()
+
+        msg = "Submitting %s to %s" % (filename, self.repository)
+        self.announce(msg, log.INFO)
+
+        # build the Request
+        headers = {
+            'Content-type': 'multipart/form-data; boundary=%s' % boundary,
+            'Content-length': str(len(body)),
+            'Authorization': auth,
+        }
+
+        request = Request(self.repository, data=body,
+                          headers=headers)
+        # send the data
+        try:
+            result = urlopen(request)
+            status = result.getcode()
+            reason = result.msg
+        except HTTPError as e:
+            status = e.code
+            reason = e.msg
+        except OSError as e:
+            self.announce(str(e), log.ERROR)
+            raise
+
+        if status == 200:
+            self.announce('Server response (%s): %s' % (status, reason),
+                          log.INFO)
+            if self.show_response:
+                text = self._read_pypi_response(result)
+                msg = '\n'.join(('-' * 75, text, '-' * 75))
+                self.announce(msg, log.INFO)
+        else:
+            msg = 'Upload failed (%s): %s' % (status, reason)
+            self.announce(msg, log.ERROR)
+            raise DistutilsError(msg)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/config.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/config.py
new file mode 100644
index 0000000..2171abd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/config.py
@@ -0,0 +1,130 @@
+"""distutils.pypirc
+
+Provides the PyPIRCCommand class, the base class for the command classes
+that uses .pypirc in the distutils.command package.
+"""
+import os
+from configparser import RawConfigParser
+
+from distutils.cmd import Command
+
+DEFAULT_PYPIRC = """\
+[distutils]
+index-servers =
+    pypi
+
+[pypi]
+username:%s
+password:%s
+"""
+
+class PyPIRCCommand(Command):
+    """Base command that knows how to handle the .pypirc file
+    """
+    DEFAULT_REPOSITORY = 'https://upload.pypi.org/legacy/'
+    DEFAULT_REALM = 'pypi'
+    repository = None
+    realm = None
+
+    user_options = [
+        ('repository=', 'r',
+         "url of repository [default: %s]" % \
+            DEFAULT_REPOSITORY),
+        ('show-response', None,
+         'display full response text from server')]
+
+    boolean_options = ['show-response']
+
+    def _get_rc_file(self):
+        """Returns rc file path."""
+        return os.path.join(os.path.expanduser('~'), '.pypirc')
+
+    def _store_pypirc(self, username, password):
+        """Creates a default .pypirc file."""
+        rc = self._get_rc_file()
+        with os.fdopen(os.open(rc, os.O_CREAT | os.O_WRONLY, 0o600), 'w') as f:
+            f.write(DEFAULT_PYPIRC % (username, password))
+
+    def _read_pypirc(self):
+        """Reads the .pypirc file."""
+        rc = self._get_rc_file()
+        if os.path.exists(rc):
+            self.announce('Using PyPI login from %s' % rc)
+            repository = self.repository or self.DEFAULT_REPOSITORY
+
+            config = RawConfigParser()
+            config.read(rc)
+            sections = config.sections()
+            if 'distutils' in sections:
+                # let's get the list of servers
+                index_servers = config.get('distutils', 'index-servers')
+                _servers = [server.strip() for server in
+                            index_servers.split('\n')
+                            if server.strip() != '']
+                if _servers == []:
+                    # nothing set, let's try to get the default pypi
+                    if 'pypi' in sections:
+                        _servers = ['pypi']
+                    else:
+                        # the file is not properly defined, returning
+                        # an empty dict
+                        return {}
+                for server in _servers:
+                    current = {'server': server}
+                    current['username'] = config.get(server, 'username')
+
+                    # optional params
+                    for key, default in (('repository',
+                                          self.DEFAULT_REPOSITORY),
+                                         ('realm', self.DEFAULT_REALM),
+                                         ('password', None)):
+                        if config.has_option(server, key):
+                            current[key] = config.get(server, key)
+                        else:
+                            current[key] = default
+
+                    # work around people having "repository" for the "pypi"
+                    # section of their config set to the HTTP (rather than
+                    # HTTPS) URL
+                    if (server == 'pypi' and
+                        repository in (self.DEFAULT_REPOSITORY, 'pypi')):
+                        current['repository'] = self.DEFAULT_REPOSITORY
+                        return current
+
+                    if (current['server'] == repository or
+                        current['repository'] == repository):
+                        return current
+            elif 'server-login' in sections:
+                # old format
+                server = 'server-login'
+                if config.has_option(server, 'repository'):
+                    repository = config.get(server, 'repository')
+                else:
+                    repository = self.DEFAULT_REPOSITORY
+                return {'username': config.get(server, 'username'),
+                        'password': config.get(server, 'password'),
+                        'repository': repository,
+                        'server': server,
+                        'realm': self.DEFAULT_REALM}
+
+        return {}
+
+    def _read_pypi_response(self, response):
+        """Read and decode a PyPI HTTP response."""
+        import cgi
+        content_type = response.getheader('content-type', 'text/plain')
+        encoding = cgi.parse_header(content_type)[1].get('charset', 'ascii')
+        return response.read().decode(encoding)
+
+    def initialize_options(self):
+        """Initialize options."""
+        self.repository = None
+        self.realm = None
+        self.show_response = 0
+
+    def finalize_options(self):
+        """Finalizes options."""
+        if self.repository is None:
+            self.repository = self.DEFAULT_REPOSITORY
+        if self.realm is None:
+            self.realm = self.DEFAULT_REALM
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/core.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/core.py
new file mode 100644
index 0000000..d603d4a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/core.py
@@ -0,0 +1,234 @@
+"""distutils.core
+
+The only module that needs to be imported to use the Distutils; provides
+the 'setup' function (which is to be called from the setup script).  Also
+indirectly provides the Distribution and Command classes, although they are
+really defined in distutils.dist and distutils.cmd.
+"""
+
+import os
+import sys
+
+from distutils.debug import DEBUG
+from distutils.errors import *
+
+# Mainly import these so setup scripts can "from distutils.core import" them.
+from distutils.dist import Distribution
+from distutils.cmd import Command
+from distutils.config import PyPIRCCommand
+from distutils.extension import Extension
+
+# This is a barebones help message generated displayed when the user
+# runs the setup script with no arguments at all.  More useful help
+# is generated with various --help options: global help, list commands,
+# and per-command help.
+USAGE = """\
+usage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
+   or: %(script)s --help [cmd1 cmd2 ...]
+   or: %(script)s --help-commands
+   or: %(script)s cmd --help
+"""
+
+def gen_usage (script_name):
+    script = os.path.basename(script_name)
+    return USAGE % vars()
+
+
+# Some mild magic to control the behaviour of 'setup()' from 'run_setup()'.
+_setup_stop_after = None
+_setup_distribution = None
+
+# Legal keyword arguments for the setup() function
+setup_keywords = ('distclass', 'script_name', 'script_args', 'options',
+                  'name', 'version', 'author', 'author_email',
+                  'maintainer', 'maintainer_email', 'url', 'license',
+                  'description', 'long_description', 'keywords',
+                  'platforms', 'classifiers', 'download_url',
+                  'requires', 'provides', 'obsoletes',
+                  )
+
+# Legal keyword arguments for the Extension constructor
+extension_keywords = ('name', 'sources', 'include_dirs',
+                      'define_macros', 'undef_macros',
+                      'library_dirs', 'libraries', 'runtime_library_dirs',
+                      'extra_objects', 'extra_compile_args', 'extra_link_args',
+                      'swig_opts', 'export_symbols', 'depends', 'language')
+
+def setup (**attrs):
+    """The gateway to the Distutils: do everything your setup script needs
+    to do, in a highly flexible and user-driven way.  Briefly: create a
+    Distribution instance; find and parse config files; parse the command
+    line; run each Distutils command found there, customized by the options
+    supplied to 'setup()' (as keyword arguments), in config files, and on
+    the command line.
+
+    The Distribution instance might be an instance of a class supplied via
+    the 'distclass' keyword argument to 'setup'; if no such class is
+    supplied, then the Distribution class (in dist.py) is instantiated.
+    All other arguments to 'setup' (except for 'cmdclass') are used to set
+    attributes of the Distribution instance.
+
+    The 'cmdclass' argument, if supplied, is a dictionary mapping command
+    names to command classes.  Each command encountered on the command line
+    will be turned into a command class, which is in turn instantiated; any
+    class found in 'cmdclass' is used in place of the default, which is
+    (for command 'foo_bar') class 'foo_bar' in module
+    'distutils.command.foo_bar'.  The command class must provide a
+    'user_options' attribute which is a list of option specifiers for
+    'distutils.fancy_getopt'.  Any command-line options between the current
+    and the next command are used to set attributes of the current command
+    object.
+
+    When the entire command-line has been successfully parsed, calls the
+    'run()' method on each command object in turn.  This method will be
+    driven entirely by the Distribution object (which each command object
+    has a reference to, thanks to its constructor), and the
+    command-specific options that became attributes of each command
+    object.
+    """
+
+    global _setup_stop_after, _setup_distribution
+
+    # Determine the distribution class -- either caller-supplied or
+    # our Distribution (see below).
+    klass = attrs.get('distclass')
+    if klass:
+        del attrs['distclass']
+    else:
+        klass = Distribution
+
+    if 'script_name' not in attrs:
+        attrs['script_name'] = os.path.basename(sys.argv[0])
+    if 'script_args'  not in attrs:
+        attrs['script_args'] = sys.argv[1:]
+
+    # Create the Distribution instance, using the remaining arguments
+    # (ie. everything except distclass) to initialize it
+    try:
+        _setup_distribution = dist = klass(attrs)
+    except DistutilsSetupError as msg:
+        if 'name' not in attrs:
+            raise SystemExit("error in setup command: %s" % msg)
+        else:
+            raise SystemExit("error in %s setup command: %s" % \
+                  (attrs['name'], msg))
+
+    if _setup_stop_after == "init":
+        return dist
+
+    # Find and parse the config file(s): they will override options from
+    # the setup script, but be overridden by the command line.
+    dist.parse_config_files()
+
+    if DEBUG:
+        print("options (after parsing config files):")
+        dist.dump_option_dicts()
+
+    if _setup_stop_after == "config":
+        return dist
+
+    # Parse the command line and override config files; any
+    # command-line errors are the end user's fault, so turn them into
+    # SystemExit to suppress tracebacks.
+    try:
+        ok = dist.parse_command_line()
+    except DistutilsArgError as msg:
+        raise SystemExit(gen_usage(dist.script_name) + "\nerror: %s" % msg)
+
+    if DEBUG:
+        print("options (after parsing command line):")
+        dist.dump_option_dicts()
+
+    if _setup_stop_after == "commandline":
+        return dist
+
+    # And finally, run all the commands found on the command line.
+    if ok:
+        try:
+            dist.run_commands()
+        except KeyboardInterrupt:
+            raise SystemExit("interrupted")
+        except OSError as exc:
+            if DEBUG:
+                sys.stderr.write("error: %s\n" % (exc,))
+                raise
+            else:
+                raise SystemExit("error: %s" % (exc,))
+
+        except (DistutilsError,
+                CCompilerError) as msg:
+            if DEBUG:
+                raise
+            else:
+                raise SystemExit("error: " + str(msg))
+
+    return dist
+
+# setup ()
+
+
+def run_setup (script_name, script_args=None, stop_after="run"):
+    """Run a setup script in a somewhat controlled environment, and
+    return the Distribution instance that drives things.  This is useful
+    if you need to find out the distribution meta-data (passed as
+    keyword args from 'script' to 'setup()', or the contents of the
+    config files or command-line.
+
+    'script_name' is a file that will be read and run with 'exec()';
+    'sys.argv[0]' will be replaced with 'script' for the duration of the
+    call.  'script_args' is a list of strings; if supplied,
+    'sys.argv[1:]' will be replaced by 'script_args' for the duration of
+    the call.
+
+    'stop_after' tells 'setup()' when to stop processing; possible
+    values:
+      init
+        stop after the Distribution instance has been created and
+        populated with the keyword arguments to 'setup()'
+      config
+        stop after config files have been parsed (and their data
+        stored in the Distribution instance)
+      commandline
+        stop after the command-line ('sys.argv[1:]' or 'script_args')
+        have been parsed (and the data stored in the Distribution)
+      run [default]
+        stop after all commands have been run (the same as if 'setup()'
+        had been called in the usual way
+
+    Returns the Distribution instance, which provides all information
+    used to drive the Distutils.
+    """
+    if stop_after not in ('init', 'config', 'commandline', 'run'):
+        raise ValueError("invalid value for 'stop_after': %r" % (stop_after,))
+
+    global _setup_stop_after, _setup_distribution
+    _setup_stop_after = stop_after
+
+    save_argv = sys.argv.copy()
+    g = {'__file__': script_name}
+    try:
+        try:
+            sys.argv[0] = script_name
+            if script_args is not None:
+                sys.argv[1:] = script_args
+            with open(script_name, 'rb') as f:
+                exec(f.read(), g)
+        finally:
+            sys.argv = save_argv
+            _setup_stop_after = None
+    except SystemExit:
+        # Hmm, should we do something if exiting with a non-zero code
+        # (ie. error)?
+        pass
+
+    if _setup_distribution is None:
+        raise RuntimeError(("'distutils.core.setup()' was never called -- "
+               "perhaps '%s' is not a Distutils setup script?") % \
+              script_name)
+
+    # I wonder if the setup script's namespace -- g and l -- would be of
+    # any interest to callers?
+    #print "_setup_distribution:", _setup_distribution
+    return _setup_distribution
+
+# run_setup ()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/cygwinccompiler.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/cygwinccompiler.py
new file mode 100644
index 0000000..66c12dd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/cygwinccompiler.py
@@ -0,0 +1,403 @@
+"""distutils.cygwinccompiler
+
+Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
+handles the Cygwin port of the GNU C compiler to Windows.  It also contains
+the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
+cygwin in no-cygwin mode).
+"""
+
+# problems:
+#
+# * if you use a msvc compiled python version (1.5.2)
+#   1. you have to insert a __GNUC__ section in its config.h
+#   2. you have to generate an import library for its dll
+#      - create a def-file for python??.dll
+#      - create an import library using
+#             dlltool --dllname python15.dll --def python15.def \
+#                       --output-lib libpython15.a
+#
+#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
+#
+# * We put export_symbols in a def-file, and don't use
+#   --export-all-symbols because it doesn't worked reliable in some
+#   tested configurations. And because other windows compilers also
+#   need their symbols specified this no serious problem.
+#
+# tested configurations:
+#
+# * cygwin gcc 2.91.57/ld 2.9.4/dllwrap 0.2.4 works
+#   (after patching python's config.h and for C++ some other include files)
+#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
+# * mingw32 gcc 2.95.2/ld 2.9.4/dllwrap 0.2.4 works
+#   (ld doesn't support -shared, so we use dllwrap)
+# * cygwin gcc 2.95.2/ld 2.10.90/dllwrap 2.10.90 works now
+#   - its dllwrap doesn't work, there is a bug in binutils 2.10.90
+#     see also http://sources.redhat.com/ml/cygwin/2000-06/msg01274.html
+#   - using gcc -mdll instead dllwrap doesn't work without -static because
+#     it tries to link against dlls instead their import libraries. (If
+#     it finds the dll first.)
+#     By specifying -static we force ld to link against the import libraries,
+#     this is windows standard and there are normally not the necessary symbols
+#     in the dlls.
+#   *** only the version of June 2000 shows these problems
+# * cygwin gcc 3.2/ld 2.13.90 works
+#   (ld supports -shared)
+# * mingw gcc 3.2/ld 2.13 works
+#   (ld supports -shared)
+
+import os
+import sys
+import copy
+from subprocess import Popen, PIPE, check_output
+import re
+
+from distutils.unixccompiler import UnixCCompiler
+from distutils.file_util import write_file
+from distutils.errors import (DistutilsExecError, CCompilerError,
+        CompileError, UnknownFileError)
+from distutils.version import LooseVersion
+from distutils.spawn import find_executable
+
+def get_msvcr():
+    """Include the appropriate MSVC runtime library if Python was built
+    with MSVC 7.0 or later.
+    """
+    msc_pos = sys.version.find('MSC v.')
+    if msc_pos != -1:
+        msc_ver = sys.version[msc_pos+6:msc_pos+10]
+        if msc_ver == '1300':
+            # MSVC 7.0
+            return ['msvcr70']
+        elif msc_ver == '1310':
+            # MSVC 7.1
+            return ['msvcr71']
+        elif msc_ver == '1400':
+            # VS2005 / MSVC 8.0
+            return ['msvcr80']
+        elif msc_ver == '1500':
+            # VS2008 / MSVC 9.0
+            return ['msvcr90']
+        elif msc_ver == '1600':
+            # VS2010 / MSVC 10.0
+            return ['msvcr100']
+        else:
+            raise ValueError("Unknown MS Compiler version %s " % msc_ver)
+
+
+class CygwinCCompiler(UnixCCompiler):
+    """ Handles the Cygwin port of the GNU C compiler to Windows.
+    """
+    compiler_type = 'cygwin'
+    obj_extension = ".o"
+    static_lib_extension = ".a"
+    shared_lib_extension = ".dll"
+    static_lib_format = "lib%s%s"
+    shared_lib_format = "%s%s"
+    exe_extension = ".exe"
+
+    def __init__(self, verbose=0, dry_run=0, force=0):
+
+        UnixCCompiler.__init__(self, verbose, dry_run, force)
+
+        status, details = check_config_h()
+        self.debug_print("Python's GCC status: %s (details: %s)" %
+                         (status, details))
+        if status is not CONFIG_H_OK:
+            self.warn(
+                "Python's pyconfig.h doesn't seem to support your compiler. "
+                "Reason: %s. "
+                "Compiling may fail because of undefined preprocessor macros."
+                % details)
+
+        self.gcc_version, self.ld_version, self.dllwrap_version = \
+            get_versions()
+        self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" %
+                         (self.gcc_version,
+                          self.ld_version,
+                          self.dllwrap_version) )
+
+        # ld_version >= "2.10.90" and < "2.13" should also be able to use
+        # gcc -mdll instead of dllwrap
+        # Older dllwraps had own version numbers, newer ones use the
+        # same as the rest of binutils ( also ld )
+        # dllwrap 2.10.90 is buggy
+        if self.ld_version >= "2.10.90":
+            self.linker_dll = "gcc"
+        else:
+            self.linker_dll = "dllwrap"
+
+        # ld_version >= "2.13" support -shared so use it instead of
+        # -mdll -static
+        if self.ld_version >= "2.13":
+            shared_option = "-shared"
+        else:
+            shared_option = "-mdll -static"
+
+        # Hard-code GCC because that's what this is all about.
+        # XXX optimization, warnings etc. should be customizable.
+        self.set_executables(compiler='gcc -mcygwin -O -Wall',
+                             compiler_so='gcc -mcygwin -mdll -O -Wall',
+                             compiler_cxx='g++ -mcygwin -O -Wall',
+                             linker_exe='gcc -mcygwin',
+                             linker_so=('%s -mcygwin %s' %
+                                        (self.linker_dll, shared_option)))
+
+        # cygwin and mingw32 need different sets of libraries
+        if self.gcc_version == "2.91.57":
+            # cygwin shouldn't need msvcrt, but without the dlls will crash
+            # (gcc version 2.91.57) -- perhaps something about initialization
+            self.dll_libraries=["msvcrt"]
+            self.warn(
+                "Consider upgrading to a newer version of gcc")
+        else:
+            # Include the appropriate MSVC runtime library if Python was built
+            # with MSVC 7.0 or later.
+            self.dll_libraries = get_msvcr()
+
+    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
+        """Compiles the source by spawning GCC and windres if needed."""
+        if ext == '.rc' or ext == '.res':
+            # gcc needs '.res' and '.rc' compiled to object files !!!
+            try:
+                self.spawn(["windres", "-i", src, "-o", obj])
+            except DistutilsExecError as msg:
+                raise CompileError(msg)
+        else: # for other files use the C-compiler
+            try:
+                self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
+                           extra_postargs)
+            except DistutilsExecError as msg:
+                raise CompileError(msg)
+
+    def link(self, target_desc, objects, output_filename, output_dir=None,
+             libraries=None, library_dirs=None, runtime_library_dirs=None,
+             export_symbols=None, debug=0, extra_preargs=None,
+             extra_postargs=None, build_temp=None, target_lang=None):
+        """Link the objects."""
+        # use separate copies, so we can modify the lists
+        extra_preargs = copy.copy(extra_preargs or [])
+        libraries = copy.copy(libraries or [])
+        objects = copy.copy(objects or [])
+
+        # Additional libraries
+        libraries.extend(self.dll_libraries)
+
+        # handle export symbols by creating a def-file
+        # with executables this only works with gcc/ld as linker
+        if ((export_symbols is not None) and
+            (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
+            # (The linker doesn't do anything if output is up-to-date.
+            # So it would probably better to check if we really need this,
+            # but for this we had to insert some unchanged parts of
+            # UnixCCompiler, and this is not what we want.)
+
+            # we want to put some files in the same directory as the
+            # object files are, build_temp doesn't help much
+            # where are the object files
+            temp_dir = os.path.dirname(objects[0])
+            # name of dll to give the helper files the same base name
+            (dll_name, dll_extension) = os.path.splitext(
+                os.path.basename(output_filename))
+
+            # generate the filenames for these files
+            def_file = os.path.join(temp_dir, dll_name + ".def")
+            lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a")
+
+            # Generate .def file
+            contents = [
+                "LIBRARY %s" % os.path.basename(output_filename),
+                "EXPORTS"]
+            for sym in export_symbols:
+                contents.append(sym)
+            self.execute(write_file, (def_file, contents),
+                         "writing %s" % def_file)
+
+            # next add options for def-file and to creating import libraries
+
+            # dllwrap uses different options than gcc/ld
+            if self.linker_dll == "dllwrap":
+                extra_preargs.extend(["--output-lib", lib_file])
+                # for dllwrap we have to use a special option
+                extra_preargs.extend(["--def", def_file])
+            # we use gcc/ld here and can be sure ld is >= 2.9.10
+            else:
+                # doesn't work: bfd_close build\...\libfoo.a: Invalid operation
+                #extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file])
+                # for gcc/ld the def-file is specified as any object files
+                objects.append(def_file)
+
+        #end: if ((export_symbols is not None) and
+        #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
+
+        # who wants symbols and a many times larger output file
+        # should explicitly switch the debug mode on
+        # otherwise we let dllwrap/ld strip the output file
+        # (On my machine: 10KiB < stripped_file < ??100KiB
+        #   unstripped_file = stripped_file + XXX KiB
+        #  ( XXX=254 for a typical python extension))
+        if not debug:
+            extra_preargs.append("-s")
+
+        UnixCCompiler.link(self, target_desc, objects, output_filename,
+                           output_dir, libraries, library_dirs,
+                           runtime_library_dirs,
+                           None, # export_symbols, we do this in our def-file
+                           debug, extra_preargs, extra_postargs, build_temp,
+                           target_lang)
+
+    # -- Miscellaneous methods -----------------------------------------
+
+    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
+        """Adds supports for rc and res files."""
+        if output_dir is None:
+            output_dir = ''
+        obj_names = []
+        for src_name in source_filenames:
+            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
+            base, ext = os.path.splitext(os.path.normcase(src_name))
+            if ext not in (self.src_extensions + ['.rc','.res']):
+                raise UnknownFileError("unknown file type '%s' (from '%s')" % \
+                      (ext, src_name))
+            if strip_dir:
+                base = os.path.basename (base)
+            if ext in ('.res', '.rc'):
+                # these need to be compiled to object files
+                obj_names.append (os.path.join(output_dir,
+                                              base + ext + self.obj_extension))
+            else:
+                obj_names.append (os.path.join(output_dir,
+                                               base + self.obj_extension))
+        return obj_names
+
+# the same as cygwin plus some additional parameters
+class Mingw32CCompiler(CygwinCCompiler):
+    """ Handles the Mingw32 port of the GNU C compiler to Windows.
+    """
+    compiler_type = 'mingw32'
+
+    def __init__(self, verbose=0, dry_run=0, force=0):
+
+        CygwinCCompiler.__init__ (self, verbose, dry_run, force)
+
+        # ld_version >= "2.13" support -shared so use it instead of
+        # -mdll -static
+        if self.ld_version >= "2.13":
+            shared_option = "-shared"
+        else:
+            shared_option = "-mdll -static"
+
+        # A real mingw32 doesn't need to specify a different entry point,
+        # but cygwin 2.91.57 in no-cygwin-mode needs it.
+        if self.gcc_version <= "2.91.57":
+            entry_point = '--entry _DllMain@12'
+        else:
+            entry_point = ''
+
+        if is_cygwingcc():
+            raise CCompilerError(
+                'Cygwin gcc cannot be used with --compiler=mingw32')
+
+        self.set_executables(compiler='gcc -O -Wall',
+                             compiler_so='gcc -mdll -O -Wall',
+                             compiler_cxx='g++ -O -Wall',
+                             linker_exe='gcc',
+                             linker_so='%s %s %s'
+                                        % (self.linker_dll, shared_option,
+                                           entry_point))
+        # Maybe we should also append -mthreads, but then the finished
+        # dlls need another dll (mingwm10.dll see Mingw32 docs)
+        # (-mthreads: Support thread-safe exception handling on `Mingw32')
+
+        # no additional libraries needed
+        self.dll_libraries=[]
+
+        # Include the appropriate MSVC runtime library if Python was built
+        # with MSVC 7.0 or later.
+        self.dll_libraries = get_msvcr()
+
+# Because these compilers aren't configured in Python's pyconfig.h file by
+# default, we should at least warn the user if he is using an unmodified
+# version.
+
+CONFIG_H_OK = "ok"
+CONFIG_H_NOTOK = "not ok"
+CONFIG_H_UNCERTAIN = "uncertain"
+
+def check_config_h():
+    """Check if the current Python installation appears amenable to building
+    extensions with GCC.
+
+    Returns a tuple (status, details), where 'status' is one of the following
+    constants:
+
+    - CONFIG_H_OK: all is well, go ahead and compile
+    - CONFIG_H_NOTOK: doesn't look good
+    - CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h
+
+    'details' is a human-readable string explaining the situation.
+
+    Note there are two ways to conclude "OK": either 'sys.version' contains
+    the string "GCC" (implying that this Python was built with GCC), or the
+    installed "pyconfig.h" contains the string "__GNUC__".
+    """
+
+    # XXX since this function also checks sys.version, it's not strictly a
+    # "pyconfig.h" check -- should probably be renamed...
+
+    from distutils import sysconfig
+
+    # if sys.version contains GCC then python was compiled with GCC, and the
+    # pyconfig.h file should be OK
+    if "GCC" in sys.version:
+        return CONFIG_H_OK, "sys.version mentions 'GCC'"
+
+    # let's see if __GNUC__ is mentioned in python.h
+    fn = sysconfig.get_config_h_filename()
+    try:
+        config_h = open(fn)
+        try:
+            if "__GNUC__" in config_h.read():
+                return CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn
+            else:
+                return CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn
+        finally:
+            config_h.close()
+    except OSError as exc:
+        return (CONFIG_H_UNCERTAIN,
+                "couldn't read '%s': %s" % (fn, exc.strerror))
+
+RE_VERSION = re.compile(br'(\d+\.\d+(\.\d+)*)')
+
+def _find_exe_version(cmd):
+    """Find the version of an executable by running `cmd` in the shell.
+
+    If the command is not found, or the output does not match
+    `RE_VERSION`, returns None.
+    """
+    executable = cmd.split()[0]
+    if find_executable(executable) is None:
+        return None
+    out = Popen(cmd, shell=True, stdout=PIPE).stdout
+    try:
+        out_string = out.read()
+    finally:
+        out.close()
+    result = RE_VERSION.search(out_string)
+    if result is None:
+        return None
+    # LooseVersion works with strings
+    # so we need to decode our bytes
+    return LooseVersion(result.group(1).decode())
+
+def get_versions():
+    """ Try to find out the versions of gcc, ld and dllwrap.
+
+    If not possible it returns None for it.
+    """
+    commands = ['gcc -dumpversion', 'ld -v', 'dllwrap --version']
+    return tuple([_find_exe_version(cmd) for cmd in commands])
+
+def is_cygwingcc():
+    '''Try to determine if the gcc that would be used is from cygwin.'''
+    out_string = check_output(['gcc', '-dumpmachine'])
+    return out_string.strip().endswith(b'cygwin')
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/debug.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/debug.py
new file mode 100644
index 0000000..daf1660
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/debug.py
@@ -0,0 +1,5 @@
+import os
+
+# If DISTUTILS_DEBUG is anything other than the empty string, we run in
+# debug mode.
+DEBUG = os.environ.get('DISTUTILS_DEBUG')
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/dep_util.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/dep_util.py
new file mode 100644
index 0000000..d74f5e4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/dep_util.py
@@ -0,0 +1,92 @@
+"""distutils.dep_util
+
+Utility functions for simple, timestamp-based dependency of files
+and groups of files; also, function based entirely on such
+timestamp dependency analysis."""
+
+import os
+from distutils.errors import DistutilsFileError
+
+
+def newer (source, target):
+    """Return true if 'source' exists and is more recently modified than
+    'target', or if 'source' exists and 'target' doesn't.  Return false if
+    both exist and 'target' is the same age or younger than 'source'.
+    Raise DistutilsFileError if 'source' does not exist.
+    """
+    if not os.path.exists(source):
+        raise DistutilsFileError("file '%s' does not exist" %
+                                 os.path.abspath(source))
+    if not os.path.exists(target):
+        return 1
+
+    from stat import ST_MTIME
+    mtime1 = os.stat(source)[ST_MTIME]
+    mtime2 = os.stat(target)[ST_MTIME]
+
+    return mtime1 > mtime2
+
+# newer ()
+
+
+def newer_pairwise (sources, targets):
+    """Walk two filename lists in parallel, testing if each source is newer
+    than its corresponding target.  Return a pair of lists (sources,
+    targets) where source is newer than target, according to the semantics
+    of 'newer()'.
+    """
+    if len(sources) != len(targets):
+        raise ValueError("'sources' and 'targets' must be same length")
+
+    # build a pair of lists (sources, targets) where  source is newer
+    n_sources = []
+    n_targets = []
+    for i in range(len(sources)):
+        if newer(sources[i], targets[i]):
+            n_sources.append(sources[i])
+            n_targets.append(targets[i])
+
+    return (n_sources, n_targets)
+
+# newer_pairwise ()
+
+
+def newer_group (sources, target, missing='error'):
+    """Return true if 'target' is out-of-date with respect to any file
+    listed in 'sources'.  In other words, if 'target' exists and is newer
+    than every file in 'sources', return false; otherwise return true.
+    'missing' controls what we do when a source file is missing; the
+    default ("error") is to blow up with an OSError from inside 'stat()';
+    if it is "ignore", we silently drop any missing source files; if it is
+    "newer", any missing source files make us assume that 'target' is
+    out-of-date (this is handy in "dry-run" mode: it'll make you pretend to
+    carry out commands that wouldn't work because inputs are missing, but
+    that doesn't matter because you're not actually going to run the
+    commands).
+    """
+    # If the target doesn't even exist, then it's definitely out-of-date.
+    if not os.path.exists(target):
+        return 1
+
+    # Otherwise we have to find out the hard way: if *any* source file
+    # is more recent than 'target', then 'target' is out-of-date and
+    # we can immediately return true.  If we fall through to the end
+    # of the loop, then 'target' is up-to-date and we return false.
+    from stat import ST_MTIME
+    target_mtime = os.stat(target)[ST_MTIME]
+    for source in sources:
+        if not os.path.exists(source):
+            if missing == 'error':      # blow up when we stat() the file
+                pass
+            elif missing == 'ignore':   # missing source dropped from
+                continue                #  target's dependency list
+            elif missing == 'newer':    # missing source means target is
+                return 1                #  out-of-date
+
+        source_mtime = os.stat(source)[ST_MTIME]
+        if source_mtime > target_mtime:
+            return 1
+    else:
+        return 0
+
+# newer_group ()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/dir_util.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/dir_util.py
new file mode 100644
index 0000000..d5cd8e3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/dir_util.py
@@ -0,0 +1,210 @@
+"""distutils.dir_util
+
+Utility functions for manipulating directories and directory trees."""
+
+import os
+import errno
+from distutils.errors import DistutilsFileError, DistutilsInternalError
+from distutils import log
+
+# cache for by mkpath() -- in addition to cheapening redundant calls,
+# eliminates redundant "creating /foo/bar/baz" messages in dry-run mode
+_path_created = {}
+
+# I don't use os.makedirs because a) it's new to Python 1.5.2, and
+# b) it blows up if the directory already exists (I want to silently
+# succeed in that case).
+def mkpath(name, mode=0o777, verbose=1, dry_run=0):
+    """Create a directory and any missing ancestor directories.
+
+    If the directory already exists (or if 'name' is the empty string, which
+    means the current directory, which of course exists), then do nothing.
+    Raise DistutilsFileError if unable to create some directory along the way
+    (eg. some sub-path exists, but is a file rather than a directory).
+    If 'verbose' is true, print a one-line summary of each mkdir to stdout.
+    Return the list of directories actually created.
+    """
+
+    global _path_created
+
+    # Detect a common bug -- name is None
+    if not isinstance(name, str):
+        raise DistutilsInternalError(
+              "mkpath: 'name' must be a string (got %r)" % (name,))
+
+    # XXX what's the better way to handle verbosity? print as we create
+    # each directory in the path (the current behaviour), or only announce
+    # the creation of the whole path? (quite easy to do the latter since
+    # we're not using a recursive algorithm)
+
+    name = os.path.normpath(name)
+    created_dirs = []
+    if os.path.isdir(name) or name == '':
+        return created_dirs
+    if _path_created.get(os.path.abspath(name)):
+        return created_dirs
+
+    (head, tail) = os.path.split(name)
+    tails = [tail]                      # stack of lone dirs to create
+
+    while head and tail and not os.path.isdir(head):
+        (head, tail) = os.path.split(head)
+        tails.insert(0, tail)          # push next higher dir onto stack
+
+    # now 'head' contains the deepest directory that already exists
+    # (that is, the child of 'head' in 'name' is the highest directory
+    # that does *not* exist)
+    for d in tails:
+        #print "head = %s, d = %s: " % (head, d),
+        head = os.path.join(head, d)
+        abs_head = os.path.abspath(head)
+
+        if _path_created.get(abs_head):
+            continue
+
+        if verbose >= 1:
+            log.info("creating %s", head)
+
+        if not dry_run:
+            try:
+                os.mkdir(head, mode)
+            except OSError as exc:
+                if not (exc.errno == errno.EEXIST and os.path.isdir(head)):
+                    raise DistutilsFileError(
+                          "could not create '%s': %s" % (head, exc.args[-1]))
+            created_dirs.append(head)
+
+        _path_created[abs_head] = 1
+    return created_dirs
+
+def create_tree(base_dir, files, mode=0o777, verbose=1, dry_run=0):
+    """Create all the empty directories under 'base_dir' needed to put 'files'
+    there.
+
+    'base_dir' is just the name of a directory which doesn't necessarily
+    exist yet; 'files' is a list of filenames to be interpreted relative to
+    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
+    will be created if it doesn't already exist.  'mode', 'verbose' and
+    'dry_run' flags are as for 'mkpath()'.
+    """
+    # First get the list of directories to create
+    need_dir = set()
+    for file in files:
+        need_dir.add(os.path.join(base_dir, os.path.dirname(file)))
+
+    # Now create them
+    for dir in sorted(need_dir):
+        mkpath(dir, mode, verbose=verbose, dry_run=dry_run)
+
+def copy_tree(src, dst, preserve_mode=1, preserve_times=1,
+              preserve_symlinks=0, update=0, verbose=1, dry_run=0):
+    """Copy an entire directory tree 'src' to a new location 'dst'.
+
+    Both 'src' and 'dst' must be directory names.  If 'src' is not a
+    directory, raise DistutilsFileError.  If 'dst' does not exist, it is
+    created with 'mkpath()'.  The end result of the copy is that every
+    file in 'src' is copied to 'dst', and directories under 'src' are
+    recursively copied to 'dst'.  Return the list of files that were
+    copied or might have been copied, using their output name.  The
+    return value is unaffected by 'update' or 'dry_run': it is simply
+    the list of all files under 'src', with the names changed to be
+    under 'dst'.
+
+    'preserve_mode' and 'preserve_times' are the same as for
+    'copy_file'; note that they only apply to regular files, not to
+    directories.  If 'preserve_symlinks' is true, symlinks will be
+    copied as symlinks (on platforms that support them!); otherwise
+    (the default), the destination of the symlink will be copied.
+    'update' and 'verbose' are the same as for 'copy_file'.
+    """
+    from distutils.file_util import copy_file
+
+    if not dry_run and not os.path.isdir(src):
+        raise DistutilsFileError(
+              "cannot copy tree '%s': not a directory" % src)
+    try:
+        names = os.listdir(src)
+    except OSError as e:
+        if dry_run:
+            names = []
+        else:
+            raise DistutilsFileError(
+                  "error listing files in '%s': %s" % (src, e.strerror))
+
+    if not dry_run:
+        mkpath(dst, verbose=verbose)
+
+    outputs = []
+
+    for n in names:
+        src_name = os.path.join(src, n)
+        dst_name = os.path.join(dst, n)
+
+        if n.startswith('.nfs'):
+            # skip NFS rename files
+            continue
+
+        if preserve_symlinks and os.path.islink(src_name):
+            link_dest = os.readlink(src_name)
+            if verbose >= 1:
+                log.info("linking %s -> %s", dst_name, link_dest)
+            if not dry_run:
+                os.symlink(link_dest, dst_name)
+            outputs.append(dst_name)
+
+        elif os.path.isdir(src_name):
+            outputs.extend(
+                copy_tree(src_name, dst_name, preserve_mode,
+                          preserve_times, preserve_symlinks, update,
+                          verbose=verbose, dry_run=dry_run))
+        else:
+            copy_file(src_name, dst_name, preserve_mode,
+                      preserve_times, update, verbose=verbose,
+                      dry_run=dry_run)
+            outputs.append(dst_name)
+
+    return outputs
+
+def _build_cmdtuple(path, cmdtuples):
+    """Helper for remove_tree()."""
+    for f in os.listdir(path):
+        real_f = os.path.join(path,f)
+        if os.path.isdir(real_f) and not os.path.islink(real_f):
+            _build_cmdtuple(real_f, cmdtuples)
+        else:
+            cmdtuples.append((os.remove, real_f))
+    cmdtuples.append((os.rmdir, path))
+
+def remove_tree(directory, verbose=1, dry_run=0):
+    """Recursively remove an entire directory tree.
+
+    Any errors are ignored (apart from being reported to stdout if 'verbose'
+    is true).
+    """
+    global _path_created
+
+    if verbose >= 1:
+        log.info("removing '%s' (and everything under it)", directory)
+    if dry_run:
+        return
+    cmdtuples = []
+    _build_cmdtuple(directory, cmdtuples)
+    for cmd in cmdtuples:
+        try:
+            cmd[0](cmd[1])
+            # remove dir from cache if it's already there
+            abspath = os.path.abspath(cmd[1])
+            if abspath in _path_created:
+                del _path_created[abspath]
+        except OSError as exc:
+            log.warn("error removing %s: %s", directory, exc)
+
+def ensure_relative(path):
+    """Take the full path 'path', and make it a relative path.
+
+    This is useful to make 'path' the second argument to os.path.join().
+    """
+    drive, path = os.path.splitdrive(path)
+    if path[0:1] == os.sep:
+        path = drive + path[1:]
+    return path
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/dist.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/dist.py
new file mode 100644
index 0000000..37db4d6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/dist.py
@@ -0,0 +1,1257 @@
+"""distutils.dist
+
+Provides the Distribution class, which represents the module distribution
+being built/installed/distributed.
+"""
+
+import sys
+import os
+import re
+from email import message_from_file
+
+try:
+    import warnings
+except ImportError:
+    warnings = None
+
+from distutils.errors import *
+from distutils.fancy_getopt import FancyGetopt, translate_longopt
+from distutils.util import check_environ, strtobool, rfc822_escape
+from distutils import log
+from distutils.debug import DEBUG
+
+# Regex to define acceptable Distutils command names.  This is not *quite*
+# the same as a Python NAME -- I don't allow leading underscores.  The fact
+# that they're very similar is no coincidence; the default naming scheme is
+# to look for a Python module named after the command.
+command_re = re.compile(r'^[a-zA-Z]([a-zA-Z0-9_]*)$')
+
+
+def _ensure_list(value, fieldname):
+    if isinstance(value, str):
+        # a string containing comma separated values is okay.  It will
+        # be converted to a list by Distribution.finalize_options().
+        pass
+    elif not isinstance(value, list):
+        # passing a tuple or an iterator perhaps, warn and convert
+        typename = type(value).__name__
+        msg = "Warning: '{fieldname}' should be a list, got type '{typename}'"
+        msg = msg.format(**locals())
+        log.log(log.WARN, msg)
+        value = list(value)
+    return value
+
+
+class Distribution:
+    """The core of the Distutils.  Most of the work hiding behind 'setup'
+    is really done within a Distribution instance, which farms the work out
+    to the Distutils commands specified on the command line.
+
+    Setup scripts will almost never instantiate Distribution directly,
+    unless the 'setup()' function is totally inadequate to their needs.
+    However, it is conceivable that a setup script might wish to subclass
+    Distribution for some specialized purpose, and then pass the subclass
+    to 'setup()' as the 'distclass' keyword argument.  If so, it is
+    necessary to respect the expectations that 'setup' has of Distribution.
+    See the code for 'setup()', in core.py, for details.
+    """
+
+    # 'global_options' describes the command-line options that may be
+    # supplied to the setup script prior to any actual commands.
+    # Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of
+    # these global options.  This list should be kept to a bare minimum,
+    # since every global option is also valid as a command option -- and we
+    # don't want to pollute the commands with too many options that they
+    # have minimal control over.
+    # The fourth entry for verbose means that it can be repeated.
+    global_options = [
+        ('verbose', 'v', "run verbosely (default)", 1),
+        ('quiet', 'q', "run quietly (turns verbosity off)"),
+        ('dry-run', 'n', "don't actually do anything"),
+        ('help', 'h', "show detailed help message"),
+        ('no-user-cfg', None,
+            'ignore pydistutils.cfg in your home directory'),
+    ]
+
+    # 'common_usage' is a short (2-3 line) string describing the common
+    # usage of the setup script.
+    common_usage = """\
+Common commands: (see '--help-commands' for more)
+
+  setup.py build      will build the package underneath 'build/'
+  setup.py install    will install the package
+"""
+
+    # options that are not propagated to the commands
+    display_options = [
+        ('help-commands', None,
+         "list all available commands"),
+        ('name', None,
+         "print package name"),
+        ('version', 'V',
+         "print package version"),
+        ('fullname', None,
+         "print <package name>-<version>"),
+        ('author', None,
+         "print the author's name"),
+        ('author-email', None,
+         "print the author's email address"),
+        ('maintainer', None,
+         "print the maintainer's name"),
+        ('maintainer-email', None,
+         "print the maintainer's email address"),
+        ('contact', None,
+         "print the maintainer's name if known, else the author's"),
+        ('contact-email', None,
+         "print the maintainer's email address if known, else the author's"),
+        ('url', None,
+         "print the URL for this package"),
+        ('license', None,
+         "print the license of the package"),
+        ('licence', None,
+         "alias for --license"),
+        ('description', None,
+         "print the package description"),
+        ('long-description', None,
+         "print the long package description"),
+        ('platforms', None,
+         "print the list of platforms"),
+        ('classifiers', None,
+         "print the list of classifiers"),
+        ('keywords', None,
+         "print the list of keywords"),
+        ('provides', None,
+         "print the list of packages/modules provided"),
+        ('requires', None,
+         "print the list of packages/modules required"),
+        ('obsoletes', None,
+         "print the list of packages/modules made obsolete")
+        ]
+    display_option_names = [translate_longopt(x[0]) for x in display_options]
+
+    # negative options are options that exclude other options
+    negative_opt = {'quiet': 'verbose'}
+
+    # -- Creation/initialization methods -------------------------------
+
+    def __init__(self, attrs=None):
+        """Construct a new Distribution instance: initialize all the
+        attributes of a Distribution, and then use 'attrs' (a dictionary
+        mapping attribute names to values) to assign some of those
+        attributes their "real" values.  (Any attributes not mentioned in
+        'attrs' will be assigned to some null value: 0, None, an empty list
+        or dictionary, etc.)  Most importantly, initialize the
+        'command_obj' attribute to the empty dictionary; this will be
+        filled in with real command objects by 'parse_command_line()'.
+        """
+
+        # Default values for our command-line options
+        self.verbose = 1
+        self.dry_run = 0
+        self.help = 0
+        for attr in self.display_option_names:
+            setattr(self, attr, 0)
+
+        # Store the distribution meta-data (name, version, author, and so
+        # forth) in a separate object -- we're getting to have enough
+        # information here (and enough command-line options) that it's
+        # worth it.  Also delegate 'get_XXX()' methods to the 'metadata'
+        # object in a sneaky and underhanded (but efficient!) way.
+        self.metadata = DistributionMetadata()
+        for basename in self.metadata._METHOD_BASENAMES:
+            method_name = "get_" + basename
+            setattr(self, method_name, getattr(self.metadata, method_name))
+
+        # 'cmdclass' maps command names to class objects, so we
+        # can 1) quickly figure out which class to instantiate when
+        # we need to create a new command object, and 2) have a way
+        # for the setup script to override command classes
+        self.cmdclass = {}
+
+        # 'command_packages' is a list of packages in which commands
+        # are searched for.  The factory for command 'foo' is expected
+        # to be named 'foo' in the module 'foo' in one of the packages
+        # named here.  This list is searched from the left; an error
+        # is raised if no named package provides the command being
+        # searched for.  (Always access using get_command_packages().)
+        self.command_packages = None
+
+        # 'script_name' and 'script_args' are usually set to sys.argv[0]
+        # and sys.argv[1:], but they can be overridden when the caller is
+        # not necessarily a setup script run from the command-line.
+        self.script_name = None
+        self.script_args = None
+
+        # 'command_options' is where we store command options between
+        # parsing them (from config files, the command-line, etc.) and when
+        # they are actually needed -- ie. when the command in question is
+        # instantiated.  It is a dictionary of dictionaries of 2-tuples:
+        #   command_options = { command_name : { option : (source, value) } }
+        self.command_options = {}
+
+        # 'dist_files' is the list of (command, pyversion, file) that
+        # have been created by any dist commands run so far. This is
+        # filled regardless of whether the run is dry or not. pyversion
+        # gives sysconfig.get_python_version() if the dist file is
+        # specific to a Python version, 'any' if it is good for all
+        # Python versions on the target platform, and '' for a source
+        # file. pyversion should not be used to specify minimum or
+        # maximum required Python versions; use the metainfo for that
+        # instead.
+        self.dist_files = []
+
+        # These options are really the business of various commands, rather
+        # than of the Distribution itself.  We provide aliases for them in
+        # Distribution as a convenience to the developer.
+        self.packages = None
+        self.package_data = {}
+        self.package_dir = None
+        self.py_modules = None
+        self.libraries = None
+        self.headers = None
+        self.ext_modules = None
+        self.ext_package = None
+        self.include_dirs = None
+        self.extra_path = None
+        self.scripts = None
+        self.data_files = None
+        self.password = ''
+
+        # And now initialize bookkeeping stuff that can't be supplied by
+        # the caller at all.  'command_obj' maps command names to
+        # Command instances -- that's how we enforce that every command
+        # class is a singleton.
+        self.command_obj = {}
+
+        # 'have_run' maps command names to boolean values; it keeps track
+        # of whether we have actually run a particular command, to make it
+        # cheap to "run" a command whenever we think we might need to -- if
+        # it's already been done, no need for expensive filesystem
+        # operations, we just check the 'have_run' dictionary and carry on.
+        # It's only safe to query 'have_run' for a command class that has
+        # been instantiated -- a false value will be inserted when the
+        # command object is created, and replaced with a true value when
+        # the command is successfully run.  Thus it's probably best to use
+        # '.get()' rather than a straight lookup.
+        self.have_run = {}
+
+        # Now we'll use the attrs dictionary (ultimately, keyword args from
+        # the setup script) to possibly override any or all of these
+        # distribution options.
+
+        if attrs:
+            # Pull out the set of command options and work on them
+            # specifically.  Note that this order guarantees that aliased
+            # command options will override any supplied redundantly
+            # through the general options dictionary.
+            options = attrs.get('options')
+            if options is not None:
+                del attrs['options']
+                for (command, cmd_options) in options.items():
+                    opt_dict = self.get_option_dict(command)
+                    for (opt, val) in cmd_options.items():
+                        opt_dict[opt] = ("setup script", val)
+
+            if 'licence' in attrs:
+                attrs['license'] = attrs['licence']
+                del attrs['licence']
+                msg = "'licence' distribution option is deprecated; use 'license'"
+                if warnings is not None:
+                    warnings.warn(msg)
+                else:
+                    sys.stderr.write(msg + "\n")
+
+            # Now work on the rest of the attributes.  Any attribute that's
+            # not already defined is invalid!
+            for (key, val) in attrs.items():
+                if hasattr(self.metadata, "set_" + key):
+                    getattr(self.metadata, "set_" + key)(val)
+                elif hasattr(self.metadata, key):
+                    setattr(self.metadata, key, val)
+                elif hasattr(self, key):
+                    setattr(self, key, val)
+                else:
+                    msg = "Unknown distribution option: %s" % repr(key)
+                    warnings.warn(msg)
+
+        # no-user-cfg is handled before other command line args
+        # because other args override the config files, and this
+        # one is needed before we can load the config files.
+        # If attrs['script_args'] wasn't passed, assume false.
+        #
+        # This also make sure we just look at the global options
+        self.want_user_cfg = True
+
+        if self.script_args is not None:
+            for arg in self.script_args:
+                if not arg.startswith('-'):
+                    break
+                if arg == '--no-user-cfg':
+                    self.want_user_cfg = False
+                    break
+
+        self.finalize_options()
+
+    def get_option_dict(self, command):
+        """Get the option dictionary for a given command.  If that
+        command's option dictionary hasn't been created yet, then create it
+        and return the new dictionary; otherwise, return the existing
+        option dictionary.
+        """
+        dict = self.command_options.get(command)
+        if dict is None:
+            dict = self.command_options[command] = {}
+        return dict
+
+    def dump_option_dicts(self, header=None, commands=None, indent=""):
+        from pprint import pformat
+
+        if commands is None:             # dump all command option dicts
+            commands = sorted(self.command_options.keys())
+
+        if header is not None:
+            self.announce(indent + header)
+            indent = indent + "  "
+
+        if not commands:
+            self.announce(indent + "no commands known yet")
+            return
+
+        for cmd_name in commands:
+            opt_dict = self.command_options.get(cmd_name)
+            if opt_dict is None:
+                self.announce(indent +
+                              "no option dict for '%s' command" % cmd_name)
+            else:
+                self.announce(indent +
+                              "option dict for '%s' command:" % cmd_name)
+                out = pformat(opt_dict)
+                for line in out.split('\n'):
+                    self.announce(indent + "  " + line)
+
+    # -- Config file finding/parsing methods ---------------------------
+
+    def find_config_files(self):
+        """Find as many configuration files as should be processed for this
+        platform, and return a list of filenames in the order in which they
+        should be parsed.  The filenames returned are guaranteed to exist
+        (modulo nasty race conditions).
+
+        There are three possible config files: distutils.cfg in the
+        Distutils installation directory (ie. where the top-level
+        Distutils __inst__.py file lives), a file in the user's home
+        directory named .pydistutils.cfg on Unix and pydistutils.cfg
+        on Windows/Mac; and setup.cfg in the current directory.
+
+        The file in the user's home directory can be disabled with the
+        --no-user-cfg option.
+        """
+        files = []
+        check_environ()
+
+        # Where to look for the system-wide Distutils config file
+        sys_dir = os.path.dirname(sys.modules['distutils'].__file__)
+
+        # Look for the system config file
+        sys_file = os.path.join(sys_dir, "distutils.cfg")
+        if os.path.isfile(sys_file):
+            files.append(sys_file)
+
+        # What to call the per-user config file
+        if os.name == 'posix':
+            user_filename = ".pydistutils.cfg"
+        else:
+            user_filename = "pydistutils.cfg"
+
+        # And look for the user config file
+        if self.want_user_cfg:
+            user_file = os.path.join(os.path.expanduser('~'), user_filename)
+            if os.path.isfile(user_file):
+                files.append(user_file)
+
+        # All platforms support local setup.cfg
+        local_file = "setup.cfg"
+        if os.path.isfile(local_file):
+            files.append(local_file)
+
+        if DEBUG:
+            self.announce("using config files: %s" % ', '.join(files))
+
+        return files
+
+    def parse_config_files(self, filenames=None):
+        from configparser import ConfigParser
+
+        # Ignore install directory options if we have a venv
+        if sys.prefix != sys.base_prefix:
+            ignore_options = [
+                'install-base', 'install-platbase', 'install-lib',
+                'install-platlib', 'install-purelib', 'install-headers',
+                'install-scripts', 'install-data', 'prefix', 'exec-prefix',
+                'home', 'user', 'root']
+        else:
+            ignore_options = []
+
+        ignore_options = frozenset(ignore_options)
+
+        if filenames is None:
+            filenames = self.find_config_files()
+
+        if DEBUG:
+            self.announce("Distribution.parse_config_files():")
+
+        parser = ConfigParser()
+        for filename in filenames:
+            if DEBUG:
+                self.announce("  reading %s" % filename)
+            parser.read(filename)
+            for section in parser.sections():
+                options = parser.options(section)
+                opt_dict = self.get_option_dict(section)
+
+                for opt in options:
+                    if opt != '__name__' and opt not in ignore_options:
+                        val = parser.get(section,opt)
+                        opt = opt.replace('-', '_')
+                        opt_dict[opt] = (filename, val)
+
+            # Make the ConfigParser forget everything (so we retain
+            # the original filenames that options come from)
+            parser.__init__()
+
+        # If there was a "global" section in the config file, use it
+        # to set Distribution options.
+
+        if 'global' in self.command_options:
+            for (opt, (src, val)) in self.command_options['global'].items():
+                alias = self.negative_opt.get(opt)
+                try:
+                    if alias:
+                        setattr(self, alias, not strtobool(val))
+                    elif opt in ('verbose', 'dry_run'): # ugh!
+                        setattr(self, opt, strtobool(val))
+                    else:
+                        setattr(self, opt, val)
+                except ValueError as msg:
+                    raise DistutilsOptionError(msg)
+
+    # -- Command-line parsing methods ----------------------------------
+
+    def parse_command_line(self):
+        """Parse the setup script's command line, taken from the
+        'script_args' instance attribute (which defaults to 'sys.argv[1:]'
+        -- see 'setup()' in core.py).  This list is first processed for
+        "global options" -- options that set attributes of the Distribution
+        instance.  Then, it is alternately scanned for Distutils commands
+        and options for that command.  Each new command terminates the
+        options for the previous command.  The allowed options for a
+        command are determined by the 'user_options' attribute of the
+        command class -- thus, we have to be able to load command classes
+        in order to parse the command line.  Any error in that 'options'
+        attribute raises DistutilsGetoptError; any error on the
+        command-line raises DistutilsArgError.  If no Distutils commands
+        were found on the command line, raises DistutilsArgError.  Return
+        true if command-line was successfully parsed and we should carry
+        on with executing commands; false if no errors but we shouldn't
+        execute commands (currently, this only happens if user asks for
+        help).
+        """
+        #
+        # We now have enough information to show the Macintosh dialog
+        # that allows the user to interactively specify the "command line".
+        #
+        toplevel_options = self._get_toplevel_options()
+
+        # We have to parse the command line a bit at a time -- global
+        # options, then the first command, then its options, and so on --
+        # because each command will be handled by a different class, and
+        # the options that are valid for a particular class aren't known
+        # until we have loaded the command class, which doesn't happen
+        # until we know what the command is.
+
+        self.commands = []
+        parser = FancyGetopt(toplevel_options + self.display_options)
+        parser.set_negative_aliases(self.negative_opt)
+        parser.set_aliases({'licence': 'license'})
+        args = parser.getopt(args=self.script_args, object=self)
+        option_order = parser.get_option_order()
+        log.set_verbosity(self.verbose)
+
+        # for display options we return immediately
+        if self.handle_display_options(option_order):
+            return
+        while args:
+            args = self._parse_command_opts(parser, args)
+            if args is None:            # user asked for help (and got it)
+                return
+
+        # Handle the cases of --help as a "global" option, ie.
+        # "setup.py --help" and "setup.py --help command ...".  For the
+        # former, we show global options (--verbose, --dry-run, etc.)
+        # and display-only options (--name, --version, etc.); for the
+        # latter, we omit the display-only options and show help for
+        # each command listed on the command line.
+        if self.help:
+            self._show_help(parser,
+                            display_options=len(self.commands) == 0,
+                            commands=self.commands)
+            return
+
+        # Oops, no commands found -- an end-user error
+        if not self.commands:
+            raise DistutilsArgError("no commands supplied")
+
+        # All is well: return true
+        return True
+
+    def _get_toplevel_options(self):
+        """Return the non-display options recognized at the top level.
+
+        This includes options that are recognized *only* at the top
+        level as well as options recognized for commands.
+        """
+        return self.global_options + [
+            ("command-packages=", None,
+             "list of packages that provide distutils commands"),
+            ]
+
+    def _parse_command_opts(self, parser, args):
+        """Parse the command-line options for a single command.
+        'parser' must be a FancyGetopt instance; 'args' must be the list
+        of arguments, starting with the current command (whose options
+        we are about to parse).  Returns a new version of 'args' with
+        the next command at the front of the list; will be the empty
+        list if there are no more commands on the command line.  Returns
+        None if the user asked for help on this command.
+        """
+        # late import because of mutual dependence between these modules
+        from distutils.cmd import Command
+
+        # Pull the current command from the head of the command line
+        command = args[0]
+        if not command_re.match(command):
+            raise SystemExit("invalid command name '%s'" % command)
+        self.commands.append(command)
+
+        # Dig up the command class that implements this command, so we
+        # 1) know that it's a valid command, and 2) know which options
+        # it takes.
+        try:
+            cmd_class = self.get_command_class(command)
+        except DistutilsModuleError as msg:
+            raise DistutilsArgError(msg)
+
+        # Require that the command class be derived from Command -- want
+        # to be sure that the basic "command" interface is implemented.
+        if not issubclass(cmd_class, Command):
+            raise DistutilsClassError(
+                "command class %s must subclass Command" % cmd_class)
+
+        # Also make sure that the command object provides a list of its
+        # known options.
+        if not (hasattr(cmd_class, 'user_options') and
+                isinstance(cmd_class.user_options, list)):
+            msg = ("command class %s must provide "
+                "'user_options' attribute (a list of tuples)")
+            raise DistutilsClassError(msg % cmd_class)
+
+        # If the command class has a list of negative alias options,
+        # merge it in with the global negative aliases.
+        negative_opt = self.negative_opt
+        if hasattr(cmd_class, 'negative_opt'):
+            negative_opt = negative_opt.copy()
+            negative_opt.update(cmd_class.negative_opt)
+
+        # Check for help_options in command class.  They have a different
+        # format (tuple of four) so we need to preprocess them here.
+        if (hasattr(cmd_class, 'help_options') and
+                isinstance(cmd_class.help_options, list)):
+            help_options = fix_help_options(cmd_class.help_options)
+        else:
+            help_options = []
+
+        # All commands support the global options too, just by adding
+        # in 'global_options'.
+        parser.set_option_table(self.global_options +
+                                cmd_class.user_options +
+                                help_options)
+        parser.set_negative_aliases(negative_opt)
+        (args, opts) = parser.getopt(args[1:])
+        if hasattr(opts, 'help') and opts.help:
+            self._show_help(parser, display_options=0, commands=[cmd_class])
+            return
+
+        if (hasattr(cmd_class, 'help_options') and
+                isinstance(cmd_class.help_options, list)):
+            help_option_found=0
+            for (help_option, short, desc, func) in cmd_class.help_options:
+                if hasattr(opts, parser.get_attr_name(help_option)):
+                    help_option_found=1
+                    if callable(func):
+                        func()
+                    else:
+                        raise DistutilsClassError(
+                            "invalid help function %r for help option '%s': "
+                            "must be a callable object (function, etc.)"
+                            % (func, help_option))
+
+            if help_option_found:
+                return
+
+        # Put the options from the command-line into their official
+        # holding pen, the 'command_options' dictionary.
+        opt_dict = self.get_option_dict(command)
+        for (name, value) in vars(opts).items():
+            opt_dict[name] = ("command line", value)
+
+        return args
+
+    def finalize_options(self):
+        """Set final values for all the options on the Distribution
+        instance, analogous to the .finalize_options() method of Command
+        objects.
+        """
+        for attr in ('keywords', 'platforms'):
+            value = getattr(self.metadata, attr)
+            if value is None:
+                continue
+            if isinstance(value, str):
+                value = [elm.strip() for elm in value.split(',')]
+                setattr(self.metadata, attr, value)
+
+    def _show_help(self, parser, global_options=1, display_options=1,
+                   commands=[]):
+        """Show help for the setup script command-line in the form of
+        several lists of command-line options.  'parser' should be a
+        FancyGetopt instance; do not expect it to be returned in the
+        same state, as its option table will be reset to make it
+        generate the correct help text.
+
+        If 'global_options' is true, lists the global options:
+        --verbose, --dry-run, etc.  If 'display_options' is true, lists
+        the "display-only" options: --name, --version, etc.  Finally,
+        lists per-command help for every command name or command class
+        in 'commands'.
+        """
+        # late import because of mutual dependence between these modules
+        from distutils.core import gen_usage
+        from distutils.cmd import Command
+
+        if global_options:
+            if display_options:
+                options = self._get_toplevel_options()
+            else:
+                options = self.global_options
+            parser.set_option_table(options)
+            parser.print_help(self.common_usage + "\nGlobal options:")
+            print('')
+
+        if display_options:
+            parser.set_option_table(self.display_options)
+            parser.print_help(
+                "Information display options (just display " +
+                "information, ignore any commands)")
+            print('')
+
+        for command in self.commands:
+            if isinstance(command, type) and issubclass(command, Command):
+                klass = command
+            else:
+                klass = self.get_command_class(command)
+            if (hasattr(klass, 'help_options') and
+                    isinstance(klass.help_options, list)):
+                parser.set_option_table(klass.user_options +
+                                        fix_help_options(klass.help_options))
+            else:
+                parser.set_option_table(klass.user_options)
+            parser.print_help("Options for '%s' command:" % klass.__name__)
+            print('')
+
+        print(gen_usage(self.script_name))
+
+    def handle_display_options(self, option_order):
+        """If there were any non-global "display-only" options
+        (--help-commands or the metadata display options) on the command
+        line, display the requested info and return true; else return
+        false.
+        """
+        from distutils.core import gen_usage
+
+        # User just wants a list of commands -- we'll print it out and stop
+        # processing now (ie. if they ran "setup --help-commands foo bar",
+        # we ignore "foo bar").
+        if self.help_commands:
+            self.print_commands()
+            print('')
+            print(gen_usage(self.script_name))
+            return 1
+
+        # If user supplied any of the "display metadata" options, then
+        # display that metadata in the order in which the user supplied the
+        # metadata options.
+        any_display_options = 0
+        is_display_option = {}
+        for option in self.display_options:
+            is_display_option[option[0]] = 1
+
+        for (opt, val) in option_order:
+            if val and is_display_option.get(opt):
+                opt = translate_longopt(opt)
+                value = getattr(self.metadata, "get_"+opt)()
+                if opt in ['keywords', 'platforms']:
+                    print(','.join(value))
+                elif opt in ('classifiers', 'provides', 'requires',
+                             'obsoletes'):
+                    print('\n'.join(value))
+                else:
+                    print(value)
+                any_display_options = 1
+
+        return any_display_options
+
+    def print_command_list(self, commands, header, max_length):
+        """Print a subset of the list of all commands -- used by
+        'print_commands()'.
+        """
+        print(header + ":")
+
+        for cmd in commands:
+            klass = self.cmdclass.get(cmd)
+            if not klass:
+                klass = self.get_command_class(cmd)
+            try:
+                description = klass.description
+            except AttributeError:
+                description = "(no description available)"
+
+            print("  %-*s  %s" % (max_length, cmd, description))
+
+    def print_commands(self):
+        """Print out a help message listing all available commands with a
+        description of each.  The list is divided into "standard commands"
+        (listed in distutils.command.__all__) and "extra commands"
+        (mentioned in self.cmdclass, but not a standard command).  The
+        descriptions come from the command class attribute
+        'description'.
+        """
+        import distutils.command
+        std_commands = distutils.command.__all__
+        is_std = {}
+        for cmd in std_commands:
+            is_std[cmd] = 1
+
+        extra_commands = []
+        for cmd in self.cmdclass.keys():
+            if not is_std.get(cmd):
+                extra_commands.append(cmd)
+
+        max_length = 0
+        for cmd in (std_commands + extra_commands):
+            if len(cmd) > max_length:
+                max_length = len(cmd)
+
+        self.print_command_list(std_commands,
+                                "Standard commands",
+                                max_length)
+        if extra_commands:
+            print()
+            self.print_command_list(extra_commands,
+                                    "Extra commands",
+                                    max_length)
+
+    def get_command_list(self):
+        """Get a list of (command, description) tuples.
+        The list is divided into "standard commands" (listed in
+        distutils.command.__all__) and "extra commands" (mentioned in
+        self.cmdclass, but not a standard command).  The descriptions come
+        from the command class attribute 'description'.
+        """
+        # Currently this is only used on Mac OS, for the Mac-only GUI
+        # Distutils interface (by Jack Jansen)
+        import distutils.command
+        std_commands = distutils.command.__all__
+        is_std = {}
+        for cmd in std_commands:
+            is_std[cmd] = 1
+
+        extra_commands = []
+        for cmd in self.cmdclass.keys():
+            if not is_std.get(cmd):
+                extra_commands.append(cmd)
+
+        rv = []
+        for cmd in (std_commands + extra_commands):
+            klass = self.cmdclass.get(cmd)
+            if not klass:
+                klass = self.get_command_class(cmd)
+            try:
+                description = klass.description
+            except AttributeError:
+                description = "(no description available)"
+            rv.append((cmd, description))
+        return rv
+
+    # -- Command class/object methods ----------------------------------
+
+    def get_command_packages(self):
+        """Return a list of packages from which commands are loaded."""
+        pkgs = self.command_packages
+        if not isinstance(pkgs, list):
+            if pkgs is None:
+                pkgs = ''
+            pkgs = [pkg.strip() for pkg in pkgs.split(',') if pkg != '']
+            if "distutils.command" not in pkgs:
+                pkgs.insert(0, "distutils.command")
+            self.command_packages = pkgs
+        return pkgs
+
+    def get_command_class(self, command):
+        """Return the class that implements the Distutils command named by
+        'command'.  First we check the 'cmdclass' dictionary; if the
+        command is mentioned there, we fetch the class object from the
+        dictionary and return it.  Otherwise we load the command module
+        ("distutils.command." + command) and fetch the command class from
+        the module.  The loaded class is also stored in 'cmdclass'
+        to speed future calls to 'get_command_class()'.
+
+        Raises DistutilsModuleError if the expected module could not be
+        found, or if that module does not define the expected class.
+        """
+        klass = self.cmdclass.get(command)
+        if klass:
+            return klass
+
+        for pkgname in self.get_command_packages():
+            module_name = "%s.%s" % (pkgname, command)
+            klass_name = command
+
+            try:
+                __import__(module_name)
+                module = sys.modules[module_name]
+            except ImportError:
+                continue
+
+            try:
+                klass = getattr(module, klass_name)
+            except AttributeError:
+                raise DistutilsModuleError(
+                    "invalid command '%s' (no class '%s' in module '%s')"
+                    % (command, klass_name, module_name))
+
+            self.cmdclass[command] = klass
+            return klass
+
+        raise DistutilsModuleError("invalid command '%s'" % command)
+
+    def get_command_obj(self, command, create=1):
+        """Return the command object for 'command'.  Normally this object
+        is cached on a previous call to 'get_command_obj()'; if no command
+        object for 'command' is in the cache, then we either create and
+        return it (if 'create' is true) or return None.
+        """
+        cmd_obj = self.command_obj.get(command)
+        if not cmd_obj and create:
+            if DEBUG:
+                self.announce("Distribution.get_command_obj(): "
+                              "creating '%s' command object" % command)
+
+            klass = self.get_command_class(command)
+            cmd_obj = self.command_obj[command] = klass(self)
+            self.have_run[command] = 0
+
+            # Set any options that were supplied in config files
+            # or on the command line.  (NB. support for error
+            # reporting is lame here: any errors aren't reported
+            # until 'finalize_options()' is called, which means
+            # we won't report the source of the error.)
+            options = self.command_options.get(command)
+            if options:
+                self._set_command_options(cmd_obj, options)
+
+        return cmd_obj
+
+    def _set_command_options(self, command_obj, option_dict=None):
+        """Set the options for 'command_obj' from 'option_dict'.  Basically
+        this means copying elements of a dictionary ('option_dict') to
+        attributes of an instance ('command').
+
+        'command_obj' must be a Command instance.  If 'option_dict' is not
+        supplied, uses the standard option dictionary for this command
+        (from 'self.command_options').
+        """
+        command_name = command_obj.get_command_name()
+        if option_dict is None:
+            option_dict = self.get_option_dict(command_name)
+
+        if DEBUG:
+            self.announce("  setting options for '%s' command:" % command_name)
+        for (option, (source, value)) in option_dict.items():
+            if DEBUG:
+                self.announce("    %s = %s (from %s)" % (option, value,
+                                                         source))
+            try:
+                bool_opts = [translate_longopt(o)
+                             for o in command_obj.boolean_options]
+            except AttributeError:
+                bool_opts = []
+            try:
+                neg_opt = command_obj.negative_opt
+            except AttributeError:
+                neg_opt = {}
+
+            try:
+                is_string = isinstance(value, str)
+                if option in neg_opt and is_string:
+                    setattr(command_obj, neg_opt[option], not strtobool(value))
+                elif option in bool_opts and is_string:
+                    setattr(command_obj, option, strtobool(value))
+                elif hasattr(command_obj, option):
+                    setattr(command_obj, option, value)
+                else:
+                    raise DistutilsOptionError(
+                        "error in %s: command '%s' has no such option '%s'"
+                        % (source, command_name, option))
+            except ValueError as msg:
+                raise DistutilsOptionError(msg)
+
+    def reinitialize_command(self, command, reinit_subcommands=0):
+        """Reinitializes a command to the state it was in when first
+        returned by 'get_command_obj()': ie., initialized but not yet
+        finalized.  This provides the opportunity to sneak option
+        values in programmatically, overriding or supplementing
+        user-supplied values from the config files and command line.
+        You'll have to re-finalize the command object (by calling
+        'finalize_options()' or 'ensure_finalized()') before using it for
+        real.
+
+        'command' should be a command name (string) or command object.  If
+        'reinit_subcommands' is true, also reinitializes the command's
+        sub-commands, as declared by the 'sub_commands' class attribute (if
+        it has one).  See the "install" command for an example.  Only
+        reinitializes the sub-commands that actually matter, ie. those
+        whose test predicates return true.
+
+        Returns the reinitialized command object.
+        """
+        from distutils.cmd import Command
+        if not isinstance(command, Command):
+            command_name = command
+            command = self.get_command_obj(command_name)
+        else:
+            command_name = command.get_command_name()
+
+        if not command.finalized:
+            return command
+        command.initialize_options()
+        command.finalized = 0
+        self.have_run[command_name] = 0
+        self._set_command_options(command)
+
+        if reinit_subcommands:
+            for sub in command.get_sub_commands():
+                self.reinitialize_command(sub, reinit_subcommands)
+
+        return command
+
+    # -- Methods that operate on the Distribution ----------------------
+
+    def announce(self, msg, level=log.INFO):
+        log.log(level, msg)
+
+    def run_commands(self):
+        """Run each command that was seen on the setup script command line.
+        Uses the list of commands found and cache of command objects
+        created by 'get_command_obj()'.
+        """
+        for cmd in self.commands:
+            self.run_command(cmd)
+
+    # -- Methods that operate on its Commands --------------------------
+
+    def run_command(self, command):
+        """Do whatever it takes to run a command (including nothing at all,
+        if the command has already been run).  Specifically: if we have
+        already created and run the command named by 'command', return
+        silently without doing anything.  If the command named by 'command'
+        doesn't even have a command object yet, create one.  Then invoke
+        'run()' on that command object (or an existing one).
+        """
+        # Already been here, done that? then return silently.
+        if self.have_run.get(command):
+            return
+
+        log.info("running %s", command)
+        cmd_obj = self.get_command_obj(command)
+        cmd_obj.ensure_finalized()
+        cmd_obj.run()
+        self.have_run[command] = 1
+
+    # -- Distribution query methods ------------------------------------
+
+    def has_pure_modules(self):
+        return len(self.packages or self.py_modules or []) > 0
+
+    def has_ext_modules(self):
+        return self.ext_modules and len(self.ext_modules) > 0
+
+    def has_c_libraries(self):
+        return self.libraries and len(self.libraries) > 0
+
+    def has_modules(self):
+        return self.has_pure_modules() or self.has_ext_modules()
+
+    def has_headers(self):
+        return self.headers and len(self.headers) > 0
+
+    def has_scripts(self):
+        return self.scripts and len(self.scripts) > 0
+
+    def has_data_files(self):
+        return self.data_files and len(self.data_files) > 0
+
+    def is_pure(self):
+        return (self.has_pure_modules() and
+                not self.has_ext_modules() and
+                not self.has_c_libraries())
+
+    # -- Metadata query methods ----------------------------------------
+
+    # If you're looking for 'get_name()', 'get_version()', and so forth,
+    # they are defined in a sneaky way: the constructor binds self.get_XXX
+    # to self.metadata.get_XXX.  The actual code is in the
+    # DistributionMetadata class, below.
+
+class DistributionMetadata:
+    """Dummy class to hold the distribution meta-data: name, version,
+    author, and so forth.
+    """
+
+    _METHOD_BASENAMES = ("name", "version", "author", "author_email",
+                         "maintainer", "maintainer_email", "url",
+                         "license", "description", "long_description",
+                         "keywords", "platforms", "fullname", "contact",
+                         "contact_email", "classifiers", "download_url",
+                         # PEP 314
+                         "provides", "requires", "obsoletes",
+                         )
+
+    def __init__(self, path=None):
+        if path is not None:
+            self.read_pkg_file(open(path))
+        else:
+            self.name = None
+            self.version = None
+            self.author = None
+            self.author_email = None
+            self.maintainer = None
+            self.maintainer_email = None
+            self.url = None
+            self.license = None
+            self.description = None
+            self.long_description = None
+            self.keywords = None
+            self.platforms = None
+            self.classifiers = None
+            self.download_url = None
+            # PEP 314
+            self.provides = None
+            self.requires = None
+            self.obsoletes = None
+
+    def read_pkg_file(self, file):
+        """Reads the metadata values from a file object."""
+        msg = message_from_file(file)
+
+        def _read_field(name):
+            value = msg[name]
+            if value == 'UNKNOWN':
+                return None
+            return value
+
+        def _read_list(name):
+            values = msg.get_all(name, None)
+            if values == []:
+                return None
+            return values
+
+        metadata_version = msg['metadata-version']
+        self.name = _read_field('name')
+        self.version = _read_field('version')
+        self.description = _read_field('summary')
+        # we are filling author only.
+        self.author = _read_field('author')
+        self.maintainer = None
+        self.author_email = _read_field('author-email')
+        self.maintainer_email = None
+        self.url = _read_field('home-page')
+        self.license = _read_field('license')
+
+        if 'download-url' in msg:
+            self.download_url = _read_field('download-url')
+        else:
+            self.download_url = None
+
+        self.long_description = _read_field('description')
+        self.description = _read_field('summary')
+
+        if 'keywords' in msg:
+            self.keywords = _read_field('keywords').split(',')
+
+        self.platforms = _read_list('platform')
+        self.classifiers = _read_list('classifier')
+
+        # PEP 314 - these fields only exist in 1.1
+        if metadata_version == '1.1':
+            self.requires = _read_list('requires')
+            self.provides = _read_list('provides')
+            self.obsoletes = _read_list('obsoletes')
+        else:
+            self.requires = None
+            self.provides = None
+            self.obsoletes = None
+
+    def write_pkg_info(self, base_dir):
+        """Write the PKG-INFO file into the release tree.
+        """
+        with open(os.path.join(base_dir, 'PKG-INFO'), 'w',
+                  encoding='UTF-8') as pkg_info:
+            self.write_pkg_file(pkg_info)
+
+    def write_pkg_file(self, file):
+        """Write the PKG-INFO format data to a file object.
+        """
+        version = '1.0'
+        if (self.provides or self.requires or self.obsoletes or
+                self.classifiers or self.download_url):
+            version = '1.1'
+
+        file.write('Metadata-Version: %s\n' % version)
+        file.write('Name: %s\n' % self.get_name())
+        file.write('Version: %s\n' % self.get_version())
+        file.write('Summary: %s\n' % self.get_description())
+        file.write('Home-page: %s\n' % self.get_url())
+        file.write('Author: %s\n' % self.get_contact())
+        file.write('Author-email: %s\n' % self.get_contact_email())
+        file.write('License: %s\n' % self.get_license())
+        if self.download_url:
+            file.write('Download-URL: %s\n' % self.download_url)
+
+        long_desc = rfc822_escape(self.get_long_description())
+        file.write('Description: %s\n' % long_desc)
+
+        keywords = ','.join(self.get_keywords())
+        if keywords:
+            file.write('Keywords: %s\n' % keywords)
+
+        self._write_list(file, 'Platform', self.get_platforms())
+        self._write_list(file, 'Classifier', self.get_classifiers())
+
+        # PEP 314
+        self._write_list(file, 'Requires', self.get_requires())
+        self._write_list(file, 'Provides', self.get_provides())
+        self._write_list(file, 'Obsoletes', self.get_obsoletes())
+
+    def _write_list(self, file, name, values):
+        for value in values:
+            file.write('%s: %s\n' % (name, value))
+
+    # -- Metadata query methods ----------------------------------------
+
+    def get_name(self):
+        return self.name or "UNKNOWN"
+
+    def get_version(self):
+        return self.version or "0.0.0"
+
+    def get_fullname(self):
+        return "%s-%s" % (self.get_name(), self.get_version())
+
+    def get_author(self):
+        return self.author or "UNKNOWN"
+
+    def get_author_email(self):
+        return self.author_email or "UNKNOWN"
+
+    def get_maintainer(self):
+        return self.maintainer or "UNKNOWN"
+
+    def get_maintainer_email(self):
+        return self.maintainer_email or "UNKNOWN"
+
+    def get_contact(self):
+        return self.maintainer or self.author or "UNKNOWN"
+
+    def get_contact_email(self):
+        return self.maintainer_email or self.author_email or "UNKNOWN"
+
+    def get_url(self):
+        return self.url or "UNKNOWN"
+
+    def get_license(self):
+        return self.license or "UNKNOWN"
+    get_licence = get_license
+
+    def get_description(self):
+        return self.description or "UNKNOWN"
+
+    def get_long_description(self):
+        return self.long_description or "UNKNOWN"
+
+    def get_keywords(self):
+        return self.keywords or []
+
+    def set_keywords(self, value):
+        self.keywords = _ensure_list(value, 'keywords')
+
+    def get_platforms(self):
+        return self.platforms or ["UNKNOWN"]
+
+    def set_platforms(self, value):
+        self.platforms = _ensure_list(value, 'platforms')
+
+    def get_classifiers(self):
+        return self.classifiers or []
+
+    def set_classifiers(self, value):
+        self.classifiers = _ensure_list(value, 'classifiers')
+
+    def get_download_url(self):
+        return self.download_url or "UNKNOWN"
+
+    # PEP 314
+    def get_requires(self):
+        return self.requires or []
+
+    def set_requires(self, value):
+        import distutils.versionpredicate
+        for v in value:
+            distutils.versionpredicate.VersionPredicate(v)
+        self.requires = list(value)
+
+    def get_provides(self):
+        return self.provides or []
+
+    def set_provides(self, value):
+        value = [v.strip() for v in value]
+        for v in value:
+            import distutils.versionpredicate
+            distutils.versionpredicate.split_provision(v)
+        self.provides = value
+
+    def get_obsoletes(self):
+        return self.obsoletes or []
+
+    def set_obsoletes(self, value):
+        import distutils.versionpredicate
+        for v in value:
+            distutils.versionpredicate.VersionPredicate(v)
+        self.obsoletes = list(value)
+
+def fix_help_options(options):
+    """Convert a 4-tuple 'help_options' list as found in various command
+    classes to the 3-tuple form required by FancyGetopt.
+    """
+    new_options = []
+    for help_tuple in options:
+        new_options.append(help_tuple[0:3])
+    return new_options
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/errors.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/errors.py
new file mode 100644
index 0000000..8b93059
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/errors.py
@@ -0,0 +1,97 @@
+"""distutils.errors
+
+Provides exceptions used by the Distutils modules.  Note that Distutils
+modules may raise standard exceptions; in particular, SystemExit is
+usually raised for errors that are obviously the end-user's fault
+(eg. bad command-line arguments).
+
+This module is safe to use in "from ... import *" mode; it only exports
+symbols whose names start with "Distutils" and end with "Error"."""
+
+class DistutilsError (Exception):
+    """The root of all Distutils evil."""
+    pass
+
+class DistutilsModuleError (DistutilsError):
+    """Unable to load an expected module, or to find an expected class
+    within some module (in particular, command modules and classes)."""
+    pass
+
+class DistutilsClassError (DistutilsError):
+    """Some command class (or possibly distribution class, if anyone
+    feels a need to subclass Distribution) is found not to be holding
+    up its end of the bargain, ie. implementing some part of the
+    "command "interface."""
+    pass
+
+class DistutilsGetoptError (DistutilsError):
+    """The option table provided to 'fancy_getopt()' is bogus."""
+    pass
+
+class DistutilsArgError (DistutilsError):
+    """Raised by fancy_getopt in response to getopt.error -- ie. an
+    error in the command line usage."""
+    pass
+
+class DistutilsFileError (DistutilsError):
+    """Any problems in the filesystem: expected file not found, etc.
+    Typically this is for problems that we detect before OSError
+    could be raised."""
+    pass
+
+class DistutilsOptionError (DistutilsError):
+    """Syntactic/semantic errors in command options, such as use of
+    mutually conflicting options, or inconsistent options,
+    badly-spelled values, etc.  No distinction is made between option
+    values originating in the setup script, the command line, config
+    files, or what-have-you -- but if we *know* something originated in
+    the setup script, we'll raise DistutilsSetupError instead."""
+    pass
+
+class DistutilsSetupError (DistutilsError):
+    """For errors that can be definitely blamed on the setup script,
+    such as invalid keyword arguments to 'setup()'."""
+    pass
+
+class DistutilsPlatformError (DistutilsError):
+    """We don't know how to do something on the current platform (but
+    we do know how to do it on some platform) -- eg. trying to compile
+    C files on a platform not supported by a CCompiler subclass."""
+    pass
+
+class DistutilsExecError (DistutilsError):
+    """Any problems executing an external program (such as the C
+    compiler, when compiling C files)."""
+    pass
+
+class DistutilsInternalError (DistutilsError):
+    """Internal inconsistencies or impossibilities (obviously, this
+    should never be seen if the code is working!)."""
+    pass
+
+class DistutilsTemplateError (DistutilsError):
+    """Syntax error in a file list template."""
+
+class DistutilsByteCompileError(DistutilsError):
+    """Byte compile error."""
+
+# Exception classes used by the CCompiler implementation classes
+class CCompilerError (Exception):
+    """Some compile/link operation failed."""
+
+class PreprocessError (CCompilerError):
+    """Failure to preprocess one or more C/C++ files."""
+
+class CompileError (CCompilerError):
+    """Failure to compile one or more C/C++ source files."""
+
+class LibError (CCompilerError):
+    """Failure to create a static library from one or more C/C++ object
+    files."""
+
+class LinkError (CCompilerError):
+    """Failure to link one or more C/C++ object files into an executable
+    or shared library file."""
+
+class UnknownFileError (CCompilerError):
+    """Attempt to process an unknown file type."""
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/extension.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/extension.py
new file mode 100644
index 0000000..c507da3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/extension.py
@@ -0,0 +1,240 @@
+"""distutils.extension
+
+Provides the Extension class, used to describe C/C++ extension
+modules in setup scripts."""
+
+import os
+import warnings
+
+# This class is really only used by the "build_ext" command, so it might
+# make sense to put it in distutils.command.build_ext.  However, that
+# module is already big enough, and I want to make this class a bit more
+# complex to simplify some common cases ("foo" module in "foo.c") and do
+# better error-checking ("foo.c" actually exists).
+#
+# Also, putting this in build_ext.py means every setup script would have to
+# import that large-ish module (indirectly, through distutils.core) in
+# order to do anything.
+
+class Extension:
+    """Just a collection of attributes that describes an extension
+    module and everything needed to build it (hopefully in a portable
+    way, but there are hooks that let you be as unportable as you need).
+
+    Instance attributes:
+      name : string
+        the full name of the extension, including any packages -- ie.
+        *not* a filename or pathname, but Python dotted name
+      sources : [string]
+        list of source filenames, relative to the distribution root
+        (where the setup script lives), in Unix form (slash-separated)
+        for portability.  Source files may be C, C++, SWIG (.i),
+        platform-specific resource files, or whatever else is recognized
+        by the "build_ext" command as source for a Python extension.
+      include_dirs : [string]
+        list of directories to search for C/C++ header files (in Unix
+        form for portability)
+      define_macros : [(name : string, value : string|None)]
+        list of macros to define; each macro is defined using a 2-tuple,
+        where 'value' is either the string to define it to or None to
+        define it without a particular value (equivalent of "#define
+        FOO" in source or -DFOO on Unix C compiler command line)
+      undef_macros : [string]
+        list of macros to undefine explicitly
+      library_dirs : [string]
+        list of directories to search for C/C++ libraries at link time
+      libraries : [string]
+        list of library names (not filenames or paths) to link against
+      runtime_library_dirs : [string]
+        list of directories to search for C/C++ libraries at run time
+        (for shared extensions, this is when the extension is loaded)
+      extra_objects : [string]
+        list of extra files to link with (eg. object files not implied
+        by 'sources', static library that must be explicitly specified,
+        binary resource files, etc.)
+      extra_compile_args : [string]
+        any extra platform- and compiler-specific information to use
+        when compiling the source files in 'sources'.  For platforms and
+        compilers where "command line" makes sense, this is typically a
+        list of command-line arguments, but for other platforms it could
+        be anything.
+      extra_link_args : [string]
+        any extra platform- and compiler-specific information to use
+        when linking object files together to create the extension (or
+        to create a new static Python interpreter).  Similar
+        interpretation as for 'extra_compile_args'.
+      export_symbols : [string]
+        list of symbols to be exported from a shared extension.  Not
+        used on all platforms, and not generally necessary for Python
+        extensions, which typically export exactly one symbol: "init" +
+        extension_name.
+      swig_opts : [string]
+        any extra options to pass to SWIG if a source file has the .i
+        extension.
+      depends : [string]
+        list of files that the extension depends on
+      language : string
+        extension language (i.e. "c", "c++", "objc"). Will be detected
+        from the source extensions if not provided.
+      optional : boolean
+        specifies that a build failure in the extension should not abort the
+        build process, but simply not install the failing extension.
+    """
+
+    # When adding arguments to this constructor, be sure to update
+    # setup_keywords in core.py.
+    def __init__(self, name, sources,
+                  include_dirs=None,
+                  define_macros=None,
+                  undef_macros=None,
+                  library_dirs=None,
+                  libraries=None,
+                  runtime_library_dirs=None,
+                  extra_objects=None,
+                  extra_compile_args=None,
+                  extra_link_args=None,
+                  export_symbols=None,
+                  swig_opts = None,
+                  depends=None,
+                  language=None,
+                  optional=None,
+                  **kw                      # To catch unknown keywords
+                 ):
+        if not isinstance(name, str):
+            raise AssertionError("'name' must be a string")
+        if not (isinstance(sources, list) and
+                all(isinstance(v, str) for v in sources)):
+            raise AssertionError("'sources' must be a list of strings")
+
+        self.name = name
+        self.sources = sources
+        self.include_dirs = include_dirs or []
+        self.define_macros = define_macros or []
+        self.undef_macros = undef_macros or []
+        self.library_dirs = library_dirs or []
+        self.libraries = libraries or []
+        self.runtime_library_dirs = runtime_library_dirs or []
+        self.extra_objects = extra_objects or []
+        self.extra_compile_args = extra_compile_args or []
+        self.extra_link_args = extra_link_args or []
+        self.export_symbols = export_symbols or []
+        self.swig_opts = swig_opts or []
+        self.depends = depends or []
+        self.language = language
+        self.optional = optional
+
+        # If there are unknown keyword options, warn about them
+        if len(kw) > 0:
+            options = [repr(option) for option in kw]
+            options = ', '.join(sorted(options))
+            msg = "Unknown Extension options: %s" % options
+            warnings.warn(msg)
+
+    def __repr__(self):
+        return '<%s.%s(%r) at %#x>' % (
+            self.__class__.__module__,
+            self.__class__.__qualname__,
+            self.name,
+            id(self))
+
+
+def read_setup_file(filename):
+    """Reads a Setup file and returns Extension instances."""
+    from distutils.sysconfig import (parse_makefile, expand_makefile_vars,
+                                     _variable_rx)
+
+    from distutils.text_file import TextFile
+    from distutils.util import split_quoted
+
+    # First pass over the file to gather "VAR = VALUE" assignments.
+    vars = parse_makefile(filename)
+
+    # Second pass to gobble up the real content: lines of the form
+    #   <module> ... [<sourcefile> ...] [<cpparg> ...] [<library> ...]
+    file = TextFile(filename,
+                    strip_comments=1, skip_blanks=1, join_lines=1,
+                    lstrip_ws=1, rstrip_ws=1)
+    try:
+        extensions = []
+
+        while True:
+            line = file.readline()
+            if line is None:                # eof
+                break
+            if _variable_rx.match(line):    # VAR=VALUE, handled in first pass
+                continue
+
+            if line[0] == line[-1] == "*":
+                file.warn("'%s' lines not handled yet" % line)
+                continue
+
+            line = expand_makefile_vars(line, vars)
+            words = split_quoted(line)
+
+            # NB. this parses a slightly different syntax than the old
+            # makesetup script: here, there must be exactly one extension per
+            # line, and it must be the first word of the line.  I have no idea
+            # why the old syntax supported multiple extensions per line, as
+            # they all wind up being the same.
+
+            module = words[0]
+            ext = Extension(module, [])
+            append_next_word = None
+
+            for word in words[1:]:
+                if append_next_word is not None:
+                    append_next_word.append(word)
+                    append_next_word = None
+                    continue
+
+                suffix = os.path.splitext(word)[1]
+                switch = word[0:2] ; value = word[2:]
+
+                if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
+                    # hmm, should we do something about C vs. C++ sources?
+                    # or leave it up to the CCompiler implementation to
+                    # worry about?
+                    ext.sources.append(word)
+                elif switch == "-I":
+                    ext.include_dirs.append(value)
+                elif switch == "-D":
+                    equals = value.find("=")
+                    if equals == -1:        # bare "-DFOO" -- no value
+                        ext.define_macros.append((value, None))
+                    else:                   # "-DFOO=blah"
+                        ext.define_macros.append((value[0:equals],
+                                                  value[equals+2:]))
+                elif switch == "-U":
+                    ext.undef_macros.append(value)
+                elif switch == "-C":        # only here 'cause makesetup has it!
+                    ext.extra_compile_args.append(word)
+                elif switch == "-l":
+                    ext.libraries.append(value)
+                elif switch == "-L":
+                    ext.library_dirs.append(value)
+                elif switch == "-R":
+                    ext.runtime_library_dirs.append(value)
+                elif word == "-rpath":
+                    append_next_word = ext.runtime_library_dirs
+                elif word == "-Xlinker":
+                    append_next_word = ext.extra_link_args
+                elif word == "-Xcompiler":
+                    append_next_word = ext.extra_compile_args
+                elif switch == "-u":
+                    ext.extra_link_args.append(word)
+                    if not value:
+                        append_next_word = ext.extra_link_args
+                elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
+                    # NB. a really faithful emulation of makesetup would
+                    # append a .o file to extra_objects only if it
+                    # had a slash in it; otherwise, it would s/.o/.c/
+                    # and append it to sources.  Hmmmm.
+                    ext.extra_objects.append(word)
+                else:
+                    file.warn("unrecognized argument '%s'" % word)
+
+            extensions.append(ext)
+    finally:
+        file.close()
+
+    return extensions
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/fancy_getopt.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/fancy_getopt.py
new file mode 100644
index 0000000..7d170dd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/fancy_getopt.py
@@ -0,0 +1,457 @@
+"""distutils.fancy_getopt
+
+Wrapper around the standard getopt module that provides the following
+additional features:
+  * short and long options are tied together
+  * options have help strings, so fancy_getopt could potentially
+    create a complete usage summary
+  * options set attributes of a passed-in object
+"""
+
+import sys, string, re
+import getopt
+from distutils.errors import *
+
+# Much like command_re in distutils.core, this is close to but not quite
+# the same as a Python NAME -- except, in the spirit of most GNU
+# utilities, we use '-' in place of '_'.  (The spirit of LISP lives on!)
+# The similarities to NAME are again not a coincidence...
+longopt_pat = r'[a-zA-Z](?:[a-zA-Z0-9-]*)'
+longopt_re = re.compile(r'^%s$' % longopt_pat)
+
+# For recognizing "negative alias" options, eg. "quiet=!verbose"
+neg_alias_re = re.compile("^(%s)=!(%s)$" % (longopt_pat, longopt_pat))
+
+# This is used to translate long options to legitimate Python identifiers
+# (for use as attributes of some object).
+longopt_xlate = str.maketrans('-', '_')
+
+class FancyGetopt:
+    """Wrapper around the standard 'getopt()' module that provides some
+    handy extra functionality:
+      * short and long options are tied together
+      * options have help strings, and help text can be assembled
+        from them
+      * options set attributes of a passed-in object
+      * boolean options can have "negative aliases" -- eg. if
+        --quiet is the "negative alias" of --verbose, then "--quiet"
+        on the command line sets 'verbose' to false
+    """
+
+    def __init__(self, option_table=None):
+        # The option table is (currently) a list of tuples.  The
+        # tuples may have 3 or four values:
+        #   (long_option, short_option, help_string [, repeatable])
+        # if an option takes an argument, its long_option should have '='
+        # appended; short_option should just be a single character, no ':'
+        # in any case.  If a long_option doesn't have a corresponding
+        # short_option, short_option should be None.  All option tuples
+        # must have long options.
+        self.option_table = option_table
+
+        # 'option_index' maps long option names to entries in the option
+        # table (ie. those 3-tuples).
+        self.option_index = {}
+        if self.option_table:
+            self._build_index()
+
+        # 'alias' records (duh) alias options; {'foo': 'bar'} means
+        # --foo is an alias for --bar
+        self.alias = {}
+
+        # 'negative_alias' keeps track of options that are the boolean
+        # opposite of some other option
+        self.negative_alias = {}
+
+        # These keep track of the information in the option table.  We
+        # don't actually populate these structures until we're ready to
+        # parse the command-line, since the 'option_table' passed in here
+        # isn't necessarily the final word.
+        self.short_opts = []
+        self.long_opts = []
+        self.short2long = {}
+        self.attr_name = {}
+        self.takes_arg = {}
+
+        # And 'option_order' is filled up in 'getopt()'; it records the
+        # original order of options (and their values) on the command-line,
+        # but expands short options, converts aliases, etc.
+        self.option_order = []
+
+    def _build_index(self):
+        self.option_index.clear()
+        for option in self.option_table:
+            self.option_index[option[0]] = option
+
+    def set_option_table(self, option_table):
+        self.option_table = option_table
+        self._build_index()
+
+    def add_option(self, long_option, short_option=None, help_string=None):
+        if long_option in self.option_index:
+            raise DistutilsGetoptError(
+                  "option conflict: already an option '%s'" % long_option)
+        else:
+            option = (long_option, short_option, help_string)
+            self.option_table.append(option)
+            self.option_index[long_option] = option
+
+    def has_option(self, long_option):
+        """Return true if the option table for this parser has an
+        option with long name 'long_option'."""
+        return long_option in self.option_index
+
+    def get_attr_name(self, long_option):
+        """Translate long option name 'long_option' to the form it
+        has as an attribute of some object: ie., translate hyphens
+        to underscores."""
+        return long_option.translate(longopt_xlate)
+
+    def _check_alias_dict(self, aliases, what):
+        assert isinstance(aliases, dict)
+        for (alias, opt) in aliases.items():
+            if alias not in self.option_index:
+                raise DistutilsGetoptError(("invalid %s '%s': "
+                       "option '%s' not defined") % (what, alias, alias))
+            if opt not in self.option_index:
+                raise DistutilsGetoptError(("invalid %s '%s': "
+                       "aliased option '%s' not defined") % (what, alias, opt))
+
+    def set_aliases(self, alias):
+        """Set the aliases for this option parser."""
+        self._check_alias_dict(alias, "alias")
+        self.alias = alias
+
+    def set_negative_aliases(self, negative_alias):
+        """Set the negative aliases for this option parser.
+        'negative_alias' should be a dictionary mapping option names to
+        option names, both the key and value must already be defined
+        in the option table."""
+        self._check_alias_dict(negative_alias, "negative alias")
+        self.negative_alias = negative_alias
+
+    def _grok_option_table(self):
+        """Populate the various data structures that keep tabs on the
+        option table.  Called by 'getopt()' before it can do anything
+        worthwhile.
+        """
+        self.long_opts = []
+        self.short_opts = []
+        self.short2long.clear()
+        self.repeat = {}
+
+        for option in self.option_table:
+            if len(option) == 3:
+                long, short, help = option
+                repeat = 0
+            elif len(option) == 4:
+                long, short, help, repeat = option
+            else:
+                # the option table is part of the code, so simply
+                # assert that it is correct
+                raise ValueError("invalid option tuple: %r" % (option,))
+
+            # Type- and value-check the option names
+            if not isinstance(long, str) or len(long) < 2:
+                raise DistutilsGetoptError(("invalid long option '%s': "
+                       "must be a string of length >= 2") % long)
+
+            if (not ((short is None) or
+                     (isinstance(short, str) and len(short) == 1))):
+                raise DistutilsGetoptError("invalid short option '%s': "
+                       "must a single character or None" % short)
+
+            self.repeat[long] = repeat
+            self.long_opts.append(long)
+
+            if long[-1] == '=':             # option takes an argument?
+                if short: short = short + ':'
+                long = long[0:-1]
+                self.takes_arg[long] = 1
+            else:
+                # Is option is a "negative alias" for some other option (eg.
+                # "quiet" == "!verbose")?
+                alias_to = self.negative_alias.get(long)
+                if alias_to is not None:
+                    if self.takes_arg[alias_to]:
+                        raise DistutilsGetoptError(
+                              "invalid negative alias '%s': "
+                              "aliased option '%s' takes a value"
+                              % (long, alias_to))
+
+                    self.long_opts[-1] = long # XXX redundant?!
+                self.takes_arg[long] = 0
+
+            # If this is an alias option, make sure its "takes arg" flag is
+            # the same as the option it's aliased to.
+            alias_to = self.alias.get(long)
+            if alias_to is not None:
+                if self.takes_arg[long] != self.takes_arg[alias_to]:
+                    raise DistutilsGetoptError(
+                          "invalid alias '%s': inconsistent with "
+                          "aliased option '%s' (one of them takes a value, "
+                          "the other doesn't"
+                          % (long, alias_to))
+
+            # Now enforce some bondage on the long option name, so we can
+            # later translate it to an attribute name on some object.  Have
+            # to do this a bit late to make sure we've removed any trailing
+            # '='.
+            if not longopt_re.match(long):
+                raise DistutilsGetoptError(
+                       "invalid long option name '%s' "
+                       "(must be letters, numbers, hyphens only" % long)
+
+            self.attr_name[long] = self.get_attr_name(long)
+            if short:
+                self.short_opts.append(short)
+                self.short2long[short[0]] = long
+
+    def getopt(self, args=None, object=None):
+        """Parse command-line options in args. Store as attributes on object.
+
+        If 'args' is None or not supplied, uses 'sys.argv[1:]'.  If
+        'object' is None or not supplied, creates a new OptionDummy
+        object, stores option values there, and returns a tuple (args,
+        object).  If 'object' is supplied, it is modified in place and
+        'getopt()' just returns 'args'; in both cases, the returned
+        'args' is a modified copy of the passed-in 'args' list, which
+        is left untouched.
+        """
+        if args is None:
+            args = sys.argv[1:]
+        if object is None:
+            object = OptionDummy()
+            created_object = True
+        else:
+            created_object = False
+
+        self._grok_option_table()
+
+        short_opts = ' '.join(self.short_opts)
+        try:
+            opts, args = getopt.getopt(args, short_opts, self.long_opts)
+        except getopt.error as msg:
+            raise DistutilsArgError(msg)
+
+        for opt, val in opts:
+            if len(opt) == 2 and opt[0] == '-': # it's a short option
+                opt = self.short2long[opt[1]]
+            else:
+                assert len(opt) > 2 and opt[:2] == '--'
+                opt = opt[2:]
+
+            alias = self.alias.get(opt)
+            if alias:
+                opt = alias
+
+            if not self.takes_arg[opt]:     # boolean option?
+                assert val == '', "boolean option can't have value"
+                alias = self.negative_alias.get(opt)
+                if alias:
+                    opt = alias
+                    val = 0
+                else:
+                    val = 1
+
+            attr = self.attr_name[opt]
+            # The only repeating option at the moment is 'verbose'.
+            # It has a negative option -q quiet, which should set verbose = 0.
+            if val and self.repeat.get(attr) is not None:
+                val = getattr(object, attr, 0) + 1
+            setattr(object, attr, val)
+            self.option_order.append((opt, val))
+
+        # for opts
+        if created_object:
+            return args, object
+        else:
+            return args
+
+    def get_option_order(self):
+        """Returns the list of (option, value) tuples processed by the
+        previous run of 'getopt()'.  Raises RuntimeError if
+        'getopt()' hasn't been called yet.
+        """
+        if self.option_order is None:
+            raise RuntimeError("'getopt()' hasn't been called yet")
+        else:
+            return self.option_order
+
+    def generate_help(self, header=None):
+        """Generate help text (a list of strings, one per suggested line of
+        output) from the option table for this FancyGetopt object.
+        """
+        # Blithely assume the option table is good: probably wouldn't call
+        # 'generate_help()' unless you've already called 'getopt()'.
+
+        # First pass: determine maximum length of long option names
+        max_opt = 0
+        for option in self.option_table:
+            long = option[0]
+            short = option[1]
+            l = len(long)
+            if long[-1] == '=':
+                l = l - 1
+            if short is not None:
+                l = l + 5                   # " (-x)" where short == 'x'
+            if l > max_opt:
+                max_opt = l
+
+        opt_width = max_opt + 2 + 2 + 2     # room for indent + dashes + gutter
+
+        # Typical help block looks like this:
+        #   --foo       controls foonabulation
+        # Help block for longest option looks like this:
+        #   --flimflam  set the flim-flam level
+        # and with wrapped text:
+        #   --flimflam  set the flim-flam level (must be between
+        #               0 and 100, except on Tuesdays)
+        # Options with short names will have the short name shown (but
+        # it doesn't contribute to max_opt):
+        #   --foo (-f)  controls foonabulation
+        # If adding the short option would make the left column too wide,
+        # we push the explanation off to the next line
+        #   --flimflam (-l)
+        #               set the flim-flam level
+        # Important parameters:
+        #   - 2 spaces before option block start lines
+        #   - 2 dashes for each long option name
+        #   - min. 2 spaces between option and explanation (gutter)
+        #   - 5 characters (incl. space) for short option name
+
+        # Now generate lines of help text.  (If 80 columns were good enough
+        # for Jesus, then 78 columns are good enough for me!)
+        line_width = 78
+        text_width = line_width - opt_width
+        big_indent = ' ' * opt_width
+        if header:
+            lines = [header]
+        else:
+            lines = ['Option summary:']
+
+        for option in self.option_table:
+            long, short, help = option[:3]
+            text = wrap_text(help, text_width)
+            if long[-1] == '=':
+                long = long[0:-1]
+
+            # Case 1: no short option at all (makes life easy)
+            if short is None:
+                if text:
+                    lines.append("  --%-*s  %s" % (max_opt, long, text[0]))
+                else:
+                    lines.append("  --%-*s  " % (max_opt, long))
+
+            # Case 2: we have a short option, so we have to include it
+            # just after the long option
+            else:
+                opt_names = "%s (-%s)" % (long, short)
+                if text:
+                    lines.append("  --%-*s  %s" %
+                                 (max_opt, opt_names, text[0]))
+                else:
+                    lines.append("  --%-*s" % opt_names)
+
+            for l in text[1:]:
+                lines.append(big_indent + l)
+        return lines
+
+    def print_help(self, header=None, file=None):
+        if file is None:
+            file = sys.stdout
+        for line in self.generate_help(header):
+            file.write(line + "\n")
+
+
+def fancy_getopt(options, negative_opt, object, args):
+    parser = FancyGetopt(options)
+    parser.set_negative_aliases(negative_opt)
+    return parser.getopt(args, object)
+
+
+WS_TRANS = {ord(_wschar) : ' ' for _wschar in string.whitespace}
+
+def wrap_text(text, width):
+    """wrap_text(text : string, width : int) -> [string]
+
+    Split 'text' into multiple lines of no more than 'width' characters
+    each, and return the list of strings that results.
+    """
+    if text is None:
+        return []
+    if len(text) <= width:
+        return [text]
+
+    text = text.expandtabs()
+    text = text.translate(WS_TRANS)
+    chunks = re.split(r'( +|-+)', text)
+    chunks = [ch for ch in chunks if ch] # ' - ' results in empty strings
+    lines = []
+
+    while chunks:
+        cur_line = []                   # list of chunks (to-be-joined)
+        cur_len = 0                     # length of current line
+
+        while chunks:
+            l = len(chunks[0])
+            if cur_len + l <= width:    # can squeeze (at least) this chunk in
+                cur_line.append(chunks[0])
+                del chunks[0]
+                cur_len = cur_len + l
+            else:                       # this line is full
+                # drop last chunk if all space
+                if cur_line and cur_line[-1][0] == ' ':
+                    del cur_line[-1]
+                break
+
+        if chunks:                      # any chunks left to process?
+            # if the current line is still empty, then we had a single
+            # chunk that's too big too fit on a line -- so we break
+            # down and break it up at the line width
+            if cur_len == 0:
+                cur_line.append(chunks[0][0:width])
+                chunks[0] = chunks[0][width:]
+
+            # all-whitespace chunks at the end of a line can be discarded
+            # (and we know from the re.split above that if a chunk has
+            # *any* whitespace, it is *all* whitespace)
+            if chunks[0][0] == ' ':
+                del chunks[0]
+
+        # and store this line in the list-of-all-lines -- as a single
+        # string, of course!
+        lines.append(''.join(cur_line))
+
+    return lines
+
+
+def translate_longopt(opt):
+    """Convert a long option name to a valid Python identifier by
+    changing "-" to "_".
+    """
+    return opt.translate(longopt_xlate)
+
+
+class OptionDummy:
+    """Dummy class just used as a place to hold command-line option
+    values as instance attributes."""
+
+    def __init__(self, options=[]):
+        """Create a new OptionDummy instance.  The attributes listed in
+        'options' will be initialized to None."""
+        for opt in options:
+            setattr(self, opt, None)
+
+
+if __name__ == "__main__":
+    text = """\
+Tra-la-la, supercalifragilisticexpialidocious.
+How *do* you spell that odd word, anyways?
+(Someone ask Mary -- she'll know [or she'll
+say, "How should I know?"].)"""
+
+    for w in (10, 20, 30, 40):
+        print("width: %d" % w)
+        print("\n".join(wrap_text(text, w)))
+        print()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/file_util.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/file_util.py
new file mode 100644
index 0000000..b3fee35
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/file_util.py
@@ -0,0 +1,238 @@
+"""distutils.file_util
+
+Utility functions for operating on single files.
+"""
+
+import os
+from distutils.errors import DistutilsFileError
+from distutils import log
+
+# for generating verbose output in 'copy_file()'
+_copy_action = { None:   'copying',
+                 'hard': 'hard linking',
+                 'sym':  'symbolically linking' }
+
+
+def _copy_file_contents(src, dst, buffer_size=16*1024):
+    """Copy the file 'src' to 'dst'; both must be filenames.  Any error
+    opening either file, reading from 'src', or writing to 'dst', raises
+    DistutilsFileError.  Data is read/written in chunks of 'buffer_size'
+    bytes (default 16k).  No attempt is made to handle anything apart from
+    regular files.
+    """
+    # Stolen from shutil module in the standard library, but with
+    # custom error-handling added.
+    fsrc = None
+    fdst = None
+    try:
+        try:
+            fsrc = open(src, 'rb')
+        except OSError as e:
+            raise DistutilsFileError("could not open '%s': %s" % (src, e.strerror))
+
+        if os.path.exists(dst):
+            try:
+                os.unlink(dst)
+            except OSError as e:
+                raise DistutilsFileError(
+                      "could not delete '%s': %s" % (dst, e.strerror))
+
+        try:
+            fdst = open(dst, 'wb')
+        except OSError as e:
+            raise DistutilsFileError(
+                  "could not create '%s': %s" % (dst, e.strerror))
+
+        while True:
+            try:
+                buf = fsrc.read(buffer_size)
+            except OSError as e:
+                raise DistutilsFileError(
+                      "could not read from '%s': %s" % (src, e.strerror))
+
+            if not buf:
+                break
+
+            try:
+                fdst.write(buf)
+            except OSError as e:
+                raise DistutilsFileError(
+                      "could not write to '%s': %s" % (dst, e.strerror))
+    finally:
+        if fdst:
+            fdst.close()
+        if fsrc:
+            fsrc.close()
+
+def copy_file(src, dst, preserve_mode=1, preserve_times=1, update=0,
+              link=None, verbose=1, dry_run=0):
+    """Copy a file 'src' to 'dst'.  If 'dst' is a directory, then 'src' is
+    copied there with the same name; otherwise, it must be a filename.  (If
+    the file exists, it will be ruthlessly clobbered.)  If 'preserve_mode'
+    is true (the default), the file's mode (type and permission bits, or
+    whatever is analogous on the current platform) is copied.  If
+    'preserve_times' is true (the default), the last-modified and
+    last-access times are copied as well.  If 'update' is true, 'src' will
+    only be copied if 'dst' does not exist, or if 'dst' does exist but is
+    older than 'src'.
+
+    'link' allows you to make hard links (os.link) or symbolic links
+    (os.symlink) instead of copying: set it to "hard" or "sym"; if it is
+    None (the default), files are copied.  Don't set 'link' on systems that
+    don't support it: 'copy_file()' doesn't check if hard or symbolic
+    linking is available. If hardlink fails, falls back to
+    _copy_file_contents().
+
+    Under Mac OS, uses the native file copy function in macostools; on
+    other systems, uses '_copy_file_contents()' to copy file contents.
+
+    Return a tuple (dest_name, copied): 'dest_name' is the actual name of
+    the output file, and 'copied' is true if the file was copied (or would
+    have been copied, if 'dry_run' true).
+    """
+    # XXX if the destination file already exists, we clobber it if
+    # copying, but blow up if linking.  Hmmm.  And I don't know what
+    # macostools.copyfile() does.  Should definitely be consistent, and
+    # should probably blow up if destination exists and we would be
+    # changing it (ie. it's not already a hard/soft link to src OR
+    # (not update) and (src newer than dst).
+
+    from distutils.dep_util import newer
+    from stat import ST_ATIME, ST_MTIME, ST_MODE, S_IMODE
+
+    if not os.path.isfile(src):
+        raise DistutilsFileError(
+              "can't copy '%s': doesn't exist or not a regular file" % src)
+
+    if os.path.isdir(dst):
+        dir = dst
+        dst = os.path.join(dst, os.path.basename(src))
+    else:
+        dir = os.path.dirname(dst)
+
+    if update and not newer(src, dst):
+        if verbose >= 1:
+            log.debug("not copying %s (output up-to-date)", src)
+        return (dst, 0)
+
+    try:
+        action = _copy_action[link]
+    except KeyError:
+        raise ValueError("invalid value '%s' for 'link' argument" % link)
+
+    if verbose >= 1:
+        if os.path.basename(dst) == os.path.basename(src):
+            log.info("%s %s -> %s", action, src, dir)
+        else:
+            log.info("%s %s -> %s", action, src, dst)
+
+    if dry_run:
+        return (dst, 1)
+
+    # If linking (hard or symbolic), use the appropriate system call
+    # (Unix only, of course, but that's the caller's responsibility)
+    elif link == 'hard':
+        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
+            try:
+                os.link(src, dst)
+                return (dst, 1)
+            except OSError:
+                # If hard linking fails, fall back on copying file
+                # (some special filesystems don't support hard linking
+                #  even under Unix, see issue #8876).
+                pass
+    elif link == 'sym':
+        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
+            os.symlink(src, dst)
+            return (dst, 1)
+
+    # Otherwise (non-Mac, not linking), copy the file contents and
+    # (optionally) copy the times and mode.
+    _copy_file_contents(src, dst)
+    if preserve_mode or preserve_times:
+        st = os.stat(src)
+
+        # According to David Ascher <da@ski.org>, utime() should be done
+        # before chmod() (at least under NT).
+        if preserve_times:
+            os.utime(dst, (st[ST_ATIME], st[ST_MTIME]))
+        if preserve_mode:
+            os.chmod(dst, S_IMODE(st[ST_MODE]))
+
+    return (dst, 1)
+
+
+# XXX I suspect this is Unix-specific -- need porting help!
+def move_file (src, dst,
+               verbose=1,
+               dry_run=0):
+
+    """Move a file 'src' to 'dst'.  If 'dst' is a directory, the file will
+    be moved into it with the same name; otherwise, 'src' is just renamed
+    to 'dst'.  Return the new full name of the file.
+
+    Handles cross-device moves on Unix using 'copy_file()'.  What about
+    other systems???
+    """
+    from os.path import exists, isfile, isdir, basename, dirname
+    import errno
+
+    if verbose >= 1:
+        log.info("moving %s -> %s", src, dst)
+
+    if dry_run:
+        return dst
+
+    if not isfile(src):
+        raise DistutilsFileError("can't move '%s': not a regular file" % src)
+
+    if isdir(dst):
+        dst = os.path.join(dst, basename(src))
+    elif exists(dst):
+        raise DistutilsFileError(
+              "can't move '%s': destination '%s' already exists" %
+              (src, dst))
+
+    if not isdir(dirname(dst)):
+        raise DistutilsFileError(
+              "can't move '%s': destination '%s' not a valid path" %
+              (src, dst))
+
+    copy_it = False
+    try:
+        os.rename(src, dst)
+    except OSError as e:
+        (num, msg) = e.args
+        if num == errno.EXDEV:
+            copy_it = True
+        else:
+            raise DistutilsFileError(
+                  "couldn't move '%s' to '%s': %s" % (src, dst, msg))
+
+    if copy_it:
+        copy_file(src, dst, verbose=verbose)
+        try:
+            os.unlink(src)
+        except OSError as e:
+            (num, msg) = e.args
+            try:
+                os.unlink(dst)
+            except OSError:
+                pass
+            raise DistutilsFileError(
+                  "couldn't move '%s' to '%s' by copy/delete: "
+                  "delete '%s' failed: %s"
+                  % (src, dst, src, msg))
+    return dst
+
+
+def write_file (filename, contents):
+    """Create a file with the specified name and write 'contents' (a
+    sequence of strings without line terminators) to it.
+    """
+    f = open(filename, "w")
+    try:
+        for line in contents:
+            f.write(line + "\n")
+    finally:
+        f.close()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/filelist.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/filelist.py
new file mode 100644
index 0000000..c92d5fd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/filelist.py
@@ -0,0 +1,327 @@
+"""distutils.filelist
+
+Provides the FileList class, used for poking about the filesystem
+and building lists of files.
+"""
+
+import os, re
+import fnmatch
+import functools
+from distutils.util import convert_path
+from distutils.errors import DistutilsTemplateError, DistutilsInternalError
+from distutils import log
+
+class FileList:
+    """A list of files built by on exploring the filesystem and filtered by
+    applying various patterns to what we find there.
+
+    Instance attributes:
+      dir
+        directory from which files will be taken -- only used if
+        'allfiles' not supplied to constructor
+      files
+        list of filenames currently being built/filtered/manipulated
+      allfiles
+        complete list of files under consideration (ie. without any
+        filtering applied)
+    """
+
+    def __init__(self, warn=None, debug_print=None):
+        # ignore argument to FileList, but keep them for backwards
+        # compatibility
+        self.allfiles = None
+        self.files = []
+
+    def set_allfiles(self, allfiles):
+        self.allfiles = allfiles
+
+    def findall(self, dir=os.curdir):
+        self.allfiles = findall(dir)
+
+    def debug_print(self, msg):
+        """Print 'msg' to stdout if the global DEBUG (taken from the
+        DISTUTILS_DEBUG environment variable) flag is true.
+        """
+        from distutils.debug import DEBUG
+        if DEBUG:
+            print(msg)
+
+    # -- List-like methods ---------------------------------------------
+
+    def append(self, item):
+        self.files.append(item)
+
+    def extend(self, items):
+        self.files.extend(items)
+
+    def sort(self):
+        # Not a strict lexical sort!
+        sortable_files = sorted(map(os.path.split, self.files))
+        self.files = []
+        for sort_tuple in sortable_files:
+            self.files.append(os.path.join(*sort_tuple))
+
+
+    # -- Other miscellaneous utility methods ---------------------------
+
+    def remove_duplicates(self):
+        # Assumes list has been sorted!
+        for i in range(len(self.files) - 1, 0, -1):
+            if self.files[i] == self.files[i - 1]:
+                del self.files[i]
+
+
+    # -- "File template" methods ---------------------------------------
+
+    def _parse_template_line(self, line):
+        words = line.split()
+        action = words[0]
+
+        patterns = dir = dir_pattern = None
+
+        if action in ('include', 'exclude',
+                      'global-include', 'global-exclude'):
+            if len(words) < 2:
+                raise DistutilsTemplateError(
+                      "'%s' expects <pattern1> <pattern2> ..." % action)
+            patterns = [convert_path(w) for w in words[1:]]
+        elif action in ('recursive-include', 'recursive-exclude'):
+            if len(words) < 3:
+                raise DistutilsTemplateError(
+                      "'%s' expects <dir> <pattern1> <pattern2> ..." % action)
+            dir = convert_path(words[1])
+            patterns = [convert_path(w) for w in words[2:]]
+        elif action in ('graft', 'prune'):
+            if len(words) != 2:
+                raise DistutilsTemplateError(
+                      "'%s' expects a single <dir_pattern>" % action)
+            dir_pattern = convert_path(words[1])
+        else:
+            raise DistutilsTemplateError("unknown action '%s'" % action)
+
+        return (action, patterns, dir, dir_pattern)
+
+    def process_template_line(self, line):
+        # Parse the line: split it up, make sure the right number of words
+        # is there, and return the relevant words.  'action' is always
+        # defined: it's the first word of the line.  Which of the other
+        # three are defined depends on the action; it'll be either
+        # patterns, (dir and patterns), or (dir_pattern).
+        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)
+
+        # OK, now we know that the action is valid and we have the
+        # right number of words on the line for that action -- so we
+        # can proceed with minimal error-checking.
+        if action == 'include':
+            self.debug_print("include " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.include_pattern(pattern, anchor=1):
+                    log.warn("warning: no files found matching '%s'",
+                             pattern)
+
+        elif action == 'exclude':
+            self.debug_print("exclude " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.exclude_pattern(pattern, anchor=1):
+                    log.warn(("warning: no previously-included files "
+                              "found matching '%s'"), pattern)
+
+        elif action == 'global-include':
+            self.debug_print("global-include " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.include_pattern(pattern, anchor=0):
+                    log.warn(("warning: no files found matching '%s' "
+                              "anywhere in distribution"), pattern)
+
+        elif action == 'global-exclude':
+            self.debug_print("global-exclude " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.exclude_pattern(pattern, anchor=0):
+                    log.warn(("warning: no previously-included files matching "
+                              "'%s' found anywhere in distribution"),
+                             pattern)
+
+        elif action == 'recursive-include':
+            self.debug_print("recursive-include %s %s" %
+                             (dir, ' '.join(patterns)))
+            for pattern in patterns:
+                if not self.include_pattern(pattern, prefix=dir):
+                    log.warn(("warning: no files found matching '%s' "
+                                "under directory '%s'"),
+                             pattern, dir)
+
+        elif action == 'recursive-exclude':
+            self.debug_print("recursive-exclude %s %s" %
+                             (dir, ' '.join(patterns)))
+            for pattern in patterns:
+                if not self.exclude_pattern(pattern, prefix=dir):
+                    log.warn(("warning: no previously-included files matching "
+                              "'%s' found under directory '%s'"),
+                             pattern, dir)
+
+        elif action == 'graft':
+            self.debug_print("graft " + dir_pattern)
+            if not self.include_pattern(None, prefix=dir_pattern):
+                log.warn("warning: no directories found matching '%s'",
+                         dir_pattern)
+
+        elif action == 'prune':
+            self.debug_print("prune " + dir_pattern)
+            if not self.exclude_pattern(None, prefix=dir_pattern):
+                log.warn(("no previously-included directories found "
+                          "matching '%s'"), dir_pattern)
+        else:
+            raise DistutilsInternalError(
+                  "this cannot happen: invalid action '%s'" % action)
+
+
+    # -- Filtering/selection methods -----------------------------------
+
+    def include_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
+        """Select strings (presumably filenames) from 'self.files' that
+        match 'pattern', a Unix-style wildcard (glob) pattern.  Patterns
+        are not quite the same as implemented by the 'fnmatch' module: '*'
+        and '?'  match non-special characters, where "special" is platform-
+        dependent: slash on Unix; colon, slash, and backslash on
+        DOS/Windows; and colon on Mac OS.
+
+        If 'anchor' is true (the default), then the pattern match is more
+        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
+        'anchor' is false, both of these will match.
+
+        If 'prefix' is supplied, then only filenames starting with 'prefix'
+        (itself a pattern) and ending with 'pattern', with anything in between
+        them, will match.  'anchor' is ignored in this case.
+
+        If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
+        'pattern' is assumed to be either a string containing a regex or a
+        regex object -- no translation is done, the regex is just compiled
+        and used as-is.
+
+        Selected strings will be added to self.files.
+
+        Return True if files are found, False otherwise.
+        """
+        # XXX docstring lying about what the special chars are?
+        files_found = False
+        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
+        self.debug_print("include_pattern: applying regex r'%s'" %
+                         pattern_re.pattern)
+
+        # delayed loading of allfiles list
+        if self.allfiles is None:
+            self.findall()
+
+        for name in self.allfiles:
+            if pattern_re.search(name):
+                self.debug_print(" adding " + name)
+                self.files.append(name)
+                files_found = True
+        return files_found
+
+
+    def exclude_pattern (self, pattern,
+                         anchor=1, prefix=None, is_regex=0):
+        """Remove strings (presumably filenames) from 'files' that match
+        'pattern'.  Other parameters are the same as for
+        'include_pattern()', above.
+        The list 'self.files' is modified in place.
+        Return True if files are found, False otherwise.
+        """
+        files_found = False
+        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
+        self.debug_print("exclude_pattern: applying regex r'%s'" %
+                         pattern_re.pattern)
+        for i in range(len(self.files)-1, -1, -1):
+            if pattern_re.search(self.files[i]):
+                self.debug_print(" removing " + self.files[i])
+                del self.files[i]
+                files_found = True
+        return files_found
+
+
+# ----------------------------------------------------------------------
+# Utility functions
+
+def _find_all_simple(path):
+    """
+    Find all files under 'path'
+    """
+    results = (
+        os.path.join(base, file)
+        for base, dirs, files in os.walk(path, followlinks=True)
+        for file in files
+    )
+    return filter(os.path.isfile, results)
+
+
+def findall(dir=os.curdir):
+    """
+    Find all files under 'dir' and return the list of full filenames.
+    Unless dir is '.', return full filenames with dir prepended.
+    """
+    files = _find_all_simple(dir)
+    if dir == os.curdir:
+        make_rel = functools.partial(os.path.relpath, start=dir)
+        files = map(make_rel, files)
+    return list(files)
+
+
+def glob_to_re(pattern):
+    """Translate a shell-like glob pattern to a regular expression; return
+    a string containing the regex.  Differs from 'fnmatch.translate()' in
+    that '*' does not match "special characters" (which are
+    platform-specific).
+    """
+    pattern_re = fnmatch.translate(pattern)
+
+    # '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
+    # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
+    # and by extension they shouldn't match such "special characters" under
+    # any OS.  So change all non-escaped dots in the RE to match any
+    # character except the special characters (currently: just os.sep).
+    sep = os.sep
+    if os.sep == '\\':
+        # we're using a regex to manipulate a regex, so we need
+        # to escape the backslash twice
+        sep = r'\\\\'
+    escaped = r'\1[^%s]' % sep
+    pattern_re = re.sub(r'((?<!\\)(\\\\)*)\.', escaped, pattern_re)
+    return pattern_re
+
+
+def translate_pattern(pattern, anchor=1, prefix=None, is_regex=0):
+    """Translate a shell-like wildcard pattern to a compiled regular
+    expression.  Return the compiled regex.  If 'is_regex' true,
+    then 'pattern' is directly compiled to a regex (if it's a string)
+    or just returned as-is (assumes it's a regex object).
+    """
+    if is_regex:
+        if isinstance(pattern, str):
+            return re.compile(pattern)
+        else:
+            return pattern
+
+    # ditch start and end characters
+    start, _, end = glob_to_re('_').partition('_')
+
+    if pattern:
+        pattern_re = glob_to_re(pattern)
+        assert pattern_re.startswith(start) and pattern_re.endswith(end)
+    else:
+        pattern_re = ''
+
+    if prefix is not None:
+        prefix_re = glob_to_re(prefix)
+        assert prefix_re.startswith(start) and prefix_re.endswith(end)
+        prefix_re = prefix_re[len(start): len(prefix_re) - len(end)]
+        sep = os.sep
+        if os.sep == '\\':
+            sep = r'\\'
+        pattern_re = pattern_re[len(start): len(pattern_re) - len(end)]
+        pattern_re = r'%s\A%s%s.*%s%s' % (start, prefix_re, sep, pattern_re, end)
+    else:                               # no prefix -- respect anchor flag
+        if anchor:
+            pattern_re = r'%s\A%s' % (start, pattern_re[len(start):])
+
+    return re.compile(pattern_re)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/log.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/log.py
new file mode 100644
index 0000000..8ef6b28
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/log.py
@@ -0,0 +1,77 @@
+"""A simple log mechanism styled after PEP 282."""
+
+# The class here is styled after PEP 282 so that it could later be
+# replaced with a standard Python logging implementation.
+
+DEBUG = 1
+INFO = 2
+WARN = 3
+ERROR = 4
+FATAL = 5
+
+import sys
+
+class Log:
+
+    def __init__(self, threshold=WARN):
+        self.threshold = threshold
+
+    def _log(self, level, msg, args):
+        if level not in (DEBUG, INFO, WARN, ERROR, FATAL):
+            raise ValueError('%s wrong log level' % str(level))
+
+        if level >= self.threshold:
+            if args:
+                msg = msg % args
+            if level in (WARN, ERROR, FATAL):
+                stream = sys.stderr
+            else:
+                stream = sys.stdout
+            try:
+                stream.write('%s\n' % msg)
+            except UnicodeEncodeError:
+                # emulate backslashreplace error handler
+                encoding = stream.encoding
+                msg = msg.encode(encoding, "backslashreplace").decode(encoding)
+                stream.write('%s\n' % msg)
+            stream.flush()
+
+    def log(self, level, msg, *args):
+        self._log(level, msg, args)
+
+    def debug(self, msg, *args):
+        self._log(DEBUG, msg, args)
+
+    def info(self, msg, *args):
+        self._log(INFO, msg, args)
+
+    def warn(self, msg, *args):
+        self._log(WARN, msg, args)
+
+    def error(self, msg, *args):
+        self._log(ERROR, msg, args)
+
+    def fatal(self, msg, *args):
+        self._log(FATAL, msg, args)
+
+_global_log = Log()
+log = _global_log.log
+debug = _global_log.debug
+info = _global_log.info
+warn = _global_log.warn
+error = _global_log.error
+fatal = _global_log.fatal
+
+def set_threshold(level):
+    # return the old threshold for use from tests
+    old = _global_log.threshold
+    _global_log.threshold = level
+    return old
+
+def set_verbosity(v):
+    if v <= 0:
+        set_threshold(WARN)
+    elif v == 1:
+        set_threshold(INFO)
+    elif v >= 2:
+        set_threshold(DEBUG)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/msvc9compiler.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/msvc9compiler.py
new file mode 100644
index 0000000..6934e96
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/msvc9compiler.py
@@ -0,0 +1,788 @@
+"""distutils.msvc9compiler
+
+Contains MSVCCompiler, an implementation of the abstract CCompiler class
+for the Microsoft Visual Studio 2008.
+
+The module is compatible with VS 2005 and VS 2008. You can find legacy support
+for older versions of VS in distutils.msvccompiler.
+"""
+
+# Written by Perry Stoll
+# hacked by Robin Becker and Thomas Heller to do a better job of
+#   finding DevStudio (through the registry)
+# ported to VS2005 and VS 2008 by Christian Heimes
+
+import os
+import subprocess
+import sys
+import re
+
+from distutils.errors import DistutilsExecError, DistutilsPlatformError, \
+                             CompileError, LibError, LinkError
+from distutils.ccompiler import CCompiler, gen_lib_options
+from distutils import log
+from distutils.util import get_platform
+
+import winreg
+
+RegOpenKeyEx = winreg.OpenKeyEx
+RegEnumKey = winreg.EnumKey
+RegEnumValue = winreg.EnumValue
+RegError = winreg.error
+
+HKEYS = (winreg.HKEY_USERS,
+         winreg.HKEY_CURRENT_USER,
+         winreg.HKEY_LOCAL_MACHINE,
+         winreg.HKEY_CLASSES_ROOT)
+
+NATIVE_WIN64 = (sys.platform == 'win32' and sys.maxsize > 2**32)
+if NATIVE_WIN64:
+    # Visual C++ is a 32-bit application, so we need to look in
+    # the corresponding registry branch, if we're running a
+    # 64-bit Python on Win64
+    VS_BASE = r"Software\Wow6432Node\Microsoft\VisualStudio\%0.1f"
+    WINSDK_BASE = r"Software\Wow6432Node\Microsoft\Microsoft SDKs\Windows"
+    NET_BASE = r"Software\Wow6432Node\Microsoft\.NETFramework"
+else:
+    VS_BASE = r"Software\Microsoft\VisualStudio\%0.1f"
+    WINSDK_BASE = r"Software\Microsoft\Microsoft SDKs\Windows"
+    NET_BASE = r"Software\Microsoft\.NETFramework"
+
+# A map keyed by get_platform() return values to values accepted by
+# 'vcvarsall.bat'.  Note a cross-compile may combine these (eg, 'x86_amd64' is
+# the param to cross-compile on x86 targeting amd64.)
+PLAT_TO_VCVARS = {
+    'win32' : 'x86',
+    'win-amd64' : 'amd64',
+}
+
+class Reg:
+    """Helper class to read values from the registry
+    """
+
+    def get_value(cls, path, key):
+        for base in HKEYS:
+            d = cls.read_values(base, path)
+            if d and key in d:
+                return d[key]
+        raise KeyError(key)
+    get_value = classmethod(get_value)
+
+    def read_keys(cls, base, key):
+        """Return list of registry keys."""
+        try:
+            handle = RegOpenKeyEx(base, key)
+        except RegError:
+            return None
+        L = []
+        i = 0
+        while True:
+            try:
+                k = RegEnumKey(handle, i)
+            except RegError:
+                break
+            L.append(k)
+            i += 1
+        return L
+    read_keys = classmethod(read_keys)
+
+    def read_values(cls, base, key):
+        """Return dict of registry keys and values.
+
+        All names are converted to lowercase.
+        """
+        try:
+            handle = RegOpenKeyEx(base, key)
+        except RegError:
+            return None
+        d = {}
+        i = 0
+        while True:
+            try:
+                name, value, type = RegEnumValue(handle, i)
+            except RegError:
+                break
+            name = name.lower()
+            d[cls.convert_mbcs(name)] = cls.convert_mbcs(value)
+            i += 1
+        return d
+    read_values = classmethod(read_values)
+
+    def convert_mbcs(s):
+        dec = getattr(s, "decode", None)
+        if dec is not None:
+            try:
+                s = dec("mbcs")
+            except UnicodeError:
+                pass
+        return s
+    convert_mbcs = staticmethod(convert_mbcs)
+
+class MacroExpander:
+
+    def __init__(self, version):
+        self.macros = {}
+        self.vsbase = VS_BASE % version
+        self.load_macros(version)
+
+    def set_macro(self, macro, path, key):
+        self.macros["$(%s)" % macro] = Reg.get_value(path, key)
+
+    def load_macros(self, version):
+        self.set_macro("VCInstallDir", self.vsbase + r"\Setup\VC", "productdir")
+        self.set_macro("VSInstallDir", self.vsbase + r"\Setup\VS", "productdir")
+        self.set_macro("FrameworkDir", NET_BASE, "installroot")
+        try:
+            if version >= 8.0:
+                self.set_macro("FrameworkSDKDir", NET_BASE,
+                               "sdkinstallrootv2.0")
+            else:
+                raise KeyError("sdkinstallrootv2.0")
+        except KeyError:
+            raise DistutilsPlatformError(
+            """Python was built with Visual Studio 2008;
+extensions must be built with a compiler than can generate compatible binaries.
+Visual Studio 2008 was not found on this system. If you have Cygwin installed,
+you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""")
+
+        if version >= 9.0:
+            self.set_macro("FrameworkVersion", self.vsbase, "clr version")
+            self.set_macro("WindowsSdkDir", WINSDK_BASE, "currentinstallfolder")
+        else:
+            p = r"Software\Microsoft\NET Framework Setup\Product"
+            for base in HKEYS:
+                try:
+                    h = RegOpenKeyEx(base, p)
+                except RegError:
+                    continue
+                key = RegEnumKey(h, 0)
+                d = Reg.get_value(base, r"%s\%s" % (p, key))
+                self.macros["$(FrameworkVersion)"] = d["version"]
+
+    def sub(self, s):
+        for k, v in self.macros.items():
+            s = s.replace(k, v)
+        return s
+
+def get_build_version():
+    """Return the version of MSVC that was used to build Python.
+
+    For Python 2.3 and up, the version number is included in
+    sys.version.  For earlier versions, assume the compiler is MSVC 6.
+    """
+    prefix = "MSC v."
+    i = sys.version.find(prefix)
+    if i == -1:
+        return 6
+    i = i + len(prefix)
+    s, rest = sys.version[i:].split(" ", 1)
+    majorVersion = int(s[:-2]) - 6
+    if majorVersion >= 13:
+        # v13 was skipped and should be v14
+        majorVersion += 1
+    minorVersion = int(s[2:3]) / 10.0
+    # I don't think paths are affected by minor version in version 6
+    if majorVersion == 6:
+        minorVersion = 0
+    if majorVersion >= 6:
+        return majorVersion + minorVersion
+    # else we don't know what version of the compiler this is
+    return None
+
+def normalize_and_reduce_paths(paths):
+    """Return a list of normalized paths with duplicates removed.
+
+    The current order of paths is maintained.
+    """
+    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
+    reduced_paths = []
+    for p in paths:
+        np = os.path.normpath(p)
+        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
+        if np not in reduced_paths:
+            reduced_paths.append(np)
+    return reduced_paths
+
+def removeDuplicates(variable):
+    """Remove duplicate values of an environment variable.
+    """
+    oldList = variable.split(os.pathsep)
+    newList = []
+    for i in oldList:
+        if i not in newList:
+            newList.append(i)
+    newVariable = os.pathsep.join(newList)
+    return newVariable
+
+def find_vcvarsall(version):
+    """Find the vcvarsall.bat file
+
+    At first it tries to find the productdir of VS 2008 in the registry. If
+    that fails it falls back to the VS90COMNTOOLS env var.
+    """
+    vsbase = VS_BASE % version
+    try:
+        productdir = Reg.get_value(r"%s\Setup\VC" % vsbase,
+                                   "productdir")
+    except KeyError:
+        log.debug("Unable to find productdir in registry")
+        productdir = None
+
+    if not productdir or not os.path.isdir(productdir):
+        toolskey = "VS%0.f0COMNTOOLS" % version
+        toolsdir = os.environ.get(toolskey, None)
+
+        if toolsdir and os.path.isdir(toolsdir):
+            productdir = os.path.join(toolsdir, os.pardir, os.pardir, "VC")
+            productdir = os.path.abspath(productdir)
+            if not os.path.isdir(productdir):
+                log.debug("%s is not a valid directory" % productdir)
+                return None
+        else:
+            log.debug("Env var %s is not set or invalid" % toolskey)
+    if not productdir:
+        log.debug("No productdir found")
+        return None
+    vcvarsall = os.path.join(productdir, "vcvarsall.bat")
+    if os.path.isfile(vcvarsall):
+        return vcvarsall
+    log.debug("Unable to find vcvarsall.bat")
+    return None
+
+def query_vcvarsall(version, arch="x86"):
+    """Launch vcvarsall.bat and read the settings from its environment
+    """
+    vcvarsall = find_vcvarsall(version)
+    interesting = {"include", "lib", "libpath", "path"}
+    result = {}
+
+    if vcvarsall is None:
+        raise DistutilsPlatformError("Unable to find vcvarsall.bat")
+    log.debug("Calling 'vcvarsall.bat %s' (version=%s)", arch, version)
+    popen = subprocess.Popen('"%s" %s & set' % (vcvarsall, arch),
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+    try:
+        stdout, stderr = popen.communicate()
+        if popen.wait() != 0:
+            raise DistutilsPlatformError(stderr.decode("mbcs"))
+
+        stdout = stdout.decode("mbcs")
+        for line in stdout.split("\n"):
+            line = Reg.convert_mbcs(line)
+            if '=' not in line:
+                continue
+            line = line.strip()
+            key, value = line.split('=', 1)
+            key = key.lower()
+            if key in interesting:
+                if value.endswith(os.pathsep):
+                    value = value[:-1]
+                result[key] = removeDuplicates(value)
+
+    finally:
+        popen.stdout.close()
+        popen.stderr.close()
+
+    if len(result) != len(interesting):
+        raise ValueError(str(list(result.keys())))
+
+    return result
+
+# More globals
+VERSION = get_build_version()
+if VERSION < 8.0:
+    raise DistutilsPlatformError("VC %0.1f is not supported by this module" % VERSION)
+# MACROS = MacroExpander(VERSION)
+
+class MSVCCompiler(CCompiler) :
+    """Concrete class that implements an interface to Microsoft Visual C++,
+       as defined by the CCompiler abstract class."""
+
+    compiler_type = 'msvc'
+
+    # Just set this so CCompiler's constructor doesn't barf.  We currently
+    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
+    # as it really isn't necessary for this sort of single-compiler class.
+    # Would be nice to have a consistent interface with UnixCCompiler,
+    # though, so it's worth thinking about.
+    executables = {}
+
+    # Private class data (need to distinguish C from C++ source for compiler)
+    _c_extensions = ['.c']
+    _cpp_extensions = ['.cc', '.cpp', '.cxx']
+    _rc_extensions = ['.rc']
+    _mc_extensions = ['.mc']
+
+    # Needed for the filename generation methods provided by the
+    # base class, CCompiler.
+    src_extensions = (_c_extensions + _cpp_extensions +
+                      _rc_extensions + _mc_extensions)
+    res_extension = '.res'
+    obj_extension = '.obj'
+    static_lib_extension = '.lib'
+    shared_lib_extension = '.dll'
+    static_lib_format = shared_lib_format = '%s%s'
+    exe_extension = '.exe'
+
+    def __init__(self, verbose=0, dry_run=0, force=0):
+        CCompiler.__init__ (self, verbose, dry_run, force)
+        self.__version = VERSION
+        self.__root = r"Software\Microsoft\VisualStudio"
+        # self.__macros = MACROS
+        self.__paths = []
+        # target platform (.plat_name is consistent with 'bdist')
+        self.plat_name = None
+        self.__arch = None # deprecated name
+        self.initialized = False
+
+    def initialize(self, plat_name=None):
+        # multi-init means we would need to check platform same each time...
+        assert not self.initialized, "don't init multiple times"
+        if plat_name is None:
+            plat_name = get_platform()
+        # sanity check for platforms to prevent obscure errors later.
+        ok_plats = 'win32', 'win-amd64'
+        if plat_name not in ok_plats:
+            raise DistutilsPlatformError("--plat-name must be one of %s" %
+                                         (ok_plats,))
+
+        if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"):
+            # Assume that the SDK set up everything alright; don't try to be
+            # smarter
+            self.cc = "cl.exe"
+            self.linker = "link.exe"
+            self.lib = "lib.exe"
+            self.rc = "rc.exe"
+            self.mc = "mc.exe"
+        else:
+            # On x86, 'vcvars32.bat amd64' creates an env that doesn't work;
+            # to cross compile, you use 'x86_amd64'.
+            # On AMD64, 'vcvars32.bat amd64' is a native build env; to cross
+            # compile use 'x86' (ie, it runs the x86 compiler directly)
+            if plat_name == get_platform() or plat_name == 'win32':
+                # native build or cross-compile to win32
+                plat_spec = PLAT_TO_VCVARS[plat_name]
+            else:
+                # cross compile from win32 -> some 64bit
+                plat_spec = PLAT_TO_VCVARS[get_platform()] + '_' + \
+                            PLAT_TO_VCVARS[plat_name]
+
+            vc_env = query_vcvarsall(VERSION, plat_spec)
+
+            self.__paths = vc_env['path'].split(os.pathsep)
+            os.environ['lib'] = vc_env['lib']
+            os.environ['include'] = vc_env['include']
+
+            if len(self.__paths) == 0:
+                raise DistutilsPlatformError("Python was built with %s, "
+                       "and extensions need to be built with the same "
+                       "version of the compiler, but it isn't installed."
+                       % self.__product)
+
+            self.cc = self.find_exe("cl.exe")
+            self.linker = self.find_exe("link.exe")
+            self.lib = self.find_exe("lib.exe")
+            self.rc = self.find_exe("rc.exe")   # resource compiler
+            self.mc = self.find_exe("mc.exe")   # message compiler
+            #self.set_path_env_var('lib')
+            #self.set_path_env_var('include')
+
+        # extend the MSVC path with the current path
+        try:
+            for p in os.environ['path'].split(';'):
+                self.__paths.append(p)
+        except KeyError:
+            pass
+        self.__paths = normalize_and_reduce_paths(self.__paths)
+        os.environ['path'] = ";".join(self.__paths)
+
+        self.preprocess_options = None
+        if self.__arch == "x86":
+            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3',
+                                     '/DNDEBUG']
+            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3',
+                                          '/Z7', '/D_DEBUG']
+        else:
+            # Win64
+            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GS-' ,
+                                     '/DNDEBUG']
+            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-',
+                                          '/Z7', '/D_DEBUG']
+
+        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
+        if self.__version >= 7:
+            self.ldflags_shared_debug = [
+                '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
+                ]
+        self.ldflags_static = [ '/nologo']
+
+        self.initialized = True
+
+    # -- Worker methods ------------------------------------------------
+
+    def object_filenames(self,
+                         source_filenames,
+                         strip_dir=0,
+                         output_dir=''):
+        # Copied from ccompiler.py, extended to return .res as 'object'-file
+        # for .rc input file
+        if output_dir is None: output_dir = ''
+        obj_names = []
+        for src_name in source_filenames:
+            (base, ext) = os.path.splitext (src_name)
+            base = os.path.splitdrive(base)[1] # Chop off the drive
+            base = base[os.path.isabs(base):]  # If abs, chop off leading /
+            if ext not in self.src_extensions:
+                # Better to raise an exception instead of silently continuing
+                # and later complain about sources and targets having
+                # different lengths
+                raise CompileError ("Don't know how to compile %s" % src_name)
+            if strip_dir:
+                base = os.path.basename (base)
+            if ext in self._rc_extensions:
+                obj_names.append (os.path.join (output_dir,
+                                                base + self.res_extension))
+            elif ext in self._mc_extensions:
+                obj_names.append (os.path.join (output_dir,
+                                                base + self.res_extension))
+            else:
+                obj_names.append (os.path.join (output_dir,
+                                                base + self.obj_extension))
+        return obj_names
+
+
+    def compile(self, sources,
+                output_dir=None, macros=None, include_dirs=None, debug=0,
+                extra_preargs=None, extra_postargs=None, depends=None):
+
+        if not self.initialized:
+            self.initialize()
+        compile_info = self._setup_compile(output_dir, macros, include_dirs,
+                                           sources, depends, extra_postargs)
+        macros, objects, extra_postargs, pp_opts, build = compile_info
+
+        compile_opts = extra_preargs or []
+        compile_opts.append ('/c')
+        if debug:
+            compile_opts.extend(self.compile_options_debug)
+        else:
+            compile_opts.extend(self.compile_options)
+
+        for obj in objects:
+            try:
+                src, ext = build[obj]
+            except KeyError:
+                continue
+            if debug:
+                # pass the full pathname to MSVC in debug mode,
+                # this allows the debugger to find the source file
+                # without asking the user to browse for it
+                src = os.path.abspath(src)
+
+            if ext in self._c_extensions:
+                input_opt = "/Tc" + src
+            elif ext in self._cpp_extensions:
+                input_opt = "/Tp" + src
+            elif ext in self._rc_extensions:
+                # compile .RC to .RES file
+                input_opt = src
+                output_opt = "/fo" + obj
+                try:
+                    self.spawn([self.rc] + pp_opts +
+                               [output_opt] + [input_opt])
+                except DistutilsExecError as msg:
+                    raise CompileError(msg)
+                continue
+            elif ext in self._mc_extensions:
+                # Compile .MC to .RC file to .RES file.
+                #   * '-h dir' specifies the directory for the
+                #     generated include file
+                #   * '-r dir' specifies the target directory of the
+                #     generated RC file and the binary message resource
+                #     it includes
+                #
+                # For now (since there are no options to change this),
+                # we use the source-directory for the include file and
+                # the build directory for the RC file and message
+                # resources. This works at least for win32all.
+                h_dir = os.path.dirname(src)
+                rc_dir = os.path.dirname(obj)
+                try:
+                    # first compile .MC to .RC and .H file
+                    self.spawn([self.mc] +
+                               ['-h', h_dir, '-r', rc_dir] + [src])
+                    base, _ = os.path.splitext (os.path.basename (src))
+                    rc_file = os.path.join (rc_dir, base + '.rc')
+                    # then compile .RC to .RES file
+                    self.spawn([self.rc] +
+                               ["/fo" + obj] + [rc_file])
+
+                except DistutilsExecError as msg:
+                    raise CompileError(msg)
+                continue
+            else:
+                # how to handle this file?
+                raise CompileError("Don't know how to compile %s to %s"
+                                   % (src, obj))
+
+            output_opt = "/Fo" + obj
+            try:
+                self.spawn([self.cc] + compile_opts + pp_opts +
+                           [input_opt, output_opt] +
+                           extra_postargs)
+            except DistutilsExecError as msg:
+                raise CompileError(msg)
+
+        return objects
+
+
+    def create_static_lib(self,
+                          objects,
+                          output_libname,
+                          output_dir=None,
+                          debug=0,
+                          target_lang=None):
+
+        if not self.initialized:
+            self.initialize()
+        (objects, output_dir) = self._fix_object_args(objects, output_dir)
+        output_filename = self.library_filename(output_libname,
+                                                output_dir=output_dir)
+
+        if self._need_link(objects, output_filename):
+            lib_args = objects + ['/OUT:' + output_filename]
+            if debug:
+                pass # XXX what goes here?
+            try:
+                self.spawn([self.lib] + lib_args)
+            except DistutilsExecError as msg:
+                raise LibError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+
+    def link(self,
+             target_desc,
+             objects,
+             output_filename,
+             output_dir=None,
+             libraries=None,
+             library_dirs=None,
+             runtime_library_dirs=None,
+             export_symbols=None,
+             debug=0,
+             extra_preargs=None,
+             extra_postargs=None,
+             build_temp=None,
+             target_lang=None):
+
+        if not self.initialized:
+            self.initialize()
+        (objects, output_dir) = self._fix_object_args(objects, output_dir)
+        fixed_args = self._fix_lib_args(libraries, library_dirs,
+                                        runtime_library_dirs)
+        (libraries, library_dirs, runtime_library_dirs) = fixed_args
+
+        if runtime_library_dirs:
+            self.warn ("I don't know what to do with 'runtime_library_dirs': "
+                       + str (runtime_library_dirs))
+
+        lib_opts = gen_lib_options(self,
+                                   library_dirs, runtime_library_dirs,
+                                   libraries)
+        if output_dir is not None:
+            output_filename = os.path.join(output_dir, output_filename)
+
+        if self._need_link(objects, output_filename):
+            if target_desc == CCompiler.EXECUTABLE:
+                if debug:
+                    ldflags = self.ldflags_shared_debug[1:]
+                else:
+                    ldflags = self.ldflags_shared[1:]
+            else:
+                if debug:
+                    ldflags = self.ldflags_shared_debug
+                else:
+                    ldflags = self.ldflags_shared
+
+            export_opts = []
+            for sym in (export_symbols or []):
+                export_opts.append("/EXPORT:" + sym)
+
+            ld_args = (ldflags + lib_opts + export_opts +
+                       objects + ['/OUT:' + output_filename])
+
+            # The MSVC linker generates .lib and .exp files, which cannot be
+            # suppressed by any linker switches. The .lib files may even be
+            # needed! Make sure they are generated in the temporary build
+            # directory. Since they have different names for debug and release
+            # builds, they can go into the same directory.
+            build_temp = os.path.dirname(objects[0])
+            if export_symbols is not None:
+                (dll_name, dll_ext) = os.path.splitext(
+                    os.path.basename(output_filename))
+                implib_file = os.path.join(
+                    build_temp,
+                    self.library_filename(dll_name))
+                ld_args.append ('/IMPLIB:' + implib_file)
+
+            self.manifest_setup_ldargs(output_filename, build_temp, ld_args)
+
+            if extra_preargs:
+                ld_args[:0] = extra_preargs
+            if extra_postargs:
+                ld_args.extend(extra_postargs)
+
+            self.mkpath(os.path.dirname(output_filename))
+            try:
+                self.spawn([self.linker] + ld_args)
+            except DistutilsExecError as msg:
+                raise LinkError(msg)
+
+            # embed the manifest
+            # XXX - this is somewhat fragile - if mt.exe fails, distutils
+            # will still consider the DLL up-to-date, but it will not have a
+            # manifest.  Maybe we should link to a temp file?  OTOH, that
+            # implies a build environment error that shouldn't go undetected.
+            mfinfo = self.manifest_get_embed_info(target_desc, ld_args)
+            if mfinfo is not None:
+                mffilename, mfid = mfinfo
+                out_arg = '-outputresource:%s;%s' % (output_filename, mfid)
+                try:
+                    self.spawn(['mt.exe', '-nologo', '-manifest',
+                                mffilename, out_arg])
+                except DistutilsExecError as msg:
+                    raise LinkError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+    def manifest_setup_ldargs(self, output_filename, build_temp, ld_args):
+        # If we need a manifest at all, an embedded manifest is recommended.
+        # See MSDN article titled
+        # "How to: Embed a Manifest Inside a C/C++ Application"
+        # (currently at http://msdn2.microsoft.com/en-us/library/ms235591(VS.80).aspx)
+        # Ask the linker to generate the manifest in the temp dir, so
+        # we can check it, and possibly embed it, later.
+        temp_manifest = os.path.join(
+                build_temp,
+                os.path.basename(output_filename) + ".manifest")
+        ld_args.append('/MANIFESTFILE:' + temp_manifest)
+
+    def manifest_get_embed_info(self, target_desc, ld_args):
+        # If a manifest should be embedded, return a tuple of
+        # (manifest_filename, resource_id).  Returns None if no manifest
+        # should be embedded.  See http://bugs.python.org/issue7833 for why
+        # we want to avoid any manifest for extension modules if we can)
+        for arg in ld_args:
+            if arg.startswith("/MANIFESTFILE:"):
+                temp_manifest = arg.split(":", 1)[1]
+                break
+        else:
+            # no /MANIFESTFILE so nothing to do.
+            return None
+        if target_desc == CCompiler.EXECUTABLE:
+            # by default, executables always get the manifest with the
+            # CRT referenced.
+            mfid = 1
+        else:
+            # Extension modules try and avoid any manifest if possible.
+            mfid = 2
+            temp_manifest = self._remove_visual_c_ref(temp_manifest)
+        if temp_manifest is None:
+            return None
+        return temp_manifest, mfid
+
+    def _remove_visual_c_ref(self, manifest_file):
+        try:
+            # Remove references to the Visual C runtime, so they will
+            # fall through to the Visual C dependency of Python.exe.
+            # This way, when installed for a restricted user (e.g.
+            # runtimes are not in WinSxS folder, but in Python's own
+            # folder), the runtimes do not need to be in every folder
+            # with .pyd's.
+            # Returns either the filename of the modified manifest or
+            # None if no manifest should be embedded.
+            manifest_f = open(manifest_file)
+            try:
+                manifest_buf = manifest_f.read()
+            finally:
+                manifest_f.close()
+            pattern = re.compile(
+                r"""<assemblyIdentity.*?name=("|')Microsoft\."""\
+                r"""VC\d{2}\.CRT("|').*?(/>|</assemblyIdentity>)""",
+                re.DOTALL)
+            manifest_buf = re.sub(pattern, "", manifest_buf)
+            pattern = r"<dependentAssembly>\s*</dependentAssembly>"
+            manifest_buf = re.sub(pattern, "", manifest_buf)
+            # Now see if any other assemblies are referenced - if not, we
+            # don't want a manifest embedded.
+            pattern = re.compile(
+                r"""<assemblyIdentity.*?name=(?:"|')(.+?)(?:"|')"""
+                r""".*?(?:/>|</assemblyIdentity>)""", re.DOTALL)
+            if re.search(pattern, manifest_buf) is None:
+                return None
+
+            manifest_f = open(manifest_file, 'w')
+            try:
+                manifest_f.write(manifest_buf)
+                return manifest_file
+            finally:
+                manifest_f.close()
+        except OSError:
+            pass
+
+    # -- Miscellaneous methods -----------------------------------------
+    # These are all used by the 'gen_lib_options() function, in
+    # ccompiler.py.
+
+    def library_dir_option(self, dir):
+        return "/LIBPATH:" + dir
+
+    def runtime_library_dir_option(self, dir):
+        raise DistutilsPlatformError(
+              "don't know how to set runtime library search path for MSVC++")
+
+    def library_option(self, lib):
+        return self.library_filename(lib)
+
+
+    def find_library_file(self, dirs, lib, debug=0):
+        # Prefer a debugging library if found (and requested), but deal
+        # with it if we don't have one.
+        if debug:
+            try_names = [lib + "_d", lib]
+        else:
+            try_names = [lib]
+        for dir in dirs:
+            for name in try_names:
+                libfile = os.path.join(dir, self.library_filename (name))
+                if os.path.exists(libfile):
+                    return libfile
+        else:
+            # Oops, didn't find it in *any* of 'dirs'
+            return None
+
+    # Helper methods for using the MSVC registry settings
+
+    def find_exe(self, exe):
+        """Return path to an MSVC executable program.
+
+        Tries to find the program in several places: first, one of the
+        MSVC program search paths from the registry; next, the directories
+        in the PATH environment variable.  If any of those work, return an
+        absolute path that is known to exist.  If none of them work, just
+        return the original program name, 'exe'.
+        """
+        for p in self.__paths:
+            fn = os.path.join(os.path.abspath(p), exe)
+            if os.path.isfile(fn):
+                return fn
+
+        # didn't find it; try existing path
+        for p in os.environ['Path'].split(';'):
+            fn = os.path.join(os.path.abspath(p),exe)
+            if os.path.isfile(fn):
+                return fn
+
+        return exe
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/msvccompiler.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/msvccompiler.py
new file mode 100644
index 0000000..d5857cb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/msvccompiler.py
@@ -0,0 +1,643 @@
+"""distutils.msvccompiler
+
+Contains MSVCCompiler, an implementation of the abstract CCompiler class
+for the Microsoft Visual Studio.
+"""
+
+# Written by Perry Stoll
+# hacked by Robin Becker and Thomas Heller to do a better job of
+#   finding DevStudio (through the registry)
+
+import sys, os
+from distutils.errors import \
+     DistutilsExecError, DistutilsPlatformError, \
+     CompileError, LibError, LinkError
+from distutils.ccompiler import \
+     CCompiler, gen_lib_options
+from distutils import log
+
+_can_read_reg = False
+try:
+    import winreg
+
+    _can_read_reg = True
+    hkey_mod = winreg
+
+    RegOpenKeyEx = winreg.OpenKeyEx
+    RegEnumKey = winreg.EnumKey
+    RegEnumValue = winreg.EnumValue
+    RegError = winreg.error
+
+except ImportError:
+    try:
+        import win32api
+        import win32con
+        _can_read_reg = True
+        hkey_mod = win32con
+
+        RegOpenKeyEx = win32api.RegOpenKeyEx
+        RegEnumKey = win32api.RegEnumKey
+        RegEnumValue = win32api.RegEnumValue
+        RegError = win32api.error
+    except ImportError:
+        log.info("Warning: Can't read registry to find the "
+                 "necessary compiler setting\n"
+                 "Make sure that Python modules winreg, "
+                 "win32api or win32con are installed.")
+        pass
+
+if _can_read_reg:
+    HKEYS = (hkey_mod.HKEY_USERS,
+             hkey_mod.HKEY_CURRENT_USER,
+             hkey_mod.HKEY_LOCAL_MACHINE,
+             hkey_mod.HKEY_CLASSES_ROOT)
+
+def read_keys(base, key):
+    """Return list of registry keys."""
+    try:
+        handle = RegOpenKeyEx(base, key)
+    except RegError:
+        return None
+    L = []
+    i = 0
+    while True:
+        try:
+            k = RegEnumKey(handle, i)
+        except RegError:
+            break
+        L.append(k)
+        i += 1
+    return L
+
+def read_values(base, key):
+    """Return dict of registry keys and values.
+
+    All names are converted to lowercase.
+    """
+    try:
+        handle = RegOpenKeyEx(base, key)
+    except RegError:
+        return None
+    d = {}
+    i = 0
+    while True:
+        try:
+            name, value, type = RegEnumValue(handle, i)
+        except RegError:
+            break
+        name = name.lower()
+        d[convert_mbcs(name)] = convert_mbcs(value)
+        i += 1
+    return d
+
+def convert_mbcs(s):
+    dec = getattr(s, "decode", None)
+    if dec is not None:
+        try:
+            s = dec("mbcs")
+        except UnicodeError:
+            pass
+    return s
+
+class MacroExpander:
+    def __init__(self, version):
+        self.macros = {}
+        self.load_macros(version)
+
+    def set_macro(self, macro, path, key):
+        for base in HKEYS:
+            d = read_values(base, path)
+            if d:
+                self.macros["$(%s)" % macro] = d[key]
+                break
+
+    def load_macros(self, version):
+        vsbase = r"Software\Microsoft\VisualStudio\%0.1f" % version
+        self.set_macro("VCInstallDir", vsbase + r"\Setup\VC", "productdir")
+        self.set_macro("VSInstallDir", vsbase + r"\Setup\VS", "productdir")
+        net = r"Software\Microsoft\.NETFramework"
+        self.set_macro("FrameworkDir", net, "installroot")
+        try:
+            if version > 7.0:
+                self.set_macro("FrameworkSDKDir", net, "sdkinstallrootv1.1")
+            else:
+                self.set_macro("FrameworkSDKDir", net, "sdkinstallroot")
+        except KeyError as exc: #
+            raise DistutilsPlatformError(
+            """Python was built with Visual Studio 2003;
+extensions must be built with a compiler than can generate compatible binaries.
+Visual Studio 2003 was not found on this system. If you have Cygwin installed,
+you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""")
+
+        p = r"Software\Microsoft\NET Framework Setup\Product"
+        for base in HKEYS:
+            try:
+                h = RegOpenKeyEx(base, p)
+            except RegError:
+                continue
+            key = RegEnumKey(h, 0)
+            d = read_values(base, r"%s\%s" % (p, key))
+            self.macros["$(FrameworkVersion)"] = d["version"]
+
+    def sub(self, s):
+        for k, v in self.macros.items():
+            s = s.replace(k, v)
+        return s
+
+def get_build_version():
+    """Return the version of MSVC that was used to build Python.
+
+    For Python 2.3 and up, the version number is included in
+    sys.version.  For earlier versions, assume the compiler is MSVC 6.
+    """
+    prefix = "MSC v."
+    i = sys.version.find(prefix)
+    if i == -1:
+        return 6
+    i = i + len(prefix)
+    s, rest = sys.version[i:].split(" ", 1)
+    majorVersion = int(s[:-2]) - 6
+    if majorVersion >= 13:
+        # v13 was skipped and should be v14
+        majorVersion += 1
+    minorVersion = int(s[2:3]) / 10.0
+    # I don't think paths are affected by minor version in version 6
+    if majorVersion == 6:
+        minorVersion = 0
+    if majorVersion >= 6:
+        return majorVersion + minorVersion
+    # else we don't know what version of the compiler this is
+    return None
+
+def get_build_architecture():
+    """Return the processor architecture.
+
+    Possible results are "Intel" or "AMD64".
+    """
+
+    prefix = " bit ("
+    i = sys.version.find(prefix)
+    if i == -1:
+        return "Intel"
+    j = sys.version.find(")", i)
+    return sys.version[i+len(prefix):j]
+
+def normalize_and_reduce_paths(paths):
+    """Return a list of normalized paths with duplicates removed.
+
+    The current order of paths is maintained.
+    """
+    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
+    reduced_paths = []
+    for p in paths:
+        np = os.path.normpath(p)
+        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
+        if np not in reduced_paths:
+            reduced_paths.append(np)
+    return reduced_paths
+
+
+class MSVCCompiler(CCompiler) :
+    """Concrete class that implements an interface to Microsoft Visual C++,
+       as defined by the CCompiler abstract class."""
+
+    compiler_type = 'msvc'
+
+    # Just set this so CCompiler's constructor doesn't barf.  We currently
+    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
+    # as it really isn't necessary for this sort of single-compiler class.
+    # Would be nice to have a consistent interface with UnixCCompiler,
+    # though, so it's worth thinking about.
+    executables = {}
+
+    # Private class data (need to distinguish C from C++ source for compiler)
+    _c_extensions = ['.c']
+    _cpp_extensions = ['.cc', '.cpp', '.cxx']
+    _rc_extensions = ['.rc']
+    _mc_extensions = ['.mc']
+
+    # Needed for the filename generation methods provided by the
+    # base class, CCompiler.
+    src_extensions = (_c_extensions + _cpp_extensions +
+                      _rc_extensions + _mc_extensions)
+    res_extension = '.res'
+    obj_extension = '.obj'
+    static_lib_extension = '.lib'
+    shared_lib_extension = '.dll'
+    static_lib_format = shared_lib_format = '%s%s'
+    exe_extension = '.exe'
+
+    def __init__(self, verbose=0, dry_run=0, force=0):
+        CCompiler.__init__ (self, verbose, dry_run, force)
+        self.__version = get_build_version()
+        self.__arch = get_build_architecture()
+        if self.__arch == "Intel":
+            # x86
+            if self.__version >= 7:
+                self.__root = r"Software\Microsoft\VisualStudio"
+                self.__macros = MacroExpander(self.__version)
+            else:
+                self.__root = r"Software\Microsoft\Devstudio"
+            self.__product = "Visual Studio version %s" % self.__version
+        else:
+            # Win64. Assume this was built with the platform SDK
+            self.__product = "Microsoft SDK compiler %s" % (self.__version + 6)
+
+        self.initialized = False
+
+    def initialize(self):
+        self.__paths = []
+        if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"):
+            # Assume that the SDK set up everything alright; don't try to be
+            # smarter
+            self.cc = "cl.exe"
+            self.linker = "link.exe"
+            self.lib = "lib.exe"
+            self.rc = "rc.exe"
+            self.mc = "mc.exe"
+        else:
+            self.__paths = self.get_msvc_paths("path")
+
+            if len(self.__paths) == 0:
+                raise DistutilsPlatformError("Python was built with %s, "
+                       "and extensions need to be built with the same "
+                       "version of the compiler, but it isn't installed."
+                       % self.__product)
+
+            self.cc = self.find_exe("cl.exe")
+            self.linker = self.find_exe("link.exe")
+            self.lib = self.find_exe("lib.exe")
+            self.rc = self.find_exe("rc.exe")   # resource compiler
+            self.mc = self.find_exe("mc.exe")   # message compiler
+            self.set_path_env_var('lib')
+            self.set_path_env_var('include')
+
+        # extend the MSVC path with the current path
+        try:
+            for p in os.environ['path'].split(';'):
+                self.__paths.append(p)
+        except KeyError:
+            pass
+        self.__paths = normalize_and_reduce_paths(self.__paths)
+        os.environ['path'] = ";".join(self.__paths)
+
+        self.preprocess_options = None
+        if self.__arch == "Intel":
+            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GX' ,
+                                     '/DNDEBUG']
+            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GX',
+                                          '/Z7', '/D_DEBUG']
+        else:
+            # Win64
+            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GS-' ,
+                                     '/DNDEBUG']
+            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-',
+                                          '/Z7', '/D_DEBUG']
+
+        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
+        if self.__version >= 7:
+            self.ldflags_shared_debug = [
+                '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
+                ]
+        else:
+            self.ldflags_shared_debug = [
+                '/DLL', '/nologo', '/INCREMENTAL:no', '/pdb:None', '/DEBUG'
+                ]
+        self.ldflags_static = [ '/nologo']
+
+        self.initialized = True
+
+    # -- Worker methods ------------------------------------------------
+
+    def object_filenames(self,
+                         source_filenames,
+                         strip_dir=0,
+                         output_dir=''):
+        # Copied from ccompiler.py, extended to return .res as 'object'-file
+        # for .rc input file
+        if output_dir is None: output_dir = ''
+        obj_names = []
+        for src_name in source_filenames:
+            (base, ext) = os.path.splitext (src_name)
+            base = os.path.splitdrive(base)[1] # Chop off the drive
+            base = base[os.path.isabs(base):]  # If abs, chop off leading /
+            if ext not in self.src_extensions:
+                # Better to raise an exception instead of silently continuing
+                # and later complain about sources and targets having
+                # different lengths
+                raise CompileError ("Don't know how to compile %s" % src_name)
+            if strip_dir:
+                base = os.path.basename (base)
+            if ext in self._rc_extensions:
+                obj_names.append (os.path.join (output_dir,
+                                                base + self.res_extension))
+            elif ext in self._mc_extensions:
+                obj_names.append (os.path.join (output_dir,
+                                                base + self.res_extension))
+            else:
+                obj_names.append (os.path.join (output_dir,
+                                                base + self.obj_extension))
+        return obj_names
+
+
+    def compile(self, sources,
+                output_dir=None, macros=None, include_dirs=None, debug=0,
+                extra_preargs=None, extra_postargs=None, depends=None):
+
+        if not self.initialized:
+            self.initialize()
+        compile_info = self._setup_compile(output_dir, macros, include_dirs,
+                                           sources, depends, extra_postargs)
+        macros, objects, extra_postargs, pp_opts, build = compile_info
+
+        compile_opts = extra_preargs or []
+        compile_opts.append ('/c')
+        if debug:
+            compile_opts.extend(self.compile_options_debug)
+        else:
+            compile_opts.extend(self.compile_options)
+
+        for obj in objects:
+            try:
+                src, ext = build[obj]
+            except KeyError:
+                continue
+            if debug:
+                # pass the full pathname to MSVC in debug mode,
+                # this allows the debugger to find the source file
+                # without asking the user to browse for it
+                src = os.path.abspath(src)
+
+            if ext in self._c_extensions:
+                input_opt = "/Tc" + src
+            elif ext in self._cpp_extensions:
+                input_opt = "/Tp" + src
+            elif ext in self._rc_extensions:
+                # compile .RC to .RES file
+                input_opt = src
+                output_opt = "/fo" + obj
+                try:
+                    self.spawn([self.rc] + pp_opts +
+                               [output_opt] + [input_opt])
+                except DistutilsExecError as msg:
+                    raise CompileError(msg)
+                continue
+            elif ext in self._mc_extensions:
+                # Compile .MC to .RC file to .RES file.
+                #   * '-h dir' specifies the directory for the
+                #     generated include file
+                #   * '-r dir' specifies the target directory of the
+                #     generated RC file and the binary message resource
+                #     it includes
+                #
+                # For now (since there are no options to change this),
+                # we use the source-directory for the include file and
+                # the build directory for the RC file and message
+                # resources. This works at least for win32all.
+                h_dir = os.path.dirname(src)
+                rc_dir = os.path.dirname(obj)
+                try:
+                    # first compile .MC to .RC and .H file
+                    self.spawn([self.mc] +
+                               ['-h', h_dir, '-r', rc_dir] + [src])
+                    base, _ = os.path.splitext (os.path.basename (src))
+                    rc_file = os.path.join (rc_dir, base + '.rc')
+                    # then compile .RC to .RES file
+                    self.spawn([self.rc] +
+                               ["/fo" + obj] + [rc_file])
+
+                except DistutilsExecError as msg:
+                    raise CompileError(msg)
+                continue
+            else:
+                # how to handle this file?
+                raise CompileError("Don't know how to compile %s to %s"
+                                   % (src, obj))
+
+            output_opt = "/Fo" + obj
+            try:
+                self.spawn([self.cc] + compile_opts + pp_opts +
+                           [input_opt, output_opt] +
+                           extra_postargs)
+            except DistutilsExecError as msg:
+                raise CompileError(msg)
+
+        return objects
+
+
+    def create_static_lib(self,
+                          objects,
+                          output_libname,
+                          output_dir=None,
+                          debug=0,
+                          target_lang=None):
+
+        if not self.initialized:
+            self.initialize()
+        (objects, output_dir) = self._fix_object_args(objects, output_dir)
+        output_filename = self.library_filename(output_libname,
+                                                output_dir=output_dir)
+
+        if self._need_link(objects, output_filename):
+            lib_args = objects + ['/OUT:' + output_filename]
+            if debug:
+                pass # XXX what goes here?
+            try:
+                self.spawn([self.lib] + lib_args)
+            except DistutilsExecError as msg:
+                raise LibError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+
+    def link(self,
+             target_desc,
+             objects,
+             output_filename,
+             output_dir=None,
+             libraries=None,
+             library_dirs=None,
+             runtime_library_dirs=None,
+             export_symbols=None,
+             debug=0,
+             extra_preargs=None,
+             extra_postargs=None,
+             build_temp=None,
+             target_lang=None):
+
+        if not self.initialized:
+            self.initialize()
+        (objects, output_dir) = self._fix_object_args(objects, output_dir)
+        fixed_args = self._fix_lib_args(libraries, library_dirs,
+                                        runtime_library_dirs)
+        (libraries, library_dirs, runtime_library_dirs) = fixed_args
+
+        if runtime_library_dirs:
+            self.warn ("I don't know what to do with 'runtime_library_dirs': "
+                       + str (runtime_library_dirs))
+
+        lib_opts = gen_lib_options(self,
+                                   library_dirs, runtime_library_dirs,
+                                   libraries)
+        if output_dir is not None:
+            output_filename = os.path.join(output_dir, output_filename)
+
+        if self._need_link(objects, output_filename):
+            if target_desc == CCompiler.EXECUTABLE:
+                if debug:
+                    ldflags = self.ldflags_shared_debug[1:]
+                else:
+                    ldflags = self.ldflags_shared[1:]
+            else:
+                if debug:
+                    ldflags = self.ldflags_shared_debug
+                else:
+                    ldflags = self.ldflags_shared
+
+            export_opts = []
+            for sym in (export_symbols or []):
+                export_opts.append("/EXPORT:" + sym)
+
+            ld_args = (ldflags + lib_opts + export_opts +
+                       objects + ['/OUT:' + output_filename])
+
+            # The MSVC linker generates .lib and .exp files, which cannot be
+            # suppressed by any linker switches. The .lib files may even be
+            # needed! Make sure they are generated in the temporary build
+            # directory. Since they have different names for debug and release
+            # builds, they can go into the same directory.
+            if export_symbols is not None:
+                (dll_name, dll_ext) = os.path.splitext(
+                    os.path.basename(output_filename))
+                implib_file = os.path.join(
+                    os.path.dirname(objects[0]),
+                    self.library_filename(dll_name))
+                ld_args.append ('/IMPLIB:' + implib_file)
+
+            if extra_preargs:
+                ld_args[:0] = extra_preargs
+            if extra_postargs:
+                ld_args.extend(extra_postargs)
+
+            self.mkpath(os.path.dirname(output_filename))
+            try:
+                self.spawn([self.linker] + ld_args)
+            except DistutilsExecError as msg:
+                raise LinkError(msg)
+
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+
+    # -- Miscellaneous methods -----------------------------------------
+    # These are all used by the 'gen_lib_options() function, in
+    # ccompiler.py.
+
+    def library_dir_option(self, dir):
+        return "/LIBPATH:" + dir
+
+    def runtime_library_dir_option(self, dir):
+        raise DistutilsPlatformError(
+              "don't know how to set runtime library search path for MSVC++")
+
+    def library_option(self, lib):
+        return self.library_filename(lib)
+
+
+    def find_library_file(self, dirs, lib, debug=0):
+        # Prefer a debugging library if found (and requested), but deal
+        # with it if we don't have one.
+        if debug:
+            try_names = [lib + "_d", lib]
+        else:
+            try_names = [lib]
+        for dir in dirs:
+            for name in try_names:
+                libfile = os.path.join(dir, self.library_filename (name))
+                if os.path.exists(libfile):
+                    return libfile
+        else:
+            # Oops, didn't find it in *any* of 'dirs'
+            return None
+
+    # Helper methods for using the MSVC registry settings
+
+    def find_exe(self, exe):
+        """Return path to an MSVC executable program.
+
+        Tries to find the program in several places: first, one of the
+        MSVC program search paths from the registry; next, the directories
+        in the PATH environment variable.  If any of those work, return an
+        absolute path that is known to exist.  If none of them work, just
+        return the original program name, 'exe'.
+        """
+        for p in self.__paths:
+            fn = os.path.join(os.path.abspath(p), exe)
+            if os.path.isfile(fn):
+                return fn
+
+        # didn't find it; try existing path
+        for p in os.environ['Path'].split(';'):
+            fn = os.path.join(os.path.abspath(p),exe)
+            if os.path.isfile(fn):
+                return fn
+
+        return exe
+
+    def get_msvc_paths(self, path, platform='x86'):
+        """Get a list of devstudio directories (include, lib or path).
+
+        Return a list of strings.  The list will be empty if unable to
+        access the registry or appropriate registry keys not found.
+        """
+        if not _can_read_reg:
+            return []
+
+        path = path + " dirs"
+        if self.__version >= 7:
+            key = (r"%s\%0.1f\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directories"
+                   % (self.__root, self.__version))
+        else:
+            key = (r"%s\6.0\Build System\Components\Platforms"
+                   r"\Win32 (%s)\Directories" % (self.__root, platform))
+
+        for base in HKEYS:
+            d = read_values(base, key)
+            if d:
+                if self.__version >= 7:
+                    return self.__macros.sub(d[path]).split(";")
+                else:
+                    return d[path].split(";")
+        # MSVC 6 seems to create the registry entries we need only when
+        # the GUI is run.
+        if self.__version == 6:
+            for base in HKEYS:
+                if read_values(base, r"%s\6.0" % self.__root) is not None:
+                    self.warn("It seems you have Visual Studio 6 installed, "
+                        "but the expected registry settings are not present.\n"
+                        "You must at least run the Visual Studio GUI once "
+                        "so that these entries are created.")
+                    break
+        return []
+
+    def set_path_env_var(self, name):
+        """Set environment variable 'name' to an MSVC path type value.
+
+        This is equivalent to a SET command prior to execution of spawned
+        commands.
+        """
+
+        if name == "lib":
+            p = self.get_msvc_paths("library")
+        else:
+            p = self.get_msvc_paths(name)
+        if p:
+            os.environ[name] = ';'.join(p)
+
+
+if get_build_version() >= 8.0:
+    log.debug("Importing new compiler from distutils.msvc9compiler")
+    OldMSVCCompiler = MSVCCompiler
+    from distutils.msvc9compiler import MSVCCompiler
+    # get_build_architecture not really relevant now we support cross-compile
+    from distutils.msvc9compiler import MacroExpander
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/spawn.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/spawn.py
new file mode 100644
index 0000000..fc592d4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/spawn.py
@@ -0,0 +1,125 @@
+"""distutils.spawn
+
+Provides the 'spawn()' function, a front-end to various platform-
+specific functions for launching another program in a sub-process.
+Also provides the 'find_executable()' to search the path for a given
+executable name.
+"""
+
+import sys
+import os
+import subprocess
+
+from distutils.errors import DistutilsPlatformError, DistutilsExecError
+from distutils.debug import DEBUG
+from distutils import log
+
+
+if sys.platform == 'darwin':
+    _cfg_target = None
+    _cfg_target_split = None
+
+
+def spawn(cmd, search_path=1, verbose=0, dry_run=0, env=None):
+    """Run another program, specified as a command list 'cmd', in a new process.
+
+    'cmd' is just the argument list for the new process, ie.
+    cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
+    There is no way to run a program with a name different from that of its
+    executable.
+
+    If 'search_path' is true (the default), the system's executable
+    search path will be used to find the program; otherwise, cmd[0]
+    must be the exact path to the executable.  If 'dry_run' is true,
+    the command will not actually be run.
+
+    Raise DistutilsExecError if running the program fails in any way; just
+    return on success.
+    """
+    # cmd is documented as a list, but just in case some code passes a tuple
+    # in, protect our %-formatting code against horrible death
+    cmd = list(cmd)
+
+    log.info(' '.join(cmd))
+    if dry_run:
+        return
+
+    if search_path:
+        executable = find_executable(cmd[0])
+        if executable is not None:
+            cmd[0] = executable
+
+    env = env if env is not None else dict(os.environ)
+
+    if sys.platform == 'darwin':
+        global _cfg_target, _cfg_target_split
+        if _cfg_target is None:
+            from distutils import sysconfig
+            _cfg_target = sysconfig.get_config_var(
+                                  'MACOSX_DEPLOYMENT_TARGET') or ''
+            if _cfg_target:
+                _cfg_target_split = [int(x) for x in _cfg_target.split('.')]
+        if _cfg_target:
+            # ensure that the deployment target of build process is not less
+            # than that used when the interpreter was built. This ensures
+            # extension modules are built with correct compatibility values
+            cur_target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', _cfg_target)
+            if _cfg_target_split > [int(x) for x in cur_target.split('.')]:
+                my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: '
+                          'now "%s" but "%s" during configure'
+                                % (cur_target, _cfg_target))
+                raise DistutilsPlatformError(my_msg)
+            env.update(MACOSX_DEPLOYMENT_TARGET=cur_target)
+
+    try:
+        proc = subprocess.Popen(cmd, env=env)
+        proc.wait()
+        exitcode = proc.returncode
+    except OSError as exc:
+        if not DEBUG:
+            cmd = cmd[0]
+        raise DistutilsExecError(
+            "command %r failed: %s" % (cmd, exc.args[-1])) from exc
+
+    if exitcode:
+        if not DEBUG:
+            cmd = cmd[0]
+        raise DistutilsExecError(
+              "command %r failed with exit code %s" % (cmd, exitcode))
+
+
+def find_executable(executable, path=None):
+    """Tries to find 'executable' in the directories listed in 'path'.
+
+    A string listing directories separated by 'os.pathsep'; defaults to
+    os.environ['PATH'].  Returns the complete filename or None if not found.
+    """
+    _, ext = os.path.splitext(executable)
+    if (sys.platform == 'win32') and (ext != '.exe'):
+        executable = executable + '.exe'
+
+    if os.path.isfile(executable):
+        return executable
+
+    if path is None:
+        path = os.environ.get('PATH', None)
+        if path is None:
+            try:
+                path = os.confstr("CS_PATH")
+            except (AttributeError, ValueError):
+                # os.confstr() or CS_PATH is not available
+                path = os.defpath
+        # bpo-35755: Don't use os.defpath if the PATH environment variable is
+        # set to an empty string
+
+    # PATH='' doesn't match, whereas PATH=':' looks in the current directory
+    if not path:
+        return None
+
+    paths = path.split(os.pathsep)
+    for p in paths:
+        f = os.path.join(p, executable)
+        if os.path.isfile(f):
+            # the file exists, we have a shot at spawn working
+            return f
+    return None
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/sysconfig.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/sysconfig.py
new file mode 100644
index 0000000..879b698
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/sysconfig.py
@@ -0,0 +1,573 @@
+"""Provide access to Python's configuration information.  The specific
+configuration variables available depend heavily on the platform and
+configuration.  The values may be retrieved using
+get_config_var(name), and the list of variables is available via
+get_config_vars().keys().  Additional convenience functions are also
+available.
+
+Written by:   Fred L. Drake, Jr.
+Email:        <fdrake@acm.org>
+"""
+
+import _imp
+import os
+import re
+import sys
+
+from .errors import DistutilsPlatformError
+
+IS_PYPY = '__pypy__' in sys.builtin_module_names
+
+# These are needed in a couple of spots, so just compute them once.
+PREFIX = os.path.normpath(sys.prefix)
+EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
+BASE_PREFIX = os.path.normpath(sys.base_prefix)
+BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix)
+
+# Path to the base directory of the project. On Windows the binary may
+# live in project/PCbuild/win32 or project/PCbuild/amd64.
+# set for cross builds
+if "_PYTHON_PROJECT_BASE" in os.environ:
+    project_base = os.path.abspath(os.environ["_PYTHON_PROJECT_BASE"])
+else:
+    if sys.executable:
+        project_base = os.path.dirname(os.path.abspath(sys.executable))
+    else:
+        # sys.executable can be empty if argv[0] has been changed and Python is
+        # unable to retrieve the real program name
+        project_base = os.getcwd()
+
+
+# python_build: (Boolean) if true, we're either building Python or
+# building an extension with an un-installed Python, so we use
+# different (hard-wired) directories.
+def _is_python_source_dir(d):
+    for fn in ("Setup", "Setup.local"):
+        if os.path.isfile(os.path.join(d, "Modules", fn)):
+            return True
+    return False
+
+_sys_home = getattr(sys, '_home', None)
+
+if os.name == 'nt':
+    def _fix_pcbuild(d):
+        if d and os.path.normcase(d).startswith(
+                os.path.normcase(os.path.join(PREFIX, "PCbuild"))):
+            return PREFIX
+        return d
+    project_base = _fix_pcbuild(project_base)
+    _sys_home = _fix_pcbuild(_sys_home)
+
+def _python_build():
+    if _sys_home:
+        return _is_python_source_dir(_sys_home)
+    return _is_python_source_dir(project_base)
+
+python_build = _python_build()
+
+
+# Calculate the build qualifier flags if they are defined.  Adding the flags
+# to the include and lib directories only makes sense for an installation, not
+# an in-source build.
+build_flags = ''
+try:
+    if not python_build:
+        build_flags = sys.abiflags
+except AttributeError:
+    # It's not a configure-based build, so the sys module doesn't have
+    # this attribute, which is fine.
+    pass
+
+def get_python_version():
+    """Return a string containing the major and minor Python version,
+    leaving off the patchlevel.  Sample return values could be '1.5'
+    or '2.2'.
+    """
+    return '%d.%d' % sys.version_info[:2]
+
+
+def get_python_inc(plat_specific=0, prefix=None):
+    """Return the directory containing installed Python header files.
+
+    If 'plat_specific' is false (the default), this is the path to the
+    non-platform-specific header files, i.e. Python.h and so on;
+    otherwise, this is the path to platform-specific header files
+    (namely pyconfig.h).
+
+    If 'prefix' is supplied, use it instead of sys.base_prefix or
+    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
+    """
+    if prefix is None:
+        prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
+    if IS_PYPY:
+        return os.path.join(prefix, 'include')
+    elif os.name == "posix":
+        if python_build:
+            # Assume the executable is in the build directory.  The
+            # pyconfig.h file should be in the same directory.  Since
+            # the build directory may not be the source directory, we
+            # must use "srcdir" from the makefile to find the "Include"
+            # directory.
+            if plat_specific:
+                return _sys_home or project_base
+            else:
+                incdir = os.path.join(get_config_var('srcdir'), 'Include')
+                return os.path.normpath(incdir)
+        python_dir = 'python' + get_python_version() + build_flags
+        return os.path.join(prefix, "include", python_dir)
+    elif os.name == "nt":
+        if python_build:
+            # Include both the include and PC dir to ensure we can find
+            # pyconfig.h
+            return (os.path.join(prefix, "include") + os.path.pathsep +
+                    os.path.join(prefix, "PC"))
+        return os.path.join(prefix, "include")
+    else:
+        raise DistutilsPlatformError(
+            "I don't know where Python installs its C header files "
+            "on platform '%s'" % os.name)
+
+
+def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
+    """Return the directory containing the Python library (standard or
+    site additions).
+
+    If 'plat_specific' is true, return the directory containing
+    platform-specific modules, i.e. any module from a non-pure-Python
+    module distribution; otherwise, return the platform-shared library
+    directory.  If 'standard_lib' is true, return the directory
+    containing standard Python library modules; otherwise, return the
+    directory for site-specific modules.
+
+    If 'prefix' is supplied, use it instead of sys.base_prefix or
+    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
+    """
+    if IS_PYPY:
+        # PyPy-specific schema
+        if prefix is None:
+            prefix = PREFIX
+        if standard_lib:
+            return os.path.join(prefix, "lib-python", sys.version[0])
+        return os.path.join(prefix, 'site-packages')
+
+    if prefix is None:
+        if standard_lib:
+            prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
+        else:
+            prefix = plat_specific and EXEC_PREFIX or PREFIX
+
+    if os.name == "posix":
+        if plat_specific or standard_lib:
+            # Platform-specific modules (any module from a non-pure-Python
+            # module distribution) or standard Python library modules.
+            libdir = getattr(sys, "platlibdir", "lib")
+        else:
+            # Pure Python
+            libdir = "lib"
+        libpython = os.path.join(prefix, libdir,
+                                 "python" + get_python_version())
+        if standard_lib:
+            return libpython
+        else:
+            return os.path.join(libpython, "site-packages")
+    elif os.name == "nt":
+        if standard_lib:
+            return os.path.join(prefix, "Lib")
+        else:
+            return os.path.join(prefix, "Lib", "site-packages")
+    else:
+        raise DistutilsPlatformError(
+            "I don't know where Python installs its library "
+            "on platform '%s'" % os.name)
+
+
+
+def customize_compiler(compiler):
+    """Do any platform-specific customization of a CCompiler instance.
+
+    Mainly needed on Unix, so we can plug in the information that
+    varies across Unices and is stored in Python's Makefile.
+    """
+    if compiler.compiler_type == "unix":
+        if sys.platform == "darwin":
+            # Perform first-time customization of compiler-related
+            # config vars on OS X now that we know we need a compiler.
+            # This is primarily to support Pythons from binary
+            # installers.  The kind and paths to build tools on
+            # the user system may vary significantly from the system
+            # that Python itself was built on.  Also the user OS
+            # version and build tools may not support the same set
+            # of CPU architectures for universal builds.
+            global _config_vars
+            # Use get_config_var() to ensure _config_vars is initialized.
+            if not get_config_var('CUSTOMIZED_OSX_COMPILER'):
+                import _osx_support
+                _osx_support.customize_compiler(_config_vars)
+                _config_vars['CUSTOMIZED_OSX_COMPILER'] = 'True'
+
+        (cc, cxx, cflags, ccshared, ldshared, shlib_suffix, ar, ar_flags) = \
+            get_config_vars('CC', 'CXX', 'CFLAGS',
+                            'CCSHARED', 'LDSHARED', 'SHLIB_SUFFIX', 'AR', 'ARFLAGS')
+
+        if 'CC' in os.environ:
+            newcc = os.environ['CC']
+            if (sys.platform == 'darwin'
+                    and 'LDSHARED' not in os.environ
+                    and ldshared.startswith(cc)):
+                # On OS X, if CC is overridden, use that as the default
+                #       command for LDSHARED as well
+                ldshared = newcc + ldshared[len(cc):]
+            cc = newcc
+        if 'CXX' in os.environ:
+            cxx = os.environ['CXX']
+        if 'LDSHARED' in os.environ:
+            ldshared = os.environ['LDSHARED']
+        if 'CPP' in os.environ:
+            cpp = os.environ['CPP']
+        else:
+            cpp = cc + " -E"           # not always
+        if 'LDFLAGS' in os.environ:
+            ldshared = ldshared + ' ' + os.environ['LDFLAGS']
+        if 'CFLAGS' in os.environ:
+            cflags = cflags + ' ' + os.environ['CFLAGS']
+            ldshared = ldshared + ' ' + os.environ['CFLAGS']
+        if 'CPPFLAGS' in os.environ:
+            cpp = cpp + ' ' + os.environ['CPPFLAGS']
+            cflags = cflags + ' ' + os.environ['CPPFLAGS']
+            ldshared = ldshared + ' ' + os.environ['CPPFLAGS']
+        if 'AR' in os.environ:
+            ar = os.environ['AR']
+        if 'ARFLAGS' in os.environ:
+            archiver = ar + ' ' + os.environ['ARFLAGS']
+        else:
+            archiver = ar + ' ' + ar_flags
+
+        cc_cmd = cc + ' ' + cflags
+        compiler.set_executables(
+            preprocessor=cpp,
+            compiler=cc_cmd,
+            compiler_so=cc_cmd + ' ' + ccshared,
+            compiler_cxx=cxx,
+            linker_so=ldshared,
+            linker_exe=cc,
+            archiver=archiver)
+
+        compiler.shared_lib_extension = shlib_suffix
+
+
+def get_config_h_filename():
+    """Return full pathname of installed pyconfig.h file."""
+    if python_build:
+        if os.name == "nt":
+            inc_dir = os.path.join(_sys_home or project_base, "PC")
+        else:
+            inc_dir = _sys_home or project_base
+    else:
+        inc_dir = get_python_inc(plat_specific=1)
+
+    return os.path.join(inc_dir, 'pyconfig.h')
+
+
+def get_makefile_filename():
+    """Return full pathname of installed Makefile from the Python build."""
+    if python_build:
+        return os.path.join(_sys_home or project_base, "Makefile")
+    lib_dir = get_python_lib(plat_specific=0, standard_lib=1)
+    config_file = 'config-{}{}'.format(get_python_version(), build_flags)
+    if hasattr(sys.implementation, '_multiarch'):
+        config_file += '-%s' % sys.implementation._multiarch
+    return os.path.join(lib_dir, config_file, 'Makefile')
+
+
+def parse_config_h(fp, g=None):
+    """Parse a config.h-style file.
+
+    A dictionary containing name/value pairs is returned.  If an
+    optional dictionary is passed in as the second argument, it is
+    used instead of a new dictionary.
+    """
+    if g is None:
+        g = {}
+    define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
+    undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
+    #
+    while True:
+        line = fp.readline()
+        if not line:
+            break
+        m = define_rx.match(line)
+        if m:
+            n, v = m.group(1, 2)
+            try: v = int(v)
+            except ValueError: pass
+            g[n] = v
+        else:
+            m = undef_rx.match(line)
+            if m:
+                g[m.group(1)] = 0
+    return g
+
+
+# Regexes needed for parsing Makefile (and similar syntaxes,
+# like old-style Setup files).
+_variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
+_findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
+_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
+
+def parse_makefile(fn, g=None):
+    """Parse a Makefile-style file.
+
+    A dictionary containing name/value pairs is returned.  If an
+    optional dictionary is passed in as the second argument, it is
+    used instead of a new dictionary.
+    """
+    from distutils.text_file import TextFile
+    fp = TextFile(fn, strip_comments=1, skip_blanks=1, join_lines=1, errors="surrogateescape")
+
+    if g is None:
+        g = {}
+    done = {}
+    notdone = {}
+
+    while True:
+        line = fp.readline()
+        if line is None: # eof
+            break
+        m = _variable_rx.match(line)
+        if m:
+            n, v = m.group(1, 2)
+            v = v.strip()
+            # `$$' is a literal `$' in make
+            tmpv = v.replace('$$', '')
+
+            if "$" in tmpv:
+                notdone[n] = v
+            else:
+                try:
+                    v = int(v)
+                except ValueError:
+                    # insert literal `$'
+                    done[n] = v.replace('$$', '$')
+                else:
+                    done[n] = v
+
+    # Variables with a 'PY_' prefix in the makefile. These need to
+    # be made available without that prefix through sysconfig.
+    # Special care is needed to ensure that variable expansion works, even
+    # if the expansion uses the name without a prefix.
+    renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')
+
+    # do variable interpolation here
+    while notdone:
+        for name in list(notdone):
+            value = notdone[name]
+            m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
+            if m:
+                n = m.group(1)
+                found = True
+                if n in done:
+                    item = str(done[n])
+                elif n in notdone:
+                    # get it on a subsequent round
+                    found = False
+                elif n in os.environ:
+                    # do it like make: fall back to environment
+                    item = os.environ[n]
+
+                elif n in renamed_variables:
+                    if name.startswith('PY_') and name[3:] in renamed_variables:
+                        item = ""
+
+                    elif 'PY_' + n in notdone:
+                        found = False
+
+                    else:
+                        item = str(done['PY_' + n])
+                else:
+                    done[n] = item = ""
+                if found:
+                    after = value[m.end():]
+                    value = value[:m.start()] + item + after
+                    if "$" in after:
+                        notdone[name] = value
+                    else:
+                        try: value = int(value)
+                        except ValueError:
+                            done[name] = value.strip()
+                        else:
+                            done[name] = value
+                        del notdone[name]
+
+                        if name.startswith('PY_') \
+                            and name[3:] in renamed_variables:
+
+                            name = name[3:]
+                            if name not in done:
+                                done[name] = value
+            else:
+                # bogus variable reference; just drop it since we can't deal
+                del notdone[name]
+
+    fp.close()
+
+    # strip spurious spaces
+    for k, v in done.items():
+        if isinstance(v, str):
+            done[k] = v.strip()
+
+    # save the results in the global dictionary
+    g.update(done)
+    return g
+
+
+def expand_makefile_vars(s, vars):
+    """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
+    'string' according to 'vars' (a dictionary mapping variable names to
+    values).  Variables not present in 'vars' are silently expanded to the
+    empty string.  The variable values in 'vars' should not contain further
+    variable expansions; if 'vars' is the output of 'parse_makefile()',
+    you're fine.  Returns a variable-expanded version of 's'.
+    """
+
+    # This algorithm does multiple expansion, so if vars['foo'] contains
+    # "${bar}", it will expand ${foo} to ${bar}, and then expand
+    # ${bar}... and so forth.  This is fine as long as 'vars' comes from
+    # 'parse_makefile()', which takes care of such expansions eagerly,
+    # according to make's variable expansion semantics.
+
+    while True:
+        m = _findvar1_rx.search(s) or _findvar2_rx.search(s)
+        if m:
+            (beg, end) = m.span()
+            s = s[0:beg] + vars.get(m.group(1)) + s[end:]
+        else:
+            break
+    return s
+
+
+_config_vars = None
+
+def _init_posix():
+    """Initialize the module as appropriate for POSIX systems."""
+    # _sysconfigdata is generated at build time, see the sysconfig module
+    name = os.environ.get('_PYTHON_SYSCONFIGDATA_NAME',
+        '_sysconfigdata_{abi}_{platform}_{multiarch}'.format(
+        abi=sys.abiflags,
+        platform=sys.platform,
+        multiarch=getattr(sys.implementation, '_multiarch', ''),
+    ))
+    try:
+        _temp = __import__(name, globals(), locals(), ['build_time_vars'], 0)
+    except ImportError:
+        # Python 3.5 and pypy 7.3.1
+        _temp = __import__(
+            '_sysconfigdata', globals(), locals(), ['build_time_vars'], 0)
+    build_time_vars = _temp.build_time_vars
+    global _config_vars
+    _config_vars = {}
+    _config_vars.update(build_time_vars)
+
+
+def _init_nt():
+    """Initialize the module as appropriate for NT"""
+    g = {}
+    # set basic install directories
+    g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
+    g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
+
+    # XXX hmmm.. a normal install puts include files here
+    g['INCLUDEPY'] = get_python_inc(plat_specific=0)
+
+    g['EXT_SUFFIX'] = _imp.extension_suffixes()[0]
+    g['EXE'] = ".exe"
+    g['VERSION'] = get_python_version().replace(".", "")
+    g['BINDIR'] = os.path.dirname(os.path.abspath(sys.executable))
+
+    global _config_vars
+    _config_vars = g
+
+
+def get_config_vars(*args):
+    """With no arguments, return a dictionary of all configuration
+    variables relevant for the current platform.  Generally this includes
+    everything needed to build extensions and install both pure modules and
+    extensions.  On Unix, this means every variable defined in Python's
+    installed Makefile; on Windows it's a much smaller set.
+
+    With arguments, return a list of values that result from looking up
+    each argument in the configuration variable dictionary.
+    """
+    global _config_vars
+    if _config_vars is None:
+        func = globals().get("_init_" + os.name)
+        if func:
+            func()
+        else:
+            _config_vars = {}
+
+        # Normalized versions of prefix and exec_prefix are handy to have;
+        # in fact, these are the standard versions used most places in the
+        # Distutils.
+        _config_vars['prefix'] = PREFIX
+        _config_vars['exec_prefix'] = EXEC_PREFIX
+
+        if not IS_PYPY:
+            # For backward compatibility, see issue19555
+            SO = _config_vars.get('EXT_SUFFIX')
+            if SO is not None:
+                _config_vars['SO'] = SO
+
+            # Always convert srcdir to an absolute path
+            srcdir = _config_vars.get('srcdir', project_base)
+            if os.name == 'posix':
+                if python_build:
+                    # If srcdir is a relative path (typically '.' or '..')
+                    # then it should be interpreted relative to the directory
+                    # containing Makefile.
+                    base = os.path.dirname(get_makefile_filename())
+                    srcdir = os.path.join(base, srcdir)
+                else:
+                    # srcdir is not meaningful since the installation is
+                    # spread about the filesystem.  We choose the
+                    # directory containing the Makefile since we know it
+                    # exists.
+                    srcdir = os.path.dirname(get_makefile_filename())
+            _config_vars['srcdir'] = os.path.abspath(os.path.normpath(srcdir))
+
+            # Convert srcdir into an absolute path if it appears necessary.
+            # Normally it is relative to the build directory.  However, during
+            # testing, for example, we might be running a non-installed python
+            # from a different directory.
+            if python_build and os.name == "posix":
+                base = project_base
+                if (not os.path.isabs(_config_vars['srcdir']) and
+                    base != os.getcwd()):
+                    # srcdir is relative and we are not in the same directory
+                    # as the executable. Assume executable is in the build
+                    # directory and make srcdir absolute.
+                    srcdir = os.path.join(base, _config_vars['srcdir'])
+                    _config_vars['srcdir'] = os.path.normpath(srcdir)
+
+        # OS X platforms require special customization to handle
+        # multi-architecture, multi-os-version installers
+        if sys.platform == 'darwin':
+            import _osx_support
+            _osx_support.customize_config_vars(_config_vars)
+
+    if args:
+        vals = []
+        for name in args:
+            vals.append(_config_vars.get(name))
+        return vals
+    else:
+        return _config_vars
+
+def get_config_var(name):
+    """Return the value of a single variable using the dictionary
+    returned by 'get_config_vars()'.  Equivalent to
+    get_config_vars().get(name)
+    """
+    if name == 'SO':
+        import warnings
+        warnings.warn('SO is deprecated, use EXT_SUFFIX', DeprecationWarning, 2)
+    return get_config_vars().get(name)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/text_file.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/text_file.py
new file mode 100644
index 0000000..93abad3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/text_file.py
@@ -0,0 +1,286 @@
+"""text_file
+
+provides the TextFile class, which gives an interface to text files
+that (optionally) takes care of stripping comments, ignoring blank
+lines, and joining lines with backslashes."""
+
+import sys, io
+
+
+class TextFile:
+    """Provides a file-like object that takes care of all the things you
+       commonly want to do when processing a text file that has some
+       line-by-line syntax: strip comments (as long as "#" is your
+       comment character), skip blank lines, join adjacent lines by
+       escaping the newline (ie. backslash at end of line), strip
+       leading and/or trailing whitespace.  All of these are optional
+       and independently controllable.
+
+       Provides a 'warn()' method so you can generate warning messages that
+       report physical line number, even if the logical line in question
+       spans multiple physical lines.  Also provides 'unreadline()' for
+       implementing line-at-a-time lookahead.
+
+       Constructor is called as:
+
+           TextFile (filename=None, file=None, **options)
+
+       It bombs (RuntimeError) if both 'filename' and 'file' are None;
+       'filename' should be a string, and 'file' a file object (or
+       something that provides 'readline()' and 'close()' methods).  It is
+       recommended that you supply at least 'filename', so that TextFile
+       can include it in warning messages.  If 'file' is not supplied,
+       TextFile creates its own using 'io.open()'.
+
+       The options are all boolean, and affect the value returned by
+       'readline()':
+         strip_comments [default: true]
+           strip from "#" to end-of-line, as well as any whitespace
+           leading up to the "#" -- unless it is escaped by a backslash
+         lstrip_ws [default: false]
+           strip leading whitespace from each line before returning it
+         rstrip_ws [default: true]
+           strip trailing whitespace (including line terminator!) from
+           each line before returning it
+         skip_blanks [default: true}
+           skip lines that are empty *after* stripping comments and
+           whitespace.  (If both lstrip_ws and rstrip_ws are false,
+           then some lines may consist of solely whitespace: these will
+           *not* be skipped, even if 'skip_blanks' is true.)
+         join_lines [default: false]
+           if a backslash is the last non-newline character on a line
+           after stripping comments and whitespace, join the following line
+           to it to form one "logical line"; if N consecutive lines end
+           with a backslash, then N+1 physical lines will be joined to
+           form one logical line.
+         collapse_join [default: false]
+           strip leading whitespace from lines that are joined to their
+           predecessor; only matters if (join_lines and not lstrip_ws)
+         errors [default: 'strict']
+           error handler used to decode the file content
+
+       Note that since 'rstrip_ws' can strip the trailing newline, the
+       semantics of 'readline()' must differ from those of the builtin file
+       object's 'readline()' method!  In particular, 'readline()' returns
+       None for end-of-file: an empty string might just be a blank line (or
+       an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is
+       not."""
+
+    default_options = { 'strip_comments': 1,
+                        'skip_blanks':    1,
+                        'lstrip_ws':      0,
+                        'rstrip_ws':      1,
+                        'join_lines':     0,
+                        'collapse_join':  0,
+                        'errors':         'strict',
+                      }
+
+    def __init__(self, filename=None, file=None, **options):
+        """Construct a new TextFile object.  At least one of 'filename'
+           (a string) and 'file' (a file-like object) must be supplied.
+           They keyword argument options are described above and affect
+           the values returned by 'readline()'."""
+        if filename is None and file is None:
+            raise RuntimeError("you must supply either or both of 'filename' and 'file'")
+
+        # set values for all options -- either from client option hash
+        # or fallback to default_options
+        for opt in self.default_options.keys():
+            if opt in options:
+                setattr(self, opt, options[opt])
+            else:
+                setattr(self, opt, self.default_options[opt])
+
+        # sanity check client option hash
+        for opt in options.keys():
+            if opt not in self.default_options:
+                raise KeyError("invalid TextFile option '%s'" % opt)
+
+        if file is None:
+            self.open(filename)
+        else:
+            self.filename = filename
+            self.file = file
+            self.current_line = 0       # assuming that file is at BOF!
+
+        # 'linebuf' is a stack of lines that will be emptied before we
+        # actually read from the file; it's only populated by an
+        # 'unreadline()' operation
+        self.linebuf = []
+
+    def open(self, filename):
+        """Open a new file named 'filename'.  This overrides both the
+           'filename' and 'file' arguments to the constructor."""
+        self.filename = filename
+        self.file = io.open(self.filename, 'r', errors=self.errors)
+        self.current_line = 0
+
+    def close(self):
+        """Close the current file and forget everything we know about it
+           (filename, current line number)."""
+        file = self.file
+        self.file = None
+        self.filename = None
+        self.current_line = None
+        file.close()
+
+    def gen_error(self, msg, line=None):
+        outmsg = []
+        if line is None:
+            line = self.current_line
+        outmsg.append(self.filename + ", ")
+        if isinstance(line, (list, tuple)):
+            outmsg.append("lines %d-%d: " % tuple(line))
+        else:
+            outmsg.append("line %d: " % line)
+        outmsg.append(str(msg))
+        return "".join(outmsg)
+
+    def error(self, msg, line=None):
+        raise ValueError("error: " + self.gen_error(msg, line))
+
+    def warn(self, msg, line=None):
+        """Print (to stderr) a warning message tied to the current logical
+           line in the current file.  If the current logical line in the
+           file spans multiple physical lines, the warning refers to the
+           whole range, eg. "lines 3-5".  If 'line' supplied, it overrides
+           the current line number; it may be a list or tuple to indicate a
+           range of physical lines, or an integer for a single physical
+           line."""
+        sys.stderr.write("warning: " + self.gen_error(msg, line) + "\n")
+
+    def readline(self):
+        """Read and return a single logical line from the current file (or
+           from an internal buffer if lines have previously been "unread"
+           with 'unreadline()').  If the 'join_lines' option is true, this
+           may involve reading multiple physical lines concatenated into a
+           single string.  Updates the current line number, so calling
+           'warn()' after 'readline()' emits a warning about the physical
+           line(s) just read.  Returns None on end-of-file, since the empty
+           string can occur if 'rstrip_ws' is true but 'strip_blanks' is
+           not."""
+        # If any "unread" lines waiting in 'linebuf', return the top
+        # one.  (We don't actually buffer read-ahead data -- lines only
+        # get put in 'linebuf' if the client explicitly does an
+        # 'unreadline()'.
+        if self.linebuf:
+            line = self.linebuf[-1]
+            del self.linebuf[-1]
+            return line
+
+        buildup_line = ''
+
+        while True:
+            # read the line, make it None if EOF
+            line = self.file.readline()
+            if line == '':
+                line = None
+
+            if self.strip_comments and line:
+
+                # Look for the first "#" in the line.  If none, never
+                # mind.  If we find one and it's the first character, or
+                # is not preceded by "\", then it starts a comment --
+                # strip the comment, strip whitespace before it, and
+                # carry on.  Otherwise, it's just an escaped "#", so
+                # unescape it (and any other escaped "#"'s that might be
+                # lurking in there) and otherwise leave the line alone.
+
+                pos = line.find("#")
+                if pos == -1: # no "#" -- no comments
+                    pass
+
+                # It's definitely a comment -- either "#" is the first
+                # character, or it's elsewhere and unescaped.
+                elif pos == 0 or line[pos-1] != "\\":
+                    # Have to preserve the trailing newline, because it's
+                    # the job of a later step (rstrip_ws) to remove it --
+                    # and if rstrip_ws is false, we'd better preserve it!
+                    # (NB. this means that if the final line is all comment
+                    # and has no trailing newline, we will think that it's
+                    # EOF; I think that's OK.)
+                    eol = (line[-1] == '\n') and '\n' or ''
+                    line = line[0:pos] + eol
+
+                    # If all that's left is whitespace, then skip line
+                    # *now*, before we try to join it to 'buildup_line' --
+                    # that way constructs like
+                    #   hello \\
+                    #   # comment that should be ignored
+                    #   there
+                    # result in "hello there".
+                    if line.strip() == "":
+                        continue
+                else: # it's an escaped "#"
+                    line = line.replace("\\#", "#")
+
+            # did previous line end with a backslash? then accumulate
+            if self.join_lines and buildup_line:
+                # oops: end of file
+                if line is None:
+                    self.warn("continuation line immediately precedes "
+                              "end-of-file")
+                    return buildup_line
+
+                if self.collapse_join:
+                    line = line.lstrip()
+                line = buildup_line + line
+
+                # careful: pay attention to line number when incrementing it
+                if isinstance(self.current_line, list):
+                    self.current_line[1] = self.current_line[1] + 1
+                else:
+                    self.current_line = [self.current_line,
+                                         self.current_line + 1]
+            # just an ordinary line, read it as usual
+            else:
+                if line is None: # eof
+                    return None
+
+                # still have to be careful about incrementing the line number!
+                if isinstance(self.current_line, list):
+                    self.current_line = self.current_line[1] + 1
+                else:
+                    self.current_line = self.current_line + 1
+
+            # strip whitespace however the client wants (leading and
+            # trailing, or one or the other, or neither)
+            if self.lstrip_ws and self.rstrip_ws:
+                line = line.strip()
+            elif self.lstrip_ws:
+                line = line.lstrip()
+            elif self.rstrip_ws:
+                line = line.rstrip()
+
+            # blank line (whether we rstrip'ed or not)? skip to next line
+            # if appropriate
+            if (line == '' or line == '\n') and self.skip_blanks:
+                continue
+
+            if self.join_lines:
+                if line[-1] == '\\':
+                    buildup_line = line[:-1]
+                    continue
+
+                if line[-2:] == '\\\n':
+                    buildup_line = line[0:-2] + '\n'
+                    continue
+
+            # well, I guess there's some actual content there: return it
+            return line
+
+    def readlines(self):
+        """Read and return the list of all logical lines remaining in the
+           current file."""
+        lines = []
+        while True:
+            line = self.readline()
+            if line is None:
+                return lines
+            lines.append(line)
+
+    def unreadline(self, line):
+        """Push 'line' (a string) onto an internal buffer that will be
+           checked by future 'readline()' calls.  Handy for implementing
+           a parser with line-at-a-time lookahead."""
+        self.linebuf.append(line)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/unixccompiler.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/unixccompiler.py
new file mode 100644
index 0000000..4d7a6de
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/unixccompiler.py
@@ -0,0 +1,328 @@
+"""distutils.unixccompiler
+
+Contains the UnixCCompiler class, a subclass of CCompiler that handles
+the "typical" Unix-style command-line C compiler:
+  * macros defined with -Dname[=value]
+  * macros undefined with -Uname
+  * include search directories specified with -Idir
+  * libraries specified with -lllib
+  * library search directories specified with -Ldir
+  * compile handled by 'cc' (or similar) executable with -c option:
+    compiles .c to .o
+  * link static library handled by 'ar' command (possibly with 'ranlib')
+  * link shared library handled by 'cc -shared'
+"""
+
+import os, sys, re
+
+from distutils import sysconfig
+from distutils.dep_util import newer
+from distutils.ccompiler import \
+     CCompiler, gen_preprocess_options, gen_lib_options
+from distutils.errors import \
+     DistutilsExecError, CompileError, LibError, LinkError
+from distutils import log
+
+if sys.platform == 'darwin':
+    import _osx_support
+
+# XXX Things not currently handled:
+#   * optimization/debug/warning flags; we just use whatever's in Python's
+#     Makefile and live with it.  Is this adequate?  If not, we might
+#     have to have a bunch of subclasses GNUCCompiler, SGICCompiler,
+#     SunCCompiler, and I suspect down that road lies madness.
+#   * even if we don't know a warning flag from an optimization flag,
+#     we need some way for outsiders to feed preprocessor/compiler/linker
+#     flags in to us -- eg. a sysadmin might want to mandate certain flags
+#     via a site config file, or a user might want to set something for
+#     compiling this module distribution only via the setup.py command
+#     line, whatever.  As long as these options come from something on the
+#     current system, they can be as system-dependent as they like, and we
+#     should just happily stuff them into the preprocessor/compiler/linker
+#     options and carry on.
+
+
+class UnixCCompiler(CCompiler):
+
+    compiler_type = 'unix'
+
+    # These are used by CCompiler in two places: the constructor sets
+    # instance attributes 'preprocessor', 'compiler', etc. from them, and
+    # 'set_executable()' allows any of these to be set.  The defaults here
+    # are pretty generic; they will probably have to be set by an outsider
+    # (eg. using information discovered by the sysconfig about building
+    # Python extensions).
+    executables = {'preprocessor' : None,
+                   'compiler'     : ["cc"],
+                   'compiler_so'  : ["cc"],
+                   'compiler_cxx' : ["cc"],
+                   'linker_so'    : ["cc", "-shared"],
+                   'linker_exe'   : ["cc"],
+                   'archiver'     : ["ar", "-cr"],
+                   'ranlib'       : None,
+                  }
+
+    if sys.platform[:6] == "darwin":
+        executables['ranlib'] = ["ranlib"]
+
+    # Needed for the filename generation methods provided by the base
+    # class, CCompiler.  NB. whoever instantiates/uses a particular
+    # UnixCCompiler instance should set 'shared_lib_ext' -- we set a
+    # reasonable common default here, but it's not necessarily used on all
+    # Unices!
+
+    src_extensions = [".c",".C",".cc",".cxx",".cpp",".m"]
+    obj_extension = ".o"
+    static_lib_extension = ".a"
+    shared_lib_extension = ".so"
+    dylib_lib_extension = ".dylib"
+    xcode_stub_lib_extension = ".tbd"
+    static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s"
+    xcode_stub_lib_format = dylib_lib_format
+    if sys.platform == "cygwin":
+        exe_extension = ".exe"
+
+    def preprocess(self, source, output_file=None, macros=None,
+                   include_dirs=None, extra_preargs=None, extra_postargs=None):
+        fixed_args = self._fix_compile_args(None, macros, include_dirs)
+        ignore, macros, include_dirs = fixed_args
+        pp_opts = gen_preprocess_options(macros, include_dirs)
+        pp_args = self.preprocessor + pp_opts
+        if output_file:
+            pp_args.extend(['-o', output_file])
+        if extra_preargs:
+            pp_args[:0] = extra_preargs
+        if extra_postargs:
+            pp_args.extend(extra_postargs)
+        pp_args.append(source)
+
+        # We need to preprocess: either we're being forced to, or we're
+        # generating output to stdout, or there's a target output file and
+        # the source file is newer than the target (or the target doesn't
+        # exist).
+        if self.force or output_file is None or newer(source, output_file):
+            if output_file:
+                self.mkpath(os.path.dirname(output_file))
+            try:
+                self.spawn(pp_args)
+            except DistutilsExecError as msg:
+                raise CompileError(msg)
+
+    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
+        compiler_so = self.compiler_so
+        if sys.platform == 'darwin':
+            compiler_so = _osx_support.compiler_fixup(compiler_so,
+                                                    cc_args + extra_postargs)
+        try:
+            self.spawn(compiler_so + cc_args + [src, '-o', obj] +
+                       extra_postargs)
+        except DistutilsExecError as msg:
+            raise CompileError(msg)
+
+    def create_static_lib(self, objects, output_libname,
+                          output_dir=None, debug=0, target_lang=None):
+        objects, output_dir = self._fix_object_args(objects, output_dir)
+
+        output_filename = \
+            self.library_filename(output_libname, output_dir=output_dir)
+
+        if self._need_link(objects, output_filename):
+            self.mkpath(os.path.dirname(output_filename))
+            self.spawn(self.archiver +
+                       [output_filename] +
+                       objects + self.objects)
+
+            # Not many Unices required ranlib anymore -- SunOS 4.x is, I
+            # think the only major Unix that does.  Maybe we need some
+            # platform intelligence here to skip ranlib if it's not
+            # needed -- or maybe Python's configure script took care of
+            # it for us, hence the check for leading colon.
+            if self.ranlib:
+                try:
+                    self.spawn(self.ranlib + [output_filename])
+                except DistutilsExecError as msg:
+                    raise LibError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+    def link(self, target_desc, objects,
+             output_filename, output_dir=None, libraries=None,
+             library_dirs=None, runtime_library_dirs=None,
+             export_symbols=None, debug=0, extra_preargs=None,
+             extra_postargs=None, build_temp=None, target_lang=None):
+        objects, output_dir = self._fix_object_args(objects, output_dir)
+        fixed_args = self._fix_lib_args(libraries, library_dirs,
+                                        runtime_library_dirs)
+        libraries, library_dirs, runtime_library_dirs = fixed_args
+
+        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs,
+                                   libraries)
+        if not isinstance(output_dir, (str, type(None))):
+            raise TypeError("'output_dir' must be a string or None")
+        if output_dir is not None:
+            output_filename = os.path.join(output_dir, output_filename)
+
+        if self._need_link(objects, output_filename):
+            ld_args = (objects + self.objects +
+                       lib_opts + ['-o', output_filename])
+            if debug:
+                ld_args[:0] = ['-g']
+            if extra_preargs:
+                ld_args[:0] = extra_preargs
+            if extra_postargs:
+                ld_args.extend(extra_postargs)
+            self.mkpath(os.path.dirname(output_filename))
+            try:
+                if target_desc == CCompiler.EXECUTABLE:
+                    linker = self.linker_exe[:]
+                else:
+                    linker = self.linker_so[:]
+                if target_lang == "c++" and self.compiler_cxx:
+                    # skip over environment variable settings if /usr/bin/env
+                    # is used to set up the linker's environment.
+                    # This is needed on OSX. Note: this assumes that the
+                    # normal and C++ compiler have the same environment
+                    # settings.
+                    i = 0
+                    if os.path.basename(linker[0]) == "env":
+                        i = 1
+                        while '=' in linker[i]:
+                            i += 1
+
+                    if os.path.basename(linker[i]) == 'ld_so_aix':
+                        # AIX platforms prefix the compiler with the ld_so_aix
+                        # script, so we need to adjust our linker index
+                        offset = 1
+                    else:
+                        offset = 0
+
+                    linker[i+offset] = self.compiler_cxx[i]
+
+                if sys.platform == 'darwin':
+                    linker = _osx_support.compiler_fixup(linker, ld_args)
+
+                self.spawn(linker + ld_args)
+            except DistutilsExecError as msg:
+                raise LinkError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+    # -- Miscellaneous methods -----------------------------------------
+    # These are all used by the 'gen_lib_options() function, in
+    # ccompiler.py.
+
+    def library_dir_option(self, dir):
+        return "-L" + dir
+
+    def _is_gcc(self, compiler_name):
+        return "gcc" in compiler_name or "g++" in compiler_name
+
+    def runtime_library_dir_option(self, dir):
+        # XXX Hackish, at the very least.  See Python bug #445902:
+        # http://sourceforge.net/tracker/index.php
+        #   ?func=detail&aid=445902&group_id=5470&atid=105470
+        # Linkers on different platforms need different options to
+        # specify that directories need to be added to the list of
+        # directories searched for dependencies when a dynamic library
+        # is sought.  GCC on GNU systems (Linux, FreeBSD, ...) has to
+        # be told to pass the -R option through to the linker, whereas
+        # other compilers and gcc on other systems just know this.
+        # Other compilers may need something slightly different.  At
+        # this time, there's no way to determine this information from
+        # the configuration data stored in the Python installation, so
+        # we use this hack.
+        compiler = os.path.basename(sysconfig.get_config_var("CC"))
+        if sys.platform[:6] == "darwin":
+            # MacOSX's linker doesn't understand the -R flag at all
+            return "-L" + dir
+        elif sys.platform[:7] == "freebsd":
+            return "-Wl,-rpath=" + dir
+        elif sys.platform[:5] == "hp-ux":
+            if self._is_gcc(compiler):
+                return ["-Wl,+s", "-L" + dir]
+            return ["+s", "-L" + dir]
+        else:
+            if self._is_gcc(compiler):
+                # gcc on non-GNU systems does not need -Wl, but can
+                # use it anyway.  Since distutils has always passed in
+                # -Wl whenever gcc was used in the past it is probably
+                # safest to keep doing so.
+                if sysconfig.get_config_var("GNULD") == "yes":
+                    # GNU ld needs an extra option to get a RUNPATH
+                    # instead of just an RPATH.
+                    return "-Wl,--enable-new-dtags,-R" + dir
+                else:
+                    return "-Wl,-R" + dir
+            else:
+                # No idea how --enable-new-dtags would be passed on to
+                # ld if this system was using GNU ld.  Don't know if a
+                # system like this even exists.
+                return "-R" + dir
+
+    def library_option(self, lib):
+        return "-l" + lib
+
+    def find_library_file(self, dirs, lib, debug=0):
+        shared_f = self.library_filename(lib, lib_type='shared')
+        dylib_f = self.library_filename(lib, lib_type='dylib')
+        xcode_stub_f = self.library_filename(lib, lib_type='xcode_stub')
+        static_f = self.library_filename(lib, lib_type='static')
+
+        if sys.platform == 'darwin':
+            # On OSX users can specify an alternate SDK using
+            # '-isysroot', calculate the SDK root if it is specified
+            # (and use it further on)
+            #
+            # Note that, as of Xcode 7, Apple SDKs may contain textual stub
+            # libraries with .tbd extensions rather than the normal .dylib
+            # shared libraries installed in /.  The Apple compiler tool
+            # chain handles this transparently but it can cause problems
+            # for programs that are being built with an SDK and searching
+            # for specific libraries.  Callers of find_library_file need to
+            # keep in mind that the base filename of the returned SDK library
+            # file might have a different extension from that of the library
+            # file installed on the running system, for example:
+            #   /Applications/Xcode.app/Contents/Developer/Platforms/
+            #       MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/
+            #       usr/lib/libedit.tbd
+            # vs
+            #   /usr/lib/libedit.dylib
+            cflags = sysconfig.get_config_var('CFLAGS')
+            m = re.search(r'-isysroot\s*(\S+)', cflags)
+            if m is None:
+                sysroot = '/'
+            else:
+                sysroot = m.group(1)
+
+
+
+        for dir in dirs:
+            shared = os.path.join(dir, shared_f)
+            dylib = os.path.join(dir, dylib_f)
+            static = os.path.join(dir, static_f)
+            xcode_stub = os.path.join(dir, xcode_stub_f)
+
+            if sys.platform == 'darwin' and (
+                dir.startswith('/System/') or (
+                dir.startswith('/usr/') and not dir.startswith('/usr/local/'))):
+
+                shared = os.path.join(sysroot, dir[1:], shared_f)
+                dylib = os.path.join(sysroot, dir[1:], dylib_f)
+                static = os.path.join(sysroot, dir[1:], static_f)
+                xcode_stub = os.path.join(sysroot, dir[1:], xcode_stub_f)
+
+            # We're second-guessing the linker here, with not much hard
+            # data to go on: GCC seems to prefer the shared library, so I'm
+            # assuming that *all* Unix C compilers do.  And of course I'm
+            # ignoring even GCC's "-static" option.  So sue me.
+            if os.path.exists(dylib):
+                return dylib
+            elif os.path.exists(xcode_stub):
+                return xcode_stub
+            elif os.path.exists(shared):
+                return shared
+            elif os.path.exists(static):
+                return static
+
+        # Oops, didn't find it in *any* of 'dirs'
+        return None
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/util.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/util.py
new file mode 100644
index 0000000..4b002ec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/util.py
@@ -0,0 +1,559 @@
+"""distutils.util
+
+Miscellaneous utility functions -- anything that doesn't fit into
+one of the other *util.py modules.
+"""
+
+import os
+import re
+import importlib.util
+import string
+import sys
+from distutils.errors import DistutilsPlatformError
+from distutils.dep_util import newer
+from distutils.spawn import spawn
+from distutils import log
+from distutils.errors import DistutilsByteCompileError
+
+def get_host_platform():
+    """Return a string that identifies the current platform.  This is used mainly to
+    distinguish platform-specific build directories and platform-specific built
+    distributions.  Typically includes the OS name and version and the
+    architecture (as supplied by 'os.uname()'), although the exact information
+    included depends on the OS; eg. on Linux, the kernel version isn't
+    particularly important.
+
+    Examples of returned values:
+       linux-i586
+       linux-alpha (?)
+       solaris-2.6-sun4u
+
+    Windows will return one of:
+       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
+       win32 (all others - specifically, sys.platform is returned)
+
+    For other non-POSIX platforms, currently just returns 'sys.platform'.
+
+    """
+    if os.name == 'nt':
+        if 'amd64' in sys.version.lower():
+            return 'win-amd64'
+        if '(arm)' in sys.version.lower():
+            return 'win-arm32'
+        if '(arm64)' in sys.version.lower():
+            return 'win-arm64'
+        return sys.platform
+
+    # Set for cross builds explicitly
+    if "_PYTHON_HOST_PLATFORM" in os.environ:
+        return os.environ["_PYTHON_HOST_PLATFORM"]
+
+    if os.name != "posix" or not hasattr(os, 'uname'):
+        # XXX what about the architecture? NT is Intel or Alpha,
+        # Mac OS is M68k or PPC, etc.
+        return sys.platform
+
+    # Try to distinguish various flavours of Unix
+
+    (osname, host, release, version, machine) = os.uname()
+
+    # Convert the OS name to lowercase, remove '/' characters, and translate
+    # spaces (for "Power Macintosh")
+    osname = osname.lower().replace('/', '')
+    machine = machine.replace(' ', '_')
+    machine = machine.replace('/', '-')
+
+    if osname[:5] == "linux":
+        # At least on Linux/Intel, 'machine' is the processor --
+        # i386, etc.
+        # XXX what about Alpha, SPARC, etc?
+        return  "%s-%s" % (osname, machine)
+    elif osname[:5] == "sunos":
+        if release[0] >= "5":           # SunOS 5 == Solaris 2
+            osname = "solaris"
+            release = "%d.%s" % (int(release[0]) - 3, release[2:])
+            # We can't use "platform.architecture()[0]" because a
+            # bootstrap problem. We use a dict to get an error
+            # if some suspicious happens.
+            bitness = {2147483647:"32bit", 9223372036854775807:"64bit"}
+            machine += ".%s" % bitness[sys.maxsize]
+        # fall through to standard osname-release-machine representation
+    elif osname[:3] == "aix":
+        from _aix_support import aix_platform
+        return aix_platform()
+    elif osname[:6] == "cygwin":
+        osname = "cygwin"
+        rel_re = re.compile (r'[\d.]+', re.ASCII)
+        m = rel_re.match(release)
+        if m:
+            release = m.group()
+    elif osname[:6] == "darwin":
+        import _osx_support, distutils.sysconfig
+        osname, release, machine = _osx_support.get_platform_osx(
+                                        distutils.sysconfig.get_config_vars(),
+                                        osname, release, machine)
+
+    return "%s-%s-%s" % (osname, release, machine)
+
+def get_platform():
+    if os.name == 'nt':
+        TARGET_TO_PLAT = {
+            'x86' : 'win32',
+            'x64' : 'win-amd64',
+            'arm' : 'win-arm32',
+        }
+        return TARGET_TO_PLAT.get(os.environ.get('VSCMD_ARG_TGT_ARCH')) or get_host_platform()
+    else:
+        return get_host_platform()
+
+def convert_path (pathname):
+    """Return 'pathname' as a name that will work on the native filesystem,
+    i.e. split it on '/' and put it back together again using the current
+    directory separator.  Needed because filenames in the setup script are
+    always supplied in Unix style, and have to be converted to the local
+    convention before we can actually use them in the filesystem.  Raises
+    ValueError on non-Unix-ish systems if 'pathname' either starts or
+    ends with a slash.
+    """
+    if os.sep == '/':
+        return pathname
+    if not pathname:
+        return pathname
+    if pathname[0] == '/':
+        raise ValueError("path '%s' cannot be absolute" % pathname)
+    if pathname[-1] == '/':
+        raise ValueError("path '%s' cannot end with '/'" % pathname)
+
+    paths = pathname.split('/')
+    while '.' in paths:
+        paths.remove('.')
+    if not paths:
+        return os.curdir
+    return os.path.join(*paths)
+
+# convert_path ()
+
+
+def change_root (new_root, pathname):
+    """Return 'pathname' with 'new_root' prepended.  If 'pathname' is
+    relative, this is equivalent to "os.path.join(new_root,pathname)".
+    Otherwise, it requires making 'pathname' relative and then joining the
+    two, which is tricky on DOS/Windows and Mac OS.
+    """
+    if os.name == 'posix':
+        if not os.path.isabs(pathname):
+            return os.path.join(new_root, pathname)
+        else:
+            return os.path.join(new_root, pathname[1:])
+
+    elif os.name == 'nt':
+        (drive, path) = os.path.splitdrive(pathname)
+        if path[0] == '\\':
+            path = path[1:]
+        return os.path.join(new_root, path)
+
+    else:
+        raise DistutilsPlatformError("nothing known about platform '%s'" % os.name)
+
+
+_environ_checked = 0
+def check_environ ():
+    """Ensure that 'os.environ' has all the environment variables we
+    guarantee that users can use in config files, command-line options,
+    etc.  Currently this includes:
+      HOME - user's home directory (Unix only)
+      PLAT - description of the current platform, including hardware
+             and OS (see 'get_platform()')
+    """
+    global _environ_checked
+    if _environ_checked:
+        return
+
+    if os.name == 'posix' and 'HOME' not in os.environ:
+        try:
+            import pwd
+            os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
+        except (ImportError, KeyError):
+            # bpo-10496: if the current user identifier doesn't exist in the
+            # password database, do nothing
+            pass
+
+    if 'PLAT' not in os.environ:
+        os.environ['PLAT'] = get_platform()
+
+    _environ_checked = 1
+
+
+def subst_vars (s, local_vars):
+    """Perform shell/Perl-style variable substitution on 'string'.  Every
+    occurrence of '$' followed by a name is considered a variable, and
+    variable is substituted by the value found in the 'local_vars'
+    dictionary, or in 'os.environ' if it's not in 'local_vars'.
+    'os.environ' is first checked/augmented to guarantee that it contains
+    certain values: see 'check_environ()'.  Raise ValueError for any
+    variables not found in either 'local_vars' or 'os.environ'.
+    """
+    check_environ()
+    def _subst (match, local_vars=local_vars):
+        var_name = match.group(1)
+        if var_name in local_vars:
+            return str(local_vars[var_name])
+        else:
+            return os.environ[var_name]
+
+    try:
+        return re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
+    except KeyError as var:
+        raise ValueError("invalid variable '$%s'" % var)
+
+# subst_vars ()
+
+
+def grok_environment_error (exc, prefix="error: "):
+    # Function kept for backward compatibility.
+    # Used to try clever things with EnvironmentErrors,
+    # but nowadays str(exception) produces good messages.
+    return prefix + str(exc)
+
+
+# Needed by 'split_quoted()'
+_wordchars_re = _squote_re = _dquote_re = None
+def _init_regex():
+    global _wordchars_re, _squote_re, _dquote_re
+    _wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)
+    _squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
+    _dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')
+
+def split_quoted (s):
+    """Split a string up according to Unix shell-like rules for quotes and
+    backslashes.  In short: words are delimited by spaces, as long as those
+    spaces are not escaped by a backslash, or inside a quoted string.
+    Single and double quotes are equivalent, and the quote characters can
+    be backslash-escaped.  The backslash is stripped from any two-character
+    escape sequence, leaving only the escaped character.  The quote
+    characters are stripped from any quoted string.  Returns a list of
+    words.
+    """
+
+    # This is a nice algorithm for splitting up a single string, since it
+    # doesn't require character-by-character examination.  It was a little
+    # bit of a brain-bender to get it working right, though...
+    if _wordchars_re is None: _init_regex()
+
+    s = s.strip()
+    words = []
+    pos = 0
+
+    while s:
+        m = _wordchars_re.match(s, pos)
+        end = m.end()
+        if end == len(s):
+            words.append(s[:end])
+            break
+
+        if s[end] in string.whitespace: # unescaped, unquoted whitespace: now
+            words.append(s[:end])       # we definitely have a word delimiter
+            s = s[end:].lstrip()
+            pos = 0
+
+        elif s[end] == '\\':            # preserve whatever is being escaped;
+                                        # will become part of the current word
+            s = s[:end] + s[end+1:]
+            pos = end+1
+
+        else:
+            if s[end] == "'":           # slurp singly-quoted string
+                m = _squote_re.match(s, end)
+            elif s[end] == '"':         # slurp doubly-quoted string
+                m = _dquote_re.match(s, end)
+            else:
+                raise RuntimeError("this can't happen (bad char '%c')" % s[end])
+
+            if m is None:
+                raise ValueError("bad string (mismatched %s quotes?)" % s[end])
+
+            (beg, end) = m.span()
+            s = s[:beg] + s[beg+1:end-1] + s[end:]
+            pos = m.end() - 2
+
+        if pos >= len(s):
+            words.append(s)
+            break
+
+    return words
+
+# split_quoted ()
+
+
+def execute (func, args, msg=None, verbose=0, dry_run=0):
+    """Perform some action that affects the outside world (eg.  by
+    writing to the filesystem).  Such actions are special because they
+    are disabled by the 'dry_run' flag.  This method takes care of all
+    that bureaucracy for you; all you have to do is supply the
+    function to call and an argument tuple for it (to embody the
+    "external action" being performed), and an optional message to
+    print.
+    """
+    if msg is None:
+        msg = "%s%r" % (func.__name__, args)
+        if msg[-2:] == ',)':        # correct for singleton tuple
+            msg = msg[0:-2] + ')'
+
+    log.info(msg)
+    if not dry_run:
+        func(*args)
+
+
+def strtobool (val):
+    """Convert a string representation of truth to true (1) or false (0).
+
+    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
+    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
+    'val' is anything else.
+    """
+    val = val.lower()
+    if val in ('y', 'yes', 't', 'true', 'on', '1'):
+        return 1
+    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
+        return 0
+    else:
+        raise ValueError("invalid truth value %r" % (val,))
+
+
+def byte_compile (py_files,
+                  optimize=0, force=0,
+                  prefix=None, base_dir=None,
+                  verbose=1, dry_run=0,
+                  direct=None):
+    """Byte-compile a collection of Python source files to .pyc
+    files in a __pycache__ subdirectory.  'py_files' is a list
+    of files to compile; any files that don't end in ".py" are silently
+    skipped.  'optimize' must be one of the following:
+      0 - don't optimize
+      1 - normal optimization (like "python -O")
+      2 - extra optimization (like "python -OO")
+    If 'force' is true, all files are recompiled regardless of
+    timestamps.
+
+    The source filename encoded in each bytecode file defaults to the
+    filenames listed in 'py_files'; you can modify these with 'prefix' and
+    'basedir'.  'prefix' is a string that will be stripped off of each
+    source filename, and 'base_dir' is a directory name that will be
+    prepended (after 'prefix' is stripped).  You can supply either or both
+    (or neither) of 'prefix' and 'base_dir', as you wish.
+
+    If 'dry_run' is true, doesn't actually do anything that would
+    affect the filesystem.
+
+    Byte-compilation is either done directly in this interpreter process
+    with the standard py_compile module, or indirectly by writing a
+    temporary script and executing it.  Normally, you should let
+    'byte_compile()' figure out to use direct compilation or not (see
+    the source for details).  The 'direct' flag is used by the script
+    generated in indirect mode; unless you know what you're doing, leave
+    it set to None.
+    """
+
+    # Late import to fix a bootstrap issue: _posixsubprocess is built by
+    # setup.py, but setup.py uses distutils.
+    import subprocess
+
+    # nothing is done if sys.dont_write_bytecode is True
+    if sys.dont_write_bytecode:
+        raise DistutilsByteCompileError('byte-compiling is disabled.')
+
+    # First, if the caller didn't force us into direct or indirect mode,
+    # figure out which mode we should be in.  We take a conservative
+    # approach: choose direct mode *only* if the current interpreter is
+    # in debug mode and optimize is 0.  If we're not in debug mode (-O
+    # or -OO), we don't know which level of optimization this
+    # interpreter is running with, so we can't do direct
+    # byte-compilation and be certain that it's the right thing.  Thus,
+    # always compile indirectly if the current interpreter is in either
+    # optimize mode, or if either optimization level was requested by
+    # the caller.
+    if direct is None:
+        direct = (__debug__ and optimize == 0)
+
+    # "Indirect" byte-compilation: write a temporary script and then
+    # run it with the appropriate flags.
+    if not direct:
+        try:
+            from tempfile import mkstemp
+            (script_fd, script_name) = mkstemp(".py")
+        except ImportError:
+            from tempfile import mktemp
+            (script_fd, script_name) = None, mktemp(".py")
+        log.info("writing byte-compilation script '%s'", script_name)
+        if not dry_run:
+            if script_fd is not None:
+                script = os.fdopen(script_fd, "w")
+            else:
+                script = open(script_name, "w")
+
+            with script:
+                script.write("""\
+from distutils.util import byte_compile
+files = [
+""")
+
+                # XXX would be nice to write absolute filenames, just for
+                # safety's sake (script should be more robust in the face of
+                # chdir'ing before running it).  But this requires abspath'ing
+                # 'prefix' as well, and that breaks the hack in build_lib's
+                # 'byte_compile()' method that carefully tacks on a trailing
+                # slash (os.sep really) to make sure the prefix here is "just
+                # right".  This whole prefix business is rather delicate -- the
+                # problem is that it's really a directory, but I'm treating it
+                # as a dumb string, so trailing slashes and so forth matter.
+
+                #py_files = map(os.path.abspath, py_files)
+                #if prefix:
+                #    prefix = os.path.abspath(prefix)
+
+                script.write(",\n".join(map(repr, py_files)) + "]\n")
+                script.write("""
+byte_compile(files, optimize=%r, force=%r,
+             prefix=%r, base_dir=%r,
+             verbose=%r, dry_run=0,
+             direct=1)
+""" % (optimize, force, prefix, base_dir, verbose))
+
+        cmd = [sys.executable]
+        cmd.extend(subprocess._optim_args_from_interpreter_flags())
+        cmd.append(script_name)
+        spawn(cmd, dry_run=dry_run)
+        execute(os.remove, (script_name,), "removing %s" % script_name,
+                dry_run=dry_run)
+
+    # "Direct" byte-compilation: use the py_compile module to compile
+    # right here, right now.  Note that the script generated in indirect
+    # mode simply calls 'byte_compile()' in direct mode, a weird sort of
+    # cross-process recursion.  Hey, it works!
+    else:
+        from py_compile import compile
+
+        for file in py_files:
+            if file[-3:] != ".py":
+                # This lets us be lazy and not filter filenames in
+                # the "install_lib" command.
+                continue
+
+            # Terminology from the py_compile module:
+            #   cfile - byte-compiled file
+            #   dfile - purported source filename (same as 'file' by default)
+            if optimize >= 0:
+                opt = '' if optimize == 0 else optimize
+                cfile = importlib.util.cache_from_source(
+                    file, optimization=opt)
+            else:
+                cfile = importlib.util.cache_from_source(file)
+            dfile = file
+            if prefix:
+                if file[:len(prefix)] != prefix:
+                    raise ValueError("invalid prefix: filename %r doesn't start with %r"
+                           % (file, prefix))
+                dfile = dfile[len(prefix):]
+            if base_dir:
+                dfile = os.path.join(base_dir, dfile)
+
+            cfile_base = os.path.basename(cfile)
+            if direct:
+                if force or newer(file, cfile):
+                    log.info("byte-compiling %s to %s", file, cfile_base)
+                    if not dry_run:
+                        compile(file, cfile, dfile)
+                else:
+                    log.debug("skipping byte-compilation of %s to %s",
+                              file, cfile_base)
+
+# byte_compile ()
+
+def rfc822_escape (header):
+    """Return a version of the string escaped for inclusion in an
+    RFC-822 header, by ensuring there are 8 spaces space after each newline.
+    """
+    lines = header.split('\n')
+    sep = '\n' + 8 * ' '
+    return sep.join(lines)
+
+# 2to3 support
+
+def run_2to3(files, fixer_names=None, options=None, explicit=None):
+    """Invoke 2to3 on a list of Python files.
+    The files should all come from the build area, as the
+    modification is done in-place. To reduce the build time,
+    only files modified since the last invocation of this
+    function should be passed in the files argument."""
+
+    if not files:
+        return
+
+    # Make this class local, to delay import of 2to3
+    from lib2to3.refactor import RefactoringTool, get_fixers_from_package
+    class DistutilsRefactoringTool(RefactoringTool):
+        def log_error(self, msg, *args, **kw):
+            log.error(msg, *args)
+
+        def log_message(self, msg, *args):
+            log.info(msg, *args)
+
+        def log_debug(self, msg, *args):
+            log.debug(msg, *args)
+
+    if fixer_names is None:
+        fixer_names = get_fixers_from_package('lib2to3.fixes')
+    r = DistutilsRefactoringTool(fixer_names, options=options)
+    r.refactor(files, write=True)
+
+def copydir_run_2to3(src, dest, template=None, fixer_names=None,
+                     options=None, explicit=None):
+    """Recursively copy a directory, only copying new and changed files,
+    running run_2to3 over all newly copied Python modules afterward.
+
+    If you give a template string, it's parsed like a MANIFEST.in.
+    """
+    from distutils.dir_util import mkpath
+    from distutils.file_util import copy_file
+    from distutils.filelist import FileList
+    filelist = FileList()
+    curdir = os.getcwd()
+    os.chdir(src)
+    try:
+        filelist.findall()
+    finally:
+        os.chdir(curdir)
+    filelist.files[:] = filelist.allfiles
+    if template:
+        for line in template.splitlines():
+            line = line.strip()
+            if not line: continue
+            filelist.process_template_line(line)
+    copied = []
+    for filename in filelist.files:
+        outname = os.path.join(dest, filename)
+        mkpath(os.path.dirname(outname))
+        res = copy_file(os.path.join(src, filename), outname, update=1)
+        if res[1]: copied.append(outname)
+    run_2to3([fn for fn in copied if fn.lower().endswith('.py')],
+             fixer_names=fixer_names, options=options, explicit=explicit)
+    return copied
+
+class Mixin2to3:
+    '''Mixin class for commands that run 2to3.
+    To configure 2to3, setup scripts may either change
+    the class variables, or inherit from individual commands
+    to override how 2to3 is invoked.'''
+
+    # provide list of fixers to run;
+    # defaults to all from lib2to3.fixers
+    fixer_names = None
+
+    # options dictionary
+    options = None
+
+    # list of fixers to invoke even though they are marked as explicit
+    explicit = None
+
+    def run_2to3(self, files):
+        return run_2to3(files, self.fixer_names, self.options, self.explicit)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/version.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/version.py
new file mode 100644
index 0000000..c33beba
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/version.py
@@ -0,0 +1,347 @@
+#
+# distutils/version.py
+#
+# Implements multiple version numbering conventions for the
+# Python Module Distribution Utilities.
+#
+# $Id$
+#
+
+"""Provides classes to represent module version numbers (one class for
+each style of version numbering).  There are currently two such classes
+implemented: StrictVersion and LooseVersion.
+
+Every version number class implements the following interface:
+  * the 'parse' method takes a string and parses it to some internal
+    representation; if the string is an invalid version number,
+    'parse' raises a ValueError exception
+  * the class constructor takes an optional string argument which,
+    if supplied, is passed to 'parse'
+  * __str__ reconstructs the string that was passed to 'parse' (or
+    an equivalent string -- ie. one that will generate an equivalent
+    version number instance)
+  * __repr__ generates Python code to recreate the version number instance
+  * _cmp compares the current instance with either another instance
+    of the same class or a string (which will be parsed to an instance
+    of the same class, thus must follow the same rules)
+"""
+
+import re
+
+class Version:
+    """Abstract base class for version numbering classes.  Just provides
+    constructor (__init__) and reproducer (__repr__), because those
+    seem to be the same for all version numbering classes; and route
+    rich comparisons to _cmp.
+    """
+
+    def __init__ (self, vstring=None):
+        if vstring:
+            self.parse(vstring)
+
+    def __repr__ (self):
+        return "%s ('%s')" % (self.__class__.__name__, str(self))
+
+    def __eq__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c == 0
+
+    def __lt__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c < 0
+
+    def __le__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c <= 0
+
+    def __gt__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c > 0
+
+    def __ge__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c >= 0
+
+
+# Interface for version-number classes -- must be implemented
+# by the following classes (the concrete ones -- Version should
+# be treated as an abstract class).
+#    __init__ (string) - create and take same action as 'parse'
+#                        (string parameter is optional)
+#    parse (string)    - convert a string representation to whatever
+#                        internal representation is appropriate for
+#                        this style of version numbering
+#    __str__ (self)    - convert back to a string; should be very similar
+#                        (if not identical to) the string supplied to parse
+#    __repr__ (self)   - generate Python code to recreate
+#                        the instance
+#    _cmp (self, other) - compare two version numbers ('other' may
+#                        be an unparsed version string, or another
+#                        instance of your version class)
+
+
+class StrictVersion (Version):
+
+    """Version numbering for anal retentives and software idealists.
+    Implements the standard interface for version number classes as
+    described above.  A version number consists of two or three
+    dot-separated numeric components, with an optional "pre-release" tag
+    on the end.  The pre-release tag consists of the letter 'a' or 'b'
+    followed by a number.  If the numeric components of two version
+    numbers are equal, then one with a pre-release tag will always
+    be deemed earlier (lesser) than one without.
+
+    The following are valid version numbers (shown in the order that
+    would be obtained by sorting according to the supplied cmp function):
+
+        0.4       0.4.0  (these two are equivalent)
+        0.4.1
+        0.5a1
+        0.5b3
+        0.5
+        0.9.6
+        1.0
+        1.0.4a3
+        1.0.4b1
+        1.0.4
+
+    The following are examples of invalid version numbers:
+
+        1
+        2.7.2.2
+        1.3.a4
+        1.3pl1
+        1.3c4
+
+    The rationale for this version numbering system will be explained
+    in the distutils documentation.
+    """
+
+    version_re = re.compile(r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$',
+                            re.VERBOSE | re.ASCII)
+
+
+    def parse (self, vstring):
+        match = self.version_re.match(vstring)
+        if not match:
+            raise ValueError("invalid version number '%s'" % vstring)
+
+        (major, minor, patch, prerelease, prerelease_num) = \
+            match.group(1, 2, 4, 5, 6)
+
+        if patch:
+            self.version = tuple(map(int, [major, minor, patch]))
+        else:
+            self.version = tuple(map(int, [major, minor])) + (0,)
+
+        if prerelease:
+            self.prerelease = (prerelease[0], int(prerelease_num))
+        else:
+            self.prerelease = None
+
+
+    def __str__ (self):
+
+        if self.version[2] == 0:
+            vstring = '.'.join(map(str, self.version[0:2]))
+        else:
+            vstring = '.'.join(map(str, self.version))
+
+        if self.prerelease:
+            vstring = vstring + self.prerelease[0] + str(self.prerelease[1])
+
+        return vstring
+
+
+    def _cmp (self, other):
+        if isinstance(other, str):
+            other = StrictVersion(other)
+        elif not isinstance(other, StrictVersion):
+            return NotImplemented
+
+        if self.version != other.version:
+            # numeric versions don't match
+            # prerelease stuff doesn't matter
+            if self.version < other.version:
+                return -1
+            else:
+                return 1
+
+        # have to compare prerelease
+        # case 1: neither has prerelease; they're equal
+        # case 2: self has prerelease, other doesn't; other is greater
+        # case 3: self doesn't have prerelease, other does: self is greater
+        # case 4: both have prerelease: must compare them!
+
+        if (not self.prerelease and not other.prerelease):
+            return 0
+        elif (self.prerelease and not other.prerelease):
+            return -1
+        elif (not self.prerelease and other.prerelease):
+            return 1
+        elif (self.prerelease and other.prerelease):
+            if self.prerelease == other.prerelease:
+                return 0
+            elif self.prerelease < other.prerelease:
+                return -1
+            else:
+                return 1
+        else:
+            assert False, "never get here"
+
+# end class StrictVersion
+
+
+# The rules according to Greg Stein:
+# 1) a version number has 1 or more numbers separated by a period or by
+#    sequences of letters. If only periods, then these are compared
+#    left-to-right to determine an ordering.
+# 2) sequences of letters are part of the tuple for comparison and are
+#    compared lexicographically
+# 3) recognize the numeric components may have leading zeroes
+#
+# The LooseVersion class below implements these rules: a version number
+# string is split up into a tuple of integer and string components, and
+# comparison is a simple tuple comparison.  This means that version
+# numbers behave in a predictable and obvious way, but a way that might
+# not necessarily be how people *want* version numbers to behave.  There
+# wouldn't be a problem if people could stick to purely numeric version
+# numbers: just split on period and compare the numbers as tuples.
+# However, people insist on putting letters into their version numbers;
+# the most common purpose seems to be:
+#   - indicating a "pre-release" version
+#     ('alpha', 'beta', 'a', 'b', 'pre', 'p')
+#   - indicating a post-release patch ('p', 'pl', 'patch')
+# but of course this can't cover all version number schemes, and there's
+# no way to know what a programmer means without asking him.
+#
+# The problem is what to do with letters (and other non-numeric
+# characters) in a version number.  The current implementation does the
+# obvious and predictable thing: keep them as strings and compare
+# lexically within a tuple comparison.  This has the desired effect if
+# an appended letter sequence implies something "post-release":
+# eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002".
+#
+# However, if letters in a version number imply a pre-release version,
+# the "obvious" thing isn't correct.  Eg. you would expect that
+# "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison
+# implemented here, this just isn't so.
+#
+# Two possible solutions come to mind.  The first is to tie the
+# comparison algorithm to a particular set of semantic rules, as has
+# been done in the StrictVersion class above.  This works great as long
+# as everyone can go along with bondage and discipline.  Hopefully a
+# (large) subset of Python module programmers will agree that the
+# particular flavour of bondage and discipline provided by StrictVersion
+# provides enough benefit to be worth using, and will submit their
+# version numbering scheme to its domination.  The free-thinking
+# anarchists in the lot will never give in, though, and something needs
+# to be done to accommodate them.
+#
+# Perhaps a "moderately strict" version class could be implemented that
+# lets almost anything slide (syntactically), and makes some heuristic
+# assumptions about non-digits in version number strings.  This could
+# sink into special-case-hell, though; if I was as talented and
+# idiosyncratic as Larry Wall, I'd go ahead and implement a class that
+# somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is
+# just as happy dealing with things like "2g6" and "1.13++".  I don't
+# think I'm smart enough to do it right though.
+#
+# In any case, I've coded the test suite for this module (see
+# ../test/test_version.py) specifically to fail on things like comparing
+# "1.2a2" and "1.2".  That's not because the *code* is doing anything
+# wrong, it's because the simple, obvious design doesn't match my
+# complicated, hairy expectations for real-world version numbers.  It
+# would be a snap to fix the test suite to say, "Yep, LooseVersion does
+# the Right Thing" (ie. the code matches the conception).  But I'd rather
+# have a conception that matches common notions about version numbers.
+
+class LooseVersion (Version):
+
+    """Version numbering for anarchists and software realists.
+    Implements the standard interface for version number classes as
+    described above.  A version number consists of a series of numbers,
+    separated by either periods or strings of letters.  When comparing
+    version numbers, the numeric components will be compared
+    numerically, and the alphabetic components lexically.  The following
+    are all valid version numbers, in no particular order:
+
+        1.5.1
+        1.5.2b2
+        161
+        3.10a
+        8.02
+        3.4j
+        1996.07.12
+        3.2.pl0
+        3.1.1.6
+        2g6
+        11g
+        0.960923
+        2.2beta29
+        1.13++
+        5.5.kw
+        2.0b1pl0
+
+    In fact, there is no such thing as an invalid version number under
+    this scheme; the rules for comparison are simple and predictable,
+    but may not always give the results you want (for some definition
+    of "want").
+    """
+
+    component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)
+
+    def __init__ (self, vstring=None):
+        if vstring:
+            self.parse(vstring)
+
+
+    def parse (self, vstring):
+        # I've given up on thinking I can reconstruct the version string
+        # from the parsed tuple -- so I just store the string here for
+        # use by __str__
+        self.vstring = vstring
+        components = [x for x in self.component_re.split(vstring)
+                              if x and x != '.']
+        for i, obj in enumerate(components):
+            try:
+                components[i] = int(obj)
+            except ValueError:
+                pass
+
+        self.version = components
+
+
+    def __str__ (self):
+        return self.vstring
+
+
+    def __repr__ (self):
+        return "LooseVersion ('%s')" % str(self)
+
+
+    def _cmp (self, other):
+        if isinstance(other, str):
+            other = LooseVersion(other)
+        elif not isinstance(other, LooseVersion):
+            return NotImplemented
+
+        if self.version == other.version:
+            return 0
+        if self.version < other.version:
+            return -1
+        if self.version > other.version:
+            return 1
+
+
+# end class LooseVersion
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_distutils/versionpredicate.py b/myenv/lib/python3.9/site-packages/setuptools/_distutils/versionpredicate.py
new file mode 100644
index 0000000..062c98f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_distutils/versionpredicate.py
@@ -0,0 +1,166 @@
+"""Module for parsing and testing package version predicate strings.
+"""
+import re
+import distutils.version
+import operator
+
+
+re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)",
+    re.ASCII)
+# (package) (rest)
+
+re_paren = re.compile(r"^\s*\((.*)\)\s*$") # (list) inside of parentheses
+re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$")
+# (comp) (version)
+
+
+def splitUp(pred):
+    """Parse a single version comparison.
+
+    Return (comparison string, StrictVersion)
+    """
+    res = re_splitComparison.match(pred)
+    if not res:
+        raise ValueError("bad package restriction syntax: %r" % pred)
+    comp, verStr = res.groups()
+    return (comp, distutils.version.StrictVersion(verStr))
+
+compmap = {"<": operator.lt, "<=": operator.le, "==": operator.eq,
+           ">": operator.gt, ">=": operator.ge, "!=": operator.ne}
+
+class VersionPredicate:
+    """Parse and test package version predicates.
+
+    >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')
+
+    The `name` attribute provides the full dotted name that is given::
+
+    >>> v.name
+    'pyepat.abc'
+
+    The str() of a `VersionPredicate` provides a normalized
+    human-readable version of the expression::
+
+    >>> print(v)
+    pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)
+
+    The `satisfied_by()` method can be used to determine with a given
+    version number is included in the set described by the version
+    restrictions::
+
+    >>> v.satisfied_by('1.1')
+    True
+    >>> v.satisfied_by('1.4')
+    True
+    >>> v.satisfied_by('1.0')
+    False
+    >>> v.satisfied_by('4444.4')
+    False
+    >>> v.satisfied_by('1555.1b3')
+    False
+
+    `VersionPredicate` is flexible in accepting extra whitespace::
+
+    >>> v = VersionPredicate(' pat( ==  0.1  )  ')
+    >>> v.name
+    'pat'
+    >>> v.satisfied_by('0.1')
+    True
+    >>> v.satisfied_by('0.2')
+    False
+
+    If any version numbers passed in do not conform to the
+    restrictions of `StrictVersion`, a `ValueError` is raised::
+
+    >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
+    Traceback (most recent call last):
+      ...
+    ValueError: invalid version number '1.2zb3'
+
+    It the module or package name given does not conform to what's
+    allowed as a legal module or package name, `ValueError` is
+    raised::
+
+    >>> v = VersionPredicate('foo-bar')
+    Traceback (most recent call last):
+      ...
+    ValueError: expected parenthesized list: '-bar'
+
+    >>> v = VersionPredicate('foo bar (12.21)')
+    Traceback (most recent call last):
+      ...
+    ValueError: expected parenthesized list: 'bar (12.21)'
+
+    """
+
+    def __init__(self, versionPredicateStr):
+        """Parse a version predicate string.
+        """
+        # Fields:
+        #    name:  package name
+        #    pred:  list of (comparison string, StrictVersion)
+
+        versionPredicateStr = versionPredicateStr.strip()
+        if not versionPredicateStr:
+            raise ValueError("empty package restriction")
+        match = re_validPackage.match(versionPredicateStr)
+        if not match:
+            raise ValueError("bad package name in %r" % versionPredicateStr)
+        self.name, paren = match.groups()
+        paren = paren.strip()
+        if paren:
+            match = re_paren.match(paren)
+            if not match:
+                raise ValueError("expected parenthesized list: %r" % paren)
+            str = match.groups()[0]
+            self.pred = [splitUp(aPred) for aPred in str.split(",")]
+            if not self.pred:
+                raise ValueError("empty parenthesized list in %r"
+                                 % versionPredicateStr)
+        else:
+            self.pred = []
+
+    def __str__(self):
+        if self.pred:
+            seq = [cond + " " + str(ver) for cond, ver in self.pred]
+            return self.name + " (" + ", ".join(seq) + ")"
+        else:
+            return self.name
+
+    def satisfied_by(self, version):
+        """True if version is compatible with all the predicates in self.
+        The parameter version must be acceptable to the StrictVersion
+        constructor.  It may be either a string or StrictVersion.
+        """
+        for cond, ver in self.pred:
+            if not compmap[cond](version, ver):
+                return False
+        return True
+
+
+_provision_rx = None
+
+def split_provision(value):
+    """Return the name and optional version number of a provision.
+
+    The version number, if given, will be returned as a `StrictVersion`
+    instance, otherwise it will be `None`.
+
+    >>> split_provision('mypkg')
+    ('mypkg', None)
+    >>> split_provision(' mypkg( 1.2 ) ')
+    ('mypkg', StrictVersion ('1.2'))
+    """
+    global _provision_rx
+    if _provision_rx is None:
+        _provision_rx = re.compile(
+            r"([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$",
+            re.ASCII)
+    value = value.strip()
+    m = _provision_rx.match(value)
+    if not m:
+        raise ValueError("illegal provides specification: %r" % value)
+    ver = m.group(2) or None
+    if ver:
+        ver = distutils.version.StrictVersion(ver)
+    return m.group(1), ver
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_imp.py b/myenv/lib/python3.9/site-packages/setuptools/_imp.py
new file mode 100644
index 0000000..451e45a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_imp.py
@@ -0,0 +1,82 @@
+"""
+Re-implementation of find_module and get_frozen_object
+from the deprecated imp module.
+"""
+
+import os
+import importlib.util
+import importlib.machinery
+
+from .py34compat import module_from_spec
+
+
+PY_SOURCE = 1
+PY_COMPILED = 2
+C_EXTENSION = 3
+C_BUILTIN = 6
+PY_FROZEN = 7
+
+
+def find_spec(module, paths):
+    finder = (
+        importlib.machinery.PathFinder().find_spec
+        if isinstance(paths, list) else
+        importlib.util.find_spec
+    )
+    return finder(module, paths)
+
+
+def find_module(module, paths=None):
+    """Just like 'imp.find_module()', but with package support"""
+    spec = find_spec(module, paths)
+    if spec is None:
+        raise ImportError("Can't find %s" % module)
+    if not spec.has_location and hasattr(spec, 'submodule_search_locations'):
+        spec = importlib.util.spec_from_loader('__init__.py', spec.loader)
+
+    kind = -1
+    file = None
+    static = isinstance(spec.loader, type)
+    if spec.origin == 'frozen' or static and issubclass(
+            spec.loader, importlib.machinery.FrozenImporter):
+        kind = PY_FROZEN
+        path = None  # imp compabilty
+        suffix = mode = ''  # imp compability
+    elif spec.origin == 'built-in' or static and issubclass(
+            spec.loader, importlib.machinery.BuiltinImporter):
+        kind = C_BUILTIN
+        path = None  # imp compabilty
+        suffix = mode = ''  # imp compability
+    elif spec.has_location:
+        path = spec.origin
+        suffix = os.path.splitext(path)[1]
+        mode = 'r' if suffix in importlib.machinery.SOURCE_SUFFIXES else 'rb'
+
+        if suffix in importlib.machinery.SOURCE_SUFFIXES:
+            kind = PY_SOURCE
+        elif suffix in importlib.machinery.BYTECODE_SUFFIXES:
+            kind = PY_COMPILED
+        elif suffix in importlib.machinery.EXTENSION_SUFFIXES:
+            kind = C_EXTENSION
+
+        if kind in {PY_SOURCE, PY_COMPILED}:
+            file = open(path, mode)
+    else:
+        path = None
+        suffix = mode = ''
+
+    return file, path, (suffix, mode, kind)
+
+
+def get_frozen_object(module, paths=None):
+    spec = find_spec(module, paths)
+    if not spec:
+        raise ImportError("Can't find %s" % module)
+    return spec.loader.get_code(module)
+
+
+def get_module(module, paths, info):
+    spec = find_spec(module, paths)
+    if not spec:
+        raise ImportError("Can't find %s" % module)
+    return module_from_spec(spec)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/__init__.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/ordered_set.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/ordered_set.py
new file mode 100644
index 0000000..1487600
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/ordered_set.py
@@ -0,0 +1,488 @@
+"""
+An OrderedSet is a custom MutableSet that remembers its order, so that every
+entry has an index that can be looked up.
+
+Based on a recipe originally posted to ActiveState Recipes by Raymond Hettiger,
+and released under the MIT license.
+"""
+import itertools as it
+from collections import deque
+
+try:
+    # Python 3
+    from collections.abc import MutableSet, Sequence
+except ImportError:
+    # Python 2.7
+    from collections import MutableSet, Sequence
+
+SLICE_ALL = slice(None)
+__version__ = "3.1"
+
+
+def is_iterable(obj):
+    """
+    Are we being asked to look up a list of things, instead of a single thing?
+    We check for the `__iter__` attribute so that this can cover types that
+    don't have to be known by this module, such as NumPy arrays.
+
+    Strings, however, should be considered as atomic values to look up, not
+    iterables. The same goes for tuples, since they are immutable and therefore
+    valid entries.
+
+    We don't need to check for the Python 2 `unicode` type, because it doesn't
+    have an `__iter__` attribute anyway.
+    """
+    return (
+        hasattr(obj, "__iter__")
+        and not isinstance(obj, str)
+        and not isinstance(obj, tuple)
+    )
+
+
+class OrderedSet(MutableSet, Sequence):
+    """
+    An OrderedSet is a custom MutableSet that remembers its order, so that
+    every entry has an index that can be looked up.
+
+    Example:
+        >>> OrderedSet([1, 1, 2, 3, 2])
+        OrderedSet([1, 2, 3])
+    """
+
+    def __init__(self, iterable=None):
+        self.items = []
+        self.map = {}
+        if iterable is not None:
+            self |= iterable
+
+    def __len__(self):
+        """
+        Returns the number of unique elements in the ordered set
+
+        Example:
+            >>> len(OrderedSet([]))
+            0
+            >>> len(OrderedSet([1, 2]))
+            2
+        """
+        return len(self.items)
+
+    def __getitem__(self, index):
+        """
+        Get the item at a given index.
+
+        If `index` is a slice, you will get back that slice of items, as a
+        new OrderedSet.
+
+        If `index` is a list or a similar iterable, you'll get a list of
+        items corresponding to those indices. This is similar to NumPy's
+        "fancy indexing". The result is not an OrderedSet because you may ask
+        for duplicate indices, and the number of elements returned should be
+        the number of elements asked for.
+
+        Example:
+            >>> oset = OrderedSet([1, 2, 3])
+            >>> oset[1]
+            2
+        """
+        if isinstance(index, slice) and index == SLICE_ALL:
+            return self.copy()
+        elif is_iterable(index):
+            return [self.items[i] for i in index]
+        elif hasattr(index, "__index__") or isinstance(index, slice):
+            result = self.items[index]
+            if isinstance(result, list):
+                return self.__class__(result)
+            else:
+                return result
+        else:
+            raise TypeError("Don't know how to index an OrderedSet by %r" % index)
+
+    def copy(self):
+        """
+        Return a shallow copy of this object.
+
+        Example:
+            >>> this = OrderedSet([1, 2, 3])
+            >>> other = this.copy()
+            >>> this == other
+            True
+            >>> this is other
+            False
+        """
+        return self.__class__(self)
+
+    def __getstate__(self):
+        if len(self) == 0:
+            # The state can't be an empty list.
+            # We need to return a truthy value, or else __setstate__ won't be run.
+            #
+            # This could have been done more gracefully by always putting the state
+            # in a tuple, but this way is backwards- and forwards- compatible with
+            # previous versions of OrderedSet.
+            return (None,)
+        else:
+            return list(self)
+
+    def __setstate__(self, state):
+        if state == (None,):
+            self.__init__([])
+        else:
+            self.__init__(state)
+
+    def __contains__(self, key):
+        """
+        Test if the item is in this ordered set
+
+        Example:
+            >>> 1 in OrderedSet([1, 3, 2])
+            True
+            >>> 5 in OrderedSet([1, 3, 2])
+            False
+        """
+        return key in self.map
+
+    def add(self, key):
+        """
+        Add `key` as an item to this OrderedSet, then return its index.
+
+        If `key` is already in the OrderedSet, return the index it already
+        had.
+
+        Example:
+            >>> oset = OrderedSet()
+            >>> oset.append(3)
+            0
+            >>> print(oset)
+            OrderedSet([3])
+        """
+        if key not in self.map:
+            self.map[key] = len(self.items)
+            self.items.append(key)
+        return self.map[key]
+
+    append = add
+
+    def update(self, sequence):
+        """
+        Update the set with the given iterable sequence, then return the index
+        of the last element inserted.
+
+        Example:
+            >>> oset = OrderedSet([1, 2, 3])
+            >>> oset.update([3, 1, 5, 1, 4])
+            4
+            >>> print(oset)
+            OrderedSet([1, 2, 3, 5, 4])
+        """
+        item_index = None
+        try:
+            for item in sequence:
+                item_index = self.add(item)
+        except TypeError:
+            raise ValueError(
+                "Argument needs to be an iterable, got %s" % type(sequence)
+            )
+        return item_index
+
+    def index(self, key):
+        """
+        Get the index of a given entry, raising an IndexError if it's not
+        present.
+
+        `key` can be an iterable of entries that is not a string, in which case
+        this returns a list of indices.
+
+        Example:
+            >>> oset = OrderedSet([1, 2, 3])
+            >>> oset.index(2)
+            1
+        """
+        if is_iterable(key):
+            return [self.index(subkey) for subkey in key]
+        return self.map[key]
+
+    # Provide some compatibility with pd.Index
+    get_loc = index
+    get_indexer = index
+
+    def pop(self):
+        """
+        Remove and return the last element from the set.
+
+        Raises KeyError if the set is empty.
+
+        Example:
+            >>> oset = OrderedSet([1, 2, 3])
+            >>> oset.pop()
+            3
+        """
+        if not self.items:
+            raise KeyError("Set is empty")
+
+        elem = self.items[-1]
+        del self.items[-1]
+        del self.map[elem]
+        return elem
+
+    def discard(self, key):
+        """
+        Remove an element.  Do not raise an exception if absent.
+
+        The MutableSet mixin uses this to implement the .remove() method, which
+        *does* raise an error when asked to remove a non-existent item.
+
+        Example:
+            >>> oset = OrderedSet([1, 2, 3])
+            >>> oset.discard(2)
+            >>> print(oset)
+            OrderedSet([1, 3])
+            >>> oset.discard(2)
+            >>> print(oset)
+            OrderedSet([1, 3])
+        """
+        if key in self:
+            i = self.map[key]
+            del self.items[i]
+            del self.map[key]
+            for k, v in self.map.items():
+                if v >= i:
+                    self.map[k] = v - 1
+
+    def clear(self):
+        """
+        Remove all items from this OrderedSet.
+        """
+        del self.items[:]
+        self.map.clear()
+
+    def __iter__(self):
+        """
+        Example:
+            >>> list(iter(OrderedSet([1, 2, 3])))
+            [1, 2, 3]
+        """
+        return iter(self.items)
+
+    def __reversed__(self):
+        """
+        Example:
+            >>> list(reversed(OrderedSet([1, 2, 3])))
+            [3, 2, 1]
+        """
+        return reversed(self.items)
+
+    def __repr__(self):
+        if not self:
+            return "%s()" % (self.__class__.__name__,)
+        return "%s(%r)" % (self.__class__.__name__, list(self))
+
+    def __eq__(self, other):
+        """
+        Returns true if the containers have the same items. If `other` is a
+        Sequence, then order is checked, otherwise it is ignored.
+
+        Example:
+            >>> oset = OrderedSet([1, 3, 2])
+            >>> oset == [1, 3, 2]
+            True
+            >>> oset == [1, 2, 3]
+            False
+            >>> oset == [2, 3]
+            False
+            >>> oset == OrderedSet([3, 2, 1])
+            False
+        """
+        # In Python 2 deque is not a Sequence, so treat it as one for
+        # consistent behavior with Python 3.
+        if isinstance(other, (Sequence, deque)):
+            # Check that this OrderedSet contains the same elements, in the
+            # same order, as the other object.
+            return list(self) == list(other)
+        try:
+            other_as_set = set(other)
+        except TypeError:
+            # If `other` can't be converted into a set, it's not equal.
+            return False
+        else:
+            return set(self) == other_as_set
+
+    def union(self, *sets):
+        """
+        Combines all unique items.
+        Each items order is defined by its first appearance.
+
+        Example:
+            >>> oset = OrderedSet.union(OrderedSet([3, 1, 4, 1, 5]), [1, 3], [2, 0])
+            >>> print(oset)
+            OrderedSet([3, 1, 4, 5, 2, 0])
+            >>> oset.union([8, 9])
+            OrderedSet([3, 1, 4, 5, 2, 0, 8, 9])
+            >>> oset | {10}
+            OrderedSet([3, 1, 4, 5, 2, 0, 10])
+        """
+        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
+        containers = map(list, it.chain([self], sets))
+        items = it.chain.from_iterable(containers)
+        return cls(items)
+
+    def __and__(self, other):
+        # the parent implementation of this is backwards
+        return self.intersection(other)
+
+    def intersection(self, *sets):
+        """
+        Returns elements in common between all sets. Order is defined only
+        by the first set.
+
+        Example:
+            >>> oset = OrderedSet.intersection(OrderedSet([0, 1, 2, 3]), [1, 2, 3])
+            >>> print(oset)
+            OrderedSet([1, 2, 3])
+            >>> oset.intersection([2, 4, 5], [1, 2, 3, 4])
+            OrderedSet([2])
+            >>> oset.intersection()
+            OrderedSet([1, 2, 3])
+        """
+        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
+        if sets:
+            common = set.intersection(*map(set, sets))
+            items = (item for item in self if item in common)
+        else:
+            items = self
+        return cls(items)
+
+    def difference(self, *sets):
+        """
+        Returns all elements that are in this set but not the others.
+
+        Example:
+            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]))
+            OrderedSet([1, 3])
+            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]), OrderedSet([3]))
+            OrderedSet([1])
+            >>> OrderedSet([1, 2, 3]) - OrderedSet([2])
+            OrderedSet([1, 3])
+            >>> OrderedSet([1, 2, 3]).difference()
+            OrderedSet([1, 2, 3])
+        """
+        cls = self.__class__
+        if sets:
+            other = set.union(*map(set, sets))
+            items = (item for item in self if item not in other)
+        else:
+            items = self
+        return cls(items)
+
+    def issubset(self, other):
+        """
+        Report whether another set contains this set.
+
+        Example:
+            >>> OrderedSet([1, 2, 3]).issubset({1, 2})
+            False
+            >>> OrderedSet([1, 2, 3]).issubset({1, 2, 3, 4})
+            True
+            >>> OrderedSet([1, 2, 3]).issubset({1, 4, 3, 5})
+            False
+        """
+        if len(self) > len(other):  # Fast check for obvious cases
+            return False
+        return all(item in other for item in self)
+
+    def issuperset(self, other):
+        """
+        Report whether this set contains another set.
+
+        Example:
+            >>> OrderedSet([1, 2]).issuperset([1, 2, 3])
+            False
+            >>> OrderedSet([1, 2, 3, 4]).issuperset({1, 2, 3})
+            True
+            >>> OrderedSet([1, 4, 3, 5]).issuperset({1, 2, 3})
+            False
+        """
+        if len(self) < len(other):  # Fast check for obvious cases
+            return False
+        return all(item in self for item in other)
+
+    def symmetric_difference(self, other):
+        """
+        Return the symmetric difference of two OrderedSets as a new set.
+        That is, the new set will contain all elements that are in exactly
+        one of the sets.
+
+        Their order will be preserved, with elements from `self` preceding
+        elements from `other`.
+
+        Example:
+            >>> this = OrderedSet([1, 4, 3, 5, 7])
+            >>> other = OrderedSet([9, 7, 1, 3, 2])
+            >>> this.symmetric_difference(other)
+            OrderedSet([4, 5, 9, 2])
+        """
+        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
+        diff1 = cls(self).difference(other)
+        diff2 = cls(other).difference(self)
+        return diff1.union(diff2)
+
+    def _update_items(self, items):
+        """
+        Replace the 'items' list of this OrderedSet with a new one, updating
+        self.map accordingly.
+        """
+        self.items = items
+        self.map = {item: idx for (idx, item) in enumerate(items)}
+
+    def difference_update(self, *sets):
+        """
+        Update this OrderedSet to remove items from one or more other sets.
+
+        Example:
+            >>> this = OrderedSet([1, 2, 3])
+            >>> this.difference_update(OrderedSet([2, 4]))
+            >>> print(this)
+            OrderedSet([1, 3])
+
+            >>> this = OrderedSet([1, 2, 3, 4, 5])
+            >>> this.difference_update(OrderedSet([2, 4]), OrderedSet([1, 4, 6]))
+            >>> print(this)
+            OrderedSet([3, 5])
+        """
+        items_to_remove = set()
+        for other in sets:
+            items_to_remove |= set(other)
+        self._update_items([item for item in self.items if item not in items_to_remove])
+
+    def intersection_update(self, other):
+        """
+        Update this OrderedSet to keep only items in another set, preserving
+        their order in this set.
+
+        Example:
+            >>> this = OrderedSet([1, 4, 3, 5, 7])
+            >>> other = OrderedSet([9, 7, 1, 3, 2])
+            >>> this.intersection_update(other)
+            >>> print(this)
+            OrderedSet([1, 3, 7])
+        """
+        other = set(other)
+        self._update_items([item for item in self.items if item in other])
+
+    def symmetric_difference_update(self, other):
+        """
+        Update this OrderedSet to remove items from another set, then
+        add items from the other set that were not present in this set.
+
+        Example:
+            >>> this = OrderedSet([1, 4, 3, 5, 7])
+            >>> other = OrderedSet([9, 7, 1, 3, 2])
+            >>> this.symmetric_difference_update(other)
+            >>> print(this)
+            OrderedSet([4, 5, 9, 2])
+        """
+        items_to_add = [item for item in other if item not in self]
+        items_to_remove = set(other)
+        self._update_items(
+            [item for item in self.items if item not in items_to_remove] + items_to_add
+        )
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/__about__.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/__about__.py
new file mode 100644
index 0000000..dc95138
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/__about__.py
@@ -0,0 +1,27 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
+
+__title__ = "packaging"
+__summary__ = "Core utilities for Python packages"
+__uri__ = "https://github.com/pypa/packaging"
+
+__version__ = "19.2"
+
+__author__ = "Donald Stufft and individual contributors"
+__email__ = "donald@stufft.io"
+
+__license__ = "BSD or Apache License, Version 2.0"
+__copyright__ = "Copyright 2014-2019 %s" % __author__
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/__init__.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/__init__.py
new file mode 100644
index 0000000..a0cf67d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/__init__.py
@@ -0,0 +1,26 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+from .__about__ import (
+    __author__,
+    __copyright__,
+    __email__,
+    __license__,
+    __summary__,
+    __title__,
+    __uri__,
+    __version__,
+)
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/_compat.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/_compat.py
new file mode 100644
index 0000000..25da473
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/_compat.py
@@ -0,0 +1,31 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import sys
+
+
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+# flake8: noqa
+
+if PY3:
+    string_types = (str,)
+else:
+    string_types = (basestring,)
+
+
+def with_metaclass(meta, *bases):
+    """
+    Create a base class with a metaclass.
+    """
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+
+    return type.__new__(metaclass, "temporary_class", (), {})
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/_structures.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/_structures.py
new file mode 100644
index 0000000..68dcca6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/_structures.py
@@ -0,0 +1,68 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+
+class Infinity(object):
+    def __repr__(self):
+        return "Infinity"
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def __lt__(self, other):
+        return False
+
+    def __le__(self, other):
+        return False
+
+    def __eq__(self, other):
+        return isinstance(other, self.__class__)
+
+    def __ne__(self, other):
+        return not isinstance(other, self.__class__)
+
+    def __gt__(self, other):
+        return True
+
+    def __ge__(self, other):
+        return True
+
+    def __neg__(self):
+        return NegativeInfinity
+
+
+Infinity = Infinity()
+
+
+class NegativeInfinity(object):
+    def __repr__(self):
+        return "-Infinity"
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def __lt__(self, other):
+        return True
+
+    def __le__(self, other):
+        return True
+
+    def __eq__(self, other):
+        return isinstance(other, self.__class__)
+
+    def __ne__(self, other):
+        return not isinstance(other, self.__class__)
+
+    def __gt__(self, other):
+        return False
+
+    def __ge__(self, other):
+        return False
+
+    def __neg__(self):
+        return Infinity
+
+
+NegativeInfinity = NegativeInfinity()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/markers.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/markers.py
new file mode 100644
index 0000000..4bdfdb2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/markers.py
@@ -0,0 +1,296 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import operator
+import os
+import platform
+import sys
+
+from setuptools.extern.pyparsing import ParseException, ParseResults, stringStart, stringEnd
+from setuptools.extern.pyparsing import ZeroOrMore, Group, Forward, QuotedString
+from setuptools.extern.pyparsing import Literal as L  # noqa
+
+from ._compat import string_types
+from .specifiers import Specifier, InvalidSpecifier
+
+
+__all__ = [
+    "InvalidMarker",
+    "UndefinedComparison",
+    "UndefinedEnvironmentName",
+    "Marker",
+    "default_environment",
+]
+
+
+class InvalidMarker(ValueError):
+    """
+    An invalid marker was found, users should refer to PEP 508.
+    """
+
+
+class UndefinedComparison(ValueError):
+    """
+    An invalid operation was attempted on a value that doesn't support it.
+    """
+
+
+class UndefinedEnvironmentName(ValueError):
+    """
+    A name was attempted to be used that does not exist inside of the
+    environment.
+    """
+
+
+class Node(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return str(self.value)
+
+    def __repr__(self):
+        return "<{0}({1!r})>".format(self.__class__.__name__, str(self))
+
+    def serialize(self):
+        raise NotImplementedError
+
+
+class Variable(Node):
+    def serialize(self):
+        return str(self)
+
+
+class Value(Node):
+    def serialize(self):
+        return '"{0}"'.format(self)
+
+
+class Op(Node):
+    def serialize(self):
+        return str(self)
+
+
+VARIABLE = (
+    L("implementation_version")
+    | L("platform_python_implementation")
+    | L("implementation_name")
+    | L("python_full_version")
+    | L("platform_release")
+    | L("platform_version")
+    | L("platform_machine")
+    | L("platform_system")
+    | L("python_version")
+    | L("sys_platform")
+    | L("os_name")
+    | L("os.name")
+    | L("sys.platform")  # PEP-345
+    | L("platform.version")  # PEP-345
+    | L("platform.machine")  # PEP-345
+    | L("platform.python_implementation")  # PEP-345
+    | L("python_implementation")  # PEP-345
+    | L("extra")  # undocumented setuptools legacy
+)
+ALIASES = {
+    "os.name": "os_name",
+    "sys.platform": "sys_platform",
+    "platform.version": "platform_version",
+    "platform.machine": "platform_machine",
+    "platform.python_implementation": "platform_python_implementation",
+    "python_implementation": "platform_python_implementation",
+}
+VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))
+
+VERSION_CMP = (
+    L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<")
+)
+
+MARKER_OP = VERSION_CMP | L("not in") | L("in")
+MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))
+
+MARKER_VALUE = QuotedString("'") | QuotedString('"')
+MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
+
+BOOLOP = L("and") | L("or")
+
+MARKER_VAR = VARIABLE | MARKER_VALUE
+
+MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
+MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
+
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+
+MARKER_EXPR = Forward()
+MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
+MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
+
+MARKER = stringStart + MARKER_EXPR + stringEnd
+
+
+def _coerce_parse_result(results):
+    if isinstance(results, ParseResults):
+        return [_coerce_parse_result(i) for i in results]
+    else:
+        return results
+
+
+def _format_marker(marker, first=True):
+    assert isinstance(marker, (list, tuple, string_types))
+
+    # Sometimes we have a structure like [[...]] which is a single item list
+    # where the single item is itself it's own list. In that case we want skip
+    # the rest of this function so that we don't get extraneous () on the
+    # outside.
+    if (
+        isinstance(marker, list)
+        and len(marker) == 1
+        and isinstance(marker[0], (list, tuple))
+    ):
+        return _format_marker(marker[0])
+
+    if isinstance(marker, list):
+        inner = (_format_marker(m, first=False) for m in marker)
+        if first:
+            return " ".join(inner)
+        else:
+            return "(" + " ".join(inner) + ")"
+    elif isinstance(marker, tuple):
+        return " ".join([m.serialize() for m in marker])
+    else:
+        return marker
+
+
+_operators = {
+    "in": lambda lhs, rhs: lhs in rhs,
+    "not in": lambda lhs, rhs: lhs not in rhs,
+    "<": operator.lt,
+    "<=": operator.le,
+    "==": operator.eq,
+    "!=": operator.ne,
+    ">=": operator.ge,
+    ">": operator.gt,
+}
+
+
+def _eval_op(lhs, op, rhs):
+    try:
+        spec = Specifier("".join([op.serialize(), rhs]))
+    except InvalidSpecifier:
+        pass
+    else:
+        return spec.contains(lhs)
+
+    oper = _operators.get(op.serialize())
+    if oper is None:
+        raise UndefinedComparison(
+            "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs)
+        )
+
+    return oper(lhs, rhs)
+
+
+_undefined = object()
+
+
+def _get_env(environment, name):
+    value = environment.get(name, _undefined)
+
+    if value is _undefined:
+        raise UndefinedEnvironmentName(
+            "{0!r} does not exist in evaluation environment.".format(name)
+        )
+
+    return value
+
+
+def _evaluate_markers(markers, environment):
+    groups = [[]]
+
+    for marker in markers:
+        assert isinstance(marker, (list, tuple, string_types))
+
+        if isinstance(marker, list):
+            groups[-1].append(_evaluate_markers(marker, environment))
+        elif isinstance(marker, tuple):
+            lhs, op, rhs = marker
+
+            if isinstance(lhs, Variable):
+                lhs_value = _get_env(environment, lhs.value)
+                rhs_value = rhs.value
+            else:
+                lhs_value = lhs.value
+                rhs_value = _get_env(environment, rhs.value)
+
+            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
+        else:
+            assert marker in ["and", "or"]
+            if marker == "or":
+                groups.append([])
+
+    return any(all(item) for item in groups)
+
+
+def format_full_version(info):
+    version = "{0.major}.{0.minor}.{0.micro}".format(info)
+    kind = info.releaselevel
+    if kind != "final":
+        version += kind[0] + str(info.serial)
+    return version
+
+
+def default_environment():
+    if hasattr(sys, "implementation"):
+        iver = format_full_version(sys.implementation.version)
+        implementation_name = sys.implementation.name
+    else:
+        iver = "0"
+        implementation_name = ""
+
+    return {
+        "implementation_name": implementation_name,
+        "implementation_version": iver,
+        "os_name": os.name,
+        "platform_machine": platform.machine(),
+        "platform_release": platform.release(),
+        "platform_system": platform.system(),
+        "platform_version": platform.version(),
+        "python_full_version": platform.python_version(),
+        "platform_python_implementation": platform.python_implementation(),
+        "python_version": ".".join(platform.python_version_tuple()[:2]),
+        "sys_platform": sys.platform,
+    }
+
+
+class Marker(object):
+    def __init__(self, marker):
+        try:
+            self._markers = _coerce_parse_result(MARKER.parseString(marker))
+        except ParseException as e:
+            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format(
+                marker, marker[e.loc : e.loc + 8]
+            )
+            raise InvalidMarker(err_str)
+
+    def __str__(self):
+        return _format_marker(self._markers)
+
+    def __repr__(self):
+        return "<Marker({0!r})>".format(str(self))
+
+    def evaluate(self, environment=None):
+        """Evaluate a marker.
+
+        Return the boolean from evaluating the given marker against the
+        environment. environment is an optional argument to override all or
+        part of the determined environment.
+
+        The environment is determined from the current Python process.
+        """
+        current_environment = default_environment()
+        if environment is not None:
+            current_environment.update(environment)
+
+        return _evaluate_markers(self._markers, current_environment)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/requirements.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/requirements.py
new file mode 100644
index 0000000..8a0c2cb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/requirements.py
@@ -0,0 +1,138 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import string
+import re
+
+from setuptools.extern.pyparsing import stringStart, stringEnd, originalTextFor, ParseException
+from setuptools.extern.pyparsing import ZeroOrMore, Word, Optional, Regex, Combine
+from setuptools.extern.pyparsing import Literal as L  # noqa
+from setuptools.extern.six.moves.urllib import parse as urlparse
+
+from .markers import MARKER_EXPR, Marker
+from .specifiers import LegacySpecifier, Specifier, SpecifierSet
+
+
+class InvalidRequirement(ValueError):
+    """
+    An invalid requirement was found, users should refer to PEP 508.
+    """
+
+
+ALPHANUM = Word(string.ascii_letters + string.digits)
+
+LBRACKET = L("[").suppress()
+RBRACKET = L("]").suppress()
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+COMMA = L(",").suppress()
+SEMICOLON = L(";").suppress()
+AT = L("@").suppress()
+
+PUNCTUATION = Word("-_.")
+IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
+IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
+
+NAME = IDENTIFIER("name")
+EXTRA = IDENTIFIER
+
+URI = Regex(r"[^ ]+")("url")
+URL = AT + URI
+
+EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
+EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
+
+VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
+VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
+
+VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
+VERSION_MANY = Combine(
+    VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False
+)("_raw_spec")
+_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY))
+_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "")
+
+VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
+VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
+
+MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
+MARKER_EXPR.setParseAction(
+    lambda s, l, t: Marker(s[t._original_start : t._original_end])
+)
+MARKER_SEPARATOR = SEMICOLON
+MARKER = MARKER_SEPARATOR + MARKER_EXPR
+
+VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
+URL_AND_MARKER = URL + Optional(MARKER)
+
+NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
+
+REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
+# setuptools.extern.pyparsing isn't thread safe during initialization, so we do it eagerly, see
+# issue #104
+REQUIREMENT.parseString("x[]")
+
+
+class Requirement(object):
+    """Parse a requirement.
+
+    Parse a given requirement string into its parts, such as name, specifier,
+    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
+    string.
+    """
+
+    # TODO: Can we test whether something is contained within a requirement?
+    #       If so how do we do that? Do we need to test against the _name_ of
+    #       the thing as well as the version? What about the markers?
+    # TODO: Can we normalize the name and extra name?
+
+    def __init__(self, requirement_string):
+        try:
+            req = REQUIREMENT.parseString(requirement_string)
+        except ParseException as e:
+            raise InvalidRequirement(
+                'Parse error at "{0!r}": {1}'.format(
+                    requirement_string[e.loc : e.loc + 8], e.msg
+                )
+            )
+
+        self.name = req.name
+        if req.url:
+            parsed_url = urlparse.urlparse(req.url)
+            if parsed_url.scheme == "file":
+                if urlparse.urlunparse(parsed_url) != req.url:
+                    raise InvalidRequirement("Invalid URL given")
+            elif not (parsed_url.scheme and parsed_url.netloc) or (
+                not parsed_url.scheme and not parsed_url.netloc
+            ):
+                raise InvalidRequirement("Invalid URL: {0}".format(req.url))
+            self.url = req.url
+        else:
+            self.url = None
+        self.extras = set(req.extras.asList() if req.extras else [])
+        self.specifier = SpecifierSet(req.specifier)
+        self.marker = req.marker if req.marker else None
+
+    def __str__(self):
+        parts = [self.name]
+
+        if self.extras:
+            parts.append("[{0}]".format(",".join(sorted(self.extras))))
+
+        if self.specifier:
+            parts.append(str(self.specifier))
+
+        if self.url:
+            parts.append("@ {0}".format(self.url))
+            if self.marker:
+                parts.append(" ")
+
+        if self.marker:
+            parts.append("; {0}".format(self.marker))
+
+        return "".join(parts)
+
+    def __repr__(self):
+        return "<Requirement({0!r})>".format(str(self))
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/specifiers.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/specifiers.py
new file mode 100644
index 0000000..743576a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/specifiers.py
@@ -0,0 +1,749 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import abc
+import functools
+import itertools
+import re
+
+from ._compat import string_types, with_metaclass
+from .version import Version, LegacyVersion, parse
+
+
+class InvalidSpecifier(ValueError):
+    """
+    An invalid specifier was found, users should refer to PEP 440.
+    """
+
+
+class BaseSpecifier(with_metaclass(abc.ABCMeta, object)):
+    @abc.abstractmethod
+    def __str__(self):
+        """
+        Returns the str representation of this Specifier like object. This
+        should be representative of the Specifier itself.
+        """
+
+    @abc.abstractmethod
+    def __hash__(self):
+        """
+        Returns a hash value for this Specifier like object.
+        """
+
+    @abc.abstractmethod
+    def __eq__(self, other):
+        """
+        Returns a boolean representing whether or not the two Specifier like
+        objects are equal.
+        """
+
+    @abc.abstractmethod
+    def __ne__(self, other):
+        """
+        Returns a boolean representing whether or not the two Specifier like
+        objects are not equal.
+        """
+
+    @abc.abstractproperty
+    def prereleases(self):
+        """
+        Returns whether or not pre-releases as a whole are allowed by this
+        specifier.
+        """
+
+    @prereleases.setter
+    def prereleases(self, value):
+        """
+        Sets whether or not pre-releases as a whole are allowed by this
+        specifier.
+        """
+
+    @abc.abstractmethod
+    def contains(self, item, prereleases=None):
+        """
+        Determines if the given item is contained within this specifier.
+        """
+
+    @abc.abstractmethod
+    def filter(self, iterable, prereleases=None):
+        """
+        Takes an iterable of items and filters them so that only items which
+        are contained within this specifier are allowed in it.
+        """
+
+
+class _IndividualSpecifier(BaseSpecifier):
+
+    _operators = {}
+
+    def __init__(self, spec="", prereleases=None):
+        match = self._regex.search(spec)
+        if not match:
+            raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec))
+
+        self._spec = (match.group("operator").strip(), match.group("version").strip())
+
+        # Store whether or not this Specifier should accept prereleases
+        self._prereleases = prereleases
+
+    def __repr__(self):
+        pre = (
+            ", prereleases={0!r}".format(self.prereleases)
+            if self._prereleases is not None
+            else ""
+        )
+
+        return "<{0}({1!r}{2})>".format(self.__class__.__name__, str(self), pre)
+
+    def __str__(self):
+        return "{0}{1}".format(*self._spec)
+
+    def __hash__(self):
+        return hash(self._spec)
+
+    def __eq__(self, other):
+        if isinstance(other, string_types):
+            try:
+                other = self.__class__(other)
+            except InvalidSpecifier:
+                return NotImplemented
+        elif not isinstance(other, self.__class__):
+            return NotImplemented
+
+        return self._spec == other._spec
+
+    def __ne__(self, other):
+        if isinstance(other, string_types):
+            try:
+                other = self.__class__(other)
+            except InvalidSpecifier:
+                return NotImplemented
+        elif not isinstance(other, self.__class__):
+            return NotImplemented
+
+        return self._spec != other._spec
+
+    def _get_operator(self, op):
+        return getattr(self, "_compare_{0}".format(self._operators[op]))
+
+    def _coerce_version(self, version):
+        if not isinstance(version, (LegacyVersion, Version)):
+            version = parse(version)
+        return version
+
+    @property
+    def operator(self):
+        return self._spec[0]
+
+    @property
+    def version(self):
+        return self._spec[1]
+
+    @property
+    def prereleases(self):
+        return self._prereleases
+
+    @prereleases.setter
+    def prereleases(self, value):
+        self._prereleases = value
+
+    def __contains__(self, item):
+        return self.contains(item)
+
+    def contains(self, item, prereleases=None):
+        # Determine if prereleases are to be allowed or not.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # Normalize item to a Version or LegacyVersion, this allows us to have
+        # a shortcut for ``"2.0" in Specifier(">=2")
+        item = self._coerce_version(item)
+
+        # Determine if we should be supporting prereleases in this specifier
+        # or not, if we do not support prereleases than we can short circuit
+        # logic if this version is a prereleases.
+        if item.is_prerelease and not prereleases:
+            return False
+
+        # Actually do the comparison to determine if this item is contained
+        # within this Specifier or not.
+        return self._get_operator(self.operator)(item, self.version)
+
+    def filter(self, iterable, prereleases=None):
+        yielded = False
+        found_prereleases = []
+
+        kw = {"prereleases": prereleases if prereleases is not None else True}
+
+        # Attempt to iterate over all the values in the iterable and if any of
+        # them match, yield them.
+        for version in iterable:
+            parsed_version = self._coerce_version(version)
+
+            if self.contains(parsed_version, **kw):
+                # If our version is a prerelease, and we were not set to allow
+                # prereleases, then we'll store it for later incase nothing
+                # else matches this specifier.
+                if parsed_version.is_prerelease and not (
+                    prereleases or self.prereleases
+                ):
+                    found_prereleases.append(version)
+                # Either this is not a prerelease, or we should have been
+                # accepting prereleases from the beginning.
+                else:
+                    yielded = True
+                    yield version
+
+        # Now that we've iterated over everything, determine if we've yielded
+        # any values, and if we have not and we have any prereleases stored up
+        # then we will go ahead and yield the prereleases.
+        if not yielded and found_prereleases:
+            for version in found_prereleases:
+                yield version
+
+
+class LegacySpecifier(_IndividualSpecifier):
+
+    _regex_str = r"""
+        (?P<operator>(==|!=|<=|>=|<|>))
+        \s*
+        (?P<version>
+            [^,;\s)]* # Since this is a "legacy" specifier, and the version
+                      # string can be just about anything, we match everything
+                      # except for whitespace, a semi-colon for marker support,
+                      # a closing paren since versions can be enclosed in
+                      # them, and a comma since it's a version separator.
+        )
+        """
+
+    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    _operators = {
+        "==": "equal",
+        "!=": "not_equal",
+        "<=": "less_than_equal",
+        ">=": "greater_than_equal",
+        "<": "less_than",
+        ">": "greater_than",
+    }
+
+    def _coerce_version(self, version):
+        if not isinstance(version, LegacyVersion):
+            version = LegacyVersion(str(version))
+        return version
+
+    def _compare_equal(self, prospective, spec):
+        return prospective == self._coerce_version(spec)
+
+    def _compare_not_equal(self, prospective, spec):
+        return prospective != self._coerce_version(spec)
+
+    def _compare_less_than_equal(self, prospective, spec):
+        return prospective <= self._coerce_version(spec)
+
+    def _compare_greater_than_equal(self, prospective, spec):
+        return prospective >= self._coerce_version(spec)
+
+    def _compare_less_than(self, prospective, spec):
+        return prospective < self._coerce_version(spec)
+
+    def _compare_greater_than(self, prospective, spec):
+        return prospective > self._coerce_version(spec)
+
+
+def _require_version_compare(fn):
+    @functools.wraps(fn)
+    def wrapped(self, prospective, spec):
+        if not isinstance(prospective, Version):
+            return False
+        return fn(self, prospective, spec)
+
+    return wrapped
+
+
+class Specifier(_IndividualSpecifier):
+
+    _regex_str = r"""
+        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
+        (?P<version>
+            (?:
+                # The identity operators allow for an escape hatch that will
+                # do an exact string match of the version you wish to install.
+                # This will not be parsed by PEP 440 and we cannot determine
+                # any semantic meaning from it. This operator is discouraged
+                # but included entirely as an escape hatch.
+                (?<====)  # Only match for the identity operator
+                \s*
+                [^\s]*    # We just match everything, except for whitespace
+                          # since we are only testing for strict identity.
+            )
+            |
+            (?:
+                # The (non)equality operators allow for wild card and local
+                # versions to be specified so we have to define these two
+                # operators separately to enable that.
+                (?<===|!=)            # Only match for equals and not equals
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)*   # release
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+
+                # You cannot use a wild card and a dev or local version
+                # together so group them with a | and make them optional.
+                (?:
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
+                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
+                    |
+                    \.\*  # Wild card syntax of .*
+                )?
+            )
+            |
+            (?:
+                # The compatible operator requires at least two digits in the
+                # release segment.
+                (?<=~=)               # Only match for the compatible operator
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+            )
+            |
+            (?:
+                # All other operators only allow a sub set of what the
+                # (non)equality operators do. Specifically they do not allow
+                # local versions to be specified nor do they allow the prefix
+                # matching wild cards.
+                (?<!==|!=|~=)         # We have special cases for these
+                                      # operators so we want to make sure they
+                                      # don't match here.
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)*   # release
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+            )
+        )
+        """
+
+    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    _operators = {
+        "~=": "compatible",
+        "==": "equal",
+        "!=": "not_equal",
+        "<=": "less_than_equal",
+        ">=": "greater_than_equal",
+        "<": "less_than",
+        ">": "greater_than",
+        "===": "arbitrary",
+    }
+
+    @_require_version_compare
+    def _compare_compatible(self, prospective, spec):
+        # Compatible releases have an equivalent combination of >= and ==. That
+        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
+        # implement this in terms of the other specifiers instead of
+        # implementing it ourselves. The only thing we need to do is construct
+        # the other specifiers.
+
+        # We want everything but the last item in the version, but we want to
+        # ignore post and dev releases and we want to treat the pre-release as
+        # it's own separate segment.
+        prefix = ".".join(
+            list(
+                itertools.takewhile(
+                    lambda x: (not x.startswith("post") and not x.startswith("dev")),
+                    _version_split(spec),
+                )
+            )[:-1]
+        )
+
+        # Add the prefix notation to the end of our string
+        prefix += ".*"
+
+        return self._get_operator(">=")(prospective, spec) and self._get_operator("==")(
+            prospective, prefix
+        )
+
+    @_require_version_compare
+    def _compare_equal(self, prospective, spec):
+        # We need special logic to handle prefix matching
+        if spec.endswith(".*"):
+            # In the case of prefix matching we want to ignore local segment.
+            prospective = Version(prospective.public)
+            # Split the spec out by dots, and pretend that there is an implicit
+            # dot in between a release segment and a pre-release segment.
+            spec = _version_split(spec[:-2])  # Remove the trailing .*
+
+            # Split the prospective version out by dots, and pretend that there
+            # is an implicit dot in between a release segment and a pre-release
+            # segment.
+            prospective = _version_split(str(prospective))
+
+            # Shorten the prospective version to be the same length as the spec
+            # so that we can determine if the specifier is a prefix of the
+            # prospective version or not.
+            prospective = prospective[: len(spec)]
+
+            # Pad out our two sides with zeros so that they both equal the same
+            # length.
+            spec, prospective = _pad_version(spec, prospective)
+        else:
+            # Convert our spec string into a Version
+            spec = Version(spec)
+
+            # If the specifier does not have a local segment, then we want to
+            # act as if the prospective version also does not have a local
+            # segment.
+            if not spec.local:
+                prospective = Version(prospective.public)
+
+        return prospective == spec
+
+    @_require_version_compare
+    def _compare_not_equal(self, prospective, spec):
+        return not self._compare_equal(prospective, spec)
+
+    @_require_version_compare
+    def _compare_less_than_equal(self, prospective, spec):
+        return prospective <= Version(spec)
+
+    @_require_version_compare
+    def _compare_greater_than_equal(self, prospective, spec):
+        return prospective >= Version(spec)
+
+    @_require_version_compare
+    def _compare_less_than(self, prospective, spec):
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
+        spec = Version(spec)
+
+        # Check to see if the prospective version is less than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective < spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a pre-release version, that we do not accept pre-release
+        # versions for the version mentioned in the specifier (e.g. <3.1 should
+        # not match 3.1.dev0, but should match 3.0.dev0).
+        if not spec.is_prerelease and prospective.is_prerelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # less than the spec version *and* it's not a pre-release of the same
+        # version in the spec.
+        return True
+
+    @_require_version_compare
+    def _compare_greater_than(self, prospective, spec):
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
+        spec = Version(spec)
+
+        # Check to see if the prospective version is greater than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective > spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a post-release version, that we do not accept
+        # post-release versions for the version mentioned in the specifier
+        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
+        if not spec.is_postrelease and prospective.is_postrelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # Ensure that we do not allow a local version of the version mentioned
+        # in the specifier, which is technically greater than, to match.
+        if prospective.local is not None:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # greater than the spec version *and* it's not a pre-release of the
+        # same version in the spec.
+        return True
+
+    def _compare_arbitrary(self, prospective, spec):
+        return str(prospective).lower() == str(spec).lower()
+
+    @property
+    def prereleases(self):
+        # If there is an explicit prereleases set for this, then we'll just
+        # blindly use that.
+        if self._prereleases is not None:
+            return self._prereleases
+
+        # Look at all of our specifiers and determine if they are inclusive
+        # operators, and if they are if they are including an explicit
+        # prerelease.
+        operator, version = self._spec
+        if operator in ["==", ">=", "<=", "~=", "==="]:
+            # The == specifier can include a trailing .*, if it does we
+            # want to remove before parsing.
+            if operator == "==" and version.endswith(".*"):
+                version = version[:-2]
+
+            # Parse the version, and if it is a pre-release than this
+            # specifier allows pre-releases.
+            if parse(version).is_prerelease:
+                return True
+
+        return False
+
+    @prereleases.setter
+    def prereleases(self, value):
+        self._prereleases = value
+
+
+_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
+
+
+def _version_split(version):
+    result = []
+    for item in version.split("."):
+        match = _prefix_regex.search(item)
+        if match:
+            result.extend(match.groups())
+        else:
+            result.append(item)
+    return result
+
+
+def _pad_version(left, right):
+    left_split, right_split = [], []
+
+    # Get the release segment of our versions
+    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
+    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
+
+    # Get the rest of our versions
+    left_split.append(left[len(left_split[0]) :])
+    right_split.append(right[len(right_split[0]) :])
+
+    # Insert our padding
+    left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0])))
+    right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0])))
+
+    return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split)))
+
+
+class SpecifierSet(BaseSpecifier):
+    def __init__(self, specifiers="", prereleases=None):
+        # Split on , to break each indidivual specifier into it's own item, and
+        # strip each item to remove leading/trailing whitespace.
+        specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
+
+        # Parsed each individual specifier, attempting first to make it a
+        # Specifier and falling back to a LegacySpecifier.
+        parsed = set()
+        for specifier in specifiers:
+            try:
+                parsed.add(Specifier(specifier))
+            except InvalidSpecifier:
+                parsed.add(LegacySpecifier(specifier))
+
+        # Turn our parsed specifiers into a frozen set and save them for later.
+        self._specs = frozenset(parsed)
+
+        # Store our prereleases value so we can use it later to determine if
+        # we accept prereleases or not.
+        self._prereleases = prereleases
+
+    def __repr__(self):
+        pre = (
+            ", prereleases={0!r}".format(self.prereleases)
+            if self._prereleases is not None
+            else ""
+        )
+
+        return "<SpecifierSet({0!r}{1})>".format(str(self), pre)
+
+    def __str__(self):
+        return ",".join(sorted(str(s) for s in self._specs))
+
+    def __hash__(self):
+        return hash(self._specs)
+
+    def __and__(self, other):
+        if isinstance(other, string_types):
+            other = SpecifierSet(other)
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        specifier = SpecifierSet()
+        specifier._specs = frozenset(self._specs | other._specs)
+
+        if self._prereleases is None and other._prereleases is not None:
+            specifier._prereleases = other._prereleases
+        elif self._prereleases is not None and other._prereleases is None:
+            specifier._prereleases = self._prereleases
+        elif self._prereleases == other._prereleases:
+            specifier._prereleases = self._prereleases
+        else:
+            raise ValueError(
+                "Cannot combine SpecifierSets with True and False prerelease "
+                "overrides."
+            )
+
+        return specifier
+
+    def __eq__(self, other):
+        if isinstance(other, string_types):
+            other = SpecifierSet(other)
+        elif isinstance(other, _IndividualSpecifier):
+            other = SpecifierSet(str(other))
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        return self._specs == other._specs
+
+    def __ne__(self, other):
+        if isinstance(other, string_types):
+            other = SpecifierSet(other)
+        elif isinstance(other, _IndividualSpecifier):
+            other = SpecifierSet(str(other))
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        return self._specs != other._specs
+
+    def __len__(self):
+        return len(self._specs)
+
+    def __iter__(self):
+        return iter(self._specs)
+
+    @property
+    def prereleases(self):
+        # If we have been given an explicit prerelease modifier, then we'll
+        # pass that through here.
+        if self._prereleases is not None:
+            return self._prereleases
+
+        # If we don't have any specifiers, and we don't have a forced value,
+        # then we'll just return None since we don't know if this should have
+        # pre-releases or not.
+        if not self._specs:
+            return None
+
+        # Otherwise we'll see if any of the given specifiers accept
+        # prereleases, if any of them do we'll return True, otherwise False.
+        return any(s.prereleases for s in self._specs)
+
+    @prereleases.setter
+    def prereleases(self, value):
+        self._prereleases = value
+
+    def __contains__(self, item):
+        return self.contains(item)
+
+    def contains(self, item, prereleases=None):
+        # Ensure that our item is a Version or LegacyVersion instance.
+        if not isinstance(item, (LegacyVersion, Version)):
+            item = parse(item)
+
+        # Determine if we're forcing a prerelease or not, if we're not forcing
+        # one for this particular filter call, then we'll use whatever the
+        # SpecifierSet thinks for whether or not we should support prereleases.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # We can determine if we're going to allow pre-releases by looking to
+        # see if any of the underlying items supports them. If none of them do
+        # and this item is a pre-release then we do not allow it and we can
+        # short circuit that here.
+        # Note: This means that 1.0.dev1 would not be contained in something
+        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
+        if not prereleases and item.is_prerelease:
+            return False
+
+        # We simply dispatch to the underlying specs here to make sure that the
+        # given version is contained within all of them.
+        # Note: This use of all() here means that an empty set of specifiers
+        #       will always return True, this is an explicit design decision.
+        return all(s.contains(item, prereleases=prereleases) for s in self._specs)
+
+    def filter(self, iterable, prereleases=None):
+        # Determine if we're forcing a prerelease or not, if we're not forcing
+        # one for this particular filter call, then we'll use whatever the
+        # SpecifierSet thinks for whether or not we should support prereleases.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # If we have any specifiers, then we want to wrap our iterable in the
+        # filter method for each one, this will act as a logical AND amongst
+        # each specifier.
+        if self._specs:
+            for spec in self._specs:
+                iterable = spec.filter(iterable, prereleases=bool(prereleases))
+            return iterable
+        # If we do not have any specifiers, then we need to have a rough filter
+        # which will filter out any pre-releases, unless there are no final
+        # releases, and which will filter out LegacyVersion in general.
+        else:
+            filtered = []
+            found_prereleases = []
+
+            for item in iterable:
+                # Ensure that we some kind of Version class for this item.
+                if not isinstance(item, (LegacyVersion, Version)):
+                    parsed_version = parse(item)
+                else:
+                    parsed_version = item
+
+                # Filter out any item which is parsed as a LegacyVersion
+                if isinstance(parsed_version, LegacyVersion):
+                    continue
+
+                # Store any item which is a pre-release for later unless we've
+                # already found a final version or we are accepting prereleases
+                if parsed_version.is_prerelease and not prereleases:
+                    if not filtered:
+                        found_prereleases.append(item)
+                else:
+                    filtered.append(item)
+
+            # If we've found no items except for pre-releases, then we'll go
+            # ahead and use the pre-releases
+            if not filtered and found_prereleases and prereleases is None:
+                return found_prereleases
+
+            return filtered
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/tags.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/tags.py
new file mode 100644
index 0000000..ec9942f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/tags.py
@@ -0,0 +1,404 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import absolute_import
+
+import distutils.util
+
+try:
+    from importlib.machinery import EXTENSION_SUFFIXES
+except ImportError:  # pragma: no cover
+    import imp
+
+    EXTENSION_SUFFIXES = [x[0] for x in imp.get_suffixes()]
+    del imp
+import platform
+import re
+import sys
+import sysconfig
+import warnings
+
+
+INTERPRETER_SHORT_NAMES = {
+    "python": "py",  # Generic.
+    "cpython": "cp",
+    "pypy": "pp",
+    "ironpython": "ip",
+    "jython": "jy",
+}
+
+
+_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32
+
+
+class Tag(object):
+
+    __slots__ = ["_interpreter", "_abi", "_platform"]
+
+    def __init__(self, interpreter, abi, platform):
+        self._interpreter = interpreter.lower()
+        self._abi = abi.lower()
+        self._platform = platform.lower()
+
+    @property
+    def interpreter(self):
+        return self._interpreter
+
+    @property
+    def abi(self):
+        return self._abi
+
+    @property
+    def platform(self):
+        return self._platform
+
+    def __eq__(self, other):
+        return (
+            (self.platform == other.platform)
+            and (self.abi == other.abi)
+            and (self.interpreter == other.interpreter)
+        )
+
+    def __hash__(self):
+        return hash((self._interpreter, self._abi, self._platform))
+
+    def __str__(self):
+        return "{}-{}-{}".format(self._interpreter, self._abi, self._platform)
+
+    def __repr__(self):
+        return "<{self} @ {self_id}>".format(self=self, self_id=id(self))
+
+
+def parse_tag(tag):
+    tags = set()
+    interpreters, abis, platforms = tag.split("-")
+    for interpreter in interpreters.split("."):
+        for abi in abis.split("."):
+            for platform_ in platforms.split("."):
+                tags.add(Tag(interpreter, abi, platform_))
+    return frozenset(tags)
+
+
+def _normalize_string(string):
+    return string.replace(".", "_").replace("-", "_")
+
+
+def _cpython_interpreter(py_version):
+    # TODO: Is using py_version_nodot for interpreter version critical?
+    return "cp{major}{minor}".format(major=py_version[0], minor=py_version[1])
+
+
+def _cpython_abis(py_version):
+    abis = []
+    version = "{}{}".format(*py_version[:2])
+    debug = pymalloc = ucs4 = ""
+    with_debug = sysconfig.get_config_var("Py_DEBUG")
+    has_refcount = hasattr(sys, "gettotalrefcount")
+    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
+    # extension modules is the best option.
+    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692
+    has_ext = "_d.pyd" in EXTENSION_SUFFIXES
+    if with_debug or (with_debug is None and (has_refcount or has_ext)):
+        debug = "d"
+    if py_version < (3, 8):
+        with_pymalloc = sysconfig.get_config_var("WITH_PYMALLOC")
+        if with_pymalloc or with_pymalloc is None:
+            pymalloc = "m"
+        if py_version < (3, 3):
+            unicode_size = sysconfig.get_config_var("Py_UNICODE_SIZE")
+            if unicode_size == 4 or (
+                unicode_size is None and sys.maxunicode == 0x10FFFF
+            ):
+                ucs4 = "u"
+    elif debug:
+        # Debug builds can also load "normal" extension modules.
+        # We can also assume no UCS-4 or pymalloc requirement.
+        abis.append("cp{version}".format(version=version))
+    abis.insert(
+        0,
+        "cp{version}{debug}{pymalloc}{ucs4}".format(
+            version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4
+        ),
+    )
+    return abis
+
+
+def _cpython_tags(py_version, interpreter, abis, platforms):
+    for abi in abis:
+        for platform_ in platforms:
+            yield Tag(interpreter, abi, platform_)
+    for tag in (Tag(interpreter, "abi3", platform_) for platform_ in platforms):
+        yield tag
+    for tag in (Tag(interpreter, "none", platform_) for platform_ in platforms):
+        yield tag
+    # PEP 384 was first implemented in Python 3.2.
+    for minor_version in range(py_version[1] - 1, 1, -1):
+        for platform_ in platforms:
+            interpreter = "cp{major}{minor}".format(
+                major=py_version[0], minor=minor_version
+            )
+            yield Tag(interpreter, "abi3", platform_)
+
+
+def _pypy_interpreter():
+    return "pp{py_major}{pypy_major}{pypy_minor}".format(
+        py_major=sys.version_info[0],
+        pypy_major=sys.pypy_version_info.major,
+        pypy_minor=sys.pypy_version_info.minor,
+    )
+
+
+def _generic_abi():
+    abi = sysconfig.get_config_var("SOABI")
+    if abi:
+        return _normalize_string(abi)
+    else:
+        return "none"
+
+
+def _pypy_tags(py_version, interpreter, abi, platforms):
+    for tag in (Tag(interpreter, abi, platform) for platform in platforms):
+        yield tag
+    for tag in (Tag(interpreter, "none", platform) for platform in platforms):
+        yield tag
+
+
+def _generic_tags(interpreter, py_version, abi, platforms):
+    for tag in (Tag(interpreter, abi, platform) for platform in platforms):
+        yield tag
+    if abi != "none":
+        tags = (Tag(interpreter, "none", platform_) for platform_ in platforms)
+        for tag in tags:
+            yield tag
+
+
+def _py_interpreter_range(py_version):
+    """
+    Yield Python versions in descending order.
+
+    After the latest version, the major-only version will be yielded, and then
+    all following versions up to 'end'.
+    """
+    yield "py{major}{minor}".format(major=py_version[0], minor=py_version[1])
+    yield "py{major}".format(major=py_version[0])
+    for minor in range(py_version[1] - 1, -1, -1):
+        yield "py{major}{minor}".format(major=py_version[0], minor=minor)
+
+
+def _independent_tags(interpreter, py_version, platforms):
+    """
+    Return the sequence of tags that are consistent across implementations.
+
+    The tags consist of:
+    - py*-none-<platform>
+    - <interpreter>-none-any
+    - py*-none-any
+    """
+    for version in _py_interpreter_range(py_version):
+        for platform_ in platforms:
+            yield Tag(version, "none", platform_)
+    yield Tag(interpreter, "none", "any")
+    for version in _py_interpreter_range(py_version):
+        yield Tag(version, "none", "any")
+
+
+def _mac_arch(arch, is_32bit=_32_BIT_INTERPRETER):
+    if not is_32bit:
+        return arch
+
+    if arch.startswith("ppc"):
+        return "ppc"
+
+    return "i386"
+
+
+def _mac_binary_formats(version, cpu_arch):
+    formats = [cpu_arch]
+    if cpu_arch == "x86_64":
+        if version < (10, 4):
+            return []
+        formats.extend(["intel", "fat64", "fat32"])
+
+    elif cpu_arch == "i386":
+        if version < (10, 4):
+            return []
+        formats.extend(["intel", "fat32", "fat"])
+
+    elif cpu_arch == "ppc64":
+        # TODO: Need to care about 32-bit PPC for ppc64 through 10.2?
+        if version > (10, 5) or version < (10, 4):
+            return []
+        formats.append("fat64")
+
+    elif cpu_arch == "ppc":
+        if version > (10, 6):
+            return []
+        formats.extend(["fat32", "fat"])
+
+    formats.append("universal")
+    return formats
+
+
+def _mac_platforms(version=None, arch=None):
+    version_str, _, cpu_arch = platform.mac_ver()
+    if version is None:
+        version = tuple(map(int, version_str.split(".")[:2]))
+    if arch is None:
+        arch = _mac_arch(cpu_arch)
+    platforms = []
+    for minor_version in range(version[1], -1, -1):
+        compat_version = version[0], minor_version
+        binary_formats = _mac_binary_formats(compat_version, arch)
+        for binary_format in binary_formats:
+            platforms.append(
+                "macosx_{major}_{minor}_{binary_format}".format(
+                    major=compat_version[0],
+                    minor=compat_version[1],
+                    binary_format=binary_format,
+                )
+            )
+    return platforms
+
+
+# From PEP 513.
+def _is_manylinux_compatible(name, glibc_version):
+    # Check for presence of _manylinux module.
+    try:
+        import _manylinux
+
+        return bool(getattr(_manylinux, name + "_compatible"))
+    except (ImportError, AttributeError):
+        # Fall through to heuristic check below.
+        pass
+
+    return _have_compatible_glibc(*glibc_version)
+
+
+def _glibc_version_string():
+    # Returns glibc version string, or None if not using glibc.
+    import ctypes
+
+    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
+    # manpage says, "If filename is NULL, then the returned handle is for the
+    # main program". This way we can let the linker do the work to figure out
+    # which libc our process is actually using.
+    process_namespace = ctypes.CDLL(None)
+    try:
+        gnu_get_libc_version = process_namespace.gnu_get_libc_version
+    except AttributeError:
+        # Symbol doesn't exist -> therefore, we are not linked to
+        # glibc.
+        return None
+
+    # Call gnu_get_libc_version, which returns a string like "2.5"
+    gnu_get_libc_version.restype = ctypes.c_char_p
+    version_str = gnu_get_libc_version()
+    # py2 / py3 compatibility:
+    if not isinstance(version_str, str):
+        version_str = version_str.decode("ascii")
+
+    return version_str
+
+
+# Separated out from have_compatible_glibc for easier unit testing.
+def _check_glibc_version(version_str, required_major, minimum_minor):
+    # Parse string and check against requested version.
+    #
+    # We use a regexp instead of str.split because we want to discard any
+    # random junk that might come after the minor version -- this might happen
+    # in patched/forked versions of glibc (e.g. Linaro's version of glibc
+    # uses version strings like "2.20-2014.11"). See gh-3588.
+    m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str)
+    if not m:
+        warnings.warn(
+            "Expected glibc version with 2 components major.minor,"
+            " got: %s" % version_str,
+            RuntimeWarning,
+        )
+        return False
+    return (
+        int(m.group("major")) == required_major
+        and int(m.group("minor")) >= minimum_minor
+    )
+
+
+def _have_compatible_glibc(required_major, minimum_minor):
+    version_str = _glibc_version_string()
+    if version_str is None:
+        return False
+    return _check_glibc_version(version_str, required_major, minimum_minor)
+
+
+def _linux_platforms(is_32bit=_32_BIT_INTERPRETER):
+    linux = _normalize_string(distutils.util.get_platform())
+    if linux == "linux_x86_64" and is_32bit:
+        linux = "linux_i686"
+    manylinux_support = (
+        ("manylinux2014", (2, 17)),  # CentOS 7 w/ glibc 2.17 (PEP 599)
+        ("manylinux2010", (2, 12)),  # CentOS 6 w/ glibc 2.12 (PEP 571)
+        ("manylinux1", (2, 5)),  # CentOS 5 w/ glibc 2.5 (PEP 513)
+    )
+    manylinux_support_iter = iter(manylinux_support)
+    for name, glibc_version in manylinux_support_iter:
+        if _is_manylinux_compatible(name, glibc_version):
+            platforms = [linux.replace("linux", name)]
+            break
+    else:
+        platforms = []
+    # Support for a later manylinux implies support for an earlier version.
+    platforms += [linux.replace("linux", name) for name, _ in manylinux_support_iter]
+    platforms.append(linux)
+    return platforms
+
+
+def _generic_platforms():
+    platform = _normalize_string(distutils.util.get_platform())
+    return [platform]
+
+
+def _interpreter_name():
+    name = platform.python_implementation().lower()
+    return INTERPRETER_SHORT_NAMES.get(name) or name
+
+
+def _generic_interpreter(name, py_version):
+    version = sysconfig.get_config_var("py_version_nodot")
+    if not version:
+        version = "".join(map(str, py_version[:2]))
+    return "{name}{version}".format(name=name, version=version)
+
+
+def sys_tags():
+    """
+    Returns the sequence of tag triples for the running interpreter.
+
+    The order of the sequence corresponds to priority order for the
+    interpreter, from most to least important.
+    """
+    py_version = sys.version_info[:2]
+    interpreter_name = _interpreter_name()
+    if platform.system() == "Darwin":
+        platforms = _mac_platforms()
+    elif platform.system() == "Linux":
+        platforms = _linux_platforms()
+    else:
+        platforms = _generic_platforms()
+
+    if interpreter_name == "cp":
+        interpreter = _cpython_interpreter(py_version)
+        abis = _cpython_abis(py_version)
+        for tag in _cpython_tags(py_version, interpreter, abis, platforms):
+            yield tag
+    elif interpreter_name == "pp":
+        interpreter = _pypy_interpreter()
+        abi = _generic_abi()
+        for tag in _pypy_tags(py_version, interpreter, abi, platforms):
+            yield tag
+    else:
+        interpreter = _generic_interpreter(interpreter_name, py_version)
+        abi = _generic_abi()
+        for tag in _generic_tags(interpreter, py_version, abi, platforms):
+            yield tag
+    for tag in _independent_tags(interpreter, py_version, platforms):
+        yield tag
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/utils.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/utils.py
new file mode 100644
index 0000000..8841878
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/utils.py
@@ -0,0 +1,57 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import re
+
+from .version import InvalidVersion, Version
+
+
+_canonicalize_regex = re.compile(r"[-_.]+")
+
+
+def canonicalize_name(name):
+    # This is taken from PEP 503.
+    return _canonicalize_regex.sub("-", name).lower()
+
+
+def canonicalize_version(version):
+    """
+    This is very similar to Version.__str__, but has one subtle differences
+    with the way it handles the release segment.
+    """
+
+    try:
+        version = Version(version)
+    except InvalidVersion:
+        # Legacy versions cannot be normalized
+        return version
+
+    parts = []
+
+    # Epoch
+    if version.epoch != 0:
+        parts.append("{0}!".format(version.epoch))
+
+    # Release segment
+    # NB: This strips trailing '.0's to normalize
+    parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in version.release)))
+
+    # Pre-release
+    if version.pre is not None:
+        parts.append("".join(str(x) for x in version.pre))
+
+    # Post-release
+    if version.post is not None:
+        parts.append(".post{0}".format(version.post))
+
+    # Development release
+    if version.dev is not None:
+        parts.append(".dev{0}".format(version.dev))
+
+    # Local version segment
+    if version.local is not None:
+        parts.append("+{0}".format(version.local))
+
+    return "".join(parts)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/version.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/version.py
new file mode 100644
index 0000000..95157a1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/packaging/version.py
@@ -0,0 +1,420 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import collections
+import itertools
+import re
+
+from ._structures import Infinity
+
+
+__all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"]
+
+
+_Version = collections.namedtuple(
+    "_Version", ["epoch", "release", "dev", "pre", "post", "local"]
+)
+
+
+def parse(version):
+    """
+    Parse the given version string and return either a :class:`Version` object
+    or a :class:`LegacyVersion` object depending on if the given version is
+    a valid PEP 440 version or a legacy version.
+    """
+    try:
+        return Version(version)
+    except InvalidVersion:
+        return LegacyVersion(version)
+
+
+class InvalidVersion(ValueError):
+    """
+    An invalid version was found, users should refer to PEP 440.
+    """
+
+
+class _BaseVersion(object):
+    def __hash__(self):
+        return hash(self._key)
+
+    def __lt__(self, other):
+        return self._compare(other, lambda s, o: s < o)
+
+    def __le__(self, other):
+        return self._compare(other, lambda s, o: s <= o)
+
+    def __eq__(self, other):
+        return self._compare(other, lambda s, o: s == o)
+
+    def __ge__(self, other):
+        return self._compare(other, lambda s, o: s >= o)
+
+    def __gt__(self, other):
+        return self._compare(other, lambda s, o: s > o)
+
+    def __ne__(self, other):
+        return self._compare(other, lambda s, o: s != o)
+
+    def _compare(self, other, method):
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+
+        return method(self._key, other._key)
+
+
+class LegacyVersion(_BaseVersion):
+    def __init__(self, version):
+        self._version = str(version)
+        self._key = _legacy_cmpkey(self._version)
+
+    def __str__(self):
+        return self._version
+
+    def __repr__(self):
+        return "<LegacyVersion({0})>".format(repr(str(self)))
+
+    @property
+    def public(self):
+        return self._version
+
+    @property
+    def base_version(self):
+        return self._version
+
+    @property
+    def epoch(self):
+        return -1
+
+    @property
+    def release(self):
+        return None
+
+    @property
+    def pre(self):
+        return None
+
+    @property
+    def post(self):
+        return None
+
+    @property
+    def dev(self):
+        return None
+
+    @property
+    def local(self):
+        return None
+
+    @property
+    def is_prerelease(self):
+        return False
+
+    @property
+    def is_postrelease(self):
+        return False
+
+    @property
+    def is_devrelease(self):
+        return False
+
+
+_legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE)
+
+_legacy_version_replacement_map = {
+    "pre": "c",
+    "preview": "c",
+    "-": "final-",
+    "rc": "c",
+    "dev": "@",
+}
+
+
+def _parse_version_parts(s):
+    for part in _legacy_version_component_re.split(s):
+        part = _legacy_version_replacement_map.get(part, part)
+
+        if not part or part == ".":
+            continue
+
+        if part[:1] in "0123456789":
+            # pad for numeric comparison
+            yield part.zfill(8)
+        else:
+            yield "*" + part
+
+    # ensure that alpha/beta/candidate are before final
+    yield "*final"
+
+
+def _legacy_cmpkey(version):
+    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
+    # greater than or equal to 0. This will effectively put the LegacyVersion,
+    # which uses the defacto standard originally implemented by setuptools,
+    # as before all PEP 440 versions.
+    epoch = -1
+
+    # This scheme is taken from pkg_resources.parse_version setuptools prior to
+    # it's adoption of the packaging library.
+    parts = []
+    for part in _parse_version_parts(version.lower()):
+        if part.startswith("*"):
+            # remove "-" before a prerelease tag
+            if part < "*final":
+                while parts and parts[-1] == "*final-":
+                    parts.pop()
+
+            # remove trailing zeros from each series of numeric parts
+            while parts and parts[-1] == "00000000":
+                parts.pop()
+
+        parts.append(part)
+    parts = tuple(parts)
+
+    return epoch, parts
+
+
+# Deliberately not anchored to the start and end of the string, to make it
+# easier for 3rd party code to reuse
+VERSION_PATTERN = r"""
+    v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
+        (?P<pre>                                          # pre-release
+            [-_\.]?
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>                                         # post release
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>                                          # dev release
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+
+
+class Version(_BaseVersion):
+
+    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    def __init__(self, version):
+        # Validate the version and parse it into pieces
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion("Invalid version: '{0}'".format(version))
+
+        # Store the parsed out pieces of the version
+        self._version = _Version(
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+            release=tuple(int(i) for i in match.group("release").split(".")),
+            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
+            post=_parse_letter_version(
+                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
+            ),
+            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
+            local=_parse_local_version(match.group("local")),
+        )
+
+        # Generate a key which will be used for sorting
+        self._key = _cmpkey(
+            self._version.epoch,
+            self._version.release,
+            self._version.pre,
+            self._version.post,
+            self._version.dev,
+            self._version.local,
+        )
+
+    def __repr__(self):
+        return "<Version({0})>".format(repr(str(self)))
+
+    def __str__(self):
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append("{0}!".format(self.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        # Pre-release
+        if self.pre is not None:
+            parts.append("".join(str(x) for x in self.pre))
+
+        # Post-release
+        if self.post is not None:
+            parts.append(".post{0}".format(self.post))
+
+        # Development release
+        if self.dev is not None:
+            parts.append(".dev{0}".format(self.dev))
+
+        # Local version segment
+        if self.local is not None:
+            parts.append("+{0}".format(self.local))
+
+        return "".join(parts)
+
+    @property
+    def epoch(self):
+        return self._version.epoch
+
+    @property
+    def release(self):
+        return self._version.release
+
+    @property
+    def pre(self):
+        return self._version.pre
+
+    @property
+    def post(self):
+        return self._version.post[1] if self._version.post else None
+
+    @property
+    def dev(self):
+        return self._version.dev[1] if self._version.dev else None
+
+    @property
+    def local(self):
+        if self._version.local:
+            return ".".join(str(x) for x in self._version.local)
+        else:
+            return None
+
+    @property
+    def public(self):
+        return str(self).split("+", 1)[0]
+
+    @property
+    def base_version(self):
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append("{0}!".format(self.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        return "".join(parts)
+
+    @property
+    def is_prerelease(self):
+        return self.dev is not None or self.pre is not None
+
+    @property
+    def is_postrelease(self):
+        return self.post is not None
+
+    @property
+    def is_devrelease(self):
+        return self.dev is not None
+
+
+def _parse_letter_version(letter, number):
+    if letter:
+        # We consider there to be an implicit 0 in a pre-release if there is
+        # not a numeral associated with it.
+        if number is None:
+            number = 0
+
+        # We normalize any letters to their lower case form
+        letter = letter.lower()
+
+        # We consider some words to be alternate spellings of other words and
+        # in those cases we want to normalize the spellings to our preferred
+        # spelling.
+        if letter == "alpha":
+            letter = "a"
+        elif letter == "beta":
+            letter = "b"
+        elif letter in ["c", "pre", "preview"]:
+            letter = "rc"
+        elif letter in ["rev", "r"]:
+            letter = "post"
+
+        return letter, int(number)
+    if not letter and number:
+        # We assume if we are given a number, but we are not given a letter
+        # then this is using the implicit post release syntax (e.g. 1.0-1)
+        letter = "post"
+
+        return letter, int(number)
+
+
+_local_version_separators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local):
+    """
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+    """
+    if local is not None:
+        return tuple(
+            part.lower() if not part.isdigit() else int(part)
+            for part in _local_version_separators.split(local)
+        )
+
+
+def _cmpkey(epoch, release, pre, post, dev, local):
+    # When we compare a release version, we want to compare it with all of the
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now
+    # leading zeros until we come to something non zero, then take the rest
+    # re-reverse it back into the correct order and make it a tuple and use
+    # that for our sorting key.
+    release = tuple(
+        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
+    )
+
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+    # We'll do this by abusing the pre segment, but we _only_ want to do this
+    # if there is not a pre or a post segment. If we have one of those then
+    # the normal sorting rules will handle this case correctly.
+    if pre is None and post is None and dev is not None:
+        pre = -Infinity
+    # Versions without a pre-release (except as noted above) should sort after
+    # those with one.
+    elif pre is None:
+        pre = Infinity
+
+    # Versions without a post segment should sort before those with one.
+    if post is None:
+        post = -Infinity
+
+    # Versions without a development segment should sort after those with one.
+    if dev is None:
+        dev = Infinity
+
+    if local is None:
+        # Versions without a local segment should sort before those with one.
+        local = -Infinity
+    else:
+        # Versions with a local segment need that segment parsed to implement
+        # the sorting rules in PEP440.
+        # - Alpha numeric segments sort before numeric segments
+        # - Alpha numeric segments sort lexicographically
+        # - Numeric segments sort numerically
+        # - Shorter versions sort before longer versions when the prefixes
+        #   match exactly
+        local = tuple((i, "") if isinstance(i, int) else (-Infinity, i) for i in local)
+
+    return epoch, release, pre, post, dev, local
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/pyparsing.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/pyparsing.py
new file mode 100644
index 0000000..cf75e1e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/pyparsing.py
@@ -0,0 +1,5742 @@
+# module pyparsing.py
+#
+# Copyright (c) 2003-2018  Paul T. McGuire
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__doc__ = \
+"""
+pyparsing module - Classes and methods to define and execute parsing grammars
+=============================================================================
+
+The pyparsing module is an alternative approach to creating and executing simple grammars,
+vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you
+don't need to learn a new syntax for defining grammars or matching expressions - the parsing module
+provides a library of classes that you use to construct the grammar directly in Python.
+
+Here is a program to parse "Hello, World!" (or any greeting of the form 
+C{"<salutation>, <addressee>!"}), built up using L{Word}, L{Literal}, and L{And} elements 
+(L{'+'<ParserElement.__add__>} operator gives L{And} expressions, strings are auto-converted to
+L{Literal} expressions)::
+
+    from pyparsing import Word, alphas
+
+    # define grammar of a greeting
+    greet = Word(alphas) + "," + Word(alphas) + "!"
+
+    hello = "Hello, World!"
+    print (hello, "->", greet.parseString(hello))
+
+The program outputs the following::
+
+    Hello, World! -> ['Hello', ',', 'World', '!']
+
+The Python representation of the grammar is quite readable, owing to the self-explanatory
+class names, and the use of '+', '|' and '^' operators.
+
+The L{ParseResults} object returned from L{ParserElement.parseString<ParserElement.parseString>} can be accessed as a nested list, a dictionary, or an
+object with named attributes.
+
+The pyparsing module handles some of the problems that are typically vexing when writing text parsers:
+ - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)
+ - quoted strings
+ - embedded comments
+
+
+Getting Started -
+-----------------
+Visit the classes L{ParserElement} and L{ParseResults} to see the base classes that most other pyparsing
+classes inherit from. Use the docstrings for examples of how to:
+ - construct literal match expressions from L{Literal} and L{CaselessLiteral} classes
+ - construct character word-group expressions using the L{Word} class
+ - see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes
+ - use L{'+'<And>}, L{'|'<MatchFirst>}, L{'^'<Or>}, and L{'&'<Each>} operators to combine simple expressions into more complex ones
+ - associate names with your parsed results using L{ParserElement.setResultsName}
+ - find some helpful expression short-cuts like L{delimitedList} and L{oneOf}
+ - find more useful common expressions in the L{pyparsing_common} namespace class
+"""
+
+__version__ = "2.2.1"
+__versionTime__ = "18 Sep 2018 00:49 UTC"
+__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"
+
+import string
+from weakref import ref as wkref
+import copy
+import sys
+import warnings
+import re
+import sre_constants
+import collections
+import pprint
+import traceback
+import types
+from datetime import datetime
+
+try:
+    from _thread import RLock
+except ImportError:
+    from threading import RLock
+
+try:
+    # Python 3
+    from collections.abc import Iterable
+    from collections.abc import MutableMapping
+except ImportError:
+    # Python 2.7
+    from collections import Iterable
+    from collections import MutableMapping
+
+try:
+    from collections import OrderedDict as _OrderedDict
+except ImportError:
+    try:
+        from ordereddict import OrderedDict as _OrderedDict
+    except ImportError:
+        _OrderedDict = None
+
+#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )
+
+__all__ = [
+'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',
+'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',
+'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',
+'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',
+'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',
+'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 
+'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',
+'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',
+'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',
+'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums',
+'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno',
+'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',
+'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',
+'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity', 
+'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',
+'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',
+'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation','locatedExpr', 'withClass',
+'CloseMatch', 'tokenMap', 'pyparsing_common',
+]
+
+system_version = tuple(sys.version_info)[:3]
+PY_3 = system_version[0] == 3
+if PY_3:
+    _MAX_INT = sys.maxsize
+    basestring = str
+    unichr = chr
+    _ustr = str
+
+    # build list of single arg builtins, that can be used as parse actions
+    singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max]
+
+else:
+    _MAX_INT = sys.maxint
+    range = xrange
+
+    def _ustr(obj):
+        """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries
+           str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It
+           then < returns the unicode object | encodes it with the default encoding | ... >.
+        """
+        if isinstance(obj,unicode):
+            return obj
+
+        try:
+            # If this works, then _ustr(obj) has the same behaviour as str(obj), so
+            # it won't break any existing code.
+            return str(obj)
+
+        except UnicodeEncodeError:
+            # Else encode it
+            ret = unicode(obj).encode(sys.getdefaultencoding(), 'xmlcharrefreplace')
+            xmlcharref = Regex(r'&#\d+;')
+            xmlcharref.setParseAction(lambda t: '\\u' + hex(int(t[0][2:-1]))[2:])
+            return xmlcharref.transformString(ret)
+
+    # build list of single arg builtins, tolerant of Python version, that can be used as parse actions
+    singleArgBuiltins = []
+    import __builtin__
+    for fname in "sum len sorted reversed list tuple set any all min max".split():
+        try:
+            singleArgBuiltins.append(getattr(__builtin__,fname))
+        except AttributeError:
+            continue
+            
+_generatorType = type((y for y in range(1)))
+ 
+def _xml_escape(data):
+    """Escape &, <, >, ", ', etc. in a string of data."""
+
+    # ampersand must be replaced first
+    from_symbols = '&><"\''
+    to_symbols = ('&'+s+';' for s in "amp gt lt quot apos".split())
+    for from_,to_ in zip(from_symbols, to_symbols):
+        data = data.replace(from_, to_)
+    return data
+
+class _Constants(object):
+    pass
+
+alphas     = string.ascii_uppercase + string.ascii_lowercase
+nums       = "0123456789"
+hexnums    = nums + "ABCDEFabcdef"
+alphanums  = alphas + nums
+_bslash    = chr(92)
+printables = "".join(c for c in string.printable if c not in string.whitespace)
+
+class ParseBaseException(Exception):
+    """base exception class for all parsing runtime exceptions"""
+    # Performance tuning: we construct a *lot* of these, so keep this
+    # constructor as small and fast as possible
+    def __init__( self, pstr, loc=0, msg=None, elem=None ):
+        self.loc = loc
+        if msg is None:
+            self.msg = pstr
+            self.pstr = ""
+        else:
+            self.msg = msg
+            self.pstr = pstr
+        self.parserElement = elem
+        self.args = (pstr, loc, msg)
+
+    @classmethod
+    def _from_exception(cls, pe):
+        """
+        internal factory method to simplify creating one type of ParseException 
+        from another - avoids having __init__ signature conflicts among subclasses
+        """
+        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement)
+
+    def __getattr__( self, aname ):
+        """supported attributes by name are:
+            - lineno - returns the line number of the exception text
+            - col - returns the column number of the exception text
+            - line - returns the line containing the exception text
+        """
+        if( aname == "lineno" ):
+            return lineno( self.loc, self.pstr )
+        elif( aname in ("col", "column") ):
+            return col( self.loc, self.pstr )
+        elif( aname == "line" ):
+            return line( self.loc, self.pstr )
+        else:
+            raise AttributeError(aname)
+
+    def __str__( self ):
+        return "%s (at char %d), (line:%d, col:%d)" % \
+                ( self.msg, self.loc, self.lineno, self.column )
+    def __repr__( self ):
+        return _ustr(self)
+    def markInputline( self, markerString = ">!<" ):
+        """Extracts the exception line from the input string, and marks
+           the location of the exception with a special symbol.
+        """
+        line_str = self.line
+        line_column = self.column - 1
+        if markerString:
+            line_str = "".join((line_str[:line_column],
+                                markerString, line_str[line_column:]))
+        return line_str.strip()
+    def __dir__(self):
+        return "lineno col line".split() + dir(type(self))
+
+class ParseException(ParseBaseException):
+    """
+    Exception thrown when parse expressions don't match class;
+    supported attributes by name are:
+     - lineno - returns the line number of the exception text
+     - col - returns the column number of the exception text
+     - line - returns the line containing the exception text
+        
+    Example::
+        try:
+            Word(nums).setName("integer").parseString("ABC")
+        except ParseException as pe:
+            print(pe)
+            print("column: {}".format(pe.col))
+            
+    prints::
+       Expected integer (at char 0), (line:1, col:1)
+        column: 1
+    """
+    pass
+
+class ParseFatalException(ParseBaseException):
+    """user-throwable exception thrown when inconsistent parse content
+       is found; stops all parsing immediately"""
+    pass
+
+class ParseSyntaxException(ParseFatalException):
+    """just like L{ParseFatalException}, but thrown internally when an
+       L{ErrorStop<And._ErrorStop>} ('-' operator) indicates that parsing is to stop 
+       immediately because an unbacktrackable syntax error has been found"""
+    pass
+
+#~ class ReparseException(ParseBaseException):
+    #~ """Experimental class - parse actions can raise this exception to cause
+       #~ pyparsing to reparse the input string:
+        #~ - with a modified input string, and/or
+        #~ - with a modified start location
+       #~ Set the values of the ReparseException in the constructor, and raise the
+       #~ exception in a parse action to cause pyparsing to use the new string/location.
+       #~ Setting the values as None causes no change to be made.
+       #~ """
+    #~ def __init_( self, newstring, restartLoc ):
+        #~ self.newParseText = newstring
+        #~ self.reparseLoc = restartLoc
+
+class RecursiveGrammarException(Exception):
+    """exception thrown by L{ParserElement.validate} if the grammar could be improperly recursive"""
+    def __init__( self, parseElementList ):
+        self.parseElementTrace = parseElementList
+
+    def __str__( self ):
+        return "RecursiveGrammarException: %s" % self.parseElementTrace
+
+class _ParseResultsWithOffset(object):
+    def __init__(self,p1,p2):
+        self.tup = (p1,p2)
+    def __getitem__(self,i):
+        return self.tup[i]
+    def __repr__(self):
+        return repr(self.tup[0])
+    def setOffset(self,i):
+        self.tup = (self.tup[0],i)
+
+class ParseResults(object):
+    """
+    Structured parse results, to provide multiple means of access to the parsed data:
+       - as a list (C{len(results)})
+       - by list index (C{results[0], results[1]}, etc.)
+       - by attribute (C{results.<resultsName>} - see L{ParserElement.setResultsName})
+
+    Example::
+        integer = Word(nums)
+        date_str = (integer.setResultsName("year") + '/' 
+                        + integer.setResultsName("month") + '/' 
+                        + integer.setResultsName("day"))
+        # equivalent form:
+        # date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+        # parseString returns a ParseResults object
+        result = date_str.parseString("1999/12/31")
+
+        def test(s, fn=repr):
+            print("%s -> %s" % (s, fn(eval(s))))
+        test("list(result)")
+        test("result[0]")
+        test("result['month']")
+        test("result.day")
+        test("'month' in result")
+        test("'minutes' in result")
+        test("result.dump()", str)
+    prints::
+        list(result) -> ['1999', '/', '12', '/', '31']
+        result[0] -> '1999'
+        result['month'] -> '12'
+        result.day -> '31'
+        'month' in result -> True
+        'minutes' in result -> False
+        result.dump() -> ['1999', '/', '12', '/', '31']
+        - day: 31
+        - month: 12
+        - year: 1999
+    """
+    def __new__(cls, toklist=None, name=None, asList=True, modal=True ):
+        if isinstance(toklist, cls):
+            return toklist
+        retobj = object.__new__(cls)
+        retobj.__doinit = True
+        return retobj
+
+    # Performance tuning: we construct a *lot* of these, so keep this
+    # constructor as small and fast as possible
+    def __init__( self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance ):
+        if self.__doinit:
+            self.__doinit = False
+            self.__name = None
+            self.__parent = None
+            self.__accumNames = {}
+            self.__asList = asList
+            self.__modal = modal
+            if toklist is None:
+                toklist = []
+            if isinstance(toklist, list):
+                self.__toklist = toklist[:]
+            elif isinstance(toklist, _generatorType):
+                self.__toklist = list(toklist)
+            else:
+                self.__toklist = [toklist]
+            self.__tokdict = dict()
+
+        if name is not None and name:
+            if not modal:
+                self.__accumNames[name] = 0
+            if isinstance(name,int):
+                name = _ustr(name) # will always return a str, but use _ustr for consistency
+            self.__name = name
+            if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None,'',[])):
+                if isinstance(toklist,basestring):
+                    toklist = [ toklist ]
+                if asList:
+                    if isinstance(toklist,ParseResults):
+                        self[name] = _ParseResultsWithOffset(toklist.copy(),0)
+                    else:
+                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0)
+                    self[name].__name = name
+                else:
+                    try:
+                        self[name] = toklist[0]
+                    except (KeyError,TypeError,IndexError):
+                        self[name] = toklist
+
+    def __getitem__( self, i ):
+        if isinstance( i, (int,slice) ):
+            return self.__toklist[i]
+        else:
+            if i not in self.__accumNames:
+                return self.__tokdict[i][-1][0]
+            else:
+                return ParseResults([ v[0] for v in self.__tokdict[i] ])
+
+    def __setitem__( self, k, v, isinstance=isinstance ):
+        if isinstance(v,_ParseResultsWithOffset):
+            self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]
+            sub = v[0]
+        elif isinstance(k,(int,slice)):
+            self.__toklist[k] = v
+            sub = v
+        else:
+            self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)]
+            sub = v
+        if isinstance(sub,ParseResults):
+            sub.__parent = wkref(self)
+
+    def __delitem__( self, i ):
+        if isinstance(i,(int,slice)):
+            mylen = len( self.__toklist )
+            del self.__toklist[i]
+
+            # convert int to slice
+            if isinstance(i, int):
+                if i < 0:
+                    i += mylen
+                i = slice(i, i+1)
+            # get removed indices
+            removed = list(range(*i.indices(mylen)))
+            removed.reverse()
+            # fixup indices in token dictionary
+            for name,occurrences in self.__tokdict.items():
+                for j in removed:
+                    for k, (value, position) in enumerate(occurrences):
+                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))
+        else:
+            del self.__tokdict[i]
+
+    def __contains__( self, k ):
+        return k in self.__tokdict
+
+    def __len__( self ): return len( self.__toklist )
+    def __bool__(self): return ( not not self.__toklist )
+    __nonzero__ = __bool__
+    def __iter__( self ): return iter( self.__toklist )
+    def __reversed__( self ): return iter( self.__toklist[::-1] )
+    def _iterkeys( self ):
+        if hasattr(self.__tokdict, "iterkeys"):
+            return self.__tokdict.iterkeys()
+        else:
+            return iter(self.__tokdict)
+
+    def _itervalues( self ):
+        return (self[k] for k in self._iterkeys())
+            
+    def _iteritems( self ):
+        return ((k, self[k]) for k in self._iterkeys())
+
+    if PY_3:
+        keys = _iterkeys       
+        """Returns an iterator of all named result keys (Python 3.x only)."""
+
+        values = _itervalues
+        """Returns an iterator of all named result values (Python 3.x only)."""
+
+        items = _iteritems
+        """Returns an iterator of all named result key-value tuples (Python 3.x only)."""
+
+    else:
+        iterkeys = _iterkeys
+        """Returns an iterator of all named result keys (Python 2.x only)."""
+
+        itervalues = _itervalues
+        """Returns an iterator of all named result values (Python 2.x only)."""
+
+        iteritems = _iteritems
+        """Returns an iterator of all named result key-value tuples (Python 2.x only)."""
+
+        def keys( self ):
+            """Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.iterkeys())
+
+        def values( self ):
+            """Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.itervalues())
+                
+        def items( self ):
+            """Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.iteritems())
+
+    def haskeys( self ):
+        """Since keys() returns an iterator, this method is helpful in bypassing
+           code that looks for the existence of any defined results names."""
+        return bool(self.__tokdict)
+        
+    def pop( self, *args, **kwargs):
+        """
+        Removes and returns item at specified index (default=C{last}).
+        Supports both C{list} and C{dict} semantics for C{pop()}. If passed no
+        argument or an integer argument, it will use C{list} semantics
+        and pop tokens from the list of parsed tokens. If passed a 
+        non-integer argument (most likely a string), it will use C{dict}
+        semantics and pop the corresponding value from any defined 
+        results names. A second default return value argument is 
+        supported, just as in C{dict.pop()}.
+
+        Example::
+            def remove_first(tokens):
+                tokens.pop(0)
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']
+
+            label = Word(alphas)
+            patt = label("LABEL") + OneOrMore(Word(nums))
+            print(patt.parseString("AAB 123 321").dump())
+
+            # Use pop() in a parse action to remove named result (note that corresponding value is not
+            # removed from list form of results)
+            def remove_LABEL(tokens):
+                tokens.pop("LABEL")
+                return tokens
+            patt.addParseAction(remove_LABEL)
+            print(patt.parseString("AAB 123 321").dump())
+        prints::
+            ['AAB', '123', '321']
+            - LABEL: AAB
+
+            ['AAB', '123', '321']
+        """
+        if not args:
+            args = [-1]
+        for k,v in kwargs.items():
+            if k == 'default':
+                args = (args[0], v)
+            else:
+                raise TypeError("pop() got an unexpected keyword argument '%s'" % k)
+        if (isinstance(args[0], int) or 
+                        len(args) == 1 or 
+                        args[0] in self):
+            index = args[0]
+            ret = self[index]
+            del self[index]
+            return ret
+        else:
+            defaultvalue = args[1]
+            return defaultvalue
+
+    def get(self, key, defaultValue=None):
+        """
+        Returns named result matching the given key, or if there is no
+        such name, then returns the given C{defaultValue} or C{None} if no
+        C{defaultValue} is specified.
+
+        Similar to C{dict.get()}.
+        
+        Example::
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
+
+            result = date_str.parseString("1999/12/31")
+            print(result.get("year")) # -> '1999'
+            print(result.get("hour", "not specified")) # -> 'not specified'
+            print(result.get("hour")) # -> None
+        """
+        if key in self:
+            return self[key]
+        else:
+            return defaultValue
+
+    def insert( self, index, insStr ):
+        """
+        Inserts new element at location index in the list of parsed tokens.
+        
+        Similar to C{list.insert()}.
+
+        Example::
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+
+            # use a parse action to insert the parse location in the front of the parsed results
+            def insert_locn(locn, tokens):
+                tokens.insert(0, locn)
+            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321']
+        """
+        self.__toklist.insert(index, insStr)
+        # fixup indices in token dictionary
+        for name,occurrences in self.__tokdict.items():
+            for k, (value, position) in enumerate(occurrences):
+                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))
+
+    def append( self, item ):
+        """
+        Add single element to end of ParseResults list of elements.
+
+        Example::
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+            
+            # use a parse action to compute the sum of the parsed integers, and add it to the end
+            def append_sum(tokens):
+                tokens.append(sum(map(int, tokens)))
+            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444]
+        """
+        self.__toklist.append(item)
+
+    def extend( self, itemseq ):
+        """
+        Add sequence of elements to end of ParseResults list of elements.
+
+        Example::
+            patt = OneOrMore(Word(alphas))
+            
+            # use a parse action to append the reverse of the matched strings, to make a palindrome
+            def make_palindrome(tokens):
+                tokens.extend(reversed([t[::-1] for t in tokens]))
+                return ''.join(tokens)
+            print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
+        """
+        if isinstance(itemseq, ParseResults):
+            self += itemseq
+        else:
+            self.__toklist.extend(itemseq)
+
+    def clear( self ):
+        """
+        Clear all elements and results names.
+        """
+        del self.__toklist[:]
+        self.__tokdict.clear()
+
+    def __getattr__( self, name ):
+        try:
+            return self[name]
+        except KeyError:
+            return ""
+            
+        if name in self.__tokdict:
+            if name not in self.__accumNames:
+                return self.__tokdict[name][-1][0]
+            else:
+                return ParseResults([ v[0] for v in self.__tokdict[name] ])
+        else:
+            return ""
+
+    def __add__( self, other ):
+        ret = self.copy()
+        ret += other
+        return ret
+
+    def __iadd__( self, other ):
+        if other.__tokdict:
+            offset = len(self.__toklist)
+            addoffset = lambda a: offset if a<0 else a+offset
+            otheritems = other.__tokdict.items()
+            otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) )
+                                for (k,vlist) in otheritems for v in vlist]
+            for k,v in otherdictitems:
+                self[k] = v
+                if isinstance(v[0],ParseResults):
+                    v[0].__parent = wkref(self)
+            
+        self.__toklist += other.__toklist
+        self.__accumNames.update( other.__accumNames )
+        return self
+
+    def __radd__(self, other):
+        if isinstance(other,int) and other == 0:
+            # useful for merging many ParseResults using sum() builtin
+            return self.copy()
+        else:
+            # this may raise a TypeError - so be it
+            return other + self
+        
+    def __repr__( self ):
+        return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )
+
+    def __str__( self ):
+        return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']'
+
+    def _asStringList( self, sep='' ):
+        out = []
+        for item in self.__toklist:
+            if out and sep:
+                out.append(sep)
+            if isinstance( item, ParseResults ):
+                out += item._asStringList()
+            else:
+                out.append( _ustr(item) )
+        return out
+
+    def asList( self ):
+        """
+        Returns the parse results as a nested list of matching tokens, all converted to strings.
+
+        Example::
+            patt = OneOrMore(Word(alphas))
+            result = patt.parseString("sldkj lsdkj sldkj")
+            # even though the result prints in string-like form, it is actually a pyparsing ParseResults
+            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']
+            
+            # Use asList() to create an actual list
+            result_list = result.asList()
+            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']
+        """
+        return [res.asList() if isinstance(res,ParseResults) else res for res in self.__toklist]
+
+    def asDict( self ):
+        """
+        Returns the named parse results as a nested dictionary.
+
+        Example::
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+            
+            result = date_str.parseString('12/31/1999')
+            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
+            
+            result_dict = result.asDict()
+            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}
+
+            # even though a ParseResults supports dict-like access, sometime you just need to have a dict
+            import json
+            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
+            print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"}
+        """
+        if PY_3:
+            item_fn = self.items
+        else:
+            item_fn = self.iteritems
+            
+        def toItem(obj):
+            if isinstance(obj, ParseResults):
+                if obj.haskeys():
+                    return obj.asDict()
+                else:
+                    return [toItem(v) for v in obj]
+            else:
+                return obj
+                
+        return dict((k,toItem(v)) for k,v in item_fn())
+
+    def copy( self ):
+        """
+        Returns a new copy of a C{ParseResults} object.
+        """
+        ret = ParseResults( self.__toklist )
+        ret.__tokdict = self.__tokdict.copy()
+        ret.__parent = self.__parent
+        ret.__accumNames.update( self.__accumNames )
+        ret.__name = self.__name
+        return ret
+
+    def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):
+        """
+        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.
+        """
+        nl = "\n"
+        out = []
+        namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items()
+                                                            for v in vlist)
+        nextLevelIndent = indent + "  "
+
+        # collapse out indents if formatting is not desired
+        if not formatted:
+            indent = ""
+            nextLevelIndent = ""
+            nl = ""
+
+        selfTag = None
+        if doctag is not None:
+            selfTag = doctag
+        else:
+            if self.__name:
+                selfTag = self.__name
+
+        if not selfTag:
+            if namedItemsOnly:
+                return ""
+            else:
+                selfTag = "ITEM"
+
+        out += [ nl, indent, "<", selfTag, ">" ]
+
+        for i,res in enumerate(self.__toklist):
+            if isinstance(res,ParseResults):
+                if i in namedItems:
+                    out += [ res.asXML(namedItems[i],
+                                        namedItemsOnly and doctag is None,
+                                        nextLevelIndent,
+                                        formatted)]
+                else:
+                    out += [ res.asXML(None,
+                                        namedItemsOnly and doctag is None,
+                                        nextLevelIndent,
+                                        formatted)]
+            else:
+                # individual token, see if there is a name for it
+                resTag = None
+                if i in namedItems:
+                    resTag = namedItems[i]
+                if not resTag:
+                    if namedItemsOnly:
+                        continue
+                    else:
+                        resTag = "ITEM"
+                xmlBodyText = _xml_escape(_ustr(res))
+                out += [ nl, nextLevelIndent, "<", resTag, ">",
+                                                xmlBodyText,
+                                                "</", resTag, ">" ]
+
+        out += [ nl, indent, "</", selfTag, ">" ]
+        return "".join(out)
+
+    def __lookup(self,sub):
+        for k,vlist in self.__tokdict.items():
+            for v,loc in vlist:
+                if sub is v:
+                    return k
+        return None
+
+    def getName(self):
+        r"""
+        Returns the results name for this token expression. Useful when several 
+        different expressions might match at a particular location.
+
+        Example::
+            integer = Word(nums)
+            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
+            house_number_expr = Suppress('#') + Word(nums, alphanums)
+            user_data = (Group(house_number_expr)("house_number") 
+                        | Group(ssn_expr)("ssn")
+                        | Group(integer)("age"))
+            user_info = OneOrMore(user_data)
+            
+            result = user_info.parseString("22 111-22-3333 #221B")
+            for item in result:
+                print(item.getName(), ':', item[0])
+        prints::
+            age : 22
+            ssn : 111-22-3333
+            house_number : 221B
+        """
+        if self.__name:
+            return self.__name
+        elif self.__parent:
+            par = self.__parent()
+            if par:
+                return par.__lookup(self)
+            else:
+                return None
+        elif (len(self) == 1 and
+               len(self.__tokdict) == 1 and
+               next(iter(self.__tokdict.values()))[0][1] in (0,-1)):
+            return next(iter(self.__tokdict.keys()))
+        else:
+            return None
+
+    def dump(self, indent='', depth=0, full=True):
+        """
+        Diagnostic method for listing out the contents of a C{ParseResults}.
+        Accepts an optional C{indent} argument so that this string can be embedded
+        in a nested display of other data.
+
+        Example::
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+            
+            result = date_str.parseString('12/31/1999')
+            print(result.dump())
+        prints::
+            ['12', '/', '31', '/', '1999']
+            - day: 1999
+            - month: 31
+            - year: 12
+        """
+        out = []
+        NL = '\n'
+        out.append( indent+_ustr(self.asList()) )
+        if full:
+            if self.haskeys():
+                items = sorted((str(k), v) for k,v in self.items())
+                for k,v in items:
+                    if out:
+                        out.append(NL)
+                    out.append( "%s%s- %s: " % (indent,('  '*depth), k) )
+                    if isinstance(v,ParseResults):
+                        if v:
+                            out.append( v.dump(indent,depth+1) )
+                        else:
+                            out.append(_ustr(v))
+                    else:
+                        out.append(repr(v))
+            elif any(isinstance(vv,ParseResults) for vv in self):
+                v = self
+                for i,vv in enumerate(v):
+                    if isinstance(vv,ParseResults):
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),vv.dump(indent,depth+1) ))
+                    else:
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),_ustr(vv)))
+            
+        return "".join(out)
+
+    def pprint(self, *args, **kwargs):
+        """
+        Pretty-printer for parsed results as a list, using the C{pprint} module.
+        Accepts additional positional or keyword args as defined for the 
+        C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#pprint.pprint})
+
+        Example::
+            ident = Word(alphas, alphanums)
+            num = Word(nums)
+            func = Forward()
+            term = ident | num | Group('(' + func + ')')
+            func <<= ident + Group(Optional(delimitedList(term)))
+            result = func.parseString("fna a,b,(fnb c,d,200),100")
+            result.pprint(width=40)
+        prints::
+            ['fna',
+             ['a',
+              'b',
+              ['(', 'fnb', ['c', 'd', '200'], ')'],
+              '100']]
+        """
+        pprint.pprint(self.asList(), *args, **kwargs)
+
+    # add support for pickle protocol
+    def __getstate__(self):
+        return ( self.__toklist,
+                 ( self.__tokdict.copy(),
+                   self.__parent is not None and self.__parent() or None,
+                   self.__accumNames,
+                   self.__name ) )
+
+    def __setstate__(self,state):
+        self.__toklist = state[0]
+        (self.__tokdict,
+         par,
+         inAccumNames,
+         self.__name) = state[1]
+        self.__accumNames = {}
+        self.__accumNames.update(inAccumNames)
+        if par is not None:
+            self.__parent = wkref(par)
+        else:
+            self.__parent = None
+
+    def __getnewargs__(self):
+        return self.__toklist, self.__name, self.__asList, self.__modal
+
+    def __dir__(self):
+        return (dir(type(self)) + list(self.keys()))
+
+MutableMapping.register(ParseResults)
+
+def col (loc,strg):
+    """Returns current column within a string, counting newlines as line separators.
+   The first column is number 1.
+
+   Note: the default parsing behavior is to expand tabs in the input string
+   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
+   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
+   consistent view of the parsed string, the parse location, and line and column
+   positions within the parsed string.
+   """
+    s = strg
+    return 1 if 0<loc<len(s) and s[loc-1] == '\n' else loc - s.rfind("\n", 0, loc)
+
+def lineno(loc,strg):
+    """Returns current line number within a string, counting newlines as line separators.
+   The first line is number 1.
+
+   Note: the default parsing behavior is to expand tabs in the input string
+   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
+   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
+   consistent view of the parsed string, the parse location, and line and column
+   positions within the parsed string.
+   """
+    return strg.count("\n",0,loc) + 1
+
+def line( loc, strg ):
+    """Returns the line of text containing loc within a string, counting newlines as line separators.
+       """
+    lastCR = strg.rfind("\n", 0, loc)
+    nextCR = strg.find("\n", loc)
+    if nextCR >= 0:
+        return strg[lastCR+1:nextCR]
+    else:
+        return strg[lastCR+1:]
+
+def _defaultStartDebugAction( instring, loc, expr ):
+    print (("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )))
+
+def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):
+    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))
+
+def _defaultExceptionDebugAction( instring, loc, expr, exc ):
+    print ("Exception raised:" + _ustr(exc))
+
+def nullDebugAction(*args):
+    """'Do-nothing' debug action, to suppress debugging output during parsing."""
+    pass
+
+# Only works on Python 3.x - nonlocal is toxic to Python 2 installs
+#~ 'decorator to trim function calls to match the arity of the target'
+#~ def _trim_arity(func, maxargs=3):
+    #~ if func in singleArgBuiltins:
+        #~ return lambda s,l,t: func(t)
+    #~ limit = 0
+    #~ foundArity = False
+    #~ def wrapper(*args):
+        #~ nonlocal limit,foundArity
+        #~ while 1:
+            #~ try:
+                #~ ret = func(*args[limit:])
+                #~ foundArity = True
+                #~ return ret
+            #~ except TypeError:
+                #~ if limit == maxargs or foundArity:
+                    #~ raise
+                #~ limit += 1
+                #~ continue
+    #~ return wrapper
+
+# this version is Python 2.x-3.x cross-compatible
+'decorator to trim function calls to match the arity of the target'
+def _trim_arity(func, maxargs=2):
+    if func in singleArgBuiltins:
+        return lambda s,l,t: func(t)
+    limit = [0]
+    foundArity = [False]
+    
+    # traceback return data structure changed in Py3.5 - normalize back to plain tuples
+    if system_version[:2] >= (3,5):
+        def extract_stack(limit=0):
+            # special handling for Python 3.5.0 - extra deep call stack by 1
+            offset = -3 if system_version == (3,5,0) else -2
+            frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset]
+            return [frame_summary[:2]]
+        def extract_tb(tb, limit=0):
+            frames = traceback.extract_tb(tb, limit=limit)
+            frame_summary = frames[-1]
+            return [frame_summary[:2]]
+    else:
+        extract_stack = traceback.extract_stack
+        extract_tb = traceback.extract_tb
+    
+    # synthesize what would be returned by traceback.extract_stack at the call to 
+    # user's parse action 'func', so that we don't incur call penalty at parse time
+    
+    LINE_DIFF = 6
+    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND 
+    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!!
+    this_line = extract_stack(limit=2)[-1]
+    pa_call_line_synth = (this_line[0], this_line[1]+LINE_DIFF)
+
+    def wrapper(*args):
+        while 1:
+            try:
+                ret = func(*args[limit[0]:])
+                foundArity[0] = True
+                return ret
+            except TypeError:
+                # re-raise TypeErrors if they did not come from our arity testing
+                if foundArity[0]:
+                    raise
+                else:
+                    try:
+                        tb = sys.exc_info()[-1]
+                        if not extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth:
+                            raise
+                    finally:
+                        del tb
+
+                if limit[0] <= maxargs:
+                    limit[0] += 1
+                    continue
+                raise
+
+    # copy func name to wrapper for sensible debug output
+    func_name = "<parse action>"
+    try:
+        func_name = getattr(func, '__name__', 
+                            getattr(func, '__class__').__name__)
+    except Exception:
+        func_name = str(func)
+    wrapper.__name__ = func_name
+
+    return wrapper
+
+class ParserElement(object):
+    """Abstract base level parser element class."""
+    DEFAULT_WHITE_CHARS = " \n\t\r"
+    verbose_stacktrace = False
+
+    @staticmethod
+    def setDefaultWhitespaceChars( chars ):
+        r"""
+        Overrides the default whitespace chars
+
+        Example::
+            # default whitespace chars are space, <TAB> and newline
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl']
+            
+            # change to just treat newline as significant
+            ParserElement.setDefaultWhitespaceChars(" \t")
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def']
+        """
+        ParserElement.DEFAULT_WHITE_CHARS = chars
+
+    @staticmethod
+    def inlineLiteralsUsing(cls):
+        """
+        Set class to be used for inclusion of string literals into a parser.
+        
+        Example::
+            # default literal class used is Literal
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']
+
+
+            # change to Suppress
+            ParserElement.inlineLiteralsUsing(Suppress)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '12', '31']
+        """
+        ParserElement._literalStringClass = cls
+
+    def __init__( self, savelist=False ):
+        self.parseAction = list()
+        self.failAction = None
+        #~ self.name = "<unknown>"  # don't define self.name, let subclasses try/except upcall
+        self.strRepr = None
+        self.resultsName = None
+        self.saveAsList = savelist
+        self.skipWhitespace = True
+        self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
+        self.copyDefaultWhiteChars = True
+        self.mayReturnEmpty = False # used when checking for left-recursion
+        self.keepTabs = False
+        self.ignoreExprs = list()
+        self.debug = False
+        self.streamlined = False
+        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index
+        self.errmsg = ""
+        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)
+        self.debugActions = ( None, None, None ) #custom debug actions
+        self.re = None
+        self.callPreparse = True # used to avoid redundant calls to preParse
+        self.callDuringTry = False
+
+    def copy( self ):
+        """
+        Make a copy of this C{ParserElement}.  Useful for defining different parse actions
+        for the same parsing pattern, using copies of the original parse element.
+        
+        Example::
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K")
+            integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
+            
+            print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))
+        prints::
+            [5120, 100, 655360, 268435456]
+        Equivalent form of C{expr.copy()} is just C{expr()}::
+            integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
+        """
+        cpy = copy.copy( self )
+        cpy.parseAction = self.parseAction[:]
+        cpy.ignoreExprs = self.ignoreExprs[:]
+        if self.copyDefaultWhiteChars:
+            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
+        return cpy
+
+    def setName( self, name ):
+        """
+        Define name for this expression, makes debugging and exception messages clearer.
+        
+        Example::
+            Word(nums).parseString("ABC")  # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)
+            Word(nums).setName("integer").parseString("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1)
+        """
+        self.name = name
+        self.errmsg = "Expected " + self.name
+        if hasattr(self,"exception"):
+            self.exception.msg = self.errmsg
+        return self
+
+    def setResultsName( self, name, listAllMatches=False ):
+        """
+        Define name for referencing matching tokens as a nested attribute
+        of the returned parse results.
+        NOTE: this returns a *copy* of the original C{ParserElement} object;
+        this is so that the client can define a basic element, such as an
+        integer, and reference it in multiple places with different names.
+
+        You can also set results names using the abbreviated syntax,
+        C{expr("name")} in place of C{expr.setResultsName("name")} - 
+        see L{I{__call__}<__call__>}.
+
+        Example::
+            date_str = (integer.setResultsName("year") + '/' 
+                        + integer.setResultsName("month") + '/' 
+                        + integer.setResultsName("day"))
+
+            # equivalent form:
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+        """
+        newself = self.copy()
+        if name.endswith("*"):
+            name = name[:-1]
+            listAllMatches=True
+        newself.resultsName = name
+        newself.modalResults = not listAllMatches
+        return newself
+
+    def setBreak(self,breakFlag = True):
+        """Method to invoke the Python pdb debugger when this element is
+           about to be parsed. Set C{breakFlag} to True to enable, False to
+           disable.
+        """
+        if breakFlag:
+            _parseMethod = self._parse
+            def breaker(instring, loc, doActions=True, callPreParse=True):
+                import pdb
+                pdb.set_trace()
+                return _parseMethod( instring, loc, doActions, callPreParse )
+            breaker._originalParseMethod = _parseMethod
+            self._parse = breaker
+        else:
+            if hasattr(self._parse,"_originalParseMethod"):
+                self._parse = self._parse._originalParseMethod
+        return self
+
+    def setParseAction( self, *fns, **kwargs ):
+        """
+        Define one or more actions to perform when successfully matching parse element definition.
+        Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)},
+        C{fn(loc,toks)}, C{fn(toks)}, or just C{fn()}, where:
+         - s   = the original string being parsed (see note below)
+         - loc = the location of the matching substring
+         - toks = a list of the matched tokens, packaged as a C{L{ParseResults}} object
+        If the functions in fns modify the tokens, they can return them as the return
+        value from fn, and the modified list of tokens will replace the original.
+        Otherwise, fn does not need to return any value.
+
+        Optional keyword arguments:
+         - callDuringTry = (default=C{False}) indicate if parse action should be run during lookaheads and alternate testing
+
+        Note: the default parsing behavior is to expand tabs in the input string
+        before starting the parsing process.  See L{I{parseString}<parseString>} for more information
+        on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
+        consistent view of the parsed string, the parse location, and line and column
+        positions within the parsed string.
+        
+        Example::
+            integer = Word(nums)
+            date_str = integer + '/' + integer + '/' + integer
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']
+
+            # use parse action to convert to ints at parse time
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            date_str = integer + '/' + integer + '/' + integer
+
+            # note that integer fields are now ints, not strings
+            date_str.parseString("1999/12/31")  # -> [1999, '/', 12, '/', 31]
+        """
+        self.parseAction = list(map(_trim_arity, list(fns)))
+        self.callDuringTry = kwargs.get("callDuringTry", False)
+        return self
+
+    def addParseAction( self, *fns, **kwargs ):
+        """
+        Add one or more parse actions to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}.
+        
+        See examples in L{I{copy}<copy>}.
+        """
+        self.parseAction += list(map(_trim_arity, list(fns)))
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
+        return self
+
+    def addCondition(self, *fns, **kwargs):
+        """Add a boolean predicate function to expression's list of parse actions. See 
+        L{I{setParseAction}<setParseAction>} for function call signatures. Unlike C{setParseAction}, 
+        functions passed to C{addCondition} need to return boolean success/fail of the condition.
+
+        Optional keyword arguments:
+         - message = define a custom message to be used in the raised exception
+         - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException
+         
+        Example::
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            year_int = integer.copy()
+            year_int.addCondition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later")
+            date_str = year_int + '/' + integer + '/' + integer
+
+            result = date_str.parseString("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1)
+        """
+        msg = kwargs.get("message", "failed user-defined condition")
+        exc_type = ParseFatalException if kwargs.get("fatal", False) else ParseException
+        for fn in fns:
+            def pa(s,l,t):
+                if not bool(_trim_arity(fn)(s,l,t)):
+                    raise exc_type(s,l,msg)
+            self.parseAction.append(pa)
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
+        return self
+
+    def setFailAction( self, fn ):
+        """Define action to perform if parsing fails at this expression.
+           Fail acton fn is a callable function that takes the arguments
+           C{fn(s,loc,expr,err)} where:
+            - s = string being parsed
+            - loc = location where expression match was attempted and failed
+            - expr = the parse expression that failed
+            - err = the exception thrown
+           The function returns no value.  It may throw C{L{ParseFatalException}}
+           if it is desired to stop parsing immediately."""
+        self.failAction = fn
+        return self
+
+    def _skipIgnorables( self, instring, loc ):
+        exprsFound = True
+        while exprsFound:
+            exprsFound = False
+            for e in self.ignoreExprs:
+                try:
+                    while 1:
+                        loc,dummy = e._parse( instring, loc )
+                        exprsFound = True
+                except ParseException:
+                    pass
+        return loc
+
+    def preParse( self, instring, loc ):
+        if self.ignoreExprs:
+            loc = self._skipIgnorables( instring, loc )
+
+        if self.skipWhitespace:
+            wt = self.whiteChars
+            instrlen = len(instring)
+            while loc < instrlen and instring[loc] in wt:
+                loc += 1
+
+        return loc
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        return loc, []
+
+    def postParse( self, instring, loc, tokenlist ):
+        return tokenlist
+
+    #~ @profile
+    def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):
+        debugging = ( self.debug ) #and doActions )
+
+        if debugging or self.failAction:
+            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
+            if (self.debugActions[0] ):
+                self.debugActions[0]( instring, loc, self )
+            if callPreParse and self.callPreparse:
+                preloc = self.preParse( instring, loc )
+            else:
+                preloc = loc
+            tokensStart = preloc
+            try:
+                try:
+                    loc,tokens = self.parseImpl( instring, preloc, doActions )
+                except IndexError:
+                    raise ParseException( instring, len(instring), self.errmsg, self )
+            except ParseBaseException as err:
+                #~ print ("Exception raised:", err)
+                if self.debugActions[2]:
+                    self.debugActions[2]( instring, tokensStart, self, err )
+                if self.failAction:
+                    self.failAction( instring, tokensStart, self, err )
+                raise
+        else:
+            if callPreParse and self.callPreparse:
+                preloc = self.preParse( instring, loc )
+            else:
+                preloc = loc
+            tokensStart = preloc
+            if self.mayIndexError or preloc >= len(instring):
+                try:
+                    loc,tokens = self.parseImpl( instring, preloc, doActions )
+                except IndexError:
+                    raise ParseException( instring, len(instring), self.errmsg, self )
+            else:
+                loc,tokens = self.parseImpl( instring, preloc, doActions )
+
+        tokens = self.postParse( instring, loc, tokens )
+
+        retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )
+        if self.parseAction and (doActions or self.callDuringTry):
+            if debugging:
+                try:
+                    for fn in self.parseAction:
+                        tokens = fn( instring, tokensStart, retTokens )
+                        if tokens is not None:
+                            retTokens = ParseResults( tokens,
+                                                      self.resultsName,
+                                                      asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
+                                                      modal=self.modalResults )
+                except ParseBaseException as err:
+                    #~ print "Exception raised in user parse action:", err
+                    if (self.debugActions[2] ):
+                        self.debugActions[2]( instring, tokensStart, self, err )
+                    raise
+            else:
+                for fn in self.parseAction:
+                    tokens = fn( instring, tokensStart, retTokens )
+                    if tokens is not None:
+                        retTokens = ParseResults( tokens,
+                                                  self.resultsName,
+                                                  asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
+                                                  modal=self.modalResults )
+        if debugging:
+            #~ print ("Matched",self,"->",retTokens.asList())
+            if (self.debugActions[1] ):
+                self.debugActions[1]( instring, tokensStart, loc, self, retTokens )
+
+        return loc, retTokens
+
+    def tryParse( self, instring, loc ):
+        try:
+            return self._parse( instring, loc, doActions=False )[0]
+        except ParseFatalException:
+            raise ParseException( instring, loc, self.errmsg, self)
+    
+    def canParseNext(self, instring, loc):
+        try:
+            self.tryParse(instring, loc)
+        except (ParseException, IndexError):
+            return False
+        else:
+            return True
+
+    class _UnboundedCache(object):
+        def __init__(self):
+            cache = {}
+            self.not_in_cache = not_in_cache = object()
+
+            def get(self, key):
+                return cache.get(key, not_in_cache)
+
+            def set(self, key, value):
+                cache[key] = value
+
+            def clear(self):
+                cache.clear()
+                
+            def cache_len(self):
+                return len(cache)
+
+            self.get = types.MethodType(get, self)
+            self.set = types.MethodType(set, self)
+            self.clear = types.MethodType(clear, self)
+            self.__len__ = types.MethodType(cache_len, self)
+
+    if _OrderedDict is not None:
+        class _FifoCache(object):
+            def __init__(self, size):
+                self.not_in_cache = not_in_cache = object()
+
+                cache = _OrderedDict()
+
+                def get(self, key):
+                    return cache.get(key, not_in_cache)
+
+                def set(self, key, value):
+                    cache[key] = value
+                    while len(cache) > size:
+                        try:
+                            cache.popitem(False)
+                        except KeyError:
+                            pass
+
+                def clear(self):
+                    cache.clear()
+
+                def cache_len(self):
+                    return len(cache)
+
+                self.get = types.MethodType(get, self)
+                self.set = types.MethodType(set, self)
+                self.clear = types.MethodType(clear, self)
+                self.__len__ = types.MethodType(cache_len, self)
+
+    else:
+        class _FifoCache(object):
+            def __init__(self, size):
+                self.not_in_cache = not_in_cache = object()
+
+                cache = {}
+                key_fifo = collections.deque([], size)
+
+                def get(self, key):
+                    return cache.get(key, not_in_cache)
+
+                def set(self, key, value):
+                    cache[key] = value
+                    while len(key_fifo) > size:
+                        cache.pop(key_fifo.popleft(), None)
+                    key_fifo.append(key)
+
+                def clear(self):
+                    cache.clear()
+                    key_fifo.clear()
+
+                def cache_len(self):
+                    return len(cache)
+
+                self.get = types.MethodType(get, self)
+                self.set = types.MethodType(set, self)
+                self.clear = types.MethodType(clear, self)
+                self.__len__ = types.MethodType(cache_len, self)
+
+    # argument cache for optimizing repeated calls when backtracking through recursive expressions
+    packrat_cache = {} # this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail
+    packrat_cache_lock = RLock()
+    packrat_cache_stats = [0, 0]
+
+    # this method gets repeatedly called during backtracking with the same arguments -
+    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression
+    def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):
+        HIT, MISS = 0, 1
+        lookup = (self, instring, loc, callPreParse, doActions)
+        with ParserElement.packrat_cache_lock:
+            cache = ParserElement.packrat_cache
+            value = cache.get(lookup)
+            if value is cache.not_in_cache:
+                ParserElement.packrat_cache_stats[MISS] += 1
+                try:
+                    value = self._parseNoCache(instring, loc, doActions, callPreParse)
+                except ParseBaseException as pe:
+                    # cache a copy of the exception, without the traceback
+                    cache.set(lookup, pe.__class__(*pe.args))
+                    raise
+                else:
+                    cache.set(lookup, (value[0], value[1].copy()))
+                    return value
+            else:
+                ParserElement.packrat_cache_stats[HIT] += 1
+                if isinstance(value, Exception):
+                    raise value
+                return (value[0], value[1].copy())
+
+    _parse = _parseNoCache
+
+    @staticmethod
+    def resetCache():
+        ParserElement.packrat_cache.clear()
+        ParserElement.packrat_cache_stats[:] = [0] * len(ParserElement.packrat_cache_stats)
+
+    _packratEnabled = False
+    @staticmethod
+    def enablePackrat(cache_size_limit=128):
+        """Enables "packrat" parsing, which adds memoizing to the parsing logic.
+           Repeated parse attempts at the same string location (which happens
+           often in many complex grammars) can immediately return a cached value,
+           instead of re-executing parsing/validating code.  Memoizing is done of
+           both valid results and parsing exceptions.
+           
+           Parameters:
+            - cache_size_limit - (default=C{128}) - if an integer value is provided
+              will limit the size of the packrat cache; if None is passed, then
+              the cache size will be unbounded; if 0 is passed, the cache will
+              be effectively disabled.
+            
+           This speedup may break existing programs that use parse actions that
+           have side-effects.  For this reason, packrat parsing is disabled when
+           you first import pyparsing.  To activate the packrat feature, your
+           program must call the class method C{ParserElement.enablePackrat()}.  If
+           your program uses C{psyco} to "compile as you go", you must call
+           C{enablePackrat} before calling C{psyco.full()}.  If you do not do this,
+           Python will crash.  For best results, call C{enablePackrat()} immediately
+           after importing pyparsing.
+           
+           Example::
+               import pyparsing
+               pyparsing.ParserElement.enablePackrat()
+        """
+        if not ParserElement._packratEnabled:
+            ParserElement._packratEnabled = True
+            if cache_size_limit is None:
+                ParserElement.packrat_cache = ParserElement._UnboundedCache()
+            else:
+                ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit)
+            ParserElement._parse = ParserElement._parseCache
+
+    def parseString( self, instring, parseAll=False ):
+        """
+        Execute the parse expression with the given string.
+        This is the main interface to the client code, once the complete
+        expression has been built.
+
+        If you want the grammar to require that the entire input string be
+        successfully parsed, then set C{parseAll} to True (equivalent to ending
+        the grammar with C{L{StringEnd()}}).
+
+        Note: C{parseString} implicitly calls C{expandtabs()} on the input string,
+        in order to report proper column numbers in parse actions.
+        If the input string contains tabs and
+        the grammar uses parse actions that use the C{loc} argument to index into the
+        string being parsed, you can ensure you have a consistent view of the input
+        string by:
+         - calling C{parseWithTabs} on your grammar before calling C{parseString}
+           (see L{I{parseWithTabs}<parseWithTabs>})
+         - define your parse action using the full C{(s,loc,toks)} signature, and
+           reference the input string using the parse action's C{s} argument
+         - explictly expand the tabs in your input string before calling
+           C{parseString}
+        
+        Example::
+            Word('a').parseString('aaaaabaaa')  # -> ['aaaaa']
+            Word('a').parseString('aaaaabaaa', parseAll=True)  # -> Exception: Expected end of text
+        """
+        ParserElement.resetCache()
+        if not self.streamlined:
+            self.streamline()
+            #~ self.saveAsList = True
+        for e in self.ignoreExprs:
+            e.streamline()
+        if not self.keepTabs:
+            instring = instring.expandtabs()
+        try:
+            loc, tokens = self._parse( instring, 0 )
+            if parseAll:
+                loc = self.preParse( instring, loc )
+                se = Empty() + StringEnd()
+                se._parse( instring, loc )
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+        else:
+            return tokens
+
+    def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ):
+        """
+        Scan the input string for expression matches.  Each match will return the
+        matching tokens, start location, and end location.  May be called with optional
+        C{maxMatches} argument, to clip scanning after 'n' matches are found.  If
+        C{overlap} is specified, then overlapping matches will be reported.
+
+        Note that the start and end locations are reported relative to the string
+        being parsed.  See L{I{parseString}<parseString>} for more information on parsing
+        strings with embedded tabs.
+
+        Example::
+            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987"
+            print(source)
+            for tokens,start,end in Word(alphas).scanString(source):
+                print(' '*start + '^'*(end-start))
+                print(' '*start + tokens[0])
+        
+        prints::
+        
+            sldjf123lsdjjkf345sldkjf879lkjsfd987
+            ^^^^^
+            sldjf
+                    ^^^^^^^
+                    lsdjjkf
+                              ^^^^^^
+                              sldkjf
+                                       ^^^^^^
+                                       lkjsfd
+        """
+        if not self.streamlined:
+            self.streamline()
+        for e in self.ignoreExprs:
+            e.streamline()
+
+        if not self.keepTabs:
+            instring = _ustr(instring).expandtabs()
+        instrlen = len(instring)
+        loc = 0
+        preparseFn = self.preParse
+        parseFn = self._parse
+        ParserElement.resetCache()
+        matches = 0
+        try:
+            while loc <= instrlen and matches < maxMatches:
+                try:
+                    preloc = preparseFn( instring, loc )
+                    nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )
+                except ParseException:
+                    loc = preloc+1
+                else:
+                    if nextLoc > loc:
+                        matches += 1
+                        yield tokens, preloc, nextLoc
+                        if overlap:
+                            nextloc = preparseFn( instring, loc )
+                            if nextloc > loc:
+                                loc = nextLoc
+                            else:
+                                loc += 1
+                        else:
+                            loc = nextLoc
+                    else:
+                        loc = preloc+1
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def transformString( self, instring ):
+        """
+        Extension to C{L{scanString}}, to modify matching text with modified tokens that may
+        be returned from a parse action.  To use C{transformString}, define a grammar and
+        attach a parse action to it that modifies the returned token list.
+        Invoking C{transformString()} on a target string will then scan for matches,
+        and replace the matched text patterns according to the logic in the parse
+        action.  C{transformString()} returns the resulting transformed string.
+        
+        Example::
+            wd = Word(alphas)
+            wd.setParseAction(lambda toks: toks[0].title())
+            
+            print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york."))
+        Prints::
+            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York.
+        """
+        out = []
+        lastE = 0
+        # force preservation of <TAB>s, to minimize unwanted transformation of string, and to
+        # keep string locs straight between transformString and scanString
+        self.keepTabs = True
+        try:
+            for t,s,e in self.scanString( instring ):
+                out.append( instring[lastE:s] )
+                if t:
+                    if isinstance(t,ParseResults):
+                        out += t.asList()
+                    elif isinstance(t,list):
+                        out += t
+                    else:
+                        out.append(t)
+                lastE = e
+            out.append(instring[lastE:])
+            out = [o for o in out if o]
+            return "".join(map(_ustr,_flatten(out)))
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def searchString( self, instring, maxMatches=_MAX_INT ):
+        """
+        Another extension to C{L{scanString}}, simplifying the access to the tokens found
+        to match the given parse expression.  May be called with optional
+        C{maxMatches} argument, to clip searching after 'n' matches are found.
+        
+        Example::
+            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters
+            cap_word = Word(alphas.upper(), alphas.lower())
+            
+            print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))
+
+            # the sum() builtin can be used to merge results into a single ParseResults object
+            print(sum(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity")))
+        prints::
+            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']]
+            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity']
+        """
+        try:
+            return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False):
+        """
+        Generator method to split a string using the given expression as a separator.
+        May be called with optional C{maxsplit} argument, to limit the number of splits;
+        and the optional C{includeSeparators} argument (default=C{False}), if the separating
+        matching text should be included in the split results.
+        
+        Example::        
+            punc = oneOf(list(".,;:/-!?"))
+            print(list(punc.split("This, this?, this sentence, is badly punctuated!")))
+        prints::
+            ['This', ' this', '', ' this sentence', ' is badly punctuated', '']
+        """
+        splits = 0
+        last = 0
+        for t,s,e in self.scanString(instring, maxMatches=maxsplit):
+            yield instring[last:s]
+            if includeSeparators:
+                yield t[0]
+            last = e
+        yield instring[last:]
+
+    def __add__(self, other ):
+        """
+        Implementation of + operator - returns C{L{And}}. Adding strings to a ParserElement
+        converts them to L{Literal}s by default.
+        
+        Example::
+            greet = Word(alphas) + "," + Word(alphas) + "!"
+            hello = "Hello, World!"
+            print (hello, "->", greet.parseString(hello))
+        Prints::
+            Hello, World! -> ['Hello', ',', 'World', '!']
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return And( [ self, other ] )
+
+    def __radd__(self, other ):
+        """
+        Implementation of + operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other + self
+
+    def __sub__(self, other):
+        """
+        Implementation of - operator, returns C{L{And}} with error stop
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return self + And._ErrorStop() + other
+
+    def __rsub__(self, other ):
+        """
+        Implementation of - operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other - self
+
+    def __mul__(self,other):
+        """
+        Implementation of * operator, allows use of C{expr * 3} in place of
+        C{expr + expr + expr}.  Expressions may also me multiplied by a 2-integer
+        tuple, similar to C{{min,max}} multipliers in regular expressions.  Tuples
+        may also include C{None} as in:
+         - C{expr*(n,None)} or C{expr*(n,)} is equivalent
+              to C{expr*n + L{ZeroOrMore}(expr)}
+              (read as "at least n instances of C{expr}")
+         - C{expr*(None,n)} is equivalent to C{expr*(0,n)}
+              (read as "0 to n instances of C{expr}")
+         - C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)}
+         - C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)}
+
+        Note that C{expr*(None,n)} does not raise an exception if
+        more than n exprs exist in the input stream; that is,
+        C{expr*(None,n)} does not enforce a maximum number of expr
+        occurrences.  If this behavior is desired, then write
+        C{expr*(None,n) + ~expr}
+        """
+        if isinstance(other,int):
+            minElements, optElements = other,0
+        elif isinstance(other,tuple):
+            other = (other + (None, None))[:2]
+            if other[0] is None:
+                other = (0, other[1])
+            if isinstance(other[0],int) and other[1] is None:
+                if other[0] == 0:
+                    return ZeroOrMore(self)
+                if other[0] == 1:
+                    return OneOrMore(self)
+                else:
+                    return self*other[0] + ZeroOrMore(self)
+            elif isinstance(other[0],int) and isinstance(other[1],int):
+                minElements, optElements = other
+                optElements -= minElements
+            else:
+                raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1]))
+        else:
+            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))
+
+        if minElements < 0:
+            raise ValueError("cannot multiply ParserElement by negative value")
+        if optElements < 0:
+            raise ValueError("second tuple value must be greater or equal to first tuple value")
+        if minElements == optElements == 0:
+            raise ValueError("cannot multiply ParserElement by 0 or (0,0)")
+
+        if (optElements):
+            def makeOptionalList(n):
+                if n>1:
+                    return Optional(self + makeOptionalList(n-1))
+                else:
+                    return Optional(self)
+            if minElements:
+                if minElements == 1:
+                    ret = self + makeOptionalList(optElements)
+                else:
+                    ret = And([self]*minElements) + makeOptionalList(optElements)
+            else:
+                ret = makeOptionalList(optElements)
+        else:
+            if minElements == 1:
+                ret = self
+            else:
+                ret = And([self]*minElements)
+        return ret
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __or__(self, other ):
+        """
+        Implementation of | operator - returns C{L{MatchFirst}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return MatchFirst( [ self, other ] )
+
+    def __ror__(self, other ):
+        """
+        Implementation of | operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other | self
+
+    def __xor__(self, other ):
+        """
+        Implementation of ^ operator - returns C{L{Or}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return Or( [ self, other ] )
+
+    def __rxor__(self, other ):
+        """
+        Implementation of ^ operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other ^ self
+
+    def __and__(self, other ):
+        """
+        Implementation of & operator - returns C{L{Each}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return Each( [ self, other ] )
+
+    def __rand__(self, other ):
+        """
+        Implementation of & operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other & self
+
+    def __invert__( self ):
+        """
+        Implementation of ~ operator - returns C{L{NotAny}}
+        """
+        return NotAny( self )
+
+    def __call__(self, name=None):
+        """
+        Shortcut for C{L{setResultsName}}, with C{listAllMatches=False}.
+        
+        If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be
+        passed as C{True}.
+           
+        If C{name} is omitted, same as calling C{L{copy}}.
+
+        Example::
+            # these are equivalent
+            userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")
+            userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")             
+        """
+        if name is not None:
+            return self.setResultsName(name)
+        else:
+            return self.copy()
+
+    def suppress( self ):
+        """
+        Suppresses the output of this C{ParserElement}; useful to keep punctuation from
+        cluttering up returned output.
+        """
+        return Suppress( self )
+
+    def leaveWhitespace( self ):
+        """
+        Disables the skipping of whitespace before matching the characters in the
+        C{ParserElement}'s defined pattern.  This is normally only used internally by
+        the pyparsing module, but may be needed in some whitespace-sensitive grammars.
+        """
+        self.skipWhitespace = False
+        return self
+
+    def setWhitespaceChars( self, chars ):
+        """
+        Overrides the default whitespace chars
+        """
+        self.skipWhitespace = True
+        self.whiteChars = chars
+        self.copyDefaultWhiteChars = False
+        return self
+
+    def parseWithTabs( self ):
+        """
+        Overrides default behavior to expand C{<TAB>}s to spaces before parsing the input string.
+        Must be called before C{parseString} when the input grammar contains elements that
+        match C{<TAB>} characters.
+        """
+        self.keepTabs = True
+        return self
+
+    def ignore( self, other ):
+        """
+        Define expression to be ignored (e.g., comments) while doing pattern
+        matching; may be called repeatedly, to define multiple comment or other
+        ignorable patterns.
+        
+        Example::
+            patt = OneOrMore(Word(alphas))
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj']
+            
+            patt.ignore(cStyleComment)
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd']
+        """
+        if isinstance(other, basestring):
+            other = Suppress(other)
+
+        if isinstance( other, Suppress ):
+            if other not in self.ignoreExprs:
+                self.ignoreExprs.append(other)
+        else:
+            self.ignoreExprs.append( Suppress( other.copy() ) )
+        return self
+
+    def setDebugActions( self, startAction, successAction, exceptionAction ):
+        """
+        Enable display of debugging messages while doing pattern matching.
+        """
+        self.debugActions = (startAction or _defaultStartDebugAction,
+                             successAction or _defaultSuccessDebugAction,
+                             exceptionAction or _defaultExceptionDebugAction)
+        self.debug = True
+        return self
+
+    def setDebug( self, flag=True ):
+        """
+        Enable display of debugging messages while doing pattern matching.
+        Set C{flag} to True to enable, False to disable.
+
+        Example::
+            wd = Word(alphas).setName("alphaword")
+            integer = Word(nums).setName("numword")
+            term = wd | integer
+            
+            # turn on debugging for wd
+            wd.setDebug()
+
+            OneOrMore(term).parseString("abc 123 xyz 890")
+        
+        prints::
+            Match alphaword at loc 0(1,1)
+            Matched alphaword -> ['abc']
+            Match alphaword at loc 3(1,4)
+            Exception raised:Expected alphaword (at char 4), (line:1, col:5)
+            Match alphaword at loc 7(1,8)
+            Matched alphaword -> ['xyz']
+            Match alphaword at loc 11(1,12)
+            Exception raised:Expected alphaword (at char 12), (line:1, col:13)
+            Match alphaword at loc 15(1,16)
+            Exception raised:Expected alphaword (at char 15), (line:1, col:16)
+
+        The output shown is that produced by the default debug actions - custom debug actions can be
+        specified using L{setDebugActions}. Prior to attempting
+        to match the C{wd} expression, the debugging message C{"Match <exprname> at loc <n>(<line>,<col>)"}
+        is shown. Then if the parse succeeds, a C{"Matched"} message is shown, or an C{"Exception raised"}
+        message is shown. Also note the use of L{setName} to assign a human-readable name to the expression,
+        which makes debugging and exception messages easier to understand - for instance, the default
+        name created for the C{Word} expression without calling C{setName} is C{"W:(ABCD...)"}.
+        """
+        if flag:
+            self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )
+        else:
+            self.debug = False
+        return self
+
+    def __str__( self ):
+        return self.name
+
+    def __repr__( self ):
+        return _ustr(self)
+
+    def streamline( self ):
+        self.streamlined = True
+        self.strRepr = None
+        return self
+
+    def checkRecursion( self, parseElementList ):
+        pass
+
+    def validate( self, validateTrace=[] ):
+        """
+        Check defined expressions for valid structure, check for infinite recursive definitions.
+        """
+        self.checkRecursion( [] )
+
+    def parseFile( self, file_or_filename, parseAll=False ):
+        """
+        Execute the parse expression on the given file or filename.
+        If a filename is specified (instead of a file object),
+        the entire file is opened, read, and closed before parsing.
+        """
+        try:
+            file_contents = file_or_filename.read()
+        except AttributeError:
+            with open(file_or_filename, "r") as f:
+                file_contents = f.read()
+        try:
+            return self.parseString(file_contents, parseAll)
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def __eq__(self,other):
+        if isinstance(other, ParserElement):
+            return self is other or vars(self) == vars(other)
+        elif isinstance(other, basestring):
+            return self.matches(other)
+        else:
+            return super(ParserElement,self)==other
+
+    def __ne__(self,other):
+        return not (self == other)
+
+    def __hash__(self):
+        return hash(id(self))
+
+    def __req__(self,other):
+        return self == other
+
+    def __rne__(self,other):
+        return not (self == other)
+
+    def matches(self, testString, parseAll=True):
+        """
+        Method for quick testing of a parser against a test string. Good for simple 
+        inline microtests of sub expressions while building up larger parser.
+           
+        Parameters:
+         - testString - to test against this expression for a match
+         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests
+            
+        Example::
+            expr = Word(nums)
+            assert expr.matches("100")
+        """
+        try:
+            self.parseString(_ustr(testString), parseAll=parseAll)
+            return True
+        except ParseBaseException:
+            return False
+                
+    def runTests(self, tests, parseAll=True, comment='#', fullDump=True, printResults=True, failureTests=False):
+        """
+        Execute the parse expression on a series of test strings, showing each
+        test, the parsed results or where the parse failed. Quick and easy way to
+        run a parse expression against a list of sample strings.
+           
+        Parameters:
+         - tests - a list of separate test strings, or a multiline string of test strings
+         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests           
+         - comment - (default=C{'#'}) - expression for indicating embedded comments in the test 
+              string; pass None to disable comment filtering
+         - fullDump - (default=C{True}) - dump results as list followed by results names in nested outline;
+              if False, only dump nested list
+         - printResults - (default=C{True}) prints test output to stdout
+         - failureTests - (default=C{False}) indicates if these tests are expected to fail parsing
+
+        Returns: a (success, results) tuple, where success indicates that all tests succeeded
+        (or failed if C{failureTests} is True), and the results contain a list of lines of each 
+        test's output
+        
+        Example::
+            number_expr = pyparsing_common.number.copy()
+
+            result = number_expr.runTests('''
+                # unsigned integer
+                100
+                # negative integer
+                -100
+                # float with scientific notation
+                6.02e23
+                # integer with scientific notation
+                1e-12
+                ''')
+            print("Success" if result[0] else "Failed!")
+
+            result = number_expr.runTests('''
+                # stray character
+                100Z
+                # missing leading digit before '.'
+                -.100
+                # too many '.'
+                3.14.159
+                ''', failureTests=True)
+            print("Success" if result[0] else "Failed!")
+        prints::
+            # unsigned integer
+            100
+            [100]
+
+            # negative integer
+            -100
+            [-100]
+
+            # float with scientific notation
+            6.02e23
+            [6.02e+23]
+
+            # integer with scientific notation
+            1e-12
+            [1e-12]
+
+            Success
+            
+            # stray character
+            100Z
+               ^
+            FAIL: Expected end of text (at char 3), (line:1, col:4)
+
+            # missing leading digit before '.'
+            -.100
+            ^
+            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1)
+
+            # too many '.'
+            3.14.159
+                ^
+            FAIL: Expected end of text (at char 4), (line:1, col:5)
+
+            Success
+
+        Each test string must be on a single line. If you want to test a string that spans multiple
+        lines, create a test like this::
+
+            expr.runTest(r"this is a test\\n of strings that spans \\n 3 lines")
+        
+        (Note that this is a raw string literal, you must include the leading 'r'.)
+        """
+        if isinstance(tests, basestring):
+            tests = list(map(str.strip, tests.rstrip().splitlines()))
+        if isinstance(comment, basestring):
+            comment = Literal(comment)
+        allResults = []
+        comments = []
+        success = True
+        for t in tests:
+            if comment is not None and comment.matches(t, False) or comments and not t:
+                comments.append(t)
+                continue
+            if not t:
+                continue
+            out = ['\n'.join(comments), t]
+            comments = []
+            try:
+                t = t.replace(r'\n','\n')
+                result = self.parseString(t, parseAll=parseAll)
+                out.append(result.dump(full=fullDump))
+                success = success and not failureTests
+            except ParseBaseException as pe:
+                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else ""
+                if '\n' in t:
+                    out.append(line(pe.loc, t))
+                    out.append(' '*(col(pe.loc,t)-1) + '^' + fatal)
+                else:
+                    out.append(' '*pe.loc + '^' + fatal)
+                out.append("FAIL: " + str(pe))
+                success = success and failureTests
+                result = pe
+            except Exception as exc:
+                out.append("FAIL-EXCEPTION: " + str(exc))
+                success = success and failureTests
+                result = exc
+
+            if printResults:
+                if fullDump:
+                    out.append('')
+                print('\n'.join(out))
+
+            allResults.append((t, result))
+        
+        return success, allResults
+
+        
+class Token(ParserElement):
+    """
+    Abstract C{ParserElement} subclass, for defining atomic matching patterns.
+    """
+    def __init__( self ):
+        super(Token,self).__init__( savelist=False )
+
+
+class Empty(Token):
+    """
+    An empty token, will always match.
+    """
+    def __init__( self ):
+        super(Empty,self).__init__()
+        self.name = "Empty"
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+
+
+class NoMatch(Token):
+    """
+    A token that will never match.
+    """
+    def __init__( self ):
+        super(NoMatch,self).__init__()
+        self.name = "NoMatch"
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.errmsg = "Unmatchable token"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class Literal(Token):
+    """
+    Token to exactly match a specified string.
+    
+    Example::
+        Literal('blah').parseString('blah')  # -> ['blah']
+        Literal('blah').parseString('blahfooblah')  # -> ['blah']
+        Literal('blah').parseString('bla')  # -> Exception: Expected "blah"
+    
+    For case-insensitive matching, use L{CaselessLiteral}.
+    
+    For keyword matching (force word break before and after the matched string),
+    use L{Keyword} or L{CaselessKeyword}.
+    """
+    def __init__( self, matchString ):
+        super(Literal,self).__init__()
+        self.match = matchString
+        self.matchLen = len(matchString)
+        try:
+            self.firstMatchChar = matchString[0]
+        except IndexError:
+            warnings.warn("null string passed to Literal; use Empty() instead",
+                            SyntaxWarning, stacklevel=2)
+            self.__class__ = Empty
+        self.name = '"%s"' % _ustr(self.match)
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = False
+        self.mayIndexError = False
+
+    # Performance tuning: this routine gets called a *lot*
+    # if this is a single character match string  and the first character matches,
+    # short-circuit as quickly as possible, and avoid calling startswith
+    #~ @profile
+    def parseImpl( self, instring, loc, doActions=True ):
+        if (instring[loc] == self.firstMatchChar and
+            (self.matchLen==1 or instring.startswith(self.match,loc)) ):
+            return loc+self.matchLen, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+_L = Literal
+ParserElement._literalStringClass = Literal
+
+class Keyword(Token):
+    """
+    Token to exactly match a specified string as a keyword, that is, it must be
+    immediately followed by a non-keyword character.  Compare with C{L{Literal}}:
+     - C{Literal("if")} will match the leading C{'if'} in C{'ifAndOnlyIf'}.
+     - C{Keyword("if")} will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'}
+    Accepts two optional constructor arguments in addition to the keyword string:
+     - C{identChars} is a string of characters that would be valid identifier characters,
+          defaulting to all alphanumerics + "_" and "$"
+     - C{caseless} allows case-insensitive matching, default is C{False}.
+       
+    Example::
+        Keyword("start").parseString("start")  # -> ['start']
+        Keyword("start").parseString("starting")  # -> Exception
+
+    For case-insensitive matching, use L{CaselessKeyword}.
+    """
+    DEFAULT_KEYWORD_CHARS = alphanums+"_$"
+
+    def __init__( self, matchString, identChars=None, caseless=False ):
+        super(Keyword,self).__init__()
+        if identChars is None:
+            identChars = Keyword.DEFAULT_KEYWORD_CHARS
+        self.match = matchString
+        self.matchLen = len(matchString)
+        try:
+            self.firstMatchChar = matchString[0]
+        except IndexError:
+            warnings.warn("null string passed to Keyword; use Empty() instead",
+                            SyntaxWarning, stacklevel=2)
+        self.name = '"%s"' % self.match
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = False
+        self.mayIndexError = False
+        self.caseless = caseless
+        if caseless:
+            self.caselessmatch = matchString.upper()
+            identChars = identChars.upper()
+        self.identChars = set(identChars)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.caseless:
+            if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
+                 (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and
+                 (loc == 0 or instring[loc-1].upper() not in self.identChars) ):
+                return loc+self.matchLen, self.match
+        else:
+            if (instring[loc] == self.firstMatchChar and
+                (self.matchLen==1 or instring.startswith(self.match,loc)) and
+                (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and
+                (loc == 0 or instring[loc-1] not in self.identChars) ):
+                return loc+self.matchLen, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+
+    def copy(self):
+        c = super(Keyword,self).copy()
+        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS
+        return c
+
+    @staticmethod
+    def setDefaultKeywordChars( chars ):
+        """Overrides the default Keyword chars
+        """
+        Keyword.DEFAULT_KEYWORD_CHARS = chars
+
+class CaselessLiteral(Literal):
+    """
+    Token to match a specified string, ignoring case of letters.
+    Note: the matched results will always be in the case of the given
+    match string, NOT the case of the input text.
+
+    Example::
+        OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD']
+        
+    (Contrast with example for L{CaselessKeyword}.)
+    """
+    def __init__( self, matchString ):
+        super(CaselessLiteral,self).__init__( matchString.upper() )
+        # Preserve the defining literal.
+        self.returnString = matchString
+        self.name = "'%s'" % self.returnString
+        self.errmsg = "Expected " + self.name
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if instring[ loc:loc+self.matchLen ].upper() == self.match:
+            return loc+self.matchLen, self.returnString
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class CaselessKeyword(Keyword):
+    """
+    Caseless version of L{Keyword}.
+
+    Example::
+        OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']
+        
+    (Contrast with example for L{CaselessLiteral}.)
+    """
+    def __init__( self, matchString, identChars=None ):
+        super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
+             (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):
+            return loc+self.matchLen, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class CloseMatch(Token):
+    """
+    A variation on L{Literal} which matches "close" matches, that is, 
+    strings with at most 'n' mismatching characters. C{CloseMatch} takes parameters:
+     - C{match_string} - string to be matched
+     - C{maxMismatches} - (C{default=1}) maximum number of mismatches allowed to count as a match
+    
+    The results from a successful parse will contain the matched text from the input string and the following named results:
+     - C{mismatches} - a list of the positions within the match_string where mismatches were found
+     - C{original} - the original match_string used to compare against the input string
+    
+    If C{mismatches} is an empty list, then the match was an exact match.
+    
+    Example::
+        patt = CloseMatch("ATCATCGAATGGA")
+        patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})
+        patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)
+
+        # exact match
+        patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})
+
+        # close match allowing up to 2 mismatches
+        patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2)
+        patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})
+    """
+    def __init__(self, match_string, maxMismatches=1):
+        super(CloseMatch,self).__init__()
+        self.name = match_string
+        self.match_string = match_string
+        self.maxMismatches = maxMismatches
+        self.errmsg = "Expected %r (with up to %d mismatches)" % (self.match_string, self.maxMismatches)
+        self.mayIndexError = False
+        self.mayReturnEmpty = False
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        start = loc
+        instrlen = len(instring)
+        maxloc = start + len(self.match_string)
+
+        if maxloc <= instrlen:
+            match_string = self.match_string
+            match_stringloc = 0
+            mismatches = []
+            maxMismatches = self.maxMismatches
+
+            for match_stringloc,s_m in enumerate(zip(instring[loc:maxloc], self.match_string)):
+                src,mat = s_m
+                if src != mat:
+                    mismatches.append(match_stringloc)
+                    if len(mismatches) > maxMismatches:
+                        break
+            else:
+                loc = match_stringloc + 1
+                results = ParseResults([instring[start:loc]])
+                results['original'] = self.match_string
+                results['mismatches'] = mismatches
+                return loc, results
+
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class Word(Token):
+    """
+    Token for matching words composed of allowed character sets.
+    Defined with string containing all allowed initial characters,
+    an optional string containing allowed body characters (if omitted,
+    defaults to the initial character set), and an optional minimum,
+    maximum, and/or exact length.  The default value for C{min} is 1 (a
+    minimum value < 1 is not valid); the default values for C{max} and C{exact}
+    are 0, meaning no maximum or exact length restriction. An optional
+    C{excludeChars} parameter can list characters that might be found in 
+    the input C{bodyChars} string; useful to define a word of all printables
+    except for one or two characters, for instance.
+    
+    L{srange} is useful for defining custom character set strings for defining 
+    C{Word} expressions, using range notation from regular expression character sets.
+    
+    A common mistake is to use C{Word} to match a specific literal string, as in 
+    C{Word("Address")}. Remember that C{Word} uses the string argument to define
+    I{sets} of matchable characters. This expression would match "Add", "AAA",
+    "dAred", or any other word made up of the characters 'A', 'd', 'r', 'e', and 's'.
+    To match an exact literal string, use L{Literal} or L{Keyword}.
+
+    pyparsing includes helper strings for building Words:
+     - L{alphas}
+     - L{nums}
+     - L{alphanums}
+     - L{hexnums}
+     - L{alphas8bit} (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.)
+     - L{punc8bit} (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.)
+     - L{printables} (any non-whitespace character)
+
+    Example::
+        # a word composed of digits
+        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))
+        
+        # a word with a leading capital, and zero or more lowercase
+        capital_word = Word(alphas.upper(), alphas.lower())
+
+        # hostnames are alphanumeric, with leading alpha, and '-'
+        hostname = Word(alphas, alphanums+'-')
+        
+        # roman numeral (not a strict parser, accepts invalid mix of characters)
+        roman = Word("IVXLCDM")
+        
+        # any string of non-whitespace characters, except for ','
+        csv_value = Word(printables, excludeChars=",")
+    """
+    def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ):
+        super(Word,self).__init__()
+        if excludeChars:
+            initChars = ''.join(c for c in initChars if c not in excludeChars)
+            if bodyChars:
+                bodyChars = ''.join(c for c in bodyChars if c not in excludeChars)
+        self.initCharsOrig = initChars
+        self.initChars = set(initChars)
+        if bodyChars :
+            self.bodyCharsOrig = bodyChars
+            self.bodyChars = set(bodyChars)
+        else:
+            self.bodyCharsOrig = initChars
+            self.bodyChars = set(initChars)
+
+        self.maxSpecified = max > 0
+
+        if min < 1:
+            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.asKeyword = asKeyword
+
+        if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):
+            if self.bodyCharsOrig == self.initCharsOrig:
+                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)
+            elif len(self.initCharsOrig) == 1:
+                self.reString = "%s[%s]*" % \
+                                      (re.escape(self.initCharsOrig),
+                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
+            else:
+                self.reString = "[%s][%s]*" % \
+                                      (_escapeRegexRangeChars(self.initCharsOrig),
+                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
+            if self.asKeyword:
+                self.reString = r"\b"+self.reString+r"\b"
+            try:
+                self.re = re.compile( self.reString )
+            except Exception:
+                self.re = None
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.re:
+            result = self.re.match(instring,loc)
+            if not result:
+                raise ParseException(instring, loc, self.errmsg, self)
+
+            loc = result.end()
+            return loc, result.group()
+
+        if not(instring[ loc ] in self.initChars):
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        start = loc
+        loc += 1
+        instrlen = len(instring)
+        bodychars = self.bodyChars
+        maxloc = start + self.maxLen
+        maxloc = min( maxloc, instrlen )
+        while loc < maxloc and instring[loc] in bodychars:
+            loc += 1
+
+        throwException = False
+        if loc - start < self.minLen:
+            throwException = True
+        if self.maxSpecified and loc < instrlen and instring[loc] in bodychars:
+            throwException = True
+        if self.asKeyword:
+            if (start>0 and instring[start-1] in bodychars) or (loc<instrlen and instring[loc] in bodychars):
+                throwException = True
+
+        if throwException:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+    def __str__( self ):
+        try:
+            return super(Word,self).__str__()
+        except Exception:
+            pass
+
+
+        if self.strRepr is None:
+
+            def charsAsStr(s):
+                if len(s)>4:
+                    return s[:4]+"..."
+                else:
+                    return s
+
+            if ( self.initCharsOrig != self.bodyCharsOrig ):
+                self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) )
+            else:
+                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)
+
+        return self.strRepr
+
+
+class Regex(Token):
+    r"""
+    Token for matching strings that match a given regular expression.
+    Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.
+    If the given regex contains named groups (defined using C{(?P<name>...)}), these will be preserved as 
+    named parse results.
+
+    Example::
+        realnum = Regex(r"[+-]?\d+\.\d*")
+        date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)')
+        # ref: http://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression
+        roman = Regex(r"M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
+    """
+    compiledREtype = type(re.compile("[A-Z]"))
+    def __init__( self, pattern, flags=0):
+        """The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags."""
+        super(Regex,self).__init__()
+
+        if isinstance(pattern, basestring):
+            if not pattern:
+                warnings.warn("null string passed to Regex; use Empty() instead",
+                        SyntaxWarning, stacklevel=2)
+
+            self.pattern = pattern
+            self.flags = flags
+
+            try:
+                self.re = re.compile(self.pattern, self.flags)
+                self.reString = self.pattern
+            except sre_constants.error:
+                warnings.warn("invalid pattern (%s) passed to Regex" % pattern,
+                    SyntaxWarning, stacklevel=2)
+                raise
+
+        elif isinstance(pattern, Regex.compiledREtype):
+            self.re = pattern
+            self.pattern = \
+            self.reString = str(pattern)
+            self.flags = flags
+            
+        else:
+            raise ValueError("Regex may only be constructed with a string or a compiled RE object")
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        result = self.re.match(instring,loc)
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        d = result.groupdict()
+        ret = ParseResults(result.group())
+        if d:
+            for k in d:
+                ret[k] = d[k]
+        return loc,ret
+
+    def __str__( self ):
+        try:
+            return super(Regex,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "Re:(%s)" % repr(self.pattern)
+
+        return self.strRepr
+
+
+class QuotedString(Token):
+    r"""
+    Token for matching strings that are delimited by quoting characters.
+    
+    Defined with the following parameters:
+        - quoteChar - string of one or more characters defining the quote delimiting string
+        - escChar - character to escape quotes, typically backslash (default=C{None})
+        - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=C{None})
+        - multiline - boolean indicating whether quotes can span multiple lines (default=C{False})
+        - unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True})
+        - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar)
+        - convertWhitespaceEscapes - convert escaped whitespace (C{'\t'}, C{'\n'}, etc.) to actual whitespace (default=C{True})
+
+    Example::
+        qs = QuotedString('"')
+        print(qs.searchString('lsjdf "This is the quote" sldjf'))
+        complex_qs = QuotedString('{{', endQuoteChar='}}')
+        print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf'))
+        sql_qs = QuotedString('"', escQuote='""')
+        print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))
+    prints::
+        [['This is the quote']]
+        [['This is the "quote"']]
+        [['This is the quote with "embedded" quotes']]
+    """
+    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True):
+        super(QuotedString,self).__init__()
+
+        # remove white space from quote chars - wont work anyway
+        quoteChar = quoteChar.strip()
+        if not quoteChar:
+            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
+            raise SyntaxError()
+
+        if endQuoteChar is None:
+            endQuoteChar = quoteChar
+        else:
+            endQuoteChar = endQuoteChar.strip()
+            if not endQuoteChar:
+                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
+                raise SyntaxError()
+
+        self.quoteChar = quoteChar
+        self.quoteCharLen = len(quoteChar)
+        self.firstQuoteChar = quoteChar[0]
+        self.endQuoteChar = endQuoteChar
+        self.endQuoteCharLen = len(endQuoteChar)
+        self.escChar = escChar
+        self.escQuote = escQuote
+        self.unquoteResults = unquoteResults
+        self.convertWhitespaceEscapes = convertWhitespaceEscapes
+
+        if multiline:
+            self.flags = re.MULTILINE | re.DOTALL
+            self.pattern = r'%s(?:[^%s%s]' % \
+                ( re.escape(self.quoteChar),
+                  _escapeRegexRangeChars(self.endQuoteChar[0]),
+                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
+        else:
+            self.flags = 0
+            self.pattern = r'%s(?:[^%s\n\r%s]' % \
+                ( re.escape(self.quoteChar),
+                  _escapeRegexRangeChars(self.endQuoteChar[0]),
+                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
+        if len(self.endQuoteChar) > 1:
+            self.pattern += (
+                '|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]),
+                                               _escapeRegexRangeChars(self.endQuoteChar[i]))
+                                    for i in range(len(self.endQuoteChar)-1,0,-1)) + ')'
+                )
+        if escQuote:
+            self.pattern += (r'|(?:%s)' % re.escape(escQuote))
+        if escChar:
+            self.pattern += (r'|(?:%s.)' % re.escape(escChar))
+            self.escCharReplacePattern = re.escape(self.escChar)+"(.)"
+        self.pattern += (r')*%s' % re.escape(self.endQuoteChar))
+
+        try:
+            self.re = re.compile(self.pattern, self.flags)
+            self.reString = self.pattern
+        except sre_constants.error:
+            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,
+                SyntaxWarning, stacklevel=2)
+            raise
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        ret = result.group()
+
+        if self.unquoteResults:
+
+            # strip off quotes
+            ret = ret[self.quoteCharLen:-self.endQuoteCharLen]
+
+            if isinstance(ret,basestring):
+                # replace escaped whitespace
+                if '\\' in ret and self.convertWhitespaceEscapes:
+                    ws_map = {
+                        r'\t' : '\t',
+                        r'\n' : '\n',
+                        r'\f' : '\f',
+                        r'\r' : '\r',
+                    }
+                    for wslit,wschar in ws_map.items():
+                        ret = ret.replace(wslit, wschar)
+
+                # replace escaped characters
+                if self.escChar:
+                    ret = re.sub(self.escCharReplacePattern, r"\g<1>", ret)
+
+                # replace escaped quotes
+                if self.escQuote:
+                    ret = ret.replace(self.escQuote, self.endQuoteChar)
+
+        return loc, ret
+
+    def __str__( self ):
+        try:
+            return super(QuotedString,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)
+
+        return self.strRepr
+
+
+class CharsNotIn(Token):
+    """
+    Token for matching words composed of characters I{not} in a given set (will
+    include whitespace in matched characters if not listed in the provided exclusion set - see example).
+    Defined with string containing all disallowed characters, and an optional
+    minimum, maximum, and/or exact length.  The default value for C{min} is 1 (a
+    minimum value < 1 is not valid); the default values for C{max} and C{exact}
+    are 0, meaning no maximum or exact length restriction.
+
+    Example::
+        # define a comma-separated-value as anything that is not a ','
+        csv_value = CharsNotIn(',')
+        print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213"))
+    prints::
+        ['dkls', 'lsdkjf', 's12 34', '@!#', '213']
+    """
+    def __init__( self, notChars, min=1, max=0, exact=0 ):
+        super(CharsNotIn,self).__init__()
+        self.skipWhitespace = False
+        self.notChars = notChars
+
+        if min < 1:
+            raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted")
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = ( self.minLen == 0 )
+        self.mayIndexError = False
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if instring[loc] in self.notChars:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        start = loc
+        loc += 1
+        notchars = self.notChars
+        maxlen = min( start+self.maxLen, len(instring) )
+        while loc < maxlen and \
+              (instring[loc] not in notchars):
+            loc += 1
+
+        if loc - start < self.minLen:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+    def __str__( self ):
+        try:
+            return super(CharsNotIn, self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            if len(self.notChars) > 4:
+                self.strRepr = "!W:(%s...)" % self.notChars[:4]
+            else:
+                self.strRepr = "!W:(%s)" % self.notChars
+
+        return self.strRepr
+
+class White(Token):
+    """
+    Special matching class for matching whitespace.  Normally, whitespace is ignored
+    by pyparsing grammars.  This class is included when some whitespace structures
+    are significant.  Define with a string containing the whitespace characters to be
+    matched; default is C{" \\t\\r\\n"}.  Also takes optional C{min}, C{max}, and C{exact} arguments,
+    as defined for the C{L{Word}} class.
+    """
+    whiteStrs = {
+        " " : "<SPC>",
+        "\t": "<TAB>",
+        "\n": "<LF>",
+        "\r": "<CR>",
+        "\f": "<FF>",
+        }
+    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):
+        super(White,self).__init__()
+        self.matchWhite = ws
+        self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) )
+        #~ self.leaveWhitespace()
+        self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite))
+        self.mayReturnEmpty = True
+        self.errmsg = "Expected " + self.name
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if not(instring[ loc ] in self.matchWhite):
+            raise ParseException(instring, loc, self.errmsg, self)
+        start = loc
+        loc += 1
+        maxloc = start + self.maxLen
+        maxloc = min( maxloc, len(instring) )
+        while loc < maxloc and instring[loc] in self.matchWhite:
+            loc += 1
+
+        if loc - start < self.minLen:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+
+class _PositionToken(Token):
+    def __init__( self ):
+        super(_PositionToken,self).__init__()
+        self.name=self.__class__.__name__
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+
+class GoToColumn(_PositionToken):
+    """
+    Token to advance to a specific column of input text; useful for tabular report scraping.
+    """
+    def __init__( self, colno ):
+        super(GoToColumn,self).__init__()
+        self.col = colno
+
+    def preParse( self, instring, loc ):
+        if col(loc,instring) != self.col:
+            instrlen = len(instring)
+            if self.ignoreExprs:
+                loc = self._skipIgnorables( instring, loc )
+            while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col :
+                loc += 1
+        return loc
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        thiscol = col( loc, instring )
+        if thiscol > self.col:
+            raise ParseException( instring, loc, "Text not in expected column", self )
+        newloc = loc + self.col - thiscol
+        ret = instring[ loc: newloc ]
+        return newloc, ret
+
+
+class LineStart(_PositionToken):
+    """
+    Matches if current position is at the beginning of a line within the parse string
+    
+    Example::
+    
+        test = '''\
+        AAA this line
+        AAA and this line
+          AAA but not this one
+        B AAA and definitely not this one
+        '''
+
+        for t in (LineStart() + 'AAA' + restOfLine).searchString(test):
+            print(t)
+    
+    Prints::
+        ['AAA', ' this line']
+        ['AAA', ' and this line']    
+
+    """
+    def __init__( self ):
+        super(LineStart,self).__init__()
+        self.errmsg = "Expected start of line"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if col(loc, instring) == 1:
+            return loc, []
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class LineEnd(_PositionToken):
+    """
+    Matches if current position is at the end of a line within the parse string
+    """
+    def __init__( self ):
+        super(LineEnd,self).__init__()
+        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )
+        self.errmsg = "Expected end of line"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if loc<len(instring):
+            if instring[loc] == "\n":
+                return loc+1, "\n"
+            else:
+                raise ParseException(instring, loc, self.errmsg, self)
+        elif loc == len(instring):
+            return loc+1, []
+        else:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+class StringStart(_PositionToken):
+    """
+    Matches if current position is at the beginning of the parse string
+    """
+    def __init__( self ):
+        super(StringStart,self).__init__()
+        self.errmsg = "Expected start of text"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if loc != 0:
+            # see if entire string up to here is just whitespace and ignoreables
+            if loc != self.preParse( instring, 0 ):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+class StringEnd(_PositionToken):
+    """
+    Matches if current position is at the end of the parse string
+    """
+    def __init__( self ):
+        super(StringEnd,self).__init__()
+        self.errmsg = "Expected end of text"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if loc < len(instring):
+            raise ParseException(instring, loc, self.errmsg, self)
+        elif loc == len(instring):
+            return loc+1, []
+        elif loc > len(instring):
+            return loc, []
+        else:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+class WordStart(_PositionToken):
+    """
+    Matches if the current position is at the beginning of a Word, and
+    is not preceded by any character in a given set of C{wordChars}
+    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
+    use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of
+    the string being parsed, or at the beginning of a line.
+    """
+    def __init__(self, wordChars = printables):
+        super(WordStart,self).__init__()
+        self.wordChars = set(wordChars)
+        self.errmsg = "Not at the start of a word"
+
+    def parseImpl(self, instring, loc, doActions=True ):
+        if loc != 0:
+            if (instring[loc-1] in self.wordChars or
+                instring[loc] not in self.wordChars):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+class WordEnd(_PositionToken):
+    """
+    Matches if the current position is at the end of a Word, and
+    is not followed by any character in a given set of C{wordChars}
+    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
+    use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of
+    the string being parsed, or at the end of a line.
+    """
+    def __init__(self, wordChars = printables):
+        super(WordEnd,self).__init__()
+        self.wordChars = set(wordChars)
+        self.skipWhitespace = False
+        self.errmsg = "Not at the end of a word"
+
+    def parseImpl(self, instring, loc, doActions=True ):
+        instrlen = len(instring)
+        if instrlen>0 and loc<instrlen:
+            if (instring[loc] in self.wordChars or
+                instring[loc-1] not in self.wordChars):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+
+class ParseExpression(ParserElement):
+    """
+    Abstract subclass of ParserElement, for combining and post-processing parsed tokens.
+    """
+    def __init__( self, exprs, savelist = False ):
+        super(ParseExpression,self).__init__(savelist)
+        if isinstance( exprs, _generatorType ):
+            exprs = list(exprs)
+
+        if isinstance( exprs, basestring ):
+            self.exprs = [ ParserElement._literalStringClass( exprs ) ]
+        elif isinstance( exprs, Iterable ):
+            exprs = list(exprs)
+            # if sequence of strings provided, wrap with Literal
+            if all(isinstance(expr, basestring) for expr in exprs):
+                exprs = map(ParserElement._literalStringClass, exprs)
+            self.exprs = list(exprs)
+        else:
+            try:
+                self.exprs = list( exprs )
+            except TypeError:
+                self.exprs = [ exprs ]
+        self.callPreparse = False
+
+    def __getitem__( self, i ):
+        return self.exprs[i]
+
+    def append( self, other ):
+        self.exprs.append( other )
+        self.strRepr = None
+        return self
+
+    def leaveWhitespace( self ):
+        """Extends C{leaveWhitespace} defined in base class, and also invokes C{leaveWhitespace} on
+           all contained expressions."""
+        self.skipWhitespace = False
+        self.exprs = [ e.copy() for e in self.exprs ]
+        for e in self.exprs:
+            e.leaveWhitespace()
+        return self
+
+    def ignore( self, other ):
+        if isinstance( other, Suppress ):
+            if other not in self.ignoreExprs:
+                super( ParseExpression, self).ignore( other )
+                for e in self.exprs:
+                    e.ignore( self.ignoreExprs[-1] )
+        else:
+            super( ParseExpression, self).ignore( other )
+            for e in self.exprs:
+                e.ignore( self.ignoreExprs[-1] )
+        return self
+
+    def __str__( self ):
+        try:
+            return super(ParseExpression,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.exprs) )
+        return self.strRepr
+
+    def streamline( self ):
+        super(ParseExpression,self).streamline()
+
+        for e in self.exprs:
+            e.streamline()
+
+        # collapse nested And's of the form And( And( And( a,b), c), d) to And( a,b,c,d )
+        # but only if there are no parse actions or resultsNames on the nested And's
+        # (likewise for Or's and MatchFirst's)
+        if ( len(self.exprs) == 2 ):
+            other = self.exprs[0]
+            if ( isinstance( other, self.__class__ ) and
+                  not(other.parseAction) and
+                  other.resultsName is None and
+                  not other.debug ):
+                self.exprs = other.exprs[:] + [ self.exprs[1] ]
+                self.strRepr = None
+                self.mayReturnEmpty |= other.mayReturnEmpty
+                self.mayIndexError  |= other.mayIndexError
+
+            other = self.exprs[-1]
+            if ( isinstance( other, self.__class__ ) and
+                  not(other.parseAction) and
+                  other.resultsName is None and
+                  not other.debug ):
+                self.exprs = self.exprs[:-1] + other.exprs[:]
+                self.strRepr = None
+                self.mayReturnEmpty |= other.mayReturnEmpty
+                self.mayIndexError  |= other.mayIndexError
+
+        self.errmsg = "Expected " + _ustr(self)
+        
+        return self
+
+    def setResultsName( self, name, listAllMatches=False ):
+        ret = super(ParseExpression,self).setResultsName(name,listAllMatches)
+        return ret
+
+    def validate( self, validateTrace=[] ):
+        tmp = validateTrace[:]+[self]
+        for e in self.exprs:
+            e.validate(tmp)
+        self.checkRecursion( [] )
+        
+    def copy(self):
+        ret = super(ParseExpression,self).copy()
+        ret.exprs = [e.copy() for e in self.exprs]
+        return ret
+
+class And(ParseExpression):
+    """
+    Requires all given C{ParseExpression}s to be found in the given order.
+    Expressions may be separated by whitespace.
+    May be constructed using the C{'+'} operator.
+    May also be constructed using the C{'-'} operator, which will suppress backtracking.
+
+    Example::
+        integer = Word(nums)
+        name_expr = OneOrMore(Word(alphas))
+
+        expr = And([integer("id"),name_expr("name"),integer("age")])
+        # more easily written as:
+        expr = integer("id") + name_expr("name") + integer("age")
+    """
+
+    class _ErrorStop(Empty):
+        def __init__(self, *args, **kwargs):
+            super(And._ErrorStop,self).__init__(*args, **kwargs)
+            self.name = '-'
+            self.leaveWhitespace()
+
+    def __init__( self, exprs, savelist = True ):
+        super(And,self).__init__(exprs, savelist)
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        self.setWhitespaceChars( self.exprs[0].whiteChars )
+        self.skipWhitespace = self.exprs[0].skipWhitespace
+        self.callPreparse = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        # pass False as last arg to _parse for first element, since we already
+        # pre-parsed the string as part of our And pre-parsing
+        loc, resultlist = self.exprs[0]._parse( instring, loc, doActions, callPreParse=False )
+        errorStop = False
+        for e in self.exprs[1:]:
+            if isinstance(e, And._ErrorStop):
+                errorStop = True
+                continue
+            if errorStop:
+                try:
+                    loc, exprtokens = e._parse( instring, loc, doActions )
+                except ParseSyntaxException:
+                    raise
+                except ParseBaseException as pe:
+                    pe.__traceback__ = None
+                    raise ParseSyntaxException._from_exception(pe)
+                except IndexError:
+                    raise ParseSyntaxException(instring, len(instring), self.errmsg, self)
+            else:
+                loc, exprtokens = e._parse( instring, loc, doActions )
+            if exprtokens or exprtokens.haskeys():
+                resultlist += exprtokens
+        return loc, resultlist
+
+    def __iadd__(self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        return self.append( other ) #And( [ self, other ] )
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+            if not e.mayReturnEmpty:
+                break
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+
+class Or(ParseExpression):
+    """
+    Requires that at least one C{ParseExpression} is found.
+    If two expressions match, the expression that matches the longest string will be used.
+    May be constructed using the C{'^'} operator.
+
+    Example::
+        # construct Or using '^' operator
+        
+        number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums))
+        print(number.searchString("123 3.1416 789"))
+    prints::
+        [['123'], ['3.1416'], ['789']]
+    """
+    def __init__( self, exprs, savelist = False ):
+        super(Or,self).__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        maxExcLoc = -1
+        maxException = None
+        matches = []
+        for e in self.exprs:
+            try:
+                loc2 = e.tryParse( instring, loc )
+            except ParseException as err:
+                err.__traceback__ = None
+                if err.loc > maxExcLoc:
+                    maxException = err
+                    maxExcLoc = err.loc
+            except IndexError:
+                if len(instring) > maxExcLoc:
+                    maxException = ParseException(instring,len(instring),e.errmsg,self)
+                    maxExcLoc = len(instring)
+            else:
+                # save match among all matches, to retry longest to shortest
+                matches.append((loc2, e))
+
+        if matches:
+            matches.sort(key=lambda x: -x[0])
+            for _,e in matches:
+                try:
+                    return e._parse( instring, loc, doActions )
+                except ParseException as err:
+                    err.__traceback__ = None
+                    if err.loc > maxExcLoc:
+                        maxException = err
+                        maxExcLoc = err.loc
+
+        if maxException is not None:
+            maxException.msg = self.errmsg
+            raise maxException
+        else:
+            raise ParseException(instring, loc, "no defined alternatives to match", self)
+
+
+    def __ixor__(self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        return self.append( other ) #Or( [ self, other ] )
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+
+
+class MatchFirst(ParseExpression):
+    """
+    Requires that at least one C{ParseExpression} is found.
+    If two expressions match, the first one listed is the one that will match.
+    May be constructed using the C{'|'} operator.
+
+    Example::
+        # construct MatchFirst using '|' operator
+        
+        # watch the order of expressions to match
+        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))
+        print(number.searchString("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']]
+
+        # put more selective expression first
+        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)
+        print(number.searchString("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']]
+    """
+    def __init__( self, exprs, savelist = False ):
+        super(MatchFirst,self).__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        maxExcLoc = -1
+        maxException = None
+        for e in self.exprs:
+            try:
+                ret = e._parse( instring, loc, doActions )
+                return ret
+            except ParseException as err:
+                if err.loc > maxExcLoc:
+                    maxException = err
+                    maxExcLoc = err.loc
+            except IndexError:
+                if len(instring) > maxExcLoc:
+                    maxException = ParseException(instring,len(instring),e.errmsg,self)
+                    maxExcLoc = len(instring)
+
+        # only got here if no expression matched, raise exception for match that made it the furthest
+        else:
+            if maxException is not None:
+                maxException.msg = self.errmsg
+                raise maxException
+            else:
+                raise ParseException(instring, loc, "no defined alternatives to match", self)
+
+    def __ior__(self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        return self.append( other ) #MatchFirst( [ self, other ] )
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+
+
+class Each(ParseExpression):
+    """
+    Requires all given C{ParseExpression}s to be found, but in any order.
+    Expressions may be separated by whitespace.
+    May be constructed using the C{'&'} operator.
+
+    Example::
+        color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")
+        shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")
+        integer = Word(nums)
+        shape_attr = "shape:" + shape_type("shape")
+        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")
+        color_attr = "color:" + color("color")
+        size_attr = "size:" + integer("size")
+
+        # use Each (using operator '&') to accept attributes in any order 
+        # (shape and posn are required, color and size are optional)
+        shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr)
+
+        shape_spec.runTests('''
+            shape: SQUARE color: BLACK posn: 100, 120
+            shape: CIRCLE size: 50 color: BLUE posn: 50,80
+            color:GREEN size:20 shape:TRIANGLE posn:20,40
+            '''
+            )
+    prints::
+        shape: SQUARE color: BLACK posn: 100, 120
+        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]
+        - color: BLACK
+        - posn: ['100', ',', '120']
+          - x: 100
+          - y: 120
+        - shape: SQUARE
+
+
+        shape: CIRCLE size: 50 color: BLUE posn: 50,80
+        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]
+        - color: BLUE
+        - posn: ['50', ',', '80']
+          - x: 50
+          - y: 80
+        - shape: CIRCLE
+        - size: 50
+
+
+        color: GREEN size: 20 shape: TRIANGLE posn: 20,40
+        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]
+        - color: GREEN
+        - posn: ['20', ',', '40']
+          - x: 20
+          - y: 40
+        - shape: TRIANGLE
+        - size: 20
+    """
+    def __init__( self, exprs, savelist = True ):
+        super(Each,self).__init__(exprs, savelist)
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        self.skipWhitespace = True
+        self.initExprGroups = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.initExprGroups:
+            self.opt1map = dict((id(e.expr),e) for e in self.exprs if isinstance(e,Optional))
+            opt1 = [ e.expr for e in self.exprs if isinstance(e,Optional) ]
+            opt2 = [ e for e in self.exprs if e.mayReturnEmpty and not isinstance(e,Optional)]
+            self.optionals = opt1 + opt2
+            self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ]
+            self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ]
+            self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ]
+            self.required += self.multirequired
+            self.initExprGroups = False
+        tmpLoc = loc
+        tmpReqd = self.required[:]
+        tmpOpt  = self.optionals[:]
+        matchOrder = []
+
+        keepMatching = True
+        while keepMatching:
+            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired
+            failed = []
+            for e in tmpExprs:
+                try:
+                    tmpLoc = e.tryParse( instring, tmpLoc )
+                except ParseException:
+                    failed.append(e)
+                else:
+                    matchOrder.append(self.opt1map.get(id(e),e))
+                    if e in tmpReqd:
+                        tmpReqd.remove(e)
+                    elif e in tmpOpt:
+                        tmpOpt.remove(e)
+            if len(failed) == len(tmpExprs):
+                keepMatching = False
+
+        if tmpReqd:
+            missing = ", ".join(_ustr(e) for e in tmpReqd)
+            raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing )
+
+        # add any unmatched Optionals, in case they have default values defined
+        matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt]
+
+        resultlist = []
+        for e in matchOrder:
+            loc,results = e._parse(instring,loc,doActions)
+            resultlist.append(results)
+
+        finalResults = sum(resultlist, ParseResults([]))
+        return loc, finalResults
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+
+
+class ParseElementEnhance(ParserElement):
+    """
+    Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens.
+    """
+    def __init__( self, expr, savelist=False ):
+        super(ParseElementEnhance,self).__init__(savelist)
+        if isinstance( expr, basestring ):
+            if issubclass(ParserElement._literalStringClass, Token):
+                expr = ParserElement._literalStringClass(expr)
+            else:
+                expr = ParserElement._literalStringClass(Literal(expr))
+        self.expr = expr
+        self.strRepr = None
+        if expr is not None:
+            self.mayIndexError = expr.mayIndexError
+            self.mayReturnEmpty = expr.mayReturnEmpty
+            self.setWhitespaceChars( expr.whiteChars )
+            self.skipWhitespace = expr.skipWhitespace
+            self.saveAsList = expr.saveAsList
+            self.callPreparse = expr.callPreparse
+            self.ignoreExprs.extend(expr.ignoreExprs)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.expr is not None:
+            return self.expr._parse( instring, loc, doActions, callPreParse=False )
+        else:
+            raise ParseException("",loc,self.errmsg,self)
+
+    def leaveWhitespace( self ):
+        self.skipWhitespace = False
+        self.expr = self.expr.copy()
+        if self.expr is not None:
+            self.expr.leaveWhitespace()
+        return self
+
+    def ignore( self, other ):
+        if isinstance( other, Suppress ):
+            if other not in self.ignoreExprs:
+                super( ParseElementEnhance, self).ignore( other )
+                if self.expr is not None:
+                    self.expr.ignore( self.ignoreExprs[-1] )
+        else:
+            super( ParseElementEnhance, self).ignore( other )
+            if self.expr is not None:
+                self.expr.ignore( self.ignoreExprs[-1] )
+        return self
+
+    def streamline( self ):
+        super(ParseElementEnhance,self).streamline()
+        if self.expr is not None:
+            self.expr.streamline()
+        return self
+
+    def checkRecursion( self, parseElementList ):
+        if self in parseElementList:
+            raise RecursiveGrammarException( parseElementList+[self] )
+        subRecCheckList = parseElementList[:] + [ self ]
+        if self.expr is not None:
+            self.expr.checkRecursion( subRecCheckList )
+
+    def validate( self, validateTrace=[] ):
+        tmp = validateTrace[:]+[self]
+        if self.expr is not None:
+            self.expr.validate(tmp)
+        self.checkRecursion( [] )
+
+    def __str__( self ):
+        try:
+            return super(ParseElementEnhance,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None and self.expr is not None:
+            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) )
+        return self.strRepr
+
+
+class FollowedBy(ParseElementEnhance):
+    """
+    Lookahead matching of the given parse expression.  C{FollowedBy}
+    does I{not} advance the parsing position within the input string, it only
+    verifies that the specified parse expression matches at the current
+    position.  C{FollowedBy} always returns a null token list.
+
+    Example::
+        # use FollowedBy to match a label only if it is followed by a ':'
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        
+        OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint()
+    prints::
+        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]
+    """
+    def __init__( self, expr ):
+        super(FollowedBy,self).__init__(expr)
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        self.expr.tryParse( instring, loc )
+        return loc, []
+
+
+class NotAny(ParseElementEnhance):
+    """
+    Lookahead to disallow matching with the given parse expression.  C{NotAny}
+    does I{not} advance the parsing position within the input string, it only
+    verifies that the specified parse expression does I{not} match at the current
+    position.  Also, C{NotAny} does I{not} skip over leading whitespace. C{NotAny}
+    always returns a null token list.  May be constructed using the '~' operator.
+
+    Example::
+        
+    """
+    def __init__( self, expr ):
+        super(NotAny,self).__init__(expr)
+        #~ self.leaveWhitespace()
+        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs
+        self.mayReturnEmpty = True
+        self.errmsg = "Found unwanted token, "+_ustr(self.expr)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.expr.canParseNext(instring, loc):
+            raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "~{" + _ustr(self.expr) + "}"
+
+        return self.strRepr
+
+class _MultipleMatch(ParseElementEnhance):
+    def __init__( self, expr, stopOn=None):
+        super(_MultipleMatch, self).__init__(expr)
+        self.saveAsList = True
+        ender = stopOn
+        if isinstance(ender, basestring):
+            ender = ParserElement._literalStringClass(ender)
+        self.not_ender = ~ender if ender is not None else None
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        self_expr_parse = self.expr._parse
+        self_skip_ignorables = self._skipIgnorables
+        check_ender = self.not_ender is not None
+        if check_ender:
+            try_not_ender = self.not_ender.tryParse
+        
+        # must be at least one (but first see if we are the stopOn sentinel;
+        # if so, fail)
+        if check_ender:
+            try_not_ender(instring, loc)
+        loc, tokens = self_expr_parse( instring, loc, doActions, callPreParse=False )
+        try:
+            hasIgnoreExprs = (not not self.ignoreExprs)
+            while 1:
+                if check_ender:
+                    try_not_ender(instring, loc)
+                if hasIgnoreExprs:
+                    preloc = self_skip_ignorables( instring, loc )
+                else:
+                    preloc = loc
+                loc, tmptokens = self_expr_parse( instring, preloc, doActions )
+                if tmptokens or tmptokens.haskeys():
+                    tokens += tmptokens
+        except (ParseException,IndexError):
+            pass
+
+        return loc, tokens
+        
+class OneOrMore(_MultipleMatch):
+    """
+    Repetition of one or more of the given expression.
+    
+    Parameters:
+     - expr - expression that must match one or more times
+     - stopOn - (default=C{None}) - expression for a terminating sentinel
+          (only required if the sentinel would ordinarily match the repetition 
+          expression)          
+
+    Example::
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
+
+        text = "shape: SQUARE posn: upper left color: BLACK"
+        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]
+
+        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]
+        
+        # could also be written as
+        (attr_expr * (1,)).parseString(text).pprint()
+    """
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + _ustr(self.expr) + "}..."
+
+        return self.strRepr
+
+class ZeroOrMore(_MultipleMatch):
+    """
+    Optional repetition of zero or more of the given expression.
+    
+    Parameters:
+     - expr - expression that must match zero or more times
+     - stopOn - (default=C{None}) - expression for a terminating sentinel
+          (only required if the sentinel would ordinarily match the repetition 
+          expression)          
+
+    Example: similar to L{OneOrMore}
+    """
+    def __init__( self, expr, stopOn=None):
+        super(ZeroOrMore,self).__init__(expr, stopOn=stopOn)
+        self.mayReturnEmpty = True
+        
+    def parseImpl( self, instring, loc, doActions=True ):
+        try:
+            return super(ZeroOrMore, self).parseImpl(instring, loc, doActions)
+        except (ParseException,IndexError):
+            return loc, []
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "[" + _ustr(self.expr) + "]..."
+
+        return self.strRepr
+
+class _NullToken(object):
+    def __bool__(self):
+        return False
+    __nonzero__ = __bool__
+    def __str__(self):
+        return ""
+
+_optionalNotMatched = _NullToken()
+class Optional(ParseElementEnhance):
+    """
+    Optional matching of the given expression.
+
+    Parameters:
+     - expr - expression that must match zero or more times
+     - default (optional) - value to be returned if the optional expression is not found.
+
+    Example::
+        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier
+        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4)))
+        zip.runTests('''
+            # traditional ZIP code
+            12345
+            
+            # ZIP+4 form
+            12101-0001
+            
+            # invalid ZIP
+            98765-
+            ''')
+    prints::
+        # traditional ZIP code
+        12345
+        ['12345']
+
+        # ZIP+4 form
+        12101-0001
+        ['12101-0001']
+
+        # invalid ZIP
+        98765-
+             ^
+        FAIL: Expected end of text (at char 5), (line:1, col:6)
+    """
+    def __init__( self, expr, default=_optionalNotMatched ):
+        super(Optional,self).__init__( expr, savelist=False )
+        self.saveAsList = self.expr.saveAsList
+        self.defaultValue = default
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        try:
+            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
+        except (ParseException,IndexError):
+            if self.defaultValue is not _optionalNotMatched:
+                if self.expr.resultsName:
+                    tokens = ParseResults([ self.defaultValue ])
+                    tokens[self.expr.resultsName] = self.defaultValue
+                else:
+                    tokens = [ self.defaultValue ]
+            else:
+                tokens = []
+        return loc, tokens
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "[" + _ustr(self.expr) + "]"
+
+        return self.strRepr
+
+class SkipTo(ParseElementEnhance):
+    """
+    Token for skipping over all undefined text until the matched expression is found.
+
+    Parameters:
+     - expr - target expression marking the end of the data to be skipped
+     - include - (default=C{False}) if True, the target expression is also parsed 
+          (the skipped text and target expression are returned as a 2-element list).
+     - ignore - (default=C{None}) used to define grammars (typically quoted strings and 
+          comments) that might contain false matches to the target expression
+     - failOn - (default=C{None}) define expressions that are not allowed to be 
+          included in the skipped test; if found before the target expression is found, 
+          the SkipTo is not a match
+
+    Example::
+        report = '''
+            Outstanding Issues Report - 1 Jan 2000
+
+               # | Severity | Description                               |  Days Open
+            -----+----------+-------------------------------------------+-----------
+             101 | Critical | Intermittent system crash                 |          6
+              94 | Cosmetic | Spelling error on Login ('log|n')         |         14
+              79 | Minor    | System slow when running too many reports |         47
+            '''
+        integer = Word(nums)
+        SEP = Suppress('|')
+        # use SkipTo to simply match everything up until the next SEP
+        # - ignore quoted strings, so that a '|' character inside a quoted string does not match
+        # - parse action will call token.strip() for each matched token, i.e., the description body
+        string_data = SkipTo(SEP, ignore=quotedString)
+        string_data.setParseAction(tokenMap(str.strip))
+        ticket_expr = (integer("issue_num") + SEP 
+                      + string_data("sev") + SEP 
+                      + string_data("desc") + SEP 
+                      + integer("days_open"))
+        
+        for tkt in ticket_expr.searchString(report):
+            print tkt.dump()
+    prints::
+        ['101', 'Critical', 'Intermittent system crash', '6']
+        - days_open: 6
+        - desc: Intermittent system crash
+        - issue_num: 101
+        - sev: Critical
+        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']
+        - days_open: 14
+        - desc: Spelling error on Login ('log|n')
+        - issue_num: 94
+        - sev: Cosmetic
+        ['79', 'Minor', 'System slow when running too many reports', '47']
+        - days_open: 47
+        - desc: System slow when running too many reports
+        - issue_num: 79
+        - sev: Minor
+    """
+    def __init__( self, other, include=False, ignore=None, failOn=None ):
+        super( SkipTo, self ).__init__( other )
+        self.ignoreExpr = ignore
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.includeMatch = include
+        self.asList = False
+        if isinstance(failOn, basestring):
+            self.failOn = ParserElement._literalStringClass(failOn)
+        else:
+            self.failOn = failOn
+        self.errmsg = "No match found for "+_ustr(self.expr)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        startloc = loc
+        instrlen = len(instring)
+        expr = self.expr
+        expr_parse = self.expr._parse
+        self_failOn_canParseNext = self.failOn.canParseNext if self.failOn is not None else None
+        self_ignoreExpr_tryParse = self.ignoreExpr.tryParse if self.ignoreExpr is not None else None
+        
+        tmploc = loc
+        while tmploc <= instrlen:
+            if self_failOn_canParseNext is not None:
+                # break if failOn expression matches
+                if self_failOn_canParseNext(instring, tmploc):
+                    break
+                    
+            if self_ignoreExpr_tryParse is not None:
+                # advance past ignore expressions
+                while 1:
+                    try:
+                        tmploc = self_ignoreExpr_tryParse(instring, tmploc)
+                    except ParseBaseException:
+                        break
+            
+            try:
+                expr_parse(instring, tmploc, doActions=False, callPreParse=False)
+            except (ParseException, IndexError):
+                # no match, advance loc in string
+                tmploc += 1
+            else:
+                # matched skipto expr, done
+                break
+
+        else:
+            # ran off the end of the input string without matching skipto expr, fail
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        # build up return values
+        loc = tmploc
+        skiptext = instring[startloc:loc]
+        skipresult = ParseResults(skiptext)
+        
+        if self.includeMatch:
+            loc, mat = expr_parse(instring,loc,doActions,callPreParse=False)
+            skipresult += mat
+
+        return loc, skipresult
+
+class Forward(ParseElementEnhance):
+    """
+    Forward declaration of an expression to be defined later -
+    used for recursive grammars, such as algebraic infix notation.
+    When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator.
+
+    Note: take care when assigning to C{Forward} not to overlook precedence of operators.
+    Specifically, '|' has a lower precedence than '<<', so that::
+        fwdExpr << a | b | c
+    will actually be evaluated as::
+        (fwdExpr << a) | b | c
+    thereby leaving b and c out as parseable alternatives.  It is recommended that you
+    explicitly group the values inserted into the C{Forward}::
+        fwdExpr << (a | b | c)
+    Converting to use the '<<=' operator instead will avoid this problem.
+
+    See L{ParseResults.pprint} for an example of a recursive parser created using
+    C{Forward}.
+    """
+    def __init__( self, other=None ):
+        super(Forward,self).__init__( other, savelist=False )
+
+    def __lshift__( self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass(other)
+        self.expr = other
+        self.strRepr = None
+        self.mayIndexError = self.expr.mayIndexError
+        self.mayReturnEmpty = self.expr.mayReturnEmpty
+        self.setWhitespaceChars( self.expr.whiteChars )
+        self.skipWhitespace = self.expr.skipWhitespace
+        self.saveAsList = self.expr.saveAsList
+        self.ignoreExprs.extend(self.expr.ignoreExprs)
+        return self
+        
+    def __ilshift__(self, other):
+        return self << other
+    
+    def leaveWhitespace( self ):
+        self.skipWhitespace = False
+        return self
+
+    def streamline( self ):
+        if not self.streamlined:
+            self.streamlined = True
+            if self.expr is not None:
+                self.expr.streamline()
+        return self
+
+    def validate( self, validateTrace=[] ):
+        if self not in validateTrace:
+            tmp = validateTrace[:]+[self]
+            if self.expr is not None:
+                self.expr.validate(tmp)
+        self.checkRecursion([])
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+        return self.__class__.__name__ + ": ..."
+
+        # stubbed out for now - creates awful memory and perf issues
+        self._revertClass = self.__class__
+        self.__class__ = _ForwardNoRecurse
+        try:
+            if self.expr is not None:
+                retString = _ustr(self.expr)
+            else:
+                retString = "None"
+        finally:
+            self.__class__ = self._revertClass
+        return self.__class__.__name__ + ": " + retString
+
+    def copy(self):
+        if self.expr is not None:
+            return super(Forward,self).copy()
+        else:
+            ret = Forward()
+            ret <<= self
+            return ret
+
+class _ForwardNoRecurse(Forward):
+    def __str__( self ):
+        return "..."
+
+class TokenConverter(ParseElementEnhance):
+    """
+    Abstract subclass of C{ParseExpression}, for converting parsed results.
+    """
+    def __init__( self, expr, savelist=False ):
+        super(TokenConverter,self).__init__( expr )#, savelist )
+        self.saveAsList = False
+
+class Combine(TokenConverter):
+    """
+    Converter to concatenate all matching tokens to a single string.
+    By default, the matching patterns must also be contiguous in the input string;
+    this can be disabled by specifying C{'adjacent=False'} in the constructor.
+
+    Example::
+        real = Word(nums) + '.' + Word(nums)
+        print(real.parseString('3.1416')) # -> ['3', '.', '1416']
+        # will also erroneously match the following
+        print(real.parseString('3. 1416')) # -> ['3', '.', '1416']
+
+        real = Combine(Word(nums) + '.' + Word(nums))
+        print(real.parseString('3.1416')) # -> ['3.1416']
+        # no match when there are internal spaces
+        print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...)
+    """
+    def __init__( self, expr, joinString="", adjacent=True ):
+        super(Combine,self).__init__( expr )
+        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself
+        if adjacent:
+            self.leaveWhitespace()
+        self.adjacent = adjacent
+        self.skipWhitespace = True
+        self.joinString = joinString
+        self.callPreparse = True
+
+    def ignore( self, other ):
+        if self.adjacent:
+            ParserElement.ignore(self, other)
+        else:
+            super( Combine, self).ignore( other )
+        return self
+
+    def postParse( self, instring, loc, tokenlist ):
+        retToks = tokenlist.copy()
+        del retToks[:]
+        retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults)
+
+        if self.resultsName and retToks.haskeys():
+            return [ retToks ]
+        else:
+            return retToks
+
+class Group(TokenConverter):
+    """
+    Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions.
+
+    Example::
+        ident = Word(alphas)
+        num = Word(nums)
+        term = ident | num
+        func = ident + Optional(delimitedList(term))
+        print(func.parseString("fn a,b,100"))  # -> ['fn', 'a', 'b', '100']
+
+        func = ident + Group(Optional(delimitedList(term)))
+        print(func.parseString("fn a,b,100"))  # -> ['fn', ['a', 'b', '100']]
+    """
+    def __init__( self, expr ):
+        super(Group,self).__init__( expr )
+        self.saveAsList = True
+
+    def postParse( self, instring, loc, tokenlist ):
+        return [ tokenlist ]
+
+class Dict(TokenConverter):
+    """
+    Converter to return a repetitive expression as a list, but also as a dictionary.
+    Each element can also be referenced using the first token in the expression as its key.
+    Useful for tabular report scraping when the first column can be used as a item key.
+
+    Example::
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
+
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        
+        # print attributes as plain groups
+        print(OneOrMore(attr_expr).parseString(text).dump())
+        
+        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names
+        result = Dict(OneOrMore(Group(attr_expr))).parseString(text)
+        print(result.dump())
+        
+        # access named fields as dict entries, or output as dict
+        print(result['shape'])        
+        print(result.asDict())
+    prints::
+        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']
+
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
+        - color: light blue
+        - posn: upper left
+        - shape: SQUARE
+        - texture: burlap
+        SQUARE
+        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}
+    See more examples at L{ParseResults} of accessing fields by results name.
+    """
+    def __init__( self, expr ):
+        super(Dict,self).__init__( expr )
+        self.saveAsList = True
+
+    def postParse( self, instring, loc, tokenlist ):
+        for i,tok in enumerate(tokenlist):
+            if len(tok) == 0:
+                continue
+            ikey = tok[0]
+            if isinstance(ikey,int):
+                ikey = _ustr(tok[0]).strip()
+            if len(tok)==1:
+                tokenlist[ikey] = _ParseResultsWithOffset("",i)
+            elif len(tok)==2 and not isinstance(tok[1],ParseResults):
+                tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i)
+            else:
+                dictvalue = tok.copy() #ParseResults(i)
+                del dictvalue[0]
+                if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.haskeys()):
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i)
+                else:
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i)
+
+        if self.resultsName:
+            return [ tokenlist ]
+        else:
+            return tokenlist
+
+
+class Suppress(TokenConverter):
+    """
+    Converter for ignoring the results of a parsed expression.
+
+    Example::
+        source = "a, b, c,d"
+        wd = Word(alphas)
+        wd_list1 = wd + ZeroOrMore(',' + wd)
+        print(wd_list1.parseString(source))
+
+        # often, delimiters that are useful during parsing are just in the
+        # way afterward - use Suppress to keep them out of the parsed output
+        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd)
+        print(wd_list2.parseString(source))
+    prints::
+        ['a', ',', 'b', ',', 'c', ',', 'd']
+        ['a', 'b', 'c', 'd']
+    (See also L{delimitedList}.)
+    """
+    def postParse( self, instring, loc, tokenlist ):
+        return []
+
+    def suppress( self ):
+        return self
+
+
+class OnlyOnce(object):
+    """
+    Wrapper for parse actions, to ensure they are only called once.
+    """
+    def __init__(self, methodCall):
+        self.callable = _trim_arity(methodCall)
+        self.called = False
+    def __call__(self,s,l,t):
+        if not self.called:
+            results = self.callable(s,l,t)
+            self.called = True
+            return results
+        raise ParseException(s,l,"")
+    def reset(self):
+        self.called = False
+
+def traceParseAction(f):
+    """
+    Decorator for debugging parse actions. 
+    
+    When the parse action is called, this decorator will print C{">> entering I{method-name}(line:I{current_source_line}, I{parse_location}, I{matched_tokens})".}
+    When the parse action completes, the decorator will print C{"<<"} followed by the returned value, or any exception that the parse action raised.
+
+    Example::
+        wd = Word(alphas)
+
+        @traceParseAction
+        def remove_duplicate_chars(tokens):
+            return ''.join(sorted(set(''.join(tokens))))
+
+        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
+        print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
+    prints::
+        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))
+        <<leaving remove_duplicate_chars (ret: 'dfjkls')
+        ['dfjkls']
+    """
+    f = _trim_arity(f)
+    def z(*paArgs):
+        thisFunc = f.__name__
+        s,l,t = paArgs[-3:]
+        if len(paArgs)>3:
+            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc
+        sys.stderr.write( ">>entering %s(line: '%s', %d, %r)\n" % (thisFunc,line(l,s),l,t) )
+        try:
+            ret = f(*paArgs)
+        except Exception as exc:
+            sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) )
+            raise
+        sys.stderr.write( "<<leaving %s (ret: %r)\n" % (thisFunc,ret) )
+        return ret
+    try:
+        z.__name__ = f.__name__
+    except AttributeError:
+        pass
+    return z
+
+#
+# global helpers
+#
+def delimitedList( expr, delim=",", combine=False ):
+    """
+    Helper to define a delimited list of expressions - the delimiter defaults to ','.
+    By default, the list elements and delimiters can have intervening whitespace, and
+    comments, but this can be overridden by passing C{combine=True} in the constructor.
+    If C{combine} is set to C{True}, the matching tokens are returned as a single token
+    string, with the delimiters included; otherwise, the matching tokens are returned
+    as a list of tokens, with the delimiters suppressed.
+
+    Example::
+        delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc']
+        delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
+    """
+    dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..."
+    if combine:
+        return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName)
+    else:
+        return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName)
+
+def countedArray( expr, intExpr=None ):
+    """
+    Helper to define a counted list of expressions.
+    This helper defines a pattern of the form::
+        integer expr expr expr...
+    where the leading integer tells how many expr expressions follow.
+    The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.
+    
+    If C{intExpr} is specified, it should be a pyparsing expression that produces an integer value.
+
+    Example::
+        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -> ['ab', 'cd']
+
+        # in this parser, the leading integer value is given in binary,
+        # '10' indicating that 2 values are in the array
+        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2))
+        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -> ['ab', 'cd']
+    """
+    arrayExpr = Forward()
+    def countFieldParseAction(s,l,t):
+        n = t[0]
+        arrayExpr << (n and Group(And([expr]*n)) or Group(empty))
+        return []
+    if intExpr is None:
+        intExpr = Word(nums).setParseAction(lambda t:int(t[0]))
+    else:
+        intExpr = intExpr.copy()
+    intExpr.setName("arrayLen")
+    intExpr.addParseAction(countFieldParseAction, callDuringTry=True)
+    return ( intExpr + arrayExpr ).setName('(len) ' + _ustr(expr) + '...')
+
+def _flatten(L):
+    ret = []
+    for i in L:
+        if isinstance(i,list):
+            ret.extend(_flatten(i))
+        else:
+            ret.append(i)
+    return ret
+
+def matchPreviousLiteral(expr):
+    """
+    Helper to define an expression that is indirectly defined from
+    the tokens matched in a previous expression, that is, it looks
+    for a 'repeat' of a previous expression.  For example::
+        first = Word(nums)
+        second = matchPreviousLiteral(first)
+        matchExpr = first + ":" + second
+    will match C{"1:1"}, but not C{"1:2"}.  Because this matches a
+    previous literal, will also match the leading C{"1:1"} in C{"1:10"}.
+    If this is not desired, use C{matchPreviousExpr}.
+    Do I{not} use with packrat parsing enabled.
+    """
+    rep = Forward()
+    def copyTokenToRepeater(s,l,t):
+        if t:
+            if len(t) == 1:
+                rep << t[0]
+            else:
+                # flatten t tokens
+                tflat = _flatten(t.asList())
+                rep << And(Literal(tt) for tt in tflat)
+        else:
+            rep << Empty()
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
+    rep.setName('(prev) ' + _ustr(expr))
+    return rep
+
+def matchPreviousExpr(expr):
+    """
+    Helper to define an expression that is indirectly defined from
+    the tokens matched in a previous expression, that is, it looks
+    for a 'repeat' of a previous expression.  For example::
+        first = Word(nums)
+        second = matchPreviousExpr(first)
+        matchExpr = first + ":" + second
+    will match C{"1:1"}, but not C{"1:2"}.  Because this matches by
+    expressions, will I{not} match the leading C{"1:1"} in C{"1:10"};
+    the expressions are evaluated first, and then compared, so
+    C{"1"} is compared with C{"10"}.
+    Do I{not} use with packrat parsing enabled.
+    """
+    rep = Forward()
+    e2 = expr.copy()
+    rep <<= e2
+    def copyTokenToRepeater(s,l,t):
+        matchTokens = _flatten(t.asList())
+        def mustMatchTheseTokens(s,l,t):
+            theseTokens = _flatten(t.asList())
+            if  theseTokens != matchTokens:
+                raise ParseException("",0,"")
+        rep.setParseAction( mustMatchTheseTokens, callDuringTry=True )
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
+    rep.setName('(prev) ' + _ustr(expr))
+    return rep
+
+def _escapeRegexRangeChars(s):
+    #~  escape these chars: ^-]
+    for c in r"\^-]":
+        s = s.replace(c,_bslash+c)
+    s = s.replace("\n",r"\n")
+    s = s.replace("\t",r"\t")
+    return _ustr(s)
+
+def oneOf( strs, caseless=False, useRegex=True ):
+    """
+    Helper to quickly define a set of alternative Literals, and makes sure to do
+    longest-first testing when there is a conflict, regardless of the input order,
+    but returns a C{L{MatchFirst}} for best performance.
+
+    Parameters:
+     - strs - a string of space-delimited literals, or a collection of string literals
+     - caseless - (default=C{False}) - treat all literals as caseless
+     - useRegex - (default=C{True}) - as an optimization, will generate a Regex
+          object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or
+          if creating a C{Regex} raises an exception)
+
+    Example::
+        comp_oper = oneOf("< = > <= >= !=")
+        var = Word(alphas)
+        number = Word(nums)
+        term = var | number
+        comparison_expr = term + comp_oper + term
+        print(comparison_expr.searchString("B = 12  AA=23 B<=AA AA>12"))
+    prints::
+        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
+    """
+    if caseless:
+        isequal = ( lambda a,b: a.upper() == b.upper() )
+        masks = ( lambda a,b: b.upper().startswith(a.upper()) )
+        parseElementClass = CaselessLiteral
+    else:
+        isequal = ( lambda a,b: a == b )
+        masks = ( lambda a,b: b.startswith(a) )
+        parseElementClass = Literal
+
+    symbols = []
+    if isinstance(strs,basestring):
+        symbols = strs.split()
+    elif isinstance(strs, Iterable):
+        symbols = list(strs)
+    else:
+        warnings.warn("Invalid argument to oneOf, expected string or iterable",
+                SyntaxWarning, stacklevel=2)
+    if not symbols:
+        return NoMatch()
+
+    i = 0
+    while i < len(symbols)-1:
+        cur = symbols[i]
+        for j,other in enumerate(symbols[i+1:]):
+            if ( isequal(other, cur) ):
+                del symbols[i+j+1]
+                break
+            elif ( masks(cur, other) ):
+                del symbols[i+j+1]
+                symbols.insert(i,other)
+                cur = other
+                break
+        else:
+            i += 1
+
+    if not caseless and useRegex:
+        #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] ))
+        try:
+            if len(symbols)==len("".join(symbols)):
+                return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) ).setName(' | '.join(symbols))
+            else:
+                return Regex( "|".join(re.escape(sym) for sym in symbols) ).setName(' | '.join(symbols))
+        except Exception:
+            warnings.warn("Exception creating Regex for oneOf, building MatchFirst",
+                    SyntaxWarning, stacklevel=2)
+
+
+    # last resort, just use MatchFirst
+    return MatchFirst(parseElementClass(sym) for sym in symbols).setName(' | '.join(symbols))
+
+def dictOf( key, value ):
+    """
+    Helper to easily and clearly define a dictionary by specifying the respective patterns
+    for the key and value.  Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens
+    in the proper order.  The key pattern can include delimiting markers or punctuation,
+    as long as they are suppressed, thereby leaving the significant key text.  The value
+    pattern can include named results, so that the C{Dict} results can include named token
+    fields.
+
+    Example::
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        print(OneOrMore(attr_expr).parseString(text).dump())
+        
+        attr_label = label
+        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)
+
+        # similar to Dict, but simpler call format
+        result = dictOf(attr_label, attr_value).parseString(text)
+        print(result.dump())
+        print(result['shape'])
+        print(result.shape)  # object attribute access works too
+        print(result.asDict())
+    prints::
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
+        - color: light blue
+        - posn: upper left
+        - shape: SQUARE
+        - texture: burlap
+        SQUARE
+        SQUARE
+        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
+    """
+    return Dict( ZeroOrMore( Group ( key + value ) ) )
+
+def originalTextFor(expr, asString=True):
+    """
+    Helper to return the original, untokenized text for a given expression.  Useful to
+    restore the parsed fields of an HTML start tag into the raw tag text itself, or to
+    revert separate tokens with intervening whitespace back to the original matching
+    input text. By default, returns astring containing the original parsed text.  
+       
+    If the optional C{asString} argument is passed as C{False}, then the return value is a 
+    C{L{ParseResults}} containing any results names that were originally matched, and a 
+    single token containing the original matched text from the input string.  So if 
+    the expression passed to C{L{originalTextFor}} contains expressions with defined
+    results names, you must set C{asString} to C{False} if you want to preserve those
+    results name values.
+
+    Example::
+        src = "this is test <b> bold <i>text</i> </b> normal text "
+        for tag in ("b","i"):
+            opener,closer = makeHTMLTags(tag)
+            patt = originalTextFor(opener + SkipTo(closer) + closer)
+            print(patt.searchString(src)[0])
+    prints::
+        ['<b> bold <i>text</i> </b>']
+        ['<i>text</i>']
+    """
+    locMarker = Empty().setParseAction(lambda s,loc,t: loc)
+    endlocMarker = locMarker.copy()
+    endlocMarker.callPreparse = False
+    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")
+    if asString:
+        extractText = lambda s,l,t: s[t._original_start:t._original_end]
+    else:
+        def extractText(s,l,t):
+            t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]]
+    matchExpr.setParseAction(extractText)
+    matchExpr.ignoreExprs = expr.ignoreExprs
+    return matchExpr
+
+def ungroup(expr): 
+    """
+    Helper to undo pyparsing's default grouping of And expressions, even
+    if all but one are non-empty.
+    """
+    return TokenConverter(expr).setParseAction(lambda t:t[0])
+
+def locatedExpr(expr):
+    """
+    Helper to decorate a returned token with its starting and ending locations in the input string.
+    This helper adds the following results names:
+     - locn_start = location where matched expression begins
+     - locn_end = location where matched expression ends
+     - value = the actual parsed results
+
+    Be careful if the input text contains C{<TAB>} characters, you may want to call
+    C{L{ParserElement.parseWithTabs}}
+
+    Example::
+        wd = Word(alphas)
+        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
+            print(match)
+    prints::
+        [[0, 'ljsdf', 5]]
+        [[8, 'lksdjjf', 15]]
+        [[18, 'lkkjj', 23]]
+    """
+    locator = Empty().setParseAction(lambda s,l,t: l)
+    return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end"))
+
+
+# convenience constants for positional expressions
+empty       = Empty().setName("empty")
+lineStart   = LineStart().setName("lineStart")
+lineEnd     = LineEnd().setName("lineEnd")
+stringStart = StringStart().setName("stringStart")
+stringEnd   = StringEnd().setName("stringEnd")
+
+_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])
+_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))
+_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))
+_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1)
+_charRange = Group(_singleChar + Suppress("-") + _singleChar)
+_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"
+
+def srange(s):
+    r"""
+    Helper to easily define string ranges for use in Word construction.  Borrows
+    syntax from regexp '[]' string range definitions::
+        srange("[0-9]")   -> "0123456789"
+        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz"
+        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"
+    The input string must be enclosed in []'s, and the returned string is the expanded
+    character set joined into a single string.
+    The values enclosed in the []'s may be:
+     - a single character
+     - an escaped character with a leading backslash (such as C{\-} or C{\]})
+     - an escaped hex character with a leading C{'\x'} (C{\x21}, which is a C{'!'} character) 
+         (C{\0x##} is also supported for backwards compatibility) 
+     - an escaped octal character with a leading C{'\0'} (C{\041}, which is a C{'!'} character)
+     - a range of any of the above, separated by a dash (C{'a-z'}, etc.)
+     - any combination of the above (C{'aeiouy'}, C{'a-zA-Z0-9_$'}, etc.)
+    """
+    _expanded = lambda p: p if not isinstance(p,ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]),ord(p[1])+1))
+    try:
+        return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body)
+    except Exception:
+        return ""
+
+def matchOnlyAtCol(n):
+    """
+    Helper method for defining parse actions that require matching at a specific
+    column in the input text.
+    """
+    def verifyCol(strg,locn,toks):
+        if col(locn,strg) != n:
+            raise ParseException(strg,locn,"matched token not at column %d" % n)
+    return verifyCol
+
+def replaceWith(replStr):
+    """
+    Helper method for common parse actions that simply return a literal value.  Especially
+    useful when used with C{L{transformString<ParserElement.transformString>}()}.
+
+    Example::
+        num = Word(nums).setParseAction(lambda toks: int(toks[0]))
+        na = oneOf("N/A NA").setParseAction(replaceWith(math.nan))
+        term = na | num
+        
+        OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234]
+    """
+    return lambda s,l,t: [replStr]
+
+def removeQuotes(s,l,t):
+    """
+    Helper parse action for removing quotation marks from parsed quoted strings.
+
+    Example::
+        # by default, quotation marks are included in parsed results
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"]
+
+        # use removeQuotes to strip quotation marks from parsed results
+        quotedString.setParseAction(removeQuotes)
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"]
+    """
+    return t[0][1:-1]
+
+def tokenMap(func, *args):
+    """
+    Helper to define a parse action by mapping a function to all elements of a ParseResults list.If any additional 
+    args are passed, they are forwarded to the given function as additional arguments after
+    the token, as in C{hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))}, which will convert the
+    parsed data to an integer using base 16.
+
+    Example (compare the last to example in L{ParserElement.transformString}::
+        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16))
+        hex_ints.runTests('''
+            00 11 22 aa FF 0a 0d 1a
+            ''')
+        
+        upperword = Word(alphas).setParseAction(tokenMap(str.upper))
+        OneOrMore(upperword).runTests('''
+            my kingdom for a horse
+            ''')
+
+        wd = Word(alphas).setParseAction(tokenMap(str.title))
+        OneOrMore(wd).setParseAction(' '.join).runTests('''
+            now is the winter of our discontent made glorious summer by this sun of york
+            ''')
+    prints::
+        00 11 22 aa FF 0a 0d 1a
+        [0, 17, 34, 170, 255, 10, 13, 26]
+
+        my kingdom for a horse
+        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE']
+
+        now is the winter of our discontent made glorious summer by this sun of york
+        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York']
+    """
+    def pa(s,l,t):
+        return [func(tokn, *args) for tokn in t]
+
+    try:
+        func_name = getattr(func, '__name__', 
+                            getattr(func, '__class__').__name__)
+    except Exception:
+        func_name = str(func)
+    pa.__name__ = func_name
+
+    return pa
+
+upcaseTokens = tokenMap(lambda t: _ustr(t).upper())
+"""(Deprecated) Helper parse action to convert tokens to upper case. Deprecated in favor of L{pyparsing_common.upcaseTokens}"""
+
+downcaseTokens = tokenMap(lambda t: _ustr(t).lower())
+"""(Deprecated) Helper parse action to convert tokens to lower case. Deprecated in favor of L{pyparsing_common.downcaseTokens}"""
+    
+def _makeTags(tagStr, xml):
+    """Internal helper to construct opening and closing tag expressions, given a tag name"""
+    if isinstance(tagStr,basestring):
+        resname = tagStr
+        tagStr = Keyword(tagStr, caseless=not xml)
+    else:
+        resname = tagStr.name
+
+    tagAttrName = Word(alphas,alphanums+"_-:")
+    if (xml):
+        tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )
+        openTag = Suppress("<") + tagStr("tag") + \
+                Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \
+                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
+    else:
+        printablesLessRAbrack = "".join(c for c in printables if c not in ">")
+        tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)
+        openTag = Suppress("<") + tagStr("tag") + \
+                Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \
+                Optional( Suppress("=") + tagAttrValue ) ))) + \
+                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
+    closeTag = Combine(_L("</") + tagStr + ">")
+
+    openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % resname)
+    closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("</%s>" % resname)
+    openTag.tag = resname
+    closeTag.tag = resname
+    return openTag, closeTag
+
+def makeHTMLTags(tagStr):
+    """
+    Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches
+    tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values.
+
+    Example::
+        text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'
+        # makeHTMLTags returns pyparsing expressions for the opening and closing tags as a 2-tuple
+        a,a_end = makeHTMLTags("A")
+        link_expr = a + SkipTo(a_end)("link_text") + a_end
+        
+        for link in link_expr.searchString(text):
+            # attributes in the <A> tag (like "href" shown here) are also accessible as named results
+            print(link.link_text, '->', link.href)
+    prints::
+        pyparsing -> http://pyparsing.wikispaces.com
+    """
+    return _makeTags( tagStr, False )
+
+def makeXMLTags(tagStr):
+    """
+    Helper to construct opening and closing tag expressions for XML, given a tag name. Matches
+    tags only in the given upper/lower case.
+
+    Example: similar to L{makeHTMLTags}
+    """
+    return _makeTags( tagStr, True )
+
+def withAttribute(*args,**attrDict):
+    """
+    Helper to create a validating parse action to be used with start tags created
+    with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag
+    with a required attribute value, to avoid false matches on common tags such as
+    C{<TD>} or C{<DIV>}.
+
+    Call C{withAttribute} with a series of attribute names and values. Specify the list
+    of filter attributes names and values as:
+     - keyword arguments, as in C{(align="right")}, or
+     - as an explicit dict with C{**} operator, when an attribute name is also a Python
+          reserved word, as in C{**{"class":"Customer", "align":"right"}}
+     - a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") )
+    For attribute names with a namespace prefix, you must use the second form.  Attribute
+    names are matched insensitive to upper/lower case.
+       
+    If just testing for C{class} (with or without a namespace), use C{L{withClass}}.
+
+    To verify that the attribute exists, but without specifying a value, pass
+    C{withAttribute.ANY_VALUE} as the value.
+
+    Example::
+        html = '''
+            <div>
+            Some text
+            <div type="grid">1 4 0 1 0</div>
+            <div type="graph">1,3 2,3 1,1</div>
+            <div>this has no type</div>
+            </div>
+                
+        '''
+        div,div_end = makeHTMLTags("div")
+
+        # only match div tag having a type attribute with value "grid"
+        div_grid = div().setParseAction(withAttribute(type="grid"))
+        grid_expr = div_grid + SkipTo(div | div_end)("body")
+        for grid_header in grid_expr.searchString(html):
+            print(grid_header.body)
+        
+        # construct a match with any div tag having a type attribute, regardless of the value
+        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE))
+        div_expr = div_any_type + SkipTo(div | div_end)("body")
+        for div_header in div_expr.searchString(html):
+            print(div_header.body)
+    prints::
+        1 4 0 1 0
+
+        1 4 0 1 0
+        1,3 2,3 1,1
+    """
+    if args:
+        attrs = args[:]
+    else:
+        attrs = attrDict.items()
+    attrs = [(k,v) for k,v in attrs]
+    def pa(s,l,tokens):
+        for attrName,attrValue in attrs:
+            if attrName not in tokens:
+                raise ParseException(s,l,"no matching attribute " + attrName)
+            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:
+                raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" %
+                                            (attrName, tokens[attrName], attrValue))
+    return pa
+withAttribute.ANY_VALUE = object()
+
+def withClass(classname, namespace=''):
+    """
+    Simplified version of C{L{withAttribute}} when matching on a div class - made
+    difficult because C{class} is a reserved word in Python.
+
+    Example::
+        html = '''
+            <div>
+            Some text
+            <div class="grid">1 4 0 1 0</div>
+            <div class="graph">1,3 2,3 1,1</div>
+            <div>this &lt;div&gt; has no class</div>
+            </div>
+                
+        '''
+        div,div_end = makeHTMLTags("div")
+        div_grid = div().setParseAction(withClass("grid"))
+        
+        grid_expr = div_grid + SkipTo(div | div_end)("body")
+        for grid_header in grid_expr.searchString(html):
+            print(grid_header.body)
+        
+        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE))
+        div_expr = div_any_type + SkipTo(div | div_end)("body")
+        for div_header in div_expr.searchString(html):
+            print(div_header.body)
+    prints::
+        1 4 0 1 0
+
+        1 4 0 1 0
+        1,3 2,3 1,1
+    """
+    classattr = "%s:class" % namespace if namespace else "class"
+    return withAttribute(**{classattr : classname})        
+
+opAssoc = _Constants()
+opAssoc.LEFT = object()
+opAssoc.RIGHT = object()
+
+def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ):
+    """
+    Helper method for constructing grammars of expressions made up of
+    operators working in a precedence hierarchy.  Operators may be unary or
+    binary, left- or right-associative.  Parse actions can also be attached
+    to operator expressions. The generated parser will also recognize the use 
+    of parentheses to override operator precedences (see example below).
+    
+    Note: if you define a deep operator list, you may see performance issues
+    when using infixNotation. See L{ParserElement.enablePackrat} for a
+    mechanism to potentially improve your parser performance.
+
+    Parameters:
+     - baseExpr - expression representing the most basic element for the nested
+     - opList - list of tuples, one for each operator precedence level in the
+      expression grammar; each tuple is of the form
+      (opExpr, numTerms, rightLeftAssoc, parseAction), where:
+       - opExpr is the pyparsing expression for the operator;
+          may also be a string, which will be converted to a Literal;
+          if numTerms is 3, opExpr is a tuple of two expressions, for the
+          two operators separating the 3 terms
+       - numTerms is the number of terms for this operator (must
+          be 1, 2, or 3)
+       - rightLeftAssoc is the indicator whether the operator is
+          right or left associative, using the pyparsing-defined
+          constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}.
+       - parseAction is the parse action to be associated with
+          expressions matching this operator expression (the
+          parse action tuple member may be omitted); if the parse action
+          is passed a tuple or list of functions, this is equivalent to
+          calling C{setParseAction(*fn)} (L{ParserElement.setParseAction})
+     - lpar - expression for matching left-parentheses (default=C{Suppress('(')})
+     - rpar - expression for matching right-parentheses (default=C{Suppress(')')})
+
+    Example::
+        # simple example of four-function arithmetic with ints and variable names
+        integer = pyparsing_common.signed_integer
+        varname = pyparsing_common.identifier 
+        
+        arith_expr = infixNotation(integer | varname,
+            [
+            ('-', 1, opAssoc.RIGHT),
+            (oneOf('* /'), 2, opAssoc.LEFT),
+            (oneOf('+ -'), 2, opAssoc.LEFT),
+            ])
+        
+        arith_expr.runTests('''
+            5+3*6
+            (5+3)*6
+            -2--11
+            ''', fullDump=False)
+    prints::
+        5+3*6
+        [[5, '+', [3, '*', 6]]]
+
+        (5+3)*6
+        [[[5, '+', 3], '*', 6]]
+
+        -2--11
+        [[['-', 2], '-', ['-', 11]]]
+    """
+    ret = Forward()
+    lastExpr = baseExpr | ( lpar + ret + rpar )
+    for i,operDef in enumerate(opList):
+        opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]
+        termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr
+        if arity == 3:
+            if opExpr is None or len(opExpr) != 2:
+                raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions")
+            opExpr1, opExpr2 = opExpr
+        thisExpr = Forward().setName(termName)
+        if rightLeftAssoc == opAssoc.LEFT:
+            if arity == 1:
+                matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) )
+            elif arity == 2:
+                if opExpr is not None:
+                    matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) )
+                else:
+                    matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) )
+            elif arity == 3:
+                matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \
+                            Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr )
+            else:
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
+        elif rightLeftAssoc == opAssoc.RIGHT:
+            if arity == 1:
+                # try to avoid LR with this extra test
+                if not isinstance(opExpr, Optional):
+                    opExpr = Optional(opExpr)
+                matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr )
+            elif arity == 2:
+                if opExpr is not None:
+                    matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) )
+                else:
+                    matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) )
+            elif arity == 3:
+                matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \
+                            Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr )
+            else:
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
+        else:
+            raise ValueError("operator must indicate right or left associativity")
+        if pa:
+            if isinstance(pa, (tuple, list)):
+                matchExpr.setParseAction(*pa)
+            else:
+                matchExpr.setParseAction(pa)
+        thisExpr <<= ( matchExpr.setName(termName) | lastExpr )
+        lastExpr = thisExpr
+    ret <<= lastExpr
+    return ret
+
+operatorPrecedence = infixNotation
+"""(Deprecated) Former name of C{L{infixNotation}}, will be dropped in a future release."""
+
+dblQuotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"').setName("string enclosed in double quotes")
+sglQuotedString = Combine(Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("string enclosed in single quotes")
+quotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"'|
+                       Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("quotedString using single or double quotes")
+unicodeString = Combine(_L('u') + quotedString.copy()).setName("unicode string literal")
+
+def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()):
+    """
+    Helper method for defining nested lists enclosed in opening and closing
+    delimiters ("(" and ")" are the default).
+
+    Parameters:
+     - opener - opening character for a nested list (default=C{"("}); can also be a pyparsing expression
+     - closer - closing character for a nested list (default=C{")"}); can also be a pyparsing expression
+     - content - expression for items within the nested lists (default=C{None})
+     - ignoreExpr - expression for ignoring opening and closing delimiters (default=C{quotedString})
+
+    If an expression is not provided for the content argument, the nested
+    expression will capture all whitespace-delimited content between delimiters
+    as a list of separate values.
+
+    Use the C{ignoreExpr} argument to define expressions that may contain
+    opening or closing characters that should not be treated as opening
+    or closing characters for nesting, such as quotedString or a comment
+    expression.  Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}.
+    The default is L{quotedString}, but if no expressions are to be ignored,
+    then pass C{None} for this argument.
+
+    Example::
+        data_type = oneOf("void int short long char float double")
+        decl_data_type = Combine(data_type + Optional(Word('*')))
+        ident = Word(alphas+'_', alphanums+'_')
+        number = pyparsing_common.number
+        arg = Group(decl_data_type + ident)
+        LPAR,RPAR = map(Suppress, "()")
+
+        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment))
+
+        c_function = (decl_data_type("type") 
+                      + ident("name")
+                      + LPAR + Optional(delimitedList(arg), [])("args") + RPAR 
+                      + code_body("body"))
+        c_function.ignore(cStyleComment)
+        
+        source_code = '''
+            int is_odd(int x) { 
+                return (x%2); 
+            }
+                
+            int dec_to_hex(char hchar) { 
+                if (hchar >= '0' && hchar <= '9') { 
+                    return (ord(hchar)-ord('0')); 
+                } else { 
+                    return (10+ord(hchar)-ord('A'));
+                } 
+            }
+        '''
+        for func in c_function.searchString(source_code):
+            print("%(name)s (%(type)s) args: %(args)s" % func)
+
+    prints::
+        is_odd (int) args: [['int', 'x']]
+        dec_to_hex (int) args: [['char', 'hchar']]
+    """
+    if opener == closer:
+        raise ValueError("opening and closing strings cannot be the same")
+    if content is None:
+        if isinstance(opener,basestring) and isinstance(closer,basestring):
+            if len(opener) == 1 and len(closer)==1:
+                if ignoreExpr is not None:
+                    content = (Combine(OneOrMore(~ignoreExpr +
+                                    CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1))
+                                ).setParseAction(lambda t:t[0].strip()))
+                else:
+                    content = (empty.copy()+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS
+                                ).setParseAction(lambda t:t[0].strip()))
+            else:
+                if ignoreExpr is not None:
+                    content = (Combine(OneOrMore(~ignoreExpr + 
+                                    ~Literal(opener) + ~Literal(closer) +
+                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
+                                ).setParseAction(lambda t:t[0].strip()))
+                else:
+                    content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) +
+                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
+                                ).setParseAction(lambda t:t[0].strip()))
+        else:
+            raise ValueError("opening and closing arguments must be strings if no content expression is given")
+    ret = Forward()
+    if ignoreExpr is not None:
+        ret <<= Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) )
+    else:
+        ret <<= Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) )
+    ret.setName('nested %s%s expression' % (opener,closer))
+    return ret
+
+def indentedBlock(blockStatementExpr, indentStack, indent=True):
+    """
+    Helper method for defining space-delimited indentation blocks, such as
+    those used to define block statements in Python source code.
+
+    Parameters:
+     - blockStatementExpr - expression defining syntax of statement that
+            is repeated within the indented block
+     - indentStack - list created by caller to manage indentation stack
+            (multiple statementWithIndentedBlock expressions within a single grammar
+            should share a common indentStack)
+     - indent - boolean indicating whether block must be indented beyond the
+            the current level; set to False for block of left-most statements
+            (default=C{True})
+
+    A valid block must contain at least one C{blockStatement}.
+
+    Example::
+        data = '''
+        def A(z):
+          A1
+          B = 100
+          G = A2
+          A2
+          A3
+        B
+        def BB(a,b,c):
+          BB1
+          def BBA():
+            bba1
+            bba2
+            bba3
+        C
+        D
+        def spam(x,y):
+             def eggs(z):
+                 pass
+        '''
+
+
+        indentStack = [1]
+        stmt = Forward()
+
+        identifier = Word(alphas, alphanums)
+        funcDecl = ("def" + identifier + Group( "(" + Optional( delimitedList(identifier) ) + ")" ) + ":")
+        func_body = indentedBlock(stmt, indentStack)
+        funcDef = Group( funcDecl + func_body )
+
+        rvalue = Forward()
+        funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")")
+        rvalue << (funcCall | identifier | Word(nums))
+        assignment = Group(identifier + "=" + rvalue)
+        stmt << ( funcDef | assignment | identifier )
+
+        module_body = OneOrMore(stmt)
+
+        parseTree = module_body.parseString(data)
+        parseTree.pprint()
+    prints::
+        [['def',
+          'A',
+          ['(', 'z', ')'],
+          ':',
+          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],
+         'B',
+         ['def',
+          'BB',
+          ['(', 'a', 'b', 'c', ')'],
+          ':',
+          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],
+         'C',
+         'D',
+         ['def',
+          'spam',
+          ['(', 'x', 'y', ')'],
+          ':',
+          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]] 
+    """
+    def checkPeerIndent(s,l,t):
+        if l >= len(s): return
+        curCol = col(l,s)
+        if curCol != indentStack[-1]:
+            if curCol > indentStack[-1]:
+                raise ParseFatalException(s,l,"illegal nesting")
+            raise ParseException(s,l,"not a peer entry")
+
+    def checkSubIndent(s,l,t):
+        curCol = col(l,s)
+        if curCol > indentStack[-1]:
+            indentStack.append( curCol )
+        else:
+            raise ParseException(s,l,"not a subentry")
+
+    def checkUnindent(s,l,t):
+        if l >= len(s): return
+        curCol = col(l,s)
+        if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]):
+            raise ParseException(s,l,"not an unindent")
+        indentStack.pop()
+
+    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress())
+    INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName('INDENT')
+    PEER   = Empty().setParseAction(checkPeerIndent).setName('')
+    UNDENT = Empty().setParseAction(checkUnindent).setName('UNINDENT')
+    if indent:
+        smExpr = Group( Optional(NL) +
+            #~ FollowedBy(blockStatementExpr) +
+            INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT)
+    else:
+        smExpr = Group( Optional(NL) +
+            (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) )
+    blockStatementExpr.ignore(_bslash + LineEnd())
+    return smExpr.setName('indented block')
+
+alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")
+punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")
+
+anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:").setName('any tag'))
+_htmlEntityMap = dict(zip("gt lt amp nbsp quot apos".split(),'><& "\''))
+commonHTMLEntity = Regex('&(?P<entity>' + '|'.join(_htmlEntityMap.keys()) +");").setName("common HTML entity")
+def replaceHTMLEntity(t):
+    """Helper parser action to replace common HTML entities with their special characters"""
+    return _htmlEntityMap.get(t.entity)
+
+# it's easy to get these comment structures wrong - they're very common, so may as well make them available
+cStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/').setName("C style comment")
+"Comment of the form C{/* ... */}"
+
+htmlComment = Regex(r"<!--[\s\S]*?-->").setName("HTML comment")
+"Comment of the form C{<!-- ... -->}"
+
+restOfLine = Regex(r".*").leaveWhitespace().setName("rest of line")
+dblSlashComment = Regex(r"//(?:\\\n|[^\n])*").setName("// comment")
+"Comment of the form C{// ... (to end of line)}"
+
+cppStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/'| dblSlashComment).setName("C++ style comment")
+"Comment of either form C{L{cStyleComment}} or C{L{dblSlashComment}}"
+
+javaStyleComment = cppStyleComment
+"Same as C{L{cppStyleComment}}"
+
+pythonStyleComment = Regex(r"#.*").setName("Python style comment")
+"Comment of the form C{# ... (to end of line)}"
+
+_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',') +
+                                  Optional( Word(" \t") +
+                                            ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem")
+commaSeparatedList = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("commaSeparatedList")
+"""(Deprecated) Predefined expression of 1 or more printable words or quoted strings, separated by commas.
+   This expression is deprecated in favor of L{pyparsing_common.comma_separated_list}."""
+
+# some other useful expressions - using lower-case class name since we are really using this as a namespace
+class pyparsing_common:
+    """
+    Here are some common low-level expressions that may be useful in jump-starting parser development:
+     - numeric forms (L{integers<integer>}, L{reals<real>}, L{scientific notation<sci_real>})
+     - common L{programming identifiers<identifier>}
+     - network addresses (L{MAC<mac_address>}, L{IPv4<ipv4_address>}, L{IPv6<ipv6_address>})
+     - ISO8601 L{dates<iso8601_date>} and L{datetime<iso8601_datetime>}
+     - L{UUID<uuid>}
+     - L{comma-separated list<comma_separated_list>}
+    Parse actions:
+     - C{L{convertToInteger}}
+     - C{L{convertToFloat}}
+     - C{L{convertToDate}}
+     - C{L{convertToDatetime}}
+     - C{L{stripHTMLTags}}
+     - C{L{upcaseTokens}}
+     - C{L{downcaseTokens}}
+
+    Example::
+        pyparsing_common.number.runTests('''
+            # any int or real number, returned as the appropriate type
+            100
+            -100
+            +100
+            3.14159
+            6.02e23
+            1e-12
+            ''')
+
+        pyparsing_common.fnumber.runTests('''
+            # any int or real number, returned as float
+            100
+            -100
+            +100
+            3.14159
+            6.02e23
+            1e-12
+            ''')
+
+        pyparsing_common.hex_integer.runTests('''
+            # hex numbers
+            100
+            FF
+            ''')
+
+        pyparsing_common.fraction.runTests('''
+            # fractions
+            1/2
+            -3/4
+            ''')
+
+        pyparsing_common.mixed_integer.runTests('''
+            # mixed fractions
+            1
+            1/2
+            -3/4
+            1-3/4
+            ''')
+
+        import uuid
+        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
+        pyparsing_common.uuid.runTests('''
+            # uuid
+            12345678-1234-5678-1234-567812345678
+            ''')
+    prints::
+        # any int or real number, returned as the appropriate type
+        100
+        [100]
+
+        -100
+        [-100]
+
+        +100
+        [100]
+
+        3.14159
+        [3.14159]
+
+        6.02e23
+        [6.02e+23]
+
+        1e-12
+        [1e-12]
+
+        # any int or real number, returned as float
+        100
+        [100.0]
+
+        -100
+        [-100.0]
+
+        +100
+        [100.0]
+
+        3.14159
+        [3.14159]
+
+        6.02e23
+        [6.02e+23]
+
+        1e-12
+        [1e-12]
+
+        # hex numbers
+        100
+        [256]
+
+        FF
+        [255]
+
+        # fractions
+        1/2
+        [0.5]
+
+        -3/4
+        [-0.75]
+
+        # mixed fractions
+        1
+        [1]
+
+        1/2
+        [0.5]
+
+        -3/4
+        [-0.75]
+
+        1-3/4
+        [1.75]
+
+        # uuid
+        12345678-1234-5678-1234-567812345678
+        [UUID('12345678-1234-5678-1234-567812345678')]
+    """
+
+    convertToInteger = tokenMap(int)
+    """
+    Parse action for converting parsed integers to Python int
+    """
+
+    convertToFloat = tokenMap(float)
+    """
+    Parse action for converting parsed numbers to Python float
+    """
+
+    integer = Word(nums).setName("integer").setParseAction(convertToInteger)
+    """expression that parses an unsigned integer, returns an int"""
+
+    hex_integer = Word(hexnums).setName("hex integer").setParseAction(tokenMap(int,16))
+    """expression that parses a hexadecimal integer, returns an int"""
+
+    signed_integer = Regex(r'[+-]?\d+').setName("signed integer").setParseAction(convertToInteger)
+    """expression that parses an integer with optional leading sign, returns an int"""
+
+    fraction = (signed_integer().setParseAction(convertToFloat) + '/' + signed_integer().setParseAction(convertToFloat)).setName("fraction")
+    """fractional expression of an integer divided by an integer, returns a float"""
+    fraction.addParseAction(lambda t: t[0]/t[-1])
+
+    mixed_integer = (fraction | signed_integer + Optional(Optional('-').suppress() + fraction)).setName("fraction or mixed integer-fraction")
+    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float"""
+    mixed_integer.addParseAction(sum)
+
+    real = Regex(r'[+-]?\d+\.\d*').setName("real number").setParseAction(convertToFloat)
+    """expression that parses a floating point number and returns a float"""
+
+    sci_real = Regex(r'[+-]?\d+([eE][+-]?\d+|\.\d*([eE][+-]?\d+)?)').setName("real number with scientific notation").setParseAction(convertToFloat)
+    """expression that parses a floating point number with optional scientific notation and returns a float"""
+
+    # streamlining this expression makes the docs nicer-looking
+    number = (sci_real | real | signed_integer).streamline()
+    """any numeric expression, returns the corresponding Python type"""
+
+    fnumber = Regex(r'[+-]?\d+\.?\d*([eE][+-]?\d+)?').setName("fnumber").setParseAction(convertToFloat)
+    """any int or real number, returned as float"""
+    
+    identifier = Word(alphas+'_', alphanums+'_').setName("identifier")
+    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')"""
+    
+    ipv4_address = Regex(r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}').setName("IPv4 address")
+    "IPv4 address (C{0.0.0.0 - 255.255.255.255})"
+
+    _ipv6_part = Regex(r'[0-9a-fA-F]{1,4}').setName("hex_integer")
+    _full_ipv6_address = (_ipv6_part + (':' + _ipv6_part)*7).setName("full IPv6 address")
+    _short_ipv6_address = (Optional(_ipv6_part + (':' + _ipv6_part)*(0,6)) + "::" + Optional(_ipv6_part + (':' + _ipv6_part)*(0,6))).setName("short IPv6 address")
+    _short_ipv6_address.addCondition(lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8)
+    _mixed_ipv6_address = ("::ffff:" + ipv4_address).setName("mixed IPv6 address")
+    ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName("IPv6 address")).setName("IPv6 address")
+    "IPv6 address (long, short, or mixed form)"
+    
+    mac_address = Regex(r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}').setName("MAC address")
+    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)"
+
+    @staticmethod
+    def convertToDate(fmt="%Y-%m-%d"):
+        """
+        Helper to create a parse action for converting parsed date string to Python datetime.date
+
+        Params -
+         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%d"})
+
+        Example::
+            date_expr = pyparsing_common.iso8601_date.copy()
+            date_expr.setParseAction(pyparsing_common.convertToDate())
+            print(date_expr.parseString("1999-12-31"))
+        prints::
+            [datetime.date(1999, 12, 31)]
+        """
+        def cvt_fn(s,l,t):
+            try:
+                return datetime.strptime(t[0], fmt).date()
+            except ValueError as ve:
+                raise ParseException(s, l, str(ve))
+        return cvt_fn
+
+    @staticmethod
+    def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"):
+        """
+        Helper to create a parse action for converting parsed datetime string to Python datetime.datetime
+
+        Params -
+         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%dT%H:%M:%S.%f"})
+
+        Example::
+            dt_expr = pyparsing_common.iso8601_datetime.copy()
+            dt_expr.setParseAction(pyparsing_common.convertToDatetime())
+            print(dt_expr.parseString("1999-12-31T23:59:59.999"))
+        prints::
+            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]
+        """
+        def cvt_fn(s,l,t):
+            try:
+                return datetime.strptime(t[0], fmt)
+            except ValueError as ve:
+                raise ParseException(s, l, str(ve))
+        return cvt_fn
+
+    iso8601_date = Regex(r'(?P<year>\d{4})(?:-(?P<month>\d\d)(?:-(?P<day>\d\d))?)?').setName("ISO8601 date")
+    "ISO8601 date (C{yyyy-mm-dd})"
+
+    iso8601_datetime = Regex(r'(?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)[T ](?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d(\.\d*)?)?)?(?P<tz>Z|[+-]\d\d:?\d\d)?').setName("ISO8601 datetime")
+    "ISO8601 datetime (C{yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)}) - trailing seconds, milliseconds, and timezone optional; accepts separating C{'T'} or C{' '}"
+
+    uuid = Regex(r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}').setName("UUID")
+    "UUID (C{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx})"
+
+    _html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress()
+    @staticmethod
+    def stripHTMLTags(s, l, tokens):
+        """
+        Parse action to remove HTML tags from web page HTML source
+
+        Example::
+            # strip HTML links from normal text 
+            text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'
+            td,td_end = makeHTMLTags("TD")
+            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end
+            
+            print(table_text.parseString(text).body) # -> 'More info at the pyparsing wiki page'
+        """
+        return pyparsing_common._html_stripper.transformString(tokens[0])
+
+    _commasepitem = Combine(OneOrMore(~Literal(",") + ~LineEnd() + Word(printables, excludeChars=',') 
+                                        + Optional( White(" \t") ) ) ).streamline().setName("commaItem")
+    comma_separated_list = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("comma separated list")
+    """Predefined expression of 1 or more printable words or quoted strings, separated by commas."""
+
+    upcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).upper()))
+    """Parse action to convert tokens to upper case."""
+
+    downcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).lower()))
+    """Parse action to convert tokens to lower case."""
+
+
+if __name__ == "__main__":
+
+    selectToken    = CaselessLiteral("select")
+    fromToken      = CaselessLiteral("from")
+
+    ident          = Word(alphas, alphanums + "_$")
+
+    columnName     = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
+    columnNameList = Group(delimitedList(columnName)).setName("columns")
+    columnSpec     = ('*' | columnNameList)
+
+    tableName      = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
+    tableNameList  = Group(delimitedList(tableName)).setName("tables")
+    
+    simpleSQL      = selectToken("command") + columnSpec("columns") + fromToken + tableNameList("tables")
+
+    # demo runTests method, including embedded comments in test string
+    simpleSQL.runTests("""
+        # '*' as column list and dotted table name
+        select * from SYS.XYZZY
+
+        # caseless match on "SELECT", and casts back to "select"
+        SELECT * from XYZZY, ABC
+
+        # list of column names, and mixed case SELECT keyword
+        Select AA,BB,CC from Sys.dual
+
+        # multiple tables
+        Select A, B, C from Sys.dual, Table2
+
+        # invalid SELECT keyword - should fail
+        Xelect A, B, C from Sys.dual
+
+        # incomplete command - should fail
+        Select
+
+        # invalid column name - should fail
+        Select ^^^ frox Sys.dual
+
+        """)
+
+    pyparsing_common.number.runTests("""
+        100
+        -100
+        +100
+        3.14159
+        6.02e23
+        1e-12
+        """)
+
+    # any int or real number, returned as float
+    pyparsing_common.fnumber.runTests("""
+        100
+        -100
+        +100
+        3.14159
+        6.02e23
+        1e-12
+        """)
+
+    pyparsing_common.hex_integer.runTests("""
+        100
+        FF
+        """)
+
+    import uuid
+    pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
+    pyparsing_common.uuid.runTests("""
+        12345678-1234-5678-1234-567812345678
+        """)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/_vendor/six.py b/myenv/lib/python3.9/site-packages/setuptools/_vendor/six.py
new file mode 100644
index 0000000..190c023
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/_vendor/six.py
@@ -0,0 +1,868 @@
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+# Copyright (c) 2010-2015 Benjamin Peterson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from __future__ import absolute_import
+
+import functools
+import itertools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.10.0"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+PY34 = sys.version_info[0:2] >= (3, 4)
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result)  # Invokes __set__.
+        try:
+            # This is a bit ugly, but it avoids running this again by
+            # removing this descriptor.
+            delattr(obj.__class__, self.name)
+        except AttributeError:
+            pass
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+]
+# Add windows specific modules.
+if sys.platform == "win32":
+    _moved_attributes += [
+        MovedModule("winreg", "_winreg"),
+    ]
+
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    def create_unbound_method(func, cls):
+        return func
+
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    def create_unbound_method(func, cls):
+        return types.MethodType(func, None, cls)
+
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+
+    viewkeys = operator.methodcaller("keys")
+
+    viewvalues = operator.methodcaller("values")
+
+    viewitems = operator.methodcaller("items")
+else:
+    def iterkeys(d, **kw):
+        return d.iterkeys(**kw)
+
+    def itervalues(d, **kw):
+        return d.itervalues(**kw)
+
+    def iteritems(d, **kw):
+        return d.iteritems(**kw)
+
+    def iterlists(d, **kw):
+        return d.iterlists(**kw)
+
+    viewkeys = operator.methodcaller("viewkeys")
+
+    viewvalues = operator.methodcaller("viewvalues")
+
+    viewitems = operator.methodcaller("viewitems")
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+
+    def u(s):
+        return s
+    unichr = chr
+    import struct
+    int2byte = struct.Struct(">B").pack
+    del struct
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+    _assertCountEqual = "assertCountEqual"
+    if sys.version_info[1] <= 1:
+        _assertRaisesRegex = "assertRaisesRegexp"
+        _assertRegex = "assertRegexpMatches"
+    else:
+        _assertRaisesRegex = "assertRaisesRegex"
+        _assertRegex = "assertRegex"
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
+
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
+
+    def byte2int(bs):
+        return ord(bs[0])
+
+    def indexbytes(buf, i):
+        return ord(buf[i])
+    iterbytes = functools.partial(itertools.imap, ord)
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
+    _assertCountEqual = "assertItemsEqual"
+    _assertRaisesRegex = "assertRaisesRegexp"
+    _assertRegex = "assertRegexpMatches"
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+def assertCountEqual(self, *args, **kwargs):
+    return getattr(self, _assertCountEqual)(*args, **kwargs)
+
+
+def assertRaisesRegex(self, *args, **kwargs):
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
+
+
+def assertRegex(self, *args, **kwargs):
+    return getattr(self, _assertRegex)(*args, **kwargs)
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+    def reraise(tp, value, tb=None):
+        if value is None:
+            value = tp()
+        if value.__traceback__ is not tb:
+            raise value.with_traceback(tb)
+        raise value
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+    exec_("""def reraise(tp, value, tb=None):
+    raise tp, value, tb
+""")
+
+
+if sys.version_info[:2] == (3, 2):
+    exec_("""def raise_from(value, from_value):
+    if from_value is None:
+        raise value
+    raise value from from_value
+""")
+elif sys.version_info[:2] > (3, 2):
+    exec_("""def raise_from(value, from_value):
+    raise value from from_value
+""")
+else:
+    def raise_from(value, from_value):
+        raise value
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
+                    isinstance(data, unicode) and
+                    fp.encoding is not None):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+if sys.version_info[:2] < (3, 3):
+    _print = print_
+
+    def print_(*args, **kwargs):
+        fp = kwargs.get("file", sys.stdout)
+        flush = kwargs.pop("flush", False)
+        _print(*args, **kwargs)
+        if flush and fp is not None:
+            fp.flush()
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+              updated=functools.WRAPPER_UPDATES):
+        def wrapper(f):
+            f = functools.wraps(wrapped, assigned, updated)(f)
+            f.__wrapped__ = wrapped
+            return f
+        return wrapper
+else:
+    wraps = functools.wraps
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):
+
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
+
+def python_2_unicode_compatible(klass):
+    """
+    A decorator that defines __unicode__ and __str__ methods under Python 2.
+    Under Python 3 it does nothing.
+
+    To support Python 2 and 3 with a single code base, define a __str__ method
+    returning text and apply this decorator to the class.
+    """
+    if PY2:
+        if '__str__' not in klass.__dict__:
+            raise ValueError("@python_2_unicode_compatible cannot be applied "
+                             "to %s because it doesn't define __str__()." %
+                             klass.__name__)
+        klass.__unicode__ = klass.__str__
+        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
+    return klass
+
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
+                importer.name == __name__):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/archive_util.py b/myenv/lib/python3.9/site-packages/setuptools/archive_util.py
new file mode 100644
index 0000000..0ce190b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/archive_util.py
@@ -0,0 +1,175 @@
+"""Utilities for extracting common archive formats"""
+
+import zipfile
+import tarfile
+import os
+import shutil
+import posixpath
+import contextlib
+from distutils.errors import DistutilsError
+
+from pkg_resources import ensure_directory
+
+__all__ = [
+    "unpack_archive", "unpack_zipfile", "unpack_tarfile", "default_filter",
+    "UnrecognizedFormat", "extraction_drivers", "unpack_directory",
+]
+
+
+class UnrecognizedFormat(DistutilsError):
+    """Couldn't recognize the archive type"""
+
+
+def default_filter(src, dst):
+    """The default progress/filter callback; returns True for all files"""
+    return dst
+
+
+def unpack_archive(
+        filename, extract_dir, progress_filter=default_filter,
+        drivers=None):
+    """Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat``
+
+    `progress_filter` is a function taking two arguments: a source path
+    internal to the archive ('/'-separated), and a filesystem path where it
+    will be extracted.  The callback must return the desired extract path
+    (which may be the same as the one passed in), or else ``None`` to skip
+    that file or directory.  The callback can thus be used to report on the
+    progress of the extraction, as well as to filter the items extracted or
+    alter their extraction paths.
+
+    `drivers`, if supplied, must be a non-empty sequence of functions with the
+    same signature as this function (minus the `drivers` argument), that raise
+    ``UnrecognizedFormat`` if they do not support extracting the designated
+    archive type.  The `drivers` are tried in sequence until one is found that
+    does not raise an error, or until all are exhausted (in which case
+    ``UnrecognizedFormat`` is raised).  If you do not supply a sequence of
+    drivers, the module's ``extraction_drivers`` constant will be used, which
+    means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that
+    order.
+    """
+    for driver in drivers or extraction_drivers:
+        try:
+            driver(filename, extract_dir, progress_filter)
+        except UnrecognizedFormat:
+            continue
+        else:
+            return
+    else:
+        raise UnrecognizedFormat(
+            "Not a recognized archive type: %s" % filename
+        )
+
+
+def unpack_directory(filename, extract_dir, progress_filter=default_filter):
+    """"Unpack" a directory, using the same interface as for archives
+
+    Raises ``UnrecognizedFormat`` if `filename` is not a directory
+    """
+    if not os.path.isdir(filename):
+        raise UnrecognizedFormat("%s is not a directory" % filename)
+
+    paths = {
+        filename: ('', extract_dir),
+    }
+    for base, dirs, files in os.walk(filename):
+        src, dst = paths[base]
+        for d in dirs:
+            paths[os.path.join(base, d)] = src + d + '/', os.path.join(dst, d)
+        for f in files:
+            target = os.path.join(dst, f)
+            target = progress_filter(src + f, target)
+            if not target:
+                # skip non-files
+                continue
+            ensure_directory(target)
+            f = os.path.join(base, f)
+            shutil.copyfile(f, target)
+            shutil.copystat(f, target)
+
+
+def unpack_zipfile(filename, extract_dir, progress_filter=default_filter):
+    """Unpack zip `filename` to `extract_dir`
+
+    Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined
+    by ``zipfile.is_zipfile()``).  See ``unpack_archive()`` for an explanation
+    of the `progress_filter` argument.
+    """
+
+    if not zipfile.is_zipfile(filename):
+        raise UnrecognizedFormat("%s is not a zip file" % (filename,))
+
+    with zipfile.ZipFile(filename) as z:
+        for info in z.infolist():
+            name = info.filename
+
+            # don't extract absolute paths or ones with .. in them
+            if name.startswith('/') or '..' in name.split('/'):
+                continue
+
+            target = os.path.join(extract_dir, *name.split('/'))
+            target = progress_filter(name, target)
+            if not target:
+                continue
+            if name.endswith('/'):
+                # directory
+                ensure_directory(target)
+            else:
+                # file
+                ensure_directory(target)
+                data = z.read(info.filename)
+                with open(target, 'wb') as f:
+                    f.write(data)
+            unix_attributes = info.external_attr >> 16
+            if unix_attributes:
+                os.chmod(target, unix_attributes)
+
+
+def unpack_tarfile(filename, extract_dir, progress_filter=default_filter):
+    """Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`
+
+    Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined
+    by ``tarfile.open()``).  See ``unpack_archive()`` for an explanation
+    of the `progress_filter` argument.
+    """
+    try:
+        tarobj = tarfile.open(filename)
+    except tarfile.TarError as e:
+        raise UnrecognizedFormat(
+            "%s is not a compressed or uncompressed tar file" % (filename,)
+        ) from e
+    with contextlib.closing(tarobj):
+        # don't do any chowning!
+        tarobj.chown = lambda *args: None
+        for member in tarobj:
+            name = member.name
+            # don't extract absolute paths or ones with .. in them
+            if not name.startswith('/') and '..' not in name.split('/'):
+                prelim_dst = os.path.join(extract_dir, *name.split('/'))
+
+                # resolve any links and to extract the link targets as normal
+                # files
+                while member is not None and (
+                        member.islnk() or member.issym()):
+                    linkpath = member.linkname
+                    if member.issym():
+                        base = posixpath.dirname(member.name)
+                        linkpath = posixpath.join(base, linkpath)
+                        linkpath = posixpath.normpath(linkpath)
+                    member = tarobj._getmember(linkpath)
+
+                if member is not None and (member.isfile() or member.isdir()):
+                    final_dst = progress_filter(name, prelim_dst)
+                    if final_dst:
+                        if final_dst.endswith(os.sep):
+                            final_dst = final_dst[:-1]
+                        try:
+                            # XXX Ugh
+                            tarobj._extract_member(member, final_dst)
+                        except tarfile.ExtractError:
+                            # chown/chmod/mkfifo/mknode/makedev failed
+                            pass
+        return True
+
+
+extraction_drivers = unpack_directory, unpack_zipfile, unpack_tarfile
diff --git a/myenv/lib/python3.9/site-packages/setuptools/build_meta.py b/myenv/lib/python3.9/site-packages/setuptools/build_meta.py
new file mode 100644
index 0000000..4626681
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/build_meta.py
@@ -0,0 +1,271 @@
+"""A PEP 517 interface to setuptools
+
+Previously, when a user or a command line tool (let's call it a "frontend")
+needed to make a request of setuptools to take a certain action, for
+example, generating a list of installation requirements, the frontend would
+would call "setup.py egg_info" or "setup.py bdist_wheel" on the command line.
+
+PEP 517 defines a different method of interfacing with setuptools. Rather
+than calling "setup.py" directly, the frontend should:
+
+  1. Set the current directory to the directory with a setup.py file
+  2. Import this module into a safe python interpreter (one in which
+     setuptools can potentially set global variables or crash hard).
+  3. Call one of the functions defined in PEP 517.
+
+What each function does is defined in PEP 517. However, here is a "casual"
+definition of the functions (this definition should not be relied on for
+bug reports or API stability):
+
+  - `build_wheel`: build a wheel in the folder and return the basename
+  - `get_requires_for_build_wheel`: get the `setup_requires` to build
+  - `prepare_metadata_for_build_wheel`: get the `install_requires`
+  - `build_sdist`: build an sdist in the folder and return the basename
+  - `get_requires_for_build_sdist`: get the `setup_requires` to build
+
+Again, this is not a formal definition! Just a "taste" of the module.
+"""
+
+import io
+import os
+import sys
+import tokenize
+import shutil
+import contextlib
+
+import setuptools
+import distutils
+from setuptools.py31compat import TemporaryDirectory
+
+from pkg_resources import parse_requirements
+
+__all__ = ['get_requires_for_build_sdist',
+           'get_requires_for_build_wheel',
+           'prepare_metadata_for_build_wheel',
+           'build_wheel',
+           'build_sdist',
+           '__legacy__',
+           'SetupRequirementsError']
+
+
+class SetupRequirementsError(BaseException):
+    def __init__(self, specifiers):
+        self.specifiers = specifiers
+
+
+class Distribution(setuptools.dist.Distribution):
+    def fetch_build_eggs(self, specifiers):
+        specifier_list = list(map(str, parse_requirements(specifiers)))
+
+        raise SetupRequirementsError(specifier_list)
+
+    @classmethod
+    @contextlib.contextmanager
+    def patch(cls):
+        """
+        Replace
+        distutils.dist.Distribution with this class
+        for the duration of this context.
+        """
+        orig = distutils.core.Distribution
+        distutils.core.Distribution = cls
+        try:
+            yield
+        finally:
+            distutils.core.Distribution = orig
+
+
+def _to_str(s):
+    """
+    Convert a filename to a string (on Python 2, explicitly
+    a byte string, not Unicode) as distutils checks for the
+    exact type str.
+    """
+    if sys.version_info[0] == 2 and not isinstance(s, str):
+        # Assume it's Unicode, as that's what the PEP says
+        # should be provided.
+        return s.encode(sys.getfilesystemencoding())
+    return s
+
+
+def _get_immediate_subdirectories(a_dir):
+    return [name for name in os.listdir(a_dir)
+            if os.path.isdir(os.path.join(a_dir, name))]
+
+
+def _file_with_extension(directory, extension):
+    matching = (
+        f for f in os.listdir(directory)
+        if f.endswith(extension)
+    )
+    file, = matching
+    return file
+
+
+def _open_setup_script(setup_script):
+    if not os.path.exists(setup_script):
+        # Supply a default setup.py
+        return io.StringIO(u"from setuptools import setup; setup()")
+
+    return getattr(tokenize, 'open', open)(setup_script)
+
+
+class _BuildMetaBackend(object):
+
+    def _fix_config(self, config_settings):
+        config_settings = config_settings or {}
+        config_settings.setdefault('--global-option', [])
+        return config_settings
+
+    def _get_build_requires(self, config_settings, requirements):
+        config_settings = self._fix_config(config_settings)
+
+        sys.argv = sys.argv[:1] + ['egg_info'] + \
+            config_settings["--global-option"]
+        try:
+            with Distribution.patch():
+                self.run_setup()
+        except SetupRequirementsError as e:
+            requirements += e.specifiers
+
+        return requirements
+
+    def run_setup(self, setup_script='setup.py'):
+        # Note that we can reuse our build directory between calls
+        # Correctness comes first, then optimization later
+        __file__ = setup_script
+        __name__ = '__main__'
+
+        with _open_setup_script(__file__) as f:
+            code = f.read().replace(r'\r\n', r'\n')
+
+        exec(compile(code, __file__, 'exec'), locals())
+
+    def get_requires_for_build_wheel(self, config_settings=None):
+        config_settings = self._fix_config(config_settings)
+        return self._get_build_requires(
+            config_settings, requirements=['wheel'])
+
+    def get_requires_for_build_sdist(self, config_settings=None):
+        config_settings = self._fix_config(config_settings)
+        return self._get_build_requires(config_settings, requirements=[])
+
+    def prepare_metadata_for_build_wheel(self, metadata_directory,
+                                         config_settings=None):
+        sys.argv = sys.argv[:1] + ['dist_info', '--egg-base',
+                                   _to_str(metadata_directory)]
+        self.run_setup()
+
+        dist_info_directory = metadata_directory
+        while True:
+            dist_infos = [f for f in os.listdir(dist_info_directory)
+                          if f.endswith('.dist-info')]
+
+            if (
+                len(dist_infos) == 0 and
+                len(_get_immediate_subdirectories(dist_info_directory)) == 1
+            ):
+
+                dist_info_directory = os.path.join(
+                    dist_info_directory, os.listdir(dist_info_directory)[0])
+                continue
+
+            assert len(dist_infos) == 1
+            break
+
+        # PEP 517 requires that the .dist-info directory be placed in the
+        # metadata_directory. To comply, we MUST copy the directory to the root
+        if dist_info_directory != metadata_directory:
+            shutil.move(
+                os.path.join(dist_info_directory, dist_infos[0]),
+                metadata_directory)
+            shutil.rmtree(dist_info_directory, ignore_errors=True)
+
+        return dist_infos[0]
+
+    def _build_with_temp_dir(self, setup_command, result_extension,
+                             result_directory, config_settings):
+        config_settings = self._fix_config(config_settings)
+        result_directory = os.path.abspath(result_directory)
+
+        # Build in a temporary directory, then copy to the target.
+        os.makedirs(result_directory, exist_ok=True)
+        with TemporaryDirectory(dir=result_directory) as tmp_dist_dir:
+            sys.argv = (sys.argv[:1] + setup_command +
+                        ['--dist-dir', tmp_dist_dir] +
+                        config_settings["--global-option"])
+            self.run_setup()
+
+            result_basename = _file_with_extension(
+                tmp_dist_dir, result_extension)
+            result_path = os.path.join(result_directory, result_basename)
+            if os.path.exists(result_path):
+                # os.rename will fail overwriting on non-Unix.
+                os.remove(result_path)
+            os.rename(os.path.join(tmp_dist_dir, result_basename), result_path)
+
+        return result_basename
+
+    def build_wheel(self, wheel_directory, config_settings=None,
+                    metadata_directory=None):
+        return self._build_with_temp_dir(['bdist_wheel'], '.whl',
+                                         wheel_directory, config_settings)
+
+    def build_sdist(self, sdist_directory, config_settings=None):
+        return self._build_with_temp_dir(['sdist', '--formats', 'gztar'],
+                                         '.tar.gz', sdist_directory,
+                                         config_settings)
+
+
+class _BuildMetaLegacyBackend(_BuildMetaBackend):
+    """Compatibility backend for setuptools
+
+    This is a version of setuptools.build_meta that endeavors
+    to maintain backwards
+    compatibility with pre-PEP 517 modes of invocation. It
+    exists as a temporary
+    bridge between the old packaging mechanism and the new
+    packaging mechanism,
+    and will eventually be removed.
+    """
+    def run_setup(self, setup_script='setup.py'):
+        # In order to maintain compatibility with scripts assuming that
+        # the setup.py script is in a directory on the PYTHONPATH, inject
+        # '' into sys.path. (pypa/setuptools#1642)
+        sys_path = list(sys.path)           # Save the original path
+
+        script_dir = os.path.dirname(os.path.abspath(setup_script))
+        if script_dir not in sys.path:
+            sys.path.insert(0, script_dir)
+
+        # Some setup.py scripts (e.g. in pygame and numpy) use sys.argv[0] to
+        # get the directory of the source code. They expect it to refer to the
+        # setup.py script.
+        sys_argv_0 = sys.argv[0]
+        sys.argv[0] = setup_script
+
+        try:
+            super(_BuildMetaLegacyBackend,
+                  self).run_setup(setup_script=setup_script)
+        finally:
+            # While PEP 517 frontends should be calling each hook in a fresh
+            # subprocess according to the standard (and thus it should not be
+            # strictly necessary to restore the old sys.path), we'll restore
+            # the original path so that the path manipulation does not persist
+            # within the hook after run_setup is called.
+            sys.path[:] = sys_path
+            sys.argv[0] = sys_argv_0
+
+
+# The primary backend
+_BACKEND = _BuildMetaBackend()
+
+get_requires_for_build_wheel = _BACKEND.get_requires_for_build_wheel
+get_requires_for_build_sdist = _BACKEND.get_requires_for_build_sdist
+prepare_metadata_for_build_wheel = _BACKEND.prepare_metadata_for_build_wheel
+build_wheel = _BACKEND.build_wheel
+build_sdist = _BACKEND.build_sdist
+
+
+# The legacy backend
+__legacy__ = _BuildMetaLegacyBackend()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/cli-32.exe b/myenv/lib/python3.9/site-packages/setuptools/cli-32.exe
new file mode 100644
index 0000000..b1487b7
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/setuptools/cli-32.exe differ
diff --git a/myenv/lib/python3.9/site-packages/setuptools/cli-64.exe b/myenv/lib/python3.9/site-packages/setuptools/cli-64.exe
new file mode 100644
index 0000000..675e6bf
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/setuptools/cli-64.exe differ
diff --git a/myenv/lib/python3.9/site-packages/setuptools/cli.exe b/myenv/lib/python3.9/site-packages/setuptools/cli.exe
new file mode 100644
index 0000000..b1487b7
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/setuptools/cli.exe differ
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/__init__.py b/myenv/lib/python3.9/site-packages/setuptools/command/__init__.py
new file mode 100644
index 0000000..743f558
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/__init__.py
@@ -0,0 +1,17 @@
+__all__ = [
+    'alias', 'bdist_egg', 'bdist_rpm', 'build_ext', 'build_py', 'develop',
+    'easy_install', 'egg_info', 'install', 'install_lib', 'rotate', 'saveopts',
+    'sdist', 'setopt', 'test', 'install_egg_info', 'install_scripts',
+    'bdist_wininst', 'upload_docs', 'build_clib', 'dist_info',
+]
+
+from distutils.command.bdist import bdist
+import sys
+
+from setuptools.command import install_scripts
+
+if 'egg' not in bdist.format_commands:
+    bdist.format_command['egg'] = ('bdist_egg', "Python .egg file")
+    bdist.format_commands.append('egg')
+
+del bdist, sys
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/alias.py b/myenv/lib/python3.9/site-packages/setuptools/command/alias.py
new file mode 100644
index 0000000..4532b1c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/alias.py
@@ -0,0 +1,80 @@
+from distutils.errors import DistutilsOptionError
+
+from setuptools.extern.six.moves import map
+
+from setuptools.command.setopt import edit_config, option_base, config_file
+
+
+def shquote(arg):
+    """Quote an argument for later parsing by shlex.split()"""
+    for c in '"', "'", "\\", "#":
+        if c in arg:
+            return repr(arg)
+    if arg.split() != [arg]:
+        return repr(arg)
+    return arg
+
+
+class alias(option_base):
+    """Define a shortcut that invokes one or more commands"""
+
+    description = "define a shortcut to invoke one or more commands"
+    command_consumes_arguments = True
+
+    user_options = [
+        ('remove', 'r', 'remove (unset) the alias'),
+    ] + option_base.user_options
+
+    boolean_options = option_base.boolean_options + ['remove']
+
+    def initialize_options(self):
+        option_base.initialize_options(self)
+        self.args = None
+        self.remove = None
+
+    def finalize_options(self):
+        option_base.finalize_options(self)
+        if self.remove and len(self.args) != 1:
+            raise DistutilsOptionError(
+                "Must specify exactly one argument (the alias name) when "
+                "using --remove"
+            )
+
+    def run(self):
+        aliases = self.distribution.get_option_dict('aliases')
+
+        if not self.args:
+            print("Command Aliases")
+            print("---------------")
+            for alias in aliases:
+                print("setup.py alias", format_alias(alias, aliases))
+            return
+
+        elif len(self.args) == 1:
+            alias, = self.args
+            if self.remove:
+                command = None
+            elif alias in aliases:
+                print("setup.py alias", format_alias(alias, aliases))
+                return
+            else:
+                print("No alias definition found for %r" % alias)
+                return
+        else:
+            alias = self.args[0]
+            command = ' '.join(map(shquote, self.args[1:]))
+
+        edit_config(self.filename, {'aliases': {alias: command}}, self.dry_run)
+
+
+def format_alias(name, aliases):
+    source, command = aliases[name]
+    if source == config_file('global'):
+        source = '--global-config '
+    elif source == config_file('user'):
+        source = '--user-config '
+    elif source == config_file('local'):
+        source = ''
+    else:
+        source = '--filename=%r' % source
+    return source + name + ' ' + command
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/bdist_egg.py b/myenv/lib/python3.9/site-packages/setuptools/command/bdist_egg.py
new file mode 100644
index 0000000..7af3165
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/bdist_egg.py
@@ -0,0 +1,510 @@
+"""setuptools.command.bdist_egg
+
+Build .egg distributions"""
+
+from distutils.errors import DistutilsSetupError
+from distutils.dir_util import remove_tree, mkpath
+from distutils import log
+from types import CodeType
+import sys
+import os
+import re
+import textwrap
+import marshal
+import warnings
+
+from setuptools.extern import six
+
+from pkg_resources import get_build_platform, Distribution, ensure_directory
+from pkg_resources import EntryPoint
+from setuptools.extension import Library
+from setuptools import Command, SetuptoolsDeprecationWarning
+
+try:
+    # Python 2.7 or >=3.2
+    from sysconfig import get_path, get_python_version
+
+    def _get_purelib():
+        return get_path("purelib")
+except ImportError:
+    from distutils.sysconfig import get_python_lib, get_python_version
+
+    def _get_purelib():
+        return get_python_lib(False)
+
+
+def strip_module(filename):
+    if '.' in filename:
+        filename = os.path.splitext(filename)[0]
+    if filename.endswith('module'):
+        filename = filename[:-6]
+    return filename
+
+
+def sorted_walk(dir):
+    """Do os.walk in a reproducible way,
+    independent of indeterministic filesystem readdir order
+    """
+    for base, dirs, files in os.walk(dir):
+        dirs.sort()
+        files.sort()
+        yield base, dirs, files
+
+
+def write_stub(resource, pyfile):
+    _stub_template = textwrap.dedent("""
+        def __bootstrap__():
+            global __bootstrap__, __loader__, __file__
+            import sys, pkg_resources
+            from importlib.machinery import ExtensionFileLoader
+            __file__ = pkg_resources.resource_filename(__name__, %r)
+            __loader__ = None; del __bootstrap__, __loader__
+            ExtensionFileLoader(__name__,__file__).load_module()
+        __bootstrap__()
+        """).lstrip()
+    with open(pyfile, 'w') as f:
+        f.write(_stub_template % resource)
+
+
+class bdist_egg(Command):
+    description = "create an \"egg\" distribution"
+
+    user_options = [
+        ('bdist-dir=', 'b',
+         "temporary directory for creating the distribution"),
+        ('plat-name=', 'p', "platform name to embed in generated filenames "
+                            "(default: %s)" % get_build_platform()),
+        ('exclude-source-files', None,
+         "remove all .py files from the generated egg"),
+        ('keep-temp', 'k',
+         "keep the pseudo-installation tree around after " +
+         "creating the distribution archive"),
+        ('dist-dir=', 'd',
+         "directory to put final built distributions in"),
+        ('skip-build', None,
+         "skip rebuilding everything (for testing/debugging)"),
+    ]
+
+    boolean_options = [
+        'keep-temp', 'skip-build', 'exclude-source-files'
+    ]
+
+    def initialize_options(self):
+        self.bdist_dir = None
+        self.plat_name = None
+        self.keep_temp = 0
+        self.dist_dir = None
+        self.skip_build = 0
+        self.egg_output = None
+        self.exclude_source_files = None
+
+    def finalize_options(self):
+        ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
+        self.egg_info = ei_cmd.egg_info
+
+        if self.bdist_dir is None:
+            bdist_base = self.get_finalized_command('bdist').bdist_base
+            self.bdist_dir = os.path.join(bdist_base, 'egg')
+
+        if self.plat_name is None:
+            self.plat_name = get_build_platform()
+
+        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
+
+        if self.egg_output is None:
+
+            # Compute filename of the output egg
+            basename = Distribution(
+                None, None, ei_cmd.egg_name, ei_cmd.egg_version,
+                get_python_version(),
+                self.distribution.has_ext_modules() and self.plat_name
+            ).egg_name()
+
+            self.egg_output = os.path.join(self.dist_dir, basename + '.egg')
+
+    def do_install_data(self):
+        # Hack for packages that install data to install's --install-lib
+        self.get_finalized_command('install').install_lib = self.bdist_dir
+
+        site_packages = os.path.normcase(os.path.realpath(_get_purelib()))
+        old, self.distribution.data_files = self.distribution.data_files, []
+
+        for item in old:
+            if isinstance(item, tuple) and len(item) == 2:
+                if os.path.isabs(item[0]):
+                    realpath = os.path.realpath(item[0])
+                    normalized = os.path.normcase(realpath)
+                    if normalized == site_packages or normalized.startswith(
+                        site_packages + os.sep
+                    ):
+                        item = realpath[len(site_packages) + 1:], item[1]
+                        # XXX else: raise ???
+            self.distribution.data_files.append(item)
+
+        try:
+            log.info("installing package data to %s", self.bdist_dir)
+            self.call_command('install_data', force=0, root=None)
+        finally:
+            self.distribution.data_files = old
+
+    def get_outputs(self):
+        return [self.egg_output]
+
+    def call_command(self, cmdname, **kw):
+        """Invoke reinitialized command `cmdname` with keyword args"""
+        for dirname in INSTALL_DIRECTORY_ATTRS:
+            kw.setdefault(dirname, self.bdist_dir)
+        kw.setdefault('skip_build', self.skip_build)
+        kw.setdefault('dry_run', self.dry_run)
+        cmd = self.reinitialize_command(cmdname, **kw)
+        self.run_command(cmdname)
+        return cmd
+
+    def run(self):
+        # Generate metadata first
+        self.run_command("egg_info")
+        # We run install_lib before install_data, because some data hacks
+        # pull their data path from the install_lib command.
+        log.info("installing library code to %s", self.bdist_dir)
+        instcmd = self.get_finalized_command('install')
+        old_root = instcmd.root
+        instcmd.root = None
+        if self.distribution.has_c_libraries() and not self.skip_build:
+            self.run_command('build_clib')
+        cmd = self.call_command('install_lib', warn_dir=0)
+        instcmd.root = old_root
+
+        all_outputs, ext_outputs = self.get_ext_outputs()
+        self.stubs = []
+        to_compile = []
+        for (p, ext_name) in enumerate(ext_outputs):
+            filename, ext = os.path.splitext(ext_name)
+            pyfile = os.path.join(self.bdist_dir, strip_module(filename) +
+                                  '.py')
+            self.stubs.append(pyfile)
+            log.info("creating stub loader for %s", ext_name)
+            if not self.dry_run:
+                write_stub(os.path.basename(ext_name), pyfile)
+            to_compile.append(pyfile)
+            ext_outputs[p] = ext_name.replace(os.sep, '/')
+
+        if to_compile:
+            cmd.byte_compile(to_compile)
+        if self.distribution.data_files:
+            self.do_install_data()
+
+        # Make the EGG-INFO directory
+        archive_root = self.bdist_dir
+        egg_info = os.path.join(archive_root, 'EGG-INFO')
+        self.mkpath(egg_info)
+        if self.distribution.scripts:
+            script_dir = os.path.join(egg_info, 'scripts')
+            log.info("installing scripts to %s", script_dir)
+            self.call_command('install_scripts', install_dir=script_dir,
+                              no_ep=1)
+
+        self.copy_metadata_to(egg_info)
+        native_libs = os.path.join(egg_info, "native_libs.txt")
+        if all_outputs:
+            log.info("writing %s", native_libs)
+            if not self.dry_run:
+                ensure_directory(native_libs)
+                libs_file = open(native_libs, 'wt')
+                libs_file.write('\n'.join(all_outputs))
+                libs_file.write('\n')
+                libs_file.close()
+        elif os.path.isfile(native_libs):
+            log.info("removing %s", native_libs)
+            if not self.dry_run:
+                os.unlink(native_libs)
+
+        write_safety_flag(
+            os.path.join(archive_root, 'EGG-INFO'), self.zip_safe()
+        )
+
+        if os.path.exists(os.path.join(self.egg_info, 'depends.txt')):
+            log.warn(
+                "WARNING: 'depends.txt' will not be used by setuptools 0.6!\n"
+                "Use the install_requires/extras_require setup() args instead."
+            )
+
+        if self.exclude_source_files:
+            self.zap_pyfiles()
+
+        # Make the archive
+        make_zipfile(self.egg_output, archive_root, verbose=self.verbose,
+                     dry_run=self.dry_run, mode=self.gen_header())
+        if not self.keep_temp:
+            remove_tree(self.bdist_dir, dry_run=self.dry_run)
+
+        # Add to 'Distribution.dist_files' so that the "upload" command works
+        getattr(self.distribution, 'dist_files', []).append(
+            ('bdist_egg', get_python_version(), self.egg_output))
+
+    def zap_pyfiles(self):
+        log.info("Removing .py files from temporary directory")
+        for base, dirs, files in walk_egg(self.bdist_dir):
+            for name in files:
+                path = os.path.join(base, name)
+
+                if name.endswith('.py'):
+                    log.debug("Deleting %s", path)
+                    os.unlink(path)
+
+                if base.endswith('__pycache__'):
+                    path_old = path
+
+                    pattern = r'(?P<name>.+)\.(?P<magic>[^.]+)\.pyc'
+                    m = re.match(pattern, name)
+                    path_new = os.path.join(
+                        base, os.pardir, m.group('name') + '.pyc')
+                    log.info(
+                        "Renaming file from [%s] to [%s]"
+                        % (path_old, path_new))
+                    try:
+                        os.remove(path_new)
+                    except OSError:
+                        pass
+                    os.rename(path_old, path_new)
+
+    def zip_safe(self):
+        safe = getattr(self.distribution, 'zip_safe', None)
+        if safe is not None:
+            return safe
+        log.warn("zip_safe flag not set; analyzing archive contents...")
+        return analyze_egg(self.bdist_dir, self.stubs)
+
+    def gen_header(self):
+        epm = EntryPoint.parse_map(self.distribution.entry_points or '')
+        ep = epm.get('setuptools.installation', {}).get('eggsecutable')
+        if ep is None:
+            return 'w'  # not an eggsecutable, do it the usual way.
+
+        warnings.warn(
+            "Eggsecutables are deprecated and will be removed in a future "
+            "version.",
+            SetuptoolsDeprecationWarning
+        )
+
+        if not ep.attrs or ep.extras:
+            raise DistutilsSetupError(
+                "eggsecutable entry point (%r) cannot have 'extras' "
+                "or refer to a module" % (ep,)
+            )
+
+        pyver = '{}.{}'.format(*sys.version_info)
+        pkg = ep.module_name
+        full = '.'.join(ep.attrs)
+        base = ep.attrs[0]
+        basename = os.path.basename(self.egg_output)
+
+        header = (
+            "#!/bin/sh\n"
+            'if [ `basename $0` = "%(basename)s" ]\n'
+            'then exec python%(pyver)s -c "'
+            "import sys, os; sys.path.insert(0, os.path.abspath('$0')); "
+            "from %(pkg)s import %(base)s; sys.exit(%(full)s())"
+            '" "$@"\n'
+            'else\n'
+            '  echo $0 is not the correct name for this egg file.\n'
+            '  echo Please rename it back to %(basename)s and try again.\n'
+            '  exec false\n'
+            'fi\n'
+        ) % locals()
+
+        if not self.dry_run:
+            mkpath(os.path.dirname(self.egg_output), dry_run=self.dry_run)
+            f = open(self.egg_output, 'w')
+            f.write(header)
+            f.close()
+        return 'a'
+
+    def copy_metadata_to(self, target_dir):
+        "Copy metadata (egg info) to the target_dir"
+        # normalize the path (so that a forward-slash in egg_info will
+        # match using startswith below)
+        norm_egg_info = os.path.normpath(self.egg_info)
+        prefix = os.path.join(norm_egg_info, '')
+        for path in self.ei_cmd.filelist.files:
+            if path.startswith(prefix):
+                target = os.path.join(target_dir, path[len(prefix):])
+                ensure_directory(target)
+                self.copy_file(path, target)
+
+    def get_ext_outputs(self):
+        """Get a list of relative paths to C extensions in the output distro"""
+
+        all_outputs = []
+        ext_outputs = []
+
+        paths = {self.bdist_dir: ''}
+        for base, dirs, files in sorted_walk(self.bdist_dir):
+            for filename in files:
+                if os.path.splitext(filename)[1].lower() in NATIVE_EXTENSIONS:
+                    all_outputs.append(paths[base] + filename)
+            for filename in dirs:
+                paths[os.path.join(base, filename)] = (paths[base] +
+                                                       filename + '/')
+
+        if self.distribution.has_ext_modules():
+            build_cmd = self.get_finalized_command('build_ext')
+            for ext in build_cmd.extensions:
+                if isinstance(ext, Library):
+                    continue
+                fullname = build_cmd.get_ext_fullname(ext.name)
+                filename = build_cmd.get_ext_filename(fullname)
+                if not os.path.basename(filename).startswith('dl-'):
+                    if os.path.exists(os.path.join(self.bdist_dir, filename)):
+                        ext_outputs.append(filename)
+
+        return all_outputs, ext_outputs
+
+
+NATIVE_EXTENSIONS = dict.fromkeys('.dll .so .dylib .pyd'.split())
+
+
+def walk_egg(egg_dir):
+    """Walk an unpacked egg's contents, skipping the metadata directory"""
+    walker = sorted_walk(egg_dir)
+    base, dirs, files = next(walker)
+    if 'EGG-INFO' in dirs:
+        dirs.remove('EGG-INFO')
+    yield base, dirs, files
+    for bdf in walker:
+        yield bdf
+
+
+def analyze_egg(egg_dir, stubs):
+    # check for existing flag in EGG-INFO
+    for flag, fn in safety_flags.items():
+        if os.path.exists(os.path.join(egg_dir, 'EGG-INFO', fn)):
+            return flag
+    if not can_scan():
+        return False
+    safe = True
+    for base, dirs, files in walk_egg(egg_dir):
+        for name in files:
+            if name.endswith('.py') or name.endswith('.pyw'):
+                continue
+            elif name.endswith('.pyc') or name.endswith('.pyo'):
+                # always scan, even if we already know we're not safe
+                safe = scan_module(egg_dir, base, name, stubs) and safe
+    return safe
+
+
+def write_safety_flag(egg_dir, safe):
+    # Write or remove zip safety flag file(s)
+    for flag, fn in safety_flags.items():
+        fn = os.path.join(egg_dir, fn)
+        if os.path.exists(fn):
+            if safe is None or bool(safe) != flag:
+                os.unlink(fn)
+        elif safe is not None and bool(safe) == flag:
+            f = open(fn, 'wt')
+            f.write('\n')
+            f.close()
+
+
+safety_flags = {
+    True: 'zip-safe',
+    False: 'not-zip-safe',
+}
+
+
+def scan_module(egg_dir, base, name, stubs):
+    """Check whether module possibly uses unsafe-for-zipfile stuff"""
+
+    filename = os.path.join(base, name)
+    if filename[:-1] in stubs:
+        return True  # Extension module
+    pkg = base[len(egg_dir) + 1:].replace(os.sep, '.')
+    module = pkg + (pkg and '.' or '') + os.path.splitext(name)[0]
+    if six.PY2:
+        skip = 8  # skip magic & date
+    elif sys.version_info < (3, 7):
+        skip = 12  # skip magic & date & file size
+    else:
+        skip = 16  # skip magic & reserved? & date & file size
+    f = open(filename, 'rb')
+    f.read(skip)
+    code = marshal.load(f)
+    f.close()
+    safe = True
+    symbols = dict.fromkeys(iter_symbols(code))
+    for bad in ['__file__', '__path__']:
+        if bad in symbols:
+            log.warn("%s: module references %s", module, bad)
+            safe = False
+    if 'inspect' in symbols:
+        for bad in [
+            'getsource', 'getabsfile', 'getsourcefile', 'getfile'
+            'getsourcelines', 'findsource', 'getcomments', 'getframeinfo',
+            'getinnerframes', 'getouterframes', 'stack', 'trace'
+        ]:
+            if bad in symbols:
+                log.warn("%s: module MAY be using inspect.%s", module, bad)
+                safe = False
+    return safe
+
+
+def iter_symbols(code):
+    """Yield names and strings used by `code` and its nested code objects"""
+    for name in code.co_names:
+        yield name
+    for const in code.co_consts:
+        if isinstance(const, six.string_types):
+            yield const
+        elif isinstance(const, CodeType):
+            for name in iter_symbols(const):
+                yield name
+
+
+def can_scan():
+    if not sys.platform.startswith('java') and sys.platform != 'cli':
+        # CPython, PyPy, etc.
+        return True
+    log.warn("Unable to analyze compiled code on this platform.")
+    log.warn("Please ask the author to include a 'zip_safe'"
+             " setting (either True or False) in the package's setup.py")
+
+
+# Attribute names of options for commands that might need to be convinced to
+# install to the egg build directory
+
+INSTALL_DIRECTORY_ATTRS = [
+    'install_lib', 'install_dir', 'install_data', 'install_base'
+]
+
+
+def make_zipfile(zip_filename, base_dir, verbose=0, dry_run=0, compress=True,
+                 mode='w'):
+    """Create a zip file from all the files under 'base_dir'.  The output
+    zip file will be named 'base_dir' + ".zip".  Uses either the "zipfile"
+    Python module (if available) or the InfoZIP "zip" utility (if installed
+    and found on the default search path).  If neither tool is available,
+    raises DistutilsExecError.  Returns the name of the output zip file.
+    """
+    import zipfile
+
+    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
+    log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)
+
+    def visit(z, dirname, names):
+        for name in names:
+            path = os.path.normpath(os.path.join(dirname, name))
+            if os.path.isfile(path):
+                p = path[len(base_dir) + 1:]
+                if not dry_run:
+                    z.write(path, p)
+                log.debug("adding '%s'", p)
+
+    compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
+    if not dry_run:
+        z = zipfile.ZipFile(zip_filename, mode, compression=compression)
+        for dirname, dirs, files in sorted_walk(base_dir):
+            visit(z, dirname, files)
+        z.close()
+    else:
+        for dirname, dirs, files in sorted_walk(base_dir):
+            visit(None, dirname, files)
+    return zip_filename
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/bdist_rpm.py b/myenv/lib/python3.9/site-packages/setuptools/command/bdist_rpm.py
new file mode 100644
index 0000000..7073092
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/bdist_rpm.py
@@ -0,0 +1,43 @@
+import distutils.command.bdist_rpm as orig
+
+
+class bdist_rpm(orig.bdist_rpm):
+    """
+    Override the default bdist_rpm behavior to do the following:
+
+    1. Run egg_info to ensure the name and version are properly calculated.
+    2. Always run 'install' using --single-version-externally-managed to
+       disable eggs in RPM distributions.
+    3. Replace dash with underscore in the version numbers for better RPM
+       compatibility.
+    """
+
+    def run(self):
+        # ensure distro name is up-to-date
+        self.run_command('egg_info')
+
+        orig.bdist_rpm.run(self)
+
+    def _make_spec_file(self):
+        version = self.distribution.get_version()
+        rpmversion = version.replace('-', '_')
+        spec = orig.bdist_rpm._make_spec_file(self)
+        line23 = '%define version ' + version
+        line24 = '%define version ' + rpmversion
+        spec = [
+            line.replace(
+                "Source0: %{name}-%{version}.tar",
+                "Source0: %{name}-%{unmangled_version}.tar"
+            ).replace(
+                "setup.py install ",
+                "setup.py install --single-version-externally-managed "
+            ).replace(
+                "%setup",
+                "%setup -n %{name}-%{unmangled_version}"
+            ).replace(line23, line24)
+            for line in spec
+        ]
+        insert_loc = spec.index(line24) + 1
+        unmangled_version = "%define unmangled_version " + version
+        spec.insert(insert_loc, unmangled_version)
+        return spec
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/bdist_wininst.py b/myenv/lib/python3.9/site-packages/setuptools/command/bdist_wininst.py
new file mode 100644
index 0000000..ff4b634
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/bdist_wininst.py
@@ -0,0 +1,30 @@
+import distutils.command.bdist_wininst as orig
+import warnings
+
+from setuptools import SetuptoolsDeprecationWarning
+
+
+class bdist_wininst(orig.bdist_wininst):
+    def reinitialize_command(self, command, reinit_subcommands=0):
+        """
+        Supplement reinitialize_command to work around
+        http://bugs.python.org/issue20819
+        """
+        cmd = self.distribution.reinitialize_command(
+            command, reinit_subcommands)
+        if command in ('install', 'install_lib'):
+            cmd.install_lib = None
+        return cmd
+
+    def run(self):
+        warnings.warn(
+            "bdist_wininst is deprecated and will be removed in a future "
+            "version. Use bdist_wheel (wheel packages) instead.",
+            SetuptoolsDeprecationWarning
+        )
+
+        self._is_running = True
+        try:
+            orig.bdist_wininst.run(self)
+        finally:
+            self._is_running = False
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/build_clib.py b/myenv/lib/python3.9/site-packages/setuptools/command/build_clib.py
new file mode 100644
index 0000000..67ce244
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/build_clib.py
@@ -0,0 +1,101 @@
+import distutils.command.build_clib as orig
+from distutils.errors import DistutilsSetupError
+from distutils import log
+from setuptools.dep_util import newer_pairwise_group
+
+
+class build_clib(orig.build_clib):
+    """
+    Override the default build_clib behaviour to do the following:
+
+    1. Implement a rudimentary timestamp-based dependency system
+       so 'compile()' doesn't run every time.
+    2. Add more keys to the 'build_info' dictionary:
+        * obj_deps - specify dependencies for each object compiled.
+                     this should be a dictionary mapping a key
+                     with the source filename to a list of
+                     dependencies. Use an empty string for global
+                     dependencies.
+        * cflags   - specify a list of additional flags to pass to
+                     the compiler.
+    """
+
+    def build_libraries(self, libraries):
+        for (lib_name, build_info) in libraries:
+            sources = build_info.get('sources')
+            if sources is None or not isinstance(sources, (list, tuple)):
+                raise DistutilsSetupError(
+                    "in 'libraries' option (library '%s'), "
+                    "'sources' must be present and must be "
+                    "a list of source filenames" % lib_name)
+            sources = list(sources)
+
+            log.info("building '%s' library", lib_name)
+
+            # Make sure everything is the correct type.
+            # obj_deps should be a dictionary of keys as sources
+            # and a list/tuple of files that are its dependencies.
+            obj_deps = build_info.get('obj_deps', dict())
+            if not isinstance(obj_deps, dict):
+                raise DistutilsSetupError(
+                    "in 'libraries' option (library '%s'), "
+                    "'obj_deps' must be a dictionary of "
+                    "type 'source: list'" % lib_name)
+            dependencies = []
+
+            # Get the global dependencies that are specified by the '' key.
+            # These will go into every source's dependency list.
+            global_deps = obj_deps.get('', list())
+            if not isinstance(global_deps, (list, tuple)):
+                raise DistutilsSetupError(
+                    "in 'libraries' option (library '%s'), "
+                    "'obj_deps' must be a dictionary of "
+                    "type 'source: list'" % lib_name)
+
+            # Build the list to be used by newer_pairwise_group
+            # each source will be auto-added to its dependencies.
+            for source in sources:
+                src_deps = [source]
+                src_deps.extend(global_deps)
+                extra_deps = obj_deps.get(source, list())
+                if not isinstance(extra_deps, (list, tuple)):
+                    raise DistutilsSetupError(
+                        "in 'libraries' option (library '%s'), "
+                        "'obj_deps' must be a dictionary of "
+                        "type 'source: list'" % lib_name)
+                src_deps.extend(extra_deps)
+                dependencies.append(src_deps)
+
+            expected_objects = self.compiler.object_filenames(
+                sources,
+                output_dir=self.build_temp,
+            )
+
+            if (
+                newer_pairwise_group(dependencies, expected_objects)
+                != ([], [])
+            ):
+                # First, compile the source code to object files in the library
+                # directory.  (This should probably change to putting object
+                # files in a temporary build directory.)
+                macros = build_info.get('macros')
+                include_dirs = build_info.get('include_dirs')
+                cflags = build_info.get('cflags')
+                self.compiler.compile(
+                    sources,
+                    output_dir=self.build_temp,
+                    macros=macros,
+                    include_dirs=include_dirs,
+                    extra_postargs=cflags,
+                    debug=self.debug
+                )
+
+            # Now "link" the object files together into a static library.
+            # (On Unix at least, this isn't really linking -- it just
+            # builds an archive.  Whatever.)
+            self.compiler.create_static_lib(
+                expected_objects,
+                lib_name,
+                output_dir=self.build_clib,
+                debug=self.debug
+            )
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/build_ext.py b/myenv/lib/python3.9/site-packages/setuptools/command/build_ext.py
new file mode 100644
index 0000000..0eb29ad
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/build_ext.py
@@ -0,0 +1,332 @@
+import os
+import sys
+import itertools
+from distutils.command.build_ext import build_ext as _du_build_ext
+from distutils.file_util import copy_file
+from distutils.ccompiler import new_compiler
+from distutils.sysconfig import customize_compiler, get_config_var
+from distutils.errors import DistutilsError
+from distutils import log
+
+from setuptools.extension import Library
+from setuptools.extern import six
+
+if six.PY2:
+    import imp
+
+    EXTENSION_SUFFIXES = [
+        s for s, _, tp in imp.get_suffixes() if tp == imp.C_EXTENSION]
+else:
+    from importlib.machinery import EXTENSION_SUFFIXES
+
+try:
+    # Attempt to use Cython for building extensions, if available
+    from Cython.Distutils.build_ext import build_ext as _build_ext
+    # Additionally, assert that the compiler module will load
+    # also. Ref #1229.
+    __import__('Cython.Compiler.Main')
+except ImportError:
+    _build_ext = _du_build_ext
+
+# make sure _config_vars is initialized
+get_config_var("LDSHARED")
+from distutils.sysconfig import _config_vars as _CONFIG_VARS  # noqa
+
+
+def _customize_compiler_for_shlib(compiler):
+    if sys.platform == "darwin":
+        # building .dylib requires additional compiler flags on OSX; here we
+        # temporarily substitute the pyconfig.h variables so that distutils'
+        # 'customize_compiler' uses them before we build the shared libraries.
+        tmp = _CONFIG_VARS.copy()
+        try:
+            # XXX Help!  I don't have any idea whether these are right...
+            _CONFIG_VARS['LDSHARED'] = (
+                "gcc -Wl,-x -dynamiclib -undefined dynamic_lookup")
+            _CONFIG_VARS['CCSHARED'] = " -dynamiclib"
+            _CONFIG_VARS['SO'] = ".dylib"
+            customize_compiler(compiler)
+        finally:
+            _CONFIG_VARS.clear()
+            _CONFIG_VARS.update(tmp)
+    else:
+        customize_compiler(compiler)
+
+
+have_rtld = False
+use_stubs = False
+libtype = 'shared'
+
+if sys.platform == "darwin":
+    use_stubs = True
+elif os.name != 'nt':
+    try:
+        import dl
+        use_stubs = have_rtld = hasattr(dl, 'RTLD_NOW')
+    except ImportError:
+        pass
+
+
+def if_dl(s):
+    return s if have_rtld else ''
+
+
+def get_abi3_suffix():
+    """Return the file extension for an abi3-compliant Extension()"""
+    for suffix in EXTENSION_SUFFIXES:
+        if '.abi3' in suffix:  # Unix
+            return suffix
+        elif suffix == '.pyd':  # Windows
+            return suffix
+
+
+class build_ext(_build_ext):
+    def run(self):
+        """Build extensions in build directory, then copy if --inplace"""
+        old_inplace, self.inplace = self.inplace, 0
+        _build_ext.run(self)
+        self.inplace = old_inplace
+        if old_inplace:
+            self.copy_extensions_to_source()
+
+    def copy_extensions_to_source(self):
+        build_py = self.get_finalized_command('build_py')
+        for ext in self.extensions:
+            fullname = self.get_ext_fullname(ext.name)
+            filename = self.get_ext_filename(fullname)
+            modpath = fullname.split('.')
+            package = '.'.join(modpath[:-1])
+            package_dir = build_py.get_package_dir(package)
+            dest_filename = os.path.join(package_dir,
+                                         os.path.basename(filename))
+            src_filename = os.path.join(self.build_lib, filename)
+
+            # Always copy, even if source is older than destination, to ensure
+            # that the right extensions for the current Python/platform are
+            # used.
+            copy_file(
+                src_filename, dest_filename, verbose=self.verbose,
+                dry_run=self.dry_run
+            )
+            if ext._needs_stub:
+                self.write_stub(package_dir or os.curdir, ext, True)
+
+    def get_ext_filename(self, fullname):
+        filename = _build_ext.get_ext_filename(self, fullname)
+        if fullname in self.ext_map:
+            ext = self.ext_map[fullname]
+            use_abi3 = (
+                not six.PY2
+                and getattr(ext, 'py_limited_api')
+                and get_abi3_suffix()
+            )
+            if use_abi3:
+                so_ext = get_config_var('EXT_SUFFIX')
+                filename = filename[:-len(so_ext)]
+                filename = filename + get_abi3_suffix()
+            if isinstance(ext, Library):
+                fn, ext = os.path.splitext(filename)
+                return self.shlib_compiler.library_filename(fn, libtype)
+            elif use_stubs and ext._links_to_dynamic:
+                d, fn = os.path.split(filename)
+                return os.path.join(d, 'dl-' + fn)
+        return filename
+
+    def initialize_options(self):
+        _build_ext.initialize_options(self)
+        self.shlib_compiler = None
+        self.shlibs = []
+        self.ext_map = {}
+
+    def finalize_options(self):
+        _build_ext.finalize_options(self)
+        self.extensions = self.extensions or []
+        self.check_extensions_list(self.extensions)
+        self.shlibs = [ext for ext in self.extensions
+                       if isinstance(ext, Library)]
+        if self.shlibs:
+            self.setup_shlib_compiler()
+        for ext in self.extensions:
+            ext._full_name = self.get_ext_fullname(ext.name)
+        for ext in self.extensions:
+            fullname = ext._full_name
+            self.ext_map[fullname] = ext
+
+            # distutils 3.1 will also ask for module names
+            # XXX what to do with conflicts?
+            self.ext_map[fullname.split('.')[-1]] = ext
+
+            ltd = self.shlibs and self.links_to_dynamic(ext) or False
+            ns = ltd and use_stubs and not isinstance(ext, Library)
+            ext._links_to_dynamic = ltd
+            ext._needs_stub = ns
+            filename = ext._file_name = self.get_ext_filename(fullname)
+            libdir = os.path.dirname(os.path.join(self.build_lib, filename))
+            if ltd and libdir not in ext.library_dirs:
+                ext.library_dirs.append(libdir)
+            if ltd and use_stubs and os.curdir not in ext.runtime_library_dirs:
+                ext.runtime_library_dirs.append(os.curdir)
+
+    def setup_shlib_compiler(self):
+        compiler = self.shlib_compiler = new_compiler(
+            compiler=self.compiler, dry_run=self.dry_run, force=self.force
+        )
+        _customize_compiler_for_shlib(compiler)
+
+        if self.include_dirs is not None:
+            compiler.set_include_dirs(self.include_dirs)
+        if self.define is not None:
+            # 'define' option is a list of (name,value) tuples
+            for (name, value) in self.define:
+                compiler.define_macro(name, value)
+        if self.undef is not None:
+            for macro in self.undef:
+                compiler.undefine_macro(macro)
+        if self.libraries is not None:
+            compiler.set_libraries(self.libraries)
+        if self.library_dirs is not None:
+            compiler.set_library_dirs(self.library_dirs)
+        if self.rpath is not None:
+            compiler.set_runtime_library_dirs(self.rpath)
+        if self.link_objects is not None:
+            compiler.set_link_objects(self.link_objects)
+
+        # hack so distutils' build_extension() builds a library instead
+        compiler.link_shared_object = link_shared_object.__get__(compiler)
+
+    def get_export_symbols(self, ext):
+        if isinstance(ext, Library):
+            return ext.export_symbols
+        return _build_ext.get_export_symbols(self, ext)
+
+    def build_extension(self, ext):
+        ext._convert_pyx_sources_to_lang()
+        _compiler = self.compiler
+        try:
+            if isinstance(ext, Library):
+                self.compiler = self.shlib_compiler
+            _build_ext.build_extension(self, ext)
+            if ext._needs_stub:
+                cmd = self.get_finalized_command('build_py').build_lib
+                self.write_stub(cmd, ext)
+        finally:
+            self.compiler = _compiler
+
+    def links_to_dynamic(self, ext):
+        """Return true if 'ext' links to a dynamic lib in the same package"""
+        # XXX this should check to ensure the lib is actually being built
+        # XXX as dynamic, and not just using a locally-found version or a
+        # XXX static-compiled version
+        libnames = dict.fromkeys([lib._full_name for lib in self.shlibs])
+        pkg = '.'.join(ext._full_name.split('.')[:-1] + [''])
+        return any(pkg + libname in libnames for libname in ext.libraries)
+
+    def get_outputs(self):
+        return _build_ext.get_outputs(self) + self.__get_stubs_outputs()
+
+    def __get_stubs_outputs(self):
+        # assemble the base name for each extension that needs a stub
+        ns_ext_bases = (
+            os.path.join(self.build_lib, *ext._full_name.split('.'))
+            for ext in self.extensions
+            if ext._needs_stub
+        )
+        # pair each base with the extension
+        pairs = itertools.product(ns_ext_bases, self.__get_output_extensions())
+        return list(base + fnext for base, fnext in pairs)
+
+    def __get_output_extensions(self):
+        yield '.py'
+        yield '.pyc'
+        if self.get_finalized_command('build_py').optimize:
+            yield '.pyo'
+
+    def write_stub(self, output_dir, ext, compile=False):
+        log.info("writing stub loader for %s to %s", ext._full_name,
+                 output_dir)
+        stub_file = (os.path.join(output_dir, *ext._full_name.split('.')) +
+                     '.py')
+        if compile and os.path.exists(stub_file):
+            raise DistutilsError(stub_file + " already exists! Please delete.")
+        if not self.dry_run:
+            f = open(stub_file, 'w')
+            f.write(
+                '\n'.join([
+                    "def __bootstrap__():",
+                    "   global __bootstrap__, __file__, __loader__",
+                    "   import sys, os, pkg_resources" + if_dl(", dl"),
+                    "   from importlib.machinery import ExtensionFileLoader",
+                    "   __file__ = pkg_resources.resource_filename"
+                    "(__name__,%r)"
+                    % os.path.basename(ext._file_name),
+                    "   del __bootstrap__",
+                    "   if '__loader__' in globals():",
+                    "       del __loader__",
+                    if_dl("   old_flags = sys.getdlopenflags()"),
+                    "   old_dir = os.getcwd()",
+                    "   try:",
+                    "     os.chdir(os.path.dirname(__file__))",
+                    if_dl("     sys.setdlopenflags(dl.RTLD_NOW)"),
+                    "     ExtensionFileLoader(__name__,",
+                    "                         __file__).load_module()",
+                    "   finally:",
+                    if_dl("     sys.setdlopenflags(old_flags)"),
+                    "     os.chdir(old_dir)",
+                    "__bootstrap__()",
+                    ""  # terminal \n
+                ])
+            )
+            f.close()
+        if compile:
+            from distutils.util import byte_compile
+
+            byte_compile([stub_file], optimize=0,
+                         force=True, dry_run=self.dry_run)
+            optimize = self.get_finalized_command('install_lib').optimize
+            if optimize > 0:
+                byte_compile([stub_file], optimize=optimize,
+                             force=True, dry_run=self.dry_run)
+            if os.path.exists(stub_file) and not self.dry_run:
+                os.unlink(stub_file)
+
+
+if use_stubs or os.name == 'nt':
+    # Build shared libraries
+    #
+    def link_shared_object(
+            self, objects, output_libname, output_dir=None, libraries=None,
+            library_dirs=None, runtime_library_dirs=None, export_symbols=None,
+            debug=0, extra_preargs=None, extra_postargs=None, build_temp=None,
+            target_lang=None):
+        self.link(
+            self.SHARED_LIBRARY, objects, output_libname,
+            output_dir, libraries, library_dirs, runtime_library_dirs,
+            export_symbols, debug, extra_preargs, extra_postargs,
+            build_temp, target_lang
+        )
+else:
+    # Build static libraries everywhere else
+    libtype = 'static'
+
+    def link_shared_object(
+            self, objects, output_libname, output_dir=None, libraries=None,
+            library_dirs=None, runtime_library_dirs=None, export_symbols=None,
+            debug=0, extra_preargs=None, extra_postargs=None, build_temp=None,
+            target_lang=None):
+        # XXX we need to either disallow these attrs on Library instances,
+        # or warn/abort here if set, or something...
+        # libraries=None, library_dirs=None, runtime_library_dirs=None,
+        # export_symbols=None, extra_preargs=None, extra_postargs=None,
+        # build_temp=None
+
+        assert output_dir is None  # distutils build_ext doesn't pass this
+        output_dir, filename = os.path.split(output_libname)
+        basename, ext = os.path.splitext(filename)
+        if self.library_filename("x").startswith('lib'):
+            # strip 'lib' prefix; this is kludgy if some platform uses
+            # a different prefix
+            basename = basename[3:]
+
+        self.create_static_lib(
+            objects, basename, output_dir, debug, target_lang
+        )
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/build_py.py b/myenv/lib/python3.9/site-packages/setuptools/command/build_py.py
new file mode 100644
index 0000000..9d0288a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/build_py.py
@@ -0,0 +1,276 @@
+from glob import glob
+from distutils.util import convert_path
+import distutils.command.build_py as orig
+import os
+import fnmatch
+import textwrap
+import io
+import distutils.errors
+import itertools
+import stat
+
+from setuptools.extern import six
+from setuptools.extern.six.moves import map, filter, filterfalse
+
+try:
+    from setuptools.lib2to3_ex import Mixin2to3
+except ImportError:
+
+    class Mixin2to3:
+        def run_2to3(self, files, doctests=True):
+            "do nothing"
+
+
+def make_writable(target):
+    os.chmod(target, os.stat(target).st_mode | stat.S_IWRITE)
+
+
+class build_py(orig.build_py, Mixin2to3):
+    """Enhanced 'build_py' command that includes data files with packages
+
+    The data files are specified via a 'package_data' argument to 'setup()'.
+    See 'setuptools.dist.Distribution' for more details.
+
+    Also, this version of the 'build_py' command allows you to specify both
+    'py_modules' and 'packages' in the same setup operation.
+    """
+
+    def finalize_options(self):
+        orig.build_py.finalize_options(self)
+        self.package_data = self.distribution.package_data
+        self.exclude_package_data = (self.distribution.exclude_package_data or
+                                     {})
+        if 'data_files' in self.__dict__:
+            del self.__dict__['data_files']
+        self.__updated_files = []
+        self.__doctests_2to3 = []
+
+    def run(self):
+        """Build modules, packages, and copy data files to build directory"""
+        if not self.py_modules and not self.packages:
+            return
+
+        if self.py_modules:
+            self.build_modules()
+
+        if self.packages:
+            self.build_packages()
+            self.build_package_data()
+
+        self.run_2to3(self.__updated_files, False)
+        self.run_2to3(self.__updated_files, True)
+        self.run_2to3(self.__doctests_2to3, True)
+
+        # Only compile actual .py files, using our base class' idea of what our
+        # output files are.
+        self.byte_compile(orig.build_py.get_outputs(self, include_bytecode=0))
+
+    def __getattr__(self, attr):
+        "lazily compute data files"
+        if attr == 'data_files':
+            self.data_files = self._get_data_files()
+            return self.data_files
+        return orig.build_py.__getattr__(self, attr)
+
+    def build_module(self, module, module_file, package):
+        if six.PY2 and isinstance(package, six.string_types):
+            # avoid errors on Python 2 when unicode is passed (#190)
+            package = package.split('.')
+        outfile, copied = orig.build_py.build_module(self, module, module_file,
+                                                     package)
+        if copied:
+            self.__updated_files.append(outfile)
+        return outfile, copied
+
+    def _get_data_files(self):
+        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
+        self.analyze_manifest()
+        return list(map(self._get_pkg_data_files, self.packages or ()))
+
+    def _get_pkg_data_files(self, package):
+        # Locate package source directory
+        src_dir = self.get_package_dir(package)
+
+        # Compute package build directory
+        build_dir = os.path.join(*([self.build_lib] + package.split('.')))
+
+        # Strip directory from globbed filenames
+        filenames = [
+            os.path.relpath(file, src_dir)
+            for file in self.find_data_files(package, src_dir)
+        ]
+        return package, src_dir, build_dir, filenames
+
+    def find_data_files(self, package, src_dir):
+        """Return filenames for package's data files in 'src_dir'"""
+        patterns = self._get_platform_patterns(
+            self.package_data,
+            package,
+            src_dir,
+        )
+        globs_expanded = map(glob, patterns)
+        # flatten the expanded globs into an iterable of matches
+        globs_matches = itertools.chain.from_iterable(globs_expanded)
+        glob_files = filter(os.path.isfile, globs_matches)
+        files = itertools.chain(
+            self.manifest_files.get(package, []),
+            glob_files,
+        )
+        return self.exclude_data_files(package, src_dir, files)
+
+    def build_package_data(self):
+        """Copy data files into build directory"""
+        for package, src_dir, build_dir, filenames in self.data_files:
+            for filename in filenames:
+                target = os.path.join(build_dir, filename)
+                self.mkpath(os.path.dirname(target))
+                srcfile = os.path.join(src_dir, filename)
+                outf, copied = self.copy_file(srcfile, target)
+                make_writable(target)
+                srcfile = os.path.abspath(srcfile)
+                if (copied and
+                        srcfile in self.distribution.convert_2to3_doctests):
+                    self.__doctests_2to3.append(outf)
+
+    def analyze_manifest(self):
+        self.manifest_files = mf = {}
+        if not self.distribution.include_package_data:
+            return
+        src_dirs = {}
+        for package in self.packages or ():
+            # Locate package source directory
+            src_dirs[assert_relative(self.get_package_dir(package))] = package
+
+        self.run_command('egg_info')
+        ei_cmd = self.get_finalized_command('egg_info')
+        for path in ei_cmd.filelist.files:
+            d, f = os.path.split(assert_relative(path))
+            prev = None
+            oldf = f
+            while d and d != prev and d not in src_dirs:
+                prev = d
+                d, df = os.path.split(d)
+                f = os.path.join(df, f)
+            if d in src_dirs:
+                if path.endswith('.py') and f == oldf:
+                    continue  # it's a module, not data
+                mf.setdefault(src_dirs[d], []).append(path)
+
+    def get_data_files(self):
+        pass  # Lazily compute data files in _get_data_files() function.
+
+    def check_package(self, package, package_dir):
+        """Check namespace packages' __init__ for declare_namespace"""
+        try:
+            return self.packages_checked[package]
+        except KeyError:
+            pass
+
+        init_py = orig.build_py.check_package(self, package, package_dir)
+        self.packages_checked[package] = init_py
+
+        if not init_py or not self.distribution.namespace_packages:
+            return init_py
+
+        for pkg in self.distribution.namespace_packages:
+            if pkg == package or pkg.startswith(package + '.'):
+                break
+        else:
+            return init_py
+
+        with io.open(init_py, 'rb') as f:
+            contents = f.read()
+        if b'declare_namespace' not in contents:
+            raise distutils.errors.DistutilsError(
+                "Namespace package problem: %s is a namespace package, but "
+                "its\n__init__.py does not call declare_namespace()! Please "
+                'fix it.\n(See the setuptools manual under '
+                '"Namespace Packages" for details.)\n"' % (package,)
+            )
+        return init_py
+
+    def initialize_options(self):
+        self.packages_checked = {}
+        orig.build_py.initialize_options(self)
+
+    def get_package_dir(self, package):
+        res = orig.build_py.get_package_dir(self, package)
+        if self.distribution.src_root is not None:
+            return os.path.join(self.distribution.src_root, res)
+        return res
+
+    def exclude_data_files(self, package, src_dir, files):
+        """Filter filenames for package's data files in 'src_dir'"""
+        files = list(files)
+        patterns = self._get_platform_patterns(
+            self.exclude_package_data,
+            package,
+            src_dir,
+        )
+        match_groups = (
+            fnmatch.filter(files, pattern)
+            for pattern in patterns
+        )
+        # flatten the groups of matches into an iterable of matches
+        matches = itertools.chain.from_iterable(match_groups)
+        bad = set(matches)
+        keepers = (
+            fn
+            for fn in files
+            if fn not in bad
+        )
+        # ditch dupes
+        return list(_unique_everseen(keepers))
+
+    @staticmethod
+    def _get_platform_patterns(spec, package, src_dir):
+        """
+        yield platform-specific path patterns (suitable for glob
+        or fn_match) from a glob-based spec (such as
+        self.package_data or self.exclude_package_data)
+        matching package in src_dir.
+        """
+        raw_patterns = itertools.chain(
+            spec.get('', []),
+            spec.get(package, []),
+        )
+        return (
+            # Each pattern has to be converted to a platform-specific path
+            os.path.join(src_dir, convert_path(pattern))
+            for pattern in raw_patterns
+        )
+
+
+# from Python docs
+def _unique_everseen(iterable, key=None):
+    "List unique elements, preserving order. Remember all elements ever seen."
+    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
+    # unique_everseen('ABBCcAD', str.lower) --> A B C D
+    seen = set()
+    seen_add = seen.add
+    if key is None:
+        for element in filterfalse(seen.__contains__, iterable):
+            seen_add(element)
+            yield element
+    else:
+        for element in iterable:
+            k = key(element)
+            if k not in seen:
+                seen_add(k)
+                yield element
+
+
+def assert_relative(path):
+    if not os.path.isabs(path):
+        return path
+    from distutils.errors import DistutilsSetupError
+
+    msg = textwrap.dedent("""
+        Error: setup script specifies an absolute path:
+
+            %s
+
+        setup() arguments must *always* be /-separated paths relative to the
+        setup.py directory, *never* absolute paths.
+        """).lstrip() % path
+    raise DistutilsSetupError(msg)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/develop.py b/myenv/lib/python3.9/site-packages/setuptools/command/develop.py
new file mode 100644
index 0000000..e7e03cd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/develop.py
@@ -0,0 +1,220 @@
+from distutils.util import convert_path
+from distutils import log
+from distutils.errors import DistutilsError, DistutilsOptionError
+import os
+import glob
+import io
+
+from setuptools.extern import six
+
+import pkg_resources
+from setuptools.command.easy_install import easy_install
+from setuptools import namespaces
+import setuptools
+
+__metaclass__ = type
+
+
+class develop(namespaces.DevelopInstaller, easy_install):
+    """Set up package for development"""
+
+    description = "install package in 'development mode'"
+
+    user_options = easy_install.user_options + [
+        ("uninstall", "u", "Uninstall this source package"),
+        ("egg-path=", None, "Set the path to be used in the .egg-link file"),
+    ]
+
+    boolean_options = easy_install.boolean_options + ['uninstall']
+
+    command_consumes_arguments = False  # override base
+
+    def run(self):
+        if self.uninstall:
+            self.multi_version = True
+            self.uninstall_link()
+            self.uninstall_namespaces()
+        else:
+            self.install_for_development()
+        self.warn_deprecated_options()
+
+    def initialize_options(self):
+        self.uninstall = None
+        self.egg_path = None
+        easy_install.initialize_options(self)
+        self.setup_path = None
+        self.always_copy_from = '.'  # always copy eggs installed in curdir
+
+    def finalize_options(self):
+        ei = self.get_finalized_command("egg_info")
+        if ei.broken_egg_info:
+            template = "Please rename %r to %r before using 'develop'"
+            args = ei.egg_info, ei.broken_egg_info
+            raise DistutilsError(template % args)
+        self.args = [ei.egg_name]
+
+        easy_install.finalize_options(self)
+        self.expand_basedirs()
+        self.expand_dirs()
+        # pick up setup-dir .egg files only: no .egg-info
+        self.package_index.scan(glob.glob('*.egg'))
+
+        egg_link_fn = ei.egg_name + '.egg-link'
+        self.egg_link = os.path.join(self.install_dir, egg_link_fn)
+        self.egg_base = ei.egg_base
+        if self.egg_path is None:
+            self.egg_path = os.path.abspath(ei.egg_base)
+
+        target = pkg_resources.normalize_path(self.egg_base)
+        egg_path = pkg_resources.normalize_path(
+            os.path.join(self.install_dir, self.egg_path))
+        if egg_path != target:
+            raise DistutilsOptionError(
+                "--egg-path must be a relative path from the install"
+                " directory to " + target
+            )
+
+        # Make a distribution for the package's source
+        self.dist = pkg_resources.Distribution(
+            target,
+            pkg_resources.PathMetadata(target, os.path.abspath(ei.egg_info)),
+            project_name=ei.egg_name
+        )
+
+        self.setup_path = self._resolve_setup_path(
+            self.egg_base,
+            self.install_dir,
+            self.egg_path,
+        )
+
+    @staticmethod
+    def _resolve_setup_path(egg_base, install_dir, egg_path):
+        """
+        Generate a path from egg_base back to '.' where the
+        setup script resides and ensure that path points to the
+        setup path from $install_dir/$egg_path.
+        """
+        path_to_setup = egg_base.replace(os.sep, '/').rstrip('/')
+        if path_to_setup != os.curdir:
+            path_to_setup = '../' * (path_to_setup.count('/') + 1)
+        resolved = pkg_resources.normalize_path(
+            os.path.join(install_dir, egg_path, path_to_setup)
+        )
+        if resolved != pkg_resources.normalize_path(os.curdir):
+            raise DistutilsOptionError(
+                "Can't get a consistent path to setup script from"
+                " installation directory", resolved,
+                pkg_resources.normalize_path(os.curdir))
+        return path_to_setup
+
+    def install_for_development(self):
+        if not six.PY2 and getattr(self.distribution, 'use_2to3', False):
+            # If we run 2to3 we can not do this inplace:
+
+            # Ensure metadata is up-to-date
+            self.reinitialize_command('build_py', inplace=0)
+            self.run_command('build_py')
+            bpy_cmd = self.get_finalized_command("build_py")
+            build_path = pkg_resources.normalize_path(bpy_cmd.build_lib)
+
+            # Build extensions
+            self.reinitialize_command('egg_info', egg_base=build_path)
+            self.run_command('egg_info')
+
+            self.reinitialize_command('build_ext', inplace=0)
+            self.run_command('build_ext')
+
+            # Fixup egg-link and easy-install.pth
+            ei_cmd = self.get_finalized_command("egg_info")
+            self.egg_path = build_path
+            self.dist.location = build_path
+            # XXX
+            self.dist._provider = pkg_resources.PathMetadata(
+                build_path, ei_cmd.egg_info)
+        else:
+            # Without 2to3 inplace works fine:
+            self.run_command('egg_info')
+
+            # Build extensions in-place
+            self.reinitialize_command('build_ext', inplace=1)
+            self.run_command('build_ext')
+
+        if setuptools.bootstrap_install_from:
+            self.easy_install(setuptools.bootstrap_install_from)
+            setuptools.bootstrap_install_from = None
+
+        self.install_namespaces()
+
+        # create an .egg-link in the installation dir, pointing to our egg
+        log.info("Creating %s (link to %s)", self.egg_link, self.egg_base)
+        if not self.dry_run:
+            with open(self.egg_link, "w") as f:
+                f.write(self.egg_path + "\n" + self.setup_path)
+        # postprocess the installed distro, fixing up .pth, installing scripts,
+        # and handling requirements
+        self.process_distribution(None, self.dist, not self.no_deps)
+
+    def uninstall_link(self):
+        if os.path.exists(self.egg_link):
+            log.info("Removing %s (link to %s)", self.egg_link, self.egg_base)
+            egg_link_file = open(self.egg_link)
+            contents = [line.rstrip() for line in egg_link_file]
+            egg_link_file.close()
+            if contents not in ([self.egg_path],
+                                [self.egg_path, self.setup_path]):
+                log.warn("Link points to %s: uninstall aborted", contents)
+                return
+            if not self.dry_run:
+                os.unlink(self.egg_link)
+        if not self.dry_run:
+            self.update_pth(self.dist)  # remove any .pth link to us
+        if self.distribution.scripts:
+            # XXX should also check for entry point scripts!
+            log.warn("Note: you must uninstall or replace scripts manually!")
+
+    def install_egg_scripts(self, dist):
+        if dist is not self.dist:
+            # Installing a dependency, so fall back to normal behavior
+            return easy_install.install_egg_scripts(self, dist)
+
+        # create wrapper scripts in the script dir, pointing to dist.scripts
+
+        # new-style...
+        self.install_wrapper_scripts(dist)
+
+        # ...and old-style
+        for script_name in self.distribution.scripts or []:
+            script_path = os.path.abspath(convert_path(script_name))
+            script_name = os.path.basename(script_path)
+            with io.open(script_path) as strm:
+                script_text = strm.read()
+            self.install_script(dist, script_name, script_text, script_path)
+
+    def install_wrapper_scripts(self, dist):
+        dist = VersionlessRequirement(dist)
+        return easy_install.install_wrapper_scripts(self, dist)
+
+
+class VersionlessRequirement:
+    """
+    Adapt a pkg_resources.Distribution to simply return the project
+    name as the 'requirement' so that scripts will work across
+    multiple versions.
+
+    >>> from pkg_resources import Distribution
+    >>> dist = Distribution(project_name='foo', version='1.0')
+    >>> str(dist.as_requirement())
+    'foo==1.0'
+    >>> adapted_dist = VersionlessRequirement(dist)
+    >>> str(adapted_dist.as_requirement())
+    'foo'
+    """
+
+    def __init__(self, dist):
+        self.__dist = dist
+
+    def __getattr__(self, name):
+        return getattr(self.__dist, name)
+
+    def as_requirement(self):
+        return self.project_name
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/dist_info.py b/myenv/lib/python3.9/site-packages/setuptools/command/dist_info.py
new file mode 100644
index 0000000..c45258f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/dist_info.py
@@ -0,0 +1,36 @@
+"""
+Create a dist_info directory
+As defined in the wheel specification
+"""
+
+import os
+
+from distutils.core import Command
+from distutils import log
+
+
+class dist_info(Command):
+
+    description = 'create a .dist-info directory'
+
+    user_options = [
+        ('egg-base=', 'e', "directory containing .egg-info directories"
+                           " (default: top of the source tree)"),
+    ]
+
+    def initialize_options(self):
+        self.egg_base = None
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        egg_info = self.get_finalized_command('egg_info')
+        egg_info.egg_base = self.egg_base
+        egg_info.finalize_options()
+        egg_info.run()
+        dist_info_dir = egg_info.egg_info[:-len('.egg-info')] + '.dist-info'
+        log.info("creating '{}'".format(os.path.abspath(dist_info_dir)))
+
+        bdist_wheel = self.get_finalized_command('bdist_wheel')
+        bdist_wheel.egg2dist(egg_info.egg_info, dist_info_dir)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/easy_install.py b/myenv/lib/python3.9/site-packages/setuptools/command/easy_install.py
new file mode 100644
index 0000000..bcbd4f5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/easy_install.py
@@ -0,0 +1,2339 @@
+"""
+Easy Install
+------------
+
+A tool for doing automatic download/extract/build of distutils-based Python
+packages.  For detailed documentation, see the accompanying EasyInstall.txt
+file, or visit the `EasyInstall home page`__.
+
+__ https://setuptools.readthedocs.io/en/latest/easy_install.html
+
+"""
+
+from glob import glob
+from distutils.util import get_platform
+from distutils.util import convert_path, subst_vars
+from distutils.errors import (
+    DistutilsArgError, DistutilsOptionError,
+    DistutilsError, DistutilsPlatformError,
+)
+from distutils.command.install import INSTALL_SCHEMES, SCHEME_KEYS
+from distutils import log, dir_util
+from distutils.command.build_scripts import first_line_re
+from distutils.spawn import find_executable
+import sys
+import os
+import zipimport
+import shutil
+import tempfile
+import zipfile
+import re
+import stat
+import random
+import textwrap
+import warnings
+import site
+import struct
+import contextlib
+import subprocess
+import shlex
+import io
+
+
+from sysconfig import get_config_vars, get_path
+
+from setuptools import SetuptoolsDeprecationWarning
+
+from setuptools.extern import six
+from setuptools.extern.six.moves import configparser, map
+
+from setuptools import Command
+from setuptools.sandbox import run_setup
+from setuptools.py27compat import rmtree_safe
+from setuptools.command import setopt
+from setuptools.archive_util import unpack_archive
+from setuptools.package_index import (
+    PackageIndex, parse_requirement_arg, URL_SCHEME,
+)
+from setuptools.command import bdist_egg, egg_info
+from setuptools.wheel import Wheel
+from pkg_resources import (
+    yield_lines, normalize_path, resource_string, ensure_directory,
+    get_distribution, find_distributions, Environment, Requirement,
+    Distribution, PathMetadata, EggMetadata, WorkingSet, DistributionNotFound,
+    VersionConflict, DEVELOP_DIST,
+)
+import pkg_resources
+
+__metaclass__ = type
+
+# Turn on PEP440Warnings
+warnings.filterwarnings("default", category=pkg_resources.PEP440Warning)
+
+__all__ = [
+    'samefile', 'easy_install', 'PthDistributions', 'extract_wininst_cfg',
+    'main', 'get_exe_prefixes',
+]
+
+
+def is_64bit():
+    return struct.calcsize("P") == 8
+
+
+def samefile(p1, p2):
+    """
+    Determine if two paths reference the same file.
+
+    Augments os.path.samefile to work on Windows and
+    suppresses errors if the path doesn't exist.
+    """
+    both_exist = os.path.exists(p1) and os.path.exists(p2)
+    use_samefile = hasattr(os.path, 'samefile') and both_exist
+    if use_samefile:
+        return os.path.samefile(p1, p2)
+    norm_p1 = os.path.normpath(os.path.normcase(p1))
+    norm_p2 = os.path.normpath(os.path.normcase(p2))
+    return norm_p1 == norm_p2
+
+
+if six.PY2:
+
+    def _to_bytes(s):
+        return s
+
+    def isascii(s):
+        try:
+            six.text_type(s, 'ascii')
+            return True
+        except UnicodeError:
+            return False
+else:
+
+    def _to_bytes(s):
+        return s.encode('utf8')
+
+    def isascii(s):
+        try:
+            s.encode('ascii')
+            return True
+        except UnicodeError:
+            return False
+
+
+def _one_liner(text):
+    return textwrap.dedent(text).strip().replace('\n', '; ')
+
+
+class easy_install(Command):
+    """Manage a download/build/install process"""
+    description = "Find/get/install Python packages"
+    command_consumes_arguments = True
+
+    user_options = [
+        ('prefix=', None, "installation prefix"),
+        ("zip-ok", "z", "install package as a zipfile"),
+        ("multi-version", "m", "make apps have to require() a version"),
+        ("upgrade", "U", "force upgrade (searches PyPI for latest versions)"),
+        ("install-dir=", "d", "install package to DIR"),
+        ("script-dir=", "s", "install scripts to DIR"),
+        ("exclude-scripts", "x", "Don't install scripts"),
+        ("always-copy", "a", "Copy all needed packages to install dir"),
+        ("index-url=", "i", "base URL of Python Package Index"),
+        ("find-links=", "f", "additional URL(s) to search for packages"),
+        ("build-directory=", "b",
+         "download/extract/build in DIR; keep the results"),
+        ('optimize=', 'O',
+         "also compile with optimization: -O1 for \"python -O\", "
+         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
+        ('record=', None,
+         "filename in which to record list of installed files"),
+        ('always-unzip', 'Z', "don't install as a zipfile, no matter what"),
+        ('site-dirs=', 'S', "list of directories where .pth files work"),
+        ('editable', 'e', "Install specified packages in editable form"),
+        ('no-deps', 'N', "don't install dependencies"),
+        ('allow-hosts=', 'H', "pattern(s) that hostnames must match"),
+        ('local-snapshots-ok', 'l',
+         "allow building eggs from local checkouts"),
+        ('version', None, "print version information and exit"),
+        ('no-find-links', None,
+         "Don't load find-links defined in packages being installed"),
+        ('user', None, "install in user site-package '%s'" % site.USER_SITE)
+    ]
+    boolean_options = [
+        'zip-ok', 'multi-version', 'exclude-scripts', 'upgrade', 'always-copy',
+        'editable',
+        'no-deps', 'local-snapshots-ok', 'version',
+        'user'
+    ]
+
+    negative_opt = {'always-unzip': 'zip-ok'}
+    create_index = PackageIndex
+
+    def initialize_options(self):
+        # the --user option seems to be an opt-in one,
+        # so the default should be False.
+        self.user = 0
+        self.zip_ok = self.local_snapshots_ok = None
+        self.install_dir = self.script_dir = self.exclude_scripts = None
+        self.index_url = None
+        self.find_links = None
+        self.build_directory = None
+        self.args = None
+        self.optimize = self.record = None
+        self.upgrade = self.always_copy = self.multi_version = None
+        self.editable = self.no_deps = self.allow_hosts = None
+        self.root = self.prefix = self.no_report = None
+        self.version = None
+        self.install_purelib = None  # for pure module distributions
+        self.install_platlib = None  # non-pure (dists w/ extensions)
+        self.install_headers = None  # for C/C++ headers
+        self.install_lib = None  # set to either purelib or platlib
+        self.install_scripts = None
+        self.install_data = None
+        self.install_base = None
+        self.install_platbase = None
+        if site.ENABLE_USER_SITE:
+            self.install_userbase = site.USER_BASE
+            self.install_usersite = site.USER_SITE
+        else:
+            self.install_userbase = None
+            self.install_usersite = None
+        self.no_find_links = None
+
+        # Options not specifiable via command line
+        self.package_index = None
+        self.pth_file = self.always_copy_from = None
+        self.site_dirs = None
+        self.installed_projects = {}
+        # Always read easy_install options, even if we are subclassed, or have
+        # an independent instance created.  This ensures that defaults will
+        # always come from the standard configuration file(s)' "easy_install"
+        # section, even if this is a "develop" or "install" command, or some
+        # other embedding.
+        self._dry_run = None
+        self.verbose = self.distribution.verbose
+        self.distribution._set_command_options(
+            self, self.distribution.get_option_dict('easy_install')
+        )
+
+    def delete_blockers(self, blockers):
+        extant_blockers = (
+            filename for filename in blockers
+            if os.path.exists(filename) or os.path.islink(filename)
+        )
+        list(map(self._delete_path, extant_blockers))
+
+    def _delete_path(self, path):
+        log.info("Deleting %s", path)
+        if self.dry_run:
+            return
+
+        is_tree = os.path.isdir(path) and not os.path.islink(path)
+        remover = rmtree if is_tree else os.unlink
+        remover(path)
+
+    @staticmethod
+    def _render_version():
+        """
+        Render the Setuptools version and installation details, then exit.
+        """
+        ver = '{}.{}'.format(*sys.version_info)
+        dist = get_distribution('setuptools')
+        tmpl = 'setuptools {dist.version} from {dist.location} (Python {ver})'
+        print(tmpl.format(**locals()))
+        raise SystemExit()
+
+    def finalize_options(self):
+        self.version and self._render_version()
+
+        py_version = sys.version.split()[0]
+        prefix, exec_prefix = get_config_vars('prefix', 'exec_prefix')
+
+        self.config_vars = {
+            'dist_name': self.distribution.get_name(),
+            'dist_version': self.distribution.get_version(),
+            'dist_fullname': self.distribution.get_fullname(),
+            'py_version': py_version,
+            'py_version_short': py_version[0:3],
+            'py_version_nodot': py_version[0] + py_version[2],
+            'sys_prefix': prefix,
+            'prefix': prefix,
+            'sys_exec_prefix': exec_prefix,
+            'exec_prefix': exec_prefix,
+            # Only python 3.2+ has abiflags
+            'abiflags': getattr(sys, 'abiflags', ''),
+        }
+
+        if site.ENABLE_USER_SITE:
+            self.config_vars['userbase'] = self.install_userbase
+            self.config_vars['usersite'] = self.install_usersite
+
+        elif self.user:
+            log.warn("WARNING: The user site-packages directory is disabled.")
+
+        self._fix_install_dir_for_user_site()
+
+        self.expand_basedirs()
+        self.expand_dirs()
+
+        self._expand(
+            'install_dir', 'script_dir', 'build_directory',
+            'site_dirs',
+        )
+        # If a non-default installation directory was specified, default the
+        # script directory to match it.
+        if self.script_dir is None:
+            self.script_dir = self.install_dir
+
+        if self.no_find_links is None:
+            self.no_find_links = False
+
+        # Let install_dir get set by install_lib command, which in turn
+        # gets its info from the install command, and takes into account
+        # --prefix and --home and all that other crud.
+        self.set_undefined_options(
+            'install_lib', ('install_dir', 'install_dir')
+        )
+        # Likewise, set default script_dir from 'install_scripts.install_dir'
+        self.set_undefined_options(
+            'install_scripts', ('install_dir', 'script_dir')
+        )
+
+        if self.user and self.install_purelib:
+            self.install_dir = self.install_purelib
+            self.script_dir = self.install_scripts
+        # default --record from the install command
+        self.set_undefined_options('install', ('record', 'record'))
+        # Should this be moved to the if statement below? It's not used
+        # elsewhere
+        normpath = map(normalize_path, sys.path)
+        self.all_site_dirs = get_site_dirs()
+        if self.site_dirs is not None:
+            site_dirs = [
+                os.path.expanduser(s.strip()) for s in
+                self.site_dirs.split(',')
+            ]
+            for d in site_dirs:
+                if not os.path.isdir(d):
+                    log.warn("%s (in --site-dirs) does not exist", d)
+                elif normalize_path(d) not in normpath:
+                    raise DistutilsOptionError(
+                        d + " (in --site-dirs) is not on sys.path"
+                    )
+                else:
+                    self.all_site_dirs.append(normalize_path(d))
+        if not self.editable:
+            self.check_site_dir()
+        self.index_url = self.index_url or "https://pypi.org/simple/"
+        self.shadow_path = self.all_site_dirs[:]
+        for path_item in self.install_dir, normalize_path(self.script_dir):
+            if path_item not in self.shadow_path:
+                self.shadow_path.insert(0, path_item)
+
+        if self.allow_hosts is not None:
+            hosts = [s.strip() for s in self.allow_hosts.split(',')]
+        else:
+            hosts = ['*']
+        if self.package_index is None:
+            self.package_index = self.create_index(
+                self.index_url, search_path=self.shadow_path, hosts=hosts,
+            )
+        self.local_index = Environment(self.shadow_path + sys.path)
+
+        if self.find_links is not None:
+            if isinstance(self.find_links, six.string_types):
+                self.find_links = self.find_links.split()
+        else:
+            self.find_links = []
+        if self.local_snapshots_ok:
+            self.package_index.scan_egg_links(self.shadow_path + sys.path)
+        if not self.no_find_links:
+            self.package_index.add_find_links(self.find_links)
+        self.set_undefined_options('install_lib', ('optimize', 'optimize'))
+        if not isinstance(self.optimize, int):
+            try:
+                self.optimize = int(self.optimize)
+                if not (0 <= self.optimize <= 2):
+                    raise ValueError
+            except ValueError as e:
+                raise DistutilsOptionError(
+                    "--optimize must be 0, 1, or 2"
+                ) from e
+
+        if self.editable and not self.build_directory:
+            raise DistutilsArgError(
+                "Must specify a build directory (-b) when using --editable"
+            )
+        if not self.args:
+            raise DistutilsArgError(
+                "No urls, filenames, or requirements specified (see --help)")
+
+        self.outputs = []
+
+    def _fix_install_dir_for_user_site(self):
+        """
+        Fix the install_dir if "--user" was used.
+        """
+        if not self.user or not site.ENABLE_USER_SITE:
+            return
+
+        self.create_home_path()
+        if self.install_userbase is None:
+            msg = "User base directory is not specified"
+            raise DistutilsPlatformError(msg)
+        self.install_base = self.install_platbase = self.install_userbase
+        scheme_name = os.name.replace('posix', 'unix') + '_user'
+        self.select_scheme(scheme_name)
+
+    def _expand_attrs(self, attrs):
+        for attr in attrs:
+            val = getattr(self, attr)
+            if val is not None:
+                if os.name == 'posix' or os.name == 'nt':
+                    val = os.path.expanduser(val)
+                val = subst_vars(val, self.config_vars)
+                setattr(self, attr, val)
+
+    def expand_basedirs(self):
+        """Calls `os.path.expanduser` on install_base, install_platbase and
+        root."""
+        self._expand_attrs(['install_base', 'install_platbase', 'root'])
+
+    def expand_dirs(self):
+        """Calls `os.path.expanduser` on install dirs."""
+        dirs = [
+            'install_purelib',
+            'install_platlib',
+            'install_lib',
+            'install_headers',
+            'install_scripts',
+            'install_data',
+        ]
+        self._expand_attrs(dirs)
+
+    def run(self, show_deprecation=True):
+        if show_deprecation:
+            self.announce(
+                "WARNING: The easy_install command is deprecated "
+                "and will be removed in a future version.",
+                log.WARN,
+            )
+        if self.verbose != self.distribution.verbose:
+            log.set_verbosity(self.verbose)
+        try:
+            for spec in self.args:
+                self.easy_install(spec, not self.no_deps)
+            if self.record:
+                outputs = self.outputs
+                if self.root:  # strip any package prefix
+                    root_len = len(self.root)
+                    for counter in range(len(outputs)):
+                        outputs[counter] = outputs[counter][root_len:]
+                from distutils import file_util
+
+                self.execute(
+                    file_util.write_file, (self.record, outputs),
+                    "writing list of installed files to '%s'" %
+                    self.record
+                )
+            self.warn_deprecated_options()
+        finally:
+            log.set_verbosity(self.distribution.verbose)
+
+    def pseudo_tempname(self):
+        """Return a pseudo-tempname base in the install directory.
+        This code is intentionally naive; if a malicious party can write to
+        the target directory you're already in deep doodoo.
+        """
+        try:
+            pid = os.getpid()
+        except Exception:
+            pid = random.randint(0, sys.maxsize)
+        return os.path.join(self.install_dir, "test-easy-install-%s" % pid)
+
+    def warn_deprecated_options(self):
+        pass
+
+    def check_site_dir(self):
+        """Verify that self.install_dir is .pth-capable dir, if needed"""
+
+        instdir = normalize_path(self.install_dir)
+        pth_file = os.path.join(instdir, 'easy-install.pth')
+
+        if not os.path.exists(instdir):
+            try:
+                os.makedirs(instdir)
+            except (OSError, IOError):
+                self.cant_write_to_target()
+
+        # Is it a configured, PYTHONPATH, implicit, or explicit site dir?
+        is_site_dir = instdir in self.all_site_dirs
+
+        if not is_site_dir and not self.multi_version:
+            # No?  Then directly test whether it does .pth file processing
+            is_site_dir = self.check_pth_processing()
+        else:
+            # make sure we can write to target dir
+            testfile = self.pseudo_tempname() + '.write-test'
+            test_exists = os.path.exists(testfile)
+            try:
+                if test_exists:
+                    os.unlink(testfile)
+                open(testfile, 'w').close()
+                os.unlink(testfile)
+            except (OSError, IOError):
+                self.cant_write_to_target()
+
+        if not is_site_dir and not self.multi_version:
+            # Can't install non-multi to non-site dir with easy_install
+            pythonpath = os.environ.get('PYTHONPATH', '')
+            log.warn(self.__no_default_msg, self.install_dir, pythonpath)
+
+        if is_site_dir:
+            if self.pth_file is None:
+                self.pth_file = PthDistributions(pth_file, self.all_site_dirs)
+        else:
+            self.pth_file = None
+
+        if self.multi_version and not os.path.exists(pth_file):
+            self.pth_file = None  # don't create a .pth file
+        self.install_dir = instdir
+
+    __cant_write_msg = textwrap.dedent("""
+        can't create or remove files in install directory
+
+        The following error occurred while trying to add or remove files in the
+        installation directory:
+
+            %s
+
+        The installation directory you specified (via --install-dir, --prefix, or
+        the distutils default setting) was:
+
+            %s
+        """).lstrip()  # noqa
+
+    __not_exists_id = textwrap.dedent("""
+        This directory does not currently exist.  Please create it and try again, or
+        choose a different installation directory (using the -d or --install-dir
+        option).
+        """).lstrip()  # noqa
+
+    __access_msg = textwrap.dedent("""
+        Perhaps your account does not have write access to this directory?  If the
+        installation directory is a system-owned directory, you may need to sign in
+        as the administrator or "root" account.  If you do not have administrative
+        access to this machine, you may wish to choose a different installation
+        directory, preferably one that is listed in your PYTHONPATH environment
+        variable.
+
+        For information on other options, you may wish to consult the
+        documentation at:
+
+          https://setuptools.readthedocs.io/en/latest/easy_install.html
+
+        Please make the appropriate changes for your system and try again.
+        """).lstrip()  # noqa
+
+    def cant_write_to_target(self):
+        msg = self.__cant_write_msg % (sys.exc_info()[1], self.install_dir,)
+
+        if not os.path.exists(self.install_dir):
+            msg += '\n' + self.__not_exists_id
+        else:
+            msg += '\n' + self.__access_msg
+        raise DistutilsError(msg)
+
+    def check_pth_processing(self):
+        """Empirically verify whether .pth files are supported in inst. dir"""
+        instdir = self.install_dir
+        log.info("Checking .pth file support in %s", instdir)
+        pth_file = self.pseudo_tempname() + ".pth"
+        ok_file = pth_file + '.ok'
+        ok_exists = os.path.exists(ok_file)
+        tmpl = _one_liner("""
+            import os
+            f = open({ok_file!r}, 'w')
+            f.write('OK')
+            f.close()
+            """) + '\n'
+        try:
+            if ok_exists:
+                os.unlink(ok_file)
+            dirname = os.path.dirname(ok_file)
+            os.makedirs(dirname, exist_ok=True)
+            f = open(pth_file, 'w')
+        except (OSError, IOError):
+            self.cant_write_to_target()
+        else:
+            try:
+                f.write(tmpl.format(**locals()))
+                f.close()
+                f = None
+                executable = sys.executable
+                if os.name == 'nt':
+                    dirname, basename = os.path.split(executable)
+                    alt = os.path.join(dirname, 'pythonw.exe')
+                    use_alt = (
+                        basename.lower() == 'python.exe' and
+                        os.path.exists(alt)
+                    )
+                    if use_alt:
+                        # use pythonw.exe to avoid opening a console window
+                        executable = alt
+
+                from distutils.spawn import spawn
+
+                spawn([executable, '-E', '-c', 'pass'], 0)
+
+                if os.path.exists(ok_file):
+                    log.info(
+                        "TEST PASSED: %s appears to support .pth files",
+                        instdir
+                    )
+                    return True
+            finally:
+                if f:
+                    f.close()
+                if os.path.exists(ok_file):
+                    os.unlink(ok_file)
+                if os.path.exists(pth_file):
+                    os.unlink(pth_file)
+        if not self.multi_version:
+            log.warn("TEST FAILED: %s does NOT support .pth files", instdir)
+        return False
+
+    def install_egg_scripts(self, dist):
+        """Write all the scripts for `dist`, unless scripts are excluded"""
+        if not self.exclude_scripts and dist.metadata_isdir('scripts'):
+            for script_name in dist.metadata_listdir('scripts'):
+                if dist.metadata_isdir('scripts/' + script_name):
+                    # The "script" is a directory, likely a Python 3
+                    # __pycache__ directory, so skip it.
+                    continue
+                self.install_script(
+                    dist, script_name,
+                    dist.get_metadata('scripts/' + script_name)
+                )
+        self.install_wrapper_scripts(dist)
+
+    def add_output(self, path):
+        if os.path.isdir(path):
+            for base, dirs, files in os.walk(path):
+                for filename in files:
+                    self.outputs.append(os.path.join(base, filename))
+        else:
+            self.outputs.append(path)
+
+    def not_editable(self, spec):
+        if self.editable:
+            raise DistutilsArgError(
+                "Invalid argument %r: you can't use filenames or URLs "
+                "with --editable (except via the --find-links option)."
+                % (spec,)
+            )
+
+    def check_editable(self, spec):
+        if not self.editable:
+            return
+
+        if os.path.exists(os.path.join(self.build_directory, spec.key)):
+            raise DistutilsArgError(
+                "%r already exists in %s; can't do a checkout there" %
+                (spec.key, self.build_directory)
+            )
+
+    @contextlib.contextmanager
+    def _tmpdir(self):
+        tmpdir = tempfile.mkdtemp(prefix=u"easy_install-")
+        try:
+            # cast to str as workaround for #709 and #710 and #712
+            yield str(tmpdir)
+        finally:
+            os.path.exists(tmpdir) and rmtree(rmtree_safe(tmpdir))
+
+    def easy_install(self, spec, deps=False):
+        with self._tmpdir() as tmpdir:
+            if not isinstance(spec, Requirement):
+                if URL_SCHEME(spec):
+                    # It's a url, download it to tmpdir and process
+                    self.not_editable(spec)
+                    dl = self.package_index.download(spec, tmpdir)
+                    return self.install_item(None, dl, tmpdir, deps, True)
+
+                elif os.path.exists(spec):
+                    # Existing file or directory, just process it directly
+                    self.not_editable(spec)
+                    return self.install_item(None, spec, tmpdir, deps, True)
+                else:
+                    spec = parse_requirement_arg(spec)
+
+            self.check_editable(spec)
+            dist = self.package_index.fetch_distribution(
+                spec, tmpdir, self.upgrade, self.editable,
+                not self.always_copy, self.local_index
+            )
+            if dist is None:
+                msg = "Could not find suitable distribution for %r" % spec
+                if self.always_copy:
+                    msg += " (--always-copy skips system and development eggs)"
+                raise DistutilsError(msg)
+            elif dist.precedence == DEVELOP_DIST:
+                # .egg-info dists don't need installing, just process deps
+                self.process_distribution(spec, dist, deps, "Using")
+                return dist
+            else:
+                return self.install_item(spec, dist.location, tmpdir, deps)
+
+    def install_item(self, spec, download, tmpdir, deps, install_needed=False):
+
+        # Installation is also needed if file in tmpdir or is not an egg
+        install_needed = install_needed or self.always_copy
+        install_needed = install_needed or os.path.dirname(download) == tmpdir
+        install_needed = install_needed or not download.endswith('.egg')
+        install_needed = install_needed or (
+            self.always_copy_from is not None and
+            os.path.dirname(normalize_path(download)) ==
+            normalize_path(self.always_copy_from)
+        )
+
+        if spec and not install_needed:
+            # at this point, we know it's a local .egg, we just don't know if
+            # it's already installed.
+            for dist in self.local_index[spec.project_name]:
+                if dist.location == download:
+                    break
+            else:
+                install_needed = True  # it's not in the local index
+
+        log.info("Processing %s", os.path.basename(download))
+
+        if install_needed:
+            dists = self.install_eggs(spec, download, tmpdir)
+            for dist in dists:
+                self.process_distribution(spec, dist, deps)
+        else:
+            dists = [self.egg_distribution(download)]
+            self.process_distribution(spec, dists[0], deps, "Using")
+
+        if spec is not None:
+            for dist in dists:
+                if dist in spec:
+                    return dist
+
+    def select_scheme(self, name):
+        """Sets the install directories by applying the install schemes."""
+        # it's the caller's problem if they supply a bad name!
+        scheme = INSTALL_SCHEMES[name]
+        for key in SCHEME_KEYS:
+            attrname = 'install_' + key
+            if getattr(self, attrname) is None:
+                setattr(self, attrname, scheme[key])
+
+    def process_distribution(self, requirement, dist, deps=True, *info):
+        self.update_pth(dist)
+        self.package_index.add(dist)
+        if dist in self.local_index[dist.key]:
+            self.local_index.remove(dist)
+        self.local_index.add(dist)
+        self.install_egg_scripts(dist)
+        self.installed_projects[dist.key] = dist
+        log.info(self.installation_report(requirement, dist, *info))
+        if (dist.has_metadata('dependency_links.txt') and
+                not self.no_find_links):
+            self.package_index.add_find_links(
+                dist.get_metadata_lines('dependency_links.txt')
+            )
+        if not deps and not self.always_copy:
+            return
+        elif requirement is not None and dist.key != requirement.key:
+            log.warn("Skipping dependencies for %s", dist)
+            return  # XXX this is not the distribution we were looking for
+        elif requirement is None or dist not in requirement:
+            # if we wound up with a different version, resolve what we've got
+            distreq = dist.as_requirement()
+            requirement = Requirement(str(distreq))
+        log.info("Processing dependencies for %s", requirement)
+        try:
+            distros = WorkingSet([]).resolve(
+                [requirement], self.local_index, self.easy_install
+            )
+        except DistributionNotFound as e:
+            raise DistutilsError(str(e)) from e
+        except VersionConflict as e:
+            raise DistutilsError(e.report()) from e
+        if self.always_copy or self.always_copy_from:
+            # Force all the relevant distros to be copied or activated
+            for dist in distros:
+                if dist.key not in self.installed_projects:
+                    self.easy_install(dist.as_requirement())
+        log.info("Finished processing dependencies for %s", requirement)
+
+    def should_unzip(self, dist):
+        if self.zip_ok is not None:
+            return not self.zip_ok
+        if dist.has_metadata('not-zip-safe'):
+            return True
+        if not dist.has_metadata('zip-safe'):
+            return True
+        return False
+
+    def maybe_move(self, spec, dist_filename, setup_base):
+        dst = os.path.join(self.build_directory, spec.key)
+        if os.path.exists(dst):
+            msg = (
+                "%r already exists in %s; build directory %s will not be kept"
+            )
+            log.warn(msg, spec.key, self.build_directory, setup_base)
+            return setup_base
+        if os.path.isdir(dist_filename):
+            setup_base = dist_filename
+        else:
+            if os.path.dirname(dist_filename) == setup_base:
+                os.unlink(dist_filename)  # get it out of the tmp dir
+            contents = os.listdir(setup_base)
+            if len(contents) == 1:
+                dist_filename = os.path.join(setup_base, contents[0])
+                if os.path.isdir(dist_filename):
+                    # if the only thing there is a directory, move it instead
+                    setup_base = dist_filename
+        ensure_directory(dst)
+        shutil.move(setup_base, dst)
+        return dst
+
+    def install_wrapper_scripts(self, dist):
+        if self.exclude_scripts:
+            return
+        for args in ScriptWriter.best().get_args(dist):
+            self.write_script(*args)
+
+    def install_script(self, dist, script_name, script_text, dev_path=None):
+        """Generate a legacy script wrapper and install it"""
+        spec = str(dist.as_requirement())
+        is_script = is_python_script(script_text, script_name)
+
+        if is_script:
+            body = self._load_template(dev_path) % locals()
+            script_text = ScriptWriter.get_header(script_text) + body
+        self.write_script(script_name, _to_bytes(script_text), 'b')
+
+    @staticmethod
+    def _load_template(dev_path):
+        """
+        There are a couple of template scripts in the package. This
+        function loads one of them and prepares it for use.
+        """
+        # See https://github.com/pypa/setuptools/issues/134 for info
+        # on script file naming and downstream issues with SVR4
+        name = 'script.tmpl'
+        if dev_path:
+            name = name.replace('.tmpl', ' (dev).tmpl')
+
+        raw_bytes = resource_string('setuptools', name)
+        return raw_bytes.decode('utf-8')
+
+    def write_script(self, script_name, contents, mode="t", blockers=()):
+        """Write an executable file to the scripts directory"""
+        self.delete_blockers(  # clean up old .py/.pyw w/o a script
+            [os.path.join(self.script_dir, x) for x in blockers]
+        )
+        log.info("Installing %s script to %s", script_name, self.script_dir)
+        target = os.path.join(self.script_dir, script_name)
+        self.add_output(target)
+
+        if self.dry_run:
+            return
+
+        mask = current_umask()
+        ensure_directory(target)
+        if os.path.exists(target):
+            os.unlink(target)
+        with open(target, "w" + mode) as f:
+            f.write(contents)
+        chmod(target, 0o777 - mask)
+
+    def install_eggs(self, spec, dist_filename, tmpdir):
+        # .egg dirs or files are already built, so just return them
+        if dist_filename.lower().endswith('.egg'):
+            return [self.install_egg(dist_filename, tmpdir)]
+        elif dist_filename.lower().endswith('.exe'):
+            return [self.install_exe(dist_filename, tmpdir)]
+        elif dist_filename.lower().endswith('.whl'):
+            return [self.install_wheel(dist_filename, tmpdir)]
+
+        # Anything else, try to extract and build
+        setup_base = tmpdir
+        if os.path.isfile(dist_filename) and not dist_filename.endswith('.py'):
+            unpack_archive(dist_filename, tmpdir, self.unpack_progress)
+        elif os.path.isdir(dist_filename):
+            setup_base = os.path.abspath(dist_filename)
+
+        if (setup_base.startswith(tmpdir)  # something we downloaded
+                and self.build_directory and spec is not None):
+            setup_base = self.maybe_move(spec, dist_filename, setup_base)
+
+        # Find the setup.py file
+        setup_script = os.path.join(setup_base, 'setup.py')
+
+        if not os.path.exists(setup_script):
+            setups = glob(os.path.join(setup_base, '*', 'setup.py'))
+            if not setups:
+                raise DistutilsError(
+                    "Couldn't find a setup script in %s" %
+                    os.path.abspath(dist_filename)
+                )
+            if len(setups) > 1:
+                raise DistutilsError(
+                    "Multiple setup scripts in %s" %
+                    os.path.abspath(dist_filename)
+                )
+            setup_script = setups[0]
+
+        # Now run it, and return the result
+        if self.editable:
+            log.info(self.report_editable(spec, setup_script))
+            return []
+        else:
+            return self.build_and_install(setup_script, setup_base)
+
+    def egg_distribution(self, egg_path):
+        if os.path.isdir(egg_path):
+            metadata = PathMetadata(egg_path, os.path.join(egg_path,
+                                                           'EGG-INFO'))
+        else:
+            metadata = EggMetadata(zipimport.zipimporter(egg_path))
+        return Distribution.from_filename(egg_path, metadata=metadata)
+
+    def install_egg(self, egg_path, tmpdir):
+        destination = os.path.join(
+            self.install_dir,
+            os.path.basename(egg_path),
+        )
+        destination = os.path.abspath(destination)
+        if not self.dry_run:
+            ensure_directory(destination)
+
+        dist = self.egg_distribution(egg_path)
+        if not samefile(egg_path, destination):
+            if os.path.isdir(destination) and not os.path.islink(destination):
+                dir_util.remove_tree(destination, dry_run=self.dry_run)
+            elif os.path.exists(destination):
+                self.execute(
+                    os.unlink,
+                    (destination,),
+                    "Removing " + destination,
+                )
+            try:
+                new_dist_is_zipped = False
+                if os.path.isdir(egg_path):
+                    if egg_path.startswith(tmpdir):
+                        f, m = shutil.move, "Moving"
+                    else:
+                        f, m = shutil.copytree, "Copying"
+                elif self.should_unzip(dist):
+                    self.mkpath(destination)
+                    f, m = self.unpack_and_compile, "Extracting"
+                else:
+                    new_dist_is_zipped = True
+                    if egg_path.startswith(tmpdir):
+                        f, m = shutil.move, "Moving"
+                    else:
+                        f, m = shutil.copy2, "Copying"
+                self.execute(
+                    f,
+                    (egg_path, destination),
+                    (m + " %s to %s") % (
+                        os.path.basename(egg_path),
+                        os.path.dirname(destination)
+                    ),
+                )
+                update_dist_caches(
+                    destination,
+                    fix_zipimporter_caches=new_dist_is_zipped,
+                )
+            except Exception:
+                update_dist_caches(destination, fix_zipimporter_caches=False)
+                raise
+
+        self.add_output(destination)
+        return self.egg_distribution(destination)
+
+    def install_exe(self, dist_filename, tmpdir):
+        # See if it's valid, get data
+        cfg = extract_wininst_cfg(dist_filename)
+        if cfg is None:
+            raise DistutilsError(
+                "%s is not a valid distutils Windows .exe" % dist_filename
+            )
+        # Create a dummy distribution object until we build the real distro
+        dist = Distribution(
+            None,
+            project_name=cfg.get('metadata', 'name'),
+            version=cfg.get('metadata', 'version'), platform=get_platform(),
+        )
+
+        # Convert the .exe to an unpacked egg
+        egg_path = os.path.join(tmpdir, dist.egg_name() + '.egg')
+        dist.location = egg_path
+        egg_tmp = egg_path + '.tmp'
+        _egg_info = os.path.join(egg_tmp, 'EGG-INFO')
+        pkg_inf = os.path.join(_egg_info, 'PKG-INFO')
+        ensure_directory(pkg_inf)  # make sure EGG-INFO dir exists
+        dist._provider = PathMetadata(egg_tmp, _egg_info)  # XXX
+        self.exe_to_egg(dist_filename, egg_tmp)
+
+        # Write EGG-INFO/PKG-INFO
+        if not os.path.exists(pkg_inf):
+            f = open(pkg_inf, 'w')
+            f.write('Metadata-Version: 1.0\n')
+            for k, v in cfg.items('metadata'):
+                if k != 'target_version':
+                    f.write('%s: %s\n' % (k.replace('_', '-').title(), v))
+            f.close()
+        script_dir = os.path.join(_egg_info, 'scripts')
+        # delete entry-point scripts to avoid duping
+        self.delete_blockers([
+            os.path.join(script_dir, args[0])
+            for args in ScriptWriter.get_args(dist)
+        ])
+        # Build .egg file from tmpdir
+        bdist_egg.make_zipfile(
+            egg_path, egg_tmp, verbose=self.verbose, dry_run=self.dry_run,
+        )
+        # install the .egg
+        return self.install_egg(egg_path, tmpdir)
+
+    def exe_to_egg(self, dist_filename, egg_tmp):
+        """Extract a bdist_wininst to the directories an egg would use"""
+        # Check for .pth file and set up prefix translations
+        prefixes = get_exe_prefixes(dist_filename)
+        to_compile = []
+        native_libs = []
+        top_level = {}
+
+        def process(src, dst):
+            s = src.lower()
+            for old, new in prefixes:
+                if s.startswith(old):
+                    src = new + src[len(old):]
+                    parts = src.split('/')
+                    dst = os.path.join(egg_tmp, *parts)
+                    dl = dst.lower()
+                    if dl.endswith('.pyd') or dl.endswith('.dll'):
+                        parts[-1] = bdist_egg.strip_module(parts[-1])
+                        top_level[os.path.splitext(parts[0])[0]] = 1
+                        native_libs.append(src)
+                    elif dl.endswith('.py') and old != 'SCRIPTS/':
+                        top_level[os.path.splitext(parts[0])[0]] = 1
+                        to_compile.append(dst)
+                    return dst
+            if not src.endswith('.pth'):
+                log.warn("WARNING: can't process %s", src)
+            return None
+
+        # extract, tracking .pyd/.dll->native_libs and .py -> to_compile
+        unpack_archive(dist_filename, egg_tmp, process)
+        stubs = []
+        for res in native_libs:
+            if res.lower().endswith('.pyd'):  # create stubs for .pyd's
+                parts = res.split('/')
+                resource = parts[-1]
+                parts[-1] = bdist_egg.strip_module(parts[-1]) + '.py'
+                pyfile = os.path.join(egg_tmp, *parts)
+                to_compile.append(pyfile)
+                stubs.append(pyfile)
+                bdist_egg.write_stub(resource, pyfile)
+        self.byte_compile(to_compile)  # compile .py's
+        bdist_egg.write_safety_flag(
+            os.path.join(egg_tmp, 'EGG-INFO'),
+            bdist_egg.analyze_egg(egg_tmp, stubs))  # write zip-safety flag
+
+        for name in 'top_level', 'native_libs':
+            if locals()[name]:
+                txt = os.path.join(egg_tmp, 'EGG-INFO', name + '.txt')
+                if not os.path.exists(txt):
+                    f = open(txt, 'w')
+                    f.write('\n'.join(locals()[name]) + '\n')
+                    f.close()
+
+    def install_wheel(self, wheel_path, tmpdir):
+        wheel = Wheel(wheel_path)
+        assert wheel.is_compatible()
+        destination = os.path.join(self.install_dir, wheel.egg_name())
+        destination = os.path.abspath(destination)
+        if not self.dry_run:
+            ensure_directory(destination)
+        if os.path.isdir(destination) and not os.path.islink(destination):
+            dir_util.remove_tree(destination, dry_run=self.dry_run)
+        elif os.path.exists(destination):
+            self.execute(
+                os.unlink,
+                (destination,),
+                "Removing " + destination,
+            )
+        try:
+            self.execute(
+                wheel.install_as_egg,
+                (destination,),
+                ("Installing %s to %s") % (
+                    os.path.basename(wheel_path),
+                    os.path.dirname(destination)
+                ),
+            )
+        finally:
+            update_dist_caches(destination, fix_zipimporter_caches=False)
+        self.add_output(destination)
+        return self.egg_distribution(destination)
+
+    __mv_warning = textwrap.dedent("""
+        Because this distribution was installed --multi-version, before you can
+        import modules from this package in an application, you will need to
+        'import pkg_resources' and then use a 'require()' call similar to one of
+        these examples, in order to select the desired version:
+
+            pkg_resources.require("%(name)s")  # latest installed version
+            pkg_resources.require("%(name)s==%(version)s")  # this exact version
+            pkg_resources.require("%(name)s>=%(version)s")  # this version or higher
+        """).lstrip()  # noqa
+
+    __id_warning = textwrap.dedent("""
+        Note also that the installation directory must be on sys.path at runtime for
+        this to work.  (e.g. by being the application's script directory, by being on
+        PYTHONPATH, or by being added to sys.path by your code.)
+        """)  # noqa
+
+    def installation_report(self, req, dist, what="Installed"):
+        """Helpful installation message for display to package users"""
+        msg = "\n%(what)s %(eggloc)s%(extras)s"
+        if self.multi_version and not self.no_report:
+            msg += '\n' + self.__mv_warning
+            if self.install_dir not in map(normalize_path, sys.path):
+                msg += '\n' + self.__id_warning
+
+        eggloc = dist.location
+        name = dist.project_name
+        version = dist.version
+        extras = ''  # TODO: self.report_extras(req, dist)
+        return msg % locals()
+
+    __editable_msg = textwrap.dedent("""
+        Extracted editable version of %(spec)s to %(dirname)s
+
+        If it uses setuptools in its setup script, you can activate it in
+        "development" mode by going to that directory and running::
+
+            %(python)s setup.py develop
+
+        See the setuptools documentation for the "develop" command for more info.
+        """).lstrip()  # noqa
+
+    def report_editable(self, spec, setup_script):
+        dirname = os.path.dirname(setup_script)
+        python = sys.executable
+        return '\n' + self.__editable_msg % locals()
+
+    def run_setup(self, setup_script, setup_base, args):
+        sys.modules.setdefault('distutils.command.bdist_egg', bdist_egg)
+        sys.modules.setdefault('distutils.command.egg_info', egg_info)
+
+        args = list(args)
+        if self.verbose > 2:
+            v = 'v' * (self.verbose - 1)
+            args.insert(0, '-' + v)
+        elif self.verbose < 2:
+            args.insert(0, '-q')
+        if self.dry_run:
+            args.insert(0, '-n')
+        log.info(
+            "Running %s %s", setup_script[len(setup_base) + 1:], ' '.join(args)
+        )
+        try:
+            run_setup(setup_script, args)
+        except SystemExit as v:
+            raise DistutilsError(
+                "Setup script exited with %s" % (v.args[0],)
+            ) from v
+
+    def build_and_install(self, setup_script, setup_base):
+        args = ['bdist_egg', '--dist-dir']
+
+        dist_dir = tempfile.mkdtemp(
+            prefix='egg-dist-tmp-', dir=os.path.dirname(setup_script)
+        )
+        try:
+            self._set_fetcher_options(os.path.dirname(setup_script))
+            args.append(dist_dir)
+
+            self.run_setup(setup_script, setup_base, args)
+            all_eggs = Environment([dist_dir])
+            eggs = []
+            for key in all_eggs:
+                for dist in all_eggs[key]:
+                    eggs.append(self.install_egg(dist.location, setup_base))
+            if not eggs and not self.dry_run:
+                log.warn("No eggs found in %s (setup script problem?)",
+                         dist_dir)
+            return eggs
+        finally:
+            rmtree(dist_dir)
+            log.set_verbosity(self.verbose)  # restore our log verbosity
+
+    def _set_fetcher_options(self, base):
+        """
+        When easy_install is about to run bdist_egg on a source dist, that
+        source dist might have 'setup_requires' directives, requiring
+        additional fetching. Ensure the fetcher options given to easy_install
+        are available to that command as well.
+        """
+        # find the fetch options from easy_install and write them out
+        # to the setup.cfg file.
+        ei_opts = self.distribution.get_option_dict('easy_install').copy()
+        fetch_directives = (
+            'find_links', 'site_dirs', 'index_url', 'optimize', 'allow_hosts',
+        )
+        fetch_options = {}
+        for key, val in ei_opts.items():
+            if key not in fetch_directives:
+                continue
+            fetch_options[key.replace('_', '-')] = val[1]
+        # create a settings dictionary suitable for `edit_config`
+        settings = dict(easy_install=fetch_options)
+        cfg_filename = os.path.join(base, 'setup.cfg')
+        setopt.edit_config(cfg_filename, settings)
+
+    def update_pth(self, dist):
+        if self.pth_file is None:
+            return
+
+        for d in self.pth_file[dist.key]:  # drop old entries
+            if self.multi_version or d.location != dist.location:
+                log.info("Removing %s from easy-install.pth file", d)
+                self.pth_file.remove(d)
+                if d.location in self.shadow_path:
+                    self.shadow_path.remove(d.location)
+
+        if not self.multi_version:
+            if dist.location in self.pth_file.paths:
+                log.info(
+                    "%s is already the active version in easy-install.pth",
+                    dist,
+                )
+            else:
+                log.info("Adding %s to easy-install.pth file", dist)
+                self.pth_file.add(dist)  # add new entry
+                if dist.location not in self.shadow_path:
+                    self.shadow_path.append(dist.location)
+
+        if not self.dry_run:
+
+            self.pth_file.save()
+
+            if dist.key == 'setuptools':
+                # Ensure that setuptools itself never becomes unavailable!
+                # XXX should this check for latest version?
+                filename = os.path.join(self.install_dir, 'setuptools.pth')
+                if os.path.islink(filename):
+                    os.unlink(filename)
+                f = open(filename, 'wt')
+                f.write(self.pth_file.make_relative(dist.location) + '\n')
+                f.close()
+
+    def unpack_progress(self, src, dst):
+        # Progress filter for unpacking
+        log.debug("Unpacking %s to %s", src, dst)
+        return dst  # only unpack-and-compile skips files for dry run
+
+    def unpack_and_compile(self, egg_path, destination):
+        to_compile = []
+        to_chmod = []
+
+        def pf(src, dst):
+            if dst.endswith('.py') and not src.startswith('EGG-INFO/'):
+                to_compile.append(dst)
+            elif dst.endswith('.dll') or dst.endswith('.so'):
+                to_chmod.append(dst)
+            self.unpack_progress(src, dst)
+            return not self.dry_run and dst or None
+
+        unpack_archive(egg_path, destination, pf)
+        self.byte_compile(to_compile)
+        if not self.dry_run:
+            for f in to_chmod:
+                mode = ((os.stat(f)[stat.ST_MODE]) | 0o555) & 0o7755
+                chmod(f, mode)
+
+    def byte_compile(self, to_compile):
+        if sys.dont_write_bytecode:
+            return
+
+        from distutils.util import byte_compile
+
+        try:
+            # try to make the byte compile messages quieter
+            log.set_verbosity(self.verbose - 1)
+
+            byte_compile(to_compile, optimize=0, force=1, dry_run=self.dry_run)
+            if self.optimize:
+                byte_compile(
+                    to_compile, optimize=self.optimize, force=1,
+                    dry_run=self.dry_run,
+                )
+        finally:
+            log.set_verbosity(self.verbose)  # restore original verbosity
+
+    __no_default_msg = textwrap.dedent("""
+        bad install directory or PYTHONPATH
+
+        You are attempting to install a package to a directory that is not
+        on PYTHONPATH and which Python does not read ".pth" files from.  The
+        installation directory you specified (via --install-dir, --prefix, or
+        the distutils default setting) was:
+
+            %s
+
+        and your PYTHONPATH environment variable currently contains:
+
+            %r
+
+        Here are some of your options for correcting the problem:
+
+        * You can choose a different installation directory, i.e., one that is
+          on PYTHONPATH or supports .pth files
+
+        * You can add the installation directory to the PYTHONPATH environment
+          variable.  (It must then also be on PYTHONPATH whenever you run
+          Python and want to use the package(s) you are installing.)
+
+        * You can set up the installation directory to support ".pth" files by
+          using one of the approaches described here:
+
+          https://setuptools.readthedocs.io/en/latest/easy_install.html#custom-installation-locations
+
+
+        Please make the appropriate changes for your system and try again.
+        """).strip()
+
+    def create_home_path(self):
+        """Create directories under ~."""
+        if not self.user:
+            return
+        home = convert_path(os.path.expanduser("~"))
+        for name, path in six.iteritems(self.config_vars):
+            if path.startswith(home) and not os.path.isdir(path):
+                self.debug_print("os.makedirs('%s', 0o700)" % path)
+                os.makedirs(path, 0o700)
+
+    INSTALL_SCHEMES = dict(
+        posix=dict(
+            install_dir='$base/lib/python$py_version_short/site-packages',
+            script_dir='$base/bin',
+        ),
+    )
+
+    DEFAULT_SCHEME = dict(
+        install_dir='$base/Lib/site-packages',
+        script_dir='$base/Scripts',
+    )
+
+    def _expand(self, *attrs):
+        config_vars = self.get_finalized_command('install').config_vars
+
+        if self.prefix:
+            # Set default install_dir/scripts from --prefix
+            config_vars = config_vars.copy()
+            config_vars['base'] = self.prefix
+            scheme = self.INSTALL_SCHEMES.get(os.name, self.DEFAULT_SCHEME)
+            for attr, val in scheme.items():
+                if getattr(self, attr, None) is None:
+                    setattr(self, attr, val)
+
+        from distutils.util import subst_vars
+
+        for attr in attrs:
+            val = getattr(self, attr)
+            if val is not None:
+                val = subst_vars(val, config_vars)
+                if os.name == 'posix':
+                    val = os.path.expanduser(val)
+                setattr(self, attr, val)
+
+
+def _pythonpath():
+    items = os.environ.get('PYTHONPATH', '').split(os.pathsep)
+    return filter(None, items)
+
+
+def get_site_dirs():
+    """
+    Return a list of 'site' dirs
+    """
+
+    sitedirs = []
+
+    # start with PYTHONPATH
+    sitedirs.extend(_pythonpath())
+
+    prefixes = [sys.prefix]
+    if sys.exec_prefix != sys.prefix:
+        prefixes.append(sys.exec_prefix)
+    for prefix in prefixes:
+        if prefix:
+            if sys.platform in ('os2emx', 'riscos'):
+                sitedirs.append(os.path.join(prefix, "Lib", "site-packages"))
+            elif os.sep == '/':
+                sitedirs.extend([
+                    os.path.join(
+                        prefix,
+                        "lib",
+                        "python{}.{}".format(*sys.version_info),
+                        "site-packages",
+                    ),
+                    os.path.join(prefix, "lib", "site-python"),
+                ])
+            else:
+                sitedirs.extend([
+                    prefix,
+                    os.path.join(prefix, "lib", "site-packages"),
+                ])
+            if sys.platform == 'darwin':
+                # for framework builds *only* we add the standard Apple
+                # locations. Currently only per-user, but /Library and
+                # /Network/Library could be added too
+                if 'Python.framework' in prefix:
+                    home = os.environ.get('HOME')
+                    if home:
+                        home_sp = os.path.join(
+                            home,
+                            'Library',
+                            'Python',
+                            '{}.{}'.format(*sys.version_info),
+                            'site-packages',
+                        )
+                        sitedirs.append(home_sp)
+    lib_paths = get_path('purelib'), get_path('platlib')
+    for site_lib in lib_paths:
+        if site_lib not in sitedirs:
+            sitedirs.append(site_lib)
+
+    if site.ENABLE_USER_SITE:
+        sitedirs.append(site.USER_SITE)
+
+    try:
+        sitedirs.extend(site.getsitepackages())
+    except AttributeError:
+        pass
+
+    sitedirs = list(map(normalize_path, sitedirs))
+
+    return sitedirs
+
+
+def expand_paths(inputs):
+    """Yield sys.path directories that might contain "old-style" packages"""
+
+    seen = {}
+
+    for dirname in inputs:
+        dirname = normalize_path(dirname)
+        if dirname in seen:
+            continue
+
+        seen[dirname] = 1
+        if not os.path.isdir(dirname):
+            continue
+
+        files = os.listdir(dirname)
+        yield dirname, files
+
+        for name in files:
+            if not name.endswith('.pth'):
+                # We only care about the .pth files
+                continue
+            if name in ('easy-install.pth', 'setuptools.pth'):
+                # Ignore .pth files that we control
+                continue
+
+            # Read the .pth file
+            f = open(os.path.join(dirname, name))
+            lines = list(yield_lines(f))
+            f.close()
+
+            # Yield existing non-dupe, non-import directory lines from it
+            for line in lines:
+                if not line.startswith("import"):
+                    line = normalize_path(line.rstrip())
+                    if line not in seen:
+                        seen[line] = 1
+                        if not os.path.isdir(line):
+                            continue
+                        yield line, os.listdir(line)
+
+
+def extract_wininst_cfg(dist_filename):
+    """Extract configuration data from a bdist_wininst .exe
+
+    Returns a configparser.RawConfigParser, or None
+    """
+    f = open(dist_filename, 'rb')
+    try:
+        endrec = zipfile._EndRecData(f)
+        if endrec is None:
+            return None
+
+        prepended = (endrec[9] - endrec[5]) - endrec[6]
+        if prepended < 12:  # no wininst data here
+            return None
+        f.seek(prepended - 12)
+
+        tag, cfglen, bmlen = struct.unpack("<iii", f.read(12))
+        if tag not in (0x1234567A, 0x1234567B):
+            return None  # not a valid tag
+
+        f.seek(prepended - (12 + cfglen))
+        init = {'version': '', 'target_version': ''}
+        cfg = configparser.RawConfigParser(init)
+        try:
+            part = f.read(cfglen)
+            # Read up to the first null byte.
+            config = part.split(b'\0', 1)[0]
+            # Now the config is in bytes, but for RawConfigParser, it should
+            #  be text, so decode it.
+            config = config.decode(sys.getfilesystemencoding())
+            cfg.readfp(six.StringIO(config))
+        except configparser.Error:
+            return None
+        if not cfg.has_section('metadata') or not cfg.has_section('Setup'):
+            return None
+        return cfg
+
+    finally:
+        f.close()
+
+
+def get_exe_prefixes(exe_filename):
+    """Get exe->egg path translations for a given .exe file"""
+
+    prefixes = [
+        ('PURELIB/', ''),
+        ('PLATLIB/pywin32_system32', ''),
+        ('PLATLIB/', ''),
+        ('SCRIPTS/', 'EGG-INFO/scripts/'),
+        ('DATA/lib/site-packages', ''),
+    ]
+    z = zipfile.ZipFile(exe_filename)
+    try:
+        for info in z.infolist():
+            name = info.filename
+            parts = name.split('/')
+            if len(parts) == 3 and parts[2] == 'PKG-INFO':
+                if parts[1].endswith('.egg-info'):
+                    prefixes.insert(0, ('/'.join(parts[:2]), 'EGG-INFO/'))
+                    break
+            if len(parts) != 2 or not name.endswith('.pth'):
+                continue
+            if name.endswith('-nspkg.pth'):
+                continue
+            if parts[0].upper() in ('PURELIB', 'PLATLIB'):
+                contents = z.read(name)
+                if not six.PY2:
+                    contents = contents.decode()
+                for pth in yield_lines(contents):
+                    pth = pth.strip().replace('\\', '/')
+                    if not pth.startswith('import'):
+                        prefixes.append((('%s/%s/' % (parts[0], pth)), ''))
+    finally:
+        z.close()
+    prefixes = [(x.lower(), y) for x, y in prefixes]
+    prefixes.sort()
+    prefixes.reverse()
+    return prefixes
+
+
+class PthDistributions(Environment):
+    """A .pth file with Distribution paths in it"""
+
+    dirty = False
+
+    def __init__(self, filename, sitedirs=()):
+        self.filename = filename
+        self.sitedirs = list(map(normalize_path, sitedirs))
+        self.basedir = normalize_path(os.path.dirname(self.filename))
+        self._load()
+        Environment.__init__(self, [], None, None)
+        for path in yield_lines(self.paths):
+            list(map(self.add, find_distributions(path, True)))
+
+    def _load(self):
+        self.paths = []
+        saw_import = False
+        seen = dict.fromkeys(self.sitedirs)
+        if os.path.isfile(self.filename):
+            f = open(self.filename, 'rt')
+            for line in f:
+                if line.startswith('import'):
+                    saw_import = True
+                    continue
+                path = line.rstrip()
+                self.paths.append(path)
+                if not path.strip() or path.strip().startswith('#'):
+                    continue
+                # skip non-existent paths, in case somebody deleted a package
+                # manually, and duplicate paths as well
+                path = self.paths[-1] = normalize_path(
+                    os.path.join(self.basedir, path)
+                )
+                if not os.path.exists(path) or path in seen:
+                    self.paths.pop()  # skip it
+                    self.dirty = True  # we cleaned up, so we're dirty now :)
+                    continue
+                seen[path] = 1
+            f.close()
+
+        if self.paths and not saw_import:
+            self.dirty = True  # ensure anything we touch has import wrappers
+        while self.paths and not self.paths[-1].strip():
+            self.paths.pop()
+
+    def save(self):
+        """Write changed .pth file back to disk"""
+        if not self.dirty:
+            return
+
+        rel_paths = list(map(self.make_relative, self.paths))
+        if rel_paths:
+            log.debug("Saving %s", self.filename)
+            lines = self._wrap_lines(rel_paths)
+            data = '\n'.join(lines) + '\n'
+
+            if os.path.islink(self.filename):
+                os.unlink(self.filename)
+            with open(self.filename, 'wt') as f:
+                f.write(data)
+
+        elif os.path.exists(self.filename):
+            log.debug("Deleting empty %s", self.filename)
+            os.unlink(self.filename)
+
+        self.dirty = False
+
+    @staticmethod
+    def _wrap_lines(lines):
+        return lines
+
+    def add(self, dist):
+        """Add `dist` to the distribution map"""
+        new_path = (
+            dist.location not in self.paths and (
+                dist.location not in self.sitedirs or
+                # account for '.' being in PYTHONPATH
+                dist.location == os.getcwd()
+            )
+        )
+        if new_path:
+            self.paths.append(dist.location)
+            self.dirty = True
+        Environment.add(self, dist)
+
+    def remove(self, dist):
+        """Remove `dist` from the distribution map"""
+        while dist.location in self.paths:
+            self.paths.remove(dist.location)
+            self.dirty = True
+        Environment.remove(self, dist)
+
+    def make_relative(self, path):
+        npath, last = os.path.split(normalize_path(path))
+        baselen = len(self.basedir)
+        parts = [last]
+        sep = os.altsep == '/' and '/' or os.sep
+        while len(npath) >= baselen:
+            if npath == self.basedir:
+                parts.append(os.curdir)
+                parts.reverse()
+                return sep.join(parts)
+            npath, last = os.path.split(npath)
+            parts.append(last)
+        else:
+            return path
+
+
+class RewritePthDistributions(PthDistributions):
+    @classmethod
+    def _wrap_lines(cls, lines):
+        yield cls.prelude
+        for line in lines:
+            yield line
+        yield cls.postlude
+
+    prelude = _one_liner("""
+        import sys
+        sys.__plen = len(sys.path)
+        """)
+    postlude = _one_liner("""
+        import sys
+        new = sys.path[sys.__plen:]
+        del sys.path[sys.__plen:]
+        p = getattr(sys, '__egginsert', 0)
+        sys.path[p:p] = new
+        sys.__egginsert = p + len(new)
+        """)
+
+
+if os.environ.get('SETUPTOOLS_SYS_PATH_TECHNIQUE', 'raw') == 'rewrite':
+    PthDistributions = RewritePthDistributions
+
+
+def _first_line_re():
+    """
+    Return a regular expression based on first_line_re suitable for matching
+    strings.
+    """
+    if isinstance(first_line_re.pattern, str):
+        return first_line_re
+
+    # first_line_re in Python >=3.1.4 and >=3.2.1 is a bytes pattern.
+    return re.compile(first_line_re.pattern.decode())
+
+
+def auto_chmod(func, arg, exc):
+    if func in [os.unlink, os.remove] and os.name == 'nt':
+        chmod(arg, stat.S_IWRITE)
+        return func(arg)
+    et, ev, _ = sys.exc_info()
+    six.reraise(et, (ev[0], ev[1] + (" %s %s" % (func, arg))))
+
+
+def update_dist_caches(dist_path, fix_zipimporter_caches):
+    """
+    Fix any globally cached `dist_path` related data
+
+    `dist_path` should be a path of a newly installed egg distribution (zipped
+    or unzipped).
+
+    sys.path_importer_cache contains finder objects that have been cached when
+    importing data from the original distribution. Any such finders need to be
+    cleared since the replacement distribution might be packaged differently,
+    e.g. a zipped egg distribution might get replaced with an unzipped egg
+    folder or vice versa. Having the old finders cached may then cause Python
+    to attempt loading modules from the replacement distribution using an
+    incorrect loader.
+
+    zipimport.zipimporter objects are Python loaders charged with importing
+    data packaged inside zip archives. If stale loaders referencing the
+    original distribution, are left behind, they can fail to load modules from
+    the replacement distribution. E.g. if an old zipimport.zipimporter instance
+    is used to load data from a new zipped egg archive, it may cause the
+    operation to attempt to locate the requested data in the wrong location -
+    one indicated by the original distribution's zip archive directory
+    information. Such an operation may then fail outright, e.g. report having
+    read a 'bad local file header', or even worse, it may fail silently &
+    return invalid data.
+
+    zipimport._zip_directory_cache contains cached zip archive directory
+    information for all existing zipimport.zipimporter instances and all such
+    instances connected to the same archive share the same cached directory
+    information.
+
+    If asked, and the underlying Python implementation allows it, we can fix
+    all existing zipimport.zipimporter instances instead of having to track
+    them down and remove them one by one, by updating their shared cached zip
+    archive directory information. This, of course, assumes that the
+    replacement distribution is packaged as a zipped egg.
+
+    If not asked to fix existing zipimport.zipimporter instances, we still do
+    our best to clear any remaining zipimport.zipimporter related cached data
+    that might somehow later get used when attempting to load data from the new
+    distribution and thus cause such load operations to fail. Note that when
+    tracking down such remaining stale data, we can not catch every conceivable
+    usage from here, and we clear only those that we know of and have found to
+    cause problems if left alive. Any remaining caches should be updated by
+    whomever is in charge of maintaining them, i.e. they should be ready to
+    handle us replacing their zip archives with new distributions at runtime.
+
+    """
+    # There are several other known sources of stale zipimport.zipimporter
+    # instances that we do not clear here, but might if ever given a reason to
+    # do so:
+    # * Global setuptools pkg_resources.working_set (a.k.a. 'master working
+    # set') may contain distributions which may in turn contain their
+    #   zipimport.zipimporter loaders.
+    # * Several zipimport.zipimporter loaders held by local variables further
+    #   up the function call stack when running the setuptools installation.
+    # * Already loaded modules may have their __loader__ attribute set to the
+    #   exact loader instance used when importing them. Python 3.4 docs state
+    #   that this information is intended mostly for introspection and so is
+    #   not expected to cause us problems.
+    normalized_path = normalize_path(dist_path)
+    _uncache(normalized_path, sys.path_importer_cache)
+    if fix_zipimporter_caches:
+        _replace_zip_directory_cache_data(normalized_path)
+    else:
+        # Here, even though we do not want to fix existing and now stale
+        # zipimporter cache information, we still want to remove it. Related to
+        # Python's zip archive directory information cache, we clear each of
+        # its stale entries in two phases:
+        #   1. Clear the entry so attempting to access zip archive information
+        #      via any existing stale zipimport.zipimporter instances fails.
+        #   2. Remove the entry from the cache so any newly constructed
+        #      zipimport.zipimporter instances do not end up using old stale
+        #      zip archive directory information.
+        # This whole stale data removal step does not seem strictly necessary,
+        # but has been left in because it was done before we started replacing
+        # the zip archive directory information cache content if possible, and
+        # there are no relevant unit tests that we can depend on to tell us if
+        # this is really needed.
+        _remove_and_clear_zip_directory_cache_data(normalized_path)
+
+
+def _collect_zipimporter_cache_entries(normalized_path, cache):
+    """
+    Return zipimporter cache entry keys related to a given normalized path.
+
+    Alternative path spellings (e.g. those using different character case or
+    those using alternative path separators) related to the same path are
+    included. Any sub-path entries are included as well, i.e. those
+    corresponding to zip archives embedded in other zip archives.
+
+    """
+    result = []
+    prefix_len = len(normalized_path)
+    for p in cache:
+        np = normalize_path(p)
+        if (np.startswith(normalized_path) and
+                np[prefix_len:prefix_len + 1] in (os.sep, '')):
+            result.append(p)
+    return result
+
+
+def _update_zipimporter_cache(normalized_path, cache, updater=None):
+    """
+    Update zipimporter cache data for a given normalized path.
+
+    Any sub-path entries are processed as well, i.e. those corresponding to zip
+    archives embedded in other zip archives.
+
+    Given updater is a callable taking a cache entry key and the original entry
+    (after already removing the entry from the cache), and expected to update
+    the entry and possibly return a new one to be inserted in its place.
+    Returning None indicates that the entry should not be replaced with a new
+    one. If no updater is given, the cache entries are simply removed without
+    any additional processing, the same as if the updater simply returned None.
+
+    """
+    for p in _collect_zipimporter_cache_entries(normalized_path, cache):
+        # N.B. pypy's custom zipimport._zip_directory_cache implementation does
+        # not support the complete dict interface:
+        # * Does not support item assignment, thus not allowing this function
+        #    to be used only for removing existing cache entries.
+        #  * Does not support the dict.pop() method, forcing us to use the
+        #    get/del patterns instead. For more detailed information see the
+        #    following links:
+        #      https://github.com/pypa/setuptools/issues/202#issuecomment-202913420
+        #      http://bit.ly/2h9itJX
+        old_entry = cache[p]
+        del cache[p]
+        new_entry = updater and updater(p, old_entry)
+        if new_entry is not None:
+            cache[p] = new_entry
+
+
+def _uncache(normalized_path, cache):
+    _update_zipimporter_cache(normalized_path, cache)
+
+
+def _remove_and_clear_zip_directory_cache_data(normalized_path):
+    def clear_and_remove_cached_zip_archive_directory_data(path, old_entry):
+        old_entry.clear()
+
+    _update_zipimporter_cache(
+        normalized_path, zipimport._zip_directory_cache,
+        updater=clear_and_remove_cached_zip_archive_directory_data)
+
+
+# PyPy Python implementation does not allow directly writing to the
+# zipimport._zip_directory_cache and so prevents us from attempting to correct
+# its content. The best we can do there is clear the problematic cache content
+# and have PyPy repopulate it as needed. The downside is that if there are any
+# stale zipimport.zipimporter instances laying around, attempting to use them
+# will fail due to not having its zip archive directory information available
+# instead of being automatically corrected to use the new correct zip archive
+# directory information.
+if '__pypy__' in sys.builtin_module_names:
+    _replace_zip_directory_cache_data = \
+        _remove_and_clear_zip_directory_cache_data
+else:
+
+    def _replace_zip_directory_cache_data(normalized_path):
+        def replace_cached_zip_archive_directory_data(path, old_entry):
+            # N.B. In theory, we could load the zip directory information just
+            # once for all updated path spellings, and then copy it locally and
+            # update its contained path strings to contain the correct
+            # spelling, but that seems like a way too invasive move (this cache
+            # structure is not officially documented anywhere and could in
+            # theory change with new Python releases) for no significant
+            # benefit.
+            old_entry.clear()
+            zipimport.zipimporter(path)
+            old_entry.update(zipimport._zip_directory_cache[path])
+            return old_entry
+
+        _update_zipimporter_cache(
+            normalized_path, zipimport._zip_directory_cache,
+            updater=replace_cached_zip_archive_directory_data)
+
+
+def is_python(text, filename='<string>'):
+    "Is this string a valid Python script?"
+    try:
+        compile(text, filename, 'exec')
+    except (SyntaxError, TypeError):
+        return False
+    else:
+        return True
+
+
+def is_sh(executable):
+    """Determine if the specified executable is a .sh (contains a #! line)"""
+    try:
+        with io.open(executable, encoding='latin-1') as fp:
+            magic = fp.read(2)
+    except (OSError, IOError):
+        return executable
+    return magic == '#!'
+
+
+def nt_quote_arg(arg):
+    """Quote a command line argument according to Windows parsing rules"""
+    return subprocess.list2cmdline([arg])
+
+
+def is_python_script(script_text, filename):
+    """Is this text, as a whole, a Python script? (as opposed to shell/bat/etc.
+    """
+    if filename.endswith('.py') or filename.endswith('.pyw'):
+        return True  # extension says it's Python
+    if is_python(script_text, filename):
+        return True  # it's syntactically valid Python
+    if script_text.startswith('#!'):
+        # It begins with a '#!' line, so check if 'python' is in it somewhere
+        return 'python' in script_text.splitlines()[0].lower()
+
+    return False  # Not any Python I can recognize
+
+
+try:
+    from os import chmod as _chmod
+except ImportError:
+    # Jython compatibility
+    def _chmod(*args):
+        pass
+
+
+def chmod(path, mode):
+    log.debug("changing mode of %s to %o", path, mode)
+    try:
+        _chmod(path, mode)
+    except os.error as e:
+        log.debug("chmod failed: %s", e)
+
+
+class CommandSpec(list):
+    """
+    A command spec for a #! header, specified as a list of arguments akin to
+    those passed to Popen.
+    """
+
+    options = []
+    split_args = dict()
+
+    @classmethod
+    def best(cls):
+        """
+        Choose the best CommandSpec class based on environmental conditions.
+        """
+        return cls
+
+    @classmethod
+    def _sys_executable(cls):
+        _default = os.path.normpath(sys.executable)
+        return os.environ.get('__PYVENV_LAUNCHER__', _default)
+
+    @classmethod
+    def from_param(cls, param):
+        """
+        Construct a CommandSpec from a parameter to build_scripts, which may
+        be None.
+        """
+        if isinstance(param, cls):
+            return param
+        if isinstance(param, list):
+            return cls(param)
+        if param is None:
+            return cls.from_environment()
+        # otherwise, assume it's a string.
+        return cls.from_string(param)
+
+    @classmethod
+    def from_environment(cls):
+        return cls([cls._sys_executable()])
+
+    @classmethod
+    def from_string(cls, string):
+        """
+        Construct a command spec from a simple string representing a command
+        line parseable by shlex.split.
+        """
+        items = shlex.split(string, **cls.split_args)
+        return cls(items)
+
+    def install_options(self, script_text):
+        self.options = shlex.split(self._extract_options(script_text))
+        cmdline = subprocess.list2cmdline(self)
+        if not isascii(cmdline):
+            self.options[:0] = ['-x']
+
+    @staticmethod
+    def _extract_options(orig_script):
+        """
+        Extract any options from the first line of the script.
+        """
+        first = (orig_script + '\n').splitlines()[0]
+        match = _first_line_re().match(first)
+        options = match.group(1) or '' if match else ''
+        return options.strip()
+
+    def as_header(self):
+        return self._render(self + list(self.options))
+
+    @staticmethod
+    def _strip_quotes(item):
+        _QUOTES = '"\''
+        for q in _QUOTES:
+            if item.startswith(q) and item.endswith(q):
+                return item[1:-1]
+        return item
+
+    @staticmethod
+    def _render(items):
+        cmdline = subprocess.list2cmdline(
+            CommandSpec._strip_quotes(item.strip()) for item in items)
+        return '#!' + cmdline + '\n'
+
+
+# For pbr compat; will be removed in a future version.
+sys_executable = CommandSpec._sys_executable()
+
+
+class WindowsCommandSpec(CommandSpec):
+    split_args = dict(posix=False)
+
+
+class ScriptWriter:
+    """
+    Encapsulates behavior around writing entry point scripts for console and
+    gui apps.
+    """
+
+    template = textwrap.dedent(r"""
+        # EASY-INSTALL-ENTRY-SCRIPT: %(spec)r,%(group)r,%(name)r
+        import re
+        import sys
+
+        # for compatibility with easy_install; see #2198
+        __requires__ = %(spec)r
+
+        try:
+            from importlib.metadata import distribution
+        except ImportError:
+            try:
+                from importlib_metadata import distribution
+            except ImportError:
+                from pkg_resources import load_entry_point
+
+
+        def importlib_load_entry_point(spec, group, name):
+            dist_name, _, _ = spec.partition('==')
+            matches = (
+                entry_point
+                for entry_point in distribution(dist_name).entry_points
+                if entry_point.group == group and entry_point.name == name
+            )
+            return next(matches).load()
+
+
+        globals().setdefault('load_entry_point', importlib_load_entry_point)
+
+
+        if __name__ == '__main__':
+            sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+            sys.exit(load_entry_point(%(spec)r, %(group)r, %(name)r)())
+        """).lstrip()
+
+    command_spec_class = CommandSpec
+
+    @classmethod
+    def get_script_args(cls, dist, executable=None, wininst=False):
+        # for backward compatibility
+        warnings.warn("Use get_args", EasyInstallDeprecationWarning)
+        writer = (WindowsScriptWriter if wininst else ScriptWriter).best()
+        header = cls.get_script_header("", executable, wininst)
+        return writer.get_args(dist, header)
+
+    @classmethod
+    def get_script_header(cls, script_text, executable=None, wininst=False):
+        # for backward compatibility
+        warnings.warn(
+            "Use get_header", EasyInstallDeprecationWarning, stacklevel=2)
+        if wininst:
+            executable = "python.exe"
+        return cls.get_header(script_text, executable)
+
+    @classmethod
+    def get_args(cls, dist, header=None):
+        """
+        Yield write_script() argument tuples for a distribution's
+        console_scripts and gui_scripts entry points.
+        """
+        if header is None:
+            header = cls.get_header()
+        spec = str(dist.as_requirement())
+        for type_ in 'console', 'gui':
+            group = type_ + '_scripts'
+            for name, ep in dist.get_entry_map(group).items():
+                cls._ensure_safe_name(name)
+                script_text = cls.template % locals()
+                args = cls._get_script_args(type_, name, header, script_text)
+                for res in args:
+                    yield res
+
+    @staticmethod
+    def _ensure_safe_name(name):
+        """
+        Prevent paths in *_scripts entry point names.
+        """
+        has_path_sep = re.search(r'[\\/]', name)
+        if has_path_sep:
+            raise ValueError("Path separators not allowed in script names")
+
+    @classmethod
+    def get_writer(cls, force_windows):
+        # for backward compatibility
+        warnings.warn("Use best", EasyInstallDeprecationWarning)
+        return WindowsScriptWriter.best() if force_windows else cls.best()
+
+    @classmethod
+    def best(cls):
+        """
+        Select the best ScriptWriter for this environment.
+        """
+        if sys.platform == 'win32' or (os.name == 'java' and os._name == 'nt'):
+            return WindowsScriptWriter.best()
+        else:
+            return cls
+
+    @classmethod
+    def _get_script_args(cls, type_, name, header, script_text):
+        # Simply write the stub with no extension.
+        yield (name, header + script_text)
+
+    @classmethod
+    def get_header(cls, script_text="", executable=None):
+        """Create a #! line, getting options (if any) from script_text"""
+        cmd = cls.command_spec_class.best().from_param(executable)
+        cmd.install_options(script_text)
+        return cmd.as_header()
+
+
+class WindowsScriptWriter(ScriptWriter):
+    command_spec_class = WindowsCommandSpec
+
+    @classmethod
+    def get_writer(cls):
+        # for backward compatibility
+        warnings.warn("Use best", EasyInstallDeprecationWarning)
+        return cls.best()
+
+    @classmethod
+    def best(cls):
+        """
+        Select the best ScriptWriter suitable for Windows
+        """
+        writer_lookup = dict(
+            executable=WindowsExecutableLauncherWriter,
+            natural=cls,
+        )
+        # for compatibility, use the executable launcher by default
+        launcher = os.environ.get('SETUPTOOLS_LAUNCHER', 'executable')
+        return writer_lookup[launcher]
+
+    @classmethod
+    def _get_script_args(cls, type_, name, header, script_text):
+        "For Windows, add a .py extension"
+        ext = dict(console='.pya', gui='.pyw')[type_]
+        if ext not in os.environ['PATHEXT'].lower().split(';'):
+            msg = (
+                "{ext} not listed in PATHEXT; scripts will not be "
+                "recognized as executables."
+            ).format(**locals())
+            warnings.warn(msg, UserWarning)
+        old = ['.pya', '.py', '-script.py', '.pyc', '.pyo', '.pyw', '.exe']
+        old.remove(ext)
+        header = cls._adjust_header(type_, header)
+        blockers = [name + x for x in old]
+        yield name + ext, header + script_text, 't', blockers
+
+    @classmethod
+    def _adjust_header(cls, type_, orig_header):
+        """
+        Make sure 'pythonw' is used for gui and and 'python' is used for
+        console (regardless of what sys.executable is).
+        """
+        pattern = 'pythonw.exe'
+        repl = 'python.exe'
+        if type_ == 'gui':
+            pattern, repl = repl, pattern
+        pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE)
+        new_header = pattern_ob.sub(string=orig_header, repl=repl)
+        return new_header if cls._use_header(new_header) else orig_header
+
+    @staticmethod
+    def _use_header(new_header):
+        """
+        Should _adjust_header use the replaced header?
+
+        On non-windows systems, always use. On
+        Windows systems, only use the replaced header if it resolves
+        to an executable on the system.
+        """
+        clean_header = new_header[2:-1].strip('"')
+        return sys.platform != 'win32' or find_executable(clean_header)
+
+
+class WindowsExecutableLauncherWriter(WindowsScriptWriter):
+    @classmethod
+    def _get_script_args(cls, type_, name, header, script_text):
+        """
+        For Windows, add a .py extension and an .exe launcher
+        """
+        if type_ == 'gui':
+            launcher_type = 'gui'
+            ext = '-script.pyw'
+            old = ['.pyw']
+        else:
+            launcher_type = 'cli'
+            ext = '-script.py'
+            old = ['.py', '.pyc', '.pyo']
+        hdr = cls._adjust_header(type_, header)
+        blockers = [name + x for x in old]
+        yield (name + ext, hdr + script_text, 't', blockers)
+        yield (
+            name + '.exe', get_win_launcher(launcher_type),
+            'b'  # write in binary mode
+        )
+        if not is_64bit():
+            # install a manifest for the launcher to prevent Windows
+            # from detecting it as an installer (which it will for
+            #  launchers like easy_install.exe). Consider only
+            #  adding a manifest for launchers detected as installers.
+            #  See Distribute #143 for details.
+            m_name = name + '.exe.manifest'
+            yield (m_name, load_launcher_manifest(name), 't')
+
+
+# for backward-compatibility
+get_script_args = ScriptWriter.get_script_args
+get_script_header = ScriptWriter.get_script_header
+
+
+def get_win_launcher(type):
+    """
+    Load the Windows launcher (executable) suitable for launching a script.
+
+    `type` should be either 'cli' or 'gui'
+
+    Returns the executable as a byte string.
+    """
+    launcher_fn = '%s.exe' % type
+    if is_64bit():
+        launcher_fn = launcher_fn.replace(".", "-64.")
+    else:
+        launcher_fn = launcher_fn.replace(".", "-32.")
+    return resource_string('setuptools', launcher_fn)
+
+
+def load_launcher_manifest(name):
+    manifest = pkg_resources.resource_string(__name__, 'launcher manifest.xml')
+    if six.PY2:
+        return manifest % vars()
+    else:
+        return manifest.decode('utf-8') % vars()
+
+
+def rmtree(path, ignore_errors=False, onerror=auto_chmod):
+    return shutil.rmtree(path, ignore_errors, onerror)
+
+
+def current_umask():
+    tmp = os.umask(0o022)
+    os.umask(tmp)
+    return tmp
+
+
+def bootstrap():
+    # This function is called when setuptools*.egg is run using /bin/sh
+    import setuptools
+
+    argv0 = os.path.dirname(setuptools.__path__[0])
+    sys.argv[0] = argv0
+    sys.argv.append(argv0)
+    main()
+
+
+def main(argv=None, **kw):
+    from setuptools import setup
+    from setuptools.dist import Distribution
+
+    class DistributionWithoutHelpCommands(Distribution):
+        common_usage = ""
+
+        def _show_help(self, *args, **kw):
+            with _patch_usage():
+                Distribution._show_help(self, *args, **kw)
+
+    if argv is None:
+        argv = sys.argv[1:]
+
+    with _patch_usage():
+        setup(
+            script_args=['-q', 'easy_install', '-v'] + argv,
+            script_name=sys.argv[0] or 'easy_install',
+            distclass=DistributionWithoutHelpCommands,
+            **kw
+        )
+
+
+@contextlib.contextmanager
+def _patch_usage():
+    import distutils.core
+    USAGE = textwrap.dedent("""
+        usage: %(script)s [options] requirement_or_url ...
+           or: %(script)s --help
+        """).lstrip()
+
+    def gen_usage(script_name):
+        return USAGE % dict(
+            script=os.path.basename(script_name),
+        )
+
+    saved = distutils.core.gen_usage
+    distutils.core.gen_usage = gen_usage
+    try:
+        yield
+    finally:
+        distutils.core.gen_usage = saved
+
+
+class EasyInstallDeprecationWarning(SetuptoolsDeprecationWarning):
+    """
+    Warning for EasyInstall deprecations, bypassing suppression.
+    """
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/egg_info.py b/myenv/lib/python3.9/site-packages/setuptools/command/egg_info.py
new file mode 100644
index 0000000..0855207
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/egg_info.py
@@ -0,0 +1,721 @@
+"""setuptools.command.egg_info
+
+Create a distribution's .egg-info directory and contents"""
+
+from distutils.filelist import FileList as _FileList
+from distutils.errors import DistutilsInternalError
+from distutils.util import convert_path
+from distutils import log
+import distutils.errors
+import distutils.filelist
+import os
+import re
+import sys
+import io
+import warnings
+import time
+import collections
+
+from setuptools.extern import six
+from setuptools.extern.six.moves import map
+
+from setuptools import Command
+from setuptools.command.sdist import sdist
+from setuptools.command.sdist import walk_revctrl
+from setuptools.command.setopt import edit_config
+from setuptools.command import bdist_egg
+from pkg_resources import (
+    parse_requirements, safe_name, parse_version,
+    safe_version, yield_lines, EntryPoint, iter_entry_points, to_filename)
+import setuptools.unicode_utils as unicode_utils
+from setuptools.glob import glob
+
+from setuptools.extern import packaging
+from setuptools import SetuptoolsDeprecationWarning
+
+
+def translate_pattern(glob):
+    """
+    Translate a file path glob like '*.txt' in to a regular expression.
+    This differs from fnmatch.translate which allows wildcards to match
+    directory separators. It also knows about '**/' which matches any number of
+    directories.
+    """
+    pat = ''
+
+    # This will split on '/' within [character classes]. This is deliberate.
+    chunks = glob.split(os.path.sep)
+
+    sep = re.escape(os.sep)
+    valid_char = '[^%s]' % (sep,)
+
+    for c, chunk in enumerate(chunks):
+        last_chunk = c == len(chunks) - 1
+
+        # Chunks that are a literal ** are globstars. They match anything.
+        if chunk == '**':
+            if last_chunk:
+                # Match anything if this is the last component
+                pat += '.*'
+            else:
+                # Match '(name/)*'
+                pat += '(?:%s+%s)*' % (valid_char, sep)
+            continue  # Break here as the whole path component has been handled
+
+        # Find any special characters in the remainder
+        i = 0
+        chunk_len = len(chunk)
+        while i < chunk_len:
+            char = chunk[i]
+            if char == '*':
+                # Match any number of name characters
+                pat += valid_char + '*'
+            elif char == '?':
+                # Match a name character
+                pat += valid_char
+            elif char == '[':
+                # Character class
+                inner_i = i + 1
+                # Skip initial !/] chars
+                if inner_i < chunk_len and chunk[inner_i] == '!':
+                    inner_i = inner_i + 1
+                if inner_i < chunk_len and chunk[inner_i] == ']':
+                    inner_i = inner_i + 1
+
+                # Loop till the closing ] is found
+                while inner_i < chunk_len and chunk[inner_i] != ']':
+                    inner_i = inner_i + 1
+
+                if inner_i >= chunk_len:
+                    # Got to the end of the string without finding a closing ]
+                    # Do not treat this as a matching group, but as a literal [
+                    pat += re.escape(char)
+                else:
+                    # Grab the insides of the [brackets]
+                    inner = chunk[i + 1:inner_i]
+                    char_class = ''
+
+                    # Class negation
+                    if inner[0] == '!':
+                        char_class = '^'
+                        inner = inner[1:]
+
+                    char_class += re.escape(inner)
+                    pat += '[%s]' % (char_class,)
+
+                    # Skip to the end ]
+                    i = inner_i
+            else:
+                pat += re.escape(char)
+            i += 1
+
+        # Join each chunk with the dir separator
+        if not last_chunk:
+            pat += sep
+
+    pat += r'\Z'
+    return re.compile(pat, flags=re.MULTILINE | re.DOTALL)
+
+
+class InfoCommon:
+    tag_build = None
+    tag_date = None
+
+    @property
+    def name(self):
+        return safe_name(self.distribution.get_name())
+
+    def tagged_version(self):
+        version = self.distribution.get_version()
+        # egg_info may be called more than once for a distribution,
+        # in which case the version string already contains all tags.
+        if self.vtags and version.endswith(self.vtags):
+            return safe_version(version)
+        return safe_version(version + self.vtags)
+
+    def tags(self):
+        version = ''
+        if self.tag_build:
+            version += self.tag_build
+        if self.tag_date:
+            version += time.strftime("-%Y%m%d")
+        return version
+    vtags = property(tags)
+
+
+class egg_info(InfoCommon, Command):
+    description = "create a distribution's .egg-info directory"
+
+    user_options = [
+        ('egg-base=', 'e', "directory containing .egg-info directories"
+                           " (default: top of the source tree)"),
+        ('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"),
+        ('tag-build=', 'b', "Specify explicit tag to add to version number"),
+        ('no-date', 'D', "Don't include date stamp [default]"),
+    ]
+
+    boolean_options = ['tag-date']
+    negative_opt = {
+        'no-date': 'tag-date',
+    }
+
+    def initialize_options(self):
+        self.egg_base = None
+        self.egg_name = None
+        self.egg_info = None
+        self.egg_version = None
+        self.broken_egg_info = False
+
+    ####################################
+    # allow the 'tag_svn_revision' to be detected and
+    # set, supporting sdists built on older Setuptools.
+    @property
+    def tag_svn_revision(self):
+        pass
+
+    @tag_svn_revision.setter
+    def tag_svn_revision(self, value):
+        pass
+    ####################################
+
+    def save_version_info(self, filename):
+        """
+        Materialize the value of date into the
+        build tag. Install build keys in a deterministic order
+        to avoid arbitrary reordering on subsequent builds.
+        """
+        egg_info = collections.OrderedDict()
+        # follow the order these keys would have been added
+        # when PYTHONHASHSEED=0
+        egg_info['tag_build'] = self.tags()
+        egg_info['tag_date'] = 0
+        edit_config(filename, dict(egg_info=egg_info))
+
+    def finalize_options(self):
+        # Note: we need to capture the current value returned
+        # by `self.tagged_version()`, so we can later update
+        # `self.distribution.metadata.version` without
+        # repercussions.
+        self.egg_name = self.name
+        self.egg_version = self.tagged_version()
+        parsed_version = parse_version(self.egg_version)
+
+        try:
+            is_version = isinstance(parsed_version, packaging.version.Version)
+            spec = (
+                "%s==%s" if is_version else "%s===%s"
+            )
+            list(
+                parse_requirements(spec % (self.egg_name, self.egg_version))
+            )
+        except ValueError as e:
+            raise distutils.errors.DistutilsOptionError(
+                "Invalid distribution name or version syntax: %s-%s" %
+                (self.egg_name, self.egg_version)
+            ) from e
+
+        if self.egg_base is None:
+            dirs = self.distribution.package_dir
+            self.egg_base = (dirs or {}).get('', os.curdir)
+
+        self.ensure_dirname('egg_base')
+        self.egg_info = to_filename(self.egg_name) + '.egg-info'
+        if self.egg_base != os.curdir:
+            self.egg_info = os.path.join(self.egg_base, self.egg_info)
+        if '-' in self.egg_name:
+            self.check_broken_egg_info()
+
+        # Set package version for the benefit of dumber commands
+        # (e.g. sdist, bdist_wininst, etc.)
+        #
+        self.distribution.metadata.version = self.egg_version
+
+        # If we bootstrapped around the lack of a PKG-INFO, as might be the
+        # case in a fresh checkout, make sure that any special tags get added
+        # to the version info
+        #
+        pd = self.distribution._patched_dist
+        if pd is not None and pd.key == self.egg_name.lower():
+            pd._version = self.egg_version
+            pd._parsed_version = parse_version(self.egg_version)
+            self.distribution._patched_dist = None
+
+    def write_or_delete_file(self, what, filename, data, force=False):
+        """Write `data` to `filename` or delete if empty
+
+        If `data` is non-empty, this routine is the same as ``write_file()``.
+        If `data` is empty but not ``None``, this is the same as calling
+        ``delete_file(filename)`.  If `data` is ``None``, then this is a no-op
+        unless `filename` exists, in which case a warning is issued about the
+        orphaned file (if `force` is false), or deleted (if `force` is true).
+        """
+        if data:
+            self.write_file(what, filename, data)
+        elif os.path.exists(filename):
+            if data is None and not force:
+                log.warn(
+                    "%s not set in setup(), but %s exists", what, filename
+                )
+                return
+            else:
+                self.delete_file(filename)
+
+    def write_file(self, what, filename, data):
+        """Write `data` to `filename` (if not a dry run) after announcing it
+
+        `what` is used in a log message to identify what is being written
+        to the file.
+        """
+        log.info("writing %s to %s", what, filename)
+        if not six.PY2:
+            data = data.encode("utf-8")
+        if not self.dry_run:
+            f = open(filename, 'wb')
+            f.write(data)
+            f.close()
+
+    def delete_file(self, filename):
+        """Delete `filename` (if not a dry run) after announcing it"""
+        log.info("deleting %s", filename)
+        if not self.dry_run:
+            os.unlink(filename)
+
+    def run(self):
+        self.mkpath(self.egg_info)
+        os.utime(self.egg_info, None)
+        installer = self.distribution.fetch_build_egg
+        for ep in iter_entry_points('egg_info.writers'):
+            ep.require(installer=installer)
+            writer = ep.resolve()
+            writer(self, ep.name, os.path.join(self.egg_info, ep.name))
+
+        # Get rid of native_libs.txt if it was put there by older bdist_egg
+        nl = os.path.join(self.egg_info, "native_libs.txt")
+        if os.path.exists(nl):
+            self.delete_file(nl)
+
+        self.find_sources()
+
+    def find_sources(self):
+        """Generate SOURCES.txt manifest file"""
+        manifest_filename = os.path.join(self.egg_info, "SOURCES.txt")
+        mm = manifest_maker(self.distribution)
+        mm.manifest = manifest_filename
+        mm.run()
+        self.filelist = mm.filelist
+
+    def check_broken_egg_info(self):
+        bei = self.egg_name + '.egg-info'
+        if self.egg_base != os.curdir:
+            bei = os.path.join(self.egg_base, bei)
+        if os.path.exists(bei):
+            log.warn(
+                "-" * 78 + '\n'
+                "Note: Your current .egg-info directory has a '-' in its name;"
+                '\nthis will not work correctly with "setup.py develop".\n\n'
+                'Please rename %s to %s to correct this problem.\n' + '-' * 78,
+                bei, self.egg_info
+            )
+            self.broken_egg_info = self.egg_info
+            self.egg_info = bei  # make it work for now
+
+
+class FileList(_FileList):
+    # Implementations of the various MANIFEST.in commands
+
+    def process_template_line(self, line):
+        # Parse the line: split it up, make sure the right number of words
+        # is there, and return the relevant words.  'action' is always
+        # defined: it's the first word of the line.  Which of the other
+        # three are defined depends on the action; it'll be either
+        # patterns, (dir and patterns), or (dir_pattern).
+        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)
+
+        # OK, now we know that the action is valid and we have the
+        # right number of words on the line for that action -- so we
+        # can proceed with minimal error-checking.
+        if action == 'include':
+            self.debug_print("include " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.include(pattern):
+                    log.warn("warning: no files found matching '%s'", pattern)
+
+        elif action == 'exclude':
+            self.debug_print("exclude " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.exclude(pattern):
+                    log.warn(("warning: no previously-included files "
+                              "found matching '%s'"), pattern)
+
+        elif action == 'global-include':
+            self.debug_print("global-include " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.global_include(pattern):
+                    log.warn(("warning: no files found matching '%s' "
+                              "anywhere in distribution"), pattern)
+
+        elif action == 'global-exclude':
+            self.debug_print("global-exclude " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.global_exclude(pattern):
+                    log.warn(("warning: no previously-included files matching "
+                              "'%s' found anywhere in distribution"),
+                             pattern)
+
+        elif action == 'recursive-include':
+            self.debug_print("recursive-include %s %s" %
+                             (dir, ' '.join(patterns)))
+            for pattern in patterns:
+                if not self.recursive_include(dir, pattern):
+                    log.warn(("warning: no files found matching '%s' "
+                              "under directory '%s'"),
+                             pattern, dir)
+
+        elif action == 'recursive-exclude':
+            self.debug_print("recursive-exclude %s %s" %
+                             (dir, ' '.join(patterns)))
+            for pattern in patterns:
+                if not self.recursive_exclude(dir, pattern):
+                    log.warn(("warning: no previously-included files matching "
+                              "'%s' found under directory '%s'"),
+                             pattern, dir)
+
+        elif action == 'graft':
+            self.debug_print("graft " + dir_pattern)
+            if not self.graft(dir_pattern):
+                log.warn("warning: no directories found matching '%s'",
+                         dir_pattern)
+
+        elif action == 'prune':
+            self.debug_print("prune " + dir_pattern)
+            if not self.prune(dir_pattern):
+                log.warn(("no previously-included directories found "
+                          "matching '%s'"), dir_pattern)
+
+        else:
+            raise DistutilsInternalError(
+                "this cannot happen: invalid action '%s'" % action)
+
+    def _remove_files(self, predicate):
+        """
+        Remove all files from the file list that match the predicate.
+        Return True if any matching files were removed
+        """
+        found = False
+        for i in range(len(self.files) - 1, -1, -1):
+            if predicate(self.files[i]):
+                self.debug_print(" removing " + self.files[i])
+                del self.files[i]
+                found = True
+        return found
+
+    def include(self, pattern):
+        """Include files that match 'pattern'."""
+        found = [f for f in glob(pattern) if not os.path.isdir(f)]
+        self.extend(found)
+        return bool(found)
+
+    def exclude(self, pattern):
+        """Exclude files that match 'pattern'."""
+        match = translate_pattern(pattern)
+        return self._remove_files(match.match)
+
+    def recursive_include(self, dir, pattern):
+        """
+        Include all files anywhere in 'dir/' that match the pattern.
+        """
+        full_pattern = os.path.join(dir, '**', pattern)
+        found = [f for f in glob(full_pattern, recursive=True)
+                 if not os.path.isdir(f)]
+        self.extend(found)
+        return bool(found)
+
+    def recursive_exclude(self, dir, pattern):
+        """
+        Exclude any file anywhere in 'dir/' that match the pattern.
+        """
+        match = translate_pattern(os.path.join(dir, '**', pattern))
+        return self._remove_files(match.match)
+
+    def graft(self, dir):
+        """Include all files from 'dir/'."""
+        found = [
+            item
+            for match_dir in glob(dir)
+            for item in distutils.filelist.findall(match_dir)
+        ]
+        self.extend(found)
+        return bool(found)
+
+    def prune(self, dir):
+        """Filter out files from 'dir/'."""
+        match = translate_pattern(os.path.join(dir, '**'))
+        return self._remove_files(match.match)
+
+    def global_include(self, pattern):
+        """
+        Include all files anywhere in the current directory that match the
+        pattern. This is very inefficient on large file trees.
+        """
+        if self.allfiles is None:
+            self.findall()
+        match = translate_pattern(os.path.join('**', pattern))
+        found = [f for f in self.allfiles if match.match(f)]
+        self.extend(found)
+        return bool(found)
+
+    def global_exclude(self, pattern):
+        """
+        Exclude all files anywhere that match the pattern.
+        """
+        match = translate_pattern(os.path.join('**', pattern))
+        return self._remove_files(match.match)
+
+    def append(self, item):
+        if item.endswith('\r'):  # Fix older sdists built on Windows
+            item = item[:-1]
+        path = convert_path(item)
+
+        if self._safe_path(path):
+            self.files.append(path)
+
+    def extend(self, paths):
+        self.files.extend(filter(self._safe_path, paths))
+
+    def _repair(self):
+        """
+        Replace self.files with only safe paths
+
+        Because some owners of FileList manipulate the underlying
+        ``files`` attribute directly, this method must be called to
+        repair those paths.
+        """
+        self.files = list(filter(self._safe_path, self.files))
+
+    def _safe_path(self, path):
+        enc_warn = "'%s' not %s encodable -- skipping"
+
+        # To avoid accidental trans-codings errors, first to unicode
+        u_path = unicode_utils.filesys_decode(path)
+        if u_path is None:
+            log.warn("'%s' in unexpected encoding -- skipping" % path)
+            return False
+
+        # Must ensure utf-8 encodability
+        utf8_path = unicode_utils.try_encode(u_path, "utf-8")
+        if utf8_path is None:
+            log.warn(enc_warn, path, 'utf-8')
+            return False
+
+        try:
+            # accept is either way checks out
+            if os.path.exists(u_path) or os.path.exists(utf8_path):
+                return True
+        # this will catch any encode errors decoding u_path
+        except UnicodeEncodeError:
+            log.warn(enc_warn, path, sys.getfilesystemencoding())
+
+
+class manifest_maker(sdist):
+    template = "MANIFEST.in"
+
+    def initialize_options(self):
+        self.use_defaults = 1
+        self.prune = 1
+        self.manifest_only = 1
+        self.force_manifest = 1
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        self.filelist = FileList()
+        if not os.path.exists(self.manifest):
+            self.write_manifest()  # it must exist so it'll get in the list
+        self.add_defaults()
+        if os.path.exists(self.template):
+            self.read_template()
+        self.prune_file_list()
+        self.filelist.sort()
+        self.filelist.remove_duplicates()
+        self.write_manifest()
+
+    def _manifest_normalize(self, path):
+        path = unicode_utils.filesys_decode(path)
+        return path.replace(os.sep, '/')
+
+    def write_manifest(self):
+        """
+        Write the file list in 'self.filelist' to the manifest file
+        named by 'self.manifest'.
+        """
+        self.filelist._repair()
+
+        # Now _repairs should encodability, but not unicode
+        files = [self._manifest_normalize(f) for f in self.filelist.files]
+        msg = "writing manifest file '%s'" % self.manifest
+        self.execute(write_file, (self.manifest, files), msg)
+
+    def warn(self, msg):
+        if not self._should_suppress_warning(msg):
+            sdist.warn(self, msg)
+
+    @staticmethod
+    def _should_suppress_warning(msg):
+        """
+        suppress missing-file warnings from sdist
+        """
+        return re.match(r"standard file .*not found", msg)
+
+    def add_defaults(self):
+        sdist.add_defaults(self)
+        self.check_license()
+        self.filelist.append(self.template)
+        self.filelist.append(self.manifest)
+        rcfiles = list(walk_revctrl())
+        if rcfiles:
+            self.filelist.extend(rcfiles)
+        elif os.path.exists(self.manifest):
+            self.read_manifest()
+
+        if os.path.exists("setup.py"):
+            # setup.py should be included by default, even if it's not
+            # the script called to create the sdist
+            self.filelist.append("setup.py")
+
+        ei_cmd = self.get_finalized_command('egg_info')
+        self.filelist.graft(ei_cmd.egg_info)
+
+    def prune_file_list(self):
+        build = self.get_finalized_command('build')
+        base_dir = self.distribution.get_fullname()
+        self.filelist.prune(build.build_base)
+        self.filelist.prune(base_dir)
+        sep = re.escape(os.sep)
+        self.filelist.exclude_pattern(r'(^|' + sep + r')(RCS|CVS|\.svn)' + sep,
+                                      is_regex=1)
+
+
+def write_file(filename, contents):
+    """Create a file with the specified name and write 'contents' (a
+    sequence of strings without line terminators) to it.
+    """
+    contents = "\n".join(contents)
+
+    # assuming the contents has been vetted for utf-8 encoding
+    contents = contents.encode("utf-8")
+
+    with open(filename, "wb") as f:  # always write POSIX-style manifest
+        f.write(contents)
+
+
+def write_pkg_info(cmd, basename, filename):
+    log.info("writing %s", filename)
+    if not cmd.dry_run:
+        metadata = cmd.distribution.metadata
+        metadata.version, oldver = cmd.egg_version, metadata.version
+        metadata.name, oldname = cmd.egg_name, metadata.name
+
+        try:
+            # write unescaped data to PKG-INFO, so older pkg_resources
+            # can still parse it
+            metadata.write_pkg_info(cmd.egg_info)
+        finally:
+            metadata.name, metadata.version = oldname, oldver
+
+        safe = getattr(cmd.distribution, 'zip_safe', None)
+
+        bdist_egg.write_safety_flag(cmd.egg_info, safe)
+
+
+def warn_depends_obsolete(cmd, basename, filename):
+    if os.path.exists(filename):
+        log.warn(
+            "WARNING: 'depends.txt' is not used by setuptools 0.6!\n"
+            "Use the install_requires/extras_require setup() args instead."
+        )
+
+
+def _write_requirements(stream, reqs):
+    lines = yield_lines(reqs or ())
+
+    def append_cr(line):
+        return line + '\n'
+    lines = map(append_cr, lines)
+    stream.writelines(lines)
+
+
+def write_requirements(cmd, basename, filename):
+    dist = cmd.distribution
+    data = six.StringIO()
+    _write_requirements(data, dist.install_requires)
+    extras_require = dist.extras_require or {}
+    for extra in sorted(extras_require):
+        data.write('\n[{extra}]\n'.format(**vars()))
+        _write_requirements(data, extras_require[extra])
+    cmd.write_or_delete_file("requirements", filename, data.getvalue())
+
+
+def write_setup_requirements(cmd, basename, filename):
+    data = io.StringIO()
+    _write_requirements(data, cmd.distribution.setup_requires)
+    cmd.write_or_delete_file("setup-requirements", filename, data.getvalue())
+
+
+def write_toplevel_names(cmd, basename, filename):
+    pkgs = dict.fromkeys(
+        [
+            k.split('.', 1)[0]
+            for k in cmd.distribution.iter_distribution_names()
+        ]
+    )
+    cmd.write_file("top-level names", filename, '\n'.join(sorted(pkgs)) + '\n')
+
+
+def overwrite_arg(cmd, basename, filename):
+    write_arg(cmd, basename, filename, True)
+
+
+def write_arg(cmd, basename, filename, force=False):
+    argname = os.path.splitext(basename)[0]
+    value = getattr(cmd.distribution, argname, None)
+    if value is not None:
+        value = '\n'.join(value) + '\n'
+    cmd.write_or_delete_file(argname, filename, value, force)
+
+
+def write_entries(cmd, basename, filename):
+    ep = cmd.distribution.entry_points
+
+    if isinstance(ep, six.string_types) or ep is None:
+        data = ep
+    elif ep is not None:
+        data = []
+        for section, contents in sorted(ep.items()):
+            if not isinstance(contents, six.string_types):
+                contents = EntryPoint.parse_group(section, contents)
+                contents = '\n'.join(sorted(map(str, contents.values())))
+            data.append('[%s]\n%s\n\n' % (section, contents))
+        data = ''.join(data)
+
+    cmd.write_or_delete_file('entry points', filename, data, True)
+
+
+def get_pkg_info_revision():
+    """
+    Get a -r### off of PKG-INFO Version in case this is an sdist of
+    a subversion revision.
+    """
+    warnings.warn(
+        "get_pkg_info_revision is deprecated.", EggInfoDeprecationWarning)
+    if os.path.exists('PKG-INFO'):
+        with io.open('PKG-INFO') as f:
+            for line in f:
+                match = re.match(r"Version:.*-r(\d+)\s*$", line)
+                if match:
+                    return int(match.group(1))
+    return 0
+
+
+class EggInfoDeprecationWarning(SetuptoolsDeprecationWarning):
+    """Deprecated behavior warning for EggInfo, bypassing suppression."""
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/install.py b/myenv/lib/python3.9/site-packages/setuptools/command/install.py
new file mode 100644
index 0000000..72b9a3e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/install.py
@@ -0,0 +1,125 @@
+from distutils.errors import DistutilsArgError
+import inspect
+import glob
+import warnings
+import platform
+import distutils.command.install as orig
+
+import setuptools
+
+# Prior to numpy 1.9, NumPy relies on the '_install' name, so provide it for
+# now. See https://github.com/pypa/setuptools/issues/199/
+_install = orig.install
+
+
+class install(orig.install):
+    """Use easy_install to install the package, w/dependencies"""
+
+    user_options = orig.install.user_options + [
+        ('old-and-unmanageable', None, "Try not to use this!"),
+        ('single-version-externally-managed', None,
+         "used by system package builders to create 'flat' eggs"),
+    ]
+    boolean_options = orig.install.boolean_options + [
+        'old-and-unmanageable', 'single-version-externally-managed',
+    ]
+    new_commands = [
+        ('install_egg_info', lambda self: True),
+        ('install_scripts', lambda self: True),
+    ]
+    _nc = dict(new_commands)
+
+    def initialize_options(self):
+        orig.install.initialize_options(self)
+        self.old_and_unmanageable = None
+        self.single_version_externally_managed = None
+
+    def finalize_options(self):
+        orig.install.finalize_options(self)
+        if self.root:
+            self.single_version_externally_managed = True
+        elif self.single_version_externally_managed:
+            if not self.root and not self.record:
+                raise DistutilsArgError(
+                    "You must specify --record or --root when building system"
+                    " packages"
+                )
+
+    def handle_extra_path(self):
+        if self.root or self.single_version_externally_managed:
+            # explicit backward-compatibility mode, allow extra_path to work
+            return orig.install.handle_extra_path(self)
+
+        # Ignore extra_path when installing an egg (or being run by another
+        # command without --root or --single-version-externally-managed
+        self.path_file = None
+        self.extra_dirs = ''
+
+    def run(self):
+        # Explicit request for old-style install?  Just do it
+        if self.old_and_unmanageable or self.single_version_externally_managed:
+            return orig.install.run(self)
+
+        if not self._called_from_setup(inspect.currentframe()):
+            # Run in backward-compatibility mode to support bdist_* commands.
+            orig.install.run(self)
+        else:
+            self.do_egg_install()
+
+    @staticmethod
+    def _called_from_setup(run_frame):
+        """
+        Attempt to detect whether run() was called from setup() or by another
+        command.  If called by setup(), the parent caller will be the
+        'run_command' method in 'distutils.dist', and *its* caller will be
+        the 'run_commands' method.  If called any other way, the
+        immediate caller *might* be 'run_command', but it won't have been
+        called by 'run_commands'. Return True in that case or if a call stack
+        is unavailable. Return False otherwise.
+        """
+        if run_frame is None:
+            msg = "Call stack not available. bdist_* commands may fail."
+            warnings.warn(msg)
+            if platform.python_implementation() == 'IronPython':
+                msg = "For best results, pass -X:Frames to enable call stack."
+                warnings.warn(msg)
+            return True
+        res = inspect.getouterframes(run_frame)[2]
+        caller, = res[:1]
+        info = inspect.getframeinfo(caller)
+        caller_module = caller.f_globals.get('__name__', '')
+        return (
+            caller_module == 'distutils.dist'
+            and info.function == 'run_commands'
+        )
+
+    def do_egg_install(self):
+
+        easy_install = self.distribution.get_command_class('easy_install')
+
+        cmd = easy_install(
+            self.distribution, args="x", root=self.root, record=self.record,
+        )
+        cmd.ensure_finalized()  # finalize before bdist_egg munges install cmd
+        cmd.always_copy_from = '.'  # make sure local-dir eggs get installed
+
+        # pick up setup-dir .egg files only: no .egg-info
+        cmd.package_index.scan(glob.glob('*.egg'))
+
+        self.run_command('bdist_egg')
+        args = [self.distribution.get_command_obj('bdist_egg').egg_output]
+
+        if setuptools.bootstrap_install_from:
+            # Bootstrap self-installation of setuptools
+            args.insert(0, setuptools.bootstrap_install_from)
+
+        cmd.args = args
+        cmd.run(show_deprecation=False)
+        setuptools.bootstrap_install_from = None
+
+
+# XXX Python 3.1 doesn't see _nc if this is inside the class
+install.sub_commands = (
+    [cmd for cmd in orig.install.sub_commands if cmd[0] not in install._nc] +
+    install.new_commands
+)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/install_egg_info.py b/myenv/lib/python3.9/site-packages/setuptools/command/install_egg_info.py
new file mode 100644
index 0000000..edc4718
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/install_egg_info.py
@@ -0,0 +1,62 @@
+from distutils import log, dir_util
+import os
+
+from setuptools import Command
+from setuptools import namespaces
+from setuptools.archive_util import unpack_archive
+import pkg_resources
+
+
+class install_egg_info(namespaces.Installer, Command):
+    """Install an .egg-info directory for the package"""
+
+    description = "Install an .egg-info directory for the package"
+
+    user_options = [
+        ('install-dir=', 'd', "directory to install to"),
+    ]
+
+    def initialize_options(self):
+        self.install_dir = None
+
+    def finalize_options(self):
+        self.set_undefined_options('install_lib',
+                                   ('install_dir', 'install_dir'))
+        ei_cmd = self.get_finalized_command("egg_info")
+        basename = pkg_resources.Distribution(
+            None, None, ei_cmd.egg_name, ei_cmd.egg_version
+        ).egg_name() + '.egg-info'
+        self.source = ei_cmd.egg_info
+        self.target = os.path.join(self.install_dir, basename)
+        self.outputs = []
+
+    def run(self):
+        self.run_command('egg_info')
+        if os.path.isdir(self.target) and not os.path.islink(self.target):
+            dir_util.remove_tree(self.target, dry_run=self.dry_run)
+        elif os.path.exists(self.target):
+            self.execute(os.unlink, (self.target,), "Removing " + self.target)
+        if not self.dry_run:
+            pkg_resources.ensure_directory(self.target)
+        self.execute(
+            self.copytree, (), "Copying %s to %s" % (self.source, self.target)
+        )
+        self.install_namespaces()
+
+    def get_outputs(self):
+        return self.outputs
+
+    def copytree(self):
+        # Copy the .egg-info tree to site-packages
+        def skimmer(src, dst):
+            # filter out source-control directories; note that 'src' is always
+            # a '/'-separated path, regardless of platform.  'dst' is a
+            # platform-specific path.
+            for skip in '.svn/', 'CVS/':
+                if src.startswith(skip) or '/' + skip in src:
+                    return None
+            self.outputs.append(dst)
+            log.debug("Copying %s to %s", src, dst)
+            return dst
+
+        unpack_archive(self.source, self.target, skimmer)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/install_lib.py b/myenv/lib/python3.9/site-packages/setuptools/command/install_lib.py
new file mode 100644
index 0000000..2e9d875
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/install_lib.py
@@ -0,0 +1,122 @@
+import os
+import sys
+from itertools import product, starmap
+import distutils.command.install_lib as orig
+
+
+class install_lib(orig.install_lib):
+    """Don't add compiled flags to filenames of non-Python files"""
+
+    def run(self):
+        self.build()
+        outfiles = self.install()
+        if outfiles is not None:
+            # always compile, in case we have any extension stubs to deal with
+            self.byte_compile(outfiles)
+
+    def get_exclusions(self):
+        """
+        Return a collections.Sized collections.Container of paths to be
+        excluded for single_version_externally_managed installations.
+        """
+        all_packages = (
+            pkg
+            for ns_pkg in self._get_SVEM_NSPs()
+            for pkg in self._all_packages(ns_pkg)
+        )
+
+        excl_specs = product(all_packages, self._gen_exclusion_paths())
+        return set(starmap(self._exclude_pkg_path, excl_specs))
+
+    def _exclude_pkg_path(self, pkg, exclusion_path):
+        """
+        Given a package name and exclusion path within that package,
+        compute the full exclusion path.
+        """
+        parts = pkg.split('.') + [exclusion_path]
+        return os.path.join(self.install_dir, *parts)
+
+    @staticmethod
+    def _all_packages(pkg_name):
+        """
+        >>> list(install_lib._all_packages('foo.bar.baz'))
+        ['foo.bar.baz', 'foo.bar', 'foo']
+        """
+        while pkg_name:
+            yield pkg_name
+            pkg_name, sep, child = pkg_name.rpartition('.')
+
+    def _get_SVEM_NSPs(self):
+        """
+        Get namespace packages (list) but only for
+        single_version_externally_managed installations and empty otherwise.
+        """
+        # TODO: is it necessary to short-circuit here? i.e. what's the cost
+        # if get_finalized_command is called even when namespace_packages is
+        # False?
+        if not self.distribution.namespace_packages:
+            return []
+
+        install_cmd = self.get_finalized_command('install')
+        svem = install_cmd.single_version_externally_managed
+
+        return self.distribution.namespace_packages if svem else []
+
+    @staticmethod
+    def _gen_exclusion_paths():
+        """
+        Generate file paths to be excluded for namespace packages (bytecode
+        cache files).
+        """
+        # always exclude the package module itself
+        yield '__init__.py'
+
+        yield '__init__.pyc'
+        yield '__init__.pyo'
+
+        if not hasattr(sys, 'implementation'):
+            return
+
+        base = os.path.join(
+            '__pycache__', '__init__.' + sys.implementation.cache_tag)
+        yield base + '.pyc'
+        yield base + '.pyo'
+        yield base + '.opt-1.pyc'
+        yield base + '.opt-2.pyc'
+
+    def copy_tree(
+            self, infile, outfile,
+            preserve_mode=1, preserve_times=1, preserve_symlinks=0, level=1
+    ):
+        assert preserve_mode and preserve_times and not preserve_symlinks
+        exclude = self.get_exclusions()
+
+        if not exclude:
+            return orig.install_lib.copy_tree(self, infile, outfile)
+
+        # Exclude namespace package __init__.py* files from the output
+
+        from setuptools.archive_util import unpack_directory
+        from distutils import log
+
+        outfiles = []
+
+        def pf(src, dst):
+            if dst in exclude:
+                log.warn("Skipping installation of %s (namespace package)",
+                         dst)
+                return False
+
+            log.info("copying %s -> %s", src, os.path.dirname(dst))
+            outfiles.append(dst)
+            return dst
+
+        unpack_directory(infile, outfile, pf)
+        return outfiles
+
+    def get_outputs(self):
+        outputs = orig.install_lib.get_outputs(self)
+        exclude = self.get_exclusions()
+        if exclude:
+            return [f for f in outputs if f not in exclude]
+        return outputs
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/install_scripts.py b/myenv/lib/python3.9/site-packages/setuptools/command/install_scripts.py
new file mode 100644
index 0000000..8c9a15e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/install_scripts.py
@@ -0,0 +1,68 @@
+from distutils import log
+import distutils.command.install_scripts as orig
+import os
+import sys
+
+from pkg_resources import Distribution, PathMetadata, ensure_directory
+
+
+class install_scripts(orig.install_scripts):
+    """Do normal script install, plus any egg_info wrapper scripts"""
+
+    def initialize_options(self):
+        orig.install_scripts.initialize_options(self)
+        self.no_ep = False
+
+    def run(self):
+        import setuptools.command.easy_install as ei
+
+        self.run_command("egg_info")
+        if self.distribution.scripts:
+            orig.install_scripts.run(self)  # run first to set up self.outfiles
+        else:
+            self.outfiles = []
+        if self.no_ep:
+            # don't install entry point scripts into .egg file!
+            return
+
+        ei_cmd = self.get_finalized_command("egg_info")
+        dist = Distribution(
+            ei_cmd.egg_base, PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info),
+            ei_cmd.egg_name, ei_cmd.egg_version,
+        )
+        bs_cmd = self.get_finalized_command('build_scripts')
+        exec_param = getattr(bs_cmd, 'executable', None)
+        try:
+            bw_cmd = self.get_finalized_command("bdist_wininst")
+            is_wininst = getattr(bw_cmd, '_is_running', False)
+        except ImportError:
+            is_wininst = False
+        writer = ei.ScriptWriter
+        if is_wininst:
+            exec_param = "python.exe"
+            writer = ei.WindowsScriptWriter
+        if exec_param == sys.executable:
+            # In case the path to the Python executable contains a space, wrap
+            # it so it's not split up.
+            exec_param = [exec_param]
+        # resolve the writer to the environment
+        writer = writer.best()
+        cmd = writer.command_spec_class.best().from_param(exec_param)
+        for args in writer.get_args(dist, cmd.as_header()):
+            self.write_script(*args)
+
+    def write_script(self, script_name, contents, mode="t", *ignored):
+        """Write an executable file to the scripts directory"""
+        from setuptools.command.easy_install import chmod, current_umask
+
+        log.info("Installing %s script to %s", script_name, self.install_dir)
+        target = os.path.join(self.install_dir, script_name)
+        self.outfiles.append(target)
+
+        mask = current_umask()
+        if not self.dry_run:
+            ensure_directory(target)
+            f = open(target, "w" + mode)
+            f.write(contents)
+            f.close()
+            chmod(target, 0o777 - mask)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/launcher manifest.xml b/myenv/lib/python3.9/site-packages/setuptools/command/launcher manifest.xml
new file mode 100644
index 0000000..5972a96
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/launcher manifest.xml	
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+    <assemblyIdentity version="1.0.0.0"
+                      processorArchitecture="X86"
+                      name="%(name)s"
+                      type="win32"/>
+    <!-- Identify the application security requirements. -->
+    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+        <security>
+            <requestedPrivileges>
+                <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
+            </requestedPrivileges>
+        </security>
+    </trustInfo>
+</assembly>
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/py36compat.py b/myenv/lib/python3.9/site-packages/setuptools/command/py36compat.py
new file mode 100644
index 0000000..2886055
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/py36compat.py
@@ -0,0 +1,136 @@
+import os
+from glob import glob
+from distutils.util import convert_path
+from distutils.command import sdist
+
+from setuptools.extern.six.moves import filter
+
+
+class sdist_add_defaults:
+    """
+    Mix-in providing forward-compatibility for functionality as found in
+    distutils on Python 3.7.
+
+    Do not edit the code in this class except to update functionality
+    as implemented in distutils. Instead, override in the subclass.
+    """
+
+    def add_defaults(self):
+        """Add all the default files to self.filelist:
+          - README or README.txt
+          - setup.py
+          - test/test*.py
+          - all pure Python modules mentioned in setup script
+          - all files pointed by package_data (build_py)
+          - all files defined in data_files.
+          - all files defined as scripts.
+          - all C sources listed as part of extensions or C libraries
+            in the setup script (doesn't catch C headers!)
+        Warns if (README or README.txt) or setup.py are missing; everything
+        else is optional.
+        """
+        self._add_defaults_standards()
+        self._add_defaults_optional()
+        self._add_defaults_python()
+        self._add_defaults_data_files()
+        self._add_defaults_ext()
+        self._add_defaults_c_libs()
+        self._add_defaults_scripts()
+
+    @staticmethod
+    def _cs_path_exists(fspath):
+        """
+        Case-sensitive path existence check
+
+        >>> sdist_add_defaults._cs_path_exists(__file__)
+        True
+        >>> sdist_add_defaults._cs_path_exists(__file__.upper())
+        False
+        """
+        if not os.path.exists(fspath):
+            return False
+        # make absolute so we always have a directory
+        abspath = os.path.abspath(fspath)
+        directory, filename = os.path.split(abspath)
+        return filename in os.listdir(directory)
+
+    def _add_defaults_standards(self):
+        standards = [self.READMES, self.distribution.script_name]
+        for fn in standards:
+            if isinstance(fn, tuple):
+                alts = fn
+                got_it = False
+                for fn in alts:
+                    if self._cs_path_exists(fn):
+                        got_it = True
+                        self.filelist.append(fn)
+                        break
+
+                if not got_it:
+                    self.warn("standard file not found: should have one of " +
+                              ', '.join(alts))
+            else:
+                if self._cs_path_exists(fn):
+                    self.filelist.append(fn)
+                else:
+                    self.warn("standard file '%s' not found" % fn)
+
+    def _add_defaults_optional(self):
+        optional = ['test/test*.py', 'setup.cfg']
+        for pattern in optional:
+            files = filter(os.path.isfile, glob(pattern))
+            self.filelist.extend(files)
+
+    def _add_defaults_python(self):
+        # build_py is used to get:
+        #  - python modules
+        #  - files defined in package_data
+        build_py = self.get_finalized_command('build_py')
+
+        # getting python files
+        if self.distribution.has_pure_modules():
+            self.filelist.extend(build_py.get_source_files())
+
+        # getting package_data files
+        # (computed in build_py.data_files by build_py.finalize_options)
+        for pkg, src_dir, build_dir, filenames in build_py.data_files:
+            for filename in filenames:
+                self.filelist.append(os.path.join(src_dir, filename))
+
+    def _add_defaults_data_files(self):
+        # getting distribution.data_files
+        if self.distribution.has_data_files():
+            for item in self.distribution.data_files:
+                if isinstance(item, str):
+                    # plain file
+                    item = convert_path(item)
+                    if os.path.isfile(item):
+                        self.filelist.append(item)
+                else:
+                    # a (dirname, filenames) tuple
+                    dirname, filenames = item
+                    for f in filenames:
+                        f = convert_path(f)
+                        if os.path.isfile(f):
+                            self.filelist.append(f)
+
+    def _add_defaults_ext(self):
+        if self.distribution.has_ext_modules():
+            build_ext = self.get_finalized_command('build_ext')
+            self.filelist.extend(build_ext.get_source_files())
+
+    def _add_defaults_c_libs(self):
+        if self.distribution.has_c_libraries():
+            build_clib = self.get_finalized_command('build_clib')
+            self.filelist.extend(build_clib.get_source_files())
+
+    def _add_defaults_scripts(self):
+        if self.distribution.has_scripts():
+            build_scripts = self.get_finalized_command('build_scripts')
+            self.filelist.extend(build_scripts.get_source_files())
+
+
+if hasattr(sdist.sdist, '_add_defaults_standards'):
+    # disable the functionality already available upstream
+    class sdist_add_defaults:  # noqa
+        pass
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/register.py b/myenv/lib/python3.9/site-packages/setuptools/command/register.py
new file mode 100644
index 0000000..b8266b9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/register.py
@@ -0,0 +1,18 @@
+from distutils import log
+import distutils.command.register as orig
+
+from setuptools.errors import RemovedCommandError
+
+
+class register(orig.register):
+    """Formerly used to register packages on PyPI."""
+
+    def run(self):
+        msg = (
+            "The register command has been removed, use twine to upload "
+            + "instead (https://pypi.org/p/twine)"
+        )
+
+        self.announce("ERROR: " + msg, log.ERROR)
+
+        raise RemovedCommandError(msg)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/rotate.py b/myenv/lib/python3.9/site-packages/setuptools/command/rotate.py
new file mode 100644
index 0000000..e398834
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/rotate.py
@@ -0,0 +1,66 @@
+from distutils.util import convert_path
+from distutils import log
+from distutils.errors import DistutilsOptionError
+import os
+import shutil
+
+from setuptools.extern import six
+
+from setuptools import Command
+
+
+class rotate(Command):
+    """Delete older distributions"""
+
+    description = "delete older distributions, keeping N newest files"
+    user_options = [
+        ('match=', 'm', "patterns to match (required)"),
+        ('dist-dir=', 'd', "directory where the distributions are"),
+        ('keep=', 'k', "number of matching distributions to keep"),
+    ]
+
+    boolean_options = []
+
+    def initialize_options(self):
+        self.match = None
+        self.dist_dir = None
+        self.keep = None
+
+    def finalize_options(self):
+        if self.match is None:
+            raise DistutilsOptionError(
+                "Must specify one or more (comma-separated) match patterns "
+                "(e.g. '.zip' or '.egg')"
+            )
+        if self.keep is None:
+            raise DistutilsOptionError("Must specify number of files to keep")
+        try:
+            self.keep = int(self.keep)
+        except ValueError as e:
+            raise DistutilsOptionError("--keep must be an integer") from e
+        if isinstance(self.match, six.string_types):
+            self.match = [
+                convert_path(p.strip()) for p in self.match.split(',')
+            ]
+        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
+
+    def run(self):
+        self.run_command("egg_info")
+        from glob import glob
+
+        for pattern in self.match:
+            pattern = self.distribution.get_name() + '*' + pattern
+            files = glob(os.path.join(self.dist_dir, pattern))
+            files = [(os.path.getmtime(f), f) for f in files]
+            files.sort()
+            files.reverse()
+
+            log.info("%d file(s) matching %s", len(files), pattern)
+            files = files[self.keep:]
+            for (t, f) in files:
+                log.info("Deleting %s", f)
+                if not self.dry_run:
+                    if os.path.isdir(f):
+                        shutil.rmtree(f)
+                    else:
+                        os.unlink(f)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/saveopts.py b/myenv/lib/python3.9/site-packages/setuptools/command/saveopts.py
new file mode 100644
index 0000000..611cec5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/saveopts.py
@@ -0,0 +1,22 @@
+from setuptools.command.setopt import edit_config, option_base
+
+
+class saveopts(option_base):
+    """Save command-line options to a file"""
+
+    description = "save supplied options to setup.cfg or other config file"
+
+    def run(self):
+        dist = self.distribution
+        settings = {}
+
+        for cmd in dist.command_options:
+
+            if cmd == 'saveopts':
+                continue  # don't save our own options!
+
+            for opt, (src, val) in dist.get_option_dict(cmd).items():
+                if src == "command line":
+                    settings.setdefault(cmd, {})[opt] = val
+
+        edit_config(self.filename, settings, self.dry_run)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/sdist.py b/myenv/lib/python3.9/site-packages/setuptools/command/sdist.py
new file mode 100644
index 0000000..8c3438e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/sdist.py
@@ -0,0 +1,252 @@
+from distutils import log
+import distutils.command.sdist as orig
+import os
+import sys
+import io
+import contextlib
+
+from setuptools.extern import six, ordered_set
+
+from .py36compat import sdist_add_defaults
+
+import pkg_resources
+
+_default_revctrl = list
+
+
+def walk_revctrl(dirname=''):
+    """Find all files under revision control"""
+    for ep in pkg_resources.iter_entry_points('setuptools.file_finders'):
+        for item in ep.load()(dirname):
+            yield item
+
+
+class sdist(sdist_add_defaults, orig.sdist):
+    """Smart sdist that finds anything supported by revision control"""
+
+    user_options = [
+        ('formats=', None,
+         "formats for source distribution (comma-separated list)"),
+        ('keep-temp', 'k',
+         "keep the distribution tree around after creating " +
+         "archive file(s)"),
+        ('dist-dir=', 'd',
+         "directory to put the source distribution archive(s) in "
+         "[default: dist]"),
+    ]
+
+    negative_opt = {}
+
+    README_EXTENSIONS = ['', '.rst', '.txt', '.md']
+    READMES = tuple('README{0}'.format(ext) for ext in README_EXTENSIONS)
+
+    def run(self):
+        self.run_command('egg_info')
+        ei_cmd = self.get_finalized_command('egg_info')
+        self.filelist = ei_cmd.filelist
+        self.filelist.append(os.path.join(ei_cmd.egg_info, 'SOURCES.txt'))
+        self.check_readme()
+
+        # Run sub commands
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+        self.make_distribution()
+
+        dist_files = getattr(self.distribution, 'dist_files', [])
+        for file in self.archive_files:
+            data = ('sdist', '', file)
+            if data not in dist_files:
+                dist_files.append(data)
+
+    def initialize_options(self):
+        orig.sdist.initialize_options(self)
+
+        self._default_to_gztar()
+
+    def _default_to_gztar(self):
+        # only needed on Python prior to 3.6.
+        if sys.version_info >= (3, 6, 0, 'beta', 1):
+            return
+        self.formats = ['gztar']
+
+    def make_distribution(self):
+        """
+        Workaround for #516
+        """
+        with self._remove_os_link():
+            orig.sdist.make_distribution(self)
+
+    @staticmethod
+    @contextlib.contextmanager
+    def _remove_os_link():
+        """
+        In a context, remove and restore os.link if it exists
+        """
+
+        class NoValue:
+            pass
+
+        orig_val = getattr(os, 'link', NoValue)
+        try:
+            del os.link
+        except Exception:
+            pass
+        try:
+            yield
+        finally:
+            if orig_val is not NoValue:
+                setattr(os, 'link', orig_val)
+
+    def __read_template_hack(self):
+        # This grody hack closes the template file (MANIFEST.in) if an
+        #  exception occurs during read_template.
+        # Doing so prevents an error when easy_install attempts to delete the
+        #  file.
+        try:
+            orig.sdist.read_template(self)
+        except Exception:
+            _, _, tb = sys.exc_info()
+            tb.tb_next.tb_frame.f_locals['template'].close()
+            raise
+
+    # Beginning with Python 2.7.2, 3.1.4, and 3.2.1, this leaky file handle
+    #  has been fixed, so only override the method if we're using an earlier
+    #  Python.
+    has_leaky_handle = (
+        sys.version_info < (2, 7, 2)
+        or (3, 0) <= sys.version_info < (3, 1, 4)
+        or (3, 2) <= sys.version_info < (3, 2, 1)
+    )
+    if has_leaky_handle:
+        read_template = __read_template_hack
+
+    def _add_defaults_optional(self):
+        if six.PY2:
+            sdist_add_defaults._add_defaults_optional(self)
+        else:
+            super()._add_defaults_optional()
+        if os.path.isfile('pyproject.toml'):
+            self.filelist.append('pyproject.toml')
+
+    def _add_defaults_python(self):
+        """getting python files"""
+        if self.distribution.has_pure_modules():
+            build_py = self.get_finalized_command('build_py')
+            self.filelist.extend(build_py.get_source_files())
+            self._add_data_files(self._safe_data_files(build_py))
+
+    def _safe_data_files(self, build_py):
+        """
+        Extracting data_files from build_py is known to cause
+        infinite recursion errors when `include_package_data`
+        is enabled, so suppress it in that case.
+        """
+        if self.distribution.include_package_data:
+            return ()
+        return build_py.data_files
+
+    def _add_data_files(self, data_files):
+        """
+        Add data files as found in build_py.data_files.
+        """
+        self.filelist.extend(
+            os.path.join(src_dir, name)
+            for _, src_dir, _, filenames in data_files
+            for name in filenames
+        )
+
+    def _add_defaults_data_files(self):
+        try:
+            if six.PY2:
+                sdist_add_defaults._add_defaults_data_files(self)
+            else:
+                super()._add_defaults_data_files()
+        except TypeError:
+            log.warn("data_files contains unexpected objects")
+
+    def check_readme(self):
+        for f in self.READMES:
+            if os.path.exists(f):
+                return
+        else:
+            self.warn(
+                "standard file not found: should have one of " +
+                ', '.join(self.READMES)
+            )
+
+    def make_release_tree(self, base_dir, files):
+        orig.sdist.make_release_tree(self, base_dir, files)
+
+        # Save any egg_info command line options used to create this sdist
+        dest = os.path.join(base_dir, 'setup.cfg')
+        if hasattr(os, 'link') and os.path.exists(dest):
+            # unlink and re-copy, since it might be hard-linked, and
+            # we don't want to change the source version
+            os.unlink(dest)
+            self.copy_file('setup.cfg', dest)
+
+        self.get_finalized_command('egg_info').save_version_info(dest)
+
+    def _manifest_is_not_generated(self):
+        # check for special comment used in 2.7.1 and higher
+        if not os.path.isfile(self.manifest):
+            return False
+
+        with io.open(self.manifest, 'rb') as fp:
+            first_line = fp.readline()
+        return (first_line !=
+                '# file GENERATED by distutils, do NOT edit\n'.encode())
+
+    def read_manifest(self):
+        """Read the manifest file (named by 'self.manifest') and use it to
+        fill in 'self.filelist', the list of files to include in the source
+        distribution.
+        """
+        log.info("reading manifest file '%s'", self.manifest)
+        manifest = open(self.manifest, 'rb')
+        for line in manifest:
+            # The manifest must contain UTF-8. See #303.
+            if not six.PY2:
+                try:
+                    line = line.decode('UTF-8')
+                except UnicodeDecodeError:
+                    log.warn("%r not UTF-8 decodable -- skipping" % line)
+                    continue
+            # ignore comments and blank lines
+            line = line.strip()
+            if line.startswith('#') or not line:
+                continue
+            self.filelist.append(line)
+        manifest.close()
+
+    def check_license(self):
+        """Checks if license_file' or 'license_files' is configured and adds any
+        valid paths to 'self.filelist'.
+        """
+
+        files = ordered_set.OrderedSet()
+
+        opts = self.distribution.get_option_dict('metadata')
+
+        # ignore the source of the value
+        _, license_file = opts.get('license_file', (None, None))
+
+        if license_file is None:
+            log.debug("'license_file' option was not specified")
+        else:
+            files.add(license_file)
+
+        try:
+            files.update(self.distribution.metadata.license_files)
+        except TypeError:
+            log.warn("warning: 'license_files' option is malformed")
+
+        for f in files:
+            if not os.path.exists(f):
+                log.warn(
+                    "warning: Failed to find the configured license file '%s'",
+                    f)
+                files.remove(f)
+
+        self.filelist.extend(files)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/setopt.py b/myenv/lib/python3.9/site-packages/setuptools/command/setopt.py
new file mode 100644
index 0000000..7e57cc0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/setopt.py
@@ -0,0 +1,149 @@
+from distutils.util import convert_path
+from distutils import log
+from distutils.errors import DistutilsOptionError
+import distutils
+import os
+
+from setuptools.extern.six.moves import configparser
+
+from setuptools import Command
+
+__all__ = ['config_file', 'edit_config', 'option_base', 'setopt']
+
+
+def config_file(kind="local"):
+    """Get the filename of the distutils, local, global, or per-user config
+
+    `kind` must be one of "local", "global", or "user"
+    """
+    if kind == 'local':
+        return 'setup.cfg'
+    if kind == 'global':
+        return os.path.join(
+            os.path.dirname(distutils.__file__), 'distutils.cfg'
+        )
+    if kind == 'user':
+        dot = os.name == 'posix' and '.' or ''
+        return os.path.expanduser(convert_path("~/%spydistutils.cfg" % dot))
+    raise ValueError(
+        "config_file() type must be 'local', 'global', or 'user'", kind
+    )
+
+
+def edit_config(filename, settings, dry_run=False):
+    """Edit a configuration file to include `settings`
+
+    `settings` is a dictionary of dictionaries or ``None`` values, keyed by
+    command/section name.  A ``None`` value means to delete the entire section,
+    while a dictionary lists settings to be changed or deleted in that section.
+    A setting of ``None`` means to delete that setting.
+    """
+    log.debug("Reading configuration from %s", filename)
+    opts = configparser.RawConfigParser()
+    opts.read([filename])
+    for section, options in settings.items():
+        if options is None:
+            log.info("Deleting section [%s] from %s", section, filename)
+            opts.remove_section(section)
+        else:
+            if not opts.has_section(section):
+                log.debug("Adding new section [%s] to %s", section, filename)
+                opts.add_section(section)
+            for option, value in options.items():
+                if value is None:
+                    log.debug(
+                        "Deleting %s.%s from %s",
+                        section, option, filename
+                    )
+                    opts.remove_option(section, option)
+                    if not opts.options(section):
+                        log.info("Deleting empty [%s] section from %s",
+                                 section, filename)
+                        opts.remove_section(section)
+                else:
+                    log.debug(
+                        "Setting %s.%s to %r in %s",
+                        section, option, value, filename
+                    )
+                    opts.set(section, option, value)
+
+    log.info("Writing %s", filename)
+    if not dry_run:
+        with open(filename, 'w') as f:
+            opts.write(f)
+
+
+class option_base(Command):
+    """Abstract base class for commands that mess with config files"""
+
+    user_options = [
+        ('global-config', 'g',
+         "save options to the site-wide distutils.cfg file"),
+        ('user-config', 'u',
+         "save options to the current user's pydistutils.cfg file"),
+        ('filename=', 'f',
+         "configuration file to use (default=setup.cfg)"),
+    ]
+
+    boolean_options = [
+        'global-config', 'user-config',
+    ]
+
+    def initialize_options(self):
+        self.global_config = None
+        self.user_config = None
+        self.filename = None
+
+    def finalize_options(self):
+        filenames = []
+        if self.global_config:
+            filenames.append(config_file('global'))
+        if self.user_config:
+            filenames.append(config_file('user'))
+        if self.filename is not None:
+            filenames.append(self.filename)
+        if not filenames:
+            filenames.append(config_file('local'))
+        if len(filenames) > 1:
+            raise DistutilsOptionError(
+                "Must specify only one configuration file option",
+                filenames
+            )
+        self.filename, = filenames
+
+
+class setopt(option_base):
+    """Save command-line options to a file"""
+
+    description = "set an option in setup.cfg or another config file"
+
+    user_options = [
+        ('command=', 'c', 'command to set an option for'),
+        ('option=', 'o', 'option to set'),
+        ('set-value=', 's', 'value of the option'),
+        ('remove', 'r', 'remove (unset) the value'),
+    ] + option_base.user_options
+
+    boolean_options = option_base.boolean_options + ['remove']
+
+    def initialize_options(self):
+        option_base.initialize_options(self)
+        self.command = None
+        self.option = None
+        self.set_value = None
+        self.remove = None
+
+    def finalize_options(self):
+        option_base.finalize_options(self)
+        if self.command is None or self.option is None:
+            raise DistutilsOptionError("Must specify --command *and* --option")
+        if self.set_value is None and not self.remove:
+            raise DistutilsOptionError("Must specify --set-value or --remove")
+
+    def run(self):
+        edit_config(
+            self.filename, {
+                self.command: {self.option.replace('-', '_'): self.set_value}
+            },
+            self.dry_run
+        )
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/test.py b/myenv/lib/python3.9/site-packages/setuptools/command/test.py
new file mode 100644
index 0000000..2d83967
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/test.py
@@ -0,0 +1,280 @@
+import os
+import operator
+import sys
+import contextlib
+import itertools
+import unittest
+from distutils.errors import DistutilsError, DistutilsOptionError
+from distutils import log
+from unittest import TestLoader
+
+from setuptools.extern import six
+from setuptools.extern.six.moves import map, filter
+
+from pkg_resources import (resource_listdir, resource_exists, normalize_path,
+                           working_set, _namespace_packages, evaluate_marker,
+                           add_activation_listener, require, EntryPoint)
+from setuptools import Command
+from .build_py import _unique_everseen
+
+__metaclass__ = type
+
+
+class ScanningLoader(TestLoader):
+
+    def __init__(self):
+        TestLoader.__init__(self)
+        self._visited = set()
+
+    def loadTestsFromModule(self, module, pattern=None):
+        """Return a suite of all tests cases contained in the given module
+
+        If the module is a package, load tests from all the modules in it.
+        If the module has an ``additional_tests`` function, call it and add
+        the return value to the tests.
+        """
+        if module in self._visited:
+            return None
+        self._visited.add(module)
+
+        tests = []
+        tests.append(TestLoader.loadTestsFromModule(self, module))
+
+        if hasattr(module, "additional_tests"):
+            tests.append(module.additional_tests())
+
+        if hasattr(module, '__path__'):
+            for file in resource_listdir(module.__name__, ''):
+                if file.endswith('.py') and file != '__init__.py':
+                    submodule = module.__name__ + '.' + file[:-3]
+                else:
+                    if resource_exists(module.__name__, file + '/__init__.py'):
+                        submodule = module.__name__ + '.' + file
+                    else:
+                        continue
+                tests.append(self.loadTestsFromName(submodule))
+
+        if len(tests) != 1:
+            return self.suiteClass(tests)
+        else:
+            return tests[0]  # don't create a nested suite for only one return
+
+
+# adapted from jaraco.classes.properties:NonDataProperty
+class NonDataProperty:
+    def __init__(self, fget):
+        self.fget = fget
+
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            return self
+        return self.fget(obj)
+
+
+class test(Command):
+    """Command to run unit tests after in-place build"""
+
+    description = "run unit tests after in-place build (deprecated)"
+
+    user_options = [
+        ('test-module=', 'm', "Run 'test_suite' in specified module"),
+        ('test-suite=', 's',
+         "Run single test, case or suite (e.g. 'module.test_suite')"),
+        ('test-runner=', 'r', "Test runner to use"),
+    ]
+
+    def initialize_options(self):
+        self.test_suite = None
+        self.test_module = None
+        self.test_loader = None
+        self.test_runner = None
+
+    def finalize_options(self):
+
+        if self.test_suite and self.test_module:
+            msg = "You may specify a module or a suite, but not both"
+            raise DistutilsOptionError(msg)
+
+        if self.test_suite is None:
+            if self.test_module is None:
+                self.test_suite = self.distribution.test_suite
+            else:
+                self.test_suite = self.test_module + ".test_suite"
+
+        if self.test_loader is None:
+            self.test_loader = getattr(self.distribution, 'test_loader', None)
+        if self.test_loader is None:
+            self.test_loader = "setuptools.command.test:ScanningLoader"
+        if self.test_runner is None:
+            self.test_runner = getattr(self.distribution, 'test_runner', None)
+
+    @NonDataProperty
+    def test_args(self):
+        return list(self._test_args())
+
+    def _test_args(self):
+        if not self.test_suite and sys.version_info >= (2, 7):
+            yield 'discover'
+        if self.verbose:
+            yield '--verbose'
+        if self.test_suite:
+            yield self.test_suite
+
+    def with_project_on_sys_path(self, func):
+        """
+        Backward compatibility for project_on_sys_path context.
+        """
+        with self.project_on_sys_path():
+            func()
+
+    @contextlib.contextmanager
+    def project_on_sys_path(self, include_dists=[]):
+        with_2to3 = not six.PY2 and getattr(
+            self.distribution, 'use_2to3', False)
+
+        if with_2to3:
+            # If we run 2to3 we can not do this inplace:
+
+            # Ensure metadata is up-to-date
+            self.reinitialize_command('build_py', inplace=0)
+            self.run_command('build_py')
+            bpy_cmd = self.get_finalized_command("build_py")
+            build_path = normalize_path(bpy_cmd.build_lib)
+
+            # Build extensions
+            self.reinitialize_command('egg_info', egg_base=build_path)
+            self.run_command('egg_info')
+
+            self.reinitialize_command('build_ext', inplace=0)
+            self.run_command('build_ext')
+        else:
+            # Without 2to3 inplace works fine:
+            self.run_command('egg_info')
+
+            # Build extensions in-place
+            self.reinitialize_command('build_ext', inplace=1)
+            self.run_command('build_ext')
+
+        ei_cmd = self.get_finalized_command("egg_info")
+
+        old_path = sys.path[:]
+        old_modules = sys.modules.copy()
+
+        try:
+            project_path = normalize_path(ei_cmd.egg_base)
+            sys.path.insert(0, project_path)
+            working_set.__init__()
+            add_activation_listener(lambda dist: dist.activate())
+            require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
+            with self.paths_on_pythonpath([project_path]):
+                yield
+        finally:
+            sys.path[:] = old_path
+            sys.modules.clear()
+            sys.modules.update(old_modules)
+            working_set.__init__()
+
+    @staticmethod
+    @contextlib.contextmanager
+    def paths_on_pythonpath(paths):
+        """
+        Add the indicated paths to the head of the PYTHONPATH environment
+        variable so that subprocesses will also see the packages at
+        these paths.
+
+        Do this in a context that restores the value on exit.
+        """
+        nothing = object()
+        orig_pythonpath = os.environ.get('PYTHONPATH', nothing)
+        current_pythonpath = os.environ.get('PYTHONPATH', '')
+        try:
+            prefix = os.pathsep.join(_unique_everseen(paths))
+            to_join = filter(None, [prefix, current_pythonpath])
+            new_path = os.pathsep.join(to_join)
+            if new_path:
+                os.environ['PYTHONPATH'] = new_path
+            yield
+        finally:
+            if orig_pythonpath is nothing:
+                os.environ.pop('PYTHONPATH', None)
+            else:
+                os.environ['PYTHONPATH'] = orig_pythonpath
+
+    @staticmethod
+    def install_dists(dist):
+        """
+        Install the requirements indicated by self.distribution and
+        return an iterable of the dists that were built.
+        """
+        ir_d = dist.fetch_build_eggs(dist.install_requires)
+        tr_d = dist.fetch_build_eggs(dist.tests_require or [])
+        er_d = dist.fetch_build_eggs(
+            v for k, v in dist.extras_require.items()
+            if k.startswith(':') and evaluate_marker(k[1:])
+        )
+        return itertools.chain(ir_d, tr_d, er_d)
+
+    def run(self):
+        self.announce(
+            "WARNING: Testing via this command is deprecated and will be "
+            "removed in a future version. Users looking for a generic test "
+            "entry point independent of test runner are encouraged to use "
+            "tox.",
+            log.WARN,
+        )
+
+        installed_dists = self.install_dists(self.distribution)
+
+        cmd = ' '.join(self._argv)
+        if self.dry_run:
+            self.announce('skipping "%s" (dry run)' % cmd)
+            return
+
+        self.announce('running "%s"' % cmd)
+
+        paths = map(operator.attrgetter('location'), installed_dists)
+        with self.paths_on_pythonpath(paths):
+            with self.project_on_sys_path():
+                self.run_tests()
+
+    def run_tests(self):
+        # Purge modules under test from sys.modules. The test loader will
+        # re-import them from the build location. Required when 2to3 is used
+        # with namespace packages.
+        if not six.PY2 and getattr(self.distribution, 'use_2to3', False):
+            module = self.test_suite.split('.')[0]
+            if module in _namespace_packages:
+                del_modules = []
+                if module in sys.modules:
+                    del_modules.append(module)
+                module += '.'
+                for name in sys.modules:
+                    if name.startswith(module):
+                        del_modules.append(name)
+                list(map(sys.modules.__delitem__, del_modules))
+
+        test = unittest.main(
+            None, None, self._argv,
+            testLoader=self._resolve_as_ep(self.test_loader),
+            testRunner=self._resolve_as_ep(self.test_runner),
+            exit=False,
+        )
+        if not test.result.wasSuccessful():
+            msg = 'Test failed: %s' % test.result
+            self.announce(msg, log.ERROR)
+            raise DistutilsError(msg)
+
+    @property
+    def _argv(self):
+        return ['unittest'] + self.test_args
+
+    @staticmethod
+    def _resolve_as_ep(val):
+        """
+        Load the indicated attribute value, called, as a as if it were
+        specified as an entry point.
+        """
+        if val is None:
+            return
+        parsed = EntryPoint.parse("x=" + val)
+        return parsed.resolve()()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/upload.py b/myenv/lib/python3.9/site-packages/setuptools/command/upload.py
new file mode 100644
index 0000000..ec7f81e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/upload.py
@@ -0,0 +1,17 @@
+from distutils import log
+from distutils.command import upload as orig
+
+from setuptools.errors import RemovedCommandError
+
+
+class upload(orig.upload):
+    """Formerly used to upload packages to PyPI."""
+
+    def run(self):
+        msg = (
+            "The upload command has been removed, use twine to upload "
+            + "instead (https://pypi.org/p/twine)"
+        )
+
+        self.announce("ERROR: " + msg, log.ERROR)
+        raise RemovedCommandError(msg)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/command/upload_docs.py b/myenv/lib/python3.9/site-packages/setuptools/command/upload_docs.py
new file mode 100644
index 0000000..0351da7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/command/upload_docs.py
@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+"""upload_docs
+
+Implements a Distutils 'upload_docs' subcommand (upload documentation to
+PyPI's pythonhosted.org).
+"""
+
+from base64 import standard_b64encode
+from distutils import log
+from distutils.errors import DistutilsOptionError
+import os
+import socket
+import zipfile
+import tempfile
+import shutil
+import itertools
+import functools
+
+from setuptools.extern import six
+from setuptools.extern.six.moves import http_client, urllib
+
+from pkg_resources import iter_entry_points
+from .upload import upload
+
+
+def _encode(s):
+    errors = 'strict' if six.PY2 else 'surrogateescape'
+    return s.encode('utf-8', errors)
+
+
+class upload_docs(upload):
+    # override the default repository as upload_docs isn't
+    # supported by Warehouse (and won't be).
+    DEFAULT_REPOSITORY = 'https://pypi.python.org/pypi/'
+
+    description = 'Upload documentation to PyPI'
+
+    user_options = [
+        ('repository=', 'r',
+         "url of repository [default: %s]" % upload.DEFAULT_REPOSITORY),
+        ('show-response', None,
+         'display full response text from server'),
+        ('upload-dir=', None, 'directory to upload'),
+    ]
+    boolean_options = upload.boolean_options
+
+    def has_sphinx(self):
+        if self.upload_dir is None:
+            for ep in iter_entry_points('distutils.commands', 'build_sphinx'):
+                return True
+
+    sub_commands = [('build_sphinx', has_sphinx)]
+
+    def initialize_options(self):
+        upload.initialize_options(self)
+        self.upload_dir = None
+        self.target_dir = None
+
+    def finalize_options(self):
+        upload.finalize_options(self)
+        if self.upload_dir is None:
+            if self.has_sphinx():
+                build_sphinx = self.get_finalized_command('build_sphinx')
+                self.target_dir = build_sphinx.builder_target_dir
+            else:
+                build = self.get_finalized_command('build')
+                self.target_dir = os.path.join(build.build_base, 'docs')
+        else:
+            self.ensure_dirname('upload_dir')
+            self.target_dir = self.upload_dir
+        if 'pypi.python.org' in self.repository:
+            log.warn("Upload_docs command is deprecated. Use RTD instead.")
+        self.announce('Using upload directory %s' % self.target_dir)
+
+    def create_zipfile(self, filename):
+        zip_file = zipfile.ZipFile(filename, "w")
+        try:
+            self.mkpath(self.target_dir)  # just in case
+            for root, dirs, files in os.walk(self.target_dir):
+                if root == self.target_dir and not files:
+                    tmpl = "no files found in upload directory '%s'"
+                    raise DistutilsOptionError(tmpl % self.target_dir)
+                for name in files:
+                    full = os.path.join(root, name)
+                    relative = root[len(self.target_dir):].lstrip(os.path.sep)
+                    dest = os.path.join(relative, name)
+                    zip_file.write(full, dest)
+        finally:
+            zip_file.close()
+
+    def run(self):
+        # Run sub commands
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+        tmp_dir = tempfile.mkdtemp()
+        name = self.distribution.metadata.get_name()
+        zip_file = os.path.join(tmp_dir, "%s.zip" % name)
+        try:
+            self.create_zipfile(zip_file)
+            self.upload_file(zip_file)
+        finally:
+            shutil.rmtree(tmp_dir)
+
+    @staticmethod
+    def _build_part(item, sep_boundary):
+        key, values = item
+        title = '\nContent-Disposition: form-data; name="%s"' % key
+        # handle multiple entries for the same name
+        if not isinstance(values, list):
+            values = [values]
+        for value in values:
+            if isinstance(value, tuple):
+                title += '; filename="%s"' % value[0]
+                value = value[1]
+            else:
+                value = _encode(value)
+            yield sep_boundary
+            yield _encode(title)
+            yield b"\n\n"
+            yield value
+            if value and value[-1:] == b'\r':
+                yield b'\n'  # write an extra newline (lurve Macs)
+
+    @classmethod
+    def _build_multipart(cls, data):
+        """
+        Build up the MIME payload for the POST data
+        """
+        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
+        sep_boundary = b'\n--' + boundary.encode('ascii')
+        end_boundary = sep_boundary + b'--'
+        end_items = end_boundary, b"\n",
+        builder = functools.partial(
+            cls._build_part,
+            sep_boundary=sep_boundary,
+        )
+        part_groups = map(builder, data.items())
+        parts = itertools.chain.from_iterable(part_groups)
+        body_items = itertools.chain(parts, end_items)
+        content_type = 'multipart/form-data; boundary=%s' % boundary
+        return b''.join(body_items), content_type
+
+    def upload_file(self, filename):
+        with open(filename, 'rb') as f:
+            content = f.read()
+        meta = self.distribution.metadata
+        data = {
+            ':action': 'doc_upload',
+            'name': meta.get_name(),
+            'content': (os.path.basename(filename), content),
+        }
+        # set up the authentication
+        credentials = _encode(self.username + ':' + self.password)
+        credentials = standard_b64encode(credentials)
+        if not six.PY2:
+            credentials = credentials.decode('ascii')
+        auth = "Basic " + credentials
+
+        body, ct = self._build_multipart(data)
+
+        msg = "Submitting documentation to %s" % (self.repository)
+        self.announce(msg, log.INFO)
+
+        # build the Request
+        # We can't use urllib2 since we need to send the Basic
+        # auth right with the first request
+        schema, netloc, url, params, query, fragments = \
+            urllib.parse.urlparse(self.repository)
+        assert not params and not query and not fragments
+        if schema == 'http':
+            conn = http_client.HTTPConnection(netloc)
+        elif schema == 'https':
+            conn = http_client.HTTPSConnection(netloc)
+        else:
+            raise AssertionError("unsupported schema " + schema)
+
+        data = ''
+        try:
+            conn.connect()
+            conn.putrequest("POST", url)
+            content_type = ct
+            conn.putheader('Content-type', content_type)
+            conn.putheader('Content-length', str(len(body)))
+            conn.putheader('Authorization', auth)
+            conn.endheaders()
+            conn.send(body)
+        except socket.error as e:
+            self.announce(str(e), log.ERROR)
+            return
+
+        r = conn.getresponse()
+        if r.status == 200:
+            msg = 'Server response (%s): %s' % (r.status, r.reason)
+            self.announce(msg, log.INFO)
+        elif r.status == 301:
+            location = r.getheader('Location')
+            if location is None:
+                location = 'https://pythonhosted.org/%s/' % meta.get_name()
+            msg = 'Upload successful. Visit %s' % location
+            self.announce(msg, log.INFO)
+        else:
+            msg = 'Upload failed (%s): %s' % (r.status, r.reason)
+            self.announce(msg, log.ERROR)
+        if self.show_response:
+            print('-' * 75, r.read(), '-' * 75)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/config.py b/myenv/lib/python3.9/site-packages/setuptools/config.py
new file mode 100644
index 0000000..a8f8b6b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/config.py
@@ -0,0 +1,701 @@
+from __future__ import absolute_import, unicode_literals
+import ast
+import io
+import os
+import sys
+
+import warnings
+import functools
+import importlib
+from collections import defaultdict
+from functools import partial
+from functools import wraps
+import contextlib
+
+from distutils.errors import DistutilsOptionError, DistutilsFileError
+from setuptools.extern.packaging.version import LegacyVersion, parse
+from setuptools.extern.packaging.specifiers import SpecifierSet
+from setuptools.extern.six import string_types, PY3
+
+
+__metaclass__ = type
+
+
+class StaticModule:
+    """
+    Attempt to load the module by the name
+    """
+    def __init__(self, name):
+        spec = importlib.util.find_spec(name)
+        with open(spec.origin) as strm:
+            src = strm.read()
+        module = ast.parse(src)
+        vars(self).update(locals())
+        del self.self
+
+    def __getattr__(self, attr):
+        try:
+            return next(
+                ast.literal_eval(statement.value)
+                for statement in self.module.body
+                if isinstance(statement, ast.Assign)
+                for target in statement.targets
+                if isinstance(target, ast.Name) and target.id == attr
+            )
+        except Exception as e:
+            raise AttributeError(
+                "{self.name} has no attribute {attr}".format(**locals())
+            ) from e
+
+
+@contextlib.contextmanager
+def patch_path(path):
+    """
+    Add path to front of sys.path for the duration of the context.
+    """
+    try:
+        sys.path.insert(0, path)
+        yield
+    finally:
+        sys.path.remove(path)
+
+
+def read_configuration(
+        filepath, find_others=False, ignore_option_errors=False):
+    """Read given configuration file and returns options from it as a dict.
+
+    :param str|unicode filepath: Path to configuration file
+        to get options from.
+
+    :param bool find_others: Whether to search for other configuration files
+        which could be on in various places.
+
+    :param bool ignore_option_errors: Whether to silently ignore
+        options, values of which could not be resolved (e.g. due to exceptions
+        in directives such as file:, attr:, etc.).
+        If False exceptions are propagated as expected.
+
+    :rtype: dict
+    """
+    from setuptools.dist import Distribution, _Distribution
+
+    filepath = os.path.abspath(filepath)
+
+    if not os.path.isfile(filepath):
+        raise DistutilsFileError(
+            'Configuration file %s does not exist.' % filepath)
+
+    current_directory = os.getcwd()
+    os.chdir(os.path.dirname(filepath))
+
+    try:
+        dist = Distribution()
+
+        filenames = dist.find_config_files() if find_others else []
+        if filepath not in filenames:
+            filenames.append(filepath)
+
+        _Distribution.parse_config_files(dist, filenames=filenames)
+
+        handlers = parse_configuration(
+            dist, dist.command_options,
+            ignore_option_errors=ignore_option_errors)
+
+    finally:
+        os.chdir(current_directory)
+
+    return configuration_to_dict(handlers)
+
+
+def _get_option(target_obj, key):
+    """
+    Given a target object and option key, get that option from
+    the target object, either through a get_{key} method or
+    from an attribute directly.
+    """
+    getter_name = 'get_{key}'.format(**locals())
+    by_attribute = functools.partial(getattr, target_obj, key)
+    getter = getattr(target_obj, getter_name, by_attribute)
+    return getter()
+
+
+def configuration_to_dict(handlers):
+    """Returns configuration data gathered by given handlers as a dict.
+
+    :param list[ConfigHandler] handlers: Handlers list,
+        usually from parse_configuration()
+
+    :rtype: dict
+    """
+    config_dict = defaultdict(dict)
+
+    for handler in handlers:
+        for option in handler.set_options:
+            value = _get_option(handler.target_obj, option)
+            config_dict[handler.section_prefix][option] = value
+
+    return config_dict
+
+
+def parse_configuration(
+        distribution, command_options, ignore_option_errors=False):
+    """Performs additional parsing of configuration options
+    for a distribution.
+
+    Returns a list of used option handlers.
+
+    :param Distribution distribution:
+    :param dict command_options:
+    :param bool ignore_option_errors: Whether to silently ignore
+        options, values of which could not be resolved (e.g. due to exceptions
+        in directives such as file:, attr:, etc.).
+        If False exceptions are propagated as expected.
+    :rtype: list
+    """
+    options = ConfigOptionsHandler(
+        distribution, command_options, ignore_option_errors)
+    options.parse()
+
+    meta = ConfigMetadataHandler(
+        distribution.metadata, command_options, ignore_option_errors,
+        distribution.package_dir)
+    meta.parse()
+
+    return meta, options
+
+
+class ConfigHandler:
+    """Handles metadata supplied in configuration files."""
+
+    section_prefix = None
+    """Prefix for config sections handled by this handler.
+    Must be provided by class heirs.
+
+    """
+
+    aliases = {}
+    """Options aliases.
+    For compatibility with various packages. E.g.: d2to1 and pbr.
+    Note: `-` in keys is replaced with `_` by config parser.
+
+    """
+
+    def __init__(self, target_obj, options, ignore_option_errors=False):
+        sections = {}
+
+        section_prefix = self.section_prefix
+        for section_name, section_options in options.items():
+            if not section_name.startswith(section_prefix):
+                continue
+
+            section_name = section_name.replace(section_prefix, '').strip('.')
+            sections[section_name] = section_options
+
+        self.ignore_option_errors = ignore_option_errors
+        self.target_obj = target_obj
+        self.sections = sections
+        self.set_options = []
+
+    @property
+    def parsers(self):
+        """Metadata item name to parser function mapping."""
+        raise NotImplementedError(
+            '%s must provide .parsers property' % self.__class__.__name__)
+
+    def __setitem__(self, option_name, value):
+        unknown = tuple()
+        target_obj = self.target_obj
+
+        # Translate alias into real name.
+        option_name = self.aliases.get(option_name, option_name)
+
+        current_value = getattr(target_obj, option_name, unknown)
+
+        if current_value is unknown:
+            raise KeyError(option_name)
+
+        if current_value:
+            # Already inhabited. Skipping.
+            return
+
+        skip_option = False
+        parser = self.parsers.get(option_name)
+        if parser:
+            try:
+                value = parser(value)
+
+            except Exception:
+                skip_option = True
+                if not self.ignore_option_errors:
+                    raise
+
+        if skip_option:
+            return
+
+        setter = getattr(target_obj, 'set_%s' % option_name, None)
+        if setter is None:
+            setattr(target_obj, option_name, value)
+        else:
+            setter(value)
+
+        self.set_options.append(option_name)
+
+    @classmethod
+    def _parse_list(cls, value, separator=','):
+        """Represents value as a list.
+
+        Value is split either by separator (defaults to comma) or by lines.
+
+        :param value:
+        :param separator: List items separator character.
+        :rtype: list
+        """
+        if isinstance(value, list):  # _get_parser_compound case
+            return value
+
+        if '\n' in value:
+            value = value.splitlines()
+        else:
+            value = value.split(separator)
+
+        return [chunk.strip() for chunk in value if chunk.strip()]
+
+    @classmethod
+    def _parse_dict(cls, value):
+        """Represents value as a dict.
+
+        :param value:
+        :rtype: dict
+        """
+        separator = '='
+        result = {}
+        for line in cls._parse_list(value):
+            key, sep, val = line.partition(separator)
+            if sep != separator:
+                raise DistutilsOptionError(
+                    'Unable to parse option value to dict: %s' % value)
+            result[key.strip()] = val.strip()
+
+        return result
+
+    @classmethod
+    def _parse_bool(cls, value):
+        """Represents value as boolean.
+
+        :param value:
+        :rtype: bool
+        """
+        value = value.lower()
+        return value in ('1', 'true', 'yes')
+
+    @classmethod
+    def _exclude_files_parser(cls, key):
+        """Returns a parser function to make sure field inputs
+        are not files.
+
+        Parses a value after getting the key so error messages are
+        more informative.
+
+        :param key:
+        :rtype: callable
+        """
+        def parser(value):
+            exclude_directive = 'file:'
+            if value.startswith(exclude_directive):
+                raise ValueError(
+                    'Only strings are accepted for the {0} field, '
+                    'files are not accepted'.format(key))
+            return value
+        return parser
+
+    @classmethod
+    def _parse_file(cls, value):
+        """Represents value as a string, allowing including text
+        from nearest files using `file:` directive.
+
+        Directive is sandboxed and won't reach anything outside
+        directory with setup.py.
+
+        Examples:
+            file: README.rst, CHANGELOG.md, src/file.txt
+
+        :param str value:
+        :rtype: str
+        """
+        include_directive = 'file:'
+
+        if not isinstance(value, string_types):
+            return value
+
+        if not value.startswith(include_directive):
+            return value
+
+        spec = value[len(include_directive):]
+        filepaths = (os.path.abspath(path.strip()) for path in spec.split(','))
+        return '\n'.join(
+            cls._read_file(path)
+            for path in filepaths
+            if (cls._assert_local(path) or True)
+            and os.path.isfile(path)
+        )
+
+    @staticmethod
+    def _assert_local(filepath):
+        if not filepath.startswith(os.getcwd()):
+            raise DistutilsOptionError(
+                '`file:` directive can not access %s' % filepath)
+
+    @staticmethod
+    def _read_file(filepath):
+        with io.open(filepath, encoding='utf-8') as f:
+            return f.read()
+
+    @classmethod
+    def _parse_attr(cls, value, package_dir=None):
+        """Represents value as a module attribute.
+
+        Examples:
+            attr: package.attr
+            attr: package.module.attr
+
+        :param str value:
+        :rtype: str
+        """
+        attr_directive = 'attr:'
+        if not value.startswith(attr_directive):
+            return value
+
+        attrs_path = value.replace(attr_directive, '').strip().split('.')
+        attr_name = attrs_path.pop()
+
+        module_name = '.'.join(attrs_path)
+        module_name = module_name or '__init__'
+
+        parent_path = os.getcwd()
+        if package_dir:
+            if attrs_path[0] in package_dir:
+                # A custom path was specified for the module we want to import
+                custom_path = package_dir[attrs_path[0]]
+                parts = custom_path.rsplit('/', 1)
+                if len(parts) > 1:
+                    parent_path = os.path.join(os.getcwd(), parts[0])
+                    module_name = parts[1]
+                else:
+                    module_name = custom_path
+            elif '' in package_dir:
+                # A custom parent directory was specified for all root modules
+                parent_path = os.path.join(os.getcwd(), package_dir[''])
+
+        with patch_path(parent_path):
+            try:
+                # attempt to load value statically
+                return getattr(StaticModule(module_name), attr_name)
+            except Exception:
+                # fallback to simple import
+                module = importlib.import_module(module_name)
+
+        return getattr(module, attr_name)
+
+    @classmethod
+    def _get_parser_compound(cls, *parse_methods):
+        """Returns parser function to represents value as a list.
+
+        Parses a value applying given methods one after another.
+
+        :param parse_methods:
+        :rtype: callable
+        """
+        def parse(value):
+            parsed = value
+
+            for method in parse_methods:
+                parsed = method(parsed)
+
+            return parsed
+
+        return parse
+
+    @classmethod
+    def _parse_section_to_dict(cls, section_options, values_parser=None):
+        """Parses section options into a dictionary.
+
+        Optionally applies a given parser to values.
+
+        :param dict section_options:
+        :param callable values_parser:
+        :rtype: dict
+        """
+        value = {}
+        values_parser = values_parser or (lambda val: val)
+        for key, (_, val) in section_options.items():
+            value[key] = values_parser(val)
+        return value
+
+    def parse_section(self, section_options):
+        """Parses configuration file section.
+
+        :param dict section_options:
+        """
+        for (name, (_, value)) in section_options.items():
+            try:
+                self[name] = value
+
+            except KeyError:
+                pass  # Keep silent for a new option may appear anytime.
+
+    def parse(self):
+        """Parses configuration file items from one
+        or more related sections.
+
+        """
+        for section_name, section_options in self.sections.items():
+
+            method_postfix = ''
+            if section_name:  # [section.option] variant
+                method_postfix = '_%s' % section_name
+
+            section_parser_method = getattr(
+                self,
+                # Dots in section names are translated into dunderscores.
+                ('parse_section%s' % method_postfix).replace('.', '__'),
+                None)
+
+            if section_parser_method is None:
+                raise DistutilsOptionError(
+                    'Unsupported distribution option section: [%s.%s]' % (
+                        self.section_prefix, section_name))
+
+            section_parser_method(section_options)
+
+    def _deprecated_config_handler(self, func, msg, warning_class):
+        """ this function will wrap around parameters that are deprecated
+
+        :param msg: deprecation message
+        :param warning_class: class of warning exception to be raised
+        :param func: function to be wrapped around
+        """
+        @wraps(func)
+        def config_handler(*args, **kwargs):
+            warnings.warn(msg, warning_class)
+            return func(*args, **kwargs)
+
+        return config_handler
+
+
+class ConfigMetadataHandler(ConfigHandler):
+
+    section_prefix = 'metadata'
+
+    aliases = {
+        'home_page': 'url',
+        'summary': 'description',
+        'classifier': 'classifiers',
+        'platform': 'platforms',
+    }
+
+    strict_mode = False
+    """We need to keep it loose, to be partially compatible with
+    `pbr` and `d2to1` packages which also uses `metadata` section.
+
+    """
+
+    def __init__(self, target_obj, options, ignore_option_errors=False,
+                 package_dir=None):
+        super(ConfigMetadataHandler, self).__init__(target_obj, options,
+                                                    ignore_option_errors)
+        self.package_dir = package_dir
+
+    @property
+    def parsers(self):
+        """Metadata item name to parser function mapping."""
+        parse_list = self._parse_list
+        parse_file = self._parse_file
+        parse_dict = self._parse_dict
+        exclude_files_parser = self._exclude_files_parser
+
+        return {
+            'platforms': parse_list,
+            'keywords': parse_list,
+            'provides': parse_list,
+            'requires': self._deprecated_config_handler(
+                parse_list,
+                "The requires parameter is deprecated, please use "
+                "install_requires for runtime dependencies.",
+                DeprecationWarning),
+            'obsoletes': parse_list,
+            'classifiers': self._get_parser_compound(parse_file, parse_list),
+            'license': exclude_files_parser('license'),
+            'license_files': parse_list,
+            'description': parse_file,
+            'long_description': parse_file,
+            'version': self._parse_version,
+            'project_urls': parse_dict,
+        }
+
+    def _parse_version(self, value):
+        """Parses `version` option value.
+
+        :param value:
+        :rtype: str
+
+        """
+        version = self._parse_file(value)
+
+        if version != value:
+            version = version.strip()
+            # Be strict about versions loaded from file because it's easy to
+            # accidentally include newlines and other unintended content
+            if isinstance(parse(version), LegacyVersion):
+                tmpl = (
+                    'Version loaded from {value} does not '
+                    'comply with PEP 440: {version}'
+                )
+                raise DistutilsOptionError(tmpl.format(**locals()))
+
+            return version
+
+        version = self._parse_attr(value, self.package_dir)
+
+        if callable(version):
+            version = version()
+
+        if not isinstance(version, string_types):
+            if hasattr(version, '__iter__'):
+                version = '.'.join(map(str, version))
+            else:
+                version = '%s' % version
+
+        return version
+
+
+class ConfigOptionsHandler(ConfigHandler):
+
+    section_prefix = 'options'
+
+    @property
+    def parsers(self):
+        """Metadata item name to parser function mapping."""
+        parse_list = self._parse_list
+        parse_list_semicolon = partial(self._parse_list, separator=';')
+        parse_bool = self._parse_bool
+        parse_dict = self._parse_dict
+
+        return {
+            'zip_safe': parse_bool,
+            'use_2to3': parse_bool,
+            'include_package_data': parse_bool,
+            'package_dir': parse_dict,
+            'use_2to3_fixers': parse_list,
+            'use_2to3_exclude_fixers': parse_list,
+            'convert_2to3_doctests': parse_list,
+            'scripts': parse_list,
+            'eager_resources': parse_list,
+            'dependency_links': parse_list,
+            'namespace_packages': parse_list,
+            'install_requires': parse_list_semicolon,
+            'setup_requires': parse_list_semicolon,
+            'tests_require': parse_list_semicolon,
+            'packages': self._parse_packages,
+            'entry_points': self._parse_file,
+            'py_modules': parse_list,
+            'python_requires': SpecifierSet,
+        }
+
+    def _parse_packages(self, value):
+        """Parses `packages` option value.
+
+        :param value:
+        :rtype: list
+        """
+        find_directives = ['find:', 'find_namespace:']
+        trimmed_value = value.strip()
+
+        if trimmed_value not in find_directives:
+            return self._parse_list(value)
+
+        findns = trimmed_value == find_directives[1]
+        if findns and not PY3:
+            raise DistutilsOptionError(
+                'find_namespace: directive is unsupported on Python < 3.3')
+
+        # Read function arguments from a dedicated section.
+        find_kwargs = self.parse_section_packages__find(
+            self.sections.get('packages.find', {}))
+
+        if findns:
+            from setuptools import find_namespace_packages as find_packages
+        else:
+            from setuptools import find_packages
+
+        return find_packages(**find_kwargs)
+
+    def parse_section_packages__find(self, section_options):
+        """Parses `packages.find` configuration file section.
+
+        To be used in conjunction with _parse_packages().
+
+        :param dict section_options:
+        """
+        section_data = self._parse_section_to_dict(
+            section_options, self._parse_list)
+
+        valid_keys = ['where', 'include', 'exclude']
+
+        find_kwargs = dict(
+            [(k, v) for k, v in section_data.items() if k in valid_keys and v])
+
+        where = find_kwargs.get('where')
+        if where is not None:
+            find_kwargs['where'] = where[0]  # cast list to single val
+
+        return find_kwargs
+
+    def parse_section_entry_points(self, section_options):
+        """Parses `entry_points` configuration file section.
+
+        :param dict section_options:
+        """
+        parsed = self._parse_section_to_dict(section_options, self._parse_list)
+        self['entry_points'] = parsed
+
+    def _parse_package_data(self, section_options):
+        parsed = self._parse_section_to_dict(section_options, self._parse_list)
+
+        root = parsed.get('*')
+        if root:
+            parsed[''] = root
+            del parsed['*']
+
+        return parsed
+
+    def parse_section_package_data(self, section_options):
+        """Parses `package_data` configuration file section.
+
+        :param dict section_options:
+        """
+        self['package_data'] = self._parse_package_data(section_options)
+
+    def parse_section_exclude_package_data(self, section_options):
+        """Parses `exclude_package_data` configuration file section.
+
+        :param dict section_options:
+        """
+        self['exclude_package_data'] = self._parse_package_data(
+            section_options)
+
+    def parse_section_extras_require(self, section_options):
+        """Parses `extras_require` configuration file section.
+
+        :param dict section_options:
+        """
+        parse_list = partial(self._parse_list, separator=';')
+        self['extras_require'] = self._parse_section_to_dict(
+            section_options, parse_list)
+
+    def parse_section_data_files(self, section_options):
+        """Parses `data_files` configuration file section.
+
+        :param dict section_options:
+        """
+        parsed = self._parse_section_to_dict(section_options, self._parse_list)
+        self['data_files'] = [(k, v) for k, v in parsed.items()]
diff --git a/myenv/lib/python3.9/site-packages/setuptools/dep_util.py b/myenv/lib/python3.9/site-packages/setuptools/dep_util.py
new file mode 100644
index 0000000..521eb71
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/dep_util.py
@@ -0,0 +1,25 @@
+from distutils.dep_util import newer_group
+
+
+# yes, this is was almost entirely copy-pasted from
+# 'newer_pairwise()', this is just another convenience
+# function.
+def newer_pairwise_group(sources_groups, targets):
+    """Walk both arguments in parallel, testing if each source group is newer
+    than its corresponding target. Returns a pair of lists (sources_groups,
+    targets) where sources is newer than target, according to the semantics
+    of 'newer_group()'.
+    """
+    if len(sources_groups) != len(targets):
+        raise ValueError(
+            "'sources_group' and 'targets' must be the same length")
+
+    # build a pair of lists (sources_groups, targets) where source is newer
+    n_sources = []
+    n_targets = []
+    for i in range(len(sources_groups)):
+        if newer_group(sources_groups[i], targets[i]):
+            n_sources.append(sources_groups[i])
+            n_targets.append(targets[i])
+
+    return n_sources, n_targets
diff --git a/myenv/lib/python3.9/site-packages/setuptools/depends.py b/myenv/lib/python3.9/site-packages/setuptools/depends.py
new file mode 100644
index 0000000..a37675c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/depends.py
@@ -0,0 +1,176 @@
+import sys
+import marshal
+import contextlib
+from distutils.version import StrictVersion
+
+from .py33compat import Bytecode
+
+from .py27compat import find_module, PY_COMPILED, PY_FROZEN, PY_SOURCE
+from . import py27compat
+
+
+__all__ = [
+    'Require', 'find_module', 'get_module_constant', 'extract_constant'
+]
+
+
+class Require:
+    """A prerequisite to building or installing a distribution"""
+
+    def __init__(
+            self, name, requested_version, module, homepage='',
+            attribute=None, format=None):
+
+        if format is None and requested_version is not None:
+            format = StrictVersion
+
+        if format is not None:
+            requested_version = format(requested_version)
+            if attribute is None:
+                attribute = '__version__'
+
+        self.__dict__.update(locals())
+        del self.self
+
+    def full_name(self):
+        """Return full package/distribution name, w/version"""
+        if self.requested_version is not None:
+            return '%s-%s' % (self.name, self.requested_version)
+        return self.name
+
+    def version_ok(self, version):
+        """Is 'version' sufficiently up-to-date?"""
+        return self.attribute is None or self.format is None or \
+            str(version) != "unknown" and version >= self.requested_version
+
+    def get_version(self, paths=None, default="unknown"):
+        """Get version number of installed module, 'None', or 'default'
+
+        Search 'paths' for module.  If not found, return 'None'.  If found,
+        return the extracted version attribute, or 'default' if no version
+        attribute was specified, or the value cannot be determined without
+        importing the module.  The version is formatted according to the
+        requirement's version format (if any), unless it is 'None' or the
+        supplied 'default'.
+        """
+
+        if self.attribute is None:
+            try:
+                f, p, i = find_module(self.module, paths)
+                if f:
+                    f.close()
+                return default
+            except ImportError:
+                return None
+
+        v = get_module_constant(self.module, self.attribute, default, paths)
+
+        if v is not None and v is not default and self.format is not None:
+            return self.format(v)
+
+        return v
+
+    def is_present(self, paths=None):
+        """Return true if dependency is present on 'paths'"""
+        return self.get_version(paths) is not None
+
+    def is_current(self, paths=None):
+        """Return true if dependency is present and up-to-date on 'paths'"""
+        version = self.get_version(paths)
+        if version is None:
+            return False
+        return self.version_ok(version)
+
+
+def maybe_close(f):
+    @contextlib.contextmanager
+    def empty():
+        yield
+        return
+    if not f:
+        return empty()
+
+    return contextlib.closing(f)
+
+
+def get_module_constant(module, symbol, default=-1, paths=None):
+    """Find 'module' by searching 'paths', and extract 'symbol'
+
+    Return 'None' if 'module' does not exist on 'paths', or it does not define
+    'symbol'.  If the module defines 'symbol' as a constant, return the
+    constant.  Otherwise, return 'default'."""
+
+    try:
+        f, path, (suffix, mode, kind) = info = find_module(module, paths)
+    except ImportError:
+        # Module doesn't exist
+        return None
+
+    with maybe_close(f):
+        if kind == PY_COMPILED:
+            f.read(8)  # skip magic & date
+            code = marshal.load(f)
+        elif kind == PY_FROZEN:
+            code = py27compat.get_frozen_object(module, paths)
+        elif kind == PY_SOURCE:
+            code = compile(f.read(), path, 'exec')
+        else:
+            # Not something we can parse; we'll have to import it.  :(
+            imported = py27compat.get_module(module, paths, info)
+            return getattr(imported, symbol, None)
+
+    return extract_constant(code, symbol, default)
+
+
+def extract_constant(code, symbol, default=-1):
+    """Extract the constant value of 'symbol' from 'code'
+
+    If the name 'symbol' is bound to a constant value by the Python code
+    object 'code', return that value.  If 'symbol' is bound to an expression,
+    return 'default'.  Otherwise, return 'None'.
+
+    Return value is based on the first assignment to 'symbol'.  'symbol' must
+    be a global, or at least a non-"fast" local in the code block.  That is,
+    only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol'
+    must be present in 'code.co_names'.
+    """
+    if symbol not in code.co_names:
+        # name's not there, can't possibly be an assignment
+        return None
+
+    name_idx = list(code.co_names).index(symbol)
+
+    STORE_NAME = 90
+    STORE_GLOBAL = 97
+    LOAD_CONST = 100
+
+    const = default
+
+    for byte_code in Bytecode(code):
+        op = byte_code.opcode
+        arg = byte_code.arg
+
+        if op == LOAD_CONST:
+            const = code.co_consts[arg]
+        elif arg == name_idx and (op == STORE_NAME or op == STORE_GLOBAL):
+            return const
+        else:
+            const = default
+
+
+def _update_globals():
+    """
+    Patch the globals to remove the objects not available on some platforms.
+
+    XXX it'd be better to test assertions about bytecode instead.
+    """
+
+    if not sys.platform.startswith('java') and sys.platform != 'cli':
+        return
+    incompatible = 'extract_constant', 'get_module_constant'
+    for name in incompatible:
+        del globals()[name]
+        __all__.remove(name)
+
+
+_update_globals()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/dist.py b/myenv/lib/python3.9/site-packages/setuptools/dist.py
new file mode 100644
index 0000000..e813b11
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/dist.py
@@ -0,0 +1,1035 @@
+# -*- coding: utf-8 -*-
+__all__ = ['Distribution']
+
+import io
+import sys
+import re
+import os
+import warnings
+import numbers
+import distutils.log
+import distutils.core
+import distutils.cmd
+import distutils.dist
+from distutils.util import strtobool
+from distutils.debug import DEBUG
+from distutils.fancy_getopt import translate_longopt
+import itertools
+
+from collections import defaultdict
+from email import message_from_file
+
+from distutils.errors import DistutilsOptionError, DistutilsSetupError
+from distutils.util import rfc822_escape
+from distutils.version import StrictVersion
+
+from setuptools.extern import six
+from setuptools.extern import packaging
+from setuptools.extern import ordered_set
+from setuptools.extern.six.moves import map, filter, filterfalse
+
+from . import SetuptoolsDeprecationWarning
+
+import setuptools
+from setuptools import windows_support
+from setuptools.monkey import get_unpatched
+from setuptools.config import parse_configuration
+import pkg_resources
+
+__import__('setuptools.extern.packaging.specifiers')
+__import__('setuptools.extern.packaging.version')
+
+
+def _get_unpatched(cls):
+    warnings.warn("Do not call this function", DistDeprecationWarning)
+    return get_unpatched(cls)
+
+
+def get_metadata_version(self):
+    mv = getattr(self, 'metadata_version', None)
+
+    if mv is None:
+        if self.long_description_content_type or self.provides_extras:
+            mv = StrictVersion('2.1')
+        elif (self.maintainer is not None or
+              self.maintainer_email is not None or
+              getattr(self, 'python_requires', None) is not None or
+              self.project_urls):
+            mv = StrictVersion('1.2')
+        elif (self.provides or self.requires or self.obsoletes or
+                self.classifiers or self.download_url):
+            mv = StrictVersion('1.1')
+        else:
+            mv = StrictVersion('1.0')
+
+        self.metadata_version = mv
+
+    return mv
+
+
+def read_pkg_file(self, file):
+    """Reads the metadata values from a file object."""
+    msg = message_from_file(file)
+
+    def _read_field(name):
+        value = msg[name]
+        if value == 'UNKNOWN':
+            return None
+        return value
+
+    def _read_list(name):
+        values = msg.get_all(name, None)
+        if values == []:
+            return None
+        return values
+
+    self.metadata_version = StrictVersion(msg['metadata-version'])
+    self.name = _read_field('name')
+    self.version = _read_field('version')
+    self.description = _read_field('summary')
+    # we are filling author only.
+    self.author = _read_field('author')
+    self.maintainer = None
+    self.author_email = _read_field('author-email')
+    self.maintainer_email = None
+    self.url = _read_field('home-page')
+    self.license = _read_field('license')
+
+    if 'download-url' in msg:
+        self.download_url = _read_field('download-url')
+    else:
+        self.download_url = None
+
+    self.long_description = _read_field('description')
+    self.description = _read_field('summary')
+
+    if 'keywords' in msg:
+        self.keywords = _read_field('keywords').split(',')
+
+    self.platforms = _read_list('platform')
+    self.classifiers = _read_list('classifier')
+
+    # PEP 314 - these fields only exist in 1.1
+    if self.metadata_version == StrictVersion('1.1'):
+        self.requires = _read_list('requires')
+        self.provides = _read_list('provides')
+        self.obsoletes = _read_list('obsoletes')
+    else:
+        self.requires = None
+        self.provides = None
+        self.obsoletes = None
+
+
+# Based on Python 3.5 version
+def write_pkg_file(self, file):
+    """Write the PKG-INFO format data to a file object.
+    """
+    version = self.get_metadata_version()
+
+    if six.PY2:
+        def write_field(key, value):
+            file.write("%s: %s\n" % (key, self._encode_field(value)))
+    else:
+        def write_field(key, value):
+            file.write("%s: %s\n" % (key, value))
+
+    write_field('Metadata-Version', str(version))
+    write_field('Name', self.get_name())
+    write_field('Version', self.get_version())
+    write_field('Summary', self.get_description())
+    write_field('Home-page', self.get_url())
+
+    if version < StrictVersion('1.2'):
+        write_field('Author', self.get_contact())
+        write_field('Author-email', self.get_contact_email())
+    else:
+        optional_fields = (
+            ('Author', 'author'),
+            ('Author-email', 'author_email'),
+            ('Maintainer', 'maintainer'),
+            ('Maintainer-email', 'maintainer_email'),
+        )
+
+        for field, attr in optional_fields:
+            attr_val = getattr(self, attr)
+
+            if attr_val is not None:
+                write_field(field, attr_val)
+
+    write_field('License', self.get_license())
+    if self.download_url:
+        write_field('Download-URL', self.download_url)
+    for project_url in self.project_urls.items():
+        write_field('Project-URL', '%s, %s' % project_url)
+
+    long_desc = rfc822_escape(self.get_long_description())
+    write_field('Description', long_desc)
+
+    keywords = ','.join(self.get_keywords())
+    if keywords:
+        write_field('Keywords', keywords)
+
+    if version >= StrictVersion('1.2'):
+        for platform in self.get_platforms():
+            write_field('Platform', platform)
+    else:
+        self._write_list(file, 'Platform', self.get_platforms())
+
+    self._write_list(file, 'Classifier', self.get_classifiers())
+
+    # PEP 314
+    self._write_list(file, 'Requires', self.get_requires())
+    self._write_list(file, 'Provides', self.get_provides())
+    self._write_list(file, 'Obsoletes', self.get_obsoletes())
+
+    # Setuptools specific for PEP 345
+    if hasattr(self, 'python_requires'):
+        write_field('Requires-Python', self.python_requires)
+
+    # PEP 566
+    if self.long_description_content_type:
+        write_field(
+            'Description-Content-Type',
+            self.long_description_content_type
+        )
+    if self.provides_extras:
+        for extra in self.provides_extras:
+            write_field('Provides-Extra', extra)
+
+
+sequence = tuple, list
+
+
+def check_importable(dist, attr, value):
+    try:
+        ep = pkg_resources.EntryPoint.parse('x=' + value)
+        assert not ep.extras
+    except (TypeError, ValueError, AttributeError, AssertionError) as e:
+        raise DistutilsSetupError(
+            "%r must be importable 'module:attrs' string (got %r)"
+            % (attr, value)
+        ) from e
+
+
+def assert_string_list(dist, attr, value):
+    """Verify that value is a string list"""
+    try:
+        # verify that value is a list or tuple to exclude unordered
+        # or single-use iterables
+        assert isinstance(value, (list, tuple))
+        # verify that elements of value are strings
+        assert ''.join(value) != value
+    except (TypeError, ValueError, AttributeError, AssertionError) as e:
+        raise DistutilsSetupError(
+            "%r must be a list of strings (got %r)" % (attr, value)
+        ) from e
+
+
+def check_nsp(dist, attr, value):
+    """Verify that namespace packages are valid"""
+    ns_packages = value
+    assert_string_list(dist, attr, ns_packages)
+    for nsp in ns_packages:
+        if not dist.has_contents_for(nsp):
+            raise DistutilsSetupError(
+                "Distribution contains no modules or packages for " +
+                "namespace package %r" % nsp
+            )
+        parent, sep, child = nsp.rpartition('.')
+        if parent and parent not in ns_packages:
+            distutils.log.warn(
+                "WARNING: %r is declared as a package namespace, but %r"
+                " is not: please correct this in setup.py", nsp, parent
+            )
+
+
+def check_extras(dist, attr, value):
+    """Verify that extras_require mapping is valid"""
+    try:
+        list(itertools.starmap(_check_extra, value.items()))
+    except (TypeError, ValueError, AttributeError) as e:
+        raise DistutilsSetupError(
+            "'extras_require' must be a dictionary whose values are "
+            "strings or lists of strings containing valid project/version "
+            "requirement specifiers."
+        ) from e
+
+
+def _check_extra(extra, reqs):
+    name, sep, marker = extra.partition(':')
+    if marker and pkg_resources.invalid_marker(marker):
+        raise DistutilsSetupError("Invalid environment marker: " + marker)
+    list(pkg_resources.parse_requirements(reqs))
+
+
+def assert_bool(dist, attr, value):
+    """Verify that value is True, False, 0, or 1"""
+    if bool(value) != value:
+        tmpl = "{attr!r} must be a boolean value (got {value!r})"
+        raise DistutilsSetupError(tmpl.format(attr=attr, value=value))
+
+
+def check_requirements(dist, attr, value):
+    """Verify that install_requires is a valid requirements list"""
+    try:
+        list(pkg_resources.parse_requirements(value))
+        if isinstance(value, (dict, set)):
+            raise TypeError("Unordered types are not allowed")
+    except (TypeError, ValueError) as error:
+        tmpl = (
+            "{attr!r} must be a string or list of strings "
+            "containing valid project/version requirement specifiers; {error}"
+        )
+        raise DistutilsSetupError(
+            tmpl.format(attr=attr, error=error)
+        ) from error
+
+
+def check_specifier(dist, attr, value):
+    """Verify that value is a valid version specifier"""
+    try:
+        packaging.specifiers.SpecifierSet(value)
+    except packaging.specifiers.InvalidSpecifier as error:
+        tmpl = (
+            "{attr!r} must be a string "
+            "containing valid version specifiers; {error}"
+        )
+        raise DistutilsSetupError(
+            tmpl.format(attr=attr, error=error)
+        ) from error
+
+
+def check_entry_points(dist, attr, value):
+    """Verify that entry_points map is parseable"""
+    try:
+        pkg_resources.EntryPoint.parse_map(value)
+    except ValueError as e:
+        raise DistutilsSetupError(e) from e
+
+
+def check_test_suite(dist, attr, value):
+    if not isinstance(value, six.string_types):
+        raise DistutilsSetupError("test_suite must be a string")
+
+
+def check_package_data(dist, attr, value):
+    """Verify that value is a dictionary of package names to glob lists"""
+    if not isinstance(value, dict):
+        raise DistutilsSetupError(
+            "{!r} must be a dictionary mapping package names to lists of "
+            "string wildcard patterns".format(attr))
+    for k, v in value.items():
+        if not isinstance(k, six.string_types):
+            raise DistutilsSetupError(
+                "keys of {!r} dict must be strings (got {!r})"
+                .format(attr, k)
+            )
+        assert_string_list(dist, 'values of {!r} dict'.format(attr), v)
+
+
+def check_packages(dist, attr, value):
+    for pkgname in value:
+        if not re.match(r'\w+(\.\w+)*', pkgname):
+            distutils.log.warn(
+                "WARNING: %r not a valid package name; please use only "
+                ".-separated package names in setup.py", pkgname
+            )
+
+
+_Distribution = get_unpatched(distutils.core.Distribution)
+
+
+class Distribution(_Distribution):
+    """Distribution with support for tests and package data
+
+    This is an enhanced version of 'distutils.dist.Distribution' that
+    effectively adds the following new optional keyword arguments to 'setup()':
+
+     'install_requires' -- a string or sequence of strings specifying project
+        versions that the distribution requires when installed, in the format
+        used by 'pkg_resources.require()'.  They will be installed
+        automatically when the package is installed.  If you wish to use
+        packages that are not available in PyPI, or want to give your users an
+        alternate download location, you can add a 'find_links' option to the
+        '[easy_install]' section of your project's 'setup.cfg' file, and then
+        setuptools will scan the listed web pages for links that satisfy the
+        requirements.
+
+     'extras_require' -- a dictionary mapping names of optional "extras" to the
+        additional requirement(s) that using those extras incurs. For example,
+        this::
+
+            extras_require = dict(reST = ["docutils>=0.3", "reSTedit"])
+
+        indicates that the distribution can optionally provide an extra
+        capability called "reST", but it can only be used if docutils and
+        reSTedit are installed.  If the user installs your package using
+        EasyInstall and requests one of your extras, the corresponding
+        additional requirements will be installed if needed.
+
+     'test_suite' -- the name of a test suite to run for the 'test' command.
+        If the user runs 'python setup.py test', the package will be installed,
+        and the named test suite will be run.  The format is the same as
+        would be used on a 'unittest.py' command line.  That is, it is the
+        dotted name of an object to import and call to generate a test suite.
+
+     'package_data' -- a dictionary mapping package names to lists of filenames
+        or globs to use to find data files contained in the named packages.
+        If the dictionary has filenames or globs listed under '""' (the empty
+        string), those names will be searched for in every package, in addition
+        to any names for the specific package.  Data files found using these
+        names/globs will be installed along with the package, in the same
+        location as the package.  Note that globs are allowed to reference
+        the contents of non-package subdirectories, as long as you use '/' as
+        a path separator.  (Globs are automatically converted to
+        platform-specific paths at runtime.)
+
+    In addition to these new keywords, this class also has several new methods
+    for manipulating the distribution's contents.  For example, the 'include()'
+    and 'exclude()' methods can be thought of as in-place add and subtract
+    commands that add or remove packages, modules, extensions, and so on from
+    the distribution.
+    """
+
+    _DISTUTILS_UNSUPPORTED_METADATA = {
+        'long_description_content_type': None,
+        'project_urls': dict,
+        'provides_extras': ordered_set.OrderedSet,
+        'license_files': ordered_set.OrderedSet,
+    }
+
+    _patched_dist = None
+
+    def patch_missing_pkg_info(self, attrs):
+        # Fake up a replacement for the data that would normally come from
+        # PKG-INFO, but which might not yet be built if this is a fresh
+        # checkout.
+        #
+        if not attrs or 'name' not in attrs or 'version' not in attrs:
+            return
+        key = pkg_resources.safe_name(str(attrs['name'])).lower()
+        dist = pkg_resources.working_set.by_key.get(key)
+        if dist is not None and not dist.has_metadata('PKG-INFO'):
+            dist._version = pkg_resources.safe_version(str(attrs['version']))
+            self._patched_dist = dist
+
+    def __init__(self, attrs=None):
+        have_package_data = hasattr(self, "package_data")
+        if not have_package_data:
+            self.package_data = {}
+        attrs = attrs or {}
+        self.dist_files = []
+        # Filter-out setuptools' specific options.
+        self.src_root = attrs.pop("src_root", None)
+        self.patch_missing_pkg_info(attrs)
+        self.dependency_links = attrs.pop('dependency_links', [])
+        self.setup_requires = attrs.pop('setup_requires', [])
+        for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
+            vars(self).setdefault(ep.name, None)
+        _Distribution.__init__(self, {
+            k: v for k, v in attrs.items()
+            if k not in self._DISTUTILS_UNSUPPORTED_METADATA
+        })
+
+        # Fill-in missing metadata fields not supported by distutils.
+        # Note some fields may have been set by other tools (e.g. pbr)
+        # above; they are taken preferrentially to setup() arguments
+        for option, default in self._DISTUTILS_UNSUPPORTED_METADATA.items():
+            for source in self.metadata.__dict__, attrs:
+                if option in source:
+                    value = source[option]
+                    break
+            else:
+                value = default() if default else None
+            setattr(self.metadata, option, value)
+
+        self.metadata.version = self._normalize_version(
+            self._validate_version(self.metadata.version))
+        self._finalize_requires()
+
+    @staticmethod
+    def _normalize_version(version):
+        if isinstance(version, setuptools.sic) or version is None:
+            return version
+
+        normalized = str(packaging.version.Version(version))
+        if version != normalized:
+            tmpl = "Normalizing '{version}' to '{normalized}'"
+            warnings.warn(tmpl.format(**locals()))
+            return normalized
+        return version
+
+    @staticmethod
+    def _validate_version(version):
+        if isinstance(version, numbers.Number):
+            # Some people apparently take "version number" too literally :)
+            version = str(version)
+
+        if version is not None:
+            try:
+                packaging.version.Version(version)
+            except (packaging.version.InvalidVersion, TypeError):
+                warnings.warn(
+                    "The version specified (%r) is an invalid version, this "
+                    "may not work as expected with newer versions of "
+                    "setuptools, pip, and PyPI. Please see PEP 440 for more "
+                    "details." % version
+                )
+                return setuptools.sic(version)
+        return version
+
+    def _finalize_requires(self):
+        """
+        Set `metadata.python_requires` and fix environment markers
+        in `install_requires` and `extras_require`.
+        """
+        if getattr(self, 'python_requires', None):
+            self.metadata.python_requires = self.python_requires
+
+        if getattr(self, 'extras_require', None):
+            for extra in self.extras_require.keys():
+                # Since this gets called multiple times at points where the
+                # keys have become 'converted' extras, ensure that we are only
+                # truly adding extras we haven't seen before here.
+                extra = extra.split(':')[0]
+                if extra:
+                    self.metadata.provides_extras.add(extra)
+
+        self._convert_extras_requirements()
+        self._move_install_requirements_markers()
+
+    def _convert_extras_requirements(self):
+        """
+        Convert requirements in `extras_require` of the form
+        `"extra": ["barbazquux; {marker}"]` to
+        `"extra:{marker}": ["barbazquux"]`.
+        """
+        spec_ext_reqs = getattr(self, 'extras_require', None) or {}
+        self._tmp_extras_require = defaultdict(list)
+        for section, v in spec_ext_reqs.items():
+            # Do not strip empty sections.
+            self._tmp_extras_require[section]
+            for r in pkg_resources.parse_requirements(v):
+                suffix = self._suffix_for(r)
+                self._tmp_extras_require[section + suffix].append(r)
+
+    @staticmethod
+    def _suffix_for(req):
+        """
+        For a requirement, return the 'extras_require' suffix for
+        that requirement.
+        """
+        return ':' + str(req.marker) if req.marker else ''
+
+    def _move_install_requirements_markers(self):
+        """
+        Move requirements in `install_requires` that are using environment
+        markers `extras_require`.
+        """
+
+        # divide the install_requires into two sets, simple ones still
+        # handled by install_requires and more complex ones handled
+        # by extras_require.
+
+        def is_simple_req(req):
+            return not req.marker
+
+        spec_inst_reqs = getattr(self, 'install_requires', None) or ()
+        inst_reqs = list(pkg_resources.parse_requirements(spec_inst_reqs))
+        simple_reqs = filter(is_simple_req, inst_reqs)
+        complex_reqs = filterfalse(is_simple_req, inst_reqs)
+        self.install_requires = list(map(str, simple_reqs))
+
+        for r in complex_reqs:
+            self._tmp_extras_require[':' + str(r.marker)].append(r)
+        self.extras_require = dict(
+            (k, [str(r) for r in map(self._clean_req, v)])
+            for k, v in self._tmp_extras_require.items()
+        )
+
+    def _clean_req(self, req):
+        """
+        Given a Requirement, remove environment markers and return it.
+        """
+        req.marker = None
+        return req
+
+    def _parse_config_files(self, filenames=None):
+        """
+        Adapted from distutils.dist.Distribution.parse_config_files,
+        this method provides the same functionality in subtly-improved
+        ways.
+        """
+        from setuptools.extern.six.moves.configparser import ConfigParser
+
+        # Ignore install directory options if we have a venv
+        if not six.PY2 and sys.prefix != sys.base_prefix:
+            ignore_options = [
+                'install-base', 'install-platbase', 'install-lib',
+                'install-platlib', 'install-purelib', 'install-headers',
+                'install-scripts', 'install-data', 'prefix', 'exec-prefix',
+                'home', 'user', 'root']
+        else:
+            ignore_options = []
+
+        ignore_options = frozenset(ignore_options)
+
+        if filenames is None:
+            filenames = self.find_config_files()
+
+        if DEBUG:
+            self.announce("Distribution.parse_config_files():")
+
+        parser = ConfigParser()
+        for filename in filenames:
+            with io.open(filename, encoding='utf-8') as reader:
+                if DEBUG:
+                    self.announce("  reading {filename}".format(**locals()))
+                (parser.readfp if six.PY2 else parser.read_file)(reader)
+            for section in parser.sections():
+                options = parser.options(section)
+                opt_dict = self.get_option_dict(section)
+
+                for opt in options:
+                    if opt != '__name__' and opt not in ignore_options:
+                        val = self._try_str(parser.get(section, opt))
+                        opt = opt.replace('-', '_')
+                        opt_dict[opt] = (filename, val)
+
+            # Make the ConfigParser forget everything (so we retain
+            # the original filenames that options come from)
+            parser.__init__()
+
+        # If there was a "global" section in the config file, use it
+        # to set Distribution options.
+
+        if 'global' in self.command_options:
+            for (opt, (src, val)) in self.command_options['global'].items():
+                alias = self.negative_opt.get(opt)
+                try:
+                    if alias:
+                        setattr(self, alias, not strtobool(val))
+                    elif opt in ('verbose', 'dry_run'):  # ugh!
+                        setattr(self, opt, strtobool(val))
+                    else:
+                        setattr(self, opt, val)
+                except ValueError as e:
+                    raise DistutilsOptionError(e) from e
+
+    @staticmethod
+    def _try_str(val):
+        """
+        On Python 2, much of distutils relies on string values being of
+        type 'str' (bytes) and not unicode text. If the value can be safely
+        encoded to bytes using the default encoding, prefer that.
+
+        Why the default encoding? Because that value can be implicitly
+        decoded back to text if needed.
+
+        Ref #1653
+        """
+        if not six.PY2:
+            return val
+        try:
+            return val.encode()
+        except UnicodeEncodeError:
+            pass
+        return val
+
+    def _set_command_options(self, command_obj, option_dict=None):
+        """
+        Set the options for 'command_obj' from 'option_dict'.  Basically
+        this means copying elements of a dictionary ('option_dict') to
+        attributes of an instance ('command').
+
+        'command_obj' must be a Command instance.  If 'option_dict' is not
+        supplied, uses the standard option dictionary for this command
+        (from 'self.command_options').
+
+        (Adopted from distutils.dist.Distribution._set_command_options)
+        """
+        command_name = command_obj.get_command_name()
+        if option_dict is None:
+            option_dict = self.get_option_dict(command_name)
+
+        if DEBUG:
+            self.announce("  setting options for '%s' command:" % command_name)
+        for (option, (source, value)) in option_dict.items():
+            if DEBUG:
+                self.announce("    %s = %s (from %s)" % (option, value,
+                                                         source))
+            try:
+                bool_opts = [translate_longopt(o)
+                             for o in command_obj.boolean_options]
+            except AttributeError:
+                bool_opts = []
+            try:
+                neg_opt = command_obj.negative_opt
+            except AttributeError:
+                neg_opt = {}
+
+            try:
+                is_string = isinstance(value, six.string_types)
+                if option in neg_opt and is_string:
+                    setattr(command_obj, neg_opt[option], not strtobool(value))
+                elif option in bool_opts and is_string:
+                    setattr(command_obj, option, strtobool(value))
+                elif hasattr(command_obj, option):
+                    setattr(command_obj, option, value)
+                else:
+                    raise DistutilsOptionError(
+                        "error in %s: command '%s' has no such option '%s'"
+                        % (source, command_name, option))
+            except ValueError as e:
+                raise DistutilsOptionError(e) from e
+
+    def parse_config_files(self, filenames=None, ignore_option_errors=False):
+        """Parses configuration files from various levels
+        and loads configuration.
+
+        """
+        self._parse_config_files(filenames=filenames)
+
+        parse_configuration(self, self.command_options,
+                            ignore_option_errors=ignore_option_errors)
+        self._finalize_requires()
+
+    def fetch_build_eggs(self, requires):
+        """Resolve pre-setup requirements"""
+        resolved_dists = pkg_resources.working_set.resolve(
+            pkg_resources.parse_requirements(requires),
+            installer=self.fetch_build_egg,
+            replace_conflicting=True,
+        )
+        for dist in resolved_dists:
+            pkg_resources.working_set.add(dist, replace=True)
+        return resolved_dists
+
+    def finalize_options(self):
+        """
+        Allow plugins to apply arbitrary operations to the
+        distribution. Each hook may optionally define a 'order'
+        to influence the order of execution. Smaller numbers
+        go first and the default is 0.
+        """
+        group = 'setuptools.finalize_distribution_options'
+
+        def by_order(hook):
+            return getattr(hook, 'order', 0)
+        eps = map(lambda e: e.load(), pkg_resources.iter_entry_points(group))
+        for ep in sorted(eps, key=by_order):
+            ep(self)
+
+    def _finalize_setup_keywords(self):
+        for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
+            value = getattr(self, ep.name, None)
+            if value is not None:
+                ep.require(installer=self.fetch_build_egg)
+                ep.load()(self, ep.name, value)
+
+    def _finalize_2to3_doctests(self):
+        if getattr(self, 'convert_2to3_doctests', None):
+            # XXX may convert to set here when we can rely on set being builtin
+            self.convert_2to3_doctests = [
+                os.path.abspath(p)
+                for p in self.convert_2to3_doctests
+            ]
+        else:
+            self.convert_2to3_doctests = []
+
+    def get_egg_cache_dir(self):
+        egg_cache_dir = os.path.join(os.curdir, '.eggs')
+        if not os.path.exists(egg_cache_dir):
+            os.mkdir(egg_cache_dir)
+            windows_support.hide_file(egg_cache_dir)
+            readme_txt_filename = os.path.join(egg_cache_dir, 'README.txt')
+            with open(readme_txt_filename, 'w') as f:
+                f.write('This directory contains eggs that were downloaded '
+                        'by setuptools to build, test, and run plug-ins.\n\n')
+                f.write('This directory caches those eggs to prevent '
+                        'repeated downloads.\n\n')
+                f.write('However, it is safe to delete this directory.\n\n')
+
+        return egg_cache_dir
+
+    def fetch_build_egg(self, req):
+        """Fetch an egg needed for building"""
+        from setuptools.installer import fetch_build_egg
+        return fetch_build_egg(self, req)
+
+    def get_command_class(self, command):
+        """Pluggable version of get_command_class()"""
+        if command in self.cmdclass:
+            return self.cmdclass[command]
+
+        eps = pkg_resources.iter_entry_points('distutils.commands', command)
+        for ep in eps:
+            ep.require(installer=self.fetch_build_egg)
+            self.cmdclass[command] = cmdclass = ep.load()
+            return cmdclass
+        else:
+            return _Distribution.get_command_class(self, command)
+
+    def print_commands(self):
+        for ep in pkg_resources.iter_entry_points('distutils.commands'):
+            if ep.name not in self.cmdclass:
+                # don't require extras as the commands won't be invoked
+                cmdclass = ep.resolve()
+                self.cmdclass[ep.name] = cmdclass
+        return _Distribution.print_commands(self)
+
+    def get_command_list(self):
+        for ep in pkg_resources.iter_entry_points('distutils.commands'):
+            if ep.name not in self.cmdclass:
+                # don't require extras as the commands won't be invoked
+                cmdclass = ep.resolve()
+                self.cmdclass[ep.name] = cmdclass
+        return _Distribution.get_command_list(self)
+
+    def include(self, **attrs):
+        """Add items to distribution that are named in keyword arguments
+
+        For example, 'dist.include(py_modules=["x"])' would add 'x' to
+        the distribution's 'py_modules' attribute, if it was not already
+        there.
+
+        Currently, this method only supports inclusion for attributes that are
+        lists or tuples.  If you need to add support for adding to other
+        attributes in this or a subclass, you can add an '_include_X' method,
+        where 'X' is the name of the attribute.  The method will be called with
+        the value passed to 'include()'.  So, 'dist.include(foo={"bar":"baz"})'
+        will try to call 'dist._include_foo({"bar":"baz"})', which can then
+        handle whatever special inclusion logic is needed.
+        """
+        for k, v in attrs.items():
+            include = getattr(self, '_include_' + k, None)
+            if include:
+                include(v)
+            else:
+                self._include_misc(k, v)
+
+    def exclude_package(self, package):
+        """Remove packages, modules, and extensions in named package"""
+
+        pfx = package + '.'
+        if self.packages:
+            self.packages = [
+                p for p in self.packages
+                if p != package and not p.startswith(pfx)
+            ]
+
+        if self.py_modules:
+            self.py_modules = [
+                p for p in self.py_modules
+                if p != package and not p.startswith(pfx)
+            ]
+
+        if self.ext_modules:
+            self.ext_modules = [
+                p for p in self.ext_modules
+                if p.name != package and not p.name.startswith(pfx)
+            ]
+
+    def has_contents_for(self, package):
+        """Return true if 'exclude_package(package)' would do something"""
+
+        pfx = package + '.'
+
+        for p in self.iter_distribution_names():
+            if p == package or p.startswith(pfx):
+                return True
+
+    def _exclude_misc(self, name, value):
+        """Handle 'exclude()' for list/tuple attrs without a special handler"""
+        if not isinstance(value, sequence):
+            raise DistutilsSetupError(
+                "%s: setting must be a list or tuple (%r)" % (name, value)
+            )
+        try:
+            old = getattr(self, name)
+        except AttributeError as e:
+            raise DistutilsSetupError(
+                "%s: No such distribution setting" % name
+            ) from e
+        if old is not None and not isinstance(old, sequence):
+            raise DistutilsSetupError(
+                name + ": this setting cannot be changed via include/exclude"
+            )
+        elif old:
+            setattr(self, name, [item for item in old if item not in value])
+
+    def _include_misc(self, name, value):
+        """Handle 'include()' for list/tuple attrs without a special handler"""
+
+        if not isinstance(value, sequence):
+            raise DistutilsSetupError(
+                "%s: setting must be a list (%r)" % (name, value)
+            )
+        try:
+            old = getattr(self, name)
+        except AttributeError as e:
+            raise DistutilsSetupError(
+                "%s: No such distribution setting" % name
+            ) from e
+        if old is None:
+            setattr(self, name, value)
+        elif not isinstance(old, sequence):
+            raise DistutilsSetupError(
+                name + ": this setting cannot be changed via include/exclude"
+            )
+        else:
+            new = [item for item in value if item not in old]
+            setattr(self, name, old + new)
+
+    def exclude(self, **attrs):
+        """Remove items from distribution that are named in keyword arguments
+
+        For example, 'dist.exclude(py_modules=["x"])' would remove 'x' from
+        the distribution's 'py_modules' attribute.  Excluding packages uses
+        the 'exclude_package()' method, so all of the package's contained
+        packages, modules, and extensions are also excluded.
+
+        Currently, this method only supports exclusion from attributes that are
+        lists or tuples.  If you need to add support for excluding from other
+        attributes in this or a subclass, you can add an '_exclude_X' method,
+        where 'X' is the name of the attribute.  The method will be called with
+        the value passed to 'exclude()'.  So, 'dist.exclude(foo={"bar":"baz"})'
+        will try to call 'dist._exclude_foo({"bar":"baz"})', which can then
+        handle whatever special exclusion logic is needed.
+        """
+        for k, v in attrs.items():
+            exclude = getattr(self, '_exclude_' + k, None)
+            if exclude:
+                exclude(v)
+            else:
+                self._exclude_misc(k, v)
+
+    def _exclude_packages(self, packages):
+        if not isinstance(packages, sequence):
+            raise DistutilsSetupError(
+                "packages: setting must be a list or tuple (%r)" % (packages,)
+            )
+        list(map(self.exclude_package, packages))
+
+    def _parse_command_opts(self, parser, args):
+        # Remove --with-X/--without-X options when processing command args
+        self.global_options = self.__class__.global_options
+        self.negative_opt = self.__class__.negative_opt
+
+        # First, expand any aliases
+        command = args[0]
+        aliases = self.get_option_dict('aliases')
+        while command in aliases:
+            src, alias = aliases[command]
+            del aliases[command]  # ensure each alias can expand only once!
+            import shlex
+            args[:1] = shlex.split(alias, True)
+            command = args[0]
+
+        nargs = _Distribution._parse_command_opts(self, parser, args)
+
+        # Handle commands that want to consume all remaining arguments
+        cmd_class = self.get_command_class(command)
+        if getattr(cmd_class, 'command_consumes_arguments', None):
+            self.get_option_dict(command)['args'] = ("command line", nargs)
+            if nargs is not None:
+                return []
+
+        return nargs
+
+    def get_cmdline_options(self):
+        """Return a '{cmd: {opt:val}}' map of all command-line options
+
+        Option names are all long, but do not include the leading '--', and
+        contain dashes rather than underscores.  If the option doesn't take
+        an argument (e.g. '--quiet'), the 'val' is 'None'.
+
+        Note that options provided by config files are intentionally excluded.
+        """
+
+        d = {}
+
+        for cmd, opts in self.command_options.items():
+
+            for opt, (src, val) in opts.items():
+
+                if src != "command line":
+                    continue
+
+                opt = opt.replace('_', '-')
+
+                if val == 0:
+                    cmdobj = self.get_command_obj(cmd)
+                    neg_opt = self.negative_opt.copy()
+                    neg_opt.update(getattr(cmdobj, 'negative_opt', {}))
+                    for neg, pos in neg_opt.items():
+                        if pos == opt:
+                            opt = neg
+                            val = None
+                            break
+                    else:
+                        raise AssertionError("Shouldn't be able to get here")
+
+                elif val == 1:
+                    val = None
+
+                d.setdefault(cmd, {})[opt] = val
+
+        return d
+
+    def iter_distribution_names(self):
+        """Yield all packages, modules, and extension names in distribution"""
+
+        for pkg in self.packages or ():
+            yield pkg
+
+        for module in self.py_modules or ():
+            yield module
+
+        for ext in self.ext_modules or ():
+            if isinstance(ext, tuple):
+                name, buildinfo = ext
+            else:
+                name = ext.name
+            if name.endswith('module'):
+                name = name[:-6]
+            yield name
+
+    def handle_display_options(self, option_order):
+        """If there were any non-global "display-only" options
+        (--help-commands or the metadata display options) on the command
+        line, display the requested info and return true; else return
+        false.
+        """
+        import sys
+
+        if six.PY2 or self.help_commands:
+            return _Distribution.handle_display_options(self, option_order)
+
+        # Stdout may be StringIO (e.g. in tests)
+        if not isinstance(sys.stdout, io.TextIOWrapper):
+            return _Distribution.handle_display_options(self, option_order)
+
+        # Don't wrap stdout if utf-8 is already the encoding. Provides
+        #  workaround for #334.
+        if sys.stdout.encoding.lower() in ('utf-8', 'utf8'):
+            return _Distribution.handle_display_options(self, option_order)
+
+        # Print metadata in UTF-8 no matter the platform
+        encoding = sys.stdout.encoding
+        errors = sys.stdout.errors
+        newline = sys.platform != 'win32' and '\n' or None
+        line_buffering = sys.stdout.line_buffering
+
+        sys.stdout = io.TextIOWrapper(
+            sys.stdout.detach(), 'utf-8', errors, newline, line_buffering)
+        try:
+            return _Distribution.handle_display_options(self, option_order)
+        finally:
+            sys.stdout = io.TextIOWrapper(
+                sys.stdout.detach(), encoding, errors, newline, line_buffering)
+
+
+class DistDeprecationWarning(SetuptoolsDeprecationWarning):
+    """Class for warning about deprecations in dist in
+    setuptools. Not ignored by default, unlike DeprecationWarning."""
diff --git a/myenv/lib/python3.9/site-packages/setuptools/distutils_patch.py b/myenv/lib/python3.9/site-packages/setuptools/distutils_patch.py
new file mode 100644
index 0000000..33f1e7f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/distutils_patch.py
@@ -0,0 +1,61 @@
+"""
+Ensure that the local copy of distutils is preferred over stdlib.
+
+See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+for more motivation.
+"""
+
+import sys
+import re
+import os
+import importlib
+import warnings
+
+
+is_pypy = '__pypy__' in sys.builtin_module_names
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    if is_pypy and sys.version_info < (3, 7):
+        # PyPy for 3.6 unconditionally imports distutils, so bypass the warning
+        # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250
+        return
+    warnings.warn(
+        "Distutils was imported before Setuptools. This usage is discouraged "
+        "and may exhibit undesirable behaviors or errors. Please use "
+        "Setuptools' objects directly or at least import Setuptools first.")
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    warnings.warn("Setuptools is replacing distutils.")
+    mods = [name for name in sys.modules if re.match(r'distutils\b', name)]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'stdlib')
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    clear_distutils()
+    distutils = importlib.import_module('setuptools._distutils')
+    distutils.__name__ = 'distutils'
+    sys.modules['distutils'] = distutils
+
+    # sanity check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+
+
+warn_distutils_present()
+if enabled():
+    ensure_local_distutils()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/errors.py b/myenv/lib/python3.9/site-packages/setuptools/errors.py
new file mode 100644
index 0000000..2701747
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/errors.py
@@ -0,0 +1,16 @@
+"""setuptools.errors
+
+Provides exceptions used by setuptools modules.
+"""
+
+from distutils.errors import DistutilsError
+
+
+class RemovedCommandError(DistutilsError, RuntimeError):
+    """Error used for commands that have been removed in setuptools.
+
+    Since ``setuptools`` is built on ``distutils``, simply removing a command
+    from ``setuptools`` will make the behavior fall back to ``distutils``; this
+    error is raised if a command exists in ``distutils`` but has been actively
+    removed in ``setuptools``.
+    """
diff --git a/myenv/lib/python3.9/site-packages/setuptools/extension.py b/myenv/lib/python3.9/site-packages/setuptools/extension.py
new file mode 100644
index 0000000..2946889
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/extension.py
@@ -0,0 +1,57 @@
+import re
+import functools
+import distutils.core
+import distutils.errors
+import distutils.extension
+
+from setuptools.extern.six.moves import map
+
+from .monkey import get_unpatched
+
+
+def _have_cython():
+    """
+    Return True if Cython can be imported.
+    """
+    cython_impl = 'Cython.Distutils.build_ext'
+    try:
+        # from (cython_impl) import build_ext
+        __import__(cython_impl, fromlist=['build_ext']).build_ext
+        return True
+    except Exception:
+        pass
+    return False
+
+
+# for compatibility
+have_pyrex = _have_cython
+
+_Extension = get_unpatched(distutils.core.Extension)
+
+
+class Extension(_Extension):
+    """Extension that uses '.c' files in place of '.pyx' files"""
+
+    def __init__(self, name, sources, *args, **kw):
+        # The *args is needed for compatibility as calls may use positional
+        # arguments. py_limited_api may be set only via keyword.
+        self.py_limited_api = kw.pop("py_limited_api", False)
+        _Extension.__init__(self, name, sources, *args, **kw)
+
+    def _convert_pyx_sources_to_lang(self):
+        """
+        Replace sources with .pyx extensions to sources with the target
+        language extension. This mechanism allows language authors to supply
+        pre-converted sources but to prefer the .pyx sources.
+        """
+        if _have_cython():
+            # the build has Cython, so allow it to compile the .pyx files
+            return
+        lang = self.language or ''
+        target_ext = '.cpp' if lang.lower() == 'c++' else '.c'
+        sub = functools.partial(re.sub, '.pyx$', target_ext)
+        self.sources = list(map(sub, self.sources))
+
+
+class Library(Extension):
+    """Just like a regular Extension, but built as a library instead"""
diff --git a/myenv/lib/python3.9/site-packages/setuptools/extern/__init__.py b/myenv/lib/python3.9/site-packages/setuptools/extern/__init__.py
new file mode 100644
index 0000000..4e79aa1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/extern/__init__.py
@@ -0,0 +1,66 @@
+import sys
+
+
+class VendorImporter:
+    """
+    A PEP 302 meta path importer for finding optionally-vendored
+    or otherwise naturally-installed packages from root_name.
+    """
+
+    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
+        self.root_name = root_name
+        self.vendored_names = set(vendored_names)
+        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')
+
+    @property
+    def search_path(self):
+        """
+        Search first the vendor package then as a natural package.
+        """
+        yield self.vendor_pkg + '.'
+        yield ''
+
+    def find_module(self, fullname, path=None):
+        """
+        Return self when fullname starts with root_name and the
+        target module is one vendored through this importer.
+        """
+        root, base, target = fullname.partition(self.root_name + '.')
+        if root:
+            return
+        if not any(map(target.startswith, self.vendored_names)):
+            return
+        return self
+
+    def load_module(self, fullname):
+        """
+        Iterate over the search path to locate and load fullname.
+        """
+        root, base, target = fullname.partition(self.root_name + '.')
+        for prefix in self.search_path:
+            try:
+                extant = prefix + target
+                __import__(extant)
+                mod = sys.modules[extant]
+                sys.modules[fullname] = mod
+                return mod
+            except ImportError:
+                pass
+        else:
+            raise ImportError(
+                "The '{target}' package is required; "
+                "normally this is bundled with this package so if you get "
+                "this warning, consult the packager of your "
+                "distribution.".format(**locals())
+            )
+
+    def install(self):
+        """
+        Install this importer into sys.meta_path if not already present.
+        """
+        if self not in sys.meta_path:
+            sys.meta_path.append(self)
+
+
+names = 'six', 'packaging', 'pyparsing', 'ordered_set',
+VendorImporter(__name__, names, 'setuptools._vendor').install()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/glob.py b/myenv/lib/python3.9/site-packages/setuptools/glob.py
new file mode 100644
index 0000000..9d7cbc5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/glob.py
@@ -0,0 +1,174 @@
+"""
+Filename globbing utility. Mostly a copy of `glob` from Python 3.5.
+
+Changes include:
+ * `yield from` and PEP3102 `*` removed.
+ * Hidden files are not ignored.
+"""
+
+import os
+import re
+import fnmatch
+
+__all__ = ["glob", "iglob", "escape"]
+
+
+def glob(pathname, recursive=False):
+    """Return a list of paths matching a pathname pattern.
+
+    The pattern may contain simple shell-style wildcards a la
+    fnmatch. However, unlike fnmatch, filenames starting with a
+    dot are special cases that are not matched by '*' and '?'
+    patterns.
+
+    If recursive is true, the pattern '**' will match any files and
+    zero or more directories and subdirectories.
+    """
+    return list(iglob(pathname, recursive=recursive))
+
+
+def iglob(pathname, recursive=False):
+    """Return an iterator which yields the paths matching a pathname pattern.
+
+    The pattern may contain simple shell-style wildcards a la
+    fnmatch. However, unlike fnmatch, filenames starting with a
+    dot are special cases that are not matched by '*' and '?'
+    patterns.
+
+    If recursive is true, the pattern '**' will match any files and
+    zero or more directories and subdirectories.
+    """
+    it = _iglob(pathname, recursive)
+    if recursive and _isrecursive(pathname):
+        s = next(it)  # skip empty string
+        assert not s
+    return it
+
+
+def _iglob(pathname, recursive):
+    dirname, basename = os.path.split(pathname)
+    if not has_magic(pathname):
+        if basename:
+            if os.path.lexists(pathname):
+                yield pathname
+        else:
+            # Patterns ending with a slash should match only directories
+            if os.path.isdir(dirname):
+                yield pathname
+        return
+    if not dirname:
+        if recursive and _isrecursive(basename):
+            for x in glob2(dirname, basename):
+                yield x
+        else:
+            for x in glob1(dirname, basename):
+                yield x
+        return
+    # `os.path.split()` returns the argument itself as a dirname if it is a
+    # drive or UNC path.  Prevent an infinite recursion if a drive or UNC path
+    # contains magic characters (i.e. r'\\?\C:').
+    if dirname != pathname and has_magic(dirname):
+        dirs = _iglob(dirname, recursive)
+    else:
+        dirs = [dirname]
+    if has_magic(basename):
+        if recursive and _isrecursive(basename):
+            glob_in_dir = glob2
+        else:
+            glob_in_dir = glob1
+    else:
+        glob_in_dir = glob0
+    for dirname in dirs:
+        for name in glob_in_dir(dirname, basename):
+            yield os.path.join(dirname, name)
+
+
+# These 2 helper functions non-recursively glob inside a literal directory.
+# They return a list of basenames. `glob1` accepts a pattern while `glob0`
+# takes a literal basename (so it only has to check for its existence).
+
+
+def glob1(dirname, pattern):
+    if not dirname:
+        if isinstance(pattern, bytes):
+            dirname = os.curdir.encode('ASCII')
+        else:
+            dirname = os.curdir
+    try:
+        names = os.listdir(dirname)
+    except OSError:
+        return []
+    return fnmatch.filter(names, pattern)
+
+
+def glob0(dirname, basename):
+    if not basename:
+        # `os.path.split()` returns an empty basename for paths ending with a
+        # directory separator.  'q*x/' should match only directories.
+        if os.path.isdir(dirname):
+            return [basename]
+    else:
+        if os.path.lexists(os.path.join(dirname, basename)):
+            return [basename]
+    return []
+
+
+# This helper function recursively yields relative pathnames inside a literal
+# directory.
+
+
+def glob2(dirname, pattern):
+    assert _isrecursive(pattern)
+    yield pattern[:0]
+    for x in _rlistdir(dirname):
+        yield x
+
+
+# Recursively yields relative pathnames inside a literal directory.
+def _rlistdir(dirname):
+    if not dirname:
+        if isinstance(dirname, bytes):
+            dirname = os.curdir.encode('ASCII')
+        else:
+            dirname = os.curdir
+    try:
+        names = os.listdir(dirname)
+    except os.error:
+        return
+    for x in names:
+        yield x
+        path = os.path.join(dirname, x) if dirname else x
+        for y in _rlistdir(path):
+            yield os.path.join(x, y)
+
+
+magic_check = re.compile('([*?[])')
+magic_check_bytes = re.compile(b'([*?[])')
+
+
+def has_magic(s):
+    if isinstance(s, bytes):
+        match = magic_check_bytes.search(s)
+    else:
+        match = magic_check.search(s)
+    return match is not None
+
+
+def _isrecursive(pattern):
+    if isinstance(pattern, bytes):
+        return pattern == b'**'
+    else:
+        return pattern == '**'
+
+
+def escape(pathname):
+    """Escape all special characters.
+    """
+    # Escaping is done by wrapping any of "*?[" between square brackets.
+    # Metacharacters do not work in the drive part and shouldn't be escaped.
+    drive, pathname = os.path.splitdrive(pathname)
+    if isinstance(pathname, bytes):
+        pathname = magic_check_bytes.sub(br'[\1]', pathname)
+    else:
+        pathname = magic_check.sub(r'[\1]', pathname)
+    return drive + pathname
diff --git a/myenv/lib/python3.9/site-packages/setuptools/gui-32.exe b/myenv/lib/python3.9/site-packages/setuptools/gui-32.exe
new file mode 100644
index 0000000..f8d3509
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/setuptools/gui-32.exe differ
diff --git a/myenv/lib/python3.9/site-packages/setuptools/gui-64.exe b/myenv/lib/python3.9/site-packages/setuptools/gui-64.exe
new file mode 100644
index 0000000..330c51a
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/setuptools/gui-64.exe differ
diff --git a/myenv/lib/python3.9/site-packages/setuptools/gui.exe b/myenv/lib/python3.9/site-packages/setuptools/gui.exe
new file mode 100644
index 0000000..f8d3509
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/setuptools/gui.exe differ
diff --git a/myenv/lib/python3.9/site-packages/setuptools/installer.py b/myenv/lib/python3.9/site-packages/setuptools/installer.py
new file mode 100644
index 0000000..e5acec2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/installer.py
@@ -0,0 +1,150 @@
+import glob
+import os
+import subprocess
+import sys
+from distutils import log
+from distutils.errors import DistutilsError
+
+import pkg_resources
+from setuptools.command.easy_install import easy_install
+from setuptools.extern import six
+from setuptools.wheel import Wheel
+
+from .py31compat import TemporaryDirectory
+
+
+def _fixup_find_links(find_links):
+    """Ensure find-links option end-up being a list of strings."""
+    if isinstance(find_links, six.string_types):
+        return find_links.split()
+    assert isinstance(find_links, (tuple, list))
+    return find_links
+
+
+def _legacy_fetch_build_egg(dist, req):
+    """Fetch an egg needed for building.
+
+    Legacy path using EasyInstall.
+    """
+    tmp_dist = dist.__class__({'script_args': ['easy_install']})
+    opts = tmp_dist.get_option_dict('easy_install')
+    opts.clear()
+    opts.update(
+        (k, v)
+        for k, v in dist.get_option_dict('easy_install').items()
+        if k in (
+            # don't use any other settings
+            'find_links', 'site_dirs', 'index_url',
+            'optimize', 'site_dirs', 'allow_hosts',
+        ))
+    if dist.dependency_links:
+        links = dist.dependency_links[:]
+        if 'find_links' in opts:
+            links = _fixup_find_links(opts['find_links'][1]) + links
+        opts['find_links'] = ('setup', links)
+    install_dir = dist.get_egg_cache_dir()
+    cmd = easy_install(
+        tmp_dist, args=["x"], install_dir=install_dir,
+        exclude_scripts=True,
+        always_copy=False, build_directory=None, editable=False,
+        upgrade=False, multi_version=True, no_report=True, user=False
+    )
+    cmd.ensure_finalized()
+    return cmd.easy_install(req)
+
+
+def fetch_build_egg(dist, req):
+    """Fetch an egg needed for building.
+
+    Use pip/wheel to fetch/build a wheel."""
+    # Check pip is available.
+    try:
+        pkg_resources.get_distribution('pip')
+    except pkg_resources.DistributionNotFound:
+        dist.announce(
+            'WARNING: The pip package is not available, falling back '
+            'to EasyInstall for handling setup_requires/test_requires; '
+            'this is deprecated and will be removed in a future version.',
+            log.WARN
+        )
+        return _legacy_fetch_build_egg(dist, req)
+    # Warn if wheel is not.
+    try:
+        pkg_resources.get_distribution('wheel')
+    except pkg_resources.DistributionNotFound:
+        dist.announce('WARNING: The wheel package is not available.', log.WARN)
+    # Ignore environment markers; if supplied, it is required.
+    req = strip_marker(req)
+    # Take easy_install options into account, but do not override relevant
+    # pip environment variables (like PIP_INDEX_URL or PIP_QUIET); they'll
+    # take precedence.
+    opts = dist.get_option_dict('easy_install')
+    if 'allow_hosts' in opts:
+        raise DistutilsError('the `allow-hosts` option is not supported '
+                             'when using pip to install requirements.')
+    if 'PIP_QUIET' in os.environ or 'PIP_VERBOSE' in os.environ:
+        quiet = False
+    else:
+        quiet = True
+    if 'PIP_INDEX_URL' in os.environ:
+        index_url = None
+    elif 'index_url' in opts:
+        index_url = opts['index_url'][1]
+    else:
+        index_url = None
+    if 'find_links' in opts:
+        find_links = _fixup_find_links(opts['find_links'][1])[:]
+    else:
+        find_links = []
+    if dist.dependency_links:
+        find_links.extend(dist.dependency_links)
+    eggs_dir = os.path.realpath(dist.get_egg_cache_dir())
+    environment = pkg_resources.Environment()
+    for egg_dist in pkg_resources.find_distributions(eggs_dir):
+        if egg_dist in req and environment.can_add(egg_dist):
+            return egg_dist
+    with TemporaryDirectory() as tmpdir:
+        cmd = [
+            sys.executable, '-m', 'pip',
+            '--disable-pip-version-check',
+            'wheel', '--no-deps',
+            '-w', tmpdir,
+        ]
+        if quiet:
+            cmd.append('--quiet')
+        if index_url is not None:
+            cmd.extend(('--index-url', index_url))
+        if find_links is not None:
+            for link in find_links:
+                cmd.extend(('--find-links', link))
+        # If requirement is a PEP 508 direct URL, directly pass
+        # the URL to pip, as `req @ url` does not work on the
+        # command line.
+        if req.url:
+            cmd.append(req.url)
+        else:
+            cmd.append(str(req))
+        try:
+            subprocess.check_call(cmd)
+        except subprocess.CalledProcessError as e:
+            raise DistutilsError(str(e)) from e
+        wheel = Wheel(glob.glob(os.path.join(tmpdir, '*.whl'))[0])
+        dist_location = os.path.join(eggs_dir, wheel.egg_name())
+        wheel.install_as_egg(dist_location)
+        dist_metadata = pkg_resources.PathMetadata(
+            dist_location, os.path.join(dist_location, 'EGG-INFO'))
+        dist = pkg_resources.Distribution.from_filename(
+            dist_location, metadata=dist_metadata)
+        return dist
+
+
+def strip_marker(req):
+    """
+    Return a new requirement without the environment marker to avoid
+    calling pip with something like `babel; extra == "i18n"`, which
+    would always be ignored.
+    """
+    # create a copy to avoid mutating the input
+    req = pkg_resources.Requirement.parse(str(req))
+    req.marker = None
+    return req
diff --git a/myenv/lib/python3.9/site-packages/setuptools/launch.py b/myenv/lib/python3.9/site-packages/setuptools/launch.py
new file mode 100644
index 0000000..0208fdf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/launch.py
@@ -0,0 +1,36 @@
+"""
+Launch the Python script on the command line after
+setuptools is bootstrapped via import.
+"""
+
+# Note that setuptools gets imported implicitly by the
+# invocation of this script using python -m setuptools.launch
+
+import tokenize
+import sys
+
+
+def run():
+    """
+    Run the script in sys.argv[1] as if it had
+    been invoked naturally.
+    """
+    __builtins__
+    script_name = sys.argv[1]
+    namespace = dict(
+        __file__=script_name,
+        __name__='__main__',
+        __doc__=None,
+    )
+    sys.argv[:] = sys.argv[1:]
+
+    open_ = getattr(tokenize, 'open', open)
+    with open_(script_name) as fid:
+        script = fid.read()
+    norm_script = script.replace('\\r\\n', '\\n')
+    code = compile(norm_script, script_name, 'exec')
+    exec(code, namespace)
+
+
+if __name__ == '__main__':
+    run()
diff --git a/myenv/lib/python3.9/site-packages/setuptools/lib2to3_ex.py b/myenv/lib/python3.9/site-packages/setuptools/lib2to3_ex.py
new file mode 100644
index 0000000..017f728
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/lib2to3_ex.py
@@ -0,0 +1,71 @@
+"""
+Customized Mixin2to3 support:
+
+ - adds support for converting doctests
+
+
+This module raises an ImportError on Python 2.
+"""
+
+import warnings
+from distutils.util import Mixin2to3 as _Mixin2to3
+from distutils import log
+from lib2to3.refactor import RefactoringTool, get_fixers_from_package
+
+import setuptools
+from ._deprecation_warning import SetuptoolsDeprecationWarning
+
+
+class DistutilsRefactoringTool(RefactoringTool):
+    def log_error(self, msg, *args, **kw):
+        log.error(msg, *args)
+
+    def log_message(self, msg, *args):
+        log.info(msg, *args)
+
+    def log_debug(self, msg, *args):
+        log.debug(msg, *args)
+
+
+class Mixin2to3(_Mixin2to3):
+    def run_2to3(self, files, doctests=False):
+        # See of the distribution option has been set, otherwise check the
+        # setuptools default.
+        if self.distribution.use_2to3 is not True:
+            return
+        if not files:
+            return
+
+        warnings.warn(
+            "2to3 support is deprecated. If the project still "
+            "requires Python 2 support, please migrate to "
+            "a single-codebase solution or employ an "
+            "independent conversion process.",
+            SetuptoolsDeprecationWarning)
+        log.info("Fixing " + " ".join(files))
+        self.__build_fixer_names()
+        self.__exclude_fixers()
+        if doctests:
+            if setuptools.run_2to3_on_doctests:
+                r = DistutilsRefactoringTool(self.fixer_names)
+                r.refactor(files, write=True, doctests_only=True)
+        else:
+            _Mixin2to3.run_2to3(self, files)
+
+    def __build_fixer_names(self):
+        if self.fixer_names:
+            return
+        self.fixer_names = []
+        for p in setuptools.lib2to3_fixer_packages:
+            self.fixer_names.extend(get_fixers_from_package(p))
+        if self.distribution.use_2to3_fixers is not None:
+            for p in self.distribution.use_2to3_fixers:
+                self.fixer_names.extend(get_fixers_from_package(p))
+
+    def __exclude_fixers(self):
+        excluded_fixers = getattr(self, 'exclude_fixers', [])
+        if self.distribution.use_2to3_exclude_fixers is not None:
+            excluded_fixers.extend(self.distribution.use_2to3_exclude_fixers)
+        for fixer_name in excluded_fixers:
+            if fixer_name in self.fixer_names:
+                self.fixer_names.remove(fixer_name)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/monkey.py b/myenv/lib/python3.9/site-packages/setuptools/monkey.py
new file mode 100644
index 0000000..3c77f8c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/monkey.py
@@ -0,0 +1,179 @@
+"""
+Monkey patching of distutils.
+"""
+
+import sys
+import distutils.filelist
+import platform
+import types
+import functools
+from importlib import import_module
+import inspect
+
+from setuptools.extern import six
+
+import setuptools
+
+__all__ = []
+"""
+Everything is private. Contact the project team
+if you think you need this functionality.
+"""
+
+
+def _get_mro(cls):
+    """
+    Returns the bases classes for cls sorted by the MRO.
+
+    Works around an issue on Jython where inspect.getmro will not return all
+    base classes if multiple classes share the same name. Instead, this
+    function will return a tuple containing the class itself, and the contents
+    of cls.__bases__. See https://github.com/pypa/setuptools/issues/1024.
+    """
+    if platform.python_implementation() == "Jython":
+        return (cls,) + cls.__bases__
+    return inspect.getmro(cls)
+
+
+def get_unpatched(item):
+    lookup = (
+        get_unpatched_class if isinstance(item, six.class_types) else
+        get_unpatched_function if isinstance(item, types.FunctionType) else
+        lambda item: None
+    )
+    return lookup(item)
+
+
+def get_unpatched_class(cls):
+    """Protect against re-patching the distutils if reloaded
+
+    Also ensures that no other distutils extension monkeypatched the distutils
+    first.
+    """
+    external_bases = (
+        cls
+        for cls in _get_mro(cls)
+        if not cls.__module__.startswith('setuptools')
+    )
+    base = next(external_bases)
+    if not base.__module__.startswith('distutils'):
+        msg = "distutils has already been patched by %r" % cls
+        raise AssertionError(msg)
+    return base
+
+
+def patch_all():
+    # we can't patch distutils.cmd, alas
+    distutils.core.Command = setuptools.Command
+
+    has_issue_12885 = sys.version_info <= (3, 5, 3)
+
+    if has_issue_12885:
+        # fix findall bug in distutils (http://bugs.python.org/issue12885)
+        distutils.filelist.findall = setuptools.findall
+
+    needs_warehouse = (
+        sys.version_info < (2, 7, 13)
+        or
+        (3, 4) < sys.version_info < (3, 4, 6)
+        or
+        (3, 5) < sys.version_info <= (3, 5, 3)
+    )
+
+    if needs_warehouse:
+        warehouse = 'https://upload.pypi.org/legacy/'
+        distutils.config.PyPIRCCommand.DEFAULT_REPOSITORY = warehouse
+
+    _patch_distribution_metadata()
+
+    # Install Distribution throughout the distutils
+    for module in distutils.dist, distutils.core, distutils.cmd:
+        module.Distribution = setuptools.dist.Distribution
+
+    # Install the patched Extension
+    distutils.core.Extension = setuptools.extension.Extension
+    distutils.extension.Extension = setuptools.extension.Extension
+    if 'distutils.command.build_ext' in sys.modules:
+        sys.modules['distutils.command.build_ext'].Extension = (
+            setuptools.extension.Extension
+        )
+
+    patch_for_msvc_specialized_compiler()
+
+
+def _patch_distribution_metadata():
+    """Patch write_pkg_file and read_pkg_file for higher metadata standards"""
+    for attr in ('write_pkg_file', 'read_pkg_file', 'get_metadata_version'):
+        new_val = getattr(setuptools.dist, attr)
+        setattr(distutils.dist.DistributionMetadata, attr, new_val)
+
+
+def patch_func(replacement, target_mod, func_name):
+    """
+    Patch func_name in target_mod with replacement
+
+    Important - original must be resolved by name to avoid
+    patching an already patched function.
+    """
+    original = getattr(target_mod, func_name)
+
+    # set the 'unpatched' attribute on the replacement to
+    # point to the original.
+    vars(replacement).setdefault('unpatched', original)
+
+    # replace the function in the original module
+    setattr(target_mod, func_name, replacement)
+
+
+def get_unpatched_function(candidate):
+    return getattr(candidate, 'unpatched')
+
+
+def patch_for_msvc_specialized_compiler():
+    """
+    Patch functions in distutils to use standalone Microsoft Visual C++
+    compilers.
+    """
+    # import late to avoid circular imports on Python < 3.5
+    msvc = import_module('setuptools.msvc')
+
+    if platform.system() != 'Windows':
+        # Compilers only availables on Microsoft Windows
+        return
+
+    def patch_params(mod_name, func_name):
+        """
+        Prepare the parameters for patch_func to patch indicated function.
+        """
+        repl_prefix = 'msvc9_' if 'msvc9' in mod_name else 'msvc14_'
+        repl_name = repl_prefix + func_name.lstrip('_')
+        repl = getattr(msvc, repl_name)
+        mod = import_module(mod_name)
+        if not hasattr(mod, func_name):
+            raise ImportError(func_name)
+        return repl, mod, func_name
+
+    # Python 2.7 to 3.4
+    msvc9 = functools.partial(patch_params, 'distutils.msvc9compiler')
+
+    # Python 3.5+
+    msvc14 = functools.partial(patch_params, 'distutils._msvccompiler')
+
+    try:
+        # Patch distutils.msvc9compiler
+        patch_func(*msvc9('find_vcvarsall'))
+        patch_func(*msvc9('query_vcvarsall'))
+    except ImportError:
+        pass
+
+    try:
+        # Patch distutils._msvccompiler._get_vc_env
+        patch_func(*msvc14('_get_vc_env'))
+    except ImportError:
+        pass
+
+    try:
+        # Patch distutils._msvccompiler.gen_lib_options for Numpy
+        patch_func(*msvc14('gen_lib_options'))
+    except ImportError:
+        pass
diff --git a/myenv/lib/python3.9/site-packages/setuptools/msvc.py b/myenv/lib/python3.9/site-packages/setuptools/msvc.py
new file mode 100644
index 0000000..72383eb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/msvc.py
@@ -0,0 +1,1831 @@
+"""
+Improved support for Microsoft Visual C++ compilers.
+
+Known supported compilers:
+--------------------------
+Microsoft Visual C++ 9.0:
+    Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64)
+    Microsoft Windows SDK 6.1 (x86, x64, ia64)
+    Microsoft Windows SDK 7.0 (x86, x64, ia64)
+
+Microsoft Visual C++ 10.0:
+    Microsoft Windows SDK 7.1 (x86, x64, ia64)
+
+Microsoft Visual C++ 14.X:
+    Microsoft Visual C++ Build Tools 2015 (x86, x64, arm)
+    Microsoft Visual Studio Build Tools 2017 (x86, x64, arm, arm64)
+    Microsoft Visual Studio Build Tools 2019 (x86, x64, arm, arm64)
+
+This may also support compilers shipped with compatible Visual Studio versions.
+"""
+
+import json
+from io import open
+from os import listdir, pathsep
+from os.path import join, isfile, isdir, dirname
+import sys
+import platform
+import itertools
+import subprocess
+import distutils.errors
+from setuptools.extern.packaging.version import LegacyVersion
+
+from setuptools.extern.six.moves import filterfalse
+
+from .monkey import get_unpatched
+
+if platform.system() == 'Windows':
+    from setuptools.extern.six.moves import winreg
+    from os import environ
+else:
+    # Mock winreg and environ so the module can be imported on this platform.
+
+    class winreg:
+        HKEY_USERS = None
+        HKEY_CURRENT_USER = None
+        HKEY_LOCAL_MACHINE = None
+        HKEY_CLASSES_ROOT = None
+
+    environ = dict()
+
+_msvc9_suppress_errors = (
+    # msvc9compiler isn't available on some platforms
+    ImportError,
+
+    # msvc9compiler raises DistutilsPlatformError in some
+    # environments. See #1118.
+    distutils.errors.DistutilsPlatformError,
+)
+
+try:
+    from distutils.msvc9compiler import Reg
+except _msvc9_suppress_errors:
+    pass
+
+
+def msvc9_find_vcvarsall(version):
+    """
+    Patched "distutils.msvc9compiler.find_vcvarsall" to use the standalone
+    compiler build for Python
+    (VCForPython / Microsoft Visual C++ Compiler for Python 2.7).
+
+    Fall back to original behavior when the standalone compiler is not
+    available.
+
+    Redirect the path of "vcvarsall.bat".
+
+    Parameters
+    ----------
+    version: float
+        Required Microsoft Visual C++ version.
+
+    Return
+    ------
+    str
+        vcvarsall.bat path
+    """
+    vc_base = r'Software\%sMicrosoft\DevDiv\VCForPython\%0.1f'
+    key = vc_base % ('', version)
+    try:
+        # Per-user installs register the compiler path here
+        productdir = Reg.get_value(key, "installdir")
+    except KeyError:
+        try:
+            # All-user installs on a 64-bit system register here
+            key = vc_base % ('Wow6432Node\\', version)
+            productdir = Reg.get_value(key, "installdir")
+        except KeyError:
+            productdir = None
+
+    if productdir:
+        vcvarsall = join(productdir, "vcvarsall.bat")
+        if isfile(vcvarsall):
+            return vcvarsall
+
+    return get_unpatched(msvc9_find_vcvarsall)(version)
+
+
+def msvc9_query_vcvarsall(ver, arch='x86', *args, **kwargs):
+    """
+    Patched "distutils.msvc9compiler.query_vcvarsall" for support extra
+    Microsoft Visual C++ 9.0 and 10.0 compilers.
+
+    Set environment without use of "vcvarsall.bat".
+
+    Parameters
+    ----------
+    ver: float
+        Required Microsoft Visual C++ version.
+    arch: str
+        Target architecture.
+
+    Return
+    ------
+    dict
+        environment
+    """
+    # Try to get environment from vcvarsall.bat (Classical way)
+    try:
+        orig = get_unpatched(msvc9_query_vcvarsall)
+        return orig(ver, arch, *args, **kwargs)
+    except distutils.errors.DistutilsPlatformError:
+        # Pass error if Vcvarsall.bat is missing
+        pass
+    except ValueError:
+        # Pass error if environment not set after executing vcvarsall.bat
+        pass
+
+    # If error, try to set environment directly
+    try:
+        return EnvironmentInfo(arch, ver).return_env()
+    except distutils.errors.DistutilsPlatformError as exc:
+        _augment_exception(exc, ver, arch)
+        raise
+
+
+def _msvc14_find_vc2015():
+    """Python 3.8 "distutils/_msvccompiler.py" backport"""
+    try:
+        key = winreg.OpenKey(
+            winreg.HKEY_LOCAL_MACHINE,
+            r"Software\Microsoft\VisualStudio\SxS\VC7",
+            0,
+            winreg.KEY_READ | winreg.KEY_WOW64_32KEY
+        )
+    except OSError:
+        return None, None
+
+    best_version = 0
+    best_dir = None
+    with key:
+        for i in itertools.count():
+            try:
+                v, vc_dir, vt = winreg.EnumValue(key, i)
+            except OSError:
+                break
+            if v and vt == winreg.REG_SZ and isdir(vc_dir):
+                try:
+                    version = int(float(v))
+                except (ValueError, TypeError):
+                    continue
+                if version >= 14 and version > best_version:
+                    best_version, best_dir = version, vc_dir
+    return best_version, best_dir
+
+
+def _msvc14_find_vc2017():
+    """Python 3.8 "distutils/_msvccompiler.py" backport
+
+    Returns "15, path" based on the result of invoking vswhere.exe
+    If no install is found, returns "None, None"
+
+    The version is returned to avoid unnecessarily changing the function
+    result. It may be ignored when the path is not None.
+
+    If vswhere.exe is not available, by definition, VS 2017 is not
+    installed.
+    """
+    root = environ.get("ProgramFiles(x86)") or environ.get("ProgramFiles")
+    if not root:
+        return None, None
+
+    try:
+        path = subprocess.check_output([
+            join(root, "Microsoft Visual Studio", "Installer", "vswhere.exe"),
+            "-latest",
+            "-prerelease",
+            "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
+            "-property", "installationPath",
+            "-products", "*",
+        ]).decode(encoding="mbcs", errors="strict").strip()
+    except (subprocess.CalledProcessError, OSError, UnicodeDecodeError):
+        return None, None
+
+    path = join(path, "VC", "Auxiliary", "Build")
+    if isdir(path):
+        return 15, path
+
+    return None, None
+
+
+PLAT_SPEC_TO_RUNTIME = {
+    'x86': 'x86',
+    'x86_amd64': 'x64',
+    'x86_arm': 'arm',
+    'x86_arm64': 'arm64'
+}
+
+
+def _msvc14_find_vcvarsall(plat_spec):
+    """Python 3.8 "distutils/_msvccompiler.py" backport"""
+    _, best_dir = _msvc14_find_vc2017()
+    vcruntime = None
+
+    if plat_spec in PLAT_SPEC_TO_RUNTIME:
+        vcruntime_plat = PLAT_SPEC_TO_RUNTIME[plat_spec]
+    else:
+        vcruntime_plat = 'x64' if 'amd64' in plat_spec else 'x86'
+
+    if best_dir:
+        vcredist = join(best_dir, "..", "..", "redist", "MSVC", "**",
+                        vcruntime_plat, "Microsoft.VC14*.CRT",
+                        "vcruntime140.dll")
+        try:
+            import glob
+            vcruntime = glob.glob(vcredist, recursive=True)[-1]
+        except (ImportError, OSError, LookupError):
+            vcruntime = None
+
+    if not best_dir:
+        best_version, best_dir = _msvc14_find_vc2015()
+        if best_version:
+            vcruntime = join(best_dir, 'redist', vcruntime_plat,
+                             "Microsoft.VC140.CRT", "vcruntime140.dll")
+
+    if not best_dir:
+        return None, None
+
+    vcvarsall = join(best_dir, "vcvarsall.bat")
+    if not isfile(vcvarsall):
+        return None, None
+
+    if not vcruntime or not isfile(vcruntime):
+        vcruntime = None
+
+    return vcvarsall, vcruntime
+
+
+def _msvc14_get_vc_env(plat_spec):
+    """Python 3.8 "distutils/_msvccompiler.py" backport"""
+    if "DISTUTILS_USE_SDK" in environ:
+        return {
+            key.lower(): value
+            for key, value in environ.items()
+        }
+
+    vcvarsall, vcruntime = _msvc14_find_vcvarsall(plat_spec)
+    if not vcvarsall:
+        raise distutils.errors.DistutilsPlatformError(
+            "Unable to find vcvarsall.bat"
+        )
+
+    try:
+        out = subprocess.check_output(
+            'cmd /u /c "{}" {} && set'.format(vcvarsall, plat_spec),
+            stderr=subprocess.STDOUT,
+        ).decode('utf-16le', errors='replace')
+    except subprocess.CalledProcessError as exc:
+        raise distutils.errors.DistutilsPlatformError(
+            "Error executing {}".format(exc.cmd)
+        ) from exc
+
+    env = {
+        key.lower(): value
+        for key, _, value in
+        (line.partition('=') for line in out.splitlines())
+        if key and value
+    }
+
+    if vcruntime:
+        env['py_vcruntime_redist'] = vcruntime
+    return env
+
+
+def msvc14_get_vc_env(plat_spec):
+    """
+    Patched "distutils._msvccompiler._get_vc_env" for support extra
+    Microsoft Visual C++ 14.X compilers.
+
+    Set environment without use of "vcvarsall.bat".
+
+    Parameters
+    ----------
+    plat_spec: str
+        Target architecture.
+
+    Return
+    ------
+    dict
+        environment
+    """
+
+    # Always use backport from CPython 3.8
+    try:
+        return _msvc14_get_vc_env(plat_spec)
+    except distutils.errors.DistutilsPlatformError as exc:
+        _augment_exception(exc, 14.0)
+        raise
+
+
+def msvc14_gen_lib_options(*args, **kwargs):
+    """
+    Patched "distutils._msvccompiler.gen_lib_options" for fix
+    compatibility between "numpy.distutils" and "distutils._msvccompiler"
+    (for Numpy < 1.11.2)
+    """
+    if "numpy.distutils" in sys.modules:
+        import numpy as np
+        if LegacyVersion(np.__version__) < LegacyVersion('1.11.2'):
+            return np.distutils.ccompiler.gen_lib_options(*args, **kwargs)
+    return get_unpatched(msvc14_gen_lib_options)(*args, **kwargs)
+
+
+def _augment_exception(exc, version, arch=''):
+    """
+    Add details to the exception message to help guide the user
+    as to what action will resolve it.
+    """
+    # Error if MSVC++ directory not found or environment not set
+    message = exc.args[0]
+
+    if "vcvarsall" in message.lower() or "visual c" in message.lower():
+        # Special error message if MSVC++ not installed
+        tmpl = 'Microsoft Visual C++ {version:0.1f} is required.'
+        message = tmpl.format(**locals())
+        msdownload = 'www.microsoft.com/download/details.aspx?id=%d'
+        if version == 9.0:
+            if arch.lower().find('ia64') > -1:
+                # For VC++ 9.0, if IA64 support is needed, redirect user
+                # to Windows SDK 7.0.
+                # Note: No download link available from Microsoft.
+                message += ' Get it with "Microsoft Windows SDK 7.0"'
+            else:
+                # For VC++ 9.0 redirect user to Vc++ for Python 2.7 :
+                # This redirection link is maintained by Microsoft.
+                # Contact vspython@microsoft.com if it needs updating.
+                message += ' Get it from http://aka.ms/vcpython27'
+        elif version == 10.0:
+            # For VC++ 10.0 Redirect user to Windows SDK 7.1
+            message += ' Get it with "Microsoft Windows SDK 7.1": '
+            message += msdownload % 8279
+        elif version >= 14.0:
+            # For VC++ 14.X Redirect user to latest Visual C++ Build Tools
+            message += (' Get it with "Build Tools for Visual Studio": '
+                        r'https://visualstudio.microsoft.com/downloads/')
+
+    exc.args = (message, )
+
+
+class PlatformInfo:
+    """
+    Current and Target Architectures information.
+
+    Parameters
+    ----------
+    arch: str
+        Target architecture.
+    """
+    current_cpu = environ.get('processor_architecture', '').lower()
+
+    def __init__(self, arch):
+        self.arch = arch.lower().replace('x64', 'amd64')
+
+    @property
+    def target_cpu(self):
+        """
+        Return Target CPU architecture.
+
+        Return
+        ------
+        str
+            Target CPU
+        """
+        return self.arch[self.arch.find('_') + 1:]
+
+    def target_is_x86(self):
+        """
+        Return True if target CPU is x86 32 bits..
+
+        Return
+        ------
+        bool
+            CPU is x86 32 bits
+        """
+        return self.target_cpu == 'x86'
+
+    def current_is_x86(self):
+        """
+        Return True if current CPU is x86 32 bits..
+
+        Return
+        ------
+        bool
+            CPU is x86 32 bits
+        """
+        return self.current_cpu == 'x86'
+
+    def current_dir(self, hidex86=False, x64=False):
+        """
+        Current platform specific subfolder.
+
+        Parameters
+        ----------
+        hidex86: bool
+            return '' and not '\x86' if architecture is x86.
+        x64: bool
+            return '\x64' and not '\amd64' if architecture is amd64.
+
+        Return
+        ------
+        str
+            subfolder: '\target', or '' (see hidex86 parameter)
+        """
+        return (
+            '' if (self.current_cpu == 'x86' and hidex86) else
+            r'\x64' if (self.current_cpu == 'amd64' and x64) else
+            r'\%s' % self.current_cpu
+        )
+
+    def target_dir(self, hidex86=False, x64=False):
+        r"""
+        Target platform specific subfolder.
+
+        Parameters
+        ----------
+        hidex86: bool
+            return '' and not '\x86' if architecture is x86.
+        x64: bool
+            return '\x64' and not '\amd64' if architecture is amd64.
+
+        Return
+        ------
+        str
+            subfolder: '\current', or '' (see hidex86 parameter)
+        """
+        return (
+            '' if (self.target_cpu == 'x86' and hidex86) else
+            r'\x64' if (self.target_cpu == 'amd64' and x64) else
+            r'\%s' % self.target_cpu
+        )
+
+    def cross_dir(self, forcex86=False):
+        r"""
+        Cross platform specific subfolder.
+
+        Parameters
+        ----------
+        forcex86: bool
+            Use 'x86' as current architecture even if current architecture is
+            not x86.
+
+        Return
+        ------
+        str
+            subfolder: '' if target architecture is current architecture,
+            '\current_target' if not.
+        """
+        current = 'x86' if forcex86 else self.current_cpu
+        return (
+            '' if self.target_cpu == current else
+            self.target_dir().replace('\\', '\\%s_' % current)
+        )
+
+
+class RegistryInfo:
+    """
+    Microsoft Visual Studio related registry information.
+
+    Parameters
+    ----------
+    platform_info: PlatformInfo
+        "PlatformInfo" instance.
+    """
+    HKEYS = (winreg.HKEY_USERS,
+             winreg.HKEY_CURRENT_USER,
+             winreg.HKEY_LOCAL_MACHINE,
+             winreg.HKEY_CLASSES_ROOT)
+
+    def __init__(self, platform_info):
+        self.pi = platform_info
+
+    @property
+    def visualstudio(self):
+        """
+        Microsoft Visual Studio root registry key.
+
+        Return
+        ------
+        str
+            Registry key
+        """
+        return 'VisualStudio'
+
+    @property
+    def sxs(self):
+        """
+        Microsoft Visual Studio SxS registry key.
+
+        Return
+        ------
+        str
+            Registry key
+        """
+        return join(self.visualstudio, 'SxS')
+
+    @property
+    def vc(self):
+        """
+        Microsoft Visual C++ VC7 registry key.
+
+        Return
+        ------
+        str
+            Registry key
+        """
+        return join(self.sxs, 'VC7')
+
+    @property
+    def vs(self):
+        """
+        Microsoft Visual Studio VS7 registry key.
+
+        Return
+        ------
+        str
+            Registry key
+        """
+        return join(self.sxs, 'VS7')
+
+    @property
+    def vc_for_python(self):
+        """
+        Microsoft Visual C++ for Python registry key.
+
+        Return
+        ------
+        str
+            Registry key
+        """
+        return r'DevDiv\VCForPython'
+
+    @property
+    def microsoft_sdk(self):
+        """
+        Microsoft SDK registry key.
+
+        Return
+        ------
+        str
+            Registry key
+        """
+        return 'Microsoft SDKs'
+
+    @property
+    def windows_sdk(self):
+        """
+        Microsoft Windows/Platform SDK registry key.
+
+        Return
+        ------
+        str
+            Registry key
+        """
+        return join(self.microsoft_sdk, 'Windows')
+
+    @property
+    def netfx_sdk(self):
+        """
+        Microsoft .NET Framework SDK registry key.
+
+        Return
+        ------
+        str
+            Registry key
+        """
+        return join(self.microsoft_sdk, 'NETFXSDK')
+
+    @property
+    def windows_kits_roots(self):
+        """
+        Microsoft Windows Kits Roots registry key.
+
+        Return
+        ------
+        str
+            Registry key
+        """
+        return r'Windows Kits\Installed Roots'
+
+    def microsoft(self, key, x86=False):
+        """
+        Return key in Microsoft software registry.
+
+        Parameters
+        ----------
+        key: str
+            Registry key path where look.
+        x86: str
+            Force x86 software registry.
+
+        Return
+        ------
+        str
+            Registry key
+        """
+        node64 = '' if self.pi.current_is_x86() or x86 else 'Wow6432Node'
+        return join('Software', node64, 'Microsoft', key)
+
+    def lookup(self, key, name):
+        """
+        Look for values in registry in Microsoft software registry.
+
+        Parameters
+        ----------
+        key: str
+            Registry key path where look.
+        name: str
+            Value name to find.
+
+        Return
+        ------
+        str
+            value
+        """
+        key_read = winreg.KEY_READ
+        openkey = winreg.OpenKey
+        closekey = winreg.CloseKey
+        ms = self.microsoft
+        for hkey in self.HKEYS:
+            bkey = None
+            try:
+                bkey = openkey(hkey, ms(key), 0, key_read)
+            except (OSError, IOError):
+                if not self.pi.current_is_x86():
+                    try:
+                        bkey = openkey(hkey, ms(key, True), 0, key_read)
+                    except (OSError, IOError):
+                        continue
+                else:
+                    continue
+            try:
+                return winreg.QueryValueEx(bkey, name)[0]
+            except (OSError, IOError):
+                pass
+            finally:
+                if bkey:
+                    closekey(bkey)
+
+
+class SystemInfo:
+    """
+    Microsoft Windows and Visual Studio related system information.
+
+    Parameters
+    ----------
+    registry_info: RegistryInfo
+        "RegistryInfo" instance.
+    vc_ver: float
+        Required Microsoft Visual C++ version.
+    """
+
+    # Variables and properties in this class use originals CamelCase variables
+    # names from Microsoft source files for more easy comparison.
+    WinDir = environ.get('WinDir', '')
+    ProgramFiles = environ.get('ProgramFiles', '')
+    ProgramFilesx86 = environ.get('ProgramFiles(x86)', ProgramFiles)
+
+    def __init__(self, registry_info, vc_ver=None):
+        self.ri = registry_info
+        self.pi = self.ri.pi
+
+        self.known_vs_paths = self.find_programdata_vs_vers()
+
+        # Except for VS15+, VC version is aligned with VS version
+        self.vs_ver = self.vc_ver = (
+            vc_ver or self._find_latest_available_vs_ver())
+
+    def _find_latest_available_vs_ver(self):
+        """
+        Find the latest VC version
+
+        Return
+        ------
+        float
+            version
+        """
+        reg_vc_vers = self.find_reg_vs_vers()
+
+        if not (reg_vc_vers or self.known_vs_paths):
+            raise distutils.errors.DistutilsPlatformError(
+                'No Microsoft Visual C++ version found')
+
+        vc_vers = set(reg_vc_vers)
+        vc_vers.update(self.known_vs_paths)
+        return sorted(vc_vers)[-1]
+
+    def find_reg_vs_vers(self):
+        """
+        Find Microsoft Visual Studio versions available in registry.
+
+        Return
+        ------
+        list of float
+            Versions
+        """
+        ms = self.ri.microsoft
+        vckeys = (self.ri.vc, self.ri.vc_for_python, self.ri.vs)
+        vs_vers = []
+        for hkey in self.ri.HKEYS:
+            for key in vckeys:
+                try:
+                    bkey = winreg.OpenKey(hkey, ms(key), 0, winreg.KEY_READ)
+                except (OSError, IOError):
+                    continue
+                with bkey:
+                    subkeys, values, _ = winreg.QueryInfoKey(bkey)
+                    for i in range(values):
+                        try:
+                            ver = float(winreg.EnumValue(bkey, i)[0])
+                            if ver not in vs_vers:
+                                vs_vers.append(ver)
+                        except ValueError:
+                            pass
+                    for i in range(subkeys):
+                        try:
+                            ver = float(winreg.EnumKey(bkey, i))
+                            if ver not in vs_vers:
+                                vs_vers.append(ver)
+                        except ValueError:
+                            pass
+        return sorted(vs_vers)
+
+    def find_programdata_vs_vers(self):
+        r"""
+        Find Visual studio 2017+ versions from information in
+        "C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances".
+
+        Return
+        ------
+        dict
+            float version as key, path as value.
+        """
+        vs_versions = {}
+        instances_dir = \
+            r'C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances'
+
+        try:
+            hashed_names = listdir(instances_dir)
+
+        except (OSError, IOError):
+            # Directory not exists with all Visual Studio versions
+            return vs_versions
+
+        for name in hashed_names:
+            try:
+                # Get VS installation path from "state.json" file
+                state_path = join(instances_dir, name, 'state.json')
+                with open(state_path, 'rt', encoding='utf-8') as state_file:
+                    state = json.load(state_file)
+                vs_path = state['installationPath']
+
+                # Raises OSError if this VS installation does not contain VC
+                listdir(join(vs_path, r'VC\Tools\MSVC'))
+
+                # Store version and path
+                vs_versions[self._as_float_version(
+                    state['installationVersion'])] = vs_path
+
+            except (OSError, IOError, KeyError):
+                # Skip if "state.json" file is missing or bad format
+                continue
+
+        return vs_versions
+
+    @staticmethod
+    def _as_float_version(version):
+        """
+        Return a string version as a simplified float version (major.minor)
+
+        Parameters
+        ----------
+        version: str
+            Version.
+
+        Return
+        ------
+        float
+            version
+        """
+        return float('.'.join(version.split('.')[:2]))
+
+    @property
+    def VSInstallDir(self):
+        """
+        Microsoft Visual Studio directory.
+
+        Return
+        ------
+        str
+            path
+        """
+        # Default path
+        default = join(self.ProgramFilesx86,
+                       'Microsoft Visual Studio %0.1f' % self.vs_ver)
+
+        # Try to get path from registry, if fail use default path
+        return self.ri.lookup(self.ri.vs, '%0.1f' % self.vs_ver) or default
+
+    @property
+    def VCInstallDir(self):
+        """
+        Microsoft Visual C++ directory.
+
+        Return
+        ------
+        str
+            path
+        """
+        path = self._guess_vc() or self._guess_vc_legacy()
+
+        if not isdir(path):
+            msg = 'Microsoft Visual C++ directory not found'
+            raise distutils.errors.DistutilsPlatformError(msg)
+
+        return path
+
+    def _guess_vc(self):
+        """
+        Locate Visual C++ for VS2017+.
+
+        Return
+        ------
+        str
+            path
+        """
+        if self.vs_ver <= 14.0:
+            return ''
+
+        try:
+            # First search in known VS paths
+            vs_dir = self.known_vs_paths[self.vs_ver]
+        except KeyError:
+            # Else, search with path from registry
+            vs_dir = self.VSInstallDir
+
+        guess_vc = join(vs_dir, r'VC\Tools\MSVC')
+
+        # Subdir with VC exact version as name
+        try:
+            # Update the VC version with real one instead of VS version
+            vc_ver = listdir(guess_vc)[-1]
+            self.vc_ver = self._as_float_version(vc_ver)
+            return join(guess_vc, vc_ver)
+        except (OSError, IOError, IndexError):
+            return ''
+
+    def _guess_vc_legacy(self):
+        """
+        Locate Visual C++ for versions prior to 2017.
+
+        Return
+        ------
+        str
+            path
+        """
+        default = join(self.ProgramFilesx86,
+                       r'Microsoft Visual Studio %0.1f\VC' % self.vs_ver)
+
+        # Try to get "VC++ for Python" path from registry as default path
+        reg_path = join(self.ri.vc_for_python, '%0.1f' % self.vs_ver)
+        python_vc = self.ri.lookup(reg_path, 'installdir')
+        default_vc = join(python_vc, 'VC') if python_vc else default
+
+        # Try to get path from registry, if fail use default path
+        return self.ri.lookup(self.ri.vc, '%0.1f' % self.vs_ver) or default_vc
+
+    @property
+    def WindowsSdkVersion(self):
+        """
+        Microsoft Windows SDK versions for specified MSVC++ version.
+
+        Return
+        ------
+        tuple of str
+            versions
+        """
+        if self.vs_ver <= 9.0:
+            return '7.0', '6.1', '6.0a'
+        elif self.vs_ver == 10.0:
+            return '7.1', '7.0a'
+        elif self.vs_ver == 11.0:
+            return '8.0', '8.0a'
+        elif self.vs_ver == 12.0:
+            return '8.1', '8.1a'
+        elif self.vs_ver >= 14.0:
+            return '10.0', '8.1'
+
+    @property
+    def WindowsSdkLastVersion(self):
+        """
+        Microsoft Windows SDK last version.
+
+        Return
+        ------
+        str
+            version
+        """
+        return self._use_last_dir_name(join(self.WindowsSdkDir, 'lib'))
+
+    @property
+    def WindowsSdkDir(self):
+        """
+        Microsoft Windows SDK directory.
+
+        Return
+        ------
+        str
+            path
+        """
+        sdkdir = ''
+        for ver in self.WindowsSdkVersion:
+            # Try to get it from registry
+            loc = join(self.ri.windows_sdk, 'v%s' % ver)
+            sdkdir = self.ri.lookup(loc, 'installationfolder')
+            if sdkdir:
+                break
+        if not sdkdir or not isdir(sdkdir):
+            # Try to get "VC++ for Python" version from registry
+            path = join(self.ri.vc_for_python, '%0.1f' % self.vc_ver)
+            install_base = self.ri.lookup(path, 'installdir')
+            if install_base:
+                sdkdir = join(install_base, 'WinSDK')
+        if not sdkdir or not isdir(sdkdir):
+            # If fail, use default new path
+            for ver in self.WindowsSdkVersion:
+                intver = ver[:ver.rfind('.')]
+                path = r'Microsoft SDKs\Windows Kits\%s' % intver
+                d = join(self.ProgramFiles, path)
+                if isdir(d):
+                    sdkdir = d
+        if not sdkdir or not isdir(sdkdir):
+            # If fail, use default old path
+            for ver in self.WindowsSdkVersion:
+                path = r'Microsoft SDKs\Windows\v%s' % ver
+                d = join(self.ProgramFiles, path)
+                if isdir(d):
+                    sdkdir = d
+        if not sdkdir:
+            # If fail, use Platform SDK
+            sdkdir = join(self.VCInstallDir, 'PlatformSDK')
+        return sdkdir
+
+    @property
+    def WindowsSDKExecutablePath(self):
+        """
+        Microsoft Windows SDK executable directory.
+
+        Return
+        ------
+        str
+            path
+        """
+        # Find WinSDK NetFx Tools registry dir name
+        if self.vs_ver <= 11.0:
+            netfxver = 35
+            arch = ''
+        else:
+            netfxver = 40
+            hidex86 = True if self.vs_ver <= 12.0 else False
+            arch = self.pi.current_dir(x64=True, hidex86=hidex86)
+        fx = 'WinSDK-NetFx%dTools%s' % (netfxver, arch.replace('\\', '-'))
+
+        # list all possibles registry paths
+        regpaths = []
+        if self.vs_ver >= 14.0:
+            for ver in self.NetFxSdkVersion:
+                regpaths += [join(self.ri.netfx_sdk, ver, fx)]
+
+        for ver in self.WindowsSdkVersion:
+            regpaths += [join(self.ri.windows_sdk, 'v%sA' % ver, fx)]
+
+        # Return installation folder from the more recent path
+        for path in regpaths:
+            execpath = self.ri.lookup(path, 'installationfolder')
+            if execpath:
+                return execpath
+
+    @property
+    def FSharpInstallDir(self):
+        """
+        Microsoft Visual F# directory.
+
+        Return
+        ------
+        str
+            path
+        """
+        path = join(self.ri.visualstudio, r'%0.1f\Setup\F#' % self.vs_ver)
+        return self.ri.lookup(path, 'productdir') or ''
+
+    @property
+    def UniversalCRTSdkDir(self):
+        """
+        Microsoft Universal CRT SDK directory.
+
+        Return
+        ------
+        str
+            path
+        """
+        # Set Kit Roots versions for specified MSVC++ version
+        vers = ('10', '81') if self.vs_ver >= 14.0 else ()
+
+        # Find path of the more recent Kit
+        for ver in vers:
+            sdkdir = self.ri.lookup(self.ri.windows_kits_roots,
+                                    'kitsroot%s' % ver)
+            if sdkdir:
+                return sdkdir or ''
+
+    @property
+    def UniversalCRTSdkLastVersion(self):
+        """
+        Microsoft Universal C Runtime SDK last version.
+
+        Return
+        ------
+        str
+            version
+        """
+        return self._use_last_dir_name(join(self.UniversalCRTSdkDir, 'lib'))
+
+    @property
+    def NetFxSdkVersion(self):
+        """
+        Microsoft .NET Framework SDK versions.
+
+        Return
+        ------
+        tuple of str
+            versions
+        """
+        # Set FxSdk versions for specified VS version
+        return (('4.7.2', '4.7.1', '4.7',
+                 '4.6.2', '4.6.1', '4.6',
+                 '4.5.2', '4.5.1', '4.5')
+                if self.vs_ver >= 14.0 else ())
+
+    @property
+    def NetFxSdkDir(self):
+        """
+        Microsoft .NET Framework SDK directory.
+
+        Return
+        ------
+        str
+            path
+        """
+        sdkdir = ''
+        for ver in self.NetFxSdkVersion:
+            loc = join(self.ri.netfx_sdk, ver)
+            sdkdir = self.ri.lookup(loc, 'kitsinstallationfolder')
+            if sdkdir:
+                break
+        return sdkdir
+
+    @property
+    def FrameworkDir32(self):
+        """
+        Microsoft .NET Framework 32bit directory.
+
+        Return
+        ------
+        str
+            path
+        """
+        # Default path
+        guess_fw = join(self.WinDir, r'Microsoft.NET\Framework')
+
+        # Try to get path from registry, if fail use default path
+        return self.ri.lookup(self.ri.vc, 'frameworkdir32') or guess_fw
+
+    @property
+    def FrameworkDir64(self):
+        """
+        Microsoft .NET Framework 64bit directory.
+
+        Return
+        ------
+        str
+            path
+        """
+        # Default path
+        guess_fw = join(self.WinDir, r'Microsoft.NET\Framework64')
+
+        # Try to get path from registry, if fail use default path
+        return self.ri.lookup(self.ri.vc, 'frameworkdir64') or guess_fw
+
+    @property
+    def FrameworkVersion32(self):
+        """
+        Microsoft .NET Framework 32bit versions.
+
+        Return
+        ------
+        tuple of str
+            versions
+        """
+        return self._find_dot_net_versions(32)
+
+    @property
+    def FrameworkVersion64(self):
+        """
+        Microsoft .NET Framework 64bit versions.
+
+        Return
+        ------
+        tuple of str
+            versions
+        """
+        return self._find_dot_net_versions(64)
+
+    def _find_dot_net_versions(self, bits):
+        """
+        Find Microsoft .NET Framework versions.
+
+        Parameters
+        ----------
+        bits: int
+            Platform number of bits: 32 or 64.
+
+        Return
+        ------
+        tuple of str
+            versions
+        """
+        # Find actual .NET version in registry
+        reg_ver = self.ri.lookup(self.ri.vc, 'frameworkver%d' % bits)
+        dot_net_dir = getattr(self, 'FrameworkDir%d' % bits)
+        ver = reg_ver or self._use_last_dir_name(dot_net_dir, 'v') or ''
+
+        # Set .NET versions for specified MSVC++ version
+        if self.vs_ver >= 12.0:
+            return ver, 'v4.0'
+        elif self.vs_ver >= 10.0:
+            return 'v4.0.30319' if ver.lower()[:2] != 'v4' else ver, 'v3.5'
+        elif self.vs_ver == 9.0:
+            return 'v3.5', 'v2.0.50727'
+        elif self.vs_ver == 8.0:
+            return 'v3.0', 'v2.0.50727'
+
+    @staticmethod
+    def _use_last_dir_name(path, prefix=''):
+        """
+        Return name of the last dir in path or '' if no dir found.
+
+        Parameters
+        ----------
+        path: str
+            Use dirs in this path
+        prefix: str
+            Use only dirs starting by this prefix
+
+        Return
+        ------
+        str
+            name
+        """
+        matching_dirs = (
+            dir_name
+            for dir_name in reversed(listdir(path))
+            if isdir(join(path, dir_name)) and
+            dir_name.startswith(prefix)
+        )
+        return next(matching_dirs, None) or ''
+
+
+class EnvironmentInfo:
+    """
+    Return environment variables for specified Microsoft Visual C++ version
+    and platform : Lib, Include, Path and libpath.
+
+    This function is compatible with Microsoft Visual C++ 9.0 to 14.X.
+
+    Script created by analysing Microsoft environment configuration files like
+    "vcvars[...].bat", "SetEnv.Cmd", "vcbuildtools.bat", ...
+
+    Parameters
+    ----------
+    arch: str
+        Target architecture.
+    vc_ver: float
+        Required Microsoft Visual C++ version. If not set, autodetect the last
+        version.
+    vc_min_ver: float
+        Minimum Microsoft Visual C++ version.
+    """
+
+    # Variables and properties in this class use originals CamelCase variables
+    # names from Microsoft source files for more easy comparison.
+
+    def __init__(self, arch, vc_ver=None, vc_min_ver=0):
+        self.pi = PlatformInfo(arch)
+        self.ri = RegistryInfo(self.pi)
+        self.si = SystemInfo(self.ri, vc_ver)
+
+        if self.vc_ver < vc_min_ver:
+            err = 'No suitable Microsoft Visual C++ version found'
+            raise distutils.errors.DistutilsPlatformError(err)
+
+    @property
+    def vs_ver(self):
+        """
+        Microsoft Visual Studio.
+
+        Return
+        ------
+        float
+            version
+        """
+        return self.si.vs_ver
+
+    @property
+    def vc_ver(self):
+        """
+        Microsoft Visual C++ version.
+
+        Return
+        ------
+        float
+            version
+        """
+        return self.si.vc_ver
+
+    @property
+    def VSTools(self):
+        """
+        Microsoft Visual Studio Tools.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        paths = [r'Common7\IDE', r'Common7\Tools']
+
+        if self.vs_ver >= 14.0:
+            arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
+            paths += [r'Common7\IDE\CommonExtensions\Microsoft\TestWindow']
+            paths += [r'Team Tools\Performance Tools']
+            paths += [r'Team Tools\Performance Tools%s' % arch_subdir]
+
+        return [join(self.si.VSInstallDir, path) for path in paths]
+
+    @property
+    def VCIncludes(self):
+        """
+        Microsoft Visual C++ & Microsoft Foundation Class Includes.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        return [join(self.si.VCInstallDir, 'Include'),
+                join(self.si.VCInstallDir, r'ATLMFC\Include')]
+
+    @property
+    def VCLibraries(self):
+        """
+        Microsoft Visual C++ & Microsoft Foundation Class Libraries.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        if self.vs_ver >= 15.0:
+            arch_subdir = self.pi.target_dir(x64=True)
+        else:
+            arch_subdir = self.pi.target_dir(hidex86=True)
+        paths = ['Lib%s' % arch_subdir, r'ATLMFC\Lib%s' % arch_subdir]
+
+        if self.vs_ver >= 14.0:
+            paths += [r'Lib\store%s' % arch_subdir]
+
+        return [join(self.si.VCInstallDir, path) for path in paths]
+
+    @property
+    def VCStoreRefs(self):
+        """
+        Microsoft Visual C++ store references Libraries.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        if self.vs_ver < 14.0:
+            return []
+        return [join(self.si.VCInstallDir, r'Lib\store\references')]
+
+    @property
+    def VCTools(self):
+        """
+        Microsoft Visual C++ Tools.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        si = self.si
+        tools = [join(si.VCInstallDir, 'VCPackages')]
+
+        forcex86 = True if self.vs_ver <= 10.0 else False
+        arch_subdir = self.pi.cross_dir(forcex86)
+        if arch_subdir:
+            tools += [join(si.VCInstallDir, 'Bin%s' % arch_subdir)]
+
+        if self.vs_ver == 14.0:
+            path = 'Bin%s' % self.pi.current_dir(hidex86=True)
+            tools += [join(si.VCInstallDir, path)]
+
+        elif self.vs_ver >= 15.0:
+            host_dir = (r'bin\HostX86%s' if self.pi.current_is_x86() else
+                        r'bin\HostX64%s')
+            tools += [join(
+                si.VCInstallDir, host_dir % self.pi.target_dir(x64=True))]
+
+            if self.pi.current_cpu != self.pi.target_cpu:
+                tools += [join(
+                    si.VCInstallDir, host_dir % self.pi.current_dir(x64=True))]
+
+        else:
+            tools += [join(si.VCInstallDir, 'Bin')]
+
+        return tools
+
+    @property
+    def OSLibraries(self):
+        """
+        Microsoft Windows SDK Libraries.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        if self.vs_ver <= 10.0:
+            arch_subdir = self.pi.target_dir(hidex86=True, x64=True)
+            return [join(self.si.WindowsSdkDir, 'Lib%s' % arch_subdir)]
+
+        else:
+            arch_subdir = self.pi.target_dir(x64=True)
+            lib = join(self.si.WindowsSdkDir, 'lib')
+            libver = self._sdk_subdir
+            return [join(lib, '%sum%s' % (libver, arch_subdir))]
+
+    @property
+    def OSIncludes(self):
+        """
+        Microsoft Windows SDK Include.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        include = join(self.si.WindowsSdkDir, 'include')
+
+        if self.vs_ver <= 10.0:
+            return [include, join(include, 'gl')]
+
+        else:
+            if self.vs_ver >= 14.0:
+                sdkver = self._sdk_subdir
+            else:
+                sdkver = ''
+            return [join(include, '%sshared' % sdkver),
+                    join(include, '%sum' % sdkver),
+                    join(include, '%swinrt' % sdkver)]
+
+    @property
+    def OSLibpath(self):
+        """
+        Microsoft Windows SDK Libraries Paths.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        ref = join(self.si.WindowsSdkDir, 'References')
+        libpath = []
+
+        if self.vs_ver <= 9.0:
+            libpath += self.OSLibraries
+
+        if self.vs_ver >= 11.0:
+            libpath += [join(ref, r'CommonConfiguration\Neutral')]
+
+        if self.vs_ver >= 14.0:
+            libpath += [
+                ref,
+                join(self.si.WindowsSdkDir, 'UnionMetadata'),
+                join(
+                    ref, 'Windows.Foundation.UniversalApiContract', '1.0.0.0'),
+                join(ref, 'Windows.Foundation.FoundationContract', '1.0.0.0'),
+                join(
+                    ref, 'Windows.Networking.Connectivity.WwanContract',
+                    '1.0.0.0'),
+                join(
+                    self.si.WindowsSdkDir, 'ExtensionSDKs', 'Microsoft.VCLibs',
+                    '%0.1f' % self.vs_ver, 'References', 'CommonConfiguration',
+                    'neutral'),
+            ]
+        return libpath
+
+    @property
+    def SdkTools(self):
+        """
+        Microsoft Windows SDK Tools.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        return list(self._sdk_tools())
+
+    def _sdk_tools(self):
+        """
+        Microsoft Windows SDK Tools paths generator.
+
+        Return
+        ------
+        generator of str
+            paths
+        """
+        if self.vs_ver < 15.0:
+            bin_dir = 'Bin' if self.vs_ver <= 11.0 else r'Bin\x86'
+            yield join(self.si.WindowsSdkDir, bin_dir)
+
+        if not self.pi.current_is_x86():
+            arch_subdir = self.pi.current_dir(x64=True)
+            path = 'Bin%s' % arch_subdir
+            yield join(self.si.WindowsSdkDir, path)
+
+        if self.vs_ver in (10.0, 11.0):
+            if self.pi.target_is_x86():
+                arch_subdir = ''
+            else:
+                arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
+            path = r'Bin\NETFX 4.0 Tools%s' % arch_subdir
+            yield join(self.si.WindowsSdkDir, path)
+
+        elif self.vs_ver >= 15.0:
+            path = join(self.si.WindowsSdkDir, 'Bin')
+            arch_subdir = self.pi.current_dir(x64=True)
+            sdkver = self.si.WindowsSdkLastVersion
+            yield join(path, '%s%s' % (sdkver, arch_subdir))
+
+        if self.si.WindowsSDKExecutablePath:
+            yield self.si.WindowsSDKExecutablePath
+
+    @property
+    def _sdk_subdir(self):
+        """
+        Microsoft Windows SDK version subdir.
+
+        Return
+        ------
+        str
+            subdir
+        """
+        ucrtver = self.si.WindowsSdkLastVersion
+        return ('%s\\' % ucrtver) if ucrtver else ''
+
+    @property
+    def SdkSetup(self):
+        """
+        Microsoft Windows SDK Setup.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        if self.vs_ver > 9.0:
+            return []
+
+        return [join(self.si.WindowsSdkDir, 'Setup')]
+
+    @property
+    def FxTools(self):
+        """
+        Microsoft .NET Framework Tools.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        pi = self.pi
+        si = self.si
+
+        if self.vs_ver <= 10.0:
+            include32 = True
+            include64 = not pi.target_is_x86() and not pi.current_is_x86()
+        else:
+            include32 = pi.target_is_x86() or pi.current_is_x86()
+            include64 = pi.current_cpu == 'amd64' or pi.target_cpu == 'amd64'
+
+        tools = []
+        if include32:
+            tools += [join(si.FrameworkDir32, ver)
+                      for ver in si.FrameworkVersion32]
+        if include64:
+            tools += [join(si.FrameworkDir64, ver)
+                      for ver in si.FrameworkVersion64]
+        return tools
+
+    @property
+    def NetFxSDKLibraries(self):
+        """
+        Microsoft .Net Framework SDK Libraries.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        if self.vs_ver < 14.0 or not self.si.NetFxSdkDir:
+            return []
+
+        arch_subdir = self.pi.target_dir(x64=True)
+        return [join(self.si.NetFxSdkDir, r'lib\um%s' % arch_subdir)]
+
+    @property
+    def NetFxSDKIncludes(self):
+        """
+        Microsoft .Net Framework SDK Includes.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        if self.vs_ver < 14.0 or not self.si.NetFxSdkDir:
+            return []
+
+        return [join(self.si.NetFxSdkDir, r'include\um')]
+
+    @property
+    def VsTDb(self):
+        """
+        Microsoft Visual Studio Team System Database.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        return [join(self.si.VSInstallDir, r'VSTSDB\Deploy')]
+
+    @property
+    def MSBuild(self):
+        """
+        Microsoft Build Engine.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        if self.vs_ver < 12.0:
+            return []
+        elif self.vs_ver < 15.0:
+            base_path = self.si.ProgramFilesx86
+            arch_subdir = self.pi.current_dir(hidex86=True)
+        else:
+            base_path = self.si.VSInstallDir
+            arch_subdir = ''
+
+        path = r'MSBuild\%0.1f\bin%s' % (self.vs_ver, arch_subdir)
+        build = [join(base_path, path)]
+
+        if self.vs_ver >= 15.0:
+            # Add Roslyn C# & Visual Basic Compiler
+            build += [join(base_path, path, 'Roslyn')]
+
+        return build
+
+    @property
+    def HTMLHelpWorkshop(self):
+        """
+        Microsoft HTML Help Workshop.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        if self.vs_ver < 11.0:
+            return []
+
+        return [join(self.si.ProgramFilesx86, 'HTML Help Workshop')]
+
+    @property
+    def UCRTLibraries(self):
+        """
+        Microsoft Universal C Runtime SDK Libraries.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        if self.vs_ver < 14.0:
+            return []
+
+        arch_subdir = self.pi.target_dir(x64=True)
+        lib = join(self.si.UniversalCRTSdkDir, 'lib')
+        ucrtver = self._ucrt_subdir
+        return [join(lib, '%sucrt%s' % (ucrtver, arch_subdir))]
+
+    @property
+    def UCRTIncludes(self):
+        """
+        Microsoft Universal C Runtime SDK Include.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        if self.vs_ver < 14.0:
+            return []
+
+        include = join(self.si.UniversalCRTSdkDir, 'include')
+        return [join(include, '%sucrt' % self._ucrt_subdir)]
+
+    @property
+    def _ucrt_subdir(self):
+        """
+        Microsoft Universal C Runtime SDK version subdir.
+
+        Return
+        ------
+        str
+            subdir
+        """
+        ucrtver = self.si.UniversalCRTSdkLastVersion
+        return ('%s\\' % ucrtver) if ucrtver else ''
+
+    @property
+    def FSharp(self):
+        """
+        Microsoft Visual F#.
+
+        Return
+        ------
+        list of str
+            paths
+        """
+        if 11.0 > self.vs_ver > 12.0:
+            return []
+
+        return [self.si.FSharpInstallDir]
+
+    @property
+    def VCRuntimeRedist(self):
+        """
+        Microsoft Visual C++ runtime redistributable dll.
+
+        Return
+        ------
+        str
+            path
+        """
+        vcruntime = 'vcruntime%d0.dll' % self.vc_ver
+        arch_subdir = self.pi.target_dir(x64=True).strip('\\')
+
+        # Installation prefixes candidates
+        prefixes = []
+        tools_path = self.si.VCInstallDir
+        redist_path = dirname(tools_path.replace(r'\Tools', r'\Redist'))
+        if isdir(redist_path):
+            # Redist version may not be exactly the same as tools
+            redist_path = join(redist_path, listdir(redist_path)[-1])
+            prefixes += [redist_path, join(redist_path, 'onecore')]
+
+        prefixes += [join(tools_path, 'redist')]  # VS14 legacy path
+
+        # CRT directory
+        crt_dirs = ('Microsoft.VC%d.CRT' % (self.vc_ver * 10),
+                    # Sometime store in directory with VS version instead of VC
+                    'Microsoft.VC%d.CRT' % (int(self.vs_ver) * 10))
+
+        # vcruntime path
+        for prefix, crt_dir in itertools.product(prefixes, crt_dirs):
+            path = join(prefix, arch_subdir, crt_dir, vcruntime)
+            if isfile(path):
+                return path
+
+    def return_env(self, exists=True):
+        """
+        Return environment dict.
+
+        Parameters
+        ----------
+        exists: bool
+            It True, only return existing paths.
+
+        Return
+        ------
+        dict
+            environment
+        """
+        env = dict(
+            include=self._build_paths('include',
+                                      [self.VCIncludes,
+                                       self.OSIncludes,
+                                       self.UCRTIncludes,
+                                       self.NetFxSDKIncludes],
+                                      exists),
+            lib=self._build_paths('lib',
+                                  [self.VCLibraries,
+                                   self.OSLibraries,
+                                   self.FxTools,
+                                   self.UCRTLibraries,
+                                   self.NetFxSDKLibraries],
+                                  exists),
+            libpath=self._build_paths('libpath',
+                                      [self.VCLibraries,
+                                       self.FxTools,
+                                       self.VCStoreRefs,
+                                       self.OSLibpath],
+                                      exists),
+            path=self._build_paths('path',
+                                   [self.VCTools,
+                                    self.VSTools,
+                                    self.VsTDb,
+                                    self.SdkTools,
+                                    self.SdkSetup,
+                                    self.FxTools,
+                                    self.MSBuild,
+                                    self.HTMLHelpWorkshop,
+                                    self.FSharp],
+                                   exists),
+        )
+        if self.vs_ver >= 14 and isfile(self.VCRuntimeRedist):
+            env['py_vcruntime_redist'] = self.VCRuntimeRedist
+        return env
+
+    def _build_paths(self, name, spec_path_lists, exists):
+        """
+        Given an environment variable name and specified paths,
+        return a pathsep-separated string of paths containing
+        unique, extant, directories from those paths and from
+        the environment variable. Raise an error if no paths
+        are resolved.
+
+        Parameters
+        ----------
+        name: str
+            Environment variable name
+        spec_path_lists: list of str
+            Paths
+        exists: bool
+            It True, only return existing paths.
+
+        Return
+        ------
+        str
+            Pathsep-separated paths
+        """
+        # flatten spec_path_lists
+        spec_paths = itertools.chain.from_iterable(spec_path_lists)
+        env_paths = environ.get(name, '').split(pathsep)
+        paths = itertools.chain(spec_paths, env_paths)
+        extant_paths = list(filter(isdir, paths)) if exists else paths
+        if not extant_paths:
+            msg = "%s environment variable is empty" % name.upper()
+            raise distutils.errors.DistutilsPlatformError(msg)
+        unique_paths = self._unique_everseen(extant_paths)
+        return pathsep.join(unique_paths)
+
+    # from Python docs
+    @staticmethod
+    def _unique_everseen(iterable, key=None):
+        """
+        List unique elements, preserving order.
+        Remember all elements ever seen.
+
+        _unique_everseen('AAAABBBCCDAABBB') --> A B C D
+
+        _unique_everseen('ABBCcAD', str.lower) --> A B C D
+        """
+        seen = set()
+        seen_add = seen.add
+        if key is None:
+            for element in filterfalse(seen.__contains__, iterable):
+                seen_add(element)
+                yield element
+        else:
+            for element in iterable:
+                k = key(element)
+                if k not in seen:
+                    seen_add(k)
+                    yield element
diff --git a/myenv/lib/python3.9/site-packages/setuptools/namespaces.py b/myenv/lib/python3.9/site-packages/setuptools/namespaces.py
new file mode 100644
index 0000000..5f403c9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/namespaces.py
@@ -0,0 +1,111 @@
+import os
+from distutils import log
+import itertools
+
+from setuptools.extern.six.moves import map
+
+
+flatten = itertools.chain.from_iterable
+
+
+class Installer:
+
+    nspkg_ext = '-nspkg.pth'
+
+    def install_namespaces(self):
+        nsp = self._get_all_ns_packages()
+        if not nsp:
+            return
+        filename, ext = os.path.splitext(self._get_target())
+        filename += self.nspkg_ext
+        self.outputs.append(filename)
+        log.info("Installing %s", filename)
+        lines = map(self._gen_nspkg_line, nsp)
+
+        if self.dry_run:
+            # always generate the lines, even in dry run
+            list(lines)
+            return
+
+        with open(filename, 'wt') as f:
+            f.writelines(lines)
+
+    def uninstall_namespaces(self):
+        filename, ext = os.path.splitext(self._get_target())
+        filename += self.nspkg_ext
+        if not os.path.exists(filename):
+            return
+        log.info("Removing %s", filename)
+        os.remove(filename)
+
+    def _get_target(self):
+        return self.target
+
+    _nspkg_tmpl = (
+        "import sys, types, os",
+        "has_mfs = sys.version_info > (3, 5)",
+        "p = os.path.join(%(root)s, *%(pth)r)",
+        "importlib = has_mfs and __import__('importlib.util')",
+        "has_mfs and __import__('importlib.machinery')",
+        (
+            "m = has_mfs and "
+            "sys.modules.setdefault(%(pkg)r, "
+            "importlib.util.module_from_spec("
+            "importlib.machinery.PathFinder.find_spec(%(pkg)r, "
+            "[os.path.dirname(p)])))"
+        ),
+        (
+            "m = m or "
+            "sys.modules.setdefault(%(pkg)r, types.ModuleType(%(pkg)r))"
+        ),
+        "mp = (m or []) and m.__dict__.setdefault('__path__',[])",
+        "(p not in mp) and mp.append(p)",
+    )
+    "lines for the namespace installer"
+
+    _nspkg_tmpl_multi = (
+        'm and setattr(sys.modules[%(parent)r], %(child)r, m)',
+    )
+    "additional line(s) when a parent package is indicated"
+
+    def _get_root(self):
+        return "sys._getframe(1).f_locals['sitedir']"
+
+    def _gen_nspkg_line(self, pkg):
+        # ensure pkg is not a unicode string under Python 2.7
+        pkg = str(pkg)
+        pth = tuple(pkg.split('.'))
+        root = self._get_root()
+        tmpl_lines = self._nspkg_tmpl
+        parent, sep, child = pkg.rpartition('.')
+        if parent:
+            tmpl_lines += self._nspkg_tmpl_multi
+        return ';'.join(tmpl_lines) % locals() + '\n'
+
+    def _get_all_ns_packages(self):
+        """Return sorted list of all package namespaces"""
+        pkgs = self.distribution.namespace_packages or []
+        return sorted(flatten(map(self._pkg_names, pkgs)))
+
+    @staticmethod
+    def _pkg_names(pkg):
+        """
+        Given a namespace package, yield the components of that
+        package.
+
+        >>> names = Installer._pkg_names('a.b.c')
+        >>> set(names) == set(['a', 'a.b', 'a.b.c'])
+        True
+        """
+        parts = pkg.split('.')
+        while parts:
+            yield '.'.join(parts)
+            parts.pop()
+
+
+class DevelopInstaller(Installer):
+    def _get_root(self):
+        return repr(str(self.egg_path))
+
+    def _get_target(self):
+        return self.egg_link
diff --git a/myenv/lib/python3.9/site-packages/setuptools/package_index.py b/myenv/lib/python3.9/site-packages/setuptools/package_index.py
new file mode 100644
index 0000000..1702c7c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/package_index.py
@@ -0,0 +1,1140 @@
+"""PyPI and direct package downloading"""
+import sys
+import os
+import re
+import shutil
+import socket
+import base64
+import hashlib
+import itertools
+import warnings
+from functools import wraps
+
+from setuptools.extern import six
+from setuptools.extern.six.moves import urllib, http_client, configparser, map
+
+import setuptools
+from pkg_resources import (
+    CHECKOUT_DIST, Distribution, BINARY_DIST, normalize_path, SOURCE_DIST,
+    Environment, find_distributions, safe_name, safe_version,
+    to_filename, Requirement, DEVELOP_DIST, EGG_DIST,
+)
+from setuptools import ssl_support
+from distutils import log
+from distutils.errors import DistutilsError
+from fnmatch import translate
+from setuptools.py27compat import get_all_headers
+from setuptools.py33compat import unescape
+from setuptools.wheel import Wheel
+
+__metaclass__ = type
+
+EGG_FRAGMENT = re.compile(r'^egg=([-A-Za-z0-9_.+!]+)$')
+HREF = re.compile(r"""href\s*=\s*['"]?([^'"> ]+)""", re.I)
+PYPI_MD5 = re.compile(
+    r'<a href="([^"#]+)">([^<]+)</a>\n\s+\(<a (?:title="MD5 hash"\n\s+)'
+    r'href="[^?]+\?:action=show_md5&amp;digest=([0-9a-f]{32})">md5</a>\)'
+)
+URL_SCHEME = re.compile('([-+.a-z0-9]{2,}):', re.I).match
+EXTENSIONS = ".tar.gz .tar.bz2 .tar .zip .tgz".split()
+
+__all__ = [
+    'PackageIndex', 'distros_for_url', 'parse_bdist_wininst',
+    'interpret_distro_name',
+]
+
+_SOCKET_TIMEOUT = 15
+
+_tmpl = "setuptools/{setuptools.__version__} Python-urllib/{py_major}"
+user_agent = _tmpl.format(
+    py_major='{}.{}'.format(*sys.version_info), setuptools=setuptools)
+
+
+def parse_requirement_arg(spec):
+    try:
+        return Requirement.parse(spec)
+    except ValueError as e:
+        raise DistutilsError(
+            "Not a URL, existing file, or requirement spec: %r" % (spec,)
+        ) from e
+
+
+def parse_bdist_wininst(name):
+    """Return (base,pyversion) or (None,None) for possible .exe name"""
+
+    lower = name.lower()
+    base, py_ver, plat = None, None, None
+
+    if lower.endswith('.exe'):
+        if lower.endswith('.win32.exe'):
+            base = name[:-10]
+            plat = 'win32'
+        elif lower.startswith('.win32-py', -16):
+            py_ver = name[-7:-4]
+            base = name[:-16]
+            plat = 'win32'
+        elif lower.endswith('.win-amd64.exe'):
+            base = name[:-14]
+            plat = 'win-amd64'
+        elif lower.startswith('.win-amd64-py', -20):
+            py_ver = name[-7:-4]
+            base = name[:-20]
+            plat = 'win-amd64'
+    return base, py_ver, plat
+
+
+def egg_info_for_url(url):
+    parts = urllib.parse.urlparse(url)
+    scheme, server, path, parameters, query, fragment = parts
+    base = urllib.parse.unquote(path.split('/')[-1])
+    if server == 'sourceforge.net' and base == 'download':  # XXX Yuck
+        base = urllib.parse.unquote(path.split('/')[-2])
+    if '#' in base:
+        base, fragment = base.split('#', 1)
+    return base, fragment
+
+
+def distros_for_url(url, metadata=None):
+    """Yield egg or source distribution objects that might be found at a URL"""
+    base, fragment = egg_info_for_url(url)
+    for dist in distros_for_location(url, base, metadata):
+        yield dist
+    if fragment:
+        match = EGG_FRAGMENT.match(fragment)
+        if match:
+            for dist in interpret_distro_name(
+                url, match.group(1), metadata, precedence=CHECKOUT_DIST
+            ):
+                yield dist
+
+
+def distros_for_location(location, basename, metadata=None):
+    """Yield egg or source distribution objects based on basename"""
+    if basename.endswith('.egg.zip'):
+        basename = basename[:-4]  # strip the .zip
+    if basename.endswith('.egg') and '-' in basename:
+        # only one, unambiguous interpretation
+        return [Distribution.from_location(location, basename, metadata)]
+    if basename.endswith('.whl') and '-' in basename:
+        wheel = Wheel(basename)
+        if not wheel.is_compatible():
+            return []
+        return [Distribution(
+            location=location,
+            project_name=wheel.project_name,
+            version=wheel.version,
+            # Increase priority over eggs.
+            precedence=EGG_DIST + 1,
+        )]
+    if basename.endswith('.exe'):
+        win_base, py_ver, platform = parse_bdist_wininst(basename)
+        if win_base is not None:
+            return interpret_distro_name(
+                location, win_base, metadata, py_ver, BINARY_DIST, platform
+            )
+    # Try source distro extensions (.zip, .tgz, etc.)
+    #
+    for ext in EXTENSIONS:
+        if basename.endswith(ext):
+            basename = basename[:-len(ext)]
+            return interpret_distro_name(location, basename, metadata)
+    return []  # no extension matched
+
+
+def distros_for_filename(filename, metadata=None):
+    """Yield possible egg or source distribution objects based on a filename"""
+    return distros_for_location(
+        normalize_path(filename), os.path.basename(filename), metadata
+    )
+
+
+def interpret_distro_name(
+        location, basename, metadata, py_version=None, precedence=SOURCE_DIST,
+        platform=None
+):
+    """Generate alternative interpretations of a source distro name
+
+    Note: if `location` is a filesystem filename, you should call
+    ``pkg_resources.normalize_path()`` on it before passing it to this
+    routine!
+    """
+    # Generate alternative interpretations of a source distro name
+    # Because some packages are ambiguous as to name/versions split
+    # e.g. "adns-python-1.1.0", "egenix-mx-commercial", etc.
+    # So, we generate each possible interepretation (e.g. "adns, python-1.1.0"
+    # "adns-python, 1.1.0", and "adns-python-1.1.0, no version").  In practice,
+    # the spurious interpretations should be ignored, because in the event
+    # there's also an "adns" package, the spurious "python-1.1.0" version will
+    # compare lower than any numeric version number, and is therefore unlikely
+    # to match a request for it.  It's still a potential problem, though, and
+    # in the long run PyPI and the distutils should go for "safe" names and
+    # versions in distribution archive names (sdist and bdist).
+
+    parts = basename.split('-')
+    if not py_version and any(re.match(r'py\d\.\d$', p) for p in parts[2:]):
+        # it is a bdist_dumb, not an sdist -- bail out
+        return
+
+    for p in range(1, len(parts) + 1):
+        yield Distribution(
+            location, metadata, '-'.join(parts[:p]), '-'.join(parts[p:]),
+            py_version=py_version, precedence=precedence,
+            platform=platform
+        )
+
+
+# From Python 2.7 docs
+def unique_everseen(iterable, key=None):
+    "List unique elements, preserving order. Remember all elements ever seen."
+    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
+    # unique_everseen('ABBCcAD', str.lower) --> A B C D
+    seen = set()
+    seen_add = seen.add
+    if key is None:
+        for element in six.moves.filterfalse(seen.__contains__, iterable):
+            seen_add(element)
+            yield element
+    else:
+        for element in iterable:
+            k = key(element)
+            if k not in seen:
+                seen_add(k)
+                yield element
+
+
+def unique_values(func):
+    """
+    Wrap a function returning an iterable such that the resulting iterable
+    only ever yields unique items.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return unique_everseen(func(*args, **kwargs))
+
+    return wrapper
+
+
+REL = re.compile(r"""<([^>]*\srel\s*=\s*['"]?([^'">]+)[^>]*)>""", re.I)
+# this line is here to fix emacs' cruddy broken syntax highlighting
+
+
+@unique_values
+def find_external_links(url, page):
+    """Find rel="homepage" and rel="download" links in `page`, yielding URLs"""
+
+    for match in REL.finditer(page):
+        tag, rel = match.groups()
+        rels = set(map(str.strip, rel.lower().split(',')))
+        if 'homepage' in rels or 'download' in rels:
+            for match in HREF.finditer(tag):
+                yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
+
+    for tag in ("<th>Home Page", "<th>Download URL"):
+        pos = page.find(tag)
+        if pos != -1:
+            match = HREF.search(page, pos)
+            if match:
+                yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
+
+
+class ContentChecker:
+    """
+    A null content checker that defines the interface for checking content
+    """
+
+    def feed(self, block):
+        """
+        Feed a block of data to the hash.
+        """
+        return
+
+    def is_valid(self):
+        """
+        Check the hash. Return False if validation fails.
+        """
+        return True
+
+    def report(self, reporter, template):
+        """
+        Call reporter with information about the checker (hash name)
+        substituted into the template.
+        """
+        return
+
+
+class HashChecker(ContentChecker):
+    pattern = re.compile(
+        r'(?P<hash_name>sha1|sha224|sha384|sha256|sha512|md5)='
+        r'(?P<expected>[a-f0-9]+)'
+    )
+
+    def __init__(self, hash_name, expected):
+        self.hash_name = hash_name
+        self.hash = hashlib.new(hash_name)
+        self.expected = expected
+
+    @classmethod
+    def from_url(cls, url):
+        "Construct a (possibly null) ContentChecker from a URL"
+        fragment = urllib.parse.urlparse(url)[-1]
+        if not fragment:
+            return ContentChecker()
+        match = cls.pattern.search(fragment)
+        if not match:
+            return ContentChecker()
+        return cls(**match.groupdict())
+
+    def feed(self, block):
+        self.hash.update(block)
+
+    def is_valid(self):
+        return self.hash.hexdigest() == self.expected
+
+    def report(self, reporter, template):
+        msg = template % self.hash_name
+        return reporter(msg)
+
+
+class PackageIndex(Environment):
+    """A distribution index that scans web pages for download URLs"""
+
+    def __init__(
+            self, index_url="https://pypi.org/simple/", hosts=('*',),
+            ca_bundle=None, verify_ssl=True, *args, **kw
+    ):
+        Environment.__init__(self, *args, **kw)
+        self.index_url = index_url + "/" [:not index_url.endswith('/')]
+        self.scanned_urls = {}
+        self.fetched_urls = {}
+        self.package_pages = {}
+        self.allows = re.compile('|'.join(map(translate, hosts))).match
+        self.to_scan = []
+        use_ssl = (
+            verify_ssl
+            and ssl_support.is_available
+            and (ca_bundle or ssl_support.find_ca_bundle())
+        )
+        if use_ssl:
+            self.opener = ssl_support.opener_for(ca_bundle)
+        else:
+            self.opener = urllib.request.urlopen
+
+    def process_url(self, url, retrieve=False):
+        """Evaluate a URL as a possible download, and maybe retrieve it"""
+        if url in self.scanned_urls and not retrieve:
+            return
+        self.scanned_urls[url] = True
+        if not URL_SCHEME(url):
+            self.process_filename(url)
+            return
+        else:
+            dists = list(distros_for_url(url))
+            if dists:
+                if not self.url_ok(url):
+                    return
+                self.debug("Found link: %s", url)
+
+        if dists or not retrieve or url in self.fetched_urls:
+            list(map(self.add, dists))
+            return  # don't need the actual page
+
+        if not self.url_ok(url):
+            self.fetched_urls[url] = True
+            return
+
+        self.info("Reading %s", url)
+        self.fetched_urls[url] = True  # prevent multiple fetch attempts
+        tmpl = "Download error on %s: %%s -- Some packages may not be found!"
+        f = self.open_url(url, tmpl % url)
+        if f is None:
+            return
+        if isinstance(f, urllib.error.HTTPError) and f.code == 401:
+            self.info("Authentication error: %s" % f.msg)
+        self.fetched_urls[f.url] = True
+        if 'html' not in f.headers.get('content-type', '').lower():
+            f.close()  # not html, we can't process it
+            return
+
+        base = f.url  # handle redirects
+        page = f.read()
+        if not isinstance(page, str):
+            # In Python 3 and got bytes but want str.
+            if isinstance(f, urllib.error.HTTPError):
+                # Errors have no charset, assume latin1:
+                charset = 'latin-1'
+            else:
+                charset = f.headers.get_param('charset') or 'latin-1'
+            page = page.decode(charset, "ignore")
+        f.close()
+        for match in HREF.finditer(page):
+            link = urllib.parse.urljoin(base, htmldecode(match.group(1)))
+            self.process_url(link)
+        if url.startswith(self.index_url) and getattr(f, 'code', None) != 404:
+            page = self.process_index(url, page)
+
+    def process_filename(self, fn, nested=False):
+        # process filenames or directories
+        if not os.path.exists(fn):
+            self.warn("Not found: %s", fn)
+            return
+
+        if os.path.isdir(fn) and not nested:
+            path = os.path.realpath(fn)
+            for item in os.listdir(path):
+                self.process_filename(os.path.join(path, item), True)
+
+        dists = distros_for_filename(fn)
+        if dists:
+            self.debug("Found: %s", fn)
+            list(map(self.add, dists))
+
+    def url_ok(self, url, fatal=False):
+        s = URL_SCHEME(url)
+        is_file = s and s.group(1).lower() == 'file'
+        if is_file or self.allows(urllib.parse.urlparse(url)[1]):
+            return True
+        msg = (
+            "\nNote: Bypassing %s (disallowed host; see "
+            "http://bit.ly/2hrImnY for details).\n")
+        if fatal:
+            raise DistutilsError(msg % url)
+        else:
+            self.warn(msg, url)
+
+    def scan_egg_links(self, search_path):
+        dirs = filter(os.path.isdir, search_path)
+        egg_links = (
+            (path, entry)
+            for path in dirs
+            for entry in os.listdir(path)
+            if entry.endswith('.egg-link')
+        )
+        list(itertools.starmap(self.scan_egg_link, egg_links))
+
+    def scan_egg_link(self, path, entry):
+        with open(os.path.join(path, entry)) as raw_lines:
+            # filter non-empty lines
+            lines = list(filter(None, map(str.strip, raw_lines)))
+
+        if len(lines) != 2:
+            # format is not recognized; punt
+            return
+
+        egg_path, setup_path = lines
+
+        for dist in find_distributions(os.path.join(path, egg_path)):
+            dist.location = os.path.join(path, *lines)
+            dist.precedence = SOURCE_DIST
+            self.add(dist)
+
+    def process_index(self, url, page):
+        """Process the contents of a PyPI page"""
+
+        def scan(link):
+            # Process a URL to see if it's for a package page
+            if link.startswith(self.index_url):
+                parts = list(map(
+                    urllib.parse.unquote, link[len(self.index_url):].split('/')
+                ))
+                if len(parts) == 2 and '#' not in parts[1]:
+                    # it's a package page, sanitize and index it
+                    pkg = safe_name(parts[0])
+                    ver = safe_version(parts[1])
+                    self.package_pages.setdefault(pkg.lower(), {})[link] = True
+                    return to_filename(pkg), to_filename(ver)
+            return None, None
+
+        # process an index page into the package-page index
+        for match in HREF.finditer(page):
+            try:
+                scan(urllib.parse.urljoin(url, htmldecode(match.group(1))))
+            except ValueError:
+                pass
+
+        pkg, ver = scan(url)  # ensure this page is in the page index
+        if pkg:
+            # process individual package page
+            for new_url in find_external_links(url, page):
+                # Process the found URL
+                base, frag = egg_info_for_url(new_url)
+                if base.endswith('.py') and not frag:
+                    if ver:
+                        new_url += '#egg=%s-%s' % (pkg, ver)
+                    else:
+                        self.need_version_info(url)
+                self.scan_url(new_url)
+
+            return PYPI_MD5.sub(
+                lambda m: '<a href="%s#md5=%s">%s</a>' % m.group(1, 3, 2), page
+            )
+        else:
+            return ""  # no sense double-scanning non-package pages
+
+    def need_version_info(self, url):
+        self.scan_all(
+            "Page at %s links to .py file(s) without version info; an index "
+            "scan is required.", url
+        )
+
+    def scan_all(self, msg=None, *args):
+        if self.index_url not in self.fetched_urls:
+            if msg:
+                self.warn(msg, *args)
+            self.info(
+                "Scanning index of all packages (this may take a while)"
+            )
+        self.scan_url(self.index_url)
+
+    def find_packages(self, requirement):
+        self.scan_url(self.index_url + requirement.unsafe_name + '/')
+
+        if not self.package_pages.get(requirement.key):
+            # Fall back to safe version of the name
+            self.scan_url(self.index_url + requirement.project_name + '/')
+
+        if not self.package_pages.get(requirement.key):
+            # We couldn't find the target package, so search the index page too
+            self.not_found_in_index(requirement)
+
+        for url in list(self.package_pages.get(requirement.key, ())):
+            # scan each page that might be related to the desired package
+            self.scan_url(url)
+
+    def obtain(self, requirement, installer=None):
+        self.prescan()
+        self.find_packages(requirement)
+        for dist in self[requirement.key]:
+            if dist in requirement:
+                return dist
+            self.debug("%s does not match %s", requirement, dist)
+        return super(PackageIndex, self).obtain(requirement, installer)
+
+    def check_hash(self, checker, filename, tfp):
+        """
+        checker is a ContentChecker
+        """
+        checker.report(
+            self.debug,
+            "Validating %%s checksum for %s" % filename)
+        if not checker.is_valid():
+            tfp.close()
+            os.unlink(filename)
+            raise DistutilsError(
+                "%s validation failed for %s; "
+                "possible download problem?"
+                % (checker.hash.name, os.path.basename(filename))
+            )
+
+    def add_find_links(self, urls):
+        """Add `urls` to the list that will be prescanned for searches"""
+        for url in urls:
+            if (
+                self.to_scan is None  # if we have already "gone online"
+                or not URL_SCHEME(url)  # or it's a local file/directory
+                or url.startswith('file:')
+                or list(distros_for_url(url))  # or a direct package link
+            ):
+                # then go ahead and process it now
+                self.scan_url(url)
+            else:
+                # otherwise, defer retrieval till later
+                self.to_scan.append(url)
+
+    def prescan(self):
+        """Scan urls scheduled for prescanning (e.g. --find-links)"""
+        if self.to_scan:
+            list(map(self.scan_url, self.to_scan))
+        self.to_scan = None  # from now on, go ahead and process immediately
+
+    def not_found_in_index(self, requirement):
+        if self[requirement.key]:  # we've seen at least one distro
+            meth, msg = self.info, "Couldn't retrieve index page for %r"
+        else:  # no distros seen for this name, might be misspelled
+            meth, msg = (
+                self.warn,
+                "Couldn't find index page for %r (maybe misspelled?)")
+        meth(msg, requirement.unsafe_name)
+        self.scan_all()
+
+    def download(self, spec, tmpdir):
+        """Locate and/or download `spec` to `tmpdir`, returning a local path
+
+        `spec` may be a ``Requirement`` object, or a string containing a URL,
+        an existing local filename, or a project/version requirement spec
+        (i.e. the string form of a ``Requirement`` object).  If it is the URL
+        of a .py file with an unambiguous ``#egg=name-version`` tag (i.e., one
+        that escapes ``-`` as ``_`` throughout), a trivial ``setup.py`` is
+        automatically created alongside the downloaded file.
+
+        If `spec` is a ``Requirement`` object or a string containing a
+        project/version requirement spec, this method returns the location of
+        a matching distribution (possibly after downloading it to `tmpdir`).
+        If `spec` is a locally existing file or directory name, it is simply
+        returned unchanged.  If `spec` is a URL, it is downloaded to a subpath
+        of `tmpdir`, and the local filename is returned.  Various errors may be
+        raised if a problem occurs during downloading.
+        """
+        if not isinstance(spec, Requirement):
+            scheme = URL_SCHEME(spec)
+            if scheme:
+                # It's a url, download it to tmpdir
+                found = self._download_url(scheme.group(1), spec, tmpdir)
+                base, fragment = egg_info_for_url(spec)
+                if base.endswith('.py'):
+                    found = self.gen_setup(found, fragment, tmpdir)
+                return found
+            elif os.path.exists(spec):
+                # Existing file or directory, just return it
+                return spec
+            else:
+                spec = parse_requirement_arg(spec)
+        return getattr(self.fetch_distribution(spec, tmpdir), 'location', None)
+
+    def fetch_distribution(
+            self, requirement, tmpdir, force_scan=False, source=False,
+            develop_ok=False, local_index=None):
+        """Obtain a distribution suitable for fulfilling `requirement`
+
+        `requirement` must be a ``pkg_resources.Requirement`` instance.
+        If necessary, or if the `force_scan` flag is set, the requirement is
+        searched for in the (online) package index as well as the locally
+        installed packages.  If a distribution matching `requirement` is found,
+        the returned distribution's ``location`` is the value you would have
+        gotten from calling the ``download()`` method with the matching
+        distribution's URL or filename.  If no matching distribution is found,
+        ``None`` is returned.
+
+        If the `source` flag is set, only source distributions and source
+        checkout links will be considered.  Unless the `develop_ok` flag is
+        set, development and system eggs (i.e., those using the ``.egg-info``
+        format) will be ignored.
+        """
+        # process a Requirement
+        self.info("Searching for %s", requirement)
+        skipped = {}
+        dist = None
+
+        def find(req, env=None):
+            if env is None:
+                env = self
+            # Find a matching distribution; may be called more than once
+
+            for dist in env[req.key]:
+
+                if dist.precedence == DEVELOP_DIST and not develop_ok:
+                    if dist not in skipped:
+                        self.warn(
+                            "Skipping development or system egg: %s", dist,
+                        )
+                        skipped[dist] = 1
+                    continue
+
+                test = (
+                    dist in req
+                    and (dist.precedence <= SOURCE_DIST or not source)
+                )
+                if test:
+                    loc = self.download(dist.location, tmpdir)
+                    dist.download_location = loc
+                    if os.path.exists(dist.download_location):
+                        return dist
+
+        if force_scan:
+            self.prescan()
+            self.find_packages(requirement)
+            dist = find(requirement)
+
+        if not dist and local_index is not None:
+            dist = find(requirement, local_index)
+
+        if dist is None:
+            if self.to_scan is not None:
+                self.prescan()
+            dist = find(requirement)
+
+        if dist is None and not force_scan:
+            self.find_packages(requirement)
+            dist = find(requirement)
+
+        if dist is None:
+            self.warn(
+                "No local packages or working download links found for %s%s",
+                (source and "a source distribution of " or ""),
+                requirement,
+            )
+        else:
+            self.info("Best match: %s", dist)
+            return dist.clone(location=dist.download_location)
+
+    def fetch(self, requirement, tmpdir, force_scan=False, source=False):
+        """Obtain a file suitable for fulfilling `requirement`
+
+        DEPRECATED; use the ``fetch_distribution()`` method now instead.  For
+        backward compatibility, this routine is identical but returns the
+        ``location`` of the downloaded distribution instead of a distribution
+        object.
+        """
+        dist = self.fetch_distribution(requirement, tmpdir, force_scan, source)
+        if dist is not None:
+            return dist.location
+        return None
+
+    def gen_setup(self, filename, fragment, tmpdir):
+        match = EGG_FRAGMENT.match(fragment)
+        dists = match and [
+            d for d in
+            interpret_distro_name(filename, match.group(1), None) if d.version
+        ] or []
+
+        if len(dists) == 1:  # unambiguous ``#egg`` fragment
+            basename = os.path.basename(filename)
+
+            # Make sure the file has been downloaded to the temp dir.
+            if os.path.dirname(filename) != tmpdir:
+                dst = os.path.join(tmpdir, basename)
+                from setuptools.command.easy_install import samefile
+                if not samefile(filename, dst):
+                    shutil.copy2(filename, dst)
+                    filename = dst
+
+            with open(os.path.join(tmpdir, 'setup.py'), 'w') as file:
+                file.write(
+                    "from setuptools import setup\n"
+                    "setup(name=%r, version=%r, py_modules=[%r])\n"
+                    % (
+                        dists[0].project_name, dists[0].version,
+                        os.path.splitext(basename)[0]
+                    )
+                )
+            return filename
+
+        elif match:
+            raise DistutilsError(
+                "Can't unambiguously interpret project/version identifier %r; "
+                "any dashes in the name or version should be escaped using "
+                "underscores. %r" % (fragment, dists)
+            )
+        else:
+            raise DistutilsError(
+                "Can't process plain .py files without an '#egg=name-version'"
+                " suffix to enable automatic setup script generation."
+            )
+
+    dl_blocksize = 8192
+
+    def _download_to(self, url, filename):
+        self.info("Downloading %s", url)
+        # Download the file
+        fp = None
+        try:
+            checker = HashChecker.from_url(url)
+            fp = self.open_url(url)
+            if isinstance(fp, urllib.error.HTTPError):
+                raise DistutilsError(
+                    "Can't download %s: %s %s" % (url, fp.code, fp.msg)
+                )
+            headers = fp.info()
+            blocknum = 0
+            bs = self.dl_blocksize
+            size = -1
+            if "content-length" in headers:
+                # Some servers return multiple Content-Length headers :(
+                sizes = get_all_headers(headers, 'Content-Length')
+                size = max(map(int, sizes))
+                self.reporthook(url, filename, blocknum, bs, size)
+            with open(filename, 'wb') as tfp:
+                while True:
+                    block = fp.read(bs)
+                    if block:
+                        checker.feed(block)
+                        tfp.write(block)
+                        blocknum += 1
+                        self.reporthook(url, filename, blocknum, bs, size)
+                    else:
+                        break
+                self.check_hash(checker, filename, tfp)
+            return headers
+        finally:
+            if fp:
+                fp.close()
+
+    def reporthook(self, url, filename, blocknum, blksize, size):
+        pass  # no-op
+
+    def open_url(self, url, warning=None):
+        if url.startswith('file:'):
+            return local_open(url)
+        try:
+            return open_with_auth(url, self.opener)
+        except (ValueError, http_client.InvalidURL) as v:
+            msg = ' '.join([str(arg) for arg in v.args])
+            if warning:
+                self.warn(warning, msg)
+            else:
+                raise DistutilsError('%s %s' % (url, msg)) from v
+        except urllib.error.HTTPError as v:
+            return v
+        except urllib.error.URLError as v:
+            if warning:
+                self.warn(warning, v.reason)
+            else:
+                raise DistutilsError("Download error for %s: %s"
+                                     % (url, v.reason)) from v
+        except http_client.BadStatusLine as v:
+            if warning:
+                self.warn(warning, v.line)
+            else:
+                raise DistutilsError(
+                    '%s returned a bad status line. The server might be '
+                    'down, %s' %
+                    (url, v.line)
+                ) from v
+        except (http_client.HTTPException, socket.error) as v:
+            if warning:
+                self.warn(warning, v)
+            else:
+                raise DistutilsError("Download error for %s: %s"
+                                     % (url, v)) from v
+
+    def _download_url(self, scheme, url, tmpdir):
+        # Determine download filename
+        #
+        name, fragment = egg_info_for_url(url)
+        if name:
+            while '..' in name:
+                name = name.replace('..', '.').replace('\\', '_')
+        else:
+            name = "__downloaded__"  # default if URL has no path contents
+
+        if name.endswith('.egg.zip'):
+            name = name[:-4]  # strip the extra .zip before download
+
+        filename = os.path.join(tmpdir, name)
+
+        # Download the file
+        #
+        if scheme == 'svn' or scheme.startswith('svn+'):
+            return self._download_svn(url, filename)
+        elif scheme == 'git' or scheme.startswith('git+'):
+            return self._download_git(url, filename)
+        elif scheme.startswith('hg+'):
+            return self._download_hg(url, filename)
+        elif scheme == 'file':
+            return urllib.request.url2pathname(urllib.parse.urlparse(url)[2])
+        else:
+            self.url_ok(url, True)  # raises error if not allowed
+            return self._attempt_download(url, filename)
+
+    def scan_url(self, url):
+        self.process_url(url, True)
+
+    def _attempt_download(self, url, filename):
+        headers = self._download_to(url, filename)
+        if 'html' in headers.get('content-type', '').lower():
+            return self._download_html(url, headers, filename)
+        else:
+            return filename
+
+    def _download_html(self, url, headers, filename):
+        file = open(filename)
+        for line in file:
+            if line.strip():
+                # Check for a subversion index page
+                if re.search(r'<title>([^- ]+ - )?Revision \d+:', line):
+                    # it's a subversion index page:
+                    file.close()
+                    os.unlink(filename)
+                    return self._download_svn(url, filename)
+                break  # not an index page
+        file.close()
+        os.unlink(filename)
+        raise DistutilsError("Unexpected HTML page found at " + url)
+
+    def _download_svn(self, url, filename):
+        warnings.warn("SVN download support is deprecated", UserWarning)
+        url = url.split('#', 1)[0]  # remove any fragment for svn's sake
+        creds = ''
+        if url.lower().startswith('svn:') and '@' in url:
+            scheme, netloc, path, p, q, f = urllib.parse.urlparse(url)
+            if not netloc and path.startswith('//') and '/' in path[2:]:
+                netloc, path = path[2:].split('/', 1)
+                auth, host = _splituser(netloc)
+                if auth:
+                    if ':' in auth:
+                        user, pw = auth.split(':', 1)
+                        creds = " --username=%s --password=%s" % (user, pw)
+                    else:
+                        creds = " --username=" + auth
+                    netloc = host
+                    parts = scheme, netloc, url, p, q, f
+                    url = urllib.parse.urlunparse(parts)
+        self.info("Doing subversion checkout from %s to %s", url, filename)
+        os.system("svn checkout%s -q %s %s" % (creds, url, filename))
+        return filename
+
+    @staticmethod
+    def _vcs_split_rev_from_url(url, pop_prefix=False):
+        scheme, netloc, path, query, frag = urllib.parse.urlsplit(url)
+
+        scheme = scheme.split('+', 1)[-1]
+
+        # Some fragment identification fails
+        path = path.split('#', 1)[0]
+
+        rev = None
+        if '@' in path:
+            path, rev = path.rsplit('@', 1)
+
+        # Also, discard fragment
+        url = urllib.parse.urlunsplit((scheme, netloc, path, query, ''))
+
+        return url, rev
+
+    def _download_git(self, url, filename):
+        filename = filename.split('#', 1)[0]
+        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)
+
+        self.info("Doing git clone from %s to %s", url, filename)
+        os.system("git clone --quiet %s %s" % (url, filename))
+
+        if rev is not None:
+            self.info("Checking out %s", rev)
+            os.system("git -C %s checkout --quiet %s" % (
+                filename,
+                rev,
+            ))
+
+        return filename
+
+    def _download_hg(self, url, filename):
+        filename = filename.split('#', 1)[0]
+        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)
+
+        self.info("Doing hg clone from %s to %s", url, filename)
+        os.system("hg clone --quiet %s %s" % (url, filename))
+
+        if rev is not None:
+            self.info("Updating to %s", rev)
+            os.system("hg --cwd %s up -C -r %s -q" % (
+                filename,
+                rev,
+            ))
+
+        return filename
+
+    def debug(self, msg, *args):
+        log.debug(msg, *args)
+
+    def info(self, msg, *args):
+        log.info(msg, *args)
+
+    def warn(self, msg, *args):
+        log.warn(msg, *args)
+
+
+# This pattern matches a character entity reference (a decimal numeric
+# references, a hexadecimal numeric reference, or a named reference).
+entity_sub = re.compile(r'&(#(\d+|x[\da-fA-F]+)|[\w.:-]+);?').sub
+
+
+def decode_entity(match):
+    what = match.group(0)
+    return unescape(what)
+
+
+def htmldecode(text):
+    """
+    Decode HTML entities in the given text.
+
+    >>> htmldecode(
+    ...     'https://../package_name-0.1.2.tar.gz'
+    ...     '?tokena=A&amp;tokenb=B">package_name-0.1.2.tar.gz')
+    'https://../package_name-0.1.2.tar.gz?tokena=A&tokenb=B">package_name-0.1.2.tar.gz'
+    """
+    return entity_sub(decode_entity, text)
+
+
+def socket_timeout(timeout=15):
+    def _socket_timeout(func):
+        def _socket_timeout(*args, **kwargs):
+            old_timeout = socket.getdefaulttimeout()
+            socket.setdefaulttimeout(timeout)
+            try:
+                return func(*args, **kwargs)
+            finally:
+                socket.setdefaulttimeout(old_timeout)
+
+        return _socket_timeout
+
+    return _socket_timeout
+
+
+def _encode_auth(auth):
+    """
+    A function compatible with Python 2.3-3.3 that will encode
+    auth from a URL suitable for an HTTP header.
+    >>> str(_encode_auth('username%3Apassword'))
+    'dXNlcm5hbWU6cGFzc3dvcmQ='
+
+    Long auth strings should not cause a newline to be inserted.
+    >>> long_auth = 'username:' + 'password'*10
+    >>> chr(10) in str(_encode_auth(long_auth))
+    False
+    """
+    auth_s = urllib.parse.unquote(auth)
+    # convert to bytes
+    auth_bytes = auth_s.encode()
+    encoded_bytes = base64.b64encode(auth_bytes)
+    # convert back to a string
+    encoded = encoded_bytes.decode()
+    # strip the trailing carriage return
+    return encoded.replace('\n', '')
+
+
+class Credential:
+    """
+    A username/password pair. Use like a namedtuple.
+    """
+
+    def __init__(self, username, password):
+        self.username = username
+        self.password = password
+
+    def __iter__(self):
+        yield self.username
+        yield self.password
+
+    def __str__(self):
+        return '%(username)s:%(password)s' % vars(self)
+
+
+class PyPIConfig(configparser.RawConfigParser):
+    def __init__(self):
+        """
+        Load from ~/.pypirc
+        """
+        defaults = dict.fromkeys(['username', 'password', 'repository'], '')
+        configparser.RawConfigParser.__init__(self, defaults)
+
+        rc = os.path.join(os.path.expanduser('~'), '.pypirc')
+        if os.path.exists(rc):
+            self.read(rc)
+
+    @property
+    def creds_by_repository(self):
+        sections_with_repositories = [
+            section for section in self.sections()
+            if self.get(section, 'repository').strip()
+        ]
+
+        return dict(map(self._get_repo_cred, sections_with_repositories))
+
+    def _get_repo_cred(self, section):
+        repo = self.get(section, 'repository').strip()
+        return repo, Credential(
+            self.get(section, 'username').strip(),
+            self.get(section, 'password').strip(),
+        )
+
+    def find_credential(self, url):
+        """
+        If the URL indicated appears to be a repository defined in this
+        config, return the credential for that repository.
+        """
+        for repository, cred in self.creds_by_repository.items():
+            if url.startswith(repository):
+                return cred
+
+
+def open_with_auth(url, opener=urllib.request.urlopen):
+    """Open a urllib2 request, handling HTTP authentication"""
+
+    parsed = urllib.parse.urlparse(url)
+    scheme, netloc, path, params, query, frag = parsed
+
+    # Double scheme does not raise on macOS as revealed by a
+    # failing test. We would expect "nonnumeric port". Refs #20.
+    if netloc.endswith(':'):
+        raise http_client.InvalidURL("nonnumeric port: ''")
+
+    if scheme in ('http', 'https'):
+        auth, address = _splituser(netloc)
+    else:
+        auth = None
+
+    if not auth:
+        cred = PyPIConfig().find_credential(url)
+        if cred:
+            auth = str(cred)
+            info = cred.username, url
+            log.info('Authenticating as %s for %s (from .pypirc)', *info)
+
+    if auth:
+        auth = "Basic " + _encode_auth(auth)
+        parts = scheme, address, path, params, query, frag
+        new_url = urllib.parse.urlunparse(parts)
+        request = urllib.request.Request(new_url)
+        request.add_header("Authorization", auth)
+    else:
+        request = urllib.request.Request(url)
+
+    request.add_header('User-Agent', user_agent)
+    fp = opener(request)
+
+    if auth:
+        # Put authentication info back into request URL if same host,
+        # so that links found on the page will work
+        s2, h2, path2, param2, query2, frag2 = urllib.parse.urlparse(fp.url)
+        if s2 == scheme and h2 == address:
+            parts = s2, netloc, path2, param2, query2, frag2
+            fp.url = urllib.parse.urlunparse(parts)
+
+    return fp
+
+
+# copy of urllib.parse._splituser from Python 3.8
+def _splituser(host):
+    """splituser('user[:passwd]@host[:port]')
+    --> 'user[:passwd]', 'host[:port]'."""
+    user, delim, host = host.rpartition('@')
+    return (user if delim else None), host
+
+
+# adding a timeout to avoid freezing package_index
+open_with_auth = socket_timeout(_SOCKET_TIMEOUT)(open_with_auth)
+
+
+def fix_sf_url(url):
+    return url  # backward compatibility
+
+
+def local_open(url):
+    """Read a local path, with special support for directories"""
+    scheme, server, path, param, query, frag = urllib.parse.urlparse(url)
+    filename = urllib.request.url2pathname(path)
+    if os.path.isfile(filename):
+        return urllib.request.urlopen(url)
+    elif path.endswith('/') and os.path.isdir(filename):
+        files = []
+        for f in os.listdir(filename):
+            filepath = os.path.join(filename, f)
+            if f == 'index.html':
+                with open(filepath, 'r') as fp:
+                    body = fp.read()
+                break
+            elif os.path.isdir(filepath):
+                f += '/'
+            files.append('<a href="{name}">{name}</a>'.format(name=f))
+        else:
+            tmpl = (
+                "<html><head><title>{url}</title>"
+                "</head><body>{files}</body></html>")
+            body = tmpl.format(url=url, files='\n'.join(files))
+        status, message = 200, "OK"
+    else:
+        status, message, body = 404, "Path not found", "Not found"
+
+    headers = {'content-type': 'text/html'}
+    body_stream = six.StringIO(body)
+    return urllib.error.HTTPError(url, status, message, headers, body_stream)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/py27compat.py b/myenv/lib/python3.9/site-packages/setuptools/py27compat.py
new file mode 100644
index 0000000..ba39af5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/py27compat.py
@@ -0,0 +1,60 @@
+"""
+Compatibility Support for Python 2.7 and earlier
+"""
+
+import sys
+import platform
+
+from setuptools.extern import six
+
+
+def get_all_headers(message, key):
+    """
+    Given an HTTPMessage, return all headers matching a given key.
+    """
+    return message.get_all(key)
+
+
+if six.PY2:
+    def get_all_headers(message, key):  # noqa
+        return message.getheaders(key)
+
+
+linux_py2_ascii = (
+    platform.system() == 'Linux' and
+    six.PY2
+)
+
+rmtree_safe = str if linux_py2_ascii else lambda x: x
+"""Workaround for http://bugs.python.org/issue24672"""
+
+
+try:
+    from ._imp import find_module, PY_COMPILED, PY_FROZEN, PY_SOURCE
+    from ._imp import get_frozen_object, get_module
+except ImportError:
+    import imp
+    from imp import PY_COMPILED, PY_FROZEN, PY_SOURCE  # noqa
+
+    def find_module(module, paths=None):
+        """Just like 'imp.find_module()', but with package support"""
+        parts = module.split('.')
+        while parts:
+            part = parts.pop(0)
+            f, path, (suffix, mode, kind) = info = imp.find_module(part, paths)
+
+            if kind == imp.PKG_DIRECTORY:
+                parts = parts or ['__init__']
+                paths = [path]
+
+            elif parts:
+                raise ImportError("Can't find %r in %s" % (parts, module))
+
+        return info
+
+    def get_frozen_object(module, paths):
+        return imp.get_frozen_object(module)
+
+    def get_module(module, paths, info):
+        imp.load_module(module, *info)
+        return sys.modules[module]
diff --git a/myenv/lib/python3.9/site-packages/setuptools/py31compat.py b/myenv/lib/python3.9/site-packages/setuptools/py31compat.py
new file mode 100644
index 0000000..e1da7ee
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/py31compat.py
@@ -0,0 +1,32 @@
+__all__ = []
+
+__metaclass__ = type
+
+
+try:
+    # Python >=3.2
+    from tempfile import TemporaryDirectory
+except ImportError:
+    import shutil
+    import tempfile
+
+    class TemporaryDirectory:
+        """
+        Very simple temporary directory context manager.
+        Will try to delete afterward, but will also ignore OS and similar
+        errors on deletion.
+        """
+
+        def __init__(self, **kwargs):
+            self.name = None  # Handle mkdtemp raising an exception
+            self.name = tempfile.mkdtemp(**kwargs)
+
+        def __enter__(self):
+            return self.name
+
+        def __exit__(self, exctype, excvalue, exctrace):
+            try:
+                shutil.rmtree(self.name, True)
+            except OSError:  # removal errors are not the only possible
+                pass
+            self.name = None
diff --git a/myenv/lib/python3.9/site-packages/setuptools/py33compat.py b/myenv/lib/python3.9/site-packages/setuptools/py33compat.py
new file mode 100644
index 0000000..cb69443
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/py33compat.py
@@ -0,0 +1,59 @@
+import dis
+import array
+import collections
+
+try:
+    import html
+except ImportError:
+    html = None
+
+from setuptools.extern import six
+from setuptools.extern.six.moves import html_parser
+
+__metaclass__ = type
+
+OpArg = collections.namedtuple('OpArg', 'opcode arg')
+
+
+class Bytecode_compat:
+    def __init__(self, code):
+        self.code = code
+
+    def __iter__(self):
+        """Yield '(op,arg)' pair for each operation in code object 'code'"""
+
+        bytes = array.array('b', self.code.co_code)
+        eof = len(self.code.co_code)
+
+        ptr = 0
+        extended_arg = 0
+
+        while ptr < eof:
+
+            op = bytes[ptr]
+
+            if op >= dis.HAVE_ARGUMENT:
+
+                arg = bytes[ptr + 1] + bytes[ptr + 2] * 256 + extended_arg
+                ptr += 3
+
+                if op == dis.EXTENDED_ARG:
+                    long_type = six.integer_types[-1]
+                    extended_arg = arg * long_type(65536)
+                    continue
+
+            else:
+                arg = None
+                ptr += 1
+
+            yield OpArg(op, arg)
+
+
+Bytecode = getattr(dis, 'Bytecode', Bytecode_compat)
+
+
+unescape = getattr(html, 'unescape', None)
+if unescape is None:
+    # HTMLParser.unescape is deprecated since Python 3.4, and will be removed
+    # from 3.9.
+    unescape = html_parser.HTMLParser().unescape
diff --git a/myenv/lib/python3.9/site-packages/setuptools/py34compat.py b/myenv/lib/python3.9/site-packages/setuptools/py34compat.py
new file mode 100644
index 0000000..3ad9172
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/py34compat.py
@@ -0,0 +1,13 @@
+import importlib
+
+try:
+    import importlib.util
+except ImportError:
+    pass
+
+
+try:
+    module_from_spec = importlib.util.module_from_spec
+except AttributeError:
+    def module_from_spec(spec):
+        return spec.loader.load_module(spec.name)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/sandbox.py b/myenv/lib/python3.9/site-packages/setuptools/sandbox.py
new file mode 100644
index 0000000..93ae8eb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/sandbox.py
@@ -0,0 +1,492 @@
+import os
+import sys
+import tempfile
+import operator
+import functools
+import itertools
+import re
+import contextlib
+import pickle
+import textwrap
+
+from setuptools.extern import six
+from setuptools.extern.six.moves import builtins, map
+
+import pkg_resources
+from distutils.errors import DistutilsError
+from pkg_resources import working_set
+
+if sys.platform.startswith('java'):
+    import org.python.modules.posix.PosixModule as _os
+else:
+    _os = sys.modules[os.name]
+try:
+    _file = file
+except NameError:
+    _file = None
+_open = open
+
+
+__all__ = [
+    "AbstractSandbox", "DirectorySandbox", "SandboxViolation", "run_setup",
+]
+
+
+def _execfile(filename, globals, locals=None):
+    """
+    Python 3 implementation of execfile.
+    """
+    mode = 'rb'
+    with open(filename, mode) as stream:
+        script = stream.read()
+    if locals is None:
+        locals = globals
+    code = compile(script, filename, 'exec')
+    exec(code, globals, locals)
+
+
+@contextlib.contextmanager
+def save_argv(repl=None):
+    saved = sys.argv[:]
+    if repl is not None:
+        sys.argv[:] = repl
+    try:
+        yield saved
+    finally:
+        sys.argv[:] = saved
+
+
+@contextlib.contextmanager
+def save_path():
+    saved = sys.path[:]
+    try:
+        yield saved
+    finally:
+        sys.path[:] = saved
+
+
+@contextlib.contextmanager
+def override_temp(replacement):
+    """
+    Monkey-patch tempfile.tempdir with replacement, ensuring it exists
+    """
+    os.makedirs(replacement, exist_ok=True)
+
+    saved = tempfile.tempdir
+
+    tempfile.tempdir = replacement
+
+    try:
+        yield
+    finally:
+        tempfile.tempdir = saved
+
+
+@contextlib.contextmanager
+def pushd(target):
+    saved = os.getcwd()
+    os.chdir(target)
+    try:
+        yield saved
+    finally:
+        os.chdir(saved)
+
+
+class UnpickleableException(Exception):
+    """
+    An exception representing another Exception that could not be pickled.
+    """
+
+    @staticmethod
+    def dump(type, exc):
+        """
+        Always return a dumped (pickled) type and exc. If exc can't be pickled,
+        wrap it in UnpickleableException first.
+        """
+        try:
+            return pickle.dumps(type), pickle.dumps(exc)
+        except Exception:
+            # get UnpickleableException inside the sandbox
+            from setuptools.sandbox import UnpickleableException as cls
+            return cls.dump(cls, cls(repr(exc)))
+
+
+class ExceptionSaver:
+    """
+    A Context Manager that will save an exception, serialized, and restore it
+    later.
+    """
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, exc, tb):
+        if not exc:
+            return
+
+        # dump the exception
+        self._saved = UnpickleableException.dump(type, exc)
+        self._tb = tb
+
+        # suppress the exception
+        return True
+
+    def resume(self):
+        "restore and re-raise any exception"
+
+        if '_saved' not in vars(self):
+            return
+
+        type, exc = map(pickle.loads, self._saved)
+        six.reraise(type, exc, self._tb)
+
+
+@contextlib.contextmanager
+def save_modules():
+    """
+    Context in which imported modules are saved.
+
+    Translates exceptions internal to the context into the equivalent exception
+    outside the context.
+    """
+    saved = sys.modules.copy()
+    with ExceptionSaver() as saved_exc:
+        yield saved
+
+    sys.modules.update(saved)
+    # remove any modules imported since
+    del_modules = (
+        mod_name for mod_name in sys.modules
+        if mod_name not in saved
+        # exclude any encodings modules. See #285
+        and not mod_name.startswith('encodings.')
+    )
+    _clear_modules(del_modules)
+
+    saved_exc.resume()
+
+
+def _clear_modules(module_names):
+    for mod_name in list(module_names):
+        del sys.modules[mod_name]
+
+
+@contextlib.contextmanager
+def save_pkg_resources_state():
+    saved = pkg_resources.__getstate__()
+    try:
+        yield saved
+    finally:
+        pkg_resources.__setstate__(saved)
+
+
+@contextlib.contextmanager
+def setup_context(setup_dir):
+    temp_dir = os.path.join(setup_dir, 'temp')
+    with save_pkg_resources_state():
+        with save_modules():
+            hide_setuptools()
+            with save_path():
+                with save_argv():
+                    with override_temp(temp_dir):
+                        with pushd(setup_dir):
+                            # ensure setuptools commands are available
+                            __import__('setuptools')
+                            yield
+
+
+def _needs_hiding(mod_name):
+    """
+    >>> _needs_hiding('setuptools')
+    True
+    >>> _needs_hiding('pkg_resources')
+    True
+    >>> _needs_hiding('setuptools_plugin')
+    False
+    >>> _needs_hiding('setuptools.__init__')
+    True
+    >>> _needs_hiding('distutils')
+    True
+    >>> _needs_hiding('os')
+    False
+    >>> _needs_hiding('Cython')
+    True
+    """
+    pattern = re.compile(r'(setuptools|pkg_resources|distutils|Cython)(\.|$)')
+    return bool(pattern.match(mod_name))
+
+
+def hide_setuptools():
+    """
+    Remove references to setuptools' modules from sys.modules to allow the
+    invocation to import the most appropriate setuptools. This technique is
+    necessary to avoid issues such as #315 where setuptools upgrading itself
+    would fail to find a function declared in the metadata.
+    """
+    modules = filter(_needs_hiding, sys.modules)
+    _clear_modules(modules)
+
+
+def run_setup(setup_script, args):
+    """Run a distutils setup script, sandboxed in its directory"""
+    setup_dir = os.path.abspath(os.path.dirname(setup_script))
+    with setup_context(setup_dir):
+        try:
+            sys.argv[:] = [setup_script] + list(args)
+            sys.path.insert(0, setup_dir)
+            # reset to include setup dir, w/clean callback list
+            working_set.__init__()
+            working_set.callbacks.append(lambda dist: dist.activate())
+
+            # __file__ should be a byte string on Python 2 (#712)
+            dunder_file = (
+                setup_script
+                if isinstance(setup_script, str) else
+                setup_script.encode(sys.getfilesystemencoding())
+            )
+
+            with DirectorySandbox(setup_dir):
+                ns = dict(__file__=dunder_file, __name__='__main__')
+                _execfile(setup_script, ns)
+        except SystemExit as v:
+            if v.args and v.args[0]:
+                raise
+            # Normal exit, just return
+
+
+class AbstractSandbox:
+    """Wrap 'os' module and 'open()' builtin for virtualizing setup scripts"""
+
+    _active = False
+
+    def __init__(self):
+        self._attrs = [
+            name for name in dir(_os)
+            if not name.startswith('_') and hasattr(self, name)
+        ]
+
+    def _copy(self, source):
+        for name in self._attrs:
+            setattr(os, name, getattr(source, name))
+
+    def __enter__(self):
+        self._copy(self)
+        if _file:
+            builtins.file = self._file
+        builtins.open = self._open
+        self._active = True
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._active = False
+        if _file:
+            builtins.file = _file
+        builtins.open = _open
+        self._copy(_os)
+
+    def run(self, func):
+        """Run 'func' under os sandboxing"""
+        with self:
+            return func()
+
+    def _mk_dual_path_wrapper(name):
+        original = getattr(_os, name)
+
+        def wrap(self, src, dst, *args, **kw):
+            if self._active:
+                src, dst = self._remap_pair(name, src, dst, *args, **kw)
+            return original(src, dst, *args, **kw)
+
+        return wrap
+
+    for name in ["rename", "link", "symlink"]:
+        if hasattr(_os, name):
+            locals()[name] = _mk_dual_path_wrapper(name)
+
+    def _mk_single_path_wrapper(name, original=None):
+        original = original or getattr(_os, name)
+
+        def wrap(self, path, *args, **kw):
+            if self._active:
+                path = self._remap_input(name, path, *args, **kw)
+            return original(path, *args, **kw)
+
+        return wrap
+
+    if _file:
+        _file = _mk_single_path_wrapper('file', _file)
+    _open = _mk_single_path_wrapper('open', _open)
+    for name in [
+        "stat", "listdir", "chdir", "open", "chmod", "chown", "mkdir",
+        "remove", "unlink", "rmdir", "utime", "lchown", "chroot", "lstat",
+        "startfile", "mkfifo", "mknod", "pathconf", "access"
+    ]:
+        if hasattr(_os, name):
+            locals()[name] = _mk_single_path_wrapper(name)
+
+    def _mk_single_with_return(name):
+        original = getattr(_os, name)
+
+        def wrap(self, path, *args, **kw):
+            if self._active:
+                path = self._remap_input(name, path, *args, **kw)
+                return self._remap_output(name, original(path, *args, **kw))
+            return original(path, *args, **kw)
+
+        return wrap
+
+    for name in ['readlink', 'tempnam']:
+        if hasattr(_os, name):
+            locals()[name] = _mk_single_with_return(name)
+
+    def _mk_query(name):
+        original = getattr(_os, name)
+
+        def wrap(self, *args, **kw):
+            retval = original(*args, **kw)
+            if self._active:
+                return self._remap_output(name, retval)
+            return retval
+
+        return wrap
+
+    for name in ['getcwd', 'tmpnam']:
+        if hasattr(_os, name):
+            locals()[name] = _mk_query(name)
+
+    def _validate_path(self, path):
+        """Called to remap or validate any path, whether input or output"""
+        return path
+
+    def _remap_input(self, operation, path, *args, **kw):
+        """Called for path inputs"""
+        return self._validate_path(path)
+
+    def _remap_output(self, operation, path):
+        """Called for path outputs"""
+        return self._validate_path(path)
+
+    def _remap_pair(self, operation, src, dst, *args, **kw):
+        """Called for path pairs like rename, link, and symlink operations"""
+        return (
+            self._remap_input(operation + '-from', src, *args, **kw),
+            self._remap_input(operation + '-to', dst, *args, **kw)
+        )
+
+
+if hasattr(os, 'devnull'):
+    _EXCEPTIONS = [os.devnull]
+else:
+    _EXCEPTIONS = []
+
+
+class DirectorySandbox(AbstractSandbox):
+    """Restrict operations to a single subdirectory - pseudo-chroot"""
+
+    write_ops = dict.fromkeys([
+        "open", "chmod", "chown", "mkdir", "remove", "unlink", "rmdir",
+        "utime", "lchown", "chroot", "mkfifo", "mknod", "tempnam",
+    ])
+
+    _exception_patterns = [
+        # Allow lib2to3 to attempt to save a pickled grammar object (#121)
+        r'.*lib2to3.*\.pickle$',
+    ]
+    "exempt writing to paths that match the pattern"
+
+    def __init__(self, sandbox, exceptions=_EXCEPTIONS):
+        self._sandbox = os.path.normcase(os.path.realpath(sandbox))
+        self._prefix = os.path.join(self._sandbox, '')
+        self._exceptions = [
+            os.path.normcase(os.path.realpath(path))
+            for path in exceptions
+        ]
+        AbstractSandbox.__init__(self)
+
+    def _violation(self, operation, *args, **kw):
+        from setuptools.sandbox import SandboxViolation
+        raise SandboxViolation(operation, args, kw)
+
+    if _file:
+
+        def _file(self, path, mode='r', *args, **kw):
+            if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path):
+                self._violation("file", path, mode, *args, **kw)
+            return _file(path, mode, *args, **kw)
+
+    def _open(self, path, mode='r', *args, **kw):
+        if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path):
+            self._violation("open", path, mode, *args, **kw)
+        return _open(path, mode, *args, **kw)
+
+    def tmpnam(self):
+        self._violation("tmpnam")
+
+    def _ok(self, path):
+        active = self._active
+        try:
+            self._active = False
+            realpath = os.path.normcase(os.path.realpath(path))
+            return (
+                self._exempted(realpath)
+                or realpath == self._sandbox
+                or realpath.startswith(self._prefix)
+            )
+        finally:
+            self._active = active
+
+    def _exempted(self, filepath):
+        start_matches = (
+            filepath.startswith(exception)
+            for exception in self._exceptions
+        )
+        pattern_matches = (
+            re.match(pattern, filepath)
+            for pattern in self._exception_patterns
+        )
+        candidates = itertools.chain(start_matches, pattern_matches)
+        return any(candidates)
+
+    def _remap_input(self, operation, path, *args, **kw):
+        """Called for path inputs"""
+        if operation in self.write_ops and not self._ok(path):
+            self._violation(operation, os.path.realpath(path), *args, **kw)
+        return path
+
+    def _remap_pair(self, operation, src, dst, *args, **kw):
+        """Called for path pairs like rename, link, and symlink operations"""
+        if not self._ok(src) or not self._ok(dst):
+            self._violation(operation, src, dst, *args, **kw)
+        return (src, dst)
+
+    def open(self, file, flags, mode=0o777, *args, **kw):
+        """Called for low-level os.open()"""
+        if flags & WRITE_FLAGS and not self._ok(file):
+            self._violation("os.open", file, flags, mode, *args, **kw)
+        return _os.open(file, flags, mode, *args, **kw)
+
+
+WRITE_FLAGS = functools.reduce(
+    operator.or_, [
+        getattr(_os, a, 0) for a in
+        "O_WRONLY O_RDWR O_APPEND O_CREAT O_TRUNC O_TEMPORARY".split()]
+)
+
+
+class SandboxViolation(DistutilsError):
+    """A setup script attempted to modify the filesystem outside the sandbox"""
+
+    tmpl = textwrap.dedent("""
+        SandboxViolation: {cmd}{args!r} {kwargs}
+
+        The package setup script has attempted to modify files on your system
+        that are not within the EasyInstall build area, and has been aborted.
+
+        This package cannot be safely installed by EasyInstall, and may not
+        support alternate installation locations even if you run its setup
+        script by hand.  Please inform the package's author and the EasyInstall
+        maintainers to find out if a fix or workaround is available.
+        """).lstrip()
+
+    def __str__(self):
+        cmd, args, kwargs = self.args
+        return self.tmpl.format(**locals())
diff --git a/myenv/lib/python3.9/site-packages/setuptools/script (dev).tmpl b/myenv/lib/python3.9/site-packages/setuptools/script (dev).tmpl
new file mode 100644
index 0000000..39a24b0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/script (dev).tmpl	
@@ -0,0 +1,6 @@
+# EASY-INSTALL-DEV-SCRIPT: %(spec)r,%(script_name)r
+__requires__ = %(spec)r
+__import__('pkg_resources').require(%(spec)r)
+__file__ = %(dev_path)r
+with open(__file__) as f:
+    exec(compile(f.read(), __file__, 'exec'))
diff --git a/myenv/lib/python3.9/site-packages/setuptools/script.tmpl b/myenv/lib/python3.9/site-packages/setuptools/script.tmpl
new file mode 100644
index 0000000..ff5efbc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/script.tmpl
@@ -0,0 +1,3 @@
+# EASY-INSTALL-SCRIPT: %(spec)r,%(script_name)r
+__requires__ = %(spec)r
+__import__('pkg_resources').run_script(%(spec)r, %(script_name)r)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/ssl_support.py b/myenv/lib/python3.9/site-packages/setuptools/ssl_support.py
new file mode 100644
index 0000000..17c14c4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/ssl_support.py
@@ -0,0 +1,265 @@
+import os
+import socket
+import atexit
+import re
+import functools
+
+from setuptools.extern.six.moves import urllib, http_client, map, filter
+
+from pkg_resources import ResolutionError, ExtractionError
+
+try:
+    import ssl
+except ImportError:
+    ssl = None
+
+__all__ = [
+    'VerifyingHTTPSHandler', 'find_ca_bundle', 'is_available', 'cert_paths',
+    'opener_for'
+]
+
+cert_paths = """
+/etc/pki/tls/certs/ca-bundle.crt
+/etc/ssl/certs/ca-certificates.crt
+/usr/share/ssl/certs/ca-bundle.crt
+/usr/local/share/certs/ca-root.crt
+/etc/ssl/cert.pem
+/System/Library/OpenSSL/certs/cert.pem
+/usr/local/share/certs/ca-root-nss.crt
+/etc/ssl/ca-bundle.pem
+""".strip().split()
+
+try:
+    HTTPSHandler = urllib.request.HTTPSHandler
+    HTTPSConnection = http_client.HTTPSConnection
+except AttributeError:
+    HTTPSHandler = HTTPSConnection = object
+
+is_available = ssl is not None and object not in (
+    HTTPSHandler, HTTPSConnection)
+
+
+try:
+    from ssl import CertificateError, match_hostname
+except ImportError:
+    try:
+        from backports.ssl_match_hostname import CertificateError
+        from backports.ssl_match_hostname import match_hostname
+    except ImportError:
+        CertificateError = None
+        match_hostname = None
+
+if not CertificateError:
+
+    class CertificateError(ValueError):
+        pass
+
+
+if not match_hostname:
+
+    def _dnsname_match(dn, hostname, max_wildcards=1):
+        """Matching according to RFC 6125, section 6.4.3
+
+        https://tools.ietf.org/html/rfc6125#section-6.4.3
+        """
+        pats = []
+        if not dn:
+            return False
+
+        # Ported from python3-syntax:
+        # leftmost, *remainder = dn.split(r'.')
+        parts = dn.split(r'.')
+        leftmost = parts[0]
+        remainder = parts[1:]
+
+        wildcards = leftmost.count('*')
+        if wildcards > max_wildcards:
+            # Issue #17980: avoid denials of service by refusing more
+            # than one wildcard per fragment.  A survey of established
+            # policy among SSL implementations showed it to be a
+            # reasonable choice.
+            raise CertificateError(
+                "too many wildcards in certificate DNS name: " + repr(dn))
+
+        # speed up common case w/o wildcards
+        if not wildcards:
+            return dn.lower() == hostname.lower()
+
+        # RFC 6125, section 6.4.3, subitem 1.
+        # The client SHOULD NOT attempt to match a
+        # presented identifier in which the wildcard
+        # character comprises a label other than the
+        # left-most label.
+        if leftmost == '*':
+            # When '*' is a fragment by itself, it matches a non-empty dotless
+            # fragment.
+            pats.append('[^.]+')
+        elif leftmost.startswith('xn--') or hostname.startswith('xn--'):
+            # RFC 6125, section 6.4.3, subitem 3.
+            # The client SHOULD NOT attempt to match a presented identifier
+            # where the wildcard character is embedded within an A-label or
+            # U-label of an internationalized domain name.
+            pats.append(re.escape(leftmost))
+        else:
+            # Otherwise, '*' matches any dotless string, e.g. www*
+            pats.append(re.escape(leftmost).replace(r'\*', '[^.]*'))
+
+        # add the remaining fragments, ignore any wildcards
+        for frag in remainder:
+            pats.append(re.escape(frag))
+
+        pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE)
+        return pat.match(hostname)
+
+    def match_hostname(cert, hostname):
+        """Verify that *cert* (in decoded format as returned by
+        SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
+        rules are followed, but IP addresses are not accepted for *hostname*.
+
+        CertificateError is raised on failure. On success, the function
+        returns nothing.
+        """
+        if not cert:
+            raise ValueError("empty or no certificate")
+        dnsnames = []
+        san = cert.get('subjectAltName', ())
+        for key, value in san:
+            if key == 'DNS':
+                if _dnsname_match(value, hostname):
+                    return
+                dnsnames.append(value)
+        if not dnsnames:
+            # The subject is only checked when there is no dNSName entry
+            # in subjectAltName
+            for sub in cert.get('subject', ()):
+                for key, value in sub:
+                    # XXX according to RFC 2818, the most specific Common Name
+                    # must be used.
+                    if key == 'commonName':
+                        if _dnsname_match(value, hostname):
+                            return
+                        dnsnames.append(value)
+        if len(dnsnames) > 1:
+            raise CertificateError(
+                "hostname %r doesn't match either of %s"
+                % (hostname, ', '.join(map(repr, dnsnames))))
+        elif len(dnsnames) == 1:
+            raise CertificateError(
+                "hostname %r doesn't match %r"
+                % (hostname, dnsnames[0]))
+        else:
+            raise CertificateError(
+                "no appropriate commonName or "
+                "subjectAltName fields were found")
+
+
+class VerifyingHTTPSHandler(HTTPSHandler):
+    """Simple verifying handler: no auth, subclasses, timeouts, etc."""
+
+    def __init__(self, ca_bundle):
+        self.ca_bundle = ca_bundle
+        HTTPSHandler.__init__(self)
+
+    def https_open(self, req):
+        return self.do_open(
+            lambda host, **kw: VerifyingHTTPSConn(host, self.ca_bundle, **kw),
+            req
+        )
+
+
+class VerifyingHTTPSConn(HTTPSConnection):
+    """Simple verifying connection: no auth, subclasses, timeouts, etc."""
+
+    def __init__(self, host, ca_bundle, **kw):
+        HTTPSConnection.__init__(self, host, **kw)
+        self.ca_bundle = ca_bundle
+
+    def connect(self):
+        sock = socket.create_connection(
+            (self.host, self.port), getattr(self, 'source_address', None)
+        )
+
+        # Handle the socket if a (proxy) tunnel is present
+        if hasattr(self, '_tunnel') and getattr(self, '_tunnel_host', None):
+            self.sock = sock
+            self._tunnel()
+            # http://bugs.python.org/issue7776: Python>=3.4.1 and >=2.7.7
+            # change self.host to mean the proxy server host when tunneling is
+            # being used. Adapt, since we are interested in the destination
+            # host for the match_hostname() comparison.
+            actual_host = self._tunnel_host
+        else:
+            actual_host = self.host
+
+        if hasattr(ssl, 'create_default_context'):
+            ctx = ssl.create_default_context(cafile=self.ca_bundle)
+            self.sock = ctx.wrap_socket(sock, server_hostname=actual_host)
+        else:
+            # This is for python < 2.7.9 and < 3.4?
+            self.sock = ssl.wrap_socket(
+                sock, cert_reqs=ssl.CERT_REQUIRED, ca_certs=self.ca_bundle
+            )
+        try:
+            match_hostname(self.sock.getpeercert(), actual_host)
+        except CertificateError:
+            self.sock.shutdown(socket.SHUT_RDWR)
+            self.sock.close()
+            raise
+
+
+def opener_for(ca_bundle=None):
+    """Get a urlopen() replacement that uses ca_bundle for verification"""
+    return urllib.request.build_opener(
+        VerifyingHTTPSHandler(ca_bundle or find_ca_bundle())
+    ).open
+
+
+# from jaraco.functools
+def once(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        if not hasattr(func, 'always_returns'):
+            func.always_returns = func(*args, **kwargs)
+        return func.always_returns
+    return wrapper
+
+
+@once
+def get_win_certfile():
+    try:
+        import wincertstore
+    except ImportError:
+        return None
+
+    class CertFile(wincertstore.CertFile):
+        def __init__(self):
+            super(CertFile, self).__init__()
+            atexit.register(self.close)
+
+        def close(self):
+            try:
+                super(CertFile, self).close()
+            except OSError:
+                pass
+
+    _wincerts = CertFile()
+    _wincerts.addstore('CA')
+    _wincerts.addstore('ROOT')
+    return _wincerts.name
+
+
+def find_ca_bundle():
+    """Return an existing CA bundle path, or None"""
+    extant_cert_paths = filter(os.path.isfile, cert_paths)
+    return (
+        get_win_certfile()
+        or next(extant_cert_paths, None)
+        or _certifi_where()
+    )
+
+
+def _certifi_where():
+    try:
+        return __import__('certifi').where()
+    except (ImportError, ResolutionError, ExtractionError):
+        pass
diff --git a/myenv/lib/python3.9/site-packages/setuptools/unicode_utils.py b/myenv/lib/python3.9/site-packages/setuptools/unicode_utils.py
new file mode 100644
index 0000000..7c63efd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/unicode_utils.py
@@ -0,0 +1,44 @@
+import unicodedata
+import sys
+
+from setuptools.extern import six
+
+
+# HFS Plus uses decomposed UTF-8
+def decompose(path):
+    if isinstance(path, six.text_type):
+        return unicodedata.normalize('NFD', path)
+    try:
+        path = path.decode('utf-8')
+        path = unicodedata.normalize('NFD', path)
+        path = path.encode('utf-8')
+    except UnicodeError:
+        pass  # Not UTF-8
+    return path
+
+
+def filesys_decode(path):
+    """
+    Ensure that the given path is decoded,
+    NONE when no expected encoding works
+    """
+
+    if isinstance(path, six.text_type):
+        return path
+
+    fs_enc = sys.getfilesystemencoding() or 'utf-8'
+    candidates = fs_enc, 'utf-8'
+
+    for enc in candidates:
+        try:
+            return path.decode(enc)
+        except UnicodeDecodeError:
+            continue
+
+
+def try_encode(string, enc):
+    "turn unicode encoding into a functional routine"
+    try:
+        return string.encode(enc)
+    except UnicodeEncodeError:
+        return None
diff --git a/myenv/lib/python3.9/site-packages/setuptools/version.py b/myenv/lib/python3.9/site-packages/setuptools/version.py
new file mode 100644
index 0000000..95e1869
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/version.py
@@ -0,0 +1,6 @@
+import pkg_resources
+
+try:
+    __version__ = pkg_resources.get_distribution('setuptools').version
+except Exception:
+    __version__ = 'unknown'
diff --git a/myenv/lib/python3.9/site-packages/setuptools/wheel.py b/myenv/lib/python3.9/site-packages/setuptools/wheel.py
new file mode 100644
index 0000000..ca09bd1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/wheel.py
@@ -0,0 +1,217 @@
+"""Wheels support."""
+
+from distutils.util import get_platform
+from distutils import log
+import email
+import itertools
+import os
+import posixpath
+import re
+import zipfile
+
+import pkg_resources
+import setuptools
+from pkg_resources import parse_version
+from setuptools.extern.packaging.tags import sys_tags
+from setuptools.extern.packaging.utils import canonicalize_name
+from setuptools.extern.six import PY3
+from setuptools.command.egg_info import write_requirements
+
+
+__metaclass__ = type
+
+
+WHEEL_NAME = re.compile(
+    r"""^(?P<project_name>.+?)-(?P<version>\d.*?)
+    ((-(?P<build>\d.*?))?-(?P<py_version>.+?)-(?P<abi>.+?)-(?P<platform>.+?)
+    )\.whl$""",
+    re.VERBOSE).match
+
+NAMESPACE_PACKAGE_INIT = \
+    "__import__('pkg_resources').declare_namespace(__name__)\n"
+
+
+def unpack(src_dir, dst_dir):
+    '''Move everything under `src_dir` to `dst_dir`, and delete the former.'''
+    for dirpath, dirnames, filenames in os.walk(src_dir):
+        subdir = os.path.relpath(dirpath, src_dir)
+        for f in filenames:
+            src = os.path.join(dirpath, f)
+            dst = os.path.join(dst_dir, subdir, f)
+            os.renames(src, dst)
+        for n, d in reversed(list(enumerate(dirnames))):
+            src = os.path.join(dirpath, d)
+            dst = os.path.join(dst_dir, subdir, d)
+            if not os.path.exists(dst):
+                # Directory does not exist in destination,
+                # rename it and prune it from os.walk list.
+                os.renames(src, dst)
+                del dirnames[n]
+    # Cleanup.
+    for dirpath, dirnames, filenames in os.walk(src_dir, topdown=True):
+        assert not filenames
+        os.rmdir(dirpath)
+
+
+class Wheel:
+
+    def __init__(self, filename):
+        match = WHEEL_NAME(os.path.basename(filename))
+        if match is None:
+            raise ValueError('invalid wheel name: %r' % filename)
+        self.filename = filename
+        for k, v in match.groupdict().items():
+            setattr(self, k, v)
+
+    def tags(self):
+        '''List tags (py_version, abi, platform) supported by this wheel.'''
+        return itertools.product(
+            self.py_version.split('.'),
+            self.abi.split('.'),
+            self.platform.split('.'),
+        )
+
+    def is_compatible(self):
+        '''Is the wheel is compatible with the current platform?'''
+        supported_tags = set(
+            (t.interpreter, t.abi, t.platform) for t in sys_tags())
+        return next((True for t in self.tags() if t in supported_tags), False)
+
+    def egg_name(self):
+        return pkg_resources.Distribution(
+            project_name=self.project_name, version=self.version,
+            platform=(None if self.platform == 'any' else get_platform()),
+        ).egg_name() + '.egg'
+
+    def get_dist_info(self, zf):
+        # find the correct name of the .dist-info dir in the wheel file
+        for member in zf.namelist():
+            dirname = posixpath.dirname(member)
+            if (dirname.endswith('.dist-info') and
+                    canonicalize_name(dirname).startswith(
+                        canonicalize_name(self.project_name))):
+                return dirname
+        raise ValueError("unsupported wheel format. .dist-info not found")
+
+    def install_as_egg(self, destination_eggdir):
+        '''Install wheel as an egg directory.'''
+        with zipfile.ZipFile(self.filename) as zf:
+            self._install_as_egg(destination_eggdir, zf)
+
+    def _install_as_egg(self, destination_eggdir, zf):
+        dist_basename = '%s-%s' % (self.project_name, self.version)
+        dist_info = self.get_dist_info(zf)
+        dist_data = '%s.data' % dist_basename
+        egg_info = os.path.join(destination_eggdir, 'EGG-INFO')
+
+        self._convert_metadata(zf, destination_eggdir, dist_info, egg_info)
+        self._move_data_entries(destination_eggdir, dist_data)
+        self._fix_namespace_packages(egg_info, destination_eggdir)
+
+    @staticmethod
+    def _convert_metadata(zf, destination_eggdir, dist_info, egg_info):
+        def get_metadata(name):
+            with zf.open(posixpath.join(dist_info, name)) as fp:
+                value = fp.read().decode('utf-8') if PY3 else fp.read()
+                return email.parser.Parser().parsestr(value)
+
+        wheel_metadata = get_metadata('WHEEL')
+        # Check wheel format version is supported.
+        wheel_version = parse_version(wheel_metadata.get('Wheel-Version'))
+        wheel_v1 = (
+            parse_version('1.0') <= wheel_version < parse_version('2.0dev0')
+        )
+        if not wheel_v1:
+            raise ValueError(
+                'unsupported wheel format version: %s' % wheel_version)
+        # Extract to target directory.
+        os.mkdir(destination_eggdir)
+        zf.extractall(destination_eggdir)
+        # Convert metadata.
+        dist_info = os.path.join(destination_eggdir, dist_info)
+        dist = pkg_resources.Distribution.from_location(
+            destination_eggdir, dist_info,
+            metadata=pkg_resources.PathMetadata(destination_eggdir, dist_info),
+        )
+
+        # Note: Evaluate and strip markers now,
+        # as it's difficult to convert back from the syntax:
+        # foobar; "linux" in sys_platform and extra == 'test'
+        def raw_req(req):
+            req.marker = None
+            return str(req)
+        install_requires = list(sorted(map(raw_req, dist.requires())))
+        extras_require = {
+            extra: sorted(
+                req
+                for req in map(raw_req, dist.requires((extra,)))
+                if req not in install_requires
+            )
+            for extra in dist.extras
+        }
+        os.rename(dist_info, egg_info)
+        os.rename(
+            os.path.join(egg_info, 'METADATA'),
+            os.path.join(egg_info, 'PKG-INFO'),
+        )
+        setup_dist = setuptools.Distribution(
+            attrs=dict(
+                install_requires=install_requires,
+                extras_require=extras_require,
+            ),
+        )
+        # Temporarily disable info traces.
+        log_threshold = log._global_log.threshold
+        log.set_threshold(log.WARN)
+        try:
+            write_requirements(
+                setup_dist.get_command_obj('egg_info'),
+                None,
+                os.path.join(egg_info, 'requires.txt'),
+            )
+        finally:
+            log.set_threshold(log_threshold)
+
+    @staticmethod
+    def _move_data_entries(destination_eggdir, dist_data):
+        """Move data entries to their correct location."""
+        dist_data = os.path.join(destination_eggdir, dist_data)
+        dist_data_scripts = os.path.join(dist_data, 'scripts')
+        if os.path.exists(dist_data_scripts):
+            egg_info_scripts = os.path.join(
+                destination_eggdir, 'EGG-INFO', 'scripts')
+            os.mkdir(egg_info_scripts)
+            for entry in os.listdir(dist_data_scripts):
+                # Remove bytecode, as it's not properly handled
+                # during easy_install scripts install phase.
+                if entry.endswith('.pyc'):
+                    os.unlink(os.path.join(dist_data_scripts, entry))
+                else:
+                    os.rename(
+                        os.path.join(dist_data_scripts, entry),
+                        os.path.join(egg_info_scripts, entry),
+                    )
+            os.rmdir(dist_data_scripts)
+        for subdir in filter(os.path.exists, (
+            os.path.join(dist_data, d)
+            for d in ('data', 'headers', 'purelib', 'platlib')
+        )):
+            unpack(subdir, destination_eggdir)
+        if os.path.exists(dist_data):
+            os.rmdir(dist_data)
+
+    @staticmethod
+    def _fix_namespace_packages(egg_info, destination_eggdir):
+        namespace_packages = os.path.join(
+            egg_info, 'namespace_packages.txt')
+        if os.path.exists(namespace_packages):
+            with open(namespace_packages) as fp:
+                namespace_packages = fp.read().split()
+            for mod in namespace_packages:
+                mod_dir = os.path.join(destination_eggdir, *mod.split('.'))
+                mod_init = os.path.join(mod_dir, '__init__.py')
+                if not os.path.exists(mod_dir):
+                    os.mkdir(mod_dir)
+                if not os.path.exists(mod_init):
+                    with open(mod_init, 'w') as fp:
+                        fp.write(NAMESPACE_PACKAGE_INIT)
diff --git a/myenv/lib/python3.9/site-packages/setuptools/windows_support.py b/myenv/lib/python3.9/site-packages/setuptools/windows_support.py
new file mode 100644
index 0000000..cb977cf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/setuptools/windows_support.py
@@ -0,0 +1,29 @@
+import platform
+import ctypes
+
+
+def windows_only(func):
+    if platform.system() != 'Windows':
+        return lambda *args, **kwargs: None
+    return func
+
+
+@windows_only
+def hide_file(path):
+    """
+    Set the hidden attribute on a file or directory.
+
+    From http://stackoverflow.com/questions/19622133/
+
+    `path` must be text.
+    """
+    __import__('ctypes.wintypes')
+    SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW
+    SetFileAttributes.argtypes = ctypes.wintypes.LPWSTR, ctypes.wintypes.DWORD
+    SetFileAttributes.restype = ctypes.wintypes.BOOL
+
+    FILE_ATTRIBUTE_HIDDEN = 0x02
+
+    ret = SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN)
+    if not ret:
+        raise ctypes.WinError()
diff --git a/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/LICENSE
new file mode 100644
index 0000000..de66331
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/LICENSE
@@ -0,0 +1,18 @@
+Copyright (c) 2010-2020 Benjamin Peterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/METADATA
new file mode 100644
index 0000000..6d7525c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/METADATA
@@ -0,0 +1,49 @@
+Metadata-Version: 2.1
+Name: six
+Version: 1.16.0
+Summary: Python 2 and 3 compatibility utilities
+Home-page: https://github.com/benjaminp/six
+Author: Benjamin Peterson
+Author-email: benjamin@python.org
+License: MIT
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*
+
+.. image:: https://img.shields.io/pypi/v/six.svg
+   :target: https://pypi.org/project/six/
+   :alt: six on PyPI
+
+.. image:: https://travis-ci.org/benjaminp/six.svg?branch=master
+   :target: https://travis-ci.org/benjaminp/six
+   :alt: six on TravisCI
+
+.. image:: https://readthedocs.org/projects/six/badge/?version=latest
+   :target: https://six.readthedocs.io/
+   :alt: six's documentation on Read the Docs
+
+.. image:: https://img.shields.io/badge/license-MIT-green.svg
+   :target: https://github.com/benjaminp/six/blob/master/LICENSE
+   :alt: MIT License badge
+
+Six is a Python 2 and 3 compatibility library.  It provides utility functions
+for smoothing over the differences between the Python versions with the goal of
+writing Python code that is compatible on both Python versions.  See the
+documentation for more information on what is provided.
+
+Six supports Python 2.7 and 3.3+.  It is contained in only one Python
+file, so it can be easily copied into your project. (The copyright and license
+notice must be retained.)
+
+Online documentation is at https://six.readthedocs.io/.
+
+Bugs can be reported to https://github.com/benjaminp/six.  The code can also
+be found there.
+
+
diff --git a/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/RECORD
new file mode 100644
index 0000000..2f8befe
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/RECORD
@@ -0,0 +1,7 @@
+six.py,sha256=TOOfQi7nFGfMrIvtdr6wX4wyHH8M7aknmuLfo2cBBrM,34549
+six-1.16.0.dist-info/LICENSE,sha256=i7hQxWWqOJ_cFvOkaWWtI9gq3_YPI5P8J2K2MYXo5sk,1066
+six-1.16.0.dist-info/METADATA,sha256=VQcGIFCAEmfZcl77E5riPCN4v2TIsc_qtacnjxKHJoI,1795
+six-1.16.0.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
+six-1.16.0.dist-info/top_level.txt,sha256=_iVH_iYEtEXnD8nYGQYpYFUvkUW9sEO1GYbkeKSAais,4
+six-1.16.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+six-1.16.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/WHEEL
new file mode 100644
index 0000000..01b8fc7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/top_level.txt
new file mode 100644
index 0000000..ffe2fce
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/six-1.16.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+six
diff --git a/myenv/lib/python3.9/site-packages/six.py b/myenv/lib/python3.9/site-packages/six.py
new file mode 100644
index 0000000..4e15675
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/six.py
@@ -0,0 +1,998 @@
+# Copyright (c) 2010-2020 Benjamin Peterson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+from __future__ import absolute_import
+
+import functools
+import itertools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.16.0"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+PY34 = sys.version_info[0:2] >= (3, 4)
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+if PY34:
+    from importlib.util import spec_from_loader
+else:
+    spec_from_loader = None
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result)  # Invokes __set__.
+        try:
+            # This is a bit ugly, but it avoids running this again by
+            # removing this descriptor.
+            delattr(obj.__class__, self.name)
+        except AttributeError:
+            pass
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def find_spec(self, fullname, path, target=None):
+        if fullname in self.known_modules:
+            return spec_from_loader(fullname, self)
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
+    def create_module(self, spec):
+        return self.load_module(spec.name)
+
+    def exec_module(self, module):
+        pass
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
+    MovedAttribute("getoutput", "commands", "subprocess"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("collections_abc", "collections", "collections.abc" if sys.version_info >= (3, 3) else "collections"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread" if sys.version_info < (3, 9) else "_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+]
+# Add windows specific modules.
+if sys.platform == "win32":
+    _moved_attributes += [
+        MovedModule("winreg", "_winreg"),
+    ]
+
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
+    MovedAttribute("splitvalue", "urllib", "urllib.parse"),
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+    MovedAttribute("parse_http_list", "urllib2", "urllib.request"),
+    MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"),
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    def create_unbound_method(func, cls):
+        return func
+
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    def create_unbound_method(func, cls):
+        return types.MethodType(func, None, cls)
+
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+
+    viewkeys = operator.methodcaller("keys")
+
+    viewvalues = operator.methodcaller("values")
+
+    viewitems = operator.methodcaller("items")
+else:
+    def iterkeys(d, **kw):
+        return d.iterkeys(**kw)
+
+    def itervalues(d, **kw):
+        return d.itervalues(**kw)
+
+    def iteritems(d, **kw):
+        return d.iteritems(**kw)
+
+    def iterlists(d, **kw):
+        return d.iterlists(**kw)
+
+    viewkeys = operator.methodcaller("viewkeys")
+
+    viewvalues = operator.methodcaller("viewvalues")
+
+    viewitems = operator.methodcaller("viewitems")
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+
+    def u(s):
+        return s
+    unichr = chr
+    import struct
+    int2byte = struct.Struct(">B").pack
+    del struct
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+    del io
+    _assertCountEqual = "assertCountEqual"
+    if sys.version_info[1] <= 1:
+        _assertRaisesRegex = "assertRaisesRegexp"
+        _assertRegex = "assertRegexpMatches"
+        _assertNotRegex = "assertNotRegexpMatches"
+    else:
+        _assertRaisesRegex = "assertRaisesRegex"
+        _assertRegex = "assertRegex"
+        _assertNotRegex = "assertNotRegex"
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
+
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
+
+    def byte2int(bs):
+        return ord(bs[0])
+
+    def indexbytes(buf, i):
+        return ord(buf[i])
+    iterbytes = functools.partial(itertools.imap, ord)
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
+    _assertCountEqual = "assertItemsEqual"
+    _assertRaisesRegex = "assertRaisesRegexp"
+    _assertRegex = "assertRegexpMatches"
+    _assertNotRegex = "assertNotRegexpMatches"
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+def assertCountEqual(self, *args, **kwargs):
+    return getattr(self, _assertCountEqual)(*args, **kwargs)
+
+
+def assertRaisesRegex(self, *args, **kwargs):
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
+
+
+def assertRegex(self, *args, **kwargs):
+    return getattr(self, _assertRegex)(*args, **kwargs)
+
+
+def assertNotRegex(self, *args, **kwargs):
+    return getattr(self, _assertNotRegex)(*args, **kwargs)
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+    def reraise(tp, value, tb=None):
+        try:
+            if value is None:
+                value = tp()
+            if value.__traceback__ is not tb:
+                raise value.with_traceback(tb)
+            raise value
+        finally:
+            value = None
+            tb = None
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+    exec_("""def reraise(tp, value, tb=None):
+    try:
+        raise tp, value, tb
+    finally:
+        tb = None
+""")
+
+
+if sys.version_info[:2] > (3,):
+    exec_("""def raise_from(value, from_value):
+    try:
+        raise value from from_value
+    finally:
+        value = None
+""")
+else:
+    def raise_from(value, from_value):
+        raise value
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
+                    isinstance(data, unicode) and
+                    fp.encoding is not None):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+if sys.version_info[:2] < (3, 3):
+    _print = print_
+
+    def print_(*args, **kwargs):
+        fp = kwargs.get("file", sys.stdout)
+        flush = kwargs.pop("flush", False)
+        _print(*args, **kwargs)
+        if flush and fp is not None:
+            fp.flush()
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+    # This does exactly the same what the :func:`py3:functools.update_wrapper`
+    # function does on Python versions after 3.2. It sets the ``__wrapped__``
+    # attribute on ``wrapper`` object and it doesn't raise an error if any of
+    # the attributes mentioned in ``assigned`` and ``updated`` are missing on
+    # ``wrapped`` object.
+    def _update_wrapper(wrapper, wrapped,
+                        assigned=functools.WRAPPER_ASSIGNMENTS,
+                        updated=functools.WRAPPER_UPDATES):
+        for attr in assigned:
+            try:
+                value = getattr(wrapped, attr)
+            except AttributeError:
+                continue
+            else:
+                setattr(wrapper, attr, value)
+        for attr in updated:
+            getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
+        wrapper.__wrapped__ = wrapped
+        return wrapper
+    _update_wrapper.__doc__ = functools.update_wrapper.__doc__
+
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+              updated=functools.WRAPPER_UPDATES):
+        return functools.partial(_update_wrapper, wrapped=wrapped,
+                                 assigned=assigned, updated=updated)
+    wraps.__doc__ = functools.wraps.__doc__
+
+else:
+    wraps = functools.wraps
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(type):
+
+        def __new__(cls, name, this_bases, d):
+            if sys.version_info[:2] >= (3, 7):
+                # This version introduced PEP 560 that requires a bit
+                # of extra care (we mimic what is done by __build_class__).
+                resolved_bases = types.resolve_bases(bases)
+                if resolved_bases is not bases:
+                    d['__orig_bases__'] = bases
+            else:
+                resolved_bases = bases
+            return meta(name, resolved_bases, d)
+
+        @classmethod
+        def __prepare__(cls, name, this_bases):
+            return meta.__prepare__(name, bases)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        if hasattr(cls, '__qualname__'):
+            orig_vars['__qualname__'] = cls.__qualname__
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
+
+def ensure_binary(s, encoding='utf-8', errors='strict'):
+    """Coerce **s** to six.binary_type.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> encoded to `bytes`
+      - `bytes` -> `bytes`
+    """
+    if isinstance(s, binary_type):
+        return s
+    if isinstance(s, text_type):
+        return s.encode(encoding, errors)
+    raise TypeError("not expecting type '%s'" % type(s))
+
+
+def ensure_str(s, encoding='utf-8', errors='strict'):
+    """Coerce *s* to `str`.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    # Optimization: Fast return for the common case.
+    if type(s) is str:
+        return s
+    if PY2 and isinstance(s, text_type):
+        return s.encode(encoding, errors)
+    elif PY3 and isinstance(s, binary_type):
+        return s.decode(encoding, errors)
+    elif not isinstance(s, (text_type, binary_type)):
+        raise TypeError("not expecting type '%s'" % type(s))
+    return s
+
+
+def ensure_text(s, encoding='utf-8', errors='strict'):
+    """Coerce *s* to six.text_type.
+
+    For Python 2:
+      - `unicode` -> `unicode`
+      - `str` -> `unicode`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    if isinstance(s, binary_type):
+        return s.decode(encoding, errors)
+    elif isinstance(s, text_type):
+        return s
+    else:
+        raise TypeError("not expecting type '%s'" % type(s))
+
+
+def python_2_unicode_compatible(klass):
+    """
+    A class decorator that defines __unicode__ and __str__ methods under Python 2.
+    Under Python 3 it does nothing.
+
+    To support Python 2 and 3 with a single code base, define a __str__ method
+    returning text and apply this decorator to the class.
+    """
+    if PY2:
+        if '__str__' not in klass.__dict__:
+            raise ValueError("@python_2_unicode_compatible cannot be applied "
+                             "to %s because it doesn't define __str__()." %
+                             klass.__name__)
+        klass.__unicode__ = klass.__str__
+        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
+    return klass
+
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
+                importer.name == __name__):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)
diff --git a/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/LICENSE
new file mode 100644
index 0000000..51f3442
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/LICENSE
@@ -0,0 +1,3 @@
+This software is made available under the terms of *either* of the
+licenses found in LICENSE.APACHE2 or LICENSE.MIT. Contributions to are
+made under the terms of *both* these licenses.
diff --git a/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/LICENSE.APACHE2 b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/LICENSE.APACHE2
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/LICENSE.APACHE2
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/LICENSE.MIT b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/LICENSE.MIT
new file mode 100644
index 0000000..b8bb971
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/LICENSE.MIT
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/METADATA
new file mode 100644
index 0000000..0e60193
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/METADATA
@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: sniffio
+Version: 1.2.0
+Summary: Sniff out which async library your code is running under
+Home-page: https://github.com/python-trio/sniffio
+Author: Nathaniel J. Smith
+Author-email: njs@pobox.com
+License: MIT -or- Apache License 2.0
+Keywords: async,trio,asyncio
+Platform: UNKNOWN
+Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Framework :: Trio
+Classifier: Framework :: AsyncIO
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 5 - Production/Stable
+Requires-Python: >=3.5
+Requires-Dist: contextvars (>=2.1) ; python_version < '3.7'
+
+.. image:: https://img.shields.io/badge/chat-join%20now-blue.svg
+   :target: https://gitter.im/python-trio/general
+   :alt: Join chatroom
+
+.. image:: https://img.shields.io/badge/docs-read%20now-blue.svg
+   :target: https://sniffio.readthedocs.io/en/latest/?badge=latest
+   :alt: Documentation Status
+
+.. image:: https://img.shields.io/pypi/v/sniffio.svg
+   :target: https://pypi.org/project/sniffio
+   :alt: Latest PyPi version
+
+.. image:: https://img.shields.io/conda/vn/conda-forge/sniffio.svg
+   :target: https://anaconda.org/conda-forge/sniffio 
+   :alt: Latest conda-forge version   
+
+.. image:: https://travis-ci.org/python-trio/sniffio.svg?branch=master
+   :target: https://travis-ci.org/python-trio/sniffio
+   :alt: Automated test status
+
+.. image:: https://codecov.io/gh/python-trio/sniffio/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/python-trio/sniffio
+   :alt: Test coverage
+
+=================================================================
+sniffio: Sniff out which async library your code is running under
+=================================================================
+
+You're writing a library. You've decided to be ambitious, and support
+multiple async I/O packages, like `Trio
+<https://trio.readthedocs.io>`__, and `asyncio
+<https://docs.python.org/3/library/asyncio.html>`__, and ... You've
+written a bunch of clever code to handle all the differences. But...
+how do you know *which* piece of clever code to run?
+
+This is a tiny package whose only purpose is to let you detect which
+async library your code is running under.
+
+* Documentation: https://sniffio.readthedocs.io
+
+* Bug tracker and source code: https://github.com/python-trio/sniffio
+
+* License: MIT or Apache License 2.0, your choice
+
+* Contributor guide: https://trio.readthedocs.io/en/latest/contributing.html
+
+* Code of conduct: Contributors are requested to follow our `code of
+  conduct
+  <https://trio.readthedocs.io/en/latest/code-of-conduct.html>`_
+  in all project spaces.
+
+This library is maintained by the Trio project, as a service to the
+async Python community as a whole.
+
+
+Quickstart
+----------
+
+.. code-block:: python3
+
+   from sniffio import current_async_library
+   import trio
+   import asyncio
+
+   async def print_library():
+       library = current_async_library()
+       print("This is:", library)
+
+   # Prints "This is trio"
+   trio.run(print_library)
+
+   # Prints "This is asyncio"
+   asyncio.run(print_library())
+
+For more details, including how to add support to new async libraries,
+`please peruse our fine manual <https://sniffio.readthedocs.io>`__.
+
+
diff --git a/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/RECORD
new file mode 100644
index 0000000..207acc0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/RECORD
@@ -0,0 +1,14 @@
+sniffio/__init__.py,sha256=OVpJIlvGte9qZSi0tbZNiIF6cxVlNIkQY09sNw80m6Y,292
+sniffio/_impl.py,sha256=gtPkeGhus65ffGiTtv1w3qaMrfJI04ubcVMrWMW2_5Q,2721
+sniffio/_version.py,sha256=codhqWKYFbR_gKABvhb2_aWOKwuRo4YQlLcENJOvFkQ,89
+sniffio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sniffio/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sniffio/_tests/test_sniffio.py,sha256=yTv4bRyHH0ay5RpqWtdbzHFD6BV02xlBax61en_-OR8,1648
+sniffio-1.2.0.dist-info/LICENSE,sha256=ZSyHhIjRRWNh4Iw_hgf9e6WYkqFBA9Fczk_5PIW1zIs,185
+sniffio-1.2.0.dist-info/LICENSE.APACHE2,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+sniffio-1.2.0.dist-info/LICENSE.MIT,sha256=Pm2uVV65J4f8gtHUg1Vnf0VMf2Wus40_nnK_mj2vA0s,1046
+sniffio-1.2.0.dist-info/METADATA,sha256=1feG2RpWgvrsxlrHGBdQWr2qz_J9T2dNk9gHwBniB4o,3597
+sniffio-1.2.0.dist-info/WHEEL,sha256=EVRjI69F5qVjm_YgqcTXPnTAv3BfSUr0WVAHuSP3Xoo,92
+sniffio-1.2.0.dist-info/top_level.txt,sha256=v9UJXGs5CyddCVeAqXkQiWOrpp6Wtx6GeRrPt9-jjHg,8
+sniffio-1.2.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+sniffio-1.2.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/WHEEL
new file mode 100644
index 0000000..83ff02e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.35.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/top_level.txt
new file mode 100644
index 0000000..01c6502
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio-1.2.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+sniffio
diff --git a/myenv/lib/python3.9/site-packages/sniffio/__init__.py b/myenv/lib/python3.9/site-packages/sniffio/__init__.py
new file mode 100644
index 0000000..ddbd53a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio/__init__.py
@@ -0,0 +1,14 @@
+"""Top-level package for sniffio."""
+
+__all__ = [
+    "current_async_library", "AsyncLibraryNotFoundError",
+    "current_async_library_cvar"
+]
+
+from ._version import __version__
+
+from ._impl import (
+    current_async_library,
+    AsyncLibraryNotFoundError,
+    current_async_library_cvar,
+)
diff --git a/myenv/lib/python3.9/site-packages/sniffio/_impl.py b/myenv/lib/python3.9/site-packages/sniffio/_impl.py
new file mode 100644
index 0000000..240d3a2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio/_impl.py
@@ -0,0 +1,83 @@
+from contextvars import ContextVar
+from typing import Optional
+import sys
+
+current_async_library_cvar = ContextVar(
+    "current_async_library_cvar", default=None
+)  # type: ContextVar[Optional[str]]
+
+
+class AsyncLibraryNotFoundError(RuntimeError):
+    pass
+
+
+def current_async_library() -> str:
+    """Detect which async library is currently running.
+
+    The following libraries are currently supported:
+
+    ================   ===========  ============================
+    Library             Requires     Magic string
+    ================   ===========  ============================
+    **Trio**            Trio v0.6+   ``"trio"``
+    **Curio**           -            ``"curio"``
+    **asyncio**                      ``"asyncio"``
+    **Trio-asyncio**    v0.8.2+     ``"trio"`` or ``"asyncio"``,
+                                    depending on current mode
+    ================   ===========  ============================
+
+    Returns:
+      A string like ``"trio"``.
+
+    Raises:
+      AsyncLibraryNotFoundError: if called from synchronous context,
+        or if the current async library was not recognized.
+
+    Examples:
+
+        .. code-block:: python3
+
+           from sniffio import current_async_library
+
+           async def generic_sleep(seconds):
+               library = current_async_library()
+               if library == "trio":
+                   import trio
+                   await trio.sleep(seconds)
+               elif library == "asyncio":
+                   import asyncio
+                   await asyncio.sleep(seconds)
+               # ... and so on ...
+               else:
+                   raise RuntimeError(f"Unsupported library {library!r}")
+
+    """
+    value = current_async_library_cvar.get()
+    if value is not None:
+        return value
+
+    # Sniff for curio (for now)
+    if 'curio' in sys.modules:
+        from curio.meta import curio_running
+        if curio_running():
+            return 'curio'
+
+    # Need to sniff for asyncio
+    if "asyncio" in sys.modules:
+        import asyncio
+        try:
+            current_task = asyncio.current_task  # type: ignore[attr-defined]
+        except AttributeError:
+            current_task = asyncio.Task.current_task  # type: ignore[attr-defined]
+        try:
+            if current_task() is not None:
+                if (3, 7) <= sys.version_info:
+                    # asyncio has contextvars support, and we're in a task, so
+                    # we can safely cache the sniffed value
+                    current_async_library_cvar.set("asyncio")
+                return "asyncio"
+        except RuntimeError:
+            pass
+    raise AsyncLibraryNotFoundError(
+        "unknown async library, or not in async context"
+    )
diff --git a/myenv/lib/python3.9/site-packages/sniffio/_tests/__init__.py b/myenv/lib/python3.9/site-packages/sniffio/_tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/sniffio/_tests/test_sniffio.py b/myenv/lib/python3.9/site-packages/sniffio/_tests/test_sniffio.py
new file mode 100644
index 0000000..a19d13c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio/_tests/test_sniffio.py
@@ -0,0 +1,67 @@
+import sys
+
+import pytest
+
+from .. import (
+    current_async_library, AsyncLibraryNotFoundError,
+    current_async_library_cvar
+)
+
+
+def test_basics():
+    with pytest.raises(AsyncLibraryNotFoundError):
+        current_async_library()
+
+    token = current_async_library_cvar.set("generic-lib")
+    try:
+        assert current_async_library() == "generic-lib"
+    finally:
+        current_async_library_cvar.reset(token)
+
+    with pytest.raises(AsyncLibraryNotFoundError):
+        current_async_library()
+
+
+def test_asyncio():
+    import asyncio
+
+    with pytest.raises(AsyncLibraryNotFoundError):
+        current_async_library()
+
+    ran = []
+
+    async def this_is_asyncio():
+        assert current_async_library() == "asyncio"
+        # Call it a second time to exercise the caching logic
+        assert current_async_library() == "asyncio"
+        ran.append(True)
+
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(this_is_asyncio())
+    assert ran == [True]
+    loop.close()
+
+    with pytest.raises(AsyncLibraryNotFoundError):
+        current_async_library()
+
+
+@pytest.mark.skipif(sys.version_info < (3, 6), reason='Curio requires 3.6+')
+def test_curio():
+    import curio
+
+    with pytest.raises(AsyncLibraryNotFoundError):
+        current_async_library()
+
+    ran = []
+
+    async def this_is_curio():
+        assert current_async_library() == "curio"
+        # Call it a second time to exercise the caching logic
+        assert current_async_library() == "curio"
+        ran.append(True)
+
+    curio.run(this_is_curio)
+    assert ran == [True]
+
+    with pytest.raises(AsyncLibraryNotFoundError):
+        current_async_library()
diff --git a/myenv/lib/python3.9/site-packages/sniffio/_version.py b/myenv/lib/python3.9/site-packages/sniffio/_version.py
new file mode 100644
index 0000000..7c4b119
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/sniffio/_version.py
@@ -0,0 +1,3 @@
+# This file is imported from __init__.py and exec'd from setup.py
+
+__version__ = "1.2.0"
diff --git a/myenv/lib/python3.9/site-packages/sniffio/py.typed b/myenv/lib/python3.9/site-packages/sniffio/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/LICENSE.md b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/LICENSE.md
new file mode 100644
index 0000000..d16a60e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/LICENSE.md
@@ -0,0 +1,27 @@
+Copyright © 2018, [Encode OSS Ltd](https://www.encode.io/).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/METADATA
new file mode 100644
index 0000000..5fcce88
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/METADATA
@@ -0,0 +1,211 @@
+Metadata-Version: 2.1
+Name: starlette
+Version: 0.16.0
+Summary: The little ASGI library that shines.
+Home-page: https://github.com/encode/starlette
+Author: Tom Christie
+Author-email: tom@tomchristie.com
+License: BSD
+Platform: UNKNOWN
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: anyio (<4,>=3.0.0)
+Requires-Dist: contextlib2 (>=21.6.0) ; python_version < "3.7"
+Requires-Dist: typing-extensions ; python_version < "3.8"
+Provides-Extra: full
+Requires-Dist: itsdangerous ; extra == 'full'
+Requires-Dist: jinja2 ; extra == 'full'
+Requires-Dist: python-multipart ; extra == 'full'
+Requires-Dist: pyyaml ; extra == 'full'
+Requires-Dist: requests ; extra == 'full'
+Requires-Dist: graphene ; (python_version < "3.10") and extra == 'full'
+
+<p align="center">
+  <a href="https://www.starlette.io/"><img width="420px" src="https://raw.githubusercontent.com/encode/starlette/master/docs/img/starlette.png" alt='starlette'></a>
+</p>
+<p align="center">
+    <em>✨ The little ASGI framework that shines. ✨</em>
+</p>
+<p align="center">
+<a href="https://github.com/encode/starlette/actions">
+    <img src="https://github.com/encode/starlette/workflows/Test%20Suite/badge.svg" alt="Build Status">
+</a>
+<a href="https://pypi.org/project/starlette/">
+    <img src="https://badge.fury.io/py/starlette.svg" alt="Package version">
+</a>
+</p>
+
+---
+
+**Documentation**: [https://www.starlette.io/](https://www.starlette.io/)
+
+---
+
+# Starlette
+
+Starlette is a lightweight [ASGI](https://asgi.readthedocs.io/en/latest/) framework/toolkit,
+which is ideal for building high performance async services.
+
+It is production-ready, and gives you the following:
+
+* Seriously impressive performance.
+* WebSocket support.
+* GraphQL support.
+* In-process background tasks.
+* Startup and shutdown events.
+* Test client built on `requests`.
+* CORS, GZip, Static Files, Streaming responses.
+* Session and Cookie support.
+* 100% test coverage.
+* 100% type annotated codebase.
+* Few hard dependencies.
+* Compatible with `asyncio` and `trio` backends.
+
+## Requirements
+
+Python 3.6+
+
+## Installation
+
+```shell
+$ pip3 install starlette
+```
+
+You'll also want to install an ASGI server, such as [uvicorn](http://www.uvicorn.org/), [daphne](https://github.com/django/daphne/), or [hypercorn](https://pgjones.gitlab.io/hypercorn/).
+
+```shell
+$ pip3 install uvicorn
+```
+
+## Example
+
+**example.py**:
+
+```python
+from starlette.applications import Starlette
+from starlette.responses import JSONResponse
+from starlette.routing import Route
+
+
+async def homepage(request):
+    return JSONResponse({'hello': 'world'})
+
+routes = [
+    Route("/", endpoint=homepage)
+]
+
+app = Starlette(debug=True, routes=routes)
+```
+
+Then run the application using Uvicorn:
+
+```shell
+$ uvicorn example:app
+```
+
+For a more complete example, see [encode/starlette-example](https://github.com/encode/starlette-example).
+
+## Dependencies
+
+Starlette only requires `anyio`, and the following are optional:
+
+* [`requests`][requests] - Required if you want to use the `TestClient`.
+* [`jinja2`][jinja2] - Required if you want to use `Jinja2Templates`.
+* [`python-multipart`][python-multipart] - Required if you want to support form parsing, with `request.form()`.
+* [`itsdangerous`][itsdangerous] - Required for `SessionMiddleware` support.
+* [`pyyaml`][pyyaml] - Required for `SchemaGenerator` support.
+* [`graphene`][graphene] - Required for `GraphQLApp` support.
+
+You can install all of these with `pip3 install starlette[full]`.
+
+## Framework or Toolkit
+
+Starlette is designed to be used either as a complete framework, or as
+an ASGI toolkit. You can use any of its components independently.
+
+```python
+from starlette.responses import PlainTextResponse
+
+
+async def app(scope, receive, send):
+    assert scope['type'] == 'http'
+    response = PlainTextResponse('Hello, world!')
+    await response(scope, receive, send)
+```
+
+Run the `app` application in `example.py`:
+
+```shell
+$ uvicorn example:app
+INFO: Started server process [11509]
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+Run uvicorn with `--reload` to enable auto-reloading on code changes.
+
+## Modularity
+
+The modularity that Starlette is designed on promotes building re-usable
+components that can be shared between any ASGI framework. This should enable
+an ecosystem of shared middleware and mountable applications.
+
+The clean API separation also means it's easier to understand each component
+in isolation.
+
+## Performance
+
+Independent TechEmpower benchmarks show Starlette applications running under Uvicorn
+as [one of the fastest Python frameworks available](https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=fortune&l=zijzen-1). *(\*)*
+
+For high throughput loads you should:
+
+* Run using gunicorn using the `uvicorn` worker class.
+* Use one or two workers per-CPU core. (You might need to experiment with this.)
+* Disable access logging.
+
+Eg.
+
+```shell
+gunicorn -w 4 -k uvicorn.workers.UvicornWorker --log-level warning example:app
+```
+
+Several of the ASGI servers also have pure Python implementations available,
+so you can also run under `PyPy` if your application code has parts that are
+CPU constrained.
+
+Either programatically:
+
+```python
+uvicorn.run(..., http='h11', loop='asyncio')
+```
+
+Or using Gunicorn:
+
+```shell
+gunicorn -k uvicorn.workers.UvicornH11Worker ...
+```
+
+<p align="center">&mdash; ⭐️ &mdash;</p>
+<p align="center"><i>Starlette is <a href="https://github.com/encode/starlette/blob/master/LICENSE.md">BSD licensed</a> code. Designed & built in Brighton, England.</i></p>
+
+[requests]: http://docs.python-requests.org/en/master/
+[jinja2]: http://jinja.pocoo.org/
+[python-multipart]: https://andrew-d.github.io/python-multipart/
+[graphene]: https://graphene-python.org/
+[itsdangerous]: https://pythonhosted.org/itsdangerous/
+[sqlalchemy]: https://www.sqlalchemy.org
+[pyyaml]: https://pyyaml.org/wiki/PyYAMLDocumentation
+
+
diff --git a/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/RECORD
new file mode 100644
index 0000000..db74033
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/RECORD
@@ -0,0 +1,39 @@
+starlette/__init__.py,sha256=3Msc5baw88UJubVj5AVFB8tExkT2OFIsNWe2leaoHhc,23
+starlette/applications.py,sha256=i94-H7ujd0KUjGuNcxueFv7v6fqmnWWEwKjDl58RVHo,7611
+starlette/authentication.py,sha256=fkk5t6ABq57oSveMrdg97Al9TkqkKSVggn0fz7n__-Q,4458
+starlette/background.py,sha256=ckcfxCzOFbbOi_xAiWPmo3CgNJ4ie5hwSHfqwBfgM8Y,1015
+starlette/concurrency.py,sha256=2NIhTPUsrfM9WAUHwkTDXGyEgx9hljJpf0-OZEGszDk,1814
+starlette/config.py,sha256=ACr7-2IKNqOpYYcyps1WKhB_1cyUK3D7xDXYF5qI0y0,3660
+starlette/convertors.py,sha256=AVlgEUu3LgDnc-SnGDGPJlZBSKeFePOcQamK3vTWq_w,2065
+starlette/datastructures.py,sha256=aHZErEpoanU0K3ss2zVPeqyFock1jiRbuRNvUNtk_B4,21271
+starlette/endpoints.py,sha256=dIO9bbrVKJYMYCukzd7Hwh1cB_DpkGY61oc-Ct4pu6k,4625
+starlette/exceptions.py,sha256=KaS3101bCYMUvr0OwWoecDR36MNqTRA0ld2JsLyLWvc,3557
+starlette/formparsers.py,sha256=figTvkuLMa8jvqsKb_1jSd1YYKZf0enVEkPou9PMo18,8520
+starlette/graphql.py,sha256=ZzP6x5Zyk7padawHcaHu-Ia2d-CqTNZQhUPKtme-tFY,9824
+starlette/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+starlette/requests.py,sha256=Di87n1m0P2rD7PV27WOQTp6JGBbgneu8BoL0OgKF9CE,9335
+starlette/responses.py,sha256=b_M-KzT5BsOCcs7Mp4ZB9KplhCp9rTLECFDUzsG3nKA,11027
+starlette/routing.py,sha256=0Cx4Nxf9fBU2xV4PkId0Rfg1xjFX9Wde46-qVNqaeTI,27782
+starlette/schemas.py,sha256=K9bDGPCMN-ikPS9hTtl2Bp30LH-O0P_dSGOmS-oDNTA,4474
+starlette/staticfiles.py,sha256=YUm4oSFyFVUlynZslZcHHO52sMPGCaEOeygCmfQ6-Ww,7988
+starlette/status.py,sha256=8Ssp-OtC07-VCk15GV82HcfxXecpnUTAEm03w5LTyVI,2783
+starlette/templating.py,sha256=rsiXQqROH0kegS4VDR4cvLiwMhzs8EYfds6mwnCoCjA,2995
+starlette/testclient.py,sha256=yq5oNUkfY1ZmzCA2iKhkaSKu5Tca3aezWvQdK59Srus,19397
+starlette/types.py,sha256=RbisZ8DEsquztH1HwK6_8Iy5ZvQwddYcDDFW32KEN3o,302
+starlette/websockets.py,sha256=zq13ifb9jGRBunCDYFKkw5PWJoe_NlssWYAk0Vq3ms4,5590
+starlette/middleware/__init__.py,sha256=tEegvh1lBhUfHaJ0p-T_9FU7PRT1WHoIc2vZX0pUlm8,546
+starlette/middleware/authentication.py,sha256=bOlEe_SvzuSTEQRDu3J0f9NseMQqx-k4-yIbMdoAz_I,1770
+starlette/middleware/base.py,sha256=ApX5jS_xsCnKcx_inumdsN8eJ-s0dn1WIsyGEfVM_DU,2280
+starlette/middleware/cors.py,sha256=RgQx99Xtjxtuzn4h_c3bHNwG2yqunnpbvqEnC6O7xpA,7059
+starlette/middleware/errors.py,sha256=ig1K3IBp79caVo9H1_eK_coZMEMcRy7zm2SXoO2NGgw,7781
+starlette/middleware/gzip.py,sha256=-93WdWqhgFtWsC_xJnuceG-3s0W_a7sgi0ZXyLkGXlg,4062
+starlette/middleware/httpsredirect.py,sha256=SNTleaYALGoITV7xwbic4gB6VYdM8Ylea_ykciUz31g,848
+starlette/middleware/sessions.py,sha256=2nd145rLPXMnZhgoGm8JRhoeOzASW8orvxxGMaIEois,3152
+starlette/middleware/trustedhost.py,sha256=pGZNmcY2QTUz8Oe4iZDNx7BdiZMm9Va4FYa96hZEISs,2190
+starlette/middleware/wsgi.py,sha256=3qbqyA8eultCLeB58nFX-dHxzXEaIRCLXY5u0knJ6i4,4681
+starlette-0.16.0.dist-info/LICENSE.md,sha256=3LlWd6AiQCQxh-lk-UGEfRmxeCHPmeWvrmhPqzKMGb8,1518
+starlette-0.16.0.dist-info/METADATA,sha256=5W48ZlFoC_z7CZR6j5RCE7myKcqLGqPDfsFRbfx99dU,6479
+starlette-0.16.0.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+starlette-0.16.0.dist-info/top_level.txt,sha256=eWSxNxwzxXl9k09QFS8z1V7D3gCryfl1rTObkPBMRJI,10
+starlette-0.16.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+starlette-0.16.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/WHEEL
new file mode 100644
index 0000000..385faab
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/top_level.txt
new file mode 100644
index 0000000..b8a0f92
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette-0.16.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+starlette
diff --git a/myenv/lib/python3.9/site-packages/starlette/__init__.py b/myenv/lib/python3.9/site-packages/starlette/__init__.py
new file mode 100644
index 0000000..5a313cc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/__init__.py
@@ -0,0 +1 @@
+__version__ = "0.16.0"
diff --git a/myenv/lib/python3.9/site-packages/starlette/applications.py b/myenv/lib/python3.9/site-packages/starlette/applications.py
new file mode 100644
index 0000000..ea52ee7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/applications.py
@@ -0,0 +1,201 @@
+import typing
+
+from starlette.datastructures import State, URLPath
+from starlette.exceptions import ExceptionMiddleware
+from starlette.middleware import Middleware
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.middleware.errors import ServerErrorMiddleware
+from starlette.routing import BaseRoute, Router
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+
+class Starlette:
+    """
+    Creates an application instance.
+
+    **Parameters:**
+
+    * **debug** - Boolean indicating if debug tracebacks should be returned on errors.
+    * **routes** - A list of routes to serve incoming HTTP and WebSocket requests.
+    * **middleware** - A list of middleware to run for every request. A starlette
+    application will always automatically include two middleware classes.
+    `ServerErrorMiddleware` is added as the very outermost middleware, to handle
+    any uncaught errors occurring anywhere in the entire stack.
+    `ExceptionMiddleware` is added as the very innermost middleware, to deal
+    with handled exception cases occurring in the routing or endpoints.
+    * **exception_handlers** - A dictionary mapping either integer status codes,
+    or exception class types onto callables which handle the exceptions.
+    Exception handler callables should be of the form
+    `handler(request, exc) -> response` and may be be either standard functions, or
+    async functions.
+    * **on_startup** - A list of callables to run on application startup.
+    Startup handler callables do not take any arguments, and may be be either
+    standard functions, or async functions.
+    * **on_shutdown** - A list of callables to run on application shutdown.
+    Shutdown handler callables do not take any arguments, and may be be either
+    standard functions, or async functions.
+    """
+
+    def __init__(
+        self,
+        debug: bool = False,
+        routes: typing.Sequence[BaseRoute] = None,
+        middleware: typing.Sequence[Middleware] = None,
+        exception_handlers: typing.Dict[
+            typing.Union[int, typing.Type[Exception]], typing.Callable
+        ] = None,
+        on_startup: typing.Sequence[typing.Callable] = None,
+        on_shutdown: typing.Sequence[typing.Callable] = None,
+        lifespan: typing.Callable[["Starlette"], typing.AsyncContextManager] = None,
+    ) -> None:
+        # The lifespan context function is a newer style that replaces
+        # on_startup / on_shutdown handlers. Use one or the other, not both.
+        assert lifespan is None or (
+            on_startup is None and on_shutdown is None
+        ), "Use either 'lifespan' or 'on_startup'/'on_shutdown', not both."
+
+        self._debug = debug
+        self.state = State()
+        self.router = Router(
+            routes, on_startup=on_startup, on_shutdown=on_shutdown, lifespan=lifespan
+        )
+        self.exception_handlers = (
+            {} if exception_handlers is None else dict(exception_handlers)
+        )
+        self.user_middleware = [] if middleware is None else list(middleware)
+        self.middleware_stack = self.build_middleware_stack()
+
+    def build_middleware_stack(self) -> ASGIApp:
+        debug = self.debug
+        error_handler = None
+        exception_handlers = {}
+
+        for key, value in self.exception_handlers.items():
+            if key in (500, Exception):
+                error_handler = value
+            else:
+                exception_handlers[key] = value
+
+        middleware = (
+            [Middleware(ServerErrorMiddleware, handler=error_handler, debug=debug)]
+            + self.user_middleware
+            + [
+                Middleware(
+                    ExceptionMiddleware, handlers=exception_handlers, debug=debug
+                )
+            ]
+        )
+
+        app = self.router
+        for cls, options in reversed(middleware):
+            app = cls(app=app, **options)
+        return app
+
+    @property
+    def routes(self) -> typing.List[BaseRoute]:
+        return self.router.routes
+
+    @property
+    def debug(self) -> bool:
+        return self._debug
+
+    @debug.setter
+    def debug(self, value: bool) -> None:
+        self._debug = value
+        self.middleware_stack = self.build_middleware_stack()
+
+    def url_path_for(self, name: str, **path_params: str) -> URLPath:
+        return self.router.url_path_for(name, **path_params)
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        scope["app"] = self
+        await self.middleware_stack(scope, receive, send)
+
+    # The following usages are now discouraged in favour of configuration
+    #  during Starlette.__init__(...)
+    def on_event(self, event_type: str) -> typing.Callable:
+        return self.router.on_event(event_type)
+
+    def mount(self, path: str, app: ASGIApp, name: str = None) -> None:
+        self.router.mount(path, app=app, name=name)
+
+    def host(self, host: str, app: ASGIApp, name: str = None) -> None:
+        self.router.host(host, app=app, name=name)
+
+    def add_middleware(self, middleware_class: type, **options: typing.Any) -> None:
+        self.user_middleware.insert(0, Middleware(middleware_class, **options))
+        self.middleware_stack = self.build_middleware_stack()
+
+    def add_exception_handler(
+        self,
+        exc_class_or_status_code: typing.Union[int, typing.Type[Exception]],
+        handler: typing.Callable,
+    ) -> None:
+        self.exception_handlers[exc_class_or_status_code] = handler
+        self.middleware_stack = self.build_middleware_stack()
+
+    def add_event_handler(self, event_type: str, func: typing.Callable) -> None:
+        self.router.add_event_handler(event_type, func)
+
+    def add_route(
+        self,
+        path: str,
+        route: typing.Callable,
+        methods: typing.List[str] = None,
+        name: str = None,
+        include_in_schema: bool = True,
+    ) -> None:
+        self.router.add_route(
+            path, route, methods=methods, name=name, include_in_schema=include_in_schema
+        )
+
+    def add_websocket_route(
+        self, path: str, route: typing.Callable, name: str = None
+    ) -> None:
+        self.router.add_websocket_route(path, route, name=name)
+
+    def exception_handler(
+        self, exc_class_or_status_code: typing.Union[int, typing.Type[Exception]]
+    ) -> typing.Callable:
+        def decorator(func: typing.Callable) -> typing.Callable:
+            self.add_exception_handler(exc_class_or_status_code, func)
+            return func
+
+        return decorator
+
+    def route(
+        self,
+        path: str,
+        methods: typing.List[str] = None,
+        name: str = None,
+        include_in_schema: bool = True,
+    ) -> typing.Callable:
+        def decorator(func: typing.Callable) -> typing.Callable:
+            self.router.add_route(
+                path,
+                func,
+                methods=methods,
+                name=name,
+                include_in_schema=include_in_schema,
+            )
+            return func
+
+        return decorator
+
+    def websocket_route(self, path: str, name: str = None) -> typing.Callable:
+        def decorator(func: typing.Callable) -> typing.Callable:
+            self.router.add_websocket_route(path, func, name=name)
+            return func
+
+        return decorator
+
+    def middleware(self, middleware_type: str) -> typing.Callable:
+        assert (
+            middleware_type == "http"
+        ), 'Currently only middleware("http") is supported.'
+
+        def decorator(func: typing.Callable) -> typing.Callable:
+            self.add_middleware(BaseHTTPMiddleware, dispatch=func)
+            return func
+
+        return decorator
diff --git a/myenv/lib/python3.9/site-packages/starlette/authentication.py b/myenv/lib/python3.9/site-packages/starlette/authentication.py
new file mode 100644
index 0000000..44a9847
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/authentication.py
@@ -0,0 +1,142 @@
+import asyncio
+import functools
+import inspect
+import typing
+
+from starlette.exceptions import HTTPException
+from starlette.requests import HTTPConnection, Request
+from starlette.responses import RedirectResponse, Response
+from starlette.websockets import WebSocket
+
+
+def has_required_scope(conn: HTTPConnection, scopes: typing.Sequence[str]) -> bool:
+    for scope in scopes:
+        if scope not in conn.auth.scopes:
+            return False
+    return True
+
+
+def requires(
+    scopes: typing.Union[str, typing.Sequence[str]],
+    status_code: int = 403,
+    redirect: str = None,
+) -> typing.Callable:
+    scopes_list = [scopes] if isinstance(scopes, str) else list(scopes)
+
+    def decorator(func: typing.Callable) -> typing.Callable:
+        sig = inspect.signature(func)
+        for idx, parameter in enumerate(sig.parameters.values()):
+            if parameter.name == "request" or parameter.name == "websocket":
+                type_ = parameter.name
+                break
+        else:
+            raise Exception(
+                f'No "request" or "websocket" argument on function "{func}"'
+            )
+
+        if type_ == "websocket":
+            # Handle websocket functions. (Always async)
+            @functools.wraps(func)
+            async def websocket_wrapper(
+                *args: typing.Any, **kwargs: typing.Any
+            ) -> None:
+                websocket = kwargs.get("websocket", args[idx] if args else None)
+                assert isinstance(websocket, WebSocket)
+
+                if not has_required_scope(websocket, scopes_list):
+                    await websocket.close()
+                else:
+                    await func(*args, **kwargs)
+
+            return websocket_wrapper
+
+        elif asyncio.iscoroutinefunction(func):
+            # Handle async request/response functions.
+            @functools.wraps(func)
+            async def async_wrapper(
+                *args: typing.Any, **kwargs: typing.Any
+            ) -> Response:
+                request = kwargs.get("request", args[idx] if args else None)
+                assert isinstance(request, Request)
+
+                if not has_required_scope(request, scopes_list):
+                    if redirect is not None:
+                        return RedirectResponse(
+                            url=request.url_for(redirect), status_code=303
+                        )
+                    raise HTTPException(status_code=status_code)
+                return await func(*args, **kwargs)
+
+            return async_wrapper
+
+        else:
+            # Handle sync request/response functions.
+            @functools.wraps(func)
+            def sync_wrapper(*args: typing.Any, **kwargs: typing.Any) -> Response:
+                request = kwargs.get("request", args[idx] if args else None)
+                assert isinstance(request, Request)
+
+                if not has_required_scope(request, scopes_list):
+                    if redirect is not None:
+                        return RedirectResponse(
+                            url=request.url_for(redirect), status_code=303
+                        )
+                    raise HTTPException(status_code=status_code)
+                return func(*args, **kwargs)
+
+            return sync_wrapper
+
+    return decorator
+
+
+class AuthenticationError(Exception):
+    pass
+
+
+class AuthenticationBackend:
+    async def authenticate(
+        self, conn: HTTPConnection
+    ) -> typing.Optional[typing.Tuple["AuthCredentials", "BaseUser"]]:
+        raise NotImplementedError()  # pragma: no cover
+
+
+class AuthCredentials:
+    def __init__(self, scopes: typing.Sequence[str] = None):
+        self.scopes = [] if scopes is None else list(scopes)
+
+
+class BaseUser:
+    @property
+    def is_authenticated(self) -> bool:
+        raise NotImplementedError()  # pragma: no cover
+
+    @property
+    def display_name(self) -> str:
+        raise NotImplementedError()  # pragma: no cover
+
+    @property
+    def identity(self) -> str:
+        raise NotImplementedError()  # pragma: no cover
+
+
+class SimpleUser(BaseUser):
+    def __init__(self, username: str) -> None:
+        self.username = username
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def display_name(self) -> str:
+        return self.username
+
+
+class UnauthenticatedUser(BaseUser):
+    @property
+    def is_authenticated(self) -> bool:
+        return False
+
+    @property
+    def display_name(self) -> str:
+        return ""
diff --git a/myenv/lib/python3.9/site-packages/starlette/background.py b/myenv/lib/python3.9/site-packages/starlette/background.py
new file mode 100644
index 0000000..1160bae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/background.py
@@ -0,0 +1,35 @@
+import asyncio
+import typing
+
+from starlette.concurrency import run_in_threadpool
+
+
+class BackgroundTask:
+    def __init__(
+        self, func: typing.Callable, *args: typing.Any, **kwargs: typing.Any
+    ) -> None:
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        self.is_async = asyncio.iscoroutinefunction(func)
+
+    async def __call__(self) -> None:
+        if self.is_async:
+            await self.func(*self.args, **self.kwargs)
+        else:
+            await run_in_threadpool(self.func, *self.args, **self.kwargs)
+
+
+class BackgroundTasks(BackgroundTask):
+    def __init__(self, tasks: typing.Sequence[BackgroundTask] = None):
+        self.tasks = list(tasks) if tasks else []
+
+    def add_task(
+        self, func: typing.Callable, *args: typing.Any, **kwargs: typing.Any
+    ) -> None:
+        task = BackgroundTask(func, *args, **kwargs)
+        self.tasks.append(task)
+
+    async def __call__(self) -> None:
+        for task in self.tasks:
+            await task()
diff --git a/myenv/lib/python3.9/site-packages/starlette/concurrency.py b/myenv/lib/python3.9/site-packages/starlette/concurrency.py
new file mode 100644
index 0000000..e89d1e0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/concurrency.py
@@ -0,0 +1,61 @@
+import functools
+import typing
+from typing import Any, AsyncGenerator, Iterator
+
+import anyio
+
+try:
+    import contextvars  # Python 3.7+ only or via contextvars backport.
+except ImportError:  # pragma: no cover
+    contextvars = None  # type: ignore
+
+
+T = typing.TypeVar("T")
+
+
+async def run_until_first_complete(*args: typing.Tuple[typing.Callable, dict]) -> None:
+    async with anyio.create_task_group() as task_group:
+
+        async def run(func: typing.Callable[[], typing.Coroutine]) -> None:
+            await func()
+            task_group.cancel_scope.cancel()
+
+        for func, kwargs in args:
+            task_group.start_soon(run, functools.partial(func, **kwargs))
+
+
+async def run_in_threadpool(
+    func: typing.Callable[..., T], *args: typing.Any, **kwargs: typing.Any
+) -> T:
+    if contextvars is not None:  # pragma: no cover
+        # Ensure we run in the same context
+        child = functools.partial(func, *args, **kwargs)
+        context = contextvars.copy_context()
+        func = context.run
+        args = (child,)
+    elif kwargs:  # pragma: no cover
+        # run_sync doesn't accept 'kwargs', so bind them in here
+        func = functools.partial(func, **kwargs)
+    return await anyio.to_thread.run_sync(func, *args)
+
+
+class _StopIteration(Exception):
+    pass
+
+
+def _next(iterator: Iterator) -> Any:
+    # We can't raise `StopIteration` from within the threadpool iterator
+    # and catch it outside that context, so we coerce them into a different
+    # exception type.
+    try:
+        return next(iterator)
+    except StopIteration:
+        raise _StopIteration
+
+
+async def iterate_in_threadpool(iterator: Iterator) -> AsyncGenerator:
+    while True:
+        try:
+            yield await anyio.to_thread.run_sync(_next, iterator)
+        except _StopIteration:
+            break
diff --git a/myenv/lib/python3.9/site-packages/starlette/config.py b/myenv/lib/python3.9/site-packages/starlette/config.py
new file mode 100644
index 0000000..e9894e0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/config.py
@@ -0,0 +1,109 @@
+import os
+import typing
+from collections.abc import MutableMapping
+from pathlib import Path
+
+
+class undefined:
+    pass
+
+
+class EnvironError(Exception):
+    pass
+
+
+class Environ(MutableMapping):
+    def __init__(self, environ: typing.MutableMapping = os.environ):
+        self._environ = environ
+        self._has_been_read: typing.Set[typing.Any] = set()
+
+    def __getitem__(self, key: typing.Any) -> typing.Any:
+        self._has_been_read.add(key)
+        return self._environ.__getitem__(key)
+
+    def __setitem__(self, key: typing.Any, value: typing.Any) -> None:
+        if key in self._has_been_read:
+            raise EnvironError(
+                f"Attempting to set environ['{key}'], but the value has already been "
+                "read."
+            )
+        self._environ.__setitem__(key, value)
+
+    def __delitem__(self, key: typing.Any) -> None:
+        if key in self._has_been_read:
+            raise EnvironError(
+                f"Attempting to delete environ['{key}'], but the value has already "
+                "been read."
+            )
+        self._environ.__delitem__(key)
+
+    def __iter__(self) -> typing.Iterator:
+        return iter(self._environ)
+
+    def __len__(self) -> int:
+        return len(self._environ)
+
+
+environ = Environ()
+
+
+class Config:
+    def __init__(
+        self,
+        env_file: typing.Union[str, Path] = None,
+        environ: typing.Mapping[str, str] = environ,
+    ) -> None:
+        self.environ = environ
+        self.file_values: typing.Dict[str, str] = {}
+        if env_file is not None and os.path.isfile(env_file):
+            self.file_values = self._read_file(env_file)
+
+    def __call__(
+        self, key: str, cast: typing.Callable = None, default: typing.Any = undefined
+    ) -> typing.Any:
+        return self.get(key, cast, default)
+
+    def get(
+        self, key: str, cast: typing.Callable = None, default: typing.Any = undefined
+    ) -> typing.Any:
+        if key in self.environ:
+            value = self.environ[key]
+            return self._perform_cast(key, value, cast)
+        if key in self.file_values:
+            value = self.file_values[key]
+            return self._perform_cast(key, value, cast)
+        if default is not undefined:
+            return self._perform_cast(key, default, cast)
+        raise KeyError(f"Config '{key}' is missing, and has no default.")
+
+    def _read_file(self, file_name: typing.Union[str, Path]) -> typing.Dict[str, str]:
+        file_values: typing.Dict[str, str] = {}
+        with open(file_name) as input_file:
+            for line in input_file.readlines():
+                line = line.strip()
+                if "=" in line and not line.startswith("#"):
+                    key, value = line.split("=", 1)
+                    key = key.strip()
+                    value = value.strip().strip("\"'")
+                    file_values[key] = value
+        return file_values
+
+    def _perform_cast(
+        self, key: str, value: typing.Any, cast: typing.Callable = None
+    ) -> typing.Any:
+        if cast is None or value is None:
+            return value
+        elif cast is bool and isinstance(value, str):
+            mapping = {"true": True, "1": True, "false": False, "0": False}
+            value = value.lower()
+            if value not in mapping:
+                raise ValueError(
+                    f"Config '{key}' has value '{value}'. Not a valid bool."
+                )
+            return mapping[value]
+        try:
+            return cast(value)
+        except (TypeError, ValueError):
+            raise ValueError(
+                f"Config '{key}' has value '{value}'. Not a valid {cast.__name__}."
+            )
diff --git a/myenv/lib/python3.9/site-packages/starlette/convertors.py b/myenv/lib/python3.9/site-packages/starlette/convertors.py
new file mode 100644
index 0000000..7afe4c8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/convertors.py
@@ -0,0 +1,81 @@
+import math
+import typing
+import uuid
+
+
+class Convertor:
+    regex = ""
+
+    def convert(self, value: str) -> typing.Any:
+        raise NotImplementedError()  # pragma: no cover
+
+    def to_string(self, value: typing.Any) -> str:
+        raise NotImplementedError()  # pragma: no cover
+
+
+class StringConvertor(Convertor):
+    regex = "[^/]+"
+
+    def convert(self, value: str) -> typing.Any:
+        return value
+
+    def to_string(self, value: typing.Any) -> str:
+        value = str(value)
+        assert "/" not in value, "May not contain path separators"
+        assert value, "Must not be empty"
+        return value
+
+
+class PathConvertor(Convertor):
+    regex = ".*"
+
+    def convert(self, value: str) -> typing.Any:
+        return str(value)
+
+    def to_string(self, value: typing.Any) -> str:
+        return str(value)
+
+
+class IntegerConvertor(Convertor):
+    regex = "[0-9]+"
+
+    def convert(self, value: str) -> typing.Any:
+        return int(value)
+
+    def to_string(self, value: typing.Any) -> str:
+        value = int(value)
+        assert value >= 0, "Negative integers are not supported"
+        return str(value)
+
+
+class FloatConvertor(Convertor):
+    regex = "[0-9]+(.[0-9]+)?"
+
+    def convert(self, value: str) -> typing.Any:
+        return float(value)
+
+    def to_string(self, value: typing.Any) -> str:
+        value = float(value)
+        assert value >= 0.0, "Negative floats are not supported"
+        assert not math.isnan(value), "NaN values are not supported"
+        assert not math.isinf(value), "Infinite values are not supported"
+        return ("%0.20f" % value).rstrip("0").rstrip(".")
+
+
+class UUIDConvertor(Convertor):
+    regex = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
+
+    def convert(self, value: str) -> typing.Any:
+        return uuid.UUID(value)
+
+    def to_string(self, value: typing.Any) -> str:
+        return str(value)
+
+
+CONVERTOR_TYPES = {
+    "str": StringConvertor(),
+    "path": PathConvertor(),
+    "int": IntegerConvertor(),
+    "float": FloatConvertor(),
+    "uuid": UUIDConvertor(),
+}
diff --git a/myenv/lib/python3.9/site-packages/starlette/datastructures.py b/myenv/lib/python3.9/site-packages/starlette/datastructures.py
new file mode 100644
index 0000000..5149a6e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/datastructures.py
@@ -0,0 +1,667 @@
+import tempfile
+import typing
+from collections import namedtuple
+from collections.abc import Sequence
+from shlex import shlex
+from urllib.parse import SplitResult, parse_qsl, urlencode, urlsplit
+
+from starlette.concurrency import run_in_threadpool
+from starlette.types import Scope
+
+Address = namedtuple("Address", ["host", "port"])
+
+
+class URL:
+    def __init__(
+        self, url: str = "", scope: Scope = None, **components: typing.Any
+    ) -> None:
+        if scope is not None:
+            assert not url, 'Cannot set both "url" and "scope".'
+            assert not components, 'Cannot set both "scope" and "**components".'
+            scheme = scope.get("scheme", "http")
+            server = scope.get("server", None)
+            path = scope.get("root_path", "") + scope["path"]
+            query_string = scope.get("query_string", b"")
+
+            host_header = None
+            for key, value in scope["headers"]:
+                if key == b"host":
+                    host_header = value.decode("latin-1")
+                    break
+
+            if host_header is not None:
+                url = f"{scheme}://{host_header}{path}"
+            elif server is None:
+                url = path
+            else:
+                host, port = server
+                default_port = {"http": 80, "https": 443, "ws": 80, "wss": 443}[scheme]
+                if port == default_port:
+                    url = f"{scheme}://{host}{path}"
+                else:
+                    url = f"{scheme}://{host}:{port}{path}"
+
+            if query_string:
+                url += "?" + query_string.decode()
+        elif components:
+            assert not url, 'Cannot set both "url" and "**components".'
+            url = URL("").replace(**components).components.geturl()
+
+        self._url = url
+
+    @property
+    def components(self) -> SplitResult:
+        if not hasattr(self, "_components"):
+            self._components = urlsplit(self._url)
+        return self._components
+
+    @property
+    def scheme(self) -> str:
+        return self.components.scheme
+
+    @property
+    def netloc(self) -> str:
+        return self.components.netloc
+
+    @property
+    def path(self) -> str:
+        return self.components.path
+
+    @property
+    def query(self) -> str:
+        return self.components.query
+
+    @property
+    def fragment(self) -> str:
+        return self.components.fragment
+
+    @property
+    def username(self) -> typing.Union[None, str]:
+        return self.components.username
+
+    @property
+    def password(self) -> typing.Union[None, str]:
+        return self.components.password
+
+    @property
+    def hostname(self) -> typing.Union[None, str]:
+        return self.components.hostname
+
+    @property
+    def port(self) -> typing.Optional[int]:
+        return self.components.port
+
+    @property
+    def is_secure(self) -> bool:
+        return self.scheme in ("https", "wss")
+
+    def replace(self, **kwargs: typing.Any) -> "URL":
+        if (
+            "username" in kwargs
+            or "password" in kwargs
+            or "hostname" in kwargs
+            or "port" in kwargs
+        ):
+            hostname = kwargs.pop("hostname", self.hostname)
+            port = kwargs.pop("port", self.port)
+            username = kwargs.pop("username", self.username)
+            password = kwargs.pop("password", self.password)
+
+            netloc = hostname
+            if port is not None:
+                netloc += f":{port}"
+            if username is not None:
+                userpass = username
+                if password is not None:
+                    userpass += f":{password}"
+                netloc = f"{userpass}@{netloc}"
+
+            kwargs["netloc"] = netloc
+
+        components = self.components._replace(**kwargs)
+        return self.__class__(components.geturl())
+
+    def include_query_params(self, **kwargs: typing.Any) -> "URL":
+        params = MultiDict(parse_qsl(self.query, keep_blank_values=True))
+        params.update({str(key): str(value) for key, value in kwargs.items()})
+        query = urlencode(params.multi_items())
+        return self.replace(query=query)
+
+    def replace_query_params(self, **kwargs: typing.Any) -> "URL":
+        query = urlencode([(str(key), str(value)) for key, value in kwargs.items()])
+        return self.replace(query=query)
+
+    def remove_query_params(
+        self, keys: typing.Union[str, typing.Sequence[str]]
+    ) -> "URL":
+        if isinstance(keys, str):
+            keys = [keys]
+        params = MultiDict(parse_qsl(self.query, keep_blank_values=True))
+        for key in keys:
+            params.pop(key, None)
+        query = urlencode(params.multi_items())
+        return self.replace(query=query)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return str(self) == str(other)
+
+    def __str__(self) -> str:
+        return self._url
+
+    def __repr__(self) -> str:
+        url = str(self)
+        if self.password:
+            url = str(self.replace(password="********"))
+        return f"{self.__class__.__name__}({repr(url)})"
+
+
+class URLPath(str):
+    """
+    A URL path string that may also hold an associated protocol and/or host.
+    Used by the routing to return `url_path_for` matches.
+    """
+
+    def __new__(cls, path: str, protocol: str = "", host: str = "") -> "URLPath":
+        assert protocol in ("http", "websocket", "")
+        return str.__new__(cls, path)  # type: ignore
+
+    def __init__(self, path: str, protocol: str = "", host: str = "") -> None:
+        self.protocol = protocol
+        self.host = host
+
+    def make_absolute_url(self, base_url: typing.Union[str, URL]) -> str:
+        if isinstance(base_url, str):
+            base_url = URL(base_url)
+        if self.protocol:
+            scheme = {
+                "http": {True: "https", False: "http"},
+                "websocket": {True: "wss", False: "ws"},
+            }[self.protocol][base_url.is_secure]
+        else:
+            scheme = base_url.scheme
+
+        netloc = self.host or base_url.netloc
+        path = base_url.path.rstrip("/") + str(self)
+        return str(URL(scheme=scheme, netloc=netloc, path=path))
+
+
+class Secret:
+    """
+    Holds a string value that should not be revealed in tracebacks etc.
+    You should cast the value to `str` at the point it is required.
+    """
+
+    def __init__(self, value: str):
+        self._value = value
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}('**********')"
+
+    def __str__(self) -> str:
+        return self._value
+
+
+class CommaSeparatedStrings(Sequence):
+    def __init__(self, value: typing.Union[str, typing.Sequence[str]]):
+        if isinstance(value, str):
+            splitter = shlex(value, posix=True)
+            splitter.whitespace = ","
+            splitter.whitespace_split = True
+            self._items = [item.strip() for item in splitter]
+        else:
+            self._items = list(value)
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def __getitem__(self, index: typing.Union[int, slice]) -> typing.Any:
+        return self._items[index]
+
+    def __iter__(self) -> typing.Iterator[str]:
+        return iter(self._items)
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        items = [item for item in self]
+        return f"{class_name}({items!r})"
+
+    def __str__(self) -> str:
+        return ", ".join(repr(item) for item in self)
+
+
+class ImmutableMultiDict(typing.Mapping):
+    def __init__(
+        self,
+        *args: typing.Union[
+            "ImmutableMultiDict",
+            typing.Mapping,
+            typing.List[typing.Tuple[typing.Any, typing.Any]],
+        ],
+        **kwargs: typing.Any,
+    ) -> None:
+        assert len(args) < 2, "Too many arguments."
+
+        value = args[0] if args else []
+        if kwargs:
+            value = (
+                ImmutableMultiDict(value).multi_items()
+                + ImmutableMultiDict(kwargs).multi_items()
+            )
+
+        if not value:
+            _items: typing.List[typing.Tuple[typing.Any, typing.Any]] = []
+        elif hasattr(value, "multi_items"):
+            value = typing.cast(ImmutableMultiDict, value)
+            _items = list(value.multi_items())
+        elif hasattr(value, "items"):
+            value = typing.cast(typing.Mapping, value)
+            _items = list(value.items())
+        else:
+            value = typing.cast(
+                typing.List[typing.Tuple[typing.Any, typing.Any]], value
+            )
+            _items = list(value)
+
+        self._dict = {k: v for k, v in _items}
+        self._list = _items
+
+    def getlist(self, key: typing.Any) -> typing.List[str]:
+        return [item_value for item_key, item_value in self._list if item_key == key]
+
+    def keys(self) -> typing.KeysView:
+        return self._dict.keys()
+
+    def values(self) -> typing.ValuesView:
+        return self._dict.values()
+
+    def items(self) -> typing.ItemsView:
+        return self._dict.items()
+
+    def multi_items(self) -> typing.List[typing.Tuple[str, str]]:
+        return list(self._list)
+
+    def get(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
+        if key in self._dict:
+            return self._dict[key]
+        return default
+
+    def __getitem__(self, key: typing.Any) -> str:
+        return self._dict[key]
+
+    def __contains__(self, key: typing.Any) -> bool:
+        return key in self._dict
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return sorted(self._list) == sorted(other._list)
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        items = self.multi_items()
+        return f"{class_name}({items!r})"
+
+
+class MultiDict(ImmutableMultiDict):
+    def __setitem__(self, key: typing.Any, value: typing.Any) -> None:
+        self.setlist(key, [value])
+
+    def __delitem__(self, key: typing.Any) -> None:
+        self._list = [(k, v) for k, v in self._list if k != key]
+        del self._dict[key]
+
+    def pop(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
+        self._list = [(k, v) for k, v in self._list if k != key]
+        return self._dict.pop(key, default)
+
+    def popitem(self) -> typing.Tuple:
+        key, value = self._dict.popitem()
+        self._list = [(k, v) for k, v in self._list if k != key]
+        return key, value
+
+    def poplist(self, key: typing.Any) -> typing.List:
+        values = [v for k, v in self._list if k == key]
+        self.pop(key)
+        return values
+
+    def clear(self) -> None:
+        self._dict.clear()
+        self._list.clear()
+
+    def setdefault(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
+        if key not in self:
+            self._dict[key] = default
+            self._list.append((key, default))
+
+        return self[key]
+
+    def setlist(self, key: typing.Any, values: typing.List) -> None:
+        if not values:
+            self.pop(key, None)
+        else:
+            existing_items = [(k, v) for (k, v) in self._list if k != key]
+            self._list = existing_items + [(key, value) for value in values]
+            self._dict[key] = values[-1]
+
+    def append(self, key: typing.Any, value: typing.Any) -> None:
+        self._list.append((key, value))
+        self._dict[key] = value
+
+    def update(
+        self,
+        *args: typing.Union[
+            "MultiDict",
+            typing.Mapping,
+            typing.List[typing.Tuple[typing.Any, typing.Any]],
+        ],
+        **kwargs: typing.Any,
+    ) -> None:
+        value = MultiDict(*args, **kwargs)
+        existing_items = [(k, v) for (k, v) in self._list if k not in value.keys()]
+        self._list = existing_items + value.multi_items()
+        self._dict.update(value)
+
+
+class QueryParams(ImmutableMultiDict):
+    """
+    An immutable multidict.
+    """
+
+    def __init__(
+        self,
+        *args: typing.Union[
+            "ImmutableMultiDict",
+            typing.Mapping,
+            typing.List[typing.Tuple[typing.Any, typing.Any]],
+            str,
+            bytes,
+        ],
+        **kwargs: typing.Any,
+    ) -> None:
+        assert len(args) < 2, "Too many arguments."
+
+        value = args[0] if args else []
+
+        if isinstance(value, str):
+            super().__init__(parse_qsl(value, keep_blank_values=True), **kwargs)
+        elif isinstance(value, bytes):
+            super().__init__(
+                parse_qsl(value.decode("latin-1"), keep_blank_values=True), **kwargs
+            )
+        else:
+            super().__init__(*args, **kwargs)  # type: ignore
+        self._list = [(str(k), str(v)) for k, v in self._list]
+        self._dict = {str(k): str(v) for k, v in self._dict.items()}
+
+    def __str__(self) -> str:
+        return urlencode(self._list)
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        query_string = str(self)
+        return f"{class_name}({query_string!r})"
+
+
+class UploadFile:
+    """
+    An uploaded file included as part of the request data.
+    """
+
+    spool_max_size = 1024 * 1024
+
+    def __init__(
+        self, filename: str, file: typing.IO = None, content_type: str = ""
+    ) -> None:
+        self.filename = filename
+        self.content_type = content_type
+        if file is None:
+            file = tempfile.SpooledTemporaryFile(max_size=self.spool_max_size)
+        self.file = file
+
+    @property
+    def _in_memory(self) -> bool:
+        rolled_to_disk = getattr(self.file, "_rolled", True)
+        return not rolled_to_disk
+
+    async def write(self, data: typing.Union[bytes, str]) -> None:
+        if self._in_memory:
+            self.file.write(data)  # type: ignore
+        else:
+            await run_in_threadpool(self.file.write, data)
+
+    async def read(self, size: int = -1) -> typing.Union[bytes, str]:
+        if self._in_memory:
+            return self.file.read(size)
+        return await run_in_threadpool(self.file.read, size)
+
+    async def seek(self, offset: int) -> None:
+        if self._in_memory:
+            self.file.seek(offset)
+        else:
+            await run_in_threadpool(self.file.seek, offset)
+
+    async def close(self) -> None:
+        if self._in_memory:
+            self.file.close()
+        else:
+            await run_in_threadpool(self.file.close)
+
+
+class FormData(ImmutableMultiDict):
+    """
+    An immutable multidict, containing both file uploads and text input.
+    """
+
+    def __init__(
+        self,
+        *args: typing.Union[
+            "FormData",
+            typing.Mapping[str, typing.Union[str, UploadFile]],
+            typing.List[typing.Tuple[str, typing.Union[str, UploadFile]]],
+        ],
+        **kwargs: typing.Union[str, UploadFile],
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+    async def close(self) -> None:
+        for key, value in self.multi_items():
+            if isinstance(value, UploadFile):
+                await value.close()
+
+
+class Headers(typing.Mapping[str, str]):
+    """
+    An immutable, case-insensitive multidict.
+    """
+
+    def __init__(
+        self,
+        headers: typing.Mapping[str, str] = None,
+        raw: typing.List[typing.Tuple[bytes, bytes]] = None,
+        scope: Scope = None,
+    ) -> None:
+        self._list: typing.List[typing.Tuple[bytes, bytes]] = []
+        if headers is not None:
+            assert raw is None, 'Cannot set both "headers" and "raw".'
+            assert scope is None, 'Cannot set both "headers" and "scope".'
+            self._list = [
+                (key.lower().encode("latin-1"), value.encode("latin-1"))
+                for key, value in headers.items()
+            ]
+        elif raw is not None:
+            assert scope is None, 'Cannot set both "raw" and "scope".'
+            self._list = raw
+        elif scope is not None:
+            self._list = scope["headers"]
+
+    @property
+    def raw(self) -> typing.List[typing.Tuple[bytes, bytes]]:
+        return list(self._list)
+
+    def keys(self) -> typing.List[str]:  # type: ignore
+        return [key.decode("latin-1") for key, value in self._list]
+
+    def values(self) -> typing.List[str]:  # type: ignore
+        return [value.decode("latin-1") for key, value in self._list]
+
+    def items(self) -> typing.List[typing.Tuple[str, str]]:  # type: ignore
+        return [
+            (key.decode("latin-1"), value.decode("latin-1"))
+            for key, value in self._list
+        ]
+
+    def get(self, key: str, default: typing.Any = None) -> typing.Any:
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def getlist(self, key: str) -> typing.List[str]:
+        get_header_key = key.lower().encode("latin-1")
+        return [
+            item_value.decode("latin-1")
+            for item_key, item_value in self._list
+            if item_key == get_header_key
+        ]
+
+    def mutablecopy(self) -> "MutableHeaders":
+        return MutableHeaders(raw=self._list[:])
+
+    def __getitem__(self, key: str) -> str:
+        get_header_key = key.lower().encode("latin-1")
+        for header_key, header_value in self._list:
+            if header_key == get_header_key:
+                return header_value.decode("latin-1")
+        raise KeyError(key)
+
+    def __contains__(self, key: typing.Any) -> bool:
+        get_header_key = key.lower().encode("latin-1")
+        for header_key, header_value in self._list:
+            if header_key == get_header_key:
+                return True
+        return False
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._list)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if not isinstance(other, Headers):
+            return False
+        return sorted(self._list) == sorted(other._list)
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        as_dict = dict(self.items())
+        if len(as_dict) == len(self):
+            return f"{class_name}({as_dict!r})"
+        return f"{class_name}(raw={self.raw!r})"
+
+
+class MutableHeaders(Headers):
+    def __setitem__(self, key: str, value: str) -> None:
+        """
+        Set the header `key` to `value`, removing any duplicate entries.
+        Retains insertion order.
+        """
+        set_key = key.lower().encode("latin-1")
+        set_value = value.encode("latin-1")
+
+        found_indexes = []
+        for idx, (item_key, item_value) in enumerate(self._list):
+            if item_key == set_key:
+                found_indexes.append(idx)
+
+        for idx in reversed(found_indexes[1:]):
+            del self._list[idx]
+
+        if found_indexes:
+            idx = found_indexes[0]
+            self._list[idx] = (set_key, set_value)
+        else:
+            self._list.append((set_key, set_value))
+
+    def __delitem__(self, key: str) -> None:
+        """
+        Remove the header `key`.
+        """
+        del_key = key.lower().encode("latin-1")
+
+        pop_indexes = []
+        for idx, (item_key, item_value) in enumerate(self._list):
+            if item_key == del_key:
+                pop_indexes.append(idx)
+
+        for idx in reversed(pop_indexes):
+            del self._list[idx]
+
+    @property
+    def raw(self) -> typing.List[typing.Tuple[bytes, bytes]]:
+        return self._list
+
+    def setdefault(self, key: str, value: str) -> str:
+        """
+        If the header `key` does not exist, then set it to `value`.
+        Returns the header value.
+        """
+        set_key = key.lower().encode("latin-1")
+        set_value = value.encode("latin-1")
+
+        for idx, (item_key, item_value) in enumerate(self._list):
+            if item_key == set_key:
+                return item_value.decode("latin-1")
+        self._list.append((set_key, set_value))
+        return value
+
+    def update(self, other: dict) -> None:
+        for key, val in other.items():
+            self[key] = val
+
+    def append(self, key: str, value: str) -> None:
+        """
+        Append a header, preserving any duplicate entries.
+        """
+        append_key = key.lower().encode("latin-1")
+        append_value = value.encode("latin-1")
+        self._list.append((append_key, append_value))
+
+    def add_vary_header(self, vary: str) -> None:
+        existing = self.get("vary")
+        if existing is not None:
+            vary = ", ".join([existing, vary])
+        self["vary"] = vary
+
+
+class State:
+    """
+    An object that can be used to store arbitrary state.
+
+    Used for `request.state` and `app.state`.
+    """
+
+    def __init__(self, state: typing.Dict = None):
+        if state is None:
+            state = {}
+        super().__setattr__("_state", state)
+
+    def __setattr__(self, key: typing.Any, value: typing.Any) -> None:
+        self._state[key] = value
+
+    def __getattr__(self, key: typing.Any) -> typing.Any:
+        try:
+            return self._state[key]
+        except KeyError:
+            message = "'{}' object has no attribute '{}'"
+            raise AttributeError(message.format(self.__class__.__name__, key))
+
+    def __delattr__(self, key: typing.Any) -> None:
+        del self._state[key]
diff --git a/myenv/lib/python3.9/site-packages/starlette/endpoints.py b/myenv/lib/python3.9/site-packages/starlette/endpoints.py
new file mode 100644
index 0000000..2504dd8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/endpoints.py
@@ -0,0 +1,117 @@
+import asyncio
+import json
+import typing
+
+from starlette import status
+from starlette.concurrency import run_in_threadpool
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import PlainTextResponse, Response
+from starlette.types import Message, Receive, Scope, Send
+from starlette.websockets import WebSocket
+
+
+class HTTPEndpoint:
+    def __init__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        assert scope["type"] == "http"
+        self.scope = scope
+        self.receive = receive
+        self.send = send
+
+    def __await__(self) -> typing.Generator:
+        return self.dispatch().__await__()
+
+    async def dispatch(self) -> None:
+        request = Request(self.scope, receive=self.receive)
+        handler_name = "get" if request.method == "HEAD" else request.method.lower()
+        handler = getattr(self, handler_name, self.method_not_allowed)
+        is_async = asyncio.iscoroutinefunction(handler)
+        if is_async:
+            response = await handler(request)
+        else:
+            response = await run_in_threadpool(handler, request)
+        await response(self.scope, self.receive, self.send)
+
+    async def method_not_allowed(self, request: Request) -> Response:
+        # If we're running inside a starlette application then raise an
+        # exception, so that the configurable exception handler can deal with
+        # returning the response. For plain ASGI apps, just return the response.
+        if "app" in self.scope:
+            raise HTTPException(status_code=405)
+        return PlainTextResponse("Method Not Allowed", status_code=405)
+
+
+class WebSocketEndpoint:
+
+    encoding: typing.Optional[str] = None  # May be "text", "bytes", or "json".
+
+    def __init__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        assert scope["type"] == "websocket"
+        self.scope = scope
+        self.receive = receive
+        self.send = send
+
+    def __await__(self) -> typing.Generator:
+        return self.dispatch().__await__()
+
+    async def dispatch(self) -> None:
+        websocket = WebSocket(self.scope, receive=self.receive, send=self.send)
+        await self.on_connect(websocket)
+
+        close_code = status.WS_1000_NORMAL_CLOSURE
+
+        try:
+            while True:
+                message = await websocket.receive()
+                if message["type"] == "websocket.receive":
+                    data = await self.decode(websocket, message)
+                    await self.on_receive(websocket, data)
+                elif message["type"] == "websocket.disconnect":
+                    close_code = int(message.get("code", status.WS_1000_NORMAL_CLOSURE))
+                    break
+        except Exception as exc:
+            close_code = status.WS_1011_INTERNAL_ERROR
+            raise exc
+        finally:
+            await self.on_disconnect(websocket, close_code)
+
+    async def decode(self, websocket: WebSocket, message: Message) -> typing.Any:
+
+        if self.encoding == "text":
+            if "text" not in message:
+                await websocket.close(code=status.WS_1003_UNSUPPORTED_DATA)
+                raise RuntimeError("Expected text websocket messages, but got bytes")
+            return message["text"]
+
+        elif self.encoding == "bytes":
+            if "bytes" not in message:
+                await websocket.close(code=status.WS_1003_UNSUPPORTED_DATA)
+                raise RuntimeError("Expected bytes websocket messages, but got text")
+            return message["bytes"]
+
+        elif self.encoding == "json":
+            if message.get("text") is not None:
+                text = message["text"]
+            else:
+                text = message["bytes"].decode("utf-8")
+
+            try:
+                return json.loads(text)
+            except json.decoder.JSONDecodeError:
+                await websocket.close(code=status.WS_1003_UNSUPPORTED_DATA)
+                raise RuntimeError("Malformed JSON data received.")
+
+        assert (
+            self.encoding is None
+        ), f"Unsupported 'encoding' attribute {self.encoding}"
+        return message["text"] if message.get("text") else message["bytes"]
+
+    async def on_connect(self, websocket: WebSocket) -> None:
+        """Override to handle an incoming websocket connection"""
+        await websocket.accept()
+
+    async def on_receive(self, websocket: WebSocket, data: typing.Any) -> None:
+        """Override to handle an incoming websocket message"""
+
+    async def on_disconnect(self, websocket: WebSocket, close_code: int) -> None:
+        """Override to handle a disconnecting websocket"""
diff --git a/myenv/lib/python3.9/site-packages/starlette/exceptions.py b/myenv/lib/python3.9/site-packages/starlette/exceptions.py
new file mode 100644
index 0000000..cbc3047
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/exceptions.py
@@ -0,0 +1,98 @@
+import asyncio
+import http
+import typing
+
+from starlette.concurrency import run_in_threadpool
+from starlette.requests import Request
+from starlette.responses import PlainTextResponse, Response
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+
+class HTTPException(Exception):
+    def __init__(self, status_code: int, detail: str = None) -> None:
+        if detail is None:
+            detail = http.HTTPStatus(status_code).phrase
+        self.status_code = status_code
+        self.detail = detail
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}(status_code={self.status_code!r}, detail={self.detail!r})"
+
+
+class ExceptionMiddleware:
+    def __init__(
+        self, app: ASGIApp, handlers: dict = None, debug: bool = False
+    ) -> None:
+        self.app = app
+        self.debug = debug  # TODO: We ought to handle 404 cases if debug is set.
+        self._status_handlers: typing.Dict[int, typing.Callable] = {}
+        self._exception_handlers: typing.Dict[
+            typing.Type[Exception], typing.Callable
+        ] = {HTTPException: self.http_exception}
+        if handlers is not None:
+            for key, value in handlers.items():
+                self.add_exception_handler(key, value)
+
+    def add_exception_handler(
+        self,
+        exc_class_or_status_code: typing.Union[int, typing.Type[Exception]],
+        handler: typing.Callable,
+    ) -> None:
+        if isinstance(exc_class_or_status_code, int):
+            self._status_handlers[exc_class_or_status_code] = handler
+        else:
+            assert issubclass(exc_class_or_status_code, Exception)
+            self._exception_handlers[exc_class_or_status_code] = handler
+
+    def _lookup_exception_handler(
+        self, exc: Exception
+    ) -> typing.Optional[typing.Callable]:
+        for cls in type(exc).__mro__:
+            if cls in self._exception_handlers:
+                return self._exception_handlers[cls]
+        return None
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        response_started = False
+
+        async def sender(message: Message) -> None:
+            nonlocal response_started
+
+            if message["type"] == "http.response.start":
+                response_started = True
+            await send(message)
+
+        try:
+            await self.app(scope, receive, sender)
+        except Exception as exc:
+            handler = None
+
+            if isinstance(exc, HTTPException):
+                handler = self._status_handlers.get(exc.status_code)
+
+            if handler is None:
+                handler = self._lookup_exception_handler(exc)
+
+            if handler is None:
+                raise exc
+
+            if response_started:
+                msg = "Caught handled exception, but response already started."
+                raise RuntimeError(msg) from exc
+
+            request = Request(scope, receive=receive)
+            if asyncio.iscoroutinefunction(handler):
+                response = await handler(request, exc)
+            else:
+                response = await run_in_threadpool(handler, request, exc)
+            await response(scope, receive, sender)
+
+    def http_exception(self, request: Request, exc: HTTPException) -> Response:
+        if exc.status_code in {204, 304}:
+            return Response(b"", status_code=exc.status_code)
+        return PlainTextResponse(exc.detail, status_code=exc.status_code)
diff --git a/myenv/lib/python3.9/site-packages/starlette/formparsers.py b/myenv/lib/python3.9/site-packages/starlette/formparsers.py
new file mode 100644
index 0000000..1614a9d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/formparsers.py
@@ -0,0 +1,234 @@
+import typing
+from enum import Enum
+from urllib.parse import unquote_plus
+
+from starlette.datastructures import FormData, Headers, UploadFile
+
+try:
+    import multipart
+    from multipart.multipart import parse_options_header
+except ImportError:  # pragma: nocover
+    parse_options_header = None
+    multipart = None
+
+
+class FormMessage(Enum):
+    FIELD_START = 1
+    FIELD_NAME = 2
+    FIELD_DATA = 3
+    FIELD_END = 4
+    END = 5
+
+
+class MultiPartMessage(Enum):
+    PART_BEGIN = 1
+    PART_DATA = 2
+    PART_END = 3
+    HEADER_FIELD = 4
+    HEADER_VALUE = 5
+    HEADER_END = 6
+    HEADERS_FINISHED = 7
+    END = 8
+
+
+def _user_safe_decode(src: bytes, codec: str) -> str:
+    try:
+        return src.decode(codec)
+    except (UnicodeDecodeError, LookupError):
+        return src.decode("latin-1")
+
+
+class FormParser:
+    def __init__(
+        self, headers: Headers, stream: typing.AsyncGenerator[bytes, None]
+    ) -> None:
+        assert (
+            multipart is not None
+        ), "The `python-multipart` library must be installed to use form parsing."
+        self.headers = headers
+        self.stream = stream
+        self.messages: typing.List[typing.Tuple[FormMessage, bytes]] = []
+
+    def on_field_start(self) -> None:
+        message = (FormMessage.FIELD_START, b"")
+        self.messages.append(message)
+
+    def on_field_name(self, data: bytes, start: int, end: int) -> None:
+        message = (FormMessage.FIELD_NAME, data[start:end])
+        self.messages.append(message)
+
+    def on_field_data(self, data: bytes, start: int, end: int) -> None:
+        message = (FormMessage.FIELD_DATA, data[start:end])
+        self.messages.append(message)
+
+    def on_field_end(self) -> None:
+        message = (FormMessage.FIELD_END, b"")
+        self.messages.append(message)
+
+    def on_end(self) -> None:
+        message = (FormMessage.END, b"")
+        self.messages.append(message)
+
+    async def parse(self) -> FormData:
+        # Callbacks dictionary.
+        callbacks = {
+            "on_field_start": self.on_field_start,
+            "on_field_name": self.on_field_name,
+            "on_field_data": self.on_field_data,
+            "on_field_end": self.on_field_end,
+            "on_end": self.on_end,
+        }
+
+        # Create the parser.
+        parser = multipart.QuerystringParser(callbacks)
+        field_name = b""
+        field_value = b""
+
+        items: typing.List[typing.Tuple[str, typing.Union[str, UploadFile]]] = []
+
+        # Feed the parser with data from the request.
+        async for chunk in self.stream:
+            if chunk:
+                parser.write(chunk)
+            else:
+                parser.finalize()
+            messages = list(self.messages)
+            self.messages.clear()
+            for message_type, message_bytes in messages:
+                if message_type == FormMessage.FIELD_START:
+                    field_name = b""
+                    field_value = b""
+                elif message_type == FormMessage.FIELD_NAME:
+                    field_name += message_bytes
+                elif message_type == FormMessage.FIELD_DATA:
+                    field_value += message_bytes
+                elif message_type == FormMessage.FIELD_END:
+                    name = unquote_plus(field_name.decode("latin-1"))
+                    value = unquote_plus(field_value.decode("latin-1"))
+                    items.append((name, value))
+
+        return FormData(items)
+
+
+class MultiPartParser:
+    def __init__(
+        self, headers: Headers, stream: typing.AsyncGenerator[bytes, None]
+    ) -> None:
+        assert (
+            multipart is not None
+        ), "The `python-multipart` library must be installed to use form parsing."
+        self.headers = headers
+        self.stream = stream
+        self.messages: typing.List[typing.Tuple[MultiPartMessage, bytes]] = []
+
+    def on_part_begin(self) -> None:
+        message = (MultiPartMessage.PART_BEGIN, b"")
+        self.messages.append(message)
+
+    def on_part_data(self, data: bytes, start: int, end: int) -> None:
+        message = (MultiPartMessage.PART_DATA, data[start:end])
+        self.messages.append(message)
+
+    def on_part_end(self) -> None:
+        message = (MultiPartMessage.PART_END, b"")
+        self.messages.append(message)
+
+    def on_header_field(self, data: bytes, start: int, end: int) -> None:
+        message = (MultiPartMessage.HEADER_FIELD, data[start:end])
+        self.messages.append(message)
+
+    def on_header_value(self, data: bytes, start: int, end: int) -> None:
+        message = (MultiPartMessage.HEADER_VALUE, data[start:end])
+        self.messages.append(message)
+
+    def on_header_end(self) -> None:
+        message = (MultiPartMessage.HEADER_END, b"")
+        self.messages.append(message)
+
+    def on_headers_finished(self) -> None:
+        message = (MultiPartMessage.HEADERS_FINISHED, b"")
+        self.messages.append(message)
+
+    def on_end(self) -> None:
+        message = (MultiPartMessage.END, b"")
+        self.messages.append(message)
+
+    async def parse(self) -> FormData:
+        # Parse the Content-Type header to get the multipart boundary.
+        content_type, params = parse_options_header(self.headers["Content-Type"])
+        charset = params.get(b"charset", "utf-8")
+        if type(charset) == bytes:
+            charset = charset.decode("latin-1")
+        boundary = params.get(b"boundary")
+
+        # Callbacks dictionary.
+        callbacks = {
+            "on_part_begin": self.on_part_begin,
+            "on_part_data": self.on_part_data,
+            "on_part_end": self.on_part_end,
+            "on_header_field": self.on_header_field,
+            "on_header_value": self.on_header_value,
+            "on_header_end": self.on_header_end,
+            "on_headers_finished": self.on_headers_finished,
+            "on_end": self.on_end,
+        }
+
+        # Create the parser.
+        parser = multipart.MultipartParser(boundary, callbacks)
+        header_field = b""
+        header_value = b""
+        content_disposition = None
+        content_type = b""
+        field_name = ""
+        data = b""
+        file: typing.Optional[UploadFile] = None
+
+        items: typing.List[typing.Tuple[str, typing.Union[str, UploadFile]]] = []
+
+        # Feed the parser with data from the request.
+        async for chunk in self.stream:
+            parser.write(chunk)
+            messages = list(self.messages)
+            self.messages.clear()
+            for message_type, message_bytes in messages:
+                if message_type == MultiPartMessage.PART_BEGIN:
+                    content_disposition = None
+                    content_type = b""
+                    data = b""
+                elif message_type == MultiPartMessage.HEADER_FIELD:
+                    header_field += message_bytes
+                elif message_type == MultiPartMessage.HEADER_VALUE:
+                    header_value += message_bytes
+                elif message_type == MultiPartMessage.HEADER_END:
+                    field = header_field.lower()
+                    if field == b"content-disposition":
+                        content_disposition = header_value
+                    elif field == b"content-type":
+                        content_type = header_value
+                    header_field = b""
+                    header_value = b""
+                elif message_type == MultiPartMessage.HEADERS_FINISHED:
+                    disposition, options = parse_options_header(content_disposition)
+                    field_name = _user_safe_decode(options[b"name"], charset)
+                    if b"filename" in options:
+                        filename = _user_safe_decode(options[b"filename"], charset)
+                        file = UploadFile(
+                            filename=filename,
+                            content_type=content_type.decode("latin-1"),
+                        )
+                    else:
+                        file = None
+                elif message_type == MultiPartMessage.PART_DATA:
+                    if file is None:
+                        data += message_bytes
+                    else:
+                        await file.write(message_bytes)
+                elif message_type == MultiPartMessage.PART_END:
+                    if file is None:
+                        items.append((field_name, _user_safe_decode(data, charset)))
+                    else:
+                        await file.seek(0)
+                        items.append((field_name, file))
+
+        parser.finalize()
+        return FormData(items)
diff --git a/myenv/lib/python3.9/site-packages/starlette/graphql.py b/myenv/lib/python3.9/site-packages/starlette/graphql.py
new file mode 100644
index 0000000..6e5d6ec
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/graphql.py
@@ -0,0 +1,275 @@
+import json
+import typing
+import warnings
+
+from starlette import status
+from starlette.background import BackgroundTasks
+from starlette.concurrency import run_in_threadpool
+from starlette.requests import Request
+from starlette.responses import HTMLResponse, JSONResponse, PlainTextResponse, Response
+from starlette.types import Receive, Scope, Send
+
+warnings.warn(
+    "GraphQLApp is deprecated and will be removed in a future release. "
+    "Consider using a third-party GraphQL implementation. "
+    "See https://github.com/encode/starlette/issues/619.",
+    DeprecationWarning,
+)
+
+try:
+    import graphene
+    from graphql.error import GraphQLError, format_error as format_graphql_error
+    from graphql.execution.executors.asyncio import AsyncioExecutor
+except ImportError:  # pragma: nocover
+    graphene = None
+    AsyncioExecutor = None  # type: ignore
+    format_graphql_error = None  # type: ignore
+    GraphQLError = None  # type: ignore
+
+
+class GraphQLApp:
+    def __init__(
+        self,
+        schema: "graphene.Schema",
+        executor_class: type = None,
+        graphiql: bool = True,
+    ) -> None:
+        self.schema = schema
+        self.graphiql = graphiql
+        self.executor_class = executor_class
+        self.is_async = executor_class is not None and issubclass(
+            executor_class, AsyncioExecutor
+        )
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if self.executor_class is not None:
+            self.executor = self.executor_class()
+
+        request = Request(scope, receive=receive)
+        response = await self.handle_graphql(request)
+        await response(scope, receive, send)
+
+    async def handle_graphql(self, request: Request) -> Response:
+        if request.method in ("GET", "HEAD"):
+            if "text/html" in request.headers.get("Accept", ""):
+                if not self.graphiql:
+                    return PlainTextResponse(
+                        "Not Found", status_code=status.HTTP_404_NOT_FOUND
+                    )
+                return await self.handle_graphiql(request)
+
+            data: typing.Mapping[str, typing.Any] = request.query_params
+
+        elif request.method == "POST":
+            content_type = request.headers.get("Content-Type", "")
+
+            if "application/json" in content_type:
+                data = await request.json()
+            elif "application/graphql" in content_type:
+                body = await request.body()
+                text = body.decode()
+                data = {"query": text}
+            elif "query" in request.query_params:
+                data = request.query_params
+            else:
+                return PlainTextResponse(
+                    "Unsupported Media Type",
+                    status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+                )
+
+        else:
+            return PlainTextResponse(
+                "Method Not Allowed", status_code=status.HTTP_405_METHOD_NOT_ALLOWED
+            )
+
+        try:
+            query = data["query"]
+            variables = data.get("variables")
+            operation_name = data.get("operationName")
+        except KeyError:
+            return PlainTextResponse(
+                "No GraphQL query found in the request",
+                status_code=status.HTTP_400_BAD_REQUEST,
+            )
+
+        background = BackgroundTasks()
+        context = {"request": request, "background": background}
+
+        result = await self.execute(
+            query, variables=variables, context=context, operation_name=operation_name
+        )
+        error_data = (
+            [format_graphql_error(err) for err in result.errors]
+            if result.errors
+            else None
+        )
+        response_data = {"data": result.data}
+        if error_data:
+            response_data["errors"] = error_data
+        status_code = (
+            status.HTTP_400_BAD_REQUEST if result.errors else status.HTTP_200_OK
+        )
+
+        return JSONResponse(
+            response_data, status_code=status_code, background=background
+        )
+
+    async def execute(  # type: ignore
+        self, query, variables=None, context=None, operation_name=None
+    ):
+        if self.is_async:
+            return await self.schema.execute(
+                query,
+                variables=variables,
+                operation_name=operation_name,
+                executor=self.executor,
+                return_promise=True,
+                context=context,
+            )
+        else:
+            return await run_in_threadpool(
+                self.schema.execute,
+                query,
+                variables=variables,
+                operation_name=operation_name,
+                context=context,
+            )
+
+    async def handle_graphiql(self, request: Request) -> Response:
+        text = GRAPHIQL.replace("{{REQUEST_PATH}}", json.dumps(request.url.path))
+        return HTMLResponse(text)
+
+
+GRAPHIQL = """
+<!--
+ *  Copyright (c) Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the license found in the
+ *  LICENSE file in the root directory of this source tree.
+-->
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      body {
+        height: 100%;
+        margin: 0;
+        width: 100%;
+        overflow: hidden;
+      }
+      #graphiql {
+        height: 100vh;
+      }
+    </style>
+    <!--
+      This GraphiQL example depends on Promise and fetch, which are available in
+      modern browsers, but can be "polyfilled" for older browsers.
+      GraphiQL itself depends on React DOM.
+      If you do not want to rely on a CDN, you can host these files locally or
+      include them directly in your favored resource bunder.
+    -->
+    <link href="//cdn.jsdelivr.net/npm/graphiql@0.12.0/graphiql.css" rel="stylesheet"/>
+    <script src="//cdn.jsdelivr.net/npm/whatwg-fetch@2.0.3/fetch.min.js"></script>
+    <script src="//cdn.jsdelivr.net/npm/react@16.2.0/umd/react.production.min.js"></script>
+    <script src="//cdn.jsdelivr.net/npm/react-dom@16.2.0/umd/react-dom.production.min.js"></script>
+    <script src="//cdn.jsdelivr.net/npm/graphiql@0.12.0/graphiql.min.js"></script>
+  </head>
+  <body>
+    <div id="graphiql">Loading...</div>
+    <script>
+      /**
+       * This GraphiQL example illustrates how to use some of GraphiQL's props
+       * in order to enable reading and updating the URL parameters, making
+       * link sharing of queries a little bit easier.
+       *
+       * This is only one example of this kind of feature, GraphiQL exposes
+       * various React params to enable interesting integrations.
+       */
+      // Parse the search string to get url parameters.
+      var search = window.location.search;
+      var parameters = {};
+      search.substr(1).split('&').forEach(function (entry) {
+        var eq = entry.indexOf('=');
+        if (eq >= 0) {
+          parameters[decodeURIComponent(entry.slice(0, eq))] =
+            decodeURIComponent(entry.slice(eq + 1));
+        }
+      });
+      // if variables was provided, try to format it.
+      if (parameters.variables) {
+        try {
+          parameters.variables =
+            JSON.stringify(JSON.parse(parameters.variables), null, 2);
+        } catch (e) {
+          // Do nothing, we want to display the invalid JSON as a string, rather
+          // than present an error.
+        }
+      }
+      // When the query and variables string is edited, update the URL bar so
+      // that it can be easily shared
+      function onEditQuery(newQuery) {
+        parameters.query = newQuery;
+        updateURL();
+      }
+      function onEditVariables(newVariables) {
+        parameters.variables = newVariables;
+        updateURL();
+      }
+      function onEditOperationName(newOperationName) {
+        parameters.operationName = newOperationName;
+        updateURL();
+      }
+      function updateURL() {
+        var newSearch = '?' + Object.keys(parameters).filter(function (key) {
+          return Boolean(parameters[key]);
+        }).map(function (key) {
+          return encodeURIComponent(key) + '=' +
+            encodeURIComponent(parameters[key]);
+        }).join('&');
+        history.replaceState(null, null, newSearch);
+      }
+      // Defines a GraphQL fetcher using the fetch API. You're not required to
+      // use fetch, and could instead implement graphQLFetcher however you like,
+      // as long as it returns a Promise or Observable.
+      function graphQLFetcher(graphQLParams) {
+        // This example expects a GraphQL server at the path /graphql.
+        // Change this to point wherever you host your GraphQL server.
+        return fetch({{REQUEST_PATH}}, {
+          method: 'post',
+          headers: {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify(graphQLParams),
+          credentials: 'include',
+        }).then(function (response) {
+          return response.text();
+        }).then(function (responseBody) {
+          try {
+            return JSON.parse(responseBody);
+          } catch (error) {
+            return responseBody;
+          }
+        });
+      }
+      // Render <GraphiQL /> into the body.
+      // See the README in the top level of this module to learn more about
+      // how you can customize GraphiQL by providing different values or
+      // additional child elements.
+      ReactDOM.render(
+        React.createElement(GraphiQL, {
+          fetcher: graphQLFetcher,
+          query: parameters.query,
+          variables: parameters.variables,
+          operationName: parameters.operationName,
+          onEditQuery: onEditQuery,
+          onEditVariables: onEditVariables,
+          onEditOperationName: onEditOperationName
+        }),
+        document.getElementById('graphiql')
+      );
+    </script>
+  </body>
+</html>
+"""  # noqa: E501
diff --git a/myenv/lib/python3.9/site-packages/starlette/middleware/__init__.py b/myenv/lib/python3.9/site-packages/starlette/middleware/__init__.py
new file mode 100644
index 0000000..5ac5b96
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/middleware/__init__.py
@@ -0,0 +1,17 @@
+import typing
+
+
+class Middleware:
+    def __init__(self, cls: type, **options: typing.Any) -> None:
+        self.cls = cls
+        self.options = options
+
+    def __iter__(self) -> typing.Iterator:
+        as_tuple = (self.cls, self.options)
+        return iter(as_tuple)
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        option_strings = [f"{key}={value!r}" for key, value in self.options.items()]
+        args_repr = ", ".join([self.cls.__name__] + option_strings)
+        return f"{class_name}({args_repr})"
diff --git a/myenv/lib/python3.9/site-packages/starlette/middleware/authentication.py b/myenv/lib/python3.9/site-packages/starlette/middleware/authentication.py
new file mode 100644
index 0000000..6e2d2da
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/middleware/authentication.py
@@ -0,0 +1,52 @@
+import typing
+
+from starlette.authentication import (
+    AuthCredentials,
+    AuthenticationBackend,
+    AuthenticationError,
+    UnauthenticatedUser,
+)
+from starlette.requests import HTTPConnection
+from starlette.responses import PlainTextResponse, Response
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+
+class AuthenticationMiddleware:
+    def __init__(
+        self,
+        app: ASGIApp,
+        backend: AuthenticationBackend,
+        on_error: typing.Callable[
+            [HTTPConnection, AuthenticationError], Response
+        ] = None,
+    ) -> None:
+        self.app = app
+        self.backend = backend
+        self.on_error: typing.Callable[
+            [HTTPConnection, AuthenticationError], Response
+        ] = (on_error if on_error is not None else self.default_on_error)
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] not in ["http", "websocket"]:
+            await self.app(scope, receive, send)
+            return
+
+        conn = HTTPConnection(scope)
+        try:
+            auth_result = await self.backend.authenticate(conn)
+        except AuthenticationError as exc:
+            response = self.on_error(conn, exc)
+            if scope["type"] == "websocket":
+                await send({"type": "websocket.close", "code": 1000})
+            else:
+                await response(scope, receive, send)
+            return
+
+        if auth_result is None:
+            auth_result = AuthCredentials(), UnauthenticatedUser()
+        scope["auth"], scope["user"] = auth_result
+        await self.app(scope, receive, send)
+
+    @staticmethod
+    def default_on_error(conn: HTTPConnection, exc: Exception) -> Response:
+        return PlainTextResponse(str(exc), status_code=400)
diff --git a/myenv/lib/python3.9/site-packages/starlette/middleware/base.py b/myenv/lib/python3.9/site-packages/starlette/middleware/base.py
new file mode 100644
index 0000000..77ba669
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/middleware/base.py
@@ -0,0 +1,62 @@
+import typing
+
+import anyio
+
+from starlette.requests import Request
+from starlette.responses import Response, StreamingResponse
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+RequestResponseEndpoint = typing.Callable[[Request], typing.Awaitable[Response]]
+DispatchFunction = typing.Callable[
+    [Request, RequestResponseEndpoint], typing.Awaitable[Response]
+]
+
+
+class BaseHTTPMiddleware:
+    def __init__(self, app: ASGIApp, dispatch: DispatchFunction = None) -> None:
+        self.app = app
+        self.dispatch_func = self.dispatch if dispatch is None else dispatch
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        async def call_next(request: Request) -> Response:
+            send_stream, recv_stream = anyio.create_memory_object_stream()
+
+            async def coro() -> None:
+                async with send_stream:
+                    await self.app(scope, request.receive, send_stream.send)
+
+            task_group.start_soon(coro)
+
+            try:
+                message = await recv_stream.receive()
+            except anyio.EndOfStream:
+                raise RuntimeError("No response returned.")
+
+            assert message["type"] == "http.response.start"
+
+            async def body_stream() -> typing.AsyncGenerator[bytes, None]:
+                async with recv_stream:
+                    async for message in recv_stream:
+                        assert message["type"] == "http.response.body"
+                        yield message.get("body", b"")
+
+            response = StreamingResponse(
+                status_code=message["status"], content=body_stream()
+            )
+            response.raw_headers = message["headers"]
+            return response
+
+        async with anyio.create_task_group() as task_group:
+            request = Request(scope, receive=receive)
+            response = await self.dispatch_func(request, call_next)
+            await response(scope, receive, send)
+            task_group.cancel_scope.cancel()
+
+    async def dispatch(
+        self, request: Request, call_next: RequestResponseEndpoint
+    ) -> Response:
+        raise NotImplementedError()  # pragma: no cover
diff --git a/myenv/lib/python3.9/site-packages/starlette/middleware/cors.py b/myenv/lib/python3.9/site-packages/starlette/middleware/cors.py
new file mode 100644
index 0000000..c850579
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/middleware/cors.py
@@ -0,0 +1,177 @@
+import functools
+import re
+import typing
+
+from starlette.datastructures import Headers, MutableHeaders
+from starlette.responses import PlainTextResponse, Response
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+ALL_METHODS = ("DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT")
+SAFELISTED_HEADERS = {"Accept", "Accept-Language", "Content-Language", "Content-Type"}
+
+
+class CORSMiddleware:
+    def __init__(
+        self,
+        app: ASGIApp,
+        allow_origins: typing.Sequence[str] = (),
+        allow_methods: typing.Sequence[str] = ("GET",),
+        allow_headers: typing.Sequence[str] = (),
+        allow_credentials: bool = False,
+        allow_origin_regex: str = None,
+        expose_headers: typing.Sequence[str] = (),
+        max_age: int = 600,
+    ) -> None:
+
+        if "*" in allow_methods:
+            allow_methods = ALL_METHODS
+
+        compiled_allow_origin_regex = None
+        if allow_origin_regex is not None:
+            compiled_allow_origin_regex = re.compile(allow_origin_regex)
+
+        allow_all_origins = "*" in allow_origins
+        allow_all_headers = "*" in allow_headers
+        preflight_explicit_allow_origin = not allow_all_origins or allow_credentials
+
+        simple_headers = {}
+        if allow_all_origins:
+            simple_headers["Access-Control-Allow-Origin"] = "*"
+        if allow_credentials:
+            simple_headers["Access-Control-Allow-Credentials"] = "true"
+        if expose_headers:
+            simple_headers["Access-Control-Expose-Headers"] = ", ".join(expose_headers)
+
+        preflight_headers = {}
+        if preflight_explicit_allow_origin:
+            # The origin value will be set in preflight_response() if it is allowed.
+            preflight_headers["Vary"] = "Origin"
+        else:
+            preflight_headers["Access-Control-Allow-Origin"] = "*"
+        preflight_headers.update(
+            {
+                "Access-Control-Allow-Methods": ", ".join(allow_methods),
+                "Access-Control-Max-Age": str(max_age),
+            }
+        )
+        allow_headers = sorted(SAFELISTED_HEADERS | set(allow_headers))
+        if allow_headers and not allow_all_headers:
+            preflight_headers["Access-Control-Allow-Headers"] = ", ".join(allow_headers)
+        if allow_credentials:
+            preflight_headers["Access-Control-Allow-Credentials"] = "true"
+
+        self.app = app
+        self.allow_origins = allow_origins
+        self.allow_methods = allow_methods
+        self.allow_headers = [h.lower() for h in allow_headers]
+        self.allow_all_origins = allow_all_origins
+        self.allow_all_headers = allow_all_headers
+        self.preflight_explicit_allow_origin = preflight_explicit_allow_origin
+        self.allow_origin_regex = compiled_allow_origin_regex
+        self.simple_headers = simple_headers
+        self.preflight_headers = preflight_headers
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":  # pragma: no cover
+            await self.app(scope, receive, send)
+            return
+
+        method = scope["method"]
+        headers = Headers(scope=scope)
+        origin = headers.get("origin")
+
+        if origin is None:
+            await self.app(scope, receive, send)
+            return
+
+        if method == "OPTIONS" and "access-control-request-method" in headers:
+            response = self.preflight_response(request_headers=headers)
+            await response(scope, receive, send)
+            return
+
+        await self.simple_response(scope, receive, send, request_headers=headers)
+
+    def is_allowed_origin(self, origin: str) -> bool:
+        if self.allow_all_origins:
+            return True
+
+        if self.allow_origin_regex is not None and self.allow_origin_regex.fullmatch(
+            origin
+        ):
+            return True
+
+        return origin in self.allow_origins
+
+    def preflight_response(self, request_headers: Headers) -> Response:
+        requested_origin = request_headers["origin"]
+        requested_method = request_headers["access-control-request-method"]
+        requested_headers = request_headers.get("access-control-request-headers")
+
+        headers = dict(self.preflight_headers)
+        failures = []
+
+        if self.is_allowed_origin(origin=requested_origin):
+            if self.preflight_explicit_allow_origin:
+                # The "else" case is already accounted for in self.preflight_headers
+                # and the value would be "*".
+                headers["Access-Control-Allow-Origin"] = requested_origin
+        else:
+            failures.append("origin")
+
+        if requested_method not in self.allow_methods:
+            failures.append("method")
+
+        # If we allow all headers, then we have to mirror back any requested
+        # headers in the response.
+        if self.allow_all_headers and requested_headers is not None:
+            headers["Access-Control-Allow-Headers"] = requested_headers
+        elif requested_headers is not None:
+            for header in [h.lower() for h in requested_headers.split(",")]:
+                if header.strip() not in self.allow_headers:
+                    failures.append("headers")
+                    break
+
+        # We don't strictly need to use 400 responses here, since its up to
+        # the browser to enforce the CORS policy, but its more informative
+        # if we do.
+        if failures:
+            failure_text = "Disallowed CORS " + ", ".join(failures)
+            return PlainTextResponse(failure_text, status_code=400, headers=headers)
+
+        return PlainTextResponse("OK", status_code=200, headers=headers)
+
+    async def simple_response(
+        self, scope: Scope, receive: Receive, send: Send, request_headers: Headers
+    ) -> None:
+        send = functools.partial(self.send, send=send, request_headers=request_headers)
+        await self.app(scope, receive, send)
+
+    async def send(
+        self, message: Message, send: Send, request_headers: Headers
+    ) -> None:
+        if message["type"] != "http.response.start":
+            await send(message)
+            return
+
+        message.setdefault("headers", [])
+        headers = MutableHeaders(scope=message)
+        headers.update(self.simple_headers)
+        origin = request_headers["Origin"]
+        has_cookie = "cookie" in request_headers
+
+        # If request includes any cookie headers, then we must respond
+        # with the specific origin instead of '*'.
+        if self.allow_all_origins and has_cookie:
+            self.allow_explicit_origin(headers, origin)
+
+        # If we only allow specific origins, then we have to mirror back
+        # the Origin header in the response.
+        elif not self.allow_all_origins and self.is_allowed_origin(origin=origin):
+            self.allow_explicit_origin(headers, origin)
+
+        await send(message)
+
+    @staticmethod
+    def allow_explicit_origin(headers: MutableHeaders, origin: str) -> None:
+        headers["Access-Control-Allow-Origin"] = origin
+        headers.add_vary_header("Origin")
diff --git a/myenv/lib/python3.9/site-packages/starlette/middleware/errors.py b/myenv/lib/python3.9/site-packages/starlette/middleware/errors.py
new file mode 100644
index 0000000..30f5570
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/middleware/errors.py
@@ -0,0 +1,251 @@
+import asyncio
+import html
+import inspect
+import traceback
+import typing
+
+from starlette.concurrency import run_in_threadpool
+from starlette.requests import Request
+from starlette.responses import HTMLResponse, PlainTextResponse, Response
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+STYLES = """
+p {
+    color: #211c1c;
+}
+.traceback-container {
+    border: 1px solid #038BB8;
+}
+.traceback-title {
+    background-color: #038BB8;
+    color: lemonchiffon;
+    padding: 12px;
+    font-size: 20px;
+    margin-top: 0px;
+}
+.frame-line {
+    padding-left: 10px;
+    font-family: monospace;
+}
+.frame-filename {
+    font-family: monospace;
+}
+.center-line {
+    background-color: #038BB8;
+    color: #f9f6e1;
+    padding: 5px 0px 5px 5px;
+}
+.lineno {
+    margin-right: 5px;
+}
+.frame-title {
+    font-weight: unset;
+    padding: 10px 10px 10px 10px;
+    background-color: #E4F4FD;
+    margin-right: 10px;
+    color: #191f21;
+    font-size: 17px;
+    border: 1px solid #c7dce8;
+}
+.collapse-btn {
+    float: right;
+    padding: 0px 5px 1px 5px;
+    border: solid 1px #96aebb;
+    cursor: pointer;
+}
+.collapsed {
+  display: none;
+}
+.source-code {
+  font-family: courier;
+  font-size: small;
+  padding-bottom: 10px;
+}
+"""
+
+JS = """
+<script type="text/javascript">
+    function collapse(element){
+        const frameId = element.getAttribute("data-frame-id");
+        const frame = document.getElementById(frameId);
+
+        if (frame.classList.contains("collapsed")){
+            element.innerHTML = "&#8210;";
+            frame.classList.remove("collapsed");
+        } else {
+            element.innerHTML = "+";
+            frame.classList.add("collapsed");
+        }
+    }
+</script>
+"""
+
+TEMPLATE = """
+<html>
+    <head>
+        <style type='text/css'>
+            {styles}
+        </style>
+        <title>Starlette Debugger</title>
+    </head>
+    <body>
+        <h1>500 Server Error</h1>
+        <h2>{error}</h2>
+        <div class="traceback-container">
+            <p class="traceback-title">Traceback</p>
+            <div>{exc_html}</div>
+        </div>
+        {js}
+    </body>
+</html>
+"""
+
+FRAME_TEMPLATE = """
+<div>
+    <p class="frame-title">File <span class="frame-filename">{frame_filename}</span>,
+    line <i>{frame_lineno}</i>,
+    in <b>{frame_name}</b>
+    <span class="collapse-btn" data-frame-id="{frame_filename}-{frame_lineno}" onclick="collapse(this)">{collapse_button}</span>
+    </p>
+    <div id="{frame_filename}-{frame_lineno}" class="source-code {collapsed}">{code_context}</div>
+</div>
+"""  # noqa: E501
+
+LINE = """
+<p><span class="frame-line">
+<span class="lineno">{lineno}.</span> {line}</span></p>
+"""
+
+CENTER_LINE = """
+<p class="center-line"><span class="frame-line center-line">
+<span class="lineno">{lineno}.</span> {line}</span></p>
+"""
+
+
+class ServerErrorMiddleware:
+    """
+    Handles returning 500 responses when a server error occurs.
+
+    If 'debug' is set, then traceback responses will be returned,
+    otherwise the designated 'handler' will be called.
+
+    This middleware class should generally be used to wrap *everything*
+    else up, so that unhandled exceptions anywhere in the stack
+    always result in an appropriate 500 response.
+    """
+
+    def __init__(
+        self, app: ASGIApp, handler: typing.Callable = None, debug: bool = False
+    ) -> None:
+        self.app = app
+        self.handler = handler
+        self.debug = debug
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        response_started = False
+
+        async def _send(message: Message) -> None:
+            nonlocal response_started, send
+
+            if message["type"] == "http.response.start":
+                response_started = True
+            await send(message)
+
+        try:
+            await self.app(scope, receive, _send)
+        except Exception as exc:
+            if not response_started:
+                request = Request(scope)
+                if self.debug:
+                    # In debug mode, return traceback responses.
+                    response = self.debug_response(request, exc)
+                elif self.handler is None:
+                    # Use our default 500 error handler.
+                    response = self.error_response(request, exc)
+                else:
+                    # Use an installed 500 error handler.
+                    if asyncio.iscoroutinefunction(self.handler):
+                        response = await self.handler(request, exc)
+                    else:
+                        response = await run_in_threadpool(self.handler, request, exc)
+
+                await response(scope, receive, send)
+
+            # We always continue to raise the exception.
+            # This allows servers to log the error, or allows test clients
+            # to optionally raise the error within the test case.
+            raise exc
+
+    def format_line(
+        self, index: int, line: str, frame_lineno: int, frame_index: int
+    ) -> str:
+        values = {
+            # HTML escape - line could contain < or >
+            "line": html.escape(line).replace(" ", "&nbsp"),
+            "lineno": (frame_lineno - frame_index) + index,
+        }
+
+        if index != frame_index:
+            return LINE.format(**values)
+        return CENTER_LINE.format(**values)
+
+    def generate_frame_html(self, frame: inspect.FrameInfo, is_collapsed: bool) -> str:
+        code_context = "".join(
+            self.format_line(index, line, frame.lineno, frame.index)  # type: ignore
+            for index, line in enumerate(frame.code_context or [])
+        )
+
+        values = {
+            # HTML escape - filename could contain < or >, especially if it's a virtual
+            # file e.g. <stdin> in the REPL
+            "frame_filename": html.escape(frame.filename),
+            "frame_lineno": frame.lineno,
+            # HTML escape - if you try very hard it's possible to name a function with <
+            # or >
+            "frame_name": html.escape(frame.function),
+            "code_context": code_context,
+            "collapsed": "collapsed" if is_collapsed else "",
+            "collapse_button": "+" if is_collapsed else "&#8210;",
+        }
+        return FRAME_TEMPLATE.format(**values)
+
+    def generate_html(self, exc: Exception, limit: int = 7) -> str:
+        traceback_obj = traceback.TracebackException.from_exception(
+            exc, capture_locals=True
+        )
+
+        exc_html = ""
+        is_collapsed = False
+        exc_traceback = exc.__traceback__
+        if exc_traceback is not None:
+            frames = inspect.getinnerframes(exc_traceback, limit)
+            for frame in reversed(frames):
+                exc_html += self.generate_frame_html(frame, is_collapsed)
+                is_collapsed = True
+
+        # escape error class and text
+        error = (
+            f"{html.escape(traceback_obj.exc_type.__name__)}: "
+            f"{html.escape(str(traceback_obj))}"
+        )
+
+        return TEMPLATE.format(styles=STYLES, js=JS, error=error, exc_html=exc_html)
+
+    def generate_plain_text(self, exc: Exception) -> str:
+        return "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+
+    def debug_response(self, request: Request, exc: Exception) -> Response:
+        accept = request.headers.get("accept", "")
+
+        if "text/html" in accept:
+            content = self.generate_html(exc)
+            return HTMLResponse(content, status_code=500)
+        content = self.generate_plain_text(exc)
+        return PlainTextResponse(content, status_code=500)
+
+    def error_response(self, request: Request, exc: Exception) -> Response:
+        return PlainTextResponse("Internal Server Error", status_code=500)
diff --git a/myenv/lib/python3.9/site-packages/starlette/middleware/gzip.py b/myenv/lib/python3.9/site-packages/starlette/middleware/gzip.py
new file mode 100644
index 0000000..37c6936
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/middleware/gzip.py
@@ -0,0 +1,104 @@
+import gzip
+import io
+
+from starlette.datastructures import Headers, MutableHeaders
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+
+class GZipMiddleware:
+    def __init__(
+        self, app: ASGIApp, minimum_size: int = 500, compresslevel: int = 9
+    ) -> None:
+        self.app = app
+        self.minimum_size = minimum_size
+        self.compresslevel = compresslevel
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] == "http":
+            headers = Headers(scope=scope)
+            if "gzip" in headers.get("Accept-Encoding", ""):
+                responder = GZipResponder(
+                    self.app, self.minimum_size, compresslevel=self.compresslevel
+                )
+                await responder(scope, receive, send)
+                return
+        await self.app(scope, receive, send)
+
+
+class GZipResponder:
+    def __init__(self, app: ASGIApp, minimum_size: int, compresslevel: int = 9) -> None:
+        self.app = app
+        self.minimum_size = minimum_size
+        self.send: Send = unattached_send
+        self.initial_message: Message = {}
+        self.started = False
+        self.gzip_buffer = io.BytesIO()
+        self.gzip_file = gzip.GzipFile(
+            mode="wb", fileobj=self.gzip_buffer, compresslevel=compresslevel
+        )
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        self.send = send
+        await self.app(scope, receive, self.send_with_gzip)
+
+    async def send_with_gzip(self, message: Message) -> None:
+        message_type = message["type"]
+        if message_type == "http.response.start":
+            # Don't send the initial message until we've determined how to
+            # modify the outgoing headers correctly.
+            self.initial_message = message
+        elif message_type == "http.response.body" and not self.started:
+            self.started = True
+            body = message.get("body", b"")
+            more_body = message.get("more_body", False)
+            if len(body) < self.minimum_size and not more_body:
+                # Don't apply GZip to small outgoing responses.
+                await self.send(self.initial_message)
+                await self.send(message)
+            elif not more_body:
+                # Standard GZip response.
+                self.gzip_file.write(body)
+                self.gzip_file.close()
+                body = self.gzip_buffer.getvalue()
+
+                headers = MutableHeaders(raw=self.initial_message["headers"])
+                headers["Content-Encoding"] = "gzip"
+                headers["Content-Length"] = str(len(body))
+                headers.add_vary_header("Accept-Encoding")
+                message["body"] = body
+
+                await self.send(self.initial_message)
+                await self.send(message)
+            else:
+                # Initial body in streaming GZip response.
+                headers = MutableHeaders(raw=self.initial_message["headers"])
+                headers["Content-Encoding"] = "gzip"
+                headers.add_vary_header("Accept-Encoding")
+                del headers["Content-Length"]
+
+                self.gzip_file.write(body)
+                message["body"] = self.gzip_buffer.getvalue()
+                self.gzip_buffer.seek(0)
+                self.gzip_buffer.truncate()
+
+                await self.send(self.initial_message)
+                await self.send(message)
+
+        elif message_type == "http.response.body":
+            # Remaining body in streaming GZip response.
+            body = message.get("body", b"")
+            more_body = message.get("more_body", False)
+
+            self.gzip_file.write(body)
+            if not more_body:
+                self.gzip_file.close()
+
+            message["body"] = self.gzip_buffer.getvalue()
+            self.gzip_buffer.seek(0)
+            self.gzip_buffer.truncate()
+
+            await self.send(message)
+
+
+async def unattached_send(message: Message) -> None:
+    raise RuntimeError("send awaitable not set")  # pragma: no cover
diff --git a/myenv/lib/python3.9/site-packages/starlette/middleware/httpsredirect.py b/myenv/lib/python3.9/site-packages/starlette/middleware/httpsredirect.py
new file mode 100644
index 0000000..a835906
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/middleware/httpsredirect.py
@@ -0,0 +1,19 @@
+from starlette.datastructures import URL
+from starlette.responses import RedirectResponse
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+
+class HTTPSRedirectMiddleware:
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] in ("http", "websocket") and scope["scheme"] in ("http", "ws"):
+            url = URL(scope=scope)
+            redirect_scheme = {"http": "https", "ws": "wss"}[url.scheme]
+            netloc = url.hostname if url.port in (80, 443) else url.netloc
+            url = url.replace(scheme=redirect_scheme, netloc=netloc)
+            response = RedirectResponse(url, status_code=307)
+            await response(scope, receive, send)
+        else:
+            await self.app(scope, receive, send)
diff --git a/myenv/lib/python3.9/site-packages/starlette/middleware/sessions.py b/myenv/lib/python3.9/site-packages/starlette/middleware/sessions.py
new file mode 100644
index 0000000..a13ec5c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/middleware/sessions.py
@@ -0,0 +1,77 @@
+import json
+import typing
+from base64 import b64decode, b64encode
+
+import itsdangerous
+from itsdangerous.exc import BadTimeSignature, SignatureExpired
+
+from starlette.datastructures import MutableHeaders, Secret
+from starlette.requests import HTTPConnection
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+
+class SessionMiddleware:
+    def __init__(
+        self,
+        app: ASGIApp,
+        secret_key: typing.Union[str, Secret],
+        session_cookie: str = "session",
+        max_age: int = 14 * 24 * 60 * 60,  # 14 days, in seconds
+        same_site: str = "lax",
+        https_only: bool = False,
+    ) -> None:
+        self.app = app
+        self.signer = itsdangerous.TimestampSigner(str(secret_key))
+        self.session_cookie = session_cookie
+        self.max_age = max_age
+        self.security_flags = "httponly; samesite=" + same_site
+        if https_only:  # Secure flag can be used with HTTPS only
+            self.security_flags += "; secure"
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] not in ("http", "websocket"):  # pragma: no cover
+            await self.app(scope, receive, send)
+            return
+
+        connection = HTTPConnection(scope)
+        initial_session_was_empty = True
+
+        if self.session_cookie in connection.cookies:
+            data = connection.cookies[self.session_cookie].encode("utf-8")
+            try:
+                data = self.signer.unsign(data, max_age=self.max_age)
+                scope["session"] = json.loads(b64decode(data))
+                initial_session_was_empty = False
+            except (BadTimeSignature, SignatureExpired):
+                scope["session"] = {}
+        else:
+            scope["session"] = {}
+
+        async def send_wrapper(message: Message) -> None:
+            if message["type"] == "http.response.start":
+                path = scope.get("root_path", "") or "/"
+                if scope["session"]:
+                    # We have session data to persist.
+                    data = b64encode(json.dumps(scope["session"]).encode("utf-8"))
+                    data = self.signer.sign(data)
+                    headers = MutableHeaders(scope=message)
+                    header_value = "%s=%s; path=%s; Max-Age=%d; %s" % (
+                        self.session_cookie,
+                        data.decode("utf-8"),
+                        path,
+                        self.max_age,
+                        self.security_flags,
+                    )
+                    headers.append("Set-Cookie", header_value)
+                elif not initial_session_was_empty:
+                    # The session has been cleared.
+                    headers = MutableHeaders(scope=message)
+                    header_value = "{}={}; {}".format(
+                        self.session_cookie,
+                        f"null; path={path}; expires=Thu, 01 Jan 1970 00:00:00 GMT;",
+                        self.security_flags,
+                    )
+                    headers.append("Set-Cookie", header_value)
+            await send(message)
+
+        await self.app(scope, receive, send_wrapper)
diff --git a/myenv/lib/python3.9/site-packages/starlette/middleware/trustedhost.py b/myenv/lib/python3.9/site-packages/starlette/middleware/trustedhost.py
new file mode 100644
index 0000000..6bc4d2b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/middleware/trustedhost.py
@@ -0,0 +1,60 @@
+import typing
+
+from starlette.datastructures import URL, Headers
+from starlette.responses import PlainTextResponse, RedirectResponse, Response
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+ENFORCE_DOMAIN_WILDCARD = "Domain wildcard patterns must be like '*.example.com'."
+
+
+class TrustedHostMiddleware:
+    def __init__(
+        self,
+        app: ASGIApp,
+        allowed_hosts: typing.Sequence[str] = None,
+        www_redirect: bool = True,
+    ) -> None:
+        if allowed_hosts is None:
+            allowed_hosts = ["*"]
+
+        for pattern in allowed_hosts:
+            assert "*" not in pattern[1:], ENFORCE_DOMAIN_WILDCARD
+            if pattern.startswith("*") and pattern != "*":
+                assert pattern.startswith("*."), ENFORCE_DOMAIN_WILDCARD
+        self.app = app
+        self.allowed_hosts = list(allowed_hosts)
+        self.allow_any = "*" in allowed_hosts
+        self.www_redirect = www_redirect
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if self.allow_any or scope["type"] not in (
+            "http",
+            "websocket",
+        ):  # pragma: no cover
+            await self.app(scope, receive, send)
+            return
+
+        headers = Headers(scope=scope)
+        host = headers.get("host", "").split(":")[0]
+        is_valid_host = False
+        found_www_redirect = False
+        for pattern in self.allowed_hosts:
+            if host == pattern or (
+                pattern.startswith("*") and host.endswith(pattern[1:])
+            ):
+                is_valid_host = True
+                break
+            elif "www." + host == pattern:
+                found_www_redirect = True
+
+        if is_valid_host:
+            await self.app(scope, receive, send)
+        else:
+            response: Response
+            if found_www_redirect and self.www_redirect:
+                url = URL(scope=scope)
+                redirect_url = url.replace(netloc="www." + url.netloc)
+                response = RedirectResponse(url=str(redirect_url))
+            else:
+                response = PlainTextResponse("Invalid host header", status_code=400)
+            await response(scope, receive, send)
diff --git a/myenv/lib/python3.9/site-packages/starlette/middleware/wsgi.py b/myenv/lib/python3.9/site-packages/starlette/middleware/wsgi.py
new file mode 100644
index 0000000..7e69e1a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/middleware/wsgi.py
@@ -0,0 +1,133 @@
+import io
+import math
+import sys
+import typing
+
+import anyio
+
+from starlette.types import Receive, Scope, Send
+
+
+def build_environ(scope: Scope, body: bytes) -> dict:
+    """
+    Builds a scope and request body into a WSGI environ object.
+    """
+    environ = {
+        "REQUEST_METHOD": scope["method"],
+        "SCRIPT_NAME": scope.get("root_path", "").encode("utf8").decode("latin1"),
+        "PATH_INFO": scope["path"].encode("utf8").decode("latin1"),
+        "QUERY_STRING": scope["query_string"].decode("ascii"),
+        "SERVER_PROTOCOL": f"HTTP/{scope['http_version']}",
+        "wsgi.version": (1, 0),
+        "wsgi.url_scheme": scope.get("scheme", "http"),
+        "wsgi.input": io.BytesIO(body),
+        "wsgi.errors": sys.stdout,
+        "wsgi.multithread": True,
+        "wsgi.multiprocess": True,
+        "wsgi.run_once": False,
+    }
+
+    # Get server name and port - required in WSGI, not in ASGI
+    server = scope.get("server") or ("localhost", 80)
+    environ["SERVER_NAME"] = server[0]
+    environ["SERVER_PORT"] = server[1]
+
+    # Get client IP address
+    if scope.get("client"):
+        environ["REMOTE_ADDR"] = scope["client"][0]
+
+    # Go through headers and make them into environ entries
+    for name, value in scope.get("headers", []):
+        name = name.decode("latin1")
+        if name == "content-length":
+            corrected_name = "CONTENT_LENGTH"
+        elif name == "content-type":
+            corrected_name = "CONTENT_TYPE"
+        else:
+            corrected_name = f"HTTP_{name}".upper().replace("-", "_")
+        # HTTPbis say only ASCII chars are allowed in headers, but we latin1 just in
+        # case
+        value = value.decode("latin1")
+        if corrected_name in environ:
+            value = environ[corrected_name] + "," + value
+        environ[corrected_name] = value
+    return environ
+
+
+class WSGIMiddleware:
+    def __init__(self, app: typing.Callable) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        assert scope["type"] == "http"
+        responder = WSGIResponder(self.app, scope)
+        await responder(receive, send)
+
+
+class WSGIResponder:
+    def __init__(self, app: typing.Callable, scope: Scope) -> None:
+        self.app = app
+        self.scope = scope
+        self.status = None
+        self.response_headers = None
+        self.stream_send, self.stream_receive = anyio.create_memory_object_stream(
+            math.inf
+        )
+        self.response_started = False
+        self.exc_info: typing.Any = None
+
+    async def __call__(self, receive: Receive, send: Send) -> None:
+        body = b""
+        more_body = True
+        while more_body:
+            message = await receive()
+            body += message.get("body", b"")
+            more_body = message.get("more_body", False)
+        environ = build_environ(self.scope, body)
+
+        async with anyio.create_task_group() as task_group:
+            task_group.start_soon(self.sender, send)
+            async with self.stream_send:
+                await anyio.to_thread.run_sync(self.wsgi, environ, self.start_response)
+        if self.exc_info is not None:
+            raise self.exc_info[0].with_traceback(self.exc_info[1], self.exc_info[2])
+
+    async def sender(self, send: Send) -> None:
+        async with self.stream_receive:
+            async for message in self.stream_receive:
+                await send(message)
+
+    def start_response(
+        self,
+        status: str,
+        response_headers: typing.List[typing.Tuple[str, str]],
+        exc_info: typing.Any = None,
+    ) -> None:
+        self.exc_info = exc_info
+        if not self.response_started:
+            self.response_started = True
+            status_code_string, _ = status.split(" ", 1)
+            status_code = int(status_code_string)
+            headers = [
+                (name.strip().encode("ascii").lower(), value.strip().encode("ascii"))
+                for name, value in response_headers
+            ]
+            anyio.from_thread.run(
+                self.stream_send.send,
+                {
+                    "type": "http.response.start",
+                    "status": status_code,
+                    "headers": headers,
+                },
+            )
+
+    def wsgi(self, environ: dict, start_response: typing.Callable) -> None:
+        for chunk in self.app(environ, start_response):
+            anyio.from_thread.run(
+                self.stream_send.send,
+                {"type": "http.response.body", "body": chunk, "more_body": True},
+            )
+
+        anyio.from_thread.run(
+            self.stream_send.send, {"type": "http.response.body", "body": b""}
+        )
diff --git a/myenv/lib/python3.9/site-packages/starlette/py.typed b/myenv/lib/python3.9/site-packages/starlette/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/starlette/requests.py b/myenv/lib/python3.9/site-packages/starlette/requests.py
new file mode 100644
index 0000000..f880216
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/requests.py
@@ -0,0 +1,283 @@
+import json
+import typing
+from collections.abc import Mapping
+from http import cookies as http_cookies
+
+import anyio
+
+from starlette.datastructures import URL, Address, FormData, Headers, QueryParams, State
+from starlette.formparsers import FormParser, MultiPartParser
+from starlette.types import Message, Receive, Scope, Send
+
+try:
+    from multipart.multipart import parse_options_header
+except ImportError:  # pragma: nocover
+    parse_options_header = None
+
+
+SERVER_PUSH_HEADERS_TO_COPY = {
+    "accept",
+    "accept-encoding",
+    "accept-language",
+    "cache-control",
+    "user-agent",
+}
+
+
+def cookie_parser(cookie_string: str) -> typing.Dict[str, str]:
+    """
+    This function parses a ``Cookie`` HTTP header into a dict of key/value pairs.
+
+    It attempts to mimic browser cookie parsing behavior: browsers and web servers
+    frequently disregard the spec (RFC 6265) when setting and reading cookies,
+    so we attempt to suit the common scenarios here.
+
+    This function has been adapted from Django 3.1.0.
+    Note: we are explicitly _NOT_ using `SimpleCookie.load` because it is based
+    on an outdated spec and will fail on lots of input we want to support
+    """
+    cookie_dict: typing.Dict[str, str] = {}
+    for chunk in cookie_string.split(";"):
+        if "=" in chunk:
+            key, val = chunk.split("=", 1)
+        else:
+            # Assume an empty name per
+            # https://bugzilla.mozilla.org/show_bug.cgi?id=169091
+            key, val = "", chunk
+        key, val = key.strip(), val.strip()
+        if key or val:
+            # unquote using Python's algorithm.
+            cookie_dict[key] = http_cookies._unquote(val)  # type: ignore
+    return cookie_dict
+
+
+class ClientDisconnect(Exception):
+    pass
+
+
+class HTTPConnection(Mapping):
+    """
+    A base class for incoming HTTP connections, that is used to provide
+    any functionality that is common to both `Request` and `WebSocket`.
+    """
+
+    def __init__(self, scope: Scope, receive: Receive = None) -> None:
+        assert scope["type"] in ("http", "websocket")
+        self.scope = scope
+
+    def __getitem__(self, key: str) -> str:
+        return self.scope[key]
+
+    def __iter__(self) -> typing.Iterator[str]:
+        return iter(self.scope)
+
+    def __len__(self) -> int:
+        return len(self.scope)
+
+    # Don't use the `abc.Mapping.__eq__` implementation.
+    # Connection instances should never be considered equal
+    # unless `self is other`.
+    __eq__ = object.__eq__
+    __hash__ = object.__hash__
+
+    @property
+    def app(self) -> typing.Any:
+        return self.scope["app"]
+
+    @property
+    def url(self) -> URL:
+        if not hasattr(self, "_url"):
+            self._url = URL(scope=self.scope)
+        return self._url
+
+    @property
+    def base_url(self) -> URL:
+        if not hasattr(self, "_base_url"):
+            base_url_scope = dict(self.scope)
+            base_url_scope["path"] = "/"
+            base_url_scope["query_string"] = b""
+            base_url_scope["root_path"] = base_url_scope.get(
+                "app_root_path", base_url_scope.get("root_path", "")
+            )
+            self._base_url = URL(scope=base_url_scope)
+        return self._base_url
+
+    @property
+    def headers(self) -> Headers:
+        if not hasattr(self, "_headers"):
+            self._headers = Headers(scope=self.scope)
+        return self._headers
+
+    @property
+    def query_params(self) -> QueryParams:
+        if not hasattr(self, "_query_params"):
+            self._query_params = QueryParams(self.scope["query_string"])
+        return self._query_params
+
+    @property
+    def path_params(self) -> dict:
+        return self.scope.get("path_params", {})
+
+    @property
+    def cookies(self) -> typing.Dict[str, str]:
+        if not hasattr(self, "_cookies"):
+            cookies: typing.Dict[str, str] = {}
+            cookie_header = self.headers.get("cookie")
+
+            if cookie_header:
+                cookies = cookie_parser(cookie_header)
+            self._cookies = cookies
+        return self._cookies
+
+    @property
+    def client(self) -> Address:
+        host, port = self.scope.get("client") or (None, None)
+        return Address(host=host, port=port)
+
+    @property
+    def session(self) -> dict:
+        assert (
+            "session" in self.scope
+        ), "SessionMiddleware must be installed to access request.session"
+        return self.scope["session"]
+
+    @property
+    def auth(self) -> typing.Any:
+        assert (
+            "auth" in self.scope
+        ), "AuthenticationMiddleware must be installed to access request.auth"
+        return self.scope["auth"]
+
+    @property
+    def user(self) -> typing.Any:
+        assert (
+            "user" in self.scope
+        ), "AuthenticationMiddleware must be installed to access request.user"
+        return self.scope["user"]
+
+    @property
+    def state(self) -> State:
+        if not hasattr(self, "_state"):
+            # Ensure 'state' has an empty dict if it's not already populated.
+            self.scope.setdefault("state", {})
+            # Create a state instance with a reference to the dict in which it should
+            # store info
+            self._state = State(self.scope["state"])
+        return self._state
+
+    def url_for(self, name: str, **path_params: typing.Any) -> str:
+        router = self.scope["router"]
+        url_path = router.url_path_for(name, **path_params)
+        return url_path.make_absolute_url(base_url=self.base_url)
+
+
+async def empty_receive() -> Message:
+    raise RuntimeError("Receive channel has not been made available")
+
+
+async def empty_send(message: Message) -> None:
+    raise RuntimeError("Send channel has not been made available")
+
+
+class Request(HTTPConnection):
+    def __init__(
+        self, scope: Scope, receive: Receive = empty_receive, send: Send = empty_send
+    ):
+        super().__init__(scope)
+        assert scope["type"] == "http"
+        self._receive = receive
+        self._send = send
+        self._stream_consumed = False
+        self._is_disconnected = False
+
+    @property
+    def method(self) -> str:
+        return self.scope["method"]
+
+    @property
+    def receive(self) -> Receive:
+        return self._receive
+
+    async def stream(self) -> typing.AsyncGenerator[bytes, None]:
+        if hasattr(self, "_body"):
+            yield self._body
+            yield b""
+            return
+
+        if self._stream_consumed:
+            raise RuntimeError("Stream consumed")
+
+        self._stream_consumed = True
+        while True:
+            message = await self._receive()
+            if message["type"] == "http.request":
+                body = message.get("body", b"")
+                if body:
+                    yield body
+                if not message.get("more_body", False):
+                    break
+            elif message["type"] == "http.disconnect":
+                self._is_disconnected = True
+                raise ClientDisconnect()
+        yield b""
+
+    async def body(self) -> bytes:
+        if not hasattr(self, "_body"):
+            chunks = []
+            async for chunk in self.stream():
+                chunks.append(chunk)
+            self._body = b"".join(chunks)
+        return self._body
+
+    async def json(self) -> typing.Any:
+        if not hasattr(self, "_json"):
+            body = await self.body()
+            self._json = json.loads(body)
+        return self._json
+
+    async def form(self) -> FormData:
+        if not hasattr(self, "_form"):
+            assert (
+                parse_options_header is not None
+            ), "The `python-multipart` library must be installed to use form parsing."
+            content_type_header = self.headers.get("Content-Type")
+            content_type, options = parse_options_header(content_type_header)
+            if content_type == b"multipart/form-data":
+                multipart_parser = MultiPartParser(self.headers, self.stream())
+                self._form = await multipart_parser.parse()
+            elif content_type == b"application/x-www-form-urlencoded":
+                form_parser = FormParser(self.headers, self.stream())
+                self._form = await form_parser.parse()
+            else:
+                self._form = FormData()
+        return self._form
+
+    async def close(self) -> None:
+        if hasattr(self, "_form"):
+            await self._form.close()
+
+    async def is_disconnected(self) -> bool:
+        if not self._is_disconnected:
+            message: Message = {}
+
+            # If message isn't immediately available, move on
+            with anyio.CancelScope() as cs:
+                cs.cancel()
+                message = await self._receive()
+
+            if message.get("type") == "http.disconnect":
+                self._is_disconnected = True
+
+        return self._is_disconnected
+
+    async def send_push_promise(self, path: str) -> None:
+        if "http.response.push" in self.scope.get("extensions", {}):
+            raw_headers = []
+            for name in SERVER_PUSH_HEADERS_TO_COPY:
+                for value in self.headers.getlist(name):
+                    raw_headers.append(
+                        (name.encode("latin-1"), value.encode("latin-1"))
+                    )
+            await self._send(
+                {"type": "http.response.push", "path": path, "headers": raw_headers}
+            )
diff --git a/myenv/lib/python3.9/site-packages/starlette/responses.py b/myenv/lib/python3.9/site-packages/starlette/responses.py
new file mode 100644
index 0000000..d03df23
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/responses.py
@@ -0,0 +1,313 @@
+import hashlib
+import http.cookies
+import json
+import os
+import stat
+import sys
+import typing
+from email.utils import formatdate
+from functools import partial
+from mimetypes import guess_type as mimetypes_guess_type
+from urllib.parse import quote
+
+import anyio
+
+from starlette.background import BackgroundTask
+from starlette.concurrency import iterate_in_threadpool
+from starlette.datastructures import URL, MutableHeaders
+from starlette.types import Receive, Scope, Send
+
+# Workaround for adding samesite support to pre 3.8 python
+http.cookies.Morsel._reserved["samesite"] = "SameSite"  # type: ignore
+
+
+# Compatibility wrapper for `mimetypes.guess_type` to support `os.PathLike` on <py3.8
+def guess_type(
+    url: typing.Union[str, "os.PathLike[str]"], strict: bool = True
+) -> typing.Tuple[typing.Optional[str], typing.Optional[str]]:
+    if sys.version_info < (3, 8):  # pragma: no cover
+        url = os.fspath(url)
+    return mimetypes_guess_type(url, strict)
+
+
+class Response:
+    media_type = None
+    charset = "utf-8"
+
+    def __init__(
+        self,
+        content: typing.Any = None,
+        status_code: int = 200,
+        headers: dict = None,
+        media_type: str = None,
+        background: BackgroundTask = None,
+    ) -> None:
+        self.status_code = status_code
+        if media_type is not None:
+            self.media_type = media_type
+        self.background = background
+        self.body = self.render(content)
+        self.init_headers(headers)
+
+    def render(self, content: typing.Any) -> bytes:
+        if content is None:
+            return b""
+        if isinstance(content, bytes):
+            return content
+        return content.encode(self.charset)
+
+    def init_headers(self, headers: typing.Mapping[str, str] = None) -> None:
+        if headers is None:
+            raw_headers: typing.List[typing.Tuple[bytes, bytes]] = []
+            populate_content_length = True
+            populate_content_type = True
+        else:
+            raw_headers = [
+                (k.lower().encode("latin-1"), v.encode("latin-1"))
+                for k, v in headers.items()
+            ]
+            keys = [h[0] for h in raw_headers]
+            populate_content_length = b"content-length" not in keys
+            populate_content_type = b"content-type" not in keys
+
+        body = getattr(self, "body", b"")
+        if body and populate_content_length:
+            content_length = str(len(body))
+            raw_headers.append((b"content-length", content_length.encode("latin-1")))
+
+        content_type = self.media_type
+        if content_type is not None and populate_content_type:
+            if content_type.startswith("text/"):
+                content_type += "; charset=" + self.charset
+            raw_headers.append((b"content-type", content_type.encode("latin-1")))
+
+        self.raw_headers = raw_headers
+
+    @property
+    def headers(self) -> MutableHeaders:
+        if not hasattr(self, "_headers"):
+            self._headers = MutableHeaders(raw=self.raw_headers)
+        return self._headers
+
+    def set_cookie(
+        self,
+        key: str,
+        value: str = "",
+        max_age: int = None,
+        expires: int = None,
+        path: str = "/",
+        domain: str = None,
+        secure: bool = False,
+        httponly: bool = False,
+        samesite: str = "lax",
+    ) -> None:
+        cookie: http.cookies.BaseCookie = http.cookies.SimpleCookie()
+        cookie[key] = value
+        if max_age is not None:
+            cookie[key]["max-age"] = max_age
+        if expires is not None:
+            cookie[key]["expires"] = expires
+        if path is not None:
+            cookie[key]["path"] = path
+        if domain is not None:
+            cookie[key]["domain"] = domain
+        if secure:
+            cookie[key]["secure"] = True
+        if httponly:
+            cookie[key]["httponly"] = True
+        if samesite is not None:
+            assert samesite.lower() in [
+                "strict",
+                "lax",
+                "none",
+            ], "samesite must be either 'strict', 'lax' or 'none'"
+            cookie[key]["samesite"] = samesite
+        cookie_val = cookie.output(header="").strip()
+        self.raw_headers.append((b"set-cookie", cookie_val.encode("latin-1")))
+
+    def delete_cookie(self, key: str, path: str = "/", domain: str = None) -> None:
+        self.set_cookie(key, expires=0, max_age=0, path=path, domain=domain)
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        await send(
+            {
+                "type": "http.response.start",
+                "status": self.status_code,
+                "headers": self.raw_headers,
+            }
+        )
+        await send({"type": "http.response.body", "body": self.body})
+
+        if self.background is not None:
+            await self.background()
+
+
+class HTMLResponse(Response):
+    media_type = "text/html"
+
+
+class PlainTextResponse(Response):
+    media_type = "text/plain"
+
+
+class JSONResponse(Response):
+    media_type = "application/json"
+
+    def render(self, content: typing.Any) -> bytes:
+        return json.dumps(
+            content,
+            ensure_ascii=False,
+            allow_nan=False,
+            indent=None,
+            separators=(",", ":"),
+        ).encode("utf-8")
+
+
+class RedirectResponse(Response):
+    def __init__(
+        self,
+        url: typing.Union[str, URL],
+        status_code: int = 307,
+        headers: dict = None,
+        background: BackgroundTask = None,
+    ) -> None:
+        super().__init__(
+            content=b"", status_code=status_code, headers=headers, background=background
+        )
+        self.headers["location"] = quote(str(url), safe=":/%#?=@[]!$&'()*+,;")
+
+
+class StreamingResponse(Response):
+    def __init__(
+        self,
+        content: typing.Any,
+        status_code: int = 200,
+        headers: dict = None,
+        media_type: str = None,
+        background: BackgroundTask = None,
+    ) -> None:
+        if isinstance(content, typing.AsyncIterable):
+            self.body_iterator = content
+        else:
+            self.body_iterator = iterate_in_threadpool(content)
+        self.status_code = status_code
+        self.media_type = self.media_type if media_type is None else media_type
+        self.background = background
+        self.init_headers(headers)
+
+    async def listen_for_disconnect(self, receive: Receive) -> None:
+        while True:
+            message = await receive()
+            if message["type"] == "http.disconnect":
+                break
+
+    async def stream_response(self, send: Send) -> None:
+        await send(
+            {
+                "type": "http.response.start",
+                "status": self.status_code,
+                "headers": self.raw_headers,
+            }
+        )
+        async for chunk in self.body_iterator:
+            if not isinstance(chunk, bytes):
+                chunk = chunk.encode(self.charset)
+            await send({"type": "http.response.body", "body": chunk, "more_body": True})
+
+        await send({"type": "http.response.body", "body": b"", "more_body": False})
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        async with anyio.create_task_group() as task_group:
+
+            async def wrap(func: typing.Callable[[], typing.Coroutine]) -> None:
+                await func()
+                task_group.cancel_scope.cancel()
+
+            task_group.start_soon(wrap, partial(self.stream_response, send))
+            await wrap(partial(self.listen_for_disconnect, receive))
+
+        if self.background is not None:
+            await self.background()
+
+
+class FileResponse(Response):
+    chunk_size = 4096
+
+    def __init__(
+        self,
+        path: typing.Union[str, "os.PathLike[str]"],
+        status_code: int = 200,
+        headers: dict = None,
+        media_type: str = None,
+        background: BackgroundTask = None,
+        filename: str = None,
+        stat_result: os.stat_result = None,
+        method: str = None,
+    ) -> None:
+        self.path = path
+        self.status_code = status_code
+        self.filename = filename
+        self.send_header_only = method is not None and method.upper() == "HEAD"
+        if media_type is None:
+            media_type = guess_type(filename or path)[0] or "text/plain"
+        self.media_type = media_type
+        self.background = background
+        self.init_headers(headers)
+        if self.filename is not None:
+            content_disposition_filename = quote(self.filename)
+            if content_disposition_filename != self.filename:
+                content_disposition = "attachment; filename*=utf-8''{}".format(
+                    content_disposition_filename
+                )
+            else:
+                content_disposition = f'attachment; filename="{self.filename}"'
+            self.headers.setdefault("content-disposition", content_disposition)
+        self.stat_result = stat_result
+        if stat_result is not None:
+            self.set_stat_headers(stat_result)
+
+    def set_stat_headers(self, stat_result: os.stat_result) -> None:
+        content_length = str(stat_result.st_size)
+        last_modified = formatdate(stat_result.st_mtime, usegmt=True)
+        etag_base = str(stat_result.st_mtime) + "-" + str(stat_result.st_size)
+        etag = hashlib.md5(etag_base.encode()).hexdigest()
+
+        self.headers.setdefault("content-length", content_length)
+        self.headers.setdefault("last-modified", last_modified)
+        self.headers.setdefault("etag", etag)
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if self.stat_result is None:
+            try:
+                stat_result = await anyio.to_thread.run_sync(os.stat, self.path)
+                self.set_stat_headers(stat_result)
+            except FileNotFoundError:
+                raise RuntimeError(f"File at path {self.path} does not exist.")
+            else:
+                mode = stat_result.st_mode
+                if not stat.S_ISREG(mode):
+                    raise RuntimeError(f"File at path {self.path} is not a file.")
+        await send(
+            {
+                "type": "http.response.start",
+                "status": self.status_code,
+                "headers": self.raw_headers,
+            }
+        )
+        if self.send_header_only:
+            await send({"type": "http.response.body", "body": b"", "more_body": False})
+        else:
+            async with await anyio.open_file(self.path, mode="rb") as file:
+                more_body = True
+                while more_body:
+                    chunk = await file.read(self.chunk_size)
+                    more_body = len(chunk) == self.chunk_size
+                    await send(
+                        {
+                            "type": "http.response.body",
+                            "body": chunk,
+                            "more_body": more_body,
+                        }
+                    )
+        if self.background is not None:
+            await self.background()
diff --git a/myenv/lib/python3.9/site-packages/starlette/routing.py b/myenv/lib/python3.9/site-packages/starlette/routing.py
new file mode 100644
index 0000000..9a1a5e1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/routing.py
@@ -0,0 +1,762 @@
+import asyncio
+import contextlib
+import functools
+import inspect
+import re
+import sys
+import traceback
+import types
+import typing
+import warnings
+from enum import Enum
+
+from starlette.concurrency import run_in_threadpool
+from starlette.convertors import CONVERTOR_TYPES, Convertor
+from starlette.datastructures import URL, Headers, URLPath
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import PlainTextResponse, RedirectResponse
+from starlette.types import ASGIApp, Receive, Scope, Send
+from starlette.websockets import WebSocket, WebSocketClose
+
+if sys.version_info >= (3, 7):
+    from contextlib import asynccontextmanager  # pragma: no cover
+else:
+    from contextlib2 import asynccontextmanager  # pragma: no cover
+
+
+class NoMatchFound(Exception):
+    """
+    Raised by `.url_for(name, **path_params)` and `.url_path_for(name, **path_params)`
+    if no matching route exists.
+    """
+
+
+class Match(Enum):
+    NONE = 0
+    PARTIAL = 1
+    FULL = 2
+
+
+def iscoroutinefunction_or_partial(obj: typing.Any) -> bool:
+    """
+    Correctly determines if an object is a coroutine function,
+    including those wrapped in functools.partial objects.
+    """
+    while isinstance(obj, functools.partial):
+        obj = obj.func
+    return inspect.iscoroutinefunction(obj)
+
+
+def request_response(func: typing.Callable) -> ASGIApp:
+    """
+    Takes a function or coroutine `func(request) -> response`,
+    and returns an ASGI application.
+    """
+    is_coroutine = iscoroutinefunction_or_partial(func)
+
+    async def app(scope: Scope, receive: Receive, send: Send) -> None:
+        request = Request(scope, receive=receive, send=send)
+        if is_coroutine:
+            response = await func(request)
+        else:
+            response = await run_in_threadpool(func, request)
+        await response(scope, receive, send)
+
+    return app
+
+
+def websocket_session(func: typing.Callable) -> ASGIApp:
+    """
+    Takes a coroutine `func(session)`, and returns an ASGI application.
+    """
+    # assert asyncio.iscoroutinefunction(func), "WebSocket endpoints must be async"
+
+    async def app(scope: Scope, receive: Receive, send: Send) -> None:
+        session = WebSocket(scope, receive=receive, send=send)
+        await func(session)
+
+    return app
+
+
+def get_name(endpoint: typing.Callable) -> str:
+    if inspect.isfunction(endpoint) or inspect.isclass(endpoint):
+        return endpoint.__name__
+    return endpoint.__class__.__name__
+
+
+def replace_params(
+    path: str,
+    param_convertors: typing.Dict[str, Convertor],
+    path_params: typing.Dict[str, str],
+) -> typing.Tuple[str, dict]:
+    for key, value in list(path_params.items()):
+        if "{" + key + "}" in path:
+            convertor = param_convertors[key]
+            value = convertor.to_string(value)
+            path = path.replace("{" + key + "}", value)
+            path_params.pop(key)
+    return path, path_params
+
+
+# Match parameters in URL paths, eg. '{param}', and '{param:int}'
+PARAM_REGEX = re.compile("{([a-zA-Z_][a-zA-Z0-9_]*)(:[a-zA-Z_][a-zA-Z0-9_]*)?}")
+
+
+def compile_path(
+    path: str,
+) -> typing.Tuple[typing.Pattern, str, typing.Dict[str, Convertor]]:
+    """
+    Given a path string, like: "/{username:str}", return a three-tuple
+    of (regex, format, {param_name:convertor}).
+
+    regex:      "/(?P<username>[^/]+)"
+    format:     "/{username}"
+    convertors: {"username": StringConvertor()}
+    """
+    path_regex = "^"
+    path_format = ""
+    duplicated_params = set()
+
+    idx = 0
+    param_convertors = {}
+    for match in PARAM_REGEX.finditer(path):
+        param_name, convertor_type = match.groups("str")
+        convertor_type = convertor_type.lstrip(":")
+        assert (
+            convertor_type in CONVERTOR_TYPES
+        ), f"Unknown path convertor '{convertor_type}'"
+        convertor = CONVERTOR_TYPES[convertor_type]
+
+        path_regex += re.escape(path[idx : match.start()])
+        path_regex += f"(?P<{param_name}>{convertor.regex})"
+
+        path_format += path[idx : match.start()]
+        path_format += "{%s}" % param_name
+
+        if param_name in param_convertors:
+            duplicated_params.add(param_name)
+
+        param_convertors[param_name] = convertor
+
+        idx = match.end()
+
+    if duplicated_params:
+        names = ", ".join(sorted(duplicated_params))
+        ending = "s" if len(duplicated_params) > 1 else ""
+        raise ValueError(f"Duplicated param name{ending} {names} at path {path}")
+
+    path_regex += re.escape(path[idx:]) + "$"
+    path_format += path[idx:]
+
+    return re.compile(path_regex), path_format, param_convertors
+
+
+class BaseRoute:
+    def matches(self, scope: Scope) -> typing.Tuple[Match, Scope]:
+        raise NotImplementedError()  # pragma: no cover
+
+    def url_path_for(self, name: str, **path_params: str) -> URLPath:
+        raise NotImplementedError()  # pragma: no cover
+
+    async def handle(self, scope: Scope, receive: Receive, send: Send) -> None:
+        raise NotImplementedError()  # pragma: no cover
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        """
+        A route may be used in isolation as a stand-alone ASGI app.
+        This is a somewhat contrived case, as they'll almost always be used
+        within a Router, but could be useful for some tooling and minimal apps.
+        """
+        match, child_scope = self.matches(scope)
+        if match == Match.NONE:
+            if scope["type"] == "http":
+                response = PlainTextResponse("Not Found", status_code=404)
+                await response(scope, receive, send)
+            elif scope["type"] == "websocket":
+                websocket_close = WebSocketClose()
+                await websocket_close(scope, receive, send)
+            return
+
+        scope.update(child_scope)
+        await self.handle(scope, receive, send)
+
+
+class Route(BaseRoute):
+    def __init__(
+        self,
+        path: str,
+        endpoint: typing.Callable,
+        *,
+        methods: typing.List[str] = None,
+        name: str = None,
+        include_in_schema: bool = True,
+    ) -> None:
+        assert path.startswith("/"), "Routed paths must start with '/'"
+        self.path = path
+        self.endpoint = endpoint
+        self.name = get_name(endpoint) if name is None else name
+        self.include_in_schema = include_in_schema
+
+        endpoint_handler = endpoint
+        while isinstance(endpoint_handler, functools.partial):
+            endpoint_handler = endpoint_handler.func
+        if inspect.isfunction(endpoint_handler) or inspect.ismethod(endpoint_handler):
+            # Endpoint is function or method. Treat it as `func(request) -> response`.
+            self.app = request_response(endpoint)
+            if methods is None:
+                methods = ["GET"]
+        else:
+            # Endpoint is a class. Treat it as ASGI.
+            self.app = endpoint
+
+        if methods is None:
+            self.methods = None
+        else:
+            self.methods = {method.upper() for method in methods}
+            if "GET" in self.methods:
+                self.methods.add("HEAD")
+
+        self.path_regex, self.path_format, self.param_convertors = compile_path(path)
+
+    def matches(self, scope: Scope) -> typing.Tuple[Match, Scope]:
+        if scope["type"] == "http":
+            match = self.path_regex.match(scope["path"])
+            if match:
+                matched_params = match.groupdict()
+                for key, value in matched_params.items():
+                    matched_params[key] = self.param_convertors[key].convert(value)
+                path_params = dict(scope.get("path_params", {}))
+                path_params.update(matched_params)
+                child_scope = {"endpoint": self.endpoint, "path_params": path_params}
+                if self.methods and scope["method"] not in self.methods:
+                    return Match.PARTIAL, child_scope
+                else:
+                    return Match.FULL, child_scope
+        return Match.NONE, {}
+
+    def url_path_for(self, name: str, **path_params: str) -> URLPath:
+        seen_params = set(path_params.keys())
+        expected_params = set(self.param_convertors.keys())
+
+        if name != self.name or seen_params != expected_params:
+            raise NoMatchFound()
+
+        path, remaining_params = replace_params(
+            self.path_format, self.param_convertors, path_params
+        )
+        assert not remaining_params
+        return URLPath(path=path, protocol="http")
+
+    async def handle(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if self.methods and scope["method"] not in self.methods:
+            if "app" in scope:
+                raise HTTPException(status_code=405)
+            else:
+                response = PlainTextResponse("Method Not Allowed", status_code=405)
+            await response(scope, receive, send)
+        else:
+            await self.app(scope, receive, send)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, Route)
+            and self.path == other.path
+            and self.endpoint == other.endpoint
+            and self.methods == other.methods
+        )
+
+
+class WebSocketRoute(BaseRoute):
+    def __init__(
+        self, path: str, endpoint: typing.Callable, *, name: str = None
+    ) -> None:
+        assert path.startswith("/"), "Routed paths must start with '/'"
+        self.path = path
+        self.endpoint = endpoint
+        self.name = get_name(endpoint) if name is None else name
+
+        if inspect.isfunction(endpoint) or inspect.ismethod(endpoint):
+            # Endpoint is function or method. Treat it as `func(websocket)`.
+            self.app = websocket_session(endpoint)
+        else:
+            # Endpoint is a class. Treat it as ASGI.
+            self.app = endpoint
+
+        self.path_regex, self.path_format, self.param_convertors = compile_path(path)
+
+    def matches(self, scope: Scope) -> typing.Tuple[Match, Scope]:
+        if scope["type"] == "websocket":
+            match = self.path_regex.match(scope["path"])
+            if match:
+                matched_params = match.groupdict()
+                for key, value in matched_params.items():
+                    matched_params[key] = self.param_convertors[key].convert(value)
+                path_params = dict(scope.get("path_params", {}))
+                path_params.update(matched_params)
+                child_scope = {"endpoint": self.endpoint, "path_params": path_params}
+                return Match.FULL, child_scope
+        return Match.NONE, {}
+
+    def url_path_for(self, name: str, **path_params: str) -> URLPath:
+        seen_params = set(path_params.keys())
+        expected_params = set(self.param_convertors.keys())
+
+        if name != self.name or seen_params != expected_params:
+            raise NoMatchFound()
+
+        path, remaining_params = replace_params(
+            self.path_format, self.param_convertors, path_params
+        )
+        assert not remaining_params
+        return URLPath(path=path, protocol="websocket")
+
+    async def handle(self, scope: Scope, receive: Receive, send: Send) -> None:
+        await self.app(scope, receive, send)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, WebSocketRoute)
+            and self.path == other.path
+            and self.endpoint == other.endpoint
+        )
+
+
+class Mount(BaseRoute):
+    def __init__(
+        self,
+        path: str,
+        app: ASGIApp = None,
+        routes: typing.Sequence[BaseRoute] = None,
+        name: str = None,
+    ) -> None:
+        assert path == "" or path.startswith("/"), "Routed paths must start with '/'"
+        assert (
+            app is not None or routes is not None
+        ), "Either 'app=...', or 'routes=' must be specified"
+        self.path = path.rstrip("/")
+        if app is not None:
+            self.app: ASGIApp = app
+        else:
+            self.app = Router(routes=routes)
+        self.name = name
+        self.path_regex, self.path_format, self.param_convertors = compile_path(
+            self.path + "/{path:path}"
+        )
+
+    @property
+    def routes(self) -> typing.List[BaseRoute]:
+        return getattr(self.app, "routes", None)
+
+    def matches(self, scope: Scope) -> typing.Tuple[Match, Scope]:
+        if scope["type"] in ("http", "websocket"):
+            path = scope["path"]
+            match = self.path_regex.match(path)
+            if match:
+                matched_params = match.groupdict()
+                for key, value in matched_params.items():
+                    matched_params[key] = self.param_convertors[key].convert(value)
+                remaining_path = "/" + matched_params.pop("path")
+                matched_path = path[: -len(remaining_path)]
+                path_params = dict(scope.get("path_params", {}))
+                path_params.update(matched_params)
+                root_path = scope.get("root_path", "")
+                child_scope = {
+                    "path_params": path_params,
+                    "app_root_path": scope.get("app_root_path", root_path),
+                    "root_path": root_path + matched_path,
+                    "path": remaining_path,
+                    "endpoint": self.app,
+                }
+                return Match.FULL, child_scope
+        return Match.NONE, {}
+
+    def url_path_for(self, name: str, **path_params: str) -> URLPath:
+        if self.name is not None and name == self.name and "path" in path_params:
+            # 'name' matches "<mount_name>".
+            path_params["path"] = path_params["path"].lstrip("/")
+            path, remaining_params = replace_params(
+                self.path_format, self.param_convertors, path_params
+            )
+            if not remaining_params:
+                return URLPath(path=path)
+        elif self.name is None or name.startswith(self.name + ":"):
+            if self.name is None:
+                # No mount name.
+                remaining_name = name
+            else:
+                # 'name' matches "<mount_name>:<child_name>".
+                remaining_name = name[len(self.name) + 1 :]
+            path_kwarg = path_params.get("path")
+            path_params["path"] = ""
+            path_prefix, remaining_params = replace_params(
+                self.path_format, self.param_convertors, path_params
+            )
+            if path_kwarg is not None:
+                remaining_params["path"] = path_kwarg
+            for route in self.routes or []:
+                try:
+                    url = route.url_path_for(remaining_name, **remaining_params)
+                    return URLPath(
+                        path=path_prefix.rstrip("/") + str(url), protocol=url.protocol
+                    )
+                except NoMatchFound:
+                    pass
+        raise NoMatchFound()
+
+    async def handle(self, scope: Scope, receive: Receive, send: Send) -> None:
+        await self.app(scope, receive, send)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, Mount)
+            and self.path == other.path
+            and self.app == other.app
+        )
+
+
+class Host(BaseRoute):
+    def __init__(self, host: str, app: ASGIApp, name: str = None) -> None:
+        self.host = host
+        self.app = app
+        self.name = name
+        self.host_regex, self.host_format, self.param_convertors = compile_path(host)
+
+    @property
+    def routes(self) -> typing.List[BaseRoute]:
+        return getattr(self.app, "routes", None)
+
+    def matches(self, scope: Scope) -> typing.Tuple[Match, Scope]:
+        if scope["type"] in ("http", "websocket"):
+            headers = Headers(scope=scope)
+            host = headers.get("host", "").split(":")[0]
+            match = self.host_regex.match(host)
+            if match:
+                matched_params = match.groupdict()
+                for key, value in matched_params.items():
+                    matched_params[key] = self.param_convertors[key].convert(value)
+                path_params = dict(scope.get("path_params", {}))
+                path_params.update(matched_params)
+                child_scope = {"path_params": path_params, "endpoint": self.app}
+                return Match.FULL, child_scope
+        return Match.NONE, {}
+
+    def url_path_for(self, name: str, **path_params: str) -> URLPath:
+        if self.name is not None and name == self.name and "path" in path_params:
+            # 'name' matches "<mount_name>".
+            path = path_params.pop("path")
+            host, remaining_params = replace_params(
+                self.host_format, self.param_convertors, path_params
+            )
+            if not remaining_params:
+                return URLPath(path=path, host=host)
+        elif self.name is None or name.startswith(self.name + ":"):
+            if self.name is None:
+                # No mount name.
+                remaining_name = name
+            else:
+                # 'name' matches "<mount_name>:<child_name>".
+                remaining_name = name[len(self.name) + 1 :]
+            host, remaining_params = replace_params(
+                self.host_format, self.param_convertors, path_params
+            )
+            for route in self.routes or []:
+                try:
+                    url = route.url_path_for(remaining_name, **remaining_params)
+                    return URLPath(path=str(url), protocol=url.protocol, host=host)
+                except NoMatchFound:
+                    pass
+        raise NoMatchFound()
+
+    async def handle(self, scope: Scope, receive: Receive, send: Send) -> None:
+        await self.app(scope, receive, send)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, Host)
+            and self.host == other.host
+            and self.app == other.app
+        )
+
+
+_T = typing.TypeVar("_T")
+
+
+class _AsyncLiftContextManager(typing.AsyncContextManager[_T]):
+    def __init__(self, cm: typing.ContextManager[_T]):
+        self._cm = cm
+
+    async def __aenter__(self) -> _T:
+        return self._cm.__enter__()
+
+    async def __aexit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]],
+        exc_value: typing.Optional[BaseException],
+        traceback: typing.Optional[types.TracebackType],
+    ) -> typing.Optional[bool]:
+        return self._cm.__exit__(exc_type, exc_value, traceback)
+
+
+def _wrap_gen_lifespan_context(
+    lifespan_context: typing.Callable[[typing.Any], typing.Generator]
+) -> typing.Callable[[typing.Any], typing.AsyncContextManager]:
+    cmgr = contextlib.contextmanager(lifespan_context)
+
+    @functools.wraps(cmgr)
+    def wrapper(app: typing.Any) -> _AsyncLiftContextManager:
+        return _AsyncLiftContextManager(cmgr(app))
+
+    return wrapper
+
+
+class _DefaultLifespan:
+    def __init__(self, router: "Router"):
+        self._router = router
+
+    async def __aenter__(self) -> None:
+        await self._router.startup()
+
+    async def __aexit__(self, *exc_info: object) -> None:
+        await self._router.shutdown()
+
+    def __call__(self: _T, app: object) -> _T:
+        return self
+
+
+class Router:
+    def __init__(
+        self,
+        routes: typing.Sequence[BaseRoute] = None,
+        redirect_slashes: bool = True,
+        default: ASGIApp = None,
+        on_startup: typing.Sequence[typing.Callable] = None,
+        on_shutdown: typing.Sequence[typing.Callable] = None,
+        lifespan: typing.Callable[[typing.Any], typing.AsyncContextManager] = None,
+    ) -> None:
+        self.routes = [] if routes is None else list(routes)
+        self.redirect_slashes = redirect_slashes
+        self.default = self.not_found if default is None else default
+        self.on_startup = [] if on_startup is None else list(on_startup)
+        self.on_shutdown = [] if on_shutdown is None else list(on_shutdown)
+
+        if lifespan is None:
+            self.lifespan_context: typing.Callable[
+                [typing.Any], typing.AsyncContextManager
+            ] = _DefaultLifespan(self)
+
+        elif inspect.isasyncgenfunction(lifespan):
+            warnings.warn(
+                "async generator function lifespans are deprecated, "
+                "use an @contextlib.asynccontextmanager function instead",
+                DeprecationWarning,
+            )
+            self.lifespan_context = asynccontextmanager(
+                lifespan,  # type: ignore[arg-type]
+            )
+        elif inspect.isgeneratorfunction(lifespan):
+            warnings.warn(
+                "generator function lifespans are deprecated, "
+                "use an @contextlib.asynccontextmanager function instead",
+                DeprecationWarning,
+            )
+            self.lifespan_context = _wrap_gen_lifespan_context(
+                lifespan,  # type: ignore[arg-type]
+            )
+        else:
+            self.lifespan_context = lifespan
+
+    async def not_found(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] == "websocket":
+            websocket_close = WebSocketClose()
+            await websocket_close(scope, receive, send)
+            return
+
+        # If we're running inside a starlette application then raise an
+        # exception, so that the configurable exception handler can deal with
+        # returning the response. For plain ASGI apps, just return the response.
+        if "app" in scope:
+            raise HTTPException(status_code=404)
+        else:
+            response = PlainTextResponse("Not Found", status_code=404)
+        await response(scope, receive, send)
+
+    def url_path_for(self, name: str, **path_params: str) -> URLPath:
+        for route in self.routes:
+            try:
+                return route.url_path_for(name, **path_params)
+            except NoMatchFound:
+                pass
+        raise NoMatchFound()
+
+    async def startup(self) -> None:
+        """
+        Run any `.on_startup` event handlers.
+        """
+        for handler in self.on_startup:
+            if asyncio.iscoroutinefunction(handler):
+                await handler()
+            else:
+                handler()
+
+    async def shutdown(self) -> None:
+        """
+        Run any `.on_shutdown` event handlers.
+        """
+        for handler in self.on_shutdown:
+            if asyncio.iscoroutinefunction(handler):
+                await handler()
+            else:
+                handler()
+
+    async def lifespan(self, scope: Scope, receive: Receive, send: Send) -> None:
+        """
+        Handle ASGI lifespan messages, which allows us to manage application
+        startup and shutdown events.
+        """
+        started = False
+        app = scope.get("app")
+        await receive()
+        try:
+            async with self.lifespan_context(app):
+                await send({"type": "lifespan.startup.complete"})
+                started = True
+                await receive()
+        except BaseException:
+            exc_text = traceback.format_exc()
+            if started:
+                await send({"type": "lifespan.shutdown.failed", "message": exc_text})
+            else:
+                await send({"type": "lifespan.startup.failed", "message": exc_text})
+            raise
+        else:
+            await send({"type": "lifespan.shutdown.complete"})
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        """
+        The main entry point to the Router class.
+        """
+        assert scope["type"] in ("http", "websocket", "lifespan")
+
+        if "router" not in scope:
+            scope["router"] = self
+
+        if scope["type"] == "lifespan":
+            await self.lifespan(scope, receive, send)
+            return
+
+        partial = None
+
+        for route in self.routes:
+            # Determine if any route matches the incoming scope,
+            # and hand over to the matching route if found.
+            match, child_scope = route.matches(scope)
+            if match == Match.FULL:
+                scope.update(child_scope)
+                await route.handle(scope, receive, send)
+                return
+            elif match == Match.PARTIAL and partial is None:
+                partial = route
+                partial_scope = child_scope
+
+        if partial is not None:
+            #  Handle partial matches. These are cases where an endpoint is
+            # able to handle the request, but is not a preferred option.
+            # We use this in particular to deal with "405 Method Not Allowed".
+            scope.update(partial_scope)
+            await partial.handle(scope, receive, send)
+            return
+
+        if scope["type"] == "http" and self.redirect_slashes and scope["path"] != "/":
+            redirect_scope = dict(scope)
+            if scope["path"].endswith("/"):
+                redirect_scope["path"] = redirect_scope["path"].rstrip("/")
+            else:
+                redirect_scope["path"] = redirect_scope["path"] + "/"
+
+            for route in self.routes:
+                match, child_scope = route.matches(redirect_scope)
+                if match != Match.NONE:
+                    redirect_url = URL(scope=redirect_scope)
+                    response = RedirectResponse(url=str(redirect_url))
+                    await response(scope, receive, send)
+                    return
+
+        await self.default(scope, receive, send)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, Router) and self.routes == other.routes
+
+    # The following usages are now discouraged in favour of configuration
+    #  during Router.__init__(...)
+    def mount(self, path: str, app: ASGIApp, name: str = None) -> None:
+        route = Mount(path, app=app, name=name)
+        self.routes.append(route)
+
+    def host(self, host: str, app: ASGIApp, name: str = None) -> None:
+        route = Host(host, app=app, name=name)
+        self.routes.append(route)
+
+    def add_route(
+        self,
+        path: str,
+        endpoint: typing.Callable,
+        methods: typing.List[str] = None,
+        name: str = None,
+        include_in_schema: bool = True,
+    ) -> None:
+        route = Route(
+            path,
+            endpoint=endpoint,
+            methods=methods,
+            name=name,
+            include_in_schema=include_in_schema,
+        )
+        self.routes.append(route)
+
+    def add_websocket_route(
+        self, path: str, endpoint: typing.Callable, name: str = None
+    ) -> None:
+        route = WebSocketRoute(path, endpoint=endpoint, name=name)
+        self.routes.append(route)
+
+    def route(
+        self,
+        path: str,
+        methods: typing.List[str] = None,
+        name: str = None,
+        include_in_schema: bool = True,
+    ) -> typing.Callable:
+        def decorator(func: typing.Callable) -> typing.Callable:
+            self.add_route(
+                path,
+                func,
+                methods=methods,
+                name=name,
+                include_in_schema=include_in_schema,
+            )
+            return func
+
+        return decorator
+
+    def websocket_route(self, path: str, name: str = None) -> typing.Callable:
+        def decorator(func: typing.Callable) -> typing.Callable:
+            self.add_websocket_route(path, func, name=name)
+            return func
+
+        return decorator
+
+    def add_event_handler(self, event_type: str, func: typing.Callable) -> None:
+        assert event_type in ("startup", "shutdown")
+
+        if event_type == "startup":
+            self.on_startup.append(func)
+        else:
+            self.on_shutdown.append(func)
+
+    def on_event(self, event_type: str) -> typing.Callable:
+        def decorator(func: typing.Callable) -> typing.Callable:
+            self.add_event_handler(event_type, func)
+            return func
+
+        return decorator
diff --git a/myenv/lib/python3.9/site-packages/starlette/schemas.py b/myenv/lib/python3.9/site-packages/starlette/schemas.py
new file mode 100644
index 0000000..6ca764f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/schemas.py
@@ -0,0 +1,135 @@
+import inspect
+import typing
+
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.routing import BaseRoute, Mount, Route
+
+try:
+    import yaml
+except ImportError:  # pragma: nocover
+    yaml = None  # type: ignore
+
+
+class OpenAPIResponse(Response):
+    media_type = "application/vnd.oai.openapi"
+
+    def render(self, content: typing.Any) -> bytes:
+        assert yaml is not None, "`pyyaml` must be installed to use OpenAPIResponse."
+        assert isinstance(
+            content, dict
+        ), "The schema passed to OpenAPIResponse should be a dictionary."
+        return yaml.dump(content, default_flow_style=False).encode("utf-8")
+
+
+class EndpointInfo(typing.NamedTuple):
+    path: str
+    http_method: str
+    func: typing.Callable
+
+
+class BaseSchemaGenerator:
+    def get_schema(self, routes: typing.List[BaseRoute]) -> dict:
+        raise NotImplementedError()  # pragma: no cover
+
+    def get_endpoints(
+        self, routes: typing.List[BaseRoute]
+    ) -> typing.List[EndpointInfo]:
+        """
+        Given the routes, yields the following information:
+
+        - path
+            eg: /users/
+        - http_method
+            one of 'get', 'post', 'put', 'patch', 'delete', 'options'
+        - func
+            method ready to extract the docstring
+        """
+        endpoints_info: list = []
+
+        for route in routes:
+            if isinstance(route, Mount):
+                routes = route.routes or []
+                sub_endpoints = [
+                    EndpointInfo(
+                        path="".join((route.path, sub_endpoint.path)),
+                        http_method=sub_endpoint.http_method,
+                        func=sub_endpoint.func,
+                    )
+                    for sub_endpoint in self.get_endpoints(routes)
+                ]
+                endpoints_info.extend(sub_endpoints)
+
+            elif not isinstance(route, Route) or not route.include_in_schema:
+                continue
+
+            elif inspect.isfunction(route.endpoint) or inspect.ismethod(route.endpoint):
+                for method in route.methods or ["GET"]:
+                    if method == "HEAD":
+                        continue
+                    endpoints_info.append(
+                        EndpointInfo(route.path, method.lower(), route.endpoint)
+                    )
+            else:
+                for method in ["get", "post", "put", "patch", "delete", "options"]:
+                    if not hasattr(route.endpoint, method):
+                        continue
+                    func = getattr(route.endpoint, method)
+                    endpoints_info.append(
+                        EndpointInfo(route.path, method.lower(), func)
+                    )
+
+        return endpoints_info
+
+    def parse_docstring(self, func_or_method: typing.Callable) -> dict:
+        """
+        Given a function, parse the docstring as YAML and return a dictionary of info.
+        """
+        docstring = func_or_method.__doc__
+        if not docstring:
+            return {}
+
+        assert yaml is not None, "`pyyaml` must be installed to use parse_docstring."
+
+        # We support having regular docstrings before the schema
+        # definition. Here we return just the schema part from
+        # the docstring.
+        docstring = docstring.split("---")[-1]
+
+        parsed = yaml.safe_load(docstring)
+
+        if not isinstance(parsed, dict):
+            # A regular docstring (not yaml formatted) can return
+            # a simple string here, which wouldn't follow the schema.
+            return {}
+
+        return parsed
+
+    def OpenAPIResponse(self, request: Request) -> Response:
+        routes = request.app.routes
+        schema = self.get_schema(routes=routes)
+        return OpenAPIResponse(schema)
+
+
+class SchemaGenerator(BaseSchemaGenerator):
+    def __init__(self, base_schema: dict) -> None:
+        self.base_schema = base_schema
+
+    def get_schema(self, routes: typing.List[BaseRoute]) -> dict:
+        schema = dict(self.base_schema)
+        schema.setdefault("paths", {})
+        endpoints_info = self.get_endpoints(routes)
+
+        for endpoint in endpoints_info:
+
+            parsed = self.parse_docstring(endpoint.func)
+
+            if not parsed:
+                continue
+
+            if endpoint.path not in schema["paths"]:
+                schema["paths"][endpoint.path] = {}
+
+            schema["paths"][endpoint.path][endpoint.http_method] = parsed
+
+        return schema
diff --git a/myenv/lib/python3.9/site-packages/starlette/staticfiles.py b/myenv/lib/python3.9/site-packages/starlette/staticfiles.py
new file mode 100644
index 0000000..33ea0b0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/staticfiles.py
@@ -0,0 +1,227 @@
+import importlib.util
+import os
+import stat
+import typing
+from email.utils import parsedate
+
+import anyio
+
+from starlette.datastructures import URL, Headers
+from starlette.responses import (
+    FileResponse,
+    PlainTextResponse,
+    RedirectResponse,
+    Response,
+)
+from starlette.types import Receive, Scope, Send
+
+PathLike = typing.Union[str, "os.PathLike[str]"]
+
+
+class NotModifiedResponse(Response):
+    NOT_MODIFIED_HEADERS = (
+        "cache-control",
+        "content-location",
+        "date",
+        "etag",
+        "expires",
+        "vary",
+    )
+
+    def __init__(self, headers: Headers):
+        super().__init__(
+            status_code=304,
+            headers={
+                name: value
+                for name, value in headers.items()
+                if name in self.NOT_MODIFIED_HEADERS
+            },
+        )
+
+
+class StaticFiles:
+    def __init__(
+        self,
+        *,
+        directory: PathLike = None,
+        packages: typing.List[str] = None,
+        html: bool = False,
+        check_dir: bool = True,
+    ) -> None:
+        self.directory = directory
+        self.packages = packages
+        self.all_directories = self.get_directories(directory, packages)
+        self.html = html
+        self.config_checked = False
+        if check_dir and directory is not None and not os.path.isdir(directory):
+            raise RuntimeError(f"Directory '{directory}' does not exist")
+
+    def get_directories(
+        self, directory: PathLike = None, packages: typing.List[str] = None
+    ) -> typing.List[PathLike]:
+        """
+        Given `directory` and `packages` arguments, return a list of all the
+        directories that should be used for serving static files from.
+        """
+        directories = []
+        if directory is not None:
+            directories.append(directory)
+
+        for package in packages or []:
+            spec = importlib.util.find_spec(package)
+            assert spec is not None, f"Package {package!r} could not be found."
+            assert (
+                spec.origin is not None
+            ), f"Directory 'statics' in package {package!r} could not be found."
+            package_directory = os.path.normpath(
+                os.path.join(spec.origin, "..", "statics")
+            )
+            assert os.path.isdir(
+                package_directory
+            ), f"Directory 'statics' in package {package!r} could not be found."
+            directories.append(package_directory)
+
+        return directories
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        """
+        The ASGI entry point.
+        """
+        assert scope["type"] == "http"
+
+        if not self.config_checked:
+            await self.check_config()
+            self.config_checked = True
+
+        path = self.get_path(scope)
+        response = await self.get_response(path, scope)
+        await response(scope, receive, send)
+
+    def get_path(self, scope: Scope) -> str:
+        """
+        Given the ASGI scope, return the `path` string to serve up,
+        with OS specific path seperators, and any '..', '.' components removed.
+        """
+        return os.path.normpath(os.path.join(*scope["path"].split("/")))
+
+    async def get_response(self, path: str, scope: Scope) -> Response:
+        """
+        Returns an HTTP response, given the incoming path, method and request headers.
+        """
+        if scope["method"] not in ("GET", "HEAD"):
+            return PlainTextResponse("Method Not Allowed", status_code=405)
+
+        full_path, stat_result = await self.lookup_path(path)
+
+        if stat_result and stat.S_ISREG(stat_result.st_mode):
+            # We have a static file to serve.
+            return self.file_response(full_path, stat_result, scope)
+
+        elif stat_result and stat.S_ISDIR(stat_result.st_mode) and self.html:
+            # We're in HTML mode, and have got a directory URL.
+            # Check if we have 'index.html' file to serve.
+            index_path = os.path.join(path, "index.html")
+            full_path, stat_result = await self.lookup_path(index_path)
+            if stat_result is not None and stat.S_ISREG(stat_result.st_mode):
+                if not scope["path"].endswith("/"):
+                    # Directory URLs should redirect to always end in "/".
+                    url = URL(scope=scope)
+                    url = url.replace(path=url.path + "/")
+                    return RedirectResponse(url=url)
+                return self.file_response(full_path, stat_result, scope)
+
+        if self.html:
+            # Check for '404.html' if we're in HTML mode.
+            full_path, stat_result = await self.lookup_path("404.html")
+            if stat_result is not None and stat.S_ISREG(stat_result.st_mode):
+                return FileResponse(
+                    full_path,
+                    stat_result=stat_result,
+                    method=scope["method"],
+                    status_code=404,
+                )
+
+        return PlainTextResponse("Not Found", status_code=404)
+
+    async def lookup_path(
+        self, path: str
+    ) -> typing.Tuple[str, typing.Optional[os.stat_result]]:
+        for directory in self.all_directories:
+            full_path = os.path.realpath(os.path.join(directory, path))
+            directory = os.path.realpath(directory)
+            if os.path.commonprefix([full_path, directory]) != directory:
+                # Don't allow misbehaving clients to break out of the static files
+                # directory.
+                continue
+            try:
+                stat_result = await anyio.to_thread.run_sync(os.stat, full_path)
+                return full_path, stat_result
+            except FileNotFoundError:
+                pass
+        return "", None
+
+    def file_response(
+        self,
+        full_path: PathLike,
+        stat_result: os.stat_result,
+        scope: Scope,
+        status_code: int = 200,
+    ) -> Response:
+        method = scope["method"]
+        request_headers = Headers(scope=scope)
+
+        response = FileResponse(
+            full_path, status_code=status_code, stat_result=stat_result, method=method
+        )
+        if self.is_not_modified(response.headers, request_headers):
+            return NotModifiedResponse(response.headers)
+        return response
+
+    async def check_config(self) -> None:
+        """
+        Perform a one-off configuration check that StaticFiles is actually
+        pointed at a directory, so that we can raise loud errors rather than
+        just returning 404 responses.
+        """
+        if self.directory is None:
+            return
+
+        try:
+            stat_result = await anyio.to_thread.run_sync(os.stat, self.directory)
+        except FileNotFoundError:
+            raise RuntimeError(
+                f"StaticFiles directory '{self.directory}' does not exist."
+            )
+        if not (stat.S_ISDIR(stat_result.st_mode) or stat.S_ISLNK(stat_result.st_mode)):
+            raise RuntimeError(
+                f"StaticFiles path '{self.directory}' is not a directory."
+            )
+
+    def is_not_modified(
+        self, response_headers: Headers, request_headers: Headers
+    ) -> bool:
+        """
+        Given the request and response headers, return `True` if an HTTP
+        "Not Modified" response could be returned instead.
+        """
+        try:
+            if_none_match = request_headers["if-none-match"]
+            etag = response_headers["etag"]
+            if if_none_match == etag:
+                return True
+        except KeyError:
+            pass
+
+        try:
+            if_modified_since = parsedate(request_headers["if-modified-since"])
+            last_modified = parsedate(response_headers["last-modified"])
+            if (
+                if_modified_since is not None
+                and last_modified is not None
+                and if_modified_since >= last_modified
+            ):
+                return True
+        except KeyError:
+            pass
+
+        return False
diff --git a/myenv/lib/python3.9/site-packages/starlette/status.py b/myenv/lib/python3.9/site-packages/starlette/status.py
new file mode 100644
index 0000000..b122ae8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/status.py
@@ -0,0 +1,92 @@
+"""
+HTTP codes
+See HTTP Status Code Registry:
+https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+
+And RFC 2324 - https://tools.ietf.org/html/rfc2324
+"""
+HTTP_100_CONTINUE = 100
+HTTP_101_SWITCHING_PROTOCOLS = 101
+HTTP_102_PROCESSING = 102
+HTTP_103_EARLY_HINTS = 103
+HTTP_200_OK = 200
+HTTP_201_CREATED = 201
+HTTP_202_ACCEPTED = 202
+HTTP_203_NON_AUTHORITATIVE_INFORMATION = 203
+HTTP_204_NO_CONTENT = 204
+HTTP_205_RESET_CONTENT = 205
+HTTP_206_PARTIAL_CONTENT = 206
+HTTP_207_MULTI_STATUS = 207
+HTTP_208_ALREADY_REPORTED = 208
+HTTP_226_IM_USED = 226
+HTTP_300_MULTIPLE_CHOICES = 300
+HTTP_301_MOVED_PERMANENTLY = 301
+HTTP_302_FOUND = 302
+HTTP_303_SEE_OTHER = 303
+HTTP_304_NOT_MODIFIED = 304
+HTTP_305_USE_PROXY = 305
+HTTP_306_RESERVED = 306
+HTTP_307_TEMPORARY_REDIRECT = 307
+HTTP_308_PERMANENT_REDIRECT = 308
+HTTP_400_BAD_REQUEST = 400
+HTTP_401_UNAUTHORIZED = 401
+HTTP_402_PAYMENT_REQUIRED = 402
+HTTP_403_FORBIDDEN = 403
+HTTP_404_NOT_FOUND = 404
+HTTP_405_METHOD_NOT_ALLOWED = 405
+HTTP_406_NOT_ACCEPTABLE = 406
+HTTP_407_PROXY_AUTHENTICATION_REQUIRED = 407
+HTTP_408_REQUEST_TIMEOUT = 408
+HTTP_409_CONFLICT = 409
+HTTP_410_GONE = 410
+HTTP_411_LENGTH_REQUIRED = 411
+HTTP_412_PRECONDITION_FAILED = 412
+HTTP_413_REQUEST_ENTITY_TOO_LARGE = 413
+HTTP_414_REQUEST_URI_TOO_LONG = 414
+HTTP_415_UNSUPPORTED_MEDIA_TYPE = 415
+HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE = 416
+HTTP_417_EXPECTATION_FAILED = 417
+HTTP_418_IM_A_TEAPOT = 418
+HTTP_421_MISDIRECTED_REQUEST = 421
+HTTP_422_UNPROCESSABLE_ENTITY = 422
+HTTP_423_LOCKED = 423
+HTTP_424_FAILED_DEPENDENCY = 424
+HTTP_425_TOO_EARLY = 425
+HTTP_426_UPGRADE_REQUIRED = 426
+HTTP_428_PRECONDITION_REQUIRED = 428
+HTTP_429_TOO_MANY_REQUESTS = 429
+HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE = 431
+HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS = 451
+HTTP_500_INTERNAL_SERVER_ERROR = 500
+HTTP_501_NOT_IMPLEMENTED = 501
+HTTP_502_BAD_GATEWAY = 502
+HTTP_503_SERVICE_UNAVAILABLE = 503
+HTTP_504_GATEWAY_TIMEOUT = 504
+HTTP_505_HTTP_VERSION_NOT_SUPPORTED = 505
+HTTP_506_VARIANT_ALSO_NEGOTIATES = 506
+HTTP_507_INSUFFICIENT_STORAGE = 507
+HTTP_508_LOOP_DETECTED = 508
+HTTP_510_NOT_EXTENDED = 510
+HTTP_511_NETWORK_AUTHENTICATION_REQUIRED = 511
+
+
+"""
+WebSocket codes
+https://www.iana.org/assignments/websocket/websocket.xml#close-code-number
+https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
+"""
+WS_1000_NORMAL_CLOSURE = 1000
+WS_1001_GOING_AWAY = 1001
+WS_1002_PROTOCOL_ERROR = 1002
+WS_1003_UNSUPPORTED_DATA = 1003
+WS_1004_NO_STATUS_RCVD = 1004
+WS_1005_ABNORMAL_CLOSURE = 1005
+WS_1007_INVALID_FRAME_PAYLOAD_DATA = 1007
+WS_1008_POLICY_VIOLATION = 1008
+WS_1009_MESSAGE_TOO_BIG = 1009
+WS_1010_MANDATORY_EXT = 1010
+WS_1011_INTERNAL_ERROR = 1011
+WS_1012_SERVICE_RESTART = 1012
+WS_1013_TRY_AGAIN_LATER = 1013
+WS_1014_BAD_GATEWAY = 1014
+WS_1015_TLS_HANDSHAKE = 1015
diff --git a/myenv/lib/python3.9/site-packages/starlette/templating.py b/myenv/lib/python3.9/site-packages/starlette/templating.py
new file mode 100644
index 0000000..36f613f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/templating.py
@@ -0,0 +1,94 @@
+import typing
+
+from starlette.background import BackgroundTask
+from starlette.responses import Response
+from starlette.types import Receive, Scope, Send
+
+try:
+    import jinja2
+
+    # @contextfunction renamed to @pass_context in Jinja 3.0, to be removed in 3.1
+    if hasattr(jinja2, "pass_context"):
+        pass_context = jinja2.pass_context
+    else:  # pragma: nocover
+        pass_context = jinja2.contextfunction
+except ImportError:  # pragma: nocover
+    jinja2 = None  # type: ignore
+
+
+class _TemplateResponse(Response):
+    media_type = "text/html"
+
+    def __init__(
+        self,
+        template: typing.Any,
+        context: dict,
+        status_code: int = 200,
+        headers: dict = None,
+        media_type: str = None,
+        background: BackgroundTask = None,
+    ):
+        self.template = template
+        self.context = context
+        content = template.render(context)
+        super().__init__(content, status_code, headers, media_type, background)
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        request = self.context.get("request", {})
+        extensions = request.get("extensions", {})
+        if "http.response.template" in extensions:
+            await send(
+                {
+                    "type": "http.response.template",
+                    "template": self.template,
+                    "context": self.context,
+                }
+            )
+        await super().__call__(scope, receive, send)
+
+
+class Jinja2Templates:
+    """
+    templates = Jinja2Templates("templates")
+
+    return templates.TemplateResponse("index.html", {"request": request})
+    """
+
+    def __init__(self, directory: str) -> None:
+        assert jinja2 is not None, "jinja2 must be installed to use Jinja2Templates"
+        self.env = self._create_env(directory)
+
+    def _create_env(self, directory: str) -> "jinja2.Environment":
+        @pass_context
+        def url_for(context: dict, name: str, **path_params: typing.Any) -> str:
+            request = context["request"]
+            return request.url_for(name, **path_params)
+
+        loader = jinja2.FileSystemLoader(directory)
+        env = jinja2.Environment(loader=loader, autoescape=True)
+        env.globals["url_for"] = url_for
+        return env
+
+    def get_template(self, name: str) -> "jinja2.Template":
+        return self.env.get_template(name)
+
+    def TemplateResponse(
+        self,
+        name: str,
+        context: dict,
+        status_code: int = 200,
+        headers: dict = None,
+        media_type: str = None,
+        background: BackgroundTask = None,
+    ) -> _TemplateResponse:
+        if "request" not in context:
+            raise ValueError('context must include a "request" key')
+        template = self.get_template(name)
+        return _TemplateResponse(
+            template,
+            context,
+            status_code=status_code,
+            headers=headers,
+            media_type=media_type,
+            background=background,
+        )
diff --git a/myenv/lib/python3.9/site-packages/starlette/testclient.py b/myenv/lib/python3.9/site-packages/starlette/testclient.py
new file mode 100644
index 0000000..08d03fa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/testclient.py
@@ -0,0 +1,576 @@
+import asyncio
+import contextlib
+import http
+import inspect
+import io
+import json
+import math
+import queue
+import sys
+import types
+import typing
+from concurrent.futures import Future
+from urllib.parse import unquote, urljoin, urlsplit
+
+import anyio.abc
+import requests
+from anyio.streams.stapled import StapledObjectStream
+
+from starlette.types import Message, Receive, Scope, Send
+from starlette.websockets import WebSocketDisconnect
+
+if sys.version_info >= (3, 8):  # pragma: no cover
+    from typing import TypedDict
+else:  # pragma: no cover
+    from typing_extensions import TypedDict
+
+
+_PortalFactoryType = typing.Callable[
+    [], typing.ContextManager[anyio.abc.BlockingPortal]
+]
+
+
+# Annotations for `Session.request()`
+Cookies = typing.Union[
+    typing.MutableMapping[str, str], requests.cookies.RequestsCookieJar
+]
+Params = typing.Union[bytes, typing.MutableMapping[str, str]]
+DataType = typing.Union[bytes, typing.MutableMapping[str, str], typing.IO]
+TimeOut = typing.Union[float, typing.Tuple[float, float]]
+FileType = typing.MutableMapping[str, typing.IO]
+AuthType = typing.Union[
+    typing.Tuple[str, str],
+    requests.auth.AuthBase,
+    typing.Callable[[requests.PreparedRequest], requests.PreparedRequest],
+]
+
+
+ASGIInstance = typing.Callable[[Receive, Send], typing.Awaitable[None]]
+ASGI2App = typing.Callable[[Scope], ASGIInstance]
+ASGI3App = typing.Callable[[Scope, Receive, Send], typing.Awaitable[None]]
+
+
+class _HeaderDict(requests.packages.urllib3._collections.HTTPHeaderDict):
+    def get_all(self, key: str, default: str) -> str:
+        return self.getheaders(key)
+
+
+class _MockOriginalResponse:
+    """
+    We have to jump through some hoops to present the response as if
+    it was made using urllib3.
+    """
+
+    def __init__(self, headers: typing.List[typing.Tuple[bytes, bytes]]) -> None:
+        self.msg = _HeaderDict(headers)
+        self.closed = False
+
+    def isclosed(self) -> bool:
+        return self.closed
+
+
+class _Upgrade(Exception):
+    def __init__(self, session: "WebSocketTestSession") -> None:
+        self.session = session
+
+
+def _get_reason_phrase(status_code: int) -> str:
+    try:
+        return http.HTTPStatus(status_code).phrase
+    except ValueError:
+        return ""
+
+
+def _is_asgi3(app: typing.Union[ASGI2App, ASGI3App]) -> bool:
+    if inspect.isclass(app):
+        return hasattr(app, "__await__")
+    elif inspect.isfunction(app):
+        return asyncio.iscoroutinefunction(app)
+    call = getattr(app, "__call__", None)
+    return asyncio.iscoroutinefunction(call)
+
+
+class _WrapASGI2:
+    """
+    Provide an ASGI3 interface onto an ASGI2 app.
+    """
+
+    def __init__(self, app: ASGI2App) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        instance = self.app(scope)
+        await instance(receive, send)
+
+
+class _AsyncBackend(TypedDict):
+    backend: str
+    backend_options: typing.Dict[str, typing.Any]
+
+
+class _ASGIAdapter(requests.adapters.HTTPAdapter):
+    def __init__(
+        self,
+        app: ASGI3App,
+        portal_factory: _PortalFactoryType,
+        raise_server_exceptions: bool = True,
+        root_path: str = "",
+    ) -> None:
+        self.app = app
+        self.raise_server_exceptions = raise_server_exceptions
+        self.root_path = root_path
+        self.portal_factory = portal_factory
+
+    def send(
+        self, request: requests.PreparedRequest, *args: typing.Any, **kwargs: typing.Any
+    ) -> requests.Response:
+        scheme, netloc, path, query, fragment = (
+            str(item) for item in urlsplit(request.url)
+        )
+
+        default_port = {"http": 80, "ws": 80, "https": 443, "wss": 443}[scheme]
+
+        if ":" in netloc:
+            host, port_string = netloc.split(":", 1)
+            port = int(port_string)
+        else:
+            host = netloc
+            port = default_port
+
+        # Include the 'host' header.
+        if "host" in request.headers:
+            headers: typing.List[typing.Tuple[bytes, bytes]] = []
+        elif port == default_port:
+            headers = [(b"host", host.encode())]
+        else:
+            headers = [(b"host", (f"{host}:{port}").encode())]
+
+        # Include other request headers.
+        headers += [
+            (key.lower().encode(), value.encode())
+            for key, value in request.headers.items()
+        ]
+
+        if scheme in {"ws", "wss"}:
+            subprotocol = request.headers.get("sec-websocket-protocol", None)
+            if subprotocol is None:
+                subprotocols: typing.Sequence[str] = []
+            else:
+                subprotocols = [value.strip() for value in subprotocol.split(",")]
+            scope = {
+                "type": "websocket",
+                "path": unquote(path),
+                "root_path": self.root_path,
+                "scheme": scheme,
+                "query_string": query.encode(),
+                "headers": headers,
+                "client": ["testclient", 50000],
+                "server": [host, port],
+                "subprotocols": subprotocols,
+            }
+            session = WebSocketTestSession(self.app, scope, self.portal_factory)
+            raise _Upgrade(session)
+
+        scope = {
+            "type": "http",
+            "http_version": "1.1",
+            "method": request.method,
+            "path": unquote(path),
+            "root_path": self.root_path,
+            "scheme": scheme,
+            "query_string": query.encode(),
+            "headers": headers,
+            "client": ["testclient", 50000],
+            "server": [host, port],
+            "extensions": {"http.response.template": {}},
+        }
+
+        request_complete = False
+        response_started = False
+        response_complete: anyio.Event
+        raw_kwargs: typing.Dict[str, typing.Any] = {"body": io.BytesIO()}
+        template = None
+        context = None
+
+        async def receive() -> Message:
+            nonlocal request_complete
+
+            if request_complete:
+                if not response_complete.is_set():
+                    await response_complete.wait()
+                return {"type": "http.disconnect"}
+
+            body = request.body
+            if isinstance(body, str):
+                body_bytes: bytes = body.encode("utf-8")
+            elif body is None:
+                body_bytes = b""
+            elif isinstance(body, types.GeneratorType):
+                try:
+                    chunk = body.send(None)
+                    if isinstance(chunk, str):
+                        chunk = chunk.encode("utf-8")
+                    return {"type": "http.request", "body": chunk, "more_body": True}
+                except StopIteration:
+                    request_complete = True
+                    return {"type": "http.request", "body": b""}
+            else:
+                body_bytes = body
+
+            request_complete = True
+            return {"type": "http.request", "body": body_bytes}
+
+        async def send(message: Message) -> None:
+            nonlocal raw_kwargs, response_started, template, context
+
+            if message["type"] == "http.response.start":
+                assert (
+                    not response_started
+                ), 'Received multiple "http.response.start" messages.'
+                raw_kwargs["version"] = 11
+                raw_kwargs["status"] = message["status"]
+                raw_kwargs["reason"] = _get_reason_phrase(message["status"])
+                raw_kwargs["headers"] = [
+                    (key.decode(), value.decode())
+                    for key, value in message.get("headers", [])
+                ]
+                raw_kwargs["preload_content"] = False
+                raw_kwargs["original_response"] = _MockOriginalResponse(
+                    raw_kwargs["headers"]
+                )
+                response_started = True
+            elif message["type"] == "http.response.body":
+                assert (
+                    response_started
+                ), 'Received "http.response.body" without "http.response.start".'
+                assert (
+                    not response_complete.is_set()
+                ), 'Received "http.response.body" after response completed.'
+                body = message.get("body", b"")
+                more_body = message.get("more_body", False)
+                if request.method != "HEAD":
+                    raw_kwargs["body"].write(body)
+                if not more_body:
+                    raw_kwargs["body"].seek(0)
+                    response_complete.set()
+            elif message["type"] == "http.response.template":
+                template = message["template"]
+                context = message["context"]
+
+        try:
+            with self.portal_factory() as portal:
+                response_complete = portal.call(anyio.Event)
+                portal.call(self.app, scope, receive, send)
+        except BaseException as exc:
+            if self.raise_server_exceptions:
+                raise exc
+
+        if self.raise_server_exceptions:
+            assert response_started, "TestClient did not receive any response."
+        elif not response_started:
+            raw_kwargs = {
+                "version": 11,
+                "status": 500,
+                "reason": "Internal Server Error",
+                "headers": [],
+                "preload_content": False,
+                "original_response": _MockOriginalResponse([]),
+                "body": io.BytesIO(),
+            }
+
+        raw = requests.packages.urllib3.HTTPResponse(**raw_kwargs)
+        response = self.build_response(request, raw)
+        if template is not None:
+            response.template = template
+            response.context = context
+        return response
+
+
+class WebSocketTestSession:
+    def __init__(
+        self,
+        app: ASGI3App,
+        scope: Scope,
+        portal_factory: _PortalFactoryType,
+    ) -> None:
+        self.app = app
+        self.scope = scope
+        self.accepted_subprotocol = None
+        self.portal_factory = portal_factory
+        self._receive_queue: "queue.Queue[typing.Any]" = queue.Queue()
+        self._send_queue: "queue.Queue[typing.Any]" = queue.Queue()
+
+    def __enter__(self) -> "WebSocketTestSession":
+        self.exit_stack = contextlib.ExitStack()
+        self.portal = self.exit_stack.enter_context(self.portal_factory())
+
+        try:
+            _: "Future[None]" = self.portal.start_task_soon(self._run)
+            self.send({"type": "websocket.connect"})
+            message = self.receive()
+            self._raise_on_close(message)
+        except Exception:
+            self.exit_stack.close()
+            raise
+        self.accepted_subprotocol = message.get("subprotocol", None)
+        return self
+
+    def __exit__(self, *args: typing.Any) -> None:
+        try:
+            self.close(1000)
+        finally:
+            self.exit_stack.close()
+        while not self._send_queue.empty():
+            message = self._send_queue.get()
+            if isinstance(message, BaseException):
+                raise message
+
+    async def _run(self) -> None:
+        """
+        The sub-thread in which the websocket session runs.
+        """
+        scope = self.scope
+        receive = self._asgi_receive
+        send = self._asgi_send
+        try:
+            await self.app(scope, receive, send)
+        except BaseException as exc:
+            self._send_queue.put(exc)
+            raise
+
+    async def _asgi_receive(self) -> Message:
+        while self._receive_queue.empty():
+            await anyio.sleep(0)
+        return self._receive_queue.get()
+
+    async def _asgi_send(self, message: Message) -> None:
+        self._send_queue.put(message)
+
+    def _raise_on_close(self, message: Message) -> None:
+        if message["type"] == "websocket.close":
+            raise WebSocketDisconnect(message.get("code", 1000))
+
+    def send(self, message: Message) -> None:
+        self._receive_queue.put(message)
+
+    def send_text(self, data: str) -> None:
+        self.send({"type": "websocket.receive", "text": data})
+
+    def send_bytes(self, data: bytes) -> None:
+        self.send({"type": "websocket.receive", "bytes": data})
+
+    def send_json(self, data: typing.Any, mode: str = "text") -> None:
+        assert mode in ["text", "binary"]
+        text = json.dumps(data)
+        if mode == "text":
+            self.send({"type": "websocket.receive", "text": text})
+        else:
+            self.send({"type": "websocket.receive", "bytes": text.encode("utf-8")})
+
+    def close(self, code: int = 1000) -> None:
+        self.send({"type": "websocket.disconnect", "code": code})
+
+    def receive(self) -> Message:
+        message = self._send_queue.get()
+        if isinstance(message, BaseException):
+            raise message
+        return message
+
+    def receive_text(self) -> str:
+        message = self.receive()
+        self._raise_on_close(message)
+        return message["text"]
+
+    def receive_bytes(self) -> bytes:
+        message = self.receive()
+        self._raise_on_close(message)
+        return message["bytes"]
+
+    def receive_json(self, mode: str = "text") -> typing.Any:
+        assert mode in ["text", "binary"]
+        message = self.receive()
+        self._raise_on_close(message)
+        if mode == "text":
+            text = message["text"]
+        else:
+            text = message["bytes"].decode("utf-8")
+        return json.loads(text)
+
+
+class TestClient(requests.Session):
+    __test__ = False  # For pytest to not discover this up.
+    task: "Future[None]"
+    portal: typing.Optional[anyio.abc.BlockingPortal] = None
+
+    def __init__(
+        self,
+        app: typing.Union[ASGI2App, ASGI3App],
+        base_url: str = "http://testserver",
+        raise_server_exceptions: bool = True,
+        root_path: str = "",
+        backend: str = "asyncio",
+        backend_options: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    ) -> None:
+        super().__init__()
+        self.async_backend = _AsyncBackend(
+            backend=backend, backend_options=backend_options or {}
+        )
+        if _is_asgi3(app):
+            app = typing.cast(ASGI3App, app)
+            asgi_app = app
+        else:
+            app = typing.cast(ASGI2App, app)
+            asgi_app = _WrapASGI2(app)  #  type: ignore
+        adapter = _ASGIAdapter(
+            asgi_app,
+            portal_factory=self._portal_factory,
+            raise_server_exceptions=raise_server_exceptions,
+            root_path=root_path,
+        )
+        self.mount("http://", adapter)
+        self.mount("https://", adapter)
+        self.mount("ws://", adapter)
+        self.mount("wss://", adapter)
+        self.headers.update({"user-agent": "testclient"})
+        self.app = asgi_app
+        self.base_url = base_url
+
+    @contextlib.contextmanager
+    def _portal_factory(
+        self,
+    ) -> typing.Generator[anyio.abc.BlockingPortal, None, None]:
+        if self.portal is not None:
+            yield self.portal
+        else:
+            with anyio.start_blocking_portal(**self.async_backend) as portal:
+                yield portal
+
+    def request(  # type: ignore
+        self,
+        method: str,
+        url: str,
+        params: Params = None,
+        data: DataType = None,
+        headers: typing.MutableMapping[str, str] = None,
+        cookies: Cookies = None,
+        files: FileType = None,
+        auth: AuthType = None,
+        timeout: TimeOut = None,
+        allow_redirects: bool = None,
+        proxies: typing.MutableMapping[str, str] = None,
+        hooks: typing.Any = None,
+        stream: bool = None,
+        verify: typing.Union[bool, str] = None,
+        cert: typing.Union[str, typing.Tuple[str, str]] = None,
+        json: typing.Any = None,
+    ) -> requests.Response:
+        url = urljoin(self.base_url, url)
+        return super().request(
+            method,
+            url,
+            params=params,
+            data=data,
+            headers=headers,
+            cookies=cookies,
+            files=files,
+            auth=auth,
+            timeout=timeout,
+            allow_redirects=allow_redirects,
+            proxies=proxies,
+            hooks=hooks,
+            stream=stream,
+            verify=verify,
+            cert=cert,
+            json=json,
+        )
+
+    def websocket_connect(
+        self, url: str, subprotocols: typing.Sequence[str] = None, **kwargs: typing.Any
+    ) -> typing.Any:
+        url = urljoin("ws://testserver", url)
+        headers = kwargs.get("headers", {})
+        headers.setdefault("connection", "upgrade")
+        headers.setdefault("sec-websocket-key", "testserver==")
+        headers.setdefault("sec-websocket-version", "13")
+        if subprotocols is not None:
+            headers.setdefault("sec-websocket-protocol", ", ".join(subprotocols))
+        kwargs["headers"] = headers
+        try:
+            super().request("GET", url, **kwargs)
+        except _Upgrade as exc:
+            session = exc.session
+        else:
+            raise RuntimeError("Expected WebSocket upgrade")  # pragma: no cover
+
+        return session
+
+    def __enter__(self) -> "TestClient":
+        with contextlib.ExitStack() as stack:
+            self.portal = portal = stack.enter_context(
+                anyio.start_blocking_portal(**self.async_backend)
+            )
+
+            @stack.callback
+            def reset_portal() -> None:
+                self.portal = None
+
+            self.stream_send = StapledObjectStream(
+                *anyio.create_memory_object_stream(math.inf)
+            )
+            self.stream_receive = StapledObjectStream(
+                *anyio.create_memory_object_stream(math.inf)
+            )
+            self.task = portal.start_task_soon(self.lifespan)
+            portal.call(self.wait_startup)
+
+            @stack.callback
+            def wait_shutdown() -> None:
+                portal.call(self.wait_shutdown)
+
+            self.exit_stack = stack.pop_all()
+
+        return self
+
+    def __exit__(self, *args: typing.Any) -> None:
+        self.exit_stack.close()
+
+    async def lifespan(self) -> None:
+        scope = {"type": "lifespan"}
+        try:
+            await self.app(scope, self.stream_receive.receive, self.stream_send.send)
+        finally:
+            await self.stream_send.send(None)
+
+    async def wait_startup(self) -> None:
+        await self.stream_receive.send({"type": "lifespan.startup"})
+
+        async def receive() -> typing.Any:
+            message = await self.stream_send.receive()
+            if message is None:
+                self.task.result()
+            return message
+
+        message = await receive()
+        assert message["type"] in (
+            "lifespan.startup.complete",
+            "lifespan.startup.failed",
+        )
+        if message["type"] == "lifespan.startup.failed":
+            await receive()
+
+    async def wait_shutdown(self) -> None:
+        async def receive() -> typing.Any:
+            message = await self.stream_send.receive()
+            if message is None:
+                self.task.result()
+            return message
+
+        async with self.stream_send:
+            await self.stream_receive.send({"type": "lifespan.shutdown"})
+            message = await receive()
+            assert message["type"] in (
+                "lifespan.shutdown.complete",
+                "lifespan.shutdown.failed",
+            )
+            if message["type"] == "lifespan.shutdown.failed":
+                await receive()
diff --git a/myenv/lib/python3.9/site-packages/starlette/types.py b/myenv/lib/python3.9/site-packages/starlette/types.py
new file mode 100644
index 0000000..888645c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/types.py
@@ -0,0 +1,9 @@
+import typing
+
+Scope = typing.MutableMapping[str, typing.Any]
+Message = typing.MutableMapping[str, typing.Any]
+
+Receive = typing.Callable[[], typing.Awaitable[Message]]
+Send = typing.Callable[[Message], typing.Awaitable[None]]
+
+ASGIApp = typing.Callable[[Scope, Receive, Send], typing.Awaitable[None]]
diff --git a/myenv/lib/python3.9/site-packages/starlette/websockets.py b/myenv/lib/python3.9/site-packages/starlette/websockets.py
new file mode 100644
index 0000000..b9b8844
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/starlette/websockets.py
@@ -0,0 +1,150 @@
+import enum
+import json
+import typing
+
+from starlette.requests import HTTPConnection
+from starlette.types import Message, Receive, Scope, Send
+
+
+class WebSocketState(enum.Enum):
+    CONNECTING = 0
+    CONNECTED = 1
+    DISCONNECTED = 2
+
+
+class WebSocketDisconnect(Exception):
+    def __init__(self, code: int = 1000) -> None:
+        self.code = code
+
+
+class WebSocket(HTTPConnection):
+    def __init__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        super().__init__(scope)
+        assert scope["type"] == "websocket"
+        self._receive = receive
+        self._send = send
+        self.client_state = WebSocketState.CONNECTING
+        self.application_state = WebSocketState.CONNECTING
+
+    async def receive(self) -> Message:
+        """
+        Receive ASGI websocket messages, ensuring valid state transitions.
+        """
+        if self.client_state == WebSocketState.CONNECTING:
+            message = await self._receive()
+            message_type = message["type"]
+            assert message_type == "websocket.connect"
+            self.client_state = WebSocketState.CONNECTED
+            return message
+        elif self.client_state == WebSocketState.CONNECTED:
+            message = await self._receive()
+            message_type = message["type"]
+            assert message_type in {"websocket.receive", "websocket.disconnect"}
+            if message_type == "websocket.disconnect":
+                self.client_state = WebSocketState.DISCONNECTED
+            return message
+        else:
+            raise RuntimeError(
+                'Cannot call "receive" once a disconnect message has been received.'
+            )
+
+    async def send(self, message: Message) -> None:
+        """
+        Send ASGI websocket messages, ensuring valid state transitions.
+        """
+        if self.application_state == WebSocketState.CONNECTING:
+            message_type = message["type"]
+            assert message_type in {"websocket.accept", "websocket.close"}
+            if message_type == "websocket.close":
+                self.application_state = WebSocketState.DISCONNECTED
+            else:
+                self.application_state = WebSocketState.CONNECTED
+            await self._send(message)
+        elif self.application_state == WebSocketState.CONNECTED:
+            message_type = message["type"]
+            assert message_type in {"websocket.send", "websocket.close"}
+            if message_type == "websocket.close":
+                self.application_state = WebSocketState.DISCONNECTED
+            await self._send(message)
+        else:
+            raise RuntimeError('Cannot call "send" once a close message has been sent.')
+
+    async def accept(self, subprotocol: str = None) -> None:
+        if self.client_state == WebSocketState.CONNECTING:
+            # If we haven't yet seen the 'connect' message, then wait for it first.
+            await self.receive()
+        await self.send({"type": "websocket.accept", "subprotocol": subprotocol})
+
+    def _raise_on_disconnect(self, message: Message) -> None:
+        if message["type"] == "websocket.disconnect":
+            raise WebSocketDisconnect(message["code"])
+
+    async def receive_text(self) -> str:
+        assert self.application_state == WebSocketState.CONNECTED
+        message = await self.receive()
+        self._raise_on_disconnect(message)
+        return message["text"]
+
+    async def receive_bytes(self) -> bytes:
+        assert self.application_state == WebSocketState.CONNECTED
+        message = await self.receive()
+        self._raise_on_disconnect(message)
+        return message["bytes"]
+
+    async def receive_json(self, mode: str = "text") -> typing.Any:
+        assert mode in ["text", "binary"]
+        assert self.application_state == WebSocketState.CONNECTED
+        message = await self.receive()
+        self._raise_on_disconnect(message)
+
+        if mode == "text":
+            text = message["text"]
+        else:
+            text = message["bytes"].decode("utf-8")
+        return json.loads(text)
+
+    async def iter_text(self) -> typing.AsyncIterator[str]:
+        try:
+            while True:
+                yield await self.receive_text()
+        except WebSocketDisconnect:
+            pass
+
+    async def iter_bytes(self) -> typing.AsyncIterator[bytes]:
+        try:
+            while True:
+                yield await self.receive_bytes()
+        except WebSocketDisconnect:
+            pass
+
+    async def iter_json(self) -> typing.AsyncIterator[typing.Any]:
+        try:
+            while True:
+                yield await self.receive_json()
+        except WebSocketDisconnect:
+            pass
+
+    async def send_text(self, data: str) -> None:
+        await self.send({"type": "websocket.send", "text": data})
+
+    async def send_bytes(self, data: bytes) -> None:
+        await self.send({"type": "websocket.send", "bytes": data})
+
+    async def send_json(self, data: typing.Any, mode: str = "text") -> None:
+        assert mode in ["text", "binary"]
+        text = json.dumps(data)
+        if mode == "text":
+            await self.send({"type": "websocket.send", "text": text})
+        else:
+            await self.send({"type": "websocket.send", "bytes": text.encode("utf-8")})
+
+    async def close(self, code: int = 1000) -> None:
+        await self.send({"type": "websocket.close", "code": code})
+
+
+class WebSocketClose:
+    def __init__(self, code: int = 1000) -> None:
+        self.code = code
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        await send({"type": "websocket.close", "code": self.code})
diff --git a/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/LICENSE
new file mode 100644
index 0000000..5010e30
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/LICENSE
@@ -0,0 +1,27 @@
+The MIT License
+
+Copyright 2013-2019 William Pearson
+Copyright 2015-2016 Julien Enselme
+Copyright 2016 Google Inc.
+Copyright 2017 Samuel Vasko
+Copyright 2017 Nate Prewitt
+Copyright 2017 Jack Evans
+Copyright 2019 Filippo Broggini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/METADATA b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/METADATA
new file mode 100644
index 0000000..6f2635c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/METADATA
@@ -0,0 +1,255 @@
+Metadata-Version: 2.1
+Name: toml
+Version: 0.10.2
+Summary: Python Library for Tom's Obvious, Minimal Language
+Home-page: https://github.com/uiri/toml
+Author: William Pearson
+Author-email: uiri@xqz.ca
+License: MIT
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=2.6, !=3.0.*, !=3.1.*, !=3.2.*
+
+****
+TOML
+****
+
+.. image:: https://img.shields.io/pypi/v/toml
+    :target: https://pypi.org/project/toml/
+
+.. image:: https://travis-ci.org/uiri/toml.svg?branch=master
+    :target: https://travis-ci.org/uiri/toml
+
+.. image:: https://img.shields.io/pypi/pyversions/toml.svg
+    :target: https://pypi.org/project/toml/
+
+
+A Python library for parsing and creating `TOML <https://en.wikipedia.org/wiki/TOML>`_.
+
+The module passes `the TOML test suite <https://github.com/BurntSushi/toml-test>`_.
+
+See also:
+
+* `The TOML Standard <https://github.com/toml-lang/toml>`_
+* `The currently supported TOML specification <https://github.com/toml-lang/toml/blob/v0.5.0/README.md>`_
+
+Installation
+============
+
+To install the latest release on `PyPI <https://pypi.org/project/toml/>`_,
+simply run:
+
+::
+
+  pip install toml
+
+Or to install the latest development version, run:
+
+::
+
+  git clone https://github.com/uiri/toml.git
+  cd toml
+  python setup.py install
+
+Quick Tutorial
+==============
+
+*toml.loads* takes in a string containing standard TOML-formatted data and
+returns a dictionary containing the parsed data.
+
+.. code:: pycon
+
+  >>> import toml
+  >>> toml_string = """
+  ... # This is a TOML document.
+  ...
+  ... title = "TOML Example"
+  ...
+  ... [owner]
+  ... name = "Tom Preston-Werner"
+  ... dob = 1979-05-27T07:32:00-08:00 # First class dates
+  ...
+  ... [database]
+  ... server = "192.168.1.1"
+  ... ports = [ 8001, 8001, 8002 ]
+  ... connection_max = 5000
+  ... enabled = true
+  ...
+  ... [servers]
+  ...
+  ...   # Indentation (tabs and/or spaces) is allowed but not required
+  ...   [servers.alpha]
+  ...   ip = "10.0.0.1"
+  ...   dc = "eqdc10"
+  ...
+  ...   [servers.beta]
+  ...   ip = "10.0.0.2"
+  ...   dc = "eqdc10"
+  ...
+  ... [clients]
+  ... data = [ ["gamma", "delta"], [1, 2] ]
+  ...
+  ... # Line breaks are OK when inside arrays
+  ... hosts = [
+  ...   "alpha",
+  ...   "omega"
+  ... ]
+  ... """
+  >>> parsed_toml = toml.loads(toml_string)
+
+
+*toml.dumps* takes a dictionary and returns a string containing the
+corresponding TOML-formatted data.
+
+.. code:: pycon
+
+  >>> new_toml_string = toml.dumps(parsed_toml)
+  >>> print(new_toml_string)
+  title = "TOML Example"
+  [owner]
+  name = "Tom Preston-Werner"
+  dob = 1979-05-27T07:32:00Z
+  [database]
+  server = "192.168.1.1"
+  ports = [ 8001, 8001, 8002,]
+  connection_max = 5000
+  enabled = true
+  [clients]
+  data = [ [ "gamma", "delta",], [ 1, 2,],]
+  hosts = [ "alpha", "omega",]
+  [servers.alpha]
+  ip = "10.0.0.1"
+  dc = "eqdc10"
+  [servers.beta]
+  ip = "10.0.0.2"
+  dc = "eqdc10"
+
+*toml.dump* takes a dictionary and a file descriptor and returns a string containing the
+corresponding TOML-formatted data.
+
+.. code:: pycon
+
+  >>> with open('new_toml_file.toml', 'w') as f:
+  ...     new_toml_string = toml.dump(parsed_toml, f)
+  >>> print(new_toml_string)
+  title = "TOML Example"
+  [owner]
+  name = "Tom Preston-Werner"
+  dob = 1979-05-27T07:32:00Z
+  [database]
+  server = "192.168.1.1"
+  ports = [ 8001, 8001, 8002,]
+  connection_max = 5000
+  enabled = true
+  [clients]
+  data = [ [ "gamma", "delta",], [ 1, 2,],]
+  hosts = [ "alpha", "omega",]
+  [servers.alpha]
+  ip = "10.0.0.1"
+  dc = "eqdc10"
+  [servers.beta]
+  ip = "10.0.0.2"
+  dc = "eqdc10"
+
+For more functions, view the API Reference below.
+
+Note
+----
+
+For Numpy users, by default the data types ``np.floatX`` will not be translated to floats by toml, but will instead be encoded as strings. To get around this, specify the ``TomlNumpyEncoder`` when saving your data.
+
+.. code:: pycon
+
+  >>> import toml
+  >>> import numpy as np
+  >>> a = np.arange(0, 10, dtype=np.double)
+  >>> output = {'a': a}
+  >>> toml.dumps(output)
+  'a = [ "0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "9.0",]\n'
+  >>> toml.dumps(output, encoder=toml.TomlNumpyEncoder())
+  'a = [ 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0,]\n'
+
+API Reference
+=============
+
+``toml.load(f, _dict=dict)``
+  Parse a file or a list of files as TOML and return a dictionary.
+
+  :Args:
+    * ``f``: A path to a file, list of filepaths (to be read into single
+      object) or a file descriptor
+    * ``_dict``: The class of the dictionary object to be returned
+
+  :Returns:
+    A dictionary (or object ``_dict``) containing parsed TOML data
+
+  :Raises:
+    * ``TypeError``: When ``f`` is an invalid type or is a list containing
+      invalid types
+    * ``TomlDecodeError``: When an error occurs while decoding the file(s)
+
+``toml.loads(s, _dict=dict)``
+  Parse a TOML-formatted string to a dictionary.
+
+  :Args:
+    * ``s``: The TOML-formatted string to be parsed
+    * ``_dict``: Specifies the class of the returned toml dictionary
+
+  :Returns:
+    A dictionary (or object ``_dict``) containing parsed TOML data
+
+  :Raises:
+    * ``TypeError``: When a non-string object is passed
+    * ``TomlDecodeError``: When an error occurs while decoding the
+      TOML-formatted string
+
+``toml.dump(o, f, encoder=None)``
+  Write a dictionary to a file containing TOML-formatted data
+
+  :Args:
+    * ``o``: An object to be converted into TOML
+    * ``f``: A File descriptor where the TOML-formatted output should be stored
+    * ``encoder``: An instance of ``TomlEncoder`` (or subclass) for encoding the object. If ``None``, will default to ``TomlEncoder``
+
+  :Returns:
+    A string containing the TOML-formatted data corresponding to object ``o``
+
+  :Raises:
+    * ``TypeError``: When anything other than file descriptor is passed
+
+``toml.dumps(o, encoder=None)``
+  Create a TOML-formatted string from an input object
+
+  :Args:
+    * ``o``: An object to be converted into TOML
+    * ``encoder``: An instance of ``TomlEncoder`` (or subclass) for encoding the object. If ``None``, will default to ``TomlEncoder``
+
+  :Returns:
+    A string containing the TOML-formatted data corresponding to object ``o``
+
+
+
+Licensing
+=========
+
+This project is released under the terms of the MIT Open Source License. View
+*LICENSE.txt* for more information.
+
+
diff --git a/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/RECORD b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/RECORD
new file mode 100644
index 0000000..b5fdcf7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/RECORD
@@ -0,0 +1,11 @@
+toml/__init__.py,sha256=Au3kqCwKD0cjbf4yJGOpUFwpsY0WHsC1ZRGvWgIKmpc,723
+toml/decoder.py,sha256=hSGTLf-2WBDZ_ddoCHWFy6N647XyMSh1o3rN2o4dEFg,38942
+toml/encoder.py,sha256=XjBc8ayvvlsLyd_qDA4tMWDNmMFRS4DpwtuDSWBq7zo,9940
+toml/ordered.py,sha256=mz03lZmV0bmc9lsYRIUOuj7Dsu5Ptwq-UtGVq5FdVZ4,354
+toml/tz.py,sha256=-5vg8wkg_atnVi2TnEveexIVE7T_FxBVr_-2WVfO1oA,701
+toml-0.10.2.dist-info/LICENSE,sha256=LZKUgj32yJNXyL5JJ_znk2HWVh5e51MtWSbmOTmqpTY,1252
+toml-0.10.2.dist-info/METADATA,sha256=n_YkspvEihd_QXLIZZ50WVSFz3rZ_k7jQP-OU1WUpWY,7142
+toml-0.10.2.dist-info/WHEEL,sha256=ADKeyaGyKF5DwBNE0sRE5pvW-bSkFMJfBuhzZ3rceP4,110
+toml-0.10.2.dist-info/top_level.txt,sha256=2BO8ZRNnvJWgXyiQv66LBb_v87qBzcoUtEBefA75Ouk,5
+toml-0.10.2.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+toml-0.10.2.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/WHEEL
new file mode 100644
index 0000000..6d38aa0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.35.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/top_level.txt
new file mode 100644
index 0000000..bd79a65
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/toml-0.10.2.dist-info/top_level.txt
@@ -0,0 +1 @@
+toml
diff --git a/myenv/lib/python3.9/site-packages/toml/__init__.py b/myenv/lib/python3.9/site-packages/toml/__init__.py
new file mode 100644
index 0000000..7719ac2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/toml/__init__.py
@@ -0,0 +1,25 @@
+"""Python module which parses and emits TOML.
+
+Released under the MIT license.
+"""
+
+from toml import encoder
+from toml import decoder
+
+__version__ = "0.10.2"
+_spec_ = "0.5.0"
+
+load = decoder.load
+loads = decoder.loads
+TomlDecoder = decoder.TomlDecoder
+TomlDecodeError = decoder.TomlDecodeError
+TomlPreserveCommentDecoder = decoder.TomlPreserveCommentDecoder
+
+dump = encoder.dump
+dumps = encoder.dumps
+TomlEncoder = encoder.TomlEncoder
+TomlArraySeparatorEncoder = encoder.TomlArraySeparatorEncoder
+TomlPreserveInlineDictEncoder = encoder.TomlPreserveInlineDictEncoder
+TomlNumpyEncoder = encoder.TomlNumpyEncoder
+TomlPreserveCommentEncoder = encoder.TomlPreserveCommentEncoder
+TomlPathlibEncoder = encoder.TomlPathlibEncoder
diff --git a/myenv/lib/python3.9/site-packages/toml/decoder.py b/myenv/lib/python3.9/site-packages/toml/decoder.py
new file mode 100644
index 0000000..bf400e9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/toml/decoder.py
@@ -0,0 +1,1057 @@
+import datetime
+import io
+from os import linesep
+import re
+import sys
+
+from toml.tz import TomlTz
+
+if sys.version_info < (3,):
+    _range = xrange  # noqa: F821
+else:
+    unicode = str
+    _range = range
+    basestring = str
+    unichr = chr
+
+
+def _detect_pathlib_path(p):
+    if (3, 4) <= sys.version_info:
+        import pathlib
+        if isinstance(p, pathlib.PurePath):
+            return True
+    return False
+
+
+def _ispath(p):
+    if isinstance(p, (bytes, basestring)):
+        return True
+    return _detect_pathlib_path(p)
+
+
+def _getpath(p):
+    if (3, 6) <= sys.version_info:
+        import os
+        return os.fspath(p)
+    if _detect_pathlib_path(p):
+        return str(p)
+    return p
+
+
+try:
+    FNFError = FileNotFoundError
+except NameError:
+    FNFError = IOError
+
+
+TIME_RE = re.compile(r"([0-9]{2}):([0-9]{2}):([0-9]{2})(\.([0-9]{3,6}))?")
+
+
+class TomlDecodeError(ValueError):
+    """Base toml Exception / Error."""
+
+    def __init__(self, msg, doc, pos):
+        lineno = doc.count('\n', 0, pos) + 1
+        colno = pos - doc.rfind('\n', 0, pos)
+        emsg = '{} (line {} column {} char {})'.format(msg, lineno, colno, pos)
+        ValueError.__init__(self, emsg)
+        self.msg = msg
+        self.doc = doc
+        self.pos = pos
+        self.lineno = lineno
+        self.colno = colno
+
+
+# Matches a TOML number, which allows underscores for readability
+_number_with_underscores = re.compile('([0-9])(_([0-9]))*')
+
+
+class CommentValue(object):
+    def __init__(self, val, comment, beginline, _dict):
+        self.val = val
+        separator = "\n" if beginline else " "
+        self.comment = separator + comment
+        self._dict = _dict
+
+    def __getitem__(self, key):
+        return self.val[key]
+
+    def __setitem__(self, key, value):
+        self.val[key] = value
+
+    def dump(self, dump_value_func):
+        retstr = dump_value_func(self.val)
+        if isinstance(self.val, self._dict):
+            return self.comment + "\n" + unicode(retstr)
+        else:
+            return unicode(retstr) + self.comment
+
+
+def _strictly_valid_num(n):
+    n = n.strip()
+    if not n:
+        return False
+    if n[0] == '_':
+        return False
+    if n[-1] == '_':
+        return False
+    if "_." in n or "._" in n:
+        return False
+    if len(n) == 1:
+        return True
+    if n[0] == '0' and n[1] not in ['.', 'o', 'b', 'x']:
+        return False
+    if n[0] == '+' or n[0] == '-':
+        n = n[1:]
+        if len(n) > 1 and n[0] == '0' and n[1] != '.':
+            return False
+    if '__' in n:
+        return False
+    return True
+
+
+def load(f, _dict=dict, decoder=None):
+    """Parses named file or files as toml and returns a dictionary
+
+    Args:
+        f: Path to the file to open, array of files to read into single dict
+           or a file descriptor
+        _dict: (optional) Specifies the class of the returned toml dictionary
+        decoder: The decoder to use
+
+    Returns:
+        Parsed toml file represented as a dictionary
+
+    Raises:
+        TypeError -- When f is invalid type
+        TomlDecodeError: Error while decoding toml
+        IOError / FileNotFoundError -- When an array with no valid (existing)
+        (Python 2 / Python 3)          file paths is passed
+    """
+
+    if _ispath(f):
+        with io.open(_getpath(f), encoding='utf-8') as ffile:
+            return loads(ffile.read(), _dict, decoder)
+    elif isinstance(f, list):
+        from os import path as op
+        from warnings import warn
+        if not [path for path in f if op.exists(path)]:
+            error_msg = "Load expects a list to contain filenames only."
+            error_msg += linesep
+            error_msg += ("The list needs to contain the path of at least one "
+                          "existing file.")
+            raise FNFError(error_msg)
+        if decoder is None:
+            decoder = TomlDecoder(_dict)
+        d = decoder.get_empty_table()
+        for l in f:  # noqa: E741
+            if op.exists(l):
+                d.update(load(l, _dict, decoder))
+            else:
+                warn("Non-existent filename in list with at least one valid "
+                     "filename")
+        return d
+    else:
+        try:
+            return loads(f.read(), _dict, decoder)
+        except AttributeError:
+            raise TypeError("You can only load a file descriptor, filename or "
+                            "list")
+
+
+_groupname_re = re.compile(r'^[A-Za-z0-9_-]+$')
+
+
+def loads(s, _dict=dict, decoder=None):
+    """Parses string as toml
+
+    Args:
+        s: String to be parsed
+        _dict: (optional) Specifies the class of the returned toml dictionary
+
+    Returns:
+        Parsed toml file represented as a dictionary
+
+    Raises:
+        TypeError: When a non-string is passed
+        TomlDecodeError: Error while decoding toml
+    """
+
+    implicitgroups = []
+    if decoder is None:
+        decoder = TomlDecoder(_dict)
+    retval = decoder.get_empty_table()
+    currentlevel = retval
+    if not isinstance(s, basestring):
+        raise TypeError("Expecting something like a string")
+
+    if not isinstance(s, unicode):
+        s = s.decode('utf8')
+
+    original = s
+    sl = list(s)
+    openarr = 0
+    openstring = False
+    openstrchar = ""
+    multilinestr = False
+    arrayoftables = False
+    beginline = True
+    keygroup = False
+    dottedkey = False
+    keyname = 0
+    key = ''
+    prev_key = ''
+    line_no = 1
+
+    for i, item in enumerate(sl):
+        if item == '\r' and sl[i + 1] == '\n':
+            sl[i] = ' '
+            continue
+        if keyname:
+            key += item
+            if item == '\n':
+                raise TomlDecodeError("Key name found without value."
+                                      " Reached end of line.", original, i)
+            if openstring:
+                if item == openstrchar:
+                    oddbackslash = False
+                    k = 1
+                    while i >= k and sl[i - k] == '\\':
+                        oddbackslash = not oddbackslash
+                        k += 1
+                    if not oddbackslash:
+                        keyname = 2
+                        openstring = False
+                        openstrchar = ""
+                continue
+            elif keyname == 1:
+                if item.isspace():
+                    keyname = 2
+                    continue
+                elif item == '.':
+                    dottedkey = True
+                    continue
+                elif item.isalnum() or item == '_' or item == '-':
+                    continue
+                elif (dottedkey and sl[i - 1] == '.' and
+                      (item == '"' or item == "'")):
+                    openstring = True
+                    openstrchar = item
+                    continue
+            elif keyname == 2:
+                if item.isspace():
+                    if dottedkey:
+                        nextitem = sl[i + 1]
+                        if not nextitem.isspace() and nextitem != '.':
+                            keyname = 1
+                    continue
+                if item == '.':
+                    dottedkey = True
+                    nextitem = sl[i + 1]
+                    if not nextitem.isspace() and nextitem != '.':
+                        keyname = 1
+                    continue
+            if item == '=':
+                keyname = 0
+                prev_key = key[:-1].rstrip()
+                key = ''
+                dottedkey = False
+            else:
+                raise TomlDecodeError("Found invalid character in key name: '" +
+                                      item + "'. Try quoting the key name.",
+                                      original, i)
+        if item == "'" and openstrchar != '"':
+            k = 1
+            try:
+                while sl[i - k] == "'":
+                    k += 1
+                    if k == 3:
+                        break
+            except IndexError:
+                pass
+            if k == 3:
+                multilinestr = not multilinestr
+                openstring = multilinestr
+            else:
+                openstring = not openstring
+            if openstring:
+                openstrchar = "'"
+            else:
+                openstrchar = ""
+        if item == '"' and openstrchar != "'":
+            oddbackslash = False
+            k = 1
+            tripquote = False
+            try:
+                while sl[i - k] == '"':
+                    k += 1
+                    if k == 3:
+                        tripquote = True
+                        break
+                if k == 1 or (k == 3 and tripquote):
+                    while sl[i - k] == '\\':
+                        oddbackslash = not oddbackslash
+                        k += 1
+            except IndexError:
+                pass
+            if not oddbackslash:
+                if tripquote:
+                    multilinestr = not multilinestr
+                    openstring = multilinestr
+                else:
+                    openstring = not openstring
+            if openstring:
+                openstrchar = '"'
+            else:
+                openstrchar = ""
+        if item == '#' and (not openstring and not keygroup and
+                            not arrayoftables):
+            j = i
+            comment = ""
+            try:
+                while sl[j] != '\n':
+                    comment += s[j]
+                    sl[j] = ' '
+                    j += 1
+            except IndexError:
+                break
+            if not openarr:
+                decoder.preserve_comment(line_no, prev_key, comment, beginline)
+        if item == '[' and (not openstring and not keygroup and
+                            not arrayoftables):
+            if beginline:
+                if len(sl) > i + 1 and sl[i + 1] == '[':
+                    arrayoftables = True
+                else:
+                    keygroup = True
+            else:
+                openarr += 1
+        if item == ']' and not openstring:
+            if keygroup:
+                keygroup = False
+            elif arrayoftables:
+                if sl[i - 1] == ']':
+                    arrayoftables = False
+            else:
+                openarr -= 1
+        if item == '\n':
+            if openstring or multilinestr:
+                if not multilinestr:
+                    raise TomlDecodeError("Unbalanced quotes", original, i)
+                if ((sl[i - 1] == "'" or sl[i - 1] == '"') and (
+                        sl[i - 2] == sl[i - 1])):
+                    sl[i] = sl[i - 1]
+                    if sl[i - 3] == sl[i - 1]:
+                        sl[i - 3] = ' '
+            elif openarr:
+                sl[i] = ' '
+            else:
+                beginline = True
+            line_no += 1
+        elif beginline and sl[i] != ' ' and sl[i] != '\t':
+            beginline = False
+            if not keygroup and not arrayoftables:
+                if sl[i] == '=':
+                    raise TomlDecodeError("Found empty keyname. ", original, i)
+                keyname = 1
+                key += item
+    if keyname:
+        raise TomlDecodeError("Key name found without value."
+                              " Reached end of file.", original, len(s))
+    if openstring:  # reached EOF and have an unterminated string
+        raise TomlDecodeError("Unterminated string found."
+                              " Reached end of file.", original, len(s))
+    s = ''.join(sl)
+    s = s.split('\n')
+    multikey = None
+    multilinestr = ""
+    multibackslash = False
+    pos = 0
+    for idx, line in enumerate(s):
+        if idx > 0:
+            pos += len(s[idx - 1]) + 1
+
+        decoder.embed_comments(idx, currentlevel)
+
+        if not multilinestr or multibackslash or '\n' not in multilinestr:
+            line = line.strip()
+        if line == "" and (not multikey or multibackslash):
+            continue
+        if multikey:
+            if multibackslash:
+                multilinestr += line
+            else:
+                multilinestr += line
+            multibackslash = False
+            closed = False
+            if multilinestr[0] == '[':
+                closed = line[-1] == ']'
+            elif len(line) > 2:
+                closed = (line[-1] == multilinestr[0] and
+                          line[-2] == multilinestr[0] and
+                          line[-3] == multilinestr[0])
+            if closed:
+                try:
+                    value, vtype = decoder.load_value(multilinestr)
+                except ValueError as err:
+                    raise TomlDecodeError(str(err), original, pos)
+                currentlevel[multikey] = value
+                multikey = None
+                multilinestr = ""
+            else:
+                k = len(multilinestr) - 1
+                while k > -1 and multilinestr[k] == '\\':
+                    multibackslash = not multibackslash
+                    k -= 1
+                if multibackslash:
+                    multilinestr = multilinestr[:-1]
+                else:
+                    multilinestr += "\n"
+            continue
+        if line[0] == '[':
+            arrayoftables = False
+            if len(line) == 1:
+                raise TomlDecodeError("Opening key group bracket on line by "
+                                      "itself.", original, pos)
+            if line[1] == '[':
+                arrayoftables = True
+                line = line[2:]
+                splitstr = ']]'
+            else:
+                line = line[1:]
+                splitstr = ']'
+            i = 1
+            quotesplits = decoder._get_split_on_quotes(line)
+            quoted = False
+            for quotesplit in quotesplits:
+                if not quoted and splitstr in quotesplit:
+                    break
+                i += quotesplit.count(splitstr)
+                quoted = not quoted
+            line = line.split(splitstr, i)
+            if len(line) < i + 1 or line[-1].strip() != "":
+                raise TomlDecodeError("Key group not on a line by itself.",
+                                      original, pos)
+            groups = splitstr.join(line[:-1]).split('.')
+            i = 0
+            while i < len(groups):
+                groups[i] = groups[i].strip()
+                if len(groups[i]) > 0 and (groups[i][0] == '"' or
+                                           groups[i][0] == "'"):
+                    groupstr = groups[i]
+                    j = i + 1
+                    while ((not groupstr[0] == groupstr[-1]) or
+                           len(groupstr) == 1):
+                        j += 1
+                        if j > len(groups) + 2:
+                            raise TomlDecodeError("Invalid group name '" +
+                                                  groupstr + "' Something " +
+                                                  "went wrong.", original, pos)
+                        groupstr = '.'.join(groups[i:j]).strip()
+                    groups[i] = groupstr[1:-1]
+                    groups[i + 1:j] = []
+                else:
+                    if not _groupname_re.match(groups[i]):
+                        raise TomlDecodeError("Invalid group name '" +
+                                              groups[i] + "'. Try quoting it.",
+                                              original, pos)
+                i += 1
+            currentlevel = retval
+            for i in _range(len(groups)):
+                group = groups[i]
+                if group == "":
+                    raise TomlDecodeError("Can't have a keygroup with an empty "
+                                          "name", original, pos)
+                try:
+                    currentlevel[group]
+                    if i == len(groups) - 1:
+                        if group in implicitgroups:
+                            implicitgroups.remove(group)
+                            if arrayoftables:
+                                raise TomlDecodeError("An implicitly defined "
+                                                      "table can't be an array",
+                                                      original, pos)
+                        elif arrayoftables:
+                            currentlevel[group].append(decoder.get_empty_table()
+                                                       )
+                        else:
+                            raise TomlDecodeError("What? " + group +
+                                                  " already exists?" +
+                                                  str(currentlevel),
+                                                  original, pos)
+                except TypeError:
+                    currentlevel = currentlevel[-1]
+                    if group not in currentlevel:
+                        currentlevel[group] = decoder.get_empty_table()
+                        if i == len(groups) - 1 and arrayoftables:
+                            currentlevel[group] = [decoder.get_empty_table()]
+                except KeyError:
+                    if i != len(groups) - 1:
+                        implicitgroups.append(group)
+                    currentlevel[group] = decoder.get_empty_table()
+                    if i == len(groups) - 1 and arrayoftables:
+                        currentlevel[group] = [decoder.get_empty_table()]
+                currentlevel = currentlevel[group]
+                if arrayoftables:
+                    try:
+                        currentlevel = currentlevel[-1]
+                    except KeyError:
+                        pass
+        elif line[0] == "{":
+            if line[-1] != "}":
+                raise TomlDecodeError("Line breaks are not allowed in inline"
+                                      "objects", original, pos)
+            try:
+                decoder.load_inline_object(line, currentlevel, multikey,
+                                           multibackslash)
+            except ValueError as err:
+                raise TomlDecodeError(str(err), original, pos)
+        elif "=" in line:
+            try:
+                ret = decoder.load_line(line, currentlevel, multikey,
+                                        multibackslash)
+            except ValueError as err:
+                raise TomlDecodeError(str(err), original, pos)
+            if ret is not None:
+                multikey, multilinestr, multibackslash = ret
+    return retval
+
+
+def _load_date(val):
+    microsecond = 0
+    tz = None
+    try:
+        if len(val) > 19:
+            if val[19] == '.':
+                if val[-1].upper() == 'Z':
+                    subsecondval = val[20:-1]
+                    tzval = "Z"
+                else:
+                    subsecondvalandtz = val[20:]
+                    if '+' in subsecondvalandtz:
+                        splitpoint = subsecondvalandtz.index('+')
+                        subsecondval = subsecondvalandtz[:splitpoint]
+                        tzval = subsecondvalandtz[splitpoint:]
+                    elif '-' in subsecondvalandtz:
+                        splitpoint = subsecondvalandtz.index('-')
+                        subsecondval = subsecondvalandtz[:splitpoint]
+                        tzval = subsecondvalandtz[splitpoint:]
+                    else:
+                        tzval = None
+                        subsecondval = subsecondvalandtz
+                if tzval is not None:
+                    tz = TomlTz(tzval)
+                microsecond = int(int(subsecondval) *
+                                  (10 ** (6 - len(subsecondval))))
+            else:
+                tz = TomlTz(val[19:])
+    except ValueError:
+        tz = None
+    if "-" not in val[1:]:
+        return None
+    try:
+        if len(val) == 10:
+            d = datetime.date(
+                int(val[:4]), int(val[5:7]),
+                int(val[8:10]))
+        else:
+            d = datetime.datetime(
+                int(val[:4]), int(val[5:7]),
+                int(val[8:10]), int(val[11:13]),
+                int(val[14:16]), int(val[17:19]), microsecond, tz)
+    except ValueError:
+        return None
+    return d
+
+
+def _load_unicode_escapes(v, hexbytes, prefix):
+    skip = False
+    i = len(v) - 1
+    while i > -1 and v[i] == '\\':
+        skip = not skip
+        i -= 1
+    for hx in hexbytes:
+        if skip:
+            skip = False
+            i = len(hx) - 1
+            while i > -1 and hx[i] == '\\':
+                skip = not skip
+                i -= 1
+            v += prefix
+            v += hx
+            continue
+        hxb = ""
+        i = 0
+        hxblen = 4
+        if prefix == "\\U":
+            hxblen = 8
+        hxb = ''.join(hx[i:i + hxblen]).lower()
+        if hxb.strip('0123456789abcdef'):
+            raise ValueError("Invalid escape sequence: " + hxb)
+        if hxb[0] == "d" and hxb[1].strip('01234567'):
+            raise ValueError("Invalid escape sequence: " + hxb +
+                             ". Only scalar unicode points are allowed.")
+        v += unichr(int(hxb, 16))
+        v += unicode(hx[len(hxb):])
+    return v
+
+
+# Unescape TOML string values.
+
+# content after the \
+_escapes = ['0', 'b', 'f', 'n', 'r', 't', '"']
+# What it should be replaced by
+_escapedchars = ['\0', '\b', '\f', '\n', '\r', '\t', '\"']
+# Used for substitution
+_escape_to_escapedchars = dict(zip(_escapes, _escapedchars))
+
+
+def _unescape(v):
+    """Unescape characters in a TOML string."""
+    i = 0
+    backslash = False
+    while i < len(v):
+        if backslash:
+            backslash = False
+            if v[i] in _escapes:
+                v = v[:i - 1] + _escape_to_escapedchars[v[i]] + v[i + 1:]
+            elif v[i] == '\\':
+                v = v[:i - 1] + v[i:]
+            elif v[i] == 'u' or v[i] == 'U':
+                i += 1
+            else:
+                raise ValueError("Reserved escape sequence used")
+            continue
+        elif v[i] == '\\':
+            backslash = True
+        i += 1
+    return v
+
+
+class InlineTableDict(object):
+    """Sentinel subclass of dict for inline tables."""
+
+
+class TomlDecoder(object):
+
+    def __init__(self, _dict=dict):
+        self._dict = _dict
+
+    def get_empty_table(self):
+        return self._dict()
+
+    def get_empty_inline_table(self):
+        class DynamicInlineTableDict(self._dict, InlineTableDict):
+            """Concrete sentinel subclass for inline tables.
+            It is a subclass of _dict which is passed in dynamically at load
+            time
+
+            It is also a subclass of InlineTableDict
+            """
+
+        return DynamicInlineTableDict()
+
+    def load_inline_object(self, line, currentlevel, multikey=False,
+                           multibackslash=False):
+        candidate_groups = line[1:-1].split(",")
+        groups = []
+        if len(candidate_groups) == 1 and not candidate_groups[0].strip():
+            candidate_groups.pop()
+        while len(candidate_groups) > 0:
+            candidate_group = candidate_groups.pop(0)
+            try:
+                _, value = candidate_group.split('=', 1)
+            except ValueError:
+                raise ValueError("Invalid inline table encountered")
+            value = value.strip()
+            if ((value[0] == value[-1] and value[0] in ('"', "'")) or (
+                    value[0] in '-0123456789' or
+                    value in ('true', 'false') or
+                    (value[0] == "[" and value[-1] == "]") or
+                    (value[0] == '{' and value[-1] == '}'))):
+                groups.append(candidate_group)
+            elif len(candidate_groups) > 0:
+                candidate_groups[0] = (candidate_group + "," +
+                                       candidate_groups[0])
+            else:
+                raise ValueError("Invalid inline table value encountered")
+        for group in groups:
+            status = self.load_line(group, currentlevel, multikey,
+                                    multibackslash)
+            if status is not None:
+                break
+
+    def _get_split_on_quotes(self, line):
+        doublequotesplits = line.split('"')
+        quoted = False
+        quotesplits = []
+        if len(doublequotesplits) > 1 and "'" in doublequotesplits[0]:
+            singlequotesplits = doublequotesplits[0].split("'")
+            doublequotesplits = doublequotesplits[1:]
+            while len(singlequotesplits) % 2 == 0 and len(doublequotesplits):
+                singlequotesplits[-1] += '"' + doublequotesplits[0]
+                doublequotesplits = doublequotesplits[1:]
+                if "'" in singlequotesplits[-1]:
+                    singlequotesplits = (singlequotesplits[:-1] +
+                                         singlequotesplits[-1].split("'"))
+            quotesplits += singlequotesplits
+        for doublequotesplit in doublequotesplits:
+            if quoted:
+                quotesplits.append(doublequotesplit)
+            else:
+                quotesplits += doublequotesplit.split("'")
+                quoted = not quoted
+        return quotesplits
+
+    def load_line(self, line, currentlevel, multikey, multibackslash):
+        i = 1
+        quotesplits = self._get_split_on_quotes(line)
+        quoted = False
+        for quotesplit in quotesplits:
+            if not quoted and '=' in quotesplit:
+                break
+            i += quotesplit.count('=')
+            quoted = not quoted
+        pair = line.split('=', i)
+        strictly_valid = _strictly_valid_num(pair[-1])
+        if _number_with_underscores.match(pair[-1]):
+            pair[-1] = pair[-1].replace('_', '')
+        while len(pair[-1]) and (pair[-1][0] != ' ' and pair[-1][0] != '\t' and
+                                 pair[-1][0] != "'" and pair[-1][0] != '"' and
+                                 pair[-1][0] != '[' and pair[-1][0] != '{' and
+                                 pair[-1].strip() != 'true' and
+                                 pair[-1].strip() != 'false'):
+            try:
+                float(pair[-1])
+                break
+            except ValueError:
+                pass
+            if _load_date(pair[-1]) is not None:
+                break
+            if TIME_RE.match(pair[-1]):
+                break
+            i += 1
+            prev_val = pair[-1]
+            pair = line.split('=', i)
+            if prev_val == pair[-1]:
+                raise ValueError("Invalid date or number")
+            if strictly_valid:
+                strictly_valid = _strictly_valid_num(pair[-1])
+        pair = ['='.join(pair[:-1]).strip(), pair[-1].strip()]
+        if '.' in pair[0]:
+            if '"' in pair[0] or "'" in pair[0]:
+                quotesplits = self._get_split_on_quotes(pair[0])
+                quoted = False
+                levels = []
+                for quotesplit in quotesplits:
+                    if quoted:
+                        levels.append(quotesplit)
+                    else:
+                        levels += [level.strip() for level in
+                                   quotesplit.split('.')]
+                    quoted = not quoted
+            else:
+                levels = pair[0].split('.')
+            while levels[-1] == "":
+                levels = levels[:-1]
+            for level in levels[:-1]:
+                if level == "":
+                    continue
+                if level not in currentlevel:
+                    currentlevel[level] = self.get_empty_table()
+                currentlevel = currentlevel[level]
+            pair[0] = levels[-1].strip()
+        elif (pair[0][0] == '"' or pair[0][0] == "'") and \
+                (pair[0][-1] == pair[0][0]):
+            pair[0] = _unescape(pair[0][1:-1])
+        k, koffset = self._load_line_multiline_str(pair[1])
+        if k > -1:
+            while k > -1 and pair[1][k + koffset] == '\\':
+                multibackslash = not multibackslash
+                k -= 1
+            if multibackslash:
+                multilinestr = pair[1][:-1]
+            else:
+                multilinestr = pair[1] + "\n"
+            multikey = pair[0]
+        else:
+            value, vtype = self.load_value(pair[1], strictly_valid)
+        try:
+            currentlevel[pair[0]]
+            raise ValueError("Duplicate keys!")
+        except TypeError:
+            raise ValueError("Duplicate keys!")
+        except KeyError:
+            if multikey:
+                return multikey, multilinestr, multibackslash
+            else:
+                currentlevel[pair[0]] = value
+
+    def _load_line_multiline_str(self, p):
+        poffset = 0
+        if len(p) < 3:
+            return -1, poffset
+        if p[0] == '[' and (p.strip()[-1] != ']' and
+                            self._load_array_isstrarray(p)):
+            newp = p[1:].strip().split(',')
+            while len(newp) > 1 and newp[-1][0] != '"' and newp[-1][0] != "'":
+                newp = newp[:-2] + [newp[-2] + ',' + newp[-1]]
+            newp = newp[-1]
+            poffset = len(p) - len(newp)
+            p = newp
+        if p[0] != '"' and p[0] != "'":
+            return -1, poffset
+        if p[1] != p[0] or p[2] != p[0]:
+            return -1, poffset
+        if len(p) > 5 and p[-1] == p[0] and p[-2] == p[0] and p[-3] == p[0]:
+            return -1, poffset
+        return len(p) - 1, poffset
+
+    def load_value(self, v, strictly_valid=True):
+        if not v:
+            raise ValueError("Empty value is invalid")
+        if v == 'true':
+            return (True, "bool")
+        elif v.lower() == 'true':
+            raise ValueError("Only all lowercase booleans allowed")
+        elif v == 'false':
+            return (False, "bool")
+        elif v.lower() == 'false':
+            raise ValueError("Only all lowercase booleans allowed")
+        elif v[0] == '"' or v[0] == "'":
+            quotechar = v[0]
+            testv = v[1:].split(quotechar)
+            triplequote = False
+            triplequotecount = 0
+            if len(testv) > 1 and testv[0] == '' and testv[1] == '':
+                testv = testv[2:]
+                triplequote = True
+            closed = False
+            for tv in testv:
+                if tv == '':
+                    if triplequote:
+                        triplequotecount += 1
+                    else:
+                        closed = True
+                else:
+                    oddbackslash = False
+                    try:
+                        i = -1
+                        j = tv[i]
+                        while j == '\\':
+                            oddbackslash = not oddbackslash
+                            i -= 1
+                            j = tv[i]
+                    except IndexError:
+                        pass
+                    if not oddbackslash:
+                        if closed:
+                            raise ValueError("Found tokens after a closed " +
+                                             "string. Invalid TOML.")
+                        else:
+                            if not triplequote or triplequotecount > 1:
+                                closed = True
+                            else:
+                                triplequotecount = 0
+            if quotechar == '"':
+                escapeseqs = v.split('\\')[1:]
+                backslash = False
+                for i in escapeseqs:
+                    if i == '':
+                        backslash = not backslash
+                    else:
+                        if i[0] not in _escapes and (i[0] != 'u' and
+                                                     i[0] != 'U' and
+                                                     not backslash):
+                            raise ValueError("Reserved escape sequence used")
+                        if backslash:
+                            backslash = False
+                for prefix in ["\\u", "\\U"]:
+                    if prefix in v:
+                        hexbytes = v.split(prefix)
+                        v = _load_unicode_escapes(hexbytes[0], hexbytes[1:],
+                                                  prefix)
+                v = _unescape(v)
+            if len(v) > 1 and v[1] == quotechar and (len(v) < 3 or
+                                                     v[1] == v[2]):
+                v = v[2:-2]
+            return (v[1:-1], "str")
+        elif v[0] == '[':
+            return (self.load_array(v), "array")
+        elif v[0] == '{':
+            inline_object = self.get_empty_inline_table()
+            self.load_inline_object(v, inline_object)
+            return (inline_object, "inline_object")
+        elif TIME_RE.match(v):
+            h, m, s, _, ms = TIME_RE.match(v).groups()
+            time = datetime.time(int(h), int(m), int(s), int(ms) if ms else 0)
+            return (time, "time")
+        else:
+            parsed_date = _load_date(v)
+            if parsed_date is not None:
+                return (parsed_date, "date")
+            if not strictly_valid:
+                raise ValueError("Weirdness with leading zeroes or "
+                                 "underscores in your number.")
+            itype = "int"
+            neg = False
+            if v[0] == '-':
+                neg = True
+                v = v[1:]
+            elif v[0] == '+':
+                v = v[1:]
+            v = v.replace('_', '')
+            lowerv = v.lower()
+            if '.' in v or ('x' not in v and ('e' in v or 'E' in v)):
+                if '.' in v and v.split('.', 1)[1] == '':
+                    raise ValueError("This float is missing digits after "
+                                     "the point")
+                if v[0] not in '0123456789':
+                    raise ValueError("This float doesn't have a leading "
+                                     "digit")
+                v = float(v)
+                itype = "float"
+            elif len(lowerv) == 3 and (lowerv == 'inf' or lowerv == 'nan'):
+                v = float(v)
+                itype = "float"
+            if itype == "int":
+                v = int(v, 0)
+            if neg:
+                return (0 - v, itype)
+            return (v, itype)
+
+    def bounded_string(self, s):
+        if len(s) == 0:
+            return True
+        if s[-1] != s[0]:
+            return False
+        i = -2
+        backslash = False
+        while len(s) + i > 0:
+            if s[i] == "\\":
+                backslash = not backslash
+                i -= 1
+            else:
+                break
+        return not backslash
+
+    def _load_array_isstrarray(self, a):
+        a = a[1:-1].strip()
+        if a != '' and (a[0] == '"' or a[0] == "'"):
+            return True
+        return False
+
+    def load_array(self, a):
+        atype = None
+        retval = []
+        a = a.strip()
+        if '[' not in a[1:-1] or "" != a[1:-1].split('[')[0].strip():
+            strarray = self._load_array_isstrarray(a)
+            if not a[1:-1].strip().startswith('{'):
+                a = a[1:-1].split(',')
+            else:
+                # a is an inline object, we must find the matching parenthesis
+                # to define groups
+                new_a = []
+                start_group_index = 1
+                end_group_index = 2
+                open_bracket_count = 1 if a[start_group_index] == '{' else 0
+                in_str = False
+                while end_group_index < len(a[1:]):
+                    if a[end_group_index] == '"' or a[end_group_index] == "'":
+                        if in_str:
+                            backslash_index = end_group_index - 1
+                            while (backslash_index > -1 and
+                                   a[backslash_index] == '\\'):
+                                in_str = not in_str
+                                backslash_index -= 1
+                        in_str = not in_str
+                    if not in_str and a[end_group_index] == '{':
+                        open_bracket_count += 1
+                    if in_str or a[end_group_index] != '}':
+                        end_group_index += 1
+                        continue
+                    elif a[end_group_index] == '}' and open_bracket_count > 1:
+                        open_bracket_count -= 1
+                        end_group_index += 1
+                        continue
+
+                    # Increase end_group_index by 1 to get the closing bracket
+                    end_group_index += 1
+
+                    new_a.append(a[start_group_index:end_group_index])
+
+                    # The next start index is at least after the closing
+                    # bracket, a closing bracket can be followed by a comma
+                    # since we are in an array.
+                    start_group_index = end_group_index + 1
+                    while (start_group_index < len(a[1:]) and
+                           a[start_group_index] != '{'):
+                        start_group_index += 1
+                    end_group_index = start_group_index + 1
+                a = new_a
+            b = 0
+            if strarray:
+                while b < len(a) - 1:
+                    ab = a[b].strip()
+                    while (not self.bounded_string(ab) or
+                           (len(ab) > 2 and
+                            ab[0] == ab[1] == ab[2] and
+                            ab[-2] != ab[0] and
+                            ab[-3] != ab[0])):
+                        a[b] = a[b] + ',' + a[b + 1]
+                        ab = a[b].strip()
+                        if b < len(a) - 2:
+                            a = a[:b + 1] + a[b + 2:]
+                        else:
+                            a = a[:b + 1]
+                    b += 1
+        else:
+            al = list(a[1:-1])
+            a = []
+            openarr = 0
+            j = 0
+            for i in _range(len(al)):
+                if al[i] == '[':
+                    openarr += 1
+                elif al[i] == ']':
+                    openarr -= 1
+                elif al[i] == ',' and not openarr:
+                    a.append(''.join(al[j:i]))
+                    j = i + 1
+            a.append(''.join(al[j:]))
+        for i in _range(len(a)):
+            a[i] = a[i].strip()
+            if a[i] != '':
+                nval, ntype = self.load_value(a[i])
+                if atype:
+                    if ntype != atype:
+                        raise ValueError("Not a homogeneous array")
+                else:
+                    atype = ntype
+                retval.append(nval)
+        return retval
+
+    def preserve_comment(self, line_no, key, comment, beginline):
+        pass
+
+    def embed_comments(self, idx, currentlevel):
+        pass
+
+
+class TomlPreserveCommentDecoder(TomlDecoder):
+
+    def __init__(self, _dict=dict):
+        self.saved_comments = {}
+        super(TomlPreserveCommentDecoder, self).__init__(_dict)
+
+    def preserve_comment(self, line_no, key, comment, beginline):
+        self.saved_comments[line_no] = (key, comment, beginline)
+
+    def embed_comments(self, idx, currentlevel):
+        if idx not in self.saved_comments:
+            return
+
+        key, comment, beginline = self.saved_comments[idx]
+        currentlevel[key] = CommentValue(currentlevel[key], comment, beginline,
+                                         self._dict)
diff --git a/myenv/lib/python3.9/site-packages/toml/encoder.py b/myenv/lib/python3.9/site-packages/toml/encoder.py
new file mode 100644
index 0000000..bf17a72
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/toml/encoder.py
@@ -0,0 +1,304 @@
+import datetime
+import re
+import sys
+from decimal import Decimal
+
+from toml.decoder import InlineTableDict
+
+if sys.version_info >= (3,):
+    unicode = str
+
+
+def dump(o, f, encoder=None):
+    """Writes out dict as toml to a file
+
+    Args:
+        o: Object to dump into toml
+        f: File descriptor where the toml should be stored
+        encoder: The ``TomlEncoder`` to use for constructing the output string
+
+    Returns:
+        String containing the toml corresponding to dictionary
+
+    Raises:
+        TypeError: When anything other than file descriptor is passed
+    """
+
+    if not f.write:
+        raise TypeError("You can only dump an object to a file descriptor")
+    d = dumps(o, encoder=encoder)
+    f.write(d)
+    return d
+
+
+def dumps(o, encoder=None):
+    """Stringifies input dict as toml
+
+    Args:
+        o: Object to dump into toml
+        encoder: The ``TomlEncoder`` to use for constructing the output string
+
+    Returns:
+        String containing the toml corresponding to dict
+
+    Examples:
+        ```python
+        >>> import toml
+        >>> output = {
+        ... 'a': "I'm a string",
+        ... 'b': ["I'm", "a", "list"],
+        ... 'c': 2400
+        ... }
+        >>> toml.dumps(output)
+        'a = "I\'m a string"\nb = [ "I\'m", "a", "list",]\nc = 2400\n'
+        ```
+    """
+
+    retval = ""
+    if encoder is None:
+        encoder = TomlEncoder(o.__class__)
+    addtoretval, sections = encoder.dump_sections(o, "")
+    retval += addtoretval
+    outer_objs = [id(o)]
+    while sections:
+        section_ids = [id(section) for section in sections.values()]
+        for outer_obj in outer_objs:
+            if outer_obj in section_ids:
+                raise ValueError("Circular reference detected")
+        outer_objs += section_ids
+        newsections = encoder.get_empty_table()
+        for section in sections:
+            addtoretval, addtosections = encoder.dump_sections(
+                sections[section], section)
+
+            if addtoretval or (not addtoretval and not addtosections):
+                if retval and retval[-2:] != "\n\n":
+                    retval += "\n"
+                retval += "[" + section + "]\n"
+                if addtoretval:
+                    retval += addtoretval
+            for s in addtosections:
+                newsections[section + "." + s] = addtosections[s]
+        sections = newsections
+    return retval
+
+
+def _dump_str(v):
+    if sys.version_info < (3,) and hasattr(v, 'decode') and isinstance(v, str):
+        v = v.decode('utf-8')
+    v = "%r" % v
+    if v[0] == 'u':
+        v = v[1:]
+    singlequote = v.startswith("'")
+    if singlequote or v.startswith('"'):
+        v = v[1:-1]
+    if singlequote:
+        v = v.replace("\\'", "'")
+        v = v.replace('"', '\\"')
+    v = v.split("\\x")
+    while len(v) > 1:
+        i = -1
+        if not v[0]:
+            v = v[1:]
+        v[0] = v[0].replace("\\\\", "\\")
+        # No, I don't know why != works and == breaks
+        joinx = v[0][i] != "\\"
+        while v[0][:i] and v[0][i] == "\\":
+            joinx = not joinx
+            i -= 1
+        if joinx:
+            joiner = "x"
+        else:
+            joiner = "u00"
+        v = [v[0] + joiner + v[1]] + v[2:]
+    return unicode('"' + v[0] + '"')
+
+
+def _dump_float(v):
+    return "{}".format(v).replace("e+0", "e+").replace("e-0", "e-")
+
+
+def _dump_time(v):
+    utcoffset = v.utcoffset()
+    if utcoffset is None:
+        return v.isoformat()
+    # The TOML norm specifies that it's local time thus we drop the offset
+    return v.isoformat()[:-6]
+
+
+class TomlEncoder(object):
+
+    def __init__(self, _dict=dict, preserve=False):
+        self._dict = _dict
+        self.preserve = preserve
+        self.dump_funcs = {
+            str: _dump_str,
+            unicode: _dump_str,
+            list: self.dump_list,
+            bool: lambda v: unicode(v).lower(),
+            int: lambda v: v,
+            float: _dump_float,
+            Decimal: _dump_float,
+            datetime.datetime: lambda v: v.isoformat().replace('+00:00', 'Z'),
+            datetime.time: _dump_time,
+            datetime.date: lambda v: v.isoformat()
+        }
+
+    def get_empty_table(self):
+        return self._dict()
+
+    def dump_list(self, v):
+        retval = "["
+        for u in v:
+            retval += " " + unicode(self.dump_value(u)) + ","
+        retval += "]"
+        return retval
+
+    def dump_inline_table(self, section):
+        """Preserve inline table in its compact syntax instead of expanding
+        into subsection.
+
+        https://github.com/toml-lang/toml#user-content-inline-table
+        """
+        retval = ""
+        if isinstance(section, dict):
+            val_list = []
+            for k, v in section.items():
+                val = self.dump_inline_table(v)
+                val_list.append(k + " = " + val)
+            retval += "{ " + ", ".join(val_list) + " }\n"
+            return retval
+        else:
+            return unicode(self.dump_value(section))
+
+    def dump_value(self, v):
+        # Lookup function corresponding to v's type
+        dump_fn = self.dump_funcs.get(type(v))
+        if dump_fn is None and hasattr(v, '__iter__'):
+            dump_fn = self.dump_funcs[list]
+        # Evaluate function (if it exists) else return v
+        return dump_fn(v) if dump_fn is not None else self.dump_funcs[str](v)
+
+    def dump_sections(self, o, sup):
+        retstr = ""
+        if sup != "" and sup[-1] != ".":
+            sup += '.'
+        retdict = self._dict()
+        arraystr = ""
+        for section in o:
+            section = unicode(section)
+            qsection = section
+            if not re.match(r'^[A-Za-z0-9_-]+$', section):
+                qsection = _dump_str(section)
+            if not isinstance(o[section], dict):
+                arrayoftables = False
+                if isinstance(o[section], list):
+                    for a in o[section]:
+                        if isinstance(a, dict):
+                            arrayoftables = True
+                if arrayoftables:
+                    for a in o[section]:
+                        arraytabstr = "\n"
+                        arraystr += "[[" + sup + qsection + "]]\n"
+                        s, d = self.dump_sections(a, sup + qsection)
+                        if s:
+                            if s[0] == "[":
+                                arraytabstr += s
+                            else:
+                                arraystr += s
+                        while d:
+                            newd = self._dict()
+                            for dsec in d:
+                                s1, d1 = self.dump_sections(d[dsec], sup +
+                                                            qsection + "." +
+                                                            dsec)
+                                if s1:
+                                    arraytabstr += ("[" + sup + qsection +
+                                                    "." + dsec + "]\n")
+                                    arraytabstr += s1
+                                for s1 in d1:
+                                    newd[dsec + "." + s1] = d1[s1]
+                            d = newd
+                        arraystr += arraytabstr
+                else:
+                    if o[section] is not None:
+                        retstr += (qsection + " = " +
+                                   unicode(self.dump_value(o[section])) + '\n')
+            elif self.preserve and isinstance(o[section], InlineTableDict):
+                retstr += (qsection + " = " +
+                           self.dump_inline_table(o[section]))
+            else:
+                retdict[qsection] = o[section]
+        retstr += arraystr
+        return (retstr, retdict)
+
+
+class TomlPreserveInlineDictEncoder(TomlEncoder):
+
+    def __init__(self, _dict=dict):
+        super(TomlPreserveInlineDictEncoder, self).__init__(_dict, True)
+
+
+class TomlArraySeparatorEncoder(TomlEncoder):
+
+    def __init__(self, _dict=dict, preserve=False, separator=","):
+        super(TomlArraySeparatorEncoder, self).__init__(_dict, preserve)
+        if separator.strip() == "":
+            separator = "," + separator
+        elif separator.strip(' \t\n\r,'):
+            raise ValueError("Invalid separator for arrays")
+        self.separator = separator
+
+    def dump_list(self, v):
+        t = []
+        retval = "["
+        for u in v:
+            t.append(self.dump_value(u))
+        while t != []:
+            s = []
+            for u in t:
+                if isinstance(u, list):
+                    for r in u:
+                        s.append(r)
+                else:
+                    retval += " " + unicode(u) + self.separator
+            t = s
+        retval += "]"
+        return retval
+
+
+class TomlNumpyEncoder(TomlEncoder):
+
+    def __init__(self, _dict=dict, preserve=False):
+        import numpy as np
+        super(TomlNumpyEncoder, self).__init__(_dict, preserve)
+        self.dump_funcs[np.float16] = _dump_float
+        self.dump_funcs[np.float32] = _dump_float
+        self.dump_funcs[np.float64] = _dump_float
+        self.dump_funcs[np.int16] = self._dump_int
+        self.dump_funcs[np.int32] = self._dump_int
+        self.dump_funcs[np.int64] = self._dump_int
+
+    def _dump_int(self, v):
+        return "{}".format(int(v))
+
+
+class TomlPreserveCommentEncoder(TomlEncoder):
+
+    def __init__(self, _dict=dict, preserve=False):
+        from toml.decoder import CommentValue
+        super(TomlPreserveCommentEncoder, self).__init__(_dict, preserve)
+        self.dump_funcs[CommentValue] = lambda v: v.dump(self.dump_value)
+
+
+class TomlPathlibEncoder(TomlEncoder):
+
+    def _dump_pathlib_path(self, v):
+        return _dump_str(str(v))
+
+    def dump_value(self, v):
+        if (3, 4) <= sys.version_info:
+            import pathlib
+            if isinstance(v, pathlib.PurePath):
+                v = str(v)
+        return super(TomlPathlibEncoder, self).dump_value(v)
diff --git a/myenv/lib/python3.9/site-packages/toml/ordered.py b/myenv/lib/python3.9/site-packages/toml/ordered.py
new file mode 100644
index 0000000..9c20c41
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/toml/ordered.py
@@ -0,0 +1,15 @@
+from collections import OrderedDict
+from toml import TomlEncoder
+from toml import TomlDecoder
+
+
+class TomlOrderedDecoder(TomlDecoder):
+
+    def __init__(self):
+        super(self.__class__, self).__init__(_dict=OrderedDict)
+
+
+class TomlOrderedEncoder(TomlEncoder):
+
+    def __init__(self):
+        super(self.__class__, self).__init__(_dict=OrderedDict)
diff --git a/myenv/lib/python3.9/site-packages/toml/tz.py b/myenv/lib/python3.9/site-packages/toml/tz.py
new file mode 100644
index 0000000..bf20593
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/toml/tz.py
@@ -0,0 +1,24 @@
+from datetime import tzinfo, timedelta
+
+
+class TomlTz(tzinfo):
+    def __init__(self, toml_offset):
+        if toml_offset == "Z":
+            self._raw_offset = "+00:00"
+        else:
+            self._raw_offset = toml_offset
+        self._sign = -1 if self._raw_offset[0] == '-' else 1
+        self._hours = int(self._raw_offset[1:3])
+        self._minutes = int(self._raw_offset[4:6])
+
+    def __deepcopy__(self, memo):
+        return self.__class__(self._raw_offset)
+
+    def tzname(self, dt):
+        return "UTC" + self._raw_offset
+
+    def utcoffset(self, dt):
+        return self._sign * timedelta(hours=self._hours, minutes=self._minutes)
+
+    def dst(self, dt):
+        return timedelta(0)
diff --git a/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/LICENSE
new file mode 100644
index 0000000..e859590
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Taneli Hukkinen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/METADATA b/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/METADATA
new file mode 100644
index 0000000..0ddc586
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/METADATA
@@ -0,0 +1,208 @@
+Metadata-Version: 2.1
+Name: tomli
+Version: 1.2.3
+Summary: A lil' TOML parser
+Keywords: toml
+Author-email: Taneli Hukkinen <hukkin@users.noreply.github.com>
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Project-URL: Changelog, https://github.com/hukkin/tomli/blob/master/CHANGELOG.md
+Project-URL: Homepage, https://github.com/hukkin/tomli
+
+[![Build Status](https://github.com/hukkin/tomli/workflows/Tests/badge.svg?branch=master)](https://github.com/hukkin/tomli/actions?query=workflow%3ATests+branch%3Amaster+event%3Apush)
+[![codecov.io](https://codecov.io/gh/hukkin/tomli/branch/master/graph/badge.svg)](https://codecov.io/gh/hukkin/tomli)
+[![PyPI version](https://img.shields.io/pypi/v/tomli)](https://pypi.org/project/tomli)
+
+# Tomli
+
+> A lil' TOML parser
+
+**Table of Contents**  *generated with [mdformat-toc](https://github.com/hukkin/mdformat-toc)*
+
+<!-- mdformat-toc start --slug=github --maxlevel=6 --minlevel=2 -->
+
+- [Intro](#intro)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Parse a TOML string](#parse-a-toml-string)
+  - [Parse a TOML file](#parse-a-toml-file)
+  - [Handle invalid TOML](#handle-invalid-toml)
+  - [Construct `decimal.Decimal`s from TOML floats](#construct-decimaldecimals-from-toml-floats)
+- [FAQ](#faq)
+  - [Why this parser?](#why-this-parser)
+  - [Is comment preserving round-trip parsing supported?](#is-comment-preserving-round-trip-parsing-supported)
+  - [Is there a `dumps`, `write` or `encode` function?](#is-there-a-dumps-write-or-encode-function)
+  - [How do TOML types map into Python types?](#how-do-toml-types-map-into-python-types)
+- [Performance](#performance)
+
+<!-- mdformat-toc end -->
+
+## Intro<a name="intro"></a>
+
+Tomli is a Python library for parsing [TOML](https://toml.io).
+Tomli is fully compatible with [TOML v1.0.0](https://toml.io/en/v1.0.0).
+
+## Installation<a name="installation"></a>
+
+```bash
+pip install tomli
+```
+
+## Usage<a name="usage"></a>
+
+### Parse a TOML string<a name="parse-a-toml-string"></a>
+
+```python
+import tomli
+
+toml_str = """
+           gretzky = 99
+
+           [kurri]
+           jari = 17
+           """
+
+toml_dict = tomli.loads(toml_str)
+assert toml_dict == {"gretzky": 99, "kurri": {"jari": 17}}
+```
+
+### Parse a TOML file<a name="parse-a-toml-file"></a>
+
+```python
+import tomli
+
+with open("path_to_file/conf.toml", "rb") as f:
+    toml_dict = tomli.load(f)
+```
+
+The file must be opened in binary mode (with the `"rb"` flag).
+Binary mode will enforce decoding the file as UTF-8 with universal newlines disabled,
+both of which are required to correctly parse TOML.
+Support for text file objects is deprecated for removal in the next major release.
+
+### Handle invalid TOML<a name="handle-invalid-toml"></a>
+
+```python
+import tomli
+
+try:
+    toml_dict = tomli.loads("]] this is invalid TOML [[")
+except tomli.TOMLDecodeError:
+    print("Yep, definitely not valid.")
+```
+
+Note that while the `TOMLDecodeError` type is public API, error messages of raised instances of it are not.
+Error messages should not be assumed to stay constant across Tomli versions.
+
+### Construct `decimal.Decimal`s from TOML floats<a name="construct-decimaldecimals-from-toml-floats"></a>
+
+```python
+from decimal import Decimal
+import tomli
+
+toml_dict = tomli.loads("precision-matters = 0.982492", parse_float=Decimal)
+assert toml_dict["precision-matters"] == Decimal("0.982492")
+```
+
+Note that `decimal.Decimal` can be replaced with another callable that converts a TOML float from string to a Python type.
+The `decimal.Decimal` is, however, a practical choice for use cases where float inaccuracies can not be tolerated.
+
+Illegal types include `dict`, `list`, and anything that has the `append` attribute.
+Parsing floats into an illegal type results in undefined behavior.
+
+## FAQ<a name="faq"></a>
+
+### Why this parser?<a name="why-this-parser"></a>
+
+- it's lil'
+- pure Python with zero dependencies
+- the fastest pure Python parser [\*](#performance):
+  15x as fast as [tomlkit](https://pypi.org/project/tomlkit/),
+  2.4x as fast as [toml](https://pypi.org/project/toml/)
+- outputs [basic data types](#how-do-toml-types-map-into-python-types) only
+- 100% spec compliant: passes all tests in
+  [a test set](https://github.com/toml-lang/compliance/pull/8)
+  soon to be merged to the official
+  [compliance tests for TOML](https://github.com/toml-lang/compliance)
+  repository
+- thoroughly tested: 100% branch coverage
+
+### Is comment preserving round-trip parsing supported?<a name="is-comment-preserving-round-trip-parsing-supported"></a>
+
+No.
+
+The `tomli.loads` function returns a plain `dict` that is populated with builtin types and types from the standard library only.
+Preserving comments requires a custom type to be returned so will not be supported,
+at least not by the `tomli.loads` and `tomli.load` functions.
+
+Look into [TOML Kit](https://github.com/sdispater/tomlkit) if preservation of style is what you need.
+
+### Is there a `dumps`, `write` or `encode` function?<a name="is-there-a-dumps-write-or-encode-function"></a>
+
+[Tomli-W](https://github.com/hukkin/tomli-w) is the write-only counterpart of Tomli, providing `dump` and `dumps` functions.
+
+The core library does not include write capability, as most TOML use cases are read-only, and Tomli intends to be minimal.
+
+### How do TOML types map into Python types?<a name="how-do-toml-types-map-into-python-types"></a>
+
+| TOML type        | Python type         | Details                                                      |
+| ---------------- | ------------------- | ------------------------------------------------------------ |
+| Document Root    | `dict`              |                                                              |
+| Key              | `str`               |                                                              |
+| String           | `str`               |                                                              |
+| Integer          | `int`               |                                                              |
+| Float            | `float`             |                                                              |
+| Boolean          | `bool`              |                                                              |
+| Offset Date-Time | `datetime.datetime` | `tzinfo` attribute set to an instance of `datetime.timezone` |
+| Local Date-Time  | `datetime.datetime` | `tzinfo` attribute set to `None`                             |
+| Local Date       | `datetime.date`     |                                                              |
+| Local Time       | `datetime.time`     |                                                              |
+| Array            | `list`              |                                                              |
+| Table            | `dict`              |                                                              |
+| Inline Table     | `dict`              |                                                              |
+
+## Performance<a name="performance"></a>
+
+The `benchmark/` folder in this repository contains a performance benchmark for comparing the various Python TOML parsers.
+The benchmark can be run with `tox -e benchmark-pypi`.
+Running the benchmark on my personal computer output the following:
+
+```console
+foo@bar:~/dev/tomli$ tox -e benchmark-pypi
+benchmark-pypi installed: attrs==19.3.0,click==7.1.2,pytomlpp==1.0.2,qtoml==0.3.0,rtoml==0.7.0,toml==0.10.2,tomli==1.1.0,tomlkit==0.7.2
+benchmark-pypi run-test-pre: PYTHONHASHSEED='2658546909'
+benchmark-pypi run-test: commands[0] | python -c 'import datetime; print(datetime.date.today())'
+2021-07-23
+benchmark-pypi run-test: commands[1] | python --version
+Python 3.8.10
+benchmark-pypi run-test: commands[2] | python benchmark/run.py
+Parsing data.toml 5000 times:
+------------------------------------------------------
+    parser |  exec time | performance (more is better)
+-----------+------------+-----------------------------
+     rtoml |    0.901 s | baseline (100%)
+  pytomlpp |     1.08 s | 83.15%
+     tomli |     3.89 s | 23.15%
+      toml |     9.36 s | 9.63%
+     qtoml |     11.5 s | 7.82%
+   tomlkit |     56.8 s | 1.59%
+```
+
+The parsers are ordered from fastest to slowest, using the fastest parser as baseline.
+Tomli performed the best out of all pure Python TOML parsers,
+losing only to pytomlpp (wraps C++) and rtoml (wraps Rust).
+
diff --git a/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/RECORD b/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/RECORD
new file mode 100644
index 0000000..d2249e3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/RECORD
@@ -0,0 +1,10 @@
+tomli/__init__.py,sha256=1DPXhXG6Ci6oRprDI-d6iBPVeKW3w_Ns8K9vdZM5WlI,299
+tomli/_parser.py,sha256=HYJuOBq1QBZm0O6PMeLJPULdYVwsdYcdZUSuABujXTM,21659
+tomli/_re.py,sha256=CGeXfid-5N2AlZ48UE8ASAFeeaLtlUe5oQgoUH0v_bs,2818
+tomli/_types.py,sha256=b1mavYLUYLBz0EP2lDrMVM6EGVFeqvxiqkS03jXNBvs,126
+tomli/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+tomli-1.2.3.dist-info/LICENSE,sha256=uAgWsNUwuKzLTCIReDeQmEpuO2GSLCte6S8zcqsnQv4,1072
+tomli-1.2.3.dist-info/WHEEL,sha256=LVOPL_YDMEiGvRLgDK1hLkfhFCnTcxcAYZJtpNFses0,81
+tomli-1.2.3.dist-info/METADATA,sha256=I3qYPyVLpQoNj-zQnKRgmdkC7V1nx_fPspqwTFMbniE,9089
+tomli-1.2.3.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+tomli-1.2.3.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/WHEEL
new file mode 100644
index 0000000..884ceb5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomli-1.2.3.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.5.1
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/myenv/lib/python3.9/site-packages/tomli/__init__.py b/myenv/lib/python3.9/site-packages/tomli/__init__.py
new file mode 100644
index 0000000..60f792a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomli/__init__.py
@@ -0,0 +1,9 @@
+"""A lil' TOML parser."""
+
+__all__ = ("loads", "load", "TOMLDecodeError")
+__version__ = "1.2.3"  # DO NOT EDIT THIS LINE MANUALLY. LET bump2version UTILITY DO IT
+
+from tomli._parser import TOMLDecodeError, load, loads
+
+# Pretend this exception was created here.
+TOMLDecodeError.__module__ = "tomli"
diff --git a/myenv/lib/python3.9/site-packages/tomli/_parser.py b/myenv/lib/python3.9/site-packages/tomli/_parser.py
new file mode 100644
index 0000000..89e81c3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomli/_parser.py
@@ -0,0 +1,663 @@
+import string
+from types import MappingProxyType
+from typing import Any, BinaryIO, Dict, FrozenSet, Iterable, NamedTuple, Optional, Tuple
+import warnings
+
+from tomli._re import (
+    RE_DATETIME,
+    RE_LOCALTIME,
+    RE_NUMBER,
+    match_to_datetime,
+    match_to_localtime,
+    match_to_number,
+)
+from tomli._types import Key, ParseFloat, Pos
+
+ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
+
+# Neither of these sets include quotation mark or backslash. They are
+# currently handled as separate cases in the parser functions.
+ILLEGAL_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t")
+ILLEGAL_MULTILINE_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t\n")
+
+ILLEGAL_LITERAL_STR_CHARS = ILLEGAL_BASIC_STR_CHARS
+ILLEGAL_MULTILINE_LITERAL_STR_CHARS = ILLEGAL_MULTILINE_BASIC_STR_CHARS
+
+ILLEGAL_COMMENT_CHARS = ILLEGAL_BASIC_STR_CHARS
+
+TOML_WS = frozenset(" \t")
+TOML_WS_AND_NEWLINE = TOML_WS | frozenset("\n")
+BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + "-_")
+KEY_INITIAL_CHARS = BARE_KEY_CHARS | frozenset("\"'")
+HEXDIGIT_CHARS = frozenset(string.hexdigits)
+
+BASIC_STR_ESCAPE_REPLACEMENTS = MappingProxyType(
+    {
+        "\\b": "\u0008",  # backspace
+        "\\t": "\u0009",  # tab
+        "\\n": "\u000A",  # linefeed
+        "\\f": "\u000C",  # form feed
+        "\\r": "\u000D",  # carriage return
+        '\\"': "\u0022",  # quote
+        "\\\\": "\u005C",  # backslash
+    }
+)
+
+
+class TOMLDecodeError(ValueError):
+    """An error raised if a document is not valid TOML."""
+
+
+def load(fp: BinaryIO, *, parse_float: ParseFloat = float) -> Dict[str, Any]:
+    """Parse TOML from a binary file object."""
+    s_bytes = fp.read()
+    try:
+        s = s_bytes.decode()
+    except AttributeError:
+        warnings.warn(
+            "Text file object support is deprecated in favor of binary file objects."
+            ' Use `open("foo.toml", "rb")` to open the file in binary mode.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        s = s_bytes  # type: ignore[assignment]
+    return loads(s, parse_float=parse_float)
+
+
+def loads(s: str, *, parse_float: ParseFloat = float) -> Dict[str, Any]:  # noqa: C901
+    """Parse TOML from a string."""
+
+    # The spec allows converting "\r\n" to "\n", even in string
+    # literals. Let's do so to simplify parsing.
+    src = s.replace("\r\n", "\n")
+    pos = 0
+    out = Output(NestedDict(), Flags())
+    header: Key = ()
+
+    # Parse one statement at a time
+    # (typically means one line in TOML source)
+    while True:
+        # 1. Skip line leading whitespace
+        pos = skip_chars(src, pos, TOML_WS)
+
+        # 2. Parse rules. Expect one of the following:
+        #    - end of file
+        #    - end of line
+        #    - comment
+        #    - key/value pair
+        #    - append dict to list (and move to its namespace)
+        #    - create dict (and move to its namespace)
+        # Skip trailing whitespace when applicable.
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char == "\n":
+            pos += 1
+            continue
+        if char in KEY_INITIAL_CHARS:
+            pos = key_value_rule(src, pos, out, header, parse_float)
+            pos = skip_chars(src, pos, TOML_WS)
+        elif char == "[":
+            try:
+                second_char: Optional[str] = src[pos + 1]
+            except IndexError:
+                second_char = None
+            if second_char == "[":
+                pos, header = create_list_rule(src, pos, out)
+            else:
+                pos, header = create_dict_rule(src, pos, out)
+            pos = skip_chars(src, pos, TOML_WS)
+        elif char != "#":
+            raise suffixed_err(src, pos, "Invalid statement")
+
+        # 3. Skip comment
+        pos = skip_comment(src, pos)
+
+        # 4. Expect end of line or end of file
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char != "\n":
+            raise suffixed_err(
+                src, pos, "Expected newline or end of document after a statement"
+            )
+        pos += 1
+
+    return out.data.dict
+
+
+class Flags:
+    """Flags that map to parsed keys/namespaces."""
+
+    # Marks an immutable namespace (inline array or inline table).
+    FROZEN = 0
+    # Marks a nest that has been explicitly created and can no longer
+    # be opened using the "[table]" syntax.
+    EXPLICIT_NEST = 1
+
+    def __init__(self) -> None:
+        self._flags: Dict[str, dict] = {}
+
+    def unset_all(self, key: Key) -> None:
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return
+            cont = cont[k]["nested"]
+        cont.pop(key[-1], None)
+
+    def set_for_relative_key(self, head_key: Key, rel_key: Key, flag: int) -> None:
+        cont = self._flags
+        for k in head_key:
+            if k not in cont:
+                cont[k] = {"flags": set(), "recursive_flags": set(), "nested": {}}
+            cont = cont[k]["nested"]
+        for k in rel_key:
+            if k in cont:
+                cont[k]["flags"].add(flag)
+            else:
+                cont[k] = {"flags": {flag}, "recursive_flags": set(), "nested": {}}
+            cont = cont[k]["nested"]
+
+    def set(self, key: Key, flag: int, *, recursive: bool) -> None:  # noqa: A003
+        cont = self._flags
+        key_parent, key_stem = key[:-1], key[-1]
+        for k in key_parent:
+            if k not in cont:
+                cont[k] = {"flags": set(), "recursive_flags": set(), "nested": {}}
+            cont = cont[k]["nested"]
+        if key_stem not in cont:
+            cont[key_stem] = {"flags": set(), "recursive_flags": set(), "nested": {}}
+        cont[key_stem]["recursive_flags" if recursive else "flags"].add(flag)
+
+    def is_(self, key: Key, flag: int) -> bool:
+        if not key:
+            return False  # document root has no flags
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return False
+            inner_cont = cont[k]
+            if flag in inner_cont["recursive_flags"]:
+                return True
+            cont = inner_cont["nested"]
+        key_stem = key[-1]
+        if key_stem in cont:
+            cont = cont[key_stem]
+            return flag in cont["flags"] or flag in cont["recursive_flags"]
+        return False
+
+
+class NestedDict:
+    def __init__(self) -> None:
+        # The parsed content of the TOML document
+        self.dict: Dict[str, Any] = {}
+
+    def get_or_create_nest(
+        self,
+        key: Key,
+        *,
+        access_lists: bool = True,
+    ) -> dict:
+        cont: Any = self.dict
+        for k in key:
+            if k not in cont:
+                cont[k] = {}
+            cont = cont[k]
+            if access_lists and isinstance(cont, list):
+                cont = cont[-1]
+            if not isinstance(cont, dict):
+                raise KeyError("There is no nest behind this key")
+        return cont
+
+    def append_nest_to_list(self, key: Key) -> None:
+        cont = self.get_or_create_nest(key[:-1])
+        last_key = key[-1]
+        if last_key in cont:
+            list_ = cont[last_key]
+            try:
+                list_.append({})
+            except AttributeError:
+                raise KeyError("An object other than list found behind this key")
+        else:
+            cont[last_key] = [{}]
+
+
+class Output(NamedTuple):
+    data: NestedDict
+    flags: Flags
+
+
+def skip_chars(src: str, pos: Pos, chars: Iterable[str]) -> Pos:
+    try:
+        while src[pos] in chars:
+            pos += 1
+    except IndexError:
+        pass
+    return pos
+
+
+def skip_until(
+    src: str,
+    pos: Pos,
+    expect: str,
+    *,
+    error_on: FrozenSet[str],
+    error_on_eof: bool,
+) -> Pos:
+    try:
+        new_pos = src.index(expect, pos)
+    except ValueError:
+        new_pos = len(src)
+        if error_on_eof:
+            raise suffixed_err(src, new_pos, f"Expected {expect!r}") from None
+
+    if not error_on.isdisjoint(src[pos:new_pos]):
+        while src[pos] not in error_on:
+            pos += 1
+        raise suffixed_err(src, pos, f"Found invalid character {src[pos]!r}")
+    return new_pos
+
+
+def skip_comment(src: str, pos: Pos) -> Pos:
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char == "#":
+        return skip_until(
+            src, pos + 1, "\n", error_on=ILLEGAL_COMMENT_CHARS, error_on_eof=False
+        )
+    return pos
+
+
+def skip_comments_and_array_ws(src: str, pos: Pos) -> Pos:
+    while True:
+        pos_before_skip = pos
+        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        pos = skip_comment(src, pos)
+        if pos == pos_before_skip:
+            return pos
+
+
+def create_dict_rule(src: str, pos: Pos, out: Output) -> Tuple[Pos, Key]:
+    pos += 1  # Skip "["
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, key = parse_key(src, pos)
+
+    if out.flags.is_(key, Flags.EXPLICIT_NEST) or out.flags.is_(key, Flags.FROZEN):
+        raise suffixed_err(src, pos, f"Can not declare {key} twice")
+    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.get_or_create_nest(key)
+    except KeyError:
+        raise suffixed_err(src, pos, "Can not overwrite a value") from None
+
+    if not src.startswith("]", pos):
+        raise suffixed_err(src, pos, 'Expected "]" at the end of a table declaration')
+    return pos + 1, key
+
+
+def create_list_rule(src: str, pos: Pos, out: Output) -> Tuple[Pos, Key]:
+    pos += 2  # Skip "[["
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, key = parse_key(src, pos)
+
+    if out.flags.is_(key, Flags.FROZEN):
+        raise suffixed_err(src, pos, f"Can not mutate immutable namespace {key}")
+    # Free the namespace now that it points to another empty list item...
+    out.flags.unset_all(key)
+    # ...but this key precisely is still prohibited from table declaration
+    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.append_nest_to_list(key)
+    except KeyError:
+        raise suffixed_err(src, pos, "Can not overwrite a value") from None
+
+    if not src.startswith("]]", pos):
+        raise suffixed_err(src, pos, 'Expected "]]" at the end of an array declaration')
+    return pos + 2, key
+
+
+def key_value_rule(
+    src: str, pos: Pos, out: Output, header: Key, parse_float: ParseFloat
+) -> Pos:
+    pos, key, value = parse_key_value_pair(src, pos, parse_float)
+    key_parent, key_stem = key[:-1], key[-1]
+    abs_key_parent = header + key_parent
+
+    if out.flags.is_(abs_key_parent, Flags.FROZEN):
+        raise suffixed_err(
+            src, pos, f"Can not mutate immutable namespace {abs_key_parent}"
+        )
+    # Containers in the relative path can't be opened with the table syntax after this
+    out.flags.set_for_relative_key(header, key, Flags.EXPLICIT_NEST)
+    try:
+        nest = out.data.get_or_create_nest(abs_key_parent)
+    except KeyError:
+        raise suffixed_err(src, pos, "Can not overwrite a value") from None
+    if key_stem in nest:
+        raise suffixed_err(src, pos, "Can not overwrite a value")
+    # Mark inline table and array namespaces recursively immutable
+    if isinstance(value, (dict, list)):
+        out.flags.set(header + key, Flags.FROZEN, recursive=True)
+    nest[key_stem] = value
+    return pos
+
+
+def parse_key_value_pair(
+    src: str, pos: Pos, parse_float: ParseFloat
+) -> Tuple[Pos, Key, Any]:
+    pos, key = parse_key(src, pos)
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char != "=":
+        raise suffixed_err(src, pos, 'Expected "=" after a key in a key/value pair')
+    pos += 1
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, value = parse_value(src, pos, parse_float)
+    return pos, key, value
+
+
+def parse_key(src: str, pos: Pos) -> Tuple[Pos, Key]:
+    pos, key_part = parse_key_part(src, pos)
+    key: Key = (key_part,)
+    pos = skip_chars(src, pos, TOML_WS)
+    while True:
+        try:
+            char: Optional[str] = src[pos]
+        except IndexError:
+            char = None
+        if char != ".":
+            return pos, key
+        pos += 1
+        pos = skip_chars(src, pos, TOML_WS)
+        pos, key_part = parse_key_part(src, pos)
+        key += (key_part,)
+        pos = skip_chars(src, pos, TOML_WS)
+
+
+def parse_key_part(src: str, pos: Pos) -> Tuple[Pos, str]:
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char in BARE_KEY_CHARS:
+        start_pos = pos
+        pos = skip_chars(src, pos, BARE_KEY_CHARS)
+        return pos, src[start_pos:pos]
+    if char == "'":
+        return parse_literal_str(src, pos)
+    if char == '"':
+        return parse_one_line_basic_str(src, pos)
+    raise suffixed_err(src, pos, "Invalid initial character for a key part")
+
+
+def parse_one_line_basic_str(src: str, pos: Pos) -> Tuple[Pos, str]:
+    pos += 1
+    return parse_basic_str(src, pos, multiline=False)
+
+
+def parse_array(src: str, pos: Pos, parse_float: ParseFloat) -> Tuple[Pos, list]:
+    pos += 1
+    array: list = []
+
+    pos = skip_comments_and_array_ws(src, pos)
+    if src.startswith("]", pos):
+        return pos + 1, array
+    while True:
+        pos, val = parse_value(src, pos, parse_float)
+        array.append(val)
+        pos = skip_comments_and_array_ws(src, pos)
+
+        c = src[pos : pos + 1]
+        if c == "]":
+            return pos + 1, array
+        if c != ",":
+            raise suffixed_err(src, pos, "Unclosed array")
+        pos += 1
+
+        pos = skip_comments_and_array_ws(src, pos)
+        if src.startswith("]", pos):
+            return pos + 1, array
+
+
+def parse_inline_table(src: str, pos: Pos, parse_float: ParseFloat) -> Tuple[Pos, dict]:
+    pos += 1
+    nested_dict = NestedDict()
+    flags = Flags()
+
+    pos = skip_chars(src, pos, TOML_WS)
+    if src.startswith("}", pos):
+        return pos + 1, nested_dict.dict
+    while True:
+        pos, key, value = parse_key_value_pair(src, pos, parse_float)
+        key_parent, key_stem = key[:-1], key[-1]
+        if flags.is_(key, Flags.FROZEN):
+            raise suffixed_err(src, pos, f"Can not mutate immutable namespace {key}")
+        try:
+            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
+        except KeyError:
+            raise suffixed_err(src, pos, "Can not overwrite a value") from None
+        if key_stem in nest:
+            raise suffixed_err(src, pos, f"Duplicate inline table key {key_stem!r}")
+        nest[key_stem] = value
+        pos = skip_chars(src, pos, TOML_WS)
+        c = src[pos : pos + 1]
+        if c == "}":
+            return pos + 1, nested_dict.dict
+        if c != ",":
+            raise suffixed_err(src, pos, "Unclosed inline table")
+        if isinstance(value, (dict, list)):
+            flags.set(key, Flags.FROZEN, recursive=True)
+        pos += 1
+        pos = skip_chars(src, pos, TOML_WS)
+
+
+def parse_basic_str_escape(  # noqa: C901
+    src: str, pos: Pos, *, multiline: bool = False
+) -> Tuple[Pos, str]:
+    escape_id = src[pos : pos + 2]
+    pos += 2
+    if multiline and escape_id in {"\\ ", "\\\t", "\\\n"}:
+        # Skip whitespace until next non-whitespace character or end of
+        # the doc. Error if non-whitespace is found before newline.
+        if escape_id != "\\\n":
+            pos = skip_chars(src, pos, TOML_WS)
+            try:
+                char = src[pos]
+            except IndexError:
+                return pos, ""
+            if char != "\n":
+                raise suffixed_err(src, pos, 'Unescaped "\\" in a string')
+            pos += 1
+        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        return pos, ""
+    if escape_id == "\\u":
+        return parse_hex_char(src, pos, 4)
+    if escape_id == "\\U":
+        return parse_hex_char(src, pos, 8)
+    try:
+        return pos, BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
+    except KeyError:
+        if len(escape_id) != 2:
+            raise suffixed_err(src, pos, "Unterminated string") from None
+        raise suffixed_err(src, pos, 'Unescaped "\\" in a string') from None
+
+
+def parse_basic_str_escape_multiline(src: str, pos: Pos) -> Tuple[Pos, str]:
+    return parse_basic_str_escape(src, pos, multiline=True)
+
+
+def parse_hex_char(src: str, pos: Pos, hex_len: int) -> Tuple[Pos, str]:
+    hex_str = src[pos : pos + hex_len]
+    if len(hex_str) != hex_len or not HEXDIGIT_CHARS.issuperset(hex_str):
+        raise suffixed_err(src, pos, "Invalid hex value")
+    pos += hex_len
+    hex_int = int(hex_str, 16)
+    if not is_unicode_scalar_value(hex_int):
+        raise suffixed_err(src, pos, "Escaped character is not a Unicode scalar value")
+    return pos, chr(hex_int)
+
+
+def parse_literal_str(src: str, pos: Pos) -> Tuple[Pos, str]:
+    pos += 1  # Skip starting apostrophe
+    start_pos = pos
+    pos = skip_until(
+        src, pos, "'", error_on=ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True
+    )
+    return pos + 1, src[start_pos:pos]  # Skip ending apostrophe
+
+
+def parse_multiline_str(src: str, pos: Pos, *, literal: bool) -> Tuple[Pos, str]:
+    pos += 3
+    if src.startswith("\n", pos):
+        pos += 1
+
+    if literal:
+        delim = "'"
+        end_pos = skip_until(
+            src,
+            pos,
+            "'''",
+            error_on=ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
+            error_on_eof=True,
+        )
+        result = src[pos:end_pos]
+        pos = end_pos + 3
+    else:
+        delim = '"'
+        pos, result = parse_basic_str(src, pos, multiline=True)
+
+    # Add at maximum two extra apostrophes/quotes if the end sequence
+    # is 4 or 5 chars long instead of just 3.
+    if not src.startswith(delim, pos):
+        return pos, result
+    pos += 1
+    if not src.startswith(delim, pos):
+        return pos, result + delim
+    pos += 1
+    return pos, result + (delim * 2)
+
+
+def parse_basic_str(src: str, pos: Pos, *, multiline: bool) -> Tuple[Pos, str]:
+    if multiline:
+        error_on = ILLEGAL_MULTILINE_BASIC_STR_CHARS
+        parse_escapes = parse_basic_str_escape_multiline
+    else:
+        error_on = ILLEGAL_BASIC_STR_CHARS
+        parse_escapes = parse_basic_str_escape
+    result = ""
+    start_pos = pos
+    while True:
+        try:
+            char = src[pos]
+        except IndexError:
+            raise suffixed_err(src, pos, "Unterminated string") from None
+        if char == '"':
+            if not multiline:
+                return pos + 1, result + src[start_pos:pos]
+            if src.startswith('"""', pos):
+                return pos + 3, result + src[start_pos:pos]
+            pos += 1
+            continue
+        if char == "\\":
+            result += src[start_pos:pos]
+            pos, parsed_escape = parse_escapes(src, pos)
+            result += parsed_escape
+            start_pos = pos
+            continue
+        if char in error_on:
+            raise suffixed_err(src, pos, f"Illegal character {char!r}")
+        pos += 1
+
+
+def parse_value(  # noqa: C901
+    src: str, pos: Pos, parse_float: ParseFloat
+) -> Tuple[Pos, Any]:
+    try:
+        char: Optional[str] = src[pos]
+    except IndexError:
+        char = None
+
+    # Basic strings
+    if char == '"':
+        if src.startswith('"""', pos):
+            return parse_multiline_str(src, pos, literal=False)
+        return parse_one_line_basic_str(src, pos)
+
+    # Literal strings
+    if char == "'":
+        if src.startswith("'''", pos):
+            return parse_multiline_str(src, pos, literal=True)
+        return parse_literal_str(src, pos)
+
+    # Booleans
+    if char == "t":
+        if src.startswith("true", pos):
+            return pos + 4, True
+    if char == "f":
+        if src.startswith("false", pos):
+            return pos + 5, False
+
+    # Dates and times
+    datetime_match = RE_DATETIME.match(src, pos)
+    if datetime_match:
+        try:
+            datetime_obj = match_to_datetime(datetime_match)
+        except ValueError as e:
+            raise suffixed_err(src, pos, "Invalid date or datetime") from e
+        return datetime_match.end(), datetime_obj
+    localtime_match = RE_LOCALTIME.match(src, pos)
+    if localtime_match:
+        return localtime_match.end(), match_to_localtime(localtime_match)
+
+    # Integers and "normal" floats.
+    # The regex will greedily match any type starting with a decimal
+    # char, so needs to be located after handling of dates and times.
+    number_match = RE_NUMBER.match(src, pos)
+    if number_match:
+        return number_match.end(), match_to_number(number_match, parse_float)
+
+    # Arrays
+    if char == "[":
+        return parse_array(src, pos, parse_float)
+
+    # Inline tables
+    if char == "{":
+        return parse_inline_table(src, pos, parse_float)
+
+    # Special floats
+    first_three = src[pos : pos + 3]
+    if first_three in {"inf", "nan"}:
+        return pos + 3, parse_float(first_three)
+    first_four = src[pos : pos + 4]
+    if first_four in {"-inf", "+inf", "-nan", "+nan"}:
+        return pos + 4, parse_float(first_four)
+
+    raise suffixed_err(src, pos, "Invalid value")
+
+
+def suffixed_err(src: str, pos: Pos, msg: str) -> TOMLDecodeError:
+    """Return a `TOMLDecodeError` where error message is suffixed with
+    coordinates in source."""
+
+    def coord_repr(src: str, pos: Pos) -> str:
+        if pos >= len(src):
+            return "end of document"
+        line = src.count("\n", 0, pos) + 1
+        if line == 1:
+            column = pos + 1
+        else:
+            column = pos - src.rindex("\n", 0, pos)
+        return f"line {line}, column {column}"
+
+    return TOMLDecodeError(f"{msg} (at {coord_repr(src, pos)})")
+
+
+def is_unicode_scalar_value(codepoint: int) -> bool:
+    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
diff --git a/myenv/lib/python3.9/site-packages/tomli/_re.py b/myenv/lib/python3.9/site-packages/tomli/_re.py
new file mode 100644
index 0000000..9dc9e90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomli/_re.py
@@ -0,0 +1,101 @@
+from datetime import date, datetime, time, timedelta, timezone, tzinfo
+from functools import lru_cache
+import re
+from typing import Any, Optional, Union
+
+from tomli._types import ParseFloat
+
+# E.g.
+# - 00:32:00.999999
+# - 00:32:00
+_TIME_RE_STR = r"([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.([0-9]{1,6})[0-9]*)?"
+
+RE_NUMBER = re.compile(
+    r"""
+0
+(?:
+    x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*   # hex
+    |
+    b[01](?:_?[01])*                 # bin
+    |
+    o[0-7](?:_?[0-7])*               # oct
+)
+|
+[+-]?(?:0|[1-9](?:_?[0-9])*)         # dec, integer part
+(?P<floatpart>
+    (?:\.[0-9](?:_?[0-9])*)?         # optional fractional part
+    (?:[eE][+-]?[0-9](?:_?[0-9])*)?  # optional exponent part
+)
+""",
+    flags=re.VERBOSE,
+)
+RE_LOCALTIME = re.compile(_TIME_RE_STR)
+RE_DATETIME = re.compile(
+    fr"""
+([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])  # date, e.g. 1988-10-27
+(?:
+    [Tt ]
+    {_TIME_RE_STR}
+    (?:([Zz])|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))?  # optional time offset
+)?
+""",
+    flags=re.VERBOSE,
+)
+
+
+def match_to_datetime(match: "re.Match") -> Union[datetime, date]:
+    """Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`.
+
+    Raises ValueError if the match does not correspond to a valid date
+    or datetime.
+    """
+    (
+        year_str,
+        month_str,
+        day_str,
+        hour_str,
+        minute_str,
+        sec_str,
+        micros_str,
+        zulu_time,
+        offset_sign_str,
+        offset_hour_str,
+        offset_minute_str,
+    ) = match.groups()
+    year, month, day = int(year_str), int(month_str), int(day_str)
+    if hour_str is None:
+        return date(year, month, day)
+    hour, minute, sec = int(hour_str), int(minute_str), int(sec_str)
+    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
+    if offset_sign_str:
+        tz: Optional[tzinfo] = cached_tz(
+            offset_hour_str, offset_minute_str, offset_sign_str
+        )
+    elif zulu_time:
+        tz = timezone.utc
+    else:  # local date-time
+        tz = None
+    return datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)
+
+
+@lru_cache(maxsize=None)
+def cached_tz(hour_str: str, minute_str: str, sign_str: str) -> timezone:
+    sign = 1 if sign_str == "+" else -1
+    return timezone(
+        timedelta(
+            hours=sign * int(hour_str),
+            minutes=sign * int(minute_str),
+        )
+    )
+
+
+def match_to_localtime(match: "re.Match") -> time:
+    hour_str, minute_str, sec_str, micros_str = match.groups()
+    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
+    return time(int(hour_str), int(minute_str), int(sec_str), micros)
+
+
+def match_to_number(match: "re.Match", parse_float: "ParseFloat") -> Any:
+    if match.group("floatpart"):
+        return parse_float(match.group())
+    return int(match.group(), 0)
diff --git a/myenv/lib/python3.9/site-packages/tomli/_types.py b/myenv/lib/python3.9/site-packages/tomli/_types.py
new file mode 100644
index 0000000..e37cc80
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomli/_types.py
@@ -0,0 +1,6 @@
+from typing import Any, Callable, Tuple
+
+# Type annotations
+ParseFloat = Callable[[str], Any]
+Key = Tuple[str, ...]
+Pos = int
diff --git a/myenv/lib/python3.9/site-packages/tomli/py.typed b/myenv/lib/python3.9/site-packages/tomli/py.typed
new file mode 100644
index 0000000..7632ecf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomli/py.typed
@@ -0,0 +1 @@
+# Marker file for PEP 561
diff --git a/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/LICENSE
new file mode 100644
index 0000000..44cf2b3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2018 Sébastien Eustace
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/METADATA b/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/METADATA
new file mode 100644
index 0000000..14981c4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/METADATA
@@ -0,0 +1,194 @@
+Metadata-Version: 2.1
+Name: tomlkit
+Version: 0.7.2
+Summary: Style preserving TOML library
+Home-page: https://github.com/sdispater/tomlkit
+License: MIT
+Author: Sébastien Eustace
+Author-email: sebastien@eustace.io
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Dist: enum34 (>=1.1,<2.0); python_version >= "2.7" and python_version < "2.8"
+Requires-Dist: functools32 (>=3.2.3,<4.0.0); python_version >= "2.7" and python_version < "2.8"
+Requires-Dist: typing (>=3.6,<4.0); python_version >= "2.7" and python_version < "2.8" or python_version >= "3.4" and python_version < "3.5"
+Project-URL: Repository, https://github.com/sdispater/tomlkit
+Description-Content-Type: text/markdown
+
+[github_release]: https://img.shields.io/github/release/sdispater/tomlkit.svg?logo=github&logoColor=white
+[pypi_version]: https://img.shields.io/pypi/v/tomlkit.svg?logo=python&logoColor=white
+[python_versions]: https://img.shields.io/pypi/pyversions/tomlkit.svg?logo=python&logoColor=white
+[github_license]: https://img.shields.io/github/license/sdispater/tomlkit.svg?logo=github&logoColor=white
+[travisci]: https://img.shields.io/travis/com/sdispater/tomlkit/master.svg?logo=travis&logoColor=white&label=Travis%20CI
+[appveyor]: https://img.shields.io/appveyor/ci/sdispater/tomlkit/master.svg?logo=appveyor&logoColor=white&label=AppVeyor
+<!--Codecov logo not offered by shields.io or simpleicons.org, this is Codecov's SVG image modified to be white-->
+[codecov]: https://img.shields.io/codecov/c/github/sdispater/tomlkit/master.svg?logo=data:image/svg+xml;base64,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&label=Codecov
+
+[![GitHub Release][github_release]](https://github.com/sdispater/tomlkit/releases/)
+[![PyPI Version][pypi_version]](https://pypi.python.org/pypi/tomlkit/)
+[![Python Versions][python_versions]](https://pypi.python.org/pypi/tomlkit/)
+[![License][github_license]](https://github.com/sdispater/tomlkit/blob/master/LICENSE)
+<br>
+[![Travis CI][travisci]](https://travis-ci.com/sdispater/tomlkit)
+[![AppVeyor][appveyor]](https://ci.appveyor.com/project/sdispater/tomlkit)
+[![Codecov][codecov]](https://codecov.io/gh/sdispater/tomlkit)
+
+# TOML Kit - Style-preserving TOML library for Python
+
+TOML Kit is a **1.0.0rc1-compliant** [TOML](https://github.com/toml-lang/toml) library.
+
+It includes a parser that preserves all comments, indentations, whitespace and internal element ordering,
+and makes them accessible and editable via an intuitive API.
+
+You can also create new TOML documents from scratch using the provided helpers.
+
+Part of the implementation as been adapted, improved and fixed from [Molten](https://github.com/LeopoldArkham/Molten).
+
+## Usage
+
+### Parsing
+
+TOML Kit comes with a fast and style-preserving parser to help you access
+the content of TOML files and strings.
+
+```python
+>>> from tomlkit import dumps
+>>> from tomlkit import parse  # you can also use loads
+
+>>> content = """[table]
+... foo = "bar"  # String
+... """
+>>> doc = parse(content)
+
+# doc is a TOMLDocument instance that holds all the information
+# about the TOML string.
+# It behaves like a standard dictionary.
+
+>>> assert doc["table"]["foo"] == "bar"
+
+# The string generated from the document is exactly the same
+# as the original string
+>>> assert dumps(doc) == content
+```
+
+### Modifying
+
+TOML Kit provides an intuitive API to modify TOML documents.
+
+```python
+>>> from tomlkit import dumps
+>>> from tomlkit import parse
+>>> from tomlkit import table
+
+>>> doc = parse("""[table]
+... foo = "bar"  # String
+... """)
+
+>>> doc["table"]["baz"] = 13
+
+>>> dumps(doc)
+"""[table]
+foo = "bar"  # String
+baz = 13
+"""
+
+# Add a new table
+>>> tab = table()
+>>> tab.add("array", [1, 2, 3])
+
+>>> doc["table2"] = tab
+
+>>> dumps(doc)
+"""[table]
+foo = "bar"  # String
+baz = 13
+
+[table2]
+array = [1, 2, 3]
+"""
+
+# Remove the newly added table
+>>> doc.remove("table2")
+# del doc["table2] is also possible
+```
+
+### Writing
+
+You can also write a new TOML document from scratch.
+
+Let's say we want to create this following document:
+
+```toml
+# This is a TOML document.
+
+title = "TOML Example"
+
+[owner]
+name = "Tom Preston-Werner"
+organization = "GitHub"
+bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
+dob = 1979-05-27T07:32:00Z # First class dates? Why not?
+
+[database]
+server = "192.168.1.1"
+ports = [ 8001, 8001, 8002 ]
+connection_max = 5000
+enabled = true
+```
+
+It can be created with the following code:
+
+```python
+>>> from tomlkit import comment
+>>> from tomlkit import document
+>>> from tomlkit import nl
+>>> from tomlkit import table
+
+>>> doc = document()
+>>> doc.add(comment("This is a TOML document."))
+>>> doc.add(nl())
+>>> doc.add("title", "TOML Example")
+# Using doc["title"] = "TOML Example" is also possible
+
+>>> owner = table()
+>>> owner.add("name", "Tom Preston-Werner")
+>>> owner.add("organization", "GitHub")
+>>> owner.add("bio", "GitHub Cofounder & CEO\nLikes tater tots and beer.")
+>>> owner.add("dob", datetime(1979, 5, 27, 7, 32, tzinfo=utc))
+>>> owner["dob"].comment("First class dates? Why not?")
+
+# Adding the table to the document
+>>> doc.add("owner", owner)
+
+>>> database = table()
+>>> database["server"] = "192.168.1.1"
+>>> database["ports"] = [8001, 8001, 8002]
+>>> database["connection_max"] = 5000
+>>> database["enabled"] = True
+
+>>> doc["database"] = database
+```
+
+
+## Installation
+
+If you are using [Poetry](https://poetry.eustace.io),
+add `tomlkit` to your `pyproject.toml` file by using:
+
+```bash
+poetry add tomlkit
+```
+
+If not, you can use `pip`:
+
+```bash
+pip install tomlkit
+```
+
diff --git a/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/RECORD b/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/RECORD
new file mode 100644
index 0000000..965f415
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/RECORD
@@ -0,0 +1,18 @@
+tomlkit/__init__.py,sha256=Q34PrcfFmJEYgrIJ3ltnMMOgpooPA67Pz5YAJlc8nmE,542
+tomlkit/_compat.py,sha256=g5oYYg3IZl0VepXovYUp8fEPO0wjfsy-LmQY4EiFftw,5554
+tomlkit/_utils.py,sha256=dX55H7Z4A-XUEWDADtwvj9egoPBq2ofK_QM5CRO2Sl4,3636
+tomlkit/api.py,sha256=YV3PqDymFeyoraW14BI6Sb1YJBjIv3qxNj1eKxzx8aQ,3122
+tomlkit/container.py,sha256=LG_R9s1je2y02OFFkSzf4-Ck_HOt1Jd0ou5aDiIkyYk,24781
+tomlkit/exceptions.py,sha256=1EfnIKkKrhzVSi0tLUDGPM1ZUv-zCCN13RSnbmewHN0,5760
+tomlkit/items.py,sha256=2X_if1cwxBpGa-g7NIWJ2SXWgD6XZ899dTprvoMXwJ8,33549
+tomlkit/parser.py,sha256=TByRtCvgYGqzIE7BOpRuV_aIhozBuOY2bKkxe52cXRk,42161
+tomlkit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tomlkit/source.py,sha256=T9Vd9M3VgyEY_AFP_qTB-XL85uxLAYrrTJobbxaMViU,5445
+tomlkit/toml_char.py,sha256=K3V8WAZwEFfuHV5mkObo3rH7soanRI07xqtkhQJ0Cfo,1700
+tomlkit/toml_document.py,sha256=B2A2p9Cr8W9otF4clE6KxlGdcxCCnJLlZ0MgUHBieOI,103
+tomlkit/toml_file.py,sha256=ak7wyn-rd2N7_nfAxVFHbNdEzuVvipcjr3t49pw257A,573
+tomlkit-0.7.2.dist-info/LICENSE,sha256=8vm0YLpxnaZiat0mTTeC8nWk_3qrZ3vtoIszCRHiOts,1062
+tomlkit-0.7.2.dist-info/WHEEL,sha256=Tf_JTHRUsYmRccQnQfn1tqmNatmXkNB0OFKM-B4YyuA,87
+tomlkit-0.7.2.dist-info/METADATA,sha256=HUaerXYemQl4oNbxadXMn1C_g4iMYhAr8WGmWc_NubI,8477
+tomlkit-0.7.2.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+tomlkit-0.7.2.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/WHEEL
new file mode 100644
index 0000000..5397c48
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit-0.7.2.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry 1.0.3
+Root-Is-Purelib: true
+Tag: py2.py3-none-any
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/__init__.py b/myenv/lib/python3.9/site-packages/tomlkit/__init__.py
new file mode 100644
index 0000000..110d6c1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/__init__.py
@@ -0,0 +1,25 @@
+from .api import aot
+from .api import array
+from .api import boolean
+from .api import comment
+from .api import date
+from .api import datetime
+from .api import document
+from .api import dumps
+from .api import float_
+from .api import inline_table
+from .api import integer
+from .api import item
+from .api import key
+from .api import key_value
+from .api import loads
+from .api import nl
+from .api import parse
+from .api import string
+from .api import table
+from .api import time
+from .api import value
+from .api import ws
+
+
+__version__ = "0.7.2"
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/_compat.py b/myenv/lib/python3.9/site-packages/tomlkit/_compat.py
new file mode 100644
index 0000000..487ed99
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/_compat.py
@@ -0,0 +1,179 @@
+import re
+import sys
+
+
+try:
+    from datetime import timezone
+except ImportError:
+    from datetime import datetime
+    from datetime import timedelta
+    from datetime import tzinfo
+
+    class timezone(tzinfo):
+        __slots__ = "_offset", "_name"
+
+        # Sentinel value to disallow None
+        _Omitted = object()
+
+        def __new__(cls, offset, name=_Omitted):
+            if not isinstance(offset, timedelta):
+                raise TypeError("offset must be a timedelta")
+            if name is cls._Omitted:
+                if not offset:
+                    return cls.utc
+                name = None
+            elif not isinstance(name, str):
+                raise TypeError("name must be a string")
+            if not cls._minoffset <= offset <= cls._maxoffset:
+                raise ValueError(
+                    "offset must be a timedelta "
+                    "strictly between -timedelta(hours=24) and "
+                    "timedelta(hours=24)."
+                )
+            return cls._create(offset, name)
+
+        @classmethod
+        def _create(cls, offset, name=None):
+            self = tzinfo.__new__(cls)
+            self._offset = offset
+            self._name = name
+            return self
+
+        def __getinitargs__(self):
+            """pickle support"""
+            if self._name is None:
+                return (self._offset,)
+            return (self._offset, self._name)
+
+        def __eq__(self, other):
+            if type(other) != timezone:
+                return False
+            return self._offset == other._offset
+
+        def __hash__(self):
+            return hash(self._offset)
+
+        def __repr__(self):
+            """Convert to formal string, for repr().
+
+            >>> tz = timezone.utc
+            >>> repr(tz)
+            'datetime.timezone.utc'
+            >>> tz = timezone(timedelta(hours=-5), 'EST')
+            >>> repr(tz)
+            "datetime.timezone(datetime.timedelta(-1, 68400), 'EST')"
+            """
+            if self is self.utc:
+                return "datetime.timezone.utc"
+            if self._name is None:
+                return "%s.%s(%r)" % (
+                    self.__class__.__module__,
+                    self.__class__.__name__,
+                    self._offset,
+                )
+            return "%s.%s(%r, %r)" % (
+                self.__class__.__module__,
+                self.__class__.__name__,
+                self._offset,
+                self._name,
+            )
+
+        def __str__(self):
+            return self.tzname(None)
+
+        def utcoffset(self, dt):
+            if isinstance(dt, datetime) or dt is None:
+                return self._offset
+            raise TypeError(
+                "utcoffset() argument must be a datetime instance" " or None"
+            )
+
+        def tzname(self, dt):
+            if isinstance(dt, datetime) or dt is None:
+                if self._name is None:
+                    return self._name_from_offset(self._offset)
+                return self._name
+            raise TypeError("tzname() argument must be a datetime instance" " or None")
+
+        def dst(self, dt):
+            if isinstance(dt, datetime) or dt is None:
+                return None
+            raise TypeError("dst() argument must be a datetime instance" " or None")
+
+        def fromutc(self, dt):
+            if isinstance(dt, datetime):
+                if dt.tzinfo is not self:
+                    raise ValueError("fromutc: dt.tzinfo " "is not self")
+                return dt + self._offset
+            raise TypeError("fromutc() argument must be a datetime instance" " or None")
+
+        _maxoffset = timedelta(hours=23, minutes=59)
+        _minoffset = -_maxoffset
+
+        @staticmethod
+        def _name_from_offset(delta):
+            if not delta:
+                return "UTC"
+            if delta < timedelta(0):
+                sign = "-"
+                delta = -delta
+            else:
+                sign = "+"
+            hours, rest = divmod(delta, timedelta(hours=1))
+            minutes, rest = divmod(rest, timedelta(minutes=1))
+            seconds = rest.seconds
+            microseconds = rest.microseconds
+            if microseconds:
+                return ("UTC{}{:02d}:{:02d}:{:02d}.{:06d}").format(
+                    sign, hours, minutes, seconds, microseconds
+                )
+            if seconds:
+                return "UTC{}{:02d}:{:02d}:{:02d}".format(sign, hours, minutes, seconds)
+            return "UTC{}{:02d}:{:02d}".format(sign, hours, minutes)
+
+    timezone.utc = timezone._create(timedelta(0))
+    timezone.min = timezone._create(timezone._minoffset)
+    timezone.max = timezone._create(timezone._maxoffset)
+
+
+PY2 = sys.version_info[0] == 2
+PY36 = sys.version_info >= (3, 6)
+PY38 = sys.version_info >= (3, 8)
+
+if PY2:
+    unicode = unicode
+    chr = unichr
+    long = long
+else:
+    unicode = str
+    chr = chr
+    long = int
+
+
+if PY36:
+    OrderedDict = dict
+else:
+    from collections import OrderedDict
+
+try:
+    from collections.abc import MutableMapping
+except ImportError:
+    from collections import MutableMapping
+
+
+def decode(string, encodings=None):
+    if not PY2 and not isinstance(string, bytes):
+        return string
+
+    if PY2 and isinstance(string, unicode):
+        return string
+
+    encodings = encodings or ["utf-8", "latin1", "ascii"]
+
+    for encoding in encodings:
+        try:
+            return string.decode(encoding)
+        except (UnicodeEncodeError, UnicodeDecodeError):
+            pass
+
+    return string.decode(encodings[0], errors="ignore")
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/_utils.py b/myenv/lib/python3.9/site-packages/tomlkit/_utils.py
new file mode 100644
index 0000000..2ae3e42
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/_utils.py
@@ -0,0 +1,144 @@
+import re
+
+from datetime import date
+from datetime import datetime
+from datetime import time
+from datetime import timedelta
+from typing import Union
+
+from ._compat import decode
+from ._compat import timezone
+
+
+try:
+    from collections.abc import Mapping
+except ImportError:
+    from collections import Mapping
+
+
+RFC_3339_LOOSE = re.compile(
+    "^"
+    r"(([0-9]+)-(\d{2})-(\d{2}))?"  # Date
+    "("
+    "([T ])?"  # Separator
+    r"(\d{2}):(\d{2}):(\d{2})(\.([0-9]+))?"  # Time
+    r"((Z)|([\+|\-]([01][0-9]|2[0-3]):([0-5][0-9])))?"  # Timezone
+    ")?"
+    "$"
+)
+
+RFC_3339_DATETIME = re.compile(
+    "^"
+    "([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])"  # Date
+    "[T ]"  # Separator
+    r"([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.([0-9]+))?"  # Time
+    r"((Z)|([\+|\-]([01][0-9]|2[0-3]):([0-5][0-9])))?"  # Timezone
+    "$"
+)
+
+RFC_3339_DATE = re.compile("^([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$")
+
+RFC_3339_TIME = re.compile(
+    r"^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.([0-9]+))?$"
+)
+
+_utc = timezone(timedelta(), "UTC")
+
+
+def parse_rfc3339(string):  # type: (str) -> Union[datetime, date, time]
+    m = RFC_3339_DATETIME.match(string)
+    if m:
+        year = int(m.group(1))
+        month = int(m.group(2))
+        day = int(m.group(3))
+        hour = int(m.group(4))
+        minute = int(m.group(5))
+        second = int(m.group(6))
+        microsecond = 0
+
+        if m.group(7):
+            microsecond = int(("{:<06s}".format(m.group(8)))[:6])
+
+        if m.group(9):
+            # Timezone
+            tz = m.group(9)
+            if tz == "Z":
+                tzinfo = _utc
+            else:
+                sign = m.group(11)[0]
+                hour_offset, minute_offset = int(m.group(12)), int(m.group(13))
+                offset = timedelta(seconds=hour_offset * 3600 + minute_offset * 60)
+                if sign == "-":
+                    offset = -offset
+
+                tzinfo = timezone(
+                    offset, "{}{}:{}".format(sign, m.group(12), m.group(13))
+                )
+
+            return datetime(
+                year, month, day, hour, minute, second, microsecond, tzinfo=tzinfo
+            )
+        else:
+            return datetime(year, month, day, hour, minute, second, microsecond)
+
+    m = RFC_3339_DATE.match(string)
+    if m:
+        year = int(m.group(1))
+        month = int(m.group(2))
+        day = int(m.group(3))
+
+        return date(year, month, day)
+
+    m = RFC_3339_TIME.match(string)
+    if m:
+        hour = int(m.group(1))
+        minute = int(m.group(2))
+        second = int(m.group(3))
+        microsecond = 0
+
+        if m.group(4):
+            microsecond = int(("{:<06s}".format(m.group(5)))[:6])
+
+        return time(hour, minute, second, microsecond)
+
+    raise ValueError("Invalid RFC 339 string")
+
+
+_escaped = {"b": "\b", "t": "\t", "n": "\n", "f": "\f", "r": "\r", '"': '"', "\\": "\\"}
+_escapes = {v: k for k, v in _escaped.items()}
+
+
+def escape_string(s):
+    s = decode(s)
+
+    res = []
+    start = 0
+
+    def flush():
+        if start != i:
+            res.append(s[start:i])
+
+        return i + 1
+
+    i = 0
+    while i < len(s):
+        c = s[i]
+        if c in '"\\\n\r\t\b\f':
+            start = flush()
+            res.append("\\" + _escapes[c])
+        elif ord(c) < 0x20:
+            start = flush()
+            res.append("\\u%04x" % ord(c))
+        i += 1
+
+    flush()
+
+    return "".join(res)
+
+
+def merge_dicts(d1, d2):
+    for k, v in d2.items():
+        if k in d1 and isinstance(d1[k], dict) and isinstance(d2[k], Mapping):
+            merge_dicts(d1[k], d2[k])
+        else:
+            d1[k] = d2[k]
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/api.py b/myenv/lib/python3.9/site-packages/tomlkit/api.py
new file mode 100644
index 0000000..3de4121
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/api.py
@@ -0,0 +1,142 @@
+import datetime as _datetime
+
+from typing import Tuple
+
+from ._utils import parse_rfc3339
+from .container import Container
+from .items import AoT
+from .items import Array
+from .items import Bool
+from .items import Comment
+from .items import Date
+from .items import DateTime
+from .items import Float
+from .items import InlineTable
+from .items import Integer
+from .items import Item as _Item
+from .items import Key
+from .items import String
+from .items import Table
+from .items import Time
+from .items import Trivia
+from .items import Whitespace
+from .items import item
+from .parser import Parser
+from .toml_document import TOMLDocument as _TOMLDocument
+
+
+def loads(string):  # type: (str) -> _TOMLDocument
+    """
+    Parses a string into a TOMLDocument.
+
+    Alias for parse().
+    """
+    return parse(string)
+
+
+def dumps(data, sort_keys=False):  # type: (_TOMLDocument, bool) -> str
+    """
+    Dumps a TOMLDocument into a string.
+    """
+    if not isinstance(data, _TOMLDocument) and isinstance(data, dict):
+        data = item(data, _sort_keys=sort_keys)
+
+    return data.as_string()
+
+
+def parse(string):  # type: (str) -> _TOMLDocument
+    """
+    Parses a string into a TOMLDocument.
+    """
+    return Parser(string).parse()
+
+
+def document():  # type: () -> _TOMLDocument
+    """
+    Returns a new TOMLDocument instance.
+    """
+    return _TOMLDocument()
+
+
+# Items
+def integer(raw):  # type: (str) -> Integer
+    return item(int(raw))
+
+
+def float_(raw):  # type: (str) -> Float
+    return item(float(raw))
+
+
+def boolean(raw):  # type: (str) -> Bool
+    return item(raw == "true")
+
+
+def string(raw):  # type: (str) -> String
+    return item(raw)
+
+
+def date(raw):  # type: (str) -> Date
+    value = parse_rfc3339(raw)
+    if not isinstance(value, _datetime.date):
+        raise ValueError("date() only accepts date strings.")
+
+    return item(value)
+
+
+def time(raw):  # type: (str) -> Time
+    value = parse_rfc3339(raw)
+    if not isinstance(value, _datetime.time):
+        raise ValueError("time() only accepts time strings.")
+
+    return item(value)
+
+
+def datetime(raw):  # type: (str) -> DateTime
+    value = parse_rfc3339(raw)
+    if not isinstance(value, _datetime.datetime):
+        raise ValueError("datetime() only accepts datetime strings.")
+
+    return item(value)
+
+
+def array(raw=None):  # type: (str) -> Array
+    if raw is None:
+        raw = "[]"
+
+    return value(raw)
+
+
+def table():  # type: () -> Table
+    return Table(Container(), Trivia(), False)
+
+
+def inline_table():  # type: () -> InlineTable
+    return InlineTable(Container(), Trivia(), new=True)
+
+
+def aot():  # type: () -> AoT
+    return AoT([])
+
+
+def key(k):  # type: (str) -> Key
+    return Key(k)
+
+
+def value(raw):  # type: (str) -> _Item
+    return Parser(raw)._parse_value()
+
+
+def key_value(src):  # type: (str) -> Tuple[Key, _Item]
+    return Parser(src)._parse_key_value()
+
+
+def ws(src):  # type: (str) -> Whitespace
+    return Whitespace(src, fixed=True)
+
+
+def nl():  # type: () -> Whitespace
+    return ws("\n")
+
+
+def comment(string):  # type: (str) -> Comment
+    return Comment(Trivia(comment_ws="  ", comment="# " + string))
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/container.py b/myenv/lib/python3.9/site-packages/tomlkit/container.py
new file mode 100644
index 0000000..e097636
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/container.py
@@ -0,0 +1,791 @@
+from __future__ import unicode_literals
+
+import copy
+
+from typing import Any
+from typing import Dict
+from typing import Generator
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+from ._compat import MutableMapping
+from ._compat import decode
+from ._utils import merge_dicts
+from .exceptions import KeyAlreadyPresent
+from .exceptions import NonExistentKey
+from .exceptions import ParseError
+from .exceptions import TOMLKitError
+from .items import AoT
+from .items import Comment
+from .items import Item
+from .items import Key
+from .items import Null
+from .items import Table
+from .items import Whitespace
+from .items import item as _item
+
+
+_NOT_SET = object()
+
+
+class Container(MutableMapping, dict):
+    """
+    A container for items within a TOMLDocument.
+    """
+
+    def __init__(self, parsed=False):  # type: (bool) -> None
+        self._map = {}  # type: Dict[Key, int]
+        self._body = []  # type: List[Tuple[Optional[Key], Item]]
+        self._parsed = parsed
+        self._table_keys = []
+
+    @property
+    def body(self):  # type: () -> List[Tuple[Optional[Key], Item]]
+        return self._body
+
+    @property
+    def value(self):  # type: () -> Dict[Any, Any]
+        d = {}
+        for k, v in self._body:
+            if k is None:
+                continue
+
+            k = k.key
+            v = v.value
+
+            if isinstance(v, Container):
+                v = v.value
+
+            if k in d:
+                merge_dicts(d[k], v)
+            else:
+                d[k] = v
+
+        return d
+
+    def parsing(self, parsing):  # type: (bool) -> None
+        self._parsed = parsing
+
+        for k, v in self._body:
+            if isinstance(v, Table):
+                v.value.parsing(parsing)
+            elif isinstance(v, AoT):
+                for t in v.body:
+                    t.value.parsing(parsing)
+
+    def add(
+        self, key, item=None
+    ):  # type: (Union[Key, Item, str], Optional[Item]) -> Container
+        """
+        Adds an item to the current Container.
+        """
+        if item is None:
+            if not isinstance(key, (Comment, Whitespace)):
+                raise ValueError(
+                    "Non comment/whitespace items must have an associated key"
+                )
+
+            key, item = None, key
+
+        return self.append(key, item)
+
+    def append(self, key, item):  # type: (Union[Key, str, None], Item) -> Container
+        if not isinstance(key, Key) and key is not None:
+            key = Key(key)
+
+        if not isinstance(item, Item):
+            item = _item(item)
+
+        if isinstance(item, (AoT, Table)) and item.name is None:
+            item.name = key.key
+
+        if (
+            isinstance(item, Table)
+            and self._body
+            and not self._parsed
+            and not item.trivia.indent
+        ):
+            item.trivia.indent = "\n"
+
+        if isinstance(item, AoT) and self._body and not self._parsed:
+            if item and "\n" not in item[0].trivia.indent:
+                item[0].trivia.indent = "\n" + item[0].trivia.indent
+
+        if key is not None and key in self:
+            current_idx = self._map[key]
+            if isinstance(current_idx, tuple):
+                current_body_element = self._body[current_idx[-1]]
+            else:
+                current_body_element = self._body[current_idx]
+
+            current = current_body_element[1]
+
+            if isinstance(item, Table):
+                if not isinstance(current, (Table, AoT)):
+                    raise KeyAlreadyPresent(key)
+
+                if item.is_aot_element():
+                    # New AoT element found later on
+                    # Adding it to the current AoT
+                    if not isinstance(current, AoT):
+                        current = AoT([current, item], parsed=self._parsed)
+
+                        self._replace(key, key, current)
+                    else:
+                        current.append(item)
+
+                    return self
+                elif current.is_aot():
+                    if not item.is_aot_element():
+                        # Tried to define a table after an AoT with the same name.
+                        raise KeyAlreadyPresent(key)
+
+                    current.append(item)
+
+                    return self
+                elif current.is_super_table():
+                    if item.is_super_table():
+                        # We need to merge both super tables
+                        if (
+                            self._table_keys[-1] != current_body_element[0]
+                            or key.is_dotted()
+                            or current_body_element[0].is_dotted()
+                        ):
+                            if not isinstance(current_idx, tuple):
+                                current_idx = (current_idx,)
+
+                            self._map[key] = current_idx + (len(self._body),)
+                            self._body.append((key, item))
+                            self._table_keys.append(key)
+
+                            # Building a temporary proxy to check for errors
+                            OutOfOrderTableProxy(self, self._map[key])
+
+                            return self
+
+                        for k, v in item.value.body:
+                            current.append(k, v)
+
+                        return self
+                    elif current_body_element[0].is_dotted():
+                        raise TOMLKitError("Redefinition of an existing table")
+                elif not item.is_super_table():
+                    raise KeyAlreadyPresent(key)
+            elif isinstance(item, AoT):
+                if not isinstance(current, AoT):
+                    # Tried to define an AoT after a table with the same name.
+                    raise KeyAlreadyPresent(key)
+
+                for table in item.body:
+                    current.append(table)
+
+                return self
+            else:
+                raise KeyAlreadyPresent(key)
+
+        is_table = isinstance(item, (Table, AoT))
+        if key is not None and self._body and not self._parsed:
+            # If there is already at least one table in the current container
+            # and the given item is not a table, we need to find the last
+            # item that is not a table and insert after it
+            # If no such item exists, insert at the top of the table
+            key_after = None
+            idx = 0
+            for k, v in self._body:
+                if isinstance(v, Null):
+                    # This happens only after deletion
+                    continue
+
+                if isinstance(v, Whitespace) and not v.is_fixed():
+                    continue
+
+                if not is_table and isinstance(v, (Table, AoT)):
+                    break
+
+                key_after = k or idx
+                idx += 1
+
+            if key_after is not None:
+                if isinstance(key_after, int):
+                    if key_after + 1 < len(self._body):
+                        return self._insert_at(key_after + 1, key, item)
+                    else:
+                        previous_item = self._body[-1][1]
+                        if (
+                            not isinstance(previous_item, Whitespace)
+                            and not is_table
+                            and "\n" not in previous_item.trivia.trail
+                        ):
+                            previous_item.trivia.trail += "\n"
+                else:
+                    return self._insert_after(key_after, key, item)
+            else:
+                return self._insert_at(0, key, item)
+
+        if key in self._map:
+            current_idx = self._map[key]
+            if isinstance(current_idx, tuple):
+                current_idx = current_idx[-1]
+
+            current = self._body[current_idx][1]
+            if key is not None and not isinstance(current, Table):
+                raise KeyAlreadyPresent(key)
+
+            # Adding sub tables to a currently existing table
+            if not isinstance(current_idx, tuple):
+                current_idx = (current_idx,)
+
+            self._map[key] = current_idx + (len(self._body),)
+        else:
+            self._map[key] = len(self._body)
+
+        self._body.append((key, item))
+        if item.is_table():
+            self._table_keys.append(key)
+
+        if key is not None:
+            dict.__setitem__(self, key.key, item.value)
+
+        return self
+
+    def remove(self, key):  # type: (Union[Key, str]) -> Container
+        if not isinstance(key, Key):
+            key = Key(key)
+
+        idx = self._map.pop(key, None)
+        if idx is None:
+            raise NonExistentKey(key)
+
+        if isinstance(idx, tuple):
+            for i in idx:
+                self._body[i] = (None, Null())
+        else:
+            self._body[idx] = (None, Null())
+
+        dict.__delitem__(self, key.key)
+
+        return self
+
+    def _insert_after(
+        self, key, other_key, item
+    ):  # type: (Union[str, Key], Union[str, Key], Union[Item, Any]) -> Container
+        if key is None:
+            raise ValueError("Key cannot be null in insert_after()")
+
+        if key not in self:
+            raise NonExistentKey(key)
+
+        if not isinstance(key, Key):
+            key = Key(key)
+
+        if not isinstance(other_key, Key):
+            other_key = Key(other_key)
+
+        item = _item(item)
+
+        idx = self._map[key]
+        # Insert after the max index if there are many.
+        if isinstance(idx, tuple):
+            idx = max(idx)
+        current_item = self._body[idx][1]
+        if "\n" not in current_item.trivia.trail:
+            current_item.trivia.trail += "\n"
+
+        # Increment indices after the current index
+        for k, v in self._map.items():
+            if isinstance(v, tuple):
+                new_indices = []
+                for v_ in v:
+                    if v_ > idx:
+                        v_ = v_ + 1
+
+                    new_indices.append(v_)
+
+                self._map[k] = tuple(new_indices)
+            elif v > idx:
+                self._map[k] = v + 1
+
+        self._map[other_key] = idx + 1
+        self._body.insert(idx + 1, (other_key, item))
+
+        if key is not None:
+            dict.__setitem__(self, other_key.key, item.value)
+
+        return self
+
+    def _insert_at(
+        self, idx, key, item
+    ):  # type: (int, Union[str, Key], Union[Item, Any]) -> Container
+        if idx > len(self._body) - 1:
+            raise ValueError("Unable to insert at position {}".format(idx))
+
+        if not isinstance(key, Key):
+            key = Key(key)
+
+        item = _item(item)
+
+        if idx > 0:
+            previous_item = self._body[idx - 1][1]
+            if (
+                not isinstance(previous_item, Whitespace)
+                and not isinstance(item, (AoT, Table))
+                and "\n" not in previous_item.trivia.trail
+            ):
+                previous_item.trivia.trail += "\n"
+
+        # Increment indices after the current index
+        for k, v in self._map.items():
+            if isinstance(v, tuple):
+                new_indices = []
+                for v_ in v:
+                    if v_ >= idx:
+                        v_ = v_ + 1
+
+                    new_indices.append(v_)
+
+                self._map[k] = tuple(new_indices)
+            elif v >= idx:
+                self._map[k] = v + 1
+
+        self._map[key] = idx
+        self._body.insert(idx, (key, item))
+
+        if key is not None:
+            dict.__setitem__(self, key.key, item.value)
+
+        return self
+
+    def item(self, key):  # type: (Union[Key, str]) -> Item
+        if not isinstance(key, Key):
+            key = Key(key)
+
+        idx = self._map.get(key, None)
+        if idx is None:
+            raise NonExistentKey(key)
+
+        if isinstance(idx, tuple):
+            # The item we are getting is an out of order table
+            # so we need a proxy to retrieve the proper objects
+            # from the parent container
+            return OutOfOrderTableProxy(self, idx)
+
+        return self._body[idx][1]
+
+    def last_item(self):  # type: () -> Optional[Item]
+        if self._body:
+            return self._body[-1][1]
+
+    def as_string(self):  # type: () -> str
+        s = ""
+        for k, v in self._body:
+            if k is not None:
+                if isinstance(v, Table):
+                    s += self._render_table(k, v)
+                elif isinstance(v, AoT):
+                    s += self._render_aot(k, v)
+                else:
+                    s += self._render_simple_item(k, v)
+            else:
+                s += self._render_simple_item(k, v)
+
+        return s
+
+    def _render_table(
+        self, key, table, prefix=None
+    ):  # (Key, Table, Optional[str]) -> str
+        cur = ""
+
+        if table.display_name is not None:
+            _key = table.display_name
+        else:
+            _key = key.as_string()
+
+            if prefix is not None:
+                _key = prefix + "." + _key
+
+        if not table.is_super_table() or (
+            any(
+                not isinstance(v, (Table, AoT, Whitespace)) for _, v in table.value.body
+            )
+            and not key.is_dotted()
+        ):
+            open_, close = "[", "]"
+            if table.is_aot_element():
+                open_, close = "[[", "]]"
+
+            cur += "{}{}{}{}{}{}{}{}".format(
+                table.trivia.indent,
+                open_,
+                decode(_key),
+                close,
+                table.trivia.comment_ws,
+                decode(table.trivia.comment),
+                table.trivia.trail,
+                "\n" if "\n" not in table.trivia.trail and len(table.value) > 0 else "",
+            )
+
+        for k, v in table.value.body:
+            if isinstance(v, Table):
+                if v.is_super_table():
+                    if k.is_dotted() and not key.is_dotted():
+                        # Dotted key inside table
+                        cur += self._render_table(k, v)
+                    else:
+                        cur += self._render_table(k, v, prefix=_key)
+                else:
+                    cur += self._render_table(k, v, prefix=_key)
+            elif isinstance(v, AoT):
+                cur += self._render_aot(k, v, prefix=_key)
+            else:
+                cur += self._render_simple_item(
+                    k, v, prefix=_key if key.is_dotted() else None
+                )
+
+        return cur
+
+    def _render_aot(self, key, aot, prefix=None):
+        _key = key.as_string()
+        if prefix is not None:
+            _key = prefix + "." + _key
+
+        cur = ""
+        _key = decode(_key)
+        for table in aot.body:
+            cur += self._render_aot_table(table, prefix=_key)
+
+        return cur
+
+    def _render_aot_table(self, table, prefix=None):  # (Table, Optional[str]) -> str
+        cur = ""
+
+        _key = prefix or ""
+
+        if not table.is_super_table():
+            open_, close = "[[", "]]"
+
+            cur += "{}{}{}{}{}{}{}".format(
+                table.trivia.indent,
+                open_,
+                decode(_key),
+                close,
+                table.trivia.comment_ws,
+                decode(table.trivia.comment),
+                table.trivia.trail,
+            )
+
+        for k, v in table.value.body:
+            if isinstance(v, Table):
+                if v.is_super_table():
+                    if k.is_dotted():
+                        # Dotted key inside table
+                        cur += self._render_table(k, v)
+                    else:
+                        cur += self._render_table(k, v, prefix=_key)
+                else:
+                    cur += self._render_table(k, v, prefix=_key)
+            elif isinstance(v, AoT):
+                cur += self._render_aot(k, v, prefix=_key)
+            else:
+                cur += self._render_simple_item(k, v)
+
+        return cur
+
+    def _render_simple_item(self, key, item, prefix=None):
+        if key is None:
+            return item.as_string()
+
+        _key = key.as_string()
+        if prefix is not None:
+            _key = prefix + "." + _key
+
+        return "{}{}{}{}{}{}{}".format(
+            item.trivia.indent,
+            decode(_key),
+            key.sep,
+            decode(item.as_string()),
+            item.trivia.comment_ws,
+            decode(item.trivia.comment),
+            item.trivia.trail,
+        )
+
+    # Dictionary methods
+
+    def pop(self, key, default=_NOT_SET):
+        try:
+            value = self[key]
+        except KeyError:
+            if default is _NOT_SET:
+                raise
+
+            return default
+
+        del self[key]
+
+        return value
+
+    def setdefault(
+        self, key, default=None
+    ):  # type: (Union[Key, str], Any) -> Union[Item, Container]
+        super(Container, self).setdefault(key, default=default)
+
+        return self[key]
+
+    def __contains__(self, key):  # type: (Union[Key, str]) -> bool
+        if not isinstance(key, Key):
+            key = Key(key)
+
+        return key in self._map
+
+    def __setitem__(self, key, value):  # type: (Union[Key, str], Any) -> None
+        if key is not None and key in self:
+            self._replace(key, key, value)
+        else:
+            self.append(key, value)
+
+    def __getitem__(self, key):  # type: (Union[Key, str]) -> Union[Item, Container]
+        if not isinstance(key, Key):
+            key = Key(key)
+
+        idx = self._map.get(key, None)
+        if idx is None:
+            raise NonExistentKey(key)
+
+        if isinstance(idx, tuple):
+            # The item we are getting is an out of order table
+            # so we need a proxy to retrieve the proper objects
+            # from the parent container
+            return OutOfOrderTableProxy(self, idx)
+
+        item = self._body[idx][1]
+        if item.is_boolean():
+            return item.value
+
+        return item
+
+    def __setitem__(self, key, value):  # type: (Union[Key, str], Any) -> None
+        if key is not None and key in self:
+            self._replace(key, key, value)
+        else:
+            self.append(key, value)
+
+    def __delitem__(self, key):  # type: (Union[Key, str]) -> None
+        self.remove(key)
+
+    def __len__(self):  # type: () -> int
+        return dict.__len__(self)
+
+    def __iter__(self):  # type: () -> Iterator[str]
+        return iter(dict.keys(self))
+
+    def _replace(
+        self, key, new_key, value
+    ):  # type: (Union[Key, str], Union[Key, str], Item) -> None
+        if not isinstance(key, Key):
+            key = Key(key)
+
+        if not isinstance(new_key, Key):
+            new_key = Key(new_key)
+
+        idx = self._map.get(key, None)
+        if idx is None:
+            raise NonExistentKey(key)
+
+        self._replace_at(idx, new_key, value)
+
+    def _replace_at(
+        self, idx, new_key, value
+    ):  # type: (Union[int, Tuple[int]], Union[Key, str], Item) -> None
+        if not isinstance(new_key, Key):
+            new_key = Key(new_key)
+
+        if isinstance(idx, tuple):
+            for i in idx[1:]:
+                self._body[i] = (None, Null())
+
+            idx = idx[0]
+
+        k, v = self._body[idx]
+
+        self._map[new_key] = self._map.pop(k)
+        if new_key != k:
+            dict.__delitem__(self, k)
+
+        if isinstance(self._map[new_key], tuple):
+            self._map[new_key] = self._map[new_key][0]
+
+        value = _item(value)
+
+        # Copying trivia
+        if not isinstance(value, (Whitespace, AoT)):
+            value.trivia.indent = v.trivia.indent
+            value.trivia.comment_ws = v.trivia.comment_ws
+            value.trivia.comment = v.trivia.comment
+            value.trivia.trail = v.trivia.trail
+
+        if isinstance(value, Table):
+            # Insert a cosmetic new line for tables
+            value.append(None, Whitespace("\n"))
+
+        self._body[idx] = (new_key, value)
+
+        dict.__setitem__(self, new_key.key, value.value)
+
+    def __str__(self):  # type: () -> str
+        return str(self.value)
+
+    def __repr__(self):  # type: () -> str
+        return repr(self.value)
+
+    def __eq__(self, other):  # type: (Dict) -> bool
+        if not isinstance(other, dict):
+            return NotImplemented
+
+        return self.value == other
+
+    def _getstate(self, protocol):
+        return (self._parsed,)
+
+    def __reduce__(self):
+        return self.__reduce_ex__(2)
+
+    def __reduce_ex__(self, protocol):
+        return (
+            self.__class__,
+            self._getstate(protocol),
+            (self._map, self._body, self._parsed, self._table_keys),
+        )
+
+    def __setstate__(self, state):
+        self._map = state[0]
+        self._body = state[1]
+        self._parsed = state[2]
+        self._table_keys = state[3]
+
+        for key, item in self._body:
+            if key is not None:
+                dict.__setitem__(self, key.key, item.value)
+
+    def copy(self):  # type: () -> Container
+        return copy.copy(self)
+
+    def __copy__(self):  # type: () -> Container
+        c = self.__class__(self._parsed)
+        for k, v in dict.items(self):
+            dict.__setitem__(c, k, v)
+
+        c._body += self.body
+        c._map.update(self._map)
+
+        return c
+
+
+class OutOfOrderTableProxy(MutableMapping, dict):
+    def __init__(self, container, indices):  # type: (Container, Tuple) -> None
+        self._container = container
+        self._internal_container = Container(self._container.parsing)
+        self._tables = []
+        self._tables_map = {}
+        self._map = {}
+
+        for i in indices:
+            key, item = self._container._body[i]
+
+            if isinstance(item, Table):
+                self._tables.append(item)
+                table_idx = len(self._tables) - 1
+                for k, v in item.value.body:
+                    self._internal_container.append(k, v)
+                    self._tables_map[k] = table_idx
+                    if k is not None:
+                        dict.__setitem__(self, k.key, v)
+            else:
+                self._internal_container.append(key, item)
+                self._map[key] = i
+                if key is not None:
+                    dict.__setitem__(self, key.key, item)
+
+    @property
+    def value(self):
+        return self._internal_container.value
+
+    def __getitem__(self, key):  # type: (Union[Key, str]) -> Any
+        if key not in self._internal_container:
+            raise NonExistentKey(key)
+
+        return self._internal_container[key]
+
+    def __setitem__(self, key, item):  # type: (Union[Key, str], Any) -> None
+        if key in self._map:
+            idx = self._map[key]
+            self._container._replace_at(idx, key, item)
+        elif key in self._tables_map:
+            table = self._tables[self._tables_map[key]]
+            table[key] = item
+        elif self._tables:
+            table = self._tables[0]
+            table[key] = item
+        else:
+            self._container[key] = item
+
+        if key is not None:
+            dict.__setitem__(self, key, item)
+
+    def __delitem__(self, key):  # type: (Union[Key, str]) -> None
+        if key in self._map:
+            idx = self._map[key]
+            del self._container[key]
+            del self._map[key]
+        elif key in self._tables_map:
+            table = self._tables[self._tables_map[key]]
+            del table[key]
+            del self._tables_map[key]
+        else:
+            raise NonExistentKey(key)
+
+        del self._internal_container[key]
+
+    def keys(self):
+        return self._internal_container.keys()
+
+    def values(self):
+        return self._internal_container.values()
+
+    def items(self):  # type: () -> Generator[Item]
+        return self._internal_container.items()
+
+    def update(self, other):  # type: (Dict) -> None
+        self._internal_container.update(other)
+
+    def get(self, key, default=None):  # type: (Any, Optional[Any]) -> Any
+        return self._internal_container.get(key, default=default)
+
+    def pop(self, key, default=_NOT_SET):
+        return self._internal_container.pop(key, default=default)
+
+    def setdefault(
+        self, key, default=None
+    ):  # type: (Union[Key, str], Any) -> Union[Item, Container]
+        return self._internal_container.setdefault(key, default=default)
+
+    def __contains__(self, key):
+        return key in self._internal_container
+
+    def __iter__(self):  # type: () -> Iterator[str]
+        return iter(self._internal_container)
+
+    def __str__(self):
+        return str(self._internal_container)
+
+    def __repr__(self):
+        return repr(self._internal_container)
+
+    def __eq__(self, other):  # type: (Dict) -> bool
+        if not isinstance(other, dict):
+            return NotImplemented
+
+        return self._internal_container == other
+
+    def __getattr__(self, attribute):
+        return getattr(self._internal_container, attribute)
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/exceptions.py b/myenv/lib/python3.9/site-packages/tomlkit/exceptions.py
new file mode 100644
index 0000000..d0c7ab5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/exceptions.py
@@ -0,0 +1,223 @@
+from __future__ import unicode_literals
+
+from typing import Optional
+
+
+class TOMLKitError(Exception):
+
+    pass
+
+
+class ParseError(ValueError, TOMLKitError):
+    """
+    This error occurs when the parser encounters a syntax error
+    in the TOML being parsed. The error references the line and
+    location within the line where the error was encountered.
+    """
+
+    def __init__(
+        self, line, col, message=None
+    ):  # type: (int, int, Optional[str]) -> None
+        self._line = line
+        self._col = col
+
+        if message is None:
+            message = "TOML parse error"
+
+        super(ParseError, self).__init__(
+            "{} at line {} col {}".format(message, self._line, self._col)
+        )
+
+    @property
+    def line(self):
+        return self._line
+
+    @property
+    def col(self):
+        return self._col
+
+
+class MixedArrayTypesError(ParseError):
+    """
+    An array was found that had two or more element types.
+    """
+
+    def __init__(self, line, col):  # type: (int, int) -> None
+        message = "Mixed types found in array"
+
+        super(MixedArrayTypesError, self).__init__(line, col, message=message)
+
+
+class InvalidNumberError(ParseError):
+    """
+    A numeric field was improperly specified.
+    """
+
+    def __init__(self, line, col):  # type: (int, int) -> None
+        message = "Invalid number"
+
+        super(InvalidNumberError, self).__init__(line, col, message=message)
+
+
+class InvalidDateTimeError(ParseError):
+    """
+    A datetime field was improperly specified.
+    """
+
+    def __init__(self, line, col):  # type: (int, int) -> None
+        message = "Invalid datetime"
+
+        super(InvalidDateTimeError, self).__init__(line, col, message=message)
+
+
+class InvalidDateError(ParseError):
+    """
+    A date field was improperly specified.
+    """
+
+    def __init__(self, line, col):  # type: (int, int) -> None
+        message = "Invalid date"
+
+        super(InvalidDateError, self).__init__(line, col, message=message)
+
+
+class InvalidTimeError(ParseError):
+    """
+    A date field was improperly specified.
+    """
+
+    def __init__(self, line, col):  # type: (int, int) -> None
+        message = "Invalid time"
+
+        super(InvalidTimeError, self).__init__(line, col, message=message)
+
+
+class InvalidNumberOrDateError(ParseError):
+    """
+    A numeric or date field was improperly specified.
+    """
+
+    def __init__(self, line, col):  # type: (int, int) -> None
+        message = "Invalid number or date format"
+
+        super(InvalidNumberOrDateError, self).__init__(line, col, message=message)
+
+
+class InvalidUnicodeValueError(ParseError):
+    """
+    A unicode code was improperly specified.
+    """
+
+    def __init__(self, line, col):  # type: (int, int) -> None
+        message = "Invalid unicode value"
+
+        super(InvalidUnicodeValueError, self).__init__(line, col, message=message)
+
+
+class UnexpectedCharError(ParseError):
+    """
+    An unexpected character was found during parsing.
+    """
+
+    def __init__(self, line, col, char):  # type: (int, int, str) -> None
+        message = "Unexpected character: {}".format(repr(char))
+
+        super(UnexpectedCharError, self).__init__(line, col, message=message)
+
+
+class EmptyKeyError(ParseError):
+    """
+    An empty key was found during parsing.
+    """
+
+    def __init__(self, line, col):  # type: (int, int) -> None
+        message = "Empty key"
+
+        super(EmptyKeyError, self).__init__(line, col, message=message)
+
+
+class EmptyTableNameError(ParseError):
+    """
+    An empty table name was found during parsing.
+    """
+
+    def __init__(self, line, col):  # type: (int, int) -> None
+        message = "Empty table name"
+
+        super(EmptyTableNameError, self).__init__(line, col, message=message)
+
+
+class InvalidCharInStringError(ParseError):
+    """
+    The string being parsed contains an invalid character.
+    """
+
+    def __init__(self, line, col, char):  # type: (int, int, str) -> None
+        message = "Invalid character {} in string".format(repr(char))
+
+        super(InvalidCharInStringError, self).__init__(line, col, message=message)
+
+
+class UnexpectedEofError(ParseError):
+    """
+    The TOML being parsed ended before the end of a statement.
+    """
+
+    def __init__(self, line, col):  # type: (int, int) -> None
+        message = "Unexpected end of file"
+
+        super(UnexpectedEofError, self).__init__(line, col, message=message)
+
+
+class InternalParserError(ParseError):
+    """
+    An error that indicates a bug in the parser.
+    """
+
+    def __init__(
+        self, line, col, message=None
+    ):  # type: (int, int, Optional[str]) -> None
+        msg = "Internal parser error"
+        if message:
+            msg += " ({})".format(message)
+
+        super(InternalParserError, self).__init__(line, col, message=msg)
+
+
+class NonExistentKey(KeyError, TOMLKitError):
+    """
+    A non-existent key was used.
+    """
+
+    def __init__(self, key):
+        message = 'Key "{}" does not exist.'.format(key)
+
+        super(NonExistentKey, self).__init__(message)
+
+
+class KeyAlreadyPresent(TOMLKitError):
+    """
+    An already present key was used.
+    """
+
+    def __init__(self, key):
+        message = 'Key "{}" already exists.'.format(key)
+
+        super(KeyAlreadyPresent, self).__init__(message)
+
+
+class InvalidControlChar(ParseError):
+    def __init__(self, line, col, char, type):  # type: (int, int, int, str) -> None
+        display_code = "\\u00"
+
+        if char < 16:
+            display_code += "0"
+
+        display_code += str(char)
+
+        message = (
+            "Control characters (codes less than 0x1f and 0x7f) are not allowed in {}, "
+            "use {} instead".format(type, display_code)
+        )
+
+        super(InvalidControlChar, self).__init__(line, col, message=message)
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/items.py b/myenv/lib/python3.9/site-packages/tomlkit/items.py
new file mode 100644
index 0000000..f738e0b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/items.py
@@ -0,0 +1,1331 @@
+from __future__ import unicode_literals
+
+import re
+import string
+
+from datetime import date
+from datetime import datetime
+from datetime import time
+from enum import Enum
+from typing import Any
+from typing import Dict
+from typing import Generator
+from typing import List
+from typing import Optional
+from typing import Union
+
+from ._compat import PY2
+from ._compat import PY38
+from ._compat import MutableMapping
+from ._compat import decode
+from ._compat import long
+from ._compat import unicode
+from ._utils import escape_string
+
+
+if PY2:
+    from functools32 import lru_cache
+else:
+    from functools import lru_cache
+
+
+def item(value, _parent=None, _sort_keys=False):
+    from .container import Container
+
+    if isinstance(value, Item):
+        return value
+
+    if isinstance(value, bool):
+        return Bool(value, Trivia())
+    elif isinstance(value, int):
+        return Integer(value, Trivia(), str(value))
+    elif isinstance(value, float):
+        return Float(value, Trivia(), str(value))
+    elif isinstance(value, dict):
+        val = Table(Container(), Trivia(), False)
+        for k, v in sorted(
+            value.items(),
+            key=lambda i: (isinstance(i[1], dict), i[0] if _sort_keys else 1),
+        ):
+            val[k] = item(v, _parent=val, _sort_keys=_sort_keys)
+
+        return val
+    elif isinstance(value, list):
+        if value and isinstance(value[0], dict):
+            a = AoT([])
+        else:
+            a = Array([], Trivia())
+
+        for v in value:
+            if isinstance(v, dict):
+                table = Table(Container(), Trivia(), True)
+
+                for k, _v in sorted(
+                    v.items(),
+                    key=lambda i: (isinstance(i[1], dict), i[0] if _sort_keys else 1),
+                ):
+                    i = item(_v, _sort_keys=_sort_keys)
+                    if isinstance(table, InlineTable):
+                        i.trivia.trail = ""
+
+                    table[k] = item(i, _sort_keys=_sort_keys)
+
+                v = table
+
+            a.append(v)
+
+        return a
+    elif isinstance(value, (str, unicode)):
+        escaped = escape_string(value)
+
+        return String(StringType.SLB, decode(value), escaped, Trivia())
+    elif isinstance(value, datetime):
+        return DateTime(
+            value.year,
+            value.month,
+            value.day,
+            value.hour,
+            value.minute,
+            value.second,
+            value.microsecond,
+            value.tzinfo,
+            Trivia(),
+            value.isoformat().replace("+00:00", "Z"),
+        )
+    elif isinstance(value, date):
+        return Date(value.year, value.month, value.day, Trivia(), value.isoformat())
+    elif isinstance(value, time):
+        return Time(
+            value.hour,
+            value.minute,
+            value.second,
+            value.microsecond,
+            value.tzinfo,
+            Trivia(),
+            value.isoformat(),
+        )
+
+    raise ValueError("Invalid type {}".format(type(value)))
+
+
+class StringType(Enum):
+    # Single Line Basic
+    SLB = '"'
+    # Multi Line Basic
+    MLB = '"""'
+    # Single Line Literal
+    SLL = "'"
+    # Multi Line Literal
+    MLL = "'''"
+
+    @property
+    @lru_cache(maxsize=None)
+    def unit(self):  # type: () -> str
+        return self.value[0]
+
+    @lru_cache(maxsize=None)
+    def is_basic(self):  # type: () -> bool
+        return self in {StringType.SLB, StringType.MLB}
+
+    @lru_cache(maxsize=None)
+    def is_literal(self):  # type: () -> bool
+        return self in {StringType.SLL, StringType.MLL}
+
+    @lru_cache(maxsize=None)
+    def is_singleline(self):  # type: () -> bool
+        return self in {StringType.SLB, StringType.SLL}
+
+    @lru_cache(maxsize=None)
+    def is_multiline(self):  # type: () -> bool
+        return self in {StringType.MLB, StringType.MLL}
+
+    @lru_cache(maxsize=None)
+    def toggle(self):  # type: () -> StringType
+        return {
+            StringType.SLB: StringType.MLB,
+            StringType.MLB: StringType.SLB,
+            StringType.SLL: StringType.MLL,
+            StringType.MLL: StringType.SLL,
+        }[self]
+
+
+class BoolType(Enum):
+    TRUE = "true"
+    FALSE = "false"
+
+    @lru_cache(maxsize=None)
+    def __bool__(self):
+        return {BoolType.TRUE: True, BoolType.FALSE: False}[self]
+
+    if PY2:
+        __nonzero__ = __bool__  # for PY2
+
+    def __iter__(self):
+        return iter(self.value)
+
+    def __len__(self):
+        return len(self.value)
+
+
+class Trivia:
+    """
+    Trivia information (aka metadata).
+    """
+
+    def __init__(
+        self, indent=None, comment_ws=None, comment=None, trail=None
+    ):  # type: (str, str, str, str) -> None
+        # Whitespace before a value.
+        self.indent = indent or ""
+        # Whitespace after a value, but before a comment.
+        self.comment_ws = comment_ws or ""
+        # Comment, starting with # character, or empty string if no comment.
+        self.comment = comment or ""
+        # Trailing newline.
+        if trail is None:
+            trail = "\n"
+
+        self.trail = trail
+
+
+class KeyType(Enum):
+    """
+    The type of a Key.
+
+    Keys can be bare (unquoted), or quoted using basic ("), or literal (')
+    quotes following the same escaping rules as single-line StringType.
+    """
+
+    Bare = ""
+    Basic = '"'
+    Literal = "'"
+
+
+class Key:
+    """
+    A key value.
+    """
+
+    def __init__(
+        self, k, t=None, sep=None, dotted=False, original=None
+    ):  # type: (str, Optional[KeyType], Optional[str], bool, Optional[str]) -> None
+        if t is None:
+            if any(
+                [c not in string.ascii_letters + string.digits + "-" + "_" for c in k]
+            ):
+                t = KeyType.Basic
+            else:
+                t = KeyType.Bare
+
+        self.t = t
+        if sep is None:
+            sep = " = "
+
+        self.sep = sep
+        self.key = k
+        if original is None:
+            original = k
+
+        self._original = original
+
+        self._dotted = dotted
+
+    @property
+    def delimiter(self):  # type: () -> str
+        return self.t.value
+
+    def is_dotted(self):  # type: () -> bool
+        return self._dotted
+
+    def is_bare(self):  # type: () -> bool
+        return self.t == KeyType.Bare
+
+    def as_string(self):  # type: () -> str
+        return "{}{}{}".format(self.delimiter, self._original, self.delimiter)
+
+    def __hash__(self):  # type: () -> int
+        return hash(self.key)
+
+    def __eq__(self, other):  # type: (Key) -> bool
+        if isinstance(other, Key):
+            return self.key == other.key
+
+        return self.key == other
+
+    def __str__(self):  # type: () -> str
+        return self.as_string()
+
+    def __repr__(self):  # type: () -> str
+        return "<Key {}>".format(self.as_string())
+
+
+class Item(object):
+    """
+    An item within a TOML document.
+    """
+
+    def __init__(self, trivia):  # type: (Trivia) -> None
+        self._trivia = trivia
+
+    @property
+    def trivia(self):  # type: () -> Trivia
+        return self._trivia
+
+    @property
+    def discriminant(self):  # type: () -> int
+        raise NotImplementedError()
+
+    def as_string(self):  # type: () -> str
+        raise NotImplementedError()
+
+    # Helpers
+
+    def comment(self, comment):  # type: (str) -> Item
+        if not comment.strip().startswith("#"):
+            comment = "# " + comment
+
+        self._trivia.comment_ws = " "
+        self._trivia.comment = comment
+
+        return self
+
+    def indent(self, indent):  # type: (int) -> Item
+        if self._trivia.indent.startswith("\n"):
+            self._trivia.indent = "\n" + " " * indent
+        else:
+            self._trivia.indent = " " * indent
+
+        return self
+
+    def is_boolean(self):  # type: () -> bool
+        return isinstance(self, Bool)
+
+    def is_table(self):  # type: () -> bool
+        return isinstance(self, Table)
+
+    def is_inline_table(self):  # type: () -> bool
+        return isinstance(self, InlineTable)
+
+    def is_aot(self):  # type: () -> bool
+        return isinstance(self, AoT)
+
+    def _getstate(self, protocol=3):
+        return (self._trivia,)
+
+    def __reduce__(self):
+        return self.__reduce_ex__(2)
+
+    def __reduce_ex__(self, protocol):
+        return self.__class__, self._getstate(protocol)
+
+
+class Whitespace(Item):
+    """
+    A whitespace literal.
+    """
+
+    def __init__(self, s, fixed=False):  # type: (str, bool) -> None
+        self._s = s
+        self._fixed = fixed
+
+    @property
+    def s(self):  # type: () -> str
+        return self._s
+
+    @property
+    def value(self):  # type: () -> str
+        return self._s
+
+    @property
+    def trivia(self):  # type: () -> Trivia
+        raise RuntimeError("Called trivia on a Whitespace variant.")
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 0
+
+    def is_fixed(self):  # type: () -> bool
+        return self._fixed
+
+    def as_string(self):  # type: () -> str
+        return self._s
+
+    def __repr__(self):  # type: () -> str
+        return "<{} {}>".format(self.__class__.__name__, repr(self._s))
+
+    def _getstate(self, protocol=3):
+        return self._s, self._fixed
+
+
+class Comment(Item):
+    """
+    A comment literal.
+    """
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 1
+
+    def as_string(self):  # type: () -> str
+        return "{}{}{}".format(
+            self._trivia.indent, decode(self._trivia.comment), self._trivia.trail
+        )
+
+    def __str__(self):  # type: () -> str
+        return "{}{}".format(self._trivia.indent, decode(self._trivia.comment))
+
+
+class Integer(long, Item):
+    """
+    An integer literal.
+    """
+
+    def __new__(cls, value, trivia, raw):  # type: (int, Trivia, str) -> Integer
+        return super(Integer, cls).__new__(cls, value)
+
+    def __init__(self, _, trivia, raw):  # type: (int, Trivia, str) -> None
+        super(Integer, self).__init__(trivia)
+
+        self._raw = raw
+        self._sign = False
+
+        if re.match(r"^[+\-]\d+$", raw):
+            self._sign = True
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 2
+
+    @property
+    def value(self):  # type: () -> int
+        return self
+
+    def as_string(self):  # type: () -> str
+        return self._raw
+
+    def __add__(self, other):
+        result = super(Integer, self).__add__(other)
+
+        return self._new(result)
+
+    def __radd__(self, other):
+        result = super(Integer, self).__radd__(other)
+
+        if isinstance(other, Integer):
+            return self._new(result)
+
+        return result
+
+    def __sub__(self, other):
+        result = super(Integer, self).__sub__(other)
+
+        return self._new(result)
+
+    def __rsub__(self, other):
+        result = super(Integer, self).__rsub__(other)
+
+        if isinstance(other, Integer):
+            return self._new(result)
+
+        return result
+
+    def _new(self, result):
+        raw = str(result)
+
+        if self._sign:
+            sign = "+" if result >= 0 else "-"
+            raw = sign + raw
+
+        return Integer(result, self._trivia, raw)
+
+    def _getstate(self, protocol=3):
+        return int(self), self._trivia, self._raw
+
+
+class Float(float, Item):
+    """
+    A float literal.
+    """
+
+    def __new__(cls, value, trivia, raw):  # type: (float, Trivia, str) -> Integer
+        return super(Float, cls).__new__(cls, value)
+
+    def __init__(self, _, trivia, raw):  # type: (float, Trivia, str) -> None
+        super(Float, self).__init__(trivia)
+
+        self._raw = raw
+        self._sign = False
+
+        if re.match(r"^[+\-].+$", raw):
+            self._sign = True
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 3
+
+    @property
+    def value(self):  # type: () -> float
+        return self
+
+    def as_string(self):  # type: () -> str
+        return self._raw
+
+    def __add__(self, other):
+        result = super(Float, self).__add__(other)
+
+        return self._new(result)
+
+    def __radd__(self, other):
+        result = super(Float, self).__radd__(other)
+
+        if isinstance(other, Float):
+            return self._new(result)
+
+        return result
+
+    def __sub__(self, other):
+        result = super(Float, self).__sub__(other)
+
+        return self._new(result)
+
+    def __rsub__(self, other):
+        result = super(Float, self).__rsub__(other)
+
+        if isinstance(other, Float):
+            return self._new(result)
+
+        return result
+
+    def _new(self, result):
+        raw = str(result)
+
+        if self._sign:
+            sign = "+" if result >= 0 else "-"
+            raw = sign + raw
+
+        return Float(result, self._trivia, raw)
+
+    def _getstate(self, protocol=3):
+        return float(self), self._trivia, self._raw
+
+
+class Bool(Item):
+    """
+    A boolean literal.
+    """
+
+    def __init__(self, t, trivia):  # type: (int, Trivia) -> None
+        super(Bool, self).__init__(trivia)
+
+        self._value = bool(t)
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 4
+
+    @property
+    def value(self):  # type: () -> bool
+        return self._value
+
+    def as_string(self):  # type: () -> str
+        return str(self._value).lower()
+
+    def _getstate(self, protocol=3):
+        return self._value, self._trivia
+
+    def __bool__(self):
+        return self._value
+
+    __nonzero__ = __bool__
+
+    def __eq__(self, other):
+        if not isinstance(other, bool):
+            return NotImplemented
+
+        return other == self._value
+
+    def __hash__(self):
+        return hash(self._value)
+
+    def __repr__(self):
+        return repr(self._value)
+
+
+class DateTime(Item, datetime):
+    """
+    A datetime literal.
+    """
+
+    def __new__(
+        cls,
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond,
+        tzinfo,
+        trivia,
+        raw,
+        **kwargs
+    ):  # type: (int, int, int, int, int, int, int, Optional[datetime.tzinfo], Trivia, str, Any) -> datetime
+        return datetime.__new__(
+            cls,
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            microsecond,
+            tzinfo=tzinfo,
+            **kwargs
+        )
+
+    def __init__(
+        self, year, month, day, hour, minute, second, microsecond, tzinfo, trivia, raw
+    ):  # type: (int, int, int, int, int, int, int, Optional[datetime.tzinfo], Trivia, str) -> None
+        super(DateTime, self).__init__(trivia)
+
+        self._raw = raw
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 5
+
+    @property
+    def value(self):  # type: () -> datetime
+        return self
+
+    def as_string(self):  # type: () -> str
+        return self._raw
+
+    def __add__(self, other):
+        if PY38:
+            result = datetime(
+                self.year,
+                self.month,
+                self.day,
+                self.hour,
+                self.minute,
+                self.second,
+                self.microsecond,
+                self.tzinfo,
+            ).__add__(other)
+        else:
+            result = super(DateTime, self).__add__(other)
+
+        return self._new(result)
+
+    def __sub__(self, other):
+        if PY38:
+            result = datetime(
+                self.year,
+                self.month,
+                self.day,
+                self.hour,
+                self.minute,
+                self.second,
+                self.microsecond,
+                self.tzinfo,
+            ).__sub__(other)
+        else:
+            result = super(DateTime, self).__sub__(other)
+
+        if isinstance(result, datetime):
+            result = self._new(result)
+
+        return result
+
+    def _new(self, result):
+        raw = result.isoformat()
+
+        return DateTime(
+            result.year,
+            result.month,
+            result.day,
+            result.hour,
+            result.minute,
+            result.second,
+            result.microsecond,
+            result.tzinfo,
+            self._trivia,
+            raw,
+        )
+
+    def _getstate(self, protocol=3):
+        return (
+            self.year,
+            self.month,
+            self.day,
+            self.hour,
+            self.minute,
+            self.second,
+            self.microsecond,
+            self.tzinfo,
+            self._trivia,
+            self._raw,
+        )
+
+
+class Date(Item, date):
+    """
+    A date literal.
+    """
+
+    def __new__(cls, year, month, day, *_):  # type: (int, int, int, Any) -> date
+        return date.__new__(cls, year, month, day)
+
+    def __init__(
+        self, year, month, day, trivia, raw
+    ):  # type: (int, int, int, Trivia, str) -> None
+        super(Date, self).__init__(trivia)
+
+        self._raw = raw
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 6
+
+    @property
+    def value(self):  # type: () -> date
+        return self
+
+    def as_string(self):  # type: () -> str
+        return self._raw
+
+    def __add__(self, other):
+        if PY38:
+            result = date(self.year, self.month, self.day).__add__(other)
+        else:
+            result = super(Date, self).__add__(other)
+
+        return self._new(result)
+
+    def __sub__(self, other):
+        if PY38:
+            result = date(self.year, self.month, self.day).__sub__(other)
+        else:
+            result = super(Date, self).__sub__(other)
+
+        if isinstance(result, date):
+            result = self._new(result)
+
+        return result
+
+    def _new(self, result):
+        raw = result.isoformat()
+
+        return Date(result.year, result.month, result.day, self._trivia, raw)
+
+    def _getstate(self, protocol=3):
+        return (self.year, self.month, self.day, self._trivia, self._raw)
+
+
+class Time(Item, time):
+    """
+    A time literal.
+    """
+
+    def __new__(
+        cls, hour, minute, second, microsecond, tzinfo, *_
+    ):  # type: (int, int, int, int, Optional[datetime.tzinfo], Any) -> time
+        return time.__new__(cls, hour, minute, second, microsecond, tzinfo)
+
+    def __init__(
+        self, hour, minute, second, microsecond, tzinfo, trivia, raw
+    ):  # type: (int, int, int, int, Optional[datetime.tzinfo], Trivia, str) -> None
+        super(Time, self).__init__(trivia)
+
+        self._raw = raw
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 7
+
+    @property
+    def value(self):  # type: () -> time
+        return self
+
+    def as_string(self):  # type: () -> str
+        return self._raw
+
+    def _getstate(self, protocol=3):
+        return (
+            self.hour,
+            self.minute,
+            self.second,
+            self.microsecond,
+            self.tzinfo,
+            self._trivia,
+            self._raw,
+        )
+
+
+class Array(Item, list):
+    """
+    An array literal
+    """
+
+    def __init__(
+        self, value, trivia, multiline=False
+    ):  # type: (list, Trivia, bool) -> None
+        super(Array, self).__init__(trivia)
+
+        list.__init__(
+            self, [v.value for v in value if not isinstance(v, (Whitespace, Comment))]
+        )
+
+        self._value = value
+        self._multiline = multiline
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 8
+
+    @property
+    def value(self):  # type: () -> list
+        return self
+
+    def multiline(self, multiline):  # type: (bool) -> self
+        self._multiline = multiline
+
+        return self
+
+    def as_string(self):  # type: () -> str
+        if not self._multiline:
+            return "[{}]".format("".join(v.as_string() for v in self._value))
+
+        s = "[\n" + self.trivia.indent + " " * 4
+        s += (",\n" + self.trivia.indent + " " * 4).join(
+            v.as_string() for v in self._value if not isinstance(v, Whitespace)
+        )
+        s += ",\n"
+        s += "]"
+
+        return s
+
+    def append(self, _item):  # type: (Any) -> None
+        if self._value:
+            self._value.append(Whitespace(", "))
+
+        it = item(_item)
+        super(Array, self).append(it.value)
+
+        self._value.append(it)
+
+    if not PY2:
+
+        def clear(self):
+            super(Array, self).clear()
+
+            self._value.clear()
+
+    def __iadd__(self, other):  # type: (list) -> Array
+        if not isinstance(other, list):
+            return NotImplemented
+
+        for v in other:
+            self.append(v)
+
+        return self
+
+    def __delitem__(self, key):
+        super(Array, self).__delitem__(key)
+
+        j = 0 if key >= 0 else -1
+        for i, v in enumerate(self._value if key >= 0 else reversed(self._value)):
+            if key < 0:
+                i = -i - 1
+
+            if isinstance(v, (Comment, Whitespace)):
+                continue
+
+            if j == key:
+                del self._value[i]
+
+                if i < 0 and abs(i) > len(self._value):
+                    i += 1
+
+                if i < len(self._value) - 1 and isinstance(self._value[i], Whitespace):
+                    del self._value[i]
+
+                break
+
+            j += 1 if key >= 0 else -1
+
+    def __str__(self):
+        return str(
+            [v.value for v in self._value if not isinstance(v, (Whitespace, Comment))]
+        )
+
+    def __repr__(self):
+        return str(self)
+
+    def _getstate(self, protocol=3):
+        return self._value, self._trivia
+
+
+class Table(Item, MutableMapping, dict):
+    """
+    A table literal.
+    """
+
+    def __init__(
+        self,
+        value,
+        trivia,
+        is_aot_element,
+        is_super_table=False,
+        name=None,
+        display_name=None,
+    ):  # type: (tomlkit.container.Container, Trivia, bool, bool, Optional[str], Optional[str]) -> None
+        super(Table, self).__init__(trivia)
+
+        self.name = name
+        self.display_name = display_name
+        self._value = value
+        self._is_aot_element = is_aot_element
+        self._is_super_table = is_super_table
+
+        for k, v in self._value.body:
+            if k is not None:
+                dict.__setitem__(self, k.key, v)
+
+    @property
+    def value(self):  # type: () -> tomlkit.container.Container
+        return self._value
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 9
+
+    def add(self, key, item=None):  # type: (Union[Key, Item, str], Any) -> Item
+        if item is None:
+            if not isinstance(key, (Comment, Whitespace)):
+                raise ValueError(
+                    "Non comment/whitespace items must have an associated key"
+                )
+
+            key, item = None, key
+
+        return self.append(key, item)
+
+    def append(self, key, _item):  # type: (Union[Key, str], Any) -> Table
+        """
+        Appends a (key, item) to the table.
+        """
+        if not isinstance(_item, Item):
+            _item = item(_item)
+
+        self._value.append(key, _item)
+
+        if isinstance(key, Key):
+            key = key.key
+
+        if key is not None:
+            dict.__setitem__(self, key, _item)
+
+        m = re.match("(?s)^[^ ]*([ ]+).*$", self._trivia.indent)
+        if not m:
+            return self
+
+        indent = m.group(1)
+
+        if not isinstance(_item, Whitespace):
+            m = re.match("(?s)^([^ ]*)(.*)$", _item.trivia.indent)
+            if not m:
+                _item.trivia.indent = indent
+            else:
+                _item.trivia.indent = m.group(1) + indent + m.group(2)
+
+        return self
+
+    def raw_append(self, key, _item):  # type: (Union[Key, str], Any) -> Table
+        if not isinstance(_item, Item):
+            _item = item(_item)
+
+        self._value.append(key, _item)
+
+        if isinstance(key, Key):
+            key = key.key
+
+        if key is not None:
+            dict.__setitem__(self, key, _item)
+
+        return self
+
+    def remove(self, key):  # type: (Union[Key, str]) -> Table
+        self._value.remove(key)
+
+        if isinstance(key, Key):
+            key = key.key
+
+        if key is not None:
+            dict.__delitem__(self, key)
+
+        return self
+
+    def is_aot_element(self):  # type: () -> bool
+        return self._is_aot_element
+
+    def is_super_table(self):  # type: () -> bool
+        return self._is_super_table
+
+    def as_string(self):  # type: () -> str
+        return self._value.as_string()
+
+    # Helpers
+
+    def indent(self, indent):  # type: (int) -> Table
+        super(Table, self).indent(indent)
+
+        m = re.match("(?s)^[^ ]*([ ]+).*$", self._trivia.indent)
+        if not m:
+            indent = ""
+        else:
+            indent = m.group(1)
+
+        for k, item in self._value.body:
+            if not isinstance(item, Whitespace):
+                item.trivia.indent = indent + item.trivia.indent
+
+        return self
+
+    def get(self, key, default=None):  # type: (Any, Optional[Any]) -> Any
+        return self._value.get(key, default)
+
+    def setdefault(
+        self, key, default=None
+    ):  # type: (Union[Key, str], Any) -> Union[Item, Container]
+        super(Table, self).setdefault(key, default=default)
+
+        return self[key]
+
+    def __getitem__(self, key):  # type: (Union[Key, str]) -> Item
+        return self._value[key]
+
+    def __setitem__(self, key, value):  # type: (Union[Key, str], Any) -> None
+        fix_indent = key not in self
+
+        if not isinstance(value, Item):
+            value = item(value)
+
+        self._value[key] = value
+
+        if key is not None:
+            dict.__setitem__(self, key, value)
+
+        m = re.match("(?s)^[^ ]*([ ]+).*$", self._trivia.indent)
+        if not m or not fix_indent:
+            return
+
+        indent = m.group(1)
+
+        if not isinstance(value, Whitespace):
+            m = re.match("(?s)^([^ ]*)(.*)$", value.trivia.indent)
+            if not m:
+                value.trivia.indent = indent
+            else:
+                value.trivia.indent = m.group(1) + indent + m.group(2)
+
+    def __delitem__(self, key):  # type: (Union[Key, str]) -> None
+        self.remove(key)
+
+    def __len__(self):  # type: () -> int
+        return len(self._value)
+
+    def __iter__(self):  # type: () -> Iterator[str]
+        return iter(self._value)
+
+    def __repr__(self):  # type: () -> str
+        return repr(self._value)
+
+    def _getstate(self, protocol=3):
+        return (
+            self._value,
+            self._trivia,
+            self._is_aot_element,
+            self._is_super_table,
+            self.name,
+            self.display_name,
+        )
+
+
+class InlineTable(Item, MutableMapping, dict):
+    """
+    An inline table literal.
+    """
+
+    def __init__(
+        self, value, trivia, new=False
+    ):  # type: (tomlkit.container.Container, Trivia, bool) -> None
+        super(InlineTable, self).__init__(trivia)
+
+        self._value = value
+        self._new = new
+
+        for k, v in self._value.body:
+            if k is not None:
+                dict.__setitem__(self, k.key, v)
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 10
+
+    @property
+    def value(self):  # type: () -> Dict
+        return self._value
+
+    def append(self, key, _item):  # type: (Union[Key, str], Any) -> InlineTable
+        """
+        Appends a (key, item) to the table.
+        """
+        if not isinstance(_item, Item):
+            _item = item(_item)
+
+        if not isinstance(_item, (Whitespace, Comment)):
+            if not _item.trivia.indent and len(self._value) > 0 and not self._new:
+                _item.trivia.indent = " "
+            if _item.trivia.comment:
+                _item.trivia.comment = ""
+
+        self._value.append(key, _item)
+
+        if isinstance(key, Key):
+            key = key.key
+
+        if key is not None:
+            dict.__setitem__(self, key, _item)
+
+        return self
+
+    def remove(self, key):  # type: (Union[Key, str]) -> InlineTable
+        self._value.remove(key)
+
+        if isinstance(key, Key):
+            key = key.key
+
+        if key is not None:
+            dict.__delitem__(self, key)
+
+        return self
+
+    def as_string(self):  # type: () -> str
+        buf = "{"
+        for i, (k, v) in enumerate(self._value.body):
+            if k is None:
+                if i == len(self._value.body) - 1:
+                    if self._new:
+                        buf = buf.rstrip(", ")
+                    else:
+                        buf = buf.rstrip(",")
+
+                buf += v.as_string()
+
+                continue
+
+            buf += "{}{}{}{}{}{}".format(
+                v.trivia.indent,
+                k.as_string() + ("." if k.is_dotted() else ""),
+                k.sep,
+                v.as_string(),
+                v.trivia.comment,
+                v.trivia.trail.replace("\n", ""),
+            )
+
+            if i != len(self._value.body) - 1:
+                buf += ","
+                if self._new:
+                    buf += " "
+
+        buf += "}"
+
+        return buf
+
+    def get(self, key, default=None):  # type: (Any, Optional[Any]) -> Any
+        return self._value.get(key, default)
+
+    def setdefault(
+        self, key, default=None
+    ):  # type: (Union[Key, str], Any) -> Union[Item, Container]
+        super(InlineTable, self).setdefault(key, default=default)
+
+        return self[key]
+
+    def __contains__(self, key):  # type: (Union[Key, str]) -> bool
+        return key in self._value
+
+    def __getitem__(self, key):  # type: (Union[Key, str]) -> Item
+        return self._value[key]
+
+    def __setitem__(self, key, value):  # type: (Union[Key, str], Any) -> None
+        if not isinstance(value, Item):
+            value = item(value)
+
+        self._value[key] = value
+
+        if key is not None:
+            dict.__setitem__(self, key, value)
+
+        if value.trivia.comment:
+            value.trivia.comment = ""
+
+        m = re.match("(?s)^[^ ]*([ ]+).*$", self._trivia.indent)
+        if not m:
+            return
+
+        indent = m.group(1)
+
+        if not isinstance(value, Whitespace):
+            m = re.match("(?s)^([^ ]*)(.*)$", value.trivia.indent)
+            if not m:
+                value.trivia.indent = indent
+            else:
+                value.trivia.indent = m.group(1) + indent + m.group(2)
+
+    def __delitem__(self, key):  # type: (Union[Key, str]) -> None
+        self.remove(key)
+
+    def __len__(self):  # type: () -> int
+        return len(self._value)
+
+    def __iter__(self):  # type: () -> Iterator[str]
+        return iter(self._value)
+
+    def __repr__(self):
+        return repr(self._value)
+
+    def _getstate(self, protocol=3):
+        return (self._value, self._trivia)
+
+
+class String(unicode, Item):
+    """
+    A string literal.
+    """
+
+    def __new__(cls, t, value, original, trivia):
+        return super(String, cls).__new__(cls, value)
+
+    def __init__(
+        self, t, _, original, trivia
+    ):  # type: (StringType, str, original, Trivia) -> None
+        super(String, self).__init__(trivia)
+
+        self._t = t
+        self._original = original
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 11
+
+    @property
+    def value(self):  # type: () -> str
+        return self
+
+    def as_string(self):  # type: () -> str
+        return "{}{}{}".format(self._t.value, decode(self._original), self._t.value)
+
+    def __add__(self, other):
+        result = super(String, self).__add__(other)
+
+        return self._new(result)
+
+    def __sub__(self, other):
+        result = super(String, self).__sub__(other)
+
+        return self._new(result)
+
+    def _new(self, result):
+        return String(self._t, result, result, self._trivia)
+
+    def _getstate(self, protocol=3):
+        return self._t, unicode(self), self._original, self._trivia
+
+
+class AoT(Item, list):
+    """
+    An array of table literal
+    """
+
+    def __init__(
+        self, body, name=None, parsed=False
+    ):  # type: (List[Table], Optional[str], bool) -> None
+        self.name = name
+        self._body = []
+        self._parsed = parsed
+
+        super(AoT, self).__init__(Trivia(trail=""))
+
+        for table in body:
+            self.append(table)
+
+    @property
+    def body(self):  # type: () -> List[Table]
+        return self._body
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return 12
+
+    @property
+    def value(self):  # type: () -> List[Dict[Any, Any]]
+        return [v.value for v in self._body]
+
+    def append(self, table):  # type: (Table) -> Table
+        m = re.match("(?s)^[^ ]*([ ]+).*$", self._trivia.indent)
+        if m:
+            indent = m.group(1)
+
+            m = re.match("(?s)^([^ ]*)(.*)$", table.trivia.indent)
+            if not m:
+                table.trivia.indent = indent
+            else:
+                table.trivia.indent = m.group(1) + indent + m.group(2)
+
+        if not self._parsed and "\n" not in table.trivia.indent and self._body:
+            table.trivia.indent = "\n" + table.trivia.indent
+
+        self._body.append(table)
+
+        super(AoT, self).append(table)
+
+        return table
+
+    def as_string(self):  # type: () -> str
+        b = ""
+        for table in self._body:
+            b += table.as_string()
+
+        return b
+
+    def __repr__(self):  # type: () -> str
+        return "<AoT {}>".format(self.value)
+
+    def _getstate(self, protocol=3):
+        return self._body, self.name, self._parsed
+
+
+class Null(Item):
+    """
+    A null item.
+    """
+
+    def __init__(self):  # type: () -> None
+        pass
+
+    @property
+    def discriminant(self):  # type: () -> int
+        return -1
+
+    @property
+    def value(self):  # type: () -> None
+        return None
+
+    def as_string(self):  # type: () -> str
+        return ""
+
+    def _getstate(self, protocol=3):
+        return tuple()
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/parser.py b/myenv/lib/python3.9/site-packages/tomlkit/parser.py
new file mode 100644
index 0000000..b702088
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/parser.py
@@ -0,0 +1,1302 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+import re
+import string
+
+from typing import Any
+from typing import Generator
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+from ._compat import chr
+from ._compat import decode
+from ._utils import RFC_3339_LOOSE
+from ._utils import _escaped
+from ._utils import parse_rfc3339
+from .container import Container
+from .exceptions import EmptyKeyError
+from .exceptions import EmptyTableNameError
+from .exceptions import InternalParserError
+from .exceptions import InvalidCharInStringError
+from .exceptions import InvalidControlChar
+from .exceptions import InvalidDateError
+from .exceptions import InvalidDateTimeError
+from .exceptions import InvalidNumberError
+from .exceptions import InvalidTimeError
+from .exceptions import InvalidUnicodeValueError
+from .exceptions import ParseError
+from .exceptions import UnexpectedCharError
+from .exceptions import UnexpectedEofError
+from .items import AoT
+from .items import Array
+from .items import Bool
+from .items import BoolType
+from .items import Comment
+from .items import Date
+from .items import DateTime
+from .items import Float
+from .items import InlineTable
+from .items import Integer
+from .items import Item
+from .items import Key
+from .items import KeyType
+from .items import Null
+from .items import String
+from .items import StringType
+from .items import Table
+from .items import Time
+from .items import Trivia
+from .items import Whitespace
+from .source import Source
+from .toml_char import TOMLChar
+from .toml_document import TOMLDocument
+
+
+CTRL_I = 0x09  # Tab
+CTRL_J = 0x0A  # Line feed
+CTRL_M = 0x0D  # Carriage return
+CTRL_CHAR_LIMIT = 0x1F
+CHR_DEL = 0x7F
+
+
+class Parser:
+    """
+    Parser for TOML documents.
+    """
+
+    def __init__(self, string):  # type: (str) -> None
+        # Input to parse
+        self._src = Source(decode(string))
+
+        self._aot_stack = []
+
+    @property
+    def _state(self):
+        return self._src.state
+
+    @property
+    def _idx(self):
+        return self._src.idx
+
+    @property
+    def _current(self):
+        return self._src.current
+
+    @property
+    def _marker(self):
+        return self._src.marker
+
+    def extract(self):  # type: () -> str
+        """
+        Extracts the value between marker and index
+        """
+        return self._src.extract()
+
+    def inc(self, exception=None):  # type: (Optional[ParseError.__class__]) -> bool
+        """
+        Increments the parser if the end of the input has not been reached.
+        Returns whether or not it was able to advance.
+        """
+        return self._src.inc(exception=exception)
+
+    def inc_n(self, n, exception=None):  # type: (int, Optional[ParseError]) -> bool
+        """
+        Increments the parser by n characters
+        if the end of the input has not been reached.
+        """
+        return self._src.inc_n(n=n, exception=exception)
+
+    def consume(self, chars, min=0, max=-1):
+        """
+        Consume chars until min/max is satisfied is valid.
+        """
+        return self._src.consume(chars=chars, min=min, max=max)
+
+    def end(self):  # type: () -> bool
+        """
+        Returns True if the parser has reached the end of the input.
+        """
+        return self._src.end()
+
+    def mark(self):  # type: () -> None
+        """
+        Sets the marker to the index's current position
+        """
+        self._src.mark()
+
+    def parse_error(self, exception=ParseError, *args):
+        """
+        Creates a generic "parse error" at the current position.
+        """
+        return self._src.parse_error(exception, *args)
+
+    def parse(self):  # type: () -> TOMLDocument
+        body = TOMLDocument(True)
+
+        # Take all keyvals outside of tables/AoT's.
+        while not self.end():
+            # Break out if a table is found
+            if self._current == "[":
+                break
+
+            # Otherwise, take and append one KV
+            item = self._parse_item()
+            if not item:
+                break
+
+            key, value = item
+            if key is not None and key.is_dotted():
+                # We actually have a table
+                self._handle_dotted_key(body, key, value)
+            elif not self._merge_ws(value, body):
+                body.append(key, value)
+
+            self.mark()
+
+        while not self.end():
+            key, value = self._parse_table()
+            if isinstance(value, Table) and value.is_aot_element():
+                # This is just the first table in an AoT. Parse the rest of the array
+                # along with it.
+                value = self._parse_aot(value, key.key)
+
+            body.append(key, value)
+
+        body.parsing(False)
+
+        return body
+
+    def _merge_ws(self, item, container):  # type: (Item, Container) -> bool
+        """
+        Merges the given Item with the last one currently in the given Container if
+        both are whitespace items.
+
+        Returns True if the items were merged.
+        """
+        last = container.last_item()
+        if not last:
+            return False
+
+        if not isinstance(item, Whitespace) or not isinstance(last, Whitespace):
+            return False
+
+        start = self._idx - (len(last.s) + len(item.s))
+        container.body[-1] = (
+            container.body[-1][0],
+            Whitespace(self._src[start : self._idx]),
+        )
+
+        return True
+
+    def _is_child(self, parent, child):  # type: (str, str) -> bool
+        """
+        Returns whether a key is strictly a child of another key.
+        AoT siblings are not considered children of one another.
+        """
+        parent_parts = tuple(self._split_table_name(parent))
+        child_parts = tuple(self._split_table_name(child))
+
+        if parent_parts == child_parts:
+            return False
+
+        return parent_parts == child_parts[: len(parent_parts)]
+
+    def _split_table_name(self, name):  # type: (str) -> Generator[Key]
+        in_name = False
+        current = ""
+        t = KeyType.Bare
+        parts = 0
+        for c in name:
+            c = TOMLChar(c)
+
+            if c == ".":
+                if in_name:
+                    current += c
+                    continue
+
+                if not current:
+                    raise self.parse_error()
+
+                yield Key(current.strip(), t=t, sep="", original=current)
+
+                parts += 1
+
+                current = ""
+                t = KeyType.Bare
+                continue
+            elif c in {"'", '"'}:
+                if in_name:
+                    if (
+                        t == KeyType.Literal
+                        and c == '"'
+                        or t == KeyType.Basic
+                        and c == "'"
+                    ):
+                        current += c
+                        continue
+
+                    if c != t.value:
+                        raise self.parse_error()
+
+                    in_name = False
+                else:
+                    if (
+                        current.strip()
+                        and TOMLChar(current[-1]).is_spaces()
+                        and not parts
+                    ):
+                        raise self.parse_error()
+
+                    in_name = True
+                    t = KeyType.Literal if c == "'" else KeyType.Basic
+
+                continue
+            elif in_name or c.is_bare_key_char():
+                current += c
+            elif c.is_spaces():
+                # A space is only valid at this point
+                # if it's in between parts.
+                # We store it for now and will check
+                # later if it's valid
+                current += c
+                continue
+            else:
+                raise self.parse_error()
+
+        if current.strip():
+            yield Key(current.strip(), t=t, sep="", original=current)
+
+    def _parse_item(self):  # type: () -> Optional[Tuple[Optional[Key], Item]]
+        """
+        Attempts to parse the next item and returns it, along with its key
+        if the item is value-like.
+        """
+        self.mark()
+        with self._state as state:
+            while True:
+                c = self._current
+                if c == "\n":
+                    # Found a newline; Return all whitespace found up to this point.
+                    self.inc()
+
+                    return None, Whitespace(self.extract())
+                elif c in " \t\r":
+                    # Skip whitespace.
+                    if not self.inc():
+                        return None, Whitespace(self.extract())
+                elif c == "#":
+                    # Found a comment, parse it
+                    indent = self.extract()
+                    cws, comment, trail = self._parse_comment_trail()
+
+                    return None, Comment(Trivia(indent, cws, comment, trail))
+                elif c == "[":
+                    # Found a table, delegate to the calling function.
+                    return
+                else:
+                    # Begining of a KV pair.
+                    # Return to beginning of whitespace so it gets included
+                    # as indentation for the KV about to be parsed.
+                    state.restore = True
+                    break
+
+        return self._parse_key_value(True)
+
+    def _parse_comment_trail(self):  # type: () -> Tuple[str, str, str]
+        """
+        Returns (comment_ws, comment, trail)
+        If there is no comment, comment_ws and comment will
+        simply be empty.
+        """
+        if self.end():
+            return "", "", ""
+
+        comment = ""
+        comment_ws = ""
+        self.mark()
+
+        while True:
+            c = self._current
+
+            if c == "\n":
+                break
+            elif c == "#":
+                comment_ws = self.extract()
+
+                self.mark()
+                self.inc()  # Skip #
+
+                # The comment itself
+                while not self.end() and not self._current.is_nl():
+                    code = ord(self._current)
+                    if code == CHR_DEL or code <= CTRL_CHAR_LIMIT and code != CTRL_I:
+                        raise self.parse_error(InvalidControlChar, code, "comments")
+
+                    if not self.inc():
+                        break
+
+                comment = self.extract()
+                self.mark()
+
+                break
+            elif c in " \t\r":
+                self.inc()
+            else:
+                raise self.parse_error(UnexpectedCharError, c)
+
+            if self.end():
+                break
+
+        while self._current.is_spaces() and self.inc():
+            pass
+
+        if self._current == "\r":
+            self.inc()
+
+        if self._current == "\n":
+            self.inc()
+
+        trail = ""
+        if self._idx != self._marker or self._current.is_ws():
+            trail = self.extract()
+
+        return comment_ws, comment, trail
+
+    def _parse_key_value(self, parse_comment=False):  # type: (bool) -> (Key, Item)
+        # Leading indent
+        self.mark()
+
+        while self._current.is_spaces() and self.inc():
+            pass
+
+        indent = self.extract()
+
+        # Key
+        key = self._parse_key()
+
+        self.mark()
+
+        found_equals = self._current == "="
+        while self._current.is_kv_sep() and self.inc():
+            if self._current == "=":
+                if found_equals:
+                    raise self.parse_error(UnexpectedCharError, "=")
+                else:
+                    found_equals = True
+            pass
+
+        if not key.sep:
+            key.sep = self.extract()
+        else:
+            key.sep += self.extract()
+
+        # Value
+        val = self._parse_value()
+        # Comment
+        if parse_comment:
+            cws, comment, trail = self._parse_comment_trail()
+            meta = val.trivia
+            if not meta.comment_ws:
+                meta.comment_ws = cws
+
+            meta.comment = comment
+            meta.trail = trail
+        else:
+            val.trivia.trail = ""
+
+        val.trivia.indent = indent
+
+        return key, val
+
+    def _parse_key(self):  # type: () -> Key
+        """
+        Parses a Key at the current position;
+        WS before the key must be exhausted first at the callsite.
+        """
+        if self._current in "\"'":
+            return self._parse_quoted_key()
+        else:
+            return self._parse_bare_key()
+
+    def _parse_quoted_key(self):  # type: () -> Key
+        """
+        Parses a key enclosed in either single or double quotes.
+        """
+        quote_style = self._current
+        key_type = None
+        dotted = False
+        for t in KeyType:
+            if t.value == quote_style:
+                key_type = t
+                break
+
+        if key_type is None:
+            raise RuntimeError("Should not have entered _parse_quoted_key()")
+
+        self.inc()
+        self.mark()
+
+        while self._current != quote_style and self.inc():
+            pass
+
+        key = self.extract()
+
+        if self._current == ".":
+            self.inc()
+            dotted = True
+            key += "." + self._parse_key().as_string()
+            key_type = KeyType.Bare
+        else:
+            self.inc()
+
+        return Key(key, key_type, "", dotted)
+
+    def _parse_bare_key(self):  # type: () -> Key
+        """
+        Parses a bare key.
+        """
+        key_type = None
+        dotted = False
+
+        self.mark()
+        while (
+            self._current.is_bare_key_char() or self._current.is_spaces()
+        ) and self.inc():
+            pass
+
+        original = self.extract()
+        key = original.strip()
+        if not key:
+            # Empty key
+            raise self.parse_error(ParseError, "Empty key found")
+
+        if " " in key:
+            # Bare key with spaces in it
+            raise self.parse_error(ParseError, 'Invalid key "{}"'.format(key))
+
+        if self._current == ".":
+            self.inc()
+            dotted = True
+            original += "." + self._parse_key().as_string()
+            key = original.strip()
+            key_type = KeyType.Bare
+
+        return Key(key, key_type, "", dotted, original=original)
+
+    def _handle_dotted_key(
+        self, container, key, value
+    ):  # type: (Union[Container, Table], Key, Any) -> None
+        names = tuple(self._split_table_name(key.as_string()))
+        name = names[0]
+        name._dotted = True
+        if name in container:
+            if not isinstance(value, Table):
+                table = Table(Container(True), Trivia(), False, is_super_table=True)
+                _table = table
+                for i, _name in enumerate(names[1:]):
+                    if i == len(names) - 2:
+                        _name.sep = key.sep
+
+                        _table.append(_name, value)
+                    else:
+                        _name._dotted = True
+                        _table.append(
+                            _name,
+                            Table(
+                                Container(True),
+                                Trivia(),
+                                False,
+                                is_super_table=i < len(names) - 2,
+                            ),
+                        )
+
+                        _table = _table[_name]
+
+                value = table
+
+            container.append(name, value)
+
+            return
+        else:
+            table = Table(Container(True), Trivia(), False, is_super_table=True)
+            if isinstance(container, Table):
+                container.raw_append(name, table)
+            else:
+                container.append(name, table)
+
+        for i, _name in enumerate(names[1:]):
+            if i == len(names) - 2:
+                _name.sep = key.sep
+
+                table.append(_name, value)
+            else:
+                _name._dotted = True
+                if _name in table.value:
+                    table = table.value[_name]
+                else:
+                    table.append(
+                        _name,
+                        Table(
+                            Container(True),
+                            Trivia(),
+                            False,
+                            is_super_table=i < len(names) - 2,
+                        ),
+                    )
+
+                    table = table[_name]
+
+    def _parse_value(self):  # type: () -> Item
+        """
+        Attempts to parse a value at the current position.
+        """
+        self.mark()
+        c = self._current
+        trivia = Trivia()
+
+        if c == StringType.SLB.value:
+            return self._parse_basic_string()
+        elif c == StringType.SLL.value:
+            return self._parse_literal_string()
+        elif c == BoolType.TRUE.value[0]:
+            return self._parse_true()
+        elif c == BoolType.FALSE.value[0]:
+            return self._parse_false()
+        elif c == "[":
+            return self._parse_array()
+        elif c == "{":
+            return self._parse_inline_table()
+        elif c in "+-" or self._peek(4) in {
+            "+inf",
+            "-inf",
+            "inf",
+            "+nan",
+            "-nan",
+            "nan",
+        }:
+            # Number
+            while self._current not in " \t\n\r#,]}" and self.inc():
+                pass
+
+            raw = self.extract()
+
+            item = self._parse_number(raw, trivia)
+            if item is not None:
+                return item
+
+            raise self.parse_error(InvalidNumberError)
+        elif c in string.digits:
+            # Integer, Float, Date, Time or DateTime
+            while self._current not in " \t\n\r#,]}" and self.inc():
+                pass
+
+            raw = self.extract()
+
+            m = RFC_3339_LOOSE.match(raw)
+            if m:
+                if m.group(1) and m.group(5):
+                    # datetime
+                    try:
+                        dt = parse_rfc3339(raw)
+                        return DateTime(
+                            dt.year,
+                            dt.month,
+                            dt.day,
+                            dt.hour,
+                            dt.minute,
+                            dt.second,
+                            dt.microsecond,
+                            dt.tzinfo,
+                            trivia,
+                            raw,
+                        )
+                    except ValueError:
+                        raise self.parse_error(InvalidDateTimeError)
+
+                if m.group(1):
+                    try:
+                        dt = parse_rfc3339(raw)
+                        date = Date(dt.year, dt.month, dt.day, trivia, raw)
+                        self.mark()
+                        while self._current not in "\t\n\r#,]}" and self.inc():
+                            pass
+
+                        time_raw = self.extract()
+                        if not time_raw.strip():
+                            trivia.comment_ws = time_raw
+                            return date
+
+                        dt = parse_rfc3339(raw + time_raw)
+                        return DateTime(
+                            dt.year,
+                            dt.month,
+                            dt.day,
+                            dt.hour,
+                            dt.minute,
+                            dt.second,
+                            dt.microsecond,
+                            dt.tzinfo,
+                            trivia,
+                            raw + time_raw,
+                        )
+                    except ValueError:
+                        raise self.parse_error(InvalidDateError)
+
+                if m.group(5):
+                    try:
+                        t = parse_rfc3339(raw)
+                        return Time(
+                            t.hour,
+                            t.minute,
+                            t.second,
+                            t.microsecond,
+                            t.tzinfo,
+                            trivia,
+                            raw,
+                        )
+                    except ValueError:
+                        raise self.parse_error(InvalidTimeError)
+
+            item = self._parse_number(raw, trivia)
+            if item is not None:
+                return item
+
+            raise self.parse_error(InvalidNumberError)
+        else:
+            raise self.parse_error(UnexpectedCharError, c)
+
+    def _parse_true(self):
+        return self._parse_bool(BoolType.TRUE)
+
+    def _parse_false(self):
+        return self._parse_bool(BoolType.FALSE)
+
+    def _parse_bool(self, style):  # type: (BoolType) -> Bool
+        with self._state:
+            style = BoolType(style)
+
+            # only keep parsing for bool if the characters match the style
+            # try consuming rest of chars in style
+            for c in style:
+                self.consume(c, min=1, max=1)
+
+            return Bool(style, Trivia())
+
+    def _parse_array(self):  # type: () -> Array
+        # Consume opening bracket, EOF here is an issue (middle of array)
+        self.inc(exception=UnexpectedEofError)
+
+        elems = []  # type: List[Item]
+        prev_value = None
+        while True:
+            # consume whitespace
+            mark = self._idx
+            self.consume(TOMLChar.SPACES)
+            newline = self.consume(TOMLChar.NL)
+            indent = self._src[mark : self._idx]
+            if newline:
+                elems.append(Whitespace(indent))
+                continue
+
+            # consume comment
+            if self._current == "#":
+                cws, comment, trail = self._parse_comment_trail()
+                elems.append(Comment(Trivia(indent, cws, comment, trail)))
+                continue
+
+            # consume indent
+            if indent:
+                elems.append(Whitespace(indent))
+                continue
+
+            # consume value
+            if not prev_value:
+                try:
+                    elems.append(self._parse_value())
+                    prev_value = True
+                    continue
+                except UnexpectedCharError:
+                    pass
+
+            # consume comma
+            if prev_value and self._current == ",":
+                self.inc(exception=UnexpectedEofError)
+                elems.append(Whitespace(","))
+                prev_value = False
+                continue
+
+            # consume closing bracket
+            if self._current == "]":
+                # consume closing bracket, EOF here doesn't matter
+                self.inc()
+                break
+
+            raise self.parse_error(UnexpectedCharError, self._current)
+
+        try:
+            res = Array(elems, Trivia())
+        except ValueError:
+            pass
+        else:
+            return res
+
+    def _parse_inline_table(self):  # type: () -> InlineTable
+        # consume opening bracket, EOF here is an issue (middle of array)
+        self.inc(exception=UnexpectedEofError)
+
+        elems = Container(True)
+        trailing_comma = None
+        while True:
+            # consume leading whitespace
+            mark = self._idx
+            self.consume(TOMLChar.SPACES)
+            raw = self._src[mark : self._idx]
+            if raw:
+                elems.add(Whitespace(raw))
+
+            if not trailing_comma:
+                # None: empty inline table
+                # False: previous key-value pair was not followed by a comma
+                if self._current == "}":
+                    # consume closing bracket, EOF here doesn't matter
+                    self.inc()
+                    break
+
+                if (
+                    trailing_comma is False
+                    or trailing_comma is None
+                    and self._current == ","
+                ):
+                    # Either the previous key-value pair was not followed by a comma
+                    # or the table has an unexpected leading comma.
+                    raise self.parse_error(UnexpectedCharError, self._current)
+            else:
+                # True: previous key-value pair was followed by a comma
+                if self._current == "}" or self._current == ",":
+                    raise self.parse_error(UnexpectedCharError, self._current)
+
+            key, val = self._parse_key_value(False)
+            if key.is_dotted():
+                self._handle_dotted_key(elems, key, val)
+            else:
+                elems.add(key, val)
+
+            # consume trailing whitespace
+            mark = self._idx
+            self.consume(TOMLChar.SPACES)
+            raw = self._src[mark : self._idx]
+            if raw:
+                elems.add(Whitespace(raw))
+
+            # consume trailing comma
+            trailing_comma = self._current == ","
+            if trailing_comma:
+                # consume closing bracket, EOF here is an issue (middle of inline table)
+                self.inc(exception=UnexpectedEofError)
+
+        return InlineTable(elems, Trivia())
+
+    def _parse_number(self, raw, trivia):  # type: (str, Trivia) -> Optional[Item]
+        # Leading zeros are not allowed
+        sign = ""
+        if raw.startswith(("+", "-")):
+            sign = raw[0]
+            raw = raw[1:]
+
+        if (
+            len(raw) > 1
+            and raw.startswith("0")
+            and not raw.startswith(("0.", "0o", "0x", "0b", "0e"))
+        ):
+            return
+
+        if raw.startswith(("0o", "0x", "0b")) and sign:
+            return
+
+        digits = "[0-9]"
+        base = 10
+        if raw.startswith("0b"):
+            digits = "[01]"
+            base = 2
+        elif raw.startswith("0o"):
+            digits = "[0-7]"
+            base = 8
+        elif raw.startswith("0x"):
+            digits = "[0-9a-f]"
+            base = 16
+
+        # Underscores should be surrounded by digits
+        clean = re.sub("(?i)(?<={})_(?={})".format(digits, digits), "", raw)
+
+        if "_" in clean:
+            return
+
+        if clean.endswith("."):
+            return
+
+        try:
+            return Integer(int(sign + clean, base), trivia, sign + raw)
+        except ValueError:
+            try:
+                return Float(float(sign + clean), trivia, sign + raw)
+            except ValueError:
+                return
+
+    def _parse_literal_string(self):  # type: () -> String
+        with self._state:
+            return self._parse_string(StringType.SLL)
+
+    def _parse_basic_string(self):  # type: () -> String
+        with self._state:
+            return self._parse_string(StringType.SLB)
+
+    def _parse_escaped_char(self, multiline):
+        if multiline and self._current.is_ws():
+            # When the last non-whitespace character on a line is
+            # a \, it will be trimmed along with all whitespace
+            # (including newlines) up to the next non-whitespace
+            # character or closing delimiter.
+            # """\
+            #     hello \
+            #     world"""
+            tmp = ""
+            while self._current.is_ws():
+                tmp += self._current
+                # consume the whitespace, EOF here is an issue
+                # (middle of string)
+                self.inc(exception=UnexpectedEofError)
+                continue
+
+            # the escape followed by whitespace must have a newline
+            # before any other chars
+            if "\n" not in tmp:
+                raise self.parse_error(InvalidCharInStringError, self._current)
+
+            return ""
+
+        if self._current in _escaped:
+            c = _escaped[self._current]
+
+            # consume this char, EOF here is an issue (middle of string)
+            self.inc(exception=UnexpectedEofError)
+
+            return c
+
+        if self._current in {"u", "U"}:
+            # this needs to be a unicode
+            u, ue = self._peek_unicode(self._current == "U")
+            if u is not None:
+                # consume the U char and the unicode value
+                self.inc_n(len(ue) + 1)
+
+                return u
+
+            raise self.parse_error(InvalidUnicodeValueError)
+
+        raise self.parse_error(InvalidCharInStringError, self._current)
+
+    def _parse_string(self, delim):  # type: (StringType) -> String
+        # only keep parsing for string if the current character matches the delim
+        if self._current != delim.unit:
+            raise self.parse_error(
+                InternalParserError,
+                "Invalid character for string type {}".format(delim),
+            )
+
+        # consume the opening/first delim, EOF here is an issue
+        # (middle of string or middle of delim)
+        self.inc(exception=UnexpectedEofError)
+
+        if self._current == delim.unit:
+            # consume the closing/second delim, we do not care if EOF occurs as
+            # that would simply imply an empty single line string
+            if not self.inc() or self._current != delim.unit:
+                # Empty string
+                return String(delim, "", "", Trivia())
+
+            # consume the third delim, EOF here is an issue (middle of string)
+            self.inc(exception=UnexpectedEofError)
+
+            delim = delim.toggle()  # convert delim to multi delim
+
+        self.mark()  # to extract the original string with whitespace and all
+        value = ""
+
+        # A newline immediately following the opening delimiter will be trimmed.
+        if delim.is_multiline() and self._current == "\n":
+            # consume the newline, EOF here is an issue (middle of string)
+            self.inc(exception=UnexpectedEofError)
+
+        escaped = False  # whether the previous key was ESCAPE
+        while True:
+            code = ord(self._current)
+            if (
+                delim.is_singleline()
+                and not escaped
+                and (code == CHR_DEL or code <= CTRL_CHAR_LIMIT and code != CTRL_I)
+            ):
+                raise self.parse_error(InvalidControlChar, code, "strings")
+            elif (
+                delim.is_multiline()
+                and not escaped
+                and (
+                    code == CHR_DEL
+                    or code <= CTRL_CHAR_LIMIT
+                    and code not in [CTRL_I, CTRL_J, CTRL_M]
+                )
+            ):
+                raise self.parse_error(InvalidControlChar, code, "strings")
+            elif not escaped and self._current == delim.unit:
+                # try to process current as a closing delim
+                original = self.extract()
+
+                close = ""
+                if delim.is_multiline():
+                    # Consume the delimiters to see if we are at the end of the string
+                    close = ""
+                    while self._current == delim.unit:
+                        close += self._current
+                        self.inc()
+
+                    if len(close) < 3:
+                        # Not a triple quote, leave in result as-is.
+                        # Adding back the characters we already consumed
+                        value += close
+                        continue
+
+                    if len(close) == 3:
+                        # We are at the end of the string
+                        return String(delim, value, original, Trivia())
+
+                    if len(close) >= 6:
+                        raise self.parse_error(InvalidCharInStringError, self._current)
+
+                    value += close[:-3]
+                    original += close[:-3]
+
+                    return String(delim, value, original, Trivia())
+                else:
+                    # consume the closing delim, we do not care if EOF occurs as
+                    # that would simply imply the end of self._src
+                    self.inc()
+
+                return String(delim, value, original, Trivia())
+            elif delim.is_basic() and escaped:
+                # attempt to parse the current char as an escaped value, an exception
+                # is raised if this fails
+                value += self._parse_escaped_char(delim.is_multiline())
+
+                # no longer escaped
+                escaped = False
+            elif delim.is_basic() and self._current == "\\":
+                # the next char is being escaped
+                escaped = True
+
+                # consume this char, EOF here is an issue (middle of string)
+                self.inc(exception=UnexpectedEofError)
+            else:
+                # this is either a literal string where we keep everything as is,
+                # or this is not a special escaped char in a basic string
+                value += self._current
+
+                # consume this char, EOF here is an issue (middle of string)
+                self.inc(exception=UnexpectedEofError)
+
+    def _parse_table(
+        self, parent_name=None, parent=None
+    ):  # type: (Optional[str], Optional[Table]) -> Tuple[Key, Union[Table, AoT]]
+        """
+        Parses a table element.
+        """
+        if self._current != "[":
+            raise self.parse_error(
+                InternalParserError, "_parse_table() called on non-bracket character."
+            )
+
+        indent = self.extract()
+        self.inc()  # Skip opening bracket
+
+        if self.end():
+            raise self.parse_error(UnexpectedEofError)
+
+        is_aot = False
+        if self._current == "[":
+            if not self.inc():
+                raise self.parse_error(UnexpectedEofError)
+
+            is_aot = True
+
+        # Consume any whitespace
+        self.mark()
+        while self._current.is_spaces() and self.inc():
+            pass
+
+        ws_prefix = self.extract()
+
+        # Key
+        if self._current in [StringType.SLL.value, StringType.SLB.value]:
+            delimiter = (
+                StringType.SLL
+                if self._current == StringType.SLL.value
+                else StringType.SLB
+            )
+            name = self._parse_string(delimiter)
+            name = "{delimiter}{name}{delimiter}".format(
+                delimiter=delimiter.value, name=name
+            )
+
+            self.mark()
+            while self._current != "]" and self.inc():
+                if self.end():
+                    raise self.parse_error(UnexpectedEofError)
+
+                pass
+
+            ws_suffix = self.extract()
+            name += ws_suffix
+        else:
+            self.mark()
+            while self._current != "]" and self.inc():
+                if self.end():
+                    raise self.parse_error(UnexpectedEofError)
+
+                pass
+
+            name = self.extract()
+
+        name = ws_prefix + name
+
+        if not name.strip():
+            raise self.parse_error(EmptyTableNameError)
+
+        key = Key(name, sep="")
+        name_parts = tuple(self._split_table_name(name))
+        if any(" " in part.key.strip() and part.is_bare() for part in name_parts):
+            raise self.parse_error(ParseError, 'Invalid table name "{}"'.format(name))
+
+        missing_table = False
+        if parent_name:
+            parent_name_parts = tuple(self._split_table_name(parent_name))
+        else:
+            parent_name_parts = tuple()
+
+        if len(name_parts) > len(parent_name_parts) + 1:
+            missing_table = True
+
+        name_parts = name_parts[len(parent_name_parts) :]
+
+        values = Container(True)
+
+        self.inc()  # Skip closing bracket
+        if is_aot:
+            # TODO: Verify close bracket
+            self.inc()
+
+        cws, comment, trail = self._parse_comment_trail()
+
+        result = Null()
+        table = Table(
+            values,
+            Trivia(indent, cws, comment, trail),
+            is_aot,
+            name=name,
+            display_name=name,
+        )
+
+        if len(name_parts) > 1:
+            if missing_table:
+                # Missing super table
+                # i.e. a table initialized like this: [foo.bar]
+                # without initializing [foo]
+                #
+                # So we have to create the parent tables
+                table = Table(
+                    Container(True),
+                    Trivia(indent, cws, comment, trail),
+                    is_aot and name_parts[0].key in self._aot_stack,
+                    is_super_table=True,
+                    name=name_parts[0].key,
+                )
+
+                result = table
+                key = name_parts[0]
+
+                for i, _name in enumerate(name_parts[1:]):
+                    if _name in table:
+                        child = table[_name]
+                    else:
+                        child = Table(
+                            Container(True),
+                            Trivia(indent, cws, comment, trail),
+                            is_aot and i == len(name_parts[1:]) - 1,
+                            is_super_table=i < len(name_parts[1:]) - 1,
+                            name=_name.key,
+                            display_name=name if i == len(name_parts[1:]) - 1 else None,
+                        )
+
+                    if is_aot and i == len(name_parts[1:]) - 1:
+                        table.raw_append(
+                            _name, AoT([child], name=table.name, parsed=True)
+                        )
+                    else:
+                        table.raw_append(_name, child)
+
+                    table = child
+                    values = table.value
+        else:
+            if name_parts:
+                key = name_parts[0]
+
+        while not self.end():
+            item = self._parse_item()
+            if item:
+                _key, item = item
+                if not self._merge_ws(item, values):
+                    if _key is not None and _key.is_dotted():
+                        self._handle_dotted_key(table, _key, item)
+                    else:
+                        table.raw_append(_key, item)
+            else:
+                if self._current == "[":
+                    is_aot_next, name_next = self._peek_table()
+
+                    if self._is_child(name, name_next):
+                        key_next, table_next = self._parse_table(name, table)
+
+                        table.raw_append(key_next, table_next)
+
+                        # Picking up any sibling
+                        while not self.end():
+                            _, name_next = self._peek_table()
+
+                            if not self._is_child(name, name_next):
+                                break
+
+                            key_next, table_next = self._parse_table(name, table)
+
+                            table.raw_append(key_next, table_next)
+
+                    break
+                else:
+                    raise self.parse_error(
+                        InternalParserError,
+                        "_parse_item() returned None on a non-bracket character.",
+                    )
+
+        if isinstance(result, Null):
+            result = table
+
+            if is_aot and (not self._aot_stack or name != self._aot_stack[-1]):
+                result = self._parse_aot(result, name)
+
+        return key, result
+
+    def _peek_table(self):  # type: () -> Tuple[bool, str]
+        """
+        Peeks ahead non-intrusively by cloning then restoring the
+        initial state of the parser.
+
+        Returns the name of the table about to be parsed,
+        as well as whether it is part of an AoT.
+        """
+        # we always want to restore after exiting this scope
+        table_name = ""
+        with self._state(save_marker=True, restore=True):
+            if self._current != "[":
+                raise self.parse_error(
+                    InternalParserError,
+                    "_peek_table() entered on non-bracket character",
+                )
+
+            # AoT
+            self.inc()
+            is_aot = False
+            if self._current == "[":
+                self.inc()
+                is_aot = True
+
+            self.mark()
+
+            while self._current != "]" and self.inc():
+                table_name = self.extract()
+
+            return is_aot, table_name
+
+    def _parse_aot(self, first, name_first):  # type: (Table, str) -> AoT
+        """
+        Parses all siblings of the provided table first and bundles them into
+        an AoT.
+        """
+        payload = [first]
+        self._aot_stack.append(name_first)
+        while not self.end():
+            is_aot_next, name_next = self._peek_table()
+            if is_aot_next and name_next == name_first:
+                _, table = self._parse_table(name_first)
+                payload.append(table)
+            else:
+                break
+
+        self._aot_stack.pop()
+
+        return AoT(payload, parsed=True)
+
+    def _peek(self, n):  # type: (int) -> str
+        """
+        Peeks ahead n characters.
+
+        n is the max number of characters that will be peeked.
+        """
+        # we always want to restore after exiting this scope
+        with self._state(restore=True):
+            buf = ""
+            for _ in range(n):
+                if self._current not in " \t\n\r#,]}":
+                    buf += self._current
+                    self.inc()
+                    continue
+
+                break
+            return buf
+
+    def _peek_unicode(
+        self, is_long
+    ):  # type: (bool) -> Tuple[Optional[str], Optional[str]]
+        """
+        Peeks ahead non-intrusively by cloning then restoring the
+        initial state of the parser.
+
+        Returns the unicode value is it's a valid one else None.
+        """
+        # we always want to restore after exiting this scope
+        with self._state(save_marker=True, restore=True):
+            if self._current not in {"u", "U"}:
+                raise self.parse_error(
+                    InternalParserError, "_peek_unicode() entered on non-unicode value"
+                )
+
+            self.inc()  # Dropping prefix
+            self.mark()
+
+            if is_long:
+                chars = 8
+            else:
+                chars = 4
+
+            if not self.inc_n(chars):
+                value, extracted = None, None
+            else:
+                extracted = self.extract()
+
+                if extracted[0].lower() == "d" and extracted[1].strip("01234567"):
+                    return None, None
+
+                try:
+                    value = chr(int(extracted, 16))
+                except (ValueError, OverflowError):
+                    value = None
+
+            return value, extracted
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/py.typed b/myenv/lib/python3.9/site-packages/tomlkit/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/source.py b/myenv/lib/python3.9/site-packages/tomlkit/source.py
new file mode 100644
index 0000000..6a6a239
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/source.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+import itertools
+
+from copy import copy
+from typing import Any
+from typing import Optional
+from typing import Tuple
+from typing import Type
+
+from ._compat import PY2
+from ._compat import unicode
+from .exceptions import ParseError
+from .exceptions import UnexpectedCharError
+from .exceptions import UnexpectedEofError
+from .toml_char import TOMLChar
+
+
+class _State:
+    def __init__(
+        self, source, save_marker=False, restore=False
+    ):  # type: (_Source, Optional[bool], Optional[bool]) -> None
+        self._source = source
+        self._save_marker = save_marker
+        self.restore = restore
+
+    def __enter__(self):  # type: () -> None
+        # Entering this context manager - save the state
+        if PY2:
+            # Python 2.7 does not allow to directly copy
+            # an iterator, so we have to make tees of the original
+            # chars iterator.
+            self._source._chars, self._chars = itertools.tee(self._source._chars)
+        else:
+            self._chars = copy(self._source._chars)
+        self._idx = self._source._idx
+        self._current = self._source._current
+        self._marker = self._source._marker
+
+        return self
+
+    def __exit__(self, exception_type, exception_val, trace):
+        # Exiting this context manager - restore the prior state
+        if self.restore or exception_type:
+            self._source._chars = self._chars
+            self._source._idx = self._idx
+            self._source._current = self._current
+            if self._save_marker:
+                self._source._marker = self._marker
+
+
+class _StateHandler:
+    """
+    State preserver for the Parser.
+    """
+
+    def __init__(self, source):  # type: (Source) -> None
+        self._source = source
+        self._states = []
+
+    def __call__(self, *args, **kwargs):
+        return _State(self._source, *args, **kwargs)
+
+    def __enter__(self):  # type: () -> None
+        state = self()
+        self._states.append(state)
+        return state.__enter__()
+
+    def __exit__(self, exception_type, exception_val, trace):
+        state = self._states.pop()
+        return state.__exit__(exception_type, exception_val, trace)
+
+
+class Source(unicode):
+    EOF = TOMLChar("\0")
+
+    def __init__(self, _):  # type: (unicode) -> None
+        super(Source, self).__init__()
+
+        # Collection of TOMLChars
+        self._chars = iter([(i, TOMLChar(c)) for i, c in enumerate(self)])
+
+        self._idx = 0
+        self._marker = 0
+        self._current = TOMLChar("")
+
+        self._state = _StateHandler(self)
+
+        self.inc()
+
+    def reset(self):
+        # initialize both idx and current
+        self.inc()
+
+        # reset marker
+        self.mark()
+
+    @property
+    def state(self):  # type: () -> _StateHandler
+        return self._state
+
+    @property
+    def idx(self):  # type: () -> int
+        return self._idx
+
+    @property
+    def current(self):  # type: () -> TOMLChar
+        return self._current
+
+    @property
+    def marker(self):  # type: () -> int
+        return self._marker
+
+    def extract(self):  # type: () -> unicode
+        """
+        Extracts the value between marker and index
+        """
+        return self[self._marker : self._idx]
+
+    def inc(self, exception=None):  # type: (Optional[Type[ParseError]]) -> bool
+        """
+        Increments the parser if the end of the input has not been reached.
+        Returns whether or not it was able to advance.
+        """
+        try:
+            self._idx, self._current = next(self._chars)
+
+            return True
+        except StopIteration:
+            self._idx = len(self)
+            self._current = self.EOF
+            if exception:
+                raise self.parse_error(exception)
+
+            return False
+
+    def inc_n(self, n, exception=None):  # type: (int, Exception) -> bool
+        """
+        Increments the parser by n characters
+        if the end of the input has not been reached.
+        """
+        for _ in range(n):
+            if not self.inc(exception=exception):
+                return False
+
+        return True
+
+    def consume(self, chars, min=0, max=-1):
+        """
+        Consume chars until min/max is satisfied is valid.
+        """
+        while self.current in chars and max != 0:
+            min -= 1
+            max -= 1
+            if not self.inc():
+                break
+
+        # failed to consume minimum number of characters
+        if min > 0:
+            self.parse_error(UnexpectedCharError)
+
+    def end(self):  # type: () -> bool
+        """
+        Returns True if the parser has reached the end of the input.
+        """
+        return self._current is self.EOF
+
+    def mark(self):  # type: () -> None
+        """
+        Sets the marker to the index's current position
+        """
+        self._marker = self._idx
+
+    def parse_error(
+        self, exception=ParseError, *args
+    ):  # type: (Type[ParseError], Any) -> ParseError
+        """
+        Creates a generic "parse error" at the current position.
+        """
+        line, col = self._to_linecol()
+
+        return exception(line, col, *args)
+
+    def _to_linecol(self):  # type: () -> Tuple[int, int]
+        cur = 0
+        for i, line in enumerate(self.splitlines()):
+            if cur + len(line) + 1 > self.idx:
+                return (i + 1, self.idx - cur)
+
+            cur += len(line) + 1
+
+        return len(self.splitlines()), 0
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/toml_char.py b/myenv/lib/python3.9/site-packages/tomlkit/toml_char.py
new file mode 100644
index 0000000..079b16c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/toml_char.py
@@ -0,0 +1,67 @@
+import string
+
+from ._compat import PY2
+from ._compat import unicode
+
+
+if PY2:
+    from functools32 import lru_cache
+else:
+    from functools import lru_cache
+
+
+class TOMLChar(unicode):
+    def __init__(self, c):
+        super(TOMLChar, self).__init__()
+
+        if len(self) > 1:
+            raise ValueError("A TOML character must be of length 1")
+
+    BARE = string.ascii_letters + string.digits + "-_"
+    KV = "= \t"
+    NUMBER = string.digits + "+-_.e"
+    SPACES = " \t"
+    NL = "\n\r"
+    WS = SPACES + NL
+
+    @lru_cache(maxsize=None)
+    def is_bare_key_char(self):  # type: () -> bool
+        """
+        Whether the character is a valid bare key name or not.
+        """
+        return self in self.BARE
+
+    @lru_cache(maxsize=None)
+    def is_kv_sep(self):  # type: () -> bool
+        """
+        Whether the character is a valid key/value separator ot not.
+        """
+        return self in self.KV
+
+    @lru_cache(maxsize=None)
+    def is_int_float_char(self):  # type: () -> bool
+        """
+        Whether the character if a valid integer or float value character or not.
+        """
+        return self in self.NUMBER
+
+    @lru_cache(maxsize=None)
+    def is_ws(self):  # type: () -> bool
+        """
+        Whether the character is a whitespace character or not.
+        """
+        return self in self.WS
+
+    @lru_cache(maxsize=None)
+    def is_nl(self):  # type: () -> bool
+        """
+        Whether the character is a new line character or not.
+        """
+        return self in self.NL
+
+    @lru_cache(maxsize=None)
+    def is_spaces(self):  # type: () -> bool
+        """
+        Whether the character is a space or not
+        """
+        return self in self.SPACES
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/toml_document.py b/myenv/lib/python3.9/site-packages/tomlkit/toml_document.py
new file mode 100644
index 0000000..b485e30
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/toml_document.py
@@ -0,0 +1,7 @@
+from .container import Container
+
+
+class TOMLDocument(Container):
+    """
+    A TOML document.
+    """
diff --git a/myenv/lib/python3.9/site-packages/tomlkit/toml_file.py b/myenv/lib/python3.9/site-packages/tomlkit/toml_file.py
new file mode 100644
index 0000000..3b41666
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/tomlkit/toml_file.py
@@ -0,0 +1,24 @@
+import io
+
+from typing import Any
+from typing import Dict
+
+from .api import loads
+from .toml_document import TOMLDocument
+
+
+class TOMLFile(object):
+    """
+    Represents a TOML file.
+    """
+
+    def __init__(self, path):  # type: (str) -> None
+        self._path = path
+
+    def read(self):  # type: () -> TOMLDocument
+        with io.open(self._path, encoding="utf-8") as f:
+            return loads(f.read())
+
+    def write(self, data):  # type: (TOMLDocument) -> None
+        with io.open(self._path, "w", encoding="utf-8") as f:
+            f.write(data.as_string())
diff --git a/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/LICENSE
new file mode 100644
index 0000000..583f9f6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/LICENSE
@@ -0,0 +1,254 @@
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC.  Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
+year, the PythonLabs team moved to Digital Creations (now Zope
+Corporation, see http://www.zope.com).  In 2001, the Python Software
+Foundation (PSF, see http://www.python.org/psf/) was formed, a
+non-profit organization created specifically to own Python-related
+Intellectual Property.  Zope Corporation is a sponsoring member of
+the PSF.
+
+All Python releases are Open Source (see http://www.opensource.org for
+the Open Source Definition).  Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+    Release         Derived     Year        Owner       GPL-
+                    from                                compatible? (1)
+
+    0.9.0 thru 1.2              1991-1995   CWI         yes
+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
+    1.6             1.5.2       2000        CNRI        no
+    2.0             1.6         2000        BeOpen.com  no
+    1.6.1           1.6         2001        CNRI        yes (2)
+    2.1             2.0+1.6.1   2001        PSF         no
+    2.0.1           2.0+1.6.1   2001        PSF         yes
+    2.1.1           2.1+2.0.1   2001        PSF         yes
+    2.1.2           2.1.1       2002        PSF         yes
+    2.1.3           2.1.2       2002        PSF         yes
+    2.2 and above   2.1.1       2001-now    PSF         yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+    the GPL.  All Python licenses, unlike the GPL, let you distribute
+    a modified version without making your changes open source.  The
+    GPL-compatible licenses make it possible to combine Python with
+    other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+    because its license has a choice of law clause.  According to
+    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+    is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014 Python Software Foundation; All Rights Reserved" are
+retained in Python alone or in any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions.  Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee.  This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party.  As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement.  This Agreement together with
+Python 1.6.1 may be located on the Internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013.  This
+Agreement may also be obtained from a proxy server on the Internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands.  All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/METADATA
new file mode 100644
index 0000000..3023688
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/METADATA
@@ -0,0 +1,176 @@
+Metadata-Version: 2.1
+Name: typing_extensions
+Version: 4.3.0
+Summary: Backported and Experimental Type Hints for Python 3.7+
+Keywords: annotations,backport,checker,checking,function,hinting,hints,type,typechecking,typehinting,typehints,typing
+Author-email: "Guido van Rossum, Jukka Lehtosalo, Łukasz Langa, Michael Lee" <levkivskyi@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Python Software Foundation License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development
+Project-URL: Bug Tracker, https://github.com/python/typing_extensions/issues
+Project-URL: Changes, https://github.com/python/typing_extensions/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://typing.readthedocs.io/
+Project-URL: Home, https://github.com/python/typing_extensions
+Project-URL: Q & A, https://github.com/python/typing/discussions
+Project-URL: Repository, https://github.com/python/typing_extensions
+
+# Typing Extensions
+
+[![Chat at https://gitter.im/python/typing](https://badges.gitter.im/python/typing.svg)](https://gitter.im/python/typing)
+
+## Overview
+
+The `typing_extensions` module serves two related purposes:
+
+- Enable use of new type system features on older Python versions. For example,
+  `typing.TypeGuard` is new in Python 3.10, but `typing_extensions` allows
+  users on Python 3.6 through 3.9 to use it too.
+- Enable experimentation with new type system PEPs before they are accepted and
+  added to the `typing` module.
+
+New features may be added to `typing_extensions` as soon as they are specified
+in a PEP that has been added to the [python/peps](https://github.com/python/peps)
+repository. If the PEP is accepted, the feature will then be added to `typing`
+for the next CPython release. No typing PEP has been rejected so far, so we
+haven't yet figured out how to deal with that possibility.
+
+Starting with version 4.0.0, `typing_extensions` uses
+[Semantic Versioning](https://semver.org/). The
+major version is incremented for all backwards-incompatible changes.
+Therefore, it's safe to depend
+on `typing_extensions` like this: `typing_extensions >=x.y, <(x+1)`,
+where `x.y` is the first version that includes all features you need.
+
+`typing_extensions` supports Python versions 3.7 and higher. In the future,
+support for older Python versions will be dropped some time after that version
+reaches end of life.
+
+## Included items
+
+This module currently contains the following:
+
+- Experimental features
+
+  - (Currently none)
+
+- In `typing` since Python 3.11
+
+  - `assert_never`
+  - `assert_type`
+  - `clear_overloads`
+  - `@dataclass_transform()` (see PEP 681)
+  - `get_overloads`
+  - `LiteralString` (see PEP 675)
+  - `Never`
+  - `NotRequired` (see PEP 655)
+  - `reveal_type`
+  - `Required` (see PEP 655)
+  - `Self` (see PEP 673)
+  - `TypeVarTuple` (see PEP 646)
+  - `Unpack` (see PEP 646)
+
+- In `typing` since Python 3.10
+
+  - `Concatenate` (see PEP 612)
+  - `ParamSpec` (see PEP 612)
+  - `ParamSpecArgs` (see PEP 612)
+  - `ParamSpecKwargs` (see PEP 612)
+  - `TypeAlias` (see PEP 613)
+  - `TypeGuard` (see PEP 647)
+  - `is_typeddict`
+
+- In `typing` since Python 3.9
+
+  - `Annotated` (see PEP 593)
+
+- In `typing` since Python 3.8
+
+  - `final` (see PEP 591)
+  - `Final` (see PEP 591)
+  - `Literal` (see PEP 586)
+  - `Protocol` (see PEP 544)
+  - `runtime_checkable` (see PEP 544)
+  - `TypedDict` (see PEP 589)
+  - `get_origin` (`typing_extensions` provides this function only in Python 3.7+)
+  - `get_args` (`typing_extensions` provides this function only in Python 3.7+)
+
+- In `typing` since Python 3.7
+
+  - `OrderedDict`
+
+- In `typing` since Python 3.5 or 3.6 (see [the typing documentation](https://docs.python.org/3.10/library/typing.html) for details)
+
+  - `AsyncContextManager`
+  - `AsyncGenerator`
+  - `AsyncIterable`
+  - `AsyncIterator`
+  - `Awaitable`
+  - `ChainMap`
+  - `ClassVar` (see PEP 526)
+  - `ContextManager`
+  - `Coroutine`
+  - `Counter`
+  - `DefaultDict`
+  - `Deque`
+  - `NamedTuple`
+  - `NewType`
+  - `NoReturn`
+  - `overload`
+  - `Text`
+  - `Type`
+  - `TYPE_CHECKING`
+  - `get_type_hints`
+
+# Other Notes and Limitations
+
+Certain objects were changed after they were added to `typing`, and
+`typing_extensions` provides a backport even on newer Python versions:
+
+- `TypedDict` does not store runtime information
+  about which (if any) keys are non-required in Python 3.8, and does not
+  honor the `total` keyword with old-style `TypedDict()` in Python
+  3.9.0 and 3.9.1. `TypedDict` also does not support multiple inheritance
+  with `typing.Generic` on Python <3.11.
+- `get_origin` and `get_args` lack support for `Annotated` in
+  Python 3.8 and lack support for `ParamSpecArgs` and `ParamSpecKwargs`
+  in 3.9.
+- `@final` was changed in Python 3.11 to set the `.__final__` attribute.
+- `@overload` was changed in Python 3.11 to make function overloads
+  introspectable at runtime. In order to access overloads with
+  `typing_extensions.get_overloads()`, you must use
+  `@typing_extensions.overload`.
+- `NamedTuple` was changed in Python 3.11 to allow for multiple inheritance
+  with `typing.Generic`.
+
+There are a few types whose interface was modified between different
+versions of typing. For example, `typing.Sequence` was modified to
+subclass `typing.Reversible` as of Python 3.5.3.
+
+These changes are _not_ backported to prevent subtle compatibility
+issues when mixing the differing implementations of modified classes.
+
+Certain types have incorrect runtime behavior due to limitations of older
+versions of the typing module:
+
+- `ParamSpec` and `Concatenate` will not work with `get_args` and
+  `get_origin`. Certain PEP 612 special cases in user-defined
+  `Generic`s are also not available.
+
+These types are only guaranteed to work for static type checking.
+
+## Running tests
+
+To run tests, navigate into the appropriate source directory and run
+`test_typing_extensions.py`.
+
diff --git a/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/RECORD
new file mode 100644
index 0000000..5100d4c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/RECORD
@@ -0,0 +1,6 @@
+typing_extensions.py,sha256=uZ95U2XP0uVC6SD6OhMsspPxUi7HaLXBIulP58ImWDA,75384
+typing_extensions-4.3.0.dist-info/LICENSE,sha256=_xfOlOECAk3raHc-scx0ynbaTmWPNzUx8Kwi1oprsa0,12755
+typing_extensions-4.3.0.dist-info/WHEEL,sha256=4TfKIB_xu-04bc2iKz6_zFt-gEFEEDU_31HGhqzOCE8,81
+typing_extensions-4.3.0.dist-info/METADATA,sha256=Gc182SCaY3PXonSf1hdCKS9NGE0QLoBnxSS9V9VCOIk,6350
+typing_extensions-4.3.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+typing_extensions-4.3.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/WHEEL
new file mode 100644
index 0000000..668ba4d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/typing_extensions-4.3.0.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.7.1
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/myenv/lib/python3.9/site-packages/typing_extensions.py b/myenv/lib/python3.9/site-packages/typing_extensions.py
new file mode 100644
index 0000000..31d3564
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/typing_extensions.py
@@ -0,0 +1,2069 @@
+import abc
+import collections
+import collections.abc
+import functools
+import operator
+import sys
+import types as _types
+import typing
+
+
+# Please keep __all__ alphabetized within each category.
+__all__ = [
+    # Super-special typing primitives.
+    'ClassVar',
+    'Concatenate',
+    'Final',
+    'LiteralString',
+    'ParamSpec',
+    'ParamSpecArgs',
+    'ParamSpecKwargs',
+    'Self',
+    'Type',
+    'TypeVarTuple',
+    'Unpack',
+
+    # ABCs (from collections.abc).
+    'Awaitable',
+    'AsyncIterator',
+    'AsyncIterable',
+    'Coroutine',
+    'AsyncGenerator',
+    'AsyncContextManager',
+    'ChainMap',
+
+    # Concrete collection types.
+    'ContextManager',
+    'Counter',
+    'Deque',
+    'DefaultDict',
+    'NamedTuple',
+    'OrderedDict',
+    'TypedDict',
+
+    # Structural checks, a.k.a. protocols.
+    'SupportsIndex',
+
+    # One-off things.
+    'Annotated',
+    'assert_never',
+    'assert_type',
+    'clear_overloads',
+    'dataclass_transform',
+    'get_overloads',
+    'final',
+    'get_args',
+    'get_origin',
+    'get_type_hints',
+    'IntVar',
+    'is_typeddict',
+    'Literal',
+    'NewType',
+    'overload',
+    'Protocol',
+    'reveal_type',
+    'runtime',
+    'runtime_checkable',
+    'Text',
+    'TypeAlias',
+    'TypeGuard',
+    'TYPE_CHECKING',
+    'Never',
+    'NoReturn',
+    'Required',
+    'NotRequired',
+]
+
+# for backward compatibility
+PEP_560 = True
+GenericMeta = type
+
+# The functions below are modified copies of typing internal helpers.
+# They are needed by _ProtocolMeta and they provide support for PEP 646.
+
+_marker = object()
+
+
+def _check_generic(cls, parameters, elen=_marker):
+    """Check correct count for parameters of a generic cls (internal helper).
+    This gives a nice error message in case of count mismatch.
+    """
+    if not elen:
+        raise TypeError(f"{cls} is not a generic class")
+    if elen is _marker:
+        if not hasattr(cls, "__parameters__") or not cls.__parameters__:
+            raise TypeError(f"{cls} is not a generic class")
+        elen = len(cls.__parameters__)
+    alen = len(parameters)
+    if alen != elen:
+        if hasattr(cls, "__parameters__"):
+            parameters = [p for p in cls.__parameters__ if not _is_unpack(p)]
+            num_tv_tuples = sum(isinstance(p, TypeVarTuple) for p in parameters)
+            if (num_tv_tuples > 0) and (alen >= elen - num_tv_tuples):
+                return
+        raise TypeError(f"Too {'many' if alen > elen else 'few'} parameters for {cls};"
+                        f" actual {alen}, expected {elen}")
+
+
+if sys.version_info >= (3, 10):
+    def _should_collect_from_parameters(t):
+        return isinstance(
+            t, (typing._GenericAlias, _types.GenericAlias, _types.UnionType)
+        )
+elif sys.version_info >= (3, 9):
+    def _should_collect_from_parameters(t):
+        return isinstance(t, (typing._GenericAlias, _types.GenericAlias))
+else:
+    def _should_collect_from_parameters(t):
+        return isinstance(t, typing._GenericAlias) and not t._special
+
+
+def _collect_type_vars(types, typevar_types=None):
+    """Collect all type variable contained in types in order of
+    first appearance (lexicographic order). For example::
+
+        _collect_type_vars((T, List[S, T])) == (T, S)
+    """
+    if typevar_types is None:
+        typevar_types = typing.TypeVar
+    tvars = []
+    for t in types:
+        if (
+            isinstance(t, typevar_types) and
+            t not in tvars and
+            not _is_unpack(t)
+        ):
+            tvars.append(t)
+        if _should_collect_from_parameters(t):
+            tvars.extend([t for t in t.__parameters__ if t not in tvars])
+    return tuple(tvars)
+
+
+NoReturn = typing.NoReturn
+
+# Some unconstrained type variables.  These are used by the container types.
+# (These are not for export.)
+T = typing.TypeVar('T')  # Any type.
+KT = typing.TypeVar('KT')  # Key type.
+VT = typing.TypeVar('VT')  # Value type.
+T_co = typing.TypeVar('T_co', covariant=True)  # Any type covariant containers.
+T_contra = typing.TypeVar('T_contra', contravariant=True)  # Ditto contravariant.
+
+ClassVar = typing.ClassVar
+
+# On older versions of typing there is an internal class named "Final".
+# 3.8+
+if hasattr(typing, 'Final') and sys.version_info[:2] >= (3, 7):
+    Final = typing.Final
+# 3.7
+else:
+    class _FinalForm(typing._SpecialForm, _root=True):
+
+        def __repr__(self):
+            return 'typing_extensions.' + self._name
+
+        def __getitem__(self, parameters):
+            item = typing._type_check(parameters,
+                                      f'{self._name} accepts only a single type.')
+            return typing._GenericAlias(self, (item,))
+
+    Final = _FinalForm('Final',
+                       doc="""A special typing construct to indicate that a name
+                       cannot be re-assigned or overridden in a subclass.
+                       For example:
+
+                           MAX_SIZE: Final = 9000
+                           MAX_SIZE += 1  # Error reported by type checker
+
+                           class Connection:
+                               TIMEOUT: Final[int] = 10
+                           class FastConnector(Connection):
+                               TIMEOUT = 1  # Error reported by type checker
+
+                       There is no runtime checking of these properties.""")
+
+if sys.version_info >= (3, 11):
+    final = typing.final
+else:
+    # @final exists in 3.8+, but we backport it for all versions
+    # before 3.11 to keep support for the __final__ attribute.
+    # See https://bugs.python.org/issue46342
+    def final(f):
+        """This decorator can be used to indicate to type checkers that
+        the decorated method cannot be overridden, and decorated class
+        cannot be subclassed. For example:
+
+            class Base:
+                @final
+                def done(self) -> None:
+                    ...
+            class Sub(Base):
+                def done(self) -> None:  # Error reported by type checker
+                    ...
+            @final
+            class Leaf:
+                ...
+            class Other(Leaf):  # Error reported by type checker
+                ...
+
+        There is no runtime checking of these properties. The decorator
+        sets the ``__final__`` attribute to ``True`` on the decorated object
+        to allow runtime introspection.
+        """
+        try:
+            f.__final__ = True
+        except (AttributeError, TypeError):
+            # Skip the attribute silently if it is not writable.
+            # AttributeError happens if the object has __slots__ or a
+            # read-only property, TypeError if it's a builtin class.
+            pass
+        return f
+
+
+def IntVar(name):
+    return typing.TypeVar(name)
+
+
+# 3.8+:
+if hasattr(typing, 'Literal'):
+    Literal = typing.Literal
+# 3.7:
+else:
+    class _LiteralForm(typing._SpecialForm, _root=True):
+
+        def __repr__(self):
+            return 'typing_extensions.' + self._name
+
+        def __getitem__(self, parameters):
+            return typing._GenericAlias(self, parameters)
+
+    Literal = _LiteralForm('Literal',
+                           doc="""A type that can be used to indicate to type checkers
+                           that the corresponding value has a value literally equivalent
+                           to the provided parameter. For example:
+
+                               var: Literal[4] = 4
+
+                           The type checker understands that 'var' is literally equal to
+                           the value 4 and no other value.
+
+                           Literal[...] cannot be subclassed. There is no runtime
+                           checking verifying that the parameter is actually a value
+                           instead of a type.""")
+
+
+_overload_dummy = typing._overload_dummy  # noqa
+
+
+if hasattr(typing, "get_overloads"):  # 3.11+
+    overload = typing.overload
+    get_overloads = typing.get_overloads
+    clear_overloads = typing.clear_overloads
+else:
+    # {module: {qualname: {firstlineno: func}}}
+    _overload_registry = collections.defaultdict(
+        functools.partial(collections.defaultdict, dict)
+    )
+
+    def overload(func):
+        """Decorator for overloaded functions/methods.
+
+        In a stub file, place two or more stub definitions for the same
+        function in a row, each decorated with @overload.  For example:
+
+        @overload
+        def utf8(value: None) -> None: ...
+        @overload
+        def utf8(value: bytes) -> bytes: ...
+        @overload
+        def utf8(value: str) -> bytes: ...
+
+        In a non-stub file (i.e. a regular .py file), do the same but
+        follow it with an implementation.  The implementation should *not*
+        be decorated with @overload.  For example:
+
+        @overload
+        def utf8(value: None) -> None: ...
+        @overload
+        def utf8(value: bytes) -> bytes: ...
+        @overload
+        def utf8(value: str) -> bytes: ...
+        def utf8(value):
+            # implementation goes here
+
+        The overloads for a function can be retrieved at runtime using the
+        get_overloads() function.
+        """
+        # classmethod and staticmethod
+        f = getattr(func, "__func__", func)
+        try:
+            _overload_registry[f.__module__][f.__qualname__][
+                f.__code__.co_firstlineno
+            ] = func
+        except AttributeError:
+            # Not a normal function; ignore.
+            pass
+        return _overload_dummy
+
+    def get_overloads(func):
+        """Return all defined overloads for *func* as a sequence."""
+        # classmethod and staticmethod
+        f = getattr(func, "__func__", func)
+        if f.__module__ not in _overload_registry:
+            return []
+        mod_dict = _overload_registry[f.__module__]
+        if f.__qualname__ not in mod_dict:
+            return []
+        return list(mod_dict[f.__qualname__].values())
+
+    def clear_overloads():
+        """Clear all overloads in the registry."""
+        _overload_registry.clear()
+
+
+# This is not a real generic class.  Don't use outside annotations.
+Type = typing.Type
+
+# Various ABCs mimicking those in collections.abc.
+# A few are simply re-exported for completeness.
+
+
+Awaitable = typing.Awaitable
+Coroutine = typing.Coroutine
+AsyncIterable = typing.AsyncIterable
+AsyncIterator = typing.AsyncIterator
+Deque = typing.Deque
+ContextManager = typing.ContextManager
+AsyncContextManager = typing.AsyncContextManager
+DefaultDict = typing.DefaultDict
+
+# 3.7.2+
+if hasattr(typing, 'OrderedDict'):
+    OrderedDict = typing.OrderedDict
+# 3.7.0-3.7.2
+else:
+    OrderedDict = typing._alias(collections.OrderedDict, (KT, VT))
+
+Counter = typing.Counter
+ChainMap = typing.ChainMap
+AsyncGenerator = typing.AsyncGenerator
+NewType = typing.NewType
+Text = typing.Text
+TYPE_CHECKING = typing.TYPE_CHECKING
+
+
+_PROTO_WHITELIST = ['Callable', 'Awaitable',
+                    'Iterable', 'Iterator', 'AsyncIterable', 'AsyncIterator',
+                    'Hashable', 'Sized', 'Container', 'Collection', 'Reversible',
+                    'ContextManager', 'AsyncContextManager']
+
+
+def _get_protocol_attrs(cls):
+    attrs = set()
+    for base in cls.__mro__[:-1]:  # without object
+        if base.__name__ in ('Protocol', 'Generic'):
+            continue
+        annotations = getattr(base, '__annotations__', {})
+        for attr in list(base.__dict__.keys()) + list(annotations.keys()):
+            if (not attr.startswith('_abc_') and attr not in (
+                    '__abstractmethods__', '__annotations__', '__weakref__',
+                    '_is_protocol', '_is_runtime_protocol', '__dict__',
+                    '__args__', '__slots__',
+                    '__next_in_mro__', '__parameters__', '__origin__',
+                    '__orig_bases__', '__extra__', '__tree_hash__',
+                    '__doc__', '__subclasshook__', '__init__', '__new__',
+                    '__module__', '_MutableMapping__marker', '_gorg')):
+                attrs.add(attr)
+    return attrs
+
+
+def _is_callable_members_only(cls):
+    return all(callable(getattr(cls, attr, None)) for attr in _get_protocol_attrs(cls))
+
+
+def _maybe_adjust_parameters(cls):
+    """Helper function used in Protocol.__init_subclass__ and _TypedDictMeta.__new__.
+
+    The contents of this function are very similar
+    to logic found in typing.Generic.__init_subclass__
+    on the CPython main branch.
+    """
+    tvars = []
+    if '__orig_bases__' in cls.__dict__:
+        tvars = typing._collect_type_vars(cls.__orig_bases__)
+        # Look for Generic[T1, ..., Tn] or Protocol[T1, ..., Tn].
+        # If found, tvars must be a subset of it.
+        # If not found, tvars is it.
+        # Also check for and reject plain Generic,
+        # and reject multiple Generic[...] and/or Protocol[...].
+        gvars = None
+        for base in cls.__orig_bases__:
+            if (isinstance(base, typing._GenericAlias) and
+                    base.__origin__ in (typing.Generic, Protocol)):
+                # for error messages
+                the_base = base.__origin__.__name__
+                if gvars is not None:
+                    raise TypeError(
+                        "Cannot inherit from Generic[...]"
+                        " and/or Protocol[...] multiple types.")
+                gvars = base.__parameters__
+        if gvars is None:
+            gvars = tvars
+        else:
+            tvarset = set(tvars)
+            gvarset = set(gvars)
+            if not tvarset <= gvarset:
+                s_vars = ', '.join(str(t) for t in tvars if t not in gvarset)
+                s_args = ', '.join(str(g) for g in gvars)
+                raise TypeError(f"Some type variables ({s_vars}) are"
+                                f" not listed in {the_base}[{s_args}]")
+            tvars = gvars
+    cls.__parameters__ = tuple(tvars)
+
+
+# 3.8+
+if hasattr(typing, 'Protocol'):
+    Protocol = typing.Protocol
+# 3.7
+else:
+
+    def _no_init(self, *args, **kwargs):
+        if type(self)._is_protocol:
+            raise TypeError('Protocols cannot be instantiated')
+
+    class _ProtocolMeta(abc.ABCMeta):
+        # This metaclass is a bit unfortunate and exists only because of the lack
+        # of __instancehook__.
+        def __instancecheck__(cls, instance):
+            # We need this method for situations where attributes are
+            # assigned in __init__.
+            if ((not getattr(cls, '_is_protocol', False) or
+                 _is_callable_members_only(cls)) and
+                    issubclass(instance.__class__, cls)):
+                return True
+            if cls._is_protocol:
+                if all(hasattr(instance, attr) and
+                       (not callable(getattr(cls, attr, None)) or
+                        getattr(instance, attr) is not None)
+                       for attr in _get_protocol_attrs(cls)):
+                    return True
+            return super().__instancecheck__(instance)
+
+    class Protocol(metaclass=_ProtocolMeta):
+        # There is quite a lot of overlapping code with typing.Generic.
+        # Unfortunately it is hard to avoid this while these live in two different
+        # modules. The duplicated code will be removed when Protocol is moved to typing.
+        """Base class for protocol classes. Protocol classes are defined as::
+
+            class Proto(Protocol):
+                def meth(self) -> int:
+                    ...
+
+        Such classes are primarily used with static type checkers that recognize
+        structural subtyping (static duck-typing), for example::
+
+            class C:
+                def meth(self) -> int:
+                    return 0
+
+            def func(x: Proto) -> int:
+                return x.meth()
+
+            func(C())  # Passes static type check
+
+        See PEP 544 for details. Protocol classes decorated with
+        @typing_extensions.runtime act as simple-minded runtime protocol that checks
+        only the presence of given attributes, ignoring their type signatures.
+
+        Protocol classes can be generic, they are defined as::
+
+            class GenProto(Protocol[T]):
+                def meth(self) -> T:
+                    ...
+        """
+        __slots__ = ()
+        _is_protocol = True
+
+        def __new__(cls, *args, **kwds):
+            if cls is Protocol:
+                raise TypeError("Type Protocol cannot be instantiated; "
+                                "it can only be used as a base class")
+            return super().__new__(cls)
+
+        @typing._tp_cache
+        def __class_getitem__(cls, params):
+            if not isinstance(params, tuple):
+                params = (params,)
+            if not params and cls is not typing.Tuple:
+                raise TypeError(
+                    f"Parameter list to {cls.__qualname__}[...] cannot be empty")
+            msg = "Parameters to generic types must be types."
+            params = tuple(typing._type_check(p, msg) for p in params)  # noqa
+            if cls is Protocol:
+                # Generic can only be subscripted with unique type variables.
+                if not all(isinstance(p, typing.TypeVar) for p in params):
+                    i = 0
+                    while isinstance(params[i], typing.TypeVar):
+                        i += 1
+                    raise TypeError(
+                        "Parameters to Protocol[...] must all be type variables."
+                        f" Parameter {i + 1} is {params[i]}")
+                if len(set(params)) != len(params):
+                    raise TypeError(
+                        "Parameters to Protocol[...] must all be unique")
+            else:
+                # Subscripting a regular Generic subclass.
+                _check_generic(cls, params, len(cls.__parameters__))
+            return typing._GenericAlias(cls, params)
+
+        def __init_subclass__(cls, *args, **kwargs):
+            if '__orig_bases__' in cls.__dict__:
+                error = typing.Generic in cls.__orig_bases__
+            else:
+                error = typing.Generic in cls.__bases__
+            if error:
+                raise TypeError("Cannot inherit from plain Generic")
+            _maybe_adjust_parameters(cls)
+
+            # Determine if this is a protocol or a concrete subclass.
+            if not cls.__dict__.get('_is_protocol', None):
+                cls._is_protocol = any(b is Protocol for b in cls.__bases__)
+
+            # Set (or override) the protocol subclass hook.
+            def _proto_hook(other):
+                if not cls.__dict__.get('_is_protocol', None):
+                    return NotImplemented
+                if not getattr(cls, '_is_runtime_protocol', False):
+                    if sys._getframe(2).f_globals['__name__'] in ['abc', 'functools']:
+                        return NotImplemented
+                    raise TypeError("Instance and class checks can only be used with"
+                                    " @runtime protocols")
+                if not _is_callable_members_only(cls):
+                    if sys._getframe(2).f_globals['__name__'] in ['abc', 'functools']:
+                        return NotImplemented
+                    raise TypeError("Protocols with non-method members"
+                                    " don't support issubclass()")
+                if not isinstance(other, type):
+                    # Same error as for issubclass(1, int)
+                    raise TypeError('issubclass() arg 1 must be a class')
+                for attr in _get_protocol_attrs(cls):
+                    for base in other.__mro__:
+                        if attr in base.__dict__:
+                            if base.__dict__[attr] is None:
+                                return NotImplemented
+                            break
+                        annotations = getattr(base, '__annotations__', {})
+                        if (isinstance(annotations, typing.Mapping) and
+                                attr in annotations and
+                                isinstance(other, _ProtocolMeta) and
+                                other._is_protocol):
+                            break
+                    else:
+                        return NotImplemented
+                return True
+            if '__subclasshook__' not in cls.__dict__:
+                cls.__subclasshook__ = _proto_hook
+
+            # We have nothing more to do for non-protocols.
+            if not cls._is_protocol:
+                return
+
+            # Check consistency of bases.
+            for base in cls.__bases__:
+                if not (base in (object, typing.Generic) or
+                        base.__module__ == 'collections.abc' and
+                        base.__name__ in _PROTO_WHITELIST or
+                        isinstance(base, _ProtocolMeta) and base._is_protocol):
+                    raise TypeError('Protocols can only inherit from other'
+                                    f' protocols, got {repr(base)}')
+            cls.__init__ = _no_init
+
+
+# 3.8+
+if hasattr(typing, 'runtime_checkable'):
+    runtime_checkable = typing.runtime_checkable
+# 3.7
+else:
+    def runtime_checkable(cls):
+        """Mark a protocol class as a runtime protocol, so that it
+        can be used with isinstance() and issubclass(). Raise TypeError
+        if applied to a non-protocol class.
+
+        This allows a simple-minded structural check very similar to the
+        one-offs in collections.abc such as Hashable.
+        """
+        if not isinstance(cls, _ProtocolMeta) or not cls._is_protocol:
+            raise TypeError('@runtime_checkable can be only applied to protocol classes,'
+                            f' got {cls!r}')
+        cls._is_runtime_protocol = True
+        return cls
+
+
+# Exists for backwards compatibility.
+runtime = runtime_checkable
+
+
+# 3.8+
+if hasattr(typing, 'SupportsIndex'):
+    SupportsIndex = typing.SupportsIndex
+# 3.7
+else:
+    @runtime_checkable
+    class SupportsIndex(Protocol):
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __index__(self) -> int:
+            pass
+
+
+if hasattr(typing, "Required"):
+    # The standard library TypedDict in Python 3.8 does not store runtime information
+    # about which (if any) keys are optional.  See https://bugs.python.org/issue38834
+    # The standard library TypedDict in Python 3.9.0/1 does not honour the "total"
+    # keyword with old-style TypedDict().  See https://bugs.python.org/issue42059
+    # The standard library TypedDict below Python 3.11 does not store runtime
+    # information about optional and required keys when using Required or NotRequired.
+    # Generic TypedDicts are also impossible using typing.TypedDict on Python <3.11.
+    TypedDict = typing.TypedDict
+    _TypedDictMeta = typing._TypedDictMeta
+    is_typeddict = typing.is_typeddict
+else:
+    def _check_fails(cls, other):
+        try:
+            if sys._getframe(1).f_globals['__name__'] not in ['abc',
+                                                              'functools',
+                                                              'typing']:
+                # Typed dicts are only for static structural subtyping.
+                raise TypeError('TypedDict does not support instance and class checks')
+        except (AttributeError, ValueError):
+            pass
+        return False
+
+    def _dict_new(*args, **kwargs):
+        if not args:
+            raise TypeError('TypedDict.__new__(): not enough arguments')
+        _, args = args[0], args[1:]  # allow the "cls" keyword be passed
+        return dict(*args, **kwargs)
+
+    _dict_new.__text_signature__ = '($cls, _typename, _fields=None, /, **kwargs)'
+
+    def _typeddict_new(*args, total=True, **kwargs):
+        if not args:
+            raise TypeError('TypedDict.__new__(): not enough arguments')
+        _, args = args[0], args[1:]  # allow the "cls" keyword be passed
+        if args:
+            typename, args = args[0], args[1:]  # allow the "_typename" keyword be passed
+        elif '_typename' in kwargs:
+            typename = kwargs.pop('_typename')
+            import warnings
+            warnings.warn("Passing '_typename' as keyword argument is deprecated",
+                          DeprecationWarning, stacklevel=2)
+        else:
+            raise TypeError("TypedDict.__new__() missing 1 required positional "
+                            "argument: '_typename'")
+        if args:
+            try:
+                fields, = args  # allow the "_fields" keyword be passed
+            except ValueError:
+                raise TypeError('TypedDict.__new__() takes from 2 to 3 '
+                                f'positional arguments but {len(args) + 2} '
+                                'were given')
+        elif '_fields' in kwargs and len(kwargs) == 1:
+            fields = kwargs.pop('_fields')
+            import warnings
+            warnings.warn("Passing '_fields' as keyword argument is deprecated",
+                          DeprecationWarning, stacklevel=2)
+        else:
+            fields = None
+
+        if fields is None:
+            fields = kwargs
+        elif kwargs:
+            raise TypeError("TypedDict takes either a dict or keyword arguments,"
+                            " but not both")
+
+        ns = {'__annotations__': dict(fields)}
+        try:
+            # Setting correct module is necessary to make typed dict classes pickleable.
+            ns['__module__'] = sys._getframe(1).f_globals.get('__name__', '__main__')
+        except (AttributeError, ValueError):
+            pass
+
+        return _TypedDictMeta(typename, (), ns, total=total)
+
+    _typeddict_new.__text_signature__ = ('($cls, _typename, _fields=None,'
+                                         ' /, *, total=True, **kwargs)')
+
+    class _TypedDictMeta(type):
+        def __init__(cls, name, bases, ns, total=True):
+            super().__init__(name, bases, ns)
+
+        def __new__(cls, name, bases, ns, total=True):
+            # Create new typed dict class object.
+            # This method is called directly when TypedDict is subclassed,
+            # or via _typeddict_new when TypedDict is instantiated. This way
+            # TypedDict supports all three syntaxes described in its docstring.
+            # Subclasses and instances of TypedDict return actual dictionaries
+            # via _dict_new.
+            ns['__new__'] = _typeddict_new if name == 'TypedDict' else _dict_new
+            # Don't insert typing.Generic into __bases__ here,
+            # or Generic.__init_subclass__ will raise TypeError
+            # in the super().__new__() call.
+            # Instead, monkey-patch __bases__ onto the class after it's been created.
+            tp_dict = super().__new__(cls, name, (dict,), ns)
+
+            if any(issubclass(base, typing.Generic) for base in bases):
+                tp_dict.__bases__ = (typing.Generic, dict)
+                _maybe_adjust_parameters(tp_dict)
+
+            annotations = {}
+            own_annotations = ns.get('__annotations__', {})
+            msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type"
+            own_annotations = {
+                n: typing._type_check(tp, msg) for n, tp in own_annotations.items()
+            }
+            required_keys = set()
+            optional_keys = set()
+
+            for base in bases:
+                annotations.update(base.__dict__.get('__annotations__', {}))
+                required_keys.update(base.__dict__.get('__required_keys__', ()))
+                optional_keys.update(base.__dict__.get('__optional_keys__', ()))
+
+            annotations.update(own_annotations)
+            for annotation_key, annotation_type in own_annotations.items():
+                annotation_origin = get_origin(annotation_type)
+                if annotation_origin is Annotated:
+                    annotation_args = get_args(annotation_type)
+                    if annotation_args:
+                        annotation_type = annotation_args[0]
+                        annotation_origin = get_origin(annotation_type)
+
+                if annotation_origin is Required:
+                    required_keys.add(annotation_key)
+                elif annotation_origin is NotRequired:
+                    optional_keys.add(annotation_key)
+                elif total:
+                    required_keys.add(annotation_key)
+                else:
+                    optional_keys.add(annotation_key)
+
+            tp_dict.__annotations__ = annotations
+            tp_dict.__required_keys__ = frozenset(required_keys)
+            tp_dict.__optional_keys__ = frozenset(optional_keys)
+            if not hasattr(tp_dict, '__total__'):
+                tp_dict.__total__ = total
+            return tp_dict
+
+        __instancecheck__ = __subclasscheck__ = _check_fails
+
+    TypedDict = _TypedDictMeta('TypedDict', (dict,), {})
+    TypedDict.__module__ = __name__
+    TypedDict.__doc__ = \
+        """A simple typed name space. At runtime it is equivalent to a plain dict.
+
+        TypedDict creates a dictionary type that expects all of its
+        instances to have a certain set of keys, with each key
+        associated with a value of a consistent type. This expectation
+        is not checked at runtime but is only enforced by type checkers.
+        Usage::
+
+            class Point2D(TypedDict):
+                x: int
+                y: int
+                label: str
+
+            a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
+            b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check
+
+            assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')
+
+        The type info can be accessed via the Point2D.__annotations__ dict, and
+        the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets.
+        TypedDict supports two additional equivalent forms::
+
+            Point2D = TypedDict('Point2D', x=int, y=int, label=str)
+            Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
+
+        The class syntax is only supported in Python 3.6+, while two other
+        syntax forms work for Python 2.7 and 3.2+
+        """
+
+    if hasattr(typing, "_TypedDictMeta"):
+        _TYPEDDICT_TYPES = (typing._TypedDictMeta, _TypedDictMeta)
+    else:
+        _TYPEDDICT_TYPES = (_TypedDictMeta,)
+
+    def is_typeddict(tp):
+        """Check if an annotation is a TypedDict class
+
+        For example::
+            class Film(TypedDict):
+                title: str
+                year: int
+
+            is_typeddict(Film)  # => True
+            is_typeddict(Union[list, str])  # => False
+        """
+        return isinstance(tp, tuple(_TYPEDDICT_TYPES))
+
+
+if hasattr(typing, "assert_type"):
+    assert_type = typing.assert_type
+
+else:
+    def assert_type(__val, __typ):
+        """Assert (to the type checker) that the value is of the given type.
+
+        When the type checker encounters a call to assert_type(), it
+        emits an error if the value is not of the specified type::
+
+            def greet(name: str) -> None:
+                assert_type(name, str)  # ok
+                assert_type(name, int)  # type checker error
+
+        At runtime this returns the first argument unchanged and otherwise
+        does nothing.
+        """
+        return __val
+
+
+if hasattr(typing, "Required"):
+    get_type_hints = typing.get_type_hints
+else:
+    import functools
+    import types
+
+    # replaces _strip_annotations()
+    def _strip_extras(t):
+        """Strips Annotated, Required and NotRequired from a given type."""
+        if isinstance(t, _AnnotatedAlias):
+            return _strip_extras(t.__origin__)
+        if hasattr(t, "__origin__") and t.__origin__ in (Required, NotRequired):
+            return _strip_extras(t.__args__[0])
+        if isinstance(t, typing._GenericAlias):
+            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
+            if stripped_args == t.__args__:
+                return t
+            return t.copy_with(stripped_args)
+        if hasattr(types, "GenericAlias") and isinstance(t, types.GenericAlias):
+            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
+            if stripped_args == t.__args__:
+                return t
+            return types.GenericAlias(t.__origin__, stripped_args)
+        if hasattr(types, "UnionType") and isinstance(t, types.UnionType):
+            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
+            if stripped_args == t.__args__:
+                return t
+            return functools.reduce(operator.or_, stripped_args)
+
+        return t
+
+    def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
+        """Return type hints for an object.
+
+        This is often the same as obj.__annotations__, but it handles
+        forward references encoded as string literals, adds Optional[t] if a
+        default value equal to None is set and recursively replaces all
+        'Annotated[T, ...]', 'Required[T]' or 'NotRequired[T]' with 'T'
+        (unless 'include_extras=True').
+
+        The argument may be a module, class, method, or function. The annotations
+        are returned as a dictionary. For classes, annotations include also
+        inherited members.
+
+        TypeError is raised if the argument is not of a type that can contain
+        annotations, and an empty dictionary is returned if no annotations are
+        present.
+
+        BEWARE -- the behavior of globalns and localns is counterintuitive
+        (unless you are familiar with how eval() and exec() work).  The
+        search order is locals first, then globals.
+
+        - If no dict arguments are passed, an attempt is made to use the
+          globals from obj (or the respective module's globals for classes),
+          and these are also used as the locals.  If the object does not appear
+          to have globals, an empty dictionary is used.
+
+        - If one dict argument is passed, it is used for both globals and
+          locals.
+
+        - If two dict arguments are passed, they specify globals and
+          locals, respectively.
+        """
+        if hasattr(typing, "Annotated"):
+            hint = typing.get_type_hints(
+                obj, globalns=globalns, localns=localns, include_extras=True
+            )
+        else:
+            hint = typing.get_type_hints(obj, globalns=globalns, localns=localns)
+        if include_extras:
+            return hint
+        return {k: _strip_extras(t) for k, t in hint.items()}
+
+
+# Python 3.9+ has PEP 593 (Annotated)
+if hasattr(typing, 'Annotated'):
+    Annotated = typing.Annotated
+    # Not exported and not a public API, but needed for get_origin() and get_args()
+    # to work.
+    _AnnotatedAlias = typing._AnnotatedAlias
+# 3.7-3.8
+else:
+    class _AnnotatedAlias(typing._GenericAlias, _root=True):
+        """Runtime representation of an annotated type.
+
+        At its core 'Annotated[t, dec1, dec2, ...]' is an alias for the type 't'
+        with extra annotations. The alias behaves like a normal typing alias,
+        instantiating is the same as instantiating the underlying type, binding
+        it to types is also the same.
+        """
+        def __init__(self, origin, metadata):
+            if isinstance(origin, _AnnotatedAlias):
+                metadata = origin.__metadata__ + metadata
+                origin = origin.__origin__
+            super().__init__(origin, origin)
+            self.__metadata__ = metadata
+
+        def copy_with(self, params):
+            assert len(params) == 1
+            new_type = params[0]
+            return _AnnotatedAlias(new_type, self.__metadata__)
+
+        def __repr__(self):
+            return (f"typing_extensions.Annotated[{typing._type_repr(self.__origin__)}, "
+                    f"{', '.join(repr(a) for a in self.__metadata__)}]")
+
+        def __reduce__(self):
+            return operator.getitem, (
+                Annotated, (self.__origin__,) + self.__metadata__
+            )
+
+        def __eq__(self, other):
+            if not isinstance(other, _AnnotatedAlias):
+                return NotImplemented
+            if self.__origin__ != other.__origin__:
+                return False
+            return self.__metadata__ == other.__metadata__
+
+        def __hash__(self):
+            return hash((self.__origin__, self.__metadata__))
+
+    class Annotated:
+        """Add context specific metadata to a type.
+
+        Example: Annotated[int, runtime_check.Unsigned] indicates to the
+        hypothetical runtime_check module that this type is an unsigned int.
+        Every other consumer of this type can ignore this metadata and treat
+        this type as int.
+
+        The first argument to Annotated must be a valid type (and will be in
+        the __origin__ field), the remaining arguments are kept as a tuple in
+        the __extra__ field.
+
+        Details:
+
+        - It's an error to call `Annotated` with less than two arguments.
+        - Nested Annotated are flattened::
+
+            Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3]
+
+        - Instantiating an annotated type is equivalent to instantiating the
+        underlying type::
+
+            Annotated[C, Ann1](5) == C(5)
+
+        - Annotated can be used as a generic type alias::
+
+            Optimized = Annotated[T, runtime.Optimize()]
+            Optimized[int] == Annotated[int, runtime.Optimize()]
+
+            OptimizedList = Annotated[List[T], runtime.Optimize()]
+            OptimizedList[int] == Annotated[List[int], runtime.Optimize()]
+        """
+
+        __slots__ = ()
+
+        def __new__(cls, *args, **kwargs):
+            raise TypeError("Type Annotated cannot be instantiated.")
+
+        @typing._tp_cache
+        def __class_getitem__(cls, params):
+            if not isinstance(params, tuple) or len(params) < 2:
+                raise TypeError("Annotated[...] should be used "
+                                "with at least two arguments (a type and an "
+                                "annotation).")
+            allowed_special_forms = (ClassVar, Final)
+            if get_origin(params[0]) in allowed_special_forms:
+                origin = params[0]
+            else:
+                msg = "Annotated[t, ...]: t must be a type."
+                origin = typing._type_check(params[0], msg)
+            metadata = tuple(params[1:])
+            return _AnnotatedAlias(origin, metadata)
+
+        def __init_subclass__(cls, *args, **kwargs):
+            raise TypeError(
+                f"Cannot subclass {cls.__module__}.Annotated"
+            )
+
+# Python 3.8 has get_origin() and get_args() but those implementations aren't
+# Annotated-aware, so we can't use those. Python 3.9's versions don't support
+# ParamSpecArgs and ParamSpecKwargs, so only Python 3.10's versions will do.
+if sys.version_info[:2] >= (3, 10):
+    get_origin = typing.get_origin
+    get_args = typing.get_args
+# 3.7-3.9
+else:
+    try:
+        # 3.9+
+        from typing import _BaseGenericAlias
+    except ImportError:
+        _BaseGenericAlias = typing._GenericAlias
+    try:
+        # 3.9+
+        from typing import GenericAlias as _typing_GenericAlias
+    except ImportError:
+        _typing_GenericAlias = typing._GenericAlias
+
+    def get_origin(tp):
+        """Get the unsubscripted version of a type.
+
+        This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar
+        and Annotated. Return None for unsupported types. Examples::
+
+            get_origin(Literal[42]) is Literal
+            get_origin(int) is None
+            get_origin(ClassVar[int]) is ClassVar
+            get_origin(Generic) is Generic
+            get_origin(Generic[T]) is Generic
+            get_origin(Union[T, int]) is Union
+            get_origin(List[Tuple[T, T]][int]) == list
+            get_origin(P.args) is P
+        """
+        if isinstance(tp, _AnnotatedAlias):
+            return Annotated
+        if isinstance(tp, (typing._GenericAlias, _typing_GenericAlias, _BaseGenericAlias,
+                           ParamSpecArgs, ParamSpecKwargs)):
+            return tp.__origin__
+        if tp is typing.Generic:
+            return typing.Generic
+        return None
+
+    def get_args(tp):
+        """Get type arguments with all substitutions performed.
+
+        For unions, basic simplifications used by Union constructor are performed.
+        Examples::
+            get_args(Dict[str, int]) == (str, int)
+            get_args(int) == ()
+            get_args(Union[int, Union[T, int], str][int]) == (int, str)
+            get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
+            get_args(Callable[[], T][int]) == ([], int)
+        """
+        if isinstance(tp, _AnnotatedAlias):
+            return (tp.__origin__,) + tp.__metadata__
+        if isinstance(tp, (typing._GenericAlias, _typing_GenericAlias)):
+            if getattr(tp, "_special", False):
+                return ()
+            res = tp.__args__
+            if get_origin(tp) is collections.abc.Callable and res[0] is not Ellipsis:
+                res = (list(res[:-1]), res[-1])
+            return res
+        return ()
+
+
+# 3.10+
+if hasattr(typing, 'TypeAlias'):
+    TypeAlias = typing.TypeAlias
+# 3.9
+elif sys.version_info[:2] >= (3, 9):
+    class _TypeAliasForm(typing._SpecialForm, _root=True):
+        def __repr__(self):
+            return 'typing_extensions.' + self._name
+
+    @_TypeAliasForm
+    def TypeAlias(self, parameters):
+        """Special marker indicating that an assignment should
+        be recognized as a proper type alias definition by type
+        checkers.
+
+        For example::
+
+            Predicate: TypeAlias = Callable[..., bool]
+
+        It's invalid when used anywhere except as in the example above.
+        """
+        raise TypeError(f"{self} is not subscriptable")
+# 3.7-3.8
+else:
+    class _TypeAliasForm(typing._SpecialForm, _root=True):
+        def __repr__(self):
+            return 'typing_extensions.' + self._name
+
+    TypeAlias = _TypeAliasForm('TypeAlias',
+                               doc="""Special marker indicating that an assignment should
+                               be recognized as a proper type alias definition by type
+                               checkers.
+
+                               For example::
+
+                                   Predicate: TypeAlias = Callable[..., bool]
+
+                               It's invalid when used anywhere except as in the example
+                               above.""")
+
+
+# Python 3.10+ has PEP 612
+if hasattr(typing, 'ParamSpecArgs'):
+    ParamSpecArgs = typing.ParamSpecArgs
+    ParamSpecKwargs = typing.ParamSpecKwargs
+# 3.7-3.9
+else:
+    class _Immutable:
+        """Mixin to indicate that object should not be copied."""
+        __slots__ = ()
+
+        def __copy__(self):
+            return self
+
+        def __deepcopy__(self, memo):
+            return self
+
+    class ParamSpecArgs(_Immutable):
+        """The args for a ParamSpec object.
+
+        Given a ParamSpec object P, P.args is an instance of ParamSpecArgs.
+
+        ParamSpecArgs objects have a reference back to their ParamSpec:
+
+        P.args.__origin__ is P
+
+        This type is meant for runtime introspection and has no special meaning to
+        static type checkers.
+        """
+        def __init__(self, origin):
+            self.__origin__ = origin
+
+        def __repr__(self):
+            return f"{self.__origin__.__name__}.args"
+
+        def __eq__(self, other):
+            if not isinstance(other, ParamSpecArgs):
+                return NotImplemented
+            return self.__origin__ == other.__origin__
+
+    class ParamSpecKwargs(_Immutable):
+        """The kwargs for a ParamSpec object.
+
+        Given a ParamSpec object P, P.kwargs is an instance of ParamSpecKwargs.
+
+        ParamSpecKwargs objects have a reference back to their ParamSpec:
+
+        P.kwargs.__origin__ is P
+
+        This type is meant for runtime introspection and has no special meaning to
+        static type checkers.
+        """
+        def __init__(self, origin):
+            self.__origin__ = origin
+
+        def __repr__(self):
+            return f"{self.__origin__.__name__}.kwargs"
+
+        def __eq__(self, other):
+            if not isinstance(other, ParamSpecKwargs):
+                return NotImplemented
+            return self.__origin__ == other.__origin__
+
+# 3.10+
+if hasattr(typing, 'ParamSpec'):
+    ParamSpec = typing.ParamSpec
+# 3.7-3.9
+else:
+
+    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
+    class ParamSpec(list):
+        """Parameter specification variable.
+
+        Usage::
+
+           P = ParamSpec('P')
+
+        Parameter specification variables exist primarily for the benefit of static
+        type checkers.  They are used to forward the parameter types of one
+        callable to another callable, a pattern commonly found in higher order
+        functions and decorators.  They are only valid when used in ``Concatenate``,
+        or s the first argument to ``Callable``. In Python 3.10 and higher,
+        they are also supported in user-defined Generics at runtime.
+        See class Generic for more information on generic types.  An
+        example for annotating a decorator::
+
+           T = TypeVar('T')
+           P = ParamSpec('P')
+
+           def add_logging(f: Callable[P, T]) -> Callable[P, T]:
+               '''A type-safe decorator to add logging to a function.'''
+               def inner(*args: P.args, **kwargs: P.kwargs) -> T:
+                   logging.info(f'{f.__name__} was called')
+                   return f(*args, **kwargs)
+               return inner
+
+           @add_logging
+           def add_two(x: float, y: float) -> float:
+               '''Add two numbers together.'''
+               return x + y
+
+        Parameter specification variables defined with covariant=True or
+        contravariant=True can be used to declare covariant or contravariant
+        generic types.  These keyword arguments are valid, but their actual semantics
+        are yet to be decided.  See PEP 612 for details.
+
+        Parameter specification variables can be introspected. e.g.:
+
+           P.__name__ == 'T'
+           P.__bound__ == None
+           P.__covariant__ == False
+           P.__contravariant__ == False
+
+        Note that only parameter specification variables defined in global scope can
+        be pickled.
+        """
+
+        # Trick Generic __parameters__.
+        __class__ = typing.TypeVar
+
+        @property
+        def args(self):
+            return ParamSpecArgs(self)
+
+        @property
+        def kwargs(self):
+            return ParamSpecKwargs(self)
+
+        def __init__(self, name, *, bound=None, covariant=False, contravariant=False):
+            super().__init__([self])
+            self.__name__ = name
+            self.__covariant__ = bool(covariant)
+            self.__contravariant__ = bool(contravariant)
+            if bound:
+                self.__bound__ = typing._type_check(bound, 'Bound must be a type.')
+            else:
+                self.__bound__ = None
+
+            # for pickling:
+            try:
+                def_mod = sys._getframe(1).f_globals.get('__name__', '__main__')
+            except (AttributeError, ValueError):
+                def_mod = None
+            if def_mod != 'typing_extensions':
+                self.__module__ = def_mod
+
+        def __repr__(self):
+            if self.__covariant__:
+                prefix = '+'
+            elif self.__contravariant__:
+                prefix = '-'
+            else:
+                prefix = '~'
+            return prefix + self.__name__
+
+        def __hash__(self):
+            return object.__hash__(self)
+
+        def __eq__(self, other):
+            return self is other
+
+        def __reduce__(self):
+            return self.__name__
+
+        # Hack to get typing._type_check to pass.
+        def __call__(self, *args, **kwargs):
+            pass
+
+
+# 3.7-3.9
+if not hasattr(typing, 'Concatenate'):
+    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
+    class _ConcatenateGenericAlias(list):
+
+        # Trick Generic into looking into this for __parameters__.
+        __class__ = typing._GenericAlias
+
+        # Flag in 3.8.
+        _special = False
+
+        def __init__(self, origin, args):
+            super().__init__(args)
+            self.__origin__ = origin
+            self.__args__ = args
+
+        def __repr__(self):
+            _type_repr = typing._type_repr
+            return (f'{_type_repr(self.__origin__)}'
+                    f'[{", ".join(_type_repr(arg) for arg in self.__args__)}]')
+
+        def __hash__(self):
+            return hash((self.__origin__, self.__args__))
+
+        # Hack to get typing._type_check to pass in Generic.
+        def __call__(self, *args, **kwargs):
+            pass
+
+        @property
+        def __parameters__(self):
+            return tuple(
+                tp for tp in self.__args__ if isinstance(tp, (typing.TypeVar, ParamSpec))
+            )
+
+
+# 3.7-3.9
+@typing._tp_cache
+def _concatenate_getitem(self, parameters):
+    if parameters == ():
+        raise TypeError("Cannot take a Concatenate of no types.")
+    if not isinstance(parameters, tuple):
+        parameters = (parameters,)
+    if not isinstance(parameters[-1], ParamSpec):
+        raise TypeError("The last parameter to Concatenate should be a "
+                        "ParamSpec variable.")
+    msg = "Concatenate[arg, ...]: each arg must be a type."
+    parameters = tuple(typing._type_check(p, msg) for p in parameters)
+    return _ConcatenateGenericAlias(self, parameters)
+
+
+# 3.10+
+if hasattr(typing, 'Concatenate'):
+    Concatenate = typing.Concatenate
+    _ConcatenateGenericAlias = typing._ConcatenateGenericAlias # noqa
+# 3.9
+elif sys.version_info[:2] >= (3, 9):
+    @_TypeAliasForm
+    def Concatenate(self, parameters):
+        """Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
+        higher order function which adds, removes or transforms parameters of a
+        callable.
+
+        For example::
+
+           Callable[Concatenate[int, P], int]
+
+        See PEP 612 for detailed information.
+        """
+        return _concatenate_getitem(self, parameters)
+# 3.7-8
+else:
+    class _ConcatenateForm(typing._SpecialForm, _root=True):
+        def __repr__(self):
+            return 'typing_extensions.' + self._name
+
+        def __getitem__(self, parameters):
+            return _concatenate_getitem(self, parameters)
+
+    Concatenate = _ConcatenateForm(
+        'Concatenate',
+        doc="""Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
+        higher order function which adds, removes or transforms parameters of a
+        callable.
+
+        For example::
+
+           Callable[Concatenate[int, P], int]
+
+        See PEP 612 for detailed information.
+        """)
+
+# 3.10+
+if hasattr(typing, 'TypeGuard'):
+    TypeGuard = typing.TypeGuard
+# 3.9
+elif sys.version_info[:2] >= (3, 9):
+    class _TypeGuardForm(typing._SpecialForm, _root=True):
+        def __repr__(self):
+            return 'typing_extensions.' + self._name
+
+    @_TypeGuardForm
+    def TypeGuard(self, parameters):
+        """Special typing form used to annotate the return type of a user-defined
+        type guard function.  ``TypeGuard`` only accepts a single type argument.
+        At runtime, functions marked this way should return a boolean.
+
+        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
+        type checkers to determine a more precise type of an expression within a
+        program's code flow.  Usually type narrowing is done by analyzing
+        conditional code flow and applying the narrowing to a block of code.  The
+        conditional expression here is sometimes referred to as a "type guard".
+
+        Sometimes it would be convenient to use a user-defined boolean function
+        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
+        return type to alert static type checkers to this intention.
+
+        Using  ``-> TypeGuard`` tells the static type checker that for a given
+        function:
+
+        1. The return value is a boolean.
+        2. If the return value is ``True``, the type of its argument
+        is the type inside ``TypeGuard``.
+
+        For example::
+
+            def is_str(val: Union[str, float]):
+                # "isinstance" type guard
+                if isinstance(val, str):
+                    # Type of ``val`` is narrowed to ``str``
+                    ...
+                else:
+                    # Else, type of ``val`` is narrowed to ``float``.
+                    ...
+
+        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
+        form of ``TypeA`` (it can even be a wider form) and this may lead to
+        type-unsafe results.  The main reason is to allow for things like
+        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
+        a subtype of the former, since ``List`` is invariant.  The responsibility of
+        writing type-safe type guards is left to the user.
+
+        ``TypeGuard`` also works with type variables.  For more information, see
+        PEP 647 (User-Defined Type Guards).
+        """
+        item = typing._type_check(parameters, f'{self} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+# 3.7-3.8
+else:
+    class _TypeGuardForm(typing._SpecialForm, _root=True):
+
+        def __repr__(self):
+            return 'typing_extensions.' + self._name
+
+        def __getitem__(self, parameters):
+            item = typing._type_check(parameters,
+                                      f'{self._name} accepts only a single type')
+            return typing._GenericAlias(self, (item,))
+
+    TypeGuard = _TypeGuardForm(
+        'TypeGuard',
+        doc="""Special typing form used to annotate the return type of a user-defined
+        type guard function.  ``TypeGuard`` only accepts a single type argument.
+        At runtime, functions marked this way should return a boolean.
+
+        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
+        type checkers to determine a more precise type of an expression within a
+        program's code flow.  Usually type narrowing is done by analyzing
+        conditional code flow and applying the narrowing to a block of code.  The
+        conditional expression here is sometimes referred to as a "type guard".
+
+        Sometimes it would be convenient to use a user-defined boolean function
+        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
+        return type to alert static type checkers to this intention.
+
+        Using  ``-> TypeGuard`` tells the static type checker that for a given
+        function:
+
+        1. The return value is a boolean.
+        2. If the return value is ``True``, the type of its argument
+        is the type inside ``TypeGuard``.
+
+        For example::
+
+            def is_str(val: Union[str, float]):
+                # "isinstance" type guard
+                if isinstance(val, str):
+                    # Type of ``val`` is narrowed to ``str``
+                    ...
+                else:
+                    # Else, type of ``val`` is narrowed to ``float``.
+                    ...
+
+        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
+        form of ``TypeA`` (it can even be a wider form) and this may lead to
+        type-unsafe results.  The main reason is to allow for things like
+        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
+        a subtype of the former, since ``List`` is invariant.  The responsibility of
+        writing type-safe type guards is left to the user.
+
+        ``TypeGuard`` also works with type variables.  For more information, see
+        PEP 647 (User-Defined Type Guards).
+        """)
+
+
+# Vendored from cpython typing._SpecialFrom
+class _SpecialForm(typing._Final, _root=True):
+    __slots__ = ('_name', '__doc__', '_getitem')
+
+    def __init__(self, getitem):
+        self._getitem = getitem
+        self._name = getitem.__name__
+        self.__doc__ = getitem.__doc__
+
+    def __getattr__(self, item):
+        if item in {'__name__', '__qualname__'}:
+            return self._name
+
+        raise AttributeError(item)
+
+    def __mro_entries__(self, bases):
+        raise TypeError(f"Cannot subclass {self!r}")
+
+    def __repr__(self):
+        return f'typing_extensions.{self._name}'
+
+    def __reduce__(self):
+        return self._name
+
+    def __call__(self, *args, **kwds):
+        raise TypeError(f"Cannot instantiate {self!r}")
+
+    def __or__(self, other):
+        return typing.Union[self, other]
+
+    def __ror__(self, other):
+        return typing.Union[other, self]
+
+    def __instancecheck__(self, obj):
+        raise TypeError(f"{self} cannot be used with isinstance()")
+
+    def __subclasscheck__(self, cls):
+        raise TypeError(f"{self} cannot be used with issubclass()")
+
+    @typing._tp_cache
+    def __getitem__(self, parameters):
+        return self._getitem(self, parameters)
+
+
+if hasattr(typing, "LiteralString"):
+    LiteralString = typing.LiteralString
+else:
+    @_SpecialForm
+    def LiteralString(self, params):
+        """Represents an arbitrary literal string.
+
+        Example::
+
+          from typing_extensions import LiteralString
+
+          def query(sql: LiteralString) -> ...:
+              ...
+
+          query("SELECT * FROM table")  # ok
+          query(f"SELECT * FROM {input()}")  # not ok
+
+        See PEP 675 for details.
+
+        """
+        raise TypeError(f"{self} is not subscriptable")
+
+
+if hasattr(typing, "Self"):
+    Self = typing.Self
+else:
+    @_SpecialForm
+    def Self(self, params):
+        """Used to spell the type of "self" in classes.
+
+        Example::
+
+          from typing import Self
+
+          class ReturnsSelf:
+              def parse(self, data: bytes) -> Self:
+                  ...
+                  return self
+
+        """
+
+        raise TypeError(f"{self} is not subscriptable")
+
+
+if hasattr(typing, "Never"):
+    Never = typing.Never
+else:
+    @_SpecialForm
+    def Never(self, params):
+        """The bottom type, a type that has no members.
+
+        This can be used to define a function that should never be
+        called, or a function that never returns::
+
+            from typing_extensions import Never
+
+            def never_call_me(arg: Never) -> None:
+                pass
+
+            def int_or_str(arg: int | str) -> None:
+                never_call_me(arg)  # type checker error
+                match arg:
+                    case int():
+                        print("It's an int")
+                    case str():
+                        print("It's a str")
+                    case _:
+                        never_call_me(arg)  # ok, arg is of type Never
+
+        """
+
+        raise TypeError(f"{self} is not subscriptable")
+
+
+if hasattr(typing, 'Required'):
+    Required = typing.Required
+    NotRequired = typing.NotRequired
+elif sys.version_info[:2] >= (3, 9):
+    class _ExtensionsSpecialForm(typing._SpecialForm, _root=True):
+        def __repr__(self):
+            return 'typing_extensions.' + self._name
+
+    @_ExtensionsSpecialForm
+    def Required(self, parameters):
+        """A special typing construct to mark a key of a total=False TypedDict
+        as required. For example:
+
+            class Movie(TypedDict, total=False):
+                title: Required[str]
+                year: int
+
+            m = Movie(
+                title='The Matrix',  # typechecker error if key is omitted
+                year=1999,
+            )
+
+        There is no runtime checking that a required key is actually provided
+        when instantiating a related TypedDict.
+        """
+        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+
+    @_ExtensionsSpecialForm
+    def NotRequired(self, parameters):
+        """A special typing construct to mark a key of a TypedDict as
+        potentially missing. For example:
+
+            class Movie(TypedDict):
+                title: str
+                year: NotRequired[int]
+
+            m = Movie(
+                title='The Matrix',  # typechecker error if key is omitted
+                year=1999,
+            )
+        """
+        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+
+else:
+    class _RequiredForm(typing._SpecialForm, _root=True):
+        def __repr__(self):
+            return 'typing_extensions.' + self._name
+
+        def __getitem__(self, parameters):
+            item = typing._type_check(parameters,
+                                      f'{self._name} accepts only a single type.')
+            return typing._GenericAlias(self, (item,))
+
+    Required = _RequiredForm(
+        'Required',
+        doc="""A special typing construct to mark a key of a total=False TypedDict
+        as required. For example:
+
+            class Movie(TypedDict, total=False):
+                title: Required[str]
+                year: int
+
+            m = Movie(
+                title='The Matrix',  # typechecker error if key is omitted
+                year=1999,
+            )
+
+        There is no runtime checking that a required key is actually provided
+        when instantiating a related TypedDict.
+        """)
+    NotRequired = _RequiredForm(
+        'NotRequired',
+        doc="""A special typing construct to mark a key of a TypedDict as
+        potentially missing. For example:
+
+            class Movie(TypedDict):
+                title: str
+                year: NotRequired[int]
+
+            m = Movie(
+                title='The Matrix',  # typechecker error if key is omitted
+                year=1999,
+            )
+        """)
+
+
+if hasattr(typing, "Unpack"):  # 3.11+
+    Unpack = typing.Unpack
+elif sys.version_info[:2] >= (3, 9):
+    class _UnpackSpecialForm(typing._SpecialForm, _root=True):
+        def __repr__(self):
+            return 'typing_extensions.' + self._name
+
+    class _UnpackAlias(typing._GenericAlias, _root=True):
+        __class__ = typing.TypeVar
+
+    @_UnpackSpecialForm
+    def Unpack(self, parameters):
+        """A special typing construct to unpack a variadic type. For example:
+
+            Shape = TypeVarTuple('Shape')
+            Batch = NewType('Batch', int)
+
+            def add_batch_axis(
+                x: Array[Unpack[Shape]]
+            ) -> Array[Batch, Unpack[Shape]]: ...
+
+        """
+        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
+        return _UnpackAlias(self, (item,))
+
+    def _is_unpack(obj):
+        return isinstance(obj, _UnpackAlias)
+
+else:
+    class _UnpackAlias(typing._GenericAlias, _root=True):
+        __class__ = typing.TypeVar
+
+    class _UnpackForm(typing._SpecialForm, _root=True):
+        def __repr__(self):
+            return 'typing_extensions.' + self._name
+
+        def __getitem__(self, parameters):
+            item = typing._type_check(parameters,
+                                      f'{self._name} accepts only a single type.')
+            return _UnpackAlias(self, (item,))
+
+    Unpack = _UnpackForm(
+        'Unpack',
+        doc="""A special typing construct to unpack a variadic type. For example:
+
+            Shape = TypeVarTuple('Shape')
+            Batch = NewType('Batch', int)
+
+            def add_batch_axis(
+                x: Array[Unpack[Shape]]
+            ) -> Array[Batch, Unpack[Shape]]: ...
+
+        """)
+
+    def _is_unpack(obj):
+        return isinstance(obj, _UnpackAlias)
+
+
+if hasattr(typing, "TypeVarTuple"):  # 3.11+
+    TypeVarTuple = typing.TypeVarTuple
+else:
+    class TypeVarTuple:
+        """Type variable tuple.
+
+        Usage::
+
+            Ts = TypeVarTuple('Ts')
+
+        In the same way that a normal type variable is a stand-in for a single
+        type such as ``int``, a type variable *tuple* is a stand-in for a *tuple*
+        type such as ``Tuple[int, str]``.
+
+        Type variable tuples can be used in ``Generic`` declarations.
+        Consider the following example::
+
+            class Array(Generic[*Ts]): ...
+
+        The ``Ts`` type variable tuple here behaves like ``tuple[T1, T2]``,
+        where ``T1`` and ``T2`` are type variables. To use these type variables
+        as type parameters of ``Array``, we must *unpack* the type variable tuple using
+        the star operator: ``*Ts``. The signature of ``Array`` then behaves
+        as if we had simply written ``class Array(Generic[T1, T2]): ...``.
+        In contrast to ``Generic[T1, T2]``, however, ``Generic[*Shape]`` allows
+        us to parameterise the class with an *arbitrary* number of type parameters.
+
+        Type variable tuples can be used anywhere a normal ``TypeVar`` can.
+        This includes class definitions, as shown above, as well as function
+        signatures and variable annotations::
+
+            class Array(Generic[*Ts]):
+
+                def __init__(self, shape: Tuple[*Ts]):
+                    self._shape: Tuple[*Ts] = shape
+
+                def get_shape(self) -> Tuple[*Ts]:
+                    return self._shape
+
+            shape = (Height(480), Width(640))
+            x: Array[Height, Width] = Array(shape)
+            y = abs(x)  # Inferred type is Array[Height, Width]
+            z = x + x   #        ...    is Array[Height, Width]
+            x.get_shape()  #     ...    is tuple[Height, Width]
+
+        """
+
+        # Trick Generic __parameters__.
+        __class__ = typing.TypeVar
+
+        def __iter__(self):
+            yield self.__unpacked__
+
+        def __init__(self, name):
+            self.__name__ = name
+
+            # for pickling:
+            try:
+                def_mod = sys._getframe(1).f_globals.get('__name__', '__main__')
+            except (AttributeError, ValueError):
+                def_mod = None
+            if def_mod != 'typing_extensions':
+                self.__module__ = def_mod
+
+            self.__unpacked__ = Unpack[self]
+
+        def __repr__(self):
+            return self.__name__
+
+        def __hash__(self):
+            return object.__hash__(self)
+
+        def __eq__(self, other):
+            return self is other
+
+        def __reduce__(self):
+            return self.__name__
+
+        def __init_subclass__(self, *args, **kwds):
+            if '_root' not in kwds:
+                raise TypeError("Cannot subclass special typing classes")
+
+
+if hasattr(typing, "reveal_type"):
+    reveal_type = typing.reveal_type
+else:
+    def reveal_type(__obj: T) -> T:
+        """Reveal the inferred type of a variable.
+
+        When a static type checker encounters a call to ``reveal_type()``,
+        it will emit the inferred type of the argument::
+
+            x: int = 1
+            reveal_type(x)
+
+        Running a static type checker (e.g., ``mypy``) on this example
+        will produce output similar to 'Revealed type is "builtins.int"'.
+
+        At runtime, the function prints the runtime type of the
+        argument and returns it unchanged.
+
+        """
+        print(f"Runtime type is {type(__obj).__name__!r}", file=sys.stderr)
+        return __obj
+
+
+if hasattr(typing, "assert_never"):
+    assert_never = typing.assert_never
+else:
+    def assert_never(__arg: Never) -> Never:
+        """Assert to the type checker that a line of code is unreachable.
+
+        Example::
+
+            def int_or_str(arg: int | str) -> None:
+                match arg:
+                    case int():
+                        print("It's an int")
+                    case str():
+                        print("It's a str")
+                    case _:
+                        assert_never(arg)
+
+        If a type checker finds that a call to assert_never() is
+        reachable, it will emit an error.
+
+        At runtime, this throws an exception when called.
+
+        """
+        raise AssertionError("Expected code to be unreachable")
+
+
+if hasattr(typing, 'dataclass_transform'):
+    dataclass_transform = typing.dataclass_transform
+else:
+    def dataclass_transform(
+        *,
+        eq_default: bool = True,
+        order_default: bool = False,
+        kw_only_default: bool = False,
+        field_specifiers: typing.Tuple[
+            typing.Union[typing.Type[typing.Any], typing.Callable[..., typing.Any]],
+            ...
+        ] = (),
+        **kwargs: typing.Any,
+    ) -> typing.Callable[[T], T]:
+        """Decorator that marks a function, class, or metaclass as providing
+        dataclass-like behavior.
+
+        Example:
+
+            from typing_extensions import dataclass_transform
+
+            _T = TypeVar("_T")
+
+            # Used on a decorator function
+            @dataclass_transform()
+            def create_model(cls: type[_T]) -> type[_T]:
+                ...
+                return cls
+
+            @create_model
+            class CustomerModel:
+                id: int
+                name: str
+
+            # Used on a base class
+            @dataclass_transform()
+            class ModelBase: ...
+
+            class CustomerModel(ModelBase):
+                id: int
+                name: str
+
+            # Used on a metaclass
+            @dataclass_transform()
+            class ModelMeta(type): ...
+
+            class ModelBase(metaclass=ModelMeta): ...
+
+            class CustomerModel(ModelBase):
+                id: int
+                name: str
+
+        Each of the ``CustomerModel`` classes defined in this example will now
+        behave similarly to a dataclass created with the ``@dataclasses.dataclass``
+        decorator. For example, the type checker will synthesize an ``__init__``
+        method.
+
+        The arguments to this decorator can be used to customize this behavior:
+        - ``eq_default`` indicates whether the ``eq`` parameter is assumed to be
+          True or False if it is omitted by the caller.
+        - ``order_default`` indicates whether the ``order`` parameter is
+          assumed to be True or False if it is omitted by the caller.
+        - ``kw_only_default`` indicates whether the ``kw_only`` parameter is
+          assumed to be True or False if it is omitted by the caller.
+        - ``field_specifiers`` specifies a static list of supported classes
+          or functions that describe fields, similar to ``dataclasses.field()``.
+
+        At runtime, this decorator records its arguments in the
+        ``__dataclass_transform__`` attribute on the decorated object.
+
+        See PEP 681 for details.
+
+        """
+        def decorator(cls_or_fn):
+            cls_or_fn.__dataclass_transform__ = {
+                "eq_default": eq_default,
+                "order_default": order_default,
+                "kw_only_default": kw_only_default,
+                "field_specifiers": field_specifiers,
+                "kwargs": kwargs,
+            }
+            return cls_or_fn
+        return decorator
+
+
+# We have to do some monkey patching to deal with the dual nature of
+# Unpack/TypeVarTuple:
+# - We want Unpack to be a kind of TypeVar so it gets accepted in
+#   Generic[Unpack[Ts]]
+# - We want it to *not* be treated as a TypeVar for the purposes of
+#   counting generic parameters, so that when we subscript a generic,
+#   the runtime doesn't try to substitute the Unpack with the subscripted type.
+if not hasattr(typing, "TypeVarTuple"):
+    typing._collect_type_vars = _collect_type_vars
+    typing._check_generic = _check_generic
+
+
+# Backport typing.NamedTuple as it exists in Python 3.11.
+# In 3.11, the ability to define generic `NamedTuple`s was supported.
+# This was explicitly disallowed in 3.9-3.10, and only half-worked in <=3.8.
+if sys.version_info >= (3, 11):
+    NamedTuple = typing.NamedTuple
+else:
+    def _caller():
+        try:
+            return sys._getframe(2).f_globals.get('__name__', '__main__')
+        except (AttributeError, ValueError):  # For platforms without _getframe()
+            return None
+
+    def _make_nmtuple(name, types, module, defaults=()):
+        fields = [n for n, t in types]
+        annotations = {n: typing._type_check(t, f"field {n} annotation must be a type")
+                       for n, t in types}
+        nm_tpl = collections.namedtuple(name, fields,
+                                        defaults=defaults, module=module)
+        nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = annotations
+        # The `_field_types` attribute was removed in 3.9;
+        # in earlier versions, it is the same as the `__annotations__` attribute
+        if sys.version_info < (3, 9):
+            nm_tpl._field_types = annotations
+        return nm_tpl
+
+    _prohibited_namedtuple_fields = typing._prohibited
+    _special_namedtuple_fields = frozenset({'__module__', '__name__', '__annotations__'})
+
+    class _NamedTupleMeta(type):
+        def __new__(cls, typename, bases, ns):
+            assert _NamedTuple in bases
+            for base in bases:
+                if base is not _NamedTuple and base is not typing.Generic:
+                    raise TypeError(
+                        'can only inherit from a NamedTuple type and Generic')
+            bases = tuple(tuple if base is _NamedTuple else base for base in bases)
+            types = ns.get('__annotations__', {})
+            default_names = []
+            for field_name in types:
+                if field_name in ns:
+                    default_names.append(field_name)
+                elif default_names:
+                    raise TypeError(f"Non-default namedtuple field {field_name} "
+                                    f"cannot follow default field"
+                                    f"{'s' if len(default_names) > 1 else ''} "
+                                    f"{', '.join(default_names)}")
+            nm_tpl = _make_nmtuple(
+                typename, types.items(),
+                defaults=[ns[n] for n in default_names],
+                module=ns['__module__']
+            )
+            nm_tpl.__bases__ = bases
+            if typing.Generic in bases:
+                class_getitem = typing.Generic.__class_getitem__.__func__
+                nm_tpl.__class_getitem__ = classmethod(class_getitem)
+            # update from user namespace without overriding special namedtuple attributes
+            for key in ns:
+                if key in _prohibited_namedtuple_fields:
+                    raise AttributeError("Cannot overwrite NamedTuple attribute " + key)
+                elif key not in _special_namedtuple_fields and key not in nm_tpl._fields:
+                    setattr(nm_tpl, key, ns[key])
+            if typing.Generic in bases:
+                nm_tpl.__init_subclass__()
+            return nm_tpl
+
+    def NamedTuple(__typename, __fields=None, **kwargs):
+        if __fields is None:
+            __fields = kwargs.items()
+        elif kwargs:
+            raise TypeError("Either list of fields or keywords"
+                            " can be provided to NamedTuple, not both")
+        return _make_nmtuple(__typename, __fields, module=_caller())
+
+    NamedTuple.__doc__ = typing.NamedTuple.__doc__
+    _NamedTuple = type.__new__(_NamedTupleMeta, 'NamedTuple', (), {})
+
+    # On 3.8+, alter the signature so that it matches typing.NamedTuple.
+    # The signature of typing.NamedTuple on >=3.8 is invalid syntax in Python 3.7,
+    # so just leave the signature as it is on 3.7.
+    if sys.version_info >= (3, 8):
+        NamedTuple.__text_signature__ = '(typename, fields=None, /, **kwargs)'
+
+    def _namedtuple_mro_entries(bases):
+        assert NamedTuple in bases
+        return (_NamedTuple,)
+
+    NamedTuple.__mro_entries__ = _namedtuple_mro_entries
diff --git a/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/LICENSE.md b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/LICENSE.md
new file mode 100644
index 0000000..37edac5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/LICENSE.md
@@ -0,0 +1,27 @@
+Copyright © 2017-present, [Encode OSS Ltd](http://www.encode.io/).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/METADATA
new file mode 100644
index 0000000..644903d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/METADATA
@@ -0,0 +1,129 @@
+Metadata-Version: 2.1
+Name: uvicorn
+Version: 0.16.0
+Summary: The lightning-fast ASGI server.
+Home-page: https://www.uvicorn.org/
+Author: Tom Christie
+Author-email: tom@tomchristie.com
+License: BSD
+Project-URL: Funding, https://github.com/sponsors/encode
+Project-URL: Source, https://github.com/encode/uvicorn
+Project-URL: Changelog, https://github.com/encode/uvicorn/blob/master/CHANGELOG.md
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Description-Content-Type: text/markdown
+Requires-Dist: asgiref (>=3.4.0)
+Requires-Dist: click (>=7.0)
+Requires-Dist: h11 (>=0.8)
+Requires-Dist: typing-extensions ; python_version < "3.8"
+Provides-Extra: standard
+Requires-Dist: httptools (<0.4.0,>=0.2.0) ; extra == 'standard'
+Requires-Dist: watchgod (>=0.6) ; extra == 'standard'
+Requires-Dist: python-dotenv (>=0.13) ; extra == 'standard'
+Requires-Dist: PyYAML (>=5.1) ; extra == 'standard'
+Requires-Dist: websockets (>=9.1) ; (python_version < "3.7") and extra == 'standard'
+Requires-Dist: websockets (>=10.0) ; (python_version >= "3.7") and extra == 'standard'
+Requires-Dist: uvloop (!=0.15.0,!=0.15.1,>=0.14.0) ; (sys_platform != "win32" and (sys_platform != "cygwin" and platform_python_implementation != "PyPy")) and extra == 'standard'
+Requires-Dist: colorama (>=0.4) ; (sys_platform == "win32") and extra == 'standard'
+
+<p align="center">
+  <img width="320" height="320" src="https://raw.githubusercontent.com/tomchristie/uvicorn/master/docs/uvicorn.png" alt='uvicorn'>
+</p>
+
+<p align="center">
+<em>The lightning-fast ASGI server.</em>
+</p>
+
+---
+
+[![Build Status](https://github.com/encode/uvicorn/workflows/Test%20Suite/badge.svg)](https://github.com/encode/uvicorn/actions)
+[![Package version](https://badge.fury.io/py/uvicorn.svg)](https://pypi.python.org/pypi/uvicorn)
+
+**Documentation**: [https://www.uvicorn.org](https://www.uvicorn.org)
+
+**Requirements**: Python 3.6+ (For Python 3.5 support, install version 0.8.6.)
+
+Uvicorn is a lightning-fast ASGI server implementation, using [uvloop][uvloop] and [httptools][httptools].
+
+Until recently Python has lacked a minimal low-level server/application interface for
+asyncio frameworks. The [ASGI specification][asgi] fills this gap, and means we're now able to
+start building a common set of tooling usable across all asyncio frameworks.
+
+Uvicorn currently supports HTTP/1.1 and WebSockets. Support for HTTP/2 is planned.
+
+## Quickstart
+
+Install using `pip`:
+
+```shell
+$ pip install uvicorn
+```
+
+This will install uvicorn with minimal (pure Python) dependencies.
+
+```shell
+$ pip install uvicorn[standard]
+```
+
+This will install uvicorn with "Cython-based" dependencies (where possible) and other "optional extras".
+
+In this context, "Cython-based" means the following:
+
+- the event loop `uvloop` will be installed and used if possible.
+- the http protocol will be handled by `httptools` if possible.
+
+Moreover, "optional extras" means that:
+
+- the websocket protocol will be handled by `websockets` (should you want to use `wsproto` you'd need to install it manually) if possible.
+- the `--reload` flag in development mode will use `watchgod`.
+- windows users will have `colorama` installed for the colored logs.
+- `python-dotenv` will be installed should you want to use the `--env-file` option.
+- `PyYAML` will be installed to allow you to provide a `.yaml` file to `--log-config`, if desired.
+
+Create an application, in `example.py`:
+
+```python
+async def app(scope, receive, send):
+    assert scope['type'] == 'http'
+
+    await send({
+        'type': 'http.response.start',
+        'status': 200,
+        'headers': [
+            [b'content-type', b'text/plain'],
+        ],
+    })
+    await send({
+        'type': 'http.response.body',
+        'body': b'Hello, world!',
+    })
+```
+
+Run the server:
+
+```shell
+$ uvicorn example:app
+```
+
+---
+
+<p align="center"><i>Uvicorn is <a href="https://github.com/encode/uvicorn/blob/master/LICENSE.md">BSD licensed</a> code.<br/>Designed & built in Brighton, England.</i><br/>&mdash; 🦄  &mdash;</p>
+
+[uvloop]: https://github.com/MagicStack/uvloop
+[httptools]: https://github.com/MagicStack/httptools
+[asgi]: https://asgi.readthedocs.io/en/latest/
+
+
diff --git a/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/RECORD
new file mode 100644
index 0000000..51d732d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/RECORD
@@ -0,0 +1,49 @@
+../../../bin/uvicorn,sha256=ETgTS4c_0zSHYgH5xKDUak4Y-bZile80ZK_MD2b-5OQ,252
+uvicorn/__init__.py,sha256=EYN-jin-8EtHfHEF18y59o4SSwL5CuUc4jCoUycLf4k,147
+uvicorn/__main__.py,sha256=DQizy6nKP0ywhPpnCHgmRDYIMfcqZKVEzNIWQZjqtVQ,62
+uvicorn/_types.py,sha256=jysk8Dv1S22qgU9P4pVgLz8Xwz7VO61AGCVcCQr4feY,423
+uvicorn/config.py,sha256=3UAzZjRH1Qiw8uM3EkdmFD-U5_O4b5XSVQILKz_0vns,20841
+uvicorn/importer.py,sha256=aGwb0nygYznrjdopDkcmbyWVHXdZAIounPHPEQ245Hk,1166
+uvicorn/logging.py,sha256=9_Uahj06zGhMAgaR6O-PYbkxigzAE2ufu3GdTRaFA9Y,4179
+uvicorn/main.py,sha256=yN4rkQPs9n4qmowYH4PNpjqy38hsHXtsCCc0rHFmLBI,12094
+uvicorn/server.py,sha256=MYQooS3H8-YvlmKEM0zf96mXpIyCLWz0a0jNjT4akmU,11165
+uvicorn/subprocess.py,sha256=zip7kqIlWL_GG7dBnl9dVuzScnjDt97VJJNH5PJFcts,2403
+uvicorn/workers.py,sha256=_QU8RWQjH3Mq3D2xLqQ6JrPg_HxPFhXg2TR-JvUzaGk,3185
+uvicorn/_handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/_handlers/http.py,sha256=pw3QMYvV8LfMshr75Y9qzI__pTVV6FFB5P-_E6Rckgw,3723
+uvicorn/lifespan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/lifespan/off.py,sha256=wjwbgYUYHwTUkMQVOt-wnNSSmEvnrrcgvq6tux_xD2o,232
+uvicorn/lifespan/on.py,sha256=k0hiorLbD5eytWttoFrg04ENeF4SsiVvokUO39xiMsU,5090
+uvicorn/loops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/loops/asyncio.py,sha256=y6BE58gMLGCWUulfLRS5CRJmSCdILrMirANucWk5WPw,400
+uvicorn/loops/auto.py,sha256=nkrV7NbK96lsxA2hIoS5wmcS31jqjwthvZyk-HEOXL8,360
+uvicorn/loops/uvloop.py,sha256=MB97XLBUu37fO3TWg0ZZw9Zj5nhLCzGc8qGa7fL65HI,140
+uvicorn/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/middleware/asgi2.py,sha256=bQGKjaQdH7-Yme3obR5kQCQugqGyNVWURxAcxMnyLsE,400
+uvicorn/middleware/debug.py,sha256=YG-NWlM0fjTqJudQ-2h8LgpLiBBgzNj5b5jjznTUop0,3375
+uvicorn/middleware/message_logger.py,sha256=HDFxr2UuGodmEI7StuoRmxh4nRZQeG5Ssp5na632AcI,2823
+uvicorn/middleware/proxy_headers.py,sha256=AZiGYwLD42sH4nCBSTxs1vvbemS02BY7J--7XZabnbY,2975
+uvicorn/middleware/wsgi.py,sha256=d8E1ROfUmL4UHMUJZ6aTpmYUqsvh0fTxku8-9EDjNtg,6442
+uvicorn/protocols/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/protocols/utils.py,sha256=_YERPli8pT2E_hjvwAjfOu6nk5TBr8bLlB7TWoRYyus,1858
+uvicorn/protocols/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/protocols/http/auto.py,sha256=fvYmlgqD3ockeVj13Hhjc3kMWBu8zj2D0npUQcvIraM,391
+uvicorn/protocols/http/flow_control.py,sha256=-QKp7mq31YBzDTX6ElPNUtFCt1mVf3zkp14fhOmlO0s,1767
+uvicorn/protocols/http/h11_impl.py,sha256=4vOSaxAUY5tRqXgx9GlyqONO_nonJ-JVpI8iuyGj1h0,18106
+uvicorn/protocols/http/httptools_impl.py,sha256=xfhIzTYgATCo7G0p4JHANM6usae6jBaOmiF9IVQLd7w,19166
+uvicorn/protocols/websockets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/protocols/websockets/auto.py,sha256=Fj-Bufny9Syw9cz0MXzZK4ajGkrTSMg1KvwskfWjuyc,539
+uvicorn/protocols/websockets/websockets_impl.py,sha256=WDc6Mfty6BdnAehuGA49NzKyULMo22U3JalmjqGkqRM,10716
+uvicorn/protocols/websockets/wsproto_impl.py,sha256=zd_nH_MP1od9R9QTol-A7V_a78ZgkFp9QZj19nywxIU,12096
+uvicorn/supervisors/__init__.py,sha256=oP5F1SOn08qsT12p0DAm3XVKNKbC8GcvpCcWPsdNCpg,482
+uvicorn/supervisors/basereload.py,sha256=iCCzJDT9RmZBE8Pdv-FXtYAp3eYN9Smie_EmsGqIJ1U,2763
+uvicorn/supervisors/multiprocess.py,sha256=wtWbTwHqAiy6Sb6yNzYTnTVAVoDst6qCbIUfkWnSsvI,2231
+uvicorn/supervisors/statreload.py,sha256=kQK9Bj6Tlum--QRkTYBrTEtApRg7S0CKMePF7QofVA8,1642
+uvicorn/supervisors/watchgodreload.py,sha256=BB4t29DndnLMbR3dyS2asVzbsINUMktZL3nDh5-blso,5396
+uvicorn-0.16.0.dist-info/LICENSE.md,sha256=er_Yxh9--QgfwWqJwXSYAYICU0lwug_wy0kwGfiSf_A,1525
+uvicorn-0.16.0.dist-info/METADATA,sha256=V7AvJ1Nh1ftr_TlT4wSlnF3sXOaaCoZ9_xNk72hdKvw,4824
+uvicorn-0.16.0.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+uvicorn-0.16.0.dist-info/entry_points.txt,sha256=ItiyNXf7FTLFhNbpn2fPncOvYXBK42UDxvzQWy38sqE,57
+uvicorn-0.16.0.dist-info/top_level.txt,sha256=bEGv_uN3auKTct_rZ-rD-cTIwkkTVUNx43BFXJkuUx4,166
+uvicorn-0.16.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+uvicorn-0.16.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/WHEEL
new file mode 100644
index 0000000..5bad85f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/entry_points.txt
new file mode 100644
index 0000000..d323115
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/entry_points.txt
@@ -0,0 +1,4 @@
+
+    [console_scripts]
+    uvicorn=uvicorn.main:main
+    
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/top_level.txt
new file mode 100644
index 0000000..82edc19
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn-0.16.0.dist-info/top_level.txt
@@ -0,0 +1,9 @@
+uvicorn
+uvicorn/_handlers
+uvicorn/lifespan
+uvicorn/loops
+uvicorn/middleware
+uvicorn/protocols
+uvicorn/protocols/http
+uvicorn/protocols/websockets
+uvicorn/supervisors
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/__init__.py b/myenv/lib/python3.9/site-packages/uvicorn/__init__.py
new file mode 100644
index 0000000..6fdda0c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/__init__.py
@@ -0,0 +1,5 @@
+from uvicorn.config import Config
+from uvicorn.main import Server, main, run
+
+__version__ = "0.16.0"
+__all__ = ["main", "run", "Config", "Server"]
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/__main__.py b/myenv/lib/python3.9/site-packages/uvicorn/__main__.py
new file mode 100644
index 0000000..8a1dc97
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/__main__.py
@@ -0,0 +1,4 @@
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.main()
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/_handlers/__init__.py b/myenv/lib/python3.9/site-packages/uvicorn/_handlers/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/_handlers/http.py b/myenv/lib/python3.9/site-packages/uvicorn/_handlers/http.py
new file mode 100644
index 0000000..e810f66
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/_handlers/http.py
@@ -0,0 +1,99 @@
+import asyncio
+from typing import TYPE_CHECKING
+
+from uvicorn.config import Config
+
+if TYPE_CHECKING:  # pragma: no cover
+    from uvicorn.server import ServerState
+
+
+async def handle_http(
+    reader: asyncio.StreamReader,
+    writer: asyncio.StreamWriter,
+    server_state: "ServerState",
+    config: Config,
+) -> None:
+    # Run transport/protocol session from streams.
+    #
+    # This is a bit fiddly, so let me explain why we do this in the first place.
+    #
+    # This was introduced to switch to the asyncio streams API while retaining our
+    # existing protocols-based code.
+    #
+    # The aim was to:
+    # * Make it easier to support alternative async libaries (all of which expose
+    #   a streams API, rather than anything similar to asyncio's transports and
+    #   protocols) while keeping the change footprint (and risk) at a minimum.
+    # * Keep a "fast track" for asyncio that's as efficient as possible, by reusing
+    #   our asyncio-optimized protocols-based implementation.
+    #
+    # See: https://github.com/encode/uvicorn/issues/169
+    # See: https://github.com/encode/uvicorn/pull/869
+
+    # Use a future to coordinate between the protocol and this handler task.
+    # https://docs.python.org/3/library/asyncio-protocol.html#connecting-existing-sockets
+    loop = asyncio.get_event_loop()
+    connection_lost = loop.create_future()
+
+    # Switch the protocol from the stream reader to our own HTTP protocol class.
+    protocol = config.http_protocol_class(  # type: ignore[call-arg, operator]
+        config=config,
+        server_state=server_state,
+        on_connection_lost=lambda: connection_lost.set_result(True),
+    )
+    transport = writer.transport
+    transport.set_protocol(protocol)
+
+    # Asyncio stream servers don't `await` handler tasks (like the one we're currently
+    # running), so we must make sure exceptions that occur in protocols but outside the
+    # ASGI cycle (e.g. bugs) are properly retrieved and logged.
+    # Vanilla asyncio handles exceptions properly out-of-the-box, but uvloop doesn't.
+    # So we need to attach a callback to handle exceptions ourselves for that case.
+    # (It's not easy to know which loop we're effectively running on, so we attach the
+    # callback in all cases. In practice it won't be called on vanilla asyncio.)
+    task = _get_current_task()
+
+    @task.add_done_callback
+    def retrieve_exception(task: asyncio.Task) -> None:
+        exc = task.exception()
+
+        if exc is None:
+            return
+
+        loop.call_exception_handler(
+            {
+                "message": "Fatal error in server handler",
+                "exception": exc,
+                "transport": transport,
+                "protocol": protocol,
+            }
+        )
+        # Hang up the connection so the client doesn't wait forever.
+        transport.close()
+
+    # Kick off the HTTP protocol.
+    protocol.connection_made(transport)
+
+    # Pass any data already in the read buffer.
+    # The assumption here is that we haven't read any data off the stream reader
+    # yet: all data that the client might have already sent since the connection has
+    # been established is in the `_buffer`.
+    data = reader._buffer  # type: ignore
+    if data:
+        protocol.data_received(data)
+
+    # Let the transport run in the background. When closed, this future will complete
+    # and we'll exit here.
+    await connection_lost
+
+
+def _get_current_task() -> asyncio.Task:
+    try:
+        current_task = asyncio.current_task  # type: ignore
+    except AttributeError:  # pragma: no cover
+        # Python 3.6.
+        current_task = asyncio.Task.current_task  # type: ignore
+
+    task = current_task()
+    assert task is not None
+    return task
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/_types.py b/myenv/lib/python3.9/site-packages/uvicorn/_types.py
new file mode 100644
index 0000000..0a547a5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/_types.py
@@ -0,0 +1,14 @@
+import types
+import typing
+
+# WSGI
+Environ = typing.MutableMapping[str, typing.Any]
+ExcInfo = typing.Tuple[
+    typing.Type[BaseException], BaseException, typing.Optional[types.TracebackType]
+]
+StartResponse = typing.Callable[
+    [str, typing.Iterable[typing.Tuple[str, str]], typing.Optional[ExcInfo]], None
+]
+WSGIApp = typing.Callable[
+    [Environ, StartResponse], typing.Union[typing.Iterable[bytes], BaseException]
+]
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/config.py b/myenv/lib/python3.9/site-packages/uvicorn/config.py
new file mode 100644
index 0000000..59c94b4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/config.py
@@ -0,0 +1,568 @@
+import asyncio
+import inspect
+import json
+import logging
+import logging.config
+import os
+import socket
+import ssl
+import sys
+from pathlib import Path
+from typing import Awaitable, Callable, Dict, List, Optional, Tuple, Type, Union
+
+from uvicorn.logging import TRACE_LOG_LEVEL
+
+if sys.version_info < (3, 8):
+    from typing_extensions import Literal
+else:
+    from typing import Literal
+
+import click
+from asgiref.typing import ASGIApplication
+
+try:
+    import yaml
+except ImportError:
+    # If the code below that depends on yaml is exercised, it will raise a NameError.
+    # Install the PyYAML package or the uvicorn[standard] optional dependencies to
+    # enable this functionality.
+    pass
+
+from uvicorn.importer import ImportFromStringError, import_from_string
+from uvicorn.middleware.asgi2 import ASGI2Middleware
+from uvicorn.middleware.debug import DebugMiddleware
+from uvicorn.middleware.message_logger import MessageLoggerMiddleware
+from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware
+from uvicorn.middleware.wsgi import WSGIMiddleware
+
+HTTPProtocolType = Literal["auto", "h11", "httptools"]
+WSProtocolType = Literal["auto", "none", "websockets", "wsproto"]
+LifespanType = Literal["auto", "on", "off"]
+LoopSetupType = Literal["none", "auto", "asyncio", "uvloop"]
+InterfaceType = Literal["auto", "asgi3", "asgi2", "wsgi"]
+
+LOG_LEVELS: Dict[str, int] = {
+    "critical": logging.CRITICAL,
+    "error": logging.ERROR,
+    "warning": logging.WARNING,
+    "info": logging.INFO,
+    "debug": logging.DEBUG,
+    "trace": TRACE_LOG_LEVEL,
+}
+HTTP_PROTOCOLS: Dict[HTTPProtocolType, str] = {
+    "auto": "uvicorn.protocols.http.auto:AutoHTTPProtocol",
+    "h11": "uvicorn.protocols.http.h11_impl:H11Protocol",
+    "httptools": "uvicorn.protocols.http.httptools_impl:HttpToolsProtocol",
+}
+WS_PROTOCOLS: Dict[WSProtocolType, Optional[str]] = {
+    "auto": "uvicorn.protocols.websockets.auto:AutoWebSocketsProtocol",
+    "none": None,
+    "websockets": "uvicorn.protocols.websockets.websockets_impl:WebSocketProtocol",
+    "wsproto": "uvicorn.protocols.websockets.wsproto_impl:WSProtocol",
+}
+LIFESPAN: Dict[LifespanType, str] = {
+    "auto": "uvicorn.lifespan.on:LifespanOn",
+    "on": "uvicorn.lifespan.on:LifespanOn",
+    "off": "uvicorn.lifespan.off:LifespanOff",
+}
+LOOP_SETUPS: Dict[LoopSetupType, Optional[str]] = {
+    "none": None,
+    "auto": "uvicorn.loops.auto:auto_loop_setup",
+    "asyncio": "uvicorn.loops.asyncio:asyncio_setup",
+    "uvloop": "uvicorn.loops.uvloop:uvloop_setup",
+}
+INTERFACES: List[InterfaceType] = ["auto", "asgi3", "asgi2", "wsgi"]
+
+
+SSL_PROTOCOL_VERSION: int = ssl.PROTOCOL_TLS_SERVER
+
+
+LOGGING_CONFIG: dict = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "default": {
+            "()": "uvicorn.logging.DefaultFormatter",
+            "fmt": "%(levelprefix)s %(message)s",
+            "use_colors": None,
+        },
+        "access": {
+            "()": "uvicorn.logging.AccessFormatter",
+            "fmt": '%(levelprefix)s %(client_addr)s - "%(request_line)s" %(status_code)s',  # noqa: E501
+        },
+    },
+    "handlers": {
+        "default": {
+            "formatter": "default",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stderr",
+        },
+        "access": {
+            "formatter": "access",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stdout",
+        },
+    },
+    "loggers": {
+        "uvicorn": {"handlers": ["default"], "level": "INFO"},
+        "uvicorn.error": {"level": "INFO"},
+        "uvicorn.access": {"handlers": ["access"], "level": "INFO", "propagate": False},
+    },
+}
+
+logger = logging.getLogger("uvicorn.error")
+
+
+def create_ssl_context(
+    certfile: Union[str, os.PathLike],
+    keyfile: Optional[Union[str, os.PathLike]],
+    password: Optional[str],
+    ssl_version: int,
+    cert_reqs: int,
+    ca_certs: Optional[Union[str, os.PathLike]],
+    ciphers: Optional[str],
+) -> ssl.SSLContext:
+    ctx = ssl.SSLContext(ssl_version)
+    get_password = (lambda: password) if password else None
+    ctx.load_cert_chain(certfile, keyfile, get_password)
+    ctx.verify_mode = cert_reqs
+    if ca_certs:
+        ctx.load_verify_locations(ca_certs)
+    if ciphers:
+        ctx.set_ciphers(ciphers)
+    return ctx
+
+
+def is_dir(path: Path) -> bool:
+    try:
+        if not path.is_absolute():
+            path = path.resolve()
+        return path.is_dir()
+    except OSError:
+        return False
+
+
+def resolve_reload_patterns(
+    patterns_list: List[str], directories_list: List[str]
+) -> Tuple[List[str], List[Path]]:
+
+    directories: List[Path] = list(set(map(Path, directories_list.copy())))
+    patterns: List[str] = patterns_list.copy()
+
+    current_working_directory = Path.cwd()
+    for pattern in patterns_list:
+        # Special case for the .* pattern, otherwise this would only match
+        # hidden directories which is probably undesired
+        if pattern == ".*":
+            continue
+        patterns.append(pattern)
+        if is_dir(Path(pattern)):
+            directories.append(Path(pattern))
+        else:
+            for match in current_working_directory.glob(pattern):
+                if is_dir(match):
+                    directories.append(match)
+
+    directories = list(set(directories))
+    directories = list(map(Path, directories))
+    directories = list(map(lambda x: x.resolve(), directories))
+    directories = list(
+        set([reload_path for reload_path in directories if is_dir(reload_path)])
+    )
+
+    children = []
+    for j in range(len(directories)):
+        for k in range(j + 1, len(directories)):
+            if directories[j] in directories[k].parents:
+                children.append(directories[k])
+            elif directories[k] in directories[j].parents:
+                children.append(directories[j])
+
+    directories = list(set(directories).difference(set(children)))
+
+    return list(set(patterns)), directories
+
+
+def _normalize_dirs(dirs: Union[List[str], str, None]) -> List[str]:
+    if dirs is None:
+        return []
+    if isinstance(dirs, str):
+        return [dirs]
+    return list(set(dirs))
+
+
+class Config:
+    def __init__(
+        self,
+        app: Union[ASGIApplication, Callable, str],
+        host: str = "127.0.0.1",
+        port: int = 8000,
+        uds: Optional[str] = None,
+        fd: Optional[int] = None,
+        loop: LoopSetupType = "auto",
+        http: Union[Type[asyncio.Protocol], HTTPProtocolType] = "auto",
+        ws: Union[Type[asyncio.Protocol], WSProtocolType] = "auto",
+        ws_max_size: int = 16 * 1024 * 1024,
+        ws_ping_interval: Optional[float] = 20,
+        ws_ping_timeout: Optional[float] = 20,
+        lifespan: LifespanType = "auto",
+        env_file: Optional[Union[str, os.PathLike]] = None,
+        log_config: Optional[Union[dict, str]] = LOGGING_CONFIG,
+        log_level: Optional[Union[str, int]] = None,
+        access_log: bool = True,
+        use_colors: Optional[bool] = None,
+        interface: InterfaceType = "auto",
+        debug: bool = False,
+        reload: bool = False,
+        reload_dirs: Optional[Union[List[str], str]] = None,
+        reload_delay: Optional[float] = None,
+        reload_includes: Optional[Union[List[str], str]] = None,
+        reload_excludes: Optional[Union[List[str], str]] = None,
+        workers: Optional[int] = None,
+        proxy_headers: bool = True,
+        server_header: bool = True,
+        date_header: bool = True,
+        forwarded_allow_ips: Optional[str] = None,
+        root_path: str = "",
+        limit_concurrency: Optional[int] = None,
+        limit_max_requests: Optional[int] = None,
+        backlog: int = 2048,
+        timeout_keep_alive: int = 5,
+        timeout_notify: int = 30,
+        callback_notify: Callable[..., Awaitable[None]] = None,
+        ssl_keyfile: Optional[str] = None,
+        ssl_certfile: Optional[Union[str, os.PathLike]] = None,
+        ssl_keyfile_password: Optional[str] = None,
+        ssl_version: int = SSL_PROTOCOL_VERSION,
+        ssl_cert_reqs: int = ssl.CERT_NONE,
+        ssl_ca_certs: Optional[str] = None,
+        ssl_ciphers: str = "TLSv1",
+        headers: Optional[List[List[str]]] = None,
+        factory: bool = False,
+    ):
+        self.app = app
+        self.host = host
+        self.port = port
+        self.uds = uds
+        self.fd = fd
+        self.loop = loop
+        self.http = http
+        self.ws = ws
+        self.ws_max_size = ws_max_size
+        self.ws_ping_interval = ws_ping_interval
+        self.ws_ping_timeout = ws_ping_timeout
+        self.lifespan = lifespan
+        self.log_config = log_config
+        self.log_level = log_level
+        self.access_log = access_log
+        self.use_colors = use_colors
+        self.interface = interface
+        self.debug = debug
+        self.reload = reload
+        self.reload_delay = reload_delay or 0.25
+        self.workers = workers or 1
+        self.proxy_headers = proxy_headers
+        self.server_header = server_header
+        self.date_header = date_header
+        self.root_path = root_path
+        self.limit_concurrency = limit_concurrency
+        self.limit_max_requests = limit_max_requests
+        self.backlog = backlog
+        self.timeout_keep_alive = timeout_keep_alive
+        self.timeout_notify = timeout_notify
+        self.callback_notify = callback_notify
+        self.ssl_keyfile = ssl_keyfile
+        self.ssl_certfile = ssl_certfile
+        self.ssl_keyfile_password = ssl_keyfile_password
+        self.ssl_version = ssl_version
+        self.ssl_cert_reqs = ssl_cert_reqs
+        self.ssl_ca_certs = ssl_ca_certs
+        self.ssl_ciphers = ssl_ciphers
+        self.headers: List[List[str]] = headers or []
+        self.encoded_headers: List[Tuple[bytes, bytes]] = []
+        self.factory = factory
+
+        self.loaded = False
+        self.configure_logging()
+
+        self.reload_dirs: List[Path] = []
+        self.reload_dirs_excludes: List[Path] = []
+        self.reload_includes: List[str] = []
+        self.reload_excludes: List[str] = []
+
+        if (
+            reload_dirs or reload_includes or reload_excludes
+        ) and not self.should_reload:
+            logger.warning(
+                "Current configuration will not reload as not all conditions are met,"
+                "please refer to documentation."
+            )
+
+        if self.should_reload:
+            reload_dirs = _normalize_dirs(reload_dirs)
+            reload_includes = _normalize_dirs(reload_includes)
+            reload_excludes = _normalize_dirs(reload_excludes)
+
+            self.reload_includes, self.reload_dirs = resolve_reload_patterns(
+                reload_includes, reload_dirs
+            )
+
+            self.reload_excludes, self.reload_dirs_excludes = resolve_reload_patterns(
+                reload_excludes, []
+            )
+
+            reload_dirs_tmp = self.reload_dirs.copy()
+
+            for directory in self.reload_dirs_excludes:
+                for reload_directory in reload_dirs_tmp:
+                    if (
+                        directory == reload_directory
+                        or directory in reload_directory.parents
+                    ):
+                        try:
+                            self.reload_dirs.remove(reload_directory)
+                        except ValueError:
+                            pass
+
+            for pattern in self.reload_excludes:
+                if pattern in self.reload_includes:
+                    self.reload_includes.remove(pattern)
+
+            if not self.reload_dirs:
+                if reload_dirs:
+                    logger.warning(
+                        "Provided reload directories %s did not contain valid "
+                        + "directories, watching current working directory.",
+                        reload_dirs,
+                    )
+                self.reload_dirs = [Path(os.getcwd())]
+
+            logger.info(
+                "Will watch for changes in these directories: %s",
+                sorted(list(map(str, self.reload_dirs))),
+            )
+
+        if env_file is not None:
+            from dotenv import load_dotenv
+
+            logger.info("Loading environment from '%s'", env_file)
+            load_dotenv(dotenv_path=env_file)
+
+        if workers is None and "WEB_CONCURRENCY" in os.environ:
+            self.workers = int(os.environ["WEB_CONCURRENCY"])
+
+        if forwarded_allow_ips is None:
+            self.forwarded_allow_ips = os.environ.get(
+                "FORWARDED_ALLOW_IPS", "127.0.0.1"
+            )
+        else:
+            self.forwarded_allow_ips = forwarded_allow_ips
+
+    @property
+    def asgi_version(self) -> Literal["2.0", "3.0"]:
+        mapping: Dict[str, Literal["2.0", "3.0"]] = {
+            "asgi2": "2.0",
+            "asgi3": "3.0",
+            "wsgi": "3.0",
+        }
+        return mapping[self.interface]
+
+    @property
+    def is_ssl(self) -> bool:
+        return bool(self.ssl_keyfile or self.ssl_certfile)
+
+    def configure_logging(self) -> None:
+        logging.addLevelName(TRACE_LOG_LEVEL, "TRACE")
+
+        if self.log_config is not None:
+            if isinstance(self.log_config, dict):
+                if self.use_colors in (True, False):
+                    self.log_config["formatters"]["default"][
+                        "use_colors"
+                    ] = self.use_colors
+                    self.log_config["formatters"]["access"][
+                        "use_colors"
+                    ] = self.use_colors
+                logging.config.dictConfig(self.log_config)
+            elif self.log_config.endswith(".json"):
+                with open(self.log_config) as file:
+                    loaded_config = json.load(file)
+                    logging.config.dictConfig(loaded_config)
+            elif self.log_config.endswith((".yaml", ".yml")):
+                with open(self.log_config) as file:
+                    loaded_config = yaml.safe_load(file)
+                    logging.config.dictConfig(loaded_config)
+            else:
+                # See the note about fileConfig() here:
+                # https://docs.python.org/3/library/logging.config.html#configuration-file-format
+                logging.config.fileConfig(
+                    self.log_config, disable_existing_loggers=False
+                )
+
+        if self.log_level is not None:
+            if isinstance(self.log_level, str):
+                log_level = LOG_LEVELS[self.log_level]
+            else:
+                log_level = self.log_level
+            logging.getLogger("uvicorn.error").setLevel(log_level)
+            logging.getLogger("uvicorn.access").setLevel(log_level)
+            logging.getLogger("uvicorn.asgi").setLevel(log_level)
+        if self.access_log is False:
+            logging.getLogger("uvicorn.access").handlers = []
+            logging.getLogger("uvicorn.access").propagate = False
+
+    def load(self) -> None:
+        assert not self.loaded
+
+        if self.is_ssl:
+            assert self.ssl_certfile
+            self.ssl: Optional[ssl.SSLContext] = create_ssl_context(
+                keyfile=self.ssl_keyfile,
+                certfile=self.ssl_certfile,
+                password=self.ssl_keyfile_password,
+                ssl_version=self.ssl_version,
+                cert_reqs=self.ssl_cert_reqs,
+                ca_certs=self.ssl_ca_certs,
+                ciphers=self.ssl_ciphers,
+            )
+        else:
+            self.ssl = None
+
+        encoded_headers = [
+            (key.lower().encode("latin1"), value.encode("latin1"))
+            for key, value in self.headers
+        ]
+        self.encoded_headers = (
+            [(b"server", b"uvicorn")] + encoded_headers
+            if b"server" not in dict(encoded_headers) and self.server_header
+            else encoded_headers
+        )
+
+        if isinstance(self.http, str):
+            http_protocol_class = import_from_string(HTTP_PROTOCOLS[self.http])
+            self.http_protocol_class: Type[asyncio.Protocol] = http_protocol_class
+        else:
+            self.http_protocol_class = self.http
+
+        if isinstance(self.ws, str):
+            ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
+            self.ws_protocol_class: Optional[Type[asyncio.Protocol]] = ws_protocol_class
+        else:
+            self.ws_protocol_class = self.ws
+
+        self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
+
+        try:
+            self.loaded_app = import_from_string(self.app)
+        except ImportFromStringError as exc:
+            logger.error("Error loading ASGI app. %s" % exc)
+            sys.exit(1)
+
+        try:
+            self.loaded_app = self.loaded_app()
+        except TypeError as exc:
+            if self.factory:
+                logger.error("Error loading ASGI app factory: %s", exc)
+                sys.exit(1)
+        else:
+            if not self.factory:
+                logger.warning(
+                    "ASGI app factory detected. Using it, "
+                    "but please consider setting the --factory flag explicitly."
+                )
+
+        if self.interface == "auto":
+            if inspect.isclass(self.loaded_app):
+                use_asgi_3 = hasattr(self.loaded_app, "__await__")
+            elif inspect.isfunction(self.loaded_app):
+                use_asgi_3 = asyncio.iscoroutinefunction(self.loaded_app)
+            else:
+                call = getattr(self.loaded_app, "__call__", None)
+                use_asgi_3 = asyncio.iscoroutinefunction(call)
+            self.interface = "asgi3" if use_asgi_3 else "asgi2"
+
+        if self.interface == "wsgi":
+            self.loaded_app = WSGIMiddleware(self.loaded_app)
+            self.ws_protocol_class = None
+        elif self.interface == "asgi2":
+            self.loaded_app = ASGI2Middleware(self.loaded_app)
+
+        if self.debug:
+            self.loaded_app = DebugMiddleware(self.loaded_app)
+        if logger.level <= TRACE_LOG_LEVEL:
+            self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
+        if self.proxy_headers:
+            self.loaded_app = ProxyHeadersMiddleware(
+                self.loaded_app, trusted_hosts=self.forwarded_allow_ips
+            )
+
+        self.loaded = True
+
+    def setup_event_loop(self) -> None:
+        loop_setup: Optional[Callable] = import_from_string(LOOP_SETUPS[self.loop])
+        if loop_setup is not None:
+            loop_setup(reload=self.reload)
+
+    def bind_socket(self) -> socket.socket:
+        logger_args: List[Union[str, int]]
+        if self.uds:  # pragma: py-win32
+            path = self.uds
+            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            try:
+                sock.bind(path)
+                uds_perms = 0o666
+                os.chmod(self.uds, uds_perms)
+            except OSError as exc:
+                logger.error(exc)
+                sys.exit(1)
+
+            message = "Uvicorn running on unix socket %s (Press CTRL+C to quit)"
+            sock_name_format = "%s"
+            color_message = (
+                "Uvicorn running on "
+                + click.style(sock_name_format, bold=True)
+                + " (Press CTRL+C to quit)"
+            )
+            logger_args = [self.uds]
+        elif self.fd:  # pragma: py-win32
+            sock = socket.fromfd(self.fd, socket.AF_UNIX, socket.SOCK_STREAM)
+            message = "Uvicorn running on socket %s (Press CTRL+C to quit)"
+            fd_name_format = "%s"
+            color_message = (
+                "Uvicorn running on "
+                + click.style(fd_name_format, bold=True)
+                + " (Press CTRL+C to quit)"
+            )
+            logger_args = [sock.getsockname()]
+        else:
+            family = socket.AF_INET
+            addr_format = "%s://%s:%d"
+
+            if self.host and ":" in self.host:  # pragma: py-win32
+                # It's an IPv6 address.
+                family = socket.AF_INET6
+                addr_format = "%s://[%s]:%d"
+
+            sock = socket.socket(family=family)
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            try:
+                sock.bind((self.host, self.port))
+            except OSError as exc:
+                logger.error(exc)
+                sys.exit(1)
+
+            message = f"Uvicorn running on {addr_format} (Press CTRL+C to quit)"
+            color_message = (
+                "Uvicorn running on "
+                + click.style(addr_format, bold=True)
+                + " (Press CTRL+C to quit)"
+            )
+            protocol_name = "https" if self.is_ssl else "http"
+            logger_args = [protocol_name, self.host, self.port]
+        logger.info(message, *logger_args, extra={"color_message": color_message})
+        sock.set_inheritable(True)
+        return sock
+
+    @property
+    def should_reload(self) -> bool:
+        return isinstance(self.app, str) and (self.debug or self.reload)
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/importer.py b/myenv/lib/python3.9/site-packages/uvicorn/importer.py
new file mode 100644
index 0000000..e612bf1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/importer.py
@@ -0,0 +1,38 @@
+import importlib
+from typing import Any
+
+
+class ImportFromStringError(Exception):
+    pass
+
+
+def import_from_string(import_str: Any) -> Any:
+    if not isinstance(import_str, str):
+        return import_str
+
+    module_str, _, attrs_str = import_str.partition(":")
+    if not module_str or not attrs_str:
+        message = (
+            'Import string "{import_str}" must be in format "<module>:<attribute>".'
+        )
+        raise ImportFromStringError(message.format(import_str=import_str))
+
+    try:
+        module = importlib.import_module(module_str)
+    except ImportError as exc:
+        if exc.name != module_str:
+            raise exc from None
+        message = 'Could not import module "{module_str}".'
+        raise ImportFromStringError(message.format(module_str=module_str))
+
+    instance = module
+    try:
+        for attr_str in attrs_str.split("."):
+            instance = getattr(instance, attr_str)
+    except AttributeError:
+        message = 'Attribute "{attrs_str}" not found in module "{module_str}".'
+        raise ImportFromStringError(
+            message.format(attrs_str=attrs_str, module_str=module_str)
+        )
+
+    return instance
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/lifespan/__init__.py b/myenv/lib/python3.9/site-packages/uvicorn/lifespan/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/lifespan/off.py b/myenv/lib/python3.9/site-packages/uvicorn/lifespan/off.py
new file mode 100644
index 0000000..7ec961b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/lifespan/off.py
@@ -0,0 +1,12 @@
+from uvicorn import Config
+
+
+class LifespanOff:
+    def __init__(self, config: Config) -> None:
+        self.should_exit = False
+
+    async def startup(self) -> None:
+        pass
+
+    async def shutdown(self) -> None:
+        pass
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/lifespan/on.py b/myenv/lib/python3.9/site-packages/uvicorn/lifespan/on.py
new file mode 100644
index 0000000..caf6e50
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/lifespan/on.py
@@ -0,0 +1,135 @@
+import asyncio
+import logging
+from asyncio import Queue
+from typing import Union
+
+from asgiref.typing import (
+    LifespanScope,
+    LifespanShutdownCompleteEvent,
+    LifespanShutdownEvent,
+    LifespanShutdownFailedEvent,
+    LifespanStartupCompleteEvent,
+    LifespanStartupEvent,
+    LifespanStartupFailedEvent,
+)
+
+from uvicorn import Config
+
+LifespanReceiveMessage = Union[LifespanStartupEvent, LifespanShutdownEvent]
+LifespanSendMessage = Union[
+    LifespanStartupFailedEvent,
+    LifespanShutdownFailedEvent,
+    LifespanStartupCompleteEvent,
+    LifespanShutdownCompleteEvent,
+]
+
+STATE_TRANSITION_ERROR = "Got invalid state transition on lifespan protocol."
+
+
+class LifespanOn:
+    def __init__(self, config: Config) -> None:
+        if not config.loaded:
+            config.load()
+
+        self.config = config
+        self.logger = logging.getLogger("uvicorn.error")
+        self.startup_event = asyncio.Event()
+        self.shutdown_event = asyncio.Event()
+        self.receive_queue: "Queue[LifespanReceiveMessage]" = asyncio.Queue()
+        self.error_occured = False
+        self.startup_failed = False
+        self.shutdown_failed = False
+        self.should_exit = False
+
+    async def startup(self) -> None:
+        self.logger.info("Waiting for application startup.")
+
+        loop = asyncio.get_event_loop()
+        main_lifespan_task = loop.create_task(self.main())  # noqa: F841
+        # Keep a hard reference to prevent garbage collection
+        # See https://github.com/encode/uvicorn/pull/972
+        startup_event: LifespanStartupEvent = {"type": "lifespan.startup"}
+        await self.receive_queue.put(startup_event)
+        await self.startup_event.wait()
+
+        if self.startup_failed or (self.error_occured and self.config.lifespan == "on"):
+            self.logger.error("Application startup failed. Exiting.")
+            self.should_exit = True
+        else:
+            self.logger.info("Application startup complete.")
+
+    async def shutdown(self) -> None:
+        if self.error_occured:
+            return
+        self.logger.info("Waiting for application shutdown.")
+        shutdown_event: LifespanShutdownEvent = {"type": "lifespan.shutdown"}
+        await self.receive_queue.put(shutdown_event)
+        await self.shutdown_event.wait()
+
+        if self.shutdown_failed or (
+            self.error_occured and self.config.lifespan == "on"
+        ):
+            self.logger.error("Application shutdown failed. Exiting.")
+            self.should_exit = True
+        else:
+            self.logger.info("Application shutdown complete.")
+
+    async def main(self) -> None:
+        try:
+            app = self.config.loaded_app
+            scope: LifespanScope = {
+                "type": "lifespan",
+                "asgi": {"version": self.config.asgi_version, "spec_version": "2.0"},
+            }
+            await app(scope, self.receive, self.send)
+        except BaseException as exc:
+            self.asgi = None
+            self.error_occured = True
+            if self.startup_failed or self.shutdown_failed:
+                return
+            if self.config.lifespan == "auto":
+                msg = "ASGI 'lifespan' protocol appears unsupported."
+                self.logger.info(msg)
+            else:
+                msg = "Exception in 'lifespan' protocol\n"
+                self.logger.error(msg, exc_info=exc)
+        finally:
+            self.startup_event.set()
+            self.shutdown_event.set()
+
+    async def send(self, message: LifespanSendMessage) -> None:
+        assert message["type"] in (
+            "lifespan.startup.complete",
+            "lifespan.startup.failed",
+            "lifespan.shutdown.complete",
+            "lifespan.shutdown.failed",
+        )
+
+        if message["type"] == "lifespan.startup.complete":
+            assert not self.startup_event.is_set(), STATE_TRANSITION_ERROR
+            assert not self.shutdown_event.is_set(), STATE_TRANSITION_ERROR
+            self.startup_event.set()
+
+        elif message["type"] == "lifespan.startup.failed":
+            assert not self.startup_event.is_set(), STATE_TRANSITION_ERROR
+            assert not self.shutdown_event.is_set(), STATE_TRANSITION_ERROR
+            self.startup_event.set()
+            self.startup_failed = True
+            if message.get("message"):
+                self.logger.error(message["message"])
+
+        elif message["type"] == "lifespan.shutdown.complete":
+            assert self.startup_event.is_set(), STATE_TRANSITION_ERROR
+            assert not self.shutdown_event.is_set(), STATE_TRANSITION_ERROR
+            self.shutdown_event.set()
+
+        elif message["type"] == "lifespan.shutdown.failed":
+            assert self.startup_event.is_set(), STATE_TRANSITION_ERROR
+            assert not self.shutdown_event.is_set(), STATE_TRANSITION_ERROR
+            self.shutdown_event.set()
+            self.shutdown_failed = True
+            if message.get("message"):
+                self.logger.error(message["message"])
+
+    async def receive(self) -> LifespanReceiveMessage:
+        return await self.receive_queue.get()
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/logging.py b/myenv/lib/python3.9/site-packages/uvicorn/logging.py
new file mode 100644
index 0000000..f22ed8d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/logging.py
@@ -0,0 +1,117 @@
+import http
+import logging
+import sys
+from copy import copy
+from typing import Optional
+
+import click
+
+TRACE_LOG_LEVEL = 5
+
+
+class ColourizedFormatter(logging.Formatter):
+    """
+    A custom log formatter class that:
+
+    * Outputs the LOG_LEVEL with an appropriate color.
+    * If a log call includes an `extras={"color_message": ...}` it will be used
+      for formatting the output, instead of the plain text message.
+    """
+
+    level_name_colors = {
+        TRACE_LOG_LEVEL: lambda level_name: click.style(str(level_name), fg="blue"),
+        logging.DEBUG: lambda level_name: click.style(str(level_name), fg="cyan"),
+        logging.INFO: lambda level_name: click.style(str(level_name), fg="green"),
+        logging.WARNING: lambda level_name: click.style(str(level_name), fg="yellow"),
+        logging.ERROR: lambda level_name: click.style(str(level_name), fg="red"),
+        logging.CRITICAL: lambda level_name: click.style(
+            str(level_name), fg="bright_red"
+        ),
+    }
+
+    def __init__(
+        self,
+        fmt: Optional[str] = None,
+        datefmt: Optional[str] = None,
+        style: str = "%",
+        use_colors: Optional[bool] = None,
+    ):
+        if use_colors in (True, False):
+            self.use_colors = use_colors
+        else:
+            self.use_colors = sys.stdout.isatty()
+        super().__init__(fmt=fmt, datefmt=datefmt, style=style)
+
+    def color_level_name(self, level_name: str, level_no: int) -> str:
+        def default(level_name: str) -> str:
+            return str(level_name)  # pragma: no cover
+
+        func = self.level_name_colors.get(level_no, default)
+        return func(level_name)
+
+    def should_use_colors(self) -> bool:
+        return True  # pragma: no cover
+
+    def formatMessage(self, record: logging.LogRecord) -> str:
+        recordcopy = copy(record)
+        levelname = recordcopy.levelname
+        seperator = " " * (8 - len(recordcopy.levelname))
+        if self.use_colors:
+            levelname = self.color_level_name(levelname, recordcopy.levelno)
+            if "color_message" in recordcopy.__dict__:
+                recordcopy.msg = recordcopy.__dict__["color_message"]
+                recordcopy.__dict__["message"] = recordcopy.getMessage()
+        recordcopy.__dict__["levelprefix"] = levelname + ":" + seperator
+        return super().formatMessage(recordcopy)
+
+
+class DefaultFormatter(ColourizedFormatter):
+    def should_use_colors(self) -> bool:
+        return sys.stderr.isatty()  # pragma: no cover
+
+
+class AccessFormatter(ColourizedFormatter):
+    status_code_colours = {
+        1: lambda code: click.style(str(code), fg="bright_white"),
+        2: lambda code: click.style(str(code), fg="green"),
+        3: lambda code: click.style(str(code), fg="yellow"),
+        4: lambda code: click.style(str(code), fg="red"),
+        5: lambda code: click.style(str(code), fg="bright_red"),
+    }
+
+    def get_status_code(self, status_code: int) -> str:
+        try:
+            status_phrase = http.HTTPStatus(status_code).phrase
+        except ValueError:
+            status_phrase = ""
+        status_and_phrase = "%s %s" % (status_code, status_phrase)
+        if self.use_colors:
+
+            def default(code: int) -> str:
+                return status_and_phrase  # pragma: no cover
+
+            func = self.status_code_colours.get(status_code // 100, default)
+            return func(status_and_phrase)
+        return status_and_phrase
+
+    def formatMessage(self, record: logging.LogRecord) -> str:
+        recordcopy = copy(record)
+        (
+            client_addr,
+            method,
+            full_path,
+            http_version,
+            status_code,
+        ) = recordcopy.args
+        status_code = self.get_status_code(int(status_code))
+        request_line = "%s %s HTTP/%s" % (method, full_path, http_version)
+        if self.use_colors:
+            request_line = click.style(request_line, bold=True)
+        recordcopy.__dict__.update(
+            {
+                "client_addr": client_addr,
+                "request_line": request_line,
+                "status_code": status_code,
+            }
+        )
+        return super().formatMessage(recordcopy)
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/loops/__init__.py b/myenv/lib/python3.9/site-packages/uvicorn/loops/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/loops/asyncio.py b/myenv/lib/python3.9/site-packages/uvicorn/loops/asyncio.py
new file mode 100644
index 0000000..9a9ed64
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/loops/asyncio.py
@@ -0,0 +1,11 @@
+import asyncio
+import logging
+import sys
+
+logger = logging.getLogger("uvicorn.error")
+
+
+def asyncio_setup(reload: bool = False) -> None:  # pragma: no cover
+    if sys.version_info >= (3, 8) and sys.platform == "win32" and reload:
+        logger.warning("The --reload flag should not be used in production on Windows.")
+        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/loops/auto.py b/myenv/lib/python3.9/site-packages/uvicorn/loops/auto.py
new file mode 100644
index 0000000..ff272c1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/loops/auto.py
@@ -0,0 +1,11 @@
+def auto_loop_setup(reload: bool = False) -> None:
+    try:
+        import uvloop  # noqa
+    except ImportError:  # pragma: no cover
+        from uvicorn.loops.asyncio import asyncio_setup as loop_setup
+
+        loop_setup(reload=reload)
+    else:  # pragma: no cover
+        from uvicorn.loops.uvloop import uvloop_setup
+
+        uvloop_setup(reload=reload)
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/loops/uvloop.py b/myenv/lib/python3.9/site-packages/uvicorn/loops/uvloop.py
new file mode 100644
index 0000000..119c9f2
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/loops/uvloop.py
@@ -0,0 +1,7 @@
+import asyncio
+
+import uvloop
+
+
+def uvloop_setup(reload: bool = False) -> None:
+    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/main.py b/myenv/lib/python3.9/site-packages/uvicorn/main.py
new file mode 100644
index 0000000..798e7f8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/main.py
@@ -0,0 +1,461 @@
+import logging
+import os
+import platform
+import ssl
+import sys
+import typing
+
+import click
+from asgiref.typing import ASGIApplication
+
+import uvicorn
+from uvicorn.config import (
+    HTTP_PROTOCOLS,
+    INTERFACES,
+    LIFESPAN,
+    LOG_LEVELS,
+    LOGGING_CONFIG,
+    LOOP_SETUPS,
+    SSL_PROTOCOL_VERSION,
+    WS_PROTOCOLS,
+    Config,
+)
+from uvicorn.server import Server, ServerState  # noqa: F401  # Used to be defined here.
+from uvicorn.supervisors import ChangeReload, Multiprocess
+
+LEVEL_CHOICES = click.Choice(list(LOG_LEVELS.keys()))
+HTTP_CHOICES = click.Choice(list(HTTP_PROTOCOLS.keys()))
+WS_CHOICES = click.Choice(list(WS_PROTOCOLS.keys()))
+LIFESPAN_CHOICES = click.Choice(list(LIFESPAN.keys()))
+LOOP_CHOICES = click.Choice([key for key in LOOP_SETUPS.keys() if key != "none"])
+INTERFACE_CHOICES = click.Choice(INTERFACES)
+
+STARTUP_FAILURE = 3
+
+logger = logging.getLogger("uvicorn.error")
+
+
+def print_version(ctx: click.Context, param: click.Parameter, value: bool) -> None:
+    if not value or ctx.resilient_parsing:
+        return
+    click.echo(
+        "Running uvicorn %s with %s %s on %s"
+        % (
+            uvicorn.__version__,
+            platform.python_implementation(),
+            platform.python_version(),
+            platform.system(),
+        )
+    )
+    ctx.exit()
+
+
+@click.command(context_settings={"auto_envvar_prefix": "UVICORN"})
+@click.argument("app")
+@click.option(
+    "--host",
+    type=str,
+    default="127.0.0.1",
+    help="Bind socket to this host.",
+    show_default=True,
+)
+@click.option(
+    "--port",
+    type=int,
+    default=8000,
+    help="Bind socket to this port.",
+    show_default=True,
+)
+@click.option("--uds", type=str, default=None, help="Bind to a UNIX domain socket.")
+@click.option(
+    "--fd", type=int, default=None, help="Bind to socket from this file descriptor."
+)
+@click.option(
+    "--debug", is_flag=True, default=False, help="Enable debug mode.", hidden=True
+)
+@click.option("--reload", is_flag=True, default=False, help="Enable auto-reload.")
+@click.option(
+    "--reload-dir",
+    "reload_dirs",
+    multiple=True,
+    help="Set reload directories explicitly, instead of using the current working"
+    " directory.",
+    type=click.Path(exists=True),
+)
+@click.option(
+    "--reload-include",
+    "reload_includes",
+    multiple=True,
+    help="Set glob patterns to include while watching for files. Includes '*.py' "
+    "by default; these defaults can be overridden in `--reload-exclude`.",
+)
+@click.option(
+    "--reload-exclude",
+    "reload_excludes",
+    multiple=True,
+    help="Set glob patterns to exclude while watching for files. Includes "
+    "'.*, .py[cod], .sw.*, ~*' by default; these defaults can be overridden "
+    "in `--reload-include`.",
+)
+@click.option(
+    "--reload-delay",
+    type=float,
+    default=0.25,
+    show_default=True,
+    help="Delay between previous and next check if application needs to be."
+    " Defaults to 0.25s.",
+)
+@click.option(
+    "--workers",
+    default=None,
+    type=int,
+    help="Number of worker processes. Defaults to the $WEB_CONCURRENCY environment"
+    " variable if available, or 1. Not valid with --reload.",
+)
+@click.option(
+    "--loop",
+    type=LOOP_CHOICES,
+    default="auto",
+    help="Event loop implementation.",
+    show_default=True,
+)
+@click.option(
+    "--http",
+    type=HTTP_CHOICES,
+    default="auto",
+    help="HTTP protocol implementation.",
+    show_default=True,
+)
+@click.option(
+    "--ws",
+    type=WS_CHOICES,
+    default="auto",
+    help="WebSocket protocol implementation.",
+    show_default=True,
+)
+@click.option(
+    "--ws-max-size",
+    type=int,
+    default=16777216,
+    help="WebSocket max size message in bytes",
+    show_default=True,
+)
+@click.option(
+    "--ws-ping-interval",
+    type=float,
+    default=20.0,
+    help="WebSocket ping interval",
+    show_default=True,
+)
+@click.option(
+    "--ws-ping-timeout",
+    type=float,
+    default=20.0,
+    help="WebSocket ping timeout",
+    show_default=True,
+)
+@click.option(
+    "--lifespan",
+    type=LIFESPAN_CHOICES,
+    default="auto",
+    help="Lifespan implementation.",
+    show_default=True,
+)
+@click.option(
+    "--interface",
+    type=INTERFACE_CHOICES,
+    default="auto",
+    help="Select ASGI3, ASGI2, or WSGI as the application interface.",
+    show_default=True,
+)
+@click.option(
+    "--env-file",
+    type=click.Path(exists=True),
+    default=None,
+    help="Environment configuration file.",
+    show_default=True,
+)
+@click.option(
+    "--log-config",
+    type=click.Path(exists=True),
+    default=None,
+    help="Logging configuration file. Supported formats: .ini, .json, .yaml.",
+    show_default=True,
+)
+@click.option(
+    "--log-level",
+    type=LEVEL_CHOICES,
+    default=None,
+    help="Log level. [default: info]",
+    show_default=True,
+)
+@click.option(
+    "--access-log/--no-access-log",
+    is_flag=True,
+    default=True,
+    help="Enable/Disable access log.",
+)
+@click.option(
+    "--use-colors/--no-use-colors",
+    is_flag=True,
+    default=None,
+    help="Enable/Disable colorized logging.",
+)
+@click.option(
+    "--proxy-headers/--no-proxy-headers",
+    is_flag=True,
+    default=True,
+    help="Enable/Disable X-Forwarded-Proto, X-Forwarded-For, X-Forwarded-Port to "
+    "populate remote address info.",
+)
+@click.option(
+    "--server-header/--no-server-header",
+    is_flag=True,
+    default=True,
+    help="Enable/Disable default Server header.",
+)
+@click.option(
+    "--date-header/--no-date-header",
+    is_flag=True,
+    default=True,
+    help="Enable/Disable default Date header.",
+)
+@click.option(
+    "--forwarded-allow-ips",
+    type=str,
+    default=None,
+    help="Comma seperated list of IPs to trust with proxy headers. Defaults to"
+    " the $FORWARDED_ALLOW_IPS environment variable if available, or '127.0.0.1'.",
+)
+@click.option(
+    "--root-path",
+    type=str,
+    default="",
+    help="Set the ASGI 'root_path' for applications submounted below a given URL path.",
+)
+@click.option(
+    "--limit-concurrency",
+    type=int,
+    default=None,
+    help="Maximum number of concurrent connections or tasks to allow, before issuing"
+    " HTTP 503 responses.",
+)
+@click.option(
+    "--backlog",
+    type=int,
+    default=2048,
+    help="Maximum number of connections to hold in backlog",
+)
+@click.option(
+    "--limit-max-requests",
+    type=int,
+    default=None,
+    help="Maximum number of requests to service before terminating the process.",
+)
+@click.option(
+    "--timeout-keep-alive",
+    type=int,
+    default=5,
+    help="Close Keep-Alive connections if no new data is received within this timeout.",
+    show_default=True,
+)
+@click.option(
+    "--ssl-keyfile", type=str, default=None, help="SSL key file", show_default=True
+)
+@click.option(
+    "--ssl-certfile",
+    type=str,
+    default=None,
+    help="SSL certificate file",
+    show_default=True,
+)
+@click.option(
+    "--ssl-keyfile-password",
+    type=str,
+    default=None,
+    help="SSL keyfile password",
+    show_default=True,
+)
+@click.option(
+    "--ssl-version",
+    type=int,
+    default=int(SSL_PROTOCOL_VERSION),
+    help="SSL version to use (see stdlib ssl module's)",
+    show_default=True,
+)
+@click.option(
+    "--ssl-cert-reqs",
+    type=int,
+    default=int(ssl.CERT_NONE),
+    help="Whether client certificate is required (see stdlib ssl module's)",
+    show_default=True,
+)
+@click.option(
+    "--ssl-ca-certs",
+    type=str,
+    default=None,
+    help="CA certificates file",
+    show_default=True,
+)
+@click.option(
+    "--ssl-ciphers",
+    type=str,
+    default="TLSv1",
+    help="Ciphers to use (see stdlib ssl module's)",
+    show_default=True,
+)
+@click.option(
+    "--header",
+    "headers",
+    multiple=True,
+    help="Specify custom default HTTP response headers as a Name:Value pair",
+)
+@click.option(
+    "--version",
+    is_flag=True,
+    callback=print_version,
+    expose_value=False,
+    is_eager=True,
+    help="Display the uvicorn version and exit.",
+)
+@click.option(
+    "--app-dir",
+    default=".",
+    show_default=True,
+    help="Look for APP in the specified directory, by adding this to the PYTHONPATH."
+    " Defaults to the current working directory.",
+)
+@click.option(
+    "--factory",
+    is_flag=True,
+    default=False,
+    help="Treat APP as an application factory, i.e. a () -> <ASGI app> callable.",
+    show_default=True,
+)
+def main(
+    app: str,
+    host: str,
+    port: int,
+    uds: str,
+    fd: int,
+    loop: str,
+    http: str,
+    ws: str,
+    ws_max_size: int,
+    ws_ping_interval: float,
+    ws_ping_timeout: float,
+    lifespan: str,
+    interface: str,
+    debug: bool,
+    reload: bool,
+    reload_dirs: typing.List[str],
+    reload_includes: typing.List[str],
+    reload_excludes: typing.List[str],
+    reload_delay: float,
+    workers: int,
+    env_file: str,
+    log_config: str,
+    log_level: str,
+    access_log: bool,
+    proxy_headers: bool,
+    server_header: bool,
+    date_header: bool,
+    forwarded_allow_ips: str,
+    root_path: str,
+    limit_concurrency: int,
+    backlog: int,
+    limit_max_requests: int,
+    timeout_keep_alive: int,
+    ssl_keyfile: str,
+    ssl_certfile: str,
+    ssl_keyfile_password: str,
+    ssl_version: int,
+    ssl_cert_reqs: int,
+    ssl_ca_certs: str,
+    ssl_ciphers: str,
+    headers: typing.List[str],
+    use_colors: bool,
+    app_dir: str,
+    factory: bool,
+) -> None:
+    kwargs = {
+        "host": host,
+        "port": port,
+        "uds": uds,
+        "fd": fd,
+        "loop": loop,
+        "http": http,
+        "ws": ws,
+        "ws_max_size": ws_max_size,
+        "ws_ping_interval": ws_ping_interval,
+        "ws_ping_timeout": ws_ping_timeout,
+        "lifespan": lifespan,
+        "env_file": env_file,
+        "log_config": LOGGING_CONFIG if log_config is None else log_config,
+        "log_level": log_level,
+        "access_log": access_log,
+        "interface": interface,
+        "debug": debug,
+        "reload": reload,
+        "reload_dirs": reload_dirs if reload_dirs else None,
+        "reload_includes": reload_includes if reload_includes else None,
+        "reload_excludes": reload_excludes if reload_excludes else None,
+        "reload_delay": reload_delay,
+        "workers": workers,
+        "proxy_headers": proxy_headers,
+        "server_header": server_header,
+        "date_header": date_header,
+        "forwarded_allow_ips": forwarded_allow_ips,
+        "root_path": root_path,
+        "limit_concurrency": limit_concurrency,
+        "backlog": backlog,
+        "limit_max_requests": limit_max_requests,
+        "timeout_keep_alive": timeout_keep_alive,
+        "ssl_keyfile": ssl_keyfile,
+        "ssl_certfile": ssl_certfile,
+        "ssl_keyfile_password": ssl_keyfile_password,
+        "ssl_version": ssl_version,
+        "ssl_cert_reqs": ssl_cert_reqs,
+        "ssl_ca_certs": ssl_ca_certs,
+        "ssl_ciphers": ssl_ciphers,
+        "headers": [header.split(":", 1) for header in headers],
+        "use_colors": use_colors,
+        "factory": factory,
+        "app_dir": app_dir,
+    }
+    run(app, **kwargs)
+
+
+def run(app: typing.Union[ASGIApplication, str], **kwargs: typing.Any) -> None:
+    app_dir = kwargs.pop("app_dir", None)
+    if app_dir is not None:
+        sys.path.insert(0, app_dir)
+
+    config = Config(app, **kwargs)
+    server = Server(config=config)
+
+    if (config.reload or config.workers > 1) and not isinstance(app, str):
+        logger = logging.getLogger("uvicorn.error")
+        logger.warning(
+            "You must pass the application as an import string to enable 'reload' or "
+            "'workers'."
+        )
+        sys.exit(1)
+
+    if config.should_reload:
+        sock = config.bind_socket()
+        ChangeReload(config, target=server.run, sockets=[sock]).run()
+    elif config.workers > 1:
+        sock = config.bind_socket()
+        Multiprocess(config, target=server.run, sockets=[sock]).run()
+    else:
+        server.run()
+    if config.uds:
+        os.remove(config.uds)  # pragma: py-win32
+
+    if not server.started and not config.should_reload and config.workers == 1:
+        sys.exit(STARTUP_FAILURE)
+
+
+if __name__ == "__main__":
+    main()  # pragma: no cover
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/middleware/__init__.py b/myenv/lib/python3.9/site-packages/uvicorn/middleware/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/middleware/asgi2.py b/myenv/lib/python3.9/site-packages/uvicorn/middleware/asgi2.py
new file mode 100644
index 0000000..7ba78e6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/middleware/asgi2.py
@@ -0,0 +1,17 @@
+from asgiref.typing import (
+    ASGI2Application,
+    ASGIReceiveCallable,
+    ASGISendCallable,
+    Scope,
+)
+
+
+class ASGI2Middleware:
+    def __init__(self, app: ASGI2Application):
+        self.app = app
+
+    async def __call__(
+        self, scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        instance = self.app(scope)
+        await instance(receive, send)
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/middleware/debug.py b/myenv/lib/python3.9/site-packages/uvicorn/middleware/debug.py
new file mode 100644
index 0000000..2ea06ca
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/middleware/debug.py
@@ -0,0 +1,112 @@
+import html
+import traceback
+from typing import Union
+
+from asgiref.typing import (
+    ASGI3Application,
+    ASGIReceiveCallable,
+    ASGISendCallable,
+    ASGISendEvent,
+    HTTPResponseBodyEvent,
+    HTTPResponseStartEvent,
+    WWWScope,
+)
+
+
+class HTMLResponse:
+    def __init__(self, content: str, status_code: int):
+        self.content = content
+        self.status_code = status_code
+
+    async def __call__(
+        self, scope: WWWScope, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        response_start: HTTPResponseStartEvent = {
+            "type": "http.response.start",
+            "status": self.status_code,
+            "headers": [(b"content-type", b"text/html; charset=utf-8")],
+        }
+        await send(response_start)
+
+        response_body: HTTPResponseBodyEvent = {
+            "type": "http.response.body",
+            "body": self.content.encode("utf-8"),
+            "more_body": False,
+        }
+        await send(response_body)
+
+
+class PlainTextResponse:
+    def __init__(self, content: str, status_code: int):
+        self.content = content
+        self.status_code = status_code
+
+    async def __call__(
+        self, scope: WWWScope, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        response_start: HTTPResponseStartEvent = {
+            "type": "http.response.start",
+            "status": self.status_code,
+            "headers": [(b"content-type", b"text/plain; charset=utf-8")],
+        }
+        await send(response_start)
+
+        response_body: HTTPResponseBodyEvent = {
+            "type": "http.response.body",
+            "body": self.content.encode("utf-8"),
+            "more_body": False,
+        }
+        await send(response_body)
+
+
+def get_accept_header(scope: WWWScope) -> str:
+    accept = "*/*"
+
+    for key, value in scope.get("headers", []):
+        if key == b"accept":
+            accept = value.decode("ascii")
+            break
+
+    return accept
+
+
+class DebugMiddleware:
+    def __init__(self, app: ASGI3Application):
+        self.app = app
+
+    async def __call__(
+        self, scope: WWWScope, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        response_started = False
+
+        async def inner_send(message: ASGISendEvent) -> None:
+            nonlocal response_started, send
+
+            if message["type"] == "http.response.start":
+                response_started = True
+            await send(message)
+
+        try:
+            await self.app(scope, receive, inner_send)
+        except BaseException as exc:
+            if response_started:
+                raise exc from None
+
+            accept = get_accept_header(scope)
+            response: Union[HTMLResponse, PlainTextResponse]
+            if "text/html" in accept:
+                exc_html = html.escape(traceback.format_exc())
+                content = (
+                    "<html><body><h1>500 Server Error</h1><pre>%s</pre></body></html>"
+                    % exc_html
+                )
+                response = HTMLResponse(content, status_code=500)
+            else:
+                content = traceback.format_exc()
+                response = PlainTextResponse(content, status_code=500)
+
+            await response(scope, receive, send)
+            raise exc from None
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/middleware/message_logger.py b/myenv/lib/python3.9/site-packages/uvicorn/middleware/message_logger.py
new file mode 100644
index 0000000..a80ed9a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/middleware/message_logger.py
@@ -0,0 +1,85 @@
+import logging
+from typing import Any
+
+from asgiref.typing import (
+    ASGI3Application,
+    ASGIReceiveCallable,
+    ASGIReceiveEvent,
+    ASGISendCallable,
+    ASGISendEvent,
+    WWWScope,
+)
+
+from uvicorn.logging import TRACE_LOG_LEVEL
+
+PLACEHOLDER_FORMAT = {
+    "body": "<{length} bytes>",
+    "bytes": "<{length} bytes>",
+    "text": "<{length} chars>",
+    "headers": "<...>",
+}
+
+
+def message_with_placeholders(message: Any) -> Any:
+    """
+    Return an ASGI message, with any body-type content omitted and replaced
+    with a placeholder.
+    """
+    new_message = message.copy()
+    for attr in PLACEHOLDER_FORMAT.keys():
+        if message.get(attr) is not None:
+            content = message[attr]
+            placeholder = PLACEHOLDER_FORMAT[attr].format(length=len(content))
+            new_message[attr] = placeholder
+    return new_message
+
+
+class MessageLoggerMiddleware:
+    def __init__(self, app: ASGI3Application):
+        self.task_counter = 0
+        self.app = app
+        self.logger = logging.getLogger("uvicorn.asgi")
+
+        def trace(message: Any, *args: Any, **kwargs: Any) -> None:
+            self.logger.log(TRACE_LOG_LEVEL, message, *args, **kwargs)
+
+        self.logger.trace = trace  # type: ignore
+
+    async def __call__(
+        self, scope: WWWScope, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        self.task_counter += 1
+
+        task_counter = self.task_counter
+        client = scope.get("client")
+        prefix = "%s:%d - ASGI" % (client[0], client[1]) if client else "ASGI"
+
+        async def inner_receive() -> ASGIReceiveEvent:
+            message = await receive()
+            logged_message = message_with_placeholders(message)
+            log_text = "%s [%d] Receive %s"
+            self.logger.trace(  # type: ignore
+                log_text, prefix, task_counter, logged_message
+            )
+            return message
+
+        async def inner_send(message: ASGISendEvent) -> None:
+            logged_message = message_with_placeholders(message)
+            log_text = "%s [%d] Send %s"
+            self.logger.trace(  # type: ignore
+                log_text, prefix, task_counter, logged_message
+            )
+            await send(message)
+
+        logged_scope = message_with_placeholders(scope)
+        log_text = "%s [%d] Started scope=%s"
+        self.logger.trace(log_text, prefix, task_counter, logged_scope)  # type: ignore
+        try:
+            await self.app(scope, inner_receive, inner_send)
+        except BaseException as exc:
+            log_text = "%s [%d] Raised exception"
+            self.logger.trace(log_text, prefix, task_counter)  # type: ignore
+            raise exc from None
+        else:
+            log_text = "%s [%d] Completed"
+            self.logger.trace(log_text, prefix, task_counter)  # type: ignore
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/middleware/proxy_headers.py b/myenv/lib/python3.9/site-packages/uvicorn/middleware/proxy_headers.py
new file mode 100644
index 0000000..5445e7b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/middleware/proxy_headers.py
@@ -0,0 +1,75 @@
+"""
+This middleware can be used when a known proxy is fronting the application,
+and is trusted to be properly setting the `X-Forwarded-Proto` and
+`X-Forwarded-For` headers with the connecting client information.
+
+Modifies the `client` and `scheme` information so that they reference
+the connecting client, rather that the connecting proxy.
+
+https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers#Proxies
+"""
+from typing import List, Optional, Tuple, Union, cast
+
+from asgiref.typing import (
+    ASGI3Application,
+    ASGIReceiveCallable,
+    ASGISendCallable,
+    HTTPScope,
+    Scope,
+    WebSocketScope,
+)
+
+
+class ProxyHeadersMiddleware:
+    def __init__(
+        self, app: ASGI3Application, trusted_hosts: Union[List[str], str] = "127.0.0.1"
+    ) -> None:
+        self.app = app
+        if isinstance(trusted_hosts, str):
+            self.trusted_hosts = {item.strip() for item in trusted_hosts.split(",")}
+        else:
+            self.trusted_hosts = set(trusted_hosts)
+        self.always_trust = "*" in self.trusted_hosts
+
+    def get_trusted_client_host(
+        self, x_forwarded_for_hosts: List[str]
+    ) -> Optional[str]:
+        if self.always_trust:
+            return x_forwarded_for_hosts[0]
+
+        for host in reversed(x_forwarded_for_hosts):
+            if host not in self.trusted_hosts:
+                return host
+
+        return None
+
+    async def __call__(
+        self, scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        if scope["type"] in ("http", "websocket"):
+            scope = cast(Union[HTTPScope, WebSocketScope], scope)
+            client_addr: Optional[Tuple[str, int]] = scope.get("client")
+            client_host = client_addr[0] if client_addr else None
+
+            if self.always_trust or client_host in self.trusted_hosts:
+                headers = dict(scope["headers"])
+
+                if b"x-forwarded-proto" in headers:
+                    # Determine if the incoming request was http or https based on
+                    # the X-Forwarded-Proto header.
+                    x_forwarded_proto = headers[b"x-forwarded-proto"].decode("latin1")
+                    scope["scheme"] = x_forwarded_proto.strip()  # type: ignore[index]
+
+                if b"x-forwarded-for" in headers:
+                    # Determine the client address from the last trusted IP in the
+                    # X-Forwarded-For header. We've lost the connecting client's port
+                    # information by now, so only include the host.
+                    x_forwarded_for = headers[b"x-forwarded-for"].decode("latin1")
+                    x_forwarded_for_hosts = [
+                        item.strip() for item in x_forwarded_for.split(",")
+                    ]
+                    host = self.get_trusted_client_host(x_forwarded_for_hosts)
+                    port = 0
+                    scope["client"] = (host, port)  # type: ignore[index]
+
+        return await self.app(scope, receive, send)
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/middleware/wsgi.py b/myenv/lib/python3.9/site-packages/uvicorn/middleware/wsgi.py
new file mode 100644
index 0000000..74bdfad
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/middleware/wsgi.py
@@ -0,0 +1,179 @@
+import asyncio
+import concurrent.futures
+import io
+import sys
+from collections import deque
+from typing import Deque, Iterable, Optional, Tuple
+
+from asgiref.typing import (
+    ASGIReceiveCallable,
+    ASGIReceiveEvent,
+    ASGISendCallable,
+    ASGISendEvent,
+    HTTPRequestEvent,
+    HTTPResponseBodyEvent,
+    HTTPResponseStartEvent,
+    HTTPScope,
+)
+
+from uvicorn._types import Environ, ExcInfo, StartResponse, WSGIApp
+
+
+def build_environ(scope: HTTPScope, message: ASGIReceiveEvent, body: bytes) -> Environ:
+    """
+    Builds a scope and request message into a WSGI environ object.
+    """
+    environ = {
+        "REQUEST_METHOD": scope["method"],
+        "SCRIPT_NAME": "",
+        "PATH_INFO": scope["path"].encode("utf8").decode("latin1"),
+        "QUERY_STRING": scope["query_string"].decode("ascii"),
+        "SERVER_PROTOCOL": "HTTP/%s" % scope["http_version"],
+        "wsgi.version": (1, 0),
+        "wsgi.url_scheme": scope.get("scheme", "http"),
+        "wsgi.input": io.BytesIO(body),
+        "wsgi.errors": sys.stdout,
+        "wsgi.multithread": True,
+        "wsgi.multiprocess": True,
+        "wsgi.run_once": False,
+    }
+
+    # Get server name and port - required in WSGI, not in ASGI
+    server = scope.get("server")
+    if server is None:
+        server = ("localhost", 80)
+    environ["SERVER_NAME"] = server[0]
+    environ["SERVER_PORT"] = server[1]
+
+    # Get client IP address
+    client = scope.get("client")
+    if client is not None:
+        environ["REMOTE_ADDR"] = client[0]
+
+    # Go through headers and make them into environ entries
+    for name, value in scope.get("headers", []):
+        name_str: str = name.decode("latin1")
+        if name_str == "content-length":
+            corrected_name = "CONTENT_LENGTH"
+        elif name_str == "content-type":
+            corrected_name = "CONTENT_TYPE"
+        else:
+            corrected_name = "HTTP_%s" % name_str.upper().replace("-", "_")
+        # HTTPbis say only ASCII chars are allowed in headers, but we latin1
+        # just in case
+        value_str: str = value.decode("latin1")
+        if corrected_name in environ:
+            corrected_name_environ = environ[corrected_name]
+            assert isinstance(corrected_name_environ, str)
+            value_str = corrected_name_environ + "," + value_str
+        environ[corrected_name] = value_str
+    return environ
+
+
+class WSGIMiddleware:
+    def __init__(self, app: WSGIApp, workers: int = 10):
+        self.app = app
+        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=workers)
+
+    async def __call__(
+        self, scope: HTTPScope, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        assert scope["type"] == "http"
+        instance = WSGIResponder(self.app, self.executor, scope)
+        await instance(receive, send)
+
+
+class WSGIResponder:
+    def __init__(
+        self,
+        app: WSGIApp,
+        executor: concurrent.futures.ThreadPoolExecutor,
+        scope: HTTPScope,
+    ):
+        self.app = app
+        self.executor = executor
+        self.scope = scope
+        self.status = None
+        self.response_headers = None
+        self.send_event = asyncio.Event()
+        self.send_queue: Deque[Optional[ASGISendEvent]] = deque()
+        self.loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()
+        self.response_started = False
+        self.exc_info: Optional[ExcInfo] = None
+
+    async def __call__(
+        self, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        message: HTTPRequestEvent = await receive()  # type: ignore[assignment]
+        body = message.get("body", b"")
+        more_body = message.get("more_body", False)
+        while more_body:
+            body_message: HTTPRequestEvent = await receive()  # type: ignore[assignment]
+            body += body_message.get("body", b"")
+            more_body = body_message.get("more_body", False)
+        environ = build_environ(self.scope, message, body)
+        self.loop = asyncio.get_event_loop()
+        wsgi = self.loop.run_in_executor(
+            self.executor, self.wsgi, environ, self.start_response
+        )
+        sender = self.loop.create_task(self.sender(send))
+        try:
+            await asyncio.wait_for(wsgi, None)
+        finally:
+            self.send_queue.append(None)
+            self.send_event.set()
+            await asyncio.wait_for(sender, None)
+        if self.exc_info is not None:
+            raise self.exc_info[0].with_traceback(self.exc_info[1], self.exc_info[2])
+
+    async def sender(self, send: ASGISendCallable) -> None:
+        while True:
+            if self.send_queue:
+                message = self.send_queue.popleft()
+                if message is None:
+                    return
+                await send(message)
+            else:
+                await self.send_event.wait()
+                self.send_event.clear()
+
+    def start_response(
+        self,
+        status: str,
+        response_headers: Iterable[Tuple[str, str]],
+        exc_info: Optional[ExcInfo] = None,
+    ) -> None:
+        self.exc_info = exc_info
+        if not self.response_started:
+            self.response_started = True
+            status_code_str, _ = status.split(" ", 1)
+            status_code = int(status_code_str)
+            headers = [
+                (name.encode("ascii"), value.encode("ascii"))
+                for name, value in response_headers
+            ]
+            http_response_start_event: HTTPResponseStartEvent = {
+                "type": "http.response.start",
+                "status": status_code,
+                "headers": headers,
+            }
+            self.send_queue.append(http_response_start_event)
+            self.loop.call_soon_threadsafe(self.send_event.set)
+
+    def wsgi(self, environ: Environ, start_response: StartResponse) -> None:
+        for chunk in self.app(environ, start_response):  # type: ignore
+            response_body: HTTPResponseBodyEvent = {
+                "type": "http.response.body",
+                "body": chunk,
+                "more_body": True,
+            }
+            self.send_queue.append(response_body)
+            self.loop.call_soon_threadsafe(self.send_event.set)
+
+        empty_body: HTTPResponseBodyEvent = {
+            "type": "http.response.body",
+            "body": b"",
+            "more_body": False,
+        }
+        self.send_queue.append(empty_body)
+        self.loop.call_soon_threadsafe(self.send_event.set)
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/protocols/__init__.py b/myenv/lib/python3.9/site-packages/uvicorn/protocols/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/__init__.py b/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/auto.py b/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/auto.py
new file mode 100644
index 0000000..1aa9967
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/auto.py
@@ -0,0 +1,14 @@
+import asyncio
+from typing import Type
+
+AutoHTTPProtocol: Type[asyncio.Protocol]
+try:
+    import httptools  # noqa
+except ImportError:  # pragma: no cover
+    from uvicorn.protocols.http.h11_impl import H11Protocol
+
+    AutoHTTPProtocol = H11Protocol
+else:  # pragma: no cover
+    from uvicorn.protocols.http.httptools_impl import HttpToolsProtocol
+
+    AutoHTTPProtocol = HttpToolsProtocol
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/flow_control.py b/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/flow_control.py
new file mode 100644
index 0000000..a499923
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/flow_control.py
@@ -0,0 +1,66 @@
+import asyncio
+
+from asgiref.typing import (
+    ASGIReceiveCallable,
+    ASGISendCallable,
+    HTTPResponseBodyEvent,
+    HTTPResponseStartEvent,
+    Scope,
+)
+
+CLOSE_HEADER = (b"connection", b"close")
+
+HIGH_WATER_LIMIT = 65536
+
+
+class FlowControl:
+    def __init__(self, transport: asyncio.Transport) -> None:
+        self._transport = transport
+        self.read_paused = False
+        self.write_paused = False
+        self._is_writable_event = asyncio.Event()
+        self._is_writable_event.set()
+
+    async def drain(self) -> None:
+        await self._is_writable_event.wait()
+
+    def pause_reading(self) -> None:
+        if not self.read_paused:
+            self.read_paused = True
+            self._transport.pause_reading()
+
+    def resume_reading(self) -> None:
+        if self.read_paused:
+            self.read_paused = False
+            self._transport.resume_reading()
+
+    def pause_writing(self) -> None:
+        if not self.write_paused:
+            self.write_paused = True
+            self._is_writable_event.clear()
+
+    def resume_writing(self) -> None:
+        if self.write_paused:
+            self.write_paused = False
+            self._is_writable_event.set()
+
+
+async def service_unavailable(
+    scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable
+) -> None:
+    response_start: HTTPResponseStartEvent = {
+        "type": "http.response.start",
+        "status": 503,
+        "headers": [
+            (b"content-type", b"text/plain; charset=utf-8"),
+            (b"connection", b"close"),
+        ],
+    }
+    await send(response_start)
+
+    response_body: HTTPResponseBodyEvent = {
+        "type": "http.response.body",
+        "body": b"Service Unavailable",
+        "more_body": False,
+    }
+    await send(response_body)
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/h11_impl.py b/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/h11_impl.py
new file mode 100644
index 0000000..04b997f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/h11_impl.py
@@ -0,0 +1,516 @@
+import asyncio
+import http
+import logging
+from typing import Callable
+from urllib.parse import unquote
+
+import h11
+
+from uvicorn.logging import TRACE_LOG_LEVEL
+from uvicorn.protocols.http.flow_control import (
+    CLOSE_HEADER,
+    HIGH_WATER_LIMIT,
+    FlowControl,
+    service_unavailable,
+)
+from uvicorn.protocols.utils import (
+    get_client_addr,
+    get_local_addr,
+    get_path_with_query_string,
+    get_remote_addr,
+    is_ssl,
+)
+
+
+def _get_status_phrase(status_code):
+    try:
+        return http.HTTPStatus(status_code).phrase.encode()
+    except ValueError:
+        return b""
+
+
+STATUS_PHRASES = {
+    status_code: _get_status_phrase(status_code) for status_code in range(100, 600)
+}
+
+
+class H11Protocol(asyncio.Protocol):
+    def __init__(
+        self, config, server_state, on_connection_lost: Callable = None, _loop=None
+    ):
+        if not config.loaded:
+            config.load()
+
+        self.config = config
+        self.app = config.loaded_app
+        self.on_connection_lost = on_connection_lost
+        self.loop = _loop or asyncio.get_event_loop()
+        self.logger = logging.getLogger("uvicorn.error")
+        self.access_logger = logging.getLogger("uvicorn.access")
+        self.access_log = self.access_logger.hasHandlers()
+        self.conn = h11.Connection(h11.SERVER)
+        self.ws_protocol_class = config.ws_protocol_class
+        self.root_path = config.root_path
+        self.limit_concurrency = config.limit_concurrency
+
+        # Timeouts
+        self.timeout_keep_alive_task = None
+        self.timeout_keep_alive = config.timeout_keep_alive
+
+        # Shared server state
+        self.server_state = server_state
+        self.connections = server_state.connections
+        self.tasks = server_state.tasks
+        self.default_headers = server_state.default_headers
+
+        # Per-connection state
+        self.transport = None
+        self.flow = None
+        self.server = None
+        self.client = None
+        self.scheme = None
+
+        # Per-request state
+        self.scope = None
+        self.headers = None
+        self.cycle = None
+
+    # Protocol interface
+    def connection_made(self, transport):
+        self.connections.add(self)
+
+        self.transport = transport
+        self.flow = FlowControl(transport)
+        self.server = get_local_addr(transport)
+        self.client = get_remote_addr(transport)
+        self.scheme = "https" if is_ssl(transport) else "http"
+
+        if self.logger.level <= TRACE_LOG_LEVEL:
+            prefix = "%s:%d - " % tuple(self.client) if self.client else ""
+            self.logger.log(TRACE_LOG_LEVEL, "%sHTTP connection made", prefix)
+
+    def connection_lost(self, exc):
+        self.connections.discard(self)
+
+        if self.logger.level <= TRACE_LOG_LEVEL:
+            prefix = "%s:%d - " % tuple(self.client) if self.client else ""
+            self.logger.log(TRACE_LOG_LEVEL, "%sHTTP connection lost", prefix)
+
+        if self.cycle and not self.cycle.response_complete:
+            self.cycle.disconnected = True
+        if self.conn.our_state != h11.ERROR:
+            event = h11.ConnectionClosed()
+            try:
+                self.conn.send(event)
+            except h11.LocalProtocolError:
+                # Premature client disconnect
+                pass
+
+        if self.cycle is not None:
+            self.cycle.message_event.set()
+        if self.flow is not None:
+            self.flow.resume_writing()
+        if exc is None:
+            self.transport.close()
+
+        if self.on_connection_lost is not None:
+            self.on_connection_lost()
+
+    def eof_received(self):
+        pass
+
+    def _unset_keepalive_if_required(self):
+        if self.timeout_keep_alive_task is not None:
+            self.timeout_keep_alive_task.cancel()
+            self.timeout_keep_alive_task = None
+
+    def data_received(self, data):
+        self._unset_keepalive_if_required()
+
+        self.conn.receive_data(data)
+        self.handle_events()
+
+    def handle_events(self):
+        while True:
+            try:
+                event = self.conn.next_event()
+            except h11.RemoteProtocolError as exc:
+                msg = "Invalid HTTP request received."
+                self.logger.warning(msg, exc_info=exc)
+                self.transport.close()
+                return
+            event_type = type(event)
+
+            if event_type is h11.NEED_DATA:
+                break
+
+            elif event_type is h11.PAUSED:
+                # This case can occur in HTTP pipelining, so we need to
+                # stop reading any more data, and ensure that at the end
+                # of the active request/response cycle we handle any
+                # events that have been buffered up.
+                self.flow.pause_reading()
+                break
+
+            elif event_type is h11.Request:
+                self.headers = [(key.lower(), value) for key, value in event.headers]
+                raw_path, _, query_string = event.target.partition(b"?")
+                self.scope = {
+                    "type": "http",
+                    "asgi": {
+                        "version": self.config.asgi_version,
+                        "spec_version": "2.1",
+                    },
+                    "http_version": event.http_version.decode("ascii"),
+                    "server": self.server,
+                    "client": self.client,
+                    "scheme": self.scheme,
+                    "method": event.method.decode("ascii"),
+                    "root_path": self.root_path,
+                    "path": unquote(raw_path.decode("ascii")),
+                    "raw_path": raw_path,
+                    "query_string": query_string,
+                    "headers": self.headers,
+                }
+
+                for name, value in self.headers:
+                    if name == b"connection":
+                        tokens = [token.lower().strip() for token in value.split(b",")]
+                        if b"upgrade" in tokens:
+                            self.handle_upgrade(event)
+                            return
+
+                # Handle 503 responses when 'limit_concurrency' is exceeded.
+                if self.limit_concurrency is not None and (
+                    len(self.connections) >= self.limit_concurrency
+                    or len(self.tasks) >= self.limit_concurrency
+                ):
+                    app = service_unavailable
+                    message = "Exceeded concurrency limit."
+                    self.logger.warning(message)
+                else:
+                    app = self.app
+
+                self.cycle = RequestResponseCycle(
+                    scope=self.scope,
+                    conn=self.conn,
+                    transport=self.transport,
+                    flow=self.flow,
+                    logger=self.logger,
+                    access_logger=self.access_logger,
+                    access_log=self.access_log,
+                    default_headers=self.default_headers,
+                    message_event=asyncio.Event(),
+                    on_response=self.on_response_complete,
+                )
+                task = self.loop.create_task(self.cycle.run_asgi(app))
+                task.add_done_callback(self.tasks.discard)
+                self.tasks.add(task)
+
+            elif event_type is h11.Data:
+                if self.conn.our_state is h11.DONE:
+                    continue
+                self.cycle.body += event.data
+                if len(self.cycle.body) > HIGH_WATER_LIMIT:
+                    self.flow.pause_reading()
+                self.cycle.message_event.set()
+
+            elif event_type is h11.EndOfMessage:
+                if self.conn.our_state is h11.DONE:
+                    self.transport.resume_reading()
+                    self.conn.start_next_cycle()
+                    continue
+                self.cycle.more_body = False
+                self.cycle.message_event.set()
+
+    def handle_upgrade(self, event):
+        upgrade_value = None
+        for name, value in self.headers:
+            if name == b"upgrade":
+                upgrade_value = value.lower()
+
+        if upgrade_value != b"websocket" or self.ws_protocol_class is None:
+            msg = "Unsupported upgrade request."
+            self.logger.warning(msg)
+
+            from uvicorn.protocols.websockets.auto import AutoWebSocketsProtocol
+
+            if AutoWebSocketsProtocol is None:
+                msg = "No supported WebSocket library detected. Please use 'pip install uvicorn[standard]', or install 'websockets' or 'wsproto' manually."  # noqa: E501
+                self.logger.warning(msg)
+
+            reason = STATUS_PHRASES[400]
+            headers = [
+                (b"content-type", b"text/plain; charset=utf-8"),
+                (b"connection", b"close"),
+            ]
+            event = h11.Response(status_code=400, headers=headers, reason=reason)
+            output = self.conn.send(event)
+            self.transport.write(output)
+            event = h11.Data(data=b"Unsupported upgrade request.")
+            output = self.conn.send(event)
+            self.transport.write(output)
+            event = h11.EndOfMessage()
+            output = self.conn.send(event)
+            self.transport.write(output)
+            self.transport.close()
+            return
+
+        if self.logger.level <= TRACE_LOG_LEVEL:
+            prefix = "%s:%d - " % tuple(self.client) if self.client else ""
+            self.logger.log(TRACE_LOG_LEVEL, "%sUpgrading to WebSocket", prefix)
+
+        self.connections.discard(self)
+        output = [event.method, b" ", event.target, b" HTTP/1.1\r\n"]
+        for name, value in self.headers:
+            output += [name, b": ", value, b"\r\n"]
+        output.append(b"\r\n")
+        protocol = self.ws_protocol_class(
+            config=self.config,
+            server_state=self.server_state,
+            on_connection_lost=self.on_connection_lost,
+        )
+        protocol.connection_made(self.transport)
+        protocol.data_received(b"".join(output))
+        self.transport.set_protocol(protocol)
+
+    def on_response_complete(self):
+        self.server_state.total_requests += 1
+
+        if self.transport.is_closing():
+            return
+
+        # Set a short Keep-Alive timeout.
+        self._unset_keepalive_if_required()
+
+        self.timeout_keep_alive_task = self.loop.call_later(
+            self.timeout_keep_alive, self.timeout_keep_alive_handler
+        )
+
+        # Unpause data reads if needed.
+        self.flow.resume_reading()
+
+        # Unblock any pipelined events.
+        if self.conn.our_state is h11.DONE and self.conn.their_state is h11.DONE:
+            self.conn.start_next_cycle()
+            self.handle_events()
+
+    def shutdown(self):
+        """
+        Called by the server to commence a graceful shutdown.
+        """
+        if self.cycle is None or self.cycle.response_complete:
+            event = h11.ConnectionClosed()
+            self.conn.send(event)
+            self.transport.close()
+        else:
+            self.cycle.keep_alive = False
+
+    def pause_writing(self):
+        """
+        Called by the transport when the write buffer exceeds the high water mark.
+        """
+        self.flow.pause_writing()
+
+    def resume_writing(self):
+        """
+        Called by the transport when the write buffer drops below the low water mark.
+        """
+        self.flow.resume_writing()
+
+    def timeout_keep_alive_handler(self):
+        """
+        Called on a keep-alive connection if no new data is received after a short
+        delay.
+        """
+        if not self.transport.is_closing():
+            event = h11.ConnectionClosed()
+            self.conn.send(event)
+            self.transport.close()
+
+
+class RequestResponseCycle:
+    def __init__(
+        self,
+        scope,
+        conn,
+        transport,
+        flow,
+        logger,
+        access_logger,
+        access_log,
+        default_headers,
+        message_event,
+        on_response,
+    ):
+        self.scope = scope
+        self.conn = conn
+        self.transport = transport
+        self.flow = flow
+        self.logger = logger
+        self.access_logger = access_logger
+        self.access_log = access_log
+        self.default_headers = default_headers
+        self.message_event = message_event
+        self.on_response = on_response
+
+        # Connection state
+        self.disconnected = False
+        self.keep_alive = True
+        self.waiting_for_100_continue = conn.they_are_waiting_for_100_continue
+
+        # Request state
+        self.body = b""
+        self.more_body = True
+
+        # Response state
+        self.response_started = False
+        self.response_complete = False
+
+    # ASGI exception wrapper
+    async def run_asgi(self, app):
+        try:
+            result = await app(self.scope, self.receive, self.send)
+        except BaseException as exc:
+            msg = "Exception in ASGI application\n"
+            self.logger.error(msg, exc_info=exc)
+            if not self.response_started:
+                await self.send_500_response()
+            else:
+                self.transport.close()
+        else:
+            if result is not None:
+                msg = "ASGI callable should return None, but returned '%s'."
+                self.logger.error(msg, result)
+                self.transport.close()
+            elif not self.response_started and not self.disconnected:
+                msg = "ASGI callable returned without starting response."
+                self.logger.error(msg)
+                await self.send_500_response()
+            elif not self.response_complete and not self.disconnected:
+                msg = "ASGI callable returned without completing response."
+                self.logger.error(msg)
+                self.transport.close()
+        finally:
+            self.on_response = None
+
+    async def send_500_response(self):
+        await self.send(
+            {
+                "type": "http.response.start",
+                "status": 500,
+                "headers": [
+                    (b"content-type", b"text/plain; charset=utf-8"),
+                    (b"connection", b"close"),
+                ],
+            }
+        )
+        await self.send(
+            {"type": "http.response.body", "body": b"Internal Server Error"}
+        )
+
+    # ASGI interface
+    async def send(self, message):
+        message_type = message["type"]
+
+        if self.flow.write_paused and not self.disconnected:
+            await self.flow.drain()
+
+        if self.disconnected:
+            return
+
+        if not self.response_started:
+            # Sending response status line and headers
+            if message_type != "http.response.start":
+                msg = "Expected ASGI message 'http.response.start', but got '%s'."
+                raise RuntimeError(msg % message_type)
+
+            self.response_started = True
+            self.waiting_for_100_continue = False
+
+            status_code = message["status"]
+            headers = self.default_headers + message.get("headers", [])
+
+            if CLOSE_HEADER in self.scope["headers"] and CLOSE_HEADER not in headers:
+                headers = headers + [CLOSE_HEADER]
+
+            if self.access_log:
+                self.access_logger.info(
+                    '%s - "%s %s HTTP/%s" %d',
+                    get_client_addr(self.scope),
+                    self.scope["method"],
+                    get_path_with_query_string(self.scope),
+                    self.scope["http_version"],
+                    status_code,
+                )
+
+            # Write response status line and headers
+            reason = STATUS_PHRASES[status_code]
+            event = h11.Response(
+                status_code=status_code, headers=headers, reason=reason
+            )
+            output = self.conn.send(event)
+            self.transport.write(output)
+
+        elif not self.response_complete:
+            # Sending response body
+            if message_type != "http.response.body":
+                msg = "Expected ASGI message 'http.response.body', but got '%s'."
+                raise RuntimeError(msg % message_type)
+
+            body = message.get("body", b"")
+            more_body = message.get("more_body", False)
+
+            # Write response body
+            if self.scope["method"] == "HEAD":
+                event = h11.Data(data=b"")
+            else:
+                event = h11.Data(data=body)
+            output = self.conn.send(event)
+            self.transport.write(output)
+
+            # Handle response completion
+            if not more_body:
+                self.response_complete = True
+                self.message_event.set()
+                event = h11.EndOfMessage()
+                output = self.conn.send(event)
+                self.transport.write(output)
+
+        else:
+            # Response already sent
+            msg = "Unexpected ASGI message '%s' sent, after response already completed."
+            raise RuntimeError(msg % message_type)
+
+        if self.response_complete:
+            if self.conn.our_state is h11.MUST_CLOSE or not self.keep_alive:
+                event = h11.ConnectionClosed()
+                self.conn.send(event)
+                self.transport.close()
+            self.on_response()
+
+    async def receive(self):
+        if self.waiting_for_100_continue and not self.transport.is_closing():
+            event = h11.InformationalResponse(
+                status_code=100, headers=[], reason="Continue"
+            )
+            output = self.conn.send(event)
+            self.transport.write(output)
+            self.waiting_for_100_continue = False
+
+        if not self.disconnected and not self.response_complete:
+            self.flow.resume_reading()
+            await self.message_event.wait()
+            self.message_event.clear()
+
+        if self.disconnected or self.response_complete:
+            message = {"type": "http.disconnect"}
+        else:
+            message = {
+                "type": "http.request",
+                "body": self.body,
+                "more_body": self.more_body,
+            }
+            self.body = b""
+
+        return message
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/httptools_impl.py b/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/httptools_impl.py
new file mode 100644
index 0000000..33e21dc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/protocols/http/httptools_impl.py
@@ -0,0 +1,545 @@
+import asyncio
+import http
+import logging
+import re
+import urllib
+from collections import deque
+from typing import Callable
+
+import httptools
+
+from uvicorn.logging import TRACE_LOG_LEVEL
+from uvicorn.protocols.http.flow_control import (
+    CLOSE_HEADER,
+    HIGH_WATER_LIMIT,
+    FlowControl,
+    service_unavailable,
+)
+from uvicorn.protocols.utils import (
+    get_client_addr,
+    get_local_addr,
+    get_path_with_query_string,
+    get_remote_addr,
+    is_ssl,
+)
+
+HEADER_RE = re.compile(b'[\x00-\x1F\x7F()<>@,;:[]={} \t\\"]')
+HEADER_VALUE_RE = re.compile(b"[\x00-\x1F\x7F]")
+
+
+def _get_status_line(status_code):
+    try:
+        phrase = http.HTTPStatus(status_code).phrase.encode()
+    except ValueError:
+        phrase = b""
+    return b"".join([b"HTTP/1.1 ", str(status_code).encode(), b" ", phrase, b"\r\n"])
+
+
+STATUS_LINE = {
+    status_code: _get_status_line(status_code) for status_code in range(100, 600)
+}
+
+
+class HttpToolsProtocol(asyncio.Protocol):
+    def __init__(
+        self, config, server_state, on_connection_lost: Callable = None, _loop=None
+    ):
+        if not config.loaded:
+            config.load()
+
+        self.config = config
+        self.app = config.loaded_app
+        self.on_connection_lost = on_connection_lost
+        self.loop = _loop or asyncio.get_event_loop()
+        self.logger = logging.getLogger("uvicorn.error")
+        self.access_logger = logging.getLogger("uvicorn.access")
+        self.access_log = self.access_logger.hasHandlers()
+        self.parser = httptools.HttpRequestParser(self)
+        self.ws_protocol_class = config.ws_protocol_class
+        self.root_path = config.root_path
+        self.limit_concurrency = config.limit_concurrency
+
+        # Timeouts
+        self.timeout_keep_alive_task = None
+        self.timeout_keep_alive = config.timeout_keep_alive
+
+        # Global state
+        self.server_state = server_state
+        self.connections = server_state.connections
+        self.tasks = server_state.tasks
+        self.default_headers = server_state.default_headers
+
+        # Per-connection state
+        self.transport = None
+        self.flow = None
+        self.server = None
+        self.client = None
+        self.scheme = None
+        self.pipeline = deque()
+
+        # Per-request state
+        self.url = None
+        self.scope = None
+        self.headers = None
+        self.expect_100_continue = False
+        self.cycle = None
+
+    # Protocol interface
+    def connection_made(self, transport):
+        self.connections.add(self)
+
+        self.transport = transport
+        self.flow = FlowControl(transport)
+        self.server = get_local_addr(transport)
+        self.client = get_remote_addr(transport)
+        self.scheme = "https" if is_ssl(transport) else "http"
+
+        if self.logger.level <= TRACE_LOG_LEVEL:
+            prefix = "%s:%d - " % tuple(self.client) if self.client else ""
+            self.logger.log(TRACE_LOG_LEVEL, "%sHTTP connection made", prefix)
+
+    def connection_lost(self, exc):
+        self.connections.discard(self)
+
+        if self.logger.level <= TRACE_LOG_LEVEL:
+            prefix = "%s:%d - " % tuple(self.client) if self.client else ""
+            self.logger.log(TRACE_LOG_LEVEL, "%sHTTP connection lost", prefix)
+
+        if self.cycle and not self.cycle.response_complete:
+            self.cycle.disconnected = True
+        if self.cycle is not None:
+            self.cycle.message_event.set()
+        if self.flow is not None:
+            self.flow.resume_writing()
+        if exc is None:
+            self.transport.close()
+
+        if self.on_connection_lost is not None:
+            self.on_connection_lost()
+
+    def eof_received(self):
+        pass
+
+    def _unset_keepalive_if_required(self):
+        if self.timeout_keep_alive_task is not None:
+            self.timeout_keep_alive_task.cancel()
+            self.timeout_keep_alive_task = None
+
+    def data_received(self, data):
+        self._unset_keepalive_if_required()
+
+        try:
+            self.parser.feed_data(data)
+        except httptools.HttpParserError as exc:
+            msg = "Invalid HTTP request received."
+            self.logger.warning(msg, exc_info=exc)
+            self.transport.close()
+        except httptools.HttpParserUpgrade:
+            self.handle_upgrade()
+
+    def handle_upgrade(self):
+        upgrade_value = None
+        for name, value in self.headers:
+            if name == b"upgrade":
+                upgrade_value = value.lower()
+
+        if upgrade_value != b"websocket" or self.ws_protocol_class is None:
+            msg = "Unsupported upgrade request."
+            self.logger.warning(msg)
+
+            from uvicorn.protocols.websockets.auto import AutoWebSocketsProtocol
+
+            if AutoWebSocketsProtocol is None:
+                msg = "No supported WebSocket library detected. Please use 'pip install uvicorn[standard]', or install 'websockets' or 'wsproto' manually."  # noqa: E501
+                self.logger.warning(msg)
+
+            content = [STATUS_LINE[400]]
+            for name, value in self.default_headers:
+                content.extend([name, b": ", value, b"\r\n"])
+            content.extend(
+                [
+                    b"content-type: text/plain; charset=utf-8\r\n",
+                    b"content-length: " + str(len(msg)).encode("ascii") + b"\r\n",
+                    b"connection: close\r\n",
+                    b"\r\n",
+                    msg.encode("ascii"),
+                ]
+            )
+            self.transport.write(b"".join(content))
+            self.transport.close()
+            return
+
+        if self.logger.level <= TRACE_LOG_LEVEL:
+            prefix = "%s:%d - " % tuple(self.client) if self.client else ""
+            self.logger.log(TRACE_LOG_LEVEL, "%sUpgrading to WebSocket", prefix)
+
+        self.connections.discard(self)
+        method = self.scope["method"].encode()
+        output = [method, b" ", self.url, b" HTTP/1.1\r\n"]
+        for name, value in self.scope["headers"]:
+            output += [name, b": ", value, b"\r\n"]
+        output.append(b"\r\n")
+        protocol = self.ws_protocol_class(
+            config=self.config,
+            server_state=self.server_state,
+            on_connection_lost=self.on_connection_lost,
+        )
+        protocol.connection_made(self.transport)
+        protocol.data_received(b"".join(output))
+        self.transport.set_protocol(protocol)
+
+    # Parser callbacks
+    def on_url(self, url):
+        method = self.parser.get_method()
+        parsed_url = httptools.parse_url(url)
+        raw_path = parsed_url.path
+        path = raw_path.decode("ascii")
+        if "%" in path:
+            path = urllib.parse.unquote(path)
+        self.url = url
+        self.expect_100_continue = False
+        self.headers = []
+        self.scope = {
+            "type": "http",
+            "asgi": {"version": self.config.asgi_version, "spec_version": "2.1"},
+            "http_version": "1.1",
+            "server": self.server,
+            "client": self.client,
+            "scheme": self.scheme,
+            "method": method.decode("ascii"),
+            "root_path": self.root_path,
+            "path": path,
+            "raw_path": raw_path,
+            "query_string": parsed_url.query if parsed_url.query else b"",
+            "headers": self.headers,
+        }
+
+    def on_header(self, name: bytes, value: bytes):
+        name = name.lower()
+        if name == b"expect" and value.lower() == b"100-continue":
+            self.expect_100_continue = True
+        self.headers.append((name, value))
+
+    def on_headers_complete(self):
+        http_version = self.parser.get_http_version()
+        if http_version != "1.1":
+            self.scope["http_version"] = http_version
+        if self.parser.should_upgrade():
+            return
+
+        # Handle 503 responses when 'limit_concurrency' is exceeded.
+        if self.limit_concurrency is not None and (
+            len(self.connections) >= self.limit_concurrency
+            or len(self.tasks) >= self.limit_concurrency
+        ):
+            app = service_unavailable
+            message = "Exceeded concurrency limit."
+            self.logger.warning(message)
+        else:
+            app = self.app
+
+        existing_cycle = self.cycle
+        self.cycle = RequestResponseCycle(
+            scope=self.scope,
+            transport=self.transport,
+            flow=self.flow,
+            logger=self.logger,
+            access_logger=self.access_logger,
+            access_log=self.access_log,
+            default_headers=self.default_headers,
+            message_event=asyncio.Event(),
+            expect_100_continue=self.expect_100_continue,
+            keep_alive=http_version != "1.0",
+            on_response=self.on_response_complete,
+        )
+        if existing_cycle is None or existing_cycle.response_complete:
+            # Standard case - start processing the request.
+            task = self.loop.create_task(self.cycle.run_asgi(app))
+            task.add_done_callback(self.tasks.discard)
+            self.tasks.add(task)
+        else:
+            # Pipelined HTTP requests need to be queued up.
+            self.flow.pause_reading()
+            self.pipeline.appendleft((self.cycle, app))
+
+    def on_body(self, body: bytes):
+        if self.parser.should_upgrade() or self.cycle.response_complete:
+            return
+        self.cycle.body += body
+        if len(self.cycle.body) > HIGH_WATER_LIMIT:
+            self.flow.pause_reading()
+        self.cycle.message_event.set()
+
+    def on_message_complete(self):
+        if self.parser.should_upgrade() or self.cycle.response_complete:
+            return
+        self.cycle.more_body = False
+        self.cycle.message_event.set()
+
+    def on_response_complete(self):
+        # Callback for pipelined HTTP requests to be started.
+        self.server_state.total_requests += 1
+
+        if self.transport.is_closing():
+            return
+
+        # Set a short Keep-Alive timeout.
+        self._unset_keepalive_if_required()
+
+        self.timeout_keep_alive_task = self.loop.call_later(
+            self.timeout_keep_alive, self.timeout_keep_alive_handler
+        )
+
+        # Unpause data reads if needed.
+        self.flow.resume_reading()
+
+        # Unblock any pipelined events.
+        if self.pipeline:
+            cycle, app = self.pipeline.pop()
+            task = self.loop.create_task(cycle.run_asgi(app))
+            task.add_done_callback(self.tasks.discard)
+            self.tasks.add(task)
+
+    def shutdown(self):
+        """
+        Called by the server to commence a graceful shutdown.
+        """
+        if self.cycle is None or self.cycle.response_complete:
+            self.transport.close()
+        else:
+            self.cycle.keep_alive = False
+
+    def pause_writing(self):
+        """
+        Called by the transport when the write buffer exceeds the high water mark.
+        """
+        self.flow.pause_writing()
+
+    def resume_writing(self):
+        """
+        Called by the transport when the write buffer drops below the low water mark.
+        """
+        self.flow.resume_writing()
+
+    def timeout_keep_alive_handler(self):
+        """
+        Called on a keep-alive connection if no new data is received after a short
+        delay.
+        """
+        if not self.transport.is_closing():
+            self.transport.close()
+
+
+class RequestResponseCycle:
+    def __init__(
+        self,
+        scope,
+        transport,
+        flow,
+        logger,
+        access_logger,
+        access_log,
+        default_headers,
+        message_event,
+        expect_100_continue,
+        keep_alive,
+        on_response,
+    ):
+        self.scope = scope
+        self.transport = transport
+        self.flow = flow
+        self.logger = logger
+        self.access_logger = access_logger
+        self.access_log = access_log
+        self.default_headers = default_headers
+        self.message_event = message_event
+        self.on_response = on_response
+
+        # Connection state
+        self.disconnected = False
+        self.keep_alive = keep_alive
+        self.waiting_for_100_continue = expect_100_continue
+
+        # Request state
+        self.body = b""
+        self.more_body = True
+
+        # Response state
+        self.response_started = False
+        self.response_complete = False
+        self.chunked_encoding = None
+        self.expected_content_length = 0
+
+    # ASGI exception wrapper
+    async def run_asgi(self, app):
+        try:
+            result = await app(self.scope, self.receive, self.send)
+        except BaseException as exc:
+            msg = "Exception in ASGI application\n"
+            self.logger.error(msg, exc_info=exc)
+            if not self.response_started:
+                await self.send_500_response()
+            else:
+                self.transport.close()
+        else:
+            if result is not None:
+                msg = "ASGI callable should return None, but returned '%s'."
+                self.logger.error(msg, result)
+                self.transport.close()
+            elif not self.response_started and not self.disconnected:
+                msg = "ASGI callable returned without starting response."
+                self.logger.error(msg)
+                await self.send_500_response()
+            elif not self.response_complete and not self.disconnected:
+                msg = "ASGI callable returned without completing response."
+                self.logger.error(msg)
+                self.transport.close()
+        finally:
+            self.on_response = None
+
+    async def send_500_response(self):
+        await self.send(
+            {
+                "type": "http.response.start",
+                "status": 500,
+                "headers": [
+                    (b"content-type", b"text/plain; charset=utf-8"),
+                    (b"connection", b"close"),
+                ],
+            }
+        )
+        await self.send(
+            {"type": "http.response.body", "body": b"Internal Server Error"}
+        )
+
+    # ASGI interface
+    async def send(self, message):
+        message_type = message["type"]
+
+        if self.flow.write_paused and not self.disconnected:
+            await self.flow.drain()
+
+        if self.disconnected:
+            return
+
+        if not self.response_started:
+            # Sending response status line and headers
+            if message_type != "http.response.start":
+                msg = "Expected ASGI message 'http.response.start', but got '%s'."
+                raise RuntimeError(msg % message_type)
+
+            self.response_started = True
+            self.waiting_for_100_continue = False
+
+            status_code = message["status"]
+            headers = self.default_headers + list(message.get("headers", []))
+
+            if CLOSE_HEADER in self.scope["headers"] and CLOSE_HEADER not in headers:
+                headers = headers + [CLOSE_HEADER]
+
+            if self.access_log:
+                self.access_logger.info(
+                    '%s - "%s %s HTTP/%s" %d',
+                    get_client_addr(self.scope),
+                    self.scope["method"],
+                    get_path_with_query_string(self.scope),
+                    self.scope["http_version"],
+                    status_code,
+                )
+
+            # Write response status line and headers
+            content = [STATUS_LINE[status_code]]
+
+            for name, value in headers:
+                if HEADER_RE.search(name):
+                    raise RuntimeError("Invalid HTTP header name.")
+                if HEADER_VALUE_RE.search(value):
+                    raise RuntimeError("Invalid HTTP header value.")
+
+                name = name.lower()
+                if name == b"content-length" and self.chunked_encoding is None:
+                    self.expected_content_length = int(value.decode())
+                    self.chunked_encoding = False
+                elif name == b"transfer-encoding" and value.lower() == b"chunked":
+                    self.expected_content_length = 0
+                    self.chunked_encoding = True
+                elif name == b"connection" and value.lower() == b"close":
+                    self.keep_alive = False
+                content.extend([name, b": ", value, b"\r\n"])
+
+            if (
+                self.chunked_encoding is None
+                and self.scope["method"] != "HEAD"
+                and status_code not in (204, 304)
+            ):
+                # Neither content-length nor transfer-encoding specified
+                self.chunked_encoding = True
+                content.append(b"transfer-encoding: chunked\r\n")
+
+            content.append(b"\r\n")
+            self.transport.write(b"".join(content))
+
+        elif not self.response_complete:
+            # Sending response body
+            if message_type != "http.response.body":
+                msg = "Expected ASGI message 'http.response.body', but got '%s'."
+                raise RuntimeError(msg % message_type)
+
+            body = message.get("body", b"")
+            more_body = message.get("more_body", False)
+
+            # Write response body
+            if self.scope["method"] == "HEAD":
+                self.expected_content_length = 0
+            elif self.chunked_encoding:
+                if body:
+                    content = [b"%x\r\n" % len(body), body, b"\r\n"]
+                else:
+                    content = []
+                if not more_body:
+                    content.append(b"0\r\n\r\n")
+                self.transport.write(b"".join(content))
+            else:
+                num_bytes = len(body)
+                if num_bytes > self.expected_content_length:
+                    raise RuntimeError("Response content longer than Content-Length")
+                else:
+                    self.expected_content_length -= num_bytes
+                self.transport.write(body)
+
+            # Handle response completion
+            if not more_body:
+                if self.expected_content_length != 0:
+                    raise RuntimeError("Response content shorter than Content-Length")
+                self.response_complete = True
+                self.message_event.set()
+                if not self.keep_alive:
+                    self.transport.close()
+                self.on_response()
+
+        else:
+            # Response already sent
+            msg = "Unexpected ASGI message '%s' sent, after response already completed."
+            raise RuntimeError(msg % message_type)
+
+    async def receive(self):
+        if self.waiting_for_100_continue and not self.transport.is_closing():
+            self.transport.write(b"HTTP/1.1 100 Continue\r\n\r\n")
+            self.waiting_for_100_continue = False
+
+        if not self.disconnected and not self.response_complete:
+            self.flow.resume_reading()
+            await self.message_event.wait()
+            self.message_event.clear()
+
+        if self.disconnected or self.response_complete:
+            message = {"type": "http.disconnect"}
+        else:
+            message = {
+                "type": "http.request",
+                "body": self.body,
+                "more_body": self.more_body,
+            }
+            self.body = b""
+
+        return message
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/protocols/utils.py b/myenv/lib/python3.9/site-packages/uvicorn/protocols/utils.py
new file mode 100644
index 0000000..bbc84f7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/protocols/utils.py
@@ -0,0 +1,56 @@
+import asyncio
+import urllib.parse
+from typing import Optional, Tuple
+
+from asgiref.typing import WWWScope
+
+
+def get_remote_addr(transport: asyncio.Transport) -> Optional[Tuple[str, int]]:
+    socket_info = transport.get_extra_info("socket")
+    if socket_info is not None:
+        try:
+            info = socket_info.getpeername()
+            return (str(info[0]), int(info[1])) if isinstance(info, tuple) else None
+        except OSError:
+            # This case appears to inconsistently occur with uvloop
+            # bound to a unix domain socket.
+            return None
+
+    info = transport.get_extra_info("peername")
+    if info is not None and isinstance(info, (list, tuple)) and len(info) == 2:
+        return (str(info[0]), int(info[1]))
+    return None
+
+
+def get_local_addr(transport: asyncio.Transport) -> Optional[Tuple[str, int]]:
+    socket_info = transport.get_extra_info("socket")
+    if socket_info is not None:
+        info = socket_info.getsockname()
+
+        return (str(info[0]), int(info[1])) if isinstance(info, tuple) else None
+    info = transport.get_extra_info("sockname")
+    if info is not None and isinstance(info, (list, tuple)) and len(info) == 2:
+        return (str(info[0]), int(info[1]))
+    return None
+
+
+def is_ssl(transport: asyncio.Transport) -> bool:
+    return bool(transport.get_extra_info("sslcontext"))
+
+
+def get_client_addr(scope: WWWScope) -> str:
+    client = scope.get("client")
+    if not client:
+        return ""
+    return "%s:%d" % client
+
+
+def get_path_with_query_string(scope: WWWScope) -> str:
+    path_with_query_string = urllib.parse.quote(
+        scope.get("root_path", "") + scope["path"]
+    )
+    if scope["query_string"]:
+        path_with_query_string = "{}?{}".format(
+            path_with_query_string, scope["query_string"].decode("ascii")
+        )
+    return path_with_query_string
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/protocols/websockets/__init__.py b/myenv/lib/python3.9/site-packages/uvicorn/protocols/websockets/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/protocols/websockets/auto.py b/myenv/lib/python3.9/site-packages/uvicorn/protocols/websockets/auto.py
new file mode 100644
index 0000000..0dfba3b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/protocols/websockets/auto.py
@@ -0,0 +1,19 @@
+import asyncio
+import typing
+
+AutoWebSocketsProtocol: typing.Optional[typing.Type[asyncio.Protocol]]
+try:
+    import websockets  # noqa
+except ImportError:  # pragma: no cover
+    try:
+        import wsproto  # noqa
+    except ImportError:
+        AutoWebSocketsProtocol = None
+    else:
+        from uvicorn.protocols.websockets.wsproto_impl import WSProtocol
+
+        AutoWebSocketsProtocol = WSProtocol
+else:
+    from uvicorn.protocols.websockets.websockets_impl import WebSocketProtocol
+
+    AutoWebSocketsProtocol = WebSocketProtocol
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/protocols/websockets/websockets_impl.py b/myenv/lib/python3.9/site-packages/uvicorn/protocols/websockets/websockets_impl.py
new file mode 100644
index 0000000..7caabad
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/protocols/websockets/websockets_impl.py
@@ -0,0 +1,305 @@
+import asyncio
+import http
+import logging
+import sys
+from typing import Callable
+from urllib.parse import unquote
+
+import websockets
+from websockets.extensions.permessage_deflate import ServerPerMessageDeflateFactory
+
+from uvicorn.logging import TRACE_LOG_LEVEL
+from uvicorn.protocols.utils import get_local_addr, get_remote_addr, is_ssl
+
+
+class Server:
+    closing = False
+
+    def register(self, ws):
+        pass
+
+    def unregister(self, ws):
+        pass
+
+    def is_serving(self):
+        return not self.closing
+
+
+# special case logger kwarg in websockets >=10
+if sys.version_info >= (3, 7):
+
+    class _LoggerMixin:
+        pass
+
+
+else:
+
+    class _LoggerMixin:
+        def __init__(self, *args, logger, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.logger = logging.LoggerAdapter(logger, {"websocket": self})
+
+
+class WebSocketProtocol(_LoggerMixin, websockets.WebSocketServerProtocol):
+    def __init__(
+        self, config, server_state, on_connection_lost: Callable = None, _loop=None
+    ):
+        if not config.loaded:
+            config.load()
+
+        self.config = config
+        self.app = config.loaded_app
+        self.on_connection_lost = on_connection_lost
+        self.loop = _loop or asyncio.get_event_loop()
+        self.root_path = config.root_path
+
+        # Shared server state
+        self.connections = server_state.connections
+        self.tasks = server_state.tasks
+
+        # Connection state
+        self.transport = None
+        self.server = None
+        self.client = None
+        self.scheme = None
+
+        # Connection events
+        self.scope = None
+        self.handshake_started_event = asyncio.Event()
+        self.handshake_completed_event = asyncio.Event()
+        self.closed_event = asyncio.Event()
+        self.initial_response = None
+        self.connect_sent = False
+        self.accepted_subprotocol = None
+        self.transfer_data_task = None
+
+        self.ws_server = Server()
+        super().__init__(
+            ws_handler=self.ws_handler,
+            ws_server=self.ws_server,
+            max_size=self.config.ws_max_size,
+            ping_interval=self.config.ws_ping_interval,
+            ping_timeout=self.config.ws_ping_timeout,
+            extensions=[ServerPerMessageDeflateFactory()],
+            logger=logging.getLogger("uvicorn.error"),
+        )
+
+    def connection_made(self, transport):
+        self.connections.add(self)
+        self.transport = transport
+        self.server = get_local_addr(transport)
+        self.client = get_remote_addr(transport)
+        self.scheme = "wss" if is_ssl(transport) else "ws"
+
+        if self.logger.isEnabledFor(TRACE_LOG_LEVEL):
+            prefix = "%s:%d - " % tuple(self.client) if self.client else ""
+            self.logger.log(TRACE_LOG_LEVEL, "%sWebSocket connection made", prefix)
+
+        super().connection_made(transport)
+
+    def connection_lost(self, exc):
+        self.connections.remove(self)
+
+        if self.logger.isEnabledFor(TRACE_LOG_LEVEL):
+            prefix = "%s:%d - " % tuple(self.client) if self.client else ""
+            self.logger.log(TRACE_LOG_LEVEL, "%sWebSocket connection lost", prefix)
+
+        self.handshake_completed_event.set()
+        super().connection_lost(exc)
+        if self.on_connection_lost is not None:
+            self.on_connection_lost()
+        if exc is None:
+            self.transport.close()
+
+    def shutdown(self):
+        self.ws_server.closing = True
+        self.transport.close()
+
+    def on_task_complete(self, task):
+        self.tasks.discard(task)
+
+    async def process_request(self, path, headers):
+        """
+        This hook is called to determine if the websocket should return
+        an HTTP response and close.
+
+        Our behavior here is to start the ASGI application, and then wait
+        for either `accept` or `close` in order to determine if we should
+        close the connection.
+        """
+        path_portion, _, query_string = path.partition("?")
+
+        websockets.legacy.handshake.check_request(headers)
+
+        subprotocols = []
+        for header in headers.get_all("Sec-WebSocket-Protocol"):
+            subprotocols.extend([token.strip() for token in header.split(",")])
+
+        asgi_headers = [
+            (name.encode("ascii"), value.encode("ascii"))
+            for name, value in headers.raw_items()
+        ]
+
+        self.scope = {
+            "type": "websocket",
+            "asgi": {"version": self.config.asgi_version, "spec_version": "2.1"},
+            "scheme": self.scheme,
+            "server": self.server,
+            "client": self.client,
+            "root_path": self.root_path,
+            "path": unquote(path_portion),
+            "raw_path": path_portion,
+            "query_string": query_string.encode("ascii"),
+            "headers": asgi_headers,
+            "subprotocols": subprotocols,
+        }
+        task = self.loop.create_task(self.run_asgi())
+        task.add_done_callback(self.on_task_complete)
+        self.tasks.add(task)
+        await self.handshake_started_event.wait()
+        return self.initial_response
+
+    def process_subprotocol(self, headers, available_subprotocols):
+        """
+        We override the standard 'process_subprotocol' behavior here so that
+        we return whatever subprotocol is sent in the 'accept' message.
+        """
+        return self.accepted_subprotocol
+
+    def send_500_response(self):
+        msg = b"Internal Server Error"
+        content = [
+            b"HTTP/1.1 500 Internal Server Error\r\n"
+            b"content-type: text/plain; charset=utf-8\r\n",
+            b"content-length: " + str(len(msg)).encode("ascii") + b"\r\n",
+            b"connection: close\r\n",
+            b"\r\n",
+            msg,
+        ]
+        self.transport.write(b"".join(content))
+        # Allow handler task to terminate cleanly, as websockets doesn't cancel it by
+        # itself (see https://github.com/encode/uvicorn/issues/920)
+        self.handshake_started_event.set()
+
+    async def ws_handler(self, protocol, path):
+        """
+        This is the main handler function for the 'websockets' implementation
+        to call into. We just wait for close then return, and instead allow
+        'send' and 'receive' events to drive the flow.
+        """
+        self.handshake_completed_event.set()
+        await self.closed_event.wait()
+
+    async def run_asgi(self):
+        """
+        Wrapper around the ASGI callable, handling exceptions and unexpected
+        termination states.
+        """
+        try:
+            result = await self.app(self.scope, self.asgi_receive, self.asgi_send)
+        except BaseException as exc:
+            self.closed_event.set()
+            msg = "Exception in ASGI application\n"
+            self.logger.error(msg, exc_info=exc)
+            if not self.handshake_started_event.is_set():
+                self.send_500_response()
+            else:
+                await self.handshake_completed_event.wait()
+            self.transport.close()
+        else:
+            self.closed_event.set()
+            if not self.handshake_started_event.is_set():
+                msg = "ASGI callable returned without sending handshake."
+                self.logger.error(msg)
+                self.send_500_response()
+                self.transport.close()
+            elif result is not None:
+                msg = "ASGI callable should return None, but returned '%s'."
+                self.logger.error(msg, result)
+                await self.handshake_completed_event.wait()
+                self.transport.close()
+
+    async def asgi_send(self, message):
+        message_type = message["type"]
+
+        if not self.handshake_started_event.is_set():
+            if message_type == "websocket.accept":
+                self.logger.info(
+                    '%s - "WebSocket %s" [accepted]',
+                    self.scope["client"],
+                    self.scope["root_path"] + self.scope["path"],
+                )
+                self.initial_response = None
+                self.accepted_subprotocol = message.get("subprotocol")
+                self.handshake_started_event.set()
+
+            elif message_type == "websocket.close":
+                self.logger.info(
+                    '%s - "WebSocket %s" 403',
+                    self.scope["client"],
+                    self.scope["root_path"] + self.scope["path"],
+                )
+                self.initial_response = (http.HTTPStatus.FORBIDDEN, [], b"")
+                self.handshake_started_event.set()
+                self.closed_event.set()
+
+            else:
+                msg = (
+                    "Expected ASGI message 'websocket.accept' or 'websocket.close', "
+                    "but got '%s'."
+                )
+                raise RuntimeError(msg % message_type)
+
+        elif not self.closed_event.is_set():
+            await self.handshake_completed_event.wait()
+
+            if message_type == "websocket.send":
+                bytes_data = message.get("bytes")
+                text_data = message.get("text")
+                data = text_data if bytes_data is None else bytes_data
+                await self.send(data)
+
+            elif message_type == "websocket.close":
+                code = message.get("code", 1000)
+                reason = message.get("reason", "") or ""
+                await self.close(code, reason)
+                self.closed_event.set()
+
+            else:
+                msg = (
+                    "Expected ASGI message 'websocket.send' or 'websocket.close',"
+                    " but got '%s'."
+                )
+                raise RuntimeError(msg % message_type)
+
+        else:
+            msg = "Unexpected ASGI message '%s', after sending 'websocket.close'."
+            raise RuntimeError(msg % message_type)
+
+    async def asgi_receive(self):
+        if not self.connect_sent:
+            self.connect_sent = True
+            return {"type": "websocket.connect"}
+
+        await self.handshake_completed_event.wait()
+
+        if self.closed_event.is_set():
+            # If client disconnected, use WebSocketServerProtocol.close_code property.
+            # If the handshake failed or the app closed before handshake completion,
+            # use 1006 Abnormal Closure.
+            return {"type": "websocket.disconnect", "code": self.close_code or 1006}
+
+        try:
+            data = await self.recv()
+        except websockets.ConnectionClosed as exc:
+            self.closed_event.set()
+            return {"type": "websocket.disconnect", "code": exc.code}
+
+        msg = {"type": "websocket.receive"}
+
+        if isinstance(data, str):
+            msg["text"] = data
+        else:
+            msg["bytes"] = data
+
+        return msg
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/protocols/websockets/wsproto_impl.py b/myenv/lib/python3.9/site-packages/uvicorn/protocols/websockets/wsproto_impl.py
new file mode 100644
index 0000000..704d6b8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/protocols/websockets/wsproto_impl.py
@@ -0,0 +1,325 @@
+import asyncio
+import logging
+from typing import Callable
+from urllib.parse import unquote
+
+import h11
+import wsproto
+from wsproto import ConnectionType, events
+from wsproto.connection import ConnectionState
+from wsproto.extensions import PerMessageDeflate
+from wsproto.utilities import RemoteProtocolError
+
+from uvicorn.logging import TRACE_LOG_LEVEL
+from uvicorn.protocols.utils import get_local_addr, get_remote_addr, is_ssl
+
+# Check wsproto version. We've build against 0.13. We don't know about 0.14 yet.
+assert wsproto.__version__ > "0.13", "Need wsproto version 0.13"
+
+
+class WSProtocol(asyncio.Protocol):
+    def __init__(
+        self, config, server_state, on_connection_lost: Callable = None, _loop=None
+    ):
+        if not config.loaded:
+            config.load()
+
+        self.config = config
+        self.app = config.loaded_app
+        self.on_connection_lost = on_connection_lost
+        self.loop = _loop or asyncio.get_event_loop()
+        self.logger = logging.getLogger("uvicorn.error")
+        self.root_path = config.root_path
+
+        # Shared server state
+        self.connections = server_state.connections
+        self.tasks = server_state.tasks
+
+        # Connection state
+        self.transport = None
+        self.server = None
+        self.client = None
+        self.scheme = None
+
+        # WebSocket state
+        self.connect_event = None
+        self.queue = asyncio.Queue()
+        self.handshake_complete = False
+        self.close_sent = False
+
+        self.conn = wsproto.WSConnection(connection_type=ConnectionType.SERVER)
+
+        self.read_paused = False
+        self.writable = asyncio.Event()
+        self.writable.set()
+
+        # Buffers
+        self.bytes = b""
+        self.text = ""
+
+    # Protocol interface
+
+    def connection_made(self, transport):
+        self.connections.add(self)
+        self.transport = transport
+        self.server = get_local_addr(transport)
+        self.client = get_remote_addr(transport)
+        self.scheme = "wss" if is_ssl(transport) else "ws"
+
+        if self.logger.level <= TRACE_LOG_LEVEL:
+            prefix = "%s:%d - " % tuple(self.client) if self.client else ""
+            self.logger.log(TRACE_LOG_LEVEL, "%sWebSocket connection made", prefix)
+
+    def connection_lost(self, exc):
+        if exc is not None:
+            self.queue.put_nowait({"type": "websocket.disconnect"})
+        self.connections.remove(self)
+
+        if self.logger.level <= TRACE_LOG_LEVEL:
+            prefix = "%s:%d - " % tuple(self.client) if self.client else ""
+            self.logger.log(TRACE_LOG_LEVEL, "%sWebSocket connection lost", prefix)
+
+        if self.on_connection_lost is not None:
+            self.on_connection_lost()
+        if exc is None:
+            self.transport.close()
+
+    def eof_received(self):
+        pass
+
+    def data_received(self, data):
+        try:
+            self.conn.receive_data(data)
+        except RemoteProtocolError as err:
+            if err.event_hint is not None:
+                self.transport.write(self.conn.send(err.event_hint))
+                self.transport.close()
+            else:
+                self.handle_no_connect(events.CloseConnection())
+        else:
+            self.handle_events()
+
+    def handle_events(self):
+        for event in self.conn.events():
+            if isinstance(event, events.Request):
+                self.handle_connect(event)
+            elif isinstance(event, events.TextMessage):
+                self.handle_text(event)
+            elif isinstance(event, events.BytesMessage):
+                self.handle_bytes(event)
+            elif isinstance(event, events.RejectConnection):
+                self.handle_no_connect(event)
+            elif isinstance(event, events.RejectData):
+                self.handle_no_connect(event)
+            elif isinstance(event, events.CloseConnection):
+                self.handle_close(event)
+            elif isinstance(event, events.Ping):
+                self.handle_ping(event)
+
+    def pause_writing(self):
+        """
+        Called by the transport when the write buffer exceeds the high water mark.
+        """
+        self.writable.clear()
+
+    def resume_writing(self):
+        """
+        Called by the transport when the write buffer drops below the low water mark.
+        """
+        self.writable.set()
+
+    def shutdown(self):
+        self.queue.put_nowait({"type": "websocket.disconnect", "code": 1012})
+        output = self.conn.send(wsproto.events.CloseConnection(code=1012))
+        self.transport.write(output)
+        self.transport.close()
+
+    def on_task_complete(self, task):
+        self.tasks.discard(task)
+
+    # Event handlers
+
+    def handle_connect(self, event):
+        self.connect_event = event
+        headers = [(b"host", event.host.encode())]
+        headers += [(key.lower(), value) for key, value in event.extra_headers]
+        raw_path, _, query_string = event.target.partition("?")
+        self.scope = {
+            "type": "websocket",
+            "asgi": {"version": self.config.asgi_version, "spec_version": "2.1"},
+            "http_version": "1.1",
+            "scheme": self.scheme,
+            "server": self.server,
+            "client": self.client,
+            "root_path": self.root_path,
+            "path": unquote(raw_path),
+            "raw_path": raw_path,
+            "query_string": query_string.encode("ascii"),
+            "headers": headers,
+            "subprotocols": event.subprotocols,
+        }
+        self.queue.put_nowait({"type": "websocket.connect"})
+        task = self.loop.create_task(self.run_asgi())
+        task.add_done_callback(self.on_task_complete)
+        self.tasks.add(task)
+
+    def handle_no_connect(self, event):
+        headers = [
+            (b"content-type", b"text/plain; charset=utf-8"),
+            (b"connection", b"close"),
+        ]
+        msg = h11.Response(status_code=400, headers=headers, reason="Bad Request")
+        output = self.conn.send(msg)
+        msg = h11.Data(data=event.reason.encode("utf-8"))
+        output += self.conn.send(msg)
+        msg = h11.EndOfMessage()
+        output += self.conn.send(msg)
+        self.transport.write(output)
+        self.transport.close()
+
+    def handle_text(self, event):
+        self.text += event.data
+        if event.message_finished:
+            self.queue.put_nowait({"type": "websocket.receive", "text": self.text})
+            self.text = ""
+            if not self.read_paused:
+                self.read_paused = True
+                self.transport.pause_reading()
+
+    def handle_bytes(self, event):
+        self.bytes += event.data
+        # todo: we may want to guard the size of self.bytes and self.text
+        if event.message_finished:
+            self.queue.put_nowait({"type": "websocket.receive", "bytes": self.bytes})
+            self.bytes = b""
+            if not self.read_paused:
+                self.read_paused = True
+                self.transport.pause_reading()
+
+    def handle_close(self, event):
+        if self.conn.state == ConnectionState.REMOTE_CLOSING:
+            self.transport.write(self.conn.send(event.response()))
+        self.queue.put_nowait({"type": "websocket.disconnect", "code": event.code})
+        self.transport.close()
+
+    def handle_ping(self, event):
+        self.transport.write(self.conn.send(event.response()))
+
+    def send_500_response(self):
+        headers = [
+            (b"content-type", b"text/plain; charset=utf-8"),
+            (b"connection", b"close"),
+        ]
+        if self.conn.connection is None:
+            output = self.conn.send(wsproto.events.RejectConnection(status_code=500))
+        else:
+            msg = h11.Response(
+                status_code=500, headers=headers, reason="Internal Server Error"
+            )
+            output = self.conn.send(msg)
+            msg = h11.Data(data=b"Internal Server Error")
+            output += self.conn.send(msg)
+            msg = h11.EndOfMessage()
+            output += self.conn.send(msg)
+        self.transport.write(output)
+
+    async def run_asgi(self):
+        try:
+            result = await self.app(self.scope, self.receive, self.send)
+        except BaseException as exc:
+            msg = "Exception in ASGI application\n"
+            self.logger.error(msg, exc_info=exc)
+            if not self.handshake_complete:
+                self.send_500_response()
+            self.transport.close()
+        else:
+            if not self.handshake_complete:
+                msg = "ASGI callable returned without completing handshake."
+                self.logger.error(msg)
+                self.send_500_response()
+                self.transport.close()
+            elif result is not None:
+                msg = "ASGI callable should return None, but returned '%s'."
+                self.logger.error(msg, result)
+                self.transport.close()
+
+    async def send(self, message):
+        await self.writable.wait()
+
+        message_type = message["type"]
+
+        if not self.handshake_complete:
+            if message_type == "websocket.accept":
+                self.logger.info(
+                    '%s - "WebSocket %s" [accepted]',
+                    self.scope["client"],
+                    self.scope["root_path"] + self.scope["path"],
+                )
+                self.handshake_complete = True
+                subprotocol = message.get("subprotocol")
+                output = self.conn.send(
+                    wsproto.events.AcceptConnection(
+                        subprotocol=subprotocol, extensions=[PerMessageDeflate()]
+                    )
+                )
+                self.transport.write(output)
+
+            elif message_type == "websocket.close":
+                self.queue.put_nowait({"type": "websocket.disconnect", "code": None})
+                self.logger.info(
+                    '%s - "WebSocket %s" 403',
+                    self.scope["client"],
+                    self.scope["root_path"] + self.scope["path"],
+                )
+                self.handshake_complete = True
+                self.close_sent = True
+                msg = events.RejectConnection(status_code=403, headers=[])
+                output = self.conn.send(msg)
+                self.transport.write(output)
+                self.transport.close()
+
+            else:
+                msg = (
+                    "Expected ASGI message 'websocket.accept' or 'websocket.close', "
+                    "but got '%s'."
+                )
+                raise RuntimeError(msg % message_type)
+
+        elif not self.close_sent:
+            if message_type == "websocket.send":
+                bytes_data = message.get("bytes")
+                text_data = message.get("text")
+                data = text_data if bytes_data is None else bytes_data
+                output = self.conn.send(wsproto.events.Message(data=data))
+                if not self.transport.is_closing():
+                    self.transport.write(output)
+
+            elif message_type == "websocket.close":
+                self.close_sent = True
+                code = message.get("code", 1000)
+                reason = message.get("reason", "") or ""
+                self.queue.put_nowait({"type": "websocket.disconnect", "code": code})
+                output = self.conn.send(
+                    wsproto.events.CloseConnection(code=code, reason=reason)
+                )
+                if not self.transport.is_closing():
+                    self.transport.write(output)
+                    self.transport.close()
+
+            else:
+                msg = (
+                    "Expected ASGI message 'websocket.send' or 'websocket.close',"
+                    " but got '%s'."
+                )
+                raise RuntimeError(msg % message_type)
+
+        else:
+            msg = "Unexpected ASGI message '%s', after sending 'websocket.close'."
+            raise RuntimeError(msg % message_type)
+
+    async def receive(self):
+        message = await self.queue.get()
+        if self.read_paused and self.queue.empty():
+            self.read_paused = False
+            self.transport.resume_reading()
+        return message
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/server.py b/myenv/lib/python3.9/site-packages/uvicorn/server.py
new file mode 100644
index 0000000..bc5a4fd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/server.py
@@ -0,0 +1,316 @@
+import asyncio
+import logging
+import os
+import platform
+import signal
+import socket
+import sys
+import threading
+import time
+from email.utils import formatdate
+from types import FrameType
+from typing import TYPE_CHECKING, Any, List, Optional, Set, Tuple, Union
+
+import click
+
+from uvicorn._handlers.http import handle_http
+from uvicorn.config import Config
+
+if TYPE_CHECKING:
+    from uvicorn.protocols.http.h11_impl import H11Protocol
+    from uvicorn.protocols.http.httptools_impl import HttpToolsProtocol
+    from uvicorn.protocols.websockets.websockets_impl import WebSocketProtocol
+    from uvicorn.protocols.websockets.wsproto_impl import WSProtocol
+
+    Protocols = Union[H11Protocol, HttpToolsProtocol, WSProtocol, WebSocketProtocol]
+
+if sys.platform != "win32":
+    from asyncio import start_unix_server as _start_unix_server
+else:
+
+    async def _start_unix_server(*args: Any, **kwargs: Any) -> Any:
+        raise NotImplementedError("Cannot start a unix server on win32")
+
+
+HANDLED_SIGNALS = (
+    signal.SIGINT,  # Unix signal 2. Sent by Ctrl+C.
+    signal.SIGTERM,  # Unix signal 15. Sent by `kill <pid>`.
+)
+
+logger = logging.getLogger("uvicorn.error")
+
+
+class ServerState:
+    """
+    Shared servers state that is available between all protocol instances.
+    """
+
+    def __init__(self) -> None:
+        self.total_requests = 0
+        self.connections: Set["Protocols"] = set()
+        self.tasks: Set[asyncio.Task] = set()
+        self.default_headers: List[Tuple[bytes, bytes]] = []
+
+
+class Server:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        self.server_state = ServerState()
+
+        self.started = False
+        self.should_exit = False
+        self.force_exit = False
+        self.last_notified = 0.0
+
+    def run(self, sockets: Optional[List[socket.socket]] = None) -> None:
+        self.config.setup_event_loop()
+        if sys.version_info >= (3, 7):
+            return asyncio.run(self.serve(sockets=sockets))
+        return asyncio.get_event_loop().run_until_complete(self.serve(sockets=sockets))
+
+    async def serve(self, sockets: Optional[List[socket.socket]] = None) -> None:
+        process_id = os.getpid()
+
+        config = self.config
+        if not config.loaded:
+            config.load()
+
+        self.lifespan = config.lifespan_class(config)
+
+        self.install_signal_handlers()
+
+        message = "Started server process [%d]"
+        color_message = "Started server process [" + click.style("%d", fg="cyan") + "]"
+        logger.info(message, process_id, extra={"color_message": color_message})
+
+        await self.startup(sockets=sockets)
+        if self.should_exit:
+            return
+        await self.main_loop()
+        await self.shutdown(sockets=sockets)
+
+        message = "Finished server process [%d]"
+        color_message = "Finished server process [" + click.style("%d", fg="cyan") + "]"
+        logger.info(message, process_id, extra={"color_message": color_message})
+
+    async def startup(self, sockets: list = None) -> None:
+        await self.lifespan.startup()
+        if self.lifespan.should_exit:
+            self.should_exit = True
+            return
+
+        config = self.config
+
+        async def handler(
+            reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+        ) -> None:
+            await handle_http(
+                reader, writer, server_state=self.server_state, config=config
+            )
+
+        if sockets is not None:
+            # Explicitly passed a list of open sockets.
+            # We use this when the server is run from a Gunicorn worker.
+
+            def _share_socket(sock: socket.SocketType) -> socket.SocketType:
+                # Windows requires the socket be explicitly shared across
+                # multiple workers (processes).
+                from socket import fromshare  # type: ignore
+
+                sock_data = sock.share(os.getpid())  # type: ignore
+                return fromshare(sock_data)
+
+            self.servers = []
+            for sock in sockets:
+                if config.workers > 1 and platform.system() == "Windows":
+                    sock = _share_socket(sock)
+                server = await asyncio.start_server(
+                    handler, sock=sock, ssl=config.ssl, backlog=config.backlog
+                )
+                self.servers.append(server)
+            listeners = sockets
+
+        elif config.fd is not None:
+            # Use an existing socket, from a file descriptor.
+            sock = socket.fromfd(config.fd, socket.AF_UNIX, socket.SOCK_STREAM)
+            server = await asyncio.start_server(
+                handler, sock=sock, ssl=config.ssl, backlog=config.backlog
+            )
+            assert server.sockets is not None  # mypy
+            listeners = server.sockets
+            self.servers = [server]
+
+        elif config.uds is not None:
+            # Create a socket using UNIX domain socket.
+            uds_perms = 0o666
+            if os.path.exists(config.uds):
+                uds_perms = os.stat(config.uds).st_mode
+            server = await _start_unix_server(
+                handler, path=config.uds, ssl=config.ssl, backlog=config.backlog
+            )
+            os.chmod(config.uds, uds_perms)
+            assert server.sockets is not None  # mypy
+            listeners = server.sockets
+            self.servers = [server]
+
+        else:
+            # Standard case. Create a socket from a host/port pair.
+            try:
+                server = await asyncio.start_server(
+                    handler,
+                    host=config.host,
+                    port=config.port,
+                    ssl=config.ssl,
+                    backlog=config.backlog,
+                )
+            except OSError as exc:
+                logger.error(exc)
+                await self.lifespan.shutdown()
+                sys.exit(1)
+
+            assert server.sockets is not None
+            listeners = server.sockets
+            self.servers = [server]
+
+        if sockets is None:
+            self._log_started_message(listeners)
+        else:
+            # We're most likely running multiple workers, so a message has already been
+            # logged by `config.bind_socket()`.
+            pass
+
+        self.started = True
+
+    def _log_started_message(self, listeners: List[socket.SocketType]) -> None:
+        config = self.config
+
+        if config.fd is not None:
+            sock = listeners[0]
+            logger.info(
+                "Uvicorn running on socket %s (Press CTRL+C to quit)",
+                sock.getsockname(),
+            )
+
+        elif config.uds is not None:
+            logger.info(
+                "Uvicorn running on unix socket %s (Press CTRL+C to quit)", config.uds
+            )
+
+        else:
+            addr_format = "%s://%s:%d"
+            host = "0.0.0.0" if config.host is None else config.host
+            if ":" in host:
+                # It's an IPv6 address.
+                addr_format = "%s://[%s]:%d"
+
+            port = config.port
+            if port == 0:
+                port = listeners[0].getsockname()[1]
+
+            protocol_name = "https" if config.ssl else "http"
+            message = f"Uvicorn running on {addr_format} (Press CTRL+C to quit)"
+            color_message = (
+                "Uvicorn running on "
+                + click.style(addr_format, bold=True)
+                + " (Press CTRL+C to quit)"
+            )
+            logger.info(
+                message,
+                protocol_name,
+                host,
+                port,
+                extra={"color_message": color_message},
+            )
+
+    async def main_loop(self) -> None:
+        counter = 0
+        should_exit = await self.on_tick(counter)
+        while not should_exit:
+            counter += 1
+            counter = counter % 864000
+            await asyncio.sleep(0.1)
+            should_exit = await self.on_tick(counter)
+
+    async def on_tick(self, counter: int) -> bool:
+        # Update the default headers, once per second.
+        if counter % 10 == 0:
+            current_time = time.time()
+            current_date = formatdate(current_time, usegmt=True).encode()
+
+            if self.config.date_header:
+                date_header = [(b"date", current_date)]
+            else:
+                date_header = []
+
+            self.server_state.default_headers = (
+                date_header + self.config.encoded_headers
+            )
+
+            # Callback to `callback_notify` once every `timeout_notify` seconds.
+            if self.config.callback_notify is not None:
+                if current_time - self.last_notified > self.config.timeout_notify:
+                    self.last_notified = current_time
+                    await self.config.callback_notify()
+
+        # Determine if we should exit.
+        if self.should_exit:
+            return True
+        if self.config.limit_max_requests is not None:
+            return self.server_state.total_requests >= self.config.limit_max_requests
+        return False
+
+    async def shutdown(self, sockets: Optional[List[socket.socket]] = None) -> None:
+        logger.info("Shutting down")
+
+        # Stop accepting new connections.
+        for server in self.servers:
+            server.close()
+        for sock in sockets or []:
+            sock.close()
+        for server in self.servers:
+            await server.wait_closed()
+
+        # Request shutdown on all existing connections.
+        for connection in list(self.server_state.connections):
+            connection.shutdown()
+        await asyncio.sleep(0.1)
+
+        # Wait for existing connections to finish sending responses.
+        if self.server_state.connections and not self.force_exit:
+            msg = "Waiting for connections to close. (CTRL+C to force quit)"
+            logger.info(msg)
+            while self.server_state.connections and not self.force_exit:
+                await asyncio.sleep(0.1)
+
+        # Wait for existing tasks to complete.
+        if self.server_state.tasks and not self.force_exit:
+            msg = "Waiting for background tasks to complete. (CTRL+C to force quit)"
+            logger.info(msg)
+            while self.server_state.tasks and not self.force_exit:
+                await asyncio.sleep(0.1)
+
+        # Send the lifespan shutdown event, and wait for application shutdown.
+        if not self.force_exit:
+            await self.lifespan.shutdown()
+
+    def install_signal_handlers(self) -> None:
+        if threading.current_thread() is not threading.main_thread():
+            # Signals can only be listened to from the main thread.
+            return
+
+        loop = asyncio.get_event_loop()
+
+        try:
+            for sig in HANDLED_SIGNALS:
+                loop.add_signal_handler(sig, self.handle_exit, sig, None)
+        except NotImplementedError:  # pragma: no cover
+            # Windows
+            for sig in HANDLED_SIGNALS:
+                signal.signal(sig, self.handle_exit)
+
+    def handle_exit(self, sig: signal.Signals, frame: FrameType) -> None:
+
+        if self.should_exit and sig == signal.SIGINT:
+            self.force_exit = True
+        else:
+            self.should_exit = True
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/subprocess.py b/myenv/lib/python3.9/site-packages/uvicorn/subprocess.py
new file mode 100644
index 0000000..e05473c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/subprocess.py
@@ -0,0 +1,76 @@
+"""
+Some light wrappers around Python's multiprocessing, to deal with cleanly
+starting child processes.
+"""
+import multiprocessing
+import os
+import sys
+from multiprocessing.context import SpawnProcess
+from socket import socket
+from typing import Callable, List, Optional
+
+from uvicorn.config import Config
+
+multiprocessing.allow_connection_pickling()
+spawn = multiprocessing.get_context("spawn")
+
+
+def get_subprocess(
+    config: Config,
+    target: Callable[..., None],
+    sockets: List[socket],
+) -> SpawnProcess:
+    """
+    Called in the parent process, to instantiate a new child process instance.
+    The child is not yet started at this point.
+
+    * config - The Uvicorn configuration instance.
+    * target - A callable that accepts a list of sockets. In practice this will
+               be the `Server.run()` method.
+    * sockets - A list of sockets to pass to the server. Sockets are bound once
+                by the parent process, and then passed to the child processes.
+    """
+    # We pass across the stdin fileno, and reopen it in the child process.
+    # This is required for some debugging environments.
+    stdin_fileno: Optional[int]
+    try:
+        stdin_fileno = sys.stdin.fileno()
+    except OSError:
+        stdin_fileno = None
+
+    kwargs = {
+        "config": config,
+        "target": target,
+        "sockets": sockets,
+        "stdin_fileno": stdin_fileno,
+    }
+
+    return spawn.Process(target=subprocess_started, kwargs=kwargs)
+
+
+def subprocess_started(
+    config: Config,
+    target: Callable[..., None],
+    sockets: List[socket],
+    stdin_fileno: Optional[int],
+) -> None:
+    """
+    Called when the child process starts.
+
+    * config - The Uvicorn configuration instance.
+    * target - A callable that accepts a list of sockets. In practice this will
+               be the `Server.run()` method.
+    * sockets - A list of sockets to pass to the server. Sockets are bound once
+                by the parent process, and then passed to the child processes.
+    * stdin_fileno - The file number of sys.stdin, so that it can be reattached
+                     to the child process.
+    """
+    # Re-open stdin.
+    if stdin_fileno is not None:
+        sys.stdin = os.fdopen(stdin_fileno)
+
+    # Logging needs to be setup again for each child.
+    config.configure_logging()
+
+    # Now we can call into `Server.run(sockets=sockets)`
+    target(sockets=sockets)
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/supervisors/__init__.py b/myenv/lib/python3.9/site-packages/uvicorn/supervisors/__init__.py
new file mode 100644
index 0000000..5a27e35
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/supervisors/__init__.py
@@ -0,0 +1,14 @@
+import typing
+
+from uvicorn.supervisors.basereload import BaseReload
+from uvicorn.supervisors.multiprocess import Multiprocess
+
+if typing.TYPE_CHECKING:
+    ChangeReload: typing.Type[BaseReload]  # pragma: no cover
+else:
+    try:
+        from uvicorn.supervisors.watchgodreload import WatchGodReload as ChangeReload
+    except ImportError:  # pragma: no cover
+        from uvicorn.supervisors.statreload import StatReload as ChangeReload
+
+__all__ = ["Multiprocess", "ChangeReload"]
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/supervisors/basereload.py b/myenv/lib/python3.9/site-packages/uvicorn/supervisors/basereload.py
new file mode 100644
index 0000000..0a431b9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/supervisors/basereload.py
@@ -0,0 +1,93 @@
+import logging
+import os
+import signal
+import threading
+from socket import socket
+from types import FrameType
+from typing import Callable, List, Optional
+
+import click
+
+from uvicorn.config import Config
+from uvicorn.subprocess import get_subprocess
+
+HANDLED_SIGNALS = (
+    signal.SIGINT,  # Unix signal 2. Sent by Ctrl+C.
+    signal.SIGTERM,  # Unix signal 15. Sent by `kill <pid>`.
+)
+
+logger = logging.getLogger("uvicorn.error")
+
+
+class BaseReload:
+    def __init__(
+        self,
+        config: Config,
+        target: Callable[[Optional[List[socket]]], None],
+        sockets: List[socket],
+    ) -> None:
+        self.config = config
+        self.target = target
+        self.sockets = sockets
+        self.should_exit = threading.Event()
+        self.pid = os.getpid()
+        self.reloader_name: Optional[str] = None
+
+    def signal_handler(self, sig: signal.Signals, frame: FrameType) -> None:
+        """
+        A signal handler that is registered with the parent process.
+        """
+        self.should_exit.set()
+
+    def run(self) -> None:
+        self.startup()
+        while not self.should_exit.wait(self.config.reload_delay):
+            if self.should_restart():
+                self.restart()
+
+            if self.process.exitcode is not None:
+                break
+
+        self.shutdown()
+
+    def startup(self) -> None:
+        message = f"Started reloader process [{self.pid}] using {self.reloader_name}"
+        color_message = "Started reloader process [{}] using {}".format(
+            click.style(str(self.pid), fg="cyan", bold=True),
+            click.style(str(self.reloader_name), fg="cyan", bold=True),
+        )
+        logger.info(message, extra={"color_message": color_message})
+
+        for sig in HANDLED_SIGNALS:
+            signal.signal(sig, self.signal_handler)
+
+        self.process = get_subprocess(
+            config=self.config, target=self.target, sockets=self.sockets
+        )
+        self.process.start()
+
+    def restart(self) -> None:
+
+        self.process.terminate()
+        self.process.join()
+
+        self.process = get_subprocess(
+            config=self.config, target=self.target, sockets=self.sockets
+        )
+        self.process.start()
+
+    def shutdown(self) -> None:
+        self.process.terminate()
+        self.process.join()
+
+        for sock in self.sockets:
+            sock.close()
+
+        message = "Stopping reloader process [{}]".format(str(self.pid))
+        color_message = "Stopping reloader process [{}]".format(
+            click.style(str(self.pid), fg="cyan", bold=True)
+        )
+        logger.info(message, extra={"color_message": color_message})
+
+    def should_restart(self) -> bool:
+        raise NotImplementedError("Reload strategies should override should_restart()")
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/supervisors/multiprocess.py b/myenv/lib/python3.9/site-packages/uvicorn/supervisors/multiprocess.py
new file mode 100644
index 0000000..ee86f8e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/supervisors/multiprocess.py
@@ -0,0 +1,74 @@
+import logging
+import os
+import signal
+import threading
+from multiprocessing.context import SpawnProcess
+from socket import socket
+from types import FrameType
+from typing import Callable, List, Optional
+
+import click
+
+from uvicorn.config import Config
+from uvicorn.subprocess import get_subprocess
+
+HANDLED_SIGNALS = (
+    signal.SIGINT,  # Unix signal 2. Sent by Ctrl+C.
+    signal.SIGTERM,  # Unix signal 15. Sent by `kill <pid>`.
+)
+
+logger = logging.getLogger("uvicorn.error")
+
+
+class Multiprocess:
+    def __init__(
+        self,
+        config: Config,
+        target: Callable[[Optional[List[socket]]], None],
+        sockets: List[socket],
+    ) -> None:
+        self.config = config
+        self.target = target
+        self.sockets = sockets
+        self.processes: List[SpawnProcess] = []
+        self.should_exit = threading.Event()
+        self.pid = os.getpid()
+
+    def signal_handler(self, sig: signal.Signals, frame: FrameType) -> None:
+        """
+        A signal handler that is registered with the parent process.
+        """
+        self.should_exit.set()
+
+    def run(self) -> None:
+        self.startup()
+        self.should_exit.wait()
+        self.shutdown()
+
+    def startup(self) -> None:
+        message = "Started parent process [{}]".format(str(self.pid))
+        color_message = "Started parent process [{}]".format(
+            click.style(str(self.pid), fg="cyan", bold=True)
+        )
+        logger.info(message, extra={"color_message": color_message})
+
+        for sig in HANDLED_SIGNALS:
+            signal.signal(sig, self.signal_handler)
+
+        for idx in range(self.config.workers):
+            process = get_subprocess(
+                config=self.config, target=self.target, sockets=self.sockets
+            )
+            process.start()
+            self.processes.append(process)
+
+    def shutdown(self) -> None:
+        for process in self.processes:
+            process.terminate()
+            process.join()
+
+        message = "Stopping parent process [{}]".format(str(self.pid))
+        color_message = "Stopping parent process [{}]".format(
+            click.style(str(self.pid), fg="cyan", bold=True)
+        )
+        logger.info(message, extra={"color_message": color_message})
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/supervisors/statreload.py b/myenv/lib/python3.9/site-packages/uvicorn/supervisors/statreload.py
new file mode 100644
index 0000000..2c9857e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/supervisors/statreload.py
@@ -0,0 +1,52 @@
+import logging
+from pathlib import Path
+from socket import socket
+from typing import Callable, Dict, Iterator, List, Optional
+
+from uvicorn.config import Config
+from uvicorn.supervisors.basereload import BaseReload
+
+logger = logging.getLogger("uvicorn.error")
+
+
+class StatReload(BaseReload):
+    def __init__(
+        self,
+        config: Config,
+        target: Callable[[Optional[List[socket]]], None],
+        sockets: List[socket],
+    ) -> None:
+        super().__init__(config, target, sockets)
+        self.reloader_name = "statreload"
+        self.mtimes: Dict[Path, float] = {}
+
+    def should_restart(self) -> bool:
+        for file in self.iter_py_files():
+            try:
+                mtime = file.stat().st_mtime
+            except OSError:  # pragma: nocover
+                continue
+
+            old_time = self.mtimes.get(file)
+            if old_time is None:
+                self.mtimes[file] = mtime
+                continue
+            elif mtime > old_time:
+                display_path = str(file)
+                try:
+                    display_path = str(file.relative_to(Path.cwd()))
+                except ValueError:
+                    pass
+                message = "StatReload detected file change in '%s'. Reloading..."
+                logger.warning(message, display_path)
+                return True
+        return False
+
+    def restart(self) -> None:
+        self.mtimes = {}
+        return super().restart()
+
+    def iter_py_files(self) -> Iterator[Path]:
+        for reload_dir in self.config.reload_dirs:
+            for path in list(reload_dir.rglob("*.py")):
+                yield path.resolve()
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/supervisors/watchgodreload.py b/myenv/lib/python3.9/site-packages/uvicorn/supervisors/watchgodreload.py
new file mode 100644
index 0000000..92ef1f5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/supervisors/watchgodreload.py
@@ -0,0 +1,152 @@
+import logging
+from pathlib import Path
+from socket import socket
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional
+
+from watchgod import DefaultWatcher
+
+from uvicorn.config import Config
+from uvicorn.supervisors.basereload import BaseReload
+
+logger = logging.getLogger("uvicorn.error")
+
+if TYPE_CHECKING:  # pragma: no cover
+    import os
+
+    DirEntry = os.DirEntry[str]
+
+
+class CustomWatcher(DefaultWatcher):
+    def __init__(self, root_path: Path, config: Config):
+        default_includes = ["*.py"]
+        self.includes = [
+            default
+            for default in default_includes
+            if default not in config.reload_excludes
+        ]
+        self.includes.extend(config.reload_includes)
+        self.includes = list(set(self.includes))
+
+        default_excludes = [".*", ".py[cod]", ".sw.*", "~*"]
+        self.excludes = [
+            default
+            for default in default_excludes
+            if default not in config.reload_includes
+        ]
+        self.excludes.extend(config.reload_excludes)
+        self.excludes = list(set(self.excludes))
+
+        self.watched_dirs: Dict[str, bool] = {}
+        self.watched_files: Dict[str, bool] = {}
+        self.dirs_includes = set(config.reload_dirs)
+        self.dirs_excludes = set(config.reload_dirs_excludes)
+        self.resolved_root = root_path
+        super().__init__(str(root_path))
+
+    def should_watch_file(self, entry: "DirEntry") -> bool:
+        cached_result = self.watched_files.get(entry.path)
+        if cached_result is not None:
+            return cached_result
+
+        entry_path = Path(entry)
+
+        # cwd is not verified through should_watch_dir, so we need to verify here
+        if entry_path.parent == Path.cwd() and not Path.cwd() in self.dirs_includes:
+            self.watched_files[entry.path] = False
+            return False
+        for include_pattern in self.includes:
+            if entry_path.match(include_pattern):
+                for exclude_pattern in self.excludes:
+                    if entry_path.match(exclude_pattern):
+                        self.watched_files[entry.path] = False
+                        return False
+                self.watched_files[entry.path] = True
+                return True
+        self.watched_files[entry.path] = False
+        return False
+
+    def should_watch_dir(self, entry: "DirEntry") -> bool:
+        cached_result = self.watched_dirs.get(entry.path)
+        if cached_result is not None:
+            return cached_result
+
+        entry_path = Path(entry)
+
+        if entry_path in self.dirs_excludes:
+            self.watched_dirs[entry.path] = False
+            return False
+
+        for exclude_pattern in self.excludes:
+            if entry_path.match(exclude_pattern):
+                is_watched = False
+                if entry_path in self.dirs_includes:
+                    is_watched = True
+
+                for directory in self.dirs_includes:
+                    if directory in entry_path.parents:
+                        is_watched = True
+
+                if is_watched:
+                    logger.debug(
+                        "WatchGodReload detected a new excluded dir '%s' in '%s'; "
+                        "Adding to exclude list.",
+                        entry_path.relative_to(self.resolved_root),
+                        str(self.resolved_root),
+                    )
+                self.watched_dirs[entry.path] = False
+                self.dirs_excludes.add(entry_path)
+                return False
+
+        if entry_path in self.dirs_includes:
+            self.watched_dirs[entry.path] = True
+            return True
+
+        for directory in self.dirs_includes:
+            if directory in entry_path.parents:
+                self.watched_dirs[entry.path] = True
+                return True
+
+        for include_pattern in self.includes:
+            if entry_path.match(include_pattern):
+                logger.info(
+                    "WatchGodReload detected a new reload dir '%s' in '%s'; "
+                    "Adding to watch list.",
+                    str(entry_path.relative_to(self.resolved_root)),
+                    str(self.resolved_root),
+                )
+                self.dirs_includes.add(entry_path)
+                self.watched_dirs[entry.path] = True
+                return True
+
+        self.watched_dirs[entry.path] = False
+        return False
+
+
+class WatchGodReload(BaseReload):
+    def __init__(
+        self,
+        config: Config,
+        target: Callable[[Optional[List[socket]]], None],
+        sockets: List[socket],
+    ) -> None:
+        super().__init__(config, target, sockets)
+        self.reloader_name = "watchgod"
+        self.watchers = []
+        reload_dirs = []
+        for directory in config.reload_dirs:
+            if Path.cwd() not in directory.parents:
+                reload_dirs.append(directory)
+        if Path.cwd() not in reload_dirs:
+            reload_dirs.append(Path.cwd())
+        for w in reload_dirs:
+            self.watchers.append(CustomWatcher(w.resolve(), self.config))
+
+    def should_restart(self) -> bool:
+        for watcher in self.watchers:
+            change = watcher.check()
+            if change != set():
+                message = "WatchGodReload detected file change in '%s'. Reloading..."
+                logger.warning(message, [c[1] for c in change])
+                return True
+
+        return False
diff --git a/myenv/lib/python3.9/site-packages/uvicorn/workers.py b/myenv/lib/python3.9/site-packages/uvicorn/workers.py
new file mode 100644
index 0000000..05ee166
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvicorn/workers.py
@@ -0,0 +1,92 @@
+import asyncio
+import logging
+import signal
+import sys
+from typing import Any
+
+from gunicorn.arbiter import Arbiter
+from gunicorn.workers.base import Worker
+
+from uvicorn.config import Config
+from uvicorn.main import Server
+
+
+class UvicornWorker(Worker):
+    """
+    A worker class for Gunicorn that interfaces with an ASGI consumer callable,
+    rather than a WSGI callable.
+    """
+
+    CONFIG_KWARGS = {"loop": "auto", "http": "auto"}
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super(UvicornWorker, self).__init__(*args, **kwargs)
+
+        logger = logging.getLogger("uvicorn.error")
+        logger.handlers = self.log.error_log.handlers
+        logger.setLevel(self.log.error_log.level)
+        logger.propagate = False
+
+        logger = logging.getLogger("uvicorn.access")
+        logger.handlers = self.log.access_log.handlers
+        logger.setLevel(self.log.access_log.level)
+        logger.propagate = False
+
+        config_kwargs: dict = {
+            "app": None,
+            "log_config": None,
+            "timeout_keep_alive": self.cfg.keepalive,
+            "timeout_notify": self.timeout,
+            "callback_notify": self.callback_notify,
+            "limit_max_requests": self.max_requests,
+            "forwarded_allow_ips": self.cfg.forwarded_allow_ips,
+        }
+
+        if self.cfg.is_ssl:
+            ssl_kwargs = {
+                "ssl_keyfile": self.cfg.ssl_options.get("keyfile"),
+                "ssl_certfile": self.cfg.ssl_options.get("certfile"),
+                "ssl_keyfile_password": self.cfg.ssl_options.get("password"),
+                "ssl_version": self.cfg.ssl_options.get("ssl_version"),
+                "ssl_cert_reqs": self.cfg.ssl_options.get("cert_reqs"),
+                "ssl_ca_certs": self.cfg.ssl_options.get("ca_certs"),
+                "ssl_ciphers": self.cfg.ssl_options.get("ciphers"),
+            }
+            config_kwargs.update(ssl_kwargs)
+
+        if self.cfg.settings["backlog"].value:
+            config_kwargs["backlog"] = self.cfg.settings["backlog"].value
+
+        config_kwargs.update(self.CONFIG_KWARGS)
+
+        self.config = Config(**config_kwargs)
+
+    def init_process(self) -> None:
+        self.config.setup_event_loop()
+        super(UvicornWorker, self).init_process()
+
+    def init_signals(self) -> None:
+        # Reset signals so Gunicorn doesn't swallow subprocess return codes
+        # other signals are set up by Server.install_signal_handlers()
+        # See: https://github.com/encode/uvicorn/issues/894
+        for s in self.SIGNALS:
+            signal.signal(s, signal.SIG_DFL)
+
+    async def _serve(self) -> None:
+        self.config.app = self.wsgi
+        server = Server(config=self.config)
+        await server.serve(sockets=self.sockets)
+        if not server.started:
+            sys.exit(Arbiter.WORKER_BOOT_ERROR)
+
+    def run(self) -> None:
+        if sys.version_info >= (3, 7):
+            return asyncio.run(self._serve())
+        return asyncio.get_event_loop().run_until_complete(self._serve())
+
+    async def callback_notify(self) -> None:
+        self.notify()
+
+
+class UvicornH11Worker(UvicornWorker):
+    CONFIG_KWARGS = {"loop": "asyncio", "http": "h11"}
diff --git a/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/LICENSE-APACHE b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/LICENSE-APACHE
new file mode 100644
index 0000000..a1de698
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/LICENSE-APACHE
@@ -0,0 +1,203 @@
+Copyright (c) 2015-present MagicStack Inc.  http://magic.io
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2015-present MagicStack Inc.  http://magic.io
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/LICENSE-MIT b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/LICENSE-MIT
new file mode 100644
index 0000000..e6b42c6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/LICENSE-MIT
@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015-present MagicStack Inc.  http://magic.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/METADATA b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/METADATA
new file mode 100644
index 0000000..b2f91aa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/METADATA
@@ -0,0 +1,157 @@
+Metadata-Version: 2.1
+Name: uvloop
+Version: 0.16.0
+Summary: Fast implementation of asyncio event loop on top of libuv
+Home-page: http://github.com/MagicStack/uvloop
+Author: Yury Selivanov
+Author-email: yury@magic.io
+License: MIT
+Platform: macOS
+Platform: POSIX
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.7
+License-File: LICENSE-APACHE
+License-File: LICENSE-MIT
+Provides-Extra: dev
+Requires-Dist: Cython (<0.30.0,>=0.29.24) ; extra == 'dev'
+Requires-Dist: pytest (>=3.6.0) ; extra == 'dev'
+Requires-Dist: Sphinx (~=4.1.2) ; extra == 'dev'
+Requires-Dist: sphinxcontrib-asyncio (~=0.3.0) ; extra == 'dev'
+Requires-Dist: sphinx-rtd-theme (~=0.5.2) ; extra == 'dev'
+Requires-Dist: aiohttp ; extra == 'dev'
+Requires-Dist: flake8 (~=3.9.2) ; extra == 'dev'
+Requires-Dist: psutil ; extra == 'dev'
+Requires-Dist: pycodestyle (~=2.7.0) ; extra == 'dev'
+Requires-Dist: pyOpenSSL (~=19.0.0) ; extra == 'dev'
+Requires-Dist: mypy (>=0.800) ; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: Sphinx (~=4.1.2) ; extra == 'docs'
+Requires-Dist: sphinxcontrib-asyncio (~=0.3.0) ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme (~=0.5.2) ; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: aiohttp ; extra == 'test'
+Requires-Dist: flake8 (~=3.9.2) ; extra == 'test'
+Requires-Dist: psutil ; extra == 'test'
+Requires-Dist: pycodestyle (~=2.7.0) ; extra == 'test'
+Requires-Dist: pyOpenSSL (~=19.0.0) ; extra == 'test'
+Requires-Dist: mypy (>=0.800) ; extra == 'test'
+
+.. image:: https://img.shields.io/github/workflow/status/MagicStack/uvloop/Tests
+    :target: https://github.com/MagicStack/uvloop/actions?query=workflow%3ATests+branch%3Amaster
+
+.. image:: https://img.shields.io/pypi/v/uvloop.svg
+    :target: https://pypi.python.org/pypi/uvloop
+
+.. image:: https://pepy.tech/badge/uvloop
+    :target: https://pepy.tech/project/uvloop
+    :alt: PyPI - Downloads
+
+
+uvloop is a fast, drop-in replacement of the built-in asyncio
+event loop.  uvloop is implemented in Cython and uses libuv
+under the hood.
+
+The project documentation can be found
+`here <http://uvloop.readthedocs.org/>`_.  Please also check out the
+`wiki <https://github.com/MagicStack/uvloop/wiki>`_.
+
+
+Performance
+-----------
+
+uvloop makes asyncio 2-4x faster.
+
+.. image:: https://raw.githubusercontent.com/MagicStack/uvloop/master/performance.png
+    :target: http://magic.io/blog/uvloop-blazing-fast-python-networking/
+
+The above chart shows the performance of an echo server with different
+message sizes.  The *sockets* benchmark uses ``loop.sock_recv()`` and
+``loop.sock_sendall()`` methods; the *streams* benchmark uses asyncio
+high-level streams, created by the ``asyncio.start_server()`` function;
+and the *protocol* benchmark uses ``loop.create_server()`` with a simple
+echo protocol.  Read more about uvloop in a
+`blog post <http://magic.io/blog/uvloop-blazing-fast-python-networking/>`_
+about it.
+
+
+Installation
+------------
+
+uvloop requires Python 3.7 or greater and is available on PyPI.
+Use pip to install it::
+
+    $ pip install uvloop
+
+Note that it is highly recommended to **upgrade pip before** installing
+uvloop with::
+
+    $ pip install -U pip
+
+
+Using uvloop
+------------
+
+Call ``uvloop.install()`` before calling ``asyncio.run()`` or
+manually creating an asyncio event loop:
+
+.. code:: python
+
+    import asyncio
+    import uvloop
+
+    async def main():
+        # Main entry-point.
+        ...
+
+    uvloop.install()
+    asyncio.run(main())
+
+
+Building From Source
+--------------------
+
+To build uvloop, you'll need Python 3.7 or greater:
+
+1. Clone the repository:
+
+   .. code::
+
+    $ git clone --recursive git@github.com:MagicStack/uvloop.git
+    $ cd uvloop
+
+2. Create a virtual environment and activate it:
+
+   .. code::
+
+    $ python3.7 -m venv uvloop-dev
+    $ source uvloop-dev/bin/activate
+
+3. Install development dependencies:
+
+   ..  code::
+
+    $ pip install -e .[dev]
+
+4. Build and run tests:
+
+   .. code::
+
+    $ make
+    $ make test
+
+
+License
+-------
+
+uvloop is dual-licensed under MIT and Apache 2.0 licenses.
+
+
diff --git a/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/RECORD b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/RECORD
new file mode 100644
index 0000000..0a586eb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/RECORD
@@ -0,0 +1,66 @@
+uvloop/cbhandles.pyx,sha256=UaKWiRtjKYWjJka_zAsWDiw1d96KF4r34GfLy0af1Kg,12084
+uvloop/dns.pyx,sha256=GWpUCjdgoa-po986ho0CEj4Qg7sMztIhmgQG0t9F14g,12242
+uvloop/loop.pxd,sha256=GEJWijlTjXSX0fv4uyycBG26CnUVqLJuPWnXSxfnNyE,6169
+uvloop/server.pyx,sha256=6wC5vUhAHnnUs7qHOJXvRkgov38IeY8xp6w45-rCRFc,3623
+uvloop/errors.pyx,sha256=2etYn89Th3tIsNMLl33Quc-1WkKKY7umPOVvilTzi9k,2774
+uvloop/sslproto.pyx,sha256=EL1fckxojYK42OCAIJ-geUoKc0uncPH1hXg50roBQ-0,35381
+uvloop/loop.c,sha256=mVoiMnVtebfjteIAzhksX-vQwqz8GugCaKwv2s8O8tc,7131196
+uvloop/_version.py,sha256=6sNAXs0xIDfxBsS9ccFLxLCuaXHbKqu_8oKP4VkOgJg,576
+uvloop/pseudosock.pyx,sha256=cOdftlcLZ0hQTPcQYdw_gdajdHXV8b_p1mhTN3x-TLc,5373
+uvloop/lru.pyx,sha256=nBZ4zuy4XjsdLorq-JhNS7WObcLpZWMr1OjyRvv8FaI,2279
+uvloop/_noop.py,sha256=SDAJTiWhE7g3KyttbjPdliv-Uheuas-tKX4_y_nvO_Q,86
+uvloop/request.pxd,sha256=7yx8JlG0Hu2cv_i2QCZ_WdLlsGjI0z5eM_ueOOOgK6w,143
+uvloop/_testbase.py,sha256=3iVbhE6tFDXoA8VfNQCI3p59pbYmj_wNPmQdD8VIZlg,15350
+uvloop/loop.pyi,sha256=AWSVVQbQ_UXEbRM6Xzsn40tZtNyn0S0rQl6ldk3oRhQ,10081
+uvloop/__init__.py,sha256=-ajoRvRk3T4H_ENgWfMOgpuzTUESZ1zCmfi3-R0ouis,1538
+uvloop/loop.cpython-39-darwin.so,sha256=z2f_j-kZK81qKrxQwcl6oJPJkiPy4dG8JO-IBX2PToE,1993608
+uvloop/request.pyx,sha256=6-8Dme6LoT88B5-MzvmpuLn3hGt1eZlekvQxG0x2y8s,2259
+uvloop/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvloop/sslproto.pxd,sha256=fCM5XWu5ZSTDpf5_-wF2jvj77Y403yk40QOiWc0wo1s,3534
+uvloop/loop.pyx,sha256=QonMAOvewNvV5PhmfpO7FfcXZ9JRtdZg0AN8qkWn_Fg,115263
+uvloop/server.pxd,sha256=_zRDiZMjsmlxJRo0KDzSM0xyfg2k-TzlGln54wvXC-Y,394
+uvloop/cbhandles.pxd,sha256=tPTORnu3M0qpjgnveXlbaXDN21kqHcSrfMrzwWZEmlM,731
+uvloop/handles/pipe.pxd,sha256=LzsEOwptkqNa52O1Iyqhxq2d4ppzmHr0x8cMwJIZZfk,933
+uvloop/handles/basetransport.pyx,sha256=GtN3vdp6DDkh1g0RRPemj0r4x-Exskw-m16p_vY_E9g,9553
+uvloop/handles/check.pyx,sha256=E3BpXrWUEtWA78oyfhR97FJjTBiYEr2ctjbEldjaRWE,1865
+uvloop/handles/process.pxd,sha256=wSbcRvKbnjwKqpKrMPwyT_Po7LtSboAB_7Ph3zsnmpc,2296
+uvloop/handles/stream.pyx,sha256=qlPsoOg7PQrx9RGeU6tm4GA099tuS9_dZFKA8FOnv0U,31823
+uvloop/handles/timer.pxd,sha256=VcLZBfzd9ixuxmJrE9O3YmyVO4LfMDwcG7UNpJbTu40,440
+uvloop/handles/poll.pxd,sha256=A6oaU1uBMbLsgQ1sAk5VgzeFIiOr_qaGlEq41Jo2Jf8,566
+uvloop/handles/tcp.pxd,sha256=xNYy-df1tK5ywK3V7a0wWno9tAA7JH-FiIQ5F0296ZM,892
+uvloop/handles/udp.pxd,sha256=gQn9FH4rAiXDR_kZNqaYcNMGMzFL-T1V1G8JI6JOHU8,671
+uvloop/handles/streamserver.pyx,sha256=-70Os2ni6eRtqSXvg6BzJiUHDJroCKP05TaKfC4rLeY,4650
+uvloop/handles/idle.pyx,sha256=H7249m-KaxGpztwlWMdq_BtNA1vs8bYTEKa7P7fcsNI,1843
+uvloop/handles/async_.pyx,sha256=hX6InWZJQNEdd82glqdCQdCzlAeMCu3JDUpn4l8Qvas,1500
+uvloop/handles/handle.pyx,sha256=FiNV1-NTolTwTK2HnUSkeLZv5c-3ZKQiZSH0Nj0hevc,13219
+uvloop/handles/handle.pxd,sha256=QPjUCObkDwvjRAZFlolF1tNXFV9-jAf22V0KweiLdOA,1189
+uvloop/handles/async_.pxd,sha256=xtsWSi0A67joJU4iFp5JWzQxwNj4LCq_KMDyDDMxdec,252
+uvloop/handles/idle.pxd,sha256=L3Gr2tuzKHWEB2NnykwjbNyexNUlckBdGFKPufn5AZU,274
+uvloop/handles/streamserver.pxd,sha256=hIDDhB2RK0lnMUscDWcGl2NRkclb6AYfche77YEdaes,786
+uvloop/handles/udp.pyx,sha256=6Wowq2X6uQPGLVr-cZmpQIdiuXuQF5LxBUC9dS-7QqY,12041
+uvloop/handles/tcp.pyx,sha256=4N6epUuY-DggDRSg1RMMi-ebZSMsWxfbIuXlv_qNhTo,7271
+uvloop/handles/poll.pyx,sha256=WWfLeeWqEzaMjOEDiUoetsANE-4zFAWME7xU6YocWR0,6506
+uvloop/handles/timer.pyx,sha256=tpGDqv3X90Lm63yGmXcWVI5RovM74H-wSw-sda34TdE,2400
+uvloop/handles/stream.pxd,sha256=J14x3cyRNCCcvksIKsAWahckv1mSbAKmKFipZ5tedIs,1062
+uvloop/handles/process.pyx,sha256=2Csa8d1Fz6SvmeXPKolzFqWKVNFNDtYKevinIlvTzMQ,25986
+uvloop/handles/check.pxd,sha256=IufFrzdMhLRc5zAjh7Lb0lAqw-UclrYVo-UgqIs6eJ0,276
+uvloop/handles/basetransport.pxd,sha256=SiDD77NPthTfjXVg12gJJGM1YYKZXw4AEK9tv22jJeE,1322
+uvloop/handles/pipe.pyx,sha256=MOhqjjD8rs9xyTu0601TruFQU1arJh8IX6CEpusyoEU,6950
+uvloop/includes/debug.h,sha256=1Fhpk1ni8KlJ0S0YqeIj11kl-XKDETmH1Sjf-yA_vhs,51
+uvloop/includes/consts.pxi,sha256=8REOdrR0a0DiJIWlQI9C2Jwxz2EN-iK7mopcRYMdVW0,687
+uvloop/includes/__init__.py,sha256=-OUZ6zr6Opdw78PKsHYi1AuP74Ep7XByxyoRYOuRtgI,361
+uvloop/includes/fork_handler.h,sha256=tB1KPZH7b_pEUN80VEtfGSb8fgEGkPlCyfbkPoqPlq0,509
+uvloop/includes/compat.h,sha256=y7nPDNCFBQzduwpjA4-dusV-SYR7rx4h7ixoElJ4SaY,1674
+uvloop/includes/debug.pxd,sha256=cCnlyp6HkhQgVF7lAQPA31wIa1n1pn6eUY_wARYh3uA,64
+uvloop/includes/flowcontrol.pxd,sha256=7PuZtEgp4TS1Y3iNqZZInkDKI5iCylERrcLqe2ls3EY,458
+uvloop/includes/system.pxd,sha256=NgQMQ4aCmsLrEj5YCLEMt1ruJjQ0QJQW4aGMEvCtt7I,2047
+uvloop/includes/uv.pxd,sha256=_YdHIrMEN66tQvuHJJVuDsI8Xr4Z0o2LrKwYZUlUY4U,15340
+uvloop/includes/python.pxd,sha256=mIqSAV0E-UsVIHdVa175agpXr3mrvAYlku-JnwOGozI,846
+uvloop/includes/stdlib.pxi,sha256=OrHwe65HC6PBYPr8CMsiOoSknu6tla6_ws7HWx3qU-Q,6261
+uvloop-0.16.0.dist-info/LICENSE-APACHE,sha256=L9xDamcHeUEpXFhkf1Ifvvj1DkbbCXBVL6Gk3YriYcY,11435
+uvloop-0.16.0.dist-info/WHEEL,sha256=bRe_g_g-vZInZP5wOdewl-4AeWx8E2_UC3Ffr2csPyk,109
+uvloop-0.16.0.dist-info/top_level.txt,sha256=2cDaltyemYfQErB19s2jFmumeJRnbsZPJ7Lj9A78c6Y,7
+uvloop-0.16.0.dist-info/METADATA,sha256=WJ7Pl_78g_TWKXAkFQ4ycmPtqnkfLmOHmC-GiKq6Ae0,4474
+uvloop-0.16.0.dist-info/LICENSE-MIT,sha256=kYXzx36fbviFmmukyUEorBMph2vj6BOq0y12ReUa5Ak,1101
+uvloop-0.16.0.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+uvloop-0.16.0.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/WHEEL
new file mode 100644
index 0000000..868d54a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_9_x86_64
+
diff --git a/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/top_level.txt
new file mode 100644
index 0000000..99d4716
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop-0.16.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+uvloop
diff --git a/myenv/lib/python3.9/site-packages/uvloop/__init__.py b/myenv/lib/python3.9/site-packages/uvloop/__init__.py
new file mode 100644
index 0000000..529b0a9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/__init__.py
@@ -0,0 +1,54 @@
+import asyncio as __asyncio
+import typing as _typing
+
+from asyncio.events import BaseDefaultEventLoopPolicy as __BasePolicy
+
+from . import includes as __includes  # NOQA
+from .loop import Loop as __BaseLoop  # NOQA
+from ._version import __version__  # NOQA
+
+
+__all__ = ('new_event_loop', 'install', 'EventLoopPolicy')
+
+
+class Loop(__BaseLoop, __asyncio.AbstractEventLoop):  # type: ignore[misc]
+    pass
+
+
+def new_event_loop() -> Loop:
+    """Return a new event loop."""
+    return Loop()
+
+
+def install() -> None:
+    """A helper function to install uvloop policy."""
+    __asyncio.set_event_loop_policy(EventLoopPolicy())
+
+
+class EventLoopPolicy(__BasePolicy):
+    """Event loop policy.
+
+    The preferred way to make your application use uvloop:
+
+    >>> import asyncio
+    >>> import uvloop
+    >>> asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+    >>> asyncio.get_event_loop()
+    <uvloop.Loop running=False closed=False debug=False>
+    """
+
+    def _loop_factory(self) -> Loop:
+        return new_event_loop()
+
+    if _typing.TYPE_CHECKING:
+        # EventLoopPolicy doesn't implement these, but since they are marked
+        # as abstract in typeshed, we have to put them in so mypy thinks
+        # the base methods are overridden. This is the same approach taken
+        # for the Windows event loop policy classes in typeshed.
+        def get_child_watcher(self) -> _typing.NoReturn:
+            ...
+
+        def set_child_watcher(
+            self, watcher: _typing.Any
+        ) -> _typing.NoReturn:
+            ...
diff --git a/myenv/lib/python3.9/site-packages/uvloop/_noop.py b/myenv/lib/python3.9/site-packages/uvloop/_noop.py
new file mode 100644
index 0000000..bfc14dc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/_noop.py
@@ -0,0 +1,3 @@
+def noop() -> None:
+    """Empty function to invoke CPython ceval loop."""
+    return
diff --git a/myenv/lib/python3.9/site-packages/uvloop/_testbase.py b/myenv/lib/python3.9/site-packages/uvloop/_testbase.py
new file mode 100644
index 0000000..3cc828c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/_testbase.py
@@ -0,0 +1,547 @@
+"""Test utilities. Don't use outside of the uvloop project."""
+
+
+import asyncio
+import asyncio.events
+import collections
+import contextlib
+import gc
+import logging
+import os
+import pprint
+import re
+import select
+import socket
+import ssl
+import tempfile
+import threading
+import time
+import unittest
+import uvloop
+
+
+class MockPattern(str):
+    def __eq__(self, other):
+        return bool(re.search(str(self), other, re.S))
+
+
+class TestCaseDict(collections.UserDict):
+
+    def __init__(self, name):
+        super().__init__()
+        self.name = name
+
+    def __setitem__(self, key, value):
+        if key in self.data:
+            raise RuntimeError('duplicate test {}.{}'.format(
+                self.name, key))
+        super().__setitem__(key, value)
+
+
+class BaseTestCaseMeta(type):
+
+    @classmethod
+    def __prepare__(mcls, name, bases):
+        return TestCaseDict(name)
+
+    def __new__(mcls, name, bases, dct):
+        for test_name in dct:
+            if not test_name.startswith('test_'):
+                continue
+            for base in bases:
+                if hasattr(base, test_name):
+                    raise RuntimeError(
+                        'duplicate test {}.{} (also defined in {} '
+                        'parent class)'.format(
+                            name, test_name, base.__name__))
+
+        return super().__new__(mcls, name, bases, dict(dct))
+
+
+class BaseTestCase(unittest.TestCase, metaclass=BaseTestCaseMeta):
+
+    def new_loop(self):
+        raise NotImplementedError
+
+    def new_policy(self):
+        raise NotImplementedError
+
+    def mock_pattern(self, str):
+        return MockPattern(str)
+
+    async def wait_closed(self, obj):
+        if not isinstance(obj, asyncio.StreamWriter):
+            return
+        try:
+            await obj.wait_closed()
+        except (BrokenPipeError, ConnectionError):
+            pass
+
+    def is_asyncio_loop(self):
+        return type(self.loop).__module__.startswith('asyncio.')
+
+    def run_loop_briefly(self, *, delay=0.01):
+        self.loop.run_until_complete(asyncio.sleep(delay))
+
+    def loop_exception_handler(self, loop, context):
+        self.__unhandled_exceptions.append(context)
+        self.loop.default_exception_handler(context)
+
+    def setUp(self):
+        self.loop = self.new_loop()
+        asyncio.set_event_loop_policy(self.new_policy())
+        asyncio.set_event_loop(self.loop)
+        self._check_unclosed_resources_in_debug = True
+
+        self.loop.set_exception_handler(self.loop_exception_handler)
+        self.__unhandled_exceptions = []
+
+    def tearDown(self):
+        self.loop.close()
+
+        if self.__unhandled_exceptions:
+            print('Unexpected calls to loop.call_exception_handler():')
+            pprint.pprint(self.__unhandled_exceptions)
+            self.fail('unexpected calls to loop.call_exception_handler()')
+            return
+
+        if not self._check_unclosed_resources_in_debug:
+            return
+
+        # GC to show any resource warnings as the test completes
+        gc.collect()
+        gc.collect()
+        gc.collect()
+
+        if getattr(self.loop, '_debug_cc', False):
+            gc.collect()
+            gc.collect()
+            gc.collect()
+
+            self.assertEqual(
+                self.loop._debug_uv_handles_total,
+                self.loop._debug_uv_handles_freed,
+                'not all uv_handle_t handles were freed')
+
+            self.assertEqual(
+                self.loop._debug_cb_handles_count, 0,
+                'not all callbacks (call_soon) are GCed')
+
+            self.assertEqual(
+                self.loop._debug_cb_timer_handles_count, 0,
+                'not all timer callbacks (call_later) are GCed')
+
+            self.assertEqual(
+                self.loop._debug_stream_write_ctx_cnt, 0,
+                'not all stream write contexts are GCed')
+
+            for h_name, h_cnt in self.loop._debug_handles_current.items():
+                with self.subTest('Alive handle after test',
+                                  handle_name=h_name):
+                    self.assertEqual(
+                        h_cnt, 0,
+                        'alive {} after test'.format(h_name))
+
+            for h_name, h_cnt in self.loop._debug_handles_total.items():
+                with self.subTest('Total/closed handles',
+                                  handle_name=h_name):
+                    self.assertEqual(
+                        h_cnt, self.loop._debug_handles_closed[h_name],
+                        'total != closed for {}'.format(h_name))
+
+        asyncio.set_event_loop(None)
+        asyncio.set_event_loop_policy(None)
+        self.loop = None
+
+    def skip_unclosed_handles_check(self):
+        self._check_unclosed_resources_in_debug = False
+
+    def tcp_server(self, server_prog, *,
+                   family=socket.AF_INET,
+                   addr=None,
+                   timeout=5,
+                   backlog=1,
+                   max_clients=10):
+
+        if addr is None:
+            if family == socket.AF_UNIX:
+                with tempfile.NamedTemporaryFile() as tmp:
+                    addr = tmp.name
+            else:
+                addr = ('127.0.0.1', 0)
+
+        sock = socket.socket(family, socket.SOCK_STREAM)
+
+        if timeout is None:
+            raise RuntimeError('timeout is required')
+        if timeout <= 0:
+            raise RuntimeError('only blocking sockets are supported')
+        sock.settimeout(timeout)
+
+        try:
+            sock.bind(addr)
+            sock.listen(backlog)
+        except OSError as ex:
+            sock.close()
+            raise ex
+
+        return TestThreadedServer(
+            self, sock, server_prog, timeout, max_clients)
+
+    def tcp_client(self, client_prog,
+                   family=socket.AF_INET,
+                   timeout=10):
+
+        sock = socket.socket(family, socket.SOCK_STREAM)
+
+        if timeout is None:
+            raise RuntimeError('timeout is required')
+        if timeout <= 0:
+            raise RuntimeError('only blocking sockets are supported')
+        sock.settimeout(timeout)
+
+        return TestThreadedClient(
+            self, sock, client_prog, timeout)
+
+    def unix_server(self, *args, **kwargs):
+        return self.tcp_server(*args, family=socket.AF_UNIX, **kwargs)
+
+    def unix_client(self, *args, **kwargs):
+        return self.tcp_client(*args, family=socket.AF_UNIX, **kwargs)
+
+    @contextlib.contextmanager
+    def unix_sock_name(self):
+        with tempfile.TemporaryDirectory() as td:
+            fn = os.path.join(td, 'sock')
+            try:
+                yield fn
+            finally:
+                try:
+                    os.unlink(fn)
+                except OSError:
+                    pass
+
+    def _abort_socket_test(self, ex):
+        try:
+            self.loop.stop()
+        finally:
+            self.fail(ex)
+
+
+def _cert_fullname(test_file_name, cert_file_name):
+    fullname = os.path.abspath(os.path.join(
+        os.path.dirname(test_file_name), 'certs', cert_file_name))
+    assert os.path.isfile(fullname)
+    return fullname
+
+
+@contextlib.contextmanager
+def silence_long_exec_warning():
+
+    class Filter(logging.Filter):
+        def filter(self, record):
+            return not (record.msg.startswith('Executing') and
+                        record.msg.endswith('seconds'))
+
+    logger = logging.getLogger('asyncio')
+    filter = Filter()
+    logger.addFilter(filter)
+    try:
+        yield
+    finally:
+        logger.removeFilter(filter)
+
+
+def find_free_port(start_from=50000):
+    for port in range(start_from, start_from + 500):
+        sock = socket.socket()
+        with sock:
+            try:
+                sock.bind(('', port))
+            except socket.error:
+                continue
+            else:
+                return port
+    raise RuntimeError('could not find a free port')
+
+
+class SSLTestCase:
+
+    def _create_server_ssl_context(self, certfile, keyfile=None):
+        if hasattr(ssl, 'PROTOCOL_TLS'):
+            sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS)
+        else:
+            sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+        sslcontext.options |= ssl.OP_NO_SSLv2
+        sslcontext.load_cert_chain(certfile, keyfile)
+        return sslcontext
+
+    def _create_client_ssl_context(self, *, disable_verify=True):
+        sslcontext = ssl.create_default_context()
+        sslcontext.check_hostname = False
+        if disable_verify:
+            sslcontext.verify_mode = ssl.CERT_NONE
+        return sslcontext
+
+    @contextlib.contextmanager
+    def _silence_eof_received_warning(self):
+        # TODO This warning has to be fixed in asyncio.
+        logger = logging.getLogger('asyncio')
+        filter = logging.Filter('has no effect when using ssl')
+        logger.addFilter(filter)
+        try:
+            yield
+        finally:
+            logger.removeFilter(filter)
+
+
+class UVTestCase(BaseTestCase):
+
+    implementation = 'uvloop'
+
+    def new_loop(self):
+        return uvloop.new_event_loop()
+
+    def new_policy(self):
+        return uvloop.EventLoopPolicy()
+
+
+class AIOTestCase(BaseTestCase):
+
+    implementation = 'asyncio'
+
+    def setUp(self):
+        super().setUp()
+
+        watcher = asyncio.SafeChildWatcher()
+        watcher.attach_loop(self.loop)
+        asyncio.set_child_watcher(watcher)
+
+    def tearDown(self):
+        asyncio.set_child_watcher(None)
+        super().tearDown()
+
+    def new_loop(self):
+        return asyncio.new_event_loop()
+
+    def new_policy(self):
+        return asyncio.DefaultEventLoopPolicy()
+
+
+def has_IPv6():
+    server_sock = socket.socket(socket.AF_INET6)
+    with server_sock:
+        try:
+            server_sock.bind(('::1', 0))
+        except OSError:
+            return False
+        else:
+            return True
+
+
+has_IPv6 = has_IPv6()
+
+
+###############################################################################
+# Socket Testing Utilities
+###############################################################################
+
+
+class TestSocketWrapper:
+
+    def __init__(self, sock):
+        self.__sock = sock
+
+    def recv_all(self, n):
+        buf = b''
+        while len(buf) < n:
+            data = self.recv(n - len(buf))
+            if data == b'':
+                raise ConnectionAbortedError
+            buf += data
+        return buf
+
+    def starttls(self, ssl_context, *,
+                 server_side=False,
+                 server_hostname=None,
+                 do_handshake_on_connect=True):
+
+        assert isinstance(ssl_context, ssl.SSLContext)
+
+        ssl_sock = ssl_context.wrap_socket(
+            self.__sock, server_side=server_side,
+            server_hostname=server_hostname,
+            do_handshake_on_connect=do_handshake_on_connect)
+
+        if server_side:
+            ssl_sock.do_handshake()
+
+        self.__sock.close()
+        self.__sock = ssl_sock
+
+    def __getattr__(self, name):
+        return getattr(self.__sock, name)
+
+    def __repr__(self):
+        return '<{} {!r}>'.format(type(self).__name__, self.__sock)
+
+
+class SocketThread(threading.Thread):
+
+    def stop(self):
+        self._active = False
+        self.join()
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, *exc):
+        self.stop()
+
+
+class TestThreadedClient(SocketThread):
+
+    def __init__(self, test, sock, prog, timeout):
+        threading.Thread.__init__(self, None, None, 'test-client')
+        self.daemon = True
+
+        self._timeout = timeout
+        self._sock = sock
+        self._active = True
+        self._prog = prog
+        self._test = test
+
+    def run(self):
+        try:
+            self._prog(TestSocketWrapper(self._sock))
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as ex:
+            self._test._abort_socket_test(ex)
+
+
+class TestThreadedServer(SocketThread):
+
+    def __init__(self, test, sock, prog, timeout, max_clients):
+        threading.Thread.__init__(self, None, None, 'test-server')
+        self.daemon = True
+
+        self._clients = 0
+        self._finished_clients = 0
+        self._max_clients = max_clients
+        self._timeout = timeout
+        self._sock = sock
+        self._active = True
+
+        self._prog = prog
+
+        self._s1, self._s2 = socket.socketpair()
+        self._s1.setblocking(False)
+
+        self._test = test
+
+    def stop(self):
+        try:
+            if self._s2 and self._s2.fileno() != -1:
+                try:
+                    self._s2.send(b'stop')
+                except OSError:
+                    pass
+        finally:
+            super().stop()
+
+    def run(self):
+        try:
+            with self._sock:
+                self._sock.setblocking(0)
+                self._run()
+        finally:
+            self._s1.close()
+            self._s2.close()
+
+    def _run(self):
+        while self._active:
+            if self._clients >= self._max_clients:
+                return
+
+            r, w, x = select.select(
+                [self._sock, self._s1], [], [], self._timeout)
+
+            if self._s1 in r:
+                return
+
+            if self._sock in r:
+                try:
+                    conn, addr = self._sock.accept()
+                except BlockingIOError:
+                    continue
+                except socket.timeout:
+                    if not self._active:
+                        return
+                    else:
+                        raise
+                else:
+                    self._clients += 1
+                    conn.settimeout(self._timeout)
+                    try:
+                        with conn:
+                            self._handle_client(conn)
+                    except (KeyboardInterrupt, SystemExit):
+                        raise
+                    except BaseException as ex:
+                        self._active = False
+                        try:
+                            raise
+                        finally:
+                            self._test._abort_socket_test(ex)
+
+    def _handle_client(self, sock):
+        self._prog(TestSocketWrapper(sock))
+
+    @property
+    def addr(self):
+        return self._sock.getsockname()
+
+
+###############################################################################
+# A few helpers from asyncio/tests/testutils.py
+###############################################################################
+
+
+def run_briefly(loop):
+    async def once():
+        pass
+    gen = once()
+    t = loop.create_task(gen)
+    # Don't log a warning if the task is not done after run_until_complete().
+    # It occurs if the loop is stopped or if a task raises a BaseException.
+    t._log_destroy_pending = False
+    try:
+        loop.run_until_complete(t)
+    finally:
+        gen.close()
+
+
+def run_until(loop, pred, timeout=30):
+    deadline = time.time() + timeout
+    while not pred():
+        if timeout is not None:
+            timeout = deadline - time.time()
+            if timeout <= 0:
+                raise asyncio.futures.TimeoutError()
+        loop.run_until_complete(asyncio.tasks.sleep(0.001))
+
+
+@contextlib.contextmanager
+def disable_logger():
+    """Context manager to disable asyncio logger.
+
+    For example, it can be used to ignore warnings in debug mode.
+    """
+    old_level = asyncio.log.logger.level
+    try:
+        asyncio.log.logger.setLevel(logging.CRITICAL + 1)
+        yield
+    finally:
+        asyncio.log.logger.setLevel(old_level)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/_version.py b/myenv/lib/python3.9/site-packages/uvloop/_version.py
new file mode 100644
index 0000000..8002348
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/_version.py
@@ -0,0 +1,13 @@
+# This file MUST NOT contain anything but the __version__ assignment.
+#
+# When making a release, change the value of __version__
+# to an appropriate value, and open a pull request against
+# the correct branch (master if making a new feature release).
+# The commit message MUST contain a properly formatted release
+# log, and the commit must be signed.
+#
+# The release automation will: build and test the packages for the
+# supported platforms, publish the packages on PyPI, merge the PR
+# to the target branch, create a Git tag pointing to the commit.
+
+__version__ = '0.16.0'
diff --git a/myenv/lib/python3.9/site-packages/uvloop/cbhandles.pxd b/myenv/lib/python3.9/site-packages/uvloop/cbhandles.pxd
new file mode 100644
index 0000000..ba65d9d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/cbhandles.pxd
@@ -0,0 +1,38 @@
+cdef class Handle:
+    cdef:
+        Loop loop
+        object context
+        bint _cancelled
+
+        str meth_name
+        int cb_type
+        void *callback
+        object arg1, arg2, arg3, arg4
+
+        object __weakref__
+
+        readonly _source_traceback
+
+    cdef inline _set_loop(self, Loop loop)
+    cdef inline _set_context(self, object context)
+
+    cdef inline _run(self)
+    cdef _cancel(self)
+
+    cdef _format_handle(self)
+
+
+cdef class TimerHandle:
+    cdef:
+        object callback
+        tuple args
+        bint _cancelled
+        UVTimer timer
+        Loop loop
+        object context
+        tuple _debug_info
+        object __weakref__
+
+    cdef _run(self)
+    cdef _cancel(self)
+    cdef inline _clear(self)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/cbhandles.pyx b/myenv/lib/python3.9/site-packages/uvloop/cbhandles.pyx
new file mode 100644
index 0000000..6d6a0b0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/cbhandles.pyx
@@ -0,0 +1,428 @@
+@cython.no_gc_clear
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class Handle:
+    def __cinit__(self):
+        self._cancelled = 0
+        self.cb_type = 0
+        self._source_traceback = None
+
+    cdef inline _set_loop(self, Loop loop):
+        self.loop = loop
+        if UVLOOP_DEBUG:
+            loop._debug_cb_handles_total += 1
+            loop._debug_cb_handles_count += 1
+        if loop._debug:
+            self._source_traceback = extract_stack()
+
+    cdef inline _set_context(self, object context):
+        if context is None:
+            context = Context_CopyCurrent()
+        self.context = context
+
+    def __dealloc__(self):
+        if UVLOOP_DEBUG and self.loop is not None:
+            self.loop._debug_cb_handles_count -= 1
+        if self.loop is None:
+            raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
+
+    def __init__(self):
+        raise TypeError(
+            '{} is not supposed to be instantiated from Python'.format(
+                self.__class__.__name__))
+
+    cdef inline _run(self):
+        cdef:
+            int cb_type
+            object callback
+
+        if self._cancelled:
+            return
+
+        cb_type = self.cb_type
+
+        # Since _run is a cdef and there's no BoundMethod,
+        # we guard 'self' manually (since the callback
+        # might cause GC of the handle.)
+        Py_INCREF(self)
+
+        try:
+            assert self.context is not None
+            Context_Enter(self.context)
+
+            if cb_type == 1:
+                callback = self.arg1
+                if callback is None:
+                    raise RuntimeError(
+                        'cannot run Handle; callback is not set')
+
+                args = self.arg2
+
+                if args is None:
+                    callback()
+                else:
+                    callback(*args)
+
+            elif cb_type == 2:
+                (<method_t>self.callback)(self.arg1)
+
+            elif cb_type == 3:
+                (<method1_t>self.callback)(self.arg1, self.arg2)
+
+            elif cb_type == 4:
+                (<method2_t>self.callback)(self.arg1, self.arg2, self.arg3)
+
+            elif cb_type == 5:
+                (<method3_t>self.callback)(
+                    self.arg1, self.arg2, self.arg3, self.arg4)
+
+            else:
+                raise RuntimeError('invalid Handle.cb_type: {}'.format(
+                    cb_type))
+
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as ex:
+            if cb_type == 1:
+                msg = 'Exception in callback {}'.format(callback)
+            else:
+                msg = 'Exception in callback {}'.format(self.meth_name)
+
+            context = {
+                'message': msg,
+                'exception': ex,
+                'handle': self,
+            }
+
+            if self._source_traceback is not None:
+                context['source_traceback'] = self._source_traceback
+
+            self.loop.call_exception_handler(context)
+
+        finally:
+            context = self.context
+            Py_DECREF(self)
+            Context_Exit(context)
+
+    cdef _cancel(self):
+        self._cancelled = 1
+        self.callback = NULL
+        self.arg1 = self.arg2 = self.arg3 = self.arg4 = None
+
+    cdef _format_handle(self):
+        # Mirrors `asyncio.base_events._format_handle`.
+        if self.cb_type == 1 and self.arg1 is not None:
+            cb = self.arg1
+            if isinstance(getattr(cb, '__self__', None), aio_Task):
+                try:
+                    return repr(cb.__self__)
+                except (AttributeError, TypeError, ValueError) as ex:
+                    # Cython generates empty __code__ objects for coroutines
+                    # that can crash asyncio.Task.__repr__ with an
+                    # AttributeError etc.  Guard against that.
+                    self.loop.call_exception_handler({
+                        'message': 'exception in Task.__repr__',
+                        'task': cb.__self__,
+                        'exception': ex,
+                        'handle': self,
+                    })
+        return repr(self)
+
+    # Public API
+
+    def __repr__(self):
+        info = [self.__class__.__name__]
+
+        if self._cancelled:
+            info.append('cancelled')
+
+        if self.cb_type == 1 and self.arg1 is not None:
+            func = self.arg1
+            # Cython can unset func.__qualname__/__name__, hence the checks.
+            if hasattr(func, '__qualname__') and func.__qualname__:
+                cb_name = func.__qualname__
+            elif hasattr(func, '__name__') and func.__name__:
+                cb_name = func.__name__
+            else:
+                cb_name = repr(func)
+
+            info.append(cb_name)
+        elif self.meth_name is not None:
+            info.append(self.meth_name)
+
+        if self._source_traceback is not None:
+            frame = self._source_traceback[-1]
+            info.append('created at {}:{}'.format(frame[0], frame[1]))
+
+        return '<' + ' '.join(info) + '>'
+
+    def cancel(self):
+        self._cancel()
+
+    def cancelled(self):
+        return self._cancelled
+
+
+@cython.no_gc_clear
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class TimerHandle:
+    def __cinit__(self, Loop loop, object callback, object args,
+                  uint64_t delay, object context):
+
+        self.loop = loop
+        self.callback = callback
+        self.args = args
+        self._cancelled = 0
+
+        if UVLOOP_DEBUG:
+            self.loop._debug_cb_timer_handles_total += 1
+            self.loop._debug_cb_timer_handles_count += 1
+
+        if context is None:
+            context = Context_CopyCurrent()
+        self.context = context
+
+        if loop._debug:
+            self._debug_info = (
+                format_callback_name(callback),
+                extract_stack()
+            )
+        else:
+            self._debug_info = None
+
+        self.timer = UVTimer.new(
+            loop, <method_t>self._run, self, delay)
+
+        self.timer.start()
+
+        # Only add to loop._timers when `self.timer` is successfully created
+        loop._timers.add(self)
+
+    property _source_traceback:
+        def __get__(self):
+            if self._debug_info is not None:
+                return self._debug_info[1]
+
+    def __dealloc__(self):
+        if UVLOOP_DEBUG:
+            self.loop._debug_cb_timer_handles_count -= 1
+        if self.timer is not None:
+            raise RuntimeError('active TimerHandle is deallacating')
+
+    cdef _cancel(self):
+        if self._cancelled == 1:
+            return
+        self._cancelled = 1
+        self._clear()
+
+    cdef inline _clear(self):
+        if self.timer is None:
+            return
+
+        self.callback = None
+        self.args = None
+
+        try:
+            self.loop._timers.remove(self)
+        finally:
+            self.timer._close()
+            self.timer = None  # let the UVTimer handle GC
+
+    cdef _run(self):
+        if self._cancelled == 1:
+            return
+        if self.callback is None:
+            raise RuntimeError('cannot run TimerHandle; callback is not set')
+
+        callback = self.callback
+        args = self.args
+
+        # Since _run is a cdef and there's no BoundMethod,
+        # we guard 'self' manually.
+        Py_INCREF(self)
+
+        if self.loop._debug:
+            started = time_monotonic()
+        try:
+            assert self.context is not None
+            Context_Enter(self.context)
+
+            if args is not None:
+                callback(*args)
+            else:
+                callback()
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as ex:
+            context = {
+                'message': 'Exception in callback {}'.format(callback),
+                'exception': ex,
+                'handle': self,
+            }
+
+            if self._debug_info is not None:
+                context['source_traceback'] = self._debug_info[1]
+
+            self.loop.call_exception_handler(context)
+        else:
+            if self.loop._debug:
+                delta = time_monotonic() - started
+                if delta > self.loop.slow_callback_duration:
+                    aio_logger.warning(
+                        'Executing %r took %.3f seconds',
+                        self, delta)
+        finally:
+            context = self.context
+            Py_DECREF(self)
+            Context_Exit(context)
+            self._clear()
+
+    # Public API
+
+    def __repr__(self):
+        info = [self.__class__.__name__]
+
+        if self._cancelled:
+            info.append('cancelled')
+
+        if self._debug_info is not None:
+            callback_name = self._debug_info[0]
+            source_traceback = self._debug_info[1]
+        else:
+            callback_name = None
+            source_traceback = None
+
+        if callback_name is not None:
+            info.append(callback_name)
+        elif self.callback is not None:
+            info.append(format_callback_name(self.callback))
+
+        if source_traceback is not None:
+            frame = source_traceback[-1]
+            info.append('created at {}:{}'.format(frame[0], frame[1]))
+
+        return '<' + ' '.join(info) + '>'
+
+    def cancelled(self):
+        return self._cancelled
+
+    def cancel(self):
+        self._cancel()
+
+    def when(self):
+        return self.timer.get_when() * 1e-3
+
+
+cdef format_callback_name(func):
+    if hasattr(func, '__qualname__'):
+        cb_name = getattr(func, '__qualname__')
+    elif hasattr(func, '__name__'):
+        cb_name = getattr(func, '__name__')
+    else:
+        cb_name = repr(func)
+    return cb_name
+
+
+cdef new_Handle(Loop loop, object callback, object args, object context):
+    cdef Handle handle
+    handle = Handle.__new__(Handle)
+    handle._set_loop(loop)
+    handle._set_context(context)
+
+    handle.cb_type = 1
+
+    handle.arg1 = callback
+    handle.arg2 = args
+
+    return handle
+
+
+cdef new_MethodHandle(Loop loop, str name, method_t callback, object context,
+                      object bound_to):
+    cdef Handle handle
+    handle = Handle.__new__(Handle)
+    handle._set_loop(loop)
+    handle._set_context(context)
+
+    handle.cb_type = 2
+    handle.meth_name = name
+
+    handle.callback = <void*> callback
+    handle.arg1 = bound_to
+
+    return handle
+
+
+cdef new_MethodHandle1(Loop loop, str name, method1_t callback, object context,
+                       object bound_to, object arg):
+
+    cdef Handle handle
+    handle = Handle.__new__(Handle)
+    handle._set_loop(loop)
+    handle._set_context(context)
+
+    handle.cb_type = 3
+    handle.meth_name = name
+
+    handle.callback = <void*> callback
+    handle.arg1 = bound_to
+    handle.arg2 = arg
+
+    return handle
+
+
+cdef new_MethodHandle2(Loop loop, str name, method2_t callback, object context,
+                       object bound_to, object arg1, object arg2):
+
+    cdef Handle handle
+    handle = Handle.__new__(Handle)
+    handle._set_loop(loop)
+    handle._set_context(context)
+
+    handle.cb_type = 4
+    handle.meth_name = name
+
+    handle.callback = <void*> callback
+    handle.arg1 = bound_to
+    handle.arg2 = arg1
+    handle.arg3 = arg2
+
+    return handle
+
+
+cdef new_MethodHandle3(Loop loop, str name, method3_t callback, object context,
+                       object bound_to, object arg1, object arg2, object arg3):
+
+    cdef Handle handle
+    handle = Handle.__new__(Handle)
+    handle._set_loop(loop)
+    handle._set_context(context)
+
+    handle.cb_type = 5
+    handle.meth_name = name
+
+    handle.callback = <void*> callback
+    handle.arg1 = bound_to
+    handle.arg2 = arg1
+    handle.arg3 = arg2
+    handle.arg4 = arg3
+
+    return handle
+
+
+cdef extract_stack():
+    """Replacement for traceback.extract_stack() that only does the
+    necessary work for asyncio debug mode.
+    """
+    f = sys_getframe()
+    if f is None:
+        return
+
+    try:
+        stack = tb_StackSummary.extract(tb_walk_stack(f),
+                                        limit=DEBUG_STACK_DEPTH,
+                                        lookup_lines=False)
+    finally:
+        f = None
+
+    stack.reverse()
+    return stack
diff --git a/myenv/lib/python3.9/site-packages/uvloop/dns.pyx b/myenv/lib/python3.9/site-packages/uvloop/dns.pyx
new file mode 100644
index 0000000..a252a24
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/dns.pyx
@@ -0,0 +1,422 @@
+cdef __port_to_int(port, proto):
+    if type(port) is int:
+        return port
+
+    if port is None or port == '' or port == b'':
+        return 0
+
+    try:
+        return int(port)
+    except (ValueError, TypeError):
+        pass
+
+    if isinstance(port, bytes):
+        port = port.decode()
+
+    if isinstance(port, str) and proto is not None:
+        if proto == uv.IPPROTO_TCP:
+            return socket_getservbyname(port, 'tcp')
+        elif proto == uv.IPPROTO_UDP:
+            return socket_getservbyname(port, 'udp')
+
+    raise OSError('service/proto not found')
+
+
+cdef __convert_sockaddr_to_pyaddr(const system.sockaddr* addr):
+    # Converts sockaddr structs into what Python socket
+    # module can understand:
+    #   - for IPv4 a tuple of (host, port)
+    #   - for IPv6 a tuple of (host, port, flowinfo, scope_id)
+
+    cdef:
+        char buf[128]  # INET6_ADDRSTRLEN is usually 46
+        int err
+        system.sockaddr_in *addr4
+        system.sockaddr_in6 *addr6
+        system.sockaddr_un *addr_un
+
+    if addr.sa_family == uv.AF_INET:
+        addr4 = <system.sockaddr_in*>addr
+
+        err = uv.uv_ip4_name(addr4, buf, sizeof(buf))
+        if err < 0:
+            raise convert_error(err)
+
+        return (
+            PyUnicode_FromString(buf),
+            system.ntohs(addr4.sin_port)
+        )
+
+    elif addr.sa_family == uv.AF_INET6:
+        addr6 = <system.sockaddr_in6*>addr
+
+        err = uv.uv_ip6_name(addr6, buf, sizeof(buf))
+        if err < 0:
+            raise convert_error(err)
+
+        return (
+            PyUnicode_FromString(buf),
+            system.ntohs(addr6.sin6_port),
+            system.ntohl(addr6.sin6_flowinfo),
+            addr6.sin6_scope_id
+        )
+
+    elif addr.sa_family == uv.AF_UNIX:
+        addr_un = <system.sockaddr_un*>addr
+        return system.MakeUnixSockPyAddr(addr_un)
+
+    raise RuntimeError("cannot convert sockaddr into Python object")
+
+
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class SockAddrHolder:
+    cdef:
+        int family
+        system.sockaddr_storage addr
+        Py_ssize_t addr_size
+
+
+cdef LruCache sockaddrs = LruCache(maxsize=DNS_PYADDR_TO_SOCKADDR_CACHE_SIZE)
+
+
+cdef __convert_pyaddr_to_sockaddr(int family, object addr,
+                                  system.sockaddr* res):
+    cdef:
+        int err
+        int addr_len
+        int scope_id = 0
+        int flowinfo = 0
+        char *buf
+        Py_ssize_t buflen
+        SockAddrHolder ret
+
+    ret = sockaddrs.get(addr, None)
+    if ret is not None and ret.family == family:
+        memcpy(res, &ret.addr, ret.addr_size)
+        return
+
+    ret = SockAddrHolder.__new__(SockAddrHolder)
+    if family == uv.AF_INET:
+        if not isinstance(addr, tuple):
+            raise TypeError('AF_INET address must be tuple')
+        if len(addr) != 2:
+            raise ValueError('AF_INET address must be tuple of (host, port)')
+        host, port = addr
+        if isinstance(host, str):
+            try:
+                # idna codec is rather slow, so we try ascii first.
+                host = host.encode('ascii')
+            except UnicodeEncodeError:
+                host = host.encode('idna')
+        if not isinstance(host, (bytes, bytearray)):
+            raise TypeError('host must be a string or bytes object')
+
+        port = __port_to_int(port, None)
+
+        ret.addr_size = sizeof(system.sockaddr_in)
+        err = uv.uv_ip4_addr(host, <int>port, <system.sockaddr_in*>&ret.addr)
+        if err < 0:
+            raise convert_error(err)
+
+    elif family == uv.AF_INET6:
+        if not isinstance(addr, tuple):
+            raise TypeError('AF_INET6 address must be tuple')
+
+        addr_len = len(addr)
+        if addr_len < 2 or addr_len > 4:
+            raise ValueError(
+                'AF_INET6 must be a tuple of 2-4 parameters: '
+                '(host, port, flowinfo?, scope_id?)')
+
+        host = addr[0]
+        if isinstance(host, str):
+            try:
+                # idna codec is rather slow, so we try ascii first.
+                host = host.encode('ascii')
+            except UnicodeEncodeError:
+                host = host.encode('idna')
+        if not isinstance(host, (bytes, bytearray)):
+            raise TypeError('host must be a string or bytes object')
+
+        port = __port_to_int(addr[1], None)
+
+        if addr_len > 2:
+            flowinfo = addr[2]
+        if addr_len > 3:
+            scope_id = addr[3]
+
+        ret.addr_size = sizeof(system.sockaddr_in6)
+
+        err = uv.uv_ip6_addr(host, port, <system.sockaddr_in6*>&ret.addr)
+        if err < 0:
+            raise convert_error(err)
+
+        (<system.sockaddr_in6*>&ret.addr).sin6_flowinfo = flowinfo
+        (<system.sockaddr_in6*>&ret.addr).sin6_scope_id = scope_id
+
+    elif family == uv.AF_UNIX:
+        if isinstance(addr, str):
+            addr = addr.encode(sys_getfilesystemencoding())
+        elif not isinstance(addr, bytes):
+            raise TypeError('AF_UNIX address must be a str or a bytes object')
+
+        PyBytes_AsStringAndSize(addr, &buf, &buflen)
+        if buflen > 107:
+            raise ValueError(
+                f'unix socket path {addr!r} is longer than 107 characters')
+
+        ret.addr_size = sizeof(system.sockaddr_un)
+        memset(&ret.addr, 0, sizeof(system.sockaddr_un))
+        (<system.sockaddr_un*>&ret.addr).sun_family = uv.AF_UNIX
+        memcpy((<system.sockaddr_un*>&ret.addr).sun_path, buf, buflen)
+
+    else:
+        raise ValueError(
+            f'expected AF_INET, AF_INET6, or AF_UNIX family, got {family}')
+
+    ret.family = family
+    sockaddrs[addr] = ret
+    memcpy(res, &ret.addr, ret.addr_size)
+
+
+cdef __static_getaddrinfo(object host, object port,
+                          int family, int type,
+                          int proto,
+                          system.sockaddr *addr):
+
+    if proto not in {0, uv.IPPROTO_TCP, uv.IPPROTO_UDP}:
+        return
+
+    if _is_sock_stream(type):
+        proto = uv.IPPROTO_TCP
+    elif _is_sock_dgram(type):
+        proto = uv.IPPROTO_UDP
+    else:
+        return
+
+    try:
+        port = __port_to_int(port, proto)
+    except Exception:
+        return
+
+    hp = (host, port)
+    if family == uv.AF_UNSPEC:
+        try:
+            __convert_pyaddr_to_sockaddr(uv.AF_INET, hp, addr)
+        except Exception:
+            pass
+        else:
+            return (uv.AF_INET, type, proto)
+
+        try:
+            __convert_pyaddr_to_sockaddr(uv.AF_INET6, hp, addr)
+        except Exception:
+            pass
+        else:
+            return (uv.AF_INET6, type, proto)
+
+    else:
+        try:
+            __convert_pyaddr_to_sockaddr(family, hp, addr)
+        except Exception:
+            pass
+        else:
+            return (family, type, proto)
+
+
+cdef __static_getaddrinfo_pyaddr(object host, object port,
+                                 int family, int type,
+                                 int proto, int flags):
+
+    cdef:
+        system.sockaddr_storage addr
+        object triplet
+
+    triplet = __static_getaddrinfo(
+        host, port, family, type,
+        proto, <system.sockaddr*>&addr)
+    if triplet is None:
+        return
+
+    af, type, proto = triplet
+
+    try:
+        pyaddr = __convert_sockaddr_to_pyaddr(<system.sockaddr*>&addr)
+    except Exception:
+        return
+
+    return af, type, proto, '', pyaddr
+
+
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class AddrInfo:
+    cdef:
+        system.addrinfo *data
+
+    def __cinit__(self):
+        self.data = NULL
+
+    def __dealloc__(self):
+        if self.data is not NULL:
+            uv.uv_freeaddrinfo(self.data)  # returns void
+            self.data = NULL
+
+    cdef void set_data(self, system.addrinfo *data):
+        self.data = data
+
+    cdef unpack(self):
+        cdef:
+            list result = []
+            system.addrinfo *ptr
+
+        if self.data is NULL:
+            raise RuntimeError('AddrInfo.data is NULL')
+
+        ptr = self.data
+        while ptr != NULL:
+            if ptr.ai_addr.sa_family in (uv.AF_INET, uv.AF_INET6):
+                result.append((
+                    ptr.ai_family,
+                    ptr.ai_socktype,
+                    ptr.ai_protocol,
+                    ('' if ptr.ai_canonname is NULL else
+                        (<bytes>ptr.ai_canonname).decode()),
+                    __convert_sockaddr_to_pyaddr(ptr.ai_addr)
+                ))
+
+            ptr = ptr.ai_next
+
+        return result
+
+    @staticmethod
+    cdef int isinstance(object other):
+        return type(other) is AddrInfo
+
+
+cdef class AddrInfoRequest(UVRequest):
+    cdef:
+        system.addrinfo hints
+        object callback
+        uv.uv_getaddrinfo_t _req_data
+
+    def __cinit__(self, Loop loop,
+                  bytes host, bytes port,
+                  int family, int type, int proto, int flags,
+                  object callback):
+
+        cdef:
+            int err
+            char *chost
+            char *cport
+
+        if host is None:
+            chost = NULL
+        else:
+            chost = <char*>host
+
+        if port is None:
+            cport = NULL
+        else:
+            cport = <char*>port
+
+        if cport is NULL and chost is NULL:
+            self.on_done()
+            msg = system.gai_strerror(socket_EAI_NONAME).decode('utf-8')
+            ex = socket_gaierror(socket_EAI_NONAME, msg)
+            callback(ex)
+            return
+
+        memset(&self.hints, 0, sizeof(system.addrinfo))
+        self.hints.ai_flags = flags
+        self.hints.ai_family = family
+        self.hints.ai_socktype = type
+        self.hints.ai_protocol = proto
+
+        self.request = <uv.uv_req_t*> &self._req_data
+        self.callback = callback
+        self.request.data = <void*>self
+
+        err = uv.uv_getaddrinfo(loop.uvloop,
+                                <uv.uv_getaddrinfo_t*>self.request,
+                                __on_addrinfo_resolved,
+                                chost,
+                                cport,
+                                &self.hints)
+
+        if err < 0:
+            self.on_done()
+            callback(convert_error(err))
+
+
+cdef class NameInfoRequest(UVRequest):
+    cdef:
+        object callback
+        uv.uv_getnameinfo_t _req_data
+
+    def __cinit__(self, Loop loop, callback):
+        self.request = <uv.uv_req_t*> &self._req_data
+        self.callback = callback
+        self.request.data = <void*>self
+
+    cdef query(self, system.sockaddr *addr, int flags):
+        cdef int err
+        err = uv.uv_getnameinfo(self.loop.uvloop,
+                                <uv.uv_getnameinfo_t*>self.request,
+                                __on_nameinfo_resolved,
+                                addr,
+                                flags)
+        if err < 0:
+            self.on_done()
+            self.callback(convert_error(err))
+
+
+cdef void __on_addrinfo_resolved(uv.uv_getaddrinfo_t *resolver,
+                                 int status, system.addrinfo *res) with gil:
+
+    if resolver.data is NULL:
+        aio_logger.error(
+            'AddrInfoRequest callback called with NULL resolver.data')
+        return
+
+    cdef:
+        AddrInfoRequest request = <AddrInfoRequest> resolver.data
+        Loop loop = request.loop
+        object callback = request.callback
+        AddrInfo ai
+
+    try:
+        if status < 0:
+            callback(convert_error(status))
+        else:
+            ai = AddrInfo()
+            ai.set_data(res)
+            callback(ai)
+    except (KeyboardInterrupt, SystemExit):
+        raise
+    except BaseException as ex:
+        loop._handle_exception(ex)
+    finally:
+        request.on_done()
+
+
+cdef void __on_nameinfo_resolved(uv.uv_getnameinfo_t* req,
+                                 int status,
+                                 const char* hostname,
+                                 const char* service) with gil:
+    cdef:
+        NameInfoRequest request = <NameInfoRequest> req.data
+        Loop loop = request.loop
+        object callback = request.callback
+
+    try:
+        if status < 0:
+            callback(convert_error(status))
+        else:
+            callback(((<bytes>hostname).decode(),
+                      (<bytes>service).decode()))
+    except (KeyboardInterrupt, SystemExit):
+        raise
+    except BaseException as ex:
+        loop._handle_exception(ex)
+    finally:
+        request.on_done()
diff --git a/myenv/lib/python3.9/site-packages/uvloop/errors.pyx b/myenv/lib/python3.9/site-packages/uvloop/errors.pyx
new file mode 100644
index 0000000..d810d65
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/errors.pyx
@@ -0,0 +1,113 @@
+cdef str __strerr(int errno):
+    return strerror(errno).decode()
+
+
+cdef __convert_python_error(int uverr):
+    # XXX Won't work for Windows:
+    # From libuv docs:
+    #      Implementation detail: on Unix error codes are the
+    #      negated errno (or -errno), while on Windows they
+    #      are defined by libuv to arbitrary negative numbers.
+    cdef int oserr = -uverr
+
+    exc = OSError
+
+    if uverr in (uv.UV_EACCES, uv.UV_EPERM):
+        exc = PermissionError
+
+    elif uverr in (uv.UV_EAGAIN, uv.UV_EALREADY):
+        exc = BlockingIOError
+
+    elif uverr in (uv.UV_EPIPE, uv.UV_ESHUTDOWN):
+        exc = BrokenPipeError
+
+    elif uverr == uv.UV_ECONNABORTED:
+        exc = ConnectionAbortedError
+
+    elif uverr == uv.UV_ECONNREFUSED:
+        exc = ConnectionRefusedError
+
+    elif uverr == uv.UV_ECONNRESET:
+        exc = ConnectionResetError
+
+    elif uverr == uv.UV_EEXIST:
+        exc = FileExistsError
+
+    elif uverr == uv.UV_ENOENT:
+        exc = FileNotFoundError
+
+    elif uverr == uv.UV_EINTR:
+        exc = InterruptedError
+
+    elif uverr == uv.UV_EISDIR:
+        exc = IsADirectoryError
+
+    elif uverr == uv.UV_ESRCH:
+        exc = ProcessLookupError
+
+    elif uverr == uv.UV_ETIMEDOUT:
+        exc = TimeoutError
+
+    return exc(oserr, __strerr(oserr))
+
+
+cdef int __convert_socket_error(int uverr):
+    cdef int sock_err = 0
+
+    if uverr == uv.UV_EAI_ADDRFAMILY:
+        sock_err = socket_EAI_ADDRFAMILY
+
+    elif uverr == uv.UV_EAI_AGAIN:
+        sock_err = socket_EAI_AGAIN
+
+    elif uverr == uv.UV_EAI_BADFLAGS:
+        sock_err = socket_EAI_BADFLAGS
+
+    elif uverr == uv.UV_EAI_BADHINTS:
+        sock_err = socket_EAI_BADHINTS
+
+    elif uverr == uv.UV_EAI_CANCELED:
+        sock_err = socket_EAI_CANCELED
+
+    elif uverr == uv.UV_EAI_FAIL:
+        sock_err = socket_EAI_FAIL
+
+    elif uverr == uv.UV_EAI_FAMILY:
+        sock_err = socket_EAI_FAMILY
+
+    elif uverr == uv.UV_EAI_MEMORY:
+        sock_err = socket_EAI_MEMORY
+
+    elif uverr == uv.UV_EAI_NODATA:
+        sock_err = socket_EAI_NODATA
+
+    elif uverr == uv.UV_EAI_NONAME:
+        sock_err = socket_EAI_NONAME
+
+    elif uverr == uv.UV_EAI_OVERFLOW:
+        sock_err = socket_EAI_OVERFLOW
+
+    elif uverr == uv.UV_EAI_PROTOCOL:
+        sock_err = socket_EAI_PROTOCOL
+
+    elif uverr == uv.UV_EAI_SERVICE:
+        sock_err = socket_EAI_SERVICE
+
+    elif uverr == uv.UV_EAI_SOCKTYPE:
+        sock_err = socket_EAI_SOCKTYPE
+
+    return sock_err
+
+
+cdef convert_error(int uverr):
+    cdef int sock_err
+
+    if uverr == uv.UV_ECANCELED:
+        return aio_CancelledError()
+
+    sock_err = __convert_socket_error(uverr)
+    if sock_err:
+        msg = system.gai_strerror(sock_err).decode('utf-8')
+        return socket_gaierror(sock_err, msg)
+
+    return __convert_python_error(uverr)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/async_.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/async_.pxd
new file mode 100644
index 0000000..5f0d820
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/async_.pxd
@@ -0,0 +1,11 @@
+cdef class UVAsync(UVHandle):
+    cdef:
+        method_t callback
+        object ctx
+
+    cdef _init(self, Loop loop, method_t callback, object ctx)
+
+    cdef send(self)
+
+    @staticmethod
+    cdef UVAsync new(Loop loop, method_t callback, object ctx)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/async_.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/async_.pyx
new file mode 100644
index 0000000..7c84389
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/async_.pyx
@@ -0,0 +1,54 @@
+@cython.no_gc_clear
+cdef class UVAsync(UVHandle):
+    cdef _init(self, Loop loop, method_t callback, object ctx):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_async_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_async_init(self._loop.uvloop,
+                               <uv.uv_async_t*>self._handle,
+                               __uvasync_callback)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.callback = callback
+        self.ctx = ctx
+
+    cdef send(self):
+        cdef int err
+
+        self._ensure_alive()
+
+        err = uv.uv_async_send(<uv.uv_async_t*>self._handle)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+    @staticmethod
+    cdef UVAsync new(Loop loop, method_t callback, object ctx):
+        cdef UVAsync handle
+        handle = UVAsync.__new__(UVAsync)
+        handle._init(loop, callback, ctx)
+        return handle
+
+
+cdef void __uvasync_callback(uv.uv_async_t* handle) with gil:
+    if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVAsync callback") == 0:
+        return
+
+    cdef:
+        UVAsync async_ = <UVAsync> handle.data
+        method_t cb = async_.callback
+    try:
+        cb(async_.ctx)
+    except BaseException as ex:
+        async_._error(ex, False)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/basetransport.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/basetransport.pxd
new file mode 100644
index 0000000..ba356a7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/basetransport.pxd
@@ -0,0 +1,54 @@
+cdef class UVBaseTransport(UVSocketHandle):
+
+    cdef:
+        readonly bint _closing
+
+        bint _protocol_connected
+        bint _protocol_paused
+        object _protocol_data_received
+        size_t _high_water
+        size_t _low_water
+
+        object _protocol
+        Server _server
+        object _waiter
+
+        dict _extra_info
+
+        uint32_t _conn_lost
+
+        object __weakref__
+
+    # All "inline" methods are final
+
+    cdef inline _maybe_pause_protocol(self)
+    cdef inline _maybe_resume_protocol(self)
+
+    cdef inline _schedule_call_connection_made(self)
+    cdef inline _schedule_call_connection_lost(self, exc)
+
+    cdef _wakeup_waiter(self)
+    cdef _call_connection_made(self)
+    cdef _call_connection_lost(self, exc)
+
+    # Overloads of UVHandle methods:
+    cdef _fatal_error(self, exc, throw, reason=?)
+    cdef _close(self)
+
+    cdef inline _set_server(self, Server server)
+    cdef inline _set_waiter(self, object waiter)
+
+    cdef _set_protocol(self, object protocol)
+    cdef _clear_protocol(self)
+
+    cdef inline _init_protocol(self)
+    cdef inline _add_extra_info(self, str name, object obj)
+
+    # === overloads ===
+
+    cdef _new_socket(self)
+    cdef size_t _get_write_buffer_size(self)
+
+    cdef bint _is_reading(self)
+    cdef _start_reading(self)
+    cdef _stop_reading(self)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/basetransport.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/basetransport.pyx
new file mode 100644
index 0000000..28b3079
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/basetransport.pyx
@@ -0,0 +1,293 @@
+cdef class UVBaseTransport(UVSocketHandle):
+
+    def __cinit__(self):
+        # Flow control
+        self._high_water = FLOW_CONTROL_HIGH_WATER * 1024
+        self._low_water = FLOW_CONTROL_HIGH_WATER // 4
+
+        self._protocol = None
+        self._protocol_connected = 0
+        self._protocol_paused = 0
+        self._protocol_data_received = None
+
+        self._server = None
+        self._waiter = None
+        self._extra_info = None
+
+        self._conn_lost = 0
+
+        self._closing = 0
+
+    cdef size_t _get_write_buffer_size(self):
+        return 0
+
+    cdef inline _schedule_call_connection_made(self):
+        self._loop._call_soon_handle(
+            new_MethodHandle(self._loop,
+                             "UVTransport._call_connection_made",
+                             <method_t>self._call_connection_made,
+                             self.context,
+                             self))
+
+    cdef inline _schedule_call_connection_lost(self, exc):
+        self._loop._call_soon_handle(
+            new_MethodHandle1(self._loop,
+                              "UVTransport._call_connection_lost",
+                              <method1_t>self._call_connection_lost,
+                              self.context,
+                              self, exc))
+
+    cdef _fatal_error(self, exc, throw, reason=None):
+        # Overload UVHandle._fatal_error
+
+        self._force_close(exc)
+
+        if not isinstance(exc, OSError):
+
+            if throw or self._loop is None:
+                raise exc
+
+            msg = f'Fatal error on transport {self.__class__.__name__}'
+            if reason is not None:
+                msg = f'{msg} ({reason})'
+
+            self._loop.call_exception_handler({
+                'message': msg,
+                'exception': exc,
+                'transport': self,
+                'protocol': self._protocol,
+            })
+
+    cdef inline _maybe_pause_protocol(self):
+        cdef:
+            size_t size = self._get_write_buffer_size()
+
+        if size <= self._high_water:
+            return
+
+        if not self._protocol_paused:
+            self._protocol_paused = 1
+            try:
+                # _maybe_pause_protocol() is always triggered from user-calls,
+                # so we must copy the context to avoid entering context twice
+                run_in_context(
+                    self.context.copy(), self._protocol.pause_writing,
+                )
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as exc:
+                self._loop.call_exception_handler({
+                    'message': 'protocol.pause_writing() failed',
+                    'exception': exc,
+                    'transport': self,
+                    'protocol': self._protocol,
+                })
+
+    cdef inline _maybe_resume_protocol(self):
+        cdef:
+            size_t size = self._get_write_buffer_size()
+
+        if self._protocol_paused and size <= self._low_water:
+            self._protocol_paused = 0
+            try:
+                # We're copying the context to avoid entering context twice,
+                # even though it's not always necessary to copy - it's easier
+                # to copy here than passing down a copied context.
+                run_in_context(
+                    self.context.copy(), self._protocol.resume_writing,
+                )
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as exc:
+                self._loop.call_exception_handler({
+                    'message': 'protocol.resume_writing() failed',
+                    'exception': exc,
+                    'transport': self,
+                    'protocol': self._protocol,
+                })
+
+    cdef _wakeup_waiter(self):
+        if self._waiter is not None:
+            if not self._waiter.cancelled():
+                if not self._is_alive():
+                    self._waiter.set_exception(
+                        RuntimeError(
+                            'closed Transport handle and unset waiter'))
+                else:
+                    self._waiter.set_result(True)
+            self._waiter = None
+
+    cdef _call_connection_made(self):
+        if self._protocol is None:
+            raise RuntimeError(
+                'protocol is not set, cannot call connection_made()')
+
+        # We use `_is_alive()` and not `_closing`, because we call
+        # `transport._close()` in `loop.create_connection()` if an
+        # exception happens during `await waiter`.
+        if not self._is_alive():
+            # A connection waiter can be cancelled between
+            # 'await loop.create_connection()' and
+            # `_schedule_call_connection_made` and
+            # the actual `_call_connection_made`.
+            self._wakeup_waiter()
+            return
+
+        # Set _protocol_connected to 1 before calling "connection_made":
+        # if transport is aborted or closed, "connection_lost" will
+        # still be scheduled.
+        self._protocol_connected = 1
+
+        try:
+            self._protocol.connection_made(self)
+        except BaseException:
+            self._wakeup_waiter()
+            raise
+
+        if not self._is_alive():
+            # This might happen when "transport.abort()" is called
+            # from "Protocol.connection_made".
+            self._wakeup_waiter()
+            return
+
+        self._start_reading()
+        self._wakeup_waiter()
+
+    cdef _call_connection_lost(self, exc):
+        if self._waiter is not None:
+            if not self._waiter.done():
+                self._waiter.set_exception(exc)
+            self._waiter = None
+
+        if self._closed:
+            # The handle is closed -- likely, _call_connection_lost
+            # was already called before.
+            return
+
+        try:
+            if self._protocol_connected:
+                self._protocol.connection_lost(exc)
+        finally:
+            self._clear_protocol()
+
+            self._close()
+
+            server = self._server
+            if server is not None:
+                (<Server>server)._detach()
+                self._server = None
+
+    cdef inline _set_server(self, Server server):
+        self._server = server
+        (<Server>server)._attach()
+
+    cdef inline _set_waiter(self, object waiter):
+        if waiter is not None and not isfuture(waiter):
+            raise TypeError(
+                f'invalid waiter object {waiter!r}, expected asyncio.Future')
+
+        self._waiter = waiter
+
+    cdef _set_protocol(self, object protocol):
+        self._protocol = protocol
+        # Store a reference to the bound method directly
+        try:
+            self._protocol_data_received = protocol.data_received
+        except AttributeError:
+            pass
+
+    cdef _clear_protocol(self):
+        self._protocol = None
+        self._protocol_data_received = None
+
+    cdef inline _init_protocol(self):
+        self._loop._track_transport(self)
+        if self._protocol is None:
+            raise RuntimeError('invalid _init_protocol call')
+        self._schedule_call_connection_made()
+
+    cdef inline _add_extra_info(self, str name, object obj):
+        if self._extra_info is None:
+            self._extra_info = {}
+        self._extra_info[name] = obj
+
+    cdef bint _is_reading(self):
+        raise NotImplementedError
+
+    cdef _start_reading(self):
+        raise NotImplementedError
+
+    cdef _stop_reading(self):
+        raise NotImplementedError
+
+    # === Public API ===
+
+    property _paused:
+        # Used by SSLProto.  Might be removed in the future.
+        def __get__(self):
+            return bool(not self._is_reading())
+
+    def get_protocol(self):
+        return self._protocol
+
+    def set_protocol(self, protocol):
+        self._set_protocol(protocol)
+        if self._is_reading():
+            self._stop_reading()
+            self._start_reading()
+
+    def _force_close(self, exc):
+        # Used by SSLProto.  Might be removed in the future.
+        if self._conn_lost or self._closed:
+            return
+        if not self._closing:
+            self._closing = 1
+            self._stop_reading()
+        self._conn_lost += 1
+        self._schedule_call_connection_lost(exc)
+
+    def abort(self):
+        self._force_close(None)
+
+    def close(self):
+        if self._closing or self._closed:
+            return
+
+        self._closing = 1
+        self._stop_reading()
+
+        if not self._get_write_buffer_size():
+            # The write buffer is empty
+            self._conn_lost += 1
+            self._schedule_call_connection_lost(None)
+
+    def is_closing(self):
+        return self._closing
+
+    def get_write_buffer_size(self):
+        return self._get_write_buffer_size()
+
+    def set_write_buffer_limits(self, high=None, low=None):
+        self._ensure_alive()
+
+        self._high_water, self._low_water = add_flowcontrol_defaults(
+            high, low, FLOW_CONTROL_HIGH_WATER)
+
+        self._maybe_pause_protocol()
+
+    def get_write_buffer_limits(self):
+        return (self._low_water, self._high_water)
+
+    def get_extra_info(self, name, default=None):
+        if self._extra_info is not None and name in self._extra_info:
+            return self._extra_info[name]
+        if name == 'socket':
+            return self._get_socket()
+        if name == 'sockname':
+            return self._get_socket().getsockname()
+        if name == 'peername':
+            try:
+                return self._get_socket().getpeername()
+            except socket_error:
+                return default
+        return default
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/check.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/check.pxd
new file mode 100644
index 0000000..86cfd8f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/check.pxd
@@ -0,0 +1,14 @@
+cdef class UVCheck(UVHandle):
+    cdef:
+        Handle h
+        bint running
+
+    # All "inline" methods are final
+
+    cdef _init(self, Loop loop, Handle h)
+
+    cdef inline stop(self)
+    cdef inline start(self)
+
+    @staticmethod
+    cdef UVCheck new(Loop loop, Handle h)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/check.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/check.pyx
new file mode 100644
index 0000000..a8d6f92
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/check.pyx
@@ -0,0 +1,70 @@
+@cython.no_gc_clear
+cdef class UVCheck(UVHandle):
+    cdef _init(self, Loop loop, Handle h):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_check_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_check_init(self._loop.uvloop, <uv.uv_check_t*>self._handle)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.h = h
+        self.running = 0
+
+    cdef inline stop(self):
+        cdef int err
+
+        if not self._is_alive():
+            self.running = 0
+            return
+
+        if self.running == 1:
+            err = uv.uv_check_stop(<uv.uv_check_t*>self._handle)
+            self.running = 0
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+
+    cdef inline start(self):
+        cdef int err
+
+        self._ensure_alive()
+
+        if self.running == 0:
+            err = uv.uv_check_start(<uv.uv_check_t*>self._handle,
+                                    cb_check_callback)
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+            self.running = 1
+
+    @staticmethod
+    cdef UVCheck new(Loop loop, Handle h):
+        cdef UVCheck handle
+        handle = UVCheck.__new__(UVCheck)
+        handle._init(loop, h)
+        return handle
+
+
+cdef void cb_check_callback(uv.uv_check_t* handle) with gil:
+    if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVCheck callback") == 0:
+        return
+
+    cdef:
+        UVCheck check = <UVCheck> handle.data
+        Handle h = check.h
+    try:
+        h._run()
+    except BaseException as ex:
+        check._error(ex, False)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/handle.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/handle.pxd
new file mode 100644
index 0000000..5af1c14
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/handle.pxd
@@ -0,0 +1,48 @@
+cdef class UVHandle:
+    cdef:
+        uv.uv_handle_t *_handle
+        Loop _loop
+        readonly _source_traceback
+        bint _closed
+        bint _inited
+        object context
+
+        # Added to enable current UDPTransport implementation,
+        # which doesn't use libuv handles.
+        bint _has_handle
+
+    # All "inline" methods are final
+
+    cdef inline _start_init(self, Loop loop)
+    cdef inline _abort_init(self)
+    cdef inline _finish_init(self)
+
+    cdef inline bint _is_alive(self)
+    cdef inline _ensure_alive(self)
+
+    cdef _error(self, exc, throw)
+    cdef _fatal_error(self, exc, throw, reason=?)
+
+    cdef _warn_unclosed(self)
+
+    cdef _free(self)
+    cdef _close(self)
+
+
+cdef class UVSocketHandle(UVHandle):
+    cdef:
+        # Points to a Python file-object that should be closed
+        # when the transport is closing.  Used by pipes.  This
+        # should probably be refactored somehow.
+        object _fileobj
+        object __cached_socket
+
+    # All "inline" methods are final
+
+    cdef _fileno(self)
+
+    cdef _new_socket(self)
+    cdef inline _get_socket(self)
+    cdef inline _attach_fileobj(self, object file)
+
+    cdef _open(self, int sockfd)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/handle.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/handle.pyx
new file mode 100644
index 0000000..c3c691f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/handle.pyx
@@ -0,0 +1,393 @@
+cdef class UVHandle:
+    """A base class for all libuv handles.
+
+    Automatically manages memory deallocation and closing.
+
+    Important:
+
+       1. call "_ensure_alive()" before calling any libuv functions on
+          your handles.
+
+       2. call "__ensure_handle_data" in *all* libuv handle callbacks.
+    """
+
+    def __cinit__(self):
+        self._closed = 0
+        self._inited = 0
+        self._has_handle = 1
+        self._handle = NULL
+        self._loop = None
+        self._source_traceback = None
+
+    def __init__(self):
+        raise TypeError(
+            '{} is not supposed to be instantiated from Python'.format(
+                self.__class__.__name__))
+
+    def __dealloc__(self):
+        if UVLOOP_DEBUG:
+            if self._loop is not None:
+                if self._inited:
+                    self._loop._debug_handles_current.subtract([
+                        self.__class__.__name__])
+            else:
+                # No "@cython.no_gc_clear" decorator on this UVHandle
+                raise RuntimeError(
+                    '{} without @no_gc_clear; loop was set to None by GC'
+                    .format(self.__class__.__name__))
+
+        if self._handle is NULL:
+            return
+
+        # -> When we're at this point, something is wrong <-
+
+        if self._handle.loop is NULL:
+            # The handle wasn't initialized with "uv_{handle}_init"
+            self._closed = 1
+            self._free()
+            raise RuntimeError(
+                '{} is open in __dealloc__ with loop set to NULL'
+                .format(self.__class__.__name__))
+
+        if self._closed:
+            # So _handle is not NULL and self._closed == 1?
+            raise RuntimeError(
+                '{}.__dealloc__: _handle is NULL, _closed == 1'.format(
+                    self.__class__.__name__))
+
+        # The handle is dealloced while open.  Let's try to close it.
+        # Situations when this is possible include unhandled exceptions,
+        # errors during Handle.__cinit__/__init__ etc.
+        if self._inited:
+            self._handle.data = NULL
+            uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+            self._handle = NULL
+            self._warn_unclosed()
+        else:
+            # The handle was allocated, but not initialized
+            self._closed = 1
+            self._free()
+
+    cdef _free(self):
+        if self._handle == NULL:
+            return
+
+        if UVLOOP_DEBUG and self._inited:
+            self._loop._debug_uv_handles_freed += 1
+
+        PyMem_RawFree(self._handle)
+        self._handle = NULL
+
+    cdef _warn_unclosed(self):
+        if self._source_traceback is not None:
+            try:
+                tb = ''.join(tb_format_list(self._source_traceback))
+                tb = 'object created at (most recent call last):\n{}'.format(
+                    tb.rstrip())
+            except Exception as ex:
+                msg = (
+                    'unclosed resource {!r}; could not serialize '
+                    'debug traceback: {}: {}'
+                ).format(self, type(ex).__name__, ex)
+            else:
+                msg = 'unclosed resource {!r}; {}'.format(self, tb)
+        else:
+            msg = 'unclosed resource {!r}'.format(self)
+        warnings_warn(msg, ResourceWarning)
+
+    cdef inline _abort_init(self):
+        if self._handle is not NULL:
+            self._free()
+
+        try:
+            if UVLOOP_DEBUG:
+                name = self.__class__.__name__
+                if self._inited:
+                    raise RuntimeError(
+                        '_abort_init: {}._inited is set'.format(name))
+                if self._closed:
+                    raise RuntimeError(
+                        '_abort_init: {}._closed is set'.format(name))
+        finally:
+            self._closed = 1
+
+    cdef inline _finish_init(self):
+        self._inited = 1
+        if self._has_handle == 1:
+            self._handle.data = <void*>self
+        if self._loop._debug:
+            self._source_traceback = extract_stack()
+        if UVLOOP_DEBUG:
+            cls_name = self.__class__.__name__
+            self._loop._debug_uv_handles_total += 1
+            self._loop._debug_handles_total.update([cls_name])
+            self._loop._debug_handles_current.update([cls_name])
+
+    cdef inline _start_init(self, Loop loop):
+        if UVLOOP_DEBUG:
+            if self._loop is not None:
+                raise RuntimeError(
+                    '{}._start_init can only be called once'.format(
+                        self.__class__.__name__))
+
+        self._loop = loop
+
+    cdef inline bint _is_alive(self):
+        cdef bint res
+        res = self._closed != 1 and self._inited == 1
+        if UVLOOP_DEBUG:
+            if res and self._has_handle == 1:
+                name = self.__class__.__name__
+                if self._handle is NULL:
+                    raise RuntimeError(
+                        '{} is alive, but _handle is NULL'.format(name))
+                if self._loop is None:
+                    raise RuntimeError(
+                        '{} is alive, but _loop is None'.format(name))
+                if self._handle.loop is not self._loop.uvloop:
+                    raise RuntimeError(
+                        '{} is alive, but _handle.loop is not '
+                        'initialized'.format(name))
+                if self._handle.data is not <void*>self:
+                    raise RuntimeError(
+                        '{} is alive, but _handle.data is not '
+                        'initialized'.format(name))
+        return res
+
+    cdef inline _ensure_alive(self):
+        if not self._is_alive():
+            raise RuntimeError(
+                'unable to perform operation on {!r}; '
+                'the handler is closed'.format(self))
+
+    cdef _fatal_error(self, exc, throw, reason=None):
+        # Fatal error means an error that was returned by the
+        # underlying libuv handle function.  We usually can't
+        # recover from that, hence we just close the handle.
+        self._close()
+
+        if throw or self._loop is None:
+            raise exc
+        else:
+            self._loop._handle_exception(exc)
+
+    cdef _error(self, exc, throw):
+        # A non-fatal error is usually an error that was caught
+        # by the handler, but was originated in the client code
+        # (not in libuv).  In this case we either want to simply
+        # raise or log it.
+        if throw or self._loop is None:
+            raise exc
+        else:
+            self._loop._handle_exception(exc)
+
+    cdef _close(self):
+        if self._closed == 1:
+            return
+
+        self._closed = 1
+
+        if self._handle is NULL:
+            return
+
+        if UVLOOP_DEBUG:
+            if self._handle.data is NULL:
+                raise RuntimeError(
+                    '{}._close: _handle.data is NULL'.format(
+                        self.__class__.__name__))
+
+            if <object>self._handle.data is not self:
+                raise RuntimeError(
+                    '{}._close: _handle.data is not UVHandle/self'.format(
+                        self.__class__.__name__))
+
+            if uv.uv_is_closing(self._handle):
+                raise RuntimeError(
+                    '{}._close: uv_is_closing() is true'.format(
+                        self.__class__.__name__))
+
+        # We want the handle wrapper (UVHandle) to stay alive until
+        # the closing callback fires.
+        Py_INCREF(self)
+        uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+
+    def __repr__(self):
+        return '<{} closed={} {:#x}>'.format(
+            self.__class__.__name__,
+            self._closed,
+            id(self))
+
+
+cdef class UVSocketHandle(UVHandle):
+
+    def __cinit__(self):
+        self._fileobj = None
+        self.__cached_socket = None
+
+    cdef _fileno(self):
+        cdef:
+            int fd
+            int err
+
+        self._ensure_alive()
+        err = uv.uv_fileno(self._handle, <uv.uv_os_fd_t*>&fd)
+        if err < 0:
+            raise convert_error(err)
+
+        return fd
+
+    cdef _new_socket(self):
+        raise NotImplementedError
+
+    cdef inline _get_socket(self):
+        if self.__cached_socket is not None:
+            return self.__cached_socket
+
+        if not self._is_alive():
+            return None
+
+        self.__cached_socket = self._new_socket()
+        if UVLOOP_DEBUG:
+            # We don't "dup" for the "__cached_socket".
+            assert self.__cached_socket.fileno() == self._fileno()
+        return self.__cached_socket
+
+    cdef inline _attach_fileobj(self, object file):
+        # When we create a TCP/PIPE/etc connection/server based on
+        # a Python file object, we need to close the file object when
+        # the uv handle is closed.
+        socket_inc_io_ref(file)
+        self._fileobj = file
+
+    cdef _close(self):
+        if self.__cached_socket is not None:
+            (<PseudoSocket>self.__cached_socket)._fd = -1
+
+        UVHandle._close(self)
+
+        try:
+            # This code will only run for transports created from
+            # Python sockets, i.e. with `loop.create_server(sock=sock)` etc.
+            if self._fileobj is not None:
+                if isinstance(self._fileobj, socket_socket):
+                    # Detaching the socket object is the ideal solution:
+                    # * libuv will actually close the FD;
+                    # * detach() call will reset FD for the Python socket
+                    #   object, which means that it won't be closed 2nd time
+                    #   when the socket object is GCed.
+                    #
+                    # No need to call `socket_dec_io_ref()`, as
+                    # `socket.detach()` ignores `socket._io_refs`.
+                    self._fileobj.detach()
+                else:
+                    try:
+                        # `socket.close()` will raise an EBADF because libuv
+                        # has already closed the underlying FD.
+                        self._fileobj.close()
+                    except OSError as ex:
+                        if ex.errno != errno_EBADF:
+                            raise
+        except Exception as ex:
+            self._loop.call_exception_handler({
+                'exception': ex,
+                'transport': self,
+                'message': f'could not close attached file object '
+                           f'{self._fileobj!r}',
+            })
+        finally:
+            self._fileobj = None
+
+    cdef _open(self, int sockfd):
+        raise NotImplementedError
+
+
+cdef inline bint __ensure_handle_data(uv.uv_handle_t* handle,
+                                      const char* handle_ctx):
+
+    cdef Loop loop
+
+    if UVLOOP_DEBUG:
+        if handle.loop is NULL:
+            raise RuntimeError(
+                'handle.loop is NULL in __ensure_handle_data')
+
+        if handle.loop.data is NULL:
+            raise RuntimeError(
+                'handle.loop.data is NULL in __ensure_handle_data')
+
+    if handle.data is NULL:
+        loop = <Loop>handle.loop.data
+        loop.call_exception_handler({
+            'message': '{} called with handle.data == NULL'.format(
+                handle_ctx.decode('latin-1'))
+        })
+        return 0
+
+    if handle.data is NULL:
+        # The underlying UVHandle object was GCed with an open uv_handle_t.
+        loop = <Loop>handle.loop.data
+        loop.call_exception_handler({
+            'message': '{} called after destroying the UVHandle'.format(
+                handle_ctx.decode('latin-1'))
+        })
+        return 0
+
+    return 1
+
+
+cdef void __uv_close_handle_cb(uv.uv_handle_t* handle) with gil:
+    cdef UVHandle h
+
+    if handle.data is NULL:
+        # The original UVHandle is long dead. Just free the mem of
+        # the uv_handle_t* handler.
+
+        if UVLOOP_DEBUG:
+            if handle.loop == NULL or handle.loop.data == NULL:
+                raise RuntimeError(
+                    '__uv_close_handle_cb: handle.loop is invalid')
+            (<Loop>handle.loop.data)._debug_uv_handles_freed += 1
+
+        PyMem_RawFree(handle)
+    else:
+        h = <UVHandle>handle.data
+        try:
+            if UVLOOP_DEBUG:
+                if not h._has_handle:
+                    raise RuntimeError(
+                        'has_handle=0 in __uv_close_handle_cb')
+                h._loop._debug_handles_closed.update([
+                    h.__class__.__name__])
+            h._free()
+        finally:
+            Py_DECREF(h)  # Was INCREFed in UVHandle._close
+
+
+cdef void __close_all_handles(Loop loop):
+    uv.uv_walk(loop.uvloop,
+               __uv_walk_close_all_handles_cb,
+               <void*>loop)  # void
+
+
+cdef void __uv_walk_close_all_handles_cb(
+        uv.uv_handle_t* handle, void* arg) with gil:
+
+    cdef:
+        Loop loop = <Loop>arg
+        UVHandle h
+
+    if uv.uv_is_closing(handle):
+        # The handle is closed or is closing.
+        return
+
+    if handle.data is NULL:
+        # This shouldn't happen. Ever.
+        loop.call_exception_handler({
+            'message': 'handle.data is NULL in __close_all_handles_cb'
+        })
+        return
+
+    h = <UVHandle>handle.data
+    if not h._closed:
+        h._warn_unclosed()
+        h._close()
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/idle.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/idle.pxd
new file mode 100644
index 0000000..cf7b19f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/idle.pxd
@@ -0,0 +1,14 @@
+cdef class UVIdle(UVHandle):
+    cdef:
+        Handle h
+        bint running
+
+    # All "inline" methods are final
+
+    cdef _init(self, Loop loop, Handle h)
+
+    cdef inline stop(self)
+    cdef inline start(self)
+
+    @staticmethod
+    cdef UVIdle new(Loop loop, Handle h)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/idle.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/idle.pyx
new file mode 100644
index 0000000..ca78219
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/idle.pyx
@@ -0,0 +1,70 @@
+@cython.no_gc_clear
+cdef class UVIdle(UVHandle):
+    cdef _init(self, Loop loop, Handle h):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_idle_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_idle_init(self._loop.uvloop, <uv.uv_idle_t*>self._handle)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.h = h
+        self.running = 0
+
+    cdef inline stop(self):
+        cdef int err
+
+        if not self._is_alive():
+            self.running = 0
+            return
+
+        if self.running == 1:
+            err = uv.uv_idle_stop(<uv.uv_idle_t*>self._handle)
+            self.running = 0
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+
+    cdef inline start(self):
+        cdef int err
+
+        self._ensure_alive()
+
+        if self.running == 0:
+            err = uv.uv_idle_start(<uv.uv_idle_t*>self._handle,
+                                   cb_idle_callback)
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+            self.running = 1
+
+    @staticmethod
+    cdef UVIdle new(Loop loop, Handle h):
+        cdef UVIdle handle
+        handle = UVIdle.__new__(UVIdle)
+        handle._init(loop, h)
+        return handle
+
+
+cdef void cb_idle_callback(uv.uv_idle_t* handle) with gil:
+    if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVIdle callback") == 0:
+        return
+
+    cdef:
+        UVIdle idle = <UVIdle> handle.data
+        Handle h = idle.h
+    try:
+        h._run()
+    except BaseException as ex:
+        idle._error(ex, False)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/pipe.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/pipe.pxd
new file mode 100644
index 0000000..56fc265
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/pipe.pxd
@@ -0,0 +1,33 @@
+cdef class UnixServer(UVStreamServer):
+
+    cdef bind(self, str path)
+
+    @staticmethod
+    cdef UnixServer new(Loop loop, object protocol_factory, Server server,
+                        object backlog,
+                        object ssl,
+                        object ssl_handshake_timeout,
+                        object ssl_shutdown_timeout)
+
+
+cdef class UnixTransport(UVStream):
+
+    @staticmethod
+    cdef UnixTransport new(Loop loop, object protocol, Server server,
+                           object waiter, object context)
+
+    cdef connect(self, char* addr)
+
+
+cdef class ReadUnixTransport(UVStream):
+
+    @staticmethod
+    cdef ReadUnixTransport new(Loop loop, object protocol, Server server,
+                               object waiter)
+
+
+cdef class WriteUnixTransport(UVStream):
+
+    @staticmethod
+    cdef WriteUnixTransport new(Loop loop, object protocol, Server server,
+                                object waiter)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/pipe.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/pipe.pyx
new file mode 100644
index 0000000..19dc3bd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/pipe.pyx
@@ -0,0 +1,223 @@
+cdef __pipe_init_uv_handle(UVStream handle, Loop loop):
+    cdef int err
+
+    handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_pipe_t))
+    if handle._handle is NULL:
+        handle._abort_init()
+        raise MemoryError()
+
+    # Initialize pipe handle with ipc=0.
+    # ipc=1 means that libuv will use recvmsg/sendmsg
+    # instead of recv/send.
+    err = uv.uv_pipe_init(handle._loop.uvloop,
+                          <uv.uv_pipe_t*>handle._handle,
+                          0)
+    # UV_HANDLE_READABLE allows calling uv_read_start() on this pipe
+    # even if it is O_WRONLY, see also #317, libuv/libuv#2058
+    handle._handle.flags |= uv.UV_INTERNAL_HANDLE_READABLE
+    if err < 0:
+        handle._abort_init()
+        raise convert_error(err)
+
+    handle._finish_init()
+
+
+cdef __pipe_open(UVStream handle, int fd):
+    cdef int err
+    err = uv.uv_pipe_open(<uv.uv_pipe_t *>handle._handle,
+                          <uv.uv_file>fd)
+    if err < 0:
+        exc = convert_error(err)
+        raise exc
+
+
+cdef __pipe_get_socket(UVSocketHandle handle):
+    fileno = handle._fileno()
+    return PseudoSocket(uv.AF_UNIX, uv.SOCK_STREAM, 0, fileno)
+
+
+@cython.no_gc_clear
+cdef class UnixServer(UVStreamServer):
+
+    @staticmethod
+    cdef UnixServer new(Loop loop, object protocol_factory, Server server,
+                        object backlog,
+                        object ssl,
+                        object ssl_handshake_timeout,
+                        object ssl_shutdown_timeout):
+
+        cdef UnixServer handle
+        handle = UnixServer.__new__(UnixServer)
+        handle._init(loop, protocol_factory, server, backlog,
+                     ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+        __pipe_init_uv_handle(<UVStream>handle, loop)
+        return handle
+
+    cdef _new_socket(self):
+        return __pipe_get_socket(<UVSocketHandle>self)
+
+    cdef _open(self, int sockfd):
+        self._ensure_alive()
+        __pipe_open(<UVStream>self, sockfd)
+        self._mark_as_open()
+
+    cdef bind(self, str path):
+        cdef int err
+        self._ensure_alive()
+        err = uv.uv_pipe_bind(<uv.uv_pipe_t *>self._handle,
+                              path.encode())
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+        self._mark_as_open()
+
+    cdef UVStream _make_new_transport(self, object protocol, object waiter,
+                                      object context):
+        cdef UnixTransport tr
+        tr = UnixTransport.new(self._loop, protocol, self._server, waiter,
+                               context)
+        return <UVStream>tr
+
+
+@cython.no_gc_clear
+cdef class UnixTransport(UVStream):
+
+    @staticmethod
+    cdef UnixTransport new(Loop loop, object protocol, Server server,
+                           object waiter, object context):
+
+        cdef UnixTransport handle
+        handle = UnixTransport.__new__(UnixTransport)
+        handle._init(loop, protocol, server, waiter, context)
+        __pipe_init_uv_handle(<UVStream>handle, loop)
+        return handle
+
+    cdef _new_socket(self):
+        return __pipe_get_socket(<UVSocketHandle>self)
+
+    cdef _open(self, int sockfd):
+        __pipe_open(<UVStream>self, sockfd)
+
+    cdef connect(self, char* addr):
+        cdef _PipeConnectRequest req
+        req = _PipeConnectRequest(self._loop, self)
+        req.connect(addr)
+
+
+@cython.no_gc_clear
+cdef class ReadUnixTransport(UVStream):
+
+    @staticmethod
+    cdef ReadUnixTransport new(Loop loop, object protocol, Server server,
+                               object waiter):
+        cdef ReadUnixTransport handle
+        handle = ReadUnixTransport.__new__(ReadUnixTransport)
+        # This is only used in connect_read_pipe() and subprocess_shell/exec()
+        # directly, we could simply copy the current context.
+        handle._init(loop, protocol, server, waiter, Context_CopyCurrent())
+        __pipe_init_uv_handle(<UVStream>handle, loop)
+        return handle
+
+    cdef _new_socket(self):
+        return __pipe_get_socket(<UVSocketHandle>self)
+
+    cdef _open(self, int sockfd):
+        __pipe_open(<UVStream>self, sockfd)
+
+    def get_write_buffer_limits(self):
+        raise NotImplementedError
+
+    def set_write_buffer_limits(self, high=None, low=None):
+        raise NotImplementedError
+
+    def get_write_buffer_size(self):
+        raise NotImplementedError
+
+    def write(self, data):
+        raise NotImplementedError
+
+    def writelines(self, list_of_data):
+        raise NotImplementedError
+
+    def write_eof(self):
+        raise NotImplementedError
+
+    def can_write_eof(self):
+        raise NotImplementedError
+
+    def abort(self):
+        raise NotImplementedError
+
+
+@cython.no_gc_clear
+cdef class WriteUnixTransport(UVStream):
+
+    @staticmethod
+    cdef WriteUnixTransport new(Loop loop, object protocol, Server server,
+                                object waiter):
+        cdef WriteUnixTransport handle
+        handle = WriteUnixTransport.__new__(WriteUnixTransport)
+
+        # We listen for read events on write-end of the pipe. When
+        # the read-end is close, the uv_stream_t.read callback will
+        # receive an error -- we want to silence that error, and just
+        # close the transport.
+        handle._close_on_read_error()
+
+        # This is only used in connect_write_pipe() and subprocess_shell/exec()
+        # directly, we could simply copy the current context.
+        handle._init(loop, protocol, server, waiter, Context_CopyCurrent())
+        __pipe_init_uv_handle(<UVStream>handle, loop)
+        return handle
+
+    cdef _new_socket(self):
+        return __pipe_get_socket(<UVSocketHandle>self)
+
+    cdef _open(self, int sockfd):
+        __pipe_open(<UVStream>self, sockfd)
+
+    def pause_reading(self):
+        raise NotImplementedError
+
+    def resume_reading(self):
+        raise NotImplementedError
+
+
+cdef class _PipeConnectRequest(UVRequest):
+    cdef:
+        UnixTransport transport
+        uv.uv_connect_t _req_data
+
+    def __cinit__(self, loop, transport):
+        self.request = <uv.uv_req_t*> &self._req_data
+        self.request.data = <void*>self
+        self.transport = transport
+
+    cdef connect(self, char* addr):
+        # uv_pipe_connect returns void
+        uv.uv_pipe_connect(<uv.uv_connect_t*>self.request,
+                           <uv.uv_pipe_t*>self.transport._handle,
+                           addr,
+                           __pipe_connect_callback)
+
+cdef void __pipe_connect_callback(uv.uv_connect_t* req, int status) with gil:
+    cdef:
+        _PipeConnectRequest wrapper
+        UnixTransport transport
+
+    wrapper = <_PipeConnectRequest> req.data
+    transport = wrapper.transport
+
+    if status < 0:
+        exc = convert_error(status)
+    else:
+        exc = None
+
+    try:
+        transport._on_connect(exc)
+    except BaseException as ex:
+        wrapper.transport._fatal_error(ex, False)
+    finally:
+        wrapper.on_done()
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/poll.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/poll.pxd
new file mode 100644
index 0000000..d07030b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/poll.pxd
@@ -0,0 +1,25 @@
+cdef class UVPoll(UVHandle):
+    cdef:
+        int fd
+        Handle reading_handle
+        Handle writing_handle
+
+    cdef _init(self, Loop loop, int fd)
+    cdef _close(self)
+
+    cdef inline _poll_start(self, int flags)
+    cdef inline _poll_stop(self)
+
+    cdef int is_active(self)
+
+    cdef is_reading(self)
+    cdef is_writing(self)
+
+    cdef start_reading(self, Handle callback)
+    cdef start_writing(self, Handle callback)
+    cdef stop_reading(self)
+    cdef stop_writing(self)
+    cdef stop(self)
+
+    @staticmethod
+    cdef UVPoll new(Loop loop, int fd)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/poll.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/poll.pyx
new file mode 100644
index 0000000..ebdbfd8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/poll.pyx
@@ -0,0 +1,230 @@
+@cython.no_gc_clear
+cdef class UVPoll(UVHandle):
+    cdef _init(self, Loop loop, int fd):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_poll_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_poll_init(self._loop.uvloop,
+                              <uv.uv_poll_t *>self._handle, fd)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.fd = fd
+        self.reading_handle = None
+        self.writing_handle = None
+
+    @staticmethod
+    cdef UVPoll new(Loop loop, int fd):
+        cdef UVPoll handle
+        handle = UVPoll.__new__(UVPoll)
+        handle._init(loop, fd)
+        return handle
+
+    cdef int is_active(self):
+        return (self.reading_handle is not None or
+                self.writing_handle is not None)
+
+    cdef inline _poll_start(self, int flags):
+        cdef int err
+
+        self._ensure_alive()
+
+        err = uv.uv_poll_start(
+            <uv.uv_poll_t*>self._handle,
+            flags,
+            __on_uvpoll_event)
+
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+    cdef inline _poll_stop(self):
+        cdef int err
+
+        if not self._is_alive():
+            return
+
+        err = uv.uv_poll_stop(<uv.uv_poll_t*>self._handle)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+        cdef:
+            int backend_id
+            system.epoll_event dummy_event
+
+        if system.PLATFORM_IS_LINUX:
+            # libuv doesn't remove the FD from epoll immediately
+            # after uv_poll_stop or uv_poll_close, causing hard
+            # to debug issue with dup-ed file descriptors causing
+            # CPU burn in epoll/epoll_ctl:
+            #    https://github.com/MagicStack/uvloop/issues/61
+            #
+            # It's safe though to manually call epoll_ctl here,
+            # after calling uv_poll_stop.
+
+            backend_id = uv.uv_backend_fd(self._loop.uvloop)
+            if backend_id != -1:
+                memset(&dummy_event, 0, sizeof(dummy_event))
+                system.epoll_ctl(
+                    backend_id,
+                    system.EPOLL_CTL_DEL,
+                    self.fd,
+                    &dummy_event)  # ignore errors
+
+    cdef is_reading(self):
+        return self._is_alive() and self.reading_handle is not None
+
+    cdef is_writing(self):
+        return self._is_alive() and self.writing_handle is not None
+
+    cdef start_reading(self, Handle callback):
+        cdef:
+            int mask = 0
+
+        if self.reading_handle is None:
+            # not reading right now, setup the handle
+
+            mask = uv.UV_READABLE
+            if self.writing_handle is not None:
+                # are we writing right now?
+                mask |= uv.UV_WRITABLE
+
+            self._poll_start(mask)
+        else:
+            self.reading_handle._cancel()
+
+        self.reading_handle = callback
+
+    cdef start_writing(self, Handle callback):
+        cdef:
+            int mask = 0
+
+        if self.writing_handle is None:
+            # not writing right now, setup the handle
+
+            mask = uv.UV_WRITABLE
+            if self.reading_handle is not None:
+                # are we reading right now?
+                mask |= uv.UV_READABLE
+
+            self._poll_start(mask)
+        else:
+            self.writing_handle._cancel()
+
+        self.writing_handle = callback
+
+    cdef stop_reading(self):
+        if self.reading_handle is None:
+            return False
+
+        self.reading_handle._cancel()
+        self.reading_handle = None
+
+        if self.writing_handle is None:
+            self.stop()
+        else:
+            self._poll_start(uv.UV_WRITABLE)
+
+        return True
+
+    cdef stop_writing(self):
+        if self.writing_handle is None:
+            return False
+
+        self.writing_handle._cancel()
+        self.writing_handle = None
+
+        if self.reading_handle is None:
+            self.stop()
+        else:
+            self._poll_start(uv.UV_READABLE)
+
+        return True
+
+    cdef stop(self):
+        if self.reading_handle is not None:
+            self.reading_handle._cancel()
+            self.reading_handle = None
+
+        if self.writing_handle is not None:
+            self.writing_handle._cancel()
+            self.writing_handle = None
+
+        self._poll_stop()
+
+    cdef _close(self):
+        if self.is_active():
+            self.stop()
+
+        UVHandle._close(<UVHandle>self)
+
+    cdef _fatal_error(self, exc, throw, reason=None):
+        try:
+            if self.reading_handle is not None:
+                try:
+                    self.reading_handle._run()
+                except BaseException as ex:
+                    self._loop._handle_exception(ex)
+                self.reading_handle = None
+
+            if self.writing_handle is not None:
+                try:
+                    self.writing_handle._run()
+                except BaseException as ex:
+                    self._loop._handle_exception(ex)
+                self.writing_handle = None
+
+        finally:
+            self._close()
+
+
+cdef void __on_uvpoll_event(uv.uv_poll_t* handle,
+                            int status, int events) with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVPoll callback") == 0:
+        return
+
+    cdef:
+        UVPoll poll = <UVPoll> handle.data
+
+    if status < 0:
+        exc = convert_error(status)
+        poll._fatal_error(exc, False)
+        return
+
+    if ((events & (uv.UV_READABLE | uv.UV_DISCONNECT)) and
+            poll.reading_handle is not None):
+
+        try:
+            if UVLOOP_DEBUG:
+                poll._loop._poll_read_events_total += 1
+            poll.reading_handle._run()
+        except BaseException as ex:
+            if UVLOOP_DEBUG:
+                poll._loop._poll_read_cb_errors_total += 1
+            poll._error(ex, False)
+            # continue code execution
+
+    if ((events & (uv.UV_WRITABLE | uv.UV_DISCONNECT)) and
+            poll.writing_handle is not None):
+
+        try:
+            if UVLOOP_DEBUG:
+                poll._loop._poll_write_events_total += 1
+            poll.writing_handle._run()
+        except BaseException as ex:
+            if UVLOOP_DEBUG:
+                poll._loop._poll_write_cb_errors_total += 1
+            poll._error(ex, False)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/process.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/process.pxd
new file mode 100644
index 0000000..5b69c73
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/process.pxd
@@ -0,0 +1,80 @@
+cdef class UVProcess(UVHandle):
+    cdef:
+        object _returncode
+        object _pid
+
+        object _errpipe_read
+        object _errpipe_write
+        object _preexec_fn
+        bint _restore_signals
+
+        set _fds_to_close
+
+        # Attributes used to compose uv_process_options_t:
+        uv.uv_process_options_t options
+        uv.uv_stdio_container_t[3] iocnt
+        list __env
+        char **uv_opt_env
+        list __args
+        char **uv_opt_args
+        char *uv_opt_file
+        bytes __cwd
+
+    cdef _close_process_handle(self)
+
+    cdef _init(self, Loop loop, list args, dict env, cwd,
+               start_new_session,
+               _stdin, _stdout, _stderr, pass_fds,
+               debug_flags, preexec_fn, restore_signals)
+
+    cdef _after_fork(self)
+
+    cdef char** __to_cstring_array(self, list arr)
+    cdef _init_args(self, list args)
+    cdef _init_env(self, dict env)
+    cdef _init_files(self, _stdin, _stdout, _stderr)
+    cdef _init_options(self, list args, dict env, cwd, start_new_session,
+                       _stdin, _stdout, _stderr)
+
+    cdef _close_after_spawn(self, int fd)
+
+    cdef _on_exit(self, int64_t exit_status, int term_signal)
+    cdef _kill(self, int signum)
+
+
+cdef class UVProcessTransport(UVProcess):
+    cdef:
+        list _exit_waiters
+        list _init_futs
+        bint _stdio_ready
+        list _pending_calls
+        object _protocol
+        bint _finished
+
+        WriteUnixTransport _stdin
+        ReadUnixTransport _stdout
+        ReadUnixTransport _stderr
+
+        object stdin_proto
+        object stdout_proto
+        object stderr_proto
+
+    cdef _file_redirect_stdio(self, int fd)
+    cdef _file_devnull(self)
+    cdef _file_inpipe(self)
+    cdef _file_outpipe(self)
+
+    cdef _check_proc(self)
+    cdef _pipe_connection_lost(self, int fd, exc)
+    cdef _pipe_data_received(self, int fd, data)
+
+    cdef _call_connection_made(self, waiter)
+    cdef _try_finish(self)
+
+    @staticmethod
+    cdef UVProcessTransport new(Loop loop, protocol, args, env, cwd,
+                                start_new_session,
+                                _stdin, _stdout, _stderr, pass_fds,
+                                waiter,
+                                debug_flags,
+                                preexec_fn, restore_signals)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/process.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/process.pyx
new file mode 100644
index 0000000..261aa1f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/process.pyx
@@ -0,0 +1,774 @@
+@cython.no_gc_clear
+cdef class UVProcess(UVHandle):
+    """Abstract class; wrapper over uv_process_t handle."""
+
+    def __cinit__(self):
+        self.uv_opt_env = NULL
+        self.uv_opt_args = NULL
+        self._returncode = None
+        self._pid = None
+        self._fds_to_close = set()
+        self._preexec_fn = None
+        self._restore_signals = True
+        self.context = Context_CopyCurrent()
+
+    cdef _close_process_handle(self):
+        # XXX: This is a workaround for a libuv bug:
+        # - https://github.com/libuv/libuv/issues/1933
+        # - https://github.com/libuv/libuv/pull/551
+        if self._handle is NULL:
+            return
+        self._handle.data = NULL
+        uv.uv_close(self._handle, __uv_close_process_handle_cb)
+        self._handle = NULL  # close callback will free() the memory
+
+    cdef _init(self, Loop loop, list args, dict env,
+               cwd, start_new_session,
+               _stdin, _stdout, _stderr,  # std* can be defined as macros in C
+               pass_fds, debug_flags, preexec_fn, restore_signals):
+
+        global __forking
+        global __forking_loop
+        global __forkHandler
+
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(
+            sizeof(uv.uv_process_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        # Too early to call _finish_init, but still a lot of work to do.
+        # Let's set handle.data to NULL, so in case something goes wrong,
+        # callbacks have a chance to avoid casting *something* into UVHandle.
+        self._handle.data = NULL
+
+        try:
+            self._init_options(args, env, cwd, start_new_session,
+                               _stdin, _stdout, _stderr)
+
+            restore_inheritable = set()
+            if pass_fds:
+                for fd in pass_fds:
+                    if not os_get_inheritable(fd):
+                        restore_inheritable.add(fd)
+                        os_set_inheritable(fd, True)
+        except Exception:
+            self._abort_init()
+            raise
+
+        if __forking or loop.active_process_handler is not None:
+            # Our pthread_atfork handlers won't work correctly when
+            # another loop is forking in another thread (even though
+            # GIL should help us to avoid that.)
+            self._abort_init()
+            raise RuntimeError(
+                'Racing with another loop to spawn a process.')
+
+        self._errpipe_read, self._errpipe_write = os_pipe()
+        try:
+            os_set_inheritable(self._errpipe_write, True)
+
+            self._preexec_fn = preexec_fn
+            self._restore_signals = restore_signals
+
+            loop.active_process_handler = self
+            __forking = 1
+            __forking_loop = loop
+            system.setForkHandler(<system.OnForkHandler>&__get_fork_handler)
+
+            PyOS_BeforeFork()
+
+            err = uv.uv_spawn(loop.uvloop,
+                              <uv.uv_process_t*>self._handle,
+                              &self.options)
+
+            __forking = 0
+            __forking_loop = None
+            system.resetForkHandler()
+            loop.active_process_handler = None
+
+            PyOS_AfterFork_Parent()
+
+            if err < 0:
+                self._close_process_handle()
+                self._abort_init()
+                raise convert_error(err)
+
+            self._finish_init()
+
+            os_close(self._errpipe_write)
+
+            if preexec_fn is not None:
+                errpipe_data = bytearray()
+                while True:
+                    # XXX: This is a blocking code that has to be
+                    # rewritten (using loop.connect_read_pipe() or
+                    # otherwise.)
+                    part = os_read(self._errpipe_read, 50000)
+                    errpipe_data += part
+                    if not part or len(errpipe_data) > 50000:
+                        break
+
+        finally:
+            os_close(self._errpipe_read)
+            try:
+                os_close(self._errpipe_write)
+            except OSError:
+                # Might be already closed
+                pass
+
+            fds_to_close = self._fds_to_close
+            self._fds_to_close = None
+            for fd in fds_to_close:
+                os_close(fd)
+
+            for fd in restore_inheritable:
+                os_set_inheritable(fd, False)
+
+        # asyncio caches the PID in BaseSubprocessTransport,
+        # so that the transport knows what the PID was even
+        # after the process is finished.
+        self._pid = (<uv.uv_process_t*>self._handle).pid
+
+        # Track the process handle (create a strong ref to it)
+        # to guarantee that __dealloc__ doesn't happen in an
+        # uncontrolled fashion.  We want to wait until the process
+        # exits and libuv calls __uvprocess_on_exit_callback,
+        # which will call `UVProcess._close()`, which will, in turn,
+        # untrack this handle.
+        self._loop._track_process(self)
+
+        if debug_flags & __PROCESS_DEBUG_SLEEP_AFTER_FORK:
+            time_sleep(1)
+
+        if preexec_fn is not None and errpipe_data:
+            # preexec_fn has raised an exception.  The child
+            # process must be dead now.
+            try:
+                exc_name, exc_msg = errpipe_data.split(b':', 1)
+                exc_name = exc_name.decode()
+                exc_msg = exc_msg.decode()
+            except Exception:
+                self._close()
+                raise subprocess_SubprocessError(
+                    'Bad exception data from child: {!r}'.format(
+                        errpipe_data))
+            exc_cls = getattr(__builtins__, exc_name,
+                              subprocess_SubprocessError)
+
+            exc = subprocess_SubprocessError(
+                'Exception occurred in preexec_fn.')
+            exc.__cause__ = exc_cls(exc_msg)
+            self._close()
+            raise exc
+
+    cdef _after_fork(self):
+        # See CPython/_posixsubprocess.c for details
+        cdef int err
+
+        if self._restore_signals:
+            _Py_RestoreSignals()
+
+        PyOS_AfterFork_Child()
+
+        err = uv.uv_loop_fork(self._loop.uvloop)
+        if err < 0:
+            raise convert_error(err)
+
+        if self._preexec_fn is not None:
+            try:
+                gc_disable()
+                self._preexec_fn()
+            except BaseException as ex:
+                try:
+                    with open(self._errpipe_write, 'wb') as f:
+                        f.write(str(ex.__class__.__name__).encode())
+                        f.write(b':')
+                        f.write(str(ex.args[0]).encode())
+                finally:
+                    system._exit(255)
+                    return
+            else:
+                os_close(self._errpipe_write)
+        else:
+            os_close(self._errpipe_write)
+
+    cdef _close_after_spawn(self, int fd):
+        if self._fds_to_close is None:
+            raise RuntimeError(
+                'UVProcess._close_after_spawn called after uv_spawn')
+        self._fds_to_close.add(fd)
+
+    def __dealloc__(self):
+        if self.uv_opt_env is not NULL:
+            PyMem_RawFree(self.uv_opt_env)
+            self.uv_opt_env = NULL
+
+        if self.uv_opt_args is not NULL:
+            PyMem_RawFree(self.uv_opt_args)
+            self.uv_opt_args = NULL
+
+    cdef char** __to_cstring_array(self, list arr):
+        cdef:
+            int i
+            ssize_t arr_len = len(arr)
+            bytes el
+
+            char **ret
+
+        if UVLOOP_DEBUG:
+            assert arr_len > 0
+
+        ret = <char **>PyMem_RawMalloc((arr_len + 1) * sizeof(char *))
+        if ret is NULL:
+            raise MemoryError()
+
+        for i in range(arr_len):
+            el = arr[i]
+            # NB: PyBytes_AsString doesn't copy the data;
+            # we have to be careful when the "arr" is GCed,
+            # and it shouldn't be ever mutated.
+            ret[i] = PyBytes_AsString(el)
+
+        ret[arr_len] = NULL
+        return ret
+
+    cdef _init_options(self, list args, dict env, cwd, start_new_session,
+                       _stdin, _stdout, _stderr):
+
+        memset(&self.options, 0, sizeof(uv.uv_process_options_t))
+
+        self._init_env(env)
+        self.options.env = self.uv_opt_env
+
+        self._init_args(args)
+        self.options.file = self.uv_opt_file
+        self.options.args = self.uv_opt_args
+
+        if start_new_session:
+            self.options.flags |= uv.UV_PROCESS_DETACHED
+
+        if cwd is not None:
+            cwd = os_fspath(cwd)
+
+            if isinstance(cwd, str):
+                cwd = PyUnicode_EncodeFSDefault(cwd)
+            if not isinstance(cwd, bytes):
+                raise ValueError('cwd must be a str or bytes object')
+
+            self.__cwd = cwd
+            self.options.cwd = PyBytes_AsString(self.__cwd)
+
+        self.options.exit_cb = &__uvprocess_on_exit_callback
+
+        self._init_files(_stdin, _stdout, _stderr)
+
+    cdef _init_args(self, list args):
+        cdef:
+            bytes path
+            int an = len(args)
+
+        if an < 1:
+            raise ValueError('cannot spawn a process: args are empty')
+
+        self.__args = args.copy()
+        for i in range(an):
+            arg = os_fspath(args[i])
+            if isinstance(arg, str):
+                self.__args[i] = PyUnicode_EncodeFSDefault(arg)
+            elif not isinstance(arg, bytes):
+                raise TypeError('all args must be str or bytes')
+
+        path = self.__args[0]
+        self.uv_opt_file = PyBytes_AsString(path)
+        self.uv_opt_args = self.__to_cstring_array(self.__args)
+
+    cdef _init_env(self, dict env):
+        if env is not None and len(env):
+            self.__env = list()
+            for key in env:
+                val = env[key]
+
+                if isinstance(key, str):
+                    key = PyUnicode_EncodeFSDefault(key)
+                elif not isinstance(key, bytes):
+                    raise TypeError(
+                        'all environment vars must be bytes or str')
+
+                if isinstance(val, str):
+                    val = PyUnicode_EncodeFSDefault(val)
+                elif not isinstance(val, bytes):
+                    raise TypeError(
+                        'all environment values must be bytes or str')
+
+                self.__env.append(key + b'=' + val)
+
+            self.uv_opt_env = self.__to_cstring_array(self.__env)
+        else:
+            self.__env = None
+
+    cdef _init_files(self, _stdin, _stdout, _stderr):
+        self.options.stdio_count = 0
+
+    cdef _kill(self, int signum):
+        cdef int err
+        self._ensure_alive()
+        err = uv.uv_process_kill(<uv.uv_process_t*>self._handle, signum)
+        if err < 0:
+            raise convert_error(err)
+
+    cdef _on_exit(self, int64_t exit_status, int term_signal):
+        if term_signal:
+            # From Python docs:
+            #    A negative value -N indicates that the child was
+            #    terminated by signal N (POSIX only).
+            self._returncode = -term_signal
+        else:
+            self._returncode = exit_status
+
+        self._close()
+
+    cdef _close(self):
+        try:
+            if self._loop is not None:
+                self._loop._untrack_process(self)
+        finally:
+            UVHandle._close(self)
+
+
+DEF _CALL_PIPE_DATA_RECEIVED = 0
+DEF _CALL_PIPE_CONNECTION_LOST = 1
+DEF _CALL_PROCESS_EXITED = 2
+DEF _CALL_CONNECTION_LOST = 3
+
+
+@cython.no_gc_clear
+cdef class UVProcessTransport(UVProcess):
+    def __cinit__(self):
+        self._exit_waiters = []
+        self._protocol = None
+
+        self._init_futs = []
+        self._pending_calls = []
+        self._stdio_ready = 0
+
+        self._stdin = self._stdout = self._stderr = None
+        self.stdin_proto = self.stdout_proto = self.stderr_proto = None
+
+        self._finished = 0
+
+    cdef _on_exit(self, int64_t exit_status, int term_signal):
+        UVProcess._on_exit(self, exit_status, term_signal)
+
+        if self._stdio_ready:
+            self._loop.call_soon(self._protocol.process_exited,
+                                 context=self.context)
+        else:
+            self._pending_calls.append((_CALL_PROCESS_EXITED, None, None))
+
+        self._try_finish()
+
+        for waiter in self._exit_waiters:
+            if not waiter.cancelled():
+                waiter.set_result(self._returncode)
+        self._exit_waiters.clear()
+
+        self._close()
+
+    cdef _check_proc(self):
+        if not self._is_alive() or self._returncode is not None:
+            raise ProcessLookupError()
+
+    cdef _pipe_connection_lost(self, int fd, exc):
+        if self._stdio_ready:
+            self._loop.call_soon(self._protocol.pipe_connection_lost, fd, exc,
+                                 context=self.context)
+            self._try_finish()
+        else:
+            self._pending_calls.append((_CALL_PIPE_CONNECTION_LOST, fd, exc))
+
+    cdef _pipe_data_received(self, int fd, data):
+        if self._stdio_ready:
+            self._loop.call_soon(self._protocol.pipe_data_received, fd, data,
+                                 context=self.context)
+        else:
+            self._pending_calls.append((_CALL_PIPE_DATA_RECEIVED, fd, data))
+
+    cdef _file_redirect_stdio(self, int fd):
+        fd = os_dup(fd)
+        os_set_inheritable(fd, True)
+        self._close_after_spawn(fd)
+        return fd
+
+    cdef _file_devnull(self):
+        dn = os_open(os_devnull, os_O_RDWR)
+        os_set_inheritable(dn, True)
+        self._close_after_spawn(dn)
+        return dn
+
+    cdef _file_outpipe(self):
+        r, w = __socketpair()
+        os_set_inheritable(w, True)
+        self._close_after_spawn(w)
+        return r, w
+
+    cdef _file_inpipe(self):
+        r, w = __socketpair()
+        os_set_inheritable(r, True)
+        self._close_after_spawn(r)
+        return r, w
+
+    cdef _init_files(self, _stdin, _stdout, _stderr):
+        cdef uv.uv_stdio_container_t *iocnt
+
+        UVProcess._init_files(self, _stdin, _stdout, _stderr)
+
+        io = [None, None, None]
+
+        self.options.stdio_count = 3
+        self.options.stdio = self.iocnt
+
+        if _stdin is not None:
+            if _stdin == subprocess_PIPE:
+                r, w = self._file_inpipe()
+                io[0] = r
+
+                self.stdin_proto = WriteSubprocessPipeProto(self, 0)
+                waiter = self._loop._new_future()
+                self._stdin = WriteUnixTransport.new(
+                    self._loop, self.stdin_proto, None, waiter)
+                self._init_futs.append(waiter)
+                self._stdin._open(w)
+                self._stdin._init_protocol()
+            elif _stdin == subprocess_DEVNULL:
+                io[0] = self._file_devnull()
+            elif _stdout == subprocess_STDOUT:
+                raise ValueError(
+                    'subprocess.STDOUT is supported only by stderr parameter')
+            else:
+                io[0] = self._file_redirect_stdio(_stdin)
+        else:
+            io[0] = self._file_redirect_stdio(0)
+
+        if _stdout is not None:
+            if _stdout == subprocess_PIPE:
+                # We can't use UV_CREATE_PIPE here, since 'stderr' might be
+                # set to 'subprocess.STDOUT', and there is no way to
+                # emulate that functionality with libuv high-level
+                # streams API. Therefore, we create pipes for stdout and
+                # stderr manually.
+
+                r, w = self._file_outpipe()
+                io[1] = w
+
+                self.stdout_proto = ReadSubprocessPipeProto(self, 1)
+                waiter = self._loop._new_future()
+                self._stdout = ReadUnixTransport.new(
+                    self._loop, self.stdout_proto, None, waiter)
+                self._init_futs.append(waiter)
+                self._stdout._open(r)
+                self._stdout._init_protocol()
+            elif _stdout == subprocess_DEVNULL:
+                io[1] = self._file_devnull()
+            elif _stdout == subprocess_STDOUT:
+                raise ValueError(
+                    'subprocess.STDOUT is supported only by stderr parameter')
+            else:
+                io[1] = self._file_redirect_stdio(_stdout)
+        else:
+            io[1] = self._file_redirect_stdio(1)
+
+        if _stderr is not None:
+            if _stderr == subprocess_PIPE:
+                r, w = self._file_outpipe()
+                io[2] = w
+
+                self.stderr_proto = ReadSubprocessPipeProto(self, 2)
+                waiter = self._loop._new_future()
+                self._stderr = ReadUnixTransport.new(
+                    self._loop, self.stderr_proto, None, waiter)
+                self._init_futs.append(waiter)
+                self._stderr._open(r)
+                self._stderr._init_protocol()
+            elif _stderr == subprocess_STDOUT:
+                if io[1] is None:
+                    # shouldn't ever happen
+                    raise RuntimeError('cannot apply subprocess.STDOUT')
+
+                newfd = os_dup(io[1])
+                os_set_inheritable(newfd, True)
+                self._close_after_spawn(newfd)
+                io[2] = newfd
+            elif _stderr == subprocess_DEVNULL:
+                io[2] = self._file_devnull()
+            else:
+                io[2] = self._file_redirect_stdio(_stderr)
+        else:
+            io[2] = self._file_redirect_stdio(2)
+
+        assert len(io) == 3
+        for idx in range(3):
+            iocnt = &self.iocnt[idx]
+            if io[idx] is not None:
+                iocnt.flags = uv.UV_INHERIT_FD
+                iocnt.data.fd = io[idx]
+            else:
+                iocnt.flags = uv.UV_IGNORE
+
+    cdef _call_connection_made(self, waiter):
+        try:
+            # we're always called in the right context, so just call the user's
+            self._protocol.connection_made(self)
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as ex:
+            if waiter is not None and not waiter.cancelled():
+                waiter.set_exception(ex)
+            else:
+                raise
+        else:
+            if waiter is not None and not waiter.cancelled():
+                waiter.set_result(True)
+
+        self._stdio_ready = 1
+        if self._pending_calls:
+            pending_calls = self._pending_calls.copy()
+            self._pending_calls.clear()
+            for (type, fd, arg) in pending_calls:
+                if type == _CALL_PIPE_CONNECTION_LOST:
+                    self._pipe_connection_lost(fd, arg)
+                elif type == _CALL_PIPE_DATA_RECEIVED:
+                    self._pipe_data_received(fd, arg)
+                elif type == _CALL_PROCESS_EXITED:
+                    self._loop.call_soon(self._protocol.process_exited)
+                elif type == _CALL_CONNECTION_LOST:
+                    self._loop.call_soon(self._protocol.connection_lost, None)
+
+    cdef _try_finish(self):
+        if self._returncode is None or self._finished:
+            return
+
+        if ((self.stdin_proto is None or self.stdin_proto.disconnected) and
+                (self.stdout_proto is None or
+                    self.stdout_proto.disconnected) and
+                (self.stderr_proto is None or
+                    self.stderr_proto.disconnected)):
+
+            self._finished = 1
+
+            if self._stdio_ready:
+                # copy self.context for simplicity
+                self._loop.call_soon(self._protocol.connection_lost, None,
+                                     context=self.context)
+            else:
+                self._pending_calls.append((_CALL_CONNECTION_LOST, None, None))
+
+    def __stdio_inited(self, waiter, stdio_fut):
+        exc = stdio_fut.exception()
+        if exc is not None:
+            if waiter is None:
+                raise exc
+            else:
+                waiter.set_exception(exc)
+        else:
+            self._loop._call_soon_handle(
+                new_MethodHandle1(self._loop,
+                                  "UVProcessTransport._call_connection_made",
+                                  <method1_t>self._call_connection_made,
+                                  None,  # means to copy the current context
+                                  self, waiter))
+
+    @staticmethod
+    cdef UVProcessTransport new(Loop loop, protocol, args, env,
+                                cwd, start_new_session,
+                                _stdin, _stdout, _stderr, pass_fds,
+                                waiter,
+                                debug_flags,
+                                preexec_fn,
+                                restore_signals):
+
+        cdef UVProcessTransport handle
+        handle = UVProcessTransport.__new__(UVProcessTransport)
+        handle._protocol = protocol
+        handle._init(loop, args, env, cwd, start_new_session,
+                     __process_convert_fileno(_stdin),
+                     __process_convert_fileno(_stdout),
+                     __process_convert_fileno(_stderr),
+                     pass_fds,
+                     debug_flags,
+                     preexec_fn,
+                     restore_signals)
+
+        if handle._init_futs:
+            handle._stdio_ready = 0
+            init_fut = aio_gather(*handle._init_futs)
+            # add_done_callback will copy the current context and run the
+            # callback within the context
+            init_fut.add_done_callback(
+                ft_partial(handle.__stdio_inited, waiter))
+        else:
+            handle._stdio_ready = 1
+            loop._call_soon_handle(
+                new_MethodHandle1(loop,
+                                  "UVProcessTransport._call_connection_made",
+                                  <method1_t>handle._call_connection_made,
+                                  None,  # means to copy the current context
+                                  handle, waiter))
+
+        return handle
+
+    def get_protocol(self):
+        return self._protocol
+
+    def set_protocol(self, protocol):
+        self._protocol = protocol
+
+    def get_pid(self):
+        return self._pid
+
+    def get_returncode(self):
+        return self._returncode
+
+    def get_pipe_transport(self, fd):
+        if fd == 0:
+            return self._stdin
+        elif fd == 1:
+            return self._stdout
+        elif fd == 2:
+            return self._stderr
+
+    def terminate(self):
+        self._check_proc()
+        self._kill(uv.SIGTERM)
+
+    def kill(self):
+        self._check_proc()
+        self._kill(uv.SIGKILL)
+
+    def send_signal(self, int signal):
+        self._check_proc()
+        self._kill(signal)
+
+    def is_closing(self):
+        return self._closed
+
+    def close(self):
+        if self._returncode is None:
+            self._kill(uv.SIGKILL)
+
+        if self._stdin is not None:
+            self._stdin.close()
+        if self._stdout is not None:
+            self._stdout.close()
+        if self._stderr is not None:
+            self._stderr.close()
+
+        if self._returncode is not None:
+            # The process is dead, just close the UV handle.
+            #
+            # (If "self._returncode is None", the process should have been
+            # killed already and we're just waiting for a SIGCHLD; after
+            # which the transport will be GC'ed and the uvhandle will be
+            # closed in UVHandle.__dealloc__.)
+            self._close()
+
+    def get_extra_info(self, name, default=None):
+        return default
+
+    def _wait(self):
+        fut = self._loop._new_future()
+        if self._returncode is not None:
+            fut.set_result(self._returncode)
+            return fut
+
+        self._exit_waiters.append(fut)
+        return fut
+
+
+class WriteSubprocessPipeProto(aio_BaseProtocol):
+
+    def __init__(self, proc, fd):
+        if UVLOOP_DEBUG:
+            if type(proc) is not UVProcessTransport:
+                raise TypeError
+            if not isinstance(fd, int):
+                raise TypeError
+        self.proc = proc
+        self.fd = fd
+        self.pipe = None
+        self.disconnected = False
+
+    def connection_made(self, transport):
+        self.pipe = transport
+
+    def __repr__(self):
+        return ('<%s fd=%s pipe=%r>'
+                % (self.__class__.__name__, self.fd, self.pipe))
+
+    def connection_lost(self, exc):
+        self.disconnected = True
+        (<UVProcessTransport>self.proc)._pipe_connection_lost(self.fd, exc)
+        self.proc = None
+
+    def pause_writing(self):
+        (<UVProcessTransport>self.proc)._protocol.pause_writing()
+
+    def resume_writing(self):
+        (<UVProcessTransport>self.proc)._protocol.resume_writing()
+
+
+class ReadSubprocessPipeProto(WriteSubprocessPipeProto,
+                              aio_Protocol):
+
+    def data_received(self, data):
+        (<UVProcessTransport>self.proc)._pipe_data_received(self.fd, data)
+
+
+cdef __process_convert_fileno(object obj):
+    if obj is None or isinstance(obj, int):
+        return obj
+
+    fileno = obj.fileno()
+    if not isinstance(fileno, int):
+        raise TypeError(
+            '{!r}.fileno() returned non-integer'.format(obj))
+    return fileno
+
+
+cdef void __uvprocess_on_exit_callback(uv.uv_process_t *handle,
+                                       int64_t exit_status,
+                                       int term_signal) with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>handle,
+                            "UVProcess exit callback") == 0:
+        return
+
+    cdef UVProcess proc = <UVProcess> handle.data
+    try:
+        proc._on_exit(exit_status, term_signal)
+    except BaseException as ex:
+        proc._error(ex, False)
+
+
+cdef __socketpair():
+    cdef:
+        int fds[2]
+        int err
+
+    err = system.socketpair(uv.AF_UNIX, uv.SOCK_STREAM, 0, fds)
+    if err:
+        exc = convert_error(-err)
+        raise exc
+
+    os_set_inheritable(fds[0], False)
+    os_set_inheritable(fds[1], False)
+
+    return fds[0], fds[1]
+
+
+cdef void __uv_close_process_handle_cb(uv.uv_handle_t* handle) with gil:
+    PyMem_RawFree(handle)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/stream.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/stream.pxd
new file mode 100644
index 0000000..21ac627
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/stream.pxd
@@ -0,0 +1,42 @@
+cdef class UVStream(UVBaseTransport):
+    cdef:
+        uv.uv_shutdown_t _shutdown_req
+        bint __shutting_down
+        bint __reading
+        bint __read_error_close
+
+        bint __buffered
+        object _protocol_get_buffer
+        object _protocol_buffer_updated
+
+        bint _eof
+        list _buffer
+        size_t _buffer_size
+
+        Py_buffer _read_pybuf
+        bint _read_pybuf_acquired
+
+    # All "inline" methods are final
+
+    cdef inline _init(self, Loop loop, object protocol, Server server,
+                      object waiter, object context)
+
+    cdef inline _exec_write(self)
+
+    cdef inline _shutdown(self)
+    cdef inline _accept(self, UVStream server)
+
+    cdef inline _close_on_read_error(self)
+
+    cdef inline __reading_started(self)
+    cdef inline __reading_stopped(self)
+
+    cdef inline _write(self, object data)
+    cdef inline _try_write(self, object data)
+
+    cdef _close(self)
+
+    cdef inline _on_accept(self)
+    cdef inline _on_eof(self)
+    cdef inline _on_write(self)
+    cdef inline _on_connect(self, object exc)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/stream.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/stream.pyx
new file mode 100644
index 0000000..4757ce7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/stream.pyx
@@ -0,0 +1,995 @@
+DEF __PREALLOCED_BUFS = 4
+
+
+@cython.no_gc_clear
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class _StreamWriteContext:
+    # used to hold additional write request information for uv_write
+
+    cdef:
+        uv.uv_write_t   req
+
+        list            buffers
+
+        uv.uv_buf_t     uv_bufs_sml[__PREALLOCED_BUFS]
+        Py_buffer       py_bufs_sml[__PREALLOCED_BUFS]
+        bint            py_bufs_sml_inuse
+
+        uv.uv_buf_t*    uv_bufs
+        Py_buffer*      py_bufs
+        size_t          py_bufs_len
+
+        uv.uv_buf_t*    uv_bufs_start
+        size_t          uv_bufs_len
+
+        UVStream        stream
+
+        bint            closed
+
+    cdef free_bufs(self):
+        cdef size_t i
+
+        if self.uv_bufs is not NULL:
+            PyMem_RawFree(self.uv_bufs)
+            self.uv_bufs = NULL
+            if UVLOOP_DEBUG:
+                if self.py_bufs_sml_inuse:
+                    raise RuntimeError(
+                        '_StreamWriteContext.close: uv_bufs != NULL and '
+                        'py_bufs_sml_inuse is True')
+
+        if self.py_bufs is not NULL:
+            for i from 0 <= i < self.py_bufs_len:
+                PyBuffer_Release(&self.py_bufs[i])
+            PyMem_RawFree(self.py_bufs)
+            self.py_bufs = NULL
+            if UVLOOP_DEBUG:
+                if self.py_bufs_sml_inuse:
+                    raise RuntimeError(
+                        '_StreamWriteContext.close: py_bufs != NULL and '
+                        'py_bufs_sml_inuse is True')
+
+        if self.py_bufs_sml_inuse:
+            for i from 0 <= i < self.py_bufs_len:
+                PyBuffer_Release(&self.py_bufs_sml[i])
+            self.py_bufs_sml_inuse = 0
+
+        self.py_bufs_len = 0
+        self.buffers = None
+
+    cdef close(self):
+        if self.closed:
+            return
+        self.closed = 1
+        self.free_bufs()
+        Py_DECREF(self)
+
+    cdef advance_uv_buf(self, size_t sent):
+        # Advance the pointer to first uv_buf and the
+        # pointer to first byte in that buffer.
+        #
+        # We do this after a "uv_try_write" call, which
+        # sometimes sends only a portion of data.
+        # We then call "advance_uv_buf" on the write
+        # context, and reuse it in a "uv_write" call.
+
+        cdef:
+            uv.uv_buf_t* buf
+            size_t idx
+
+        for idx from 0 <= idx < self.uv_bufs_len:
+            buf = &self.uv_bufs_start[idx]
+            if buf.len > sent:
+                buf.len -= sent
+                buf.base = buf.base + sent
+                self.uv_bufs_start = buf
+                self.uv_bufs_len -= idx
+                return
+            else:
+                sent -= self.uv_bufs_start[idx].len
+
+            if UVLOOP_DEBUG:
+                if sent < 0:
+                    raise RuntimeError('fatal: sent < 0 in advance_uv_buf')
+
+        raise RuntimeError('fatal: Could not advance _StreamWriteContext')
+
+    @staticmethod
+    cdef _StreamWriteContext new(UVStream stream, list buffers):
+        cdef:
+            _StreamWriteContext ctx
+            int uv_bufs_idx = 0
+            size_t py_bufs_len = 0
+            int i
+
+            Py_buffer* p_pybufs
+            uv.uv_buf_t* p_uvbufs
+
+        ctx = _StreamWriteContext.__new__(_StreamWriteContext)
+        ctx.stream = None
+        ctx.closed = 1
+        ctx.py_bufs_len = 0
+        ctx.py_bufs_sml_inuse = 0
+        ctx.uv_bufs = NULL
+        ctx.py_bufs = NULL
+        ctx.buffers = buffers
+        ctx.stream = stream
+
+        if len(buffers) <= __PREALLOCED_BUFS:
+            # We've got a small number of buffers to write, don't
+            # need to use malloc.
+            ctx.py_bufs_sml_inuse = 1
+            p_pybufs = <Py_buffer*>&ctx.py_bufs_sml
+            p_uvbufs = <uv.uv_buf_t*>&ctx.uv_bufs_sml
+
+        else:
+            for buf in buffers:
+                if UVLOOP_DEBUG:
+                    if not isinstance(buf, (bytes, bytearray, memoryview)):
+                        raise RuntimeError(
+                            'invalid data in writebuf: an instance of '
+                            'bytes, bytearray or memoryview was expected, '
+                            'got {}'.format(type(buf)))
+
+                if not PyBytes_CheckExact(buf):
+                    py_bufs_len += 1
+
+            if py_bufs_len > 0:
+                ctx.py_bufs = <Py_buffer*>PyMem_RawMalloc(
+                    py_bufs_len * sizeof(Py_buffer))
+                if ctx.py_bufs is NULL:
+                    raise MemoryError()
+
+            ctx.uv_bufs = <uv.uv_buf_t*>PyMem_RawMalloc(
+                len(buffers) * sizeof(uv.uv_buf_t))
+            if ctx.uv_bufs is NULL:
+                raise MemoryError()
+
+            p_pybufs = ctx.py_bufs
+            p_uvbufs = ctx.uv_bufs
+
+        py_bufs_len = 0
+        for buf in buffers:
+            if PyBytes_CheckExact(buf):
+                # We can only use this hack for bytes since it's
+                # immutable.  For everything else it is only safe to
+                # use buffer protocol.
+                p_uvbufs[uv_bufs_idx].base = PyBytes_AS_STRING(buf)
+                p_uvbufs[uv_bufs_idx].len = Py_SIZE(buf)
+
+            else:
+                try:
+                    PyObject_GetBuffer(
+                        buf, &p_pybufs[py_bufs_len], PyBUF_SIMPLE)
+                except Exception:
+                    # This shouldn't ever happen, as `UVStream._write`
+                    # casts non-bytes objects to `memoryviews`.
+                    ctx.py_bufs_len = py_bufs_len
+                    ctx.free_bufs()
+                    raise
+
+                p_uvbufs[uv_bufs_idx].base = <char*>p_pybufs[py_bufs_len].buf
+                p_uvbufs[uv_bufs_idx].len = p_pybufs[py_bufs_len].len
+
+                py_bufs_len += 1
+
+            uv_bufs_idx += 1
+
+        ctx.uv_bufs_start = p_uvbufs
+        ctx.uv_bufs_len = uv_bufs_idx
+
+        ctx.py_bufs_len = py_bufs_len
+        ctx.req.data = <void*> ctx
+
+        if UVLOOP_DEBUG:
+            stream._loop._debug_stream_write_ctx_total += 1
+            stream._loop._debug_stream_write_ctx_cnt += 1
+
+        # Do incref after everything else is done.
+        # Under no circumstances we want `ctx` to be GCed while
+        # libuv is still working with `ctx.uv_bufs`.
+        Py_INCREF(ctx)
+        ctx.closed = 0
+        return ctx
+
+    def __dealloc__(self):
+        if not self.closed:
+            # Because we do an INCREF in _StreamWriteContext.new,
+            # __dealloc__ shouldn't ever happen with `self.closed == 1`
+            raise RuntimeError(
+                'open _StreamWriteContext is being deallocated')
+
+        if UVLOOP_DEBUG:
+            if self.stream is not None:
+                self.stream._loop._debug_stream_write_ctx_cnt -= 1
+                self.stream = None
+
+
+@cython.no_gc_clear
+cdef class UVStream(UVBaseTransport):
+
+    def __cinit__(self):
+        self.__shutting_down = 0
+        self.__reading = 0
+        self.__read_error_close = 0
+        self.__buffered = 0
+        self._eof = 0
+        self._buffer = []
+        self._buffer_size = 0
+
+        self._protocol_get_buffer = None
+        self._protocol_buffer_updated = None
+
+        self._read_pybuf_acquired = False
+
+    cdef _set_protocol(self, object protocol):
+        if protocol is None:
+            raise TypeError('protocol is required')
+
+        UVBaseTransport._set_protocol(self, protocol)
+
+        if (hasattr(protocol, 'get_buffer') and
+                not isinstance(protocol, aio_Protocol)):
+            try:
+                self._protocol_get_buffer = protocol.get_buffer
+                self._protocol_buffer_updated = protocol.buffer_updated
+                self.__buffered = 1
+            except AttributeError:
+                pass
+        else:
+            self.__buffered = 0
+
+    cdef _clear_protocol(self):
+        UVBaseTransport._clear_protocol(self)
+        self._protocol_get_buffer = None
+        self._protocol_buffer_updated = None
+        self.__buffered = 0
+
+    cdef inline _shutdown(self):
+        cdef int err
+
+        if self.__shutting_down:
+            return
+        self.__shutting_down = 1
+
+        self._ensure_alive()
+
+        self._shutdown_req.data = <void*> self
+        err = uv.uv_shutdown(&self._shutdown_req,
+                             <uv.uv_stream_t*> self._handle,
+                             __uv_stream_on_shutdown)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+    cdef inline _accept(self, UVStream server):
+        cdef int err
+        self._ensure_alive()
+
+        err = uv.uv_accept(<uv.uv_stream_t*>server._handle,
+                           <uv.uv_stream_t*>self._handle)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+        self._on_accept()
+
+    cdef inline _close_on_read_error(self):
+        self.__read_error_close = 1
+
+    cdef bint _is_reading(self):
+        return self.__reading
+
+    cdef _start_reading(self):
+        cdef int err
+
+        if self._closing:
+            return
+
+        self._ensure_alive()
+
+        if self.__reading:
+            return
+
+        if self.__buffered:
+            err = uv.uv_read_start(<uv.uv_stream_t*>self._handle,
+                                   __uv_stream_buffered_alloc,
+                                   __uv_stream_buffered_on_read)
+        else:
+            err = uv.uv_read_start(<uv.uv_stream_t*>self._handle,
+                                   __loop_alloc_buffer,
+                                   __uv_stream_on_read)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+        else:
+            # UVStream must live until the read callback is called
+            self.__reading_started()
+
+    cdef inline __reading_started(self):
+        if self.__reading:
+            return
+        self.__reading = 1
+        Py_INCREF(self)
+
+    cdef inline __reading_stopped(self):
+        if not self.__reading:
+            return
+        self.__reading = 0
+        Py_DECREF(self)
+
+    cdef _stop_reading(self):
+        cdef int err
+
+        if not self.__reading:
+            return
+
+        self._ensure_alive()
+
+        # From libuv docs:
+        #    This function is idempotent and may be safely
+        #    called on a stopped stream.
+        err = uv.uv_read_stop(<uv.uv_stream_t*>self._handle)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+        else:
+            self.__reading_stopped()
+
+    cdef inline _try_write(self, object data):
+        cdef:
+            ssize_t written
+            bint used_buf = 0
+            Py_buffer py_buf
+            void* buf
+            size_t blen
+            int saved_errno
+            int fd
+
+        if (<uv.uv_stream_t*>self._handle).write_queue_size != 0:
+            raise RuntimeError(
+                'UVStream._try_write called with data in uv buffers')
+
+        if PyBytes_CheckExact(data):
+            # We can only use this hack for bytes since it's
+            # immutable.  For everything else it is only safe to
+            # use buffer protocol.
+            buf = <void*>PyBytes_AS_STRING(data)
+            blen = Py_SIZE(data)
+        else:
+            PyObject_GetBuffer(data, &py_buf, PyBUF_SIMPLE)
+            used_buf = 1
+            buf = py_buf.buf
+            blen = py_buf.len
+
+        if blen == 0:
+            # Empty data, do nothing.
+            return 0
+
+        fd = self._fileno()
+        # Use `unistd.h/write` directly, it's faster than
+        # uv_try_write -- less layers of code.  The error
+        # checking logic is copied from libuv.
+        written = system.write(fd, buf, blen)
+        while written == -1 and (
+                errno.errno == errno.EINTR or
+                (system.PLATFORM_IS_APPLE and
+                    errno.errno == errno.EPROTOTYPE)):
+            # From libuv code (unix/stream.c):
+            #   Due to a possible kernel bug at least in OS X 10.10 "Yosemite",
+            #   EPROTOTYPE can be returned while trying to write to a socket
+            #   that is shutting down. If we retry the write, we should get
+            #   the expected EPIPE instead.
+            written = system.write(fd, buf, blen)
+        saved_errno = errno.errno
+
+        if used_buf:
+            PyBuffer_Release(&py_buf)
+
+        if written < 0:
+            if saved_errno == errno.EAGAIN or \
+                    saved_errno == system.EWOULDBLOCK:
+                return -1
+            else:
+                exc = convert_error(-saved_errno)
+                self._fatal_error(exc, True)
+                return
+
+        if UVLOOP_DEBUG:
+            self._loop._debug_stream_write_tries += 1
+
+        if <size_t>written == blen:
+            return 0
+
+        return written
+
+    cdef inline _write(self, object data):
+        cdef int dlen
+
+        if not PyBytes_CheckExact(data):
+            data = memoryview(data).cast('b')
+
+        dlen = len(data)
+        if not dlen:
+            return
+
+        self._buffer_size += dlen
+        self._buffer.append(data)
+
+        if (not self._protocol_paused and
+                (<uv.uv_stream_t*>self._handle).write_queue_size == 0 and
+                self._buffer_size > self._high_water):
+            # Fast-path.  If:
+            #   - the protocol isn't yet paused,
+            #   - there is no data in libuv buffers for this stream,
+            #   - the protocol will be paused if we continue to buffer data
+            #
+            # Then:
+            #   - Try to write all buffered data right now.
+            all_sent = self._exec_write()
+            if UVLOOP_DEBUG:
+                if self._buffer_size != 0 or self._buffer != []:
+                    raise RuntimeError(
+                        '_buffer_size is not 0 after a successful _exec_write')
+
+            # There is no need to call `_queue_write` anymore,
+            # as `uv_write` should be called already.
+
+            if not all_sent:
+                # If not all of the data was sent successfully,
+                # we might need to pause the protocol.
+                self._maybe_pause_protocol()
+            return
+
+        self._maybe_pause_protocol()
+        self._loop._queue_write(self)
+
+    cdef inline _exec_write(self):
+        cdef:
+            int err
+            int buf_len
+            _StreamWriteContext ctx = None
+
+        if self._closed:
+            # If the handle is closed, just return, it's too
+            # late to do anything.
+            return
+
+        buf_len = len(self._buffer)
+        if not buf_len:
+            return
+
+        if (<uv.uv_stream_t*>self._handle).write_queue_size == 0:
+            # libuv internal write buffers for this stream are empty.
+            if buf_len == 1:
+                # If we only have one piece of data to send, let's
+                # use our fast implementation of try_write.
+                data = self._buffer[0]
+                sent = self._try_write(data)
+
+                if sent is None:
+                    # A `self._fatal_error` was called.
+                    # It might not raise an exception under some
+                    # conditions.
+                    self._buffer_size = 0
+                    self._buffer.clear()
+                    if not self._closing:
+                        # This should never happen.
+                        raise RuntimeError(
+                            'stream is open after UVStream._try_write '
+                            'returned None')
+                    return
+
+                if sent == 0:
+                    # All data was successfully written.
+                    self._buffer_size = 0
+                    self._buffer.clear()
+                    # on_write will call "maybe_resume_protocol".
+                    self._on_write()
+                    return True
+
+                if sent > 0:
+                    if UVLOOP_DEBUG:
+                        if sent == len(data):
+                            raise RuntimeError(
+                                '_try_write sent all data and returned '
+                                'non-zero')
+
+                    if PyBytes_CheckExact(data):
+                        # Cast bytes to memoryview to avoid copying
+                        # data that wasn't sent.
+                        data = memoryview(data)
+                    data = data[sent:]
+
+                    self._buffer_size -= sent
+                    self._buffer[0] = data
+
+                # At this point it's either data was sent partially,
+                # or an EAGAIN has happened.
+
+            else:
+                ctx = _StreamWriteContext.new(self, self._buffer)
+
+                err = uv.uv_try_write(<uv.uv_stream_t*>self._handle,
+                                      ctx.uv_bufs_start,
+                                      ctx.uv_bufs_len)
+
+                if err > 0:
+                    # Some data was successfully sent.
+
+                    if <size_t>err == self._buffer_size:
+                        # Everything was sent.
+                        ctx.close()
+                        self._buffer.clear()
+                        self._buffer_size = 0
+                        # on_write will call "maybe_resume_protocol".
+                        self._on_write()
+                        return True
+
+                    try:
+                        # Advance pointers to uv_bufs in `ctx`,
+                        # we will reuse it soon for a uv_write
+                        # call.
+                        ctx.advance_uv_buf(<ssize_t>err)
+                    except Exception as ex:  # This should never happen.
+                        # Let's try to close the `ctx` anyways.
+                        ctx.close()
+                        self._fatal_error(ex, True)
+                        self._buffer.clear()
+                        self._buffer_size = 0
+                        return
+
+                elif err != uv.UV_EAGAIN:
+                    ctx.close()
+                    exc = convert_error(err)
+                    self._fatal_error(exc, True)
+                    self._buffer.clear()
+                    self._buffer_size = 0
+                    return
+
+                # fall through
+
+        if ctx is None:
+            ctx = _StreamWriteContext.new(self, self._buffer)
+
+        err = uv.uv_write(&ctx.req,
+                          <uv.uv_stream_t*>self._handle,
+                          ctx.uv_bufs_start,
+                          ctx.uv_bufs_len,
+                          __uv_stream_on_write)
+
+        self._buffer_size = 0
+        # Can't use `_buffer.clear()` here: `ctx` holds a reference to
+        # the `_buffer`.
+        self._buffer = []
+
+        if err < 0:
+            # close write context
+            ctx.close()
+
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+        self._maybe_resume_protocol()
+
+    cdef size_t _get_write_buffer_size(self):
+        if self._handle is NULL:
+            return 0
+        return ((<uv.uv_stream_t*>self._handle).write_queue_size +
+                self._buffer_size)
+
+    cdef _close(self):
+        try:
+            if self._read_pybuf_acquired:
+                # Should never happen. libuv always calls uv_alloc/uv_read
+                # in pairs.
+                self._loop.call_exception_handler({
+                    'transport': self,
+                    'message': 'XXX: an allocated buffer in transport._close()'
+                })
+                self._read_pybuf_acquired = 0
+                PyBuffer_Release(&self._read_pybuf)
+
+            self._stop_reading()
+        finally:
+            UVSocketHandle._close(<UVHandle>self)
+
+    cdef inline _on_accept(self):
+        # Ultimately called by __uv_stream_on_listen.
+        self._init_protocol()
+
+    cdef inline _on_eof(self):
+        # Any exception raised here will be caught in
+        # __uv_stream_on_read.
+
+        try:
+            meth = self._protocol.eof_received
+        except AttributeError:
+            keep_open = False
+        else:
+            keep_open = run_in_context(self.context, meth)
+
+        if keep_open:
+            # We're keeping the connection open so the
+            # protocol can write more, but we still can't
+            # receive more, so remove the reader callback.
+            self._stop_reading()
+        else:
+            self.close()
+
+    cdef inline _on_write(self):
+        self._maybe_resume_protocol()
+        if not self._get_write_buffer_size():
+            if self._closing:
+                self._schedule_call_connection_lost(None)
+            elif self._eof:
+                self._shutdown()
+
+    cdef inline _init(self, Loop loop, object protocol, Server server,
+                      object waiter, object context):
+        self.context = context
+        self._set_protocol(protocol)
+        self._start_init(loop)
+
+        if server is not None:
+            self._set_server(server)
+
+        if waiter is not None:
+            self._set_waiter(waiter)
+
+    cdef inline _on_connect(self, object exc):
+        # Called from __tcp_connect_callback (tcp.pyx) and
+        # __pipe_connect_callback (pipe.pyx).
+        if exc is None:
+            self._init_protocol()
+        else:
+            if self._waiter is None:
+                self._fatal_error(exc, False, "connect failed")
+            elif self._waiter.cancelled():
+                # Connect call was cancelled; just close the transport
+                # silently.
+                self._close()
+            elif self._waiter.done():
+                self._fatal_error(exc, False, "connect failed")
+            else:
+                self._waiter.set_exception(exc)
+                self._close()
+
+    # === Public API ===
+
+    def __repr__(self):
+        return '<{} closed={} reading={} {:#x}>'.format(
+            self.__class__.__name__,
+            self._closed,
+            self.__reading,
+            id(self))
+
+    def write(self, object buf):
+        self._ensure_alive()
+
+        if self._eof:
+            raise RuntimeError('Cannot call write() after write_eof()')
+        if not buf:
+            return
+        if self._conn_lost:
+            self._conn_lost += 1
+            return
+        self._write(buf)
+
+    def writelines(self, bufs):
+        self._ensure_alive()
+
+        if self._eof:
+            raise RuntimeError('Cannot call writelines() after write_eof()')
+        if self._conn_lost:
+            self._conn_lost += 1
+            return
+        for buf in bufs:
+            self._write(buf)
+
+    def write_eof(self):
+        self._ensure_alive()
+
+        if self._eof:
+            return
+
+        self._eof = 1
+        if not self._get_write_buffer_size():
+            self._shutdown()
+
+    def can_write_eof(self):
+        return True
+
+    def is_reading(self):
+        return self._is_reading()
+
+    def pause_reading(self):
+        if self._closing or not self._is_reading():
+            return
+        self._stop_reading()
+
+    def resume_reading(self):
+        if self._is_reading() or self._closing:
+            return
+        self._start_reading()
+
+
+cdef void __uv_stream_on_shutdown(uv.uv_shutdown_t* req,
+                                  int status) with gil:
+
+    # callback for uv_shutdown
+
+    if req.data is NULL:
+        aio_logger.error(
+            'UVStream.shutdown callback called with NULL req.data, status=%r',
+            status)
+        return
+
+    cdef UVStream stream = <UVStream> req.data
+
+    if status < 0 and status != uv.UV_ECANCELED:
+        # From libuv source code:
+        #     The ECANCELED error code is a lie, the shutdown(2) syscall is a
+        #     fait accompli at this point. Maybe we should revisit this in
+        #     v0.11.  A possible reason for leaving it unchanged is that it
+        #     informs the callee that the handle has been destroyed.
+
+        if UVLOOP_DEBUG:
+            stream._loop._debug_stream_shutdown_errors_total += 1
+
+        exc = convert_error(status)
+        stream._fatal_error(
+            exc, False, "error status in uv_stream_t.shutdown callback")
+        return
+
+
+cdef inline bint __uv_stream_on_read_common(UVStream sc, Loop loop,
+                                            ssize_t nread):
+    if sc._closed:
+        # The stream was closed, there is no reason to
+        # do any work now.
+        sc.__reading_stopped()  # Just in case.
+        return True
+
+    if nread == uv.UV_EOF:
+        # From libuv docs:
+        #     The callee is responsible for stopping closing the stream
+        #     when an error happens by calling uv_read_stop() or uv_close().
+        #     Trying to read from the stream again is undefined.
+        try:
+            if UVLOOP_DEBUG:
+                loop._debug_stream_read_eof_total += 1
+
+            sc._stop_reading()
+            sc._on_eof()
+        except BaseException as ex:
+            if UVLOOP_DEBUG:
+                loop._debug_stream_read_eof_cb_errors_total += 1
+
+            sc._fatal_error(ex, False)
+        finally:
+            return True
+
+    if nread == 0:
+        # From libuv docs:
+        #     nread might be 0, which does not indicate an error or EOF.
+        #     This is equivalent to EAGAIN or EWOULDBLOCK under read(2).
+        return True
+
+    if nread < 0:
+        # From libuv docs:
+        #     The callee is responsible for stopping closing the stream
+        #     when an error happens by calling uv_read_stop() or uv_close().
+        #     Trying to read from the stream again is undefined.
+        #
+        # Therefore, we're closing the stream.  Since "UVHandle._close()"
+        # doesn't raise exceptions unless uvloop is built with DEBUG=1,
+        # we don't need try...finally here.
+
+        if UVLOOP_DEBUG:
+            loop._debug_stream_read_errors_total += 1
+
+        if sc.__read_error_close:
+            # Used for getting notified when a pipe is closed.
+            # See WriteUnixTransport for the explanation.
+            sc._on_eof()
+            return True
+
+        exc = convert_error(nread)
+        sc._fatal_error(
+            exc, False, "error status in uv_stream_t.read callback")
+        return True
+
+    return False
+
+
+cdef inline void __uv_stream_on_read_impl(uv.uv_stream_t* stream,
+                                          ssize_t nread,
+                                          const uv.uv_buf_t* buf):
+    cdef:
+        UVStream sc = <UVStream>stream.data
+        Loop loop = sc._loop
+
+    # It's OK to free the buffer early, since nothing will
+    # be able to touch it until this method is done.
+    __loop_free_buffer(loop)
+
+    if __uv_stream_on_read_common(sc, loop, nread):
+        return
+
+    try:
+        if UVLOOP_DEBUG:
+            loop._debug_stream_read_cb_total += 1
+
+        run_in_context1(
+            sc.context,
+            sc._protocol_data_received,
+            loop._recv_buffer[:nread],
+        )
+    except BaseException as exc:
+        if UVLOOP_DEBUG:
+            loop._debug_stream_read_cb_errors_total += 1
+
+        sc._fatal_error(exc, False)
+
+
+cdef inline void __uv_stream_on_write_impl(uv.uv_write_t* req, int status):
+    cdef:
+        _StreamWriteContext ctx = <_StreamWriteContext> req.data
+        UVStream stream = <UVStream>ctx.stream
+
+    ctx.close()
+
+    if stream._closed:
+        # The stream was closed, there is nothing to do.
+        # Even if there is an error, like EPIPE, there
+        # is no reason to report it.
+        return
+
+    if status < 0:
+        if UVLOOP_DEBUG:
+            stream._loop._debug_stream_write_errors_total += 1
+
+        exc = convert_error(status)
+        stream._fatal_error(
+            exc, False, "error status in uv_stream_t.write callback")
+        return
+
+    try:
+        stream._on_write()
+    except BaseException as exc:
+        if UVLOOP_DEBUG:
+            stream._loop._debug_stream_write_cb_errors_total += 1
+
+        stream._fatal_error(exc, False)
+
+
+cdef void __uv_stream_on_read(uv.uv_stream_t* stream,
+                              ssize_t nread,
+                              const uv.uv_buf_t* buf) with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>stream,
+                            "UVStream read callback") == 0:
+        return
+
+    # Don't need try-finally, __uv_stream_on_read_impl is void
+    __uv_stream_on_read_impl(stream, nread, buf)
+
+
+cdef void __uv_stream_on_write(uv.uv_write_t* req, int status) with gil:
+
+    if UVLOOP_DEBUG:
+        if req.data is NULL:
+            aio_logger.error(
+                'UVStream.write callback called with NULL req.data, status=%r',
+                status)
+            return
+
+    # Don't need try-finally, __uv_stream_on_write_impl is void
+    __uv_stream_on_write_impl(req, status)
+
+
+cdef void __uv_stream_buffered_alloc(uv.uv_handle_t* stream,
+                                     size_t suggested_size,
+                                     uv.uv_buf_t* uvbuf) with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>stream,
+                            "UVStream alloc buffer callback") == 0:
+        return
+
+    cdef:
+        UVStream sc = <UVStream>stream.data
+        Loop loop = sc._loop
+        Py_buffer* pybuf = &sc._read_pybuf
+        int got_buf = 0
+
+    if sc._read_pybuf_acquired:
+        uvbuf.len = 0
+        uvbuf.base = NULL
+        return
+
+    sc._read_pybuf_acquired = 0
+    try:
+        buf = run_in_context1(
+            sc.context,
+            sc._protocol_get_buffer,
+            suggested_size,
+        )
+        PyObject_GetBuffer(buf, pybuf, PyBUF_WRITABLE)
+        got_buf = 1
+    except BaseException as exc:
+        # Can't call 'sc._fatal_error' or 'sc._close', libuv will SF.
+        # We'll do it later in __uv_stream_buffered_on_read when we
+        # receive UV_ENOBUFS.
+        uvbuf.len = 0
+        uvbuf.base = NULL
+        return
+
+    if not pybuf.len:
+        uvbuf.len = 0
+        uvbuf.base = NULL
+        if got_buf:
+            PyBuffer_Release(pybuf)
+        return
+
+    sc._read_pybuf_acquired = 1
+    uvbuf.base = <char*>pybuf.buf
+    uvbuf.len = pybuf.len
+
+
+cdef void __uv_stream_buffered_on_read(uv.uv_stream_t* stream,
+                                       ssize_t nread,
+                                       const uv.uv_buf_t* buf) with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>stream,
+                            "UVStream buffered read callback") == 0:
+        return
+
+    cdef:
+        UVStream sc = <UVStream>stream.data
+        Loop loop = sc._loop
+        Py_buffer* pybuf = &sc._read_pybuf
+
+    if nread == uv.UV_ENOBUFS:
+        sc._fatal_error(
+            RuntimeError(
+                'unhandled error (or an empty buffer) in get_buffer()'),
+            False)
+        return
+
+    try:
+        if nread > 0 and not sc._read_pybuf_acquired:
+            # From libuv docs:
+            #     nread is > 0 if there is data available or < 0 on error. When
+            #     we’ve reached EOF, nread will be set to UV_EOF. When
+            #     nread < 0, the buf parameter might not point to a valid
+            #     buffer; in that case buf.len and buf.base are both set to 0.
+            raise RuntimeError(
+                f'no python buffer is allocated in on_read; nread={nread}')
+
+        if nread == 0:
+            # From libuv docs:
+            #     nread might be 0, which does not indicate an error or EOF.
+            #     This is equivalent to EAGAIN or EWOULDBLOCK under read(2).
+            return
+
+        if __uv_stream_on_read_common(sc, loop, nread):
+            return
+
+        if UVLOOP_DEBUG:
+            loop._debug_stream_read_cb_total += 1
+
+        run_in_context1(sc.context, sc._protocol_buffer_updated, nread)
+    except BaseException as exc:
+        if UVLOOP_DEBUG:
+            loop._debug_stream_read_cb_errors_total += 1
+
+        sc._fatal_error(exc, False)
+    finally:
+        sc._read_pybuf_acquired = 0
+        PyBuffer_Release(pybuf)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/streamserver.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/streamserver.pxd
new file mode 100644
index 0000000..a004efd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/streamserver.pxd
@@ -0,0 +1,26 @@
+cdef class UVStreamServer(UVSocketHandle):
+    cdef:
+        int backlog
+        object ssl
+        object ssl_handshake_timeout
+        object ssl_shutdown_timeout
+        object protocol_factory
+        bint opened
+        Server _server
+
+    # All "inline" methods are final
+
+    cdef inline _init(self, Loop loop, object protocol_factory,
+                      Server server,
+                      object backlog,
+                      object ssl,
+                      object ssl_handshake_timeout,
+                      object ssl_shutdown_timeout)
+
+    cdef inline _mark_as_open(self)
+
+    cdef inline listen(self)
+    cdef inline _on_listen(self)
+
+    cdef UVStream _make_new_transport(self, object protocol, object waiter,
+                                      object context)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/streamserver.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/streamserver.pyx
new file mode 100644
index 0000000..6e0f357
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/streamserver.pyx
@@ -0,0 +1,148 @@
+@cython.no_gc_clear
+cdef class UVStreamServer(UVSocketHandle):
+
+    def __cinit__(self):
+        self.opened = 0
+        self._server = None
+        self.ssl = None
+        self.ssl_handshake_timeout = None
+        self.ssl_shutdown_timeout = None
+        self.protocol_factory = None
+
+    cdef inline _init(self, Loop loop, object protocol_factory,
+                      Server server,
+                      object backlog,
+                      object ssl,
+                      object ssl_handshake_timeout,
+                      object ssl_shutdown_timeout):
+
+        if not isinstance(backlog, int):
+            # Don't allow floats
+            raise TypeError('integer argument expected, got {}'.format(
+                type(backlog).__name__))
+
+        if ssl is not None:
+            if not isinstance(ssl, ssl_SSLContext):
+                raise TypeError(
+                    'ssl is expected to be None or an instance of '
+                    'ssl.SSLContext, got {!r}'.format(ssl))
+        else:
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        self.backlog = backlog
+        self.ssl = ssl
+        self.ssl_handshake_timeout = ssl_handshake_timeout
+        self.ssl_shutdown_timeout = ssl_shutdown_timeout
+
+        self._start_init(loop)
+        self.protocol_factory = protocol_factory
+        self._server = server
+
+    cdef inline listen(self):
+        cdef int err
+        self._ensure_alive()
+
+        if self.protocol_factory is None:
+            raise RuntimeError('unable to listen(); no protocol_factory')
+
+        if self.opened != 1:
+            raise RuntimeError('unopened TCPServer')
+
+        self.context = Context_CopyCurrent()
+
+        err = uv.uv_listen(<uv.uv_stream_t*> self._handle,
+                           self.backlog,
+                           __uv_streamserver_on_listen)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+    cdef inline _on_listen(self):
+        cdef UVStream client
+
+        protocol = run_in_context(self.context, self.protocol_factory)
+
+        if self.ssl is None:
+            client = self._make_new_transport(protocol, None, self.context)
+
+        else:
+            waiter = self._loop._new_future()
+
+            ssl_protocol = SSLProtocol(
+                self._loop, protocol, self.ssl,
+                waiter,
+                server_side=True,
+                server_hostname=None,
+                ssl_handshake_timeout=self.ssl_handshake_timeout,
+                ssl_shutdown_timeout=self.ssl_shutdown_timeout)
+
+            client = self._make_new_transport(ssl_protocol, None, self.context)
+
+            waiter.add_done_callback(
+                ft_partial(self.__on_ssl_connected, client))
+
+        client._accept(<UVStream>self)
+
+    cdef _fatal_error(self, exc, throw, reason=None):
+        # Overload UVHandle._fatal_error
+
+        self._close()
+
+        if not isinstance(exc, OSError):
+
+            if throw or self._loop is None:
+                raise exc
+
+            msg = f'Fatal error on server {self.__class__.__name__}'
+            if reason is not None:
+                msg = f'{msg} ({reason})'
+
+            self._loop.call_exception_handler({
+                'message': msg,
+                'exception': exc,
+            })
+
+    cdef inline _mark_as_open(self):
+        self.opened = 1
+
+    cdef UVStream _make_new_transport(self, object protocol, object waiter,
+                                      object context):
+        raise NotImplementedError
+
+    def __on_ssl_connected(self, transport, fut):
+        exc = fut.exception()
+        if exc is not None:
+            transport._force_close(exc)
+
+
+cdef void __uv_streamserver_on_listen(uv.uv_stream_t* handle,
+                                      int status) with gil:
+
+    # callback for uv_listen
+
+    if __ensure_handle_data(<uv.uv_handle_t*>handle,
+                            "UVStream listen callback") == 0:
+        return
+
+    cdef:
+        UVStreamServer stream = <UVStreamServer> handle.data
+
+    if status < 0:
+        if UVLOOP_DEBUG:
+            stream._loop._debug_stream_listen_errors_total += 1
+
+        exc = convert_error(status)
+        stream._fatal_error(
+            exc, False, "error status in uv_stream_t.listen callback")
+        return
+
+    try:
+        stream._on_listen()
+    except BaseException as exc:
+        stream._error(exc, False)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/tcp.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/tcp.pxd
new file mode 100644
index 0000000..8d388ef
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/tcp.pxd
@@ -0,0 +1,26 @@
+cdef class TCPServer(UVStreamServer):
+    cdef bind(self, system.sockaddr* addr, unsigned int flags=*)
+
+    @staticmethod
+    cdef TCPServer new(Loop loop, object protocol_factory, Server server,
+                       unsigned int flags,
+                       object backlog,
+                       object ssl,
+                       object ssl_handshake_timeout,
+                       object ssl_shutdown_timeout)
+
+
+cdef class TCPTransport(UVStream):
+    cdef:
+        bint __peername_set
+        bint __sockname_set
+        system.sockaddr_storage __peername
+        system.sockaddr_storage __sockname
+
+    cdef bind(self, system.sockaddr* addr, unsigned int flags=*)
+    cdef connect(self, system.sockaddr* addr)
+    cdef _set_nodelay(self)
+
+    @staticmethod
+    cdef TCPTransport new(Loop loop, object protocol, Server server,
+                          object waiter, object context)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/tcp.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/tcp.pyx
new file mode 100644
index 0000000..8c65f69
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/tcp.pyx
@@ -0,0 +1,225 @@
+cdef __tcp_init_uv_handle(UVStream handle, Loop loop, unsigned int flags):
+    cdef int err
+
+    handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_tcp_t))
+    if handle._handle is NULL:
+        handle._abort_init()
+        raise MemoryError()
+
+    err = uv.uv_tcp_init_ex(handle._loop.uvloop,
+                            <uv.uv_tcp_t*>handle._handle,
+                            flags)
+    if err < 0:
+        handle._abort_init()
+        raise convert_error(err)
+
+    handle._finish_init()
+
+
+cdef __tcp_bind(UVStream handle, system.sockaddr* addr, unsigned int flags):
+    cdef int err
+    err = uv.uv_tcp_bind(<uv.uv_tcp_t *>handle._handle,
+                         addr, flags)
+    if err < 0:
+        exc = convert_error(err)
+        raise exc
+
+
+cdef __tcp_open(UVStream handle, int sockfd):
+    cdef int err
+    err = uv.uv_tcp_open(<uv.uv_tcp_t *>handle._handle,
+                         <uv.uv_os_sock_t>sockfd)
+    if err < 0:
+        exc = convert_error(err)
+        raise exc
+
+
+cdef __tcp_get_socket(UVSocketHandle handle):
+    cdef:
+        int buf_len = sizeof(system.sockaddr_storage)
+        int fileno
+        int err
+        system.sockaddr_storage buf
+
+    fileno = handle._fileno()
+
+    err = uv.uv_tcp_getsockname(<uv.uv_tcp_t*>handle._handle,
+                                <system.sockaddr*>&buf,
+                                &buf_len)
+    if err < 0:
+        raise convert_error(err)
+
+    return PseudoSocket(buf.ss_family, uv.SOCK_STREAM, 0, fileno)
+
+
+@cython.no_gc_clear
+cdef class TCPServer(UVStreamServer):
+
+    @staticmethod
+    cdef TCPServer new(Loop loop, object protocol_factory, Server server,
+                       unsigned int flags,
+                       object backlog,
+                       object ssl,
+                       object ssl_handshake_timeout,
+                       object ssl_shutdown_timeout):
+
+        cdef TCPServer handle
+        handle = TCPServer.__new__(TCPServer)
+        handle._init(loop, protocol_factory, server, backlog,
+                     ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+        __tcp_init_uv_handle(<UVStream>handle, loop, flags)
+        return handle
+
+    cdef _new_socket(self):
+        return __tcp_get_socket(<UVSocketHandle>self)
+
+    cdef _open(self, int sockfd):
+        self._ensure_alive()
+        try:
+            __tcp_open(<UVStream>self, sockfd)
+        except Exception as exc:
+            self._fatal_error(exc, True)
+        else:
+            self._mark_as_open()
+
+    cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+        self._ensure_alive()
+        try:
+            __tcp_bind(<UVStream>self, addr, flags)
+        except Exception as exc:
+            self._fatal_error(exc, True)
+        else:
+            self._mark_as_open()
+
+    cdef UVStream _make_new_transport(self, object protocol, object waiter,
+                                      object context):
+        cdef TCPTransport tr
+        tr = TCPTransport.new(self._loop, protocol, self._server, waiter,
+                              context)
+        return <UVStream>tr
+
+
+@cython.no_gc_clear
+cdef class TCPTransport(UVStream):
+
+    @staticmethod
+    cdef TCPTransport new(Loop loop, object protocol, Server server,
+                          object waiter, object context):
+
+        cdef TCPTransport handle
+        handle = TCPTransport.__new__(TCPTransport)
+        handle._init(loop, protocol, server, waiter, context)
+        __tcp_init_uv_handle(<UVStream>handle, loop, uv.AF_UNSPEC)
+        handle.__peername_set = 0
+        handle.__sockname_set = 0
+        handle._set_nodelay()
+        return handle
+
+    cdef _set_nodelay(self):
+        cdef int err
+        self._ensure_alive()
+        err = uv.uv_tcp_nodelay(<uv.uv_tcp_t*>self._handle, 1)
+        if err < 0:
+            raise convert_error(err)
+
+    cdef _call_connection_made(self):
+        # asyncio saves peername & sockname when transports are instantiated,
+        # so that they're accessible even after the transport is closed.
+        # We are doing the same thing here, except that we create Python
+        # objects lazily, on request in get_extra_info()
+
+        cdef:
+            int err
+            int buf_len
+
+        buf_len = sizeof(system.sockaddr_storage)
+        err = uv.uv_tcp_getsockname(<uv.uv_tcp_t*>self._handle,
+                                    <system.sockaddr*>&self.__sockname,
+                                    &buf_len)
+        if err >= 0:
+            # Ignore errors, this is an optional thing.
+            # If something serious is going on, the transport
+            # will crash later (in roughly the same way how
+            # an asyncio transport would.)
+            self.__sockname_set = 1
+
+        buf_len = sizeof(system.sockaddr_storage)
+        err = uv.uv_tcp_getpeername(<uv.uv_tcp_t*>self._handle,
+                                    <system.sockaddr*>&self.__peername,
+                                    &buf_len)
+        if err >= 0:
+            # Same as few lines above -- we don't really care
+            # about error case here.
+            self.__peername_set = 1
+
+        UVBaseTransport._call_connection_made(self)
+
+    def get_extra_info(self, name, default=None):
+        if name == 'sockname':
+            if self.__sockname_set:
+                return __convert_sockaddr_to_pyaddr(
+                    <system.sockaddr*>&self.__sockname)
+        elif name == 'peername':
+            if self.__peername_set:
+                return __convert_sockaddr_to_pyaddr(
+                    <system.sockaddr*>&self.__peername)
+        return super().get_extra_info(name, default)
+
+    cdef _new_socket(self):
+        return __tcp_get_socket(<UVSocketHandle>self)
+
+    cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+        self._ensure_alive()
+        __tcp_bind(<UVStream>self, addr, flags)
+
+    cdef _open(self, int sockfd):
+        self._ensure_alive()
+        __tcp_open(<UVStream>self, sockfd)
+
+    cdef connect(self, system.sockaddr* addr):
+        cdef _TCPConnectRequest req
+        req = _TCPConnectRequest(self._loop, self)
+        req.connect(addr)
+
+
+cdef class _TCPConnectRequest(UVRequest):
+    cdef:
+        TCPTransport transport
+        uv.uv_connect_t _req_data
+
+    def __cinit__(self, loop, transport):
+        self.request = <uv.uv_req_t*>&self._req_data
+        self.request.data = <void*>self
+        self.transport = transport
+
+    cdef connect(self, system.sockaddr* addr):
+        cdef int err
+        err = uv.uv_tcp_connect(<uv.uv_connect_t*>self.request,
+                                <uv.uv_tcp_t*>self.transport._handle,
+                                addr,
+                                __tcp_connect_callback)
+        if err < 0:
+            exc = convert_error(err)
+            self.on_done()
+            raise exc
+
+
+cdef void __tcp_connect_callback(uv.uv_connect_t* req, int status) with gil:
+    cdef:
+        _TCPConnectRequest wrapper
+        TCPTransport transport
+
+    wrapper = <_TCPConnectRequest> req.data
+    transport = wrapper.transport
+
+    if status < 0:
+        exc = convert_error(status)
+    else:
+        exc = None
+
+    try:
+        transport._on_connect(exc)
+    except BaseException as ex:
+        wrapper.transport._fatal_error(ex, False)
+    finally:
+        wrapper.on_done()
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/timer.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/timer.pxd
new file mode 100644
index 0000000..fda23b6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/timer.pxd
@@ -0,0 +1,18 @@
+cdef class UVTimer(UVHandle):
+    cdef:
+        method_t callback
+        object ctx
+        bint running
+        uint64_t timeout
+        uint64_t start_t
+
+    cdef _init(self, Loop loop, method_t callback, object ctx,
+               uint64_t timeout)
+
+    cdef stop(self)
+    cdef start(self)
+    cdef get_when(self)
+
+    @staticmethod
+    cdef UVTimer new(Loop loop, method_t callback, object ctx,
+                     uint64_t timeout)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/timer.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/timer.pyx
new file mode 100644
index 0000000..6ea5ff5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/timer.pyx
@@ -0,0 +1,87 @@
+@cython.no_gc_clear
+cdef class UVTimer(UVHandle):
+    cdef _init(self, Loop loop, method_t callback, object ctx,
+               uint64_t timeout):
+
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*> PyMem_RawMalloc(sizeof(uv.uv_timer_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_timer_init(self._loop.uvloop, <uv.uv_timer_t*>self._handle)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.callback = callback
+        self.ctx = ctx
+        self.running = 0
+        self.timeout = timeout
+        self.start_t = 0
+
+    cdef stop(self):
+        cdef int err
+
+        if not self._is_alive():
+            self.running = 0
+            return
+
+        if self.running == 1:
+            err = uv.uv_timer_stop(<uv.uv_timer_t*>self._handle)
+            self.running = 0
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+
+    cdef start(self):
+        cdef int err
+
+        self._ensure_alive()
+
+        if self.running == 0:
+            # Update libuv internal time.
+            uv.uv_update_time(self._loop.uvloop)  # void
+            self.start_t = uv.uv_now(self._loop.uvloop)
+
+            err = uv.uv_timer_start(<uv.uv_timer_t*>self._handle,
+                                    __uvtimer_callback,
+                                    self.timeout, 0)
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+            self.running = 1
+
+    cdef get_when(self):
+        return self.start_t + self.timeout
+
+    @staticmethod
+    cdef UVTimer new(Loop loop, method_t callback, object ctx,
+                     uint64_t timeout):
+
+        cdef UVTimer handle
+        handle = UVTimer.__new__(UVTimer)
+        handle._init(loop, callback, ctx, timeout)
+        return handle
+
+
+cdef void __uvtimer_callback(uv.uv_timer_t* handle) with gil:
+    if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVTimer callback") == 0:
+        return
+
+    cdef:
+        UVTimer timer = <UVTimer> handle.data
+        method_t cb = timer.callback
+
+    timer.running = 0
+    try:
+        cb(timer.ctx)
+    except BaseException as ex:
+        timer._error(ex, False)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/udp.pxd b/myenv/lib/python3.9/site-packages/uvloop/handles/udp.pxd
new file mode 100644
index 0000000..daa9a1b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/udp.pxd
@@ -0,0 +1,22 @@
+cdef class UDPTransport(UVBaseTransport):
+    cdef:
+        bint __receiving
+        int _family
+        object _address
+
+    cdef _init(self, Loop loop, unsigned int family)
+    cdef _set_address(self, system.addrinfo *addr)
+
+    cdef _connect(self, system.sockaddr* addr, size_t addr_len)
+
+    cdef _bind(self, system.sockaddr* addr)
+    cdef open(self, int family, int sockfd)
+    cdef _set_broadcast(self, bint on)
+
+    cdef inline __receiving_started(self)
+    cdef inline __receiving_stopped(self)
+
+    cdef _send(self, object data, object addr)
+
+    cdef _on_receive(self, bytes data, object exc, object addr)
+    cdef _on_sent(self, object exc, object context=*)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/handles/udp.pyx b/myenv/lib/python3.9/site-packages/uvloop/handles/udp.pyx
new file mode 100644
index 0000000..b92fdfd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/handles/udp.pyx
@@ -0,0 +1,404 @@
+@cython.no_gc_clear
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class _UDPSendContext:
+    # used to hold additional write request information for uv_write
+
+    cdef:
+        uv.uv_udp_send_t   req
+
+        uv.uv_buf_t     uv_buf
+        Py_buffer       py_buf
+
+        UDPTransport    udp
+
+        bint            closed
+
+    cdef close(self):
+        if self.closed:
+            return
+
+        self.closed = 1
+        PyBuffer_Release(&self.py_buf)  # void
+        self.req.data = NULL
+        self.uv_buf.base = NULL
+        Py_DECREF(self)
+        self.udp = None
+
+    @staticmethod
+    cdef _UDPSendContext new(UDPTransport udp, object data):
+        cdef _UDPSendContext ctx
+        ctx = _UDPSendContext.__new__(_UDPSendContext)
+        ctx.udp = None
+        ctx.closed = 1
+
+        ctx.req.data = <void*> ctx
+        Py_INCREF(ctx)
+
+        PyObject_GetBuffer(data, &ctx.py_buf, PyBUF_SIMPLE)
+        ctx.uv_buf.base = <char*>ctx.py_buf.buf
+        ctx.uv_buf.len = ctx.py_buf.len
+        ctx.udp = udp
+
+        ctx.closed = 0
+        return ctx
+
+    def __dealloc__(self):
+        if UVLOOP_DEBUG:
+            if not self.closed:
+                raise RuntimeError(
+                    'open _UDPSendContext is being deallocated')
+        self.udp = None
+
+
+@cython.no_gc_clear
+cdef class UDPTransport(UVBaseTransport):
+    def __cinit__(self):
+        self._family = uv.AF_UNSPEC
+        self.__receiving = 0
+        self._address = None
+        self.context = Context_CopyCurrent()
+
+    cdef _init(self, Loop loop, unsigned int family):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_udp_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_udp_init_ex(loop.uvloop,
+                                <uv.uv_udp_t*>self._handle,
+                                family)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        if family in (uv.AF_INET, uv.AF_INET6):
+            self._family = family
+
+        self._finish_init()
+
+    cdef _set_address(self, system.addrinfo *addr):
+        self._address = __convert_sockaddr_to_pyaddr(addr.ai_addr)
+
+    cdef _connect(self, system.sockaddr* addr, size_t addr_len):
+        cdef int err
+        err = uv.uv_udp_connect(<uv.uv_udp_t*>self._handle, addr)
+        if err < 0:
+            exc = convert_error(err)
+            raise exc
+
+    cdef open(self, int family, int sockfd):
+        if family in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+            self._family = family
+        else:
+            raise ValueError(
+                'cannot open a UDP handle, invalid family {}'.format(family))
+
+        cdef int err
+        err = uv.uv_udp_open(<uv.uv_udp_t*>self._handle,
+                             <uv.uv_os_sock_t>sockfd)
+
+        if err < 0:
+            exc = convert_error(err)
+            raise exc
+
+    cdef _bind(self, system.sockaddr* addr):
+        cdef:
+            int err
+            int flags = 0
+
+        self._ensure_alive()
+
+        err = uv.uv_udp_bind(<uv.uv_udp_t*>self._handle, addr, flags)
+        if err < 0:
+            exc = convert_error(err)
+            raise exc
+
+    cdef _set_broadcast(self, bint on):
+        cdef int err
+
+        self._ensure_alive()
+
+        err = uv.uv_udp_set_broadcast(<uv.uv_udp_t*>self._handle, on)
+        if err < 0:
+            exc = convert_error(err)
+            raise exc
+
+    cdef size_t _get_write_buffer_size(self):
+        if self._handle is NULL:
+            return 0
+        return (<uv.uv_udp_t*>self._handle).send_queue_size
+
+    cdef bint _is_reading(self):
+        return self.__receiving
+
+    cdef _start_reading(self):
+        cdef int err
+
+        if self.__receiving:
+            return
+
+        self._ensure_alive()
+
+        err = uv.uv_udp_recv_start(<uv.uv_udp_t*>self._handle,
+                                   __loop_alloc_buffer,
+                                   __uv_udp_on_receive)
+
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+        else:
+            # UDPTransport must live until the read callback is called
+            self.__receiving_started()
+
+    cdef _stop_reading(self):
+        cdef int err
+
+        if not self.__receiving:
+            return
+
+        self._ensure_alive()
+
+        err = uv.uv_udp_recv_stop(<uv.uv_udp_t*>self._handle)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+        else:
+            self.__receiving_stopped()
+
+    cdef inline __receiving_started(self):
+        if self.__receiving:
+            return
+        self.__receiving = 1
+        Py_INCREF(self)
+
+    cdef inline __receiving_stopped(self):
+        if not self.__receiving:
+            return
+        self.__receiving = 0
+        Py_DECREF(self)
+
+    cdef _new_socket(self):
+        if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+            raise RuntimeError(
+                'UDPTransport.family is undefined; '
+                'cannot create python socket')
+
+        fileno = self._fileno()
+        return PseudoSocket(self._family, uv.SOCK_DGRAM, 0, fileno)
+
+    cdef _send(self, object data, object addr):
+        cdef:
+            _UDPSendContext ctx
+            system.sockaddr_storage saddr_st
+            system.sockaddr *saddr
+            Py_buffer       try_pybuf
+            uv.uv_buf_t     try_uvbuf
+
+        self._ensure_alive()
+
+        if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+            raise RuntimeError('UDPTransport.family is undefined; cannot send')
+
+        if addr is None:
+            saddr = NULL
+        else:
+            try:
+                __convert_pyaddr_to_sockaddr(self._family, addr,
+                                             <system.sockaddr*>&saddr_st)
+            except (ValueError, TypeError):
+                raise
+            except Exception:
+                raise ValueError(
+                    f'{addr!r}: socket family mismatch or '
+                    f'a DNS lookup is required')
+            saddr = <system.sockaddr*>(&saddr_st)
+
+        if self._get_write_buffer_size() == 0:
+            PyObject_GetBuffer(data, &try_pybuf, PyBUF_SIMPLE)
+            try_uvbuf.base = <char*>try_pybuf.buf
+            try_uvbuf.len = try_pybuf.len
+            err = uv.uv_udp_try_send(<uv.uv_udp_t*>self._handle,
+                                     &try_uvbuf,
+                                     1,
+                                     saddr)
+            PyBuffer_Release(&try_pybuf)
+        else:
+            err = uv.UV_EAGAIN
+
+        if err == uv.UV_EAGAIN:
+            ctx = _UDPSendContext.new(self, data)
+            err = uv.uv_udp_send(&ctx.req,
+                                 <uv.uv_udp_t*>self._handle,
+                                 &ctx.uv_buf,
+                                 1,
+                                 saddr,
+                                 __uv_udp_on_send)
+
+            if err < 0:
+                ctx.close()
+
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+            else:
+                self._maybe_pause_protocol()
+
+        else:
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+            else:
+                self._on_sent(None, self.context.copy())
+
+    cdef _on_receive(self, bytes data, object exc, object addr):
+        if exc is None:
+            run_in_context2(
+                self.context, self._protocol.datagram_received, data, addr,
+            )
+        else:
+            run_in_context1(self.context, self._protocol.error_received, exc)
+
+    cdef _on_sent(self, object exc, object context=None):
+        if exc is not None:
+            if isinstance(exc, OSError):
+                if context is None:
+                    context = self.context
+                run_in_context1(context, self._protocol.error_received, exc)
+            else:
+                self._fatal_error(
+                    exc, False, 'Fatal write error on datagram transport')
+
+        self._maybe_resume_protocol()
+        if not self._get_write_buffer_size():
+            if self._closing:
+                self._schedule_call_connection_lost(None)
+
+    # === Public API ===
+
+    def sendto(self, data, addr=None):
+        if not data:
+            # Replicating asyncio logic here.
+            return
+
+        if self._address:
+            if addr not in (None, self._address):
+                # Replicating asyncio logic here.
+                raise ValueError(
+                    'Invalid address: must be None or %s' % (self._address,))
+
+            # Instead of setting addr to self._address below like what asyncio
+            # does, we depend on previous uv_udp_connect() to set the address
+            addr = None
+
+        if self._conn_lost:
+            # Replicating asyncio logic here.
+            if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+                aio_logger.warning('socket.send() raised exception.')
+            self._conn_lost += 1
+            return
+
+        self._send(data, addr)
+
+
+cdef void __uv_udp_on_receive(uv.uv_udp_t* handle,
+                              ssize_t nread,
+                              const uv.uv_buf_t* buf,
+                              const system.sockaddr* addr,
+                              unsigned flags) with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>handle,
+                            "UDPTransport receive callback") == 0:
+        return
+
+    cdef:
+        UDPTransport udp = <UDPTransport>handle.data
+        Loop loop = udp._loop
+        bytes data
+        object pyaddr
+
+    # It's OK to free the buffer early, since nothing will
+    # be able to touch it until this method is done.
+    __loop_free_buffer(loop)
+
+    if udp._closed:
+        # The handle was closed, there is no reason to
+        # do any work now.
+        udp.__receiving_stopped()  # Just in case.
+        return
+
+    if addr is NULL and nread == 0:
+        # From libuv docs:
+        #      addr: struct sockaddr* containing the address
+        #      of the sender. Can be NULL. Valid for the duration
+        #      of the callback only.
+        #      [...]
+        #      The receive callback will be called with
+        #      nread == 0 and addr == NULL when there is
+        #      nothing to read, and with nread == 0 and
+        #      addr != NULL when an empty UDP packet is
+        #      received.
+        return
+
+    if addr is NULL:
+        pyaddr = None
+    elif addr.sa_family == uv.AF_UNSPEC:
+        # https://github.com/MagicStack/uvloop/issues/304
+        IF UNAME_SYSNAME == "Linux":
+            pyaddr = None
+        ELSE:
+            pyaddr = ''
+    else:
+        try:
+            pyaddr = __convert_sockaddr_to_pyaddr(addr)
+        except BaseException as exc:
+            udp._error(exc, False)
+            return
+
+    if nread < 0:
+        exc = convert_error(nread)
+        udp._on_receive(None, exc, pyaddr)
+        return
+
+    if nread == 0:
+        data = b''
+    else:
+        data = loop._recv_buffer[:nread]
+
+    try:
+        udp._on_receive(data, None, pyaddr)
+    except BaseException as exc:
+        udp._error(exc, False)
+
+
+cdef void __uv_udp_on_send(uv.uv_udp_send_t* req, int status) with gil:
+
+    if req.data is NULL:
+        # Shouldn't happen as:
+        #    - _UDPSendContext does an extra INCREF in its 'init()'
+        #    - _UDPSendContext holds a ref to the relevant UDPTransport
+        aio_logger.error(
+            'UVStream.write callback called with NULL req.data, status=%r',
+            status)
+        return
+
+    cdef:
+        _UDPSendContext ctx = <_UDPSendContext> req.data
+        UDPTransport udp = <UDPTransport>ctx.udp
+
+    ctx.close()
+
+    if status < 0:
+        exc = convert_error(status)
+        print(exc)
+    else:
+        exc = None
+
+    try:
+        udp._on_sent(exc)
+    except BaseException as exc:
+        udp._error(exc, False)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/includes/__init__.py b/myenv/lib/python3.9/site-packages/uvloop/includes/__init__.py
new file mode 100644
index 0000000..2ccf9ca
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/includes/__init__.py
@@ -0,0 +1,23 @@
+# flake8: noqa
+
+# These have to be synced with the stdlib.pxi
+import asyncio
+import collections
+import concurrent.futures
+import errno
+import functools
+import gc
+import inspect
+import itertools
+import os
+import signal
+import socket
+import subprocess
+import ssl
+import stat
+import sys
+import threading
+import traceback
+import time
+import warnings
+import weakref
diff --git a/myenv/lib/python3.9/site-packages/uvloop/includes/compat.h b/myenv/lib/python3.9/site-packages/uvloop/includes/compat.h
new file mode 100644
index 0000000..7ae39e7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/includes/compat.h
@@ -0,0 +1,85 @@
+#include <errno.h>
+#include <stddef.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include "Python.h"
+#include "uv.h"
+
+
+#ifndef EWOULDBLOCK
+#define EWOULDBLOCK EAGAIN
+#endif
+
+#ifdef __APPLE__
+#define PLATFORM_IS_APPLE 1
+#else
+#define PLATFORM_IS_APPLE 0
+#endif
+
+
+#ifdef __linux__
+#  define PLATFORM_IS_LINUX 1
+#  include <sys/epoll.h>
+#else
+#  define PLATFORM_IS_LINUX 0
+#  define EPOLL_CTL_DEL 2
+struct epoll_event {};
+int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) {
+    return 0;
+};
+#endif
+
+
+PyObject *
+MakeUnixSockPyAddr(struct sockaddr_un *addr)
+{
+    if (addr->sun_family != AF_UNIX) {
+        PyErr_SetString(
+            PyExc_ValueError, "a UNIX socket addr was expected");
+        return NULL;
+    }
+
+#ifdef __linux__
+    int addrlen = sizeof (struct sockaddr_un);
+    size_t linuxaddrlen = addrlen - offsetof(struct sockaddr_un, sun_path);
+    if (linuxaddrlen > 0 && addr->sun_path[0] == 0) {
+        return PyBytes_FromStringAndSize(addr->sun_path, linuxaddrlen);
+    }
+    else
+#endif /* linux */
+    {
+        /* regular NULL-terminated string */
+        return PyUnicode_DecodeFSDefault(addr->sun_path);
+    }
+}
+
+
+#if PY_VERSION_HEX < 0x03070100
+
+PyObject * Context_CopyCurrent(void) {
+    return (PyObject *)PyContext_CopyCurrent();
+};
+
+int Context_Enter(PyObject *ctx) {
+    return PyContext_Enter((PyContext *)ctx);
+}
+
+int Context_Exit(PyObject *ctx) {
+    return PyContext_Exit((PyContext *)ctx);
+}
+
+#else
+
+PyObject * Context_CopyCurrent(void) {
+    return PyContext_CopyCurrent();
+};
+
+int Context_Enter(PyObject *ctx) {
+    return PyContext_Enter(ctx);
+}
+
+int Context_Exit(PyObject *ctx) {
+    return PyContext_Exit(ctx);
+}
+
+#endif
diff --git a/myenv/lib/python3.9/site-packages/uvloop/includes/consts.pxi b/myenv/lib/python3.9/site-packages/uvloop/includes/consts.pxi
new file mode 100644
index 0000000..f765053
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/includes/consts.pxi
@@ -0,0 +1,25 @@
+DEF UV_STREAM_RECV_BUF_SIZE = 256000  # 250kb
+
+DEF FLOW_CONTROL_HIGH_WATER = 64  # KiB
+DEF FLOW_CONTROL_HIGH_WATER_SSL_READ = 256  # KiB
+DEF FLOW_CONTROL_HIGH_WATER_SSL_WRITE = 512  # KiB
+
+DEF DEFAULT_FREELIST_SIZE = 250
+DEF DNS_PYADDR_TO_SOCKADDR_CACHE_SIZE = 2048
+
+DEF DEBUG_STACK_DEPTH = 10
+
+
+DEF __PROCESS_DEBUG_SLEEP_AFTER_FORK = 1
+
+
+DEF LOG_THRESHOLD_FOR_CONNLOST_WRITES = 5
+
+
+# Number of seconds to wait for SSL handshake to complete
+# The default timeout matches that of Nginx.
+DEF SSL_HANDSHAKE_TIMEOUT = 60.0
+# Number of seconds to wait for SSL shutdown to complete
+# The default timeout mimics lingering_time
+DEF SSL_SHUTDOWN_TIMEOUT = 30.0
+DEF SSL_READ_MAX_SIZE = 256 * 1024
diff --git a/myenv/lib/python3.9/site-packages/uvloop/includes/debug.h b/myenv/lib/python3.9/site-packages/uvloop/includes/debug.h
new file mode 100644
index 0000000..753ac76
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/includes/debug.h
@@ -0,0 +1,3 @@
+#ifndef UVLOOP_DEBUG
+#define UVLOOP_DEBUG 0
+#endif
diff --git a/myenv/lib/python3.9/site-packages/uvloop/includes/debug.pxd b/myenv/lib/python3.9/site-packages/uvloop/includes/debug.pxd
new file mode 100644
index 0000000..a825def
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/includes/debug.pxd
@@ -0,0 +1,3 @@
+cdef extern from "includes/debug.h":
+
+    cdef int UVLOOP_DEBUG
diff --git a/myenv/lib/python3.9/site-packages/uvloop/includes/flowcontrol.pxd b/myenv/lib/python3.9/site-packages/uvloop/includes/flowcontrol.pxd
new file mode 100644
index 0000000..f22f1a7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/includes/flowcontrol.pxd
@@ -0,0 +1,23 @@
+# flake8: noqa
+
+
+cdef inline add_flowcontrol_defaults(high, low, int kb):
+    cdef int h, l
+    if high is None:
+        if low is None:
+            h = kb * 1024
+        else:
+            l = low
+            h = 4 * l
+    else:
+        h = high
+    if low is None:
+        l = h // 4
+    else:
+        l = low
+
+    if not h >= l >= 0:
+        raise ValueError('high (%r) must be >= low (%r) must be >= 0' %
+                         (h, l))
+
+    return h, l
diff --git a/myenv/lib/python3.9/site-packages/uvloop/includes/fork_handler.h b/myenv/lib/python3.9/site-packages/uvloop/includes/fork_handler.h
new file mode 100644
index 0000000..19a016d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/includes/fork_handler.h
@@ -0,0 +1,27 @@
+
+typedef void (*OnForkHandler)();
+
+OnForkHandler __forkHandler = NULL;
+
+/* Auxiliary function to call global fork handler if defined.
+
+Note: Fork handler needs to be in C (not cython) otherwise it would require
+GIL to be present, but some forks can exec non-python processes.
+*/
+void handleAtFork(void) {
+    if (__forkHandler != NULL) {
+        __forkHandler();
+    }
+}
+
+
+void setForkHandler(OnForkHandler handler)
+{
+    __forkHandler = handler;
+}
+
+
+void resetForkHandler(void)
+{
+    __forkHandler = NULL;
+}
diff --git a/myenv/lib/python3.9/site-packages/uvloop/includes/python.pxd b/myenv/lib/python3.9/site-packages/uvloop/includes/python.pxd
new file mode 100644
index 0000000..454d5c7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/includes/python.pxd
@@ -0,0 +1,31 @@
+cdef extern from "Python.h":
+    int PY_VERSION_HEX
+
+    unicode PyUnicode_FromString(const char *)
+
+    void* PyMem_RawMalloc(size_t n) nogil
+    void* PyMem_RawRealloc(void *p, size_t n) nogil
+    void* PyMem_RawCalloc(size_t nelem, size_t elsize) nogil
+    void PyMem_RawFree(void *p) nogil
+
+    object PyUnicode_EncodeFSDefault(object)
+    void PyErr_SetInterrupt() nogil
+
+    void _Py_RestoreSignals()
+
+    object PyMemoryView_FromMemory(char *mem, ssize_t size, int flags)
+    object PyMemoryView_FromObject(object obj)
+    int PyMemoryView_Check(object obj)
+
+    cdef enum:
+        PyBUF_WRITE
+
+
+cdef extern from "includes/compat.h":
+    object Context_CopyCurrent()
+    int Context_Enter(object) except -1
+    int Context_Exit(object) except -1
+
+    void PyOS_BeforeFork()
+    void PyOS_AfterFork_Parent()
+    void PyOS_AfterFork_Child()
diff --git a/myenv/lib/python3.9/site-packages/uvloop/includes/stdlib.pxi b/myenv/lib/python3.9/site-packages/uvloop/includes/stdlib.pxi
new file mode 100644
index 0000000..adf9806
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/includes/stdlib.pxi
@@ -0,0 +1,173 @@
+# flake8: noqa
+
+
+import asyncio, asyncio.log, asyncio.base_events, \
+       asyncio.sslproto, asyncio.coroutines, \
+       asyncio.futures, asyncio.transports
+import collections.abc
+import concurrent.futures
+import errno
+import functools
+import gc
+import inspect
+import itertools
+import os
+import signal
+import socket
+import subprocess
+import ssl
+import stat
+import sys
+import threading
+import traceback
+import time
+import warnings
+import weakref
+
+
+cdef aio_get_event_loop = asyncio.get_event_loop
+cdef aio_CancelledError = asyncio.CancelledError
+cdef aio_InvalidStateError = asyncio.InvalidStateError
+cdef aio_TimeoutError = asyncio.TimeoutError
+cdef aio_Future = asyncio.Future
+cdef aio_Task = asyncio.Task
+cdef aio_ensure_future = asyncio.ensure_future
+cdef aio_gather = asyncio.gather
+cdef aio_wait = asyncio.wait
+cdef aio_wrap_future = asyncio.wrap_future
+cdef aio_logger = asyncio.log.logger
+cdef aio_iscoroutine = asyncio.iscoroutine
+cdef aio_iscoroutinefunction = asyncio.iscoroutinefunction
+cdef aio_BaseProtocol = asyncio.BaseProtocol
+cdef aio_Protocol = asyncio.Protocol
+cdef aio_isfuture = getattr(asyncio, 'isfuture', None)
+cdef aio_get_running_loop = getattr(asyncio, '_get_running_loop', None)
+cdef aio_set_running_loop = getattr(asyncio, '_set_running_loop', None)
+cdef aio_debug_wrapper = getattr(asyncio.coroutines, 'debug_wrapper', None)
+cdef aio_AbstractChildWatcher = asyncio.AbstractChildWatcher
+cdef aio_Transport = asyncio.Transport
+cdef aio_FlowControlMixin = asyncio.transports._FlowControlMixin
+
+cdef col_deque = collections.deque
+cdef col_Iterable = collections.abc.Iterable
+cdef col_Counter = collections.Counter
+cdef col_OrderedDict = collections.OrderedDict
+
+cdef cc_ThreadPoolExecutor = concurrent.futures.ThreadPoolExecutor
+cdef cc_Future = concurrent.futures.Future
+
+cdef errno_EBADF = errno.EBADF
+cdef errno_EINVAL = errno.EINVAL
+
+cdef ft_partial = functools.partial
+
+cdef gc_disable = gc.disable
+
+cdef iter_chain = itertools.chain
+cdef inspect_isgenerator = inspect.isgenerator
+
+cdef int has_IPV6_V6ONLY = hasattr(socket, 'IPV6_V6ONLY')
+cdef int IPV6_V6ONLY = getattr(socket, 'IPV6_V6ONLY', -1)
+cdef int has_SO_REUSEPORT = hasattr(socket, 'SO_REUSEPORT')
+cdef int SO_REUSEPORT = getattr(socket, 'SO_REUSEPORT', 0)
+cdef int SO_BROADCAST = getattr(socket, 'SO_BROADCAST')
+cdef int SOCK_NONBLOCK = getattr(socket, 'SOCK_NONBLOCK', -1)
+
+cdef socket_gaierror = socket.gaierror
+cdef socket_error = socket.error
+cdef socket_timeout = socket.timeout
+cdef socket_socket = socket.socket
+cdef socket_socketpair = socket.socketpair
+cdef socket_getservbyname = socket.getservbyname
+cdef socket_AddressFamily = socket.AddressFamily
+cdef socket_SocketKind = socket.SocketKind
+
+cdef int socket_EAI_ADDRFAMILY = getattr(socket, 'EAI_ADDRFAMILY', -1)
+cdef int socket_EAI_AGAIN      = getattr(socket, 'EAI_AGAIN', -1)
+cdef int socket_EAI_BADFLAGS   = getattr(socket, 'EAI_BADFLAGS', -1)
+cdef int socket_EAI_BADHINTS   = getattr(socket, 'EAI_BADHINTS', -1)
+cdef int socket_EAI_CANCELED   = getattr(socket, 'EAI_CANCELED', -1)
+cdef int socket_EAI_FAIL       = getattr(socket, 'EAI_FAIL', -1)
+cdef int socket_EAI_FAMILY     = getattr(socket, 'EAI_FAMILY', -1)
+cdef int socket_EAI_MEMORY     = getattr(socket, 'EAI_MEMORY', -1)
+cdef int socket_EAI_NODATA     = getattr(socket, 'EAI_NODATA', -1)
+cdef int socket_EAI_NONAME     = getattr(socket, 'EAI_NONAME', -1)
+cdef int socket_EAI_OVERFLOW   = getattr(socket, 'EAI_OVERFLOW', -1)
+cdef int socket_EAI_PROTOCOL   = getattr(socket, 'EAI_PROTOCOL', -1)
+cdef int socket_EAI_SERVICE    = getattr(socket, 'EAI_SERVICE', -1)
+cdef int socket_EAI_SOCKTYPE   = getattr(socket, 'EAI_SOCKTYPE', -1)
+
+
+cdef str os_name = os.name
+cdef os_environ = os.environ
+cdef os_dup = os.dup
+cdef os_set_inheritable = os.set_inheritable
+cdef os_get_inheritable = os.get_inheritable
+cdef os_close = os.close
+cdef os_open = os.open
+cdef os_devnull = os.devnull
+cdef os_O_RDWR = os.O_RDWR
+cdef os_pipe = os.pipe
+cdef os_read = os.read
+cdef os_remove = os.remove
+cdef os_stat = os.stat
+cdef os_fspath = os.fspath
+
+cdef stat_S_ISSOCK = stat.S_ISSOCK
+
+cdef sys_ignore_environment = sys.flags.ignore_environment
+cdef sys_exc_info = sys.exc_info
+cdef sys_set_coroutine_wrapper = getattr(sys, 'set_coroutine_wrapper', None)
+cdef sys_get_coroutine_wrapper = getattr(sys, 'get_coroutine_wrapper', None)
+cdef sys_getframe = sys._getframe
+cdef sys_version_info = sys.version_info
+cdef sys_getfilesystemencoding = sys.getfilesystemencoding
+cdef str sys_platform = sys.platform
+
+cdef ssl_SSLContext = ssl.SSLContext
+cdef ssl_MemoryBIO = ssl.MemoryBIO
+cdef ssl_create_default_context = ssl.create_default_context
+cdef ssl_SSLError = ssl.SSLError
+cdef ssl_SSLAgainErrors = (ssl.SSLWantReadError, ssl.SSLSyscallError)
+cdef ssl_SSLZeroReturnError = ssl.SSLZeroReturnError
+cdef ssl_CertificateError = ssl.CertificateError
+cdef int ssl_SSL_ERROR_WANT_READ = ssl.SSL_ERROR_WANT_READ
+cdef int ssl_SSL_ERROR_WANT_WRITE = ssl.SSL_ERROR_WANT_WRITE
+cdef int ssl_SSL_ERROR_SYSCALL = ssl.SSL_ERROR_SYSCALL
+
+cdef uint64_t MAIN_THREAD_ID = <uint64_t><int64_t>threading.main_thread().ident
+cdef threading_Thread = threading.Thread
+
+cdef int subprocess_PIPE = subprocess.PIPE
+cdef int subprocess_STDOUT = subprocess.STDOUT
+cdef int subprocess_DEVNULL = subprocess.DEVNULL
+cdef subprocess_SubprocessError = subprocess.SubprocessError
+
+cdef int signal_NSIG = signal.NSIG
+cdef signal_signal = signal.signal
+cdef signal_siginterrupt = signal.siginterrupt
+cdef signal_set_wakeup_fd = signal.set_wakeup_fd
+cdef signal_default_int_handler = signal.default_int_handler
+cdef signal_SIG_DFL = signal.SIG_DFL
+
+cdef time_sleep = time.sleep
+cdef time_monotonic = time.monotonic
+
+cdef tb_StackSummary = traceback.StackSummary
+cdef tb_walk_stack = traceback.walk_stack
+cdef tb_format_list = traceback.format_list
+
+cdef warnings_warn = warnings.warn
+
+cdef weakref_WeakValueDictionary = weakref.WeakValueDictionary
+cdef weakref_WeakSet = weakref.WeakSet
+
+cdef py_inf = float('inf')
+
+
+# Cython doesn't clean-up imported objects properly in Py3 mode,
+# so we delete refs to all modules manually (except sys)
+del asyncio, concurrent, collections, errno
+del functools, inspect, itertools, socket, os, threading
+del signal, subprocess, ssl
+del time, traceback, warnings, weakref
diff --git a/myenv/lib/python3.9/site-packages/uvloop/includes/system.pxd b/myenv/lib/python3.9/site-packages/uvloop/includes/system.pxd
new file mode 100644
index 0000000..63b9efa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/includes/system.pxd
@@ -0,0 +1,91 @@
+cdef extern from "arpa/inet.h" nogil:
+
+    int ntohl(int)
+    int htonl(int)
+    int ntohs(int)
+
+
+cdef extern from "sys/socket.h" nogil:
+
+    struct sockaddr:
+        unsigned short sa_family
+        char           sa_data[14]
+
+    struct addrinfo:
+        int            ai_flags
+        int            ai_family
+        int            ai_socktype
+        int            ai_protocol
+        size_t         ai_addrlen
+        sockaddr*      ai_addr
+        char*          ai_canonname
+        addrinfo*      ai_next
+
+    struct sockaddr_in:
+        unsigned short sin_family
+        unsigned short sin_port
+        # ...
+
+    struct sockaddr_in6:
+        unsigned short sin6_family
+        unsigned short sin6_port
+        unsigned long  sin6_flowinfo
+        # ...
+        unsigned long  sin6_scope_id
+
+    struct sockaddr_storage:
+        unsigned short ss_family
+        # ...
+
+    const char *gai_strerror(int errcode)
+
+    int socketpair(int domain, int type, int protocol, int socket_vector[2])
+
+    int setsockopt(int socket, int level, int option_name,
+                   const void *option_value, int option_len)
+
+
+cdef extern from "sys/un.h" nogil:
+
+    struct sockaddr_un:
+        unsigned short sun_family
+        char*          sun_path
+        # ...
+
+
+cdef extern from "unistd.h" nogil:
+
+    ssize_t write(int fd, const void *buf, size_t count)
+    void _exit(int status)
+
+
+cdef extern from "pthread.h":
+
+    int pthread_atfork(
+        void (*prepare)(),
+        void (*parent)(),
+        void (*child)())
+
+
+cdef extern from "includes/compat.h" nogil:
+
+    cdef int EWOULDBLOCK
+
+    cdef int PLATFORM_IS_APPLE
+    cdef int PLATFORM_IS_LINUX
+
+    struct epoll_event:
+        # We don't use the fields
+        pass
+
+    int EPOLL_CTL_DEL
+    int epoll_ctl(int epfd, int op, int fd, epoll_event *event)
+    object MakeUnixSockPyAddr(sockaddr_un *addr)
+
+
+cdef extern from "includes/fork_handler.h":
+
+    ctypedef void (*OnForkHandler)()
+    void handleAtFork()
+    void setForkHandler(OnForkHandler handler)
+    void resetForkHandler()
diff --git a/myenv/lib/python3.9/site-packages/uvloop/includes/uv.pxd b/myenv/lib/python3.9/site-packages/uvloop/includes/uv.pxd
new file mode 100644
index 0000000..0b0f1da
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/includes/uv.pxd
@@ -0,0 +1,484 @@
+from libc.stdint cimport uint16_t, uint32_t, uint64_t, int64_t
+from posix.types cimport gid_t, uid_t
+
+from . cimport system
+
+# This is an internal enum UV_HANDLE_READABLE from uv-common.h, used only by
+# handles/pipe.pyx to temporarily workaround a libuv issue libuv/libuv#2058,
+# before there is a proper fix in libuv. In short, libuv disallowed feeding a
+# write-only pipe to uv_read_start(), which was needed by uvloop to detect a
+# broken pipe without having to send anything on the write-only end. We're
+# setting UV_HANDLE_READABLE on pipe_t to workaround this limitation
+# temporarily, please see also #317.
+cdef enum:
+    UV_INTERNAL_HANDLE_READABLE = 0x00004000
+
+cdef extern from "uv.h" nogil:
+    cdef int UV_TCP_IPV6ONLY
+
+    cdef int UV_EACCES
+    cdef int UV_EAGAIN
+    cdef int UV_EALREADY
+    cdef int UV_EBUSY
+    cdef int UV_ECONNABORTED
+    cdef int UV_ECONNREFUSED
+    cdef int UV_ECONNRESET
+    cdef int UV_ECANCELED
+    cdef int UV_EEXIST
+    cdef int UV_EINTR
+    cdef int UV_EINVAL
+    cdef int UV_EISDIR
+    cdef int UV_ENOENT
+    cdef int UV_EOF
+    cdef int UV_EPERM
+    cdef int UV_EPIPE
+    cdef int UV_ESHUTDOWN
+    cdef int UV_ESRCH
+    cdef int UV_ETIMEDOUT
+    cdef int UV_EBADF
+    cdef int UV_ENOBUFS
+
+    cdef int UV_EAI_ADDRFAMILY
+    cdef int UV_EAI_AGAIN
+    cdef int UV_EAI_BADFLAGS
+    cdef int UV_EAI_BADHINTS
+    cdef int UV_EAI_CANCELED
+    cdef int UV_EAI_FAIL
+    cdef int UV_EAI_FAMILY
+    cdef int UV_EAI_MEMORY
+    cdef int UV_EAI_NODATA
+    cdef int UV_EAI_NONAME
+    cdef int UV_EAI_OVERFLOW
+    cdef int UV_EAI_PROTOCOL
+    cdef int UV_EAI_SERVICE
+    cdef int UV_EAI_SOCKTYPE
+
+    cdef int SOL_SOCKET
+    cdef int SO_ERROR
+    cdef int SO_REUSEADDR
+    cdef int SO_REUSEPORT
+    cdef int AF_INET
+    cdef int AF_INET6
+    cdef int AF_UNIX
+    cdef int AF_UNSPEC
+    cdef int AI_PASSIVE
+    cdef int AI_NUMERICHOST
+    cdef int INET6_ADDRSTRLEN
+    cdef int IPPROTO_IPV6
+    cdef int SOCK_STREAM
+    cdef int SOCK_DGRAM
+    cdef int IPPROTO_TCP
+    cdef int IPPROTO_UDP
+
+    cdef int SIGINT
+    cdef int SIGHUP
+    cdef int SIGCHLD
+    cdef int SIGKILL
+    cdef int SIGTERM
+
+    ctypedef int uv_os_sock_t
+    ctypedef int uv_file
+    ctypedef int uv_os_fd_t
+
+    ctypedef struct uv_buf_t:
+        char* base
+        size_t len
+
+    ctypedef struct uv_loop_t:
+        void* data
+        # ...
+
+    ctypedef struct uv_handle_t:
+        void* data
+        uv_loop_t* loop
+        unsigned int flags
+        # ...
+
+    ctypedef struct uv_idle_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_check_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_signal_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_async_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_timer_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_stream_t:
+        void* data
+        size_t write_queue_size
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_tcp_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_pipe_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_udp_t:
+        void* data
+        uv_loop_t* loop
+        size_t send_queue_size
+        size_t send_queue_count
+        # ...
+
+    ctypedef struct uv_udp_send_t:
+        void* data
+        uv_udp_t* handle
+
+    ctypedef struct uv_poll_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_req_t:
+        # Only cancellation of uv_fs_t, uv_getaddrinfo_t,
+        # uv_getnameinfo_t and uv_work_t requests is
+        # currently supported.
+        void* data
+        uv_req_type type
+        # ...
+
+    ctypedef struct uv_connect_t:
+        void* data
+
+    ctypedef struct uv_getaddrinfo_t:
+        void* data
+        # ...
+
+    ctypedef struct uv_getnameinfo_t:
+        void* data
+        # ...
+
+    ctypedef struct uv_write_t:
+        void* data
+        # ...
+
+    ctypedef struct uv_shutdown_t:
+        void* data
+        # ...
+
+    ctypedef struct uv_process_t:
+        void* data
+        int pid
+        # ...
+
+    ctypedef enum uv_req_type:
+        UV_UNKNOWN_REQ = 0,
+        UV_REQ,
+        UV_CONNECT,
+        UV_WRITE,
+        UV_SHUTDOWN,
+        UV_UDP_SEND,
+        UV_FS,
+        UV_WORK,
+        UV_GETADDRINFO,
+        UV_GETNAMEINFO,
+        UV_REQ_TYPE_PRIVATE,
+        UV_REQ_TYPE_MAX
+
+    ctypedef enum uv_run_mode:
+        UV_RUN_DEFAULT = 0,
+        UV_RUN_ONCE,
+        UV_RUN_NOWAIT
+
+    ctypedef enum uv_poll_event:
+        UV_READABLE = 1,
+        UV_WRITABLE = 2,
+        UV_DISCONNECT = 4
+
+    ctypedef enum uv_udp_flags:
+        UV_UDP_IPV6ONLY = 1,
+        UV_UDP_PARTIAL = 2
+
+    ctypedef enum uv_membership:
+        UV_LEAVE_GROUP = 0,
+        UV_JOIN_GROUP
+
+    const char* uv_strerror(int err)
+    const char* uv_err_name(int err)
+
+    ctypedef void (*uv_walk_cb)(uv_handle_t* handle, void* arg) with gil
+
+    ctypedef void (*uv_close_cb)(uv_handle_t* handle) with gil
+    ctypedef void (*uv_idle_cb)(uv_idle_t* handle) with gil
+    ctypedef void (*uv_check_cb)(uv_check_t* handle) with gil
+    ctypedef void (*uv_signal_cb)(uv_signal_t* handle, int signum) with gil
+    ctypedef void (*uv_async_cb)(uv_async_t* handle) with gil
+    ctypedef void (*uv_timer_cb)(uv_timer_t* handle) with gil
+    ctypedef void (*uv_connection_cb)(uv_stream_t* server, int status) with gil
+    ctypedef void (*uv_alloc_cb)(uv_handle_t* handle,
+                                 size_t suggested_size,
+                                 uv_buf_t* buf) with gil
+    ctypedef void (*uv_read_cb)(uv_stream_t* stream,
+                                ssize_t nread,
+                                const uv_buf_t* buf) with gil
+    ctypedef void (*uv_write_cb)(uv_write_t* req, int status) with gil
+    ctypedef void (*uv_getaddrinfo_cb)(uv_getaddrinfo_t* req,
+                                       int status,
+                                       system.addrinfo* res) with gil
+    ctypedef void (*uv_getnameinfo_cb)(uv_getnameinfo_t* req,
+                                       int status,
+                                       const char* hostname,
+                                       const char* service) with gil
+    ctypedef void (*uv_shutdown_cb)(uv_shutdown_t* req, int status) with gil
+    ctypedef void (*uv_poll_cb)(uv_poll_t* handle,
+                                int status, int events) with gil
+
+    ctypedef void (*uv_connect_cb)(uv_connect_t* req, int status) with gil
+
+    ctypedef void (*uv_udp_send_cb)(uv_udp_send_t* req, int status) with gil
+    ctypedef void (*uv_udp_recv_cb)(uv_udp_t* handle,
+                                    ssize_t nread,
+                                    const uv_buf_t* buf,
+                                    const system.sockaddr* addr,
+                                    unsigned flags) with gil
+
+    # Generic request functions
+    int uv_cancel(uv_req_t* req)
+
+    # Generic handler functions
+    int uv_is_active(const uv_handle_t* handle)
+    void uv_close(uv_handle_t* handle, uv_close_cb close_cb)
+    int uv_is_closing(const uv_handle_t* handle)
+    int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd)
+    void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg)
+
+    # Loop functions
+    int uv_loop_init(uv_loop_t* loop)
+    int uv_loop_close(uv_loop_t* loop)
+    int uv_loop_alive(uv_loop_t* loop)
+    int uv_loop_fork(uv_loop_t* loop)
+    int uv_backend_fd(uv_loop_t* loop)
+
+    void uv_update_time(uv_loop_t* loop)
+    uint64_t uv_now(const uv_loop_t*)
+
+    int uv_run(uv_loop_t*, uv_run_mode mode) nogil
+    void uv_stop(uv_loop_t*)
+
+    # Idle handler
+    int uv_idle_init(uv_loop_t*, uv_idle_t* idle)
+    int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb)
+    int uv_idle_stop(uv_idle_t* idle)
+
+    # Check handler
+    int uv_check_init(uv_loop_t*, uv_check_t* idle)
+    int uv_check_start(uv_check_t* check, uv_check_cb cb)
+    int uv_check_stop(uv_check_t* check)
+
+    # Signal handler
+    int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle)
+    int uv_signal_start(uv_signal_t* handle,
+                        uv_signal_cb signal_cb,
+                        int signum)
+    int uv_signal_stop(uv_signal_t* handle)
+
+    # Async handler
+    int uv_async_init(uv_loop_t*,
+                      uv_async_t* async_,
+                      uv_async_cb async_cb)
+    int uv_async_send(uv_async_t* async_)
+
+    # Timer handler
+    int uv_timer_init(uv_loop_t*, uv_timer_t* handle)
+    int uv_timer_start(uv_timer_t* handle,
+                       uv_timer_cb cb,
+                       uint64_t timeout,
+                       uint64_t repeat)
+    int uv_timer_stop(uv_timer_t* handle)
+
+    # DNS
+    int uv_getaddrinfo(uv_loop_t* loop,
+                       uv_getaddrinfo_t* req,
+                       uv_getaddrinfo_cb getaddrinfo_cb,
+                       const char* node,
+                       const char* service,
+                       const system.addrinfo* hints)
+
+    void uv_freeaddrinfo(system.addrinfo* ai)
+
+    int uv_getnameinfo(uv_loop_t* loop,
+                       uv_getnameinfo_t* req,
+                       uv_getnameinfo_cb getnameinfo_cb,
+                       const system.sockaddr* addr,
+                       int flags)
+
+    int uv_ip4_name(const system.sockaddr_in* src, char* dst, size_t size)
+    int uv_ip6_name(const system.sockaddr_in6* src, char* dst, size_t size)
+
+    # Streams
+
+    int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb)
+    int uv_accept(uv_stream_t* server, uv_stream_t* client)
+    int uv_read_start(uv_stream_t* stream,
+                      uv_alloc_cb alloc_cb,
+                      uv_read_cb read_cb)
+    int uv_read_stop(uv_stream_t*)
+    int uv_write(uv_write_t* req, uv_stream_t* handle,
+                 uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb)
+
+    int uv_try_write(uv_stream_t* handle, uv_buf_t bufs[], unsigned int nbufs)
+
+    int uv_shutdown(uv_shutdown_t* req, uv_stream_t* handle, uv_shutdown_cb cb)
+
+    int uv_is_readable(const uv_stream_t* handle)
+    int uv_is_writable(const uv_stream_t* handle)
+
+    # TCP
+
+    int uv_tcp_init_ex(uv_loop_t*, uv_tcp_t* handle, unsigned int flags)
+    int uv_tcp_nodelay(uv_tcp_t* handle, int enable)
+    int uv_tcp_keepalive(uv_tcp_t* handle, int enable, unsigned int delay)
+    int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock)
+    int uv_tcp_bind(uv_tcp_t* handle, system.sockaddr* addr,
+                    unsigned int flags)
+
+    int uv_tcp_getsockname(const uv_tcp_t* handle, system.sockaddr* name,
+                           int* namelen)
+    int uv_tcp_getpeername(const uv_tcp_t* handle, system.sockaddr* name,
+                           int* namelen)
+
+    int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle,
+                       const system.sockaddr* addr, uv_connect_cb cb)
+
+    # Pipes
+
+    int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc)
+    int uv_pipe_open(uv_pipe_t* handle, uv_file file)
+    int uv_pipe_bind(uv_pipe_t* handle, const char* name)
+
+    void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle,
+                         const char* name, uv_connect_cb cb)
+
+    # UDP
+
+    int uv_udp_init_ex(uv_loop_t* loop, uv_udp_t* handle, unsigned int flags)
+    int uv_udp_connect(uv_udp_t* handle, const system.sockaddr* addr)
+    int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock)
+    int uv_udp_bind(uv_udp_t* handle, const system.sockaddr* addr,
+                    unsigned int flags)
+    int uv_udp_send(uv_udp_send_t* req, uv_udp_t* handle,
+                    const uv_buf_t bufs[], unsigned int nbufs,
+                    const system.sockaddr* addr, uv_udp_send_cb send_cb)
+    int uv_udp_try_send(uv_udp_t* handle,
+                        const uv_buf_t bufs[], unsigned int nbufs,
+                        const system.sockaddr* addr)
+    int uv_udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb,
+                          uv_udp_recv_cb recv_cb)
+    int uv_udp_recv_stop(uv_udp_t* handle)
+    int uv_udp_set_broadcast(uv_udp_t* handle, int on)
+
+    # Polling
+
+    int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd)
+    int uv_poll_init_socket(uv_loop_t* loop, uv_poll_t* handle,
+                            uv_os_sock_t socket)
+    int uv_poll_start(uv_poll_t* handle, int events, uv_poll_cb cb)
+    int uv_poll_stop(uv_poll_t* poll)
+
+    # Misc
+
+    ctypedef struct uv_timeval_t:
+        long tv_sec
+        long tv_usec
+
+    ctypedef struct uv_rusage_t:
+        uv_timeval_t ru_utime   # user CPU time used
+        uv_timeval_t ru_stime   # system CPU time used
+        uint64_t ru_maxrss      # maximum resident set size
+        uint64_t ru_ixrss       # integral shared memory size
+        uint64_t ru_idrss       # integral unshared data size
+        uint64_t ru_isrss       # integral unshared stack size
+        uint64_t ru_minflt      # page reclaims (soft page faults)
+        uint64_t ru_majflt      # page faults (hard page faults)
+        uint64_t ru_nswap       # swaps
+        uint64_t ru_inblock     # block input operations
+        uint64_t ru_oublock     # block output operations
+        uint64_t ru_msgsnd      # IPC messages sent
+        uint64_t ru_msgrcv      # IPC messages received
+        uint64_t ru_nsignals    # signals received
+        uint64_t ru_nvcsw       # voluntary context switches
+        uint64_t ru_nivcsw      # involuntary context switches
+
+    int uv_getrusage(uv_rusage_t* rusage)
+
+    int uv_ip4_addr(const char* ip, int port, system.sockaddr_in* addr)
+    int uv_ip6_addr(const char* ip, int port, system.sockaddr_in6* addr)
+
+    # Memory Allocation
+
+    ctypedef void* (*uv_malloc_func)(size_t size)
+    ctypedef void* (*uv_realloc_func)(void* ptr, size_t size)
+    ctypedef void* (*uv_calloc_func)(size_t count, size_t size)
+    ctypedef void (*uv_free_func)(void* ptr)
+
+    int uv_replace_allocator(uv_malloc_func malloc_func,
+                             uv_realloc_func realloc_func,
+                             uv_calloc_func calloc_func,
+                             uv_free_func free_func)
+
+    # Process
+
+    ctypedef void (*uv_exit_cb)(uv_process_t*, int64_t exit_status,
+                                int term_signal) with gil
+
+    ctypedef enum uv_process_flags:
+        UV_PROCESS_SETUID = 1,
+        UV_PROCESS_SETGID = 2,
+        UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = 4,
+        UV_PROCESS_DETACHED = 8,
+        UV_PROCESS_WINDOWS_HIDE = 16
+
+    ctypedef enum uv_stdio_flags:
+        UV_IGNORE = 0x00,
+        UV_CREATE_PIPE = 0x01,
+        UV_INHERIT_FD = 0x02,
+        UV_INHERIT_STREAM = 0x04,
+        UV_READABLE_PIPE = 0x10,
+        UV_WRITABLE_PIPE = 0x20
+
+    ctypedef union uv_stdio_container_data_u:
+        uv_stream_t* stream
+        int fd
+
+    ctypedef struct uv_stdio_container_t:
+        uv_stdio_flags flags
+        uv_stdio_container_data_u data
+
+    ctypedef struct uv_process_options_t:
+        uv_exit_cb exit_cb
+        char* file
+        char** args
+        char** env
+        char* cwd
+        unsigned int flags
+        int stdio_count
+        uv_stdio_container_t* stdio
+        uid_t uid
+        gid_t gid
+
+    int uv_spawn(uv_loop_t* loop, uv_process_t* handle,
+                 const uv_process_options_t* options)
+
+    int uv_process_kill(uv_process_t* handle, int signum)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/loop.c b/myenv/lib/python3.9/site-packages/uvloop/loop.c
new file mode 100644
index 0000000..f23b906
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/loop.c
@@ -0,0 +1,174850 @@
+/* Generated by Cython 0.29.24 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "name": "uvloop.loop",
+        "sources": [
+            "uvloop/loop.pyx"
+        ]
+    },
+    "module_name": "uvloop.loop"
+}
+END: Cython Metadata */
+
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif /* PY_SSIZE_T_CLEAN */
+#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+.
+#else
+#define CYTHON_ABI "0_29_24"
+#define CYTHON_HEX_VERSION 0x001D18F0
+#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)
+  #ifndef __stdcall
+    #define __stdcall
+  #endif
+  #ifndef __cdecl
+    #define __cdecl
+  #endif
+  #ifndef __fastcall
+    #define __fastcall
+  #endif
+#endif
+#ifndef DL_IMPORT
+  #define DL_IMPORT(t) t
+#endif
+#ifndef DL_EXPORT
+  #define DL_EXPORT(t) t
+#endif
+#define __PYX_COMMA ,
+#ifndef HAVE_LONG_LONG
+  #if PY_VERSION_HEX >= 0x02070000
+    #define HAVE_LONG_LONG
+  #endif
+#endif
+#ifndef PY_LONG_LONG
+  #define PY_LONG_LONG LONG_LONG
+#endif
+#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 CYTHON_COMPILING_IN_CPYTHON 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #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_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #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_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+#elif defined(PYSTON_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 1
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #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
+  #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_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #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_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+#else
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 1
+  #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)
+    #define CYTHON_USE_PYTYPE_LOOKUP 1
+  #endif
+  #if PY_MAJOR_VERSION < 3
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #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)
+    #define CYTHON_USE_PYLONG_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_PYLIST_INTERNALS
+    #define CYTHON_USE_PYLIST_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #if PY_VERSION_HEX < 0x030300F0
+    #undef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
+  #elif !defined(CYTHON_USE_UNICODE_WRITER)
+    #define CYTHON_USE_UNICODE_WRITER 1
+  #endif
+  #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
+  #ifndef CYTHON_FAST_THREAD_STATE
+    #define CYTHON_FAST_THREAD_STATE 1
+  #endif
+  #ifndef CYTHON_FAST_PYCALL
+    #define CYTHON_FAST_PYCALL 1
+  #endif
+  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #endif
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #endif
+  #ifndef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #endif
+  #ifndef CYTHON_USE_EXC_INFO_STACK
+    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+  #endif
+#endif
+#if !defined(CYTHON_FAST_PYCCALL)
+#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+  #include "longintrepr.h"
+  #undef SHIFT
+  #undef BASE
+  #undef MASK
+  #ifdef SIZEOF_VOID_P
+    enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
+  #endif
+#endif
+#ifndef __has_attribute
+  #define __has_attribute(x) 0
+#endif
+#ifndef __has_cpp_attribute
+  #define __has_cpp_attribute(x) 0
+#endif
+#ifndef CYTHON_RESTRICT
+  #if defined(__GNUC__)
+    #define CYTHON_RESTRICT __restrict__
+  #elif defined(_MSC_VER) && _MSC_VER >= 1400
+    #define CYTHON_RESTRICT __restrict
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_RESTRICT restrict
+  #else
+    #define CYTHON_RESTRICT
+  #endif
+#endif
+#ifndef CYTHON_UNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define CYTHON_UNUSED __attribute__ ((__unused__))
+#   else
+#     define CYTHON_UNUSED
+#   endif
+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
+#   define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+#   define CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+#  if defined(__cplusplus)
+     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+#  else
+#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#  endif
+#endif
+#ifndef CYTHON_NCP_UNUSED
+# if CYTHON_COMPILING_IN_CPYTHON
+#  define CYTHON_NCP_UNUSED
+# else
+#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
+# 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;
+        #else
+           typedef unsigned __int8   uint8_t;
+           typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+#else
+   #include <stdint.h>
+#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]]
+    #endif
+  #endif
+  #ifndef CYTHON_FALLTHROUGH
+    #if __has_attribute(fallthrough)
+      #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
+    #else
+      #define CYTHON_FALLTHROUGH
+    #endif
+  #endif
+  #if defined(__clang__ ) && defined(__apple_build_version__)
+    #if __apple_build_version__ < 7000000
+      #undef  CYTHON_FALLTHROUGH
+      #define CYTHON_FALLTHROUGH
+    #endif
+  #endif
+#endif
+
+#ifndef CYTHON_INLINE
+  #if defined(__clang__)
+    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
+  #elif defined(__GNUC__)
+    #define CYTHON_INLINE __inline__
+  #elif defined(_MSC_VER)
+    #define CYTHON_INLINE __inline
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_INLINE inline
+  #else
+    #define CYTHON_INLINE
+  #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
+#else
+  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
+#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a, 0, 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)\
+          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#endif
+  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+  #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+  #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+  #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef METH_STACKLESS
+  #define METH_STACKLESS 0
+#endif
+#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
+  #ifndef METH_FASTCALL
+     #define METH_FASTCALL 0x80
+  #endif
+  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
+  typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
+                                                          Py_ssize_t nargs, PyObject *kwnames);
+#else
+  #define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+#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)))))
+#else
+#define __Pyx_PyFastCFunction_Check(func) 0
+#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)
+#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
+  #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x03060000
+  #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
+#elif PY_VERSION_HEX >= 0x03000000
+  #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#else
+  #define __Pyx_PyThreadState_Current _PyThreadState_Current
+#endif
+#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
+#include "pythread.h"
+#define Py_tss_NEEDS_INIT 0
+typedef int Py_tss_t;
+static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
+  *key = PyThread_create_key();
+  return 0;
+}
+static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
+  Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
+  *key = Py_tss_NEEDS_INIT;
+  return key;
+}
+static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
+  PyObject_Free(key);
+}
+static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
+  return *key != Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
+  PyThread_delete_key(*key);
+  *key = Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
+  return PyThread_set_key_value(*key, value);
+}
+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)
+#define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
+#else
+#define __Pyx_PyDict_NewPresized(n)  PyDict_New()
+#endif
+#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
+#else
+  #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)
+#else
+#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#endif
+#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #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)
+  #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_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
+  #else
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+  #endif
+#else
+  #define CYTHON_PEP393_ENABLED 0
+  #define PyUnicode_1BYTE_KIND  1
+  #define PyUnicode_2BYTE_KIND  2
+  #define PyUnicode_4BYTE_KIND  4
+  #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_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_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
+#else
+  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
+  #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)
+#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))
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
+#else
+  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
+#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+  #define PyObject_ASCII(o)            PyObject_Repr(o)
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBaseString_Type            PyUnicode_Type
+  #define PyStringObject               PyUnicodeObject
+  #define PyString_Type                PyUnicode_Type
+  #define PyString_Check               PyUnicode_Check
+  #define PyString_CheckExact          PyUnicode_CheckExact
+#ifndef PyObject_Unicode
+  #define PyObject_Unicode             PyObject_Str
+#endif
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
+  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#else
+  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
+  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+#endif
+#ifndef PySet_CheckExact
+  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+#endif
+#if PY_VERSION_HEX >= 0x030900A4
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
+#else
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
+#endif
+#if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+#else
+  #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+#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 PyInt_FromString             PyLong_FromString
+  #define PyInt_FromUnicode            PyLong_FromUnicode
+  #define PyInt_FromLong               PyLong_FromLong
+  #define PyInt_FromSize_t             PyLong_FromSize_t
+  #define PyInt_FromSsize_t            PyLong_FromSsize_t
+  #define PyInt_AsLong                 PyLong_AsLong
+  #define PyInt_AS_LONG                PyLong_AS_LONG
+  #define PyInt_AsSsize_t              PyLong_AsSsize_t
+  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
+  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+  #define PyNumber_Int                 PyNumber_Long
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBoolObject                 PyLongObject
+#endif
+#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
+  #ifndef PyUnicode_InternFromString
+    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+  #endif
+#endif
+#if PY_VERSION_HEX < 0x030200A4
+  typedef long Py_hash_t;
+  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
+#else
+  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
+  #define __Pyx_PyInt_AsHash_t   PyInt_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
+    #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
+  #else
+    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
+  #endif
+#else
+  #define __Pyx_PyType_AsAsync(obj) NULL
+#endif
+#ifndef __Pyx_PyAsyncMethodsStruct
+    typedef struct {
+        unaryfunc am_await;
+        unaryfunc am_aiter;
+        unaryfunc am_anext;
+    } __Pyx_PyAsyncMethodsStruct;
+#endif
+
+#if defined(WIN32) || defined(MS_WINDOWS)
+  #define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+#ifdef NAN
+#define __PYX_NAN() ((float) NAN)
+#else
+static CYTHON_INLINE float __PYX_NAN() {
+  float value;
+  memset(&value, 0xFF, sizeof(value));
+  return value;
+}
+#endif
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#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; }
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+    { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
+
+#ifndef __PYX_EXTERN_C
+  #ifdef __cplusplus
+    #define __PYX_EXTERN_C extern "C"
+  #else
+    #define __PYX_EXTERN_C extern
+  #endif
+#endif
+
+#define __PYX_HAVE__uvloop__loop
+#define __PYX_HAVE_API__uvloop__loop
+/* Early includes */
+#include <stdint.h>
+#include <sys/types.h>
+#include "arpa/inet.h"
+#include "sys/socket.h"
+#include "sys/un.h"
+#include "unistd.h"
+#include "pthread.h"
+#include "includes/compat.h"
+#include "includes/fork_handler.h"
+#include "uv.h"
+#include "includes/debug.h"
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+#include "pythread.h"
+#ifdef _OPENMP
+#include <omp.h>
+#endif /* _OPENMP */
+
+#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
+                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
+    (sizeof(type) < sizeof(Py_ssize_t))  ||\
+    (sizeof(type) > sizeof(Py_ssize_t) &&\
+          likely(v < (type)PY_SSIZE_T_MAX ||\
+                 v == (type)PY_SSIZE_T_MAX)  &&\
+          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+                                v == (type)PY_SSIZE_T_MIN)))  ||\
+    (sizeof(type) == sizeof(Py_ssize_t) &&\
+          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+                               v == (type)PY_SSIZE_T_MAX)))  )
+static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
+    return (size_t) i < (size_t) limit;
+}
+#if defined (__cplusplus) && __cplusplus >= 201103L
+    #include <cstdlib>
+    #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER)
+    #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+    #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+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))
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString        PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+#if PY_MAJOR_VERSION < 3
+    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#else
+    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
+#endif
+#define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AS_STRING(s))
+#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_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)
+#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
+#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_AsUnicode            PyUnicode_AsUnicode
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+#define __Pyx_PySequence_Tuple(obj)\
+    (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#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;
+    const char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    if (strcmp(default_encoding_c, "ascii") == 0) {
+        __Pyx_sys_getdefaultencoding_not_ascii = 0;
+    } else {
+        char ascii_chars[128];
+        int c;
+        for (c = 0; c < 128; c++) {
+            ascii_chars[c] = c;
+        }
+        __Pyx_sys_getdefaultencoding_not_ascii = 1;
+        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+        if (!ascii_chars_u) goto bad;
+        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+            PyErr_Format(
+                PyExc_ValueError,
+                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+                default_encoding_c);
+            goto bad;
+        }
+        Py_DECREF(ascii_chars_u);
+        Py_DECREF(ascii_chars_b);
+    }
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    Py_XDECREF(ascii_chars_u);
+    Py_XDECREF(ascii_chars_b);
+    return -1;
+}
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#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
+static char* __PYX_DEFAULT_STRING_ENCODING;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
+    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    return -1;
+}
+#endif
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+  #define likely(x)   __builtin_expect(!!(x), 1)
+  #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+  #define likely(x)   (x)
+  #define unlikely(x) (x)
+#endif /* __GNUC__ */
+static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
+
+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;
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * __pyx_cfilenm= __FILE__;
+static const char *__pyx_filename;
+
+
+static const char *__pyx_f[] = {
+  "uvloop/loop.pyx",
+  "uvloop/errors.pyx",
+  "uvloop/handles/handle.pyx",
+  "uvloop/handles/tcp.pyx",
+  "uvloop/handles/process.pyx",
+  "uvloop/dns.pyx",
+  "uvloop/loop.pxd",
+  "stringsource",
+  "uvloop/cbhandles.pyx",
+  "uvloop/pseudosock.pyx",
+  "uvloop/lru.pyx",
+  "uvloop/handles/async_.pyx",
+  "uvloop/handles/idle.pyx",
+  "uvloop/handles/check.pyx",
+  "uvloop/handles/timer.pyx",
+  "uvloop/handles/poll.pyx",
+  "uvloop/handles/basetransport.pyx",
+  "uvloop/handles/basetransport.pxd",
+  "uvloop/handles/stream.pyx",
+  "uvloop/handles/streamserver.pyx",
+  "uvloop/handles/pipe.pyx",
+  "uvloop/request.pyx",
+  "uvloop/sslproto.pyx",
+  "uvloop/handles/udp.pyx",
+  "uvloop/server.pyx",
+  "uvloop/includes/flowcontrol.pxd",
+  ".eggs/Cython-0.29.24-py3.9-macosx-10.9-x86_64.egg/Cython/Includes/cpython/type.pxd",
+  ".eggs/Cython-0.29.24-py3.9-macosx-10.9-x86_64.egg/Cython/Includes/cpython/bool.pxd",
+  ".eggs/Cython-0.29.24-py3.9-macosx-10.9-x86_64.egg/Cython/Includes/cpython/complex.pxd",
+  "uvloop/includes/stdlib.pxi",
+};
+/* NoFastGil.proto */
+#define __Pyx_PyGILState_Ensure PyGILState_Ensure
+#define __Pyx_PyGILState_Release PyGILState_Release
+#define __Pyx_FastGIL_Remember()
+#define __Pyx_FastGIL_Forget()
+#define __Pyx_FastGilFuncInit()
+
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
+
+/*--- Type declarations ---*/
+struct __pyx_obj_6uvloop_4loop_Loop;
+struct __pyx_obj_6uvloop_4loop_Handle;
+struct __pyx_obj_6uvloop_4loop_TimerHandle;
+struct __pyx_obj_6uvloop_4loop_UVHandle;
+struct __pyx_obj_6uvloop_4loop_UVSocketHandle;
+struct __pyx_obj_6uvloop_4loop_UVAsync;
+struct __pyx_obj_6uvloop_4loop_UVIdle;
+struct __pyx_obj_6uvloop_4loop_UVCheck;
+struct __pyx_obj_6uvloop_4loop_UVTimer;
+struct __pyx_obj_6uvloop_4loop_UVPoll;
+struct __pyx_obj_6uvloop_4loop_UVBaseTransport;
+struct __pyx_obj_6uvloop_4loop_UVStream;
+struct __pyx_obj_6uvloop_4loop_UVStreamServer;
+struct __pyx_obj_6uvloop_4loop_TCPServer;
+struct __pyx_obj_6uvloop_4loop_TCPTransport;
+struct __pyx_obj_6uvloop_4loop_UnixServer;
+struct __pyx_obj_6uvloop_4loop_UnixTransport;
+struct __pyx_obj_6uvloop_4loop_ReadUnixTransport;
+struct __pyx_obj_6uvloop_4loop_WriteUnixTransport;
+struct __pyx_obj_6uvloop_4loop_UVProcess;
+struct __pyx_obj_6uvloop_4loop_UVProcessTransport;
+struct __pyx_obj_6uvloop_4loop_UVRequest;
+struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport;
+struct __pyx_obj_6uvloop_4loop_SSLProtocol;
+struct __pyx_obj_6uvloop_4loop_UDPTransport;
+struct __pyx_obj_6uvloop_4loop_Server;
+struct __pyx_obj_6uvloop_4loop_PseudoSocket;
+struct __pyx_obj_6uvloop_4loop_LruCache;
+struct __pyx_obj_6uvloop_4loop__StreamWriteContext;
+struct __pyx_obj_6uvloop_4loop__TCPConnectRequest;
+struct __pyx_obj_6uvloop_4loop__PipeConnectRequest;
+struct __pyx_obj_6uvloop_4loop_SockAddrHolder;
+struct __pyx_obj_6uvloop_4loop_AddrInfo;
+struct __pyx_obj_6uvloop_4loop_AddrInfoRequest;
+struct __pyx_obj_6uvloop_4loop_NameInfoRequest;
+struct __pyx_obj_6uvloop_4loop__UDPSendContext;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever;
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1;
+struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py;
+
+/* "uv.pxd":13
+ * # setting UV_HANDLE_READABLE on pipe_t to workaround this limitation
+ * # temporarily, please see also #317.
+ * cdef enum:             # <<<<<<<<<<<<<<
+ *     UV_INTERNAL_HANDLE_READABLE = 0x00004000
+ * 
+ */
+enum  {
+  __pyx_e_6uvloop_8includes_2uv_UV_INTERNAL_HANDLE_READABLE = 0x00004000
+};
+struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error;
+struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__fatal_error;
+struct __pyx_opt_args_6uvloop_4loop_9TCPServer_bind;
+struct __pyx_opt_args_6uvloop_4loop_12TCPTransport_bind;
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__wakeup_waiter;
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__get_extra_info;
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__start_shutdown;
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_flush;
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_shutdown;
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__call_eof_received;
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__control_app_writing;
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_write_buffer_limits;
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_read_buffer_limits;
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__fatal_error;
+struct __pyx_opt_args_6uvloop_4loop_12UDPTransport__on_sent;
+struct __pyx_opt_args_6uvloop_4loop_6UVPoll__fatal_error;
+struct __pyx_opt_args_6uvloop_4loop_14UVStreamServer__fatal_error;
+
+/* "uvloop/sslproto.pxd":1
+ * cdef enum SSLProtocolState:             # <<<<<<<<<<<<<<
+ *     UNWRAPPED = 0
+ *     DO_HANDSHAKE = 1
+ */
+enum __pyx_t_6uvloop_4loop_SSLProtocolState {
+  __pyx_e_6uvloop_4loop_UNWRAPPED = 0,
+  __pyx_e_6uvloop_4loop_DO_HANDSHAKE = 1,
+  __pyx_e_6uvloop_4loop_WRAPPED = 2,
+  __pyx_e_6uvloop_4loop_FLUSHING = 3,
+  __pyx_e_6uvloop_4loop_SHUTDOWN = 4
+};
+
+/* "uvloop/sslproto.pxd":9
+ * 
+ * 
+ * cdef enum AppProtocolState:             # <<<<<<<<<<<<<<
+ *     # This tracks the state of app protocol (https://git.io/fj59P):
+ *     #
+ */
+enum __pyx_t_6uvloop_4loop_AppProtocolState {
+  __pyx_e_6uvloop_4loop_STATE_INIT = 0,
+  __pyx_e_6uvloop_4loop_STATE_CON_MADE = 1,
+  __pyx_e_6uvloop_4loop_STATE_EOF = 2,
+  __pyx_e_6uvloop_4loop_STATE_CON_LOST = 3
+};
+
+/* "uvloop/loop.pxd":26
+ * cdef class UVBaseTransport(UVSocketHandle)
+ * 
+ * ctypedef object (*method_t)(object)             # <<<<<<<<<<<<<<
+ * ctypedef object (*method1_t)(object, object)
+ * ctypedef object (*method2_t)(object, object, object)
+ */
+typedef PyObject *(*__pyx_t_6uvloop_4loop_method_t)(PyObject *);
+
+/* "uvloop/loop.pxd":27
+ * 
+ * ctypedef object (*method_t)(object)
+ * ctypedef object (*method1_t)(object, object)             # <<<<<<<<<<<<<<
+ * ctypedef object (*method2_t)(object, object, object)
+ * ctypedef object (*method3_t)(object, object, object, object)
+ */
+typedef PyObject *(*__pyx_t_6uvloop_4loop_method1_t)(PyObject *, PyObject *);
+
+/* "uvloop/loop.pxd":28
+ * ctypedef object (*method_t)(object)
+ * ctypedef object (*method1_t)(object, object)
+ * ctypedef object (*method2_t)(object, object, object)             # <<<<<<<<<<<<<<
+ * ctypedef object (*method3_t)(object, object, object, object)
+ * 
+ */
+typedef PyObject *(*__pyx_t_6uvloop_4loop_method2_t)(PyObject *, PyObject *, PyObject *);
+
+/* "uvloop/loop.pxd":29
+ * ctypedef object (*method1_t)(object, object)
+ * ctypedef object (*method2_t)(object, object, object)
+ * ctypedef object (*method3_t)(object, object, object, object)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+typedef PyObject *(*__pyx_t_6uvloop_4loop_method3_t)(PyObject *, PyObject *, PyObject *, PyObject *);
+
+/* "uvloop/handles/handle.pxd":24
+ * 
+ *     cdef _error(self, exc, throw)
+ *     cdef _fatal_error(self, exc, throw, reason=?)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _warn_unclosed(self)
+ */
+struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error {
+  int __pyx_n;
+  PyObject *reason;
+};
+
+/* "uvloop/handles/basetransport.pxd":35
+ * 
+ *     # Overloads of UVHandle methods:
+ *     cdef _fatal_error(self, exc, throw, reason=?)             # <<<<<<<<<<<<<<
+ *     cdef _close(self)
+ * 
+ */
+struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__fatal_error {
+  int __pyx_n;
+  PyObject *reason;
+};
+
+/* "uvloop/handles/tcp.pxd":2
+ * cdef class TCPServer(UVStreamServer):
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=*)             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+struct __pyx_opt_args_6uvloop_4loop_9TCPServer_bind {
+  int __pyx_n;
+  unsigned int flags;
+};
+
+/* "uvloop/handles/tcp.pxd":20
+ *         system.sockaddr_storage __sockname
+ * 
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=*)             # <<<<<<<<<<<<<<
+ *     cdef connect(self, system.sockaddr* addr)
+ *     cdef _set_nodelay(self)
+ */
+struct __pyx_opt_args_6uvloop_4loop_12TCPTransport_bind {
+  int __pyx_n;
+  unsigned int flags;
+};
+
+/* "uvloop/sslproto.pxd":88
+ * 
+ *     cdef _set_app_protocol(self, app_protocol)
+ *     cdef _wakeup_waiter(self, exc=*)             # <<<<<<<<<<<<<<
+ *     cdef _get_extra_info(self, name, default=*)
+ *     cdef _set_state(self, SSLProtocolState new_state)
+ */
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__wakeup_waiter {
+  int __pyx_n;
+  PyObject *exc;
+};
+
+/* "uvloop/sslproto.pxd":89
+ *     cdef _set_app_protocol(self, app_protocol)
+ *     cdef _wakeup_waiter(self, exc=*)
+ *     cdef _get_extra_info(self, name, default=*)             # <<<<<<<<<<<<<<
+ *     cdef _set_state(self, SSLProtocolState new_state)
+ * 
+ */
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__get_extra_info {
+  int __pyx_n;
+  PyObject *__pyx_default;
+};
+
+/* "uvloop/sslproto.pxd":101
+ *     # Shutdown flow
+ * 
+ *     cdef _start_shutdown(self, object context=*)             # <<<<<<<<<<<<<<
+ *     cdef _check_shutdown_timeout(self)
+ *     cdef _do_read_into_void(self, object context)
+ */
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__start_shutdown {
+  int __pyx_n;
+  PyObject *context;
+};
+
+/* "uvloop/sslproto.pxd":104
+ *     cdef _check_shutdown_timeout(self)
+ *     cdef _do_read_into_void(self, object context)
+ *     cdef _do_flush(self, object context=*)             # <<<<<<<<<<<<<<
+ *     cdef _do_shutdown(self, object context=*)
+ *     cdef _on_shutdown_complete(self, shutdown_exc)
+ */
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_flush {
+  int __pyx_n;
+  PyObject *context;
+};
+
+/* "uvloop/sslproto.pxd":105
+ *     cdef _do_read_into_void(self, object context)
+ *     cdef _do_flush(self, object context=*)
+ *     cdef _do_shutdown(self, object context=*)             # <<<<<<<<<<<<<<
+ *     cdef _on_shutdown_complete(self, shutdown_exc)
+ *     cdef _abort(self, exc)
+ */
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_shutdown {
+  int __pyx_n;
+  PyObject *context;
+};
+
+/* "uvloop/sslproto.pxd":120
+ *     cdef _do_read__buffered(self)
+ *     cdef _do_read__copied(self)
+ *     cdef _call_eof_received(self, object context=*)             # <<<<<<<<<<<<<<
+ * 
+ *     # Flow control for writes from APP socket
+ */
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__call_eof_received {
+  int __pyx_n;
+  PyObject *context;
+};
+
+/* "uvloop/sslproto.pxd":124
+ *     # Flow control for writes from APP socket
+ * 
+ *     cdef _control_app_writing(self, object context=*)             # <<<<<<<<<<<<<<
+ *     cdef size_t _get_write_buffer_size(self)
+ *     cdef _set_write_buffer_limits(self, high=*, low=*)
+ */
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__control_app_writing {
+  int __pyx_n;
+  PyObject *context;
+};
+
+/* "uvloop/sslproto.pxd":126
+ *     cdef _control_app_writing(self, object context=*)
+ *     cdef size_t _get_write_buffer_size(self)
+ *     cdef _set_write_buffer_limits(self, high=*, low=*)             # <<<<<<<<<<<<<<
+ * 
+ *     # Flow control for reads to APP socket
+ */
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_write_buffer_limits {
+  int __pyx_n;
+  PyObject *high;
+  PyObject *low;
+};
+
+/* "uvloop/sslproto.pxd":136
+ * 
+ *     cdef _control_ssl_reading(self)
+ *     cdef _set_read_buffer_limits(self, high=*, low=*)             # <<<<<<<<<<<<<<
+ *     cdef size_t _get_read_buffer_size(self)
+ *     cdef _fatal_error(self, exc, message=*)
+ */
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_read_buffer_limits {
+  int __pyx_n;
+  PyObject *high;
+  PyObject *low;
+};
+
+/* "uvloop/sslproto.pxd":138
+ *     cdef _set_read_buffer_limits(self, high=*, low=*)
+ *     cdef size_t _get_read_buffer_size(self)
+ *     cdef _fatal_error(self, exc, message=*)             # <<<<<<<<<<<<<<
+ */
+struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__fatal_error {
+  int __pyx_n;
+  PyObject *message;
+};
+
+/* "uvloop/handles/udp.pxd":22
+ * 
+ *     cdef _on_receive(self, bytes data, object exc, object addr)
+ *     cdef _on_sent(self, object exc, object context=*)             # <<<<<<<<<<<<<<
+ */
+struct __pyx_opt_args_6uvloop_4loop_12UDPTransport__on_sent {
+  int __pyx_n;
+  PyObject *context;
+};
+
+/* "uvloop/handles/poll.pyx":173
+ *         UVHandle._close(<UVHandle>self)
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):             # <<<<<<<<<<<<<<
+ *         try:
+ *             if self.reading_handle is not None:
+ */
+struct __pyx_opt_args_6uvloop_4loop_6UVPoll__fatal_error {
+  int __pyx_n;
+  PyObject *reason;
+};
+
+/* "uvloop/handles/streamserver.pyx":92
+ *         client._accept(<UVStream>self)
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):             # <<<<<<<<<<<<<<
+ *         # Overload UVHandle._fatal_error
+ * 
+ */
+struct __pyx_opt_args_6uvloop_4loop_14UVStreamServer__fatal_error {
+  int __pyx_n;
+  PyObject *reason;
+};
+
+/* "uvloop/loop.pxd":32
+ * 
+ * 
+ * cdef class Loop:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         uv.uv_loop_t *uvloop
+ */
+struct __pyx_obj_6uvloop_4loop_Loop {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop_Loop *__pyx_vtab;
+  uv_loop_t *uvloop;
+  int _coroutine_debug_set;
+  int _coroutine_origin_tracking_saved_depth;
+  PyObject *slow_callback_duration;
+  int _closed;
+  int _debug;
+  int _running;
+  int _stopping;
+  uint64_t _thread_id;
+  int _thread_is_main;
+  PyObject *_task_factory;
+  PyObject *_exception_handler;
+  PyObject *_default_executor;
+  PyObject *_ready;
+  PyObject *_queued_streams;
+  Py_ssize_t _ready_len;
+  PyObject *_servers;
+  PyObject *_transports;
+  PyObject *_processes;
+  PyObject *_fd_to_reader_fileobj;
+  PyObject *_fd_to_writer_fileobj;
+  PyObject *_signals;
+  PyObject *_signal_handlers;
+  PyObject *_ssock;
+  PyObject *_csock;
+  int _listening_signals;
+  int _old_signal_wakeup_id;
+  PyObject *_timers;
+  PyObject *_polls;
+  struct __pyx_obj_6uvloop_4loop_UVProcess *active_process_handler;
+  struct __pyx_obj_6uvloop_4loop_UVAsync *handler_async;
+  struct __pyx_obj_6uvloop_4loop_UVIdle *handler_idle;
+  struct __pyx_obj_6uvloop_4loop_UVCheck *handler_check__exec_writes;
+  PyObject *_last_error;
+  PyObject *__weakref__;
+  PyObject *_asyncgens;
+  int _asyncgens_shutdown_called;
+  int _executor_shutdown_called;
+  char _recv_buffer[0x3E800];
+  int _recv_buffer_in_use;
+  int _debug_cc;
+  PyObject *_debug_handles_total;
+  PyObject *_debug_handles_closed;
+  PyObject *_debug_handles_current;
+  uint64_t _debug_uv_handles_total;
+  uint64_t _debug_uv_handles_freed;
+  uint64_t _debug_cb_handles_total;
+  uint64_t _debug_cb_handles_count;
+  uint64_t _debug_cb_timer_handles_total;
+  uint64_t _debug_cb_timer_handles_count;
+  uint64_t _debug_stream_shutdown_errors_total;
+  uint64_t _debug_stream_listen_errors_total;
+  uint64_t _debug_stream_read_cb_total;
+  uint64_t _debug_stream_read_cb_errors_total;
+  uint64_t _debug_stream_read_eof_total;
+  uint64_t _debug_stream_read_eof_cb_errors_total;
+  uint64_t _debug_stream_read_errors_total;
+  uint64_t _debug_stream_write_tries;
+  uint64_t _debug_stream_write_errors_total;
+  uint64_t _debug_stream_write_ctx_total;
+  uint64_t _debug_stream_write_ctx_cnt;
+  uint64_t _debug_stream_write_cb_errors_total;
+  uint64_t _poll_read_events_total;
+  uint64_t _poll_read_cb_errors_total;
+  uint64_t _poll_write_events_total;
+  uint64_t _poll_write_cb_errors_total;
+  uint64_t _sock_try_write_total;
+  uint64_t _debug_exception_handler_cnt;
+};
+
+
+/* "uvloop/cbhandles.pxd":1
+ * cdef class Handle:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         Loop loop
+ */
+struct __pyx_obj_6uvloop_4loop_Handle {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop_Handle *__pyx_vtab;
+  struct __pyx_obj_6uvloop_4loop_Loop *loop;
+  PyObject *context;
+  int _cancelled;
+  PyObject *meth_name;
+  int cb_type;
+  void *callback;
+  PyObject *arg1;
+  PyObject *arg2;
+  PyObject *arg3;
+  PyObject *arg4;
+  PyObject *__weakref__;
+  PyObject *_source_traceback;
+};
+
+
+/* "uvloop/cbhandles.pxd":25
+ * 
+ * 
+ * cdef class TimerHandle:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         object callback
+ */
+struct __pyx_obj_6uvloop_4loop_TimerHandle {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop_TimerHandle *__pyx_vtab;
+  PyObject *callback;
+  PyObject *args;
+  int _cancelled;
+  struct __pyx_obj_6uvloop_4loop_UVTimer *timer;
+  struct __pyx_obj_6uvloop_4loop_Loop *loop;
+  PyObject *context;
+  PyObject *_debug_info;
+  PyObject *__weakref__;
+};
+
+
+/* "uvloop/loop.pxd":17
+ * 
+ * 
+ * cdef class UVHandle             # <<<<<<<<<<<<<<
+ * cdef class UVSocketHandle(UVHandle)
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop_UVHandle {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *__pyx_vtab;
+  uv_handle_t *_handle;
+  struct __pyx_obj_6uvloop_4loop_Loop *_loop;
+  PyObject *_source_traceback;
+  int _closed;
+  int _inited;
+  PyObject *context;
+  int _has_handle;
+};
+
+
+/* "uvloop/loop.pxd":18
+ * 
+ * cdef class UVHandle
+ * cdef class UVSocketHandle(UVHandle)             # <<<<<<<<<<<<<<
+ * 
+ * cdef class UVAsync(UVHandle)
+ */
+struct __pyx_obj_6uvloop_4loop_UVSocketHandle {
+  struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
+  PyObject *_fileobj;
+  PyObject *__pyx___cached_socket;
+};
+
+
+/* "uvloop/loop.pxd":20
+ * cdef class UVSocketHandle(UVHandle)
+ * 
+ * cdef class UVAsync(UVHandle)             # <<<<<<<<<<<<<<
+ * cdef class UVTimer(UVHandle)
+ * cdef class UVIdle(UVHandle)
+ */
+struct __pyx_obj_6uvloop_4loop_UVAsync {
+  struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
+  __pyx_t_6uvloop_4loop_method_t callback;
+  PyObject *ctx;
+};
+
+
+/* "uvloop/loop.pxd":22
+ * cdef class UVAsync(UVHandle)
+ * cdef class UVTimer(UVHandle)
+ * cdef class UVIdle(UVHandle)             # <<<<<<<<<<<<<<
+ * 
+ * cdef class UVBaseTransport(UVSocketHandle)
+ */
+struct __pyx_obj_6uvloop_4loop_UVIdle {
+  struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
+  struct __pyx_obj_6uvloop_4loop_Handle *h;
+  int running;
+};
+
+
+/* "uvloop/handles/check.pxd":1
+ * cdef class UVCheck(UVHandle):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         Handle h
+ */
+struct __pyx_obj_6uvloop_4loop_UVCheck {
+  struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
+  struct __pyx_obj_6uvloop_4loop_Handle *h;
+  int running;
+};
+
+
+/* "uvloop/loop.pxd":21
+ * 
+ * cdef class UVAsync(UVHandle)
+ * cdef class UVTimer(UVHandle)             # <<<<<<<<<<<<<<
+ * cdef class UVIdle(UVHandle)
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop_UVTimer {
+  struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
+  __pyx_t_6uvloop_4loop_method_t callback;
+  PyObject *ctx;
+  int running;
+  uint64_t timeout;
+  uint64_t start_t;
+};
+
+
+/* "uvloop/handles/poll.pxd":1
+ * cdef class UVPoll(UVHandle):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int fd
+ */
+struct __pyx_obj_6uvloop_4loop_UVPoll {
+  struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
+  int fd;
+  struct __pyx_obj_6uvloop_4loop_Handle *reading_handle;
+  struct __pyx_obj_6uvloop_4loop_Handle *writing_handle;
+};
+
+
+/* "uvloop/loop.pxd":24
+ * cdef class UVIdle(UVHandle)
+ * 
+ * cdef class UVBaseTransport(UVSocketHandle)             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef object (*method_t)(object)
+ */
+struct __pyx_obj_6uvloop_4loop_UVBaseTransport {
+  struct __pyx_obj_6uvloop_4loop_UVSocketHandle __pyx_base;
+  int _closing;
+  int _protocol_connected;
+  int _protocol_paused;
+  PyObject *_protocol_data_received;
+  size_t _high_water;
+  size_t _low_water;
+  PyObject *_protocol;
+  struct __pyx_obj_6uvloop_4loop_Server *_server;
+  PyObject *_waiter;
+  PyObject *_extra_info;
+  uint32_t _conn_lost;
+  PyObject *__weakref__;
+};
+
+
+/* "uvloop/handles/stream.pxd":1
+ * cdef class UVStream(UVBaseTransport):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         uv.uv_shutdown_t _shutdown_req
+ */
+struct __pyx_obj_6uvloop_4loop_UVStream {
+  struct __pyx_obj_6uvloop_4loop_UVBaseTransport __pyx_base;
+  uv_shutdown_t _shutdown_req;
+  int __pyx___shutting_down;
+  int __pyx___reading;
+  int __pyx___read_error_close;
+  int __pyx___buffered;
+  PyObject *_protocol_get_buffer;
+  PyObject *_protocol_buffer_updated;
+  int _eof;
+  PyObject *_buffer;
+  size_t _buffer_size;
+  Py_buffer _read_pybuf;
+  int _read_pybuf_acquired;
+};
+
+
+/* "uvloop/handles/streamserver.pxd":1
+ * cdef class UVStreamServer(UVSocketHandle):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int backlog
+ */
+struct __pyx_obj_6uvloop_4loop_UVStreamServer {
+  struct __pyx_obj_6uvloop_4loop_UVSocketHandle __pyx_base;
+  int backlog;
+  PyObject *ssl;
+  PyObject *ssl_handshake_timeout;
+  PyObject *ssl_shutdown_timeout;
+  PyObject *protocol_factory;
+  int opened;
+  struct __pyx_obj_6uvloop_4loop_Server *_server;
+};
+
+
+/* "uvloop/handles/tcp.pxd":1
+ * cdef class TCPServer(UVStreamServer):             # <<<<<<<<<<<<<<
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=*)
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop_TCPServer {
+  struct __pyx_obj_6uvloop_4loop_UVStreamServer __pyx_base;
+};
+
+
+/* "uvloop/handles/tcp.pxd":13
+ * 
+ * 
+ * cdef class TCPTransport(UVStream):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         bint __peername_set
+ */
+struct __pyx_obj_6uvloop_4loop_TCPTransport {
+  struct __pyx_obj_6uvloop_4loop_UVStream __pyx_base;
+  int __pyx___peername_set;
+  int __pyx___sockname_set;
+  struct sockaddr_storage __pyx___peername;
+  struct sockaddr_storage __pyx___sockname;
+};
+
+
+/* "uvloop/handles/pipe.pxd":1
+ * cdef class UnixServer(UVStreamServer):             # <<<<<<<<<<<<<<
+ * 
+ *     cdef bind(self, str path)
+ */
+struct __pyx_obj_6uvloop_4loop_UnixServer {
+  struct __pyx_obj_6uvloop_4loop_UVStreamServer __pyx_base;
+};
+
+
+/* "uvloop/handles/pipe.pxd":13
+ * 
+ * 
+ * cdef class UnixTransport(UVStream):             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+struct __pyx_obj_6uvloop_4loop_UnixTransport {
+  struct __pyx_obj_6uvloop_4loop_UVStream __pyx_base;
+};
+
+
+/* "uvloop/handles/pipe.pxd":22
+ * 
+ * 
+ * cdef class ReadUnixTransport(UVStream):             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+struct __pyx_obj_6uvloop_4loop_ReadUnixTransport {
+  struct __pyx_obj_6uvloop_4loop_UVStream __pyx_base;
+};
+
+
+/* "uvloop/handles/pipe.pxd":29
+ * 
+ * 
+ * cdef class WriteUnixTransport(UVStream):             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+struct __pyx_obj_6uvloop_4loop_WriteUnixTransport {
+  struct __pyx_obj_6uvloop_4loop_UVStream __pyx_base;
+};
+
+
+/* "uvloop/handles/process.pxd":1
+ * cdef class UVProcess(UVHandle):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         object _returncode
+ */
+struct __pyx_obj_6uvloop_4loop_UVProcess {
+  struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
+  PyObject *_returncode;
+  PyObject *_pid;
+  PyObject *_errpipe_read;
+  PyObject *_errpipe_write;
+  PyObject *_preexec_fn;
+  int _restore_signals;
+  PyObject *_fds_to_close;
+  uv_process_options_t options;
+  uv_stdio_container_t iocnt[3];
+  PyObject *__pyx___env;
+  char **uv_opt_env;
+  PyObject *__pyx___args;
+  char **uv_opt_args;
+  char *uv_opt_file;
+  PyObject *__pyx___cwd;
+};
+
+
+/* "uvloop/handles/process.pxd":45
+ * 
+ * 
+ * cdef class UVProcessTransport(UVProcess):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         list _exit_waiters
+ */
+struct __pyx_obj_6uvloop_4loop_UVProcessTransport {
+  struct __pyx_obj_6uvloop_4loop_UVProcess __pyx_base;
+  PyObject *_exit_waiters;
+  PyObject *_init_futs;
+  int _stdio_ready;
+  PyObject *_pending_calls;
+  PyObject *_protocol;
+  int _finished;
+  struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *_stdin;
+  struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *_stdout;
+  struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *_stderr;
+  PyObject *stdin_proto;
+  PyObject *stdout_proto;
+  PyObject *stderr_proto;
+};
+
+
+/* "uvloop/request.pxd":1
+ * cdef class UVRequest:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         uv.uv_req_t *request
+ */
+struct __pyx_obj_6uvloop_4loop_UVRequest {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop_UVRequest *__pyx_vtab;
+  uv_req_t *request;
+  int done;
+  struct __pyx_obj_6uvloop_4loop_Loop *loop;
+};
+
+
+/* "uvloop/sslproto.pxd":25
+ * 
+ * 
+ * cdef class _SSLProtocolTransport:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         Loop _loop
+ */
+struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop_Loop *_loop;
+  struct __pyx_obj_6uvloop_4loop_SSLProtocol *_ssl_protocol;
+  int _closed;
+  PyObject *context;
+};
+
+
+/* "uvloop/sslproto.pxd":33
+ * 
+ * 
+ * cdef class SSLProtocol:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         bint _server_side
+ */
+struct __pyx_obj_6uvloop_4loop_SSLProtocol {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *__pyx_vtab;
+  int _server_side;
+  PyObject *_server_hostname;
+  PyObject *_sslcontext;
+  PyObject *_extra;
+  PyObject *_write_backlog;
+  size_t _write_buffer_size;
+  PyObject *_waiter;
+  struct __pyx_obj_6uvloop_4loop_Loop *_loop;
+  struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *_app_transport;
+  int _app_transport_created;
+  PyObject *_transport;
+  PyObject *_ssl_handshake_timeout;
+  PyObject *_ssl_shutdown_timeout;
+  PyObject *_sslobj;
+  PyObject *_sslobj_read;
+  PyObject *_sslobj_write;
+  PyObject *_incoming;
+  PyObject *_incoming_write;
+  PyObject *_outgoing;
+  PyObject *_outgoing_read;
+  char *_ssl_buffer;
+  size_t _ssl_buffer_len;
+  PyObject *_ssl_buffer_view;
+  enum __pyx_t_6uvloop_4loop_SSLProtocolState _state;
+  size_t _conn_lost;
+  enum __pyx_t_6uvloop_4loop_AppProtocolState _app_state;
+  int _ssl_writing_paused;
+  int _app_reading_paused;
+  size_t _incoming_high_water;
+  size_t _incoming_low_water;
+  int _ssl_reading_paused;
+  int _app_writing_paused;
+  size_t _outgoing_high_water;
+  size_t _outgoing_low_water;
+  PyObject *_app_protocol;
+  int _app_protocol_is_buffer;
+  PyObject *_app_protocol_get_buffer;
+  PyObject *_app_protocol_buffer_updated;
+  PyObject *_handshake_start_time;
+  PyObject *_handshake_timeout_handle;
+  PyObject *_shutdown_timeout_handle;
+};
+
+
+/* "uvloop/handles/udp.pxd":1
+ * cdef class UDPTransport(UVBaseTransport):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         bint __receiving
+ */
+struct __pyx_obj_6uvloop_4loop_UDPTransport {
+  struct __pyx_obj_6uvloop_4loop_UVBaseTransport __pyx_base;
+  int __pyx___receiving;
+  int _family;
+  PyObject *_address;
+};
+
+
+/* "uvloop/server.pxd":1
+ * cdef class Server:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         list _servers
+ */
+struct __pyx_obj_6uvloop_4loop_Server {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop_Server *__pyx_vtab;
+  PyObject *_servers;
+  PyObject *_waiters;
+  int _active_count;
+  struct __pyx_obj_6uvloop_4loop_Loop *_loop;
+  int _serving;
+  PyObject *_serving_forever_fut;
+  PyObject *__weakref__;
+};
+
+
+/* "uvloop/pseudosock.pyx":1
+ * cdef class PseudoSocket:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int _family
+ */
+struct __pyx_obj_6uvloop_4loop_PseudoSocket {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *__pyx_vtab;
+  int _family;
+  int _type;
+  int _proto;
+  int _fd;
+  PyObject *_peername;
+  PyObject *_sockname;
+};
+
+
+/* "uvloop/lru.pyx":5
+ * 
+ * @cython.final
+ * cdef class LruCache:             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+struct __pyx_obj_6uvloop_4loop_LruCache {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop_LruCache *__pyx_vtab;
+  PyObject *_dict;
+  int _maxsize;
+  PyObject *_dict_move_to_end;
+  PyObject *_dict_get;
+};
+
+
+/* "uvloop/handles/stream.pyx":6
+ * @cython.no_gc_clear
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class _StreamWriteContext:             # <<<<<<<<<<<<<<
+ *     # used to hold additional write request information for uv_write
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop__StreamWriteContext {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *__pyx_vtab;
+  uv_write_t req;
+  PyObject *buffers;
+  uv_buf_t uv_bufs_sml[4];
+  Py_buffer py_bufs_sml[4];
+  int py_bufs_sml_inuse;
+  uv_buf_t *uv_bufs;
+  Py_buffer *py_bufs;
+  size_t py_bufs_len;
+  uv_buf_t *uv_bufs_start;
+  size_t uv_bufs_len;
+  struct __pyx_obj_6uvloop_4loop_UVStream *stream;
+  int closed;
+};
+
+
+/* "uvloop/handles/tcp.pyx":185
+ * 
+ * 
+ * cdef class _TCPConnectRequest(UVRequest):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         TCPTransport transport
+ */
+struct __pyx_obj_6uvloop_4loop__TCPConnectRequest {
+  struct __pyx_obj_6uvloop_4loop_UVRequest __pyx_base;
+  struct __pyx_obj_6uvloop_4loop_TCPTransport *transport;
+  uv_connect_t _req_data;
+};
+
+
+/* "uvloop/handles/pipe.pyx":188
+ * 
+ * 
+ * cdef class _PipeConnectRequest(UVRequest):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         UnixTransport transport
+ */
+struct __pyx_obj_6uvloop_4loop__PipeConnectRequest {
+  struct __pyx_obj_6uvloop_4loop_UVRequest __pyx_base;
+  struct __pyx_obj_6uvloop_4loop_UnixTransport *transport;
+  uv_connect_t _req_data;
+};
+
+
+/* "uvloop/dns.pyx":72
+ * 
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class SockAddrHolder:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int family
+ */
+struct __pyx_obj_6uvloop_4loop_SockAddrHolder {
+  PyObject_HEAD
+  int family;
+  struct sockaddr_storage addr;
+  Py_ssize_t addr_size;
+};
+
+
+/* "uvloop/dns.pyx":252
+ * 
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class AddrInfo:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         system.addrinfo *data
+ */
+struct __pyx_obj_6uvloop_4loop_AddrInfo {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop_AddrInfo *__pyx_vtab;
+  struct addrinfo *data;
+};
+
+
+/* "uvloop/dns.pyx":296
+ * 
+ * 
+ * cdef class AddrInfoRequest(UVRequest):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         system.addrinfo hints
+ */
+struct __pyx_obj_6uvloop_4loop_AddrInfoRequest {
+  struct __pyx_obj_6uvloop_4loop_UVRequest __pyx_base;
+  struct addrinfo hints;
+  PyObject *callback;
+  uv_getaddrinfo_t _req_data;
+};
+
+
+/* "uvloop/dns.pyx":351
+ * 
+ * 
+ * cdef class NameInfoRequest(UVRequest):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         object callback
+ */
+struct __pyx_obj_6uvloop_4loop_NameInfoRequest {
+  struct __pyx_obj_6uvloop_4loop_UVRequest __pyx_base;
+  PyObject *callback;
+  uv_getnameinfo_t _req_data;
+};
+
+
+/* "uvloop/handles/udp.pyx":3
+ * @cython.no_gc_clear
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class _UDPSendContext:             # <<<<<<<<<<<<<<
+ *     # used to hold additional write request information for uv_write
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop__UDPSendContext {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_6uvloop_4loop__UDPSendContext *__pyx_vtab;
+  uv_udp_send_t req;
+  uv_buf_t uv_buf;
+  Py_buffer py_buf;
+  struct __pyx_obj_6uvloop_4loop_UDPTransport *udp;
+  int closed;
+};
+
+
+/* "uvloop/loop.pyx":892
+ *         return poll.is_writing()
+ * 
+ *     cdef _getaddrinfo(self, object host, object port,             # <<<<<<<<<<<<<<
+ *                       int family, int type,
+ *                       int proto, int flags,
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo {
+  PyObject_HEAD
+  PyObject *__pyx_v_fut;
+  int __pyx_v_unpack;
+};
+
+
+/* "uvloop/loop.pyx":934
+ *         return fut
+ * 
+ *     cdef _getnameinfo(self, system.sockaddr *addr, int flags):             # <<<<<<<<<<<<<<
+ *         cdef NameInfoRequest nr
+ *         fut = self._new_future()
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo {
+  PyObject_HEAD
+  PyObject *__pyx_v_fut;
+};
+
+
+/* "uvloop/loop.pyx":1249
+ * 
+ *     property print_debug_info:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 return lambda: self._print_debug_info()
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+};
+
+
+/* "uvloop/loop.pyx":1457
+ *         return self._task_factory
+ * 
+ *     def run_until_complete(self, future):             # <<<<<<<<<<<<<<
+ *         """Run until the Future is done.
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+};
+
+
+/* "uvloop/loop.pyx":1504
+ * 
+ *     @cython.iterable_coroutine
+ *     async def getaddrinfo(self, object host, object port, *,             # <<<<<<<<<<<<<<
+ *                           int family=0, int type=0, int proto=0, int flags=0):
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo {
+  PyObject_HEAD
+  PyObject *__pyx_v_addr;
+  int __pyx_v_family;
+  int __pyx_v_flags;
+  PyObject *__pyx_v_fut;
+  PyObject *__pyx_v_host;
+  PyObject *__pyx_v_port;
+  int __pyx_v_proto;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  int __pyx_v_type;
+};
+
+
+/* "uvloop/loop.pyx":1518
+ * 
+ *     @cython.iterable_coroutine
+ *     async def getnameinfo(self, sockaddr, int flags=0):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             AddrInfo ai_cnt
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo {
+  PyObject_HEAD
+  struct addrinfo *__pyx_v_ai;
+  struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_ai_cnt;
+  int __pyx_v_flags;
+  PyObject *__pyx_v_flowinfo;
+  PyObject *__pyx_v_scope_id;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  struct sockaddr_in6 *__pyx_v_sin6;
+  Py_ssize_t __pyx_v_sl;
+  PyObject *__pyx_v_sockaddr;
+};
+
+
+/* "uvloop/loop.pyx":1573
+ * 
+ *     @cython.iterable_coroutine
+ *     async def start_tls(self, transport, protocol, sslcontext, *,             # <<<<<<<<<<<<<<
+ *                         server_side=False,
+ *                         server_hostname=None,
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls {
+  PyObject_HEAD
+  PyObject *__pyx_v_app_transport;
+  PyObject *__pyx_v_conmade_cb;
+  PyObject *__pyx_v_context;
+  PyObject *__pyx_v_protocol;
+  PyObject *__pyx_v_resume_cb;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_server_hostname;
+  PyObject *__pyx_v_server_side;
+  PyObject *__pyx_v_ssl_handshake_timeout;
+  struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_ssl_protocol;
+  PyObject *__pyx_v_ssl_shutdown_timeout;
+  PyObject *__pyx_v_sslcontext;
+  PyObject *__pyx_v_transport;
+  PyObject *__pyx_v_waiter;
+  PyObject *__pyx_t_0;
+  PyObject *__pyx_t_1;
+  PyObject *__pyx_t_2;
+};
+
+
+/* "uvloop/loop.pyx":1629
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_server(self, protocol_factory, host=None, port=None,             # <<<<<<<<<<<<<<
+ *                             *,
+ *                             int family=uv.AF_UNSPEC,
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server {
+  PyObject_HEAD
+  struct addrinfo *__pyx_v_addrinfo;
+  PyObject *__pyx_v_backlog;
+  int __pyx_v_completed;
+  PyObject *__pyx_v_err;
+  int __pyx_v_family;
+  int __pyx_v_flags;
+  PyObject *__pyx_v_fs;
+  PyObject *__pyx_7genexpr__pyx_v_host;
+  PyObject *__pyx_v_host;
+  PyObject *__pyx_v_hosts;
+  PyObject *__pyx_v_info;
+  PyObject *__pyx_v_infos;
+  PyObject *__pyx_v_port;
+  PyObject *__pyx_v_protocol_factory;
+  PyObject *__pyx_v_pyaddr;
+  PyObject *__pyx_v_reuse_address;
+  PyObject *__pyx_v_reuse_port;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server;
+  PyObject *__pyx_v_sock;
+  PyObject *__pyx_v_ssl;
+  PyObject *__pyx_v_ssl_handshake_timeout;
+  PyObject *__pyx_v_ssl_shutdown_timeout;
+  PyObject *__pyx_v_start_serving;
+  struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_tcp;
+};
+
+
+/* "uvloop/loop.pyx":1839
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_connection(self, protocol_factory, host=None, port=None,             # <<<<<<<<<<<<<<
+ *                                 *,
+ *                                 ssl=None,
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection {
+  PyObject_HEAD
+  PyObject *__pyx_v_addr;
+  struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_ai_local;
+  struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_ai_remote;
+  PyObject *__pyx_v_app_protocol;
+  PyObject *__pyx_v_app_transport;
+  PyObject *__pyx_v_context;
+  PyObject *__pyx_v_exc;
+  PyObject *__pyx_v_exceptions;
+  PyObject *__pyx_v_f1;
+  PyObject *__pyx_v_f2;
+  PyObject *__pyx_v_family;
+  PyObject *__pyx_v_flags;
+  PyObject *__pyx_v_fs;
+  PyObject *__pyx_v_genexpr;
+  PyObject *__pyx_v_host;
+  struct addrinfo *__pyx_v_lai;
+  struct sockaddr_storage __pyx_v_lai_addr_static;
+  struct addrinfo *__pyx_v_lai_iter;
+  struct addrinfo __pyx_v_lai_static;
+  PyObject *__pyx_v_local_addr;
+  PyObject *__pyx_v_model;
+  PyObject *__pyx_v_port;
+  PyObject *__pyx_v_proto;
+  PyObject *__pyx_v_protocol;
+  PyObject *__pyx_v_protocol_factory;
+  struct addrinfo *__pyx_v_rai;
+  struct sockaddr_storage __pyx_v_rai_addr_static;
+  struct addrinfo *__pyx_v_rai_iter;
+  struct addrinfo __pyx_v_rai_static;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_server_hostname;
+  PyObject *__pyx_v_sock;
+  PyObject *__pyx_v_ssl;
+  PyObject *__pyx_v_ssl_handshake_timeout;
+  PyObject *__pyx_v_ssl_shutdown_timeout;
+  PyObject *__pyx_v_ssl_waiter;
+  PyObject *__pyx_v_sslcontext;
+  struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_tr;
+  PyObject *__pyx_v_waiter;
+  PyObject *__pyx_t_0;
+  PyObject *__pyx_t_1;
+  PyObject *__pyx_t_2;
+};
+
+
+/* "uvloop/loop.pyx":2023
+ *                 # If they all have the same str(), raise one.
+ *                 model = str(exceptions[0])
+ *                 if all(str(exc) == model for exc in exceptions):             # <<<<<<<<<<<<<<
+ *                     raise exceptions[0]
+ *                 # Raise a combined exception so the user can see all
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *__pyx_outer_scope;
+  PyObject *__pyx_v_exc;
+};
+
+
+/* "uvloop/loop.pyx":2028
+ *                 # the various error messages.
+ *                 raise OSError('Multiple exceptions: {}'.format(
+ *                     ', '.join(str(exc) for exc in exceptions)))             # <<<<<<<<<<<<<<
+ *         else:
+ *             if sock is None:
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *__pyx_outer_scope;
+  PyObject *__pyx_v_exc;
+};
+
+
+/* "uvloop/loop.pyx":2075
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_unix_server(self, protocol_factory, path=None,             # <<<<<<<<<<<<<<
+ *                                  *, backlog=100, sock=None, ssl=None,
+ *                                  ssl_handshake_timeout=None,
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server {
+  PyObject_HEAD
+  PyObject *__pyx_v_backlog;
+  PyObject *__pyx_v_err;
+  PyObject *__pyx_v_exc;
+  PyObject *__pyx_v_msg;
+  PyObject *__pyx_v_orig_path;
+  PyObject *__pyx_v_path;
+  struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_pipe;
+  PyObject *__pyx_v_protocol_factory;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server;
+  PyObject *__pyx_v_sock;
+  PyObject *__pyx_v_ssl;
+  PyObject *__pyx_v_ssl_handshake_timeout;
+  PyObject *__pyx_v_ssl_shutdown_timeout;
+  PyObject *__pyx_v_start_serving;
+};
+
+
+/* "uvloop/loop.pyx":2203
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_unix_connection(self, protocol_factory, path=None, *,             # <<<<<<<<<<<<<<
+ *                                      ssl=None, sock=None,
+ *                                      server_hostname=None,
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection {
+  PyObject_HEAD
+  PyObject *__pyx_v_app_protocol;
+  PyObject *__pyx_v_app_transport;
+  PyObject *__pyx_v_context;
+  PyObject *__pyx_v_path;
+  PyObject *__pyx_v_protocol;
+  PyObject *__pyx_v_protocol_factory;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_server_hostname;
+  PyObject *__pyx_v_sock;
+  PyObject *__pyx_v_ssl;
+  PyObject *__pyx_v_ssl_handshake_timeout;
+  PyObject *__pyx_v_ssl_shutdown_timeout;
+  PyObject *__pyx_v_ssl_waiter;
+  PyObject *__pyx_v_sslcontext;
+  struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_tr;
+  PyObject *__pyx_v_waiter;
+  PyObject *__pyx_t_0;
+  PyObject *__pyx_t_1;
+  PyObject *__pyx_t_2;
+};
+
+
+/* "uvloop/loop.pyx":2443
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_recv(self, sock, n):             # <<<<<<<<<<<<<<
+ *         """Receive data from the socket.
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv {
+  PyObject_HEAD
+  PyObject *__pyx_v_fut;
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle;
+  PyObject *__pyx_v_n;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_sock;
+};
+
+
+/* "uvloop/loop.pyx":2471
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_recv_into(self, sock, buf):             # <<<<<<<<<<<<<<
+ *         """Receive data from the socket.
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into {
+  PyObject_HEAD
+  PyObject *__pyx_v_buf;
+  PyObject *__pyx_v_fut;
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_sock;
+};
+
+
+/* "uvloop/loop.pyx":2498
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_sendall(self, sock, data):             # <<<<<<<<<<<<<<
+ *         """Send data to the socket.
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall {
+  PyObject_HEAD
+  PyObject *__pyx_v_data;
+  PyObject *__pyx_v_fut;
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle;
+  Py_ssize_t __pyx_v_n;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_sock;
+};
+
+
+/* "uvloop/loop.pyx":2552
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_accept(self, sock):             # <<<<<<<<<<<<<<
+ *         """Accept a connection.
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept {
+  PyObject_HEAD
+  PyObject *__pyx_v_fut;
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_sock;
+};
+
+
+/* "uvloop/loop.pyx":2581
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_connect(self, sock, address):             # <<<<<<<<<<<<<<
+ *         """Connect to a remote socket at address.
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect {
+  PyObject_HEAD
+  PyObject *__pyx_v__;
+  PyObject *__pyx_v_address;
+  PyObject *__pyx_v_addrs;
+  PyObject *__pyx_v_fut;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_sock;
+};
+
+
+/* "uvloop/loop.pyx":2605
+ * 
+ *     @cython.iterable_coroutine
+ *     async def connect_accepted_socket(self, protocol_factory, sock, *,             # <<<<<<<<<<<<<<
+ *                                       ssl=None,
+ *                                       ssl_handshake_timeout=None,
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket {
+  PyObject_HEAD
+  PyObject *__pyx_v_app_protocol;
+  PyObject *__pyx_v_app_transport;
+  PyObject *__pyx_v_context;
+  PyObject *__pyx_v_protocol;
+  PyObject *__pyx_v_protocol_factory;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_sock;
+  PyObject *__pyx_v_ssl;
+  PyObject *__pyx_v_ssl_handshake_timeout;
+  PyObject *__pyx_v_ssl_shutdown_timeout;
+  struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_transport;
+  PyObject *__pyx_v_transport_waiter;
+  PyObject *__pyx_v_waiter;
+  PyObject *__pyx_t_0;
+  PyObject *__pyx_t_1;
+  PyObject *__pyx_t_2;
+};
+
+
+/* "uvloop/loop.pyx":2708
+ * 
+ *     @cython.iterable_coroutine
+ *     async def __subprocess_run(self, protocol_factory, args,             # <<<<<<<<<<<<<<
+ *                                stdin=subprocess_PIPE,
+ *                                stdout=subprocess_PIPE,
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run {
+  PyObject_HEAD
+  PyObject *__pyx_v___uvloop_sleep_after_fork;
+  PyObject *__pyx_v_args;
+  PyObject *__pyx_v_bufsize;
+  PyObject *__pyx_v_close_fds;
+  PyObject *__pyx_v_creationflags;
+  PyObject *__pyx_v_cwd;
+  int __pyx_v_debug_flags;
+  PyObject *__pyx_v_env;
+  PyObject *__pyx_v_executable;
+  PyObject *__pyx_v_pass_fds;
+  PyObject *__pyx_v_preexec_fn;
+  struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_proc;
+  PyObject *__pyx_v_protocol;
+  PyObject *__pyx_v_protocol_factory;
+  PyObject *__pyx_v_restore_signals;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_shell;
+  PyObject *__pyx_v_start_new_session;
+  PyObject *__pyx_v_startupinfo;
+  PyObject *__pyx_v_stderr;
+  PyObject *__pyx_v_stdin;
+  PyObject *__pyx_v_stdout;
+  PyObject *__pyx_v_universal_newlines;
+  PyObject *__pyx_v_waiter;
+  PyObject *__pyx_t_0;
+  PyObject *__pyx_t_1;
+  PyObject *__pyx_t_2;
+};
+
+
+/* "uvloop/loop.pyx":2770
+ * 
+ *     @cython.iterable_coroutine
+ *     async def subprocess_shell(self, protocol_factory, cmd, *,             # <<<<<<<<<<<<<<
+ *                                shell=True,
+ *                                **kwargs):
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell {
+  PyObject_HEAD
+  PyObject *__pyx_v_args;
+  PyObject *__pyx_v_cmd;
+  PyObject *__pyx_v_kwargs;
+  PyObject *__pyx_v_protocol_factory;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_shell;
+};
+
+
+/* "uvloop/loop.pyx":2785
+ * 
+ *     @cython.iterable_coroutine
+ *     async def subprocess_exec(self, protocol_factory, program, *args,             # <<<<<<<<<<<<<<
+ *                               shell=False, **kwargs):
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec {
+  PyObject_HEAD
+  PyObject *__pyx_v_args;
+  PyObject *__pyx_v_kwargs;
+  PyObject *__pyx_v_program;
+  PyObject *__pyx_v_protocol_factory;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_shell;
+};
+
+
+/* "uvloop/loop.pyx":2797
+ * 
+ *     @cython.iterable_coroutine
+ *     async def connect_read_pipe(self, proto_factory, pipe):             # <<<<<<<<<<<<<<
+ *         """Register read pipe in event loop. Set the pipe to non-blocking mode.
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe {
+  PyObject_HEAD
+  PyObject *__pyx_v_pipe;
+  PyObject *__pyx_v_proto;
+  PyObject *__pyx_v_proto_factory;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_transp;
+  PyObject *__pyx_v_waiter;
+  PyObject *__pyx_t_0;
+  PyObject *__pyx_t_1;
+  PyObject *__pyx_t_2;
+};
+
+
+/* "uvloop/loop.pyx":2824
+ * 
+ *     @cython.iterable_coroutine
+ *     async def connect_write_pipe(self, proto_factory, pipe):             # <<<<<<<<<<<<<<
+ *         """Register write pipe in event loop.
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe {
+  PyObject_HEAD
+  PyObject *__pyx_v_pipe;
+  PyObject *__pyx_v_proto;
+  PyObject *__pyx_v_proto_factory;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_transp;
+  PyObject *__pyx_v_waiter;
+  PyObject *__pyx_t_0;
+  PyObject *__pyx_t_1;
+  PyObject *__pyx_t_2;
+};
+
+
+/* "uvloop/loop.pyx":2955
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_datagram_endpoint(self, protocol_factory,             # <<<<<<<<<<<<<<
+ *                                        local_addr=None, remote_addr=None, *,
+ *                                        family=0, proto=0, flags=0,
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint {
+  PyObject_HEAD
+  PyObject *__pyx_v_allow_broadcast;
+  PyObject *__pyx_v_ctx;
+  PyObject *__pyx_v_ex;
+  PyObject *__pyx_v_excs;
+  PyObject *__pyx_v_family;
+  PyObject *__pyx_v_flags;
+  PyObject *__pyx_v_genexpr;
+  PyObject *__pyx_v_lads;
+  struct addrinfo *__pyx_v_lai;
+  PyObject *__pyx_v_local_addr;
+  PyObject *__pyx_v_opts;
+  PyObject *__pyx_v_problems;
+  PyObject *__pyx_v_proto;
+  PyObject *__pyx_v_protocol;
+  PyObject *__pyx_v_protocol_factory;
+  PyObject *__pyx_v_rads;
+  struct addrinfo *__pyx_v_rai;
+  PyObject *__pyx_v_remote_addr;
+  PyObject *__pyx_v_reuse_address;
+  PyObject *__pyx_v_reuse_port;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_sock;
+  struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_udp;
+  PyObject *__pyx_v_waiter;
+};
+
+
+/* "uvloop/loop.pyx":3001
+ *                             allow_broadcast=allow_broadcast)
+ *                 problems = ', '.join(
+ *                     '{}={}'.format(k, v) for k, v in opts.items() if v)             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'socket modifier keyword arguments can not be used '
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *__pyx_outer_scope;
+  PyObject *__pyx_v_k;
+  PyObject *__pyx_v_v;
+};
+
+
+/* "uvloop/loop.pyx":3138
+ * 
+ *     @cython.iterable_coroutine
+ *     async def shutdown_asyncgens(self):             # <<<<<<<<<<<<<<
+ *         """Shutdown all active asynchronous generators."""
+ *         self._asyncgens_shutdown_called = True
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens {
+  PyObject_HEAD
+  PyObject *__pyx_8genexpr4__pyx_v_ag;
+  PyObject *__pyx_v_agen;
+  PyObject *__pyx_v_closing_agens;
+  PyObject *__pyx_v_result;
+  PyObject *__pyx_v_results;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_shutdown_coro;
+};
+
+
+/* "uvloop/loop.pyx":3163
+ * 
+ *     @cython.iterable_coroutine
+ *     async def shutdown_default_executor(self):             # <<<<<<<<<<<<<<
+ *         """Schedule the shutdown of the default executor."""
+ *         self._executor_shutdown_called = True
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor {
+  PyObject_HEAD
+  PyObject *__pyx_v_future;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
+  PyObject *__pyx_v_thread;
+};
+
+
+/* "uvloop/sslproto.pyx":462
+ *     # Handshake flow
+ * 
+ *     cdef _start_handshake(self):             # <<<<<<<<<<<<<<
+ *         if self._loop.get_debug():
+ *             aio_logger.debug("%r starts SSL handshake", self)
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self;
+};
+
+
+/* "uvloop/sslproto.pyx":559
+ *     # Shutdown flow
+ * 
+ *     cdef _start_shutdown(self, object context=None):             # <<<<<<<<<<<<<<
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+ *             return
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self;
+};
+
+
+/* "uvloop/server.pyx":52
+ * 
+ *     @cython.iterable_coroutine
+ *     async def __aenter__(self):             # <<<<<<<<<<<<<<
+ *         return self
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self;
+};
+
+
+/* "uvloop/server.pyx":56
+ * 
+ *     @cython.iterable_coroutine
+ *     async def __aexit__(self, *exc):             # <<<<<<<<<<<<<<
+ *         self.close()
+ *         await self.wait_closed()
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ {
+  PyObject_HEAD
+  PyObject *__pyx_v_exc;
+  struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self;
+};
+
+
+/* "uvloop/server.pyx":67
+ * 
+ *     @cython.iterable_coroutine
+ *     async def wait_closed(self):             # <<<<<<<<<<<<<<
+ *         # Do not remove `self._servers is None` below
+ *         # because close() method only closes server sockets
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self;
+  PyObject *__pyx_v_waiter;
+};
+
+
+/* "uvloop/server.pyx":100
+ * 
+ *     @cython.iterable_coroutine
+ *     async def start_serving(self):             # <<<<<<<<<<<<<<
+ *         self._start_serving()
+ * 
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self;
+};
+
+
+/* "uvloop/server.pyx":104
+ * 
+ *     @cython.iterable_coroutine
+ *     async def serve_forever(self):             # <<<<<<<<<<<<<<
+ *         if self._serving_forever_fut is not None:
+ *             raise RuntimeError(
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever {
+  PyObject_HEAD
+  struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self;
+  PyObject *__pyx_t_0;
+  PyObject *__pyx_t_1;
+  PyObject *__pyx_t_2;
+  PyObject *__pyx_t_3;
+  PyObject *__pyx_t_4;
+  PyObject *__pyx_t_5;
+};
+
+
+/* "uvloop/loop.pyx":3334
+ * 
+ * @cython.iterable_coroutine
+ * async def _test_coroutine_1():             # <<<<<<<<<<<<<<
+ *     return 42
+ */
+struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 {
+  PyObject_HEAD
+};
+
+
+/* "cfunc.to_py":64
+ * 
+ * @cname("__Pyx_CFunc_object____Loop____bint___to_py")
+ * cdef object __Pyx_CFunc_object____Loop____bint___to_py(object (*f)(Loop, bint) ):             # <<<<<<<<<<<<<<
+ *     def wrap(Loop self, bint enabled):
+ *         """wrap(self: 'Loop', enabled: bool)"""
+ */
+struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py {
+  PyObject_HEAD
+  PyObject *(*__pyx_v_f)(struct __pyx_obj_6uvloop_4loop_Loop *, int);
+};
+
+
+
+/* "uvloop/handles/handle.pyx":1
+ * cdef class UVHandle:             # <<<<<<<<<<<<<<
+ *     """A base class for all libuv handles.
+ * 
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVHandle {
+  PyObject *(*_start_init)(struct __pyx_obj_6uvloop_4loop_UVHandle *, struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_abort_init)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
+  PyObject *(*_finish_init)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
+  int (*_is_alive)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
+  PyObject *(*_ensure_alive)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
+  PyObject *(*_error)(struct __pyx_obj_6uvloop_4loop_UVHandle *, PyObject *, PyObject *);
+  PyObject *(*_fatal_error)(struct __pyx_obj_6uvloop_4loop_UVHandle *, PyObject *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error *__pyx_optional_args);
+  PyObject *(*_warn_unclosed)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
+  PyObject *(*_free)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
+  PyObject *(*_close)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *__pyx_vtabptr_6uvloop_4loop_UVHandle;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__start_init(struct __pyx_obj_6uvloop_4loop_UVHandle *, struct __pyx_obj_6uvloop_4loop_Loop *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__abort_init(struct __pyx_obj_6uvloop_4loop_UVHandle *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__finish_init(struct __pyx_obj_6uvloop_4loop_UVHandle *);
+static CYTHON_INLINE int __pyx_f_6uvloop_4loop_8UVHandle__is_alive(struct __pyx_obj_6uvloop_4loop_UVHandle *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__ensure_alive(struct __pyx_obj_6uvloop_4loop_UVHandle *);
+
+
+/* "uvloop/handles/handle.pyx":221
+ * 
+ * 
+ * cdef class UVSocketHandle(UVHandle):             # <<<<<<<<<<<<<<
+ * 
+ *     def __cinit__(self):
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
+  PyObject *(*_fileno)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *);
+  PyObject *(*_new_socket)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *);
+  PyObject *(*_get_socket)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *);
+  PyObject *(*_attach_fileobj)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, PyObject *);
+  PyObject *(*_open)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, int);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle *__pyx_vtabptr_6uvloop_4loop_UVSocketHandle;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__get_socket(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__attach_fileobj(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, PyObject *);
+
+
+/* "uvloop/handles/async_.pyx":2
+ * @cython.no_gc_clear
+ * cdef class UVAsync(UVHandle):             # <<<<<<<<<<<<<<
+ *     cdef _init(self, Loop loop, method_t callback, object ctx):
+ *         cdef int err
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVAsync {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
+  PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVAsync *, struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *);
+  PyObject *(*send)(struct __pyx_obj_6uvloop_4loop_UVAsync *);
+  struct __pyx_obj_6uvloop_4loop_UVAsync *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *__pyx_vtabptr_6uvloop_4loop_UVAsync;
+
+
+/* "uvloop/handles/timer.pyx":2
+ * @cython.no_gc_clear
+ * cdef class UVTimer(UVHandle):             # <<<<<<<<<<<<<<
+ *     cdef _init(self, Loop loop, method_t callback, object ctx,
+ *                uint64_t timeout):
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVTimer {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
+  PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVTimer *, struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *, uint64_t);
+  PyObject *(*stop)(struct __pyx_obj_6uvloop_4loop_UVTimer *);
+  PyObject *(*start)(struct __pyx_obj_6uvloop_4loop_UVTimer *);
+  PyObject *(*get_when)(struct __pyx_obj_6uvloop_4loop_UVTimer *);
+  struct __pyx_obj_6uvloop_4loop_UVTimer *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *, uint64_t);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *__pyx_vtabptr_6uvloop_4loop_UVTimer;
+
+
+/* "uvloop/handles/idle.pyx":2
+ * @cython.no_gc_clear
+ * cdef class UVIdle(UVHandle):             # <<<<<<<<<<<<<<
+ *     cdef _init(self, Loop loop, Handle h):
+ *         cdef int err
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVIdle {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
+  PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVIdle *, struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
+  PyObject *(*stop)(struct __pyx_obj_6uvloop_4loop_UVIdle *);
+  PyObject *(*start)(struct __pyx_obj_6uvloop_4loop_UVIdle *);
+  struct __pyx_obj_6uvloop_4loop_UVIdle *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *__pyx_vtabptr_6uvloop_4loop_UVIdle;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVIdle_stop(struct __pyx_obj_6uvloop_4loop_UVIdle *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVIdle_start(struct __pyx_obj_6uvloop_4loop_UVIdle *);
+
+
+/* "uvloop/handles/basetransport.pyx":1
+ * cdef class UVBaseTransport(UVSocketHandle):             # <<<<<<<<<<<<<<
+ * 
+ *     def __cinit__(self):
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle __pyx_base;
+  PyObject *(*_maybe_pause_protocol)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+  PyObject *(*_maybe_resume_protocol)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+  PyObject *(*_schedule_call_connection_made)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+  PyObject *(*_schedule_call_connection_lost)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
+  PyObject *(*_wakeup_waiter)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+  PyObject *(*_call_connection_made)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+  PyObject *(*_call_connection_lost)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
+  PyObject *(*_set_server)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, struct __pyx_obj_6uvloop_4loop_Server *);
+  PyObject *(*_set_waiter)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
+  PyObject *(*_set_protocol)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
+  PyObject *(*_clear_protocol)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+  PyObject *(*_init_protocol)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+  PyObject *(*_add_extra_info)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *, PyObject *);
+  size_t (*_get_write_buffer_size)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+  int (*_is_reading)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+  PyObject *(*_start_reading)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+  PyObject *(*_stop_reading)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *__pyx_vtabptr_6uvloop_4loop_UVBaseTransport;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_pause_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_resume_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_made(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_lost(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_server(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, struct __pyx_obj_6uvloop_4loop_Server *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_waiter(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__init_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__add_extra_info(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *, PyObject *);
+
+
+/* "uvloop/loop.pyx":126
+ * 
+ * @cython.no_gc_clear
+ * cdef class Loop:             # <<<<<<<<<<<<<<
+ *     def __cinit__(self):
+ *         cdef int err
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_Loop {
+  PyObject *(*_init_debug_fields)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_on_wake)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_on_idle)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*__pyx___run)(struct __pyx_obj_6uvloop_4loop_Loop *, uv_run_mode);
+  PyObject *(*_run)(struct __pyx_obj_6uvloop_4loop_Loop *, uv_run_mode);
+  PyObject *(*_close)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_stop)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+  uint64_t (*_time)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_queue_write)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVStream *);
+  PyObject *(*_exec_queued_writes)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_call_soon)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *);
+  PyObject *(*_append_ready_handle)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
+  PyObject *(*_call_soon_handle)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
+  PyObject *(*_call_later)(struct __pyx_obj_6uvloop_4loop_Loop *, uint64_t, PyObject *, PyObject *, PyObject *);
+  void (*_handle_exception)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+  PyObject *(*_is_main_thread)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_new_future)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_check_signal)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+  PyObject *(*_check_closed)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_check_thread)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_getaddrinfo)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, int, int, int, int, int);
+  PyObject *(*_getnameinfo)(struct __pyx_obj_6uvloop_4loop_Loop *, struct sockaddr *, int);
+  PyObject *(*_track_transport)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
+  PyObject *(*_fileobj_to_fd)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+  PyObject *(*_ensure_fd_no_transport)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+  PyObject *(*_track_process)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVProcess *);
+  PyObject *(*_untrack_process)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVProcess *);
+  PyObject *(*_add_reader)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Handle *);
+  PyObject *(*_has_reader)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+  PyObject *(*_remove_reader)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+  PyObject *(*_add_writer)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Handle *);
+  PyObject *(*_has_writer)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+  PyObject *(*_remove_writer)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+  PyObject *(*_sock_recv)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *);
+  PyObject *(*_sock_recv_into)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *);
+  PyObject *(*_sock_sendall)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *);
+  PyObject *(*_sock_accept)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *);
+  PyObject *(*_sock_connect)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *);
+  PyObject *(*_sock_connect_cb)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *);
+  PyObject *(*_sock_set_reuseport)(struct __pyx_obj_6uvloop_4loop_Loop *, int);
+  PyObject *(*_setup_or_resume_signals)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_shutdown_signals)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_pause_signals)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_handle_signal)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+  PyObject *(*_read_from_self)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_ceval_process_signals)(struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_invoke_signals)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+  PyObject *(*_set_coroutine_debug)(struct __pyx_obj_6uvloop_4loop_Loop *, int);
+  PyObject *(*_print_debug_info)(struct __pyx_obj_6uvloop_4loop_Loop *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_Loop *__pyx_vtabptr_6uvloop_4loop_Loop;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__queue_write(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVStream *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__append_ready_handle(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon_handle(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__is_main_thread(struct __pyx_obj_6uvloop_4loop_Loop *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__new_future(struct __pyx_obj_6uvloop_4loop_Loop *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_signal(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_closed(struct __pyx_obj_6uvloop_4loop_Loop *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_thread(struct __pyx_obj_6uvloop_4loop_Loop *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__ceval_process_signals(struct __pyx_obj_6uvloop_4loop_Loop *);
+
+
+/* "uvloop/cbhandles.pyx":3
+ * @cython.no_gc_clear
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class Handle:             # <<<<<<<<<<<<<<
+ *     def __cinit__(self):
+ *         self._cancelled = 0
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_Handle {
+  PyObject *(*_set_loop)(struct __pyx_obj_6uvloop_4loop_Handle *, struct __pyx_obj_6uvloop_4loop_Loop *);
+  PyObject *(*_set_context)(struct __pyx_obj_6uvloop_4loop_Handle *, PyObject *);
+  PyObject *(*_run)(struct __pyx_obj_6uvloop_4loop_Handle *);
+  PyObject *(*_cancel)(struct __pyx_obj_6uvloop_4loop_Handle *);
+  PyObject *(*_format_handle)(struct __pyx_obj_6uvloop_4loop_Handle *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_Handle *__pyx_vtabptr_6uvloop_4loop_Handle;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__set_loop(struct __pyx_obj_6uvloop_4loop_Handle *, struct __pyx_obj_6uvloop_4loop_Loop *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__set_context(struct __pyx_obj_6uvloop_4loop_Handle *, PyObject *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__run(struct __pyx_obj_6uvloop_4loop_Handle *);
+
+
+/* "uvloop/cbhandles.pyx":167
+ * @cython.no_gc_clear
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class TimerHandle:             # <<<<<<<<<<<<<<
+ *     def __cinit__(self, Loop loop, object callback, object args,
+ *                   uint64_t delay, object context):
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_TimerHandle {
+  PyObject *(*_run)(struct __pyx_obj_6uvloop_4loop_TimerHandle *);
+  PyObject *(*_cancel)(struct __pyx_obj_6uvloop_4loop_TimerHandle *);
+  PyObject *(*_clear)(struct __pyx_obj_6uvloop_4loop_TimerHandle *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_TimerHandle *__pyx_vtabptr_6uvloop_4loop_TimerHandle;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_11TimerHandle__clear(struct __pyx_obj_6uvloop_4loop_TimerHandle *);
+
+
+/* "uvloop/handles/check.pyx":2
+ * @cython.no_gc_clear
+ * cdef class UVCheck(UVHandle):             # <<<<<<<<<<<<<<
+ *     cdef _init(self, Loop loop, Handle h):
+ *         cdef int err
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVCheck {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
+  PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVCheck *, struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
+  PyObject *(*stop)(struct __pyx_obj_6uvloop_4loop_UVCheck *);
+  PyObject *(*start)(struct __pyx_obj_6uvloop_4loop_UVCheck *);
+  struct __pyx_obj_6uvloop_4loop_UVCheck *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *__pyx_vtabptr_6uvloop_4loop_UVCheck;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_7UVCheck_stop(struct __pyx_obj_6uvloop_4loop_UVCheck *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_7UVCheck_start(struct __pyx_obj_6uvloop_4loop_UVCheck *);
+
+
+/* "uvloop/handles/poll.pyx":2
+ * @cython.no_gc_clear
+ * cdef class UVPoll(UVHandle):             # <<<<<<<<<<<<<<
+ *     cdef _init(self, Loop loop, int fd):
+ *         cdef int err
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVPoll {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
+  PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVPoll *, struct __pyx_obj_6uvloop_4loop_Loop *, int);
+  PyObject *(*_poll_start)(struct __pyx_obj_6uvloop_4loop_UVPoll *, int);
+  PyObject *(*_poll_stop)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
+  int (*is_active)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
+  PyObject *(*is_reading)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
+  PyObject *(*is_writing)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
+  PyObject *(*start_reading)(struct __pyx_obj_6uvloop_4loop_UVPoll *, struct __pyx_obj_6uvloop_4loop_Handle *);
+  PyObject *(*start_writing)(struct __pyx_obj_6uvloop_4loop_UVPoll *, struct __pyx_obj_6uvloop_4loop_Handle *);
+  PyObject *(*stop_reading)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
+  PyObject *(*stop_writing)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
+  PyObject *(*stop)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
+  struct __pyx_obj_6uvloop_4loop_UVPoll *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, int);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *__pyx_vtabptr_6uvloop_4loop_UVPoll;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVPoll__poll_start(struct __pyx_obj_6uvloop_4loop_UVPoll *, int);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVPoll__poll_stop(struct __pyx_obj_6uvloop_4loop_UVPoll *);
+
+
+/* "uvloop/handles/stream.pyx":209
+ * 
+ * @cython.no_gc_clear
+ * cdef class UVStream(UVBaseTransport):             # <<<<<<<<<<<<<<
+ * 
+ *     def __cinit__(self):
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVStream {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport __pyx_base;
+  PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *);
+  PyObject *(*_exec_write)(struct __pyx_obj_6uvloop_4loop_UVStream *);
+  PyObject *(*_shutdown)(struct __pyx_obj_6uvloop_4loop_UVStream *);
+  PyObject *(*_accept)(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_UVStream *);
+  PyObject *(*_close_on_read_error)(struct __pyx_obj_6uvloop_4loop_UVStream *);
+  PyObject *(*__pyx___reading_started)(struct __pyx_obj_6uvloop_4loop_UVStream *);
+  PyObject *(*__pyx___reading_stopped)(struct __pyx_obj_6uvloop_4loop_UVStream *);
+  PyObject *(*_write)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
+  PyObject *(*_try_write)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
+  PyObject *(*_on_accept)(struct __pyx_obj_6uvloop_4loop_UVStream *);
+  PyObject *(*_on_eof)(struct __pyx_obj_6uvloop_4loop_UVStream *);
+  PyObject *(*_on_write)(struct __pyx_obj_6uvloop_4loop_UVStream *);
+  PyObject *(*_on_connect)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVStream *__pyx_vtabptr_6uvloop_4loop_UVStream;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__init(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__exec_write(struct __pyx_obj_6uvloop_4loop_UVStream *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__shutdown(struct __pyx_obj_6uvloop_4loop_UVStream *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__accept(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_UVStream *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__close_on_read_error(struct __pyx_obj_6uvloop_4loop_UVStream *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream___reading_started(struct __pyx_obj_6uvloop_4loop_UVStream *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream___reading_stopped(struct __pyx_obj_6uvloop_4loop_UVStream *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__write(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__try_write(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_accept(struct __pyx_obj_6uvloop_4loop_UVStream *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_eof(struct __pyx_obj_6uvloop_4loop_UVStream *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_write(struct __pyx_obj_6uvloop_4loop_UVStream *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_connect(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
+
+
+/* "uvloop/handles/streamserver.pyx":2
+ * @cython.no_gc_clear
+ * cdef class UVStreamServer(UVSocketHandle):             # <<<<<<<<<<<<<<
+ * 
+ *     def __cinit__(self):
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle __pyx_base;
+  PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *, PyObject *, PyObject *);
+  PyObject *(*_mark_as_open)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
+  PyObject *(*listen)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
+  PyObject *(*_on_listen)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
+  struct __pyx_obj_6uvloop_4loop_UVStream *(*_make_new_transport)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, PyObject *, PyObject *, PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *__pyx_vtabptr_6uvloop_4loop_UVStreamServer;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__init(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *, PyObject *, PyObject *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__mark_as_open(struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer_listen(struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__on_listen(struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
+
+
+/* "uvloop/handles/tcp.pyx":56
+ * 
+ * @cython.no_gc_clear
+ * cdef class TCPServer(UVStreamServer):             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_TCPServer {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer __pyx_base;
+  PyObject *(*bind)(struct __pyx_obj_6uvloop_4loop_TCPServer *, struct sockaddr *, struct __pyx_opt_args_6uvloop_4loop_9TCPServer_bind *__pyx_optional_args);
+  struct __pyx_obj_6uvloop_4loop_TCPServer *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, unsigned int, PyObject *, PyObject *, PyObject *, PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *__pyx_vtabptr_6uvloop_4loop_TCPServer;
+
+
+/* "uvloop/handles/tcp.pyx":103
+ * 
+ * @cython.no_gc_clear
+ * cdef class TCPTransport(UVStream):             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVStream __pyx_base;
+  PyObject *(*bind)(struct __pyx_obj_6uvloop_4loop_TCPTransport *, struct sockaddr *, struct __pyx_opt_args_6uvloop_4loop_12TCPTransport_bind *__pyx_optional_args);
+  PyObject *(*connect)(struct __pyx_obj_6uvloop_4loop_TCPTransport *, struct sockaddr *);
+  PyObject *(*_set_nodelay)(struct __pyx_obj_6uvloop_4loop_TCPTransport *);
+  struct __pyx_obj_6uvloop_4loop_TCPTransport *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *__pyx_vtabptr_6uvloop_4loop_TCPTransport;
+
+
+/* "uvloop/handles/pipe.pyx":40
+ * 
+ * @cython.no_gc_clear
+ * cdef class UnixServer(UVStreamServer):             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UnixServer {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer __pyx_base;
+  PyObject *(*bind)(struct __pyx_obj_6uvloop_4loop_UnixServer *, PyObject *);
+  struct __pyx_obj_6uvloop_4loop_UnixServer *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *, PyObject *, PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *__pyx_vtabptr_6uvloop_4loop_UnixServer;
+
+
+/* "uvloop/handles/pipe.pyx":85
+ * 
+ * @cython.no_gc_clear
+ * cdef class UnixTransport(UVStream):             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVStream __pyx_base;
+  struct __pyx_obj_6uvloop_4loop_UnixTransport *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *);
+  PyObject *(*connect)(struct __pyx_obj_6uvloop_4loop_UnixTransport *, char *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *__pyx_vtabptr_6uvloop_4loop_UnixTransport;
+
+
+/* "uvloop/handles/pipe.pyx":110
+ * 
+ * @cython.no_gc_clear
+ * cdef class ReadUnixTransport(UVStream):             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVStream __pyx_base;
+  struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *__pyx_vtabptr_6uvloop_4loop_ReadUnixTransport;
+
+
+/* "uvloop/handles/pipe.pyx":155
+ * 
+ * @cython.no_gc_clear
+ * cdef class WriteUnixTransport(UVStream):             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVStream __pyx_base;
+  struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *__pyx_vtabptr_6uvloop_4loop_WriteUnixTransport;
+
+
+/* "uvloop/handles/process.pyx":2
+ * @cython.no_gc_clear
+ * cdef class UVProcess(UVHandle):             # <<<<<<<<<<<<<<
+ *     """Abstract class; wrapper over uv_process_t handle."""
+ * 
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVProcess {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
+  PyObject *(*_close_process_handle)(struct __pyx_obj_6uvloop_4loop_UVProcess *);
+  PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVProcess *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *);
+  PyObject *(*_after_fork)(struct __pyx_obj_6uvloop_4loop_UVProcess *);
+  char **(*__pyx___to_cstring_array)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *);
+  PyObject *(*_init_args)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *);
+  PyObject *(*_init_env)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *);
+  PyObject *(*_init_files)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *, PyObject *, PyObject *);
+  PyObject *(*_init_options)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *);
+  PyObject *(*_close_after_spawn)(struct __pyx_obj_6uvloop_4loop_UVProcess *, int);
+  PyObject *(*_on_exit)(struct __pyx_obj_6uvloop_4loop_UVProcess *, int64_t, int);
+  PyObject *(*_kill)(struct __pyx_obj_6uvloop_4loop_UVProcess *, int);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *__pyx_vtabptr_6uvloop_4loop_UVProcess;
+
+
+/* "uvloop/handles/process.pyx":350
+ * 
+ * @cython.no_gc_clear
+ * cdef class UVProcessTransport(UVProcess):             # <<<<<<<<<<<<<<
+ *     def __cinit__(self):
+ *         self._exit_waiters = []
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVProcess __pyx_base;
+  PyObject *(*_file_redirect_stdio)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, int);
+  PyObject *(*_file_devnull)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *);
+  PyObject *(*_file_inpipe)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *);
+  PyObject *(*_file_outpipe)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *);
+  PyObject *(*_check_proc)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *);
+  PyObject *(*_pipe_connection_lost)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, int, PyObject *);
+  PyObject *(*_pipe_data_received)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, int, PyObject *);
+  PyObject *(*_call_connection_made)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, PyObject *);
+  PyObject *(*_try_finish)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *);
+  struct __pyx_obj_6uvloop_4loop_UVProcessTransport *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *__pyx_vtabptr_6uvloop_4loop_UVProcessTransport;
+
+
+/* "uvloop/request.pyx":1
+ * cdef class UVRequest:             # <<<<<<<<<<<<<<
+ *     """A base class for all libuv requests (uv_getaddrinfo_t, etc).
+ * 
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UVRequest {
+  PyObject *(*on_done)(struct __pyx_obj_6uvloop_4loop_UVRequest *);
+  PyObject *(*cancel)(struct __pyx_obj_6uvloop_4loop_UVRequest *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVRequest *__pyx_vtabptr_6uvloop_4loop_UVRequest;
+
+
+/* "uvloop/sslproto.pyx":195
+ * 
+ * 
+ * cdef class SSLProtocol:             # <<<<<<<<<<<<<<
+ *     """SSL protocol.
+ * 
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol {
+  PyObject *(*_set_app_protocol)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *);
+  PyObject *(*_wakeup_waiter)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__wakeup_waiter *__pyx_optional_args);
+  PyObject *(*_get_extra_info)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__get_extra_info *__pyx_optional_args);
+  PyObject *(*_set_state)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, enum __pyx_t_6uvloop_4loop_SSLProtocolState);
+  PyObject *(*_start_handshake)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_check_handshake_timeout)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_do_handshake)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_on_handshake_complete)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *);
+  PyObject *(*_start_shutdown)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__start_shutdown *__pyx_optional_args);
+  PyObject *(*_check_shutdown_timeout)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_do_read_into_void)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *);
+  PyObject *(*_do_flush)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_flush *__pyx_optional_args);
+  PyObject *(*_do_shutdown)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_shutdown *__pyx_optional_args);
+  PyObject *(*_on_shutdown_complete)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *);
+  PyObject *(*_abort)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *);
+  PyObject *(*_write_appdata)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *, PyObject *);
+  PyObject *(*_do_write)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_process_outgoing)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_do_read)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_do_read__buffered)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_do_read__copied)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_call_eof_received)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__call_eof_received *__pyx_optional_args);
+  PyObject *(*_control_app_writing)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__control_app_writing *__pyx_optional_args);
+  size_t (*_get_write_buffer_size)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_set_write_buffer_limits)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_write_buffer_limits *__pyx_optional_args);
+  PyObject *(*_pause_reading)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_resume_reading)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *);
+  PyObject *(*_control_ssl_reading)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_set_read_buffer_limits)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_read_buffer_limits *__pyx_optional_args);
+  size_t (*_get_read_buffer_size)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *);
+  PyObject *(*_fatal_error)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__fatal_error *__pyx_optional_args);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *__pyx_vtabptr_6uvloop_4loop_SSLProtocol;
+
+
+/* "uvloop/handles/udp.pyx":54
+ * 
+ * @cython.no_gc_clear
+ * cdef class UDPTransport(UVBaseTransport):             # <<<<<<<<<<<<<<
+ *     def __cinit__(self):
+ *         self._family = uv.AF_UNSPEC
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport __pyx_base;
+  PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, struct __pyx_obj_6uvloop_4loop_Loop *, unsigned int);
+  PyObject *(*_set_address)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, struct addrinfo *);
+  PyObject *(*_connect)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, struct sockaddr *, size_t);
+  PyObject *(*_bind)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, struct sockaddr *);
+  PyObject *(*open)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, int, int);
+  PyObject *(*_set_broadcast)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, int);
+  PyObject *(*__pyx___receiving_started)(struct __pyx_obj_6uvloop_4loop_UDPTransport *);
+  PyObject *(*__pyx___receiving_stopped)(struct __pyx_obj_6uvloop_4loop_UDPTransport *);
+  PyObject *(*_send)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *, PyObject *);
+  PyObject *(*_on_receive)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *, PyObject *, PyObject *);
+  PyObject *(*_on_sent)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_12UDPTransport__on_sent *__pyx_optional_args);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *__pyx_vtabptr_6uvloop_4loop_UDPTransport;
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_12UDPTransport___receiving_started(struct __pyx_obj_6uvloop_4loop_UDPTransport *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_12UDPTransport___receiving_stopped(struct __pyx_obj_6uvloop_4loop_UDPTransport *);
+
+
+/* "uvloop/server.pyx":4
+ * 
+ * 
+ * cdef class Server:             # <<<<<<<<<<<<<<
+ *     def __cinit__(self, Loop loop):
+ *         self._loop = loop
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_Server {
+  PyObject *(*_add_server)(struct __pyx_obj_6uvloop_4loop_Server *, struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
+  PyObject *(*_start_serving)(struct __pyx_obj_6uvloop_4loop_Server *);
+  PyObject *(*_wakeup)(struct __pyx_obj_6uvloop_4loop_Server *);
+  PyObject *(*_attach)(struct __pyx_obj_6uvloop_4loop_Server *);
+  PyObject *(*_detach)(struct __pyx_obj_6uvloop_4loop_Server *);
+  PyObject *(*_ref)(struct __pyx_obj_6uvloop_4loop_Server *);
+  PyObject *(*_unref)(struct __pyx_obj_6uvloop_4loop_Server *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_Server *__pyx_vtabptr_6uvloop_4loop_Server;
+
+
+/* "uvloop/pseudosock.pyx":1
+ * cdef class PseudoSocket:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int _family
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket {
+  PyObject *(*_na)(struct __pyx_obj_6uvloop_4loop_PseudoSocket *, PyObject *);
+  PyObject *(*_make_sock)(struct __pyx_obj_6uvloop_4loop_PseudoSocket *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *__pyx_vtabptr_6uvloop_4loop_PseudoSocket;
+
+
+/* "uvloop/lru.pyx":5
+ * 
+ * @cython.final
+ * cdef class LruCache:             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_LruCache {
+  PyObject *(*get)(struct __pyx_obj_6uvloop_4loop_LruCache *, PyObject *, PyObject *);
+  PyObject *(*needs_cleanup)(struct __pyx_obj_6uvloop_4loop_LruCache *);
+  PyObject *(*cleanup_one)(struct __pyx_obj_6uvloop_4loop_LruCache *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_LruCache *__pyx_vtabptr_6uvloop_4loop_LruCache;
+static PyObject *__pyx_f_6uvloop_4loop_8LruCache_get(struct __pyx_obj_6uvloop_4loop_LruCache *, PyObject *, PyObject *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8LruCache_needs_cleanup(struct __pyx_obj_6uvloop_4loop_LruCache *);
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8LruCache_cleanup_one(struct __pyx_obj_6uvloop_4loop_LruCache *);
+
+
+/* "uvloop/handles/stream.pyx":6
+ * @cython.no_gc_clear
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class _StreamWriteContext:             # <<<<<<<<<<<<<<
+ *     # used to hold additional write request information for uv_write
+ * 
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext {
+  PyObject *(*free_bufs)(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *);
+  PyObject *(*close)(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *);
+  PyObject *(*advance_uv_buf)(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *, size_t);
+  struct __pyx_obj_6uvloop_4loop__StreamWriteContext *(*new)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *__pyx_vtabptr_6uvloop_4loop__StreamWriteContext;
+
+
+/* "uvloop/handles/tcp.pyx":185
+ * 
+ * 
+ * cdef class _TCPConnectRequest(UVRequest):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         TCPTransport transport
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop__TCPConnectRequest {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVRequest __pyx_base;
+  PyObject *(*connect)(struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *, struct sockaddr *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop__TCPConnectRequest *__pyx_vtabptr_6uvloop_4loop__TCPConnectRequest;
+
+
+/* "uvloop/handles/pipe.pyx":188
+ * 
+ * 
+ * cdef class _PipeConnectRequest(UVRequest):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         UnixTransport transport
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop__PipeConnectRequest {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVRequest __pyx_base;
+  PyObject *(*connect)(struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *, char *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop__PipeConnectRequest *__pyx_vtabptr_6uvloop_4loop__PipeConnectRequest;
+
+
+/* "uvloop/dns.pyx":252
+ * 
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class AddrInfo:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         system.addrinfo *data
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_AddrInfo {
+  void (*set_data)(struct __pyx_obj_6uvloop_4loop_AddrInfo *, struct addrinfo *);
+  PyObject *(*unpack)(struct __pyx_obj_6uvloop_4loop_AddrInfo *);
+  int (*isinstance)(PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_AddrInfo *__pyx_vtabptr_6uvloop_4loop_AddrInfo;
+
+
+/* "uvloop/dns.pyx":296
+ * 
+ * 
+ * cdef class AddrInfoRequest(UVRequest):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         system.addrinfo hints
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_AddrInfoRequest {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVRequest __pyx_base;
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_AddrInfoRequest *__pyx_vtabptr_6uvloop_4loop_AddrInfoRequest;
+
+
+/* "uvloop/dns.pyx":351
+ * 
+ * 
+ * cdef class NameInfoRequest(UVRequest):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         object callback
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop_NameInfoRequest {
+  struct __pyx_vtabstruct_6uvloop_4loop_UVRequest __pyx_base;
+  PyObject *(*query)(struct __pyx_obj_6uvloop_4loop_NameInfoRequest *, struct sockaddr *, int);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_NameInfoRequest *__pyx_vtabptr_6uvloop_4loop_NameInfoRequest;
+
+
+/* "uvloop/handles/udp.pyx":3
+ * @cython.no_gc_clear
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class _UDPSendContext:             # <<<<<<<<<<<<<<
+ *     # used to hold additional write request information for uv_write
+ * 
+ */
+
+struct __pyx_vtabstruct_6uvloop_4loop__UDPSendContext {
+  PyObject *(*close)(struct __pyx_obj_6uvloop_4loop__UDPSendContext *);
+  struct __pyx_obj_6uvloop_4loop__UDPSendContext *(*new)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *);
+};
+static struct __pyx_vtabstruct_6uvloop_4loop__UDPSendContext *__pyx_vtabptr_6uvloop_4loop__UDPSendContext;
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+  #define CYTHON_REFNANNY 0
+#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 (*FinishContext)(void**);
+  } __Pyx_RefNannyAPIStruct;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+#ifdef WITH_THREAD
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          if (acquire_gil) {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              PyGILState_Release(__pyx_gilstate_save);\
+          } else {\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+          }
+#else
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+#endif
+  #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)
+#else
+  #define __Pyx_RefNannyDeclarations
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContext()
+  #define __Pyx_INCREF(r) Py_INCREF(r)
+  #define __Pyx_DECREF(r) Py_DECREF(r)
+  #define __Pyx_GOTREF(r)
+  #define __Pyx_GIVEREF(r)
+  #define __Pyx_XINCREF(r) Py_XINCREF(r)
+  #define __Pyx_XDECREF(r) Py_XDECREF(r)
+  #define __Pyx_XGOTREF(r)
+  #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_XDECREF(tmp);\
+    } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_DECREF(tmp);\
+    } while (0)
+#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);
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* decode_c_string_utf16.proto */
+static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) {
+    int byteorder = 0;
+    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
+}
+static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) {
+    int byteorder = -1;
+    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
+}
+static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) {
+    int byteorder = 1;
+    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
+}
+
+/* decode_c_string.proto */
+static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
+         const char* cstring, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));
+
+/* PyDictVersioning.proto */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+#define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
+#define __PYX_GET_DICT_VERSION(dict)  (((PyDictObject*)(dict))->ma_version_tag)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
+    (version_var) = __PYX_GET_DICT_VERSION(dict);\
+    (cache_var) = (value);
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
+    static PY_UINT64_T __pyx_dict_version = 0;\
+    static PyObject *__pyx_dict_cached_value = NULL;\
+    if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
+        (VAR) = __pyx_dict_cached_value;\
+    } else {\
+        (VAR) = __pyx_dict_cached_value = (LOOKUP);\
+        __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
+    }\
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
+#else
+#define __PYX_GET_DICT_VERSION(dict)  (0)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP)  (VAR) = (LOOKUP);
+#endif
+
+/* GetModuleGlobalName.proto */
+#if CYTHON_USE_DICT_VERSIONS
+#define __Pyx_GetModuleGlobalName(var, name)  {\
+    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)  {\
+    PY_UINT64_T __pyx_dict_version;\
+    PyObject *__pyx_dict_cached_value;\
+    (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
+}
+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)
+#define __Pyx_GetModuleGlobalNameUncached(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#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
+  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
+
+/* 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
+
+/* 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
+
+/* 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
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyIntBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AndObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check);
+#else
+#define __Pyx_PyInt_AndObjC(op1, op2, intval, inplace, zerodivision_check)\
+    (inplace ? PyNumber_InPlaceAnd(op1, op2) : PyNumber_And(op1, op2))
+#endif
+
+/* PyObjectCall2Args.proto */
+static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
+
+/* PyIntBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check);
+#else
+#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\
+    (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
+#endif
+
+/* PyObjectSetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL)
+static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value);
+#else
+#define __Pyx_PyObject_DelAttrStr(o,n)   PyObject_DelAttr(o,n)
+#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v)
+#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
+
+/* GetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* SwapException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSwap(type, value, tb)  __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* GetTopmostException.proto */
+#if CYTHON_USE_EXC_INFO_STACK
+static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
+#endif
+
+/* SaveResetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+#else
+#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
+#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 *kwdict, const char* function_name, int kw_allowed);
+
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* ExtTypeTest.proto */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
+
+/* WriteUnraisableException.proto */
+static void __Pyx_WriteUnraisable(const char *name, int clineno,
+                                  int lineno, const char *filename,
+                                  int full_traceback, int nogil);
+
+/* RaiseTooManyValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
+
+/* RaiseNeedMoreValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+
+/* IterFinish.proto */
+static CYTHON_INLINE int __Pyx_IterFinish(void);
+
+/* UnpackItemEndCheck.proto */
+static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);
+
+/* 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
+
+/* 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);
+
+/* FastTypeChecks.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+static CYTHON_INLINE int __Pyx_IsSubtype(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_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_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+
+/* pyfrozenset_new.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it);
+
+/* py_set_discard.proto */
+static CYTHON_INLINE int __Pyx_PySet_Discard(PyObject *set, PyObject *key);
+
+/* set_iter.proto */
+static CYTHON_INLINE PyObject* __Pyx_set_iterator(PyObject* iterable, int is_set,
+                                                  Py_ssize_t* p_orig_length, int* p_source_is_set);
+static CYTHON_INLINE int __Pyx_set_iter_next(
+        PyObject* iter_obj, Py_ssize_t orig_length,
+        Py_ssize_t* ppos, PyObject **value,
+        int source_is_set);
+
+/* DictGetItem.proto */
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);
+#define __Pyx_PyObject_Dict_GetItem(obj, name)\
+    (likely(PyDict_CheckExact(obj)) ?\
+     __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name))
+#else
+#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
+#define __Pyx_PyObject_Dict_GetItem(obj, name)  PyObject_GetItem(obj, name)
+#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);
+
+/* RaiseNoneIterError.proto */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
+
+/* UnpackTupleError.proto */
+static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index);
+
+/* UnpackTuple2.proto */
+#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\
+    (likely(is_tuple || PyTuple_Check(tuple)) ?\
+        (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\
+            __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\
+            (__Pyx_UnpackTupleError(tuple, 2), -1)) :\
+        __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple))
+static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
+    PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple);
+static int __Pyx_unpack_tuple2_generic(
+    PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple);
+
+/* dict_iter.proto */
+static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name,
+                                                   Py_ssize_t* p_orig_length, int* p_is_dict);
+static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos,
+                                              PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict);
+
+/* py_dict_clear.proto */
+#define __Pyx_PyDict_Clear(d) (PyDict_Clear(d), 0)
+
+/* PyObjectFormatSimple.proto */
+#if CYTHON_COMPILING_IN_PYPY
+    #define __Pyx_PyObject_FormatSimple(s, f) (\
+        likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
+        PyObject_Format(s, f))
+#elif PY_MAJOR_VERSION < 3
+    #define __Pyx_PyObject_FormatSimple(s, f) (\
+        likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
+        likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\
+        PyObject_Format(s, f))
+#elif CYTHON_USE_TYPE_SLOTS
+    #define __Pyx_PyObject_FormatSimple(s, f) (\
+        likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
+        likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_str(s) :\
+        likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_str(s) :\
+        PyObject_Format(s, f))
+#else
+    #define __Pyx_PyObject_FormatSimple(s, f) (\
+        likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
+        PyObject_Format(s, f))
+#endif
+
+/* ListAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
+    PyListObject* L = (PyListObject*) list;
+    Py_ssize_t len = Py_SIZE(list);
+    if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
+        Py_INCREF(x);
+        PyList_SET_ITEM(list, len, x);
+        __Pyx_SET_SIZE(list, len + 1);
+        return 0;
+    }
+    return PyList_Append(list, x);
+}
+#else
+#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* PyObjectCallMethod1.proto */
+static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg);
+
+/* append.proto */
+static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x);
+
+/* GetItemInt.proto */
+#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
+    (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
+               __Pyx_GetItemInt_Generic(o, to_py_func(i))))
+#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+    (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+                                                              int wraparound, int boundscheck);
+#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+    (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+                                                              int wraparound, int boundscheck);
+static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
+                                                     int is_list, int wraparound, int boundscheck);
+
+/* ObjectGetItem.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key);
+#else
+#define __Pyx_PyObject_GetItem(obj, key)  PyObject_GetItem(obj, key)
+#endif
+
+/* py_dict_pop.proto */
+static CYTHON_INLINE PyObject *__Pyx_PyDict_Pop(PyObject *d, PyObject *key, PyObject *default_value);
+
+/* UnpackUnboundCMethod.proto */
+typedef struct {
+    PyObject *type;
+    PyObject **method_name;
+    PyCFunction func;
+    PyObject *method;
+    int flag;
+} __Pyx_CachedCFunction;
+
+/* CallUnboundCMethod2.proto */
+static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1
+static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2);
+#else
+#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2)  __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2)
+#endif
+
+/* 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
+
+/* None.proto */
+static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname);
+
+/* FetchCommonType.proto */
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED 1
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#define __Pyx_CyFunction_GetClassObj(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_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 {
+    PyCFunctionObject func;
+#if PY_VERSION_HEX < 0x030500A0
+    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;
+    PyObject *func_classobj;
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;  // used by FusedFunction for copying defaults
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+} __pyx_CyFunctionObject;
+static PyTypeObject *__pyx_CyFunctionType = 0;
+#define __Pyx_CyFunction_Check(obj)  (__Pyx_TypeCheck(obj, __pyx_CyFunctionType))
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *self,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+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(void);
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+
+/* PyObjectFormatAndDecref.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f);
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f);
+
+/* JoinPyUnicode.proto */
+static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength,
+                                      Py_UCS4 max_char);
+
+/* SliceObject.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(
+        PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop,
+        PyObject** py_start, PyObject** py_stop, PyObject** py_slice,
+        int has_cstart, int has_cstop, int wraparound);
+
+/* PyIntCompare.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, long intval, long inplace);
+
+/* CallableCheck.proto */
+#if CYTHON_USE_TYPE_SLOTS && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyCallable_Check(obj)   (Py_TYPE(obj)->tp_call != NULL)
+#else
+#define __Pyx_PyCallable_Check(obj)   PyCallable_Check(obj)
+#endif
+
+/* CoroutineBase.proto */
+typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyThreadState *, PyObject *);
+#if CYTHON_USE_EXC_INFO_STACK
+#define __Pyx_ExcInfoStruct  _PyErr_StackItem
+#else
+typedef struct {
+    PyObject *exc_type;
+    PyObject *exc_value;
+    PyObject *exc_traceback;
+} __Pyx_ExcInfoStruct;
+#endif
+typedef struct {
+    PyObject_HEAD
+    __pyx_coroutine_body_t body;
+    PyObject *closure;
+    __Pyx_ExcInfoStruct gi_exc_state;
+    PyObject *gi_weakreflist;
+    PyObject *classobj;
+    PyObject *yieldfrom;
+    PyObject *gi_name;
+    PyObject *gi_qualname;
+    PyObject *gi_modulename;
+    PyObject *gi_code;
+    PyObject *gi_frame;
+    int resume_label;
+    char is_running;
+} __pyx_CoroutineObject;
+static __pyx_CoroutineObject *__Pyx__Coroutine_New(
+    PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure,
+    PyObject *name, PyObject *qualname, PyObject *module_name);
+static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit(
+            __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure,
+            PyObject *name, PyObject *qualname, PyObject *module_name);
+static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self);
+static int __Pyx_Coroutine_clear(PyObject *self);
+static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value);
+static PyObject *__Pyx_Coroutine_Close(PyObject *self);
+static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args);
+#if CYTHON_USE_EXC_INFO_STACK
+#define __Pyx_Coroutine_SwapException(self)
+#define __Pyx_Coroutine_ResetAndClearException(self)  __Pyx_Coroutine_ExceptionClear(&(self)->gi_exc_state)
+#else
+#define __Pyx_Coroutine_SwapException(self) {\
+    __Pyx_ExceptionSwap(&(self)->gi_exc_state.exc_type, &(self)->gi_exc_state.exc_value, &(self)->gi_exc_state.exc_traceback);\
+    __Pyx_Coroutine_ResetFrameBackpointer(&(self)->gi_exc_state);\
+    }
+#define __Pyx_Coroutine_ResetAndClearException(self) {\
+    __Pyx_ExceptionReset((self)->gi_exc_state.exc_type, (self)->gi_exc_state.exc_value, (self)->gi_exc_state.exc_traceback);\
+    (self)->gi_exc_state.exc_type = (self)->gi_exc_state.exc_value = (self)->gi_exc_state.exc_traceback = NULL;\
+    }
+#endif
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\
+    __Pyx_PyGen__FetchStopIterationValue(__pyx_tstate, pvalue)
+#else
+#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\
+    __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, pvalue)
+#endif
+static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue);
+static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state);
+
+/* 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);
+#else
+#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr
+#endif
+
+/* PatchModuleWithCoroutine.proto */
+static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code);
+
+/* PatchGeneratorABC.proto */
+static int __Pyx_patch_abc(void);
+
+/* Coroutine.proto */
+#define __Pyx_Coroutine_USED
+static PyTypeObject *__pyx_CoroutineType = 0;
+static PyTypeObject *__pyx_CoroutineAwaitType = 0;
+#define __Pyx_Coroutine_CheckExact(obj) (Py_TYPE(obj) == __pyx_CoroutineType)
+#define __Pyx_Coroutine_Check(obj) __Pyx_Coroutine_CheckExact(obj)
+#define __Pyx_CoroutineAwait_CheckExact(obj) (Py_TYPE(obj) == __pyx_CoroutineAwaitType)
+#define __Pyx_Coroutine_New(body, code, closure, name, qualname, module_name)\
+    __Pyx__Coroutine_New(__pyx_CoroutineType, body, code, closure, name, qualname, module_name)
+static int __pyx_Coroutine_init(void);
+static PyObject *__Pyx__Coroutine_await(PyObject *coroutine);
+typedef struct {
+    PyObject_HEAD
+    PyObject *coroutine;
+} __pyx_CoroutineAwaitObject;
+static PyObject *__Pyx_CoroutineAwait_Close(__pyx_CoroutineAwaitObject *self, PyObject *arg);
+static PyObject *__Pyx_CoroutineAwait_Throw(__pyx_CoroutineAwaitObject *self, PyObject *args);
+
+/* GetAwaitIter.proto */
+static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAwaitableIter(PyObject *o);
+static PyObject *__Pyx__Coroutine_GetAwaitableIter(PyObject *o);
+
+/* CoroutineYieldFrom.proto */
+static CYTHON_INLINE PyObject* __Pyx_Coroutine_Yield_From(__pyx_CoroutineObject *gen, PyObject *source);
+
+/* ReturnWithStopIteration.proto */
+#define __Pyx_ReturnWithStopIteration(value)\
+    if (value == Py_None) PyErr_SetNone(PyExc_StopIteration); else __Pyx__ReturnWithStopIteration(value)
+static void __Pyx__ReturnWithStopIteration(PyObject* value);
+
+/* 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);
+
+/* 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);
+}
+#else
+#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* CallUnboundCMethod0.proto */
+static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self);
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CallUnboundCMethod0(cfunc, self)\
+    (likely((cfunc)->func) ?\
+        (likely((cfunc)->flag == METH_NOARGS) ?  (*((cfunc)->func))(self, NULL) :\
+         (PY_VERSION_HEX >= 0x030600B1 && likely((cfunc)->flag == METH_FASTCALL) ?\
+            (PY_VERSION_HEX >= 0x030700A0 ?\
+                (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0) :\
+                (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL)) :\
+          (PY_VERSION_HEX >= 0x030700A0 && (cfunc)->flag == (METH_FASTCALL | METH_KEYWORDS) ?\
+            (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL) :\
+            (likely((cfunc)->flag == (METH_VARARGS | METH_KEYWORDS)) ?  ((*(PyCFunctionWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, __pyx_empty_tuple, NULL)) :\
+               ((cfunc)->flag == METH_VARARGS ?  (*((cfunc)->func))(self, __pyx_empty_tuple) :\
+               __Pyx__CallUnboundCMethod0(cfunc, self)))))) :\
+        __Pyx__CallUnboundCMethod0(cfunc, self))
+#else
+#define __Pyx_CallUnboundCMethod0(cfunc, self)  __Pyx__CallUnboundCMethod0(cfunc, self)
+#endif
+
+/* SetItemInt.proto */
+#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\
+    (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\
+               __Pyx_SetItemInt_Generic(o, to_py_func(i), v)))
+static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v);
+static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
+                                               int is_list, int wraparound, int boundscheck);
+
+/* MergeKeywords.proto */
+static int __Pyx_MergeKeywords(PyObject *kwdict, PyObject *source_mapping);
+
+/* GetAttr.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *);
+
+/* HasAttr.proto */
+static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *);
+
+/* None.proto */
+static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname);
+
+/* GetAttr3.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *);
+
+/* 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);
+
+/* py_set_remove.proto */
+static CYTHON_INLINE int __Pyx_PySet_Remove(PyObject *set, PyObject *key);
+
+/* PyIntCompare.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace);
+
+/* RaiseKeywordRequired.proto */
+static void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name);
+
+/* PySequenceContains.proto */
+static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) {
+    int result = PySequence_Contains(seq, item);
+    return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
+}
+
+/* PyDictContains.proto */
+static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) {
+    int result = PyDict_Contains(dict, item);
+    return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
+}
+
+/* GCCDiagnostics.proto */
+#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#define __Pyx_HAS_GCC_DIAGNOSTIC
+#endif
+
+/* BuildPyUnicode.proto */
+static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength,
+                                                int prepend_sign, char padding_char);
+
+/* CIntToPyUnicode.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char);
+
+/* PyObjectLookupSpecial.proto */
+#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name) {
+    PyObject *res;
+    PyTypeObject *tp = Py_TYPE(obj);
+#if PY_MAJOR_VERSION < 3
+    if (unlikely(PyInstance_Check(obj)))
+        return __Pyx_PyObject_GetAttrStr(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 {
+        PyErr_SetObject(PyExc_AttributeError, attr_name);
+    }
+    return res;
+}
+#else
+#define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n)
+#endif
+
+/* CIntToPyUnicode.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char);
+
+/* decode_c_bytes.proto */
+static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes(
+         const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));
+
+/* decode_bytes.proto */
+static CYTHON_INLINE PyObject* __Pyx_decode_bytes(
+         PyObject* string, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
+    return __Pyx_decode_c_bytes(
+        PyBytes_AS_STRING(string), PyBytes_GET_SIZE(string),
+        start, stop, encoding, errors, decode_func);
+}
+
+/* DelItemInt.proto */
+#define __Pyx_DelItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_DelItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound) :\
+    (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\
+               __Pyx_DelItem_Generic(o, to_py_func(i))))
+static int __Pyx_DelItem_Generic(PyObject *o, PyObject *j);
+static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i,
+                                               int is_list, int wraparound);
+
+/* StringJoin.proto */
+#if PY_MAJOR_VERSION < 3
+#define __Pyx_PyString_Join __Pyx_PyBytes_Join
+#define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v))
+#else
+#define __Pyx_PyString_Join PyUnicode_Join
+#define __Pyx_PyBaseString_Join PyUnicode_Join
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+    #if PY_MAJOR_VERSION < 3
+    #define __Pyx_PyBytes_Join _PyString_Join
+    #else
+    #define __Pyx_PyBytes_Join _PyBytes_Join
+    #endif
+#else
+static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values);
+#endif
+
+/* Import.proto */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+
+/* ImportFrom.proto */
+static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
+
+/* None.proto */
+static CYTHON_INLINE long __Pyx_div_long(long, long);
+
+/* PyObject_GenericGetAttr.proto */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
+#endif
+
+/* SetVTable.proto */
+static int __Pyx_SetVtable(PyObject *dict, void *vtable);
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* SetupReduce.proto */
+static int __Pyx_setup_reduce(PyObject* type_obj);
+
+/* 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
+};
+static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+#endif
+
+/* PatchInspect.proto */
+static PyObject* __Pyx_patch_inspect(PyObject* module);
+
+/* PatchAsyncIO.proto */
+static PyObject* __Pyx_patch_asyncio(PyObject* module);
+
+/* CalculateMetaclass.proto */
+static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases);
+
+/* SetNameInClass.proto */
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
+#define __Pyx_SetNameInClass(ns, name, value)\
+    (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value))
+#elif CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_SetNameInClass(ns, name, value)\
+    (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value))
+#else
+#define __Pyx_SetNameInClass(ns, name, value)  PyObject_SetItem(ns, name, value)
+#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);
+
+/* CLineInTraceback.proto */
+#ifdef CYTHON_CLINE_IN_TRACEBACK
+#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
+#else
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
+#endif
+
+/* CodeObjectCache.proto */
+typedef struct {
+    PyCodeObject* code_object;
+    int code_line;
+} __Pyx_CodeObjectCacheEntry;
+struct __Pyx_CodeObjectCache {
+    int count;
+    int max_count;
+    __Pyx_CodeObjectCacheEntry* entries;
+};
+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);
+
+/* AddTraceback.proto */
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_short(unsigned short value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_volatile__int(volatile int value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum____pyx_t_6uvloop_4loop_SSLProtocolState(enum __pyx_t_6uvloop_4loop_SSLProtocolState value);
+
+/* IterableCoroutine.proto */
+#define __Pyx_IterableCoroutine_USED
+static PyTypeObject *__pyx_IterableCoroutineType = 0;
+#undef __Pyx_Coroutine_Check
+#define __Pyx_Coroutine_Check(obj) (__Pyx_Coroutine_CheckExact(obj) || (Py_TYPE(obj) == __pyx_IterableCoroutineType))
+#define __Pyx_IterableCoroutine_New(body, code, closure, name, qualname, module_name)\
+    __Pyx__Coroutine_New(__pyx_IterableCoroutineType, body, code, closure, name, qualname, module_name)
+static int __pyx_IterableCoroutine_init(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_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);
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(void);
+
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__is_main_thread(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__init_debug_fields(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__setup_or_resume_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__pause_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__shutdown_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__ceval_process_signals(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__read_from_self(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__invoke_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_data); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__handle_signal(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__on_wake(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__on_idle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__stop(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop___run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uv_run_mode __pyx_v_mode); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uv_run_mode __pyx_v_mode); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__close(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static uint64_t __pyx_f_6uvloop_4loop_4Loop__time(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__queue_write(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_stream); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__exec_queued_writes(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args, PyObject *__pyx_v_context); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__append_ready_handle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon_handle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__call_later(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uint64_t __pyx_v_delay, PyObject *__pyx_v_callback, PyObject *__pyx_v_args, PyObject *__pyx_v_context); /* proto*/
+static void __pyx_f_6uvloop_4loop_4Loop__handle_exception(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_ex); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_signal(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_closed(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_thread(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__new_future(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__track_transport(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_transport); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__track_process(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_proc); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__untrack_process(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_proc); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__fileobj_to_fd(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__ensure_fd_no_transport(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__add_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__remove_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__has_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__add_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__remove_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__has_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__getaddrinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_flags, int __pyx_v_unpack); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__getnameinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct sockaddr *__pyx_v_addr, int __pyx_v_flags); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_recv(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_n); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_recv_into(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_buf); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_sendall(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_data); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_accept(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_connect(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_address); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_connect_cb(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_address); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_set_reuseport(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, int __pyx_v_fd); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__set_coroutine_debug(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, int __pyx_v_enabled); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__print_debug_info(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__set_loop(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__set_context(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self, PyObject *__pyx_v_context); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__run(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6Handle__cancel(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6Handle__format_handle(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11TimerHandle__cancel(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_11TimerHandle__clear(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11TimerHandle__run(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12PseudoSocket__na(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_what); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12PseudoSocket__make_sock(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8LruCache_get(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8LruCache_needs_cleanup(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8LruCache_cleanup_one(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__free(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__warn_unclosed(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__abort_init(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__finish_init(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__start_init(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop); /* proto*/
+static CYTHON_INLINE int __pyx_f_6uvloop_4loop_8UVHandle__is_alive(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__ensure_alive(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__fatal_error(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__error(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__close(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__fileno(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__new_socket(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__get_socket(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__attach_fileobj(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self, PyObject *__pyx_v_file); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__close(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__open(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self, CYTHON_UNUSED int __pyx_v_sockfd); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_7UVAsync__init(struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_7UVAsync_send(struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_v_self); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_f_6uvloop_4loop_7UVAsync_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6UVIdle__init(struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVIdle_stop(struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVIdle_start(struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_self); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_f_6uvloop_4loop_6UVIdle_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_7UVCheck__init(struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_7UVCheck_stop(struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_7UVCheck_start(struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_self); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_f_6uvloop_4loop_7UVCheck_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_7UVTimer__init(struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx, uint64_t __pyx_v_timeout); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_7UVTimer_stop(struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_7UVTimer_start(struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_7UVTimer_get_when(struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_f_6uvloop_4loop_7UVTimer_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx, uint64_t __pyx_v_timeout); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll__init(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, int __pyx_v_fd); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_f_6uvloop_4loop_6UVPoll_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, int __pyx_v_fd); /* proto*/
+static int __pyx_f_6uvloop_4loop_6UVPoll_is_active(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVPoll__poll_start(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, int __pyx_v_flags); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVPoll__poll_stop(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_is_reading(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_is_writing(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_start_reading(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_callback); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_start_writing(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_callback); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_stop_reading(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_stop_writing(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_stop(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll__close(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll__fatal_error(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc, CYTHON_UNUSED PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_6UVPoll__fatal_error *__pyx_optional_args); /* proto*/
+static size_t __pyx_f_6uvloop_4loop_15UVBaseTransport__get_write_buffer_size(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_made(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_lost(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__fatal_error(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__fatal_error *__pyx_optional_args); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_pause_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_resume_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__wakeup_waiter(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__call_connection_made(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__call_connection_lost(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_server(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_waiter(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_waiter); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_protocol); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__clear_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__init_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__add_extra_info(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_obj); /* proto*/
+static int __pyx_f_6uvloop_4loop_15UVBaseTransport__is_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__start_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__stop_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_19_StreamWriteContext_free_bufs(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_19_StreamWriteContext_close(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_19_StreamWriteContext_advance_uv_buf(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self, size_t __pyx_v_sent); /* proto*/
+static struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_f_6uvloop_4loop_19_StreamWriteContext_new(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_stream, PyObject *__pyx_v_buffers); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8UVStream__set_protocol(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_protocol); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8UVStream__clear_protocol(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__shutdown(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__accept(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_server); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__close_on_read_error(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static int __pyx_f_6uvloop_4loop_8UVStream__is_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8UVStream__start_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream___reading_started(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream___reading_stopped(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8UVStream__stop_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__try_write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_data); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_data); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__exec_write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static size_t __pyx_f_6uvloop_4loop_8UVStream__get_write_buffer_size(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8UVStream__close(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_accept(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_eof(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__init(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter, PyObject *__pyx_v_context); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_connect(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__init(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol_factory, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_backlog, PyObject *__pyx_v_ssl, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer_listen(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__on_listen(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__fatal_error(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_14UVStreamServer__fatal_error *__pyx_optional_args); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__mark_as_open(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_f_6uvloop_4loop_14UVStreamServer__make_new_transport(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_protocol, CYTHON_UNUSED PyObject *__pyx_v_waiter, CYTHON_UNUSED PyObject *__pyx_v_context); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_f_6uvloop_4loop_9TCPServer_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol_factory, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, unsigned int __pyx_v_flags, PyObject *__pyx_v_backlog, PyObject *__pyx_v_ssl, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9TCPServer__new_socket(struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9TCPServer__open(struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9TCPServer_bind(struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self, struct sockaddr *__pyx_v_addr, struct __pyx_opt_args_6uvloop_4loop_9TCPServer_bind *__pyx_optional_args); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_f_6uvloop_4loop_9TCPServer__make_new_transport(struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self, PyObject *__pyx_v_protocol, PyObject *__pyx_v_waiter, PyObject *__pyx_v_context); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_f_6uvloop_4loop_12TCPTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter, PyObject *__pyx_v_context); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport__set_nodelay(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport__call_connection_made(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport__new_socket(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport_bind(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr, struct __pyx_opt_args_6uvloop_4loop_12TCPTransport_bind *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport__open(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport_connect(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18_TCPConnectRequest_connect(struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__pyx_v_self, struct sockaddr *__pyx_v_addr); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_f_6uvloop_4loop_10UnixServer_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol_factory, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_backlog, PyObject *__pyx_v_ssl, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_10UnixServer__new_socket(struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_10UnixServer__open(struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_10UnixServer_bind(struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self, PyObject *__pyx_v_path); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_f_6uvloop_4loop_10UnixServer__make_new_transport(struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self, PyObject *__pyx_v_protocol, PyObject *__pyx_v_waiter, PyObject *__pyx_v_context); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_f_6uvloop_4loop_13UnixTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter, PyObject *__pyx_v_context); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_13UnixTransport__new_socket(struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_13UnixTransport__open(struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_13UnixTransport_connect(struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_self, char *__pyx_v_addr); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_f_6uvloop_4loop_17ReadUnixTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_17ReadUnixTransport__new_socket(struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_17ReadUnixTransport__open(struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_f_6uvloop_4loop_18WriteUnixTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18WriteUnixTransport__new_socket(struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18WriteUnixTransport__open(struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_19_PipeConnectRequest_connect(struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__pyx_v_self, char *__pyx_v_addr); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__close_process_handle(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_args, PyObject *__pyx_v_env, PyObject *__pyx_v_cwd, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr, PyObject *__pyx_v_pass_fds, PyObject *__pyx_v_debug_flags, PyObject *__pyx_v_preexec_fn, PyObject *__pyx_v_restore_signals); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__after_fork(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__close_after_spawn(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, int __pyx_v_fd); /* proto*/
+static char **__pyx_f_6uvloop_4loop_9UVProcess___to_cstring_array(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_arr); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_options(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_env, PyObject *__pyx_v_cwd, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_args(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_env(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_env); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_files(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v__stdin, CYTHON_UNUSED PyObject *__pyx_v__stdout, CYTHON_UNUSED PyObject *__pyx_v__stderr); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__kill(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, int __pyx_v_signum); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__on_exit(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, int64_t __pyx_v_exit_status, int __pyx_v_term_signal); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__close(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__on_exit(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int64_t __pyx_v_exit_status, int __pyx_v_term_signal); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__check_proc(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__pipe_connection_lost(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_fd, PyObject *__pyx_v_exc); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__pipe_data_received(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_fd, PyObject *__pyx_v_data); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_redirect_stdio(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_fd); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_devnull(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_outpipe(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_inpipe(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__init_files(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__call_connection_made(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_waiter); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__try_finish(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto*/
+static struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_f_6uvloop_4loop_18UVProcessTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, PyObject *__pyx_v_args, PyObject *__pyx_v_env, PyObject *__pyx_v_cwd, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr, PyObject *__pyx_v_pass_fds, PyObject *__pyx_v_waiter, PyObject *__pyx_v_debug_flags, PyObject *__pyx_v_preexec_fn, PyObject *__pyx_v_restore_signals); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVRequest_on_done(struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_9UVRequest_cancel(struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self); /* proto*/
+static void __pyx_f_6uvloop_4loop_8AddrInfo_set_data(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self, struct addrinfo *__pyx_v_data); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_8AddrInfo_unpack(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self); /* proto*/
+static int __pyx_f_6uvloop_4loop_8AddrInfo_isinstance(PyObject *__pyx_v_other); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_15NameInfoRequest_query(struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__pyx_v_self, struct sockaddr *__pyx_v_addr, int __pyx_v_flags); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__set_app_protocol(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_app_protocol); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__wakeup_waiter(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__wakeup_waiter *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__get_extra_info(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_name, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__get_extra_info *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__set_state(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, enum __pyx_t_6uvloop_4loop_SSLProtocolState __pyx_v_new_state); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__start_handshake(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__check_handshake_timeout(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_handshake(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__on_handshake_complete(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_handshake_exc); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__start_shutdown(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__start_shutdown *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__check_shutdown_timeout(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_read_into_void(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_context); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_flush(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_flush *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_shutdown(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_shutdown *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__on_shutdown_complete(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_shutdown_exc); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__abort(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__write_appdata(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_list_of_data, PyObject *__pyx_v_context); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_write(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__process_outgoing(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_read(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_read__buffered(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_read__copied(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__call_eof_received(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__call_eof_received *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__control_app_writing(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__control_app_writing *__pyx_optional_args); /* proto*/
+static size_t __pyx_f_6uvloop_4loop_11SSLProtocol__get_write_buffer_size(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__set_write_buffer_limits(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_write_buffer_limits *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__pause_reading(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__resume_reading(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_context); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__control_ssl_reading(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__set_read_buffer_limits(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_read_buffer_limits *__pyx_optional_args); /* proto*/
+static size_t __pyx_f_6uvloop_4loop_11SSLProtocol__get_read_buffer_size(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__fatal_error(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_exc, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__fatal_error *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_15_UDPSendContext_close(struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_v_self); /* proto*/
+static struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_f_6uvloop_4loop_15_UDPSendContext_new(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_udp, PyObject *__pyx_v_data); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__init(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, unsigned int __pyx_v_family); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__set_address(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, struct addrinfo *__pyx_v_addr); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__connect(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr, CYTHON_UNUSED size_t __pyx_v_addr_len); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport_open(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, int __pyx_v_family, int __pyx_v_sockfd); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__bind(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__set_broadcast(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, int __pyx_v_on); /* proto*/
+static size_t __pyx_f_6uvloop_4loop_12UDPTransport__get_write_buffer_size(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
+static int __pyx_f_6uvloop_4loop_12UDPTransport__is_reading(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__start_reading(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__stop_reading(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_12UDPTransport___receiving_started(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_12UDPTransport___receiving_stopped(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__new_socket(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__send(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_data, PyObject *__pyx_v_addr); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__on_receive(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_data, PyObject *__pyx_v_exc, PyObject *__pyx_v_addr); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__on_sent(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_exc, struct __pyx_opt_args_6uvloop_4loop_12UDPTransport__on_sent *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6Server__add_server(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_srv); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6Server__start_serving(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6Server__wakeup(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6Server__attach(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6Server__detach(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6Server__ref(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto*/
+static PyObject *__pyx_f_6uvloop_4loop_6Server__unref(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto*/
+
+/* Module declarations from 'uvloop.includes' */
+
+/* Module declarations from 'libc.stdint' */
+
+/* Module declarations from 'posix.types' */
+
+/* Module declarations from 'uvloop.includes.system' */
+
+/* Module declarations from 'uvloop.includes.uv' */
+
+/* Module declarations from 'cython' */
+
+/* Module declarations from 'uvloop.includes.debug' */
+
+/* Module declarations from 'uvloop.includes.python' */
+
+/* Module declarations from 'uvloop.includes.flowcontrol' */
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_8includes_11flowcontrol_add_flowcontrol_defaults(PyObject *, PyObject *, int); /*proto*/
+
+/* Module declarations from 'libc.string' */
+
+/* Module declarations from 'libc' */
+
+/* Module declarations from 'libc.errno' */
+
+/* Module declarations from 'cpython.version' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.type' */
+static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
+
+/* Module declarations from 'libc.stdio' */
+
+/* Module declarations from 'cpython.object' */
+
+/* Module declarations from 'cpython.ref' */
+
+/* Module declarations from 'cpython.exc' */
+
+/* Module declarations from 'cpython.module' */
+
+/* Module declarations from 'cpython.mem' */
+
+/* Module declarations from 'cpython.tuple' */
+
+/* Module declarations from 'cpython.list' */
+
+/* Module declarations from 'cpython.sequence' */
+
+/* Module declarations from 'cpython.mapping' */
+
+/* Module declarations from 'cpython.iterator' */
+
+/* Module declarations from 'cpython.number' */
+
+/* Module declarations from 'cpython.int' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.bool' */
+static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0;
+
+/* Module declarations from 'cpython.long' */
+
+/* Module declarations from 'cpython.float' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.complex' */
+static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0;
+
+/* Module declarations from 'cpython.string' */
+
+/* Module declarations from 'cpython.unicode' */
+
+/* Module declarations from 'cpython.dict' */
+
+/* Module declarations from 'cpython.instance' */
+
+/* Module declarations from 'cpython.function' */
+
+/* Module declarations from 'cpython.method' */
+
+/* Module declarations from 'cpython.weakref' */
+
+/* Module declarations from 'cpython.getargs' */
+
+/* Module declarations from 'cpython.pythread' */
+
+/* Module declarations from 'cpython.pystate' */
+
+/* Module declarations from 'cpython.cobject' */
+
+/* Module declarations from 'cpython.oldbuffer' */
+
+/* Module declarations from 'cpython.set' */
+
+/* Module declarations from 'cpython.buffer' */
+
+/* Module declarations from 'cpython.bytes' */
+
+/* Module declarations from 'cpython.pycapsule' */
+
+/* Module declarations from 'cpython' */
+
+/* Module declarations from 'uvloop.loop' */
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVHandle = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVSocketHandle = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVAsync = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVTimer = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVIdle = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVBaseTransport = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_Loop = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_Handle = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_TimerHandle = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVCheck = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVPoll = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVStream = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVStreamServer = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_TCPServer = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_TCPTransport = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UnixServer = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UnixTransport = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_ReadUnixTransport = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_WriteUnixTransport = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVProcess = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVProcessTransport = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVRequest = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop__SSLProtocolTransport = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_SSLProtocol = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_UDPTransport = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_Server = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_PseudoSocket = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_LruCache = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop__StreamWriteContext = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop__TCPConnectRequest = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop__PipeConnectRequest = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_SockAddrHolder = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_AddrInfo = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_AddrInfoRequest = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop_NameInfoRequest = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop__UDPSendContext = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct___getaddrinfo = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_1__getnameinfo = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_2___get__ = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_3_run_until_complete = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_5_getnameinfo = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_6_start_tls = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_7_create_server = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_8_create_connection = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_9_genexpr = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_10_genexpr = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_11_create_unix_server = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_13_sock_recv = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_15_sock_sendall = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_16_sock_accept = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_17_sock_connect = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_19___subprocess_run = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_25_genexpr = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_28__start_handshake = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_29__start_shutdown = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_30___aenter__ = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_31___aexit__ = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_32_wait_closed = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_33_start_serving = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_34_serve_forever = 0;
+static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 = 0;
+static PyTypeObject *__pyx_ptype___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_get_event_loop = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_CancelledError = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_InvalidStateError = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_TimeoutError = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_Future = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_Task = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_ensure_future = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_gather = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_wait = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_wrap_future = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_logger = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_iscoroutine = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_iscoroutinefunction = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_BaseProtocol = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_Protocol = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_isfuture = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_get_running_loop = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_set_running_loop = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_debug_wrapper = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_AbstractChildWatcher = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_Transport = 0;
+static PyObject *__pyx_v_6uvloop_4loop_aio_FlowControlMixin = 0;
+static PyObject *__pyx_v_6uvloop_4loop_col_deque = 0;
+static PyObject *__pyx_v_6uvloop_4loop_col_Iterable = 0;
+static PyObject *__pyx_v_6uvloop_4loop_col_Counter = 0;
+static PyObject *__pyx_v_6uvloop_4loop_col_OrderedDict = 0;
+static PyObject *__pyx_v_6uvloop_4loop_cc_ThreadPoolExecutor = 0;
+static PyObject *__pyx_v_6uvloop_4loop_cc_Future = 0;
+static PyObject *__pyx_v_6uvloop_4loop_errno_EBADF = 0;
+static PyObject *__pyx_v_6uvloop_4loop_errno_EINVAL = 0;
+static PyObject *__pyx_v_6uvloop_4loop_ft_partial = 0;
+static PyObject *__pyx_v_6uvloop_4loop_gc_disable = 0;
+static PyObject *__pyx_v_6uvloop_4loop_iter_chain = 0;
+static PyObject *__pyx_v_6uvloop_4loop_inspect_isgenerator = 0;
+static int __pyx_v_6uvloop_4loop_has_IPV6_V6ONLY;
+static int __pyx_v_6uvloop_4loop_IPV6_V6ONLY;
+static int __pyx_v_6uvloop_4loop_has_SO_REUSEPORT;
+static int __pyx_v_6uvloop_4loop_SO_REUSEPORT;
+static int __pyx_v_6uvloop_4loop_SO_BROADCAST;
+static int __pyx_v_6uvloop_4loop_SOCK_NONBLOCK;
+static PyObject *__pyx_v_6uvloop_4loop_socket_gaierror = 0;
+static PyObject *__pyx_v_6uvloop_4loop_socket_error = 0;
+static PyObject *__pyx_v_6uvloop_4loop_socket_timeout = 0;
+static PyObject *__pyx_v_6uvloop_4loop_socket_socket = 0;
+static PyObject *__pyx_v_6uvloop_4loop_socket_socketpair = 0;
+static PyObject *__pyx_v_6uvloop_4loop_socket_getservbyname = 0;
+static PyObject *__pyx_v_6uvloop_4loop_socket_AddressFamily = 0;
+static PyObject *__pyx_v_6uvloop_4loop_socket_SocketKind = 0;
+static int __pyx_v_6uvloop_4loop_socket_EAI_ADDRFAMILY;
+static int __pyx_v_6uvloop_4loop_socket_EAI_AGAIN;
+static int __pyx_v_6uvloop_4loop_socket_EAI_BADFLAGS;
+static int __pyx_v_6uvloop_4loop_socket_EAI_BADHINTS;
+static int __pyx_v_6uvloop_4loop_socket_EAI_CANCELED;
+static int __pyx_v_6uvloop_4loop_socket_EAI_FAIL;
+static int __pyx_v_6uvloop_4loop_socket_EAI_FAMILY;
+static int __pyx_v_6uvloop_4loop_socket_EAI_MEMORY;
+static int __pyx_v_6uvloop_4loop_socket_EAI_NODATA;
+static int __pyx_v_6uvloop_4loop_socket_EAI_NONAME;
+static int __pyx_v_6uvloop_4loop_socket_EAI_OVERFLOW;
+static int __pyx_v_6uvloop_4loop_socket_EAI_PROTOCOL;
+static int __pyx_v_6uvloop_4loop_socket_EAI_SERVICE;
+static int __pyx_v_6uvloop_4loop_socket_EAI_SOCKTYPE;
+static PyObject *__pyx_v_6uvloop_4loop_os_name = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_environ = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_dup = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_set_inheritable = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_get_inheritable = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_close = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_open = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_devnull = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_O_RDWR = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_pipe = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_read = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_remove = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_stat = 0;
+static PyObject *__pyx_v_6uvloop_4loop_os_fspath = 0;
+static PyObject *__pyx_v_6uvloop_4loop_stat_S_ISSOCK = 0;
+static PyObject *__pyx_v_6uvloop_4loop_sys_ignore_environment = 0;
+static PyObject *__pyx_v_6uvloop_4loop_sys_exc_info = 0;
+static PyObject *__pyx_v_6uvloop_4loop_sys_set_coroutine_wrapper = 0;
+static PyObject *__pyx_v_6uvloop_4loop_sys_get_coroutine_wrapper = 0;
+static PyObject *__pyx_v_6uvloop_4loop_sys_getframe = 0;
+static PyObject *__pyx_v_6uvloop_4loop_sys_version_info = 0;
+static PyObject *__pyx_v_6uvloop_4loop_sys_getfilesystemencoding = 0;
+static PyObject *__pyx_v_6uvloop_4loop_sys_platform = 0;
+static PyObject *__pyx_v_6uvloop_4loop_ssl_SSLContext = 0;
+static PyObject *__pyx_v_6uvloop_4loop_ssl_MemoryBIO = 0;
+static PyObject *__pyx_v_6uvloop_4loop_ssl_create_default_context = 0;
+static PyObject *__pyx_v_6uvloop_4loop_ssl_SSLError = 0;
+static PyObject *__pyx_v_6uvloop_4loop_ssl_SSLAgainErrors = 0;
+static PyObject *__pyx_v_6uvloop_4loop_ssl_SSLZeroReturnError = 0;
+static PyObject *__pyx_v_6uvloop_4loop_ssl_CertificateError = 0;
+static int __pyx_v_6uvloop_4loop_ssl_SSL_ERROR_WANT_READ;
+static int __pyx_v_6uvloop_4loop_ssl_SSL_ERROR_WANT_WRITE;
+static int __pyx_v_6uvloop_4loop_ssl_SSL_ERROR_SYSCALL;
+static uint64_t __pyx_v_6uvloop_4loop_MAIN_THREAD_ID;
+static PyObject *__pyx_v_6uvloop_4loop_threading_Thread = 0;
+static int __pyx_v_6uvloop_4loop_subprocess_PIPE;
+static int __pyx_v_6uvloop_4loop_subprocess_STDOUT;
+static int __pyx_v_6uvloop_4loop_subprocess_DEVNULL;
+static PyObject *__pyx_v_6uvloop_4loop_subprocess_SubprocessError = 0;
+static int __pyx_v_6uvloop_4loop_signal_NSIG;
+static PyObject *__pyx_v_6uvloop_4loop_signal_signal = 0;
+static PyObject *__pyx_v_6uvloop_4loop_signal_siginterrupt = 0;
+static PyObject *__pyx_v_6uvloop_4loop_signal_set_wakeup_fd = 0;
+static PyObject *__pyx_v_6uvloop_4loop_signal_default_int_handler = 0;
+static PyObject *__pyx_v_6uvloop_4loop_signal_SIG_DFL = 0;
+static PyObject *__pyx_v_6uvloop_4loop_time_sleep = 0;
+static PyObject *__pyx_v_6uvloop_4loop_time_monotonic = 0;
+static PyObject *__pyx_v_6uvloop_4loop_tb_StackSummary = 0;
+static PyObject *__pyx_v_6uvloop_4loop_tb_walk_stack = 0;
+static PyObject *__pyx_v_6uvloop_4loop_tb_format_list = 0;
+static PyObject *__pyx_v_6uvloop_4loop_warnings_warn = 0;
+static PyObject *__pyx_v_6uvloop_4loop_weakref_WeakValueDictionary = 0;
+static PyObject *__pyx_v_6uvloop_4loop_weakref_WeakSet = 0;
+static PyObject *__pyx_v_6uvloop_4loop_py_inf = 0;
+static int __pyx_v_6uvloop_4loop_PY39;
+static uint64_t __pyx_v_6uvloop_4loop_MAX_SLEEP;
+static PyObject *__pyx_v_6uvloop_4loop__LRU_MARKER = 0;
+static struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_6uvloop_4loop_sockaddrs = 0;
+static volatile int __pyx_v_6uvloop_4loop___atfork_installed;
+static volatile int __pyx_v_6uvloop_4loop___forking;
+static struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_6uvloop_4loop___forking_loop = 0;
+static volatile int __pyx_v_6uvloop_4loop___mem_installed;
+static PyObject *__pyx_f_6uvloop_4loop___strerr(int); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___convert_python_error(int); /*proto*/
+static int __pyx_f_6uvloop_4loop___convert_socket_error(int); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop_convert_error(int); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop__is_sock_stream(PyObject *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop__is_sock_dgram(PyObject *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop_isfuture(PyObject *); /*proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_socket_inc_io_ref(PyObject *); /*proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_socket_dec_io_ref(PyObject *); /*proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_run_in_context(PyObject *, PyObject *); /*proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_run_in_context1(PyObject *, PyObject *, PyObject *); /*proto*/
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_run_in_context2(PyObject *, PyObject *, PyObject *, PyObject *); /*proto*/
+static void __pyx_f_6uvloop_4loop___loop_alloc_buffer(uv_handle_t *, size_t, uv_buf_t *); /*proto*/
+static CYTHON_INLINE void __pyx_f_6uvloop_4loop___loop_free_buffer(struct __pyx_obj_6uvloop_4loop_Loop *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop_format_callback_name(PyObject *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop_new_Handle(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, __pyx_t_6uvloop_4loop_method_t, PyObject *, PyObject *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle1(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, __pyx_t_6uvloop_4loop_method1_t, PyObject *, PyObject *, PyObject *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle2(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, __pyx_t_6uvloop_4loop_method2_t, PyObject *, PyObject *, PyObject *, PyObject *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle3(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, __pyx_t_6uvloop_4loop_method3_t, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop_extract_stack(void); /*proto*/
+static CYTHON_INLINE int __pyx_f_6uvloop_4loop___ensure_handle_data(uv_handle_t *, char const *); /*proto*/
+static void __pyx_f_6uvloop_4loop___uv_close_handle_cb(uv_handle_t *); /*proto*/
+static void __pyx_f_6uvloop_4loop___close_all_handles(struct __pyx_obj_6uvloop_4loop_Loop *); /*proto*/
+static void __pyx_f_6uvloop_4loop___uv_walk_close_all_handles_cb(uv_handle_t *, void *); /*proto*/
+static void __pyx_f_6uvloop_4loop___uvasync_callback(uv_async_t *); /*proto*/
+static void __pyx_f_6uvloop_4loop_cb_idle_callback(uv_idle_t *); /*proto*/
+static void __pyx_f_6uvloop_4loop_cb_check_callback(uv_check_t *); /*proto*/
+static void __pyx_f_6uvloop_4loop___uvtimer_callback(uv_timer_t *); /*proto*/
+static void __pyx_f_6uvloop_4loop___on_uvpoll_event(uv_poll_t *, int, int); /*proto*/
+static void __pyx_f_6uvloop_4loop___uv_stream_on_shutdown(uv_shutdown_t *, int); /*proto*/
+static CYTHON_INLINE int __pyx_f_6uvloop_4loop___uv_stream_on_read_common(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_Loop *, Py_ssize_t); /*proto*/
+static CYTHON_INLINE void __pyx_f_6uvloop_4loop___uv_stream_on_read_impl(uv_stream_t *, Py_ssize_t, uv_buf_t const *); /*proto*/
+static CYTHON_INLINE void __pyx_f_6uvloop_4loop___uv_stream_on_write_impl(uv_write_t *, int); /*proto*/
+static void __pyx_f_6uvloop_4loop___uv_stream_on_read(uv_stream_t *, Py_ssize_t, uv_buf_t const *); /*proto*/
+static void __pyx_f_6uvloop_4loop___uv_stream_on_write(uv_write_t *, int); /*proto*/
+static void __pyx_f_6uvloop_4loop___uv_stream_buffered_alloc(uv_handle_t *, size_t, uv_buf_t *); /*proto*/
+static void __pyx_f_6uvloop_4loop___uv_stream_buffered_on_read(uv_stream_t *, Py_ssize_t, uv_buf_t const *); /*proto*/
+static void __pyx_f_6uvloop_4loop___uv_streamserver_on_listen(uv_stream_t *, int); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___tcp_init_uv_handle(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_Loop *, unsigned int); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___tcp_bind(struct __pyx_obj_6uvloop_4loop_UVStream *, struct sockaddr *, unsigned int); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___tcp_open(struct __pyx_obj_6uvloop_4loop_UVStream *, int); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___tcp_get_socket(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *); /*proto*/
+static void __pyx_f_6uvloop_4loop___tcp_connect_callback(uv_connect_t *, int); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___pipe_init_uv_handle(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_Loop *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___pipe_open(struct __pyx_obj_6uvloop_4loop_UVStream *, int); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___pipe_get_socket(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *); /*proto*/
+static void __pyx_f_6uvloop_4loop___pipe_connect_callback(uv_connect_t *, int); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___process_convert_fileno(PyObject *); /*proto*/
+static void __pyx_f_6uvloop_4loop___uvprocess_on_exit_callback(uv_process_t *, int64_t, int); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___socketpair(void); /*proto*/
+static void __pyx_f_6uvloop_4loop___uv_close_process_handle_cb(uv_handle_t *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___port_to_int(PyObject *, PyObject *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___convert_sockaddr_to_pyaddr(struct sockaddr const *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___convert_pyaddr_to_sockaddr(int, PyObject *, struct sockaddr *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___static_getaddrinfo(PyObject *, PyObject *, int, int, int, struct sockaddr *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___static_getaddrinfo_pyaddr(PyObject *, PyObject *, int, int, int, int); /*proto*/
+static void __pyx_f_6uvloop_4loop___on_addrinfo_resolved(uv_getaddrinfo_t *, int, struct addrinfo *); /*proto*/
+static void __pyx_f_6uvloop_4loop___on_nameinfo_resolved(uv_getnameinfo_t *, int, char const *, char const *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop__create_transport_context(PyObject *, PyObject *); /*proto*/
+static void __pyx_f_6uvloop_4loop___uv_udp_on_receive(uv_udp_t *, Py_ssize_t, uv_buf_t const *, struct sockaddr const *, unsigned int); /*proto*/
+static void __pyx_f_6uvloop_4loop___uv_udp_on_send(uv_udp_send_t *, int); /*proto*/
+static void __pyx_f_6uvloop_4loop___get_fork_handler(void); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___install_atfork(void); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___install_pymem(void); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop__set_signal_wakeup_fd(PyObject *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___pyx_unpickle_PseudoSocket__set_state(struct __pyx_obj_6uvloop_4loop_PseudoSocket *, PyObject *); /*proto*/
+static PyObject *__pyx_f_6uvloop_4loop___pyx_unpickle_LruCache__set_state(struct __pyx_obj_6uvloop_4loop_LruCache *, PyObject *); /*proto*/
+static PyObject *__Pyx_CFunc_object____Loop____bint___to_py(PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, int)); /*proto*/
+#define __Pyx_MODULE_NAME "uvloop.loop"
+extern int __pyx_module_is_main_uvloop__loop;
+int __pyx_module_is_main_uvloop__loop = 0;
+
+/* Implementation of 'uvloop.loop' */
+static PyObject *__pyx_builtin_object;
+static PyObject *__pyx_builtin_OSError;
+static PyObject *__pyx_builtin_MemoryError;
+static PyObject *__pyx_builtin_RuntimeError;
+static PyObject *__pyx_builtin_KeyError;
+static PyObject *__pyx_builtin_BaseException;
+static PyObject *__pyx_builtin_TypeError;
+static PyObject *__pyx_builtin_ValueError;
+static PyObject *__pyx_builtin_AttributeError;
+static PyObject *__pyx_builtin_KeyboardInterrupt;
+static PyObject *__pyx_builtin_SystemExit;
+static PyObject *__pyx_builtin_print;
+static PyObject *__pyx_builtin_round;
+static PyObject *__pyx_builtin_OverflowError;
+static PyObject *__pyx_builtin_RuntimeWarning;
+static PyObject *__pyx_builtin_DeprecationWarning;
+static PyObject *__pyx_builtin_zip;
+static PyObject *__pyx_builtin_id;
+static PyObject *__pyx_builtin_NotImplementedError;
+static PyObject *__pyx_builtin_super;
+static PyObject *__pyx_builtin_open;
+static PyObject *__pyx_builtin_range;
+static PyObject *__pyx_builtin_UnicodeEncodeError;
+static const char __pyx_k_1[] = "1";
+static const char __pyx_k_b[] = "b";
+static const char __pyx_k_c[] = "-c";
+static const char __pyx_k_n[] = "n";
+static const char __pyx_k__8[] = "";
+static const char __pyx_k_ex[] = "ex";
+static const char __pyx_k_fd[] = "fd";
+static const char __pyx_k_gc[] = "gc";
+static const char __pyx_k_id[] = "id";
+static const char __pyx_k_os[] = "os";
+static const char __pyx_k_wb[] = "wb";
+static const char __pyx_k__32[] = "-------------------------------+---------+---------";
+static const char __pyx_k__56[] = ": ";
+static const char __pyx_k__63[] = ", ";
+static const char __pyx_k__68[] = "{}: {}";
+static const char __pyx_k__69[] = "\n";
+static const char __pyx_k__91[] = "{}={}";
+static const char __pyx_k_abc[] = "abc";
+static const char __pyx_k_add[] = "add";
+static const char __pyx_k_buf[] = "buf";
+static const char __pyx_k_cmd[] = "cmd";
+static const char __pyx_k_cwd[] = "cwd";
+static const char __pyx_k_doc[] = "__doc__";
+static const char __pyx_k_dup[] = "dup";
+static const char __pyx_k_env[] = "env";
+static const char __pyx_k_exc[] = "exc";
+static const char __pyx_k_fut[] = "fut";
+static const char __pyx_k_get[] = "get";
+static const char __pyx_k_inf[] = "inf";
+static const char __pyx_k_log[] = "log";
+static const char __pyx_k_low[] = "low";
+static const char __pyx_k_msg[] = "msg";
+static const char __pyx_k_new[] = "__new__";
+static const char __pyx_k_pop[] = "pop";
+static const char __pyx_k_r_s[] = "%r: %s";
+static const char __pyx_k_run[] = "run";
+static const char __pyx_k_sig[] = "sig";
+static const char __pyx_k_ssl[] = "ssl";
+static const char __pyx_k_sys[] = "sys";
+static const char __pyx_k_tcp[] = "tcp";
+static const char __pyx_k_udp[] = "udp";
+static const char __pyx_k_zip[] = "zip";
+static const char __pyx_k_Loop[] = "Loop";
+static const char __pyx_k_NSIG[] = "NSIG";
+static const char __pyx_k_PIPE[] = "PIPE";
+static const char __pyx_k_Task[] = "Task";
+static const char __pyx_k__103[] = "<";
+static const char __pyx_k__104[] = " ";
+static const char __pyx_k__105[] = ">";
+static const char __pyx_k__133[] = " (";
+static const char __pyx_k__134[] = ")";
+static const char __pyx_k__178[] = ":";
+static const char __pyx_k__187[] = "=";
+static const char __pyx_k_addr[] = "addr";
+static const char __pyx_k_args[] = "args";
+static const char __pyx_k_bind[] = "bind";
+static const char __pyx_k_cast[] = "cast";
+static const char __pyx_k_copy[] = "copy";
+static const char __pyx_k_coro[] = "coro";
+static const char __pyx_k_data[] = "data";
+static const char __pyx_k_dict[] = "__dict__";
+static const char __pyx_k_done[] = "done";
+static const char __pyx_k_exit[] = "__exit__";
+static const char __pyx_k_fd_2[] = " fd=";
+static const char __pyx_k_func[] = "func";
+static const char __pyx_k_high[] = "high";
+static const char __pyx_k_host[] = "host";
+static const char __pyx_k_idna[] = "idna";
+static const char __pyx_k_info[] = "info";
+static const char __pyx_k_init[] = "__init__";
+static const char __pyx_k_join[] = "join";
+static const char __pyx_k_last[] = "last";
+static const char __pyx_k_loop[] = "loop";
+static const char __pyx_k_main[] = "__main__";
+static const char __pyx_k_name[] = "__name__";
+static const char __pyx_k_noop[] = "_noop";
+static const char __pyx_k_open[] = "open";
+static const char __pyx_k_path[] = "path";
+static const char __pyx_k_pipe[] = "pipe";
+static const char __pyx_k_port[] = "port";
+static const char __pyx_k_proc[] = "proc";
+static const char __pyx_k_read[] = "read";
+static const char __pyx_k_recv[] = "recv";
+static const char __pyx_k_repr[] = "__repr__";
+static const char __pyx_k_self[] = "__self__";
+static const char __pyx_k_send[] = "send";
+static const char __pyx_k_sock[] = "sock";
+static const char __pyx_k_stat[] = "stat";
+static const char __pyx_k_stop[] = "stop";
+static const char __pyx_k_task[] = "task";
+static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_time[] = "time";
+static const char __pyx_k_type[] = "type";
+static const char __pyx_k_wait[] = "wait";
+static const char __pyx_k_warn[] = "warn";
+static const char __pyx_k_when[] = "when";
+static const char __pyx_k_wrap[] = "wrap";
+static const char __pyx_k_aexit[] = "__aexit__";
+static const char __pyx_k_ascii[] = "ascii";
+static const char __pyx_k_await[] = "__await__";
+static const char __pyx_k_cause[] = "__cause__";
+static const char __pyx_k_chain[] = "chain";
+static const char __pyx_k_class[] = "__class__";
+static const char __pyx_k_clear[] = "clear";
+static const char __pyx_k_close[] = "close";
+static const char __pyx_k_debug[] = "debug";
+static const char __pyx_k_delay[] = "delay";
+static const char __pyx_k_deque[] = "deque";
+static const char __pyx_k_enter[] = "__enter__";
+static const char __pyx_k_errno[] = "errno";
+static const char __pyx_k_error[] = "error";
+static const char __pyx_k_flags[] = "flags";
+static const char __pyx_k_flush[] = "flush";
+static const char __pyx_k_frame[] = "frame";
+static const char __pyx_k_ident[] = "ident";
+static const char __pyx_k_items[] = "items";
+static const char __pyx_k_limit[] = "limit";
+static const char __pyx_k_lower[] = "lower";
+static const char __pyx_k_posix[] = "posix";
+static const char __pyx_k_print[] = "print";
+static const char __pyx_k_proto[] = "proto";
+static const char __pyx_k_range[] = "range";
+static const char __pyx_k_round[] = "round";
+static const char __pyx_k_share[] = "share";
+static const char __pyx_k_shell[] = "shell";
+static const char __pyx_k_sleep[] = "sleep";
+static const char __pyx_k_split[] = "split";
+static const char __pyx_k_start[] = "start";
+static const char __pyx_k_stdin[] = "stdin";
+static const char __pyx_k_super[] = "super";
+static const char __pyx_k_throw[] = "throw";
+static const char __pyx_k_unset[] = "_unset";
+static const char __pyx_k_write[] = "write";
+static const char __pyx_k_Future[] = "Future";
+static const char __pyx_k_Handle[] = "Handle";
+static const char __pyx_k_O_RDWR[] = "O_RDWR";
+static const char __pyx_k_STDOUT[] = "STDOUT";
+static const char __pyx_k_Server[] = "Server";
+static const char __pyx_k_Thread[] = "Thread";
+static const char __pyx_k_UVIdle[] = "UVIdle";
+static const char __pyx_k_UVPoll[] = "UVPoll";
+static const char __pyx_k_accept[] = "accept";
+static const char __pyx_k_aclose[] = "aclose";
+static const char __pyx_k_aenter[] = "__aenter__";
+static const char __pyx_k_append[] = "append";
+static const char __pyx_k_bin_sh[] = "/bin/sh";
+static const char __pyx_k_cancel[] = "cancel";
+static const char __pyx_k_cipher[] = "cipher";
+static const char __pyx_k_cygwin[] = "cygwin";
+static const char __pyx_k_decode[] = "decode";
+static const char __pyx_k_detach[] = "detach";
+static const char __pyx_k_encode[] = "encode";
+static const char __pyx_k_family[] = "family";
+static const char __pyx_k_fileno[] = "fileno";
+static const char __pyx_k_format[] = "format";
+static const char __pyx_k_fspath[] = "fspath";
+static const char __pyx_k_gather[] = "gather";
+static const char __pyx_k_handle[] = "handle";
+static const char __pyx_k_high_2[] = "high (";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_logger[] = "logger";
+static const char __pyx_k_module[] = "__module__";
+static const char __pyx_k_name_2[] = "name";
+static const char __pyx_k_noop_2[] = "noop";
+static const char __pyx_k_object[] = "object";
+static const char __pyx_k_pickle[] = "pickle";
+static const char __pyx_k_pipe_2[] = " pipe=";
+static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_remove[] = "remove";
+static const char __pyx_k_result[] = "result";
+static const char __pyx_k_rstrip[] = "rstrip";
+static const char __pyx_k_self_2[] = "self";
+static const char __pyx_k_server[] = "server ";
+static const char __pyx_k_signal[] = "signal";
+static const char __pyx_k_signum[] = "signum";
+static const char __pyx_k_socket[] = "socket ";
+static const char __pyx_k_source[] = "source";
+static const char __pyx_k_stderr[] = "stderr";
+static const char __pyx_k_stdout[] = "stdout";
+static const char __pyx_k_submit[] = "submit";
+static const char __pyx_k_target[] = "target";
+static const char __pyx_k_unwrap[] = "unwrap";
+static const char __pyx_k_update[] = "update";
+static const char __pyx_k_values[] = "values";
+static const char __pyx_k_waiter[] = "waiter";
+static const char __pyx_k_Counter[] = "Counter";
+static const char __pyx_k_DEVNULL[] = "DEVNULL";
+static const char __pyx_k_OSError[] = "OSError";
+static const char __pyx_k_SIG_DFL[] = "SIG_DFL";
+static const char __pyx_k_UVAsync[] = "UVAsync";
+static const char __pyx_k_UVCheck[] = "UVCheck";
+static const char __pyx_k_UVTimer[] = "UVTimer";
+static const char __pyx_k_WeakSet[] = "WeakSet";
+static const char __pyx_k_address[] = "address";
+static const char __pyx_k_asyncio[] = "asyncio";
+static const char __pyx_k_backlog[] = "backlog";
+static const char __pyx_k_bufsize[] = "bufsize";
+static const char __pyx_k_connect[] = "connect";
+static const char __pyx_k_context[] = "context";
+static const char __pyx_k_default[] = "default";
+static const char __pyx_k_devnull[] = "devnull";
+static const char __pyx_k_disable[] = "disable";
+static const char __pyx_k_discard[] = "discard";
+static const char __pyx_k_done_cb[] = "done_cb";
+static const char __pyx_k_enabled[] = "enabled";
+static const char __pyx_k_environ[] = "environ";
+static const char __pyx_k_extract[] = "extract";
+static const char __pyx_k_fileobj[] = "fileobj";
+static const char __pyx_k_futures[] = "futures";
+static const char __pyx_k_genexpr[] = "genexpr";
+static const char __pyx_k_inspect[] = "inspect";
+static const char __pyx_k_io_refs[] = "_io_refs";
+static const char __pyx_k_laddr_s[] = ", laddr=%s";
+static const char __pyx_k_maxsize[] = "maxsize";
+static const char __pyx_k_message[] = "message";
+static const char __pyx_k_partial[] = "partial";
+static const char __pyx_k_pending[] = "pending";
+static const char __pyx_k_popitem[] = "popitem";
+static const char __pyx_k_popleft[] = "popleft";
+static const char __pyx_k_prepare[] = "__prepare__";
+static const char __pyx_k_program[] = "program";
+static const char __pyx_k_raddr_s[] = ", raddr=%s";
+static const char __pyx_k_reverse[] = "reverse";
+static const char __pyx_k_sockets[] = " sockets=";
+static const char __pyx_k_st_mode[] = "st_mode";
+static const char __pyx_k_timeout[] = "timeout";
+static const char __pyx_k_warning[] = "warning";
+static const char __pyx_k_weakref[] = "weakref";
+static const char __pyx_k_18_7_7_7[] = "    {: <18} {: >7} | {: >7} | {: >7}";
+static const char __pyx_k_AddrInfo[] = "AddrInfo";
+static const char __pyx_k_EAI_FAIL[] = "EAI_FAIL";
+static const char __pyx_k_Iterable[] = "Iterable";
+static const char __pyx_k_KeyError[] = "KeyError";
+static const char __pyx_k_LruCache[] = "LruCache";
+static const char __pyx_k_Protocol[] = "Protocol";
+static const char __pyx_k_SSLError[] = "SSLError";
+static const char __pyx_k_S_ISSOCK[] = "S_ISSOCK";
+static const char __pyx_k_UVHandle[] = "UVHandle";
+static const char __pyx_k_UVStream[] = "UVStream";
+static const char __pyx_k_asyncgen[] = "asyncgen";
+static const char __pyx_k_builtins[] = "__builtins__";
+static const char __pyx_k_callback[] = "callback";
+static const char __pyx_k_closed_x[] = "<{} closed={} {:#x}>";
+static const char __pyx_k_exc_info[] = "exc_info";
+static const char __pyx_k_executor[] = "executor";
+static const char __pyx_k_gaierror[] = "gaierror";
+static const char __pyx_k_getframe[] = "_getframe";
+static const char __pyx_k_getstate[] = "__getstate__";
+static const char __pyx_k_isfuture[] = "isfuture";
+static const char __pyx_k_pass_fds[] = "pass_fds";
+static const char __pyx_k_peercert[] = "peercert";
+static const char __pyx_k_peername[] = "peername";
+static const char __pyx_k_platform[] = "platform";
+static const char __pyx_k_protocol[] = "protocol";
+static const char __pyx_k_pyx_type[] = "__pyx_type";
+static const char __pyx_k_qualname[] = "__qualname__";
+static const char __pyx_k_set_name[] = "set_name";
+static const char __pyx_k_setstate[] = "__setstate__";
+static const char __pyx_k_shutdown[] = "shutdown";
+static const char __pyx_k_sockaddr[] = "sockaddr";
+static const char __pyx_k_socket_2[] = "socket";
+static const char __pyx_k_sockname[] = "sockname";
+static const char __pyx_k_strerror[] = "strerror";
+static const char __pyx_k_subtract[] = "subtract";
+static const char __pyx_k_warnings[] = "warnings";
+static const char __pyx_k_wrap_bio[] = "wrap_bio";
+static const char __pyx_k_EAI_AGAIN[] = "EAI_AGAIN";
+static const char __pyx_k_Loop_time[] = "Loop time:                 {}";
+static const char __pyx_k_MemoryBIO[] = "MemoryBIO";
+static const char __pyx_k_Read_EOFs[] = "Read EOFs:                 {}";
+static const char __pyx_k_TCPServer[] = "TCPServer";
+static const char __pyx_k_Transport[] = "Transport";
+static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_UVProcess[] = "UVProcess";
+static const char __pyx_k_UVRequest[] = "UVRequest";
+static const char __pyx_k_call_soon[] = "call_soon";
+static const char __pyx_k_cancelled[] = "cancelled";
+static const char __pyx_k_close_fds[] = "close_fds";
+static const char __pyx_k_exception[] = "exception";
+static const char __pyx_k_finalizer[] = "finalizer";
+static const char __pyx_k_firstiter[] = "firstiter";
+static const char __pyx_k_functools[] = "functools";
+static const char __pyx_k_get_debug[] = "get_debug";
+static const char __pyx_k_is_closed[] = "is_closed";
+static const char __pyx_k_itertools[] = "itertools";
+static const char __pyx_k_metaclass[] = "__metaclass__";
+static const char __pyx_k_monotonic[] = "monotonic";
+static const char __pyx_k_must_be_0[] = ") must be >= 0";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
+static const char __pyx_k_recv_into[] = "recv_into";
+static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
+static const char __pyx_k_set_debug[] = "set_debug";
+static const char __pyx_k_sock_recv[] = "sock_recv";
+static const char __pyx_k_sockets_2[] = "sockets";
+static const char __pyx_k_start_tls[] = "start_tls";
+static const char __pyx_k_stdio_fut[] = "stdio_fut";
+static const char __pyx_k_threading[] = "threading";
+static const char __pyx_k_traceback[] = "__traceback__";
+static const char __pyx_k_transport[] = "transport";
+static const char __pyx_k_EAI_FAMILY[] = "EAI_FAMILY";
+static const char __pyx_k_EAI_MEMORY[] = "EAI_MEMORY";
+static const char __pyx_k_EAI_NODATA[] = "EAI_NODATA";
+static const char __pyx_k_EAI_NONAME[] = "EAI_NONAME";
+static const char __pyx_k_Loop__stop[] = "Loop._stop";
+static const char __pyx_k_SSLContext[] = "SSLContext";
+static const char __pyx_k_SocketKind[] = "SocketKind";
+static const char __pyx_k_SystemExit[] = "SystemExit";
+static const char __pyx_k_UnixServer[] = "UnixServer";
+static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_call_later[] = "call_later";
+static const char __pyx_k_concurrent[] = "concurrent";
+static const char __pyx_k_coroutines[] = "coroutines";
+static const char __pyx_k_created_at[] = "created at {}:{}";
+static const char __pyx_k_executable[] = "executable";
+static const char __pyx_k_get_buffer[] = "get_buffer";
+static const char __pyx_k_getsockopt[] = "getsockopt";
+static const char __pyx_k_gettimeout[] = "gettimeout";
+static const char __pyx_k_is_running[] = "is_running";
+static const char __pyx_k_local_addr[] = "local_addr";
+static const char __pyx_k_memoryview[] = "memoryview";
+static const char __pyx_k_preexec_fn[] = "preexec_fn";
+static const char __pyx_k_pyx_result[] = "__pyx_result";
+static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
+static const char __pyx_k_reuse_port[] = "reuse_port";
+static const char __pyx_k_set_result[] = "set_result";
+static const char __pyx_k_setsockopt[] = "setsockopt";
+static const char __pyx_k_settimeout[] = "settimeout";
+static const char __pyx_k_sighandler[] = "__sighandler";
+static const char __pyx_k_socketpair[] = "socketpair";
+static const char __pyx_k_ssl_object[] = "ssl_object";
+static const char __pyx_k_sslcontext[] = "sslcontext";
+static const char __pyx_k_stacklevel[] = "stacklevel";
+static const char __pyx_k_subprocess[] = "subprocess";
+static const char __pyx_k_transports[] = "transports";
+static const char __pyx_k_walk_stack[] = "walk_stack";
+static const char __pyx_k_EAI_SERVICE[] = "EAI_SERVICE";
+static const char __pyx_k_IPV6_V6ONLY[] = "IPV6_V6ONLY";
+static const char __pyx_k_MemoryError[] = "MemoryError";
+static const char __pyx_k_OrderedDict[] = "OrderedDict";
+static const char __pyx_k_PickleError[] = "PickleError";
+static const char __pyx_k_Read_errors[] = "Read errors:               {}";
+static const char __pyx_k_Read_events[] = "Read events:               {}";
+static const char __pyx_k_SSLProtocol[] = "SSLProtocol";
+static const char __pyx_k_TimerHandle[] = "TimerHandle";
+static const char __pyx_k_asyncio_log[] = "asyncio.log";
+static const char __pyx_k_bind_method[] = "bind() method";
+static const char __pyx_k_cfunc_to_py[] = "cfunc.to_py";
+static const char __pyx_k_collections[] = "collections";
+static const char __pyx_k_compression[] = "compression";
+static const char __pyx_k_create_task[] = "create_task";
+static const char __pyx_k_do_shutdown[] = "_do_shutdown";
+static const char __pyx_k_force_close[] = "_force_close";
+static const char __pyx_k_format_list[] = "format_list";
+static const char __pyx_k_getaddrinfo[] = "getaddrinfo";
+static const char __pyx_k_getnameinfo[] = "getnameinfo";
+static const char __pyx_k_getpeercert[] = "getpeercert";
+static const char __pyx_k_getpeername[] = "getpeername";
+static const char __pyx_k_getsockname[] = "getsockname";
+static const char __pyx_k_is_closed_2[] = " is closed";
+static const char __pyx_k_iscoroutine[] = "iscoroutine";
+static const char __pyx_k_isgenerator[] = "isgenerator";
+static const char __pyx_k_main_thread[] = "main_thread";
+static const char __pyx_k_move_to_end[] = "move_to_end";
+static const char __pyx_k_must_be_low[] = ") must be >= low (";
+static const char __pyx_k_recv_method[] = "recv() method";
+static const char __pyx_k_remote_addr[] = "remote_addr";
+static const char __pyx_k_run_forever[] = "run_forever";
+static const char __pyx_k_send_method[] = "send() method";
+static const char __pyx_k_server_side[] = "server_side";
+static const char __pyx_k_setblocking[] = "setblocking";
+static const char __pyx_k_sock_accept[] = "sock_accept";
+static const char __pyx_k_startupinfo[] = "startupinfo";
+static const char __pyx_k_traceback_2[] = "traceback";
+static const char __pyx_k_transport_2[] = "transport ";
+static const char __pyx_k_uvloop_loop[] = "uvloop.loop";
+static const char __pyx_k_wait_closed[] = "wait_closed";
+static const char __pyx_k_wrap_future[] = "wrap_future";
+static const char __pyx_k_BaseProtocol[] = "BaseProtocol";
+static const char __pyx_k_EAI_BADFLAGS[] = "EAI_BADFLAGS";
+static const char __pyx_k_EAI_BADHINTS[] = "EAI_BADHINTS";
+static const char __pyx_k_EAI_CANCELED[] = "EAI_CANCELED";
+static const char __pyx_k_EAI_OVERFLOW[] = "EAI_OVERFLOW";
+static const char __pyx_k_EAI_PROTOCOL[] = "EAI_PROTOCOL";
+static const char __pyx_k_EAI_SOCKTYPE[] = "EAI_SOCKTYPE";
+static const char __pyx_k_Process_info[] = "---- Process info: -----";
+static const char __pyx_k_PseudoSocket[] = "PseudoSocket";
+static const char __pyx_k_RuntimeError[] = "RuntimeError";
+static const char __pyx_k_SO_BROADCAST[] = "SO_BROADCAST";
+static const char __pyx_k_SO_REUSEPORT[] = "SO_REUSEPORT";
+static const char __pyx_k_StackSummary[] = "StackSummary";
+static const char __pyx_k_TCPTransport[] = "TCPTransport";
+static const char __pyx_k_TimeoutError[] = "TimeoutError";
+static const char __pyx_k_UDPTransport[] = "UDPTransport";
+static const char __pyx_k_Write_errors[] = "Write errors:              {}";
+static const char __pyx_k_Write_events[] = "Write events:              {}";
+static const char __pyx_k_alive_closed[] = "                        alive  | closed  |";
+static const char __pyx_k_app_protocol[] = "app_protocol";
+static const char __pyx_k_close_method[] = "close() method";
+static const char __pyx_k_disconnected[] = "disconnected";
+static const char __pyx_k_do_handshake[] = "do_handshake";
+static const char __pyx_k_eof_received[] = "eof_received";
+static const char __pyx_k_lookup_lines[] = "lookup_lines";
+static const char __pyx_k_objs_handles[] = "                        objs   | handles |";
+static const char __pyx_k_pyx_checksum[] = "__pyx_checksum";
+static const char __pyx_k_set_protocol[] = "set_protocol";
+static const char __pyx_k_siginterrupt[] = "siginterrupt";
+static const char __pyx_k_sock_connect[] = "sock_connect";
+static const char __pyx_k_sock_sendall[] = "sock_sendall";
+static const char __pyx_k_ssl_protocol[] = "ssl_protocol";
+static const char __pyx_k_stdio_inited[] = "__stdio_inited";
+static const char __pyx_k_stringsource[] = "stringsource";
+static const char __pyx_k_version_info[] = "version_info";
+static const char __pyx_k_AddressFamily[] = "AddressFamily";
+static const char __pyx_k_BaseException[] = "BaseException";
+static const char __pyx_k_Errors_logged[] = "Errors logged:             {}";
+static const char __pyx_k_Listen_errors[] = "Listen errors:             {}";
+static const char __pyx_k_OverflowError[] = "OverflowError";
+static const char __pyx_k_SOCK_NONBLOCK[] = "SOCK_NONBLOCK";
+static const char __pyx_k_UnixTransport[] = "UnixTransport";
+static const char __pyx_k_accept_method[] = "accept() method";
+static const char __pyx_k_asyncio_tasks[] = "asyncio.tasks";
+static const char __pyx_k_create_future[] = "create_future";
+static const char __pyx_k_create_server[] = "create_server";
+static const char __pyx_k_creationflags[] = "creationflags";
+static const char __pyx_k_data_received[] = "data_received";
+static const char __pyx_k_debug_wrapper[] = "debug_wrapper";
+static const char __pyx_k_detach_method[] = "detach() method";
+static const char __pyx_k_ensure_future[] = "ensure_future";
+static const char __pyx_k_getservbyname[] = "getservbyname";
+static const char __pyx_k_listen_method[] = "listen() method";
+static const char __pyx_k_loop__on_idle[] = "loop._on_idle";
+static const char __pyx_k_pause_reading[] = "pause_reading";
+static const char __pyx_k_pause_writing[] = "pause_writing";
+static const char __pyx_k_proto_factory[] = "proto_factory";
+static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_remove_reader[] = "remove_reader";
+static const char __pyx_k_remove_writer[] = "remove_writer";
+static const char __pyx_k_reuse_address[] = "reuse_address";
+static const char __pyx_k_sendto_method[] = "sendto() method";
+static const char __pyx_k_serve_forever[] = "serve_forever";
+static const char __pyx_k_set_exception[] = "set_exception";
+static const char __pyx_k_set_wakeup_fd[] = "set_wakeup_fd";
+static const char __pyx_k_start_serving[] = "start_serving";
+static const char __pyx_k_AttributeError[] = "AttributeError";
+static const char __pyx_k_CancelledError[] = "CancelledError";
+static const char __pyx_k_EAI_ADDRFAMILY[] = "EAI_ADDRFAMILY";
+static const char __pyx_k_Loop_sock_recv[] = "Loop.sock_recv";
+static const char __pyx_k_Loop_start_tls[] = "Loop.start_tls";
+static const char __pyx_k_Process_memory[] = "Process memory:            {}";
+static const char __pyx_k_Read_callbacks[] = "Read callbacks:            {}";
+static const char __pyx_k_RuntimeWarning[] = "RuntimeWarning";
+static const char __pyx_k_Server___aexit[] = "Server.__aexit__";
+static const char __pyx_k_SockAddrHolder[] = "SockAddrHolder";
+static const char __pyx_k_UDPSendContext[] = "_UDPSendContext";
+static const char __pyx_k_UVSocketHandle[] = "UVSocketHandle";
+static const char __pyx_k_UVStreamServer[] = "UVStreamServer";
+static const char __pyx_k_buffer_updated[] = "buffer_updated";
+static const char __pyx_k_check_hostname[] = "check_hostname";
+static const char __pyx_k_connect_failed[] = "connect failed";
+static const char __pyx_k_connect_method[] = "connect() method";
+static const char __pyx_k_error_received[] = "error_received";
+static const char __pyx_k_get_event_loop[] = "get_event_loop";
+static const char __pyx_k_get_extra_info[] = "get_extra_info";
+static const char __pyx_k_process_exited[] = "process_exited";
+static const char __pyx_k_r_received_EOF[] = "%r received EOF";
+static const char __pyx_k_recvmsg_method[] = "recvmsg() method";
+static const char __pyx_k_resume_reading[] = "resume_reading";
+static const char __pyx_k_resume_writing[] = "resume_writing";
+static const char __pyx_k_sendall_method[] = "sendall() method";
+static const char __pyx_k_sendmsg_method[] = "sendmsg() method";
+static const char __pyx_k_sock_recv_into[] = "sock_recv_into";
+static const char __pyx_k_subprocess_run[] = "__subprocess_run";
+static const char __pyx_k_AddrInfoRequest[] = "AddrInfoRequest";
+static const char __pyx_k_BlockingIOError[] = "BlockingIOError";
+static const char __pyx_k_BrokenPipeError[] = "BrokenPipeError";
+static const char __pyx_k_FileExistsError[] = "FileExistsError";
+static const char __pyx_k_Loop__sock_recv[] = "Loop._sock_recv";
+static const char __pyx_k_Loop_debug_info[] = "--- Loop debug info: ---";
+static const char __pyx_k_NameInfoRequest[] = "NameInfoRequest";
+static const char __pyx_k_PermissionError[] = "PermissionError";
+static const char __pyx_k_ResourceWarning[] = "ResourceWarning";
+static const char __pyx_k_SSLSyscallError[] = "SSLSyscallError";
+static const char __pyx_k_Server___aenter[] = "Server.__aenter__";
+static const char __pyx_k_Shutdown_errors[] = "Shutdown errors            {}";
+static const char __pyx_k_SubprocessError[] = "SubprocessError";
+static const char __pyx_k_Timer_handles_8[] = "Timer handles:             {: <8} | {}";
+static const char __pyx_k_UVBaseTransport[] = "UVBaseTransport";
+static const char __pyx_k_allow_broadcast[] = "allow_broadcast";
+static const char __pyx_k_asyncio_futures[] = "asyncio.futures";
+static const char __pyx_k_collections_abc[] = "collections.abc";
+static const char __pyx_k_connection_lost[] = "connection_lost";
+static const char __pyx_k_connection_made[] = "connection_made";
+static const char __pyx_k_get_inheritable[] = "get_inheritable";
+static const char __pyx_k_makefile_method[] = "makefile() method";
+static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError";
+static const char __pyx_k_recvfrom_method[] = "recvfrom() method";
+static const char __pyx_k_remove_reader_2[] = "__remove_reader";
+static const char __pyx_k_remove_writer_2[] = "__remove_writer";
+static const char __pyx_k_restore_signals[] = "restore_signals";
+static const char __pyx_k_sendfile_method[] = "sendfile() method";
+static const char __pyx_k_server_hostname[] = "server_hostname";
+static const char __pyx_k_set_inheritable[] = "set_inheritable";
+static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_shutdown_method[] = "shutdown() method";
+static const char __pyx_k_subprocess_exec[] = "subprocess_exec";
+static const char __pyx_k_uvloop_loop_pyx[] = "uvloop/loop.pyx";
+static const char __pyx_k_uvloop_sslproto[] = "uvloop.sslproto";
+static const char __pyx_k_CertificateError[] = "CertificateError";
+static const char __pyx_k_FlowControlMixin[] = "_FlowControlMixin";
+static const char __pyx_k_InterruptedError[] = "InterruptedError";
+static const char __pyx_k_Loop_getaddrinfo[] = "Loop.getaddrinfo";
+static const char __pyx_k_Loop_getnameinfo[] = "Loop.getnameinfo";
+static const char __pyx_k_Loop_sock_accept[] = "Loop.sock_accept";
+static const char __pyx_k_Polls_debug_info[] = "--- Polls debug info: ---";
+static const char __pyx_k_SSLWantReadError[] = "SSLWantReadError";
+static const char __pyx_k_Write_contexts_8[] = "Write contexts:            {: <8} | {}";
+static const char __pyx_k_asyncio_sslproto[] = "asyncio.sslproto";
+static const char __pyx_k_closed_reading_x[] = "<{} closed={} reading={} {:#x}>";
+static const char __pyx_k_decref_socketios[] = "_decref_socketios";
+static const char __pyx_k_get_running_loop[] = "_get_running_loop";
+static const char __pyx_k_on_ssl_connected[] = "__on_ssl_connected";
+static const char __pyx_k_print_debug_info[] = "print_debug_info";
+static const char __pyx_k_protocol_factory[] = "protocol_factory";
+static const char __pyx_k_recv_into_method[] = "recv_into() method";
+static const char __pyx_k_set_running_loop[] = "_set_running_loop";
+static const char __pyx_k_source_traceback[] = "source_traceback";
+static const char __pyx_k_subprocess_shell[] = "subprocess_shell";
+static const char __pyx_k_test_coroutine_1[] = "_test_coroutine_1";
+static const char __pyx_k_unix_socket_path[] = "unix socket path ";
+static const char __pyx_k_FileNotFoundError[] = "FileNotFoundError";
+static const char __pyx_k_InvalidStateError[] = "InvalidStateError";
+static const char __pyx_k_IsADirectoryError[] = "IsADirectoryError";
+static const char __pyx_k_KeyboardInterrupt[] = "KeyboardInterrupt";
+static const char __pyx_k_Loop__sock_accept[] = "Loop._sock_accept";
+static const char __pyx_k_Loop_sock_connect[] = "Loop.sock_connect";
+static const char __pyx_k_Loop_sock_sendall[] = "Loop.sock_sendall";
+static const char __pyx_k_Number_of_signals[] = "Number of signals:         {}";
+static const char __pyx_k_ReadUnixTransport[] = "ReadUnixTransport";
+static const char __pyx_k_SSL_ERROR_SYSCALL[] = "SSL_ERROR_SYSCALL";
+static const char __pyx_k_Socket_try_writes[] = "Socket try-writes:         {}";
+static const char __pyx_k_TCPConnectRequest[] = "_TCPConnectRequest";
+static const char __pyx_k_add_done_callback[] = "add_done_callback";
+static const char __pyx_k_bufsize_must_be_0[] = "bufsize must be 0";
+static const char __pyx_k_connect_ex_method[] = "connect_ex() method";
+static const char __pyx_k_connect_read_pipe[] = "connect_read_pipe";
+static const char __pyx_k_create_connection[] = "create_connection";
+static const char __pyx_k_datagram_received[] = "datagram_received";
+static const char __pyx_k_get_app_transport[] = "_get_app_transport";
+static const char __pyx_k_return_exceptions[] = "return_exceptions";
+static const char __pyx_k_start_new_session[] = "start_new_session";
+static const char __pyx_k_Callback_handles_8[] = "Callback handles:          {: <8} | {}";
+static const char __pyx_k_DeprecationWarning[] = "DeprecationWarning";
+static const char __pyx_k_Loop__sock_connect[] = "Loop._sock_connect";
+static const char __pyx_k_Loop__sock_sendall[] = "Loop._sock_sendall";
+static const char __pyx_k_Loop_create_server[] = "Loop.create_server";
+static const char __pyx_k_PYTHONASYNCIODEBUG[] = "PYTHONASYNCIODEBUG";
+static const char __pyx_k_PipeConnectRequest[] = "_PipeConnectRequest";
+static const char __pyx_k_ProcessLookupError[] = "ProcessLookupError";
+static const char __pyx_k_SSLZeroReturnError[] = "SSLZeroReturnError";
+static const char __pyx_k_Server_wait_closed[] = "Server.wait_closed";
+static const char __pyx_k_StreamWriteContext[] = "_StreamWriteContext";
+static const char __pyx_k_Streams_debug_info[] = "--- Streams debug info: ---";
+static const char __pyx_k_ThreadPoolExecutor[] = "ThreadPoolExecutor";
+static const char __pyx_k_UVProcessTransport[] = "UVProcessTransport";
+static const char __pyx_k_UnicodeEncodeError[] = "UnicodeEncodeError";
+static const char __pyx_k_WriteUnixTransport[] = "WriteUnixTransport";
+static const char __pyx_k_Write_without_poll[] = "Write without poll:        {}";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
+static const char __pyx_k_asyncio_transports[] = "asyncio.transports";
+static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_concurrent_futures[] = "concurrent.futures";
+static const char __pyx_k_connect_write_pipe[] = "connect_write_pipe";
+static const char __pyx_k_create_unix_server[] = "create_unix_server";
+static const char __pyx_k_get_asyncgen_hooks[] = "get_asyncgen_hooks";
+static const char __pyx_k_ignore_environment[] = "ignore_environment";
+static const char __pyx_k_pipe_data_received[] = "pipe_data_received";
+static const char __pyx_k_set_asyncgen_hooks[] = "set_asyncgen_hooks";
+static const char __pyx_k_shell_must_be_True[] = "shell must be True";
+static const char __pyx_k_shutdown_asyncgens[] = "shutdown_asyncgens";
+static const char __pyx_k_sig_out_of_range_1[] = "sig {} out of range(1, {})";
+static const char __pyx_k_universal_newlines[] = "universal_newlines";
+static const char __pyx_k_unopened_TCPServer[] = "unopened TCPServer";
+static const char __pyx_k_Connect_call_failed[] = "Connect call failed ";
+static const char __pyx_k_Loop_sock_recv_into[] = "Loop.sock_recv_into";
+static const char __pyx_k_Multiple_exceptions[] = "Multiple exceptions: {}";
+static const char __pyx_k_NotImplementedError[] = "NotImplementedError";
+static const char __pyx_k_SSL_ERROR_WANT_READ[] = "SSL_ERROR_WANT_READ";
+static const char __pyx_k_WeakValueDictionary[] = "WeakValueDictionary";
+static const char __pyx_k_asyncio_base_events[] = "asyncio.base_events";
+static const char __pyx_k_default_int_handler[] = "default_int_handler";
+static const char __pyx_k_iscoroutinefunction[] = "iscoroutinefunction";
+static const char __pyx_k_log_destroy_pending[] = "_log_destroy_pending";
+static const char __pyx_k_recvmsg_into_method[] = "recvmsg_into() method";
+static const char __pyx_k_shell_must_be_False[] = "shell must be False";
+static const char __pyx_k_unclosed_resource_r[] = "unclosed resource {!r}; {}";
+static const char __pyx_k_warn_on_full_buffer[] = "warn_on_full_buffer";
+static const char __pyx_k_AbstractChildWatcher[] = "AbstractChildWatcher";
+static const char __pyx_k_ConnectionResetError[] = "ConnectionResetError";
+static const char __pyx_k_Event_loop_is_closed[] = "Event loop is closed";
+static const char __pyx_k_Loop__read_from_self[] = "Loop._read_from_self";
+static const char __pyx_k_Loop__sock_recv_into[] = "Loop._sock_recv_into";
+static const char __pyx_k_Loop_subprocess_exec[] = "Loop.subprocess_exec";
+static const char __pyx_k_SSLProtocolTransport[] = "_SSLProtocolTransport";
+static const char __pyx_k_SSLProtocol__do_read[] = "SSLProtocol._do_read";
+static const char __pyx_k_SSL_ERROR_WANT_WRITE[] = "SSL_ERROR_WANT_WRITE";
+static const char __pyx_k_SSL_handshake_failed[] = "SSL handshake failed";
+static const char __pyx_k_Server_serve_forever[] = "Server.serve_forever";
+static const char __pyx_k_Server_start_serving[] = "Server.start_serving";
+static const char __pyx_k_call_connection_made[] = "call_connection_made";
+static const char __pyx_k_call_soon_threadsafe[] = "call_soon_threadsafe";
+static const char __pyx_k_pipe_connection_lost[] = "pipe_connection_lost";
+static const char __pyx_k_protocol_is_required[] = "protocol is required";
+static const char __pyx_k_recvfrom_into_method[] = "recvfrom_into() method";
+static const char __pyx_k_remove_done_callback[] = "remove_done_callback";
+static const char __pyx_k_running_closed_debug[] = "<{}.{} running={} closed={} debug={}>";
+static const char __pyx_k_sendmsg_afalg_method[] = "sendmsg_afalg() method";
+static const char __pyx_k_sig_cannot_be_caught[] = "sig {} cannot be caught";
+static const char __pyx_k_ssl_shutdown_timeout[] = "ssl_shutdown_timeout";
+static const char __pyx_k_AddrInfo_data_is_NULL[] = "AddrInfo.data is NULL";
+static const char __pyx_k_Exception_in_callback[] = "Exception in callback {}";
+static const char __pyx_k_Fatal_error_on_server[] = "Fatal error on server ";
+static const char __pyx_k_Invalid_file_object_r[] = "Invalid file object: {!r}";
+static const char __pyx_k_Loop___subprocess_run[] = "Loop.__subprocess_run";
+static const char __pyx_k_Loop_subprocess_shell[] = "Loop.subprocess_shell";
+static const char __pyx_k_Read_callbacks_failed[] = "Read callbacks failed:     {}";
+static const char __pyx_k_Read_failed_callbacks[] = "Read failed callbacks:     {}";
+static const char __pyx_k_get_coroutine_wrapper[] = "get_coroutine_wrapper";
+static const char __pyx_k_getfilesystemencoding[] = "getfilesystemencoding";
+static const char __pyx_k_invalid_waiter_object[] = "invalid waiter object ";
+static const char __pyx_k_pyx_unpickle_LruCache[] = "__pyx_unpickle_LruCache";
+static const char __pyx_k_remove_signal_handler[] = "remove_signal_handler";
+static const char __pyx_k_set_coroutine_wrapper[] = "set_coroutine_wrapper";
+static const char __pyx_k_ssl_handshake_timeout[] = "ssl_handshake_timeout";
+static const char __pyx_k_unclosed_resource_r_2[] = "unclosed resource {!r}";
+static const char __pyx_k_ConnectionAbortedError[] = "ConnectionAbortedError";
+static const char __pyx_k_ConnectionRefusedError[] = "ConnectionRefusedError";
+static const char __pyx_k_Loop_connect_read_pipe[] = "Loop.connect_read_pipe";
+static const char __pyx_k_Loop_create_connection[] = "Loop.create_connection";
+static const char __pyx_k_SSL_shutdown_timed_out[] = "SSL shutdown timed out";
+static const char __pyx_k_SyncSocketReaderFuture[] = "_SyncSocketReaderFuture";
+static const char __pyx_k_SyncSocketWriterFuture[] = "_SyncSocketWriterFuture";
+static const char __pyx_k_Write_callbacks_failed[] = "Write callbacks failed:    {}";
+static const char __pyx_k_Write_failed_callbacks[] = "Write failed callbacks:    {}";
+static const char __pyx_k_call_exception_handler[] = "call_exception_handler";
+static const char __pyx_k_cancel_request_is_NULL[] = "{}.cancel: .request is NULL";
+static const char __pyx_k_check_default_executor[] = "_check_default_executor";
+static const char __pyx_k_concurrent_allocations[] = "concurrent allocations";
+static const char __pyx_k_create_default_context[] = "create_default_context";
+static const char __pyx_k_create_unix_connection[] = "create_unix_connection";
+static const char __pyx_k_invalid_Handle_cb_type[] = "invalid Handle.cb_type: {}";
+static const char __pyx_k_r_starts_SSL_handshake[] = "%r starts SSL handshake";
+static const char __pyx_k_Invalid_file_descriptor[] = "Invalid file descriptor: {}";
+static const char __pyx_k_Loop_connect_write_pipe[] = "Loop.connect_write_pipe";
+static const char __pyx_k_Loop_create_unix_server[] = "Loop.create_unix_server";
+static const char __pyx_k_Loop_shutdown_asyncgens[] = "Loop.shutdown_asyncgens";
+static const char __pyx_k_ReadSubprocessPipeProto[] = "ReadSubprocessPipeProto";
+static const char __pyx_k_asyncgen_finalizer_hook[] = "_asyncgen_finalizer_hook";
+static const char __pyx_k_asyncgen_firstiter_hook[] = "_asyncgen_firstiter_hook";
+static const char __pyx_k_connect_accepted_socket[] = "connect_accepted_socket";
+static const char __pyx_k_expected_asyncio_Future[] = ", expected asyncio.Future";
+static const char __pyx_k_service_proto_not_found[] = "service/proto not found";
+static const char __pyx_k_uvloop_sleep_after_fork[] = "__uvloop_sleep_after_fork";
+static const char __pyx_k_AF_UNSPEC_in_DNS_results[] = "AF_UNSPEC in DNS results";
+static const char __pyx_k_Fatal_error_on_transport[] = "Fatal error on transport ";
+static const char __pyx_k_SSL_connection_is_closed[] = "SSL connection is closed";
+static const char __pyx_k_WriteSubprocessPipeProto[] = "WriteSubprocessPipeProto";
+static const char __pyx_k_context_manager_protocol[] = "context manager protocol";
+static const char __pyx_k_create_datagram_endpoint[] = "create_datagram_endpoint";
+static const char __pyx_k_exception_in_Task___repr[] = "exception in Task.__repr__";
+static const char __pyx_k_loop__exec_queued_writes[] = "loop._exec_queued_writes";
+static const char __pyx_k_set_wakeup_fd_1_failed_s[] = "set_wakeup_fd(-1) failed: %s";
+static const char __pyx_k_sig_must_be_an_int_not_r[] = "sig must be an int, not {!r}";
+static const char __pyx_k_Read_EOF_failed_callbacks[] = "Read EOF failed callbacks: {}";
+static const char __pyx_k_abort_init__closed_is_set[] = "_abort_init: {}._closed is set";
+static const char __pyx_k_abort_init__inited_is_set[] = "_abort_init: {}._inited is set";
+static const char __pyx_k_default_exception_handler[] = "default_exception_handler";
+static const char __pyx_k_pyx_unpickle_PseudoSocket[] = "__pyx_unpickle_PseudoSocket";
+static const char __pyx_k_shutdown_default_executor[] = "shutdown_default_executor";
+static const char __pyx_k_unexpected_address_family[] = "unexpected address family";
+static const char __pyx_k_Error_calling_eof_received[] = "Error calling eof_received()";
+static const char __pyx_k_Fatal_error_on_transport_2[] = "Fatal error on transport";
+static const char __pyx_k_Loop___get___locals_lambda[] = "Loop.__get__.<locals>.<lambda>";
+static const char __pyx_k_close__handle_data_is_NULL[] = "{}._close: _handle.data is NULL";
+static const char __pyx_k_is_alive_but__loop_is_None[] = "{} is alive, but _loop is None";
+static const char __pyx_k_r_SSL_handshake_took_1f_ms[] = "%r: SSL handshake took %.1f ms";
+static const char __pyx_k_uvloop_handles_process_pyx[] = "uvloop/handles/process.pyx";
+static const char __pyx_k_Address_r_is_already_in_use[] = "Address {!r} is already in use";
+static const char __pyx_k_Executing_r_took_3f_seconds[] = "Executing %r took %.3f seconds";
+static const char __pyx_k_Executing_s_took_3f_seconds[] = "Executing %s took %.3f seconds";
+static const char __pyx_k_Fatal_error_on_SSL_protocol[] = "Fatal error on SSL protocol";
+static const char __pyx_k_Loop_create_unix_connection[] = "Loop.create_unix_connection";
+static const char __pyx_k_cancel_request_data_is_NULL[] = "{}.cancel: .request.data is NULL";
+static const char __pyx_k_cannot_switch_state_from_to[] = "cannot switch state from {} to {}";
+static const char __pyx_k_close_uv_is_closing_is_true[] = "{}._close: uv_is_closing() is true";
+static const char __pyx_k_host_must_be_a_str_or_bytes[] = "host must be a str or bytes";
+static const char __pyx_k_invalid__init_protocol_call[] = "invalid _init_protocol call";
+static const char __pyx_k_Loop_connect_accepted_socket[] = "Loop.connect_accepted_socket";
+static const char __pyx_k_SyncSocketReaderFuture__loop[] = "_SyncSocketReaderFuture__loop";
+static const char __pyx_k_SyncSocketReaderFuture__sock[] = "_SyncSocketReaderFuture__sock";
+static const char __pyx_k_SyncSocketWriterFuture__loop[] = "_SyncSocketWriterFuture__loop";
+static const char __pyx_k_SyncSocketWriterFuture__sock[] = "_SyncSocketWriterFuture__sock";
+static const char __pyx_k_UVHandles_python_libuv_total[] = "UVHandles               python | libuv   | total";
+static const char __pyx_k_called_with_handle_data_NULL[] = "{} called with handle.data == NULL";
+static const char __pyx_k_could_not_bind_to_local_addr[] = "could not bind to local_addr {}";
+static const char __pyx_k_is_alive_but__handle_is_NULL[] = "{} is alive, but _handle is NULL";
+static const char __pyx_k_socket_send_raised_exception[] = "socket.send() raised exception.";
+static const char __pyx_k_startupinfo_is_not_supported[] = "startupinfo is not supported";
+static const char __pyx_k_AF_INET_address_must_be_tuple[] = "AF_INET address must be tuple";
+static const char __pyx_k_Handle_loop_is_None_in_Handle[] = "Handle.loop is None in Handle.__dealloc__";
+static const char __pyx_k_IPv4_sockaddr_must_be_2_tuple[] = "IPv4 sockaddr must be 2 tuple";
+static const char __pyx_k_Loop_create_datagram_endpoint[] = "Loop.create_datagram_endpoint";
+static const char __pyx_k_SyncSocketReaderFuture___init[] = "_SyncSocketReaderFuture.__init__";
+static const char __pyx_k_SyncSocketReaderFuture_cancel[] = "_SyncSocketReaderFuture.cancel";
+static const char __pyx_k_SyncSocketWriterFuture___init[] = "_SyncSocketWriterFuture.__init__";
+static const char __pyx_k_SyncSocketWriterFuture_cancel[] = "_SyncSocketWriterFuture.cancel";
+static const char __pyx_k_all_args_must_be_str_or_bytes[] = "all args must be str or bytes";
+static const char __pyx_k_could_not_bind_to_remote_addr[] = "could not bind to remote_addr {}";
+static const char __pyx_k_dealloc____handle_is_NULL__cl[] = "{}.__dealloc__: _handle is NULL, _closed == 1";
+static const char __pyx_k_does_not_have_a_reader_in_the[] = " does not have a reader in the _sock_recv callback";
+static const char __pyx_k_does_not_have_a_writer_in_the[] = " does not have a writer in the _sock_sendall callback";
+static const char __pyx_k_integer_argument_expected_got[] = "integer argument expected, got {}";
+static const char __pyx_k_is_longer_than_107_characters[] = " is longer than 107 characters";
+static const char __pyx_k_is_not_supported_by_start_tls[] = " is not supported by start_tls()";
+static const char __pyx_k_protocol_pause_writing_failed[] = "protocol.pause_writing() failed";
+static const char __pyx_k_r_fileno_returned_non_integer[] = "{!r}.fileno() returned non-integer";
+static const char __pyx_k_start_init_can_only_be_called[] = "{}._start_init can only be called once";
+static const char __pyx_k_AF_INET6_address_must_be_tuple[] = "AF_INET6 address must be tuple";
+static const char __pyx_k_Cannot_serialize_socket_object[] = "Cannot serialize socket object";
+static const char __pyx_k_Error_occurred_during_shutdown[] = "Error occurred during shutdown";
+static const char __pyx_k_Loop_shutdown_default_executor[] = "Loop.shutdown_default_executor";
+static const char __pyx_k_Pyx_CFunc_object____Loop____bi[] = "__Pyx_CFunc_object____Loop____bint___to_py.<locals>.wrap";
+static const char __pyx_k_Sock_ops_successful_on_1st_try[] = "--- Sock ops successful on 1st try: ---";
+static const char __pyx_k_SyncSocketReaderFuture__remove[] = "_SyncSocketReaderFuture__remove_reader";
+static const char __pyx_k_SyncSocketWriterFuture__remove[] = "_SyncSocketWriterFuture__remove_writer";
+static const char __pyx_k_cannot_apply_subprocess_STDOUT[] = "cannot apply subprocess.STDOUT";
+static const char __pyx_k_close__handle_data_is_not_UVHa[] = "{}._close: _handle.data is not UVHandle/self";
+static const char __pyx_k_creationflags_is_not_supported[] = "creationflags is not supported";
+static const char __pyx_k_fatal_sent_0_in_advance_uv_buf[] = "fatal: sent < 0 in advance_uv_buf";
+static const char __pyx_k_protocol_resume_writing_failed[] = "protocol.resume_writing() failed";
+static const char __pyx_k_sock_connect_cb_is_called_on_a[] = "_sock_connect_cb is called on a cancelled Future";
+static const char __pyx_k_unclosed_transport_uvloop_loop[] = "unclosed transport <uvloop.loop._SSLProtocolTransport object>";
+static const char __pyx_k_uv_close_handle_cb_handle_loop[] = "__uv_close_handle_cb: handle.loop is invalid";
+static const char __pyx_k_AF_INET6_must_be_a_tuple_of_2_4[] = "AF_INET6 must be a tuple of 2-4 parameters: (host, port, flowinfo?, scope_id?)";
+static const char __pyx_k_A_UDP_Socket_was_expected_got_r[] = "A UDP Socket was expected, got {!r}";
+static const char __pyx_k_A_UNIX_Domain_Stream_Socket_was[] = "A UNIX Domain Stream Socket was expected, got {!r}";
+static const char __pyx_k_AddrInfoRequest_callback_called[] = "AddrInfoRequest callback called with NULL resolver.data";
+static const char __pyx_k_Bad_exception_data_from_child_r[] = "Bad exception data from child: {!r}";
+static const char __pyx_k_Cannot_run_the_event_loop_while[] = "Cannot run the event loop while another loop is running";
+static const char __pyx_k_Invalid_address_must_be_None_or[] = "Invalid address: must be None or ";
+static const char __pyx_k_Neither_host_port_nor_sock_were[] = "Neither host/port nor sock were specified";
+static const char __pyx_k_Pickling_of_struct_members_such[] = "Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)";
+static const char __pyx_k_StreamWriteContext_close_py_buf[] = "_StreamWriteContext.close: py_bufs != NULL and py_bufs_sml_inuse is True";
+static const char __pyx_k_StreamWriteContext_close_uv_buf[] = "_StreamWriteContext.close: uv_bufs != NULL and py_bufs_sml_inuse is True";
+static const char __pyx_k_SyncSocketReaderFuture___remove[] = "_SyncSocketReaderFuture.__remove_reader";
+static const char __pyx_k_SyncSocketWriterFuture___remove[] = "_SyncSocketWriterFuture.__remove_writer";
+static const char __pyx_k_The_reuse_address_parameter_has[] = "The *reuse_address* parameter has been deprecated as of 0.15.";
+static const char __pyx_k_UVStream__try_write_called_with[] = "UVStream._try_write called with data in uv buffers";
+static const char __pyx_k_Unable_to_check_or_remove_stale[] = "Unable to check or remove stale UNIX socket %r: %r";
+static const char __pyx_k_WriteSubprocessPipeProto___init[] = "WriteSubprocessPipeProto.__init__";
+static const char __pyx_k_WriteSubprocessPipeProto___repr[] = "WriteSubprocessPipeProto.__repr__";
+static const char __pyx_k_WriteSubprocessPipeProto_resume[] = "WriteSubprocessPipeProto.resume_writing";
+static const char __pyx_k_asyncio_is_trying_to_install_it[] = "!!! asyncio is trying to install its ChildWatcher for SIGCHLD signal !!!\n\nThis is probably because a uvloop instance is used with asyncio.set_event_loop(). The correct way to use uvloop is to install its policy: `asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())`\n\n";
+static const char __pyx_k_buffer_size_is_not_0_after_a_su[] = "_buffer_size is not 0 after a successful _exec_write";
+static const char __pyx_k_called_after_destroying_the_UVH[] = "{} called after destroying the UVHandle";
+static const char __pyx_k_cancel_request_data_is_not_UVRe[] = "{}.cancel: .request.data is not UVRequest";
+static const char __pyx_k_cannot_add_a_signal_handler_for[] = "cannot add a signal handler for SIGCHLD: it is used by the event loop to track subprocesses";
+static const char __pyx_k_cannot_run_TimerHandle_callback[] = "cannot run TimerHandle; callback is not set";
+static const char __pyx_k_cannot_spawn_a_process_args_are[] = "cannot spawn a process: args are empty";
+static const char __pyx_k_create_datagram_endpoint_locals[] = "create_datagram_endpoint.<locals>.genexpr";
+static const char __pyx_k_deallocating_an_open_event_loop[] = "deallocating an open event loop";
+static const char __pyx_k_does_not_have_a_reader_in_the_2[] = " does not have a reader in the _sock_recv_into callback";
+static const char __pyx_k_does_not_have_a_writer_in_the_2[] = " does not have a writer in the _sock_connect_cb callback";
+static const char __pyx_k_expected_AF_INET_AF_INET6_or_AF[] = "expected AF_INET, AF_INET6, or AF_UNIX family, got ";
+static const char __pyx_k_getaddrinfo_returned_empty_list[] = "getaddrinfo() returned empty list";
+static const char __pyx_k_getsockaddrarg_scope_id_must_be[] = "getsockaddrarg: scope_id must be unsigned 32 bit integer";
+static const char __pyx_k_handle_loop_is_NULL_in___ensure[] = "handle.loop is NULL in __ensure_handle_data";
+static const char __pyx_k_host_and_port_was_not_specified[] = "host and port was not specified and no sock specified";
+static const char __pyx_k_is_alive_but__handle_data_is_no[] = "{} is alive, but _handle.data is not initialized";
+static const char __pyx_k_is_alive_but__handle_loop_is_no[] = "{} is alive, but _handle.loop is not initialized";
+static const char __pyx_k_is_already_being_awaited_on_ser[] = " is already being awaited on serve_forever()";
+static const char __pyx_k_is_not_supposed_to_be_instantia[] = "{} is not supposed to be instantiated from Python";
+static const char __pyx_k_is_open_in___dealloc___with_loo[] = "{} is open in __dealloc__ with loop set to NULL";
+static const char __pyx_k_no_path_and_sock_were_specified[] = "no path and sock were specified";
+static const char __pyx_k_port_must_be_a_str_bytes_or_int[] = "port must be a str, bytes or int";
+static const char __pyx_k_protocol_is_not_set_cannot_call[] = "protocol is not set, cannot call connection_made()";
+static const char __pyx_k_seconds_aborting_the_connection[] = " seconds: aborting the connection";
+static const char __pyx_k_sock_recv_into_is_called_on_a_c[] = "_sock_recv_into is called on a cancelled Future";
+static const char __pyx_k_sock_recv_is_called_on_a_cancel[] = "_sock_recv is called on a cancelled Future";
+static const char __pyx_k_sock_sendall_is_called_on_a_can[] = "_sock_sendall is called on a cancelled Future";
+static const char __pyx_k_sockaddr_must_be_a_tuple_of_2_3[] = "sockaddr must be a tuple of 2, 3 or 4 values";
+static const char __pyx_k_socket_family_mismatch_or_a_DNS[] = ": socket family mismatch or a DNS lookup is required";
+static const char __pyx_k_ssl_handshake_timeout_should_be[] = "ssl_handshake_timeout should be a positive number, got ";
+static const char __pyx_k_sslcontext_is_expected_to_be_an[] = "sslcontext is expected to be an instance of ssl.SSLContext, got ";
+static const char __pyx_k_task_factory_must_be_a_callable[] = "task factory must be a callable or None";
+static const char __pyx_k_the_socket_must_be_non_blocking[] = "the socket must be non-blocking";
+static const char __pyx_k_try_write_sent_all_data_and_ret[] = "_try_write sent all data and returned non-zero";
+static const char __pyx_k_unable_to_start_the_loop_it_was[] = "unable to start the loop; it was closed";
+static const char __pyx_k_uv_handle_t_current_freed_total[] = "uv_handle_t (current: {}; freed: {}; total: {})";
+static const char __pyx_k_uvloop_PseudoSocket_fd_family_s[] = "<uvloop.PseudoSocket fd={}, family={!s}, type={!s}, proto={}";
+static const char __pyx_k_without_no_gc_clear_loop_was_se[] = "{} without @no_gc_clear; loop was set to None by GC";
+static const char __pyx_k_AF_INET_address_must_be_tuple_of[] = "AF_INET address must be tuple of (host, port)";
+static const char __pyx_k_AF_UNIX_address_must_be_a_str_or[] = "AF_UNIX address must be a str or a bytes object";
+static const char __pyx_k_A_Stream_Socket_was_expected_got[] = "A Stream Socket was expected, got {!r}";
+static const char __pyx_k_A_callable_object_or_None_is_exp[] = "A callable object or None is expected, got {!r}";
+static const char __pyx_k_Cannot_call_write_after_write_eo[] = "Cannot call write() after write_eof()";
+static const char __pyx_k_Cannot_call_writelines_after_wri[] = "Cannot call writelines() after write_eof()";
+static const char __pyx_k_Cannot_close_a_running_event_loo[] = "Cannot close a running event loop";
+static const char __pyx_k_Creating__SSLProtocolTransport_t[] = "Creating _SSLProtocolTransport twice";
+static const char __pyx_k_Event_loop_stopped_before_Future[] = "Event loop stopped before Future completed.";
+static const char __pyx_k_Exception_in___repr___r_value_ty[] = "Exception in __repr__ {!r}; value type: {!r}";
+static const char __pyx_k_Exception_in_default_exception_h[] = "Exception in default exception handler";
+static const char __pyx_k_Exception_occurred_in_preexec_fn[] = "Exception occurred in preexec_fn.";
+static const char __pyx_k_Executor_shutdown_has_been_calle[] = "Executor shutdown has been called";
+static const char __pyx_k_Fatal_write_error_on_datagram_tr[] = "Fatal write error on datagram transport";
+static const char __pyx_k_File_descriptor_r_is_used_by_tra[] = "File descriptor {!r} is used by transport {!r}";
+static const char __pyx_k_Incompatible_checksums_s_vs_0x53[] = "Incompatible checksums (%s vs 0x53368d7 = (_dict, _dict_get, _dict_move_to_end, _maxsize))";
+static const char __pyx_k_Incompatible_checksums_s_vs_0x88[] = "Incompatible checksums (%s vs 0x88c0b03 = (_family, _fd, _peername, _proto, _sockname, _type))";
+static const char __pyx_k_Loop__getaddrinfo_locals_callbac[] = "Loop._getaddrinfo.<locals>.callback";
+static const char __pyx_k_Loop__getnameinfo_locals_callbac[] = "Loop._getnameinfo.<locals>.callback";
+static const char __pyx_k_Non_thread_safe_operation_invoke[] = "Non-thread-safe operation invoked on an event loop other than the current one";
+static const char __pyx_k_Object_created_at_most_recent_ca[] = "Object created at (most recent call last):\n";
+static const char __pyx_k_Passing_reuse_address_True_is_no[] = "Passing `reuse_address=True` is no longer supported, as the usage of SO_REUSEPORT in UDP poses a significant security concern.";
+static const char __pyx_k_Racing_with_another_loop_to_spaw[] = "Racing with another loop to spawn a process.";
+static const char __pyx_k_ReadSubprocessPipeProto_data_rec[] = "ReadSubprocessPipeProto.data_received";
+static const char __pyx_k_SSLProtocol__start_handshake_loc[] = "SSLProtocol._start_handshake.<locals>.<lambda>";
+static const char __pyx_k_SSLProtocol__start_shutdown_loca[] = "SSLProtocol._start_shutdown.<locals>.<lambda>";
+static const char __pyx_k_SSL_handshake_failed_on_verifyin[] = "SSL handshake failed on verifying the certificate";
+static const char __pyx_k_SSL_handshake_is_taking_longer_t[] = "SSL handshake is taking longer than ";
+static const char __pyx_k_Server_side_SSL_needs_a_valid_SS[] = "Server side SSL needs a valid SSLContext";
+static const char __pyx_k_UDPTransport_family_is_undefined[] = "UDPTransport.family is undefined; cannot create python socket";
+static const char __pyx_k_UVProcessTransport__call_connect[] = "UVProcessTransport._call_connection_made";
+static const char __pyx_k_UVProcess__close_after_spawn_cal[] = "UVProcess._close_after_spawn called after uv_spawn";
+static const char __pyx_k_UVStream_shutdown_callback_calle[] = "UVStream.shutdown callback called with NULL req.data, status=%r";
+static const char __pyx_k_UVStream_write_callback_called_w[] = "UVStream.write callback called with NULL req.data, status=%r";
+static const char __pyx_k_UVTransport__call_connection_los[] = "UVTransport._call_connection_lost";
+static const char __pyx_k_UVTransport__call_connection_mad[] = "UVTransport._call_connection_made";
+static const char __pyx_k_Unhandled_error_in_exception_han[] = "Unhandled error in exception handler";
+static const char __pyx_k_Unhandled_exception_in_event_loo[] = "Unhandled exception in event loop";
+static const char __pyx_k_WriteSubprocessPipeProto_connect[] = "WriteSubprocessPipeProto.connection_made";
+static const char __pyx_k_WriteSubprocessPipeProto_pause_w[] = "WriteSubprocessPipeProto.pause_writing";
+static const char __pyx_k_XXX_an_allocated_buffer_in_trans[] = "XXX: an allocated buffer in transport._close()";
+static const char __pyx_k_You_must_set_server_hostname_whe[] = "You must set server_hostname when using ssl without a host";
+static const char __pyx_k_active_TimerHandle_is_deallacati[] = "active TimerHandle is deallacating";
+static const char __pyx_k_add_signal_handler_can_only_be_c[] = "add_signal_handler() can only be called from the main thread";
+static const char __pyx_k_all_environment_values_must_be_b[] = "all environment values must be bytes or str";
+static const char __pyx_k_all_environment_vars_must_be_byt[] = "all environment vars must be bytes or str";
+static const char __pyx_k_an_error_occurred_during_closing[] = "an error occurred during closing of asynchronous generator {!r}";
+static const char __pyx_k_asynchronous_generator_r_was_sch[] = "asynchronous generator {!r} was scheduled after loop.shutdown_asyncgens() call";
+static const char __pyx_k_cannot_cleanup_signal_handlers_c[] = "cannot cleanup signal handlers: closing the event loop in a non-main OS thread";
+static const char __pyx_k_cannot_convert_sockaddr_into_Pyt[] = "cannot convert sockaddr into Python object";
+static const char __pyx_k_cannot_open_a_UDP_handle_invalid[] = "cannot open a UDP handle, invalid family {}";
+static const char __pyx_k_cannot_pause_signals_handling_no[] = "cannot pause signals handling; no longer running in the main thread";
+static const char __pyx_k_cannot_run_Handle_callback_is_no[] = "cannot run Handle; callback is not set";
+static const char __pyx_k_cannot_shutdown_signals_handling[] = "cannot shutdown signals handling as it has not been paused";
+static const char __pyx_k_closed_Transport_handle_and_unse[] = "closed Transport handle and unset waiter";
+static const char __pyx_k_coroutines_cannot_be_used_with_a[] = "coroutines cannot be used with add_signal_handler()";
+static const char __pyx_k_coroutines_cannot_be_used_with_r[] = "coroutines cannot be used with run_in_executor()";
+static const char __pyx_k_could_not_close_attached_file_ob[] = "could not close attached file object ";
+static const char __pyx_k_create_connection_locals_genexpr[] = "create_connection.<locals>.genexpr";
+static const char __pyx_k_create_server_failed_to_create_s[] = "create_server() failed to create socket.socket(%r, %r, %r)";
+static const char __pyx_k_cwd_must_be_a_str_or_bytes_objec[] = "cwd must be a str or bytes object";
+static const char __pyx_k_data_expecting_a_bytes_like_inst[] = "data: expecting a bytes-like instance, got ";
+static const char __pyx_k_deallocating_a_running_event_loo[] = "deallocating a running event loop!";
+static const char __pyx_k_error_status_in_uv_stream_t_list[] = "error status in uv_stream_t.listen callback";
+static const char __pyx_k_error_status_in_uv_stream_t_read[] = "error status in uv_stream_t.read callback";
+static const char __pyx_k_error_status_in_uv_stream_t_shut[] = "error status in uv_stream_t.shutdown callback";
+static const char __pyx_k_error_status_in_uv_stream_t_writ[] = "error status in uv_stream_t.write callback";
+static const char __pyx_k_error_while_attempting_to_bind_o[] = "error while attempting to bind on address ";
+static const char __pyx_k_fatal_Could_not_advance__StreamW[] = "fatal: Could not advance _StreamWriteContext";
+static const char __pyx_k_get_coroutine_origin_tracking_de[] = "get_coroutine_origin_tracking_depth";
+static const char __pyx_k_getnameinfo_argument_1_must_be_a[] = "getnameinfo() argument 1 must be a tuple";
+static const char __pyx_k_getnameinfo_flowinfo_must_be_0_1[] = "getnameinfo(): flowinfo must be 0-1048575.";
+static const char __pyx_k_handle_data_is_NULL_in___close_a[] = "handle.data is NULL in __close_all_handles_cb";
+static const char __pyx_k_handle_loop_data_is_NULL_in___en[] = "handle.loop.data is NULL in __ensure_handle_data";
+static const char __pyx_k_has_handle_0_in___uv_close_handl[] = "has_handle=0 in __uv_close_handle_cb";
+static const char __pyx_k_host_must_be_a_string_or_bytes_o[] = "host must be a string or bytes object";
+static const char __pyx_k_host_port_and_sock_can_not_be_sp[] = "host/port and sock can not be specified at the same time";
+static const char __pyx_k_invalid_data_in_writebuf_an_inst[] = "invalid data in writebuf: an instance of bytes, bytearray or memoryview was expected, got {}";
+static const char __pyx_k_invalid_socket_family_expected_A[] = "invalid socket family, expected AF_UNIX, AF_INET or AF_INET6";
+static const char __pyx_k_local_addr_must_be_a_tuple_of_ho[] = "local_addr must be a tuple of host and port";
+static const char __pyx_k_loop__queued_streams_are_not_emp[] = "loop._queued_streams are not empty after _exec_queued_writes";
+static const char __pyx_k_maxsize_is_expected_to_be_greate[] = "maxsize is expected to be greater than 0, got ";
+static const char __pyx_k_new_callbacks_were_queued_during[] = "new callbacks were queued during loop closing: ";
+static const char __pyx_k_new_poll_handles_were_queued_dur[] = "new poll handles were queued during loop closing: ";
+static const char __pyx_k_new_timers_were_queued_during_lo[] = "new timers were queued during loop closing: ";
+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_python_buffer_is_allocated_in[] = "no python buffer is allocated in on_read; nread=";
+static const char __pyx_k_object_created_at_most_recent_ca[] = "object created at (most recent call last):\n{}";
+static const char __pyx_k_open__StreamWriteContext_is_bein[] = "open _StreamWriteContext is being deallocated";
+static const char __pyx_k_open__UDPSendContext_is_being_de[] = "open _UDPSendContext is being deallocated";
+static const char __pyx_k_path_and_sock_can_not_be_specifi[] = "path and sock can not be specified at the same time";
+static const char __pyx_k_path_was_not_specified_and_no_so[] = "path was not specified, and no sock specified";
+static const char __pyx_k_remote_addr_must_be_a_tuple_of_h[] = "remote_addr must be a tuple of (host, port)";
+static const char __pyx_k_remove_signal_handler_can_only_b[] = "remove_signal_handler() can only be called from the main thread";
+static const char __pyx_k_returning_true_from_eof_received[] = "returning true from eof_received() has no effect when using ssl";
+static const char __pyx_k_reuse_port_not_supported_by_sock[] = "reuse_port not supported by socket module";
+static const char __pyx_k_run_until_complete_locals_done_c[] = "run_until_complete.<locals>.done_cb";
+static const char __pyx_k_self_pipe_exists_before_loop_run[] = "self-pipe exists before loop run";
+static const char __pyx_k_self_pipe_was_not_cleaned_up_aft[] = "self-pipe was not cleaned up after loop was run";
+static const char __pyx_k_self_py_buf_self_req_cannot_be_c[] = "self.py_buf,self.req cannot be converted to a Python object for pickling";
+static const char __pyx_k_self_py_bufs_self_py_bufs_sml_se[] = "self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling";
+static const char __pyx_k_server_hostname_is_only_meaningf[] = "server_hostname is only meaningful with ssl";
+static const char __pyx_k_set_coroutine_origin_tracking_de[] = "set_coroutine_origin_tracking_depth";
+static const char __pyx_k_setblocking_transport_sockets_ca[] = "setblocking(): transport sockets cannot be blocking";
+static const char __pyx_k_settimeout_only_0_timeout_is_all[] = "settimeout(): only 0 timeout is allowed on transport sockets";
+static const char __pyx_k_signals_handling_has_been_alread[] = "signals handling has been already setup";
+static const char __pyx_k_signals_handling_has_not_been_se[] = "signals handling has not been setup";
+static const char __pyx_k_sockaddr_resolved_to_multiple_ad[] = "sockaddr resolved to multiple addresses";
+static const char __pyx_k_socket_modifier_keyword_argument[] = "socket modifier keyword arguments can not be used when sock is specified. ({})";
+static const char __pyx_k_ssl_argument_must_be_an_SSLConte[] = "ssl argument must be an SSLContext or None";
+static const char __pyx_k_ssl_handshake_timeout_is_only_me[] = "ssl_handshake_timeout is only meaningful with ssl";
+static const char __pyx_k_ssl_is_expected_to_be_None_or_an[] = "ssl is expected to be None or an instance of ssl.SSLContext, got {!r}";
+static const char __pyx_k_ssl_shutdown_timeout_is_only_mea[] = "ssl_shutdown_timeout is only meaningful with ssl";
+static const char __pyx_k_ssl_shutdown_timeout_should_be_a[] = "ssl_shutdown_timeout should be a positive number, got ";
+static const char __pyx_k_stream_is_open_after_UVStream__t[] = "stream is open after UVStream._try_write returned None";
+static const char __pyx_k_subprocess_STDOUT_is_supported_o[] = "subprocess.STDOUT is supported only by stderr parameter";
+static const char __pyx_k_this_event_loop_is_already_runni[] = "this event loop is already running.";
+static const char __pyx_k_transport_sockets_do_not_support[] = "transport sockets do not support {}";
+static const char __pyx_k_unable_to_listen_no_protocol_fac[] = "unable to listen(); no protocol_factory";
+static const char __pyx_k_unable_to_perform_operation_on_r[] = "unable to perform operation on {!r}; the handler is closed";
+static const char __pyx_k_unclosed_resource_r_could_not_se[] = "unclosed resource {!r}; could not serialize debug traceback: {}: {}";
+static const char __pyx_k_unhandled_error_or_an_empty_buff[] = "unhandled error (or an empty buffer) in get_buffer()";
+static const char __pyx_k_universal_newlines_must_be_False[] = "universal_newlines must be False";
+static const char __pyx_k_getaddrinfo_returned_empty_list_2[] = "getaddrinfo() returned empty list for local_addr";
+static const char __pyx_k_Exception_in_default_exception_h_2[] = "Exception in default exception handler while handling an unexpected error in custom exception handler";
+static const char __pyx_k_UDPTransport_family_is_undefined_2[] = "UDPTransport.family is undefined; cannot send";
+static const char __pyx_k_WriteSubprocessPipeProto_connect_2[] = "WriteSubprocessPipeProto.connection_lost";
+static const char __pyx_k_local_addr_must_be_a_tuple_of_ho_2[] = "local_addr must be a tuple of (host, port)";
+static PyObject *__pyx_kp_b_1;
+static PyObject *__pyx_kp_u_18_7_7_7;
+static PyObject *__pyx_kp_u_AF_INET6_address_must_be_tuple;
+static PyObject *__pyx_kp_u_AF_INET6_must_be_a_tuple_of_2_4;
+static PyObject *__pyx_kp_u_AF_INET_address_must_be_tuple;
+static PyObject *__pyx_kp_u_AF_INET_address_must_be_tuple_of;
+static PyObject *__pyx_kp_u_AF_UNIX_address_must_be_a_str_or;
+static PyObject *__pyx_kp_u_AF_UNSPEC_in_DNS_results;
+static PyObject *__pyx_kp_u_A_Stream_Socket_was_expected_got;
+static PyObject *__pyx_kp_u_A_UDP_Socket_was_expected_got_r;
+static PyObject *__pyx_kp_u_A_UNIX_Domain_Stream_Socket_was;
+static PyObject *__pyx_kp_u_A_callable_object_or_None_is_exp;
+static PyObject *__pyx_n_s_AbstractChildWatcher;
+static PyObject *__pyx_n_s_AddrInfo;
+static PyObject *__pyx_n_s_AddrInfoRequest;
+static PyObject *__pyx_kp_u_AddrInfoRequest_callback_called;
+static PyObject *__pyx_kp_u_AddrInfo_data_is_NULL;
+static PyObject *__pyx_n_s_AddressFamily;
+static PyObject *__pyx_kp_u_Address_r_is_already_in_use;
+static PyObject *__pyx_n_s_AttributeError;
+static PyObject *__pyx_kp_u_Bad_exception_data_from_child_r;
+static PyObject *__pyx_n_s_BaseException;
+static PyObject *__pyx_n_s_BaseProtocol;
+static PyObject *__pyx_n_s_BlockingIOError;
+static PyObject *__pyx_n_s_BrokenPipeError;
+static PyObject *__pyx_kp_u_Callback_handles_8;
+static PyObject *__pyx_n_s_CancelledError;
+static PyObject *__pyx_kp_u_Cannot_call_write_after_write_eo;
+static PyObject *__pyx_kp_u_Cannot_call_writelines_after_wri;
+static PyObject *__pyx_kp_u_Cannot_close_a_running_event_loo;
+static PyObject *__pyx_kp_u_Cannot_run_the_event_loop_while;
+static PyObject *__pyx_kp_u_Cannot_serialize_socket_object;
+static PyObject *__pyx_n_s_CertificateError;
+static PyObject *__pyx_kp_u_Connect_call_failed;
+static PyObject *__pyx_n_s_ConnectionAbortedError;
+static PyObject *__pyx_n_s_ConnectionRefusedError;
+static PyObject *__pyx_n_s_ConnectionResetError;
+static PyObject *__pyx_n_s_Counter;
+static PyObject *__pyx_kp_u_Creating__SSLProtocolTransport_t;
+static PyObject *__pyx_n_s_DEVNULL;
+static PyObject *__pyx_n_s_DeprecationWarning;
+static PyObject *__pyx_n_u_EAI_ADDRFAMILY;
+static PyObject *__pyx_n_u_EAI_AGAIN;
+static PyObject *__pyx_n_u_EAI_BADFLAGS;
+static PyObject *__pyx_n_u_EAI_BADHINTS;
+static PyObject *__pyx_n_u_EAI_CANCELED;
+static PyObject *__pyx_n_u_EAI_FAIL;
+static PyObject *__pyx_n_u_EAI_FAMILY;
+static PyObject *__pyx_n_u_EAI_MEMORY;
+static PyObject *__pyx_n_u_EAI_NODATA;
+static PyObject *__pyx_n_u_EAI_NONAME;
+static PyObject *__pyx_n_u_EAI_OVERFLOW;
+static PyObject *__pyx_n_u_EAI_PROTOCOL;
+static PyObject *__pyx_n_u_EAI_SERVICE;
+static PyObject *__pyx_n_u_EAI_SOCKTYPE;
+static PyObject *__pyx_kp_u_Error_calling_eof_received;
+static PyObject *__pyx_kp_u_Error_occurred_during_shutdown;
+static PyObject *__pyx_kp_u_Errors_logged;
+static PyObject *__pyx_kp_u_Event_loop_is_closed;
+static PyObject *__pyx_kp_u_Event_loop_stopped_before_Future;
+static PyObject *__pyx_kp_u_Exception_in___repr___r_value_ty;
+static PyObject *__pyx_kp_u_Exception_in_callback;
+static PyObject *__pyx_kp_u_Exception_in_default_exception_h;
+static PyObject *__pyx_kp_u_Exception_in_default_exception_h_2;
+static PyObject *__pyx_kp_u_Exception_occurred_in_preexec_fn;
+static PyObject *__pyx_kp_u_Executing_r_took_3f_seconds;
+static PyObject *__pyx_kp_u_Executing_s_took_3f_seconds;
+static PyObject *__pyx_kp_u_Executor_shutdown_has_been_calle;
+static PyObject *__pyx_kp_u_Fatal_error_on_SSL_protocol;
+static PyObject *__pyx_kp_u_Fatal_error_on_server;
+static PyObject *__pyx_kp_u_Fatal_error_on_transport;
+static PyObject *__pyx_kp_u_Fatal_error_on_transport_2;
+static PyObject *__pyx_kp_u_Fatal_write_error_on_datagram_tr;
+static PyObject *__pyx_n_s_FileExistsError;
+static PyObject *__pyx_n_s_FileNotFoundError;
+static PyObject *__pyx_kp_u_File_descriptor_r_is_used_by_tra;
+static PyObject *__pyx_n_s_FlowControlMixin;
+static PyObject *__pyx_n_s_Future;
+static PyObject *__pyx_n_s_Handle;
+static PyObject *__pyx_kp_u_Handle_loop_is_None_in_Handle;
+static PyObject *__pyx_n_u_IPV6_V6ONLY;
+static PyObject *__pyx_kp_u_IPv4_sockaddr_must_be_2_tuple;
+static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0x53;
+static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0x88;
+static PyObject *__pyx_n_s_InterruptedError;
+static PyObject *__pyx_n_s_InvalidStateError;
+static PyObject *__pyx_kp_u_Invalid_address_must_be_None_or;
+static PyObject *__pyx_kp_u_Invalid_file_descriptor;
+static PyObject *__pyx_kp_u_Invalid_file_object_r;
+static PyObject *__pyx_n_s_IsADirectoryError;
+static PyObject *__pyx_n_s_Iterable;
+static PyObject *__pyx_n_s_KeyError;
+static PyObject *__pyx_n_s_KeyboardInterrupt;
+static PyObject *__pyx_kp_u_Listen_errors;
+static PyObject *__pyx_n_s_Loop;
+static PyObject *__pyx_n_s_Loop___get___locals_lambda;
+static PyObject *__pyx_n_s_Loop___subprocess_run;
+static PyObject *__pyx_n_s_Loop__getaddrinfo_locals_callbac;
+static PyObject *__pyx_n_s_Loop__getnameinfo_locals_callbac;
+static PyObject *__pyx_kp_u_Loop__read_from_self;
+static PyObject *__pyx_kp_u_Loop__sock_accept;
+static PyObject *__pyx_kp_u_Loop__sock_connect;
+static PyObject *__pyx_kp_u_Loop__sock_recv;
+static PyObject *__pyx_kp_u_Loop__sock_recv_into;
+static PyObject *__pyx_kp_u_Loop__sock_sendall;
+static PyObject *__pyx_kp_u_Loop__stop;
+static PyObject *__pyx_n_s_Loop_connect_accepted_socket;
+static PyObject *__pyx_n_s_Loop_connect_read_pipe;
+static PyObject *__pyx_n_s_Loop_connect_write_pipe;
+static PyObject *__pyx_n_s_Loop_create_connection;
+static PyObject *__pyx_n_s_Loop_create_datagram_endpoint;
+static PyObject *__pyx_n_s_Loop_create_server;
+static PyObject *__pyx_n_s_Loop_create_unix_connection;
+static PyObject *__pyx_n_s_Loop_create_unix_server;
+static PyObject *__pyx_kp_u_Loop_debug_info;
+static PyObject *__pyx_n_s_Loop_getaddrinfo;
+static PyObject *__pyx_n_s_Loop_getnameinfo;
+static PyObject *__pyx_n_s_Loop_shutdown_asyncgens;
+static PyObject *__pyx_n_s_Loop_shutdown_default_executor;
+static PyObject *__pyx_n_s_Loop_sock_accept;
+static PyObject *__pyx_n_s_Loop_sock_connect;
+static PyObject *__pyx_n_s_Loop_sock_recv;
+static PyObject *__pyx_n_s_Loop_sock_recv_into;
+static PyObject *__pyx_n_s_Loop_sock_sendall;
+static PyObject *__pyx_n_s_Loop_start_tls;
+static PyObject *__pyx_n_s_Loop_subprocess_exec;
+static PyObject *__pyx_n_s_Loop_subprocess_shell;
+static PyObject *__pyx_kp_u_Loop_time;
+static PyObject *__pyx_n_s_LruCache;
+static PyObject *__pyx_n_s_MemoryBIO;
+static PyObject *__pyx_n_s_MemoryError;
+static PyObject *__pyx_kp_u_Multiple_exceptions;
+static PyObject *__pyx_n_s_NSIG;
+static PyObject *__pyx_n_s_NameInfoRequest;
+static PyObject *__pyx_kp_u_Neither_host_port_nor_sock_were;
+static PyObject *__pyx_kp_u_Non_thread_safe_operation_invoke;
+static PyObject *__pyx_n_s_NotImplementedError;
+static PyObject *__pyx_kp_u_Number_of_signals;
+static PyObject *__pyx_n_s_OSError;
+static PyObject *__pyx_n_s_O_RDWR;
+static PyObject *__pyx_kp_u_Object_created_at_most_recent_ca;
+static PyObject *__pyx_n_s_OrderedDict;
+static PyObject *__pyx_n_s_OverflowError;
+static PyObject *__pyx_n_s_PIPE;
+static PyObject *__pyx_n_u_PYTHONASYNCIODEBUG;
+static PyObject *__pyx_kp_u_Passing_reuse_address_True_is_no;
+static PyObject *__pyx_n_s_PermissionError;
+static PyObject *__pyx_n_s_PickleError;
+static PyObject *__pyx_kp_s_Pickling_of_struct_members_such;
+static PyObject *__pyx_n_s_PipeConnectRequest;
+static PyObject *__pyx_kp_u_Polls_debug_info;
+static PyObject *__pyx_n_s_ProcessLookupError;
+static PyObject *__pyx_kp_u_Process_info;
+static PyObject *__pyx_kp_u_Process_memory;
+static PyObject *__pyx_n_s_Protocol;
+static PyObject *__pyx_n_s_PseudoSocket;
+static PyObject *__pyx_n_s_Pyx_CFunc_object____Loop____bi;
+static PyObject *__pyx_kp_u_Racing_with_another_loop_to_spaw;
+static PyObject *__pyx_n_s_ReadSubprocessPipeProto;
+static PyObject *__pyx_n_s_ReadSubprocessPipeProto_data_rec;
+static PyObject *__pyx_n_s_ReadUnixTransport;
+static PyObject *__pyx_kp_u_Read_EOF_failed_callbacks;
+static PyObject *__pyx_kp_u_Read_EOFs;
+static PyObject *__pyx_kp_u_Read_callbacks;
+static PyObject *__pyx_kp_u_Read_callbacks_failed;
+static PyObject *__pyx_kp_u_Read_errors;
+static PyObject *__pyx_kp_u_Read_events;
+static PyObject *__pyx_kp_u_Read_failed_callbacks;
+static PyObject *__pyx_n_s_ResourceWarning;
+static PyObject *__pyx_n_s_RuntimeError;
+static PyObject *__pyx_n_s_RuntimeWarning;
+static PyObject *__pyx_n_s_SIG_DFL;
+static PyObject *__pyx_n_u_SOCK_NONBLOCK;
+static PyObject *__pyx_n_u_SO_BROADCAST;
+static PyObject *__pyx_n_u_SO_REUSEPORT;
+static PyObject *__pyx_n_s_SSLContext;
+static PyObject *__pyx_n_s_SSLError;
+static PyObject *__pyx_n_s_SSLProtocol;
+static PyObject *__pyx_n_s_SSLProtocolTransport;
+static PyObject *__pyx_kp_u_SSLProtocol__do_read;
+static PyObject *__pyx_n_s_SSLProtocol__start_handshake_loc;
+static PyObject *__pyx_n_s_SSLProtocol__start_shutdown_loca;
+static PyObject *__pyx_n_s_SSLSyscallError;
+static PyObject *__pyx_n_s_SSLWantReadError;
+static PyObject *__pyx_n_s_SSLZeroReturnError;
+static PyObject *__pyx_n_s_SSL_ERROR_SYSCALL;
+static PyObject *__pyx_n_s_SSL_ERROR_WANT_READ;
+static PyObject *__pyx_n_s_SSL_ERROR_WANT_WRITE;
+static PyObject *__pyx_kp_u_SSL_connection_is_closed;
+static PyObject *__pyx_kp_u_SSL_handshake_failed;
+static PyObject *__pyx_kp_u_SSL_handshake_failed_on_verifyin;
+static PyObject *__pyx_kp_u_SSL_handshake_is_taking_longer_t;
+static PyObject *__pyx_kp_u_SSL_shutdown_timed_out;
+static PyObject *__pyx_n_s_STDOUT;
+static PyObject *__pyx_n_s_S_ISSOCK;
+static PyObject *__pyx_n_s_Server;
+static PyObject *__pyx_n_s_Server___aenter;
+static PyObject *__pyx_n_s_Server___aexit;
+static PyObject *__pyx_n_s_Server_serve_forever;
+static PyObject *__pyx_kp_u_Server_side_SSL_needs_a_valid_SS;
+static PyObject *__pyx_n_s_Server_start_serving;
+static PyObject *__pyx_n_s_Server_wait_closed;
+static PyObject *__pyx_kp_u_Shutdown_errors;
+static PyObject *__pyx_n_s_SockAddrHolder;
+static PyObject *__pyx_kp_u_Sock_ops_successful_on_1st_try;
+static PyObject *__pyx_n_s_SocketKind;
+static PyObject *__pyx_kp_u_Socket_try_writes;
+static PyObject *__pyx_n_s_StackSummary;
+static PyObject *__pyx_n_s_StreamWriteContext;
+static PyObject *__pyx_kp_u_StreamWriteContext_close_py_buf;
+static PyObject *__pyx_kp_u_StreamWriteContext_close_uv_buf;
+static PyObject *__pyx_kp_u_Streams_debug_info;
+static PyObject *__pyx_n_s_SubprocessError;
+static PyObject *__pyx_n_s_SyncSocketReaderFuture;
+static PyObject *__pyx_n_s_SyncSocketReaderFuture___init;
+static PyObject *__pyx_n_s_SyncSocketReaderFuture___remove;
+static PyObject *__pyx_n_s_SyncSocketReaderFuture__loop;
+static PyObject *__pyx_n_s_SyncSocketReaderFuture__remove;
+static PyObject *__pyx_n_s_SyncSocketReaderFuture__sock;
+static PyObject *__pyx_n_s_SyncSocketReaderFuture_cancel;
+static PyObject *__pyx_n_s_SyncSocketWriterFuture;
+static PyObject *__pyx_n_s_SyncSocketWriterFuture___init;
+static PyObject *__pyx_n_s_SyncSocketWriterFuture___remove;
+static PyObject *__pyx_n_s_SyncSocketWriterFuture__loop;
+static PyObject *__pyx_n_s_SyncSocketWriterFuture__remove;
+static PyObject *__pyx_n_s_SyncSocketWriterFuture__sock;
+static PyObject *__pyx_n_s_SyncSocketWriterFuture_cancel;
+static PyObject *__pyx_n_s_SystemExit;
+static PyObject *__pyx_n_s_TCPConnectRequest;
+static PyObject *__pyx_n_s_TCPServer;
+static PyObject *__pyx_n_s_TCPTransport;
+static PyObject *__pyx_n_s_Task;
+static PyObject *__pyx_kp_u_The_reuse_address_parameter_has;
+static PyObject *__pyx_n_s_Thread;
+static PyObject *__pyx_n_s_ThreadPoolExecutor;
+static PyObject *__pyx_n_s_TimeoutError;
+static PyObject *__pyx_n_s_TimerHandle;
+static PyObject *__pyx_kp_u_Timer_handles_8;
+static PyObject *__pyx_n_s_Transport;
+static PyObject *__pyx_n_s_TypeError;
+static PyObject *__pyx_n_s_UDPSendContext;
+static PyObject *__pyx_n_s_UDPTransport;
+static PyObject *__pyx_kp_u_UDPTransport_family_is_undefined;
+static PyObject *__pyx_kp_u_UDPTransport_family_is_undefined_2;
+static PyObject *__pyx_n_s_UVAsync;
+static PyObject *__pyx_n_s_UVBaseTransport;
+static PyObject *__pyx_n_s_UVCheck;
+static PyObject *__pyx_n_s_UVHandle;
+static PyObject *__pyx_kp_u_UVHandles_python_libuv_total;
+static PyObject *__pyx_n_s_UVIdle;
+static PyObject *__pyx_n_s_UVPoll;
+static PyObject *__pyx_n_s_UVProcess;
+static PyObject *__pyx_n_s_UVProcessTransport;
+static PyObject *__pyx_kp_u_UVProcessTransport__call_connect;
+static PyObject *__pyx_kp_u_UVProcess__close_after_spawn_cal;
+static PyObject *__pyx_n_s_UVRequest;
+static PyObject *__pyx_n_s_UVSocketHandle;
+static PyObject *__pyx_n_s_UVStream;
+static PyObject *__pyx_n_s_UVStreamServer;
+static PyObject *__pyx_kp_u_UVStream__try_write_called_with;
+static PyObject *__pyx_kp_u_UVStream_shutdown_callback_calle;
+static PyObject *__pyx_kp_u_UVStream_write_callback_called_w;
+static PyObject *__pyx_n_s_UVTimer;
+static PyObject *__pyx_kp_u_UVTransport__call_connection_los;
+static PyObject *__pyx_kp_u_UVTransport__call_connection_mad;
+static PyObject *__pyx_kp_u_Unable_to_check_or_remove_stale;
+static PyObject *__pyx_kp_u_Unhandled_error_in_exception_han;
+static PyObject *__pyx_kp_u_Unhandled_exception_in_event_loo;
+static PyObject *__pyx_n_s_UnicodeEncodeError;
+static PyObject *__pyx_n_s_UnixServer;
+static PyObject *__pyx_n_s_UnixTransport;
+static PyObject *__pyx_n_s_ValueError;
+static PyObject *__pyx_n_s_WeakSet;
+static PyObject *__pyx_n_s_WeakValueDictionary;
+static PyObject *__pyx_n_s_WriteSubprocessPipeProto;
+static PyObject *__pyx_n_s_WriteSubprocessPipeProto___init;
+static PyObject *__pyx_n_s_WriteSubprocessPipeProto___repr;
+static PyObject *__pyx_n_s_WriteSubprocessPipeProto_connect;
+static PyObject *__pyx_n_s_WriteSubprocessPipeProto_connect_2;
+static PyObject *__pyx_n_s_WriteSubprocessPipeProto_pause_w;
+static PyObject *__pyx_n_s_WriteSubprocessPipeProto_resume;
+static PyObject *__pyx_n_s_WriteUnixTransport;
+static PyObject *__pyx_kp_u_Write_callbacks_failed;
+static PyObject *__pyx_kp_u_Write_contexts_8;
+static PyObject *__pyx_kp_u_Write_errors;
+static PyObject *__pyx_kp_u_Write_events;
+static PyObject *__pyx_kp_u_Write_failed_callbacks;
+static PyObject *__pyx_kp_u_Write_without_poll;
+static PyObject *__pyx_kp_u_XXX_an_allocated_buffer_in_trans;
+static PyObject *__pyx_kp_u_You_must_set_server_hostname_whe;
+static PyObject *__pyx_kp_u__103;
+static PyObject *__pyx_kp_u__104;
+static PyObject *__pyx_kp_u__105;
+static PyObject *__pyx_kp_u__133;
+static PyObject *__pyx_kp_u__134;
+static PyObject *__pyx_kp_b__178;
+static PyObject *__pyx_kp_b__187;
+static PyObject *__pyx_kp_u__32;
+static PyObject *__pyx_kp_u__56;
+static PyObject *__pyx_kp_u__63;
+static PyObject *__pyx_kp_u__68;
+static PyObject *__pyx_kp_u__69;
+static PyObject *__pyx_n_s__8;
+static PyObject *__pyx_kp_b__8;
+static PyObject *__pyx_kp_u__8;
+static PyObject *__pyx_kp_u__91;
+static PyObject *__pyx_n_s_abc;
+static PyObject *__pyx_kp_u_abort_init__closed_is_set;
+static PyObject *__pyx_kp_u_abort_init__inited_is_set;
+static PyObject *__pyx_n_s_accept;
+static PyObject *__pyx_kp_u_accept_method;
+static PyObject *__pyx_n_s_aclose;
+static PyObject *__pyx_kp_u_active_TimerHandle_is_deallacati;
+static PyObject *__pyx_n_s_add;
+static PyObject *__pyx_n_s_add_done_callback;
+static PyObject *__pyx_kp_u_add_signal_handler_can_only_be_c;
+static PyObject *__pyx_n_s_addr;
+static PyObject *__pyx_n_s_address;
+static PyObject *__pyx_n_s_aenter;
+static PyObject *__pyx_n_s_aexit;
+static PyObject *__pyx_kp_u_alive_closed;
+static PyObject *__pyx_kp_u_all_args_must_be_str_or_bytes;
+static PyObject *__pyx_kp_u_all_environment_values_must_be_b;
+static PyObject *__pyx_kp_u_all_environment_vars_must_be_byt;
+static PyObject *__pyx_n_s_allow_broadcast;
+static PyObject *__pyx_kp_u_an_error_occurred_during_closing;
+static PyObject *__pyx_n_s_app_protocol;
+static PyObject *__pyx_n_s_append;
+static PyObject *__pyx_n_s_args;
+static PyObject *__pyx_n_u_ascii;
+static PyObject *__pyx_n_u_asyncgen;
+static PyObject *__pyx_n_s_asyncgen_finalizer_hook;
+static PyObject *__pyx_n_s_asyncgen_firstiter_hook;
+static PyObject *__pyx_kp_u_asynchronous_generator_r_was_sch;
+static PyObject *__pyx_n_s_asyncio;
+static PyObject *__pyx_n_s_asyncio_base_events;
+static PyObject *__pyx_n_s_asyncio_coroutines;
+static PyObject *__pyx_n_s_asyncio_futures;
+static PyObject *__pyx_kp_u_asyncio_is_trying_to_install_it;
+static PyObject *__pyx_n_s_asyncio_log;
+static PyObject *__pyx_n_s_asyncio_sslproto;
+static PyObject *__pyx_n_s_asyncio_tasks;
+static PyObject *__pyx_n_s_asyncio_transports;
+static PyObject *__pyx_n_s_await;
+static PyObject *__pyx_n_u_b;
+static PyObject *__pyx_n_s_backlog;
+static PyObject *__pyx_kp_b_bin_sh;
+static PyObject *__pyx_n_s_bind;
+static PyObject *__pyx_kp_u_bind_method;
+static PyObject *__pyx_n_s_buf;
+static PyObject *__pyx_kp_u_buffer_size_is_not_0_after_a_su;
+static PyObject *__pyx_n_s_buffer_updated;
+static PyObject *__pyx_n_s_bufsize;
+static PyObject *__pyx_kp_u_bufsize_must_be_0;
+static PyObject *__pyx_n_s_builtins;
+static PyObject *__pyx_kp_b_c;
+static PyObject *__pyx_n_s_call_connection_made;
+static PyObject *__pyx_n_s_call_exception_handler;
+static PyObject *__pyx_n_s_call_later;
+static PyObject *__pyx_n_s_call_soon;
+static PyObject *__pyx_n_s_call_soon_threadsafe;
+static PyObject *__pyx_n_s_callback;
+static PyObject *__pyx_kp_u_called_after_destroying_the_UVH;
+static PyObject *__pyx_kp_u_called_with_handle_data_NULL;
+static PyObject *__pyx_n_s_cancel;
+static PyObject *__pyx_kp_u_cancel_request_data_is_NULL;
+static PyObject *__pyx_kp_u_cancel_request_data_is_not_UVRe;
+static PyObject *__pyx_kp_u_cancel_request_is_NULL;
+static PyObject *__pyx_n_s_cancelled;
+static PyObject *__pyx_n_u_cancelled;
+static PyObject *__pyx_kp_u_cannot_add_a_signal_handler_for;
+static PyObject *__pyx_kp_u_cannot_apply_subprocess_STDOUT;
+static PyObject *__pyx_kp_u_cannot_cleanup_signal_handlers_c;
+static PyObject *__pyx_kp_u_cannot_convert_sockaddr_into_Pyt;
+static PyObject *__pyx_kp_u_cannot_open_a_UDP_handle_invalid;
+static PyObject *__pyx_kp_u_cannot_pause_signals_handling_no;
+static PyObject *__pyx_kp_u_cannot_run_Handle_callback_is_no;
+static PyObject *__pyx_kp_u_cannot_run_TimerHandle_callback;
+static PyObject *__pyx_kp_u_cannot_shutdown_signals_handling;
+static PyObject *__pyx_kp_u_cannot_spawn_a_process_args_are;
+static PyObject *__pyx_kp_u_cannot_switch_state_from_to;
+static PyObject *__pyx_n_s_cast;
+static PyObject *__pyx_n_s_cause;
+static PyObject *__pyx_n_s_cfunc_to_py;
+static PyObject *__pyx_n_s_chain;
+static PyObject *__pyx_n_s_check_default_executor;
+static PyObject *__pyx_n_s_check_hostname;
+static PyObject *__pyx_n_s_cipher;
+static PyObject *__pyx_n_s_class;
+static PyObject *__pyx_n_s_clear;
+static PyObject *__pyx_n_s_cline_in_traceback;
+static PyObject *__pyx_n_s_close;
+static PyObject *__pyx_kp_u_close__handle_data_is_NULL;
+static PyObject *__pyx_kp_u_close__handle_data_is_not_UVHa;
+static PyObject *__pyx_n_s_close_fds;
+static PyObject *__pyx_kp_u_close_method;
+static PyObject *__pyx_kp_u_close_uv_is_closing_is_true;
+static PyObject *__pyx_kp_u_closed_Transport_handle_and_unse;
+static PyObject *__pyx_kp_u_closed_reading_x;
+static PyObject *__pyx_kp_u_closed_x;
+static PyObject *__pyx_n_s_cmd;
+static PyObject *__pyx_n_s_collections;
+static PyObject *__pyx_n_s_collections_abc;
+static PyObject *__pyx_n_s_compression;
+static PyObject *__pyx_n_s_concurrent;
+static PyObject *__pyx_kp_u_concurrent_allocations;
+static PyObject *__pyx_n_s_concurrent_futures;
+static PyObject *__pyx_n_s_connect;
+static PyObject *__pyx_n_s_connect_accepted_socket;
+static PyObject *__pyx_kp_u_connect_ex_method;
+static PyObject *__pyx_kp_u_connect_failed;
+static PyObject *__pyx_kp_u_connect_method;
+static PyObject *__pyx_n_s_connect_read_pipe;
+static PyObject *__pyx_n_s_connect_write_pipe;
+static PyObject *__pyx_n_s_connection_lost;
+static PyObject *__pyx_n_s_connection_made;
+static PyObject *__pyx_n_s_context;
+static PyObject *__pyx_n_u_context;
+static PyObject *__pyx_kp_u_context_manager_protocol;
+static PyObject *__pyx_n_s_copy;
+static PyObject *__pyx_n_s_coro;
+static PyObject *__pyx_n_s_coroutines;
+static PyObject *__pyx_kp_u_coroutines_cannot_be_used_with_a;
+static PyObject *__pyx_kp_u_coroutines_cannot_be_used_with_r;
+static PyObject *__pyx_kp_u_could_not_bind_to_local_addr;
+static PyObject *__pyx_kp_u_could_not_bind_to_remote_addr;
+static PyObject *__pyx_kp_u_could_not_close_attached_file_ob;
+static PyObject *__pyx_n_s_create_connection;
+static PyObject *__pyx_n_s_create_connection_locals_genexpr;
+static PyObject *__pyx_n_s_create_datagram_endpoint;
+static PyObject *__pyx_n_s_create_datagram_endpoint_locals;
+static PyObject *__pyx_n_s_create_default_context;
+static PyObject *__pyx_n_s_create_future;
+static PyObject *__pyx_n_s_create_server;
+static PyObject *__pyx_kp_u_create_server_failed_to_create_s;
+static PyObject *__pyx_n_s_create_task;
+static PyObject *__pyx_n_s_create_unix_connection;
+static PyObject *__pyx_n_s_create_unix_server;
+static PyObject *__pyx_kp_u_created_at;
+static PyObject *__pyx_n_s_creationflags;
+static PyObject *__pyx_kp_u_creationflags_is_not_supported;
+static PyObject *__pyx_n_s_cwd;
+static PyObject *__pyx_kp_u_cwd_must_be_a_str_or_bytes_objec;
+static PyObject *__pyx_n_u_cygwin;
+static PyObject *__pyx_n_s_data;
+static PyObject *__pyx_kp_u_data_expecting_a_bytes_like_inst;
+static PyObject *__pyx_n_s_data_received;
+static PyObject *__pyx_n_s_datagram_received;
+static PyObject *__pyx_kp_u_dealloc____handle_is_NULL__cl;
+static PyObject *__pyx_kp_u_deallocating_a_running_event_loo;
+static PyObject *__pyx_kp_u_deallocating_an_open_event_loop;
+static PyObject *__pyx_n_s_debug;
+static PyObject *__pyx_n_u_debug_wrapper;
+static PyObject *__pyx_n_s_decode;
+static PyObject *__pyx_n_s_decref_socketios;
+static PyObject *__pyx_n_s_default;
+static PyObject *__pyx_n_s_default_exception_handler;
+static PyObject *__pyx_n_s_default_int_handler;
+static PyObject *__pyx_n_s_delay;
+static PyObject *__pyx_n_s_deque;
+static PyObject *__pyx_n_s_detach;
+static PyObject *__pyx_kp_u_detach_method;
+static PyObject *__pyx_n_s_devnull;
+static PyObject *__pyx_n_s_dict;
+static PyObject *__pyx_n_s_disable;
+static PyObject *__pyx_n_s_discard;
+static PyObject *__pyx_n_s_disconnected;
+static PyObject *__pyx_n_s_do_handshake;
+static PyObject *__pyx_n_s_do_shutdown;
+static PyObject *__pyx_n_s_doc;
+static PyObject *__pyx_kp_u_does_not_have_a_reader_in_the;
+static PyObject *__pyx_kp_u_does_not_have_a_reader_in_the_2;
+static PyObject *__pyx_kp_u_does_not_have_a_writer_in_the;
+static PyObject *__pyx_kp_u_does_not_have_a_writer_in_the_2;
+static PyObject *__pyx_n_s_done;
+static PyObject *__pyx_n_s_done_cb;
+static PyObject *__pyx_n_s_dup;
+static PyObject *__pyx_n_s_enabled;
+static PyObject *__pyx_n_s_encode;
+static PyObject *__pyx_n_s_ensure_future;
+static PyObject *__pyx_n_s_enter;
+static PyObject *__pyx_n_s_env;
+static PyObject *__pyx_n_s_environ;
+static PyObject *__pyx_n_s_eof_received;
+static PyObject *__pyx_n_s_errno;
+static PyObject *__pyx_n_s_error;
+static PyObject *__pyx_n_s_error_received;
+static PyObject *__pyx_kp_u_error_status_in_uv_stream_t_list;
+static PyObject *__pyx_kp_u_error_status_in_uv_stream_t_read;
+static PyObject *__pyx_kp_u_error_status_in_uv_stream_t_shut;
+static PyObject *__pyx_kp_u_error_status_in_uv_stream_t_writ;
+static PyObject *__pyx_kp_u_error_while_attempting_to_bind_o;
+static PyObject *__pyx_n_s_ex;
+static PyObject *__pyx_n_s_exc;
+static PyObject *__pyx_n_s_exc_info;
+static PyObject *__pyx_n_s_exception;
+static PyObject *__pyx_n_u_exception;
+static PyObject *__pyx_kp_u_exception_in_Task___repr;
+static PyObject *__pyx_n_s_executable;
+static PyObject *__pyx_n_s_executor;
+static PyObject *__pyx_n_s_exit;
+static PyObject *__pyx_kp_u_expected_AF_INET_AF_INET6_or_AF;
+static PyObject *__pyx_kp_u_expected_asyncio_Future;
+static PyObject *__pyx_n_s_extract;
+static PyObject *__pyx_n_s_family;
+static PyObject *__pyx_kp_u_fatal_Could_not_advance__StreamW;
+static PyObject *__pyx_kp_u_fatal_sent_0_in_advance_uv_buf;
+static PyObject *__pyx_n_s_fd;
+static PyObject *__pyx_kp_u_fd_2;
+static PyObject *__pyx_n_s_fileno;
+static PyObject *__pyx_n_s_fileobj;
+static PyObject *__pyx_n_s_finalizer;
+static PyObject *__pyx_n_s_firstiter;
+static PyObject *__pyx_n_s_flags;
+static PyObject *__pyx_n_s_flush;
+static PyObject *__pyx_n_s_force_close;
+static PyObject *__pyx_n_s_format;
+static PyObject *__pyx_n_s_format_list;
+static PyObject *__pyx_n_s_frame;
+static PyObject *__pyx_n_s_fspath;
+static PyObject *__pyx_n_s_func;
+static PyObject *__pyx_n_s_functools;
+static PyObject *__pyx_n_s_fut;
+static PyObject *__pyx_n_s_futures;
+static PyObject *__pyx_n_s_gaierror;
+static PyObject *__pyx_n_s_gather;
+static PyObject *__pyx_n_s_gc;
+static PyObject *__pyx_n_s_genexpr;
+static PyObject *__pyx_n_s_get;
+static PyObject *__pyx_n_s_get_app_transport;
+static PyObject *__pyx_n_s_get_asyncgen_hooks;
+static PyObject *__pyx_n_s_get_buffer;
+static PyObject *__pyx_n_u_get_buffer;
+static PyObject *__pyx_n_s_get_coroutine_origin_tracking_de;
+static PyObject *__pyx_n_u_get_coroutine_wrapper;
+static PyObject *__pyx_n_s_get_debug;
+static PyObject *__pyx_n_s_get_event_loop;
+static PyObject *__pyx_n_s_get_extra_info;
+static PyObject *__pyx_n_s_get_inheritable;
+static PyObject *__pyx_n_u_get_running_loop;
+static PyObject *__pyx_n_s_getaddrinfo;
+static PyObject *__pyx_kp_u_getaddrinfo_returned_empty_list;
+static PyObject *__pyx_kp_u_getaddrinfo_returned_empty_list_2;
+static PyObject *__pyx_n_s_getfilesystemencoding;
+static PyObject *__pyx_n_s_getframe;
+static PyObject *__pyx_n_s_getnameinfo;
+static PyObject *__pyx_kp_u_getnameinfo_argument_1_must_be_a;
+static PyObject *__pyx_kp_u_getnameinfo_flowinfo_must_be_0_1;
+static PyObject *__pyx_n_s_getpeercert;
+static PyObject *__pyx_n_s_getpeername;
+static PyObject *__pyx_n_s_getservbyname;
+static PyObject *__pyx_kp_u_getsockaddrarg_scope_id_must_be;
+static PyObject *__pyx_n_s_getsockname;
+static PyObject *__pyx_n_s_getsockopt;
+static PyObject *__pyx_n_s_getstate;
+static PyObject *__pyx_n_s_gettimeout;
+static PyObject *__pyx_n_u_handle;
+static PyObject *__pyx_kp_u_handle_data_is_NULL_in___close_a;
+static PyObject *__pyx_kp_u_handle_loop_data_is_NULL_in___en;
+static PyObject *__pyx_kp_u_handle_loop_is_NULL_in___ensure;
+static PyObject *__pyx_kp_u_has_handle_0_in___uv_close_handl;
+static PyObject *__pyx_n_s_high;
+static PyObject *__pyx_kp_u_high_2;
+static PyObject *__pyx_n_s_host;
+static PyObject *__pyx_kp_u_host_and_port_was_not_specified;
+static PyObject *__pyx_kp_u_host_must_be_a_str_or_bytes;
+static PyObject *__pyx_kp_u_host_must_be_a_string_or_bytes_o;
+static PyObject *__pyx_kp_u_host_port_and_sock_can_not_be_sp;
+static PyObject *__pyx_n_s_id;
+static PyObject *__pyx_n_s_ident;
+static PyObject *__pyx_n_u_idna;
+static PyObject *__pyx_n_s_ignore_environment;
+static PyObject *__pyx_n_s_import;
+static PyObject *__pyx_n_u_inf;
+static PyObject *__pyx_n_s_info;
+static PyObject *__pyx_n_s_init;
+static PyObject *__pyx_n_s_inspect;
+static PyObject *__pyx_kp_u_integer_argument_expected_got;
+static PyObject *__pyx_kp_u_invalid_Handle_cb_type;
+static PyObject *__pyx_kp_u_invalid__init_protocol_call;
+static PyObject *__pyx_kp_u_invalid_data_in_writebuf_an_inst;
+static PyObject *__pyx_kp_u_invalid_socket_family_expected_A;
+static PyObject *__pyx_kp_u_invalid_waiter_object;
+static PyObject *__pyx_n_s_io_refs;
+static PyObject *__pyx_kp_u_is_alive_but__handle_data_is_no;
+static PyObject *__pyx_kp_u_is_alive_but__handle_is_NULL;
+static PyObject *__pyx_kp_u_is_alive_but__handle_loop_is_no;
+static PyObject *__pyx_kp_u_is_alive_but__loop_is_None;
+static PyObject *__pyx_kp_u_is_already_being_awaited_on_ser;
+static PyObject *__pyx_n_s_is_closed;
+static PyObject *__pyx_kp_u_is_closed_2;
+static PyObject *__pyx_kp_u_is_longer_than_107_characters;
+static PyObject *__pyx_kp_u_is_not_supported_by_start_tls;
+static PyObject *__pyx_kp_u_is_not_supposed_to_be_instantia;
+static PyObject *__pyx_kp_u_is_open_in___dealloc___with_loo;
+static PyObject *__pyx_n_s_is_running;
+static PyObject *__pyx_n_s_iscoroutine;
+static PyObject *__pyx_n_s_iscoroutinefunction;
+static PyObject *__pyx_n_u_isfuture;
+static PyObject *__pyx_n_s_isgenerator;
+static PyObject *__pyx_n_s_items;
+static PyObject *__pyx_n_s_itertools;
+static PyObject *__pyx_n_s_join;
+static PyObject *__pyx_kp_u_laddr_s;
+static PyObject *__pyx_n_s_last;
+static PyObject *__pyx_n_s_limit;
+static PyObject *__pyx_kp_u_listen_method;
+static PyObject *__pyx_n_s_local_addr;
+static PyObject *__pyx_kp_u_local_addr_must_be_a_tuple_of_ho;
+static PyObject *__pyx_kp_u_local_addr_must_be_a_tuple_of_ho_2;
+static PyObject *__pyx_n_s_log;
+static PyObject *__pyx_n_s_log_destroy_pending;
+static PyObject *__pyx_n_s_logger;
+static PyObject *__pyx_n_s_lookup_lines;
+static PyObject *__pyx_n_s_loop;
+static PyObject *__pyx_kp_u_loop__exec_queued_writes;
+static PyObject *__pyx_kp_u_loop__on_idle;
+static PyObject *__pyx_kp_u_loop__queued_streams_are_not_emp;
+static PyObject *__pyx_n_s_low;
+static PyObject *__pyx_n_s_lower;
+static PyObject *__pyx_n_s_main;
+static PyObject *__pyx_n_s_main_thread;
+static PyObject *__pyx_kp_u_makefile_method;
+static PyObject *__pyx_n_s_maxsize;
+static PyObject *__pyx_kp_u_maxsize_is_expected_to_be_greate;
+static PyObject *__pyx_n_s_memoryview;
+static PyObject *__pyx_n_u_message;
+static PyObject *__pyx_n_s_metaclass;
+static PyObject *__pyx_n_s_module;
+static PyObject *__pyx_n_s_monotonic;
+static PyObject *__pyx_n_s_move_to_end;
+static PyObject *__pyx_n_s_msg;
+static PyObject *__pyx_kp_u_must_be_0;
+static PyObject *__pyx_kp_u_must_be_low;
+static PyObject *__pyx_n_s_n;
+static PyObject *__pyx_n_s_name;
+static PyObject *__pyx_n_u_name;
+static PyObject *__pyx_n_s_name_2;
+static PyObject *__pyx_n_s_new;
+static PyObject *__pyx_kp_u_new_callbacks_were_queued_during;
+static PyObject *__pyx_kp_u_new_poll_handles_were_queued_dur;
+static PyObject *__pyx_kp_u_new_timers_were_queued_during_lo;
+static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+static PyObject *__pyx_kp_u_no_path_and_sock_were_specified;
+static PyObject *__pyx_kp_u_no_python_buffer_is_allocated_in;
+static PyObject *__pyx_n_s_noop;
+static PyObject *__pyx_n_s_noop_2;
+static PyObject *__pyx_n_s_object;
+static PyObject *__pyx_kp_u_object_created_at_most_recent_ca;
+static PyObject *__pyx_kp_u_objs_handles;
+static PyObject *__pyx_n_s_on_ssl_connected;
+static PyObject *__pyx_n_s_open;
+static PyObject *__pyx_kp_u_open__StreamWriteContext_is_bein;
+static PyObject *__pyx_kp_u_open__UDPSendContext_is_being_de;
+static PyObject *__pyx_n_s_os;
+static PyObject *__pyx_n_s_partial;
+static PyObject *__pyx_n_s_pass_fds;
+static PyObject *__pyx_n_s_path;
+static PyObject *__pyx_kp_u_path_and_sock_can_not_be_specifi;
+static PyObject *__pyx_kp_u_path_was_not_specified_and_no_so;
+static PyObject *__pyx_n_s_pause_reading;
+static PyObject *__pyx_n_s_pause_writing;
+static PyObject *__pyx_n_s_peercert;
+static PyObject *__pyx_n_u_peername;
+static PyObject *__pyx_n_s_pending;
+static PyObject *__pyx_n_s_pickle;
+static PyObject *__pyx_n_s_pipe;
+static PyObject *__pyx_n_u_pipe;
+static PyObject *__pyx_kp_u_pipe_2;
+static PyObject *__pyx_n_s_pipe_connection_lost;
+static PyObject *__pyx_n_s_pipe_data_received;
+static PyObject *__pyx_n_s_platform;
+static PyObject *__pyx_n_s_pop;
+static PyObject *__pyx_n_s_popitem;
+static PyObject *__pyx_n_s_popleft;
+static PyObject *__pyx_n_s_port;
+static PyObject *__pyx_kp_u_port_must_be_a_str_bytes_or_int;
+static PyObject *__pyx_n_u_posix;
+static PyObject *__pyx_n_s_preexec_fn;
+static PyObject *__pyx_n_s_prepare;
+static PyObject *__pyx_n_s_print;
+static PyObject *__pyx_n_u_print_debug_info;
+static PyObject *__pyx_n_s_proc;
+static PyObject *__pyx_n_s_process_exited;
+static PyObject *__pyx_n_s_program;
+static PyObject *__pyx_n_s_proto;
+static PyObject *__pyx_n_s_proto_factory;
+static PyObject *__pyx_n_s_protocol;
+static PyObject *__pyx_n_u_protocol;
+static PyObject *__pyx_n_s_protocol_factory;
+static PyObject *__pyx_kp_u_protocol_is_not_set_cannot_call;
+static PyObject *__pyx_kp_u_protocol_is_required;
+static PyObject *__pyx_kp_u_protocol_pause_writing_failed;
+static PyObject *__pyx_kp_u_protocol_resume_writing_failed;
+static PyObject *__pyx_n_s_pyx_PickleError;
+static PyObject *__pyx_n_s_pyx_checksum;
+static PyObject *__pyx_n_s_pyx_result;
+static PyObject *__pyx_n_s_pyx_state;
+static PyObject *__pyx_n_s_pyx_type;
+static PyObject *__pyx_n_s_pyx_unpickle_LruCache;
+static PyObject *__pyx_n_s_pyx_unpickle_PseudoSocket;
+static PyObject *__pyx_n_s_pyx_vtable;
+static PyObject *__pyx_n_s_qualname;
+static PyObject *__pyx_n_u_qualname;
+static PyObject *__pyx_kp_u_r_SSL_handshake_took_1f_ms;
+static PyObject *__pyx_kp_u_r_fileno_returned_non_integer;
+static PyObject *__pyx_kp_u_r_received_EOF;
+static PyObject *__pyx_kp_u_r_s;
+static PyObject *__pyx_kp_u_r_starts_SSL_handshake;
+static PyObject *__pyx_kp_u_raddr_s;
+static PyObject *__pyx_n_s_range;
+static PyObject *__pyx_n_s_read;
+static PyObject *__pyx_n_s_recv;
+static PyObject *__pyx_n_s_recv_into;
+static PyObject *__pyx_kp_u_recv_into_method;
+static PyObject *__pyx_kp_u_recv_method;
+static PyObject *__pyx_kp_u_recvfrom_into_method;
+static PyObject *__pyx_kp_u_recvfrom_method;
+static PyObject *__pyx_kp_u_recvmsg_into_method;
+static PyObject *__pyx_kp_u_recvmsg_method;
+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_remote_addr;
+static PyObject *__pyx_kp_u_remote_addr_must_be_a_tuple_of_h;
+static PyObject *__pyx_n_s_remove;
+static PyObject *__pyx_n_s_remove_done_callback;
+static PyObject *__pyx_n_s_remove_reader;
+static PyObject *__pyx_n_s_remove_reader_2;
+static PyObject *__pyx_n_s_remove_signal_handler;
+static PyObject *__pyx_kp_u_remove_signal_handler_can_only_b;
+static PyObject *__pyx_n_s_remove_writer;
+static PyObject *__pyx_n_s_remove_writer_2;
+static PyObject *__pyx_n_s_repr;
+static PyObject *__pyx_n_s_restore_signals;
+static PyObject *__pyx_n_s_result;
+static PyObject *__pyx_n_s_resume_reading;
+static PyObject *__pyx_n_s_resume_writing;
+static PyObject *__pyx_n_s_return_exceptions;
+static PyObject *__pyx_kp_u_returning_true_from_eof_received;
+static PyObject *__pyx_n_s_reuse_address;
+static PyObject *__pyx_n_s_reuse_port;
+static PyObject *__pyx_kp_u_reuse_port_not_supported_by_sock;
+static PyObject *__pyx_n_s_reverse;
+static PyObject *__pyx_n_s_round;
+static PyObject *__pyx_n_s_rstrip;
+static PyObject *__pyx_n_s_run;
+static PyObject *__pyx_n_s_run_forever;
+static PyObject *__pyx_n_s_run_until_complete_locals_done_c;
+static PyObject *__pyx_kp_u_running_closed_debug;
+static PyObject *__pyx_kp_u_seconds_aborting_the_connection;
+static PyObject *__pyx_n_s_self;
+static PyObject *__pyx_n_u_self;
+static PyObject *__pyx_n_s_self_2;
+static PyObject *__pyx_kp_u_self_pipe_exists_before_loop_run;
+static PyObject *__pyx_kp_u_self_pipe_was_not_cleaned_up_aft;
+static PyObject *__pyx_kp_s_self_py_buf_self_req_cannot_be_c;
+static PyObject *__pyx_kp_s_self_py_bufs_self_py_bufs_sml_se;
+static PyObject *__pyx_n_s_send;
+static PyObject *__pyx_kp_u_send_method;
+static PyObject *__pyx_kp_u_sendall_method;
+static PyObject *__pyx_kp_u_sendfile_method;
+static PyObject *__pyx_kp_u_sendmsg_afalg_method;
+static PyObject *__pyx_kp_u_sendmsg_method;
+static PyObject *__pyx_kp_u_sendto_method;
+static PyObject *__pyx_n_s_serve_forever;
+static PyObject *__pyx_kp_u_server;
+static PyObject *__pyx_n_s_server_hostname;
+static PyObject *__pyx_kp_u_server_hostname_is_only_meaningf;
+static PyObject *__pyx_n_s_server_side;
+static PyObject *__pyx_kp_u_service_proto_not_found;
+static PyObject *__pyx_n_s_set_asyncgen_hooks;
+static PyObject *__pyx_n_s_set_coroutine_origin_tracking_de;
+static PyObject *__pyx_n_u_set_coroutine_wrapper;
+static PyObject *__pyx_n_s_set_debug;
+static PyObject *__pyx_n_s_set_exception;
+static PyObject *__pyx_n_s_set_inheritable;
+static PyObject *__pyx_n_s_set_name;
+static PyObject *__pyx_n_s_set_protocol;
+static PyObject *__pyx_n_s_set_result;
+static PyObject *__pyx_n_u_set_running_loop;
+static PyObject *__pyx_n_s_set_wakeup_fd;
+static PyObject *__pyx_kp_u_set_wakeup_fd_1_failed_s;
+static PyObject *__pyx_n_s_setblocking;
+static PyObject *__pyx_kp_u_setblocking_transport_sockets_ca;
+static PyObject *__pyx_n_s_setsockopt;
+static PyObject *__pyx_n_s_setstate;
+static PyObject *__pyx_n_s_setstate_cython;
+static PyObject *__pyx_n_s_settimeout;
+static PyObject *__pyx_kp_u_settimeout_only_0_timeout_is_all;
+static PyObject *__pyx_n_s_share;
+static PyObject *__pyx_n_s_shell;
+static PyObject *__pyx_kp_u_shell_must_be_False;
+static PyObject *__pyx_kp_u_shell_must_be_True;
+static PyObject *__pyx_n_s_shutdown;
+static PyObject *__pyx_n_s_shutdown_asyncgens;
+static PyObject *__pyx_n_s_shutdown_default_executor;
+static PyObject *__pyx_kp_u_shutdown_method;
+static PyObject *__pyx_n_s_sig;
+static PyObject *__pyx_kp_u_sig_cannot_be_caught;
+static PyObject *__pyx_kp_u_sig_must_be_an_int_not_r;
+static PyObject *__pyx_kp_u_sig_out_of_range_1;
+static PyObject *__pyx_n_s_sighandler;
+static PyObject *__pyx_n_s_siginterrupt;
+static PyObject *__pyx_n_s_signal;
+static PyObject *__pyx_kp_u_signals_handling_has_been_alread;
+static PyObject *__pyx_kp_u_signals_handling_has_not_been_se;
+static PyObject *__pyx_n_s_signum;
+static PyObject *__pyx_n_s_sleep;
+static PyObject *__pyx_n_s_sock;
+static PyObject *__pyx_n_s_sock_accept;
+static PyObject *__pyx_n_s_sock_connect;
+static PyObject *__pyx_kp_u_sock_connect_cb_is_called_on_a;
+static PyObject *__pyx_n_s_sock_recv;
+static PyObject *__pyx_n_s_sock_recv_into;
+static PyObject *__pyx_kp_u_sock_recv_into_is_called_on_a_c;
+static PyObject *__pyx_kp_u_sock_recv_is_called_on_a_cancel;
+static PyObject *__pyx_n_s_sock_sendall;
+static PyObject *__pyx_kp_u_sock_sendall_is_called_on_a_can;
+static PyObject *__pyx_n_s_sockaddr;
+static PyObject *__pyx_kp_u_sockaddr_must_be_a_tuple_of_2_3;
+static PyObject *__pyx_kp_u_sockaddr_resolved_to_multiple_ad;
+static PyObject *__pyx_kp_u_socket;
+static PyObject *__pyx_n_s_socket_2;
+static PyObject *__pyx_n_u_socket_2;
+static PyObject *__pyx_kp_u_socket_family_mismatch_or_a_DNS;
+static PyObject *__pyx_kp_u_socket_modifier_keyword_argument;
+static PyObject *__pyx_kp_u_socket_send_raised_exception;
+static PyObject *__pyx_n_s_socketpair;
+static PyObject *__pyx_kp_u_sockets;
+static PyObject *__pyx_n_s_sockets_2;
+static PyObject *__pyx_n_u_sockname;
+static PyObject *__pyx_n_s_source;
+static PyObject *__pyx_n_u_source_traceback;
+static PyObject *__pyx_n_s_split;
+static PyObject *__pyx_n_s_ssl;
+static PyObject *__pyx_kp_u_ssl_argument_must_be_an_SSLConte;
+static PyObject *__pyx_n_s_ssl_handshake_timeout;
+static PyObject *__pyx_kp_u_ssl_handshake_timeout_is_only_me;
+static PyObject *__pyx_kp_u_ssl_handshake_timeout_should_be;
+static PyObject *__pyx_kp_u_ssl_is_expected_to_be_None_or_an;
+static PyObject *__pyx_n_s_ssl_object;
+static PyObject *__pyx_n_s_ssl_protocol;
+static PyObject *__pyx_n_s_ssl_shutdown_timeout;
+static PyObject *__pyx_kp_u_ssl_shutdown_timeout_is_only_mea;
+static PyObject *__pyx_kp_u_ssl_shutdown_timeout_should_be_a;
+static PyObject *__pyx_n_s_sslcontext;
+static PyObject *__pyx_kp_u_sslcontext_is_expected_to_be_an;
+static PyObject *__pyx_n_s_st_mode;
+static PyObject *__pyx_n_s_stacklevel;
+static PyObject *__pyx_n_s_start;
+static PyObject *__pyx_kp_u_start_init_can_only_be_called;
+static PyObject *__pyx_n_s_start_new_session;
+static PyObject *__pyx_n_s_start_serving;
+static PyObject *__pyx_n_s_start_tls;
+static PyObject *__pyx_n_s_startupinfo;
+static PyObject *__pyx_kp_u_startupinfo_is_not_supported;
+static PyObject *__pyx_n_s_stat;
+static PyObject *__pyx_n_s_stderr;
+static PyObject *__pyx_n_s_stdin;
+static PyObject *__pyx_n_s_stdio_fut;
+static PyObject *__pyx_n_s_stdio_inited;
+static PyObject *__pyx_n_s_stdout;
+static PyObject *__pyx_n_s_stop;
+static PyObject *__pyx_kp_u_stream_is_open_after_UVStream__t;
+static PyObject *__pyx_n_s_strerror;
+static PyObject *__pyx_kp_s_stringsource;
+static PyObject *__pyx_n_s_submit;
+static PyObject *__pyx_n_s_subprocess;
+static PyObject *__pyx_kp_u_subprocess_STDOUT_is_supported_o;
+static PyObject *__pyx_n_s_subprocess_exec;
+static PyObject *__pyx_n_s_subprocess_run;
+static PyObject *__pyx_n_s_subprocess_shell;
+static PyObject *__pyx_n_s_subtract;
+static PyObject *__pyx_n_s_super;
+static PyObject *__pyx_n_s_sys;
+static PyObject *__pyx_n_s_target;
+static PyObject *__pyx_n_u_task;
+static PyObject *__pyx_kp_u_task_factory_must_be_a_callable;
+static PyObject *__pyx_n_u_tcp;
+static PyObject *__pyx_n_s_test;
+static PyObject *__pyx_n_s_test_coroutine_1;
+static PyObject *__pyx_kp_u_the_socket_must_be_non_blocking;
+static PyObject *__pyx_kp_u_this_event_loop_is_already_runni;
+static PyObject *__pyx_n_s_threading;
+static PyObject *__pyx_n_s_throw;
+static PyObject *__pyx_n_s_time;
+static PyObject *__pyx_n_s_timeout;
+static PyObject *__pyx_n_s_traceback;
+static PyObject *__pyx_n_s_traceback_2;
+static PyObject *__pyx_n_s_transport;
+static PyObject *__pyx_n_u_transport;
+static PyObject *__pyx_kp_u_transport_2;
+static PyObject *__pyx_kp_u_transport_sockets_do_not_support;
+static PyObject *__pyx_n_s_transports;
+static PyObject *__pyx_kp_u_try_write_sent_all_data_and_ret;
+static PyObject *__pyx_n_s_type;
+static PyObject *__pyx_n_u_udp;
+static PyObject *__pyx_kp_u_unable_to_listen_no_protocol_fac;
+static PyObject *__pyx_kp_u_unable_to_perform_operation_on_r;
+static PyObject *__pyx_kp_u_unable_to_start_the_loop_it_was;
+static PyObject *__pyx_kp_u_unclosed_resource_r;
+static PyObject *__pyx_kp_u_unclosed_resource_r_2;
+static PyObject *__pyx_kp_u_unclosed_resource_r_could_not_se;
+static PyObject *__pyx_kp_u_unclosed_transport_uvloop_loop;
+static PyObject *__pyx_kp_u_unexpected_address_family;
+static PyObject *__pyx_kp_u_unhandled_error_or_an_empty_buff;
+static PyObject *__pyx_n_s_universal_newlines;
+static PyObject *__pyx_kp_u_universal_newlines_must_be_False;
+static PyObject *__pyx_kp_u_unix_socket_path;
+static PyObject *__pyx_kp_u_unopened_TCPServer;
+static PyObject *__pyx_n_s_unset;
+static PyObject *__pyx_n_s_unwrap;
+static PyObject *__pyx_n_s_update;
+static PyObject *__pyx_kp_u_uv_close_handle_cb_handle_loop;
+static PyObject *__pyx_kp_u_uv_handle_t_current_freed_total;
+static PyObject *__pyx_kp_u_uvloop_PseudoSocket_fd_family_s;
+static PyObject *__pyx_kp_s_uvloop_handles_process_pyx;
+static PyObject *__pyx_n_s_uvloop_loop;
+static PyObject *__pyx_kp_s_uvloop_loop_pyx;
+static PyObject *__pyx_n_s_uvloop_sleep_after_fork;
+static PyObject *__pyx_kp_u_uvloop_sslproto;
+static PyObject *__pyx_n_s_values;
+static PyObject *__pyx_n_s_version_info;
+static PyObject *__pyx_n_s_wait;
+static PyObject *__pyx_n_s_wait_closed;
+static PyObject *__pyx_n_s_waiter;
+static PyObject *__pyx_n_s_walk_stack;
+static PyObject *__pyx_n_s_warn;
+static PyObject *__pyx_n_s_warn_on_full_buffer;
+static PyObject *__pyx_n_s_warning;
+static PyObject *__pyx_n_s_warnings;
+static PyObject *__pyx_n_u_wb;
+static PyObject *__pyx_n_s_weakref;
+static PyObject *__pyx_n_s_when;
+static PyObject *__pyx_kp_u_without_no_gc_clear_loop_was_se;
+static PyObject *__pyx_n_s_wrap;
+static PyObject *__pyx_n_s_wrap_bio;
+static PyObject *__pyx_n_s_wrap_future;
+static PyObject *__pyx_n_s_write;
+static PyObject *__pyx_n_s_zip;
+static int __pyx_pf_6uvloop_4loop_4Loop___cinit__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static int __pyx_pf_6uvloop_4loop_4Loop_2__init__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static void __pyx_pf_6uvloop_4loop_4Loop_4__dealloc__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_6__sighandler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_signum, CYTHON_UNUSED PyObject *__pyx_v_frame); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12_getaddrinfo_callback(PyObject *__pyx_self, PyObject *__pyx_v_result); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12_getnameinfo_callback(PyObject *__pyx_self, PyObject *__pyx_v_result); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_8_get_backend_id(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_16print_debug_info___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_10__repr__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12call_soon(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_14call_soon_threadsafe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_16call_later(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_delay, PyObject *__pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_18call_at(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_when, PyObject *__pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_20time(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22stop(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24run_forever(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_26close(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28get_debug(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_30set_debug(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_enabled); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_32is_running(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_34is_closed(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_36create_future(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_38create_task(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_coro, PyObject *__pyx_v_name); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_40set_task_factory(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_factory); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_42get_task_factory(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_18run_until_complete_done_cb(PyObject *__pyx_self, PyObject *__pyx_v_fut); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_44run_until_complete(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_future); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_46getaddrinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_flags); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_49getnameinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sockaddr, int __pyx_v_flags); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_52start_tls(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_transport, PyObject *__pyx_v_protocol, PyObject *__pyx_v_sslcontext, PyObject *__pyx_v_server_side, PyObject *__pyx_v_server_hostname, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_55create_server(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_flags, PyObject *__pyx_v_sock, PyObject *__pyx_v_backlog, PyObject *__pyx_v_ssl, PyObject *__pyx_v_reuse_address, PyObject *__pyx_v_reuse_port, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout, PyObject *__pyx_v_start_serving); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_17create_connection_genexpr(PyObject *__pyx_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_17create_connection_3genexpr(PyObject *__pyx_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_58create_connection(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_host, PyObject *__pyx_v_port, PyObject *__pyx_v_ssl, PyObject *__pyx_v_family, PyObject *__pyx_v_proto, PyObject *__pyx_v_flags, PyObject *__pyx_v_sock, PyObject *__pyx_v_local_addr, PyObject *__pyx_v_server_hostname, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_61create_unix_server(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_path, PyObject *__pyx_v_backlog, PyObject *__pyx_v_sock, PyObject *__pyx_v_ssl, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout, PyObject *__pyx_v_start_serving); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_64create_unix_connection(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_path, PyObject *__pyx_v_ssl, PyObject *__pyx_v_sock, PyObject *__pyx_v_server_hostname, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_67default_exception_handler(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_context); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_69get_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_71set_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_handler); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_73call_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_context); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_75add_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_77remove_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_79add_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_81remove_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_83sock_recv(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_n); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_86sock_recv_into(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_buf); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_89sock_sendall(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_data); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_92sock_accept(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_95sock_connect(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_address); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_98connect_accepted_socket(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_sock, PyObject *__pyx_v_ssl, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_101run_in_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_executor, PyObject *__pyx_v_func, PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_103set_default_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_executor); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_105__subprocess_run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_args, PyObject *__pyx_v_stdin, PyObject *__pyx_v_stdout, PyObject *__pyx_v_stderr, PyObject *__pyx_v_universal_newlines, CYTHON_UNUSED PyObject *__pyx_v_shell, PyObject *__pyx_v_bufsize, PyObject *__pyx_v_preexec_fn, CYTHON_UNUSED PyObject *__pyx_v_close_fds, PyObject *__pyx_v_cwd, PyObject *__pyx_v_env, PyObject *__pyx_v_startupinfo, PyObject *__pyx_v_creationflags, PyObject *__pyx_v_restore_signals, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v_executable, PyObject *__pyx_v_pass_fds, PyObject *__pyx_v___uvloop_sleep_after_fork); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_108subprocess_shell(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_cmd, PyObject *__pyx_v_shell, PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_111subprocess_exec(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_program, PyObject *__pyx_v_shell, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_114connect_read_pipe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_proto_factory, PyObject *__pyx_v_pipe); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_117connect_write_pipe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_proto_factory, PyObject *__pyx_v_pipe); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_120add_signal_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_122remove_signal_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24create_datagram_endpoint_genexpr(PyObject *__pyx_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_124create_datagram_endpoint(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_local_addr, PyObject *__pyx_v_remote_addr, PyObject *__pyx_v_family, PyObject *__pyx_v_proto, PyObject *__pyx_v_flags, PyObject *__pyx_v_reuse_address, PyObject *__pyx_v_reuse_port, PyObject *__pyx_v_allow_broadcast, PyObject *__pyx_v_sock); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_127_check_default_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_129_asyncgen_finalizer_hook(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_agen); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_131_asyncgen_firstiter_hook(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_agen); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_133shutdown_asyncgens(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_136shutdown_default_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_139_do_shutdown(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_future); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static int __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_2__set__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
+static int __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_4__del__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_7_closed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_9_debug_cc___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_20_debug_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_21_debug_handles_closed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22_debug_handles_current___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_freed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_count___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_count___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_shutdown_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_33_debug_stream_listen_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_read_cb_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_34_debug_stream_read_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28_debug_stream_read_eof_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_38_debug_stream_read_eof_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_31_debug_stream_read_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_25_debug_stream_write_tries___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_32_debug_stream_write_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_stream_write_ctx_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_write_ctx_cnt___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_write_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_poll_read_events_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_26_poll_read_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24_poll_write_events_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_poll_write_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_21_sock_try_write_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28_debug_exception_handler_cnt___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_141__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_143__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_loop); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture_2__remove_reader(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture_4cancel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_msg); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture_6cancel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_loop); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture_2__remove_writer(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture_4cancel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_msg); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture_6cancel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
+static int __pyx_pf_6uvloop_4loop_6Handle___cinit__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
+static void __pyx_pf_6uvloop_4loop_6Handle_2__dealloc__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
+static int __pyx_pf_6uvloop_4loop_6Handle_4__init__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_6__repr__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_8cancel(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_10cancelled(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_17_source_traceback___get__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_11TimerHandle___cinit__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_callback, PyObject *__pyx_v_args, uint64_t __pyx_v_delay, PyObject *__pyx_v_context); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_17_source_traceback___get__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto */
+static void __pyx_pf_6uvloop_4loop_11TimerHandle_2__dealloc__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_4__repr__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_6cancelled(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_8cancel(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_10when(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_12PseudoSocket___init__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_fd); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_6family___get__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_4type___get__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_5proto___get__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_2__repr__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_4__getstate__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_6fileno(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_8dup(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_10get_inheritable(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_12set_inheritable(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_14ioctl(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_16getsockopt(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_18setsockopt(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_20getpeername(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_22getsockname(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_24share(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_process_id); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_26accept(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_28connect(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_30connect_ex(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_32bind(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_34listen(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_36makefile(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_38sendfile(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_40close(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_42detach(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_44shutdown(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_46sendmsg_afalg(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_48sendmsg(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_50sendto(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_52send(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_54sendall(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_56recv_into(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_58recvfrom_into(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_60recvmsg_into(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_62recvmsg(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_64recvfrom(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_66recv(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_68settimeout(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_70gettimeout(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_72setblocking(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_74__enter__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_76__exit__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_err); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_78__reduce_cython__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_80__setstate_cython__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_8LruCache___init__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_maxsize); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8LruCache_2__getitem__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_key); /* proto */
+static int __pyx_pf_6uvloop_4loop_8LruCache_4__setitem__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_o); /* proto */
+static int __pyx_pf_6uvloop_4loop_8LruCache_6__delitem__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_key); /* proto */
+static int __pyx_pf_6uvloop_4loop_8LruCache_8__contains__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_key); /* proto */
+static Py_ssize_t __pyx_pf_6uvloop_4loop_8LruCache_10__len__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8LruCache_12__iter__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8LruCache_14__reduce_cython__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8LruCache_16__setstate_cython__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_8UVHandle___cinit__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto */
+static int __pyx_pf_6uvloop_4loop_8UVHandle_2__init__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto */
+static void __pyx_pf_6uvloop_4loop_8UVHandle_4__dealloc__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVHandle_6__repr__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVHandle_17_source_traceback___get__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVHandle_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVHandle_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_14UVSocketHandle___cinit__(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_14UVSocketHandle_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_14UVSocketHandle_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_7UVAsync___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_7UVAsync_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6UVIdle___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6UVIdle_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_7UVCheck___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_7UVCheck_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_7UVTimer___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_7UVTimer_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6UVPoll___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6UVPoll_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_15UVBaseTransport___cinit__(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_7_paused___get__(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_2get_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_4set_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_protocol); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_6_force_close(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_8abort(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_10close(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_12is_closing(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_14get_write_buffer_size(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_16set_write_buffer_limits(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_high, PyObject *__pyx_v_low); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_18get_write_buffer_limits(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_20get_extra_info(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_default); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_8_closing___get__(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_22__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_24__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static void __pyx_pf_6uvloop_4loop_19_StreamWriteContext___dealloc__(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_19_StreamWriteContext_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_19_StreamWriteContext_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_8UVStream___cinit__(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_2__repr__(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_4write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_buf); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_6writelines(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_bufs); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_8write_eof(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_10can_write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_12is_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_14pause_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_16resume_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_14UVStreamServer___cinit__(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_14UVStreamServer_2__on_ssl_connected(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, PyObject *__pyx_v_transport, PyObject *__pyx_v_fut); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_14UVStreamServer_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_14UVStreamServer_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_9TCPServer___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_9TCPServer_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12TCPTransport_get_extra_info(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_default); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12TCPTransport_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12TCPTransport_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_18_TCPConnectRequest___cinit__(struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_loop, PyObject *__pyx_v_transport); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18_TCPConnectRequest_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18_TCPConnectRequest_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_10UnixServer___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_10UnixServer_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_13UnixTransport___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_13UnixTransport_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_get_write_buffer_limits(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_2set_write_buffer_limits(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_high, CYTHON_UNUSED PyObject *__pyx_v_low); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_4get_write_buffer_size(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_6write(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_data); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_8writelines(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_list_of_data); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_10write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_12can_write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_14abort(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18WriteUnixTransport_pause_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18WriteUnixTransport_2resume_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18WriteUnixTransport_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18WriteUnixTransport_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_19_PipeConnectRequest___cinit__(struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_loop, PyObject *__pyx_v_transport); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_19_PipeConnectRequest_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_19_PipeConnectRequest_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_9UVProcess___cinit__(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self); /* proto */
+static void __pyx_pf_6uvloop_4loop_9UVProcess_2__dealloc__(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_9UVProcess_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_9UVProcess_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_18UVProcessTransport___cinit__(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_2__stdio_inited(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_waiter, PyObject *__pyx_v_stdio_fut); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_4get_protocol(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_6set_protocol(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_protocol); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_8get_pid(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_10get_returncode(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_12get_pipe_transport(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_fd); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_14terminate(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_16kill(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_18send_signal(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_signal); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_20is_closing(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_22close(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_24get_extra_info(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_name, PyObject *__pyx_v_default); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_26_wait(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_proc, PyObject *__pyx_v_fd); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_2connection_made(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_transport); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_4__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_6connection_lost(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_exc); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_8pause_writing(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_10resume_writing(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_23ReadSubprocessPipeProto_data_received(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_data); /* proto */
+static int __pyx_pf_6uvloop_4loop_9UVRequest___cinit__(struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, CYTHON_UNUSED PyObject *__pyx_v__); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_9UVRequest_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_9UVRequest_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_14SockAddrHolder___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_SockAddrHolder *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_14SockAddrHolder_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_SockAddrHolder *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_8AddrInfo___cinit__(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self); /* proto */
+static void __pyx_pf_6uvloop_4loop_8AddrInfo_2__dealloc__(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8AddrInfo_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_8AddrInfo_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_15AddrInfoRequest___cinit__(struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_flags, PyObject *__pyx_v_callback); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15AddrInfoRequest_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15AddrInfoRequest_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_15NameInfoRequest___cinit__(struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__pyx_v_self, CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_callback); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15NameInfoRequest_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15NameInfoRequest_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport___cinit__(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_ssl_protocol, PyObject *__pyx_v_context); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_2get_extra_info(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_default); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_4set_protocol(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_protocol); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_6get_protocol(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_8is_closing(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_10close(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static void __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_12__dealloc__(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_14is_reading(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_16pause_reading(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_18resume_reading(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_20set_write_buffer_limits(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_high, PyObject *__pyx_v_low); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_22get_write_buffer_limits(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_24get_write_buffer_size(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_26set_read_buffer_limits(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_high, PyObject *__pyx_v_low); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_28get_read_buffer_limits(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_30get_read_buffer_size(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_16_protocol_paused___get__(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_32write(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_data); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_34writelines(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_list_of_data); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_36write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_38can_write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_40abort(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_42_force_close(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_exc); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_44_test__append_write_backlog(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_data); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_46__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_48__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_11SSLProtocol___cinit__(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
+static void __pyx_pf_6uvloop_4loop_11SSLProtocol_2__dealloc__(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto */
+static int __pyx_pf_6uvloop_4loop_11SSLProtocol_4__init__(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_loop, PyObject *__pyx_v_app_protocol, PyObject *__pyx_v_sslcontext, PyObject *__pyx_v_waiter, PyObject *__pyx_v_server_side, PyObject *__pyx_v_server_hostname, PyObject *__pyx_v_call_connection_made, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_6_get_app_transport(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_context); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_8connection_made(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_transport); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_10connection_lost(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_exc); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_12get_buffer(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_n); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_14buffer_updated(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_nbytes); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_16eof_received(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto */
+static PyObject *__pyx_lambda_funcdef_lambda4(PyObject *__pyx_self); /* proto */
+static PyObject *__pyx_lambda_funcdef_lambda5(PyObject *__pyx_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_18pause_writing(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_20resume_writing(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_22__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_24__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static void __pyx_pf_6uvloop_4loop_15_UDPSendContext___dealloc__(struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15_UDPSendContext_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_15_UDPSendContext_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_12UDPTransport___cinit__(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12UDPTransport_2sendto(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_data, PyObject *__pyx_v_addr); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12UDPTransport_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_12UDPTransport_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_pf_6uvloop_4loop_6Server___cinit__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_2__aenter__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_5__aexit__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_8__repr__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_10get_loop(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_12wait_closed(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_15close(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_17is_serving(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_19start_serving(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_22serve_forever(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_7sockets___get__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_25__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_27__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop__test_coroutine_1(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_3__pyx_unpickle_PseudoSocket(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_6uvloop_4loop_5__pyx_unpickle_LruCache(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_11cfunc_dot_to_py_42__Pyx_CFunc_object____Loop____bint___to_py_wrap(PyObject *__pyx_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, int __pyx_v_enabled); /* proto */
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVHandle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVSocketHandle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVAsync(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVTimer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVIdle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVBaseTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_Loop(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_Handle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_TimerHandle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVCheck(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVPoll(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVStream(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVStreamServer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_TCPServer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_TCPTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UnixServer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UnixTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_ReadUnixTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_WriteUnixTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVProcess(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVProcessTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVRequest(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop__SSLProtocolTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_SSLProtocol(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_UDPTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_Server(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_PseudoSocket(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_LruCache(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop__StreamWriteContext(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop__TCPConnectRequest(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop__PipeConnectRequest(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_SockAddrHolder(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_AddrInfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_AddrInfoRequest(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop_NameInfoRequest(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop__UDPSendContext(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct___getaddrinfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_1__getnameinfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_2___get__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_3_run_until_complete(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_5_getnameinfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_6_start_tls(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_7_create_server(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_8_create_connection(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_9_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_10_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_11_create_unix_server(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_13_sock_recv(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_15_sock_sendall(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_16_sock_accept(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_17_sock_connect(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_19___subprocess_run(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_25_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_28__start_handshake(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_29__start_shutdown(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_30___aenter__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_31___aexit__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_32_wait_closed(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_33_start_serving(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_34_serve_forever(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop = {0, &__pyx_n_s_pop, 0, 0, 0};
+static __Pyx_CachedCFunction __pyx_umethod_PyList_Type_copy = {0, &__pyx_n_s_copy, 0, 0, 0};
+static __Pyx_CachedCFunction __pyx_umethod_PyUnicode_Type_rstrip = {0, &__pyx_n_s_rstrip, 0, 0, 0};
+static PyObject *__pyx_float_0_1;
+static PyObject *__pyx_float_1e3;
+static PyObject *__pyx_float_1eneg_3;
+static PyObject *__pyx_float_30_0;
+static PyObject *__pyx_float_60_0;
+static PyObject *__pyx_int_0;
+static PyObject *__pyx_int_1;
+static PyObject *__pyx_int_2;
+static PyObject *__pyx_int_3;
+static PyObject *__pyx_int_10;
+static PyObject *__pyx_int_15;
+static PyObject *__pyx_int_42;
+static PyObject *__pyx_int_100;
+static PyObject *__pyx_int_1000;
+static PyObject *__pyx_int_2048;
+static PyObject *__pyx_int_50000;
+static PyObject *__pyx_int_65536;
+static PyObject *__pyx_int_262144;
+static PyObject *__pyx_int_1048575;
+static PyObject *__pyx_int_87255255;
+static PyObject *__pyx_int_143395587;
+static PyObject *__pyx_int_4294967296;
+static PyObject *__pyx_int_neg_1;
+static int __pyx_k__48;
+static int __pyx_k__49;
+static PyObject *__pyx_k__76;
+static PyObject *__pyx_k__77;
+static PyObject *__pyx_k__78;
+static PyObject *__pyx_k__90;
+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__9;
+static PyObject *__pyx_slice__73;
+static PyObject *__pyx_tuple__10;
+static PyObject *__pyx_tuple__11;
+static PyObject *__pyx_tuple__12;
+static PyObject *__pyx_tuple__13;
+static PyObject *__pyx_tuple__14;
+static PyObject *__pyx_tuple__15;
+static PyObject *__pyx_tuple__16;
+static PyObject *__pyx_tuple__17;
+static PyObject *__pyx_tuple__18;
+static PyObject *__pyx_tuple__20;
+static PyObject *__pyx_tuple__22;
+static PyObject *__pyx_tuple__23;
+static PyObject *__pyx_tuple__24;
+static PyObject *__pyx_tuple__25;
+static PyObject *__pyx_tuple__26;
+static PyObject *__pyx_tuple__27;
+static PyObject *__pyx_tuple__28;
+static PyObject *__pyx_tuple__29;
+static PyObject *__pyx_tuple__30;
+static PyObject *__pyx_tuple__31;
+static PyObject *__pyx_tuple__33;
+static PyObject *__pyx_tuple__34;
+static PyObject *__pyx_tuple__35;
+static PyObject *__pyx_tuple__36;
+static PyObject *__pyx_tuple__37;
+static PyObject *__pyx_tuple__38;
+static PyObject *__pyx_tuple__39;
+static PyObject *__pyx_tuple__41;
+static PyObject *__pyx_tuple__42;
+static PyObject *__pyx_tuple__43;
+static PyObject *__pyx_tuple__44;
+static PyObject *__pyx_tuple__45;
+static PyObject *__pyx_tuple__46;
+static PyObject *__pyx_tuple__47;
+static PyObject *__pyx_tuple__50;
+static PyObject *__pyx_tuple__51;
+static PyObject *__pyx_tuple__52;
+static PyObject *__pyx_tuple__53;
+static PyObject *__pyx_tuple__54;
+static PyObject *__pyx_tuple__55;
+static PyObject *__pyx_tuple__57;
+static PyObject *__pyx_tuple__58;
+static PyObject *__pyx_tuple__59;
+static PyObject *__pyx_tuple__60;
+static PyObject *__pyx_tuple__61;
+static PyObject *__pyx_tuple__62;
+static PyObject *__pyx_tuple__64;
+static PyObject *__pyx_tuple__65;
+static PyObject *__pyx_tuple__66;
+static PyObject *__pyx_tuple__67;
+static PyObject *__pyx_tuple__70;
+static PyObject *__pyx_tuple__71;
+static PyObject *__pyx_tuple__72;
+static PyObject *__pyx_tuple__74;
+static PyObject *__pyx_tuple__75;
+static PyObject *__pyx_tuple__79;
+static PyObject *__pyx_tuple__80;
+static PyObject *__pyx_tuple__81;
+static PyObject *__pyx_tuple__82;
+static PyObject *__pyx_tuple__83;
+static PyObject *__pyx_tuple__84;
+static PyObject *__pyx_tuple__85;
+static PyObject *__pyx_tuple__86;
+static PyObject *__pyx_tuple__87;
+static PyObject *__pyx_tuple__88;
+static PyObject *__pyx_tuple__89;
+static PyObject *__pyx_tuple__92;
+static PyObject *__pyx_tuple__93;
+static PyObject *__pyx_tuple__94;
+static PyObject *__pyx_tuple__95;
+static PyObject *__pyx_tuple__96;
+static PyObject *__pyx_tuple__97;
+static PyObject *__pyx_tuple__98;
+static PyObject *__pyx_tuple__99;
+static PyObject *__pyx_tuple__100;
+static PyObject *__pyx_tuple__101;
+static PyObject *__pyx_tuple__102;
+static PyObject *__pyx_tuple__106;
+static PyObject *__pyx_tuple__107;
+static PyObject *__pyx_tuple__108;
+static PyObject *__pyx_tuple__109;
+static PyObject *__pyx_tuple__110;
+static PyObject *__pyx_tuple__111;
+static PyObject *__pyx_tuple__112;
+static PyObject *__pyx_tuple__113;
+static PyObject *__pyx_tuple__114;
+static PyObject *__pyx_tuple__115;
+static PyObject *__pyx_tuple__116;
+static PyObject *__pyx_tuple__117;
+static PyObject *__pyx_tuple__118;
+static PyObject *__pyx_tuple__119;
+static PyObject *__pyx_tuple__120;
+static PyObject *__pyx_tuple__121;
+static PyObject *__pyx_tuple__122;
+static PyObject *__pyx_tuple__123;
+static PyObject *__pyx_tuple__124;
+static PyObject *__pyx_tuple__125;
+static PyObject *__pyx_tuple__126;
+static PyObject *__pyx_tuple__127;
+static PyObject *__pyx_tuple__128;
+static PyObject *__pyx_tuple__129;
+static PyObject *__pyx_tuple__130;
+static PyObject *__pyx_tuple__131;
+static PyObject *__pyx_tuple__132;
+static PyObject *__pyx_tuple__135;
+static PyObject *__pyx_tuple__136;
+static PyObject *__pyx_tuple__137;
+static PyObject *__pyx_tuple__138;
+static PyObject *__pyx_tuple__139;
+static PyObject *__pyx_tuple__140;
+static PyObject *__pyx_tuple__141;
+static PyObject *__pyx_tuple__142;
+static PyObject *__pyx_tuple__143;
+static PyObject *__pyx_tuple__144;
+static PyObject *__pyx_tuple__145;
+static PyObject *__pyx_tuple__146;
+static PyObject *__pyx_tuple__147;
+static PyObject *__pyx_tuple__148;
+static PyObject *__pyx_tuple__149;
+static PyObject *__pyx_tuple__150;
+static PyObject *__pyx_tuple__151;
+static PyObject *__pyx_tuple__152;
+static PyObject *__pyx_tuple__153;
+static PyObject *__pyx_tuple__154;
+static PyObject *__pyx_tuple__155;
+static PyObject *__pyx_tuple__156;
+static PyObject *__pyx_tuple__157;
+static PyObject *__pyx_tuple__158;
+static PyObject *__pyx_tuple__159;
+static PyObject *__pyx_tuple__160;
+static PyObject *__pyx_tuple__161;
+static PyObject *__pyx_tuple__162;
+static PyObject *__pyx_tuple__163;
+static PyObject *__pyx_tuple__164;
+static PyObject *__pyx_tuple__165;
+static PyObject *__pyx_tuple__166;
+static PyObject *__pyx_tuple__167;
+static PyObject *__pyx_tuple__168;
+static PyObject *__pyx_tuple__169;
+static PyObject *__pyx_tuple__170;
+static PyObject *__pyx_tuple__171;
+static PyObject *__pyx_tuple__172;
+static PyObject *__pyx_tuple__173;
+static PyObject *__pyx_tuple__174;
+static PyObject *__pyx_tuple__175;
+static PyObject *__pyx_tuple__176;
+static PyObject *__pyx_tuple__177;
+static PyObject *__pyx_tuple__179;
+static PyObject *__pyx_tuple__180;
+static PyObject *__pyx_tuple__181;
+static PyObject *__pyx_tuple__182;
+static PyObject *__pyx_tuple__183;
+static PyObject *__pyx_tuple__184;
+static PyObject *__pyx_tuple__185;
+static PyObject *__pyx_tuple__186;
+static PyObject *__pyx_tuple__188;
+static PyObject *__pyx_tuple__189;
+static PyObject *__pyx_tuple__190;
+static PyObject *__pyx_tuple__191;
+static PyObject *__pyx_tuple__192;
+static PyObject *__pyx_tuple__193;
+static PyObject *__pyx_tuple__194;
+static PyObject *__pyx_tuple__195;
+static PyObject *__pyx_tuple__196;
+static PyObject *__pyx_tuple__197;
+static PyObject *__pyx_tuple__198;
+static PyObject *__pyx_tuple__199;
+static PyObject *__pyx_tuple__200;
+static PyObject *__pyx_tuple__201;
+static PyObject *__pyx_tuple__202;
+static PyObject *__pyx_tuple__203;
+static PyObject *__pyx_tuple__204;
+static PyObject *__pyx_tuple__205;
+static PyObject *__pyx_tuple__206;
+static PyObject *__pyx_tuple__207;
+static PyObject *__pyx_tuple__208;
+static PyObject *__pyx_tuple__209;
+static PyObject *__pyx_tuple__210;
+static PyObject *__pyx_tuple__211;
+static PyObject *__pyx_tuple__212;
+static PyObject *__pyx_tuple__213;
+static PyObject *__pyx_tuple__214;
+static PyObject *__pyx_tuple__215;
+static PyObject *__pyx_tuple__216;
+static PyObject *__pyx_tuple__217;
+static PyObject *__pyx_tuple__218;
+static PyObject *__pyx_tuple__219;
+static PyObject *__pyx_tuple__220;
+static PyObject *__pyx_tuple__221;
+static PyObject *__pyx_tuple__222;
+static PyObject *__pyx_tuple__223;
+static PyObject *__pyx_tuple__224;
+static PyObject *__pyx_tuple__225;
+static PyObject *__pyx_tuple__226;
+static PyObject *__pyx_tuple__227;
+static PyObject *__pyx_tuple__228;
+static PyObject *__pyx_tuple__229;
+static PyObject *__pyx_tuple__231;
+static PyObject *__pyx_tuple__233;
+static PyObject *__pyx_tuple__235;
+static PyObject *__pyx_tuple__237;
+static PyObject *__pyx_tuple__239;
+static PyObject *__pyx_tuple__240;
+static PyObject *__pyx_tuple__242;
+static PyObject *__pyx_tuple__244;
+static PyObject *__pyx_tuple__246;
+static PyObject *__pyx_tuple__248;
+static PyObject *__pyx_tuple__249;
+static PyObject *__pyx_tuple__251;
+static PyObject *__pyx_tuple__253;
+static PyObject *__pyx_tuple__255;
+static PyObject *__pyx_tuple__257;
+static PyObject *__pyx_tuple__259;
+static PyObject *__pyx_tuple__261;
+static PyObject *__pyx_tuple__263;
+static PyObject *__pyx_tuple__265;
+static PyObject *__pyx_tuple__267;
+static PyObject *__pyx_codeobj__19;
+static PyObject *__pyx_codeobj__21;
+static PyObject *__pyx_codeobj__40;
+static PyObject *__pyx_codeobj__230;
+static PyObject *__pyx_codeobj__232;
+static PyObject *__pyx_codeobj__234;
+static PyObject *__pyx_codeobj__236;
+static PyObject *__pyx_codeobj__238;
+static PyObject *__pyx_codeobj__241;
+static PyObject *__pyx_codeobj__243;
+static PyObject *__pyx_codeobj__245;
+static PyObject *__pyx_codeobj__247;
+static PyObject *__pyx_codeobj__250;
+static PyObject *__pyx_codeobj__252;
+static PyObject *__pyx_codeobj__254;
+static PyObject *__pyx_codeobj__256;
+static PyObject *__pyx_codeobj__258;
+static PyObject *__pyx_codeobj__260;
+static PyObject *__pyx_codeobj__262;
+static PyObject *__pyx_codeobj__264;
+static PyObject *__pyx_codeobj__266;
+static PyObject *__pyx_codeobj__268;
+/* Late includes */
+
+/* "uvloop/errors.pyx":1
+ * cdef str __strerr(int errno):             # <<<<<<<<<<<<<<
+ *     return strerror(errno).decode()
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___strerr(int __pyx_v_errno) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  char *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__strerr", 0);
+
+  /* "uvloop/errors.pyx":2
+ * cdef str __strerr(int errno):
+ *     return strerror(errno).decode()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = strerror(__pyx_v_errno);
+  __pyx_t_2 = __Pyx_decode_c_string(__pyx_t_1, 0, strlen(__pyx_t_1), NULL, NULL, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (!(likely(PyUnicode_CheckExact(__pyx_t_2))||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(1, 2, __pyx_L1_error)
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_r = ((PyObject*)__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/errors.pyx":1
+ * cdef str __strerr(int errno):             # <<<<<<<<<<<<<<
+ *     return strerror(errno).decode()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.__strerr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/errors.pyx":5
+ * 
+ * 
+ * cdef __convert_python_error(int uverr):             # <<<<<<<<<<<<<<
+ *     # XXX Won't work for Windows:
+ *     # From libuv docs:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___convert_python_error(int __pyx_v_uverr) {
+  int __pyx_v_oserr;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__convert_python_error", 0);
+
+  /* "uvloop/errors.pyx":11
+ *     #      negated errno (or -errno), while on Windows they
+ *     #      are defined by libuv to arbitrary negative numbers.
+ *     cdef int oserr = -uverr             # <<<<<<<<<<<<<<
+ * 
+ *     exc = OSError
+ */
+  __pyx_v_oserr = (-__pyx_v_uverr);
+
+  /* "uvloop/errors.pyx":13
+ *     cdef int oserr = -uverr
+ * 
+ *     exc = OSError             # <<<<<<<<<<<<<<
+ * 
+ *     if uverr in (uv.UV_EACCES, uv.UV_EPERM):
+ */
+  __Pyx_INCREF(__pyx_builtin_OSError);
+  __pyx_v_exc = __pyx_builtin_OSError;
+
+  /* "uvloop/errors.pyx":15
+ *     exc = OSError
+ * 
+ *     if uverr in (uv.UV_EACCES, uv.UV_EPERM):             # <<<<<<<<<<<<<<
+ *         exc = PermissionError
+ * 
+ */
+  __pyx_t_1 = __pyx_v_uverr;
+  __pyx_t_3 = ((__pyx_t_1 == UV_EACCES) != 0);
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_3 = ((__pyx_t_1 == UV_EPERM) != 0);
+  __pyx_t_2 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/errors.pyx":16
+ * 
+ *     if uverr in (uv.UV_EACCES, uv.UV_EPERM):
+ *         exc = PermissionError             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr in (uv.UV_EAGAIN, uv.UV_EALREADY):
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PermissionError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 16, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":15
+ *     exc = OSError
+ * 
+ *     if uverr in (uv.UV_EACCES, uv.UV_EPERM):             # <<<<<<<<<<<<<<
+ *         exc = PermissionError
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":18
+ *         exc = PermissionError
+ * 
+ *     elif uverr in (uv.UV_EAGAIN, uv.UV_EALREADY):             # <<<<<<<<<<<<<<
+ *         exc = BlockingIOError
+ * 
+ */
+  __pyx_t_1 = __pyx_v_uverr;
+  __pyx_t_2 = ((__pyx_t_1 == UV_EAGAIN) != 0);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_3 = __pyx_t_2;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_2 = ((__pyx_t_1 == UV_EALREADY) != 0);
+  __pyx_t_3 = __pyx_t_2;
+  __pyx_L6_bool_binop_done:;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/errors.pyx":19
+ * 
+ *     elif uverr in (uv.UV_EAGAIN, uv.UV_EALREADY):
+ *         exc = BlockingIOError             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr in (uv.UV_EPIPE, uv.UV_ESHUTDOWN):
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BlockingIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 19, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":18
+ *         exc = PermissionError
+ * 
+ *     elif uverr in (uv.UV_EAGAIN, uv.UV_EALREADY):             # <<<<<<<<<<<<<<
+ *         exc = BlockingIOError
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":21
+ *         exc = BlockingIOError
+ * 
+ *     elif uverr in (uv.UV_EPIPE, uv.UV_ESHUTDOWN):             # <<<<<<<<<<<<<<
+ *         exc = BrokenPipeError
+ * 
+ */
+  __pyx_t_1 = __pyx_v_uverr;
+  __pyx_t_3 = ((__pyx_t_1 == UV_EPIPE) != 0);
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L8_bool_binop_done;
+  }
+  __pyx_t_3 = ((__pyx_t_1 == UV_ESHUTDOWN) != 0);
+  __pyx_t_2 = __pyx_t_3;
+  __pyx_L8_bool_binop_done:;
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/errors.pyx":22
+ * 
+ *     elif uverr in (uv.UV_EPIPE, uv.UV_ESHUTDOWN):
+ *         exc = BrokenPipeError             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_ECONNABORTED:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BrokenPipeError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 22, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":21
+ *         exc = BlockingIOError
+ * 
+ *     elif uverr in (uv.UV_EPIPE, uv.UV_ESHUTDOWN):             # <<<<<<<<<<<<<<
+ *         exc = BrokenPipeError
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":24
+ *         exc = BrokenPipeError
+ * 
+ *     elif uverr == uv.UV_ECONNABORTED:             # <<<<<<<<<<<<<<
+ *         exc = ConnectionAbortedError
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_uverr == UV_ECONNABORTED) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/errors.pyx":25
+ * 
+ *     elif uverr == uv.UV_ECONNABORTED:
+ *         exc = ConnectionAbortedError             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_ECONNREFUSED:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ConnectionAbortedError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 25, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":24
+ *         exc = BrokenPipeError
+ * 
+ *     elif uverr == uv.UV_ECONNABORTED:             # <<<<<<<<<<<<<<
+ *         exc = ConnectionAbortedError
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":27
+ *         exc = ConnectionAbortedError
+ * 
+ *     elif uverr == uv.UV_ECONNREFUSED:             # <<<<<<<<<<<<<<
+ *         exc = ConnectionRefusedError
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_uverr == UV_ECONNREFUSED) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/errors.pyx":28
+ * 
+ *     elif uverr == uv.UV_ECONNREFUSED:
+ *         exc = ConnectionRefusedError             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_ECONNRESET:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ConnectionRefusedError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 28, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":27
+ *         exc = ConnectionAbortedError
+ * 
+ *     elif uverr == uv.UV_ECONNREFUSED:             # <<<<<<<<<<<<<<
+ *         exc = ConnectionRefusedError
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":30
+ *         exc = ConnectionRefusedError
+ * 
+ *     elif uverr == uv.UV_ECONNRESET:             # <<<<<<<<<<<<<<
+ *         exc = ConnectionResetError
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_uverr == UV_ECONNRESET) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/errors.pyx":31
+ * 
+ *     elif uverr == uv.UV_ECONNRESET:
+ *         exc = ConnectionResetError             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EEXIST:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ConnectionResetError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 31, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":30
+ *         exc = ConnectionRefusedError
+ * 
+ *     elif uverr == uv.UV_ECONNRESET:             # <<<<<<<<<<<<<<
+ *         exc = ConnectionResetError
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":33
+ *         exc = ConnectionResetError
+ * 
+ *     elif uverr == uv.UV_EEXIST:             # <<<<<<<<<<<<<<
+ *         exc = FileExistsError
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_uverr == UV_EEXIST) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/errors.pyx":34
+ * 
+ *     elif uverr == uv.UV_EEXIST:
+ *         exc = FileExistsError             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_ENOENT:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FileExistsError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 34, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":33
+ *         exc = ConnectionResetError
+ * 
+ *     elif uverr == uv.UV_EEXIST:             # <<<<<<<<<<<<<<
+ *         exc = FileExistsError
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":36
+ *         exc = FileExistsError
+ * 
+ *     elif uverr == uv.UV_ENOENT:             # <<<<<<<<<<<<<<
+ *         exc = FileNotFoundError
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_uverr == UV_ENOENT) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/errors.pyx":37
+ * 
+ *     elif uverr == uv.UV_ENOENT:
+ *         exc = FileNotFoundError             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EINTR:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FileNotFoundError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 37, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":36
+ *         exc = FileExistsError
+ * 
+ *     elif uverr == uv.UV_ENOENT:             # <<<<<<<<<<<<<<
+ *         exc = FileNotFoundError
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":39
+ *         exc = FileNotFoundError
+ * 
+ *     elif uverr == uv.UV_EINTR:             # <<<<<<<<<<<<<<
+ *         exc = InterruptedError
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_uverr == UV_EINTR) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/errors.pyx":40
+ * 
+ *     elif uverr == uv.UV_EINTR:
+ *         exc = InterruptedError             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EISDIR:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_InterruptedError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 40, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":39
+ *         exc = FileNotFoundError
+ * 
+ *     elif uverr == uv.UV_EINTR:             # <<<<<<<<<<<<<<
+ *         exc = InterruptedError
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":42
+ *         exc = InterruptedError
+ * 
+ *     elif uverr == uv.UV_EISDIR:             # <<<<<<<<<<<<<<
+ *         exc = IsADirectoryError
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_uverr == UV_EISDIR) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/errors.pyx":43
+ * 
+ *     elif uverr == uv.UV_EISDIR:
+ *         exc = IsADirectoryError             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_ESRCH:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_IsADirectoryError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 43, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":42
+ *         exc = InterruptedError
+ * 
+ *     elif uverr == uv.UV_EISDIR:             # <<<<<<<<<<<<<<
+ *         exc = IsADirectoryError
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":45
+ *         exc = IsADirectoryError
+ * 
+ *     elif uverr == uv.UV_ESRCH:             # <<<<<<<<<<<<<<
+ *         exc = ProcessLookupError
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_uverr == UV_ESRCH) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/errors.pyx":46
+ * 
+ *     elif uverr == uv.UV_ESRCH:
+ *         exc = ProcessLookupError             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_ETIMEDOUT:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ProcessLookupError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 46, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":45
+ *         exc = IsADirectoryError
+ * 
+ *     elif uverr == uv.UV_ESRCH:             # <<<<<<<<<<<<<<
+ *         exc = ProcessLookupError
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":48
+ *         exc = ProcessLookupError
+ * 
+ *     elif uverr == uv.UV_ETIMEDOUT:             # <<<<<<<<<<<<<<
+ *         exc = TimeoutError
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_uverr == UV_ETIMEDOUT) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/errors.pyx":49
+ * 
+ *     elif uverr == uv.UV_ETIMEDOUT:
+ *         exc = TimeoutError             # <<<<<<<<<<<<<<
+ * 
+ *     return exc(oserr, __strerr(oserr))
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_TimeoutError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 49, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/errors.pyx":48
+ *         exc = ProcessLookupError
+ * 
+ *     elif uverr == uv.UV_ETIMEDOUT:             # <<<<<<<<<<<<<<
+ *         exc = TimeoutError
+ * 
+ */
+  }
+  __pyx_L3:;
+
+  /* "uvloop/errors.pyx":51
+ *         exc = TimeoutError
+ * 
+ *     return exc(oserr, __strerr(oserr))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_oserr); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __pyx_f_6uvloop_4loop___strerr(__pyx_v_oserr); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_INCREF(__pyx_v_exc);
+  __pyx_t_7 = __pyx_v_exc; __pyx_t_8 = NULL;
+  __pyx_t_1 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+    if (likely(__pyx_t_8)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_8);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_7, function);
+      __pyx_t_1 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_7)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_5, __pyx_t_6};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_1, 2+__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 51, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_5, __pyx_t_6};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_1, 2+__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 51, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_9 = PyTuple_New(2+__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 51, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    if (__pyx_t_8) {
+      __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_1, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_1, __pyx_t_6);
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 51, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/errors.pyx":5
+ * 
+ * 
+ * cdef __convert_python_error(int uverr):             # <<<<<<<<<<<<<<
+ *     # XXX Won't work for Windows:
+ *     # From libuv docs:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.__convert_python_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/errors.pyx":54
+ * 
+ * 
+ * cdef int __convert_socket_error(int uverr):             # <<<<<<<<<<<<<<
+ *     cdef int sock_err = 0
+ * 
+ */
+
+static int __pyx_f_6uvloop_4loop___convert_socket_error(int __pyx_v_uverr) {
+  int __pyx_v_sock_err;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__convert_socket_error", 0);
+
+  /* "uvloop/errors.pyx":55
+ * 
+ * cdef int __convert_socket_error(int uverr):
+ *     cdef int sock_err = 0             # <<<<<<<<<<<<<<
+ * 
+ *     if uverr == uv.UV_EAI_ADDRFAMILY:
+ */
+  __pyx_v_sock_err = 0;
+
+  /* "uvloop/errors.pyx":57
+ *     cdef int sock_err = 0
+ * 
+ *     if uverr == uv.UV_EAI_ADDRFAMILY:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_ADDRFAMILY
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_ADDRFAMILY) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":58
+ * 
+ *     if uverr == uv.UV_EAI_ADDRFAMILY:
+ *         sock_err = socket_EAI_ADDRFAMILY             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_AGAIN:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_ADDRFAMILY;
+
+    /* "uvloop/errors.pyx":57
+ *     cdef int sock_err = 0
+ * 
+ *     if uverr == uv.UV_EAI_ADDRFAMILY:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_ADDRFAMILY
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":60
+ *         sock_err = socket_EAI_ADDRFAMILY
+ * 
+ *     elif uverr == uv.UV_EAI_AGAIN:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_AGAIN
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_AGAIN) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":61
+ * 
+ *     elif uverr == uv.UV_EAI_AGAIN:
+ *         sock_err = socket_EAI_AGAIN             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_BADFLAGS:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_AGAIN;
+
+    /* "uvloop/errors.pyx":60
+ *         sock_err = socket_EAI_ADDRFAMILY
+ * 
+ *     elif uverr == uv.UV_EAI_AGAIN:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_AGAIN
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":63
+ *         sock_err = socket_EAI_AGAIN
+ * 
+ *     elif uverr == uv.UV_EAI_BADFLAGS:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_BADFLAGS
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_BADFLAGS) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":64
+ * 
+ *     elif uverr == uv.UV_EAI_BADFLAGS:
+ *         sock_err = socket_EAI_BADFLAGS             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_BADHINTS:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_BADFLAGS;
+
+    /* "uvloop/errors.pyx":63
+ *         sock_err = socket_EAI_AGAIN
+ * 
+ *     elif uverr == uv.UV_EAI_BADFLAGS:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_BADFLAGS
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":66
+ *         sock_err = socket_EAI_BADFLAGS
+ * 
+ *     elif uverr == uv.UV_EAI_BADHINTS:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_BADHINTS
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_BADHINTS) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":67
+ * 
+ *     elif uverr == uv.UV_EAI_BADHINTS:
+ *         sock_err = socket_EAI_BADHINTS             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_CANCELED:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_BADHINTS;
+
+    /* "uvloop/errors.pyx":66
+ *         sock_err = socket_EAI_BADFLAGS
+ * 
+ *     elif uverr == uv.UV_EAI_BADHINTS:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_BADHINTS
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":69
+ *         sock_err = socket_EAI_BADHINTS
+ * 
+ *     elif uverr == uv.UV_EAI_CANCELED:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_CANCELED
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_CANCELED) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":70
+ * 
+ *     elif uverr == uv.UV_EAI_CANCELED:
+ *         sock_err = socket_EAI_CANCELED             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_FAIL:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_CANCELED;
+
+    /* "uvloop/errors.pyx":69
+ *         sock_err = socket_EAI_BADHINTS
+ * 
+ *     elif uverr == uv.UV_EAI_CANCELED:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_CANCELED
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":72
+ *         sock_err = socket_EAI_CANCELED
+ * 
+ *     elif uverr == uv.UV_EAI_FAIL:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_FAIL
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_FAIL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":73
+ * 
+ *     elif uverr == uv.UV_EAI_FAIL:
+ *         sock_err = socket_EAI_FAIL             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_FAMILY:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_FAIL;
+
+    /* "uvloop/errors.pyx":72
+ *         sock_err = socket_EAI_CANCELED
+ * 
+ *     elif uverr == uv.UV_EAI_FAIL:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_FAIL
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":75
+ *         sock_err = socket_EAI_FAIL
+ * 
+ *     elif uverr == uv.UV_EAI_FAMILY:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_FAMILY
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_FAMILY) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":76
+ * 
+ *     elif uverr == uv.UV_EAI_FAMILY:
+ *         sock_err = socket_EAI_FAMILY             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_MEMORY:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_FAMILY;
+
+    /* "uvloop/errors.pyx":75
+ *         sock_err = socket_EAI_FAIL
+ * 
+ *     elif uverr == uv.UV_EAI_FAMILY:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_FAMILY
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":78
+ *         sock_err = socket_EAI_FAMILY
+ * 
+ *     elif uverr == uv.UV_EAI_MEMORY:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_MEMORY
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_MEMORY) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":79
+ * 
+ *     elif uverr == uv.UV_EAI_MEMORY:
+ *         sock_err = socket_EAI_MEMORY             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_NODATA:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_MEMORY;
+
+    /* "uvloop/errors.pyx":78
+ *         sock_err = socket_EAI_FAMILY
+ * 
+ *     elif uverr == uv.UV_EAI_MEMORY:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_MEMORY
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":81
+ *         sock_err = socket_EAI_MEMORY
+ * 
+ *     elif uverr == uv.UV_EAI_NODATA:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_NODATA
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_NODATA) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":82
+ * 
+ *     elif uverr == uv.UV_EAI_NODATA:
+ *         sock_err = socket_EAI_NODATA             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_NONAME:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_NODATA;
+
+    /* "uvloop/errors.pyx":81
+ *         sock_err = socket_EAI_MEMORY
+ * 
+ *     elif uverr == uv.UV_EAI_NODATA:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_NODATA
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":84
+ *         sock_err = socket_EAI_NODATA
+ * 
+ *     elif uverr == uv.UV_EAI_NONAME:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_NONAME
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_NONAME) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":85
+ * 
+ *     elif uverr == uv.UV_EAI_NONAME:
+ *         sock_err = socket_EAI_NONAME             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_OVERFLOW:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_NONAME;
+
+    /* "uvloop/errors.pyx":84
+ *         sock_err = socket_EAI_NODATA
+ * 
+ *     elif uverr == uv.UV_EAI_NONAME:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_NONAME
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":87
+ *         sock_err = socket_EAI_NONAME
+ * 
+ *     elif uverr == uv.UV_EAI_OVERFLOW:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_OVERFLOW
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_OVERFLOW) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":88
+ * 
+ *     elif uverr == uv.UV_EAI_OVERFLOW:
+ *         sock_err = socket_EAI_OVERFLOW             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_PROTOCOL:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_OVERFLOW;
+
+    /* "uvloop/errors.pyx":87
+ *         sock_err = socket_EAI_NONAME
+ * 
+ *     elif uverr == uv.UV_EAI_OVERFLOW:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_OVERFLOW
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":90
+ *         sock_err = socket_EAI_OVERFLOW
+ * 
+ *     elif uverr == uv.UV_EAI_PROTOCOL:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_PROTOCOL
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_PROTOCOL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":91
+ * 
+ *     elif uverr == uv.UV_EAI_PROTOCOL:
+ *         sock_err = socket_EAI_PROTOCOL             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_SERVICE:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_PROTOCOL;
+
+    /* "uvloop/errors.pyx":90
+ *         sock_err = socket_EAI_OVERFLOW
+ * 
+ *     elif uverr == uv.UV_EAI_PROTOCOL:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_PROTOCOL
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":93
+ *         sock_err = socket_EAI_PROTOCOL
+ * 
+ *     elif uverr == uv.UV_EAI_SERVICE:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_SERVICE
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_SERVICE) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":94
+ * 
+ *     elif uverr == uv.UV_EAI_SERVICE:
+ *         sock_err = socket_EAI_SERVICE             # <<<<<<<<<<<<<<
+ * 
+ *     elif uverr == uv.UV_EAI_SOCKTYPE:
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_SERVICE;
+
+    /* "uvloop/errors.pyx":93
+ *         sock_err = socket_EAI_PROTOCOL
+ * 
+ *     elif uverr == uv.UV_EAI_SERVICE:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_SERVICE
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/errors.pyx":96
+ *         sock_err = socket_EAI_SERVICE
+ * 
+ *     elif uverr == uv.UV_EAI_SOCKTYPE:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_SOCKTYPE
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_EAI_SOCKTYPE) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":97
+ * 
+ *     elif uverr == uv.UV_EAI_SOCKTYPE:
+ *         sock_err = socket_EAI_SOCKTYPE             # <<<<<<<<<<<<<<
+ * 
+ *     return sock_err
+ */
+    __pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_SOCKTYPE;
+
+    /* "uvloop/errors.pyx":96
+ *         sock_err = socket_EAI_SERVICE
+ * 
+ *     elif uverr == uv.UV_EAI_SOCKTYPE:             # <<<<<<<<<<<<<<
+ *         sock_err = socket_EAI_SOCKTYPE
+ * 
+ */
+  }
+  __pyx_L3:;
+
+  /* "uvloop/errors.pyx":99
+ *         sock_err = socket_EAI_SOCKTYPE
+ * 
+ *     return sock_err             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_sock_err;
+  goto __pyx_L0;
+
+  /* "uvloop/errors.pyx":54
+ * 
+ * 
+ * cdef int __convert_socket_error(int uverr):             # <<<<<<<<<<<<<<
+ *     cdef int sock_err = 0
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/errors.pyx":102
+ * 
+ * 
+ * cdef convert_error(int uverr):             # <<<<<<<<<<<<<<
+ *     cdef int sock_err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_convert_error(int __pyx_v_uverr) {
+  int __pyx_v_sock_err;
+  PyObject *__pyx_v_msg = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  char const *__pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("convert_error", 0);
+
+  /* "uvloop/errors.pyx":105
+ *     cdef int sock_err
+ * 
+ *     if uverr == uv.UV_ECANCELED:             # <<<<<<<<<<<<<<
+ *         return aio_CancelledError()
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_uverr == UV_ECANCELED) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":106
+ * 
+ *     if uverr == uv.UV_ECANCELED:
+ *         return aio_CancelledError()             # <<<<<<<<<<<<<<
+ * 
+ *     sock_err = __convert_socket_error(uverr)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_CancelledError);
+    __pyx_t_3 = __pyx_v_6uvloop_4loop_aio_CancelledError; __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_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 106, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_r = __pyx_t_2;
+    __pyx_t_2 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/errors.pyx":105
+ *     cdef int sock_err
+ * 
+ *     if uverr == uv.UV_ECANCELED:             # <<<<<<<<<<<<<<
+ *         return aio_CancelledError()
+ * 
+ */
+  }
+
+  /* "uvloop/errors.pyx":108
+ *         return aio_CancelledError()
+ * 
+ *     sock_err = __convert_socket_error(uverr)             # <<<<<<<<<<<<<<
+ *     if sock_err:
+ *         msg = system.gai_strerror(sock_err).decode('utf-8')
+ */
+  __pyx_v_sock_err = __pyx_f_6uvloop_4loop___convert_socket_error(__pyx_v_uverr);
+
+  /* "uvloop/errors.pyx":109
+ * 
+ *     sock_err = __convert_socket_error(uverr)
+ *     if sock_err:             # <<<<<<<<<<<<<<
+ *         msg = system.gai_strerror(sock_err).decode('utf-8')
+ *         return socket_gaierror(sock_err, msg)
+ */
+  __pyx_t_1 = (__pyx_v_sock_err != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/errors.pyx":110
+ *     sock_err = __convert_socket_error(uverr)
+ *     if sock_err:
+ *         msg = system.gai_strerror(sock_err).decode('utf-8')             # <<<<<<<<<<<<<<
+ *         return socket_gaierror(sock_err, msg)
+ * 
+ */
+    __pyx_t_5 = gai_strerror(__pyx_v_sock_err);
+    __pyx_t_2 = __Pyx_decode_c_string(__pyx_t_5, 0, strlen(__pyx_t_5), NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 110, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_2);
+    __pyx_v_msg = __pyx_t_2;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/errors.pyx":111
+ *     if sock_err:
+ *         msg = system.gai_strerror(sock_err).decode('utf-8')
+ *         return socket_gaierror(sock_err, msg)             # <<<<<<<<<<<<<<
+ * 
+ *     return __convert_python_error(uverr)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_sock_err); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 111, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_gaierror);
+    __pyx_t_4 = __pyx_v_6uvloop_4loop_socket_gaierror; __pyx_t_6 = NULL;
+    __pyx_t_7 = 0;
+    if (CYTHON_UNPACK_METHODS && 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_4, function);
+        __pyx_t_7 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_v_msg};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 111, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __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_6, __pyx_t_3, __pyx_v_msg};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 111, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 111, __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_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3);
+      __Pyx_INCREF(__pyx_v_msg);
+      __Pyx_GIVEREF(__pyx_v_msg);
+      PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_msg);
+      __pyx_t_3 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 111, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_r = __pyx_t_2;
+    __pyx_t_2 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/errors.pyx":109
+ * 
+ *     sock_err = __convert_socket_error(uverr)
+ *     if sock_err:             # <<<<<<<<<<<<<<
+ *         msg = system.gai_strerror(sock_err).decode('utf-8')
+ *         return socket_gaierror(sock_err, msg)
+ */
+  }
+
+  /* "uvloop/errors.pyx":113
+ *         return socket_gaierror(sock_err, msg)
+ * 
+ *     return __convert_python_error(uverr)             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __pyx_f_6uvloop_4loop___convert_python_error(__pyx_v_uverr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/errors.pyx":102
+ * 
+ * 
+ * cdef convert_error(int uverr):             # <<<<<<<<<<<<<<
+ *     cdef int sock_err
+ * 
+ */
+
+  /* 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_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.convert_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_msg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":55
+ * 
+ * 
+ * cdef _is_sock_stream(sock_type):             # <<<<<<<<<<<<<<
+ *     if SOCK_NONBLOCK == -1:
+ *         return sock_type == uv.SOCK_STREAM
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop__is_sock_stream(PyObject *__pyx_v_sock_type) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_is_sock_stream", 0);
+
+  /* "uvloop/loop.pyx":56
+ * 
+ * cdef _is_sock_stream(sock_type):
+ *     if SOCK_NONBLOCK == -1:             # <<<<<<<<<<<<<<
+ *         return sock_type == uv.SOCK_STREAM
+ *     else:
+ */
+  __pyx_t_1 = ((__pyx_v_6uvloop_4loop_SOCK_NONBLOCK == -1L) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":57
+ * cdef _is_sock_stream(sock_type):
+ *     if SOCK_NONBLOCK == -1:
+ *         return sock_type == uv.SOCK_STREAM             # <<<<<<<<<<<<<<
+ *     else:
+ *         # Linux's socket.type is a bitmask that can include extra info
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __Pyx_PyInt_From_int(SOCK_STREAM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PyObject_RichCompare(__pyx_v_sock_type, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 57, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":56
+ * 
+ * cdef _is_sock_stream(sock_type):
+ *     if SOCK_NONBLOCK == -1:             # <<<<<<<<<<<<<<
+ *         return sock_type == uv.SOCK_STREAM
+ *     else:
+ */
+  }
+
+  /* "uvloop/loop.pyx":64
+ *         # https://github.com/torvalds/linux/blob/v4.13/include/linux/net.h#L77
+ *         # for more details.
+ *         return (sock_type & 0xF) == uv.SOCK_STREAM             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_3 = __Pyx_PyInt_AndObjC(__pyx_v_sock_type, __pyx_int_15, 0xF, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 64, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_2 = __Pyx_PyInt_From_int(SOCK_STREAM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 64, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "uvloop/loop.pyx":55
+ * 
+ * 
+ * cdef _is_sock_stream(sock_type):             # <<<<<<<<<<<<<<
+ *     if SOCK_NONBLOCK == -1:
+ *         return sock_type == uv.SOCK_STREAM
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop._is_sock_stream", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":67
+ * 
+ * 
+ * cdef _is_sock_dgram(sock_type):             # <<<<<<<<<<<<<<
+ *     if SOCK_NONBLOCK == -1:
+ *         return sock_type == uv.SOCK_DGRAM
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop__is_sock_dgram(PyObject *__pyx_v_sock_type) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_is_sock_dgram", 0);
+
+  /* "uvloop/loop.pyx":68
+ * 
+ * cdef _is_sock_dgram(sock_type):
+ *     if SOCK_NONBLOCK == -1:             # <<<<<<<<<<<<<<
+ *         return sock_type == uv.SOCK_DGRAM
+ *     else:
+ */
+  __pyx_t_1 = ((__pyx_v_6uvloop_4loop_SOCK_NONBLOCK == -1L) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":69
+ * cdef _is_sock_dgram(sock_type):
+ *     if SOCK_NONBLOCK == -1:
+ *         return sock_type == uv.SOCK_DGRAM             # <<<<<<<<<<<<<<
+ *     else:
+ *         # Read the comment in `_is_sock_stream`.
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __Pyx_PyInt_From_int(SOCK_DGRAM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PyObject_RichCompare(__pyx_v_sock_type, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":68
+ * 
+ * cdef _is_sock_dgram(sock_type):
+ *     if SOCK_NONBLOCK == -1:             # <<<<<<<<<<<<<<
+ *         return sock_type == uv.SOCK_DGRAM
+ *     else:
+ */
+  }
+
+  /* "uvloop/loop.pyx":72
+ *     else:
+ *         # Read the comment in `_is_sock_stream`.
+ *         return (sock_type & 0xF) == uv.SOCK_DGRAM             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_3 = __Pyx_PyInt_AndObjC(__pyx_v_sock_type, __pyx_int_15, 0xF, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_2 = __Pyx_PyInt_From_int(SOCK_DGRAM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 72, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "uvloop/loop.pyx":67
+ * 
+ * 
+ * cdef _is_sock_dgram(sock_type):             # <<<<<<<<<<<<<<
+ *     if SOCK_NONBLOCK == -1:
+ *         return sock_type == uv.SOCK_DGRAM
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop._is_sock_dgram", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":75
+ * 
+ * 
+ * cdef isfuture(obj):             # <<<<<<<<<<<<<<
+ *     if aio_isfuture is None:
+ *         return isinstance(obj, aio_Future)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_isfuture(PyObject *__pyx_v_obj) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  __Pyx_RefNannySetupContext("isfuture", 0);
+
+  /* "uvloop/loop.pyx":76
+ * 
+ * cdef isfuture(obj):
+ *     if aio_isfuture is None:             # <<<<<<<<<<<<<<
+ *         return isinstance(obj, aio_Future)
+ *     else:
+ */
+  __pyx_t_1 = (__pyx_v_6uvloop_4loop_aio_isfuture == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":77
+ * cdef isfuture(obj):
+ *     if aio_isfuture is None:
+ *         return isinstance(obj, aio_Future)             # <<<<<<<<<<<<<<
+ *     else:
+ *         return aio_isfuture(obj)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_3 = __pyx_v_6uvloop_4loop_aio_Future;
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_2 = PyObject_IsInstance(__pyx_v_obj, __pyx_t_3); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 77, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":76
+ * 
+ * cdef isfuture(obj):
+ *     if aio_isfuture is None:             # <<<<<<<<<<<<<<
+ *         return isinstance(obj, aio_Future)
+ *     else:
+ */
+  }
+
+  /* "uvloop/loop.pyx":79
+ *         return isinstance(obj, aio_Future)
+ *     else:
+ *         return aio_isfuture(obj)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_isfuture);
+    __pyx_t_4 = __pyx_v_6uvloop_4loop_aio_isfuture; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_obj) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_obj);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "uvloop/loop.pyx":75
+ * 
+ * 
+ * cdef isfuture(obj):             # <<<<<<<<<<<<<<
+ *     if aio_isfuture is None:
+ *         return isinstance(obj, aio_Future)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.isfuture", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":82
+ * 
+ * 
+ * cdef inline socket_inc_io_ref(sock):             # <<<<<<<<<<<<<<
+ *     if isinstance(sock, socket_socket):
+ *         sock._io_refs += 1
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_socket_inc_io_ref(PyObject *__pyx_v_sock) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("socket_inc_io_ref", 0);
+
+  /* "uvloop/loop.pyx":83
+ * 
+ * cdef inline socket_inc_io_ref(sock):
+ *     if isinstance(sock, socket_socket):             # <<<<<<<<<<<<<<
+ *         sock._io_refs += 1
+ * 
+ */
+  __pyx_t_1 = __pyx_v_6uvloop_4loop_socket_socket;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_sock, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 83, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":84
+ * cdef inline socket_inc_io_ref(sock):
+ *     if isinstance(sock, socket_socket):
+ *         sock._io_refs += 1             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_io_refs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 84, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_sock, __pyx_n_s_io_refs, __pyx_t_4) < 0) __PYX_ERR(0, 84, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":83
+ * 
+ * cdef inline socket_inc_io_ref(sock):
+ *     if isinstance(sock, socket_socket):             # <<<<<<<<<<<<<<
+ *         sock._io_refs += 1
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":82
+ * 
+ * 
+ * cdef inline socket_inc_io_ref(sock):             # <<<<<<<<<<<<<<
+ *     if isinstance(sock, socket_socket):
+ *         sock._io_refs += 1
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.socket_inc_io_ref", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":87
+ * 
+ * 
+ * cdef inline socket_dec_io_ref(sock):             # <<<<<<<<<<<<<<
+ *     if isinstance(sock, socket_socket):
+ *         sock._decref_socketios()
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_socket_dec_io_ref(PyObject *__pyx_v_sock) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("socket_dec_io_ref", 0);
+
+  /* "uvloop/loop.pyx":88
+ * 
+ * cdef inline socket_dec_io_ref(sock):
+ *     if isinstance(sock, socket_socket):             # <<<<<<<<<<<<<<
+ *         sock._decref_socketios()
+ * 
+ */
+  __pyx_t_1 = __pyx_v_6uvloop_4loop_socket_socket;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_sock, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 88, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":89
+ * cdef inline socket_dec_io_ref(sock):
+ *     if isinstance(sock, socket_socket):
+ *         sock._decref_socketios()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_decref_socketios); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 89, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":88
+ * 
+ * cdef inline socket_dec_io_ref(sock):
+ *     if isinstance(sock, socket_socket):             # <<<<<<<<<<<<<<
+ *         sock._decref_socketios()
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":87
+ * 
+ * 
+ * cdef inline socket_dec_io_ref(sock):             # <<<<<<<<<<<<<<
+ *     if isinstance(sock, socket_socket):
+ *         sock._decref_socketios()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.socket_dec_io_ref", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":92
+ * 
+ * 
+ * cdef inline run_in_context(context, method):             # <<<<<<<<<<<<<<
+ *     # This method is internally used to workaround a reference issue that in
+ *     # certain circumstances, inlined context.run() will not hold a reference to
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_run_in_context(PyObject *__pyx_v_context, PyObject *__pyx_v_method) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  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("run_in_context", 0);
+
+  /* "uvloop/loop.pyx":97
+ *     # the given method instance, which - if deallocated - will cause segault.
+ *     # See also: edgedb/edgedb#2222
+ *     Py_INCREF(method)             # <<<<<<<<<<<<<<
+ *     try:
+ *         return context.run(method)
+ */
+  Py_INCREF(__pyx_v_method);
+
+  /* "uvloop/loop.pyx":98
+ *     # See also: edgedb/edgedb#2222
+ *     Py_INCREF(method)
+ *     try:             # <<<<<<<<<<<<<<
+ *         return context.run(method)
+ *     finally:
+ */
+  /*try:*/ {
+
+    /* "uvloop/loop.pyx":99
+ *     Py_INCREF(method)
+ *     try:
+ *         return context.run(method)             # <<<<<<<<<<<<<<
+ *     finally:
+ *         Py_DECREF(method)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_context, __pyx_n_s_run); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L4_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_method) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_method);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L4_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_L3_return;
+  }
+
+  /* "uvloop/loop.pyx":101
+ *         return context.run(method)
+ *     finally:
+ *         Py_DECREF(method)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*finally:*/ {
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __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_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      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_XGOTREF(__pyx_t_12);
+      __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
+      {
+        Py_DECREF(__pyx_v_method);
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+      }
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __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_L3_return: {
+      __pyx_t_12 = __pyx_r;
+      __pyx_r = 0;
+      Py_DECREF(__pyx_v_method);
+      __pyx_r = __pyx_t_12;
+      __pyx_t_12 = 0;
+      goto __pyx_L0;
+    }
+  }
+
+  /* "uvloop/loop.pyx":92
+ * 
+ * 
+ * cdef inline run_in_context(context, method):             # <<<<<<<<<<<<<<
+ *     # This method is internally used to workaround a reference issue that in
+ *     # certain circumstances, inlined context.run() will not hold a reference to
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.run_in_context", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":104
+ * 
+ * 
+ * cdef inline run_in_context1(context, method, arg):             # <<<<<<<<<<<<<<
+ *     Py_INCREF(method)
+ *     try:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_run_in_context1(PyObject *__pyx_v_context, PyObject *__pyx_v_method, PyObject *__pyx_v_arg) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  char const *__pyx_t_7;
+  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;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("run_in_context1", 0);
+
+  /* "uvloop/loop.pyx":105
+ * 
+ * cdef inline run_in_context1(context, method, arg):
+ *     Py_INCREF(method)             # <<<<<<<<<<<<<<
+ *     try:
+ *         return context.run(method, arg)
+ */
+  Py_INCREF(__pyx_v_method);
+
+  /* "uvloop/loop.pyx":106
+ * cdef inline run_in_context1(context, method, arg):
+ *     Py_INCREF(method)
+ *     try:             # <<<<<<<<<<<<<<
+ *         return context.run(method, arg)
+ *     finally:
+ */
+  /*try:*/ {
+
+    /* "uvloop/loop.pyx":107
+ *     Py_INCREF(method)
+ *     try:
+ *         return context.run(method, arg)             # <<<<<<<<<<<<<<
+ *     finally:
+ *         Py_DECREF(method)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_context, __pyx_n_s_run); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L4_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = NULL;
+    __pyx_t_4 = 0;
+    if (CYTHON_UNPACK_METHODS && 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;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_method, __pyx_v_arg};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L4_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[3] = {__pyx_t_3, __pyx_v_method, __pyx_v_arg};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L4_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 107, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      if (__pyx_t_3) {
+        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_method);
+      __Pyx_GIVEREF(__pyx_v_method);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_method);
+      __Pyx_INCREF(__pyx_v_arg);
+      __Pyx_GIVEREF(__pyx_v_arg);
+      PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_arg);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_r = __pyx_t_1;
+    __pyx_t_1 = 0;
+    goto __pyx_L3_return;
+  }
+
+  /* "uvloop/loop.pyx":109
+ *         return context.run(method, arg)
+ *     finally:
+ *         Py_DECREF(method)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*finally:*/ {
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __pyx_t_4 = __pyx_lineno; __pyx_t_6 = __pyx_clineno; __pyx_t_7 = __pyx_filename;
+      {
+        Py_DECREF(__pyx_v_method);
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+      }
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_ErrRestore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_6; __pyx_filename = __pyx_t_7;
+      goto __pyx_L1_error;
+    }
+    __pyx_L3_return: {
+      __pyx_t_13 = __pyx_r;
+      __pyx_r = 0;
+      Py_DECREF(__pyx_v_method);
+      __pyx_r = __pyx_t_13;
+      __pyx_t_13 = 0;
+      goto __pyx_L0;
+    }
+  }
+
+  /* "uvloop/loop.pyx":104
+ * 
+ * 
+ * cdef inline run_in_context1(context, method, arg):             # <<<<<<<<<<<<<<
+ *     Py_INCREF(method)
+ *     try:
+ */
+
+  /* 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_5);
+  __Pyx_AddTraceback("uvloop.loop.run_in_context1", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":112
+ * 
+ * 
+ * cdef inline run_in_context2(context, method, arg1, arg2):             # <<<<<<<<<<<<<<
+ *     Py_INCREF(method)
+ *     try:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_run_in_context2(PyObject *__pyx_v_context, PyObject *__pyx_v_method, PyObject *__pyx_v_arg1, PyObject *__pyx_v_arg2) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  char const *__pyx_t_7;
+  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;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("run_in_context2", 0);
+
+  /* "uvloop/loop.pyx":113
+ * 
+ * cdef inline run_in_context2(context, method, arg1, arg2):
+ *     Py_INCREF(method)             # <<<<<<<<<<<<<<
+ *     try:
+ *         return context.run(method, arg1, arg2)
+ */
+  Py_INCREF(__pyx_v_method);
+
+  /* "uvloop/loop.pyx":114
+ * cdef inline run_in_context2(context, method, arg1, arg2):
+ *     Py_INCREF(method)
+ *     try:             # <<<<<<<<<<<<<<
+ *         return context.run(method, arg1, arg2)
+ *     finally:
+ */
+  /*try:*/ {
+
+    /* "uvloop/loop.pyx":115
+ *     Py_INCREF(method)
+ *     try:
+ *         return context.run(method, arg1, arg2)             # <<<<<<<<<<<<<<
+ *     finally:
+ *         Py_DECREF(method)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_context, __pyx_n_s_run); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 115, __pyx_L4_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = NULL;
+    __pyx_t_4 = 0;
+    if (CYTHON_UNPACK_METHODS && 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;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_v_method, __pyx_v_arg1, __pyx_v_arg2};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L4_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[4] = {__pyx_t_3, __pyx_v_method, __pyx_v_arg1, __pyx_v_arg2};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L4_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(3+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 115, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      if (__pyx_t_3) {
+        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_method);
+      __Pyx_GIVEREF(__pyx_v_method);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_method);
+      __Pyx_INCREF(__pyx_v_arg1);
+      __Pyx_GIVEREF(__pyx_v_arg1);
+      PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_arg1);
+      __Pyx_INCREF(__pyx_v_arg2);
+      __Pyx_GIVEREF(__pyx_v_arg2);
+      PyTuple_SET_ITEM(__pyx_t_5, 2+__pyx_t_4, __pyx_v_arg2);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_r = __pyx_t_1;
+    __pyx_t_1 = 0;
+    goto __pyx_L3_return;
+  }
+
+  /* "uvloop/loop.pyx":117
+ *         return context.run(method, arg1, arg2)
+ *     finally:
+ *         Py_DECREF(method)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*finally:*/ {
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __pyx_t_4 = __pyx_lineno; __pyx_t_6 = __pyx_clineno; __pyx_t_7 = __pyx_filename;
+      {
+        Py_DECREF(__pyx_v_method);
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+      }
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_ErrRestore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_6; __pyx_filename = __pyx_t_7;
+      goto __pyx_L1_error;
+    }
+    __pyx_L3_return: {
+      __pyx_t_13 = __pyx_r;
+      __pyx_r = 0;
+      Py_DECREF(__pyx_v_method);
+      __pyx_r = __pyx_t_13;
+      __pyx_t_13 = 0;
+      goto __pyx_L0;
+    }
+  }
+
+  /* "uvloop/loop.pyx":112
+ * 
+ * 
+ * cdef inline run_in_context2(context, method, arg1, arg2):             # <<<<<<<<<<<<<<
+ *     Py_INCREF(method)
+ *     try:
+ */
+
+  /* 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_5);
+  __Pyx_AddTraceback("uvloop.loop.run_in_context2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":127
+ * @cython.no_gc_clear
+ * cdef class Loop:
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_4Loop_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_4Loop_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop___cinit__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_4Loop___cinit__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  int __pyx_v_err;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "uvloop/loop.pyx":131
+ * 
+ *         # Install PyMem* memory allocators if they aren't installed yet.
+ *         __install_pymem()             # <<<<<<<<<<<<<<
+ * 
+ *         # Install pthread_atfork handlers
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___install_pymem(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":134
+ * 
+ *         # Install pthread_atfork handlers
+ *         __install_atfork()             # <<<<<<<<<<<<<<
+ * 
+ *         self.uvloop = <uv.uv_loop_t*>PyMem_RawMalloc(sizeof(uv.uv_loop_t))
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___install_atfork(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":136
+ *         __install_atfork()
+ * 
+ *         self.uvloop = <uv.uv_loop_t*>PyMem_RawMalloc(sizeof(uv.uv_loop_t))             # <<<<<<<<<<<<<<
+ *         if self.uvloop is NULL:
+ *             raise MemoryError()
+ */
+  __pyx_v_self->uvloop = ((uv_loop_t *)PyMem_RawMalloc((sizeof(uv_loop_t))));
+
+  /* "uvloop/loop.pyx":137
+ * 
+ *         self.uvloop = <uv.uv_loop_t*>PyMem_RawMalloc(sizeof(uv.uv_loop_t))
+ *         if self.uvloop is NULL:             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_self->uvloop == NULL) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/loop.pyx":138
+ *         self.uvloop = <uv.uv_loop_t*>PyMem_RawMalloc(sizeof(uv.uv_loop_t))
+ *         if self.uvloop is NULL:
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *         self.slow_callback_duration = 0.1
+ */
+    PyErr_NoMemory(); __PYX_ERR(0, 138, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":137
+ * 
+ *         self.uvloop = <uv.uv_loop_t*>PyMem_RawMalloc(sizeof(uv.uv_loop_t))
+ *         if self.uvloop is NULL:             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":140
+ *             raise MemoryError()
+ * 
+ *         self.slow_callback_duration = 0.1             # <<<<<<<<<<<<<<
+ * 
+ *         self._closed = 0
+ */
+  __Pyx_INCREF(__pyx_float_0_1);
+  __Pyx_GIVEREF(__pyx_float_0_1);
+  __Pyx_GOTREF(__pyx_v_self->slow_callback_duration);
+  __Pyx_DECREF(__pyx_v_self->slow_callback_duration);
+  __pyx_v_self->slow_callback_duration = __pyx_float_0_1;
+
+  /* "uvloop/loop.pyx":142
+ *         self.slow_callback_duration = 0.1
+ * 
+ *         self._closed = 0             # <<<<<<<<<<<<<<
+ *         self._debug = 0
+ *         self._thread_is_main = 0
+ */
+  __pyx_v_self->_closed = 0;
+
+  /* "uvloop/loop.pyx":143
+ * 
+ *         self._closed = 0
+ *         self._debug = 0             # <<<<<<<<<<<<<<
+ *         self._thread_is_main = 0
+ *         self._thread_id = 0
+ */
+  __pyx_v_self->_debug = 0;
+
+  /* "uvloop/loop.pyx":144
+ *         self._closed = 0
+ *         self._debug = 0
+ *         self._thread_is_main = 0             # <<<<<<<<<<<<<<
+ *         self._thread_id = 0
+ *         self._running = 0
+ */
+  __pyx_v_self->_thread_is_main = 0;
+
+  /* "uvloop/loop.pyx":145
+ *         self._debug = 0
+ *         self._thread_is_main = 0
+ *         self._thread_id = 0             # <<<<<<<<<<<<<<
+ *         self._running = 0
+ *         self._stopping = 0
+ */
+  __pyx_v_self->_thread_id = 0;
+
+  /* "uvloop/loop.pyx":146
+ *         self._thread_is_main = 0
+ *         self._thread_id = 0
+ *         self._running = 0             # <<<<<<<<<<<<<<
+ *         self._stopping = 0
+ * 
+ */
+  __pyx_v_self->_running = 0;
+
+  /* "uvloop/loop.pyx":147
+ *         self._thread_id = 0
+ *         self._running = 0
+ *         self._stopping = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._transports = weakref_WeakValueDictionary()
+ */
+  __pyx_v_self->_stopping = 0;
+
+  /* "uvloop/loop.pyx":149
+ *         self._stopping = 0
+ * 
+ *         self._transports = weakref_WeakValueDictionary()             # <<<<<<<<<<<<<<
+ *         self._processes = set()
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_weakref_WeakValueDictionary);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_weakref_WeakValueDictionary; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_transports);
+  __Pyx_DECREF(__pyx_v_self->_transports);
+  __pyx_v_self->_transports = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":150
+ * 
+ *         self._transports = weakref_WeakValueDictionary()
+ *         self._processes = set()             # <<<<<<<<<<<<<<
+ * 
+ *         # Used to keep a reference (and hence keep the fileobj alive)
+ */
+  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_processes);
+  __Pyx_DECREF(__pyx_v_self->_processes);
+  __pyx_v_self->_processes = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":155
+ *         # for as long as its registered by add_reader or add_writer.
+ *         # This is how the selector module and hence asyncio behaves.
+ *         self._fd_to_reader_fileobj = {}             # <<<<<<<<<<<<<<
+ *         self._fd_to_writer_fileobj = {}
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_fd_to_reader_fileobj);
+  __Pyx_DECREF(__pyx_v_self->_fd_to_reader_fileobj);
+  __pyx_v_self->_fd_to_reader_fileobj = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":156
+ *         # This is how the selector module and hence asyncio behaves.
+ *         self._fd_to_reader_fileobj = {}
+ *         self._fd_to_writer_fileobj = {}             # <<<<<<<<<<<<<<
+ * 
+ *         self._timers = set()
+ */
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_fd_to_writer_fileobj);
+  __Pyx_DECREF(__pyx_v_self->_fd_to_writer_fileobj);
+  __pyx_v_self->_fd_to_writer_fileobj = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":158
+ *         self._fd_to_writer_fileobj = {}
+ * 
+ *         self._timers = set()             # <<<<<<<<<<<<<<
+ *         self._polls = {}
+ * 
+ */
+  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_timers);
+  __Pyx_DECREF(__pyx_v_self->_timers);
+  __pyx_v_self->_timers = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":159
+ * 
+ *         self._timers = set()
+ *         self._polls = {}             # <<<<<<<<<<<<<<
+ * 
+ *         self._recv_buffer_in_use = 0
+ */
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_polls);
+  __Pyx_DECREF(__pyx_v_self->_polls);
+  __pyx_v_self->_polls = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":161
+ *         self._polls = {}
+ * 
+ *         self._recv_buffer_in_use = 0             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_loop_init(self.uvloop)
+ */
+  __pyx_v_self->_recv_buffer_in_use = 0;
+
+  /* "uvloop/loop.pyx":163
+ *         self._recv_buffer_in_use = 0
+ * 
+ *         err = uv.uv_loop_init(self.uvloop)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             raise convert_error(err)
+ */
+  __pyx_v_err = uv_loop_init(__pyx_v_self->uvloop);
+
+  /* "uvloop/loop.pyx":164
+ * 
+ *         err = uv.uv_loop_init(self.uvloop)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ *         self.uvloop.data = <void*> self
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/loop.pyx":165
+ *         err = uv.uv_loop_init(self.uvloop)
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ *         self.uvloop.data = <void*> self
+ * 
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __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, 165, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":164
+ * 
+ *         err = uv.uv_loop_init(self.uvloop)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ *         self.uvloop.data = <void*> self
+ */
+  }
+
+  /* "uvloop/loop.pyx":166
+ *         if err < 0:
+ *             raise convert_error(err)
+ *         self.uvloop.data = <void*> self             # <<<<<<<<<<<<<<
+ * 
+ *         self._init_debug_fields()
+ */
+  __pyx_v_self->uvloop->data = ((void *)__pyx_v_self);
+
+  /* "uvloop/loop.pyx":168
+ *         self.uvloop.data = <void*> self
+ * 
+ *         self._init_debug_fields()             # <<<<<<<<<<<<<<
+ * 
+ *         self.active_process_handler = None
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_init_debug_fields(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":170
+ *         self._init_debug_fields()
+ * 
+ *         self.active_process_handler = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._last_error = None
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->active_process_handler);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->active_process_handler));
+  __pyx_v_self->active_process_handler = ((struct __pyx_obj_6uvloop_4loop_UVProcess *)Py_None);
+
+  /* "uvloop/loop.pyx":172
+ *         self.active_process_handler = None
+ * 
+ *         self._last_error = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._task_factory = None
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_last_error);
+  __Pyx_DECREF(__pyx_v_self->_last_error);
+  __pyx_v_self->_last_error = Py_None;
+
+  /* "uvloop/loop.pyx":174
+ *         self._last_error = None
+ * 
+ *         self._task_factory = None             # <<<<<<<<<<<<<<
+ *         self._exception_handler = None
+ *         self._default_executor = None
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_task_factory);
+  __Pyx_DECREF(__pyx_v_self->_task_factory);
+  __pyx_v_self->_task_factory = Py_None;
+
+  /* "uvloop/loop.pyx":175
+ * 
+ *         self._task_factory = None
+ *         self._exception_handler = None             # <<<<<<<<<<<<<<
+ *         self._default_executor = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_exception_handler);
+  __Pyx_DECREF(__pyx_v_self->_exception_handler);
+  __pyx_v_self->_exception_handler = Py_None;
+
+  /* "uvloop/loop.pyx":176
+ *         self._task_factory = None
+ *         self._exception_handler = None
+ *         self._default_executor = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._queued_streams = set()
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_default_executor);
+  __Pyx_DECREF(__pyx_v_self->_default_executor);
+  __pyx_v_self->_default_executor = Py_None;
+
+  /* "uvloop/loop.pyx":178
+ *         self._default_executor = None
+ * 
+ *         self._queued_streams = set()             # <<<<<<<<<<<<<<
+ *         self._ready = col_deque()
+ *         self._ready_len = 0
+ */
+  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_queued_streams);
+  __Pyx_DECREF(__pyx_v_self->_queued_streams);
+  __pyx_v_self->_queued_streams = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":179
+ * 
+ *         self._queued_streams = set()
+ *         self._ready = col_deque()             # <<<<<<<<<<<<<<
+ *         self._ready_len = 0
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_col_deque);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_col_deque; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_ready);
+  __Pyx_DECREF(__pyx_v_self->_ready);
+  __pyx_v_self->_ready = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":180
+ *         self._queued_streams = set()
+ *         self._ready = col_deque()
+ *         self._ready_len = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self.handler_async = UVAsync.new(
+ */
+  __pyx_v_self->_ready_len = 0;
+
+  /* "uvloop/loop.pyx":182
+ *         self._ready_len = 0
+ * 
+ *         self.handler_async = UVAsync.new(             # <<<<<<<<<<<<<<
+ *             self, <method_t>self._on_wake, self)
+ * 
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_7UVAsync_new(__pyx_v_self, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_on_wake), ((PyObject *)__pyx_v_self))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->handler_async);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->handler_async));
+  __pyx_v_self->handler_async = ((struct __pyx_obj_6uvloop_4loop_UVAsync *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":187
+ *         self.handler_idle = UVIdle.new(
+ *             self,
+ *             new_MethodHandle(             # <<<<<<<<<<<<<<
+ *                 self, "loop._on_idle", <method_t>self._on_idle, None, self))
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_new_MethodHandle(__pyx_v_self, __pyx_kp_u_loop__on_idle, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_on_idle), Py_None, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 187, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":185
+ *             self, <method_t>self._on_wake, self)
+ * 
+ *         self.handler_idle = UVIdle.new(             # <<<<<<<<<<<<<<
+ *             self,
+ *             new_MethodHandle(
+ */
+  __pyx_t_3 = ((PyObject *)__pyx_f_6uvloop_4loop_6UVIdle_new(__pyx_v_self, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 185, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_v_self->handler_idle);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->handler_idle));
+  __pyx_v_self->handler_idle = ((struct __pyx_obj_6uvloop_4loop_UVIdle *)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":194
+ *         self.handler_check__exec_writes = UVCheck.new(
+ *             self,
+ *             new_MethodHandle(             # <<<<<<<<<<<<<<
+ *                 self, "loop._exec_queued_writes",
+ *                 <method_t>self._exec_queued_writes, None, self))
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_new_MethodHandle(__pyx_v_self, __pyx_kp_u_loop__exec_queued_writes, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_exec_queued_writes), Py_None, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 194, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":192
+ *         # Needed to call `UVStream._exec_write` for writes scheduled
+ *         # during `Protocol.data_received`.
+ *         self.handler_check__exec_writes = UVCheck.new(             # <<<<<<<<<<<<<<
+ *             self,
+ *             new_MethodHandle(
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_7UVCheck_new(__pyx_v_self, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_3))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->handler_check__exec_writes);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->handler_check__exec_writes));
+  __pyx_v_self->handler_check__exec_writes = ((struct __pyx_obj_6uvloop_4loop_UVCheck *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":198
+ *                 <method_t>self._exec_queued_writes, None, self))
+ * 
+ *         self._signals = set()             # <<<<<<<<<<<<<<
+ *         self._ssock = self._csock = None
+ *         self._signal_handlers = {}
+ */
+  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_signals);
+  __Pyx_DECREF(__pyx_v_self->_signals);
+  __pyx_v_self->_signals = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":199
+ * 
+ *         self._signals = set()
+ *         self._ssock = self._csock = None             # <<<<<<<<<<<<<<
+ *         self._signal_handlers = {}
+ *         self._listening_signals = False
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_ssock);
+  __Pyx_DECREF(__pyx_v_self->_ssock);
+  __pyx_v_self->_ssock = Py_None;
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_csock);
+  __Pyx_DECREF(__pyx_v_self->_csock);
+  __pyx_v_self->_csock = Py_None;
+
+  /* "uvloop/loop.pyx":200
+ *         self._signals = set()
+ *         self._ssock = self._csock = None
+ *         self._signal_handlers = {}             # <<<<<<<<<<<<<<
+ *         self._listening_signals = False
+ *         self._old_signal_wakeup_id = -1
+ */
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_signal_handlers);
+  __Pyx_DECREF(__pyx_v_self->_signal_handlers);
+  __pyx_v_self->_signal_handlers = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":201
+ *         self._ssock = self._csock = None
+ *         self._signal_handlers = {}
+ *         self._listening_signals = False             # <<<<<<<<<<<<<<
+ *         self._old_signal_wakeup_id = -1
+ * 
+ */
+  __pyx_v_self->_listening_signals = 0;
+
+  /* "uvloop/loop.pyx":202
+ *         self._signal_handlers = {}
+ *         self._listening_signals = False
+ *         self._old_signal_wakeup_id = -1             # <<<<<<<<<<<<<<
+ * 
+ *         self._coroutine_debug_set = False
+ */
+  __pyx_v_self->_old_signal_wakeup_id = -1;
+
+  /* "uvloop/loop.pyx":204
+ *         self._old_signal_wakeup_id = -1
+ * 
+ *         self._coroutine_debug_set = False             # <<<<<<<<<<<<<<
+ * 
+ *         # A weak set of all asynchronous generators that are
+ */
+  __pyx_v_self->_coroutine_debug_set = 0;
+
+  /* "uvloop/loop.pyx":208
+ *         # A weak set of all asynchronous generators that are
+ *         # being iterated by the loop.
+ *         self._asyncgens = weakref_WeakSet()             # <<<<<<<<<<<<<<
+ * 
+ *         # Set to True when `loop.shutdown_asyncgens` is called.
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_weakref_WeakSet);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_weakref_WeakSet; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_asyncgens);
+  __Pyx_DECREF(__pyx_v_self->_asyncgens);
+  __pyx_v_self->_asyncgens = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":211
+ * 
+ *         # Set to True when `loop.shutdown_asyncgens` is called.
+ *         self._asyncgens_shutdown_called = False             # <<<<<<<<<<<<<<
+ *         # Set to True when `loop.shutdown_default_executor` is called.
+ *         self._executor_shutdown_called = False
+ */
+  __pyx_v_self->_asyncgens_shutdown_called = 0;
+
+  /* "uvloop/loop.pyx":213
+ *         self._asyncgens_shutdown_called = False
+ *         # Set to True when `loop.shutdown_default_executor` is called.
+ *         self._executor_shutdown_called = False             # <<<<<<<<<<<<<<
+ * 
+ *         self._servers = set()
+ */
+  __pyx_v_self->_executor_shutdown_called = 0;
+
+  /* "uvloop/loop.pyx":215
+ *         self._executor_shutdown_called = False
+ * 
+ *         self._servers = set()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _is_main_thread(self):
+ */
+  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_servers);
+  __Pyx_DECREF(__pyx_v_self->_servers);
+  __pyx_v_self->_servers = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":127
+ * @cython.no_gc_clear
+ * cdef class Loop:
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Loop.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":217
+ *         self._servers = set()
+ * 
+ *     cdef inline _is_main_thread(self):             # <<<<<<<<<<<<<<
+ *         return MAIN_THREAD_ID == PyThread_get_thread_ident()
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__is_main_thread(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__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("_is_main_thread", 0);
+
+  /* "uvloop/loop.pyx":218
+ * 
+ *     cdef inline _is_main_thread(self):
+ *         return MAIN_THREAD_ID == PyThread_get_thread_ident()             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong((__pyx_v_6uvloop_4loop_MAIN_THREAD_ID == PyThread_get_thread_ident())); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":217
+ *         self._servers = set()
+ * 
+ *     cdef inline _is_main_thread(self):             # <<<<<<<<<<<<<<
+ *         return MAIN_THREAD_ID == PyThread_get_thread_ident()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._is_main_thread", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":220
+ *         return MAIN_THREAD_ID == PyThread_get_thread_ident()
+ * 
+ *     def __init__(self):             # <<<<<<<<<<<<<<
+ *         self.set_debug((not sys_ignore_environment
+ *                         and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_4Loop_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_4Loop_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__init__", 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, "__init__", 0))) return -1;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_2__init__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_4Loop_2__init__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  /* "uvloop/loop.pyx":221
+ * 
+ *     def __init__(self):
+ *         self.set_debug((not sys_ignore_environment             # <<<<<<<<<<<<<<
+ *                         and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_debug); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 221, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/loop.pyx":222
+ *     def __init__(self):
+ *         self.set_debug((not sys_ignore_environment
+ *                         and bool(os_environ.get('PYTHONASYNCIODEBUG'))))             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_6uvloop_4loop_sys_ignore_environment); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 221, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":221
+ * 
+ *     def __init__(self):
+ *         self.set_debug((not sys_ignore_environment             # <<<<<<<<<<<<<<
+ *                         and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
+ * 
+ */
+  __pyx_t_5 = (!__pyx_t_4);
+  if (__pyx_t_5) {
+  } else {
+    __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 221, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_3 = __pyx_t_6;
+    __pyx_t_6 = 0;
+    goto __pyx_L3_bool_binop_done;
+  }
+
+  /* "uvloop/loop.pyx":222
+ *     def __init__(self):
+ *         self.set_debug((not sys_ignore_environment
+ *                         and bool(os_environ.get('PYTHONASYNCIODEBUG'))))             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_os_environ, __pyx_n_s_get); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+    if (likely(__pyx_t_8)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_8);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_7, function);
+    }
+  }
+  __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_n_u_PYTHONASYNCIODEBUG) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_n_u_PYTHONASYNCIODEBUG);
+  __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyBool_FromLong((!(!__pyx_t_5))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_INCREF(__pyx_t_6);
+  __pyx_t_3 = __pyx_t_6;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_L3_bool_binop_done:;
+  __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 221, __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;
+
+  /* "uvloop/loop.pyx":220
+ *         return MAIN_THREAD_ID == PyThread_get_thread_ident()
+ * 
+ *     def __init__(self):             # <<<<<<<<<<<<<<
+ *         self.set_debug((not sys_ignore_environment
+ *                         and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  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_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.Loop.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":224
+ *                         and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self._running == 1:
+ *             raise RuntimeError('deallocating a running event loop!')
+ */
+
+/* Python wrapper */
+static void __pyx_pw_6uvloop_4loop_4Loop_5__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_6uvloop_4loop_4Loop_5__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_6uvloop_4loop_4Loop_4__dealloc__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_6uvloop_4loop_4Loop_4__dealloc__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "uvloop/loop.pyx":225
+ * 
+ *     def __dealloc__(self):
+ *         if self._running == 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('deallocating a running event loop!')
+ *         if self._closed == 0:
+ */
+  __pyx_t_1 = ((__pyx_v_self->_running == 1) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":226
+ *     def __dealloc__(self):
+ *         if self._running == 1:
+ *             raise RuntimeError('deallocating a running event loop!')             # <<<<<<<<<<<<<<
+ *         if self._closed == 0:
+ *             aio_logger.error("deallocating an open event loop")
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __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(0, 226, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":225
+ * 
+ *     def __dealloc__(self):
+ *         if self._running == 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('deallocating a running event loop!')
+ *         if self._closed == 0:
+ */
+  }
+
+  /* "uvloop/loop.pyx":227
+ *         if self._running == 1:
+ *             raise RuntimeError('deallocating a running event loop!')
+ *         if self._closed == 0:             # <<<<<<<<<<<<<<
+ *             aio_logger.error("deallocating an open event loop")
+ *             return
+ */
+  __pyx_t_1 = ((__pyx_v_self->_closed == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":228
+ *             raise RuntimeError('deallocating a running event loop!')
+ *         if self._closed == 0:
+ *             aio_logger.error("deallocating an open event loop")             # <<<<<<<<<<<<<<
+ *             return
+ *         PyMem_RawFree(self.uvloop)
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_deallocating_an_open_event_loop) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_deallocating_an_open_event_loop);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":229
+ *         if self._closed == 0:
+ *             aio_logger.error("deallocating an open event loop")
+ *             return             # <<<<<<<<<<<<<<
+ *         PyMem_RawFree(self.uvloop)
+ *         self.uvloop = NULL
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":227
+ *         if self._running == 1:
+ *             raise RuntimeError('deallocating a running event loop!')
+ *         if self._closed == 0:             # <<<<<<<<<<<<<<
+ *             aio_logger.error("deallocating an open event loop")
+ *             return
+ */
+  }
+
+  /* "uvloop/loop.pyx":230
+ *             aio_logger.error("deallocating an open event loop")
+ *             return
+ *         PyMem_RawFree(self.uvloop)             # <<<<<<<<<<<<<<
+ *         self.uvloop = NULL
+ * 
+ */
+  PyMem_RawFree(__pyx_v_self->uvloop);
+
+  /* "uvloop/loop.pyx":231
+ *             return
+ *         PyMem_RawFree(self.uvloop)
+ *         self.uvloop = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _init_debug_fields(self):
+ */
+  __pyx_v_self->uvloop = NULL;
+
+  /* "uvloop/loop.pyx":224
+ *                         and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self._running == 1:
+ *             raise RuntimeError('deallocating a running event loop!')
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_WriteUnraisable("uvloop.loop.Loop.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/loop.pyx":233
+ *         self.uvloop = NULL
+ * 
+ *     cdef _init_debug_fields(self):             # <<<<<<<<<<<<<<
+ *         self._debug_cc = bool(UVLOOP_DEBUG)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__init_debug_fields(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init_debug_fields", 0);
+
+  /* "uvloop/loop.pyx":234
+ * 
+ *     cdef _init_debug_fields(self):
+ *         self._debug_cc = bool(UVLOOP_DEBUG)             # <<<<<<<<<<<<<<
+ * 
+ *         if UVLOOP_DEBUG:
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_int(UVLOOP_DEBUG); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __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, 234, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_self->_debug_cc = (!(!__pyx_t_2));
+
+  /* "uvloop/loop.pyx":236
+ *         self._debug_cc = bool(UVLOOP_DEBUG)
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             self._debug_handles_current = col_Counter()
+ *             self._debug_handles_closed = col_Counter()
+ */
+  __pyx_t_2 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":237
+ * 
+ *         if UVLOOP_DEBUG:
+ *             self._debug_handles_current = col_Counter()             # <<<<<<<<<<<<<<
+ *             self._debug_handles_closed = col_Counter()
+ *             self._debug_handles_total = col_Counter()
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_col_Counter);
+    __pyx_t_3 = __pyx_v_6uvloop_4loop_col_Counter; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GIVEREF(__pyx_t_1);
+    __Pyx_GOTREF(__pyx_v_self->_debug_handles_current);
+    __Pyx_DECREF(__pyx_v_self->_debug_handles_current);
+    __pyx_v_self->_debug_handles_current = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":238
+ *         if UVLOOP_DEBUG:
+ *             self._debug_handles_current = col_Counter()
+ *             self._debug_handles_closed = col_Counter()             # <<<<<<<<<<<<<<
+ *             self._debug_handles_total = col_Counter()
+ *         else:
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_col_Counter);
+    __pyx_t_3 = __pyx_v_6uvloop_4loop_col_Counter; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GIVEREF(__pyx_t_1);
+    __Pyx_GOTREF(__pyx_v_self->_debug_handles_closed);
+    __Pyx_DECREF(__pyx_v_self->_debug_handles_closed);
+    __pyx_v_self->_debug_handles_closed = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":239
+ *             self._debug_handles_current = col_Counter()
+ *             self._debug_handles_closed = col_Counter()
+ *             self._debug_handles_total = col_Counter()             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._debug_handles_current = None
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_col_Counter);
+    __pyx_t_3 = __pyx_v_6uvloop_4loop_col_Counter; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GIVEREF(__pyx_t_1);
+    __Pyx_GOTREF(__pyx_v_self->_debug_handles_total);
+    __Pyx_DECREF(__pyx_v_self->_debug_handles_total);
+    __pyx_v_self->_debug_handles_total = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":236
+ *         self._debug_cc = bool(UVLOOP_DEBUG)
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             self._debug_handles_current = col_Counter()
+ *             self._debug_handles_closed = col_Counter()
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/loop.pyx":241
+ *             self._debug_handles_total = col_Counter()
+ *         else:
+ *             self._debug_handles_current = None             # <<<<<<<<<<<<<<
+ *             self._debug_handles_closed = None
+ *             self._debug_handles_total = None
+ */
+  /*else*/ {
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_debug_handles_current);
+    __Pyx_DECREF(__pyx_v_self->_debug_handles_current);
+    __pyx_v_self->_debug_handles_current = Py_None;
+
+    /* "uvloop/loop.pyx":242
+ *         else:
+ *             self._debug_handles_current = None
+ *             self._debug_handles_closed = None             # <<<<<<<<<<<<<<
+ *             self._debug_handles_total = None
+ * 
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_debug_handles_closed);
+    __Pyx_DECREF(__pyx_v_self->_debug_handles_closed);
+    __pyx_v_self->_debug_handles_closed = Py_None;
+
+    /* "uvloop/loop.pyx":243
+ *             self._debug_handles_current = None
+ *             self._debug_handles_closed = None
+ *             self._debug_handles_total = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._debug_uv_handles_total = 0
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_debug_handles_total);
+    __Pyx_DECREF(__pyx_v_self->_debug_handles_total);
+    __pyx_v_self->_debug_handles_total = Py_None;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/loop.pyx":245
+ *             self._debug_handles_total = None
+ * 
+ *         self._debug_uv_handles_total = 0             # <<<<<<<<<<<<<<
+ *         self._debug_uv_handles_freed = 0
+ * 
+ */
+  __pyx_v_self->_debug_uv_handles_total = 0;
+
+  /* "uvloop/loop.pyx":246
+ * 
+ *         self._debug_uv_handles_total = 0
+ *         self._debug_uv_handles_freed = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._debug_stream_read_cb_total = 0
+ */
+  __pyx_v_self->_debug_uv_handles_freed = 0;
+
+  /* "uvloop/loop.pyx":248
+ *         self._debug_uv_handles_freed = 0
+ * 
+ *         self._debug_stream_read_cb_total = 0             # <<<<<<<<<<<<<<
+ *         self._debug_stream_read_eof_total = 0
+ *         self._debug_stream_read_errors_total = 0
+ */
+  __pyx_v_self->_debug_stream_read_cb_total = 0;
+
+  /* "uvloop/loop.pyx":249
+ * 
+ *         self._debug_stream_read_cb_total = 0
+ *         self._debug_stream_read_eof_total = 0             # <<<<<<<<<<<<<<
+ *         self._debug_stream_read_errors_total = 0
+ *         self._debug_stream_read_cb_errors_total = 0
+ */
+  __pyx_v_self->_debug_stream_read_eof_total = 0;
+
+  /* "uvloop/loop.pyx":250
+ *         self._debug_stream_read_cb_total = 0
+ *         self._debug_stream_read_eof_total = 0
+ *         self._debug_stream_read_errors_total = 0             # <<<<<<<<<<<<<<
+ *         self._debug_stream_read_cb_errors_total = 0
+ *         self._debug_stream_read_eof_cb_errors_total = 0
+ */
+  __pyx_v_self->_debug_stream_read_errors_total = 0;
+
+  /* "uvloop/loop.pyx":251
+ *         self._debug_stream_read_eof_total = 0
+ *         self._debug_stream_read_errors_total = 0
+ *         self._debug_stream_read_cb_errors_total = 0             # <<<<<<<<<<<<<<
+ *         self._debug_stream_read_eof_cb_errors_total = 0
+ * 
+ */
+  __pyx_v_self->_debug_stream_read_cb_errors_total = 0;
+
+  /* "uvloop/loop.pyx":252
+ *         self._debug_stream_read_errors_total = 0
+ *         self._debug_stream_read_cb_errors_total = 0
+ *         self._debug_stream_read_eof_cb_errors_total = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._debug_stream_shutdown_errors_total = 0
+ */
+  __pyx_v_self->_debug_stream_read_eof_cb_errors_total = 0;
+
+  /* "uvloop/loop.pyx":254
+ *         self._debug_stream_read_eof_cb_errors_total = 0
+ * 
+ *         self._debug_stream_shutdown_errors_total = 0             # <<<<<<<<<<<<<<
+ *         self._debug_stream_listen_errors_total = 0
+ * 
+ */
+  __pyx_v_self->_debug_stream_shutdown_errors_total = 0;
+
+  /* "uvloop/loop.pyx":255
+ * 
+ *         self._debug_stream_shutdown_errors_total = 0
+ *         self._debug_stream_listen_errors_total = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._debug_stream_write_tries = 0
+ */
+  __pyx_v_self->_debug_stream_listen_errors_total = 0;
+
+  /* "uvloop/loop.pyx":257
+ *         self._debug_stream_listen_errors_total = 0
+ * 
+ *         self._debug_stream_write_tries = 0             # <<<<<<<<<<<<<<
+ *         self._debug_stream_write_errors_total = 0
+ *         self._debug_stream_write_ctx_total = 0
+ */
+  __pyx_v_self->_debug_stream_write_tries = 0;
+
+  /* "uvloop/loop.pyx":258
+ * 
+ *         self._debug_stream_write_tries = 0
+ *         self._debug_stream_write_errors_total = 0             # <<<<<<<<<<<<<<
+ *         self._debug_stream_write_ctx_total = 0
+ *         self._debug_stream_write_ctx_cnt = 0
+ */
+  __pyx_v_self->_debug_stream_write_errors_total = 0;
+
+  /* "uvloop/loop.pyx":259
+ *         self._debug_stream_write_tries = 0
+ *         self._debug_stream_write_errors_total = 0
+ *         self._debug_stream_write_ctx_total = 0             # <<<<<<<<<<<<<<
+ *         self._debug_stream_write_ctx_cnt = 0
+ *         self._debug_stream_write_cb_errors_total = 0
+ */
+  __pyx_v_self->_debug_stream_write_ctx_total = 0;
+
+  /* "uvloop/loop.pyx":260
+ *         self._debug_stream_write_errors_total = 0
+ *         self._debug_stream_write_ctx_total = 0
+ *         self._debug_stream_write_ctx_cnt = 0             # <<<<<<<<<<<<<<
+ *         self._debug_stream_write_cb_errors_total = 0
+ * 
+ */
+  __pyx_v_self->_debug_stream_write_ctx_cnt = 0;
+
+  /* "uvloop/loop.pyx":261
+ *         self._debug_stream_write_ctx_total = 0
+ *         self._debug_stream_write_ctx_cnt = 0
+ *         self._debug_stream_write_cb_errors_total = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._debug_cb_handles_total = 0
+ */
+  __pyx_v_self->_debug_stream_write_cb_errors_total = 0;
+
+  /* "uvloop/loop.pyx":263
+ *         self._debug_stream_write_cb_errors_total = 0
+ * 
+ *         self._debug_cb_handles_total = 0             # <<<<<<<<<<<<<<
+ *         self._debug_cb_handles_count = 0
+ * 
+ */
+  __pyx_v_self->_debug_cb_handles_total = 0;
+
+  /* "uvloop/loop.pyx":264
+ * 
+ *         self._debug_cb_handles_total = 0
+ *         self._debug_cb_handles_count = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._debug_cb_timer_handles_total = 0
+ */
+  __pyx_v_self->_debug_cb_handles_count = 0;
+
+  /* "uvloop/loop.pyx":266
+ *         self._debug_cb_handles_count = 0
+ * 
+ *         self._debug_cb_timer_handles_total = 0             # <<<<<<<<<<<<<<
+ *         self._debug_cb_timer_handles_count = 0
+ * 
+ */
+  __pyx_v_self->_debug_cb_timer_handles_total = 0;
+
+  /* "uvloop/loop.pyx":267
+ * 
+ *         self._debug_cb_timer_handles_total = 0
+ *         self._debug_cb_timer_handles_count = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._poll_read_events_total = 0
+ */
+  __pyx_v_self->_debug_cb_timer_handles_count = 0;
+
+  /* "uvloop/loop.pyx":269
+ *         self._debug_cb_timer_handles_count = 0
+ * 
+ *         self._poll_read_events_total = 0             # <<<<<<<<<<<<<<
+ *         self._poll_read_cb_errors_total = 0
+ *         self._poll_write_events_total = 0
+ */
+  __pyx_v_self->_poll_read_events_total = 0;
+
+  /* "uvloop/loop.pyx":270
+ * 
+ *         self._poll_read_events_total = 0
+ *         self._poll_read_cb_errors_total = 0             # <<<<<<<<<<<<<<
+ *         self._poll_write_events_total = 0
+ *         self._poll_write_cb_errors_total = 0
+ */
+  __pyx_v_self->_poll_read_cb_errors_total = 0;
+
+  /* "uvloop/loop.pyx":271
+ *         self._poll_read_events_total = 0
+ *         self._poll_read_cb_errors_total = 0
+ *         self._poll_write_events_total = 0             # <<<<<<<<<<<<<<
+ *         self._poll_write_cb_errors_total = 0
+ * 
+ */
+  __pyx_v_self->_poll_write_events_total = 0;
+
+  /* "uvloop/loop.pyx":272
+ *         self._poll_read_cb_errors_total = 0
+ *         self._poll_write_events_total = 0
+ *         self._poll_write_cb_errors_total = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._sock_try_write_total = 0
+ */
+  __pyx_v_self->_poll_write_cb_errors_total = 0;
+
+  /* "uvloop/loop.pyx":274
+ *         self._poll_write_cb_errors_total = 0
+ * 
+ *         self._sock_try_write_total = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._debug_exception_handler_cnt = 0
+ */
+  __pyx_v_self->_sock_try_write_total = 0;
+
+  /* "uvloop/loop.pyx":276
+ *         self._sock_try_write_total = 0
+ * 
+ *         self._debug_exception_handler_cnt = 0             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _setup_or_resume_signals(self):
+ */
+  __pyx_v_self->_debug_exception_handler_cnt = 0;
+
+  /* "uvloop/loop.pyx":233
+ *         self.uvloop = NULL
+ * 
+ *     cdef _init_debug_fields(self):             # <<<<<<<<<<<<<<
+ *         self._debug_cc = bool(UVLOOP_DEBUG)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Loop._init_debug_fields", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":278
+ *         self._debug_exception_handler_cnt = 0
+ * 
+ *     cdef _setup_or_resume_signals(self):             # <<<<<<<<<<<<<<
+ *         if not self._is_main_thread():
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__setup_or_resume_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_v_fileno = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *(*__pyx_t_7)(PyObject *);
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_setup_or_resume_signals", 0);
+
+  /* "uvloop/loop.pyx":279
+ * 
+ *     cdef _setup_or_resume_signals(self):
+ *         if not self._is_main_thread():             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__is_main_thread(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 279, __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, 279, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = ((!__pyx_t_2) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":280
+ *     cdef _setup_or_resume_signals(self):
+ *         if not self._is_main_thread():
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if self._listening_signals:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":279
+ * 
+ *     cdef _setup_or_resume_signals(self):
+ *         if not self._is_main_thread():             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":282
+ *             return
+ * 
+ *         if self._listening_signals:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('signals handling has been already setup')
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->_listening_signals != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/loop.pyx":283
+ * 
+ *         if self._listening_signals:
+ *             raise RuntimeError('signals handling has been already setup')             # <<<<<<<<<<<<<<
+ * 
+ *         if self._ssock is not None:
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 283, __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, 283, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":282
+ *             return
+ * 
+ *         if self._listening_signals:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('signals handling has been already setup')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":285
+ *             raise RuntimeError('signals handling has been already setup')
+ * 
+ *         if self._ssock is not None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('self-pipe exists before loop run')
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->_ssock != Py_None);
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/loop.pyx":286
+ * 
+ *         if self._ssock is not None:
+ *             raise RuntimeError('self-pipe exists before loop run')             # <<<<<<<<<<<<<<
+ * 
+ *         # Create a self-pipe and call set_signal_wakeup_fd() with one
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 286, __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, 286, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":285
+ *             raise RuntimeError('signals handling has been already setup')
+ * 
+ *         if self._ssock is not None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('self-pipe exists before loop run')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":293
+ *         # standard Python's one or or user set their own.)
+ * 
+ *         self._ssock, self._csock = socket_socketpair()             # <<<<<<<<<<<<<<
+ *         try:
+ *             self._ssock.setblocking(False)
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_socketpair);
+  __pyx_t_4 = __pyx_v_6uvloop_4loop_socket_socketpair; __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 293, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 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);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 293, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_4 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_5 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_5);
+    #else
+    __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 293, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 293, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    #endif
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 293, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext;
+    index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L6_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_4);
+    index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_5);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(0, 293, __pyx_L1_error)
+    __pyx_t_7 = NULL;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    goto __pyx_L7_unpacking_done;
+    __pyx_L6_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_7 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 293, __pyx_L1_error)
+    __pyx_L7_unpacking_done:;
+  }
+  __Pyx_GIVEREF(__pyx_t_4);
+  __Pyx_GOTREF(__pyx_v_self->_ssock);
+  __Pyx_DECREF(__pyx_v_self->_ssock);
+  __pyx_v_self->_ssock = __pyx_t_4;
+  __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_5);
+  __Pyx_GOTREF(__pyx_v_self->_csock);
+  __Pyx_DECREF(__pyx_v_self->_csock);
+  __pyx_v_self->_csock = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":294
+ * 
+ *         self._ssock, self._csock = socket_socketpair()
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._ssock.setblocking(False)
+ *             self._csock.setblocking(False)
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+    __Pyx_XGOTREF(__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_9);
+    __Pyx_XGOTREF(__pyx_t_10);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":295
+ *         self._ssock, self._csock = socket_socketpair()
+ *         try:
+ *             self._ssock.setblocking(False)             # <<<<<<<<<<<<<<
+ *             self._csock.setblocking(False)
+ * 
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ssock, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 295, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_4)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_4);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, Py_False) : __Pyx_PyObject_CallOneArg(__pyx_t_5, Py_False);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":296
+ *         try:
+ *             self._ssock.setblocking(False)
+ *             self._csock.setblocking(False)             # <<<<<<<<<<<<<<
+ * 
+ *             fileno = self._csock.fileno()
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_csock, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 296, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_4)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_4);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, Py_False) : __Pyx_PyObject_CallOneArg(__pyx_t_5, Py_False);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":298
+ *             self._csock.setblocking(False)
+ * 
+ *             fileno = self._csock.fileno()             # <<<<<<<<<<<<<<
+ * 
+ *             self._old_signal_wakeup_id = _set_signal_wakeup_fd(fileno)
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_csock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 298, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_4)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_4);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 298, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_v_fileno = __pyx_t_1;
+      __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":300
+ *             fileno = self._csock.fileno()
+ * 
+ *             self._old_signal_wakeup_id = _set_signal_wakeup_fd(fileno)             # <<<<<<<<<<<<<<
+ *         except Exception:
+ *             # Out of all statements in the try block, only the
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop__set_signal_wakeup_fd(__pyx_v_fileno); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 300, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 300, __pyx_L8_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_v_self->_old_signal_wakeup_id = __pyx_t_11;
+
+      /* "uvloop/loop.pyx":294
+ * 
+ *         self._ssock, self._csock = socket_socketpair()
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._ssock.setblocking(False)
+ *             self._csock.setblocking(False)
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    goto __pyx_L13_try_end;
+    __pyx_L8_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/loop.pyx":301
+ * 
+ *             self._old_signal_wakeup_id = _set_signal_wakeup_fd(fileno)
+ *         except Exception:             # <<<<<<<<<<<<<<
+ *             # Out of all statements in the try block, only the
+ *             # "_set_signal_wakeup_fd()" call can fail, but it shouldn't,
+ */
+    __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_11) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._setup_or_resume_signals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(0, 301, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/loop.pyx":307
+ *             # Still, if something goes horribly wrong we want to clean up
+ *             # the socket pair.
+ *             self._ssock.close()             # <<<<<<<<<<<<<<
+ *             self._csock.close()
+ *             self._ssock = None
+ */
+      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ssock, __pyx_n_s_close); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 307, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __pyx_t_13 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) {
+        __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_12);
+        if (likely(__pyx_t_13)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
+          __Pyx_INCREF(__pyx_t_13);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_12, function);
+        }
+      }
+      __pyx_t_6 = (__pyx_t_13) ? __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_13) : __Pyx_PyObject_CallNoArg(__pyx_t_12);
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 307, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/loop.pyx":308
+ *             # the socket pair.
+ *             self._ssock.close()
+ *             self._csock.close()             # <<<<<<<<<<<<<<
+ *             self._ssock = None
+ *             self._csock = None
+ */
+      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_csock, __pyx_n_s_close); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 308, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __pyx_t_13 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) {
+        __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_12);
+        if (likely(__pyx_t_13)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
+          __Pyx_INCREF(__pyx_t_13);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_12, function);
+        }
+      }
+      __pyx_t_6 = (__pyx_t_13) ? __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_13) : __Pyx_PyObject_CallNoArg(__pyx_t_12);
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 308, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/loop.pyx":309
+ *             self._ssock.close()
+ *             self._csock.close()
+ *             self._ssock = None             # <<<<<<<<<<<<<<
+ *             self._csock = None
+ *             raise
+ */
+      __Pyx_INCREF(Py_None);
+      __Pyx_GIVEREF(Py_None);
+      __Pyx_GOTREF(__pyx_v_self->_ssock);
+      __Pyx_DECREF(__pyx_v_self->_ssock);
+      __pyx_v_self->_ssock = Py_None;
+
+      /* "uvloop/loop.pyx":310
+ *             self._csock.close()
+ *             self._ssock = None
+ *             self._csock = None             # <<<<<<<<<<<<<<
+ *             raise
+ * 
+ */
+      __Pyx_INCREF(Py_None);
+      __Pyx_GIVEREF(Py_None);
+      __Pyx_GOTREF(__pyx_v_self->_csock);
+      __Pyx_DECREF(__pyx_v_self->_csock);
+      __pyx_v_self->_csock = Py_None;
+
+      /* "uvloop/loop.pyx":311
+ *             self._ssock = None
+ *             self._csock = None
+ *             raise             # <<<<<<<<<<<<<<
+ * 
+ *         self._add_reader(
+ */
+      __Pyx_GIVEREF(__pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_5, __pyx_t_4);
+      __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; 
+      __PYX_ERR(0, 311, __pyx_L10_except_error)
+    }
+    goto __pyx_L10_except_error;
+    __pyx_L10_except_error:;
+
+    /* "uvloop/loop.pyx":294
+ * 
+ *         self._ssock, self._csock = socket_socketpair()
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._ssock.setblocking(False)
+ *             self._csock.setblocking(False)
+ */
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    goto __pyx_L1_error;
+    __pyx_L13_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":314
+ * 
+ *         self._add_reader(
+ *             self._ssock,             # <<<<<<<<<<<<<<
+ *             new_MethodHandle(
+ *                 self,
+ */
+  __pyx_t_4 = __pyx_v_self->_ssock;
+  __Pyx_INCREF(__pyx_t_4);
+
+  /* "uvloop/loop.pyx":315
+ *         self._add_reader(
+ *             self._ssock,
+ *             new_MethodHandle(             # <<<<<<<<<<<<<<
+ *                 self,
+ *                 "Loop._read_from_self",
+ */
+  __pyx_t_5 = __pyx_f_6uvloop_4loop_new_MethodHandle(__pyx_v_self, __pyx_kp_u_Loop__read_from_self, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_read_from_self), Py_None, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 315, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 315, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":313
+ *             raise
+ * 
+ *         self._add_reader(             # <<<<<<<<<<<<<<
+ *             self._ssock,
+ *             new_MethodHandle(
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_add_reader(__pyx_v_self, __pyx_t_4, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_5)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 313, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":322
+ *                 self))
+ * 
+ *         self._listening_signals = True             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _pause_signals(self):
+ */
+  __pyx_v_self->_listening_signals = 1;
+
+  /* "uvloop/loop.pyx":278
+ *         self._debug_exception_handler_cnt = 0
+ * 
+ *     cdef _setup_or_resume_signals(self):             # <<<<<<<<<<<<<<
+ *         if not self._is_main_thread():
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_AddTraceback("uvloop.loop.Loop._setup_or_resume_signals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fileno);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":324
+ *         self._listening_signals = True
+ * 
+ *     cdef _pause_signals(self):             # <<<<<<<<<<<<<<
+ *         if not self._is_main_thread():
+ *             if self._listening_signals:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__pause_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_pause_signals", 0);
+
+  /* "uvloop/loop.pyx":325
+ * 
+ *     cdef _pause_signals(self):
+ *         if not self._is_main_thread():             # <<<<<<<<<<<<<<
+ *             if self._listening_signals:
+ *                 raise RuntimeError(
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__is_main_thread(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 325, __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, 325, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = ((!__pyx_t_2) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":326
+ *     cdef _pause_signals(self):
+ *         if not self._is_main_thread():
+ *             if self._listening_signals:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     'cannot pause signals handling; no longer running in '
+ */
+    __pyx_t_3 = (__pyx_v_self->_listening_signals != 0);
+    if (unlikely(__pyx_t_3)) {
+
+      /* "uvloop/loop.pyx":327
+ *         if not self._is_main_thread():
+ *             if self._listening_signals:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     'cannot pause signals handling; no longer running in '
+ *                     'the main thread')
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 327, __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, 327, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":326
+ *     cdef _pause_signals(self):
+ *         if not self._is_main_thread():
+ *             if self._listening_signals:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     'cannot pause signals handling; no longer running in '
+ */
+    }
+
+    /* "uvloop/loop.pyx":331
+ *                     'the main thread')
+ *             else:
+ *                 return             # <<<<<<<<<<<<<<
+ * 
+ *         if not self._listening_signals:
+ */
+    /*else*/ {
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+    }
+
+    /* "uvloop/loop.pyx":325
+ * 
+ *     cdef _pause_signals(self):
+ *         if not self._is_main_thread():             # <<<<<<<<<<<<<<
+ *             if self._listening_signals:
+ *                 raise RuntimeError(
+ */
+  }
+
+  /* "uvloop/loop.pyx":333
+ *                 return
+ * 
+ *         if not self._listening_signals:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('signals handling has not been setup')
+ * 
+ */
+  __pyx_t_3 = ((!(__pyx_v_self->_listening_signals != 0)) != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/loop.pyx":334
+ * 
+ *         if not self._listening_signals:
+ *             raise RuntimeError('signals handling has not been setup')             # <<<<<<<<<<<<<<
+ * 
+ *         self._listening_signals = False
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 334, __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, 334, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":333
+ *                 return
+ * 
+ *         if not self._listening_signals:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('signals handling has not been setup')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":336
+ *             raise RuntimeError('signals handling has not been setup')
+ * 
+ *         self._listening_signals = False             # <<<<<<<<<<<<<<
+ * 
+ *         _set_signal_wakeup_fd(self._old_signal_wakeup_id)
+ */
+  __pyx_v_self->_listening_signals = 0;
+
+  /* "uvloop/loop.pyx":338
+ *         self._listening_signals = False
+ * 
+ *         _set_signal_wakeup_fd(self._old_signal_wakeup_id)             # <<<<<<<<<<<<<<
+ * 
+ *         self._remove_reader(self._ssock)
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_old_signal_wakeup_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 338, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_f_6uvloop_4loop__set_signal_wakeup_fd(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 338, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":340
+ *         _set_signal_wakeup_fd(self._old_signal_wakeup_id)
+ * 
+ *         self._remove_reader(self._ssock)             # <<<<<<<<<<<<<<
+ *         self._ssock.close()
+ *         self._csock.close()
+ */
+  __pyx_t_4 = __pyx_v_self->_ssock;
+  __Pyx_INCREF(__pyx_t_4);
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_reader(__pyx_v_self, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 340, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":341
+ * 
+ *         self._remove_reader(self._ssock)
+ *         self._ssock.close()             # <<<<<<<<<<<<<<
+ *         self._csock.close()
+ *         self._ssock = None
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ssock, __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":342
+ *         self._remove_reader(self._ssock)
+ *         self._ssock.close()
+ *         self._csock.close()             # <<<<<<<<<<<<<<
+ *         self._ssock = None
+ *         self._csock = None
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_csock, __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 342, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 342, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":343
+ *         self._ssock.close()
+ *         self._csock.close()
+ *         self._ssock = None             # <<<<<<<<<<<<<<
+ *         self._csock = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_ssock);
+  __Pyx_DECREF(__pyx_v_self->_ssock);
+  __pyx_v_self->_ssock = Py_None;
+
+  /* "uvloop/loop.pyx":344
+ *         self._csock.close()
+ *         self._ssock = None
+ *         self._csock = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _shutdown_signals(self):
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_csock);
+  __Pyx_DECREF(__pyx_v_self->_csock);
+  __pyx_v_self->_csock = Py_None;
+
+  /* "uvloop/loop.pyx":324
+ *         self._listening_signals = True
+ * 
+ *     cdef _pause_signals(self):             # <<<<<<<<<<<<<<
+ *         if not self._is_main_thread():
+ *             if self._listening_signals:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.Loop._pause_signals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":346
+ *         self._csock = None
+ * 
+ *     cdef _shutdown_signals(self):             # <<<<<<<<<<<<<<
+ *         if not self._is_main_thread():
+ *             if self._signal_handlers:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__shutdown_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_v_sig = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  Py_ssize_t __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_shutdown_signals", 0);
+
+  /* "uvloop/loop.pyx":347
+ * 
+ *     cdef _shutdown_signals(self):
+ *         if not self._is_main_thread():             # <<<<<<<<<<<<<<
+ *             if self._signal_handlers:
+ *                 aio_logger.warning(
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__is_main_thread(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __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, 347, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = ((!__pyx_t_2) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":348
+ *     cdef _shutdown_signals(self):
+ *         if not self._is_main_thread():
+ *             if self._signal_handlers:             # <<<<<<<<<<<<<<
+ *                 aio_logger.warning(
+ *                     'cannot cleanup signal handlers: closing the event loop '
+ */
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->_signal_handlers); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 348, __pyx_L1_error)
+    if (__pyx_t_3) {
+
+      /* "uvloop/loop.pyx":349
+ *         if not self._is_main_thread():
+ *             if self._signal_handlers:
+ *                 aio_logger.warning(             # <<<<<<<<<<<<<<
+ *                     'cannot cleanup signal handlers: closing the event loop '
+ *                     'in a non-main OS thread')
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_warning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 349, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_kp_u_cannot_cleanup_signal_handlers_c) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_cannot_cleanup_signal_handlers_c);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 349, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":348
+ *     cdef _shutdown_signals(self):
+ *         if not self._is_main_thread():
+ *             if self._signal_handlers:             # <<<<<<<<<<<<<<
+ *                 aio_logger.warning(
+ *                     'cannot cleanup signal handlers: closing the event loop '
+ */
+    }
+
+    /* "uvloop/loop.pyx":352
+ *                     'cannot cleanup signal handlers: closing the event loop '
+ *                     'in a non-main OS thread')
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if self._listening_signals:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":347
+ * 
+ *     cdef _shutdown_signals(self):
+ *         if not self._is_main_thread():             # <<<<<<<<<<<<<<
+ *             if self._signal_handlers:
+ *                 aio_logger.warning(
+ */
+  }
+
+  /* "uvloop/loop.pyx":354
+ *             return
+ * 
+ *         if self._listening_signals:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'cannot shutdown signals handling as it has not been paused')
+ */
+  __pyx_t_3 = (__pyx_v_self->_listening_signals != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/loop.pyx":355
+ * 
+ *         if self._listening_signals:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'cannot shutdown signals handling as it has not been paused')
+ * 
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 355, __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, 355, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":354
+ *             return
+ * 
+ *         if self._listening_signals:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'cannot shutdown signals handling as it has not been paused')
+ */
+  }
+
+  /* "uvloop/loop.pyx":358
+ *                 'cannot shutdown signals handling as it has not been paused')
+ * 
+ *         if self._ssock:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'self-pipe was not cleaned up after loop was run')
+ */
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->_ssock); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 358, __pyx_L1_error)
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/loop.pyx":359
+ * 
+ *         if self._ssock:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'self-pipe was not cleaned up after loop was run')
+ * 
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __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, 359, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":358
+ *                 'cannot shutdown signals handling as it has not been paused')
+ * 
+ *         if self._ssock:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'self-pipe was not cleaned up after loop was run')
+ */
+  }
+
+  /* "uvloop/loop.pyx":362
+ *                 'self-pipe was not cleaned up after loop was run')
+ * 
+ *         for sig in list(self._signal_handlers):             # <<<<<<<<<<<<<<
+ *             self.remove_signal_handler(sig)
+ * 
+ */
+  __pyx_t_1 = PySequence_List(__pyx_v_self->_signal_handlers); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 362, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_t_1; __Pyx_INCREF(__pyx_t_4); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  for (;;) {
+    if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_4)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 362, __pyx_L1_error)
+    #else
+    __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 362, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":363
+ * 
+ *         for sig in list(self._signal_handlers):
+ *             self.remove_signal_handler(sig)             # <<<<<<<<<<<<<<
+ * 
+ *     def __sighandler(self, signum, frame):
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_remove_signal_handler); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 363, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_5, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_v_sig) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_sig);
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 363, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":362
+ *                 'self-pipe was not cleaned up after loop was run')
+ * 
+ *         for sig in list(self._signal_handlers):             # <<<<<<<<<<<<<<
+ *             self.remove_signal_handler(sig)
+ * 
+ */
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":346
+ *         self._csock = None
+ * 
+ *     cdef _shutdown_signals(self):             # <<<<<<<<<<<<<<
+ *         if not self._is_main_thread():
+ *             if self._signal_handlers:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.Loop._shutdown_signals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sig);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":365
+ *             self.remove_signal_handler(sig)
+ * 
+ *     def __sighandler(self, signum, frame):             # <<<<<<<<<<<<<<
+ *         self._signals.add(signum)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_7__sighandler(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_6__sighandler[] = "Loop.__sighandler(self, signum, frame)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_7__sighandler(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_signum = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_frame = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__sighandler (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signum,&__pyx_n_s_frame,0};
+    PyObject* values[2] = {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  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_signum)) != 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_frame)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__sighandler", 1, 2, 2, 1); __PYX_ERR(0, 365, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__sighandler") < 0)) __PYX_ERR(0, 365, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_signum = values[0];
+    __pyx_v_frame = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__sighandler", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 365, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.__sighandler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_6__sighandler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_signum, __pyx_v_frame);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_6__sighandler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_signum, CYTHON_UNUSED PyObject *__pyx_v_frame) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__sighandler", 0);
+
+  /* "uvloop/loop.pyx":366
+ * 
+ *     def __sighandler(self, signum, frame):
+ *         self._signals.add(signum)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _ceval_process_signals(self):
+ */
+  if (unlikely(__pyx_v_self->_signals == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "add");
+    __PYX_ERR(0, 366, __pyx_L1_error)
+  }
+  __pyx_t_1 = PySet_Add(__pyx_v_self->_signals, __pyx_v_signum); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 366, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":365
+ *             self.remove_signal_handler(sig)
+ * 
+ *     def __sighandler(self, signum, frame):             # <<<<<<<<<<<<<<
+ *         self._signals.add(signum)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.__sighandler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":368
+ *         self._signals.add(signum)
+ * 
+ *     cdef inline _ceval_process_signals(self):             # <<<<<<<<<<<<<<
+ *         # Invoke CPython eval loop to let process signals.
+ *         PyErr_CheckSignals()
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__ceval_process_signals(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ceval_process_signals", 0);
+
+  /* "uvloop/loop.pyx":370
+ *     cdef inline _ceval_process_signals(self):
+ *         # Invoke CPython eval loop to let process signals.
+ *         PyErr_CheckSignals()             # <<<<<<<<<<<<<<
+ *         # Calling a pure-Python function will invoke
+ *         # _PyEval_EvalFrameDefault which will process
+ */
+  __pyx_t_1 = PyErr_CheckSignals(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 370, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":374
+ *         # _PyEval_EvalFrameDefault which will process
+ *         # pending signal callbacks.
+ *         _noop.noop()  # Might raise ^C             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _read_from_self(self):
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_noop); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 374, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_noop_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 374, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 374, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":368
+ *         self._signals.add(signum)
+ * 
+ *     cdef inline _ceval_process_signals(self):             # <<<<<<<<<<<<<<
+ *         # Invoke CPython eval loop to let process signals.
+ *         PyErr_CheckSignals()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Loop._ceval_process_signals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":376
+ *         _noop.noop()  # Might raise ^C
+ * 
+ *     cdef _read_from_self(self):             # <<<<<<<<<<<<<<
+ *         cdef bytes sigdata
+ *         sigdata = b''
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__read_from_self(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_v_sigdata = 0;
+  PyObject *__pyx_v_data = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_t_10;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_read_from_self", 0);
+
+  /* "uvloop/loop.pyx":378
+ *     cdef _read_from_self(self):
+ *         cdef bytes sigdata
+ *         sigdata = b''             # <<<<<<<<<<<<<<
+ *         while True:
+ *             try:
+ */
+  __Pyx_INCREF(__pyx_kp_b__8);
+  __pyx_v_sigdata = __pyx_kp_b__8;
+
+  /* "uvloop/loop.pyx":379
+ *         cdef bytes sigdata
+ *         sigdata = b''
+ *         while True:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 data = self._ssock.recv(65536)
+ */
+  while (1) {
+
+    /* "uvloop/loop.pyx":380
+ *         sigdata = b''
+ *         while True:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 data = self._ssock.recv(65536)
+ *                 if not data:
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_1);
+      __Pyx_XGOTREF(__pyx_t_2);
+      __Pyx_XGOTREF(__pyx_t_3);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":381
+ *         while True:
+ *             try:
+ *                 data = self._ssock.recv(65536)             # <<<<<<<<<<<<<<
+ *                 if not data:
+ *                     break
+ */
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ssock, __pyx_n_s_recv); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 381, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __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_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_5, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_int_65536) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_int_65536);
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 381, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_XDECREF_SET(__pyx_v_data, __pyx_t_4);
+        __pyx_t_4 = 0;
+
+        /* "uvloop/loop.pyx":382
+ *             try:
+ *                 data = self._ssock.recv(65536)
+ *                 if not data:             # <<<<<<<<<<<<<<
+ *                     break
+ *                 sigdata += data
+ */
+        __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_data); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 382, __pyx_L5_error)
+        __pyx_t_8 = ((!__pyx_t_7) != 0);
+        if (__pyx_t_8) {
+
+          /* "uvloop/loop.pyx":383
+ *                 data = self._ssock.recv(65536)
+ *                 if not data:
+ *                     break             # <<<<<<<<<<<<<<
+ *                 sigdata += data
+ *             except InterruptedError:
+ */
+          goto __pyx_L10_try_break;
+
+          /* "uvloop/loop.pyx":382
+ *             try:
+ *                 data = self._ssock.recv(65536)
+ *                 if not data:             # <<<<<<<<<<<<<<
+ *                     break
+ *                 sigdata += data
+ */
+        }
+
+        /* "uvloop/loop.pyx":384
+ *                 if not data:
+ *                     break
+ *                 sigdata += data             # <<<<<<<<<<<<<<
+ *             except InterruptedError:
+ *                 continue
+ */
+        __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_sigdata, __pyx_v_data); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 384, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(0, 384, __pyx_L5_error)
+        __Pyx_DECREF_SET(__pyx_v_sigdata, ((PyObject*)__pyx_t_4));
+        __pyx_t_4 = 0;
+
+        /* "uvloop/loop.pyx":380
+ *         sigdata = b''
+ *         while True:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 data = self._ssock.recv(65536)
+ *                 if not data:
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      goto __pyx_L12_try_end;
+      __pyx_L5_error:;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/loop.pyx":385
+ *                     break
+ *                 sigdata += data
+ *             except InterruptedError:             # <<<<<<<<<<<<<<
+ *                 continue
+ *             except BlockingIOError:
+ */
+      __Pyx_ErrFetch(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_InterruptedError); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 385, __pyx_L7_except_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_10 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_4, __pyx_t_9);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_ErrRestore(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0;
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.Loop._read_from_self", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(0, 385, __pyx_L7_except_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_4);
+
+        /* "uvloop/loop.pyx":386
+ *                 sigdata += data
+ *             except InterruptedError:
+ *                 continue             # <<<<<<<<<<<<<<
+ *             except BlockingIOError:
+ *                 break
+ */
+        goto __pyx_L15_except_continue;
+        __pyx_L15_except_continue:;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        goto __pyx_L11_try_continue;
+      }
+
+      /* "uvloop/loop.pyx":387
+ *             except InterruptedError:
+ *                 continue
+ *             except BlockingIOError:             # <<<<<<<<<<<<<<
+ *                 break
+ *         if sigdata:
+ */
+      __Pyx_ErrFetch(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_BlockingIOError); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 387, __pyx_L7_except_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_10 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_4, __pyx_t_9);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_ErrRestore(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0;
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.Loop._read_from_self", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(0, 387, __pyx_L7_except_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_4);
+
+        /* "uvloop/loop.pyx":388
+ *                 continue
+ *             except BlockingIOError:
+ *                 break             # <<<<<<<<<<<<<<
+ *         if sigdata:
+ *             self._invoke_signals(sigdata)
+ */
+        goto __pyx_L16_except_break;
+        __pyx_L16_except_break:;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        goto __pyx_L10_try_break;
+      }
+      goto __pyx_L7_except_error;
+      __pyx_L7_except_error:;
+
+      /* "uvloop/loop.pyx":380
+ *         sigdata = b''
+ *         while True:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 data = self._ssock.recv(65536)
+ *                 if not data:
+ */
+      __Pyx_XGIVEREF(__pyx_t_1);
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+      goto __pyx_L1_error;
+      __pyx_L10_try_break:;
+      __Pyx_XGIVEREF(__pyx_t_1);
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+      goto __pyx_L4_break;
+      __pyx_L11_try_continue:;
+      __Pyx_XGIVEREF(__pyx_t_1);
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+      goto __pyx_L3_continue;
+      __pyx_L12_try_end:;
+    }
+    __pyx_L3_continue:;
+  }
+  __pyx_L4_break:;
+
+  /* "uvloop/loop.pyx":389
+ *             except BlockingIOError:
+ *                 break
+ *         if sigdata:             # <<<<<<<<<<<<<<
+ *             self._invoke_signals(sigdata)
+ * 
+ */
+  __pyx_t_8 = (__pyx_v_sigdata != Py_None)&&(PyBytes_GET_SIZE(__pyx_v_sigdata) != 0);
+  if (__pyx_t_8) {
+
+    /* "uvloop/loop.pyx":390
+ *                 break
+ *         if sigdata:
+ *             self._invoke_signals(sigdata)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _invoke_signals(self, bytes data):
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_invoke_signals(__pyx_v_self, __pyx_v_sigdata); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 390, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":389
+ *             except BlockingIOError:
+ *                 break
+ *         if sigdata:             # <<<<<<<<<<<<<<
+ *             self._invoke_signals(sigdata)
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":376
+ *         _noop.noop()  # Might raise ^C
+ * 
+ *     cdef _read_from_self(self):             # <<<<<<<<<<<<<<
+ *         cdef bytes sigdata
+ *         sigdata = b''
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.Loop._read_from_self", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sigdata);
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":392
+ *             self._invoke_signals(sigdata)
+ * 
+ *     cdef _invoke_signals(self, bytes data):             # <<<<<<<<<<<<<<
+ *         cdef set sigs
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__invoke_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_data) {
+  PyObject *__pyx_v_sigs = 0;
+  PyObject *__pyx_v_signum = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *(*__pyx_t_5)(PyObject *);
+  int __pyx_t_6;
+  int __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  int __pyx_t_10;
+  int __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_invoke_signals", 0);
+
+  /* "uvloop/loop.pyx":395
+ *         cdef set sigs
+ * 
+ *         self._ceval_process_signals()             # <<<<<<<<<<<<<<
+ * 
+ *         sigs = self._signals.copy()
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__ceval_process_signals(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":397
+ *         self._ceval_process_signals()
+ * 
+ *         sigs = self._signals.copy()             # <<<<<<<<<<<<<<
+ *         self._signals.clear()
+ *         for signum in data:
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_signals, __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 397, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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, 397, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!(likely(PySet_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "set", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 397, __pyx_L1_error)
+  __pyx_v_sigs = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":398
+ * 
+ *         sigs = self._signals.copy()
+ *         self._signals.clear()             # <<<<<<<<<<<<<<
+ *         for signum in data:
+ *             if not signum:
+ */
+  if (unlikely(__pyx_v_self->_signals == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "clear");
+    __PYX_ERR(0, 398, __pyx_L1_error)
+  }
+  __pyx_t_4 = PySet_Clear(__pyx_v_self->_signals); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 398, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":399
+ *         sigs = self._signals.copy()
+ *         self._signals.clear()
+ *         for signum in data:             # <<<<<<<<<<<<<<
+ *             if not signum:
+ *                 # ignore null bytes written by set_wakeup_fd()
+ */
+  __pyx_t_1 = PyObject_GetIter(__pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 399, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 399, __pyx_L1_error)
+  for (;;) {
+    {
+      __pyx_t_2 = __pyx_t_5(__pyx_t_1);
+      if (unlikely(!__pyx_t_2)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 399, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_signum, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":400
+ *         self._signals.clear()
+ *         for signum in data:
+ *             if not signum:             # <<<<<<<<<<<<<<
+ *                 # ignore null bytes written by set_wakeup_fd()
+ *                 continue
+ */
+    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_signum); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 400, __pyx_L1_error)
+    __pyx_t_7 = ((!__pyx_t_6) != 0);
+    if (__pyx_t_7) {
+
+      /* "uvloop/loop.pyx":402
+ *             if not signum:
+ *                 # ignore null bytes written by set_wakeup_fd()
+ *                 continue             # <<<<<<<<<<<<<<
+ *             sigs.discard(signum)
+ *             self._handle_signal(signum)
+ */
+      goto __pyx_L3_continue;
+
+      /* "uvloop/loop.pyx":400
+ *         self._signals.clear()
+ *         for signum in data:
+ *             if not signum:             # <<<<<<<<<<<<<<
+ *                 # ignore null bytes written by set_wakeup_fd()
+ *                 continue
+ */
+    }
+
+    /* "uvloop/loop.pyx":403
+ *                 # ignore null bytes written by set_wakeup_fd()
+ *                 continue
+ *             sigs.discard(signum)             # <<<<<<<<<<<<<<
+ *             self._handle_signal(signum)
+ * 
+ */
+    if (unlikely(__pyx_v_sigs == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "discard");
+      __PYX_ERR(0, 403, __pyx_L1_error)
+    }
+    __pyx_t_4 = __Pyx_PySet_Discard(__pyx_v_sigs, __pyx_v_signum); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 403, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":404
+ *                 continue
+ *             sigs.discard(signum)
+ *             self._handle_signal(signum)             # <<<<<<<<<<<<<<
+ * 
+ *         for signum in sigs:
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_handle_signal(__pyx_v_self, __pyx_v_signum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 404, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":399
+ *         sigs = self._signals.copy()
+ *         self._signals.clear()
+ *         for signum in data:             # <<<<<<<<<<<<<<
+ *             if not signum:
+ *                 # ignore null bytes written by set_wakeup_fd()
+ */
+    __pyx_L3_continue:;
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":406
+ *             self._handle_signal(signum)
+ * 
+ *         for signum in sigs:             # <<<<<<<<<<<<<<
+ *             # Since not all signals are registered by add_signal_handler()
+ *             # (for instance, we use the default SIGINT handler) not all
+ */
+  __pyx_t_8 = 0;
+  __pyx_t_2 = __Pyx_set_iterator(__pyx_v_sigs, 1, (&__pyx_t_9), (&__pyx_t_10)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 406, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_1);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_t_2 = 0;
+  while (1) {
+    __pyx_t_11 = __Pyx_set_iter_next(__pyx_t_1, __pyx_t_9, &__pyx_t_8, &__pyx_t_2, __pyx_t_10);
+    if (unlikely(__pyx_t_11 == 0)) break;
+    if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 406, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_signum, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":413
+ *             # from __sighandler; this ensures that signals shouldn't be
+ *             # lost even if set_wakeup_fd() couldn't write to the self-pipe.
+ *             self._handle_signal(signum)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _handle_signal(self, sig):
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_handle_signal(__pyx_v_self, __pyx_v_signum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 413, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":392
+ *             self._invoke_signals(sigdata)
+ * 
+ *     cdef _invoke_signals(self, bytes data):             # <<<<<<<<<<<<<<
+ *         cdef set sigs
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.Loop._invoke_signals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sigs);
+  __Pyx_XDECREF(__pyx_v_signum);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":415
+ *             self._handle_signal(signum)
+ * 
+ *     cdef _handle_signal(self, sig):             # <<<<<<<<<<<<<<
+ *         cdef Handle handle
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__handle_signal(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig) {
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_handle_signal", 0);
+
+  /* "uvloop/loop.pyx":418
+ *         cdef Handle handle
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             handle = <Handle>(self._signal_handlers[sig])
+ *         except KeyError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":419
+ * 
+ *         try:
+ *             handle = <Handle>(self._signal_handlers[sig])             # <<<<<<<<<<<<<<
+ *         except KeyError:
+ *             handle = None
+ */
+      if (unlikely(__pyx_v_self->_signal_handlers == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 419, __pyx_L3_error)
+      }
+      __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_self->_signal_handlers, __pyx_v_sig); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 419, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __pyx_t_4;
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":418
+ *         cdef Handle handle
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             handle = <Handle>(self._signal_handlers[sig])
+ *         except KeyError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":420
+ *         try:
+ *             handle = <Handle>(self._signal_handlers[sig])
+ *         except KeyError:             # <<<<<<<<<<<<<<
+ *             handle = None
+ * 
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._handle_signal", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(0, 420, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "uvloop/loop.pyx":421
+ *             handle = <Handle>(self._signal_handlers[sig])
+ *         except KeyError:
+ *             handle = None             # <<<<<<<<<<<<<<
+ * 
+ *         if handle is None:
+ */
+      __Pyx_INCREF(Py_None);
+      __Pyx_XDECREF_SET(__pyx_v_handle, ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None));
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/loop.pyx":418
+ *         cdef Handle handle
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             handle = <Handle>(self._signal_handlers[sig])
+ *         except KeyError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":423
+ *             handle = None
+ * 
+ *         if handle is None:             # <<<<<<<<<<<<<<
+ *             self._ceval_process_signals()
+ *             return
+ */
+  __pyx_t_8 = (((PyObject *)__pyx_v_handle) == Py_None);
+  __pyx_t_9 = (__pyx_t_8 != 0);
+  if (__pyx_t_9) {
+
+    /* "uvloop/loop.pyx":424
+ * 
+ *         if handle is None:
+ *             self._ceval_process_signals()             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_t_7 = __pyx_f_6uvloop_4loop_4Loop__ceval_process_signals(__pyx_v_self); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 424, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":425
+ *         if handle is None:
+ *             self._ceval_process_signals()
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if handle._cancelled:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":423
+ *             handle = None
+ * 
+ *         if handle is None:             # <<<<<<<<<<<<<<
+ *             self._ceval_process_signals()
+ *             return
+ */
+  }
+
+  /* "uvloop/loop.pyx":427
+ *             return
+ * 
+ *         if handle._cancelled:             # <<<<<<<<<<<<<<
+ *             self.remove_signal_handler(sig)  # Remove it properly.
+ *         else:
+ */
+  __pyx_t_9 = (__pyx_v_handle->_cancelled != 0);
+  if (__pyx_t_9) {
+
+    /* "uvloop/loop.pyx":428
+ * 
+ *         if handle._cancelled:
+ *             self.remove_signal_handler(sig)  # Remove it properly.             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._append_ready_handle(handle)
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_remove_signal_handler); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 428, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_7 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_sig) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sig);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 428, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":427
+ *             return
+ * 
+ *         if handle._cancelled:             # <<<<<<<<<<<<<<
+ *             self.remove_signal_handler(sig)  # Remove it properly.
+ *         else:
+ */
+    goto __pyx_L12;
+  }
+
+  /* "uvloop/loop.pyx":430
+ *             self.remove_signal_handler(sig)  # Remove it properly.
+ *         else:
+ *             self._append_ready_handle(handle)             # <<<<<<<<<<<<<<
+ *             self.handler_async.send()
+ * 
+ */
+  /*else*/ {
+    __pyx_t_7 = __pyx_f_6uvloop_4loop_4Loop__append_ready_handle(__pyx_v_self, __pyx_v_handle); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 430, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":431
+ *         else:
+ *             self._append_ready_handle(handle)
+ *             self.handler_async.send()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_wake(self):
+ */
+    __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->handler_async->__pyx_base.__pyx_vtab)->send(__pyx_v_self->handler_async); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 431, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_L12:;
+
+  /* "uvloop/loop.pyx":415
+ *             self._handle_signal(signum)
+ * 
+ *     cdef _handle_signal(self, sig):             # <<<<<<<<<<<<<<
+ *         cdef Handle handle
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.Loop._handle_signal", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":433
+ *             self.handler_async.send()
+ * 
+ *     cdef _on_wake(self):             # <<<<<<<<<<<<<<
+ *         if ((self._ready_len > 0 or self._stopping) and
+ *                 not self.handler_idle.running):
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__on_wake(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("_on_wake", 0);
+
+  /* "uvloop/loop.pyx":434
+ * 
+ *     cdef _on_wake(self):
+ *         if ((self._ready_len > 0 or self._stopping) and             # <<<<<<<<<<<<<<
+ *                 not self.handler_idle.running):
+ *             self.handler_idle.start()
+ */
+  __pyx_t_2 = ((__pyx_v_self->_ready_len > 0) != 0);
+  if (!__pyx_t_2) {
+  } else {
+    goto __pyx_L5_next_and;
+  }
+  __pyx_t_2 = (__pyx_v_self->_stopping != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_L5_next_and:;
+
+  /* "uvloop/loop.pyx":435
+ *     cdef _on_wake(self):
+ *         if ((self._ready_len > 0 or self._stopping) and
+ *                 not self.handler_idle.running):             # <<<<<<<<<<<<<<
+ *             self.handler_idle.start()
+ * 
+ */
+  __pyx_t_2 = ((!(__pyx_v_self->handler_idle->running != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+
+  /* "uvloop/loop.pyx":434
+ * 
+ *     cdef _on_wake(self):
+ *         if ((self._ready_len > 0 or self._stopping) and             # <<<<<<<<<<<<<<
+ *                 not self.handler_idle.running):
+ *             self.handler_idle.start()
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":436
+ *         if ((self._ready_len > 0 or self._stopping) and
+ *                 not self.handler_idle.running):
+ *             self.handler_idle.start()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_idle(self):
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_6UVIdle_start(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 436, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":434
+ * 
+ *     cdef _on_wake(self):
+ *         if ((self._ready_len > 0 or self._stopping) and             # <<<<<<<<<<<<<<
+ *                 not self.handler_idle.running):
+ *             self.handler_idle.start()
+ */
+  }
+
+  /* "uvloop/loop.pyx":433
+ *             self.handler_async.send()
+ * 
+ *     cdef _on_wake(self):             # <<<<<<<<<<<<<<
+ *         if ((self._ready_len > 0 or self._stopping) and
+ *                 not self.handler_idle.running):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.Loop._on_wake", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":438
+ *             self.handler_idle.start()
+ * 
+ *     cdef _on_idle(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int i, ntodo
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__on_idle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  CYTHON_UNUSED int __pyx_v_i;
+  int __pyx_v_ntodo;
+  PyObject *__pyx_v_popleft = 0;
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handler = 0;
+  PyObject *__pyx_v_started = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_v_delta = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  int __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;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_t_13;
+  char const *__pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  char const *__pyx_t_21;
+  int __pyx_t_22;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_idle", 0);
+
+  /* "uvloop/loop.pyx":441
+ *         cdef:
+ *             int i, ntodo
+ *             object popleft = self._ready.popleft             # <<<<<<<<<<<<<<
+ *             Handle handler
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ready, __pyx_n_s_popleft); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 441, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_popleft = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":444
+ *             Handle handler
+ * 
+ *         ntodo = len(self._ready)             # <<<<<<<<<<<<<<
+ *         if self._debug:
+ *             for i from 0 <= i < ntodo:
+ */
+  __pyx_t_1 = __pyx_v_self->_ready;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 444, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_ntodo = __pyx_t_2;
+
+  /* "uvloop/loop.pyx":445
+ * 
+ *         ntodo = len(self._ready)
+ *         if self._debug:             # <<<<<<<<<<<<<<
+ *             for i from 0 <= i < ntodo:
+ *                 handler = <Handle> popleft()
+ */
+  __pyx_t_3 = (__pyx_v_self->_debug != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":446
+ *         ntodo = len(self._ready)
+ *         if self._debug:
+ *             for i from 0 <= i < ntodo:             # <<<<<<<<<<<<<<
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:
+ */
+    __pyx_t_4 = __pyx_v_ntodo;
+    for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_4; __pyx_v_i++) {
+
+      /* "uvloop/loop.pyx":447
+ *         if self._debug:
+ *             for i from 0 <= i < ntodo:
+ *                 handler = <Handle> popleft()             # <<<<<<<<<<<<<<
+ *                 if handler._cancelled == 0:
+ *                     try:
+ */
+      __Pyx_INCREF(__pyx_v_popleft);
+      __pyx_t_5 = __pyx_v_popleft; __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_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_1 = (__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_1)) __PYX_ERR(0, 447, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_5 = __pyx_t_1;
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_handler, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_5));
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":448
+ *             for i from 0 <= i < ntodo:
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:             # <<<<<<<<<<<<<<
+ *                     try:
+ *                         started = time_monotonic()
+ */
+      __pyx_t_3 = ((__pyx_v_handler->_cancelled == 0) != 0);
+      if (__pyx_t_3) {
+
+        /* "uvloop/loop.pyx":449
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         started = time_monotonic()
+ *                         handler._run()
+ */
+        {
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
+          __Pyx_XGOTREF(__pyx_t_7);
+          __Pyx_XGOTREF(__pyx_t_8);
+          __Pyx_XGOTREF(__pyx_t_9);
+          /*try:*/ {
+
+            /* "uvloop/loop.pyx":450
+ *                 if handler._cancelled == 0:
+ *                     try:
+ *                         started = time_monotonic()             # <<<<<<<<<<<<<<
+ *                         handler._run()
+ *                     except BaseException as ex:
+ */
+            __Pyx_INCREF(__pyx_v_6uvloop_4loop_time_monotonic);
+            __pyx_t_1 = __pyx_v_6uvloop_4loop_time_monotonic; __pyx_t_6 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+              __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1);
+              if (likely(__pyx_t_6)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+                __Pyx_INCREF(__pyx_t_6);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_1, function);
+              }
+            }
+            __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_1);
+            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 450, __pyx_L7_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+            __Pyx_XDECREF_SET(__pyx_v_started, __pyx_t_5);
+            __pyx_t_5 = 0;
+
+            /* "uvloop/loop.pyx":451
+ *                     try:
+ *                         started = time_monotonic()
+ *                         handler._run()             # <<<<<<<<<<<<<<
+ *                     except BaseException as ex:
+ *                         self._stop(ex)
+ */
+            __pyx_t_5 = __pyx_f_6uvloop_4loop_6Handle__run(__pyx_v_handler); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 451, __pyx_L7_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+            /* "uvloop/loop.pyx":449
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         started = time_monotonic()
+ *                         handler._run()
+ */
+          }
+
+          /* "uvloop/loop.pyx":456
+ *                         return
+ *                     else:
+ *                         delta = time_monotonic() - started             # <<<<<<<<<<<<<<
+ *                         if delta > self.slow_callback_duration:
+ *                             aio_logger.warning(
+ */
+          /*else:*/ {
+            __Pyx_INCREF(__pyx_v_6uvloop_4loop_time_monotonic);
+            __pyx_t_1 = __pyx_v_6uvloop_4loop_time_monotonic; __pyx_t_6 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+              __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1);
+              if (likely(__pyx_t_6)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+                __Pyx_INCREF(__pyx_t_6);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_1, function);
+              }
+            }
+            __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_1);
+            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 456, __pyx_L9_except_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+            __pyx_t_1 = PyNumber_Subtract(__pyx_t_5, __pyx_v_started); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 456, __pyx_L9_except_error)
+            __Pyx_GOTREF(__pyx_t_1);
+            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+            __Pyx_XDECREF_SET(__pyx_v_delta, __pyx_t_1);
+            __pyx_t_1 = 0;
+
+            /* "uvloop/loop.pyx":457
+ *                     else:
+ *                         delta = time_monotonic() - started
+ *                         if delta > self.slow_callback_duration:             # <<<<<<<<<<<<<<
+ *                             aio_logger.warning(
+ *                                 'Executing %s took %.3f seconds',
+ */
+            __pyx_t_1 = PyObject_RichCompare(__pyx_v_delta, __pyx_v_self->slow_callback_duration, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 457, __pyx_L9_except_error)
+            __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 457, __pyx_L9_except_error)
+            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+            if (__pyx_t_3) {
+
+              /* "uvloop/loop.pyx":458
+ *                         delta = time_monotonic() - started
+ *                         if delta > self.slow_callback_duration:
+ *                             aio_logger.warning(             # <<<<<<<<<<<<<<
+ *                                 'Executing %s took %.3f seconds',
+ *                                 handler._format_handle(), delta)
+ */
+              __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_warning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 458, __pyx_L9_except_error)
+              __Pyx_GOTREF(__pyx_t_5);
+
+              /* "uvloop/loop.pyx":460
+ *                             aio_logger.warning(
+ *                                 'Executing %s took %.3f seconds',
+ *                                 handler._format_handle(), delta)             # <<<<<<<<<<<<<<
+ * 
+ *         else:
+ */
+              __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Handle *)__pyx_v_handler->__pyx_vtab)->_format_handle(__pyx_v_handler); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 460, __pyx_L9_except_error)
+              __Pyx_GOTREF(__pyx_t_6);
+              __pyx_t_10 = NULL;
+              __pyx_t_11 = 0;
+              if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+                __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_5);
+                if (likely(__pyx_t_10)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+                  __Pyx_INCREF(__pyx_t_10);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_5, function);
+                  __pyx_t_11 = 1;
+                }
+              }
+              #if CYTHON_FAST_PYCALL
+              if (PyFunction_Check(__pyx_t_5)) {
+                PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_kp_u_Executing_s_took_3f_seconds, __pyx_t_6, __pyx_v_delta};
+                __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 458, __pyx_L9_except_error)
+                __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+                __Pyx_GOTREF(__pyx_t_1);
+                __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_10, __pyx_kp_u_Executing_s_took_3f_seconds, __pyx_t_6, __pyx_v_delta};
+                __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 458, __pyx_L9_except_error)
+                __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+                __Pyx_GOTREF(__pyx_t_1);
+                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+              } else
+              #endif
+              {
+                __pyx_t_12 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 458, __pyx_L9_except_error)
+                __Pyx_GOTREF(__pyx_t_12);
+                if (__pyx_t_10) {
+                  __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL;
+                }
+                __Pyx_INCREF(__pyx_kp_u_Executing_s_took_3f_seconds);
+                __Pyx_GIVEREF(__pyx_kp_u_Executing_s_took_3f_seconds);
+                PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_11, __pyx_kp_u_Executing_s_took_3f_seconds);
+                __Pyx_GIVEREF(__pyx_t_6);
+                PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_t_6);
+                __Pyx_INCREF(__pyx_v_delta);
+                __Pyx_GIVEREF(__pyx_v_delta);
+                PyTuple_SET_ITEM(__pyx_t_12, 2+__pyx_t_11, __pyx_v_delta);
+                __pyx_t_6 = 0;
+                __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 458, __pyx_L9_except_error)
+                __Pyx_GOTREF(__pyx_t_1);
+                __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+              }
+              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+              /* "uvloop/loop.pyx":457
+ *                     else:
+ *                         delta = time_monotonic() - started
+ *                         if delta > self.slow_callback_duration:             # <<<<<<<<<<<<<<
+ *                             aio_logger.warning(
+ *                                 'Executing %s took %.3f seconds',
+ */
+            }
+          }
+          __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;
+          goto __pyx_L14_try_end;
+          __pyx_L7_error:;
+          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+          /* "uvloop/loop.pyx":452
+ *                         started = time_monotonic()
+ *                         handler._run()
+ *                     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                         self._stop(ex)
+ *                         return
+ */
+          __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+          if (__pyx_t_11) {
+            __Pyx_AddTraceback("uvloop.loop.Loop._on_idle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+            if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_12) < 0) __PYX_ERR(0, 452, __pyx_L9_except_error)
+            __Pyx_GOTREF(__pyx_t_1);
+            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_GOTREF(__pyx_t_12);
+            __Pyx_INCREF(__pyx_t_5);
+            __pyx_v_ex = __pyx_t_5;
+            /*try:*/ {
+
+              /* "uvloop/loop.pyx":453
+ *                         handler._run()
+ *                     except BaseException as ex:
+ *                         self._stop(ex)             # <<<<<<<<<<<<<<
+ *                         return
+ *                     else:
+ */
+              __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_stop(__pyx_v_self, __pyx_v_ex); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 453, __pyx_L21_error)
+              __Pyx_GOTREF(__pyx_t_6);
+              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+              /* "uvloop/loop.pyx":454
+ *                     except BaseException as ex:
+ *                         self._stop(ex)
+ *                         return             # <<<<<<<<<<<<<<
+ *                     else:
+ *                         delta = time_monotonic() - started
+ */
+              __Pyx_XDECREF(__pyx_r);
+              __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+              __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+              goto __pyx_L20_return;
+            }
+
+            /* "uvloop/loop.pyx":452
+ *                         started = time_monotonic()
+ *                         handler._run()
+ *                     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                         self._stop(ex)
+ *                         return
+ */
+            /*finally:*/ {
+              __pyx_L21_error:;
+              /*exception exit:*/{
+                __Pyx_PyThreadState_declare
+                __Pyx_PyThreadState_assign
+                __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+                __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+                __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+                if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+                if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+                __Pyx_XGOTREF(__pyx_t_15);
+                __Pyx_XGOTREF(__pyx_t_16);
+                __Pyx_XGOTREF(__pyx_t_17);
+                __Pyx_XGOTREF(__pyx_t_18);
+                __Pyx_XGOTREF(__pyx_t_19);
+                __Pyx_XGOTREF(__pyx_t_20);
+                __pyx_t_11 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
+                {
+                  __Pyx_DECREF(__pyx_v_ex);
+                  __pyx_v_ex = NULL;
+                }
+                if (PY_MAJOR_VERSION >= 3) {
+                  __Pyx_XGIVEREF(__pyx_t_18);
+                  __Pyx_XGIVEREF(__pyx_t_19);
+                  __Pyx_XGIVEREF(__pyx_t_20);
+                  __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+                }
+                __Pyx_XGIVEREF(__pyx_t_15);
+                __Pyx_XGIVEREF(__pyx_t_16);
+                __Pyx_XGIVEREF(__pyx_t_17);
+                __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+                __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+                __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
+                goto __pyx_L9_except_error;
+              }
+              __pyx_L20_return: {
+                __pyx_t_20 = __pyx_r;
+                __pyx_r = 0;
+                __Pyx_DECREF(__pyx_v_ex);
+                __pyx_v_ex = NULL;
+                __pyx_r = __pyx_t_20;
+                __pyx_t_20 = 0;
+                goto __pyx_L10_except_return;
+              }
+            }
+          }
+          goto __pyx_L9_except_error;
+          __pyx_L9_except_error:;
+
+          /* "uvloop/loop.pyx":449
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         started = time_monotonic()
+ *                         handler._run()
+ */
+          __Pyx_XGIVEREF(__pyx_t_7);
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+          goto __pyx_L1_error;
+          __pyx_L10_except_return:;
+          __Pyx_XGIVEREF(__pyx_t_7);
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+          goto __pyx_L0;
+          __pyx_L14_try_end:;
+        }
+
+        /* "uvloop/loop.pyx":448
+ *             for i from 0 <= i < ntodo:
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:             # <<<<<<<<<<<<<<
+ *                     try:
+ *                         started = time_monotonic()
+ */
+      }
+    }
+
+    /* "uvloop/loop.pyx":445
+ * 
+ *         ntodo = len(self._ready)
+ *         if self._debug:             # <<<<<<<<<<<<<<
+ *             for i from 0 <= i < ntodo:
+ *                 handler = <Handle> popleft()
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/loop.pyx":463
+ * 
+ *         else:
+ *             for i from 0 <= i < ntodo:             # <<<<<<<<<<<<<<
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:
+ */
+  /*else*/ {
+    __pyx_t_4 = __pyx_v_ntodo;
+    for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_4; __pyx_v_i++) {
+
+      /* "uvloop/loop.pyx":464
+ *         else:
+ *             for i from 0 <= i < ntodo:
+ *                 handler = <Handle> popleft()             # <<<<<<<<<<<<<<
+ *                 if handler._cancelled == 0:
+ *                     try:
+ */
+      __Pyx_INCREF(__pyx_v_popleft);
+      __pyx_t_5 = __pyx_v_popleft; __pyx_t_1 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_1)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_1);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_12 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 464, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_5 = __pyx_t_12;
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_handler, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_5));
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":465
+ *             for i from 0 <= i < ntodo:
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:             # <<<<<<<<<<<<<<
+ *                     try:
+ *                         handler._run()
+ */
+      __pyx_t_3 = ((__pyx_v_handler->_cancelled == 0) != 0);
+      if (__pyx_t_3) {
+
+        /* "uvloop/loop.pyx":466
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         handler._run()
+ *                     except BaseException as ex:
+ */
+        {
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7);
+          __Pyx_XGOTREF(__pyx_t_9);
+          __Pyx_XGOTREF(__pyx_t_8);
+          __Pyx_XGOTREF(__pyx_t_7);
+          /*try:*/ {
+
+            /* "uvloop/loop.pyx":467
+ *                 if handler._cancelled == 0:
+ *                     try:
+ *                         handler._run()             # <<<<<<<<<<<<<<
+ *                     except BaseException as ex:
+ *                         self._stop(ex)
+ */
+            __pyx_t_5 = __pyx_f_6uvloop_4loop_6Handle__run(__pyx_v_handler); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 467, __pyx_L30_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+            /* "uvloop/loop.pyx":466
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         handler._run()
+ *                     except BaseException as ex:
+ */
+          }
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+          goto __pyx_L37_try_end;
+          __pyx_L30_error:;
+          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+          /* "uvloop/loop.pyx":468
+ *                     try:
+ *                         handler._run()
+ *                     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                         self._stop(ex)
+ *                         return
+ */
+          __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+          if (__pyx_t_13) {
+            __Pyx_AddTraceback("uvloop.loop.Loop._on_idle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+            if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_12, &__pyx_t_1) < 0) __PYX_ERR(0, 468, __pyx_L32_except_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_GOTREF(__pyx_t_12);
+            __Pyx_GOTREF(__pyx_t_1);
+            __Pyx_INCREF(__pyx_t_12);
+            __pyx_v_ex = __pyx_t_12;
+            /*try:*/ {
+
+              /* "uvloop/loop.pyx":469
+ *                         handler._run()
+ *                     except BaseException as ex:
+ *                         self._stop(ex)             # <<<<<<<<<<<<<<
+ *                         return
+ * 
+ */
+              __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_stop(__pyx_v_self, __pyx_v_ex); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 469, __pyx_L43_error)
+              __Pyx_GOTREF(__pyx_t_6);
+              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+              /* "uvloop/loop.pyx":470
+ *                     except BaseException as ex:
+ *                         self._stop(ex)
+ *                         return             # <<<<<<<<<<<<<<
+ * 
+ *         if len(self._queued_streams):
+ */
+              __Pyx_XDECREF(__pyx_r);
+              __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+              __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+              goto __pyx_L42_return;
+            }
+
+            /* "uvloop/loop.pyx":468
+ *                     try:
+ *                         handler._run()
+ *                     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                         self._stop(ex)
+ *                         return
+ */
+            /*finally:*/ {
+              __pyx_L43_error:;
+              /*exception exit:*/{
+                __Pyx_PyThreadState_declare
+                __Pyx_PyThreadState_assign
+                __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+                __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+                __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+                if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_16, &__pyx_t_15);
+                if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18);
+                __Pyx_XGOTREF(__pyx_t_20);
+                __Pyx_XGOTREF(__pyx_t_19);
+                __Pyx_XGOTREF(__pyx_t_18);
+                __Pyx_XGOTREF(__pyx_t_17);
+                __Pyx_XGOTREF(__pyx_t_16);
+                __Pyx_XGOTREF(__pyx_t_15);
+                __pyx_t_13 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_21 = __pyx_filename;
+                {
+                  __Pyx_DECREF(__pyx_v_ex);
+                  __pyx_v_ex = NULL;
+                }
+                if (PY_MAJOR_VERSION >= 3) {
+                  __Pyx_XGIVEREF(__pyx_t_17);
+                  __Pyx_XGIVEREF(__pyx_t_16);
+                  __Pyx_XGIVEREF(__pyx_t_15);
+                  __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15);
+                }
+                __Pyx_XGIVEREF(__pyx_t_20);
+                __Pyx_XGIVEREF(__pyx_t_19);
+                __Pyx_XGIVEREF(__pyx_t_18);
+                __Pyx_ErrRestore(__pyx_t_20, __pyx_t_19, __pyx_t_18);
+                __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+                __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_21;
+                goto __pyx_L32_except_error;
+              }
+              __pyx_L42_return: {
+                __pyx_t_15 = __pyx_r;
+                __pyx_r = 0;
+                __Pyx_DECREF(__pyx_v_ex);
+                __pyx_v_ex = NULL;
+                __pyx_r = __pyx_t_15;
+                __pyx_t_15 = 0;
+                goto __pyx_L33_except_return;
+              }
+            }
+          }
+          goto __pyx_L32_except_error;
+          __pyx_L32_except_error:;
+
+          /* "uvloop/loop.pyx":466
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         handler._run()
+ *                     except BaseException as ex:
+ */
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __Pyx_XGIVEREF(__pyx_t_7);
+          __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_8, __pyx_t_7);
+          goto __pyx_L1_error;
+          __pyx_L33_except_return:;
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __Pyx_XGIVEREF(__pyx_t_7);
+          __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_8, __pyx_t_7);
+          goto __pyx_L0;
+          __pyx_L37_try_end:;
+        }
+
+        /* "uvloop/loop.pyx":465
+ *             for i from 0 <= i < ntodo:
+ *                 handler = <Handle> popleft()
+ *                 if handler._cancelled == 0:             # <<<<<<<<<<<<<<
+ *                     try:
+ *                         handler._run()
+ */
+      }
+    }
+  }
+  __pyx_L3:;
+
+  /* "uvloop/loop.pyx":472
+ *                         return
+ * 
+ *         if len(self._queued_streams):             # <<<<<<<<<<<<<<
+ *             self._exec_queued_writes()
+ * 
+ */
+  __pyx_t_1 = __pyx_v_self->_queued_streams;
+  __Pyx_INCREF(__pyx_t_1);
+  if (unlikely(__pyx_t_1 == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(0, 472, __pyx_L1_error)
+  }
+  __pyx_t_2 = PySet_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 472, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":473
+ * 
+ *         if len(self._queued_streams):
+ *             self._exec_queued_writes()             # <<<<<<<<<<<<<<
+ * 
+ *         self._ready_len = len(self._ready)
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_exec_queued_writes(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 473, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":472
+ *                         return
+ * 
+ *         if len(self._queued_streams):             # <<<<<<<<<<<<<<
+ *             self._exec_queued_writes()
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":475
+ *             self._exec_queued_writes()
+ * 
+ *         self._ready_len = len(self._ready)             # <<<<<<<<<<<<<<
+ *         if self._ready_len == 0 and self.handler_idle.running:
+ *             self.handler_idle.stop()
+ */
+  __pyx_t_1 = __pyx_v_self->_ready;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 475, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_self->_ready_len = __pyx_t_2;
+
+  /* "uvloop/loop.pyx":476
+ * 
+ *         self._ready_len = len(self._ready)
+ *         if self._ready_len == 0 and self.handler_idle.running:             # <<<<<<<<<<<<<<
+ *             self.handler_idle.stop()
+ * 
+ */
+  __pyx_t_22 = ((__pyx_v_self->_ready_len == 0) != 0);
+  if (__pyx_t_22) {
+  } else {
+    __pyx_t_3 = __pyx_t_22;
+    goto __pyx_L51_bool_binop_done;
+  }
+  __pyx_t_22 = (__pyx_v_self->handler_idle->running != 0);
+  __pyx_t_3 = __pyx_t_22;
+  __pyx_L51_bool_binop_done:;
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":477
+ *         self._ready_len = len(self._ready)
+ *         if self._ready_len == 0 and self.handler_idle.running:
+ *             self.handler_idle.stop()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._stopping:
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_6UVIdle_stop(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 477, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":476
+ * 
+ *         self._ready_len = len(self._ready)
+ *         if self._ready_len == 0 and self.handler_idle.running:             # <<<<<<<<<<<<<<
+ *             self.handler_idle.stop()
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":479
+ *             self.handler_idle.stop()
+ * 
+ *         if self._stopping:             # <<<<<<<<<<<<<<
+ *             uv.uv_stop(self.uvloop)  # void
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->_stopping != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":480
+ * 
+ *         if self._stopping:
+ *             uv.uv_stop(self.uvloop)  # void             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _stop(self, exc):
+ */
+    uv_stop(__pyx_v_self->uvloop);
+
+    /* "uvloop/loop.pyx":479
+ *             self.handler_idle.stop()
+ * 
+ *         if self._stopping:             # <<<<<<<<<<<<<<
+ *             uv.uv_stop(self.uvloop)  # void
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":438
+ *             self.handler_idle.start()
+ * 
+ *     cdef _on_idle(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int i, ntodo
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("uvloop.loop.Loop._on_idle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_popleft);
+  __Pyx_XDECREF((PyObject *)__pyx_v_handler);
+  __Pyx_XDECREF(__pyx_v_started);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XDECREF(__pyx_v_delta);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":482
+ *             uv.uv_stop(self.uvloop)  # void
+ * 
+ *     cdef _stop(self, exc):             # <<<<<<<<<<<<<<
+ *         if exc is not None:
+ *             self._last_error = exc
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__stop(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_exc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("_stop", 0);
+
+  /* "uvloop/loop.pyx":483
+ * 
+ *     cdef _stop(self, exc):
+ *         if exc is not None:             # <<<<<<<<<<<<<<
+ *             self._last_error = exc
+ *         if self._stopping == 1:
+ */
+  __pyx_t_1 = (__pyx_v_exc != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":484
+ *     cdef _stop(self, exc):
+ *         if exc is not None:
+ *             self._last_error = exc             # <<<<<<<<<<<<<<
+ *         if self._stopping == 1:
+ *             return
+ */
+    __Pyx_INCREF(__pyx_v_exc);
+    __Pyx_GIVEREF(__pyx_v_exc);
+    __Pyx_GOTREF(__pyx_v_self->_last_error);
+    __Pyx_DECREF(__pyx_v_self->_last_error);
+    __pyx_v_self->_last_error = __pyx_v_exc;
+
+    /* "uvloop/loop.pyx":483
+ * 
+ *     cdef _stop(self, exc):
+ *         if exc is not None:             # <<<<<<<<<<<<<<
+ *             self._last_error = exc
+ *         if self._stopping == 1:
+ */
+  }
+
+  /* "uvloop/loop.pyx":485
+ *         if exc is not None:
+ *             self._last_error = exc
+ *         if self._stopping == 1:             # <<<<<<<<<<<<<<
+ *             return
+ *         self._stopping = 1
+ */
+  __pyx_t_2 = ((__pyx_v_self->_stopping == 1) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":486
+ *             self._last_error = exc
+ *         if self._stopping == 1:
+ *             return             # <<<<<<<<<<<<<<
+ *         self._stopping = 1
+ *         if not self.handler_idle.running:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":485
+ *         if exc is not None:
+ *             self._last_error = exc
+ *         if self._stopping == 1:             # <<<<<<<<<<<<<<
+ *             return
+ *         self._stopping = 1
+ */
+  }
+
+  /* "uvloop/loop.pyx":487
+ *         if self._stopping == 1:
+ *             return
+ *         self._stopping = 1             # <<<<<<<<<<<<<<
+ *         if not self.handler_idle.running:
+ *             self.handler_idle.start()
+ */
+  __pyx_v_self->_stopping = 1;
+
+  /* "uvloop/loop.pyx":488
+ *             return
+ *         self._stopping = 1
+ *         if not self.handler_idle.running:             # <<<<<<<<<<<<<<
+ *             self.handler_idle.start()
+ * 
+ */
+  __pyx_t_2 = ((!(__pyx_v_self->handler_idle->running != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":489
+ *         self._stopping = 1
+ *         if not self.handler_idle.running:
+ *             self.handler_idle.start()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef __run(self, uv.uv_run_mode mode):
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_6UVIdle_start(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 489, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":488
+ *             return
+ *         self._stopping = 1
+ *         if not self.handler_idle.running:             # <<<<<<<<<<<<<<
+ *             self.handler_idle.start()
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":482
+ *             uv.uv_stop(self.uvloop)  # void
+ * 
+ *     cdef _stop(self, exc):             # <<<<<<<<<<<<<<
+ *         if exc is not None:
+ *             self._last_error = exc
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.Loop._stop", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":491
+ *             self.handler_idle.start()
+ * 
+ *     cdef __run(self, uv.uv_run_mode mode):             # <<<<<<<<<<<<<<
+ *         # Although every UVHandle holds a reference to the loop,
+ *         # we want to do everything to ensure that the loop will
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop___run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uv_run_mode __pyx_v_mode) {
+  int __pyx_v_err;
+  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("__run", 0);
+
+  /* "uvloop/loop.pyx":496
+ *         # never deallocate during the run -- so we do some
+ *         # manual refs management.
+ *         Py_INCREF(self)             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             err = uv.uv_run(self.uvloop, mode)
+ */
+  Py_INCREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/loop.pyx":497
+ *         # manual refs management.
+ *         Py_INCREF(self)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_run(self.uvloop, mode)
+ *         Py_DECREF(self)
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      __Pyx_FastGIL_Remember();
+      #endif
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":498
+ *         Py_INCREF(self)
+ *         with nogil:
+ *             err = uv.uv_run(self.uvloop, mode)             # <<<<<<<<<<<<<<
+ *         Py_DECREF(self)
+ * 
+ */
+        __pyx_v_err = uv_run(__pyx_v_self->uvloop, __pyx_v_mode);
+      }
+
+      /* "uvloop/loop.pyx":497
+ *         # manual refs management.
+ *         Py_INCREF(self)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_run(self.uvloop, mode)
+ *         Py_DECREF(self)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          __Pyx_FastGIL_Forget();
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "uvloop/loop.pyx":499
+ *         with nogil:
+ *             err = uv.uv_run(self.uvloop, mode)
+ *         Py_DECREF(self)             # <<<<<<<<<<<<<<
+ * 
+ *         if err < 0:
+ */
+  Py_DECREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/loop.pyx":501
+ *         Py_DECREF(self)
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":502
+ * 
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _run(self, uv.uv_run_mode mode):
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 502, __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(0, 502, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":501
+ *         Py_DECREF(self)
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":491
+ *             self.handler_idle.start()
+ * 
+ *     cdef __run(self, uv.uv_run_mode mode):             # <<<<<<<<<<<<<<
+ *         # Although every UVHandle holds a reference to the loop,
+ *         # we want to do everything to ensure that the loop will
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop.__run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":504
+ *             raise convert_error(err)
+ * 
+ *     cdef _run(self, uv.uv_run_mode mode):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uv_run_mode __pyx_v_mode) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  char const *__pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_run", 0);
+
+  /* "uvloop/loop.pyx":507
+ *         cdef int err
+ * 
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('unable to start the loop; it was closed')
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_closed == 1) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":508
+ * 
+ *         if self._closed == 1:
+ *             raise RuntimeError('unable to start the loop; it was closed')             # <<<<<<<<<<<<<<
+ * 
+ *         if self._running == 1:
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 508, __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(0, 508, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":507
+ *         cdef int err
+ * 
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('unable to start the loop; it was closed')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":510
+ *             raise RuntimeError('unable to start the loop; it was closed')
+ * 
+ *         if self._running == 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('this event loop is already running.')
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_running == 1) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":511
+ * 
+ *         if self._running == 1:
+ *             raise RuntimeError('this event loop is already running.')             # <<<<<<<<<<<<<<
+ * 
+ *         if (aio_get_running_loop is not None and
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 511, __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(0, 511, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":510
+ *             raise RuntimeError('unable to start the loop; it was closed')
+ * 
+ *         if self._running == 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('this event loop is already running.')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":513
+ *             raise RuntimeError('this event loop is already running.')
+ * 
+ *         if (aio_get_running_loop is not None and             # <<<<<<<<<<<<<<
+ *                 aio_get_running_loop() is not None):
+ *             raise RuntimeError(
+ */
+  __pyx_t_3 = (__pyx_v_6uvloop_4loop_aio_get_running_loop != Py_None);
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  if (__pyx_t_4) {
+  } else {
+    __pyx_t_1 = __pyx_t_4;
+    goto __pyx_L6_bool_binop_done;
+  }
+
+  /* "uvloop/loop.pyx":514
+ * 
+ *         if (aio_get_running_loop is not None and
+ *                 aio_get_running_loop() is not None):             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'Cannot run the event loop while another loop is running')
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_get_running_loop);
+  __pyx_t_5 = __pyx_v_6uvloop_4loop_aio_get_running_loop; __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  __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(0, 514, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_4 = (__pyx_t_2 != Py_None);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = (__pyx_t_4 != 0);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L6_bool_binop_done:;
+
+  /* "uvloop/loop.pyx":513
+ *             raise RuntimeError('this event loop is already running.')
+ * 
+ *         if (aio_get_running_loop is not None and             # <<<<<<<<<<<<<<
+ *                 aio_get_running_loop() is not None):
+ *             raise RuntimeError(
+ */
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":515
+ *         if (aio_get_running_loop is not None and
+ *                 aio_get_running_loop() is not None):
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'Cannot run the event loop while another loop is running')
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 515, __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(0, 515, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":513
+ *             raise RuntimeError('this event loop is already running.')
+ * 
+ *         if (aio_get_running_loop is not None and             # <<<<<<<<<<<<<<
+ *                 aio_get_running_loop() is not None):
+ *             raise RuntimeError(
+ */
+  }
+
+  /* "uvloop/loop.pyx":519
+ * 
+ *         # reset _last_error
+ *         self._last_error = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._thread_id = PyThread_get_thread_ident()
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_last_error);
+  __Pyx_DECREF(__pyx_v_self->_last_error);
+  __pyx_v_self->_last_error = Py_None;
+
+  /* "uvloop/loop.pyx":521
+ *         self._last_error = None
+ * 
+ *         self._thread_id = PyThread_get_thread_ident()             # <<<<<<<<<<<<<<
+ *         self._thread_is_main = MAIN_THREAD_ID == self._thread_id
+ *         self._running = 1
+ */
+  __pyx_v_self->_thread_id = PyThread_get_thread_ident();
+
+  /* "uvloop/loop.pyx":522
+ * 
+ *         self._thread_id = PyThread_get_thread_ident()
+ *         self._thread_is_main = MAIN_THREAD_ID == self._thread_id             # <<<<<<<<<<<<<<
+ *         self._running = 1
+ * 
+ */
+  __pyx_v_self->_thread_is_main = (__pyx_v_6uvloop_4loop_MAIN_THREAD_ID == __pyx_v_self->_thread_id);
+
+  /* "uvloop/loop.pyx":523
+ *         self._thread_id = PyThread_get_thread_ident()
+ *         self._thread_is_main = MAIN_THREAD_ID == self._thread_id
+ *         self._running = 1             # <<<<<<<<<<<<<<
+ * 
+ *         self.handler_check__exec_writes.start()
+ */
+  __pyx_v_self->_running = 1;
+
+  /* "uvloop/loop.pyx":525
+ *         self._running = 1
+ * 
+ *         self.handler_check__exec_writes.start()             # <<<<<<<<<<<<<<
+ *         self.handler_idle.start()
+ * 
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop_7UVCheck_start(__pyx_v_self->handler_check__exec_writes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 525, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":526
+ * 
+ *         self.handler_check__exec_writes.start()
+ *         self.handler_idle.start()             # <<<<<<<<<<<<<<
+ * 
+ *         self._setup_or_resume_signals()
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop_6UVIdle_start(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 526, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":528
+ *         self.handler_idle.start()
+ * 
+ *         self._setup_or_resume_signals()             # <<<<<<<<<<<<<<
+ * 
+ *         if aio_set_running_loop is not None:
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_setup_or_resume_signals(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 528, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":530
+ *         self._setup_or_resume_signals()
+ * 
+ *         if aio_set_running_loop is not None:             # <<<<<<<<<<<<<<
+ *             aio_set_running_loop(self)
+ *         try:
+ */
+  __pyx_t_1 = (__pyx_v_6uvloop_4loop_aio_set_running_loop != Py_None);
+  __pyx_t_3 = (__pyx_t_1 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":531
+ * 
+ *         if aio_set_running_loop is not None:
+ *             aio_set_running_loop(self)             # <<<<<<<<<<<<<<
+ *         try:
+ *             self.__run(mode)
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_set_running_loop);
+    __pyx_t_5 = __pyx_v_6uvloop_4loop_aio_set_running_loop; __pyx_t_6 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_5, ((PyObject *)__pyx_v_self));
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 531, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":530
+ *         self._setup_or_resume_signals()
+ * 
+ *         if aio_set_running_loop is not None:             # <<<<<<<<<<<<<<
+ *             aio_set_running_loop(self)
+ *         try:
+ */
+  }
+
+  /* "uvloop/loop.pyx":532
+ *         if aio_set_running_loop is not None:
+ *             aio_set_running_loop(self)
+ *         try:             # <<<<<<<<<<<<<<
+ *             self.__run(mode)
+ *         finally:
+ */
+  /*try:*/ {
+
+    /* "uvloop/loop.pyx":533
+ *             aio_set_running_loop(self)
+ *         try:
+ *             self.__run(mode)             # <<<<<<<<<<<<<<
+ *         finally:
+ *             if aio_set_running_loop is not None:
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->__pyx___run(__pyx_v_self, __pyx_v_mode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 533, __pyx_L10_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+
+  /* "uvloop/loop.pyx":535
+ *             self.__run(mode)
+ *         finally:
+ *             if aio_set_running_loop is not None:             # <<<<<<<<<<<<<<
+ *                 aio_set_running_loop(None)
+ * 
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_3 = (__pyx_v_6uvloop_4loop_aio_set_running_loop != Py_None);
+      __pyx_t_1 = (__pyx_t_3 != 0);
+      if (__pyx_t_1) {
+
+        /* "uvloop/loop.pyx":536
+ *         finally:
+ *             if aio_set_running_loop is not None:
+ *                 aio_set_running_loop(None)             # <<<<<<<<<<<<<<
+ * 
+ *             self.handler_check__exec_writes.stop()
+ */
+        __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_set_running_loop);
+        __pyx_t_5 = __pyx_v_6uvloop_4loop_aio_set_running_loop; __pyx_t_6 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_6);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_5, function);
+          }
+        }
+        __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, Py_None) : __Pyx_PyObject_CallOneArg(__pyx_t_5, Py_None);
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 536, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/loop.pyx":535
+ *             self.__run(mode)
+ *         finally:
+ *             if aio_set_running_loop is not None:             # <<<<<<<<<<<<<<
+ *                 aio_set_running_loop(None)
+ * 
+ */
+      }
+
+      /* "uvloop/loop.pyx":538
+ *                 aio_set_running_loop(None)
+ * 
+ *             self.handler_check__exec_writes.stop()             # <<<<<<<<<<<<<<
+ *             self.handler_idle.stop()
+ * 
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_7UVCheck_stop(__pyx_v_self->handler_check__exec_writes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 538, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":539
+ * 
+ *             self.handler_check__exec_writes.stop()
+ *             self.handler_idle.stop()             # <<<<<<<<<<<<<<
+ * 
+ *             self._pause_signals()
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_6UVIdle_stop(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 539, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":541
+ *             self.handler_idle.stop()
+ * 
+ *             self._pause_signals()             # <<<<<<<<<<<<<<
+ * 
+ *             self._thread_is_main = 0
+ */
+      __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_pause_signals(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 541, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":543
+ *             self._pause_signals()
+ * 
+ *             self._thread_is_main = 0             # <<<<<<<<<<<<<<
+ *             self._thread_id = 0
+ *             self._running = 0
+ */
+      __pyx_v_self->_thread_is_main = 0;
+
+      /* "uvloop/loop.pyx":544
+ * 
+ *             self._thread_is_main = 0
+ *             self._thread_id = 0             # <<<<<<<<<<<<<<
+ *             self._running = 0
+ *             self._stopping = 0
+ */
+      __pyx_v_self->_thread_id = 0;
+
+      /* "uvloop/loop.pyx":545
+ *             self._thread_is_main = 0
+ *             self._thread_id = 0
+ *             self._running = 0             # <<<<<<<<<<<<<<
+ *             self._stopping = 0
+ * 
+ */
+      __pyx_v_self->_running = 0;
+
+      /* "uvloop/loop.pyx":546
+ *             self._thread_id = 0
+ *             self._running = 0
+ *             self._stopping = 0             # <<<<<<<<<<<<<<
+ * 
+ *         if self._last_error is not None:
+ */
+      __pyx_v_self->_stopping = 0;
+      goto __pyx_L11;
+    }
+    __pyx_L10_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __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_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 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);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __Pyx_XGOTREF(__pyx_t_15);
+      __pyx_t_7 = __pyx_lineno; __pyx_t_8 = __pyx_clineno; __pyx_t_9 = __pyx_filename;
+      {
+
+        /* "uvloop/loop.pyx":535
+ *             self.__run(mode)
+ *         finally:
+ *             if aio_set_running_loop is not None:             # <<<<<<<<<<<<<<
+ *                 aio_set_running_loop(None)
+ * 
+ */
+        __pyx_t_1 = (__pyx_v_6uvloop_4loop_aio_set_running_loop != Py_None);
+        __pyx_t_3 = (__pyx_t_1 != 0);
+        if (__pyx_t_3) {
+
+          /* "uvloop/loop.pyx":536
+ *         finally:
+ *             if aio_set_running_loop is not None:
+ *                 aio_set_running_loop(None)             # <<<<<<<<<<<<<<
+ * 
+ *             self.handler_check__exec_writes.stop()
+ */
+          __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_set_running_loop);
+          __pyx_t_5 = __pyx_v_6uvloop_4loop_aio_set_running_loop; __pyx_t_6 = NULL;
+          if (CYTHON_UNPACK_METHODS && 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_6);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_5, function);
+            }
+          }
+          __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, Py_None) : __Pyx_PyObject_CallOneArg(__pyx_t_5, Py_None);
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 536, __pyx_L14_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+          /* "uvloop/loop.pyx":535
+ *             self.__run(mode)
+ *         finally:
+ *             if aio_set_running_loop is not None:             # <<<<<<<<<<<<<<
+ *                 aio_set_running_loop(None)
+ * 
+ */
+        }
+
+        /* "uvloop/loop.pyx":538
+ *                 aio_set_running_loop(None)
+ * 
+ *             self.handler_check__exec_writes.stop()             # <<<<<<<<<<<<<<
+ *             self.handler_idle.stop()
+ * 
+ */
+        __pyx_t_2 = __pyx_f_6uvloop_4loop_7UVCheck_stop(__pyx_v_self->handler_check__exec_writes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 538, __pyx_L14_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/loop.pyx":539
+ * 
+ *             self.handler_check__exec_writes.stop()
+ *             self.handler_idle.stop()             # <<<<<<<<<<<<<<
+ * 
+ *             self._pause_signals()
+ */
+        __pyx_t_2 = __pyx_f_6uvloop_4loop_6UVIdle_stop(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 539, __pyx_L14_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/loop.pyx":541
+ *             self.handler_idle.stop()
+ * 
+ *             self._pause_signals()             # <<<<<<<<<<<<<<
+ * 
+ *             self._thread_is_main = 0
+ */
+        __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_pause_signals(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 541, __pyx_L14_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/loop.pyx":543
+ *             self._pause_signals()
+ * 
+ *             self._thread_is_main = 0             # <<<<<<<<<<<<<<
+ *             self._thread_id = 0
+ *             self._running = 0
+ */
+        __pyx_v_self->_thread_is_main = 0;
+
+        /* "uvloop/loop.pyx":544
+ * 
+ *             self._thread_is_main = 0
+ *             self._thread_id = 0             # <<<<<<<<<<<<<<
+ *             self._running = 0
+ *             self._stopping = 0
+ */
+        __pyx_v_self->_thread_id = 0;
+
+        /* "uvloop/loop.pyx":545
+ *             self._thread_is_main = 0
+ *             self._thread_id = 0
+ *             self._running = 0             # <<<<<<<<<<<<<<
+ *             self._stopping = 0
+ * 
+ */
+        __pyx_v_self->_running = 0;
+
+        /* "uvloop/loop.pyx":546
+ *             self._thread_id = 0
+ *             self._running = 0
+ *             self._stopping = 0             # <<<<<<<<<<<<<<
+ * 
+ *         if self._last_error is not None:
+ */
+        __pyx_v_self->_stopping = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+      }
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __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_7; __pyx_clineno = __pyx_t_8; __pyx_filename = __pyx_t_9;
+      goto __pyx_L1_error;
+      __pyx_L14_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+      }
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L11:;
+  }
+
+  /* "uvloop/loop.pyx":548
+ *             self._stopping = 0
+ * 
+ *         if self._last_error is not None:             # <<<<<<<<<<<<<<
+ *             # The loop was stopped with an error with 'loop._stop(error)' call
+ *             raise self._last_error
+ */
+  __pyx_t_3 = (__pyx_v_self->_last_error != Py_None);
+  __pyx_t_1 = (__pyx_t_3 != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":550
+ *         if self._last_error is not None:
+ *             # The loop was stopped with an error with 'loop._stop(error)' call
+ *             raise self._last_error             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _close(self):
+ */
+    __Pyx_Raise(__pyx_v_self->_last_error, 0, 0, 0);
+    __PYX_ERR(0, 550, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":548
+ *             self._stopping = 0
+ * 
+ *         if self._last_error is not None:             # <<<<<<<<<<<<<<
+ *             # The loop was stopped with an error with 'loop._stop(error)' call
+ *             raise self._last_error
+ */
+  }
+
+  /* "uvloop/loop.pyx":504
+ *             raise convert_error(err)
+ * 
+ *     cdef _run(self, uv.uv_run_mode mode):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.Loop._run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":552
+ *             raise self._last_error
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__close(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_cb_handle = NULL;
+  PyObject *__pyx_v_poll_handle = NULL;
+  PyObject *__pyx_v_timer_cbhandle = NULL;
+  PyObject *__pyx_v_fileobj = NULL;
+  PyObject *__pyx_v_executor = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  PyObject *(*__pyx_t_4)(PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  Py_ssize_t __pyx_t_8;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  int __pyx_t_11;
+  int __pyx_t_12;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_close", 0);
+
+  /* "uvloop/loop.pyx":555
+ *         cdef int err
+ * 
+ *         if self._running == 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError("Cannot close a running event loop")
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_running == 1) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":556
+ * 
+ *         if self._running == 1:
+ *             raise RuntimeError("Cannot close a running event loop")             # <<<<<<<<<<<<<<
+ * 
+ *         if self._closed == 1:
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 556, __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(0, 556, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":555
+ *         cdef int err
+ * 
+ *         if self._running == 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError("Cannot close a running event loop")
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":558
+ *             raise RuntimeError("Cannot close a running event loop")
+ * 
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_closed == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":559
+ * 
+ *         if self._closed == 1:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._closed = 1
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":558
+ *             raise RuntimeError("Cannot close a running event loop")
+ * 
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":561
+ *             return
+ * 
+ *         self._closed = 1             # <<<<<<<<<<<<<<
+ * 
+ *         for cb_handle in self._ready:
+ */
+  __pyx_v_self->_closed = 1;
+
+  /* "uvloop/loop.pyx":563
+ *         self._closed = 1
+ * 
+ *         for cb_handle in self._ready:             # <<<<<<<<<<<<<<
+ *             cb_handle.cancel()
+ *         self._ready.clear()
+ */
+  if (likely(PyList_CheckExact(__pyx_v_self->_ready)) || PyTuple_CheckExact(__pyx_v_self->_ready)) {
+    __pyx_t_2 = __pyx_v_self->_ready; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
+    __pyx_t_4 = NULL;
+  } else {
+    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_self->_ready); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 563, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 563, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_4)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 563, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 563, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      } else {
+        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 563, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 563, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      }
+    } else {
+      __pyx_t_5 = __pyx_t_4(__pyx_t_2);
+      if (unlikely(!__pyx_t_5)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 563, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_5);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_cb_handle, __pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":564
+ * 
+ *         for cb_handle in self._ready:
+ *             cb_handle.cancel()             # <<<<<<<<<<<<<<
+ *         self._ready.clear()
+ *         self._ready_len = 0
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_cb_handle, __pyx_n_s_cancel); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 564, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 564, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":563
+ *         self._closed = 1
+ * 
+ *         for cb_handle in self._ready:             # <<<<<<<<<<<<<<
+ *             cb_handle.cancel()
+ *         self._ready.clear()
+ */
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":565
+ *         for cb_handle in self._ready:
+ *             cb_handle.cancel()
+ *         self._ready.clear()             # <<<<<<<<<<<<<<
+ *         self._ready_len = 0
+ * 
+ */
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ready, __pyx_n_s_clear); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __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_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  __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(0, 565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":566
+ *             cb_handle.cancel()
+ *         self._ready.clear()
+ *         self._ready_len = 0             # <<<<<<<<<<<<<<
+ * 
+ *         if self._polls:
+ */
+  __pyx_v_self->_ready_len = 0;
+
+  /* "uvloop/loop.pyx":568
+ *         self._ready_len = 0
+ * 
+ *         if self._polls:             # <<<<<<<<<<<<<<
+ *             for poll_handle in self._polls.values():
+ *                 (<UVHandle>poll_handle)._close()
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_polls); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 568, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":569
+ * 
+ *         if self._polls:
+ *             for poll_handle in self._polls.values():             # <<<<<<<<<<<<<<
+ *                 (<UVHandle>poll_handle)._close()
+ * 
+ */
+    __pyx_t_3 = 0;
+    if (unlikely(__pyx_v_self->_polls == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values");
+      __PYX_ERR(0, 569, __pyx_L1_error)
+    }
+    __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_self->_polls, 1, __pyx_n_s_values, (&__pyx_t_8), (&__pyx_t_9)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 569, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_XDECREF(__pyx_t_2);
+    __pyx_t_2 = __pyx_t_5;
+    __pyx_t_5 = 0;
+    while (1) {
+      __pyx_t_10 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_8, &__pyx_t_3, NULL, &__pyx_t_5, NULL, __pyx_t_9);
+      if (unlikely(__pyx_t_10 == 0)) break;
+      if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(0, 569, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_XDECREF_SET(__pyx_v_poll_handle, __pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":570
+ *         if self._polls:
+ *             for poll_handle in self._polls.values():
+ *                 (<UVHandle>poll_handle)._close()             # <<<<<<<<<<<<<<
+ * 
+ *             self._polls.clear()
+ */
+      __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *)((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_poll_handle)->__pyx_vtab)->_close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_poll_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 570, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":572
+ *                 (<UVHandle>poll_handle)._close()
+ * 
+ *             self._polls.clear()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._timers:
+ */
+    if (unlikely(__pyx_v_self->_polls == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "clear");
+      __PYX_ERR(0, 572, __pyx_L1_error)
+    }
+    __pyx_t_11 = __Pyx_PyDict_Clear(__pyx_v_self->_polls); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 572, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":568
+ *         self._ready_len = 0
+ * 
+ *         if self._polls:             # <<<<<<<<<<<<<<
+ *             for poll_handle in self._polls.values():
+ *                 (<UVHandle>poll_handle)._close()
+ */
+  }
+
+  /* "uvloop/loop.pyx":574
+ *             self._polls.clear()
+ * 
+ *         if self._timers:             # <<<<<<<<<<<<<<
+ *             for timer_cbhandle in tuple(self._timers):
+ *                 timer_cbhandle.cancel()
+ */
+  __pyx_t_1 = (__pyx_v_self->_timers != Py_None)&&(PySet_GET_SIZE(__pyx_v_self->_timers) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":575
+ * 
+ *         if self._timers:
+ *             for timer_cbhandle in tuple(self._timers):             # <<<<<<<<<<<<<<
+ *                 timer_cbhandle.cancel()
+ * 
+ */
+    __pyx_t_2 = PySequence_Tuple(__pyx_v_self->_timers); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 575, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = __pyx_t_2; __Pyx_INCREF(__pyx_t_5); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    for (;;) {
+      if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_8); __Pyx_INCREF(__pyx_t_2); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 575, __pyx_L1_error)
+      #else
+      __pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 575, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      #endif
+      __Pyx_XDECREF_SET(__pyx_v_timer_cbhandle, __pyx_t_2);
+      __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":576
+ *         if self._timers:
+ *             for timer_cbhandle in tuple(self._timers):
+ *                 timer_cbhandle.cancel()             # <<<<<<<<<<<<<<
+ * 
+ *         # Close all remaining handles
+ */
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_timer_cbhandle, __pyx_n_s_cancel); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 576, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 576, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":575
+ * 
+ *         if self._timers:
+ *             for timer_cbhandle in tuple(self._timers):             # <<<<<<<<<<<<<<
+ *                 timer_cbhandle.cancel()
+ * 
+ */
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":574
+ *             self._polls.clear()
+ * 
+ *         if self._timers:             # <<<<<<<<<<<<<<
+ *             for timer_cbhandle in tuple(self._timers):
+ *                 timer_cbhandle.cancel()
+ */
+  }
+
+  /* "uvloop/loop.pyx":579
+ * 
+ *         # Close all remaining handles
+ *         self.handler_async._close()             # <<<<<<<<<<<<<<
+ *         self.handler_idle._close()
+ *         self.handler_check__exec_writes._close()
+ */
+  __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->handler_async->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self->handler_async)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 579, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":580
+ *         # Close all remaining handles
+ *         self.handler_async._close()
+ *         self.handler_idle._close()             # <<<<<<<<<<<<<<
+ *         self.handler_check__exec_writes._close()
+ *         __close_all_handles(self)
+ */
+  __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_self->handler_idle->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self->handler_idle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 580, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":581
+ *         self.handler_async._close()
+ *         self.handler_idle._close()
+ *         self.handler_check__exec_writes._close()             # <<<<<<<<<<<<<<
+ *         __close_all_handles(self)
+ *         self._shutdown_signals()
+ */
+  __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_self->handler_check__exec_writes->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self->handler_check__exec_writes)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 581, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":582
+ *         self.handler_idle._close()
+ *         self.handler_check__exec_writes._close()
+ *         __close_all_handles(self)             # <<<<<<<<<<<<<<
+ *         self._shutdown_signals()
+ *         # During this run there should be no open handles,
+ */
+  __pyx_f_6uvloop_4loop___close_all_handles(__pyx_v_self);
+
+  /* "uvloop/loop.pyx":583
+ *         self.handler_check__exec_writes._close()
+ *         __close_all_handles(self)
+ *         self._shutdown_signals()             # <<<<<<<<<<<<<<
+ *         # During this run there should be no open handles,
+ *         # so it should finish right away
+ */
+  __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_shutdown_signals(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 583, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":586
+ *         # During this run there should be no open handles,
+ *         # so it should finish right away
+ *         self.__run(uv.UV_RUN_DEFAULT)             # <<<<<<<<<<<<<<
+ * 
+ *         if self._fd_to_writer_fileobj:
+ */
+  __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->__pyx___run(__pyx_v_self, UV_RUN_DEFAULT); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 586, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":588
+ *         self.__run(uv.UV_RUN_DEFAULT)
+ * 
+ *         if self._fd_to_writer_fileobj:             # <<<<<<<<<<<<<<
+ *             for fileobj in self._fd_to_writer_fileobj.values():
+ *                 socket_dec_io_ref(fileobj)
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_fd_to_writer_fileobj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 588, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":589
+ * 
+ *         if self._fd_to_writer_fileobj:
+ *             for fileobj in self._fd_to_writer_fileobj.values():             # <<<<<<<<<<<<<<
+ *                 socket_dec_io_ref(fileobj)
+ *             self._fd_to_writer_fileobj.clear()
+ */
+    __pyx_t_8 = 0;
+    if (unlikely(__pyx_v_self->_fd_to_writer_fileobj == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values");
+      __PYX_ERR(0, 589, __pyx_L1_error)
+    }
+    __pyx_t_2 = __Pyx_dict_iterator(__pyx_v_self->_fd_to_writer_fileobj, 1, __pyx_n_s_values, (&__pyx_t_3), (&__pyx_t_9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 589, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_XDECREF(__pyx_t_5);
+    __pyx_t_5 = __pyx_t_2;
+    __pyx_t_2 = 0;
+    while (1) {
+      __pyx_t_10 = __Pyx_dict_iter_next(__pyx_t_5, __pyx_t_3, &__pyx_t_8, NULL, &__pyx_t_2, NULL, __pyx_t_9);
+      if (unlikely(__pyx_t_10 == 0)) break;
+      if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(0, 589, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_XDECREF_SET(__pyx_v_fileobj, __pyx_t_2);
+      __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":590
+ *         if self._fd_to_writer_fileobj:
+ *             for fileobj in self._fd_to_writer_fileobj.values():
+ *                 socket_dec_io_ref(fileobj)             # <<<<<<<<<<<<<<
+ *             self._fd_to_writer_fileobj.clear()
+ * 
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_socket_dec_io_ref(__pyx_v_fileobj); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 590, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":591
+ *             for fileobj in self._fd_to_writer_fileobj.values():
+ *                 socket_dec_io_ref(fileobj)
+ *             self._fd_to_writer_fileobj.clear()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._fd_to_reader_fileobj:
+ */
+    if (unlikely(__pyx_v_self->_fd_to_writer_fileobj == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "clear");
+      __PYX_ERR(0, 591, __pyx_L1_error)
+    }
+    __pyx_t_11 = __Pyx_PyDict_Clear(__pyx_v_self->_fd_to_writer_fileobj); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 591, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":588
+ *         self.__run(uv.UV_RUN_DEFAULT)
+ * 
+ *         if self._fd_to_writer_fileobj:             # <<<<<<<<<<<<<<
+ *             for fileobj in self._fd_to_writer_fileobj.values():
+ *                 socket_dec_io_ref(fileobj)
+ */
+  }
+
+  /* "uvloop/loop.pyx":593
+ *             self._fd_to_writer_fileobj.clear()
+ * 
+ *         if self._fd_to_reader_fileobj:             # <<<<<<<<<<<<<<
+ *             for fileobj in self._fd_to_reader_fileobj.values():
+ *                 socket_dec_io_ref(fileobj)
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_fd_to_reader_fileobj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 593, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":594
+ * 
+ *         if self._fd_to_reader_fileobj:
+ *             for fileobj in self._fd_to_reader_fileobj.values():             # <<<<<<<<<<<<<<
+ *                 socket_dec_io_ref(fileobj)
+ *             self._fd_to_reader_fileobj.clear()
+ */
+    __pyx_t_3 = 0;
+    if (unlikely(__pyx_v_self->_fd_to_reader_fileobj == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values");
+      __PYX_ERR(0, 594, __pyx_L1_error)
+    }
+    __pyx_t_2 = __Pyx_dict_iterator(__pyx_v_self->_fd_to_reader_fileobj, 1, __pyx_n_s_values, (&__pyx_t_8), (&__pyx_t_9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 594, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_XDECREF(__pyx_t_5);
+    __pyx_t_5 = __pyx_t_2;
+    __pyx_t_2 = 0;
+    while (1) {
+      __pyx_t_10 = __Pyx_dict_iter_next(__pyx_t_5, __pyx_t_8, &__pyx_t_3, NULL, &__pyx_t_2, NULL, __pyx_t_9);
+      if (unlikely(__pyx_t_10 == 0)) break;
+      if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(0, 594, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_XDECREF_SET(__pyx_v_fileobj, __pyx_t_2);
+      __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":595
+ *         if self._fd_to_reader_fileobj:
+ *             for fileobj in self._fd_to_reader_fileobj.values():
+ *                 socket_dec_io_ref(fileobj)             # <<<<<<<<<<<<<<
+ *             self._fd_to_reader_fileobj.clear()
+ * 
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_socket_dec_io_ref(__pyx_v_fileobj); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 595, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":596
+ *             for fileobj in self._fd_to_reader_fileobj.values():
+ *                 socket_dec_io_ref(fileobj)
+ *             self._fd_to_reader_fileobj.clear()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._timers:
+ */
+    if (unlikely(__pyx_v_self->_fd_to_reader_fileobj == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "clear");
+      __PYX_ERR(0, 596, __pyx_L1_error)
+    }
+    __pyx_t_11 = __Pyx_PyDict_Clear(__pyx_v_self->_fd_to_reader_fileobj); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 596, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":593
+ *             self._fd_to_writer_fileobj.clear()
+ * 
+ *         if self._fd_to_reader_fileobj:             # <<<<<<<<<<<<<<
+ *             for fileobj in self._fd_to_reader_fileobj.values():
+ *                 socket_dec_io_ref(fileobj)
+ */
+  }
+
+  /* "uvloop/loop.pyx":598
+ *             self._fd_to_reader_fileobj.clear()
+ * 
+ *         if self._timers:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 f"new timers were queued during loop closing: {self._timers}")
+ */
+  __pyx_t_1 = (__pyx_v_self->_timers != Py_None)&&(PySet_GET_SIZE(__pyx_v_self->_timers) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":600
+ *         if self._timers:
+ *             raise RuntimeError(
+ *                 f"new timers were queued during loop closing: {self._timers}")             # <<<<<<<<<<<<<<
+ * 
+ *         if self._polls:
+ */
+    __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_self->_timers, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 600, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_new_timers_were_queued_during_lo, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 600, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":599
+ * 
+ *         if self._timers:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 f"new timers were queued during loop closing: {self._timers}")
+ * 
+ */
+    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 599, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(0, 599, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":598
+ *             self._fd_to_reader_fileobj.clear()
+ * 
+ *         if self._timers:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 f"new timers were queued during loop closing: {self._timers}")
+ */
+  }
+
+  /* "uvloop/loop.pyx":602
+ *                 f"new timers were queued during loop closing: {self._timers}")
+ * 
+ *         if self._polls:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 f"new poll handles were queued during loop closing: "
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_polls); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 602, __pyx_L1_error)
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":605
+ *             raise RuntimeError(
+ *                 f"new poll handles were queued during loop closing: "
+ *                 f"{self._polls}")             # <<<<<<<<<<<<<<
+ * 
+ *         if self._ready:
+ */
+    __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_self->_polls, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 605, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+
+    /* "uvloop/loop.pyx":604
+ *         if self._polls:
+ *             raise RuntimeError(
+ *                 f"new poll handles were queued during loop closing: "             # <<<<<<<<<<<<<<
+ *                 f"{self._polls}")
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_new_poll_handles_were_queued_dur, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 604, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":603
+ * 
+ *         if self._polls:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 f"new poll handles were queued during loop closing: "
+ *                 f"{self._polls}")
+ */
+    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 603, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(0, 603, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":602
+ *                 f"new timers were queued during loop closing: {self._timers}")
+ * 
+ *         if self._polls:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 f"new poll handles were queued during loop closing: "
+ */
+  }
+
+  /* "uvloop/loop.pyx":607
+ *                 f"{self._polls}")
+ * 
+ *         if self._ready:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 f"new callbacks were queued during loop closing: "
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_ready); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 607, __pyx_L1_error)
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":610
+ *             raise RuntimeError(
+ *                 f"new callbacks were queued during loop closing: "
+ *                 f"{self._ready}")             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_loop_close(self.uvloop)
+ */
+    __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_self->_ready, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 610, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+
+    /* "uvloop/loop.pyx":609
+ *         if self._ready:
+ *             raise RuntimeError(
+ *                 f"new callbacks were queued during loop closing: "             # <<<<<<<<<<<<<<
+ *                 f"{self._ready}")
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_new_callbacks_were_queued_during, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 609, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":608
+ * 
+ *         if self._ready:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 f"new callbacks were queued during loop closing: "
+ *                 f"{self._ready}")
+ */
+    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 608, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(0, 608, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":607
+ *                 f"{self._polls}")
+ * 
+ *         if self._ready:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 f"new callbacks were queued during loop closing: "
+ */
+  }
+
+  /* "uvloop/loop.pyx":612
+ *                 f"{self._ready}")
+ * 
+ *         err = uv.uv_loop_close(self.uvloop)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             raise convert_error(err)
+ */
+  __pyx_v_err = uv_loop_close(__pyx_v_self->uvloop);
+
+  /* "uvloop/loop.pyx":613
+ * 
+ *         err = uv.uv_loop_close(self.uvloop)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":614
+ *         err = uv.uv_loop_close(self.uvloop)
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         self.handler_async = None
+ */
+    __pyx_t_5 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 614, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(0, 614, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":613
+ * 
+ *         err = uv.uv_loop_close(self.uvloop)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":616
+ *             raise convert_error(err)
+ * 
+ *         self.handler_async = None             # <<<<<<<<<<<<<<
+ *         self.handler_idle = None
+ *         self.handler_check__exec_writes = None
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->handler_async);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->handler_async));
+  __pyx_v_self->handler_async = ((struct __pyx_obj_6uvloop_4loop_UVAsync *)Py_None);
+
+  /* "uvloop/loop.pyx":617
+ * 
+ *         self.handler_async = None
+ *         self.handler_idle = None             # <<<<<<<<<<<<<<
+ *         self.handler_check__exec_writes = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->handler_idle);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->handler_idle));
+  __pyx_v_self->handler_idle = ((struct __pyx_obj_6uvloop_4loop_UVIdle *)Py_None);
+
+  /* "uvloop/loop.pyx":618
+ *         self.handler_async = None
+ *         self.handler_idle = None
+ *         self.handler_check__exec_writes = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._executor_shutdown_called = True
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->handler_check__exec_writes);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->handler_check__exec_writes));
+  __pyx_v_self->handler_check__exec_writes = ((struct __pyx_obj_6uvloop_4loop_UVCheck *)Py_None);
+
+  /* "uvloop/loop.pyx":620
+ *         self.handler_check__exec_writes = None
+ * 
+ *         self._executor_shutdown_called = True             # <<<<<<<<<<<<<<
+ *         executor = self._default_executor
+ *         if executor is not None:
+ */
+  __pyx_v_self->_executor_shutdown_called = 1;
+
+  /* "uvloop/loop.pyx":621
+ * 
+ *         self._executor_shutdown_called = True
+ *         executor = self._default_executor             # <<<<<<<<<<<<<<
+ *         if executor is not None:
+ *             self._default_executor = None
+ */
+  __pyx_t_5 = __pyx_v_self->_default_executor;
+  __Pyx_INCREF(__pyx_t_5);
+  __pyx_v_executor = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":622
+ *         self._executor_shutdown_called = True
+ *         executor = self._default_executor
+ *         if executor is not None:             # <<<<<<<<<<<<<<
+ *             self._default_executor = None
+ *             executor.shutdown(wait=False)
+ */
+  __pyx_t_1 = (__pyx_v_executor != Py_None);
+  __pyx_t_12 = (__pyx_t_1 != 0);
+  if (__pyx_t_12) {
+
+    /* "uvloop/loop.pyx":623
+ *         executor = self._default_executor
+ *         if executor is not None:
+ *             self._default_executor = None             # <<<<<<<<<<<<<<
+ *             executor.shutdown(wait=False)
+ * 
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_default_executor);
+    __Pyx_DECREF(__pyx_v_self->_default_executor);
+    __pyx_v_self->_default_executor = Py_None;
+
+    /* "uvloop/loop.pyx":624
+ *         if executor is not None:
+ *             self._default_executor = None
+ *             executor.shutdown(wait=False)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef uint64_t _time(self):
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_executor, __pyx_n_s_shutdown); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 624, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 624, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_wait, Py_False) < 0) __PYX_ERR(0, 624, __pyx_L1_error)
+    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 624, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/loop.pyx":622
+ *         self._executor_shutdown_called = True
+ *         executor = self._default_executor
+ *         if executor is not None:             # <<<<<<<<<<<<<<
+ *             self._default_executor = None
+ *             executor.shutdown(wait=False)
+ */
+  }
+
+  /* "uvloop/loop.pyx":552
+ *             raise self._last_error
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.Loop._close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_cb_handle);
+  __Pyx_XDECREF(__pyx_v_poll_handle);
+  __Pyx_XDECREF(__pyx_v_timer_cbhandle);
+  __Pyx_XDECREF(__pyx_v_fileobj);
+  __Pyx_XDECREF(__pyx_v_executor);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":626
+ *             executor.shutdown(wait=False)
+ * 
+ *     cdef uint64_t _time(self):             # <<<<<<<<<<<<<<
+ *         # asyncio doesn't have a time cache, neither should uvloop.
+ *         uv.uv_update_time(self.uvloop)  # void
+ */
+
+static uint64_t __pyx_f_6uvloop_4loop_4Loop__time(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  uint64_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_time", 0);
+
+  /* "uvloop/loop.pyx":628
+ *     cdef uint64_t _time(self):
+ *         # asyncio doesn't have a time cache, neither should uvloop.
+ *         uv.uv_update_time(self.uvloop)  # void             # <<<<<<<<<<<<<<
+ *         return uv.uv_now(self.uvloop)
+ * 
+ */
+  uv_update_time(__pyx_v_self->uvloop);
+
+  /* "uvloop/loop.pyx":629
+ *         # asyncio doesn't have a time cache, neither should uvloop.
+ *         uv.uv_update_time(self.uvloop)  # void
+ *         return uv.uv_now(self.uvloop)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _queue_write(self, UVStream stream):
+ */
+  __pyx_r = uv_now(__pyx_v_self->uvloop);
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":626
+ *             executor.shutdown(wait=False)
+ * 
+ *     cdef uint64_t _time(self):             # <<<<<<<<<<<<<<
+ *         # asyncio doesn't have a time cache, neither should uvloop.
+ *         uv.uv_update_time(self.uvloop)  # void
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":631
+ *         return uv.uv_now(self.uvloop)
+ * 
+ *     cdef inline _queue_write(self, UVStream stream):             # <<<<<<<<<<<<<<
+ *         self._queued_streams.add(stream)
+ *         if not self.handler_check__exec_writes.running:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__queue_write(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_stream) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("_queue_write", 0);
+
+  /* "uvloop/loop.pyx":632
+ * 
+ *     cdef inline _queue_write(self, UVStream stream):
+ *         self._queued_streams.add(stream)             # <<<<<<<<<<<<<<
+ *         if not self.handler_check__exec_writes.running:
+ *             self.handler_check__exec_writes.start()
+ */
+  if (unlikely(__pyx_v_self->_queued_streams == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "add");
+    __PYX_ERR(0, 632, __pyx_L1_error)
+  }
+  __pyx_t_1 = PySet_Add(__pyx_v_self->_queued_streams, ((PyObject *)__pyx_v_stream)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 632, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":633
+ *     cdef inline _queue_write(self, UVStream stream):
+ *         self._queued_streams.add(stream)
+ *         if not self.handler_check__exec_writes.running:             # <<<<<<<<<<<<<<
+ *             self.handler_check__exec_writes.start()
+ * 
+ */
+  __pyx_t_2 = ((!(__pyx_v_self->handler_check__exec_writes->running != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":634
+ *         self._queued_streams.add(stream)
+ *         if not self.handler_check__exec_writes.running:
+ *             self.handler_check__exec_writes.start()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _exec_queued_writes(self):
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_7UVCheck_start(__pyx_v_self->handler_check__exec_writes); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 634, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":633
+ *     cdef inline _queue_write(self, UVStream stream):
+ *         self._queued_streams.add(stream)
+ *         if not self.handler_check__exec_writes.running:             # <<<<<<<<<<<<<<
+ *             self.handler_check__exec_writes.start()
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":631
+ *         return uv.uv_now(self.uvloop)
+ * 
+ *     cdef inline _queue_write(self, UVStream stream):             # <<<<<<<<<<<<<<
+ *         self._queued_streams.add(stream)
+ *         if not self.handler_check__exec_writes.running:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.Loop._queue_write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":636
+ *             self.handler_check__exec_writes.start()
+ * 
+ *     cdef _exec_queued_writes(self):             # <<<<<<<<<<<<<<
+ *         if len(self._queued_streams) == 0:
+ *             if self.handler_check__exec_writes.running:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__exec_queued_writes(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_stream = 0;
+  int __pyx_v_queued_len;
+  PyObject *__pyx_v_pystream = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  int __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_exec_queued_writes", 0);
+
+  /* "uvloop/loop.pyx":637
+ * 
+ *     cdef _exec_queued_writes(self):
+ *         if len(self._queued_streams) == 0:             # <<<<<<<<<<<<<<
+ *             if self.handler_check__exec_writes.running:
+ *                 self.handler_check__exec_writes.stop()
+ */
+  __pyx_t_1 = __pyx_v_self->_queued_streams;
+  __Pyx_INCREF(__pyx_t_1);
+  if (unlikely(__pyx_t_1 == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(0, 637, __pyx_L1_error)
+  }
+  __pyx_t_2 = PySet_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 637, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = ((__pyx_t_2 == 0) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":638
+ *     cdef _exec_queued_writes(self):
+ *         if len(self._queued_streams) == 0:
+ *             if self.handler_check__exec_writes.running:             # <<<<<<<<<<<<<<
+ *                 self.handler_check__exec_writes.stop()
+ *             return
+ */
+    __pyx_t_3 = (__pyx_v_self->handler_check__exec_writes->running != 0);
+    if (__pyx_t_3) {
+
+      /* "uvloop/loop.pyx":639
+ *         if len(self._queued_streams) == 0:
+ *             if self.handler_check__exec_writes.running:
+ *                 self.handler_check__exec_writes.stop()             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop_7UVCheck_stop(__pyx_v_self->handler_check__exec_writes); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 639, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":638
+ *     cdef _exec_queued_writes(self):
+ *         if len(self._queued_streams) == 0:
+ *             if self.handler_check__exec_writes.running:             # <<<<<<<<<<<<<<
+ *                 self.handler_check__exec_writes.stop()
+ *             return
+ */
+    }
+
+    /* "uvloop/loop.pyx":640
+ *             if self.handler_check__exec_writes.running:
+ *                 self.handler_check__exec_writes.stop()
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         cdef:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":637
+ * 
+ *     cdef _exec_queued_writes(self):
+ *         if len(self._queued_streams) == 0:             # <<<<<<<<<<<<<<
+ *             if self.handler_check__exec_writes.running:
+ *                 self.handler_check__exec_writes.stop()
+ */
+  }
+
+  /* "uvloop/loop.pyx":646
+ *             int queued_len
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             queued_len = len(self._queued_streams)
+ * 
+ */
+  __pyx_t_3 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":647
+ * 
+ *         if UVLOOP_DEBUG:
+ *             queued_len = len(self._queued_streams)             # <<<<<<<<<<<<<<
+ * 
+ *         for pystream in self._queued_streams:
+ */
+    __pyx_t_1 = __pyx_v_self->_queued_streams;
+    __Pyx_INCREF(__pyx_t_1);
+    if (unlikely(__pyx_t_1 == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+      __PYX_ERR(0, 647, __pyx_L1_error)
+    }
+    __pyx_t_2 = PySet_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 647, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_v_queued_len = __pyx_t_2;
+
+    /* "uvloop/loop.pyx":646
+ *             int queued_len
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             queued_len = len(self._queued_streams)
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":649
+ *             queued_len = len(self._queued_streams)
+ * 
+ *         for pystream in self._queued_streams:             # <<<<<<<<<<<<<<
+ *             stream = <UVStream>pystream
+ *             stream._exec_write()
+ */
+  __pyx_t_2 = 0;
+  __pyx_t_6 = __Pyx_set_iterator(__pyx_v_self->_queued_streams, 1, (&__pyx_t_4), (&__pyx_t_5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 649, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_1);
+  __pyx_t_1 = __pyx_t_6;
+  __pyx_t_6 = 0;
+  while (1) {
+    __pyx_t_7 = __Pyx_set_iter_next(__pyx_t_1, __pyx_t_4, &__pyx_t_2, &__pyx_t_6, __pyx_t_5);
+    if (unlikely(__pyx_t_7 == 0)) break;
+    if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 649, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_XDECREF_SET(__pyx_v_pystream, __pyx_t_6);
+    __pyx_t_6 = 0;
+
+    /* "uvloop/loop.pyx":650
+ * 
+ *         for pystream in self._queued_streams:
+ *             stream = <UVStream>pystream             # <<<<<<<<<<<<<<
+ *             stream._exec_write()
+ * 
+ */
+    __pyx_t_6 = __pyx_v_pystream;
+    __Pyx_INCREF(__pyx_t_6);
+    __Pyx_XDECREF_SET(__pyx_v_stream, ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_6));
+    __pyx_t_6 = 0;
+
+    /* "uvloop/loop.pyx":651
+ *         for pystream in self._queued_streams:
+ *             stream = <UVStream>pystream
+ *             stream._exec_write()             # <<<<<<<<<<<<<<
+ * 
+ *         if UVLOOP_DEBUG:
+ */
+    __pyx_t_6 = __pyx_f_6uvloop_4loop_8UVStream__exec_write(__pyx_v_stream); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 651, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":653
+ *             stream._exec_write()
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if len(self._queued_streams) != queued_len:
+ *                 raise RuntimeError(
+ */
+  __pyx_t_3 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":654
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if len(self._queued_streams) != queued_len:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     'loop._queued_streams are not empty after '
+ */
+    __pyx_t_1 = __pyx_v_self->_queued_streams;
+    __Pyx_INCREF(__pyx_t_1);
+    if (unlikely(__pyx_t_1 == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+      __PYX_ERR(0, 654, __pyx_L1_error)
+    }
+    __pyx_t_4 = PySet_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 654, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_3 = ((__pyx_t_4 != __pyx_v_queued_len) != 0);
+    if (unlikely(__pyx_t_3)) {
+
+      /* "uvloop/loop.pyx":655
+ *         if UVLOOP_DEBUG:
+ *             if len(self._queued_streams) != queued_len:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     'loop._queued_streams are not empty after '
+ *                     '_exec_queued_writes')
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 655, __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, 655, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":654
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if len(self._queued_streams) != queued_len:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     'loop._queued_streams are not empty after '
+ */
+    }
+
+    /* "uvloop/loop.pyx":653
+ *             stream._exec_write()
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if len(self._queued_streams) != queued_len:
+ *                 raise RuntimeError(
+ */
+  }
+
+  /* "uvloop/loop.pyx":659
+ *                     '_exec_queued_writes')
+ * 
+ *         self._queued_streams.clear()             # <<<<<<<<<<<<<<
+ * 
+ *         if self.handler_check__exec_writes.running:
+ */
+  if (unlikely(__pyx_v_self->_queued_streams == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "clear");
+    __PYX_ERR(0, 659, __pyx_L1_error)
+  }
+  __pyx_t_8 = PySet_Clear(__pyx_v_self->_queued_streams); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 659, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":661
+ *         self._queued_streams.clear()
+ * 
+ *         if self.handler_check__exec_writes.running:             # <<<<<<<<<<<<<<
+ *             self.handler_check__exec_writes.stop()
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->handler_check__exec_writes->running != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":662
+ * 
+ *         if self.handler_check__exec_writes.running:
+ *             self.handler_check__exec_writes.stop()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _call_soon(self, object callback, object args, object context):
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_7UVCheck_stop(__pyx_v_self->handler_check__exec_writes); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 662, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":661
+ *         self._queued_streams.clear()
+ * 
+ *         if self.handler_check__exec_writes.running:             # <<<<<<<<<<<<<<
+ *             self.handler_check__exec_writes.stop()
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":636
+ *             self.handler_check__exec_writes.start()
+ * 
+ *     cdef _exec_queued_writes(self):             # <<<<<<<<<<<<<<
+ *         if len(self._queued_streams) == 0:
+ *             if self.handler_check__exec_writes.running:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.Loop._exec_queued_writes", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_stream);
+  __Pyx_XDECREF(__pyx_v_pystream);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":664
+ *             self.handler_check__exec_writes.stop()
+ * 
+ *     cdef inline _call_soon(self, object callback, object args, object context):             # <<<<<<<<<<<<<<
+ *         cdef Handle handle
+ *         handle = new_Handle(self, callback, args, context)
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args, PyObject *__pyx_v_context) {
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
+  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("_call_soon", 0);
+
+  /* "uvloop/loop.pyx":666
+ *     cdef inline _call_soon(self, object callback, object args, object context):
+ *         cdef Handle handle
+ *         handle = new_Handle(self, callback, args, context)             # <<<<<<<<<<<<<<
+ *         self._call_soon_handle(handle)
+ *         return handle
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_new_Handle(__pyx_v_self, __pyx_v_callback, __pyx_v_args, __pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 666, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 666, __pyx_L1_error)
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":667
+ *         cdef Handle handle
+ *         handle = new_Handle(self, callback, args, context)
+ *         self._call_soon_handle(handle)             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_self, __pyx_v_handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 667, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":668
+ *         handle = new_Handle(self, callback, args, context)
+ *         self._call_soon_handle(handle)
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _append_ready_handle(self, Handle handle):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = ((PyObject *)__pyx_v_handle);
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":664
+ *             self.handler_check__exec_writes.stop()
+ * 
+ *     cdef inline _call_soon(self, object callback, object args, object context):             # <<<<<<<<<<<<<<
+ *         cdef Handle handle
+ *         handle = new_Handle(self, callback, args, context)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._call_soon", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":670
+ *         return handle
+ * 
+ *     cdef inline _append_ready_handle(self, Handle handle):             # <<<<<<<<<<<<<<
+ *         self._check_closed()
+ *         self._ready.append(handle)
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__append_ready_handle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_append_ready_handle", 0);
+
+  /* "uvloop/loop.pyx":671
+ * 
+ *     cdef inline _append_ready_handle(self, Handle handle):
+ *         self._check_closed()             # <<<<<<<<<<<<<<
+ *         self._ready.append(handle)
+ *         self._ready_len += 1
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 671, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":672
+ *     cdef inline _append_ready_handle(self, Handle handle):
+ *         self._check_closed()
+ *         self._ready.append(handle)             # <<<<<<<<<<<<<<
+ *         self._ready_len += 1
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_Append(__pyx_v_self->_ready, ((PyObject *)__pyx_v_handle)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 672, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":673
+ *         self._check_closed()
+ *         self._ready.append(handle)
+ *         self._ready_len += 1             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _call_soon_handle(self, Handle handle):
+ */
+  __pyx_v_self->_ready_len = (__pyx_v_self->_ready_len + 1);
+
+  /* "uvloop/loop.pyx":670
+ *         return handle
+ * 
+ *     cdef inline _append_ready_handle(self, Handle handle):             # <<<<<<<<<<<<<<
+ *         self._check_closed()
+ *         self._ready.append(handle)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._append_ready_handle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":675
+ *         self._ready_len += 1
+ * 
+ *     cdef inline _call_soon_handle(self, Handle handle):             # <<<<<<<<<<<<<<
+ *         self._append_ready_handle(handle)
+ *         if not self.handler_idle.running:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon_handle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_call_soon_handle", 0);
+
+  /* "uvloop/loop.pyx":676
+ * 
+ *     cdef inline _call_soon_handle(self, Handle handle):
+ *         self._append_ready_handle(handle)             # <<<<<<<<<<<<<<
+ *         if not self.handler_idle.running:
+ *             self.handler_idle.start()
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__append_ready_handle(__pyx_v_self, __pyx_v_handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 676, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":677
+ *     cdef inline _call_soon_handle(self, Handle handle):
+ *         self._append_ready_handle(handle)
+ *         if not self.handler_idle.running:             # <<<<<<<<<<<<<<
+ *             self.handler_idle.start()
+ * 
+ */
+  __pyx_t_2 = ((!(__pyx_v_self->handler_idle->running != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":678
+ *         self._append_ready_handle(handle)
+ *         if not self.handler_idle.running:
+ *             self.handler_idle.start()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _call_later(self, uint64_t delay, object callback, object args,
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_6UVIdle_start(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 678, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":677
+ *     cdef inline _call_soon_handle(self, Handle handle):
+ *         self._append_ready_handle(handle)
+ *         if not self.handler_idle.running:             # <<<<<<<<<<<<<<
+ *             self.handler_idle.start()
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":675
+ *         self._ready_len += 1
+ * 
+ *     cdef inline _call_soon_handle(self, Handle handle):             # <<<<<<<<<<<<<<
+ *         self._append_ready_handle(handle)
+ *         if not self.handler_idle.running:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._call_soon_handle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":680
+ *             self.handler_idle.start()
+ * 
+ *     cdef _call_later(self, uint64_t delay, object callback, object args,             # <<<<<<<<<<<<<<
+ *                      object context):
+ *         return TimerHandle(self, callback, args, delay, context)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__call_later(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uint64_t __pyx_v_delay, PyObject *__pyx_v_callback, PyObject *__pyx_v_args, PyObject *__pyx_v_context) {
+  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("_call_later", 0);
+
+  /* "uvloop/loop.pyx":682
+ *     cdef _call_later(self, uint64_t delay, object callback, object args,
+ *                      object context):
+ *         return TimerHandle(self, callback, args, delay, context)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef void _handle_exception(self, object ex):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_delay); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 682, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 682, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self));
+  __Pyx_INCREF(__pyx_v_callback);
+  __Pyx_GIVEREF(__pyx_v_callback);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_callback);
+  __Pyx_INCREF(__pyx_v_args);
+  __Pyx_GIVEREF(__pyx_v_args);
+  PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_args);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_1);
+  __Pyx_INCREF(__pyx_v_context);
+  __Pyx_GIVEREF(__pyx_v_context);
+  PyTuple_SET_ITEM(__pyx_t_2, 4, __pyx_v_context);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_TimerHandle), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 682, __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;
+
+  /* "uvloop/loop.pyx":680
+ *             self.handler_idle.start()
+ * 
+ *     cdef _call_later(self, uint64_t delay, object callback, object args,             # <<<<<<<<<<<<<<
+ *                      object context):
+ *         return TimerHandle(self, callback, args, delay, context)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop._call_later", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":684
+ *         return TimerHandle(self, callback, args, delay, context)
+ * 
+ *     cdef void _handle_exception(self, object ex):             # <<<<<<<<<<<<<<
+ *         if isinstance(ex, Exception):
+ *             self.call_exception_handler({'exception': ex})
+ */
+
+static void __pyx_f_6uvloop_4loop_4Loop__handle_exception(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_ex) {
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_handle_exception", 0);
+
+  /* "uvloop/loop.pyx":685
+ * 
+ *     cdef void _handle_exception(self, object ex):
+ *         if isinstance(ex, Exception):             # <<<<<<<<<<<<<<
+ *             self.call_exception_handler({'exception': ex})
+ *         else:
+ */
+  __pyx_t_1 = __Pyx_PyException_Check(__pyx_v_ex); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":686
+ *     cdef void _handle_exception(self, object ex):
+ *         if isinstance(ex, Exception):
+ *             self.call_exception_handler({'exception': ex})             # <<<<<<<<<<<<<<
+ *         else:
+ *             # BaseException
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 686, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 686, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (PyDict_SetItem(__pyx_t_5, __pyx_n_u_exception, __pyx_v_ex) < 0) __PYX_ERR(0, 686, __pyx_L1_error)
+    __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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __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, 686, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":685
+ * 
+ *     cdef void _handle_exception(self, object ex):
+ *         if isinstance(ex, Exception):             # <<<<<<<<<<<<<<
+ *             self.call_exception_handler({'exception': ex})
+ *         else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/loop.pyx":689
+ *         else:
+ *             # BaseException
+ *             self._last_error = ex             # <<<<<<<<<<<<<<
+ *             # Exit ASAP
+ *             self._stop(None)
+ */
+  /*else*/ {
+    __Pyx_INCREF(__pyx_v_ex);
+    __Pyx_GIVEREF(__pyx_v_ex);
+    __Pyx_GOTREF(__pyx_v_self->_last_error);
+    __Pyx_DECREF(__pyx_v_self->_last_error);
+    __pyx_v_self->_last_error = __pyx_v_ex;
+
+    /* "uvloop/loop.pyx":691
+ *             self._last_error = ex
+ *             # Exit ASAP
+ *             self._stop(None)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _check_signal(self, sig):
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_stop(__pyx_v_self, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 691, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/loop.pyx":684
+ *         return TimerHandle(self, callback, args, delay, context)
+ * 
+ *     cdef void _handle_exception(self, object ex):             # <<<<<<<<<<<<<<
+ *         if isinstance(ex, Exception):
+ *             self.call_exception_handler({'exception': ex})
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_WriteUnraisable("uvloop.loop.Loop._handle_exception", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/loop.pyx":693
+ *             self._stop(None)
+ * 
+ *     cdef inline _check_signal(self, sig):             # <<<<<<<<<<<<<<
+ *         if not isinstance(sig, int):
+ *             raise TypeError('sig must be an int, not {!r}'.format(sig))
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_signal(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_check_signal", 0);
+
+  /* "uvloop/loop.pyx":694
+ * 
+ *     cdef inline _check_signal(self, sig):
+ *         if not isinstance(sig, int):             # <<<<<<<<<<<<<<
+ *             raise TypeError('sig must be an int, not {!r}'.format(sig))
+ * 
+ */
+  __pyx_t_1 = PyInt_Check(__pyx_v_sig); 
+  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/loop.pyx":695
+ *     cdef inline _check_signal(self, sig):
+ *         if not isinstance(sig, int):
+ *             raise TypeError('sig must be an int, not {!r}'.format(sig))             # <<<<<<<<<<<<<<
+ * 
+ *         if not (1 <= sig < signal_NSIG):
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_sig_must_be_an_int_not_r, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 695, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_sig) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sig);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 695, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(0, 695, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":694
+ * 
+ *     cdef inline _check_signal(self, sig):
+ *         if not isinstance(sig, int):             # <<<<<<<<<<<<<<
+ *             raise TypeError('sig must be an int, not {!r}'.format(sig))
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":697
+ *             raise TypeError('sig must be an int, not {!r}'.format(sig))
+ * 
+ *         if not (1 <= sig < signal_NSIG):             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'sig {} out of range(1, {})'.format(sig, signal_NSIG))
+ */
+  __pyx_t_4 = PyObject_RichCompare(__pyx_int_1, __pyx_v_sig, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 697, __pyx_L1_error)
+  if (__Pyx_PyObject_IsTrue(__pyx_t_4)) {
+    __Pyx_DECREF(__pyx_t_4);
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_signal_NSIG); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 697, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = PyObject_RichCompare(__pyx_v_sig, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 697, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 697, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_1 = ((!__pyx_t_2) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":699
+ *         if not (1 <= sig < signal_NSIG):
+ *             raise ValueError(
+ *                 'sig {} out of range(1, {})'.format(sig, signal_NSIG))             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _check_closed(self):
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_sig_out_of_range_1, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 699, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_signal_NSIG); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 699, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = NULL;
+    __pyx_t_7 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(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_7 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_sig, __pyx_t_5};
+      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 699, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_sig, __pyx_t_5};
+      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 699, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 699, __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_v_sig);
+      __Pyx_GIVEREF(__pyx_v_sig);
+      PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_v_sig);
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5);
+      __pyx_t_5 = 0;
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 699, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":698
+ * 
+ *         if not (1 <= sig < signal_NSIG):
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'sig {} out of range(1, {})'.format(sig, signal_NSIG))
+ * 
+ */
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 698, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(0, 698, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":697
+ *             raise TypeError('sig must be an int, not {!r}'.format(sig))
+ * 
+ *         if not (1 <= sig < signal_NSIG):             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'sig {} out of range(1, {})'.format(sig, signal_NSIG))
+ */
+  }
+
+  /* "uvloop/loop.pyx":693
+ *             self._stop(None)
+ * 
+ *     cdef inline _check_signal(self, sig):             # <<<<<<<<<<<<<<
+ *         if not isinstance(sig, int):
+ *             raise TypeError('sig must be an int, not {!r}'.format(sig))
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.Loop._check_signal", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":701
+ *                 'sig {} out of range(1, {})'.format(sig, signal_NSIG))
+ * 
+ *     cdef inline _check_closed(self):             # <<<<<<<<<<<<<<
+ *         if self._closed == 1:
+ *             raise RuntimeError('Event loop is closed')
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_closed(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  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("_check_closed", 0);
+
+  /* "uvloop/loop.pyx":702
+ * 
+ *     cdef inline _check_closed(self):
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Event loop is closed')
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_closed == 1) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":703
+ *     cdef inline _check_closed(self):
+ *         if self._closed == 1:
+ *             raise RuntimeError('Event loop is closed')             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _check_thread(self):
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 703, __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(0, 703, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":702
+ * 
+ *     cdef inline _check_closed(self):
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Event loop is closed')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":701
+ *                 'sig {} out of range(1, {})'.format(sig, signal_NSIG))
+ * 
+ *     cdef inline _check_closed(self):             # <<<<<<<<<<<<<<
+ *         if self._closed == 1:
+ *             raise RuntimeError('Event loop is closed')
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop._check_closed", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":705
+ *             raise RuntimeError('Event loop is closed')
+ * 
+ *     cdef inline _check_thread(self):             # <<<<<<<<<<<<<<
+ *         if self._thread_id == 0:
+ *             return
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_thread(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  uint64_t __pyx_v_thread_id;
+  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("_check_thread", 0);
+
+  /* "uvloop/loop.pyx":706
+ * 
+ *     cdef inline _check_thread(self):
+ *         if self._thread_id == 0:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_thread_id == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":707
+ *     cdef inline _check_thread(self):
+ *         if self._thread_id == 0:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         cdef uint64_t thread_id
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":706
+ * 
+ *     cdef inline _check_thread(self):
+ *         if self._thread_id == 0:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":710
+ * 
+ *         cdef uint64_t thread_id
+ *         thread_id = <uint64_t><int64_t>PyThread_get_thread_ident()             # <<<<<<<<<<<<<<
+ * 
+ *         if thread_id != self._thread_id:
+ */
+  __pyx_v_thread_id = ((uint64_t)((int64_t)PyThread_get_thread_ident()));
+
+  /* "uvloop/loop.pyx":712
+ *         thread_id = <uint64_t><int64_t>PyThread_get_thread_ident()
+ * 
+ *         if thread_id != self._thread_id:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 "Non-thread-safe operation invoked on an event loop other "
+ */
+  __pyx_t_1 = ((__pyx_v_thread_id != __pyx_v_self->_thread_id) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":713
+ * 
+ *         if thread_id != self._thread_id:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 "Non-thread-safe operation invoked on an event loop other "
+ *                 "than the current one")
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 713, __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(0, 713, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":712
+ *         thread_id = <uint64_t><int64_t>PyThread_get_thread_ident()
+ * 
+ *         if thread_id != self._thread_id:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 "Non-thread-safe operation invoked on an event loop other "
+ */
+  }
+
+  /* "uvloop/loop.pyx":705
+ *             raise RuntimeError('Event loop is closed')
+ * 
+ *     cdef inline _check_thread(self):             # <<<<<<<<<<<<<<
+ *         if self._thread_id == 0:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop._check_thread", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":717
+ *                 "than the current one")
+ * 
+ *     cdef inline _new_future(self):             # <<<<<<<<<<<<<<
+ *         return aio_Future(loop=self)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__new_future(struct __pyx_obj_6uvloop_4loop_Loop *__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("_new_future", 0);
+
+  /* "uvloop/loop.pyx":718
+ * 
+ *     cdef inline _new_future(self):
+ *         return aio_Future(loop=self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _track_transport(self, UVBaseTransport transport):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 718, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_loop, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(0, 718, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_Future, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 718, __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;
+
+  /* "uvloop/loop.pyx":717
+ *                 "than the current one")
+ * 
+ *     cdef inline _new_future(self):             # <<<<<<<<<<<<<<
+ *         return aio_Future(loop=self)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop._new_future", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":720
+ *         return aio_Future(loop=self)
+ * 
+ *     cdef _track_transport(self, UVBaseTransport transport):             # <<<<<<<<<<<<<<
+ *         self._transports[transport._fileno()] = transport
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__track_transport(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_transport) {
+  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("_track_transport", 0);
+
+  /* "uvloop/loop.pyx":721
+ * 
+ *     cdef _track_transport(self, UVBaseTransport transport):
+ *         self._transports[transport._fileno()] = transport             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _track_process(self, UVProcess proc):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_transport->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._fileno(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_transport)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 721, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (unlikely(PyObject_SetItem(__pyx_v_self->_transports, __pyx_t_1, ((PyObject *)__pyx_v_transport)) < 0)) __PYX_ERR(0, 721, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":720
+ *         return aio_Future(loop=self)
+ * 
+ *     cdef _track_transport(self, UVBaseTransport transport):             # <<<<<<<<<<<<<<
+ *         self._transports[transport._fileno()] = transport
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._track_transport", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":723
+ *         self._transports[transport._fileno()] = transport
+ * 
+ *     cdef _track_process(self, UVProcess proc):             # <<<<<<<<<<<<<<
+ *         self._processes.add(proc)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__track_process(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_proc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_track_process", 0);
+
+  /* "uvloop/loop.pyx":724
+ * 
+ *     cdef _track_process(self, UVProcess proc):
+ *         self._processes.add(proc)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _untrack_process(self, UVProcess proc):
+ */
+  if (unlikely(__pyx_v_self->_processes == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "add");
+    __PYX_ERR(0, 724, __pyx_L1_error)
+  }
+  __pyx_t_1 = PySet_Add(__pyx_v_self->_processes, ((PyObject *)__pyx_v_proc)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 724, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":723
+ *         self._transports[transport._fileno()] = transport
+ * 
+ *     cdef _track_process(self, UVProcess proc):             # <<<<<<<<<<<<<<
+ *         self._processes.add(proc)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop._track_process", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":726
+ *         self._processes.add(proc)
+ * 
+ *     cdef _untrack_process(self, UVProcess proc):             # <<<<<<<<<<<<<<
+ *         self._processes.discard(proc)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__untrack_process(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_proc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_untrack_process", 0);
+
+  /* "uvloop/loop.pyx":727
+ * 
+ *     cdef _untrack_process(self, UVProcess proc):
+ *         self._processes.discard(proc)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _fileobj_to_fd(self, fileobj):
+ */
+  if (unlikely(__pyx_v_self->_processes == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "discard");
+    __PYX_ERR(0, 727, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_PySet_Discard(__pyx_v_self->_processes, ((PyObject *)__pyx_v_proc)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 727, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":726
+ *         self._processes.add(proc)
+ * 
+ *     cdef _untrack_process(self, UVProcess proc):             # <<<<<<<<<<<<<<
+ *         self._processes.discard(proc)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop._untrack_process", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":729
+ *         self._processes.discard(proc)
+ * 
+ *     cdef _fileobj_to_fd(self, fileobj):             # <<<<<<<<<<<<<<
+ *         """Return a file descriptor from a file object.
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__fileobj_to_fd(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj) {
+  PyObject *__pyx_v_fd = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_9;
+  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("_fileobj_to_fd", 0);
+
+  /* "uvloop/loop.pyx":742
+ *         """
+ *         # Copy of the `selectors._fileobj_to_fd()` function.
+ *         if isinstance(fileobj, int):             # <<<<<<<<<<<<<<
+ *             fd = fileobj
+ *         else:
+ */
+  __pyx_t_1 = PyInt_Check(__pyx_v_fileobj); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":743
+ *         # Copy of the `selectors._fileobj_to_fd()` function.
+ *         if isinstance(fileobj, int):
+ *             fd = fileobj             # <<<<<<<<<<<<<<
+ *         else:
+ *             try:
+ */
+    __Pyx_INCREF(__pyx_v_fileobj);
+    __pyx_v_fd = __pyx_v_fileobj;
+
+    /* "uvloop/loop.pyx":742
+ *         """
+ *         # Copy of the `selectors._fileobj_to_fd()` function.
+ *         if isinstance(fileobj, int):             # <<<<<<<<<<<<<<
+ *             fd = fileobj
+ *         else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/loop.pyx":745
+ *             fd = fileobj
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 fd = int(fileobj.fileno())
+ *             except (AttributeError, TypeError, ValueError):
+ */
+  /*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:*/ {
+
+        /* "uvloop/loop.pyx":746
+ *         else:
+ *             try:
+ *                 fd = int(fileobj.fileno())             # <<<<<<<<<<<<<<
+ *             except (AttributeError, TypeError, ValueError):
+ *                 raise ValueError("Invalid file object: "
+ */
+        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_fileobj, __pyx_n_s_fileno); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 746, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __pyx_t_8 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+          if (likely(__pyx_t_8)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+            __Pyx_INCREF(__pyx_t_8);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_7, function);
+          }
+        }
+        __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 746, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __pyx_t_7 = __Pyx_PyNumber_Int(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 746, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __pyx_v_fd = __pyx_t_7;
+        __pyx_t_7 = 0;
+
+        /* "uvloop/loop.pyx":745
+ *             fd = fileobj
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 fd = int(fileobj.fileno())
+ *             except (AttributeError, TypeError, ValueError):
+ */
+      }
+      __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;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "uvloop/loop.pyx":747
+ *             try:
+ *                 fd = int(fileobj.fileno())
+ *             except (AttributeError, TypeError, ValueError):             # <<<<<<<<<<<<<<
+ *                 raise ValueError("Invalid file object: "
+ *                                  "{!r}".format(fileobj)) from None
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.Loop._fileobj_to_fd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_8) < 0) __PYX_ERR(0, 747, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_8);
+
+        /* "uvloop/loop.pyx":749
+ *             except (AttributeError, TypeError, ValueError):
+ *                 raise ValueError("Invalid file object: "
+ *                                  "{!r}".format(fileobj)) from None             # <<<<<<<<<<<<<<
+ *         if fd < 0:
+ *             raise ValueError("Invalid file descriptor: {}".format(fd))
+ */
+        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Invalid_file_object_r, __pyx_n_s_format); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 749, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __pyx_t_12 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+          __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+          if (likely(__pyx_t_12)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+            __Pyx_INCREF(__pyx_t_12);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_11, function);
+          }
+        }
+        __pyx_t_10 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_12, __pyx_v_fileobj) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_fileobj);
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 749, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+
+        /* "uvloop/loop.pyx":748
+ *                 fd = int(fileobj.fileno())
+ *             except (AttributeError, TypeError, ValueError):
+ *                 raise ValueError("Invalid file object: "             # <<<<<<<<<<<<<<
+ *                                  "{!r}".format(fileobj)) from None
+ *         if fd < 0:
+ */
+        __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 748, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+        /* "uvloop/loop.pyx":749
+ *             except (AttributeError, TypeError, ValueError):
+ *                 raise ValueError("Invalid file object: "
+ *                                  "{!r}".format(fileobj)) from None             # <<<<<<<<<<<<<<
+ *         if fd < 0:
+ *             raise ValueError("Invalid file descriptor: {}".format(fd))
+ */
+        __Pyx_Raise(__pyx_t_11, 0, 0, Py_None);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __PYX_ERR(0, 748, __pyx_L6_except_error)
+      }
+      goto __pyx_L6_except_error;
+      __pyx_L6_except_error:;
+
+      /* "uvloop/loop.pyx":745
+ *             fd = fileobj
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 fd = int(fileobj.fileno())
+ *             except (AttributeError, TypeError, ValueError):
+ */
+      __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:;
+    }
+  }
+  __pyx_L3:;
+
+  /* "uvloop/loop.pyx":750
+ *                 raise ValueError("Invalid file object: "
+ *                                  "{!r}".format(fileobj)) from None
+ *         if fd < 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Invalid file descriptor: {}".format(fd))
+ *         return fd
+ */
+  __pyx_t_8 = PyObject_RichCompare(__pyx_v_fd, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 750, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 750, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/loop.pyx":751
+ *                                  "{!r}".format(fileobj)) from None
+ *         if fd < 0:
+ *             raise ValueError("Invalid file descriptor: {}".format(fd))             # <<<<<<<<<<<<<<
+ *         return fd
+ * 
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Invalid_file_descriptor, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 751, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    __pyx_t_8 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_v_fd) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_fd);
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 751, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 751, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __PYX_ERR(0, 751, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":750
+ *                 raise ValueError("Invalid file object: "
+ *                                  "{!r}".format(fileobj)) from None
+ *         if fd < 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Invalid file descriptor: {}".format(fd))
+ *         return fd
+ */
+  }
+
+  /* "uvloop/loop.pyx":752
+ *         if fd < 0:
+ *             raise ValueError("Invalid file descriptor: {}".format(fd))
+ *         return fd             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _ensure_fd_no_transport(self, fd):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_fd);
+  __pyx_r = __pyx_v_fd;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":729
+ *         self._processes.discard(proc)
+ * 
+ *     cdef _fileobj_to_fd(self, fileobj):             # <<<<<<<<<<<<<<
+ *         """Return a file descriptor from a file object.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("uvloop.loop.Loop._fileobj_to_fd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fd);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":754
+ *         return fd
+ * 
+ *     cdef _ensure_fd_no_transport(self, fd):             # <<<<<<<<<<<<<<
+ *         cdef UVBaseTransport tr
+ *         try:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__ensure_fd_no_transport(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd) {
+  struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_tr = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ensure_fd_no_transport", 0);
+
+  /* "uvloop/loop.pyx":756
+ *     cdef _ensure_fd_no_transport(self, fd):
+ *         cdef UVBaseTransport tr
+ *         try:             # <<<<<<<<<<<<<<
+ *             tr = <UVBaseTransport>(self._transports[fd])
+ *         except KeyError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":757
+ *         cdef UVBaseTransport tr
+ *         try:
+ *             tr = <UVBaseTransport>(self._transports[fd])             # <<<<<<<<<<<<<<
+ *         except KeyError:
+ *             pass
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_self->_transports, __pyx_v_fd); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 757, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __pyx_t_4;
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_v_tr = ((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":756
+ *     cdef _ensure_fd_no_transport(self, fd):
+ *         cdef UVBaseTransport tr
+ *         try:             # <<<<<<<<<<<<<<
+ *             tr = <UVBaseTransport>(self._transports[fd])
+ *         except KeyError:
+ */
+    }
+
+    /* "uvloop/loop.pyx":761
+ *             pass
+ *         else:
+ *             if tr._is_alive():             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     'File descriptor {!r} is used by transport {!r}'.format(
+ */
+    /*else:*/ {
+      __pyx_t_6 = (((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_tr->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_tr)) != 0);
+      if (unlikely(__pyx_t_6)) {
+
+        /* "uvloop/loop.pyx":763
+ *             if tr._is_alive():
+ *                 raise RuntimeError(
+ *                     'File descriptor {!r} is used by transport {!r}'.format(             # <<<<<<<<<<<<<<
+ *                         fd, tr))
+ * 
+ */
+        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_File_descriptor_r_is_used_by_tra, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 763, __pyx_L5_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+
+        /* "uvloop/loop.pyx":764
+ *                 raise RuntimeError(
+ *                     'File descriptor {!r} is used by transport {!r}'.format(
+ *                         fd, tr))             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _add_reader(self, fileobj, Handle handle):
+ */
+        __pyx_t_7 = NULL;
+        __pyx_t_8 = 0;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+          __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+          if (likely(__pyx_t_7)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+            __Pyx_INCREF(__pyx_t_7);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_4, function);
+            __pyx_t_8 = 1;
+          }
+        }
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_4)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_fd, ((PyObject *)__pyx_v_tr)};
+          __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 763, __pyx_L5_except_error)
+          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __Pyx_GOTREF(__pyx_t_5);
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_fd, ((PyObject *)__pyx_v_tr)};
+          __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 763, __pyx_L5_except_error)
+          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __Pyx_GOTREF(__pyx_t_5);
+        } else
+        #endif
+        {
+          __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 763, __pyx_L5_except_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_v_fd);
+          __Pyx_GIVEREF(__pyx_v_fd);
+          PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_v_fd);
+          __Pyx_INCREF(((PyObject *)__pyx_v_tr));
+          __Pyx_GIVEREF(((PyObject *)__pyx_v_tr));
+          PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, ((PyObject *)__pyx_v_tr));
+          __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 763, __pyx_L5_except_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/loop.pyx":762
+ *         else:
+ *             if tr._is_alive():
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     'File descriptor {!r} is used by transport {!r}'.format(
+ *                         fd, tr))
+ */
+        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 762, __pyx_L5_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __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, 762, __pyx_L5_except_error)
+
+        /* "uvloop/loop.pyx":761
+ *             pass
+ *         else:
+ *             if tr._is_alive():             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     'File descriptor {!r} is used by transport {!r}'.format(
+ */
+      }
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":758
+ *         try:
+ *             tr = <UVBaseTransport>(self._transports[fd])
+ *         except KeyError:             # <<<<<<<<<<<<<<
+ *             pass
+ *         else:
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_8) {
+      __Pyx_ErrRestore(0,0,0);
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/loop.pyx":756
+ *     cdef _ensure_fd_no_transport(self, fd):
+ *         cdef UVBaseTransport tr
+ *         try:             # <<<<<<<<<<<<<<
+ *             tr = <UVBaseTransport>(self._transports[fd])
+ *         except KeyError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":754
+ *         return fd
+ * 
+ *     cdef _ensure_fd_no_transport(self, fd):             # <<<<<<<<<<<<<<
+ *         cdef UVBaseTransport tr
+ *         try:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.Loop._ensure_fd_no_transport", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_tr);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":766
+ *                         fd, tr))
+ * 
+ *     cdef _add_reader(self, fileobj, Handle handle):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__add_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle) {
+  struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_poll = 0;
+  PyObject *__pyx_v_fd = NULL;
+  PyObject *__pyx_v_old_fileobj = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_add_reader", 0);
+
+  /* "uvloop/loop.pyx":770
+ *             UVPoll poll
+ * 
+ *         self._check_closed()             # <<<<<<<<<<<<<<
+ *         fd = self._fileobj_to_fd(fileobj)
+ *         self._ensure_fd_no_transport(fd)
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 770, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":771
+ * 
+ *         self._check_closed()
+ *         fd = self._fileobj_to_fd(fileobj)             # <<<<<<<<<<<<<<
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_fileobj_to_fd(__pyx_v_self, __pyx_v_fileobj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 771, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fd = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":772
+ *         self._check_closed()
+ *         fd = self._fileobj_to_fd(fileobj)
+ *         self._ensure_fd_no_transport(fd)             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_ensure_fd_no_transport(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 772, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":774
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":775
+ * 
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])             # <<<<<<<<<<<<<<
+ *         except KeyError:
+ *             poll = UVPoll.new(self, fd)
+ */
+      if (unlikely(__pyx_v_self->_polls == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 775, __pyx_L3_error)
+      }
+      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->_polls, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 775, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_5 = __pyx_t_1;
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_v_poll = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":774
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":776
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:             # <<<<<<<<<<<<<<
+ *             poll = UVPoll.new(self, fd)
+ *             self._polls[fd] = poll
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._add_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(0, 776, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "uvloop/loop.pyx":777
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ *             poll = UVPoll.new(self, fd)             # <<<<<<<<<<<<<<
+ *             self._polls[fd] = poll
+ * 
+ */
+      __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_fd); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 777, __pyx_L5_except_error)
+      __pyx_t_8 = ((PyObject *)__pyx_f_6uvloop_4loop_6UVPoll_new(__pyx_v_self, __pyx_t_6)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 777, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_XDECREF_SET(__pyx_v_poll, ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_8));
+      __pyx_t_8 = 0;
+
+      /* "uvloop/loop.pyx":778
+ *         except KeyError:
+ *             poll = UVPoll.new(self, fd)
+ *             self._polls[fd] = poll             # <<<<<<<<<<<<<<
+ * 
+ *         poll.start_reading(handle)
+ */
+      if (unlikely(__pyx_v_self->_polls == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 778, __pyx_L5_except_error)
+      }
+      if (unlikely(PyDict_SetItem(__pyx_v_self->_polls, __pyx_v_fd, ((PyObject *)__pyx_v_poll)) < 0)) __PYX_ERR(0, 778, __pyx_L5_except_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/loop.pyx":774
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":780
+ *             self._polls[fd] = poll
+ * 
+ *         poll.start_reading(handle)             # <<<<<<<<<<<<<<
+ * 
+ *         old_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+ */
+  __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->start_reading(__pyx_v_poll, __pyx_v_handle); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 780, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":782
+ *         poll.start_reading(handle)
+ * 
+ *         old_fileobj = self._fd_to_reader_fileobj.pop(fd, None)             # <<<<<<<<<<<<<<
+ *         if old_fileobj is not None:
+ *             socket_dec_io_ref(old_fileobj)
+ */
+  if (unlikely(__pyx_v_self->_fd_to_reader_fileobj == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "pop");
+    __PYX_ERR(0, 782, __pyx_L1_error)
+  }
+  __pyx_t_7 = __Pyx_PyDict_Pop(__pyx_v_self->_fd_to_reader_fileobj, __pyx_v_fd, Py_None); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 782, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_v_old_fileobj = __pyx_t_7;
+  __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":783
+ * 
+ *         old_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+ *         if old_fileobj is not None:             # <<<<<<<<<<<<<<
+ *             socket_dec_io_ref(old_fileobj)
+ * 
+ */
+  __pyx_t_9 = (__pyx_v_old_fileobj != Py_None);
+  __pyx_t_10 = (__pyx_t_9 != 0);
+  if (__pyx_t_10) {
+
+    /* "uvloop/loop.pyx":784
+ *         old_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+ *         if old_fileobj is not None:
+ *             socket_dec_io_ref(old_fileobj)             # <<<<<<<<<<<<<<
+ * 
+ *         self._fd_to_reader_fileobj[fd] = fileobj
+ */
+    __pyx_t_7 = __pyx_f_6uvloop_4loop_socket_dec_io_ref(__pyx_v_old_fileobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 784, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":783
+ * 
+ *         old_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+ *         if old_fileobj is not None:             # <<<<<<<<<<<<<<
+ *             socket_dec_io_ref(old_fileobj)
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":786
+ *             socket_dec_io_ref(old_fileobj)
+ * 
+ *         self._fd_to_reader_fileobj[fd] = fileobj             # <<<<<<<<<<<<<<
+ *         socket_inc_io_ref(fileobj)
+ * 
+ */
+  if (unlikely(__pyx_v_self->_fd_to_reader_fileobj == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(0, 786, __pyx_L1_error)
+  }
+  if (unlikely(PyDict_SetItem(__pyx_v_self->_fd_to_reader_fileobj, __pyx_v_fd, __pyx_v_fileobj) < 0)) __PYX_ERR(0, 786, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":787
+ * 
+ *         self._fd_to_reader_fileobj[fd] = fileobj
+ *         socket_inc_io_ref(fileobj)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _remove_reader(self, fileobj):
+ */
+  __pyx_t_7 = __pyx_f_6uvloop_4loop_socket_inc_io_ref(__pyx_v_fileobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 787, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":766
+ *                         fd, tr))
+ * 
+ *     cdef _add_reader(self, fileobj, Handle handle):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.Loop._add_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_poll);
+  __Pyx_XDECREF(__pyx_v_fd);
+  __Pyx_XDECREF(__pyx_v_old_fileobj);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":789
+ *         socket_inc_io_ref(fileobj)
+ * 
+ *     cdef _remove_reader(self, fileobj):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__remove_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj) {
+  struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_poll = 0;
+  PyObject *__pyx_v_fd = NULL;
+  PyObject *__pyx_v_mapped_fileobj = NULL;
+  PyObject *__pyx_v_result = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_remove_reader", 0);
+
+  /* "uvloop/loop.pyx":793
+ *             UVPoll poll
+ * 
+ *         fd = self._fileobj_to_fd(fileobj)             # <<<<<<<<<<<<<<
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_fileobj_to_fd(__pyx_v_self, __pyx_v_fileobj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 793, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fd = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":794
+ * 
+ *         fd = self._fileobj_to_fd(fileobj)
+ *         self._ensure_fd_no_transport(fd)             # <<<<<<<<<<<<<<
+ * 
+ *         mapped_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_ensure_fd_no_transport(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 794, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":796
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ *         mapped_fileobj = self._fd_to_reader_fileobj.pop(fd, None)             # <<<<<<<<<<<<<<
+ *         if mapped_fileobj is not None:
+ *             socket_dec_io_ref(mapped_fileobj)
+ */
+  if (unlikely(__pyx_v_self->_fd_to_reader_fileobj == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "pop");
+    __PYX_ERR(0, 796, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_PyDict_Pop(__pyx_v_self->_fd_to_reader_fileobj, __pyx_v_fd, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 796, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_mapped_fileobj = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":797
+ * 
+ *         mapped_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+ *         if mapped_fileobj is not None:             # <<<<<<<<<<<<<<
+ *             socket_dec_io_ref(mapped_fileobj)
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_mapped_fileobj != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":798
+ *         mapped_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+ *         if mapped_fileobj is not None:
+ *             socket_dec_io_ref(mapped_fileobj)             # <<<<<<<<<<<<<<
+ * 
+ *         if self._closed == 1:
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_socket_dec_io_ref(__pyx_v_mapped_fileobj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 798, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":797
+ * 
+ *         mapped_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+ *         if mapped_fileobj is not None:             # <<<<<<<<<<<<<<
+ *             socket_dec_io_ref(mapped_fileobj)
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":800
+ *             socket_dec_io_ref(mapped_fileobj)
+ * 
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_self->_closed == 1) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":801
+ * 
+ *         if self._closed == 1:
+ *             return False             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_False);
+    __pyx_r = Py_False;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":800
+ *             socket_dec_io_ref(mapped_fileobj)
+ * 
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":803
+ *             return False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_6);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":804
+ * 
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])             # <<<<<<<<<<<<<<
+ *         except KeyError:
+ *             return False
+ */
+      if (unlikely(__pyx_v_self->_polls == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 804, __pyx_L5_error)
+      }
+      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->_polls, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 804, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_7 = __pyx_t_1;
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_v_poll = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_7);
+      __pyx_t_7 = 0;
+
+      /* "uvloop/loop.pyx":803
+ *             return False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L5_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":805
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._remove_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(0, 805, __pyx_L7_except_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_9);
+
+      /* "uvloop/loop.pyx":806
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ *             return False             # <<<<<<<<<<<<<<
+ * 
+ *         result = poll.stop_reading()
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __Pyx_INCREF(Py_False);
+      __pyx_r = Py_False;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      goto __pyx_L8_except_return;
+    }
+    goto __pyx_L7_except_error;
+    __pyx_L7_except_error:;
+
+    /* "uvloop/loop.pyx":803
+ *             return False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L1_error;
+    __pyx_L8_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L0;
+    __pyx_L10_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":808
+ *             return False
+ * 
+ *         result = poll.stop_reading()             # <<<<<<<<<<<<<<
+ *         if not poll.is_active():
+ *             del self._polls[fd]
+ */
+  __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->stop_reading(__pyx_v_poll); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 808, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __pyx_v_result = __pyx_t_9;
+  __pyx_t_9 = 0;
+
+  /* "uvloop/loop.pyx":809
+ * 
+ *         result = poll.stop_reading()
+ *         if not poll.is_active():             # <<<<<<<<<<<<<<
+ *             del self._polls[fd]
+ *             poll._close()
+ */
+  __pyx_t_3 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->is_active(__pyx_v_poll) != 0)) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":810
+ *         result = poll.stop_reading()
+ *         if not poll.is_active():
+ *             del self._polls[fd]             # <<<<<<<<<<<<<<
+ *             poll._close()
+ * 
+ */
+    if (unlikely(__pyx_v_self->_polls == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 810, __pyx_L1_error)
+    }
+    if (unlikely(PyDict_DelItem(__pyx_v_self->_polls, __pyx_v_fd) < 0)) __PYX_ERR(0, 810, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":811
+ *         if not poll.is_active():
+ *             del self._polls[fd]
+ *             poll._close()             # <<<<<<<<<<<<<<
+ * 
+ *         return result
+ */
+    __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_poll)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 811, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/loop.pyx":809
+ * 
+ *         result = poll.stop_reading()
+ *         if not poll.is_active():             # <<<<<<<<<<<<<<
+ *             del self._polls[fd]
+ *             poll._close()
+ */
+  }
+
+  /* "uvloop/loop.pyx":813
+ *             poll._close()
+ * 
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _has_reader(self, fileobj):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_result);
+  __pyx_r = __pyx_v_result;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":789
+ *         socket_inc_io_ref(fileobj)
+ * 
+ *     cdef _remove_reader(self, fileobj):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.Loop._remove_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_poll);
+  __Pyx_XDECREF(__pyx_v_fd);
+  __Pyx_XDECREF(__pyx_v_mapped_fileobj);
+  __Pyx_XDECREF(__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":815
+ *         return result
+ * 
+ *     cdef _has_reader(self, fileobj):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__has_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj) {
+  struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_poll = 0;
+  PyObject *__pyx_v_fd = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_has_reader", 0);
+
+  /* "uvloop/loop.pyx":819
+ *             UVPoll poll
+ * 
+ *         self._check_closed()             # <<<<<<<<<<<<<<
+ *         fd = self._fileobj_to_fd(fileobj)
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 819, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":820
+ * 
+ *         self._check_closed()
+ *         fd = self._fileobj_to_fd(fileobj)             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_fileobj_to_fd(__pyx_v_self, __pyx_v_fileobj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 820, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fd = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":822
+ *         fd = self._fileobj_to_fd(fileobj)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":823
+ * 
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])             # <<<<<<<<<<<<<<
+ *         except KeyError:
+ *             return False
+ */
+      if (unlikely(__pyx_v_self->_polls == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 823, __pyx_L3_error)
+      }
+      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->_polls, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 823, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_5 = __pyx_t_1;
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_v_poll = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":822
+ *         fd = self._fileobj_to_fd(fileobj)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":824
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._has_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(0, 824, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "uvloop/loop.pyx":825
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ *             return False             # <<<<<<<<<<<<<<
+ * 
+ *         return poll.is_reading()
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __Pyx_INCREF(Py_False);
+      __pyx_r = Py_False;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L6_except_return;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/loop.pyx":822
+ *         fd = self._fileobj_to_fd(fileobj)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":827
+ *             return False
+ * 
+ *         return poll.is_reading()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _add_writer(self, fileobj, Handle handle):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->is_reading(__pyx_v_poll); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 827, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_r = __pyx_t_7;
+  __pyx_t_7 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":815
+ *         return result
+ * 
+ *     cdef _has_reader(self, fileobj):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.Loop._has_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_poll);
+  __Pyx_XDECREF(__pyx_v_fd);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":829
+ *         return poll.is_reading()
+ * 
+ *     cdef _add_writer(self, fileobj, Handle handle):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__add_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle) {
+  struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_poll = 0;
+  PyObject *__pyx_v_fd = NULL;
+  PyObject *__pyx_v_old_fileobj = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_add_writer", 0);
+
+  /* "uvloop/loop.pyx":833
+ *             UVPoll poll
+ * 
+ *         self._check_closed()             # <<<<<<<<<<<<<<
+ *         fd = self._fileobj_to_fd(fileobj)
+ *         self._ensure_fd_no_transport(fd)
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 833, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":834
+ * 
+ *         self._check_closed()
+ *         fd = self._fileobj_to_fd(fileobj)             # <<<<<<<<<<<<<<
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_fileobj_to_fd(__pyx_v_self, __pyx_v_fileobj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 834, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fd = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":835
+ *         self._check_closed()
+ *         fd = self._fileobj_to_fd(fileobj)
+ *         self._ensure_fd_no_transport(fd)             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_ensure_fd_no_transport(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 835, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":837
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":838
+ * 
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])             # <<<<<<<<<<<<<<
+ *         except KeyError:
+ *             poll = UVPoll.new(self, fd)
+ */
+      if (unlikely(__pyx_v_self->_polls == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 838, __pyx_L3_error)
+      }
+      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->_polls, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 838, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_5 = __pyx_t_1;
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_v_poll = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":837
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":839
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:             # <<<<<<<<<<<<<<
+ *             poll = UVPoll.new(self, fd)
+ *             self._polls[fd] = poll
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._add_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(0, 839, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "uvloop/loop.pyx":840
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ *             poll = UVPoll.new(self, fd)             # <<<<<<<<<<<<<<
+ *             self._polls[fd] = poll
+ * 
+ */
+      __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_fd); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 840, __pyx_L5_except_error)
+      __pyx_t_8 = ((PyObject *)__pyx_f_6uvloop_4loop_6UVPoll_new(__pyx_v_self, __pyx_t_6)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 840, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_XDECREF_SET(__pyx_v_poll, ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_8));
+      __pyx_t_8 = 0;
+
+      /* "uvloop/loop.pyx":841
+ *         except KeyError:
+ *             poll = UVPoll.new(self, fd)
+ *             self._polls[fd] = poll             # <<<<<<<<<<<<<<
+ * 
+ *         poll.start_writing(handle)
+ */
+      if (unlikely(__pyx_v_self->_polls == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 841, __pyx_L5_except_error)
+      }
+      if (unlikely(PyDict_SetItem(__pyx_v_self->_polls, __pyx_v_fd, ((PyObject *)__pyx_v_poll)) < 0)) __PYX_ERR(0, 841, __pyx_L5_except_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/loop.pyx":837
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":843
+ *             self._polls[fd] = poll
+ * 
+ *         poll.start_writing(handle)             # <<<<<<<<<<<<<<
+ * 
+ *         old_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+ */
+  __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->start_writing(__pyx_v_poll, __pyx_v_handle); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 843, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":845
+ *         poll.start_writing(handle)
+ * 
+ *         old_fileobj = self._fd_to_writer_fileobj.pop(fd, None)             # <<<<<<<<<<<<<<
+ *         if old_fileobj is not None:
+ *             socket_dec_io_ref(old_fileobj)
+ */
+  if (unlikely(__pyx_v_self->_fd_to_writer_fileobj == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "pop");
+    __PYX_ERR(0, 845, __pyx_L1_error)
+  }
+  __pyx_t_7 = __Pyx_PyDict_Pop(__pyx_v_self->_fd_to_writer_fileobj, __pyx_v_fd, Py_None); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 845, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_v_old_fileobj = __pyx_t_7;
+  __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":846
+ * 
+ *         old_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+ *         if old_fileobj is not None:             # <<<<<<<<<<<<<<
+ *             socket_dec_io_ref(old_fileobj)
+ * 
+ */
+  __pyx_t_9 = (__pyx_v_old_fileobj != Py_None);
+  __pyx_t_10 = (__pyx_t_9 != 0);
+  if (__pyx_t_10) {
+
+    /* "uvloop/loop.pyx":847
+ *         old_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+ *         if old_fileobj is not None:
+ *             socket_dec_io_ref(old_fileobj)             # <<<<<<<<<<<<<<
+ * 
+ *         self._fd_to_writer_fileobj[fd] = fileobj
+ */
+    __pyx_t_7 = __pyx_f_6uvloop_4loop_socket_dec_io_ref(__pyx_v_old_fileobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 847, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":846
+ * 
+ *         old_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+ *         if old_fileobj is not None:             # <<<<<<<<<<<<<<
+ *             socket_dec_io_ref(old_fileobj)
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":849
+ *             socket_dec_io_ref(old_fileobj)
+ * 
+ *         self._fd_to_writer_fileobj[fd] = fileobj             # <<<<<<<<<<<<<<
+ *         socket_inc_io_ref(fileobj)
+ * 
+ */
+  if (unlikely(__pyx_v_self->_fd_to_writer_fileobj == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(0, 849, __pyx_L1_error)
+  }
+  if (unlikely(PyDict_SetItem(__pyx_v_self->_fd_to_writer_fileobj, __pyx_v_fd, __pyx_v_fileobj) < 0)) __PYX_ERR(0, 849, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":850
+ * 
+ *         self._fd_to_writer_fileobj[fd] = fileobj
+ *         socket_inc_io_ref(fileobj)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _remove_writer(self, fileobj):
+ */
+  __pyx_t_7 = __pyx_f_6uvloop_4loop_socket_inc_io_ref(__pyx_v_fileobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 850, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":829
+ *         return poll.is_reading()
+ * 
+ *     cdef _add_writer(self, fileobj, Handle handle):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.Loop._add_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_poll);
+  __Pyx_XDECREF(__pyx_v_fd);
+  __Pyx_XDECREF(__pyx_v_old_fileobj);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":852
+ *         socket_inc_io_ref(fileobj)
+ * 
+ *     cdef _remove_writer(self, fileobj):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__remove_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj) {
+  struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_poll = 0;
+  PyObject *__pyx_v_fd = NULL;
+  PyObject *__pyx_v_mapped_fileobj = NULL;
+  PyObject *__pyx_v_result = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_remove_writer", 0);
+
+  /* "uvloop/loop.pyx":856
+ *             UVPoll poll
+ * 
+ *         fd = self._fileobj_to_fd(fileobj)             # <<<<<<<<<<<<<<
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_fileobj_to_fd(__pyx_v_self, __pyx_v_fileobj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 856, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fd = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":857
+ * 
+ *         fd = self._fileobj_to_fd(fileobj)
+ *         self._ensure_fd_no_transport(fd)             # <<<<<<<<<<<<<<
+ * 
+ *         mapped_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_ensure_fd_no_transport(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 857, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":859
+ *         self._ensure_fd_no_transport(fd)
+ * 
+ *         mapped_fileobj = self._fd_to_writer_fileobj.pop(fd, None)             # <<<<<<<<<<<<<<
+ *         if mapped_fileobj is not None:
+ *             socket_dec_io_ref(mapped_fileobj)
+ */
+  if (unlikely(__pyx_v_self->_fd_to_writer_fileobj == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "pop");
+    __PYX_ERR(0, 859, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_PyDict_Pop(__pyx_v_self->_fd_to_writer_fileobj, __pyx_v_fd, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 859, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_mapped_fileobj = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":860
+ * 
+ *         mapped_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+ *         if mapped_fileobj is not None:             # <<<<<<<<<<<<<<
+ *             socket_dec_io_ref(mapped_fileobj)
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_mapped_fileobj != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":861
+ *         mapped_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+ *         if mapped_fileobj is not None:
+ *             socket_dec_io_ref(mapped_fileobj)             # <<<<<<<<<<<<<<
+ * 
+ *         if self._closed == 1:
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_socket_dec_io_ref(__pyx_v_mapped_fileobj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 861, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":860
+ * 
+ *         mapped_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+ *         if mapped_fileobj is not None:             # <<<<<<<<<<<<<<
+ *             socket_dec_io_ref(mapped_fileobj)
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":863
+ *             socket_dec_io_ref(mapped_fileobj)
+ * 
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_self->_closed == 1) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":864
+ * 
+ *         if self._closed == 1:
+ *             return False             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_False);
+    __pyx_r = Py_False;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":863
+ *             socket_dec_io_ref(mapped_fileobj)
+ * 
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":866
+ *             return False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_6);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":867
+ * 
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])             # <<<<<<<<<<<<<<
+ *         except KeyError:
+ *             return False
+ */
+      if (unlikely(__pyx_v_self->_polls == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 867, __pyx_L5_error)
+      }
+      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->_polls, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 867, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_7 = __pyx_t_1;
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_v_poll = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_7);
+      __pyx_t_7 = 0;
+
+      /* "uvloop/loop.pyx":866
+ *             return False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L5_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":868
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._remove_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(0, 868, __pyx_L7_except_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_9);
+
+      /* "uvloop/loop.pyx":869
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ *             return False             # <<<<<<<<<<<<<<
+ * 
+ *         result = poll.stop_writing()
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __Pyx_INCREF(Py_False);
+      __pyx_r = Py_False;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      goto __pyx_L8_except_return;
+    }
+    goto __pyx_L7_except_error;
+    __pyx_L7_except_error:;
+
+    /* "uvloop/loop.pyx":866
+ *             return False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L1_error;
+    __pyx_L8_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L0;
+    __pyx_L10_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":871
+ *             return False
+ * 
+ *         result = poll.stop_writing()             # <<<<<<<<<<<<<<
+ *         if not poll.is_active():
+ *             del self._polls[fd]
+ */
+  __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->stop_writing(__pyx_v_poll); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 871, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __pyx_v_result = __pyx_t_9;
+  __pyx_t_9 = 0;
+
+  /* "uvloop/loop.pyx":872
+ * 
+ *         result = poll.stop_writing()
+ *         if not poll.is_active():             # <<<<<<<<<<<<<<
+ *             del self._polls[fd]
+ *             poll._close()
+ */
+  __pyx_t_3 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->is_active(__pyx_v_poll) != 0)) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":873
+ *         result = poll.stop_writing()
+ *         if not poll.is_active():
+ *             del self._polls[fd]             # <<<<<<<<<<<<<<
+ *             poll._close()
+ * 
+ */
+    if (unlikely(__pyx_v_self->_polls == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 873, __pyx_L1_error)
+    }
+    if (unlikely(PyDict_DelItem(__pyx_v_self->_polls, __pyx_v_fd) < 0)) __PYX_ERR(0, 873, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":874
+ *         if not poll.is_active():
+ *             del self._polls[fd]
+ *             poll._close()             # <<<<<<<<<<<<<<
+ * 
+ *         return result
+ */
+    __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_poll)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 874, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/loop.pyx":872
+ * 
+ *         result = poll.stop_writing()
+ *         if not poll.is_active():             # <<<<<<<<<<<<<<
+ *             del self._polls[fd]
+ *             poll._close()
+ */
+  }
+
+  /* "uvloop/loop.pyx":876
+ *             poll._close()
+ * 
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _has_writer(self, fileobj):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_result);
+  __pyx_r = __pyx_v_result;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":852
+ *         socket_inc_io_ref(fileobj)
+ * 
+ *     cdef _remove_writer(self, fileobj):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.Loop._remove_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_poll);
+  __Pyx_XDECREF(__pyx_v_fd);
+  __Pyx_XDECREF(__pyx_v_mapped_fileobj);
+  __Pyx_XDECREF(__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":878
+ *         return result
+ * 
+ *     cdef _has_writer(self, fileobj):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__has_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj) {
+  struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_poll = 0;
+  PyObject *__pyx_v_fd = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_has_writer", 0);
+
+  /* "uvloop/loop.pyx":882
+ *             UVPoll poll
+ * 
+ *         self._check_closed()             # <<<<<<<<<<<<<<
+ *         fd = self._fileobj_to_fd(fileobj)
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 882, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":883
+ * 
+ *         self._check_closed()
+ *         fd = self._fileobj_to_fd(fileobj)             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_fileobj_to_fd(__pyx_v_self, __pyx_v_fileobj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 883, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fd = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":885
+ *         fd = self._fileobj_to_fd(fileobj)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":886
+ * 
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])             # <<<<<<<<<<<<<<
+ *         except KeyError:
+ *             return False
+ */
+      if (unlikely(__pyx_v_self->_polls == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 886, __pyx_L3_error)
+      }
+      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->_polls, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 886, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_5 = __pyx_t_1;
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_v_poll = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":885
+ *         fd = self._fileobj_to_fd(fileobj)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":887
+ *         try:
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._has_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(0, 887, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "uvloop/loop.pyx":888
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ *             return False             # <<<<<<<<<<<<<<
+ * 
+ *         return poll.is_writing()
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __Pyx_INCREF(Py_False);
+      __pyx_r = Py_False;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L6_except_return;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/loop.pyx":885
+ *         fd = self._fileobj_to_fd(fileobj)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             poll = <UVPoll>(self._polls[fd])
+ *         except KeyError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":890
+ *             return False
+ * 
+ *         return poll.is_writing()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _getaddrinfo(self, object host, object port,
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->is_writing(__pyx_v_poll); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 890, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_r = __pyx_t_7;
+  __pyx_t_7 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":878
+ *         return result
+ * 
+ *     cdef _has_writer(self, fileobj):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             UVPoll poll
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.Loop._has_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_poll);
+  __Pyx_XDECREF(__pyx_v_fd);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":912
+ *         fut = self._new_future()
+ * 
+ *         def callback(result):             # <<<<<<<<<<<<<<
+ *             if AddrInfo.isinstance(result):
+ *                 try:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_12_getaddrinfo_1callback(PyObject *__pyx_self, PyObject *__pyx_v_result); /*proto*/
+static PyMethodDef __pyx_mdef_6uvloop_4loop_4Loop_12_getaddrinfo_1callback = {"callback", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_12_getaddrinfo_1callback, METH_O, 0};
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_12_getaddrinfo_1callback(PyObject *__pyx_self, PyObject *__pyx_v_result) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("callback (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_12_getaddrinfo_callback(__pyx_self, ((PyObject *)__pyx_v_result));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12_getaddrinfo_callback(PyObject *__pyx_self, PyObject *__pyx_v_result) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *__pyx_cur_scope;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *__pyx_outer_scope;
+  PyObject *__pyx_v_data = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_t_13;
+  char const *__pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("callback", 0);
+  __pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *) __Pyx_CyFunction_GetClosure(__pyx_self);
+  __pyx_cur_scope = __pyx_outer_scope;
+
+  /* "uvloop/loop.pyx":913
+ * 
+ *         def callback(result):
+ *             if AddrInfo.isinstance(result):             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     if unpack == 0:
+ */
+  __pyx_t_1 = (__pyx_f_6uvloop_4loop_8AddrInfo_isinstance(__pyx_v_result) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":914
+ *         def callback(result):
+ *             if AddrInfo.isinstance(result):
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     if unpack == 0:
+ *                         data = result
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_2);
+      __Pyx_XGOTREF(__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_4);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":915
+ *             if AddrInfo.isinstance(result):
+ *                 try:
+ *                     if unpack == 0:             # <<<<<<<<<<<<<<
+ *                         data = result
+ *                     else:
+ */
+        __pyx_t_1 = ((__pyx_cur_scope->__pyx_v_unpack == 0) != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/loop.pyx":916
+ *                 try:
+ *                     if unpack == 0:
+ *                         data = result             # <<<<<<<<<<<<<<
+ *                     else:
+ *                         data = (<AddrInfo>result).unpack()
+ */
+          __Pyx_INCREF(__pyx_v_result);
+          __pyx_v_data = __pyx_v_result;
+
+          /* "uvloop/loop.pyx":915
+ *             if AddrInfo.isinstance(result):
+ *                 try:
+ *                     if unpack == 0:             # <<<<<<<<<<<<<<
+ *                         data = result
+ *                     else:
+ */
+          goto __pyx_L10;
+        }
+
+        /* "uvloop/loop.pyx":918
+ *                         data = result
+ *                     else:
+ *                         data = (<AddrInfo>result).unpack()             # <<<<<<<<<<<<<<
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise
+ */
+        /*else*/ {
+          __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_AddrInfo *)((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_v_result)->__pyx_vtab)->unpack(((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_v_result)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 918, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __pyx_v_data = __pyx_t_5;
+          __pyx_t_5 = 0;
+        }
+        __pyx_L10:;
+
+        /* "uvloop/loop.pyx":914
+ *         def callback(result):
+ *             if AddrInfo.isinstance(result):
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     if unpack == 0:
+ *                         data = result
+ */
+      }
+
+      /* "uvloop/loop.pyx":925
+ *                         fut.set_exception(ex)
+ *                 else:
+ *                     if not fut.cancelled():             # <<<<<<<<<<<<<<
+ *                         fut.set_result(data)
+ *             else:
+ */
+      /*else:*/ {
+        if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(0, 925, __pyx_L6_except_error) }
+        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 925, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __pyx_t_7 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+          __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+          if (likely(__pyx_t_7)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+            __Pyx_INCREF(__pyx_t_7);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_6, function);
+          }
+        }
+        __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 925, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 925, __pyx_L6_except_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __pyx_t_8 = ((!__pyx_t_1) != 0);
+        if (__pyx_t_8) {
+
+          /* "uvloop/loop.pyx":926
+ *                 else:
+ *                     if not fut.cancelled():
+ *                         fut.set_result(data)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 if not fut.cancelled():
+ */
+          if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(0, 926, __pyx_L6_except_error) }
+          __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 926, __pyx_L6_except_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __pyx_t_7 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+            __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+            if (likely(__pyx_t_7)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+              __Pyx_INCREF(__pyx_t_7);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_6, function);
+            }
+          }
+          __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_v_data) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_data);
+          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+          if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 926, __pyx_L6_except_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+          /* "uvloop/loop.pyx":925
+ *                         fut.set_exception(ex)
+ *                 else:
+ *                     if not fut.cancelled():             # <<<<<<<<<<<<<<
+ *                         fut.set_result(data)
+ *             else:
+ */
+        }
+      }
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L9_try_end;
+      __pyx_L4_error:;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":919
+ *                     else:
+ *                         data = (<AddrInfo>result).unpack()
+ *                 except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                     raise
+ *                 except BaseException as ex:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.Loop._getaddrinfo.callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 919, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_7);
+
+        /* "uvloop/loop.pyx":920
+ *                         data = (<AddrInfo>result).unpack()
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise             # <<<<<<<<<<<<<<
+ *                 except BaseException as ex:
+ *                     if not fut.cancelled():
+ */
+        __Pyx_GIVEREF(__pyx_t_5);
+        __Pyx_GIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+        __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; 
+        __PYX_ERR(0, 920, __pyx_L6_except_error)
+      }
+
+      /* "uvloop/loop.pyx":921
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise
+ *                 except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                     if not fut.cancelled():
+ *                         fut.set_exception(ex)
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.Loop._getaddrinfo.callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5) < 0) __PYX_ERR(0, 921, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_6);
+        __pyx_v_ex = __pyx_t_6;
+        /*try:*/ {
+
+          /* "uvloop/loop.pyx":922
+ *                     raise
+ *                 except BaseException as ex:
+ *                     if not fut.cancelled():             # <<<<<<<<<<<<<<
+ *                         fut.set_exception(ex)
+ *                 else:
+ */
+          if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(0, 922, __pyx_L19_error) }
+          __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 922, __pyx_L19_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __pyx_t_12 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+            __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+            if (likely(__pyx_t_12)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+              __Pyx_INCREF(__pyx_t_12);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_11, function);
+            }
+          }
+          __pyx_t_10 = (__pyx_t_12) ? __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_12) : __Pyx_PyObject_CallNoArg(__pyx_t_11);
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 922, __pyx_L19_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 922, __pyx_L19_error)
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+          __pyx_t_1 = ((!__pyx_t_8) != 0);
+          if (__pyx_t_1) {
+
+            /* "uvloop/loop.pyx":923
+ *                 except BaseException as ex:
+ *                     if not fut.cancelled():
+ *                         fut.set_exception(ex)             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     if not fut.cancelled():
+ */
+            if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(0, 923, __pyx_L19_error) }
+            __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 923, __pyx_L19_error)
+            __Pyx_GOTREF(__pyx_t_11);
+            __pyx_t_12 = NULL;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+              __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+              if (likely(__pyx_t_12)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+                __Pyx_INCREF(__pyx_t_12);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_11, function);
+              }
+            }
+            __pyx_t_10 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_12, __pyx_v_ex) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_ex);
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 923, __pyx_L19_error)
+            __Pyx_GOTREF(__pyx_t_10);
+            __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+            /* "uvloop/loop.pyx":922
+ *                     raise
+ *                 except BaseException as ex:
+ *                     if not fut.cancelled():             # <<<<<<<<<<<<<<
+ *                         fut.set_exception(ex)
+ *                 else:
+ */
+          }
+        }
+
+        /* "uvloop/loop.pyx":921
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise
+ *                 except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                     if not fut.cancelled():
+ *                         fut.set_exception(ex)
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L20;
+          }
+          __pyx_L19_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __pyx_t_9 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+            }
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+            __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+            __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
+            goto __pyx_L6_except_error;
+          }
+          __pyx_L20:;
+        }
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        goto __pyx_L5_exception_handled;
+      }
+      goto __pyx_L6_except_error;
+      __pyx_L6_except_error:;
+
+      /* "uvloop/loop.pyx":914
+ *         def callback(result):
+ *             if AddrInfo.isinstance(result):
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     if unpack == 0:
+ *                         data = result
+ */
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+      goto __pyx_L1_error;
+      __pyx_L5_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+      __pyx_L9_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":913
+ * 
+ *         def callback(result):
+ *             if AddrInfo.isinstance(result):             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     if unpack == 0:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/loop.pyx":928
+ *                         fut.set_result(data)
+ *             else:
+ *                 if not fut.cancelled():             # <<<<<<<<<<<<<<
+ *                     fut.set_exception(result)
+ * 
+ */
+  /*else*/ {
+    if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(0, 928, __pyx_L1_error) }
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 928, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 928, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 928, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_8 = ((!__pyx_t_1) != 0);
+    if (__pyx_t_8) {
+
+      /* "uvloop/loop.pyx":929
+ *             else:
+ *                 if not fut.cancelled():
+ *                     fut.set_exception(result)             # <<<<<<<<<<<<<<
+ * 
+ *         AddrInfoRequest(self, host, port, family, type, proto, flags, callback)
+ */
+      if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(0, 929, __pyx_L1_error) }
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 929, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_v_result) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_result);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 929, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":928
+ *                         fut.set_result(data)
+ *             else:
+ *                 if not fut.cancelled():             # <<<<<<<<<<<<<<
+ *                     fut.set_exception(result)
+ * 
+ */
+    }
+  }
+  __pyx_L3:;
+
+  /* "uvloop/loop.pyx":912
+ *         fut = self._new_future()
+ * 
+ *         def callback(result):             # <<<<<<<<<<<<<<
+ *             if AddrInfo.isinstance(result):
+ *                 try:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("uvloop.loop.Loop._getaddrinfo.callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":892
+ *         return poll.is_writing()
+ * 
+ *     cdef _getaddrinfo(self, object host, object port,             # <<<<<<<<<<<<<<
+ *                       int family, int type,
+ *                       int proto, int flags,
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__getaddrinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_flags, int __pyx_v_unpack) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *__pyx_cur_scope;
+  PyObject *__pyx_v_callback = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_getaddrinfo", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct___getaddrinfo(__pyx_ptype_6uvloop_4loop___pyx_scope_struct___getaddrinfo, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 892, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__pyx_cur_scope);
+  }
+  __pyx_cur_scope->__pyx_v_unpack = __pyx_v_unpack;
+  __Pyx_INCREF(__pyx_v_host);
+  __Pyx_INCREF(__pyx_v_port);
+
+  /* "uvloop/loop.pyx":897
+ *                       int unpack):
+ * 
+ *         if isinstance(port, str):             # <<<<<<<<<<<<<<
+ *             port = port.encode()
+ *         elif isinstance(port, int):
+ */
+  __pyx_t_1 = PyUnicode_Check(__pyx_v_port); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":898
+ * 
+ *         if isinstance(port, str):
+ *             port = port.encode()             # <<<<<<<<<<<<<<
+ *         elif isinstance(port, int):
+ *             port = str(port).encode()
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_port, __pyx_n_s_encode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 898, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 898, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF_SET(__pyx_v_port, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":897
+ *                       int unpack):
+ * 
+ *         if isinstance(port, str):             # <<<<<<<<<<<<<<
+ *             port = port.encode()
+ *         elif isinstance(port, int):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/loop.pyx":899
+ *         if isinstance(port, str):
+ *             port = port.encode()
+ *         elif isinstance(port, int):             # <<<<<<<<<<<<<<
+ *             port = str(port).encode()
+ *         if port is not None and not isinstance(port, bytes):
+ */
+  __pyx_t_2 = PyInt_Check(__pyx_v_port); 
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":900
+ *             port = port.encode()
+ *         elif isinstance(port, int):
+ *             port = str(port).encode()             # <<<<<<<<<<<<<<
+ *         if port is not None and not isinstance(port, bytes):
+ *             raise TypeError('port must be a str, bytes or int')
+ */
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_v_port); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 900, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = PyUnicode_AsEncodedString(((PyObject*)__pyx_t_3), NULL, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 900, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF_SET(__pyx_v_port, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":899
+ *         if isinstance(port, str):
+ *             port = port.encode()
+ *         elif isinstance(port, int):             # <<<<<<<<<<<<<<
+ *             port = str(port).encode()
+ *         if port is not None and not isinstance(port, bytes):
+ */
+  }
+  __pyx_L3:;
+
+  /* "uvloop/loop.pyx":901
+ *         elif isinstance(port, int):
+ *             port = str(port).encode()
+ *         if port is not None and not isinstance(port, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError('port must be a str, bytes or int')
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_port != Py_None);
+  __pyx_t_6 = (__pyx_t_2 != 0);
+  if (__pyx_t_6) {
+  } else {
+    __pyx_t_1 = __pyx_t_6;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_6 = PyBytes_Check(__pyx_v_port); 
+  __pyx_t_2 = ((!(__pyx_t_6 != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L5_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":902
+ *             port = str(port).encode()
+ *         if port is not None and not isinstance(port, bytes):
+ *             raise TypeError('port must be a str, bytes or int')             # <<<<<<<<<<<<<<
+ * 
+ *         if isinstance(host, str):
+ */
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 902, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(0, 902, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":901
+ *         elif isinstance(port, int):
+ *             port = str(port).encode()
+ *         if port is not None and not isinstance(port, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError('port must be a str, bytes or int')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":904
+ *             raise TypeError('port must be a str, bytes or int')
+ * 
+ *         if isinstance(host, str):             # <<<<<<<<<<<<<<
+ *             host = host.encode('idna')
+ *         if host is not None:
+ */
+  __pyx_t_1 = PyUnicode_Check(__pyx_v_host); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":905
+ * 
+ *         if isinstance(host, str):
+ *             host = host.encode('idna')             # <<<<<<<<<<<<<<
+ *         if host is not None:
+ *             if not isinstance(host, bytes):
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_host, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 905, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_n_u_idna) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_n_u_idna);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 905, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF_SET(__pyx_v_host, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":904
+ *             raise TypeError('port must be a str, bytes or int')
+ * 
+ *         if isinstance(host, str):             # <<<<<<<<<<<<<<
+ *             host = host.encode('idna')
+ *         if host is not None:
+ */
+  }
+
+  /* "uvloop/loop.pyx":906
+ *         if isinstance(host, str):
+ *             host = host.encode('idna')
+ *         if host is not None:             # <<<<<<<<<<<<<<
+ *             if not isinstance(host, bytes):
+ *                 raise TypeError('host must be a str or bytes')
+ */
+  __pyx_t_2 = (__pyx_v_host != Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":907
+ *             host = host.encode('idna')
+ *         if host is not None:
+ *             if not isinstance(host, bytes):             # <<<<<<<<<<<<<<
+ *                 raise TypeError('host must be a str or bytes')
+ * 
+ */
+    __pyx_t_1 = PyBytes_Check(__pyx_v_host); 
+    __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":908
+ *         if host is not None:
+ *             if not isinstance(host, bytes):
+ *                 raise TypeError('host must be a str or bytes')             # <<<<<<<<<<<<<<
+ * 
+ *         fut = self._new_future()
+ */
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 908, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __PYX_ERR(0, 908, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":907
+ *             host = host.encode('idna')
+ *         if host is not None:
+ *             if not isinstance(host, bytes):             # <<<<<<<<<<<<<<
+ *                 raise TypeError('host must be a str or bytes')
+ * 
+ */
+    }
+
+    /* "uvloop/loop.pyx":906
+ *         if isinstance(host, str):
+ *             host = host.encode('idna')
+ *         if host is not None:             # <<<<<<<<<<<<<<
+ *             if not isinstance(host, bytes):
+ *                 raise TypeError('host must be a str or bytes')
+ */
+  }
+
+  /* "uvloop/loop.pyx":910
+ *                 raise TypeError('host must be a str or bytes')
+ * 
+ *         fut = self._new_future()             # <<<<<<<<<<<<<<
+ * 
+ *         def callback(result):
+ */
+  __pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 910, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_4);
+  __pyx_cur_scope->__pyx_v_fut = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":912
+ *         fut = self._new_future()
+ * 
+ *         def callback(result):             # <<<<<<<<<<<<<<
+ *             if AddrInfo.isinstance(result):
+ *                 try:
+ */
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_4Loop_12_getaddrinfo_1callback, 0, __pyx_n_s_Loop__getaddrinfo_locals_callbac, ((PyObject*)__pyx_cur_scope), __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 912, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_v_callback = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":931
+ *                     fut.set_exception(result)
+ * 
+ *         AddrInfoRequest(self, host, port, family, type, proto, flags, callback)             # <<<<<<<<<<<<<<
+ *         return fut
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 931, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 931, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_proto); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 931, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 931, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = PyTuple_New(8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 931, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_8, 0, ((PyObject *)__pyx_v_self));
+  __Pyx_INCREF(__pyx_v_host);
+  __Pyx_GIVEREF(__pyx_v_host);
+  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_host);
+  __Pyx_INCREF(__pyx_v_port);
+  __Pyx_GIVEREF(__pyx_v_port);
+  PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_v_port);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_8, 6, __pyx_t_7);
+  __Pyx_INCREF(__pyx_v_callback);
+  __Pyx_GIVEREF(__pyx_v_callback);
+  PyTuple_SET_ITEM(__pyx_t_8, 7, __pyx_v_callback);
+  __pyx_t_4 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_AddrInfoRequest), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 931, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":932
+ * 
+ *         AddrInfoRequest(self, host, port, family, type, proto, flags, callback)
+ *         return fut             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _getnameinfo(self, system.sockaddr *addr, int flags):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_fut);
+  __pyx_r = __pyx_cur_scope->__pyx_v_fut;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":892
+ *         return poll.is_writing()
+ * 
+ *     cdef _getaddrinfo(self, object host, object port,             # <<<<<<<<<<<<<<
+ *                       int family, int type,
+ *                       int proto, int flags,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.Loop._getaddrinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_callback);
+  __Pyx_XDECREF(__pyx_v_host);
+  __Pyx_XDECREF(__pyx_v_port);
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":938
+ *         fut = self._new_future()
+ * 
+ *         def callback(result):             # <<<<<<<<<<<<<<
+ *             if isinstance(result, tuple):
+ *                 fut.set_result(result)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_12_getnameinfo_1callback(PyObject *__pyx_self, PyObject *__pyx_v_result); /*proto*/
+static PyMethodDef __pyx_mdef_6uvloop_4loop_4Loop_12_getnameinfo_1callback = {"callback", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_12_getnameinfo_1callback, METH_O, 0};
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_12_getnameinfo_1callback(PyObject *__pyx_self, PyObject *__pyx_v_result) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("callback (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_12_getnameinfo_callback(__pyx_self, ((PyObject *)__pyx_v_result));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12_getnameinfo_callback(PyObject *__pyx_self, PyObject *__pyx_v_result) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *__pyx_cur_scope;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *__pyx_outer_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  __Pyx_RefNannySetupContext("callback", 0);
+  __pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *) __Pyx_CyFunction_GetClosure(__pyx_self);
+  __pyx_cur_scope = __pyx_outer_scope;
+
+  /* "uvloop/loop.pyx":939
+ * 
+ *         def callback(result):
+ *             if isinstance(result, tuple):             # <<<<<<<<<<<<<<
+ *                 fut.set_result(result)
+ *             else:
+ */
+  __pyx_t_1 = PyTuple_Check(__pyx_v_result); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":940
+ *         def callback(result):
+ *             if isinstance(result, tuple):
+ *                 fut.set_result(result)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 fut.set_exception(result)
+ */
+    if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(0, 940, __pyx_L1_error) }
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 940, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_result) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_result);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 940, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":939
+ * 
+ *         def callback(result):
+ *             if isinstance(result, tuple):             # <<<<<<<<<<<<<<
+ *                 fut.set_result(result)
+ *             else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/loop.pyx":942
+ *                 fut.set_result(result)
+ *             else:
+ *                 fut.set_exception(result)             # <<<<<<<<<<<<<<
+ * 
+ *         nr = NameInfoRequest(self, callback)
+ */
+  /*else*/ {
+    if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(0, 942, __pyx_L1_error) }
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 942, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_result) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_result);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 942, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/loop.pyx":938
+ *         fut = self._new_future()
+ * 
+ *         def callback(result):             # <<<<<<<<<<<<<<
+ *             if isinstance(result, tuple):
+ *                 fut.set_result(result)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.Loop._getnameinfo.callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":934
+ *         return fut
+ * 
+ *     cdef _getnameinfo(self, system.sockaddr *addr, int flags):             # <<<<<<<<<<<<<<
+ *         cdef NameInfoRequest nr
+ *         fut = self._new_future()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__getnameinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct sockaddr *__pyx_v_addr, int __pyx_v_flags) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *__pyx_cur_scope;
+  struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__pyx_v_nr = 0;
+  PyObject *__pyx_v_callback = 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("_getnameinfo", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_1__getnameinfo(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_1__getnameinfo, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 934, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__pyx_cur_scope);
+  }
+
+  /* "uvloop/loop.pyx":936
+ *     cdef _getnameinfo(self, system.sockaddr *addr, int flags):
+ *         cdef NameInfoRequest nr
+ *         fut = self._new_future()             # <<<<<<<<<<<<<<
+ * 
+ *         def callback(result):
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 936, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_fut = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":938
+ *         fut = self._new_future()
+ * 
+ *         def callback(result):             # <<<<<<<<<<<<<<
+ *             if isinstance(result, tuple):
+ *                 fut.set_result(result)
+ */
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_4Loop_12_getnameinfo_1callback, 0, __pyx_n_s_Loop__getnameinfo_locals_callbac, ((PyObject*)__pyx_cur_scope), __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 938, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_callback = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":944
+ *                 fut.set_exception(result)
+ * 
+ *         nr = NameInfoRequest(self, callback)             # <<<<<<<<<<<<<<
+ *         nr.query(addr, flags)
+ *         return fut
+ */
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 944, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __Pyx_INCREF(__pyx_v_callback);
+  __Pyx_GIVEREF(__pyx_v_callback);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_callback);
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_NameInfoRequest), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 944, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_nr = ((struct __pyx_obj_6uvloop_4loop_NameInfoRequest *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":945
+ * 
+ *         nr = NameInfoRequest(self, callback)
+ *         nr.query(addr, flags)             # <<<<<<<<<<<<<<
+ *         return fut
+ * 
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_NameInfoRequest *)__pyx_v_nr->__pyx_base.__pyx_vtab)->query(__pyx_v_nr, __pyx_v_addr, __pyx_v_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 945, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":946
+ *         nr = NameInfoRequest(self, callback)
+ *         nr.query(addr, flags)
+ *         return fut             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _sock_recv(self, fut, sock, n):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_fut);
+  __pyx_r = __pyx_cur_scope->__pyx_v_fut;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":934
+ *         return fut
+ * 
+ *     cdef _getnameinfo(self, system.sockaddr *addr, int flags):             # <<<<<<<<<<<<<<
+ *         cdef NameInfoRequest nr
+ *         fut = self._new_future()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop._getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_nr);
+  __Pyx_XDECREF(__pyx_v_callback);
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":948
+ *         return fut
+ * 
+ *     cdef _sock_recv(self, fut, sock, n):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_recv(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_n) {
+  PyObject *__pyx_v_data = NULL;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  Py_ssize_t __pyx_t_6;
+  Py_UCS4 __pyx_t_7;
+  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_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_t_15;
+  char const *__pyx_t_16;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_sock_recv", 0);
+
+  /* "uvloop/loop.pyx":949
+ * 
+ *     cdef _sock_recv(self, fut, sock, n):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":950
+ *     cdef _sock_recv(self, fut, sock, n):
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():             # <<<<<<<<<<<<<<
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ *                 raise RuntimeError(
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 950, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 950, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 950, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":952
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'_sock_recv is called on a cancelled Future')
+ * 
+ */
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 952, __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(0, 952, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":950
+ *     cdef _sock_recv(self, fut, sock, n):
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():             # <<<<<<<<<<<<<<
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ *                 raise RuntimeError(
+ */
+    }
+
+    /* "uvloop/loop.pyx":955
+ *                     f'_sock_recv is called on a cancelled Future')
+ * 
+ *             if not self._has_reader(sock):             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a reader '
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_has_reader(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 955, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 955, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_5 = ((!__pyx_t_1) != 0);
+    if (unlikely(__pyx_t_5)) {
+
+      /* "uvloop/loop.pyx":957
+ *             if not self._has_reader(sock):
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a reader '             # <<<<<<<<<<<<<<
+ *                     f'in the _sock_recv callback')
+ * 
+ */
+      __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 957, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_6 = 0;
+      __pyx_t_7 = 127;
+      __Pyx_INCREF(__pyx_kp_u_socket);
+      __pyx_t_6 += 7;
+      __Pyx_GIVEREF(__pyx_kp_u_socket);
+      PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_socket);
+      __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_sock), __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 957, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_7;
+      __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __Pyx_INCREF(__pyx_kp_u_does_not_have_a_reader_in_the);
+      __pyx_t_6 += 50;
+      __Pyx_GIVEREF(__pyx_kp_u_does_not_have_a_reader_in_the);
+      PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_does_not_have_a_reader_in_the);
+      __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 957, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":956
+ * 
+ *             if not self._has_reader(sock):
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'socket {sock!r} does not have a reader '
+ *                     f'in the _sock_recv callback')
+ */
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 956, __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(0, 956, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":955
+ *                     f'_sock_recv is called on a cancelled Future')
+ * 
+ *             if not self._has_reader(sock):             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a reader '
+ */
+    }
+
+    /* "uvloop/loop.pyx":949
+ * 
+ *     cdef _sock_recv(self, fut, sock, n):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ */
+  }
+
+  /* "uvloop/loop.pyx":960
+ *                     f'in the _sock_recv callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             data = sock.recv(n)
+ *         except (BlockingIOError, InterruptedError):
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+    __Pyx_XGOTREF(__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_9);
+    __Pyx_XGOTREF(__pyx_t_10);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":961
+ * 
+ *         try:
+ *             data = sock.recv(n)             # <<<<<<<<<<<<<<
+ *         except (BlockingIOError, InterruptedError):
+ *             # No need to re-add the reader, let's just wait until
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_recv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 961, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_n) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_n);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 961, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_v_data = __pyx_t_2;
+      __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":960
+ *                     f'in the _sock_recv callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             data = sock.recv(n)
+ *         except (BlockingIOError, InterruptedError):
+ */
+    }
+
+    /* "uvloop/loop.pyx":972
+ *             self._remove_reader(sock)
+ *         else:
+ *             fut.set_result(data)             # <<<<<<<<<<<<<<
+ *             self._remove_reader(sock)
+ * 
+ */
+    /*else:*/ {
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 972, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_data) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_data);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 972, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":973
+ *         else:
+ *             fut.set_result(data)
+ *             self._remove_reader(sock)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _sock_recv_into(self, fut, sock, buf):
+ */
+      __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_reader(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 973, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    }
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    goto __pyx_L11_try_end;
+    __pyx_L6_error:;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":962
+ *         try:
+ *             data = sock.recv(n)
+ *         except (BlockingIOError, InterruptedError):             # <<<<<<<<<<<<<<
+ *             # No need to re-add the reader, let's just wait until
+ *             # the poll handler calls this callback again.
+ */
+    __Pyx_ErrFetch(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_BlockingIOError); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 962, __pyx_L8_except_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_InterruptedError); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 962, __pyx_L8_except_error)
+    __Pyx_GOTREF(__pyx_t_12);
+    __pyx_t_13 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_2, __pyx_t_11) || __Pyx_PyErr_GivenExceptionMatches(__pyx_t_2, __pyx_t_12);
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_ErrRestore(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0;
+    if (__pyx_t_13) {
+      __Pyx_ErrRestore(0,0,0);
+      goto __pyx_L7_exception_handled;
+    }
+
+    /* "uvloop/loop.pyx":966
+ *             # the poll handler calls this callback again.
+ *             pass
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException as exc:
+ */
+    __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+    if (__pyx_t_13) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._sock_recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2) < 0) __PYX_ERR(0, 966, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_2);
+
+      /* "uvloop/loop.pyx":967
+ *             pass
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)
+ */
+      __Pyx_GIVEREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_3, __pyx_t_2);
+      __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_2 = 0; 
+      __PYX_ERR(0, 967, __pyx_L8_except_error)
+    }
+
+    /* "uvloop/loop.pyx":968
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             fut.set_exception(exc)
+ *             self._remove_reader(sock)
+ */
+    __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_13) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._sock_recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4) < 0) __PYX_ERR(0, 968, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_3);
+      __pyx_v_exc = __pyx_t_3;
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":969
+ *             raise
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)             # <<<<<<<<<<<<<<
+ *             self._remove_reader(sock)
+ *         else:
+ */
+        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 969, __pyx_L19_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __pyx_t_14 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+          __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_11);
+          if (likely(__pyx_t_14)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+            __Pyx_INCREF(__pyx_t_14);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_11, function);
+          }
+        }
+        __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_14, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_exc);
+        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+        if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 969, __pyx_L19_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+
+        /* "uvloop/loop.pyx":970
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)
+ *             self._remove_reader(sock)             # <<<<<<<<<<<<<<
+ *         else:
+ *             fut.set_result(data)
+ */
+        __pyx_t_12 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_reader(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 970, __pyx_L19_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      }
+
+      /* "uvloop/loop.pyx":968
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             fut.set_exception(exc)
+ *             self._remove_reader(sock)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L20;
+        }
+        __pyx_L19_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_20);
+          __Pyx_XGOTREF(__pyx_t_21);
+          __Pyx_XGOTREF(__pyx_t_22);
+          __pyx_t_13 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_XGIVEREF(__pyx_t_21);
+            __Pyx_XGIVEREF(__pyx_t_22);
+            __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
+          }
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __Pyx_XGIVEREF(__pyx_t_18);
+          __Pyx_XGIVEREF(__pyx_t_19);
+          __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+          __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+          __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16;
+          goto __pyx_L8_except_error;
+        }
+        __pyx_L20:;
+      }
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L7_exception_handled;
+    }
+    goto __pyx_L8_except_error;
+    __pyx_L8_except_error:;
+
+    /* "uvloop/loop.pyx":960
+ *                     f'in the _sock_recv callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             data = sock.recv(n)
+ *         except (BlockingIOError, InterruptedError):
+ */
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    goto __pyx_L1_error;
+    __pyx_L7_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    __pyx_L11_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":948
+ *         return fut
+ * 
+ *     cdef _sock_recv(self, fut, sock, n):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("uvloop.loop.Loop._sock_recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":975
+ *             self._remove_reader(sock)
+ * 
+ *     cdef _sock_recv_into(self, fut, sock, buf):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_recv_into(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_buf) {
+  PyObject *__pyx_v_data = NULL;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  Py_ssize_t __pyx_t_6;
+  Py_UCS4 __pyx_t_7;
+  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_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_t_15;
+  char const *__pyx_t_16;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_sock_recv_into", 0);
+
+  /* "uvloop/loop.pyx":976
+ * 
+ *     cdef _sock_recv_into(self, fut, sock, buf):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":977
+ *     cdef _sock_recv_into(self, fut, sock, buf):
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():             # <<<<<<<<<<<<<<
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ *                 raise RuntimeError(
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 977, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 977, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 977, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":979
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'_sock_recv_into is called on a cancelled Future')
+ * 
+ */
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 979, __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(0, 979, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":977
+ *     cdef _sock_recv_into(self, fut, sock, buf):
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():             # <<<<<<<<<<<<<<
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ *                 raise RuntimeError(
+ */
+    }
+
+    /* "uvloop/loop.pyx":982
+ *                     f'_sock_recv_into is called on a cancelled Future')
+ * 
+ *             if not self._has_reader(sock):             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a reader '
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_has_reader(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 982, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 982, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_5 = ((!__pyx_t_1) != 0);
+    if (unlikely(__pyx_t_5)) {
+
+      /* "uvloop/loop.pyx":984
+ *             if not self._has_reader(sock):
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a reader '             # <<<<<<<<<<<<<<
+ *                     f'in the _sock_recv_into callback')
+ * 
+ */
+      __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 984, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_6 = 0;
+      __pyx_t_7 = 127;
+      __Pyx_INCREF(__pyx_kp_u_socket);
+      __pyx_t_6 += 7;
+      __Pyx_GIVEREF(__pyx_kp_u_socket);
+      PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_socket);
+      __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_sock), __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 984, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_7;
+      __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __Pyx_INCREF(__pyx_kp_u_does_not_have_a_reader_in_the_2);
+      __pyx_t_6 += 55;
+      __Pyx_GIVEREF(__pyx_kp_u_does_not_have_a_reader_in_the_2);
+      PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_does_not_have_a_reader_in_the_2);
+      __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 984, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":983
+ * 
+ *             if not self._has_reader(sock):
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'socket {sock!r} does not have a reader '
+ *                     f'in the _sock_recv_into callback')
+ */
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 983, __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(0, 983, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":982
+ *                     f'_sock_recv_into is called on a cancelled Future')
+ * 
+ *             if not self._has_reader(sock):             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a reader '
+ */
+    }
+
+    /* "uvloop/loop.pyx":976
+ * 
+ *     cdef _sock_recv_into(self, fut, sock, buf):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ */
+  }
+
+  /* "uvloop/loop.pyx":987
+ *                     f'in the _sock_recv_into callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             data = sock.recv_into(buf)
+ *         except (BlockingIOError, InterruptedError):
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+    __Pyx_XGOTREF(__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_9);
+    __Pyx_XGOTREF(__pyx_t_10);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":988
+ * 
+ *         try:
+ *             data = sock.recv_into(buf)             # <<<<<<<<<<<<<<
+ *         except (BlockingIOError, InterruptedError):
+ *             # No need to re-add the reader, let's just wait until
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_recv_into); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 988, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_buf) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_buf);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 988, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_v_data = __pyx_t_2;
+      __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":987
+ *                     f'in the _sock_recv_into callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             data = sock.recv_into(buf)
+ *         except (BlockingIOError, InterruptedError):
+ */
+    }
+
+    /* "uvloop/loop.pyx":999
+ *             self._remove_reader(sock)
+ *         else:
+ *             fut.set_result(data)             # <<<<<<<<<<<<<<
+ *             self._remove_reader(sock)
+ * 
+ */
+    /*else:*/ {
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 999, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_data) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_data);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 999, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":1000
+ *         else:
+ *             fut.set_result(data)
+ *             self._remove_reader(sock)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _sock_sendall(self, fut, sock, data):
+ */
+      __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_reader(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1000, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    }
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    goto __pyx_L11_try_end;
+    __pyx_L6_error:;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":989
+ *         try:
+ *             data = sock.recv_into(buf)
+ *         except (BlockingIOError, InterruptedError):             # <<<<<<<<<<<<<<
+ *             # No need to re-add the reader, let's just wait until
+ *             # the poll handler calls this callback again.
+ */
+    __Pyx_ErrFetch(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_BlockingIOError); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 989, __pyx_L8_except_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_InterruptedError); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 989, __pyx_L8_except_error)
+    __Pyx_GOTREF(__pyx_t_12);
+    __pyx_t_13 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_2, __pyx_t_11) || __Pyx_PyErr_GivenExceptionMatches(__pyx_t_2, __pyx_t_12);
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_ErrRestore(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0;
+    if (__pyx_t_13) {
+      __Pyx_ErrRestore(0,0,0);
+      goto __pyx_L7_exception_handled;
+    }
+
+    /* "uvloop/loop.pyx":993
+ *             # the poll handler calls this callback again.
+ *             pass
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException as exc:
+ */
+    __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+    if (__pyx_t_13) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._sock_recv_into", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2) < 0) __PYX_ERR(0, 993, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_2);
+
+      /* "uvloop/loop.pyx":994
+ *             pass
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)
+ */
+      __Pyx_GIVEREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_3, __pyx_t_2);
+      __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_2 = 0; 
+      __PYX_ERR(0, 994, __pyx_L8_except_error)
+    }
+
+    /* "uvloop/loop.pyx":995
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             fut.set_exception(exc)
+ *             self._remove_reader(sock)
+ */
+    __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_13) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._sock_recv_into", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4) < 0) __PYX_ERR(0, 995, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_3);
+      __pyx_v_exc = __pyx_t_3;
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":996
+ *             raise
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)             # <<<<<<<<<<<<<<
+ *             self._remove_reader(sock)
+ *         else:
+ */
+        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 996, __pyx_L19_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __pyx_t_14 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+          __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_11);
+          if (likely(__pyx_t_14)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+            __Pyx_INCREF(__pyx_t_14);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_11, function);
+          }
+        }
+        __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_14, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_exc);
+        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+        if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 996, __pyx_L19_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+
+        /* "uvloop/loop.pyx":997
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)
+ *             self._remove_reader(sock)             # <<<<<<<<<<<<<<
+ *         else:
+ *             fut.set_result(data)
+ */
+        __pyx_t_12 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_reader(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 997, __pyx_L19_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      }
+
+      /* "uvloop/loop.pyx":995
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             fut.set_exception(exc)
+ *             self._remove_reader(sock)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L20;
+        }
+        __pyx_L19_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_20);
+          __Pyx_XGOTREF(__pyx_t_21);
+          __Pyx_XGOTREF(__pyx_t_22);
+          __pyx_t_13 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_XGIVEREF(__pyx_t_21);
+            __Pyx_XGIVEREF(__pyx_t_22);
+            __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
+          }
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __Pyx_XGIVEREF(__pyx_t_18);
+          __Pyx_XGIVEREF(__pyx_t_19);
+          __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+          __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+          __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16;
+          goto __pyx_L8_except_error;
+        }
+        __pyx_L20:;
+      }
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L7_exception_handled;
+    }
+    goto __pyx_L8_except_error;
+    __pyx_L8_except_error:;
+
+    /* "uvloop/loop.pyx":987
+ *                     f'in the _sock_recv_into callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             data = sock.recv_into(buf)
+ *         except (BlockingIOError, InterruptedError):
+ */
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    goto __pyx_L1_error;
+    __pyx_L7_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    __pyx_L11_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":975
+ *             self._remove_reader(sock)
+ * 
+ *     cdef _sock_recv_into(self, fut, sock, buf):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("uvloop.loop.Loop._sock_recv_into", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1002
+ *             self._remove_reader(sock)
+ * 
+ *     cdef _sock_sendall(self, fut, sock, data):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             Handle handle
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_sendall(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_data) {
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
+  int __pyx_v_n;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  Py_ssize_t __pyx_t_6;
+  Py_UCS4 __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_t_15;
+  char const *__pyx_t_16;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_sock_sendall", 0);
+  __Pyx_INCREF(__pyx_v_data);
+
+  /* "uvloop/loop.pyx":1007
+ *             int n
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1008
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():             # <<<<<<<<<<<<<<
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ *                 raise RuntimeError(
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1008, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1008, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1008, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":1010
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'_sock_sendall is called on a cancelled Future')
+ * 
+ */
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1010, __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(0, 1010, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1008
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():             # <<<<<<<<<<<<<<
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ *                 raise RuntimeError(
+ */
+    }
+
+    /* "uvloop/loop.pyx":1013
+ *                     f'_sock_sendall is called on a cancelled Future')
+ * 
+ *             if not self._has_writer(sock):             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a writer '
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_has_writer(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1013, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1013, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_5 = ((!__pyx_t_1) != 0);
+    if (unlikely(__pyx_t_5)) {
+
+      /* "uvloop/loop.pyx":1015
+ *             if not self._has_writer(sock):
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a writer '             # <<<<<<<<<<<<<<
+ *                     f'in the _sock_sendall callback')
+ * 
+ */
+      __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1015, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_6 = 0;
+      __pyx_t_7 = 127;
+      __Pyx_INCREF(__pyx_kp_u_socket);
+      __pyx_t_6 += 7;
+      __Pyx_GIVEREF(__pyx_kp_u_socket);
+      PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_socket);
+      __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_sock), __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1015, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_7;
+      __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __Pyx_INCREF(__pyx_kp_u_does_not_have_a_writer_in_the);
+      __pyx_t_6 += 53;
+      __Pyx_GIVEREF(__pyx_kp_u_does_not_have_a_writer_in_the);
+      PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_does_not_have_a_writer_in_the);
+      __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1015, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":1014
+ * 
+ *             if not self._has_writer(sock):
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'socket {sock!r} does not have a writer '
+ *                     f'in the _sock_sendall callback')
+ */
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1014, __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(0, 1014, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1013
+ *                     f'_sock_sendall is called on a cancelled Future')
+ * 
+ *             if not self._has_writer(sock):             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a writer '
+ */
+    }
+
+    /* "uvloop/loop.pyx":1007
+ *             int n
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ */
+  }
+
+  /* "uvloop/loop.pyx":1018
+ *                     f'in the _sock_sendall callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             n = sock.send(data)
+ *         except (BlockingIOError, InterruptedError):
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+    __Pyx_XGOTREF(__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_9);
+    __Pyx_XGOTREF(__pyx_t_10);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":1019
+ * 
+ *         try:
+ *             n = sock.send(data)             # <<<<<<<<<<<<<<
+ *         except (BlockingIOError, InterruptedError):
+ *             # Try next time.
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_send); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1019, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_data) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_data);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1019, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1019, __pyx_L6_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_v_n = __pyx_t_11;
+
+      /* "uvloop/loop.pyx":1018
+ *                     f'in the _sock_sendall callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             n = sock.send(data)
+ *         except (BlockingIOError, InterruptedError):
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    goto __pyx_L11_try_end;
+    __pyx_L6_error:;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":1020
+ *         try:
+ *             n = sock.send(data)
+ *         except (BlockingIOError, InterruptedError):             # <<<<<<<<<<<<<<
+ *             # Try next time.
+ *             return
+ */
+    __Pyx_ErrFetch(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_BlockingIOError); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1020, __pyx_L8_except_error)
+    __Pyx_GOTREF(__pyx_t_12);
+    __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_n_s_InterruptedError); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1020, __pyx_L8_except_error)
+    __Pyx_GOTREF(__pyx_t_13);
+    __pyx_t_11 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_2, __pyx_t_12) || __Pyx_PyErr_GivenExceptionMatches(__pyx_t_2, __pyx_t_13);
+    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+    __Pyx_ErrRestore(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0;
+    if (__pyx_t_11) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2) < 0) __PYX_ERR(0, 1020, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_2);
+
+      /* "uvloop/loop.pyx":1022
+ *         except (BlockingIOError, InterruptedError):
+ *             # Try next time.
+ *             return             # <<<<<<<<<<<<<<
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L9_except_return;
+    }
+
+    /* "uvloop/loop.pyx":1023
+ *             # Try next time.
+ *             return
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException as exc:
+ */
+    __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+    if (__pyx_t_11) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4) < 0) __PYX_ERR(0, 1023, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/loop.pyx":1024
+ *             return
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)
+ */
+      __Pyx_GIVEREF(__pyx_t_2);
+      __Pyx_GIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+      __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0; 
+      __PYX_ERR(0, 1024, __pyx_L8_except_error)
+    }
+
+    /* "uvloop/loop.pyx":1025
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             fut.set_exception(exc)
+ *             self._remove_writer(sock)
+ */
+    __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_11) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2) < 0) __PYX_ERR(0, 1025, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __pyx_v_exc = __pyx_t_3;
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":1026
+ *             raise
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)             # <<<<<<<<<<<<<<
+ *             self._remove_writer(sock)
+ *             return
+ */
+        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1026, __pyx_L21_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __pyx_t_14 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) {
+          __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_12);
+          if (likely(__pyx_t_14)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
+            __Pyx_INCREF(__pyx_t_14);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_12, function);
+          }
+        }
+        __pyx_t_13 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_12, __pyx_t_14, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_v_exc);
+        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+        if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1026, __pyx_L21_error)
+        __Pyx_GOTREF(__pyx_t_13);
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+        /* "uvloop/loop.pyx":1027
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)
+ *             self._remove_writer(sock)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+        __pyx_t_13 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_writer(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1027, __pyx_L21_error)
+        __Pyx_GOTREF(__pyx_t_13);
+        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+        /* "uvloop/loop.pyx":1028
+ *             fut.set_exception(exc)
+ *             self._remove_writer(sock)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._remove_writer(sock)
+ */
+        __Pyx_XDECREF(__pyx_r);
+        __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        goto __pyx_L20_return;
+      }
+
+      /* "uvloop/loop.pyx":1025
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             fut.set_exception(exc)
+ *             self._remove_writer(sock)
+ */
+      /*finally:*/ {
+        __pyx_L21_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_20);
+          __Pyx_XGOTREF(__pyx_t_21);
+          __Pyx_XGOTREF(__pyx_t_22);
+          __pyx_t_11 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_XGIVEREF(__pyx_t_21);
+            __Pyx_XGIVEREF(__pyx_t_22);
+            __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
+          }
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __Pyx_XGIVEREF(__pyx_t_18);
+          __Pyx_XGIVEREF(__pyx_t_19);
+          __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+          __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+          __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16;
+          goto __pyx_L8_except_error;
+        }
+        __pyx_L20_return: {
+          __pyx_t_22 = __pyx_r;
+          __pyx_r = 0;
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          __pyx_r = __pyx_t_22;
+          __pyx_t_22 = 0;
+          goto __pyx_L9_except_return;
+        }
+      }
+    }
+    goto __pyx_L8_except_error;
+    __pyx_L8_except_error:;
+
+    /* "uvloop/loop.pyx":1018
+ *                     f'in the _sock_sendall callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             n = sock.send(data)
+ *         except (BlockingIOError, InterruptedError):
+ */
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    goto __pyx_L1_error;
+    __pyx_L9_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    goto __pyx_L0;
+    __pyx_L11_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":1030
+ *             return
+ * 
+ *         self._remove_writer(sock)             # <<<<<<<<<<<<<<
+ * 
+ *         if n == len(data):
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_writer(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1030, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1032
+ *         self._remove_writer(sock)
+ * 
+ *         if n == len(data):             # <<<<<<<<<<<<<<
+ *             fut.set_result(None)
+ *         else:
+ */
+  __pyx_t_6 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1032, __pyx_L1_error)
+  __pyx_t_5 = ((__pyx_v_n == __pyx_t_6) != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/loop.pyx":1033
+ * 
+ *         if n == len(data):
+ *             fut.set_result(None)             # <<<<<<<<<<<<<<
+ *         else:
+ *             if n:
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1033, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, Py_None) : __Pyx_PyObject_CallOneArg(__pyx_t_3, Py_None);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1033, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":1032
+ *         self._remove_writer(sock)
+ * 
+ *         if n == len(data):             # <<<<<<<<<<<<<<
+ *             fut.set_result(None)
+ *         else:
+ */
+    goto __pyx_L27;
+  }
+
+  /* "uvloop/loop.pyx":1035
+ *             fut.set_result(None)
+ *         else:
+ *             if n:             # <<<<<<<<<<<<<<
+ *                 if not isinstance(data, memoryview):
+ *                     data = memoryview(data)
+ */
+  /*else*/ {
+    __pyx_t_5 = (__pyx_v_n != 0);
+    if (__pyx_t_5) {
+
+      /* "uvloop/loop.pyx":1036
+ *         else:
+ *             if n:
+ *                 if not isinstance(data, memoryview):             # <<<<<<<<<<<<<<
+ *                     data = memoryview(data)
+ *                 data = data[n:]
+ */
+      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1036, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_5 = PyObject_IsInstance(__pyx_v_data, __pyx_t_2); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 1036, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0);
+      if (__pyx_t_1) {
+
+        /* "uvloop/loop.pyx":1037
+ *             if n:
+ *                 if not isinstance(data, memoryview):
+ *                     data = memoryview(data)             # <<<<<<<<<<<<<<
+ *                 data = data[n:]
+ * 
+ */
+        __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1037, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_data); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1037, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_DECREF_SET(__pyx_v_data, __pyx_t_3);
+        __pyx_t_3 = 0;
+
+        /* "uvloop/loop.pyx":1036
+ *         else:
+ *             if n:
+ *                 if not isinstance(data, memoryview):             # <<<<<<<<<<<<<<
+ *                     data = memoryview(data)
+ *                 data = data[n:]
+ */
+      }
+
+      /* "uvloop/loop.pyx":1038
+ *                 if not isinstance(data, memoryview):
+ *                     data = memoryview(data)
+ *                 data = data[n:]             # <<<<<<<<<<<<<<
+ * 
+ *             handle = new_MethodHandle3(
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_v_data, __pyx_v_n, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1038, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF_SET(__pyx_v_data, __pyx_t_3);
+      __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":1035
+ *             fut.set_result(None)
+ *         else:
+ *             if n:             # <<<<<<<<<<<<<<
+ *                 if not isinstance(data, memoryview):
+ *                     data = memoryview(data)
+ */
+    }
+
+    /* "uvloop/loop.pyx":1040
+ *                 data = data[n:]
+ * 
+ *             handle = new_MethodHandle3(             # <<<<<<<<<<<<<<
+ *                 self,
+ *                 "Loop._sock_sendall",
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_new_MethodHandle3(__pyx_v_self, __pyx_kp_u_Loop__sock_sendall, ((__pyx_t_6uvloop_4loop_method3_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_sock_sendall), Py_None, ((PyObject *)__pyx_v_self), __pyx_v_fut, __pyx_v_sock, __pyx_v_data); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1040, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 1040, __pyx_L1_error)
+    __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":1048
+ *                 fut, sock, data)
+ * 
+ *             self._add_writer(sock, handle)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _sock_accept(self, fut, sock):
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_add_writer(__pyx_v_self, __pyx_v_sock, __pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1048, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_L27:;
+
+  /* "uvloop/loop.pyx":1002
+ *             self._remove_reader(sock)
+ * 
+ *     cdef _sock_sendall(self, fut, sock, data):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             Handle handle
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("uvloop.loop.Loop._sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1050
+ *             self._add_writer(sock, handle)
+ * 
+ *     cdef _sock_accept(self, fut, sock):             # <<<<<<<<<<<<<<
+ *         try:
+ *             conn, address = sock.accept()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_accept(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock) {
+  PyObject *__pyx_v_conn = NULL;
+  PyObject *__pyx_v_address = NULL;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *(*__pyx_t_8)(PyObject *);
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_t_12;
+  char const *__pyx_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_sock_accept", 0);
+
+  /* "uvloop/loop.pyx":1051
+ * 
+ *     cdef _sock_accept(self, fut, sock):
+ *         try:             # <<<<<<<<<<<<<<
+ *             conn, address = sock.accept()
+ *             conn.setblocking(False)
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":1052
+ *     cdef _sock_accept(self, fut, sock):
+ *         try:
+ *             conn, address = sock.accept()             # <<<<<<<<<<<<<<
+ *             conn.setblocking(False)
+ *         except (BlockingIOError, InterruptedError):
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_accept); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1052, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __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_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_4 = (__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_4)) __PYX_ERR(0, 1052, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 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);
+        if (unlikely(size != 2)) {
+          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+          __PYX_ERR(0, 1052, __pyx_L3_error)
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        if (likely(PyTuple_CheckExact(sequence))) {
+          __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); 
+          __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); 
+        } else {
+          __pyx_t_5 = PyList_GET_ITEM(sequence, 0); 
+          __pyx_t_6 = PyList_GET_ITEM(sequence, 1); 
+        }
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_6);
+        #else
+        __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1052, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1052, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else {
+        Py_ssize_t index = -1;
+        __pyx_t_7 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1052, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
+        index = 0; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L9_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_5);
+        index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L9_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_6);
+        if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 1052, __pyx_L3_error)
+        __pyx_t_8 = NULL;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L10_unpacking_done;
+        __pyx_L9_unpacking_failed:;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __pyx_t_8 = NULL;
+        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+        __PYX_ERR(0, 1052, __pyx_L3_error)
+        __pyx_L10_unpacking_done:;
+      }
+      __pyx_v_conn = __pyx_t_5;
+      __pyx_t_5 = 0;
+      __pyx_v_address = __pyx_t_6;
+      __pyx_t_6 = 0;
+
+      /* "uvloop/loop.pyx":1053
+ *         try:
+ *             conn, address = sock.accept()
+ *             conn.setblocking(False)             # <<<<<<<<<<<<<<
+ *         except (BlockingIOError, InterruptedError):
+ *             # There is an active reader for _sock_accept, so
+ */
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_conn, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1053, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_5)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_5);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_5, Py_False) : __Pyx_PyObject_CallOneArg(__pyx_t_6, Py_False);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1053, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":1051
+ * 
+ *     cdef _sock_accept(self, fut, sock):
+ *         try:             # <<<<<<<<<<<<<<
+ *             conn, address = sock.accept()
+ *             conn.setblocking(False)
+ */
+    }
+
+    /* "uvloop/loop.pyx":1064
+ *             self._remove_reader(sock)
+ *         else:
+ *             fut.set_result((conn, address))             # <<<<<<<<<<<<<<
+ *             self._remove_reader(sock)
+ * 
+ */
+    /*else:*/ {
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1064, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1064, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_v_conn);
+      __Pyx_GIVEREF(__pyx_v_conn);
+      PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_conn);
+      __Pyx_INCREF(__pyx_v_address);
+      __Pyx_GIVEREF(__pyx_v_address);
+      PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_address);
+      __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1064, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":1065
+ *         else:
+ *             fut.set_result((conn, address))
+ *             self._remove_reader(sock)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _sock_connect(self, sock, address):
+ */
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_reader(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1065, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":1054
+ *             conn, address = sock.accept()
+ *             conn.setblocking(False)
+ *         except (BlockingIOError, InterruptedError):             # <<<<<<<<<<<<<<
+ *             # There is an active reader for _sock_accept, so
+ *             # do nothing, it will be called again.
+ */
+    __Pyx_ErrFetch(&__pyx_t_4, &__pyx_t_6, &__pyx_t_5);
+    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_BlockingIOError); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1054, __pyx_L5_except_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_InterruptedError); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1054, __pyx_L5_except_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_10 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_4, __pyx_t_7) || __Pyx_PyErr_GivenExceptionMatches(__pyx_t_4, __pyx_t_9);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_5);
+    __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0;
+    if (__pyx_t_10) {
+      __Pyx_ErrRestore(0,0,0);
+      goto __pyx_L4_exception_handled;
+    }
+
+    /* "uvloop/loop.pyx":1058
+ *             # do nothing, it will be called again.
+ *             pass
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException as exc:
+ */
+    __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+    if (__pyx_t_10) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._sock_accept", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_4) < 0) __PYX_ERR(0, 1058, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/loop.pyx":1059
+ *             pass
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)
+ */
+      __Pyx_GIVEREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_6, __pyx_t_4);
+      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_4 = 0; 
+      __PYX_ERR(0, 1059, __pyx_L5_except_error)
+    }
+
+    /* "uvloop/loop.pyx":1060
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             fut.set_exception(exc)
+ *             self._remove_reader(sock)
+ */
+    __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_10) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._sock_accept", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_5) < 0) __PYX_ERR(0, 1060, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_v_exc = __pyx_t_6;
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":1061
+ *             raise
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)             # <<<<<<<<<<<<<<
+ *             self._remove_reader(sock)
+ *         else:
+ */
+        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1061, __pyx_L18_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __pyx_t_11 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+          __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_7);
+          if (likely(__pyx_t_11)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+            __Pyx_INCREF(__pyx_t_11);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_7, function);
+          }
+        }
+        __pyx_t_9 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_11, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_exc);
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1061, __pyx_L18_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        /* "uvloop/loop.pyx":1062
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)
+ *             self._remove_reader(sock)             # <<<<<<<<<<<<<<
+ *         else:
+ *             fut.set_result((conn, address))
+ */
+        __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_reader(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1062, __pyx_L18_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      }
+
+      /* "uvloop/loop.pyx":1060
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             fut.set_exception(exc)
+ *             self._remove_reader(sock)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L19;
+        }
+        __pyx_L18_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __pyx_t_10 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+          }
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+          __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+          __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13;
+          goto __pyx_L5_except_error;
+        }
+        __pyx_L19:;
+      }
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/loop.pyx":1051
+ * 
+ *     cdef _sock_accept(self, fut, sock):
+ *         try:             # <<<<<<<<<<<<<<
+ *             conn, address = sock.accept()
+ *             conn.setblocking(False)
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":1050
+ *             self._add_writer(sock, handle)
+ * 
+ *     cdef _sock_accept(self, fut, sock):             # <<<<<<<<<<<<<<
+ *         try:
+ *             conn, address = sock.accept()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("uvloop.loop.Loop._sock_accept", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_conn);
+  __Pyx_XDECREF(__pyx_v_address);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1067
+ *             self._remove_reader(sock)
+ * 
+ *     cdef _sock_connect(self, sock, address):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             Handle handle
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_connect(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_address) {
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
+  PyObject *__pyx_v_fut = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_sock_connect", 0);
+
+  /* "uvloop/loop.pyx":1071
+ *             Handle handle
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             sock.connect(address)
+ *         except (BlockingIOError, InterruptedError):
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":1072
+ * 
+ *         try:
+ *             sock.connect(address)             # <<<<<<<<<<<<<<
+ *         except (BlockingIOError, InterruptedError):
+ *             pass
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_connect); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1072, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __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_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_v_address) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_address);
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1072, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":1071
+ *             Handle handle
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             sock.connect(address)
+ *         except (BlockingIOError, InterruptedError):
+ */
+    }
+
+    /* "uvloop/loop.pyx":1076
+ *             pass
+ *         else:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         fut = _SyncSocketWriterFuture(sock, self)
+ */
+    /*else:*/ {
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L6_except_return;
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/loop.pyx":1073
+ *         try:
+ *             sock.connect(address)
+ *         except (BlockingIOError, InterruptedError):             # <<<<<<<<<<<<<<
+ *             pass
+ *         else:
+ */
+    __Pyx_ErrFetch(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_BlockingIOError); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1073, __pyx_L5_except_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_InterruptedError); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1073, __pyx_L5_except_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_9 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_4, __pyx_t_7) || __Pyx_PyErr_GivenExceptionMatches(__pyx_t_4, __pyx_t_8);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_ErrRestore(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0;
+    if (__pyx_t_9) {
+      __Pyx_ErrRestore(0,0,0);
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/loop.pyx":1071
+ *             Handle handle
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             sock.connect(address)
+ *         except (BlockingIOError, InterruptedError):
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L0;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+  }
+
+  /* "uvloop/loop.pyx":1078
+ *             return
+ * 
+ *         fut = _SyncSocketWriterFuture(sock, self)             # <<<<<<<<<<<<<<
+ *         handle = new_MethodHandle3(
+ *             self,
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_SyncSocketWriterFuture); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1078, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = NULL;
+  __pyx_t_9 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+      __pyx_t_9 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_5)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_sock, ((PyObject *)__pyx_v_self)};
+    __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1078, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_6);
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_sock, ((PyObject *)__pyx_v_self)};
+    __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1078, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_6);
+  } else
+  #endif
+  {
+    __pyx_t_8 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1078, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    if (__pyx_t_4) {
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+    }
+    __Pyx_INCREF(__pyx_v_sock);
+    __Pyx_GIVEREF(__pyx_v_sock);
+    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_9, __pyx_v_sock);
+    __Pyx_INCREF(((PyObject *)__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_9, ((PyObject *)__pyx_v_self));
+    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1078, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_fut = __pyx_t_6;
+  __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1079
+ * 
+ *         fut = _SyncSocketWriterFuture(sock, self)
+ *         handle = new_MethodHandle3(             # <<<<<<<<<<<<<<
+ *             self,
+ *             "Loop._sock_connect",
+ */
+  __pyx_t_6 = __pyx_f_6uvloop_4loop_new_MethodHandle3(__pyx_v_self, __pyx_kp_u_Loop__sock_connect, ((__pyx_t_6uvloop_4loop_method3_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_sock_connect_cb), Py_None, ((PyObject *)__pyx_v_self), __pyx_v_fut, __pyx_v_sock, __pyx_v_address); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1079, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 1079, __pyx_L1_error)
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1087
+ *             fut, sock, address)
+ * 
+ *         self._add_writer(sock, handle)             # <<<<<<<<<<<<<<
+ *         return fut
+ * 
+ */
+  __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_add_writer(__pyx_v_self, __pyx_v_sock, __pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1087, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1088
+ * 
+ *         self._add_writer(sock, handle)
+ *         return fut             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _sock_connect_cb(self, fut, sock, address):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_fut);
+  __pyx_r = __pyx_v_fut;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1067
+ *             self._remove_reader(sock)
+ * 
+ *     cdef _sock_connect(self, sock, address):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             Handle handle
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.Loop._sock_connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XDECREF(__pyx_v_fut);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1090
+ *         return fut
+ * 
+ *     cdef _sock_connect_cb(self, fut, sock, address):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_connect_cb(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_address) {
+  PyObject *__pyx_v_err = NULL;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  Py_ssize_t __pyx_t_6;
+  Py_UCS4 __pyx_t_7;
+  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_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_t_15;
+  char const *__pyx_t_16;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_sock_connect_cb", 0);
+
+  /* "uvloop/loop.pyx":1091
+ * 
+ *     cdef _sock_connect_cb(self, fut, sock, address):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1092
+ *     cdef _sock_connect_cb(self, fut, sock, address):
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():             # <<<<<<<<<<<<<<
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ *                 raise RuntimeError(
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1092, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1092, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1092, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":1094
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'_sock_connect_cb is called on a cancelled Future')
+ * 
+ */
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1094, __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(0, 1094, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1092
+ *     cdef _sock_connect_cb(self, fut, sock, address):
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():             # <<<<<<<<<<<<<<
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ *                 raise RuntimeError(
+ */
+    }
+
+    /* "uvloop/loop.pyx":1097
+ *                     f'_sock_connect_cb is called on a cancelled Future')
+ * 
+ *             if not self._has_writer(sock):             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a writer '
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_has_writer(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1097, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1097, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_5 = ((!__pyx_t_1) != 0);
+    if (unlikely(__pyx_t_5)) {
+
+      /* "uvloop/loop.pyx":1099
+ *             if not self._has_writer(sock):
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a writer '             # <<<<<<<<<<<<<<
+ *                     f'in the _sock_connect_cb callback')
+ * 
+ */
+      __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1099, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_6 = 0;
+      __pyx_t_7 = 127;
+      __Pyx_INCREF(__pyx_kp_u_socket);
+      __pyx_t_6 += 7;
+      __Pyx_GIVEREF(__pyx_kp_u_socket);
+      PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_socket);
+      __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_sock), __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1099, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_7;
+      __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __Pyx_INCREF(__pyx_kp_u_does_not_have_a_writer_in_the_2);
+      __pyx_t_6 += 56;
+      __Pyx_GIVEREF(__pyx_kp_u_does_not_have_a_writer_in_the_2);
+      PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_does_not_have_a_writer_in_the_2);
+      __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1099, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":1098
+ * 
+ *             if not self._has_writer(sock):
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'socket {sock!r} does not have a writer '
+ *                     f'in the _sock_connect_cb callback')
+ */
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1098, __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(0, 1098, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1097
+ *                     f'_sock_connect_cb is called on a cancelled Future')
+ * 
+ *             if not self._has_writer(sock):             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     f'socket {sock!r} does not have a writer '
+ */
+    }
+
+    /* "uvloop/loop.pyx":1091
+ * 
+ *     cdef _sock_connect_cb(self, fut, sock, address):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ */
+  }
+
+  /* "uvloop/loop.pyx":1102
+ *                     f'in the _sock_connect_cb callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
+ *             if err != 0:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+    __Pyx_XGOTREF(__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_9);
+    __Pyx_XGOTREF(__pyx_t_10);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":1103
+ * 
+ *         try:
+ *             err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)             # <<<<<<<<<<<<<<
+ *             if err != 0:
+ *                 # Jump to any except clause below.
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_getsockopt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1103, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = __Pyx_PyInt_From_int(SOL_SOCKET); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1103, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_11 = __Pyx_PyInt_From_int(SO_ERROR); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1103, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_12 = NULL;
+      __pyx_t_13 = 0;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+        __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3);
+        if (likely(__pyx_t_12)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+          __Pyx_INCREF(__pyx_t_12);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_3, function);
+          __pyx_t_13 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_3)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_t_4, __pyx_t_11};
+        __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1103, __pyx_L6_error)
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_t_4, __pyx_t_11};
+        __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1103, __pyx_L6_error)
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1103, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_14);
+        if (__pyx_t_12) {
+          __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __pyx_t_12 = NULL;
+        }
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_11);
+        PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_11);
+        __pyx_t_4 = 0;
+        __pyx_t_11 = 0;
+        __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_14, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1103, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_v_err = __pyx_t_2;
+      __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":1104
+ *         try:
+ *             err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
+ *             if err != 0:             # <<<<<<<<<<<<<<
+ *                 # Jump to any except clause below.
+ *                 raise OSError(err, 'Connect call failed %s' % (address,))
+ */
+      __pyx_t_2 = __Pyx_PyInt_NeObjC(__pyx_v_err, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1104, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 1104, __pyx_L6_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      if (unlikely(__pyx_t_5)) {
+
+        /* "uvloop/loop.pyx":1106
+ *             if err != 0:
+ *                 # Jump to any except clause below.
+ *                 raise OSError(err, 'Connect call failed %s' % (address,))             # <<<<<<<<<<<<<<
+ *         except (BlockingIOError, InterruptedError):
+ *             # socket is still registered, the callback will be retried later
+ */
+        __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Unicode(__pyx_v_address), __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1106, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Connect_call_failed, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1106, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1106, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_INCREF(__pyx_v_err);
+        __Pyx_GIVEREF(__pyx_v_err);
+        PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_err);
+        __Pyx_GIVEREF(__pyx_t_3);
+        PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3);
+        __pyx_t_3 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1106, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(0, 1106, __pyx_L6_error)
+
+        /* "uvloop/loop.pyx":1104
+ *         try:
+ *             err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
+ *             if err != 0:             # <<<<<<<<<<<<<<
+ *                 # Jump to any except clause below.
+ *                 raise OSError(err, 'Connect call failed %s' % (address,))
+ */
+      }
+
+      /* "uvloop/loop.pyx":1102
+ *                     f'in the _sock_connect_cb callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
+ *             if err != 0:
+ */
+    }
+
+    /* "uvloop/loop.pyx":1116
+ *             self._remove_writer(sock)
+ *         else:
+ *             fut.set_result(None)             # <<<<<<<<<<<<<<
+ *             self._remove_writer(sock)
+ * 
+ */
+    /*else:*/ {
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1116, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_14 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+        __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_2);
+        if (likely(__pyx_t_14)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+          __Pyx_INCREF(__pyx_t_14);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_2, function);
+        }
+      }
+      __pyx_t_3 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_14, Py_None) : __Pyx_PyObject_CallOneArg(__pyx_t_2, Py_None);
+      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1116, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":1117
+ *         else:
+ *             fut.set_result(None)
+ *             self._remove_writer(sock)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _sock_set_reuseport(self, int fd):
+ */
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_writer(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1117, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    goto __pyx_L11_try_end;
+    __pyx_L6_error:;
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":1107
+ *                 # Jump to any except clause below.
+ *                 raise OSError(err, 'Connect call failed %s' % (address,))
+ *         except (BlockingIOError, InterruptedError):             # <<<<<<<<<<<<<<
+ *             # socket is still registered, the callback will be retried later
+ *             pass
+ */
+    __Pyx_ErrFetch(&__pyx_t_3, &__pyx_t_2, &__pyx_t_14);
+    __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_BlockingIOError); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1107, __pyx_L8_except_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_InterruptedError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1107, __pyx_L8_except_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_13 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_3, __pyx_t_11) || __Pyx_PyErr_GivenExceptionMatches(__pyx_t_3, __pyx_t_4);
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_ErrRestore(__pyx_t_3, __pyx_t_2, __pyx_t_14);
+    __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_14 = 0;
+    if (__pyx_t_13) {
+      __Pyx_ErrRestore(0,0,0);
+      goto __pyx_L7_exception_handled;
+    }
+
+    /* "uvloop/loop.pyx":1110
+ *             # socket is still registered, the callback will be retried later
+ *             pass
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException as exc:
+ */
+    __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+    if (__pyx_t_13) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._sock_connect_cb", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 1110, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_14);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_3);
+
+      /* "uvloop/loop.pyx":1111
+ *             pass
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)
+ */
+      __Pyx_GIVEREF(__pyx_t_14);
+      __Pyx_GIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_ErrRestoreWithState(__pyx_t_14, __pyx_t_2, __pyx_t_3);
+      __pyx_t_14 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; 
+      __PYX_ERR(0, 1111, __pyx_L8_except_error)
+    }
+
+    /* "uvloop/loop.pyx":1112
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             fut.set_exception(exc)
+ *             self._remove_writer(sock)
+ */
+    __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_13) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._sock_connect_cb", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_14) < 0) __PYX_ERR(0, 1112, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_14);
+      __Pyx_INCREF(__pyx_t_2);
+      __pyx_v_exc = __pyx_t_2;
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":1113
+ *             raise
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)             # <<<<<<<<<<<<<<
+ *             self._remove_writer(sock)
+ *         else:
+ */
+        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1113, __pyx_L20_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __pyx_t_12 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+          __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+          if (likely(__pyx_t_12)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+            __Pyx_INCREF(__pyx_t_12);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_11, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_12, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_exc);
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1113, __pyx_L20_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/loop.pyx":1114
+ *         except BaseException as exc:
+ *             fut.set_exception(exc)
+ *             self._remove_writer(sock)             # <<<<<<<<<<<<<<
+ *         else:
+ *             fut.set_result(None)
+ */
+        __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_writer(__pyx_v_self, __pyx_v_sock); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1114, __pyx_L20_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+
+      /* "uvloop/loop.pyx":1112
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             fut.set_exception(exc)
+ *             self._remove_writer(sock)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L21;
+        }
+        __pyx_L20_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_20);
+          __Pyx_XGOTREF(__pyx_t_21);
+          __Pyx_XGOTREF(__pyx_t_22);
+          __pyx_t_13 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_XGIVEREF(__pyx_t_21);
+            __Pyx_XGIVEREF(__pyx_t_22);
+            __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
+          }
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __Pyx_XGIVEREF(__pyx_t_18);
+          __Pyx_XGIVEREF(__pyx_t_19);
+          __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+          __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+          __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16;
+          goto __pyx_L8_except_error;
+        }
+        __pyx_L21:;
+      }
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+      goto __pyx_L7_exception_handled;
+    }
+    goto __pyx_L8_except_error;
+    __pyx_L8_except_error:;
+
+    /* "uvloop/loop.pyx":1102
+ *                     f'in the _sock_connect_cb callback')
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
+ *             if err != 0:
+ */
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    goto __pyx_L1_error;
+    __pyx_L7_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    __pyx_L11_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":1090
+ *         return fut
+ * 
+ *     cdef _sock_connect_cb(self, fut, sock, address):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if fut.cancelled():
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("uvloop.loop.Loop._sock_connect_cb", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_err);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1119
+ *             self._remove_writer(sock)
+ * 
+ *     cdef _sock_set_reuseport(self, int fd):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int err
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_set_reuseport(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, int __pyx_v_fd) {
+  int __pyx_v_err;
+  int __pyx_v_reuseport_flag;
+  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("_sock_set_reuseport", 0);
+
+  /* "uvloop/loop.pyx":1122
+ *         cdef:
+ *             int err
+ *             int reuseport_flag = 1             # <<<<<<<<<<<<<<
+ * 
+ *         err = system.setsockopt(
+ */
+  __pyx_v_reuseport_flag = 1;
+
+  /* "uvloop/loop.pyx":1124
+ *             int reuseport_flag = 1
+ * 
+ *         err = system.setsockopt(             # <<<<<<<<<<<<<<
+ *             fd,
+ *             uv.SOL_SOCKET,
+ */
+  __pyx_v_err = setsockopt(__pyx_v_fd, SOL_SOCKET, __pyx_v_6uvloop_4loop_SO_REUSEPORT, ((char *)(&__pyx_v_reuseport_flag)), (sizeof(__pyx_v_reuseport_flag)));
+
+  /* "uvloop/loop.pyx":1131
+ *             sizeof(reuseport_flag))
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(-errno.errno)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":1132
+ * 
+ *         if err < 0:
+ *             raise convert_error(-errno.errno)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _set_coroutine_debug(self, bint enabled):
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error((-errno)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1132, __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(0, 1132, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1131
+ *             sizeof(reuseport_flag))
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(-errno.errno)
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":1119
+ *             self._remove_writer(sock)
+ * 
+ *     cdef _sock_set_reuseport(self, int fd):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int err
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop._sock_set_reuseport", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1134
+ *             raise convert_error(-errno.errno)
+ * 
+ *     cdef _set_coroutine_debug(self, bint enabled):             # <<<<<<<<<<<<<<
+ *         enabled = bool(enabled)
+ *         if self._coroutine_debug_set == enabled:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__set_coroutine_debug(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, int __pyx_v_enabled) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = 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("_set_coroutine_debug", 0);
+
+  /* "uvloop/loop.pyx":1135
+ * 
+ *     cdef _set_coroutine_debug(self, bint enabled):
+ *         enabled = bool(enabled)             # <<<<<<<<<<<<<<
+ *         if self._coroutine_debug_set == enabled:
+ *             return
+ */
+  __pyx_t_1 = __pyx_v_enabled;
+  __pyx_v_enabled = (!(!__pyx_t_1));
+
+  /* "uvloop/loop.pyx":1136
+ *     cdef _set_coroutine_debug(self, bint enabled):
+ *         enabled = bool(enabled)
+ *         if self._coroutine_debug_set == enabled:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_coroutine_debug_set == __pyx_v_enabled) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1137
+ *         enabled = bool(enabled)
+ *         if self._coroutine_debug_set == enabled:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if enabled:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":1136
+ *     cdef _set_coroutine_debug(self, bint enabled):
+ *         enabled = bool(enabled)
+ *         if self._coroutine_debug_set == enabled:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":1139
+ *             return
+ * 
+ *         if enabled:             # <<<<<<<<<<<<<<
+ *             self._coroutine_origin_tracking_saved_depth = (
+ *                 sys.get_coroutine_origin_tracking_depth())
+ */
+  __pyx_t_1 = (__pyx_v_enabled != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1141
+ *         if enabled:
+ *             self._coroutine_origin_tracking_saved_depth = (
+ *                 sys.get_coroutine_origin_tracking_depth())             # <<<<<<<<<<<<<<
+ *             sys.set_coroutine_origin_tracking_depth(
+ *                 DEBUG_STACK_DEPTH)
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_sys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1141, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_get_coroutine_origin_tracking_de); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1141, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1141, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1141, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":1140
+ * 
+ *         if enabled:
+ *             self._coroutine_origin_tracking_saved_depth = (             # <<<<<<<<<<<<<<
+ *                 sys.get_coroutine_origin_tracking_depth())
+ *             sys.set_coroutine_origin_tracking_depth(
+ */
+    __pyx_v_self->_coroutine_origin_tracking_saved_depth = __pyx_t_5;
+
+    /* "uvloop/loop.pyx":1142
+ *             self._coroutine_origin_tracking_saved_depth = (
+ *                 sys.get_coroutine_origin_tracking_depth())
+ *             sys.set_coroutine_origin_tracking_depth(             # <<<<<<<<<<<<<<
+ *                 DEBUG_STACK_DEPTH)
+ *         else:
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_sys); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1142, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_set_coroutine_origin_tracking_de); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1142, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __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_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_int_10) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_int_10);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1142, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":1139
+ *             return
+ * 
+ *         if enabled:             # <<<<<<<<<<<<<<
+ *             self._coroutine_origin_tracking_saved_depth = (
+ *                 sys.get_coroutine_origin_tracking_depth())
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/loop.pyx":1145
+ *                 DEBUG_STACK_DEPTH)
+ *         else:
+ *             sys.set_coroutine_origin_tracking_depth(             # <<<<<<<<<<<<<<
+ *                 self._coroutine_origin_tracking_saved_depth)
+ * 
+ */
+  /*else*/ {
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_sys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1145, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_set_coroutine_origin_tracking_de); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1145, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":1146
+ *         else:
+ *             sys.set_coroutine_origin_tracking_depth(
+ *                 self._coroutine_origin_tracking_saved_depth)             # <<<<<<<<<<<<<<
+ * 
+ *         self._coroutine_debug_set = enabled
+ */
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->_coroutine_origin_tracking_saved_depth); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1146, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_6 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_4, function);
+      }
+    }
+    __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1145, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+  __pyx_L4:;
+
+  /* "uvloop/loop.pyx":1148
+ *                 self._coroutine_origin_tracking_saved_depth)
+ * 
+ *         self._coroutine_debug_set = enabled             # <<<<<<<<<<<<<<
+ * 
+ *     def _get_backend_id(self):
+ */
+  __pyx_v_self->_coroutine_debug_set = __pyx_v_enabled;
+
+  /* "uvloop/loop.pyx":1134
+ *             raise convert_error(-errno.errno)
+ * 
+ *     cdef _set_coroutine_debug(self, bint enabled):             # <<<<<<<<<<<<<<
+ *         enabled = bool(enabled)
+ *         if self._coroutine_debug_set == enabled:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.Loop._set_coroutine_debug", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1150
+ *         self._coroutine_debug_set = enabled
+ * 
+ *     def _get_backend_id(self):             # <<<<<<<<<<<<<<
+ *         """This method is used by uvloop tests and is not part of the API."""
+ *         return uv.uv_backend_fd(self.uvloop)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_9_get_backend_id(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_8_get_backend_id[] = "Loop._get_backend_id(self)\nThis method is used by uvloop tests and is not part of the API.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_9_get_backend_id(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_get_backend_id (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_8_get_backend_id(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_8_get_backend_id(struct __pyx_obj_6uvloop_4loop_Loop *__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_backend_id", 0);
+
+  /* "uvloop/loop.pyx":1152
+ *     def _get_backend_id(self):
+ *         """This method is used by uvloop tests and is not part of the API."""
+ *         return uv.uv_backend_fd(self.uvloop)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _print_debug_info(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(uv_backend_fd(__pyx_v_self->uvloop)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1150
+ *         self._coroutine_debug_set = enabled
+ * 
+ *     def _get_backend_id(self):             # <<<<<<<<<<<<<<
+ *         """This method is used by uvloop tests and is not part of the API."""
+ *         return uv.uv_backend_fd(self.uvloop)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._get_backend_id", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1154
+ *         return uv.uv_backend_fd(self.uvloop)
+ * 
+ *     cdef _print_debug_info(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int err
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_4Loop__print_debug_info(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  int __pyx_v_err;
+  uv_rusage_t __pyx_v_rusage;
+  PyObject *__pyx_v_name = NULL;
+  PyObject *__pyx_r = NULL;
+  __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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  Py_ssize_t __pyx_t_10;
+  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("_print_debug_info", 0);
+
+  /* "uvloop/loop.pyx":1159
+ *             uv.uv_rusage_t rusage
+ * 
+ *         err = uv.uv_getrusage(&rusage)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             raise convert_error(err)
+ */
+  __pyx_v_err = uv_getrusage((&__pyx_v_rusage));
+
+  /* "uvloop/loop.pyx":1160
+ * 
+ *         err = uv.uv_getrusage(&rusage)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":1161
+ *         err = uv.uv_getrusage(&rusage)
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         # OS
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1161, __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(0, 1161, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1160
+ * 
+ *         err = uv.uv_getrusage(&rusage)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":1165
+ *         # OS
+ * 
+ *         print('---- Process info: -----')             # <<<<<<<<<<<<<<
+ *         print('Process memory:            {}'.format(rusage.ru_maxrss))
+ *         print('Number of signals:         {}'.format(rusage.ru_nsignals))
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1166
+ * 
+ *         print('---- Process info: -----')
+ *         print('Process memory:            {}'.format(rusage.ru_maxrss))             # <<<<<<<<<<<<<<
+ *         print('Number of signals:         {}'.format(rusage.ru_nsignals))
+ *         print('')
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Process_memory, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_rusage.ru_maxrss); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3, function);
+    }
+  }
+  __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, 1166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1167
+ *         print('---- Process info: -----')
+ *         print('Process memory:            {}'.format(rusage.ru_maxrss))
+ *         print('Number of signals:         {}'.format(rusage.ru_nsignals))             # <<<<<<<<<<<<<<
+ *         print('')
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Number_of_signals, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_rusage.ru_nsignals); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __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_3)) __PYX_ERR(0, 1167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1168
+ *         print('Process memory:            {}'.format(rusage.ru_maxrss))
+ *         print('Number of signals:         {}'.format(rusage.ru_nsignals))
+ *         print('')             # <<<<<<<<<<<<<<
+ * 
+ *         # Loop
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1172
+ *         # Loop
+ * 
+ *         print('--- Loop debug info: ---')             # <<<<<<<<<<<<<<
+ *         print('Loop time:                 {}'.format(self.time()))
+ *         print('Errors logged:             {}'.format(
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1173
+ * 
+ *         print('--- Loop debug info: ---')
+ *         print('Loop time:                 {}'.format(self.time()))             # <<<<<<<<<<<<<<
+ *         print('Errors logged:             {}'.format(
+ *             self._debug_exception_handler_cnt))
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Loop_time, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __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_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  __pyx_t_4 = (__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_4)) __PYX_ERR(0, 1173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3, function);
+    }
+  }
+  __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, 1173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1174
+ *         print('--- Loop debug info: ---')
+ *         print('Loop time:                 {}'.format(self.time()))
+ *         print('Errors logged:             {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_exception_handler_cnt))
+ *         print()
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Errors_logged, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/loop.pyx":1175
+ *         print('Loop time:                 {}'.format(self.time()))
+ *         print('Errors logged:             {}'.format(
+ *             self._debug_exception_handler_cnt))             # <<<<<<<<<<<<<<
+ *         print()
+ *         print('Callback handles:          {: <8} | {}'.format(
+ */
+  __pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_exception_handler_cnt); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __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_3)) __PYX_ERR(0, 1174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1174
+ *         print('--- Loop debug info: ---')
+ *         print('Loop time:                 {}'.format(self.time()))
+ *         print('Errors logged:             {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_exception_handler_cnt))
+ *         print()
+ */
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1176
+ *         print('Errors logged:             {}'.format(
+ *             self._debug_exception_handler_cnt))
+ *         print()             # <<<<<<<<<<<<<<
+ *         print('Callback handles:          {: <8} | {}'.format(
+ *             self._debug_cb_handles_count,
+ */
+  __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1177
+ *             self._debug_exception_handler_cnt))
+ *         print()
+ *         print('Callback handles:          {: <8} | {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_cb_handles_count,
+ *             self._debug_cb_handles_total))
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Callback_handles_8, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/loop.pyx":1178
+ *         print()
+ *         print('Callback handles:          {: <8} | {}'.format(
+ *             self._debug_cb_handles_count,             # <<<<<<<<<<<<<<
+ *             self._debug_cb_handles_total))
+ *         print('Timer handles:             {: <8} | {}'.format(
+ */
+  __pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_handles_count); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  /* "uvloop/loop.pyx":1179
+ *         print('Callback handles:          {: <8} | {}'.format(
+ *             self._debug_cb_handles_count,
+ *             self._debug_cb_handles_total))             # <<<<<<<<<<<<<<
+ *         print('Timer handles:             {: <8} | {}'.format(
+ *             self._debug_cb_timer_handles_count,
+ */
+  __pyx_t_5 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_handles_total); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = NULL;
+  __pyx_t_7 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(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_7 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_4, __pyx_t_5};
+    __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1177, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_4, __pyx_t_5};
+    __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1177, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1177, __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_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1177, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1177
+ *             self._debug_exception_handler_cnt))
+ *         print()
+ *         print('Callback handles:          {: <8} | {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_cb_handles_count,
+ *             self._debug_cb_handles_total))
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1180
+ *             self._debug_cb_handles_count,
+ *             self._debug_cb_handles_total))
+ *         print('Timer handles:             {: <8} | {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_cb_timer_handles_count,
+ *             self._debug_cb_timer_handles_total))
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Timer_handles_8, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1180, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/loop.pyx":1181
+ *             self._debug_cb_handles_total))
+ *         print('Timer handles:             {: <8} | {}'.format(
+ *             self._debug_cb_timer_handles_count,             # <<<<<<<<<<<<<<
+ *             self._debug_cb_timer_handles_total))
+ *         print()
+ */
+  __pyx_t_8 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_timer_handles_count); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1181, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+
+  /* "uvloop/loop.pyx":1182
+ *         print('Timer handles:             {: <8} | {}'.format(
+ *             self._debug_cb_timer_handles_count,
+ *             self._debug_cb_timer_handles_total))             # <<<<<<<<<<<<<<
+ *         print()
+ * 
+ */
+  __pyx_t_5 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_timer_handles_total); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = NULL;
+  __pyx_t_7 = 0;
+  if (CYTHON_UNPACK_METHODS && 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_7 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_8, __pyx_t_5};
+    __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1180, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_8, __pyx_t_5};
+    __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1180, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_6 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1180, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (__pyx_t_4) {
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_8);
+    PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_7, __pyx_t_8);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_7, __pyx_t_5);
+    __pyx_t_8 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1180, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1180
+ *             self._debug_cb_handles_count,
+ *             self._debug_cb_handles_total))
+ *         print('Timer handles:             {: <8} | {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_cb_timer_handles_count,
+ *             self._debug_cb_timer_handles_total))
+ */
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1180, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1183
+ *             self._debug_cb_timer_handles_count,
+ *             self._debug_cb_timer_handles_total))
+ *         print()             # <<<<<<<<<<<<<<
+ * 
+ *         print('                        alive  | closed  |')
+ */
+  __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1183, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1185
+ *         print()
+ * 
+ *         print('                        alive  | closed  |')             # <<<<<<<<<<<<<<
+ *         print('UVHandles               python | libuv   | total')
+ *         print('                        objs   | handles |')
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1185, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1186
+ * 
+ *         print('                        alive  | closed  |')
+ *         print('UVHandles               python | libuv   | total')             # <<<<<<<<<<<<<<
+ *         print('                        objs   | handles |')
+ *         print('-------------------------------+---------+---------')
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1186, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1187
+ *         print('                        alive  | closed  |')
+ *         print('UVHandles               python | libuv   | total')
+ *         print('                        objs   | handles |')             # <<<<<<<<<<<<<<
+ *         print('-------------------------------+---------+---------')
+ *         for name in sorted(self._debug_handles_total):
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1188
+ *         print('UVHandles               python | libuv   | total')
+ *         print('                        objs   | handles |')
+ *         print('-------------------------------+---------+---------')             # <<<<<<<<<<<<<<
+ *         for name in sorted(self._debug_handles_total):
+ *             print('    {: <18} {: >7} | {: >7} | {: >7}'.format(
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1189
+ *         print('                        objs   | handles |')
+ *         print('-------------------------------+---------+---------')
+ *         for name in sorted(self._debug_handles_total):             # <<<<<<<<<<<<<<
+ *             print('    {: <18} {: >7} | {: >7} | {: >7}'.format(
+ *                 name,
+ */
+  __pyx_t_3 = __pyx_v_self->_debug_handles_total;
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_t_6 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = ((PyObject*)__pyx_t_6);
+  __pyx_t_6 = 0;
+  __pyx_t_9 = PyList_Sort(__pyx_t_2); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(0, 1189, __pyx_L1_error)
+  if (unlikely(__pyx_t_2 == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(0, 1189, __pyx_L1_error)
+  }
+  __pyx_t_6 = __pyx_t_2; __Pyx_INCREF(__pyx_t_6); __pyx_t_10 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  for (;;) {
+    if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_6)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_2 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_2); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 1189, __pyx_L1_error)
+    #else
+    __pyx_t_2 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1189, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":1190
+ *         print('-------------------------------+---------+---------')
+ *         for name in sorted(self._debug_handles_total):
+ *             print('    {: <18} {: >7} | {: >7} | {: >7}'.format(             # <<<<<<<<<<<<<<
+ *                 name,
+ *                 self._debug_handles_current[name],
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_18_7_7_7, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1190, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/loop.pyx":1192
+ *             print('    {: <18} {: >7} | {: >7} | {: >7}'.format(
+ *                 name,
+ *                 self._debug_handles_current[name],             # <<<<<<<<<<<<<<
+ *                 self._debug_handles_closed[name],
+ *                 self._debug_handles_total[name]))
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_self->_debug_handles_current, __pyx_v_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1192, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+
+    /* "uvloop/loop.pyx":1193
+ *                 name,
+ *                 self._debug_handles_current[name],
+ *                 self._debug_handles_closed[name],             # <<<<<<<<<<<<<<
+ *                 self._debug_handles_total[name]))
+ *         print()
+ */
+    __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_self->_debug_handles_closed, __pyx_v_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1193, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+
+    /* "uvloop/loop.pyx":1194
+ *                 self._debug_handles_current[name],
+ *                 self._debug_handles_closed[name],
+ *                 self._debug_handles_total[name]))             # <<<<<<<<<<<<<<
+ *         print()
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_self->_debug_handles_total, __pyx_v_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1194, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_11 = NULL;
+    __pyx_t_7 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_11)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_11);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_7 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_v_name, __pyx_t_5, __pyx_t_8, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 4+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1190, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __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[5] = {__pyx_t_11, __pyx_v_name, __pyx_t_5, __pyx_t_8, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 4+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1190, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_12 = PyTuple_New(4+__pyx_t_7); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1190, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      if (__pyx_t_11) {
+        __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_11); __pyx_t_11 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_name);
+      __Pyx_GIVEREF(__pyx_v_name);
+      PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_7, __pyx_v_name);
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_7, __pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_8);
+      PyTuple_SET_ITEM(__pyx_t_12, 2+__pyx_t_7, __pyx_t_8);
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_12, 3+__pyx_t_7, __pyx_t_4);
+      __pyx_t_5 = 0;
+      __pyx_t_8 = 0;
+      __pyx_t_4 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1190, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":1190
+ *         print('-------------------------------+---------+---------')
+ *         for name in sorted(self._debug_handles_total):
+ *             print('    {: <18} {: >7} | {: >7} | {: >7}'.format(             # <<<<<<<<<<<<<<
+ *                 name,
+ *                 self._debug_handles_current[name],
+ */
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1190, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":1189
+ *         print('                        objs   | handles |')
+ *         print('-------------------------------+---------+---------')
+ *         for name in sorted(self._debug_handles_total):             # <<<<<<<<<<<<<<
+ *             print('    {: <18} {: >7} | {: >7} | {: >7}'.format(
+ *                 name,
+ */
+  }
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1195
+ *                 self._debug_handles_closed[name],
+ *                 self._debug_handles_total[name]))
+ *         print()             # <<<<<<<<<<<<<<
+ * 
+ *         print('uv_handle_t (current: {}; freed: {}; total: {})'.format(
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1195, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1197
+ *         print()
+ * 
+ *         print('uv_handle_t (current: {}; freed: {}; total: {})'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_uv_handles_total - self._debug_uv_handles_freed,
+ *             self._debug_uv_handles_freed,
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_uv_handle_t_current_freed_total, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/loop.pyx":1198
+ * 
+ *         print('uv_handle_t (current: {}; freed: {}; total: {})'.format(
+ *             self._debug_uv_handles_total - self._debug_uv_handles_freed,             # <<<<<<<<<<<<<<
+ *             self._debug_uv_handles_freed,
+ *             self._debug_uv_handles_total))
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t((__pyx_v_self->_debug_uv_handles_total - __pyx_v_self->_debug_uv_handles_freed)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1198, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/loop.pyx":1199
+ *         print('uv_handle_t (current: {}; freed: {}; total: {})'.format(
+ *             self._debug_uv_handles_total - self._debug_uv_handles_freed,
+ *             self._debug_uv_handles_freed,             # <<<<<<<<<<<<<<
+ *             self._debug_uv_handles_total))
+ *         print()
+ */
+  __pyx_t_12 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_uv_handles_freed); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_12);
+
+  /* "uvloop/loop.pyx":1200
+ *             self._debug_uv_handles_total - self._debug_uv_handles_freed,
+ *             self._debug_uv_handles_freed,
+ *             self._debug_uv_handles_total))             # <<<<<<<<<<<<<<
+ *         print()
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_uv_handles_total); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_8 = NULL;
+  __pyx_t_7 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_8)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_8);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+      __pyx_t_7 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_2, __pyx_t_12, __pyx_t_4};
+    __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1197, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __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[4] = {__pyx_t_8, __pyx_t_2, __pyx_t_12, __pyx_t_4};
+    __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1197, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_5 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1197, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (__pyx_t_8) {
+      __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_8); __pyx_t_8 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_7, __pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_12);
+    PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_7, __pyx_t_12);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_5, 2+__pyx_t_7, __pyx_t_4);
+    __pyx_t_2 = 0;
+    __pyx_t_12 = 0;
+    __pyx_t_4 = 0;
+    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1197, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1197
+ *         print()
+ * 
+ *         print('uv_handle_t (current: {}; freed: {}; total: {})'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_uv_handles_total - self._debug_uv_handles_freed,
+ *             self._debug_uv_handles_freed,
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1201
+ *             self._debug_uv_handles_freed,
+ *             self._debug_uv_handles_total))
+ *         print()             # <<<<<<<<<<<<<<
+ * 
+ *         print('--- Streams debug info: ---')
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1201, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1203
+ *         print()
+ * 
+ *         print('--- Streams debug info: ---')             # <<<<<<<<<<<<<<
+ *         print('Write errors:              {}'.format(
+ *             self._debug_stream_write_errors_total))
+ */
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1203, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1204
+ * 
+ *         print('--- Streams debug info: ---')
+ *         print('Write errors:              {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_write_errors_total))
+ *         print('Write without poll:        {}'.format(
+ */
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_errors, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+
+  /* "uvloop/loop.pyx":1205
+ *         print('--- Streams debug info: ---')
+ *         print('Write errors:              {}'.format(
+ *             self._debug_stream_write_errors_total))             # <<<<<<<<<<<<<<
+ *         print('Write without poll:        {}'.format(
+ *             self._debug_stream_write_tries))
+ */
+  __pyx_t_5 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_errors_total); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1204
+ * 
+ *         print('--- Streams debug info: ---')
+ *         print('Write errors:              {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_write_errors_total))
+ *         print('Write without poll:        {}'.format(
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1206
+ *         print('Write errors:              {}'.format(
+ *             self._debug_stream_write_errors_total))
+ *         print('Write without poll:        {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_write_tries))
+ *         print('Write contexts:            {: <8} | {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_without_poll, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/loop.pyx":1207
+ *             self._debug_stream_write_errors_total))
+ *         print('Write without poll:        {}'.format(
+ *             self._debug_stream_write_tries))             # <<<<<<<<<<<<<<
+ *         print('Write contexts:            {: <8} | {}'.format(
+ *             self._debug_stream_write_ctx_cnt,
+ */
+  __pyx_t_5 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_tries); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1206
+ *         print('Write errors:              {}'.format(
+ *             self._debug_stream_write_errors_total))
+ *         print('Write without poll:        {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_write_tries))
+ *         print('Write contexts:            {: <8} | {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1208
+ *         print('Write without poll:        {}'.format(
+ *             self._debug_stream_write_tries))
+ *         print('Write contexts:            {: <8} | {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_write_ctx_cnt,
+ *             self._debug_stream_write_ctx_total))
+ */
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_contexts_8, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+
+  /* "uvloop/loop.pyx":1209
+ *             self._debug_stream_write_tries))
+ *         print('Write contexts:            {: <8} | {}'.format(
+ *             self._debug_stream_write_ctx_cnt,             # <<<<<<<<<<<<<<
+ *             self._debug_stream_write_ctx_total))
+ *         print('Write failed callbacks:    {}'.format(
+ */
+  __pyx_t_5 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_ctx_cnt); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+
+  /* "uvloop/loop.pyx":1210
+ *         print('Write contexts:            {: <8} | {}'.format(
+ *             self._debug_stream_write_ctx_cnt,
+ *             self._debug_stream_write_ctx_total))             # <<<<<<<<<<<<<<
+ *         print('Write failed callbacks:    {}'.format(
+ *             self._debug_stream_write_cb_errors_total))
+ */
+  __pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_ctx_total); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_12 = NULL;
+  __pyx_t_7 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_12)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_12);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+      __pyx_t_7 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_6)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_t_5, __pyx_t_4};
+    __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1208, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_t_5, __pyx_t_4};
+    __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1208, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_2 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1208, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (__pyx_t_12) {
+      __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_12); __pyx_t_12 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_7, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_7, __pyx_t_4);
+    __pyx_t_5 = 0;
+    __pyx_t_4 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1208, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1208
+ *         print('Write without poll:        {}'.format(
+ *             self._debug_stream_write_tries))
+ *         print('Write contexts:            {: <8} | {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_write_ctx_cnt,
+ *             self._debug_stream_write_ctx_total))
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1211
+ *             self._debug_stream_write_ctx_cnt,
+ *             self._debug_stream_write_ctx_total))
+ *         print('Write failed callbacks:    {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_write_cb_errors_total))
+ *         print()
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_failed_callbacks, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/loop.pyx":1212
+ *             self._debug_stream_write_ctx_total))
+ *         print('Write failed callbacks:    {}'.format(
+ *             self._debug_stream_write_cb_errors_total))             # <<<<<<<<<<<<<<
+ *         print()
+ *         print('Read errors:               {}'.format(
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_cb_errors_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1212, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1211
+ *             self._debug_stream_write_ctx_cnt,
+ *             self._debug_stream_write_ctx_total))
+ *         print('Write failed callbacks:    {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_write_cb_errors_total))
+ *         print()
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1213
+ *         print('Write failed callbacks:    {}'.format(
+ *             self._debug_stream_write_cb_errors_total))
+ *         print()             # <<<<<<<<<<<<<<
+ *         print('Read errors:               {}'.format(
+ *             self._debug_stream_read_errors_total))
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1214
+ *             self._debug_stream_write_cb_errors_total))
+ *         print()
+ *         print('Read errors:               {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_read_errors_total))
+ *         print('Read callbacks:            {}'.format(
+ */
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_errors, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+
+  /* "uvloop/loop.pyx":1215
+ *         print()
+ *         print('Read errors:               {}'.format(
+ *             self._debug_stream_read_errors_total))             # <<<<<<<<<<<<<<
+ *         print('Read callbacks:            {}'.format(
+ *             self._debug_stream_read_cb_total))
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_errors_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1215, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1214
+ *             self._debug_stream_write_cb_errors_total))
+ *         print()
+ *         print('Read errors:               {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_read_errors_total))
+ *         print('Read callbacks:            {}'.format(
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1216
+ *         print('Read errors:               {}'.format(
+ *             self._debug_stream_read_errors_total))
+ *         print('Read callbacks:            {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_read_cb_total))
+ *         print('Read failed callbacks:     {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_callbacks, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/loop.pyx":1217
+ *             self._debug_stream_read_errors_total))
+ *         print('Read callbacks:            {}'.format(
+ *             self._debug_stream_read_cb_total))             # <<<<<<<<<<<<<<
+ *         print('Read failed callbacks:     {}'.format(
+ *             self._debug_stream_read_cb_errors_total))
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_cb_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1216
+ *         print('Read errors:               {}'.format(
+ *             self._debug_stream_read_errors_total))
+ *         print('Read callbacks:            {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_read_cb_total))
+ *         print('Read failed callbacks:     {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1218
+ *         print('Read callbacks:            {}'.format(
+ *             self._debug_stream_read_cb_total))
+ *         print('Read failed callbacks:     {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_read_cb_errors_total))
+ *         print('Read EOFs:                 {}'.format(
+ */
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_failed_callbacks, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+
+  /* "uvloop/loop.pyx":1219
+ *             self._debug_stream_read_cb_total))
+ *         print('Read failed callbacks:     {}'.format(
+ *             self._debug_stream_read_cb_errors_total))             # <<<<<<<<<<<<<<
+ *         print('Read EOFs:                 {}'.format(
+ *             self._debug_stream_read_eof_total))
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_cb_errors_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1218
+ *         print('Read callbacks:            {}'.format(
+ *             self._debug_stream_read_cb_total))
+ *         print('Read failed callbacks:     {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_read_cb_errors_total))
+ *         print('Read EOFs:                 {}'.format(
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1220
+ *         print('Read failed callbacks:     {}'.format(
+ *             self._debug_stream_read_cb_errors_total))
+ *         print('Read EOFs:                 {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_read_eof_total))
+ *         print('Read EOF failed callbacks: {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_EOFs, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/loop.pyx":1221
+ *             self._debug_stream_read_cb_errors_total))
+ *         print('Read EOFs:                 {}'.format(
+ *             self._debug_stream_read_eof_total))             # <<<<<<<<<<<<<<
+ *         print('Read EOF failed callbacks: {}'.format(
+ *             self._debug_stream_read_eof_cb_errors_total))
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_eof_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1221, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1220
+ *         print('Read failed callbacks:     {}'.format(
+ *             self._debug_stream_read_cb_errors_total))
+ *         print('Read EOFs:                 {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_read_eof_total))
+ *         print('Read EOF failed callbacks: {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1222
+ *         print('Read EOFs:                 {}'.format(
+ *             self._debug_stream_read_eof_total))
+ *         print('Read EOF failed callbacks: {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_read_eof_cb_errors_total))
+ *         print()
+ */
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_EOF_failed_callbacks, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+
+  /* "uvloop/loop.pyx":1223
+ *             self._debug_stream_read_eof_total))
+ *         print('Read EOF failed callbacks: {}'.format(
+ *             self._debug_stream_read_eof_cb_errors_total))             # <<<<<<<<<<<<<<
+ *         print()
+ *         print('Listen errors:             {}'.format(
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_eof_cb_errors_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1222
+ *         print('Read EOFs:                 {}'.format(
+ *             self._debug_stream_read_eof_total))
+ *         print('Read EOF failed callbacks: {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_read_eof_cb_errors_total))
+ *         print()
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1224
+ *         print('Read EOF failed callbacks: {}'.format(
+ *             self._debug_stream_read_eof_cb_errors_total))
+ *         print()             # <<<<<<<<<<<<<<
+ *         print('Listen errors:             {}'.format(
+ *             self._debug_stream_listen_errors_total))
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1225
+ *             self._debug_stream_read_eof_cb_errors_total))
+ *         print()
+ *         print('Listen errors:             {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_listen_errors_total))
+ *         print('Shutdown errors            {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Listen_errors, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1225, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/loop.pyx":1226
+ *         print()
+ *         print('Listen errors:             {}'.format(
+ *             self._debug_stream_listen_errors_total))             # <<<<<<<<<<<<<<
+ *         print('Shutdown errors            {}'.format(
+ *             self._debug_stream_shutdown_errors_total))
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_listen_errors_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1225, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1225
+ *             self._debug_stream_read_eof_cb_errors_total))
+ *         print()
+ *         print('Listen errors:             {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_listen_errors_total))
+ *         print('Shutdown errors            {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1225, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1227
+ *         print('Listen errors:             {}'.format(
+ *             self._debug_stream_listen_errors_total))
+ *         print('Shutdown errors            {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_shutdown_errors_total))
+ *         print()
+ */
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Shutdown_errors, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+
+  /* "uvloop/loop.pyx":1228
+ *             self._debug_stream_listen_errors_total))
+ *         print('Shutdown errors            {}'.format(
+ *             self._debug_stream_shutdown_errors_total))             # <<<<<<<<<<<<<<
+ *         print()
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_shutdown_errors_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1227
+ *         print('Listen errors:             {}'.format(
+ *             self._debug_stream_listen_errors_total))
+ *         print('Shutdown errors            {}'.format(             # <<<<<<<<<<<<<<
+ *             self._debug_stream_shutdown_errors_total))
+ *         print()
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1229
+ *         print('Shutdown errors            {}'.format(
+ *             self._debug_stream_shutdown_errors_total))
+ *         print()             # <<<<<<<<<<<<<<
+ * 
+ *         print('--- Polls debug info: ---')
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1231
+ *         print()
+ * 
+ *         print('--- Polls debug info: ---')             # <<<<<<<<<<<<<<
+ *         print('Read events:               {}'.format(
+ *             self._poll_read_events_total))
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1231, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1232
+ * 
+ *         print('--- Polls debug info: ---')
+ *         print('Read events:               {}'.format(             # <<<<<<<<<<<<<<
+ *             self._poll_read_events_total))
+ *         print('Read callbacks failed:     {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_events, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/loop.pyx":1233
+ *         print('--- Polls debug info: ---')
+ *         print('Read events:               {}'.format(
+ *             self._poll_read_events_total))             # <<<<<<<<<<<<<<
+ *         print('Read callbacks failed:     {}'.format(
+ *             self._poll_read_cb_errors_total))
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_read_events_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1233, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1232
+ * 
+ *         print('--- Polls debug info: ---')
+ *         print('Read events:               {}'.format(             # <<<<<<<<<<<<<<
+ *             self._poll_read_events_total))
+ *         print('Read callbacks failed:     {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1234
+ *         print('Read events:               {}'.format(
+ *             self._poll_read_events_total))
+ *         print('Read callbacks failed:     {}'.format(             # <<<<<<<<<<<<<<
+ *             self._poll_read_cb_errors_total))
+ *         print('Write events:              {}'.format(
+ */
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_callbacks_failed, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+
+  /* "uvloop/loop.pyx":1235
+ *             self._poll_read_events_total))
+ *         print('Read callbacks failed:     {}'.format(
+ *             self._poll_read_cb_errors_total))             # <<<<<<<<<<<<<<
+ *         print('Write events:              {}'.format(
+ *             self._poll_write_events_total))
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_read_cb_errors_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1234
+ *         print('Read events:               {}'.format(
+ *             self._poll_read_events_total))
+ *         print('Read callbacks failed:     {}'.format(             # <<<<<<<<<<<<<<
+ *             self._poll_read_cb_errors_total))
+ *         print('Write events:              {}'.format(
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1236
+ *         print('Read callbacks failed:     {}'.format(
+ *             self._poll_read_cb_errors_total))
+ *         print('Write events:              {}'.format(             # <<<<<<<<<<<<<<
+ *             self._poll_write_events_total))
+ *         print('Write callbacks failed:    {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_events, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/loop.pyx":1237
+ *             self._poll_read_cb_errors_total))
+ *         print('Write events:              {}'.format(
+ *             self._poll_write_events_total))             # <<<<<<<<<<<<<<
+ *         print('Write callbacks failed:    {}'.format(
+ *             self._poll_write_cb_errors_total))
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_write_events_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1237, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1236
+ *         print('Read callbacks failed:     {}'.format(
+ *             self._poll_read_cb_errors_total))
+ *         print('Write events:              {}'.format(             # <<<<<<<<<<<<<<
+ *             self._poll_write_events_total))
+ *         print('Write callbacks failed:    {}'.format(
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1238
+ *         print('Write events:              {}'.format(
+ *             self._poll_write_events_total))
+ *         print('Write callbacks failed:    {}'.format(             # <<<<<<<<<<<<<<
+ *             self._poll_write_cb_errors_total))
+ *         print()
+ */
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_callbacks_failed, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+
+  /* "uvloop/loop.pyx":1239
+ *             self._poll_write_events_total))
+ *         print('Write callbacks failed:    {}'.format(
+ *             self._poll_write_cb_errors_total))             # <<<<<<<<<<<<<<
+ *         print()
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_write_cb_errors_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1239, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1238
+ *         print('Write events:              {}'.format(
+ *             self._poll_write_events_total))
+ *         print('Write callbacks failed:    {}'.format(             # <<<<<<<<<<<<<<
+ *             self._poll_write_cb_errors_total))
+ *         print()
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1240
+ *         print('Write callbacks failed:    {}'.format(
+ *             self._poll_write_cb_errors_total))
+ *         print()             # <<<<<<<<<<<<<<
+ * 
+ *         print('--- Sock ops successful on 1st try: ---')
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1242
+ *         print()
+ * 
+ *         print('--- Sock ops successful on 1st try: ---')             # <<<<<<<<<<<<<<
+ *         print('Socket try-writes:         {}'.format(
+ *             self._sock_try_write_total))
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1243
+ * 
+ *         print('--- Sock ops successful on 1st try: ---')
+ *         print('Socket try-writes:         {}'.format(             # <<<<<<<<<<<<<<
+ *             self._sock_try_write_total))
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Socket_try_writes, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/loop.pyx":1244
+ *         print('--- Sock ops successful on 1st try: ---')
+ *         print('Socket try-writes:         {}'.format(
+ *             self._sock_try_write_total))             # <<<<<<<<<<<<<<
+ * 
+ *         print(flush=True)
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_sock_try_write_total); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1243
+ * 
+ *         print('--- Sock ops successful on 1st try: ---')
+ *         print('Socket try-writes:         {}'.format(             # <<<<<<<<<<<<<<
+ *             self._sock_try_write_total))
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1246
+ *             self._sock_try_write_total))
+ * 
+ *         print(flush=True)             # <<<<<<<<<<<<<<
+ * 
+ *     property print_debug_info:
+ */
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_flush, Py_True) < 0) __PYX_ERR(0, 1246, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1154
+ *         return uv.uv_backend_fd(self.uvloop)
+ * 
+ *     cdef _print_debug_info(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int err
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __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_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("uvloop.loop.Loop._print_debug_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_name);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1249
+ * 
+ *     property print_debug_info:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 return lambda: self._print_debug_info()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_16print_debug_info_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_16print_debug_info_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_16print_debug_info___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1251
+ *         def __get__(self):
+ *             if UVLOOP_DEBUG:
+ *                 return lambda: self._print_debug_info()             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise AttributeError('print_debug_info')
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_16print_debug_info_7__get___lambda(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyMethodDef __pyx_mdef_6uvloop_4loop_4Loop_16print_debug_info_7__get___lambda = {"lambda", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_16print_debug_info_7__get___lambda, METH_NOARGS, 0};
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_16print_debug_info_7__get___lambda(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("lambda (wrapper)", 0);
+  __pyx_r = __pyx_lambda_funcdef_lambda(__pyx_self);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *__pyx_cur_scope;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *__pyx_outer_scope;
+  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("lambda", 0);
+  __pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *) __Pyx_CyFunction_GetClosure(__pyx_self);
+  __pyx_cur_scope = __pyx_outer_scope;
+  __Pyx_XDECREF(__pyx_r);
+  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 1251, __pyx_L1_error) }
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_print_debug_info(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1251, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop.print_debug_info.__get__.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1249
+ * 
+ *     property print_debug_info:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 return lambda: self._print_debug_info()
+ */
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_16print_debug_info___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *__pyx_cur_scope;
+  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__", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_2___get__(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_2___get__, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 1249, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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);
+
+  /* "uvloop/loop.pyx":1250
+ *     property print_debug_info:
+ *         def __get__(self):
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 return lambda: self._print_debug_info()
+ *             else:
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (likely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":1251
+ *         def __get__(self):
+ *             if UVLOOP_DEBUG:
+ *                 return lambda: self._print_debug_info()             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise AttributeError('print_debug_info')
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_4Loop_16print_debug_info_7__get___lambda, 0, __pyx_n_s_Loop___get___locals_lambda, ((PyObject*)__pyx_cur_scope), __pyx_n_s_uvloop_loop, __pyx_d, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1251, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_r = __pyx_t_2;
+    __pyx_t_2 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":1250
+ *     property print_debug_info:
+ *         def __get__(self):
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 return lambda: self._print_debug_info()
+ *             else:
+ */
+  }
+
+  /* "uvloop/loop.pyx":1253
+ *                 return lambda: self._print_debug_info()
+ *             else:
+ *                 raise AttributeError('print_debug_info')             # <<<<<<<<<<<<<<
+ * 
+ *     # Public API
+ */
+  /*else*/ {
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1253, __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(0, 1253, __pyx_L1_error)
+  }
+
+  /* "uvloop/loop.pyx":1249
+ * 
+ *     property print_debug_info:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 return lambda: self._print_debug_info()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop.print_debug_info.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1257
+ *     # Public API
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return '<{}.{} running={} closed={} debug={}>'.format(
+ *             self.__class__.__module__,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_11__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_11__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_10__repr__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_10__repr__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_t_10;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "uvloop/loop.pyx":1258
+ * 
+ *     def __repr__(self):
+ *         return '<{}.{} running={} closed={} debug={}>'.format(             # <<<<<<<<<<<<<<
+ *             self.__class__.__module__,
+ *             self.__class__.__name__,
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_running_closed_debug, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1258, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/loop.pyx":1259
+ *     def __repr__(self):
+ *         return '<{}.{} running={} closed={} debug={}>'.format(
+ *             self.__class__.__module__,             # <<<<<<<<<<<<<<
+ *             self.__class__.__name__,
+ *             self.is_running(),
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_module); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1260
+ *         return '<{}.{} running={} closed={} debug={}>'.format(
+ *             self.__class__.__module__,
+ *             self.__class__.__name__,             # <<<<<<<<<<<<<<
+ *             self.is_running(),
+ *             self.is_closed(),
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1261
+ *             self.__class__.__module__,
+ *             self.__class__.__name__,
+ *             self.is_running(),             # <<<<<<<<<<<<<<
+ *             self.is_closed(),
+ *             self.get_debug()
+ */
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_is_running); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1261, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1261, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1262
+ *             self.__class__.__name__,
+ *             self.is_running(),
+ *             self.is_closed(),             # <<<<<<<<<<<<<<
+ *             self.get_debug()
+ *         )
+ */
+  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_is_closed); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1262, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+    if (likely(__pyx_t_8)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_8);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_7, function);
+    }
+  }
+  __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1262, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":1263
+ *             self.is_running(),
+ *             self.is_closed(),
+ *             self.get_debug()             # <<<<<<<<<<<<<<
+ *         )
+ * 
+ */
+  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_debug); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1263, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_9 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+    if (likely(__pyx_t_9)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_9);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_8, function);
+    }
+  }
+  __pyx_t_7 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+  if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1263, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __pyx_t_8 = NULL;
+  __pyx_t_10 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_8)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_8);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_10 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[6] = {__pyx_t_8, __pyx_t_4, __pyx_t_5, __pyx_t_3, __pyx_t_6, __pyx_t_7};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 5+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1258, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[6] = {__pyx_t_8, __pyx_t_4, __pyx_t_5, __pyx_t_3, __pyx_t_6, __pyx_t_7};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 5+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1258, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_9 = PyTuple_New(5+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1258, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    if (__pyx_t_8) {
+      __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_10, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_10, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_10, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_10, __pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_7);
+    PyTuple_SET_ITEM(__pyx_t_9, 4+__pyx_t_10, __pyx_t_7);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_3 = 0;
+    __pyx_t_6 = 0;
+    __pyx_t_7 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1258, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1257
+ *     # Public API
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return '<{}.{} running={} closed={} debug={}>'.format(
+ *             self.__class__.__module__,
+ */
+
+  /* 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_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.Loop.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1266
+ *         )
+ * 
+ *     def call_soon(self, callback, *args, context=None):             # <<<<<<<<<<<<<<
+ *         """Arrange for a callback to be called as soon as possible.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_13call_soon(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_12call_soon[] = "Loop.call_soon(self, callback, *args, context=None)\nArrange for a callback to be called as soon as possible.\n\n        This operates as a FIFO queue: callbacks are called in the\n        order in which they are registered.  Each callback will be\n        called exactly once.\n\n        Any positional arguments after the callback will be passed to\n        the callback when it is called.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_13call_soon(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_callback = 0;
+  PyObject *__pyx_v_context = 0;
+  PyObject *__pyx_v_args = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("call_soon (wrapper)", 0);
+  if (PyTuple_GET_SIZE(__pyx_args) > 1) {
+    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args));
+    if (unlikely(!__pyx_v_args)) {
+      __Pyx_RefNannyFinishContext();
+      return NULL;
+    }
+    __Pyx_GOTREF(__pyx_v_args);
+  } else {
+    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
+  }
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_context,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        default:
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (kw_args == 1) {
+        const Py_ssize_t index = 1;
+        PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+        if (value) { values[index] = value; kw_args--; }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "call_soon") < 0)) __PYX_ERR(0, 1266, __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_callback = values[0];
+    __pyx_v_context = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("call_soon", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1266, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
+  __Pyx_AddTraceback("uvloop.loop.Loop.call_soon", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_12call_soon(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_callback, __pyx_v_context, __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12call_soon(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_args) {
+  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("call_soon", 0);
+
+  /* "uvloop/loop.pyx":1276
+ *         the callback when it is called.
+ *         """
+ *         if self._debug == 1:             # <<<<<<<<<<<<<<
+ *             self._check_thread()
+ *         if args:
+ */
+  __pyx_t_1 = ((__pyx_v_self->_debug == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1277
+ *         """
+ *         if self._debug == 1:
+ *             self._check_thread()             # <<<<<<<<<<<<<<
+ *         if args:
+ *             return self._call_soon(callback, args, context)
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__check_thread(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1277, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":1276
+ *         the callback when it is called.
+ *         """
+ *         if self._debug == 1:             # <<<<<<<<<<<<<<
+ *             self._check_thread()
+ *         if args:
+ */
+  }
+
+  /* "uvloop/loop.pyx":1278
+ *         if self._debug == 1:
+ *             self._check_thread()
+ *         if args:             # <<<<<<<<<<<<<<
+ *             return self._call_soon(callback, args, context)
+ *         else:
+ */
+  __pyx_t_1 = (PyTuple_GET_SIZE(__pyx_v_args) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1279
+ *             self._check_thread()
+ *         if args:
+ *             return self._call_soon(callback, args, context)             # <<<<<<<<<<<<<<
+ *         else:
+ *             return self._call_soon(callback, None, context)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__call_soon(__pyx_v_self, __pyx_v_callback, __pyx_v_args, __pyx_v_context); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1279, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_r = __pyx_t_2;
+    __pyx_t_2 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":1278
+ *         if self._debug == 1:
+ *             self._check_thread()
+ *         if args:             # <<<<<<<<<<<<<<
+ *             return self._call_soon(callback, args, context)
+ *         else:
+ */
+  }
+
+  /* "uvloop/loop.pyx":1281
+ *             return self._call_soon(callback, args, context)
+ *         else:
+ *             return self._call_soon(callback, None, context)             # <<<<<<<<<<<<<<
+ * 
+ *     def call_soon_threadsafe(self, callback, *args, context=None):
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__call_soon(__pyx_v_self, __pyx_v_callback, Py_None, __pyx_v_context); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1281, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_r = __pyx_t_2;
+    __pyx_t_2 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "uvloop/loop.pyx":1266
+ *         )
+ * 
+ *     def call_soon(self, callback, *args, context=None):             # <<<<<<<<<<<<<<
+ *         """Arrange for a callback to be called as soon as possible.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop.call_soon", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1283
+ *             return self._call_soon(callback, None, context)
+ * 
+ *     def call_soon_threadsafe(self, callback, *args, context=None):             # <<<<<<<<<<<<<<
+ *         """Like call_soon(), but thread-safe."""
+ *         if not args:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_15call_soon_threadsafe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_14call_soon_threadsafe[] = "Loop.call_soon_threadsafe(self, callback, *args, context=None)\nLike call_soon(), but thread-safe.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_15call_soon_threadsafe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_callback = 0;
+  PyObject *__pyx_v_context = 0;
+  PyObject *__pyx_v_args = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("call_soon_threadsafe (wrapper)", 0);
+  if (PyTuple_GET_SIZE(__pyx_args) > 1) {
+    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args));
+    if (unlikely(!__pyx_v_args)) {
+      __Pyx_RefNannyFinishContext();
+      return NULL;
+    }
+    __Pyx_GOTREF(__pyx_v_args);
+  } else {
+    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
+  }
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_context,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        default:
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (kw_args == 1) {
+        const Py_ssize_t index = 1;
+        PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+        if (value) { values[index] = value; kw_args--; }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "call_soon_threadsafe") < 0)) __PYX_ERR(0, 1283, __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_callback = values[0];
+    __pyx_v_context = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("call_soon_threadsafe", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1283, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
+  __Pyx_AddTraceback("uvloop.loop.Loop.call_soon_threadsafe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_14call_soon_threadsafe(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_callback, __pyx_v_context, __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_14call_soon_threadsafe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_args) {
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("call_soon_threadsafe", 0);
+  __Pyx_INCREF(__pyx_v_args);
+
+  /* "uvloop/loop.pyx":1285
+ *     def call_soon_threadsafe(self, callback, *args, context=None):
+ *         """Like call_soon(), but thread-safe."""
+ *         if not args:             # <<<<<<<<<<<<<<
+ *             args = None
+ *         cdef Handle handle = new_Handle(self, callback, args, context)
+ */
+  __pyx_t_1 = (PyTuple_GET_SIZE(__pyx_v_args) != 0);
+  __pyx_t_2 = ((!__pyx_t_1) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1286
+ *         """Like call_soon(), but thread-safe."""
+ *         if not args:
+ *             args = None             # <<<<<<<<<<<<<<
+ *         cdef Handle handle = new_Handle(self, callback, args, context)
+ *         self._append_ready_handle(handle)  # deque append is atomic
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_DECREF_SET(__pyx_v_args, ((PyObject*)Py_None));
+
+    /* "uvloop/loop.pyx":1285
+ *     def call_soon_threadsafe(self, callback, *args, context=None):
+ *         """Like call_soon(), but thread-safe."""
+ *         if not args:             # <<<<<<<<<<<<<<
+ *             args = None
+ *         cdef Handle handle = new_Handle(self, callback, args, context)
+ */
+  }
+
+  /* "uvloop/loop.pyx":1287
+ *         if not args:
+ *             args = None
+ *         cdef Handle handle = new_Handle(self, callback, args, context)             # <<<<<<<<<<<<<<
+ *         self._append_ready_handle(handle)  # deque append is atomic
+ *         # libuv async handler is thread-safe while the idle handler is not -
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_new_Handle(__pyx_v_self, __pyx_v_callback, __pyx_v_args, __pyx_v_context); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1287, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 1287, __pyx_L1_error)
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1288
+ *             args = None
+ *         cdef Handle handle = new_Handle(self, callback, args, context)
+ *         self._append_ready_handle(handle)  # deque append is atomic             # <<<<<<<<<<<<<<
+ *         # libuv async handler is thread-safe while the idle handler is not -
+ *         # we only set the async handler here, which will start the idle handler
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__append_ready_handle(__pyx_v_self, __pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1288, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1292
+ *         # we only set the async handler here, which will start the idle handler
+ *         # in _on_wake() from the loop and eventually call the callback.
+ *         self.handler_async.send()             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->handler_async->__pyx_base.__pyx_vtab)->send(__pyx_v_self->handler_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1292, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1293
+ *         # in _on_wake() from the loop and eventually call the callback.
+ *         self.handler_async.send()
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ *     def call_later(self, delay, callback, *args, context=None):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = ((PyObject *)__pyx_v_handle);
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1283
+ *             return self._call_soon(callback, None, context)
+ * 
+ *     def call_soon_threadsafe(self, callback, *args, context=None):             # <<<<<<<<<<<<<<
+ *         """Like call_soon(), but thread-safe."""
+ *         if not args:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.Loop.call_soon_threadsafe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1295
+ *         return handle
+ * 
+ *     def call_later(self, delay, callback, *args, context=None):             # <<<<<<<<<<<<<<
+ *         """Arrange for a callback to be called at a given time.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_17call_later(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_16call_later[] = "Loop.call_later(self, delay, callback, *args, context=None)\nArrange for a callback to be called at a given time.\n\n        Return a Handle: an opaque object with a cancel() method that\n        can be used to cancel the call.\n\n        The delay can be an int or float, expressed in seconds.  It is\n        always relative to the current time.\n\n        Each callback will be called exactly once.  If two callbacks\n        are scheduled for exactly the same time, it undefined which\n        will be called first.\n\n        Any positional arguments after the callback will be passed to\n        the callback when it is called.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_17call_later(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_delay = 0;
+  PyObject *__pyx_v_callback = 0;
+  PyObject *__pyx_v_context = 0;
+  PyObject *__pyx_v_args = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("call_later (wrapper)", 0);
+  if (PyTuple_GET_SIZE(__pyx_args) > 2) {
+    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
+    if (unlikely(!__pyx_v_args)) {
+      __Pyx_RefNannyFinishContext();
+      return NULL;
+    }
+    __Pyx_GOTREF(__pyx_v_args);
+  } else {
+    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
+  }
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delay,&__pyx_n_s_callback,&__pyx_n_s_context,0};
+    PyObject* values[3] = {0,0,0};
+    values[2] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        default:
+        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;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delay)) != 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_callback)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("call_later", 0, 2, 2, 1); __PYX_ERR(0, 1295, __pyx_L3_error)
+        }
+      }
+      if (kw_args == 1) {
+        const Py_ssize_t index = 2;
+        PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+        if (value) { values[index] = value; kw_args--; }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "call_later") < 0)) __PYX_ERR(0, 1295, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_delay = values[0];
+    __pyx_v_callback = values[1];
+    __pyx_v_context = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("call_later", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1295, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
+  __Pyx_AddTraceback("uvloop.loop.Loop.call_later", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_16call_later(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_delay, __pyx_v_callback, __pyx_v_context, __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_16call_later(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_delay, PyObject *__pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_args) {
+  uint64_t __pyx_v_when;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  uint64_t __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("call_later", 0);
+  __Pyx_INCREF(__pyx_v_delay);
+  __Pyx_INCREF(__pyx_v_args);
+
+  /* "uvloop/loop.pyx":1313
+ *         cdef uint64_t when
+ * 
+ *         self._check_closed()             # <<<<<<<<<<<<<<
+ *         if self._debug == 1:
+ *             self._check_thread()
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1313, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":1314
+ * 
+ *         self._check_closed()
+ *         if self._debug == 1:             # <<<<<<<<<<<<<<
+ *             self._check_thread()
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_self->_debug == 1) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1315
+ *         self._check_closed()
+ *         if self._debug == 1:
+ *             self._check_thread()             # <<<<<<<<<<<<<<
+ * 
+ *         if delay < 0:
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_thread(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1315, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":1314
+ * 
+ *         self._check_closed()
+ *         if self._debug == 1:             # <<<<<<<<<<<<<<
+ *             self._check_thread()
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":1317
+ *             self._check_thread()
+ * 
+ *         if delay < 0:             # <<<<<<<<<<<<<<
+ *             delay = 0
+ *         elif delay == py_inf or delay > MAX_SLEEP:
+ */
+  __pyx_t_1 = PyObject_RichCompare(__pyx_v_delay, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1317, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1317, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1318
+ * 
+ *         if delay < 0:
+ *             delay = 0             # <<<<<<<<<<<<<<
+ *         elif delay == py_inf or delay > MAX_SLEEP:
+ *             # ~100 years sounds like a good approximation of
+ */
+    __Pyx_INCREF(__pyx_int_0);
+    __Pyx_DECREF_SET(__pyx_v_delay, __pyx_int_0);
+
+    /* "uvloop/loop.pyx":1317
+ *             self._check_thread()
+ * 
+ *         if delay < 0:             # <<<<<<<<<<<<<<
+ *             delay = 0
+ *         elif delay == py_inf or delay > MAX_SLEEP:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/loop.pyx":1319
+ *         if delay < 0:
+ *             delay = 0
+ *         elif delay == py_inf or delay > MAX_SLEEP:             # <<<<<<<<<<<<<<
+ *             # ~100 years sounds like a good approximation of
+ *             # infinity for a Python application.
+ */
+  __pyx_t_1 = PyObject_RichCompare(__pyx_v_delay, __pyx_v_6uvloop_4loop_py_inf, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1319, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1319, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_6uvloop_4loop_MAX_SLEEP); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1319, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = PyObject_RichCompare(__pyx_v_delay, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1319, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1319, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = __pyx_t_3;
+  __pyx_L5_bool_binop_done:;
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1322
+ *             # ~100 years sounds like a good approximation of
+ *             # infinity for a Python application.
+ *             delay = MAX_SLEEP             # <<<<<<<<<<<<<<
+ * 
+ *         when = <uint64_t>round(delay * 1000)
+ */
+    __pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_6uvloop_4loop_MAX_SLEEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1322, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF_SET(__pyx_v_delay, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":1319
+ *         if delay < 0:
+ *             delay = 0
+ *         elif delay == py_inf or delay > MAX_SLEEP:             # <<<<<<<<<<<<<<
+ *             # ~100 years sounds like a good approximation of
+ *             # infinity for a Python application.
+ */
+  }
+  __pyx_L4:;
+
+  /* "uvloop/loop.pyx":1324
+ *             delay = MAX_SLEEP
+ * 
+ *         when = <uint64_t>round(delay * 1000)             # <<<<<<<<<<<<<<
+ *         if not args:
+ *             args = None
+ */
+  __pyx_t_4 = PyNumber_Multiply(__pyx_v_delay, __pyx_int_1000); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1324, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_round, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1324, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_5 = __Pyx_PyInt_As_uint64_t(__pyx_t_1); if (unlikely((__pyx_t_5 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1324, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_when = ((uint64_t)__pyx_t_5);
+
+  /* "uvloop/loop.pyx":1325
+ * 
+ *         when = <uint64_t>round(delay * 1000)
+ *         if not args:             # <<<<<<<<<<<<<<
+ *             args = None
+ *         if when == 0:
+ */
+  __pyx_t_2 = (PyTuple_GET_SIZE(__pyx_v_args) != 0);
+  __pyx_t_3 = ((!__pyx_t_2) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":1326
+ *         when = <uint64_t>round(delay * 1000)
+ *         if not args:
+ *             args = None             # <<<<<<<<<<<<<<
+ *         if when == 0:
+ *             return self._call_soon(callback, args, context)
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_DECREF_SET(__pyx_v_args, ((PyObject*)Py_None));
+
+    /* "uvloop/loop.pyx":1325
+ * 
+ *         when = <uint64_t>round(delay * 1000)
+ *         if not args:             # <<<<<<<<<<<<<<
+ *             args = None
+ *         if when == 0:
+ */
+  }
+
+  /* "uvloop/loop.pyx":1327
+ *         if not args:
+ *             args = None
+ *         if when == 0:             # <<<<<<<<<<<<<<
+ *             return self._call_soon(callback, args, context)
+ *         else:
+ */
+  __pyx_t_3 = ((__pyx_v_when == 0) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":1328
+ *             args = None
+ *         if when == 0:
+ *             return self._call_soon(callback, args, context)             # <<<<<<<<<<<<<<
+ *         else:
+ *             return self._call_later(when, callback, args, context)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__call_soon(__pyx_v_self, __pyx_v_callback, __pyx_v_args, __pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1328, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_r = __pyx_t_1;
+    __pyx_t_1 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":1327
+ *         if not args:
+ *             args = None
+ *         if when == 0:             # <<<<<<<<<<<<<<
+ *             return self._call_soon(callback, args, context)
+ *         else:
+ */
+  }
+
+  /* "uvloop/loop.pyx":1330
+ *             return self._call_soon(callback, args, context)
+ *         else:
+ *             return self._call_later(when, callback, args, context)             # <<<<<<<<<<<<<<
+ * 
+ *     def call_at(self, when, callback, *args, context=None):
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_call_later(__pyx_v_self, __pyx_v_when, __pyx_v_callback, __pyx_v_args, __pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1330, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_r = __pyx_t_1;
+    __pyx_t_1 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "uvloop/loop.pyx":1295
+ *         return handle
+ * 
+ *     def call_later(self, delay, callback, *args, context=None):             # <<<<<<<<<<<<<<
+ *         """Arrange for a callback to be called at a given time.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Loop.call_later", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_delay);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1332
+ *             return self._call_later(when, callback, args, context)
+ * 
+ *     def call_at(self, when, callback, *args, context=None):             # <<<<<<<<<<<<<<
+ *         """Like call_later(), but uses an absolute time.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_19call_at(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_18call_at[] = "Loop.call_at(self, when, callback, *args, context=None)\nLike call_later(), but uses an absolute time.\n\n        Absolute time corresponds to the event loop's time() method.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_19call_at(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_when = 0;
+  PyObject *__pyx_v_callback = 0;
+  PyObject *__pyx_v_context = 0;
+  PyObject *__pyx_v_args = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("call_at (wrapper)", 0);
+  if (PyTuple_GET_SIZE(__pyx_args) > 2) {
+    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
+    if (unlikely(!__pyx_v_args)) {
+      __Pyx_RefNannyFinishContext();
+      return NULL;
+    }
+    __Pyx_GOTREF(__pyx_v_args);
+  } else {
+    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
+  }
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_when,&__pyx_n_s_callback,&__pyx_n_s_context,0};
+    PyObject* values[3] = {0,0,0};
+    values[2] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        default:
+        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;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_when)) != 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_callback)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("call_at", 0, 2, 2, 1); __PYX_ERR(0, 1332, __pyx_L3_error)
+        }
+      }
+      if (kw_args == 1) {
+        const Py_ssize_t index = 2;
+        PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+        if (value) { values[index] = value; kw_args--; }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "call_at") < 0)) __PYX_ERR(0, 1332, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_when = values[0];
+    __pyx_v_callback = values[1];
+    __pyx_v_context = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("call_at", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1332, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
+  __Pyx_AddTraceback("uvloop.loop.Loop.call_at", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_18call_at(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_when, __pyx_v_callback, __pyx_v_context, __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_18call_at(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_when, PyObject *__pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_args) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("call_at", 0);
+
+  /* "uvloop/loop.pyx":1337
+ *         Absolute time corresponds to the event loop's time() method.
+ *         """
+ *         return self.call_later(             # <<<<<<<<<<<<<<
+ *             when - self.time(), callback, *args, context=context)
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call_later); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1337, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+
+  /* "uvloop/loop.pyx":1338
+ *         """
+ *         return self.call_later(
+ *             when - self.time(), callback, *args, context=context)             # <<<<<<<<<<<<<<
+ * 
+ *     def time(self):
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1338, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1338, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyNumber_Subtract(__pyx_v_when, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1338, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1337
+ *         Absolute time corresponds to the event loop's time() method.
+ *         """
+ *         return self.call_later(             # <<<<<<<<<<<<<<
+ *             when - self.time(), callback, *args, context=context)
+ * 
+ */
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1337, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+  __Pyx_INCREF(__pyx_v_callback);
+  __Pyx_GIVEREF(__pyx_v_callback);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_callback);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1338
+ *         """
+ *         return self.call_later(
+ *             when - self.time(), callback, *args, context=context)             # <<<<<<<<<<<<<<
+ * 
+ *     def time(self):
+ */
+  __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1337, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1338, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_context, __pyx_v_context) < 0) __PYX_ERR(0, 1338, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1337
+ *         Absolute time corresponds to the event loop's time() method.
+ *         """
+ *         return self.call_later(             # <<<<<<<<<<<<<<
+ *             when - self.time(), callback, *args, context=context)
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1337, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1332
+ *             return self._call_later(when, callback, args, context)
+ * 
+ *     def call_at(self, when, callback, *args, context=None):             # <<<<<<<<<<<<<<
+ *         """Like call_later(), but uses an absolute time.
+ * 
+ */
+
+  /* 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_AddTraceback("uvloop.loop.Loop.call_at", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1340
+ *             when - self.time(), callback, *args, context=context)
+ * 
+ *     def time(self):             # <<<<<<<<<<<<<<
+ *         """Return the time according to the event loop's clock.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21time(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_20time[] = "Loop.time(self)\nReturn the time according to the event loop's clock.\n\n        This is a float expressed in seconds since an epoch, but the\n        epoch, precision, accuracy and drift are unspecified and may\n        differ per event loop.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21time(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("time (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_20time(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_20time(struct __pyx_obj_6uvloop_4loop_Loop *__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("time", 0);
+
+  /* "uvloop/loop.pyx":1347
+ *         differ per event loop.
+ *         """
+ *         return self._time() / 1000             # <<<<<<<<<<<<<<
+ * 
+ *     def stop(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble((((double)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_time(__pyx_v_self)) / 1000.0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1347, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1340
+ *             when - self.time(), callback, *args, context=context)
+ * 
+ *     def time(self):             # <<<<<<<<<<<<<<
+ *         """Return the time according to the event loop's clock.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop.time", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1349
+ *         return self._time() / 1000
+ * 
+ *     def stop(self):             # <<<<<<<<<<<<<<
+ *         """Stop running the event loop.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_22stop[] = "Loop.stop(self)\nStop running the event loop.\n\n        Every callback already scheduled will still run.  This simply informs\n        run_forever to stop looping after a complete iteration.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stop (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_22stop(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22stop(struct __pyx_obj_6uvloop_4loop_Loop *__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("stop", 0);
+
+  /* "uvloop/loop.pyx":1356
+ *         """
+ *         self._call_soon_handle(
+ *             new_MethodHandle1(             # <<<<<<<<<<<<<<
+ *                 self,
+ *                 "Loop._stop",
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_new_MethodHandle1(__pyx_v_self, __pyx_kp_u_Loop__stop, ((__pyx_t_6uvloop_4loop_method1_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_stop), Py_None, ((PyObject *)__pyx_v_self), Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1356, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 1356, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1355
+ *         run_forever to stop looping after a complete iteration.
+ *         """
+ *         self._call_soon_handle(             # <<<<<<<<<<<<<<
+ *             new_MethodHandle1(
+ *                 self,
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_self, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1355, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":1349
+ *         return self._time() / 1000
+ * 
+ *     def stop(self):             # <<<<<<<<<<<<<<
+ *         """Stop running the event loop.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop.stop", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1364
+ *                 None))
+ * 
+ *     def run_forever(self):             # <<<<<<<<<<<<<<
+ *         """Run the event loop until stop() is called."""
+ *         self._check_closed()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_25run_forever(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_24run_forever[] = "Loop.run_forever(self)\nRun the event loop until stop() is called.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_25run_forever(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("run_forever (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_24run_forever(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24run_forever(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  uv_run_mode __pyx_v_mode;
+  PyObject *__pyx_v_old_agen_hooks = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  char const *__pyx_t_7;
+  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;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("run_forever", 0);
+
+  /* "uvloop/loop.pyx":1366
+ *     def run_forever(self):
+ *         """Run the event loop until stop() is called."""
+ *         self._check_closed()             # <<<<<<<<<<<<<<
+ *         mode = uv.UV_RUN_DEFAULT
+ *         if self._stopping:
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1366, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":1367
+ *         """Run the event loop until stop() is called."""
+ *         self._check_closed()
+ *         mode = uv.UV_RUN_DEFAULT             # <<<<<<<<<<<<<<
+ *         if self._stopping:
+ *             # loop.stop() was called right before loop.run_forever().
+ */
+  __pyx_v_mode = UV_RUN_DEFAULT;
+
+  /* "uvloop/loop.pyx":1368
+ *         self._check_closed()
+ *         mode = uv.UV_RUN_DEFAULT
+ *         if self._stopping:             # <<<<<<<<<<<<<<
+ *             # loop.stop() was called right before loop.run_forever().
+ *             # This is how asyncio loop behaves.
+ */
+  __pyx_t_2 = (__pyx_v_self->_stopping != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1371
+ *             # loop.stop() was called right before loop.run_forever().
+ *             # This is how asyncio loop behaves.
+ *             mode = uv.UV_RUN_NOWAIT             # <<<<<<<<<<<<<<
+ *         self._set_coroutine_debug(self._debug)
+ *         old_agen_hooks = sys.get_asyncgen_hooks()
+ */
+    __pyx_v_mode = UV_RUN_NOWAIT;
+
+    /* "uvloop/loop.pyx":1368
+ *         self._check_closed()
+ *         mode = uv.UV_RUN_DEFAULT
+ *         if self._stopping:             # <<<<<<<<<<<<<<
+ *             # loop.stop() was called right before loop.run_forever().
+ *             # This is how asyncio loop behaves.
+ */
+  }
+
+  /* "uvloop/loop.pyx":1372
+ *             # This is how asyncio loop behaves.
+ *             mode = uv.UV_RUN_NOWAIT
+ *         self._set_coroutine_debug(self._debug)             # <<<<<<<<<<<<<<
+ *         old_agen_hooks = sys.get_asyncgen_hooks()
+ *         sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_set_coroutine_debug(__pyx_v_self, __pyx_v_self->_debug); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1372, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":1373
+ *             mode = uv.UV_RUN_NOWAIT
+ *         self._set_coroutine_debug(self._debug)
+ *         old_agen_hooks = sys.get_asyncgen_hooks()             # <<<<<<<<<<<<<<
+ *         sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
+ *                                finalizer=self._asyncgen_finalizer_hook)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_sys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1373, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_get_asyncgen_hooks); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1373, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1373, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_old_agen_hooks = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":1374
+ *         self._set_coroutine_debug(self._debug)
+ *         old_agen_hooks = sys.get_asyncgen_hooks()
+ *         sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,             # <<<<<<<<<<<<<<
+ *                                finalizer=self._asyncgen_finalizer_hook)
+ *         try:
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1374, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_set_asyncgen_hooks); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1374, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1374, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_asyncgen_firstiter_hook); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1374, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_firstiter, __pyx_t_3) < 0) __PYX_ERR(0, 1374, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1375
+ *         old_agen_hooks = sys.get_asyncgen_hooks()
+ *         sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
+ *                                finalizer=self._asyncgen_finalizer_hook)             # <<<<<<<<<<<<<<
+ *         try:
+ *             self._run(mode)
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_asyncgen_finalizer_hook); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1375, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_finalizer, __pyx_t_3) < 0) __PYX_ERR(0, 1374, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1374
+ *         self._set_coroutine_debug(self._debug)
+ *         old_agen_hooks = sys.get_asyncgen_hooks()
+ *         sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,             # <<<<<<<<<<<<<<
+ *                                finalizer=self._asyncgen_finalizer_hook)
+ *         try:
+ */
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1374, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":1376
+ *         sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
+ *                                finalizer=self._asyncgen_finalizer_hook)
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._run(mode)
+ *         finally:
+ */
+  /*try:*/ {
+
+    /* "uvloop/loop.pyx":1377
+ *                                finalizer=self._asyncgen_finalizer_hook)
+ *         try:
+ *             self._run(mode)             # <<<<<<<<<<<<<<
+ *         finally:
+ *             self._set_coroutine_debug(False)
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_run(__pyx_v_self, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1377, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+
+  /* "uvloop/loop.pyx":1379
+ *             self._run(mode)
+ *         finally:
+ *             self._set_coroutine_debug(False)             # <<<<<<<<<<<<<<
+ *             sys.set_asyncgen_hooks(*old_agen_hooks)
+ * 
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_set_coroutine_debug(__pyx_v_self, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1379, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":1380
+ *         finally:
+ *             self._set_coroutine_debug(False)
+ *             sys.set_asyncgen_hooks(*old_agen_hooks)             # <<<<<<<<<<<<<<
+ * 
+ *     def close(self):
+ */
+      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_sys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1380, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_set_asyncgen_hooks); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1380, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_v_old_agen_hooks); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1380, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1380, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __pyx_t_5 = __pyx_lineno; __pyx_t_6 = __pyx_clineno; __pyx_t_7 = __pyx_filename;
+      {
+
+        /* "uvloop/loop.pyx":1379
+ *             self._run(mode)
+ *         finally:
+ *             self._set_coroutine_debug(False)             # <<<<<<<<<<<<<<
+ *             sys.set_asyncgen_hooks(*old_agen_hooks)
+ * 
+ */
+        __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_set_coroutine_debug(__pyx_v_self, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1379, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/loop.pyx":1380
+ *         finally:
+ *             self._set_coroutine_debug(False)
+ *             sys.set_asyncgen_hooks(*old_agen_hooks)             # <<<<<<<<<<<<<<
+ * 
+ *     def close(self):
+ */
+        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_sys); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1380, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_set_asyncgen_hooks); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1380, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_old_agen_hooks); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1380, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1380, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+      }
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_ErrRestore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      __pyx_lineno = __pyx_t_5; __pyx_clineno = __pyx_t_6; __pyx_filename = __pyx_t_7;
+      goto __pyx_L1_error;
+      __pyx_L8_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+      }
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/loop.pyx":1364
+ *                 None))
+ * 
+ *     def run_forever(self):             # <<<<<<<<<<<<<<
+ *         """Run the event loop until stop() is called."""
+ *         self._check_closed()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Loop.run_forever", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_old_agen_hooks);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1382
+ *             sys.set_asyncgen_hooks(*old_agen_hooks)
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         """Close the event loop.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_26close[] = "Loop.close(self)\nClose the event loop.\n\n        The event loop must not be running.\n\n        This is idempotent and irreversible.\n\n        No other methods should be called after this one.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("close (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_26close(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_26close(struct __pyx_obj_6uvloop_4loop_Loop *__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("close", 0);
+
+  /* "uvloop/loop.pyx":1391
+ *         No other methods should be called after this one.
+ *         """
+ *         self._close()             # <<<<<<<<<<<<<<
+ * 
+ *     def get_debug(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_close(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1391, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":1382
+ *             sys.set_asyncgen_hooks(*old_agen_hooks)
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         """Close the event loop.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop.close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1393
+ *         self._close()
+ * 
+ *     def get_debug(self):             # <<<<<<<<<<<<<<
+ *         return bool(self._debug)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29get_debug(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_28get_debug[] = "Loop.get_debug(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29get_debug(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_debug (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_28get_debug(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28get_debug(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  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_debug", 0);
+
+  /* "uvloop/loop.pyx":1394
+ * 
+ *     def get_debug(self):
+ *         return bool(self._debug)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_debug(self, enabled):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_v_self->_debug;
+  __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1393
+ *         self._close()
+ * 
+ *     def get_debug(self):             # <<<<<<<<<<<<<<
+ *         return bool(self._debug)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop.get_debug", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1396
+ *         return bool(self._debug)
+ * 
+ *     def set_debug(self, enabled):             # <<<<<<<<<<<<<<
+ *         self._debug = bool(enabled)
+ *         if self.is_running():
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_31set_debug(PyObject *__pyx_v_self, PyObject *__pyx_v_enabled); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_30set_debug[] = "Loop.set_debug(self, enabled)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_31set_debug(PyObject *__pyx_v_self, PyObject *__pyx_v_enabled) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_debug (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_30set_debug(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_enabled));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_30set_debug(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_enabled) {
+  PyObject *__pyx_r = NULL;
+  __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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_debug", 0);
+
+  /* "uvloop/loop.pyx":1397
+ * 
+ *     def set_debug(self, enabled):
+ *         self._debug = bool(enabled)             # <<<<<<<<<<<<<<
+ *         if self.is_running():
+ *             self.call_soon_threadsafe(
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_enabled); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1397, __pyx_L1_error)
+  __pyx_v_self->_debug = (!(!__pyx_t_1));
+
+  /* "uvloop/loop.pyx":1398
+ *     def set_debug(self, enabled):
+ *         self._debug = bool(enabled)
+ *         if self.is_running():             # <<<<<<<<<<<<<<
+ *             self.call_soon_threadsafe(
+ *                 self._set_coroutine_debug, self, self._debug)
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_is_running); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1398, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1398, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1398, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1399
+ *         self._debug = bool(enabled)
+ *         if self.is_running():
+ *             self.call_soon_threadsafe(             # <<<<<<<<<<<<<<
+ *                 self._set_coroutine_debug, self, self._debug)
+ * 
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call_soon_threadsafe); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1399, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/loop.pyx":1400
+ *         if self.is_running():
+ *             self.call_soon_threadsafe(
+ *                 self._set_coroutine_debug, self, self._debug)             # <<<<<<<<<<<<<<
+ * 
+ *     def is_running(self):
+ */
+    __pyx_t_4 = __Pyx_CFunc_object____Loop____bint___to_py(((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_set_coroutine_debug); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1400, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = __Pyx_PyBool_FromLong(__pyx_v_self->_debug); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1400, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = NULL;
+    __pyx_t_7 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(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_7 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_t_4, ((PyObject *)__pyx_v_self), __pyx_t_5};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1399, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_t_4, ((PyObject *)__pyx_v_self), __pyx_t_5};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1399, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __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, 1399, __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_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_4);
+      __Pyx_INCREF(((PyObject *)__pyx_v_self));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+      PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, ((PyObject *)__pyx_v_self));
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_t_5);
+      __pyx_t_4 = 0;
+      __pyx_t_5 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1399, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":1398
+ *     def set_debug(self, enabled):
+ *         self._debug = bool(enabled)
+ *         if self.is_running():             # <<<<<<<<<<<<<<
+ *             self.call_soon_threadsafe(
+ *                 self._set_coroutine_debug, self, self._debug)
+ */
+  }
+
+  /* "uvloop/loop.pyx":1396
+ *         return bool(self._debug)
+ * 
+ *     def set_debug(self, enabled):             # <<<<<<<<<<<<<<
+ *         self._debug = bool(enabled)
+ *         if self.is_running():
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __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_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.Loop.set_debug", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1402
+ *                 self._set_coroutine_debug, self, self._debug)
+ * 
+ *     def is_running(self):             # <<<<<<<<<<<<<<
+ *         """Return whether the event loop is currently running."""
+ *         return bool(self._running)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_33is_running(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_32is_running[] = "Loop.is_running(self)\nReturn whether the event loop is currently running.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_33is_running(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_running (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_32is_running(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_32is_running(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  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("is_running", 0);
+
+  /* "uvloop/loop.pyx":1404
+ *     def is_running(self):
+ *         """Return whether the event loop is currently running."""
+ *         return bool(self._running)             # <<<<<<<<<<<<<<
+ * 
+ *     def is_closed(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_v_self->_running;
+  __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1404, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1402
+ *                 self._set_coroutine_debug, self, self._debug)
+ * 
+ *     def is_running(self):             # <<<<<<<<<<<<<<
+ *         """Return whether the event loop is currently running."""
+ *         return bool(self._running)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop.is_running", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1406
+ *         return bool(self._running)
+ * 
+ *     def is_closed(self):             # <<<<<<<<<<<<<<
+ *         """Returns True if the event loop was closed."""
+ *         return bool(self._closed)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35is_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_34is_closed[] = "Loop.is_closed(self)\nReturns True if the event loop was closed.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35is_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_closed (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_34is_closed(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_34is_closed(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  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("is_closed", 0);
+
+  /* "uvloop/loop.pyx":1408
+ *     def is_closed(self):
+ *         """Returns True if the event loop was closed."""
+ *         return bool(self._closed)             # <<<<<<<<<<<<<<
+ * 
+ *     def create_future(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_v_self->_closed;
+  __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1408, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1406
+ *         return bool(self._running)
+ * 
+ *     def is_closed(self):             # <<<<<<<<<<<<<<
+ *         """Returns True if the event loop was closed."""
+ *         return bool(self._closed)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop.is_closed", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1410
+ *         return bool(self._closed)
+ * 
+ *     def create_future(self):             # <<<<<<<<<<<<<<
+ *         """Create a Future object attached to the loop."""
+ *         return self._new_future()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_37create_future(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_36create_future[] = "Loop.create_future(self)\nCreate a Future object attached to the loop.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_37create_future(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_future (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_36create_future(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_36create_future(struct __pyx_obj_6uvloop_4loop_Loop *__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("create_future", 0);
+
+  /* "uvloop/loop.pyx":1412
+ *     def create_future(self):
+ *         """Create a Future object attached to the loop."""
+ *         return self._new_future()             # <<<<<<<<<<<<<<
+ * 
+ *     def create_task(self, coro, *, name=None):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1412, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1410
+ *         return bool(self._closed)
+ * 
+ *     def create_future(self):             # <<<<<<<<<<<<<<
+ *         """Create a Future object attached to the loop."""
+ *         return self._new_future()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_future", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1414
+ *         return self._new_future()
+ * 
+ *     def create_task(self, coro, *, name=None):             # <<<<<<<<<<<<<<
+ *         """Schedule a coroutine object.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_39create_task(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_38create_task[] = "Loop.create_task(self, coro, *, name=None)\nSchedule a coroutine object.\n\n        Return a task object.\n\n        If name is not None, task.set_name(name) will be called if the task\n        object has the set_name attribute, true for default Task in Python 3.8.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_39create_task(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_coro = 0;
+  PyObject *__pyx_v_name = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_task (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_coro,&__pyx_n_s_name_2,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)Py_None);
+    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_coro)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (kw_args == 1) {
+        const Py_ssize_t index = 1;
+        PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+        if (value) { values[index] = value; kw_args--; }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_task") < 0)) __PYX_ERR(0, 1414, __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_coro = values[0];
+    __pyx_v_name = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("create_task", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1414, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_task", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_38create_task(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_coro, __pyx_v_name);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_38create_task(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_coro, PyObject *__pyx_v_name) {
+  PyObject *__pyx_v_task = NULL;
+  PyObject *__pyx_v_set_name = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  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;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("create_task", 0);
+
+  /* "uvloop/loop.pyx":1422
+ *         object has the set_name attribute, true for default Task in Python 3.8.
+ *         """
+ *         self._check_closed()             # <<<<<<<<<<<<<<
+ *         if self._task_factory is None:
+ *             task = aio_Task(coro, loop=self)
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":1423
+ *         """
+ *         self._check_closed()
+ *         if self._task_factory is None:             # <<<<<<<<<<<<<<
+ *             task = aio_Task(coro, loop=self)
+ *         else:
+ */
+  __pyx_t_2 = (__pyx_v_self->_task_factory == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":1424
+ *         self._check_closed()
+ *         if self._task_factory is None:
+ *             task = aio_Task(coro, loop=self)             # <<<<<<<<<<<<<<
+ *         else:
+ *             task = self._task_factory(self, coro)
+ */
+    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1424, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_v_coro);
+    __Pyx_GIVEREF(__pyx_v_coro);
+    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_coro);
+    __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1424, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_loop, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(0, 1424, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_Task, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1424, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_v_task = __pyx_t_5;
+    __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":1423
+ *         """
+ *         self._check_closed()
+ *         if self._task_factory is None:             # <<<<<<<<<<<<<<
+ *             task = aio_Task(coro, loop=self)
+ *         else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/loop.pyx":1426
+ *             task = aio_Task(coro, loop=self)
+ *         else:
+ *             task = self._task_factory(self, coro)             # <<<<<<<<<<<<<<
+ * 
+ *         # copied from asyncio.tasks._set_task_name (bpo-34270)
+ */
+  /*else*/ {
+    __Pyx_INCREF(__pyx_v_self->_task_factory);
+    __pyx_t_4 = __pyx_v_self->_task_factory; __pyx_t_1 = NULL;
+    __pyx_t_6 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_6 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_1, ((PyObject *)__pyx_v_self), __pyx_v_coro};
+      __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, 1426, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_GOTREF(__pyx_t_5);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_1, ((PyObject *)__pyx_v_self), __pyx_v_coro};
+      __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, 1426, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_GOTREF(__pyx_t_5);
+    } else
+    #endif
+    {
+      __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1426, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      if (__pyx_t_1) {
+        __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __pyx_t_1 = NULL;
+      }
+      __Pyx_INCREF(((PyObject *)__pyx_v_self));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+      PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, ((PyObject *)__pyx_v_self));
+      __Pyx_INCREF(__pyx_v_coro);
+      __Pyx_GIVEREF(__pyx_v_coro);
+      PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_coro);
+      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1426, __pyx_L1_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_v_task = __pyx_t_5;
+    __pyx_t_5 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/loop.pyx":1429
+ * 
+ *         # copied from asyncio.tasks._set_task_name (bpo-34270)
+ *         if name is not None:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 set_name = task.set_name
+ */
+  __pyx_t_3 = (__pyx_v_name != Py_None);
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1430
+ *         # copied from asyncio.tasks._set_task_name (bpo-34270)
+ *         if name is not None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 set_name = task.set_name
+ *             except AttributeError:
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":1431
+ *         if name is not None:
+ *             try:
+ *                 set_name = task.set_name             # <<<<<<<<<<<<<<
+ *             except AttributeError:
+ *                 pass
+ */
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_task, __pyx_n_s_set_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1431, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_v_set_name = __pyx_t_5;
+        __pyx_t_5 = 0;
+
+        /* "uvloop/loop.pyx":1430
+ *         # copied from asyncio.tasks._set_task_name (bpo-34270)
+ *         if name is not None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 set_name = task.set_name
+ *             except AttributeError:
+ */
+      }
+
+      /* "uvloop/loop.pyx":1435
+ *                 pass
+ *             else:
+ *                 set_name(name)             # <<<<<<<<<<<<<<
+ * 
+ *         return task
+ */
+      /*else:*/ {
+        __Pyx_INCREF(__pyx_v_set_name);
+        __pyx_t_4 = __pyx_v_set_name; __pyx_t_7 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+          __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+          if (likely(__pyx_t_7)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+            __Pyx_INCREF(__pyx_t_7);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_4, function);
+          }
+        }
+        __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_7, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_name);
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1435, __pyx_L7_except_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      }
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      goto __pyx_L10_try_end;
+      __pyx_L5_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 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;
+
+      /* "uvloop/loop.pyx":1432
+ *             try:
+ *                 set_name = task.set_name
+ *             except AttributeError:             # <<<<<<<<<<<<<<
+ *                 pass
+ *             else:
+ */
+      __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError);
+      if (__pyx_t_6) {
+        __Pyx_ErrRestore(0,0,0);
+        goto __pyx_L6_exception_handled;
+      }
+      goto __pyx_L7_except_error;
+      __pyx_L7_except_error:;
+
+      /* "uvloop/loop.pyx":1430
+ *         # copied from asyncio.tasks._set_task_name (bpo-34270)
+ *         if name is not None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 set_name = task.set_name
+ *             except AttributeError:
+ */
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      goto __pyx_L1_error;
+      __pyx_L6_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      __pyx_L10_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":1429
+ * 
+ *         # copied from asyncio.tasks._set_task_name (bpo-34270)
+ *         if name is not None:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 set_name = task.set_name
+ */
+  }
+
+  /* "uvloop/loop.pyx":1437
+ *                 set_name(name)
+ * 
+ *         return task             # <<<<<<<<<<<<<<
+ * 
+ *     def set_task_factory(self, factory):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_task);
+  __pyx_r = __pyx_v_task;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1414
+ *         return self._new_future()
+ * 
+ *     def create_task(self, coro, *, name=None):             # <<<<<<<<<<<<<<
+ *         """Schedule a coroutine object.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_task", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_task);
+  __Pyx_XDECREF(__pyx_v_set_name);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1439
+ *         return task
+ * 
+ *     def set_task_factory(self, factory):             # <<<<<<<<<<<<<<
+ *         """Set a task factory that will be used by loop.create_task().
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_41set_task_factory(PyObject *__pyx_v_self, PyObject *__pyx_v_factory); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_40set_task_factory[] = "Loop.set_task_factory(self, factory)\nSet a task factory that will be used by loop.create_task().\n\n        If factory is None the default task factory will be set.\n\n        If factory is a callable, it should have a signature matching\n        '(loop, coro)', where 'loop' will be a reference to the active\n        event loop, 'coro' will be a coroutine object.  The callable\n        must return a Future.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_41set_task_factory(PyObject *__pyx_v_self, PyObject *__pyx_v_factory) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_task_factory (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_40set_task_factory(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_factory));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_40set_task_factory(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_factory) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_task_factory", 0);
+
+  /* "uvloop/loop.pyx":1449
+ *         must return a Future.
+ *         """
+ *         if factory is not None and not callable(factory):             # <<<<<<<<<<<<<<
+ *             raise TypeError('task factory must be a callable or None')
+ *         self._task_factory = factory
+ */
+  __pyx_t_2 = (__pyx_v_factory != 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;
+  }
+  __pyx_t_3 = __Pyx_PyCallable_Check(__pyx_v_factory); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 1449, __pyx_L1_error)
+  __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":1450
+ *         """
+ *         if factory is not None and not callable(factory):
+ *             raise TypeError('task factory must be a callable or None')             # <<<<<<<<<<<<<<
+ *         self._task_factory = factory
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1450, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(0, 1450, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1449
+ *         must return a Future.
+ *         """
+ *         if factory is not None and not callable(factory):             # <<<<<<<<<<<<<<
+ *             raise TypeError('task factory must be a callable or None')
+ *         self._task_factory = factory
+ */
+  }
+
+  /* "uvloop/loop.pyx":1451
+ *         if factory is not None and not callable(factory):
+ *             raise TypeError('task factory must be a callable or None')
+ *         self._task_factory = factory             # <<<<<<<<<<<<<<
+ * 
+ *     def get_task_factory(self):
+ */
+  __Pyx_INCREF(__pyx_v_factory);
+  __Pyx_GIVEREF(__pyx_v_factory);
+  __Pyx_GOTREF(__pyx_v_self->_task_factory);
+  __Pyx_DECREF(__pyx_v_self->_task_factory);
+  __pyx_v_self->_task_factory = __pyx_v_factory;
+
+  /* "uvloop/loop.pyx":1439
+ *         return task
+ * 
+ *     def set_task_factory(self, factory):             # <<<<<<<<<<<<<<
+ *         """Set a task factory that will be used by loop.create_task().
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Loop.set_task_factory", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1453
+ *         self._task_factory = factory
+ * 
+ *     def get_task_factory(self):             # <<<<<<<<<<<<<<
+ *         """Return a task factory, or None if the default one is in use."""
+ *         return self._task_factory
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_43get_task_factory(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_42get_task_factory[] = "Loop.get_task_factory(self)\nReturn a task factory, or None if the default one is in use.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_43get_task_factory(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_task_factory (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_42get_task_factory(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_42get_task_factory(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_task_factory", 0);
+
+  /* "uvloop/loop.pyx":1455
+ *     def get_task_factory(self):
+ *         """Return a task factory, or None if the default one is in use."""
+ *         return self._task_factory             # <<<<<<<<<<<<<<
+ * 
+ *     def run_until_complete(self, future):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_task_factory);
+  __pyx_r = __pyx_v_self->_task_factory;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1453
+ *         self._task_factory = factory
+ * 
+ *     def get_task_factory(self):             # <<<<<<<<<<<<<<
+ *         """Return a task factory, or None if the default one is in use."""
+ *         return self._task_factory
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1457
+ *         return self._task_factory
+ * 
+ *     def run_until_complete(self, future):             # <<<<<<<<<<<<<<
+ *         """Run until the Future is done.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_45run_until_complete(PyObject *__pyx_v_self, PyObject *__pyx_v_future); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_44run_until_complete[] = "Loop.run_until_complete(self, future)\nRun until the Future is done.\n\n        If the argument is a coroutine, it is wrapped in a Task.\n\n        WARNING: It would be disastrous to call run_until_complete()\n        with the same coroutine twice -- it would wrap it in two\n        different Tasks and that can't be good.\n\n        Return the Future's result, or raise its exception.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_45run_until_complete(PyObject *__pyx_v_self, PyObject *__pyx_v_future) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("run_until_complete (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_44run_until_complete(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_future));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1477
+ *             future._log_destroy_pending = False
+ * 
+ *         def done_cb(fut):             # <<<<<<<<<<<<<<
+ *             if not fut.cancelled():
+ *                 exc = fut.exception()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_18run_until_complete_1done_cb(PyObject *__pyx_self, PyObject *__pyx_v_fut); /*proto*/
+static PyMethodDef __pyx_mdef_6uvloop_4loop_4Loop_18run_until_complete_1done_cb = {"done_cb", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_18run_until_complete_1done_cb, METH_O, 0};
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_18run_until_complete_1done_cb(PyObject *__pyx_self, PyObject *__pyx_v_fut) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("done_cb (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_18run_until_complete_done_cb(__pyx_self, ((PyObject *)__pyx_v_fut));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_18run_until_complete_done_cb(PyObject *__pyx_self, PyObject *__pyx_v_fut) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *__pyx_cur_scope;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *__pyx_outer_scope;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  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("done_cb", 0);
+  __pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *) __Pyx_CyFunction_GetClosure(__pyx_self);
+  __pyx_cur_scope = __pyx_outer_scope;
+
+  /* "uvloop/loop.pyx":1478
+ * 
+ *         def done_cb(fut):
+ *             if not fut.cancelled():             # <<<<<<<<<<<<<<
+ *                 exc = fut.exception()
+ *                 if isinstance(exc, (SystemExit, KeyboardInterrupt)):
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1478, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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, 1478, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 1478, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_5 = ((!__pyx_t_4) != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/loop.pyx":1479
+ *         def done_cb(fut):
+ *             if not fut.cancelled():
+ *                 exc = fut.exception()             # <<<<<<<<<<<<<<
+ *                 if isinstance(exc, (SystemExit, KeyboardInterrupt)):
+ *                     # Issue #336: run_forever() already finished,
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_exception); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1479, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_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, 1479, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":1480
+ *             if not fut.cancelled():
+ *                 exc = fut.exception()
+ *                 if isinstance(exc, (SystemExit, KeyboardInterrupt)):             # <<<<<<<<<<<<<<
+ *                     # Issue #336: run_forever() already finished,
+ *                     # no need to stop it.
+ */
+    __pyx_t_4 = PyObject_IsInstance(__pyx_v_exc, __pyx_builtin_SystemExit); 
+    __pyx_t_6 = (__pyx_t_4 != 0);
+    if (!__pyx_t_6) {
+    } else {
+      __pyx_t_5 = __pyx_t_6;
+      goto __pyx_L5_bool_binop_done;
+    }
+    __pyx_t_6 = PyObject_IsInstance(__pyx_v_exc, __pyx_builtin_KeyboardInterrupt); 
+    __pyx_t_4 = (__pyx_t_6 != 0);
+    __pyx_t_5 = __pyx_t_4;
+    __pyx_L5_bool_binop_done:;
+    __pyx_t_4 = (__pyx_t_5 != 0);
+    if (__pyx_t_4) {
+
+      /* "uvloop/loop.pyx":1483
+ *                     # Issue #336: run_forever() already finished,
+ *                     # no need to stop it.
+ *                     return             # <<<<<<<<<<<<<<
+ *             self.stop()
+ * 
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+
+      /* "uvloop/loop.pyx":1480
+ *             if not fut.cancelled():
+ *                 exc = fut.exception()
+ *                 if isinstance(exc, (SystemExit, KeyboardInterrupt)):             # <<<<<<<<<<<<<<
+ *                     # Issue #336: run_forever() already finished,
+ *                     # no need to stop it.
+ */
+    }
+
+    /* "uvloop/loop.pyx":1478
+ * 
+ *         def done_cb(fut):
+ *             if not fut.cancelled():             # <<<<<<<<<<<<<<
+ *                 exc = fut.exception()
+ *                 if isinstance(exc, (SystemExit, KeyboardInterrupt)):
+ */
+  }
+
+  /* "uvloop/loop.pyx":1484
+ *                     # no need to stop it.
+ *                     return
+ *             self.stop()             # <<<<<<<<<<<<<<
+ * 
+ *         future.add_done_callback(done_cb)
+ */
+  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 1484, __pyx_L1_error) }
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_stop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1484, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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, 1484, __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;
+
+  /* "uvloop/loop.pyx":1477
+ *             future._log_destroy_pending = False
+ * 
+ *         def done_cb(fut):             # <<<<<<<<<<<<<<
+ *             if not fut.cancelled():
+ *                 exc = fut.exception()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.Loop.run_until_complete.done_cb", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1457
+ *         return self._task_factory
+ * 
+ *     def run_until_complete(self, future):             # <<<<<<<<<<<<<<
+ *         """Run until the Future is done.
+ * 
+ */
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_44run_until_complete(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_future) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *__pyx_cur_scope;
+  int __pyx_v_new_task;
+  PyObject *__pyx_v_done_cb = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = 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;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_t_13;
+  int __pyx_t_14;
+  char const *__pyx_t_15;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("run_until_complete", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_3_run_until_complete(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_3_run_until_complete, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 1457, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_INCREF(__pyx_v_future);
+
+  /* "uvloop/loop.pyx":1468
+ *         Return the Future's result, or raise its exception.
+ *         """
+ *         self._check_closed()             # <<<<<<<<<<<<<<
+ * 
+ *         new_task = not isfuture(future)
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1468, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":1470
+ *         self._check_closed()
+ * 
+ *         new_task = not isfuture(future)             # <<<<<<<<<<<<<<
+ *         future = aio_ensure_future(future, loop=self)
+ *         if new_task:
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_isfuture(__pyx_v_future); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1470, __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, 1470, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_new_task = (!__pyx_t_2);
+
+  /* "uvloop/loop.pyx":1471
+ * 
+ *         new_task = not isfuture(future)
+ *         future = aio_ensure_future(future, loop=self)             # <<<<<<<<<<<<<<
+ *         if new_task:
+ *             # An exception is raised if the future didn't complete, so there
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1471, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_v_future);
+  __Pyx_GIVEREF(__pyx_v_future);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_future);
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1471, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_loop, ((PyObject *)__pyx_cur_scope->__pyx_v_self)) < 0) __PYX_ERR(0, 1471, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_ensure_future, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1471, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_future, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":1472
+ *         new_task = not isfuture(future)
+ *         future = aio_ensure_future(future, loop=self)
+ *         if new_task:             # <<<<<<<<<<<<<<
+ *             # An exception is raised if the future didn't complete, so there
+ *             # is no need to log the "destroy pending task" message
+ */
+  __pyx_t_2 = (__pyx_v_new_task != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1475
+ *             # An exception is raised if the future didn't complete, so there
+ *             # is no need to log the "destroy pending task" message
+ *             future._log_destroy_pending = False             # <<<<<<<<<<<<<<
+ * 
+ *         def done_cb(fut):
+ */
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_future, __pyx_n_s_log_destroy_pending, Py_False) < 0) __PYX_ERR(0, 1475, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1472
+ *         new_task = not isfuture(future)
+ *         future = aio_ensure_future(future, loop=self)
+ *         if new_task:             # <<<<<<<<<<<<<<
+ *             # An exception is raised if the future didn't complete, so there
+ *             # is no need to log the "destroy pending task" message
+ */
+  }
+
+  /* "uvloop/loop.pyx":1477
+ *             future._log_destroy_pending = False
+ * 
+ *         def done_cb(fut):             # <<<<<<<<<<<<<<
+ *             if not fut.cancelled():
+ *                 exc = fut.exception()
+ */
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_4Loop_18run_until_complete_1done_cb, 0, __pyx_n_s_run_until_complete_locals_done_c, ((PyObject*)__pyx_cur_scope), __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1477, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_v_done_cb = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":1486
+ *             self.stop()
+ * 
+ *         future.add_done_callback(done_cb)             # <<<<<<<<<<<<<<
+ *         try:
+ *             self.run_forever()
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_add_done_callback); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1486, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_done_cb) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_done_cb);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1486, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":1487
+ * 
+ *         future.add_done_callback(done_cb)
+ *         try:             # <<<<<<<<<<<<<<
+ *             self.run_forever()
+ *         except BaseException:
+ */
+  /*try:*/ {
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":1488
+ *         future.add_done_callback(done_cb)
+ *         try:
+ *             self.run_forever()             # <<<<<<<<<<<<<<
+ *         except BaseException:
+ *             if new_task and future.done() and not future.cancelled():
+ */
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_run_forever); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1488, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_1 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+          __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+          if (likely(__pyx_t_1)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+            __Pyx_INCREF(__pyx_t_1);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_3, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1488, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/loop.pyx":1487
+ * 
+ *         future.add_done_callback(done_cb)
+ *         try:             # <<<<<<<<<<<<<<
+ *             self.run_forever()
+ *         except BaseException:
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L12_try_end;
+      __pyx_L7_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":1489
+ *         try:
+ *             self.run_forever()
+ *         except BaseException:             # <<<<<<<<<<<<<<
+ *             if new_task and future.done() and not future.cancelled():
+ *                 # The coroutine raised a BaseException. Consume the exception
+ */
+      __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_8) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.run_until_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_1) < 0) __PYX_ERR(0, 1489, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_1);
+
+        /* "uvloop/loop.pyx":1490
+ *             self.run_forever()
+ *         except BaseException:
+ *             if new_task and future.done() and not future.cancelled():             # <<<<<<<<<<<<<<
+ *                 # The coroutine raised a BaseException. Consume the exception
+ *                 # to not log a warning, the caller doesn't have access to the
+ */
+        __pyx_t_9 = (__pyx_v_new_task != 0);
+        if (__pyx_t_9) {
+        } else {
+          __pyx_t_2 = __pyx_t_9;
+          goto __pyx_L16_bool_binop_done;
+        }
+        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_done); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1490, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __pyx_t_12 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+          __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+          if (likely(__pyx_t_12)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+            __Pyx_INCREF(__pyx_t_12);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_11, function);
+          }
+        }
+        __pyx_t_10 = (__pyx_t_12) ? __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_12) : __Pyx_PyObject_CallNoArg(__pyx_t_11);
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1490, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1490, __pyx_L9_except_error)
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        if (__pyx_t_9) {
+        } else {
+          __pyx_t_2 = __pyx_t_9;
+          goto __pyx_L16_bool_binop_done;
+        }
+        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1490, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __pyx_t_12 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+          __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+          if (likely(__pyx_t_12)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+            __Pyx_INCREF(__pyx_t_12);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_11, function);
+          }
+        }
+        __pyx_t_10 = (__pyx_t_12) ? __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_12) : __Pyx_PyObject_CallNoArg(__pyx_t_11);
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1490, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1490, __pyx_L9_except_error)
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __pyx_t_13 = ((!__pyx_t_9) != 0);
+        __pyx_t_2 = __pyx_t_13;
+        __pyx_L16_bool_binop_done:;
+        if (__pyx_t_2) {
+
+          /* "uvloop/loop.pyx":1494
+ *                 # to not log a warning, the caller doesn't have access to the
+ *                 # local task.
+ *                 future.exception()             # <<<<<<<<<<<<<<
+ *             raise
+ *         finally:
+ */
+          __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_exception); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1494, __pyx_L9_except_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __pyx_t_12 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+            __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+            if (likely(__pyx_t_12)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+              __Pyx_INCREF(__pyx_t_12);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_11, function);
+            }
+          }
+          __pyx_t_10 = (__pyx_t_12) ? __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_12) : __Pyx_PyObject_CallNoArg(__pyx_t_11);
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1494, __pyx_L9_except_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+          /* "uvloop/loop.pyx":1490
+ *             self.run_forever()
+ *         except BaseException:
+ *             if new_task and future.done() and not future.cancelled():             # <<<<<<<<<<<<<<
+ *                 # The coroutine raised a BaseException. Consume the exception
+ *                 # to not log a warning, the caller doesn't have access to the
+ */
+        }
+
+        /* "uvloop/loop.pyx":1495
+ *                 # local task.
+ *                 future.exception()
+ *             raise             # <<<<<<<<<<<<<<
+ *         finally:
+ *             future.remove_done_callback(done_cb)
+ */
+        __Pyx_GIVEREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_3);
+        __Pyx_XGIVEREF(__pyx_t_1);
+        __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_3, __pyx_t_1);
+        __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_1 = 0; 
+        __PYX_ERR(0, 1495, __pyx_L9_except_error)
+      }
+      goto __pyx_L9_except_error;
+      __pyx_L9_except_error:;
+
+      /* "uvloop/loop.pyx":1487
+ * 
+ *         future.add_done_callback(done_cb)
+ *         try:             # <<<<<<<<<<<<<<
+ *             self.run_forever()
+ *         except BaseException:
+ */
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+      goto __pyx_L5_error;
+      __pyx_L12_try_end:;
+    }
+  }
+
+  /* "uvloop/loop.pyx":1497
+ *             raise
+ *         finally:
+ *             future.remove_done_callback(done_cb)             # <<<<<<<<<<<<<<
+ *         if not future.done():
+ *             raise RuntimeError('Event loop stopped before Future completed.')
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_remove_done_callback); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1497, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_done_cb) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_done_cb);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1497, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_16);
+      __Pyx_XGOTREF(__pyx_t_17);
+      __Pyx_XGOTREF(__pyx_t_18);
+      __pyx_t_8 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
+      {
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_remove_done_callback); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1497, __pyx_L20_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_4 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_done_cb) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_done_cb);
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1497, __pyx_L20_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_XGIVEREF(__pyx_t_18);
+        __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+      }
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_ErrRestore(__pyx_t_7, __pyx_t_6, __pyx_t_5);
+      __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+      __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
+      goto __pyx_L1_error;
+      __pyx_L20_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_XGIVEREF(__pyx_t_18);
+        __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+      }
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/loop.pyx":1498
+ *         finally:
+ *             future.remove_done_callback(done_cb)
+ *         if not future.done():             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Event loop stopped before Future completed.')
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_done); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1498, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1498, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1498, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_13 = ((!__pyx_t_2) != 0);
+  if (unlikely(__pyx_t_13)) {
+
+    /* "uvloop/loop.pyx":1499
+ *             future.remove_done_callback(done_cb)
+ *         if not future.done():
+ *             raise RuntimeError('Event loop stopped before Future completed.')             # <<<<<<<<<<<<<<
+ * 
+ *         return future.result()
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1499, __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, 1499, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1498
+ *         finally:
+ *             future.remove_done_callback(done_cb)
+ *         if not future.done():             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Event loop stopped before Future completed.')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":1501
+ *             raise RuntimeError('Event loop stopped before Future completed.')
+ * 
+ *         return future.result()             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1501, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1501, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":1457
+ *         return self._task_factory
+ * 
+ *     def run_until_complete(self, future):             # <<<<<<<<<<<<<<
+ *         """Run until the Future is done.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("uvloop.loop.Loop.run_until_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_done_cb);
+  __Pyx_XDECREF(__pyx_v_future);
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_48generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":1504
+ * 
+ *     @cython.iterable_coroutine
+ *     async def getaddrinfo(self, object host, object port, *,             # <<<<<<<<<<<<<<
+ *                           int family=0, int type=0, int proto=0, int flags=0):
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_47getaddrinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_46getaddrinfo[] = "Loop.getaddrinfo(self, host, port, *, int family=0, int type=0, int proto=0, int flags=0)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_47getaddrinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_host = 0;
+  PyObject *__pyx_v_port = 0;
+  int __pyx_v_family;
+  int __pyx_v_type;
+  int __pyx_v_proto;
+  int __pyx_v_flags;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("getaddrinfo (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_family,&__pyx_n_s_type,&__pyx_n_s_proto,&__pyx_n_s_flags,0};
+    PyObject* values[6] = {0,0,0,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  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_host)) != 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_port)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("getaddrinfo", 1, 2, 2, 1); __PYX_ERR(0, 1504, __pyx_L3_error)
+        }
+      }
+      if (kw_args > 0 && likely(kw_args <= 4)) {
+        Py_ssize_t index;
+        for (index = 2; index < 6 && kw_args > 0; index++) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+          if (value) { values[index] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getaddrinfo") < 0)) __PYX_ERR(0, 1504, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_host = values[0];
+    __pyx_v_port = values[1];
+    if (values[2]) {
+      __pyx_v_family = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_family == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1505, __pyx_L3_error)
+    } else {
+      __pyx_v_family = ((int)0);
+    }
+    if (values[3]) {
+      __pyx_v_type = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1505, __pyx_L3_error)
+    } else {
+      __pyx_v_type = ((int)0);
+    }
+    if (values[4]) {
+      __pyx_v_proto = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_proto == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1505, __pyx_L3_error)
+    } else {
+      __pyx_v_proto = ((int)0);
+    }
+    if (values[5]) {
+      __pyx_v_flags = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1505, __pyx_L3_error)
+    } else {
+      __pyx_v_flags = ((int)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("getaddrinfo", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1504, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.getaddrinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_46getaddrinfo(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_host, __pyx_v_port, __pyx_v_family, __pyx_v_type, __pyx_v_proto, __pyx_v_flags);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_46getaddrinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_flags) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("getaddrinfo", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 1504, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_host = __pyx_v_host;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_host);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_host);
+  __pyx_cur_scope->__pyx_v_port = __pyx_v_port;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_port);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_port);
+  __pyx_cur_scope->__pyx_v_family = __pyx_v_family;
+  __pyx_cur_scope->__pyx_v_type = __pyx_v_type;
+  __pyx_cur_scope->__pyx_v_proto = __pyx_v_proto;
+  __pyx_cur_scope->__pyx_v_flags = __pyx_v_flags;
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_48generator, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_getaddrinfo, __pyx_n_s_Loop_getaddrinfo, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 1504, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.getaddrinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_48generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("getaddrinfo", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L5_resume_from_await;
+    case 2: goto __pyx_L6_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1504, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1507
+ *                           int family=0, int type=0, int proto=0, int flags=0):
+ * 
+ *         addr = __static_getaddrinfo_pyaddr(host, port, family,             # <<<<<<<<<<<<<<
+ *                                            type, proto, flags)
+ *         if addr is not None:
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___static_getaddrinfo_pyaddr(__pyx_cur_scope->__pyx_v_host, __pyx_cur_scope->__pyx_v_port, __pyx_cur_scope->__pyx_v_family, __pyx_cur_scope->__pyx_v_type, __pyx_cur_scope->__pyx_v_proto, __pyx_cur_scope->__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1507, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_addr = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":1509
+ *         addr = __static_getaddrinfo_pyaddr(host, port, family,
+ *                                            type, proto, flags)
+ *         if addr is not None:             # <<<<<<<<<<<<<<
+ *             fut = self._new_future()
+ *             fut.set_result([addr])
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_addr != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":1510
+ *                                            type, proto, flags)
+ *         if addr is not None:
+ *             fut = self._new_future()             # <<<<<<<<<<<<<<
+ *             fut.set_result([addr])
+ *             return await fut
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1510, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_1);
+    __pyx_cur_scope->__pyx_v_fut = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":1511
+ *         if addr is not None:
+ *             fut = self._new_future()
+ *             fut.set_result([addr])             # <<<<<<<<<<<<<<
+ *             return await fut
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1511, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1511, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_addr);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_addr);
+    PyList_SET_ITEM(__pyx_t_5, 0, __pyx_cur_scope->__pyx_v_addr);
+    __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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_1 = (__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_1)) __PYX_ERR(0, 1511, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":1512
+ *             fut = self._new_future()
+ *             fut.set_result([addr])
+ *             return await fut             # <<<<<<<<<<<<<<
+ * 
+ *         return await self._getaddrinfo(
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_fut);
+    __Pyx_XGOTREF(__pyx_r);
+    if (likely(__pyx_r)) {
+      __Pyx_XGIVEREF(__pyx_r);
+      __Pyx_RefNannyFinishContext();
+      __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+      /* return from generator, awaiting value */
+      __pyx_generator->resume_label = 1;
+      return __pyx_r;
+      __pyx_L5_resume_from_await:;
+      if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1512, __pyx_L1_error)
+      __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1);
+    } else {
+      __pyx_t_1 = NULL;
+      if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(0, 1512, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":1509
+ *         addr = __static_getaddrinfo_pyaddr(host, port, family,
+ *                                            type, proto, flags)
+ *         if addr is not None:             # <<<<<<<<<<<<<<
+ *             fut = self._new_future()
+ *             fut.set_result([addr])
+ */
+  }
+
+  /* "uvloop/loop.pyx":1514
+ *             return await fut
+ * 
+ *         return await self._getaddrinfo(             # <<<<<<<<<<<<<<
+ *             host, port, family, type, proto, flags, 1)
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+
+  /* "uvloop/loop.pyx":1515
+ * 
+ *         return await self._getaddrinfo(
+ *             host, port, family, type, proto, flags, 1)             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_host, __pyx_cur_scope->__pyx_v_port, __pyx_cur_scope->__pyx_v_family, __pyx_cur_scope->__pyx_v_type, __pyx_cur_scope->__pyx_v_proto, __pyx_cur_scope->__pyx_v_flags, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1514, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 2;
+    return __pyx_r;
+    __pyx_L6_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1514, __pyx_L1_error)
+    __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1);
+  } else {
+    __pyx_t_1 = NULL;
+    if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(0, 1514, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  }
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":1504
+ * 
+ *     @cython.iterable_coroutine
+ *     async def getaddrinfo(self, object host, object port, *,             # <<<<<<<<<<<<<<
+ *                           int family=0, int type=0, int proto=0, int flags=0):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("getaddrinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_51generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":1518
+ * 
+ *     @cython.iterable_coroutine
+ *     async def getnameinfo(self, sockaddr, int flags=0):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             AddrInfo ai_cnt
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_50getnameinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_49getnameinfo[] = "Loop.getnameinfo(self, sockaddr, int flags=0)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_50getnameinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_sockaddr = 0;
+  int __pyx_v_flags;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("getnameinfo (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sockaddr,&__pyx_n_s_flags,0};
+    PyObject* values[2] = {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  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_sockaddr)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getnameinfo") < 0)) __PYX_ERR(0, 1518, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_sockaddr = values[0];
+    if (values[1]) {
+      __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1518, __pyx_L3_error)
+    } else {
+      __pyx_v_flags = ((int)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("getnameinfo", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1518, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_49getnameinfo(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_sockaddr, __pyx_v_flags);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_49getnameinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sockaddr, int __pyx_v_flags) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("getnameinfo", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_5_getnameinfo(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_5_getnameinfo, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 1518, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_sockaddr = __pyx_v_sockaddr;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sockaddr);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sockaddr);
+  __pyx_cur_scope->__pyx_v_flags = __pyx_v_flags;
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_51generator1, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_getnameinfo, __pyx_n_s_Loop_getnameinfo, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 1518, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_51generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  Py_ssize_t __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  struct addrinfo *__pyx_t_7;
+  int __pyx_t_8;
+  unsigned long __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("getnameinfo", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L16_resume_from_await;
+    case 2: goto __pyx_L20_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1518, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1524
+ *             system.sockaddr_in6 *sin6
+ * 
+ *         if not isinstance(sockaddr, tuple):             # <<<<<<<<<<<<<<
+ *             raise TypeError('getnameinfo() argument 1 must be a tuple')
+ * 
+ */
+  __pyx_t_1 = PyTuple_Check(__pyx_cur_scope->__pyx_v_sockaddr); 
+  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/loop.pyx":1525
+ * 
+ *         if not isinstance(sockaddr, tuple):
+ *             raise TypeError('getnameinfo() argument 1 must be a tuple')             # <<<<<<<<<<<<<<
+ * 
+ *         sl = len(sockaddr)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1525, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(0, 1525, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1524
+ *             system.sockaddr_in6 *sin6
+ * 
+ *         if not isinstance(sockaddr, tuple):             # <<<<<<<<<<<<<<
+ *             raise TypeError('getnameinfo() argument 1 must be a tuple')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":1527
+ *             raise TypeError('getnameinfo() argument 1 must be a tuple')
+ * 
+ *         sl = len(sockaddr)             # <<<<<<<<<<<<<<
+ * 
+ *         if sl < 2 or sl > 4:
+ */
+  __pyx_t_4 = PyObject_Length(__pyx_cur_scope->__pyx_v_sockaddr); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1527, __pyx_L1_error)
+  __pyx_cur_scope->__pyx_v_sl = __pyx_t_4;
+
+  /* "uvloop/loop.pyx":1529
+ *         sl = len(sockaddr)
+ * 
+ *         if sl < 2 or sl > 4:             # <<<<<<<<<<<<<<
+ *             raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')
+ * 
+ */
+  __pyx_t_1 = ((__pyx_cur_scope->__pyx_v_sl < 2) != 0);
+  if (!__pyx_t_1) {
+  } else {
+    __pyx_t_2 = __pyx_t_1;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_1 = ((__pyx_cur_scope->__pyx_v_sl > 4) != 0);
+  __pyx_t_2 = __pyx_t_1;
+  __pyx_L6_bool_binop_done:;
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/loop.pyx":1530
+ * 
+ *         if sl < 2 or sl > 4:
+ *             raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')             # <<<<<<<<<<<<<<
+ * 
+ *         if sl > 2:
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1530, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(0, 1530, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1529
+ *         sl = len(sockaddr)
+ * 
+ *         if sl < 2 or sl > 4:             # <<<<<<<<<<<<<<
+ *             raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":1532
+ *             raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')
+ * 
+ *         if sl > 2:             # <<<<<<<<<<<<<<
+ *             flowinfo = sockaddr[2]
+ *             if flowinfo < 0 or flowinfo > 0xfffff:
+ */
+  __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_sl > 2) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1533
+ * 
+ *         if sl > 2:
+ *             flowinfo = sockaddr[2]             # <<<<<<<<<<<<<<
+ *             if flowinfo < 0 or flowinfo > 0xfffff:
+ *                 raise OverflowError(
+ */
+    __pyx_t_3 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_sockaddr, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1533, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_cur_scope->__pyx_v_flowinfo = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":1534
+ *         if sl > 2:
+ *             flowinfo = sockaddr[2]
+ *             if flowinfo < 0 or flowinfo > 0xfffff:             # <<<<<<<<<<<<<<
+ *                 raise OverflowError(
+ *                     'getnameinfo(): flowinfo must be 0-1048575.')
+ */
+    __pyx_t_3 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_flowinfo, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1534, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1534, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!__pyx_t_1) {
+    } else {
+      __pyx_t_2 = __pyx_t_1;
+      goto __pyx_L10_bool_binop_done;
+    }
+    __pyx_t_3 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_flowinfo, __pyx_int_1048575, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1534, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1534, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_2 = __pyx_t_1;
+    __pyx_L10_bool_binop_done:;
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":1535
+ *             flowinfo = sockaddr[2]
+ *             if flowinfo < 0 or flowinfo > 0xfffff:
+ *                 raise OverflowError(             # <<<<<<<<<<<<<<
+ *                     'getnameinfo(): flowinfo must be 0-1048575.')
+ *         else:
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_OverflowError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1535, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 1535, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1534
+ *         if sl > 2:
+ *             flowinfo = sockaddr[2]
+ *             if flowinfo < 0 or flowinfo > 0xfffff:             # <<<<<<<<<<<<<<
+ *                 raise OverflowError(
+ *                     'getnameinfo(): flowinfo must be 0-1048575.')
+ */
+    }
+
+    /* "uvloop/loop.pyx":1532
+ *             raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')
+ * 
+ *         if sl > 2:             # <<<<<<<<<<<<<<
+ *             flowinfo = sockaddr[2]
+ *             if flowinfo < 0 or flowinfo > 0xfffff:
+ */
+    goto __pyx_L8;
+  }
+
+  /* "uvloop/loop.pyx":1538
+ *                     'getnameinfo(): flowinfo must be 0-1048575.')
+ *         else:
+ *             flowinfo = 0             # <<<<<<<<<<<<<<
+ * 
+ *         if sl > 3:
+ */
+  /*else*/ {
+    __Pyx_INCREF(__pyx_int_0);
+    __Pyx_GIVEREF(__pyx_int_0);
+    __pyx_cur_scope->__pyx_v_flowinfo = __pyx_int_0;
+  }
+  __pyx_L8:;
+
+  /* "uvloop/loop.pyx":1540
+ *             flowinfo = 0
+ * 
+ *         if sl > 3:             # <<<<<<<<<<<<<<
+ *             scope_id = sockaddr[3]
+ *             if scope_id < 0 or scope_id > 2 ** 32:
+ */
+  __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_sl > 3) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1541
+ * 
+ *         if sl > 3:
+ *             scope_id = sockaddr[3]             # <<<<<<<<<<<<<<
+ *             if scope_id < 0 or scope_id > 2 ** 32:
+ *                 raise OverflowError(
+ */
+    __pyx_t_3 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_sockaddr, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1541, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_cur_scope->__pyx_v_scope_id = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":1542
+ *         if sl > 3:
+ *             scope_id = sockaddr[3]
+ *             if scope_id < 0 or scope_id > 2 ** 32:             # <<<<<<<<<<<<<<
+ *                 raise OverflowError(
+ *                     'getsockaddrarg: scope_id must be unsigned 32 bit integer')
+ */
+    __pyx_t_3 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_scope_id, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1542, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1542, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!__pyx_t_1) {
+    } else {
+      __pyx_t_2 = __pyx_t_1;
+      goto __pyx_L14_bool_binop_done;
+    }
+    __pyx_t_3 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_scope_id, __pyx_int_4294967296, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1542, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1542, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_2 = __pyx_t_1;
+    __pyx_L14_bool_binop_done:;
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":1543
+ *             scope_id = sockaddr[3]
+ *             if scope_id < 0 or scope_id > 2 ** 32:
+ *                 raise OverflowError(             # <<<<<<<<<<<<<<
+ *                     'getsockaddrarg: scope_id must be unsigned 32 bit integer')
+ *         else:
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_OverflowError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1543, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 1543, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1542
+ *         if sl > 3:
+ *             scope_id = sockaddr[3]
+ *             if scope_id < 0 or scope_id > 2 ** 32:             # <<<<<<<<<<<<<<
+ *                 raise OverflowError(
+ *                     'getsockaddrarg: scope_id must be unsigned 32 bit integer')
+ */
+    }
+
+    /* "uvloop/loop.pyx":1540
+ *             flowinfo = 0
+ * 
+ *         if sl > 3:             # <<<<<<<<<<<<<<
+ *             scope_id = sockaddr[3]
+ *             if scope_id < 0 or scope_id > 2 ** 32:
+ */
+    goto __pyx_L12;
+  }
+
+  /* "uvloop/loop.pyx":1546
+ *                     'getsockaddrarg: scope_id must be unsigned 32 bit integer')
+ *         else:
+ *             scope_id = 0             # <<<<<<<<<<<<<<
+ * 
+ *         ai_cnt = await self._getaddrinfo(
+ */
+  /*else*/ {
+    __Pyx_INCREF(__pyx_int_0);
+    __Pyx_GIVEREF(__pyx_int_0);
+    __pyx_cur_scope->__pyx_v_scope_id = __pyx_int_0;
+  }
+  __pyx_L12:;
+
+  /* "uvloop/loop.pyx":1549
+ * 
+ *         ai_cnt = await self._getaddrinfo(
+ *             sockaddr[0], sockaddr[1],             # <<<<<<<<<<<<<<
+ *             uv.AF_UNSPEC,         # family
+ *             uv.SOCK_DGRAM,        # type
+ */
+  __pyx_t_3 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_sockaddr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1549, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_sockaddr, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1549, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+
+  /* "uvloop/loop.pyx":1548
+ *             scope_id = 0
+ * 
+ *         ai_cnt = await self._getaddrinfo(             # <<<<<<<<<<<<<<
+ *             sockaddr[0], sockaddr[1],
+ *             uv.AF_UNSPEC,         # family
+ */
+  __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_t_3, __pyx_t_5, AF_UNSPEC, SOCK_DGRAM, 0, AI_NUMERICHOST, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1548, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 1;
+    return __pyx_r;
+    __pyx_L16_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1548, __pyx_L1_error)
+    __pyx_t_6 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_6);
+  } else {
+    __pyx_t_6 = NULL;
+    if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_6) < 0) __PYX_ERR(0, 1548, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+  }
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_6uvloop_4loop_AddrInfo))))) __PYX_ERR(0, 1548, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_6);
+  __pyx_cur_scope->__pyx_v_ai_cnt = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":1556
+ *             0)                    # unpack
+ * 
+ *         ai = ai_cnt.data             # <<<<<<<<<<<<<<
+ * 
+ *         if ai.ai_next:
+ */
+  __pyx_t_7 = __pyx_cur_scope->__pyx_v_ai_cnt->data;
+  __pyx_cur_scope->__pyx_v_ai = __pyx_t_7;
+
+  /* "uvloop/loop.pyx":1558
+ *         ai = ai_cnt.data
+ * 
+ *         if ai.ai_next:             # <<<<<<<<<<<<<<
+ *             raise OSError("sockaddr resolved to multiple addresses")
+ * 
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_ai->ai_next != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/loop.pyx":1559
+ * 
+ *         if ai.ai_next:
+ *             raise OSError("sockaddr resolved to multiple addresses")             # <<<<<<<<<<<<<<
+ * 
+ *         if ai.ai_family == uv.AF_INET:
+ */
+    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1559, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __PYX_ERR(0, 1559, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1558
+ *         ai = ai_cnt.data
+ * 
+ *         if ai.ai_next:             # <<<<<<<<<<<<<<
+ *             raise OSError("sockaddr resolved to multiple addresses")
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":1561
+ *             raise OSError("sockaddr resolved to multiple addresses")
+ * 
+ *         if ai.ai_family == uv.AF_INET:             # <<<<<<<<<<<<<<
+ *             if sl > 2:
+ *                 raise OSError("IPv4 sockaddr must be 2 tuple")
+ */
+  __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_ai->ai_family == AF_INET) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1562
+ * 
+ *         if ai.ai_family == uv.AF_INET:
+ *             if sl > 2:             # <<<<<<<<<<<<<<
+ *                 raise OSError("IPv4 sockaddr must be 2 tuple")
+ *         elif ai.ai_family == uv.AF_INET6:
+ */
+    __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_sl > 2) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":1563
+ *         if ai.ai_family == uv.AF_INET:
+ *             if sl > 2:
+ *                 raise OSError("IPv4 sockaddr must be 2 tuple")             # <<<<<<<<<<<<<<
+ *         elif ai.ai_family == uv.AF_INET6:
+ *             # Modify some fields in `ai`
+ */
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1563, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __PYX_ERR(0, 1563, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1562
+ * 
+ *         if ai.ai_family == uv.AF_INET:
+ *             if sl > 2:             # <<<<<<<<<<<<<<
+ *                 raise OSError("IPv4 sockaddr must be 2 tuple")
+ *         elif ai.ai_family == uv.AF_INET6:
+ */
+    }
+
+    /* "uvloop/loop.pyx":1561
+ *             raise OSError("sockaddr resolved to multiple addresses")
+ * 
+ *         if ai.ai_family == uv.AF_INET:             # <<<<<<<<<<<<<<
+ *             if sl > 2:
+ *                 raise OSError("IPv4 sockaddr must be 2 tuple")
+ */
+    goto __pyx_L18;
+  }
+
+  /* "uvloop/loop.pyx":1564
+ *             if sl > 2:
+ *                 raise OSError("IPv4 sockaddr must be 2 tuple")
+ *         elif ai.ai_family == uv.AF_INET6:             # <<<<<<<<<<<<<<
+ *             # Modify some fields in `ai`
+ *             sin6 = <system.sockaddr_in6*> ai.ai_addr
+ */
+  __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_ai->ai_family == AF_INET6) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1566
+ *         elif ai.ai_family == uv.AF_INET6:
+ *             # Modify some fields in `ai`
+ *             sin6 = <system.sockaddr_in6*> ai.ai_addr             # <<<<<<<<<<<<<<
+ *             sin6.sin6_flowinfo = system.htonl(flowinfo)
+ *             sin6.sin6_scope_id = scope_id
+ */
+    __pyx_cur_scope->__pyx_v_sin6 = ((struct sockaddr_in6 *)__pyx_cur_scope->__pyx_v_ai->ai_addr);
+
+    /* "uvloop/loop.pyx":1567
+ *             # Modify some fields in `ai`
+ *             sin6 = <system.sockaddr_in6*> ai.ai_addr
+ *             sin6.sin6_flowinfo = system.htonl(flowinfo)             # <<<<<<<<<<<<<<
+ *             sin6.sin6_scope_id = scope_id
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_flowinfo); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1567, __pyx_L1_error)
+    __pyx_cur_scope->__pyx_v_sin6->sin6_flowinfo = htonl(__pyx_t_8);
+
+    /* "uvloop/loop.pyx":1568
+ *             sin6 = <system.sockaddr_in6*> ai.ai_addr
+ *             sin6.sin6_flowinfo = system.htonl(flowinfo)
+ *             sin6.sin6_scope_id = scope_id             # <<<<<<<<<<<<<<
+ * 
+ *         return await self._getnameinfo(ai.ai_addr, flags)
+ */
+    __pyx_t_9 = __Pyx_PyInt_As_unsigned_long(__pyx_cur_scope->__pyx_v_scope_id); if (unlikely((__pyx_t_9 == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1568, __pyx_L1_error)
+    __pyx_cur_scope->__pyx_v_sin6->sin6_scope_id = __pyx_t_9;
+
+    /* "uvloop/loop.pyx":1564
+ *             if sl > 2:
+ *                 raise OSError("IPv4 sockaddr must be 2 tuple")
+ *         elif ai.ai_family == uv.AF_INET6:             # <<<<<<<<<<<<<<
+ *             # Modify some fields in `ai`
+ *             sin6 = <system.sockaddr_in6*> ai.ai_addr
+ */
+  }
+  __pyx_L18:;
+
+  /* "uvloop/loop.pyx":1570
+ *             sin6.sin6_scope_id = scope_id
+ * 
+ *         return await self._getnameinfo(ai.ai_addr, flags)             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getnameinfo(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_ai->ai_addr, __pyx_cur_scope->__pyx_v_flags); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1570, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 2;
+    return __pyx_r;
+    __pyx_L20_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1570, __pyx_L1_error)
+    __pyx_t_6 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_6);
+  } else {
+    __pyx_t_6 = NULL;
+    if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_6) < 0) __PYX_ERR(0, 1570, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+  }
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":1518
+ * 
+ *     @cython.iterable_coroutine
+ *     async def getnameinfo(self, sockaddr, int flags=0):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             AddrInfo ai_cnt
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_54generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":1573
+ * 
+ *     @cython.iterable_coroutine
+ *     async def start_tls(self, transport, protocol, sslcontext, *,             # <<<<<<<<<<<<<<
+ *                         server_side=False,
+ *                         server_hostname=None,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_53start_tls(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_52start_tls[] = "Loop.start_tls(self, transport, protocol, sslcontext, *, server_side=False, server_hostname=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None)\nUpgrade transport to TLS.\n\n        Return a new transport that *protocol* should start using\n        immediately.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_53start_tls(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_transport = 0;
+  PyObject *__pyx_v_protocol = 0;
+  PyObject *__pyx_v_sslcontext = 0;
+  PyObject *__pyx_v_server_side = 0;
+  PyObject *__pyx_v_server_hostname = 0;
+  PyObject *__pyx_v_ssl_handshake_timeout = 0;
+  PyObject *__pyx_v_ssl_shutdown_timeout = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("start_tls (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_transport,&__pyx_n_s_protocol,&__pyx_n_s_sslcontext,&__pyx_n_s_server_side,&__pyx_n_s_server_hostname,&__pyx_n_s_ssl_handshake_timeout,&__pyx_n_s_ssl_shutdown_timeout,0};
+    PyObject* values[7] = {0,0,0,0,0,0,0};
+
+    /* "uvloop/loop.pyx":1574
+ *     @cython.iterable_coroutine
+ *     async def start_tls(self, transport, protocol, sslcontext, *,
+ *                         server_side=False,             # <<<<<<<<<<<<<<
+ *                         server_hostname=None,
+ *                         ssl_handshake_timeout=None,
+ */
+    values[3] = ((PyObject *)Py_False);
+
+    /* "uvloop/loop.pyx":1575
+ *     async def start_tls(self, transport, protocol, sslcontext, *,
+ *                         server_side=False,
+ *                         server_hostname=None,             # <<<<<<<<<<<<<<
+ *                         ssl_handshake_timeout=None,
+ *                         ssl_shutdown_timeout=None):
+ */
+    values[4] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1576
+ *                         server_side=False,
+ *                         server_hostname=None,
+ *                         ssl_handshake_timeout=None,             # <<<<<<<<<<<<<<
+ *                         ssl_shutdown_timeout=None):
+ *         """Upgrade transport to TLS.
+ */
+    values[5] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1577
+ *                         server_hostname=None,
+ *                         ssl_handshake_timeout=None,
+ *                         ssl_shutdown_timeout=None):             # <<<<<<<<<<<<<<
+ *         """Upgrade transport to TLS.
+ * 
+ */
+    values[6] = ((PyObject *)Py_None);
+    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_transport)) != 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_protocol)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("start_tls", 1, 3, 3, 1); __PYX_ERR(0, 1573, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sslcontext)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("start_tls", 1, 3, 3, 2); __PYX_ERR(0, 1573, __pyx_L3_error)
+        }
+      }
+      if (kw_args > 0 && likely(kw_args <= 4)) {
+        Py_ssize_t index;
+        for (index = 3; index < 7 && kw_args > 0; index++) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+          if (value) { values[index] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "start_tls") < 0)) __PYX_ERR(0, 1573, __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_transport = values[0];
+    __pyx_v_protocol = values[1];
+    __pyx_v_sslcontext = values[2];
+    __pyx_v_server_side = values[3];
+    __pyx_v_server_hostname = values[4];
+    __pyx_v_ssl_handshake_timeout = values[5];
+    __pyx_v_ssl_shutdown_timeout = values[6];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("start_tls", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1573, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.start_tls", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_52start_tls(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_transport, __pyx_v_protocol, __pyx_v_sslcontext, __pyx_v_server_side, __pyx_v_server_hostname, __pyx_v_ssl_handshake_timeout, __pyx_v_ssl_shutdown_timeout);
+
+  /* "uvloop/loop.pyx":1573
+ * 
+ *     @cython.iterable_coroutine
+ *     async def start_tls(self, transport, protocol, sslcontext, *,             # <<<<<<<<<<<<<<
+ *                         server_side=False,
+ *                         server_hostname=None,
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_52start_tls(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_transport, PyObject *__pyx_v_protocol, PyObject *__pyx_v_sslcontext, PyObject *__pyx_v_server_side, PyObject *__pyx_v_server_hostname, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("start_tls", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_6_start_tls(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_6_start_tls, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 1573, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_transport = __pyx_v_transport;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_transport);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_transport);
+  __pyx_cur_scope->__pyx_v_protocol = __pyx_v_protocol;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
+  __pyx_cur_scope->__pyx_v_sslcontext = __pyx_v_sslcontext;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sslcontext);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sslcontext);
+  __pyx_cur_scope->__pyx_v_server_side = __pyx_v_server_side;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_side);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_side);
+  __pyx_cur_scope->__pyx_v_server_hostname = __pyx_v_server_hostname;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_hostname);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_hostname);
+  __pyx_cur_scope->__pyx_v_ssl_handshake_timeout = __pyx_v_ssl_handshake_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout = __pyx_v_ssl_shutdown_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_54generator2, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_start_tls, __pyx_n_s_Loop_start_tls, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 1573, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.start_tls", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_54generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  Py_ssize_t __pyx_t_6;
+  Py_UCS4 __pyx_t_7;
+  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_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("start_tls", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L14_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1573, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1583
+ *         immediately.
+ *         """
+ *         if not isinstance(sslcontext, ssl_SSLContext):             # <<<<<<<<<<<<<<
+ *             raise TypeError(
+ *                 f'sslcontext is expected to be an instance of ssl.SSLContext, '
+ */
+  __pyx_t_1 = __pyx_v_6uvloop_4loop_ssl_SSLContext;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_sslcontext, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 1583, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/loop.pyx":1586
+ *             raise TypeError(
+ *                 f'sslcontext is expected to be an instance of ssl.SSLContext, '
+ *                 f'got {sslcontext!r}')             # <<<<<<<<<<<<<<
+ * 
+ *         if isinstance(transport, (TCPTransport, UnixTransport)):
+ */
+    __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_cur_scope->__pyx_v_sslcontext), __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1586, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+
+    /* "uvloop/loop.pyx":1585
+ *         if not isinstance(sslcontext, ssl_SSLContext):
+ *             raise TypeError(
+ *                 f'sslcontext is expected to be an instance of ssl.SSLContext, '             # <<<<<<<<<<<<<<
+ *                 f'got {sslcontext!r}')
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_sslcontext_is_expected_to_be_an, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1585, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":1584
+ *         """
+ *         if not isinstance(sslcontext, ssl_SSLContext):
+ *             raise TypeError(             # <<<<<<<<<<<<<<
+ *                 f'sslcontext is expected to be an instance of ssl.SSLContext, '
+ *                 f'got {sslcontext!r}')
+ */
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1584, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __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, 1584, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1583
+ *         immediately.
+ *         """
+ *         if not isinstance(sslcontext, ssl_SSLContext):             # <<<<<<<<<<<<<<
+ *             raise TypeError(
+ *                 f'sslcontext is expected to be an instance of ssl.SSLContext, '
+ */
+  }
+
+  /* "uvloop/loop.pyx":1588
+ *                 f'got {sslcontext!r}')
+ * 
+ *         if isinstance(transport, (TCPTransport, UnixTransport)):             # <<<<<<<<<<<<<<
+ *             context = (<UVStream>transport).context
+ *         elif isinstance(transport, _SSLProtocolTransport):
+ */
+  __pyx_t_2 = __Pyx_TypeCheck(__pyx_cur_scope->__pyx_v_transport, __pyx_ptype_6uvloop_4loop_TCPTransport); 
+  __pyx_t_5 = (__pyx_t_2 != 0);
+  if (!__pyx_t_5) {
+  } else {
+    __pyx_t_3 = __pyx_t_5;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_5 = __Pyx_TypeCheck(__pyx_cur_scope->__pyx_v_transport, __pyx_ptype_6uvloop_4loop_UnixTransport); 
+  __pyx_t_2 = (__pyx_t_5 != 0);
+  __pyx_t_3 = __pyx_t_2;
+  __pyx_L6_bool_binop_done:;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":1589
+ * 
+ *         if isinstance(transport, (TCPTransport, UnixTransport)):
+ *             context = (<UVStream>transport).context             # <<<<<<<<<<<<<<
+ *         elif isinstance(transport, _SSLProtocolTransport):
+ *             context = (<_SSLProtocolTransport>transport).context
+ */
+    __pyx_t_1 = ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_cur_scope->__pyx_v_transport)->__pyx_base.__pyx_base.__pyx_base.context;
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_1);
+    __pyx_cur_scope->__pyx_v_context = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":1588
+ *                 f'got {sslcontext!r}')
+ * 
+ *         if isinstance(transport, (TCPTransport, UnixTransport)):             # <<<<<<<<<<<<<<
+ *             context = (<UVStream>transport).context
+ *         elif isinstance(transport, _SSLProtocolTransport):
+ */
+    goto __pyx_L5;
+  }
+
+  /* "uvloop/loop.pyx":1590
+ *         if isinstance(transport, (TCPTransport, UnixTransport)):
+ *             context = (<UVStream>transport).context
+ *         elif isinstance(transport, _SSLProtocolTransport):             # <<<<<<<<<<<<<<
+ *             context = (<_SSLProtocolTransport>transport).context
+ *         else:
+ */
+  __pyx_t_2 = __Pyx_TypeCheck(__pyx_cur_scope->__pyx_v_transport, __pyx_ptype_6uvloop_4loop__SSLProtocolTransport); 
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (likely(__pyx_t_3)) {
+
+    /* "uvloop/loop.pyx":1591
+ *             context = (<UVStream>transport).context
+ *         elif isinstance(transport, _SSLProtocolTransport):
+ *             context = (<_SSLProtocolTransport>transport).context             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise TypeError(
+ */
+    __pyx_t_1 = ((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_cur_scope->__pyx_v_transport)->context;
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_1);
+    __pyx_cur_scope->__pyx_v_context = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":1590
+ *         if isinstance(transport, (TCPTransport, UnixTransport)):
+ *             context = (<UVStream>transport).context
+ *         elif isinstance(transport, _SSLProtocolTransport):             # <<<<<<<<<<<<<<
+ *             context = (<_SSLProtocolTransport>transport).context
+ *         else:
+ */
+    goto __pyx_L5;
+  }
+
+  /* "uvloop/loop.pyx":1593
+ *             context = (<_SSLProtocolTransport>transport).context
+ *         else:
+ *             raise TypeError(             # <<<<<<<<<<<<<<
+ *                 f'transport {transport!r} is not supported by start_tls()')
+ * 
+ */
+  /*else*/ {
+
+    /* "uvloop/loop.pyx":1594
+ *         else:
+ *             raise TypeError(
+ *                 f'transport {transport!r} is not supported by start_tls()')             # <<<<<<<<<<<<<<
+ * 
+ *         waiter = self._new_future()
+ */
+    __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1594, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_6 = 0;
+    __pyx_t_7 = 127;
+    __Pyx_INCREF(__pyx_kp_u_transport_2);
+    __pyx_t_6 += 10;
+    __Pyx_GIVEREF(__pyx_kp_u_transport_2);
+    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_transport_2);
+    __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_cur_scope->__pyx_v_transport), __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1594, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_7;
+    __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4);
+    __pyx_t_4 = 0;
+    __Pyx_INCREF(__pyx_kp_u_is_not_supported_by_start_tls);
+    __pyx_t_6 += 32;
+    __Pyx_GIVEREF(__pyx_kp_u_is_not_supported_by_start_tls);
+    PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_is_not_supported_by_start_tls);
+    __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1594, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":1593
+ *             context = (<_SSLProtocolTransport>transport).context
+ *         else:
+ *             raise TypeError(             # <<<<<<<<<<<<<<
+ *                 f'transport {transport!r} is not supported by start_tls()')
+ * 
+ */
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1593, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __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, 1593, __pyx_L1_error)
+  }
+  __pyx_L5:;
+
+  /* "uvloop/loop.pyx":1596
+ *                 f'transport {transport!r} is not supported by start_tls()')
+ * 
+ *         waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *         ssl_protocol = SSLProtocol(
+ *             self, protocol, sslcontext, waiter,
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1596, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_waiter = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":1597
+ * 
+ *         waiter = self._new_future()
+ *         ssl_protocol = SSLProtocol(             # <<<<<<<<<<<<<<
+ *             self, protocol, sslcontext, waiter,
+ *             server_side, server_hostname,
+ */
+  __pyx_t_1 = PyTuple_New(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1597, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_cur_scope->__pyx_v_protocol);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sslcontext);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sslcontext);
+  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_cur_scope->__pyx_v_sslcontext);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_waiter);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_waiter);
+  PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_cur_scope->__pyx_v_waiter);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_side);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_side);
+  PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_cur_scope->__pyx_v_server_side);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_hostname);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_hostname);
+  PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_cur_scope->__pyx_v_server_hostname);
+
+  /* "uvloop/loop.pyx":1600
+ *             self, protocol, sslcontext, waiter,
+ *             server_side, server_hostname,
+ *             ssl_handshake_timeout=ssl_handshake_timeout,             # <<<<<<<<<<<<<<
+ *             ssl_shutdown_timeout=ssl_shutdown_timeout,
+ *             call_connection_made=False)
+ */
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1600, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_ssl_handshake_timeout, __pyx_cur_scope->__pyx_v_ssl_handshake_timeout) < 0) __PYX_ERR(0, 1600, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1601
+ *             server_side, server_hostname,
+ *             ssl_handshake_timeout=ssl_handshake_timeout,
+ *             ssl_shutdown_timeout=ssl_shutdown_timeout,             # <<<<<<<<<<<<<<
+ *             call_connection_made=False)
+ * 
+ */
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_ssl_shutdown_timeout, __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout) < 0) __PYX_ERR(0, 1600, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1602
+ *             ssl_handshake_timeout=ssl_handshake_timeout,
+ *             ssl_shutdown_timeout=ssl_shutdown_timeout,
+ *             call_connection_made=False)             # <<<<<<<<<<<<<<
+ * 
+ *         # Pause early so that "ssl_protocol.data_received()" doesn't
+ */
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_call_connection_made, Py_False) < 0) __PYX_ERR(0, 1600, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1597
+ * 
+ *         waiter = self._new_future()
+ *         ssl_protocol = SSLProtocol(             # <<<<<<<<<<<<<<
+ *             self, protocol, sslcontext, waiter,
+ *             server_side, server_hostname,
+ */
+  __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_SSLProtocol), __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1597, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_8);
+  __pyx_cur_scope->__pyx_v_ssl_protocol = ((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_t_8);
+  __pyx_t_8 = 0;
+
+  /* "uvloop/loop.pyx":1606
+ *         # Pause early so that "ssl_protocol.data_received()" doesn't
+ *         # have a chance to get called before "ssl_protocol.connection_made()".
+ *         transport.pause_reading()             # <<<<<<<<<<<<<<
+ * 
+ *         transport.set_protocol(ssl_protocol)
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_transport, __pyx_n_s_pause_reading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1606, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_8 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1606, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+  /* "uvloop/loop.pyx":1608
+ *         transport.pause_reading()
+ * 
+ *         transport.set_protocol(ssl_protocol)             # <<<<<<<<<<<<<<
+ *         conmade_cb = self.call_soon(ssl_protocol.connection_made, transport,
+ *                                     context=context)
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_transport, __pyx_n_s_set_protocol); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1608, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_8 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, ((PyObject *)__pyx_cur_scope->__pyx_v_ssl_protocol)) : __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_cur_scope->__pyx_v_ssl_protocol));
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1608, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+  /* "uvloop/loop.pyx":1609
+ * 
+ *         transport.set_protocol(ssl_protocol)
+ *         conmade_cb = self.call_soon(ssl_protocol.connection_made, transport,             # <<<<<<<<<<<<<<
+ *                                     context=context)
+ *         # transport.resume_reading() will use the right context
+ */
+  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_call_soon); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1609, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_ssl_protocol), __pyx_n_s_connection_made); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1609, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1609, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_transport);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_transport);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_cur_scope->__pyx_v_transport);
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":1610
+ *         transport.set_protocol(ssl_protocol)
+ *         conmade_cb = self.call_soon(ssl_protocol.connection_made, transport,
+ *                                     context=context)             # <<<<<<<<<<<<<<
+ *         # transport.resume_reading() will use the right context
+ *         # (transport.context) to call e.g. data_received()
+ */
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1610, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_context, __pyx_cur_scope->__pyx_v_context) < 0) __PYX_ERR(0, 1610, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1609
+ * 
+ *         transport.set_protocol(ssl_protocol)
+ *         conmade_cb = self.call_soon(ssl_protocol.connection_made, transport,             # <<<<<<<<<<<<<<
+ *                                     context=context)
+ *         # transport.resume_reading() will use the right context
+ */
+  __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1609, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_9);
+  __pyx_cur_scope->__pyx_v_conmade_cb = __pyx_t_9;
+  __pyx_t_9 = 0;
+
+  /* "uvloop/loop.pyx":1613
+ *         # transport.resume_reading() will use the right context
+ *         # (transport.context) to call e.g. data_received()
+ *         resume_cb = self.call_soon(transport.resume_reading)             # <<<<<<<<<<<<<<
+ *         app_transport = ssl_protocol._get_app_transport(context)
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_call_soon); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1613, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_transport, __pyx_n_s_resume_reading); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1613, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_8 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_8)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_8);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_9 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_8, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1613, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_9);
+  __pyx_cur_scope->__pyx_v_resume_cb = __pyx_t_9;
+  __pyx_t_9 = 0;
+
+  /* "uvloop/loop.pyx":1614
+ *         # (transport.context) to call e.g. data_received()
+ *         resume_cb = self.call_soon(transport.resume_reading)
+ *         app_transport = ssl_protocol._get_app_transport(context)             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_ssl_protocol), __pyx_n_s_get_app_transport); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1614, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_9 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_cur_scope->__pyx_v_context) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_context);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1614, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_9);
+  __pyx_cur_scope->__pyx_v_app_transport = __pyx_t_9;
+  __pyx_t_9 = 0;
+
+  /* "uvloop/loop.pyx":1616
+ *         app_transport = ssl_protocol._get_app_transport(context)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+  {
+    __Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
+    __Pyx_XGOTREF(__pyx_t_10);
+    __Pyx_XGOTREF(__pyx_t_11);
+    __Pyx_XGOTREF(__pyx_t_12);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":1617
+ * 
+ *         try:
+ *             await waiter             # <<<<<<<<<<<<<<
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ */
+      __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+      __Pyx_XGOTREF(__pyx_r);
+      if (likely(__pyx_r)) {
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __pyx_cur_scope->__pyx_t_0 = __pyx_t_10;
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __pyx_cur_scope->__pyx_t_1 = __pyx_t_11;
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __pyx_cur_scope->__pyx_t_2 = __pyx_t_12;
+        __Pyx_XGIVEREF(__pyx_r);
+        __Pyx_RefNannyFinishContext();
+        __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+        /* return from generator, awaiting value */
+        __pyx_generator->resume_label = 1;
+        return __pyx_r;
+        __pyx_L14_resume_from_await:;
+        __pyx_t_10 = __pyx_cur_scope->__pyx_t_0;
+        __pyx_cur_scope->__pyx_t_0 = 0;
+        __Pyx_XGOTREF(__pyx_t_10);
+        __pyx_t_11 = __pyx_cur_scope->__pyx_t_1;
+        __pyx_cur_scope->__pyx_t_1 = 0;
+        __Pyx_XGOTREF(__pyx_t_11);
+        __pyx_t_12 = __pyx_cur_scope->__pyx_t_2;
+        __pyx_cur_scope->__pyx_t_2 = 0;
+        __Pyx_XGOTREF(__pyx_t_12);
+        if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1617, __pyx_L8_error)
+      } else {
+        PyObject* exc_type = __Pyx_PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+          else __PYX_ERR(0, 1617, __pyx_L8_error)
+        }
+      }
+
+      /* "uvloop/loop.pyx":1616
+ *         app_transport = ssl_protocol._get_app_transport(context)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+    goto __pyx_L13_try_end;
+    __pyx_L8_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/loop.pyx":1618
+ *         try:
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException:
+ */
+    __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+    if (__pyx_t_13) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.start_tls", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_4, &__pyx_t_1) < 0) __PYX_ERR(0, 1618, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_1);
+
+      /* "uvloop/loop.pyx":1619
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException:
+ *             app_transport.close()
+ */
+      __Pyx_GIVEREF(__pyx_t_9);
+      __Pyx_GIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_1);
+      __Pyx_ErrRestoreWithState(__pyx_t_9, __pyx_t_4, __pyx_t_1);
+      __pyx_t_9 = 0; __pyx_t_4 = 0; __pyx_t_1 = 0; 
+      __PYX_ERR(0, 1619, __pyx_L10_except_error)
+    }
+
+    /* "uvloop/loop.pyx":1620
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException:             # <<<<<<<<<<<<<<
+ *             app_transport.close()
+ *             conmade_cb.cancel()
+ */
+    __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_13) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.start_tls", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_4, &__pyx_t_9) < 0) __PYX_ERR(0, 1620, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_9);
+
+      /* "uvloop/loop.pyx":1621
+ *             raise
+ *         except BaseException:
+ *             app_transport.close()             # <<<<<<<<<<<<<<
+ *             conmade_cb.cancel()
+ *             resume_cb.cancel()
+ */
+      __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_app_transport, __pyx_n_s_close); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1621, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_14);
+      __pyx_t_15 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) {
+        __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14);
+        if (likely(__pyx_t_15)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
+          __Pyx_INCREF(__pyx_t_15);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_14, function);
+        }
+      }
+      __pyx_t_8 = (__pyx_t_15) ? __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_t_15) : __Pyx_PyObject_CallNoArg(__pyx_t_14);
+      __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1621, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "uvloop/loop.pyx":1622
+ *         except BaseException:
+ *             app_transport.close()
+ *             conmade_cb.cancel()             # <<<<<<<<<<<<<<
+ *             resume_cb.cancel()
+ *             raise
+ */
+      __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_conmade_cb, __pyx_n_s_cancel); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1622, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_14);
+      __pyx_t_15 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) {
+        __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14);
+        if (likely(__pyx_t_15)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
+          __Pyx_INCREF(__pyx_t_15);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_14, function);
+        }
+      }
+      __pyx_t_8 = (__pyx_t_15) ? __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_t_15) : __Pyx_PyObject_CallNoArg(__pyx_t_14);
+      __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1622, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "uvloop/loop.pyx":1623
+ *             app_transport.close()
+ *             conmade_cb.cancel()
+ *             resume_cb.cancel()             # <<<<<<<<<<<<<<
+ *             raise
+ * 
+ */
+      __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_resume_cb, __pyx_n_s_cancel); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1623, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_14);
+      __pyx_t_15 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) {
+        __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14);
+        if (likely(__pyx_t_15)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
+          __Pyx_INCREF(__pyx_t_15);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_14, function);
+        }
+      }
+      __pyx_t_8 = (__pyx_t_15) ? __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_t_15) : __Pyx_PyObject_CallNoArg(__pyx_t_14);
+      __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1623, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "uvloop/loop.pyx":1624
+ *             conmade_cb.cancel()
+ *             resume_cb.cancel()
+ *             raise             # <<<<<<<<<<<<<<
+ * 
+ *         return app_transport
+ */
+      __Pyx_GIVEREF(__pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_4, __pyx_t_9);
+      __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_9 = 0; 
+      __PYX_ERR(0, 1624, __pyx_L10_except_error)
+    }
+    goto __pyx_L10_except_error;
+    __pyx_L10_except_error:;
+
+    /* "uvloop/loop.pyx":1616
+ *         app_transport = ssl_protocol._get_app_transport(context)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_XGIVEREF(__pyx_t_11);
+    __Pyx_XGIVEREF(__pyx_t_12);
+    __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+    goto __pyx_L1_error;
+    __pyx_L13_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":1626
+ *             raise
+ * 
+ *         return app_transport             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_cur_scope->__pyx_v_app_transport);
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":1573
+ * 
+ *     @cython.iterable_coroutine
+ *     async def start_tls(self, transport, protocol, sslcontext, *,             # <<<<<<<<<<<<<<
+ *                         server_side=False,
+ *                         server_hostname=None,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_XDECREF(__pyx_t_15);
+  __Pyx_AddTraceback("start_tls", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_57generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":1629
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_server(self, protocol_factory, host=None, port=None,             # <<<<<<<<<<<<<<
+ *                             *,
+ *                             int family=uv.AF_UNSPEC,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_56create_server(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_55create_server[] = "Loop.create_server(self, protocol_factory, host=None, port=None, *, int family=uv.AF_UNSPEC, int flags=uv.AI_PASSIVE, sock=None, backlog=100, ssl=None, reuse_address=None, reuse_port=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None, start_serving=True)\nA coroutine which creates a TCP server bound to host and port.\n\n        The return value is a Server object which can be used to stop\n        the service.\n\n        If host is an empty string or None all interfaces are assumed\n        and a list of multiple sockets will be returned (most likely\n        one for IPv4 and another one for IPv6). The host parameter can also be\n        a sequence (e.g. list) of hosts to bind to.\n\n        family can be set to either AF_INET or AF_INET6 to force the\n        socket to use IPv4 or IPv6. If not set it will be determined\n        from host (defaults to AF_UNSPEC).\n\n        flags is a bitmask for getaddrinfo().\n\n        sock can optionally be specified in order to use a preexisting\n        socket object.\n\n        backlog is the maximum number of queued connections passed to\n        listen() (defaults to 100).\n\n        ssl can be set to an SSLContext to enable SSL over the\n        accepted connections.\n\n        reuse_address tells the kernel to reuse a local socket in\n        TIME_WAIT state, without waiting for its natural timeout to\n        expire. If not specified will automatically be set to True on\n        UNIX.\n\n        reuse_port tells the kernel to allow this endpoint to be bound to\n        the same port as other existing endpoints are bound to, so long as\n        they all set this flag when being created. This option is not\n        supported on Windows.\n\n        ssl_handshake_timeout is the time in seconds that an SSL server\n        will wait for completion of the SSL handshake before aborting the\n        connection. Default is 60s.\n\n        ssl_shutdown_timeout is the time in seconds that an SSL server\n        will wait fo""r completion of the SSL shutdown before aborting the\n        connection. Default is 30s.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_56create_server(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_protocol_factory = 0;
+  PyObject *__pyx_v_host = 0;
+  PyObject *__pyx_v_port = 0;
+  int __pyx_v_family;
+  int __pyx_v_flags;
+  PyObject *__pyx_v_sock = 0;
+  PyObject *__pyx_v_backlog = 0;
+  PyObject *__pyx_v_ssl = 0;
+  PyObject *__pyx_v_reuse_address = 0;
+  PyObject *__pyx_v_reuse_port = 0;
+  PyObject *__pyx_v_ssl_handshake_timeout = 0;
+  PyObject *__pyx_v_ssl_shutdown_timeout = 0;
+  PyObject *__pyx_v_start_serving = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_server (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_family,&__pyx_n_s_flags,&__pyx_n_s_sock,&__pyx_n_s_backlog,&__pyx_n_s_ssl,&__pyx_n_s_reuse_address,&__pyx_n_s_reuse_port,&__pyx_n_s_ssl_handshake_timeout,&__pyx_n_s_ssl_shutdown_timeout,&__pyx_n_s_start_serving,0};
+    PyObject* values[13] = {0,0,0,0,0,0,0,0,0,0,0,0,0};
+    values[1] = ((PyObject *)Py_None);
+    values[2] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1633
+ *                             int family=uv.AF_UNSPEC,
+ *                             int flags=uv.AI_PASSIVE,
+ *                             sock=None,             # <<<<<<<<<<<<<<
+ *                             backlog=100,
+ *                             ssl=None,
+ */
+    values[5] = ((PyObject *)Py_None);
+    values[6] = ((PyObject *)__pyx_int_100);
+
+    /* "uvloop/loop.pyx":1635
+ *                             sock=None,
+ *                             backlog=100,
+ *                             ssl=None,             # <<<<<<<<<<<<<<
+ *                             reuse_address=None,
+ *                             reuse_port=None,
+ */
+    values[7] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1636
+ *                             backlog=100,
+ *                             ssl=None,
+ *                             reuse_address=None,             # <<<<<<<<<<<<<<
+ *                             reuse_port=None,
+ *                             ssl_handshake_timeout=None,
+ */
+    values[8] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1637
+ *                             ssl=None,
+ *                             reuse_address=None,
+ *                             reuse_port=None,             # <<<<<<<<<<<<<<
+ *                             ssl_handshake_timeout=None,
+ *                             ssl_shutdown_timeout=None,
+ */
+    values[9] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1638
+ *                             reuse_address=None,
+ *                             reuse_port=None,
+ *                             ssl_handshake_timeout=None,             # <<<<<<<<<<<<<<
+ *                             ssl_shutdown_timeout=None,
+ *                             start_serving=True):
+ */
+    values[10] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1639
+ *                             reuse_port=None,
+ *                             ssl_handshake_timeout=None,
+ *                             ssl_shutdown_timeout=None,             # <<<<<<<<<<<<<<
+ *                             start_serving=True):
+ *         """A coroutine which creates a TCP server bound to host and port.
+ */
+    values[11] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1640
+ *                             ssl_handshake_timeout=None,
+ *                             ssl_shutdown_timeout=None,
+ *                             start_serving=True):             # <<<<<<<<<<<<<<
+ *         """A coroutine which creates a TCP server bound to host and port.
+ * 
+ */
+    values[12] = ((PyObject *)Py_True);
+    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_protocol_factory)) != 0)) kw_args--;
+        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--; }
+        }
+        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--; }
+        }
+      }
+      if (kw_args > 0 && likely(kw_args <= 10)) {
+        Py_ssize_t index;
+        for (index = 3; index < 13 && kw_args > 0; index++) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+          if (value) { values[index] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_server") < 0)) __PYX_ERR(0, 1629, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_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);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_protocol_factory = values[0];
+    __pyx_v_host = values[1];
+    __pyx_v_port = values[2];
+    if (values[3]) {
+      __pyx_v_family = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_family == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1631, __pyx_L3_error)
+    } else {
+      __pyx_v_family = __pyx_k__48;
+    }
+    if (values[4]) {
+      __pyx_v_flags = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1632, __pyx_L3_error)
+    } else {
+      __pyx_v_flags = __pyx_k__49;
+    }
+    __pyx_v_sock = values[5];
+    __pyx_v_backlog = values[6];
+    __pyx_v_ssl = values[7];
+    __pyx_v_reuse_address = values[8];
+    __pyx_v_reuse_port = values[9];
+    __pyx_v_ssl_handshake_timeout = values[10];
+    __pyx_v_ssl_shutdown_timeout = values[11];
+    __pyx_v_start_serving = values[12];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("create_server", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1629, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_55create_server(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_host, __pyx_v_port, __pyx_v_family, __pyx_v_flags, __pyx_v_sock, __pyx_v_backlog, __pyx_v_ssl, __pyx_v_reuse_address, __pyx_v_reuse_port, __pyx_v_ssl_handshake_timeout, __pyx_v_ssl_shutdown_timeout, __pyx_v_start_serving);
+
+  /* "uvloop/loop.pyx":1629
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_server(self, protocol_factory, host=None, port=None,             # <<<<<<<<<<<<<<
+ *                             *,
+ *                             int family=uv.AF_UNSPEC,
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_55create_server(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_flags, PyObject *__pyx_v_sock, PyObject *__pyx_v_backlog, PyObject *__pyx_v_ssl, PyObject *__pyx_v_reuse_address, PyObject *__pyx_v_reuse_port, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout, PyObject *__pyx_v_start_serving) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("create_server", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_7_create_server(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_7_create_server, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 1629, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_protocol_factory = __pyx_v_protocol_factory;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_cur_scope->__pyx_v_host = __pyx_v_host;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_host);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_host);
+  __pyx_cur_scope->__pyx_v_port = __pyx_v_port;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_port);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_port);
+  __pyx_cur_scope->__pyx_v_family = __pyx_v_family;
+  __pyx_cur_scope->__pyx_v_flags = __pyx_v_flags;
+  __pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+  __pyx_cur_scope->__pyx_v_backlog = __pyx_v_backlog;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_backlog);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_backlog);
+  __pyx_cur_scope->__pyx_v_ssl = __pyx_v_ssl;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
+  __pyx_cur_scope->__pyx_v_reuse_address = __pyx_v_reuse_address;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_reuse_address);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_reuse_address);
+  __pyx_cur_scope->__pyx_v_reuse_port = __pyx_v_reuse_port;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_reuse_port);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_reuse_port);
+  __pyx_cur_scope->__pyx_v_ssl_handshake_timeout = __pyx_v_ssl_handshake_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout = __pyx_v_ssl_shutdown_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  __pyx_cur_scope->__pyx_v_start_serving = __pyx_v_start_serving;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_start_serving);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_start_serving);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_57generator3, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_create_server, __pyx_n_s_Loop_create_server, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 1629, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_57generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  Py_ssize_t __pyx_t_8;
+  PyObject *(*__pyx_t_9)(PyObject *);
+  struct addrinfo *__pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  int __pyx_t_17;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  Py_ssize_t __pyx_t_20;
+  Py_UCS4 __pyx_t_21;
+  int __pyx_t_22;
+  char const *__pyx_t_23;
+  PyObject *__pyx_t_24 = NULL;
+  PyObject *__pyx_t_25 = NULL;
+  PyObject *__pyx_t_26 = NULL;
+  PyObject *__pyx_t_27 = NULL;
+  PyObject *__pyx_t_28 = NULL;
+  PyObject *__pyx_t_29 = NULL;
+  char const *__pyx_t_30;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_server", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L10_resume_from_await;
+    case 2: goto __pyx_L30_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1629, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1689
+ *             Server server
+ * 
+ *         if sock is not None and sock.family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *             if host is not None or port is not None:
+ *                 raise ValueError(
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+  } else {
+    __pyx_t_1 = __pyx_t_3;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1689, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1689, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1689, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1689, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L5_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1690
+ * 
+ *         if sock is not None and sock.family == uv.AF_UNIX:
+ *             if host is not None or port is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ */
+    __pyx_t_3 = (__pyx_cur_scope->__pyx_v_host != Py_None);
+    __pyx_t_2 = (__pyx_t_3 != 0);
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L8_bool_binop_done;
+    }
+    __pyx_t_2 = (__pyx_cur_scope->__pyx_v_port != Py_None);
+    __pyx_t_3 = (__pyx_t_2 != 0);
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_L8_bool_binop_done:;
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":1691
+ *         if sock is not None and sock.family == uv.AF_UNIX:
+ *             if host is not None or port is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'host/port and sock can not be specified at the same time')
+ *             return await self.create_unix_server(
+ */
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1691, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __PYX_ERR(0, 1691, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1690
+ * 
+ *         if sock is not None and sock.family == uv.AF_UNIX:
+ *             if host is not None or port is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ */
+    }
+
+    /* "uvloop/loop.pyx":1693
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ *             return await self.create_unix_server(             # <<<<<<<<<<<<<<
+ *                 protocol_factory, sock=sock, backlog=backlog, ssl=ssl,
+ *                 start_serving=start_serving)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_create_unix_server); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1693, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+
+    /* "uvloop/loop.pyx":1694
+ *                     'host/port and sock can not be specified at the same time')
+ *             return await self.create_unix_server(
+ *                 protocol_factory, sock=sock, backlog=backlog, ssl=ssl,             # <<<<<<<<<<<<<<
+ *                 start_serving=start_serving)
+ * 
+ */
+    __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1693, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_cur_scope->__pyx_v_protocol_factory);
+    __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1694, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_sock, __pyx_cur_scope->__pyx_v_sock) < 0) __PYX_ERR(0, 1694, __pyx_L1_error)
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_backlog, __pyx_cur_scope->__pyx_v_backlog) < 0) __PYX_ERR(0, 1694, __pyx_L1_error)
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_ssl, __pyx_cur_scope->__pyx_v_ssl) < 0) __PYX_ERR(0, 1694, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1695
+ *             return await self.create_unix_server(
+ *                 protocol_factory, sock=sock, backlog=backlog, ssl=ssl,
+ *                 start_serving=start_serving)             # <<<<<<<<<<<<<<
+ * 
+ *         server = Server(self)
+ */
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_start_serving, __pyx_cur_scope->__pyx_v_start_serving) < 0) __PYX_ERR(0, 1694, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1693
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ *             return await self.create_unix_server(             # <<<<<<<<<<<<<<
+ *                 protocol_factory, sock=sock, backlog=backlog, ssl=ssl,
+ *                 start_serving=start_serving)
+ */
+    __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1693, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_7);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XGOTREF(__pyx_r);
+    if (likely(__pyx_r)) {
+      __Pyx_XGIVEREF(__pyx_r);
+      __Pyx_RefNannyFinishContext();
+      __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+      /* return from generator, awaiting value */
+      __pyx_generator->resume_label = 1;
+      return __pyx_r;
+      __pyx_L10_resume_from_await:;
+      if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1693, __pyx_L1_error)
+      __pyx_t_7 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_7);
+    } else {
+      __pyx_t_7 = NULL;
+      if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_7) < 0) __PYX_ERR(0, 1693, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+    }
+    __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":1689
+ *             Server server
+ * 
+ *         if sock is not None and sock.family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *             if host is not None or port is not None:
+ *                 raise ValueError(
+ */
+  }
+
+  /* "uvloop/loop.pyx":1697
+ *                 start_serving=start_serving)
+ * 
+ *         server = Server(self)             # <<<<<<<<<<<<<<
+ * 
+ *         if ssl is not None:
+ */
+  __pyx_t_7 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6uvloop_4loop_Server), ((PyObject *)__pyx_cur_scope->__pyx_v_self)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1697, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_7);
+  __pyx_cur_scope->__pyx_v_server = ((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_t_7);
+  __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":1699
+ *         server = Server(self)
+ * 
+ *         if ssl is not None:             # <<<<<<<<<<<<<<
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ */
+  __pyx_t_1 = (__pyx_cur_scope->__pyx_v_ssl != Py_None);
+  __pyx_t_3 = (__pyx_t_1 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":1700
+ * 
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):             # <<<<<<<<<<<<<<
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ */
+    __pyx_t_7 = __pyx_v_6uvloop_4loop_ssl_SSLContext;
+    __Pyx_INCREF(__pyx_t_7);
+    __pyx_t_3 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_ssl, __pyx_t_7); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 1700, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":1701
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError('ssl argument must be an SSLContext or None')             # <<<<<<<<<<<<<<
+ *         else:
+ *             if ssl_handshake_timeout is not None:
+ */
+      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1701, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __PYX_ERR(0, 1701, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1700
+ * 
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):             # <<<<<<<<<<<<<<
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ */
+    }
+
+    /* "uvloop/loop.pyx":1699
+ *         server = Server(self)
+ * 
+ *         if ssl is not None:             # <<<<<<<<<<<<<<
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ */
+    goto __pyx_L11;
+  }
+
+  /* "uvloop/loop.pyx":1703
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+  /*else*/ {
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_ssl_handshake_timeout != Py_None);
+    __pyx_t_3 = (__pyx_t_1 != 0);
+    if (unlikely(__pyx_t_3)) {
+
+      /* "uvloop/loop.pyx":1704
+ *         else:
+ *             if ssl_handshake_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ */
+      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1704, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __PYX_ERR(0, 1704, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1703
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+    }
+
+    /* "uvloop/loop.pyx":1706
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    __pyx_t_3 = (__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout != Py_None);
+    __pyx_t_1 = (__pyx_t_3 != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":1707
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ */
+      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1707, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __PYX_ERR(0, 1707, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1706
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    }
+  }
+  __pyx_L11:;
+
+  /* "uvloop/loop.pyx":1710
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ *         if host is not None or port is not None:             # <<<<<<<<<<<<<<
+ *             if sock is not None:
+ *                 raise ValueError(
+ */
+  __pyx_t_3 = (__pyx_cur_scope->__pyx_v_host != Py_None);
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L16_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_port != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L16_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1711
+ * 
+ *         if host is not None or port is not None:
+ *             if sock is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ */
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
+    __pyx_t_3 = (__pyx_t_1 != 0);
+    if (unlikely(__pyx_t_3)) {
+
+      /* "uvloop/loop.pyx":1712
+ *         if host is not None or port is not None:
+ *             if sock is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'host/port and sock can not be specified at the same time')
+ * 
+ */
+      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1712, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __PYX_ERR(0, 1712, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1711
+ * 
+ *         if host is not None or port is not None:
+ *             if sock is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ */
+    }
+
+    /* "uvloop/loop.pyx":1715
+ *                     'host/port and sock can not be specified at the same time')
+ * 
+ *             if reuse_address is None:             # <<<<<<<<<<<<<<
+ *                 reuse_address = os_name == 'posix' and sys_platform != 'cygwin'
+ *             reuse_port = bool(reuse_port)
+ */
+    __pyx_t_3 = (__pyx_cur_scope->__pyx_v_reuse_address == Py_None);
+    __pyx_t_1 = (__pyx_t_3 != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/loop.pyx":1716
+ * 
+ *             if reuse_address is None:
+ *                 reuse_address = os_name == 'posix' and sys_platform != 'cygwin'             # <<<<<<<<<<<<<<
+ *             reuse_port = bool(reuse_port)
+ *             if reuse_port and not has_SO_REUSEPORT:
+ */
+      __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_6uvloop_4loop_os_name, __pyx_n_u_posix, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1716, __pyx_L1_error)
+      if (__pyx_t_1) {
+      } else {
+        __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1716, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_7 = __pyx_t_4;
+        __pyx_t_4 = 0;
+        goto __pyx_L20_bool_binop_done;
+      }
+      __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_6uvloop_4loop_sys_platform, __pyx_n_u_cygwin, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1716, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1716, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_7 = __pyx_t_4;
+      __pyx_t_4 = 0;
+      __pyx_L20_bool_binop_done:;
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_reuse_address);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_reuse_address, __pyx_t_7);
+      __Pyx_GIVEREF(__pyx_t_7);
+      __pyx_t_7 = 0;
+
+      /* "uvloop/loop.pyx":1715
+ *                     'host/port and sock can not be specified at the same time')
+ * 
+ *             if reuse_address is None:             # <<<<<<<<<<<<<<
+ *                 reuse_address = os_name == 'posix' and sys_platform != 'cygwin'
+ *             reuse_port = bool(reuse_port)
+ */
+    }
+
+    /* "uvloop/loop.pyx":1717
+ *             if reuse_address is None:
+ *                 reuse_address = os_name == 'posix' and sys_platform != 'cygwin'
+ *             reuse_port = bool(reuse_port)             # <<<<<<<<<<<<<<
+ *             if reuse_port and not has_SO_REUSEPORT:
+ *                 raise ValueError(
+ */
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1717, __pyx_L1_error)
+    __pyx_t_7 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1717, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_reuse_port);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_reuse_port, __pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_7);
+    __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":1718
+ *                 reuse_address = os_name == 'posix' and sys_platform != 'cygwin'
+ *             reuse_port = bool(reuse_port)
+ *             if reuse_port and not has_SO_REUSEPORT:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'reuse_port not supported by socket module')
+ */
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1718, __pyx_L1_error)
+    if (__pyx_t_3) {
+    } else {
+      __pyx_t_1 = __pyx_t_3;
+      goto __pyx_L23_bool_binop_done;
+    }
+    __pyx_t_3 = ((!(__pyx_v_6uvloop_4loop_has_SO_REUSEPORT != 0)) != 0);
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_L23_bool_binop_done:;
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":1719
+ *             reuse_port = bool(reuse_port)
+ *             if reuse_port and not has_SO_REUSEPORT:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'reuse_port not supported by socket module')
+ * 
+ */
+      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1719, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __PYX_ERR(0, 1719, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1718
+ *                 reuse_address = os_name == 'posix' and sys_platform != 'cygwin'
+ *             reuse_port = bool(reuse_port)
+ *             if reuse_port and not has_SO_REUSEPORT:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'reuse_port not supported by socket module')
+ */
+    }
+
+    /* "uvloop/loop.pyx":1722
+ *                     'reuse_port not supported by socket module')
+ * 
+ *             if host == '':             # <<<<<<<<<<<<<<
+ *                 hosts = [None]
+ *             elif (isinstance(host, str) or not isinstance(host, col_Iterable)):
+ */
+    __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_cur_scope->__pyx_v_host, __pyx_kp_u__8, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1722, __pyx_L1_error)
+    if (__pyx_t_1) {
+
+      /* "uvloop/loop.pyx":1723
+ * 
+ *             if host == '':
+ *                 hosts = [None]             # <<<<<<<<<<<<<<
+ *             elif (isinstance(host, str) or not isinstance(host, col_Iterable)):
+ *                 hosts = [host]
+ */
+      __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1723, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_INCREF(Py_None);
+      __Pyx_GIVEREF(Py_None);
+      PyList_SET_ITEM(__pyx_t_7, 0, Py_None);
+      __Pyx_GIVEREF(__pyx_t_7);
+      __pyx_cur_scope->__pyx_v_hosts = __pyx_t_7;
+      __pyx_t_7 = 0;
+
+      /* "uvloop/loop.pyx":1722
+ *                     'reuse_port not supported by socket module')
+ * 
+ *             if host == '':             # <<<<<<<<<<<<<<
+ *                 hosts = [None]
+ *             elif (isinstance(host, str) or not isinstance(host, col_Iterable)):
+ */
+      goto __pyx_L25;
+    }
+
+    /* "uvloop/loop.pyx":1724
+ *             if host == '':
+ *                 hosts = [None]
+ *             elif (isinstance(host, str) or not isinstance(host, col_Iterable)):             # <<<<<<<<<<<<<<
+ *                 hosts = [host]
+ *             else:
+ */
+    __pyx_t_3 = PyUnicode_Check(__pyx_cur_scope->__pyx_v_host); 
+    __pyx_t_2 = (__pyx_t_3 != 0);
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L26_bool_binop_done;
+    }
+    __pyx_t_7 = __pyx_v_6uvloop_4loop_col_Iterable;
+    __Pyx_INCREF(__pyx_t_7);
+    __pyx_t_2 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_host, __pyx_t_7); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 1724, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0);
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_L26_bool_binop_done:;
+    if (__pyx_t_1) {
+
+      /* "uvloop/loop.pyx":1725
+ *                 hosts = [None]
+ *             elif (isinstance(host, str) or not isinstance(host, col_Iterable)):
+ *                 hosts = [host]             # <<<<<<<<<<<<<<
+ *             else:
+ *                 hosts = host
+ */
+      __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1725, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_host);
+      __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_host);
+      PyList_SET_ITEM(__pyx_t_7, 0, __pyx_cur_scope->__pyx_v_host);
+      __Pyx_GIVEREF(__pyx_t_7);
+      __pyx_cur_scope->__pyx_v_hosts = __pyx_t_7;
+      __pyx_t_7 = 0;
+
+      /* "uvloop/loop.pyx":1724
+ *             if host == '':
+ *                 hosts = [None]
+ *             elif (isinstance(host, str) or not isinstance(host, col_Iterable)):             # <<<<<<<<<<<<<<
+ *                 hosts = [host]
+ *             else:
+ */
+      goto __pyx_L25;
+    }
+
+    /* "uvloop/loop.pyx":1727
+ *                 hosts = [host]
+ *             else:
+ *                 hosts = host             # <<<<<<<<<<<<<<
+ * 
+ *             fs = [self._getaddrinfo(host, port, family,
+ */
+    /*else*/ {
+      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_host);
+      __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_host);
+      __pyx_cur_scope->__pyx_v_hosts = __pyx_cur_scope->__pyx_v_host;
+    }
+    __pyx_L25:;
+
+    /* "uvloop/loop.pyx":1729
+ *                 hosts = host
+ * 
+ *             fs = [self._getaddrinfo(host, port, family,             # <<<<<<<<<<<<<<
+ *                                     uv.SOCK_STREAM, 0, flags,
+ *                                     0) for host in hosts]
+ */
+    { /* enter inner scope */
+      __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1729, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "uvloop/loop.pyx":1731
+ *             fs = [self._getaddrinfo(host, port, family,
+ *                                     uv.SOCK_STREAM, 0, flags,
+ *                                     0) for host in hosts]             # <<<<<<<<<<<<<<
+ * 
+ *             infos = await aio_gather(*fs)
+ */
+      if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_v_hosts)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_v_hosts)) {
+        __pyx_t_4 = __pyx_cur_scope->__pyx_v_hosts; __Pyx_INCREF(__pyx_t_4); __pyx_t_8 = 0;
+        __pyx_t_9 = NULL;
+      } else {
+        __pyx_t_8 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_cur_scope->__pyx_v_hosts); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1731, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_9 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1731, __pyx_L1_error)
+      }
+      for (;;) {
+        if (likely(!__pyx_t_9)) {
+          if (likely(PyList_CheckExact(__pyx_t_4))) {
+            if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_4)) break;
+            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+            __pyx_t_5 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_8); __Pyx_INCREF(__pyx_t_5); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 1731, __pyx_L1_error)
+            #else
+            __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1731, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            #endif
+          } else {
+            if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
+            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+            __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_8); __Pyx_INCREF(__pyx_t_5); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 1731, __pyx_L1_error)
+            #else
+            __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1731, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            #endif
+          }
+        } else {
+          __pyx_t_5 = __pyx_t_9(__pyx_t_4);
+          if (unlikely(!__pyx_t_5)) {
+            PyObject* exc_type = PyErr_Occurred();
+            if (exc_type) {
+              if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+              else __PYX_ERR(0, 1731, __pyx_L1_error)
+            }
+            break;
+          }
+          __Pyx_GOTREF(__pyx_t_5);
+        }
+        __Pyx_XGOTREF(__pyx_cur_scope->__pyx_7genexpr__pyx_v_host);
+        __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_7genexpr__pyx_v_host, __pyx_t_5);
+        __Pyx_GIVEREF(__pyx_t_5);
+        __pyx_t_5 = 0;
+
+        /* "uvloop/loop.pyx":1729
+ *                 hosts = host
+ * 
+ *             fs = [self._getaddrinfo(host, port, family,             # <<<<<<<<<<<<<<
+ *                                     uv.SOCK_STREAM, 0, flags,
+ *                                     0) for host in hosts]
+ */
+        __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_7genexpr__pyx_v_host, __pyx_cur_scope->__pyx_v_port, __pyx_cur_scope->__pyx_v_family, SOCK_STREAM, 0, __pyx_cur_scope->__pyx_v_flags, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1729, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        if (unlikely(__Pyx_ListComp_Append(__pyx_t_7, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 1729, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/loop.pyx":1731
+ *             fs = [self._getaddrinfo(host, port, family,
+ *                                     uv.SOCK_STREAM, 0, flags,
+ *                                     0) for host in hosts]             # <<<<<<<<<<<<<<
+ * 
+ *             infos = await aio_gather(*fs)
+ */
+      }
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } /* exit inner scope */
+    __Pyx_GIVEREF(__pyx_t_7);
+    __pyx_cur_scope->__pyx_v_fs = ((PyObject*)__pyx_t_7);
+    __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":1733
+ *                                     0) for host in hosts]
+ * 
+ *             infos = await aio_gather(*fs)             # <<<<<<<<<<<<<<
+ * 
+ *             completed = False
+ */
+    __pyx_t_7 = PySequence_Tuple(__pyx_cur_scope->__pyx_v_fs); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1733, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_gather, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1733, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XGOTREF(__pyx_r);
+    if (likely(__pyx_r)) {
+      __Pyx_XGIVEREF(__pyx_r);
+      __Pyx_RefNannyFinishContext();
+      __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+      /* return from generator, awaiting value */
+      __pyx_generator->resume_label = 2;
+      return __pyx_r;
+      __pyx_L30_resume_from_await:;
+      if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1733, __pyx_L1_error)
+      __pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4);
+    } else {
+      __pyx_t_4 = NULL;
+      if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(0, 1733, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+    }
+    __Pyx_GIVEREF(__pyx_t_4);
+    __pyx_cur_scope->__pyx_v_infos = __pyx_t_4;
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":1735
+ *             infos = await aio_gather(*fs)
+ * 
+ *             completed = False             # <<<<<<<<<<<<<<
+ *             sock = None
+ *             try:
+ */
+    __pyx_cur_scope->__pyx_v_completed = 0;
+
+    /* "uvloop/loop.pyx":1736
+ * 
+ *             completed = False
+ *             sock = None             # <<<<<<<<<<<<<<
+ *             try:
+ *                 for info in infos:
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_sock);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_sock, Py_None);
+    __Pyx_GIVEREF(Py_None);
+
+    /* "uvloop/loop.pyx":1737
+ *             completed = False
+ *             sock = None
+ *             try:             # <<<<<<<<<<<<<<
+ *                 for info in infos:
+ *                     addrinfo = (<AddrInfo>info).data
+ */
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":1738
+ *             sock = None
+ *             try:
+ *                 for info in infos:             # <<<<<<<<<<<<<<
+ *                     addrinfo = (<AddrInfo>info).data
+ *                     while addrinfo != NULL:
+ */
+      if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_v_infos)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_v_infos)) {
+        __pyx_t_4 = __pyx_cur_scope->__pyx_v_infos; __Pyx_INCREF(__pyx_t_4); __pyx_t_8 = 0;
+        __pyx_t_9 = NULL;
+      } else {
+        __pyx_t_8 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_cur_scope->__pyx_v_infos); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1738, __pyx_L32_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_9 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1738, __pyx_L32_error)
+      }
+      for (;;) {
+        if (likely(!__pyx_t_9)) {
+          if (likely(PyList_CheckExact(__pyx_t_4))) {
+            if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_4)) break;
+            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+            __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 1738, __pyx_L32_error)
+            #else
+            __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1738, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_7);
+            #endif
+          } else {
+            if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
+            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+            __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 1738, __pyx_L32_error)
+            #else
+            __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1738, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_7);
+            #endif
+          }
+        } else {
+          __pyx_t_7 = __pyx_t_9(__pyx_t_4);
+          if (unlikely(!__pyx_t_7)) {
+            PyObject* exc_type = PyErr_Occurred();
+            if (exc_type) {
+              if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+              else __PYX_ERR(0, 1738, __pyx_L32_error)
+            }
+            break;
+          }
+          __Pyx_GOTREF(__pyx_t_7);
+        }
+        __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_info);
+        __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_info, __pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_7);
+        __pyx_t_7 = 0;
+
+        /* "uvloop/loop.pyx":1739
+ *             try:
+ *                 for info in infos:
+ *                     addrinfo = (<AddrInfo>info).data             # <<<<<<<<<<<<<<
+ *                     while addrinfo != NULL:
+ *                         if addrinfo.ai_family == uv.AF_UNSPEC:
+ */
+        __pyx_t_10 = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_cur_scope->__pyx_v_info)->data;
+        __pyx_cur_scope->__pyx_v_addrinfo = __pyx_t_10;
+
+        /* "uvloop/loop.pyx":1740
+ *                 for info in infos:
+ *                     addrinfo = (<AddrInfo>info).data
+ *                     while addrinfo != NULL:             # <<<<<<<<<<<<<<
+ *                         if addrinfo.ai_family == uv.AF_UNSPEC:
+ *                             raise RuntimeError('AF_UNSPEC in DNS results')
+ */
+        while (1) {
+          __pyx_t_1 = ((__pyx_cur_scope->__pyx_v_addrinfo != NULL) != 0);
+          if (!__pyx_t_1) break;
+
+          /* "uvloop/loop.pyx":1741
+ *                     addrinfo = (<AddrInfo>info).data
+ *                     while addrinfo != NULL:
+ *                         if addrinfo.ai_family == uv.AF_UNSPEC:             # <<<<<<<<<<<<<<
+ *                             raise RuntimeError('AF_UNSPEC in DNS results')
+ * 
+ */
+          __pyx_t_1 = ((__pyx_cur_scope->__pyx_v_addrinfo->ai_family == AF_UNSPEC) != 0);
+          if (unlikely(__pyx_t_1)) {
+
+            /* "uvloop/loop.pyx":1742
+ *                     while addrinfo != NULL:
+ *                         if addrinfo.ai_family == uv.AF_UNSPEC:
+ *                             raise RuntimeError('AF_UNSPEC in DNS results')             # <<<<<<<<<<<<<<
+ * 
+ *                         try:
+ */
+            __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1742, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_7);
+            __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+            __PYX_ERR(0, 1742, __pyx_L32_error)
+
+            /* "uvloop/loop.pyx":1741
+ *                     addrinfo = (<AddrInfo>info).data
+ *                     while addrinfo != NULL:
+ *                         if addrinfo.ai_family == uv.AF_UNSPEC:             # <<<<<<<<<<<<<<
+ *                             raise RuntimeError('AF_UNSPEC in DNS results')
+ * 
+ */
+          }
+
+          /* "uvloop/loop.pyx":1744
+ *                             raise RuntimeError('AF_UNSPEC in DNS results')
+ * 
+ *                         try:             # <<<<<<<<<<<<<<
+ *                             sock = socket_socket(addrinfo.ai_family,
+ *                                                  addrinfo.ai_socktype,
+ */
+          {
+            __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+            __Pyx_XGOTREF(__pyx_t_11);
+            __Pyx_XGOTREF(__pyx_t_12);
+            __Pyx_XGOTREF(__pyx_t_13);
+            /*try:*/ {
+
+              /* "uvloop/loop.pyx":1745
+ * 
+ *                         try:
+ *                             sock = socket_socket(addrinfo.ai_family,             # <<<<<<<<<<<<<<
+ *                                                  addrinfo.ai_socktype,
+ *                                                  addrinfo.ai_protocol)
+ */
+              __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_addrinfo->ai_family); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1745, __pyx_L39_error)
+              __Pyx_GOTREF(__pyx_t_5);
+
+              /* "uvloop/loop.pyx":1746
+ *                         try:
+ *                             sock = socket_socket(addrinfo.ai_family,
+ *                                                  addrinfo.ai_socktype,             # <<<<<<<<<<<<<<
+ *                                                  addrinfo.ai_protocol)
+ *                         except socket_error:
+ */
+              __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_addrinfo->ai_socktype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1746, __pyx_L39_error)
+              __Pyx_GOTREF(__pyx_t_6);
+
+              /* "uvloop/loop.pyx":1747
+ *                             sock = socket_socket(addrinfo.ai_family,
+ *                                                  addrinfo.ai_socktype,
+ *                                                  addrinfo.ai_protocol)             # <<<<<<<<<<<<<<
+ *                         except socket_error:
+ *                             # Assume it's a bad family/type/protocol
+ */
+              __pyx_t_14 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_addrinfo->ai_protocol); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1747, __pyx_L39_error)
+              __Pyx_GOTREF(__pyx_t_14);
+              __Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_socket);
+              __pyx_t_15 = __pyx_v_6uvloop_4loop_socket_socket; __pyx_t_16 = NULL;
+              __pyx_t_17 = 0;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_15))) {
+                __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_15);
+                if (likely(__pyx_t_16)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
+                  __Pyx_INCREF(__pyx_t_16);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_15, function);
+                  __pyx_t_17 = 1;
+                }
+              }
+              #if CYTHON_FAST_PYCALL
+              if (PyFunction_Check(__pyx_t_15)) {
+                PyObject *__pyx_temp[4] = {__pyx_t_16, __pyx_t_5, __pyx_t_6, __pyx_t_14};
+                __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1745, __pyx_L39_error)
+                __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+                __Pyx_GOTREF(__pyx_t_7);
+                __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+                __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+              } else
+              #endif
+              #if CYTHON_FAST_PYCCALL
+              if (__Pyx_PyFastCFunction_Check(__pyx_t_15)) {
+                PyObject *__pyx_temp[4] = {__pyx_t_16, __pyx_t_5, __pyx_t_6, __pyx_t_14};
+                __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1745, __pyx_L39_error)
+                __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+                __Pyx_GOTREF(__pyx_t_7);
+                __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+                __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+              } else
+              #endif
+              {
+                __pyx_t_18 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1745, __pyx_L39_error)
+                __Pyx_GOTREF(__pyx_t_18);
+                if (__pyx_t_16) {
+                  __Pyx_GIVEREF(__pyx_t_16); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_16); __pyx_t_16 = NULL;
+                }
+                __Pyx_GIVEREF(__pyx_t_5);
+                PyTuple_SET_ITEM(__pyx_t_18, 0+__pyx_t_17, __pyx_t_5);
+                __Pyx_GIVEREF(__pyx_t_6);
+                PyTuple_SET_ITEM(__pyx_t_18, 1+__pyx_t_17, __pyx_t_6);
+                __Pyx_GIVEREF(__pyx_t_14);
+                PyTuple_SET_ITEM(__pyx_t_18, 2+__pyx_t_17, __pyx_t_14);
+                __pyx_t_5 = 0;
+                __pyx_t_6 = 0;
+                __pyx_t_14 = 0;
+                __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_18, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1745, __pyx_L39_error)
+                __Pyx_GOTREF(__pyx_t_7);
+                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+              }
+              __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+              __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_sock);
+              __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_sock, __pyx_t_7);
+              __Pyx_GIVEREF(__pyx_t_7);
+              __pyx_t_7 = 0;
+
+              /* "uvloop/loop.pyx":1744
+ *                             raise RuntimeError('AF_UNSPEC in DNS results')
+ * 
+ *                         try:             # <<<<<<<<<<<<<<
+ *                             sock = socket_socket(addrinfo.ai_family,
+ *                                                  addrinfo.ai_socktype,
+ */
+            }
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            goto __pyx_L46_try_end;
+            __pyx_L39_error:;
+            __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+            __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+            __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+            /* "uvloop/loop.pyx":1748
+ *                                                  addrinfo.ai_socktype,
+ *                                                  addrinfo.ai_protocol)
+ *                         except socket_error:             # <<<<<<<<<<<<<<
+ *                             # Assume it's a bad family/type/protocol
+ *                             # combination.
+ */
+            __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_socket_error);
+            if (__pyx_t_17) {
+              __Pyx_AddTraceback("uvloop.loop.Loop.create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+              if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_15, &__pyx_t_18) < 0) __PYX_ERR(0, 1748, __pyx_L41_except_error)
+              __Pyx_GOTREF(__pyx_t_7);
+              __Pyx_GOTREF(__pyx_t_15);
+              __Pyx_GOTREF(__pyx_t_18);
+
+              /* "uvloop/loop.pyx":1751
+ *                             # Assume it's a bad family/type/protocol
+ *                             # combination.
+ *                             if self._debug:             # <<<<<<<<<<<<<<
+ *                                 aio_logger.warning(
+ *                                     'create_server() failed to create '
+ */
+              __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->_debug != 0);
+              if (__pyx_t_1) {
+
+                /* "uvloop/loop.pyx":1752
+ *                             # combination.
+ *                             if self._debug:
+ *                                 aio_logger.warning(             # <<<<<<<<<<<<<<
+ *                                     'create_server() failed to create '
+ *                                     'socket.socket(%r, %r, %r)',
+ */
+                __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_warning); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1752, __pyx_L41_except_error)
+                __Pyx_GOTREF(__pyx_t_14);
+
+                /* "uvloop/loop.pyx":1755
+ *                                     'create_server() failed to create '
+ *                                     'socket.socket(%r, %r, %r)',
+ *                                     addrinfo.ai_family,             # <<<<<<<<<<<<<<
+ *                                     addrinfo.ai_socktype,
+ *                                     addrinfo.ai_protocol, exc_info=True)
+ */
+                __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_addrinfo->ai_family); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1755, __pyx_L41_except_error)
+                __Pyx_GOTREF(__pyx_t_6);
+
+                /* "uvloop/loop.pyx":1756
+ *                                     'socket.socket(%r, %r, %r)',
+ *                                     addrinfo.ai_family,
+ *                                     addrinfo.ai_socktype,             # <<<<<<<<<<<<<<
+ *                                     addrinfo.ai_protocol, exc_info=True)
+ *                             continue
+ */
+                __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_addrinfo->ai_socktype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1756, __pyx_L41_except_error)
+                __Pyx_GOTREF(__pyx_t_5);
+
+                /* "uvloop/loop.pyx":1757
+ *                                     addrinfo.ai_family,
+ *                                     addrinfo.ai_socktype,
+ *                                     addrinfo.ai_protocol, exc_info=True)             # <<<<<<<<<<<<<<
+ *                             continue
+ * 
+ */
+                __pyx_t_16 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_addrinfo->ai_protocol); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1757, __pyx_L41_except_error)
+                __Pyx_GOTREF(__pyx_t_16);
+
+                /* "uvloop/loop.pyx":1752
+ *                             # combination.
+ *                             if self._debug:
+ *                                 aio_logger.warning(             # <<<<<<<<<<<<<<
+ *                                     'create_server() failed to create '
+ *                                     'socket.socket(%r, %r, %r)',
+ */
+                __pyx_t_19 = PyTuple_New(4); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 1752, __pyx_L41_except_error)
+                __Pyx_GOTREF(__pyx_t_19);
+                __Pyx_INCREF(__pyx_kp_u_create_server_failed_to_create_s);
+                __Pyx_GIVEREF(__pyx_kp_u_create_server_failed_to_create_s);
+                PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_kp_u_create_server_failed_to_create_s);
+                __Pyx_GIVEREF(__pyx_t_6);
+                PyTuple_SET_ITEM(__pyx_t_19, 1, __pyx_t_6);
+                __Pyx_GIVEREF(__pyx_t_5);
+                PyTuple_SET_ITEM(__pyx_t_19, 2, __pyx_t_5);
+                __Pyx_GIVEREF(__pyx_t_16);
+                PyTuple_SET_ITEM(__pyx_t_19, 3, __pyx_t_16);
+                __pyx_t_6 = 0;
+                __pyx_t_5 = 0;
+                __pyx_t_16 = 0;
+
+                /* "uvloop/loop.pyx":1757
+ *                                     addrinfo.ai_family,
+ *                                     addrinfo.ai_socktype,
+ *                                     addrinfo.ai_protocol, exc_info=True)             # <<<<<<<<<<<<<<
+ *                             continue
+ * 
+ */
+                __pyx_t_16 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1757, __pyx_L41_except_error)
+                __Pyx_GOTREF(__pyx_t_16);
+                if (PyDict_SetItem(__pyx_t_16, __pyx_n_s_exc_info, Py_True) < 0) __PYX_ERR(0, 1757, __pyx_L41_except_error)
+
+                /* "uvloop/loop.pyx":1752
+ *                             # combination.
+ *                             if self._debug:
+ *                                 aio_logger.warning(             # <<<<<<<<<<<<<<
+ *                                     'create_server() failed to create '
+ *                                     'socket.socket(%r, %r, %r)',
+ */
+                __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_19, __pyx_t_16); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1752, __pyx_L41_except_error)
+                __Pyx_GOTREF(__pyx_t_5);
+                __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+                __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+                __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+                __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+                /* "uvloop/loop.pyx":1751
+ *                             # Assume it's a bad family/type/protocol
+ *                             # combination.
+ *                             if self._debug:             # <<<<<<<<<<<<<<
+ *                                 aio_logger.warning(
+ *                                     'create_server() failed to create '
+ */
+              }
+
+              /* "uvloop/loop.pyx":1758
+ *                                     addrinfo.ai_socktype,
+ *                                     addrinfo.ai_protocol, exc_info=True)
+ *                             continue             # <<<<<<<<<<<<<<
+ * 
+ *                         if reuse_address:
+ */
+              goto __pyx_L48_except_continue;
+              __pyx_L48_except_continue:;
+              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+              __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+              goto __pyx_L45_try_continue;
+            }
+            goto __pyx_L41_except_error;
+            __pyx_L41_except_error:;
+
+            /* "uvloop/loop.pyx":1744
+ *                             raise RuntimeError('AF_UNSPEC in DNS results')
+ * 
+ *                         try:             # <<<<<<<<<<<<<<
+ *                             sock = socket_socket(addrinfo.ai_family,
+ *                                                  addrinfo.ai_socktype,
+ */
+            __Pyx_XGIVEREF(__pyx_t_11);
+            __Pyx_XGIVEREF(__pyx_t_12);
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+            goto __pyx_L32_error;
+            __pyx_L45_try_continue:;
+            __Pyx_XGIVEREF(__pyx_t_11);
+            __Pyx_XGIVEREF(__pyx_t_12);
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+            goto __pyx_L36_continue;
+            __pyx_L46_try_end:;
+          }
+
+          /* "uvloop/loop.pyx":1760
+ *                             continue
+ * 
+ *                         if reuse_address:             # <<<<<<<<<<<<<<
+ *                             sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEADDR, 1)
+ *                         if reuse_port:
+ */
+          __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_address); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1760, __pyx_L32_error)
+          if (__pyx_t_1) {
+
+            /* "uvloop/loop.pyx":1761
+ * 
+ *                         if reuse_address:
+ *                             sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEADDR, 1)             # <<<<<<<<<<<<<<
+ *                         if reuse_port:
+ *                             sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEPORT, 1)
+ */
+            __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_setsockopt); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1761, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_15);
+            __pyx_t_7 = __Pyx_PyInt_From_int(SOL_SOCKET); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1761, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_7);
+            __pyx_t_5 = __Pyx_PyInt_From_int(SO_REUSEADDR); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1761, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __pyx_t_16 = NULL;
+            __pyx_t_17 = 0;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_15))) {
+              __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_15);
+              if (likely(__pyx_t_16)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
+                __Pyx_INCREF(__pyx_t_16);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_15, function);
+                __pyx_t_17 = 1;
+              }
+            }
+            #if CYTHON_FAST_PYCALL
+            if (PyFunction_Check(__pyx_t_15)) {
+              PyObject *__pyx_temp[4] = {__pyx_t_16, __pyx_t_7, __pyx_t_5, __pyx_int_1};
+              __pyx_t_18 = __Pyx_PyFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1761, __pyx_L32_error)
+              __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+            } else
+            #endif
+            #if CYTHON_FAST_PYCCALL
+            if (__Pyx_PyFastCFunction_Check(__pyx_t_15)) {
+              PyObject *__pyx_temp[4] = {__pyx_t_16, __pyx_t_7, __pyx_t_5, __pyx_int_1};
+              __pyx_t_18 = __Pyx_PyCFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1761, __pyx_L32_error)
+              __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+            } else
+            #endif
+            {
+              __pyx_t_19 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 1761, __pyx_L32_error)
+              __Pyx_GOTREF(__pyx_t_19);
+              if (__pyx_t_16) {
+                __Pyx_GIVEREF(__pyx_t_16); PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_16); __pyx_t_16 = NULL;
+              }
+              __Pyx_GIVEREF(__pyx_t_7);
+              PyTuple_SET_ITEM(__pyx_t_19, 0+__pyx_t_17, __pyx_t_7);
+              __Pyx_GIVEREF(__pyx_t_5);
+              PyTuple_SET_ITEM(__pyx_t_19, 1+__pyx_t_17, __pyx_t_5);
+              __Pyx_INCREF(__pyx_int_1);
+              __Pyx_GIVEREF(__pyx_int_1);
+              PyTuple_SET_ITEM(__pyx_t_19, 2+__pyx_t_17, __pyx_int_1);
+              __pyx_t_7 = 0;
+              __pyx_t_5 = 0;
+              __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_19, NULL); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1761, __pyx_L32_error)
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+            }
+            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+
+            /* "uvloop/loop.pyx":1760
+ *                             continue
+ * 
+ *                         if reuse_address:             # <<<<<<<<<<<<<<
+ *                             sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEADDR, 1)
+ *                         if reuse_port:
+ */
+          }
+
+          /* "uvloop/loop.pyx":1762
+ *                         if reuse_address:
+ *                             sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEADDR, 1)
+ *                         if reuse_port:             # <<<<<<<<<<<<<<
+ *                             sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEPORT, 1)
+ *                         # Disable IPv4/IPv6 dual stack support (enabled by
+ */
+          __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1762, __pyx_L32_error)
+          if (__pyx_t_1) {
+
+            /* "uvloop/loop.pyx":1763
+ *                             sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEADDR, 1)
+ *                         if reuse_port:
+ *                             sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEPORT, 1)             # <<<<<<<<<<<<<<
+ *                         # Disable IPv4/IPv6 dual stack support (enabled by
+ *                         # default on Linux) which makes a single socket
+ */
+            __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_setsockopt); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1763, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_15);
+            __pyx_t_19 = __Pyx_PyInt_From_int(SOL_SOCKET); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 1763, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_19);
+            __pyx_t_5 = __Pyx_PyInt_From_int(SO_REUSEPORT); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1763, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __pyx_t_7 = NULL;
+            __pyx_t_17 = 0;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_15))) {
+              __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_15);
+              if (likely(__pyx_t_7)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
+                __Pyx_INCREF(__pyx_t_7);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_15, function);
+                __pyx_t_17 = 1;
+              }
+            }
+            #if CYTHON_FAST_PYCALL
+            if (PyFunction_Check(__pyx_t_15)) {
+              PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_19, __pyx_t_5, __pyx_int_1};
+              __pyx_t_18 = __Pyx_PyFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1763, __pyx_L32_error)
+              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+            } else
+            #endif
+            #if CYTHON_FAST_PYCCALL
+            if (__Pyx_PyFastCFunction_Check(__pyx_t_15)) {
+              PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_19, __pyx_t_5, __pyx_int_1};
+              __pyx_t_18 = __Pyx_PyCFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1763, __pyx_L32_error)
+              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+            } else
+            #endif
+            {
+              __pyx_t_16 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1763, __pyx_L32_error)
+              __Pyx_GOTREF(__pyx_t_16);
+              if (__pyx_t_7) {
+                __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_7); __pyx_t_7 = NULL;
+              }
+              __Pyx_GIVEREF(__pyx_t_19);
+              PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_17, __pyx_t_19);
+              __Pyx_GIVEREF(__pyx_t_5);
+              PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_17, __pyx_t_5);
+              __Pyx_INCREF(__pyx_int_1);
+              __Pyx_GIVEREF(__pyx_int_1);
+              PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_17, __pyx_int_1);
+              __pyx_t_19 = 0;
+              __pyx_t_5 = 0;
+              __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_16, NULL); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1763, __pyx_L32_error)
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+            }
+            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+
+            /* "uvloop/loop.pyx":1762
+ *                         if reuse_address:
+ *                             sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEADDR, 1)
+ *                         if reuse_port:             # <<<<<<<<<<<<<<
+ *                             sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEPORT, 1)
+ *                         # Disable IPv4/IPv6 dual stack support (enabled by
+ */
+          }
+
+          /* "uvloop/loop.pyx":1767
+ *                         # default on Linux) which makes a single socket
+ *                         # listen on both address families.
+ *                         if (addrinfo.ai_family == uv.AF_INET6 and             # <<<<<<<<<<<<<<
+ *                                 has_IPV6_V6ONLY):
+ *                             sock.setsockopt(uv.IPPROTO_IPV6, IPV6_V6ONLY, 1)
+ */
+          __pyx_t_3 = ((__pyx_cur_scope->__pyx_v_addrinfo->ai_family == AF_INET6) != 0);
+          if (__pyx_t_3) {
+          } else {
+            __pyx_t_1 = __pyx_t_3;
+            goto __pyx_L53_bool_binop_done;
+          }
+
+          /* "uvloop/loop.pyx":1768
+ *                         # listen on both address families.
+ *                         if (addrinfo.ai_family == uv.AF_INET6 and
+ *                                 has_IPV6_V6ONLY):             # <<<<<<<<<<<<<<
+ *                             sock.setsockopt(uv.IPPROTO_IPV6, IPV6_V6ONLY, 1)
+ * 
+ */
+          __pyx_t_3 = (__pyx_v_6uvloop_4loop_has_IPV6_V6ONLY != 0);
+          __pyx_t_1 = __pyx_t_3;
+          __pyx_L53_bool_binop_done:;
+
+          /* "uvloop/loop.pyx":1767
+ *                         # default on Linux) which makes a single socket
+ *                         # listen on both address families.
+ *                         if (addrinfo.ai_family == uv.AF_INET6 and             # <<<<<<<<<<<<<<
+ *                                 has_IPV6_V6ONLY):
+ *                             sock.setsockopt(uv.IPPROTO_IPV6, IPV6_V6ONLY, 1)
+ */
+          if (__pyx_t_1) {
+
+            /* "uvloop/loop.pyx":1769
+ *                         if (addrinfo.ai_family == uv.AF_INET6 and
+ *                                 has_IPV6_V6ONLY):
+ *                             sock.setsockopt(uv.IPPROTO_IPV6, IPV6_V6ONLY, 1)             # <<<<<<<<<<<<<<
+ * 
+ *                         pyaddr = __convert_sockaddr_to_pyaddr(addrinfo.ai_addr)
+ */
+            __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_setsockopt); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1769, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_15);
+            __pyx_t_16 = __Pyx_PyInt_From_int(IPPROTO_IPV6); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1769, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_16);
+            __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_IPV6_V6ONLY); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1769, __pyx_L32_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __pyx_t_19 = NULL;
+            __pyx_t_17 = 0;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_15))) {
+              __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_15);
+              if (likely(__pyx_t_19)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
+                __Pyx_INCREF(__pyx_t_19);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_15, function);
+                __pyx_t_17 = 1;
+              }
+            }
+            #if CYTHON_FAST_PYCALL
+            if (PyFunction_Check(__pyx_t_15)) {
+              PyObject *__pyx_temp[4] = {__pyx_t_19, __pyx_t_16, __pyx_t_5, __pyx_int_1};
+              __pyx_t_18 = __Pyx_PyFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1769, __pyx_L32_error)
+              __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+            } else
+            #endif
+            #if CYTHON_FAST_PYCCALL
+            if (__Pyx_PyFastCFunction_Check(__pyx_t_15)) {
+              PyObject *__pyx_temp[4] = {__pyx_t_19, __pyx_t_16, __pyx_t_5, __pyx_int_1};
+              __pyx_t_18 = __Pyx_PyCFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1769, __pyx_L32_error)
+              __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+            } else
+            #endif
+            {
+              __pyx_t_7 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1769, __pyx_L32_error)
+              __Pyx_GOTREF(__pyx_t_7);
+              if (__pyx_t_19) {
+                __Pyx_GIVEREF(__pyx_t_19); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_19); __pyx_t_19 = NULL;
+              }
+              __Pyx_GIVEREF(__pyx_t_16);
+              PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_17, __pyx_t_16);
+              __Pyx_GIVEREF(__pyx_t_5);
+              PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_17, __pyx_t_5);
+              __Pyx_INCREF(__pyx_int_1);
+              __Pyx_GIVEREF(__pyx_int_1);
+              PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_17, __pyx_int_1);
+              __pyx_t_16 = 0;
+              __pyx_t_5 = 0;
+              __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_7, NULL); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1769, __pyx_L32_error)
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+            }
+            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+
+            /* "uvloop/loop.pyx":1767
+ *                         # default on Linux) which makes a single socket
+ *                         # listen on both address families.
+ *                         if (addrinfo.ai_family == uv.AF_INET6 and             # <<<<<<<<<<<<<<
+ *                                 has_IPV6_V6ONLY):
+ *                             sock.setsockopt(uv.IPPROTO_IPV6, IPV6_V6ONLY, 1)
+ */
+          }
+
+          /* "uvloop/loop.pyx":1771
+ *                             sock.setsockopt(uv.IPPROTO_IPV6, IPV6_V6ONLY, 1)
+ * 
+ *                         pyaddr = __convert_sockaddr_to_pyaddr(addrinfo.ai_addr)             # <<<<<<<<<<<<<<
+ *                         try:
+ *                             sock.bind(pyaddr)
+ */
+          __pyx_t_18 = __pyx_f_6uvloop_4loop___convert_sockaddr_to_pyaddr(__pyx_cur_scope->__pyx_v_addrinfo->ai_addr); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1771, __pyx_L32_error)
+          __Pyx_GOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_pyaddr);
+          __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_pyaddr, __pyx_t_18);
+          __Pyx_GIVEREF(__pyx_t_18);
+          __pyx_t_18 = 0;
+
+          /* "uvloop/loop.pyx":1772
+ * 
+ *                         pyaddr = __convert_sockaddr_to_pyaddr(addrinfo.ai_addr)
+ *                         try:             # <<<<<<<<<<<<<<
+ *                             sock.bind(pyaddr)
+ *                         except OSError as err:
+ */
+          {
+            __Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11);
+            __Pyx_XGOTREF(__pyx_t_13);
+            __Pyx_XGOTREF(__pyx_t_12);
+            __Pyx_XGOTREF(__pyx_t_11);
+            /*try:*/ {
+
+              /* "uvloop/loop.pyx":1773
+ *                         pyaddr = __convert_sockaddr_to_pyaddr(addrinfo.ai_addr)
+ *                         try:
+ *                             sock.bind(pyaddr)             # <<<<<<<<<<<<<<
+ *                         except OSError as err:
+ *                             raise OSError(
+ */
+              __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_bind); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1773, __pyx_L55_error)
+              __Pyx_GOTREF(__pyx_t_15);
+              __pyx_t_7 = NULL;
+              if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_15))) {
+                __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_15);
+                if (likely(__pyx_t_7)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
+                  __Pyx_INCREF(__pyx_t_7);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_15, function);
+                }
+              }
+              __pyx_t_18 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_15, __pyx_t_7, __pyx_cur_scope->__pyx_v_pyaddr) : __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_cur_scope->__pyx_v_pyaddr);
+              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+              if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1773, __pyx_L55_error)
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+
+              /* "uvloop/loop.pyx":1772
+ * 
+ *                         pyaddr = __convert_sockaddr_to_pyaddr(addrinfo.ai_addr)
+ *                         try:             # <<<<<<<<<<<<<<
+ *                             sock.bind(pyaddr)
+ *                         except OSError as err:
+ */
+            }
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            goto __pyx_L62_try_end;
+            __pyx_L55_error:;
+            __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+            __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+            __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+            __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+            /* "uvloop/loop.pyx":1774
+ *                         try:
+ *                             sock.bind(pyaddr)
+ *                         except OSError as err:             # <<<<<<<<<<<<<<
+ *                             raise OSError(
+ *                                 err.errno, 'error while attempting '
+ */
+            __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
+            if (__pyx_t_17) {
+              __Pyx_AddTraceback("uvloop.loop.Loop.create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+              if (__Pyx_GetException(&__pyx_t_18, &__pyx_t_15, &__pyx_t_7) < 0) __PYX_ERR(0, 1774, __pyx_L57_except_error)
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_GOTREF(__pyx_t_15);
+              __Pyx_GOTREF(__pyx_t_7);
+              __Pyx_INCREF(__pyx_t_15);
+              __Pyx_GIVEREF(__pyx_t_15);
+              __pyx_cur_scope->__pyx_v_err = __pyx_t_15;
+              /*try:*/ {
+
+                /* "uvloop/loop.pyx":1776
+ *                         except OSError as err:
+ *                             raise OSError(
+ *                                 err.errno, 'error while attempting '             # <<<<<<<<<<<<<<
+ *                                 'to bind on address %r: %s'
+ *                                 % (pyaddr, err.strerror.lower())) from None
+ */
+                __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_err, __pyx_n_s_errno); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1776, __pyx_L68_error)
+                __Pyx_GOTREF(__pyx_t_5);
+                __pyx_t_16 = PyTuple_New(4); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1776, __pyx_L68_error)
+                __Pyx_GOTREF(__pyx_t_16);
+                __pyx_t_20 = 0;
+                __pyx_t_21 = 127;
+                __Pyx_INCREF(__pyx_kp_u_error_while_attempting_to_bind_o);
+                __pyx_t_20 += 42;
+                __Pyx_GIVEREF(__pyx_kp_u_error_while_attempting_to_bind_o);
+                PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_kp_u_error_while_attempting_to_bind_o);
+
+                /* "uvloop/loop.pyx":1778
+ *                                 err.errno, 'error while attempting '
+ *                                 'to bind on address %r: %s'
+ *                                 % (pyaddr, err.strerror.lower())) from None             # <<<<<<<<<<<<<<
+ * 
+ *                         tcp = TCPServer.new(self, protocol_factory, server,
+ */
+                __pyx_t_19 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_cur_scope->__pyx_v_pyaddr), __pyx_empty_unicode); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 1778, __pyx_L68_error)
+                __Pyx_GOTREF(__pyx_t_19);
+                __pyx_t_21 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_19) > __pyx_t_21) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_19) : __pyx_t_21;
+                __pyx_t_20 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_19);
+                __Pyx_GIVEREF(__pyx_t_19);
+                PyTuple_SET_ITEM(__pyx_t_16, 1, __pyx_t_19);
+                __pyx_t_19 = 0;
+                __Pyx_INCREF(__pyx_kp_u__56);
+                __pyx_t_20 += 2;
+                __Pyx_GIVEREF(__pyx_kp_u__56);
+                PyTuple_SET_ITEM(__pyx_t_16, 2, __pyx_kp_u__56);
+                __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_err, __pyx_n_s_strerror); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1778, __pyx_L68_error)
+                __Pyx_GOTREF(__pyx_t_14);
+                __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_14, __pyx_n_s_lower); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1778, __pyx_L68_error)
+                __Pyx_GOTREF(__pyx_t_6);
+                __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+                __pyx_t_14 = NULL;
+                if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+                  __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_6);
+                  if (likely(__pyx_t_14)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+                    __Pyx_INCREF(__pyx_t_14);
+                    __Pyx_INCREF(function);
+                    __Pyx_DECREF_SET(__pyx_t_6, function);
+                  }
+                }
+                __pyx_t_19 = (__pyx_t_14) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_14) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+                __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+                if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 1778, __pyx_L68_error)
+                __Pyx_GOTREF(__pyx_t_19);
+                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+                __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Unicode(__pyx_t_19), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1778, __pyx_L68_error)
+                __Pyx_GOTREF(__pyx_t_6);
+                __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+                __pyx_t_21 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_21) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_21;
+                __pyx_t_20 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6);
+                __Pyx_GIVEREF(__pyx_t_6);
+                PyTuple_SET_ITEM(__pyx_t_16, 3, __pyx_t_6);
+                __pyx_t_6 = 0;
+
+                /* "uvloop/loop.pyx":1776
+ *                         except OSError as err:
+ *                             raise OSError(
+ *                                 err.errno, 'error while attempting '             # <<<<<<<<<<<<<<
+ *                                 'to bind on address %r: %s'
+ *                                 % (pyaddr, err.strerror.lower())) from None
+ */
+                __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_16, 4, __pyx_t_20, __pyx_t_21); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1776, __pyx_L68_error)
+                __Pyx_GOTREF(__pyx_t_6);
+                __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+                /* "uvloop/loop.pyx":1775
+ *                             sock.bind(pyaddr)
+ *                         except OSError as err:
+ *                             raise OSError(             # <<<<<<<<<<<<<<
+ *                                 err.errno, 'error while attempting '
+ *                                 'to bind on address %r: %s'
+ */
+                __pyx_t_16 = PyTuple_New(2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1775, __pyx_L68_error)
+                __Pyx_GOTREF(__pyx_t_16);
+                __Pyx_GIVEREF(__pyx_t_5);
+                PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_5);
+                __Pyx_GIVEREF(__pyx_t_6);
+                PyTuple_SET_ITEM(__pyx_t_16, 1, __pyx_t_6);
+                __pyx_t_5 = 0;
+                __pyx_t_6 = 0;
+                __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_16, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1775, __pyx_L68_error)
+                __Pyx_GOTREF(__pyx_t_6);
+                __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+                /* "uvloop/loop.pyx":1778
+ *                                 err.errno, 'error while attempting '
+ *                                 'to bind on address %r: %s'
+ *                                 % (pyaddr, err.strerror.lower())) from None             # <<<<<<<<<<<<<<
+ * 
+ *                         tcp = TCPServer.new(self, protocol_factory, server,
+ */
+                __Pyx_Raise(__pyx_t_6, 0, 0, Py_None);
+                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+                __PYX_ERR(0, 1775, __pyx_L68_error)
+              }
+
+              /* "uvloop/loop.pyx":1774
+ *                         try:
+ *                             sock.bind(pyaddr)
+ *                         except OSError as err:             # <<<<<<<<<<<<<<
+ *                             raise OSError(
+ *                                 err.errno, 'error while attempting '
+ */
+              /*finally:*/ {
+                __pyx_L68_error:;
+                /*exception exit:*/{
+                  __Pyx_PyThreadState_assign
+                  __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_t_29 = 0;
+                  __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+                  __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+                  __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+                  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+                  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+                  if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_27, &__pyx_t_28, &__pyx_t_29);
+                  if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_24, &__pyx_t_25, &__pyx_t_26) < 0)) __Pyx_ErrFetch(&__pyx_t_24, &__pyx_t_25, &__pyx_t_26);
+                  __Pyx_XGOTREF(__pyx_t_24);
+                  __Pyx_XGOTREF(__pyx_t_25);
+                  __Pyx_XGOTREF(__pyx_t_26);
+                  __Pyx_XGOTREF(__pyx_t_27);
+                  __Pyx_XGOTREF(__pyx_t_28);
+                  __Pyx_XGOTREF(__pyx_t_29);
+                  __pyx_t_17 = __pyx_lineno; __pyx_t_22 = __pyx_clineno; __pyx_t_23 = __pyx_filename;
+                  {
+                    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_err);
+                    __Pyx_DECREF(__pyx_cur_scope->__pyx_v_err);
+                    __pyx_cur_scope->__pyx_v_err = NULL;
+                  }
+                  if (PY_MAJOR_VERSION >= 3) {
+                    __Pyx_XGIVEREF(__pyx_t_27);
+                    __Pyx_XGIVEREF(__pyx_t_28);
+                    __Pyx_XGIVEREF(__pyx_t_29);
+                    __Pyx_ExceptionReset(__pyx_t_27, __pyx_t_28, __pyx_t_29);
+                  }
+                  __Pyx_XGIVEREF(__pyx_t_24);
+                  __Pyx_XGIVEREF(__pyx_t_25);
+                  __Pyx_XGIVEREF(__pyx_t_26);
+                  __Pyx_ErrRestore(__pyx_t_24, __pyx_t_25, __pyx_t_26);
+                  __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_t_29 = 0;
+                  __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_22; __pyx_filename = __pyx_t_23;
+                  goto __pyx_L57_except_error;
+                }
+              }
+            }
+            goto __pyx_L57_except_error;
+            __pyx_L57_except_error:;
+
+            /* "uvloop/loop.pyx":1772
+ * 
+ *                         pyaddr = __convert_sockaddr_to_pyaddr(addrinfo.ai_addr)
+ *                         try:             # <<<<<<<<<<<<<<
+ *                             sock.bind(pyaddr)
+ *                         except OSError as err:
+ */
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_XGIVEREF(__pyx_t_12);
+            __Pyx_XGIVEREF(__pyx_t_11);
+            __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_12, __pyx_t_11);
+            goto __pyx_L32_error;
+            __pyx_L62_try_end:;
+          }
+
+          /* "uvloop/loop.pyx":1780
+ *                                 % (pyaddr, err.strerror.lower())) from None
+ * 
+ *                         tcp = TCPServer.new(self, protocol_factory, server,             # <<<<<<<<<<<<<<
+ *                                             uv.AF_UNSPEC, backlog,
+ *                                             ssl, ssl_handshake_timeout,
+ */
+          __pyx_t_7 = ((PyObject *)__pyx_f_6uvloop_4loop_9TCPServer_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol_factory, __pyx_cur_scope->__pyx_v_server, AF_UNSPEC, __pyx_cur_scope->__pyx_v_backlog, __pyx_cur_scope->__pyx_v_ssl, __pyx_cur_scope->__pyx_v_ssl_handshake_timeout, __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1780, __pyx_L32_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_XGOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tcp));
+          __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_tcp, ((struct __pyx_obj_6uvloop_4loop_TCPServer *)__pyx_t_7));
+          __Pyx_GIVEREF(__pyx_t_7);
+          __pyx_t_7 = 0;
+
+          /* "uvloop/loop.pyx":1785
+ *                                             ssl_shutdown_timeout)
+ * 
+ *                         try:             # <<<<<<<<<<<<<<
+ *                             tcp._open(sock.fileno())
+ *                         except (KeyboardInterrupt, SystemExit):
+ */
+          {
+            __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+            __Pyx_XGOTREF(__pyx_t_11);
+            __Pyx_XGOTREF(__pyx_t_12);
+            __Pyx_XGOTREF(__pyx_t_13);
+            /*try:*/ {
+
+              /* "uvloop/loop.pyx":1786
+ * 
+ *                         try:
+ *                             tcp._open(sock.fileno())             # <<<<<<<<<<<<<<
+ *                         except (KeyboardInterrupt, SystemExit):
+ *                             raise
+ */
+              __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1786, __pyx_L74_error)
+              __Pyx_GOTREF(__pyx_t_15);
+              __pyx_t_18 = NULL;
+              if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_15))) {
+                __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_15);
+                if (likely(__pyx_t_18)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
+                  __Pyx_INCREF(__pyx_t_18);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_15, function);
+                }
+              }
+              __pyx_t_7 = (__pyx_t_18) ? __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_t_18) : __Pyx_PyObject_CallNoArg(__pyx_t_15);
+              __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+              if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1786, __pyx_L74_error)
+              __Pyx_GOTREF(__pyx_t_7);
+              __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+              __pyx_t_22 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_22 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1786, __pyx_L74_error)
+              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+              __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_cur_scope->__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tcp), __pyx_t_22); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1786, __pyx_L74_error)
+              __Pyx_GOTREF(__pyx_t_7);
+              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+              /* "uvloop/loop.pyx":1785
+ *                                             ssl_shutdown_timeout)
+ * 
+ *                         try:             # <<<<<<<<<<<<<<
+ *                             tcp._open(sock.fileno())
+ *                         except (KeyboardInterrupt, SystemExit):
+ */
+            }
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            goto __pyx_L81_try_end;
+            __pyx_L74_error:;
+            __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+            __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+            __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+            __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+            /* "uvloop/loop.pyx":1787
+ *                         try:
+ *                             tcp._open(sock.fileno())
+ *                         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                             raise
+ *                         except BaseException:
+ */
+            __pyx_t_22 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+            if (__pyx_t_22) {
+              __Pyx_AddTraceback("uvloop.loop.Loop.create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+              if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_15, &__pyx_t_18) < 0) __PYX_ERR(0, 1787, __pyx_L76_except_error)
+              __Pyx_GOTREF(__pyx_t_7);
+              __Pyx_GOTREF(__pyx_t_15);
+              __Pyx_GOTREF(__pyx_t_18);
+
+              /* "uvloop/loop.pyx":1788
+ *                             tcp._open(sock.fileno())
+ *                         except (KeyboardInterrupt, SystemExit):
+ *                             raise             # <<<<<<<<<<<<<<
+ *                         except BaseException:
+ *                             tcp._close()
+ */
+              __Pyx_GIVEREF(__pyx_t_7);
+              __Pyx_GIVEREF(__pyx_t_15);
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_15, __pyx_t_18);
+              __pyx_t_7 = 0; __pyx_t_15 = 0; __pyx_t_18 = 0; 
+              __PYX_ERR(0, 1788, __pyx_L76_except_error)
+            }
+
+            /* "uvloop/loop.pyx":1789
+ *                         except (KeyboardInterrupt, SystemExit):
+ *                             raise
+ *                         except BaseException:             # <<<<<<<<<<<<<<
+ *                             tcp._close()
+ *                             raise
+ */
+            __pyx_t_22 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+            if (__pyx_t_22) {
+              __Pyx_AddTraceback("uvloop.loop.Loop.create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+              if (__Pyx_GetException(&__pyx_t_18, &__pyx_t_15, &__pyx_t_7) < 0) __PYX_ERR(0, 1789, __pyx_L76_except_error)
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_GOTREF(__pyx_t_15);
+              __Pyx_GOTREF(__pyx_t_7);
+
+              /* "uvloop/loop.pyx":1790
+ *                             raise
+ *                         except BaseException:
+ *                             tcp._close()             # <<<<<<<<<<<<<<
+ *                             raise
+ * 
+ */
+              __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_cur_scope->__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tcp)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1790, __pyx_L76_except_error)
+              __Pyx_GOTREF(__pyx_t_6);
+              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+              /* "uvloop/loop.pyx":1791
+ *                         except BaseException:
+ *                             tcp._close()
+ *                             raise             # <<<<<<<<<<<<<<
+ * 
+ *                         server._add_server(tcp)
+ */
+              __Pyx_GIVEREF(__pyx_t_18);
+              __Pyx_GIVEREF(__pyx_t_15);
+              __Pyx_XGIVEREF(__pyx_t_7);
+              __Pyx_ErrRestoreWithState(__pyx_t_18, __pyx_t_15, __pyx_t_7);
+              __pyx_t_18 = 0; __pyx_t_15 = 0; __pyx_t_7 = 0; 
+              __PYX_ERR(0, 1791, __pyx_L76_except_error)
+            }
+            goto __pyx_L76_except_error;
+            __pyx_L76_except_error:;
+
+            /* "uvloop/loop.pyx":1785
+ *                                             ssl_shutdown_timeout)
+ * 
+ *                         try:             # <<<<<<<<<<<<<<
+ *                             tcp._open(sock.fileno())
+ *                         except (KeyboardInterrupt, SystemExit):
+ */
+            __Pyx_XGIVEREF(__pyx_t_11);
+            __Pyx_XGIVEREF(__pyx_t_12);
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+            goto __pyx_L32_error;
+            __pyx_L81_try_end:;
+          }
+
+          /* "uvloop/loop.pyx":1793
+ *                             raise
+ * 
+ *                         server._add_server(tcp)             # <<<<<<<<<<<<<<
+ *                         sock.detach()
+ *                         sock = None
+ */
+          __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_cur_scope->__pyx_v_server->__pyx_vtab)->_add_server(__pyx_cur_scope->__pyx_v_server, ((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_cur_scope->__pyx_v_tcp)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1793, __pyx_L32_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+          /* "uvloop/loop.pyx":1794
+ * 
+ *                         server._add_server(tcp)
+ *                         sock.detach()             # <<<<<<<<<<<<<<
+ *                         sock = None
+ * 
+ */
+          __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_detach); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1794, __pyx_L32_error)
+          __Pyx_GOTREF(__pyx_t_15);
+          __pyx_t_18 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_15))) {
+            __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_15);
+            if (likely(__pyx_t_18)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
+              __Pyx_INCREF(__pyx_t_18);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_15, function);
+            }
+          }
+          __pyx_t_7 = (__pyx_t_18) ? __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_t_18) : __Pyx_PyObject_CallNoArg(__pyx_t_15);
+          __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+          if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1794, __pyx_L32_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+          /* "uvloop/loop.pyx":1795
+ *                         server._add_server(tcp)
+ *                         sock.detach()
+ *                         sock = None             # <<<<<<<<<<<<<<
+ * 
+ *                         addrinfo = addrinfo.ai_next
+ */
+          __Pyx_INCREF(Py_None);
+          __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_sock);
+          __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_sock, Py_None);
+          __Pyx_GIVEREF(Py_None);
+
+          /* "uvloop/loop.pyx":1797
+ *                         sock = None
+ * 
+ *                         addrinfo = addrinfo.ai_next             # <<<<<<<<<<<<<<
+ * 
+ *                 completed = True
+ */
+          __pyx_t_10 = __pyx_cur_scope->__pyx_v_addrinfo->ai_next;
+          __pyx_cur_scope->__pyx_v_addrinfo = __pyx_t_10;
+          __pyx_L36_continue:;
+        }
+
+        /* "uvloop/loop.pyx":1738
+ *             sock = None
+ *             try:
+ *                 for info in infos:             # <<<<<<<<<<<<<<
+ *                     addrinfo = (<AddrInfo>info).data
+ *                     while addrinfo != NULL:
+ */
+      }
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":1799
+ *                         addrinfo = addrinfo.ai_next
+ * 
+ *                 completed = True             # <<<<<<<<<<<<<<
+ *             finally:
+ *                 if not completed:
+ */
+      __pyx_cur_scope->__pyx_v_completed = 1;
+    }
+
+    /* "uvloop/loop.pyx":1801
+ *                 completed = True
+ *             finally:
+ *                 if not completed:             # <<<<<<<<<<<<<<
+ *                     if sock is not None:
+ *                         sock.close()
+ */
+    /*finally:*/ {
+      /*normal exit:*/{
+        __pyx_t_1 = ((!(__pyx_cur_scope->__pyx_v_completed != 0)) != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/loop.pyx":1802
+ *             finally:
+ *                 if not completed:
+ *                     if sock is not None:             # <<<<<<<<<<<<<<
+ *                         sock.close()
+ *                     server.close()
+ */
+          __pyx_t_1 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
+          __pyx_t_3 = (__pyx_t_1 != 0);
+          if (__pyx_t_3) {
+
+            /* "uvloop/loop.pyx":1803
+ *                 if not completed:
+ *                     if sock is not None:
+ *                         sock.close()             # <<<<<<<<<<<<<<
+ *                     server.close()
+ *         else:
+ */
+            __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_close); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1803, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_7);
+            __pyx_t_15 = NULL;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+              __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_7);
+              if (likely(__pyx_t_15)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+                __Pyx_INCREF(__pyx_t_15);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_7, function);
+              }
+            }
+            __pyx_t_4 = (__pyx_t_15) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_15) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+            if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1803, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+            /* "uvloop/loop.pyx":1802
+ *             finally:
+ *                 if not completed:
+ *                     if sock is not None:             # <<<<<<<<<<<<<<
+ *                         sock.close()
+ *                     server.close()
+ */
+          }
+
+          /* "uvloop/loop.pyx":1804
+ *                     if sock is not None:
+ *                         sock.close()
+ *                     server.close()             # <<<<<<<<<<<<<<
+ *         else:
+ *             if sock is None:
+ */
+          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_server), __pyx_n_s_close); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1804, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __pyx_t_15 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+            __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_7);
+            if (likely(__pyx_t_15)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+              __Pyx_INCREF(__pyx_t_15);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_7, function);
+            }
+          }
+          __pyx_t_4 = (__pyx_t_15) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_15) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1804, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+          /* "uvloop/loop.pyx":1801
+ *                 completed = True
+ *             finally:
+ *                 if not completed:             # <<<<<<<<<<<<<<
+ *                     if sock is not None:
+ *                         sock.close()
+ */
+        }
+        goto __pyx_L33;
+      }
+      __pyx_L32_error:;
+      /*exception exit:*/{
+        __Pyx_PyThreadState_assign
+        __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_29 = 0; __pyx_t_28 = 0; __pyx_t_27 = 0;
+        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+        __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+        __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_29, &__pyx_t_28, &__pyx_t_27);
+        if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11);
+        __Pyx_XGOTREF(__pyx_t_13);
+        __Pyx_XGOTREF(__pyx_t_12);
+        __Pyx_XGOTREF(__pyx_t_11);
+        __Pyx_XGOTREF(__pyx_t_29);
+        __Pyx_XGOTREF(__pyx_t_28);
+        __Pyx_XGOTREF(__pyx_t_27);
+        __pyx_t_22 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_30 = __pyx_filename;
+        {
+          __pyx_t_3 = ((!(__pyx_cur_scope->__pyx_v_completed != 0)) != 0);
+          if (__pyx_t_3) {
+
+            /* "uvloop/loop.pyx":1802
+ *             finally:
+ *                 if not completed:
+ *                     if sock is not None:             # <<<<<<<<<<<<<<
+ *                         sock.close()
+ *                     server.close()
+ */
+            __pyx_t_3 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
+            __pyx_t_1 = (__pyx_t_3 != 0);
+            if (__pyx_t_1) {
+
+              /* "uvloop/loop.pyx":1803
+ *                 if not completed:
+ *                     if sock is not None:
+ *                         sock.close()             # <<<<<<<<<<<<<<
+ *                     server.close()
+ *         else:
+ */
+              __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_close); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1803, __pyx_L89_error)
+              __Pyx_GOTREF(__pyx_t_7);
+              __pyx_t_15 = NULL;
+              if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+                __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_7);
+                if (likely(__pyx_t_15)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+                  __Pyx_INCREF(__pyx_t_15);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_7, function);
+                }
+              }
+              __pyx_t_4 = (__pyx_t_15) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_15) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+              __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+              if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1803, __pyx_L89_error)
+              __Pyx_GOTREF(__pyx_t_4);
+              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+              /* "uvloop/loop.pyx":1802
+ *             finally:
+ *                 if not completed:
+ *                     if sock is not None:             # <<<<<<<<<<<<<<
+ *                         sock.close()
+ *                     server.close()
+ */
+            }
+
+            /* "uvloop/loop.pyx":1804
+ *                     if sock is not None:
+ *                         sock.close()
+ *                     server.close()             # <<<<<<<<<<<<<<
+ *         else:
+ *             if sock is None:
+ */
+            __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_server), __pyx_n_s_close); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1804, __pyx_L89_error)
+            __Pyx_GOTREF(__pyx_t_7);
+            __pyx_t_15 = NULL;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+              __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_7);
+              if (likely(__pyx_t_15)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+                __Pyx_INCREF(__pyx_t_15);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_7, function);
+              }
+            }
+            __pyx_t_4 = (__pyx_t_15) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_15) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+            if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1804, __pyx_L89_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+            /* "uvloop/loop.pyx":1801
+ *                 completed = True
+ *             finally:
+ *                 if not completed:             # <<<<<<<<<<<<<<
+ *                     if sock is not None:
+ *                         sock.close()
+ */
+          }
+        }
+        if (PY_MAJOR_VERSION >= 3) {
+          __Pyx_XGIVEREF(__pyx_t_29);
+          __Pyx_XGIVEREF(__pyx_t_28);
+          __Pyx_XGIVEREF(__pyx_t_27);
+          __Pyx_ExceptionReset(__pyx_t_29, __pyx_t_28, __pyx_t_27);
+        }
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_ErrRestore(__pyx_t_13, __pyx_t_12, __pyx_t_11);
+        __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_29 = 0; __pyx_t_28 = 0; __pyx_t_27 = 0;
+        __pyx_lineno = __pyx_t_22; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_30;
+        goto __pyx_L1_error;
+        __pyx_L89_error:;
+        if (PY_MAJOR_VERSION >= 3) {
+          __Pyx_XGIVEREF(__pyx_t_29);
+          __Pyx_XGIVEREF(__pyx_t_28);
+          __Pyx_XGIVEREF(__pyx_t_27);
+          __Pyx_ExceptionReset(__pyx_t_29, __pyx_t_28, __pyx_t_27);
+        }
+        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __pyx_t_29 = 0; __pyx_t_28 = 0; __pyx_t_27 = 0;
+        goto __pyx_L1_error;
+      }
+      __pyx_L33:;
+    }
+
+    /* "uvloop/loop.pyx":1710
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ *         if host is not None or port is not None:             # <<<<<<<<<<<<<<
+ *             if sock is not None:
+ *                 raise ValueError(
+ */
+    goto __pyx_L15;
+  }
+
+  /* "uvloop/loop.pyx":1806
+ *                     server.close()
+ *         else:
+ *             if sock is None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError('Neither host/port nor sock were specified')
+ *             if not _is_sock_stream(sock.type):
+ */
+  /*else*/ {
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_sock == Py_None);
+    __pyx_t_3 = (__pyx_t_1 != 0);
+    if (unlikely(__pyx_t_3)) {
+
+      /* "uvloop/loop.pyx":1807
+ *         else:
+ *             if sock is None:
+ *                 raise ValueError('Neither host/port nor sock were specified')             # <<<<<<<<<<<<<<
+ *             if not _is_sock_stream(sock.type):
+ *                 raise ValueError(
+ */
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1807, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __PYX_ERR(0, 1807, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1806
+ *                     server.close()
+ *         else:
+ *             if sock is None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError('Neither host/port nor sock were specified')
+ *             if not _is_sock_stream(sock.type):
+ */
+    }
+
+    /* "uvloop/loop.pyx":1808
+ *             if sock is None:
+ *                 raise ValueError('Neither host/port nor sock were specified')
+ *             if not _is_sock_stream(sock.type):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'A Stream Socket was expected, got {!r}'.format(sock))
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1808, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = __pyx_f_6uvloop_4loop__is_sock_stream(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1808, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1808, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_1 = ((!__pyx_t_3) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":1810
+ *             if not _is_sock_stream(sock.type):
+ *                 raise ValueError(
+ *                     'A Stream Socket was expected, got {!r}'.format(sock))             # <<<<<<<<<<<<<<
+ * 
+ *             # libuv will set the socket to non-blocking mode, but
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_Stream_Socket_was_expected_got, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1810, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_15 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_4);
+        if (likely(__pyx_t_15)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+          __Pyx_INCREF(__pyx_t_15);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_4, function);
+        }
+      }
+      __pyx_t_7 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_15, __pyx_cur_scope->__pyx_v_sock) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_sock);
+      __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1810, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":1809
+ *                 raise ValueError('Neither host/port nor sock were specified')
+ *             if not _is_sock_stream(sock.type):
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'A Stream Socket was expected, got {!r}'.format(sock))
+ * 
+ */
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1809, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __PYX_ERR(0, 1809, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1808
+ *             if sock is None:
+ *                 raise ValueError('Neither host/port nor sock were specified')
+ *             if not _is_sock_stream(sock.type):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'A Stream Socket was expected, got {!r}'.format(sock))
+ */
+    }
+
+    /* "uvloop/loop.pyx":1814
+ *             # libuv will set the socket to non-blocking mode, but
+ *             # we want Python socket object to notice that.
+ *             sock.setblocking(False)             # <<<<<<<<<<<<<<
+ * 
+ *             tcp = TCPServer.new(self, protocol_factory, server,
+ */
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1814, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_15 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_15)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_15);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_15, Py_False) : __Pyx_PyObject_CallOneArg(__pyx_t_7, Py_False);
+    __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1814, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":1816
+ *             sock.setblocking(False)
+ * 
+ *             tcp = TCPServer.new(self, protocol_factory, server,             # <<<<<<<<<<<<<<
+ *                                 uv.AF_UNSPEC, backlog,
+ *                                 ssl, ssl_handshake_timeout,
+ */
+    __pyx_t_4 = ((PyObject *)__pyx_f_6uvloop_4loop_9TCPServer_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol_factory, __pyx_cur_scope->__pyx_v_server, AF_UNSPEC, __pyx_cur_scope->__pyx_v_backlog, __pyx_cur_scope->__pyx_v_ssl, __pyx_cur_scope->__pyx_v_ssl_handshake_timeout, __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1816, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_4);
+    __pyx_cur_scope->__pyx_v_tcp = ((struct __pyx_obj_6uvloop_4loop_TCPServer *)__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":1821
+ *                                 ssl_shutdown_timeout)
+ * 
+ *             try:             # <<<<<<<<<<<<<<
+ *                 tcp._open(sock.fileno())
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+    {
+      __Pyx_ExceptionSave(&__pyx_t_27, &__pyx_t_28, &__pyx_t_29);
+      __Pyx_XGOTREF(__pyx_t_27);
+      __Pyx_XGOTREF(__pyx_t_28);
+      __Pyx_XGOTREF(__pyx_t_29);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":1822
+ * 
+ *             try:
+ *                 tcp._open(sock.fileno())             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1822, __pyx_L94_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __pyx_t_15 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+          __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_7);
+          if (likely(__pyx_t_15)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+            __Pyx_INCREF(__pyx_t_15);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_7, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_15) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_15) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+        __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1822, __pyx_L94_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1822, __pyx_L94_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_cur_scope->__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tcp), __pyx_t_17); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1822, __pyx_L94_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/loop.pyx":1821
+ *                                 ssl_shutdown_timeout)
+ * 
+ *             try:             # <<<<<<<<<<<<<<
+ *                 tcp._open(sock.fileno())
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_27); __pyx_t_27 = 0;
+      __Pyx_XDECREF(__pyx_t_28); __pyx_t_28 = 0;
+      __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0;
+      goto __pyx_L99_try_end;
+      __pyx_L94_error:;
+      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+      __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+      __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+      __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/loop.pyx":1823
+ *             try:
+ *                 tcp._open(sock.fileno())
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException:
+ */
+      __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_17) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_7, &__pyx_t_15) < 0) __PYX_ERR(0, 1823, __pyx_L96_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_15);
+
+        /* "uvloop/loop.pyx":1824
+ *                 tcp._open(sock.fileno())
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException:
+ *                 tcp._close()
+ */
+        __Pyx_GIVEREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_7, __pyx_t_15);
+        __pyx_t_4 = 0; __pyx_t_7 = 0; __pyx_t_15 = 0; 
+        __PYX_ERR(0, 1824, __pyx_L96_except_error)
+      }
+
+      /* "uvloop/loop.pyx":1825
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException:             # <<<<<<<<<<<<<<
+ *                 tcp._close()
+ *                 raise
+ */
+      __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_17) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_7, &__pyx_t_4) < 0) __PYX_ERR(0, 1825, __pyx_L96_except_error)
+        __Pyx_GOTREF(__pyx_t_15);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_4);
+
+        /* "uvloop/loop.pyx":1826
+ *                 raise
+ *             except BaseException:
+ *                 tcp._close()             # <<<<<<<<<<<<<<
+ *                 raise
+ * 
+ */
+        __pyx_t_18 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_cur_scope->__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tcp)); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1826, __pyx_L96_except_error)
+        __Pyx_GOTREF(__pyx_t_18);
+        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+
+        /* "uvloop/loop.pyx":1827
+ *             except BaseException:
+ *                 tcp._close()
+ *                 raise             # <<<<<<<<<<<<<<
+ * 
+ *             tcp._attach_fileobj(sock)
+ */
+        __Pyx_GIVEREF(__pyx_t_15);
+        __Pyx_GIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_4);
+        __Pyx_ErrRestoreWithState(__pyx_t_15, __pyx_t_7, __pyx_t_4);
+        __pyx_t_15 = 0; __pyx_t_7 = 0; __pyx_t_4 = 0; 
+        __PYX_ERR(0, 1827, __pyx_L96_except_error)
+      }
+      goto __pyx_L96_except_error;
+      __pyx_L96_except_error:;
+
+      /* "uvloop/loop.pyx":1821
+ *                                 ssl_shutdown_timeout)
+ * 
+ *             try:             # <<<<<<<<<<<<<<
+ *                 tcp._open(sock.fileno())
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      __Pyx_XGIVEREF(__pyx_t_27);
+      __Pyx_XGIVEREF(__pyx_t_28);
+      __Pyx_XGIVEREF(__pyx_t_29);
+      __Pyx_ExceptionReset(__pyx_t_27, __pyx_t_28, __pyx_t_29);
+      goto __pyx_L1_error;
+      __pyx_L99_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":1829
+ *                 raise
+ * 
+ *             tcp._attach_fileobj(sock)             # <<<<<<<<<<<<<<
+ *             server._add_server(tcp)
+ * 
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_cur_scope->__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tcp), __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1829, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":1830
+ * 
+ *             tcp._attach_fileobj(sock)
+ *             server._add_server(tcp)             # <<<<<<<<<<<<<<
+ * 
+ *         if start_serving:
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_cur_scope->__pyx_v_server->__pyx_vtab)->_add_server(__pyx_cur_scope->__pyx_v_server, ((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_cur_scope->__pyx_v_tcp)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1830, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_L15:;
+
+  /* "uvloop/loop.pyx":1832
+ *             server._add_server(tcp)
+ * 
+ *         if start_serving:             # <<<<<<<<<<<<<<
+ *             server._start_serving()
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_start_serving); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1832, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1833
+ * 
+ *         if start_serving:
+ *             server._start_serving()             # <<<<<<<<<<<<<<
+ * 
+ *         server._ref()
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_cur_scope->__pyx_v_server->__pyx_vtab)->_start_serving(__pyx_cur_scope->__pyx_v_server); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1833, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":1832
+ *             server._add_server(tcp)
+ * 
+ *         if start_serving:             # <<<<<<<<<<<<<<
+ *             server._start_serving()
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":1835
+ *             server._start_serving()
+ * 
+ *         server._ref()             # <<<<<<<<<<<<<<
+ *         return server
+ * 
+ */
+  __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_cur_scope->__pyx_v_server->__pyx_vtab)->_ref(__pyx_cur_scope->__pyx_v_server); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1835, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":1836
+ * 
+ *         server._ref()
+ *         return server             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(((PyObject *)__pyx_cur_scope->__pyx_v_server));
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":1629
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_server(self, protocol_factory, host=None, port=None,             # <<<<<<<<<<<<<<
+ *                             *,
+ *                             int family=uv.AF_UNSPEC,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_XDECREF(__pyx_t_15);
+  __Pyx_XDECREF(__pyx_t_16);
+  __Pyx_XDECREF(__pyx_t_18);
+  __Pyx_XDECREF(__pyx_t_19);
+  __Pyx_AddTraceback("create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_60generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":1839
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_connection(self, protocol_factory, host=None, port=None,             # <<<<<<<<<<<<<<
+ *                                 *,
+ *                                 ssl=None,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_59create_connection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_58create_connection[] = "Loop.create_connection(self, protocol_factory, host=None, port=None, *, ssl=None, family=0, proto=0, flags=0, sock=None, local_addr=None, server_hostname=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None)\nConnect to a TCP server.\n\n        Create a streaming transport connection to a given Internet host and\n        port: socket family AF_INET or socket.AF_INET6 depending on host (or\n        family if specified), socket type SOCK_STREAM. protocol_factory must be\n        a callable returning a protocol instance.\n\n        This method is a coroutine which will try to establish the connection\n        in the background.  When successful, the coroutine returns a\n        (transport, protocol) pair.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_59create_connection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_protocol_factory = 0;
+  PyObject *__pyx_v_host = 0;
+  PyObject *__pyx_v_port = 0;
+  PyObject *__pyx_v_ssl = 0;
+  PyObject *__pyx_v_family = 0;
+  PyObject *__pyx_v_proto = 0;
+  PyObject *__pyx_v_flags = 0;
+  PyObject *__pyx_v_sock = 0;
+  PyObject *__pyx_v_local_addr = 0;
+  PyObject *__pyx_v_server_hostname = 0;
+  PyObject *__pyx_v_ssl_handshake_timeout = 0;
+  PyObject *__pyx_v_ssl_shutdown_timeout = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_connection (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_ssl,&__pyx_n_s_family,&__pyx_n_s_proto,&__pyx_n_s_flags,&__pyx_n_s_sock,&__pyx_n_s_local_addr,&__pyx_n_s_server_hostname,&__pyx_n_s_ssl_handshake_timeout,&__pyx_n_s_ssl_shutdown_timeout,0};
+    PyObject* values[12] = {0,0,0,0,0,0,0,0,0,0,0,0};
+    values[1] = ((PyObject *)Py_None);
+    values[2] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1841
+ *     async def create_connection(self, protocol_factory, host=None, port=None,
+ *                                 *,
+ *                                 ssl=None,             # <<<<<<<<<<<<<<
+ *                                 family=0, proto=0, flags=0, sock=None,
+ *                                 local_addr=None, server_hostname=None,
+ */
+    values[3] = ((PyObject *)Py_None);
+    values[4] = ((PyObject *)__pyx_int_0);
+    values[5] = ((PyObject *)__pyx_int_0);
+    values[6] = ((PyObject *)__pyx_int_0);
+
+    /* "uvloop/loop.pyx":1842
+ *                                 *,
+ *                                 ssl=None,
+ *                                 family=0, proto=0, flags=0, sock=None,             # <<<<<<<<<<<<<<
+ *                                 local_addr=None, server_hostname=None,
+ *                                 ssl_handshake_timeout=None,
+ */
+    values[7] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1843
+ *                                 ssl=None,
+ *                                 family=0, proto=0, flags=0, sock=None,
+ *                                 local_addr=None, server_hostname=None,             # <<<<<<<<<<<<<<
+ *                                 ssl_handshake_timeout=None,
+ *                                 ssl_shutdown_timeout=None):
+ */
+    values[8] = ((PyObject *)Py_None);
+    values[9] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1844
+ *                                 family=0, proto=0, flags=0, sock=None,
+ *                                 local_addr=None, server_hostname=None,
+ *                                 ssl_handshake_timeout=None,             # <<<<<<<<<<<<<<
+ *                                 ssl_shutdown_timeout=None):
+ *         """Connect to a TCP server.
+ */
+    values[10] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":1845
+ *                                 local_addr=None, server_hostname=None,
+ *                                 ssl_handshake_timeout=None,
+ *                                 ssl_shutdown_timeout=None):             # <<<<<<<<<<<<<<
+ *         """Connect to a TCP server.
+ * 
+ */
+    values[11] = ((PyObject *)Py_None);
+    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_protocol_factory)) != 0)) kw_args--;
+        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--; }
+        }
+        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--; }
+        }
+      }
+      if (kw_args > 0 && likely(kw_args <= 9)) {
+        Py_ssize_t index;
+        for (index = 3; index < 12 && kw_args > 0; index++) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+          if (value) { values[index] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_connection") < 0)) __PYX_ERR(0, 1839, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_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);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_protocol_factory = values[0];
+    __pyx_v_host = values[1];
+    __pyx_v_port = values[2];
+    __pyx_v_ssl = values[3];
+    __pyx_v_family = values[4];
+    __pyx_v_proto = values[5];
+    __pyx_v_flags = values[6];
+    __pyx_v_sock = values[7];
+    __pyx_v_local_addr = values[8];
+    __pyx_v_server_hostname = values[9];
+    __pyx_v_ssl_handshake_timeout = values[10];
+    __pyx_v_ssl_shutdown_timeout = values[11];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("create_connection", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1839, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_58create_connection(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_host, __pyx_v_port, __pyx_v_ssl, __pyx_v_family, __pyx_v_proto, __pyx_v_flags, __pyx_v_sock, __pyx_v_local_addr, __pyx_v_server_hostname, __pyx_v_ssl_handshake_timeout, __pyx_v_ssl_shutdown_timeout);
+
+  /* "uvloop/loop.pyx":1839
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_connection(self, protocol_factory, host=None, port=None,             # <<<<<<<<<<<<<<
+ *                                 *,
+ *                                 ssl=None,
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_17create_connection_2generator27(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2023
+ *                 # If they all have the same str(), raise one.
+ *                 model = str(exceptions[0])
+ *                 if all(str(exc) == model for exc in exceptions):             # <<<<<<<<<<<<<<
+ *                     raise exceptions[0]
+ *                 # Raise a combined exception so the user can see all
+ */
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_17create_connection_genexpr(PyObject *__pyx_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("genexpr", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_9_genexpr(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_9_genexpr, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2023, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__pyx_cur_scope);
+  }
+  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *) __pyx_self;
+  __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope));
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_17create_connection_2generator27, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_create_connection_locals_genexpr, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2023, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_connection.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_17create_connection_2generator27(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("genexpr", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2023, __pyx_L1_error)
+  if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions)) { __Pyx_RaiseClosureNameError("exceptions"); __PYX_ERR(0, 2023, __pyx_L1_error) }
+  if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(0, 2023, __pyx_L1_error)
+  }
+  __pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+  for (;;) {
+    if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 2023, __pyx_L1_error)
+    #else
+    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2023, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_exc);
+    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_exc, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_cur_scope->__pyx_v_exc); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2023, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_model)) { __Pyx_RaiseClosureNameError("model"); __PYX_ERR(0, 2023, __pyx_L1_error) }
+    __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_model, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 2023, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_5 = ((!__pyx_t_4) != 0);
+    if (__pyx_t_5) {
+      __Pyx_XDECREF(__pyx_r);
+      __Pyx_INCREF(Py_False);
+      __pyx_r = Py_False;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      goto __pyx_L0;
+    }
+  }
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_True);
+    __pyx_r = Py_True;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    goto __pyx_L0;
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_17create_connection_5generator28(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2028
+ *                 # the various error messages.
+ *                 raise OSError('Multiple exceptions: {}'.format(
+ *                     ', '.join(str(exc) for exc in exceptions)))             # <<<<<<<<<<<<<<
+ *         else:
+ *             if sock is None:
+ */
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_17create_connection_3genexpr(PyObject *__pyx_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("genexpr", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_10_genexpr(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_10_genexpr, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2028, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__pyx_cur_scope);
+  }
+  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *) __pyx_self;
+  __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope));
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_17create_connection_5generator28, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_create_connection_locals_genexpr, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2028, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_connection.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_17create_connection_5generator28(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("genexpr", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2028, __pyx_L1_error)
+  __pyx_r = PyList_New(0); if (unlikely(!__pyx_r)) __PYX_ERR(0, 2028, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_r);
+  if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions)) { __Pyx_RaiseClosureNameError("exceptions"); __PYX_ERR(0, 2028, __pyx_L1_error) }
+  if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(0, 2028, __pyx_L1_error)
+  }
+  __pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+  for (;;) {
+    if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 2028, __pyx_L1_error)
+    #else
+    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2028, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_exc);
+    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_exc, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_cur_scope->__pyx_v_exc); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2028, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_r, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 2028, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":1839
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_connection(self, protocol_factory, host=None, port=None,             # <<<<<<<<<<<<<<
+ *                                 *,
+ *                                 ssl=None,
+ */
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_58create_connection(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_host, PyObject *__pyx_v_port, PyObject *__pyx_v_ssl, PyObject *__pyx_v_family, PyObject *__pyx_v_proto, PyObject *__pyx_v_flags, PyObject *__pyx_v_sock, PyObject *__pyx_v_local_addr, PyObject *__pyx_v_server_hostname, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *__pyx_cur_scope;
+  PyObject *__pyx_gb_6uvloop_4loop_4Loop_17create_connection_2generator27 = 0;
+  PyObject *__pyx_gb_6uvloop_4loop_4Loop_17create_connection_5generator28 = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("create_connection", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_8_create_connection(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_8_create_connection, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 1839, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_protocol_factory = __pyx_v_protocol_factory;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_cur_scope->__pyx_v_host = __pyx_v_host;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_host);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_host);
+  __pyx_cur_scope->__pyx_v_port = __pyx_v_port;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_port);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_port);
+  __pyx_cur_scope->__pyx_v_ssl = __pyx_v_ssl;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
+  __pyx_cur_scope->__pyx_v_family = __pyx_v_family;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_family);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_family);
+  __pyx_cur_scope->__pyx_v_proto = __pyx_v_proto;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto);
+  __pyx_cur_scope->__pyx_v_flags = __pyx_v_flags;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_flags);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_flags);
+  __pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+  __pyx_cur_scope->__pyx_v_local_addr = __pyx_v_local_addr;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_local_addr);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_local_addr);
+  __pyx_cur_scope->__pyx_v_server_hostname = __pyx_v_server_hostname;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_hostname);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_hostname);
+  __pyx_cur_scope->__pyx_v_ssl_handshake_timeout = __pyx_v_ssl_handshake_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout = __pyx_v_ssl_shutdown_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_60generator4, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_create_connection, __pyx_n_s_Loop_create_connection, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 1839, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_gb_6uvloop_4loop_4Loop_17create_connection_2generator27);
+  __Pyx_XDECREF(__pyx_gb_6uvloop_4loop_4Loop_17create_connection_5generator28);
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_60generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  int __pyx_t_11;
+  int __pyx_t_12;
+  Py_ssize_t __pyx_t_13;
+  struct addrinfo *__pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  char const *__pyx_t_21;
+  PyObject *__pyx_t_22 = NULL;
+  PyObject *__pyx_t_23 = NULL;
+  PyObject *__pyx_t_24 = NULL;
+  PyObject *__pyx_t_25 = NULL;
+  PyObject *__pyx_t_26 = NULL;
+  PyObject *__pyx_t_27 = NULL;
+  char const *__pyx_t_28;
+  PyObject *__pyx_t_29 = NULL;
+  PyObject *__pyx_t_30 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_connection", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L10_resume_from_await;
+    case 2: goto __pyx_L30_resume_from_await;
+    case 3: goto __pyx_L69_resume_from_await;
+    case 4: goto __pyx_L96_resume_from_await;
+    case 5: goto __pyx_L108_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1839, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1858
+ *         """
+ *         cdef:
+ *             AddrInfo ai_local = None             # <<<<<<<<<<<<<<
+ *             AddrInfo ai_remote
+ *             TCPTransport tr
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __pyx_cur_scope->__pyx_v_ai_local = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)Py_None);
+
+  /* "uvloop/loop.pyx":1862
+ *             TCPTransport tr
+ * 
+ *             system.addrinfo *rai = NULL             # <<<<<<<<<<<<<<
+ *             system.addrinfo *lai = NULL
+ * 
+ */
+  __pyx_cur_scope->__pyx_v_rai = NULL;
+
+  /* "uvloop/loop.pyx":1863
+ * 
+ *             system.addrinfo *rai = NULL
+ *             system.addrinfo *lai = NULL             # <<<<<<<<<<<<<<
+ * 
+ *             system.addrinfo *rai_iter = NULL
+ */
+  __pyx_cur_scope->__pyx_v_lai = NULL;
+
+  /* "uvloop/loop.pyx":1865
+ *             system.addrinfo *lai = NULL
+ * 
+ *             system.addrinfo *rai_iter = NULL             # <<<<<<<<<<<<<<
+ *             system.addrinfo *lai_iter = NULL
+ * 
+ */
+  __pyx_cur_scope->__pyx_v_rai_iter = NULL;
+
+  /* "uvloop/loop.pyx":1866
+ * 
+ *             system.addrinfo *rai_iter = NULL
+ *             system.addrinfo *lai_iter = NULL             # <<<<<<<<<<<<<<
+ * 
+ *             system.addrinfo rai_static
+ */
+  __pyx_cur_scope->__pyx_v_lai_iter = NULL;
+
+  /* "uvloop/loop.pyx":1878
+ *             object ssl_waiter
+ * 
+ *         if sock is not None and sock.family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *             if host is not None or port is not None:
+ *                 raise ValueError(
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+  } else {
+    __pyx_t_1 = __pyx_t_3;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1878, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1878, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1878, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1878, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L5_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1879
+ * 
+ *         if sock is not None and sock.family == uv.AF_UNIX:
+ *             if host is not None or port is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ */
+    __pyx_t_3 = (__pyx_cur_scope->__pyx_v_host != Py_None);
+    __pyx_t_2 = (__pyx_t_3 != 0);
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L8_bool_binop_done;
+    }
+    __pyx_t_2 = (__pyx_cur_scope->__pyx_v_port != Py_None);
+    __pyx_t_3 = (__pyx_t_2 != 0);
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_L8_bool_binop_done:;
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":1880
+ *         if sock is not None and sock.family == uv.AF_UNIX:
+ *             if host is not None or port is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'host/port and sock can not be specified at the same time')
+ *             return await self.create_unix_connection(
+ */
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1880, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __PYX_ERR(0, 1880, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1879
+ * 
+ *         if sock is not None and sock.family == uv.AF_UNIX:
+ *             if host is not None or port is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ */
+    }
+
+    /* "uvloop/loop.pyx":1882
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ *             return await self.create_unix_connection(             # <<<<<<<<<<<<<<
+ *                 protocol_factory, None,
+ *                 sock=sock, ssl=ssl, server_hostname=server_hostname)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_create_unix_connection); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1882, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+
+    /* "uvloop/loop.pyx":1883
+ *                     'host/port and sock can not be specified at the same time')
+ *             return await self.create_unix_connection(
+ *                 protocol_factory, None,             # <<<<<<<<<<<<<<
+ *                 sock=sock, ssl=ssl, server_hostname=server_hostname)
+ * 
+ */
+    __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1882, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_cur_scope->__pyx_v_protocol_factory);
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, Py_None);
+
+    /* "uvloop/loop.pyx":1884
+ *             return await self.create_unix_connection(
+ *                 protocol_factory, None,
+ *                 sock=sock, ssl=ssl, server_hostname=server_hostname)             # <<<<<<<<<<<<<<
+ * 
+ *         app_protocol = protocol = protocol_factory()
+ */
+    __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1884, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_sock, __pyx_cur_scope->__pyx_v_sock) < 0) __PYX_ERR(0, 1884, __pyx_L1_error)
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_ssl, __pyx_cur_scope->__pyx_v_ssl) < 0) __PYX_ERR(0, 1884, __pyx_L1_error)
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_server_hostname, __pyx_cur_scope->__pyx_v_server_hostname) < 0) __PYX_ERR(0, 1884, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1882
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ *             return await self.create_unix_connection(             # <<<<<<<<<<<<<<
+ *                 protocol_factory, None,
+ *                 sock=sock, ssl=ssl, server_hostname=server_hostname)
+ */
+    __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1882, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_7);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XGOTREF(__pyx_r);
+    if (likely(__pyx_r)) {
+      __Pyx_XGIVEREF(__pyx_r);
+      __Pyx_RefNannyFinishContext();
+      __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+      /* return from generator, awaiting value */
+      __pyx_generator->resume_label = 1;
+      return __pyx_r;
+      __pyx_L10_resume_from_await:;
+      if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1882, __pyx_L1_error)
+      __pyx_t_7 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_7);
+    } else {
+      __pyx_t_7 = NULL;
+      if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_7) < 0) __PYX_ERR(0, 1882, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+    }
+    __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":1878
+ *             object ssl_waiter
+ * 
+ *         if sock is not None and sock.family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *             if host is not None or port is not None:
+ *                 raise ValueError(
+ */
+  }
+
+  /* "uvloop/loop.pyx":1886
+ *                 sock=sock, ssl=ssl, server_hostname=server_hostname)
+ * 
+ *         app_protocol = protocol = protocol_factory()             # <<<<<<<<<<<<<<
+ *         ssl_waiter = None
+ *         context = Context_CopyCurrent()
+ */
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_t_4 = __pyx_cur_scope->__pyx_v_protocol_factory; __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_7 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1886, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_INCREF(__pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_7);
+  __pyx_cur_scope->__pyx_v_app_protocol = __pyx_t_7;
+  __Pyx_INCREF(__pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_7);
+  __pyx_cur_scope->__pyx_v_protocol = __pyx_t_7;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":1887
+ * 
+ *         app_protocol = protocol = protocol_factory()
+ *         ssl_waiter = None             # <<<<<<<<<<<<<<
+ *         context = Context_CopyCurrent()
+ *         if ssl:
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __pyx_cur_scope->__pyx_v_ssl_waiter = Py_None;
+
+  /* "uvloop/loop.pyx":1888
+ *         app_protocol = protocol = protocol_factory()
+ *         ssl_waiter = None
+ *         context = Context_CopyCurrent()             # <<<<<<<<<<<<<<
+ *         if ssl:
+ *             if server_hostname is None:
+ */
+  __pyx_t_7 = Context_CopyCurrent(); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1888, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_7);
+  __pyx_cur_scope->__pyx_v_context = __pyx_t_7;
+  __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":1889
+ *         ssl_waiter = None
+ *         context = Context_CopyCurrent()
+ *         if ssl:             # <<<<<<<<<<<<<<
+ *             if server_hostname is None:
+ *                 if not host:
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_ssl); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1889, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":1890
+ *         context = Context_CopyCurrent()
+ *         if ssl:
+ *             if server_hostname is None:             # <<<<<<<<<<<<<<
+ *                 if not host:
+ *                     raise ValueError('You must set server_hostname '
+ */
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_server_hostname == Py_None);
+    __pyx_t_3 = (__pyx_t_1 != 0);
+    if (__pyx_t_3) {
+
+      /* "uvloop/loop.pyx":1891
+ *         if ssl:
+ *             if server_hostname is None:
+ *                 if not host:             # <<<<<<<<<<<<<<
+ *                     raise ValueError('You must set server_hostname '
+ *                                      'when using ssl without a host')
+ */
+      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_host); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1891, __pyx_L1_error)
+      __pyx_t_1 = ((!__pyx_t_3) != 0);
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/loop.pyx":1892
+ *             if server_hostname is None:
+ *                 if not host:
+ *                     raise ValueError('You must set server_hostname '             # <<<<<<<<<<<<<<
+ *                                      'when using ssl without a host')
+ *                 server_hostname = host
+ */
+        __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1892, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __PYX_ERR(0, 1892, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":1891
+ *         if ssl:
+ *             if server_hostname is None:
+ *                 if not host:             # <<<<<<<<<<<<<<
+ *                     raise ValueError('You must set server_hostname '
+ *                                      'when using ssl without a host')
+ */
+      }
+
+      /* "uvloop/loop.pyx":1894
+ *                     raise ValueError('You must set server_hostname '
+ *                                      'when using ssl without a host')
+ *                 server_hostname = host             # <<<<<<<<<<<<<<
+ * 
+ *             ssl_waiter = self._new_future()
+ */
+      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_host);
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_server_hostname);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_server_hostname, __pyx_cur_scope->__pyx_v_host);
+      __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_host);
+
+      /* "uvloop/loop.pyx":1890
+ *         context = Context_CopyCurrent()
+ *         if ssl:
+ *             if server_hostname is None:             # <<<<<<<<<<<<<<
+ *                 if not host:
+ *                     raise ValueError('You must set server_hostname '
+ */
+    }
+
+    /* "uvloop/loop.pyx":1896
+ *                 server_hostname = host
+ * 
+ *             ssl_waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *             sslcontext = None if isinstance(ssl, bool) else ssl
+ *             protocol = SSLProtocol(
+ */
+    __pyx_t_7 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1896, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_ssl_waiter, __pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_7);
+    __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":1897
+ * 
+ *             ssl_waiter = self._new_future()
+ *             sslcontext = None if isinstance(ssl, bool) else ssl             # <<<<<<<<<<<<<<
+ *             protocol = SSLProtocol(
+ *                 self, app_protocol, sslcontext, ssl_waiter,
+ */
+    __pyx_t_4 = ((PyObject*)&PyBool_Type);
+    __Pyx_INCREF(__pyx_t_4);
+    __pyx_t_1 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_ssl, __pyx_t_4); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 1897, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if ((__pyx_t_1 != 0)) {
+      __Pyx_INCREF(Py_None);
+      __pyx_t_7 = Py_None;
+    } else {
+      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
+      __pyx_t_7 = __pyx_cur_scope->__pyx_v_ssl;
+    }
+    __Pyx_GIVEREF(__pyx_t_7);
+    __pyx_cur_scope->__pyx_v_sslcontext = __pyx_t_7;
+    __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":1898
+ *             ssl_waiter = self._new_future()
+ *             sslcontext = None if isinstance(ssl, bool) else ssl
+ *             protocol = SSLProtocol(             # <<<<<<<<<<<<<<
+ *                 self, app_protocol, sslcontext, ssl_waiter,
+ *                 False, server_hostname,
+ */
+    __pyx_t_7 = PyTuple_New(6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1898, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    PyTuple_SET_ITEM(__pyx_t_7, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_cur_scope->__pyx_v_app_protocol);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sslcontext);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sslcontext);
+    PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_cur_scope->__pyx_v_sslcontext);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
+    PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_cur_scope->__pyx_v_ssl_waiter);
+    __Pyx_INCREF(Py_False);
+    __Pyx_GIVEREF(Py_False);
+    PyTuple_SET_ITEM(__pyx_t_7, 4, Py_False);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_hostname);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_hostname);
+    PyTuple_SET_ITEM(__pyx_t_7, 5, __pyx_cur_scope->__pyx_v_server_hostname);
+
+    /* "uvloop/loop.pyx":1901
+ *                 self, app_protocol, sslcontext, ssl_waiter,
+ *                 False, server_hostname,
+ *                 ssl_handshake_timeout=ssl_handshake_timeout,             # <<<<<<<<<<<<<<
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)
+ *         else:
+ */
+    __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1901, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_ssl_handshake_timeout, __pyx_cur_scope->__pyx_v_ssl_handshake_timeout) < 0) __PYX_ERR(0, 1901, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1902
+ *                 False, server_hostname,
+ *                 ssl_handshake_timeout=ssl_handshake_timeout,
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)             # <<<<<<<<<<<<<<
+ *         else:
+ *             if server_hostname is not None:
+ */
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_ssl_shutdown_timeout, __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout) < 0) __PYX_ERR(0, 1901, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1898
+ *             ssl_waiter = self._new_future()
+ *             sslcontext = None if isinstance(ssl, bool) else ssl
+ *             protocol = SSLProtocol(             # <<<<<<<<<<<<<<
+ *                 self, app_protocol, sslcontext, ssl_waiter,
+ *                 False, server_hostname,
+ */
+    __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_SSLProtocol), __pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1898, __pyx_L1_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_GOTREF(__pyx_cur_scope->__pyx_v_protocol);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_protocol, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":1889
+ *         ssl_waiter = None
+ *         context = Context_CopyCurrent()
+ *         if ssl:             # <<<<<<<<<<<<<<
+ *             if server_hostname is None:
+ *                 if not host:
+ */
+    goto __pyx_L11;
+  }
+
+  /* "uvloop/loop.pyx":1904
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)
+ *         else:
+ *             if server_hostname is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError('server_hostname is only meaningful with ssl')
+ *             if ssl_handshake_timeout is not None:
+ */
+  /*else*/ {
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_server_hostname != Py_None);
+    __pyx_t_3 = (__pyx_t_1 != 0);
+    if (unlikely(__pyx_t_3)) {
+
+      /* "uvloop/loop.pyx":1905
+ *         else:
+ *             if server_hostname is not None:
+ *                 raise ValueError('server_hostname is only meaningful with ssl')             # <<<<<<<<<<<<<<
+ *             if ssl_handshake_timeout is not None:
+ *                 raise ValueError(
+ */
+      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1905, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __PYX_ERR(0, 1905, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1904
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)
+ *         else:
+ *             if server_hostname is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError('server_hostname is only meaningful with ssl')
+ *             if ssl_handshake_timeout is not None:
+ */
+    }
+
+    /* "uvloop/loop.pyx":1906
+ *             if server_hostname is not None:
+ *                 raise ValueError('server_hostname is only meaningful with ssl')
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+    __pyx_t_3 = (__pyx_cur_scope->__pyx_v_ssl_handshake_timeout != Py_None);
+    __pyx_t_1 = (__pyx_t_3 != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":1907
+ *                 raise ValueError('server_hostname is only meaningful with ssl')
+ *             if ssl_handshake_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ */
+      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1907, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __PYX_ERR(0, 1907, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1906
+ *             if server_hostname is not None:
+ *                 raise ValueError('server_hostname is only meaningful with ssl')
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+    }
+
+    /* "uvloop/loop.pyx":1909
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout != Py_None);
+    __pyx_t_3 = (__pyx_t_1 != 0);
+    if (unlikely(__pyx_t_3)) {
+
+      /* "uvloop/loop.pyx":1910
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ */
+      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1910, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __PYX_ERR(0, 1910, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1909
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    }
+  }
+  __pyx_L11:;
+
+  /* "uvloop/loop.pyx":1913
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ *         if host is not None or port is not None:             # <<<<<<<<<<<<<<
+ *             if sock is not None:
+ *                 raise ValueError(
+ */
+  __pyx_t_1 = (__pyx_cur_scope->__pyx_v_host != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_3 = __pyx_t_2;
+    goto __pyx_L18_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_port != Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  __pyx_t_3 = __pyx_t_1;
+  __pyx_L18_bool_binop_done:;
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":1914
+ * 
+ *         if host is not None or port is not None:
+ *             if sock is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ */
+    __pyx_t_3 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
+    __pyx_t_1 = (__pyx_t_3 != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":1915
+ *         if host is not None or port is not None:
+ *             if sock is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'host/port and sock can not be specified at the same time')
+ * 
+ */
+      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1915, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __PYX_ERR(0, 1915, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1914
+ * 
+ *         if host is not None or port is not None:
+ *             if sock is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'host/port and sock can not be specified at the same time')
+ */
+    }
+
+    /* "uvloop/loop.pyx":1918
+ *                     'host/port and sock can not be specified at the same time')
+ * 
+ *             fs = []             # <<<<<<<<<<<<<<
+ *             f1 = f2 = None
+ * 
+ */
+    __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1918, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_5);
+    __pyx_cur_scope->__pyx_v_fs = ((PyObject*)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":1919
+ * 
+ *             fs = []
+ *             f1 = f2 = None             # <<<<<<<<<<<<<<
+ * 
+ *             addr = __static_getaddrinfo(
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __pyx_cur_scope->__pyx_v_f1 = Py_None;
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __pyx_cur_scope->__pyx_v_f2 = Py_None;
+
+    /* "uvloop/loop.pyx":1922
+ * 
+ *             addr = __static_getaddrinfo(
+ *                 host, port, family, uv.SOCK_STREAM,             # <<<<<<<<<<<<<<
+ *                 proto, <system.sockaddr*>&rai_addr_static)
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1922, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1923
+ *             addr = __static_getaddrinfo(
+ *                 host, port, family, uv.SOCK_STREAM,
+ *                 proto, <system.sockaddr*>&rai_addr_static)             # <<<<<<<<<<<<<<
+ * 
+ *             if addr is None:
+ */
+    __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1923, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":1921
+ *             f1 = f2 = None
+ * 
+ *             addr = __static_getaddrinfo(             # <<<<<<<<<<<<<<
+ *                 host, port, family, uv.SOCK_STREAM,
+ *                 proto, <system.sockaddr*>&rai_addr_static)
+ */
+    __pyx_t_5 = __pyx_f_6uvloop_4loop___static_getaddrinfo(__pyx_cur_scope->__pyx_v_host, __pyx_cur_scope->__pyx_v_port, __pyx_t_8, SOCK_STREAM, __pyx_t_9, ((struct sockaddr *)(&__pyx_cur_scope->__pyx_v_rai_addr_static))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1921, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_5);
+    __pyx_cur_scope->__pyx_v_addr = __pyx_t_5;
+    __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":1925
+ *                 proto, <system.sockaddr*>&rai_addr_static)
+ * 
+ *             if addr is None:             # <<<<<<<<<<<<<<
+ *                 f1 = self._getaddrinfo(
+ *                     host, port, family,
+ */
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_addr == Py_None);
+    __pyx_t_3 = (__pyx_t_1 != 0);
+    if (__pyx_t_3) {
+
+      /* "uvloop/loop.pyx":1927
+ *             if addr is None:
+ *                 f1 = self._getaddrinfo(
+ *                     host, port, family,             # <<<<<<<<<<<<<<
+ *                     uv.SOCK_STREAM, proto, flags,
+ *                     0)  # 0 == don't unpack
+ */
+      __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1927, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1928
+ *                 f1 = self._getaddrinfo(
+ *                     host, port, family,
+ *                     uv.SOCK_STREAM, proto, flags,             # <<<<<<<<<<<<<<
+ *                     0)  # 0 == don't unpack
+ * 
+ */
+      __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1928, __pyx_L1_error)
+      __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_flags); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1928, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1926
+ * 
+ *             if addr is None:
+ *                 f1 = self._getaddrinfo(             # <<<<<<<<<<<<<<
+ *                     host, port, family,
+ *                     uv.SOCK_STREAM, proto, flags,
+ */
+      __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_host, __pyx_cur_scope->__pyx_v_port, __pyx_t_9, SOCK_STREAM, __pyx_t_8, __pyx_t_10, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1926, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_f1);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_f1, __pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":1931
+ *                     0)  # 0 == don't unpack
+ * 
+ *                 fs.append(f1)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 rai_static.ai_addr = <system.sockaddr*>&rai_addr_static
+ */
+      __pyx_t_11 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_fs, __pyx_cur_scope->__pyx_v_f1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 1931, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1925
+ *                 proto, <system.sockaddr*>&rai_addr_static)
+ * 
+ *             if addr is None:             # <<<<<<<<<<<<<<
+ *                 f1 = self._getaddrinfo(
+ *                     host, port, family,
+ */
+      goto __pyx_L21;
+    }
+
+    /* "uvloop/loop.pyx":1933
+ *                 fs.append(f1)
+ *             else:
+ *                 rai_static.ai_addr = <system.sockaddr*>&rai_addr_static             # <<<<<<<<<<<<<<
+ *                 rai_static.ai_next = NULL
+ *                 rai = &rai_static
+ */
+    /*else*/ {
+      __pyx_cur_scope->__pyx_v_rai_static.ai_addr = ((struct sockaddr *)(&__pyx_cur_scope->__pyx_v_rai_addr_static));
+
+      /* "uvloop/loop.pyx":1934
+ *             else:
+ *                 rai_static.ai_addr = <system.sockaddr*>&rai_addr_static
+ *                 rai_static.ai_next = NULL             # <<<<<<<<<<<<<<
+ *                 rai = &rai_static
+ * 
+ */
+      __pyx_cur_scope->__pyx_v_rai_static.ai_next = NULL;
+
+      /* "uvloop/loop.pyx":1935
+ *                 rai_static.ai_addr = <system.sockaddr*>&rai_addr_static
+ *                 rai_static.ai_next = NULL
+ *                 rai = &rai_static             # <<<<<<<<<<<<<<
+ * 
+ *             if local_addr is not None:
+ */
+      __pyx_cur_scope->__pyx_v_rai = (&__pyx_cur_scope->__pyx_v_rai_static);
+    }
+    __pyx_L21:;
+
+    /* "uvloop/loop.pyx":1937
+ *                 rai = &rai_static
+ * 
+ *             if local_addr is not None:             # <<<<<<<<<<<<<<
+ *                 if not isinstance(local_addr, (tuple, list)) or \
+ *                         len(local_addr) != 2:
+ */
+    __pyx_t_3 = (__pyx_cur_scope->__pyx_v_local_addr != Py_None);
+    __pyx_t_1 = (__pyx_t_3 != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/loop.pyx":1938
+ * 
+ *             if local_addr is not None:
+ *                 if not isinstance(local_addr, (tuple, list)) or \             # <<<<<<<<<<<<<<
+ *                         len(local_addr) != 2:
+ *                     raise ValueError(
+ */
+      __pyx_t_2 = PyTuple_Check(__pyx_cur_scope->__pyx_v_local_addr); 
+      __pyx_t_12 = (__pyx_t_2 != 0);
+      if (!__pyx_t_12) {
+      } else {
+        __pyx_t_3 = __pyx_t_12;
+        goto __pyx_L26_bool_binop_done;
+      }
+      __pyx_t_12 = PyList_Check(__pyx_cur_scope->__pyx_v_local_addr); 
+      __pyx_t_2 = (__pyx_t_12 != 0);
+      __pyx_t_3 = __pyx_t_2;
+      __pyx_L26_bool_binop_done:;
+      __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0);
+      if (!__pyx_t_2) {
+      } else {
+        __pyx_t_1 = __pyx_t_2;
+        goto __pyx_L24_bool_binop_done;
+      }
+
+      /* "uvloop/loop.pyx":1939
+ *             if local_addr is not None:
+ *                 if not isinstance(local_addr, (tuple, list)) or \
+ *                         len(local_addr) != 2:             # <<<<<<<<<<<<<<
+ *                     raise ValueError(
+ *                         'local_addr must be a tuple of host and port')
+ */
+      __pyx_t_13 = PyObject_Length(__pyx_cur_scope->__pyx_v_local_addr); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1939, __pyx_L1_error)
+      __pyx_t_2 = ((__pyx_t_13 != 2) != 0);
+      __pyx_t_1 = __pyx_t_2;
+      __pyx_L24_bool_binop_done:;
+
+      /* "uvloop/loop.pyx":1938
+ * 
+ *             if local_addr is not None:
+ *                 if not isinstance(local_addr, (tuple, list)) or \             # <<<<<<<<<<<<<<
+ *                         len(local_addr) != 2:
+ *                     raise ValueError(
+ */
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/loop.pyx":1940
+ *                 if not isinstance(local_addr, (tuple, list)) or \
+ *                         len(local_addr) != 2:
+ *                     raise ValueError(             # <<<<<<<<<<<<<<
+ *                         'local_addr must be a tuple of host and port')
+ * 
+ */
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1940, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __PYX_ERR(0, 1940, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":1938
+ * 
+ *             if local_addr is not None:
+ *                 if not isinstance(local_addr, (tuple, list)) or \             # <<<<<<<<<<<<<<
+ *                         len(local_addr) != 2:
+ *                     raise ValueError(
+ */
+      }
+
+      /* "uvloop/loop.pyx":1944
+ * 
+ *                 addr = __static_getaddrinfo(
+ *                     local_addr[0], local_addr[1],             # <<<<<<<<<<<<<<
+ *                     family, uv.SOCK_STREAM,
+ *                     proto, <system.sockaddr*>&lai_addr_static)
+ */
+      __pyx_t_5 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1944, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_4 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1944, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/loop.pyx":1945
+ *                 addr = __static_getaddrinfo(
+ *                     local_addr[0], local_addr[1],
+ *                     family, uv.SOCK_STREAM,             # <<<<<<<<<<<<<<
+ *                     proto, <system.sockaddr*>&lai_addr_static)
+ *                 if addr is None:
+ */
+      __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1945, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1946
+ *                     local_addr[0], local_addr[1],
+ *                     family, uv.SOCK_STREAM,
+ *                     proto, <system.sockaddr*>&lai_addr_static)             # <<<<<<<<<<<<<<
+ *                 if addr is None:
+ *                     f2 = self._getaddrinfo(
+ */
+      __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1946, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":1943
+ *                         'local_addr must be a tuple of host and port')
+ * 
+ *                 addr = __static_getaddrinfo(             # <<<<<<<<<<<<<<
+ *                     local_addr[0], local_addr[1],
+ *                     family, uv.SOCK_STREAM,
+ */
+      __pyx_t_7 = __pyx_f_6uvloop_4loop___static_getaddrinfo(__pyx_t_5, __pyx_t_4, __pyx_t_10, SOCK_STREAM, __pyx_t_8, ((struct sockaddr *)(&__pyx_cur_scope->__pyx_v_lai_addr_static))); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1943, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_addr);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_addr, __pyx_t_7);
+      __Pyx_GIVEREF(__pyx_t_7);
+      __pyx_t_7 = 0;
+
+      /* "uvloop/loop.pyx":1947
+ *                     family, uv.SOCK_STREAM,
+ *                     proto, <system.sockaddr*>&lai_addr_static)
+ *                 if addr is None:             # <<<<<<<<<<<<<<
+ *                     f2 = self._getaddrinfo(
+ *                         local_addr[0], local_addr[1], family,
+ */
+      __pyx_t_1 = (__pyx_cur_scope->__pyx_v_addr == Py_None);
+      __pyx_t_2 = (__pyx_t_1 != 0);
+      if (__pyx_t_2) {
+
+        /* "uvloop/loop.pyx":1949
+ *                 if addr is None:
+ *                     f2 = self._getaddrinfo(
+ *                         local_addr[0], local_addr[1], family,             # <<<<<<<<<<<<<<
+ *                         uv.SOCK_STREAM, proto, flags,
+ *                         0)  # 0 == don't unpack
+ */
+        __pyx_t_7 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1949, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __pyx_t_4 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1949, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1949, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":1950
+ *                     f2 = self._getaddrinfo(
+ *                         local_addr[0], local_addr[1], family,
+ *                         uv.SOCK_STREAM, proto, flags,             # <<<<<<<<<<<<<<
+ *                         0)  # 0 == don't unpack
+ * 
+ */
+        __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1950, __pyx_L1_error)
+        __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_flags); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1950, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":1948
+ *                     proto, <system.sockaddr*>&lai_addr_static)
+ *                 if addr is None:
+ *                     f2 = self._getaddrinfo(             # <<<<<<<<<<<<<<
+ *                         local_addr[0], local_addr[1], family,
+ *                         uv.SOCK_STREAM, proto, flags,
+ */
+        __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_t_7, __pyx_t_4, __pyx_t_8, SOCK_STREAM, __pyx_t_10, __pyx_t_9, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1948, __pyx_L1_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_GOTREF(__pyx_cur_scope->__pyx_v_f2);
+        __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_f2, __pyx_t_5);
+        __Pyx_GIVEREF(__pyx_t_5);
+        __pyx_t_5 = 0;
+
+        /* "uvloop/loop.pyx":1953
+ *                         0)  # 0 == don't unpack
+ * 
+ *                     fs.append(f2)             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     lai_static.ai_addr = <system.sockaddr*>&lai_addr_static
+ */
+        __pyx_t_11 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_fs, __pyx_cur_scope->__pyx_v_f2); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 1953, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":1947
+ *                     family, uv.SOCK_STREAM,
+ *                     proto, <system.sockaddr*>&lai_addr_static)
+ *                 if addr is None:             # <<<<<<<<<<<<<<
+ *                     f2 = self._getaddrinfo(
+ *                         local_addr[0], local_addr[1], family,
+ */
+        goto __pyx_L28;
+      }
+
+      /* "uvloop/loop.pyx":1955
+ *                     fs.append(f2)
+ *                 else:
+ *                     lai_static.ai_addr = <system.sockaddr*>&lai_addr_static             # <<<<<<<<<<<<<<
+ *                     lai_static.ai_next = NULL
+ *                     lai = &lai_static
+ */
+      /*else*/ {
+        __pyx_cur_scope->__pyx_v_lai_static.ai_addr = ((struct sockaddr *)(&__pyx_cur_scope->__pyx_v_lai_addr_static));
+
+        /* "uvloop/loop.pyx":1956
+ *                 else:
+ *                     lai_static.ai_addr = <system.sockaddr*>&lai_addr_static
+ *                     lai_static.ai_next = NULL             # <<<<<<<<<<<<<<
+ *                     lai = &lai_static
+ * 
+ */
+        __pyx_cur_scope->__pyx_v_lai_static.ai_next = NULL;
+
+        /* "uvloop/loop.pyx":1957
+ *                     lai_static.ai_addr = <system.sockaddr*>&lai_addr_static
+ *                     lai_static.ai_next = NULL
+ *                     lai = &lai_static             # <<<<<<<<<<<<<<
+ * 
+ *             if len(fs):
+ */
+        __pyx_cur_scope->__pyx_v_lai = (&__pyx_cur_scope->__pyx_v_lai_static);
+      }
+      __pyx_L28:;
+
+      /* "uvloop/loop.pyx":1937
+ *                 rai = &rai_static
+ * 
+ *             if local_addr is not None:             # <<<<<<<<<<<<<<
+ *                 if not isinstance(local_addr, (tuple, list)) or \
+ *                         len(local_addr) != 2:
+ */
+    }
+
+    /* "uvloop/loop.pyx":1959
+ *                     lai = &lai_static
+ * 
+ *             if len(fs):             # <<<<<<<<<<<<<<
+ *                 await aio_wait(fs)
+ * 
+ */
+    __pyx_t_13 = PyList_GET_SIZE(__pyx_cur_scope->__pyx_v_fs); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1959, __pyx_L1_error)
+    __pyx_t_2 = (__pyx_t_13 != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/loop.pyx":1960
+ * 
+ *             if len(fs):
+ *                 await aio_wait(fs)             # <<<<<<<<<<<<<<
+ * 
+ *             if rai is NULL:
+ */
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_wait);
+      __pyx_t_4 = __pyx_v_6uvloop_4loop_aio_wait; __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_4, function);
+        }
+      }
+      __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_7, __pyx_cur_scope->__pyx_v_fs) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_fs);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1960, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_5);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XGOTREF(__pyx_r);
+      if (likely(__pyx_r)) {
+        __Pyx_XGIVEREF(__pyx_r);
+        __Pyx_RefNannyFinishContext();
+        __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+        /* return from generator, awaiting value */
+        __pyx_generator->resume_label = 2;
+        return __pyx_r;
+        __pyx_L30_resume_from_await:;
+        if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1960, __pyx_L1_error)
+      } else {
+        PyObject* exc_type = __Pyx_PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+          else __PYX_ERR(0, 1960, __pyx_L1_error)
+        }
+      }
+
+      /* "uvloop/loop.pyx":1959
+ *                     lai = &lai_static
+ * 
+ *             if len(fs):             # <<<<<<<<<<<<<<
+ *                 await aio_wait(fs)
+ * 
+ */
+    }
+
+    /* "uvloop/loop.pyx":1962
+ *                 await aio_wait(fs)
+ * 
+ *             if rai is NULL:             # <<<<<<<<<<<<<<
+ *                 ai_remote = f1.result()
+ *                 if ai_remote.data is NULL:
+ */
+    __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_rai == NULL) != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/loop.pyx":1963
+ * 
+ *             if rai is NULL:
+ *                 ai_remote = f1.result()             # <<<<<<<<<<<<<<
+ *                 if ai_remote.data is NULL:
+ *                     raise OSError('getaddrinfo() returned empty list')
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_f1, __pyx_n_s_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1963, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_4, function);
+        }
+      }
+      __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1963, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_6uvloop_4loop_AddrInfo))))) __PYX_ERR(0, 1963, __pyx_L1_error)
+      __Pyx_GIVEREF(__pyx_t_5);
+      __pyx_cur_scope->__pyx_v_ai_remote = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":1964
+ *             if rai is NULL:
+ *                 ai_remote = f1.result()
+ *                 if ai_remote.data is NULL:             # <<<<<<<<<<<<<<
+ *                     raise OSError('getaddrinfo() returned empty list')
+ *                 rai = ai_remote.data
+ */
+      __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_ai_remote->data == NULL) != 0);
+      if (unlikely(__pyx_t_2)) {
+
+        /* "uvloop/loop.pyx":1965
+ *                 ai_remote = f1.result()
+ *                 if ai_remote.data is NULL:
+ *                     raise OSError('getaddrinfo() returned empty list')             # <<<<<<<<<<<<<<
+ *                 rai = ai_remote.data
+ * 
+ */
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1965, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __PYX_ERR(0, 1965, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":1964
+ *             if rai is NULL:
+ *                 ai_remote = f1.result()
+ *                 if ai_remote.data is NULL:             # <<<<<<<<<<<<<<
+ *                     raise OSError('getaddrinfo() returned empty list')
+ *                 rai = ai_remote.data
+ */
+      }
+
+      /* "uvloop/loop.pyx":1966
+ *                 if ai_remote.data is NULL:
+ *                     raise OSError('getaddrinfo() returned empty list')
+ *                 rai = ai_remote.data             # <<<<<<<<<<<<<<
+ * 
+ *             if lai is NULL and f2 is not None:
+ */
+      __pyx_t_14 = __pyx_cur_scope->__pyx_v_ai_remote->data;
+      __pyx_cur_scope->__pyx_v_rai = __pyx_t_14;
+
+      /* "uvloop/loop.pyx":1962
+ *                 await aio_wait(fs)
+ * 
+ *             if rai is NULL:             # <<<<<<<<<<<<<<
+ *                 ai_remote = f1.result()
+ *                 if ai_remote.data is NULL:
+ */
+    }
+
+    /* "uvloop/loop.pyx":1968
+ *                 rai = ai_remote.data
+ * 
+ *             if lai is NULL and f2 is not None:             # <<<<<<<<<<<<<<
+ *                 ai_local = f2.result()
+ *                 if ai_local.data is NULL:
+ */
+    __pyx_t_1 = ((__pyx_cur_scope->__pyx_v_lai == NULL) != 0);
+    if (__pyx_t_1) {
+    } else {
+      __pyx_t_2 = __pyx_t_1;
+      goto __pyx_L34_bool_binop_done;
+    }
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_f2 != Py_None);
+    __pyx_t_3 = (__pyx_t_1 != 0);
+    __pyx_t_2 = __pyx_t_3;
+    __pyx_L34_bool_binop_done:;
+    if (__pyx_t_2) {
+
+      /* "uvloop/loop.pyx":1969
+ * 
+ *             if lai is NULL and f2 is not None:
+ *                 ai_local = f2.result()             # <<<<<<<<<<<<<<
+ *                 if ai_local.data is NULL:
+ *                     raise OSError(
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_f2, __pyx_n_s_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1969, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_4, function);
+        }
+      }
+      __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1969, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_6uvloop_4loop_AddrInfo))))) __PYX_ERR(0, 1969, __pyx_L1_error)
+      __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_ai_local));
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_ai_local, ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_t_5));
+      __Pyx_GIVEREF(__pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":1970
+ *             if lai is NULL and f2 is not None:
+ *                 ai_local = f2.result()
+ *                 if ai_local.data is NULL:             # <<<<<<<<<<<<<<
+ *                     raise OSError(
+ *                         'getaddrinfo() returned empty list for local_addr')
+ */
+      __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_ai_local->data == NULL) != 0);
+      if (unlikely(__pyx_t_2)) {
+
+        /* "uvloop/loop.pyx":1971
+ *                 ai_local = f2.result()
+ *                 if ai_local.data is NULL:
+ *                     raise OSError(             # <<<<<<<<<<<<<<
+ *                         'getaddrinfo() returned empty list for local_addr')
+ *                 lai = ai_local.data
+ */
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1971, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __PYX_ERR(0, 1971, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":1970
+ *             if lai is NULL and f2 is not None:
+ *                 ai_local = f2.result()
+ *                 if ai_local.data is NULL:             # <<<<<<<<<<<<<<
+ *                     raise OSError(
+ *                         'getaddrinfo() returned empty list for local_addr')
+ */
+      }
+
+      /* "uvloop/loop.pyx":1973
+ *                     raise OSError(
+ *                         'getaddrinfo() returned empty list for local_addr')
+ *                 lai = ai_local.data             # <<<<<<<<<<<<<<
+ * 
+ *             exceptions = []
+ */
+      __pyx_t_14 = __pyx_cur_scope->__pyx_v_ai_local->data;
+      __pyx_cur_scope->__pyx_v_lai = __pyx_t_14;
+
+      /* "uvloop/loop.pyx":1968
+ *                 rai = ai_remote.data
+ * 
+ *             if lai is NULL and f2 is not None:             # <<<<<<<<<<<<<<
+ *                 ai_local = f2.result()
+ *                 if ai_local.data is NULL:
+ */
+    }
+
+    /* "uvloop/loop.pyx":1975
+ *                 lai = ai_local.data
+ * 
+ *             exceptions = []             # <<<<<<<<<<<<<<
+ *             rai_iter = rai
+ *             while rai_iter is not NULL:
+ */
+    __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1975, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_5);
+    __pyx_cur_scope->__pyx_v_exceptions = ((PyObject*)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":1976
+ * 
+ *             exceptions = []
+ *             rai_iter = rai             # <<<<<<<<<<<<<<
+ *             while rai_iter is not NULL:
+ *                 tr = None
+ */
+    __pyx_cur_scope->__pyx_v_rai_iter = __pyx_cur_scope->__pyx_v_rai;
+
+    /* "uvloop/loop.pyx":1977
+ *             exceptions = []
+ *             rai_iter = rai
+ *             while rai_iter is not NULL:             # <<<<<<<<<<<<<<
+ *                 tr = None
+ *                 try:
+ */
+    while (1) {
+      __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_rai_iter != NULL) != 0);
+      if (!__pyx_t_2) break;
+
+      /* "uvloop/loop.pyx":1978
+ *             rai_iter = rai
+ *             while rai_iter is not NULL:
+ *                 tr = None             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     waiter = self._new_future()
+ */
+      __Pyx_INCREF(Py_None);
+      __Pyx_XGOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
+      __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_tr, ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)Py_None));
+      __Pyx_GIVEREF(Py_None);
+
+      /* "uvloop/loop.pyx":1979
+ *             while rai_iter is not NULL:
+ *                 tr = None
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     waiter = self._new_future()
+ *                     tr = TCPTransport.new(self, protocol, None, waiter,
+ */
+      {
+        __Pyx_ExceptionSave(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+        __Pyx_XGOTREF(__pyx_t_15);
+        __Pyx_XGOTREF(__pyx_t_16);
+        __Pyx_XGOTREF(__pyx_t_17);
+        /*try:*/ {
+
+          /* "uvloop/loop.pyx":1980
+ *                 tr = None
+ *                 try:
+ *                     waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *                     tr = TCPTransport.new(self, protocol, None, waiter,
+ *                                           context)
+ */
+          __pyx_t_5 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1980, __pyx_L39_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_waiter);
+          __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_waiter, __pyx_t_5);
+          __Pyx_GIVEREF(__pyx_t_5);
+          __pyx_t_5 = 0;
+
+          /* "uvloop/loop.pyx":1981
+ *                 try:
+ *                     waiter = self._new_future()
+ *                     tr = TCPTransport.new(self, protocol, None, waiter,             # <<<<<<<<<<<<<<
+ *                                           context)
+ * 
+ */
+          __pyx_t_5 = ((PyObject *)__pyx_f_6uvloop_4loop_12TCPTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter, __pyx_cur_scope->__pyx_v_context)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1981, __pyx_L39_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
+          __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_tr, ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)__pyx_t_5));
+          __Pyx_GIVEREF(__pyx_t_5);
+          __pyx_t_5 = 0;
+
+          /* "uvloop/loop.pyx":1984
+ *                                           context)
+ * 
+ *                     if lai is not NULL:             # <<<<<<<<<<<<<<
+ *                         lai_iter = lai
+ *                         while lai_iter is not NULL:
+ */
+          __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_lai != NULL) != 0);
+          if (__pyx_t_2) {
+
+            /* "uvloop/loop.pyx":1985
+ * 
+ *                     if lai is not NULL:
+ *                         lai_iter = lai             # <<<<<<<<<<<<<<
+ *                         while lai_iter is not NULL:
+ *                             try:
+ */
+            __pyx_cur_scope->__pyx_v_lai_iter = __pyx_cur_scope->__pyx_v_lai;
+
+            /* "uvloop/loop.pyx":1986
+ *                     if lai is not NULL:
+ *                         lai_iter = lai
+ *                         while lai_iter is not NULL:             # <<<<<<<<<<<<<<
+ *                             try:
+ *                                 tr.bind(lai_iter.ai_addr)
+ */
+            while (1) {
+              __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_lai_iter != NULL) != 0);
+              if (!__pyx_t_2) break;
+
+              /* "uvloop/loop.pyx":1987
+ *                         lai_iter = lai
+ *                         while lai_iter is not NULL:
+ *                             try:             # <<<<<<<<<<<<<<
+ *                                 tr.bind(lai_iter.ai_addr)
+ *                                 break
+ */
+              {
+                __Pyx_ExceptionSave(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+                __Pyx_XGOTREF(__pyx_t_18);
+                __Pyx_XGOTREF(__pyx_t_19);
+                __Pyx_XGOTREF(__pyx_t_20);
+                /*try:*/ {
+
+                  /* "uvloop/loop.pyx":1988
+ *                         while lai_iter is not NULL:
+ *                             try:
+ *                                 tr.bind(lai_iter.ai_addr)             # <<<<<<<<<<<<<<
+ *                                 break
+ *                             except OSError as exc:
+ */
+                  __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->bind(__pyx_cur_scope->__pyx_v_tr, __pyx_cur_scope->__pyx_v_lai_iter->ai_addr, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1988, __pyx_L50_error)
+                  __Pyx_GOTREF(__pyx_t_5);
+                  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+                  /* "uvloop/loop.pyx":1989
+ *                             try:
+ *                                 tr.bind(lai_iter.ai_addr)
+ *                                 break             # <<<<<<<<<<<<<<
+ *                             except OSError as exc:
+ *                                 exceptions.append(exc)
+ */
+                  goto __pyx_L55_try_break;
+
+                  /* "uvloop/loop.pyx":1987
+ *                         lai_iter = lai
+ *                         while lai_iter is not NULL:
+ *                             try:             # <<<<<<<<<<<<<<
+ *                                 tr.bind(lai_iter.ai_addr)
+ *                                 break
+ */
+                }
+                __pyx_L50_error:;
+                __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+                __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+                __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+                __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+                /* "uvloop/loop.pyx":1990
+ *                                 tr.bind(lai_iter.ai_addr)
+ *                                 break
+ *                             except OSError as exc:             # <<<<<<<<<<<<<<
+ *                                 exceptions.append(exc)
+ *                             lai_iter = lai_iter.ai_next
+ */
+                __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
+                if (__pyx_t_9) {
+                  __Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+                  if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(0, 1990, __pyx_L52_except_error)
+                  __Pyx_GOTREF(__pyx_t_5);
+                  __Pyx_GOTREF(__pyx_t_4);
+                  __Pyx_GOTREF(__pyx_t_7);
+                  __Pyx_INCREF(__pyx_t_4);
+                  __Pyx_GIVEREF(__pyx_t_4);
+                  __pyx_cur_scope->__pyx_v_exc = __pyx_t_4;
+                  /*try:*/ {
+
+                    /* "uvloop/loop.pyx":1991
+ *                                 break
+ *                             except OSError as exc:
+ *                                 exceptions.append(exc)             # <<<<<<<<<<<<<<
+ *                             lai_iter = lai_iter.ai_next
+ *                         else:
+ */
+                    __pyx_t_11 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_exceptions, __pyx_cur_scope->__pyx_v_exc); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 1991, __pyx_L63_error)
+                  }
+
+                  /* "uvloop/loop.pyx":1990
+ *                                 tr.bind(lai_iter.ai_addr)
+ *                                 break
+ *                             except OSError as exc:             # <<<<<<<<<<<<<<
+ *                                 exceptions.append(exc)
+ *                             lai_iter = lai_iter.ai_next
+ */
+                  /*finally:*/ {
+                    /*normal exit:*/{
+                      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_exc);
+                      __Pyx_DECREF(__pyx_cur_scope->__pyx_v_exc);
+                      __pyx_cur_scope->__pyx_v_exc = NULL;
+                      goto __pyx_L64;
+                    }
+                    __pyx_L63_error:;
+                    /*exception exit:*/{
+                      __Pyx_PyThreadState_assign
+                      __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0;
+                      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+                      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_25, &__pyx_t_26, &__pyx_t_27);
+                      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_22, &__pyx_t_23, &__pyx_t_24) < 0)) __Pyx_ErrFetch(&__pyx_t_22, &__pyx_t_23, &__pyx_t_24);
+                      __Pyx_XGOTREF(__pyx_t_22);
+                      __Pyx_XGOTREF(__pyx_t_23);
+                      __Pyx_XGOTREF(__pyx_t_24);
+                      __Pyx_XGOTREF(__pyx_t_25);
+                      __Pyx_XGOTREF(__pyx_t_26);
+                      __Pyx_XGOTREF(__pyx_t_27);
+                      __pyx_t_9 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_21 = __pyx_filename;
+                      {
+                        __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_exc);
+                        __Pyx_DECREF(__pyx_cur_scope->__pyx_v_exc);
+                        __pyx_cur_scope->__pyx_v_exc = NULL;
+                      }
+                      if (PY_MAJOR_VERSION >= 3) {
+                        __Pyx_XGIVEREF(__pyx_t_25);
+                        __Pyx_XGIVEREF(__pyx_t_26);
+                        __Pyx_XGIVEREF(__pyx_t_27);
+                        __Pyx_ExceptionReset(__pyx_t_25, __pyx_t_26, __pyx_t_27);
+                      }
+                      __Pyx_XGIVEREF(__pyx_t_22);
+                      __Pyx_XGIVEREF(__pyx_t_23);
+                      __Pyx_XGIVEREF(__pyx_t_24);
+                      __Pyx_ErrRestore(__pyx_t_22, __pyx_t_23, __pyx_t_24);
+                      __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0;
+                      __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_21;
+                      goto __pyx_L52_except_error;
+                    }
+                    __pyx_L64:;
+                  }
+                  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+                  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+                  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+                  goto __pyx_L51_exception_handled;
+                }
+                goto __pyx_L52_except_error;
+                __pyx_L52_except_error:;
+
+                /* "uvloop/loop.pyx":1987
+ *                         lai_iter = lai
+ *                         while lai_iter is not NULL:
+ *                             try:             # <<<<<<<<<<<<<<
+ *                                 tr.bind(lai_iter.ai_addr)
+ *                                 break
+ */
+                __Pyx_XGIVEREF(__pyx_t_18);
+                __Pyx_XGIVEREF(__pyx_t_19);
+                __Pyx_XGIVEREF(__pyx_t_20);
+                __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+                goto __pyx_L39_error;
+                __pyx_L55_try_break:;
+                __Pyx_XGIVEREF(__pyx_t_18);
+                __Pyx_XGIVEREF(__pyx_t_19);
+                __Pyx_XGIVEREF(__pyx_t_20);
+                __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+                goto __pyx_L49_break;
+                __pyx_L51_exception_handled:;
+                __Pyx_XGIVEREF(__pyx_t_18);
+                __Pyx_XGIVEREF(__pyx_t_19);
+                __Pyx_XGIVEREF(__pyx_t_20);
+                __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+              }
+
+              /* "uvloop/loop.pyx":1992
+ *                             except OSError as exc:
+ *                                 exceptions.append(exc)
+ *                             lai_iter = lai_iter.ai_next             # <<<<<<<<<<<<<<
+ *                         else:
+ *                             tr._close()
+ */
+              __pyx_t_14 = __pyx_cur_scope->__pyx_v_lai_iter->ai_next;
+              __pyx_cur_scope->__pyx_v_lai_iter = __pyx_t_14;
+            }
+
+            /* "uvloop/loop.pyx":1994
+ *                             lai_iter = lai_iter.ai_next
+ *                         else:
+ *                             tr._close()             # <<<<<<<<<<<<<<
+ *                             tr = None
+ * 
+ */
+            /*else*/ {
+              __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1994, __pyx_L39_error)
+              __Pyx_GOTREF(__pyx_t_7);
+              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+              /* "uvloop/loop.pyx":1995
+ *                         else:
+ *                             tr._close()
+ *                             tr = None             # <<<<<<<<<<<<<<
+ * 
+ *                             rai_iter = rai_iter.ai_next
+ */
+              __Pyx_INCREF(Py_None);
+              __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
+              __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_tr, ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)Py_None));
+              __Pyx_GIVEREF(Py_None);
+
+              /* "uvloop/loop.pyx":1997
+ *                             tr = None
+ * 
+ *                             rai_iter = rai_iter.ai_next             # <<<<<<<<<<<<<<
+ *                             continue
+ * 
+ */
+              __pyx_t_14 = __pyx_cur_scope->__pyx_v_rai_iter->ai_next;
+              __pyx_cur_scope->__pyx_v_rai_iter = __pyx_t_14;
+
+              /* "uvloop/loop.pyx":1998
+ * 
+ *                             rai_iter = rai_iter.ai_next
+ *                             continue             # <<<<<<<<<<<<<<
+ * 
+ *                     tr.connect(rai_iter.ai_addr)
+ */
+              goto __pyx_L45_try_continue;
+            }
+            __pyx_L49_break:;
+
+            /* "uvloop/loop.pyx":1984
+ *                                           context)
+ * 
+ *                     if lai is not NULL:             # <<<<<<<<<<<<<<
+ *                         lai_iter = lai
+ *                         while lai_iter is not NULL:
+ */
+          }
+
+          /* "uvloop/loop.pyx":2000
+ *                             continue
+ * 
+ *                     tr.connect(rai_iter.ai_addr)             # <<<<<<<<<<<<<<
+ *                     await waiter
+ * 
+ */
+          __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->connect(__pyx_cur_scope->__pyx_v_tr, __pyx_cur_scope->__pyx_v_rai_iter->ai_addr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2000, __pyx_L39_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+          /* "uvloop/loop.pyx":2001
+ * 
+ *                     tr.connect(rai_iter.ai_addr)
+ *                     await waiter             # <<<<<<<<<<<<<<
+ * 
+ *                 except OSError as exc:
+ */
+          __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+          __Pyx_XGOTREF(__pyx_r);
+          if (likely(__pyx_r)) {
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __pyx_cur_scope->__pyx_t_0 = __pyx_t_15;
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __pyx_cur_scope->__pyx_t_1 = __pyx_t_16;
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __pyx_cur_scope->__pyx_t_2 = __pyx_t_17;
+            __Pyx_XGIVEREF(__pyx_r);
+            __Pyx_RefNannyFinishContext();
+            __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+            /* return from generator, awaiting value */
+            __pyx_generator->resume_label = 3;
+            return __pyx_r;
+            __pyx_L69_resume_from_await:;
+            __pyx_t_15 = __pyx_cur_scope->__pyx_t_0;
+            __pyx_cur_scope->__pyx_t_0 = 0;
+            __Pyx_XGOTREF(__pyx_t_15);
+            __pyx_t_16 = __pyx_cur_scope->__pyx_t_1;
+            __pyx_cur_scope->__pyx_t_1 = 0;
+            __Pyx_XGOTREF(__pyx_t_16);
+            __pyx_t_17 = __pyx_cur_scope->__pyx_t_2;
+            __pyx_cur_scope->__pyx_t_2 = 0;
+            __Pyx_XGOTREF(__pyx_t_17);
+            if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2001, __pyx_L39_error)
+          } else {
+            PyObject* exc_type = __Pyx_PyErr_Occurred();
+            if (exc_type) {
+              if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+              else __PYX_ERR(0, 2001, __pyx_L39_error)
+            }
+          }
+
+          /* "uvloop/loop.pyx":1979
+ *             while rai_iter is not NULL:
+ *                 tr = None
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     waiter = self._new_future()
+ *                     tr = TCPTransport.new(self, protocol, None, waiter,
+ */
+        }
+
+        /* "uvloop/loop.pyx":2016
+ *                     raise
+ *                 else:
+ *                     break             # <<<<<<<<<<<<<<
+ * 
+ *                 rai_iter = rai_iter.ai_next
+ */
+        /*else:*/ {
+          goto __pyx_L44_try_break;
+        }
+        __pyx_L39_error:;
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+        /* "uvloop/loop.pyx":2003
+ *                     await waiter
+ * 
+ *                 except OSError as exc:             # <<<<<<<<<<<<<<
+ *                     if tr is not None:
+ *                         tr._close()
+ */
+        __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
+        if (__pyx_t_10) {
+          __Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(0, 2003, __pyx_L41_except_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_4);
+          __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_exc);
+          __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_exc, __pyx_t_4);
+          __Pyx_GIVEREF(__pyx_t_4);
+          /*try:*/ {
+
+            /* "uvloop/loop.pyx":2004
+ * 
+ *                 except OSError as exc:
+ *                     if tr is not None:             # <<<<<<<<<<<<<<
+ *                         tr._close()
+ *                         tr = None
+ */
+            __pyx_t_2 = (((PyObject *)__pyx_cur_scope->__pyx_v_tr) != Py_None);
+            __pyx_t_3 = (__pyx_t_2 != 0);
+            if (__pyx_t_3) {
+
+              /* "uvloop/loop.pyx":2005
+ *                 except OSError as exc:
+ *                     if tr is not None:
+ *                         tr._close()             # <<<<<<<<<<<<<<
+ *                         tr = None
+ *                     exceptions.append(exc)
+ */
+              __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2005, __pyx_L75_error)
+              __Pyx_GOTREF(__pyx_t_6);
+              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+              /* "uvloop/loop.pyx":2006
+ *                     if tr is not None:
+ *                         tr._close()
+ *                         tr = None             # <<<<<<<<<<<<<<
+ *                     exceptions.append(exc)
+ *                 except (KeyboardInterrupt, SystemExit):
+ */
+              __Pyx_INCREF(Py_None);
+              __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
+              __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_tr, ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)Py_None));
+              __Pyx_GIVEREF(Py_None);
+
+              /* "uvloop/loop.pyx":2004
+ * 
+ *                 except OSError as exc:
+ *                     if tr is not None:             # <<<<<<<<<<<<<<
+ *                         tr._close()
+ *                         tr = None
+ */
+            }
+
+            /* "uvloop/loop.pyx":2007
+ *                         tr._close()
+ *                         tr = None
+ *                     exceptions.append(exc)             # <<<<<<<<<<<<<<
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise
+ */
+            __pyx_t_11 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_exceptions, __pyx_cur_scope->__pyx_v_exc); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 2007, __pyx_L75_error)
+          }
+
+          /* "uvloop/loop.pyx":2003
+ *                     await waiter
+ * 
+ *                 except OSError as exc:             # <<<<<<<<<<<<<<
+ *                     if tr is not None:
+ *                         tr._close()
+ */
+          /*finally:*/ {
+            /*normal exit:*/{
+              __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_exc);
+              __Pyx_DECREF(__pyx_cur_scope->__pyx_v_exc);
+              __pyx_cur_scope->__pyx_v_exc = NULL;
+              goto __pyx_L76;
+            }
+            __pyx_L75_error:;
+            /*exception exit:*/{
+              __Pyx_PyThreadState_assign
+              __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_27 = 0; __pyx_t_26 = 0; __pyx_t_25 = 0;
+              __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+              if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_27, &__pyx_t_26, &__pyx_t_25);
+              if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18);
+              __Pyx_XGOTREF(__pyx_t_20);
+              __Pyx_XGOTREF(__pyx_t_19);
+              __Pyx_XGOTREF(__pyx_t_18);
+              __Pyx_XGOTREF(__pyx_t_27);
+              __Pyx_XGOTREF(__pyx_t_26);
+              __Pyx_XGOTREF(__pyx_t_25);
+              __pyx_t_10 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_28 = __pyx_filename;
+              {
+                __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_exc);
+                __Pyx_DECREF(__pyx_cur_scope->__pyx_v_exc);
+                __pyx_cur_scope->__pyx_v_exc = NULL;
+              }
+              if (PY_MAJOR_VERSION >= 3) {
+                __Pyx_XGIVEREF(__pyx_t_27);
+                __Pyx_XGIVEREF(__pyx_t_26);
+                __Pyx_XGIVEREF(__pyx_t_25);
+                __Pyx_ExceptionReset(__pyx_t_27, __pyx_t_26, __pyx_t_25);
+              }
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_ErrRestore(__pyx_t_20, __pyx_t_19, __pyx_t_18);
+              __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_27 = 0; __pyx_t_26 = 0; __pyx_t_25 = 0;
+              __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_28;
+              goto __pyx_L41_except_error;
+            }
+            __pyx_L76:;
+          }
+          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          goto __pyx_L40_exception_handled;
+        }
+
+        /* "uvloop/loop.pyx":2008
+ *                         tr = None
+ *                     exceptions.append(exc)
+ *                 except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                     raise
+ *                 except BaseException:
+ */
+        __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+        if (__pyx_t_9) {
+          __Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(0, 2008, __pyx_L41_except_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_GOTREF(__pyx_t_7);
+
+          /* "uvloop/loop.pyx":2009
+ *                     exceptions.append(exc)
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise             # <<<<<<<<<<<<<<
+ *                 except BaseException:
+ *                     if tr is not None:
+ */
+          __Pyx_GIVEREF(__pyx_t_5);
+          __Pyx_GIVEREF(__pyx_t_4);
+          __Pyx_XGIVEREF(__pyx_t_7);
+          __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_4, __pyx_t_7);
+          __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_7 = 0; 
+          __PYX_ERR(0, 2009, __pyx_L41_except_error)
+        }
+
+        /* "uvloop/loop.pyx":2010
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise
+ *                 except BaseException:             # <<<<<<<<<<<<<<
+ *                     if tr is not None:
+ *                         tr._close()
+ */
+        __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+        if (__pyx_t_9) {
+          __Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(0, 2010, __pyx_L41_except_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_GOTREF(__pyx_t_5);
+
+          /* "uvloop/loop.pyx":2011
+ *                     raise
+ *                 except BaseException:
+ *                     if tr is not None:             # <<<<<<<<<<<<<<
+ *                         tr._close()
+ *                         tr = None
+ */
+          __pyx_t_3 = (((PyObject *)__pyx_cur_scope->__pyx_v_tr) != Py_None);
+          __pyx_t_2 = (__pyx_t_3 != 0);
+          if (__pyx_t_2) {
+
+            /* "uvloop/loop.pyx":2012
+ *                 except BaseException:
+ *                     if tr is not None:
+ *                         tr._close()             # <<<<<<<<<<<<<<
+ *                         tr = None
+ *                     raise
+ */
+            __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2012, __pyx_L41_except_error)
+            __Pyx_GOTREF(__pyx_t_6);
+            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+            /* "uvloop/loop.pyx":2013
+ *                     if tr is not None:
+ *                         tr._close()
+ *                         tr = None             # <<<<<<<<<<<<<<
+ *                     raise
+ *                 else:
+ */
+            __Pyx_INCREF(Py_None);
+            __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
+            __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_tr, ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)Py_None));
+            __Pyx_GIVEREF(Py_None);
+
+            /* "uvloop/loop.pyx":2011
+ *                     raise
+ *                 except BaseException:
+ *                     if tr is not None:             # <<<<<<<<<<<<<<
+ *                         tr._close()
+ *                         tr = None
+ */
+          }
+
+          /* "uvloop/loop.pyx":2014
+ *                         tr._close()
+ *                         tr = None
+ *                     raise             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     break
+ */
+          __Pyx_GIVEREF(__pyx_t_7);
+          __Pyx_GIVEREF(__pyx_t_4);
+          __Pyx_XGIVEREF(__pyx_t_5);
+          __Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_4, __pyx_t_5);
+          __pyx_t_7 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; 
+          __PYX_ERR(0, 2014, __pyx_L41_except_error)
+        }
+        goto __pyx_L41_except_error;
+        __pyx_L41_except_error:;
+
+        /* "uvloop/loop.pyx":1979
+ *             while rai_iter is not NULL:
+ *                 tr = None
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     waiter = self._new_future()
+ *                     tr = TCPTransport.new(self, protocol, None, waiter,
+ */
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+        goto __pyx_L1_error;
+        __pyx_L44_try_break:;
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+        goto __pyx_L38_break;
+        __pyx_L45_try_continue:;
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+        goto __pyx_L37_continue;
+        __pyx_L40_exception_handled:;
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+      }
+
+      /* "uvloop/loop.pyx":2018
+ *                     break
+ * 
+ *                 rai_iter = rai_iter.ai_next             # <<<<<<<<<<<<<<
+ * 
+ *             else:
+ */
+      __pyx_t_14 = __pyx_cur_scope->__pyx_v_rai_iter->ai_next;
+      __pyx_cur_scope->__pyx_v_rai_iter = __pyx_t_14;
+      __pyx_L37_continue:;
+    }
+
+    /* "uvloop/loop.pyx":2022
+ *             else:
+ *                 # If they all have the same str(), raise one.
+ *                 model = str(exceptions[0])             # <<<<<<<<<<<<<<
+ *                 if all(str(exc) == model for exc in exceptions):
+ *                     raise exceptions[0]
+ */
+    /*else*/ {
+      __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_cur_scope->__pyx_v_exceptions, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2022, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2022, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GIVEREF(__pyx_t_4);
+      __pyx_cur_scope->__pyx_v_model = __pyx_t_4;
+      __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":2023
+ *                 # If they all have the same str(), raise one.
+ *                 model = str(exceptions[0])
+ *                 if all(str(exc) == model for exc in exceptions):             # <<<<<<<<<<<<<<
+ *                     raise exceptions[0]
+ *                 # Raise a combined exception so the user can see all
+ */
+      __pyx_t_4 = __pyx_pf_6uvloop_4loop_4Loop_17create_connection_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2023, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __Pyx_Generator_Next(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2023, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2023, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(__pyx_t_2)) {
+
+        /* "uvloop/loop.pyx":2024
+ *                 model = str(exceptions[0])
+ *                 if all(str(exc) == model for exc in exceptions):
+ *                     raise exceptions[0]             # <<<<<<<<<<<<<<
+ *                 # Raise a combined exception so the user can see all
+ *                 # the various error messages.
+ */
+        __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_cur_scope->__pyx_v_exceptions, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2024, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __PYX_ERR(0, 2024, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":2023
+ *                 # If they all have the same str(), raise one.
+ *                 model = str(exceptions[0])
+ *                 if all(str(exc) == model for exc in exceptions):             # <<<<<<<<<<<<<<
+ *                     raise exceptions[0]
+ *                 # Raise a combined exception so the user can see all
+ */
+      }
+
+      /* "uvloop/loop.pyx":2027
+ *                 # Raise a combined exception so the user can see all
+ *                 # the various error messages.
+ *                 raise OSError('Multiple exceptions: {}'.format(             # <<<<<<<<<<<<<<
+ *                     ', '.join(str(exc) for exc in exceptions)))
+ *         else:
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Multiple_exceptions, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2027, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/loop.pyx":2028
+ *                 # the various error messages.
+ *                 raise OSError('Multiple exceptions: {}'.format(
+ *                     ', '.join(str(exc) for exc in exceptions)))             # <<<<<<<<<<<<<<
+ *         else:
+ *             if sock is None:
+ */
+      __pyx_t_7 = __pyx_pf_6uvloop_4loop_4Loop_17create_connection_3genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2028, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_6 = __Pyx_Generator_Next(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2028, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __pyx_t_7 = PyUnicode_Join(__pyx_kp_u__63, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2028, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __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_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_4, function);
+        }
+      }
+      __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_7);
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2027, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":2027
+ *                 # Raise a combined exception so the user can see all
+ *                 # the various error messages.
+ *                 raise OSError('Multiple exceptions: {}'.format(             # <<<<<<<<<<<<<<
+ *                     ', '.join(str(exc) for exc in exceptions)))
+ *         else:
+ */
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_OSError, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2027, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __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, 2027, __pyx_L1_error)
+    }
+    __pyx_L38_break:;
+
+    /* "uvloop/loop.pyx":1913
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ *         if host is not None or port is not None:             # <<<<<<<<<<<<<<
+ *             if sock is not None:
+ *                 raise ValueError(
+ */
+    goto __pyx_L17;
+  }
+
+  /* "uvloop/loop.pyx":2030
+ *                     ', '.join(str(exc) for exc in exceptions)))
+ *         else:
+ *             if sock is None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'host and port was not specified and no sock specified')
+ */
+  /*else*/ {
+    __pyx_t_2 = (__pyx_cur_scope->__pyx_v_sock == Py_None);
+    __pyx_t_3 = (__pyx_t_2 != 0);
+    if (unlikely(__pyx_t_3)) {
+
+      /* "uvloop/loop.pyx":2031
+ *         else:
+ *             if sock is None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'host and port was not specified and no sock specified')
+ *             if not _is_sock_stream(sock.type):
+ */
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2031, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __PYX_ERR(0, 2031, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2030
+ *                     ', '.join(str(exc) for exc in exceptions)))
+ *         else:
+ *             if sock is None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'host and port was not specified and no sock specified')
+ */
+    }
+
+    /* "uvloop/loop.pyx":2033
+ *                 raise ValueError(
+ *                     'host and port was not specified and no sock specified')
+ *             if not _is_sock_stream(sock.type):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'A Stream Socket was expected, got {!r}'.format(sock))
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2033, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = __pyx_f_6uvloop_4loop__is_sock_stream(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2033, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2033, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_2 = ((!__pyx_t_3) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":2035
+ *             if not _is_sock_stream(sock.type):
+ *                 raise ValueError(
+ *                     'A Stream Socket was expected, got {!r}'.format(sock))             # <<<<<<<<<<<<<<
+ * 
+ *             # libuv will set the socket to non-blocking mode, but
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_Stream_Socket_was_expected_got, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2035, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_4, function);
+        }
+      }
+      __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_7, __pyx_cur_scope->__pyx_v_sock) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_sock);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2035, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":2034
+ *                     'host and port was not specified and no sock specified')
+ *             if not _is_sock_stream(sock.type):
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'A Stream Socket was expected, got {!r}'.format(sock))
+ * 
+ */
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2034, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __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, 2034, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2033
+ *                 raise ValueError(
+ *                     'host and port was not specified and no sock specified')
+ *             if not _is_sock_stream(sock.type):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'A Stream Socket was expected, got {!r}'.format(sock))
+ */
+    }
+
+    /* "uvloop/loop.pyx":2039
+ *             # libuv will set the socket to non-blocking mode, but
+ *             # we want Python socket object to notice that.
+ *             sock.setblocking(False)             # <<<<<<<<<<<<<<
+ * 
+ *             waiter = self._new_future()
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2039, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_5, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, Py_False) : __Pyx_PyObject_CallOneArg(__pyx_t_5, Py_False);
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2039, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":2041
+ *             sock.setblocking(False)
+ * 
+ *             waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *             tr = TCPTransport.new(self, protocol, None, waiter, context)
+ *             try:
+ */
+    __pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2041, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_4);
+    __pyx_cur_scope->__pyx_v_waiter = __pyx_t_4;
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":2042
+ * 
+ *             waiter = self._new_future()
+ *             tr = TCPTransport.new(self, protocol, None, waiter, context)             # <<<<<<<<<<<<<<
+ *             try:
+ *                 # libuv will make socket non-blocking
+ */
+    __pyx_t_4 = ((PyObject *)__pyx_f_6uvloop_4loop_12TCPTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter, __pyx_cur_scope->__pyx_v_context)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2042, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_4);
+    __pyx_cur_scope->__pyx_v_tr = ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":2043
+ *             waiter = self._new_future()
+ *             tr = TCPTransport.new(self, protocol, None, waiter, context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # libuv will make socket non-blocking
+ *                 tr._open(sock.fileno())
+ */
+    {
+      __Pyx_ExceptionSave(&__pyx_t_17, &__pyx_t_16, &__pyx_t_15);
+      __Pyx_XGOTREF(__pyx_t_17);
+      __Pyx_XGOTREF(__pyx_t_16);
+      __Pyx_XGOTREF(__pyx_t_15);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":2045
+ *             try:
+ *                 # libuv will make socket non-blocking
+ *                 tr._open(sock.fileno())             # <<<<<<<<<<<<<<
+ *                 tr._init_protocol()
+ *                 await waiter
+ */
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2045, __pyx_L90_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_7 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(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_5, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_5);
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2045, __pyx_L90_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2045, __pyx_L90_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tr), __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2045, __pyx_L90_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/loop.pyx":2046
+ *                 # libuv will make socket non-blocking
+ *                 tr._open(sock.fileno())
+ *                 tr._init_protocol()             # <<<<<<<<<<<<<<
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+        __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2046, __pyx_L90_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/loop.pyx":2047
+ *                 tr._open(sock.fileno())
+ *                 tr._init_protocol()
+ *                 await waiter             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+        __Pyx_XGOTREF(__pyx_r);
+        if (likely(__pyx_r)) {
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __pyx_cur_scope->__pyx_t_0 = __pyx_t_15;
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __pyx_cur_scope->__pyx_t_1 = __pyx_t_16;
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __pyx_cur_scope->__pyx_t_2 = __pyx_t_17;
+          __Pyx_XGIVEREF(__pyx_r);
+          __Pyx_RefNannyFinishContext();
+          __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+          /* return from generator, awaiting value */
+          __pyx_generator->resume_label = 4;
+          return __pyx_r;
+          __pyx_L96_resume_from_await:;
+          __pyx_t_15 = __pyx_cur_scope->__pyx_t_0;
+          __pyx_cur_scope->__pyx_t_0 = 0;
+          __Pyx_XGOTREF(__pyx_t_15);
+          __pyx_t_16 = __pyx_cur_scope->__pyx_t_1;
+          __pyx_cur_scope->__pyx_t_1 = 0;
+          __Pyx_XGOTREF(__pyx_t_16);
+          __pyx_t_17 = __pyx_cur_scope->__pyx_t_2;
+          __pyx_cur_scope->__pyx_t_2 = 0;
+          __Pyx_XGOTREF(__pyx_t_17);
+          if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2047, __pyx_L90_error)
+        } else {
+          PyObject* exc_type = __Pyx_PyErr_Occurred();
+          if (exc_type) {
+            if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+            else __PYX_ERR(0, 2047, __pyx_L90_error)
+          }
+        }
+
+        /* "uvloop/loop.pyx":2043
+ *             waiter = self._new_future()
+ *             tr = TCPTransport.new(self, protocol, None, waiter, context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # libuv will make socket non-blocking
+ *                 tr._open(sock.fileno())
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
+      __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+      __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+      goto __pyx_L95_try_end;
+      __pyx_L90_error:;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/loop.pyx":2048
+ *                 tr._init_protocol()
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_7) < 0) __PYX_ERR(0, 2048, __pyx_L92_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_7);
+
+        /* "uvloop/loop.pyx":2049
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException:
+ *                 # It's OK to call `_close()` here, as opposed to
+ */
+        __Pyx_GIVEREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_5);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_5, __pyx_t_7);
+        __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_7 = 0; 
+        __PYX_ERR(0, 2049, __pyx_L92_except_error)
+      }
+
+      /* "uvloop/loop.pyx":2050
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException:             # <<<<<<<<<<<<<<
+ *                 # It's OK to call `_close()` here, as opposed to
+ *                 # `_force_close()` or `close()` as we want to terminate the
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(0, 2050, __pyx_L92_except_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_4);
+
+        /* "uvloop/loop.pyx":2056
+ *                 # up in `Transport._call_connection_made()`, and calling
+ *                 # `_close()` before it is fine.
+ *                 tr._close()             # <<<<<<<<<<<<<<
+ *                 raise
+ * 
+ */
+        __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2056, __pyx_L92_except_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+        /* "uvloop/loop.pyx":2057
+ *                 # `_close()` before it is fine.
+ *                 tr._close()
+ *                 raise             # <<<<<<<<<<<<<<
+ * 
+ *             tr._attach_fileobj(sock)
+ */
+        __Pyx_GIVEREF(__pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_5);
+        __Pyx_XGIVEREF(__pyx_t_4);
+        __Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_5, __pyx_t_4);
+        __pyx_t_7 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; 
+        __PYX_ERR(0, 2057, __pyx_L92_except_error)
+      }
+      goto __pyx_L92_except_error;
+      __pyx_L92_except_error:;
+
+      /* "uvloop/loop.pyx":2043
+ *             waiter = self._new_future()
+ *             tr = TCPTransport.new(self, protocol, None, waiter, context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # libuv will make socket non-blocking
+ *                 tr._open(sock.fileno())
+ */
+      __Pyx_XGIVEREF(__pyx_t_17);
+      __Pyx_XGIVEREF(__pyx_t_16);
+      __Pyx_XGIVEREF(__pyx_t_15);
+      __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15);
+      goto __pyx_L1_error;
+      __pyx_L95_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":2059
+ *                 raise
+ * 
+ *             tr._attach_fileobj(sock)             # <<<<<<<<<<<<<<
+ * 
+ *         if ssl:
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tr), __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2059, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_L17:;
+
+  /* "uvloop/loop.pyx":2061
+ *             tr._attach_fileobj(sock)
+ * 
+ *         if ssl:             # <<<<<<<<<<<<<<
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:
+ */
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_ssl); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2061, __pyx_L1_error)
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":2062
+ * 
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(context)             # <<<<<<<<<<<<<<
+ *             try:
+ *                 await ssl_waiter
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_protocol, __pyx_n_s_get_app_transport); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2062, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_5, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_cur_scope->__pyx_v_context) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_cur_scope->__pyx_v_context);
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2062, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GIVEREF(__pyx_t_4);
+    __pyx_cur_scope->__pyx_v_app_transport = __pyx_t_4;
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":2063
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await ssl_waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+    {
+      __Pyx_ExceptionSave(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+      __Pyx_XGOTREF(__pyx_t_15);
+      __Pyx_XGOTREF(__pyx_t_16);
+      __Pyx_XGOTREF(__pyx_t_17);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":2064
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:
+ *                 await ssl_waiter             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_ssl_waiter);
+        __Pyx_XGOTREF(__pyx_r);
+        if (likely(__pyx_r)) {
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __pyx_cur_scope->__pyx_t_0 = __pyx_t_15;
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __pyx_cur_scope->__pyx_t_1 = __pyx_t_16;
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __pyx_cur_scope->__pyx_t_2 = __pyx_t_17;
+          __Pyx_XGIVEREF(__pyx_r);
+          __Pyx_RefNannyFinishContext();
+          __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+          /* return from generator, awaiting value */
+          __pyx_generator->resume_label = 5;
+          return __pyx_r;
+          __pyx_L108_resume_from_await:;
+          __pyx_t_15 = __pyx_cur_scope->__pyx_t_0;
+          __pyx_cur_scope->__pyx_t_0 = 0;
+          __Pyx_XGOTREF(__pyx_t_15);
+          __pyx_t_16 = __pyx_cur_scope->__pyx_t_1;
+          __pyx_cur_scope->__pyx_t_1 = 0;
+          __Pyx_XGOTREF(__pyx_t_16);
+          __pyx_t_17 = __pyx_cur_scope->__pyx_t_2;
+          __pyx_cur_scope->__pyx_t_2 = 0;
+          __Pyx_XGOTREF(__pyx_t_17);
+          if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2064, __pyx_L102_error)
+        } else {
+          PyObject* exc_type = __Pyx_PyErr_Occurred();
+          if (exc_type) {
+            if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+            else __PYX_ERR(0, 2064, __pyx_L102_error)
+          }
+        }
+
+        /* "uvloop/loop.pyx":2063
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await ssl_waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+      __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+      __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
+      goto __pyx_L107_try_end;
+      __pyx_L102_error:;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/loop.pyx":2065
+ *             try:
+ *                 await ssl_waiter
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_7) < 0) __PYX_ERR(0, 2065, __pyx_L104_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_7);
+
+        /* "uvloop/loop.pyx":2066
+ *                 await ssl_waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException:
+ *                 app_transport.close()
+ */
+        __Pyx_GIVEREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_5);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_5, __pyx_t_7);
+        __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_7 = 0; 
+        __PYX_ERR(0, 2066, __pyx_L104_except_error)
+      }
+
+      /* "uvloop/loop.pyx":2067
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException:             # <<<<<<<<<<<<<<
+ *                 app_transport.close()
+ *                 raise
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(0, 2067, __pyx_L104_except_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_4);
+
+        /* "uvloop/loop.pyx":2068
+ *                 raise
+ *             except BaseException:
+ *                 app_transport.close()             # <<<<<<<<<<<<<<
+ *                 raise
+ *             return app_transport, app_protocol
+ */
+        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_app_transport, __pyx_n_s_close); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 2068, __pyx_L104_except_error)
+        __Pyx_GOTREF(__pyx_t_29);
+        __pyx_t_30 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_29))) {
+          __pyx_t_30 = PyMethod_GET_SELF(__pyx_t_29);
+          if (likely(__pyx_t_30)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_29);
+            __Pyx_INCREF(__pyx_t_30);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_29, function);
+          }
+        }
+        __pyx_t_6 = (__pyx_t_30) ? __Pyx_PyObject_CallOneArg(__pyx_t_29, __pyx_t_30) : __Pyx_PyObject_CallNoArg(__pyx_t_29);
+        __Pyx_XDECREF(__pyx_t_30); __pyx_t_30 = 0;
+        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2068, __pyx_L104_except_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+        /* "uvloop/loop.pyx":2069
+ *             except BaseException:
+ *                 app_transport.close()
+ *                 raise             # <<<<<<<<<<<<<<
+ *             return app_transport, app_protocol
+ *         else:
+ */
+        __Pyx_GIVEREF(__pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_5);
+        __Pyx_XGIVEREF(__pyx_t_4);
+        __Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_5, __pyx_t_4);
+        __pyx_t_7 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; 
+        __PYX_ERR(0, 2069, __pyx_L104_except_error)
+      }
+      goto __pyx_L104_except_error;
+      __pyx_L104_except_error:;
+
+      /* "uvloop/loop.pyx":2063
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await ssl_waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      __Pyx_XGIVEREF(__pyx_t_15);
+      __Pyx_XGIVEREF(__pyx_t_16);
+      __Pyx_XGIVEREF(__pyx_t_17);
+      __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+      goto __pyx_L1_error;
+      __pyx_L107_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":2070
+ *                 app_transport.close()
+ *                 raise
+ *             return app_transport, app_protocol             # <<<<<<<<<<<<<<
+ *         else:
+ *             return tr, protocol
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2070, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_transport);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_transport);
+    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_cur_scope->__pyx_v_app_transport);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_cur_scope->__pyx_v_app_protocol);
+    __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":2061
+ *             tr._attach_fileobj(sock)
+ * 
+ *         if ssl:             # <<<<<<<<<<<<<<
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:
+ */
+  }
+
+  /* "uvloop/loop.pyx":2072
+ *             return app_transport, app_protocol
+ *         else:
+ *             return tr, protocol             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2072, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
+    __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
+    PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_tr));
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
+    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_cur_scope->__pyx_v_protocol);
+    __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L0;
+  }
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":1839
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_connection(self, protocol_factory, host=None, port=None,             # <<<<<<<<<<<<<<
+ *                                 *,
+ *                                 ssl=None,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_29);
+  __Pyx_XDECREF(__pyx_t_30);
+  __Pyx_AddTraceback("create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_63generator5(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2075
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_unix_server(self, protocol_factory, path=None,             # <<<<<<<<<<<<<<
+ *                                  *, backlog=100, sock=None, ssl=None,
+ *                                  ssl_handshake_timeout=None,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_62create_unix_server(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_61create_unix_server[] = "Loop.create_unix_server(self, protocol_factory, path=None, *, backlog=100, sock=None, ssl=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None, start_serving=True)\nA coroutine which creates a UNIX Domain Socket server.\n\n        The return value is a Server object, which can be used to stop\n        the service.\n\n        path is a str, representing a file systsem path to bind the\n        server socket to.\n\n        sock can optionally be specified in order to use a preexisting\n        socket object.\n\n        backlog is the maximum number of queued connections passed to\n        listen() (defaults to 100).\n\n        ssl can be set to an SSLContext to enable SSL over the\n        accepted connections.\n\n        ssl_handshake_timeout is the time in seconds that an SSL server\n        will wait for completion of the SSL handshake before aborting the\n        connection. Default is 60s.\n\n        ssl_shutdown_timeout is the time in seconds that an SSL server\n        will wait for completion of the SSL shutdown before aborting the\n        connection. Default is 30s.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_62create_unix_server(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_protocol_factory = 0;
+  PyObject *__pyx_v_path = 0;
+  PyObject *__pyx_v_backlog = 0;
+  PyObject *__pyx_v_sock = 0;
+  PyObject *__pyx_v_ssl = 0;
+  PyObject *__pyx_v_ssl_handshake_timeout = 0;
+  PyObject *__pyx_v_ssl_shutdown_timeout = 0;
+  PyObject *__pyx_v_start_serving = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_unix_server (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_path,&__pyx_n_s_backlog,&__pyx_n_s_sock,&__pyx_n_s_ssl,&__pyx_n_s_ssl_handshake_timeout,&__pyx_n_s_ssl_shutdown_timeout,&__pyx_n_s_start_serving,0};
+    PyObject* values[8] = {0,0,0,0,0,0,0,0};
+    values[1] = ((PyObject *)Py_None);
+    values[2] = ((PyObject *)__pyx_int_100);
+
+    /* "uvloop/loop.pyx":2076
+ *     @cython.iterable_coroutine
+ *     async def create_unix_server(self, protocol_factory, path=None,
+ *                                  *, backlog=100, sock=None, ssl=None,             # <<<<<<<<<<<<<<
+ *                                  ssl_handshake_timeout=None,
+ *                                  ssl_shutdown_timeout=None,
+ */
+    values[3] = ((PyObject *)Py_None);
+    values[4] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2077
+ *     async def create_unix_server(self, protocol_factory, path=None,
+ *                                  *, backlog=100, sock=None, ssl=None,
+ *                                  ssl_handshake_timeout=None,             # <<<<<<<<<<<<<<
+ *                                  ssl_shutdown_timeout=None,
+ *                                  start_serving=True):
+ */
+    values[5] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2078
+ *                                  *, backlog=100, sock=None, ssl=None,
+ *                                  ssl_handshake_timeout=None,
+ *                                  ssl_shutdown_timeout=None,             # <<<<<<<<<<<<<<
+ *                                  start_serving=True):
+ *         """A coroutine which creates a UNIX Domain Socket server.
+ */
+    values[6] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2079
+ *                                  ssl_handshake_timeout=None,
+ *                                  ssl_shutdown_timeout=None,
+ *                                  start_serving=True):             # <<<<<<<<<<<<<<
+ *         """A coroutine which creates a UNIX Domain Socket server.
+ * 
+ */
+    values[7] = ((PyObject *)Py_True);
+    if (unlikely(__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);
+        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_protocol_factory)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (kw_args > 0 && likely(kw_args <= 6)) {
+        Py_ssize_t index;
+        for (index = 2; index < 8 && kw_args > 0; index++) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+          if (value) { values[index] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_unix_server") < 0)) __PYX_ERR(0, 2075, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_protocol_factory = values[0];
+    __pyx_v_path = values[1];
+    __pyx_v_backlog = values[2];
+    __pyx_v_sock = values[3];
+    __pyx_v_ssl = values[4];
+    __pyx_v_ssl_handshake_timeout = values[5];
+    __pyx_v_ssl_shutdown_timeout = values[6];
+    __pyx_v_start_serving = values[7];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("create_unix_server", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2075, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_61create_unix_server(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_path, __pyx_v_backlog, __pyx_v_sock, __pyx_v_ssl, __pyx_v_ssl_handshake_timeout, __pyx_v_ssl_shutdown_timeout, __pyx_v_start_serving);
+
+  /* "uvloop/loop.pyx":2075
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_unix_server(self, protocol_factory, path=None,             # <<<<<<<<<<<<<<
+ *                                  *, backlog=100, sock=None, ssl=None,
+ *                                  ssl_handshake_timeout=None,
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_61create_unix_server(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_path, PyObject *__pyx_v_backlog, PyObject *__pyx_v_sock, PyObject *__pyx_v_ssl, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout, PyObject *__pyx_v_start_serving) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("create_unix_server", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_11_create_unix_server(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_11_create_unix_server, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2075, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_protocol_factory = __pyx_v_protocol_factory;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_cur_scope->__pyx_v_path = __pyx_v_path;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_path);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_path);
+  __pyx_cur_scope->__pyx_v_backlog = __pyx_v_backlog;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_backlog);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_backlog);
+  __pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+  __pyx_cur_scope->__pyx_v_ssl = __pyx_v_ssl;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
+  __pyx_cur_scope->__pyx_v_ssl_handshake_timeout = __pyx_v_ssl_handshake_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout = __pyx_v_ssl_shutdown_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  __pyx_cur_scope->__pyx_v_start_serving = __pyx_v_start_serving;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_start_serving);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_start_serving);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_63generator5, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_create_unix_server, __pyx_n_s_Loop_create_unix_server, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2075, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_63generator5(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  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;
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_t_14;
+  char const *__pyx_t_15;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  char const *__pyx_t_22;
+  int __pyx_t_23;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_unix_server", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2075, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2107
+ *         cdef:
+ *             UnixServer pipe
+ *             Server server = Server(self)             # <<<<<<<<<<<<<<
+ * 
+ *         if ssl is not None:
+ */
+  __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_6uvloop_4loop_Server), ((PyObject *)__pyx_cur_scope->__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2107, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_server = ((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2109
+ *             Server server = Server(self)
+ * 
+ *         if ssl is not None:             # <<<<<<<<<<<<<<
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_ssl != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":2110
+ * 
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):             # <<<<<<<<<<<<<<
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ */
+    __pyx_t_1 = __pyx_v_6uvloop_4loop_ssl_SSLContext;
+    __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_3 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_ssl, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 2110, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":2111
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError('ssl argument must be an SSLContext or None')             # <<<<<<<<<<<<<<
+ *         else:
+ *             if ssl_handshake_timeout is not None:
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2111, __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, 2111, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2110
+ * 
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):             # <<<<<<<<<<<<<<
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ */
+    }
+
+    /* "uvloop/loop.pyx":2109
+ *             Server server = Server(self)
+ * 
+ *         if ssl is not None:             # <<<<<<<<<<<<<<
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/loop.pyx":2113
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+  /*else*/ {
+    __pyx_t_2 = (__pyx_cur_scope->__pyx_v_ssl_handshake_timeout != Py_None);
+    __pyx_t_3 = (__pyx_t_2 != 0);
+    if (unlikely(__pyx_t_3)) {
+
+      /* "uvloop/loop.pyx":2114
+ *         else:
+ *             if ssl_handshake_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2114, __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, 2114, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2113
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+    }
+
+    /* "uvloop/loop.pyx":2116
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    __pyx_t_3 = (__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout != Py_None);
+    __pyx_t_2 = (__pyx_t_3 != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":2117
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2117, __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, 2117, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2116
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    }
+  }
+  __pyx_L4:;
+
+  /* "uvloop/loop.pyx":2120
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ *         if path is not None:             # <<<<<<<<<<<<<<
+ *             if sock is not None:
+ *                 raise ValueError(
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_path != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":2121
+ * 
+ *         if path is not None:
+ *             if sock is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'path and sock can not be specified at the same time')
+ */
+    __pyx_t_3 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
+    __pyx_t_2 = (__pyx_t_3 != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":2122
+ *         if path is not None:
+ *             if sock is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'path and sock can not be specified at the same time')
+ *             orig_path = path
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2122, __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, 2122, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2121
+ * 
+ *         if path is not None:
+ *             if sock is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'path and sock can not be specified at the same time')
+ */
+    }
+
+    /* "uvloop/loop.pyx":2124
+ *                 raise ValueError(
+ *                     'path and sock can not be specified at the same time')
+ *             orig_path = path             # <<<<<<<<<<<<<<
+ * 
+ *             path = os_fspath(path)
+ */
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_path);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_path);
+    __pyx_cur_scope->__pyx_v_orig_path = __pyx_cur_scope->__pyx_v_path;
+
+    /* "uvloop/loop.pyx":2126
+ *             orig_path = path
+ * 
+ *             path = os_fspath(path)             # <<<<<<<<<<<<<<
+ * 
+ *             if isinstance(path, str):
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_fspath);
+    __pyx_t_4 = __pyx_v_6uvloop_4loop_os_fspath; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_cur_scope->__pyx_v_path) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_path);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2126, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_path);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_path, __pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":2128
+ *             path = os_fspath(path)
+ * 
+ *             if isinstance(path, str):             # <<<<<<<<<<<<<<
+ *                 path = PyUnicode_EncodeFSDefault(path)
+ * 
+ */
+    __pyx_t_2 = PyUnicode_Check(__pyx_cur_scope->__pyx_v_path); 
+    __pyx_t_3 = (__pyx_t_2 != 0);
+    if (__pyx_t_3) {
+
+      /* "uvloop/loop.pyx":2129
+ * 
+ *             if isinstance(path, str):
+ *                 path = PyUnicode_EncodeFSDefault(path)             # <<<<<<<<<<<<<<
+ * 
+ *             # Check for abstract socket.
+ */
+      __pyx_t_1 = PyUnicode_EncodeFSDefault(__pyx_cur_scope->__pyx_v_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2129, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_path);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_path, __pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_1);
+      __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":2128
+ *             path = os_fspath(path)
+ * 
+ *             if isinstance(path, str):             # <<<<<<<<<<<<<<
+ *                 path = PyUnicode_EncodeFSDefault(path)
+ * 
+ */
+    }
+
+    /* "uvloop/loop.pyx":2132
+ * 
+ *             # Check for abstract socket.
+ *             if path[0] != 0:             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     if stat_S_ISSOCK(os_stat(path).st_mode):
+ */
+    __pyx_t_1 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_path, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = __Pyx_PyInt_NeObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2132, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (__pyx_t_3) {
+
+      /* "uvloop/loop.pyx":2133
+ *             # Check for abstract socket.
+ *             if path[0] != 0:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     if stat_S_ISSOCK(os_stat(path).st_mode):
+ *                         os_remove(path)
+ */
+      {
+        __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
+        __Pyx_XGOTREF(__pyx_t_6);
+        __Pyx_XGOTREF(__pyx_t_7);
+        __Pyx_XGOTREF(__pyx_t_8);
+        /*try:*/ {
+
+          /* "uvloop/loop.pyx":2134
+ *             if path[0] != 0:
+ *                 try:
+ *                     if stat_S_ISSOCK(os_stat(path).st_mode):             # <<<<<<<<<<<<<<
+ *                         os_remove(path)
+ *                 except FileNotFoundError:
+ */
+          __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_stat);
+          __pyx_t_5 = __pyx_v_6uvloop_4loop_os_stat; __pyx_t_9 = NULL;
+          if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+            __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5);
+            if (likely(__pyx_t_9)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+              __Pyx_INCREF(__pyx_t_9);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_5, function);
+            }
+          }
+          __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_9, __pyx_cur_scope->__pyx_v_path) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_cur_scope->__pyx_v_path);
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2134, __pyx_L12_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_st_mode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2134, __pyx_L12_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_INCREF(__pyx_v_6uvloop_4loop_stat_S_ISSOCK);
+          __pyx_t_1 = __pyx_v_6uvloop_4loop_stat_S_ISSOCK; __pyx_t_9 = NULL;
+          if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+            __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1);
+            if (likely(__pyx_t_9)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+              __Pyx_INCREF(__pyx_t_9);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_1, function);
+            }
+          }
+          __pyx_t_4 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_9, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5);
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2134, __pyx_L12_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2134, __pyx_L12_error)
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          if (__pyx_t_3) {
+
+            /* "uvloop/loop.pyx":2135
+ *                 try:
+ *                     if stat_S_ISSOCK(os_stat(path).st_mode):
+ *                         os_remove(path)             # <<<<<<<<<<<<<<
+ *                 except FileNotFoundError:
+ *                     pass
+ */
+            __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_remove);
+            __pyx_t_1 = __pyx_v_6uvloop_4loop_os_remove; __pyx_t_5 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+              __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
+              if (likely(__pyx_t_5)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+                __Pyx_INCREF(__pyx_t_5);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_1, function);
+              }
+            }
+            __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_cur_scope->__pyx_v_path) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_cur_scope->__pyx_v_path);
+            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+            if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2135, __pyx_L12_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+            /* "uvloop/loop.pyx":2134
+ *             if path[0] != 0:
+ *                 try:
+ *                     if stat_S_ISSOCK(os_stat(path).st_mode):             # <<<<<<<<<<<<<<
+ *                         os_remove(path)
+ *                 except FileNotFoundError:
+ */
+          }
+
+          /* "uvloop/loop.pyx":2133
+ *             # Check for abstract socket.
+ *             if path[0] != 0:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     if stat_S_ISSOCK(os_stat(path).st_mode):
+ *                         os_remove(path)
+ */
+        }
+        __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;
+        goto __pyx_L17_try_end;
+        __pyx_L12_error:;
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        /* "uvloop/loop.pyx":2136
+ *                     if stat_S_ISSOCK(os_stat(path).st_mode):
+ *                         os_remove(path)
+ *                 except FileNotFoundError:             # <<<<<<<<<<<<<<
+ *                     pass
+ *                 except OSError as err:
+ */
+        __Pyx_ErrFetch(&__pyx_t_4, &__pyx_t_1, &__pyx_t_5);
+        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_FileNotFoundError); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2136, __pyx_L14_except_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __pyx_t_10 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_4, __pyx_t_9);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_ErrRestore(__pyx_t_4, __pyx_t_1, __pyx_t_5);
+        __pyx_t_4 = 0; __pyx_t_1 = 0; __pyx_t_5 = 0;
+        if (__pyx_t_10) {
+          __Pyx_ErrRestore(0,0,0);
+          goto __pyx_L13_exception_handled;
+        }
+
+        /* "uvloop/loop.pyx":2138
+ *                 except FileNotFoundError:
+ *                     pass
+ *                 except OSError as err:             # <<<<<<<<<<<<<<
+ *                     # Directory may have permissions only to create socket.
+ *                     aio_logger.error(
+ */
+        __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
+        if (__pyx_t_10) {
+          __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_4) < 0) __PYX_ERR(0, 2138, __pyx_L14_except_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_INCREF(__pyx_t_1);
+          __Pyx_GIVEREF(__pyx_t_1);
+          __pyx_cur_scope->__pyx_v_err = __pyx_t_1;
+          /*try:*/ {
+
+            /* "uvloop/loop.pyx":2140
+ *                 except OSError as err:
+ *                     # Directory may have permissions only to create socket.
+ *                     aio_logger.error(             # <<<<<<<<<<<<<<
+ *                         'Unable to check or remove stale UNIX socket %r: %r',
+ *                         orig_path, err)
+ */
+            __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2140, __pyx_L24_error)
+            __Pyx_GOTREF(__pyx_t_11);
+
+            /* "uvloop/loop.pyx":2142
+ *                     aio_logger.error(
+ *                         'Unable to check or remove stale UNIX socket %r: %r',
+ *                         orig_path, err)             # <<<<<<<<<<<<<<
+ * 
+ *             # We use Python sockets to create a UNIX server socket because
+ */
+            __pyx_t_12 = NULL;
+            __pyx_t_10 = 0;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+              __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+              if (likely(__pyx_t_12)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+                __Pyx_INCREF(__pyx_t_12);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_11, function);
+                __pyx_t_10 = 1;
+              }
+            }
+            #if CYTHON_FAST_PYCALL
+            if (PyFunction_Check(__pyx_t_11)) {
+              PyObject *__pyx_temp[4] = {__pyx_t_12, __pyx_kp_u_Unable_to_check_or_remove_stale, __pyx_cur_scope->__pyx_v_orig_path, __pyx_cur_scope->__pyx_v_err};
+              __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2140, __pyx_L24_error)
+              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+              __Pyx_GOTREF(__pyx_t_9);
+            } else
+            #endif
+            #if CYTHON_FAST_PYCCALL
+            if (__Pyx_PyFastCFunction_Check(__pyx_t_11)) {
+              PyObject *__pyx_temp[4] = {__pyx_t_12, __pyx_kp_u_Unable_to_check_or_remove_stale, __pyx_cur_scope->__pyx_v_orig_path, __pyx_cur_scope->__pyx_v_err};
+              __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2140, __pyx_L24_error)
+              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+              __Pyx_GOTREF(__pyx_t_9);
+            } else
+            #endif
+            {
+              __pyx_t_13 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2140, __pyx_L24_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              if (__pyx_t_12) {
+                __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __pyx_t_12 = NULL;
+              }
+              __Pyx_INCREF(__pyx_kp_u_Unable_to_check_or_remove_stale);
+              __Pyx_GIVEREF(__pyx_kp_u_Unable_to_check_or_remove_stale);
+              PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_10, __pyx_kp_u_Unable_to_check_or_remove_stale);
+              __Pyx_INCREF(__pyx_cur_scope->__pyx_v_orig_path);
+              __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_orig_path);
+              PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_10, __pyx_cur_scope->__pyx_v_orig_path);
+              __Pyx_INCREF(__pyx_cur_scope->__pyx_v_err);
+              __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_err);
+              PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_10, __pyx_cur_scope->__pyx_v_err);
+              __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_13, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2140, __pyx_L24_error)
+              __Pyx_GOTREF(__pyx_t_9);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            }
+            __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          }
+
+          /* "uvloop/loop.pyx":2138
+ *                 except FileNotFoundError:
+ *                     pass
+ *                 except OSError as err:             # <<<<<<<<<<<<<<
+ *                     # Directory may have permissions only to create socket.
+ *                     aio_logger.error(
+ */
+          /*finally:*/ {
+            /*normal exit:*/{
+              __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_err);
+              __Pyx_DECREF(__pyx_cur_scope->__pyx_v_err);
+              __pyx_cur_scope->__pyx_v_err = NULL;
+              goto __pyx_L25;
+            }
+            __pyx_L24_error:;
+            /*exception exit:*/{
+              __Pyx_PyThreadState_assign
+              __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
+              __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+              __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+              if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
+              if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+              __Pyx_XGOTREF(__pyx_t_16);
+              __Pyx_XGOTREF(__pyx_t_17);
+              __Pyx_XGOTREF(__pyx_t_18);
+              __Pyx_XGOTREF(__pyx_t_19);
+              __Pyx_XGOTREF(__pyx_t_20);
+              __Pyx_XGOTREF(__pyx_t_21);
+              __pyx_t_10 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
+              {
+                __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_err);
+                __Pyx_DECREF(__pyx_cur_scope->__pyx_v_err);
+                __pyx_cur_scope->__pyx_v_err = NULL;
+              }
+              if (PY_MAJOR_VERSION >= 3) {
+                __Pyx_XGIVEREF(__pyx_t_19);
+                __Pyx_XGIVEREF(__pyx_t_20);
+                __Pyx_XGIVEREF(__pyx_t_21);
+                __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
+              }
+              __Pyx_XGIVEREF(__pyx_t_16);
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+              __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
+              __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
+              goto __pyx_L14_except_error;
+            }
+            __pyx_L25:;
+          }
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+          goto __pyx_L13_exception_handled;
+        }
+        goto __pyx_L14_except_error;
+        __pyx_L14_except_error:;
+
+        /* "uvloop/loop.pyx":2133
+ *             # Check for abstract socket.
+ *             if path[0] != 0:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     if stat_S_ISSOCK(os_stat(path).st_mode):
+ *                         os_remove(path)
+ */
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+        goto __pyx_L1_error;
+        __pyx_L13_exception_handled:;
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+        __pyx_L17_try_end:;
+      }
+
+      /* "uvloop/loop.pyx":2132
+ * 
+ *             # Check for abstract socket.
+ *             if path[0] != 0:             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     if stat_S_ISSOCK(os_stat(path).st_mode):
+ */
+    }
+
+    /* "uvloop/loop.pyx":2148
+ *             # they were bound to.  This is different from asyncio, which
+ *             # doesn't cleanup the socket path.
+ *             sock = socket_socket(uv.AF_UNIX)             # <<<<<<<<<<<<<<
+ * 
+ *             try:
+ */
+    __pyx_t_1 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2148, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_socket);
+    __pyx_t_5 = __pyx_v_6uvloop_4loop_socket_socket; __pyx_t_9 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_9, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1);
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2148, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_sock);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_sock, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":2150
+ *             sock = socket_socket(uv.AF_UNIX)
+ * 
+ *             try:             # <<<<<<<<<<<<<<
+ *                 sock.bind(path)
+ *             except OSError as exc:
+ */
+    {
+      __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_6);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":2151
+ * 
+ *             try:
+ *                 sock.bind(path)             # <<<<<<<<<<<<<<
+ *             except OSError as exc:
+ *                 sock.close()
+ */
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_bind); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2151, __pyx_L30_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_1 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+          __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
+          if (likely(__pyx_t_1)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+            __Pyx_INCREF(__pyx_t_1);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_5, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_cur_scope->__pyx_v_path) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_cur_scope->__pyx_v_path);
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2151, __pyx_L30_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/loop.pyx":2150
+ *             sock = socket_socket(uv.AF_UNIX)
+ * 
+ *             try:             # <<<<<<<<<<<<<<
+ *                 sock.bind(path)
+ *             except OSError as exc:
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L35_try_end;
+      __pyx_L30_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/loop.pyx":2152
+ *             try:
+ *                 sock.bind(path)
+ *             except OSError as exc:             # <<<<<<<<<<<<<<
+ *                 sock.close()
+ *                 if exc.errno == errno.EADDRINUSE:
+ */
+      __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
+      if (__pyx_t_14) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(0, 2152, __pyx_L32_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_GIVEREF(__pyx_t_5);
+        __pyx_cur_scope->__pyx_v_exc = __pyx_t_5;
+        /*try:*/ {
+
+          /* "uvloop/loop.pyx":2153
+ *                 sock.bind(path)
+ *             except OSError as exc:
+ *                 sock.close()             # <<<<<<<<<<<<<<
+ *                 if exc.errno == errno.EADDRINUSE:
+ *                     # Let's improve the error message by adding
+ */
+          __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_close); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2153, __pyx_L41_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __pyx_t_13 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+            __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_11);
+            if (likely(__pyx_t_13)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+              __Pyx_INCREF(__pyx_t_13);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_11, function);
+            }
+          }
+          __pyx_t_9 = (__pyx_t_13) ? __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_13) : __Pyx_PyObject_CallNoArg(__pyx_t_11);
+          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2153, __pyx_L41_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+          /* "uvloop/loop.pyx":2154
+ *             except OSError as exc:
+ *                 sock.close()
+ *                 if exc.errno == errno.EADDRINUSE:             # <<<<<<<<<<<<<<
+ *                     # Let's improve the error message by adding
+ *                     # with what exact address it occurs.
+ */
+          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_exc, __pyx_n_s_errno); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2154, __pyx_L41_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __pyx_t_11 = __Pyx_PyInt_From_int(EADDRINUSE); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2154, __pyx_L41_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __pyx_t_13 = PyObject_RichCompare(__pyx_t_9, __pyx_t_11, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2154, __pyx_L41_error)
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2154, __pyx_L41_error)
+          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+          if (unlikely(__pyx_t_3)) {
+
+            /* "uvloop/loop.pyx":2157
+ *                     # Let's improve the error message by adding
+ *                     # with what exact address it occurs.
+ *                     msg = 'Address {!r} is already in use'.format(orig_path)             # <<<<<<<<<<<<<<
+ *                     raise OSError(errno.EADDRINUSE, msg) from None
+ *                 else:
+ */
+            __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Address_r_is_already_in_use, __pyx_n_s_format); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2157, __pyx_L41_error)
+            __Pyx_GOTREF(__pyx_t_11);
+            __pyx_t_9 = NULL;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+              __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_11);
+              if (likely(__pyx_t_9)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+                __Pyx_INCREF(__pyx_t_9);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_11, function);
+              }
+            }
+            __pyx_t_13 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_9, __pyx_cur_scope->__pyx_v_orig_path) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_cur_scope->__pyx_v_orig_path);
+            __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+            if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2157, __pyx_L41_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_GIVEREF(__pyx_t_13);
+            __pyx_cur_scope->__pyx_v_msg = __pyx_t_13;
+            __pyx_t_13 = 0;
+
+            /* "uvloop/loop.pyx":2158
+ *                     # with what exact address it occurs.
+ *                     msg = 'Address {!r} is already in use'.format(orig_path)
+ *                     raise OSError(errno.EADDRINUSE, msg) from None             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     raise
+ */
+            __pyx_t_13 = __Pyx_PyInt_From_int(EADDRINUSE); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2158, __pyx_L41_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2158, __pyx_L41_error)
+            __Pyx_GOTREF(__pyx_t_11);
+            __Pyx_GIVEREF(__pyx_t_13);
+            PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_13);
+            __Pyx_INCREF(__pyx_cur_scope->__pyx_v_msg);
+            __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_msg);
+            PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_cur_scope->__pyx_v_msg);
+            __pyx_t_13 = 0;
+            __pyx_t_13 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_11, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2158, __pyx_L41_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_Raise(__pyx_t_13, 0, 0, Py_None);
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __PYX_ERR(0, 2158, __pyx_L41_error)
+
+            /* "uvloop/loop.pyx":2154
+ *             except OSError as exc:
+ *                 sock.close()
+ *                 if exc.errno == errno.EADDRINUSE:             # <<<<<<<<<<<<<<
+ *                     # Let's improve the error message by adding
+ *                     # with what exact address it occurs.
+ */
+          }
+
+          /* "uvloop/loop.pyx":2160
+ *                     raise OSError(errno.EADDRINUSE, msg) from None
+ *                 else:
+ *                     raise             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+          /*else*/ {
+            __Pyx_GIVEREF(__pyx_t_4);
+            __Pyx_GIVEREF(__pyx_t_5);
+            __Pyx_XGIVEREF(__pyx_t_1);
+            __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_5, __pyx_t_1);
+            __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_1 = 0; 
+            __PYX_ERR(0, 2160, __pyx_L41_error)
+          }
+        }
+
+        /* "uvloop/loop.pyx":2152
+ *             try:
+ *                 sock.bind(path)
+ *             except OSError as exc:             # <<<<<<<<<<<<<<
+ *                 sock.close()
+ *                 if exc.errno == errno.EADDRINUSE:
+ */
+        /*finally:*/ {
+          __pyx_L41_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_assign
+            __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0;
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_21, &__pyx_t_20, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_21, &__pyx_t_20, &__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_21);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __pyx_t_14 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_22 = __pyx_filename;
+            {
+              __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_exc);
+              __Pyx_DECREF(__pyx_cur_scope->__pyx_v_exc);
+              __pyx_cur_scope->__pyx_v_exc = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_XGIVEREF(__pyx_t_16);
+              __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_17, __pyx_t_16);
+            }
+            __Pyx_XGIVEREF(__pyx_t_21);
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_ErrRestore(__pyx_t_21, __pyx_t_20, __pyx_t_19);
+            __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0;
+            __pyx_lineno = __pyx_t_14; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_22;
+            goto __pyx_L32_except_error;
+          }
+        }
+      }
+
+      /* "uvloop/loop.pyx":2161
+ *                 else:
+ *                     raise
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException:
+ */
+      __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(0, 2161, __pyx_L32_except_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_4);
+
+        /* "uvloop/loop.pyx":2162
+ *                     raise
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException:
+ *                 sock.close()
+ */
+        __Pyx_GIVEREF(__pyx_t_1);
+        __Pyx_GIVEREF(__pyx_t_5);
+        __Pyx_XGIVEREF(__pyx_t_4);
+        __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_5, __pyx_t_4);
+        __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; 
+        __PYX_ERR(0, 2162, __pyx_L32_except_error)
+      }
+
+      /* "uvloop/loop.pyx":2163
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException:             # <<<<<<<<<<<<<<
+ *                 sock.close()
+ *                 raise
+ */
+      __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(0, 2163, __pyx_L32_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_1);
+
+        /* "uvloop/loop.pyx":2164
+ *                 raise
+ *             except BaseException:
+ *                 sock.close()             # <<<<<<<<<<<<<<
+ *                 raise
+ * 
+ */
+        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_close); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2164, __pyx_L32_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __pyx_t_9 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+          __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_11);
+          if (likely(__pyx_t_9)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+            __Pyx_INCREF(__pyx_t_9);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_11, function);
+          }
+        }
+        __pyx_t_13 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_11);
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2164, __pyx_L32_except_error)
+        __Pyx_GOTREF(__pyx_t_13);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+        /* "uvloop/loop.pyx":2165
+ *             except BaseException:
+ *                 sock.close()
+ *                 raise             # <<<<<<<<<<<<<<
+ * 
+ *         else:
+ */
+        __Pyx_GIVEREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_5);
+        __Pyx_XGIVEREF(__pyx_t_1);
+        __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_5, __pyx_t_1);
+        __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_1 = 0; 
+        __PYX_ERR(0, 2165, __pyx_L32_except_error)
+      }
+      goto __pyx_L32_except_error;
+      __pyx_L32_except_error:;
+
+      /* "uvloop/loop.pyx":2150
+ *             sock = socket_socket(uv.AF_UNIX)
+ * 
+ *             try:             # <<<<<<<<<<<<<<
+ *                 sock.bind(path)
+ *             except OSError as exc:
+ */
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_7, __pyx_t_6);
+      goto __pyx_L1_error;
+      __pyx_L35_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":2120
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ *         if path is not None:             # <<<<<<<<<<<<<<
+ *             if sock is not None:
+ *                 raise ValueError(
+ */
+    goto __pyx_L8;
+  }
+
+  /* "uvloop/loop.pyx":2168
+ * 
+ *         else:
+ *             if sock is None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'path was not specified, and no sock specified')
+ */
+  /*else*/ {
+    __pyx_t_3 = (__pyx_cur_scope->__pyx_v_sock == Py_None);
+    __pyx_t_2 = (__pyx_t_3 != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":2169
+ *         else:
+ *             if sock is None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'path was not specified, and no sock specified')
+ * 
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2169, __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, 2169, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2168
+ * 
+ *         else:
+ *             if sock is None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'path was not specified, and no sock specified')
+ */
+    }
+
+    /* "uvloop/loop.pyx":2172
+ *                     'path was not specified, and no sock specified')
+ * 
+ *             if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'A UNIX Domain Stream Socket was expected, got {!r}'
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2172, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2172, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_5, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2172, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2172, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (!__pyx_t_3) {
+    } else {
+      __pyx_t_2 = __pyx_t_3;
+      goto __pyx_L54_bool_binop_done;
+    }
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2172, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = __pyx_f_6uvloop_4loop__is_sock_stream(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2172, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2172, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_23 = ((!__pyx_t_3) != 0);
+    __pyx_t_2 = __pyx_t_23;
+    __pyx_L54_bool_binop_done:;
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":2175
+ *                 raise ValueError(
+ *                     'A UNIX Domain Stream Socket was expected, got {!r}'
+ *                     .format(sock))             # <<<<<<<<<<<<<<
+ * 
+ *             # libuv will set the socket to non-blocking mode, but
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_UNIX_Domain_Stream_Socket_was, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2175, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_1 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+        if (likely(__pyx_t_1)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+          __Pyx_INCREF(__pyx_t_1);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_4, function);
+        }
+      }
+      __pyx_t_5 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_cur_scope->__pyx_v_sock) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_sock);
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2175, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":2173
+ * 
+ *             if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'A UNIX Domain Stream Socket was expected, got {!r}'
+ *                     .format(sock))
+ */
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2173, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __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, 2173, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2172
+ *                     'path was not specified, and no sock specified')
+ * 
+ *             if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'A UNIX Domain Stream Socket was expected, got {!r}'
+ */
+    }
+
+    /* "uvloop/loop.pyx":2179
+ *             # libuv will set the socket to non-blocking mode, but
+ *             # we want Python socket object to notice that.
+ *             sock.setblocking(False)             # <<<<<<<<<<<<<<
+ * 
+ *         pipe = UnixServer.new(
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2179, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_1 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, Py_False) : __Pyx_PyObject_CallOneArg(__pyx_t_5, Py_False);
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2179, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_L8:;
+
+  /* "uvloop/loop.pyx":2181
+ *             sock.setblocking(False)
+ * 
+ *         pipe = UnixServer.new(             # <<<<<<<<<<<<<<
+ *             self, protocol_factory, server, backlog,
+ *             ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ */
+  __pyx_t_4 = ((PyObject *)__pyx_f_6uvloop_4loop_10UnixServer_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol_factory, __pyx_cur_scope->__pyx_v_server, __pyx_cur_scope->__pyx_v_backlog, __pyx_cur_scope->__pyx_v_ssl, __pyx_cur_scope->__pyx_v_ssl_handshake_timeout, __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2181, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_4);
+  __pyx_cur_scope->__pyx_v_pipe = ((struct __pyx_obj_6uvloop_4loop_UnixServer *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2185
+ *             ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             pipe._open(sock.fileno())
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+  {
+    __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_7);
+    __Pyx_XGOTREF(__pyx_t_8);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":2186
+ * 
+ *         try:
+ *             pipe._open(sock.fileno())             # <<<<<<<<<<<<<<
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2186, __pyx_L56_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_1 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_1)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_1);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2186, __pyx_L56_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2186, __pyx_L56_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_cur_scope->__pyx_v_pipe->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_pipe), __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2186, __pyx_L56_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":2185
+ *             ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             pipe._open(sock.fileno())
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+    }
+    __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;
+    goto __pyx_L61_try_end;
+    __pyx_L56_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/loop.pyx":2187
+ *         try:
+ *             pipe._open(sock.fileno())
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException:
+ */
+    __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+    if (__pyx_t_10) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(0, 2187, __pyx_L58_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_1);
+
+      /* "uvloop/loop.pyx":2188
+ *             pipe._open(sock.fileno())
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException:
+ *             pipe._close()
+ */
+      __Pyx_GIVEREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_1);
+      __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_5, __pyx_t_1);
+      __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_1 = 0; 
+      __PYX_ERR(0, 2188, __pyx_L58_except_error)
+    }
+
+    /* "uvloop/loop.pyx":2189
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException:             # <<<<<<<<<<<<<<
+ *             pipe._close()
+ *             sock.close()
+ */
+    __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_10) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(0, 2189, __pyx_L58_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/loop.pyx":2190
+ *             raise
+ *         except BaseException:
+ *             pipe._close()             # <<<<<<<<<<<<<<
+ *             sock.close()
+ *             raise
+ */
+      __pyx_t_13 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_cur_scope->__pyx_v_pipe->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_pipe)); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2190, __pyx_L58_except_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+      /* "uvloop/loop.pyx":2191
+ *         except BaseException:
+ *             pipe._close()
+ *             sock.close()             # <<<<<<<<<<<<<<
+ *             raise
+ * 
+ */
+      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_close); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2191, __pyx_L58_except_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_9 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+        __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_11);
+        if (likely(__pyx_t_9)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+          __Pyx_INCREF(__pyx_t_9);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_11, function);
+        }
+      }
+      __pyx_t_13 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_11);
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2191, __pyx_L58_except_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+      /* "uvloop/loop.pyx":2192
+ *             pipe._close()
+ *             sock.close()
+ *             raise             # <<<<<<<<<<<<<<
+ * 
+ *         pipe._attach_fileobj(sock)
+ */
+      __Pyx_GIVEREF(__pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_5, __pyx_t_4);
+      __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; 
+      __PYX_ERR(0, 2192, __pyx_L58_except_error)
+    }
+    goto __pyx_L58_except_error;
+    __pyx_L58_except_error:;
+
+    /* "uvloop/loop.pyx":2185
+ *             ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             pipe._open(sock.fileno())
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_7);
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+    goto __pyx_L1_error;
+    __pyx_L61_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":2194
+ *             raise
+ * 
+ *         pipe._attach_fileobj(sock)             # <<<<<<<<<<<<<<
+ *         server._add_server(pipe)
+ * 
+ */
+  __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_cur_scope->__pyx_v_pipe->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_pipe), __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2195
+ * 
+ *         pipe._attach_fileobj(sock)
+ *         server._add_server(pipe)             # <<<<<<<<<<<<<<
+ * 
+ *         if start_serving:
+ */
+  __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_cur_scope->__pyx_v_server->__pyx_vtab)->_add_server(__pyx_cur_scope->__pyx_v_server, ((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_cur_scope->__pyx_v_pipe)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2195, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2197
+ *         server._add_server(pipe)
+ * 
+ *         if start_serving:             # <<<<<<<<<<<<<<
+ *             server._start_serving()
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_start_serving); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2197, __pyx_L1_error)
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":2198
+ * 
+ *         if start_serving:
+ *             server._start_serving()             # <<<<<<<<<<<<<<
+ * 
+ *         return server
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_cur_scope->__pyx_v_server->__pyx_vtab)->_start_serving(__pyx_cur_scope->__pyx_v_server); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2198, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":2197
+ *         server._add_server(pipe)
+ * 
+ *         if start_serving:             # <<<<<<<<<<<<<<
+ *             server._start_serving()
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2200
+ *             server._start_serving()
+ * 
+ *         return server             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(((PyObject *)__pyx_cur_scope->__pyx_v_server));
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2075
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_unix_server(self, protocol_factory, path=None,             # <<<<<<<<<<<<<<
+ *                                  *, backlog=100, sock=None, ssl=None,
+ *                                  ssl_handshake_timeout=None,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_AddTraceback("create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_66generator6(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2203
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_unix_connection(self, protocol_factory, path=None, *,             # <<<<<<<<<<<<<<
+ *                                      ssl=None, sock=None,
+ *                                      server_hostname=None,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_65create_unix_connection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_64create_unix_connection[] = "Loop.create_unix_connection(self, protocol_factory, path=None, *, ssl=None, sock=None, server_hostname=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_65create_unix_connection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_protocol_factory = 0;
+  PyObject *__pyx_v_path = 0;
+  PyObject *__pyx_v_ssl = 0;
+  PyObject *__pyx_v_sock = 0;
+  PyObject *__pyx_v_server_hostname = 0;
+  PyObject *__pyx_v_ssl_handshake_timeout = 0;
+  PyObject *__pyx_v_ssl_shutdown_timeout = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_unix_connection (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_path,&__pyx_n_s_ssl,&__pyx_n_s_sock,&__pyx_n_s_server_hostname,&__pyx_n_s_ssl_handshake_timeout,&__pyx_n_s_ssl_shutdown_timeout,0};
+    PyObject* values[7] = {0,0,0,0,0,0,0};
+    values[1] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2204
+ *     @cython.iterable_coroutine
+ *     async def create_unix_connection(self, protocol_factory, path=None, *,
+ *                                      ssl=None, sock=None,             # <<<<<<<<<<<<<<
+ *                                      server_hostname=None,
+ *                                      ssl_handshake_timeout=None,
+ */
+    values[2] = ((PyObject *)Py_None);
+    values[3] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2205
+ *     async def create_unix_connection(self, protocol_factory, path=None, *,
+ *                                      ssl=None, sock=None,
+ *                                      server_hostname=None,             # <<<<<<<<<<<<<<
+ *                                      ssl_handshake_timeout=None,
+ *                                      ssl_shutdown_timeout=None):
+ */
+    values[4] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2206
+ *                                      ssl=None, sock=None,
+ *                                      server_hostname=None,
+ *                                      ssl_handshake_timeout=None,             # <<<<<<<<<<<<<<
+ *                                      ssl_shutdown_timeout=None):
+ * 
+ */
+    values[5] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2207
+ *                                      server_hostname=None,
+ *                                      ssl_handshake_timeout=None,
+ *                                      ssl_shutdown_timeout=None):             # <<<<<<<<<<<<<<
+ * 
+ *         cdef:
+ */
+    values[6] = ((PyObject *)Py_None);
+    if (unlikely(__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);
+        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_protocol_factory)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (kw_args > 0 && likely(kw_args <= 5)) {
+        Py_ssize_t index;
+        for (index = 2; index < 7 && kw_args > 0; index++) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+          if (value) { values[index] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_unix_connection") < 0)) __PYX_ERR(0, 2203, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_protocol_factory = values[0];
+    __pyx_v_path = values[1];
+    __pyx_v_ssl = values[2];
+    __pyx_v_sock = values[3];
+    __pyx_v_server_hostname = values[4];
+    __pyx_v_ssl_handshake_timeout = values[5];
+    __pyx_v_ssl_shutdown_timeout = values[6];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("create_unix_connection", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2203, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_64create_unix_connection(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_path, __pyx_v_ssl, __pyx_v_sock, __pyx_v_server_hostname, __pyx_v_ssl_handshake_timeout, __pyx_v_ssl_shutdown_timeout);
+
+  /* "uvloop/loop.pyx":2203
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_unix_connection(self, protocol_factory, path=None, *,             # <<<<<<<<<<<<<<
+ *                                      ssl=None, sock=None,
+ *                                      server_hostname=None,
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_64create_unix_connection(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_path, PyObject *__pyx_v_ssl, PyObject *__pyx_v_sock, PyObject *__pyx_v_server_hostname, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("create_unix_connection", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2203, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_protocol_factory = __pyx_v_protocol_factory;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_cur_scope->__pyx_v_path = __pyx_v_path;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_path);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_path);
+  __pyx_cur_scope->__pyx_v_ssl = __pyx_v_ssl;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
+  __pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+  __pyx_cur_scope->__pyx_v_server_hostname = __pyx_v_server_hostname;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_hostname);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_hostname);
+  __pyx_cur_scope->__pyx_v_ssl_handshake_timeout = __pyx_v_ssl_handshake_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout = __pyx_v_ssl_shutdown_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_66generator6, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_create_unix_connection, __pyx_n_s_Loop_create_unix_connection, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2203, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_66generator6(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  char *__pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_unix_connection", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L18_resume_from_await;
+    case 2: goto __pyx_L33_resume_from_await;
+    case 3: goto __pyx_L45_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2203, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2216
+ *             object ssl_waiter
+ * 
+ *         app_protocol = protocol = protocol_factory()             # <<<<<<<<<<<<<<
+ *         ssl_waiter = None
+ *         context = Context_CopyCurrent()
+ */
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_t_2 = __pyx_cur_scope->__pyx_v_protocol_factory; __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __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, 2216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_INCREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_app_protocol = __pyx_t_1;
+  __Pyx_INCREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_protocol = __pyx_t_1;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2217
+ * 
+ *         app_protocol = protocol = protocol_factory()
+ *         ssl_waiter = None             # <<<<<<<<<<<<<<
+ *         context = Context_CopyCurrent()
+ *         if ssl:
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __pyx_cur_scope->__pyx_v_ssl_waiter = Py_None;
+
+  /* "uvloop/loop.pyx":2218
+ *         app_protocol = protocol = protocol_factory()
+ *         ssl_waiter = None
+ *         context = Context_CopyCurrent()             # <<<<<<<<<<<<<<
+ *         if ssl:
+ *             if server_hostname is None:
+ */
+  __pyx_t_1 = Context_CopyCurrent(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_context = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2219
+ *         ssl_waiter = None
+ *         context = Context_CopyCurrent()
+ *         if ssl:             # <<<<<<<<<<<<<<
+ *             if server_hostname is None:
+ *                 raise ValueError('You must set server_hostname '
+ */
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_ssl); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 2219, __pyx_L1_error)
+  if (__pyx_t_4) {
+
+    /* "uvloop/loop.pyx":2220
+ *         context = Context_CopyCurrent()
+ *         if ssl:
+ *             if server_hostname is None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError('You must set server_hostname '
+ *                                  'when using ssl without a host')
+ */
+    __pyx_t_4 = (__pyx_cur_scope->__pyx_v_server_hostname == Py_None);
+    __pyx_t_5 = (__pyx_t_4 != 0);
+    if (unlikely(__pyx_t_5)) {
+
+      /* "uvloop/loop.pyx":2221
+ *         if ssl:
+ *             if server_hostname is None:
+ *                 raise ValueError('You must set server_hostname '             # <<<<<<<<<<<<<<
+ *                                  'when using ssl without a host')
+ * 
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2221, __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, 2221, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2220
+ *         context = Context_CopyCurrent()
+ *         if ssl:
+ *             if server_hostname is None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError('You must set server_hostname '
+ *                                  'when using ssl without a host')
+ */
+    }
+
+    /* "uvloop/loop.pyx":2224
+ *                                  'when using ssl without a host')
+ * 
+ *             ssl_waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *             sslcontext = None if isinstance(ssl, bool) else ssl
+ *             protocol = SSLProtocol(
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2224, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_ssl_waiter, __pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":2225
+ * 
+ *             ssl_waiter = self._new_future()
+ *             sslcontext = None if isinstance(ssl, bool) else ssl             # <<<<<<<<<<<<<<
+ *             protocol = SSLProtocol(
+ *                 self, app_protocol, sslcontext, ssl_waiter,
+ */
+    __pyx_t_2 = ((PyObject*)&PyBool_Type);
+    __Pyx_INCREF(__pyx_t_2);
+    __pyx_t_5 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_ssl, __pyx_t_2); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 2225, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if ((__pyx_t_5 != 0)) {
+      __Pyx_INCREF(Py_None);
+      __pyx_t_1 = Py_None;
+    } else {
+      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
+      __pyx_t_1 = __pyx_cur_scope->__pyx_v_ssl;
+    }
+    __Pyx_GIVEREF(__pyx_t_1);
+    __pyx_cur_scope->__pyx_v_sslcontext = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":2226
+ *             ssl_waiter = self._new_future()
+ *             sslcontext = None if isinstance(ssl, bool) else ssl
+ *             protocol = SSLProtocol(             # <<<<<<<<<<<<<<
+ *                 self, app_protocol, sslcontext, ssl_waiter,
+ *                 False, server_hostname,
+ */
+    __pyx_t_1 = PyTuple_New(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2226, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_cur_scope->__pyx_v_app_protocol);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sslcontext);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sslcontext);
+    PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_cur_scope->__pyx_v_sslcontext);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
+    PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_cur_scope->__pyx_v_ssl_waiter);
+    __Pyx_INCREF(Py_False);
+    __Pyx_GIVEREF(Py_False);
+    PyTuple_SET_ITEM(__pyx_t_1, 4, Py_False);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_hostname);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_hostname);
+    PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_cur_scope->__pyx_v_server_hostname);
+
+    /* "uvloop/loop.pyx":2229
+ *                 self, app_protocol, sslcontext, ssl_waiter,
+ *                 False, server_hostname,
+ *                 ssl_handshake_timeout=ssl_handshake_timeout,             # <<<<<<<<<<<<<<
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)
+ *         else:
+ */
+    __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2229, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_ssl_handshake_timeout, __pyx_cur_scope->__pyx_v_ssl_handshake_timeout) < 0) __PYX_ERR(0, 2229, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2230
+ *                 False, server_hostname,
+ *                 ssl_handshake_timeout=ssl_handshake_timeout,
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)             # <<<<<<<<<<<<<<
+ *         else:
+ *             if server_hostname is not None:
+ */
+    if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_ssl_shutdown_timeout, __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout) < 0) __PYX_ERR(0, 2229, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2226
+ *             ssl_waiter = self._new_future()
+ *             sslcontext = None if isinstance(ssl, bool) else ssl
+ *             protocol = SSLProtocol(             # <<<<<<<<<<<<<<
+ *                 self, app_protocol, sslcontext, ssl_waiter,
+ *                 False, server_hostname,
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_SSLProtocol), __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2226, __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;
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_protocol);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_protocol, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":2219
+ *         ssl_waiter = None
+ *         context = Context_CopyCurrent()
+ *         if ssl:             # <<<<<<<<<<<<<<
+ *             if server_hostname is None:
+ *                 raise ValueError('You must set server_hostname '
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/loop.pyx":2232
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)
+ *         else:
+ *             if server_hostname is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError('server_hostname is only meaningful with ssl')
+ *             if ssl_handshake_timeout is not None:
+ */
+  /*else*/ {
+    __pyx_t_5 = (__pyx_cur_scope->__pyx_v_server_hostname != Py_None);
+    __pyx_t_4 = (__pyx_t_5 != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "uvloop/loop.pyx":2233
+ *         else:
+ *             if server_hostname is not None:
+ *                 raise ValueError('server_hostname is only meaningful with ssl')             # <<<<<<<<<<<<<<
+ *             if ssl_handshake_timeout is not None:
+ *                 raise ValueError(
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2233, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 2233, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2232
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)
+ *         else:
+ *             if server_hostname is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError('server_hostname is only meaningful with ssl')
+ *             if ssl_handshake_timeout is not None:
+ */
+    }
+
+    /* "uvloop/loop.pyx":2234
+ *             if server_hostname is not None:
+ *                 raise ValueError('server_hostname is only meaningful with ssl')
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+    __pyx_t_4 = (__pyx_cur_scope->__pyx_v_ssl_handshake_timeout != Py_None);
+    __pyx_t_5 = (__pyx_t_4 != 0);
+    if (unlikely(__pyx_t_5)) {
+
+      /* "uvloop/loop.pyx":2235
+ *                 raise ValueError('server_hostname is only meaningful with ssl')
+ *             if ssl_handshake_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2235, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 2235, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2234
+ *             if server_hostname is not None:
+ *                 raise ValueError('server_hostname is only meaningful with ssl')
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+    }
+
+    /* "uvloop/loop.pyx":2237
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    __pyx_t_5 = (__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout != Py_None);
+    __pyx_t_4 = (__pyx_t_5 != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "uvloop/loop.pyx":2238
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2238, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 2238, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2237
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    }
+  }
+  __pyx_L4:;
+
+  /* "uvloop/loop.pyx":2241
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ *         if path is not None:             # <<<<<<<<<<<<<<
+ *             if sock is not None:
+ *                 raise ValueError(
+ */
+  __pyx_t_4 = (__pyx_cur_scope->__pyx_v_path != Py_None);
+  __pyx_t_5 = (__pyx_t_4 != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/loop.pyx":2242
+ * 
+ *         if path is not None:
+ *             if sock is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'path and sock can not be specified at the same time')
+ */
+    __pyx_t_5 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
+    __pyx_t_4 = (__pyx_t_5 != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "uvloop/loop.pyx":2243
+ *         if path is not None:
+ *             if sock is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'path and sock can not be specified at the same time')
+ * 
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2243, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 2243, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2242
+ * 
+ *         if path is not None:
+ *             if sock is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'path and sock can not be specified at the same time')
+ */
+    }
+
+    /* "uvloop/loop.pyx":2246
+ *                     'path and sock can not be specified at the same time')
+ * 
+ *             path = os_fspath(path)             # <<<<<<<<<<<<<<
+ * 
+ *             if isinstance(path, str):
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_fspath);
+    __pyx_t_2 = __pyx_v_6uvloop_4loop_os_fspath; __pyx_t_1 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_cur_scope->__pyx_v_path) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_cur_scope->__pyx_v_path);
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2246, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_path);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_path, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":2248
+ *             path = os_fspath(path)
+ * 
+ *             if isinstance(path, str):             # <<<<<<<<<<<<<<
+ *                 path = PyUnicode_EncodeFSDefault(path)
+ * 
+ */
+    __pyx_t_4 = PyUnicode_Check(__pyx_cur_scope->__pyx_v_path); 
+    __pyx_t_5 = (__pyx_t_4 != 0);
+    if (__pyx_t_5) {
+
+      /* "uvloop/loop.pyx":2249
+ * 
+ *             if isinstance(path, str):
+ *                 path = PyUnicode_EncodeFSDefault(path)             # <<<<<<<<<<<<<<
+ * 
+ *             waiter = self._new_future()
+ */
+      __pyx_t_3 = PyUnicode_EncodeFSDefault(__pyx_cur_scope->__pyx_v_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2249, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_path);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_path, __pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_3);
+      __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":2248
+ *             path = os_fspath(path)
+ * 
+ *             if isinstance(path, str):             # <<<<<<<<<<<<<<
+ *                 path = PyUnicode_EncodeFSDefault(path)
+ * 
+ */
+    }
+
+    /* "uvloop/loop.pyx":2251
+ *                 path = PyUnicode_EncodeFSDefault(path)
+ * 
+ *             waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)
+ *             tr.connect(path)
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2251, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_cur_scope->__pyx_v_waiter = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":2252
+ * 
+ *             waiter = self._new_future()
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)             # <<<<<<<<<<<<<<
+ *             tr.connect(path)
+ *             try:
+ */
+    __pyx_t_3 = ((PyObject *)__pyx_f_6uvloop_4loop_13UnixTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter, __pyx_cur_scope->__pyx_v_context)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2252, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_cur_scope->__pyx_v_tr = ((struct __pyx_obj_6uvloop_4loop_UnixTransport *)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":2253
+ *             waiter = self._new_future()
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)
+ *             tr.connect(path)             # <<<<<<<<<<<<<<
+ *             try:
+ *                 await waiter
+ */
+    __pyx_t_6 = __Pyx_PyObject_AsWritableString(__pyx_cur_scope->__pyx_v_path); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 2253, __pyx_L1_error)
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->connect(__pyx_cur_scope->__pyx_v_tr, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2253, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":2254
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)
+ *             tr.connect(path)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+    {
+      __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":2255
+ *             tr.connect(path)
+ *             try:
+ *                 await waiter             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+        __Pyx_XGOTREF(__pyx_r);
+        if (likely(__pyx_r)) {
+          __Pyx_XGIVEREF(__pyx_t_7);
+          __pyx_cur_scope->__pyx_t_0 = __pyx_t_7;
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __pyx_cur_scope->__pyx_t_1 = __pyx_t_8;
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __pyx_cur_scope->__pyx_t_2 = __pyx_t_9;
+          __Pyx_XGIVEREF(__pyx_r);
+          __Pyx_RefNannyFinishContext();
+          __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+          /* return from generator, awaiting value */
+          __pyx_generator->resume_label = 1;
+          return __pyx_r;
+          __pyx_L18_resume_from_await:;
+          __pyx_t_7 = __pyx_cur_scope->__pyx_t_0;
+          __pyx_cur_scope->__pyx_t_0 = 0;
+          __Pyx_XGOTREF(__pyx_t_7);
+          __pyx_t_8 = __pyx_cur_scope->__pyx_t_1;
+          __pyx_cur_scope->__pyx_t_1 = 0;
+          __Pyx_XGOTREF(__pyx_t_8);
+          __pyx_t_9 = __pyx_cur_scope->__pyx_t_2;
+          __pyx_cur_scope->__pyx_t_2 = 0;
+          __Pyx_XGOTREF(__pyx_t_9);
+          if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2255, __pyx_L12_error)
+        } else {
+          PyObject* exc_type = __Pyx_PyErr_Occurred();
+          if (exc_type) {
+            if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+            else __PYX_ERR(0, 2255, __pyx_L12_error)
+          }
+        }
+
+        /* "uvloop/loop.pyx":2254
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)
+ *             tr.connect(path)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      }
+      __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;
+      goto __pyx_L17_try_end;
+      __pyx_L12_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":2256
+ *             try:
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException:
+ */
+      __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 2256, __pyx_L14_except_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_GOTREF(__pyx_t_1);
+
+        /* "uvloop/loop.pyx":2257
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException:
+ *                 tr._close()
+ */
+        __Pyx_GIVEREF(__pyx_t_3);
+        __Pyx_GIVEREF(__pyx_t_2);
+        __Pyx_XGIVEREF(__pyx_t_1);
+        __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_2, __pyx_t_1);
+        __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; 
+        __PYX_ERR(0, 2257, __pyx_L14_except_error)
+      }
+
+      /* "uvloop/loop.pyx":2258
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException:             # <<<<<<<<<<<<<<
+ *                 tr._close()
+ *                 raise
+ */
+      __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 2258, __pyx_L14_except_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_GOTREF(__pyx_t_3);
+
+        /* "uvloop/loop.pyx":2259
+ *                 raise
+ *             except BaseException:
+ *                 tr._close()             # <<<<<<<<<<<<<<
+ *                 raise
+ * 
+ */
+        __pyx_t_11 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2259, __pyx_L14_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+
+        /* "uvloop/loop.pyx":2260
+ *             except BaseException:
+ *                 tr._close()
+ *                 raise             # <<<<<<<<<<<<<<
+ * 
+ *         else:
+ */
+        __Pyx_GIVEREF(__pyx_t_1);
+        __Pyx_GIVEREF(__pyx_t_2);
+        __Pyx_XGIVEREF(__pyx_t_3);
+        __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+        __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; 
+        __PYX_ERR(0, 2260, __pyx_L14_except_error)
+      }
+      goto __pyx_L14_except_error;
+      __pyx_L14_except_error:;
+
+      /* "uvloop/loop.pyx":2254
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)
+ *             tr.connect(path)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+      goto __pyx_L1_error;
+      __pyx_L17_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":2241
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ *         if path is not None:             # <<<<<<<<<<<<<<
+ *             if sock is not None:
+ *                 raise ValueError(
+ */
+    goto __pyx_L9;
+  }
+
+  /* "uvloop/loop.pyx":2263
+ * 
+ *         else:
+ *             if sock is None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError('no path and sock were specified')
+ * 
+ */
+  /*else*/ {
+    __pyx_t_5 = (__pyx_cur_scope->__pyx_v_sock == Py_None);
+    __pyx_t_4 = (__pyx_t_5 != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "uvloop/loop.pyx":2264
+ *         else:
+ *             if sock is None:
+ *                 raise ValueError('no path and sock were specified')             # <<<<<<<<<<<<<<
+ * 
+ *             if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2264, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 2264, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2263
+ * 
+ *         else:
+ *             if sock is None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError('no path and sock were specified')
+ * 
+ */
+    }
+
+    /* "uvloop/loop.pyx":2266
+ *                 raise ValueError('no path and sock were specified')
+ * 
+ *             if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'A UNIX Domain Stream Socket was expected, got {!r}'
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2266, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_2 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2266, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2266, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 2266, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (!__pyx_t_5) {
+    } else {
+      __pyx_t_4 = __pyx_t_5;
+      goto __pyx_L25_bool_binop_done;
+    }
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2266, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = __pyx_f_6uvloop_4loop__is_sock_stream(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2266, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 2266, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_12 = ((!__pyx_t_5) != 0);
+    __pyx_t_4 = __pyx_t_12;
+    __pyx_L25_bool_binop_done:;
+    if (unlikely(__pyx_t_4)) {
+
+      /* "uvloop/loop.pyx":2269
+ *                 raise ValueError(
+ *                     'A UNIX Domain Stream Socket was expected, got {!r}'
+ *                     .format(sock))             # <<<<<<<<<<<<<<
+ * 
+ *             # libuv will set the socket to non-blocking mode, but
+ */
+      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_UNIX_Domain_Stream_Socket_was, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2269, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_3 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
+        if (likely(__pyx_t_3)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+          __Pyx_INCREF(__pyx_t_3);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_1, function);
+        }
+      }
+      __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_cur_scope->__pyx_v_sock) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_cur_scope->__pyx_v_sock);
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2269, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":2267
+ * 
+ *             if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'A UNIX Domain Stream Socket was expected, got {!r}'
+ *                     .format(sock))
+ */
+      __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2267, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __PYX_ERR(0, 2267, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2266
+ *                 raise ValueError('no path and sock were specified')
+ * 
+ *             if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'A UNIX Domain Stream Socket was expected, got {!r}'
+ */
+    }
+
+    /* "uvloop/loop.pyx":2273
+ *             # libuv will set the socket to non-blocking mode, but
+ *             # we want Python socket object to notice that.
+ *             sock.setblocking(False)             # <<<<<<<<<<<<<<
+ * 
+ *             waiter = self._new_future()
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2273, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, Py_False) : __Pyx_PyObject_CallOneArg(__pyx_t_2, Py_False);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2273, __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;
+
+    /* "uvloop/loop.pyx":2275
+ *             sock.setblocking(False)
+ * 
+ *             waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)
+ *             try:
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2275, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_1);
+    __pyx_cur_scope->__pyx_v_waiter = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":2276
+ * 
+ *             waiter = self._new_future()
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)             # <<<<<<<<<<<<<<
+ *             try:
+ *                 tr._open(sock.fileno())
+ */
+    __pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_13UnixTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter, __pyx_cur_scope->__pyx_v_context)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2276, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_1);
+    __pyx_cur_scope->__pyx_v_tr = ((struct __pyx_obj_6uvloop_4loop_UnixTransport *)__pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":2277
+ *             waiter = self._new_future()
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 tr._open(sock.fileno())
+ *                 tr._init_protocol()
+ */
+    {
+      __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_7);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":2278
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)
+ *             try:
+ *                 tr._open(sock.fileno())             # <<<<<<<<<<<<<<
+ *                 tr._init_protocol()
+ *                 await waiter
+ */
+        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2278, __pyx_L27_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_3 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_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, 2278, __pyx_L27_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2278, __pyx_L27_error)
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tr), __pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2278, __pyx_L27_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+        /* "uvloop/loop.pyx":2279
+ *             try:
+ *                 tr._open(sock.fileno())
+ *                 tr._init_protocol()             # <<<<<<<<<<<<<<
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+        __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2279, __pyx_L27_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+        /* "uvloop/loop.pyx":2280
+ *                 tr._open(sock.fileno())
+ *                 tr._init_protocol()
+ *                 await waiter             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+        __Pyx_XGOTREF(__pyx_r);
+        if (likely(__pyx_r)) {
+          __Pyx_XGIVEREF(__pyx_t_7);
+          __pyx_cur_scope->__pyx_t_0 = __pyx_t_7;
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __pyx_cur_scope->__pyx_t_1 = __pyx_t_8;
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __pyx_cur_scope->__pyx_t_2 = __pyx_t_9;
+          __Pyx_XGIVEREF(__pyx_r);
+          __Pyx_RefNannyFinishContext();
+          __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+          /* return from generator, awaiting value */
+          __pyx_generator->resume_label = 2;
+          return __pyx_r;
+          __pyx_L33_resume_from_await:;
+          __pyx_t_7 = __pyx_cur_scope->__pyx_t_0;
+          __pyx_cur_scope->__pyx_t_0 = 0;
+          __Pyx_XGOTREF(__pyx_t_7);
+          __pyx_t_8 = __pyx_cur_scope->__pyx_t_1;
+          __pyx_cur_scope->__pyx_t_1 = 0;
+          __Pyx_XGOTREF(__pyx_t_8);
+          __pyx_t_9 = __pyx_cur_scope->__pyx_t_2;
+          __pyx_cur_scope->__pyx_t_2 = 0;
+          __Pyx_XGOTREF(__pyx_t_9);
+          if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2280, __pyx_L27_error)
+        } else {
+          PyObject* exc_type = __Pyx_PyErr_Occurred();
+          if (exc_type) {
+            if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+            else __PYX_ERR(0, 2280, __pyx_L27_error)
+          }
+        }
+
+        /* "uvloop/loop.pyx":2277
+ *             waiter = self._new_future()
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 tr._open(sock.fileno())
+ *                 tr._init_protocol()
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L32_try_end;
+      __pyx_L27_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":2281
+ *                 tr._init_protocol()
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException:
+ */
+      __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 2281, __pyx_L29_except_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_GOTREF(__pyx_t_3);
+
+        /* "uvloop/loop.pyx":2282
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException:
+ *                 tr._close()
+ */
+        __Pyx_GIVEREF(__pyx_t_1);
+        __Pyx_GIVEREF(__pyx_t_2);
+        __Pyx_XGIVEREF(__pyx_t_3);
+        __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+        __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; 
+        __PYX_ERR(0, 2282, __pyx_L29_except_error)
+      }
+
+      /* "uvloop/loop.pyx":2283
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException:             # <<<<<<<<<<<<<<
+ *                 tr._close()
+ *                 raise
+ */
+      __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 2283, __pyx_L29_except_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_GOTREF(__pyx_t_1);
+
+        /* "uvloop/loop.pyx":2284
+ *                 raise
+ *             except BaseException:
+ *                 tr._close()             # <<<<<<<<<<<<<<
+ *                 raise
+ * 
+ */
+        __pyx_t_11 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2284, __pyx_L29_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+
+        /* "uvloop/loop.pyx":2285
+ *             except BaseException:
+ *                 tr._close()
+ *                 raise             # <<<<<<<<<<<<<<
+ * 
+ *             tr._attach_fileobj(sock)
+ */
+        __Pyx_GIVEREF(__pyx_t_3);
+        __Pyx_GIVEREF(__pyx_t_2);
+        __Pyx_XGIVEREF(__pyx_t_1);
+        __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_2, __pyx_t_1);
+        __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; 
+        __PYX_ERR(0, 2285, __pyx_L29_except_error)
+      }
+      goto __pyx_L29_except_error;
+      __pyx_L29_except_error:;
+
+      /* "uvloop/loop.pyx":2277
+ *             waiter = self._new_future()
+ *             tr = UnixTransport.new(self, protocol, None, waiter, context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 tr._open(sock.fileno())
+ *                 tr._init_protocol()
+ */
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_8, __pyx_t_7);
+      goto __pyx_L1_error;
+      __pyx_L32_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":2287
+ *                 raise
+ * 
+ *             tr._attach_fileobj(sock)             # <<<<<<<<<<<<<<
+ * 
+ *         if ssl:
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tr), __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2287, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
+  __pyx_L9:;
+
+  /* "uvloop/loop.pyx":2289
+ *             tr._attach_fileobj(sock)
+ * 
+ *         if ssl:             # <<<<<<<<<<<<<<
+ *             app_transport = protocol._get_app_transport(Context_CopyCurrent())
+ *             try:
+ */
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_ssl); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 2289, __pyx_L1_error)
+  if (__pyx_t_4) {
+
+    /* "uvloop/loop.pyx":2290
+ * 
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(Context_CopyCurrent())             # <<<<<<<<<<<<<<
+ *             try:
+ *                 await ssl_waiter
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_protocol, __pyx_n_s_get_app_transport); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2290, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = Context_CopyCurrent(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2290, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_11 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_11)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_11);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_11, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2290, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GIVEREF(__pyx_t_1);
+    __pyx_cur_scope->__pyx_v_app_transport = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":2291
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(Context_CopyCurrent())
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await ssl_waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+    {
+      __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":2292
+ *             app_transport = protocol._get_app_transport(Context_CopyCurrent())
+ *             try:
+ *                 await ssl_waiter             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_ssl_waiter);
+        __Pyx_XGOTREF(__pyx_r);
+        if (likely(__pyx_r)) {
+          __Pyx_XGIVEREF(__pyx_t_7);
+          __pyx_cur_scope->__pyx_t_0 = __pyx_t_7;
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __pyx_cur_scope->__pyx_t_1 = __pyx_t_8;
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __pyx_cur_scope->__pyx_t_2 = __pyx_t_9;
+          __Pyx_XGIVEREF(__pyx_r);
+          __Pyx_RefNannyFinishContext();
+          __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+          /* return from generator, awaiting value */
+          __pyx_generator->resume_label = 3;
+          return __pyx_r;
+          __pyx_L45_resume_from_await:;
+          __pyx_t_7 = __pyx_cur_scope->__pyx_t_0;
+          __pyx_cur_scope->__pyx_t_0 = 0;
+          __Pyx_XGOTREF(__pyx_t_7);
+          __pyx_t_8 = __pyx_cur_scope->__pyx_t_1;
+          __pyx_cur_scope->__pyx_t_1 = 0;
+          __Pyx_XGOTREF(__pyx_t_8);
+          __pyx_t_9 = __pyx_cur_scope->__pyx_t_2;
+          __pyx_cur_scope->__pyx_t_2 = 0;
+          __Pyx_XGOTREF(__pyx_t_9);
+          if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2292, __pyx_L39_error)
+        } else {
+          PyObject* exc_type = __Pyx_PyErr_Occurred();
+          if (exc_type) {
+            if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+            else __PYX_ERR(0, 2292, __pyx_L39_error)
+          }
+        }
+
+        /* "uvloop/loop.pyx":2291
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(Context_CopyCurrent())
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await ssl_waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      }
+      __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;
+      goto __pyx_L44_try_end;
+      __pyx_L39_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":2293
+ *             try:
+ *                 await ssl_waiter
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException:
+ */
+      __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 2293, __pyx_L41_except_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_GOTREF(__pyx_t_3);
+
+        /* "uvloop/loop.pyx":2294
+ *                 await ssl_waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException:
+ *                 app_transport.close()
+ */
+        __Pyx_GIVEREF(__pyx_t_1);
+        __Pyx_GIVEREF(__pyx_t_2);
+        __Pyx_XGIVEREF(__pyx_t_3);
+        __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+        __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; 
+        __PYX_ERR(0, 2294, __pyx_L41_except_error)
+      }
+
+      /* "uvloop/loop.pyx":2295
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException:             # <<<<<<<<<<<<<<
+ *                 app_transport.close()
+ *                 raise
+ */
+      __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 2295, __pyx_L41_except_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_GOTREF(__pyx_t_1);
+
+        /* "uvloop/loop.pyx":2296
+ *                 raise
+ *             except BaseException:
+ *                 app_transport.close()             # <<<<<<<<<<<<<<
+ *                 raise
+ *             return app_transport, app_protocol
+ */
+        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_app_transport, __pyx_n_s_close); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2296, __pyx_L41_except_error)
+        __Pyx_GOTREF(__pyx_t_13);
+        __pyx_t_14 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) {
+          __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13);
+          if (likely(__pyx_t_14)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+            __Pyx_INCREF(__pyx_t_14);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_13, function);
+          }
+        }
+        __pyx_t_11 = (__pyx_t_14) ? __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_14) : __Pyx_PyObject_CallNoArg(__pyx_t_13);
+        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+        if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2296, __pyx_L41_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+
+        /* "uvloop/loop.pyx":2297
+ *             except BaseException:
+ *                 app_transport.close()
+ *                 raise             # <<<<<<<<<<<<<<
+ *             return app_transport, app_protocol
+ *         else:
+ */
+        __Pyx_GIVEREF(__pyx_t_3);
+        __Pyx_GIVEREF(__pyx_t_2);
+        __Pyx_XGIVEREF(__pyx_t_1);
+        __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_2, __pyx_t_1);
+        __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; 
+        __PYX_ERR(0, 2297, __pyx_L41_except_error)
+      }
+      goto __pyx_L41_except_error;
+      __pyx_L41_except_error:;
+
+      /* "uvloop/loop.pyx":2291
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(Context_CopyCurrent())
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await ssl_waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+      goto __pyx_L1_error;
+      __pyx_L44_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":2298
+ *                 app_transport.close()
+ *                 raise
+ *             return app_transport, app_protocol             # <<<<<<<<<<<<<<
+ *         else:
+ *             return tr, protocol
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2298, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_transport);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_transport);
+    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_cur_scope->__pyx_v_app_transport);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_cur_scope->__pyx_v_app_protocol);
+    __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":2289
+ *             tr._attach_fileobj(sock)
+ * 
+ *         if ssl:             # <<<<<<<<<<<<<<
+ *             app_transport = protocol._get_app_transport(Context_CopyCurrent())
+ *             try:
+ */
+  }
+
+  /* "uvloop/loop.pyx":2300
+ *             return app_transport, app_protocol
+ *         else:
+ *             return tr, protocol             # <<<<<<<<<<<<<<
+ * 
+ *     def default_exception_handler(self, context):
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2300, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
+    __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
+    PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_tr));
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
+    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_cur_scope->__pyx_v_protocol);
+    __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    goto __pyx_L0;
+  }
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2203
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_unix_connection(self, protocol_factory, path=None, *,             # <<<<<<<<<<<<<<
+ *                                      ssl=None, sock=None,
+ *                                      server_hostname=None,
+ */
+
+  /* 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_11);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2302
+ *             return tr, protocol
+ * 
+ *     def default_exception_handler(self, context):             # <<<<<<<<<<<<<<
+ *         """Default exception handler.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_68default_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_context); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_67default_exception_handler[] = "Loop.default_exception_handler(self, context)\nDefault exception handler.\n\n        This is called when an exception occurs and no exception\n        handler is set, and can be called by a custom exception\n        handler that wants to defer to the default behavior.\n\n        The context parameter has the same meaning as in\n        `call_exception_handler()`.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_68default_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_context) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("default_exception_handler (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_67default_exception_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_context));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_67default_exception_handler(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_context) {
+  PyObject *__pyx_v_message = NULL;
+  PyObject *__pyx_v_exception = NULL;
+  PyObject *__pyx_v_exc_info = NULL;
+  PyObject *__pyx_v_log_lines = NULL;
+  PyObject *__pyx_v_key = NULL;
+  PyObject *__pyx_v_value = NULL;
+  PyObject *__pyx_v_tb = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  Py_ssize_t __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  int __pyx_t_17;
+  char const *__pyx_t_18;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  PyObject *__pyx_t_23 = NULL;
+  PyObject *__pyx_t_24 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("default_exception_handler", 0);
+
+  /* "uvloop/loop.pyx":2312
+ *         `call_exception_handler()`.
+ *         """
+ *         message = context.get('message')             # <<<<<<<<<<<<<<
+ *         if not message:
+ *             message = 'Unhandled exception in event loop'
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_context, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2312, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_n_u_message) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_n_u_message);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2312, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_message = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2313
+ *         """
+ *         message = context.get('message')
+ *         if not message:             # <<<<<<<<<<<<<<
+ *             message = 'Unhandled exception in event loop'
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_message); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 2313, __pyx_L1_error)
+  __pyx_t_5 = ((!__pyx_t_4) != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/loop.pyx":2314
+ *         message = context.get('message')
+ *         if not message:
+ *             message = 'Unhandled exception in event loop'             # <<<<<<<<<<<<<<
+ * 
+ *         exception = context.get('exception')
+ */
+    __Pyx_INCREF(__pyx_kp_u_Unhandled_exception_in_event_loo);
+    __Pyx_DECREF_SET(__pyx_v_message, __pyx_kp_u_Unhandled_exception_in_event_loo);
+
+    /* "uvloop/loop.pyx":2313
+ *         """
+ *         message = context.get('message')
+ *         if not message:             # <<<<<<<<<<<<<<
+ *             message = 'Unhandled exception in event loop'
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2316
+ *             message = 'Unhandled exception in event loop'
+ * 
+ *         exception = context.get('exception')             # <<<<<<<<<<<<<<
+ *         if exception is not None:
+ *             exc_info = (type(exception), exception, exception.__traceback__)
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_context, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2316, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_n_u_exception) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_n_u_exception);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2316, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_exception = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2317
+ * 
+ *         exception = context.get('exception')
+ *         if exception is not None:             # <<<<<<<<<<<<<<
+ *             exc_info = (type(exception), exception, exception.__traceback__)
+ *         else:
+ */
+  __pyx_t_5 = (__pyx_v_exception != Py_None);
+  __pyx_t_4 = (__pyx_t_5 != 0);
+  if (__pyx_t_4) {
+
+    /* "uvloop/loop.pyx":2318
+ *         exception = context.get('exception')
+ *         if exception is not None:
+ *             exc_info = (type(exception), exception, exception.__traceback__)             # <<<<<<<<<<<<<<
+ *         else:
+ *             exc_info = False
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_exception, __pyx_n_s_traceback); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2318, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2318, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(((PyObject *)Py_TYPE(__pyx_v_exception)));
+    __Pyx_GIVEREF(((PyObject *)Py_TYPE(__pyx_v_exception)));
+    PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(__pyx_v_exception)));
+    __Pyx_INCREF(__pyx_v_exception);
+    __Pyx_GIVEREF(__pyx_v_exception);
+    PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_exception);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_1);
+    __pyx_t_1 = 0;
+    __pyx_v_exc_info = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":2317
+ * 
+ *         exception = context.get('exception')
+ *         if exception is not None:             # <<<<<<<<<<<<<<
+ *             exc_info = (type(exception), exception, exception.__traceback__)
+ *         else:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/loop.pyx":2320
+ *             exc_info = (type(exception), exception, exception.__traceback__)
+ *         else:
+ *             exc_info = False             # <<<<<<<<<<<<<<
+ * 
+ *         log_lines = [message]
+ */
+  /*else*/ {
+    __Pyx_INCREF(Py_False);
+    __pyx_v_exc_info = Py_False;
+  }
+  __pyx_L4:;
+
+  /* "uvloop/loop.pyx":2322
+ *             exc_info = False
+ * 
+ *         log_lines = [message]             # <<<<<<<<<<<<<<
+ *         for key in sorted(context):
+ *             if key in {'message', 'exception'}:
+ */
+  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2322, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_message);
+  __Pyx_GIVEREF(__pyx_v_message);
+  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_message);
+  __pyx_v_log_lines = ((PyObject*)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":2323
+ * 
+ *         log_lines = [message]
+ *         for key in sorted(context):             # <<<<<<<<<<<<<<
+ *             if key in {'message', 'exception'}:
+ *                 continue
+ */
+  __pyx_t_1 = PySequence_List(__pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2323, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_6 = PyList_Sort(__pyx_t_2); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 2323, __pyx_L1_error)
+  if (unlikely(__pyx_t_2 == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(0, 2323, __pyx_L1_error)
+  }
+  __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  for (;;) {
+    if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_1)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 2323, __pyx_L1_error)
+    #else
+    __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2323, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":2324
+ *         log_lines = [message]
+ *         for key in sorted(context):
+ *             if key in {'message', 'exception'}:             # <<<<<<<<<<<<<<
+ *                 continue
+ *             value = context[key]
+ */
+    __Pyx_INCREF(__pyx_v_key);
+    __pyx_t_2 = __pyx_v_key;
+    __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_message, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 2324, __pyx_L1_error)
+    if (!__pyx_t_5) {
+    } else {
+      __pyx_t_4 = __pyx_t_5;
+      goto __pyx_L8_bool_binop_done;
+    }
+    __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_exception, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 2324, __pyx_L1_error)
+    __pyx_t_4 = __pyx_t_5;
+    __pyx_L8_bool_binop_done:;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_5 = (__pyx_t_4 != 0);
+    if (__pyx_t_5) {
+
+      /* "uvloop/loop.pyx":2325
+ *         for key in sorted(context):
+ *             if key in {'message', 'exception'}:
+ *                 continue             # <<<<<<<<<<<<<<
+ *             value = context[key]
+ *             if key == 'source_traceback':
+ */
+      goto __pyx_L5_continue;
+
+      /* "uvloop/loop.pyx":2324
+ *         log_lines = [message]
+ *         for key in sorted(context):
+ *             if key in {'message', 'exception'}:             # <<<<<<<<<<<<<<
+ *                 continue
+ *             value = context[key]
+ */
+    }
+
+    /* "uvloop/loop.pyx":2326
+ *             if key in {'message', 'exception'}:
+ *                 continue
+ *             value = context[key]             # <<<<<<<<<<<<<<
+ *             if key == 'source_traceback':
+ *                 tb = ''.join(tb_format_list(value))
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_context, __pyx_v_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2326, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":2327
+ *                 continue
+ *             value = context[key]
+ *             if key == 'source_traceback':             # <<<<<<<<<<<<<<
+ *                 tb = ''.join(tb_format_list(value))
+ *                 value = 'Object created at (most recent call last):\n'
+ */
+    __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_key, __pyx_n_u_source_traceback, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 2327, __pyx_L1_error)
+    if (__pyx_t_5) {
+
+      /* "uvloop/loop.pyx":2328
+ *             value = context[key]
+ *             if key == 'source_traceback':
+ *                 tb = ''.join(tb_format_list(value))             # <<<<<<<<<<<<<<
+ *                 value = 'Object created at (most recent call last):\n'
+ *                 value += tb.rstrip()
+ */
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_tb_format_list);
+      __pyx_t_3 = __pyx_v_6uvloop_4loop_tb_format_list; __pyx_t_8 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3);
+        if (likely(__pyx_t_8)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+          __Pyx_INCREF(__pyx_t_8);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_3, function);
+        }
+      }
+      __pyx_t_2 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_8, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value);
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2328, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_3 = PyUnicode_Join(__pyx_kp_u__8, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2328, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_tb, ((PyObject*)__pyx_t_3));
+      __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":2329
+ *             if key == 'source_traceback':
+ *                 tb = ''.join(tb_format_list(value))
+ *                 value = 'Object created at (most recent call last):\n'             # <<<<<<<<<<<<<<
+ *                 value += tb.rstrip()
+ *             else:
+ */
+      __Pyx_INCREF(__pyx_kp_u_Object_created_at_most_recent_ca);
+      __Pyx_DECREF_SET(__pyx_v_value, __pyx_kp_u_Object_created_at_most_recent_ca);
+
+      /* "uvloop/loop.pyx":2330
+ *                 tb = ''.join(tb_format_list(value))
+ *                 value = 'Object created at (most recent call last):\n'
+ *                 value += tb.rstrip()             # <<<<<<<<<<<<<<
+ *             else:
+ *                 try:
+ */
+      __pyx_t_3 = __Pyx_CallUnboundCMethod0(&__pyx_umethod_PyUnicode_Type_rstrip, __pyx_v_tb); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2330, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_value, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2330, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_2);
+      __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":2327
+ *                 continue
+ *             value = context[key]
+ *             if key == 'source_traceback':             # <<<<<<<<<<<<<<
+ *                 tb = ''.join(tb_format_list(value))
+ *                 value = 'Object created at (most recent call last):\n'
+ */
+      goto __pyx_L10;
+    }
+
+    /* "uvloop/loop.pyx":2332
+ *                 value += tb.rstrip()
+ *             else:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     value = repr(value)
+ *                 except (KeyboardInterrupt, SystemExit):
+ */
+    /*else*/ {
+      {
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+        __Pyx_XGOTREF(__pyx_t_9);
+        __Pyx_XGOTREF(__pyx_t_10);
+        __Pyx_XGOTREF(__pyx_t_11);
+        /*try:*/ {
+
+          /* "uvloop/loop.pyx":2333
+ *             else:
+ *                 try:
+ *                     value = repr(value)             # <<<<<<<<<<<<<<
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise
+ */
+          __pyx_t_2 = PyObject_Repr(__pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2333, __pyx_L11_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_2);
+          __pyx_t_2 = 0;
+
+          /* "uvloop/loop.pyx":2332
+ *                 value += tb.rstrip()
+ *             else:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     value = repr(value)
+ *                 except (KeyboardInterrupt, SystemExit):
+ */
+        }
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        goto __pyx_L18_try_end;
+        __pyx_L11_error:;
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+        /* "uvloop/loop.pyx":2334
+ *                 try:
+ *                     value = repr(value)
+ *                 except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                     raise
+ *                 except BaseException as ex:
+ */
+        __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+        if (__pyx_t_12) {
+          __Pyx_AddTraceback("uvloop.loop.Loop.default_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_3, &__pyx_t_8) < 0) __PYX_ERR(0, 2334, __pyx_L13_except_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_GOTREF(__pyx_t_8);
+
+          /* "uvloop/loop.pyx":2335
+ *                     value = repr(value)
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise             # <<<<<<<<<<<<<<
+ *                 except BaseException as ex:
+ *                     value = ('Exception in __repr__ {!r}; '
+ */
+          __Pyx_GIVEREF(__pyx_t_2);
+          __Pyx_GIVEREF(__pyx_t_3);
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_3, __pyx_t_8);
+          __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_8 = 0; 
+          __PYX_ERR(0, 2335, __pyx_L13_except_error)
+        }
+
+        /* "uvloop/loop.pyx":2336
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise
+ *                 except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                     value = ('Exception in __repr__ {!r}; '
+ *                              'value type: {!r}'.format(ex, type(value)))
+ */
+        __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+        if (__pyx_t_12) {
+          __Pyx_AddTraceback("uvloop.loop.Loop.default_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_3, &__pyx_t_2) < 0) __PYX_ERR(0, 2336, __pyx_L13_except_error)
+          __Pyx_GOTREF(__pyx_t_8);
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_INCREF(__pyx_t_3);
+          __pyx_v_ex = __pyx_t_3;
+          /*try:*/ {
+
+            /* "uvloop/loop.pyx":2338
+ *                 except BaseException as ex:
+ *                     value = ('Exception in __repr__ {!r}; '
+ *                              'value type: {!r}'.format(ex, type(value)))             # <<<<<<<<<<<<<<
+ *             log_lines.append('{}: {}'.format(key, value))
+ * 
+ */
+            __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Exception_in___repr___r_value_ty, __pyx_n_s_format); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2338, __pyx_L26_error)
+            __Pyx_GOTREF(__pyx_t_14);
+            __pyx_t_15 = NULL;
+            __pyx_t_12 = 0;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) {
+              __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14);
+              if (likely(__pyx_t_15)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
+                __Pyx_INCREF(__pyx_t_15);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_14, function);
+                __pyx_t_12 = 1;
+              }
+            }
+            #if CYTHON_FAST_PYCALL
+            if (PyFunction_Check(__pyx_t_14)) {
+              PyObject *__pyx_temp[3] = {__pyx_t_15, __pyx_v_ex, ((PyObject *)Py_TYPE(__pyx_v_value))};
+              __pyx_t_13 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2338, __pyx_L26_error)
+              __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+              __Pyx_GOTREF(__pyx_t_13);
+            } else
+            #endif
+            #if CYTHON_FAST_PYCCALL
+            if (__Pyx_PyFastCFunction_Check(__pyx_t_14)) {
+              PyObject *__pyx_temp[3] = {__pyx_t_15, __pyx_v_ex, ((PyObject *)Py_TYPE(__pyx_v_value))};
+              __pyx_t_13 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2338, __pyx_L26_error)
+              __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+              __Pyx_GOTREF(__pyx_t_13);
+            } else
+            #endif
+            {
+              __pyx_t_16 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2338, __pyx_L26_error)
+              __Pyx_GOTREF(__pyx_t_16);
+              if (__pyx_t_15) {
+                __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_15); __pyx_t_15 = NULL;
+              }
+              __Pyx_INCREF(__pyx_v_ex);
+              __Pyx_GIVEREF(__pyx_v_ex);
+              PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_12, __pyx_v_ex);
+              __Pyx_INCREF(((PyObject *)Py_TYPE(__pyx_v_value)));
+              __Pyx_GIVEREF(((PyObject *)Py_TYPE(__pyx_v_value)));
+              PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_12, ((PyObject *)Py_TYPE(__pyx_v_value)));
+              __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_16, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2338, __pyx_L26_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+            }
+            __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+            __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_13);
+            __pyx_t_13 = 0;
+          }
+
+          /* "uvloop/loop.pyx":2336
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise
+ *                 except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                     value = ('Exception in __repr__ {!r}; '
+ *                              'value type: {!r}'.format(ex, type(value)))
+ */
+          /*finally:*/ {
+            /*normal exit:*/{
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+              goto __pyx_L27;
+            }
+            __pyx_L26_error:;
+            /*exception exit:*/{
+              __Pyx_PyThreadState_declare
+              __Pyx_PyThreadState_assign
+              __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0;
+              __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+              __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+              __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+              if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_22, &__pyx_t_23, &__pyx_t_24);
+              if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21) < 0)) __Pyx_ErrFetch(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
+              __Pyx_XGOTREF(__pyx_t_19);
+              __Pyx_XGOTREF(__pyx_t_20);
+              __Pyx_XGOTREF(__pyx_t_21);
+              __Pyx_XGOTREF(__pyx_t_22);
+              __Pyx_XGOTREF(__pyx_t_23);
+              __Pyx_XGOTREF(__pyx_t_24);
+              __pyx_t_12 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename;
+              {
+                __Pyx_DECREF(__pyx_v_ex);
+                __pyx_v_ex = NULL;
+              }
+              if (PY_MAJOR_VERSION >= 3) {
+                __Pyx_XGIVEREF(__pyx_t_22);
+                __Pyx_XGIVEREF(__pyx_t_23);
+                __Pyx_XGIVEREF(__pyx_t_24);
+                __Pyx_ExceptionReset(__pyx_t_22, __pyx_t_23, __pyx_t_24);
+              }
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_XGIVEREF(__pyx_t_21);
+              __Pyx_ErrRestore(__pyx_t_19, __pyx_t_20, __pyx_t_21);
+              __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0;
+              __pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18;
+              goto __pyx_L13_except_error;
+            }
+            __pyx_L27:;
+          }
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+          goto __pyx_L12_exception_handled;
+        }
+        goto __pyx_L13_except_error;
+        __pyx_L13_except_error:;
+
+        /* "uvloop/loop.pyx":2332
+ *                 value += tb.rstrip()
+ *             else:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     value = repr(value)
+ *                 except (KeyboardInterrupt, SystemExit):
+ */
+        __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);
+        goto __pyx_L1_error;
+        __pyx_L12_exception_handled:;
+        __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_L18_try_end:;
+      }
+    }
+    __pyx_L10:;
+
+    /* "uvloop/loop.pyx":2339
+ *                     value = ('Exception in __repr__ {!r}; '
+ *                              'value type: {!r}'.format(ex, type(value)))
+ *             log_lines.append('{}: {}'.format(key, value))             # <<<<<<<<<<<<<<
+ * 
+ *         aio_logger.error('\n'.join(log_lines), exc_info=exc_info)
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__68, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2339, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_8 = NULL;
+    __pyx_t_17 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_17 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_key, __pyx_v_value};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_17, 2+__pyx_t_17); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2339, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_key, __pyx_v_value};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_17, 2+__pyx_t_17); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2339, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+    } else
+    #endif
+    {
+      __pyx_t_13 = PyTuple_New(2+__pyx_t_17); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2339, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      if (__pyx_t_8) {
+        __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_8); __pyx_t_8 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_key);
+      __Pyx_GIVEREF(__pyx_v_key);
+      PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_17, __pyx_v_key);
+      __Pyx_INCREF(__pyx_v_value);
+      __Pyx_GIVEREF(__pyx_v_value);
+      PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_17, __pyx_v_value);
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2339, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_log_lines, __pyx_t_2); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 2339, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":2323
+ * 
+ *         log_lines = [message]
+ *         for key in sorted(context):             # <<<<<<<<<<<<<<
+ *             if key in {'message', 'exception'}:
+ *                 continue
+ */
+    __pyx_L5_continue:;
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2341
+ *             log_lines.append('{}: {}'.format(key, value))
+ * 
+ *         aio_logger.error('\n'.join(log_lines), exc_info=exc_info)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_exception_handler(self):
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyUnicode_Join(__pyx_kp_u__69, __pyx_v_log_lines); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exc_info, __pyx_v_exc_info) < 0) __PYX_ERR(0, 2341, __pyx_L1_error)
+  __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_13);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+  /* "uvloop/loop.pyx":2302
+ *             return tr, protocol
+ * 
+ *     def default_exception_handler(self, context):             # <<<<<<<<<<<<<<
+ *         """Default exception handler.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_8);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_XDECREF(__pyx_t_15);
+  __Pyx_XDECREF(__pyx_t_16);
+  __Pyx_AddTraceback("uvloop.loop.Loop.default_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_message);
+  __Pyx_XDECREF(__pyx_v_exception);
+  __Pyx_XDECREF(__pyx_v_exc_info);
+  __Pyx_XDECREF(__pyx_v_log_lines);
+  __Pyx_XDECREF(__pyx_v_key);
+  __Pyx_XDECREF(__pyx_v_value);
+  __Pyx_XDECREF(__pyx_v_tb);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2343
+ *         aio_logger.error('\n'.join(log_lines), exc_info=exc_info)
+ * 
+ *     def get_exception_handler(self):             # <<<<<<<<<<<<<<
+ *         """Return an exception handler, or None if the default one is in use.
+ *         """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_70get_exception_handler(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_69get_exception_handler[] = "Loop.get_exception_handler(self)\nReturn an exception handler, or None if the default one is in use.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_70get_exception_handler(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_exception_handler (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_69get_exception_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_69get_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_exception_handler", 0);
+
+  /* "uvloop/loop.pyx":2346
+ *         """Return an exception handler, or None if the default one is in use.
+ *         """
+ *         return self._exception_handler             # <<<<<<<<<<<<<<
+ * 
+ *     def set_exception_handler(self, handler):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_exception_handler);
+  __pyx_r = __pyx_v_self->_exception_handler;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":2343
+ *         aio_logger.error('\n'.join(log_lines), exc_info=exc_info)
+ * 
+ *     def get_exception_handler(self):             # <<<<<<<<<<<<<<
+ *         """Return an exception handler, or None if the default one is in use.
+ *         """
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2348
+ *         return self._exception_handler
+ * 
+ *     def set_exception_handler(self, handler):             # <<<<<<<<<<<<<<
+ *         """Set handler as the new event loop exception handler.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_72set_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_handler); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_71set_exception_handler[] = "Loop.set_exception_handler(self, handler)\nSet handler as the new event loop exception handler.\n\n        If handler is None, the default exception handler will\n        be set.\n\n        If handler is a callable object, it should have a\n        signature matching '(loop, context)', where 'loop'\n        will be a reference to the active event loop, 'context'\n        will be a dict object (see `call_exception_handler()`\n        documentation for details about context).\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_72set_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_handler) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_exception_handler (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_71set_exception_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_handler));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_71set_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_handler) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_exception_handler", 0);
+
+  /* "uvloop/loop.pyx":2360
+ *         documentation for details about context).
+ *         """
+ *         if handler is not None and not callable(handler):             # <<<<<<<<<<<<<<
+ *             raise TypeError('A callable object or None is expected, '
+ *                             'got {!r}'.format(handler))
+ */
+  __pyx_t_2 = (__pyx_v_handler != 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;
+  }
+  __pyx_t_3 = __Pyx_PyCallable_Check(__pyx_v_handler); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 2360, __pyx_L1_error)
+  __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":2362
+ *         if handler is not None and not callable(handler):
+ *             raise TypeError('A callable object or None is expected, '
+ *                             'got {!r}'.format(handler))             # <<<<<<<<<<<<<<
+ *         self._exception_handler = handler
+ * 
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_callable_object_or_None_is_exp, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2362, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_v_handler) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_handler);
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2362, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":2361
+ *         """
+ *         if handler is not None and not callable(handler):
+ *             raise TypeError('A callable object or None is expected, '             # <<<<<<<<<<<<<<
+ *                             'got {!r}'.format(handler))
+ *         self._exception_handler = handler
+ */
+    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2361, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __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, 2361, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2360
+ *         documentation for details about context).
+ *         """
+ *         if handler is not None and not callable(handler):             # <<<<<<<<<<<<<<
+ *             raise TypeError('A callable object or None is expected, '
+ *                             'got {!r}'.format(handler))
+ */
+  }
+
+  /* "uvloop/loop.pyx":2363
+ *             raise TypeError('A callable object or None is expected, '
+ *                             'got {!r}'.format(handler))
+ *         self._exception_handler = handler             # <<<<<<<<<<<<<<
+ * 
+ *     def call_exception_handler(self, context):
+ */
+  __Pyx_INCREF(__pyx_v_handler);
+  __Pyx_GIVEREF(__pyx_v_handler);
+  __Pyx_GOTREF(__pyx_v_self->_exception_handler);
+  __Pyx_DECREF(__pyx_v_self->_exception_handler);
+  __pyx_v_self->_exception_handler = __pyx_v_handler;
+
+  /* "uvloop/loop.pyx":2348
+ *         return self._exception_handler
+ * 
+ *     def set_exception_handler(self, handler):             # <<<<<<<<<<<<<<
+ *         """Set handler as the new event loop exception handler.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.Loop.set_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2365
+ *         self._exception_handler = handler
+ * 
+ *     def call_exception_handler(self, context):             # <<<<<<<<<<<<<<
+ *         """Call the current event loop's exception handler.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_74call_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_context); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_73call_exception_handler[] = "Loop.call_exception_handler(self, context)\nCall the current event loop's exception handler.\n\n        The context argument is a dict containing the following keys:\n\n        - 'message': Error message;\n        - 'exception' (optional): Exception object;\n        - 'future' (optional): Future instance;\n        - 'handle' (optional): Handle instance;\n        - 'protocol' (optional): Protocol instance;\n        - 'transport' (optional): Transport instance;\n        - 'socket' (optional): Socket instance.\n\n        New keys maybe introduced in the future.\n\n        Note: do not overload this method in an event loop subclass.\n        For custom exception handling, use the\n        `set_exception_handler()` method.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_74call_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_context) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("call_exception_handler (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_73call_exception_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_context));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_73call_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_context) {
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  int __pyx_t_19;
+  char const *__pyx_t_20;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  PyObject *__pyx_t_23 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("call_exception_handler", 0);
+
+  /* "uvloop/loop.pyx":2384
+ *         `set_exception_handler()` method.
+ *         """
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             self._debug_exception_handler_cnt += 1
+ * 
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":2385
+ *         """
+ *         if UVLOOP_DEBUG:
+ *             self._debug_exception_handler_cnt += 1             # <<<<<<<<<<<<<<
+ * 
+ *         if self._exception_handler is None:
+ */
+    __pyx_v_self->_debug_exception_handler_cnt = (__pyx_v_self->_debug_exception_handler_cnt + 1);
+
+    /* "uvloop/loop.pyx":2384
+ *         `set_exception_handler()` method.
+ *         """
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             self._debug_exception_handler_cnt += 1
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2387
+ *             self._debug_exception_handler_cnt += 1
+ * 
+ *         if self._exception_handler is None:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 self.default_exception_handler(context)
+ */
+  __pyx_t_1 = (__pyx_v_self->_exception_handler == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":2388
+ * 
+ *         if self._exception_handler is None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self.default_exception_handler(context)
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+    {
+      __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:*/ {
+
+        /* "uvloop/loop.pyx":2389
+ *         if self._exception_handler is None:
+ *             try:
+ *                 self.default_exception_handler(context)             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_default_exception_handler); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2389, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __pyx_t_8 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+          if (likely(__pyx_t_8)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+            __Pyx_INCREF(__pyx_t_8);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_7, function);
+          }
+        }
+        __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_v_context) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_context);
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2389, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+        /* "uvloop/loop.pyx":2388
+ * 
+ *         if self._exception_handler is None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self.default_exception_handler(context)
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      }
+      __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_L10_try_end;
+      __pyx_L5_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;
+
+      /* "uvloop/loop.pyx":2390
+ *             try:
+ *                 self.default_exception_handler(context)
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.call_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 2390, __pyx_L7_except_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_8);
+
+        /* "uvloop/loop.pyx":2391
+ *                 self.default_exception_handler(context)
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException:
+ *                 # Second protection layer for unexpected errors
+ */
+        __Pyx_GIVEREF(__pyx_t_6);
+        __Pyx_GIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __Pyx_ErrRestoreWithState(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+        __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; 
+        __PYX_ERR(0, 2391, __pyx_L7_except_error)
+      }
+
+      /* "uvloop/loop.pyx":2392
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException:             # <<<<<<<<<<<<<<
+ *                 # Second protection layer for unexpected errors
+ *                 # in the default implementation, as well as for subclassed
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.call_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(0, 2392, __pyx_L7_except_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_6);
+
+        /* "uvloop/loop.pyx":2396
+ *                 # in the default implementation, as well as for subclassed
+ *                 # event loops with overloaded "default_exception_handler".
+ *                 aio_logger.error('Exception in default exception handler',             # <<<<<<<<<<<<<<
+ *                                  exc_info=True)
+ *         else:
+ */
+        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2396, __pyx_L7_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+
+        /* "uvloop/loop.pyx":2397
+ *                 # event loops with overloaded "default_exception_handler".
+ *                 aio_logger.error('Exception in default exception handler',
+ *                                  exc_info=True)             # <<<<<<<<<<<<<<
+ *         else:
+ *             try:
+ */
+        __pyx_t_11 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2397, __pyx_L7_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        if (PyDict_SetItem(__pyx_t_11, __pyx_n_s_exc_info, Py_True) < 0) __PYX_ERR(0, 2397, __pyx_L7_except_error)
+
+        /* "uvloop/loop.pyx":2396
+ *                 # in the default implementation, as well as for subclassed
+ *                 # event loops with overloaded "default_exception_handler".
+ *                 aio_logger.error('Exception in default exception handler',             # <<<<<<<<<<<<<<
+ *                                  exc_info=True)
+ *         else:
+ */
+        __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_tuple__70, __pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2396, __pyx_L7_except_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        goto __pyx_L6_exception_handled;
+      }
+      goto __pyx_L7_except_error;
+      __pyx_L7_except_error:;
+
+      /* "uvloop/loop.pyx":2388
+ * 
+ *         if self._exception_handler is None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self.default_exception_handler(context)
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      __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_L6_exception_handled:;
+      __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);
+      __pyx_L10_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":2387
+ *             self._debug_exception_handler_cnt += 1
+ * 
+ *         if self._exception_handler is None:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 self.default_exception_handler(context)
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/loop.pyx":2399
+ *                                  exc_info=True)
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self._exception_handler(self, context)
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+  /*else*/ {
+    {
+      __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:*/ {
+
+        /* "uvloop/loop.pyx":2400
+ *         else:
+ *             try:
+ *                 self._exception_handler(self, context)             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        __Pyx_INCREF(__pyx_v_self->_exception_handler);
+        __pyx_t_7 = __pyx_v_self->_exception_handler; __pyx_t_8 = NULL;
+        __pyx_t_9 = 0;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+          if (likely(__pyx_t_8)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+            __Pyx_INCREF(__pyx_t_8);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_7, function);
+            __pyx_t_9 = 1;
+          }
+        }
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_7)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_8, ((PyObject *)__pyx_v_self), __pyx_v_context};
+          __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2400, __pyx_L15_error)
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_GOTREF(__pyx_t_6);
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_8, ((PyObject *)__pyx_v_self), __pyx_v_context};
+          __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2400, __pyx_L15_error)
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_GOTREF(__pyx_t_6);
+        } else
+        #endif
+        {
+          __pyx_t_12 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2400, __pyx_L15_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          if (__pyx_t_8) {
+            __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __pyx_t_8 = NULL;
+          }
+          __Pyx_INCREF(((PyObject *)__pyx_v_self));
+          __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+          PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_9, ((PyObject *)__pyx_v_self));
+          __Pyx_INCREF(__pyx_v_context);
+          __Pyx_GIVEREF(__pyx_v_context);
+          PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_9, __pyx_v_context);
+          __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_12, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2400, __pyx_L15_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+        /* "uvloop/loop.pyx":2399
+ *                                  exc_info=True)
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self._exception_handler(self, context)
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      }
+      __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_L20_try_end;
+      __pyx_L15_error:;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __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;
+
+      /* "uvloop/loop.pyx":2401
+ *             try:
+ *                 self._exception_handler(self, context)
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException as exc:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.call_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_12) < 0) __PYX_ERR(0, 2401, __pyx_L17_except_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_12);
+
+        /* "uvloop/loop.pyx":2402
+ *                 self._exception_handler(self, context)
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException as exc:
+ *                 # Exception in the user set custom exception handler.
+ */
+        __Pyx_GIVEREF(__pyx_t_6);
+        __Pyx_GIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ErrRestoreWithState(__pyx_t_6, __pyx_t_7, __pyx_t_12);
+        __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_12 = 0; 
+        __PYX_ERR(0, 2402, __pyx_L17_except_error)
+      }
+
+      /* "uvloop/loop.pyx":2403
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as exc:             # <<<<<<<<<<<<<<
+ *                 # Exception in the user set custom exception handler.
+ *                 try:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.call_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(0, 2403, __pyx_L17_except_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_7);
+        __pyx_v_exc = __pyx_t_7;
+        /*try:*/ {
+
+          /* "uvloop/loop.pyx":2405
+ *             except BaseException as exc:
+ *                 # Exception in the user set custom exception handler.
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     # Let's try default handler.
+ *                     self.default_exception_handler({
+ */
+          {
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_13);
+            __Pyx_XGOTREF(__pyx_t_14);
+            __Pyx_XGOTREF(__pyx_t_15);
+            /*try:*/ {
+
+              /* "uvloop/loop.pyx":2407
+ *                 try:
+ *                     # Let's try default handler.
+ *                     self.default_exception_handler({             # <<<<<<<<<<<<<<
+ *                         'message': 'Unhandled error in exception handler',
+ *                         'exception': exc,
+ */
+              __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_default_exception_handler); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2407, __pyx_L30_error)
+              __Pyx_GOTREF(__pyx_t_11);
+
+              /* "uvloop/loop.pyx":2408
+ *                     # Let's try default handler.
+ *                     self.default_exception_handler({
+ *                         'message': 'Unhandled error in exception handler',             # <<<<<<<<<<<<<<
+ *                         'exception': exc,
+ *                         'context': context,
+ */
+              __pyx_t_10 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2408, __pyx_L30_error)
+              __Pyx_GOTREF(__pyx_t_10);
+              if (PyDict_SetItem(__pyx_t_10, __pyx_n_u_message, __pyx_kp_u_Unhandled_error_in_exception_han) < 0) __PYX_ERR(0, 2408, __pyx_L30_error)
+
+              /* "uvloop/loop.pyx":2409
+ *                     self.default_exception_handler({
+ *                         'message': 'Unhandled error in exception handler',
+ *                         'exception': exc,             # <<<<<<<<<<<<<<
+ *                         'context': context,
+ *                     })
+ */
+              if (PyDict_SetItem(__pyx_t_10, __pyx_n_u_exception, __pyx_v_exc) < 0) __PYX_ERR(0, 2408, __pyx_L30_error)
+
+              /* "uvloop/loop.pyx":2410
+ *                         'message': 'Unhandled error in exception handler',
+ *                         'exception': exc,
+ *                         'context': context,             # <<<<<<<<<<<<<<
+ *                     })
+ *                 except (KeyboardInterrupt, SystemExit):
+ */
+              if (PyDict_SetItem(__pyx_t_10, __pyx_n_u_context, __pyx_v_context) < 0) __PYX_ERR(0, 2408, __pyx_L30_error)
+              __pyx_t_16 = NULL;
+              if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+                __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_11);
+                if (likely(__pyx_t_16)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+                  __Pyx_INCREF(__pyx_t_16);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_11, function);
+                }
+              }
+              __pyx_t_8 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_16, __pyx_t_10) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_10);
+              __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+              __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+              if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2407, __pyx_L30_error)
+              __Pyx_GOTREF(__pyx_t_8);
+              __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+              /* "uvloop/loop.pyx":2405
+ *             except BaseException as exc:
+ *                 # Exception in the user set custom exception handler.
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     # Let's try default handler.
+ *                     self.default_exception_handler({
+ */
+            }
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+            goto __pyx_L37_try_end;
+            __pyx_L30_error:;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+            __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+            /* "uvloop/loop.pyx":2412
+ *                         'context': context,
+ *                     })
+ *                 except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                     raise
+ *                 except BaseException:
+ */
+            __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+            if (__pyx_t_9) {
+              __Pyx_AddTraceback("uvloop.loop.Loop.call_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+              if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_11, &__pyx_t_10) < 0) __PYX_ERR(0, 2412, __pyx_L32_except_error)
+              __Pyx_GOTREF(__pyx_t_8);
+              __Pyx_GOTREF(__pyx_t_11);
+              __Pyx_GOTREF(__pyx_t_10);
+
+              /* "uvloop/loop.pyx":2413
+ *                     })
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise             # <<<<<<<<<<<<<<
+ *                 except BaseException:
+ *                     # Guard 'default_exception_handler' in case it is
+ */
+              __Pyx_GIVEREF(__pyx_t_8);
+              __Pyx_GIVEREF(__pyx_t_11);
+              __Pyx_XGIVEREF(__pyx_t_10);
+              __Pyx_ErrRestoreWithState(__pyx_t_8, __pyx_t_11, __pyx_t_10);
+              __pyx_t_8 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; 
+              __PYX_ERR(0, 2413, __pyx_L32_except_error)
+            }
+
+            /* "uvloop/loop.pyx":2414
+ *                 except (KeyboardInterrupt, SystemExit):
+ *                     raise
+ *                 except BaseException:             # <<<<<<<<<<<<<<
+ *                     # Guard 'default_exception_handler' in case it is
+ *                     # overloaded.
+ */
+            __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+            if (__pyx_t_9) {
+              __Pyx_AddTraceback("uvloop.loop.Loop.call_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+              if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_11, &__pyx_t_8) < 0) __PYX_ERR(0, 2414, __pyx_L32_except_error)
+              __Pyx_GOTREF(__pyx_t_10);
+              __Pyx_GOTREF(__pyx_t_11);
+              __Pyx_GOTREF(__pyx_t_8);
+
+              /* "uvloop/loop.pyx":2417
+ *                     # Guard 'default_exception_handler' in case it is
+ *                     # overloaded.
+ *                     aio_logger.error('Exception in default exception handler '             # <<<<<<<<<<<<<<
+ *                                      'while handling an unexpected error '
+ *                                      'in custom exception handler',
+ */
+              __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2417, __pyx_L32_except_error)
+              __Pyx_GOTREF(__pyx_t_16);
+
+              /* "uvloop/loop.pyx":2420
+ *                                      'while handling an unexpected error '
+ *                                      'in custom exception handler',
+ *                                      exc_info=True)             # <<<<<<<<<<<<<<
+ * 
+ *     def add_reader(self, fileobj, callback, *args):
+ */
+              __pyx_t_17 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2420, __pyx_L32_except_error)
+              __Pyx_GOTREF(__pyx_t_17);
+              if (PyDict_SetItem(__pyx_t_17, __pyx_n_s_exc_info, Py_True) < 0) __PYX_ERR(0, 2420, __pyx_L32_except_error)
+
+              /* "uvloop/loop.pyx":2417
+ *                     # Guard 'default_exception_handler' in case it is
+ *                     # overloaded.
+ *                     aio_logger.error('Exception in default exception handler '             # <<<<<<<<<<<<<<
+ *                                      'while handling an unexpected error '
+ *                                      'in custom exception handler',
+ */
+              __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_16, __pyx_tuple__71, __pyx_t_17); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2417, __pyx_L32_except_error)
+              __Pyx_GOTREF(__pyx_t_18);
+              __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+              __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
+              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+              __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+              goto __pyx_L31_exception_handled;
+            }
+            goto __pyx_L32_except_error;
+            __pyx_L32_except_error:;
+
+            /* "uvloop/loop.pyx":2405
+ *             except BaseException as exc:
+ *                 # Exception in the user set custom exception handler.
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     # Let's try default handler.
+ *                     self.default_exception_handler({
+ */
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+            goto __pyx_L28_error;
+            __pyx_L31_exception_handled:;
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+            __pyx_L37_try_end:;
+          }
+        }
+
+        /* "uvloop/loop.pyx":2403
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as exc:             # <<<<<<<<<<<<<<
+ *                 # Exception in the user set custom exception handler.
+ *                 try:
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+            goto __pyx_L29;
+          }
+          __pyx_L28_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+            __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
+            __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+            __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_14);
+            __Pyx_XGOTREF(__pyx_t_13);
+            __Pyx_XGOTREF(__pyx_t_21);
+            __Pyx_XGOTREF(__pyx_t_22);
+            __Pyx_XGOTREF(__pyx_t_23);
+            __pyx_t_9 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_exc);
+              __pyx_v_exc = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_21);
+              __Pyx_XGIVEREF(__pyx_t_22);
+              __Pyx_XGIVEREF(__pyx_t_23);
+              __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_22, __pyx_t_23);
+            }
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_ErrRestore(__pyx_t_15, __pyx_t_14, __pyx_t_13);
+            __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0;
+            __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20;
+            goto __pyx_L17_except_error;
+          }
+          __pyx_L29:;
+        }
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        goto __pyx_L16_exception_handled;
+      }
+      goto __pyx_L17_except_error;
+      __pyx_L17_except_error:;
+
+      /* "uvloop/loop.pyx":2399
+ *                                  exc_info=True)
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self._exception_handler(self, context)
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      __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_L16_exception_handled:;
+      __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);
+      __pyx_L20_try_end:;
+    }
+  }
+  __pyx_L4:;
+
+  /* "uvloop/loop.pyx":2365
+ *         self._exception_handler = handler
+ * 
+ *     def call_exception_handler(self, context):             # <<<<<<<<<<<<<<
+ *         """Call the current event loop's exception handler.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_16);
+  __Pyx_XDECREF(__pyx_t_17);
+  __Pyx_XDECREF(__pyx_t_18);
+  __Pyx_AddTraceback("uvloop.loop.Loop.call_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2422
+ *                                      exc_info=True)
+ * 
+ *     def add_reader(self, fileobj, callback, *args):             # <<<<<<<<<<<<<<
+ *         """Add a reader callback."""
+ *         if len(args) == 0:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_76add_reader(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_75add_reader[] = "Loop.add_reader(self, fileobj, callback, *args)\nAdd a reader callback.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_76add_reader(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_fileobj = 0;
+  PyObject *__pyx_v_callback = 0;
+  PyObject *__pyx_v_args = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_reader (wrapper)", 0);
+  if (PyTuple_GET_SIZE(__pyx_args) > 2) {
+    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
+    if (unlikely(!__pyx_v_args)) {
+      __Pyx_RefNannyFinishContext();
+      return NULL;
+    }
+    __Pyx_GOTREF(__pyx_v_args);
+  } else {
+    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
+  }
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fileobj,&__pyx_n_s_callback,0};
+    PyObject* values[2] = {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) {
+        default:
+        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;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fileobj)) != 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_callback)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("add_reader", 0, 2, 2, 1); __PYX_ERR(0, 2422, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "add_reader") < 0)) __PYX_ERR(0, 2422, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_fileobj = values[0];
+    __pyx_v_callback = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("add_reader", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2422, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
+  __Pyx_AddTraceback("uvloop.loop.Loop.add_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_75add_reader(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_fileobj, __pyx_v_callback, __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_75add_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("add_reader", 0);
+  __Pyx_INCREF(__pyx_v_args);
+
+  /* "uvloop/loop.pyx":2424
+ *     def add_reader(self, fileobj, callback, *args):
+ *         """Add a reader callback."""
+ *         if len(args) == 0:             # <<<<<<<<<<<<<<
+ *             args = None
+ *         self._add_reader(fileobj, new_Handle(self, callback, args, None))
+ */
+  __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2424, __pyx_L1_error)
+  __pyx_t_2 = ((__pyx_t_1 == 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":2425
+ *         """Add a reader callback."""
+ *         if len(args) == 0:
+ *             args = None             # <<<<<<<<<<<<<<
+ *         self._add_reader(fileobj, new_Handle(self, callback, args, None))
+ * 
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_DECREF_SET(__pyx_v_args, ((PyObject*)Py_None));
+
+    /* "uvloop/loop.pyx":2424
+ *     def add_reader(self, fileobj, callback, *args):
+ *         """Add a reader callback."""
+ *         if len(args) == 0:             # <<<<<<<<<<<<<<
+ *             args = None
+ *         self._add_reader(fileobj, new_Handle(self, callback, args, None))
+ */
+  }
+
+  /* "uvloop/loop.pyx":2426
+ *         if len(args) == 0:
+ *             args = None
+ *         self._add_reader(fileobj, new_Handle(self, callback, args, None))             # <<<<<<<<<<<<<<
+ * 
+ *     def remove_reader(self, fileobj):
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_new_Handle(__pyx_v_self, __pyx_v_callback, __pyx_v_args, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2426, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 2426, __pyx_L1_error)
+  __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_add_reader(__pyx_v_self, __pyx_v_fileobj, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2426, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2422
+ *                                      exc_info=True)
+ * 
+ *     def add_reader(self, fileobj, callback, *args):             # <<<<<<<<<<<<<<
+ *         """Add a reader callback."""
+ *         if len(args) == 0:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Loop.add_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2428
+ *         self._add_reader(fileobj, new_Handle(self, callback, args, None))
+ * 
+ *     def remove_reader(self, fileobj):             # <<<<<<<<<<<<<<
+ *         """Remove a reader callback."""
+ *         self._remove_reader(fileobj)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_78remove_reader(PyObject *__pyx_v_self, PyObject *__pyx_v_fileobj); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_77remove_reader[] = "Loop.remove_reader(self, fileobj)\nRemove a reader callback.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_78remove_reader(PyObject *__pyx_v_self, PyObject *__pyx_v_fileobj) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("remove_reader (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_77remove_reader(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_fileobj));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_77remove_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj) {
+  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("remove_reader", 0);
+
+  /* "uvloop/loop.pyx":2430
+ *     def remove_reader(self, fileobj):
+ *         """Remove a reader callback."""
+ *         self._remove_reader(fileobj)             # <<<<<<<<<<<<<<
+ * 
+ *     def add_writer(self, fileobj, callback, *args):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_reader(__pyx_v_self, __pyx_v_fileobj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2430, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2428
+ *         self._add_reader(fileobj, new_Handle(self, callback, args, None))
+ * 
+ *     def remove_reader(self, fileobj):             # <<<<<<<<<<<<<<
+ *         """Remove a reader callback."""
+ *         self._remove_reader(fileobj)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop.remove_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2432
+ *         self._remove_reader(fileobj)
+ * 
+ *     def add_writer(self, fileobj, callback, *args):             # <<<<<<<<<<<<<<
+ *         """Add a writer callback.."""
+ *         if len(args) == 0:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_80add_writer(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_79add_writer[] = "Loop.add_writer(self, fileobj, callback, *args)\nAdd a writer callback..";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_80add_writer(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_fileobj = 0;
+  PyObject *__pyx_v_callback = 0;
+  PyObject *__pyx_v_args = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_writer (wrapper)", 0);
+  if (PyTuple_GET_SIZE(__pyx_args) > 2) {
+    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
+    if (unlikely(!__pyx_v_args)) {
+      __Pyx_RefNannyFinishContext();
+      return NULL;
+    }
+    __Pyx_GOTREF(__pyx_v_args);
+  } else {
+    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
+  }
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fileobj,&__pyx_n_s_callback,0};
+    PyObject* values[2] = {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) {
+        default:
+        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;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fileobj)) != 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_callback)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("add_writer", 0, 2, 2, 1); __PYX_ERR(0, 2432, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "add_writer") < 0)) __PYX_ERR(0, 2432, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_fileobj = values[0];
+    __pyx_v_callback = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("add_writer", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2432, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
+  __Pyx_AddTraceback("uvloop.loop.Loop.add_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_79add_writer(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_fileobj, __pyx_v_callback, __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_79add_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("add_writer", 0);
+  __Pyx_INCREF(__pyx_v_args);
+
+  /* "uvloop/loop.pyx":2434
+ *     def add_writer(self, fileobj, callback, *args):
+ *         """Add a writer callback.."""
+ *         if len(args) == 0:             # <<<<<<<<<<<<<<
+ *             args = None
+ *         self._add_writer(fileobj, new_Handle(self, callback, args, None))
+ */
+  __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2434, __pyx_L1_error)
+  __pyx_t_2 = ((__pyx_t_1 == 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":2435
+ *         """Add a writer callback.."""
+ *         if len(args) == 0:
+ *             args = None             # <<<<<<<<<<<<<<
+ *         self._add_writer(fileobj, new_Handle(self, callback, args, None))
+ * 
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_DECREF_SET(__pyx_v_args, ((PyObject*)Py_None));
+
+    /* "uvloop/loop.pyx":2434
+ *     def add_writer(self, fileobj, callback, *args):
+ *         """Add a writer callback.."""
+ *         if len(args) == 0:             # <<<<<<<<<<<<<<
+ *             args = None
+ *         self._add_writer(fileobj, new_Handle(self, callback, args, None))
+ */
+  }
+
+  /* "uvloop/loop.pyx":2436
+ *         if len(args) == 0:
+ *             args = None
+ *         self._add_writer(fileobj, new_Handle(self, callback, args, None))             # <<<<<<<<<<<<<<
+ * 
+ *     def remove_writer(self, fileobj):
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_new_Handle(__pyx_v_self, __pyx_v_callback, __pyx_v_args, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2436, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 2436, __pyx_L1_error)
+  __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_add_writer(__pyx_v_self, __pyx_v_fileobj, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2436, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2432
+ *         self._remove_reader(fileobj)
+ * 
+ *     def add_writer(self, fileobj, callback, *args):             # <<<<<<<<<<<<<<
+ *         """Add a writer callback.."""
+ *         if len(args) == 0:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Loop.add_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2438
+ *         self._add_writer(fileobj, new_Handle(self, callback, args, None))
+ * 
+ *     def remove_writer(self, fileobj):             # <<<<<<<<<<<<<<
+ *         """Remove a writer callback."""
+ *         self._remove_writer(fileobj)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_82remove_writer(PyObject *__pyx_v_self, PyObject *__pyx_v_fileobj); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_81remove_writer[] = "Loop.remove_writer(self, fileobj)\nRemove a writer callback.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_82remove_writer(PyObject *__pyx_v_self, PyObject *__pyx_v_fileobj) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("remove_writer (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_81remove_writer(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_fileobj));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_81remove_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fileobj) {
+  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("remove_writer", 0);
+
+  /* "uvloop/loop.pyx":2440
+ *     def remove_writer(self, fileobj):
+ *         """Remove a writer callback."""
+ *         self._remove_writer(fileobj)             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_remove_writer(__pyx_v_self, __pyx_v_fileobj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2440, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2438
+ *         self._add_writer(fileobj, new_Handle(self, callback, args, None))
+ * 
+ *     def remove_writer(self, fileobj):             # <<<<<<<<<<<<<<
+ *         """Remove a writer callback."""
+ *         self._remove_writer(fileobj)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop.remove_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_85generator7(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2443
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_recv(self, sock, n):             # <<<<<<<<<<<<<<
+ *         """Receive data from the socket.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_84sock_recv(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_83sock_recv[] = "Loop.sock_recv(self, sock, n)\nReceive data from the socket.\n\n        The return value is a bytes object representing the data received.\n        The maximum amount of data to be received at once is specified by\n        nbytes.\n\n        This method is a coroutine.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_84sock_recv(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_sock = 0;
+  PyObject *__pyx_v_n = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sock_recv (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sock,&__pyx_n_s_n,0};
+    PyObject* values[2] = {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  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_sock)) != 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_n)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("sock_recv", 1, 2, 2, 1); __PYX_ERR(0, 2443, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "sock_recv") < 0)) __PYX_ERR(0, 2443, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_sock = values[0];
+    __pyx_v_n = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("sock_recv", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2443, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.sock_recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_83sock_recv(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_sock, __pyx_v_n);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_83sock_recv(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_n) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("sock_recv", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_13_sock_recv(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_13_sock_recv, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2443, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_sock = __pyx_v_sock;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+  __pyx_cur_scope->__pyx_v_n = __pyx_v_n;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_n);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_n);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_85generator7, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_sock_recv, __pyx_n_s_Loop_sock_recv, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2443, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.sock_recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_85generator7(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sock_recv", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L7_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2443, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2455
+ *             Handle handle
+ * 
+ *         if self._debug and sock.gettimeout() != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->_debug != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_gettimeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2455, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2455, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2455, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2455, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L5_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":2456
+ * 
+ *         if self._debug and sock.gettimeout() != 0:
+ *             raise ValueError("the socket must be non-blocking")             # <<<<<<<<<<<<<<
+ * 
+ *         fut = _SyncSocketReaderFuture(sock, self)
+ */
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2456, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(0, 2456, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2455
+ *             Handle handle
+ * 
+ *         if self._debug and sock.gettimeout() != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2458
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ *         fut = _SyncSocketReaderFuture(sock, self)             # <<<<<<<<<<<<<<
+ *         handle = new_MethodHandle3(
+ *             self,
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SyncSocketReaderFuture); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2458, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __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_cur_scope->__pyx_v_sock, ((PyObject *)__pyx_cur_scope->__pyx_v_self)};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2458, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_sock, ((PyObject *)__pyx_cur_scope->__pyx_v_self)};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2458, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+  } else
+  #endif
+  {
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2458, __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_cur_scope->__pyx_v_sock);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_cur_scope->__pyx_v_sock);
+    __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2458, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GIVEREF(__pyx_t_4);
+  __pyx_cur_scope->__pyx_v_fut = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2459
+ * 
+ *         fut = _SyncSocketReaderFuture(sock, self)
+ *         handle = new_MethodHandle3(             # <<<<<<<<<<<<<<
+ *             self,
+ *             "Loop._sock_recv",
+ */
+  __pyx_t_4 = __pyx_f_6uvloop_4loop_new_MethodHandle3(__pyx_cur_scope->__pyx_v_self, __pyx_kp_u_Loop__sock_recv, ((__pyx_t_6uvloop_4loop_method3_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_recv), Py_None, ((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_fut, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2459, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 2459, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_4);
+  __pyx_cur_scope->__pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2467
+ *             fut, sock, n)
+ * 
+ *         self._add_reader(sock, handle)             # <<<<<<<<<<<<<<
+ *         return await fut
+ * 
+ */
+  __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_add_reader(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2467, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2468
+ * 
+ *         self._add_reader(sock, handle)
+ *         return await fut             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_fut);
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 1;
+    return __pyx_r;
+    __pyx_L7_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2468, __pyx_L1_error)
+    __pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4);
+  } else {
+    __pyx_t_4 = NULL;
+    if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(0, 2468, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+  }
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2443
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_recv(self, sock, n):             # <<<<<<<<<<<<<<
+ *         """Receive data from the socket.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("sock_recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_88generator8(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2471
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_recv_into(self, sock, buf):             # <<<<<<<<<<<<<<
+ *         """Receive data from the socket.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_87sock_recv_into(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_86sock_recv_into[] = "Loop.sock_recv_into(self, sock, buf)\nReceive data from the socket.\n\n        The received data is written into *buf* (a writable buffer).\n        The return value is the number of bytes written.\n\n        This method is a coroutine.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_87sock_recv_into(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_sock = 0;
+  PyObject *__pyx_v_buf = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sock_recv_into (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sock,&__pyx_n_s_buf,0};
+    PyObject* values[2] = {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  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_sock)) != 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_buf)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("sock_recv_into", 1, 2, 2, 1); __PYX_ERR(0, 2471, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "sock_recv_into") < 0)) __PYX_ERR(0, 2471, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_sock = values[0];
+    __pyx_v_buf = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("sock_recv_into", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2471, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.sock_recv_into", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_86sock_recv_into(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_sock, __pyx_v_buf);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_86sock_recv_into(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_buf) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("sock_recv_into", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2471, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_sock = __pyx_v_sock;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+  __pyx_cur_scope->__pyx_v_buf = __pyx_v_buf;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_buf);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_buf);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_88generator8, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_sock_recv_into, __pyx_n_s_Loop_sock_recv_into, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2471, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.sock_recv_into", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_88generator8(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sock_recv_into", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L7_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2471, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2482
+ *             Handle handle
+ * 
+ *         if self._debug and sock.gettimeout() != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->_debug != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_gettimeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2482, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2482, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2482, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2482, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L5_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":2483
+ * 
+ *         if self._debug and sock.gettimeout() != 0:
+ *             raise ValueError("the socket must be non-blocking")             # <<<<<<<<<<<<<<
+ * 
+ *         fut = _SyncSocketReaderFuture(sock, self)
+ */
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2483, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(0, 2483, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2482
+ *             Handle handle
+ * 
+ *         if self._debug and sock.gettimeout() != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2485
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ *         fut = _SyncSocketReaderFuture(sock, self)             # <<<<<<<<<<<<<<
+ *         handle = new_MethodHandle3(
+ *             self,
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SyncSocketReaderFuture); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2485, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __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_cur_scope->__pyx_v_sock, ((PyObject *)__pyx_cur_scope->__pyx_v_self)};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2485, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_sock, ((PyObject *)__pyx_cur_scope->__pyx_v_self)};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2485, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+  } else
+  #endif
+  {
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2485, __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_cur_scope->__pyx_v_sock);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_cur_scope->__pyx_v_sock);
+    __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2485, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GIVEREF(__pyx_t_4);
+  __pyx_cur_scope->__pyx_v_fut = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2486
+ * 
+ *         fut = _SyncSocketReaderFuture(sock, self)
+ *         handle = new_MethodHandle3(             # <<<<<<<<<<<<<<
+ *             self,
+ *             "Loop._sock_recv_into",
+ */
+  __pyx_t_4 = __pyx_f_6uvloop_4loop_new_MethodHandle3(__pyx_cur_scope->__pyx_v_self, __pyx_kp_u_Loop__sock_recv_into, ((__pyx_t_6uvloop_4loop_method3_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_recv_into), Py_None, ((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_fut, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_buf); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2486, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 2486, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_4);
+  __pyx_cur_scope->__pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2494
+ *             fut, sock, buf)
+ * 
+ *         self._add_reader(sock, handle)             # <<<<<<<<<<<<<<
+ *         return await fut
+ * 
+ */
+  __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_add_reader(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2494, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2495
+ * 
+ *         self._add_reader(sock, handle)
+ *         return await fut             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_fut);
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 1;
+    return __pyx_r;
+    __pyx_L7_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2495, __pyx_L1_error)
+    __pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4);
+  } else {
+    __pyx_t_4 = NULL;
+    if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(0, 2495, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+  }
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2471
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_recv_into(self, sock, buf):             # <<<<<<<<<<<<<<
+ *         """Receive data from the socket.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("sock_recv_into", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_91generator9(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2498
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_sendall(self, sock, data):             # <<<<<<<<<<<<<<
+ *         """Send data to the socket.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_90sock_sendall(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_89sock_sendall[] = "Loop.sock_sendall(self, sock, data)\nSend data to the socket.\n\n        The socket must be connected to a remote socket. This method continues\n        to send data from data until either all data has been sent or an\n        error occurs. None is returned on success. On error, an exception is\n        raised, and there is no way to determine how much data, if any, was\n        successfully processed by the receiving end of the connection.\n\n        This method is a coroutine.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_90sock_sendall(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_sock = 0;
+  PyObject *__pyx_v_data = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sock_sendall (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sock,&__pyx_n_s_data,0};
+    PyObject* values[2] = {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  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_sock)) != 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_data)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("sock_sendall", 1, 2, 2, 1); __PYX_ERR(0, 2498, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "sock_sendall") < 0)) __PYX_ERR(0, 2498, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_sock = values[0];
+    __pyx_v_data = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("sock_sendall", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2498, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_89sock_sendall(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_sock, __pyx_v_data);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_89sock_sendall(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_data) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("sock_sendall", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_15_sock_sendall(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_15_sock_sendall, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2498, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_sock = __pyx_v_sock;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+  __pyx_cur_scope->__pyx_v_data = __pyx_v_data;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_data);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_data);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_91generator9, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_sock_sendall, __pyx_n_s_Loop_sock_sendall, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2498, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_91generator9(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall *)__pyx_generator->closure);
+  PyObject *__pyx_r = 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;
+  Py_ssize_t __pyx_t_9;
+  Py_ssize_t __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_t_13;
+  int __pyx_t_14;
+  char const *__pyx_t_15;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sock_sendall", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L20_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2498, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2513
+ *             ssize_t n
+ * 
+ *         if self._debug and sock.gettimeout() != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->_debug != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_gettimeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2513, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2513, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2513, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2513, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L5_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":2514
+ * 
+ *         if self._debug and sock.gettimeout() != 0:
+ *             raise ValueError("the socket must be non-blocking")             # <<<<<<<<<<<<<<
+ * 
+ *         if not data:
+ */
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2514, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(0, 2514, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2513
+ *             ssize_t n
+ * 
+ *         if self._debug and sock.gettimeout() != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2516
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ *         if not data:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_data); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2516, __pyx_L1_error)
+  __pyx_t_2 = ((!__pyx_t_1) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":2517
+ * 
+ *         if not data:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         socket_inc_io_ref(sock)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = NULL;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":2516
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ *         if not data:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2519
+ *             return
+ * 
+ *         socket_inc_io_ref(sock)             # <<<<<<<<<<<<<<
+ *         try:
+ *             try:
+ */
+  __pyx_t_4 = __pyx_f_6uvloop_4loop_socket_inc_io_ref(__pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2519, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2520
+ * 
+ *         socket_inc_io_ref(sock)
+ *         try:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 n = sock.send(data)
+ */
+  /*try:*/ {
+
+    /* "uvloop/loop.pyx":2521
+ *         socket_inc_io_ref(sock)
+ *         try:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 n = sock.send(data)
+ *             except (BlockingIOError, InterruptedError):
+ */
+    {
+      __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":2522
+ *         try:
+ *             try:
+ *                 n = sock.send(data)             # <<<<<<<<<<<<<<
+ *             except (BlockingIOError, InterruptedError):
+ *                 pass
+ */
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_send); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2522, __pyx_L11_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_5 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_3, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_cur_scope->__pyx_v_data) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_cur_scope->__pyx_v_data);
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2522, __pyx_L11_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __pyx_t_9 = PyInt_AsSsize_t(__pyx_t_4); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2522, __pyx_L11_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_cur_scope->__pyx_v_n = __pyx_t_9;
+
+        /* "uvloop/loop.pyx":2521
+ *         socket_inc_io_ref(sock)
+ *         try:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 n = sock.send(data)
+ *             except (BlockingIOError, InterruptedError):
+ */
+      }
+
+      /* "uvloop/loop.pyx":2526
+ *                 pass
+ *             else:
+ *                 if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                     # This can be a partial success, i.e. only part
+ *                     # of the data was sent
+ */
+      /*else:*/ {
+        __pyx_t_2 = (UVLOOP_DEBUG != 0);
+        if (__pyx_t_2) {
+
+          /* "uvloop/loop.pyx":2529
+ *                     # This can be a partial success, i.e. only part
+ *                     # of the data was sent
+ *                     self._sock_try_write_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *                 if n == len(data):
+ */
+          __pyx_cur_scope->__pyx_v_self->_sock_try_write_total = (__pyx_cur_scope->__pyx_v_self->_sock_try_write_total + 1);
+
+          /* "uvloop/loop.pyx":2526
+ *                 pass
+ *             else:
+ *                 if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                     # This can be a partial success, i.e. only part
+ *                     # of the data was sent
+ */
+        }
+
+        /* "uvloop/loop.pyx":2531
+ *                     self._sock_try_write_total += 1
+ * 
+ *                 if n == len(data):             # <<<<<<<<<<<<<<
+ *                     return
+ *                 if not isinstance(data, memoryview):
+ */
+        __pyx_t_10 = PyObject_Length(__pyx_cur_scope->__pyx_v_data); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2531, __pyx_L13_except_error)
+        __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_n == __pyx_t_10) != 0);
+        if (__pyx_t_2) {
+
+          /* "uvloop/loop.pyx":2532
+ * 
+ *                 if n == len(data):
+ *                     return             # <<<<<<<<<<<<<<
+ *                 if not isinstance(data, memoryview):
+ *                     data = memoryview(data)
+ */
+          __Pyx_XDECREF(__pyx_r);
+          __pyx_r = NULL;
+          goto __pyx_L14_except_return;
+
+          /* "uvloop/loop.pyx":2531
+ *                     self._sock_try_write_total += 1
+ * 
+ *                 if n == len(data):             # <<<<<<<<<<<<<<
+ *                     return
+ *                 if not isinstance(data, memoryview):
+ */
+        }
+
+        /* "uvloop/loop.pyx":2533
+ *                 if n == len(data):
+ *                     return
+ *                 if not isinstance(data, memoryview):             # <<<<<<<<<<<<<<
+ *                     data = memoryview(data)
+ *                 data = data[n:]
+ */
+        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2533, __pyx_L13_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_2 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_data, __pyx_t_4); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 2533, __pyx_L13_except_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/loop.pyx":2534
+ *                     return
+ *                 if not isinstance(data, memoryview):
+ *                     data = memoryview(data)             # <<<<<<<<<<<<<<
+ *                 data = data[n:]
+ * 
+ */
+          __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2534, __pyx_L13_except_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_data); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2534, __pyx_L13_except_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_data);
+          __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_data, __pyx_t_3);
+          __Pyx_GIVEREF(__pyx_t_3);
+          __pyx_t_3 = 0;
+
+          /* "uvloop/loop.pyx":2533
+ *                 if n == len(data):
+ *                     return
+ *                 if not isinstance(data, memoryview):             # <<<<<<<<<<<<<<
+ *                     data = memoryview(data)
+ *                 data = data[n:]
+ */
+        }
+
+        /* "uvloop/loop.pyx":2535
+ *                 if not isinstance(data, memoryview):
+ *                     data = memoryview(data)
+ *                 data = data[n:]             # <<<<<<<<<<<<<<
+ * 
+ *             fut = _SyncSocketWriterFuture(sock, self)
+ */
+        __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_cur_scope->__pyx_v_data, __pyx_cur_scope->__pyx_v_n, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2535, __pyx_L13_except_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_data);
+        __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_data, __pyx_t_3);
+        __Pyx_GIVEREF(__pyx_t_3);
+        __pyx_t_3 = 0;
+      }
+      __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;
+      goto __pyx_L16_try_end;
+      __pyx_L11_error:;
+      __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;
+
+      /* "uvloop/loop.pyx":2523
+ *             try:
+ *                 n = sock.send(data)
+ *             except (BlockingIOError, InterruptedError):             # <<<<<<<<<<<<<<
+ *                 pass
+ *             else:
+ */
+      __Pyx_ErrFetch(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
+      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_BlockingIOError); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2523, __pyx_L13_except_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_InterruptedError); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2523, __pyx_L13_except_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __pyx_t_13 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_3, __pyx_t_11) || __Pyx_PyErr_GivenExceptionMatches(__pyx_t_3, __pyx_t_12);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_ErrRestore(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+      __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0;
+      if (__pyx_t_13) {
+        __Pyx_ErrRestore(0,0,0);
+        goto __pyx_L12_exception_handled;
+      }
+      goto __pyx_L13_except_error;
+      __pyx_L13_except_error:;
+
+      /* "uvloop/loop.pyx":2521
+ *         socket_inc_io_ref(sock)
+ *         try:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 n = sock.send(data)
+ *             except (BlockingIOError, InterruptedError):
+ */
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      goto __pyx_L9_error;
+      __pyx_L14_except_return:;
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      goto __pyx_L8_return;
+      __pyx_L12_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      __pyx_L16_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":2537
+ *                 data = data[n:]
+ * 
+ *             fut = _SyncSocketWriterFuture(sock, self)             # <<<<<<<<<<<<<<
+ *             handle = new_MethodHandle3(
+ *                 self,
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_SyncSocketWriterFuture); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2537, __pyx_L9_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = NULL;
+    __pyx_t_13 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_13 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_cur_scope->__pyx_v_sock, ((PyObject *)__pyx_cur_scope->__pyx_v_self)};
+      __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2537, __pyx_L9_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_5);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_cur_scope->__pyx_v_sock, ((PyObject *)__pyx_cur_scope->__pyx_v_self)};
+      __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2537, __pyx_L9_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_5);
+    } else
+    #endif
+    {
+      __pyx_t_12 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2537, __pyx_L9_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      if (__pyx_t_3) {
+        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      }
+      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+      __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+      PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_13, __pyx_cur_scope->__pyx_v_sock);
+      __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+      __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+      PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_13, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
+      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_12, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2537, __pyx_L9_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GIVEREF(__pyx_t_5);
+    __pyx_cur_scope->__pyx_v_fut = __pyx_t_5;
+    __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":2538
+ * 
+ *             fut = _SyncSocketWriterFuture(sock, self)
+ *             handle = new_MethodHandle3(             # <<<<<<<<<<<<<<
+ *                 self,
+ *                 "Loop._sock_sendall",
+ */
+    __pyx_t_5 = __pyx_f_6uvloop_4loop_new_MethodHandle3(__pyx_cur_scope->__pyx_v_self, __pyx_kp_u_Loop__sock_sendall, ((__pyx_t_6uvloop_4loop_method3_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_sendall), Py_None, ((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_fut, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2538, __pyx_L9_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 2538, __pyx_L9_error)
+    __Pyx_GIVEREF(__pyx_t_5);
+    __pyx_cur_scope->__pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":2546
+ *                 fut, sock, data)
+ * 
+ *             self._add_writer(sock, handle)             # <<<<<<<<<<<<<<
+ *             return await fut
+ *         finally:
+ */
+    __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_add_writer(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2546, __pyx_L9_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":2547
+ * 
+ *             self._add_writer(sock, handle)
+ *             return await fut             # <<<<<<<<<<<<<<
+ *         finally:
+ *             socket_dec_io_ref(sock)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_fut);
+    __Pyx_XGOTREF(__pyx_r);
+    if (likely(__pyx_r)) {
+      __Pyx_XGIVEREF(__pyx_r);
+      __Pyx_RefNannyFinishContext();
+      __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+      /* return from generator, awaiting value */
+      __pyx_generator->resume_label = 1;
+      return __pyx_r;
+      __pyx_L20_resume_from_await:;
+      if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2547, __pyx_L9_error)
+      __pyx_t_5 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_5);
+    } else {
+      __pyx_t_5 = NULL;
+      if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_5) < 0) __PYX_ERR(0, 2547, __pyx_L9_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    }
+    __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    goto __pyx_L8_return;
+  }
+
+  /* "uvloop/loop.pyx":2549
+ *             return await fut
+ *         finally:
+ *             socket_dec_io_ref(sock)             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  /*finally:*/ {
+    __pyx_L9_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_assign
+      __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0)) __Pyx_ErrFetch(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_16);
+      __Pyx_XGOTREF(__pyx_t_17);
+      __Pyx_XGOTREF(__pyx_t_18);
+      __pyx_t_13 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
+      {
+        __pyx_t_5 = __pyx_f_6uvloop_4loop_socket_dec_io_ref(__pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2549, __pyx_L22_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_XGIVEREF(__pyx_t_18);
+        __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+      }
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ErrRestore(__pyx_t_8, __pyx_t_7, __pyx_t_6);
+      __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+      __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
+      goto __pyx_L1_error;
+      __pyx_L22_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_XGIVEREF(__pyx_t_18);
+        __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+      }
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L8_return: {
+      __Pyx_PyThreadState_assign
+      __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
+      __Pyx_XGOTREF(__pyx_t_18);
+      __Pyx_XGOTREF(__pyx_t_17);
+      __Pyx_XGOTREF(__pyx_t_16);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __pyx_t_19 = __pyx_r;
+      __pyx_r = 0;
+      __pyx_t_5 = __pyx_f_6uvloop_4loop_socket_dec_io_ref(__pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2549, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_r = __pyx_t_19;
+      __pyx_t_19 = 0;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      }
+      __Pyx_XGIVEREF(__pyx_t_18);
+      __Pyx_XGIVEREF(__pyx_t_17);
+      __Pyx_XGIVEREF(__pyx_t_16);
+      __Pyx_ErrRestore(__pyx_t_18, __pyx_t_17, __pyx_t_16);
+      __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0;
+      goto __pyx_L0;
+    }
+  }
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2498
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_sendall(self, sock, data):             # <<<<<<<<<<<<<<
+ *         """Send data to the socket.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_94generator10(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2552
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_accept(self, sock):             # <<<<<<<<<<<<<<
+ *         """Accept a connection.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_93sock_accept(PyObject *__pyx_v_self, PyObject *__pyx_v_sock); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_92sock_accept[] = "Loop.sock_accept(self, sock)\nAccept a connection.\n\n        The socket must be bound to an address and listening for connections.\n        The return value is a pair (conn, address) where conn is a new socket\n        object usable to send and receive data on the connection, and address\n        is the address bound to the socket on the other end of the connection.\n\n        This method is a coroutine.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_93sock_accept(PyObject *__pyx_v_self, PyObject *__pyx_v_sock) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sock_accept (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_92sock_accept(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_sock));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_92sock_accept(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("sock_accept", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_16_sock_accept(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_16_sock_accept, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2552, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_sock = __pyx_v_sock;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_94generator10, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_sock_accept, __pyx_n_s_Loop_sock_accept, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2552, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.sock_accept", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_94generator10(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sock_accept", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L7_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2552, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2565
+ *             Handle handle
+ * 
+ *         if self._debug and sock.gettimeout() != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->_debug != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_gettimeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2565, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L5_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":2566
+ * 
+ *         if self._debug and sock.gettimeout() != 0:
+ *             raise ValueError("the socket must be non-blocking")             # <<<<<<<<<<<<<<
+ * 
+ *         fut = _SyncSocketReaderFuture(sock, self)
+ */
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2566, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(0, 2566, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2565
+ *             Handle handle
+ * 
+ *         if self._debug and sock.gettimeout() != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2568
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ *         fut = _SyncSocketReaderFuture(sock, self)             # <<<<<<<<<<<<<<
+ *         handle = new_MethodHandle2(
+ *             self,
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SyncSocketReaderFuture); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2568, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __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_cur_scope->__pyx_v_sock, ((PyObject *)__pyx_cur_scope->__pyx_v_self)};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2568, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_sock, ((PyObject *)__pyx_cur_scope->__pyx_v_self)};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2568, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+  } else
+  #endif
+  {
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2568, __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_cur_scope->__pyx_v_sock);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_cur_scope->__pyx_v_sock);
+    __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2568, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GIVEREF(__pyx_t_4);
+  __pyx_cur_scope->__pyx_v_fut = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2569
+ * 
+ *         fut = _SyncSocketReaderFuture(sock, self)
+ *         handle = new_MethodHandle2(             # <<<<<<<<<<<<<<
+ *             self,
+ *             "Loop._sock_accept",
+ */
+  __pyx_t_4 = __pyx_f_6uvloop_4loop_new_MethodHandle2(__pyx_cur_scope->__pyx_v_self, __pyx_kp_u_Loop__sock_accept, ((__pyx_t_6uvloop_4loop_method2_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_accept), Py_None, ((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_fut, __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2569, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 2569, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_4);
+  __pyx_cur_scope->__pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2577
+ *             fut, sock)
+ * 
+ *         self._add_reader(sock, handle)             # <<<<<<<<<<<<<<
+ *         return await fut
+ * 
+ */
+  __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_add_reader(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2577, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2578
+ * 
+ *         self._add_reader(sock, handle)
+ *         return await fut             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_fut);
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 1;
+    return __pyx_r;
+    __pyx_L7_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2578, __pyx_L1_error)
+    __pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4);
+  } else {
+    __pyx_t_4 = NULL;
+    if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(0, 2578, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+  }
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2552
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_accept(self, sock):             # <<<<<<<<<<<<<<
+ *         """Accept a connection.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("sock_accept", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_97generator11(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2581
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_connect(self, sock, address):             # <<<<<<<<<<<<<<
+ *         """Connect to a remote socket at address.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_96sock_connect(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_95sock_connect[] = "Loop.sock_connect(self, sock, address)\nConnect to a remote socket at address.\n\n        This method is a coroutine.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_96sock_connect(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_sock = 0;
+  PyObject *__pyx_v_address = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sock_connect (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sock,&__pyx_n_s_address,0};
+    PyObject* values[2] = {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  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_sock)) != 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_address)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("sock_connect", 1, 2, 2, 1); __PYX_ERR(0, 2581, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "sock_connect") < 0)) __PYX_ERR(0, 2581, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_sock = values[0];
+    __pyx_v_address = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("sock_connect", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2581, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.sock_connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_95sock_connect(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_sock, __pyx_v_address);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_95sock_connect(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_address) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("sock_connect", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_17_sock_connect(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_17_sock_connect, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2581, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_sock = __pyx_v_sock;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+  __pyx_cur_scope->__pyx_v_address = __pyx_v_address;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_address);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_address);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_97generator11, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_sock_connect, __pyx_n_s_Loop_sock_connect, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2581, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.sock_connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_97generator11(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect *)__pyx_generator->closure);
+  PyObject *__pyx_r = 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;
+  PyObject *(*__pyx_t_10)(PyObject *);
+  int __pyx_t_11;
+  int __pyx_t_12;
+  char const *__pyx_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sock_connect", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L11_resume_from_await;
+    case 2: goto __pyx_L15_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2581, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2586
+ *         This method is a coroutine.
+ *         """
+ *         if self._debug and sock.gettimeout() != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->_debug != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_gettimeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2586, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2586, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2586, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2586, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L5_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":2587
+ *         """
+ *         if self._debug and sock.gettimeout() != 0:
+ *             raise ValueError("the socket must be non-blocking")             # <<<<<<<<<<<<<<
+ * 
+ *         socket_inc_io_ref(sock)
+ */
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2587, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(0, 2587, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2586
+ *         This method is a coroutine.
+ *         """
+ *         if self._debug and sock.gettimeout() != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2589
+ *             raise ValueError("the socket must be non-blocking")
+ * 
+ *         socket_inc_io_ref(sock)             # <<<<<<<<<<<<<<
+ *         try:
+ *             if sock.family == uv.AF_UNIX:
+ */
+  __pyx_t_4 = __pyx_f_6uvloop_4loop_socket_inc_io_ref(__pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2589, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2590
+ * 
+ *         socket_inc_io_ref(sock)
+ *         try:             # <<<<<<<<<<<<<<
+ *             if sock.family == uv.AF_UNIX:
+ *                 fut = self._sock_connect(sock, address)
+ */
+  /*try:*/ {
+
+    /* "uvloop/loop.pyx":2591
+ *         socket_inc_io_ref(sock)
+ *         try:
+ *             if sock.family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *                 fut = self._sock_connect(sock, address)
+ *             else:
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2591, __pyx_L8_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2591, __pyx_L8_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2591, __pyx_L8_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2591, __pyx_L8_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (__pyx_t_1) {
+
+      /* "uvloop/loop.pyx":2592
+ *         try:
+ *             if sock.family == uv.AF_UNIX:
+ *                 fut = self._sock_connect(sock, address)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 addrs = await self.getaddrinfo(
+ */
+      __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_connect(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_address); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2592, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_5);
+      __pyx_cur_scope->__pyx_v_fut = __pyx_t_5;
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":2591
+ *         socket_inc_io_ref(sock)
+ *         try:
+ *             if sock.family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *                 fut = self._sock_connect(sock, address)
+ *             else:
+ */
+      goto __pyx_L10;
+    }
+
+    /* "uvloop/loop.pyx":2594
+ *                 fut = self._sock_connect(sock, address)
+ *             else:
+ *                 addrs = await self.getaddrinfo(             # <<<<<<<<<<<<<<
+ *                     *address[:2], family=sock.family)
+ * 
+ */
+    /*else*/ {
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_getaddrinfo); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2594, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_5);
+
+      /* "uvloop/loop.pyx":2595
+ *             else:
+ *                 addrs = await self.getaddrinfo(
+ *                     *address[:2], family=sock.family)             # <<<<<<<<<<<<<<
+ * 
+ *                 _, _, _, _, address = addrs[0]
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_cur_scope->__pyx_v_address, 0, 2, NULL, NULL, &__pyx_slice__73, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2595, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_3);
+
+      /* "uvloop/loop.pyx":2594
+ *                 fut = self._sock_connect(sock, address)
+ *             else:
+ *                 addrs = await self.getaddrinfo(             # <<<<<<<<<<<<<<
+ *                     *address[:2], family=sock.family)
+ * 
+ */
+      __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2594, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":2595
+ *             else:
+ *                 addrs = await self.getaddrinfo(
+ *                     *address[:2], family=sock.family)             # <<<<<<<<<<<<<<
+ * 
+ *                 _, _, _, _, address = addrs[0]
+ */
+      __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2595, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2595, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_family, __pyx_t_6) < 0) __PYX_ERR(0, 2595, __pyx_L8_error)
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/loop.pyx":2594
+ *                 fut = self._sock_connect(sock, address)
+ *             else:
+ *                 addrs = await self.getaddrinfo(             # <<<<<<<<<<<<<<
+ *                     *address[:2], family=sock.family)
+ * 
+ */
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2594, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __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_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_6);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XGOTREF(__pyx_r);
+      if (likely(__pyx_r)) {
+        __Pyx_XGIVEREF(__pyx_r);
+        __Pyx_RefNannyFinishContext();
+        __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+        /* return from generator, awaiting value */
+        __pyx_generator->resume_label = 1;
+        return __pyx_r;
+        __pyx_L11_resume_from_await:;
+        if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2594, __pyx_L8_error)
+        __pyx_t_6 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_6);
+      } else {
+        __pyx_t_6 = NULL;
+        if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_6) < 0) __PYX_ERR(0, 2594, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_6);
+      }
+      __Pyx_GIVEREF(__pyx_t_6);
+      __pyx_cur_scope->__pyx_v_addrs = __pyx_t_6;
+      __pyx_t_6 = 0;
+
+      /* "uvloop/loop.pyx":2597
+ *                     *address[:2], family=sock.family)
+ * 
+ *                 _, _, _, _, address = addrs[0]             # <<<<<<<<<<<<<<
+ *                 fut = self._sock_connect(sock, address)
+ *             if fut is not None:
+ */
+      __pyx_t_6 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_addrs, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2597, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) {
+        PyObject* sequence = __pyx_t_6;
+        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+        if (unlikely(size != 5)) {
+          if (size > 5) __Pyx_RaiseTooManyValuesError(5);
+          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+          __PYX_ERR(0, 2597, __pyx_L8_error)
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        if (likely(PyTuple_CheckExact(sequence))) {
+          __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
+          __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+          __pyx_t_5 = PyTuple_GET_ITEM(sequence, 2); 
+          __pyx_t_7 = PyTuple_GET_ITEM(sequence, 3); 
+          __pyx_t_8 = PyTuple_GET_ITEM(sequence, 4); 
+        } else {
+          __pyx_t_3 = PyList_GET_ITEM(sequence, 0); 
+          __pyx_t_4 = PyList_GET_ITEM(sequence, 1); 
+          __pyx_t_5 = PyList_GET_ITEM(sequence, 2); 
+          __pyx_t_7 = PyList_GET_ITEM(sequence, 3); 
+          __pyx_t_8 = PyList_GET_ITEM(sequence, 4); 
+        }
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_8);
+        #else
+        {
+          Py_ssize_t i;
+          PyObject** temps[5] = {&__pyx_t_3,&__pyx_t_4,&__pyx_t_5,&__pyx_t_7,&__pyx_t_8};
+          for (i=0; i < 5; i++) {
+            PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 2597, __pyx_L8_error)
+            __Pyx_GOTREF(item);
+            *(temps[i]) = item;
+          }
+        }
+        #endif
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      } else {
+        Py_ssize_t index = -1;
+        PyObject** temps[5] = {&__pyx_t_3,&__pyx_t_4,&__pyx_t_5,&__pyx_t_7,&__pyx_t_8};
+        __pyx_t_9 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2597, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext;
+        for (index=0; index < 5; index++) {
+          PyObject* item = __pyx_t_10(__pyx_t_9); if (unlikely(!item)) goto __pyx_L12_unpacking_failed;
+          __Pyx_GOTREF(item);
+          *(temps[index]) = item;
+        }
+        if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 5) < 0) __PYX_ERR(0, 2597, __pyx_L8_error)
+        __pyx_t_10 = NULL;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        goto __pyx_L13_unpacking_done;
+        __pyx_L12_unpacking_failed:;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __pyx_t_10 = NULL;
+        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+        __PYX_ERR(0, 2597, __pyx_L8_error)
+        __pyx_L13_unpacking_done:;
+      }
+      __Pyx_GIVEREF(__pyx_t_3);
+      __pyx_cur_scope->__pyx_v__ = __pyx_t_3;
+      __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v__);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v__, __pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_4);
+      __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v__);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v__, __pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_5);
+      __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v__);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v__, __pyx_t_7);
+      __Pyx_GIVEREF(__pyx_t_7);
+      __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_address);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_address, __pyx_t_8);
+      __Pyx_GIVEREF(__pyx_t_8);
+      __pyx_t_8 = 0;
+
+      /* "uvloop/loop.pyx":2598
+ * 
+ *                 _, _, _, _, address = addrs[0]
+ *                 fut = self._sock_connect(sock, address)             # <<<<<<<<<<<<<<
+ *             if fut is not None:
+ *                 await fut
+ */
+      __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_connect(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_address); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2598, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_6);
+      __pyx_cur_scope->__pyx_v_fut = __pyx_t_6;
+      __pyx_t_6 = 0;
+    }
+    __pyx_L10:;
+
+    /* "uvloop/loop.pyx":2599
+ *                 _, _, _, _, address = addrs[0]
+ *                 fut = self._sock_connect(sock, address)
+ *             if fut is not None:             # <<<<<<<<<<<<<<
+ *                 await fut
+ *         finally:
+ */
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_fut != Py_None);
+    __pyx_t_2 = (__pyx_t_1 != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/loop.pyx":2600
+ *                 fut = self._sock_connect(sock, address)
+ *             if fut is not None:
+ *                 await fut             # <<<<<<<<<<<<<<
+ *         finally:
+ *             socket_dec_io_ref(sock)
+ */
+      __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_fut);
+      __Pyx_XGOTREF(__pyx_r);
+      if (likely(__pyx_r)) {
+        __Pyx_XGIVEREF(__pyx_r);
+        __Pyx_RefNannyFinishContext();
+        __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+        /* return from generator, awaiting value */
+        __pyx_generator->resume_label = 2;
+        return __pyx_r;
+        __pyx_L15_resume_from_await:;
+        if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2600, __pyx_L8_error)
+      } else {
+        PyObject* exc_type = __Pyx_PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+          else __PYX_ERR(0, 2600, __pyx_L8_error)
+        }
+      }
+
+      /* "uvloop/loop.pyx":2599
+ *                 _, _, _, _, address = addrs[0]
+ *                 fut = self._sock_connect(sock, address)
+ *             if fut is not None:             # <<<<<<<<<<<<<<
+ *                 await fut
+ *         finally:
+ */
+    }
+  }
+
+  /* "uvloop/loop.pyx":2602
+ *                 await fut
+ *         finally:
+ *             socket_dec_io_ref(sock)             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_6 = __pyx_f_6uvloop_4loop_socket_dec_io_ref(__pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2602, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L9;
+    }
+    __pyx_L8_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_assign
+      __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 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;
+      __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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __Pyx_XGOTREF(__pyx_t_15);
+      __Pyx_XGOTREF(__pyx_t_16);
+      __Pyx_XGOTREF(__pyx_t_17);
+      __Pyx_XGOTREF(__pyx_t_18);
+      __Pyx_XGOTREF(__pyx_t_19);
+      __pyx_t_11 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename;
+      {
+        __pyx_t_6 = __pyx_f_6uvloop_4loop_socket_dec_io_ref(__pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2602, __pyx_L17_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_XGIVEREF(__pyx_t_18);
+        __Pyx_XGIVEREF(__pyx_t_19);
+        __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+      }
+      __Pyx_XGIVEREF(__pyx_t_14);
+      __Pyx_XGIVEREF(__pyx_t_15);
+      __Pyx_XGIVEREF(__pyx_t_16);
+      __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+      __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+      __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13;
+      goto __pyx_L1_error;
+      __pyx_L17_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_XGIVEREF(__pyx_t_18);
+        __Pyx_XGIVEREF(__pyx_t_19);
+        __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+      }
+      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+      __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+      __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L9:;
+  }
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2581
+ * 
+ *     @cython.iterable_coroutine
+ *     async def sock_connect(self, sock, address):             # <<<<<<<<<<<<<<
+ *         """Connect to a remote socket at address.
+ * 
+ */
+
+  /* function exit code */
+  PyErr_SetNone(PyExc_StopIteration);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("sock_connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_100generator12(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2605
+ * 
+ *     @cython.iterable_coroutine
+ *     async def connect_accepted_socket(self, protocol_factory, sock, *,             # <<<<<<<<<<<<<<
+ *                                       ssl=None,
+ *                                       ssl_handshake_timeout=None,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_99connect_accepted_socket(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_98connect_accepted_socket[] = "Loop.connect_accepted_socket(self, protocol_factory, sock, *, ssl=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None)\nHandle an accepted connection.\n\n        This is used by servers that accept connections outside of\n        asyncio but that use asyncio to handle connections.\n\n        This method is a coroutine.  When completed, the coroutine\n        returns a (transport, protocol) pair.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_99connect_accepted_socket(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_protocol_factory = 0;
+  PyObject *__pyx_v_sock = 0;
+  PyObject *__pyx_v_ssl = 0;
+  PyObject *__pyx_v_ssl_handshake_timeout = 0;
+  PyObject *__pyx_v_ssl_shutdown_timeout = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connect_accepted_socket (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_sock,&__pyx_n_s_ssl,&__pyx_n_s_ssl_handshake_timeout,&__pyx_n_s_ssl_shutdown_timeout,0};
+    PyObject* values[5] = {0,0,0,0,0};
+
+    /* "uvloop/loop.pyx":2606
+ *     @cython.iterable_coroutine
+ *     async def connect_accepted_socket(self, protocol_factory, sock, *,
+ *                                       ssl=None,             # <<<<<<<<<<<<<<
+ *                                       ssl_handshake_timeout=None,
+ *                                       ssl_shutdown_timeout=None):
+ */
+    values[2] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2607
+ *     async def connect_accepted_socket(self, protocol_factory, sock, *,
+ *                                       ssl=None,
+ *                                       ssl_handshake_timeout=None,             # <<<<<<<<<<<<<<
+ *                                       ssl_shutdown_timeout=None):
+ *         """Handle an accepted connection.
+ */
+    values[3] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2608
+ *                                       ssl=None,
+ *                                       ssl_handshake_timeout=None,
+ *                                       ssl_shutdown_timeout=None):             # <<<<<<<<<<<<<<
+ *         """Handle an accepted connection.
+ * 
+ */
+    values[4] = ((PyObject *)Py_None);
+    if (unlikely(__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);
+        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_protocol_factory)) != 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_sock)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("connect_accepted_socket", 1, 2, 2, 1); __PYX_ERR(0, 2605, __pyx_L3_error)
+        }
+      }
+      if (kw_args > 0 && likely(kw_args <= 3)) {
+        Py_ssize_t index;
+        for (index = 2; index < 5 && kw_args > 0; index++) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+          if (value) { values[index] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "connect_accepted_socket") < 0)) __PYX_ERR(0, 2605, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_protocol_factory = values[0];
+    __pyx_v_sock = values[1];
+    __pyx_v_ssl = values[2];
+    __pyx_v_ssl_handshake_timeout = values[3];
+    __pyx_v_ssl_shutdown_timeout = values[4];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("connect_accepted_socket", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2605, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.connect_accepted_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_98connect_accepted_socket(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_sock, __pyx_v_ssl, __pyx_v_ssl_handshake_timeout, __pyx_v_ssl_shutdown_timeout);
+
+  /* "uvloop/loop.pyx":2605
+ * 
+ *     @cython.iterable_coroutine
+ *     async def connect_accepted_socket(self, protocol_factory, sock, *,             # <<<<<<<<<<<<<<
+ *                                       ssl=None,
+ *                                       ssl_handshake_timeout=None,
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_98connect_accepted_socket(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_sock, PyObject *__pyx_v_ssl, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("connect_accepted_socket", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2605, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_protocol_factory = __pyx_v_protocol_factory;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+  __pyx_cur_scope->__pyx_v_ssl = __pyx_v_ssl;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
+  __pyx_cur_scope->__pyx_v_ssl_handshake_timeout = __pyx_v_ssl_handshake_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_handshake_timeout);
+  __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout = __pyx_v_ssl_shutdown_timeout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_100generator12, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_connect_accepted_socket, __pyx_n_s_Loop_connect_accepted_socket, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2605, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.connect_accepted_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_100generator12(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  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_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connect_accepted_socket", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L21_resume_from_await;
+    case 2: goto __pyx_L32_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2605, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2619
+ * 
+ *         cdef:
+ *             UVStream transport = None             # <<<<<<<<<<<<<<
+ * 
+ *         if ssl is not None:
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __pyx_cur_scope->__pyx_v_transport = ((struct __pyx_obj_6uvloop_4loop_UVStream *)Py_None);
+
+  /* "uvloop/loop.pyx":2621
+ *             UVStream transport = None
+ * 
+ *         if ssl is not None:             # <<<<<<<<<<<<<<
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ */
+  __pyx_t_1 = (__pyx_cur_scope->__pyx_v_ssl != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":2622
+ * 
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):             # <<<<<<<<<<<<<<
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ */
+    __pyx_t_3 = __pyx_v_6uvloop_4loop_ssl_SSLContext;
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_2 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_ssl, __pyx_t_3); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 2622, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":2623
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError('ssl argument must be an SSLContext or None')             # <<<<<<<<<<<<<<
+ *         else:
+ *             if ssl_handshake_timeout is not None:
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2623, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 2623, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2622
+ * 
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):             # <<<<<<<<<<<<<<
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ */
+    }
+
+    /* "uvloop/loop.pyx":2621
+ *             UVStream transport = None
+ * 
+ *         if ssl is not None:             # <<<<<<<<<<<<<<
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/loop.pyx":2625
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+  /*else*/ {
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_ssl_handshake_timeout != Py_None);
+    __pyx_t_2 = (__pyx_t_1 != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":2626
+ *         else:
+ *             if ssl_handshake_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2626, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 2626, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2625
+ *                 raise TypeError('ssl argument must be an SSLContext or None')
+ *         else:
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+    }
+
+    /* "uvloop/loop.pyx":2628
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    __pyx_t_2 = (__pyx_cur_scope->__pyx_v_ssl_shutdown_timeout != Py_None);
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":2629
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2629, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 2629, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2628
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    }
+  }
+  __pyx_L4:;
+
+  /* "uvloop/loop.pyx":2632
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ *         if not _is_sock_stream(sock.type):             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'A Stream Socket was expected, got {!r}'.format(sock))
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2632, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __pyx_f_6uvloop_4loop__is_sock_stream(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2632, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2632, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = ((!__pyx_t_1) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/loop.pyx":2634
+ *         if not _is_sock_stream(sock.type):
+ *             raise ValueError(
+ *                 'A Stream Socket was expected, got {!r}'.format(sock))             # <<<<<<<<<<<<<<
+ * 
+ *         app_protocol = protocol_factory()
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_Stream_Socket_was_expected_got, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2634, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_cur_scope->__pyx_v_sock) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_cur_scope->__pyx_v_sock);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2634, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":2633
+ * 
+ *         if not _is_sock_stream(sock.type):
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'A Stream Socket was expected, got {!r}'.format(sock))
+ * 
+ */
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2633, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(0, 2633, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2632
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ *         if not _is_sock_stream(sock.type):             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'A Stream Socket was expected, got {!r}'.format(sock))
+ */
+  }
+
+  /* "uvloop/loop.pyx":2636
+ *                 'A Stream Socket was expected, got {!r}'.format(sock))
+ * 
+ *         app_protocol = protocol_factory()             # <<<<<<<<<<<<<<
+ *         waiter = self._new_future()
+ *         transport_waiter = None
+ */
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_t_4 = __pyx_cur_scope->__pyx_v_protocol_factory; __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2636, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_3);
+  __pyx_cur_scope->__pyx_v_app_protocol = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":2637
+ * 
+ *         app_protocol = protocol_factory()
+ *         waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *         transport_waiter = None
+ *         context = Context_CopyCurrent()
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2637, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_3);
+  __pyx_cur_scope->__pyx_v_waiter = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":2638
+ *         app_protocol = protocol_factory()
+ *         waiter = self._new_future()
+ *         transport_waiter = None             # <<<<<<<<<<<<<<
+ *         context = Context_CopyCurrent()
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __pyx_cur_scope->__pyx_v_transport_waiter = Py_None;
+
+  /* "uvloop/loop.pyx":2639
+ *         waiter = self._new_future()
+ *         transport_waiter = None
+ *         context = Context_CopyCurrent()             # <<<<<<<<<<<<<<
+ * 
+ *         if ssl is None:
+ */
+  __pyx_t_3 = Context_CopyCurrent(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2639, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_3);
+  __pyx_cur_scope->__pyx_v_context = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":2641
+ *         context = Context_CopyCurrent()
+ * 
+ *         if ssl is None:             # <<<<<<<<<<<<<<
+ *             protocol = app_protocol
+ *             transport_waiter = waiter
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_ssl == Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":2642
+ * 
+ *         if ssl is None:
+ *             protocol = app_protocol             # <<<<<<<<<<<<<<
+ *             transport_waiter = waiter
+ *         else:
+ */
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    __pyx_cur_scope->__pyx_v_protocol = __pyx_cur_scope->__pyx_v_app_protocol;
+
+    /* "uvloop/loop.pyx":2643
+ *         if ssl is None:
+ *             protocol = app_protocol
+ *             transport_waiter = waiter             # <<<<<<<<<<<<<<
+ *         else:
+ *             protocol = SSLProtocol(
+ */
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_waiter);
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_transport_waiter);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_transport_waiter, __pyx_cur_scope->__pyx_v_waiter);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_waiter);
+
+    /* "uvloop/loop.pyx":2641
+ *         context = Context_CopyCurrent()
+ * 
+ *         if ssl is None:             # <<<<<<<<<<<<<<
+ *             protocol = app_protocol
+ *             transport_waiter = waiter
+ */
+    goto __pyx_L9;
+  }
+
+  /* "uvloop/loop.pyx":2645
+ *             transport_waiter = waiter
+ *         else:
+ *             protocol = SSLProtocol(             # <<<<<<<<<<<<<<
+ *                 self, app_protocol, ssl, waiter,
+ *                 server_side=True,
+ */
+  /*else*/ {
+
+    /* "uvloop/loop.pyx":2646
+ *         else:
+ *             protocol = SSLProtocol(
+ *                 self, app_protocol, ssl, waiter,             # <<<<<<<<<<<<<<
+ *                 server_side=True,
+ *                 server_hostname=None,
+ */
+    __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2645, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
+    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_v_app_protocol);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
+    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_cur_scope->__pyx_v_ssl);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_waiter);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_waiter);
+    PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_cur_scope->__pyx_v_waiter);
+
+    /* "uvloop/loop.pyx":2647
+ *             protocol = SSLProtocol(
+ *                 self, app_protocol, ssl, waiter,
+ *                 server_side=True,             # <<<<<<<<<<<<<<
+ *                 server_hostname=None,
+ *                 ssl_handshake_timeout=ssl_handshake_timeout,
+ */
+    __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2647, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_server_side, Py_True) < 0) __PYX_ERR(0, 2647, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2648
+ *                 self, app_protocol, ssl, waiter,
+ *                 server_side=True,
+ *                 server_hostname=None,             # <<<<<<<<<<<<<<
+ *                 ssl_handshake_timeout=ssl_handshake_timeout,
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)
+ */
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_server_hostname, Py_None) < 0) __PYX_ERR(0, 2647, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2649
+ *                 server_side=True,
+ *                 server_hostname=None,
+ *                 ssl_handshake_timeout=ssl_handshake_timeout,             # <<<<<<<<<<<<<<
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)
+ *             transport_waiter = None
+ */
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_ssl_handshake_timeout, __pyx_cur_scope->__pyx_v_ssl_handshake_timeout) < 0) __PYX_ERR(0, 2647, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2650
+ *                 server_hostname=None,
+ *                 ssl_handshake_timeout=ssl_handshake_timeout,
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)             # <<<<<<<<<<<<<<
+ *             transport_waiter = None
+ * 
+ */
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_ssl_shutdown_timeout, __pyx_cur_scope->__pyx_v_ssl_shutdown_timeout) < 0) __PYX_ERR(0, 2647, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2645
+ *             transport_waiter = waiter
+ *         else:
+ *             protocol = SSLProtocol(             # <<<<<<<<<<<<<<
+ *                 self, app_protocol, ssl, waiter,
+ *                 server_side=True,
+ */
+    __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_SSLProtocol), __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2645, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GIVEREF(__pyx_t_5);
+    __pyx_cur_scope->__pyx_v_protocol = __pyx_t_5;
+    __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":2651
+ *                 ssl_handshake_timeout=ssl_handshake_timeout,
+ *                 ssl_shutdown_timeout=ssl_shutdown_timeout)
+ *             transport_waiter = None             # <<<<<<<<<<<<<<
+ * 
+ *         if sock.family == uv.AF_UNIX:
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_transport_waiter);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_transport_waiter, Py_None);
+    __Pyx_GIVEREF(Py_None);
+  }
+  __pyx_L9:;
+
+  /* "uvloop/loop.pyx":2653
+ *             transport_waiter = None
+ * 
+ *         if sock.family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *             transport = <UVStream>UnixTransport.new(
+ *                 self, protocol, None, transport_waiter, context)
+ */
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2653, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2653, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2653, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2653, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":2654
+ * 
+ *         if sock.family == uv.AF_UNIX:
+ *             transport = <UVStream>UnixTransport.new(             # <<<<<<<<<<<<<<
+ *                 self, protocol, None, transport_waiter, context)
+ *         elif sock.family in (uv.AF_INET, uv.AF_INET6):
+ */
+    __pyx_t_3 = ((PyObject *)__pyx_f_6uvloop_4loop_13UnixTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_transport_waiter, __pyx_cur_scope->__pyx_v_context)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2654, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __pyx_t_3;
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_transport));
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_transport, ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_4));
+    __Pyx_GIVEREF(__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":2653
+ *             transport_waiter = None
+ * 
+ *         if sock.family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *             transport = <UVStream>UnixTransport.new(
+ *                 self, protocol, None, transport_waiter, context)
+ */
+    goto __pyx_L10;
+  }
+
+  /* "uvloop/loop.pyx":2656
+ *             transport = <UVStream>UnixTransport.new(
+ *                 self, protocol, None, transport_waiter, context)
+ *         elif sock.family in (uv.AF_INET, uv.AF_INET6):             # <<<<<<<<<<<<<<
+ *             transport = <UVStream>TCPTransport.new(
+ *                 self, protocol, None, transport_waiter, context)
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2656, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyInt_From_int(AF_INET); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2656, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2656, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2656, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L11_bool_binop_done;
+  }
+  __pyx_t_5 = __Pyx_PyInt_From_int(AF_INET6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2656, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2656, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2656, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L11_bool_binop_done:;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":2657
+ *                 self, protocol, None, transport_waiter, context)
+ *         elif sock.family in (uv.AF_INET, uv.AF_INET6):
+ *             transport = <UVStream>TCPTransport.new(             # <<<<<<<<<<<<<<
+ *                 self, protocol, None, transport_waiter, context)
+ * 
+ */
+    __pyx_t_4 = ((PyObject *)__pyx_f_6uvloop_4loop_12TCPTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_transport_waiter, __pyx_cur_scope->__pyx_v_context)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2657, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = __pyx_t_4;
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_transport));
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_transport, ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_3));
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":2656
+ *             transport = <UVStream>UnixTransport.new(
+ *                 self, protocol, None, transport_waiter, context)
+ *         elif sock.family in (uv.AF_INET, uv.AF_INET6):             # <<<<<<<<<<<<<<
+ *             transport = <UVStream>TCPTransport.new(
+ *                 self, protocol, None, transport_waiter, context)
+ */
+  }
+  __pyx_L10:;
+
+  /* "uvloop/loop.pyx":2660
+ *                 self, protocol, None, transport_waiter, context)
+ * 
+ *         if transport is None:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
+ */
+  __pyx_t_2 = (((PyObject *)__pyx_cur_scope->__pyx_v_transport) == Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":2661
+ * 
+ *         if transport is None:
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
+ * 
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2661, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(0, 2661, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2660
+ *                 self, protocol, None, transport_waiter, context)
+ * 
+ *         if transport is None:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
+ */
+  }
+
+  /* "uvloop/loop.pyx":2664
+ *                 'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
+ * 
+ *         transport._open(sock.fileno())             # <<<<<<<<<<<<<<
+ *         transport._init_protocol()
+ *         transport._attach_fileobj(sock)
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2664, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2664, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2664, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_cur_scope->__pyx_v_transport->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_transport), __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2664, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":2665
+ * 
+ *         transport._open(sock.fileno())
+ *         transport._init_protocol()             # <<<<<<<<<<<<<<
+ *         transport._attach_fileobj(sock)
+ * 
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_cur_scope->__pyx_v_transport->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_transport)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2665, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":2666
+ *         transport._open(sock.fileno())
+ *         transport._init_protocol()
+ *         transport._attach_fileobj(sock)             # <<<<<<<<<<<<<<
+ * 
+ *         if ssl:
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_cur_scope->__pyx_v_transport->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_transport), __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2666, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":2668
+ *         transport._attach_fileobj(sock)
+ * 
+ *         if ssl:             # <<<<<<<<<<<<<<
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_ssl); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2668, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":2669
+ * 
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(context)             # <<<<<<<<<<<<<<
+ *             try:
+ *                 await waiter
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_protocol, __pyx_n_s_get_app_transport); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2669, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_cur_scope->__pyx_v_context) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_context);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2669, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_cur_scope->__pyx_v_app_transport = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":2670
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+    {
+      __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":2671
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:
+ *                 await waiter             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+        __Pyx_XGOTREF(__pyx_r);
+        if (likely(__pyx_r)) {
+          __Pyx_XGIVEREF(__pyx_t_7);
+          __pyx_cur_scope->__pyx_t_0 = __pyx_t_7;
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __pyx_cur_scope->__pyx_t_1 = __pyx_t_8;
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __pyx_cur_scope->__pyx_t_2 = __pyx_t_9;
+          __Pyx_XGIVEREF(__pyx_r);
+          __Pyx_RefNannyFinishContext();
+          __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+          /* return from generator, awaiting value */
+          __pyx_generator->resume_label = 1;
+          return __pyx_r;
+          __pyx_L21_resume_from_await:;
+          __pyx_t_7 = __pyx_cur_scope->__pyx_t_0;
+          __pyx_cur_scope->__pyx_t_0 = 0;
+          __Pyx_XGOTREF(__pyx_t_7);
+          __pyx_t_8 = __pyx_cur_scope->__pyx_t_1;
+          __pyx_cur_scope->__pyx_t_1 = 0;
+          __Pyx_XGOTREF(__pyx_t_8);
+          __pyx_t_9 = __pyx_cur_scope->__pyx_t_2;
+          __pyx_cur_scope->__pyx_t_2 = 0;
+          __Pyx_XGOTREF(__pyx_t_9);
+          if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2671, __pyx_L15_error)
+        } else {
+          PyObject* exc_type = __Pyx_PyErr_Occurred();
+          if (exc_type) {
+            if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+            else __PYX_ERR(0, 2671, __pyx_L15_error)
+          }
+        }
+
+        /* "uvloop/loop.pyx":2670
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      }
+      __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;
+      goto __pyx_L20_try_end;
+      __pyx_L15_error:;
+      __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;
+
+      /* "uvloop/loop.pyx":2672
+ *             try:
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException:
+ */
+      __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_6) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.connect_accepted_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(0, 2672, __pyx_L17_except_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_5);
+
+        /* "uvloop/loop.pyx":2673
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException:
+ *                 app_transport.close()
+ */
+        __Pyx_GIVEREF(__pyx_t_3);
+        __Pyx_GIVEREF(__pyx_t_4);
+        __Pyx_XGIVEREF(__pyx_t_5);
+        __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+        __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; 
+        __PYX_ERR(0, 2673, __pyx_L17_except_error)
+      }
+
+      /* "uvloop/loop.pyx":2674
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException:             # <<<<<<<<<<<<<<
+ *                 app_transport.close()
+ *                 raise
+ */
+      __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_6) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.connect_accepted_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3) < 0) __PYX_ERR(0, 2674, __pyx_L17_except_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_3);
+
+        /* "uvloop/loop.pyx":2675
+ *                 raise
+ *             except BaseException:
+ *                 app_transport.close()             # <<<<<<<<<<<<<<
+ *                 raise
+ *             return app_transport, protocol
+ */
+        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_app_transport, __pyx_n_s_close); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2675, __pyx_L17_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __pyx_t_12 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+          __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+          if (likely(__pyx_t_12)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+            __Pyx_INCREF(__pyx_t_12);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_11, function);
+          }
+        }
+        __pyx_t_10 = (__pyx_t_12) ? __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_12) : __Pyx_PyObject_CallNoArg(__pyx_t_11);
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2675, __pyx_L17_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+        /* "uvloop/loop.pyx":2676
+ *             except BaseException:
+ *                 app_transport.close()
+ *                 raise             # <<<<<<<<<<<<<<
+ *             return app_transport, protocol
+ *         else:
+ */
+        __Pyx_GIVEREF(__pyx_t_5);
+        __Pyx_GIVEREF(__pyx_t_4);
+        __Pyx_XGIVEREF(__pyx_t_3);
+        __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_4, __pyx_t_3);
+        __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_3 = 0; 
+        __PYX_ERR(0, 2676, __pyx_L17_except_error)
+      }
+      goto __pyx_L17_except_error;
+      __pyx_L17_except_error:;
+
+      /* "uvloop/loop.pyx":2670
+ *         if ssl:
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+      goto __pyx_L1_error;
+      __pyx_L20_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":2677
+ *                 app_transport.close()
+ *                 raise
+ *             return app_transport, protocol             # <<<<<<<<<<<<<<
+ *         else:
+ *             try:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2677, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_transport);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_transport);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_cur_scope->__pyx_v_app_transport);
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
+    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_v_protocol);
+    __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":2668
+ *         transport._attach_fileobj(sock)
+ * 
+ *         if ssl:             # <<<<<<<<<<<<<<
+ *             app_transport = protocol._get_app_transport(context)
+ *             try:
+ */
+  }
+
+  /* "uvloop/loop.pyx":2679
+ *             return app_transport, protocol
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+  /*else*/ {
+    {
+      __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_7);
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":2680
+ *         else:
+ *             try:
+ *                 await waiter             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+        __Pyx_XGOTREF(__pyx_r);
+        if (likely(__pyx_r)) {
+          __Pyx_XGIVEREF(__pyx_t_7);
+          __pyx_cur_scope->__pyx_t_0 = __pyx_t_7;
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __pyx_cur_scope->__pyx_t_1 = __pyx_t_8;
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __pyx_cur_scope->__pyx_t_2 = __pyx_t_9;
+          __Pyx_XGIVEREF(__pyx_r);
+          __Pyx_RefNannyFinishContext();
+          __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+          /* return from generator, awaiting value */
+          __pyx_generator->resume_label = 2;
+          return __pyx_r;
+          __pyx_L32_resume_from_await:;
+          __pyx_t_7 = __pyx_cur_scope->__pyx_t_0;
+          __pyx_cur_scope->__pyx_t_0 = 0;
+          __Pyx_XGOTREF(__pyx_t_7);
+          __pyx_t_8 = __pyx_cur_scope->__pyx_t_1;
+          __pyx_cur_scope->__pyx_t_1 = 0;
+          __Pyx_XGOTREF(__pyx_t_8);
+          __pyx_t_9 = __pyx_cur_scope->__pyx_t_2;
+          __pyx_cur_scope->__pyx_t_2 = 0;
+          __Pyx_XGOTREF(__pyx_t_9);
+          if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2680, __pyx_L26_error)
+        } else {
+          PyObject* exc_type = __Pyx_PyErr_Occurred();
+          if (exc_type) {
+            if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+            else __PYX_ERR(0, 2680, __pyx_L26_error)
+          }
+        }
+
+        /* "uvloop/loop.pyx":2679
+ *             return app_transport, protocol
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L31_try_end;
+      __pyx_L26_error:;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 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;
+
+      /* "uvloop/loop.pyx":2681
+ *             try:
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException:
+ */
+      __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_6) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.connect_accepted_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(0, 2681, __pyx_L28_except_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_5);
+
+        /* "uvloop/loop.pyx":2682
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException:
+ *                 transport._close()
+ */
+        __Pyx_GIVEREF(__pyx_t_3);
+        __Pyx_GIVEREF(__pyx_t_4);
+        __Pyx_XGIVEREF(__pyx_t_5);
+        __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+        __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; 
+        __PYX_ERR(0, 2682, __pyx_L28_except_error)
+      }
+
+      /* "uvloop/loop.pyx":2683
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException:             # <<<<<<<<<<<<<<
+ *                 transport._close()
+ *                 raise
+ */
+      __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_6) {
+        __Pyx_AddTraceback("uvloop.loop.Loop.connect_accepted_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3) < 0) __PYX_ERR(0, 2683, __pyx_L28_except_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_3);
+
+        /* "uvloop/loop.pyx":2684
+ *                 raise
+ *             except BaseException:
+ *                 transport._close()             # <<<<<<<<<<<<<<
+ *                 raise
+ *             return transport, protocol
+ */
+        __pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_cur_scope->__pyx_v_transport->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_transport)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2684, __pyx_L28_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+        /* "uvloop/loop.pyx":2685
+ *             except BaseException:
+ *                 transport._close()
+ *                 raise             # <<<<<<<<<<<<<<
+ *             return transport, protocol
+ * 
+ */
+        __Pyx_GIVEREF(__pyx_t_5);
+        __Pyx_GIVEREF(__pyx_t_4);
+        __Pyx_XGIVEREF(__pyx_t_3);
+        __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_4, __pyx_t_3);
+        __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_3 = 0; 
+        __PYX_ERR(0, 2685, __pyx_L28_except_error)
+      }
+      goto __pyx_L28_except_error;
+      __pyx_L28_except_error:;
+
+      /* "uvloop/loop.pyx":2679
+ *             return app_transport, protocol
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 await waiter
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_8, __pyx_t_7);
+      goto __pyx_L1_error;
+      __pyx_L31_try_end:;
+    }
+
+    /* "uvloop/loop.pyx":2686
+ *                 transport._close()
+ *                 raise
+ *             return transport, protocol             # <<<<<<<<<<<<<<
+ * 
+ *     def run_in_executor(self, executor, func, *args):
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2686, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_transport));
+    __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_transport));
+    PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_transport));
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
+    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_v_protocol);
+    __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L0;
+  }
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2605
+ * 
+ *     @cython.iterable_coroutine
+ *     async def connect_accepted_socket(self, protocol_factory, sock, *,             # <<<<<<<<<<<<<<
+ *                                       ssl=None,
+ *                                       ssl_handshake_timeout=None,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("connect_accepted_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2688
+ *             return transport, protocol
+ * 
+ *     def run_in_executor(self, executor, func, *args):             # <<<<<<<<<<<<<<
+ *         if aio_iscoroutine(func) or aio_iscoroutinefunction(func):
+ *             raise TypeError("coroutines cannot be used with run_in_executor()")
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_102run_in_executor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_101run_in_executor[] = "Loop.run_in_executor(self, executor, func, *args)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_102run_in_executor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_executor = 0;
+  PyObject *__pyx_v_func = 0;
+  PyObject *__pyx_v_args = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("run_in_executor (wrapper)", 0);
+  if (PyTuple_GET_SIZE(__pyx_args) > 2) {
+    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
+    if (unlikely(!__pyx_v_args)) {
+      __Pyx_RefNannyFinishContext();
+      return NULL;
+    }
+    __Pyx_GOTREF(__pyx_v_args);
+  } else {
+    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
+  }
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_executor,&__pyx_n_s_func,0};
+    PyObject* values[2] = {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) {
+        default:
+        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;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_executor)) != 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_func)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("run_in_executor", 0, 2, 2, 1); __PYX_ERR(0, 2688, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "run_in_executor") < 0)) __PYX_ERR(0, 2688, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_executor = values[0];
+    __pyx_v_func = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("run_in_executor", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2688, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
+  __Pyx_AddTraceback("uvloop.loop.Loop.run_in_executor", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_101run_in_executor(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_executor, __pyx_v_func, __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_101run_in_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_executor, PyObject *__pyx_v_func, PyObject *__pyx_v_args) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("run_in_executor", 0);
+  __Pyx_INCREF(__pyx_v_executor);
+
+  /* "uvloop/loop.pyx":2689
+ * 
+ *     def run_in_executor(self, executor, func, *args):
+ *         if aio_iscoroutine(func) or aio_iscoroutinefunction(func):             # <<<<<<<<<<<<<<
+ *             raise TypeError("coroutines cannot be used with run_in_executor()")
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_iscoroutine);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_aio_iscoroutine; __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_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_func) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_func);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2689, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 2689, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!__pyx_t_5) {
+  } else {
+    __pyx_t_1 = __pyx_t_5;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_iscoroutinefunction);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_aio_iscoroutinefunction; __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_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_func) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_func);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2689, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 2689, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_1 = __pyx_t_5;
+  __pyx_L4_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":2690
+ *     def run_in_executor(self, executor, func, *args):
+ *         if aio_iscoroutine(func) or aio_iscoroutinefunction(func):
+ *             raise TypeError("coroutines cannot be used with run_in_executor()")             # <<<<<<<<<<<<<<
+ * 
+ *         self._check_closed()
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2690, __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(0, 2690, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2689
+ * 
+ *     def run_in_executor(self, executor, func, *args):
+ *         if aio_iscoroutine(func) or aio_iscoroutinefunction(func):             # <<<<<<<<<<<<<<
+ *             raise TypeError("coroutines cannot be used with run_in_executor()")
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2692
+ *             raise TypeError("coroutines cannot be used with run_in_executor()")
+ * 
+ *         self._check_closed()             # <<<<<<<<<<<<<<
+ * 
+ *         if executor is None:
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2692, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":2694
+ *         self._check_closed()
+ * 
+ *         if executor is None:             # <<<<<<<<<<<<<<
+ *             executor = self._default_executor
+ *             # Only check when the default executor is being used
+ */
+  __pyx_t_1 = (__pyx_v_executor == Py_None);
+  __pyx_t_5 = (__pyx_t_1 != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/loop.pyx":2695
+ * 
+ *         if executor is None:
+ *             executor = self._default_executor             # <<<<<<<<<<<<<<
+ *             # Only check when the default executor is being used
+ *             self._check_default_executor()
+ */
+    __pyx_t_2 = __pyx_v_self->_default_executor;
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_DECREF_SET(__pyx_v_executor, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":2697
+ *             executor = self._default_executor
+ *             # Only check when the default executor is being used
+ *             self._check_default_executor()             # <<<<<<<<<<<<<<
+ *             if executor is None:
+ *                 executor = cc_ThreadPoolExecutor()
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_default_executor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2697, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2697, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/loop.pyx":2698
+ *             # Only check when the default executor is being used
+ *             self._check_default_executor()
+ *             if executor is None:             # <<<<<<<<<<<<<<
+ *                 executor = cc_ThreadPoolExecutor()
+ *                 self._default_executor = executor
+ */
+    __pyx_t_5 = (__pyx_v_executor == Py_None);
+    __pyx_t_1 = (__pyx_t_5 != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/loop.pyx":2699
+ *             self._check_default_executor()
+ *             if executor is None:
+ *                 executor = cc_ThreadPoolExecutor()             # <<<<<<<<<<<<<<
+ *                 self._default_executor = executor
+ * 
+ */
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_cc_ThreadPoolExecutor);
+      __pyx_t_3 = __pyx_v_6uvloop_4loop_cc_ThreadPoolExecutor; __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_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2699, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF_SET(__pyx_v_executor, __pyx_t_2);
+      __pyx_t_2 = 0;
+
+      /* "uvloop/loop.pyx":2700
+ *             if executor is None:
+ *                 executor = cc_ThreadPoolExecutor()
+ *                 self._default_executor = executor             # <<<<<<<<<<<<<<
+ * 
+ *         return aio_wrap_future(executor.submit(func, *args), loop=self)
+ */
+      __Pyx_INCREF(__pyx_v_executor);
+      __Pyx_GIVEREF(__pyx_v_executor);
+      __Pyx_GOTREF(__pyx_v_self->_default_executor);
+      __Pyx_DECREF(__pyx_v_self->_default_executor);
+      __pyx_v_self->_default_executor = __pyx_v_executor;
+
+      /* "uvloop/loop.pyx":2698
+ *             # Only check when the default executor is being used
+ *             self._check_default_executor()
+ *             if executor is None:             # <<<<<<<<<<<<<<
+ *                 executor = cc_ThreadPoolExecutor()
+ *                 self._default_executor = executor
+ */
+    }
+
+    /* "uvloop/loop.pyx":2694
+ *         self._check_closed()
+ * 
+ *         if executor is None:             # <<<<<<<<<<<<<<
+ *             executor = self._default_executor
+ *             # Only check when the default executor is being used
+ */
+  }
+
+  /* "uvloop/loop.pyx":2702
+ *                 self._default_executor = executor
+ * 
+ *         return aio_wrap_future(executor.submit(func, *args), loop=self)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_default_executor(self, executor):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_executor, __pyx_n_s_submit); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2702, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2702, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_v_func);
+  __Pyx_GIVEREF(__pyx_v_func);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_func);
+  __pyx_t_4 = PyNumber_Add(__pyx_t_3, __pyx_v_args); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2702, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2702, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2702, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2702, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_loop, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(0, 2702, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_wrap_future, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2702, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":2688
+ *             return transport, protocol
+ * 
+ *     def run_in_executor(self, executor, func, *args):             # <<<<<<<<<<<<<<
+ *         if aio_iscoroutine(func) or aio_iscoroutinefunction(func):
+ *             raise TypeError("coroutines cannot be used with run_in_executor()")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Loop.run_in_executor", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_executor);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2704
+ *         return aio_wrap_future(executor.submit(func, *args), loop=self)
+ * 
+ *     def set_default_executor(self, executor):             # <<<<<<<<<<<<<<
+ *         self._default_executor = executor
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_104set_default_executor(PyObject *__pyx_v_self, PyObject *__pyx_v_executor); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_103set_default_executor[] = "Loop.set_default_executor(self, executor)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_104set_default_executor(PyObject *__pyx_v_self, PyObject *__pyx_v_executor) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_default_executor (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_103set_default_executor(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_executor));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_103set_default_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_executor) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_default_executor", 0);
+
+  /* "uvloop/loop.pyx":2705
+ * 
+ *     def set_default_executor(self, executor):
+ *         self._default_executor = executor             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_INCREF(__pyx_v_executor);
+  __Pyx_GIVEREF(__pyx_v_executor);
+  __Pyx_GOTREF(__pyx_v_self->_default_executor);
+  __Pyx_DECREF(__pyx_v_self->_default_executor);
+  __pyx_v_self->_default_executor = __pyx_v_executor;
+
+  /* "uvloop/loop.pyx":2704
+ *         return aio_wrap_future(executor.submit(func, *args), loop=self)
+ * 
+ *     def set_default_executor(self, executor):             # <<<<<<<<<<<<<<
+ *         self._default_executor = executor
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_107generator13(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2708
+ * 
+ *     @cython.iterable_coroutine
+ *     async def __subprocess_run(self, protocol_factory, args,             # <<<<<<<<<<<<<<
+ *                                stdin=subprocess_PIPE,
+ *                                stdout=subprocess_PIPE,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_106__subprocess_run(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_105__subprocess_run[] = "Loop.__subprocess_run(self, protocol_factory, args, stdin=subprocess_PIPE, stdout=subprocess_PIPE, stderr=subprocess_PIPE, universal_newlines=False, shell=True, bufsize=0, preexec_fn=None, close_fds=None, cwd=None, env=None, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, executable=None, pass_fds=(), __uvloop_sleep_after_fork=False)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_106__subprocess_run(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_protocol_factory = 0;
+  PyObject *__pyx_v_args = 0;
+  PyObject *__pyx_v_stdin = 0;
+  PyObject *__pyx_v_stdout = 0;
+  PyObject *__pyx_v_stderr = 0;
+  PyObject *__pyx_v_universal_newlines = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_shell = 0;
+  PyObject *__pyx_v_bufsize = 0;
+  PyObject *__pyx_v_preexec_fn = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_close_fds = 0;
+  PyObject *__pyx_v_cwd = 0;
+  PyObject *__pyx_v_env = 0;
+  PyObject *__pyx_v_startupinfo = 0;
+  PyObject *__pyx_v_creationflags = 0;
+  PyObject *__pyx_v_restore_signals = 0;
+  PyObject *__pyx_v_start_new_session = 0;
+  PyObject *__pyx_v_executable = 0;
+  PyObject *__pyx_v_pass_fds = 0;
+  PyObject *__pyx_v___uvloop_sleep_after_fork = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__subprocess_run (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_args,&__pyx_n_s_stdin,&__pyx_n_s_stdout,&__pyx_n_s_stderr,&__pyx_n_s_universal_newlines,&__pyx_n_s_shell,&__pyx_n_s_bufsize,&__pyx_n_s_preexec_fn,&__pyx_n_s_close_fds,&__pyx_n_s_cwd,&__pyx_n_s_env,&__pyx_n_s_startupinfo,&__pyx_n_s_creationflags,&__pyx_n_s_restore_signals,&__pyx_n_s_start_new_session,&__pyx_n_s_executable,&__pyx_n_s_pass_fds,&__pyx_n_s_uvloop_sleep_after_fork,0};
+    PyObject* values[19] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+    values[2] = __pyx_k__76;
+    values[3] = __pyx_k__77;
+    values[4] = __pyx_k__78;
+
+    /* "uvloop/loop.pyx":2712
+ *                                stdout=subprocess_PIPE,
+ *                                stderr=subprocess_PIPE,
+ *                                universal_newlines=False,             # <<<<<<<<<<<<<<
+ *                                shell=True,
+ *                                bufsize=0,
+ */
+    values[5] = ((PyObject *)Py_False);
+
+    /* "uvloop/loop.pyx":2713
+ *                                stderr=subprocess_PIPE,
+ *                                universal_newlines=False,
+ *                                shell=True,             # <<<<<<<<<<<<<<
+ *                                bufsize=0,
+ *                                preexec_fn=None,
+ */
+    values[6] = ((PyObject *)Py_True);
+    values[7] = ((PyObject *)__pyx_int_0);
+
+    /* "uvloop/loop.pyx":2715
+ *                                shell=True,
+ *                                bufsize=0,
+ *                                preexec_fn=None,             # <<<<<<<<<<<<<<
+ *                                close_fds=None,
+ *                                cwd=None,
+ */
+    values[8] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2716
+ *                                bufsize=0,
+ *                                preexec_fn=None,
+ *                                close_fds=None,             # <<<<<<<<<<<<<<
+ *                                cwd=None,
+ *                                env=None,
+ */
+    values[9] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2717
+ *                                preexec_fn=None,
+ *                                close_fds=None,
+ *                                cwd=None,             # <<<<<<<<<<<<<<
+ *                                env=None,
+ *                                startupinfo=None,
+ */
+    values[10] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2718
+ *                                close_fds=None,
+ *                                cwd=None,
+ *                                env=None,             # <<<<<<<<<<<<<<
+ *                                startupinfo=None,
+ *                                creationflags=0,
+ */
+    values[11] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2719
+ *                                cwd=None,
+ *                                env=None,
+ *                                startupinfo=None,             # <<<<<<<<<<<<<<
+ *                                creationflags=0,
+ *                                restore_signals=True,
+ */
+    values[12] = ((PyObject *)Py_None);
+    values[13] = ((PyObject *)__pyx_int_0);
+
+    /* "uvloop/loop.pyx":2721
+ *                                startupinfo=None,
+ *                                creationflags=0,
+ *                                restore_signals=True,             # <<<<<<<<<<<<<<
+ *                                start_new_session=False,
+ *                                executable=None,
+ */
+    values[14] = ((PyObject *)Py_True);
+
+    /* "uvloop/loop.pyx":2722
+ *                                creationflags=0,
+ *                                restore_signals=True,
+ *                                start_new_session=False,             # <<<<<<<<<<<<<<
+ *                                executable=None,
+ *                                pass_fds=(),
+ */
+    values[15] = ((PyObject *)Py_False);
+
+    /* "uvloop/loop.pyx":2723
+ *                                restore_signals=True,
+ *                                start_new_session=False,
+ *                                executable=None,             # <<<<<<<<<<<<<<
+ *                                pass_fds=(),
+ *                                # For tests only! Do not use in your code. Ever.
+ */
+    values[16] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2724
+ *                                start_new_session=False,
+ *                                executable=None,
+ *                                pass_fds=(),             # <<<<<<<<<<<<<<
+ *                                # For tests only! Do not use in your code. Ever.
+ *                                __uvloop_sleep_after_fork=False):
+ */
+    values[17] = ((PyObject *)__pyx_empty_tuple);
+
+    /* "uvloop/loop.pyx":2726
+ *                                pass_fds=(),
+ *                                # For tests only! Do not use in your code. Ever.
+ *                                __uvloop_sleep_after_fork=False):             # <<<<<<<<<<<<<<
+ * 
+ *         # TODO: Implement close_fds (might not be very important in
+ */
+    values[18] = ((PyObject *)Py_False);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case 19: values[18] = PyTuple_GET_ITEM(__pyx_args, 18);
+        CYTHON_FALLTHROUGH;
+        case 18: values[17] = PyTuple_GET_ITEM(__pyx_args, 17);
+        CYTHON_FALLTHROUGH;
+        case 17: values[16] = PyTuple_GET_ITEM(__pyx_args, 16);
+        CYTHON_FALLTHROUGH;
+        case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15);
+        CYTHON_FALLTHROUGH;
+        case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14);
+        CYTHON_FALLTHROUGH;
+        case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13);
+        CYTHON_FALLTHROUGH;
+        case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12);
+        CYTHON_FALLTHROUGH;
+        case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11);
+        CYTHON_FALLTHROUGH;
+        case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
+        CYTHON_FALLTHROUGH;
+        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
+        CYTHON_FALLTHROUGH;
+        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
+        CYTHON_FALLTHROUGH;
+        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+        CYTHON_FALLTHROUGH;
+        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+        CYTHON_FALLTHROUGH;
+        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+        CYTHON_FALLTHROUGH;
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        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);
+        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_protocol_factory)) != 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_args)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__subprocess_run", 0, 2, 19, 1); __PYX_ERR(0, 2708, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stdin);
+          if (value) { values[2] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stdout);
+          if (value) { values[3] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stderr);
+          if (value) { values[4] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  5:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_universal_newlines);
+          if (value) { values[5] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  6:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shell);
+          if (value) { values[6] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  7:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bufsize);
+          if (value) { values[7] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  8:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_preexec_fn);
+          if (value) { values[8] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  9:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close_fds);
+          if (value) { values[9] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case 10:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_cwd);
+          if (value) { values[10] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case 11:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_env);
+          if (value) { values[11] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case 12:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_startupinfo);
+          if (value) { values[12] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case 13:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_creationflags);
+          if (value) { values[13] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case 14:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_restore_signals);
+          if (value) { values[14] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case 15:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start_new_session);
+          if (value) { values[15] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case 16:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_executable);
+          if (value) { values[16] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case 17:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pass_fds);
+          if (value) { values[17] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case 18:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_uvloop_sleep_after_fork);
+          if (value) { values[18] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__subprocess_run") < 0)) __PYX_ERR(0, 2708, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case 19: values[18] = PyTuple_GET_ITEM(__pyx_args, 18);
+        CYTHON_FALLTHROUGH;
+        case 18: values[17] = PyTuple_GET_ITEM(__pyx_args, 17);
+        CYTHON_FALLTHROUGH;
+        case 17: values[16] = PyTuple_GET_ITEM(__pyx_args, 16);
+        CYTHON_FALLTHROUGH;
+        case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15);
+        CYTHON_FALLTHROUGH;
+        case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14);
+        CYTHON_FALLTHROUGH;
+        case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13);
+        CYTHON_FALLTHROUGH;
+        case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12);
+        CYTHON_FALLTHROUGH;
+        case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11);
+        CYTHON_FALLTHROUGH;
+        case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
+        CYTHON_FALLTHROUGH;
+        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
+        CYTHON_FALLTHROUGH;
+        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
+        CYTHON_FALLTHROUGH;
+        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+        CYTHON_FALLTHROUGH;
+        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+        CYTHON_FALLTHROUGH;
+        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+        CYTHON_FALLTHROUGH;
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        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);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_protocol_factory = values[0];
+    __pyx_v_args = values[1];
+    __pyx_v_stdin = values[2];
+    __pyx_v_stdout = values[3];
+    __pyx_v_stderr = values[4];
+    __pyx_v_universal_newlines = values[5];
+    __pyx_v_shell = values[6];
+    __pyx_v_bufsize = values[7];
+    __pyx_v_preexec_fn = values[8];
+    __pyx_v_close_fds = values[9];
+    __pyx_v_cwd = values[10];
+    __pyx_v_env = values[11];
+    __pyx_v_startupinfo = values[12];
+    __pyx_v_creationflags = values[13];
+    __pyx_v_restore_signals = values[14];
+    __pyx_v_start_new_session = values[15];
+    __pyx_v_executable = values[16];
+    __pyx_v_pass_fds = values[17];
+    __pyx_v___uvloop_sleep_after_fork = values[18];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__subprocess_run", 0, 2, 19, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2708, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.__subprocess_run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_105__subprocess_run(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_args, __pyx_v_stdin, __pyx_v_stdout, __pyx_v_stderr, __pyx_v_universal_newlines, __pyx_v_shell, __pyx_v_bufsize, __pyx_v_preexec_fn, __pyx_v_close_fds, __pyx_v_cwd, __pyx_v_env, __pyx_v_startupinfo, __pyx_v_creationflags, __pyx_v_restore_signals, __pyx_v_start_new_session, __pyx_v_executable, __pyx_v_pass_fds, __pyx_v___uvloop_sleep_after_fork);
+
+  /* "uvloop/loop.pyx":2708
+ * 
+ *     @cython.iterable_coroutine
+ *     async def __subprocess_run(self, protocol_factory, args,             # <<<<<<<<<<<<<<
+ *                                stdin=subprocess_PIPE,
+ *                                stdout=subprocess_PIPE,
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_105__subprocess_run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_args, PyObject *__pyx_v_stdin, PyObject *__pyx_v_stdout, PyObject *__pyx_v_stderr, PyObject *__pyx_v_universal_newlines, CYTHON_UNUSED PyObject *__pyx_v_shell, PyObject *__pyx_v_bufsize, PyObject *__pyx_v_preexec_fn, CYTHON_UNUSED PyObject *__pyx_v_close_fds, PyObject *__pyx_v_cwd, PyObject *__pyx_v_env, PyObject *__pyx_v_startupinfo, PyObject *__pyx_v_creationflags, PyObject *__pyx_v_restore_signals, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v_executable, PyObject *__pyx_v_pass_fds, PyObject *__pyx_v___uvloop_sleep_after_fork) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__subprocess_run", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_19___subprocess_run(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_19___subprocess_run, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2708, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_protocol_factory = __pyx_v_protocol_factory;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_cur_scope->__pyx_v_args = __pyx_v_args;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_args);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_args);
+  __pyx_cur_scope->__pyx_v_stdin = __pyx_v_stdin;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_stdin);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_stdin);
+  __pyx_cur_scope->__pyx_v_stdout = __pyx_v_stdout;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_stdout);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_stdout);
+  __pyx_cur_scope->__pyx_v_stderr = __pyx_v_stderr;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_stderr);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_stderr);
+  __pyx_cur_scope->__pyx_v_universal_newlines = __pyx_v_universal_newlines;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_universal_newlines);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_universal_newlines);
+  __pyx_cur_scope->__pyx_v_shell = __pyx_v_shell;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_shell);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_shell);
+  __pyx_cur_scope->__pyx_v_bufsize = __pyx_v_bufsize;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_bufsize);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_bufsize);
+  __pyx_cur_scope->__pyx_v_preexec_fn = __pyx_v_preexec_fn;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_preexec_fn);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_preexec_fn);
+  __pyx_cur_scope->__pyx_v_close_fds = __pyx_v_close_fds;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_close_fds);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_close_fds);
+  __pyx_cur_scope->__pyx_v_cwd = __pyx_v_cwd;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_cwd);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_cwd);
+  __pyx_cur_scope->__pyx_v_env = __pyx_v_env;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_env);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_env);
+  __pyx_cur_scope->__pyx_v_startupinfo = __pyx_v_startupinfo;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_startupinfo);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_startupinfo);
+  __pyx_cur_scope->__pyx_v_creationflags = __pyx_v_creationflags;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_creationflags);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_creationflags);
+  __pyx_cur_scope->__pyx_v_restore_signals = __pyx_v_restore_signals;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_restore_signals);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_restore_signals);
+  __pyx_cur_scope->__pyx_v_start_new_session = __pyx_v_start_new_session;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_start_new_session);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_start_new_session);
+  __pyx_cur_scope->__pyx_v_executable = __pyx_v_executable;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_executable);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_executable);
+  __pyx_cur_scope->__pyx_v_pass_fds = __pyx_v_pass_fds;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_pass_fds);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_pass_fds);
+  __pyx_cur_scope->__pyx_v___uvloop_sleep_after_fork = __pyx_v___uvloop_sleep_after_fork;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v___uvloop_sleep_after_fork);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v___uvloop_sleep_after_fork);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_107generator13, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_subprocess_run, __pyx_n_s_Loop___subprocess_run, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2708, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.__subprocess_run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_107generator13(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  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;
+  int __pyx_t_9;
+  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_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__subprocess_run", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L16_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2708, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2732
+ * 
+ *         cdef:
+ *             int debug_flags = 0             # <<<<<<<<<<<<<<
+ * 
+ *         if universal_newlines:
+ */
+  __pyx_cur_scope->__pyx_v_debug_flags = 0;
+
+  /* "uvloop/loop.pyx":2734
+ *             int debug_flags = 0
+ * 
+ *         if universal_newlines:             # <<<<<<<<<<<<<<
+ *             raise ValueError("universal_newlines must be False")
+ *         if bufsize != 0:
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_universal_newlines); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2734, __pyx_L1_error)
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":2735
+ * 
+ *         if universal_newlines:
+ *             raise ValueError("universal_newlines must be False")             # <<<<<<<<<<<<<<
+ *         if bufsize != 0:
+ *             raise ValueError("bufsize must be 0")
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2735, __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(0, 2735, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2734
+ *             int debug_flags = 0
+ * 
+ *         if universal_newlines:             # <<<<<<<<<<<<<<
+ *             raise ValueError("universal_newlines must be False")
+ *         if bufsize != 0:
+ */
+  }
+
+  /* "uvloop/loop.pyx":2736
+ *         if universal_newlines:
+ *             raise ValueError("universal_newlines must be False")
+ *         if bufsize != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("bufsize must be 0")
+ *         if startupinfo is not None:
+ */
+  __pyx_t_2 = __Pyx_PyInt_NeObjC(__pyx_cur_scope->__pyx_v_bufsize, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2736, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2736, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":2737
+ *             raise ValueError("universal_newlines must be False")
+ *         if bufsize != 0:
+ *             raise ValueError("bufsize must be 0")             # <<<<<<<<<<<<<<
+ *         if startupinfo is not None:
+ *             raise ValueError('startupinfo is not supported')
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2737, __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(0, 2737, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2736
+ *         if universal_newlines:
+ *             raise ValueError("universal_newlines must be False")
+ *         if bufsize != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("bufsize must be 0")
+ *         if startupinfo is not None:
+ */
+  }
+
+  /* "uvloop/loop.pyx":2738
+ *         if bufsize != 0:
+ *             raise ValueError("bufsize must be 0")
+ *         if startupinfo is not None:             # <<<<<<<<<<<<<<
+ *             raise ValueError('startupinfo is not supported')
+ *         if creationflags != 0:
+ */
+  __pyx_t_1 = (__pyx_cur_scope->__pyx_v_startupinfo != Py_None);
+  __pyx_t_3 = (__pyx_t_1 != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/loop.pyx":2739
+ *             raise ValueError("bufsize must be 0")
+ *         if startupinfo is not None:
+ *             raise ValueError('startupinfo is not supported')             # <<<<<<<<<<<<<<
+ *         if creationflags != 0:
+ *             raise ValueError('creationflags is not supported')
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2739, __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(0, 2739, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2738
+ *         if bufsize != 0:
+ *             raise ValueError("bufsize must be 0")
+ *         if startupinfo is not None:             # <<<<<<<<<<<<<<
+ *             raise ValueError('startupinfo is not supported')
+ *         if creationflags != 0:
+ */
+  }
+
+  /* "uvloop/loop.pyx":2740
+ *         if startupinfo is not None:
+ *             raise ValueError('startupinfo is not supported')
+ *         if creationflags != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError('creationflags is not supported')
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_NeObjC(__pyx_cur_scope->__pyx_v_creationflags, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2740, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2740, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/loop.pyx":2741
+ *             raise ValueError('startupinfo is not supported')
+ *         if creationflags != 0:
+ *             raise ValueError('creationflags is not supported')             # <<<<<<<<<<<<<<
+ * 
+ *         if executable is not None:
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2741, __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(0, 2741, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2740
+ *         if startupinfo is not None:
+ *             raise ValueError('startupinfo is not supported')
+ *         if creationflags != 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError('creationflags is not supported')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2743
+ *             raise ValueError('creationflags is not supported')
+ * 
+ *         if executable is not None:             # <<<<<<<<<<<<<<
+ *             args[0] = executable
+ * 
+ */
+  __pyx_t_3 = (__pyx_cur_scope->__pyx_v_executable != Py_None);
+  __pyx_t_1 = (__pyx_t_3 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":2744
+ * 
+ *         if executable is not None:
+ *             args[0] = executable             # <<<<<<<<<<<<<<
+ * 
+ *         if __uvloop_sleep_after_fork:
+ */
+    if (unlikely(__Pyx_SetItemInt(__pyx_cur_scope->__pyx_v_args, 0, __pyx_cur_scope->__pyx_v_executable, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) __PYX_ERR(0, 2744, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2743
+ *             raise ValueError('creationflags is not supported')
+ * 
+ *         if executable is not None:             # <<<<<<<<<<<<<<
+ *             args[0] = executable
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2746
+ *             args[0] = executable
+ * 
+ *         if __uvloop_sleep_after_fork:             # <<<<<<<<<<<<<<
+ *             debug_flags |= __PROCESS_DEBUG_SLEEP_AFTER_FORK
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v___uvloop_sleep_after_fork); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2746, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":2747
+ * 
+ *         if __uvloop_sleep_after_fork:
+ *             debug_flags |= __PROCESS_DEBUG_SLEEP_AFTER_FORK             # <<<<<<<<<<<<<<
+ * 
+ *         waiter = self._new_future()
+ */
+    __pyx_cur_scope->__pyx_v_debug_flags = (__pyx_cur_scope->__pyx_v_debug_flags | 1);
+
+    /* "uvloop/loop.pyx":2746
+ *             args[0] = executable
+ * 
+ *         if __uvloop_sleep_after_fork:             # <<<<<<<<<<<<<<
+ *             debug_flags |= __PROCESS_DEBUG_SLEEP_AFTER_FORK
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2749
+ *             debug_flags |= __PROCESS_DEBUG_SLEEP_AFTER_FORK
+ * 
+ *         waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *         protocol = protocol_factory()
+ *         proc = UVProcessTransport.new(self, protocol,
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2749, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_cur_scope->__pyx_v_waiter = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":2750
+ * 
+ *         waiter = self._new_future()
+ *         protocol = protocol_factory()             # <<<<<<<<<<<<<<
+ *         proc = UVProcessTransport.new(self, protocol,
+ *                                       args, env, cwd, start_new_session,
+ */
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_t_4 = __pyx_cur_scope->__pyx_v_protocol_factory; __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2750, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_cur_scope->__pyx_v_protocol = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":2755
+ *                                       stdin, stdout, stderr, pass_fds,
+ *                                       waiter,
+ *                                       debug_flags,             # <<<<<<<<<<<<<<
+ *                                       preexec_fn,
+ *                                       restore_signals)
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_debug_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2755, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/loop.pyx":2751
+ *         waiter = self._new_future()
+ *         protocol = protocol_factory()
+ *         proc = UVProcessTransport.new(self, protocol,             # <<<<<<<<<<<<<<
+ *                                       args, env, cwd, start_new_session,
+ *                                       stdin, stdout, stderr, pass_fds,
+ */
+  __pyx_t_4 = ((PyObject *)__pyx_f_6uvloop_4loop_18UVProcessTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, __pyx_cur_scope->__pyx_v_args, __pyx_cur_scope->__pyx_v_env, __pyx_cur_scope->__pyx_v_cwd, __pyx_cur_scope->__pyx_v_start_new_session, __pyx_cur_scope->__pyx_v_stdin, __pyx_cur_scope->__pyx_v_stdout, __pyx_cur_scope->__pyx_v_stderr, __pyx_cur_scope->__pyx_v_pass_fds, __pyx_cur_scope->__pyx_v_waiter, __pyx_t_2, __pyx_cur_scope->__pyx_v_preexec_fn, __pyx_cur_scope->__pyx_v_restore_signals)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2751, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_GIVEREF(__pyx_t_4);
+  __pyx_cur_scope->__pyx_v_proc = ((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2759
+ *                                       restore_signals)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+  {
+    __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_7);
+    __Pyx_XGOTREF(__pyx_t_8);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":2760
+ * 
+ *         try:
+ *             await waiter             # <<<<<<<<<<<<<<
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ */
+      __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+      __Pyx_XGOTREF(__pyx_r);
+      if (likely(__pyx_r)) {
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __pyx_cur_scope->__pyx_t_0 = __pyx_t_6;
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __pyx_cur_scope->__pyx_t_1 = __pyx_t_7;
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __pyx_cur_scope->__pyx_t_2 = __pyx_t_8;
+        __Pyx_XGIVEREF(__pyx_r);
+        __Pyx_RefNannyFinishContext();
+        __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+        /* return from generator, awaiting value */
+        __pyx_generator->resume_label = 1;
+        return __pyx_r;
+        __pyx_L16_resume_from_await:;
+        __pyx_t_6 = __pyx_cur_scope->__pyx_t_0;
+        __pyx_cur_scope->__pyx_t_0 = 0;
+        __Pyx_XGOTREF(__pyx_t_6);
+        __pyx_t_7 = __pyx_cur_scope->__pyx_t_1;
+        __pyx_cur_scope->__pyx_t_1 = 0;
+        __Pyx_XGOTREF(__pyx_t_7);
+        __pyx_t_8 = __pyx_cur_scope->__pyx_t_2;
+        __pyx_cur_scope->__pyx_t_2 = 0;
+        __Pyx_XGOTREF(__pyx_t_8);
+        if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2760, __pyx_L10_error)
+      } else {
+        PyObject* exc_type = __Pyx_PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+          else __PYX_ERR(0, 2760, __pyx_L10_error)
+        }
+      }
+
+      /* "uvloop/loop.pyx":2759
+ *                                       restore_signals)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+    }
+    __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;
+    goto __pyx_L15_try_end;
+    __pyx_L10_error:;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":2761
+ *         try:
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException:
+ */
+    __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+    if (__pyx_t_9) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.__subprocess_run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_2, &__pyx_t_5) < 0) __PYX_ERR(0, 2761, __pyx_L12_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_5);
+
+      /* "uvloop/loop.pyx":2762
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException:
+ *             proc.close()
+ */
+      __Pyx_GIVEREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_2, __pyx_t_5);
+      __pyx_t_4 = 0; __pyx_t_2 = 0; __pyx_t_5 = 0; 
+      __PYX_ERR(0, 2762, __pyx_L12_except_error)
+    }
+
+    /* "uvloop/loop.pyx":2763
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException:             # <<<<<<<<<<<<<<
+ *             proc.close()
+ *             raise
+ */
+    __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_9) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.__subprocess_run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_2, &__pyx_t_4) < 0) __PYX_ERR(0, 2763, __pyx_L12_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/loop.pyx":2764
+ *             raise
+ *         except BaseException:
+ *             proc.close()             # <<<<<<<<<<<<<<
+ *             raise
+ * 
+ */
+      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_proc), __pyx_n_s_close); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2764, __pyx_L12_except_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_12 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+        __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+        if (likely(__pyx_t_12)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+          __Pyx_INCREF(__pyx_t_12);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_11, function);
+        }
+      }
+      __pyx_t_10 = (__pyx_t_12) ? __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_12) : __Pyx_PyObject_CallNoArg(__pyx_t_11);
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2764, __pyx_L12_except_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+      /* "uvloop/loop.pyx":2765
+ *         except BaseException:
+ *             proc.close()
+ *             raise             # <<<<<<<<<<<<<<
+ * 
+ *         return proc, protocol
+ */
+      __Pyx_GIVEREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_2, __pyx_t_4);
+      __pyx_t_5 = 0; __pyx_t_2 = 0; __pyx_t_4 = 0; 
+      __PYX_ERR(0, 2765, __pyx_L12_except_error)
+    }
+    goto __pyx_L12_except_error;
+    __pyx_L12_except_error:;
+
+    /* "uvloop/loop.pyx":2759
+ *                                       restore_signals)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_7);
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+    goto __pyx_L1_error;
+    __pyx_L15_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":2767
+ *             raise
+ * 
+ *         return proc, protocol             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2767, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_proc));
+  __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_proc));
+  PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_proc));
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_cur_scope->__pyx_v_protocol);
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2708
+ * 
+ *     @cython.iterable_coroutine
+ *     async def __subprocess_run(self, protocol_factory, args,             # <<<<<<<<<<<<<<
+ *                                stdin=subprocess_PIPE,
+ *                                stdout=subprocess_PIPE,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("__subprocess_run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_110generator14(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2770
+ * 
+ *     @cython.iterable_coroutine
+ *     async def subprocess_shell(self, protocol_factory, cmd, *,             # <<<<<<<<<<<<<<
+ *                                shell=True,
+ *                                **kwargs):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_109subprocess_shell(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_108subprocess_shell[] = "Loop.subprocess_shell(self, protocol_factory, cmd, *, shell=True, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_109subprocess_shell(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_protocol_factory = 0;
+  PyObject *__pyx_v_cmd = 0;
+  PyObject *__pyx_v_shell = 0;
+  PyObject *__pyx_v_kwargs = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("subprocess_shell (wrapper)", 0);
+  __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
+  __Pyx_GOTREF(__pyx_v_kwargs);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_cmd,&__pyx_n_s_shell,0};
+    PyObject* values[3] = {0,0,0};
+
+    /* "uvloop/loop.pyx":2771
+ *     @cython.iterable_coroutine
+ *     async def subprocess_shell(self, protocol_factory, cmd, *,
+ *                                shell=True,             # <<<<<<<<<<<<<<
+ *                                **kwargs):
+ * 
+ */
+    values[2] = ((PyObject *)Py_True);
+    if (unlikely(__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);
+        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_protocol_factory)) != 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_cmd)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("subprocess_shell", 1, 2, 2, 1); __PYX_ERR(0, 2770, __pyx_L3_error)
+        }
+      }
+      if (kw_args == 1) {
+        const Py_ssize_t index = 2;
+        PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+        if (value) { values[index] = value; kw_args--; }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "subprocess_shell") < 0)) __PYX_ERR(0, 2770, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_protocol_factory = values[0];
+    __pyx_v_cmd = values[1];
+    __pyx_v_shell = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("subprocess_shell", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2770, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_CLEAR(__pyx_v_kwargs);
+  __Pyx_AddTraceback("uvloop.loop.Loop.subprocess_shell", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_108subprocess_shell(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_cmd, __pyx_v_shell, __pyx_v_kwargs);
+
+  /* "uvloop/loop.pyx":2770
+ * 
+ *     @cython.iterable_coroutine
+ *     async def subprocess_shell(self, protocol_factory, cmd, *,             # <<<<<<<<<<<<<<
+ *                                shell=True,
+ *                                **kwargs):
+ */
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_108subprocess_shell(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_cmd, PyObject *__pyx_v_shell, PyObject *__pyx_v_kwargs) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("subprocess_shell", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2770, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_protocol_factory = __pyx_v_protocol_factory;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_cur_scope->__pyx_v_cmd = __pyx_v_cmd;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_cmd);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_cmd);
+  __pyx_cur_scope->__pyx_v_shell = __pyx_v_shell;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_shell);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_shell);
+  __pyx_cur_scope->__pyx_v_kwargs = __pyx_v_kwargs;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_kwargs);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_kwargs);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_110generator14, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_subprocess_shell, __pyx_n_s_Loop_subprocess_shell, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2770, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.subprocess_shell", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_110generator14(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell *)__pyx_generator->closure);
+  PyObject *__pyx_r = 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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("subprocess_shell", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L6_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2770, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2774
+ *                                **kwargs):
+ * 
+ *         if not shell:             # <<<<<<<<<<<<<<
+ *             raise ValueError("shell must be True")
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_shell); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2774, __pyx_L1_error)
+  __pyx_t_2 = ((!__pyx_t_1) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/loop.pyx":2775
+ * 
+ *         if not shell:
+ *             raise ValueError("shell must be True")             # <<<<<<<<<<<<<<
+ * 
+ *         args = [cmd]
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2775, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(0, 2775, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2774
+ *                                **kwargs):
+ * 
+ *         if not shell:             # <<<<<<<<<<<<<<
+ *             raise ValueError("shell must be True")
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2777
+ *             raise ValueError("shell must be True")
+ * 
+ *         args = [cmd]             # <<<<<<<<<<<<<<
+ *         if shell:
+ *             args = [b'/bin/sh', b'-c'] + args
+ */
+  __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2777, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_cmd);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_cmd);
+  PyList_SET_ITEM(__pyx_t_3, 0, __pyx_cur_scope->__pyx_v_cmd);
+  __Pyx_GIVEREF(__pyx_t_3);
+  __pyx_cur_scope->__pyx_v_args = ((PyObject*)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":2778
+ * 
+ *         args = [cmd]
+ *         if shell:             # <<<<<<<<<<<<<<
+ *             args = [b'/bin/sh', b'-c'] + args
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_shell); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2778, __pyx_L1_error)
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":2779
+ *         args = [cmd]
+ *         if shell:
+ *             args = [b'/bin/sh', b'-c'] + args             # <<<<<<<<<<<<<<
+ * 
+ *         return await self.__subprocess_run(protocol_factory, args, shell=True,
+ */
+    __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2779, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_kp_b_bin_sh);
+    __Pyx_GIVEREF(__pyx_kp_b_bin_sh);
+    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_kp_b_bin_sh);
+    __Pyx_INCREF(__pyx_kp_b_c);
+    __Pyx_GIVEREF(__pyx_kp_b_c);
+    PyList_SET_ITEM(__pyx_t_3, 1, __pyx_kp_b_c);
+    __pyx_t_4 = PyNumber_Add(__pyx_t_3, __pyx_cur_scope->__pyx_v_args); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2779, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_args);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_args, ((PyObject*)__pyx_t_4));
+    __Pyx_GIVEREF(__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":2778
+ * 
+ *         args = [cmd]
+ *         if shell:             # <<<<<<<<<<<<<<
+ *             args = [b'/bin/sh', b'-c'] + args
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2781
+ *             args = [b'/bin/sh', b'-c'] + args
+ * 
+ *         return await self.__subprocess_run(protocol_factory, args, shell=True,             # <<<<<<<<<<<<<<
+ *                                            **kwargs)
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_subprocess_run); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2781, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2781, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_args);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_args);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_v_args);
+  __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2781, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_shell, Py_True) < 0) __PYX_ERR(0, 2781, __pyx_L1_error)
+  __pyx_t_5 = __pyx_t_6;
+  __pyx_t_6 = 0;
+
+  /* "uvloop/loop.pyx":2782
+ * 
+ *         return await self.__subprocess_run(protocol_factory, args, shell=True,
+ *                                            **kwargs)             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  if (__Pyx_MergeKeywords(__pyx_t_5, __pyx_cur_scope->__pyx_v_kwargs) < 0) __PYX_ERR(0, 2782, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2781
+ *             args = [b'/bin/sh', b'-c'] + args
+ * 
+ *         return await self.__subprocess_run(protocol_factory, args, shell=True,             # <<<<<<<<<<<<<<
+ *                                            **kwargs)
+ * 
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2781, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 1;
+    return __pyx_r;
+    __pyx_L6_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2781, __pyx_L1_error)
+    __pyx_t_6 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_6);
+  } else {
+    __pyx_t_6 = NULL;
+    if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_6) < 0) __PYX_ERR(0, 2781, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+  }
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2770
+ * 
+ *     @cython.iterable_coroutine
+ *     async def subprocess_shell(self, protocol_factory, cmd, *,             # <<<<<<<<<<<<<<
+ *                                shell=True,
+ *                                **kwargs):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("subprocess_shell", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_113generator15(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2785
+ * 
+ *     @cython.iterable_coroutine
+ *     async def subprocess_exec(self, protocol_factory, program, *args,             # <<<<<<<<<<<<<<
+ *                               shell=False, **kwargs):
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_112subprocess_exec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_111subprocess_exec[] = "Loop.subprocess_exec(self, protocol_factory, program, *args, shell=False, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_112subprocess_exec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_protocol_factory = 0;
+  PyObject *__pyx_v_program = 0;
+  PyObject *__pyx_v_shell = 0;
+  PyObject *__pyx_v_args = 0;
+  PyObject *__pyx_v_kwargs = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("subprocess_exec (wrapper)", 0);
+  __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
+  __Pyx_GOTREF(__pyx_v_kwargs);
+  if (PyTuple_GET_SIZE(__pyx_args) > 2) {
+    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
+    if (unlikely(!__pyx_v_args)) {
+      __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
+      __Pyx_RefNannyFinishContext();
+      return NULL;
+    }
+    __Pyx_GOTREF(__pyx_v_args);
+  } else {
+    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
+  }
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_program,&__pyx_n_s_shell,0};
+    PyObject* values[3] = {0,0,0};
+
+    /* "uvloop/loop.pyx":2786
+ *     @cython.iterable_coroutine
+ *     async def subprocess_exec(self, protocol_factory, program, *args,
+ *                               shell=False, **kwargs):             # <<<<<<<<<<<<<<
+ * 
+ *         if shell:
+ */
+    values[2] = ((PyObject *)Py_False);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        default:
+        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;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_protocol_factory)) != 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_program)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("subprocess_exec", 0, 2, 2, 1); __PYX_ERR(0, 2785, __pyx_L3_error)
+        }
+      }
+      if (kw_args == 1) {
+        const Py_ssize_t index = 2;
+        PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+        if (value) { values[index] = value; kw_args--; }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "subprocess_exec") < 0)) __PYX_ERR(0, 2785, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_protocol_factory = values[0];
+    __pyx_v_program = values[1];
+    __pyx_v_shell = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("subprocess_exec", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2785, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_CLEAR(__pyx_v_args);
+  __Pyx_CLEAR(__pyx_v_kwargs);
+  __Pyx_AddTraceback("uvloop.loop.Loop.subprocess_exec", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_111subprocess_exec(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_program, __pyx_v_shell, __pyx_v_args, __pyx_v_kwargs);
+
+  /* "uvloop/loop.pyx":2785
+ * 
+ *     @cython.iterable_coroutine
+ *     async def subprocess_exec(self, protocol_factory, program, *args,             # <<<<<<<<<<<<<<
+ *                               shell=False, **kwargs):
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_111subprocess_exec(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_program, PyObject *__pyx_v_shell, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("subprocess_exec", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2785, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_protocol_factory = __pyx_v_protocol_factory;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_cur_scope->__pyx_v_program = __pyx_v_program;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_program);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_program);
+  __pyx_cur_scope->__pyx_v_shell = __pyx_v_shell;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_shell);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_shell);
+  __pyx_cur_scope->__pyx_v_args = __pyx_v_args;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_args);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_args);
+  __pyx_cur_scope->__pyx_v_kwargs = __pyx_v_kwargs;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_kwargs);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_kwargs);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_113generator15, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_subprocess_exec, __pyx_n_s_Loop_subprocess_exec, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2785, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.subprocess_exec", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_113generator15(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  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_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("subprocess_exec", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L5_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2785, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2788
+ *                               shell=False, **kwargs):
+ * 
+ *         if shell:             # <<<<<<<<<<<<<<
+ *             raise ValueError("shell must be False")
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_shell); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2788, __pyx_L1_error)
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":2789
+ * 
+ *         if shell:
+ *             raise ValueError("shell must be False")             # <<<<<<<<<<<<<<
+ * 
+ *         args = list((program,) + args)
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2789, __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(0, 2789, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2788
+ *                               shell=False, **kwargs):
+ * 
+ *         if shell:             # <<<<<<<<<<<<<<
+ *             raise ValueError("shell must be False")
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2791
+ *             raise ValueError("shell must be False")
+ * 
+ *         args = list((program,) + args)             # <<<<<<<<<<<<<<
+ * 
+ *         return await self.__subprocess_run(protocol_factory, args, shell=False,
+ */
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2791, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_program);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_program);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_cur_scope->__pyx_v_program);
+  __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_cur_scope->__pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2791, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2791, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_args);
+  __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_args, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":2793
+ *         args = list((program,) + args)
+ * 
+ *         return await self.__subprocess_run(protocol_factory, args, shell=False,             # <<<<<<<<<<<<<<
+ *                                            **kwargs)
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_subprocess_run); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2793, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2793, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_args);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_args);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_v_args);
+  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2793, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_shell, Py_False) < 0) __PYX_ERR(0, 2793, __pyx_L1_error)
+  __pyx_t_4 = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":2794
+ * 
+ *         return await self.__subprocess_run(protocol_factory, args, shell=False,
+ *                                            **kwargs)             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  if (__Pyx_MergeKeywords(__pyx_t_4, __pyx_cur_scope->__pyx_v_kwargs) < 0) __PYX_ERR(0, 2794, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2793
+ *         args = list((program,) + args)
+ * 
+ *         return await self.__subprocess_run(protocol_factory, args, shell=False,             # <<<<<<<<<<<<<<
+ *                                            **kwargs)
+ * 
+ */
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2793, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_5);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 1;
+    return __pyx_r;
+    __pyx_L5_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2793, __pyx_L1_error)
+    __pyx_t_5 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_5);
+  } else {
+    __pyx_t_5 = NULL;
+    if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_5) < 0) __PYX_ERR(0, 2793, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+  }
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2785
+ * 
+ *     @cython.iterable_coroutine
+ *     async def subprocess_exec(self, protocol_factory, program, *args,             # <<<<<<<<<<<<<<
+ *                               shell=False, **kwargs):
+ * 
+ */
+
+  /* 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_AddTraceback("subprocess_exec", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_116generator16(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2797
+ * 
+ *     @cython.iterable_coroutine
+ *     async def connect_read_pipe(self, proto_factory, pipe):             # <<<<<<<<<<<<<<
+ *         """Register read pipe in event loop. Set the pipe to non-blocking mode.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_115connect_read_pipe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_114connect_read_pipe[] = "Loop.connect_read_pipe(self, proto_factory, pipe)\nRegister read pipe in event loop. Set the pipe to non-blocking mode.\n\n        protocol_factory should instantiate object with Protocol interface.\n        pipe is a file-like object.\n        Return pair (transport, protocol), where transport supports the\n        ReadTransport interface.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_115connect_read_pipe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_proto_factory = 0;
+  PyObject *__pyx_v_pipe = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connect_read_pipe (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_proto_factory,&__pyx_n_s_pipe,0};
+    PyObject* values[2] = {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  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_proto_factory)) != 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_pipe)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("connect_read_pipe", 1, 2, 2, 1); __PYX_ERR(0, 2797, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "connect_read_pipe") < 0)) __PYX_ERR(0, 2797, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_proto_factory = values[0];
+    __pyx_v_pipe = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("connect_read_pipe", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2797, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.connect_read_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_114connect_read_pipe(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_proto_factory, __pyx_v_pipe);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_114connect_read_pipe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_proto_factory, PyObject *__pyx_v_pipe) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("connect_read_pipe", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2797, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_proto_factory = __pyx_v_proto_factory;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto_factory);
+  __pyx_cur_scope->__pyx_v_pipe = __pyx_v_pipe;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_pipe);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_pipe);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_116generator16, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_connect_read_pipe, __pyx_n_s_Loop_connect_read_pipe, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2797, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.connect_read_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_116generator16(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connect_read_pipe", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L10_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2797, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2807
+ *             ReadUnixTransport transp
+ * 
+ *         waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *         proto = proto_factory()
+ *         transp = ReadUnixTransport.new(self, proto, None, waiter)
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2807, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_waiter = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2808
+ * 
+ *         waiter = self._new_future()
+ *         proto = proto_factory()             # <<<<<<<<<<<<<<
+ *         transp = ReadUnixTransport.new(self, proto, None, waiter)
+ *         transp._add_extra_info('pipe', pipe)
+ */
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto_factory);
+  __pyx_t_2 = __pyx_cur_scope->__pyx_v_proto_factory; __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __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, 2808, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_proto = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2809
+ *         waiter = self._new_future()
+ *         proto = proto_factory()
+ *         transp = ReadUnixTransport.new(self, proto, None, waiter)             # <<<<<<<<<<<<<<
+ *         transp._add_extra_info('pipe', pipe)
+ *         try:
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_17ReadUnixTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_proto, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2809, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_transp = ((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2810
+ *         proto = proto_factory()
+ *         transp = ReadUnixTransport.new(self, proto, None, waiter)
+ *         transp._add_extra_info('pipe', pipe)             # <<<<<<<<<<<<<<
+ *         try:
+ *             transp._open(pipe.fileno())
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._add_extra_info(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_transp), __pyx_n_u_pipe, __pyx_cur_scope->__pyx_v_pipe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2810, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2811
+ *         transp = ReadUnixTransport.new(self, proto, None, waiter)
+ *         transp._add_extra_info('pipe', pipe)
+ *         try:             # <<<<<<<<<<<<<<
+ *             transp._open(pipe.fileno())
+ *             transp._init_protocol()
+ */
+  {
+    __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_6);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":2812
+ *         transp._add_extra_info('pipe', pipe)
+ *         try:
+ *             transp._open(pipe.fileno())             # <<<<<<<<<<<<<<
+ *             transp._init_protocol()
+ *             await waiter
+ */
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_pipe, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2812, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_3 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_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, 2812, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2812, __pyx_L4_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_transp), __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2812, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":2813
+ *         try:
+ *             transp._open(pipe.fileno())
+ *             transp._init_protocol()             # <<<<<<<<<<<<<<
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_transp)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2813, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":2814
+ *             transp._open(pipe.fileno())
+ *             transp._init_protocol()
+ *             await waiter             # <<<<<<<<<<<<<<
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ */
+      __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+      __Pyx_XGOTREF(__pyx_r);
+      if (likely(__pyx_r)) {
+        __Pyx_XGIVEREF(__pyx_t_4);
+        __pyx_cur_scope->__pyx_t_0 = __pyx_t_4;
+        __Pyx_XGIVEREF(__pyx_t_5);
+        __pyx_cur_scope->__pyx_t_1 = __pyx_t_5;
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __pyx_cur_scope->__pyx_t_2 = __pyx_t_6;
+        __Pyx_XGIVEREF(__pyx_r);
+        __Pyx_RefNannyFinishContext();
+        __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+        /* return from generator, awaiting value */
+        __pyx_generator->resume_label = 1;
+        return __pyx_r;
+        __pyx_L10_resume_from_await:;
+        __pyx_t_4 = __pyx_cur_scope->__pyx_t_0;
+        __pyx_cur_scope->__pyx_t_0 = 0;
+        __Pyx_XGOTREF(__pyx_t_4);
+        __pyx_t_5 = __pyx_cur_scope->__pyx_t_1;
+        __pyx_cur_scope->__pyx_t_1 = 0;
+        __Pyx_XGOTREF(__pyx_t_5);
+        __pyx_t_6 = __pyx_cur_scope->__pyx_t_2;
+        __pyx_cur_scope->__pyx_t_2 = 0;
+        __Pyx_XGOTREF(__pyx_t_6);
+        if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2814, __pyx_L4_error)
+      } else {
+        PyObject* exc_type = __Pyx_PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+          else __PYX_ERR(0, 2814, __pyx_L4_error)
+        }
+      }
+
+      /* "uvloop/loop.pyx":2811
+ *         transp = ReadUnixTransport.new(self, proto, None, waiter)
+ *         transp._add_extra_info('pipe', pipe)
+ *         try:             # <<<<<<<<<<<<<<
+ *             transp._open(pipe.fileno())
+ *             transp._init_protocol()
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    goto __pyx_L9_try_end;
+    __pyx_L4_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":2815
+ *             transp._init_protocol()
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException:
+ */
+    __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+    if (__pyx_t_7) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.connect_read_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 2815, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_3);
+
+      /* "uvloop/loop.pyx":2816
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException:
+ *             transp._close()
+ */
+      __Pyx_GIVEREF(__pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+      __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; 
+      __PYX_ERR(0, 2816, __pyx_L6_except_error)
+    }
+
+    /* "uvloop/loop.pyx":2817
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException:             # <<<<<<<<<<<<<<
+ *             transp._close()
+ *             raise
+ */
+    __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_7) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.connect_read_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 2817, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_1);
+
+      /* "uvloop/loop.pyx":2818
+ *             raise
+ *         except BaseException:
+ *             transp._close()             # <<<<<<<<<<<<<<
+ *             raise
+ *         transp._attach_fileobj(pipe)
+ */
+      __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_transp)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2818, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "uvloop/loop.pyx":2819
+ *         except BaseException:
+ *             transp._close()
+ *             raise             # <<<<<<<<<<<<<<
+ *         transp._attach_fileobj(pipe)
+ *         return transp, proto
+ */
+      __Pyx_GIVEREF(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_1);
+      __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_2, __pyx_t_1);
+      __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; 
+      __PYX_ERR(0, 2819, __pyx_L6_except_error)
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/loop.pyx":2811
+ *         transp = ReadUnixTransport.new(self, proto, None, waiter)
+ *         transp._add_extra_info('pipe', pipe)
+ *         try:             # <<<<<<<<<<<<<<
+ *             transp._open(pipe.fileno())
+ *             transp._init_protocol()
+ */
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L1_error;
+    __pyx_L9_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":2820
+ *             transp._close()
+ *             raise
+ *         transp._attach_fileobj(pipe)             # <<<<<<<<<<<<<<
+ *         return transp, proto
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_transp), __pyx_cur_scope->__pyx_v_pipe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2820, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2821
+ *             raise
+ *         transp._attach_fileobj(pipe)
+ *         return transp, proto             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2821, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_transp));
+  __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_transp));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_transp));
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_cur_scope->__pyx_v_proto);
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2797
+ * 
+ *     @cython.iterable_coroutine
+ *     async def connect_read_pipe(self, proto_factory, pipe):             # <<<<<<<<<<<<<<
+ *         """Register read pipe in event loop. Set the pipe to non-blocking mode.
+ * 
+ */
+
+  /* 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_8);
+  __Pyx_AddTraceback("connect_read_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_119generator17(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2824
+ * 
+ *     @cython.iterable_coroutine
+ *     async def connect_write_pipe(self, proto_factory, pipe):             # <<<<<<<<<<<<<<
+ *         """Register write pipe in event loop.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_118connect_write_pipe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_117connect_write_pipe[] = "Loop.connect_write_pipe(self, proto_factory, pipe)\nRegister write pipe in event loop.\n\n        protocol_factory should instantiate object with BaseProtocol interface.\n        Pipe is file-like object already switched to nonblocking.\n        Return pair (transport, protocol), where transport support\n        WriteTransport interface.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_118connect_write_pipe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_proto_factory = 0;
+  PyObject *__pyx_v_pipe = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connect_write_pipe (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_proto_factory,&__pyx_n_s_pipe,0};
+    PyObject* values[2] = {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  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_proto_factory)) != 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_pipe)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("connect_write_pipe", 1, 2, 2, 1); __PYX_ERR(0, 2824, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "connect_write_pipe") < 0)) __PYX_ERR(0, 2824, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_proto_factory = values[0];
+    __pyx_v_pipe = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("connect_write_pipe", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2824, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.connect_write_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_117connect_write_pipe(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_proto_factory, __pyx_v_pipe);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_117connect_write_pipe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_proto_factory, PyObject *__pyx_v_pipe) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("connect_write_pipe", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2824, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_proto_factory = __pyx_v_proto_factory;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto_factory);
+  __pyx_cur_scope->__pyx_v_pipe = __pyx_v_pipe;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_pipe);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_pipe);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_119generator17, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_connect_write_pipe, __pyx_n_s_Loop_connect_write_pipe, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2824, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.connect_write_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_119generator17(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connect_write_pipe", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L10_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2824, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2834
+ *             WriteUnixTransport transp
+ * 
+ *         waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *         proto = proto_factory()
+ *         transp = WriteUnixTransport.new(self, proto, None, waiter)
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2834, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_waiter = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2835
+ * 
+ *         waiter = self._new_future()
+ *         proto = proto_factory()             # <<<<<<<<<<<<<<
+ *         transp = WriteUnixTransport.new(self, proto, None, waiter)
+ *         transp._add_extra_info('pipe', pipe)
+ */
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto_factory);
+  __pyx_t_2 = __pyx_cur_scope->__pyx_v_proto_factory; __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __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, 2835, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_proto = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2836
+ *         waiter = self._new_future()
+ *         proto = proto_factory()
+ *         transp = WriteUnixTransport.new(self, proto, None, waiter)             # <<<<<<<<<<<<<<
+ *         transp._add_extra_info('pipe', pipe)
+ *         try:
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_18WriteUnixTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_proto, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2836, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_transp = ((struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2837
+ *         proto = proto_factory()
+ *         transp = WriteUnixTransport.new(self, proto, None, waiter)
+ *         transp._add_extra_info('pipe', pipe)             # <<<<<<<<<<<<<<
+ *         try:
+ *             transp._open(pipe.fileno())
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._add_extra_info(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_transp), __pyx_n_u_pipe, __pyx_cur_scope->__pyx_v_pipe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2837, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2838
+ *         transp = WriteUnixTransport.new(self, proto, None, waiter)
+ *         transp._add_extra_info('pipe', pipe)
+ *         try:             # <<<<<<<<<<<<<<
+ *             transp._open(pipe.fileno())
+ *             transp._init_protocol()
+ */
+  {
+    __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_6);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":2839
+ *         transp._add_extra_info('pipe', pipe)
+ *         try:
+ *             transp._open(pipe.fileno())             # <<<<<<<<<<<<<<
+ *             transp._init_protocol()
+ *             await waiter
+ */
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_pipe, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2839, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_3 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_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, 2839, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2839, __pyx_L4_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_transp), __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2839, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":2840
+ *         try:
+ *             transp._open(pipe.fileno())
+ *             transp._init_protocol()             # <<<<<<<<<<<<<<
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_transp)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2840, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":2841
+ *             transp._open(pipe.fileno())
+ *             transp._init_protocol()
+ *             await waiter             # <<<<<<<<<<<<<<
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ */
+      __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+      __Pyx_XGOTREF(__pyx_r);
+      if (likely(__pyx_r)) {
+        __Pyx_XGIVEREF(__pyx_t_4);
+        __pyx_cur_scope->__pyx_t_0 = __pyx_t_4;
+        __Pyx_XGIVEREF(__pyx_t_5);
+        __pyx_cur_scope->__pyx_t_1 = __pyx_t_5;
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __pyx_cur_scope->__pyx_t_2 = __pyx_t_6;
+        __Pyx_XGIVEREF(__pyx_r);
+        __Pyx_RefNannyFinishContext();
+        __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+        /* return from generator, awaiting value */
+        __pyx_generator->resume_label = 1;
+        return __pyx_r;
+        __pyx_L10_resume_from_await:;
+        __pyx_t_4 = __pyx_cur_scope->__pyx_t_0;
+        __pyx_cur_scope->__pyx_t_0 = 0;
+        __Pyx_XGOTREF(__pyx_t_4);
+        __pyx_t_5 = __pyx_cur_scope->__pyx_t_1;
+        __pyx_cur_scope->__pyx_t_1 = 0;
+        __Pyx_XGOTREF(__pyx_t_5);
+        __pyx_t_6 = __pyx_cur_scope->__pyx_t_2;
+        __pyx_cur_scope->__pyx_t_2 = 0;
+        __Pyx_XGOTREF(__pyx_t_6);
+        if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2841, __pyx_L4_error)
+      } else {
+        PyObject* exc_type = __Pyx_PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+          else __PYX_ERR(0, 2841, __pyx_L4_error)
+        }
+      }
+
+      /* "uvloop/loop.pyx":2838
+ *         transp = WriteUnixTransport.new(self, proto, None, waiter)
+ *         transp._add_extra_info('pipe', pipe)
+ *         try:             # <<<<<<<<<<<<<<
+ *             transp._open(pipe.fileno())
+ *             transp._init_protocol()
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    goto __pyx_L9_try_end;
+    __pyx_L4_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":2842
+ *             transp._init_protocol()
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException:
+ */
+    __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+    if (__pyx_t_7) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.connect_write_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 2842, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_3);
+
+      /* "uvloop/loop.pyx":2843
+ *             await waiter
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException:
+ *             transp._close()
+ */
+      __Pyx_GIVEREF(__pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+      __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; 
+      __PYX_ERR(0, 2843, __pyx_L6_except_error)
+    }
+
+    /* "uvloop/loop.pyx":2844
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException:             # <<<<<<<<<<<<<<
+ *             transp._close()
+ *             raise
+ */
+    __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_7) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.connect_write_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 2844, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_1);
+
+      /* "uvloop/loop.pyx":2845
+ *             raise
+ *         except BaseException:
+ *             transp._close()             # <<<<<<<<<<<<<<
+ *             raise
+ *         transp._attach_fileobj(pipe)
+ */
+      __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_transp)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2845, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "uvloop/loop.pyx":2846
+ *         except BaseException:
+ *             transp._close()
+ *             raise             # <<<<<<<<<<<<<<
+ *         transp._attach_fileobj(pipe)
+ *         return transp, proto
+ */
+      __Pyx_GIVEREF(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_1);
+      __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_2, __pyx_t_1);
+      __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; 
+      __PYX_ERR(0, 2846, __pyx_L6_except_error)
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/loop.pyx":2838
+ *         transp = WriteUnixTransport.new(self, proto, None, waiter)
+ *         transp._add_extra_info('pipe', pipe)
+ *         try:             # <<<<<<<<<<<<<<
+ *             transp._open(pipe.fileno())
+ *             transp._init_protocol()
+ */
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L1_error;
+    __pyx_L9_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":2847
+ *             transp._close()
+ *             raise
+ *         transp._attach_fileobj(pipe)             # <<<<<<<<<<<<<<
+ *         return transp, proto
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_transp), __pyx_cur_scope->__pyx_v_pipe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2847, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2848
+ *             raise
+ *         transp._attach_fileobj(pipe)
+ *         return transp, proto             # <<<<<<<<<<<<<<
+ * 
+ *     def add_signal_handler(self, sig, callback, *args):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2848, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_transp));
+  __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_transp));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_transp));
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_cur_scope->__pyx_v_proto);
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2824
+ * 
+ *     @cython.iterable_coroutine
+ *     async def connect_write_pipe(self, proto_factory, pipe):             # <<<<<<<<<<<<<<
+ *         """Register write pipe in event loop.
+ * 
+ */
+
+  /* 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_8);
+  __Pyx_AddTraceback("connect_write_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2850
+ *         return transp, proto
+ * 
+ *     def add_signal_handler(self, sig, callback, *args):             # <<<<<<<<<<<<<<
+ *         """Add a handler for a signal.  UNIX only.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_121add_signal_handler(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_120add_signal_handler[] = "Loop.add_signal_handler(self, sig, callback, *args)\nAdd a handler for a signal.  UNIX only.\n\n        Raise ValueError if the signal number is invalid or uncatchable.\n        Raise RuntimeError if there is a problem setting up the handler.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_121add_signal_handler(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_sig = 0;
+  PyObject *__pyx_v_callback = 0;
+  PyObject *__pyx_v_args = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_signal_handler (wrapper)", 0);
+  if (PyTuple_GET_SIZE(__pyx_args) > 2) {
+    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
+    if (unlikely(!__pyx_v_args)) {
+      __Pyx_RefNannyFinishContext();
+      return NULL;
+    }
+    __Pyx_GOTREF(__pyx_v_args);
+  } else {
+    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
+  }
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sig,&__pyx_n_s_callback,0};
+    PyObject* values[2] = {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) {
+        default:
+        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;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sig)) != 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_callback)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("add_signal_handler", 0, 2, 2, 1); __PYX_ERR(0, 2850, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "add_signal_handler") < 0)) __PYX_ERR(0, 2850, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_sig = values[0];
+    __pyx_v_callback = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("add_signal_handler", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2850, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
+  __Pyx_AddTraceback("uvloop.loop.Loop.add_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_120add_signal_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_sig, __pyx_v_callback, __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_120add_signal_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h = 0;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_v_nexc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  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;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  int __pyx_t_21;
+  char const *__pyx_t_22;
+  PyObject *__pyx_t_23 = NULL;
+  PyObject *__pyx_t_24 = NULL;
+  PyObject *__pyx_t_25 = NULL;
+  PyObject *__pyx_t_26 = NULL;
+  PyObject *__pyx_t_27 = NULL;
+  PyObject *__pyx_t_28 = NULL;
+  char const *__pyx_t_29;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("add_signal_handler", 0);
+
+  /* "uvloop/loop.pyx":2859
+ *             Handle h
+ * 
+ *         if not self._is_main_thread():             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'add_signal_handler() can only be called from '
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__is_main_thread(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2859, __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, 2859, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = ((!__pyx_t_2) != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/loop.pyx":2860
+ * 
+ *         if not self._is_main_thread():
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'add_signal_handler() can only be called from '
+ *                 'the main thread')
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__85, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2860, __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, 2860, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2859
+ *             Handle h
+ * 
+ *         if not self._is_main_thread():             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'add_signal_handler() can only be called from '
+ */
+  }
+
+  /* "uvloop/loop.pyx":2864
+ *                 'the main thread')
+ * 
+ *         if (aio_iscoroutine(callback)             # <<<<<<<<<<<<<<
+ *                 or aio_iscoroutinefunction(callback)):
+ *             raise TypeError(
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_iscoroutine);
+  __pyx_t_4 = __pyx_v_6uvloop_4loop_aio_iscoroutine; __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_callback) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_callback);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2864, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2864, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_3 = __pyx_t_2;
+    goto __pyx_L5_bool_binop_done;
+  }
+
+  /* "uvloop/loop.pyx":2865
+ * 
+ *         if (aio_iscoroutine(callback)
+ *                 or aio_iscoroutinefunction(callback)):             # <<<<<<<<<<<<<<
+ *             raise TypeError(
+ *                 "coroutines cannot be used with add_signal_handler()")
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_iscoroutinefunction);
+  __pyx_t_4 = __pyx_v_6uvloop_4loop_aio_iscoroutinefunction; __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_callback) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_callback);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2865, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2865, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __pyx_t_2;
+  __pyx_L5_bool_binop_done:;
+
+  /* "uvloop/loop.pyx":2864
+ *                 'the main thread')
+ * 
+ *         if (aio_iscoroutine(callback)             # <<<<<<<<<<<<<<
+ *                 or aio_iscoroutinefunction(callback)):
+ *             raise TypeError(
+ */
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/loop.pyx":2866
+ *         if (aio_iscoroutine(callback)
+ *                 or aio_iscoroutinefunction(callback)):
+ *             raise TypeError(             # <<<<<<<<<<<<<<
+ *                 "coroutines cannot be used with add_signal_handler()")
+ * 
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__86, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2866, __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, 2866, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2864
+ *                 'the main thread')
+ * 
+ *         if (aio_iscoroutine(callback)             # <<<<<<<<<<<<<<
+ *                 or aio_iscoroutinefunction(callback)):
+ *             raise TypeError(
+ */
+  }
+
+  /* "uvloop/loop.pyx":2869
+ *                 "coroutines cannot be used with add_signal_handler()")
+ * 
+ *         if sig == uv.SIGCHLD:             # <<<<<<<<<<<<<<
+ *             if (hasattr(callback, '__self__') and
+ *                     isinstance(callback.__self__, aio_AbstractChildWatcher)):
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_int(SIGCHLD); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2869, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = PyObject_RichCompare(__pyx_v_sig, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2869, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2869, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":2870
+ * 
+ *         if sig == uv.SIGCHLD:
+ *             if (hasattr(callback, '__self__') and             # <<<<<<<<<<<<<<
+ *                     isinstance(callback.__self__, aio_AbstractChildWatcher)):
+ * 
+ */
+    __pyx_t_2 = __Pyx_HasAttr(__pyx_v_callback, __pyx_n_u_self); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 2870, __pyx_L1_error)
+    __pyx_t_6 = (__pyx_t_2 != 0);
+    if (__pyx_t_6) {
+    } else {
+      __pyx_t_3 = __pyx_t_6;
+      goto __pyx_L9_bool_binop_done;
+    }
+
+    /* "uvloop/loop.pyx":2871
+ *         if sig == uv.SIGCHLD:
+ *             if (hasattr(callback, '__self__') and
+ *                     isinstance(callback.__self__, aio_AbstractChildWatcher)):             # <<<<<<<<<<<<<<
+ * 
+ *                 warnings_warn(
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_callback, __pyx_n_s_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2871, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_1 = __pyx_v_6uvloop_4loop_aio_AbstractChildWatcher;
+    __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_6 = PyObject_IsInstance(__pyx_t_4, __pyx_t_1); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 2871, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_2 = (__pyx_t_6 != 0);
+    __pyx_t_3 = __pyx_t_2;
+    __pyx_L9_bool_binop_done:;
+
+    /* "uvloop/loop.pyx":2870
+ * 
+ *         if sig == uv.SIGCHLD:
+ *             if (hasattr(callback, '__self__') and             # <<<<<<<<<<<<<<
+ *                     isinstance(callback.__self__, aio_AbstractChildWatcher)):
+ * 
+ */
+    if (__pyx_t_3) {
+
+      /* "uvloop/loop.pyx":2879
+ *                     "The correct way to use uvloop is to install its policy: "
+ *                     "`asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())`"
+ *                     "\n\n", RuntimeWarning, source=self)             # <<<<<<<<<<<<<<
+ * 
+ *                 # TODO: ideally we should always raise an error here,
+ */
+      __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2879, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_source, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(0, 2879, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2873
+ *                     isinstance(callback.__self__, aio_AbstractChildWatcher)):
+ * 
+ *                 warnings_warn(             # <<<<<<<<<<<<<<
+ *                     "!!! asyncio is trying to install its ChildWatcher for "
+ *                     "SIGCHLD signal !!!\n\nThis is probably because a uvloop "
+ */
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_warnings_warn, __pyx_tuple__87, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2873, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":2886
+ *                 # in our README.  Need to start a deprecation period
+ *                 # at some point to turn this warning into an error.
+ *                 return             # <<<<<<<<<<<<<<
+ * 
+ *             raise RuntimeError(
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+
+      /* "uvloop/loop.pyx":2870
+ * 
+ *         if sig == uv.SIGCHLD:
+ *             if (hasattr(callback, '__self__') and             # <<<<<<<<<<<<<<
+ *                     isinstance(callback.__self__, aio_AbstractChildWatcher)):
+ * 
+ */
+    }
+
+    /* "uvloop/loop.pyx":2888
+ *                 return
+ * 
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'cannot add a signal handler for SIGCHLD: it is used '
+ *                 'by the event loop to track subprocesses')
+ */
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__88, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2888, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(0, 2888, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2869
+ *                 "coroutines cannot be used with add_signal_handler()")
+ * 
+ *         if sig == uv.SIGCHLD:             # <<<<<<<<<<<<<<
+ *             if (hasattr(callback, '__self__') and
+ *                     isinstance(callback.__self__, aio_AbstractChildWatcher)):
+ */
+  }
+
+  /* "uvloop/loop.pyx":2892
+ *                 'by the event loop to track subprocesses')
+ * 
+ *         self._check_signal(sig)             # <<<<<<<<<<<<<<
+ *         self._check_closed()
+ * 
+ */
+  __pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__check_signal(__pyx_v_self, __pyx_v_sig); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2892, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2893
+ * 
+ *         self._check_signal(sig)
+ *         self._check_closed()             # <<<<<<<<<<<<<<
+ * 
+ *         h = new_Handle(self, callback, args or None, None)
+ */
+  __pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2893, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":2895
+ *         self._check_closed()
+ * 
+ *         h = new_Handle(self, callback, args or None, None)             # <<<<<<<<<<<<<<
+ *         self._signal_handlers[sig] = h
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_args); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2895, __pyx_L1_error)
+  if (!__pyx_t_3) {
+  } else {
+    __Pyx_INCREF(__pyx_v_args);
+    __pyx_t_4 = __pyx_v_args;
+    goto __pyx_L11_bool_binop_done;
+  }
+  __Pyx_INCREF(Py_None);
+  __pyx_t_4 = Py_None;
+  __pyx_L11_bool_binop_done:;
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_new_Handle(__pyx_v_self, __pyx_v_callback, __pyx_t_4, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2895, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(0, 2895, __pyx_L1_error)
+  __pyx_v_h = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2896
+ * 
+ *         h = new_Handle(self, callback, args or None, None)
+ *         self._signal_handlers[sig] = h             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  if (unlikely(__pyx_v_self->_signal_handlers == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(0, 2896, __pyx_L1_error)
+  }
+  if (unlikely(PyDict_SetItem(__pyx_v_self->_signal_handlers, __pyx_v_sig, ((PyObject *)__pyx_v_h)) < 0)) __PYX_ERR(0, 2896, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2898
+ *         self._signal_handlers[sig] = h
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             # Register a dummy signal handler to ask Python to write the signal
+ *             # number in the wakeup file descriptor.
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
+    __Pyx_XGOTREF(__pyx_t_7);
+    __Pyx_XGOTREF(__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_9);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":2901
+ *             # Register a dummy signal handler to ask Python to write the signal
+ *             # number in the wakeup file descriptor.
+ *             signal_signal(sig, self.__sighandler)             # <<<<<<<<<<<<<<
+ * 
+ *             # Set SA_RESTART to limit EINTR occurrences.
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_sighandler); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2901, __pyx_L13_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_signal);
+      __pyx_t_5 = __pyx_v_6uvloop_4loop_signal_signal; __pyx_t_10 = NULL;
+      __pyx_t_11 = 0;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_10)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_10);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+          __pyx_t_11 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_sig, __pyx_t_4};
+        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2901, __pyx_L13_error)
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_sig, __pyx_t_4};
+        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2901, __pyx_L13_error)
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2901, __pyx_L13_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        if (__pyx_t_10) {
+          __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL;
+        }
+        __Pyx_INCREF(__pyx_v_sig);
+        __Pyx_GIVEREF(__pyx_v_sig);
+        PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_11, __pyx_v_sig);
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_t_4);
+        __pyx_t_4 = 0;
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2901, __pyx_L13_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":2904
+ * 
+ *             # Set SA_RESTART to limit EINTR occurrences.
+ *             signal_siginterrupt(sig, False)             # <<<<<<<<<<<<<<
+ *         except OSError as exc:
+ *             del self._signal_handlers[sig]
+ */
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_siginterrupt);
+      __pyx_t_5 = __pyx_v_6uvloop_4loop_signal_siginterrupt; __pyx_t_12 = NULL;
+      __pyx_t_11 = 0;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_12)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_12);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+          __pyx_t_11 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_v_sig, Py_False};
+        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2904, __pyx_L13_error)
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_v_sig, Py_False};
+        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2904, __pyx_L13_error)
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+      } else
+      #endif
+      {
+        __pyx_t_4 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2904, __pyx_L13_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        if (__pyx_t_12) {
+          __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_12); __pyx_t_12 = NULL;
+        }
+        __Pyx_INCREF(__pyx_v_sig);
+        __Pyx_GIVEREF(__pyx_v_sig);
+        PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_11, __pyx_v_sig);
+        __Pyx_INCREF(Py_False);
+        __Pyx_GIVEREF(Py_False);
+        PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_11, Py_False);
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2904, __pyx_L13_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":2898
+ *         self._signal_handlers[sig] = h
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             # Register a dummy signal handler to ask Python to write the signal
+ *             # number in the wakeup file descriptor.
+ */
+    }
+    __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;
+    goto __pyx_L18_try_end;
+    __pyx_L13_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/loop.pyx":2905
+ *             # Set SA_RESTART to limit EINTR occurrences.
+ *             signal_siginterrupt(sig, False)
+ *         except OSError as exc:             # <<<<<<<<<<<<<<
+ *             del self._signal_handlers[sig]
+ *             if not self._signal_handlers:
+ */
+    __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
+    if (__pyx_t_11) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.add_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(0, 2905, __pyx_L15_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_v_exc = __pyx_t_5;
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":2906
+ *             signal_siginterrupt(sig, False)
+ *         except OSError as exc:
+ *             del self._signal_handlers[sig]             # <<<<<<<<<<<<<<
+ *             if not self._signal_handlers:
+ *                 try:
+ */
+        if (unlikely(__pyx_v_self->_signal_handlers == Py_None)) {
+          PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+          __PYX_ERR(0, 2906, __pyx_L24_error)
+        }
+        if (unlikely(PyDict_DelItem(__pyx_v_self->_signal_handlers, __pyx_v_sig) < 0)) __PYX_ERR(0, 2906, __pyx_L24_error)
+
+        /* "uvloop/loop.pyx":2907
+ *         except OSError as exc:
+ *             del self._signal_handlers[sig]
+ *             if not self._signal_handlers:             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     signal_set_wakeup_fd(-1)
+ */
+        __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->_signal_handlers); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2907, __pyx_L24_error)
+        __pyx_t_2 = ((!__pyx_t_3) != 0);
+        if (__pyx_t_2) {
+
+          /* "uvloop/loop.pyx":2908
+ *             del self._signal_handlers[sig]
+ *             if not self._signal_handlers:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     signal_set_wakeup_fd(-1)
+ *                 except (ValueError, OSError) as nexc:
+ */
+          {
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_13);
+            __Pyx_XGOTREF(__pyx_t_14);
+            __Pyx_XGOTREF(__pyx_t_15);
+            /*try:*/ {
+
+              /* "uvloop/loop.pyx":2909
+ *             if not self._signal_handlers:
+ *                 try:
+ *                     signal_set_wakeup_fd(-1)             # <<<<<<<<<<<<<<
+ *                 except (ValueError, OSError) as nexc:
+ *                     aio_logger.info('set_wakeup_fd(-1) failed: %s', nexc)
+ */
+              __Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_set_wakeup_fd);
+              __pyx_t_10 = __pyx_v_6uvloop_4loop_signal_set_wakeup_fd; __pyx_t_16 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) {
+                __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_10);
+                if (likely(__pyx_t_16)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+                  __Pyx_INCREF(__pyx_t_16);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_10, function);
+                }
+              }
+              __pyx_t_12 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_16, __pyx_int_neg_1) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_int_neg_1);
+              __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+              if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2909, __pyx_L27_error)
+              __Pyx_GOTREF(__pyx_t_12);
+              __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+
+              /* "uvloop/loop.pyx":2908
+ *             del self._signal_handlers[sig]
+ *             if not self._signal_handlers:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     signal_set_wakeup_fd(-1)
+ *                 except (ValueError, OSError) as nexc:
+ */
+            }
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+            goto __pyx_L34_try_end;
+            __pyx_L27_error:;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+            /* "uvloop/loop.pyx":2910
+ *                 try:
+ *                     signal_set_wakeup_fd(-1)
+ *                 except (ValueError, OSError) as nexc:             # <<<<<<<<<<<<<<
+ *                     aio_logger.info('set_wakeup_fd(-1) failed: %s', nexc)
+ * 
+ */
+            __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
+            if (__pyx_t_11) {
+              __Pyx_AddTraceback("uvloop.loop.Loop.add_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+              if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_10, &__pyx_t_16) < 0) __PYX_ERR(0, 2910, __pyx_L29_except_error)
+              __Pyx_GOTREF(__pyx_t_12);
+              __Pyx_GOTREF(__pyx_t_10);
+              __Pyx_GOTREF(__pyx_t_16);
+              __Pyx_INCREF(__pyx_t_10);
+              __pyx_v_nexc = __pyx_t_10;
+              /*try:*/ {
+
+                /* "uvloop/loop.pyx":2911
+ *                     signal_set_wakeup_fd(-1)
+ *                 except (ValueError, OSError) as nexc:
+ *                     aio_logger.info('set_wakeup_fd(-1) failed: %s', nexc)             # <<<<<<<<<<<<<<
+ * 
+ *             if exc.errno == errno_EINVAL:
+ */
+                __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_info); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2911, __pyx_L40_error)
+                __Pyx_GOTREF(__pyx_t_18);
+                __pyx_t_19 = NULL;
+                __pyx_t_11 = 0;
+                if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_18))) {
+                  __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_18);
+                  if (likely(__pyx_t_19)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_18);
+                    __Pyx_INCREF(__pyx_t_19);
+                    __Pyx_INCREF(function);
+                    __Pyx_DECREF_SET(__pyx_t_18, function);
+                    __pyx_t_11 = 1;
+                  }
+                }
+                #if CYTHON_FAST_PYCALL
+                if (PyFunction_Check(__pyx_t_18)) {
+                  PyObject *__pyx_temp[3] = {__pyx_t_19, __pyx_kp_u_set_wakeup_fd_1_failed_s, __pyx_v_nexc};
+                  __pyx_t_17 = __Pyx_PyFunction_FastCall(__pyx_t_18, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2911, __pyx_L40_error)
+                  __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+                  __Pyx_GOTREF(__pyx_t_17);
+                } else
+                #endif
+                #if CYTHON_FAST_PYCCALL
+                if (__Pyx_PyFastCFunction_Check(__pyx_t_18)) {
+                  PyObject *__pyx_temp[3] = {__pyx_t_19, __pyx_kp_u_set_wakeup_fd_1_failed_s, __pyx_v_nexc};
+                  __pyx_t_17 = __Pyx_PyCFunction_FastCall(__pyx_t_18, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2911, __pyx_L40_error)
+                  __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+                  __Pyx_GOTREF(__pyx_t_17);
+                } else
+                #endif
+                {
+                  __pyx_t_20 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 2911, __pyx_L40_error)
+                  __Pyx_GOTREF(__pyx_t_20);
+                  if (__pyx_t_19) {
+                    __Pyx_GIVEREF(__pyx_t_19); PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_19); __pyx_t_19 = NULL;
+                  }
+                  __Pyx_INCREF(__pyx_kp_u_set_wakeup_fd_1_failed_s);
+                  __Pyx_GIVEREF(__pyx_kp_u_set_wakeup_fd_1_failed_s);
+                  PyTuple_SET_ITEM(__pyx_t_20, 0+__pyx_t_11, __pyx_kp_u_set_wakeup_fd_1_failed_s);
+                  __Pyx_INCREF(__pyx_v_nexc);
+                  __Pyx_GIVEREF(__pyx_v_nexc);
+                  PyTuple_SET_ITEM(__pyx_t_20, 1+__pyx_t_11, __pyx_v_nexc);
+                  __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_18, __pyx_t_20, NULL); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2911, __pyx_L40_error)
+                  __Pyx_GOTREF(__pyx_t_17);
+                  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+                }
+                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+                __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
+              }
+
+              /* "uvloop/loop.pyx":2910
+ *                 try:
+ *                     signal_set_wakeup_fd(-1)
+ *                 except (ValueError, OSError) as nexc:             # <<<<<<<<<<<<<<
+ *                     aio_logger.info('set_wakeup_fd(-1) failed: %s', nexc)
+ * 
+ */
+              /*finally:*/ {
+                /*normal exit:*/{
+                  __Pyx_DECREF(__pyx_v_nexc);
+                  __pyx_v_nexc = NULL;
+                  goto __pyx_L41;
+                }
+                __pyx_L40_error:;
+                /*exception exit:*/{
+                  __Pyx_PyThreadState_declare
+                  __Pyx_PyThreadState_assign
+                  __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0;
+                  __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
+                  __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+                  __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+                  __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+                  if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_26, &__pyx_t_27, &__pyx_t_28);
+                  if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_23, &__pyx_t_24, &__pyx_t_25) < 0)) __Pyx_ErrFetch(&__pyx_t_23, &__pyx_t_24, &__pyx_t_25);
+                  __Pyx_XGOTREF(__pyx_t_23);
+                  __Pyx_XGOTREF(__pyx_t_24);
+                  __Pyx_XGOTREF(__pyx_t_25);
+                  __Pyx_XGOTREF(__pyx_t_26);
+                  __Pyx_XGOTREF(__pyx_t_27);
+                  __Pyx_XGOTREF(__pyx_t_28);
+                  __pyx_t_11 = __pyx_lineno; __pyx_t_21 = __pyx_clineno; __pyx_t_22 = __pyx_filename;
+                  {
+                    __Pyx_DECREF(__pyx_v_nexc);
+                    __pyx_v_nexc = NULL;
+                  }
+                  if (PY_MAJOR_VERSION >= 3) {
+                    __Pyx_XGIVEREF(__pyx_t_26);
+                    __Pyx_XGIVEREF(__pyx_t_27);
+                    __Pyx_XGIVEREF(__pyx_t_28);
+                    __Pyx_ExceptionReset(__pyx_t_26, __pyx_t_27, __pyx_t_28);
+                  }
+                  __Pyx_XGIVEREF(__pyx_t_23);
+                  __Pyx_XGIVEREF(__pyx_t_24);
+                  __Pyx_XGIVEREF(__pyx_t_25);
+                  __Pyx_ErrRestore(__pyx_t_23, __pyx_t_24, __pyx_t_25);
+                  __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0;
+                  __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_21; __pyx_filename = __pyx_t_22;
+                  goto __pyx_L29_except_error;
+                }
+                __pyx_L41:;
+              }
+              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+              goto __pyx_L28_exception_handled;
+            }
+            goto __pyx_L29_except_error;
+            __pyx_L29_except_error:;
+
+            /* "uvloop/loop.pyx":2908
+ *             del self._signal_handlers[sig]
+ *             if not self._signal_handlers:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     signal_set_wakeup_fd(-1)
+ *                 except (ValueError, OSError) as nexc:
+ */
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+            goto __pyx_L24_error;
+            __pyx_L28_exception_handled:;
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+            __pyx_L34_try_end:;
+          }
+
+          /* "uvloop/loop.pyx":2907
+ *         except OSError as exc:
+ *             del self._signal_handlers[sig]
+ *             if not self._signal_handlers:             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     signal_set_wakeup_fd(-1)
+ */
+        }
+
+        /* "uvloop/loop.pyx":2913
+ *                     aio_logger.info('set_wakeup_fd(-1) failed: %s', nexc)
+ * 
+ *             if exc.errno == errno_EINVAL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError('sig {} cannot be caught'.format(sig))
+ *             else:
+ */
+        __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_exc, __pyx_n_s_errno); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2913, __pyx_L24_error)
+        __Pyx_GOTREF(__pyx_t_16);
+        __pyx_t_10 = PyObject_RichCompare(__pyx_t_16, __pyx_v_6uvloop_4loop_errno_EINVAL, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2913, __pyx_L24_error)
+        __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+        __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2913, __pyx_L24_error)
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        if (unlikely(__pyx_t_2)) {
+
+          /* "uvloop/loop.pyx":2914
+ * 
+ *             if exc.errno == errno_EINVAL:
+ *                 raise RuntimeError('sig {} cannot be caught'.format(sig))             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise
+ */
+          __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_sig_cannot_be_caught, __pyx_n_s_format); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2914, __pyx_L24_error)
+          __Pyx_GOTREF(__pyx_t_16);
+          __pyx_t_12 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_16))) {
+            __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_16);
+            if (likely(__pyx_t_12)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16);
+              __Pyx_INCREF(__pyx_t_12);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_16, function);
+            }
+          }
+          __pyx_t_10 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_12, __pyx_v_sig) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sig);
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2914, __pyx_L24_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+          __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2914, __pyx_L24_error)
+          __Pyx_GOTREF(__pyx_t_16);
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+          __Pyx_Raise(__pyx_t_16, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+          __PYX_ERR(0, 2914, __pyx_L24_error)
+
+          /* "uvloop/loop.pyx":2913
+ *                     aio_logger.info('set_wakeup_fd(-1) failed: %s', nexc)
+ * 
+ *             if exc.errno == errno_EINVAL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError('sig {} cannot be caught'.format(sig))
+ *             else:
+ */
+        }
+
+        /* "uvloop/loop.pyx":2916
+ *                 raise RuntimeError('sig {} cannot be caught'.format(sig))
+ *             else:
+ *                 raise             # <<<<<<<<<<<<<<
+ * 
+ *     def remove_signal_handler(self, sig):
+ */
+        /*else*/ {
+          __Pyx_GIVEREF(__pyx_t_1);
+          __Pyx_GIVEREF(__pyx_t_5);
+          __Pyx_XGIVEREF(__pyx_t_4);
+          __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_5, __pyx_t_4);
+          __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; 
+          __PYX_ERR(0, 2916, __pyx_L24_error)
+        }
+      }
+
+      /* "uvloop/loop.pyx":2905
+ *             # Set SA_RESTART to limit EINTR occurrences.
+ *             signal_siginterrupt(sig, False)
+ *         except OSError as exc:             # <<<<<<<<<<<<<<
+ *             del self._signal_handlers[sig]
+ *             if not self._signal_handlers:
+ */
+      /*finally:*/ {
+        __pyx_L24_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0; __pyx_t_28 = 0; __pyx_t_27 = 0; __pyx_t_26 = 0;
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+          __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
+          __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+          __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+          __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_28, &__pyx_t_27, &__pyx_t_26);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_28);
+          __Pyx_XGOTREF(__pyx_t_27);
+          __Pyx_XGOTREF(__pyx_t_26);
+          __pyx_t_21 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_29 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_28);
+            __Pyx_XGIVEREF(__pyx_t_27);
+            __Pyx_XGIVEREF(__pyx_t_26);
+            __Pyx_ExceptionReset(__pyx_t_28, __pyx_t_27, __pyx_t_26);
+          }
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_ErrRestore(__pyx_t_15, __pyx_t_14, __pyx_t_13);
+          __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0; __pyx_t_28 = 0; __pyx_t_27 = 0; __pyx_t_26 = 0;
+          __pyx_lineno = __pyx_t_21; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_29;
+          goto __pyx_L15_except_error;
+        }
+      }
+    }
+    goto __pyx_L15_except_error;
+    __pyx_L15_except_error:;
+
+    /* "uvloop/loop.pyx":2898
+ *         self._signal_handlers[sig] = h
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             # Register a dummy signal handler to ask Python to write the signal
+ *             # number in the wakeup file descriptor.
+ */
+    __Pyx_XGIVEREF(__pyx_t_7);
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+    goto __pyx_L1_error;
+    __pyx_L18_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":2850
+ *         return transp, proto
+ * 
+ *     def add_signal_handler(self, sig, callback, *args):             # <<<<<<<<<<<<<<
+ *         """Add a handler for a signal.  UNIX only.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_16);
+  __Pyx_XDECREF(__pyx_t_17);
+  __Pyx_XDECREF(__pyx_t_18);
+  __Pyx_XDECREF(__pyx_t_19);
+  __Pyx_XDECREF(__pyx_t_20);
+  __Pyx_AddTraceback("uvloop.loop.Loop.add_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_h);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XDECREF(__pyx_v_nexc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2918
+ *                 raise
+ * 
+ *     def remove_signal_handler(self, sig):             # <<<<<<<<<<<<<<
+ *         """Remove a handler for a signal.  UNIX only.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_123remove_signal_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_sig); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_122remove_signal_handler[] = "Loop.remove_signal_handler(self, sig)\nRemove a handler for a signal.  UNIX only.\n\n        Return True if a signal handler was removed, False if not.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_123remove_signal_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_sig) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("remove_signal_handler (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_122remove_signal_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_sig));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_122remove_signal_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig) {
+  PyObject *__pyx_v_handler = NULL;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  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_t_13;
+  char const *__pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("remove_signal_handler", 0);
+
+  /* "uvloop/loop.pyx":2924
+ *         """
+ * 
+ *         if not self._is_main_thread():             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'remove_signal_handler() can only be called from '
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__is_main_thread(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2924, __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, 2924, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = ((!__pyx_t_2) != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/loop.pyx":2925
+ * 
+ *         if not self._is_main_thread():
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'remove_signal_handler() can only be called from '
+ *                 'the main thread')
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__89, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2925, __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, 2925, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":2924
+ *         """
+ * 
+ *         if not self._is_main_thread():             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'remove_signal_handler() can only be called from '
+ */
+  }
+
+  /* "uvloop/loop.pyx":2929
+ *                 'the main thread')
+ * 
+ *         self._check_signal(sig)             # <<<<<<<<<<<<<<
+ * 
+ *         if not self._listening_signals:
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_signal(__pyx_v_self, __pyx_v_sig); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2929, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":2931
+ *         self._check_signal(sig)
+ * 
+ *         if not self._listening_signals:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+  __pyx_t_3 = ((!(__pyx_v_self->_listening_signals != 0)) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":2932
+ * 
+ *         if not self._listening_signals:
+ *             return False             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_False);
+    __pyx_r = Py_False;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":2931
+ *         self._check_signal(sig)
+ * 
+ *         if not self._listening_signals:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":2934
+ *             return False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             del self._signal_handlers[sig]
+ *         except KeyError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_6);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":2935
+ * 
+ *         try:
+ *             del self._signal_handlers[sig]             # <<<<<<<<<<<<<<
+ *         except KeyError:
+ *             return False
+ */
+      if (unlikely(__pyx_v_self->_signal_handlers == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 2935, __pyx_L5_error)
+      }
+      if (unlikely(PyDict_DelItem(__pyx_v_self->_signal_handlers, __pyx_v_sig) < 0)) __PYX_ERR(0, 2935, __pyx_L5_error)
+
+      /* "uvloop/loop.pyx":2934
+ *             return False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             del self._signal_handlers[sig]
+ *         except KeyError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L5_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":2936
+ *         try:
+ *             del self._signal_handlers[sig]
+ *         except KeyError:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+    __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_7) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.remove_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(0, 2936, __pyx_L7_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_GOTREF(__pyx_t_9);
+
+      /* "uvloop/loop.pyx":2937
+ *             del self._signal_handlers[sig]
+ *         except KeyError:
+ *             return False             # <<<<<<<<<<<<<<
+ * 
+ *         if sig == uv.SIGINT:
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __Pyx_INCREF(Py_False);
+      __pyx_r = Py_False;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      goto __pyx_L8_except_return;
+    }
+    goto __pyx_L7_except_error;
+    __pyx_L7_except_error:;
+
+    /* "uvloop/loop.pyx":2934
+ *             return False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             del self._signal_handlers[sig]
+ *         except KeyError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L1_error;
+    __pyx_L8_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L0;
+    __pyx_L10_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":2939
+ *             return False
+ * 
+ *         if sig == uv.SIGINT:             # <<<<<<<<<<<<<<
+ *             handler = signal_default_int_handler
+ *         else:
+ */
+  __pyx_t_9 = __Pyx_PyInt_From_int(SIGINT); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2939, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __pyx_t_8 = PyObject_RichCompare(__pyx_v_sig, __pyx_t_9, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2939, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2939, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":2940
+ * 
+ *         if sig == uv.SIGINT:
+ *             handler = signal_default_int_handler             # <<<<<<<<<<<<<<
+ *         else:
+ *             handler = signal_SIG_DFL
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_default_int_handler);
+    __pyx_v_handler = __pyx_v_6uvloop_4loop_signal_default_int_handler;
+
+    /* "uvloop/loop.pyx":2939
+ *             return False
+ * 
+ *         if sig == uv.SIGINT:             # <<<<<<<<<<<<<<
+ *             handler = signal_default_int_handler
+ *         else:
+ */
+    goto __pyx_L13;
+  }
+
+  /* "uvloop/loop.pyx":2942
+ *             handler = signal_default_int_handler
+ *         else:
+ *             handler = signal_SIG_DFL             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  /*else*/ {
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_SIG_DFL);
+    __pyx_v_handler = __pyx_v_6uvloop_4loop_signal_SIG_DFL;
+  }
+  __pyx_L13:;
+
+  /* "uvloop/loop.pyx":2944
+ *             handler = signal_SIG_DFL
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             signal_signal(sig, handler)
+ *         except OSError as exc:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":2945
+ * 
+ *         try:
+ *             signal_signal(sig, handler)             # <<<<<<<<<<<<<<
+ *         except OSError as exc:
+ *             if exc.errno == errno_EINVAL:
+ */
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_signal);
+      __pyx_t_9 = __pyx_v_6uvloop_4loop_signal_signal; __pyx_t_1 = NULL;
+      __pyx_t_7 = 0;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9);
+        if (likely(__pyx_t_1)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+          __Pyx_INCREF(__pyx_t_1);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_9, function);
+          __pyx_t_7 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_9)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_sig, __pyx_v_handler};
+        __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2945, __pyx_L14_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_8);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_sig, __pyx_v_handler};
+        __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2945, __pyx_L14_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_8);
+      } else
+      #endif
+      {
+        __pyx_t_10 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2945, __pyx_L14_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        if (__pyx_t_1) {
+          __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1); __pyx_t_1 = NULL;
+        }
+        __Pyx_INCREF(__pyx_v_sig);
+        __Pyx_GIVEREF(__pyx_v_sig);
+        PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_7, __pyx_v_sig);
+        __Pyx_INCREF(__pyx_v_handler);
+        __Pyx_GIVEREF(__pyx_v_handler);
+        PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_7, __pyx_v_handler);
+        __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2945, __pyx_L14_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "uvloop/loop.pyx":2944
+ *             handler = signal_SIG_DFL
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             signal_signal(sig, handler)
+ *         except OSError as exc:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L19_try_end;
+    __pyx_L14_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/loop.pyx":2946
+ *         try:
+ *             signal_signal(sig, handler)
+ *         except OSError as exc:             # <<<<<<<<<<<<<<
+ *             if exc.errno == errno_EINVAL:
+ *                 raise RuntimeError('sig {} cannot be caught'.format(sig))
+ */
+    __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
+    if (__pyx_t_7) {
+      __Pyx_AddTraceback("uvloop.loop.Loop.remove_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10) < 0) __PYX_ERR(0, 2946, __pyx_L16_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_GOTREF(__pyx_t_10);
+      __Pyx_INCREF(__pyx_t_9);
+      __pyx_v_exc = __pyx_t_9;
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":2947
+ *             signal_signal(sig, handler)
+ *         except OSError as exc:
+ *             if exc.errno == errno_EINVAL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError('sig {} cannot be caught'.format(sig))
+ *             else:
+ */
+        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_exc, __pyx_n_s_errno); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2947, __pyx_L25_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_11 = PyObject_RichCompare(__pyx_t_1, __pyx_v_6uvloop_4loop_errno_EINVAL, Py_EQ); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2947, __pyx_L25_error)
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2947, __pyx_L25_error)
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        if (unlikely(__pyx_t_3)) {
+
+          /* "uvloop/loop.pyx":2948
+ *         except OSError as exc:
+ *             if exc.errno == errno_EINVAL:
+ *                 raise RuntimeError('sig {} cannot be caught'.format(sig))             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise
+ */
+          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_sig_cannot_be_caught, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2948, __pyx_L25_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __pyx_t_12 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+            __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_1);
+            if (likely(__pyx_t_12)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+              __Pyx_INCREF(__pyx_t_12);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_1, function);
+            }
+          }
+          __pyx_t_11 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_12, __pyx_v_sig) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_sig);
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2948, __pyx_L25_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2948, __pyx_L25_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __PYX_ERR(0, 2948, __pyx_L25_error)
+
+          /* "uvloop/loop.pyx":2947
+ *             signal_signal(sig, handler)
+ *         except OSError as exc:
+ *             if exc.errno == errno_EINVAL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError('sig {} cannot be caught'.format(sig))
+ *             else:
+ */
+        }
+
+        /* "uvloop/loop.pyx":2950
+ *                 raise RuntimeError('sig {} cannot be caught'.format(sig))
+ *             else:
+ *                 raise             # <<<<<<<<<<<<<<
+ * 
+ *         return True
+ */
+        /*else*/ {
+          __Pyx_GIVEREF(__pyx_t_8);
+          __Pyx_GIVEREF(__pyx_t_9);
+          __Pyx_XGIVEREF(__pyx_t_10);
+          __Pyx_ErrRestoreWithState(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+          __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; 
+          __PYX_ERR(0, 2950, __pyx_L25_error)
+        }
+      }
+
+      /* "uvloop/loop.pyx":2946
+ *         try:
+ *             signal_signal(sig, handler)
+ *         except OSError as exc:             # <<<<<<<<<<<<<<
+ *             if exc.errno == errno_EINVAL:
+ *                 raise RuntimeError('sig {} cannot be caught'.format(sig))
+ */
+      /*finally:*/ {
+        __pyx_L25_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_20);
+          __pyx_t_7 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+          }
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+          __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+          __pyx_lineno = __pyx_t_7; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
+          goto __pyx_L16_except_error;
+        }
+      }
+    }
+    goto __pyx_L16_except_error;
+    __pyx_L16_except_error:;
+
+    /* "uvloop/loop.pyx":2944
+ *             handler = signal_SIG_DFL
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             signal_signal(sig, handler)
+ *         except OSError as exc:
+ */
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_5, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L19_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":2952
+ *                 raise
+ * 
+ *         return True             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(Py_True);
+  __pyx_r = Py_True;
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":2918
+ *                 raise
+ * 
+ *     def remove_signal_handler(self, sig):             # <<<<<<<<<<<<<<
+ *         """Remove a handler for a signal.  UNIX only.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("uvloop.loop.Loop.remove_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_handler);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_126generator18(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":2955
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_datagram_endpoint(self, protocol_factory,             # <<<<<<<<<<<<<<
+ *                                        local_addr=None, remote_addr=None, *,
+ *                                        family=0, proto=0, flags=0,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_125create_datagram_endpoint(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_124create_datagram_endpoint[] = "Loop.create_datagram_endpoint(self, protocol_factory, local_addr=None, remote_addr=None, *, family=0, proto=0, flags=0, reuse_address=_unset, reuse_port=None, allow_broadcast=None, sock=None)\nA coroutine which creates a datagram endpoint.\n\n        This method will try to establish the endpoint in the background.\n        When successful, the coroutine returns a (transport, protocol) pair.\n\n        protocol_factory must be a callable returning a protocol instance.\n\n        socket family AF_INET or socket.AF_INET6 depending on host (or\n        family if specified), socket type SOCK_DGRAM.\n\n        reuse_port tells the kernel to allow this endpoint to be bound to\n        the same port as other existing endpoints are bound to, so long as\n        they all set this flag when being created. This option is not\n        supported on Windows and some UNIX's. If the\n        :py:data:`~socket.SO_REUSEPORT` constant is not defined then this\n        capability is unsupported.\n\n        allow_broadcast tells the kernel to allow this endpoint to send\n        messages to the broadcast address.\n\n        sock can optionally be specified in order to use a preexisting\n        socket object.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_125create_datagram_endpoint(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_protocol_factory = 0;
+  PyObject *__pyx_v_local_addr = 0;
+  PyObject *__pyx_v_remote_addr = 0;
+  PyObject *__pyx_v_family = 0;
+  PyObject *__pyx_v_proto = 0;
+  PyObject *__pyx_v_flags = 0;
+  PyObject *__pyx_v_reuse_address = 0;
+  PyObject *__pyx_v_reuse_port = 0;
+  PyObject *__pyx_v_allow_broadcast = 0;
+  PyObject *__pyx_v_sock = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_datagram_endpoint (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_local_addr,&__pyx_n_s_remote_addr,&__pyx_n_s_family,&__pyx_n_s_proto,&__pyx_n_s_flags,&__pyx_n_s_reuse_address,&__pyx_n_s_reuse_port,&__pyx_n_s_allow_broadcast,&__pyx_n_s_sock,0};
+    PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0};
+
+    /* "uvloop/loop.pyx":2956
+ *     @cython.iterable_coroutine
+ *     async def create_datagram_endpoint(self, protocol_factory,
+ *                                        local_addr=None, remote_addr=None, *,             # <<<<<<<<<<<<<<
+ *                                        family=0, proto=0, flags=0,
+ *                                        reuse_address=_unset, reuse_port=None,
+ */
+    values[1] = ((PyObject *)Py_None);
+    values[2] = ((PyObject *)Py_None);
+    values[3] = ((PyObject *)__pyx_int_0);
+    values[4] = ((PyObject *)__pyx_int_0);
+    values[5] = ((PyObject *)__pyx_int_0);
+    values[6] = __pyx_k__90;
+
+    /* "uvloop/loop.pyx":2958
+ *                                        local_addr=None, remote_addr=None, *,
+ *                                        family=0, proto=0, flags=0,
+ *                                        reuse_address=_unset, reuse_port=None,             # <<<<<<<<<<<<<<
+ *                                        allow_broadcast=None, sock=None):
+ *         """A coroutine which creates a datagram endpoint.
+ */
+    values[7] = ((PyObject *)Py_None);
+
+    /* "uvloop/loop.pyx":2959
+ *                                        family=0, proto=0, flags=0,
+ *                                        reuse_address=_unset, reuse_port=None,
+ *                                        allow_broadcast=None, sock=None):             # <<<<<<<<<<<<<<
+ *         """A coroutine which creates a datagram endpoint.
+ * 
+ */
+    values[8] = ((PyObject *)Py_None);
+    values[9] = ((PyObject *)Py_None);
+    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_protocol_factory)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_local_addr);
+          if (value) { values[1] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_remote_addr);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (kw_args > 0 && likely(kw_args <= 7)) {
+        Py_ssize_t index;
+        for (index = 3; index < 10 && kw_args > 0; index++) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, *__pyx_pyargnames[index]);
+          if (value) { values[index] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_datagram_endpoint") < 0)) __PYX_ERR(0, 2955, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_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);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_protocol_factory = values[0];
+    __pyx_v_local_addr = values[1];
+    __pyx_v_remote_addr = values[2];
+    __pyx_v_family = values[3];
+    __pyx_v_proto = values[4];
+    __pyx_v_flags = values[5];
+    __pyx_v_reuse_address = values[6];
+    __pyx_v_reuse_port = values[7];
+    __pyx_v_allow_broadcast = values[8];
+    __pyx_v_sock = values[9];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("create_datagram_endpoint", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2955, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_datagram_endpoint", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_124create_datagram_endpoint(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_local_addr, __pyx_v_remote_addr, __pyx_v_family, __pyx_v_proto, __pyx_v_flags, __pyx_v_reuse_address, __pyx_v_reuse_port, __pyx_v_allow_broadcast, __pyx_v_sock);
+
+  /* "uvloop/loop.pyx":2955
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_datagram_endpoint(self, protocol_factory,             # <<<<<<<<<<<<<<
+ *                                        local_addr=None, remote_addr=None, *,
+ *                                        family=0, proto=0, flags=0,
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_24create_datagram_endpoint_2generator29(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":3001
+ *                             allow_broadcast=allow_broadcast)
+ *                 problems = ', '.join(
+ *                     '{}={}'.format(k, v) for k, v in opts.items() if v)             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'socket modifier keyword arguments can not be used '
+ */
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24create_datagram_endpoint_genexpr(PyObject *__pyx_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("genexpr", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_25_genexpr(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_25_genexpr, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 3001, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__pyx_cur_scope);
+  }
+  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *) __pyx_self;
+  __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope));
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_24create_datagram_endpoint_2generator29, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_create_datagram_endpoint_locals, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 3001, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_datagram_endpoint.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_24create_datagram_endpoint_2generator29(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("genexpr", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 3001, __pyx_L1_error)
+  __pyx_r = PyList_New(0); if (unlikely(!__pyx_r)) __PYX_ERR(0, 3001, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_r);
+  __pyx_t_2 = 0;
+  if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_opts)) { __Pyx_RaiseClosureNameError("opts"); __PYX_ERR(0, 3001, __pyx_L1_error) }
+  if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_opts == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items");
+    __PYX_ERR(0, 3001, __pyx_L1_error)
+  }
+  __pyx_t_5 = __Pyx_dict_iterator(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_opts, 1, __pyx_n_s_items, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3001, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_1);
+  __pyx_t_1 = __pyx_t_5;
+  __pyx_t_5 = 0;
+  while (1) {
+    __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, &__pyx_t_6, NULL, __pyx_t_4);
+    if (unlikely(__pyx_t_7 == 0)) break;
+    if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 3001, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_k);
+    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_k, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_5);
+    __pyx_t_5 = 0;
+    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_v);
+    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_v, __pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_6);
+    __pyx_t_6 = 0;
+    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_v); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3001, __pyx_L1_error)
+    if (__pyx_t_8) {
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__91, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3001, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_9 = NULL;
+      __pyx_t_7 = 0;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_9)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_9);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+          __pyx_t_7 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_cur_scope->__pyx_v_k, __pyx_cur_scope->__pyx_v_v};
+        __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3001, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_GOTREF(__pyx_t_6);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_cur_scope->__pyx_v_k, __pyx_cur_scope->__pyx_v_v};
+        __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3001, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_GOTREF(__pyx_t_6);
+      } else
+      #endif
+      {
+        __pyx_t_10 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3001, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        if (__pyx_t_9) {
+          __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL;
+        }
+        __Pyx_INCREF(__pyx_cur_scope->__pyx_v_k);
+        __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_k);
+        PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_7, __pyx_cur_scope->__pyx_v_k);
+        __Pyx_INCREF(__pyx_cur_scope->__pyx_v_v);
+        __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_v);
+        PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_7, __pyx_cur_scope->__pyx_v_v);
+        __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3001, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(__Pyx_ListComp_Append(__pyx_r, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 3001, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":2955
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_datagram_endpoint(self, protocol_factory,             # <<<<<<<<<<<<<<
+ *                                        local_addr=None, remote_addr=None, *,
+ *                                        family=0, proto=0, flags=0,
+ */
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_124create_datagram_endpoint(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_local_addr, PyObject *__pyx_v_remote_addr, PyObject *__pyx_v_family, PyObject *__pyx_v_proto, PyObject *__pyx_v_flags, PyObject *__pyx_v_reuse_address, PyObject *__pyx_v_reuse_port, PyObject *__pyx_v_allow_broadcast, PyObject *__pyx_v_sock) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *__pyx_cur_scope;
+  PyObject *__pyx_gb_6uvloop_4loop_4Loop_24create_datagram_endpoint_2generator29 = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("create_datagram_endpoint", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 2955, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_protocol_factory = __pyx_v_protocol_factory;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_cur_scope->__pyx_v_local_addr = __pyx_v_local_addr;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_local_addr);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_local_addr);
+  __pyx_cur_scope->__pyx_v_remote_addr = __pyx_v_remote_addr;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_remote_addr);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_remote_addr);
+  __pyx_cur_scope->__pyx_v_family = __pyx_v_family;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_family);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_family);
+  __pyx_cur_scope->__pyx_v_proto = __pyx_v_proto;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto);
+  __pyx_cur_scope->__pyx_v_flags = __pyx_v_flags;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_flags);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_flags);
+  __pyx_cur_scope->__pyx_v_reuse_address = __pyx_v_reuse_address;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_reuse_address);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_reuse_address);
+  __pyx_cur_scope->__pyx_v_reuse_port = __pyx_v_reuse_port;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_reuse_port);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_reuse_port);
+  __pyx_cur_scope->__pyx_v_allow_broadcast = __pyx_v_allow_broadcast;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_allow_broadcast);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_allow_broadcast);
+  __pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_126generator18, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_create_datagram_endpoint, __pyx_n_s_Loop_create_datagram_endpoint, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 2955, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.create_datagram_endpoint", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_gb_6uvloop_4loop_4Loop_24create_datagram_endpoint_2generator29);
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_126generator18(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  Py_ssize_t __pyx_t_10;
+  int __pyx_t_11;
+  struct addrinfo *__pyx_t_12;
+  unsigned int __pyx_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  int __pyx_t_17;
+  char const *__pyx_t_18;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  PyObject *__pyx_t_23 = NULL;
+  PyObject *__pyx_t_24 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_datagram_endpoint", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L25_resume_from_await;
+    case 2: goto __pyx_L32_resume_from_await;
+    case 3: goto __pyx_L70_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2955, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":2984
+ *         """
+ *         cdef:
+ *             UDPTransport udp = None             # <<<<<<<<<<<<<<
+ *             system.addrinfo * lai
+ *             system.addrinfo * rai
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __pyx_cur_scope->__pyx_v_udp = ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)Py_None);
+
+  /* "uvloop/loop.pyx":2988
+ *             system.addrinfo * rai
+ * 
+ *         if sock is not None:             # <<<<<<<<<<<<<<
+ *             if not _is_sock_dgram(sock.type):
+ *                 raise ValueError(
+ */
+  __pyx_t_1 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":2989
+ * 
+ *         if sock is not None:
+ *             if not _is_sock_dgram(sock.type):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'A UDP Socket was expected, got {!r}'.format(sock))
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2989, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __pyx_f_6uvloop_4loop__is_sock_dgram(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2989, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2989, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_1 = ((!__pyx_t_2) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":2991
+ *             if not _is_sock_dgram(sock.type):
+ *                 raise ValueError(
+ *                     'A UDP Socket was expected, got {!r}'.format(sock))             # <<<<<<<<<<<<<<
+ *             if (local_addr or remote_addr or
+ *                     family or proto or flags or
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_UDP_Socket_was_expected_got_r, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2991, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3, function);
+        }
+      }
+      __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_cur_scope->__pyx_v_sock) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_cur_scope->__pyx_v_sock);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2991, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":2990
+ *         if sock is not None:
+ *             if not _is_sock_dgram(sock.type):
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'A UDP Socket was expected, got {!r}'.format(sock))
+ *             if (local_addr or remote_addr or
+ */
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2990, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 2990, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2989
+ * 
+ *         if sock is not None:
+ *             if not _is_sock_dgram(sock.type):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'A UDP Socket was expected, got {!r}'.format(sock))
+ */
+    }
+
+    /* "uvloop/loop.pyx":2992
+ *                 raise ValueError(
+ *                     'A UDP Socket was expected, got {!r}'.format(sock))
+ *             if (local_addr or remote_addr or             # <<<<<<<<<<<<<<
+ *                     family or proto or flags or
+ *                     reuse_port or allow_broadcast):
+ */
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_local_addr); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2992, __pyx_L1_error)
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_remote_addr); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2992, __pyx_L1_error)
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L7_bool_binop_done;
+    }
+
+    /* "uvloop/loop.pyx":2993
+ *                     'A UDP Socket was expected, got {!r}'.format(sock))
+ *             if (local_addr or remote_addr or
+ *                     family or proto or flags or             # <<<<<<<<<<<<<<
+ *                     reuse_port or allow_broadcast):
+ *                 # show the problematic kwargs in exception msg
+ */
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_family); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2993, __pyx_L1_error)
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_proto); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2993, __pyx_L1_error)
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_flags); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2993, __pyx_L1_error)
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L7_bool_binop_done;
+    }
+
+    /* "uvloop/loop.pyx":2994
+ *             if (local_addr or remote_addr or
+ *                     family or proto or flags or
+ *                     reuse_port or allow_broadcast):             # <<<<<<<<<<<<<<
+ *                 # show the problematic kwargs in exception msg
+ *                 opts = dict(local_addr=local_addr, remote_addr=remote_addr,
+ */
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2994, __pyx_L1_error)
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_allow_broadcast); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2994, __pyx_L1_error)
+    __pyx_t_1 = __pyx_t_2;
+    __pyx_L7_bool_binop_done:;
+
+    /* "uvloop/loop.pyx":2992
+ *                 raise ValueError(
+ *                     'A UDP Socket was expected, got {!r}'.format(sock))
+ *             if (local_addr or remote_addr or             # <<<<<<<<<<<<<<
+ *                     family or proto or flags or
+ *                     reuse_port or allow_broadcast):
+ */
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/loop.pyx":2996
+ *                     reuse_port or allow_broadcast):
+ *                 # show the problematic kwargs in exception msg
+ *                 opts = dict(local_addr=local_addr, remote_addr=remote_addr,             # <<<<<<<<<<<<<<
+ *                             family=family, proto=proto, flags=flags,
+ *                             reuse_address=reuse_address, reuse_port=reuse_port,
+ */
+      __pyx_t_3 = __Pyx_PyDict_NewPresized(8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2996, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_local_addr, __pyx_cur_scope->__pyx_v_local_addr) < 0) __PYX_ERR(0, 2996, __pyx_L1_error)
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_remote_addr, __pyx_cur_scope->__pyx_v_remote_addr) < 0) __PYX_ERR(0, 2996, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2997
+ *                 # show the problematic kwargs in exception msg
+ *                 opts = dict(local_addr=local_addr, remote_addr=remote_addr,
+ *                             family=family, proto=proto, flags=flags,             # <<<<<<<<<<<<<<
+ *                             reuse_address=reuse_address, reuse_port=reuse_port,
+ *                             allow_broadcast=allow_broadcast)
+ */
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_family, __pyx_cur_scope->__pyx_v_family) < 0) __PYX_ERR(0, 2996, __pyx_L1_error)
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_proto, __pyx_cur_scope->__pyx_v_proto) < 0) __PYX_ERR(0, 2996, __pyx_L1_error)
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_flags, __pyx_cur_scope->__pyx_v_flags) < 0) __PYX_ERR(0, 2996, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2998
+ *                 opts = dict(local_addr=local_addr, remote_addr=remote_addr,
+ *                             family=family, proto=proto, flags=flags,
+ *                             reuse_address=reuse_address, reuse_port=reuse_port,             # <<<<<<<<<<<<<<
+ *                             allow_broadcast=allow_broadcast)
+ *                 problems = ', '.join(
+ */
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_reuse_address, __pyx_cur_scope->__pyx_v_reuse_address) < 0) __PYX_ERR(0, 2996, __pyx_L1_error)
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_reuse_port, __pyx_cur_scope->__pyx_v_reuse_port) < 0) __PYX_ERR(0, 2996, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2999
+ *                             family=family, proto=proto, flags=flags,
+ *                             reuse_address=reuse_address, reuse_port=reuse_port,
+ *                             allow_broadcast=allow_broadcast)             # <<<<<<<<<<<<<<
+ *                 problems = ', '.join(
+ *                     '{}={}'.format(k, v) for k, v in opts.items() if v)
+ */
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allow_broadcast, __pyx_cur_scope->__pyx_v_allow_broadcast) < 0) __PYX_ERR(0, 2996, __pyx_L1_error)
+      __Pyx_GIVEREF(__pyx_t_3);
+      __pyx_cur_scope->__pyx_v_opts = ((PyObject*)__pyx_t_3);
+      __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":3001
+ *                             allow_broadcast=allow_broadcast)
+ *                 problems = ', '.join(
+ *                     '{}={}'.format(k, v) for k, v in opts.items() if v)             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'socket modifier keyword arguments can not be used '
+ */
+      __pyx_t_3 = __pyx_pf_6uvloop_4loop_4Loop_24create_datagram_endpoint_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3001, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+
+      /* "uvloop/loop.pyx":3000
+ *                             reuse_address=reuse_address, reuse_port=reuse_port,
+ *                             allow_broadcast=allow_broadcast)
+ *                 problems = ', '.join(             # <<<<<<<<<<<<<<
+ *                     '{}={}'.format(k, v) for k, v in opts.items() if v)
+ *                 raise ValueError(
+ */
+      __pyx_t_4 = __Pyx_Generator_Next(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3000, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_3 = PyUnicode_Join(__pyx_kp_u__63, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3000, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GIVEREF(__pyx_t_3);
+      __pyx_cur_scope->__pyx_v_problems = ((PyObject*)__pyx_t_3);
+      __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":3004
+ *                 raise ValueError(
+ *                     'socket modifier keyword arguments can not be used '
+ *                     'when sock is specified. ({})'.format(problems))             # <<<<<<<<<<<<<<
+ *             sock.setblocking(False)
+ *             udp = UDPTransport.__new__(UDPTransport)
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_socket_modifier_keyword_argument, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3004, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_cur_scope->__pyx_v_problems) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_problems);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3004, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/loop.pyx":3002
+ *                 problems = ', '.join(
+ *                     '{}={}'.format(k, v) for k, v in opts.items() if v)
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'socket modifier keyword arguments can not be used '
+ *                     'when sock is specified. ({})'.format(problems))
+ */
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3002, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __PYX_ERR(0, 3002, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":2992
+ *                 raise ValueError(
+ *                     'A UDP Socket was expected, got {!r}'.format(sock))
+ *             if (local_addr or remote_addr or             # <<<<<<<<<<<<<<
+ *                     family or proto or flags or
+ *                     reuse_port or allow_broadcast):
+ */
+    }
+
+    /* "uvloop/loop.pyx":3005
+ *                     'socket modifier keyword arguments can not be used '
+ *                     'when sock is specified. ({})'.format(problems))
+ *             sock.setblocking(False)             # <<<<<<<<<<<<<<
+ *             udp = UDPTransport.__new__(UDPTransport)
+ *             udp._init(self, uv.AF_UNSPEC)
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3005, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, Py_False) : __Pyx_PyObject_CallOneArg(__pyx_t_3, Py_False);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3005, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":3006
+ *                     'when sock is specified. ({})'.format(problems))
+ *             sock.setblocking(False)
+ *             udp = UDPTransport.__new__(UDPTransport)             # <<<<<<<<<<<<<<
+ *             udp._init(self, uv.AF_UNSPEC)
+ *             udp.open(sock.family, sock.fileno())
+ */
+    __pyx_t_4 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UDPTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UDPTransport), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3006, __pyx_L1_error)
+    __Pyx_GOTREF(((PyObject *)__pyx_t_4));
+    __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_udp, ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_t_4));
+    __Pyx_GIVEREF(((PyObject *)__pyx_t_4));
+    __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":3007
+ *             sock.setblocking(False)
+ *             udp = UDPTransport.__new__(UDPTransport)
+ *             udp._init(self, uv.AF_UNSPEC)             # <<<<<<<<<<<<<<
+ *             udp.open(sock.family, sock.fileno())
+ *             udp._attach_fileobj(sock)
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_init(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_self, AF_UNSPEC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3007, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":3008
+ *             udp = UDPTransport.__new__(UDPTransport)
+ *             udp._init(self, uv.AF_UNSPEC)
+ *             udp.open(sock.family, sock.fileno())             # <<<<<<<<<<<<<<
+ *             udp._attach_fileobj(sock)
+ *         else:
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3008, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3008, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3008, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3008, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3008, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->open(__pyx_cur_scope->__pyx_v_udp, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3008, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":3009
+ *             udp._init(self, uv.AF_UNSPEC)
+ *             udp.open(sock.family, sock.fileno())
+ *             udp._attach_fileobj(sock)             # <<<<<<<<<<<<<<
+ *         else:
+ *             if reuse_address is not _unset:
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_udp), __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3009, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/loop.pyx":2988
+ *             system.addrinfo * rai
+ * 
+ *         if sock is not None:             # <<<<<<<<<<<<<<
+ *             if not _is_sock_dgram(sock.type):
+ *                 raise ValueError(
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/loop.pyx":3011
+ *             udp._attach_fileobj(sock)
+ *         else:
+ *             if reuse_address is not _unset:             # <<<<<<<<<<<<<<
+ *                 if reuse_address:
+ *                     raise ValueError("Passing `reuse_address=True` is no "
+ */
+  /*else*/ {
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_unset); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3011, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_reuse_address != __pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_2 = (__pyx_t_1 != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/loop.pyx":3012
+ *         else:
+ *             if reuse_address is not _unset:
+ *                 if reuse_address:             # <<<<<<<<<<<<<<
+ *                     raise ValueError("Passing `reuse_address=True` is no "
+ *                                      "longer supported, as the usage of "
+ */
+      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_address); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3012, __pyx_L1_error)
+      if (unlikely(__pyx_t_2)) {
+
+        /* "uvloop/loop.pyx":3013
+ *             if reuse_address is not _unset:
+ *                 if reuse_address:
+ *                     raise ValueError("Passing `reuse_address=True` is no "             # <<<<<<<<<<<<<<
+ *                                      "longer supported, as the usage of "
+ *                                      "SO_REUSEPORT in UDP poses a significant "
+ */
+        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__92, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3013, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __PYX_ERR(0, 3013, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":3012
+ *         else:
+ *             if reuse_address is not _unset:
+ *                 if reuse_address:             # <<<<<<<<<<<<<<
+ *                     raise ValueError("Passing `reuse_address=True` is no "
+ *                                      "longer supported, as the usage of "
+ */
+      }
+
+      /* "uvloop/loop.pyx":3018
+ *                                      "security concern.")
+ *                 else:
+ *                     warnings_warn("The *reuse_address* parameter has been "             # <<<<<<<<<<<<<<
+ *                                   "deprecated as of 0.15.", DeprecationWarning,
+ *                                   stacklevel=2)
+ */
+      /*else*/ {
+
+        /* "uvloop/loop.pyx":3020
+ *                     warnings_warn("The *reuse_address* parameter has been "
+ *                                   "deprecated as of 0.15.", DeprecationWarning,
+ *                                   stacklevel=2)             # <<<<<<<<<<<<<<
+ *             reuse_port = bool(reuse_port)
+ *             if reuse_port and not has_SO_REUSEPORT:
+ */
+        __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3020, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_stacklevel, __pyx_int_2) < 0) __PYX_ERR(0, 3020, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":3018
+ *                                      "security concern.")
+ *                 else:
+ *                     warnings_warn("The *reuse_address* parameter has been "             # <<<<<<<<<<<<<<
+ *                                   "deprecated as of 0.15.", DeprecationWarning,
+ *                                   stacklevel=2)
+ */
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_warnings_warn, __pyx_tuple__93, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3018, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      }
+
+      /* "uvloop/loop.pyx":3011
+ *             udp._attach_fileobj(sock)
+ *         else:
+ *             if reuse_address is not _unset:             # <<<<<<<<<<<<<<
+ *                 if reuse_address:
+ *                     raise ValueError("Passing `reuse_address=True` is no "
+ */
+    }
+
+    /* "uvloop/loop.pyx":3021
+ *                                   "deprecated as of 0.15.", DeprecationWarning,
+ *                                   stacklevel=2)
+ *             reuse_port = bool(reuse_port)             # <<<<<<<<<<<<<<
+ *             if reuse_port and not has_SO_REUSEPORT:
+ *                 raise ValueError(
+ */
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3021, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyBool_FromLong((!(!__pyx_t_2))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3021, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_reuse_port);
+    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_reuse_port, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":3022
+ *                                   stacklevel=2)
+ *             reuse_port = bool(reuse_port)
+ *             if reuse_port and not has_SO_REUSEPORT:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'reuse_port not supported by socket module')
+ */
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3022, __pyx_L1_error)
+    if (__pyx_t_1) {
+    } else {
+      __pyx_t_2 = __pyx_t_1;
+      goto __pyx_L17_bool_binop_done;
+    }
+    __pyx_t_1 = ((!(__pyx_v_6uvloop_4loop_has_SO_REUSEPORT != 0)) != 0);
+    __pyx_t_2 = __pyx_t_1;
+    __pyx_L17_bool_binop_done:;
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/loop.pyx":3023
+ *             reuse_port = bool(reuse_port)
+ *             if reuse_port and not has_SO_REUSEPORT:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'reuse_port not supported by socket module')
+ * 
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3023, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 3023, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":3022
+ *                                   stacklevel=2)
+ *             reuse_port = bool(reuse_port)
+ *             if reuse_port and not has_SO_REUSEPORT:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'reuse_port not supported by socket module')
+ */
+    }
+
+    /* "uvloop/loop.pyx":3026
+ *                     'reuse_port not supported by socket module')
+ * 
+ *             lads = None             # <<<<<<<<<<<<<<
+ *             if local_addr is not None:
+ *                 if (not isinstance(local_addr, (tuple, list)) or
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __pyx_cur_scope->__pyx_v_lads = Py_None;
+
+    /* "uvloop/loop.pyx":3027
+ * 
+ *             lads = None
+ *             if local_addr is not None:             # <<<<<<<<<<<<<<
+ *                 if (not isinstance(local_addr, (tuple, list)) or
+ *                         len(local_addr) != 2):
+ */
+    __pyx_t_2 = (__pyx_cur_scope->__pyx_v_local_addr != Py_None);
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/loop.pyx":3028
+ *             lads = None
+ *             if local_addr is not None:
+ *                 if (not isinstance(local_addr, (tuple, list)) or             # <<<<<<<<<<<<<<
+ *                         len(local_addr) != 2):
+ *                     raise TypeError(
+ */
+      __pyx_t_8 = PyTuple_Check(__pyx_cur_scope->__pyx_v_local_addr); 
+      __pyx_t_9 = (__pyx_t_8 != 0);
+      if (!__pyx_t_9) {
+      } else {
+        __pyx_t_2 = __pyx_t_9;
+        goto __pyx_L23_bool_binop_done;
+      }
+      __pyx_t_9 = PyList_Check(__pyx_cur_scope->__pyx_v_local_addr); 
+      __pyx_t_8 = (__pyx_t_9 != 0);
+      __pyx_t_2 = __pyx_t_8;
+      __pyx_L23_bool_binop_done:;
+      __pyx_t_8 = ((!(__pyx_t_2 != 0)) != 0);
+      if (!__pyx_t_8) {
+      } else {
+        __pyx_t_1 = __pyx_t_8;
+        goto __pyx_L21_bool_binop_done;
+      }
+
+      /* "uvloop/loop.pyx":3029
+ *             if local_addr is not None:
+ *                 if (not isinstance(local_addr, (tuple, list)) or
+ *                         len(local_addr) != 2):             # <<<<<<<<<<<<<<
+ *                     raise TypeError(
+ *                         'local_addr must be a tuple of (host, port)')
+ */
+      __pyx_t_10 = PyObject_Length(__pyx_cur_scope->__pyx_v_local_addr); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 3029, __pyx_L1_error)
+      __pyx_t_8 = ((__pyx_t_10 != 2) != 0);
+      __pyx_t_1 = __pyx_t_8;
+      __pyx_L21_bool_binop_done:;
+
+      /* "uvloop/loop.pyx":3028
+ *             lads = None
+ *             if local_addr is not None:
+ *                 if (not isinstance(local_addr, (tuple, list)) or             # <<<<<<<<<<<<<<
+ *                         len(local_addr) != 2):
+ *                     raise TypeError(
+ */
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/loop.pyx":3030
+ *                 if (not isinstance(local_addr, (tuple, list)) or
+ *                         len(local_addr) != 2):
+ *                     raise TypeError(             # <<<<<<<<<<<<<<
+ *                         'local_addr must be a tuple of (host, port)')
+ *                 lads = await self._getaddrinfo(
+ */
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__94, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3030, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(0, 3030, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":3028
+ *             lads = None
+ *             if local_addr is not None:
+ *                 if (not isinstance(local_addr, (tuple, list)) or             # <<<<<<<<<<<<<<
+ *                         len(local_addr) != 2):
+ *                     raise TypeError(
+ */
+      }
+
+      /* "uvloop/loop.pyx":3033
+ *                         'local_addr must be a tuple of (host, port)')
+ *                 lads = await self._getaddrinfo(
+ *                     local_addr[0], local_addr[1],             # <<<<<<<<<<<<<<
+ *                     family, uv.SOCK_DGRAM, proto, flags,
+ *                     0)
+ */
+      __pyx_t_3 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3033, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3033, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/loop.pyx":3034
+ *                 lads = await self._getaddrinfo(
+ *                     local_addr[0], local_addr[1],
+ *                     family, uv.SOCK_DGRAM, proto, flags,             # <<<<<<<<<<<<<<
+ *                     0)
+ * 
+ */
+      __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3034, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3034, __pyx_L1_error)
+      __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_flags); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3034, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":3032
+ *                     raise TypeError(
+ *                         'local_addr must be a tuple of (host, port)')
+ *                 lads = await self._getaddrinfo(             # <<<<<<<<<<<<<<
+ *                     local_addr[0], local_addr[1],
+ *                     family, uv.SOCK_DGRAM, proto, flags,
+ */
+      __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_t_3, __pyx_t_4, __pyx_t_7, SOCK_DGRAM, __pyx_t_6, __pyx_t_11, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3032, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_5);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XGOTREF(__pyx_r);
+      if (likely(__pyx_r)) {
+        __Pyx_XGIVEREF(__pyx_r);
+        __Pyx_RefNannyFinishContext();
+        __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+        /* return from generator, awaiting value */
+        __pyx_generator->resume_label = 1;
+        return __pyx_r;
+        __pyx_L25_resume_from_await:;
+        if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 3032, __pyx_L1_error)
+        __pyx_t_5 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_5);
+      } else {
+        __pyx_t_5 = NULL;
+        if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_5) < 0) __PYX_ERR(0, 3032, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+      }
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_lads);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_lads, __pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/loop.pyx":3027
+ * 
+ *             lads = None
+ *             if local_addr is not None:             # <<<<<<<<<<<<<<
+ *                 if (not isinstance(local_addr, (tuple, list)) or
+ *                         len(local_addr) != 2):
+ */
+    }
+
+    /* "uvloop/loop.pyx":3037
+ *                     0)
+ * 
+ *             rads = None             # <<<<<<<<<<<<<<
+ *             if remote_addr is not None:
+ *                 if (not isinstance(remote_addr, (tuple, list)) or
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __pyx_cur_scope->__pyx_v_rads = Py_None;
+
+    /* "uvloop/loop.pyx":3038
+ * 
+ *             rads = None
+ *             if remote_addr is not None:             # <<<<<<<<<<<<<<
+ *                 if (not isinstance(remote_addr, (tuple, list)) or
+ *                         len(remote_addr) != 2):
+ */
+    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_remote_addr != Py_None);
+    __pyx_t_8 = (__pyx_t_1 != 0);
+    if (__pyx_t_8) {
+
+      /* "uvloop/loop.pyx":3039
+ *             rads = None
+ *             if remote_addr is not None:
+ *                 if (not isinstance(remote_addr, (tuple, list)) or             # <<<<<<<<<<<<<<
+ *                         len(remote_addr) != 2):
+ *                     raise TypeError(
+ */
+      __pyx_t_2 = PyTuple_Check(__pyx_cur_scope->__pyx_v_remote_addr); 
+      __pyx_t_9 = (__pyx_t_2 != 0);
+      if (!__pyx_t_9) {
+      } else {
+        __pyx_t_1 = __pyx_t_9;
+        goto __pyx_L30_bool_binop_done;
+      }
+      __pyx_t_9 = PyList_Check(__pyx_cur_scope->__pyx_v_remote_addr); 
+      __pyx_t_2 = (__pyx_t_9 != 0);
+      __pyx_t_1 = __pyx_t_2;
+      __pyx_L30_bool_binop_done:;
+      __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
+      if (!__pyx_t_2) {
+      } else {
+        __pyx_t_8 = __pyx_t_2;
+        goto __pyx_L28_bool_binop_done;
+      }
+
+      /* "uvloop/loop.pyx":3040
+ *             if remote_addr is not None:
+ *                 if (not isinstance(remote_addr, (tuple, list)) or
+ *                         len(remote_addr) != 2):             # <<<<<<<<<<<<<<
+ *                     raise TypeError(
+ *                         'remote_addr must be a tuple of (host, port)')
+ */
+      __pyx_t_10 = PyObject_Length(__pyx_cur_scope->__pyx_v_remote_addr); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 3040, __pyx_L1_error)
+      __pyx_t_2 = ((__pyx_t_10 != 2) != 0);
+      __pyx_t_8 = __pyx_t_2;
+      __pyx_L28_bool_binop_done:;
+
+      /* "uvloop/loop.pyx":3039
+ *             rads = None
+ *             if remote_addr is not None:
+ *                 if (not isinstance(remote_addr, (tuple, list)) or             # <<<<<<<<<<<<<<
+ *                         len(remote_addr) != 2):
+ *                     raise TypeError(
+ */
+      if (unlikely(__pyx_t_8)) {
+
+        /* "uvloop/loop.pyx":3041
+ *                 if (not isinstance(remote_addr, (tuple, list)) or
+ *                         len(remote_addr) != 2):
+ *                     raise TypeError(             # <<<<<<<<<<<<<<
+ *                         'remote_addr must be a tuple of (host, port)')
+ *                 rads = await self._getaddrinfo(
+ */
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__95, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3041, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __PYX_ERR(0, 3041, __pyx_L1_error)
+
+        /* "uvloop/loop.pyx":3039
+ *             rads = None
+ *             if remote_addr is not None:
+ *                 if (not isinstance(remote_addr, (tuple, list)) or             # <<<<<<<<<<<<<<
+ *                         len(remote_addr) != 2):
+ *                     raise TypeError(
+ */
+      }
+
+      /* "uvloop/loop.pyx":3044
+ *                         'remote_addr must be a tuple of (host, port)')
+ *                 rads = await self._getaddrinfo(
+ *                     remote_addr[0], remote_addr[1],             # <<<<<<<<<<<<<<
+ *                     family, uv.SOCK_DGRAM, proto, flags,
+ *                     0)
+ */
+      __pyx_t_5 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_remote_addr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3044, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_4 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_remote_addr, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3044, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/loop.pyx":3045
+ *                 rads = await self._getaddrinfo(
+ *                     remote_addr[0], remote_addr[1],
+ *                     family, uv.SOCK_DGRAM, proto, flags,             # <<<<<<<<<<<<<<
+ *                     0)
+ * 
+ */
+      __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3045, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3045, __pyx_L1_error)
+      __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_flags); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3045, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":3043
+ *                     raise TypeError(
+ *                         'remote_addr must be a tuple of (host, port)')
+ *                 rads = await self._getaddrinfo(             # <<<<<<<<<<<<<<
+ *                     remote_addr[0], remote_addr[1],
+ *                     family, uv.SOCK_DGRAM, proto, flags,
+ */
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_t_5, __pyx_t_4, __pyx_t_11, SOCK_DGRAM, __pyx_t_6, __pyx_t_7, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3043, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XGOTREF(__pyx_r);
+      if (likely(__pyx_r)) {
+        __Pyx_XGIVEREF(__pyx_r);
+        __Pyx_RefNannyFinishContext();
+        __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+        /* return from generator, awaiting value */
+        __pyx_generator->resume_label = 2;
+        return __pyx_r;
+        __pyx_L32_resume_from_await:;
+        if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 3043, __pyx_L1_error)
+        __pyx_t_3 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_3);
+      } else {
+        __pyx_t_3 = NULL;
+        if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_3) < 0) __PYX_ERR(0, 3043, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+      }
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_rads);
+      __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_rads, __pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_3);
+      __pyx_t_3 = 0;
+
+      /* "uvloop/loop.pyx":3038
+ * 
+ *             rads = None
+ *             if remote_addr is not None:             # <<<<<<<<<<<<<<
+ *                 if (not isinstance(remote_addr, (tuple, list)) or
+ *                         len(remote_addr) != 2):
+ */
+    }
+
+    /* "uvloop/loop.pyx":3048
+ *                     0)
+ * 
+ *             excs = []             # <<<<<<<<<<<<<<
+ *             if lads is None:
+ *                 if rads is not None:
+ */
+    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3048, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __pyx_cur_scope->__pyx_v_excs = ((PyObject*)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":3049
+ * 
+ *             excs = []
+ *             if lads is None:             # <<<<<<<<<<<<<<
+ *                 if rads is not None:
+ *                     udp = UDPTransport.__new__(UDPTransport)
+ */
+    __pyx_t_8 = (__pyx_cur_scope->__pyx_v_lads == Py_None);
+    __pyx_t_2 = (__pyx_t_8 != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/loop.pyx":3050
+ *             excs = []
+ *             if lads is None:
+ *                 if rads is not None:             # <<<<<<<<<<<<<<
+ *                     udp = UDPTransport.__new__(UDPTransport)
+ *                     rai = (<AddrInfo>rads).data
+ */
+      __pyx_t_2 = (__pyx_cur_scope->__pyx_v_rads != Py_None);
+      __pyx_t_8 = (__pyx_t_2 != 0);
+      if (__pyx_t_8) {
+
+        /* "uvloop/loop.pyx":3051
+ *             if lads is None:
+ *                 if rads is not None:
+ *                     udp = UDPTransport.__new__(UDPTransport)             # <<<<<<<<<<<<<<
+ *                     rai = (<AddrInfo>rads).data
+ *                     udp._init(self, rai.ai_family)
+ */
+        __pyx_t_3 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UDPTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UDPTransport), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3051, __pyx_L1_error)
+        __Pyx_GOTREF(((PyObject *)__pyx_t_3));
+        __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
+        __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_udp, ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_t_3));
+        __Pyx_GIVEREF(((PyObject *)__pyx_t_3));
+        __pyx_t_3 = 0;
+
+        /* "uvloop/loop.pyx":3052
+ *                 if rads is not None:
+ *                     udp = UDPTransport.__new__(UDPTransport)
+ *                     rai = (<AddrInfo>rads).data             # <<<<<<<<<<<<<<
+ *                     udp._init(self, rai.ai_family)
+ *                     udp._connect(rai.ai_addr, rai.ai_addrlen)
+ */
+        __pyx_t_12 = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_cur_scope->__pyx_v_rads)->data;
+        __pyx_cur_scope->__pyx_v_rai = __pyx_t_12;
+
+        /* "uvloop/loop.pyx":3053
+ *                     udp = UDPTransport.__new__(UDPTransport)
+ *                     rai = (<AddrInfo>rads).data
+ *                     udp._init(self, rai.ai_family)             # <<<<<<<<<<<<<<
+ *                     udp._connect(rai.ai_addr, rai.ai_addrlen)
+ *                     udp._set_address(rai)
+ */
+        __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_init(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_rai->ai_family); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3053, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/loop.pyx":3054
+ *                     rai = (<AddrInfo>rads).data
+ *                     udp._init(self, rai.ai_family)
+ *                     udp._connect(rai.ai_addr, rai.ai_addrlen)             # <<<<<<<<<<<<<<
+ *                     udp._set_address(rai)
+ *                 else:
+ */
+        __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_connect(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_rai->ai_addr, __pyx_cur_scope->__pyx_v_rai->ai_addrlen); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3054, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/loop.pyx":3055
+ *                     udp._init(self, rai.ai_family)
+ *                     udp._connect(rai.ai_addr, rai.ai_addrlen)
+ *                     udp._set_address(rai)             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     if family not in (uv.AF_INET, uv.AF_INET6):
+ */
+        __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_set_address(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_rai); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3055, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/loop.pyx":3050
+ *             excs = []
+ *             if lads is None:
+ *                 if rads is not None:             # <<<<<<<<<<<<<<
+ *                     udp = UDPTransport.__new__(UDPTransport)
+ *                     rai = (<AddrInfo>rads).data
+ */
+        goto __pyx_L34;
+      }
+
+      /* "uvloop/loop.pyx":3057
+ *                     udp._set_address(rai)
+ *                 else:
+ *                     if family not in (uv.AF_INET, uv.AF_INET6):             # <<<<<<<<<<<<<<
+ *                         raise ValueError('unexpected address family')
+ *                     udp = UDPTransport.__new__(UDPTransport)
+ */
+      /*else*/ {
+        __Pyx_INCREF(__pyx_cur_scope->__pyx_v_family);
+        __pyx_t_3 = __pyx_cur_scope->__pyx_v_family;
+        __pyx_t_4 = __Pyx_PyInt_From_int(AF_INET); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3057, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_NE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3057, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3057, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (__pyx_t_2) {
+        } else {
+          __pyx_t_8 = __pyx_t_2;
+          goto __pyx_L36_bool_binop_done;
+        }
+        __pyx_t_5 = __Pyx_PyInt_From_int(AF_INET6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3057, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_5, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3057, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3057, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_8 = __pyx_t_2;
+        __pyx_L36_bool_binop_done:;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __pyx_t_2 = (__pyx_t_8 != 0);
+        if (unlikely(__pyx_t_2)) {
+
+          /* "uvloop/loop.pyx":3058
+ *                 else:
+ *                     if family not in (uv.AF_INET, uv.AF_INET6):
+ *                         raise ValueError('unexpected address family')             # <<<<<<<<<<<<<<
+ *                     udp = UDPTransport.__new__(UDPTransport)
+ *                     udp._init(self, family)
+ */
+          __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__96, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3058, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __PYX_ERR(0, 3058, __pyx_L1_error)
+
+          /* "uvloop/loop.pyx":3057
+ *                     udp._set_address(rai)
+ *                 else:
+ *                     if family not in (uv.AF_INET, uv.AF_INET6):             # <<<<<<<<<<<<<<
+ *                         raise ValueError('unexpected address family')
+ *                     udp = UDPTransport.__new__(UDPTransport)
+ */
+        }
+
+        /* "uvloop/loop.pyx":3059
+ *                     if family not in (uv.AF_INET, uv.AF_INET6):
+ *                         raise ValueError('unexpected address family')
+ *                     udp = UDPTransport.__new__(UDPTransport)             # <<<<<<<<<<<<<<
+ *                     udp._init(self, family)
+ * 
+ */
+        __pyx_t_3 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UDPTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UDPTransport), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3059, __pyx_L1_error)
+        __Pyx_GOTREF(((PyObject *)__pyx_t_3));
+        __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
+        __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_udp, ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_t_3));
+        __Pyx_GIVEREF(((PyObject *)__pyx_t_3));
+        __pyx_t_3 = 0;
+
+        /* "uvloop/loop.pyx":3060
+ *                         raise ValueError('unexpected address family')
+ *                     udp = UDPTransport.__new__(UDPTransport)
+ *                     udp._init(self, family)             # <<<<<<<<<<<<<<
+ * 
+ *                 if reuse_port:
+ */
+        __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3060, __pyx_L1_error)
+        __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_init(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_self, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3060, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      }
+      __pyx_L34:;
+
+      /* "uvloop/loop.pyx":3062
+ *                     udp._init(self, family)
+ * 
+ *                 if reuse_port:             # <<<<<<<<<<<<<<
+ *                     self._sock_set_reuseport(udp._fileno())
+ * 
+ */
+      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3062, __pyx_L1_error)
+      if (__pyx_t_2) {
+
+        /* "uvloop/loop.pyx":3063
+ * 
+ *                 if reuse_port:
+ *                     self._sock_set_reuseport(udp._fileno())             # <<<<<<<<<<<<<<
+ * 
+ *             else:
+ */
+        __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._fileno(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_udp)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3063, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3063, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_set_reuseport(__pyx_cur_scope->__pyx_v_self, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3063, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/loop.pyx":3062
+ *                     udp._init(self, family)
+ * 
+ *                 if reuse_port:             # <<<<<<<<<<<<<<
+ *                     self._sock_set_reuseport(udp._fileno())
+ * 
+ */
+      }
+
+      /* "uvloop/loop.pyx":3049
+ * 
+ *             excs = []
+ *             if lads is None:             # <<<<<<<<<<<<<<
+ *                 if rads is not None:
+ *                     udp = UDPTransport.__new__(UDPTransport)
+ */
+      goto __pyx_L33;
+    }
+
+    /* "uvloop/loop.pyx":3066
+ * 
+ *             else:
+ *                 lai = (<AddrInfo>lads).data             # <<<<<<<<<<<<<<
+ *                 while lai is not NULL:
+ *                     try:
+ */
+    /*else*/ {
+      __pyx_t_12 = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_cur_scope->__pyx_v_lads)->data;
+      __pyx_cur_scope->__pyx_v_lai = __pyx_t_12;
+
+      /* "uvloop/loop.pyx":3067
+ *             else:
+ *                 lai = (<AddrInfo>lads).data
+ *                 while lai is not NULL:             # <<<<<<<<<<<<<<
+ *                     try:
+ *                         udp = UDPTransport.__new__(UDPTransport)
+ */
+      while (1) {
+        __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_lai != NULL) != 0);
+        if (!__pyx_t_2) break;
+
+        /* "uvloop/loop.pyx":3068
+ *                 lai = (<AddrInfo>lads).data
+ *                 while lai is not NULL:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         udp = UDPTransport.__new__(UDPTransport)
+ *                         udp._init(self, lai.ai_family)
+ */
+        {
+          __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          /*try:*/ {
+
+            /* "uvloop/loop.pyx":3069
+ *                 while lai is not NULL:
+ *                     try:
+ *                         udp = UDPTransport.__new__(UDPTransport)             # <<<<<<<<<<<<<<
+ *                         udp._init(self, lai.ai_family)
+ *                         if reuse_port:
+ */
+            __pyx_t_3 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UDPTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UDPTransport), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3069, __pyx_L41_error)
+            __Pyx_GOTREF(((PyObject *)__pyx_t_3));
+            __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
+            __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_udp, ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_t_3));
+            __Pyx_GIVEREF(((PyObject *)__pyx_t_3));
+            __pyx_t_3 = 0;
+
+            /* "uvloop/loop.pyx":3070
+ *                     try:
+ *                         udp = UDPTransport.__new__(UDPTransport)
+ *                         udp._init(self, lai.ai_family)             # <<<<<<<<<<<<<<
+ *                         if reuse_port:
+ *                             self._sock_set_reuseport(udp._fileno())
+ */
+            __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_init(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_lai->ai_family); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3070, __pyx_L41_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+            /* "uvloop/loop.pyx":3071
+ *                         udp = UDPTransport.__new__(UDPTransport)
+ *                         udp._init(self, lai.ai_family)
+ *                         if reuse_port:             # <<<<<<<<<<<<<<
+ *                             self._sock_set_reuseport(udp._fileno())
+ *                         udp._bind(lai.ai_addr)
+ */
+            __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3071, __pyx_L41_error)
+            if (__pyx_t_2) {
+
+              /* "uvloop/loop.pyx":3072
+ *                         udp._init(self, lai.ai_family)
+ *                         if reuse_port:
+ *                             self._sock_set_reuseport(udp._fileno())             # <<<<<<<<<<<<<<
+ *                         udp._bind(lai.ai_addr)
+ *                     except (KeyboardInterrupt, SystemExit):
+ */
+              __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._fileno(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_udp)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3072, __pyx_L41_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3072, __pyx_L41_error)
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_set_reuseport(__pyx_cur_scope->__pyx_v_self, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3072, __pyx_L41_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+              /* "uvloop/loop.pyx":3071
+ *                         udp = UDPTransport.__new__(UDPTransport)
+ *                         udp._init(self, lai.ai_family)
+ *                         if reuse_port:             # <<<<<<<<<<<<<<
+ *                             self._sock_set_reuseport(udp._fileno())
+ *                         udp._bind(lai.ai_addr)
+ */
+            }
+
+            /* "uvloop/loop.pyx":3073
+ *                         if reuse_port:
+ *                             self._sock_set_reuseport(udp._fileno())
+ *                         udp._bind(lai.ai_addr)             # <<<<<<<<<<<<<<
+ *                     except (KeyboardInterrupt, SystemExit):
+ *                         raise
+ */
+            __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_bind(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_lai->ai_addr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3073, __pyx_L41_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+            /* "uvloop/loop.pyx":3068
+ *                 lai = (<AddrInfo>lads).data
+ *                 while lai is not NULL:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         udp = UDPTransport.__new__(UDPTransport)
+ *                         udp._init(self, lai.ai_family)
+ */
+          }
+
+          /* "uvloop/loop.pyx":3081
+ *                         continue
+ *                     else:
+ *                         break             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     ctx = None
+ */
+          /*else:*/ {
+            goto __pyx_L46_try_break;
+          }
+          __pyx_L41_error:;
+          __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;
+
+          /* "uvloop/loop.pyx":3074
+ *                             self._sock_set_reuseport(udp._fileno())
+ *                         udp._bind(lai.ai_addr)
+ *                     except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                         raise
+ *                     except BaseException as ex:
+ */
+          __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+          if (__pyx_t_7) {
+            __Pyx_AddTraceback("uvloop.loop.Loop.create_datagram_endpoint", __pyx_clineno, __pyx_lineno, __pyx_filename);
+            if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(0, 3074, __pyx_L43_except_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_GOTREF(__pyx_t_5);
+
+            /* "uvloop/loop.pyx":3075
+ *                         udp._bind(lai.ai_addr)
+ *                     except (KeyboardInterrupt, SystemExit):
+ *                         raise             # <<<<<<<<<<<<<<
+ *                     except BaseException as ex:
+ *                         lai = lai.ai_next
+ */
+            __Pyx_GIVEREF(__pyx_t_3);
+            __Pyx_GIVEREF(__pyx_t_4);
+            __Pyx_XGIVEREF(__pyx_t_5);
+            __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+            __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; 
+            __PYX_ERR(0, 3075, __pyx_L43_except_error)
+          }
+
+          /* "uvloop/loop.pyx":3076
+ *                     except (KeyboardInterrupt, SystemExit):
+ *                         raise
+ *                     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                         lai = lai.ai_next
+ *                         excs.append(ex)
+ */
+          __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+          if (__pyx_t_7) {
+            __Pyx_AddTraceback("uvloop.loop.Loop.create_datagram_endpoint", __pyx_clineno, __pyx_lineno, __pyx_filename);
+            if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3) < 0) __PYX_ERR(0, 3076, __pyx_L43_except_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_INCREF(__pyx_t_4);
+            __Pyx_GIVEREF(__pyx_t_4);
+            __pyx_cur_scope->__pyx_v_ex = __pyx_t_4;
+            /*try:*/ {
+
+              /* "uvloop/loop.pyx":3077
+ *                         raise
+ *                     except BaseException as ex:
+ *                         lai = lai.ai_next             # <<<<<<<<<<<<<<
+ *                         excs.append(ex)
+ *                         continue
+ */
+              __pyx_t_12 = __pyx_cur_scope->__pyx_v_lai->ai_next;
+              __pyx_cur_scope->__pyx_v_lai = __pyx_t_12;
+
+              /* "uvloop/loop.pyx":3078
+ *                     except BaseException as ex:
+ *                         lai = lai.ai_next
+ *                         excs.append(ex)             # <<<<<<<<<<<<<<
+ *                         continue
+ *                     else:
+ */
+              __pyx_t_17 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_excs, __pyx_cur_scope->__pyx_v_ex); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(0, 3078, __pyx_L57_error)
+
+              /* "uvloop/loop.pyx":3079
+ *                         lai = lai.ai_next
+ *                         excs.append(ex)
+ *                         continue             # <<<<<<<<<<<<<<
+ *                     else:
+ *                         break
+ */
+              goto __pyx_L54_continue;
+            }
+
+            /* "uvloop/loop.pyx":3076
+ *                     except (KeyboardInterrupt, SystemExit):
+ *                         raise
+ *                     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                         lai = lai.ai_next
+ *                         excs.append(ex)
+ */
+            /*finally:*/ {
+              __pyx_L57_error:;
+              /*exception exit:*/{
+                __Pyx_PyThreadState_assign
+                __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0;
+                if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_22, &__pyx_t_23, &__pyx_t_24);
+                if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21) < 0)) __Pyx_ErrFetch(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
+                __Pyx_XGOTREF(__pyx_t_19);
+                __Pyx_XGOTREF(__pyx_t_20);
+                __Pyx_XGOTREF(__pyx_t_21);
+                __Pyx_XGOTREF(__pyx_t_22);
+                __Pyx_XGOTREF(__pyx_t_23);
+                __Pyx_XGOTREF(__pyx_t_24);
+                __pyx_t_7 = __pyx_lineno; __pyx_t_6 = __pyx_clineno; __pyx_t_18 = __pyx_filename;
+                {
+                  __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ex);
+                  __Pyx_DECREF(__pyx_cur_scope->__pyx_v_ex);
+                  __pyx_cur_scope->__pyx_v_ex = NULL;
+                }
+                if (PY_MAJOR_VERSION >= 3) {
+                  __Pyx_XGIVEREF(__pyx_t_22);
+                  __Pyx_XGIVEREF(__pyx_t_23);
+                  __Pyx_XGIVEREF(__pyx_t_24);
+                  __Pyx_ExceptionReset(__pyx_t_22, __pyx_t_23, __pyx_t_24);
+                }
+                __Pyx_XGIVEREF(__pyx_t_19);
+                __Pyx_XGIVEREF(__pyx_t_20);
+                __Pyx_XGIVEREF(__pyx_t_21);
+                __Pyx_ErrRestore(__pyx_t_19, __pyx_t_20, __pyx_t_21);
+                __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0;
+                __pyx_lineno = __pyx_t_7; __pyx_clineno = __pyx_t_6; __pyx_filename = __pyx_t_18;
+                goto __pyx_L43_except_error;
+              }
+              __pyx_L54_continue: {
+                __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ex);
+                __Pyx_DECREF(__pyx_cur_scope->__pyx_v_ex);
+                __pyx_cur_scope->__pyx_v_ex = NULL;
+                goto __pyx_L53_except_continue;
+              }
+            }
+            __pyx_L53_except_continue:;
+            __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;
+            goto __pyx_L47_try_continue;
+          }
+          goto __pyx_L43_except_error;
+          __pyx_L43_except_error:;
+
+          /* "uvloop/loop.pyx":3068
+ *                 lai = (<AddrInfo>lads).data
+ *                 while lai is not NULL:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         udp = UDPTransport.__new__(UDPTransport)
+ *                         udp._init(self, lai.ai_family)
+ */
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+          goto __pyx_L1_error;
+          __pyx_L46_try_break:;
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+          goto __pyx_L40_break;
+          __pyx_L47_try_continue:;
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+          goto __pyx_L39_continue;
+        }
+        __pyx_L39_continue:;
+      }
+
+      /* "uvloop/loop.pyx":3083
+ *                         break
+ *                 else:
+ *                     ctx = None             # <<<<<<<<<<<<<<
+ *                     if len(excs):
+ *                         ctx = excs[0]
+ */
+      /*else*/ {
+        __Pyx_INCREF(Py_None);
+        __Pyx_GIVEREF(Py_None);
+        __pyx_cur_scope->__pyx_v_ctx = Py_None;
+
+        /* "uvloop/loop.pyx":3084
+ *                 else:
+ *                     ctx = None
+ *                     if len(excs):             # <<<<<<<<<<<<<<
+ *                         ctx = excs[0]
+ *                     raise OSError('could not bind to local_addr {}'.format(
+ */
+        __pyx_t_10 = PyList_GET_SIZE(__pyx_cur_scope->__pyx_v_excs); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 3084, __pyx_L1_error)
+        __pyx_t_2 = (__pyx_t_10 != 0);
+        if (__pyx_t_2) {
+
+          /* "uvloop/loop.pyx":3085
+ *                     ctx = None
+ *                     if len(excs):
+ *                         ctx = excs[0]             # <<<<<<<<<<<<<<
+ *                     raise OSError('could not bind to local_addr {}'.format(
+ *                         local_addr)) from ctx
+ */
+          __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_cur_scope->__pyx_v_excs, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3085, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ctx);
+          __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_ctx, __pyx_t_3);
+          __Pyx_GIVEREF(__pyx_t_3);
+          __pyx_t_3 = 0;
+
+          /* "uvloop/loop.pyx":3084
+ *                 else:
+ *                     ctx = None
+ *                     if len(excs):             # <<<<<<<<<<<<<<
+ *                         ctx = excs[0]
+ *                     raise OSError('could not bind to local_addr {}'.format(
+ */
+        }
+
+        /* "uvloop/loop.pyx":3086
+ *                     if len(excs):
+ *                         ctx = excs[0]
+ *                     raise OSError('could not bind to local_addr {}'.format(             # <<<<<<<<<<<<<<
+ *                         local_addr)) from ctx
+ * 
+ */
+        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_could_not_bind_to_local_addr, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3086, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+
+        /* "uvloop/loop.pyx":3087
+ *                         ctx = excs[0]
+ *                     raise OSError('could not bind to local_addr {}'.format(
+ *                         local_addr)) from ctx             # <<<<<<<<<<<<<<
+ * 
+ *                 if rads is not None:
+ */
+        __pyx_t_5 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_cur_scope->__pyx_v_local_addr) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_local_addr);
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3086, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/loop.pyx":3086
+ *                     if len(excs):
+ *                         ctx = excs[0]
+ *                     raise OSError('could not bind to local_addr {}'.format(             # <<<<<<<<<<<<<<
+ *                         local_addr)) from ctx
+ * 
+ */
+        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_OSError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3086, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/loop.pyx":3087
+ *                         ctx = excs[0]
+ *                     raise OSError('could not bind to local_addr {}'.format(
+ *                         local_addr)) from ctx             # <<<<<<<<<<<<<<
+ * 
+ *                 if rads is not None:
+ */
+        __Pyx_Raise(__pyx_t_4, 0, 0, __pyx_cur_scope->__pyx_v_ctx);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __PYX_ERR(0, 3086, __pyx_L1_error)
+      }
+      __pyx_L40_break:;
+
+      /* "uvloop/loop.pyx":3089
+ *                         local_addr)) from ctx
+ * 
+ *                 if rads is not None:             # <<<<<<<<<<<<<<
+ *                     rai = (<AddrInfo>rads).data
+ *                     while rai is not NULL:
+ */
+      __pyx_t_2 = (__pyx_cur_scope->__pyx_v_rads != Py_None);
+      __pyx_t_8 = (__pyx_t_2 != 0);
+      if (__pyx_t_8) {
+
+        /* "uvloop/loop.pyx":3090
+ * 
+ *                 if rads is not None:
+ *                     rai = (<AddrInfo>rads).data             # <<<<<<<<<<<<<<
+ *                     while rai is not NULL:
+ *                         if rai.ai_family != lai.ai_family:
+ */
+        __pyx_t_12 = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_cur_scope->__pyx_v_rads)->data;
+        __pyx_cur_scope->__pyx_v_rai = __pyx_t_12;
+
+        /* "uvloop/loop.pyx":3091
+ *                 if rads is not None:
+ *                     rai = (<AddrInfo>rads).data
+ *                     while rai is not NULL:             # <<<<<<<<<<<<<<
+ *                         if rai.ai_family != lai.ai_family:
+ *                             rai = rai.ai_next
+ */
+        while (1) {
+          __pyx_t_8 = ((__pyx_cur_scope->__pyx_v_rai != NULL) != 0);
+          if (!__pyx_t_8) break;
+
+          /* "uvloop/loop.pyx":3092
+ *                     rai = (<AddrInfo>rads).data
+ *                     while rai is not NULL:
+ *                         if rai.ai_family != lai.ai_family:             # <<<<<<<<<<<<<<
+ *                             rai = rai.ai_next
+ *                             continue
+ */
+          __pyx_t_8 = ((__pyx_cur_scope->__pyx_v_rai->ai_family != __pyx_cur_scope->__pyx_v_lai->ai_family) != 0);
+          if (__pyx_t_8) {
+
+            /* "uvloop/loop.pyx":3093
+ *                     while rai is not NULL:
+ *                         if rai.ai_family != lai.ai_family:
+ *                             rai = rai.ai_next             # <<<<<<<<<<<<<<
+ *                             continue
+ *                         if rai.ai_protocol != lai.ai_protocol:
+ */
+            __pyx_t_12 = __pyx_cur_scope->__pyx_v_rai->ai_next;
+            __pyx_cur_scope->__pyx_v_rai = __pyx_t_12;
+
+            /* "uvloop/loop.pyx":3094
+ *                         if rai.ai_family != lai.ai_family:
+ *                             rai = rai.ai_next
+ *                             continue             # <<<<<<<<<<<<<<
+ *                         if rai.ai_protocol != lai.ai_protocol:
+ *                             rai = rai.ai_next
+ */
+            goto __pyx_L65_continue;
+
+            /* "uvloop/loop.pyx":3092
+ *                     rai = (<AddrInfo>rads).data
+ *                     while rai is not NULL:
+ *                         if rai.ai_family != lai.ai_family:             # <<<<<<<<<<<<<<
+ *                             rai = rai.ai_next
+ *                             continue
+ */
+          }
+
+          /* "uvloop/loop.pyx":3095
+ *                             rai = rai.ai_next
+ *                             continue
+ *                         if rai.ai_protocol != lai.ai_protocol:             # <<<<<<<<<<<<<<
+ *                             rai = rai.ai_next
+ *                             continue
+ */
+          __pyx_t_8 = ((__pyx_cur_scope->__pyx_v_rai->ai_protocol != __pyx_cur_scope->__pyx_v_lai->ai_protocol) != 0);
+          if (__pyx_t_8) {
+
+            /* "uvloop/loop.pyx":3096
+ *                             continue
+ *                         if rai.ai_protocol != lai.ai_protocol:
+ *                             rai = rai.ai_next             # <<<<<<<<<<<<<<
+ *                             continue
+ *                         udp._connect(rai.ai_addr, rai.ai_addrlen)
+ */
+            __pyx_t_12 = __pyx_cur_scope->__pyx_v_rai->ai_next;
+            __pyx_cur_scope->__pyx_v_rai = __pyx_t_12;
+
+            /* "uvloop/loop.pyx":3097
+ *                         if rai.ai_protocol != lai.ai_protocol:
+ *                             rai = rai.ai_next
+ *                             continue             # <<<<<<<<<<<<<<
+ *                         udp._connect(rai.ai_addr, rai.ai_addrlen)
+ *                         udp._set_address(rai)
+ */
+            goto __pyx_L65_continue;
+
+            /* "uvloop/loop.pyx":3095
+ *                             rai = rai.ai_next
+ *                             continue
+ *                         if rai.ai_protocol != lai.ai_protocol:             # <<<<<<<<<<<<<<
+ *                             rai = rai.ai_next
+ *                             continue
+ */
+          }
+
+          /* "uvloop/loop.pyx":3098
+ *                             rai = rai.ai_next
+ *                             continue
+ *                         udp._connect(rai.ai_addr, rai.ai_addrlen)             # <<<<<<<<<<<<<<
+ *                         udp._set_address(rai)
+ *                         break
+ */
+          __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_connect(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_rai->ai_addr, __pyx_cur_scope->__pyx_v_rai->ai_addrlen); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3098, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+          /* "uvloop/loop.pyx":3099
+ *                             continue
+ *                         udp._connect(rai.ai_addr, rai.ai_addrlen)
+ *                         udp._set_address(rai)             # <<<<<<<<<<<<<<
+ *                         break
+ *                     else:
+ */
+          __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_set_address(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_rai); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3099, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+          /* "uvloop/loop.pyx":3100
+ *                         udp._connect(rai.ai_addr, rai.ai_addrlen)
+ *                         udp._set_address(rai)
+ *                         break             # <<<<<<<<<<<<<<
+ *                     else:
+ *                         raise OSError(
+ */
+          goto __pyx_L66_break;
+          __pyx_L65_continue:;
+        }
+
+        /* "uvloop/loop.pyx":3102
+ *                         break
+ *                     else:
+ *                         raise OSError(             # <<<<<<<<<<<<<<
+ *                             'could not bind to remote_addr {}'.format(
+ *                                 remote_addr))
+ */
+        /*else*/ {
+
+          /* "uvloop/loop.pyx":3103
+ *                     else:
+ *                         raise OSError(
+ *                             'could not bind to remote_addr {}'.format(             # <<<<<<<<<<<<<<
+ *                                 remote_addr))
+ * 
+ */
+          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_could_not_bind_to_remote_addr, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3103, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+
+          /* "uvloop/loop.pyx":3104
+ *                         raise OSError(
+ *                             'could not bind to remote_addr {}'.format(
+ *                                 remote_addr))             # <<<<<<<<<<<<<<
+ * 
+ *         if allow_broadcast:
+ */
+          __pyx_t_5 = NULL;
+          if (CYTHON_UNPACK_METHODS && 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_3, function);
+            }
+          }
+          __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_cur_scope->__pyx_v_remote_addr) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_cur_scope->__pyx_v_remote_addr);
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3103, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+          /* "uvloop/loop.pyx":3102
+ *                         break
+ *                     else:
+ *                         raise OSError(             # <<<<<<<<<<<<<<
+ *                             'could not bind to remote_addr {}'.format(
+ *                                 remote_addr))
+ */
+          __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_OSError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3102, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __PYX_ERR(0, 3102, __pyx_L1_error)
+        }
+        __pyx_L66_break:;
+
+        /* "uvloop/loop.pyx":3089
+ *                         local_addr)) from ctx
+ * 
+ *                 if rads is not None:             # <<<<<<<<<<<<<<
+ *                     rai = (<AddrInfo>rads).data
+ *                     while rai is not NULL:
+ */
+      }
+    }
+    __pyx_L33:;
+  }
+  __pyx_L4:;
+
+  /* "uvloop/loop.pyx":3106
+ *                                 remote_addr))
+ * 
+ *         if allow_broadcast:             # <<<<<<<<<<<<<<
+ *             udp._set_broadcast(1)
+ * 
+ */
+  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_allow_broadcast); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3106, __pyx_L1_error)
+  if (__pyx_t_8) {
+
+    /* "uvloop/loop.pyx":3107
+ * 
+ *         if allow_broadcast:
+ *             udp._set_broadcast(1)             # <<<<<<<<<<<<<<
+ * 
+ *         protocol = protocol_factory()
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_set_broadcast(__pyx_cur_scope->__pyx_v_udp, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3107, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":3106
+ *                                 remote_addr))
+ * 
+ *         if allow_broadcast:             # <<<<<<<<<<<<<<
+ *             udp._set_broadcast(1)
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":3109
+ *             udp._set_broadcast(1)
+ * 
+ *         protocol = protocol_factory()             # <<<<<<<<<<<<<<
+ *         waiter = self._new_future()
+ *         assert udp is not None
+ */
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
+  __pyx_t_4 = __pyx_cur_scope->__pyx_v_protocol_factory; __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3109, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_3);
+  __pyx_cur_scope->__pyx_v_protocol = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":3110
+ * 
+ *         protocol = protocol_factory()
+ *         waiter = self._new_future()             # <<<<<<<<<<<<<<
+ *         assert udp is not None
+ *         udp._set_protocol(protocol)
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_3);
+  __pyx_cur_scope->__pyx_v_waiter = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":3111
+ *         protocol = protocol_factory()
+ *         waiter = self._new_future()
+ *         assert udp is not None             # <<<<<<<<<<<<<<
+ *         udp._set_protocol(protocol)
+ *         udp._set_waiter(waiter)
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    __pyx_t_8 = (((PyObject *)__pyx_cur_scope->__pyx_v_udp) != Py_None);
+    if (unlikely(!(__pyx_t_8 != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(0, 3111, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "uvloop/loop.pyx":3112
+ *         waiter = self._new_future()
+ *         assert udp is not None
+ *         udp._set_protocol(protocol)             # <<<<<<<<<<<<<<
+ *         udp._set_waiter(waiter)
+ *         udp._init_protocol()
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._set_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_udp), __pyx_cur_scope->__pyx_v_protocol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":3113
+ *         assert udp is not None
+ *         udp._set_protocol(protocol)
+ *         udp._set_waiter(waiter)             # <<<<<<<<<<<<<<
+ *         udp._init_protocol()
+ * 
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._set_waiter(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_udp), __pyx_cur_scope->__pyx_v_waiter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":3114
+ *         udp._set_protocol(protocol)
+ *         udp._set_waiter(waiter)
+ *         udp._init_protocol()             # <<<<<<<<<<<<<<
+ * 
+ *         await waiter
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_udp)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":3116
+ *         udp._init_protocol()
+ * 
+ *         await waiter             # <<<<<<<<<<<<<<
+ *         return udp, protocol
+ * 
+ */
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 3;
+    return __pyx_r;
+    __pyx_L70_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 3116, __pyx_L1_error)
+  } else {
+    PyObject* exc_type = __Pyx_PyErr_Occurred();
+    if (exc_type) {
+      if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+      else __PYX_ERR(0, 3116, __pyx_L1_error)
+    }
+  }
+
+  /* "uvloop/loop.pyx":3117
+ * 
+ *         await waiter
+ *         return udp, protocol             # <<<<<<<<<<<<<<
+ * 
+ *     def _check_default_executor(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3117, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
+  __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
+  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_udp));
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_v_protocol);
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":2955
+ * 
+ *     @cython.iterable_coroutine
+ *     async def create_datagram_endpoint(self, protocol_factory,             # <<<<<<<<<<<<<<
+ *                                        local_addr=None, remote_addr=None, *,
+ *                                        family=0, proto=0, flags=0,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("create_datagram_endpoint", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3119
+ *         return udp, protocol
+ * 
+ *     def _check_default_executor(self):             # <<<<<<<<<<<<<<
+ *         if self._executor_shutdown_called:
+ *             raise RuntimeError('Executor shutdown has been called')
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_128_check_default_executor(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_127_check_default_executor[] = "Loop._check_default_executor(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_128_check_default_executor(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_check_default_executor (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_127_check_default_executor(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_127_check_default_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  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("_check_default_executor", 0);
+
+  /* "uvloop/loop.pyx":3120
+ * 
+ *     def _check_default_executor(self):
+ *         if self._executor_shutdown_called:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Executor shutdown has been called')
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->_executor_shutdown_called != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":3121
+ *     def _check_default_executor(self):
+ *         if self._executor_shutdown_called:
+ *             raise RuntimeError('Executor shutdown has been called')             # <<<<<<<<<<<<<<
+ * 
+ *     def _asyncgen_finalizer_hook(self, agen):
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__97, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3121, __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(0, 3121, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":3120
+ * 
+ *     def _check_default_executor(self):
+ *         if self._executor_shutdown_called:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Executor shutdown has been called')
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":3119
+ *         return udp, protocol
+ * 
+ *     def _check_default_executor(self):             # <<<<<<<<<<<<<<
+ *         if self._executor_shutdown_called:
+ *             raise RuntimeError('Executor shutdown has been called')
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Loop._check_default_executor", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3123
+ *             raise RuntimeError('Executor shutdown has been called')
+ * 
+ *     def _asyncgen_finalizer_hook(self, agen):             # <<<<<<<<<<<<<<
+ *         self._asyncgens.discard(agen)
+ *         if not self.is_closed():
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_130_asyncgen_finalizer_hook(PyObject *__pyx_v_self, PyObject *__pyx_v_agen); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_129_asyncgen_finalizer_hook[] = "Loop._asyncgen_finalizer_hook(self, agen)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_130_asyncgen_finalizer_hook(PyObject *__pyx_v_self, PyObject *__pyx_v_agen) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_asyncgen_finalizer_hook (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_129_asyncgen_finalizer_hook(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_agen));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_129_asyncgen_finalizer_hook(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_agen) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_asyncgen_finalizer_hook", 0);
+
+  /* "uvloop/loop.pyx":3124
+ * 
+ *     def _asyncgen_finalizer_hook(self, agen):
+ *         self._asyncgens.discard(agen)             # <<<<<<<<<<<<<<
+ *         if not self.is_closed():
+ *             self.call_soon_threadsafe(self.create_task, agen.aclose())
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_asyncgens, __pyx_n_s_discard); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_agen) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_agen);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3124, __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;
+
+  /* "uvloop/loop.pyx":3125
+ *     def _asyncgen_finalizer_hook(self, agen):
+ *         self._asyncgens.discard(agen)
+ *         if not self.is_closed():             # <<<<<<<<<<<<<<
+ *             self.call_soon_threadsafe(self.create_task, agen.aclose())
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_is_closed); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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, 3125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3125, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_5 = ((!__pyx_t_4) != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/loop.pyx":3126
+ *         self._asyncgens.discard(agen)
+ *         if not self.is_closed():
+ *             self.call_soon_threadsafe(self.create_task, agen.aclose())             # <<<<<<<<<<<<<<
+ * 
+ *     def _asyncgen_firstiter_hook(self, agen):
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call_soon_threadsafe); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3126, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_create_task); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3126, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_agen, __pyx_n_s_aclose); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3126, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+      }
+    }
+    __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3126, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = NULL;
+    __pyx_t_9 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+        __pyx_t_9 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_3, __pyx_t_6};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3126, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_3, __pyx_t_6};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3126, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_8 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3126, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      if (__pyx_t_7) {
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_9, __pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_9, __pyx_t_6);
+      __pyx_t_3 = 0;
+      __pyx_t_6 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3126, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":3125
+ *     def _asyncgen_finalizer_hook(self, agen):
+ *         self._asyncgens.discard(agen)
+ *         if not self.is_closed():             # <<<<<<<<<<<<<<
+ *             self.call_soon_threadsafe(self.create_task, agen.aclose())
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":3123
+ *             raise RuntimeError('Executor shutdown has been called')
+ * 
+ *     def _asyncgen_finalizer_hook(self, agen):             # <<<<<<<<<<<<<<
+ *         self._asyncgens.discard(agen)
+ *         if not self.is_closed():
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.Loop._asyncgen_finalizer_hook", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3128
+ *             self.call_soon_threadsafe(self.create_task, agen.aclose())
+ * 
+ *     def _asyncgen_firstiter_hook(self, agen):             # <<<<<<<<<<<<<<
+ *         if self._asyncgens_shutdown_called:
+ *             warnings_warn(
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_132_asyncgen_firstiter_hook(PyObject *__pyx_v_self, PyObject *__pyx_v_agen); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_131_asyncgen_firstiter_hook[] = "Loop._asyncgen_firstiter_hook(self, agen)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_132_asyncgen_firstiter_hook(PyObject *__pyx_v_self, PyObject *__pyx_v_agen) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_asyncgen_firstiter_hook (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_131_asyncgen_firstiter_hook(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_agen));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_131_asyncgen_firstiter_hook(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_agen) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_asyncgen_firstiter_hook", 0);
+
+  /* "uvloop/loop.pyx":3129
+ * 
+ *     def _asyncgen_firstiter_hook(self, agen):
+ *         if self._asyncgens_shutdown_called:             # <<<<<<<<<<<<<<
+ *             warnings_warn(
+ *                 "asynchronous generator {!r} was scheduled after "
+ */
+  __pyx_t_1 = (__pyx_v_self->_asyncgens_shutdown_called != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":3132
+ *             warnings_warn(
+ *                 "asynchronous generator {!r} was scheduled after "
+ *                 "loop.shutdown_asyncgens() call".format(agen),             # <<<<<<<<<<<<<<
+ *                 ResourceWarning, source=self)
+ * 
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_asynchronous_generator_r_was_sch, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_agen) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_agen);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":3133
+ *                 "asynchronous generator {!r} was scheduled after "
+ *                 "loop.shutdown_asyncgens() call".format(agen),
+ *                 ResourceWarning, source=self)             # <<<<<<<<<<<<<<
+ * 
+ *         self._asyncgens.add(agen)
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ResourceWarning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3133, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/loop.pyx":3130
+ *     def _asyncgen_firstiter_hook(self, agen):
+ *         if self._asyncgens_shutdown_called:
+ *             warnings_warn(             # <<<<<<<<<<<<<<
+ *                 "asynchronous generator {!r} was scheduled after "
+ *                 "loop.shutdown_asyncgens() call".format(agen),
+ */
+    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3130, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+    __pyx_t_2 = 0;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/loop.pyx":3133
+ *                 "asynchronous generator {!r} was scheduled after "
+ *                 "loop.shutdown_asyncgens() call".format(agen),
+ *                 ResourceWarning, source=self)             # <<<<<<<<<<<<<<
+ * 
+ *         self._asyncgens.add(agen)
+ */
+    __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3133, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(0, 3133, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":3130
+ *     def _asyncgen_firstiter_hook(self, agen):
+ *         if self._asyncgens_shutdown_called:
+ *             warnings_warn(             # <<<<<<<<<<<<<<
+ *                 "asynchronous generator {!r} was scheduled after "
+ *                 "loop.shutdown_asyncgens() call".format(agen),
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_warnings_warn, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3130, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __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;
+
+    /* "uvloop/loop.pyx":3129
+ * 
+ *     def _asyncgen_firstiter_hook(self, agen):
+ *         if self._asyncgens_shutdown_called:             # <<<<<<<<<<<<<<
+ *             warnings_warn(
+ *                 "asynchronous generator {!r} was scheduled after "
+ */
+  }
+
+  /* "uvloop/loop.pyx":3135
+ *                 ResourceWarning, source=self)
+ * 
+ *         self._asyncgens.add(agen)             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_asyncgens, __pyx_n_s_add); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_agen) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_agen);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/loop.pyx":3128
+ *             self.call_soon_threadsafe(self.create_task, agen.aclose())
+ * 
+ *     def _asyncgen_firstiter_hook(self, agen):             # <<<<<<<<<<<<<<
+ *         if self._asyncgens_shutdown_called:
+ *             warnings_warn(
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Loop._asyncgen_firstiter_hook", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_135generator19(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":3138
+ * 
+ *     @cython.iterable_coroutine
+ *     async def shutdown_asyncgens(self):             # <<<<<<<<<<<<<<
+ *         """Shutdown all active asynchronous generators."""
+ *         self._asyncgens_shutdown_called = True
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_134shutdown_asyncgens(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_133shutdown_asyncgens[] = "Loop.shutdown_asyncgens(self)\nShutdown all active asynchronous generators.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_134shutdown_asyncgens(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("shutdown_asyncgens (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_133shutdown_asyncgens(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_133shutdown_asyncgens(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("shutdown_asyncgens", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 3138, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_135generator19, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_shutdown_asyncgens, __pyx_n_s_Loop_shutdown_asyncgens, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 3138, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.shutdown_asyncgens", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_135generator19(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *(*__pyx_t_8)(PyObject *);
+  PyObject *(*__pyx_t_9)(PyObject *);
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("shutdown_asyncgens", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L7_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 3138, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3140
+ *     async def shutdown_asyncgens(self):
+ *         """Shutdown all active asynchronous generators."""
+ *         self._asyncgens_shutdown_called = True             # <<<<<<<<<<<<<<
+ * 
+ *         if not len(self._asyncgens):
+ */
+  __pyx_cur_scope->__pyx_v_self->_asyncgens_shutdown_called = 1;
+
+  /* "uvloop/loop.pyx":3142
+ *         self._asyncgens_shutdown_called = True
+ * 
+ *         if not len(self._asyncgens):             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = __pyx_cur_scope->__pyx_v_self->_asyncgens;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 3142, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":3143
+ * 
+ *         if not len(self._asyncgens):
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         closing_agens = list(self._asyncgens)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = NULL;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":3142
+ *         self._asyncgens_shutdown_called = True
+ * 
+ *         if not len(self._asyncgens):             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/loop.pyx":3145
+ *             return
+ * 
+ *         closing_agens = list(self._asyncgens)             # <<<<<<<<<<<<<<
+ *         self._asyncgens.clear()
+ * 
+ */
+  __pyx_t_1 = PySequence_List(__pyx_cur_scope->__pyx_v_self->_asyncgens); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3145, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_cur_scope->__pyx_v_closing_agens = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":3146
+ * 
+ *         closing_agens = list(self._asyncgens)
+ *         self._asyncgens.clear()             # <<<<<<<<<<<<<<
+ * 
+ *         shutdown_coro = aio_gather(
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self->_asyncgens, __pyx_n_s_clear); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":3148
+ *         self._asyncgens.clear()
+ * 
+ *         shutdown_coro = aio_gather(             # <<<<<<<<<<<<<<
+ *             *[ag.aclose() for ag in closing_agens],
+ *             return_exceptions=True)
+ */
+  { /* enter inner scope */
+
+    /* "uvloop/loop.pyx":3149
+ * 
+ *         shutdown_coro = aio_gather(
+ *             *[ag.aclose() for ag in closing_agens],             # <<<<<<<<<<<<<<
+ *             return_exceptions=True)
+ * 
+ */
+    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3149, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = __pyx_cur_scope->__pyx_v_closing_agens; __Pyx_INCREF(__pyx_t_4); __pyx_t_2 = 0;
+    for (;;) {
+      if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_4)) break;
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_5 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_2); __Pyx_INCREF(__pyx_t_5); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 3149, __pyx_L1_error)
+      #else
+      __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3149, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      #endif
+      __Pyx_XGOTREF(__pyx_cur_scope->__pyx_8genexpr4__pyx_v_ag);
+      __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_8genexpr4__pyx_v_ag, __pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_5);
+      __pyx_t_5 = 0;
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_8genexpr4__pyx_v_ag, __pyx_n_s_aclose); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3149, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3149, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 3149, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } /* exit inner scope */
+
+  /* "uvloop/loop.pyx":3148
+ *         self._asyncgens.clear()
+ * 
+ *         shutdown_coro = aio_gather(             # <<<<<<<<<<<<<<
+ *             *[ag.aclose() for ag in closing_agens],
+ *             return_exceptions=True)
+ */
+  __pyx_t_4 = PySequence_Tuple(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":3150
+ *         shutdown_coro = aio_gather(
+ *             *[ag.aclose() for ag in closing_agens],
+ *             return_exceptions=True)             # <<<<<<<<<<<<<<
+ * 
+ *         results = await shutdown_coro
+ */
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_return_exceptions, Py_True) < 0) __PYX_ERR(0, 3150, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3148
+ *         self._asyncgens.clear()
+ * 
+ *         shutdown_coro = aio_gather(             # <<<<<<<<<<<<<<
+ *             *[ag.aclose() for ag in closing_agens],
+ *             return_exceptions=True)
+ */
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_gather, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_cur_scope->__pyx_v_shutdown_coro = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":3152
+ *             return_exceptions=True)
+ * 
+ *         results = await shutdown_coro             # <<<<<<<<<<<<<<
+ *         for result, agen in zip(results, closing_agens):
+ *             if isinstance(result, Exception):
+ */
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_shutdown_coro);
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 1;
+    return __pyx_r;
+    __pyx_L7_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 3152, __pyx_L1_error)
+    __pyx_t_5 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_5);
+  } else {
+    __pyx_t_5 = NULL;
+    if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_5) < 0) __PYX_ERR(0, 3152, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+  }
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_cur_scope->__pyx_v_results = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":3153
+ * 
+ *         results = await shutdown_coro
+ *         for result, agen in zip(results, closing_agens):             # <<<<<<<<<<<<<<
+ *             if isinstance(result, Exception):
+ *                 self.call_exception_handler({
+ */
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_results);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_results);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_cur_scope->__pyx_v_results);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_closing_agens);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_closing_agens);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_cur_scope->__pyx_v_closing_agens);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+    __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __pyx_t_2 = 0;
+    __pyx_t_8 = NULL;
+  } else {
+    __pyx_t_2 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3153, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_8 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3153, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_8)) {
+      if (likely(PyList_CheckExact(__pyx_t_5))) {
+        if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_5)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_2); __Pyx_INCREF(__pyx_t_1); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 3153, __pyx_L1_error)
+        #else
+        __pyx_t_1 = PySequence_ITEM(__pyx_t_5, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3153, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        #endif
+      } else {
+        if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_2); __Pyx_INCREF(__pyx_t_1); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 3153, __pyx_L1_error)
+        #else
+        __pyx_t_1 = PySequence_ITEM(__pyx_t_5, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3153, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        #endif
+      }
+    } else {
+      __pyx_t_1 = __pyx_t_8(__pyx_t_5);
+      if (unlikely(!__pyx_t_1)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 3153, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    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);
+      if (unlikely(size != 2)) {
+        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(0, 3153, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      if (likely(PyTuple_CheckExact(sequence))) {
+        __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); 
+        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); 
+      } else {
+        __pyx_t_4 = PyList_GET_ITEM(sequence, 0); 
+        __pyx_t_6 = PyList_GET_ITEM(sequence, 1); 
+      }
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_6);
+      #else
+      __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3153, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3153, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      #endif
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    } else {
+      Py_ssize_t index = -1;
+      __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3153, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_t_9 = Py_TYPE(__pyx_t_7)->tp_iternext;
+      index = 0; __pyx_t_4 = __pyx_t_9(__pyx_t_7); if (unlikely(!__pyx_t_4)) goto __pyx_L10_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_4);
+      index = 1; __pyx_t_6 = __pyx_t_9(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L10_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_6);
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_7), 2) < 0) __PYX_ERR(0, 3153, __pyx_L1_error)
+      __pyx_t_9 = NULL;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L11_unpacking_done;
+      __pyx_L10_unpacking_failed:;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __pyx_t_9 = NULL;
+      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+      __PYX_ERR(0, 3153, __pyx_L1_error)
+      __pyx_L11_unpacking_done:;
+    }
+    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_result);
+    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_result, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_4);
+    __pyx_t_4 = 0;
+    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_agen);
+    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_agen, __pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_6);
+    __pyx_t_6 = 0;
+
+    /* "uvloop/loop.pyx":3154
+ *         results = await shutdown_coro
+ *         for result, agen in zip(results, closing_agens):
+ *             if isinstance(result, Exception):             # <<<<<<<<<<<<<<
+ *                 self.call_exception_handler({
+ *                     'message': 'an error occurred during closing of '
+ */
+    __pyx_t_3 = __Pyx_PyException_Check(__pyx_cur_scope->__pyx_v_result); 
+    __pyx_t_10 = (__pyx_t_3 != 0);
+    if (__pyx_t_10) {
+
+      /* "uvloop/loop.pyx":3155
+ *         for result, agen in zip(results, closing_agens):
+ *             if isinstance(result, Exception):
+ *                 self.call_exception_handler({             # <<<<<<<<<<<<<<
+ *                     'message': 'an error occurred during closing of '
+ *                                'asynchronous generator {!r}'.format(agen),
+ */
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3155, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+
+      /* "uvloop/loop.pyx":3156
+ *             if isinstance(result, Exception):
+ *                 self.call_exception_handler({
+ *                     'message': 'an error occurred during closing of '             # <<<<<<<<<<<<<<
+ *                                'asynchronous generator {!r}'.format(agen),
+ *                     'exception': result,
+ */
+      __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3156, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/loop.pyx":3157
+ *                 self.call_exception_handler({
+ *                     'message': 'an error occurred during closing of '
+ *                                'asynchronous generator {!r}'.format(agen),             # <<<<<<<<<<<<<<
+ *                     'exception': result,
+ *                     'asyncgen': agen
+ */
+      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_an_error_occurred_during_closing, __pyx_n_s_format); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3157, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_12 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+        __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+        if (likely(__pyx_t_12)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+          __Pyx_INCREF(__pyx_t_12);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_11, function);
+        }
+      }
+      __pyx_t_7 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_12, __pyx_cur_scope->__pyx_v_agen) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_cur_scope->__pyx_v_agen);
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3157, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      if (PyDict_SetItem(__pyx_t_4, __pyx_n_u_message, __pyx_t_7) < 0) __PYX_ERR(0, 3156, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/loop.pyx":3158
+ *                     'message': 'an error occurred during closing of '
+ *                                'asynchronous generator {!r}'.format(agen),
+ *                     'exception': result,             # <<<<<<<<<<<<<<
+ *                     'asyncgen': agen
+ *                 })
+ */
+      if (PyDict_SetItem(__pyx_t_4, __pyx_n_u_exception, __pyx_cur_scope->__pyx_v_result) < 0) __PYX_ERR(0, 3156, __pyx_L1_error)
+
+      /* "uvloop/loop.pyx":3159
+ *                                'asynchronous generator {!r}'.format(agen),
+ *                     'exception': result,
+ *                     'asyncgen': agen             # <<<<<<<<<<<<<<
+ *                 })
+ * 
+ */
+      if (PyDict_SetItem(__pyx_t_4, __pyx_n_u_asyncgen, __pyx_cur_scope->__pyx_v_agen) < 0) __PYX_ERR(0, 3156, __pyx_L1_error)
+      __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3155, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/loop.pyx":3154
+ *         results = await shutdown_coro
+ *         for result, agen in zip(results, closing_agens):
+ *             if isinstance(result, Exception):             # <<<<<<<<<<<<<<
+ *                 self.call_exception_handler({
+ *                     'message': 'an error occurred during closing of '
+ */
+    }
+
+    /* "uvloop/loop.pyx":3153
+ * 
+ *         results = await shutdown_coro
+ *         for result, agen in zip(results, closing_agens):             # <<<<<<<<<<<<<<
+ *             if isinstance(result, Exception):
+ *                 self.call_exception_handler({
+ */
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":3138
+ * 
+ *     @cython.iterable_coroutine
+ *     async def shutdown_asyncgens(self):             # <<<<<<<<<<<<<<
+ *         """Shutdown all active asynchronous generators."""
+ *         self._asyncgens_shutdown_called = True
+ */
+
+  /* function exit code */
+  PyErr_SetNone(PyExc_StopIteration);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("shutdown_asyncgens", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_138generator20(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":3163
+ * 
+ *     @cython.iterable_coroutine
+ *     async def shutdown_default_executor(self):             # <<<<<<<<<<<<<<
+ *         """Schedule the shutdown of the default executor."""
+ *         self._executor_shutdown_called = True
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_137shutdown_default_executor(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_136shutdown_default_executor[] = "Loop.shutdown_default_executor(self)\nSchedule the shutdown of the default executor.";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_137shutdown_default_executor(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("shutdown_default_executor (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_136shutdown_default_executor(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_136shutdown_default_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("shutdown_default_executor", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 3163, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_138generator20, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_shutdown_default_executor, __pyx_n_s_Loop_shutdown_default_executor, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 3163, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Loop.shutdown_default_executor", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_4Loop_138generator20(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  char const *__pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("shutdown_default_executor", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L8_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 3163, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3165
+ *     async def shutdown_default_executor(self):
+ *         """Schedule the shutdown of the default executor."""
+ *         self._executor_shutdown_called = True             # <<<<<<<<<<<<<<
+ *         if self._default_executor is None:
+ *             return
+ */
+  __pyx_cur_scope->__pyx_v_self->_executor_shutdown_called = 1;
+
+  /* "uvloop/loop.pyx":3166
+ *         """Schedule the shutdown of the default executor."""
+ *         self._executor_shutdown_called = True
+ *         if self._default_executor is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         future = self.create_future()
+ */
+  __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->_default_executor == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":3167
+ *         self._executor_shutdown_called = True
+ *         if self._default_executor is None:
+ *             return             # <<<<<<<<<<<<<<
+ *         future = self.create_future()
+ *         thread = threading_Thread(target=self._do_shutdown, args=(future,))
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = NULL;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":3166
+ *         """Schedule the shutdown of the default executor."""
+ *         self._executor_shutdown_called = True
+ *         if self._default_executor is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         future = self.create_future()
+ */
+  }
+
+  /* "uvloop/loop.pyx":3168
+ *         if self._default_executor is None:
+ *             return
+ *         future = self.create_future()             # <<<<<<<<<<<<<<
+ *         thread = threading_Thread(target=self._do_shutdown, args=(future,))
+ *         thread.start()
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_create_future); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_3);
+  __pyx_cur_scope->__pyx_v_future = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/loop.pyx":3169
+ *             return
+ *         future = self.create_future()
+ *         thread = threading_Thread(target=self._do_shutdown, args=(future,))             # <<<<<<<<<<<<<<
+ *         thread.start()
+ *         try:
+ */
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_do_shutdown); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_target, __pyx_t_4) < 0) __PYX_ERR(0, 3169, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_future);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_future);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_cur_scope->__pyx_v_future);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_args, __pyx_t_4) < 0) __PYX_ERR(0, 3169, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_threading_Thread, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GIVEREF(__pyx_t_4);
+  __pyx_cur_scope->__pyx_v_thread = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":3170
+ *         future = self.create_future()
+ *         thread = threading_Thread(target=self._do_shutdown, args=(future,))
+ *         thread.start()             # <<<<<<<<<<<<<<
+ *         try:
+ *             await future
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_thread, __pyx_n_s_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":3171
+ *         thread = threading_Thread(target=self._do_shutdown, args=(future,))
+ *         thread.start()
+ *         try:             # <<<<<<<<<<<<<<
+ *             await future
+ *         finally:
+ */
+  /*try:*/ {
+
+    /* "uvloop/loop.pyx":3172
+ *         thread.start()
+ *         try:
+ *             await future             # <<<<<<<<<<<<<<
+ *         finally:
+ *             thread.join()
+ */
+    __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_future);
+    __Pyx_XGOTREF(__pyx_r);
+    if (likely(__pyx_r)) {
+      __Pyx_XGIVEREF(__pyx_r);
+      __Pyx_RefNannyFinishContext();
+      __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+      /* return from generator, awaiting value */
+      __pyx_generator->resume_label = 1;
+      return __pyx_r;
+      __pyx_L8_resume_from_await:;
+      if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 3172, __pyx_L6_error)
+    } else {
+      PyObject* exc_type = __Pyx_PyErr_Occurred();
+      if (exc_type) {
+        if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+        else __PYX_ERR(0, 3172, __pyx_L6_error)
+      }
+    }
+  }
+
+  /* "uvloop/loop.pyx":3174
+ *             await future
+ *         finally:
+ *             thread.join()             # <<<<<<<<<<<<<<
+ * 
+ *     def _do_shutdown(self, future):
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_thread, __pyx_n_s_join); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3174, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3, function);
+        }
+      }
+      __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3174, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L7;
+    }
+    __pyx_L6_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_assign
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __pyx_t_6 = __pyx_lineno; __pyx_t_7 = __pyx_clineno; __pyx_t_8 = __pyx_filename;
+      {
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_thread, __pyx_n_s_join); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3174, __pyx_L10_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_5 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_3, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3174, __pyx_L10_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __Pyx_ErrRestore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_7; __pyx_filename = __pyx_t_8;
+      goto __pyx_L1_error;
+      __pyx_L10_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L7:;
+  }
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/loop.pyx":3163
+ * 
+ *     @cython.iterable_coroutine
+ *     async def shutdown_default_executor(self):             # <<<<<<<<<<<<<<
+ *         """Schedule the shutdown of the default executor."""
+ *         self._executor_shutdown_called = True
+ */
+
+  /* function exit code */
+  PyErr_SetNone(PyExc_StopIteration);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("shutdown_default_executor", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3176
+ *             thread.join()
+ * 
+ *     def _do_shutdown(self, future):             # <<<<<<<<<<<<<<
+ *         try:
+ *             self._default_executor.shutdown(wait=True)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_140_do_shutdown(PyObject *__pyx_v_self, PyObject *__pyx_v_future); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_139_do_shutdown[] = "Loop._do_shutdown(self, future)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_140_do_shutdown(PyObject *__pyx_v_self, PyObject *__pyx_v_future) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_do_shutdown (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_139_do_shutdown(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_future));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_139_do_shutdown(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_future) {
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_t_13;
+  char const *__pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_do_shutdown", 0);
+
+  /* "uvloop/loop.pyx":3177
+ * 
+ *     def _do_shutdown(self, future):
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._default_executor.shutdown(wait=True)
+ *             self.call_soon_threadsafe(future.set_result, None)
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/loop.pyx":3178
+ *     def _do_shutdown(self, future):
+ *         try:
+ *             self._default_executor.shutdown(wait=True)             # <<<<<<<<<<<<<<
+ *             self.call_soon_threadsafe(future.set_result, None)
+ *         except Exception as ex:
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_default_executor, __pyx_n_s_shutdown); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3178, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3178, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_wait, Py_True) < 0) __PYX_ERR(0, 3178, __pyx_L3_error)
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3178, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/loop.pyx":3179
+ *         try:
+ *             self._default_executor.shutdown(wait=True)
+ *             self.call_soon_threadsafe(future.set_result, None)             # <<<<<<<<<<<<<<
+ *         except Exception as ex:
+ *             self.call_soon_threadsafe(future.set_exception, ex)
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call_soon_threadsafe); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3179, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3179, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_7 = NULL;
+      __pyx_t_8 = 0;
+      if (CYTHON_UNPACK_METHODS && likely(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_5, function);
+          __pyx_t_8 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_4, Py_None};
+        __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3179, __pyx_L3_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_4, Py_None};
+        __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3179, __pyx_L3_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3179, __pyx_L3_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_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_4);
+        __Pyx_INCREF(Py_None);
+        __Pyx_GIVEREF(Py_None);
+        PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, Py_None);
+        __pyx_t_4 = 0;
+        __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3179, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/loop.pyx":3177
+ * 
+ *     def _do_shutdown(self, future):
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._default_executor.shutdown(wait=True)
+ *             self.call_soon_threadsafe(future.set_result, None)
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/loop.pyx":3180
+ *             self._default_executor.shutdown(wait=True)
+ *             self.call_soon_threadsafe(future.set_result, None)
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self.call_soon_threadsafe(future.set_exception, ex)
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("uvloop.loop.Loop._do_shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_9) < 0) __PYX_ERR(0, 3180, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_v_ex = __pyx_t_5;
+      /*try:*/ {
+
+        /* "uvloop/loop.pyx":3181
+ *             self.call_soon_threadsafe(future.set_result, None)
+ *         except Exception as ex:
+ *             self.call_soon_threadsafe(future.set_exception, ex)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call_soon_threadsafe); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3181, __pyx_L14_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3181, __pyx_L14_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __pyx_t_11 = NULL;
+        __pyx_t_8 = 0;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+          __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_7);
+          if (likely(__pyx_t_11)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+            __Pyx_INCREF(__pyx_t_11);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_7, function);
+            __pyx_t_8 = 1;
+          }
+        }
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_7)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_11, __pyx_t_10, __pyx_v_ex};
+          __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3181, __pyx_L14_error)
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_11, __pyx_t_10, __pyx_v_ex};
+          __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3181, __pyx_L14_error)
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        } else
+        #endif
+        {
+          __pyx_t_12 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3181, __pyx_L14_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          if (__pyx_t_11) {
+            __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_11); __pyx_t_11 = NULL;
+          }
+          __Pyx_GIVEREF(__pyx_t_10);
+          PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_8, __pyx_t_10);
+          __Pyx_INCREF(__pyx_v_ex);
+          __Pyx_GIVEREF(__pyx_v_ex);
+          PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_8, __pyx_v_ex);
+          __pyx_t_10 = 0;
+          __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3181, __pyx_L14_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+
+      /* "uvloop/loop.pyx":3180
+ *             self._default_executor.shutdown(wait=True)
+ *             self.call_soon_threadsafe(future.set_result, None)
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self.call_soon_threadsafe(future.set_exception, ex)
+ * 
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L15;
+        }
+        __pyx_L14_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_20);
+          __pyx_t_8 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+          }
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+          __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+          __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
+          goto __pyx_L5_except_error;
+        }
+        __pyx_L15:;
+      }
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/loop.pyx":3177
+ * 
+ *     def _do_shutdown(self, future):
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._default_executor.shutdown(wait=True)
+ *             self.call_soon_threadsafe(future.set_result, None)
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/loop.pyx":3176
+ *             thread.join()
+ * 
+ *     def _do_shutdown(self, future):             # <<<<<<<<<<<<<<
+ *         try:
+ *             self._default_executor.shutdown(wait=True)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("uvloop.loop.Loop._do_shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":39
+ *         int _coroutine_origin_tracking_saved_depth
+ * 
+ *         public slow_callback_duration             # <<<<<<<<<<<<<<
+ * 
+ *         readonly bint _closed
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->slow_callback_duration);
+  __pyx_r = __pyx_v_self->slow_callback_duration;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
+static int __pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_2__set__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_value));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_2__set__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_value) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+  __Pyx_INCREF(__pyx_v_value);
+  __Pyx_GIVEREF(__pyx_v_value);
+  __Pyx_GOTREF(__pyx_v_self->slow_callback_duration);
+  __Pyx_DECREF(__pyx_v_self->slow_callback_duration);
+  __pyx_v_self->slow_callback_duration = __pyx_v_value;
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_5__del__(PyObject *__pyx_v_self); /*proto*/
+static int __pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_5__del__(PyObject *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_4__del__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_4__del__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__del__", 0);
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->slow_callback_duration);
+  __Pyx_DECREF(__pyx_v_self->slow_callback_duration);
+  __pyx_v_self->slow_callback_duration = Py_None;
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":41
+ *         public slow_callback_duration
+ * 
+ *         readonly bint _closed             # <<<<<<<<<<<<<<
+ *         bint _debug
+ *         bint _running
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_7_closed_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_7_closed_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_7_closed___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_7_closed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_closed); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._closed.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":94
+ *         # True when compiled with DEBUG.
+ *         # Used only in unittests.
+ *         readonly bint _debug_cc             # <<<<<<<<<<<<<<
+ * 
+ *         readonly object _debug_handles_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_9_debug_cc_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_9_debug_cc_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_9_debug_cc___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_9_debug_cc___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_debug_cc); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_cc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":96
+ *         readonly bint _debug_cc
+ * 
+ *         readonly object _debug_handles_total             # <<<<<<<<<<<<<<
+ *         readonly object _debug_handles_closed
+ *         readonly object _debug_handles_current
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_20_debug_handles_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_20_debug_handles_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_20_debug_handles_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_20_debug_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_debug_handles_total);
+  __pyx_r = __pyx_v_self->_debug_handles_total;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":97
+ * 
+ *         readonly object _debug_handles_total
+ *         readonly object _debug_handles_closed             # <<<<<<<<<<<<<<
+ *         readonly object _debug_handles_current
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21_debug_handles_closed_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21_debug_handles_closed_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_21_debug_handles_closed___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_21_debug_handles_closed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_debug_handles_closed);
+  __pyx_r = __pyx_v_self->_debug_handles_closed;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":98
+ *         readonly object _debug_handles_total
+ *         readonly object _debug_handles_closed
+ *         readonly object _debug_handles_current             # <<<<<<<<<<<<<<
+ * 
+ *         readonly uint64_t _debug_uv_handles_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_22_debug_handles_current_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_22_debug_handles_current_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_22_debug_handles_current___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22_debug_handles_current___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_debug_handles_current);
+  __pyx_r = __pyx_v_self->_debug_handles_current;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":100
+ *         readonly object _debug_handles_current
+ * 
+ *         readonly uint64_t _debug_uv_handles_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_uv_handles_freed
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_uv_handles_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_uv_handles_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_uv_handles_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 100, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_uv_handles_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":101
+ * 
+ *         readonly uint64_t _debug_uv_handles_total
+ *         readonly uint64_t _debug_uv_handles_freed             # <<<<<<<<<<<<<<
+ * 
+ *         readonly uint64_t _debug_cb_handles_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_uv_handles_freed_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_uv_handles_freed_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_freed___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_freed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_uv_handles_freed); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_uv_handles_freed.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":103
+ *         readonly uint64_t _debug_uv_handles_freed
+ * 
+ *         readonly uint64_t _debug_cb_handles_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_cb_handles_count
+ *         readonly uint64_t _debug_cb_timer_handles_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_cb_handles_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_cb_handles_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_handles_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 103, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_cb_handles_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":104
+ * 
+ *         readonly uint64_t _debug_cb_handles_total
+ *         readonly uint64_t _debug_cb_handles_count             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_cb_timer_handles_total
+ *         readonly uint64_t _debug_cb_timer_handles_count
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_cb_handles_count_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_cb_handles_count_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_count___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_count___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_handles_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 104, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_cb_handles_count.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":105
+ *         readonly uint64_t _debug_cb_handles_total
+ *         readonly uint64_t _debug_cb_handles_count
+ *         readonly uint64_t _debug_cb_timer_handles_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_cb_timer_handles_count
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_timer_handles_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 105, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_cb_timer_handles_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":106
+ *         readonly uint64_t _debug_cb_handles_count
+ *         readonly uint64_t _debug_cb_timer_handles_total
+ *         readonly uint64_t _debug_cb_timer_handles_count             # <<<<<<<<<<<<<<
+ * 
+ *         readonly uint64_t _debug_stream_shutdown_errors_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_count_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_count_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_count___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_count___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_timer_handles_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_cb_timer_handles_count.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":108
+ *         readonly uint64_t _debug_cb_timer_handles_count
+ * 
+ *         readonly uint64_t _debug_stream_shutdown_errors_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_stream_listen_errors_total
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35_debug_stream_shutdown_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35_debug_stream_shutdown_errors_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_shutdown_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_shutdown_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_shutdown_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 108, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_shutdown_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":109
+ * 
+ *         readonly uint64_t _debug_stream_shutdown_errors_total
+ *         readonly uint64_t _debug_stream_listen_errors_total             # <<<<<<<<<<<<<<
+ * 
+ *         readonly uint64_t _debug_stream_read_cb_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_33_debug_stream_listen_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_33_debug_stream_listen_errors_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_33_debug_stream_listen_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_33_debug_stream_listen_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_listen_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 109, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_listen_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":111
+ *         readonly uint64_t _debug_stream_listen_errors_total
+ * 
+ *         readonly uint64_t _debug_stream_read_cb_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_stream_read_cb_errors_total
+ *         readonly uint64_t _debug_stream_read_eof_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_debug_stream_read_cb_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_debug_stream_read_cb_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_read_cb_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_read_cb_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_cb_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_read_cb_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":112
+ * 
+ *         readonly uint64_t _debug_stream_read_cb_total
+ *         readonly uint64_t _debug_stream_read_cb_errors_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_stream_read_eof_total
+ *         readonly uint64_t _debug_stream_read_eof_cb_errors_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_34_debug_stream_read_cb_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_34_debug_stream_read_cb_errors_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_34_debug_stream_read_cb_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_34_debug_stream_read_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_cb_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_read_cb_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":113
+ *         readonly uint64_t _debug_stream_read_cb_total
+ *         readonly uint64_t _debug_stream_read_cb_errors_total
+ *         readonly uint64_t _debug_stream_read_eof_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_stream_read_eof_cb_errors_total
+ *         readonly uint64_t _debug_stream_read_errors_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_28_debug_stream_read_eof_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_28_debug_stream_read_eof_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_28_debug_stream_read_eof_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28_debug_stream_read_eof_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_eof_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_read_eof_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":114
+ *         readonly uint64_t _debug_stream_read_cb_errors_total
+ *         readonly uint64_t _debug_stream_read_eof_total
+ *         readonly uint64_t _debug_stream_read_eof_cb_errors_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_stream_read_errors_total
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_38_debug_stream_read_eof_cb_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_38_debug_stream_read_eof_cb_errors_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_38_debug_stream_read_eof_cb_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_38_debug_stream_read_eof_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_eof_cb_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_read_eof_cb_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":115
+ *         readonly uint64_t _debug_stream_read_eof_total
+ *         readonly uint64_t _debug_stream_read_eof_cb_errors_total
+ *         readonly uint64_t _debug_stream_read_errors_total             # <<<<<<<<<<<<<<
+ * 
+ *         readonly uint64_t _debug_stream_write_tries
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_31_debug_stream_read_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_31_debug_stream_read_errors_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_31_debug_stream_read_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_31_debug_stream_read_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 115, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_read_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":117
+ *         readonly uint64_t _debug_stream_read_errors_total
+ * 
+ *         readonly uint64_t _debug_stream_write_tries             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_stream_write_errors_total
+ *         readonly uint64_t _debug_stream_write_ctx_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_25_debug_stream_write_tries_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_25_debug_stream_write_tries_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_25_debug_stream_write_tries___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_25_debug_stream_write_tries___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_tries); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 117, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_write_tries.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":118
+ * 
+ *         readonly uint64_t _debug_stream_write_tries
+ *         readonly uint64_t _debug_stream_write_errors_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_stream_write_ctx_total
+ *         readonly uint64_t _debug_stream_write_ctx_cnt
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_32_debug_stream_write_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_32_debug_stream_write_errors_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_32_debug_stream_write_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_32_debug_stream_write_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_write_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":119
+ *         readonly uint64_t _debug_stream_write_tries
+ *         readonly uint64_t _debug_stream_write_errors_total
+ *         readonly uint64_t _debug_stream_write_ctx_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_stream_write_ctx_cnt
+ *         readonly uint64_t _debug_stream_write_cb_errors_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_stream_write_ctx_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_stream_write_ctx_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_29_debug_stream_write_ctx_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_stream_write_ctx_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_ctx_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_write_ctx_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":120
+ *         readonly uint64_t _debug_stream_write_errors_total
+ *         readonly uint64_t _debug_stream_write_ctx_total
+ *         readonly uint64_t _debug_stream_write_ctx_cnt             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _debug_stream_write_cb_errors_total
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_debug_stream_write_ctx_cnt_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_debug_stream_write_ctx_cnt_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_write_ctx_cnt___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_write_ctx_cnt___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_ctx_cnt); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_write_ctx_cnt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":121
+ *         readonly uint64_t _debug_stream_write_ctx_total
+ *         readonly uint64_t _debug_stream_write_ctx_cnt
+ *         readonly uint64_t _debug_stream_write_cb_errors_total             # <<<<<<<<<<<<<<
+ * 
+ *         readonly uint64_t _poll_read_events_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35_debug_stream_write_cb_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35_debug_stream_write_cb_errors_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_write_cb_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_write_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_cb_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_write_cb_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":123
+ *         readonly uint64_t _debug_stream_write_cb_errors_total
+ * 
+ *         readonly uint64_t _poll_read_events_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _poll_read_cb_errors_total
+ *         readonly uint64_t _poll_write_events_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_poll_read_events_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_poll_read_events_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_23_poll_read_events_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_poll_read_events_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_read_events_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._poll_read_events_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":124
+ * 
+ *         readonly uint64_t _poll_read_events_total
+ *         readonly uint64_t _poll_read_cb_errors_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _poll_write_events_total
+ *         readonly uint64_t _poll_write_cb_errors_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_26_poll_read_cb_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_26_poll_read_cb_errors_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_26_poll_read_cb_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_26_poll_read_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_read_cb_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._poll_read_cb_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":125
+ *         readonly uint64_t _poll_read_events_total
+ *         readonly uint64_t _poll_read_cb_errors_total
+ *         readonly uint64_t _poll_write_events_total             # <<<<<<<<<<<<<<
+ *         readonly uint64_t _poll_write_cb_errors_total
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_24_poll_write_events_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_24_poll_write_events_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_24_poll_write_events_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24_poll_write_events_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_write_events_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._poll_write_events_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":126
+ *         readonly uint64_t _poll_read_cb_errors_total
+ *         readonly uint64_t _poll_write_events_total
+ *         readonly uint64_t _poll_write_cb_errors_total             # <<<<<<<<<<<<<<
+ * 
+ *         readonly uint64_t _sock_try_write_total
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_poll_write_cb_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_poll_write_cb_errors_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_27_poll_write_cb_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_poll_write_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_write_cb_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._poll_write_cb_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":128
+ *         readonly uint64_t _poll_write_cb_errors_total
+ * 
+ *         readonly uint64_t _sock_try_write_total             # <<<<<<<<<<<<<<
+ * 
+ *         readonly uint64_t _debug_exception_handler_cnt
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21_sock_try_write_total_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21_sock_try_write_total_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_21_sock_try_write_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_21_sock_try_write_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_sock_try_write_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._sock_try_write_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pxd":130
+ *         readonly uint64_t _sock_try_write_total
+ * 
+ *         readonly uint64_t _debug_exception_handler_cnt             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _init_debug_fields(self)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_28_debug_exception_handler_cnt_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_28_debug_exception_handler_cnt_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_4Loop_28_debug_exception_handler_cnt___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28_debug_exception_handler_cnt___get__(struct __pyx_obj_6uvloop_4loop_Loop *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_exception_handler_cnt); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop._debug_exception_handler_cnt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_142__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_141__reduce_cython__[] = "Loop.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_142__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_6uvloop_4loop_4Loop_141__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_141__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__98, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop.__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_6uvloop_4loop_4Loop_144__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_4Loop_143__setstate_cython__[] = "Loop.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_4Loop_144__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_6uvloop_4loop_4Loop_143__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_4Loop_143__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__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);
+
+  /* "(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__99, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Loop.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3184
+ * 
+ * 
+ * cdef void __loop_alloc_buffer(uv.uv_handle_t* uvhandle,             # <<<<<<<<<<<<<<
+ *                               size_t suggested_size,
+ *                               uv.uv_buf_t* buf) with gil:
+ */
+
+static void __pyx_f_6uvloop_4loop___loop_alloc_buffer(uv_handle_t *__pyx_v_uvhandle, CYTHON_UNUSED size_t __pyx_v_suggested_size, uv_buf_t *__pyx_v_buf) {
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  PyObject *__pyx_v_exc = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  char *__pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__loop_alloc_buffer", 0);
+
+  /* "uvloop/loop.pyx":3188
+ *                               uv.uv_buf_t* buf) with gil:
+ *     cdef:
+ *         Loop loop = (<UVHandle>uvhandle.data)._loop             # <<<<<<<<<<<<<<
+ * 
+ *     if loop._recv_buffer_in_use == 1:
+ */
+  __pyx_t_1 = ((PyObject *)((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_uvhandle->data)->_loop);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":3190
+ *         Loop loop = (<UVHandle>uvhandle.data)._loop
+ * 
+ *     if loop._recv_buffer_in_use == 1:             # <<<<<<<<<<<<<<
+ *         buf.len = 0
+ *         exc = RuntimeError('concurrent allocations')
+ */
+  __pyx_t_2 = ((__pyx_v_loop->_recv_buffer_in_use == 1) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":3191
+ * 
+ *     if loop._recv_buffer_in_use == 1:
+ *         buf.len = 0             # <<<<<<<<<<<<<<
+ *         exc = RuntimeError('concurrent allocations')
+ *         loop._handle_exception(exc)
+ */
+    __pyx_v_buf->len = 0;
+
+    /* "uvloop/loop.pyx":3192
+ *     if loop._recv_buffer_in_use == 1:
+ *         buf.len = 0
+ *         exc = RuntimeError('concurrent allocations')             # <<<<<<<<<<<<<<
+ *         loop._handle_exception(exc)
+ *         return
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__100, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3192, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/loop.pyx":3193
+ *         buf.len = 0
+ *         exc = RuntimeError('concurrent allocations')
+ *         loop._handle_exception(exc)             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+    ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_loop->__pyx_vtab)->_handle_exception(__pyx_v_loop, __pyx_v_exc);
+
+    /* "uvloop/loop.pyx":3194
+ *         exc = RuntimeError('concurrent allocations')
+ *         loop._handle_exception(exc)
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     loop._recv_buffer_in_use = 1
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":3190
+ *         Loop loop = (<UVHandle>uvhandle.data)._loop
+ * 
+ *     if loop._recv_buffer_in_use == 1:             # <<<<<<<<<<<<<<
+ *         buf.len = 0
+ *         exc = RuntimeError('concurrent allocations')
+ */
+  }
+
+  /* "uvloop/loop.pyx":3196
+ *         return
+ * 
+ *     loop._recv_buffer_in_use = 1             # <<<<<<<<<<<<<<
+ *     buf.base = loop._recv_buffer
+ *     buf.len = sizeof(loop._recv_buffer)
+ */
+  __pyx_v_loop->_recv_buffer_in_use = 1;
+
+  /* "uvloop/loop.pyx":3197
+ * 
+ *     loop._recv_buffer_in_use = 1
+ *     buf.base = loop._recv_buffer             # <<<<<<<<<<<<<<
+ *     buf.len = sizeof(loop._recv_buffer)
+ * 
+ */
+  __pyx_t_3 = __pyx_v_loop->_recv_buffer;
+  __pyx_v_buf->base = __pyx_t_3;
+
+  /* "uvloop/loop.pyx":3198
+ *     loop._recv_buffer_in_use = 1
+ *     buf.base = loop._recv_buffer
+ *     buf.len = sizeof(loop._recv_buffer)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  if (unlikely(!__pyx_v_loop)) { __Pyx_RaiseUnboundLocalError("loop"); __PYX_ERR(0, 3198, __pyx_L1_error) }
+  __pyx_v_buf->len = (sizeof(__pyx_v_loop->_recv_buffer));
+
+  /* "uvloop/loop.pyx":3184
+ * 
+ * 
+ * cdef void __loop_alloc_buffer(uv.uv_handle_t* uvhandle,             # <<<<<<<<<<<<<<
+ *                               size_t suggested_size,
+ *                               uv.uv_buf_t* buf) with gil:
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_WriteUnraisable("uvloop.loop.__loop_alloc_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_loop);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/loop.pyx":3201
+ * 
+ * 
+ * cdef inline void __loop_free_buffer(Loop loop):             # <<<<<<<<<<<<<<
+ *     loop._recv_buffer_in_use = 0
+ * 
+ */
+
+static CYTHON_INLINE void __pyx_f_6uvloop_4loop___loop_free_buffer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__loop_free_buffer", 0);
+
+  /* "uvloop/loop.pyx":3202
+ * 
+ * cdef inline void __loop_free_buffer(Loop loop):
+ *     loop._recv_buffer_in_use = 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_loop->_recv_buffer_in_use = 0;
+
+  /* "uvloop/loop.pyx":3201
+ * 
+ * 
+ * cdef inline void __loop_free_buffer(Loop loop):             # <<<<<<<<<<<<<<
+ *     loop._recv_buffer_in_use = 0
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/loop.pyx":3207
+ * class _SyncSocketReaderFuture(aio_Future):
+ * 
+ *     def __init__(self, sock, loop):             # <<<<<<<<<<<<<<
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_23_SyncSocketReaderFuture___init__[] = "_SyncSocketReaderFuture.__init__(self, sock, loop)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_23_SyncSocketReaderFuture_1__init__ = {"__init__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_1__init__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_23_SyncSocketReaderFuture___init__};
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_sock = 0;
+  PyObject *__pyx_v_loop = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self_2,&__pyx_n_s_sock,&__pyx_n_s_loop,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_self_2)) != 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_sock)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 1); __PYX_ERR(0, 3207, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 2); __PYX_ERR(0, 3207, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 3207, __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_self = values[0];
+    __pyx_v_sock = values[1];
+    __pyx_v_loop = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3207, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop._SyncSocketReaderFuture.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture___init__(__pyx_self, __pyx_v_self, __pyx_v_sock, __pyx_v_loop);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_loop) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  /* "uvloop/loop.pyx":3208
+ * 
+ *     def __init__(self, sock, loop):
+ *         aio_Future.__init__(self, loop=loop)             # <<<<<<<<<<<<<<
+ *         self.__sock = sock
+ *         self.__loop = loop
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_Future, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_self);
+  __Pyx_GIVEREF(__pyx_v_self);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self);
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_loop, __pyx_v_loop) < 0) __PYX_ERR(0, 3208, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __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;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":3209
+ *     def __init__(self, sock, loop):
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock             # <<<<<<<<<<<<<<
+ *         self.__loop = loop
+ * 
+ */
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketReaderFuture__sock, __pyx_v_sock) < 0) __PYX_ERR(0, 3209, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3210
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock
+ *         self.__loop = loop             # <<<<<<<<<<<<<<
+ * 
+ *     def __remove_reader(self):
+ */
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketReaderFuture__loop, __pyx_v_loop) < 0) __PYX_ERR(0, 3210, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3207
+ * class _SyncSocketReaderFuture(aio_Future):
+ * 
+ *     def __init__(self, sock, loop):             # <<<<<<<<<<<<<<
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_AddTraceback("uvloop.loop._SyncSocketReaderFuture.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3212
+ *         self.__loop = loop
+ * 
+ *     def __remove_reader(self):             # <<<<<<<<<<<<<<
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_reader(self.__sock)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_3__remove_reader(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static char __pyx_doc_6uvloop_4loop_23_SyncSocketReaderFuture_2__remove_reader[] = "_SyncSocketReaderFuture.__remove_reader(self)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_23_SyncSocketReaderFuture_3__remove_reader = {"__remove_reader", (PyCFunction)__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_3__remove_reader, METH_O, __pyx_doc_6uvloop_4loop_23_SyncSocketReaderFuture_2__remove_reader};
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_3__remove_reader(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__remove_reader (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture_2__remove_reader(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture_2__remove_reader(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__remove_reader", 0);
+
+  /* "uvloop/loop.pyx":3213
+ * 
+ *     def __remove_reader(self):
+ *         if self.__sock is not None and self.__sock.fileno() != -1:             # <<<<<<<<<<<<<<
+ *             self.__loop.remove_reader(self.__sock)
+ *             self.__sock = None
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketReaderFuture__sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = (__pyx_t_2 != Py_None);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  if (__pyx_t_4) {
+  } else {
+    __pyx_t_1 = __pyx_t_4;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketReaderFuture__sock); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_fileno); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_NeObjC(__pyx_t_2, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3213, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_1 = __pyx_t_4;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":3214
+ *     def __remove_reader(self):
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_reader(self.__sock)             # <<<<<<<<<<<<<<
+ *             self.__sock = None
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketReaderFuture__loop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3214, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_remove_reader); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3214, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketReaderFuture__sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3214, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_5, function);
+      }
+    }
+    __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2);
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3214, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/loop.pyx":3215
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_reader(self.__sock)
+ *             self.__sock = None             # <<<<<<<<<<<<<<
+ * 
+ *     if PY39:
+ */
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketReaderFuture__sock, Py_None) < 0) __PYX_ERR(0, 3215, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":3213
+ * 
+ *     def __remove_reader(self):
+ *         if self.__sock is not None and self.__sock.fileno() != -1:             # <<<<<<<<<<<<<<
+ *             self.__loop.remove_reader(self.__sock)
+ *             self.__sock = None
+ */
+  }
+
+  /* "uvloop/loop.pyx":3212
+ *         self.__loop = loop
+ * 
+ *     def __remove_reader(self):             # <<<<<<<<<<<<<<
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_reader(self.__sock)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop._SyncSocketReaderFuture.__remove_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3218
+ * 
+ *     if PY39:
+ *         def cancel(self, msg=None):             # <<<<<<<<<<<<<<
+ *             self.__remove_reader()
+ *             aio_Future.cancel(self, msg=msg)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_5cancel(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_23_SyncSocketReaderFuture_4cancel[] = "_SyncSocketReaderFuture.cancel(self, msg=None)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_23_SyncSocketReaderFuture_5cancel = {"cancel", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_5cancel, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_23_SyncSocketReaderFuture_4cancel};
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_5cancel(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_msg = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("cancel (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self_2,&__pyx_n_s_msg,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)((PyObject *)Py_None));
+    if (unlikely(__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);
+        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_self_2)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_msg);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cancel") < 0)) __PYX_ERR(0, 3218, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_msg = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("cancel", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3218, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop._SyncSocketReaderFuture.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture_4cancel(__pyx_self, __pyx_v_self, __pyx_v_msg);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture_4cancel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_msg) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cancel", 0);
+
+  /* "uvloop/loop.pyx":3219
+ *     if PY39:
+ *         def cancel(self, msg=None):
+ *             self.__remove_reader()             # <<<<<<<<<<<<<<
+ *             aio_Future.cancel(self, msg=msg)
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketReaderFuture__remove); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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, 3219, __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;
+
+  /* "uvloop/loop.pyx":3220
+ *         def cancel(self, msg=None):
+ *             self.__remove_reader()
+ *             aio_Future.cancel(self, msg=msg)             # <<<<<<<<<<<<<<
+ * 
+ *     else:
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_Future, __pyx_n_s_cancel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_self);
+  __Pyx_GIVEREF(__pyx_v_self);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self);
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_msg, __pyx_v_msg) < 0) __PYX_ERR(0, 3220, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __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;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":3218
+ * 
+ *     if PY39:
+ *         def cancel(self, msg=None):             # <<<<<<<<<<<<<<
+ *             self.__remove_reader()
+ *             aio_Future.cancel(self, msg=msg)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_AddTraceback("uvloop.loop._SyncSocketReaderFuture.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3223
+ * 
+ *     else:
+ *         def cancel(self):             # <<<<<<<<<<<<<<
+ *             self.__remove_reader()
+ *             aio_Future.cancel(self)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_7cancel(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static char __pyx_doc_6uvloop_4loop_23_SyncSocketReaderFuture_6cancel[] = "_SyncSocketReaderFuture.cancel(self)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_23_SyncSocketReaderFuture_7cancel = {"cancel", (PyCFunction)__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_7cancel, METH_O, __pyx_doc_6uvloop_4loop_23_SyncSocketReaderFuture_6cancel};
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketReaderFuture_7cancel(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("cancel (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture_6cancel(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketReaderFuture_6cancel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("cancel", 0);
+
+  /* "uvloop/loop.pyx":3224
+ *     else:
+ *         def cancel(self):
+ *             self.__remove_reader()             # <<<<<<<<<<<<<<
+ *             aio_Future.cancel(self)
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketReaderFuture__remove); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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, 3224, __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;
+
+  /* "uvloop/loop.pyx":3225
+ *         def cancel(self):
+ *             self.__remove_reader()
+ *             aio_Future.cancel(self)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_Future, __pyx_n_s_cancel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3225, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_self) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3225, __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;
+
+  /* "uvloop/loop.pyx":3223
+ * 
+ *     else:
+ *         def cancel(self):             # <<<<<<<<<<<<<<
+ *             self.__remove_reader()
+ *             aio_Future.cancel(self)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop._SyncSocketReaderFuture.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3230
+ * class _SyncSocketWriterFuture(aio_Future):
+ * 
+ *     def __init__(self, sock, loop):             # <<<<<<<<<<<<<<
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_23_SyncSocketWriterFuture___init__[] = "_SyncSocketWriterFuture.__init__(self, sock, loop)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_23_SyncSocketWriterFuture_1__init__ = {"__init__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_1__init__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_23_SyncSocketWriterFuture___init__};
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_sock = 0;
+  PyObject *__pyx_v_loop = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self_2,&__pyx_n_s_sock,&__pyx_n_s_loop,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_self_2)) != 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_sock)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 1); __PYX_ERR(0, 3230, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 2); __PYX_ERR(0, 3230, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 3230, __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_self = values[0];
+    __pyx_v_sock = values[1];
+    __pyx_v_loop = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3230, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop._SyncSocketWriterFuture.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture___init__(__pyx_self, __pyx_v_self, __pyx_v_sock, __pyx_v_loop);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_loop) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  /* "uvloop/loop.pyx":3231
+ * 
+ *     def __init__(self, sock, loop):
+ *         aio_Future.__init__(self, loop=loop)             # <<<<<<<<<<<<<<
+ *         self.__sock = sock
+ *         self.__loop = loop
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_Future, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3231, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3231, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_self);
+  __Pyx_GIVEREF(__pyx_v_self);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self);
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3231, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_loop, __pyx_v_loop) < 0) __PYX_ERR(0, 3231, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3231, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __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;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":3232
+ *     def __init__(self, sock, loop):
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock             # <<<<<<<<<<<<<<
+ *         self.__loop = loop
+ * 
+ */
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketWriterFuture__sock, __pyx_v_sock) < 0) __PYX_ERR(0, 3232, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3233
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock
+ *         self.__loop = loop             # <<<<<<<<<<<<<<
+ * 
+ *     def __remove_writer(self):
+ */
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketWriterFuture__loop, __pyx_v_loop) < 0) __PYX_ERR(0, 3233, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3230
+ * class _SyncSocketWriterFuture(aio_Future):
+ * 
+ *     def __init__(self, sock, loop):             # <<<<<<<<<<<<<<
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_AddTraceback("uvloop.loop._SyncSocketWriterFuture.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3235
+ *         self.__loop = loop
+ * 
+ *     def __remove_writer(self):             # <<<<<<<<<<<<<<
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_writer(self.__sock)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_3__remove_writer(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static char __pyx_doc_6uvloop_4loop_23_SyncSocketWriterFuture_2__remove_writer[] = "_SyncSocketWriterFuture.__remove_writer(self)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_23_SyncSocketWriterFuture_3__remove_writer = {"__remove_writer", (PyCFunction)__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_3__remove_writer, METH_O, __pyx_doc_6uvloop_4loop_23_SyncSocketWriterFuture_2__remove_writer};
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_3__remove_writer(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__remove_writer (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture_2__remove_writer(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture_2__remove_writer(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__remove_writer", 0);
+
+  /* "uvloop/loop.pyx":3236
+ * 
+ *     def __remove_writer(self):
+ *         if self.__sock is not None and self.__sock.fileno() != -1:             # <<<<<<<<<<<<<<
+ *             self.__loop.remove_writer(self.__sock)
+ *             self.__sock = None
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketWriterFuture__sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = (__pyx_t_2 != Py_None);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  if (__pyx_t_4) {
+  } else {
+    __pyx_t_1 = __pyx_t_4;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketWriterFuture__sock); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_fileno); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_NeObjC(__pyx_t_2, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3236, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_1 = __pyx_t_4;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":3237
+ *     def __remove_writer(self):
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_writer(self.__sock)             # <<<<<<<<<<<<<<
+ *             self.__sock = None
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketWriterFuture__loop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_remove_writer); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketWriterFuture__sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_5, function);
+      }
+    }
+    __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2);
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/loop.pyx":3238
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_writer(self.__sock)
+ *             self.__sock = None             # <<<<<<<<<<<<<<
+ * 
+ *     if PY39:
+ */
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketWriterFuture__sock, Py_None) < 0) __PYX_ERR(0, 3238, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":3236
+ * 
+ *     def __remove_writer(self):
+ *         if self.__sock is not None and self.__sock.fileno() != -1:             # <<<<<<<<<<<<<<
+ *             self.__loop.remove_writer(self.__sock)
+ *             self.__sock = None
+ */
+  }
+
+  /* "uvloop/loop.pyx":3235
+ *         self.__loop = loop
+ * 
+ *     def __remove_writer(self):             # <<<<<<<<<<<<<<
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_writer(self.__sock)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop._SyncSocketWriterFuture.__remove_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3241
+ * 
+ *     if PY39:
+ *         def cancel(self, msg=None):             # <<<<<<<<<<<<<<
+ *             self.__remove_writer()
+ *             aio_Future.cancel(self, msg=msg)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_5cancel(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_23_SyncSocketWriterFuture_4cancel[] = "_SyncSocketWriterFuture.cancel(self, msg=None)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_23_SyncSocketWriterFuture_5cancel = {"cancel", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_5cancel, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_23_SyncSocketWriterFuture_4cancel};
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_5cancel(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_msg = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("cancel (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self_2,&__pyx_n_s_msg,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)((PyObject *)Py_None));
+    if (unlikely(__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);
+        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_self_2)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_msg);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cancel") < 0)) __PYX_ERR(0, 3241, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_msg = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("cancel", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3241, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop._SyncSocketWriterFuture.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture_4cancel(__pyx_self, __pyx_v_self, __pyx_v_msg);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture_4cancel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_msg) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cancel", 0);
+
+  /* "uvloop/loop.pyx":3242
+ *     if PY39:
+ *         def cancel(self, msg=None):
+ *             self.__remove_writer()             # <<<<<<<<<<<<<<
+ *             aio_Future.cancel(self, msg=msg)
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketWriterFuture__remove); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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, 3242, __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;
+
+  /* "uvloop/loop.pyx":3243
+ *         def cancel(self, msg=None):
+ *             self.__remove_writer()
+ *             aio_Future.cancel(self, msg=msg)             # <<<<<<<<<<<<<<
+ * 
+ *     else:
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_Future, __pyx_n_s_cancel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_self);
+  __Pyx_GIVEREF(__pyx_v_self);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self);
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_msg, __pyx_v_msg) < 0) __PYX_ERR(0, 3243, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __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;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/loop.pyx":3241
+ * 
+ *     if PY39:
+ *         def cancel(self, msg=None):             # <<<<<<<<<<<<<<
+ *             self.__remove_writer()
+ *             aio_Future.cancel(self, msg=msg)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_AddTraceback("uvloop.loop._SyncSocketWriterFuture.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3246
+ * 
+ *     else:
+ *         def cancel(self):             # <<<<<<<<<<<<<<
+ *             self.__remove_writer()
+ *             aio_Future.cancel(self)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_7cancel(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static char __pyx_doc_6uvloop_4loop_23_SyncSocketWriterFuture_6cancel[] = "_SyncSocketWriterFuture.cancel(self)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_23_SyncSocketWriterFuture_7cancel = {"cancel", (PyCFunction)__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_7cancel, METH_O, __pyx_doc_6uvloop_4loop_23_SyncSocketWriterFuture_6cancel};
+static PyObject *__pyx_pw_6uvloop_4loop_23_SyncSocketWriterFuture_7cancel(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("cancel (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture_6cancel(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_23_SyncSocketWriterFuture_6cancel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("cancel", 0);
+
+  /* "uvloop/loop.pyx":3247
+ *     else:
+ *         def cancel(self):
+ *             self.__remove_writer()             # <<<<<<<<<<<<<<
+ *             aio_Future.cancel(self)
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_SyncSocketWriterFuture__remove); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3247, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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, 3247, __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;
+
+  /* "uvloop/loop.pyx":3248
+ *         def cancel(self):
+ *             self.__remove_writer()
+ *             aio_Future.cancel(self)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_Future, __pyx_n_s_cancel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_self) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3248, __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;
+
+  /* "uvloop/loop.pyx":3246
+ * 
+ *     else:
+ *         def cancel(self):             # <<<<<<<<<<<<<<
+ *             self.__remove_writer()
+ *             aio_Future.cancel(self)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop._SyncSocketWriterFuture.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":4
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class Handle:
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._cancelled = 0
+ *         self.cb_type = 0
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_6Handle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_6Handle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Handle___cinit__(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_6Handle___cinit__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "uvloop/cbhandles.pyx":5
+ * cdef class Handle:
+ *     def __cinit__(self):
+ *         self._cancelled = 0             # <<<<<<<<<<<<<<
+ *         self.cb_type = 0
+ *         self._source_traceback = None
+ */
+  __pyx_v_self->_cancelled = 0;
+
+  /* "uvloop/cbhandles.pyx":6
+ *     def __cinit__(self):
+ *         self._cancelled = 0
+ *         self.cb_type = 0             # <<<<<<<<<<<<<<
+ *         self._source_traceback = None
+ * 
+ */
+  __pyx_v_self->cb_type = 0;
+
+  /* "uvloop/cbhandles.pyx":7
+ *         self._cancelled = 0
+ *         self.cb_type = 0
+ *         self._source_traceback = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _set_loop(self, Loop loop):
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_source_traceback);
+  __Pyx_DECREF(__pyx_v_self->_source_traceback);
+  __pyx_v_self->_source_traceback = Py_None;
+
+  /* "uvloop/cbhandles.pyx":4
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class Handle:
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._cancelled = 0
+ *         self.cb_type = 0
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":9
+ *         self._source_traceback = None
+ * 
+ *     cdef inline _set_loop(self, Loop loop):             # <<<<<<<<<<<<<<
+ *         self.loop = loop
+ *         if UVLOOP_DEBUG:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__set_loop(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop) {
+  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("_set_loop", 0);
+
+  /* "uvloop/cbhandles.pyx":10
+ * 
+ *     cdef inline _set_loop(self, Loop loop):
+ *         self.loop = loop             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_cb_handles_total += 1
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GOTREF(__pyx_v_self->loop);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->loop));
+  __pyx_v_self->loop = __pyx_v_loop;
+
+  /* "uvloop/cbhandles.pyx":11
+ *     cdef inline _set_loop(self, Loop loop):
+ *         self.loop = loop
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_cb_handles_total += 1
+ *             loop._debug_cb_handles_count += 1
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/cbhandles.pyx":12
+ *         self.loop = loop
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_cb_handles_total += 1             # <<<<<<<<<<<<<<
+ *             loop._debug_cb_handles_count += 1
+ *         if loop._debug:
+ */
+    __pyx_v_loop->_debug_cb_handles_total = (__pyx_v_loop->_debug_cb_handles_total + 1);
+
+    /* "uvloop/cbhandles.pyx":13
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_cb_handles_total += 1
+ *             loop._debug_cb_handles_count += 1             # <<<<<<<<<<<<<<
+ *         if loop._debug:
+ *             self._source_traceback = extract_stack()
+ */
+    __pyx_v_loop->_debug_cb_handles_count = (__pyx_v_loop->_debug_cb_handles_count + 1);
+
+    /* "uvloop/cbhandles.pyx":11
+ *     cdef inline _set_loop(self, Loop loop):
+ *         self.loop = loop
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_cb_handles_total += 1
+ *             loop._debug_cb_handles_count += 1
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":14
+ *             loop._debug_cb_handles_total += 1
+ *             loop._debug_cb_handles_count += 1
+ *         if loop._debug:             # <<<<<<<<<<<<<<
+ *             self._source_traceback = extract_stack()
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_loop->_debug != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/cbhandles.pyx":15
+ *             loop._debug_cb_handles_count += 1
+ *         if loop._debug:
+ *             self._source_traceback = extract_stack()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _set_context(self, object context):
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_extract_stack(); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_2);
+    __Pyx_GOTREF(__pyx_v_self->_source_traceback);
+    __Pyx_DECREF(__pyx_v_self->_source_traceback);
+    __pyx_v_self->_source_traceback = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/cbhandles.pyx":14
+ *             loop._debug_cb_handles_total += 1
+ *             loop._debug_cb_handles_count += 1
+ *         if loop._debug:             # <<<<<<<<<<<<<<
+ *             self._source_traceback = extract_stack()
+ * 
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":9
+ *         self._source_traceback = None
+ * 
+ *     cdef inline _set_loop(self, Loop loop):             # <<<<<<<<<<<<<<
+ *         self.loop = loop
+ *         if UVLOOP_DEBUG:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.Handle._set_loop", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":17
+ *             self._source_traceback = extract_stack()
+ * 
+ *     cdef inline _set_context(self, object context):             # <<<<<<<<<<<<<<
+ *         if context is None:
+ *             context = Context_CopyCurrent()
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__set_context(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self, PyObject *__pyx_v_context) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("_set_context", 0);
+  __Pyx_INCREF(__pyx_v_context);
+
+  /* "uvloop/cbhandles.pyx":18
+ * 
+ *     cdef inline _set_context(self, object context):
+ *         if context is None:             # <<<<<<<<<<<<<<
+ *             context = Context_CopyCurrent()
+ *         self.context = context
+ */
+  __pyx_t_1 = (__pyx_v_context == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/cbhandles.pyx":19
+ *     cdef inline _set_context(self, object context):
+ *         if context is None:
+ *             context = Context_CopyCurrent()             # <<<<<<<<<<<<<<
+ *         self.context = context
+ * 
+ */
+    __pyx_t_3 = Context_CopyCurrent(); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 19, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF_SET(__pyx_v_context, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/cbhandles.pyx":18
+ * 
+ *     cdef inline _set_context(self, object context):
+ *         if context is None:             # <<<<<<<<<<<<<<
+ *             context = Context_CopyCurrent()
+ *         self.context = context
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":20
+ *         if context is None:
+ *             context = Context_CopyCurrent()
+ *         self.context = context             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __Pyx_INCREF(__pyx_v_context);
+  __Pyx_GIVEREF(__pyx_v_context);
+  __Pyx_GOTREF(__pyx_v_self->context);
+  __Pyx_DECREF(__pyx_v_self->context);
+  __pyx_v_self->context = __pyx_v_context;
+
+  /* "uvloop/cbhandles.pyx":17
+ *             self._source_traceback = extract_stack()
+ * 
+ *     cdef inline _set_context(self, object context):             # <<<<<<<<<<<<<<
+ *         if context is None:
+ *             context = Context_CopyCurrent()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.Handle._set_context", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_context);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":22
+ *         self.context = context
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG and self.loop is not None:
+ *             self.loop._debug_cb_handles_count -= 1
+ */
+
+/* Python wrapper */
+static void __pyx_pw_6uvloop_4loop_6Handle_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_6uvloop_4loop_6Handle_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_6uvloop_4loop_6Handle_2__dealloc__(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_6uvloop_4loop_6Handle_2__dealloc__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "uvloop/cbhandles.pyx":23
+ * 
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG and self.loop is not None:             # <<<<<<<<<<<<<<
+ *             self.loop._debug_cb_handles_count -= 1
+ *         if self.loop is None:
+ */
+  __pyx_t_2 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->loop) != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/cbhandles.pyx":24
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG and self.loop is not None:
+ *             self.loop._debug_cb_handles_count -= 1             # <<<<<<<<<<<<<<
+ *         if self.loop is None:
+ *             raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
+ */
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->loop));
+    __pyx_t_4 = __pyx_v_self->loop;
+    __pyx_t_4->_debug_cb_handles_count = (__pyx_t_4->_debug_cb_handles_count - 1);
+    __Pyx_DECREF(((PyObject *)__pyx_t_4)); __pyx_t_4 = 0;
+
+    /* "uvloop/cbhandles.pyx":23
+ * 
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG and self.loop is not None:             # <<<<<<<<<<<<<<
+ *             self.loop._debug_cb_handles_count -= 1
+ *         if self.loop is None:
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":25
+ *         if UVLOOP_DEBUG and self.loop is not None:
+ *             self.loop._debug_cb_handles_count -= 1
+ *         if self.loop is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
+ * 
+ */
+  __pyx_t_1 = (((PyObject *)__pyx_v_self->loop) == Py_None);
+  __pyx_t_3 = (__pyx_t_1 != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/cbhandles.pyx":26
+ *             self.loop._debug_cb_handles_count -= 1
+ *         if self.loop is None:
+ *             raise RuntimeError('Handle.loop is None in Handle.__dealloc__')             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self):
+ */
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__101, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 26, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(8, 26, __pyx_L1_error)
+
+    /* "uvloop/cbhandles.pyx":25
+ *         if UVLOOP_DEBUG and self.loop is not None:
+ *             self.loop._debug_cb_handles_count -= 1
+ *         if self.loop is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
+ * 
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":22
+ *         self.context = context
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG and self.loop is not None:
+ *             self.loop._debug_cb_handles_count -= 1
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(((PyObject *)__pyx_t_4));
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_WriteUnraisable("uvloop.loop.Handle.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/cbhandles.pyx":28
+ *             raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
+ * 
+ *     def __init__(self):             # <<<<<<<<<<<<<<
+ *         raise TypeError(
+ *             '{} is not supposed to be instantiated from Python'.format(
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_6Handle_5__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_6Handle_5__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__init__", 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, "__init__", 0))) return -1;
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Handle_4__init__(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_6Handle_4__init__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  /* "uvloop/cbhandles.pyx":30
+ *     def __init__(self):
+ *         raise TypeError(
+ *             '{} is not supposed to be instantiated from Python'.format(             # <<<<<<<<<<<<<<
+ *                 self.__class__.__name__))
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_is_not_supposed_to_be_instantia, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/cbhandles.pyx":31
+ *         raise TypeError(
+ *             '{} is not supposed to be instantiated from Python'.format(
+ *                 self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _run(self):
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/cbhandles.pyx":29
+ * 
+ *     def __init__(self):
+ *         raise TypeError(             # <<<<<<<<<<<<<<
+ *             '{} is not supposed to be instantiated from Python'.format(
+ *                 self.__class__.__name__))
+ */
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __PYX_ERR(8, 29, __pyx_L1_error)
+
+  /* "uvloop/cbhandles.pyx":28
+ *             raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
+ * 
+ *     def __init__(self):             # <<<<<<<<<<<<<<
+ *         raise TypeError(
+ *             '{} is not supposed to be instantiated from Python'.format(
+ */
+
+  /* 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_AddTraceback("uvloop.loop.Handle.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":33
+ *                 self.__class__.__name__))
+ * 
+ *     cdef inline _run(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int cb_type
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__run(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
+  int __pyx_v_cb_type;
+  PyObject *__pyx_v_callback = 0;
+  PyObject *__pyx_v_args = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_v_msg = NULL;
+  PyObject *__pyx_v_context = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_7;
+  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_t_13;
+  char const *__pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  char const *__pyx_t_21;
+  int __pyx_t_22;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_run", 0);
+
+  /* "uvloop/cbhandles.pyx":38
+ *             object callback
+ * 
+ *         if self._cancelled:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->_cancelled != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/cbhandles.pyx":39
+ * 
+ *         if self._cancelled:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         cb_type = self.cb_type
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/cbhandles.pyx":38
+ *             object callback
+ * 
+ *         if self._cancelled:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":41
+ *             return
+ * 
+ *         cb_type = self.cb_type             # <<<<<<<<<<<<<<
+ * 
+ *         # Since _run is a cdef and there's no BoundMethod,
+ */
+  __pyx_t_2 = __pyx_v_self->cb_type;
+  __pyx_v_cb_type = __pyx_t_2;
+
+  /* "uvloop/cbhandles.pyx":46
+ *         # we guard 'self' manually (since the callback
+ *         # might cause GC of the handle.)
+ *         Py_INCREF(self)             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  Py_INCREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/cbhandles.pyx":48
+ *         Py_INCREF(self)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             assert self.context is not None
+ *             Context_Enter(self.context)
+ */
+  /*try:*/ {
+    {
+      __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:*/ {
+
+        /* "uvloop/cbhandles.pyx":49
+ * 
+ *         try:
+ *             assert self.context is not None             # <<<<<<<<<<<<<<
+ *             Context_Enter(self.context)
+ * 
+ */
+        #ifndef CYTHON_WITHOUT_ASSERTIONS
+        if (unlikely(!Py_OptimizeFlag)) {
+          __pyx_t_1 = (__pyx_v_self->context != Py_None);
+          if (unlikely(!(__pyx_t_1 != 0))) {
+            PyErr_SetNone(PyExc_AssertionError);
+            __PYX_ERR(8, 49, __pyx_L7_error)
+          }
+        }
+        #endif
+
+        /* "uvloop/cbhandles.pyx":50
+ *         try:
+ *             assert self.context is not None
+ *             Context_Enter(self.context)             # <<<<<<<<<<<<<<
+ * 
+ *             if cb_type == 1:
+ */
+        __pyx_t_6 = __pyx_v_self->context;
+        __Pyx_INCREF(__pyx_t_6);
+        __pyx_t_2 = Context_Enter(__pyx_t_6); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(8, 50, __pyx_L7_error)
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+        /* "uvloop/cbhandles.pyx":52
+ *             Context_Enter(self.context)
+ * 
+ *             if cb_type == 1:             # <<<<<<<<<<<<<<
+ *                 callback = self.arg1
+ *                 if callback is None:
+ */
+        switch (__pyx_v_cb_type) {
+          case 1:
+
+          /* "uvloop/cbhandles.pyx":53
+ * 
+ *             if cb_type == 1:
+ *                 callback = self.arg1             # <<<<<<<<<<<<<<
+ *                 if callback is None:
+ *                     raise RuntimeError(
+ */
+          __pyx_t_6 = __pyx_v_self->arg1;
+          __Pyx_INCREF(__pyx_t_6);
+          __pyx_v_callback = __pyx_t_6;
+          __pyx_t_6 = 0;
+
+          /* "uvloop/cbhandles.pyx":54
+ *             if cb_type == 1:
+ *                 callback = self.arg1
+ *                 if callback is None:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         'cannot run Handle; callback is not set')
+ */
+          __pyx_t_1 = (__pyx_v_callback == Py_None);
+          __pyx_t_7 = (__pyx_t_1 != 0);
+          if (unlikely(__pyx_t_7)) {
+
+            /* "uvloop/cbhandles.pyx":55
+ *                 callback = self.arg1
+ *                 if callback is None:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         'cannot run Handle; callback is not set')
+ * 
+ */
+            __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__102, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 55, __pyx_L7_error)
+            __Pyx_GOTREF(__pyx_t_6);
+            __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+            __PYX_ERR(8, 55, __pyx_L7_error)
+
+            /* "uvloop/cbhandles.pyx":54
+ *             if cb_type == 1:
+ *                 callback = self.arg1
+ *                 if callback is None:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         'cannot run Handle; callback is not set')
+ */
+          }
+
+          /* "uvloop/cbhandles.pyx":58
+ *                         'cannot run Handle; callback is not set')
+ * 
+ *                 args = self.arg2             # <<<<<<<<<<<<<<
+ * 
+ *                 if args is None:
+ */
+          __pyx_t_6 = __pyx_v_self->arg2;
+          __Pyx_INCREF(__pyx_t_6);
+          __pyx_v_args = __pyx_t_6;
+          __pyx_t_6 = 0;
+
+          /* "uvloop/cbhandles.pyx":60
+ *                 args = self.arg2
+ * 
+ *                 if args is None:             # <<<<<<<<<<<<<<
+ *                     callback()
+ *                 else:
+ */
+          __pyx_t_7 = (__pyx_v_args == Py_None);
+          __pyx_t_1 = (__pyx_t_7 != 0);
+          if (__pyx_t_1) {
+
+            /* "uvloop/cbhandles.pyx":61
+ * 
+ *                 if args is None:
+ *                     callback()             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     callback(*args)
+ */
+            __Pyx_INCREF(__pyx_v_callback);
+            __pyx_t_8 = __pyx_v_callback; __pyx_t_9 = NULL;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+              __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+              if (likely(__pyx_t_9)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+                __Pyx_INCREF(__pyx_t_9);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_8, function);
+              }
+            }
+            __pyx_t_6 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_8);
+            __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+            if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 61, __pyx_L7_error)
+            __Pyx_GOTREF(__pyx_t_6);
+            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+            /* "uvloop/cbhandles.pyx":60
+ *                 args = self.arg2
+ * 
+ *                 if args is None:             # <<<<<<<<<<<<<<
+ *                     callback()
+ *                 else:
+ */
+            goto __pyx_L14;
+          }
+
+          /* "uvloop/cbhandles.pyx":63
+ *                     callback()
+ *                 else:
+ *                     callback(*args)             # <<<<<<<<<<<<<<
+ * 
+ *             elif cb_type == 2:
+ */
+          /*else*/ {
+            __pyx_t_6 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 63, __pyx_L7_error)
+            __Pyx_GOTREF(__pyx_t_6);
+            __pyx_t_8 = __Pyx_PyObject_Call(__pyx_v_callback, __pyx_t_6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(8, 63, __pyx_L7_error)
+            __Pyx_GOTREF(__pyx_t_8);
+            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          }
+          __pyx_L14:;
+
+          /* "uvloop/cbhandles.pyx":52
+ *             Context_Enter(self.context)
+ * 
+ *             if cb_type == 1:             # <<<<<<<<<<<<<<
+ *                 callback = self.arg1
+ *                 if callback is None:
+ */
+          break;
+          case 2:
+
+          /* "uvloop/cbhandles.pyx":66
+ * 
+ *             elif cb_type == 2:
+ *                 (<method_t>self.callback)(self.arg1)             # <<<<<<<<<<<<<<
+ * 
+ *             elif cb_type == 3:
+ */
+          __pyx_t_8 = __pyx_v_self->arg1;
+          __Pyx_INCREF(__pyx_t_8);
+          __pyx_t_6 = ((__pyx_t_6uvloop_4loop_method_t)__pyx_v_self->callback)(__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 66, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+          /* "uvloop/cbhandles.pyx":65
+ *                     callback(*args)
+ * 
+ *             elif cb_type == 2:             # <<<<<<<<<<<<<<
+ *                 (<method_t>self.callback)(self.arg1)
+ * 
+ */
+          break;
+          case 3:
+
+          /* "uvloop/cbhandles.pyx":69
+ * 
+ *             elif cb_type == 3:
+ *                 (<method1_t>self.callback)(self.arg1, self.arg2)             # <<<<<<<<<<<<<<
+ * 
+ *             elif cb_type == 4:
+ */
+          __pyx_t_6 = __pyx_v_self->arg1;
+          __Pyx_INCREF(__pyx_t_6);
+          __pyx_t_8 = __pyx_v_self->arg2;
+          __Pyx_INCREF(__pyx_t_8);
+          __pyx_t_9 = ((__pyx_t_6uvloop_4loop_method1_t)__pyx_v_self->callback)(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(8, 69, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+          /* "uvloop/cbhandles.pyx":68
+ *                 (<method_t>self.callback)(self.arg1)
+ * 
+ *             elif cb_type == 3:             # <<<<<<<<<<<<<<
+ *                 (<method1_t>self.callback)(self.arg1, self.arg2)
+ * 
+ */
+          break;
+          case 4:
+
+          /* "uvloop/cbhandles.pyx":72
+ * 
+ *             elif cb_type == 4:
+ *                 (<method2_t>self.callback)(self.arg1, self.arg2, self.arg3)             # <<<<<<<<<<<<<<
+ * 
+ *             elif cb_type == 5:
+ */
+          __pyx_t_9 = __pyx_v_self->arg1;
+          __Pyx_INCREF(__pyx_t_9);
+          __pyx_t_8 = __pyx_v_self->arg2;
+          __Pyx_INCREF(__pyx_t_8);
+          __pyx_t_6 = __pyx_v_self->arg3;
+          __Pyx_INCREF(__pyx_t_6);
+          __pyx_t_10 = ((__pyx_t_6uvloop_4loop_method2_t)__pyx_v_self->callback)(__pyx_t_9, __pyx_t_8, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(8, 72, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+          /* "uvloop/cbhandles.pyx":71
+ *                 (<method1_t>self.callback)(self.arg1, self.arg2)
+ * 
+ *             elif cb_type == 4:             # <<<<<<<<<<<<<<
+ *                 (<method2_t>self.callback)(self.arg1, self.arg2, self.arg3)
+ * 
+ */
+          break;
+          case 5:
+
+          /* "uvloop/cbhandles.pyx":76
+ *             elif cb_type == 5:
+ *                 (<method3_t>self.callback)(
+ *                     self.arg1, self.arg2, self.arg3, self.arg4)             # <<<<<<<<<<<<<<
+ * 
+ *             else:
+ */
+          __pyx_t_10 = __pyx_v_self->arg1;
+          __Pyx_INCREF(__pyx_t_10);
+          __pyx_t_6 = __pyx_v_self->arg2;
+          __Pyx_INCREF(__pyx_t_6);
+          __pyx_t_8 = __pyx_v_self->arg3;
+          __Pyx_INCREF(__pyx_t_8);
+          __pyx_t_9 = __pyx_v_self->arg4;
+          __Pyx_INCREF(__pyx_t_9);
+
+          /* "uvloop/cbhandles.pyx":75
+ * 
+ *             elif cb_type == 5:
+ *                 (<method3_t>self.callback)(             # <<<<<<<<<<<<<<
+ *                     self.arg1, self.arg2, self.arg3, self.arg4)
+ * 
+ */
+          __pyx_t_11 = ((__pyx_t_6uvloop_4loop_method3_t)__pyx_v_self->callback)(__pyx_t_10, __pyx_t_6, __pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_11)) __PYX_ERR(8, 75, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+
+          /* "uvloop/cbhandles.pyx":74
+ *                 (<method2_t>self.callback)(self.arg1, self.arg2, self.arg3)
+ * 
+ *             elif cb_type == 5:             # <<<<<<<<<<<<<<
+ *                 (<method3_t>self.callback)(
+ *                     self.arg1, self.arg2, self.arg3, self.arg4)
+ */
+          break;
+          default:
+
+          /* "uvloop/cbhandles.pyx":79
+ * 
+ *             else:
+ *                 raise RuntimeError('invalid Handle.cb_type: {}'.format(             # <<<<<<<<<<<<<<
+ *                     cb_type))
+ * 
+ */
+          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_invalid_Handle_cb_type, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(8, 79, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_9);
+
+          /* "uvloop/cbhandles.pyx":80
+ *             else:
+ *                 raise RuntimeError('invalid Handle.cb_type: {}'.format(
+ *                     cb_type))             # <<<<<<<<<<<<<<
+ * 
+ *         except (KeyboardInterrupt, SystemExit):
+ */
+          __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_cb_type); if (unlikely(!__pyx_t_8)) __PYX_ERR(8, 80, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_8);
+          __pyx_t_6 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) {
+            __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_9);
+            if (likely(__pyx_t_6)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+              __Pyx_INCREF(__pyx_t_6);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_9, function);
+            }
+          }
+          __pyx_t_11 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_6, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_8);
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (unlikely(!__pyx_t_11)) __PYX_ERR(8, 79, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+          /* "uvloop/cbhandles.pyx":79
+ * 
+ *             else:
+ *                 raise RuntimeError('invalid Handle.cb_type: {}'.format(             # <<<<<<<<<<<<<<
+ *                     cb_type))
+ * 
+ */
+          __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(8, 79, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_Raise(__pyx_t_9, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __PYX_ERR(8, 79, __pyx_L7_error)
+          break;
+        }
+
+        /* "uvloop/cbhandles.pyx":48
+ *         Py_INCREF(self)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             assert self.context is not None
+ *             Context_Enter(self.context)
+ */
+      }
+      __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_L12_try_end;
+      __pyx_L7_error:;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/cbhandles.pyx":82
+ *                     cb_type))
+ * 
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException as ex:
+ */
+      __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_2) {
+        __Pyx_AddTraceback("uvloop.loop.Handle._run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_11, &__pyx_t_8) < 0) __PYX_ERR(8, 82, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_GOTREF(__pyx_t_8);
+
+        /* "uvloop/cbhandles.pyx":83
+ * 
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException as ex:
+ *             if cb_type == 1:
+ */
+        __Pyx_GIVEREF(__pyx_t_9);
+        __Pyx_GIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __Pyx_ErrRestoreWithState(__pyx_t_9, __pyx_t_11, __pyx_t_8);
+        __pyx_t_9 = 0; __pyx_t_11 = 0; __pyx_t_8 = 0; 
+        __PYX_ERR(8, 83, __pyx_L9_except_error)
+      }
+
+      /* "uvloop/cbhandles.pyx":84
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             if cb_type == 1:
+ *                 msg = 'Exception in callback {}'.format(callback)
+ */
+      __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_2) {
+        __Pyx_AddTraceback("uvloop.loop.Handle._run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_11, &__pyx_t_9) < 0) __PYX_ERR(8, 84, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_INCREF(__pyx_t_11);
+        __pyx_v_ex = __pyx_t_11;
+        /*try:*/ {
+
+          /* "uvloop/cbhandles.pyx":85
+ *             raise
+ *         except BaseException as ex:
+ *             if cb_type == 1:             # <<<<<<<<<<<<<<
+ *                 msg = 'Exception in callback {}'.format(callback)
+ *             else:
+ */
+          __pyx_t_1 = ((__pyx_v_cb_type == 1) != 0);
+          if (__pyx_t_1) {
+
+            /* "uvloop/cbhandles.pyx":86
+ *         except BaseException as ex:
+ *             if cb_type == 1:
+ *                 msg = 'Exception in callback {}'.format(callback)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 msg = 'Exception in callback {}'.format(self.meth_name)
+ */
+            __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Exception_in_callback, __pyx_n_s_format); if (unlikely(!__pyx_t_10)) __PYX_ERR(8, 86, __pyx_L22_error)
+            __Pyx_GOTREF(__pyx_t_10);
+            if (unlikely(!__pyx_v_callback)) { __Pyx_RaiseUnboundLocalError("callback"); __PYX_ERR(8, 86, __pyx_L22_error) }
+            __pyx_t_12 = NULL;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
+              __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_10);
+              if (likely(__pyx_t_12)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+                __Pyx_INCREF(__pyx_t_12);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_10, function);
+              }
+            }
+            __pyx_t_6 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_12, __pyx_v_callback) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_callback);
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 86, __pyx_L22_error)
+            __Pyx_GOTREF(__pyx_t_6);
+            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __pyx_v_msg = __pyx_t_6;
+            __pyx_t_6 = 0;
+
+            /* "uvloop/cbhandles.pyx":85
+ *             raise
+ *         except BaseException as ex:
+ *             if cb_type == 1:             # <<<<<<<<<<<<<<
+ *                 msg = 'Exception in callback {}'.format(callback)
+ *             else:
+ */
+            goto __pyx_L24;
+          }
+
+          /* "uvloop/cbhandles.pyx":88
+ *                 msg = 'Exception in callback {}'.format(callback)
+ *             else:
+ *                 msg = 'Exception in callback {}'.format(self.meth_name)             # <<<<<<<<<<<<<<
+ * 
+ *             context = {
+ */
+          /*else*/ {
+            __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Exception_in_callback, __pyx_n_s_format); if (unlikely(!__pyx_t_10)) __PYX_ERR(8, 88, __pyx_L22_error)
+            __Pyx_GOTREF(__pyx_t_10);
+            __pyx_t_12 = NULL;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
+              __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_10);
+              if (likely(__pyx_t_12)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+                __Pyx_INCREF(__pyx_t_12);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_10, function);
+              }
+            }
+            __pyx_t_6 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_12, __pyx_v_self->meth_name) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_self->meth_name);
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 88, __pyx_L22_error)
+            __Pyx_GOTREF(__pyx_t_6);
+            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __pyx_v_msg = __pyx_t_6;
+            __pyx_t_6 = 0;
+          }
+          __pyx_L24:;
+
+          /* "uvloop/cbhandles.pyx":91
+ * 
+ *             context = {
+ *                 'message': msg,             # <<<<<<<<<<<<<<
+ *                 'exception': ex,
+ *                 'handle': self,
+ */
+          __pyx_t_6 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 91, __pyx_L22_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_message, __pyx_v_msg) < 0) __PYX_ERR(8, 91, __pyx_L22_error)
+
+          /* "uvloop/cbhandles.pyx":92
+ *             context = {
+ *                 'message': msg,
+ *                 'exception': ex,             # <<<<<<<<<<<<<<
+ *                 'handle': self,
+ *             }
+ */
+          if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_exception, __pyx_v_ex) < 0) __PYX_ERR(8, 91, __pyx_L22_error)
+
+          /* "uvloop/cbhandles.pyx":93
+ *                 'message': msg,
+ *                 'exception': ex,
+ *                 'handle': self,             # <<<<<<<<<<<<<<
+ *             }
+ * 
+ */
+          if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_handle, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(8, 91, __pyx_L22_error)
+          __pyx_v_context = __pyx_t_6;
+          __pyx_t_6 = 0;
+
+          /* "uvloop/cbhandles.pyx":96
+ *             }
+ * 
+ *             if self._source_traceback is not None:             # <<<<<<<<<<<<<<
+ *                 context['source_traceback'] = self._source_traceback
+ * 
+ */
+          __pyx_t_1 = (__pyx_v_self->_source_traceback != Py_None);
+          __pyx_t_7 = (__pyx_t_1 != 0);
+          if (__pyx_t_7) {
+
+            /* "uvloop/cbhandles.pyx":97
+ * 
+ *             if self._source_traceback is not None:
+ *                 context['source_traceback'] = self._source_traceback             # <<<<<<<<<<<<<<
+ * 
+ *             self.loop.call_exception_handler(context)
+ */
+            __pyx_t_6 = __pyx_v_self->_source_traceback;
+            __Pyx_INCREF(__pyx_t_6);
+            if (unlikely(PyObject_SetItem(__pyx_v_context, __pyx_n_u_source_traceback, __pyx_t_6) < 0)) __PYX_ERR(8, 97, __pyx_L22_error)
+            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+            /* "uvloop/cbhandles.pyx":96
+ *             }
+ * 
+ *             if self._source_traceback is not None:             # <<<<<<<<<<<<<<
+ *                 context['source_traceback'] = self._source_traceback
+ * 
+ */
+          }
+
+          /* "uvloop/cbhandles.pyx":99
+ *                 context['source_traceback'] = self._source_traceback
+ * 
+ *             self.loop.call_exception_handler(context)             # <<<<<<<<<<<<<<
+ * 
+ *         finally:
+ */
+          __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_10)) __PYX_ERR(8, 99, __pyx_L22_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          __pyx_t_12 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
+            __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_10);
+            if (likely(__pyx_t_12)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+              __Pyx_INCREF(__pyx_t_12);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_10, function);
+            }
+          }
+          __pyx_t_6 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_12, __pyx_v_context) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_context);
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 99, __pyx_L22_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        }
+
+        /* "uvloop/cbhandles.pyx":84
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             if cb_type == 1:
+ *                 msg = 'Exception in callback {}'.format(callback)
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L23;
+          }
+          __pyx_L22_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __pyx_t_2 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+            }
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+            __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+            __pyx_lineno = __pyx_t_2; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
+            goto __pyx_L9_except_error;
+          }
+          __pyx_L23:;
+        }
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        goto __pyx_L8_exception_handled;
+      }
+      goto __pyx_L9_except_error;
+      __pyx_L9_except_error:;
+
+      /* "uvloop/cbhandles.pyx":48
+ *         Py_INCREF(self)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             assert self.context is not None
+ *             Context_Enter(self.context)
+ */
+      __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_L5_error;
+      __pyx_L8_exception_handled:;
+      __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);
+      __pyx_L12_try_end:;
+    }
+  }
+
+  /* "uvloop/cbhandles.pyx":102
+ * 
+ *         finally:
+ *             context = self.context             # <<<<<<<<<<<<<<
+ *             Py_DECREF(self)
+ *             Context_Exit(context)
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_9 = __pyx_v_self->context;
+      __Pyx_INCREF(__pyx_t_9);
+      __Pyx_XDECREF_SET(__pyx_v_context, __pyx_t_9);
+      __pyx_t_9 = 0;
+
+      /* "uvloop/cbhandles.pyx":103
+ *         finally:
+ *             context = self.context
+ *             Py_DECREF(self)             # <<<<<<<<<<<<<<
+ *             Context_Exit(context)
+ * 
+ */
+      Py_DECREF(((PyObject *)__pyx_v_self));
+
+      /* "uvloop/cbhandles.pyx":104
+ *             context = self.context
+ *             Py_DECREF(self)
+ *             Context_Exit(context)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _cancel(self):
+ */
+      __pyx_t_13 = Context_Exit(__pyx_v_context); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(8, 104, __pyx_L1_error)
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_20);
+      __Pyx_XGOTREF(__pyx_t_19);
+      __Pyx_XGOTREF(__pyx_t_18);
+      __pyx_t_13 = __pyx_lineno; __pyx_t_2 = __pyx_clineno; __pyx_t_21 = __pyx_filename;
+      {
+
+        /* "uvloop/cbhandles.pyx":102
+ * 
+ *         finally:
+ *             context = self.context             # <<<<<<<<<<<<<<
+ *             Py_DECREF(self)
+ *             Context_Exit(context)
+ */
+        __pyx_t_9 = __pyx_v_self->context;
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_XDECREF_SET(__pyx_v_context, __pyx_t_9);
+        __pyx_t_9 = 0;
+
+        /* "uvloop/cbhandles.pyx":103
+ *         finally:
+ *             context = self.context
+ *             Py_DECREF(self)             # <<<<<<<<<<<<<<
+ *             Context_Exit(context)
+ * 
+ */
+        Py_DECREF(((PyObject *)__pyx_v_self));
+
+        /* "uvloop/cbhandles.pyx":104
+ *             context = self.context
+ *             Py_DECREF(self)
+ *             Context_Exit(context)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _cancel(self):
+ */
+        __pyx_t_22 = Context_Exit(__pyx_v_context); if (unlikely(__pyx_t_22 == ((int)-1))) __PYX_ERR(8, 104, __pyx_L31_error)
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_20);
+        __Pyx_XGIVEREF(__pyx_t_19);
+        __Pyx_XGIVEREF(__pyx_t_18);
+        __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_19, __pyx_t_18);
+      }
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_ErrRestore(__pyx_t_5, __pyx_t_4, __pyx_t_3);
+      __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0;
+      __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_2; __pyx_filename = __pyx_t_21;
+      goto __pyx_L1_error;
+      __pyx_L31_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_20);
+        __Pyx_XGIVEREF(__pyx_t_19);
+        __Pyx_XGIVEREF(__pyx_t_18);
+        __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_19, __pyx_t_18);
+      }
+      __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;
+      __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/cbhandles.pyx":33
+ *                 self.__class__.__name__))
+ * 
+ *     cdef inline _run(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int cb_type
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("uvloop.loop.Handle._run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_callback);
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XDECREF(__pyx_v_msg);
+  __Pyx_XDECREF(__pyx_v_context);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":106
+ *             Context_Exit(context)
+ * 
+ *     cdef _cancel(self):             # <<<<<<<<<<<<<<
+ *         self._cancelled = 1
+ *         self.callback = NULL
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6Handle__cancel(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_cancel", 0);
+
+  /* "uvloop/cbhandles.pyx":107
+ * 
+ *     cdef _cancel(self):
+ *         self._cancelled = 1             # <<<<<<<<<<<<<<
+ *         self.callback = NULL
+ *         self.arg1 = self.arg2 = self.arg3 = self.arg4 = None
+ */
+  __pyx_v_self->_cancelled = 1;
+
+  /* "uvloop/cbhandles.pyx":108
+ *     cdef _cancel(self):
+ *         self._cancelled = 1
+ *         self.callback = NULL             # <<<<<<<<<<<<<<
+ *         self.arg1 = self.arg2 = self.arg3 = self.arg4 = None
+ * 
+ */
+  __pyx_v_self->callback = NULL;
+
+  /* "uvloop/cbhandles.pyx":109
+ *         self._cancelled = 1
+ *         self.callback = NULL
+ *         self.arg1 = self.arg2 = self.arg3 = self.arg4 = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _format_handle(self):
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->arg1);
+  __Pyx_DECREF(__pyx_v_self->arg1);
+  __pyx_v_self->arg1 = Py_None;
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->arg2);
+  __Pyx_DECREF(__pyx_v_self->arg2);
+  __pyx_v_self->arg2 = Py_None;
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->arg3);
+  __Pyx_DECREF(__pyx_v_self->arg3);
+  __pyx_v_self->arg3 = Py_None;
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->arg4);
+  __Pyx_DECREF(__pyx_v_self->arg4);
+  __pyx_v_self->arg4 = Py_None;
+
+  /* "uvloop/cbhandles.pyx":106
+ *             Context_Exit(context)
+ * 
+ *     cdef _cancel(self):             # <<<<<<<<<<<<<<
+ *         self._cancelled = 1
+ *         self.callback = NULL
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":111
+ *         self.arg1 = self.arg2 = self.arg3 = self.arg4 = None
+ * 
+ *     cdef _format_handle(self):             # <<<<<<<<<<<<<<
+ *         # Mirrors `asyncio.base_events._format_handle`.
+ *         if self.cb_type == 1 and self.arg1 is not None:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6Handle__format_handle(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
+  PyObject *__pyx_v_cb = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  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;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_t_15;
+  char const *__pyx_t_16;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_format_handle", 0);
+
+  /* "uvloop/cbhandles.pyx":113
+ *     cdef _format_handle(self):
+ *         # Mirrors `asyncio.base_events._format_handle`.
+ *         if self.cb_type == 1 and self.arg1 is not None:             # <<<<<<<<<<<<<<
+ *             cb = self.arg1
+ *             if isinstance(getattr(cb, '__self__', None), aio_Task):
+ */
+  __pyx_t_2 = ((__pyx_v_self->cb_type == 1) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_v_self->arg1 != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/cbhandles.pyx":114
+ *         # Mirrors `asyncio.base_events._format_handle`.
+ *         if self.cb_type == 1 and self.arg1 is not None:
+ *             cb = self.arg1             # <<<<<<<<<<<<<<
+ *             if isinstance(getattr(cb, '__self__', None), aio_Task):
+ *                 try:
+ */
+    __pyx_t_4 = __pyx_v_self->arg1;
+    __Pyx_INCREF(__pyx_t_4);
+    __pyx_v_cb = __pyx_t_4;
+    __pyx_t_4 = 0;
+
+    /* "uvloop/cbhandles.pyx":115
+ *         if self.cb_type == 1 and self.arg1 is not None:
+ *             cb = self.arg1
+ *             if isinstance(getattr(cb, '__self__', None), aio_Task):             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     return repr(cb.__self__)
+ */
+    __pyx_t_4 = __Pyx_GetAttr3(__pyx_v_cb, __pyx_n_u_self, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 115, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = __pyx_v_6uvloop_4loop_aio_Task;
+    __Pyx_INCREF(__pyx_t_5);
+    __pyx_t_1 = PyObject_IsInstance(__pyx_t_4, __pyx_t_5); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(8, 115, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_3 = (__pyx_t_1 != 0);
+    if (__pyx_t_3) {
+
+      /* "uvloop/cbhandles.pyx":116
+ *             cb = self.arg1
+ *             if isinstance(getattr(cb, '__self__', None), aio_Task):
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     return repr(cb.__self__)
+ *                 except (AttributeError, TypeError, ValueError) as ex:
+ */
+      {
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
+        __Pyx_XGOTREF(__pyx_t_6);
+        __Pyx_XGOTREF(__pyx_t_7);
+        __Pyx_XGOTREF(__pyx_t_8);
+        /*try:*/ {
+
+          /* "uvloop/cbhandles.pyx":117
+ *             if isinstance(getattr(cb, '__self__', None), aio_Task):
+ *                 try:
+ *                     return repr(cb.__self__)             # <<<<<<<<<<<<<<
+ *                 except (AttributeError, TypeError, ValueError) as ex:
+ *                     # Cython generates empty __code__ objects for coroutines
+ */
+          __Pyx_XDECREF(__pyx_r);
+          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_cb, __pyx_n_s_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 117, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __pyx_t_4 = PyObject_Repr(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 117, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __pyx_r = __pyx_t_4;
+          __pyx_t_4 = 0;
+          goto __pyx_L11_try_return;
+
+          /* "uvloop/cbhandles.pyx":116
+ *             cb = self.arg1
+ *             if isinstance(getattr(cb, '__self__', None), aio_Task):
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     return repr(cb.__self__)
+ *                 except (AttributeError, TypeError, ValueError) as ex:
+ */
+        }
+        __pyx_L7_error:;
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/cbhandles.pyx":118
+ *                 try:
+ *                     return repr(cb.__self__)
+ *                 except (AttributeError, TypeError, ValueError) as ex:             # <<<<<<<<<<<<<<
+ *                     # Cython generates empty __code__ objects for coroutines
+ *                     # that can crash asyncio.Task.__repr__ with an
+ */
+        __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError);
+        if (__pyx_t_9) {
+          __Pyx_AddTraceback("uvloop.loop.Handle._format_handle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_10) < 0) __PYX_ERR(8, 118, __pyx_L9_except_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_GOTREF(__pyx_t_10);
+          __Pyx_INCREF(__pyx_t_5);
+          __pyx_v_ex = __pyx_t_5;
+          /*try:*/ {
+
+            /* "uvloop/cbhandles.pyx":122
+ *                     # that can crash asyncio.Task.__repr__ with an
+ *                     # AttributeError etc.  Guard against that.
+ *                     self.loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *                         'message': 'exception in Task.__repr__',
+ *                         'task': cb.__self__,
+ */
+            __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_12)) __PYX_ERR(8, 122, __pyx_L18_error)
+            __Pyx_GOTREF(__pyx_t_12);
+
+            /* "uvloop/cbhandles.pyx":123
+ *                     # AttributeError etc.  Guard against that.
+ *                     self.loop.call_exception_handler({
+ *                         'message': 'exception in Task.__repr__',             # <<<<<<<<<<<<<<
+ *                         'task': cb.__self__,
+ *                         'exception': ex,
+ */
+            __pyx_t_13 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_13)) __PYX_ERR(8, 123, __pyx_L18_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            if (PyDict_SetItem(__pyx_t_13, __pyx_n_u_message, __pyx_kp_u_exception_in_Task___repr) < 0) __PYX_ERR(8, 123, __pyx_L18_error)
+
+            /* "uvloop/cbhandles.pyx":124
+ *                     self.loop.call_exception_handler({
+ *                         'message': 'exception in Task.__repr__',
+ *                         'task': cb.__self__,             # <<<<<<<<<<<<<<
+ *                         'exception': ex,
+ *                         'handle': self,
+ */
+            __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_cb, __pyx_n_s_self); if (unlikely(!__pyx_t_14)) __PYX_ERR(8, 124, __pyx_L18_error)
+            __Pyx_GOTREF(__pyx_t_14);
+            if (PyDict_SetItem(__pyx_t_13, __pyx_n_u_task, __pyx_t_14) < 0) __PYX_ERR(8, 123, __pyx_L18_error)
+            __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+
+            /* "uvloop/cbhandles.pyx":125
+ *                         'message': 'exception in Task.__repr__',
+ *                         'task': cb.__self__,
+ *                         'exception': ex,             # <<<<<<<<<<<<<<
+ *                         'handle': self,
+ *                     })
+ */
+            if (PyDict_SetItem(__pyx_t_13, __pyx_n_u_exception, __pyx_v_ex) < 0) __PYX_ERR(8, 123, __pyx_L18_error)
+
+            /* "uvloop/cbhandles.pyx":126
+ *                         'task': cb.__self__,
+ *                         'exception': ex,
+ *                         'handle': self,             # <<<<<<<<<<<<<<
+ *                     })
+ *         return repr(self)
+ */
+            if (PyDict_SetItem(__pyx_t_13, __pyx_n_u_handle, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(8, 123, __pyx_L18_error)
+            __pyx_t_14 = NULL;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) {
+              __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_12);
+              if (likely(__pyx_t_14)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
+                __Pyx_INCREF(__pyx_t_14);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_12, function);
+              }
+            }
+            __pyx_t_11 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_12, __pyx_t_14, __pyx_t_13) : __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_13);
+            __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            if (unlikely(!__pyx_t_11)) __PYX_ERR(8, 122, __pyx_L18_error)
+            __Pyx_GOTREF(__pyx_t_11);
+            __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          }
+
+          /* "uvloop/cbhandles.pyx":118
+ *                 try:
+ *                     return repr(cb.__self__)
+ *                 except (AttributeError, TypeError, ValueError) as ex:             # <<<<<<<<<<<<<<
+ *                     # Cython generates empty __code__ objects for coroutines
+ *                     # that can crash asyncio.Task.__repr__ with an
+ */
+          /*finally:*/ {
+            /*normal exit:*/{
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+              goto __pyx_L19;
+            }
+            __pyx_L18_error:;
+            /*exception exit:*/{
+              __Pyx_PyThreadState_declare
+              __Pyx_PyThreadState_assign
+              __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+              __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+              __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+              if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
+              if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+              __Pyx_XGOTREF(__pyx_t_17);
+              __Pyx_XGOTREF(__pyx_t_18);
+              __Pyx_XGOTREF(__pyx_t_19);
+              __Pyx_XGOTREF(__pyx_t_20);
+              __Pyx_XGOTREF(__pyx_t_21);
+              __Pyx_XGOTREF(__pyx_t_22);
+              __pyx_t_9 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename;
+              {
+                __Pyx_DECREF(__pyx_v_ex);
+                __pyx_v_ex = NULL;
+              }
+              if (PY_MAJOR_VERSION >= 3) {
+                __Pyx_XGIVEREF(__pyx_t_20);
+                __Pyx_XGIVEREF(__pyx_t_21);
+                __Pyx_XGIVEREF(__pyx_t_22);
+                __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
+              }
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+              __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+              __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16;
+              goto __pyx_L9_except_error;
+            }
+            __pyx_L19:;
+          }
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          goto __pyx_L8_exception_handled;
+        }
+        goto __pyx_L9_except_error;
+        __pyx_L9_except_error:;
+
+        /* "uvloop/cbhandles.pyx":116
+ *             cb = self.arg1
+ *             if isinstance(getattr(cb, '__self__', None), aio_Task):
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     return repr(cb.__self__)
+ *                 except (AttributeError, TypeError, ValueError) as ex:
+ */
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+        goto __pyx_L1_error;
+        __pyx_L11_try_return:;
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+        goto __pyx_L0;
+        __pyx_L8_exception_handled:;
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      }
+
+      /* "uvloop/cbhandles.pyx":115
+ *         if self.cb_type == 1 and self.arg1 is not None:
+ *             cb = self.arg1
+ *             if isinstance(getattr(cb, '__self__', None), aio_Task):             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     return repr(cb.__self__)
+ */
+    }
+
+    /* "uvloop/cbhandles.pyx":113
+ *     cdef _format_handle(self):
+ *         # Mirrors `asyncio.base_events._format_handle`.
+ *         if self.cb_type == 1 and self.arg1 is not None:             # <<<<<<<<<<<<<<
+ *             cb = self.arg1
+ *             if isinstance(getattr(cb, '__self__', None), aio_Task):
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":128
+ *                         'handle': self,
+ *                     })
+ *         return repr(self)             # <<<<<<<<<<<<<<
+ * 
+ *     # Public API
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_10 = PyObject_Repr(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_10)) __PYX_ERR(8, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_10);
+  __pyx_r = __pyx_t_10;
+  __pyx_t_10 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/cbhandles.pyx":111
+ *         self.arg1 = self.arg2 = self.arg3 = self.arg4 = None
+ * 
+ *     cdef _format_handle(self):             # <<<<<<<<<<<<<<
+ *         # Mirrors `asyncio.base_events._format_handle`.
+ *         if self.cb_type == 1 and self.arg1 is not None:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("uvloop.loop.Handle._format_handle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_cb);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":132
+ *     # Public API
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         info = [self.__class__.__name__]
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Handle_7__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_6Handle_7__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Handle_6__repr__(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_6__repr__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
+  PyObject *__pyx_v_info = NULL;
+  PyObject *__pyx_v_func = NULL;
+  PyObject *__pyx_v_cb_name = NULL;
+  PyObject *__pyx_v_frame = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "uvloop/cbhandles.pyx":133
+ * 
+ *     def __repr__(self):
+ *         info = [self.__class__.__name__]             # <<<<<<<<<<<<<<
+ * 
+ *         if self._cancelled:
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 133, __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(8, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_v_info = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":135
+ *         info = [self.__class__.__name__]
+ * 
+ *         if self._cancelled:             # <<<<<<<<<<<<<<
+ *             info.append('cancelled')
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->_cancelled != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/cbhandles.pyx":136
+ * 
+ *         if self._cancelled:
+ *             info.append('cancelled')             # <<<<<<<<<<<<<<
+ * 
+ *         if self.cb_type == 1 and self.arg1 is not None:
+ */
+    __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_info, __pyx_n_u_cancelled); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(8, 136, __pyx_L1_error)
+
+    /* "uvloop/cbhandles.pyx":135
+ *         info = [self.__class__.__name__]
+ * 
+ *         if self._cancelled:             # <<<<<<<<<<<<<<
+ *             info.append('cancelled')
+ * 
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":138
+ *             info.append('cancelled')
+ * 
+ *         if self.cb_type == 1 and self.arg1 is not None:             # <<<<<<<<<<<<<<
+ *             func = self.arg1
+ *             # Cython can unset func.__qualname__/__name__, hence the checks.
+ */
+  __pyx_t_5 = ((__pyx_v_self->cb_type == 1) != 0);
+  if (__pyx_t_5) {
+  } else {
+    __pyx_t_3 = __pyx_t_5;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_5 = (__pyx_v_self->arg1 != Py_None);
+  __pyx_t_6 = (__pyx_t_5 != 0);
+  __pyx_t_3 = __pyx_t_6;
+  __pyx_L5_bool_binop_done:;
+  if (__pyx_t_3) {
+
+    /* "uvloop/cbhandles.pyx":139
+ * 
+ *         if self.cb_type == 1 and self.arg1 is not None:
+ *             func = self.arg1             # <<<<<<<<<<<<<<
+ *             # Cython can unset func.__qualname__/__name__, hence the checks.
+ *             if hasattr(func, '__qualname__') and func.__qualname__:
+ */
+    __pyx_t_1 = __pyx_v_self->arg1;
+    __Pyx_INCREF(__pyx_t_1);
+    __pyx_v_func = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/cbhandles.pyx":141
+ *             func = self.arg1
+ *             # Cython can unset func.__qualname__/__name__, hence the checks.
+ *             if hasattr(func, '__qualname__') and func.__qualname__:             # <<<<<<<<<<<<<<
+ *                 cb_name = func.__qualname__
+ *             elif hasattr(func, '__name__') and func.__name__:
+ */
+    __pyx_t_6 = __Pyx_HasAttr(__pyx_v_func, __pyx_n_u_qualname); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(8, 141, __pyx_L1_error)
+    __pyx_t_5 = (__pyx_t_6 != 0);
+    if (__pyx_t_5) {
+    } else {
+      __pyx_t_3 = __pyx_t_5;
+      goto __pyx_L8_bool_binop_done;
+    }
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_func, __pyx_n_s_qualname); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 141, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(8, 141, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_3 = __pyx_t_5;
+    __pyx_L8_bool_binop_done:;
+    if (__pyx_t_3) {
+
+      /* "uvloop/cbhandles.pyx":142
+ *             # Cython can unset func.__qualname__/__name__, hence the checks.
+ *             if hasattr(func, '__qualname__') and func.__qualname__:
+ *                 cb_name = func.__qualname__             # <<<<<<<<<<<<<<
+ *             elif hasattr(func, '__name__') and func.__name__:
+ *                 cb_name = func.__name__
+ */
+      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_func, __pyx_n_s_qualname); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 142, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_v_cb_name = __pyx_t_1;
+      __pyx_t_1 = 0;
+
+      /* "uvloop/cbhandles.pyx":141
+ *             func = self.arg1
+ *             # Cython can unset func.__qualname__/__name__, hence the checks.
+ *             if hasattr(func, '__qualname__') and func.__qualname__:             # <<<<<<<<<<<<<<
+ *                 cb_name = func.__qualname__
+ *             elif hasattr(func, '__name__') and func.__name__:
+ */
+      goto __pyx_L7;
+    }
+
+    /* "uvloop/cbhandles.pyx":143
+ *             if hasattr(func, '__qualname__') and func.__qualname__:
+ *                 cb_name = func.__qualname__
+ *             elif hasattr(func, '__name__') and func.__name__:             # <<<<<<<<<<<<<<
+ *                 cb_name = func.__name__
+ *             else:
+ */
+    __pyx_t_5 = __Pyx_HasAttr(__pyx_v_func, __pyx_n_u_name); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(8, 143, __pyx_L1_error)
+    __pyx_t_6 = (__pyx_t_5 != 0);
+    if (__pyx_t_6) {
+    } else {
+      __pyx_t_3 = __pyx_t_6;
+      goto __pyx_L10_bool_binop_done;
+    }
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_func, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 143, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(8, 143, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_3 = __pyx_t_6;
+    __pyx_L10_bool_binop_done:;
+    if (__pyx_t_3) {
+
+      /* "uvloop/cbhandles.pyx":144
+ *                 cb_name = func.__qualname__
+ *             elif hasattr(func, '__name__') and func.__name__:
+ *                 cb_name = func.__name__             # <<<<<<<<<<<<<<
+ *             else:
+ *                 cb_name = repr(func)
+ */
+      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_func, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 144, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_v_cb_name = __pyx_t_1;
+      __pyx_t_1 = 0;
+
+      /* "uvloop/cbhandles.pyx":143
+ *             if hasattr(func, '__qualname__') and func.__qualname__:
+ *                 cb_name = func.__qualname__
+ *             elif hasattr(func, '__name__') and func.__name__:             # <<<<<<<<<<<<<<
+ *                 cb_name = func.__name__
+ *             else:
+ */
+      goto __pyx_L7;
+    }
+
+    /* "uvloop/cbhandles.pyx":146
+ *                 cb_name = func.__name__
+ *             else:
+ *                 cb_name = repr(func)             # <<<<<<<<<<<<<<
+ * 
+ *             info.append(cb_name)
+ */
+    /*else*/ {
+      __pyx_t_1 = PyObject_Repr(__pyx_v_func); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 146, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_v_cb_name = __pyx_t_1;
+      __pyx_t_1 = 0;
+    }
+    __pyx_L7:;
+
+    /* "uvloop/cbhandles.pyx":148
+ *                 cb_name = repr(func)
+ * 
+ *             info.append(cb_name)             # <<<<<<<<<<<<<<
+ *         elif self.meth_name is not None:
+ *             info.append(self.meth_name)
+ */
+    __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_info, __pyx_v_cb_name); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(8, 148, __pyx_L1_error)
+
+    /* "uvloop/cbhandles.pyx":138
+ *             info.append('cancelled')
+ * 
+ *         if self.cb_type == 1 and self.arg1 is not None:             # <<<<<<<<<<<<<<
+ *             func = self.arg1
+ *             # Cython can unset func.__qualname__/__name__, hence the checks.
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/cbhandles.pyx":149
+ * 
+ *             info.append(cb_name)
+ *         elif self.meth_name is not None:             # <<<<<<<<<<<<<<
+ *             info.append(self.meth_name)
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->meth_name != ((PyObject*)Py_None));
+  __pyx_t_6 = (__pyx_t_3 != 0);
+  if (__pyx_t_6) {
+
+    /* "uvloop/cbhandles.pyx":150
+ *             info.append(cb_name)
+ *         elif self.meth_name is not None:
+ *             info.append(self.meth_name)             # <<<<<<<<<<<<<<
+ * 
+ *         if self._source_traceback is not None:
+ */
+    __pyx_t_1 = __pyx_v_self->meth_name;
+    __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_info, __pyx_t_1); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(8, 150, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/cbhandles.pyx":149
+ * 
+ *             info.append(cb_name)
+ *         elif self.meth_name is not None:             # <<<<<<<<<<<<<<
+ *             info.append(self.meth_name)
+ * 
+ */
+  }
+  __pyx_L4:;
+
+  /* "uvloop/cbhandles.pyx":152
+ *             info.append(self.meth_name)
+ * 
+ *         if self._source_traceback is not None:             # <<<<<<<<<<<<<<
+ *             frame = self._source_traceback[-1]
+ *             info.append('created at {}:{}'.format(frame[0], frame[1]))
+ */
+  __pyx_t_6 = (__pyx_v_self->_source_traceback != Py_None);
+  __pyx_t_3 = (__pyx_t_6 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/cbhandles.pyx":153
+ * 
+ *         if self._source_traceback is not None:
+ *             frame = self._source_traceback[-1]             # <<<<<<<<<<<<<<
+ *             info.append('created at {}:{}'.format(frame[0], frame[1]))
+ * 
+ */
+    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_self->_source_traceback, -1L, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 153, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_frame = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/cbhandles.pyx":154
+ *         if self._source_traceback is not None:
+ *             frame = self._source_traceback[-1]
+ *             info.append('created at {}:{}'.format(frame[0], frame[1]))             # <<<<<<<<<<<<<<
+ * 
+ *         return '<' + ' '.join(info) + '>'
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_created_at, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 154, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_frame, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(8, 154, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_frame, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(8, 154, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_9 = NULL;
+    __pyx_t_10 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+        __pyx_t_10 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_t_8};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 154, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_t_8};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 154, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(8, 154, __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_GIVEREF(__pyx_t_7);
+      PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_7);
+      __Pyx_GIVEREF(__pyx_t_8);
+      PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_8);
+      __pyx_t_7 = 0;
+      __pyx_t_8 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 154, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_info, __pyx_t_1); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(8, 154, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/cbhandles.pyx":152
+ *             info.append(self.meth_name)
+ * 
+ *         if self._source_traceback is not None:             # <<<<<<<<<<<<<<
+ *             frame = self._source_traceback[-1]
+ *             info.append('created at {}:{}'.format(frame[0], frame[1]))
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":156
+ *             info.append('created at {}:{}'.format(frame[0], frame[1]))
+ * 
+ *         return '<' + ' '.join(info) + '>'             # <<<<<<<<<<<<<<
+ * 
+ *     def cancel(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyUnicode_Join(__pyx_kp_u__104, __pyx_v_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u__103, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_t_2, __pyx_kp_u__105); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 156, __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;
+
+  /* "uvloop/cbhandles.pyx":132
+ *     # Public API
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         info = [self.__class__.__name__]
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("uvloop.loop.Handle.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_info);
+  __Pyx_XDECREF(__pyx_v_func);
+  __Pyx_XDECREF(__pyx_v_cb_name);
+  __Pyx_XDECREF(__pyx_v_frame);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":158
+ *         return '<' + ' '.join(info) + '>'
+ * 
+ *     def cancel(self):             # <<<<<<<<<<<<<<
+ *         self._cancel()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Handle_9cancel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Handle_8cancel[] = "Handle.cancel(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Handle_9cancel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("cancel (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Handle_8cancel(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_8cancel(struct __pyx_obj_6uvloop_4loop_Handle *__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("cancel", 0);
+
+  /* "uvloop/cbhandles.pyx":159
+ * 
+ *     def cancel(self):
+ *         self._cancel()             # <<<<<<<<<<<<<<
+ * 
+ *     def cancelled(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Handle *)__pyx_v_self->__pyx_vtab)->_cancel(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 159, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":158
+ *         return '<' + ' '.join(info) + '>'
+ * 
+ *     def cancel(self):             # <<<<<<<<<<<<<<
+ *         self._cancel()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Handle.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":161
+ *         self._cancel()
+ * 
+ *     def cancelled(self):             # <<<<<<<<<<<<<<
+ *         return self._cancelled
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Handle_11cancelled(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Handle_10cancelled[] = "Handle.cancelled(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Handle_11cancelled(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("cancelled (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Handle_10cancelled(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_10cancelled(struct __pyx_obj_6uvloop_4loop_Handle *__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("cancelled", 0);
+
+  /* "uvloop/cbhandles.pyx":162
+ * 
+ *     def cancelled(self):
+ *         return self._cancelled             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_cancelled); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 162, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/cbhandles.pyx":161
+ *         self._cancel()
+ * 
+ *     def cancelled(self):             # <<<<<<<<<<<<<<
+ *         return self._cancelled
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Handle.cancelled", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pxd":14
+ *         object __weakref__
+ * 
+ *         readonly _source_traceback             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _set_loop(self, Loop loop)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Handle_17_source_traceback_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_6Handle_17_source_traceback_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Handle_17_source_traceback___get__(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_17_source_traceback___get__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_source_traceback);
+  __pyx_r = __pyx_v_self->_source_traceback;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Handle_13__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Handle_12__reduce_cython__[] = "Handle.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Handle_13__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_6uvloop_4loop_6Handle_12__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Handle *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__106, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Handle.__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_6uvloop_4loop_6Handle_15__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Handle_14__setstate_cython__[] = "Handle.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Handle_15__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_6uvloop_4loop_6Handle_14__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Handle_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Handle *__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);
+
+  /* "(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__107, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Handle.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":168
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class TimerHandle:
+ *     def __cinit__(self, Loop loop, object callback, object args,             # <<<<<<<<<<<<<<
+ *                   uint64_t delay, object context):
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_11TimerHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_11TimerHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  PyObject *__pyx_v_callback = 0;
+  PyObject *__pyx_v_args = 0;
+  uint64_t __pyx_v_delay;
+  PyObject *__pyx_v_context = 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_loop,&__pyx_n_s_callback,&__pyx_n_s_args,&__pyx_n_s_delay,&__pyx_n_s_context,0};
+    PyObject* values[5] = {0,0,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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        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);
+        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_loop)) != 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_callback)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 5, 5, 1); __PYX_ERR(8, 168, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 5, 5, 2); __PYX_ERR(8, 168, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delay)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 5, 5, 3); __PYX_ERR(8, 168, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_context)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 5, 5, 4); __PYX_ERR(8, 168, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(8, 168, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 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);
+    }
+    __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)values[0]);
+    __pyx_v_callback = values[1];
+    __pyx_v_args = values[2];
+    __pyx_v_delay = __Pyx_PyInt_As_uint64_t(values[3]); if (unlikely((__pyx_v_delay == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(8, 169, __pyx_L3_error)
+    __pyx_v_context = values[4];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(8, 168, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6uvloop_4loop_Loop, 1, "loop", 0))) __PYX_ERR(8, 168, __pyx_L1_error)
+  __pyx_r = __pyx_pf_6uvloop_4loop_11TimerHandle___cinit__(((struct __pyx_obj_6uvloop_4loop_TimerHandle *)__pyx_v_self), __pyx_v_loop, __pyx_v_callback, __pyx_v_args, __pyx_v_delay, __pyx_v_context);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_11TimerHandle___cinit__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_callback, PyObject *__pyx_v_args, uint64_t __pyx_v_delay, PyObject *__pyx_v_context) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_INCREF(__pyx_v_context);
+
+  /* "uvloop/cbhandles.pyx":171
+ *                   uint64_t delay, object context):
+ * 
+ *         self.loop = loop             # <<<<<<<<<<<<<<
+ *         self.callback = callback
+ *         self.args = args
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GOTREF(__pyx_v_self->loop);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->loop));
+  __pyx_v_self->loop = __pyx_v_loop;
+
+  /* "uvloop/cbhandles.pyx":172
+ * 
+ *         self.loop = loop
+ *         self.callback = callback             # <<<<<<<<<<<<<<
+ *         self.args = args
+ *         self._cancelled = 0
+ */
+  __Pyx_INCREF(__pyx_v_callback);
+  __Pyx_GIVEREF(__pyx_v_callback);
+  __Pyx_GOTREF(__pyx_v_self->callback);
+  __Pyx_DECREF(__pyx_v_self->callback);
+  __pyx_v_self->callback = __pyx_v_callback;
+
+  /* "uvloop/cbhandles.pyx":173
+ *         self.loop = loop
+ *         self.callback = callback
+ *         self.args = args             # <<<<<<<<<<<<<<
+ *         self._cancelled = 0
+ * 
+ */
+  if (!(likely(PyTuple_CheckExact(__pyx_v_args))||((__pyx_v_args) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_args)->tp_name), 0))) __PYX_ERR(8, 173, __pyx_L1_error)
+  __pyx_t_1 = __pyx_v_args;
+  __Pyx_INCREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->args);
+  __Pyx_DECREF(__pyx_v_self->args);
+  __pyx_v_self->args = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":174
+ *         self.callback = callback
+ *         self.args = args
+ *         self._cancelled = 0             # <<<<<<<<<<<<<<
+ * 
+ *         if UVLOOP_DEBUG:
+ */
+  __pyx_v_self->_cancelled = 0;
+
+  /* "uvloop/cbhandles.pyx":176
+ *         self._cancelled = 0
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             self.loop._debug_cb_timer_handles_total += 1
+ *             self.loop._debug_cb_timer_handles_count += 1
+ */
+  __pyx_t_2 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/cbhandles.pyx":177
+ * 
+ *         if UVLOOP_DEBUG:
+ *             self.loop._debug_cb_timer_handles_total += 1             # <<<<<<<<<<<<<<
+ *             self.loop._debug_cb_timer_handles_count += 1
+ * 
+ */
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->loop));
+    __pyx_t_3 = __pyx_v_self->loop;
+    __pyx_t_3->_debug_cb_timer_handles_total = (__pyx_t_3->_debug_cb_timer_handles_total + 1);
+    __Pyx_DECREF(((PyObject *)__pyx_t_3)); __pyx_t_3 = 0;
+
+    /* "uvloop/cbhandles.pyx":178
+ *         if UVLOOP_DEBUG:
+ *             self.loop._debug_cb_timer_handles_total += 1
+ *             self.loop._debug_cb_timer_handles_count += 1             # <<<<<<<<<<<<<<
+ * 
+ *         if context is None:
+ */
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->loop));
+    __pyx_t_3 = __pyx_v_self->loop;
+    __pyx_t_3->_debug_cb_timer_handles_count = (__pyx_t_3->_debug_cb_timer_handles_count + 1);
+    __Pyx_DECREF(((PyObject *)__pyx_t_3)); __pyx_t_3 = 0;
+
+    /* "uvloop/cbhandles.pyx":176
+ *         self._cancelled = 0
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             self.loop._debug_cb_timer_handles_total += 1
+ *             self.loop._debug_cb_timer_handles_count += 1
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":180
+ *             self.loop._debug_cb_timer_handles_count += 1
+ * 
+ *         if context is None:             # <<<<<<<<<<<<<<
+ *             context = Context_CopyCurrent()
+ *         self.context = context
+ */
+  __pyx_t_2 = (__pyx_v_context == Py_None);
+  __pyx_t_4 = (__pyx_t_2 != 0);
+  if (__pyx_t_4) {
+
+    /* "uvloop/cbhandles.pyx":181
+ * 
+ *         if context is None:
+ *             context = Context_CopyCurrent()             # <<<<<<<<<<<<<<
+ *         self.context = context
+ * 
+ */
+    __pyx_t_1 = Context_CopyCurrent(); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF_SET(__pyx_v_context, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "uvloop/cbhandles.pyx":180
+ *             self.loop._debug_cb_timer_handles_count += 1
+ * 
+ *         if context is None:             # <<<<<<<<<<<<<<
+ *             context = Context_CopyCurrent()
+ *         self.context = context
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":182
+ *         if context is None:
+ *             context = Context_CopyCurrent()
+ *         self.context = context             # <<<<<<<<<<<<<<
+ * 
+ *         if loop._debug:
+ */
+  __Pyx_INCREF(__pyx_v_context);
+  __Pyx_GIVEREF(__pyx_v_context);
+  __Pyx_GOTREF(__pyx_v_self->context);
+  __Pyx_DECREF(__pyx_v_self->context);
+  __pyx_v_self->context = __pyx_v_context;
+
+  /* "uvloop/cbhandles.pyx":184
+ *         self.context = context
+ * 
+ *         if loop._debug:             # <<<<<<<<<<<<<<
+ *             self._debug_info = (
+ *                 format_callback_name(callback),
+ */
+  __pyx_t_4 = (__pyx_v_loop->_debug != 0);
+  if (__pyx_t_4) {
+
+    /* "uvloop/cbhandles.pyx":186
+ *         if loop._debug:
+ *             self._debug_info = (
+ *                 format_callback_name(callback),             # <<<<<<<<<<<<<<
+ *                 extract_stack()
+ *             )
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_format_callback_name(__pyx_v_callback); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 186, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+
+    /* "uvloop/cbhandles.pyx":187
+ *             self._debug_info = (
+ *                 format_callback_name(callback),
+ *                 extract_stack()             # <<<<<<<<<<<<<<
+ *             )
+ *         else:
+ */
+    __pyx_t_5 = __pyx_f_6uvloop_4loop_extract_stack(); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 187, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+
+    /* "uvloop/cbhandles.pyx":186
+ *         if loop._debug:
+ *             self._debug_info = (
+ *                 format_callback_name(callback),             # <<<<<<<<<<<<<<
+ *                 extract_stack()
+ *             )
+ */
+    __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 186, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5);
+    __pyx_t_1 = 0;
+    __pyx_t_5 = 0;
+
+    /* "uvloop/cbhandles.pyx":185
+ * 
+ *         if loop._debug:
+ *             self._debug_info = (             # <<<<<<<<<<<<<<
+ *                 format_callback_name(callback),
+ *                 extract_stack()
+ */
+    __Pyx_GIVEREF(__pyx_t_6);
+    __Pyx_GOTREF(__pyx_v_self->_debug_info);
+    __Pyx_DECREF(__pyx_v_self->_debug_info);
+    __pyx_v_self->_debug_info = ((PyObject*)__pyx_t_6);
+    __pyx_t_6 = 0;
+
+    /* "uvloop/cbhandles.pyx":184
+ *         self.context = context
+ * 
+ *         if loop._debug:             # <<<<<<<<<<<<<<
+ *             self._debug_info = (
+ *                 format_callback_name(callback),
+ */
+    goto __pyx_L5;
+  }
+
+  /* "uvloop/cbhandles.pyx":190
+ *             )
+ *         else:
+ *             self._debug_info = None             # <<<<<<<<<<<<<<
+ * 
+ *         self.timer = UVTimer.new(
+ */
+  /*else*/ {
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_debug_info);
+    __Pyx_DECREF(__pyx_v_self->_debug_info);
+    __pyx_v_self->_debug_info = ((PyObject*)Py_None);
+  }
+  __pyx_L5:;
+
+  /* "uvloop/cbhandles.pyx":192
+ *             self._debug_info = None
+ * 
+ *         self.timer = UVTimer.new(             # <<<<<<<<<<<<<<
+ *             loop, <method_t>self._run, self, delay)
+ * 
+ */
+  __pyx_t_6 = ((PyObject *)__pyx_f_6uvloop_4loop_7UVTimer_new(__pyx_v_loop, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_TimerHandle *)__pyx_v_self->__pyx_vtab)->_run), ((PyObject *)__pyx_v_self), __pyx_v_delay)); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_6);
+  __Pyx_GOTREF(__pyx_v_self->timer);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->timer));
+  __pyx_v_self->timer = ((struct __pyx_obj_6uvloop_4loop_UVTimer *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "uvloop/cbhandles.pyx":195
+ *             loop, <method_t>self._run, self, delay)
+ * 
+ *         self.timer.start()             # <<<<<<<<<<<<<<
+ * 
+ *         # Only add to loop._timers when `self.timer` is successfully created
+ */
+  __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->timer->__pyx_base.__pyx_vtab)->start(__pyx_v_self->timer); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 195, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/cbhandles.pyx":198
+ * 
+ *         # Only add to loop._timers when `self.timer` is successfully created
+ *         loop._timers.add(self)             # <<<<<<<<<<<<<<
+ * 
+ *     property _source_traceback:
+ */
+  if (unlikely(__pyx_v_loop->_timers == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "add");
+    __PYX_ERR(8, 198, __pyx_L1_error)
+  }
+  __pyx_t_7 = PySet_Add(__pyx_v_loop->_timers, ((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(8, 198, __pyx_L1_error)
+
+  /* "uvloop/cbhandles.pyx":168
+ * @cython.freelist(DEFAULT_FREELIST_SIZE)
+ * cdef class TimerHandle:
+ *     def __cinit__(self, Loop loop, object callback, object args,             # <<<<<<<<<<<<<<
+ *                   uint64_t delay, object context):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(((PyObject *)__pyx_t_3));
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_context);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":201
+ * 
+ *     property _source_traceback:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             if self._debug_info is not None:
+ *                 return self._debug_info[1]
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_17_source_traceback_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_17_source_traceback_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11TimerHandle_17_source_traceback___get__(((struct __pyx_obj_6uvloop_4loop_TimerHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_17_source_traceback___get__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("__get__", 0);
+
+  /* "uvloop/cbhandles.pyx":202
+ *     property _source_traceback:
+ *         def __get__(self):
+ *             if self._debug_info is not None:             # <<<<<<<<<<<<<<
+ *                 return self._debug_info[1]
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->_debug_info != ((PyObject*)Py_None));
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/cbhandles.pyx":203
+ *         def __get__(self):
+ *             if self._debug_info is not None:
+ *                 return self._debug_info[1]             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+    __Pyx_XDECREF(__pyx_r);
+    if (unlikely(__pyx_v_self->_debug_info == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(8, 203, __pyx_L1_error)
+    }
+    __pyx_t_3 = __Pyx_GetItemInt_Tuple(__pyx_v_self->_debug_info, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/cbhandles.pyx":202
+ *     property _source_traceback:
+ *         def __get__(self):
+ *             if self._debug_info is not None:             # <<<<<<<<<<<<<<
+ *                 return self._debug_info[1]
+ * 
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":201
+ * 
+ *     property _source_traceback:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             if self._debug_info is not None:
+ *                 return self._debug_info[1]
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle._source_traceback.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":205
+ *                 return self._debug_info[1]
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             self.loop._debug_cb_timer_handles_count -= 1
+ */
+
+/* Python wrapper */
+static void __pyx_pw_6uvloop_4loop_11TimerHandle_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_6uvloop_4loop_11TimerHandle_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_6uvloop_4loop_11TimerHandle_2__dealloc__(((struct __pyx_obj_6uvloop_4loop_TimerHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_6uvloop_4loop_11TimerHandle_2__dealloc__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "uvloop/cbhandles.pyx":206
+ * 
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             self.loop._debug_cb_timer_handles_count -= 1
+ *         if self.timer is not None:
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/cbhandles.pyx":207
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG:
+ *             self.loop._debug_cb_timer_handles_count -= 1             # <<<<<<<<<<<<<<
+ *         if self.timer is not None:
+ *             raise RuntimeError('active TimerHandle is deallacating')
+ */
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->loop));
+    __pyx_t_2 = __pyx_v_self->loop;
+    __pyx_t_2->_debug_cb_timer_handles_count = (__pyx_t_2->_debug_cb_timer_handles_count - 1);
+    __Pyx_DECREF(((PyObject *)__pyx_t_2)); __pyx_t_2 = 0;
+
+    /* "uvloop/cbhandles.pyx":206
+ * 
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             self.loop._debug_cb_timer_handles_count -= 1
+ *         if self.timer is not None:
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":208
+ *         if UVLOOP_DEBUG:
+ *             self.loop._debug_cb_timer_handles_count -= 1
+ *         if self.timer is not None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('active TimerHandle is deallacating')
+ * 
+ */
+  __pyx_t_1 = (((PyObject *)__pyx_v_self->timer) != Py_None);
+  __pyx_t_3 = (__pyx_t_1 != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/cbhandles.pyx":209
+ *             self.loop._debug_cb_timer_handles_count -= 1
+ *         if self.timer is not None:
+ *             raise RuntimeError('active TimerHandle is deallacating')             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _cancel(self):
+ */
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__108, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(8, 209, __pyx_L1_error)
+
+    /* "uvloop/cbhandles.pyx":208
+ *         if UVLOOP_DEBUG:
+ *             self.loop._debug_cb_timer_handles_count -= 1
+ *         if self.timer is not None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('active TimerHandle is deallacating')
+ * 
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":205
+ *                 return self._debug_info[1]
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             self.loop._debug_cb_timer_handles_count -= 1
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(((PyObject *)__pyx_t_2));
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_WriteUnraisable("uvloop.loop.TimerHandle.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/cbhandles.pyx":211
+ *             raise RuntimeError('active TimerHandle is deallacating')
+ * 
+ *     cdef _cancel(self):             # <<<<<<<<<<<<<<
+ *         if self._cancelled == 1:
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11TimerHandle__cancel(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self) {
+  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("_cancel", 0);
+
+  /* "uvloop/cbhandles.pyx":212
+ * 
+ *     cdef _cancel(self):
+ *         if self._cancelled == 1:             # <<<<<<<<<<<<<<
+ *             return
+ *         self._cancelled = 1
+ */
+  __pyx_t_1 = ((__pyx_v_self->_cancelled == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/cbhandles.pyx":213
+ *     cdef _cancel(self):
+ *         if self._cancelled == 1:
+ *             return             # <<<<<<<<<<<<<<
+ *         self._cancelled = 1
+ *         self._clear()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/cbhandles.pyx":212
+ * 
+ *     cdef _cancel(self):
+ *         if self._cancelled == 1:             # <<<<<<<<<<<<<<
+ *             return
+ *         self._cancelled = 1
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":214
+ *         if self._cancelled == 1:
+ *             return
+ *         self._cancelled = 1             # <<<<<<<<<<<<<<
+ *         self._clear()
+ * 
+ */
+  __pyx_v_self->_cancelled = 1;
+
+  /* "uvloop/cbhandles.pyx":215
+ *             return
+ *         self._cancelled = 1
+ *         self._clear()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _clear(self):
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop_11TimerHandle__clear(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 215, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/cbhandles.pyx":211
+ *             raise RuntimeError('active TimerHandle is deallacating')
+ * 
+ *     cdef _cancel(self):             # <<<<<<<<<<<<<<
+ *         if self._cancelled == 1:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle._cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":217
+ *         self._clear()
+ * 
+ *     cdef inline _clear(self):             # <<<<<<<<<<<<<<
+ *         if self.timer is None:
+ *             return
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_11TimerHandle__clear(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  char const *__pyx_t_7;
+  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;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_clear", 0);
+
+  /* "uvloop/cbhandles.pyx":218
+ * 
+ *     cdef inline _clear(self):
+ *         if self.timer is None:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = (((PyObject *)__pyx_v_self->timer) == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/cbhandles.pyx":219
+ *     cdef inline _clear(self):
+ *         if self.timer is None:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self.callback = None
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/cbhandles.pyx":218
+ * 
+ *     cdef inline _clear(self):
+ *         if self.timer is None:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":221
+ *             return
+ * 
+ *         self.callback = None             # <<<<<<<<<<<<<<
+ *         self.args = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->callback);
+  __Pyx_DECREF(__pyx_v_self->callback);
+  __pyx_v_self->callback = Py_None;
+
+  /* "uvloop/cbhandles.pyx":222
+ * 
+ *         self.callback = None
+ *         self.args = None             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->args);
+  __Pyx_DECREF(__pyx_v_self->args);
+  __pyx_v_self->args = ((PyObject*)Py_None);
+
+  /* "uvloop/cbhandles.pyx":224
+ *         self.args = None
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             self.loop._timers.remove(self)
+ *         finally:
+ */
+  /*try:*/ {
+
+    /* "uvloop/cbhandles.pyx":225
+ * 
+ *         try:
+ *             self.loop._timers.remove(self)             # <<<<<<<<<<<<<<
+ *         finally:
+ *             self.timer._close()
+ */
+    if (unlikely(__pyx_v_self->loop->_timers == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "remove");
+      __PYX_ERR(8, 225, __pyx_L5_error)
+    }
+    __pyx_t_3 = __Pyx_PySet_Remove(__pyx_v_self->loop->_timers, ((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(8, 225, __pyx_L5_error)
+  }
+
+  /* "uvloop/cbhandles.pyx":227
+ *             self.loop._timers.remove(self)
+ *         finally:
+ *             self.timer._close()             # <<<<<<<<<<<<<<
+ *             self.timer = None  # let the UVTimer handle GC
+ * 
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->timer->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self->timer)); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 227, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/cbhandles.pyx":228
+ *         finally:
+ *             self.timer._close()
+ *             self.timer = None  # let the UVTimer handle GC             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _run(self):
+ */
+      __Pyx_INCREF(Py_None);
+      __Pyx_GIVEREF(Py_None);
+      __Pyx_GOTREF(__pyx_v_self->timer);
+      __Pyx_DECREF(((PyObject *)__pyx_v_self->timer));
+      __pyx_v_self->timer = ((struct __pyx_obj_6uvloop_4loop_UVTimer *)Py_None);
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __pyx_t_5 = __pyx_lineno; __pyx_t_6 = __pyx_clineno; __pyx_t_7 = __pyx_filename;
+      {
+
+        /* "uvloop/cbhandles.pyx":227
+ *             self.loop._timers.remove(self)
+ *         finally:
+ *             self.timer._close()             # <<<<<<<<<<<<<<
+ *             self.timer = None  # let the UVTimer handle GC
+ * 
+ */
+        __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->timer->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self->timer)); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 227, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/cbhandles.pyx":228
+ *         finally:
+ *             self.timer._close()
+ *             self.timer = None  # let the UVTimer handle GC             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _run(self):
+ */
+        __Pyx_INCREF(Py_None);
+        __Pyx_GIVEREF(Py_None);
+        __Pyx_GOTREF(__pyx_v_self->timer);
+        __Pyx_DECREF(((PyObject *)__pyx_v_self->timer));
+        __pyx_v_self->timer = ((struct __pyx_obj_6uvloop_4loop_UVTimer *)Py_None);
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+      }
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_ErrRestore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      __pyx_lineno = __pyx_t_5; __pyx_clineno = __pyx_t_6; __pyx_filename = __pyx_t_7;
+      goto __pyx_L1_error;
+      __pyx_L8_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+      }
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/cbhandles.pyx":217
+ *         self._clear()
+ * 
+ *     cdef inline _clear(self):             # <<<<<<<<<<<<<<
+ *         if self.timer is None:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle._clear", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":230
+ *             self.timer = None  # let the UVTimer handle GC
+ * 
+ *     cdef _run(self):             # <<<<<<<<<<<<<<
+ *         if self._cancelled == 1:
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11TimerHandle__run(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self) {
+  PyObject *__pyx_v_callback = NULL;
+  PyObject *__pyx_v_args = NULL;
+  PyObject *__pyx_v_started = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_v_context = NULL;
+  PyObject *__pyx_v_delta = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_t_14;
+  char const *__pyx_t_15;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  char const *__pyx_t_22;
+  int __pyx_t_23;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_run", 0);
+
+  /* "uvloop/cbhandles.pyx":231
+ * 
+ *     cdef _run(self):
+ *         if self._cancelled == 1:             # <<<<<<<<<<<<<<
+ *             return
+ *         if self.callback is None:
+ */
+  __pyx_t_1 = ((__pyx_v_self->_cancelled == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/cbhandles.pyx":232
+ *     cdef _run(self):
+ *         if self._cancelled == 1:
+ *             return             # <<<<<<<<<<<<<<
+ *         if self.callback is None:
+ *             raise RuntimeError('cannot run TimerHandle; callback is not set')
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/cbhandles.pyx":231
+ * 
+ *     cdef _run(self):
+ *         if self._cancelled == 1:             # <<<<<<<<<<<<<<
+ *             return
+ *         if self.callback is None:
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":233
+ *         if self._cancelled == 1:
+ *             return
+ *         if self.callback is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('cannot run TimerHandle; callback is not set')
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->callback == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/cbhandles.pyx":234
+ *             return
+ *         if self.callback is None:
+ *             raise RuntimeError('cannot run TimerHandle; callback is not set')             # <<<<<<<<<<<<<<
+ * 
+ *         callback = self.callback
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__109, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 234, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(8, 234, __pyx_L1_error)
+
+    /* "uvloop/cbhandles.pyx":233
+ *         if self._cancelled == 1:
+ *             return
+ *         if self.callback is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('cannot run TimerHandle; callback is not set')
+ * 
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":236
+ *             raise RuntimeError('cannot run TimerHandle; callback is not set')
+ * 
+ *         callback = self.callback             # <<<<<<<<<<<<<<
+ *         args = self.args
+ * 
+ */
+  __pyx_t_3 = __pyx_v_self->callback;
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_v_callback = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/cbhandles.pyx":237
+ * 
+ *         callback = self.callback
+ *         args = self.args             # <<<<<<<<<<<<<<
+ * 
+ *         # Since _run is a cdef and there's no BoundMethod,
+ */
+  __pyx_t_3 = __pyx_v_self->args;
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_v_args = ((PyObject*)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/cbhandles.pyx":241
+ *         # Since _run is a cdef and there's no BoundMethod,
+ *         # we guard 'self' manually.
+ *         Py_INCREF(self)             # <<<<<<<<<<<<<<
+ * 
+ *         if self.loop._debug:
+ */
+  Py_INCREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/cbhandles.pyx":243
+ *         Py_INCREF(self)
+ * 
+ *         if self.loop._debug:             # <<<<<<<<<<<<<<
+ *             started = time_monotonic()
+ *         try:
+ */
+  __pyx_t_2 = (__pyx_v_self->loop->_debug != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/cbhandles.pyx":244
+ * 
+ *         if self.loop._debug:
+ *             started = time_monotonic()             # <<<<<<<<<<<<<<
+ *         try:
+ *             assert self.context is not None
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_time_monotonic);
+    __pyx_t_4 = __pyx_v_6uvloop_4loop_time_monotonic; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 244, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_v_started = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/cbhandles.pyx":243
+ *         Py_INCREF(self)
+ * 
+ *         if self.loop._debug:             # <<<<<<<<<<<<<<
+ *             started = time_monotonic()
+ *         try:
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":245
+ *         if self.loop._debug:
+ *             started = time_monotonic()
+ *         try:             # <<<<<<<<<<<<<<
+ *             assert self.context is not None
+ *             Context_Enter(self.context)
+ */
+  /*try:*/ {
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
+      /*try:*/ {
+
+        /* "uvloop/cbhandles.pyx":246
+ *             started = time_monotonic()
+ *         try:
+ *             assert self.context is not None             # <<<<<<<<<<<<<<
+ *             Context_Enter(self.context)
+ * 
+ */
+        #ifndef CYTHON_WITHOUT_ASSERTIONS
+        if (unlikely(!Py_OptimizeFlag)) {
+          __pyx_t_2 = (__pyx_v_self->context != Py_None);
+          if (unlikely(!(__pyx_t_2 != 0))) {
+            PyErr_SetNone(PyExc_AssertionError);
+            __PYX_ERR(8, 246, __pyx_L9_error)
+          }
+        }
+        #endif
+
+        /* "uvloop/cbhandles.pyx":247
+ *         try:
+ *             assert self.context is not None
+ *             Context_Enter(self.context)             # <<<<<<<<<<<<<<
+ * 
+ *             if args is not None:
+ */
+        __pyx_t_3 = __pyx_v_self->context;
+        __Pyx_INCREF(__pyx_t_3);
+        __pyx_t_9 = Context_Enter(__pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(8, 247, __pyx_L9_error)
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/cbhandles.pyx":249
+ *             Context_Enter(self.context)
+ * 
+ *             if args is not None:             # <<<<<<<<<<<<<<
+ *                 callback(*args)
+ *             else:
+ */
+        __pyx_t_2 = (__pyx_v_args != ((PyObject*)Py_None));
+        __pyx_t_1 = (__pyx_t_2 != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/cbhandles.pyx":250
+ * 
+ *             if args is not None:
+ *                 callback(*args)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 callback()
+ */
+          if (unlikely(__pyx_v_args == Py_None)) {
+            PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+            __PYX_ERR(8, 250, __pyx_L9_error)
+          }
+          __pyx_t_3 = __Pyx_PyObject_Call(__pyx_v_callback, __pyx_v_args, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 250, __pyx_L9_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+          /* "uvloop/cbhandles.pyx":249
+ *             Context_Enter(self.context)
+ * 
+ *             if args is not None:             # <<<<<<<<<<<<<<
+ *                 callback(*args)
+ *             else:
+ */
+          goto __pyx_L15;
+        }
+
+        /* "uvloop/cbhandles.pyx":252
+ *                 callback(*args)
+ *             else:
+ *                 callback()             # <<<<<<<<<<<<<<
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ */
+        /*else*/ {
+          __Pyx_INCREF(__pyx_v_callback);
+          __pyx_t_4 = __pyx_v_callback; __pyx_t_5 = NULL;
+          if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 252, __pyx_L9_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        }
+        __pyx_L15:;
+
+        /* "uvloop/cbhandles.pyx":245
+ *         if self.loop._debug:
+ *             started = time_monotonic()
+ *         try:             # <<<<<<<<<<<<<<
+ *             assert self.context is not None
+ *             Context_Enter(self.context)
+ */
+      }
+
+      /* "uvloop/cbhandles.pyx":267
+ *             self.loop.call_exception_handler(context)
+ *         else:
+ *             if self.loop._debug:             # <<<<<<<<<<<<<<
+ *                 delta = time_monotonic() - started
+ *                 if delta > self.loop.slow_callback_duration:
+ */
+      /*else:*/ {
+        __pyx_t_1 = (__pyx_v_self->loop->_debug != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/cbhandles.pyx":268
+ *         else:
+ *             if self.loop._debug:
+ *                 delta = time_monotonic() - started             # <<<<<<<<<<<<<<
+ *                 if delta > self.loop.slow_callback_duration:
+ *                     aio_logger.warning(
+ */
+          __Pyx_INCREF(__pyx_v_6uvloop_4loop_time_monotonic);
+          __pyx_t_4 = __pyx_v_6uvloop_4loop_time_monotonic; __pyx_t_5 = NULL;
+          if (CYTHON_UNPACK_METHODS && 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);
+              __Pyx_INCREF(__pyx_t_5);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_4, function);
+            }
+          }
+          __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 268, __pyx_L11_except_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          if (unlikely(!__pyx_v_started)) { __Pyx_RaiseUnboundLocalError("started"); __PYX_ERR(8, 268, __pyx_L11_except_error) }
+          __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __pyx_v_started); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 268, __pyx_L11_except_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __pyx_v_delta = __pyx_t_4;
+          __pyx_t_4 = 0;
+
+          /* "uvloop/cbhandles.pyx":269
+ *             if self.loop._debug:
+ *                 delta = time_monotonic() - started
+ *                 if delta > self.loop.slow_callback_duration:             # <<<<<<<<<<<<<<
+ *                     aio_logger.warning(
+ *                         'Executing %r took %.3f seconds',
+ */
+          __pyx_t_4 = PyObject_RichCompare(__pyx_v_delta, __pyx_v_self->loop->slow_callback_duration, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 269, __pyx_L11_except_error)
+          __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(8, 269, __pyx_L11_except_error)
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          if (__pyx_t_1) {
+
+            /* "uvloop/cbhandles.pyx":270
+ *                 delta = time_monotonic() - started
+ *                 if delta > self.loop.slow_callback_duration:
+ *                     aio_logger.warning(             # <<<<<<<<<<<<<<
+ *                         'Executing %r took %.3f seconds',
+ *                         self, delta)
+ */
+            __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_warning); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 270, __pyx_L11_except_error)
+            __Pyx_GOTREF(__pyx_t_3);
+
+            /* "uvloop/cbhandles.pyx":272
+ *                     aio_logger.warning(
+ *                         'Executing %r took %.3f seconds',
+ *                         self, delta)             # <<<<<<<<<<<<<<
+ *         finally:
+ *             context = self.context
+ */
+            __pyx_t_5 = NULL;
+            __pyx_t_9 = 0;
+            if (CYTHON_UNPACK_METHODS && 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_3, function);
+                __pyx_t_9 = 1;
+              }
+            }
+            #if CYTHON_FAST_PYCALL
+            if (PyFunction_Check(__pyx_t_3)) {
+              PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_kp_u_Executing_r_took_3f_seconds, ((PyObject *)__pyx_v_self), __pyx_v_delta};
+              __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 270, __pyx_L11_except_error)
+              __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+              __Pyx_GOTREF(__pyx_t_4);
+            } else
+            #endif
+            #if CYTHON_FAST_PYCCALL
+            if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+              PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_kp_u_Executing_r_took_3f_seconds, ((PyObject *)__pyx_v_self), __pyx_v_delta};
+              __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 270, __pyx_L11_except_error)
+              __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+              __Pyx_GOTREF(__pyx_t_4);
+            } else
+            #endif
+            {
+              __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(8, 270, __pyx_L11_except_error)
+              __Pyx_GOTREF(__pyx_t_10);
+              if (__pyx_t_5) {
+                __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); __pyx_t_5 = NULL;
+              }
+              __Pyx_INCREF(__pyx_kp_u_Executing_r_took_3f_seconds);
+              __Pyx_GIVEREF(__pyx_kp_u_Executing_r_took_3f_seconds);
+              PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_kp_u_Executing_r_took_3f_seconds);
+              __Pyx_INCREF(((PyObject *)__pyx_v_self));
+              __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+              PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, ((PyObject *)__pyx_v_self));
+              __Pyx_INCREF(__pyx_v_delta);
+              __Pyx_GIVEREF(__pyx_v_delta);
+              PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_v_delta);
+              __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 270, __pyx_L11_except_error)
+              __Pyx_GOTREF(__pyx_t_4);
+              __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+            }
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+            /* "uvloop/cbhandles.pyx":269
+ *             if self.loop._debug:
+ *                 delta = time_monotonic() - started
+ *                 if delta > self.loop.slow_callback_duration:             # <<<<<<<<<<<<<<
+ *                     aio_logger.warning(
+ *                         'Executing %r took %.3f seconds',
+ */
+          }
+
+          /* "uvloop/cbhandles.pyx":267
+ *             self.loop.call_exception_handler(context)
+ *         else:
+ *             if self.loop._debug:             # <<<<<<<<<<<<<<
+ *                 delta = time_monotonic() - started
+ *                 if delta > self.loop.slow_callback_duration:
+ */
+        }
+      }
+      __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;
+      goto __pyx_L14_try_end;
+      __pyx_L9_error:;
+      __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;
+
+      /* "uvloop/cbhandles.pyx":253
+ *             else:
+ *                 callback()
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException as ex:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.TimerHandle._run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_10) < 0) __PYX_ERR(8, 253, __pyx_L11_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_10);
+
+        /* "uvloop/cbhandles.pyx":254
+ *                 callback()
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException as ex:
+ *             context = {
+ */
+        __Pyx_GIVEREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_3);
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_3, __pyx_t_10);
+        __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_10 = 0; 
+        __PYX_ERR(8, 254, __pyx_L11_except_error)
+      }
+
+      /* "uvloop/cbhandles.pyx":255
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             context = {
+ *                 'message': 'Exception in callback {}'.format(callback),
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.TimerHandle._run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_3, &__pyx_t_4) < 0) __PYX_ERR(8, 255, __pyx_L11_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
+        __pyx_v_ex = __pyx_t_3;
+        /*try:*/ {
+
+          /* "uvloop/cbhandles.pyx":257
+ *         except BaseException as ex:
+ *             context = {
+ *                 'message': 'Exception in callback {}'.format(callback),             # <<<<<<<<<<<<<<
+ *                 'exception': ex,
+ *                 'handle': self,
+ */
+          __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 257, __pyx_L25_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Exception_in_callback, __pyx_n_s_format); if (unlikely(!__pyx_t_12)) __PYX_ERR(8, 257, __pyx_L25_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          __pyx_t_13 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) {
+            __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_12);
+            if (likely(__pyx_t_13)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
+              __Pyx_INCREF(__pyx_t_13);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_12, function);
+            }
+          }
+          __pyx_t_11 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_12, __pyx_t_13, __pyx_v_callback) : __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_v_callback);
+          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+          if (unlikely(!__pyx_t_11)) __PYX_ERR(8, 257, __pyx_L25_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (PyDict_SetItem(__pyx_t_5, __pyx_n_u_message, __pyx_t_11) < 0) __PYX_ERR(8, 257, __pyx_L25_error)
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+
+          /* "uvloop/cbhandles.pyx":258
+ *             context = {
+ *                 'message': 'Exception in callback {}'.format(callback),
+ *                 'exception': ex,             # <<<<<<<<<<<<<<
+ *                 'handle': self,
+ *             }
+ */
+          if (PyDict_SetItem(__pyx_t_5, __pyx_n_u_exception, __pyx_v_ex) < 0) __PYX_ERR(8, 257, __pyx_L25_error)
+
+          /* "uvloop/cbhandles.pyx":259
+ *                 'message': 'Exception in callback {}'.format(callback),
+ *                 'exception': ex,
+ *                 'handle': self,             # <<<<<<<<<<<<<<
+ *             }
+ * 
+ */
+          if (PyDict_SetItem(__pyx_t_5, __pyx_n_u_handle, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(8, 257, __pyx_L25_error)
+          __pyx_v_context = __pyx_t_5;
+          __pyx_t_5 = 0;
+
+          /* "uvloop/cbhandles.pyx":262
+ *             }
+ * 
+ *             if self._debug_info is not None:             # <<<<<<<<<<<<<<
+ *                 context['source_traceback'] = self._debug_info[1]
+ * 
+ */
+          __pyx_t_1 = (__pyx_v_self->_debug_info != ((PyObject*)Py_None));
+          __pyx_t_2 = (__pyx_t_1 != 0);
+          if (__pyx_t_2) {
+
+            /* "uvloop/cbhandles.pyx":263
+ * 
+ *             if self._debug_info is not None:
+ *                 context['source_traceback'] = self._debug_info[1]             # <<<<<<<<<<<<<<
+ * 
+ *             self.loop.call_exception_handler(context)
+ */
+            if (unlikely(__pyx_v_self->_debug_info == Py_None)) {
+              PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+              __PYX_ERR(8, 263, __pyx_L25_error)
+            }
+            __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v_self->_debug_info, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 263, __pyx_L25_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            if (unlikely(PyObject_SetItem(__pyx_v_context, __pyx_n_u_source_traceback, __pyx_t_5) < 0)) __PYX_ERR(8, 263, __pyx_L25_error)
+            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+            /* "uvloop/cbhandles.pyx":262
+ *             }
+ * 
+ *             if self._debug_info is not None:             # <<<<<<<<<<<<<<
+ *                 context['source_traceback'] = self._debug_info[1]
+ * 
+ */
+          }
+
+          /* "uvloop/cbhandles.pyx":265
+ *                 context['source_traceback'] = self._debug_info[1]
+ * 
+ *             self.loop.call_exception_handler(context)             # <<<<<<<<<<<<<<
+ *         else:
+ *             if self.loop._debug:
+ */
+          __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_11)) __PYX_ERR(8, 265, __pyx_L25_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __pyx_t_12 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+            __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
+            if (likely(__pyx_t_12)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+              __Pyx_INCREF(__pyx_t_12);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_11, function);
+            }
+          }
+          __pyx_t_5 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_12, __pyx_v_context) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_context);
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 265, __pyx_L25_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        }
+
+        /* "uvloop/cbhandles.pyx":255
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             context = {
+ *                 'message': 'Exception in callback {}'.format(callback),
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L26;
+          }
+          __pyx_L25_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __Pyx_XGOTREF(__pyx_t_21);
+            __pyx_t_9 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_XGIVEREF(__pyx_t_21);
+              __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
+            }
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+            __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
+            __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
+            goto __pyx_L11_except_error;
+          }
+          __pyx_L26:;
+        }
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        goto __pyx_L10_exception_handled;
+      }
+      goto __pyx_L11_except_error;
+      __pyx_L11_except_error:;
+
+      /* "uvloop/cbhandles.pyx":245
+ *         if self.loop._debug:
+ *             started = time_monotonic()
+ *         try:             # <<<<<<<<<<<<<<
+ *             assert self.context is not None
+ *             Context_Enter(self.context)
+ */
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      goto __pyx_L7_error;
+      __pyx_L10_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      __pyx_L14_try_end:;
+    }
+  }
+
+  /* "uvloop/cbhandles.pyx":274
+ *                         self, delta)
+ *         finally:
+ *             context = self.context             # <<<<<<<<<<<<<<
+ *             Py_DECREF(self)
+ *             Context_Exit(context)
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_4 = __pyx_v_self->context;
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_XDECREF_SET(__pyx_v_context, __pyx_t_4);
+      __pyx_t_4 = 0;
+
+      /* "uvloop/cbhandles.pyx":275
+ *         finally:
+ *             context = self.context
+ *             Py_DECREF(self)             # <<<<<<<<<<<<<<
+ *             Context_Exit(context)
+ *             self._clear()
+ */
+      Py_DECREF(((PyObject *)__pyx_v_self));
+
+      /* "uvloop/cbhandles.pyx":276
+ *             context = self.context
+ *             Py_DECREF(self)
+ *             Context_Exit(context)             # <<<<<<<<<<<<<<
+ *             self._clear()
+ * 
+ */
+      __pyx_t_14 = Context_Exit(__pyx_v_context); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(8, 276, __pyx_L1_error)
+
+      /* "uvloop/cbhandles.pyx":277
+ *             Py_DECREF(self)
+ *             Context_Exit(context)
+ *             self._clear()             # <<<<<<<<<<<<<<
+ * 
+ *     # Public API
+ */
+      __pyx_t_4 = __pyx_f_6uvloop_4loop_11TimerHandle__clear(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 277, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L8;
+    }
+    __pyx_L7_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_20, &__pyx_t_19);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0)) __Pyx_ErrFetch(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_21);
+      __Pyx_XGOTREF(__pyx_t_20);
+      __Pyx_XGOTREF(__pyx_t_19);
+      __pyx_t_14 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_22 = __pyx_filename;
+      {
+
+        /* "uvloop/cbhandles.pyx":274
+ *                         self, delta)
+ *         finally:
+ *             context = self.context             # <<<<<<<<<<<<<<
+ *             Py_DECREF(self)
+ *             Context_Exit(context)
+ */
+        __pyx_t_4 = __pyx_v_self->context;
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_XDECREF_SET(__pyx_v_context, __pyx_t_4);
+        __pyx_t_4 = 0;
+
+        /* "uvloop/cbhandles.pyx":275
+ *         finally:
+ *             context = self.context
+ *             Py_DECREF(self)             # <<<<<<<<<<<<<<
+ *             Context_Exit(context)
+ *             self._clear()
+ */
+        Py_DECREF(((PyObject *)__pyx_v_self));
+
+        /* "uvloop/cbhandles.pyx":276
+ *             context = self.context
+ *             Py_DECREF(self)
+ *             Context_Exit(context)             # <<<<<<<<<<<<<<
+ *             self._clear()
+ * 
+ */
+        __pyx_t_23 = Context_Exit(__pyx_v_context); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(8, 276, __pyx_L33_error)
+
+        /* "uvloop/cbhandles.pyx":277
+ *             Py_DECREF(self)
+ *             Context_Exit(context)
+ *             self._clear()             # <<<<<<<<<<<<<<
+ * 
+ *     # Public API
+ */
+        __pyx_t_4 = __pyx_f_6uvloop_4loop_11TimerHandle__clear(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 277, __pyx_L33_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_21);
+        __Pyx_XGIVEREF(__pyx_t_20);
+        __Pyx_XGIVEREF(__pyx_t_19);
+        __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_20, __pyx_t_19);
+      }
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ErrRestore(__pyx_t_8, __pyx_t_7, __pyx_t_6);
+      __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0;
+      __pyx_lineno = __pyx_t_14; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_22;
+      goto __pyx_L1_error;
+      __pyx_L33_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_21);
+        __Pyx_XGIVEREF(__pyx_t_20);
+        __Pyx_XGIVEREF(__pyx_t_19);
+        __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_20, __pyx_t_19);
+      }
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L8:;
+  }
+
+  /* "uvloop/cbhandles.pyx":230
+ *             self.timer = None  # let the UVTimer handle GC
+ * 
+ *     cdef _run(self):             # <<<<<<<<<<<<<<
+ *         if self._cancelled == 1:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle._run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_callback);
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_started);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XDECREF(__pyx_v_context);
+  __Pyx_XDECREF(__pyx_v_delta);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":281
+ *     # Public API
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         info = [self.__class__.__name__]
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_5__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_5__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11TimerHandle_4__repr__(((struct __pyx_obj_6uvloop_4loop_TimerHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_4__repr__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self) {
+  PyObject *__pyx_v_info = NULL;
+  PyObject *__pyx_v_callback_name = NULL;
+  PyObject *__pyx_v_source_traceback = NULL;
+  PyObject *__pyx_v_frame = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "uvloop/cbhandles.pyx":282
+ * 
+ *     def __repr__(self):
+ *         info = [self.__class__.__name__]             # <<<<<<<<<<<<<<
+ * 
+ *         if self._cancelled:
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 282, __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(8, 282, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 282, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_v_info = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":284
+ *         info = [self.__class__.__name__]
+ * 
+ *         if self._cancelled:             # <<<<<<<<<<<<<<
+ *             info.append('cancelled')
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->_cancelled != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/cbhandles.pyx":285
+ * 
+ *         if self._cancelled:
+ *             info.append('cancelled')             # <<<<<<<<<<<<<<
+ * 
+ *         if self._debug_info is not None:
+ */
+    __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_info, __pyx_n_u_cancelled); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(8, 285, __pyx_L1_error)
+
+    /* "uvloop/cbhandles.pyx":284
+ *         info = [self.__class__.__name__]
+ * 
+ *         if self._cancelled:             # <<<<<<<<<<<<<<
+ *             info.append('cancelled')
+ * 
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":287
+ *             info.append('cancelled')
+ * 
+ *         if self._debug_info is not None:             # <<<<<<<<<<<<<<
+ *             callback_name = self._debug_info[0]
+ *             source_traceback = self._debug_info[1]
+ */
+  __pyx_t_3 = (__pyx_v_self->_debug_info != ((PyObject*)Py_None));
+  __pyx_t_5 = (__pyx_t_3 != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/cbhandles.pyx":288
+ * 
+ *         if self._debug_info is not None:
+ *             callback_name = self._debug_info[0]             # <<<<<<<<<<<<<<
+ *             source_traceback = self._debug_info[1]
+ *         else:
+ */
+    if (unlikely(__pyx_v_self->_debug_info == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(8, 288, __pyx_L1_error)
+    }
+    __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_self->_debug_info, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 288, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_callback_name = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/cbhandles.pyx":289
+ *         if self._debug_info is not None:
+ *             callback_name = self._debug_info[0]
+ *             source_traceback = self._debug_info[1]             # <<<<<<<<<<<<<<
+ *         else:
+ *             callback_name = None
+ */
+    if (unlikely(__pyx_v_self->_debug_info == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(8, 289, __pyx_L1_error)
+    }
+    __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_self->_debug_info, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 289, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_source_traceback = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/cbhandles.pyx":287
+ *             info.append('cancelled')
+ * 
+ *         if self._debug_info is not None:             # <<<<<<<<<<<<<<
+ *             callback_name = self._debug_info[0]
+ *             source_traceback = self._debug_info[1]
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/cbhandles.pyx":291
+ *             source_traceback = self._debug_info[1]
+ *         else:
+ *             callback_name = None             # <<<<<<<<<<<<<<
+ *             source_traceback = None
+ * 
+ */
+  /*else*/ {
+    __Pyx_INCREF(Py_None);
+    __pyx_v_callback_name = Py_None;
+
+    /* "uvloop/cbhandles.pyx":292
+ *         else:
+ *             callback_name = None
+ *             source_traceback = None             # <<<<<<<<<<<<<<
+ * 
+ *         if callback_name is not None:
+ */
+    __Pyx_INCREF(Py_None);
+    __pyx_v_source_traceback = Py_None;
+  }
+  __pyx_L4:;
+
+  /* "uvloop/cbhandles.pyx":294
+ *             source_traceback = None
+ * 
+ *         if callback_name is not None:             # <<<<<<<<<<<<<<
+ *             info.append(callback_name)
+ *         elif self.callback is not None:
+ */
+  __pyx_t_5 = (__pyx_v_callback_name != Py_None);
+  __pyx_t_3 = (__pyx_t_5 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/cbhandles.pyx":295
+ * 
+ *         if callback_name is not None:
+ *             info.append(callback_name)             # <<<<<<<<<<<<<<
+ *         elif self.callback is not None:
+ *             info.append(format_callback_name(self.callback))
+ */
+    __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_info, __pyx_v_callback_name); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(8, 295, __pyx_L1_error)
+
+    /* "uvloop/cbhandles.pyx":294
+ *             source_traceback = None
+ * 
+ *         if callback_name is not None:             # <<<<<<<<<<<<<<
+ *             info.append(callback_name)
+ *         elif self.callback is not None:
+ */
+    goto __pyx_L5;
+  }
+
+  /* "uvloop/cbhandles.pyx":296
+ *         if callback_name is not None:
+ *             info.append(callback_name)
+ *         elif self.callback is not None:             # <<<<<<<<<<<<<<
+ *             info.append(format_callback_name(self.callback))
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->callback != Py_None);
+  __pyx_t_5 = (__pyx_t_3 != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/cbhandles.pyx":297
+ *             info.append(callback_name)
+ *         elif self.callback is not None:
+ *             info.append(format_callback_name(self.callback))             # <<<<<<<<<<<<<<
+ * 
+ *         if source_traceback is not None:
+ */
+    __pyx_t_1 = __pyx_v_self->callback;
+    __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_format_callback_name(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 297, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_info, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(8, 297, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/cbhandles.pyx":296
+ *         if callback_name is not None:
+ *             info.append(callback_name)
+ *         elif self.callback is not None:             # <<<<<<<<<<<<<<
+ *             info.append(format_callback_name(self.callback))
+ * 
+ */
+  }
+  __pyx_L5:;
+
+  /* "uvloop/cbhandles.pyx":299
+ *             info.append(format_callback_name(self.callback))
+ * 
+ *         if source_traceback is not None:             # <<<<<<<<<<<<<<
+ *             frame = source_traceback[-1]
+ *             info.append('created at {}:{}'.format(frame[0], frame[1]))
+ */
+  __pyx_t_5 = (__pyx_v_source_traceback != Py_None);
+  __pyx_t_3 = (__pyx_t_5 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/cbhandles.pyx":300
+ * 
+ *         if source_traceback is not None:
+ *             frame = source_traceback[-1]             # <<<<<<<<<<<<<<
+ *             info.append('created at {}:{}'.format(frame[0], frame[1]))
+ * 
+ */
+    __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_source_traceback, -1L, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 300, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_frame = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/cbhandles.pyx":301
+ *         if source_traceback is not None:
+ *             frame = source_traceback[-1]
+ *             info.append('created at {}:{}'.format(frame[0], frame[1]))             # <<<<<<<<<<<<<<
+ * 
+ *         return '<' + ' '.join(info) + '>'
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_created_at, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 301, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_frame, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 301, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_frame, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(8, 301, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_8 = NULL;
+    __pyx_t_9 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+        __pyx_t_9 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 301, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 301, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __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(8, 301, __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_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_7);
+      PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
+      __pyx_t_6 = 0;
+      __pyx_t_7 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 301, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_info, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(8, 301, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/cbhandles.pyx":299
+ *             info.append(format_callback_name(self.callback))
+ * 
+ *         if source_traceback is not None:             # <<<<<<<<<<<<<<
+ *             frame = source_traceback[-1]
+ *             info.append('created at {}:{}'.format(frame[0], frame[1]))
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":303
+ *             info.append('created at {}:{}'.format(frame[0], frame[1]))
+ * 
+ *         return '<' + ' '.join(info) + '>'             # <<<<<<<<<<<<<<
+ * 
+ *     def cancelled(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyUnicode_Join(__pyx_kp_u__104, __pyx_v_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 303, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_kp_u__103, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 303, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_t_1, __pyx_kp_u__105); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 303, __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;
+
+  /* "uvloop/cbhandles.pyx":281
+ *     # Public API
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         info = [self.__class__.__name__]
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_info);
+  __Pyx_XDECREF(__pyx_v_callback_name);
+  __Pyx_XDECREF(__pyx_v_source_traceback);
+  __Pyx_XDECREF(__pyx_v_frame);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":305
+ *         return '<' + ' '.join(info) + '>'
+ * 
+ *     def cancelled(self):             # <<<<<<<<<<<<<<
+ *         return self._cancelled
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_7cancelled(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11TimerHandle_6cancelled[] = "TimerHandle.cancelled(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_7cancelled(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("cancelled (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11TimerHandle_6cancelled(((struct __pyx_obj_6uvloop_4loop_TimerHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_6cancelled(struct __pyx_obj_6uvloop_4loop_TimerHandle *__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("cancelled", 0);
+
+  /* "uvloop/cbhandles.pyx":306
+ * 
+ *     def cancelled(self):
+ *         return self._cancelled             # <<<<<<<<<<<<<<
+ * 
+ *     def cancel(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_cancelled); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 306, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/cbhandles.pyx":305
+ *         return '<' + ' '.join(info) + '>'
+ * 
+ *     def cancelled(self):             # <<<<<<<<<<<<<<
+ *         return self._cancelled
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle.cancelled", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":308
+ *         return self._cancelled
+ * 
+ *     def cancel(self):             # <<<<<<<<<<<<<<
+ *         self._cancel()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_9cancel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11TimerHandle_8cancel[] = "TimerHandle.cancel(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_9cancel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("cancel (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11TimerHandle_8cancel(((struct __pyx_obj_6uvloop_4loop_TimerHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_8cancel(struct __pyx_obj_6uvloop_4loop_TimerHandle *__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("cancel", 0);
+
+  /* "uvloop/cbhandles.pyx":309
+ * 
+ *     def cancel(self):
+ *         self._cancel()             # <<<<<<<<<<<<<<
+ * 
+ *     def when(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TimerHandle *)__pyx_v_self->__pyx_vtab)->_cancel(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 309, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":308
+ *         return self._cancelled
+ * 
+ *     def cancel(self):             # <<<<<<<<<<<<<<
+ *         self._cancel()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":311
+ *         self._cancel()
+ * 
+ *     def when(self):             # <<<<<<<<<<<<<<
+ *         return self.timer.get_when() * 1e-3
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_11when(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11TimerHandle_10when[] = "TimerHandle.when(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_11when(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("when (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11TimerHandle_10when(((struct __pyx_obj_6uvloop_4loop_TimerHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_10when(struct __pyx_obj_6uvloop_4loop_TimerHandle *__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("when", 0);
+
+  /* "uvloop/cbhandles.pyx":312
+ * 
+ *     def when(self):
+ *         return self.timer.get_when() * 1e-3             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->timer->__pyx_base.__pyx_vtab)->get_when(__pyx_v_self->timer); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 312, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_float_1eneg_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 312, __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;
+
+  /* "uvloop/cbhandles.pyx":311
+ *         self._cancel()
+ * 
+ *     def when(self):             # <<<<<<<<<<<<<<
+ *         return self.timer.get_when() * 1e-3
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle.when", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_13__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11TimerHandle_12__reduce_cython__[] = "TimerHandle.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_13__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_6uvloop_4loop_11TimerHandle_12__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_TimerHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TimerHandle *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__110, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle.__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_6uvloop_4loop_11TimerHandle_15__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11TimerHandle_14__setstate_cython__[] = "TimerHandle.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_11TimerHandle_15__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_6uvloop_4loop_11TimerHandle_14__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_TimerHandle *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TimerHandle *__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);
+
+  /* "(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__111, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TimerHandle.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":315
+ * 
+ * 
+ * cdef format_callback_name(func):             # <<<<<<<<<<<<<<
+ *     if hasattr(func, '__qualname__'):
+ *         cb_name = getattr(func, '__qualname__')
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_format_callback_name(PyObject *__pyx_v_func) {
+  PyObject *__pyx_v_cb_name = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("format_callback_name", 0);
+
+  /* "uvloop/cbhandles.pyx":316
+ * 
+ * cdef format_callback_name(func):
+ *     if hasattr(func, '__qualname__'):             # <<<<<<<<<<<<<<
+ *         cb_name = getattr(func, '__qualname__')
+ *     elif hasattr(func, '__name__'):
+ */
+  __pyx_t_1 = __Pyx_HasAttr(__pyx_v_func, __pyx_n_u_qualname); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(8, 316, __pyx_L1_error)
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/cbhandles.pyx":317
+ * cdef format_callback_name(func):
+ *     if hasattr(func, '__qualname__'):
+ *         cb_name = getattr(func, '__qualname__')             # <<<<<<<<<<<<<<
+ *     elif hasattr(func, '__name__'):
+ *         cb_name = getattr(func, '__name__')
+ */
+    __pyx_t_3 = __Pyx_GetAttr(__pyx_v_func, __pyx_n_u_qualname); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 317, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_v_cb_name = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/cbhandles.pyx":316
+ * 
+ * cdef format_callback_name(func):
+ *     if hasattr(func, '__qualname__'):             # <<<<<<<<<<<<<<
+ *         cb_name = getattr(func, '__qualname__')
+ *     elif hasattr(func, '__name__'):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/cbhandles.pyx":318
+ *     if hasattr(func, '__qualname__'):
+ *         cb_name = getattr(func, '__qualname__')
+ *     elif hasattr(func, '__name__'):             # <<<<<<<<<<<<<<
+ *         cb_name = getattr(func, '__name__')
+ *     else:
+ */
+  __pyx_t_2 = __Pyx_HasAttr(__pyx_v_func, __pyx_n_u_name); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(8, 318, __pyx_L1_error)
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/cbhandles.pyx":319
+ *         cb_name = getattr(func, '__qualname__')
+ *     elif hasattr(func, '__name__'):
+ *         cb_name = getattr(func, '__name__')             # <<<<<<<<<<<<<<
+ *     else:
+ *         cb_name = repr(func)
+ */
+    __pyx_t_3 = __Pyx_GetAttr(__pyx_v_func, __pyx_n_u_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 319, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_v_cb_name = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/cbhandles.pyx":318
+ *     if hasattr(func, '__qualname__'):
+ *         cb_name = getattr(func, '__qualname__')
+ *     elif hasattr(func, '__name__'):             # <<<<<<<<<<<<<<
+ *         cb_name = getattr(func, '__name__')
+ *     else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/cbhandles.pyx":321
+ *         cb_name = getattr(func, '__name__')
+ *     else:
+ *         cb_name = repr(func)             # <<<<<<<<<<<<<<
+ *     return cb_name
+ * 
+ */
+  /*else*/ {
+    __pyx_t_3 = PyObject_Repr(__pyx_v_func); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 321, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_v_cb_name = __pyx_t_3;
+    __pyx_t_3 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/cbhandles.pyx":322
+ *     else:
+ *         cb_name = repr(func)
+ *     return cb_name             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_cb_name);
+  __pyx_r = __pyx_v_cb_name;
+  goto __pyx_L0;
+
+  /* "uvloop/cbhandles.pyx":315
+ * 
+ * 
+ * cdef format_callback_name(func):             # <<<<<<<<<<<<<<
+ *     if hasattr(func, '__qualname__'):
+ *         cb_name = getattr(func, '__qualname__')
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.format_callback_name", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_cb_name);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":325
+ * 
+ * 
+ * cdef new_Handle(Loop loop, object callback, object args, object context):             # <<<<<<<<<<<<<<
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_new_Handle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_callback, PyObject *__pyx_v_args, PyObject *__pyx_v_context) {
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
+  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("new_Handle", 0);
+
+  /* "uvloop/cbhandles.pyx":327
+ * cdef new_Handle(Loop loop, object callback, object args, object context):
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)             # <<<<<<<<<<<<<<
+ *     handle._set_loop(loop)
+ *     handle._set_context(context)
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_Handle(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_Handle), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 327, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":328
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)
+ *     handle._set_loop(loop)             # <<<<<<<<<<<<<<
+ *     handle._set_context(context)
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_6Handle__set_loop(__pyx_v_handle, __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 328, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":329
+ *     handle = Handle.__new__(Handle)
+ *     handle._set_loop(loop)
+ *     handle._set_context(context)             # <<<<<<<<<<<<<<
+ * 
+ *     handle.cb_type = 1
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_6Handle__set_context(__pyx_v_handle, __pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 329, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":331
+ *     handle._set_context(context)
+ * 
+ *     handle.cb_type = 1             # <<<<<<<<<<<<<<
+ * 
+ *     handle.arg1 = callback
+ */
+  __pyx_v_handle->cb_type = 1;
+
+  /* "uvloop/cbhandles.pyx":333
+ *     handle.cb_type = 1
+ * 
+ *     handle.arg1 = callback             # <<<<<<<<<<<<<<
+ *     handle.arg2 = args
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_callback);
+  __Pyx_GIVEREF(__pyx_v_callback);
+  __Pyx_GOTREF(__pyx_v_handle->arg1);
+  __Pyx_DECREF(__pyx_v_handle->arg1);
+  __pyx_v_handle->arg1 = __pyx_v_callback;
+
+  /* "uvloop/cbhandles.pyx":334
+ * 
+ *     handle.arg1 = callback
+ *     handle.arg2 = args             # <<<<<<<<<<<<<<
+ * 
+ *     return handle
+ */
+  __Pyx_INCREF(__pyx_v_args);
+  __Pyx_GIVEREF(__pyx_v_args);
+  __Pyx_GOTREF(__pyx_v_handle->arg2);
+  __Pyx_DECREF(__pyx_v_handle->arg2);
+  __pyx_v_handle->arg2 = __pyx_v_args;
+
+  /* "uvloop/cbhandles.pyx":336
+ *     handle.arg2 = args
+ * 
+ *     return handle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = ((PyObject *)__pyx_v_handle);
+  goto __pyx_L0;
+
+  /* "uvloop/cbhandles.pyx":325
+ * 
+ * 
+ * cdef new_Handle(Loop loop, object callback, object args, object context):             # <<<<<<<<<<<<<<
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.new_Handle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":339
+ * 
+ * 
+ * cdef new_MethodHandle(Loop loop, str name, method_t callback, object context,             # <<<<<<<<<<<<<<
+ *                       object bound_to):
+ *     cdef Handle handle
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_name, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_bound_to) {
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
+  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("new_MethodHandle", 0);
+
+  /* "uvloop/cbhandles.pyx":342
+ *                       object bound_to):
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)             # <<<<<<<<<<<<<<
+ *     handle._set_loop(loop)
+ *     handle._set_context(context)
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_Handle(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_Handle), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 342, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":343
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)
+ *     handle._set_loop(loop)             # <<<<<<<<<<<<<<
+ *     handle._set_context(context)
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_6Handle__set_loop(__pyx_v_handle, __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 343, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":344
+ *     handle = Handle.__new__(Handle)
+ *     handle._set_loop(loop)
+ *     handle._set_context(context)             # <<<<<<<<<<<<<<
+ * 
+ *     handle.cb_type = 2
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_6Handle__set_context(__pyx_v_handle, __pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 344, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":346
+ *     handle._set_context(context)
+ * 
+ *     handle.cb_type = 2             # <<<<<<<<<<<<<<
+ *     handle.meth_name = name
+ * 
+ */
+  __pyx_v_handle->cb_type = 2;
+
+  /* "uvloop/cbhandles.pyx":347
+ * 
+ *     handle.cb_type = 2
+ *     handle.meth_name = name             # <<<<<<<<<<<<<<
+ * 
+ *     handle.callback = <void*> callback
+ */
+  __Pyx_INCREF(__pyx_v_name);
+  __Pyx_GIVEREF(__pyx_v_name);
+  __Pyx_GOTREF(__pyx_v_handle->meth_name);
+  __Pyx_DECREF(__pyx_v_handle->meth_name);
+  __pyx_v_handle->meth_name = __pyx_v_name;
+
+  /* "uvloop/cbhandles.pyx":349
+ *     handle.meth_name = name
+ * 
+ *     handle.callback = <void*> callback             # <<<<<<<<<<<<<<
+ *     handle.arg1 = bound_to
+ * 
+ */
+  __pyx_v_handle->callback = ((void *)__pyx_v_callback);
+
+  /* "uvloop/cbhandles.pyx":350
+ * 
+ *     handle.callback = <void*> callback
+ *     handle.arg1 = bound_to             # <<<<<<<<<<<<<<
+ * 
+ *     return handle
+ */
+  __Pyx_INCREF(__pyx_v_bound_to);
+  __Pyx_GIVEREF(__pyx_v_bound_to);
+  __Pyx_GOTREF(__pyx_v_handle->arg1);
+  __Pyx_DECREF(__pyx_v_handle->arg1);
+  __pyx_v_handle->arg1 = __pyx_v_bound_to;
+
+  /* "uvloop/cbhandles.pyx":352
+ *     handle.arg1 = bound_to
+ * 
+ *     return handle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = ((PyObject *)__pyx_v_handle);
+  goto __pyx_L0;
+
+  /* "uvloop/cbhandles.pyx":339
+ * 
+ * 
+ * cdef new_MethodHandle(Loop loop, str name, method_t callback, object context,             # <<<<<<<<<<<<<<
+ *                       object bound_to):
+ *     cdef Handle handle
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.new_MethodHandle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":355
+ * 
+ * 
+ * cdef new_MethodHandle1(Loop loop, str name, method1_t callback, object context,             # <<<<<<<<<<<<<<
+ *                        object bound_to, object arg):
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle1(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_name, __pyx_t_6uvloop_4loop_method1_t __pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_bound_to, PyObject *__pyx_v_arg) {
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
+  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("new_MethodHandle1", 0);
+
+  /* "uvloop/cbhandles.pyx":359
+ * 
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)             # <<<<<<<<<<<<<<
+ *     handle._set_loop(loop)
+ *     handle._set_context(context)
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_Handle(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_Handle), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 359, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":360
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)
+ *     handle._set_loop(loop)             # <<<<<<<<<<<<<<
+ *     handle._set_context(context)
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_6Handle__set_loop(__pyx_v_handle, __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 360, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":361
+ *     handle = Handle.__new__(Handle)
+ *     handle._set_loop(loop)
+ *     handle._set_context(context)             # <<<<<<<<<<<<<<
+ * 
+ *     handle.cb_type = 3
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_6Handle__set_context(__pyx_v_handle, __pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 361, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":363
+ *     handle._set_context(context)
+ * 
+ *     handle.cb_type = 3             # <<<<<<<<<<<<<<
+ *     handle.meth_name = name
+ * 
+ */
+  __pyx_v_handle->cb_type = 3;
+
+  /* "uvloop/cbhandles.pyx":364
+ * 
+ *     handle.cb_type = 3
+ *     handle.meth_name = name             # <<<<<<<<<<<<<<
+ * 
+ *     handle.callback = <void*> callback
+ */
+  __Pyx_INCREF(__pyx_v_name);
+  __Pyx_GIVEREF(__pyx_v_name);
+  __Pyx_GOTREF(__pyx_v_handle->meth_name);
+  __Pyx_DECREF(__pyx_v_handle->meth_name);
+  __pyx_v_handle->meth_name = __pyx_v_name;
+
+  /* "uvloop/cbhandles.pyx":366
+ *     handle.meth_name = name
+ * 
+ *     handle.callback = <void*> callback             # <<<<<<<<<<<<<<
+ *     handle.arg1 = bound_to
+ *     handle.arg2 = arg
+ */
+  __pyx_v_handle->callback = ((void *)__pyx_v_callback);
+
+  /* "uvloop/cbhandles.pyx":367
+ * 
+ *     handle.callback = <void*> callback
+ *     handle.arg1 = bound_to             # <<<<<<<<<<<<<<
+ *     handle.arg2 = arg
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_bound_to);
+  __Pyx_GIVEREF(__pyx_v_bound_to);
+  __Pyx_GOTREF(__pyx_v_handle->arg1);
+  __Pyx_DECREF(__pyx_v_handle->arg1);
+  __pyx_v_handle->arg1 = __pyx_v_bound_to;
+
+  /* "uvloop/cbhandles.pyx":368
+ *     handle.callback = <void*> callback
+ *     handle.arg1 = bound_to
+ *     handle.arg2 = arg             # <<<<<<<<<<<<<<
+ * 
+ *     return handle
+ */
+  __Pyx_INCREF(__pyx_v_arg);
+  __Pyx_GIVEREF(__pyx_v_arg);
+  __Pyx_GOTREF(__pyx_v_handle->arg2);
+  __Pyx_DECREF(__pyx_v_handle->arg2);
+  __pyx_v_handle->arg2 = __pyx_v_arg;
+
+  /* "uvloop/cbhandles.pyx":370
+ *     handle.arg2 = arg
+ * 
+ *     return handle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = ((PyObject *)__pyx_v_handle);
+  goto __pyx_L0;
+
+  /* "uvloop/cbhandles.pyx":355
+ * 
+ * 
+ * cdef new_MethodHandle1(Loop loop, str name, method1_t callback, object context,             # <<<<<<<<<<<<<<
+ *                        object bound_to, object arg):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.new_MethodHandle1", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":373
+ * 
+ * 
+ * cdef new_MethodHandle2(Loop loop, str name, method2_t callback, object context,             # <<<<<<<<<<<<<<
+ *                        object bound_to, object arg1, object arg2):
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle2(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_name, __pyx_t_6uvloop_4loop_method2_t __pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_bound_to, PyObject *__pyx_v_arg1, PyObject *__pyx_v_arg2) {
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
+  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("new_MethodHandle2", 0);
+
+  /* "uvloop/cbhandles.pyx":377
+ * 
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)             # <<<<<<<<<<<<<<
+ *     handle._set_loop(loop)
+ *     handle._set_context(context)
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_Handle(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_Handle), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 377, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":378
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)
+ *     handle._set_loop(loop)             # <<<<<<<<<<<<<<
+ *     handle._set_context(context)
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_6Handle__set_loop(__pyx_v_handle, __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":379
+ *     handle = Handle.__new__(Handle)
+ *     handle._set_loop(loop)
+ *     handle._set_context(context)             # <<<<<<<<<<<<<<
+ * 
+ *     handle.cb_type = 4
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_6Handle__set_context(__pyx_v_handle, __pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 379, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":381
+ *     handle._set_context(context)
+ * 
+ *     handle.cb_type = 4             # <<<<<<<<<<<<<<
+ *     handle.meth_name = name
+ * 
+ */
+  __pyx_v_handle->cb_type = 4;
+
+  /* "uvloop/cbhandles.pyx":382
+ * 
+ *     handle.cb_type = 4
+ *     handle.meth_name = name             # <<<<<<<<<<<<<<
+ * 
+ *     handle.callback = <void*> callback
+ */
+  __Pyx_INCREF(__pyx_v_name);
+  __Pyx_GIVEREF(__pyx_v_name);
+  __Pyx_GOTREF(__pyx_v_handle->meth_name);
+  __Pyx_DECREF(__pyx_v_handle->meth_name);
+  __pyx_v_handle->meth_name = __pyx_v_name;
+
+  /* "uvloop/cbhandles.pyx":384
+ *     handle.meth_name = name
+ * 
+ *     handle.callback = <void*> callback             # <<<<<<<<<<<<<<
+ *     handle.arg1 = bound_to
+ *     handle.arg2 = arg1
+ */
+  __pyx_v_handle->callback = ((void *)__pyx_v_callback);
+
+  /* "uvloop/cbhandles.pyx":385
+ * 
+ *     handle.callback = <void*> callback
+ *     handle.arg1 = bound_to             # <<<<<<<<<<<<<<
+ *     handle.arg2 = arg1
+ *     handle.arg3 = arg2
+ */
+  __Pyx_INCREF(__pyx_v_bound_to);
+  __Pyx_GIVEREF(__pyx_v_bound_to);
+  __Pyx_GOTREF(__pyx_v_handle->arg1);
+  __Pyx_DECREF(__pyx_v_handle->arg1);
+  __pyx_v_handle->arg1 = __pyx_v_bound_to;
+
+  /* "uvloop/cbhandles.pyx":386
+ *     handle.callback = <void*> callback
+ *     handle.arg1 = bound_to
+ *     handle.arg2 = arg1             # <<<<<<<<<<<<<<
+ *     handle.arg3 = arg2
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_arg1);
+  __Pyx_GIVEREF(__pyx_v_arg1);
+  __Pyx_GOTREF(__pyx_v_handle->arg2);
+  __Pyx_DECREF(__pyx_v_handle->arg2);
+  __pyx_v_handle->arg2 = __pyx_v_arg1;
+
+  /* "uvloop/cbhandles.pyx":387
+ *     handle.arg1 = bound_to
+ *     handle.arg2 = arg1
+ *     handle.arg3 = arg2             # <<<<<<<<<<<<<<
+ * 
+ *     return handle
+ */
+  __Pyx_INCREF(__pyx_v_arg2);
+  __Pyx_GIVEREF(__pyx_v_arg2);
+  __Pyx_GOTREF(__pyx_v_handle->arg3);
+  __Pyx_DECREF(__pyx_v_handle->arg3);
+  __pyx_v_handle->arg3 = __pyx_v_arg2;
+
+  /* "uvloop/cbhandles.pyx":389
+ *     handle.arg3 = arg2
+ * 
+ *     return handle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = ((PyObject *)__pyx_v_handle);
+  goto __pyx_L0;
+
+  /* "uvloop/cbhandles.pyx":373
+ * 
+ * 
+ * cdef new_MethodHandle2(Loop loop, str name, method2_t callback, object context,             # <<<<<<<<<<<<<<
+ *                        object bound_to, object arg1, object arg2):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.new_MethodHandle2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":392
+ * 
+ * 
+ * cdef new_MethodHandle3(Loop loop, str name, method3_t callback, object context,             # <<<<<<<<<<<<<<
+ *                        object bound_to, object arg1, object arg2, object arg3):
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle3(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_name, __pyx_t_6uvloop_4loop_method3_t __pyx_v_callback, PyObject *__pyx_v_context, PyObject *__pyx_v_bound_to, PyObject *__pyx_v_arg1, PyObject *__pyx_v_arg2, PyObject *__pyx_v_arg3) {
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
+  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("new_MethodHandle3", 0);
+
+  /* "uvloop/cbhandles.pyx":396
+ * 
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)             # <<<<<<<<<<<<<<
+ *     handle._set_loop(loop)
+ *     handle._set_context(context)
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_Handle(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_Handle), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 396, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":397
+ *     cdef Handle handle
+ *     handle = Handle.__new__(Handle)
+ *     handle._set_loop(loop)             # <<<<<<<<<<<<<<
+ *     handle._set_context(context)
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_6Handle__set_loop(__pyx_v_handle, __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 397, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":398
+ *     handle = Handle.__new__(Handle)
+ *     handle._set_loop(loop)
+ *     handle._set_context(context)             # <<<<<<<<<<<<<<
+ * 
+ *     handle.cb_type = 5
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_6Handle__set_context(__pyx_v_handle, __pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 398, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":400
+ *     handle._set_context(context)
+ * 
+ *     handle.cb_type = 5             # <<<<<<<<<<<<<<
+ *     handle.meth_name = name
+ * 
+ */
+  __pyx_v_handle->cb_type = 5;
+
+  /* "uvloop/cbhandles.pyx":401
+ * 
+ *     handle.cb_type = 5
+ *     handle.meth_name = name             # <<<<<<<<<<<<<<
+ * 
+ *     handle.callback = <void*> callback
+ */
+  __Pyx_INCREF(__pyx_v_name);
+  __Pyx_GIVEREF(__pyx_v_name);
+  __Pyx_GOTREF(__pyx_v_handle->meth_name);
+  __Pyx_DECREF(__pyx_v_handle->meth_name);
+  __pyx_v_handle->meth_name = __pyx_v_name;
+
+  /* "uvloop/cbhandles.pyx":403
+ *     handle.meth_name = name
+ * 
+ *     handle.callback = <void*> callback             # <<<<<<<<<<<<<<
+ *     handle.arg1 = bound_to
+ *     handle.arg2 = arg1
+ */
+  __pyx_v_handle->callback = ((void *)__pyx_v_callback);
+
+  /* "uvloop/cbhandles.pyx":404
+ * 
+ *     handle.callback = <void*> callback
+ *     handle.arg1 = bound_to             # <<<<<<<<<<<<<<
+ *     handle.arg2 = arg1
+ *     handle.arg3 = arg2
+ */
+  __Pyx_INCREF(__pyx_v_bound_to);
+  __Pyx_GIVEREF(__pyx_v_bound_to);
+  __Pyx_GOTREF(__pyx_v_handle->arg1);
+  __Pyx_DECREF(__pyx_v_handle->arg1);
+  __pyx_v_handle->arg1 = __pyx_v_bound_to;
+
+  /* "uvloop/cbhandles.pyx":405
+ *     handle.callback = <void*> callback
+ *     handle.arg1 = bound_to
+ *     handle.arg2 = arg1             # <<<<<<<<<<<<<<
+ *     handle.arg3 = arg2
+ *     handle.arg4 = arg3
+ */
+  __Pyx_INCREF(__pyx_v_arg1);
+  __Pyx_GIVEREF(__pyx_v_arg1);
+  __Pyx_GOTREF(__pyx_v_handle->arg2);
+  __Pyx_DECREF(__pyx_v_handle->arg2);
+  __pyx_v_handle->arg2 = __pyx_v_arg1;
+
+  /* "uvloop/cbhandles.pyx":406
+ *     handle.arg1 = bound_to
+ *     handle.arg2 = arg1
+ *     handle.arg3 = arg2             # <<<<<<<<<<<<<<
+ *     handle.arg4 = arg3
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_arg2);
+  __Pyx_GIVEREF(__pyx_v_arg2);
+  __Pyx_GOTREF(__pyx_v_handle->arg3);
+  __Pyx_DECREF(__pyx_v_handle->arg3);
+  __pyx_v_handle->arg3 = __pyx_v_arg2;
+
+  /* "uvloop/cbhandles.pyx":407
+ *     handle.arg2 = arg1
+ *     handle.arg3 = arg2
+ *     handle.arg4 = arg3             # <<<<<<<<<<<<<<
+ * 
+ *     return handle
+ */
+  __Pyx_INCREF(__pyx_v_arg3);
+  __Pyx_GIVEREF(__pyx_v_arg3);
+  __Pyx_GOTREF(__pyx_v_handle->arg4);
+  __Pyx_DECREF(__pyx_v_handle->arg4);
+  __pyx_v_handle->arg4 = __pyx_v_arg3;
+
+  /* "uvloop/cbhandles.pyx":409
+ *     handle.arg4 = arg3
+ * 
+ *     return handle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = ((PyObject *)__pyx_v_handle);
+  goto __pyx_L0;
+
+  /* "uvloop/cbhandles.pyx":392
+ * 
+ * 
+ * cdef new_MethodHandle3(Loop loop, str name, method3_t callback, object context,             # <<<<<<<<<<<<<<
+ *                        object bound_to, object arg1, object arg2, object arg3):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.new_MethodHandle3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/cbhandles.pyx":412
+ * 
+ * 
+ * cdef extract_stack():             # <<<<<<<<<<<<<<
+ *     """Replacement for traceback.extract_stack() that only does the
+ *     necessary work for asyncio debug mode.
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_extract_stack(void) {
+  PyObject *__pyx_v_f = NULL;
+  PyObject *__pyx_v_stack = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  char const *__pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("extract_stack", 0);
+
+  /* "uvloop/cbhandles.pyx":416
+ *     necessary work for asyncio debug mode.
+ *     """
+ *     f = sys_getframe()             # <<<<<<<<<<<<<<
+ *     if f is None:
+ *         return
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_sys_getframe);
+  __pyx_t_2 = __pyx_v_6uvloop_4loop_sys_getframe; __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __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(8, 416, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_f = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/cbhandles.pyx":417
+ *     """
+ *     f = sys_getframe()
+ *     if f is None:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_4 = (__pyx_v_f == Py_None);
+  __pyx_t_5 = (__pyx_t_4 != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/cbhandles.pyx":418
+ *     f = sys_getframe()
+ *     if f is None:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/cbhandles.pyx":417
+ *     """
+ *     f = sys_getframe()
+ *     if f is None:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  }
+
+  /* "uvloop/cbhandles.pyx":420
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         stack = tb_StackSummary.extract(tb_walk_stack(f),
+ *                                         limit=DEBUG_STACK_DEPTH,
+ */
+  /*try:*/ {
+
+    /* "uvloop/cbhandles.pyx":421
+ * 
+ *     try:
+ *         stack = tb_StackSummary.extract(tb_walk_stack(f),             # <<<<<<<<<<<<<<
+ *                                         limit=DEBUG_STACK_DEPTH,
+ *                                         lookup_lines=False)
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_tb_StackSummary, __pyx_n_s_extract); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 421, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_tb_walk_stack);
+    __pyx_t_3 = __pyx_v_6uvloop_4loop_tb_walk_stack; __pyx_t_6 = NULL;
+    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_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_6, __pyx_v_f) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_f);
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 421, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 421, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/cbhandles.pyx":422
+ *     try:
+ *         stack = tb_StackSummary.extract(tb_walk_stack(f),
+ *                                         limit=DEBUG_STACK_DEPTH,             # <<<<<<<<<<<<<<
+ *                                         lookup_lines=False)
+ *     finally:
+ */
+    __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 422, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_limit, __pyx_int_10) < 0) __PYX_ERR(8, 422, __pyx_L5_error)
+
+    /* "uvloop/cbhandles.pyx":423
+ *         stack = tb_StackSummary.extract(tb_walk_stack(f),
+ *                                         limit=DEBUG_STACK_DEPTH,
+ *                                         lookup_lines=False)             # <<<<<<<<<<<<<<
+ *     finally:
+ *         f = None
+ */
+    if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lookup_lines, Py_False) < 0) __PYX_ERR(8, 422, __pyx_L5_error)
+
+    /* "uvloop/cbhandles.pyx":421
+ * 
+ *     try:
+ *         stack = tb_StackSummary.extract(tb_walk_stack(f),             # <<<<<<<<<<<<<<
+ *                                         limit=DEBUG_STACK_DEPTH,
+ *                                         lookup_lines=False)
+ */
+    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 421, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_v_stack = __pyx_t_6;
+    __pyx_t_6 = 0;
+  }
+
+  /* "uvloop/cbhandles.pyx":425
+ *                                         lookup_lines=False)
+ *     finally:
+ *         f = None             # <<<<<<<<<<<<<<
+ * 
+ *     stack.reverse()
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __Pyx_INCREF(Py_None);
+      __Pyx_DECREF_SET(__pyx_v_f, Py_None);
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __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_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 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);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __Pyx_XGOTREF(__pyx_t_15);
+      __pyx_t_7 = __pyx_lineno; __pyx_t_8 = __pyx_clineno; __pyx_t_9 = __pyx_filename;
+      {
+        __Pyx_INCREF(Py_None);
+        __Pyx_DECREF_SET(__pyx_v_f, Py_None);
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+      }
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __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_7; __pyx_clineno = __pyx_t_8; __pyx_filename = __pyx_t_9;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/cbhandles.pyx":427
+ *         f = None
+ * 
+ *     stack.reverse()             # <<<<<<<<<<<<<<
+ *     return stack
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_stack, __pyx_n_s_reverse); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 427, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_6 = (__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_6)) __PYX_ERR(8, 427, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/cbhandles.pyx":428
+ * 
+ *     stack.reverse()
+ *     return stack             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_stack);
+  __pyx_r = __pyx_v_stack;
+  goto __pyx_L0;
+
+  /* "uvloop/cbhandles.pyx":412
+ * 
+ * 
+ * cdef extract_stack():             # <<<<<<<<<<<<<<
+ *     """Replacement for traceback.extract_stack() that only does the
+ *     necessary work for asyncio debug mode.
+ */
+
+  /* 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_6);
+  __Pyx_AddTraceback("uvloop.loop.extract_stack", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_f);
+  __Pyx_XDECREF(__pyx_v_stack);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":10
+ *         object _sockname
+ * 
+ *     def __init__(self, int family, int type, int proto, int fd):             # <<<<<<<<<<<<<<
+ *         self._family = family
+ *         self._type = type
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_12PseudoSocket_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_12PseudoSocket_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_v_family;
+  int __pyx_v_type;
+  int __pyx_v_proto;
+  int __pyx_v_fd;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_family,&__pyx_n_s_type,&__pyx_n_s_proto,&__pyx_n_s_fd,0};
+    PyObject* values[4] = {0,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  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);
+        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_family)) != 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_type)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 1); __PYX_ERR(9, 10, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_proto)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 2); __PYX_ERR(9, 10, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fd)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 3); __PYX_ERR(9, 10, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(9, 10, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 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);
+    }
+    __pyx_v_family = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_family == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 10, __pyx_L3_error)
+    __pyx_v_type = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 10, __pyx_L3_error)
+    __pyx_v_proto = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_proto == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 10, __pyx_L3_error)
+    __pyx_v_fd = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fd == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 10, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(9, 10, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket___init__(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_family, __pyx_v_type, __pyx_v_proto, __pyx_v_fd);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_12PseudoSocket___init__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_fd) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  /* "uvloop/pseudosock.pyx":11
+ * 
+ *     def __init__(self, int family, int type, int proto, int fd):
+ *         self._family = family             # <<<<<<<<<<<<<<
+ *         self._type = type
+ *         self._proto = proto
+ */
+  __pyx_v_self->_family = __pyx_v_family;
+
+  /* "uvloop/pseudosock.pyx":12
+ *     def __init__(self, int family, int type, int proto, int fd):
+ *         self._family = family
+ *         self._type = type             # <<<<<<<<<<<<<<
+ *         self._proto = proto
+ *         self._fd = fd
+ */
+  __pyx_v_self->_type = __pyx_v_type;
+
+  /* "uvloop/pseudosock.pyx":13
+ *         self._family = family
+ *         self._type = type
+ *         self._proto = proto             # <<<<<<<<<<<<<<
+ *         self._fd = fd
+ *         self._peername = None
+ */
+  __pyx_v_self->_proto = __pyx_v_proto;
+
+  /* "uvloop/pseudosock.pyx":14
+ *         self._type = type
+ *         self._proto = proto
+ *         self._fd = fd             # <<<<<<<<<<<<<<
+ *         self._peername = None
+ *         self._sockname = None
+ */
+  __pyx_v_self->_fd = __pyx_v_fd;
+
+  /* "uvloop/pseudosock.pyx":15
+ *         self._proto = proto
+ *         self._fd = fd
+ *         self._peername = None             # <<<<<<<<<<<<<<
+ *         self._sockname = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_peername);
+  __Pyx_DECREF(__pyx_v_self->_peername);
+  __pyx_v_self->_peername = Py_None;
+
+  /* "uvloop/pseudosock.pyx":16
+ *         self._fd = fd
+ *         self._peername = None
+ *         self._sockname = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _na(self, what):
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_sockname);
+  __Pyx_DECREF(__pyx_v_self->_sockname);
+  __pyx_v_self->_sockname = Py_None;
+
+  /* "uvloop/pseudosock.pyx":10
+ *         object _sockname
+ * 
+ *     def __init__(self, int family, int type, int proto, int fd):             # <<<<<<<<<<<<<<
+ *         self._family = family
+ *         self._type = type
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":18
+ *         self._sockname = None
+ * 
+ *     cdef _na(self, what):             # <<<<<<<<<<<<<<
+ *         raise TypeError('transport sockets do not support {}'.format(what))
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12PseudoSocket__na(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_what) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("_na", 0);
+
+  /* "uvloop/pseudosock.pyx":19
+ * 
+ *     cdef _na(self, what):
+ *         raise TypeError('transport sockets do not support {}'.format(what))             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _make_sock(self):
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_transport_sockets_do_not_support, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_what) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_what);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __PYX_ERR(9, 19, __pyx_L1_error)
+
+  /* "uvloop/pseudosock.pyx":18
+ *         self._sockname = None
+ * 
+ *     cdef _na(self, what):             # <<<<<<<<<<<<<<
+ *         raise TypeError('transport sockets do not support {}'.format(what))
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket._na", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":21
+ *         raise TypeError('transport sockets do not support {}'.format(what))
+ * 
+ *     cdef _make_sock(self):             # <<<<<<<<<<<<<<
+ *         return socket_socket(self._family, self._type, self._proto, self._fd)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12PseudoSocket__make_sock(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_make_sock", 0);
+
+  /* "uvloop/pseudosock.pyx":22
+ * 
+ *     cdef _make_sock(self):
+ *         return socket_socket(self._family, self._type, self._proto, self._fd)             # <<<<<<<<<<<<<<
+ * 
+ *     property family:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->_family); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_self->_proto); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->_fd); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_socket);
+  __pyx_t_6 = __pyx_v_6uvloop_4loop_socket_socket; __pyx_t_7 = NULL;
+  __pyx_t_8 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+      __pyx_t_8 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_6)) {
+    PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 22, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+    PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 22, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_9 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(9, 22, __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_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_8, __pyx_t_5);
+    __pyx_t_2 = 0;
+    __pyx_t_3 = 0;
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 22, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/pseudosock.pyx":21
+ *         raise TypeError('transport sockets do not support {}'.format(what))
+ * 
+ *     cdef _make_sock(self):             # <<<<<<<<<<<<<<
+ *         return socket_socket(self._family, self._type, self._proto, self._fd)
+ * 
+ */
+
+  /* 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_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket._make_sock", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":25
+ * 
+ *     property family:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             try:
+ *                 return socket_AddressFamily(self._family)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_6family_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_6family_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_6family___get__(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_6family___get__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "uvloop/pseudosock.pyx":26
+ *     property family:
+ *         def __get__(self):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 return socket_AddressFamily(self._family)
+ *             except ValueError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/pseudosock.pyx":27
+ *         def __get__(self):
+ *             try:
+ *                 return socket_AddressFamily(self._family)             # <<<<<<<<<<<<<<
+ *             except ValueError:
+ *                 return self._family
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->_family); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 27, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_AddressFamily);
+      __pyx_t_6 = __pyx_v_6uvloop_4loop_socket_AddressFamily; __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 27, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __pyx_r = __pyx_t_4;
+      __pyx_t_4 = 0;
+      goto __pyx_L7_try_return;
+
+      /* "uvloop/pseudosock.pyx":26
+ *     property family:
+ *         def __get__(self):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 return socket_AddressFamily(self._family)
+ *             except ValueError:
+ */
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/pseudosock.pyx":28
+ *             try:
+ *                 return socket_AddressFamily(self._family)
+ *             except ValueError:             # <<<<<<<<<<<<<<
+ *                 return self._family
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError);
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("uvloop.loop.PseudoSocket.family.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_5) < 0) __PYX_ERR(9, 28, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_5);
+
+      /* "uvloop/pseudosock.pyx":29
+ *                 return socket_AddressFamily(self._family)
+ *             except ValueError:
+ *                 return self._family             # <<<<<<<<<<<<<<
+ * 
+ *     property type:
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_self->_family); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 29, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_r = __pyx_t_7;
+      __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L6_except_return;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/pseudosock.pyx":26
+ *     property family:
+ *         def __get__(self):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 return socket_AddressFamily(self._family)
+ *             except ValueError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L7_try_return:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L0;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L0;
+  }
+
+  /* "uvloop/pseudosock.pyx":25
+ * 
+ *     property family:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             try:
+ *                 return socket_AddressFamily(self._family)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.family.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":32
+ * 
+ *     property type:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             try:
+ *                 return socket_SocketKind(self._type)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_4type_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_4type_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_4type___get__(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_4type___get__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "uvloop/pseudosock.pyx":33
+ *     property type:
+ *         def __get__(self):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 return socket_SocketKind(self._type)
+ *             except ValueError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/pseudosock.pyx":34
+ *         def __get__(self):
+ *             try:
+ *                 return socket_SocketKind(self._type)             # <<<<<<<<<<<<<<
+ *             except ValueError:
+ *                 return self._type
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 34, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_SocketKind);
+      __pyx_t_6 = __pyx_v_6uvloop_4loop_socket_SocketKind; __pyx_t_7 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 34, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __pyx_r = __pyx_t_4;
+      __pyx_t_4 = 0;
+      goto __pyx_L7_try_return;
+
+      /* "uvloop/pseudosock.pyx":33
+ *     property type:
+ *         def __get__(self):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 return socket_SocketKind(self._type)
+ *             except ValueError:
+ */
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/pseudosock.pyx":35
+ *             try:
+ *                 return socket_SocketKind(self._type)
+ *             except ValueError:             # <<<<<<<<<<<<<<
+ *                 return self._type
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError);
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("uvloop.loop.PseudoSocket.type.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_5) < 0) __PYX_ERR(9, 35, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_5);
+
+      /* "uvloop/pseudosock.pyx":36
+ *                 return socket_SocketKind(self._type)
+ *             except ValueError:
+ *                 return self._type             # <<<<<<<<<<<<<<
+ * 
+ *     property proto:
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_self->_type); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 36, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_r = __pyx_t_7;
+      __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L6_except_return;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/pseudosock.pyx":33
+ *     property type:
+ *         def __get__(self):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 return socket_SocketKind(self._type)
+ *             except ValueError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L7_try_return:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L0;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L0;
+  }
+
+  /* "uvloop/pseudosock.pyx":32
+ * 
+ *     property type:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             try:
+ *                 return socket_SocketKind(self._type)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.type.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":39
+ * 
+ *     property proto:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self._proto
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_5proto_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_5proto_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_5proto___get__(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_5proto___get__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__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);
+
+  /* "uvloop/pseudosock.pyx":40
+ *     property proto:
+ *         def __get__(self):
+ *             return self._proto             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_proto); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/pseudosock.pyx":39
+ * 
+ *     property proto:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self._proto
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.proto.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":42
+ *             return self._proto
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         s = ("<uvloop.PseudoSocket fd={}, family={!s}, "
+ *              "type={!s}, proto={}").format(self.fileno(), self.family,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_3__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_2__repr__(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_2__repr__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self) {
+  PyObject *__pyx_v_s = NULL;
+  PyObject *__pyx_v_laddr = NULL;
+  PyObject *__pyx_v_raddr = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "uvloop/pseudosock.pyx":44
+ *     def __repr__(self):
+ *         s = ("<uvloop.PseudoSocket fd={}, family={!s}, "
+ *              "type={!s}, proto={}").format(self.fileno(), self.family,             # <<<<<<<<<<<<<<
+ *                                            self.type, self.proto)
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_uvloop_PseudoSocket_fd_family_s, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_fileno); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  /* "uvloop/pseudosock.pyx":45
+ *         s = ("<uvloop.PseudoSocket fd={}, family={!s}, "
+ *              "type={!s}, proto={}").format(self.fileno(), self.family,
+ *                                            self.type, self.proto)             # <<<<<<<<<<<<<<
+ * 
+ *         if self._fd != -1:
+ */
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_proto); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = NULL;
+  __pyx_t_8 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_8 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_6};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 44, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_6};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 44, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_9 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(9, 44, __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_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_8, __pyx_t_6);
+    __pyx_t_3 = 0;
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 44, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_s = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":47
+ *                                            self.type, self.proto)
+ * 
+ *         if self._fd != -1:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 laddr = self.getsockname()
+ */
+  __pyx_t_10 = ((__pyx_v_self->_fd != -1L) != 0);
+  if (__pyx_t_10) {
+
+    /* "uvloop/pseudosock.pyx":48
+ * 
+ *         if self._fd != -1:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 laddr = self.getsockname()
+ *                 if laddr:
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      /*try:*/ {
+
+        /* "uvloop/pseudosock.pyx":49
+ *         if self._fd != -1:
+ *             try:
+ *                 laddr = self.getsockname()             # <<<<<<<<<<<<<<
+ *                 if laddr:
+ *                     s += ", laddr=%s" % str(laddr)
+ */
+        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getsockname); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 49, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_9 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+          __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2);
+          if (likely(__pyx_t_9)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+            __Pyx_INCREF(__pyx_t_9);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_2, function);
+          }
+        }
+        __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 49, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __pyx_v_laddr = __pyx_t_1;
+        __pyx_t_1 = 0;
+
+        /* "uvloop/pseudosock.pyx":50
+ *             try:
+ *                 laddr = self.getsockname()
+ *                 if laddr:             # <<<<<<<<<<<<<<
+ *                     s += ", laddr=%s" % str(laddr)
+ *             except socket_error:
+ */
+        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_laddr); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(9, 50, __pyx_L4_error)
+        if (__pyx_t_10) {
+
+          /* "uvloop/pseudosock.pyx":51
+ *                 laddr = self.getsockname()
+ *                 if laddr:
+ *                     s += ", laddr=%s" % str(laddr)             # <<<<<<<<<<<<<<
+ *             except socket_error:
+ *                 pass
+ */
+          __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_v_laddr); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 51, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __pyx_t_2 = PyUnicode_Format(__pyx_kp_u_laddr_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 51, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 51, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __Pyx_DECREF_SET(__pyx_v_s, __pyx_t_1);
+          __pyx_t_1 = 0;
+
+          /* "uvloop/pseudosock.pyx":50
+ *             try:
+ *                 laddr = self.getsockname()
+ *                 if laddr:             # <<<<<<<<<<<<<<
+ *                     s += ", laddr=%s" % str(laddr)
+ *             except socket_error:
+ */
+        }
+
+        /* "uvloop/pseudosock.pyx":48
+ * 
+ *         if self._fd != -1:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 laddr = self.getsockname()
+ *                 if laddr:
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      goto __pyx_L9_try_end;
+      __pyx_L4_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 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;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/pseudosock.pyx":52
+ *                 if laddr:
+ *                     s += ", laddr=%s" % str(laddr)
+ *             except socket_error:             # <<<<<<<<<<<<<<
+ *                 pass
+ *             try:
+ */
+      __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_socket_error);
+      if (__pyx_t_8) {
+        __Pyx_ErrRestore(0,0,0);
+        goto __pyx_L5_exception_handled;
+      }
+      goto __pyx_L6_except_error;
+      __pyx_L6_except_error:;
+
+      /* "uvloop/pseudosock.pyx":48
+ * 
+ *         if self._fd != -1:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 laddr = self.getsockname()
+ *                 if laddr:
+ */
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __Pyx_XGIVEREF(__pyx_t_12);
+      __Pyx_XGIVEREF(__pyx_t_13);
+      __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+      goto __pyx_L1_error;
+      __pyx_L5_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __Pyx_XGIVEREF(__pyx_t_12);
+      __Pyx_XGIVEREF(__pyx_t_13);
+      __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+      __pyx_L9_try_end:;
+    }
+
+    /* "uvloop/pseudosock.pyx":54
+ *             except socket_error:
+ *                 pass
+ *             try:             # <<<<<<<<<<<<<<
+ *                 raddr = self.getpeername()
+ *                 if raddr:
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_11);
+      /*try:*/ {
+
+        /* "uvloop/pseudosock.pyx":55
+ *                 pass
+ *             try:
+ *                 raddr = self.getpeername()             # <<<<<<<<<<<<<<
+ *                 if raddr:
+ *                     s += ", raddr=%s" % str(raddr)
+ */
+        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getpeername); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 55, __pyx_L11_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_9 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+          __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2);
+          if (likely(__pyx_t_9)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+            __Pyx_INCREF(__pyx_t_9);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_2, function);
+          }
+        }
+        __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 55, __pyx_L11_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __pyx_v_raddr = __pyx_t_1;
+        __pyx_t_1 = 0;
+
+        /* "uvloop/pseudosock.pyx":56
+ *             try:
+ *                 raddr = self.getpeername()
+ *                 if raddr:             # <<<<<<<<<<<<<<
+ *                     s += ", raddr=%s" % str(raddr)
+ *             except socket_error:
+ */
+        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_raddr); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(9, 56, __pyx_L11_error)
+        if (__pyx_t_10) {
+
+          /* "uvloop/pseudosock.pyx":57
+ *                 raddr = self.getpeername()
+ *                 if raddr:
+ *                     s += ", raddr=%s" % str(raddr)             # <<<<<<<<<<<<<<
+ *             except socket_error:
+ *                 pass
+ */
+          __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_v_raddr); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 57, __pyx_L11_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __pyx_t_2 = PyUnicode_Format(__pyx_kp_u_raddr_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 57, __pyx_L11_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 57, __pyx_L11_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __Pyx_DECREF_SET(__pyx_v_s, __pyx_t_1);
+          __pyx_t_1 = 0;
+
+          /* "uvloop/pseudosock.pyx":56
+ *             try:
+ *                 raddr = self.getpeername()
+ *                 if raddr:             # <<<<<<<<<<<<<<
+ *                     s += ", raddr=%s" % str(raddr)
+ *             except socket_error:
+ */
+        }
+
+        /* "uvloop/pseudosock.pyx":54
+ *             except socket_error:
+ *                 pass
+ *             try:             # <<<<<<<<<<<<<<
+ *                 raddr = self.getpeername()
+ *                 if raddr:
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      goto __pyx_L16_try_end;
+      __pyx_L11_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 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;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/pseudosock.pyx":58
+ *                 if raddr:
+ *                     s += ", raddr=%s" % str(raddr)
+ *             except socket_error:             # <<<<<<<<<<<<<<
+ *                 pass
+ *         s += '>'
+ */
+      __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_socket_error);
+      if (__pyx_t_8) {
+        __Pyx_ErrRestore(0,0,0);
+        goto __pyx_L12_exception_handled;
+      }
+      goto __pyx_L13_except_error;
+      __pyx_L13_except_error:;
+
+      /* "uvloop/pseudosock.pyx":54
+ *             except socket_error:
+ *                 pass
+ *             try:             # <<<<<<<<<<<<<<
+ *                 raddr = self.getpeername()
+ *                 if raddr:
+ */
+      __Pyx_XGIVEREF(__pyx_t_13);
+      __Pyx_XGIVEREF(__pyx_t_12);
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_12, __pyx_t_11);
+      goto __pyx_L1_error;
+      __pyx_L12_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_13);
+      __Pyx_XGIVEREF(__pyx_t_12);
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_12, __pyx_t_11);
+      __pyx_L16_try_end:;
+    }
+
+    /* "uvloop/pseudosock.pyx":47
+ *                                            self.type, self.proto)
+ * 
+ *         if self._fd != -1:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 laddr = self.getsockname()
+ */
+  }
+
+  /* "uvloop/pseudosock.pyx":60
+ *             except socket_error:
+ *                 pass
+ *         s += '>'             # <<<<<<<<<<<<<<
+ *         return s
+ * 
+ */
+  __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_s, __pyx_kp_u__105); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_s, __pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":61
+ *                 pass
+ *         s += '>'
+ *         return s             # <<<<<<<<<<<<<<
+ * 
+ *     def __getstate__(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_s);
+  __pyx_r = __pyx_v_s;
+  goto __pyx_L0;
+
+  /* "uvloop/pseudosock.pyx":42
+ *             return self._proto
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         s = ("<uvloop.PseudoSocket fd={}, family={!s}, "
+ *              "type={!s}, proto={}").format(self.fileno(), self.family,
+ */
+
+  /* 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_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_s);
+  __Pyx_XDECREF(__pyx_v_laddr);
+  __Pyx_XDECREF(__pyx_v_raddr);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":63
+ *         return s
+ * 
+ *     def __getstate__(self):             # <<<<<<<<<<<<<<
+ *         raise TypeError("Cannot serialize socket object")
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_5__getstate__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_4__getstate__[] = "PseudoSocket.__getstate__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_5__getstate__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getstate__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_4__getstate__(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_4__getstate__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__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("__getstate__", 0);
+
+  /* "uvloop/pseudosock.pyx":64
+ * 
+ *     def __getstate__(self):
+ *         raise TypeError("Cannot serialize socket object")             # <<<<<<<<<<<<<<
+ * 
+ *     def fileno(self):
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__112, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 64, __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(9, 64, __pyx_L1_error)
+
+  /* "uvloop/pseudosock.pyx":63
+ *         return s
+ * 
+ *     def __getstate__(self):             # <<<<<<<<<<<<<<
+ *         raise TypeError("Cannot serialize socket object")
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.__getstate__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":66
+ *         raise TypeError("Cannot serialize socket object")
+ * 
+ *     def fileno(self):             # <<<<<<<<<<<<<<
+ *         return self._fd
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_7fileno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_6fileno[] = "PseudoSocket.fileno(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_7fileno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("fileno (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_6fileno(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_6fileno(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__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("fileno", 0);
+
+  /* "uvloop/pseudosock.pyx":67
+ * 
+ *     def fileno(self):
+ *         return self._fd             # <<<<<<<<<<<<<<
+ * 
+ *     def dup(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/pseudosock.pyx":66
+ *         raise TypeError("Cannot serialize socket object")
+ * 
+ *     def fileno(self):             # <<<<<<<<<<<<<<
+ *         return self._fd
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.fileno", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":69
+ *         return self._fd
+ * 
+ *     def dup(self):             # <<<<<<<<<<<<<<
+ *         fd = os_dup(self._fd)
+ *         sock = socket_socket(self._family, self._type, self._proto, fileno=fd)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_9dup(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_8dup[] = "PseudoSocket.dup(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_9dup(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("dup (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_8dup(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_8dup(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self) {
+  PyObject *__pyx_v_fd = NULL;
+  PyObject *__pyx_v_sock = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("dup", 0);
+
+  /* "uvloop/pseudosock.pyx":70
+ * 
+ *     def dup(self):
+ *         fd = os_dup(self._fd)             # <<<<<<<<<<<<<<
+ *         sock = socket_socket(self._family, self._type, self._proto, fileno=fd)
+ *         sock.settimeout(0)
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_dup);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_os_dup; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_fd = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":71
+ *     def dup(self):
+ *         fd = os_dup(self._fd)
+ *         sock = socket_socket(self._family, self._type, self._proto, fileno=fd)             # <<<<<<<<<<<<<<
+ *         sock.settimeout(0)
+ *         return sock
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_family); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->_proto); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_fileno, __pyx_v_fd) < 0) __PYX_ERR(9, 71, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_socket_socket, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_sock = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/pseudosock.pyx":72
+ *         fd = os_dup(self._fd)
+ *         sock = socket_socket(self._family, self._type, self._proto, fileno=fd)
+ *         sock.settimeout(0)             # <<<<<<<<<<<<<<
+ *         return sock
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_settimeout); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_int_0) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_int_0);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/pseudosock.pyx":73
+ *         sock = socket_socket(self._family, self._type, self._proto, fileno=fd)
+ *         sock.settimeout(0)
+ *         return sock             # <<<<<<<<<<<<<<
+ * 
+ *     def get_inheritable(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_sock);
+  __pyx_r = __pyx_v_sock;
+  goto __pyx_L0;
+
+  /* "uvloop/pseudosock.pyx":69
+ *         return self._fd
+ * 
+ *     def dup(self):             # <<<<<<<<<<<<<<
+ *         fd = os_dup(self._fd)
+ *         sock = socket_socket(self._family, self._type, self._proto, fileno=fd)
+ */
+
+  /* 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_AddTraceback("uvloop.loop.PseudoSocket.dup", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fd);
+  __Pyx_XDECREF(__pyx_v_sock);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":75
+ *         return sock
+ * 
+ *     def get_inheritable(self):             # <<<<<<<<<<<<<<
+ *         return os_get_inheritable(self._fd)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_11get_inheritable(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_10get_inheritable[] = "PseudoSocket.get_inheritable(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_11get_inheritable(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_inheritable (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_10get_inheritable(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_10get_inheritable(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_inheritable", 0);
+
+  /* "uvloop/pseudosock.pyx":76
+ * 
+ *     def get_inheritable(self):
+ *         return os_get_inheritable(self._fd)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_inheritable(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_get_inheritable);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_os_get_inheritable; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/pseudosock.pyx":75
+ *         return sock
+ * 
+ *     def get_inheritable(self):             # <<<<<<<<<<<<<<
+ *         return os_get_inheritable(self._fd)
+ * 
+ */
+
+  /* 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_AddTraceback("uvloop.loop.PseudoSocket.get_inheritable", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":78
+ *         return os_get_inheritable(self._fd)
+ * 
+ *     def set_inheritable(self):             # <<<<<<<<<<<<<<
+ *         os_set_inheritable(self._fd)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_13set_inheritable(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_12set_inheritable[] = "PseudoSocket.set_inheritable(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_13set_inheritable(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_inheritable (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_12set_inheritable(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_12set_inheritable(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_inheritable", 0);
+
+  /* "uvloop/pseudosock.pyx":79
+ * 
+ *     def set_inheritable(self):
+ *         os_set_inheritable(self._fd)             # <<<<<<<<<<<<<<
+ * 
+ *     def ioctl(self, *args, **kwargs):
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_os_set_inheritable; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":78
+ *         return os_get_inheritable(self._fd)
+ * 
+ *     def set_inheritable(self):             # <<<<<<<<<<<<<<
+ *         os_set_inheritable(self._fd)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_AddTraceback("uvloop.loop.PseudoSocket.set_inheritable", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":81
+ *         os_set_inheritable(self._fd)
+ * 
+ *     def ioctl(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_15ioctl(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_14ioctl[] = "PseudoSocket.ioctl(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_15ioctl(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("ioctl (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "ioctl", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_14ioctl(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_14ioctl(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("ioctl", 0);
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":84
+ *         pass
+ * 
+ *     def getsockopt(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         sock = self._make_sock()
+ *         try:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_17getsockopt(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_16getsockopt[] = "PseudoSocket.getsockopt(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_17getsockopt(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_args = 0;
+  PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("getsockopt (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getsockopt", 1))) return NULL;
+  __pyx_v_kwargs = (__pyx_kwds) ? PyDict_Copy(__pyx_kwds) : PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
+  __Pyx_GOTREF(__pyx_v_kwargs);
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_16getsockopt(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_16getsockopt(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) {
+  PyObject *__pyx_v_sock = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  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("getsockopt", 0);
+
+  /* "uvloop/pseudosock.pyx":85
+ * 
+ *     def getsockopt(self, *args, **kwargs):
+ *         sock = self._make_sock()             # <<<<<<<<<<<<<<
+ *         try:
+ *             return sock.getsockopt(*args, **kwargs)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_make_sock(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 85, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_sock = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":86
+ *     def getsockopt(self, *args, **kwargs):
+ *         sock = self._make_sock()
+ *         try:             # <<<<<<<<<<<<<<
+ *             return sock.getsockopt(*args, **kwargs)
+ *         finally:
+ */
+  /*try:*/ {
+
+    /* "uvloop/pseudosock.pyx":87
+ *         sock = self._make_sock()
+ *         try:
+ *             return sock.getsockopt(*args, **kwargs)             # <<<<<<<<<<<<<<
+ *         finally:
+ *             sock.detach()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_getsockopt); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 87, __pyx_L4_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 87, __pyx_L4_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 87, __pyx_L4_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L3_return;
+  }
+
+  /* "uvloop/pseudosock.pyx":89
+ *             return sock.getsockopt(*args, **kwargs)
+ *         finally:
+ *             sock.detach()             # <<<<<<<<<<<<<<
+ * 
+ *     def setsockopt(self, *args, **kwargs):
+ */
+  /*finally:*/ {
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __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_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      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_XGOTREF(__pyx_t_12);
+      __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
+      {
+        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_detach); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 89, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_1 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+          __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+          if (likely(__pyx_t_1)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+            __Pyx_INCREF(__pyx_t_1);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_2, function);
+          }
+        }
+        __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 89, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+      }
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __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_L7_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+      }
+      __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;
+      __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L3_return: {
+      __pyx_t_12 = __pyx_r;
+      __pyx_r = 0;
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_detach); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 89, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_1 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+        if (likely(__pyx_t_1)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+          __Pyx_INCREF(__pyx_t_1);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_2, function);
+        }
+      }
+      __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 89, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_r = __pyx_t_12;
+      __pyx_t_12 = 0;
+      goto __pyx_L0;
+    }
+  }
+
+  /* "uvloop/pseudosock.pyx":84
+ *         pass
+ * 
+ *     def getsockopt(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         sock = self._make_sock()
+ *         try:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.getsockopt", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sock);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":91
+ *             sock.detach()
+ * 
+ *     def setsockopt(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         sock = self._make_sock()
+ *         try:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_19setsockopt(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_18setsockopt[] = "PseudoSocket.setsockopt(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_19setsockopt(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_args = 0;
+  PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("setsockopt (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setsockopt", 1))) return NULL;
+  __pyx_v_kwargs = (__pyx_kwds) ? PyDict_Copy(__pyx_kwds) : PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
+  __Pyx_GOTREF(__pyx_v_kwargs);
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_18setsockopt(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_18setsockopt(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) {
+  PyObject *__pyx_v_sock = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  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("setsockopt", 0);
+
+  /* "uvloop/pseudosock.pyx":92
+ * 
+ *     def setsockopt(self, *args, **kwargs):
+ *         sock = self._make_sock()             # <<<<<<<<<<<<<<
+ *         try:
+ *             return sock.setsockopt(*args, **kwargs)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_make_sock(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 92, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_sock = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":93
+ *     def setsockopt(self, *args, **kwargs):
+ *         sock = self._make_sock()
+ *         try:             # <<<<<<<<<<<<<<
+ *             return sock.setsockopt(*args, **kwargs)
+ *         finally:
+ */
+  /*try:*/ {
+
+    /* "uvloop/pseudosock.pyx":94
+ *         sock = self._make_sock()
+ *         try:
+ *             return sock.setsockopt(*args, **kwargs)             # <<<<<<<<<<<<<<
+ *         finally:
+ *             sock.detach()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_setsockopt); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 94, __pyx_L4_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 94, __pyx_L4_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 94, __pyx_L4_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L3_return;
+  }
+
+  /* "uvloop/pseudosock.pyx":96
+ *             return sock.setsockopt(*args, **kwargs)
+ *         finally:
+ *             sock.detach()             # <<<<<<<<<<<<<<
+ * 
+ *     def getpeername(self):
+ */
+  /*finally:*/ {
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __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_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      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_XGOTREF(__pyx_t_12);
+      __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
+      {
+        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_detach); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 96, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_1 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+          __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+          if (likely(__pyx_t_1)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+            __Pyx_INCREF(__pyx_t_1);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_2, function);
+          }
+        }
+        __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 96, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+      }
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __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_L7_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+      }
+      __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;
+      __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L3_return: {
+      __pyx_t_12 = __pyx_r;
+      __pyx_r = 0;
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_detach); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 96, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_1 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+        if (likely(__pyx_t_1)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+          __Pyx_INCREF(__pyx_t_1);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_2, function);
+        }
+      }
+      __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 96, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_r = __pyx_t_12;
+      __pyx_t_12 = 0;
+      goto __pyx_L0;
+    }
+  }
+
+  /* "uvloop/pseudosock.pyx":91
+ *             sock.detach()
+ * 
+ *     def setsockopt(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         sock = self._make_sock()
+ *         try:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.setsockopt", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sock);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":98
+ *             sock.detach()
+ * 
+ *     def getpeername(self):             # <<<<<<<<<<<<<<
+ *         if self._peername is not None:
+ *             return self._peername
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_21getpeername(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_20getpeername[] = "PseudoSocket.getpeername(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_21getpeername(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("getpeername (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_20getpeername(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_20getpeername(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self) {
+  PyObject *__pyx_v_sock = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  char const *__pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("getpeername", 0);
+
+  /* "uvloop/pseudosock.pyx":99
+ * 
+ *     def getpeername(self):
+ *         if self._peername is not None:             # <<<<<<<<<<<<<<
+ *             return self._peername
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->_peername != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/pseudosock.pyx":100
+ *     def getpeername(self):
+ *         if self._peername is not None:
+ *             return self._peername             # <<<<<<<<<<<<<<
+ * 
+ *         sock = self._make_sock()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_self->_peername);
+    __pyx_r = __pyx_v_self->_peername;
+    goto __pyx_L0;
+
+    /* "uvloop/pseudosock.pyx":99
+ * 
+ *     def getpeername(self):
+ *         if self._peername is not None:             # <<<<<<<<<<<<<<
+ *             return self._peername
+ * 
+ */
+  }
+
+  /* "uvloop/pseudosock.pyx":102
+ *             return self._peername
+ * 
+ *         sock = self._make_sock()             # <<<<<<<<<<<<<<
+ *         try:
+ *             self._peername = sock.getpeername()
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_make_sock(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_v_sock = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/pseudosock.pyx":103
+ * 
+ *         sock = self._make_sock()
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._peername = sock.getpeername()
+ *             return self._peername
+ */
+  /*try:*/ {
+
+    /* "uvloop/pseudosock.pyx":104
+ *         sock = self._make_sock()
+ *         try:
+ *             self._peername = sock.getpeername()             # <<<<<<<<<<<<<<
+ *             return self._peername
+ *         finally:
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_getpeername); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 104, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 104, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GIVEREF(__pyx_t_3);
+    __Pyx_GOTREF(__pyx_v_self->_peername);
+    __Pyx_DECREF(__pyx_v_self->_peername);
+    __pyx_v_self->_peername = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/pseudosock.pyx":105
+ *         try:
+ *             self._peername = sock.getpeername()
+ *             return self._peername             # <<<<<<<<<<<<<<
+ *         finally:
+ *             sock.detach()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_self->_peername);
+    __pyx_r = __pyx_v_self->_peername;
+    goto __pyx_L4_return;
+  }
+
+  /* "uvloop/pseudosock.pyx":107
+ *             return self._peername
+ *         finally:
+ *             sock.detach()             # <<<<<<<<<<<<<<
+ * 
+ *     def getsockname(self):
+ */
+  /*finally:*/ {
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __pyx_t_6 = __pyx_lineno; __pyx_t_7 = __pyx_clineno; __pyx_t_8 = __pyx_filename;
+      {
+        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_detach); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 107, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_5 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 107, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __Pyx_ErrRestore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_7; __pyx_filename = __pyx_t_8;
+      goto __pyx_L1_error;
+      __pyx_L8_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L4_return: {
+      __pyx_t_14 = __pyx_r;
+      __pyx_r = 0;
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_detach); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 107, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 107, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_r = __pyx_t_14;
+      __pyx_t_14 = 0;
+      goto __pyx_L0;
+    }
+  }
+
+  /* "uvloop/pseudosock.pyx":98
+ *             sock.detach()
+ * 
+ *     def getpeername(self):             # <<<<<<<<<<<<<<
+ *         if self._peername is not None:
+ *             return self._peername
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.getpeername", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sock);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":109
+ *             sock.detach()
+ * 
+ *     def getsockname(self):             # <<<<<<<<<<<<<<
+ *         if self._sockname is not None:
+ *             return self._sockname
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_23getsockname(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_22getsockname[] = "PseudoSocket.getsockname(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_23getsockname(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("getsockname (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_22getsockname(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_22getsockname(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self) {
+  PyObject *__pyx_v_sock = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  char const *__pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("getsockname", 0);
+
+  /* "uvloop/pseudosock.pyx":110
+ * 
+ *     def getsockname(self):
+ *         if self._sockname is not None:             # <<<<<<<<<<<<<<
+ *             return self._sockname
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->_sockname != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/pseudosock.pyx":111
+ *     def getsockname(self):
+ *         if self._sockname is not None:
+ *             return self._sockname             # <<<<<<<<<<<<<<
+ * 
+ *         sock = self._make_sock()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_self->_sockname);
+    __pyx_r = __pyx_v_self->_sockname;
+    goto __pyx_L0;
+
+    /* "uvloop/pseudosock.pyx":110
+ * 
+ *     def getsockname(self):
+ *         if self._sockname is not None:             # <<<<<<<<<<<<<<
+ *             return self._sockname
+ * 
+ */
+  }
+
+  /* "uvloop/pseudosock.pyx":113
+ *             return self._sockname
+ * 
+ *         sock = self._make_sock()             # <<<<<<<<<<<<<<
+ *         try:
+ *             self._sockname = sock.getsockname()
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_make_sock(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_v_sock = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/pseudosock.pyx":114
+ * 
+ *         sock = self._make_sock()
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._sockname = sock.getsockname()
+ *             return self._sockname
+ */
+  /*try:*/ {
+
+    /* "uvloop/pseudosock.pyx":115
+ *         sock = self._make_sock()
+ *         try:
+ *             self._sockname = sock.getsockname()             # <<<<<<<<<<<<<<
+ *             return self._sockname
+ *         finally:
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_getsockname); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 115, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 115, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GIVEREF(__pyx_t_3);
+    __Pyx_GOTREF(__pyx_v_self->_sockname);
+    __Pyx_DECREF(__pyx_v_self->_sockname);
+    __pyx_v_self->_sockname = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/pseudosock.pyx":116
+ *         try:
+ *             self._sockname = sock.getsockname()
+ *             return self._sockname             # <<<<<<<<<<<<<<
+ *         finally:
+ *             sock.detach()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_self->_sockname);
+    __pyx_r = __pyx_v_self->_sockname;
+    goto __pyx_L4_return;
+  }
+
+  /* "uvloop/pseudosock.pyx":118
+ *             return self._sockname
+ *         finally:
+ *             sock.detach()             # <<<<<<<<<<<<<<
+ * 
+ *     def share(self, process_id):
+ */
+  /*finally:*/ {
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __pyx_t_6 = __pyx_lineno; __pyx_t_7 = __pyx_clineno; __pyx_t_8 = __pyx_filename;
+      {
+        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_detach); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 118, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_5 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 118, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __Pyx_ErrRestore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_7; __pyx_filename = __pyx_t_8;
+      goto __pyx_L1_error;
+      __pyx_L8_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L4_return: {
+      __pyx_t_14 = __pyx_r;
+      __pyx_r = 0;
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_detach); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 118, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 118, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_r = __pyx_t_14;
+      __pyx_t_14 = 0;
+      goto __pyx_L0;
+    }
+  }
+
+  /* "uvloop/pseudosock.pyx":109
+ *             sock.detach()
+ * 
+ *     def getsockname(self):             # <<<<<<<<<<<<<<
+ *         if self._sockname is not None:
+ *             return self._sockname
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.getsockname", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sock);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":120
+ *             sock.detach()
+ * 
+ *     def share(self, process_id):             # <<<<<<<<<<<<<<
+ *         sock = self._make_sock()
+ *         try:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_25share(PyObject *__pyx_v_self, PyObject *__pyx_v_process_id); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_24share[] = "PseudoSocket.share(self, process_id)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_25share(PyObject *__pyx_v_self, PyObject *__pyx_v_process_id) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("share (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_24share(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), ((PyObject *)__pyx_v_process_id));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_24share(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_process_id) {
+  PyObject *__pyx_v_sock = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  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("share", 0);
+
+  /* "uvloop/pseudosock.pyx":121
+ * 
+ *     def share(self, process_id):
+ *         sock = self._make_sock()             # <<<<<<<<<<<<<<
+ *         try:
+ *             return sock.share(process_id)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_make_sock(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_sock = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":122
+ *     def share(self, process_id):
+ *         sock = self._make_sock()
+ *         try:             # <<<<<<<<<<<<<<
+ *             return sock.share(process_id)
+ *         finally:
+ */
+  /*try:*/ {
+
+    /* "uvloop/pseudosock.pyx":123
+ *         sock = self._make_sock()
+ *         try:
+ *             return sock.share(process_id)             # <<<<<<<<<<<<<<
+ *         finally:
+ *             sock.detach()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_share); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 123, __pyx_L4_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_process_id) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_process_id);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 123, __pyx_L4_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_L3_return;
+  }
+
+  /* "uvloop/pseudosock.pyx":125
+ *             return sock.share(process_id)
+ *         finally:
+ *             sock.detach()             # <<<<<<<<<<<<<<
+ * 
+ *     def accept(self):
+ */
+  /*finally:*/ {
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __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_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      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_XGOTREF(__pyx_t_12);
+      __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
+      {
+        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_detach); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 125, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_3 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_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(9, 125, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+      }
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __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_L7_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+      }
+      __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;
+      __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L3_return: {
+      __pyx_t_12 = __pyx_r;
+      __pyx_r = 0;
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_detach); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 125, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_3 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_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(9, 125, __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;
+      __pyx_r = __pyx_t_12;
+      __pyx_t_12 = 0;
+      goto __pyx_L0;
+    }
+  }
+
+  /* "uvloop/pseudosock.pyx":120
+ *             sock.detach()
+ * 
+ *     def share(self, process_id):             # <<<<<<<<<<<<<<
+ *         sock = self._make_sock()
+ *         try:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.share", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sock);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":127
+ *             sock.detach()
+ * 
+ *     def accept(self):             # <<<<<<<<<<<<<<
+ *         self._na('accept() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_27accept(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_26accept[] = "PseudoSocket.accept(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_27accept(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("accept (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_26accept(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_26accept(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__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("accept", 0);
+
+  /* "uvloop/pseudosock.pyx":128
+ * 
+ *     def accept(self):
+ *         self._na('accept() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def connect(self, *args):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_accept_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":127
+ *             sock.detach()
+ * 
+ *     def accept(self):             # <<<<<<<<<<<<<<
+ *         self._na('accept() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.accept", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":130
+ *         self._na('accept() method')
+ * 
+ *     def connect(self, *args):             # <<<<<<<<<<<<<<
+ *         self._na('connect() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_29connect(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_28connect[] = "PseudoSocket.connect(self, *args)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_29connect(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connect (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "connect", 0))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_28connect(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_28connect(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args) {
+  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("connect", 0);
+
+  /* "uvloop/pseudosock.pyx":131
+ * 
+ *     def connect(self, *args):
+ *         self._na('connect() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def connect_ex(self, *args):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_connect_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":130
+ *         self._na('accept() method')
+ * 
+ *     def connect(self, *args):             # <<<<<<<<<<<<<<
+ *         self._na('connect() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":133
+ *         self._na('connect() method')
+ * 
+ *     def connect_ex(self, *args):             # <<<<<<<<<<<<<<
+ *         self._na('connect_ex() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_31connect_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_30connect_ex[] = "PseudoSocket.connect_ex(self, *args)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_31connect_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connect_ex (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "connect_ex", 0))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_30connect_ex(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_30connect_ex(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args) {
+  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("connect_ex", 0);
+
+  /* "uvloop/pseudosock.pyx":134
+ * 
+ *     def connect_ex(self, *args):
+ *         self._na('connect_ex() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def bind(self, *args):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_connect_ex_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":133
+ *         self._na('connect() method')
+ * 
+ *     def connect_ex(self, *args):             # <<<<<<<<<<<<<<
+ *         self._na('connect_ex() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.connect_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":136
+ *         self._na('connect_ex() method')
+ * 
+ *     def bind(self, *args):             # <<<<<<<<<<<<<<
+ *         self._na('bind() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_33bind(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_32bind[] = "PseudoSocket.bind(self, *args)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_33bind(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("bind (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "bind", 0))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_32bind(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_32bind(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args) {
+  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("bind", 0);
+
+  /* "uvloop/pseudosock.pyx":137
+ * 
+ *     def bind(self, *args):
+ *         self._na('bind() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def listen(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_bind_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":136
+ *         self._na('connect_ex() method')
+ * 
+ *     def bind(self, *args):             # <<<<<<<<<<<<<<
+ *         self._na('bind() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.bind", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":139
+ *         self._na('bind() method')
+ * 
+ *     def listen(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('listen() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_35listen(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_34listen[] = "PseudoSocket.listen(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_35listen(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("listen (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "listen", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_34listen(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_34listen(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("listen", 0);
+
+  /* "uvloop/pseudosock.pyx":140
+ * 
+ *     def listen(self, *args, **kwargs):
+ *         self._na('listen() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def makefile(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_listen_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 140, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":139
+ *         self._na('bind() method')
+ * 
+ *     def listen(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('listen() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.listen", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":142
+ *         self._na('listen() method')
+ * 
+ *     def makefile(self):             # <<<<<<<<<<<<<<
+ *         self._na('makefile() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_37makefile(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_36makefile[] = "PseudoSocket.makefile(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_37makefile(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("makefile (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_36makefile(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_36makefile(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__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("makefile", 0);
+
+  /* "uvloop/pseudosock.pyx":143
+ * 
+ *     def makefile(self):
+ *         self._na('makefile() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def sendfile(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_makefile_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":142
+ *         self._na('listen() method')
+ * 
+ *     def makefile(self):             # <<<<<<<<<<<<<<
+ *         self._na('makefile() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.makefile", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":145
+ *         self._na('makefile() method')
+ * 
+ *     def sendfile(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('sendfile() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_39sendfile(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_38sendfile[] = "PseudoSocket.sendfile(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_39sendfile(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sendfile (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "sendfile", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_38sendfile(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_38sendfile(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("sendfile", 0);
+
+  /* "uvloop/pseudosock.pyx":146
+ * 
+ *     def sendfile(self, *args, **kwargs):
+ *         self._na('sendfile() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def close(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_sendfile_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":145
+ *         self._na('makefile() method')
+ * 
+ *     def sendfile(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('sendfile() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.sendfile", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":148
+ *         self._na('sendfile() method')
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         self._na('close() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_41close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_40close[] = "PseudoSocket.close(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_41close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("close (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_40close(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_40close(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__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("close", 0);
+
+  /* "uvloop/pseudosock.pyx":149
+ * 
+ *     def close(self):
+ *         self._na('close() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def detach(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_close_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":148
+ *         self._na('sendfile() method')
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         self._na('close() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":151
+ *         self._na('close() method')
+ * 
+ *     def detach(self):             # <<<<<<<<<<<<<<
+ *         self._na('detach() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_43detach(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_42detach[] = "PseudoSocket.detach(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_43detach(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("detach (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_42detach(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_42detach(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__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("detach", 0);
+
+  /* "uvloop/pseudosock.pyx":152
+ * 
+ *     def detach(self):
+ *         self._na('detach() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def shutdown(self, *args):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_detach_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":151
+ *         self._na('close() method')
+ * 
+ *     def detach(self):             # <<<<<<<<<<<<<<
+ *         self._na('detach() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.detach", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":154
+ *         self._na('detach() method')
+ * 
+ *     def shutdown(self, *args):             # <<<<<<<<<<<<<<
+ *         self._na('shutdown() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_45shutdown(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_44shutdown[] = "PseudoSocket.shutdown(self, *args)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_45shutdown(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("shutdown (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "shutdown", 0))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_44shutdown(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_44shutdown(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args) {
+  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("shutdown", 0);
+
+  /* "uvloop/pseudosock.pyx":155
+ * 
+ *     def shutdown(self, *args):
+ *         self._na('shutdown() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def sendmsg_afalg(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_shutdown_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":154
+ *         self._na('detach() method')
+ * 
+ *     def shutdown(self, *args):             # <<<<<<<<<<<<<<
+ *         self._na('shutdown() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":157
+ *         self._na('shutdown() method')
+ * 
+ *     def sendmsg_afalg(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('sendmsg_afalg() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_47sendmsg_afalg(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_46sendmsg_afalg[] = "PseudoSocket.sendmsg_afalg(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_47sendmsg_afalg(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sendmsg_afalg (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "sendmsg_afalg", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_46sendmsg_afalg(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_46sendmsg_afalg(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("sendmsg_afalg", 0);
+
+  /* "uvloop/pseudosock.pyx":158
+ * 
+ *     def sendmsg_afalg(self, *args, **kwargs):
+ *         self._na('sendmsg_afalg() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def sendmsg(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_sendmsg_afalg_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":157
+ *         self._na('shutdown() method')
+ * 
+ *     def sendmsg_afalg(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('sendmsg_afalg() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.sendmsg_afalg", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":160
+ *         self._na('sendmsg_afalg() method')
+ * 
+ *     def sendmsg(self):             # <<<<<<<<<<<<<<
+ *         self._na('sendmsg() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_49sendmsg(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_48sendmsg[] = "PseudoSocket.sendmsg(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_49sendmsg(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sendmsg (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_48sendmsg(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_48sendmsg(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__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("sendmsg", 0);
+
+  /* "uvloop/pseudosock.pyx":161
+ * 
+ *     def sendmsg(self):
+ *         self._na('sendmsg() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def sendto(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_sendmsg_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":160
+ *         self._na('sendmsg_afalg() method')
+ * 
+ *     def sendmsg(self):             # <<<<<<<<<<<<<<
+ *         self._na('sendmsg() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.sendmsg", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":163
+ *         self._na('sendmsg() method')
+ * 
+ *     def sendto(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('sendto() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_51sendto(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_50sendto[] = "PseudoSocket.sendto(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_51sendto(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sendto (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "sendto", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_50sendto(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_50sendto(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("sendto", 0);
+
+  /* "uvloop/pseudosock.pyx":164
+ * 
+ *     def sendto(self, *args, **kwargs):
+ *         self._na('sendto() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def send(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_sendto_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":163
+ *         self._na('sendmsg() method')
+ * 
+ *     def sendto(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('sendto() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.sendto", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":166
+ *         self._na('sendto() method')
+ * 
+ *     def send(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('send() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_53send(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_52send[] = "PseudoSocket.send(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_53send(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("send (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "send", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_52send(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_52send(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("send", 0);
+
+  /* "uvloop/pseudosock.pyx":167
+ * 
+ *     def send(self, *args, **kwargs):
+ *         self._na('send() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def sendall(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_send_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":166
+ *         self._na('sendto() method')
+ * 
+ *     def send(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('send() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.send", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":169
+ *         self._na('send() method')
+ * 
+ *     def sendall(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('sendall() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_55sendall(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_54sendall[] = "PseudoSocket.sendall(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_55sendall(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sendall (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "sendall", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_54sendall(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_54sendall(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("sendall", 0);
+
+  /* "uvloop/pseudosock.pyx":170
+ * 
+ *     def sendall(self, *args, **kwargs):
+ *         self._na('sendall() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def recv_into(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_sendall_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":169
+ *         self._na('send() method')
+ * 
+ *     def sendall(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('sendall() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":172
+ *         self._na('sendall() method')
+ * 
+ *     def recv_into(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recv_into() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_57recv_into(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_56recv_into[] = "PseudoSocket.recv_into(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_57recv_into(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("recv_into (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "recv_into", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_56recv_into(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_56recv_into(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("recv_into", 0);
+
+  /* "uvloop/pseudosock.pyx":173
+ * 
+ *     def recv_into(self, *args, **kwargs):
+ *         self._na('recv_into() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def recvfrom_into(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_recv_into_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":172
+ *         self._na('sendall() method')
+ * 
+ *     def recv_into(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recv_into() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.recv_into", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":175
+ *         self._na('recv_into() method')
+ * 
+ *     def recvfrom_into(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recvfrom_into() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_59recvfrom_into(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_58recvfrom_into[] = "PseudoSocket.recvfrom_into(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_59recvfrom_into(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("recvfrom_into (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "recvfrom_into", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_58recvfrom_into(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_58recvfrom_into(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("recvfrom_into", 0);
+
+  /* "uvloop/pseudosock.pyx":176
+ * 
+ *     def recvfrom_into(self, *args, **kwargs):
+ *         self._na('recvfrom_into() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def recvmsg_into(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_recvfrom_into_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":175
+ *         self._na('recv_into() method')
+ * 
+ *     def recvfrom_into(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recvfrom_into() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.recvfrom_into", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":178
+ *         self._na('recvfrom_into() method')
+ * 
+ *     def recvmsg_into(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recvmsg_into() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_61recvmsg_into(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_60recvmsg_into[] = "PseudoSocket.recvmsg_into(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_61recvmsg_into(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("recvmsg_into (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "recvmsg_into", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_60recvmsg_into(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_60recvmsg_into(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("recvmsg_into", 0);
+
+  /* "uvloop/pseudosock.pyx":179
+ * 
+ *     def recvmsg_into(self, *args, **kwargs):
+ *         self._na('recvmsg_into() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def recvmsg(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_recvmsg_into_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":178
+ *         self._na('recvfrom_into() method')
+ * 
+ *     def recvmsg_into(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recvmsg_into() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.recvmsg_into", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":181
+ *         self._na('recvmsg_into() method')
+ * 
+ *     def recvmsg(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recvmsg() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_63recvmsg(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_62recvmsg[] = "PseudoSocket.recvmsg(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_63recvmsg(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("recvmsg (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "recvmsg", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_62recvmsg(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_62recvmsg(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("recvmsg", 0);
+
+  /* "uvloop/pseudosock.pyx":182
+ * 
+ *     def recvmsg(self, *args, **kwargs):
+ *         self._na('recvmsg() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def recvfrom(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_recvmsg_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":181
+ *         self._na('recvmsg_into() method')
+ * 
+ *     def recvmsg(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recvmsg() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.recvmsg", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":184
+ *         self._na('recvmsg() method')
+ * 
+ *     def recvfrom(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recvfrom() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_65recvfrom(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_64recvfrom[] = "PseudoSocket.recvfrom(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_65recvfrom(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("recvfrom (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "recvfrom", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_64recvfrom(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_64recvfrom(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("recvfrom", 0);
+
+  /* "uvloop/pseudosock.pyx":185
+ * 
+ *     def recvfrom(self, *args, **kwargs):
+ *         self._na('recvfrom() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def recv(self, *args, **kwargs):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_recvfrom_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 185, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":184
+ *         self._na('recvmsg() method')
+ * 
+ *     def recvfrom(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recvfrom() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.recvfrom", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":187
+ *         self._na('recvfrom() method')
+ * 
+ *     def recv(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recv() method')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_67recv(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_66recv[] = "PseudoSocket.recv(self, *args, **kwargs)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_67recv(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("recv (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "recv", 1))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_66recv(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_66recv(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  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("recv", 0);
+
+  /* "uvloop/pseudosock.pyx":188
+ * 
+ *     def recv(self, *args, **kwargs):
+ *         self._na('recv() method')             # <<<<<<<<<<<<<<
+ * 
+ *     def settimeout(self, value):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_recv_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":187
+ *         self._na('recvfrom() method')
+ * 
+ *     def recv(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._na('recv() method')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":190
+ *         self._na('recv() method')
+ * 
+ *     def settimeout(self, value):             # <<<<<<<<<<<<<<
+ *         if value == 0:
+ *             return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_69settimeout(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_68settimeout[] = "PseudoSocket.settimeout(self, value)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_69settimeout(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("settimeout (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_68settimeout(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), ((PyObject *)__pyx_v_value));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_68settimeout(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_value) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("settimeout", 0);
+
+  /* "uvloop/pseudosock.pyx":191
+ * 
+ *     def settimeout(self, value):
+ *         if value == 0:             # <<<<<<<<<<<<<<
+ *             return
+ *         raise ValueError(
+ */
+  __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_value, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 191, __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(9, 191, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_2) {
+
+    /* "uvloop/pseudosock.pyx":192
+ *     def settimeout(self, value):
+ *         if value == 0:
+ *             return             # <<<<<<<<<<<<<<
+ *         raise ValueError(
+ *             'settimeout(): only 0 timeout is allowed on transport sockets')
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/pseudosock.pyx":191
+ * 
+ *     def settimeout(self, value):
+ *         if value == 0:             # <<<<<<<<<<<<<<
+ *             return
+ *         raise ValueError(
+ */
+  }
+
+  /* "uvloop/pseudosock.pyx":193
+ *         if value == 0:
+ *             return
+ *         raise ValueError(             # <<<<<<<<<<<<<<
+ *             'settimeout(): only 0 timeout is allowed on transport sockets')
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__113, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 193, __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(9, 193, __pyx_L1_error)
+
+  /* "uvloop/pseudosock.pyx":190
+ *         self._na('recv() method')
+ * 
+ *     def settimeout(self, value):             # <<<<<<<<<<<<<<
+ *         if value == 0:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.settimeout", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":196
+ *             'settimeout(): only 0 timeout is allowed on transport sockets')
+ * 
+ *     def gettimeout(self):             # <<<<<<<<<<<<<<
+ *         return 0
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_71gettimeout(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_70gettimeout[] = "PseudoSocket.gettimeout(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_71gettimeout(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("gettimeout (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_70gettimeout(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_70gettimeout(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("gettimeout", 0);
+
+  /* "uvloop/pseudosock.pyx":197
+ * 
+ *     def gettimeout(self):
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ *     def setblocking(self, flag):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_int_0);
+  __pyx_r = __pyx_int_0;
+  goto __pyx_L0;
+
+  /* "uvloop/pseudosock.pyx":196
+ *             'settimeout(): only 0 timeout is allowed on transport sockets')
+ * 
+ *     def gettimeout(self):             # <<<<<<<<<<<<<<
+ *         return 0
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":199
+ *         return 0
+ * 
+ *     def setblocking(self, flag):             # <<<<<<<<<<<<<<
+ *         if not flag:
+ *             return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_73setblocking(PyObject *__pyx_v_self, PyObject *__pyx_v_flag); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_72setblocking[] = "PseudoSocket.setblocking(self, flag)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_73setblocking(PyObject *__pyx_v_self, PyObject *__pyx_v_flag) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("setblocking (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_72setblocking(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), ((PyObject *)__pyx_v_flag));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_72setblocking(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, PyObject *__pyx_v_flag) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("setblocking", 0);
+
+  /* "uvloop/pseudosock.pyx":200
+ * 
+ *     def setblocking(self, flag):
+ *         if not flag:             # <<<<<<<<<<<<<<
+ *             return
+ *         raise ValueError(
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_flag); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(9, 200, __pyx_L1_error)
+  __pyx_t_2 = ((!__pyx_t_1) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/pseudosock.pyx":201
+ *     def setblocking(self, flag):
+ *         if not flag:
+ *             return             # <<<<<<<<<<<<<<
+ *         raise ValueError(
+ *             'setblocking(): transport sockets cannot be blocking')
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/pseudosock.pyx":200
+ * 
+ *     def setblocking(self, flag):
+ *         if not flag:             # <<<<<<<<<<<<<<
+ *             return
+ *         raise ValueError(
+ */
+  }
+
+  /* "uvloop/pseudosock.pyx":202
+ *         if not flag:
+ *             return
+ *         raise ValueError(             # <<<<<<<<<<<<<<
+ *             'setblocking(): transport sockets cannot be blocking')
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__114, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __PYX_ERR(9, 202, __pyx_L1_error)
+
+  /* "uvloop/pseudosock.pyx":199
+ *         return 0
+ * 
+ *     def setblocking(self, flag):             # <<<<<<<<<<<<<<
+ *         if not flag:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.setblocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":205
+ *             'setblocking(): transport sockets cannot be blocking')
+ * 
+ *     def __enter__(self):             # <<<<<<<<<<<<<<
+ *         self._na('context manager protocol')
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_75__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_74__enter__[] = "PseudoSocket.__enter__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_75__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_74__enter__(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_74__enter__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__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("__enter__", 0);
+
+  /* "uvloop/pseudosock.pyx":206
+ * 
+ *     def __enter__(self):
+ *         self._na('context manager protocol')             # <<<<<<<<<<<<<<
+ * 
+ *     def __exit__(self, *err):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_context_manager_protocol); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":205
+ *             'setblocking(): transport sockets cannot be blocking')
+ * 
+ *     def __enter__(self):             # <<<<<<<<<<<<<<
+ *         self._na('context manager protocol')
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.__enter__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/pseudosock.pyx":208
+ *         self._na('context manager protocol')
+ * 
+ *     def __exit__(self, *err):             # <<<<<<<<<<<<<<
+ *         self._na('context manager protocol')
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_77__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_76__exit__[] = "PseudoSocket.__exit__(self, *err)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_77__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_err = 0;
+  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;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_err = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12PseudoSocket_76__exit__(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), __pyx_v_err);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_err);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_76__exit__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_err) {
+  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("__exit__", 0);
+
+  /* "uvloop/pseudosock.pyx":209
+ * 
+ *     def __exit__(self, *err):
+ *         self._na('context manager protocol')             # <<<<<<<<<<<<<<
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx_vtab)->_na(__pyx_v_self, __pyx_kp_u_context_manager_protocol); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/pseudosock.pyx":208
+ *         self._na('context manager protocol')
+ * 
+ *     def __exit__(self, *err):             # <<<<<<<<<<<<<<
+ *         self._na('context manager protocol')
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_79__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_78__reduce_cython__[] = "PseudoSocket.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_79__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_6uvloop_4loop_12PseudoSocket_78__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_78__reduce_cython__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self) {
+  PyObject *__pyx_v_state = 0;
+  PyObject *__pyx_v__dict = 0;
+  int __pyx_v_use_setstate;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_t_6;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+
+  /* "(tree fragment)":5
+ *     cdef object _dict
+ *     cdef bint use_setstate
+ *     state = (self._family, self._fd, self._peername, self._proto, self._sockname, self._type)             # <<<<<<<<<<<<<<
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_family); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->_proto); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_self->_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(7, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(6); if (unlikely(!__pyx_t_5)) __PYX_ERR(7, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2);
+  __Pyx_INCREF(__pyx_v_self->_peername);
+  __Pyx_GIVEREF(__pyx_v_self->_peername);
+  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_self->_peername);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_3);
+  __Pyx_INCREF(__pyx_v_self->_sockname);
+  __Pyx_GIVEREF(__pyx_v_self->_sockname);
+  PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_v_self->_sockname);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 5, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_v_state = ((PyObject*)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "(tree fragment)":6
+ *     cdef bint use_setstate
+ *     state = (self._family, self._fd, self._peername, self._proto, self._sockname, self._type)
+ *     _dict = getattr(self, '__dict__', None)             # <<<<<<<<<<<<<<
+ *     if _dict is not None:
+ *         state += (_dict,)
+ */
+  __pyx_t_5 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(7, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_v__dict = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+  /* "(tree fragment)":7
+ *     state = (self._family, self._fd, self._peername, self._proto, self._sockname, self._type)
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:             # <<<<<<<<<<<<<<
+ *         state += (_dict,)
+ *         use_setstate = True
+ */
+  __pyx_t_6 = (__pyx_v__dict != Py_None);
+  __pyx_t_7 = (__pyx_t_6 != 0);
+  if (__pyx_t_7) {
+
+    /* "(tree fragment)":8
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:
+ *         state += (_dict,)             # <<<<<<<<<<<<<<
+ *         use_setstate = True
+ *     else:
+ */
+    __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(7, 8, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_v__dict);
+    __Pyx_GIVEREF(__pyx_v__dict);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v__dict);
+    __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(7, 8, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4));
+    __pyx_t_4 = 0;
+
+    /* "(tree fragment)":9
+ *     if _dict is not None:
+ *         state += (_dict,)
+ *         use_setstate = True             # <<<<<<<<<<<<<<
+ *     else:
+ *         use_setstate = self._peername is not None or self._sockname is not None
+ */
+    __pyx_v_use_setstate = 1;
+
+    /* "(tree fragment)":7
+ *     state = (self._family, self._fd, self._peername, self._proto, self._sockname, self._type)
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:             # <<<<<<<<<<<<<<
+ *         state += (_dict,)
+ *         use_setstate = True
+ */
+    goto __pyx_L3;
+  }
+
+  /* "(tree fragment)":11
+ *         use_setstate = True
+ *     else:
+ *         use_setstate = self._peername is not None or self._sockname is not None             # <<<<<<<<<<<<<<
+ *     if use_setstate:
+ *         return __pyx_unpickle_PseudoSocket, (type(self), 0x88c0b03, None), state
+ */
+  /*else*/ {
+    __pyx_t_6 = (__pyx_v_self->_peername != Py_None);
+    __pyx_t_8 = (__pyx_t_6 != 0);
+    if (!__pyx_t_8) {
+    } else {
+      __pyx_t_7 = __pyx_t_8;
+      goto __pyx_L4_bool_binop_done;
+    }
+    __pyx_t_8 = (__pyx_v_self->_sockname != Py_None);
+    __pyx_t_6 = (__pyx_t_8 != 0);
+    __pyx_t_7 = __pyx_t_6;
+    __pyx_L4_bool_binop_done:;
+    __pyx_v_use_setstate = __pyx_t_7;
+  }
+  __pyx_L3:;
+
+  /* "(tree fragment)":12
+ *     else:
+ *         use_setstate = self._peername is not None or self._sockname is not None
+ *     if use_setstate:             # <<<<<<<<<<<<<<
+ *         return __pyx_unpickle_PseudoSocket, (type(self), 0x88c0b03, None), state
+ *     else:
+ */
+  __pyx_t_7 = (__pyx_v_use_setstate != 0);
+  if (__pyx_t_7) {
+
+    /* "(tree fragment)":13
+ *         use_setstate = self._peername is not None or self._sockname is not None
+ *     if use_setstate:
+ *         return __pyx_unpickle_PseudoSocket, (type(self), 0x88c0b03, None), state             # <<<<<<<<<<<<<<
+ *     else:
+ *         return __pyx_unpickle_PseudoSocket, (type(self), 0x88c0b03, state)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PseudoSocket); if (unlikely(!__pyx_t_4)) __PYX_ERR(7, 13, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(7, 13, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_INCREF(__pyx_int_143395587);
+    __Pyx_GIVEREF(__pyx_int_143395587);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_143395587);
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    PyTuple_SET_ITEM(__pyx_t_5, 2, Py_None);
+    __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 13, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5);
+    __Pyx_INCREF(__pyx_v_state);
+    __Pyx_GIVEREF(__pyx_v_state);
+    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+
+    /* "(tree fragment)":12
+ *     else:
+ *         use_setstate = self._peername is not None or self._sockname is not None
+ *     if use_setstate:             # <<<<<<<<<<<<<<
+ *         return __pyx_unpickle_PseudoSocket, (type(self), 0x88c0b03, None), state
+ *     else:
+ */
+  }
+
+  /* "(tree fragment)":15
+ *         return __pyx_unpickle_PseudoSocket, (type(self), 0x88c0b03, None), state
+ *     else:
+ *         return __pyx_unpickle_PseudoSocket, (type(self), 0x88c0b03, state)             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     __pyx_unpickle_PseudoSocket__set_state(self, __pyx_state)
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PseudoSocket); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(7, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_INCREF(__pyx_int_143395587);
+    __Pyx_GIVEREF(__pyx_int_143395587);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_143395587);
+    __Pyx_INCREF(__pyx_v_state);
+    __Pyx_GIVEREF(__pyx_v_state);
+    PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state);
+    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(7, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5);
+    __pyx_t_3 = 0;
+    __pyx_t_5 = 0;
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+
+  /* 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_AddTraceback("uvloop.loop.PseudoSocket.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_state);
+  __Pyx_XDECREF(__pyx_v__dict);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PseudoSocket, (type(self), 0x88c0b03, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PseudoSocket__set_state(self, __pyx_state)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_81__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12PseudoSocket_80__setstate_cython__[] = "PseudoSocket.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_12PseudoSocket_81__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_6uvloop_4loop_12PseudoSocket_80__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12PseudoSocket_80__setstate_cython__(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v_self, 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);
+
+  /* "(tree fragment)":17
+ *         return __pyx_unpickle_PseudoSocket, (type(self), 0x88c0b03, state)
+ * def __setstate_cython__(self, __pyx_state):
+ *     __pyx_unpickle_PseudoSocket__set_state(self, __pyx_state)             # <<<<<<<<<<<<<<
+ */
+  if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(7, 17, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pyx_unpickle_PseudoSocket__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PseudoSocket, (type(self), 0x88c0b03, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PseudoSocket__set_state(self, __pyx_state)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.PseudoSocket.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/lru.pyx":31
+ *     # beginning of it.
+ * 
+ *     def __init__(self, *, maxsize):             # <<<<<<<<<<<<<<
+ *         if maxsize <= 0:
+ *             raise ValueError(
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_8LruCache_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_8LruCache_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_maxsize = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_maxsize,0};
+    PyObject* values[1] = {0};
+    if (likely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_maxsize)) != 0)) kw_args--;
+      else {
+        __Pyx_RaiseKeywordRequired("__init__", __pyx_n_s_maxsize); __PYX_ERR(10, 31, __pyx_L3_error)
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, 0, "__init__") < 0)) __PYX_ERR(10, 31, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 0) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      __Pyx_RaiseKeywordRequired("__init__", __pyx_n_s_maxsize); __PYX_ERR(10, 31, __pyx_L3_error)
+    }
+    __pyx_v_maxsize = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(10, 31, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.LruCache.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_8LruCache___init__(((struct __pyx_obj_6uvloop_4loop_LruCache *)__pyx_v_self), __pyx_v_maxsize);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_8LruCache___init__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_maxsize) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  /* "uvloop/lru.pyx":32
+ * 
+ *     def __init__(self, *, maxsize):
+ *         if maxsize <= 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 f'maxsize is expected to be greater than 0, got {maxsize}')
+ */
+  __pyx_t_1 = PyObject_RichCompare(__pyx_v_maxsize, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 32, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(10, 32, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/lru.pyx":34
+ *         if maxsize <= 0:
+ *             raise ValueError(
+ *                 f'maxsize is expected to be greater than 0, got {maxsize}')             # <<<<<<<<<<<<<<
+ * 
+ *         self._dict = col_OrderedDict()
+ */
+    __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_maxsize, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 34, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_maxsize_is_expected_to_be_greate, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(10, 34, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/lru.pyx":33
+ *     def __init__(self, *, maxsize):
+ *         if maxsize <= 0:
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 f'maxsize is expected to be greater than 0, got {maxsize}')
+ * 
+ */
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 33, __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(10, 33, __pyx_L1_error)
+
+    /* "uvloop/lru.pyx":32
+ * 
+ *     def __init__(self, *, maxsize):
+ *         if maxsize <= 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 f'maxsize is expected to be greater than 0, got {maxsize}')
+ */
+  }
+
+  /* "uvloop/lru.pyx":36
+ *                 f'maxsize is expected to be greater than 0, got {maxsize}')
+ * 
+ *         self._dict = col_OrderedDict()             # <<<<<<<<<<<<<<
+ *         self._dict_move_to_end = self._dict.move_to_end
+ *         self._dict_get = self._dict.get
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_col_OrderedDict);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_col_OrderedDict; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_dict);
+  __Pyx_DECREF(__pyx_v_self->_dict);
+  __pyx_v_self->_dict = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/lru.pyx":37
+ * 
+ *         self._dict = col_OrderedDict()
+ *         self._dict_move_to_end = self._dict.move_to_end             # <<<<<<<<<<<<<<
+ *         self._dict_get = self._dict.get
+ *         self._maxsize = maxsize
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_dict, __pyx_n_s_move_to_end); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_dict_move_to_end);
+  __Pyx_DECREF(__pyx_v_self->_dict_move_to_end);
+  __pyx_v_self->_dict_move_to_end = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/lru.pyx":38
+ *         self._dict = col_OrderedDict()
+ *         self._dict_move_to_end = self._dict.move_to_end
+ *         self._dict_get = self._dict.get             # <<<<<<<<<<<<<<
+ *         self._maxsize = maxsize
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_dict_get);
+  __Pyx_DECREF(__pyx_v_self->_dict_get);
+  __pyx_v_self->_dict_get = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/lru.pyx":39
+ *         self._dict_move_to_end = self._dict.move_to_end
+ *         self._dict_get = self._dict.get
+ *         self._maxsize = maxsize             # <<<<<<<<<<<<<<
+ * 
+ *     cdef get(self, key, default):
+ */
+  __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_maxsize); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(10, 39, __pyx_L1_error)
+  __pyx_v_self->_maxsize = __pyx_t_5;
+
+  /* "uvloop/lru.pyx":31
+ *     # beginning of it.
+ * 
+ *     def __init__(self, *, maxsize):             # <<<<<<<<<<<<<<
+ *         if maxsize <= 0:
+ *             raise ValueError(
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.LruCache.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/lru.pyx":41
+ *         self._maxsize = maxsize
+ * 
+ *     cdef get(self, key, default):             # <<<<<<<<<<<<<<
+ *         o = self._dict_get(key, _LRU_MARKER)
+ *         if o is _LRU_MARKER:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8LruCache_get(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_default) {
+  PyObject *__pyx_v_o = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get", 0);
+
+  /* "uvloop/lru.pyx":42
+ * 
+ *     cdef get(self, key, default):
+ *         o = self._dict_get(key, _LRU_MARKER)             # <<<<<<<<<<<<<<
+ *         if o is _LRU_MARKER:
+ *             return default
+ */
+  __Pyx_INCREF(__pyx_v_self->_dict_get);
+  __pyx_t_2 = __pyx_v_self->_dict_get; __pyx_t_3 = NULL;
+  __pyx_t_4 = 0;
+  if (CYTHON_UNPACK_METHODS && 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;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_key, __pyx_v_6uvloop_4loop__LRU_MARKER};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 42, __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[3] = {__pyx_t_3, __pyx_v_key, __pyx_v_6uvloop_4loop__LRU_MARKER};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 42, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  {
+    __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 42, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (__pyx_t_3) {
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+    }
+    __Pyx_INCREF(__pyx_v_key);
+    __Pyx_GIVEREF(__pyx_v_key);
+    PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_key);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop__LRU_MARKER);
+    __Pyx_GIVEREF(__pyx_v_6uvloop_4loop__LRU_MARKER);
+    PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_6uvloop_4loop__LRU_MARKER);
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 42, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_o = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/lru.pyx":43
+ *     cdef get(self, key, default):
+ *         o = self._dict_get(key, _LRU_MARKER)
+ *         if o is _LRU_MARKER:             # <<<<<<<<<<<<<<
+ *             return default
+ *         self._dict_move_to_end(key)  # last=True
+ */
+  __pyx_t_6 = (__pyx_v_o == __pyx_v_6uvloop_4loop__LRU_MARKER);
+  __pyx_t_7 = (__pyx_t_6 != 0);
+  if (__pyx_t_7) {
+
+    /* "uvloop/lru.pyx":44
+ *         o = self._dict_get(key, _LRU_MARKER)
+ *         if o is _LRU_MARKER:
+ *             return default             # <<<<<<<<<<<<<<
+ *         self._dict_move_to_end(key)  # last=True
+ *         return o
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_default);
+    __pyx_r = __pyx_v_default;
+    goto __pyx_L0;
+
+    /* "uvloop/lru.pyx":43
+ *     cdef get(self, key, default):
+ *         o = self._dict_get(key, _LRU_MARKER)
+ *         if o is _LRU_MARKER:             # <<<<<<<<<<<<<<
+ *             return default
+ *         self._dict_move_to_end(key)  # last=True
+ */
+  }
+
+  /* "uvloop/lru.pyx":45
+ *         if o is _LRU_MARKER:
+ *             return default
+ *         self._dict_move_to_end(key)  # last=True             # <<<<<<<<<<<<<<
+ *         return o
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_self->_dict_move_to_end);
+  __pyx_t_2 = __pyx_v_self->_dict_move_to_end; __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_v_key) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_key);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 45, __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;
+
+  /* "uvloop/lru.pyx":46
+ *             return default
+ *         self._dict_move_to_end(key)  # last=True
+ *         return o             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline needs_cleanup(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_o);
+  __pyx_r = __pyx_v_o;
+  goto __pyx_L0;
+
+  /* "uvloop/lru.pyx":41
+ *         self._maxsize = maxsize
+ * 
+ *     cdef get(self, key, default):             # <<<<<<<<<<<<<<
+ *         o = self._dict_get(key, _LRU_MARKER)
+ *         if o is _LRU_MARKER:
+ */
+
+  /* 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_5);
+  __Pyx_AddTraceback("uvloop.loop.LruCache.get", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_o);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/lru.pyx":48
+ *         return o
+ * 
+ *     cdef inline needs_cleanup(self):             # <<<<<<<<<<<<<<
+ *         return len(self._dict) > self._maxsize
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8LruCache_needs_cleanup(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("needs_cleanup", 0);
+
+  /* "uvloop/lru.pyx":49
+ * 
+ *     cdef inline needs_cleanup(self):
+ *         return len(self._dict) > self._maxsize             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline cleanup_one(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_v_self->_dict;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(10, 49, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyBool_FromLong((__pyx_t_2 > __pyx_v_self->_maxsize)); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/lru.pyx":48
+ *         return o
+ * 
+ *     cdef inline needs_cleanup(self):             # <<<<<<<<<<<<<<
+ *         return len(self._dict) > self._maxsize
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.LruCache.needs_cleanup", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/lru.pyx":51
+ *         return len(self._dict) > self._maxsize
+ * 
+ *     cdef inline cleanup_one(self):             # <<<<<<<<<<<<<<
+ *         k, _ = self._dict.popitem(last=False)
+ *         return k
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8LruCache_cleanup_one(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self) {
+  PyObject *__pyx_v_k = NULL;
+  CYTHON_UNUSED PyObject *__pyx_v__ = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cleanup_one", 0);
+
+  /* "uvloop/lru.pyx":52
+ * 
+ *     cdef inline cleanup_one(self):
+ *         k, _ = self._dict.popitem(last=False)             # <<<<<<<<<<<<<<
+ *         return k
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_dict, __pyx_n_s_popitem); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_last, Py_False) < 0) __PYX_ERR(10, 52, __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(10, 52, __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;
+  if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
+    PyObject* sequence = __pyx_t_3;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(10, 52, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_1 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_1);
+    #else
+    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 52, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 52, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    #endif
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 52, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 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_GOTREF(__pyx_t_2);
+    index = 1; __pyx_t_1 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_1)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_1);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(10, 52, __pyx_L1_error)
+    __pyx_t_5 = NULL;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L4_unpacking_done;
+    __pyx_L3_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(10, 52, __pyx_L1_error)
+    __pyx_L4_unpacking_done:;
+  }
+  __pyx_v_k = __pyx_t_2;
+  __pyx_t_2 = 0;
+  __pyx_v__ = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/lru.pyx":53
+ *     cdef inline cleanup_one(self):
+ *         k, _ = self._dict.popitem(last=False)
+ *         return k             # <<<<<<<<<<<<<<
+ * 
+ *     def __getitem__(self, key):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_k);
+  __pyx_r = __pyx_v_k;
+  goto __pyx_L0;
+
+  /* "uvloop/lru.pyx":51
+ *         return len(self._dict) > self._maxsize
+ * 
+ *     cdef inline cleanup_one(self):             # <<<<<<<<<<<<<<
+ *         k, _ = self._dict.popitem(last=False)
+ *         return k
+ */
+
+  /* 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_AddTraceback("uvloop.loop.LruCache.cleanup_one", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_k);
+  __Pyx_XDECREF(__pyx_v__);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/lru.pyx":55
+ *         return k
+ * 
+ *     def __getitem__(self, key):             # <<<<<<<<<<<<<<
+ *         o = self._dict[key]
+ *         self._dict_move_to_end(key)  # last=True
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8LruCache_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_8LruCache_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8LruCache_2__getitem__(((struct __pyx_obj_6uvloop_4loop_LruCache *)__pyx_v_self), ((PyObject *)__pyx_v_key));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8LruCache_2__getitem__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_key) {
+  PyObject *__pyx_v_o = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("__getitem__", 0);
+
+  /* "uvloop/lru.pyx":56
+ * 
+ *     def __getitem__(self, key):
+ *         o = self._dict[key]             # <<<<<<<<<<<<<<
+ *         self._dict_move_to_end(key)  # last=True
+ *         return o
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_self->_dict, __pyx_v_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_o = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/lru.pyx":57
+ *     def __getitem__(self, key):
+ *         o = self._dict[key]
+ *         self._dict_move_to_end(key)  # last=True             # <<<<<<<<<<<<<<
+ *         return o
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_self->_dict_move_to_end);
+  __pyx_t_2 = __pyx_v_self->_dict_move_to_end; __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_key) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_key);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 57, __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;
+
+  /* "uvloop/lru.pyx":58
+ *         o = self._dict[key]
+ *         self._dict_move_to_end(key)  # last=True
+ *         return o             # <<<<<<<<<<<<<<
+ * 
+ *     def __setitem__(self, key, o):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_o);
+  __pyx_r = __pyx_v_o;
+  goto __pyx_L0;
+
+  /* "uvloop/lru.pyx":55
+ *         return k
+ * 
+ *     def __getitem__(self, key):             # <<<<<<<<<<<<<<
+ *         o = self._dict[key]
+ *         self._dict_move_to_end(key)  # last=True
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.LruCache.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_o);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/lru.pyx":60
+ *         return o
+ * 
+ *     def __setitem__(self, key, o):             # <<<<<<<<<<<<<<
+ *         if key in self._dict:
+ *             self._dict[key] = o
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_8LruCache_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_o); /*proto*/
+static int __pyx_pw_6uvloop_4loop_8LruCache_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_o) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8LruCache_4__setitem__(((struct __pyx_obj_6uvloop_4loop_LruCache *)__pyx_v_self), ((PyObject *)__pyx_v_key), ((PyObject *)__pyx_v_o));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_8LruCache_4__setitem__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_o) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  __Pyx_RefNannySetupContext("__setitem__", 0);
+
+  /* "uvloop/lru.pyx":61
+ * 
+ *     def __setitem__(self, key, o):
+ *         if key in self._dict:             # <<<<<<<<<<<<<<
+ *             self._dict[key] = o
+ *             self._dict_move_to_end(key)  # last=True
+ */
+  __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_v_self->_dict, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(10, 61, __pyx_L1_error)
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/lru.pyx":62
+ *     def __setitem__(self, key, o):
+ *         if key in self._dict:
+ *             self._dict[key] = o             # <<<<<<<<<<<<<<
+ *             self._dict_move_to_end(key)  # last=True
+ *         else:
+ */
+    if (unlikely(PyObject_SetItem(__pyx_v_self->_dict, __pyx_v_key, __pyx_v_o) < 0)) __PYX_ERR(10, 62, __pyx_L1_error)
+
+    /* "uvloop/lru.pyx":63
+ *         if key in self._dict:
+ *             self._dict[key] = o
+ *             self._dict_move_to_end(key)  # last=True             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._dict[key] = o
+ */
+    __Pyx_INCREF(__pyx_v_self->_dict_move_to_end);
+    __pyx_t_4 = __pyx_v_self->_dict_move_to_end; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_key) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_key);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(10, 63, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/lru.pyx":61
+ * 
+ *     def __setitem__(self, key, o):
+ *         if key in self._dict:             # <<<<<<<<<<<<<<
+ *             self._dict[key] = o
+ *             self._dict_move_to_end(key)  # last=True
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/lru.pyx":65
+ *             self._dict_move_to_end(key)  # last=True
+ *         else:
+ *             self._dict[key] = o             # <<<<<<<<<<<<<<
+ *         while self.needs_cleanup():
+ *             self.cleanup_one()
+ */
+  /*else*/ {
+    if (unlikely(PyObject_SetItem(__pyx_v_self->_dict, __pyx_v_key, __pyx_v_o) < 0)) __PYX_ERR(10, 65, __pyx_L1_error)
+  }
+  __pyx_L3:;
+
+  /* "uvloop/lru.pyx":66
+ *         else:
+ *             self._dict[key] = o
+ *         while self.needs_cleanup():             # <<<<<<<<<<<<<<
+ *             self.cleanup_one()
+ * 
+ */
+  while (1) {
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_8LruCache_needs_cleanup(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(10, 66, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(10, 66, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!__pyx_t_2) break;
+
+    /* "uvloop/lru.pyx":67
+ *             self._dict[key] = o
+ *         while self.needs_cleanup():
+ *             self.cleanup_one()             # <<<<<<<<<<<<<<
+ * 
+ *     def __delitem__(self, key):
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_8LruCache_cleanup_one(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(10, 67, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+
+  /* "uvloop/lru.pyx":60
+ *         return o
+ * 
+ *     def __setitem__(self, key, o):             # <<<<<<<<<<<<<<
+ *         if key in self._dict:
+ *             self._dict[key] = o
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.LruCache.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/lru.pyx":69
+ *             self.cleanup_one()
+ * 
+ *     def __delitem__(self, key):             # <<<<<<<<<<<<<<
+ *         del self._dict[key]
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_8LruCache_7__delitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/
+static int __pyx_pw_6uvloop_4loop_8LruCache_7__delitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__delitem__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8LruCache_6__delitem__(((struct __pyx_obj_6uvloop_4loop_LruCache *)__pyx_v_self), ((PyObject *)__pyx_v_key));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_8LruCache_6__delitem__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_key) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__delitem__", 0);
+
+  /* "uvloop/lru.pyx":70
+ * 
+ *     def __delitem__(self, key):
+ *         del self._dict[key]             # <<<<<<<<<<<<<<
+ * 
+ *     def __contains__(self, key):
+ */
+  if (unlikely(PyObject_DelItem(__pyx_v_self->_dict, __pyx_v_key) < 0)) __PYX_ERR(10, 70, __pyx_L1_error)
+
+  /* "uvloop/lru.pyx":69
+ *             self.cleanup_one()
+ * 
+ *     def __delitem__(self, key):             # <<<<<<<<<<<<<<
+ *         del self._dict[key]
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.LruCache.__delitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/lru.pyx":72
+ *         del self._dict[key]
+ * 
+ *     def __contains__(self, key):             # <<<<<<<<<<<<<<
+ *         return key in self._dict
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_8LruCache_9__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/
+static int __pyx_pw_6uvloop_4loop_8LruCache_9__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__contains__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8LruCache_8__contains__(((struct __pyx_obj_6uvloop_4loop_LruCache *)__pyx_v_self), ((PyObject *)__pyx_v_key));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_8LruCache_8__contains__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, PyObject *__pyx_v_key) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__contains__", 0);
+
+  /* "uvloop/lru.pyx":73
+ * 
+ *     def __contains__(self, key):
+ *         return key in self._dict             # <<<<<<<<<<<<<<
+ * 
+ *     def __len__(self):
+ */
+  __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_v_self->_dict, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(10, 73, __pyx_L1_error)
+  __pyx_r = __pyx_t_1;
+  goto __pyx_L0;
+
+  /* "uvloop/lru.pyx":72
+ *         del self._dict[key]
+ * 
+ *     def __contains__(self, key):             # <<<<<<<<<<<<<<
+ *         return key in self._dict
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.LruCache.__contains__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/lru.pyx":75
+ *         return key in self._dict
+ * 
+ *     def __len__(self):             # <<<<<<<<<<<<<<
+ *         return len(self._dict)
+ * 
+ */
+
+/* Python wrapper */
+static Py_ssize_t __pyx_pw_6uvloop_4loop_8LruCache_11__len__(PyObject *__pyx_v_self); /*proto*/
+static Py_ssize_t __pyx_pw_6uvloop_4loop_8LruCache_11__len__(PyObject *__pyx_v_self) {
+  Py_ssize_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__len__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8LruCache_10__len__(((struct __pyx_obj_6uvloop_4loop_LruCache *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static Py_ssize_t __pyx_pf_6uvloop_4loop_8LruCache_10__len__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self) {
+  Py_ssize_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__len__", 0);
+
+  /* "uvloop/lru.pyx":76
+ * 
+ *     def __len__(self):
+ *         return len(self._dict)             # <<<<<<<<<<<<<<
+ * 
+ *     def __iter__(self):
+ */
+  __pyx_t_1 = __pyx_v_self->_dict;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(10, 76, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  goto __pyx_L0;
+
+  /* "uvloop/lru.pyx":75
+ *         return key in self._dict
+ * 
+ *     def __len__(self):             # <<<<<<<<<<<<<<
+ *         return len(self._dict)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.LruCache.__len__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/lru.pyx":78
+ *         return len(self._dict)
+ * 
+ *     def __iter__(self):             # <<<<<<<<<<<<<<
+ *         return iter(self._dict)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8LruCache_13__iter__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_8LruCache_13__iter__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8LruCache_12__iter__(((struct __pyx_obj_6uvloop_4loop_LruCache *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8LruCache_12__iter__(struct __pyx_obj_6uvloop_4loop_LruCache *__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("__iter__", 0);
+
+  /* "uvloop/lru.pyx":79
+ * 
+ *     def __iter__(self):
+ *         return iter(self._dict)             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_v_self->_dict;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 79, __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;
+
+  /* "uvloop/lru.pyx":78
+ *         return len(self._dict)
+ * 
+ *     def __iter__(self):             # <<<<<<<<<<<<<<
+ *         return iter(self._dict)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.LruCache.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8LruCache_15__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8LruCache_14__reduce_cython__[] = "LruCache.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_8LruCache_15__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_6uvloop_4loop_8LruCache_14__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_LruCache *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8LruCache_14__reduce_cython__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self) {
+  PyObject *__pyx_v_state = 0;
+  PyObject *__pyx_v__dict = 0;
+  int __pyx_v_use_setstate;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __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("__reduce_cython__", 0);
+
+  /* "(tree fragment)":5
+ *     cdef object _dict
+ *     cdef bint use_setstate
+ *     state = (self._dict, self._dict_get, self._dict_move_to_end, self._maxsize)             # <<<<<<<<<<<<<<
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_maxsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_self->_dict);
+  __Pyx_GIVEREF(__pyx_v_self->_dict);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self->_dict);
+  __Pyx_INCREF(__pyx_v_self->_dict_get);
+  __Pyx_GIVEREF(__pyx_v_self->_dict_get);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_self->_dict_get);
+  __Pyx_INCREF(__pyx_v_self->_dict_move_to_end);
+  __Pyx_GIVEREF(__pyx_v_self->_dict_move_to_end);
+  PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_self->_dict_move_to_end);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_v_state = ((PyObject*)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "(tree fragment)":6
+ *     cdef bint use_setstate
+ *     state = (self._dict, self._dict_get, self._dict_move_to_end, self._maxsize)
+ *     _dict = getattr(self, '__dict__', None)             # <<<<<<<<<<<<<<
+ *     if _dict is not None:
+ *         state += (_dict,)
+ */
+  __pyx_t_2 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v__dict = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "(tree fragment)":7
+ *     state = (self._dict, self._dict_get, self._dict_move_to_end, self._maxsize)
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:             # <<<<<<<<<<<<<<
+ *         state += (_dict,)
+ *         use_setstate = True
+ */
+  __pyx_t_3 = (__pyx_v__dict != Py_None);
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  if (__pyx_t_4) {
+
+    /* "(tree fragment)":8
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:
+ *         state += (_dict,)             # <<<<<<<<<<<<<<
+ *         use_setstate = True
+ *     else:
+ */
+    __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 8, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_v__dict);
+    __Pyx_GIVEREF(__pyx_v__dict);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v__dict);
+    __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 8, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_1));
+    __pyx_t_1 = 0;
+
+    /* "(tree fragment)":9
+ *     if _dict is not None:
+ *         state += (_dict,)
+ *         use_setstate = True             # <<<<<<<<<<<<<<
+ *     else:
+ *         use_setstate = self._dict is not None or self._dict_get is not None or self._dict_move_to_end is not None
+ */
+    __pyx_v_use_setstate = 1;
+
+    /* "(tree fragment)":7
+ *     state = (self._dict, self._dict_get, self._dict_move_to_end, self._maxsize)
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:             # <<<<<<<<<<<<<<
+ *         state += (_dict,)
+ *         use_setstate = True
+ */
+    goto __pyx_L3;
+  }
+
+  /* "(tree fragment)":11
+ *         use_setstate = True
+ *     else:
+ *         use_setstate = self._dict is not None or self._dict_get is not None or self._dict_move_to_end is not None             # <<<<<<<<<<<<<<
+ *     if use_setstate:
+ *         return __pyx_unpickle_LruCache, (type(self), 0x53368d7, None), state
+ */
+  /*else*/ {
+    __pyx_t_3 = (__pyx_v_self->_dict != Py_None);
+    __pyx_t_5 = (__pyx_t_3 != 0);
+    if (!__pyx_t_5) {
+    } else {
+      __pyx_t_4 = __pyx_t_5;
+      goto __pyx_L4_bool_binop_done;
+    }
+    __pyx_t_5 = (__pyx_v_self->_dict_get != Py_None);
+    __pyx_t_3 = (__pyx_t_5 != 0);
+    if (!__pyx_t_3) {
+    } else {
+      __pyx_t_4 = __pyx_t_3;
+      goto __pyx_L4_bool_binop_done;
+    }
+    __pyx_t_3 = (__pyx_v_self->_dict_move_to_end != Py_None);
+    __pyx_t_5 = (__pyx_t_3 != 0);
+    __pyx_t_4 = __pyx_t_5;
+    __pyx_L4_bool_binop_done:;
+    __pyx_v_use_setstate = __pyx_t_4;
+  }
+  __pyx_L3:;
+
+  /* "(tree fragment)":12
+ *     else:
+ *         use_setstate = self._dict is not None or self._dict_get is not None or self._dict_move_to_end is not None
+ *     if use_setstate:             # <<<<<<<<<<<<<<
+ *         return __pyx_unpickle_LruCache, (type(self), 0x53368d7, None), state
+ *     else:
+ */
+  __pyx_t_4 = (__pyx_v_use_setstate != 0);
+  if (__pyx_t_4) {
+
+    /* "(tree fragment)":13
+ *         use_setstate = self._dict is not None or self._dict_get is not None or self._dict_move_to_end is not None
+ *     if use_setstate:
+ *         return __pyx_unpickle_LruCache, (type(self), 0x53368d7, None), state             # <<<<<<<<<<<<<<
+ *     else:
+ *         return __pyx_unpickle_LruCache, (type(self), 0x53368d7, state)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_pyx_unpickle_LruCache); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 13, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 13, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_INCREF(__pyx_int_87255255);
+    __Pyx_GIVEREF(__pyx_int_87255255);
+    PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_87255255);
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    PyTuple_SET_ITEM(__pyx_t_2, 2, Py_None);
+    __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(7, 13, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2);
+    __Pyx_INCREF(__pyx_v_state);
+    __Pyx_GIVEREF(__pyx_v_state);
+    PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_state);
+    __pyx_t_1 = 0;
+    __pyx_t_2 = 0;
+    __pyx_r = __pyx_t_6;
+    __pyx_t_6 = 0;
+    goto __pyx_L0;
+
+    /* "(tree fragment)":12
+ *     else:
+ *         use_setstate = self._dict is not None or self._dict_get is not None or self._dict_move_to_end is not None
+ *     if use_setstate:             # <<<<<<<<<<<<<<
+ *         return __pyx_unpickle_LruCache, (type(self), 0x53368d7, None), state
+ *     else:
+ */
+  }
+
+  /* "(tree fragment)":15
+ *         return __pyx_unpickle_LruCache, (type(self), 0x53368d7, None), state
+ *     else:
+ *         return __pyx_unpickle_LruCache, (type(self), 0x53368d7, state)             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     __pyx_unpickle_LruCache__set_state(self, __pyx_state)
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_pyx_unpickle_LruCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(7, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_INCREF(__pyx_int_87255255);
+    __Pyx_GIVEREF(__pyx_int_87255255);
+    PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_87255255);
+    __Pyx_INCREF(__pyx_v_state);
+    __Pyx_GIVEREF(__pyx_v_state);
+    PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state);
+    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2);
+    __pyx_t_6 = 0;
+    __pyx_t_2 = 0;
+    __pyx_r = __pyx_t_1;
+    __pyx_t_1 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.LruCache.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_state);
+  __Pyx_XDECREF(__pyx_v__dict);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_LruCache, (type(self), 0x53368d7, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_LruCache__set_state(self, __pyx_state)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8LruCache_17__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8LruCache_16__setstate_cython__[] = "LruCache.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_8LruCache_17__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_6uvloop_4loop_8LruCache_16__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_LruCache *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8LruCache_16__setstate_cython__(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v_self, 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);
+
+  /* "(tree fragment)":17
+ *         return __pyx_unpickle_LruCache, (type(self), 0x53368d7, state)
+ * def __setstate_cython__(self, __pyx_state):
+ *     __pyx_unpickle_LruCache__set_state(self, __pyx_state)             # <<<<<<<<<<<<<<
+ */
+  if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(7, 17, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pyx_unpickle_LruCache__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_LruCache, (type(self), 0x53368d7, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_LruCache__set_state(self, __pyx_state)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.LruCache.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":14
+ *     """
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._closed = 0
+ *         self._inited = 0
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_8UVHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_8UVHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVHandle___cinit__(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_8UVHandle___cinit__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "uvloop/handles/handle.pyx":15
+ * 
+ *     def __cinit__(self):
+ *         self._closed = 0             # <<<<<<<<<<<<<<
+ *         self._inited = 0
+ *         self._has_handle = 1
+ */
+  __pyx_v_self->_closed = 0;
+
+  /* "uvloop/handles/handle.pyx":16
+ *     def __cinit__(self):
+ *         self._closed = 0
+ *         self._inited = 0             # <<<<<<<<<<<<<<
+ *         self._has_handle = 1
+ *         self._handle = NULL
+ */
+  __pyx_v_self->_inited = 0;
+
+  /* "uvloop/handles/handle.pyx":17
+ *         self._closed = 0
+ *         self._inited = 0
+ *         self._has_handle = 1             # <<<<<<<<<<<<<<
+ *         self._handle = NULL
+ *         self._loop = None
+ */
+  __pyx_v_self->_has_handle = 1;
+
+  /* "uvloop/handles/handle.pyx":18
+ *         self._inited = 0
+ *         self._has_handle = 1
+ *         self._handle = NULL             # <<<<<<<<<<<<<<
+ *         self._loop = None
+ *         self._source_traceback = None
+ */
+  __pyx_v_self->_handle = NULL;
+
+  /* "uvloop/handles/handle.pyx":19
+ *         self._has_handle = 1
+ *         self._handle = NULL
+ *         self._loop = None             # <<<<<<<<<<<<<<
+ *         self._source_traceback = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_loop);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_loop));
+  __pyx_v_self->_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None);
+
+  /* "uvloop/handles/handle.pyx":20
+ *         self._handle = NULL
+ *         self._loop = None
+ *         self._source_traceback = None             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self):
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_source_traceback);
+  __Pyx_DECREF(__pyx_v_self->_source_traceback);
+  __pyx_v_self->_source_traceback = Py_None;
+
+  /* "uvloop/handles/handle.pyx":14
+ *     """
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._closed = 0
+ *         self._inited = 0
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":22
+ *         self._source_traceback = None
+ * 
+ *     def __init__(self):             # <<<<<<<<<<<<<<
+ *         raise TypeError(
+ *             '{} is not supposed to be instantiated from Python'.format(
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_8UVHandle_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_8UVHandle_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__init__", 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, "__init__", 0))) return -1;
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVHandle_2__init__(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_8UVHandle_2__init__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  /* "uvloop/handles/handle.pyx":24
+ *     def __init__(self):
+ *         raise TypeError(
+ *             '{} is not supposed to be instantiated from Python'.format(             # <<<<<<<<<<<<<<
+ *                 self.__class__.__name__))
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_is_not_supposed_to_be_instantia, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/handles/handle.pyx":25
+ *         raise TypeError(
+ *             '{} is not supposed to be instantiated from Python'.format(
+ *                 self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 25, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 25, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/handle.pyx":23
+ * 
+ *     def __init__(self):
+ *         raise TypeError(             # <<<<<<<<<<<<<<
+ *             '{} is not supposed to be instantiated from Python'.format(
+ *                 self.__class__.__name__))
+ */
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __PYX_ERR(2, 23, __pyx_L1_error)
+
+  /* "uvloop/handles/handle.pyx":22
+ *         self._source_traceback = None
+ * 
+ *     def __init__(self):             # <<<<<<<<<<<<<<
+ *         raise TypeError(
+ *             '{} is not supposed to be instantiated from Python'.format(
+ */
+
+  /* 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_AddTraceback("uvloop.loop.UVHandle.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":27
+ *                 self.__class__.__name__))
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if self._loop is not None:
+ */
+
+/* Python wrapper */
+static void __pyx_pw_6uvloop_4loop_8UVHandle_5__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_6uvloop_4loop_8UVHandle_5__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_6uvloop_4loop_8UVHandle_4__dealloc__(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_6uvloop_4loop_8UVHandle_4__dealloc__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "uvloop/handles/handle.pyx":28
+ * 
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if self._loop is not None:
+ *                 if self._inited:
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":29
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG:
+ *             if self._loop is not None:             # <<<<<<<<<<<<<<
+ *                 if self._inited:
+ *                     self._loop._debug_handles_current.subtract([
+ */
+    __pyx_t_1 = (((PyObject *)__pyx_v_self->_loop) != Py_None);
+    __pyx_t_2 = (__pyx_t_1 != 0);
+    if (likely(__pyx_t_2)) {
+
+      /* "uvloop/handles/handle.pyx":30
+ *         if UVLOOP_DEBUG:
+ *             if self._loop is not None:
+ *                 if self._inited:             # <<<<<<<<<<<<<<
+ *                     self._loop._debug_handles_current.subtract([
+ *                         self.__class__.__name__])
+ */
+      __pyx_t_2 = (__pyx_v_self->_inited != 0);
+      if (__pyx_t_2) {
+
+        /* "uvloop/handles/handle.pyx":31
+ *             if self._loop is not None:
+ *                 if self._inited:
+ *                     self._loop._debug_handles_current.subtract([             # <<<<<<<<<<<<<<
+ *                         self.__class__.__name__])
+ *             else:
+ */
+        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_loop->_debug_handles_current, __pyx_n_s_subtract); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 31, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+
+        /* "uvloop/handles/handle.pyx":32
+ *                 if self._inited:
+ *                     self._loop._debug_handles_current.subtract([
+ *                         self.__class__.__name__])             # <<<<<<<<<<<<<<
+ *             else:
+ *                 # No "@cython.no_gc_clear" decorator on this UVHandle
+ */
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 32, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 32, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/handles/handle.pyx":31
+ *             if self._loop is not None:
+ *                 if self._inited:
+ *                     self._loop._debug_handles_current.subtract([             # <<<<<<<<<<<<<<
+ *                         self.__class__.__name__])
+ *             else:
+ */
+        __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 31, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GIVEREF(__pyx_t_6);
+        PyList_SET_ITEM(__pyx_t_5, 0, __pyx_t_6);
+        __pyx_t_6 = 0;
+        __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_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_4, function);
+          }
+        }
+        __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(2, 31, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/handles/handle.pyx":30
+ *         if UVLOOP_DEBUG:
+ *             if self._loop is not None:
+ *                 if self._inited:             # <<<<<<<<<<<<<<
+ *                     self._loop._debug_handles_current.subtract([
+ *                         self.__class__.__name__])
+ */
+      }
+
+      /* "uvloop/handles/handle.pyx":29
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG:
+ *             if self._loop is not None:             # <<<<<<<<<<<<<<
+ *                 if self._inited:
+ *                     self._loop._debug_handles_current.subtract([
+ */
+      goto __pyx_L4;
+    }
+
+    /* "uvloop/handles/handle.pyx":35
+ *             else:
+ *                 # No "@cython.no_gc_clear" decorator on this UVHandle
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     '{} without @no_gc_clear; loop was set to None by GC'
+ *                     .format(self.__class__.__name__))
+ */
+    /*else*/ {
+
+      /* "uvloop/handles/handle.pyx":37
+ *                 raise RuntimeError(
+ *                     '{} without @no_gc_clear; loop was set to None by GC'
+ *                     .format(self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *         if self._handle is NULL:
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_without_no_gc_clear_loop_was_se, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 37, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 37, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 37, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 37, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/handles/handle.pyx":35
+ *             else:
+ *                 # No "@cython.no_gc_clear" decorator on this UVHandle
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     '{} without @no_gc_clear; loop was set to None by GC'
+ *                     .format(self.__class__.__name__))
+ */
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 35, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __PYX_ERR(2, 35, __pyx_L1_error)
+    }
+    __pyx_L4:;
+
+    /* "uvloop/handles/handle.pyx":28
+ * 
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if self._loop is not None:
+ *                 if self._inited:
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":39
+ *                     .format(self.__class__.__name__))
+ * 
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_self->_handle == NULL) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/handle.pyx":40
+ * 
+ *         if self._handle is NULL:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         # -> When we're at this point, something is wrong <-
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/handle.pyx":39
+ *                     .format(self.__class__.__name__))
+ * 
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":44
+ *         # -> When we're at this point, something is wrong <-
+ * 
+ *         if self._handle.loop is NULL:             # <<<<<<<<<<<<<<
+ *             # The handle wasn't initialized with "uv_{handle}_init"
+ *             self._closed = 1
+ */
+  __pyx_t_2 = ((__pyx_v_self->_handle->loop == NULL) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/handle.pyx":46
+ *         if self._handle.loop is NULL:
+ *             # The handle wasn't initialized with "uv_{handle}_init"
+ *             self._closed = 1             # <<<<<<<<<<<<<<
+ *             self._free()
+ *             raise RuntimeError(
+ */
+    __pyx_v_self->_closed = 1;
+
+    /* "uvloop/handles/handle.pyx":47
+ *             # The handle wasn't initialized with "uv_{handle}_init"
+ *             self._closed = 1
+ *             self._free()             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 '{} is open in __dealloc__ with loop set to NULL'
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *)__pyx_v_self->__pyx_vtab)->_free(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/handles/handle.pyx":50
+ *             raise RuntimeError(
+ *                 '{} is open in __dealloc__ with loop set to NULL'
+ *                 .format(self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *         if self._closed:
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_is_open_in___dealloc___with_loo, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 50, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 50, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 50, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_6 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __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_4)) __PYX_ERR(2, 50, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/handle.pyx":48
+ *             self._closed = 1
+ *             self._free()
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 '{} is open in __dealloc__ with loop set to NULL'
+ *                 .format(self.__class__.__name__))
+ */
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 48, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 48, __pyx_L1_error)
+
+    /* "uvloop/handles/handle.pyx":44
+ *         # -> When we're at this point, something is wrong <-
+ * 
+ *         if self._handle.loop is NULL:             # <<<<<<<<<<<<<<
+ *             # The handle wasn't initialized with "uv_{handle}_init"
+ *             self._closed = 1
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":52
+ *                 .format(self.__class__.__name__))
+ * 
+ *         if self._closed:             # <<<<<<<<<<<<<<
+ *             # So _handle is not NULL and self._closed == 1?
+ *             raise RuntimeError(
+ */
+  __pyx_t_2 = (__pyx_v_self->_closed != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/handle.pyx":55
+ *             # So _handle is not NULL and self._closed == 1?
+ *             raise RuntimeError(
+ *                 '{}.__dealloc__: _handle is NULL, _closed == 1'.format(             # <<<<<<<<<<<<<<
+ *                     self.__class__.__name__))
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_dealloc____handle_is_NULL__cl, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 55, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "uvloop/handles/handle.pyx":56
+ *             raise RuntimeError(
+ *                 '{}.__dealloc__: _handle is NULL, _closed == 1'.format(
+ *                     self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *         # The handle is dealloced while open.  Let's try to close it.
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 56, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 56, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 55, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/handles/handle.pyx":54
+ *         if self._closed:
+ *             # So _handle is not NULL and self._closed == 1?
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 '{}.__dealloc__: _handle is NULL, _closed == 1'.format(
+ *                     self.__class__.__name__))
+ */
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 54, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(2, 54, __pyx_L1_error)
+
+    /* "uvloop/handles/handle.pyx":52
+ *                 .format(self.__class__.__name__))
+ * 
+ *         if self._closed:             # <<<<<<<<<<<<<<
+ *             # So _handle is not NULL and self._closed == 1?
+ *             raise RuntimeError(
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":61
+ *         # Situations when this is possible include unhandled exceptions,
+ *         # errors during Handle.__cinit__/__init__ etc.
+ *         if self._inited:             # <<<<<<<<<<<<<<
+ *             self._handle.data = NULL
+ *             uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+ */
+  __pyx_t_2 = (__pyx_v_self->_inited != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/handle.pyx":62
+ *         # errors during Handle.__cinit__/__init__ etc.
+ *         if self._inited:
+ *             self._handle.data = NULL             # <<<<<<<<<<<<<<
+ *             uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+ *             self._handle = NULL
+ */
+    __pyx_v_self->_handle->data = NULL;
+
+    /* "uvloop/handles/handle.pyx":63
+ *         if self._inited:
+ *             self._handle.data = NULL
+ *             uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors             # <<<<<<<<<<<<<<
+ *             self._handle = NULL
+ *             self._warn_unclosed()
+ */
+    uv_close(__pyx_v_self->_handle, __pyx_f_6uvloop_4loop___uv_close_handle_cb);
+
+    /* "uvloop/handles/handle.pyx":64
+ *             self._handle.data = NULL
+ *             uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+ *             self._handle = NULL             # <<<<<<<<<<<<<<
+ *             self._warn_unclosed()
+ *         else:
+ */
+    __pyx_v_self->_handle = NULL;
+
+    /* "uvloop/handles/handle.pyx":65
+ *             uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+ *             self._handle = NULL
+ *             self._warn_unclosed()             # <<<<<<<<<<<<<<
+ *         else:
+ *             # The handle was allocated, but not initialized
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *)__pyx_v_self->__pyx_vtab)->_warn_unclosed(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 65, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/handles/handle.pyx":61
+ *         # Situations when this is possible include unhandled exceptions,
+ *         # errors during Handle.__cinit__/__init__ etc.
+ *         if self._inited:             # <<<<<<<<<<<<<<
+ *             self._handle.data = NULL
+ *             uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+ */
+    goto __pyx_L9;
+  }
+
+  /* "uvloop/handles/handle.pyx":68
+ *         else:
+ *             # The handle was allocated, but not initialized
+ *             self._closed = 1             # <<<<<<<<<<<<<<
+ *             self._free()
+ * 
+ */
+  /*else*/ {
+    __pyx_v_self->_closed = 1;
+
+    /* "uvloop/handles/handle.pyx":69
+ *             # The handle was allocated, but not initialized
+ *             self._closed = 1
+ *             self._free()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _free(self):
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *)__pyx_v_self->__pyx_vtab)->_free(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 69, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_L9:;
+
+  /* "uvloop/handles/handle.pyx":27
+ *                 self.__class__.__name__))
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if self._loop is not None:
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_WriteUnraisable("uvloop.loop.UVHandle.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/handles/handle.pyx":71
+ *             self._free()
+ * 
+ *     cdef _free(self):             # <<<<<<<<<<<<<<
+ *         if self._handle == NULL:
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__free(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_free", 0);
+
+  /* "uvloop/handles/handle.pyx":72
+ * 
+ *     cdef _free(self):
+ *         if self._handle == NULL:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_handle == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":73
+ *     cdef _free(self):
+ *         if self._handle == NULL:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if UVLOOP_DEBUG and self._inited:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/handle.pyx":72
+ * 
+ *     cdef _free(self):
+ *         if self._handle == NULL:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":75
+ *             return
+ * 
+ *         if UVLOOP_DEBUG and self._inited:             # <<<<<<<<<<<<<<
+ *             self._loop._debug_uv_handles_freed += 1
+ * 
+ */
+  __pyx_t_2 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_v_self->_inited != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L5_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":76
+ * 
+ *         if UVLOOP_DEBUG and self._inited:
+ *             self._loop._debug_uv_handles_freed += 1             # <<<<<<<<<<<<<<
+ * 
+ *         PyMem_RawFree(self._handle)
+ */
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->_loop));
+    __pyx_t_3 = __pyx_v_self->_loop;
+    __pyx_t_3->_debug_uv_handles_freed = (__pyx_t_3->_debug_uv_handles_freed + 1);
+    __Pyx_DECREF(((PyObject *)__pyx_t_3)); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/handle.pyx":75
+ *             return
+ * 
+ *         if UVLOOP_DEBUG and self._inited:             # <<<<<<<<<<<<<<
+ *             self._loop._debug_uv_handles_freed += 1
+ * 
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":78
+ *             self._loop._debug_uv_handles_freed += 1
+ * 
+ *         PyMem_RawFree(self._handle)             # <<<<<<<<<<<<<<
+ *         self._handle = NULL
+ * 
+ */
+  PyMem_RawFree(__pyx_v_self->_handle);
+
+  /* "uvloop/handles/handle.pyx":79
+ * 
+ *         PyMem_RawFree(self._handle)
+ *         self._handle = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _warn_unclosed(self):
+ */
+  __pyx_v_self->_handle = NULL;
+
+  /* "uvloop/handles/handle.pyx":71
+ *             self._free()
+ * 
+ *     cdef _free(self):             # <<<<<<<<<<<<<<
+ *         if self._handle == NULL:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":81
+ *         self._handle = NULL
+ * 
+ *     cdef _warn_unclosed(self):             # <<<<<<<<<<<<<<
+ *         if self._source_traceback is not None:
+ *             try:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__warn_unclosed(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  PyObject *__pyx_v_tb = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_v_msg = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_t_15;
+  char const *__pyx_t_16;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_warn_unclosed", 0);
+
+  /* "uvloop/handles/handle.pyx":82
+ * 
+ *     cdef _warn_unclosed(self):
+ *         if self._source_traceback is not None:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 tb = ''.join(tb_format_list(self._source_traceback))
+ */
+  __pyx_t_1 = (__pyx_v_self->_source_traceback != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/handle.pyx":83
+ *     cdef _warn_unclosed(self):
+ *         if self._source_traceback is not None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 tb = ''.join(tb_format_list(self._source_traceback))
+ *                 tb = 'object created at (most recent call last):\n{}'.format(
+ */
+    {
+      __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:*/ {
+
+        /* "uvloop/handles/handle.pyx":84
+ *         if self._source_traceback is not None:
+ *             try:
+ *                 tb = ''.join(tb_format_list(self._source_traceback))             # <<<<<<<<<<<<<<
+ *                 tb = 'object created at (most recent call last):\n{}'.format(
+ *                     tb.rstrip())
+ */
+        __Pyx_INCREF(__pyx_v_6uvloop_4loop_tb_format_list);
+        __pyx_t_7 = __pyx_v_6uvloop_4loop_tb_format_list; __pyx_t_8 = NULL;
+        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+          if (likely(__pyx_t_8)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+            __Pyx_INCREF(__pyx_t_8);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_7, function);
+          }
+        }
+        __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_v_self->_source_traceback) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_self->_source_traceback);
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 84, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __pyx_t_7 = PyUnicode_Join(__pyx_kp_u__8, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 84, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __pyx_v_tb = __pyx_t_7;
+        __pyx_t_7 = 0;
+
+        /* "uvloop/handles/handle.pyx":85
+ *             try:
+ *                 tb = ''.join(tb_format_list(self._source_traceback))
+ *                 tb = 'object created at (most recent call last):\n{}'.format(             # <<<<<<<<<<<<<<
+ *                     tb.rstrip())
+ *             except Exception as ex:
+ */
+        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_object_created_at_most_recent_ca, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 85, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_6);
+
+        /* "uvloop/handles/handle.pyx":86
+ *                 tb = ''.join(tb_format_list(self._source_traceback))
+ *                 tb = 'object created at (most recent call last):\n{}'.format(
+ *                     tb.rstrip())             # <<<<<<<<<<<<<<
+ *             except Exception as ex:
+ *                 msg = (
+ */
+        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_tb, __pyx_n_s_rstrip); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 86, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __pyx_t_10 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) {
+          __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9);
+          if (likely(__pyx_t_10)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+            __Pyx_INCREF(__pyx_t_10);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_9, function);
+          }
+        }
+        __pyx_t_8 = (__pyx_t_10) ? __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_10) : __Pyx_PyObject_CallNoArg(__pyx_t_9);
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 86, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __pyx_t_9 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+          __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6);
+          if (likely(__pyx_t_9)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+            __Pyx_INCREF(__pyx_t_9);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_6, function);
+          }
+        }
+        __pyx_t_7 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_9, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_8);
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 85, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF_SET(__pyx_v_tb, __pyx_t_7);
+        __pyx_t_7 = 0;
+
+        /* "uvloop/handles/handle.pyx":83
+ *     cdef _warn_unclosed(self):
+ *         if self._source_traceback is not None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 tb = ''.join(tb_format_list(self._source_traceback))
+ *                 tb = 'object created at (most recent call last):\n{}'.format(
+ */
+      }
+
+      /* "uvloop/handles/handle.pyx":93
+ *                 ).format(self, type(ex).__name__, ex)
+ *             else:
+ *                 msg = 'unclosed resource {!r}; {}'.format(self, tb)             # <<<<<<<<<<<<<<
+ *         else:
+ *             msg = 'unclosed resource {!r}'.format(self)
+ */
+      /*else:*/ {
+        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unclosed_resource_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 93, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __pyx_t_8 = NULL;
+        __pyx_t_11 = 0;
+        if (CYTHON_UNPACK_METHODS && likely(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_6, function);
+            __pyx_t_11 = 1;
+          }
+        }
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_6)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_8, ((PyObject *)__pyx_v_self), __pyx_v_tb};
+          __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 93, __pyx_L6_except_error)
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_GOTREF(__pyx_t_7);
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_8, ((PyObject *)__pyx_v_self), __pyx_v_tb};
+          __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 93, __pyx_L6_except_error)
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_GOTREF(__pyx_t_7);
+        } else
+        #endif
+        {
+          __pyx_t_9 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 93, __pyx_L6_except_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          if (__pyx_t_8) {
+            __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
+          }
+          __Pyx_INCREF(((PyObject *)__pyx_v_self));
+          __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+          PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_11, ((PyObject *)__pyx_v_self));
+          __Pyx_INCREF(__pyx_v_tb);
+          __Pyx_GIVEREF(__pyx_v_tb);
+          PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_11, __pyx_v_tb);
+          __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 93, __pyx_L6_except_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __pyx_v_msg = __pyx_t_7;
+        __pyx_t_7 = 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_10); __pyx_t_10 = 0;
+      __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;
+
+      /* "uvloop/handles/handle.pyx":87
+ *                 tb = 'object created at (most recent call last):\n{}'.format(
+ *                     tb.rstrip())
+ *             except Exception as ex:             # <<<<<<<<<<<<<<
+ *                 msg = (
+ *                     'unclosed resource {!r}; could not serialize '
+ */
+      __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+      if (__pyx_t_11) {
+        __Pyx_AddTraceback("uvloop.loop.UVHandle._warn_unclosed", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_9) < 0) __PYX_ERR(2, 87, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_INCREF(__pyx_t_6);
+        __pyx_v_ex = __pyx_t_6;
+        /*try:*/ {
+
+          /* "uvloop/handles/handle.pyx":91
+ *                     'unclosed resource {!r}; could not serialize '
+ *                     'debug traceback: {}: {}'
+ *                 ).format(self, type(ex).__name__, ex)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 msg = 'unclosed resource {!r}; {}'.format(self, tb)
+ */
+          __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unclosed_resource_r_could_not_se, __pyx_n_s_format); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 91, __pyx_L15_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_ex)), __pyx_n_s_name); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 91, __pyx_L15_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          __pyx_t_13 = NULL;
+          __pyx_t_11 = 0;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
+            __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_10);
+            if (likely(__pyx_t_13)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+              __Pyx_INCREF(__pyx_t_13);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_10, function);
+              __pyx_t_11 = 1;
+            }
+          }
+          #if CYTHON_FAST_PYCALL
+          if (PyFunction_Check(__pyx_t_10)) {
+            PyObject *__pyx_temp[4] = {__pyx_t_13, ((PyObject *)__pyx_v_self), __pyx_t_12, __pyx_v_ex};
+            __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 91, __pyx_L15_error)
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_GOTREF(__pyx_t_8);
+            __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+          } else
+          #endif
+          #if CYTHON_FAST_PYCCALL
+          if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) {
+            PyObject *__pyx_temp[4] = {__pyx_t_13, ((PyObject *)__pyx_v_self), __pyx_t_12, __pyx_v_ex};
+            __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 91, __pyx_L15_error)
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_GOTREF(__pyx_t_8);
+            __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+          } else
+          #endif
+          {
+            __pyx_t_14 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 91, __pyx_L15_error)
+            __Pyx_GOTREF(__pyx_t_14);
+            if (__pyx_t_13) {
+              __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_13); __pyx_t_13 = NULL;
+            }
+            __Pyx_INCREF(((PyObject *)__pyx_v_self));
+            __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+            PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_11, ((PyObject *)__pyx_v_self));
+            __Pyx_GIVEREF(__pyx_t_12);
+            PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_11, __pyx_t_12);
+            __Pyx_INCREF(__pyx_v_ex);
+            __Pyx_GIVEREF(__pyx_v_ex);
+            PyTuple_SET_ITEM(__pyx_t_14, 2+__pyx_t_11, __pyx_v_ex);
+            __pyx_t_12 = 0;
+            __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_14, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 91, __pyx_L15_error)
+            __Pyx_GOTREF(__pyx_t_8);
+            __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+          }
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+          __pyx_v_msg = __pyx_t_8;
+          __pyx_t_8 = 0;
+        }
+
+        /* "uvloop/handles/handle.pyx":87
+ *                 tb = 'object created at (most recent call last):\n{}'.format(
+ *                     tb.rstrip())
+ *             except Exception as ex:             # <<<<<<<<<<<<<<
+ *                 msg = (
+ *                     'unclosed resource {!r}; could not serialize '
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L16;
+          }
+          __pyx_L15_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+            __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __Pyx_XGOTREF(__pyx_t_21);
+            __Pyx_XGOTREF(__pyx_t_22);
+            __pyx_t_11 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_XGIVEREF(__pyx_t_21);
+              __Pyx_XGIVEREF(__pyx_t_22);
+              __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
+            }
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+            __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+            __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16;
+            goto __pyx_L6_except_error;
+          }
+          __pyx_L16:;
+        }
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        goto __pyx_L5_exception_handled;
+      }
+      goto __pyx_L6_except_error;
+      __pyx_L6_except_error:;
+
+      /* "uvloop/handles/handle.pyx":83
+ *     cdef _warn_unclosed(self):
+ *         if self._source_traceback is not None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 tb = ''.join(tb_format_list(self._source_traceback))
+ *                 tb = 'object created at (most recent call last):\n{}'.format(
+ */
+      __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_L5_exception_handled:;
+      __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);
+      __pyx_L9_try_end:;
+    }
+
+    /* "uvloop/handles/handle.pyx":82
+ * 
+ *     cdef _warn_unclosed(self):
+ *         if self._source_traceback is not None:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 tb = ''.join(tb_format_list(self._source_traceback))
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/handle.pyx":95
+ *                 msg = 'unclosed resource {!r}; {}'.format(self, tb)
+ *         else:
+ *             msg = 'unclosed resource {!r}'.format(self)             # <<<<<<<<<<<<<<
+ *         warnings_warn(msg, ResourceWarning)
+ * 
+ */
+  /*else*/ {
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unclosed_resource_r_2, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 95, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    __pyx_t_9 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_self));
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 95, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_v_msg = __pyx_t_9;
+    __pyx_t_9 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/handle.pyx":96
+ *         else:
+ *             msg = 'unclosed resource {!r}'.format(self)
+ *         warnings_warn(msg, ResourceWarning)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _abort_init(self):
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ResourceWarning); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 96, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_warnings_warn);
+  __pyx_t_7 = __pyx_v_6uvloop_4loop_warnings_warn; __pyx_t_8 = NULL;
+  __pyx_t_15 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+    if (likely(__pyx_t_8)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_8);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_7, function);
+      __pyx_t_15 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_7)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_msg, __pyx_t_6};
+    __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_15, 2+__pyx_t_15); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 96, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_msg, __pyx_t_6};
+    __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_15, 2+__pyx_t_15); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 96, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_10 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 96, __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_v_msg);
+    __Pyx_GIVEREF(__pyx_v_msg);
+    PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_15, __pyx_v_msg);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_15, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 96, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+  /* "uvloop/handles/handle.pyx":81
+ *         self._handle = NULL
+ * 
+ *     cdef _warn_unclosed(self):             # <<<<<<<<<<<<<<
+ *         if self._source_traceback is not None:
+ *             try:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("uvloop.loop.UVHandle._warn_unclosed", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_tb);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XDECREF(__pyx_v_msg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":98
+ *         warnings_warn(msg, ResourceWarning)
+ * 
+ *     cdef inline _abort_init(self):             # <<<<<<<<<<<<<<
+ *         if self._handle is not NULL:
+ *             self._free()
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__abort_init(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  PyObject *__pyx_v_name = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  char const *__pyx_t_7;
+  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;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_abort_init", 0);
+
+  /* "uvloop/handles/handle.pyx":99
+ * 
+ *     cdef inline _abort_init(self):
+ *         if self._handle is not NULL:             # <<<<<<<<<<<<<<
+ *             self._free()
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_handle != NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":100
+ *     cdef inline _abort_init(self):
+ *         if self._handle is not NULL:
+ *             self._free()             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *)__pyx_v_self->__pyx_vtab)->_free(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 100, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/handle.pyx":99
+ * 
+ *     cdef inline _abort_init(self):
+ *         if self._handle is not NULL:             # <<<<<<<<<<<<<<
+ *             self._free()
+ * 
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":102
+ *             self._free()
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 name = self.__class__.__name__
+ */
+  /*try:*/ {
+
+    /* "uvloop/handles/handle.pyx":103
+ * 
+ *         try:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 name = self.__class__.__name__
+ *                 if self._inited:
+ */
+    __pyx_t_1 = (UVLOOP_DEBUG != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/handle.pyx":104
+ *         try:
+ *             if UVLOOP_DEBUG:
+ *                 name = self.__class__.__name__             # <<<<<<<<<<<<<<
+ *                 if self._inited:
+ *                     raise RuntimeError(
+ */
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 104, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 104, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_v_name = __pyx_t_3;
+      __pyx_t_3 = 0;
+
+      /* "uvloop/handles/handle.pyx":105
+ *             if UVLOOP_DEBUG:
+ *                 name = self.__class__.__name__
+ *                 if self._inited:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '_abort_init: {}._inited is set'.format(name))
+ */
+      __pyx_t_1 = (__pyx_v_self->_inited != 0);
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/handles/handle.pyx":107
+ *                 if self._inited:
+ *                     raise RuntimeError(
+ *                         '_abort_init: {}._inited is set'.format(name))             # <<<<<<<<<<<<<<
+ *                 if self._closed:
+ *                     raise RuntimeError(
+ */
+        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_abort_init__inited_is_set, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 107, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_4 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_name);
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 107, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/handles/handle.pyx":106
+ *                 name = self.__class__.__name__
+ *                 if self._inited:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '_abort_init: {}._inited is set'.format(name))
+ *                 if self._closed:
+ */
+        __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 106, __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(2, 106, __pyx_L5_error)
+
+        /* "uvloop/handles/handle.pyx":105
+ *             if UVLOOP_DEBUG:
+ *                 name = self.__class__.__name__
+ *                 if self._inited:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '_abort_init: {}._inited is set'.format(name))
+ */
+      }
+
+      /* "uvloop/handles/handle.pyx":108
+ *                     raise RuntimeError(
+ *                         '_abort_init: {}._inited is set'.format(name))
+ *                 if self._closed:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '_abort_init: {}._closed is set'.format(name))
+ */
+      __pyx_t_1 = (__pyx_v_self->_closed != 0);
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/handles/handle.pyx":110
+ *                 if self._closed:
+ *                     raise RuntimeError(
+ *                         '_abort_init: {}._closed is set'.format(name))             # <<<<<<<<<<<<<<
+ *         finally:
+ *             self._closed = 1
+ */
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_abort_init__closed_is_set, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 110, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_4 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_name);
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 110, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/handles/handle.pyx":109
+ *                         '_abort_init: {}._inited is set'.format(name))
+ *                 if self._closed:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '_abort_init: {}._closed is set'.format(name))
+ *         finally:
+ */
+        __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 109, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(2, 109, __pyx_L5_error)
+
+        /* "uvloop/handles/handle.pyx":108
+ *                     raise RuntimeError(
+ *                         '_abort_init: {}._inited is set'.format(name))
+ *                 if self._closed:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '_abort_init: {}._closed is set'.format(name))
+ */
+      }
+
+      /* "uvloop/handles/handle.pyx":103
+ * 
+ *         try:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 name = self.__class__.__name__
+ *                 if self._inited:
+ */
+    }
+  }
+
+  /* "uvloop/handles/handle.pyx":112
+ *                         '_abort_init: {}._closed is set'.format(name))
+ *         finally:
+ *             self._closed = 1             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _finish_init(self):
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_v_self->_closed = 1;
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __pyx_t_5 = __pyx_lineno; __pyx_t_6 = __pyx_clineno; __pyx_t_7 = __pyx_filename;
+      {
+        __pyx_v_self->_closed = 1;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+      }
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_ErrRestore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0;
+      __pyx_lineno = __pyx_t_5; __pyx_clineno = __pyx_t_6; __pyx_filename = __pyx_t_7;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/handles/handle.pyx":98
+ *         warnings_warn(msg, ResourceWarning)
+ * 
+ *     cdef inline _abort_init(self):             # <<<<<<<<<<<<<<
+ *         if self._handle is not NULL:
+ *             self._free()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.UVHandle._abort_init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_name);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":114
+ *             self._closed = 1
+ * 
+ *     cdef inline _finish_init(self):             # <<<<<<<<<<<<<<
+ *         self._inited = 1
+ *         if self._has_handle == 1:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__finish_init(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  PyObject *__pyx_v_cls_name = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_finish_init", 0);
+
+  /* "uvloop/handles/handle.pyx":115
+ * 
+ *     cdef inline _finish_init(self):
+ *         self._inited = 1             # <<<<<<<<<<<<<<
+ *         if self._has_handle == 1:
+ *             self._handle.data = <void*>self
+ */
+  __pyx_v_self->_inited = 1;
+
+  /* "uvloop/handles/handle.pyx":116
+ *     cdef inline _finish_init(self):
+ *         self._inited = 1
+ *         if self._has_handle == 1:             # <<<<<<<<<<<<<<
+ *             self._handle.data = <void*>self
+ *         if self._loop._debug:
+ */
+  __pyx_t_1 = ((__pyx_v_self->_has_handle == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":117
+ *         self._inited = 1
+ *         if self._has_handle == 1:
+ *             self._handle.data = <void*>self             # <<<<<<<<<<<<<<
+ *         if self._loop._debug:
+ *             self._source_traceback = extract_stack()
+ */
+    __pyx_v_self->_handle->data = ((void *)__pyx_v_self);
+
+    /* "uvloop/handles/handle.pyx":116
+ *     cdef inline _finish_init(self):
+ *         self._inited = 1
+ *         if self._has_handle == 1:             # <<<<<<<<<<<<<<
+ *             self._handle.data = <void*>self
+ *         if self._loop._debug:
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":118
+ *         if self._has_handle == 1:
+ *             self._handle.data = <void*>self
+ *         if self._loop._debug:             # <<<<<<<<<<<<<<
+ *             self._source_traceback = extract_stack()
+ *         if UVLOOP_DEBUG:
+ */
+  __pyx_t_1 = (__pyx_v_self->_loop->_debug != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":119
+ *             self._handle.data = <void*>self
+ *         if self._loop._debug:
+ *             self._source_traceback = extract_stack()             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             cls_name = self.__class__.__name__
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_extract_stack(); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 119, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_2);
+    __Pyx_GOTREF(__pyx_v_self->_source_traceback);
+    __Pyx_DECREF(__pyx_v_self->_source_traceback);
+    __pyx_v_self->_source_traceback = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/handle.pyx":118
+ *         if self._has_handle == 1:
+ *             self._handle.data = <void*>self
+ *         if self._loop._debug:             # <<<<<<<<<<<<<<
+ *             self._source_traceback = extract_stack()
+ *         if UVLOOP_DEBUG:
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":120
+ *         if self._loop._debug:
+ *             self._source_traceback = extract_stack()
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             cls_name = self.__class__.__name__
+ *             self._loop._debug_uv_handles_total += 1
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":121
+ *             self._source_traceback = extract_stack()
+ *         if UVLOOP_DEBUG:
+ *             cls_name = self.__class__.__name__             # <<<<<<<<<<<<<<
+ *             self._loop._debug_uv_handles_total += 1
+ *             self._loop._debug_handles_total.update([cls_name])
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 121, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 121, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_v_cls_name = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/handles/handle.pyx":122
+ *         if UVLOOP_DEBUG:
+ *             cls_name = self.__class__.__name__
+ *             self._loop._debug_uv_handles_total += 1             # <<<<<<<<<<<<<<
+ *             self._loop._debug_handles_total.update([cls_name])
+ *             self._loop._debug_handles_current.update([cls_name])
+ */
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->_loop));
+    __pyx_t_4 = __pyx_v_self->_loop;
+    __pyx_t_4->_debug_uv_handles_total = (__pyx_t_4->_debug_uv_handles_total + 1);
+    __Pyx_DECREF(((PyObject *)__pyx_t_4)); __pyx_t_4 = 0;
+
+    /* "uvloop/handles/handle.pyx":123
+ *             cls_name = self.__class__.__name__
+ *             self._loop._debug_uv_handles_total += 1
+ *             self._loop._debug_handles_total.update([cls_name])             # <<<<<<<<<<<<<<
+ *             self._loop._debug_handles_current.update([cls_name])
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_loop->_debug_handles_total, __pyx_n_s_update); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 123, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 123, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_v_cls_name);
+    __Pyx_GIVEREF(__pyx_v_cls_name);
+    PyList_SET_ITEM(__pyx_t_5, 0, __pyx_v_cls_name);
+    __pyx_t_6 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_6)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __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(2, 123, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/handle.pyx":124
+ *             self._loop._debug_uv_handles_total += 1
+ *             self._loop._debug_handles_total.update([cls_name])
+ *             self._loop._debug_handles_current.update([cls_name])             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _start_init(self, Loop loop):
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_loop->_debug_handles_current, __pyx_n_s_update); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 124, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 124, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_v_cls_name);
+    __Pyx_GIVEREF(__pyx_v_cls_name);
+    PyList_SET_ITEM(__pyx_t_5, 0, __pyx_v_cls_name);
+    __pyx_t_6 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_6)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __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(2, 124, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/handle.pyx":120
+ *         if self._loop._debug:
+ *             self._source_traceback = extract_stack()
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             cls_name = self.__class__.__name__
+ *             self._loop._debug_uv_handles_total += 1
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":114
+ *             self._closed = 1
+ * 
+ *     cdef inline _finish_init(self):             # <<<<<<<<<<<<<<
+ *         self._inited = 1
+ *         if self._has_handle == 1:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(((PyObject *)__pyx_t_4));
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.UVHandle._finish_init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_cls_name);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":126
+ *             self._loop._debug_handles_current.update([cls_name])
+ * 
+ *     cdef inline _start_init(self, Loop loop):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if self._loop is not None:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__start_init(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_start_init", 0);
+
+  /* "uvloop/handles/handle.pyx":127
+ * 
+ *     cdef inline _start_init(self, Loop loop):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if self._loop is not None:
+ *                 raise RuntimeError(
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":128
+ *     cdef inline _start_init(self, Loop loop):
+ *         if UVLOOP_DEBUG:
+ *             if self._loop is not None:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}._start_init can only be called once'.format(
+ */
+    __pyx_t_1 = (((PyObject *)__pyx_v_self->_loop) != Py_None);
+    __pyx_t_2 = (__pyx_t_1 != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/handles/handle.pyx":130
+ *             if self._loop is not None:
+ *                 raise RuntimeError(
+ *                     '{}._start_init can only be called once'.format(             # <<<<<<<<<<<<<<
+ *                         self.__class__.__name__))
+ * 
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_start_init_can_only_be_called, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 130, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/handles/handle.pyx":131
+ *                 raise RuntimeError(
+ *                     '{}._start_init can only be called once'.format(
+ *                         self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *         self._loop = loop
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 131, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 131, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 130, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/handles/handle.pyx":129
+ *         if UVLOOP_DEBUG:
+ *             if self._loop is not None:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     '{}._start_init can only be called once'.format(
+ *                         self.__class__.__name__))
+ */
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 129, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __PYX_ERR(2, 129, __pyx_L1_error)
+
+      /* "uvloop/handles/handle.pyx":128
+ *     cdef inline _start_init(self, Loop loop):
+ *         if UVLOOP_DEBUG:
+ *             if self._loop is not None:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}._start_init can only be called once'.format(
+ */
+    }
+
+    /* "uvloop/handles/handle.pyx":127
+ * 
+ *     cdef inline _start_init(self, Loop loop):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if self._loop is not None:
+ *                 raise RuntimeError(
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":133
+ *                         self.__class__.__name__))
+ * 
+ *         self._loop = loop             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline bint _is_alive(self):
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GOTREF(__pyx_v_self->_loop);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_loop));
+  __pyx_v_self->_loop = __pyx_v_loop;
+
+  /* "uvloop/handles/handle.pyx":126
+ *             self._loop._debug_handles_current.update([cls_name])
+ * 
+ *     cdef inline _start_init(self, Loop loop):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if self._loop is not None:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.UVHandle._start_init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":135
+ *         self._loop = loop
+ * 
+ *     cdef inline bint _is_alive(self):             # <<<<<<<<<<<<<<
+ *         cdef bint res
+ *         res = self._closed != 1 and self._inited == 1
+ */
+
+static CYTHON_INLINE int __pyx_f_6uvloop_4loop_8UVHandle__is_alive(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  int __pyx_v_res;
+  PyObject *__pyx_v_name = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  __Pyx_RefNannySetupContext("_is_alive", 0);
+
+  /* "uvloop/handles/handle.pyx":137
+ *     cdef inline bint _is_alive(self):
+ *         cdef bint res
+ *         res = self._closed != 1 and self._inited == 1             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if res and self._has_handle == 1:
+ */
+  __pyx_t_2 = ((__pyx_v_self->_closed != 1) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L3_bool_binop_done;
+  }
+  __pyx_t_2 = ((__pyx_v_self->_inited == 1) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L3_bool_binop_done:;
+  __pyx_v_res = __pyx_t_1;
+
+  /* "uvloop/handles/handle.pyx":138
+ *         cdef bint res
+ *         res = self._closed != 1 and self._inited == 1
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if res and self._has_handle == 1:
+ *                 name = self.__class__.__name__
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":139
+ *         res = self._closed != 1 and self._inited == 1
+ *         if UVLOOP_DEBUG:
+ *             if res and self._has_handle == 1:             # <<<<<<<<<<<<<<
+ *                 name = self.__class__.__name__
+ *                 if self._handle is NULL:
+ */
+    __pyx_t_2 = (__pyx_v_res != 0);
+    if (__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_2 = ((__pyx_v_self->_has_handle == 1) != 0);
+    __pyx_t_1 = __pyx_t_2;
+    __pyx_L7_bool_binop_done:;
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/handle.pyx":140
+ *         if UVLOOP_DEBUG:
+ *             if res and self._has_handle == 1:
+ *                 name = self.__class__.__name__             # <<<<<<<<<<<<<<
+ *                 if self._handle is NULL:
+ *                     raise RuntimeError(
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 140, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 140, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_v_name = __pyx_t_4;
+      __pyx_t_4 = 0;
+
+      /* "uvloop/handles/handle.pyx":141
+ *             if res and self._has_handle == 1:
+ *                 name = self.__class__.__name__
+ *                 if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _handle is NULL'.format(name))
+ */
+      __pyx_t_1 = ((__pyx_v_self->_handle == NULL) != 0);
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/handles/handle.pyx":143
+ *                 if self._handle is NULL:
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _handle is NULL'.format(name))             # <<<<<<<<<<<<<<
+ *                 if self._loop is None:
+ *                     raise RuntimeError(
+ */
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_is_alive_but__handle_is_NULL, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 143, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_5 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_3, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_name);
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 143, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/handles/handle.pyx":142
+ *                 name = self.__class__.__name__
+ *                 if self._handle is NULL:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '{} is alive, but _handle is NULL'.format(name))
+ *                 if self._loop is None:
+ */
+        __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 142, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(2, 142, __pyx_L1_error)
+
+        /* "uvloop/handles/handle.pyx":141
+ *             if res and self._has_handle == 1:
+ *                 name = self.__class__.__name__
+ *                 if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _handle is NULL'.format(name))
+ */
+      }
+
+      /* "uvloop/handles/handle.pyx":144
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _handle is NULL'.format(name))
+ *                 if self._loop is None:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _loop is None'.format(name))
+ */
+      __pyx_t_1 = (((PyObject *)__pyx_v_self->_loop) == Py_None);
+      __pyx_t_2 = (__pyx_t_1 != 0);
+      if (unlikely(__pyx_t_2)) {
+
+        /* "uvloop/handles/handle.pyx":146
+ *                 if self._loop is None:
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _loop is None'.format(name))             # <<<<<<<<<<<<<<
+ *                 if self._handle.loop is not self._loop.uvloop:
+ *                     raise RuntimeError(
+ */
+        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_is_alive_but__loop_is_None, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 146, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_5 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_name);
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 146, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/handles/handle.pyx":145
+ *                         '{} is alive, but _handle is NULL'.format(name))
+ *                 if self._loop is None:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '{} is alive, but _loop is None'.format(name))
+ *                 if self._handle.loop is not self._loop.uvloop:
+ */
+        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 145, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __PYX_ERR(2, 145, __pyx_L1_error)
+
+        /* "uvloop/handles/handle.pyx":144
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _handle is NULL'.format(name))
+ *                 if self._loop is None:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _loop is None'.format(name))
+ */
+      }
+
+      /* "uvloop/handles/handle.pyx":147
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _loop is None'.format(name))
+ *                 if self._handle.loop is not self._loop.uvloop:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _handle.loop is not '
+ */
+      __pyx_t_2 = ((__pyx_v_self->_handle->loop != __pyx_v_self->_loop->uvloop) != 0);
+      if (unlikely(__pyx_t_2)) {
+
+        /* "uvloop/handles/handle.pyx":150
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _handle.loop is not '
+ *                         'initialized'.format(name))             # <<<<<<<<<<<<<<
+ *                 if self._handle.data is not <void*>self:
+ *                     raise RuntimeError(
+ */
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_is_alive_but__handle_loop_is_no, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 150, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_5 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_3, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_name);
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 150, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/handles/handle.pyx":148
+ *                         '{} is alive, but _loop is None'.format(name))
+ *                 if self._handle.loop is not self._loop.uvloop:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '{} is alive, but _handle.loop is not '
+ *                         'initialized'.format(name))
+ */
+        __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 148, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(2, 148, __pyx_L1_error)
+
+        /* "uvloop/handles/handle.pyx":147
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _loop is None'.format(name))
+ *                 if self._handle.loop is not self._loop.uvloop:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _handle.loop is not '
+ */
+      }
+
+      /* "uvloop/handles/handle.pyx":151
+ *                         '{} is alive, but _handle.loop is not '
+ *                         'initialized'.format(name))
+ *                 if self._handle.data is not <void*>self:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _handle.data is not '
+ */
+      __pyx_t_2 = ((__pyx_v_self->_handle->data != ((void *)__pyx_v_self)) != 0);
+      if (unlikely(__pyx_t_2)) {
+
+        /* "uvloop/handles/handle.pyx":154
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _handle.data is not '
+ *                         'initialized'.format(name))             # <<<<<<<<<<<<<<
+ *         return res
+ * 
+ */
+        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_is_alive_but__handle_data_is_no, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 154, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_5 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_name);
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 154, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/handles/handle.pyx":152
+ *                         'initialized'.format(name))
+ *                 if self._handle.data is not <void*>self:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '{} is alive, but _handle.data is not '
+ *                         'initialized'.format(name))
+ */
+        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 152, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __PYX_ERR(2, 152, __pyx_L1_error)
+
+        /* "uvloop/handles/handle.pyx":151
+ *                         '{} is alive, but _handle.loop is not '
+ *                         'initialized'.format(name))
+ *                 if self._handle.data is not <void*>self:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '{} is alive, but _handle.data is not '
+ */
+      }
+
+      /* "uvloop/handles/handle.pyx":139
+ *         res = self._closed != 1 and self._inited == 1
+ *         if UVLOOP_DEBUG:
+ *             if res and self._has_handle == 1:             # <<<<<<<<<<<<<<
+ *                 name = self.__class__.__name__
+ *                 if self._handle is NULL:
+ */
+    }
+
+    /* "uvloop/handles/handle.pyx":138
+ *         cdef bint res
+ *         res = self._closed != 1 and self._inited == 1
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if res and self._has_handle == 1:
+ *                 name = self.__class__.__name__
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":155
+ *                         '{} is alive, but _handle.data is not '
+ *                         'initialized'.format(name))
+ *         return res             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _ensure_alive(self):
+ */
+  __pyx_r = __pyx_v_res;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/handle.pyx":135
+ *         self._loop = loop
+ * 
+ *     cdef inline bint _is_alive(self):             # <<<<<<<<<<<<<<
+ *         cdef bint res
+ *         res = self._closed != 1 and self._inited == 1
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_WriteUnraisable("uvloop.loop.UVHandle._is_alive", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_name);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":157
+ *         return res
+ * 
+ *     cdef inline _ensure_alive(self):             # <<<<<<<<<<<<<<
+ *         if not self._is_alive():
+ *             raise RuntimeError(
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__ensure_alive(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ensure_alive", 0);
+
+  /* "uvloop/handles/handle.pyx":158
+ * 
+ *     cdef inline _ensure_alive(self):
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'unable to perform operation on {!r}; '
+ */
+  __pyx_t_1 = ((!(__pyx_f_6uvloop_4loop_8UVHandle__is_alive(__pyx_v_self) != 0)) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/handle.pyx":161
+ *             raise RuntimeError(
+ *                 'unable to perform operation on {!r}; '
+ *                 'the handler is closed'.format(self))             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unable_to_perform_operation_on_r, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 161, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_self));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 161, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/handle.pyx":159
+ *     cdef inline _ensure_alive(self):
+ *         if not self._is_alive():
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'unable to perform operation on {!r}; '
+ *                 'the handler is closed'.format(self))
+ */
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 159, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 159, __pyx_L1_error)
+
+    /* "uvloop/handles/handle.pyx":158
+ * 
+ *     cdef inline _ensure_alive(self):
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'unable to perform operation on {!r}; '
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":157
+ *         return res
+ * 
+ *     cdef inline _ensure_alive(self):             # <<<<<<<<<<<<<<
+ *         if not self._is_alive():
+ *             raise RuntimeError(
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.UVHandle._ensure_alive", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":163
+ *                 'the handler is closed'.format(self))
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):             # <<<<<<<<<<<<<<
+ *         # Fatal error means an error that was returned by the
+ *         # underlying libuv handle function.  We usually can't
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__fatal_error(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error *__pyx_optional_args) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_fatal_error", 0);
+  if (__pyx_optional_args) {
+  }
+
+  /* "uvloop/handles/handle.pyx":167
+ *         # underlying libuv handle function.  We usually can't
+ *         # recover from that, hence we just close the handle.
+ *         self._close()             # <<<<<<<<<<<<<<
+ * 
+ *         if throw or self._loop is None:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *)__pyx_v_self->__pyx_vtab)->_close(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/handle.pyx":169
+ *         self._close()
+ * 
+ *         if throw or self._loop is None:             # <<<<<<<<<<<<<<
+ *             raise exc
+ *         else:
+ */
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_throw); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 169, __pyx_L1_error)
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_3 = (((PyObject *)__pyx_v_self->_loop) == Py_None);
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  __pyx_t_2 = __pyx_t_4;
+  __pyx_L4_bool_binop_done:;
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/handle.pyx":170
+ * 
+ *         if throw or self._loop is None:
+ *             raise exc             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._loop._handle_exception(exc)
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(2, 170, __pyx_L1_error)
+
+    /* "uvloop/handles/handle.pyx":169
+ *         self._close()
+ * 
+ *         if throw or self._loop is None:             # <<<<<<<<<<<<<<
+ *             raise exc
+ *         else:
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":172
+ *             raise exc
+ *         else:
+ *             self._loop._handle_exception(exc)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _error(self, exc, throw):
+ */
+  /*else*/ {
+    ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->_loop->__pyx_vtab)->_handle_exception(__pyx_v_self->_loop, __pyx_v_exc);
+  }
+
+  /* "uvloop/handles/handle.pyx":163
+ *                 'the handler is closed'.format(self))
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):             # <<<<<<<<<<<<<<
+ *         # Fatal error means an error that was returned by the
+ *         # underlying libuv handle function.  We usually can't
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVHandle._fatal_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":174
+ *             self._loop._handle_exception(exc)
+ * 
+ *     cdef _error(self, exc, throw):             # <<<<<<<<<<<<<<
+ *         # A non-fatal error is usually an error that was caught
+ *         # by the handler, but was originated in the client code
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__error(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_error", 0);
+
+  /* "uvloop/handles/handle.pyx":179
+ *         # (not in libuv).  In this case we either want to simply
+ *         # raise or log it.
+ *         if throw or self._loop is None:             # <<<<<<<<<<<<<<
+ *             raise exc
+ *         else:
+ */
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_throw); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 179, __pyx_L1_error)
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->_loop) == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/handle.pyx":180
+ *         # raise or log it.
+ *         if throw or self._loop is None:
+ *             raise exc             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._loop._handle_exception(exc)
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(2, 180, __pyx_L1_error)
+
+    /* "uvloop/handles/handle.pyx":179
+ *         # (not in libuv).  In this case we either want to simply
+ *         # raise or log it.
+ *         if throw or self._loop is None:             # <<<<<<<<<<<<<<
+ *             raise exc
+ *         else:
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":182
+ *             raise exc
+ *         else:
+ *             self._loop._handle_exception(exc)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _close(self):
+ */
+  /*else*/ {
+    ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->_loop->__pyx_vtab)->_handle_exception(__pyx_v_self->_loop, __pyx_v_exc);
+  }
+
+  /* "uvloop/handles/handle.pyx":174
+ *             self._loop._handle_exception(exc)
+ * 
+ *     cdef _error(self, exc, throw):             # <<<<<<<<<<<<<<
+ *         # A non-fatal error is usually an error that was caught
+ *         # by the handler, but was originated in the client code
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVHandle._error", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":184
+ *             self._loop._handle_exception(exc)
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         if self._closed == 1:
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__close(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_close", 0);
+
+  /* "uvloop/handles/handle.pyx":185
+ * 
+ *     cdef _close(self):
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_closed == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":186
+ *     cdef _close(self):
+ *         if self._closed == 1:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._closed = 1
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/handle.pyx":185
+ * 
+ *     cdef _close(self):
+ *         if self._closed == 1:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":188
+ *             return
+ * 
+ *         self._closed = 1             # <<<<<<<<<<<<<<
+ * 
+ *         if self._handle is NULL:
+ */
+  __pyx_v_self->_closed = 1;
+
+  /* "uvloop/handles/handle.pyx":190
+ *         self._closed = 1
+ * 
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->_handle == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":191
+ * 
+ *         if self._handle is NULL:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if UVLOOP_DEBUG:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/handle.pyx":190
+ *         self._closed = 1
+ * 
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":193
+ *             return
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if self._handle.data is NULL:
+ *                 raise RuntimeError(
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":194
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if self._handle.data is NULL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}._close: _handle.data is NULL'.format(
+ */
+    __pyx_t_1 = ((__pyx_v_self->_handle->data == NULL) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/handles/handle.pyx":196
+ *             if self._handle.data is NULL:
+ *                 raise RuntimeError(
+ *                     '{}._close: _handle.data is NULL'.format(             # <<<<<<<<<<<<<<
+ *                         self.__class__.__name__))
+ * 
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_close__handle_data_is_NULL, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 196, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+
+      /* "uvloop/handles/handle.pyx":197
+ *                 raise RuntimeError(
+ *                     '{}._close: _handle.data is NULL'.format(
+ *                         self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *             if <object>self._handle.data is not self:
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 197, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 197, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 196, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/handle.pyx":195
+ *         if UVLOOP_DEBUG:
+ *             if self._handle.data is NULL:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     '{}._close: _handle.data is NULL'.format(
+ *                         self.__class__.__name__))
+ */
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 195, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(2, 195, __pyx_L1_error)
+
+      /* "uvloop/handles/handle.pyx":194
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if self._handle.data is NULL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}._close: _handle.data is NULL'.format(
+ */
+    }
+
+    /* "uvloop/handles/handle.pyx":199
+ *                         self.__class__.__name__))
+ * 
+ *             if <object>self._handle.data is not self:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}._close: _handle.data is not UVHandle/self'.format(
+ */
+    __pyx_t_1 = (((PyObject *)__pyx_v_self->_handle->data) != ((PyObject *)__pyx_v_self));
+    __pyx_t_6 = (__pyx_t_1 != 0);
+    if (unlikely(__pyx_t_6)) {
+
+      /* "uvloop/handles/handle.pyx":201
+ *             if <object>self._handle.data is not self:
+ *                 raise RuntimeError(
+ *                     '{}._close: _handle.data is not UVHandle/self'.format(             # <<<<<<<<<<<<<<
+ *                         self.__class__.__name__))
+ * 
+ */
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_close__handle_data_is_not_UVHa, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 201, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+
+      /* "uvloop/handles/handle.pyx":202
+ *                 raise RuntimeError(
+ *                     '{}._close: _handle.data is not UVHandle/self'.format(
+ *                         self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *             if uv.uv_is_closing(self._handle):
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 202, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 202, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+        if (likely(__pyx_t_5)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+          __Pyx_INCREF(__pyx_t_5);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_2, function);
+        }
+      }
+      __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __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_3)) __PYX_ERR(2, 201, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/handle.pyx":200
+ * 
+ *             if <object>self._handle.data is not self:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     '{}._close: _handle.data is not UVHandle/self'.format(
+ *                         self.__class__.__name__))
+ */
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 200, __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(2, 200, __pyx_L1_error)
+
+      /* "uvloop/handles/handle.pyx":199
+ *                         self.__class__.__name__))
+ * 
+ *             if <object>self._handle.data is not self:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}._close: _handle.data is not UVHandle/self'.format(
+ */
+    }
+
+    /* "uvloop/handles/handle.pyx":204
+ *                         self.__class__.__name__))
+ * 
+ *             if uv.uv_is_closing(self._handle):             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}._close: uv_is_closing() is true'.format(
+ */
+    __pyx_t_6 = (uv_is_closing(__pyx_v_self->_handle) != 0);
+    if (unlikely(__pyx_t_6)) {
+
+      /* "uvloop/handles/handle.pyx":206
+ *             if uv.uv_is_closing(self._handle):
+ *                 raise RuntimeError(
+ *                     '{}._close: uv_is_closing() is true'.format(             # <<<<<<<<<<<<<<
+ *                         self.__class__.__name__))
+ * 
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_close_uv_is_closing_is_true, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 206, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+
+      /* "uvloop/handles/handle.pyx":207
+ *                 raise RuntimeError(
+ *                     '{}._close: uv_is_closing() is true'.format(
+ *                         self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *         # We want the handle wrapper (UVHandle) to stay alive until
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 207, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 207, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 206, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/handle.pyx":205
+ * 
+ *             if uv.uv_is_closing(self._handle):
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     '{}._close: uv_is_closing() is true'.format(
+ *                         self.__class__.__name__))
+ */
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 205, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(2, 205, __pyx_L1_error)
+
+      /* "uvloop/handles/handle.pyx":204
+ *                         self.__class__.__name__))
+ * 
+ *             if uv.uv_is_closing(self._handle):             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}._close: uv_is_closing() is true'.format(
+ */
+    }
+
+    /* "uvloop/handles/handle.pyx":193
+ *             return
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if self._handle.data is NULL:
+ *                 raise RuntimeError(
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":211
+ *         # We want the handle wrapper (UVHandle) to stay alive until
+ *         # the closing callback fires.
+ *         Py_INCREF(self)             # <<<<<<<<<<<<<<
+ *         uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+ * 
+ */
+  Py_INCREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/handles/handle.pyx":212
+ *         # the closing callback fires.
+ *         Py_INCREF(self)
+ *         uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+  uv_close(__pyx_v_self->_handle, __pyx_f_6uvloop_4loop___uv_close_handle_cb);
+
+  /* "uvloop/handles/handle.pyx":184
+ *             self._loop._handle_exception(exc)
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         if self._closed == 1:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVHandle._close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":214
+ *         uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return '<{} closed={} {:#x}>'.format(
+ *             self.__class__.__name__,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVHandle_7__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_8UVHandle_7__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVHandle_6__repr__(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVHandle_6__repr__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "uvloop/handles/handle.pyx":215
+ * 
+ *     def __repr__(self):
+ *         return '<{} closed={} {:#x}>'.format(             # <<<<<<<<<<<<<<
+ *             self.__class__.__name__,
+ *             self._closed,
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_closed_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 215, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/handles/handle.pyx":216
+ *     def __repr__(self):
+ *         return '<{} closed={} {:#x}>'.format(
+ *             self.__class__.__name__,             # <<<<<<<<<<<<<<
+ *             self._closed,
+ *             id(self))
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/handle.pyx":217
+ *         return '<{} closed={} {:#x}>'.format(
+ *             self.__class__.__name__,
+ *             self._closed,             # <<<<<<<<<<<<<<
+ *             id(self))
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_self->_closed); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/handles/handle.pyx":218
+ *             self.__class__.__name__,
+ *             self._closed,
+ *             id(self))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = NULL;
+  __pyx_t_7 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_7 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_t_4, __pyx_t_3, __pyx_t_5};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 215, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_t_4, __pyx_t_3, __pyx_t_5};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 215, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __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(2, 215, __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_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_t_5);
+    __pyx_t_4 = 0;
+    __pyx_t_3 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 215, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/handle.pyx":214
+ *         uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return '<{} closed={} {:#x}>'.format(
+ *             self.__class__.__name__,
+ */
+
+  /* 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_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.UVHandle.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pxd":5
+ *         uv.uv_handle_t *_handle
+ *         Loop _loop
+ *         readonly _source_traceback             # <<<<<<<<<<<<<<
+ *         bint _closed
+ *         bint _inited
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVHandle_17_source_traceback_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_8UVHandle_17_source_traceback_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVHandle_17_source_traceback___get__(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVHandle_17_source_traceback___get__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_source_traceback);
+  __pyx_r = __pyx_v_self->_source_traceback;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVHandle_9__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8UVHandle_8__reduce_cython__[] = "UVHandle.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_8UVHandle_9__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_6uvloop_4loop_8UVHandle_8__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVHandle_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVHandle *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__115, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVHandle.__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_6uvloop_4loop_8UVHandle_11__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8UVHandle_10__setstate_cython__[] = "UVHandle.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_8UVHandle_11__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_6uvloop_4loop_8UVHandle_10__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVHandle_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVHandle *__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);
+
+  /* "(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__116, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVHandle.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":223
+ * cdef class UVSocketHandle(UVHandle):
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._fileobj = None
+ *         self.__cached_socket = None
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_14UVSocketHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_14UVSocketHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_6uvloop_4loop_14UVSocketHandle___cinit__(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_14UVSocketHandle___cinit__(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "uvloop/handles/handle.pyx":224
+ * 
+ *     def __cinit__(self):
+ *         self._fileobj = None             # <<<<<<<<<<<<<<
+ *         self.__cached_socket = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_fileobj);
+  __Pyx_DECREF(__pyx_v_self->_fileobj);
+  __pyx_v_self->_fileobj = Py_None;
+
+  /* "uvloop/handles/handle.pyx":225
+ *     def __cinit__(self):
+ *         self._fileobj = None
+ *         self.__cached_socket = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _fileno(self):
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->__pyx___cached_socket);
+  __Pyx_DECREF(__pyx_v_self->__pyx___cached_socket);
+  __pyx_v_self->__pyx___cached_socket = Py_None;
+
+  /* "uvloop/handles/handle.pyx":223
+ * cdef class UVSocketHandle(UVHandle):
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._fileobj = None
+ *         self.__cached_socket = None
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":227
+ *         self.__cached_socket = None
+ * 
+ *     cdef _fileno(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int fd
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__fileno(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self) {
+  int __pyx_v_fd;
+  int __pyx_v_err;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_fileno", 0);
+
+  /* "uvloop/handles/handle.pyx":232
+ *             int err
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ *         err = uv.uv_fileno(self._handle, <uv.uv_os_fd_t*>&fd)
+ *         if err < 0:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/handle.pyx":233
+ * 
+ *         self._ensure_alive()
+ *         err = uv.uv_fileno(self._handle, <uv.uv_os_fd_t*>&fd)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             raise convert_error(err)
+ */
+  __pyx_v_err = uv_fileno(__pyx_v_self->__pyx_base._handle, ((uv_os_fd_t *)(&__pyx_v_fd)));
+
+  /* "uvloop/handles/handle.pyx":234
+ *         self._ensure_alive()
+ *         err = uv.uv_fileno(self._handle, <uv.uv_os_fd_t*>&fd)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/handle.pyx":235
+ *         err = uv.uv_fileno(self._handle, <uv.uv_os_fd_t*>&fd)
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         return fd
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 235, __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(2, 235, __pyx_L1_error)
+
+    /* "uvloop/handles/handle.pyx":234
+ *         self._ensure_alive()
+ *         err = uv.uv_fileno(self._handle, <uv.uv_os_fd_t*>&fd)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":237
+ *             raise convert_error(err)
+ * 
+ *         return fd             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _new_socket(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 237, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/handle.pyx":227
+ *         self.__cached_socket = None
+ * 
+ *     cdef _fileno(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int fd
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVSocketHandle._fileno", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":239
+ *         return fd
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__new_socket(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_new_socket", 0);
+
+  /* "uvloop/handles/handle.pyx":240
+ * 
+ *     cdef _new_socket(self):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _get_socket(self):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(2, 240, __pyx_L1_error)
+
+  /* "uvloop/handles/handle.pyx":239
+ *         return fd
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVSocketHandle._new_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":242
+ *         raise NotImplementedError
+ * 
+ *     cdef inline _get_socket(self):             # <<<<<<<<<<<<<<
+ *         if self.__cached_socket is not None:
+ *             return self.__cached_socket
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__get_socket(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  __Pyx_RefNannySetupContext("_get_socket", 0);
+
+  /* "uvloop/handles/handle.pyx":243
+ * 
+ *     cdef inline _get_socket(self):
+ *         if self.__cached_socket is not None:             # <<<<<<<<<<<<<<
+ *             return self.__cached_socket
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx___cached_socket != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/handle.pyx":244
+ *     cdef inline _get_socket(self):
+ *         if self.__cached_socket is not None:
+ *             return self.__cached_socket             # <<<<<<<<<<<<<<
+ * 
+ *         if not self._is_alive():
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_self->__pyx___cached_socket);
+    __pyx_r = __pyx_v_self->__pyx___cached_socket;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/handle.pyx":243
+ * 
+ *     cdef inline _get_socket(self):
+ *         if self.__cached_socket is not None:             # <<<<<<<<<<<<<<
+ *             return self.__cached_socket
+ * 
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":246
+ *             return self.__cached_socket
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             return None
+ * 
+ */
+  __pyx_t_2 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)) != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/handle.pyx":247
+ * 
+ *         if not self._is_alive():
+ *             return None             # <<<<<<<<<<<<<<
+ * 
+ *         self.__cached_socket = self._new_socket()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/handle.pyx":246
+ *             return self.__cached_socket
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             return None
+ * 
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":249
+ *             return None
+ * 
+ *         self.__cached_socket = self._new_socket()             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             # We don't "dup" for the "__cached_socket".
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle *)__pyx_v_self->__pyx_base.__pyx_vtab)->_new_socket(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 249, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_v_self->__pyx___cached_socket);
+  __Pyx_DECREF(__pyx_v_self->__pyx___cached_socket);
+  __pyx_v_self->__pyx___cached_socket = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/handles/handle.pyx":250
+ * 
+ *         self.__cached_socket = self._new_socket()
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             # We don't "dup" for the "__cached_socket".
+ *             assert self.__cached_socket.fileno() == self._fileno()
+ */
+  __pyx_t_2 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/handle.pyx":252
+ *         if UVLOOP_DEBUG:
+ *             # We don't "dup" for the "__cached_socket".
+ *             assert self.__cached_socket.fileno() == self._fileno()             # <<<<<<<<<<<<<<
+ *         return self.__cached_socket
+ * 
+ */
+    #ifndef CYTHON_WITHOUT_ASSERTIONS
+    if (unlikely(!Py_OptimizeFlag)) {
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx___cached_socket, __pyx_n_s_fileno); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 252, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 252, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle *)__pyx_v_self->__pyx_base.__pyx_vtab)->_fileno(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 252, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 252, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 252, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_2)) {
+        PyErr_SetNone(PyExc_AssertionError);
+        __PYX_ERR(2, 252, __pyx_L1_error)
+      }
+    }
+    #endif
+
+    /* "uvloop/handles/handle.pyx":250
+ * 
+ *         self.__cached_socket = self._new_socket()
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             # We don't "dup" for the "__cached_socket".
+ *             assert self.__cached_socket.fileno() == self._fileno()
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":253
+ *             # We don't "dup" for the "__cached_socket".
+ *             assert self.__cached_socket.fileno() == self._fileno()
+ *         return self.__cached_socket             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _attach_fileobj(self, object file):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->__pyx___cached_socket);
+  __pyx_r = __pyx_v_self->__pyx___cached_socket;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/handle.pyx":242
+ *         raise NotImplementedError
+ * 
+ *     cdef inline _get_socket(self):             # <<<<<<<<<<<<<<
+ *         if self.__cached_socket is not None:
+ *             return self.__cached_socket
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVSocketHandle._get_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":255
+ *         return self.__cached_socket
+ * 
+ *     cdef inline _attach_fileobj(self, object file):             # <<<<<<<<<<<<<<
+ *         # When we create a TCP/PIPE/etc connection/server based on
+ *         # a Python file object, we need to close the file object when
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__attach_fileobj(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self, PyObject *__pyx_v_file) {
+  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("_attach_fileobj", 0);
+
+  /* "uvloop/handles/handle.pyx":259
+ *         # a Python file object, we need to close the file object when
+ *         # the uv handle is closed.
+ *         socket_inc_io_ref(file)             # <<<<<<<<<<<<<<
+ *         self._fileobj = file
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_socket_inc_io_ref(__pyx_v_file); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/handle.pyx":260
+ *         # the uv handle is closed.
+ *         socket_inc_io_ref(file)
+ *         self._fileobj = file             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _close(self):
+ */
+  __Pyx_INCREF(__pyx_v_file);
+  __Pyx_GIVEREF(__pyx_v_file);
+  __Pyx_GOTREF(__pyx_v_self->_fileobj);
+  __Pyx_DECREF(__pyx_v_self->_fileobj);
+  __pyx_v_self->_fileobj = __pyx_v_file;
+
+  /* "uvloop/handles/handle.pyx":255
+ *         return self.__cached_socket
+ * 
+ *     cdef inline _attach_fileobj(self, object file):             # <<<<<<<<<<<<<<
+ *         # When we create a TCP/PIPE/etc connection/server based on
+ *         # a Python file object, we need to close the file object when
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVSocketHandle._attach_fileobj", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":262
+ *         self._fileobj = file
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         if self.__cached_socket is not None:
+ *             (<PseudoSocket>self.__cached_socket)._fd = -1
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__close(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self) {
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_t_15;
+  char const *__pyx_t_16;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  PyObject *__pyx_t_23 = NULL;
+  PyObject *__pyx_t_24 = NULL;
+  PyObject *__pyx_t_25 = NULL;
+  char const *__pyx_t_26;
+  char const *__pyx_t_27;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_close", 0);
+
+  /* "uvloop/handles/handle.pyx":263
+ * 
+ *     cdef _close(self):
+ *         if self.__cached_socket is not None:             # <<<<<<<<<<<<<<
+ *             (<PseudoSocket>self.__cached_socket)._fd = -1
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx___cached_socket != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/handle.pyx":264
+ *     cdef _close(self):
+ *         if self.__cached_socket is not None:
+ *             (<PseudoSocket>self.__cached_socket)._fd = -1             # <<<<<<<<<<<<<<
+ * 
+ *         UVHandle._close(self)
+ */
+    ((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v_self->__pyx___cached_socket)->_fd = -1;
+
+    /* "uvloop/handles/handle.pyx":263
+ * 
+ *     cdef _close(self):
+ *         if self.__cached_socket is not None:             # <<<<<<<<<<<<<<
+ *             (<PseudoSocket>self.__cached_socket)._fd = -1
+ * 
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":266
+ *             (<PseudoSocket>self.__cached_socket)._fd = -1
+ * 
+ *         UVHandle._close(self)             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_8UVHandle__close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/handle.pyx":268
+ *         UVHandle._close(self)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             # This code will only run for transports created from
+ *             # Python sockets, i.e. with `loop.create_server(sock=sock)` etc.
+ */
+  /*try:*/ {
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      /*try:*/ {
+
+        /* "uvloop/handles/handle.pyx":271
+ *             # This code will only run for transports created from
+ *             # Python sockets, i.e. with `loop.create_server(sock=sock)` etc.
+ *             if self._fileobj is not None:             # <<<<<<<<<<<<<<
+ *                 if isinstance(self._fileobj, socket_socket):
+ *                     # Detaching the socket object is the ideal solution:
+ */
+        __pyx_t_2 = (__pyx_v_self->_fileobj != Py_None);
+        __pyx_t_1 = (__pyx_t_2 != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/handles/handle.pyx":272
+ *             # Python sockets, i.e. with `loop.create_server(sock=sock)` etc.
+ *             if self._fileobj is not None:
+ *                 if isinstance(self._fileobj, socket_socket):             # <<<<<<<<<<<<<<
+ *                     # Detaching the socket object is the ideal solution:
+ *                     # * libuv will actually close the FD;
+ */
+          __pyx_t_3 = __pyx_v_self->_fileobj;
+          __Pyx_INCREF(__pyx_t_3);
+          __pyx_t_7 = __pyx_v_6uvloop_4loop_socket_socket;
+          __Pyx_INCREF(__pyx_t_7);
+          __pyx_t_1 = PyObject_IsInstance(__pyx_t_3, __pyx_t_7); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 272, __pyx_L7_error)
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __pyx_t_2 = (__pyx_t_1 != 0);
+          if (__pyx_t_2) {
+
+            /* "uvloop/handles/handle.pyx":281
+ *                     # No need to call `socket_dec_io_ref()`, as
+ *                     # `socket.detach()` ignores `socket._io_refs`.
+ *                     self._fileobj.detach()             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     try:
+ */
+            __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_fileobj, __pyx_n_s_detach); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 281, __pyx_L7_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_8 = NULL;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+              __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3);
+              if (likely(__pyx_t_8)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                __Pyx_INCREF(__pyx_t_8);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_3, function);
+              }
+            }
+            __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+            __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+            if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 281, __pyx_L7_error)
+            __Pyx_GOTREF(__pyx_t_7);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+            /* "uvloop/handles/handle.pyx":272
+ *             # Python sockets, i.e. with `loop.create_server(sock=sock)` etc.
+ *             if self._fileobj is not None:
+ *                 if isinstance(self._fileobj, socket_socket):             # <<<<<<<<<<<<<<
+ *                     # Detaching the socket object is the ideal solution:
+ *                     # * libuv will actually close the FD;
+ */
+            goto __pyx_L14;
+          }
+
+          /* "uvloop/handles/handle.pyx":283
+ *                     self._fileobj.detach()
+ *                 else:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         # `socket.close()` will raise an EBADF because libuv
+ *                         # has already closed the underlying FD.
+ */
+          /*else*/ {
+            {
+              __Pyx_PyThreadState_declare
+              __Pyx_PyThreadState_assign
+              __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+              __Pyx_XGOTREF(__pyx_t_9);
+              __Pyx_XGOTREF(__pyx_t_10);
+              __Pyx_XGOTREF(__pyx_t_11);
+              /*try:*/ {
+
+                /* "uvloop/handles/handle.pyx":286
+ *                         # `socket.close()` will raise an EBADF because libuv
+ *                         # has already closed the underlying FD.
+ *                         self._fileobj.close()             # <<<<<<<<<<<<<<
+ *                     except OSError as ex:
+ *                         if ex.errno != errno_EBADF:
+ */
+                __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_fileobj, __pyx_n_s_close); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 286, __pyx_L15_error)
+                __Pyx_GOTREF(__pyx_t_3);
+                __pyx_t_8 = NULL;
+                if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+                  __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3);
+                  if (likely(__pyx_t_8)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                    __Pyx_INCREF(__pyx_t_8);
+                    __Pyx_INCREF(function);
+                    __Pyx_DECREF_SET(__pyx_t_3, function);
+                  }
+                }
+                __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+                __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+                if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 286, __pyx_L15_error)
+                __Pyx_GOTREF(__pyx_t_7);
+                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+                __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+                /* "uvloop/handles/handle.pyx":283
+ *                     self._fileobj.detach()
+ *                 else:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         # `socket.close()` will raise an EBADF because libuv
+ *                         # has already closed the underlying FD.
+ */
+              }
+              __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+              goto __pyx_L20_try_end;
+              __pyx_L15_error:;
+              __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+              __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+              /* "uvloop/handles/handle.pyx":287
+ *                         # has already closed the underlying FD.
+ *                         self._fileobj.close()
+ *                     except OSError as ex:             # <<<<<<<<<<<<<<
+ *                         if ex.errno != errno_EBADF:
+ *                             raise
+ */
+              __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
+              if (__pyx_t_12) {
+                __Pyx_AddTraceback("uvloop.loop.UVSocketHandle._close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+                if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_3, &__pyx_t_8) < 0) __PYX_ERR(2, 287, __pyx_L17_except_error)
+                __Pyx_GOTREF(__pyx_t_7);
+                __Pyx_GOTREF(__pyx_t_3);
+                __Pyx_GOTREF(__pyx_t_8);
+                __Pyx_INCREF(__pyx_t_3);
+                __pyx_v_ex = __pyx_t_3;
+                /*try:*/ {
+
+                  /* "uvloop/handles/handle.pyx":288
+ *                         self._fileobj.close()
+ *                     except OSError as ex:
+ *                         if ex.errno != errno_EBADF:             # <<<<<<<<<<<<<<
+ *                             raise
+ *         except Exception as ex:
+ */
+                  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_ex, __pyx_n_s_errno); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 288, __pyx_L26_error)
+                  __Pyx_GOTREF(__pyx_t_13);
+                  __pyx_t_14 = PyObject_RichCompare(__pyx_t_13, __pyx_v_6uvloop_4loop_errno_EBADF, Py_NE); __Pyx_XGOTREF(__pyx_t_14); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 288, __pyx_L26_error)
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_14); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 288, __pyx_L26_error)
+                  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+                  if (unlikely(__pyx_t_2)) {
+
+                    /* "uvloop/handles/handle.pyx":289
+ *                     except OSError as ex:
+ *                         if ex.errno != errno_EBADF:
+ *                             raise             # <<<<<<<<<<<<<<
+ *         except Exception as ex:
+ *             self._loop.call_exception_handler({
+ */
+                    __Pyx_GIVEREF(__pyx_t_7);
+                    __Pyx_GIVEREF(__pyx_t_3);
+                    __Pyx_XGIVEREF(__pyx_t_8);
+                    __Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_3, __pyx_t_8);
+                    __pyx_t_7 = 0; __pyx_t_3 = 0; __pyx_t_8 = 0; 
+                    __PYX_ERR(2, 289, __pyx_L26_error)
+
+                    /* "uvloop/handles/handle.pyx":288
+ *                         self._fileobj.close()
+ *                     except OSError as ex:
+ *                         if ex.errno != errno_EBADF:             # <<<<<<<<<<<<<<
+ *                             raise
+ *         except Exception as ex:
+ */
+                  }
+                }
+
+                /* "uvloop/handles/handle.pyx":287
+ *                         # has already closed the underlying FD.
+ *                         self._fileobj.close()
+ *                     except OSError as ex:             # <<<<<<<<<<<<<<
+ *                         if ex.errno != errno_EBADF:
+ *                             raise
+ */
+                /*finally:*/ {
+                  /*normal exit:*/{
+                    __Pyx_DECREF(__pyx_v_ex);
+                    __pyx_v_ex = NULL;
+                    goto __pyx_L27;
+                  }
+                  __pyx_L26_error:;
+                  /*exception exit:*/{
+                    __Pyx_PyThreadState_declare
+                    __Pyx_PyThreadState_assign
+                    __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+                    __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+                    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+                    if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
+                    if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+                    __Pyx_XGOTREF(__pyx_t_17);
+                    __Pyx_XGOTREF(__pyx_t_18);
+                    __Pyx_XGOTREF(__pyx_t_19);
+                    __Pyx_XGOTREF(__pyx_t_20);
+                    __Pyx_XGOTREF(__pyx_t_21);
+                    __Pyx_XGOTREF(__pyx_t_22);
+                    __pyx_t_12 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename;
+                    {
+                      __Pyx_DECREF(__pyx_v_ex);
+                      __pyx_v_ex = NULL;
+                    }
+                    if (PY_MAJOR_VERSION >= 3) {
+                      __Pyx_XGIVEREF(__pyx_t_20);
+                      __Pyx_XGIVEREF(__pyx_t_21);
+                      __Pyx_XGIVEREF(__pyx_t_22);
+                      __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
+                    }
+                    __Pyx_XGIVEREF(__pyx_t_17);
+                    __Pyx_XGIVEREF(__pyx_t_18);
+                    __Pyx_XGIVEREF(__pyx_t_19);
+                    __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+                    __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+                    __pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16;
+                    goto __pyx_L17_except_error;
+                  }
+                  __pyx_L27:;
+                }
+                __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+                __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+                __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+                goto __pyx_L16_exception_handled;
+              }
+              goto __pyx_L17_except_error;
+              __pyx_L17_except_error:;
+
+              /* "uvloop/handles/handle.pyx":283
+ *                     self._fileobj.detach()
+ *                 else:
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         # `socket.close()` will raise an EBADF because libuv
+ *                         # has already closed the underlying FD.
+ */
+              __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);
+              goto __pyx_L7_error;
+              __pyx_L16_exception_handled:;
+              __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_L20_try_end:;
+            }
+          }
+          __pyx_L14:;
+
+          /* "uvloop/handles/handle.pyx":271
+ *             # This code will only run for transports created from
+ *             # Python sockets, i.e. with `loop.create_server(sock=sock)` etc.
+ *             if self._fileobj is not None:             # <<<<<<<<<<<<<<
+ *                 if isinstance(self._fileobj, socket_socket):
+ *                     # Detaching the socket object is the ideal solution:
+ */
+        }
+
+        /* "uvloop/handles/handle.pyx":268
+ *         UVHandle._close(self)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             # This code will only run for transports created from
+ *             # Python sockets, i.e. with `loop.create_server(sock=sock)` etc.
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L12_try_end;
+      __pyx_L7_error:;
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "uvloop/handles/handle.pyx":290
+ *                         if ex.errno != errno_EBADF:
+ *                             raise
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._loop.call_exception_handler({
+ *                 'exception': ex,
+ */
+      __pyx_t_15 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+      if (__pyx_t_15) {
+        __Pyx_AddTraceback("uvloop.loop.UVSocketHandle._close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_3, &__pyx_t_7) < 0) __PYX_ERR(2, 290, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_XDECREF_SET(__pyx_v_ex, __pyx_t_3);
+        /*try:*/ {
+
+          /* "uvloop/handles/handle.pyx":291
+ *                             raise
+ *         except Exception as ex:
+ *             self._loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *                 'exception': ex,
+ *                 'transport': self,
+ */
+          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base._loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 291, __pyx_L38_error)
+          __Pyx_GOTREF(__pyx_t_13);
+
+          /* "uvloop/handles/handle.pyx":292
+ *         except Exception as ex:
+ *             self._loop.call_exception_handler({
+ *                 'exception': ex,             # <<<<<<<<<<<<<<
+ *                 'transport': self,
+ *                 'message': f'could not close attached file object '
+ */
+          __pyx_t_23 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_23)) __PYX_ERR(2, 292, __pyx_L38_error)
+          __Pyx_GOTREF(__pyx_t_23);
+          if (PyDict_SetItem(__pyx_t_23, __pyx_n_u_exception, __pyx_v_ex) < 0) __PYX_ERR(2, 292, __pyx_L38_error)
+
+          /* "uvloop/handles/handle.pyx":293
+ *             self._loop.call_exception_handler({
+ *                 'exception': ex,
+ *                 'transport': self,             # <<<<<<<<<<<<<<
+ *                 'message': f'could not close attached file object '
+ *                            f'{self._fileobj!r}',
+ */
+          if (PyDict_SetItem(__pyx_t_23, __pyx_n_u_transport, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(2, 292, __pyx_L38_error)
+
+          /* "uvloop/handles/handle.pyx":295
+ *                 'transport': self,
+ *                 'message': f'could not close attached file object '
+ *                            f'{self._fileobj!r}',             # <<<<<<<<<<<<<<
+ *             })
+ *         finally:
+ */
+          __pyx_t_24 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_self->_fileobj), __pyx_empty_unicode); if (unlikely(!__pyx_t_24)) __PYX_ERR(2, 295, __pyx_L38_error)
+          __Pyx_GOTREF(__pyx_t_24);
+
+          /* "uvloop/handles/handle.pyx":294
+ *                 'exception': ex,
+ *                 'transport': self,
+ *                 'message': f'could not close attached file object '             # <<<<<<<<<<<<<<
+ *                            f'{self._fileobj!r}',
+ *             })
+ */
+          __pyx_t_25 = __Pyx_PyUnicode_Concat(__pyx_kp_u_could_not_close_attached_file_ob, __pyx_t_24); if (unlikely(!__pyx_t_25)) __PYX_ERR(2, 294, __pyx_L38_error)
+          __Pyx_GOTREF(__pyx_t_25);
+          __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
+          if (PyDict_SetItem(__pyx_t_23, __pyx_n_u_message, __pyx_t_25) < 0) __PYX_ERR(2, 292, __pyx_L38_error)
+          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
+          __pyx_t_25 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) {
+            __pyx_t_25 = PyMethod_GET_SELF(__pyx_t_13);
+            if (likely(__pyx_t_25)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+              __Pyx_INCREF(__pyx_t_25);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_13, function);
+            }
+          }
+          __pyx_t_14 = (__pyx_t_25) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_25, __pyx_t_23) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_23);
+          __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
+          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
+          if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 291, __pyx_L38_error)
+          __Pyx_GOTREF(__pyx_t_14);
+          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+        }
+
+        /* "uvloop/handles/handle.pyx":290
+ *                         if ex.errno != errno_EBADF:
+ *                             raise
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._loop.call_exception_handler({
+ *                 'exception': ex,
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L39;
+          }
+          __pyx_L38_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_22 = 0; __pyx_t_21 = 0; __pyx_t_20 = 0;
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+            __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
+            __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
+            __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_22, &__pyx_t_21, &__pyx_t_20);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9);
+            __Pyx_XGOTREF(__pyx_t_11);
+            __Pyx_XGOTREF(__pyx_t_10);
+            __Pyx_XGOTREF(__pyx_t_9);
+            __Pyx_XGOTREF(__pyx_t_22);
+            __Pyx_XGOTREF(__pyx_t_21);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __pyx_t_15 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_26 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_22);
+              __Pyx_XGIVEREF(__pyx_t_21);
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_ExceptionReset(__pyx_t_22, __pyx_t_21, __pyx_t_20);
+            }
+            __Pyx_XGIVEREF(__pyx_t_11);
+            __Pyx_XGIVEREF(__pyx_t_10);
+            __Pyx_XGIVEREF(__pyx_t_9);
+            __Pyx_ErrRestore(__pyx_t_11, __pyx_t_10, __pyx_t_9);
+            __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_22 = 0; __pyx_t_21 = 0; __pyx_t_20 = 0;
+            __pyx_lineno = __pyx_t_15; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_26;
+            goto __pyx_L9_except_error;
+          }
+          __pyx_L39:;
+        }
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L8_exception_handled;
+      }
+      goto __pyx_L9_except_error;
+      __pyx_L9_except_error:;
+
+      /* "uvloop/handles/handle.pyx":268
+ *         UVHandle._close(self)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             # This code will only run for transports created from
+ *             # Python sockets, i.e. with `loop.create_server(sock=sock)` etc.
+ */
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      goto __pyx_L5_error;
+      __pyx_L8_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      __pyx_L12_try_end:;
+    }
+  }
+
+  /* "uvloop/handles/handle.pyx":298
+ *             })
+ *         finally:
+ *             self._fileobj = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _open(self, int sockfd):
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __Pyx_INCREF(Py_None);
+      __Pyx_GIVEREF(Py_None);
+      __Pyx_GOTREF(__pyx_v_self->_fileobj);
+      __Pyx_DECREF(__pyx_v_self->_fileobj);
+      __pyx_v_self->_fileobj = Py_None;
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
+      __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
+      __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4) < 0)) __Pyx_ErrFetch(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_20);
+      __Pyx_XGOTREF(__pyx_t_21);
+      __Pyx_XGOTREF(__pyx_t_22);
+      __pyx_t_12 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_27 = __pyx_filename;
+      {
+        __Pyx_INCREF(Py_None);
+        __Pyx_GIVEREF(Py_None);
+        __Pyx_GOTREF(__pyx_v_self->_fileobj);
+        __Pyx_DECREF(__pyx_v_self->_fileobj);
+        __pyx_v_self->_fileobj = Py_None;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_20);
+        __Pyx_XGIVEREF(__pyx_t_21);
+        __Pyx_XGIVEREF(__pyx_t_22);
+        __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
+      }
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ErrRestore(__pyx_t_6, __pyx_t_5, __pyx_t_4);
+      __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+      __pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_27;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/handles/handle.pyx":262
+ *         self._fileobj = file
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         if self.__cached_socket is not None:
+ *             (<PseudoSocket>self.__cached_socket)._fd = -1
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_XDECREF(__pyx_t_23);
+  __Pyx_XDECREF(__pyx_t_24);
+  __Pyx_XDECREF(__pyx_t_25);
+  __Pyx_AddTraceback("uvloop.loop.UVSocketHandle._close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":300
+ *             self._fileobj = None
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__open(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self, CYTHON_UNUSED int __pyx_v_sockfd) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_open", 0);
+
+  /* "uvloop/handles/handle.pyx":301
+ * 
+ *     cdef _open(self, int sockfd):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(2, 301, __pyx_L1_error)
+
+  /* "uvloop/handles/handle.pyx":300
+ *             self._fileobj = None
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVSocketHandle._open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_14UVSocketHandle_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_14UVSocketHandle_2__reduce_cython__[] = "UVSocketHandle.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_14UVSocketHandle_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_6uvloop_4loop_14UVSocketHandle_2__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_14UVSocketHandle_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__117, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVSocketHandle.__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_6uvloop_4loop_14UVSocketHandle_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_14UVSocketHandle_4__setstate_cython__[] = "UVSocketHandle.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_14UVSocketHandle_5__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_6uvloop_4loop_14UVSocketHandle_4__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_14UVSocketHandle_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__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);
+
+  /* "(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__118, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVSocketHandle.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":304
+ * 
+ * 
+ * cdef inline bint __ensure_handle_data(uv.uv_handle_t* handle,             # <<<<<<<<<<<<<<
+ *                                       const char* handle_ctx):
+ * 
+ */
+
+static CYTHON_INLINE int __pyx_f_6uvloop_4loop___ensure_handle_data(uv_handle_t *__pyx_v_handle, char const *__pyx_v_handle_ctx) {
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  int __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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__ensure_handle_data", 0);
+
+  /* "uvloop/handles/handle.pyx":309
+ *     cdef Loop loop
+ * 
+ *     if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *         if handle.loop is NULL:
+ *             raise RuntimeError(
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":310
+ * 
+ *     if UVLOOP_DEBUG:
+ *         if handle.loop is NULL:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'handle.loop is NULL in __ensure_handle_data')
+ */
+    __pyx_t_1 = ((__pyx_v_handle->loop == NULL) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/handles/handle.pyx":311
+ *     if UVLOOP_DEBUG:
+ *         if handle.loop is NULL:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'handle.loop is NULL in __ensure_handle_data')
+ * 
+ */
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__119, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 311, __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(2, 311, __pyx_L1_error)
+
+      /* "uvloop/handles/handle.pyx":310
+ * 
+ *     if UVLOOP_DEBUG:
+ *         if handle.loop is NULL:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'handle.loop is NULL in __ensure_handle_data')
+ */
+    }
+
+    /* "uvloop/handles/handle.pyx":314
+ *                 'handle.loop is NULL in __ensure_handle_data')
+ * 
+ *         if handle.loop.data is NULL:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'handle.loop.data is NULL in __ensure_handle_data')
+ */
+    __pyx_t_1 = ((__pyx_v_handle->loop->data == NULL) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/handles/handle.pyx":315
+ * 
+ *         if handle.loop.data is NULL:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'handle.loop.data is NULL in __ensure_handle_data')
+ * 
+ */
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__120, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 315, __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(2, 315, __pyx_L1_error)
+
+      /* "uvloop/handles/handle.pyx":314
+ *                 'handle.loop is NULL in __ensure_handle_data')
+ * 
+ *         if handle.loop.data is NULL:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'handle.loop.data is NULL in __ensure_handle_data')
+ */
+    }
+
+    /* "uvloop/handles/handle.pyx":309
+ *     cdef Loop loop
+ * 
+ *     if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *         if handle.loop is NULL:
+ *             raise RuntimeError(
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":318
+ *                 'handle.loop.data is NULL in __ensure_handle_data')
+ * 
+ *     if handle.data is NULL:             # <<<<<<<<<<<<<<
+ *         loop = <Loop>handle.loop.data
+ *         loop.call_exception_handler({
+ */
+  __pyx_t_1 = ((__pyx_v_handle->data == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":319
+ * 
+ *     if handle.data is NULL:
+ *         loop = <Loop>handle.loop.data             # <<<<<<<<<<<<<<
+ *         loop.call_exception_handler({
+ *             'message': '{} called with handle.data == NULL'.format(
+ */
+    __pyx_t_2 = ((PyObject *)__pyx_v_handle->loop->data);
+    __Pyx_INCREF(__pyx_t_2);
+    __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/handle.pyx":320
+ *     if handle.data is NULL:
+ *         loop = <Loop>handle.loop.data
+ *         loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *             'message': '{} called with handle.data == NULL'.format(
+ *                 handle_ctx.decode('latin-1'))
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 320, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/handles/handle.pyx":321
+ *         loop = <Loop>handle.loop.data
+ *         loop.call_exception_handler({
+ *             'message': '{} called with handle.data == NULL'.format(             # <<<<<<<<<<<<<<
+ *                 handle_ctx.decode('latin-1'))
+ *         })
+ */
+    __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 321, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_called_with_handle_data_NULL, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 321, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+
+    /* "uvloop/handles/handle.pyx":322
+ *         loop.call_exception_handler({
+ *             'message': '{} called with handle.data == NULL'.format(
+ *                 handle_ctx.decode('latin-1'))             # <<<<<<<<<<<<<<
+ *         })
+ *         return 0
+ */
+    __pyx_t_7 = __Pyx_decode_c_string(__pyx_v_handle_ctx, 0, strlen(__pyx_v_handle_ctx), NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 322, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_6, function);
+      }
+    }
+    __pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7);
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 321, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_u_message, __pyx_t_5) < 0) __PYX_ERR(2, 321, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3, function);
+      }
+    }
+    __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(2, 320, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/handle.pyx":324
+ *                 handle_ctx.decode('latin-1'))
+ *         })
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ *     if handle.data is NULL:
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/handle.pyx":318
+ *                 'handle.loop.data is NULL in __ensure_handle_data')
+ * 
+ *     if handle.data is NULL:             # <<<<<<<<<<<<<<
+ *         loop = <Loop>handle.loop.data
+ *         loop.call_exception_handler({
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":326
+ *         return 0
+ * 
+ *     if handle.data is NULL:             # <<<<<<<<<<<<<<
+ *         # The underlying UVHandle object was GCed with an open uv_handle_t.
+ *         loop = <Loop>handle.loop.data
+ */
+  __pyx_t_1 = ((__pyx_v_handle->data == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":328
+ *     if handle.data is NULL:
+ *         # The underlying UVHandle object was GCed with an open uv_handle_t.
+ *         loop = <Loop>handle.loop.data             # <<<<<<<<<<<<<<
+ *         loop.call_exception_handler({
+ *             'message': '{} called after destroying the UVHandle'.format(
+ */
+    __pyx_t_2 = ((PyObject *)__pyx_v_handle->loop->data);
+    __Pyx_INCREF(__pyx_t_2);
+    __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/handle.pyx":329
+ *         # The underlying UVHandle object was GCed with an open uv_handle_t.
+ *         loop = <Loop>handle.loop.data
+ *         loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *             'message': '{} called after destroying the UVHandle'.format(
+ *                 handle_ctx.decode('latin-1'))
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 329, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/handles/handle.pyx":330
+ *         loop = <Loop>handle.loop.data
+ *         loop.call_exception_handler({
+ *             'message': '{} called after destroying the UVHandle'.format(             # <<<<<<<<<<<<<<
+ *                 handle_ctx.decode('latin-1'))
+ *         })
+ */
+    __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 330, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_called_after_destroying_the_UVH, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 330, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+
+    /* "uvloop/handles/handle.pyx":331
+ *         loop.call_exception_handler({
+ *             'message': '{} called after destroying the UVHandle'.format(
+ *                 handle_ctx.decode('latin-1'))             # <<<<<<<<<<<<<<
+ *         })
+ *         return 0
+ */
+    __pyx_t_7 = __Pyx_decode_c_string(__pyx_v_handle_ctx, 0, strlen(__pyx_v_handle_ctx), NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 331, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_6, function);
+      }
+    }
+    __pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7);
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 330, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_u_message, __pyx_t_5) < 0) __PYX_ERR(2, 330, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3, function);
+      }
+    }
+    __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(2, 329, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/handle.pyx":333
+ *                 handle_ctx.decode('latin-1'))
+ *         })
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ *     return 1
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/handle.pyx":326
+ *         return 0
+ * 
+ *     if handle.data is NULL:             # <<<<<<<<<<<<<<
+ *         # The underlying UVHandle object was GCed with an open uv_handle_t.
+ *         loop = <Loop>handle.loop.data
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":335
+ *         return 0
+ * 
+ *     return 1             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = 1;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/handle.pyx":304
+ * 
+ * 
+ * cdef inline bint __ensure_handle_data(uv.uv_handle_t* handle,             # <<<<<<<<<<<<<<
+ *                                       const char* handle_ctx):
+ * 
+ */
+
+  /* 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_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_WriteUnraisable("uvloop.loop.__ensure_handle_data", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_loop);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/handle.pyx":338
+ * 
+ * 
+ * cdef void __uv_close_handle_cb(uv.uv_handle_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     cdef UVHandle h
+ * 
+ */
+
+static void __pyx_f_6uvloop_4loop___uv_close_handle_cb(uv_handle_t *__pyx_v_handle) {
+  struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_h = 0;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  char const *__pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uv_close_handle_cb", 0);
+
+  /* "uvloop/handles/handle.pyx":341
+ *     cdef UVHandle h
+ * 
+ *     if handle.data is NULL:             # <<<<<<<<<<<<<<
+ *         # The original UVHandle is long dead. Just free the mem of
+ *         # the uv_handle_t* handler.
+ */
+  __pyx_t_1 = ((__pyx_v_handle->data == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/handle.pyx":345
+ *         # the uv_handle_t* handler.
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if handle.loop == NULL or handle.loop.data == NULL:
+ *                 raise RuntimeError(
+ */
+    __pyx_t_1 = (UVLOOP_DEBUG != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/handle.pyx":346
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if handle.loop == NULL or handle.loop.data == NULL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '__uv_close_handle_cb: handle.loop is invalid')
+ */
+      __pyx_t_2 = ((__pyx_v_handle->loop == NULL) != 0);
+      if (!__pyx_t_2) {
+      } else {
+        __pyx_t_1 = __pyx_t_2;
+        goto __pyx_L6_bool_binop_done;
+      }
+      __pyx_t_2 = ((__pyx_v_handle->loop->data == NULL) != 0);
+      __pyx_t_1 = __pyx_t_2;
+      __pyx_L6_bool_binop_done:;
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/handles/handle.pyx":347
+ *         if UVLOOP_DEBUG:
+ *             if handle.loop == NULL or handle.loop.data == NULL:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     '__uv_close_handle_cb: handle.loop is invalid')
+ *             (<Loop>handle.loop.data)._debug_uv_handles_freed += 1
+ */
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__121, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 347, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(2, 347, __pyx_L1_error)
+
+        /* "uvloop/handles/handle.pyx":346
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if handle.loop == NULL or handle.loop.data == NULL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '__uv_close_handle_cb: handle.loop is invalid')
+ */
+      }
+
+      /* "uvloop/handles/handle.pyx":349
+ *                 raise RuntimeError(
+ *                     '__uv_close_handle_cb: handle.loop is invalid')
+ *             (<Loop>handle.loop.data)._debug_uv_handles_freed += 1             # <<<<<<<<<<<<<<
+ * 
+ *         PyMem_RawFree(handle)
+ */
+      __Pyx_INCREF(((PyObject *)((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_handle->loop->data)));
+      __pyx_t_4 = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_handle->loop->data);
+      __pyx_t_4->_debug_uv_handles_freed = (__pyx_t_4->_debug_uv_handles_freed + 1);
+      __Pyx_DECREF(((PyObject *)__pyx_t_4)); __pyx_t_4 = 0;
+
+      /* "uvloop/handles/handle.pyx":345
+ *         # the uv_handle_t* handler.
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if handle.loop == NULL or handle.loop.data == NULL:
+ *                 raise RuntimeError(
+ */
+    }
+
+    /* "uvloop/handles/handle.pyx":351
+ *             (<Loop>handle.loop.data)._debug_uv_handles_freed += 1
+ * 
+ *         PyMem_RawFree(handle)             # <<<<<<<<<<<<<<
+ *     else:
+ *         h = <UVHandle>handle.data
+ */
+    PyMem_RawFree(__pyx_v_handle);
+
+    /* "uvloop/handles/handle.pyx":341
+ *     cdef UVHandle h
+ * 
+ *     if handle.data is NULL:             # <<<<<<<<<<<<<<
+ *         # The original UVHandle is long dead. Just free the mem of
+ *         # the uv_handle_t* handler.
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/handle.pyx":353
+ *         PyMem_RawFree(handle)
+ *     else:
+ *         h = <UVHandle>handle.data             # <<<<<<<<<<<<<<
+ *         try:
+ *             if UVLOOP_DEBUG:
+ */
+  /*else*/ {
+    __pyx_t_3 = ((PyObject *)__pyx_v_handle->data);
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_v_h = ((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/handles/handle.pyx":354
+ *     else:
+ *         h = <UVHandle>handle.data
+ *         try:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 if not h._has_handle:
+ */
+    /*try:*/ {
+
+      /* "uvloop/handles/handle.pyx":355
+ *         h = <UVHandle>handle.data
+ *         try:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 if not h._has_handle:
+ *                     raise RuntimeError(
+ */
+      __pyx_t_1 = (UVLOOP_DEBUG != 0);
+      if (__pyx_t_1) {
+
+        /* "uvloop/handles/handle.pyx":356
+ *         try:
+ *             if UVLOOP_DEBUG:
+ *                 if not h._has_handle:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         'has_handle=0 in __uv_close_handle_cb')
+ */
+        __pyx_t_1 = ((!(__pyx_v_h->_has_handle != 0)) != 0);
+        if (unlikely(__pyx_t_1)) {
+
+          /* "uvloop/handles/handle.pyx":357
+ *             if UVLOOP_DEBUG:
+ *                 if not h._has_handle:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         'has_handle=0 in __uv_close_handle_cb')
+ *                 h._loop._debug_handles_closed.update([
+ */
+          __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__122, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 357, __pyx_L9_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __PYX_ERR(2, 357, __pyx_L9_error)
+
+          /* "uvloop/handles/handle.pyx":356
+ *         try:
+ *             if UVLOOP_DEBUG:
+ *                 if not h._has_handle:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         'has_handle=0 in __uv_close_handle_cb')
+ */
+        }
+
+        /* "uvloop/handles/handle.pyx":359
+ *                     raise RuntimeError(
+ *                         'has_handle=0 in __uv_close_handle_cb')
+ *                 h._loop._debug_handles_closed.update([             # <<<<<<<<<<<<<<
+ *                     h.__class__.__name__])
+ *             h._free()
+ */
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_h->_loop->_debug_handles_closed, __pyx_n_s_update); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 359, __pyx_L9_error)
+        __Pyx_GOTREF(__pyx_t_5);
+
+        /* "uvloop/handles/handle.pyx":360
+ *                         'has_handle=0 in __uv_close_handle_cb')
+ *                 h._loop._debug_handles_closed.update([
+ *                     h.__class__.__name__])             # <<<<<<<<<<<<<<
+ *             h._free()
+ *         finally:
+ */
+        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_h), __pyx_n_s_class); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 360, __pyx_L9_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_name); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 360, __pyx_L9_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+        /* "uvloop/handles/handle.pyx":359
+ *                     raise RuntimeError(
+ *                         'has_handle=0 in __uv_close_handle_cb')
+ *                 h._loop._debug_handles_closed.update([             # <<<<<<<<<<<<<<
+ *                     h.__class__.__name__])
+ *             h._free()
+ */
+        __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 359, __pyx_L9_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GIVEREF(__pyx_t_7);
+        PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_7);
+        __pyx_t_7 = 0;
+        __pyx_t_7 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(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_5, function);
+          }
+        }
+        __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6);
+        __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(2, 359, __pyx_L9_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/handles/handle.pyx":355
+ *         h = <UVHandle>handle.data
+ *         try:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 if not h._has_handle:
+ *                     raise RuntimeError(
+ */
+      }
+
+      /* "uvloop/handles/handle.pyx":361
+ *                 h._loop._debug_handles_closed.update([
+ *                     h.__class__.__name__])
+ *             h._free()             # <<<<<<<<<<<<<<
+ *         finally:
+ *             Py_DECREF(h)  # Was INCREFed in UVHandle._close
+ */
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *)__pyx_v_h->__pyx_vtab)->_free(__pyx_v_h); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 361, __pyx_L9_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+
+    /* "uvloop/handles/handle.pyx":363
+ *             h._free()
+ *         finally:
+ *             Py_DECREF(h)  # Was INCREFed in UVHandle._close             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    /*finally:*/ {
+      /*normal exit:*/{
+        Py_DECREF(((PyObject *)__pyx_v_h));
+        goto __pyx_L10;
+      }
+      __pyx_L9_error:;
+      /*exception exit:*/{
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_XDECREF(((PyObject *)__pyx_t_4)); __pyx_t_4 = 0;
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+        if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+        __Pyx_XGOTREF(__pyx_t_11);
+        __Pyx_XGOTREF(__pyx_t_12);
+        __Pyx_XGOTREF(__pyx_t_13);
+        __Pyx_XGOTREF(__pyx_t_14);
+        __Pyx_XGOTREF(__pyx_t_15);
+        __Pyx_XGOTREF(__pyx_t_16);
+        __pyx_t_8 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename;
+        {
+          Py_DECREF(((PyObject *)__pyx_v_h));
+        }
+        if (PY_MAJOR_VERSION >= 3) {
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+        }
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+        __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+        __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10;
+        goto __pyx_L1_error;
+      }
+      __pyx_L10:;
+    }
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/handle.pyx":338
+ * 
+ * 
+ * cdef void __uv_close_handle_cb(uv.uv_handle_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     cdef UVHandle h
+ * 
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(((PyObject *)__pyx_t_4));
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_WriteUnraisable("uvloop.loop.__uv_close_handle_cb", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_h);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/handle.pyx":366
+ * 
+ * 
+ * cdef void __close_all_handles(Loop loop):             # <<<<<<<<<<<<<<
+ *     uv.uv_walk(loop.uvloop,
+ *                __uv_walk_close_all_handles_cb,
+ */
+
+static void __pyx_f_6uvloop_4loop___close_all_handles(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__close_all_handles", 0);
+
+  /* "uvloop/handles/handle.pyx":367
+ * 
+ * cdef void __close_all_handles(Loop loop):
+ *     uv.uv_walk(loop.uvloop,             # <<<<<<<<<<<<<<
+ *                __uv_walk_close_all_handles_cb,
+ *                <void*>loop)  # void
+ */
+  uv_walk(__pyx_v_loop->uvloop, __pyx_f_6uvloop_4loop___uv_walk_close_all_handles_cb, ((void *)__pyx_v_loop));
+
+  /* "uvloop/handles/handle.pyx":366
+ * 
+ * 
+ * cdef void __close_all_handles(Loop loop):             # <<<<<<<<<<<<<<
+ *     uv.uv_walk(loop.uvloop,
+ *                __uv_walk_close_all_handles_cb,
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/handles/handle.pyx":372
+ * 
+ * 
+ * cdef void __uv_walk_close_all_handles_cb(             # <<<<<<<<<<<<<<
+ *         uv.uv_handle_t* handle, void* arg) with gil:
+ * 
+ */
+
+static void __pyx_f_6uvloop_4loop___uv_walk_close_all_handles_cb(uv_handle_t *__pyx_v_handle, void *__pyx_v_arg) {
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_h = 0;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  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;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uv_walk_close_all_handles_cb", 0);
+
+  /* "uvloop/handles/handle.pyx":376
+ * 
+ *     cdef:
+ *         Loop loop = <Loop>arg             # <<<<<<<<<<<<<<
+ *         UVHandle h
+ * 
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_arg);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/handle.pyx":379
+ *         UVHandle h
+ * 
+ *     if uv.uv_is_closing(handle):             # <<<<<<<<<<<<<<
+ *         # The handle is closed or is closing.
+ *         return
+ */
+  __pyx_t_2 = (uv_is_closing(__pyx_v_handle) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/handle.pyx":381
+ *     if uv.uv_is_closing(handle):
+ *         # The handle is closed or is closing.
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     if handle.data is NULL:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/handle.pyx":379
+ *         UVHandle h
+ * 
+ *     if uv.uv_is_closing(handle):             # <<<<<<<<<<<<<<
+ *         # The handle is closed or is closing.
+ *         return
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":383
+ *         return
+ * 
+ *     if handle.data is NULL:             # <<<<<<<<<<<<<<
+ *         # This shouldn't happen. Ever.
+ *         loop.call_exception_handler({
+ */
+  __pyx_t_2 = ((__pyx_v_handle->data == NULL) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/handle.pyx":385
+ *     if handle.data is NULL:
+ *         # This shouldn't happen. Ever.
+ *         loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *             'message': 'handle.data is NULL in __close_all_handles_cb'
+ *         })
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 385, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/handles/handle.pyx":386
+ *         # This shouldn't happen. Ever.
+ *         loop.call_exception_handler({
+ *             'message': 'handle.data is NULL in __close_all_handles_cb'             # <<<<<<<<<<<<<<
+ *         })
+ *         return
+ */
+    __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 386, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_u_message, __pyx_kp_u_handle_data_is_NULL_in___close_a) < 0) __PYX_ERR(2, 386, __pyx_L1_error)
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3, function);
+      }
+    }
+    __pyx_t_1 = (__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_1)) __PYX_ERR(2, 385, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/handle.pyx":388
+ *             'message': 'handle.data is NULL in __close_all_handles_cb'
+ *         })
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     h = <UVHandle>handle.data
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/handle.pyx":383
+ *         return
+ * 
+ *     if handle.data is NULL:             # <<<<<<<<<<<<<<
+ *         # This shouldn't happen. Ever.
+ *         loop.call_exception_handler({
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":390
+ *         return
+ * 
+ *     h = <UVHandle>handle.data             # <<<<<<<<<<<<<<
+ *     if not h._closed:
+ *         h._warn_unclosed()
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_handle->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_h = ((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/handle.pyx":391
+ * 
+ *     h = <UVHandle>handle.data
+ *     if not h._closed:             # <<<<<<<<<<<<<<
+ *         h._warn_unclosed()
+ *         h._close()
+ */
+  __pyx_t_2 = ((!(__pyx_v_h->_closed != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/handle.pyx":392
+ *     h = <UVHandle>handle.data
+ *     if not h._closed:
+ *         h._warn_unclosed()             # <<<<<<<<<<<<<<
+ *         h._close()
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *)__pyx_v_h->__pyx_vtab)->_warn_unclosed(__pyx_v_h); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 392, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/handle.pyx":393
+ *     if not h._closed:
+ *         h._warn_unclosed()
+ *         h._close()             # <<<<<<<<<<<<<<
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *)__pyx_v_h->__pyx_vtab)->_close(__pyx_v_h); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 393, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/handle.pyx":391
+ * 
+ *     h = <UVHandle>handle.data
+ *     if not h._closed:             # <<<<<<<<<<<<<<
+ *         h._warn_unclosed()
+ *         h._close()
+ */
+  }
+
+  /* "uvloop/handles/handle.pyx":372
+ * 
+ * 
+ * cdef void __uv_walk_close_all_handles_cb(             # <<<<<<<<<<<<<<
+ *         uv.uv_handle_t* handle, void* arg) with gil:
+ * 
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_WriteUnraisable("uvloop.loop.__uv_walk_close_all_handles_cb", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_loop);
+  __Pyx_XDECREF((PyObject *)__pyx_v_h);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/async_.pyx":3
+ * @cython.no_gc_clear
+ * cdef class UVAsync(UVHandle):
+ *     cdef _init(self, Loop loop, method_t callback, object ctx):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_7UVAsync__init(struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx) {
+  int __pyx_v_err;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init", 0);
+
+  /* "uvloop/handles/async_.pyx":6
+ *         cdef int err
+ * 
+ *         self._start_init(loop)             # <<<<<<<<<<<<<<
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_async_t))
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._start_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/async_.pyx":8
+ *         self._start_init(loop)
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_async_t))             # <<<<<<<<<<<<<<
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ */
+  __pyx_v_self->__pyx_base._handle = ((uv_handle_t *)PyMem_RawMalloc((sizeof(uv_async_t))));
+
+  /* "uvloop/handles/async_.pyx":9
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_async_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  __pyx_t_2 = ((__pyx_v_self->__pyx_base._handle == NULL) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/async_.pyx":10
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_async_t))
+ *         if self._handle is NULL:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 10, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/async_.pyx":11
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_async_init(self._loop.uvloop,
+ */
+    PyErr_NoMemory(); __PYX_ERR(11, 11, __pyx_L1_error)
+
+    /* "uvloop/handles/async_.pyx":9
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_async_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  }
+
+  /* "uvloop/handles/async_.pyx":13
+ *             raise MemoryError()
+ * 
+ *         err = uv.uv_async_init(self._loop.uvloop,             # <<<<<<<<<<<<<<
+ *                                <uv.uv_async_t*>self._handle,
+ *                                __uvasync_callback)
+ */
+  __pyx_v_err = uv_async_init(__pyx_v_self->__pyx_base._loop->uvloop, ((uv_async_t *)__pyx_v_self->__pyx_base._handle), __pyx_f_6uvloop_4loop___uvasync_callback);
+
+  /* "uvloop/handles/async_.pyx":16
+ *                                <uv.uv_async_t*>self._handle,
+ *                                __uvasync_callback)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/async_.pyx":17
+ *                                __uvasync_callback)
+ *         if err < 0:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 17, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/async_.pyx":18
+ *         if err < 0:
+ *             self._abort_init()
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         self._finish_init()
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 18, __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(11, 18, __pyx_L1_error)
+
+    /* "uvloop/handles/async_.pyx":16
+ *                                <uv.uv_async_t*>self._handle,
+ *                                __uvasync_callback)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  }
+
+  /* "uvloop/handles/async_.pyx":20
+ *             raise convert_error(err)
+ * 
+ *         self._finish_init()             # <<<<<<<<<<<<<<
+ * 
+ *         self.callback = callback
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._finish_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/async_.pyx":22
+ *         self._finish_init()
+ * 
+ *         self.callback = callback             # <<<<<<<<<<<<<<
+ *         self.ctx = ctx
+ * 
+ */
+  __pyx_v_self->callback = __pyx_v_callback;
+
+  /* "uvloop/handles/async_.pyx":23
+ * 
+ *         self.callback = callback
+ *         self.ctx = ctx             # <<<<<<<<<<<<<<
+ * 
+ *     cdef send(self):
+ */
+  __Pyx_INCREF(__pyx_v_ctx);
+  __Pyx_GIVEREF(__pyx_v_ctx);
+  __Pyx_GOTREF(__pyx_v_self->ctx);
+  __Pyx_DECREF(__pyx_v_self->ctx);
+  __pyx_v_self->ctx = __pyx_v_ctx;
+
+  /* "uvloop/handles/async_.pyx":3
+ * @cython.no_gc_clear
+ * cdef class UVAsync(UVHandle):
+ *     cdef _init(self, Loop loop, method_t callback, object ctx):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVAsync._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/async_.pyx":25
+ *         self.ctx = ctx
+ * 
+ *     cdef send(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_7UVAsync_send(struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("send", 0);
+
+  /* "uvloop/handles/async_.pyx":28
+ *         cdef int err
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_async_send(<uv.uv_async_t*>self._handle)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/async_.pyx":30
+ *         self._ensure_alive()
+ * 
+ *         err = uv.uv_async_send(<uv.uv_async_t*>self._handle)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             exc = convert_error(err)
+ */
+  __pyx_v_err = uv_async_send(((uv_async_t *)__pyx_v_self->__pyx_base._handle));
+
+  /* "uvloop/handles/async_.pyx":31
+ * 
+ *         err = uv.uv_async_send(<uv.uv_async_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/async_.pyx":32
+ *         err = uv.uv_async_send(<uv.uv_async_t*>self._handle)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 32, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/async_.pyx":33
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 33, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/async_.pyx":34
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/async_.pyx":31
+ * 
+ *         err = uv.uv_async_send(<uv.uv_async_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  }
+
+  /* "uvloop/handles/async_.pyx":25
+ *         self.ctx = ctx
+ * 
+ *     cdef send(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVAsync.send", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/async_.pyx":37
+ * 
+ *     @staticmethod
+ *     cdef UVAsync new(Loop loop, method_t callback, object ctx):             # <<<<<<<<<<<<<<
+ *         cdef UVAsync handle
+ *         handle = UVAsync.__new__(UVAsync)
+ */
+
+static struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_f_6uvloop_4loop_7UVAsync_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx) {
+  struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_v_handle = 0;
+  struct __pyx_obj_6uvloop_4loop_UVAsync *__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("new", 0);
+
+  /* "uvloop/handles/async_.pyx":39
+ *     cdef UVAsync new(Loop loop, method_t callback, object ctx):
+ *         cdef UVAsync handle
+ *         handle = UVAsync.__new__(UVAsync)             # <<<<<<<<<<<<<<
+ *         handle._init(loop, callback, ctx)
+ *         return handle
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UVAsync(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UVAsync), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 39, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_UVAsync *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/async_.pyx":40
+ *         cdef UVAsync handle
+ *         handle = UVAsync.__new__(UVAsync)
+ *         handle._init(loop, callback, ctx)             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_handle->__pyx_base.__pyx_vtab)->_init(__pyx_v_handle, __pyx_v_loop, __pyx_v_callback, __pyx_v_ctx); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/async_.pyx":41
+ *         handle = UVAsync.__new__(UVAsync)
+ *         handle._init(loop, callback, ctx)
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/async_.pyx":37
+ * 
+ *     @staticmethod
+ *     cdef UVAsync new(Loop loop, method_t callback, object ctx):             # <<<<<<<<<<<<<<
+ *         cdef UVAsync handle
+ *         handle = UVAsync.__new__(UVAsync)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVAsync.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF((PyObject *)__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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_7UVAsync_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_7UVAsync___reduce_cython__[] = "UVAsync.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_7UVAsync_1__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_6uvloop_4loop_7UVAsync___reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVAsync *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_7UVAsync___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVAsync *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__123, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVAsync.__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_6uvloop_4loop_7UVAsync_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_7UVAsync_2__setstate_cython__[] = "UVAsync.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_7UVAsync_3__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_6uvloop_4loop_7UVAsync_2__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVAsync *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_7UVAsync_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVAsync *__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);
+
+  /* "(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__124, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVAsync.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/async_.pyx":44
+ * 
+ * 
+ * cdef void __uvasync_callback(uv.uv_async_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVAsync callback") == 0:
+ *         return
+ */
+
+static void __pyx_f_6uvloop_4loop___uvasync_callback(uv_async_t *__pyx_v_handle) {
+  struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_v_async_ = 0;
+  __pyx_t_6uvloop_4loop_method_t __pyx_v_cb;
+  PyObject *__pyx_v_ex = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  __pyx_t_6uvloop_4loop_method_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  char const *__pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uvasync_callback", 0);
+
+  /* "uvloop/handles/async_.pyx":45
+ * 
+ * cdef void __uvasync_callback(uv.uv_async_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVAsync callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_f_6uvloop_4loop___ensure_handle_data(((uv_handle_t *)__pyx_v_handle), ((char const *)"UVAsync callback")) == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/async_.pyx":46
+ * cdef void __uvasync_callback(uv.uv_async_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVAsync callback") == 0:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/async_.pyx":45
+ * 
+ * cdef void __uvasync_callback(uv.uv_async_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVAsync callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/async_.pyx":49
+ * 
+ *     cdef:
+ *         UVAsync async_ = <UVAsync> handle.data             # <<<<<<<<<<<<<<
+ *         method_t cb = async_.callback
+ *     try:
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_handle->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_async_ = ((struct __pyx_obj_6uvloop_4loop_UVAsync *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/async_.pyx":50
+ *     cdef:
+ *         UVAsync async_ = <UVAsync> handle.data
+ *         method_t cb = async_.callback             # <<<<<<<<<<<<<<
+ *     try:
+ *         cb(async_.ctx)
+ */
+  __pyx_t_3 = __pyx_v_async_->callback;
+  __pyx_v_cb = __pyx_t_3;
+
+  /* "uvloop/handles/async_.pyx":51
+ *         UVAsync async_ = <UVAsync> handle.data
+ *         method_t cb = async_.callback
+ *     try:             # <<<<<<<<<<<<<<
+ *         cb(async_.ctx)
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_6);
+    /*try:*/ {
+
+      /* "uvloop/handles/async_.pyx":52
+ *         method_t cb = async_.callback
+ *     try:
+ *         cb(async_.ctx)             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         async_._error(ex, False)
+ */
+      __pyx_t_2 = __pyx_v_async_->ctx;
+      __Pyx_INCREF(__pyx_t_2);
+      __pyx_t_7 = __pyx_v_cb(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(11, 52, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/handles/async_.pyx":51
+ *         UVAsync async_ = <UVAsync> handle.data
+ *         method_t cb = async_.callback
+ *     try:             # <<<<<<<<<<<<<<
+ *         cb(async_.ctx)
+ *     except BaseException as ex:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    goto __pyx_L9_try_end;
+    __pyx_L4_error:;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/handles/async_.pyx":53
+ *     try:
+ *         cb(async_.ctx)
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         async_._error(ex, False)
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("uvloop.loop.__uvasync_callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_2, &__pyx_t_9) < 0) __PYX_ERR(11, 53, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_INCREF(__pyx_t_2);
+      __pyx_v_ex = __pyx_t_2;
+      /*try:*/ {
+
+        /* "uvloop/handles/async_.pyx":54
+ *         cb(async_.ctx)
+ *     except BaseException as ex:
+ *         async_._error(ex, False)             # <<<<<<<<<<<<<<
+ */
+        __pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_async_->__pyx_base.__pyx_vtab)->__pyx_base._error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_async_), __pyx_v_ex, Py_False); if (unlikely(!__pyx_t_10)) __PYX_ERR(11, 54, __pyx_L15_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      }
+
+      /* "uvloop/handles/async_.pyx":53
+ *     try:
+ *         cb(async_.ctx)
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         async_._error(ex, False)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L16;
+        }
+        __pyx_L15_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __pyx_t_8 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+          }
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12;
+          goto __pyx_L6_except_error;
+        }
+        __pyx_L16:;
+      }
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      goto __pyx_L5_exception_handled;
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/handles/async_.pyx":51
+ *         UVAsync async_ = <UVAsync> handle.data
+ *         method_t cb = async_.callback
+ *     try:             # <<<<<<<<<<<<<<
+ *         cb(async_.ctx)
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L1_error;
+    __pyx_L5_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    __pyx_L9_try_end:;
+  }
+
+  /* "uvloop/handles/async_.pyx":44
+ * 
+ * 
+ * cdef void __uvasync_callback(uv.uv_async_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVAsync callback") == 0:
+ *         return
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_WriteUnraisable("uvloop.loop.__uvasync_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_async_);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/idle.pyx":3
+ * @cython.no_gc_clear
+ * cdef class UVIdle(UVHandle):
+ *     cdef _init(self, Loop loop, Handle h):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6UVIdle__init(struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h) {
+  int __pyx_v_err;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init", 0);
+
+  /* "uvloop/handles/idle.pyx":6
+ *         cdef int err
+ * 
+ *         self._start_init(loop)             # <<<<<<<<<<<<<<
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_idle_t))
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._start_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/idle.pyx":8
+ *         self._start_init(loop)
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_idle_t))             # <<<<<<<<<<<<<<
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ */
+  __pyx_v_self->__pyx_base._handle = ((uv_handle_t *)PyMem_RawMalloc((sizeof(uv_idle_t))));
+
+  /* "uvloop/handles/idle.pyx":9
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_idle_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  __pyx_t_2 = ((__pyx_v_self->__pyx_base._handle == NULL) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/idle.pyx":10
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_idle_t))
+ *         if self._handle is NULL:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 10, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/idle.pyx":11
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_idle_init(self._loop.uvloop, <uv.uv_idle_t*>self._handle)
+ */
+    PyErr_NoMemory(); __PYX_ERR(12, 11, __pyx_L1_error)
+
+    /* "uvloop/handles/idle.pyx":9
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_idle_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  }
+
+  /* "uvloop/handles/idle.pyx":13
+ *             raise MemoryError()
+ * 
+ *         err = uv.uv_idle_init(self._loop.uvloop, <uv.uv_idle_t*>self._handle)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             self._abort_init()
+ */
+  __pyx_v_err = uv_idle_init(__pyx_v_self->__pyx_base._loop->uvloop, ((uv_idle_t *)__pyx_v_self->__pyx_base._handle));
+
+  /* "uvloop/handles/idle.pyx":14
+ * 
+ *         err = uv.uv_idle_init(self._loop.uvloop, <uv.uv_idle_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/idle.pyx":15
+ *         err = uv.uv_idle_init(self._loop.uvloop, <uv.uv_idle_t*>self._handle)
+ *         if err < 0:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/idle.pyx":16
+ *         if err < 0:
+ *             self._abort_init()
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         self._finish_init()
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 16, __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(12, 16, __pyx_L1_error)
+
+    /* "uvloop/handles/idle.pyx":14
+ * 
+ *         err = uv.uv_idle_init(self._loop.uvloop, <uv.uv_idle_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  }
+
+  /* "uvloop/handles/idle.pyx":18
+ *             raise convert_error(err)
+ * 
+ *         self._finish_init()             # <<<<<<<<<<<<<<
+ * 
+ *         self.h = h
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._finish_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/idle.pyx":20
+ *         self._finish_init()
+ * 
+ *         self.h = h             # <<<<<<<<<<<<<<
+ *         self.running = 0
+ * 
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_h));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_h));
+  __Pyx_GOTREF(__pyx_v_self->h);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->h));
+  __pyx_v_self->h = __pyx_v_h;
+
+  /* "uvloop/handles/idle.pyx":21
+ * 
+ *         self.h = h
+ *         self.running = 0             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline stop(self):
+ */
+  __pyx_v_self->running = 0;
+
+  /* "uvloop/handles/idle.pyx":3
+ * @cython.no_gc_clear
+ * cdef class UVIdle(UVHandle):
+ *     cdef _init(self, Loop loop, Handle h):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVIdle._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/idle.pyx":23
+ *         self.running = 0
+ * 
+ *     cdef inline stop(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVIdle_stop(struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("stop", 0);
+
+  /* "uvloop/handles/idle.pyx":26
+ *         cdef int err
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             self.running = 0
+ *             return
+ */
+  __pyx_t_1 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)) != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/idle.pyx":27
+ * 
+ *         if not self._is_alive():
+ *             self.running = 0             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_v_self->running = 0;
+
+    /* "uvloop/handles/idle.pyx":28
+ *         if not self._is_alive():
+ *             self.running = 0
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if self.running == 1:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/idle.pyx":26
+ *         cdef int err
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             self.running = 0
+ *             return
+ */
+  }
+
+  /* "uvloop/handles/idle.pyx":30
+ *             return
+ * 
+ *         if self.running == 1:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_idle_stop(<uv.uv_idle_t*>self._handle)
+ *             self.running = 0
+ */
+  __pyx_t_1 = ((__pyx_v_self->running == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/idle.pyx":31
+ * 
+ *         if self.running == 1:
+ *             err = uv.uv_idle_stop(<uv.uv_idle_t*>self._handle)             # <<<<<<<<<<<<<<
+ *             self.running = 0
+ *             if err < 0:
+ */
+    __pyx_v_err = uv_idle_stop(((uv_idle_t *)__pyx_v_self->__pyx_base._handle));
+
+    /* "uvloop/handles/idle.pyx":32
+ *         if self.running == 1:
+ *             err = uv.uv_idle_stop(<uv.uv_idle_t*>self._handle)
+ *             self.running = 0             # <<<<<<<<<<<<<<
+ *             if err < 0:
+ *                 exc = convert_error(err)
+ */
+    __pyx_v_self->running = 0;
+
+    /* "uvloop/handles/idle.pyx":33
+ *             err = uv.uv_idle_stop(<uv.uv_idle_t*>self._handle)
+ *             self.running = 0
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/idle.pyx":34
+ *             self.running = 0
+ *             if err < 0:
+ *                 exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, True)
+ *                 return
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 34, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_v_exc = __pyx_t_2;
+      __pyx_t_2 = 0;
+
+      /* "uvloop/handles/idle.pyx":35
+ *             if err < 0:
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *                 return
+ * 
+ */
+      __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 35, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/idle.pyx":36
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ *                 return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline start(self):
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+
+      /* "uvloop/handles/idle.pyx":33
+ *             err = uv.uv_idle_stop(<uv.uv_idle_t*>self._handle)
+ *             self.running = 0
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    }
+
+    /* "uvloop/handles/idle.pyx":30
+ *             return
+ * 
+ *         if self.running == 1:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_idle_stop(<uv.uv_idle_t*>self._handle)
+ *             self.running = 0
+ */
+  }
+
+  /* "uvloop/handles/idle.pyx":23
+ *         self.running = 0
+ * 
+ *     cdef inline stop(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UVIdle.stop", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/idle.pyx":38
+ *                 return
+ * 
+ *     cdef inline start(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVIdle_start(struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("start", 0);
+
+  /* "uvloop/handles/idle.pyx":41
+ *         cdef int err
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         if self.running == 0:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/idle.pyx":43
+ *         self._ensure_alive()
+ * 
+ *         if self.running == 0:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_idle_start(<uv.uv_idle_t*>self._handle,
+ *                                    cb_idle_callback)
+ */
+  __pyx_t_2 = ((__pyx_v_self->running == 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/idle.pyx":44
+ * 
+ *         if self.running == 0:
+ *             err = uv.uv_idle_start(<uv.uv_idle_t*>self._handle,             # <<<<<<<<<<<<<<
+ *                                    cb_idle_callback)
+ *             if err < 0:
+ */
+    __pyx_v_err = uv_idle_start(((uv_idle_t *)__pyx_v_self->__pyx_base._handle), __pyx_f_6uvloop_4loop_cb_idle_callback);
+
+    /* "uvloop/handles/idle.pyx":46
+ *             err = uv.uv_idle_start(<uv.uv_idle_t*>self._handle,
+ *                                    cb_idle_callback)
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/handles/idle.pyx":47
+ *                                    cb_idle_callback)
+ *             if err < 0:
+ *                 exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, True)
+ *                 return
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 47, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_v_exc = __pyx_t_1;
+      __pyx_t_1 = 0;
+
+      /* "uvloop/handles/idle.pyx":48
+ *             if err < 0:
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *                 return
+ *             self.running = 1
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 48, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/idle.pyx":49
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ *                 return             # <<<<<<<<<<<<<<
+ *             self.running = 1
+ * 
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+
+      /* "uvloop/handles/idle.pyx":46
+ *             err = uv.uv_idle_start(<uv.uv_idle_t*>self._handle,
+ *                                    cb_idle_callback)
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    }
+
+    /* "uvloop/handles/idle.pyx":50
+ *                 self._fatal_error(exc, True)
+ *                 return
+ *             self.running = 1             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+    __pyx_v_self->running = 1;
+
+    /* "uvloop/handles/idle.pyx":43
+ *         self._ensure_alive()
+ * 
+ *         if self.running == 0:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_idle_start(<uv.uv_idle_t*>self._handle,
+ *                                    cb_idle_callback)
+ */
+  }
+
+  /* "uvloop/handles/idle.pyx":38
+ *                 return
+ * 
+ *     cdef inline start(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVIdle.start", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/idle.pyx":53
+ * 
+ *     @staticmethod
+ *     cdef UVIdle new(Loop loop, Handle h):             # <<<<<<<<<<<<<<
+ *         cdef UVIdle handle
+ *         handle = UVIdle.__new__(UVIdle)
+ */
+
+static struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_f_6uvloop_4loop_6UVIdle_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h) {
+  struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_handle = 0;
+  struct __pyx_obj_6uvloop_4loop_UVIdle *__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("new", 0);
+
+  /* "uvloop/handles/idle.pyx":55
+ *     cdef UVIdle new(Loop loop, Handle h):
+ *         cdef UVIdle handle
+ *         handle = UVIdle.__new__(UVIdle)             # <<<<<<<<<<<<<<
+ *         handle._init(loop, h)
+ *         return handle
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UVIdle(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UVIdle), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 55, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_UVIdle *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/idle.pyx":56
+ *         cdef UVIdle handle
+ *         handle = UVIdle.__new__(UVIdle)
+ *         handle._init(loop, h)             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_handle->__pyx_base.__pyx_vtab)->_init(__pyx_v_handle, __pyx_v_loop, __pyx_v_h); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/idle.pyx":57
+ *         handle = UVIdle.__new__(UVIdle)
+ *         handle._init(loop, h)
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/idle.pyx":53
+ * 
+ *     @staticmethod
+ *     cdef UVIdle new(Loop loop, Handle h):             # <<<<<<<<<<<<<<
+ *         cdef UVIdle handle
+ *         handle = UVIdle.__new__(UVIdle)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVIdle.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF((PyObject *)__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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6UVIdle_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6UVIdle___reduce_cython__[] = "UVIdle.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6UVIdle_1__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_6uvloop_4loop_6UVIdle___reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVIdle *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6UVIdle___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVIdle *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__125, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVIdle.__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_6uvloop_4loop_6UVIdle_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6UVIdle_2__setstate_cython__[] = "UVIdle.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_6UVIdle_3__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_6uvloop_4loop_6UVIdle_2__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVIdle *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6UVIdle_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVIdle *__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);
+
+  /* "(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__126, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVIdle.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/idle.pyx":60
+ * 
+ * 
+ * cdef void cb_idle_callback(uv.uv_idle_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVIdle callback") == 0:
+ *         return
+ */
+
+static void __pyx_f_6uvloop_4loop_cb_idle_callback(uv_idle_t *__pyx_v_handle) {
+  struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_idle = 0;
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h = 0;
+  PyObject *__pyx_v_ex = NULL;
+  __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;
+  int __pyx_t_10;
+  char const *__pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("cb_idle_callback", 0);
+
+  /* "uvloop/handles/idle.pyx":61
+ * 
+ * cdef void cb_idle_callback(uv.uv_idle_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVIdle callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_f_6uvloop_4loop___ensure_handle_data(((uv_handle_t *)__pyx_v_handle), ((char const *)"UVIdle callback")) == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/idle.pyx":62
+ * cdef void cb_idle_callback(uv.uv_idle_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVIdle callback") == 0:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/idle.pyx":61
+ * 
+ * cdef void cb_idle_callback(uv.uv_idle_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVIdle callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/idle.pyx":65
+ * 
+ *     cdef:
+ *         UVIdle idle = <UVIdle> handle.data             # <<<<<<<<<<<<<<
+ *         Handle h = idle.h
+ *     try:
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_handle->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_idle = ((struct __pyx_obj_6uvloop_4loop_UVIdle *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/idle.pyx":66
+ *     cdef:
+ *         UVIdle idle = <UVIdle> handle.data
+ *         Handle h = idle.h             # <<<<<<<<<<<<<<
+ *     try:
+ *         h._run()
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_idle->h);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_h = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/idle.pyx":67
+ *         UVIdle idle = <UVIdle> handle.data
+ *         Handle h = idle.h
+ *     try:             # <<<<<<<<<<<<<<
+ *         h._run()
+ *     except BaseException as ex:
+ */
+  {
+    __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:*/ {
+
+      /* "uvloop/handles/idle.pyx":68
+ *         Handle h = idle.h
+ *     try:
+ *         h._run()             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         idle._error(ex, False)
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_6Handle__run(__pyx_v_h); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 68, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/idle.pyx":67
+ *         UVIdle idle = <UVIdle> handle.data
+ *         Handle h = idle.h
+ *     try:             # <<<<<<<<<<<<<<
+ *         h._run()
+ *     except BaseException as ex:
+ */
+    }
+    __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;
+
+    /* "uvloop/handles/idle.pyx":69
+ *     try:
+ *         h._run()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         idle._error(ex, False)
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("uvloop.loop.cb_idle_callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(12, 69, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_7);
+      __pyx_v_ex = __pyx_t_7;
+      /*try:*/ {
+
+        /* "uvloop/handles/idle.pyx":70
+ *         h._run()
+ *     except BaseException as ex:
+ *         idle._error(ex, False)             # <<<<<<<<<<<<<<
+ */
+        __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_idle->__pyx_base.__pyx_vtab)->__pyx_base._error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_idle), __pyx_v_ex, Py_False); if (unlikely(!__pyx_t_9)) __PYX_ERR(12, 70, __pyx_L15_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      }
+
+      /* "uvloop/handles/idle.pyx":69
+ *     try:
+ *         h._run()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         idle._error(ex, False)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L16;
+        }
+        __pyx_L15_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_12);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __pyx_t_6 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+          }
+          __Pyx_XGIVEREF(__pyx_t_12);
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+          __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+          __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
+          goto __pyx_L6_except_error;
+        }
+        __pyx_L16:;
+      }
+      __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;
+      goto __pyx_L5_exception_handled;
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/handles/idle.pyx":67
+ *         UVIdle idle = <UVIdle> handle.data
+ *         Handle h = idle.h
+ *     try:             # <<<<<<<<<<<<<<
+ *         h._run()
+ *     except BaseException as ex:
+ */
+    __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_L5_exception_handled:;
+    __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);
+    __pyx_L9_try_end:;
+  }
+
+  /* "uvloop/handles/idle.pyx":60
+ * 
+ * 
+ * cdef void cb_idle_callback(uv.uv_idle_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVIdle callback") == 0:
+ *         return
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_WriteUnraisable("uvloop.loop.cb_idle_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_idle);
+  __Pyx_XDECREF((PyObject *)__pyx_v_h);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/check.pyx":3
+ * @cython.no_gc_clear
+ * cdef class UVCheck(UVHandle):
+ *     cdef _init(self, Loop loop, Handle h):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_7UVCheck__init(struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h) {
+  int __pyx_v_err;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init", 0);
+
+  /* "uvloop/handles/check.pyx":6
+ *         cdef int err
+ * 
+ *         self._start_init(loop)             # <<<<<<<<<<<<<<
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_check_t))
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._start_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/check.pyx":8
+ *         self._start_init(loop)
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_check_t))             # <<<<<<<<<<<<<<
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ */
+  __pyx_v_self->__pyx_base._handle = ((uv_handle_t *)PyMem_RawMalloc((sizeof(uv_check_t))));
+
+  /* "uvloop/handles/check.pyx":9
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_check_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  __pyx_t_2 = ((__pyx_v_self->__pyx_base._handle == NULL) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/check.pyx":10
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_check_t))
+ *         if self._handle is NULL:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 10, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/check.pyx":11
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_check_init(self._loop.uvloop, <uv.uv_check_t*>self._handle)
+ */
+    PyErr_NoMemory(); __PYX_ERR(13, 11, __pyx_L1_error)
+
+    /* "uvloop/handles/check.pyx":9
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_check_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  }
+
+  /* "uvloop/handles/check.pyx":13
+ *             raise MemoryError()
+ * 
+ *         err = uv.uv_check_init(self._loop.uvloop, <uv.uv_check_t*>self._handle)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             self._abort_init()
+ */
+  __pyx_v_err = uv_check_init(__pyx_v_self->__pyx_base._loop->uvloop, ((uv_check_t *)__pyx_v_self->__pyx_base._handle));
+
+  /* "uvloop/handles/check.pyx":14
+ * 
+ *         err = uv.uv_check_init(self._loop.uvloop, <uv.uv_check_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/check.pyx":15
+ *         err = uv.uv_check_init(self._loop.uvloop, <uv.uv_check_t*>self._handle)
+ *         if err < 0:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/check.pyx":16
+ *         if err < 0:
+ *             self._abort_init()
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         self._finish_init()
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 16, __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(13, 16, __pyx_L1_error)
+
+    /* "uvloop/handles/check.pyx":14
+ * 
+ *         err = uv.uv_check_init(self._loop.uvloop, <uv.uv_check_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  }
+
+  /* "uvloop/handles/check.pyx":18
+ *             raise convert_error(err)
+ * 
+ *         self._finish_init()             # <<<<<<<<<<<<<<
+ * 
+ *         self.h = h
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._finish_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/check.pyx":20
+ *         self._finish_init()
+ * 
+ *         self.h = h             # <<<<<<<<<<<<<<
+ *         self.running = 0
+ * 
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_h));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_h));
+  __Pyx_GOTREF(__pyx_v_self->h);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->h));
+  __pyx_v_self->h = __pyx_v_h;
+
+  /* "uvloop/handles/check.pyx":21
+ * 
+ *         self.h = h
+ *         self.running = 0             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline stop(self):
+ */
+  __pyx_v_self->running = 0;
+
+  /* "uvloop/handles/check.pyx":3
+ * @cython.no_gc_clear
+ * cdef class UVCheck(UVHandle):
+ *     cdef _init(self, Loop loop, Handle h):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVCheck._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/check.pyx":23
+ *         self.running = 0
+ * 
+ *     cdef inline stop(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_7UVCheck_stop(struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("stop", 0);
+
+  /* "uvloop/handles/check.pyx":26
+ *         cdef int err
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             self.running = 0
+ *             return
+ */
+  __pyx_t_1 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)) != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/check.pyx":27
+ * 
+ *         if not self._is_alive():
+ *             self.running = 0             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_v_self->running = 0;
+
+    /* "uvloop/handles/check.pyx":28
+ *         if not self._is_alive():
+ *             self.running = 0
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if self.running == 1:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/check.pyx":26
+ *         cdef int err
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             self.running = 0
+ *             return
+ */
+  }
+
+  /* "uvloop/handles/check.pyx":30
+ *             return
+ * 
+ *         if self.running == 1:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_check_stop(<uv.uv_check_t*>self._handle)
+ *             self.running = 0
+ */
+  __pyx_t_1 = ((__pyx_v_self->running == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/check.pyx":31
+ * 
+ *         if self.running == 1:
+ *             err = uv.uv_check_stop(<uv.uv_check_t*>self._handle)             # <<<<<<<<<<<<<<
+ *             self.running = 0
+ *             if err < 0:
+ */
+    __pyx_v_err = uv_check_stop(((uv_check_t *)__pyx_v_self->__pyx_base._handle));
+
+    /* "uvloop/handles/check.pyx":32
+ *         if self.running == 1:
+ *             err = uv.uv_check_stop(<uv.uv_check_t*>self._handle)
+ *             self.running = 0             # <<<<<<<<<<<<<<
+ *             if err < 0:
+ *                 exc = convert_error(err)
+ */
+    __pyx_v_self->running = 0;
+
+    /* "uvloop/handles/check.pyx":33
+ *             err = uv.uv_check_stop(<uv.uv_check_t*>self._handle)
+ *             self.running = 0
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/check.pyx":34
+ *             self.running = 0
+ *             if err < 0:
+ *                 exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, True)
+ *                 return
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 34, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_v_exc = __pyx_t_2;
+      __pyx_t_2 = 0;
+
+      /* "uvloop/handles/check.pyx":35
+ *             if err < 0:
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *                 return
+ * 
+ */
+      __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 35, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/check.pyx":36
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ *                 return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline start(self):
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+
+      /* "uvloop/handles/check.pyx":33
+ *             err = uv.uv_check_stop(<uv.uv_check_t*>self._handle)
+ *             self.running = 0
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    }
+
+    /* "uvloop/handles/check.pyx":30
+ *             return
+ * 
+ *         if self.running == 1:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_check_stop(<uv.uv_check_t*>self._handle)
+ *             self.running = 0
+ */
+  }
+
+  /* "uvloop/handles/check.pyx":23
+ *         self.running = 0
+ * 
+ *     cdef inline stop(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UVCheck.stop", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/check.pyx":38
+ *                 return
+ * 
+ *     cdef inline start(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_7UVCheck_start(struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("start", 0);
+
+  /* "uvloop/handles/check.pyx":41
+ *         cdef int err
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         if self.running == 0:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/check.pyx":43
+ *         self._ensure_alive()
+ * 
+ *         if self.running == 0:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_check_start(<uv.uv_check_t*>self._handle,
+ *                                     cb_check_callback)
+ */
+  __pyx_t_2 = ((__pyx_v_self->running == 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/check.pyx":44
+ * 
+ *         if self.running == 0:
+ *             err = uv.uv_check_start(<uv.uv_check_t*>self._handle,             # <<<<<<<<<<<<<<
+ *                                     cb_check_callback)
+ *             if err < 0:
+ */
+    __pyx_v_err = uv_check_start(((uv_check_t *)__pyx_v_self->__pyx_base._handle), __pyx_f_6uvloop_4loop_cb_check_callback);
+
+    /* "uvloop/handles/check.pyx":46
+ *             err = uv.uv_check_start(<uv.uv_check_t*>self._handle,
+ *                                     cb_check_callback)
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/handles/check.pyx":47
+ *                                     cb_check_callback)
+ *             if err < 0:
+ *                 exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, True)
+ *                 return
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 47, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_v_exc = __pyx_t_1;
+      __pyx_t_1 = 0;
+
+      /* "uvloop/handles/check.pyx":48
+ *             if err < 0:
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *                 return
+ *             self.running = 1
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 48, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/check.pyx":49
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ *                 return             # <<<<<<<<<<<<<<
+ *             self.running = 1
+ * 
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+
+      /* "uvloop/handles/check.pyx":46
+ *             err = uv.uv_check_start(<uv.uv_check_t*>self._handle,
+ *                                     cb_check_callback)
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    }
+
+    /* "uvloop/handles/check.pyx":50
+ *                 self._fatal_error(exc, True)
+ *                 return
+ *             self.running = 1             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+    __pyx_v_self->running = 1;
+
+    /* "uvloop/handles/check.pyx":43
+ *         self._ensure_alive()
+ * 
+ *         if self.running == 0:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_check_start(<uv.uv_check_t*>self._handle,
+ *                                     cb_check_callback)
+ */
+  }
+
+  /* "uvloop/handles/check.pyx":38
+ *                 return
+ * 
+ *     cdef inline start(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVCheck.start", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/check.pyx":53
+ * 
+ *     @staticmethod
+ *     cdef UVCheck new(Loop loop, Handle h):             # <<<<<<<<<<<<<<
+ *         cdef UVCheck handle
+ *         handle = UVCheck.__new__(UVCheck)
+ */
+
+static struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_f_6uvloop_4loop_7UVCheck_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h) {
+  struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_handle = 0;
+  struct __pyx_obj_6uvloop_4loop_UVCheck *__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("new", 0);
+
+  /* "uvloop/handles/check.pyx":55
+ *     cdef UVCheck new(Loop loop, Handle h):
+ *         cdef UVCheck handle
+ *         handle = UVCheck.__new__(UVCheck)             # <<<<<<<<<<<<<<
+ *         handle._init(loop, h)
+ *         return handle
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UVCheck(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UVCheck), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 55, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_UVCheck *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/check.pyx":56
+ *         cdef UVCheck handle
+ *         handle = UVCheck.__new__(UVCheck)
+ *         handle._init(loop, h)             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_handle->__pyx_base.__pyx_vtab)->_init(__pyx_v_handle, __pyx_v_loop, __pyx_v_h); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/check.pyx":57
+ *         handle = UVCheck.__new__(UVCheck)
+ *         handle._init(loop, h)
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/check.pyx":53
+ * 
+ *     @staticmethod
+ *     cdef UVCheck new(Loop loop, Handle h):             # <<<<<<<<<<<<<<
+ *         cdef UVCheck handle
+ *         handle = UVCheck.__new__(UVCheck)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVCheck.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF((PyObject *)__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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_7UVCheck_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_7UVCheck___reduce_cython__[] = "UVCheck.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_7UVCheck_1__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_6uvloop_4loop_7UVCheck___reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVCheck *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_7UVCheck___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVCheck *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__127, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVCheck.__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_6uvloop_4loop_7UVCheck_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_7UVCheck_2__setstate_cython__[] = "UVCheck.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_7UVCheck_3__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_6uvloop_4loop_7UVCheck_2__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVCheck *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_7UVCheck_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVCheck *__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);
+
+  /* "(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__128, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVCheck.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/check.pyx":60
+ * 
+ * 
+ * cdef void cb_check_callback(uv.uv_check_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVCheck callback") == 0:
+ *         return
+ */
+
+static void __pyx_f_6uvloop_4loop_cb_check_callback(uv_check_t *__pyx_v_handle) {
+  struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_check = 0;
+  struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h = 0;
+  PyObject *__pyx_v_ex = NULL;
+  __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;
+  int __pyx_t_10;
+  char const *__pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("cb_check_callback", 0);
+
+  /* "uvloop/handles/check.pyx":61
+ * 
+ * cdef void cb_check_callback(uv.uv_check_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVCheck callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_f_6uvloop_4loop___ensure_handle_data(((uv_handle_t *)__pyx_v_handle), ((char const *)"UVCheck callback")) == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/check.pyx":62
+ * cdef void cb_check_callback(uv.uv_check_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVCheck callback") == 0:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/check.pyx":61
+ * 
+ * cdef void cb_check_callback(uv.uv_check_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVCheck callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/check.pyx":65
+ * 
+ *     cdef:
+ *         UVCheck check = <UVCheck> handle.data             # <<<<<<<<<<<<<<
+ *         Handle h = check.h
+ *     try:
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_handle->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_check = ((struct __pyx_obj_6uvloop_4loop_UVCheck *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/check.pyx":66
+ *     cdef:
+ *         UVCheck check = <UVCheck> handle.data
+ *         Handle h = check.h             # <<<<<<<<<<<<<<
+ *     try:
+ *         h._run()
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_check->h);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_h = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/check.pyx":67
+ *         UVCheck check = <UVCheck> handle.data
+ *         Handle h = check.h
+ *     try:             # <<<<<<<<<<<<<<
+ *         h._run()
+ *     except BaseException as ex:
+ */
+  {
+    __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:*/ {
+
+      /* "uvloop/handles/check.pyx":68
+ *         Handle h = check.h
+ *     try:
+ *         h._run()             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         check._error(ex, False)
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_6Handle__run(__pyx_v_h); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 68, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/check.pyx":67
+ *         UVCheck check = <UVCheck> handle.data
+ *         Handle h = check.h
+ *     try:             # <<<<<<<<<<<<<<
+ *         h._run()
+ *     except BaseException as ex:
+ */
+    }
+    __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;
+
+    /* "uvloop/handles/check.pyx":69
+ *     try:
+ *         h._run()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         check._error(ex, False)
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("uvloop.loop.cb_check_callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(13, 69, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_7);
+      __pyx_v_ex = __pyx_t_7;
+      /*try:*/ {
+
+        /* "uvloop/handles/check.pyx":70
+ *         h._run()
+ *     except BaseException as ex:
+ *         check._error(ex, False)             # <<<<<<<<<<<<<<
+ */
+        __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_check->__pyx_base.__pyx_vtab)->__pyx_base._error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_check), __pyx_v_ex, Py_False); if (unlikely(!__pyx_t_9)) __PYX_ERR(13, 70, __pyx_L15_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      }
+
+      /* "uvloop/handles/check.pyx":69
+ *     try:
+ *         h._run()
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         check._error(ex, False)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L16;
+        }
+        __pyx_L15_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_12);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __pyx_t_6 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+          }
+          __Pyx_XGIVEREF(__pyx_t_12);
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+          __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+          __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
+          goto __pyx_L6_except_error;
+        }
+        __pyx_L16:;
+      }
+      __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;
+      goto __pyx_L5_exception_handled;
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/handles/check.pyx":67
+ *         UVCheck check = <UVCheck> handle.data
+ *         Handle h = check.h
+ *     try:             # <<<<<<<<<<<<<<
+ *         h._run()
+ *     except BaseException as ex:
+ */
+    __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_L5_exception_handled:;
+    __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);
+    __pyx_L9_try_end:;
+  }
+
+  /* "uvloop/handles/check.pyx":60
+ * 
+ * 
+ * cdef void cb_check_callback(uv.uv_check_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVCheck callback") == 0:
+ *         return
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_WriteUnraisable("uvloop.loop.cb_check_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_check);
+  __Pyx_XDECREF((PyObject *)__pyx_v_h);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/timer.pyx":3
+ * @cython.no_gc_clear
+ * cdef class UVTimer(UVHandle):
+ *     cdef _init(self, Loop loop, method_t callback, object ctx,             # <<<<<<<<<<<<<<
+ *                uint64_t timeout):
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_7UVTimer__init(struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx, uint64_t __pyx_v_timeout) {
+  int __pyx_v_err;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init", 0);
+
+  /* "uvloop/handles/timer.pyx":8
+ *         cdef int err
+ * 
+ *         self._start_init(loop)             # <<<<<<<<<<<<<<
+ * 
+ *         self._handle = <uv.uv_handle_t*> PyMem_RawMalloc(sizeof(uv.uv_timer_t))
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._start_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/timer.pyx":10
+ *         self._start_init(loop)
+ * 
+ *         self._handle = <uv.uv_handle_t*> PyMem_RawMalloc(sizeof(uv.uv_timer_t))             # <<<<<<<<<<<<<<
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ */
+  __pyx_v_self->__pyx_base._handle = ((uv_handle_t *)PyMem_RawMalloc((sizeof(uv_timer_t))));
+
+  /* "uvloop/handles/timer.pyx":11
+ * 
+ *         self._handle = <uv.uv_handle_t*> PyMem_RawMalloc(sizeof(uv.uv_timer_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  __pyx_t_2 = ((__pyx_v_self->__pyx_base._handle == NULL) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/timer.pyx":12
+ *         self._handle = <uv.uv_handle_t*> PyMem_RawMalloc(sizeof(uv.uv_timer_t))
+ *         if self._handle is NULL:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 12, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/timer.pyx":13
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_timer_init(self._loop.uvloop, <uv.uv_timer_t*>self._handle)
+ */
+    PyErr_NoMemory(); __PYX_ERR(14, 13, __pyx_L1_error)
+
+    /* "uvloop/handles/timer.pyx":11
+ * 
+ *         self._handle = <uv.uv_handle_t*> PyMem_RawMalloc(sizeof(uv.uv_timer_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  }
+
+  /* "uvloop/handles/timer.pyx":15
+ *             raise MemoryError()
+ * 
+ *         err = uv.uv_timer_init(self._loop.uvloop, <uv.uv_timer_t*>self._handle)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             self._abort_init()
+ */
+  __pyx_v_err = uv_timer_init(__pyx_v_self->__pyx_base._loop->uvloop, ((uv_timer_t *)__pyx_v_self->__pyx_base._handle));
+
+  /* "uvloop/handles/timer.pyx":16
+ * 
+ *         err = uv.uv_timer_init(self._loop.uvloop, <uv.uv_timer_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/timer.pyx":17
+ *         err = uv.uv_timer_init(self._loop.uvloop, <uv.uv_timer_t*>self._handle)
+ *         if err < 0:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 17, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/timer.pyx":18
+ *         if err < 0:
+ *             self._abort_init()
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         self._finish_init()
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 18, __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(14, 18, __pyx_L1_error)
+
+    /* "uvloop/handles/timer.pyx":16
+ * 
+ *         err = uv.uv_timer_init(self._loop.uvloop, <uv.uv_timer_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  }
+
+  /* "uvloop/handles/timer.pyx":20
+ *             raise convert_error(err)
+ * 
+ *         self._finish_init()             # <<<<<<<<<<<<<<
+ * 
+ *         self.callback = callback
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._finish_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/timer.pyx":22
+ *         self._finish_init()
+ * 
+ *         self.callback = callback             # <<<<<<<<<<<<<<
+ *         self.ctx = ctx
+ *         self.running = 0
+ */
+  __pyx_v_self->callback = __pyx_v_callback;
+
+  /* "uvloop/handles/timer.pyx":23
+ * 
+ *         self.callback = callback
+ *         self.ctx = ctx             # <<<<<<<<<<<<<<
+ *         self.running = 0
+ *         self.timeout = timeout
+ */
+  __Pyx_INCREF(__pyx_v_ctx);
+  __Pyx_GIVEREF(__pyx_v_ctx);
+  __Pyx_GOTREF(__pyx_v_self->ctx);
+  __Pyx_DECREF(__pyx_v_self->ctx);
+  __pyx_v_self->ctx = __pyx_v_ctx;
+
+  /* "uvloop/handles/timer.pyx":24
+ *         self.callback = callback
+ *         self.ctx = ctx
+ *         self.running = 0             # <<<<<<<<<<<<<<
+ *         self.timeout = timeout
+ *         self.start_t = 0
+ */
+  __pyx_v_self->running = 0;
+
+  /* "uvloop/handles/timer.pyx":25
+ *         self.ctx = ctx
+ *         self.running = 0
+ *         self.timeout = timeout             # <<<<<<<<<<<<<<
+ *         self.start_t = 0
+ * 
+ */
+  __pyx_v_self->timeout = __pyx_v_timeout;
+
+  /* "uvloop/handles/timer.pyx":26
+ *         self.running = 0
+ *         self.timeout = timeout
+ *         self.start_t = 0             # <<<<<<<<<<<<<<
+ * 
+ *     cdef stop(self):
+ */
+  __pyx_v_self->start_t = 0;
+
+  /* "uvloop/handles/timer.pyx":3
+ * @cython.no_gc_clear
+ * cdef class UVTimer(UVHandle):
+ *     cdef _init(self, Loop loop, method_t callback, object ctx,             # <<<<<<<<<<<<<<
+ *                uint64_t timeout):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVTimer._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/timer.pyx":28
+ *         self.start_t = 0
+ * 
+ *     cdef stop(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_7UVTimer_stop(struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("stop", 0);
+
+  /* "uvloop/handles/timer.pyx":31
+ *         cdef int err
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             self.running = 0
+ *             return
+ */
+  __pyx_t_1 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)) != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/timer.pyx":32
+ * 
+ *         if not self._is_alive():
+ *             self.running = 0             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_v_self->running = 0;
+
+    /* "uvloop/handles/timer.pyx":33
+ *         if not self._is_alive():
+ *             self.running = 0
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if self.running == 1:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/timer.pyx":31
+ *         cdef int err
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             self.running = 0
+ *             return
+ */
+  }
+
+  /* "uvloop/handles/timer.pyx":35
+ *             return
+ * 
+ *         if self.running == 1:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_timer_stop(<uv.uv_timer_t*>self._handle)
+ *             self.running = 0
+ */
+  __pyx_t_1 = ((__pyx_v_self->running == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/timer.pyx":36
+ * 
+ *         if self.running == 1:
+ *             err = uv.uv_timer_stop(<uv.uv_timer_t*>self._handle)             # <<<<<<<<<<<<<<
+ *             self.running = 0
+ *             if err < 0:
+ */
+    __pyx_v_err = uv_timer_stop(((uv_timer_t *)__pyx_v_self->__pyx_base._handle));
+
+    /* "uvloop/handles/timer.pyx":37
+ *         if self.running == 1:
+ *             err = uv.uv_timer_stop(<uv.uv_timer_t*>self._handle)
+ *             self.running = 0             # <<<<<<<<<<<<<<
+ *             if err < 0:
+ *                 exc = convert_error(err)
+ */
+    __pyx_v_self->running = 0;
+
+    /* "uvloop/handles/timer.pyx":38
+ *             err = uv.uv_timer_stop(<uv.uv_timer_t*>self._handle)
+ *             self.running = 0
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/timer.pyx":39
+ *             self.running = 0
+ *             if err < 0:
+ *                 exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, True)
+ *                 return
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 39, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_v_exc = __pyx_t_2;
+      __pyx_t_2 = 0;
+
+      /* "uvloop/handles/timer.pyx":40
+ *             if err < 0:
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *                 return
+ * 
+ */
+      __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 40, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/timer.pyx":41
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ *                 return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef start(self):
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+
+      /* "uvloop/handles/timer.pyx":38
+ *             err = uv.uv_timer_stop(<uv.uv_timer_t*>self._handle)
+ *             self.running = 0
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    }
+
+    /* "uvloop/handles/timer.pyx":35
+ *             return
+ * 
+ *         if self.running == 1:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_timer_stop(<uv.uv_timer_t*>self._handle)
+ *             self.running = 0
+ */
+  }
+
+  /* "uvloop/handles/timer.pyx":28
+ *         self.start_t = 0
+ * 
+ *     cdef stop(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UVTimer.stop", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/timer.pyx":43
+ *                 return
+ * 
+ *     cdef start(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_7UVTimer_start(struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("start", 0);
+
+  /* "uvloop/handles/timer.pyx":46
+ *         cdef int err
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         if self.running == 0:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/timer.pyx":48
+ *         self._ensure_alive()
+ * 
+ *         if self.running == 0:             # <<<<<<<<<<<<<<
+ *             # Update libuv internal time.
+ *             uv.uv_update_time(self._loop.uvloop)  # void
+ */
+  __pyx_t_2 = ((__pyx_v_self->running == 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/timer.pyx":50
+ *         if self.running == 0:
+ *             # Update libuv internal time.
+ *             uv.uv_update_time(self._loop.uvloop)  # void             # <<<<<<<<<<<<<<
+ *             self.start_t = uv.uv_now(self._loop.uvloop)
+ * 
+ */
+    uv_update_time(__pyx_v_self->__pyx_base._loop->uvloop);
+
+    /* "uvloop/handles/timer.pyx":51
+ *             # Update libuv internal time.
+ *             uv.uv_update_time(self._loop.uvloop)  # void
+ *             self.start_t = uv.uv_now(self._loop.uvloop)             # <<<<<<<<<<<<<<
+ * 
+ *             err = uv.uv_timer_start(<uv.uv_timer_t*>self._handle,
+ */
+    __pyx_v_self->start_t = uv_now(__pyx_v_self->__pyx_base._loop->uvloop);
+
+    /* "uvloop/handles/timer.pyx":53
+ *             self.start_t = uv.uv_now(self._loop.uvloop)
+ * 
+ *             err = uv.uv_timer_start(<uv.uv_timer_t*>self._handle,             # <<<<<<<<<<<<<<
+ *                                     __uvtimer_callback,
+ *                                     self.timeout, 0)
+ */
+    __pyx_v_err = uv_timer_start(((uv_timer_t *)__pyx_v_self->__pyx_base._handle), __pyx_f_6uvloop_4loop___uvtimer_callback, __pyx_v_self->timeout, 0);
+
+    /* "uvloop/handles/timer.pyx":56
+ *                                     __uvtimer_callback,
+ *                                     self.timeout, 0)
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/handles/timer.pyx":57
+ *                                     self.timeout, 0)
+ *             if err < 0:
+ *                 exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, True)
+ *                 return
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 57, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_v_exc = __pyx_t_1;
+      __pyx_t_1 = 0;
+
+      /* "uvloop/handles/timer.pyx":58
+ *             if err < 0:
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *                 return
+ *             self.running = 1
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 58, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/timer.pyx":59
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ *                 return             # <<<<<<<<<<<<<<
+ *             self.running = 1
+ * 
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+
+      /* "uvloop/handles/timer.pyx":56
+ *                                     __uvtimer_callback,
+ *                                     self.timeout, 0)
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+    }
+
+    /* "uvloop/handles/timer.pyx":60
+ *                 self._fatal_error(exc, True)
+ *                 return
+ *             self.running = 1             # <<<<<<<<<<<<<<
+ * 
+ *     cdef get_when(self):
+ */
+    __pyx_v_self->running = 1;
+
+    /* "uvloop/handles/timer.pyx":48
+ *         self._ensure_alive()
+ * 
+ *         if self.running == 0:             # <<<<<<<<<<<<<<
+ *             # Update libuv internal time.
+ *             uv.uv_update_time(self._loop.uvloop)  # void
+ */
+  }
+
+  /* "uvloop/handles/timer.pyx":43
+ *                 return
+ * 
+ *     cdef start(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVTimer.start", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/timer.pyx":62
+ *             self.running = 1
+ * 
+ *     cdef get_when(self):             # <<<<<<<<<<<<<<
+ *         return self.start_t + self.timeout
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_7UVTimer_get_when(struct __pyx_obj_6uvloop_4loop_UVTimer *__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_when", 0);
+
+  /* "uvloop/handles/timer.pyx":63
+ * 
+ *     cdef get_when(self):
+ *         return self.start_t + self.timeout             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_uint64_t((__pyx_v_self->start_t + __pyx_v_self->timeout)); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 63, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/timer.pyx":62
+ *             self.running = 1
+ * 
+ *     cdef get_when(self):             # <<<<<<<<<<<<<<
+ *         return self.start_t + self.timeout
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVTimer.get_when", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/timer.pyx":66
+ * 
+ *     @staticmethod
+ *     cdef UVTimer new(Loop loop, method_t callback, object ctx,             # <<<<<<<<<<<<<<
+ *                      uint64_t timeout):
+ * 
+ */
+
+static struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_f_6uvloop_4loop_7UVTimer_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx, uint64_t __pyx_v_timeout) {
+  struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_handle = 0;
+  struct __pyx_obj_6uvloop_4loop_UVTimer *__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("new", 0);
+
+  /* "uvloop/handles/timer.pyx":70
+ * 
+ *         cdef UVTimer handle
+ *         handle = UVTimer.__new__(UVTimer)             # <<<<<<<<<<<<<<
+ *         handle._init(loop, callback, ctx, timeout)
+ *         return handle
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UVTimer(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UVTimer), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 70, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_UVTimer *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/timer.pyx":71
+ *         cdef UVTimer handle
+ *         handle = UVTimer.__new__(UVTimer)
+ *         handle._init(loop, callback, ctx, timeout)             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_handle->__pyx_base.__pyx_vtab)->_init(__pyx_v_handle, __pyx_v_loop, __pyx_v_callback, __pyx_v_ctx, __pyx_v_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/timer.pyx":72
+ *         handle = UVTimer.__new__(UVTimer)
+ *         handle._init(loop, callback, ctx, timeout)
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/timer.pyx":66
+ * 
+ *     @staticmethod
+ *     cdef UVTimer new(Loop loop, method_t callback, object ctx,             # <<<<<<<<<<<<<<
+ *                      uint64_t timeout):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVTimer.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF((PyObject *)__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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_7UVTimer_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_7UVTimer___reduce_cython__[] = "UVTimer.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_7UVTimer_1__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_6uvloop_4loop_7UVTimer___reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVTimer *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_7UVTimer___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVTimer *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__129, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVTimer.__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_6uvloop_4loop_7UVTimer_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_7UVTimer_2__setstate_cython__[] = "UVTimer.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_7UVTimer_3__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_6uvloop_4loop_7UVTimer_2__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVTimer *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_7UVTimer_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVTimer *__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);
+
+  /* "(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__130, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVTimer.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/timer.pyx":75
+ * 
+ * 
+ * cdef void __uvtimer_callback(uv.uv_timer_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVTimer callback") == 0:
+ *         return
+ */
+
+static void __pyx_f_6uvloop_4loop___uvtimer_callback(uv_timer_t *__pyx_v_handle) {
+  struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_timer = 0;
+  __pyx_t_6uvloop_4loop_method_t __pyx_v_cb;
+  PyObject *__pyx_v_ex = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  __pyx_t_6uvloop_4loop_method_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  char const *__pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uvtimer_callback", 0);
+
+  /* "uvloop/handles/timer.pyx":76
+ * 
+ * cdef void __uvtimer_callback(uv.uv_timer_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVTimer callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_f_6uvloop_4loop___ensure_handle_data(((uv_handle_t *)__pyx_v_handle), ((char const *)"UVTimer callback")) == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/timer.pyx":77
+ * cdef void __uvtimer_callback(uv.uv_timer_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVTimer callback") == 0:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/timer.pyx":76
+ * 
+ * cdef void __uvtimer_callback(uv.uv_timer_t* handle) with gil:
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVTimer callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/timer.pyx":80
+ * 
+ *     cdef:
+ *         UVTimer timer = <UVTimer> handle.data             # <<<<<<<<<<<<<<
+ *         method_t cb = timer.callback
+ * 
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_handle->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_timer = ((struct __pyx_obj_6uvloop_4loop_UVTimer *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/timer.pyx":81
+ *     cdef:
+ *         UVTimer timer = <UVTimer> handle.data
+ *         method_t cb = timer.callback             # <<<<<<<<<<<<<<
+ * 
+ *     timer.running = 0
+ */
+  __pyx_t_3 = __pyx_v_timer->callback;
+  __pyx_v_cb = __pyx_t_3;
+
+  /* "uvloop/handles/timer.pyx":83
+ *         method_t cb = timer.callback
+ * 
+ *     timer.running = 0             # <<<<<<<<<<<<<<
+ *     try:
+ *         cb(timer.ctx)
+ */
+  __pyx_v_timer->running = 0;
+
+  /* "uvloop/handles/timer.pyx":84
+ * 
+ *     timer.running = 0
+ *     try:             # <<<<<<<<<<<<<<
+ *         cb(timer.ctx)
+ *     except BaseException as ex:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_6);
+    /*try:*/ {
+
+      /* "uvloop/handles/timer.pyx":85
+ *     timer.running = 0
+ *     try:
+ *         cb(timer.ctx)             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         timer._error(ex, False)
+ */
+      __pyx_t_2 = __pyx_v_timer->ctx;
+      __Pyx_INCREF(__pyx_t_2);
+      __pyx_t_7 = __pyx_v_cb(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(14, 85, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/handles/timer.pyx":84
+ * 
+ *     timer.running = 0
+ *     try:             # <<<<<<<<<<<<<<
+ *         cb(timer.ctx)
+ *     except BaseException as ex:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    goto __pyx_L9_try_end;
+    __pyx_L4_error:;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/handles/timer.pyx":86
+ *     try:
+ *         cb(timer.ctx)
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         timer._error(ex, False)
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("uvloop.loop.__uvtimer_callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_2, &__pyx_t_9) < 0) __PYX_ERR(14, 86, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_INCREF(__pyx_t_2);
+      __pyx_v_ex = __pyx_t_2;
+      /*try:*/ {
+
+        /* "uvloop/handles/timer.pyx":87
+ *         cb(timer.ctx)
+ *     except BaseException as ex:
+ *         timer._error(ex, False)             # <<<<<<<<<<<<<<
+ */
+        __pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *)__pyx_v_timer->__pyx_base.__pyx_vtab)->__pyx_base._error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_timer), __pyx_v_ex, Py_False); if (unlikely(!__pyx_t_10)) __PYX_ERR(14, 87, __pyx_L15_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      }
+
+      /* "uvloop/handles/timer.pyx":86
+ *     try:
+ *         cb(timer.ctx)
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         timer._error(ex, False)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L16;
+        }
+        __pyx_L15_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __pyx_t_8 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+          }
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12;
+          goto __pyx_L6_except_error;
+        }
+        __pyx_L16:;
+      }
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      goto __pyx_L5_exception_handled;
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/handles/timer.pyx":84
+ * 
+ *     timer.running = 0
+ *     try:             # <<<<<<<<<<<<<<
+ *         cb(timer.ctx)
+ *     except BaseException as ex:
+ */
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L1_error;
+    __pyx_L5_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    __pyx_L9_try_end:;
+  }
+
+  /* "uvloop/handles/timer.pyx":75
+ * 
+ * 
+ * cdef void __uvtimer_callback(uv.uv_timer_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVTimer callback") == 0:
+ *         return
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_WriteUnraisable("uvloop.loop.__uvtimer_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_timer);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/poll.pyx":3
+ * @cython.no_gc_clear
+ * cdef class UVPoll(UVHandle):
+ *     cdef _init(self, Loop loop, int fd):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll__init(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, int __pyx_v_fd) {
+  int __pyx_v_err;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init", 0);
+
+  /* "uvloop/handles/poll.pyx":6
+ *         cdef int err
+ * 
+ *         self._start_init(loop)             # <<<<<<<<<<<<<<
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_poll_t))
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._start_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/poll.pyx":8
+ *         self._start_init(loop)
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_poll_t))             # <<<<<<<<<<<<<<
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ */
+  __pyx_v_self->__pyx_base._handle = ((uv_handle_t *)PyMem_RawMalloc((sizeof(uv_poll_t))));
+
+  /* "uvloop/handles/poll.pyx":9
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_poll_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  __pyx_t_2 = ((__pyx_v_self->__pyx_base._handle == NULL) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/poll.pyx":10
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_poll_t))
+ *         if self._handle is NULL:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 10, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/poll.pyx":11
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_poll_init(self._loop.uvloop,
+ */
+    PyErr_NoMemory(); __PYX_ERR(15, 11, __pyx_L1_error)
+
+    /* "uvloop/handles/poll.pyx":9
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_poll_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":13
+ *             raise MemoryError()
+ * 
+ *         err = uv.uv_poll_init(self._loop.uvloop,             # <<<<<<<<<<<<<<
+ *                               <uv.uv_poll_t *>self._handle, fd)
+ *         if err < 0:
+ */
+  __pyx_v_err = uv_poll_init(__pyx_v_self->__pyx_base._loop->uvloop, ((uv_poll_t *)__pyx_v_self->__pyx_base._handle), __pyx_v_fd);
+
+  /* "uvloop/handles/poll.pyx":15
+ *         err = uv.uv_poll_init(self._loop.uvloop,
+ *                               <uv.uv_poll_t *>self._handle, fd)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/poll.pyx":16
+ *                               <uv.uv_poll_t *>self._handle, fd)
+ *         if err < 0:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 16, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/poll.pyx":17
+ *         if err < 0:
+ *             self._abort_init()
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         self._finish_init()
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 17, __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(15, 17, __pyx_L1_error)
+
+    /* "uvloop/handles/poll.pyx":15
+ *         err = uv.uv_poll_init(self._loop.uvloop,
+ *                               <uv.uv_poll_t *>self._handle, fd)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":19
+ *             raise convert_error(err)
+ * 
+ *         self._finish_init()             # <<<<<<<<<<<<<<
+ * 
+ *         self.fd = fd
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._finish_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/poll.pyx":21
+ *         self._finish_init()
+ * 
+ *         self.fd = fd             # <<<<<<<<<<<<<<
+ *         self.reading_handle = None
+ *         self.writing_handle = None
+ */
+  __pyx_v_self->fd = __pyx_v_fd;
+
+  /* "uvloop/handles/poll.pyx":22
+ * 
+ *         self.fd = fd
+ *         self.reading_handle = None             # <<<<<<<<<<<<<<
+ *         self.writing_handle = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->reading_handle);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->reading_handle));
+  __pyx_v_self->reading_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None);
+
+  /* "uvloop/handles/poll.pyx":23
+ *         self.fd = fd
+ *         self.reading_handle = None
+ *         self.writing_handle = None             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->writing_handle);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->writing_handle));
+  __pyx_v_self->writing_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None);
+
+  /* "uvloop/handles/poll.pyx":3
+ * @cython.no_gc_clear
+ * cdef class UVPoll(UVHandle):
+ *     cdef _init(self, Loop loop, int fd):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":26
+ * 
+ *     @staticmethod
+ *     cdef UVPoll new(Loop loop, int fd):             # <<<<<<<<<<<<<<
+ *         cdef UVPoll handle
+ *         handle = UVPoll.__new__(UVPoll)
+ */
+
+static struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_f_6uvloop_4loop_6UVPoll_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, int __pyx_v_fd) {
+  struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_handle = 0;
+  struct __pyx_obj_6uvloop_4loop_UVPoll *__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("new", 0);
+
+  /* "uvloop/handles/poll.pyx":28
+ *     cdef UVPoll new(Loop loop, int fd):
+ *         cdef UVPoll handle
+ *         handle = UVPoll.__new__(UVPoll)             # <<<<<<<<<<<<<<
+ *         handle._init(loop, fd)
+ *         return handle
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UVPoll(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UVPoll), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 28, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/poll.pyx":29
+ *         cdef UVPoll handle
+ *         handle = UVPoll.__new__(UVPoll)
+ *         handle._init(loop, fd)             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_handle->__pyx_base.__pyx_vtab)->_init(__pyx_v_handle, __pyx_v_loop, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/poll.pyx":30
+ *         handle = UVPoll.__new__(UVPoll)
+ *         handle._init(loop, fd)
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ *     cdef int is_active(self):
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/poll.pyx":26
+ * 
+ *     @staticmethod
+ *     cdef UVPoll new(Loop loop, int fd):             # <<<<<<<<<<<<<<
+ *         cdef UVPoll handle
+ *         handle = UVPoll.__new__(UVPoll)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":32
+ *         return handle
+ * 
+ *     cdef int is_active(self):             # <<<<<<<<<<<<<<
+ *         return (self.reading_handle is not None or
+ *                 self.writing_handle is not None)
+ */
+
+static int __pyx_f_6uvloop_4loop_6UVPoll_is_active(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  __Pyx_RefNannySetupContext("is_active", 0);
+
+  /* "uvloop/handles/poll.pyx":33
+ * 
+ *     cdef int is_active(self):
+ *         return (self.reading_handle is not None or             # <<<<<<<<<<<<<<
+ *                 self.writing_handle is not None)
+ * 
+ */
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->reading_handle) != Py_None);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L3_bool_binop_done;
+  }
+
+  /* "uvloop/handles/poll.pyx":34
+ *     cdef int is_active(self):
+ *         return (self.reading_handle is not None or
+ *                 self.writing_handle is not None)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _poll_start(self, int flags):
+ */
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->writing_handle) != Py_None);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L3_bool_binop_done:;
+  __pyx_r = __pyx_t_1;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/poll.pyx":32
+ *         return handle
+ * 
+ *     cdef int is_active(self):             # <<<<<<<<<<<<<<
+ *         return (self.reading_handle is not None or
+ *                 self.writing_handle is not None)
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":36
+ *                 self.writing_handle is not None)
+ * 
+ *     cdef inline _poll_start(self, int flags):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVPoll__poll_start(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, int __pyx_v_flags) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_poll_start", 0);
+
+  /* "uvloop/handles/poll.pyx":39
+ *         cdef int err
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_poll_start(
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 39, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/poll.pyx":41
+ *         self._ensure_alive()
+ * 
+ *         err = uv.uv_poll_start(             # <<<<<<<<<<<<<<
+ *             <uv.uv_poll_t*>self._handle,
+ *             flags,
+ */
+  __pyx_v_err = uv_poll_start(((uv_poll_t *)__pyx_v_self->__pyx_base._handle), __pyx_v_flags, __pyx_f_6uvloop_4loop___on_uvpoll_event);
+
+  /* "uvloop/handles/poll.pyx":46
+ *             __on_uvpoll_event)
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/poll.pyx":47
+ * 
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 47, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/poll.pyx":48
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 48, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/poll.pyx":49
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _poll_stop(self):
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/poll.pyx":46
+ *             __on_uvpoll_event)
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":36
+ *                 self.writing_handle is not None)
+ * 
+ *     cdef inline _poll_start(self, int flags):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll._poll_start", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":51
+ *             return
+ * 
+ *     cdef inline _poll_stop(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVPoll__poll_stop(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  int __pyx_v_backend_id;
+  struct epoll_event __pyx_v_dummy_event;
+  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("_poll_stop", 0);
+
+  /* "uvloop/handles/poll.pyx":54
+ *         cdef int err
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)) != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/poll.pyx":55
+ * 
+ *         if not self._is_alive():
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_poll_stop(<uv.uv_poll_t*>self._handle)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/poll.pyx":54
+ *         cdef int err
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":57
+ *             return
+ * 
+ *         err = uv.uv_poll_stop(<uv.uv_poll_t*>self._handle)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             exc = convert_error(err)
+ */
+  __pyx_v_err = uv_poll_stop(((uv_poll_t *)__pyx_v_self->__pyx_base._handle));
+
+  /* "uvloop/handles/poll.pyx":58
+ * 
+ *         err = uv.uv_poll_stop(<uv.uv_poll_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/poll.pyx":59
+ *         err = uv.uv_poll_stop(<uv.uv_poll_t*>self._handle)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 59, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/poll.pyx":60
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 60, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/poll.pyx":61
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         cdef:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/poll.pyx":58
+ * 
+ *         err = uv.uv_poll_stop(<uv.uv_poll_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":67
+ *             system.epoll_event dummy_event
+ * 
+ *         if system.PLATFORM_IS_LINUX:             # <<<<<<<<<<<<<<
+ *             # libuv doesn't remove the FD from epoll immediately
+ *             # after uv_poll_stop or uv_poll_close, causing hard
+ */
+  __pyx_t_1 = (PLATFORM_IS_LINUX != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/poll.pyx":77
+ *             # after calling uv_poll_stop.
+ * 
+ *             backend_id = uv.uv_backend_fd(self._loop.uvloop)             # <<<<<<<<<<<<<<
+ *             if backend_id != -1:
+ *                 memset(&dummy_event, 0, sizeof(dummy_event))
+ */
+    __pyx_v_backend_id = uv_backend_fd(__pyx_v_self->__pyx_base._loop->uvloop);
+
+    /* "uvloop/handles/poll.pyx":78
+ * 
+ *             backend_id = uv.uv_backend_fd(self._loop.uvloop)
+ *             if backend_id != -1:             # <<<<<<<<<<<<<<
+ *                 memset(&dummy_event, 0, sizeof(dummy_event))
+ *                 system.epoll_ctl(
+ */
+    __pyx_t_1 = ((__pyx_v_backend_id != -1L) != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/poll.pyx":79
+ *             backend_id = uv.uv_backend_fd(self._loop.uvloop)
+ *             if backend_id != -1:
+ *                 memset(&dummy_event, 0, sizeof(dummy_event))             # <<<<<<<<<<<<<<
+ *                 system.epoll_ctl(
+ *                     backend_id,
+ */
+      (void)(memset((&__pyx_v_dummy_event), 0, (sizeof(__pyx_v_dummy_event))));
+
+      /* "uvloop/handles/poll.pyx":80
+ *             if backend_id != -1:
+ *                 memset(&dummy_event, 0, sizeof(dummy_event))
+ *                 system.epoll_ctl(             # <<<<<<<<<<<<<<
+ *                     backend_id,
+ *                     system.EPOLL_CTL_DEL,
+ */
+      (void)(epoll_ctl(__pyx_v_backend_id, EPOLL_CTL_DEL, __pyx_v_self->fd, (&__pyx_v_dummy_event)));
+
+      /* "uvloop/handles/poll.pyx":78
+ * 
+ *             backend_id = uv.uv_backend_fd(self._loop.uvloop)
+ *             if backend_id != -1:             # <<<<<<<<<<<<<<
+ *                 memset(&dummy_event, 0, sizeof(dummy_event))
+ *                 system.epoll_ctl(
+ */
+    }
+
+    /* "uvloop/handles/poll.pyx":67
+ *             system.epoll_event dummy_event
+ * 
+ *         if system.PLATFORM_IS_LINUX:             # <<<<<<<<<<<<<<
+ *             # libuv doesn't remove the FD from epoll immediately
+ *             # after uv_poll_stop or uv_poll_close, causing hard
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":51
+ *             return
+ * 
+ *     cdef inline _poll_stop(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll._poll_stop", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":86
+ *                     &dummy_event)  # ignore errors
+ * 
+ *     cdef is_reading(self):             # <<<<<<<<<<<<<<
+ *         return self._is_alive() and self.reading_handle is not None
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_is_reading(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = 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("is_reading", 0);
+
+  /* "uvloop/handles/poll.pyx":87
+ * 
+ *     cdef is_reading(self):
+ *         return self._is_alive() and self.reading_handle is not None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef is_writing(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self));
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 87, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L3_bool_binop_done;
+  }
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->reading_handle) != Py_None);
+  __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 87, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_t_3 = 0;
+  __pyx_L3_bool_binop_done:;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/poll.pyx":86
+ *                     &dummy_event)  # ignore errors
+ * 
+ *     cdef is_reading(self):             # <<<<<<<<<<<<<<
+ *         return self._is_alive() and self.reading_handle is not None
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll.is_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":89
+ *         return self._is_alive() and self.reading_handle is not None
+ * 
+ *     cdef is_writing(self):             # <<<<<<<<<<<<<<
+ *         return self._is_alive() and self.writing_handle is not None
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_is_writing(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = 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("is_writing", 0);
+
+  /* "uvloop/handles/poll.pyx":90
+ * 
+ *     cdef is_writing(self):
+ *         return self._is_alive() and self.writing_handle is not None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef start_reading(self, Handle callback):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self));
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 90, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L3_bool_binop_done;
+  }
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->writing_handle) != Py_None);
+  __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_t_3 = 0;
+  __pyx_L3_bool_binop_done:;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/poll.pyx":89
+ *         return self._is_alive() and self.reading_handle is not None
+ * 
+ *     cdef is_writing(self):             # <<<<<<<<<<<<<<
+ *         return self._is_alive() and self.writing_handle is not None
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll.is_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":92
+ *         return self._is_alive() and self.writing_handle is not None
+ * 
+ *     cdef start_reading(self, Handle callback):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int mask = 0
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_start_reading(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_callback) {
+  int __pyx_v_mask;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("start_reading", 0);
+
+  /* "uvloop/handles/poll.pyx":94
+ *     cdef start_reading(self, Handle callback):
+ *         cdef:
+ *             int mask = 0             # <<<<<<<<<<<<<<
+ * 
+ *         if self.reading_handle is None:
+ */
+  __pyx_v_mask = 0;
+
+  /* "uvloop/handles/poll.pyx":96
+ *             int mask = 0
+ * 
+ *         if self.reading_handle is None:             # <<<<<<<<<<<<<<
+ *             # not reading right now, setup the handle
+ * 
+ */
+  __pyx_t_1 = (((PyObject *)__pyx_v_self->reading_handle) == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/poll.pyx":99
+ *             # not reading right now, setup the handle
+ * 
+ *             mask = uv.UV_READABLE             # <<<<<<<<<<<<<<
+ *             if self.writing_handle is not None:
+ *                 # are we writing right now?
+ */
+    __pyx_v_mask = UV_READABLE;
+
+    /* "uvloop/handles/poll.pyx":100
+ * 
+ *             mask = uv.UV_READABLE
+ *             if self.writing_handle is not None:             # <<<<<<<<<<<<<<
+ *                 # are we writing right now?
+ *                 mask |= uv.UV_WRITABLE
+ */
+    __pyx_t_2 = (((PyObject *)__pyx_v_self->writing_handle) != Py_None);
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/poll.pyx":102
+ *             if self.writing_handle is not None:
+ *                 # are we writing right now?
+ *                 mask |= uv.UV_WRITABLE             # <<<<<<<<<<<<<<
+ * 
+ *             self._poll_start(mask)
+ */
+      __pyx_v_mask = (__pyx_v_mask | UV_WRITABLE);
+
+      /* "uvloop/handles/poll.pyx":100
+ * 
+ *             mask = uv.UV_READABLE
+ *             if self.writing_handle is not None:             # <<<<<<<<<<<<<<
+ *                 # are we writing right now?
+ *                 mask |= uv.UV_WRITABLE
+ */
+    }
+
+    /* "uvloop/handles/poll.pyx":104
+ *                 mask |= uv.UV_WRITABLE
+ * 
+ *             self._poll_start(mask)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self.reading_handle._cancel()
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_6UVPoll__poll_start(__pyx_v_self, __pyx_v_mask); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 104, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/poll.pyx":96
+ *             int mask = 0
+ * 
+ *         if self.reading_handle is None:             # <<<<<<<<<<<<<<
+ *             # not reading right now, setup the handle
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/poll.pyx":106
+ *             self._poll_start(mask)
+ *         else:
+ *             self.reading_handle._cancel()             # <<<<<<<<<<<<<<
+ * 
+ *         self.reading_handle = callback
+ */
+  /*else*/ {
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Handle *)__pyx_v_self->reading_handle->__pyx_vtab)->_cancel(__pyx_v_self->reading_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 106, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/poll.pyx":108
+ *             self.reading_handle._cancel()
+ * 
+ *         self.reading_handle = callback             # <<<<<<<<<<<<<<
+ * 
+ *     cdef start_writing(self, Handle callback):
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_callback));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_callback));
+  __Pyx_GOTREF(__pyx_v_self->reading_handle);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->reading_handle));
+  __pyx_v_self->reading_handle = __pyx_v_callback;
+
+  /* "uvloop/handles/poll.pyx":92
+ *         return self._is_alive() and self.writing_handle is not None
+ * 
+ *     cdef start_reading(self, Handle callback):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int mask = 0
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll.start_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":110
+ *         self.reading_handle = callback
+ * 
+ *     cdef start_writing(self, Handle callback):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int mask = 0
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_start_writing(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_callback) {
+  int __pyx_v_mask;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("start_writing", 0);
+
+  /* "uvloop/handles/poll.pyx":112
+ *     cdef start_writing(self, Handle callback):
+ *         cdef:
+ *             int mask = 0             # <<<<<<<<<<<<<<
+ * 
+ *         if self.writing_handle is None:
+ */
+  __pyx_v_mask = 0;
+
+  /* "uvloop/handles/poll.pyx":114
+ *             int mask = 0
+ * 
+ *         if self.writing_handle is None:             # <<<<<<<<<<<<<<
+ *             # not writing right now, setup the handle
+ * 
+ */
+  __pyx_t_1 = (((PyObject *)__pyx_v_self->writing_handle) == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/poll.pyx":117
+ *             # not writing right now, setup the handle
+ * 
+ *             mask = uv.UV_WRITABLE             # <<<<<<<<<<<<<<
+ *             if self.reading_handle is not None:
+ *                 # are we reading right now?
+ */
+    __pyx_v_mask = UV_WRITABLE;
+
+    /* "uvloop/handles/poll.pyx":118
+ * 
+ *             mask = uv.UV_WRITABLE
+ *             if self.reading_handle is not None:             # <<<<<<<<<<<<<<
+ *                 # are we reading right now?
+ *                 mask |= uv.UV_READABLE
+ */
+    __pyx_t_2 = (((PyObject *)__pyx_v_self->reading_handle) != Py_None);
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/poll.pyx":120
+ *             if self.reading_handle is not None:
+ *                 # are we reading right now?
+ *                 mask |= uv.UV_READABLE             # <<<<<<<<<<<<<<
+ * 
+ *             self._poll_start(mask)
+ */
+      __pyx_v_mask = (__pyx_v_mask | UV_READABLE);
+
+      /* "uvloop/handles/poll.pyx":118
+ * 
+ *             mask = uv.UV_WRITABLE
+ *             if self.reading_handle is not None:             # <<<<<<<<<<<<<<
+ *                 # are we reading right now?
+ *                 mask |= uv.UV_READABLE
+ */
+    }
+
+    /* "uvloop/handles/poll.pyx":122
+ *                 mask |= uv.UV_READABLE
+ * 
+ *             self._poll_start(mask)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self.writing_handle._cancel()
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_6UVPoll__poll_start(__pyx_v_self, __pyx_v_mask); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 122, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/poll.pyx":114
+ *             int mask = 0
+ * 
+ *         if self.writing_handle is None:             # <<<<<<<<<<<<<<
+ *             # not writing right now, setup the handle
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/poll.pyx":124
+ *             self._poll_start(mask)
+ *         else:
+ *             self.writing_handle._cancel()             # <<<<<<<<<<<<<<
+ * 
+ *         self.writing_handle = callback
+ */
+  /*else*/ {
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Handle *)__pyx_v_self->writing_handle->__pyx_vtab)->_cancel(__pyx_v_self->writing_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 124, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/poll.pyx":126
+ *             self.writing_handle._cancel()
+ * 
+ *         self.writing_handle = callback             # <<<<<<<<<<<<<<
+ * 
+ *     cdef stop_reading(self):
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_callback));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_callback));
+  __Pyx_GOTREF(__pyx_v_self->writing_handle);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->writing_handle));
+  __pyx_v_self->writing_handle = __pyx_v_callback;
+
+  /* "uvloop/handles/poll.pyx":110
+ *         self.reading_handle = callback
+ * 
+ *     cdef start_writing(self, Handle callback):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int mask = 0
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll.start_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":128
+ *         self.writing_handle = callback
+ * 
+ *     cdef stop_reading(self):             # <<<<<<<<<<<<<<
+ *         if self.reading_handle is None:
+ *             return False
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_stop_reading(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("stop_reading", 0);
+
+  /* "uvloop/handles/poll.pyx":129
+ * 
+ *     cdef stop_reading(self):
+ *         if self.reading_handle is None:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+  __pyx_t_1 = (((PyObject *)__pyx_v_self->reading_handle) == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/poll.pyx":130
+ *     cdef stop_reading(self):
+ *         if self.reading_handle is None:
+ *             return False             # <<<<<<<<<<<<<<
+ * 
+ *         self.reading_handle._cancel()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_False);
+    __pyx_r = Py_False;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/poll.pyx":129
+ * 
+ *     cdef stop_reading(self):
+ *         if self.reading_handle is None:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":132
+ *             return False
+ * 
+ *         self.reading_handle._cancel()             # <<<<<<<<<<<<<<
+ *         self.reading_handle = None
+ * 
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Handle *)__pyx_v_self->reading_handle->__pyx_vtab)->_cancel(__pyx_v_self->reading_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/poll.pyx":133
+ * 
+ *         self.reading_handle._cancel()
+ *         self.reading_handle = None             # <<<<<<<<<<<<<<
+ * 
+ *         if self.writing_handle is None:
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->reading_handle);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->reading_handle));
+  __pyx_v_self->reading_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None);
+
+  /* "uvloop/handles/poll.pyx":135
+ *         self.reading_handle = None
+ * 
+ *         if self.writing_handle is None:             # <<<<<<<<<<<<<<
+ *             self.stop()
+ *         else:
+ */
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->writing_handle) == Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/poll.pyx":136
+ * 
+ *         if self.writing_handle is None:
+ *             self.stop()             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._poll_start(uv.UV_WRITABLE)
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->stop(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 136, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/poll.pyx":135
+ *         self.reading_handle = None
+ * 
+ *         if self.writing_handle is None:             # <<<<<<<<<<<<<<
+ *             self.stop()
+ *         else:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/handles/poll.pyx":138
+ *             self.stop()
+ *         else:
+ *             self._poll_start(uv.UV_WRITABLE)             # <<<<<<<<<<<<<<
+ * 
+ *         return True
+ */
+  /*else*/ {
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_6UVPoll__poll_start(__pyx_v_self, UV_WRITABLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 138, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_L4:;
+
+  /* "uvloop/handles/poll.pyx":140
+ *             self._poll_start(uv.UV_WRITABLE)
+ * 
+ *         return True             # <<<<<<<<<<<<<<
+ * 
+ *     cdef stop_writing(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(Py_True);
+  __pyx_r = Py_True;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/poll.pyx":128
+ *         self.writing_handle = callback
+ * 
+ *     cdef stop_reading(self):             # <<<<<<<<<<<<<<
+ *         if self.reading_handle is None:
+ *             return False
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll.stop_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":142
+ *         return True
+ * 
+ *     cdef stop_writing(self):             # <<<<<<<<<<<<<<
+ *         if self.writing_handle is None:
+ *             return False
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_stop_writing(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("stop_writing", 0);
+
+  /* "uvloop/handles/poll.pyx":143
+ * 
+ *     cdef stop_writing(self):
+ *         if self.writing_handle is None:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+  __pyx_t_1 = (((PyObject *)__pyx_v_self->writing_handle) == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/poll.pyx":144
+ *     cdef stop_writing(self):
+ *         if self.writing_handle is None:
+ *             return False             # <<<<<<<<<<<<<<
+ * 
+ *         self.writing_handle._cancel()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_False);
+    __pyx_r = Py_False;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/poll.pyx":143
+ * 
+ *     cdef stop_writing(self):
+ *         if self.writing_handle is None:             # <<<<<<<<<<<<<<
+ *             return False
+ * 
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":146
+ *             return False
+ * 
+ *         self.writing_handle._cancel()             # <<<<<<<<<<<<<<
+ *         self.writing_handle = None
+ * 
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Handle *)__pyx_v_self->writing_handle->__pyx_vtab)->_cancel(__pyx_v_self->writing_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/poll.pyx":147
+ * 
+ *         self.writing_handle._cancel()
+ *         self.writing_handle = None             # <<<<<<<<<<<<<<
+ * 
+ *         if self.reading_handle is None:
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->writing_handle);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->writing_handle));
+  __pyx_v_self->writing_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None);
+
+  /* "uvloop/handles/poll.pyx":149
+ *         self.writing_handle = None
+ * 
+ *         if self.reading_handle is None:             # <<<<<<<<<<<<<<
+ *             self.stop()
+ *         else:
+ */
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->reading_handle) == Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/poll.pyx":150
+ * 
+ *         if self.reading_handle is None:
+ *             self.stop()             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._poll_start(uv.UV_READABLE)
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->stop(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 150, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/poll.pyx":149
+ *         self.writing_handle = None
+ * 
+ *         if self.reading_handle is None:             # <<<<<<<<<<<<<<
+ *             self.stop()
+ *         else:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/handles/poll.pyx":152
+ *             self.stop()
+ *         else:
+ *             self._poll_start(uv.UV_READABLE)             # <<<<<<<<<<<<<<
+ * 
+ *         return True
+ */
+  /*else*/ {
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_6UVPoll__poll_start(__pyx_v_self, UV_READABLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 152, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_L4:;
+
+  /* "uvloop/handles/poll.pyx":154
+ *             self._poll_start(uv.UV_READABLE)
+ * 
+ *         return True             # <<<<<<<<<<<<<<
+ * 
+ *     cdef stop(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(Py_True);
+  __pyx_r = Py_True;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/poll.pyx":142
+ *         return True
+ * 
+ *     cdef stop_writing(self):             # <<<<<<<<<<<<<<
+ *         if self.writing_handle is None:
+ *             return False
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll.stop_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":156
+ *         return True
+ * 
+ *     cdef stop(self):             # <<<<<<<<<<<<<<
+ *         if self.reading_handle is not None:
+ *             self.reading_handle._cancel()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_stop(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("stop", 0);
+
+  /* "uvloop/handles/poll.pyx":157
+ * 
+ *     cdef stop(self):
+ *         if self.reading_handle is not None:             # <<<<<<<<<<<<<<
+ *             self.reading_handle._cancel()
+ *             self.reading_handle = None
+ */
+  __pyx_t_1 = (((PyObject *)__pyx_v_self->reading_handle) != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/poll.pyx":158
+ *     cdef stop(self):
+ *         if self.reading_handle is not None:
+ *             self.reading_handle._cancel()             # <<<<<<<<<<<<<<
+ *             self.reading_handle = None
+ * 
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Handle *)__pyx_v_self->reading_handle->__pyx_vtab)->_cancel(__pyx_v_self->reading_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 158, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/poll.pyx":159
+ *         if self.reading_handle is not None:
+ *             self.reading_handle._cancel()
+ *             self.reading_handle = None             # <<<<<<<<<<<<<<
+ * 
+ *         if self.writing_handle is not None:
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->reading_handle);
+    __Pyx_DECREF(((PyObject *)__pyx_v_self->reading_handle));
+    __pyx_v_self->reading_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None);
+
+    /* "uvloop/handles/poll.pyx":157
+ * 
+ *     cdef stop(self):
+ *         if self.reading_handle is not None:             # <<<<<<<<<<<<<<
+ *             self.reading_handle._cancel()
+ *             self.reading_handle = None
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":161
+ *             self.reading_handle = None
+ * 
+ *         if self.writing_handle is not None:             # <<<<<<<<<<<<<<
+ *             self.writing_handle._cancel()
+ *             self.writing_handle = None
+ */
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->writing_handle) != Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/poll.pyx":162
+ * 
+ *         if self.writing_handle is not None:
+ *             self.writing_handle._cancel()             # <<<<<<<<<<<<<<
+ *             self.writing_handle = None
+ * 
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Handle *)__pyx_v_self->writing_handle->__pyx_vtab)->_cancel(__pyx_v_self->writing_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 162, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/poll.pyx":163
+ *         if self.writing_handle is not None:
+ *             self.writing_handle._cancel()
+ *             self.writing_handle = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._poll_stop()
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->writing_handle);
+    __Pyx_DECREF(((PyObject *)__pyx_v_self->writing_handle));
+    __pyx_v_self->writing_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None);
+
+    /* "uvloop/handles/poll.pyx":161
+ *             self.reading_handle = None
+ * 
+ *         if self.writing_handle is not None:             # <<<<<<<<<<<<<<
+ *             self.writing_handle._cancel()
+ *             self.writing_handle = None
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":165
+ *             self.writing_handle = None
+ * 
+ *         self._poll_stop()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _close(self):
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_6UVPoll__poll_stop(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/poll.pyx":156
+ *         return True
+ * 
+ *     cdef stop(self):             # <<<<<<<<<<<<<<
+ *         if self.reading_handle is not None:
+ *             self.reading_handle._cancel()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll.stop", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":167
+ *         self._poll_stop()
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         if self.is_active():
+ *             self.stop()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll__close(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self) {
+  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("_close", 0);
+
+  /* "uvloop/handles/poll.pyx":168
+ * 
+ *     cdef _close(self):
+ *         if self.is_active():             # <<<<<<<<<<<<<<
+ *             self.stop()
+ * 
+ */
+  __pyx_t_1 = (((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->is_active(__pyx_v_self) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/poll.pyx":169
+ *     cdef _close(self):
+ *         if self.is_active():
+ *             self.stop()             # <<<<<<<<<<<<<<
+ * 
+ *         UVHandle._close(<UVHandle>self)
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->stop(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 169, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/poll.pyx":168
+ * 
+ *     cdef _close(self):
+ *         if self.is_active():             # <<<<<<<<<<<<<<
+ *             self.stop()
+ * 
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":171
+ *             self.stop()
+ * 
+ *         UVHandle._close(<UVHandle>self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop_8UVHandle__close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/poll.pyx":167
+ *         self._poll_stop()
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         if self.is_active():
+ *             self.stop()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll._close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":173
+ *         UVHandle._close(<UVHandle>self)
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):             # <<<<<<<<<<<<<<
+ *         try:
+ *             if self.reading_handle is not None:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6UVPoll__fatal_error(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc, CYTHON_UNUSED PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_6UVPoll__fatal_error *__pyx_optional_args) {
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_t_10;
+  char const *__pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_fatal_error", 0);
+  if (__pyx_optional_args) {
+  }
+
+  /* "uvloop/handles/poll.pyx":174
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self.reading_handle is not None:
+ *                 try:
+ */
+  /*try:*/ {
+
+    /* "uvloop/handles/poll.pyx":175
+ *     cdef _fatal_error(self, exc, throw, reason=None):
+ *         try:
+ *             if self.reading_handle is not None:             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     self.reading_handle._run()
+ */
+    __pyx_t_1 = (((PyObject *)__pyx_v_self->reading_handle) != Py_None);
+    __pyx_t_2 = (__pyx_t_1 != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/handles/poll.pyx":176
+ *         try:
+ *             if self.reading_handle is not None:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     self.reading_handle._run()
+ *                 except BaseException as ex:
+ */
+      {
+        __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:*/ {
+
+          /* "uvloop/handles/poll.pyx":177
+ *             if self.reading_handle is not None:
+ *                 try:
+ *                     self.reading_handle._run()             # <<<<<<<<<<<<<<
+ *                 except BaseException as ex:
+ *                     self._loop._handle_exception(ex)
+ */
+          __pyx_t_6 = __pyx_f_6uvloop_4loop_6Handle__run(__pyx_v_self->reading_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(15, 177, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+          /* "uvloop/handles/poll.pyx":176
+ *         try:
+ *             if self.reading_handle is not None:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     self.reading_handle._run()
+ *                 except BaseException as ex:
+ */
+        }
+        __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_L12_try_end;
+        __pyx_L7_error:;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+        /* "uvloop/handles/poll.pyx":178
+ *                 try:
+ *                     self.reading_handle._run()
+ *                 except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                     self._loop._handle_exception(ex)
+ *                 self.reading_handle = None
+ */
+        __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+        if (__pyx_t_7) {
+          __Pyx_AddTraceback("uvloop.loop.UVPoll._fatal_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(15, 178, __pyx_L9_except_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_GOTREF(__pyx_t_8);
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_INCREF(__pyx_t_8);
+          __pyx_v_ex = __pyx_t_8;
+          /*try:*/ {
+
+            /* "uvloop/handles/poll.pyx":179
+ *                     self.reading_handle._run()
+ *                 except BaseException as ex:
+ *                     self._loop._handle_exception(ex)             # <<<<<<<<<<<<<<
+ *                 self.reading_handle = None
+ * 
+ */
+            ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_base._loop->__pyx_vtab)->_handle_exception(__pyx_v_self->__pyx_base._loop, __pyx_v_ex);
+          }
+
+          /* "uvloop/handles/poll.pyx":178
+ *                 try:
+ *                     self.reading_handle._run()
+ *                 except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                     self._loop._handle_exception(ex)
+ *                 self.reading_handle = None
+ */
+          /*finally:*/ {
+            /*normal exit:*/{
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+              goto __pyx_L19;
+            }
+            __pyx_L19:;
+          }
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          goto __pyx_L8_exception_handled;
+        }
+        goto __pyx_L9_except_error;
+        __pyx_L9_except_error:;
+
+        /* "uvloop/handles/poll.pyx":176
+ *         try:
+ *             if self.reading_handle is not None:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     self.reading_handle._run()
+ *                 except BaseException as ex:
+ */
+        __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_L4_error;
+        __pyx_L8_exception_handled:;
+        __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);
+        __pyx_L12_try_end:;
+      }
+
+      /* "uvloop/handles/poll.pyx":180
+ *                 except BaseException as ex:
+ *                     self._loop._handle_exception(ex)
+ *                 self.reading_handle = None             # <<<<<<<<<<<<<<
+ * 
+ *             if self.writing_handle is not None:
+ */
+      __Pyx_INCREF(Py_None);
+      __Pyx_GIVEREF(Py_None);
+      __Pyx_GOTREF(__pyx_v_self->reading_handle);
+      __Pyx_DECREF(((PyObject *)__pyx_v_self->reading_handle));
+      __pyx_v_self->reading_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None);
+
+      /* "uvloop/handles/poll.pyx":175
+ *     cdef _fatal_error(self, exc, throw, reason=None):
+ *         try:
+ *             if self.reading_handle is not None:             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     self.reading_handle._run()
+ */
+    }
+
+    /* "uvloop/handles/poll.pyx":182
+ *                 self.reading_handle = None
+ * 
+ *             if self.writing_handle is not None:             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     self.writing_handle._run()
+ */
+    __pyx_t_2 = (((PyObject *)__pyx_v_self->writing_handle) != Py_None);
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/poll.pyx":183
+ * 
+ *             if self.writing_handle is not None:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     self.writing_handle._run()
+ *                 except BaseException as ex:
+ */
+      {
+        __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:*/ {
+
+          /* "uvloop/handles/poll.pyx":184
+ *             if self.writing_handle is not None:
+ *                 try:
+ *                     self.writing_handle._run()             # <<<<<<<<<<<<<<
+ *                 except BaseException as ex:
+ *                     self._loop._handle_exception(ex)
+ */
+          __pyx_t_9 = __pyx_f_6uvloop_4loop_6Handle__run(__pyx_v_self->writing_handle); if (unlikely(!__pyx_t_9)) __PYX_ERR(15, 184, __pyx_L21_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+          /* "uvloop/handles/poll.pyx":183
+ * 
+ *             if self.writing_handle is not None:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     self.writing_handle._run()
+ *                 except BaseException as ex:
+ */
+        }
+        __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_L26_try_end;
+        __pyx_L21_error:;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        /* "uvloop/handles/poll.pyx":185
+ *                 try:
+ *                     self.writing_handle._run()
+ *                 except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                     self._loop._handle_exception(ex)
+ *                 self.writing_handle = None
+ */
+        __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+        if (__pyx_t_7) {
+          __Pyx_AddTraceback("uvloop.loop.UVPoll._fatal_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(15, 185, __pyx_L23_except_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_GOTREF(__pyx_t_8);
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_8);
+          __pyx_v_ex = __pyx_t_8;
+          /*try:*/ {
+
+            /* "uvloop/handles/poll.pyx":186
+ *                     self.writing_handle._run()
+ *                 except BaseException as ex:
+ *                     self._loop._handle_exception(ex)             # <<<<<<<<<<<<<<
+ *                 self.writing_handle = None
+ * 
+ */
+            ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_base._loop->__pyx_vtab)->_handle_exception(__pyx_v_self->__pyx_base._loop, __pyx_v_ex);
+          }
+
+          /* "uvloop/handles/poll.pyx":185
+ *                 try:
+ *                     self.writing_handle._run()
+ *                 except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                     self._loop._handle_exception(ex)
+ *                 self.writing_handle = None
+ */
+          /*finally:*/ {
+            /*normal exit:*/{
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+              goto __pyx_L33;
+            }
+            __pyx_L33:;
+          }
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          goto __pyx_L22_exception_handled;
+        }
+        goto __pyx_L23_except_error;
+        __pyx_L23_except_error:;
+
+        /* "uvloop/handles/poll.pyx":183
+ * 
+ *             if self.writing_handle is not None:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     self.writing_handle._run()
+ *                 except BaseException as ex:
+ */
+        __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_L4_error;
+        __pyx_L22_exception_handled:;
+        __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);
+        __pyx_L26_try_end:;
+      }
+
+      /* "uvloop/handles/poll.pyx":187
+ *                 except BaseException as ex:
+ *                     self._loop._handle_exception(ex)
+ *                 self.writing_handle = None             # <<<<<<<<<<<<<<
+ * 
+ *         finally:
+ */
+      __Pyx_INCREF(Py_None);
+      __Pyx_GIVEREF(Py_None);
+      __Pyx_GOTREF(__pyx_v_self->writing_handle);
+      __Pyx_DECREF(((PyObject *)__pyx_v_self->writing_handle));
+      __pyx_v_self->writing_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None);
+
+      /* "uvloop/handles/poll.pyx":182
+ *                 self.reading_handle = None
+ * 
+ *             if self.writing_handle is not None:             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     self.writing_handle._run()
+ */
+    }
+  }
+
+  /* "uvloop/handles/poll.pyx":190
+ * 
+ *         finally:
+ *             self._close()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(15, 190, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L5;
+    }
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5) < 0)) __Pyx_ErrFetch(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __pyx_t_7 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
+      {
+        __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(15, 190, __pyx_L35_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_ErrRestore(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+      __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __pyx_lineno = __pyx_t_7; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
+      goto __pyx_L1_error;
+      __pyx_L35_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __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_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L5:;
+  }
+
+  /* "uvloop/handles/poll.pyx":173
+ *         UVHandle._close(<UVHandle>self)
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):             # <<<<<<<<<<<<<<
+ *         try:
+ *             if self.reading_handle is not None:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll._fatal_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ex);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6UVPoll_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6UVPoll___reduce_cython__[] = "UVPoll.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6UVPoll_1__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_6uvloop_4loop_6UVPoll___reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6UVPoll___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVPoll *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__131, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll.__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_6uvloop_4loop_6UVPoll_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6UVPoll_2__setstate_cython__[] = "UVPoll.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_6UVPoll_3__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_6uvloop_4loop_6UVPoll_2__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6UVPoll_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVPoll *__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);
+
+  /* "(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__132, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVPoll.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/poll.pyx":193
+ * 
+ * 
+ * cdef void __on_uvpoll_event(uv.uv_poll_t* handle,             # <<<<<<<<<<<<<<
+ *                             int status, int events) with gil:
+ * 
+ */
+
+static void __pyx_f_6uvloop_4loop___on_uvpoll_event(uv_poll_t *__pyx_v_handle, int __pyx_v_status, int __pyx_v_events) {
+  struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_poll = 0;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_t_13;
+  char const *__pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  char const *__pyx_t_21;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__on_uvpoll_event", 0);
+
+  /* "uvloop/handles/poll.pyx":196
+ *                             int status, int events) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVPoll callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_f_6uvloop_4loop___ensure_handle_data(((uv_handle_t *)__pyx_v_handle), ((char const *)"UVPoll callback")) == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/poll.pyx":197
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVPoll callback") == 0:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/poll.pyx":196
+ *                             int status, int events) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVPoll callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":200
+ * 
+ *     cdef:
+ *         UVPoll poll = <UVPoll> handle.data             # <<<<<<<<<<<<<<
+ * 
+ *     if status < 0:
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_handle->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_poll = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/poll.pyx":202
+ *         UVPoll poll = <UVPoll> handle.data
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(status)
+ *         poll._fatal_error(exc, False)
+ */
+  __pyx_t_1 = ((__pyx_v_status < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/poll.pyx":203
+ * 
+ *     if status < 0:
+ *         exc = convert_error(status)             # <<<<<<<<<<<<<<
+ *         poll._fatal_error(exc, False)
+ *         return
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_status); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/poll.pyx":204
+ *     if status < 0:
+ *         exc = convert_error(status)
+ *         poll._fatal_error(exc, False)             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_poll), __pyx_v_exc, Py_False, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 204, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/poll.pyx":205
+ *         exc = convert_error(status)
+ *         poll._fatal_error(exc, False)
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     if ((events & (uv.UV_READABLE | uv.UV_DISCONNECT)) and
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/poll.pyx":202
+ *         UVPoll poll = <UVPoll> handle.data
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(status)
+ *         poll._fatal_error(exc, False)
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":207
+ *         return
+ * 
+ *     if ((events & (uv.UV_READABLE | uv.UV_DISCONNECT)) and             # <<<<<<<<<<<<<<
+ *             poll.reading_handle is not None):
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_events & (UV_READABLE | UV_DISCONNECT)) != 0);
+  if (__pyx_t_3) {
+  } else {
+    __pyx_t_1 = __pyx_t_3;
+    goto __pyx_L6_bool_binop_done;
+  }
+
+  /* "uvloop/handles/poll.pyx":208
+ * 
+ *     if ((events & (uv.UV_READABLE | uv.UV_DISCONNECT)) and
+ *             poll.reading_handle is not None):             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_t_3 = (((PyObject *)__pyx_v_poll->reading_handle) != Py_None);
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  __pyx_t_1 = __pyx_t_4;
+  __pyx_L6_bool_binop_done:;
+
+  /* "uvloop/handles/poll.pyx":207
+ *         return
+ * 
+ *     if ((events & (uv.UV_READABLE | uv.UV_DISCONNECT)) and             # <<<<<<<<<<<<<<
+ *             poll.reading_handle is not None):
+ * 
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/poll.pyx":210
+ *             poll.reading_handle is not None):
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_read_events_total += 1
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      /*try:*/ {
+
+        /* "uvloop/handles/poll.pyx":211
+ * 
+ *         try:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 poll._loop._poll_read_events_total += 1
+ *             poll.reading_handle._run()
+ */
+        __pyx_t_1 = (UVLOOP_DEBUG != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/handles/poll.pyx":212
+ *         try:
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_read_events_total += 1             # <<<<<<<<<<<<<<
+ *             poll.reading_handle._run()
+ *         except BaseException as ex:
+ */
+          __Pyx_INCREF(((PyObject *)__pyx_v_poll->__pyx_base._loop));
+          __pyx_t_8 = __pyx_v_poll->__pyx_base._loop;
+          __pyx_t_8->_poll_read_events_total = (__pyx_t_8->_poll_read_events_total + 1);
+          __Pyx_DECREF(((PyObject *)__pyx_t_8)); __pyx_t_8 = 0;
+
+          /* "uvloop/handles/poll.pyx":211
+ * 
+ *         try:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 poll._loop._poll_read_events_total += 1
+ *             poll.reading_handle._run()
+ */
+        }
+
+        /* "uvloop/handles/poll.pyx":213
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_read_events_total += 1
+ *             poll.reading_handle._run()             # <<<<<<<<<<<<<<
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:
+ */
+        __pyx_t_2 = __pyx_f_6uvloop_4loop_6Handle__run(__pyx_v_poll->reading_handle); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 213, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/handles/poll.pyx":210
+ *             poll.reading_handle is not None):
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_read_events_total += 1
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L13_try_end;
+      __pyx_L8_error:;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(((PyObject *)__pyx_t_8)); __pyx_t_8 = 0;
+
+      /* "uvloop/handles/poll.pyx":214
+ *                 poll._loop._poll_read_events_total += 1
+ *             poll.reading_handle._run()
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_read_cb_errors_total += 1
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.__on_uvpoll_event", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_10, &__pyx_t_11) < 0) __PYX_ERR(15, 214, __pyx_L10_except_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_INCREF(__pyx_t_10);
+        __pyx_v_ex = __pyx_t_10;
+        /*try:*/ {
+
+          /* "uvloop/handles/poll.pyx":215
+ *             poll.reading_handle._run()
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 poll._loop._poll_read_cb_errors_total += 1
+ *             poll._error(ex, False)
+ */
+          __pyx_t_1 = (UVLOOP_DEBUG != 0);
+          if (__pyx_t_1) {
+
+            /* "uvloop/handles/poll.pyx":216
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_read_cb_errors_total += 1             # <<<<<<<<<<<<<<
+ *             poll._error(ex, False)
+ *             # continue code execution
+ */
+            __Pyx_INCREF(((PyObject *)__pyx_v_poll->__pyx_base._loop));
+            __pyx_t_8 = __pyx_v_poll->__pyx_base._loop;
+            __pyx_t_8->_poll_read_cb_errors_total = (__pyx_t_8->_poll_read_cb_errors_total + 1);
+            __Pyx_DECREF(((PyObject *)__pyx_t_8)); __pyx_t_8 = 0;
+
+            /* "uvloop/handles/poll.pyx":215
+ *             poll.reading_handle._run()
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 poll._loop._poll_read_cb_errors_total += 1
+ *             poll._error(ex, False)
+ */
+          }
+
+          /* "uvloop/handles/poll.pyx":217
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_read_cb_errors_total += 1
+ *             poll._error(ex, False)             # <<<<<<<<<<<<<<
+ *             # continue code execution
+ * 
+ */
+          __pyx_t_12 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->__pyx_base._error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_poll), __pyx_v_ex, Py_False); if (unlikely(!__pyx_t_12)) __PYX_ERR(15, 217, __pyx_L20_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+        }
+
+        /* "uvloop/handles/poll.pyx":214
+ *                 poll._loop._poll_read_events_total += 1
+ *             poll.reading_handle._run()
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_read_cb_errors_total += 1
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L21;
+          }
+          __pyx_L20_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(((PyObject *)__pyx_t_8)); __pyx_t_8 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __pyx_t_9 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+            }
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+            __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+            __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
+            goto __pyx_L10_except_error;
+          }
+          __pyx_L21:;
+        }
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        goto __pyx_L9_exception_handled;
+      }
+      goto __pyx_L10_except_error;
+      __pyx_L10_except_error:;
+
+      /* "uvloop/handles/poll.pyx":210
+ *             poll.reading_handle is not None):
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_read_events_total += 1
+ */
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+      goto __pyx_L1_error;
+      __pyx_L9_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+      __pyx_L13_try_end:;
+    }
+
+    /* "uvloop/handles/poll.pyx":207
+ *         return
+ * 
+ *     if ((events & (uv.UV_READABLE | uv.UV_DISCONNECT)) and             # <<<<<<<<<<<<<<
+ *             poll.reading_handle is not None):
+ * 
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":220
+ *             # continue code execution
+ * 
+ *     if ((events & (uv.UV_WRITABLE | uv.UV_DISCONNECT)) and             # <<<<<<<<<<<<<<
+ *             poll.writing_handle is not None):
+ * 
+ */
+  __pyx_t_4 = ((__pyx_v_events & (UV_WRITABLE | UV_DISCONNECT)) != 0);
+  if (__pyx_t_4) {
+  } else {
+    __pyx_t_1 = __pyx_t_4;
+    goto __pyx_L28_bool_binop_done;
+  }
+
+  /* "uvloop/handles/poll.pyx":221
+ * 
+ *     if ((events & (uv.UV_WRITABLE | uv.UV_DISCONNECT)) and
+ *             poll.writing_handle is not None):             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_t_4 = (((PyObject *)__pyx_v_poll->writing_handle) != Py_None);
+  __pyx_t_3 = (__pyx_t_4 != 0);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L28_bool_binop_done:;
+
+  /* "uvloop/handles/poll.pyx":220
+ *             # continue code execution
+ * 
+ *     if ((events & (uv.UV_WRITABLE | uv.UV_DISCONNECT)) and             # <<<<<<<<<<<<<<
+ *             poll.writing_handle is not None):
+ * 
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/poll.pyx":223
+ *             poll.writing_handle is not None):
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_write_events_total += 1
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_5);
+      /*try:*/ {
+
+        /* "uvloop/handles/poll.pyx":224
+ * 
+ *         try:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 poll._loop._poll_write_events_total += 1
+ *             poll.writing_handle._run()
+ */
+        __pyx_t_1 = (UVLOOP_DEBUG != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/handles/poll.pyx":225
+ *         try:
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_write_events_total += 1             # <<<<<<<<<<<<<<
+ *             poll.writing_handle._run()
+ *         except BaseException as ex:
+ */
+          __Pyx_INCREF(((PyObject *)__pyx_v_poll->__pyx_base._loop));
+          __pyx_t_8 = __pyx_v_poll->__pyx_base._loop;
+          __pyx_t_8->_poll_write_events_total = (__pyx_t_8->_poll_write_events_total + 1);
+          __Pyx_DECREF(((PyObject *)__pyx_t_8)); __pyx_t_8 = 0;
+
+          /* "uvloop/handles/poll.pyx":224
+ * 
+ *         try:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 poll._loop._poll_write_events_total += 1
+ *             poll.writing_handle._run()
+ */
+        }
+
+        /* "uvloop/handles/poll.pyx":226
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_write_events_total += 1
+ *             poll.writing_handle._run()             # <<<<<<<<<<<<<<
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:
+ */
+        __pyx_t_11 = __pyx_f_6uvloop_4loop_6Handle__run(__pyx_v_poll->writing_handle); if (unlikely(!__pyx_t_11)) __PYX_ERR(15, 226, __pyx_L30_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+
+        /* "uvloop/handles/poll.pyx":223
+ *             poll.writing_handle is not None):
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_write_events_total += 1
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      goto __pyx_L35_try_end;
+      __pyx_L30_error:;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(((PyObject *)__pyx_t_8)); __pyx_t_8 = 0;
+
+      /* "uvloop/handles/poll.pyx":227
+ *                 poll._loop._poll_write_events_total += 1
+ *             poll.writing_handle._run()
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_write_cb_errors_total += 1
+ */
+      __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_13) {
+        __Pyx_AddTraceback("uvloop.loop.__on_uvpoll_event", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_10, &__pyx_t_2) < 0) __PYX_ERR(15, 227, __pyx_L32_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_10);
+        __pyx_v_ex = __pyx_t_10;
+        /*try:*/ {
+
+          /* "uvloop/handles/poll.pyx":228
+ *             poll.writing_handle._run()
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 poll._loop._poll_write_cb_errors_total += 1
+ *             poll._error(ex, False)
+ */
+          __pyx_t_1 = (UVLOOP_DEBUG != 0);
+          if (__pyx_t_1) {
+
+            /* "uvloop/handles/poll.pyx":229
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_write_cb_errors_total += 1             # <<<<<<<<<<<<<<
+ *             poll._error(ex, False)
+ */
+            __Pyx_INCREF(((PyObject *)__pyx_v_poll->__pyx_base._loop));
+            __pyx_t_8 = __pyx_v_poll->__pyx_base._loop;
+            __pyx_t_8->_poll_write_cb_errors_total = (__pyx_t_8->_poll_write_cb_errors_total + 1);
+            __Pyx_DECREF(((PyObject *)__pyx_t_8)); __pyx_t_8 = 0;
+
+            /* "uvloop/handles/poll.pyx":228
+ *             poll.writing_handle._run()
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 poll._loop._poll_write_cb_errors_total += 1
+ *             poll._error(ex, False)
+ */
+          }
+
+          /* "uvloop/handles/poll.pyx":230
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_write_cb_errors_total += 1
+ *             poll._error(ex, False)             # <<<<<<<<<<<<<<
+ */
+          __pyx_t_12 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->__pyx_base._error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_poll), __pyx_v_ex, Py_False); if (unlikely(!__pyx_t_12)) __PYX_ERR(15, 230, __pyx_L42_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+        }
+
+        /* "uvloop/handles/poll.pyx":227
+ *                 poll._loop._poll_write_events_total += 1
+ *             poll.writing_handle._run()
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_write_cb_errors_total += 1
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L43;
+          }
+          __pyx_L42_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(((PyObject *)__pyx_t_8)); __pyx_t_8 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_16, &__pyx_t_15);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __pyx_t_13 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_21 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_XGIVEREF(__pyx_t_16);
+              __Pyx_XGIVEREF(__pyx_t_15);
+              __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15);
+            }
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_ErrRestore(__pyx_t_20, __pyx_t_19, __pyx_t_18);
+            __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+            __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_21;
+            goto __pyx_L32_except_error;
+          }
+          __pyx_L43:;
+        }
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        goto __pyx_L31_exception_handled;
+      }
+      goto __pyx_L32_except_error;
+      __pyx_L32_except_error:;
+
+      /* "uvloop/handles/poll.pyx":223
+ *             poll.writing_handle is not None):
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 poll._loop._poll_write_events_total += 1
+ */
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_6, __pyx_t_5);
+      goto __pyx_L1_error;
+      __pyx_L31_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_6, __pyx_t_5);
+      __pyx_L35_try_end:;
+    }
+
+    /* "uvloop/handles/poll.pyx":220
+ *             # continue code execution
+ * 
+ *     if ((events & (uv.UV_WRITABLE | uv.UV_DISCONNECT)) and             # <<<<<<<<<<<<<<
+ *             poll.writing_handle is not None):
+ * 
+ */
+  }
+
+  /* "uvloop/handles/poll.pyx":193
+ * 
+ * 
+ * cdef void __on_uvpoll_event(uv.uv_poll_t* handle,             # <<<<<<<<<<<<<<
+ *                             int status, int events) with gil:
+ * 
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(((PyObject *)__pyx_t_8));
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_WriteUnraisable("uvloop.loop.__on_uvpoll_event", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_poll);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/basetransport.pyx":3
+ * cdef class UVBaseTransport(UVSocketHandle):
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         # Flow control
+ *         self._high_water = FLOW_CONTROL_HIGH_WATER * 1024
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_15UVBaseTransport_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_15UVBaseTransport_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport___cinit__(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_15UVBaseTransport___cinit__(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "uvloop/handles/basetransport.pyx":5
+ *     def __cinit__(self):
+ *         # Flow control
+ *         self._high_water = FLOW_CONTROL_HIGH_WATER * 1024             # <<<<<<<<<<<<<<
+ *         self._low_water = FLOW_CONTROL_HIGH_WATER // 4
+ * 
+ */
+  __pyx_v_self->_high_water = 0x10000;
+
+  /* "uvloop/handles/basetransport.pyx":6
+ *         # Flow control
+ *         self._high_water = FLOW_CONTROL_HIGH_WATER * 1024
+ *         self._low_water = FLOW_CONTROL_HIGH_WATER // 4             # <<<<<<<<<<<<<<
+ * 
+ *         self._protocol = None
+ */
+  __pyx_v_self->_low_water = 16;
+
+  /* "uvloop/handles/basetransport.pyx":8
+ *         self._low_water = FLOW_CONTROL_HIGH_WATER // 4
+ * 
+ *         self._protocol = None             # <<<<<<<<<<<<<<
+ *         self._protocol_connected = 0
+ *         self._protocol_paused = 0
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_protocol);
+  __Pyx_DECREF(__pyx_v_self->_protocol);
+  __pyx_v_self->_protocol = Py_None;
+
+  /* "uvloop/handles/basetransport.pyx":9
+ * 
+ *         self._protocol = None
+ *         self._protocol_connected = 0             # <<<<<<<<<<<<<<
+ *         self._protocol_paused = 0
+ *         self._protocol_data_received = None
+ */
+  __pyx_v_self->_protocol_connected = 0;
+
+  /* "uvloop/handles/basetransport.pyx":10
+ *         self._protocol = None
+ *         self._protocol_connected = 0
+ *         self._protocol_paused = 0             # <<<<<<<<<<<<<<
+ *         self._protocol_data_received = None
+ * 
+ */
+  __pyx_v_self->_protocol_paused = 0;
+
+  /* "uvloop/handles/basetransport.pyx":11
+ *         self._protocol_connected = 0
+ *         self._protocol_paused = 0
+ *         self._protocol_data_received = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._server = None
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_protocol_data_received);
+  __Pyx_DECREF(__pyx_v_self->_protocol_data_received);
+  __pyx_v_self->_protocol_data_received = Py_None;
+
+  /* "uvloop/handles/basetransport.pyx":13
+ *         self._protocol_data_received = None
+ * 
+ *         self._server = None             # <<<<<<<<<<<<<<
+ *         self._waiter = None
+ *         self._extra_info = None
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_server);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_server));
+  __pyx_v_self->_server = ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None);
+
+  /* "uvloop/handles/basetransport.pyx":14
+ * 
+ *         self._server = None
+ *         self._waiter = None             # <<<<<<<<<<<<<<
+ *         self._extra_info = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_waiter);
+  __Pyx_DECREF(__pyx_v_self->_waiter);
+  __pyx_v_self->_waiter = Py_None;
+
+  /* "uvloop/handles/basetransport.pyx":15
+ *         self._server = None
+ *         self._waiter = None
+ *         self._extra_info = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._conn_lost = 0
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_extra_info);
+  __Pyx_DECREF(__pyx_v_self->_extra_info);
+  __pyx_v_self->_extra_info = ((PyObject*)Py_None);
+
+  /* "uvloop/handles/basetransport.pyx":17
+ *         self._extra_info = None
+ * 
+ *         self._conn_lost = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._closing = 0
+ */
+  __pyx_v_self->_conn_lost = 0;
+
+  /* "uvloop/handles/basetransport.pyx":19
+ *         self._conn_lost = 0
+ * 
+ *         self._closing = 0             # <<<<<<<<<<<<<<
+ * 
+ *     cdef size_t _get_write_buffer_size(self):
+ */
+  __pyx_v_self->_closing = 0;
+
+  /* "uvloop/handles/basetransport.pyx":3
+ * cdef class UVBaseTransport(UVSocketHandle):
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         # Flow control
+ *         self._high_water = FLOW_CONTROL_HIGH_WATER * 1024
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":21
+ *         self._closing = 0
+ * 
+ *     cdef size_t _get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         return 0
+ * 
+ */
+
+static size_t __pyx_f_6uvloop_4loop_15UVBaseTransport__get_write_buffer_size(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  size_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_get_write_buffer_size", 0);
+
+  /* "uvloop/handles/basetransport.pyx":22
+ * 
+ *     cdef size_t _get_write_buffer_size(self):
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _schedule_call_connection_made(self):
+ */
+  __pyx_r = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/basetransport.pyx":21
+ *         self._closing = 0
+ * 
+ *     cdef size_t _get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         return 0
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":24
+ *         return 0
+ * 
+ *     cdef inline _schedule_call_connection_made(self):             # <<<<<<<<<<<<<<
+ *         self._loop._call_soon_handle(
+ *             new_MethodHandle(self._loop,
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_made(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("_schedule_call_connection_made", 0);
+
+  /* "uvloop/handles/basetransport.pyx":26
+ *     cdef inline _schedule_call_connection_made(self):
+ *         self._loop._call_soon_handle(
+ *             new_MethodHandle(self._loop,             # <<<<<<<<<<<<<<
+ *                              "UVTransport._call_connection_made",
+ *                              <method_t>self._call_connection_made,
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop);
+  __Pyx_INCREF(__pyx_t_1);
+
+  /* "uvloop/handles/basetransport.pyx":29
+ *                              "UVTransport._call_connection_made",
+ *                              <method_t>self._call_connection_made,
+ *                              self.context,             # <<<<<<<<<<<<<<
+ *                              self))
+ * 
+ */
+  __pyx_t_2 = __pyx_v_self->__pyx_base.__pyx_base.context;
+  __Pyx_INCREF(__pyx_t_2);
+
+  /* "uvloop/handles/basetransport.pyx":26
+ *     cdef inline _schedule_call_connection_made(self):
+ *         self._loop._call_soon_handle(
+ *             new_MethodHandle(self._loop,             # <<<<<<<<<<<<<<
+ *                              "UVTransport._call_connection_made",
+ *                              <method_t>self._call_connection_made,
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_new_MethodHandle(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_1), __pyx_kp_u_UVTransport__call_connection_mad, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_call_connection_made), __pyx_t_2, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 26, __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;
+  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(16, 26, __pyx_L1_error)
+
+  /* "uvloop/handles/basetransport.pyx":25
+ * 
+ *     cdef inline _schedule_call_connection_made(self):
+ *         self._loop._call_soon_handle(             # <<<<<<<<<<<<<<
+ *             new_MethodHandle(self._loop,
+ *                              "UVTransport._call_connection_made",
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_self->__pyx_base.__pyx_base._loop, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 25, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":24
+ *         return 0
+ * 
+ *     cdef inline _schedule_call_connection_made(self):             # <<<<<<<<<<<<<<
+ *         self._loop._call_soon_handle(
+ *             new_MethodHandle(self._loop,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._schedule_call_connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":32
+ *                              self))
+ * 
+ *     cdef inline _schedule_call_connection_lost(self, exc):             # <<<<<<<<<<<<<<
+ *         self._loop._call_soon_handle(
+ *             new_MethodHandle1(self._loop,
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_lost(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("_schedule_call_connection_lost", 0);
+
+  /* "uvloop/handles/basetransport.pyx":34
+ *     cdef inline _schedule_call_connection_lost(self, exc):
+ *         self._loop._call_soon_handle(
+ *             new_MethodHandle1(self._loop,             # <<<<<<<<<<<<<<
+ *                               "UVTransport._call_connection_lost",
+ *                               <method1_t>self._call_connection_lost,
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop);
+  __Pyx_INCREF(__pyx_t_1);
+
+  /* "uvloop/handles/basetransport.pyx":37
+ *                               "UVTransport._call_connection_lost",
+ *                               <method1_t>self._call_connection_lost,
+ *                               self.context,             # <<<<<<<<<<<<<<
+ *                               self, exc))
+ * 
+ */
+  __pyx_t_2 = __pyx_v_self->__pyx_base.__pyx_base.context;
+  __Pyx_INCREF(__pyx_t_2);
+
+  /* "uvloop/handles/basetransport.pyx":34
+ *     cdef inline _schedule_call_connection_lost(self, exc):
+ *         self._loop._call_soon_handle(
+ *             new_MethodHandle1(self._loop,             # <<<<<<<<<<<<<<
+ *                               "UVTransport._call_connection_lost",
+ *                               <method1_t>self._call_connection_lost,
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_new_MethodHandle1(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_1), __pyx_kp_u_UVTransport__call_connection_los, ((__pyx_t_6uvloop_4loop_method1_t)((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_call_connection_lost), __pyx_t_2, ((PyObject *)__pyx_v_self), __pyx_v_exc); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 34, __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;
+  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(16, 34, __pyx_L1_error)
+
+  /* "uvloop/handles/basetransport.pyx":33
+ * 
+ *     cdef inline _schedule_call_connection_lost(self, exc):
+ *         self._loop._call_soon_handle(             # <<<<<<<<<<<<<<
+ *             new_MethodHandle1(self._loop,
+ *                               "UVTransport._call_connection_lost",
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_self->__pyx_base.__pyx_base._loop, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 33, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":32
+ *                              self))
+ * 
+ *     cdef inline _schedule_call_connection_lost(self, exc):             # <<<<<<<<<<<<<<
+ *         self._loop._call_soon_handle(
+ *             new_MethodHandle1(self._loop,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._schedule_call_connection_lost", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":40
+ *                               self, exc))
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):             # <<<<<<<<<<<<<<
+ *         # Overload UVHandle._fatal_error
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__fatal_error(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__fatal_error *__pyx_optional_args) {
+  PyObject *__pyx_v_reason = ((PyObject *)Py_None);
+  PyObject *__pyx_v_msg = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  Py_ssize_t __pyx_t_7;
+  Py_UCS4 __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_fatal_error", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_reason = __pyx_optional_args->reason;
+    }
+  }
+
+  /* "uvloop/handles/basetransport.pyx":43
+ *         # Overload UVHandle._fatal_error
+ * 
+ *         self._force_close(exc)             # <<<<<<<<<<<<<<
+ * 
+ *         if not isinstance(exc, OSError):
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_force_close); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_exc);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 43, __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;
+
+  /* "uvloop/handles/basetransport.pyx":45
+ *         self._force_close(exc)
+ * 
+ *         if not isinstance(exc, OSError):             # <<<<<<<<<<<<<<
+ * 
+ *             if throw or self._loop is None:
+ */
+  __pyx_t_4 = PyObject_IsInstance(__pyx_v_exc, __pyx_builtin_OSError); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(16, 45, __pyx_L1_error)
+  __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/handles/basetransport.pyx":47
+ *         if not isinstance(exc, OSError):
+ * 
+ *             if throw or self._loop is None:             # <<<<<<<<<<<<<<
+ *                 raise exc
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_throw); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(16, 47, __pyx_L1_error)
+    if (!__pyx_t_4) {
+    } else {
+      __pyx_t_5 = __pyx_t_4;
+      goto __pyx_L5_bool_binop_done;
+    }
+    __pyx_t_4 = (((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop) == Py_None);
+    __pyx_t_6 = (__pyx_t_4 != 0);
+    __pyx_t_5 = __pyx_t_6;
+    __pyx_L5_bool_binop_done:;
+    if (unlikely(__pyx_t_5)) {
+
+      /* "uvloop/handles/basetransport.pyx":48
+ * 
+ *             if throw or self._loop is None:
+ *                 raise exc             # <<<<<<<<<<<<<<
+ * 
+ *             msg = f'Fatal error on transport {self.__class__.__name__}'
+ */
+      __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+      __PYX_ERR(16, 48, __pyx_L1_error)
+
+      /* "uvloop/handles/basetransport.pyx":47
+ *         if not isinstance(exc, OSError):
+ * 
+ *             if throw or self._loop is None:             # <<<<<<<<<<<<<<
+ *                 raise exc
+ * 
+ */
+    }
+
+    /* "uvloop/handles/basetransport.pyx":50
+ *                 raise exc
+ * 
+ *             msg = f'Fatal error on transport {self.__class__.__name__}'             # <<<<<<<<<<<<<<
+ *             if reason is not None:
+ *                 msg = f'{msg} ({reason})'
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 50, __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(16, 50, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 50, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Fatal_error_on_transport, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 50, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_v_msg = ((PyObject*)__pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/basetransport.pyx":51
+ * 
+ *             msg = f'Fatal error on transport {self.__class__.__name__}'
+ *             if reason is not None:             # <<<<<<<<<<<<<<
+ *                 msg = f'{msg} ({reason})'
+ * 
+ */
+    __pyx_t_5 = (__pyx_v_reason != Py_None);
+    __pyx_t_6 = (__pyx_t_5 != 0);
+    if (__pyx_t_6) {
+
+      /* "uvloop/handles/basetransport.pyx":52
+ *             msg = f'Fatal error on transport {self.__class__.__name__}'
+ *             if reason is not None:
+ *                 msg = f'{msg} ({reason})'             # <<<<<<<<<<<<<<
+ * 
+ *             self._loop.call_exception_handler({
+ */
+      __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 52, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_7 = 0;
+      __pyx_t_8 = 127;
+      __Pyx_INCREF(__pyx_v_msg);
+      __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_v_msg) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_v_msg) : __pyx_t_8;
+      __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_v_msg);
+      __Pyx_GIVEREF(__pyx_v_msg);
+      PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg);
+      __Pyx_INCREF(__pyx_kp_u__133);
+      __pyx_t_7 += 2;
+      __Pyx_GIVEREF(__pyx_kp_u__133);
+      PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_kp_u__133);
+      __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_reason, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 52, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_8;
+      __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_1);
+      PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_1);
+      __pyx_t_1 = 0;
+      __Pyx_INCREF(__pyx_kp_u__134);
+      __pyx_t_7 += 1;
+      __Pyx_GIVEREF(__pyx_kp_u__134);
+      PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_kp_u__134);
+      __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 52, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF_SET(__pyx_v_msg, ((PyObject*)__pyx_t_1));
+      __pyx_t_1 = 0;
+
+      /* "uvloop/handles/basetransport.pyx":51
+ * 
+ *             msg = f'Fatal error on transport {self.__class__.__name__}'
+ *             if reason is not None:             # <<<<<<<<<<<<<<
+ *                 msg = f'{msg} ({reason})'
+ * 
+ */
+    }
+
+    /* "uvloop/handles/basetransport.pyx":54
+ *                 msg = f'{msg} ({reason})'
+ * 
+ *             self._loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *                 'message': msg,
+ *                 'exception': exc,
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 54, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+
+    /* "uvloop/handles/basetransport.pyx":55
+ * 
+ *             self._loop.call_exception_handler({
+ *                 'message': msg,             # <<<<<<<<<<<<<<
+ *                 'exception': exc,
+ *                 'transport': self,
+ */
+    __pyx_t_3 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 55, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_message, __pyx_v_msg) < 0) __PYX_ERR(16, 55, __pyx_L1_error)
+
+    /* "uvloop/handles/basetransport.pyx":56
+ *             self._loop.call_exception_handler({
+ *                 'message': msg,
+ *                 'exception': exc,             # <<<<<<<<<<<<<<
+ *                 'transport': self,
+ *                 'protocol': self._protocol,
+ */
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_exception, __pyx_v_exc) < 0) __PYX_ERR(16, 55, __pyx_L1_error)
+
+    /* "uvloop/handles/basetransport.pyx":57
+ *                 'message': msg,
+ *                 'exception': exc,
+ *                 'transport': self,             # <<<<<<<<<<<<<<
+ *                 'protocol': self._protocol,
+ *             })
+ */
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_transport, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(16, 55, __pyx_L1_error)
+
+    /* "uvloop/handles/basetransport.pyx":58
+ *                 'exception': exc,
+ *                 'transport': self,
+ *                 'protocol': self._protocol,             # <<<<<<<<<<<<<<
+ *             })
+ * 
+ */
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_protocol, __pyx_v_self->_protocol) < 0) __PYX_ERR(16, 55, __pyx_L1_error)
+    __pyx_t_9 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_9, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 54, __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;
+
+    /* "uvloop/handles/basetransport.pyx":45
+ *         self._force_close(exc)
+ * 
+ *         if not isinstance(exc, OSError):             # <<<<<<<<<<<<<<
+ * 
+ *             if throw or self._loop is None:
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":40
+ *                               self, exc))
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):             # <<<<<<<<<<<<<<
+ *         # Overload UVHandle._fatal_error
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_9);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._fatal_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_msg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":61
+ *             })
+ * 
+ *     cdef inline _maybe_pause_protocol(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             size_t size = self._get_write_buffer_size()
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_pause_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  size_t __pyx_v_size;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_t_13;
+  char const *__pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_maybe_pause_protocol", 0);
+
+  /* "uvloop/handles/basetransport.pyx":63
+ *     cdef inline _maybe_pause_protocol(self):
+ *         cdef:
+ *             size_t size = self._get_write_buffer_size()             # <<<<<<<<<<<<<<
+ * 
+ *         if size <= self._high_water:
+ */
+  __pyx_v_size = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_get_write_buffer_size(__pyx_v_self);
+
+  /* "uvloop/handles/basetransport.pyx":65
+ *             size_t size = self._get_write_buffer_size()
+ * 
+ *         if size <= self._high_water:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_size <= __pyx_v_self->_high_water) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":66
+ * 
+ *         if size <= self._high_water:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if not self._protocol_paused:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/basetransport.pyx":65
+ *             size_t size = self._get_write_buffer_size()
+ * 
+ *         if size <= self._high_water:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":68
+ *             return
+ * 
+ *         if not self._protocol_paused:             # <<<<<<<<<<<<<<
+ *             self._protocol_paused = 1
+ *             try:
+ */
+  __pyx_t_1 = ((!(__pyx_v_self->_protocol_paused != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":69
+ * 
+ *         if not self._protocol_paused:
+ *             self._protocol_paused = 1             # <<<<<<<<<<<<<<
+ *             try:
+ *                 # _maybe_pause_protocol() is always triggered from user-calls,
+ */
+    __pyx_v_self->_protocol_paused = 1;
+
+    /* "uvloop/handles/basetransport.pyx":70
+ *         if not self._protocol_paused:
+ *             self._protocol_paused = 1
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # _maybe_pause_protocol() is always triggered from user-calls,
+ *                 # so we must copy the context to avoid entering context twice
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_2);
+      __Pyx_XGOTREF(__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_4);
+      /*try:*/ {
+
+        /* "uvloop/handles/basetransport.pyx":74
+ *                 # so we must copy the context to avoid entering context twice
+ *                 run_in_context(
+ *                     self.context.copy(), self._protocol.pause_writing,             # <<<<<<<<<<<<<<
+ *                 )
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base.__pyx_base.context, __pyx_n_s_copy); if (unlikely(!__pyx_t_6)) __PYX_ERR(16, 74, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __pyx_t_7 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+          __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+          if (likely(__pyx_t_7)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+            __Pyx_INCREF(__pyx_t_7);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_6, function);
+          }
+        }
+        __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 74, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_n_s_pause_writing); if (unlikely(!__pyx_t_6)) __PYX_ERR(16, 74, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_6);
+
+        /* "uvloop/handles/basetransport.pyx":73
+ *                 # _maybe_pause_protocol() is always triggered from user-calls,
+ *                 # so we must copy the context to avoid entering context twice
+ *                 run_in_context(             # <<<<<<<<<<<<<<
+ *                     self.context.copy(), self._protocol.pause_writing,
+ *                 )
+ */
+        __pyx_t_7 = __pyx_f_6uvloop_4loop_run_in_context(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(16, 73, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+        /* "uvloop/handles/basetransport.pyx":70
+ *         if not self._protocol_paused:
+ *             self._protocol_paused = 1
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # _maybe_pause_protocol() is always triggered from user-calls,
+ *                 # so we must copy the context to avoid entering context twice
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L10_try_end;
+      __pyx_L5_error:;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/handles/basetransport.pyx":76
+ *                     self.context.copy(), self._protocol.pause_writing,
+ *                 )
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException as exc:
+ */
+      __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_8) {
+        __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._maybe_pause_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5) < 0) __PYX_ERR(16, 76, __pyx_L7_except_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_5);
+
+        /* "uvloop/handles/basetransport.pyx":77
+ *                 )
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({
+ */
+        __Pyx_GIVEREF(__pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_5);
+        __Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_6, __pyx_t_5);
+        __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; 
+        __PYX_ERR(16, 77, __pyx_L7_except_error)
+      }
+
+      /* "uvloop/handles/basetransport.pyx":78
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as exc:             # <<<<<<<<<<<<<<
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.pause_writing() failed',
+ */
+      __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_8) {
+        __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._maybe_pause_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(16, 78, __pyx_L7_except_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_6);
+        __pyx_v_exc = __pyx_t_6;
+        /*try:*/ {
+
+          /* "uvloop/handles/basetransport.pyx":79
+ *                 raise
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *                     'message': 'protocol.pause_writing() failed',
+ *                     'exception': exc,
+ */
+          __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_10)) __PYX_ERR(16, 79, __pyx_L18_error)
+          __Pyx_GOTREF(__pyx_t_10);
+
+          /* "uvloop/handles/basetransport.pyx":80
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.pause_writing() failed',             # <<<<<<<<<<<<<<
+ *                     'exception': exc,
+ *                     'transport': self,
+ */
+          __pyx_t_11 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_11)) __PYX_ERR(16, 80, __pyx_L18_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          if (PyDict_SetItem(__pyx_t_11, __pyx_n_u_message, __pyx_kp_u_protocol_pause_writing_failed) < 0) __PYX_ERR(16, 80, __pyx_L18_error)
+
+          /* "uvloop/handles/basetransport.pyx":81
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.pause_writing() failed',
+ *                     'exception': exc,             # <<<<<<<<<<<<<<
+ *                     'transport': self,
+ *                     'protocol': self._protocol,
+ */
+          if (PyDict_SetItem(__pyx_t_11, __pyx_n_u_exception, __pyx_v_exc) < 0) __PYX_ERR(16, 80, __pyx_L18_error)
+
+          /* "uvloop/handles/basetransport.pyx":82
+ *                     'message': 'protocol.pause_writing() failed',
+ *                     'exception': exc,
+ *                     'transport': self,             # <<<<<<<<<<<<<<
+ *                     'protocol': self._protocol,
+ *                 })
+ */
+          if (PyDict_SetItem(__pyx_t_11, __pyx_n_u_transport, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(16, 80, __pyx_L18_error)
+
+          /* "uvloop/handles/basetransport.pyx":83
+ *                     'exception': exc,
+ *                     'transport': self,
+ *                     'protocol': self._protocol,             # <<<<<<<<<<<<<<
+ *                 })
+ * 
+ */
+          if (PyDict_SetItem(__pyx_t_11, __pyx_n_u_protocol, __pyx_v_self->_protocol) < 0) __PYX_ERR(16, 80, __pyx_L18_error)
+          __pyx_t_12 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
+            __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_10);
+            if (likely(__pyx_t_12)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+              __Pyx_INCREF(__pyx_t_12);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_10, function);
+            }
+          }
+          __pyx_t_9 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_12, __pyx_t_11) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_11);
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          if (unlikely(!__pyx_t_9)) __PYX_ERR(16, 79, __pyx_L18_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        }
+
+        /* "uvloop/handles/basetransport.pyx":78
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as exc:             # <<<<<<<<<<<<<<
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.pause_writing() failed',
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+            goto __pyx_L19;
+          }
+          __pyx_L18_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __pyx_t_8 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_exc);
+              __pyx_v_exc = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+            }
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+            __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+            __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
+            goto __pyx_L7_except_error;
+          }
+          __pyx_L19:;
+        }
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L6_exception_handled;
+      }
+      goto __pyx_L7_except_error;
+      __pyx_L7_except_error:;
+
+      /* "uvloop/handles/basetransport.pyx":70
+ *         if not self._protocol_paused:
+ *             self._protocol_paused = 1
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # _maybe_pause_protocol() is always triggered from user-calls,
+ *                 # so we must copy the context to avoid entering context twice
+ */
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+      goto __pyx_L1_error;
+      __pyx_L6_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+      __pyx_L10_try_end:;
+    }
+
+    /* "uvloop/handles/basetransport.pyx":68
+ *             return
+ * 
+ *         if not self._protocol_paused:             # <<<<<<<<<<<<<<
+ *             self._protocol_paused = 1
+ *             try:
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":61
+ *             })
+ * 
+ *     cdef inline _maybe_pause_protocol(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             size_t size = self._get_write_buffer_size()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._maybe_pause_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":86
+ *                 })
+ * 
+ *     cdef inline _maybe_resume_protocol(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             size_t size = self._get_write_buffer_size()
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_resume_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  size_t __pyx_v_size;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_t_14;
+  char const *__pyx_t_15;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_maybe_resume_protocol", 0);
+
+  /* "uvloop/handles/basetransport.pyx":88
+ *     cdef inline _maybe_resume_protocol(self):
+ *         cdef:
+ *             size_t size = self._get_write_buffer_size()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._protocol_paused and size <= self._low_water:
+ */
+  __pyx_v_size = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_get_write_buffer_size(__pyx_v_self);
+
+  /* "uvloop/handles/basetransport.pyx":90
+ *             size_t size = self._get_write_buffer_size()
+ * 
+ *         if self._protocol_paused and size <= self._low_water:             # <<<<<<<<<<<<<<
+ *             self._protocol_paused = 0
+ *             try:
+ */
+  __pyx_t_2 = (__pyx_v_self->_protocol_paused != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = ((__pyx_v_size <= __pyx_v_self->_low_water) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":91
+ * 
+ *         if self._protocol_paused and size <= self._low_water:
+ *             self._protocol_paused = 0             # <<<<<<<<<<<<<<
+ *             try:
+ *                 # We're copying the context to avoid entering context twice,
+ */
+    __pyx_v_self->_protocol_paused = 0;
+
+    /* "uvloop/handles/basetransport.pyx":92
+ *         if self._protocol_paused and size <= self._low_water:
+ *             self._protocol_paused = 0
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # We're copying the context to avoid entering context twice,
+ *                 # even though it's not always necessary to copy - it's easier
+ */
+    {
+      __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:*/ {
+
+        /* "uvloop/handles/basetransport.pyx":97
+ *                 # to copy here than passing down a copied context.
+ *                 run_in_context(
+ *                     self.context.copy(), self._protocol.resume_writing,             # <<<<<<<<<<<<<<
+ *                 )
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base.__pyx_base.context, __pyx_n_s_copy); if (unlikely(!__pyx_t_7)) __PYX_ERR(16, 97, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __pyx_t_8 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+          if (likely(__pyx_t_8)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+            __Pyx_INCREF(__pyx_t_8);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_7, function);
+          }
+        }
+        __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (unlikely(!__pyx_t_6)) __PYX_ERR(16, 97, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_n_s_resume_writing); if (unlikely(!__pyx_t_7)) __PYX_ERR(16, 97, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_7);
+
+        /* "uvloop/handles/basetransport.pyx":96
+ *                 # even though it's not always necessary to copy - it's easier
+ *                 # to copy here than passing down a copied context.
+ *                 run_in_context(             # <<<<<<<<<<<<<<
+ *                     self.context.copy(), self._protocol.resume_writing,
+ *                 )
+ */
+        __pyx_t_8 = __pyx_f_6uvloop_4loop_run_in_context(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(16, 96, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+        /* "uvloop/handles/basetransport.pyx":92
+ *         if self._protocol_paused and size <= self._low_water:
+ *             self._protocol_paused = 0
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # We're copying the context to avoid entering context twice,
+ *                 # even though it's not always necessary to copy - it's easier
+ */
+      }
+      __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_L11_try_end;
+      __pyx_L6_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;
+
+      /* "uvloop/handles/basetransport.pyx":99
+ *                     self.context.copy(), self._protocol.resume_writing,
+ *                 )
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException as exc:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._maybe_resume_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(16, 99, __pyx_L8_except_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_6);
+
+        /* "uvloop/handles/basetransport.pyx":100
+ *                 )
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({
+ */
+        __Pyx_GIVEREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __Pyx_ErrRestoreWithState(__pyx_t_8, __pyx_t_7, __pyx_t_6);
+        __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_6 = 0; 
+        __PYX_ERR(16, 100, __pyx_L8_except_error)
+      }
+
+      /* "uvloop/handles/basetransport.pyx":101
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as exc:             # <<<<<<<<<<<<<<
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.resume_writing() failed',
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._maybe_resume_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(16, 101, __pyx_L8_except_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_7);
+        __pyx_v_exc = __pyx_t_7;
+        /*try:*/ {
+
+          /* "uvloop/handles/basetransport.pyx":102
+ *                 raise
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *                     'message': 'protocol.resume_writing() failed',
+ *                     'exception': exc,
+ */
+          __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_11)) __PYX_ERR(16, 102, __pyx_L19_error)
+          __Pyx_GOTREF(__pyx_t_11);
+
+          /* "uvloop/handles/basetransport.pyx":103
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.resume_writing() failed',             # <<<<<<<<<<<<<<
+ *                     'exception': exc,
+ *                     'transport': self,
+ */
+          __pyx_t_12 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_12)) __PYX_ERR(16, 103, __pyx_L19_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_message, __pyx_kp_u_protocol_resume_writing_failed) < 0) __PYX_ERR(16, 103, __pyx_L19_error)
+
+          /* "uvloop/handles/basetransport.pyx":104
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.resume_writing() failed',
+ *                     'exception': exc,             # <<<<<<<<<<<<<<
+ *                     'transport': self,
+ *                     'protocol': self._protocol,
+ */
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_exception, __pyx_v_exc) < 0) __PYX_ERR(16, 103, __pyx_L19_error)
+
+          /* "uvloop/handles/basetransport.pyx":105
+ *                     'message': 'protocol.resume_writing() failed',
+ *                     'exception': exc,
+ *                     'transport': self,             # <<<<<<<<<<<<<<
+ *                     'protocol': self._protocol,
+ *                 })
+ */
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_transport, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(16, 103, __pyx_L19_error)
+
+          /* "uvloop/handles/basetransport.pyx":106
+ *                     'exception': exc,
+ *                     'transport': self,
+ *                     'protocol': self._protocol,             # <<<<<<<<<<<<<<
+ *                 })
+ * 
+ */
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_protocol, __pyx_v_self->_protocol) < 0) __PYX_ERR(16, 103, __pyx_L19_error)
+          __pyx_t_13 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+            __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_11);
+            if (likely(__pyx_t_13)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+              __Pyx_INCREF(__pyx_t_13);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_11, function);
+            }
+          }
+          __pyx_t_10 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_13, __pyx_t_12) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_12);
+          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (unlikely(!__pyx_t_10)) __PYX_ERR(16, 102, __pyx_L19_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        }
+
+        /* "uvloop/handles/basetransport.pyx":101
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as exc:             # <<<<<<<<<<<<<<
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.resume_writing() failed',
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+            goto __pyx_L20;
+          }
+          __pyx_L19_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __Pyx_XGOTREF(__pyx_t_21);
+            __pyx_t_9 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_exc);
+              __pyx_v_exc = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_XGIVEREF(__pyx_t_21);
+              __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
+            }
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+            __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
+            __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
+            goto __pyx_L8_except_error;
+          }
+          __pyx_L20:;
+        }
+        __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;
+        goto __pyx_L7_exception_handled;
+      }
+      goto __pyx_L8_except_error;
+      __pyx_L8_except_error:;
+
+      /* "uvloop/handles/basetransport.pyx":92
+ *         if self._protocol_paused and size <= self._low_water:
+ *             self._protocol_paused = 0
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # We're copying the context to avoid entering context twice,
+ *                 # even though it's not always necessary to copy - it's easier
+ */
+      __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_L7_exception_handled:;
+      __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);
+      __pyx_L11_try_end:;
+    }
+
+    /* "uvloop/handles/basetransport.pyx":90
+ *             size_t size = self._get_write_buffer_size()
+ * 
+ *         if self._protocol_paused and size <= self._low_water:             # <<<<<<<<<<<<<<
+ *             self._protocol_paused = 0
+ *             try:
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":86
+ *                 })
+ * 
+ *     cdef inline _maybe_resume_protocol(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             size_t size = self._get_write_buffer_size()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._maybe_resume_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":109
+ *                 })
+ * 
+ *     cdef _wakeup_waiter(self):             # <<<<<<<<<<<<<<
+ *         if self._waiter is not None:
+ *             if not self._waiter.cancelled():
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__wakeup_waiter(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_wakeup_waiter", 0);
+
+  /* "uvloop/handles/basetransport.pyx":110
+ * 
+ *     cdef _wakeup_waiter(self):
+ *         if self._waiter is not None:             # <<<<<<<<<<<<<<
+ *             if not self._waiter.cancelled():
+ *                 if not self._is_alive():
+ */
+  __pyx_t_1 = (__pyx_v_self->_waiter != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/basetransport.pyx":111
+ *     cdef _wakeup_waiter(self):
+ *         if self._waiter is not None:
+ *             if not self._waiter.cancelled():             # <<<<<<<<<<<<<<
+ *                 if not self._is_alive():
+ *                     self._waiter.set_exception(
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_waiter, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 111, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 111, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(16, 111, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_1 = ((!__pyx_t_2) != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/basetransport.pyx":112
+ *         if self._waiter is not None:
+ *             if not self._waiter.cancelled():
+ *                 if not self._is_alive():             # <<<<<<<<<<<<<<
+ *                     self._waiter.set_exception(
+ *                         RuntimeError(
+ */
+      __pyx_t_1 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)) != 0)) != 0);
+      if (__pyx_t_1) {
+
+        /* "uvloop/handles/basetransport.pyx":113
+ *             if not self._waiter.cancelled():
+ *                 if not self._is_alive():
+ *                     self._waiter.set_exception(             # <<<<<<<<<<<<<<
+ *                         RuntimeError(
+ *                             'closed Transport handle and unset waiter'))
+ */
+        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_waiter, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 113, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+
+        /* "uvloop/handles/basetransport.pyx":114
+ *                 if not self._is_alive():
+ *                     self._waiter.set_exception(
+ *                         RuntimeError(             # <<<<<<<<<<<<<<
+ *                             'closed Transport handle and unset waiter'))
+ *                 else:
+ */
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__135, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 114, __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_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_4, function);
+          }
+        }
+        __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(16, 113, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/handles/basetransport.pyx":112
+ *         if self._waiter is not None:
+ *             if not self._waiter.cancelled():
+ *                 if not self._is_alive():             # <<<<<<<<<<<<<<
+ *                     self._waiter.set_exception(
+ *                         RuntimeError(
+ */
+        goto __pyx_L5;
+      }
+
+      /* "uvloop/handles/basetransport.pyx":117
+ *                             'closed Transport handle and unset waiter'))
+ *                 else:
+ *                     self._waiter.set_result(True)             # <<<<<<<<<<<<<<
+ *             self._waiter = None
+ * 
+ */
+      /*else*/ {
+        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 117, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_5 = NULL;
+        if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, Py_True) : __Pyx_PyObject_CallOneArg(__pyx_t_4, Py_True);
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 117, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      }
+      __pyx_L5:;
+
+      /* "uvloop/handles/basetransport.pyx":111
+ *     cdef _wakeup_waiter(self):
+ *         if self._waiter is not None:
+ *             if not self._waiter.cancelled():             # <<<<<<<<<<<<<<
+ *                 if not self._is_alive():
+ *                     self._waiter.set_exception(
+ */
+    }
+
+    /* "uvloop/handles/basetransport.pyx":118
+ *                 else:
+ *                     self._waiter.set_result(True)
+ *             self._waiter = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _call_connection_made(self):
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_waiter);
+    __Pyx_DECREF(__pyx_v_self->_waiter);
+    __pyx_v_self->_waiter = Py_None;
+
+    /* "uvloop/handles/basetransport.pyx":110
+ * 
+ *     cdef _wakeup_waiter(self):
+ *         if self._waiter is not None:             # <<<<<<<<<<<<<<
+ *             if not self._waiter.cancelled():
+ *                 if not self._is_alive():
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":109
+ *                 })
+ * 
+ *     cdef _wakeup_waiter(self):             # <<<<<<<<<<<<<<
+ *         if self._waiter is not None:
+ *             if not self._waiter.cancelled():
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._wakeup_waiter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":120
+ *             self._waiter = None
+ * 
+ *     cdef _call_connection_made(self):             # <<<<<<<<<<<<<<
+ *         if self._protocol is None:
+ *             raise RuntimeError(
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__call_connection_made(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_call_connection_made", 0);
+
+  /* "uvloop/handles/basetransport.pyx":121
+ * 
+ *     cdef _call_connection_made(self):
+ *         if self._protocol is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'protocol is not set, cannot call connection_made()')
+ */
+  __pyx_t_1 = (__pyx_v_self->_protocol == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/basetransport.pyx":122
+ *     cdef _call_connection_made(self):
+ *         if self._protocol is None:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'protocol is not set, cannot call connection_made()')
+ * 
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__136, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 122, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(16, 122, __pyx_L1_error)
+
+    /* "uvloop/handles/basetransport.pyx":121
+ * 
+ *     cdef _call_connection_made(self):
+ *         if self._protocol is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'protocol is not set, cannot call connection_made()')
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":128
+ *         # `transport._close()` in `loop.create_connection()` if an
+ *         # exception happens during `await waiter`.
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             # A connection waiter can be cancelled between
+ *             # 'await loop.create_connection()' and
+ */
+  __pyx_t_2 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)) != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/basetransport.pyx":133
+ *             # `_schedule_call_connection_made` and
+ *             # the actual `_call_connection_made`.
+ *             self._wakeup_waiter()             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_wakeup_waiter(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 133, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/basetransport.pyx":134
+ *             # the actual `_call_connection_made`.
+ *             self._wakeup_waiter()
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         # Set _protocol_connected to 1 before calling "connection_made":
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/basetransport.pyx":128
+ *         # `transport._close()` in `loop.create_connection()` if an
+ *         # exception happens during `await waiter`.
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             # A connection waiter can be cancelled between
+ *             # 'await loop.create_connection()' and
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":139
+ *         # if transport is aborted or closed, "connection_lost" will
+ *         # still be scheduled.
+ *         self._protocol_connected = 1             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_v_self->_protocol_connected = 1;
+
+  /* "uvloop/handles/basetransport.pyx":141
+ *         self._protocol_connected = 1
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._protocol.connection_made(self)
+ *         except BaseException:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_6);
+    /*try:*/ {
+
+      /* "uvloop/handles/basetransport.pyx":142
+ * 
+ *         try:
+ *             self._protocol.connection_made(self)             # <<<<<<<<<<<<<<
+ *         except BaseException:
+ *             self._wakeup_waiter()
+ */
+      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_n_s_connection_made); if (unlikely(!__pyx_t_7)) __PYX_ERR(16, 142, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_8 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+        if (likely(__pyx_t_8)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+          __Pyx_INCREF(__pyx_t_8);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_7, function);
+        }
+      }
+      __pyx_t_3 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_7, ((PyObject *)__pyx_v_self));
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 142, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/basetransport.pyx":141
+ *         self._protocol_connected = 1
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._protocol.connection_made(self)
+ *         except BaseException:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L5_error:;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+    /* "uvloop/handles/basetransport.pyx":143
+ *         try:
+ *             self._protocol.connection_made(self)
+ *         except BaseException:             # <<<<<<<<<<<<<<
+ *             self._wakeup_waiter()
+ *             raise
+ */
+    __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_9) {
+      __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._call_connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(16, 143, __pyx_L7_except_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_8);
+
+      /* "uvloop/handles/basetransport.pyx":144
+ *             self._protocol.connection_made(self)
+ *         except BaseException:
+ *             self._wakeup_waiter()             # <<<<<<<<<<<<<<
+ *             raise
+ * 
+ */
+      __pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_wakeup_waiter(__pyx_v_self); if (unlikely(!__pyx_t_10)) __PYX_ERR(16, 144, __pyx_L7_except_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+      /* "uvloop/handles/basetransport.pyx":145
+ *         except BaseException:
+ *             self._wakeup_waiter()
+ *             raise             # <<<<<<<<<<<<<<
+ * 
+ *         if not self._is_alive():
+ */
+      __Pyx_GIVEREF(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_7, __pyx_t_8);
+      __pyx_t_3 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; 
+      __PYX_ERR(16, 145, __pyx_L7_except_error)
+    }
+    goto __pyx_L7_except_error;
+    __pyx_L7_except_error:;
+
+    /* "uvloop/handles/basetransport.pyx":141
+ *         self._protocol_connected = 1
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._protocol.connection_made(self)
+ *         except BaseException:
+ */
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "uvloop/handles/basetransport.pyx":147
+ *             raise
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             # This might happen when "transport.abort()" is called
+ *             # from "Protocol.connection_made".
+ */
+  __pyx_t_2 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)) != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/basetransport.pyx":150
+ *             # This might happen when "transport.abort()" is called
+ *             # from "Protocol.connection_made".
+ *             self._wakeup_waiter()             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_wakeup_waiter(__pyx_v_self); if (unlikely(!__pyx_t_8)) __PYX_ERR(16, 150, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+    /* "uvloop/handles/basetransport.pyx":151
+ *             # from "Protocol.connection_made".
+ *             self._wakeup_waiter()
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._start_reading()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/basetransport.pyx":147
+ *             raise
+ * 
+ *         if not self._is_alive():             # <<<<<<<<<<<<<<
+ *             # This might happen when "transport.abort()" is called
+ *             # from "Protocol.connection_made".
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":153
+ *             return
+ * 
+ *         self._start_reading()             # <<<<<<<<<<<<<<
+ *         self._wakeup_waiter()
+ * 
+ */
+  __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_start_reading(__pyx_v_self); if (unlikely(!__pyx_t_8)) __PYX_ERR(16, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":154
+ * 
+ *         self._start_reading()
+ *         self._wakeup_waiter()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _call_connection_lost(self, exc):
+ */
+  __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_wakeup_waiter(__pyx_v_self); if (unlikely(!__pyx_t_8)) __PYX_ERR(16, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":120
+ *             self._waiter = None
+ * 
+ *     cdef _call_connection_made(self):             # <<<<<<<<<<<<<<
+ *         if self._protocol is None:
+ *             raise RuntimeError(
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._call_connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":156
+ *         self._wakeup_waiter()
+ * 
+ *     cdef _call_connection_lost(self, exc):             # <<<<<<<<<<<<<<
+ *         if self._waiter is not None:
+ *             if not self._waiter.done():
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__call_connection_lost(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc) {
+  struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  char const *__pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_call_connection_lost", 0);
+
+  /* "uvloop/handles/basetransport.pyx":157
+ * 
+ *     cdef _call_connection_lost(self, exc):
+ *         if self._waiter is not None:             # <<<<<<<<<<<<<<
+ *             if not self._waiter.done():
+ *                 self._waiter.set_exception(exc)
+ */
+  __pyx_t_1 = (__pyx_v_self->_waiter != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/basetransport.pyx":158
+ *     cdef _call_connection_lost(self, exc):
+ *         if self._waiter is not None:
+ *             if not self._waiter.done():             # <<<<<<<<<<<<<<
+ *                 self._waiter.set_exception(exc)
+ *             self._waiter = None
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_waiter, __pyx_n_s_done); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 158, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 158, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(16, 158, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_1 = ((!__pyx_t_2) != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/basetransport.pyx":159
+ *         if self._waiter is not None:
+ *             if not self._waiter.done():
+ *                 self._waiter.set_exception(exc)             # <<<<<<<<<<<<<<
+ *             self._waiter = None
+ * 
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_waiter, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 159, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_exc);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 159, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/basetransport.pyx":158
+ *     cdef _call_connection_lost(self, exc):
+ *         if self._waiter is not None:
+ *             if not self._waiter.done():             # <<<<<<<<<<<<<<
+ *                 self._waiter.set_exception(exc)
+ *             self._waiter = None
+ */
+    }
+
+    /* "uvloop/handles/basetransport.pyx":160
+ *             if not self._waiter.done():
+ *                 self._waiter.set_exception(exc)
+ *             self._waiter = None             # <<<<<<<<<<<<<<
+ * 
+ *         if self._closed:
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_waiter);
+    __Pyx_DECREF(__pyx_v_self->_waiter);
+    __pyx_v_self->_waiter = Py_None;
+
+    /* "uvloop/handles/basetransport.pyx":157
+ * 
+ *     cdef _call_connection_lost(self, exc):
+ *         if self._waiter is not None:             # <<<<<<<<<<<<<<
+ *             if not self._waiter.done():
+ *                 self._waiter.set_exception(exc)
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":162
+ *             self._waiter = None
+ * 
+ *         if self._closed:             # <<<<<<<<<<<<<<
+ *             # The handle is closed -- likely, _call_connection_lost
+ *             # was already called before.
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx_base.__pyx_base._closed != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":165
+ *             # The handle is closed -- likely, _call_connection_lost
+ *             # was already called before.
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/basetransport.pyx":162
+ *             self._waiter = None
+ * 
+ *         if self._closed:             # <<<<<<<<<<<<<<
+ *             # The handle is closed -- likely, _call_connection_lost
+ *             # was already called before.
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":167
+ *             return
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self._protocol_connected:
+ *                 self._protocol.connection_lost(exc)
+ */
+  /*try:*/ {
+
+    /* "uvloop/handles/basetransport.pyx":168
+ * 
+ *         try:
+ *             if self._protocol_connected:             # <<<<<<<<<<<<<<
+ *                 self._protocol.connection_lost(exc)
+ *         finally:
+ */
+    __pyx_t_1 = (__pyx_v_self->_protocol_connected != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/basetransport.pyx":169
+ *         try:
+ *             if self._protocol_connected:
+ *                 self._protocol.connection_lost(exc)             # <<<<<<<<<<<<<<
+ *         finally:
+ *             self._clear_protocol()
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_n_s_connection_lost); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 169, __pyx_L7_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_exc);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 169, __pyx_L7_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/basetransport.pyx":168
+ * 
+ *         try:
+ *             if self._protocol_connected:             # <<<<<<<<<<<<<<
+ *                 self._protocol.connection_lost(exc)
+ *         finally:
+ */
+    }
+  }
+
+  /* "uvloop/handles/basetransport.pyx":171
+ *                 self._protocol.connection_lost(exc)
+ *         finally:
+ *             self._clear_protocol()             # <<<<<<<<<<<<<<
+ * 
+ *             self._close()
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_clear_protocol(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 171, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/basetransport.pyx":173
+ *             self._clear_protocol()
+ * 
+ *             self._close()             # <<<<<<<<<<<<<<
+ * 
+ *             server = self._server
+ */
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 173, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/basetransport.pyx":175
+ *             self._close()
+ * 
+ *             server = self._server             # <<<<<<<<<<<<<<
+ *             if server is not None:
+ *                 (<Server>server)._detach()
+ */
+      __pyx_t_3 = ((PyObject *)__pyx_v_self->_server);
+      __Pyx_INCREF(__pyx_t_3);
+      __pyx_v_server = ((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_t_3);
+      __pyx_t_3 = 0;
+
+      /* "uvloop/handles/basetransport.pyx":176
+ * 
+ *             server = self._server
+ *             if server is not None:             # <<<<<<<<<<<<<<
+ *                 (<Server>server)._detach()
+ *                 self._server = None
+ */
+      __pyx_t_1 = (((PyObject *)__pyx_v_server) != Py_None);
+      __pyx_t_2 = (__pyx_t_1 != 0);
+      if (__pyx_t_2) {
+
+        /* "uvloop/handles/basetransport.pyx":177
+ *             server = self._server
+ *             if server is not None:
+ *                 (<Server>server)._detach()             # <<<<<<<<<<<<<<
+ *                 self._server = None
+ * 
+ */
+        __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_server)->__pyx_vtab)->_detach(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_server)); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 177, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/handles/basetransport.pyx":178
+ *             if server is not None:
+ *                 (<Server>server)._detach()
+ *                 self._server = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _set_server(self, Server server):
+ */
+        __Pyx_INCREF(Py_None);
+        __Pyx_GIVEREF(Py_None);
+        __Pyx_GOTREF(__pyx_v_self->_server);
+        __Pyx_DECREF(((PyObject *)__pyx_v_self->_server));
+        __pyx_v_self->_server = ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None);
+
+        /* "uvloop/handles/basetransport.pyx":176
+ * 
+ *             server = self._server
+ *             if server is not None:             # <<<<<<<<<<<<<<
+ *                 (<Server>server)._detach()
+ *                 self._server = None
+ */
+      }
+      goto __pyx_L8;
+    }
+    __pyx_L7_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __pyx_t_6 = __pyx_lineno; __pyx_t_7 = __pyx_clineno; __pyx_t_8 = __pyx_filename;
+      {
+
+        /* "uvloop/handles/basetransport.pyx":171
+ *                 self._protocol.connection_lost(exc)
+ *         finally:
+ *             self._clear_protocol()             # <<<<<<<<<<<<<<
+ * 
+ *             self._close()
+ */
+        __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_clear_protocol(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 171, __pyx_L12_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/handles/basetransport.pyx":173
+ *             self._clear_protocol()
+ * 
+ *             self._close()             # <<<<<<<<<<<<<<
+ * 
+ *             server = self._server
+ */
+        __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 173, __pyx_L12_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/handles/basetransport.pyx":175
+ *             self._close()
+ * 
+ *             server = self._server             # <<<<<<<<<<<<<<
+ *             if server is not None:
+ *                 (<Server>server)._detach()
+ */
+        __pyx_t_3 = ((PyObject *)__pyx_v_self->_server);
+        __Pyx_INCREF(__pyx_t_3);
+        __pyx_v_server = ((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_t_3);
+        __pyx_t_3 = 0;
+
+        /* "uvloop/handles/basetransport.pyx":176
+ * 
+ *             server = self._server
+ *             if server is not None:             # <<<<<<<<<<<<<<
+ *                 (<Server>server)._detach()
+ *                 self._server = None
+ */
+        __pyx_t_2 = (((PyObject *)__pyx_v_server) != Py_None);
+        __pyx_t_1 = (__pyx_t_2 != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/handles/basetransport.pyx":177
+ *             server = self._server
+ *             if server is not None:
+ *                 (<Server>server)._detach()             # <<<<<<<<<<<<<<
+ *                 self._server = None
+ * 
+ */
+          __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_server)->__pyx_vtab)->_detach(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_server)); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 177, __pyx_L12_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+          /* "uvloop/handles/basetransport.pyx":178
+ *             if server is not None:
+ *                 (<Server>server)._detach()
+ *                 self._server = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _set_server(self, Server server):
+ */
+          __Pyx_INCREF(Py_None);
+          __Pyx_GIVEREF(Py_None);
+          __Pyx_GOTREF(__pyx_v_self->_server);
+          __Pyx_DECREF(((PyObject *)__pyx_v_self->_server));
+          __pyx_v_self->_server = ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None);
+
+          /* "uvloop/handles/basetransport.pyx":176
+ * 
+ *             server = self._server
+ *             if server is not None:             # <<<<<<<<<<<<<<
+ *                 (<Server>server)._detach()
+ *                 self._server = None
+ */
+        }
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __Pyx_ErrRestore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_7; __pyx_filename = __pyx_t_8;
+      goto __pyx_L1_error;
+      __pyx_L12_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L8:;
+  }
+
+  /* "uvloop/handles/basetransport.pyx":156
+ *         self._wakeup_waiter()
+ * 
+ *     cdef _call_connection_lost(self, exc):             # <<<<<<<<<<<<<<
+ *         if self._waiter is not None:
+ *             if not self._waiter.done():
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._call_connection_lost", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_server);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":180
+ *                 self._server = None
+ * 
+ *     cdef inline _set_server(self, Server server):             # <<<<<<<<<<<<<<
+ *         self._server = server
+ *         (<Server>server)._attach()
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_server(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server) {
+  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("_set_server", 0);
+
+  /* "uvloop/handles/basetransport.pyx":181
+ * 
+ *     cdef inline _set_server(self, Server server):
+ *         self._server = server             # <<<<<<<<<<<<<<
+ *         (<Server>server)._attach()
+ * 
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_server));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_server));
+  __Pyx_GOTREF(__pyx_v_self->_server);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_server));
+  __pyx_v_self->_server = __pyx_v_server;
+
+  /* "uvloop/handles/basetransport.pyx":182
+ *     cdef inline _set_server(self, Server server):
+ *         self._server = server
+ *         (<Server>server)._attach()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _set_waiter(self, object waiter):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_server)->__pyx_vtab)->_attach(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_server)); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":180
+ *                 self._server = None
+ * 
+ *     cdef inline _set_server(self, Server server):             # <<<<<<<<<<<<<<
+ *         self._server = server
+ *         (<Server>server)._attach()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._set_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":184
+ *         (<Server>server)._attach()
+ * 
+ *     cdef inline _set_waiter(self, object waiter):             # <<<<<<<<<<<<<<
+ *         if waiter is not None and not isfuture(waiter):
+ *             raise TypeError(
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_waiter(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_waiter) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  Py_ssize_t __pyx_t_5;
+  Py_UCS4 __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_set_waiter", 0);
+
+  /* "uvloop/handles/basetransport.pyx":185
+ * 
+ *     cdef inline _set_waiter(self, object waiter):
+ *         if waiter is not None and not isfuture(waiter):             # <<<<<<<<<<<<<<
+ *             raise TypeError(
+ *                 f'invalid waiter object {waiter!r}, expected asyncio.Future')
+ */
+  __pyx_t_2 = (__pyx_v_waiter != 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;
+  }
+  __pyx_t_4 = __pyx_f_6uvloop_4loop_isfuture(__pyx_v_waiter); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 185, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(16, 185, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = ((!__pyx_t_3) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/basetransport.pyx":187
+ *         if waiter is not None and not isfuture(waiter):
+ *             raise TypeError(
+ *                 f'invalid waiter object {waiter!r}, expected asyncio.Future')             # <<<<<<<<<<<<<<
+ * 
+ *         self._waiter = waiter
+ */
+    __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 187, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 127;
+    __Pyx_INCREF(__pyx_kp_u_invalid_waiter_object);
+    __pyx_t_5 += 22;
+    __Pyx_GIVEREF(__pyx_kp_u_invalid_waiter_object);
+    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_invalid_waiter_object);
+    __pyx_t_7 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_waiter), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(16, 187, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6;
+    __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_7);
+    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_7);
+    __pyx_t_7 = 0;
+    __Pyx_INCREF(__pyx_kp_u_expected_asyncio_Future);
+    __pyx_t_5 += 25;
+    __Pyx_GIVEREF(__pyx_kp_u_expected_asyncio_Future);
+    PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u_expected_asyncio_Future);
+    __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_4, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(16, 187, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/handles/basetransport.pyx":186
+ *     cdef inline _set_waiter(self, object waiter):
+ *         if waiter is not None and not isfuture(waiter):
+ *             raise TypeError(             # <<<<<<<<<<<<<<
+ *                 f'invalid waiter object {waiter!r}, expected asyncio.Future')
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 186, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(16, 186, __pyx_L1_error)
+
+    /* "uvloop/handles/basetransport.pyx":185
+ * 
+ *     cdef inline _set_waiter(self, object waiter):
+ *         if waiter is not None and not isfuture(waiter):             # <<<<<<<<<<<<<<
+ *             raise TypeError(
+ *                 f'invalid waiter object {waiter!r}, expected asyncio.Future')
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":189
+ *                 f'invalid waiter object {waiter!r}, expected asyncio.Future')
+ * 
+ *         self._waiter = waiter             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _set_protocol(self, object protocol):
+ */
+  __Pyx_INCREF(__pyx_v_waiter);
+  __Pyx_GIVEREF(__pyx_v_waiter);
+  __Pyx_GOTREF(__pyx_v_self->_waiter);
+  __Pyx_DECREF(__pyx_v_self->_waiter);
+  __pyx_v_self->_waiter = __pyx_v_waiter;
+
+  /* "uvloop/handles/basetransport.pyx":184
+ *         (<Server>server)._attach()
+ * 
+ *     cdef inline _set_waiter(self, object waiter):             # <<<<<<<<<<<<<<
+ *         if waiter is not None and not isfuture(waiter):
+ *             raise TypeError(
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._set_waiter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":191
+ *         self._waiter = waiter
+ * 
+ *     cdef _set_protocol(self, object protocol):             # <<<<<<<<<<<<<<
+ *         self._protocol = protocol
+ *         # Store a reference to the bound method directly
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_protocol) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_set_protocol", 0);
+
+  /* "uvloop/handles/basetransport.pyx":192
+ * 
+ *     cdef _set_protocol(self, object protocol):
+ *         self._protocol = protocol             # <<<<<<<<<<<<<<
+ *         # Store a reference to the bound method directly
+ *         try:
+ */
+  __Pyx_INCREF(__pyx_v_protocol);
+  __Pyx_GIVEREF(__pyx_v_protocol);
+  __Pyx_GOTREF(__pyx_v_self->_protocol);
+  __Pyx_DECREF(__pyx_v_self->_protocol);
+  __pyx_v_self->_protocol = __pyx_v_protocol;
+
+  /* "uvloop/handles/basetransport.pyx":194
+ *         self._protocol = protocol
+ *         # Store a reference to the bound method directly
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._protocol_data_received = protocol.data_received
+ *         except AttributeError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/handles/basetransport.pyx":195
+ *         # Store a reference to the bound method directly
+ *         try:
+ *             self._protocol_data_received = protocol.data_received             # <<<<<<<<<<<<<<
+ *         except AttributeError:
+ *             pass
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_protocol, __pyx_n_s_data_received); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 195, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_v_self->_protocol_data_received);
+      __Pyx_DECREF(__pyx_v_self->_protocol_data_received);
+      __pyx_v_self->_protocol_data_received = __pyx_t_4;
+      __pyx_t_4 = 0;
+
+      /* "uvloop/handles/basetransport.pyx":194
+ *         self._protocol = protocol
+ *         # Store a reference to the bound method directly
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._protocol_data_received = protocol.data_received
+ *         except AttributeError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/handles/basetransport.pyx":196
+ *         try:
+ *             self._protocol_data_received = protocol.data_received
+ *         except AttributeError:             # <<<<<<<<<<<<<<
+ *             pass
+ * 
+ */
+    __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError);
+    if (__pyx_t_5) {
+      __Pyx_ErrRestore(0,0,0);
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/handles/basetransport.pyx":194
+ *         self._protocol = protocol
+ *         # Store a reference to the bound method directly
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._protocol_data_received = protocol.data_received
+ *         except AttributeError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/handles/basetransport.pyx":191
+ *         self._waiter = waiter
+ * 
+ *     cdef _set_protocol(self, object protocol):             # <<<<<<<<<<<<<<
+ *         self._protocol = protocol
+ *         # Store a reference to the bound method directly
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._set_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":199
+ *             pass
+ * 
+ *     cdef _clear_protocol(self):             # <<<<<<<<<<<<<<
+ *         self._protocol = None
+ *         self._protocol_data_received = None
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__clear_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_clear_protocol", 0);
+
+  /* "uvloop/handles/basetransport.pyx":200
+ * 
+ *     cdef _clear_protocol(self):
+ *         self._protocol = None             # <<<<<<<<<<<<<<
+ *         self._protocol_data_received = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_protocol);
+  __Pyx_DECREF(__pyx_v_self->_protocol);
+  __pyx_v_self->_protocol = Py_None;
+
+  /* "uvloop/handles/basetransport.pyx":201
+ *     cdef _clear_protocol(self):
+ *         self._protocol = None
+ *         self._protocol_data_received = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _init_protocol(self):
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_protocol_data_received);
+  __Pyx_DECREF(__pyx_v_self->_protocol_data_received);
+  __pyx_v_self->_protocol_data_received = Py_None;
+
+  /* "uvloop/handles/basetransport.pyx":199
+ *             pass
+ * 
+ *     cdef _clear_protocol(self):             # <<<<<<<<<<<<<<
+ *         self._protocol = None
+ *         self._protocol_data_received = None
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":203
+ *         self._protocol_data_received = None
+ * 
+ *     cdef inline _init_protocol(self):             # <<<<<<<<<<<<<<
+ *         self._loop._track_transport(self)
+ *         if self._protocol is None:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__init_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init_protocol", 0);
+
+  /* "uvloop/handles/basetransport.pyx":204
+ * 
+ *     cdef inline _init_protocol(self):
+ *         self._loop._track_transport(self)             # <<<<<<<<<<<<<<
+ *         if self._protocol is None:
+ *             raise RuntimeError('invalid _init_protocol call')
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_base.__pyx_base._loop->__pyx_vtab)->_track_transport(__pyx_v_self->__pyx_base.__pyx_base._loop, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":205
+ *     cdef inline _init_protocol(self):
+ *         self._loop._track_transport(self)
+ *         if self._protocol is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('invalid _init_protocol call')
+ *         self._schedule_call_connection_made()
+ */
+  __pyx_t_2 = (__pyx_v_self->_protocol == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/handles/basetransport.pyx":206
+ *         self._loop._track_transport(self)
+ *         if self._protocol is None:
+ *             raise RuntimeError('invalid _init_protocol call')             # <<<<<<<<<<<<<<
+ *         self._schedule_call_connection_made()
+ * 
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__137, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 206, __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(16, 206, __pyx_L1_error)
+
+    /* "uvloop/handles/basetransport.pyx":205
+ *     cdef inline _init_protocol(self):
+ *         self._loop._track_transport(self)
+ *         if self._protocol is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('invalid _init_protocol call')
+ *         self._schedule_call_connection_made()
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":207
+ *         if self._protocol is None:
+ *             raise RuntimeError('invalid _init_protocol call')
+ *         self._schedule_call_connection_made()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _add_extra_info(self, str name, object obj):
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_made(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":203
+ *         self._protocol_data_received = None
+ * 
+ *     cdef inline _init_protocol(self):             # <<<<<<<<<<<<<<
+ *         self._loop._track_transport(self)
+ *         if self._protocol is None:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._init_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":209
+ *         self._schedule_call_connection_made()
+ * 
+ *     cdef inline _add_extra_info(self, str name, object obj):             # <<<<<<<<<<<<<<
+ *         if self._extra_info is None:
+ *             self._extra_info = {}
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__add_extra_info(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_obj) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("_add_extra_info", 0);
+
+  /* "uvloop/handles/basetransport.pyx":210
+ * 
+ *     cdef inline _add_extra_info(self, str name, object obj):
+ *         if self._extra_info is None:             # <<<<<<<<<<<<<<
+ *             self._extra_info = {}
+ *         self._extra_info[name] = obj
+ */
+  __pyx_t_1 = (__pyx_v_self->_extra_info == ((PyObject*)Py_None));
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/basetransport.pyx":211
+ *     cdef inline _add_extra_info(self, str name, object obj):
+ *         if self._extra_info is None:
+ *             self._extra_info = {}             # <<<<<<<<<<<<<<
+ *         self._extra_info[name] = obj
+ * 
+ */
+    __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 211, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __Pyx_GOTREF(__pyx_v_self->_extra_info);
+    __Pyx_DECREF(__pyx_v_self->_extra_info);
+    __pyx_v_self->_extra_info = ((PyObject*)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/handles/basetransport.pyx":210
+ * 
+ *     cdef inline _add_extra_info(self, str name, object obj):
+ *         if self._extra_info is None:             # <<<<<<<<<<<<<<
+ *             self._extra_info = {}
+ *         self._extra_info[name] = obj
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":212
+ *         if self._extra_info is None:
+ *             self._extra_info = {}
+ *         self._extra_info[name] = obj             # <<<<<<<<<<<<<<
+ * 
+ *     cdef bint _is_reading(self):
+ */
+  if (unlikely(__pyx_v_self->_extra_info == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(16, 212, __pyx_L1_error)
+  }
+  if (unlikely(PyDict_SetItem(__pyx_v_self->_extra_info, __pyx_v_name, __pyx_v_obj) < 0)) __PYX_ERR(16, 212, __pyx_L1_error)
+
+  /* "uvloop/handles/basetransport.pyx":209
+ *         self._schedule_call_connection_made()
+ * 
+ *     cdef inline _add_extra_info(self, str name, object obj):             # <<<<<<<<<<<<<<
+ *         if self._extra_info is None:
+ *             self._extra_info = {}
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._add_extra_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":214
+ *         self._extra_info[name] = obj
+ * 
+ *     cdef bint _is_reading(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+static int __pyx_f_6uvloop_4loop_15UVBaseTransport__is_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_is_reading", 0);
+
+  /* "uvloop/handles/basetransport.pyx":215
+ * 
+ *     cdef bint _is_reading(self):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _start_reading(self):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(16, 215, __pyx_L1_error)
+
+  /* "uvloop/handles/basetransport.pyx":214
+ *         self._extra_info[name] = obj
+ * 
+ *     cdef bint _is_reading(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_WriteUnraisable("uvloop.loop.UVBaseTransport._is_reading", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":217
+ *         raise NotImplementedError
+ * 
+ *     cdef _start_reading(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__start_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_start_reading", 0);
+
+  /* "uvloop/handles/basetransport.pyx":218
+ * 
+ *     cdef _start_reading(self):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _stop_reading(self):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(16, 218, __pyx_L1_error)
+
+  /* "uvloop/handles/basetransport.pyx":217
+ *         raise NotImplementedError
+ * 
+ *     cdef _start_reading(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._start_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":220
+ *         raise NotImplementedError
+ * 
+ *     cdef _stop_reading(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__stop_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_stop_reading", 0);
+
+  /* "uvloop/handles/basetransport.pyx":221
+ * 
+ *     cdef _stop_reading(self):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     # === Public API ===
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(16, 221, __pyx_L1_error)
+
+  /* "uvloop/handles/basetransport.pyx":220
+ *         raise NotImplementedError
+ * 
+ *     cdef _stop_reading(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._stop_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":227
+ *     property _paused:
+ *         # Used by SSLProto.  Might be removed in the future.
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return bool(not self._is_reading())
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_7_paused_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_7_paused_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_7_paused___get__(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_7_paused___get__(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  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__", 0);
+
+  /* "uvloop/handles/basetransport.pyx":228
+ *         # Used by SSLProto.  Might be removed in the future.
+ *         def __get__(self):
+ *             return bool(not self._is_reading())             # <<<<<<<<<<<<<<
+ * 
+ *     def get_protocol(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = (!(((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_is_reading(__pyx_v_self) != 0));
+  __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/basetransport.pyx":227
+ *     property _paused:
+ *         # Used by SSLProto.  Might be removed in the future.
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return bool(not self._is_reading())
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._paused.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":230
+ *             return bool(not self._is_reading())
+ * 
+ *     def get_protocol(self):             # <<<<<<<<<<<<<<
+ *         return self._protocol
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_3get_protocol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_2get_protocol[] = "UVBaseTransport.get_protocol(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_3get_protocol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_protocol (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_2get_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_2get_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_protocol", 0);
+
+  /* "uvloop/handles/basetransport.pyx":231
+ * 
+ *     def get_protocol(self):
+ *         return self._protocol             # <<<<<<<<<<<<<<
+ * 
+ *     def set_protocol(self, protocol):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_protocol);
+  __pyx_r = __pyx_v_self->_protocol;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/basetransport.pyx":230
+ *             return bool(not self._is_reading())
+ * 
+ *     def get_protocol(self):             # <<<<<<<<<<<<<<
+ *         return self._protocol
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":233
+ *         return self._protocol
+ * 
+ *     def set_protocol(self, protocol):             # <<<<<<<<<<<<<<
+ *         self._set_protocol(protocol)
+ *         if self._is_reading():
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_5set_protocol(PyObject *__pyx_v_self, PyObject *__pyx_v_protocol); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_4set_protocol[] = "UVBaseTransport.set_protocol(self, protocol)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_5set_protocol(PyObject *__pyx_v_self, PyObject *__pyx_v_protocol) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_protocol (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_4set_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self), ((PyObject *)__pyx_v_protocol));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_4set_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_protocol) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_protocol", 0);
+
+  /* "uvloop/handles/basetransport.pyx":234
+ * 
+ *     def set_protocol(self, protocol):
+ *         self._set_protocol(protocol)             # <<<<<<<<<<<<<<
+ *         if self._is_reading():
+ *             self._stop_reading()
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_set_protocol(__pyx_v_self, __pyx_v_protocol); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":235
+ *     def set_protocol(self, protocol):
+ *         self._set_protocol(protocol)
+ *         if self._is_reading():             # <<<<<<<<<<<<<<
+ *             self._stop_reading()
+ *             self._start_reading()
+ */
+  __pyx_t_2 = (((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_is_reading(__pyx_v_self) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/basetransport.pyx":236
+ *         self._set_protocol(protocol)
+ *         if self._is_reading():
+ *             self._stop_reading()             # <<<<<<<<<<<<<<
+ *             self._start_reading()
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_stop_reading(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 236, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/basetransport.pyx":237
+ *         if self._is_reading():
+ *             self._stop_reading()
+ *             self._start_reading()             # <<<<<<<<<<<<<<
+ * 
+ *     def _force_close(self, exc):
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_start_reading(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/basetransport.pyx":235
+ *     def set_protocol(self, protocol):
+ *         self._set_protocol(protocol)
+ *         if self._is_reading():             # <<<<<<<<<<<<<<
+ *             self._stop_reading()
+ *             self._start_reading()
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":233
+ *         return self._protocol
+ * 
+ *     def set_protocol(self, protocol):             # <<<<<<<<<<<<<<
+ *         self._set_protocol(protocol)
+ *         if self._is_reading():
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.set_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":239
+ *             self._start_reading()
+ * 
+ *     def _force_close(self, exc):             # <<<<<<<<<<<<<<
+ *         # Used by SSLProto.  Might be removed in the future.
+ *         if self._conn_lost or self._closed:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_7_force_close(PyObject *__pyx_v_self, PyObject *__pyx_v_exc); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_6_force_close[] = "UVBaseTransport._force_close(self, exc)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_7_force_close(PyObject *__pyx_v_self, PyObject *__pyx_v_exc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_force_close (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_6_force_close(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self), ((PyObject *)__pyx_v_exc));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_6_force_close(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("_force_close", 0);
+
+  /* "uvloop/handles/basetransport.pyx":241
+ *     def _force_close(self, exc):
+ *         # Used by SSLProto.  Might be removed in the future.
+ *         if self._conn_lost or self._closed:             # <<<<<<<<<<<<<<
+ *             return
+ *         if not self._closing:
+ */
+  __pyx_t_2 = (__pyx_v_self->_conn_lost != 0);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_v_self->__pyx_base.__pyx_base._closed != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":242
+ *         # Used by SSLProto.  Might be removed in the future.
+ *         if self._conn_lost or self._closed:
+ *             return             # <<<<<<<<<<<<<<
+ *         if not self._closing:
+ *             self._closing = 1
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/basetransport.pyx":241
+ *     def _force_close(self, exc):
+ *         # Used by SSLProto.  Might be removed in the future.
+ *         if self._conn_lost or self._closed:             # <<<<<<<<<<<<<<
+ *             return
+ *         if not self._closing:
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":243
+ *         if self._conn_lost or self._closed:
+ *             return
+ *         if not self._closing:             # <<<<<<<<<<<<<<
+ *             self._closing = 1
+ *             self._stop_reading()
+ */
+  __pyx_t_1 = ((!(__pyx_v_self->_closing != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":244
+ *             return
+ *         if not self._closing:
+ *             self._closing = 1             # <<<<<<<<<<<<<<
+ *             self._stop_reading()
+ *         self._conn_lost += 1
+ */
+    __pyx_v_self->_closing = 1;
+
+    /* "uvloop/handles/basetransport.pyx":245
+ *         if not self._closing:
+ *             self._closing = 1
+ *             self._stop_reading()             # <<<<<<<<<<<<<<
+ *         self._conn_lost += 1
+ *         self._schedule_call_connection_lost(exc)
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_stop_reading(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 245, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/basetransport.pyx":243
+ *         if self._conn_lost or self._closed:
+ *             return
+ *         if not self._closing:             # <<<<<<<<<<<<<<
+ *             self._closing = 1
+ *             self._stop_reading()
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":246
+ *             self._closing = 1
+ *             self._stop_reading()
+ *         self._conn_lost += 1             # <<<<<<<<<<<<<<
+ *         self._schedule_call_connection_lost(exc)
+ * 
+ */
+  __pyx_v_self->_conn_lost = (__pyx_v_self->_conn_lost + 1);
+
+  /* "uvloop/handles/basetransport.pyx":247
+ *             self._stop_reading()
+ *         self._conn_lost += 1
+ *         self._schedule_call_connection_lost(exc)             # <<<<<<<<<<<<<<
+ * 
+ *     def abort(self):
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_lost(__pyx_v_self, __pyx_v_exc); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 247, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":239
+ *             self._start_reading()
+ * 
+ *     def _force_close(self, exc):             # <<<<<<<<<<<<<<
+ *         # Used by SSLProto.  Might be removed in the future.
+ *         if self._conn_lost or self._closed:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._force_close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":249
+ *         self._schedule_call_connection_lost(exc)
+ * 
+ *     def abort(self):             # <<<<<<<<<<<<<<
+ *         self._force_close(None)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_9abort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_8abort[] = "UVBaseTransport.abort(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_9abort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("abort (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_8abort(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_8abort(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("abort", 0);
+
+  /* "uvloop/handles/basetransport.pyx":250
+ * 
+ *     def abort(self):
+ *         self._force_close(None)             # <<<<<<<<<<<<<<
+ * 
+ *     def close(self):
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_force_close); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, Py_None) : __Pyx_PyObject_CallOneArg(__pyx_t_2, Py_None);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 250, __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;
+
+  /* "uvloop/handles/basetransport.pyx":249
+ *         self._schedule_call_connection_lost(exc)
+ * 
+ *     def abort(self):             # <<<<<<<<<<<<<<
+ *         self._force_close(None)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.abort", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":252
+ *         self._force_close(None)
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         if self._closing or self._closed:
+ *             return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_11close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_10close[] = "UVBaseTransport.close(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_11close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("close (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_10close(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_10close(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("close", 0);
+
+  /* "uvloop/handles/basetransport.pyx":253
+ * 
+ *     def close(self):
+ *         if self._closing or self._closed:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_self->_closing != 0);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_v_self->__pyx_base.__pyx_base._closed != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":254
+ *     def close(self):
+ *         if self._closing or self._closed:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._closing = 1
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/basetransport.pyx":253
+ * 
+ *     def close(self):
+ *         if self._closing or self._closed:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":256
+ *             return
+ * 
+ *         self._closing = 1             # <<<<<<<<<<<<<<
+ *         self._stop_reading()
+ * 
+ */
+  __pyx_v_self->_closing = 1;
+
+  /* "uvloop/handles/basetransport.pyx":257
+ * 
+ *         self._closing = 1
+ *         self._stop_reading()             # <<<<<<<<<<<<<<
+ * 
+ *         if not self._get_write_buffer_size():
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_stop_reading(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 257, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":259
+ *         self._stop_reading()
+ * 
+ *         if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *             # The write buffer is empty
+ *             self._conn_lost += 1
+ */
+  __pyx_t_1 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_get_write_buffer_size(__pyx_v_self) != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":261
+ *         if not self._get_write_buffer_size():
+ *             # The write buffer is empty
+ *             self._conn_lost += 1             # <<<<<<<<<<<<<<
+ *             self._schedule_call_connection_lost(None)
+ * 
+ */
+    __pyx_v_self->_conn_lost = (__pyx_v_self->_conn_lost + 1);
+
+    /* "uvloop/handles/basetransport.pyx":262
+ *             # The write buffer is empty
+ *             self._conn_lost += 1
+ *             self._schedule_call_connection_lost(None)             # <<<<<<<<<<<<<<
+ * 
+ *     def is_closing(self):
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_lost(__pyx_v_self, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 262, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/basetransport.pyx":259
+ *         self._stop_reading()
+ * 
+ *         if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *             # The write buffer is empty
+ *             self._conn_lost += 1
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":252
+ *         self._force_close(None)
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         if self._closing or self._closed:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":264
+ *             self._schedule_call_connection_lost(None)
+ * 
+ *     def is_closing(self):             # <<<<<<<<<<<<<<
+ *         return self._closing
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_13is_closing(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_12is_closing[] = "UVBaseTransport.is_closing(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_13is_closing(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_closing (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_12is_closing(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_12is_closing(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__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("is_closing", 0);
+
+  /* "uvloop/handles/basetransport.pyx":265
+ * 
+ *     def is_closing(self):
+ *         return self._closing             # <<<<<<<<<<<<<<
+ * 
+ *     def get_write_buffer_size(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_closing); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 265, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/basetransport.pyx":264
+ *             self._schedule_call_connection_lost(None)
+ * 
+ *     def is_closing(self):             # <<<<<<<<<<<<<<
+ *         return self._closing
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.is_closing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":267
+ *         return self._closing
+ * 
+ *     def get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         return self._get_write_buffer_size()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_15get_write_buffer_size(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_14get_write_buffer_size[] = "UVBaseTransport.get_write_buffer_size(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_15get_write_buffer_size(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_write_buffer_size (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_14get_write_buffer_size(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_14get_write_buffer_size(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__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_write_buffer_size", 0);
+
+  /* "uvloop/handles/basetransport.pyx":268
+ * 
+ *     def get_write_buffer_size(self):
+ *         return self._get_write_buffer_size()             # <<<<<<<<<<<<<<
+ * 
+ *     def set_write_buffer_limits(self, high=None, low=None):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_get_write_buffer_size(__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 268, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/basetransport.pyx":267
+ *         return self._closing
+ * 
+ *     def get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         return self._get_write_buffer_size()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.get_write_buffer_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":270
+ *         return self._get_write_buffer_size()
+ * 
+ *     def set_write_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_17set_write_buffer_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_16set_write_buffer_limits[] = "UVBaseTransport.set_write_buffer_limits(self, high=None, low=None)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_17set_write_buffer_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_high = 0;
+  PyObject *__pyx_v_low = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_write_buffer_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,0};
+    PyObject* values[2] = {0,0};
+    values[0] = ((PyObject *)Py_None);
+    values[1] = ((PyObject *)Py_None);
+    if (unlikely(__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);
+        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 (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high);
+          if (value) { values[0] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_write_buffer_limits") < 0)) __PYX_ERR(16, 270, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        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;
+      }
+    }
+    __pyx_v_high = values[0];
+    __pyx_v_low = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_write_buffer_limits", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 270, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.set_write_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_16set_write_buffer_limits(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self), __pyx_v_high, __pyx_v_low);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_16set_write_buffer_limits(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_high, PyObject *__pyx_v_low) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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 *);
+  size_t __pyx_t_6;
+  size_t __pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_write_buffer_limits", 0);
+
+  /* "uvloop/handles/basetransport.pyx":271
+ * 
+ *     def set_write_buffer_limits(self, high=None, low=None):
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         self._high_water, self._low_water = add_flowcontrol_defaults(
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 271, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":273
+ *         self._ensure_alive()
+ * 
+ *         self._high_water, self._low_water = add_flowcontrol_defaults(             # <<<<<<<<<<<<<<
+ *             high, low, FLOW_CONTROL_HIGH_WATER)
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_8includes_11flowcontrol_add_flowcontrol_defaults(__pyx_v_high, __pyx_v_low, 64); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 273, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  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);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(16, 273, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_3);
+    #else
+    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 273, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 273, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __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(16, 273, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __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_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;
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(16, 273, __pyx_L1_error)
+    __pyx_t_5 = NULL;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L4_unpacking_done;
+    __pyx_L3_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(16, 273, __pyx_L1_error)
+    __pyx_L4_unpacking_done:;
+  }
+  __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(16, 273, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(16, 273, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_self->_high_water = __pyx_t_6;
+  __pyx_v_self->_low_water = __pyx_t_7;
+
+  /* "uvloop/handles/basetransport.pyx":276
+ *             high, low, FLOW_CONTROL_HIGH_WATER)
+ * 
+ *         self._maybe_pause_protocol()             # <<<<<<<<<<<<<<
+ * 
+ *     def get_write_buffer_limits(self):
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_pause_protocol(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 276, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/basetransport.pyx":270
+ *         return self._get_write_buffer_size()
+ * 
+ *     def set_write_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_AddTraceback("uvloop.loop.UVBaseTransport.set_write_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":278
+ *         self._maybe_pause_protocol()
+ * 
+ *     def get_write_buffer_limits(self):             # <<<<<<<<<<<<<<
+ *         return (self._low_water, self._high_water)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_19get_write_buffer_limits(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_18get_write_buffer_limits[] = "UVBaseTransport.get_write_buffer_limits(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_19get_write_buffer_limits(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_write_buffer_limits (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_18get_write_buffer_limits(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_18get_write_buffer_limits(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("get_write_buffer_limits", 0);
+
+  /* "uvloop/handles/basetransport.pyx":279
+ * 
+ *     def get_write_buffer_limits(self):
+ *         return (self._low_water, self._high_water)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_extra_info(self, name, default=None):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_self->_low_water); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 279, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_v_self->_high_water); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 279, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 279, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/basetransport.pyx":278
+ *         self._maybe_pause_protocol()
+ * 
+ *     def get_write_buffer_limits(self):             # <<<<<<<<<<<<<<
+ *         return (self._low_water, self._high_water)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.get_write_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pyx":281
+ *         return (self._low_water, self._high_water)
+ * 
+ *     def get_extra_info(self, name, default=None):             # <<<<<<<<<<<<<<
+ *         if self._extra_info is not None and name in self._extra_info:
+ *             return self._extra_info[name]
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_21get_extra_info(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_20get_extra_info[] = "UVBaseTransport.get_extra_info(self, name, default=None)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_21get_extra_info(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_name = 0;
+  PyObject *__pyx_v_default = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_extra_info (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name_2,&__pyx_n_s_default,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)Py_None);
+    if (unlikely(__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);
+        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_2)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_default);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_extra_info") < 0)) __PYX_ERR(16, 281, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_name = values[0];
+    __pyx_v_default = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_extra_info", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 281, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.get_extra_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_20get_extra_info(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self), __pyx_v_name, __pyx_v_default);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_20get_extra_info(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_default) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  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;
+  int __pyx_t_10;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_extra_info", 0);
+
+  /* "uvloop/handles/basetransport.pyx":282
+ * 
+ *     def get_extra_info(self, name, default=None):
+ *         if self._extra_info is not None and name in self._extra_info:             # <<<<<<<<<<<<<<
+ *             return self._extra_info[name]
+ *         if name == 'socket':
+ */
+  __pyx_t_2 = (__pyx_v_self->_extra_info != ((PyObject*)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_self->_extra_info == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(16, 282, __pyx_L1_error)
+  }
+  __pyx_t_3 = (__Pyx_PyDict_ContainsTF(__pyx_v_name, __pyx_v_self->_extra_info, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(16, 282, __pyx_L1_error)
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":283
+ *     def get_extra_info(self, name, default=None):
+ *         if self._extra_info is not None and name in self._extra_info:
+ *             return self._extra_info[name]             # <<<<<<<<<<<<<<
+ *         if name == 'socket':
+ *             return self._get_socket()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    if (unlikely(__pyx_v_self->_extra_info == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(16, 283, __pyx_L1_error)
+    }
+    __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_self->_extra_info, __pyx_v_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 283, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/basetransport.pyx":282
+ * 
+ *     def get_extra_info(self, name, default=None):
+ *         if self._extra_info is not None and name in self._extra_info:             # <<<<<<<<<<<<<<
+ *             return self._extra_info[name]
+ *         if name == 'socket':
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":284
+ *         if self._extra_info is not None and name in self._extra_info:
+ *             return self._extra_info[name]
+ *         if name == 'socket':             # <<<<<<<<<<<<<<
+ *             return self._get_socket()
+ *         if name == 'sockname':
+ */
+  __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_name, __pyx_n_u_socket_2, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(16, 284, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":285
+ *             return self._extra_info[name]
+ *         if name == 'socket':
+ *             return self._get_socket()             # <<<<<<<<<<<<<<
+ *         if name == 'sockname':
+ *             return self._get_socket().getsockname()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 285, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/basetransport.pyx":284
+ *         if self._extra_info is not None and name in self._extra_info:
+ *             return self._extra_info[name]
+ *         if name == 'socket':             # <<<<<<<<<<<<<<
+ *             return self._get_socket()
+ *         if name == 'sockname':
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":286
+ *         if name == 'socket':
+ *             return self._get_socket()
+ *         if name == 'sockname':             # <<<<<<<<<<<<<<
+ *             return self._get_socket().getsockname()
+ *         if name == 'peername':
+ */
+  __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_name, __pyx_n_u_sockname, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(16, 286, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":287
+ *             return self._get_socket()
+ *         if name == 'sockname':
+ *             return self._get_socket().getsockname()             # <<<<<<<<<<<<<<
+ *         if name == 'peername':
+ *             try:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 287, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_getsockname); if (unlikely(!__pyx_t_6)) __PYX_ERR(16, 287, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_5)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 287, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/basetransport.pyx":286
+ *         if name == 'socket':
+ *             return self._get_socket()
+ *         if name == 'sockname':             # <<<<<<<<<<<<<<
+ *             return self._get_socket().getsockname()
+ *         if name == 'peername':
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":288
+ *         if name == 'sockname':
+ *             return self._get_socket().getsockname()
+ *         if name == 'peername':             # <<<<<<<<<<<<<<
+ *             try:
+ *                 return self._get_socket().getpeername()
+ */
+  __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_name, __pyx_n_u_peername, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(16, 288, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/basetransport.pyx":289
+ *             return self._get_socket().getsockname()
+ *         if name == 'peername':
+ *             try:             # <<<<<<<<<<<<<<
+ *                 return self._get_socket().getpeername()
+ *             except socket_error:
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      /*try:*/ {
+
+        /* "uvloop/handles/basetransport.pyx":290
+ *         if name == 'peername':
+ *             try:
+ *                 return self._get_socket().getpeername()             # <<<<<<<<<<<<<<
+ *             except socket_error:
+ *                 return default
+ */
+        __Pyx_XDECREF(__pyx_r);
+        __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(16, 290, __pyx_L9_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_getpeername); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 290, __pyx_L9_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __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_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_5, function);
+          }
+        }
+        __pyx_t_4 = (__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_4)) __PYX_ERR(16, 290, __pyx_L9_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __pyx_r = __pyx_t_4;
+        __pyx_t_4 = 0;
+        goto __pyx_L13_try_return;
+
+        /* "uvloop/handles/basetransport.pyx":289
+ *             return self._get_socket().getsockname()
+ *         if name == 'peername':
+ *             try:             # <<<<<<<<<<<<<<
+ *                 return self._get_socket().getpeername()
+ *             except socket_error:
+ */
+      }
+      __pyx_L9_error:;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/handles/basetransport.pyx":291
+ *             try:
+ *                 return self._get_socket().getpeername()
+ *             except socket_error:             # <<<<<<<<<<<<<<
+ *                 return default
+ *         return default
+ */
+      __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_socket_error);
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.get_extra_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(16, 291, __pyx_L11_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_6);
+
+        /* "uvloop/handles/basetransport.pyx":292
+ *                 return self._get_socket().getpeername()
+ *             except socket_error:
+ *                 return default             # <<<<<<<<<<<<<<
+ *         return default
+ */
+        __Pyx_XDECREF(__pyx_r);
+        __Pyx_INCREF(__pyx_v_default);
+        __pyx_r = __pyx_v_default;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        goto __pyx_L12_except_return;
+      }
+      goto __pyx_L11_except_error;
+      __pyx_L11_except_error:;
+
+      /* "uvloop/handles/basetransport.pyx":289
+ *             return self._get_socket().getsockname()
+ *         if name == 'peername':
+ *             try:             # <<<<<<<<<<<<<<
+ *                 return self._get_socket().getpeername()
+ *             except socket_error:
+ */
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+      goto __pyx_L1_error;
+      __pyx_L13_try_return:;
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+      goto __pyx_L0;
+      __pyx_L12_except_return:;
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+      goto __pyx_L0;
+    }
+
+    /* "uvloop/handles/basetransport.pyx":288
+ *         if name == 'sockname':
+ *             return self._get_socket().getsockname()
+ *         if name == 'peername':             # <<<<<<<<<<<<<<
+ *             try:
+ *                 return self._get_socket().getpeername()
+ */
+  }
+
+  /* "uvloop/handles/basetransport.pyx":293
+ *             except socket_error:
+ *                 return default
+ *         return default             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_default);
+  __pyx_r = __pyx_v_default;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/basetransport.pyx":281
+ *         return (self._low_water, self._high_water)
+ * 
+ *     def get_extra_info(self, name, default=None):             # <<<<<<<<<<<<<<
+ *         if self._extra_info is not None and name in self._extra_info:
+ *             return self._extra_info[name]
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.get_extra_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/basetransport.pxd":4
+ * 
+ *     cdef:
+ *         readonly bint _closing             # <<<<<<<<<<<<<<
+ * 
+ *         bint _protocol_connected
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_8_closing_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_8_closing_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_15UVBaseTransport_8_closing___get__(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_8_closing___get__(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__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_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_closing); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport._closing.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_23__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_22__reduce_cython__[] = "UVBaseTransport.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_23__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_6uvloop_4loop_15UVBaseTransport_22__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_22__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__138, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.__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_6uvloop_4loop_15UVBaseTransport_25__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15UVBaseTransport_24__setstate_cython__[] = "UVBaseTransport.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_15UVBaseTransport_25__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_6uvloop_4loop_15UVBaseTransport_24__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_24__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__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);
+
+  /* "(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__139, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVBaseTransport.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":29
+ *         bint            closed
+ * 
+ *     cdef free_bufs(self):             # <<<<<<<<<<<<<<
+ *         cdef size_t i
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_19_StreamWriteContext_free_bufs(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self) {
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  size_t __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("free_bufs", 0);
+
+  /* "uvloop/handles/stream.pyx":32
+ *         cdef size_t i
+ * 
+ *         if self.uv_bufs is not NULL:             # <<<<<<<<<<<<<<
+ *             PyMem_RawFree(self.uv_bufs)
+ *             self.uv_bufs = NULL
+ */
+  __pyx_t_1 = ((__pyx_v_self->uv_bufs != NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":33
+ * 
+ *         if self.uv_bufs is not NULL:
+ *             PyMem_RawFree(self.uv_bufs)             # <<<<<<<<<<<<<<
+ *             self.uv_bufs = NULL
+ *             if UVLOOP_DEBUG:
+ */
+    PyMem_RawFree(__pyx_v_self->uv_bufs);
+
+    /* "uvloop/handles/stream.pyx":34
+ *         if self.uv_bufs is not NULL:
+ *             PyMem_RawFree(self.uv_bufs)
+ *             self.uv_bufs = NULL             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 if self.py_bufs_sml_inuse:
+ */
+    __pyx_v_self->uv_bufs = NULL;
+
+    /* "uvloop/handles/stream.pyx":35
+ *             PyMem_RawFree(self.uv_bufs)
+ *             self.uv_bufs = NULL
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 if self.py_bufs_sml_inuse:
+ *                     raise RuntimeError(
+ */
+    __pyx_t_1 = (UVLOOP_DEBUG != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":36
+ *             self.uv_bufs = NULL
+ *             if UVLOOP_DEBUG:
+ *                 if self.py_bufs_sml_inuse:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '_StreamWriteContext.close: uv_bufs != NULL and '
+ */
+      __pyx_t_1 = (__pyx_v_self->py_bufs_sml_inuse != 0);
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/handles/stream.pyx":37
+ *             if UVLOOP_DEBUG:
+ *                 if self.py_bufs_sml_inuse:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '_StreamWriteContext.close: uv_bufs != NULL and '
+ *                         'py_bufs_sml_inuse is True')
+ */
+        __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__140, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 37, __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(18, 37, __pyx_L1_error)
+
+        /* "uvloop/handles/stream.pyx":36
+ *             self.uv_bufs = NULL
+ *             if UVLOOP_DEBUG:
+ *                 if self.py_bufs_sml_inuse:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '_StreamWriteContext.close: uv_bufs != NULL and '
+ */
+      }
+
+      /* "uvloop/handles/stream.pyx":35
+ *             PyMem_RawFree(self.uv_bufs)
+ *             self.uv_bufs = NULL
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 if self.py_bufs_sml_inuse:
+ *                     raise RuntimeError(
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":32
+ *         cdef size_t i
+ * 
+ *         if self.uv_bufs is not NULL:             # <<<<<<<<<<<<<<
+ *             PyMem_RawFree(self.uv_bufs)
+ *             self.uv_bufs = NULL
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":41
+ *                         'py_bufs_sml_inuse is True')
+ * 
+ *         if self.py_bufs is not NULL:             # <<<<<<<<<<<<<<
+ *             for i from 0 <= i < self.py_bufs_len:
+ *                 PyBuffer_Release(&self.py_bufs[i])
+ */
+  __pyx_t_1 = ((__pyx_v_self->py_bufs != NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":42
+ * 
+ *         if self.py_bufs is not NULL:
+ *             for i from 0 <= i < self.py_bufs_len:             # <<<<<<<<<<<<<<
+ *                 PyBuffer_Release(&self.py_bufs[i])
+ *             PyMem_RawFree(self.py_bufs)
+ */
+    __pyx_t_3 = __pyx_v_self->py_bufs_len;
+    for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_3; __pyx_v_i++) {
+
+      /* "uvloop/handles/stream.pyx":43
+ *         if self.py_bufs is not NULL:
+ *             for i from 0 <= i < self.py_bufs_len:
+ *                 PyBuffer_Release(&self.py_bufs[i])             # <<<<<<<<<<<<<<
+ *             PyMem_RawFree(self.py_bufs)
+ *             self.py_bufs = NULL
+ */
+      PyBuffer_Release((&(__pyx_v_self->py_bufs[__pyx_v_i])));
+    }
+
+    /* "uvloop/handles/stream.pyx":44
+ *             for i from 0 <= i < self.py_bufs_len:
+ *                 PyBuffer_Release(&self.py_bufs[i])
+ *             PyMem_RawFree(self.py_bufs)             # <<<<<<<<<<<<<<
+ *             self.py_bufs = NULL
+ *             if UVLOOP_DEBUG:
+ */
+    PyMem_RawFree(__pyx_v_self->py_bufs);
+
+    /* "uvloop/handles/stream.pyx":45
+ *                 PyBuffer_Release(&self.py_bufs[i])
+ *             PyMem_RawFree(self.py_bufs)
+ *             self.py_bufs = NULL             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 if self.py_bufs_sml_inuse:
+ */
+    __pyx_v_self->py_bufs = NULL;
+
+    /* "uvloop/handles/stream.pyx":46
+ *             PyMem_RawFree(self.py_bufs)
+ *             self.py_bufs = NULL
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 if self.py_bufs_sml_inuse:
+ *                     raise RuntimeError(
+ */
+    __pyx_t_1 = (UVLOOP_DEBUG != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":47
+ *             self.py_bufs = NULL
+ *             if UVLOOP_DEBUG:
+ *                 if self.py_bufs_sml_inuse:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '_StreamWriteContext.close: py_bufs != NULL and '
+ */
+      __pyx_t_1 = (__pyx_v_self->py_bufs_sml_inuse != 0);
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/handles/stream.pyx":48
+ *             if UVLOOP_DEBUG:
+ *                 if self.py_bufs_sml_inuse:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '_StreamWriteContext.close: py_bufs != NULL and '
+ *                         'py_bufs_sml_inuse is True')
+ */
+        __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__141, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 48, __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(18, 48, __pyx_L1_error)
+
+        /* "uvloop/handles/stream.pyx":47
+ *             self.py_bufs = NULL
+ *             if UVLOOP_DEBUG:
+ *                 if self.py_bufs_sml_inuse:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '_StreamWriteContext.close: py_bufs != NULL and '
+ */
+      }
+
+      /* "uvloop/handles/stream.pyx":46
+ *             PyMem_RawFree(self.py_bufs)
+ *             self.py_bufs = NULL
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 if self.py_bufs_sml_inuse:
+ *                     raise RuntimeError(
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":41
+ *                         'py_bufs_sml_inuse is True')
+ * 
+ *         if self.py_bufs is not NULL:             # <<<<<<<<<<<<<<
+ *             for i from 0 <= i < self.py_bufs_len:
+ *                 PyBuffer_Release(&self.py_bufs[i])
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":52
+ *                         'py_bufs_sml_inuse is True')
+ * 
+ *         if self.py_bufs_sml_inuse:             # <<<<<<<<<<<<<<
+ *             for i from 0 <= i < self.py_bufs_len:
+ *                 PyBuffer_Release(&self.py_bufs_sml[i])
+ */
+  __pyx_t_1 = (__pyx_v_self->py_bufs_sml_inuse != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":53
+ * 
+ *         if self.py_bufs_sml_inuse:
+ *             for i from 0 <= i < self.py_bufs_len:             # <<<<<<<<<<<<<<
+ *                 PyBuffer_Release(&self.py_bufs_sml[i])
+ *             self.py_bufs_sml_inuse = 0
+ */
+    __pyx_t_3 = __pyx_v_self->py_bufs_len;
+    for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_3; __pyx_v_i++) {
+
+      /* "uvloop/handles/stream.pyx":54
+ *         if self.py_bufs_sml_inuse:
+ *             for i from 0 <= i < self.py_bufs_len:
+ *                 PyBuffer_Release(&self.py_bufs_sml[i])             # <<<<<<<<<<<<<<
+ *             self.py_bufs_sml_inuse = 0
+ * 
+ */
+      PyBuffer_Release((&(__pyx_v_self->py_bufs_sml[__pyx_v_i])));
+    }
+
+    /* "uvloop/handles/stream.pyx":55
+ *             for i from 0 <= i < self.py_bufs_len:
+ *                 PyBuffer_Release(&self.py_bufs_sml[i])
+ *             self.py_bufs_sml_inuse = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self.py_bufs_len = 0
+ */
+    __pyx_v_self->py_bufs_sml_inuse = 0;
+
+    /* "uvloop/handles/stream.pyx":52
+ *                         'py_bufs_sml_inuse is True')
+ * 
+ *         if self.py_bufs_sml_inuse:             # <<<<<<<<<<<<<<
+ *             for i from 0 <= i < self.py_bufs_len:
+ *                 PyBuffer_Release(&self.py_bufs_sml[i])
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":57
+ *             self.py_bufs_sml_inuse = 0
+ * 
+ *         self.py_bufs_len = 0             # <<<<<<<<<<<<<<
+ *         self.buffers = None
+ * 
+ */
+  __pyx_v_self->py_bufs_len = 0;
+
+  /* "uvloop/handles/stream.pyx":58
+ * 
+ *         self.py_bufs_len = 0
+ *         self.buffers = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef close(self):
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->buffers);
+  __Pyx_DECREF(__pyx_v_self->buffers);
+  __pyx_v_self->buffers = ((PyObject*)Py_None);
+
+  /* "uvloop/handles/stream.pyx":29
+ *         bint            closed
+ * 
+ *     cdef free_bufs(self):             # <<<<<<<<<<<<<<
+ *         cdef size_t i
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop._StreamWriteContext.free_bufs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":60
+ *         self.buffers = None
+ * 
+ *     cdef close(self):             # <<<<<<<<<<<<<<
+ *         if self.closed:
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_19_StreamWriteContext_close(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self) {
+  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("close", 0);
+
+  /* "uvloop/handles/stream.pyx":61
+ * 
+ *     cdef close(self):
+ *         if self.closed:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.closed = 1
+ */
+  __pyx_t_1 = (__pyx_v_self->closed != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":62
+ *     cdef close(self):
+ *         if self.closed:
+ *             return             # <<<<<<<<<<<<<<
+ *         self.closed = 1
+ *         self.free_bufs()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":61
+ * 
+ *     cdef close(self):
+ *         if self.closed:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.closed = 1
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":63
+ *         if self.closed:
+ *             return
+ *         self.closed = 1             # <<<<<<<<<<<<<<
+ *         self.free_bufs()
+ *         Py_DECREF(self)
+ */
+  __pyx_v_self->closed = 1;
+
+  /* "uvloop/handles/stream.pyx":64
+ *             return
+ *         self.closed = 1
+ *         self.free_bufs()             # <<<<<<<<<<<<<<
+ *         Py_DECREF(self)
+ * 
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *)__pyx_v_self->__pyx_vtab)->free_bufs(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/stream.pyx":65
+ *         self.closed = 1
+ *         self.free_bufs()
+ *         Py_DECREF(self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef advance_uv_buf(self, size_t sent):
+ */
+  Py_DECREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/handles/stream.pyx":60
+ *         self.buffers = None
+ * 
+ *     cdef close(self):             # <<<<<<<<<<<<<<
+ *         if self.closed:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop._StreamWriteContext.close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":67
+ *         Py_DECREF(self)
+ * 
+ *     cdef advance_uv_buf(self, size_t sent):             # <<<<<<<<<<<<<<
+ *         # Advance the pointer to first uv_buf and the
+ *         # pointer to first byte in that buffer.
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_19_StreamWriteContext_advance_uv_buf(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self, size_t __pyx_v_sent) {
+  uv_buf_t *__pyx_v_buf;
+  size_t __pyx_v_idx;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  size_t __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("advance_uv_buf", 0);
+
+  /* "uvloop/handles/stream.pyx":80
+ *             size_t idx
+ * 
+ *         for idx from 0 <= idx < self.uv_bufs_len:             # <<<<<<<<<<<<<<
+ *             buf = &self.uv_bufs_start[idx]
+ *             if buf.len > sent:
+ */
+  __pyx_t_1 = __pyx_v_self->uv_bufs_len;
+  for (__pyx_v_idx = 0; __pyx_v_idx < __pyx_t_1; __pyx_v_idx++) {
+
+    /* "uvloop/handles/stream.pyx":81
+ * 
+ *         for idx from 0 <= idx < self.uv_bufs_len:
+ *             buf = &self.uv_bufs_start[idx]             # <<<<<<<<<<<<<<
+ *             if buf.len > sent:
+ *                 buf.len -= sent
+ */
+    __pyx_v_buf = (&(__pyx_v_self->uv_bufs_start[__pyx_v_idx]));
+
+    /* "uvloop/handles/stream.pyx":82
+ *         for idx from 0 <= idx < self.uv_bufs_len:
+ *             buf = &self.uv_bufs_start[idx]
+ *             if buf.len > sent:             # <<<<<<<<<<<<<<
+ *                 buf.len -= sent
+ *                 buf.base = buf.base + sent
+ */
+    __pyx_t_2 = ((__pyx_v_buf->len > __pyx_v_sent) != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/handles/stream.pyx":83
+ *             buf = &self.uv_bufs_start[idx]
+ *             if buf.len > sent:
+ *                 buf.len -= sent             # <<<<<<<<<<<<<<
+ *                 buf.base = buf.base + sent
+ *                 self.uv_bufs_start = buf
+ */
+      __pyx_v_buf->len = (__pyx_v_buf->len - __pyx_v_sent);
+
+      /* "uvloop/handles/stream.pyx":84
+ *             if buf.len > sent:
+ *                 buf.len -= sent
+ *                 buf.base = buf.base + sent             # <<<<<<<<<<<<<<
+ *                 self.uv_bufs_start = buf
+ *                 self.uv_bufs_len -= idx
+ */
+      __pyx_v_buf->base = (__pyx_v_buf->base + __pyx_v_sent);
+
+      /* "uvloop/handles/stream.pyx":85
+ *                 buf.len -= sent
+ *                 buf.base = buf.base + sent
+ *                 self.uv_bufs_start = buf             # <<<<<<<<<<<<<<
+ *                 self.uv_bufs_len -= idx
+ *                 return
+ */
+      __pyx_v_self->uv_bufs_start = __pyx_v_buf;
+
+      /* "uvloop/handles/stream.pyx":86
+ *                 buf.base = buf.base + sent
+ *                 self.uv_bufs_start = buf
+ *                 self.uv_bufs_len -= idx             # <<<<<<<<<<<<<<
+ *                 return
+ *             else:
+ */
+      __pyx_v_self->uv_bufs_len = (__pyx_v_self->uv_bufs_len - __pyx_v_idx);
+
+      /* "uvloop/handles/stream.pyx":87
+ *                 self.uv_bufs_start = buf
+ *                 self.uv_bufs_len -= idx
+ *                 return             # <<<<<<<<<<<<<<
+ *             else:
+ *                 sent -= self.uv_bufs_start[idx].len
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+
+      /* "uvloop/handles/stream.pyx":82
+ *         for idx from 0 <= idx < self.uv_bufs_len:
+ *             buf = &self.uv_bufs_start[idx]
+ *             if buf.len > sent:             # <<<<<<<<<<<<<<
+ *                 buf.len -= sent
+ *                 buf.base = buf.base + sent
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":89
+ *                 return
+ *             else:
+ *                 sent -= self.uv_bufs_start[idx].len             # <<<<<<<<<<<<<<
+ * 
+ *             if UVLOOP_DEBUG:
+ */
+    /*else*/ {
+      __pyx_v_sent = (__pyx_v_sent - (__pyx_v_self->uv_bufs_start[__pyx_v_idx]).len);
+    }
+
+    /* "uvloop/handles/stream.pyx":91
+ *                 sent -= self.uv_bufs_start[idx].len
+ * 
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 if sent < 0:
+ *                     raise RuntimeError('fatal: sent < 0 in advance_uv_buf')
+ */
+    __pyx_t_2 = (UVLOOP_DEBUG != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/handles/stream.pyx":92
+ * 
+ *             if UVLOOP_DEBUG:
+ *                 if sent < 0:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError('fatal: sent < 0 in advance_uv_buf')
+ * 
+ */
+      __pyx_t_2 = ((__pyx_v_sent < 0) != 0);
+      if (unlikely(__pyx_t_2)) {
+
+        /* "uvloop/handles/stream.pyx":93
+ *             if UVLOOP_DEBUG:
+ *                 if sent < 0:
+ *                     raise RuntimeError('fatal: sent < 0 in advance_uv_buf')             # <<<<<<<<<<<<<<
+ * 
+ *         raise RuntimeError('fatal: Could not advance _StreamWriteContext')
+ */
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__142, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 93, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(18, 93, __pyx_L1_error)
+
+        /* "uvloop/handles/stream.pyx":92
+ * 
+ *             if UVLOOP_DEBUG:
+ *                 if sent < 0:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError('fatal: sent < 0 in advance_uv_buf')
+ * 
+ */
+      }
+
+      /* "uvloop/handles/stream.pyx":91
+ *                 sent -= self.uv_bufs_start[idx].len
+ * 
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 if sent < 0:
+ *                     raise RuntimeError('fatal: sent < 0 in advance_uv_buf')
+ */
+    }
+  }
+
+  /* "uvloop/handles/stream.pyx":95
+ *                     raise RuntimeError('fatal: sent < 0 in advance_uv_buf')
+ * 
+ *         raise RuntimeError('fatal: Could not advance _StreamWriteContext')             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__143, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __PYX_ERR(18, 95, __pyx_L1_error)
+
+  /* "uvloop/handles/stream.pyx":67
+ *         Py_DECREF(self)
+ * 
+ *     cdef advance_uv_buf(self, size_t sent):             # <<<<<<<<<<<<<<
+ *         # Advance the pointer to first uv_buf and the
+ *         # pointer to first byte in that buffer.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop._StreamWriteContext.advance_uv_buf", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":98
+ * 
+ *     @staticmethod
+ *     cdef _StreamWriteContext new(UVStream stream, list buffers):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             _StreamWriteContext ctx
+ */
+
+static struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_f_6uvloop_4loop_19_StreamWriteContext_new(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_stream, PyObject *__pyx_v_buffers) {
+  struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_ctx = 0;
+  int __pyx_v_uv_bufs_idx;
+  size_t __pyx_v_py_bufs_len;
+  Py_buffer *__pyx_v_p_pybufs;
+  uv_buf_t *__pyx_v_p_uvbufs;
+  PyObject *__pyx_v_buf = NULL;
+  struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  Py_buffer *__pyx_t_9;
+  uv_buf_t *__pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  Py_ssize_t __pyx_t_16;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_17 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("new", 0);
+
+  /* "uvloop/handles/stream.pyx":101
+ *         cdef:
+ *             _StreamWriteContext ctx
+ *             int uv_bufs_idx = 0             # <<<<<<<<<<<<<<
+ *             size_t py_bufs_len = 0
+ *             int i
+ */
+  __pyx_v_uv_bufs_idx = 0;
+
+  /* "uvloop/handles/stream.pyx":102
+ *             _StreamWriteContext ctx
+ *             int uv_bufs_idx = 0
+ *             size_t py_bufs_len = 0             # <<<<<<<<<<<<<<
+ *             int i
+ * 
+ */
+  __pyx_v_py_bufs_len = 0;
+
+  /* "uvloop/handles/stream.pyx":108
+ *             uv.uv_buf_t* p_uvbufs
+ * 
+ *         ctx = _StreamWriteContext.__new__(_StreamWriteContext)             # <<<<<<<<<<<<<<
+ *         ctx.stream = None
+ *         ctx.closed = 1
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop__StreamWriteContext(((PyTypeObject *)__pyx_ptype_6uvloop_4loop__StreamWriteContext), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 108, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_ctx = ((struct __pyx_obj_6uvloop_4loop__StreamWriteContext *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":109
+ * 
+ *         ctx = _StreamWriteContext.__new__(_StreamWriteContext)
+ *         ctx.stream = None             # <<<<<<<<<<<<<<
+ *         ctx.closed = 1
+ *         ctx.py_bufs_len = 0
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_ctx->stream);
+  __Pyx_DECREF(((PyObject *)__pyx_v_ctx->stream));
+  __pyx_v_ctx->stream = ((struct __pyx_obj_6uvloop_4loop_UVStream *)Py_None);
+
+  /* "uvloop/handles/stream.pyx":110
+ *         ctx = _StreamWriteContext.__new__(_StreamWriteContext)
+ *         ctx.stream = None
+ *         ctx.closed = 1             # <<<<<<<<<<<<<<
+ *         ctx.py_bufs_len = 0
+ *         ctx.py_bufs_sml_inuse = 0
+ */
+  __pyx_v_ctx->closed = 1;
+
+  /* "uvloop/handles/stream.pyx":111
+ *         ctx.stream = None
+ *         ctx.closed = 1
+ *         ctx.py_bufs_len = 0             # <<<<<<<<<<<<<<
+ *         ctx.py_bufs_sml_inuse = 0
+ *         ctx.uv_bufs = NULL
+ */
+  __pyx_v_ctx->py_bufs_len = 0;
+
+  /* "uvloop/handles/stream.pyx":112
+ *         ctx.closed = 1
+ *         ctx.py_bufs_len = 0
+ *         ctx.py_bufs_sml_inuse = 0             # <<<<<<<<<<<<<<
+ *         ctx.uv_bufs = NULL
+ *         ctx.py_bufs = NULL
+ */
+  __pyx_v_ctx->py_bufs_sml_inuse = 0;
+
+  /* "uvloop/handles/stream.pyx":113
+ *         ctx.py_bufs_len = 0
+ *         ctx.py_bufs_sml_inuse = 0
+ *         ctx.uv_bufs = NULL             # <<<<<<<<<<<<<<
+ *         ctx.py_bufs = NULL
+ *         ctx.buffers = buffers
+ */
+  __pyx_v_ctx->uv_bufs = NULL;
+
+  /* "uvloop/handles/stream.pyx":114
+ *         ctx.py_bufs_sml_inuse = 0
+ *         ctx.uv_bufs = NULL
+ *         ctx.py_bufs = NULL             # <<<<<<<<<<<<<<
+ *         ctx.buffers = buffers
+ *         ctx.stream = stream
+ */
+  __pyx_v_ctx->py_bufs = NULL;
+
+  /* "uvloop/handles/stream.pyx":115
+ *         ctx.uv_bufs = NULL
+ *         ctx.py_bufs = NULL
+ *         ctx.buffers = buffers             # <<<<<<<<<<<<<<
+ *         ctx.stream = stream
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_buffers);
+  __Pyx_GIVEREF(__pyx_v_buffers);
+  __Pyx_GOTREF(__pyx_v_ctx->buffers);
+  __Pyx_DECREF(__pyx_v_ctx->buffers);
+  __pyx_v_ctx->buffers = __pyx_v_buffers;
+
+  /* "uvloop/handles/stream.pyx":116
+ *         ctx.py_bufs = NULL
+ *         ctx.buffers = buffers
+ *         ctx.stream = stream             # <<<<<<<<<<<<<<
+ * 
+ *         if len(buffers) <= __PREALLOCED_BUFS:
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_stream));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_stream));
+  __Pyx_GOTREF(__pyx_v_ctx->stream);
+  __Pyx_DECREF(((PyObject *)__pyx_v_ctx->stream));
+  __pyx_v_ctx->stream = __pyx_v_stream;
+
+  /* "uvloop/handles/stream.pyx":118
+ *         ctx.stream = stream
+ * 
+ *         if len(buffers) <= __PREALLOCED_BUFS:             # <<<<<<<<<<<<<<
+ *             # We've got a small number of buffers to write, don't
+ *             # need to use malloc.
+ */
+  if (unlikely(__pyx_v_buffers == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(18, 118, __pyx_L1_error)
+  }
+  __pyx_t_2 = PyList_GET_SIZE(__pyx_v_buffers); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(18, 118, __pyx_L1_error)
+  __pyx_t_3 = ((__pyx_t_2 <= 4) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/stream.pyx":121
+ *             # We've got a small number of buffers to write, don't
+ *             # need to use malloc.
+ *             ctx.py_bufs_sml_inuse = 1             # <<<<<<<<<<<<<<
+ *             p_pybufs = <Py_buffer*>&ctx.py_bufs_sml
+ *             p_uvbufs = <uv.uv_buf_t*>&ctx.uv_bufs_sml
+ */
+    __pyx_v_ctx->py_bufs_sml_inuse = 1;
+
+    /* "uvloop/handles/stream.pyx":122
+ *             # need to use malloc.
+ *             ctx.py_bufs_sml_inuse = 1
+ *             p_pybufs = <Py_buffer*>&ctx.py_bufs_sml             # <<<<<<<<<<<<<<
+ *             p_uvbufs = <uv.uv_buf_t*>&ctx.uv_bufs_sml
+ * 
+ */
+    __pyx_v_p_pybufs = ((Py_buffer *)(&__pyx_v_ctx->py_bufs_sml));
+
+    /* "uvloop/handles/stream.pyx":123
+ *             ctx.py_bufs_sml_inuse = 1
+ *             p_pybufs = <Py_buffer*>&ctx.py_bufs_sml
+ *             p_uvbufs = <uv.uv_buf_t*>&ctx.uv_bufs_sml             # <<<<<<<<<<<<<<
+ * 
+ *         else:
+ */
+    __pyx_v_p_uvbufs = ((uv_buf_t *)(&__pyx_v_ctx->uv_bufs_sml));
+
+    /* "uvloop/handles/stream.pyx":118
+ *         ctx.stream = stream
+ * 
+ *         if len(buffers) <= __PREALLOCED_BUFS:             # <<<<<<<<<<<<<<
+ *             # We've got a small number of buffers to write, don't
+ *             # need to use malloc.
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/stream.pyx":126
+ * 
+ *         else:
+ *             for buf in buffers:             # <<<<<<<<<<<<<<
+ *                 if UVLOOP_DEBUG:
+ *                     if not isinstance(buf, (bytes, bytearray, memoryview)):
+ */
+  /*else*/ {
+    if (unlikely(__pyx_v_buffers == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+      __PYX_ERR(18, 126, __pyx_L1_error)
+    }
+    __pyx_t_1 = __pyx_v_buffers; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+    for (;;) {
+      if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(18, 126, __pyx_L1_error)
+      #else
+      __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 126, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      #endif
+      __Pyx_XDECREF_SET(__pyx_v_buf, __pyx_t_4);
+      __pyx_t_4 = 0;
+
+      /* "uvloop/handles/stream.pyx":127
+ *         else:
+ *             for buf in buffers:
+ *                 if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                     if not isinstance(buf, (bytes, bytearray, memoryview)):
+ *                         raise RuntimeError(
+ */
+      __pyx_t_3 = (UVLOOP_DEBUG != 0);
+      if (__pyx_t_3) {
+
+        /* "uvloop/handles/stream.pyx":128
+ *             for buf in buffers:
+ *                 if UVLOOP_DEBUG:
+ *                     if not isinstance(buf, (bytes, bytearray, memoryview)):             # <<<<<<<<<<<<<<
+ *                         raise RuntimeError(
+ *                             'invalid data in writebuf: an instance of '
+ */
+        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 128, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_5 = PyBytes_Check(__pyx_v_buf); 
+        __pyx_t_6 = (__pyx_t_5 != 0);
+        if (!__pyx_t_6) {
+        } else {
+          __pyx_t_3 = __pyx_t_6;
+          goto __pyx_L8_bool_binop_done;
+        }
+        __pyx_t_6 = PyByteArray_Check(__pyx_v_buf); 
+        __pyx_t_5 = (__pyx_t_6 != 0);
+        if (!__pyx_t_5) {
+        } else {
+          __pyx_t_3 = __pyx_t_5;
+          goto __pyx_L8_bool_binop_done;
+        }
+        __pyx_t_5 = PyObject_IsInstance(__pyx_v_buf, __pyx_t_4); 
+        __pyx_t_6 = (__pyx_t_5 != 0);
+        __pyx_t_3 = __pyx_t_6;
+        __pyx_L8_bool_binop_done:;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_6 = ((!(__pyx_t_3 != 0)) != 0);
+        if (unlikely(__pyx_t_6)) {
+
+          /* "uvloop/handles/stream.pyx":132
+ *                             'invalid data in writebuf: an instance of '
+ *                             'bytes, bytearray or memoryview was expected, '
+ *                             'got {}'.format(type(buf)))             # <<<<<<<<<<<<<<
+ * 
+ *                 if not PyBytes_CheckExact(buf):
+ */
+          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_invalid_data_in_writebuf_an_inst, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(18, 132, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __pyx_t_8 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+            __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+            if (likely(__pyx_t_8)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+              __Pyx_INCREF(__pyx_t_8);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_7, function);
+            }
+          }
+          __pyx_t_4 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, ((PyObject *)Py_TYPE(__pyx_v_buf))) : __Pyx_PyObject_CallOneArg(__pyx_t_7, ((PyObject *)Py_TYPE(__pyx_v_buf)));
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 132, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+          /* "uvloop/handles/stream.pyx":129
+ *                 if UVLOOP_DEBUG:
+ *                     if not isinstance(buf, (bytes, bytearray, memoryview)):
+ *                         raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                             'invalid data in writebuf: an instance of '
+ *                             'bytes, bytearray or memoryview was expected, '
+ */
+          __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(18, 129, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __PYX_ERR(18, 129, __pyx_L1_error)
+
+          /* "uvloop/handles/stream.pyx":128
+ *             for buf in buffers:
+ *                 if UVLOOP_DEBUG:
+ *                     if not isinstance(buf, (bytes, bytearray, memoryview)):             # <<<<<<<<<<<<<<
+ *                         raise RuntimeError(
+ *                             'invalid data in writebuf: an instance of '
+ */
+        }
+
+        /* "uvloop/handles/stream.pyx":127
+ *         else:
+ *             for buf in buffers:
+ *                 if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                     if not isinstance(buf, (bytes, bytearray, memoryview)):
+ *                         raise RuntimeError(
+ */
+      }
+
+      /* "uvloop/handles/stream.pyx":134
+ *                             'got {}'.format(type(buf)))
+ * 
+ *                 if not PyBytes_CheckExact(buf):             # <<<<<<<<<<<<<<
+ *                     py_bufs_len += 1
+ * 
+ */
+      __pyx_t_6 = ((!(PyBytes_CheckExact(__pyx_v_buf) != 0)) != 0);
+      if (__pyx_t_6) {
+
+        /* "uvloop/handles/stream.pyx":135
+ * 
+ *                 if not PyBytes_CheckExact(buf):
+ *                     py_bufs_len += 1             # <<<<<<<<<<<<<<
+ * 
+ *             if py_bufs_len > 0:
+ */
+        __pyx_v_py_bufs_len = (__pyx_v_py_bufs_len + 1);
+
+        /* "uvloop/handles/stream.pyx":134
+ *                             'got {}'.format(type(buf)))
+ * 
+ *                 if not PyBytes_CheckExact(buf):             # <<<<<<<<<<<<<<
+ *                     py_bufs_len += 1
+ * 
+ */
+      }
+
+      /* "uvloop/handles/stream.pyx":126
+ * 
+ *         else:
+ *             for buf in buffers:             # <<<<<<<<<<<<<<
+ *                 if UVLOOP_DEBUG:
+ *                     if not isinstance(buf, (bytes, bytearray, memoryview)):
+ */
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/stream.pyx":137
+ *                     py_bufs_len += 1
+ * 
+ *             if py_bufs_len > 0:             # <<<<<<<<<<<<<<
+ *                 ctx.py_bufs = <Py_buffer*>PyMem_RawMalloc(
+ *                     py_bufs_len * sizeof(Py_buffer))
+ */
+    __pyx_t_6 = ((__pyx_v_py_bufs_len > 0) != 0);
+    if (__pyx_t_6) {
+
+      /* "uvloop/handles/stream.pyx":138
+ * 
+ *             if py_bufs_len > 0:
+ *                 ctx.py_bufs = <Py_buffer*>PyMem_RawMalloc(             # <<<<<<<<<<<<<<
+ *                     py_bufs_len * sizeof(Py_buffer))
+ *                 if ctx.py_bufs is NULL:
+ */
+      __pyx_v_ctx->py_bufs = ((Py_buffer *)PyMem_RawMalloc((__pyx_v_py_bufs_len * (sizeof(Py_buffer)))));
+
+      /* "uvloop/handles/stream.pyx":140
+ *                 ctx.py_bufs = <Py_buffer*>PyMem_RawMalloc(
+ *                     py_bufs_len * sizeof(Py_buffer))
+ *                 if ctx.py_bufs is NULL:             # <<<<<<<<<<<<<<
+ *                     raise MemoryError()
+ * 
+ */
+      __pyx_t_6 = ((__pyx_v_ctx->py_bufs == NULL) != 0);
+      if (unlikely(__pyx_t_6)) {
+
+        /* "uvloop/handles/stream.pyx":141
+ *                     py_bufs_len * sizeof(Py_buffer))
+ *                 if ctx.py_bufs is NULL:
+ *                     raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *             ctx.uv_bufs = <uv.uv_buf_t*>PyMem_RawMalloc(
+ */
+        PyErr_NoMemory(); __PYX_ERR(18, 141, __pyx_L1_error)
+
+        /* "uvloop/handles/stream.pyx":140
+ *                 ctx.py_bufs = <Py_buffer*>PyMem_RawMalloc(
+ *                     py_bufs_len * sizeof(Py_buffer))
+ *                 if ctx.py_bufs is NULL:             # <<<<<<<<<<<<<<
+ *                     raise MemoryError()
+ * 
+ */
+      }
+
+      /* "uvloop/handles/stream.pyx":137
+ *                     py_bufs_len += 1
+ * 
+ *             if py_bufs_len > 0:             # <<<<<<<<<<<<<<
+ *                 ctx.py_bufs = <Py_buffer*>PyMem_RawMalloc(
+ *                     py_bufs_len * sizeof(Py_buffer))
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":144
+ * 
+ *             ctx.uv_bufs = <uv.uv_buf_t*>PyMem_RawMalloc(
+ *                 len(buffers) * sizeof(uv.uv_buf_t))             # <<<<<<<<<<<<<<
+ *             if ctx.uv_bufs is NULL:
+ *                 raise MemoryError()
+ */
+    if (unlikely(__pyx_v_buffers == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+      __PYX_ERR(18, 144, __pyx_L1_error)
+    }
+    __pyx_t_2 = PyList_GET_SIZE(__pyx_v_buffers); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(18, 144, __pyx_L1_error)
+
+    /* "uvloop/handles/stream.pyx":143
+ *                     raise MemoryError()
+ * 
+ *             ctx.uv_bufs = <uv.uv_buf_t*>PyMem_RawMalloc(             # <<<<<<<<<<<<<<
+ *                 len(buffers) * sizeof(uv.uv_buf_t))
+ *             if ctx.uv_bufs is NULL:
+ */
+    __pyx_v_ctx->uv_bufs = ((uv_buf_t *)PyMem_RawMalloc((__pyx_t_2 * (sizeof(uv_buf_t)))));
+
+    /* "uvloop/handles/stream.pyx":145
+ *             ctx.uv_bufs = <uv.uv_buf_t*>PyMem_RawMalloc(
+ *                 len(buffers) * sizeof(uv.uv_buf_t))
+ *             if ctx.uv_bufs is NULL:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError()
+ * 
+ */
+    __pyx_t_6 = ((__pyx_v_ctx->uv_bufs == NULL) != 0);
+    if (unlikely(__pyx_t_6)) {
+
+      /* "uvloop/handles/stream.pyx":146
+ *                 len(buffers) * sizeof(uv.uv_buf_t))
+ *             if ctx.uv_bufs is NULL:
+ *                 raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *             p_pybufs = ctx.py_bufs
+ */
+      PyErr_NoMemory(); __PYX_ERR(18, 146, __pyx_L1_error)
+
+      /* "uvloop/handles/stream.pyx":145
+ *             ctx.uv_bufs = <uv.uv_buf_t*>PyMem_RawMalloc(
+ *                 len(buffers) * sizeof(uv.uv_buf_t))
+ *             if ctx.uv_bufs is NULL:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError()
+ * 
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":148
+ *                 raise MemoryError()
+ * 
+ *             p_pybufs = ctx.py_bufs             # <<<<<<<<<<<<<<
+ *             p_uvbufs = ctx.uv_bufs
+ * 
+ */
+    __pyx_t_9 = __pyx_v_ctx->py_bufs;
+    __pyx_v_p_pybufs = __pyx_t_9;
+
+    /* "uvloop/handles/stream.pyx":149
+ * 
+ *             p_pybufs = ctx.py_bufs
+ *             p_uvbufs = ctx.uv_bufs             # <<<<<<<<<<<<<<
+ * 
+ *         py_bufs_len = 0
+ */
+    __pyx_t_10 = __pyx_v_ctx->uv_bufs;
+    __pyx_v_p_uvbufs = __pyx_t_10;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/stream.pyx":151
+ *             p_uvbufs = ctx.uv_bufs
+ * 
+ *         py_bufs_len = 0             # <<<<<<<<<<<<<<
+ *         for buf in buffers:
+ *             if PyBytes_CheckExact(buf):
+ */
+  __pyx_v_py_bufs_len = 0;
+
+  /* "uvloop/handles/stream.pyx":152
+ * 
+ *         py_bufs_len = 0
+ *         for buf in buffers:             # <<<<<<<<<<<<<<
+ *             if PyBytes_CheckExact(buf):
+ *                 # We can only use this hack for bytes since it's
+ */
+  if (unlikely(__pyx_v_buffers == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(18, 152, __pyx_L1_error)
+  }
+  __pyx_t_1 = __pyx_v_buffers; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+  for (;;) {
+    if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_7); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(18, 152, __pyx_L1_error)
+    #else
+    __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_7)) __PYX_ERR(18, 152, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_buf, __pyx_t_7);
+    __pyx_t_7 = 0;
+
+    /* "uvloop/handles/stream.pyx":153
+ *         py_bufs_len = 0
+ *         for buf in buffers:
+ *             if PyBytes_CheckExact(buf):             # <<<<<<<<<<<<<<
+ *                 # We can only use this hack for bytes since it's
+ *                 # immutable.  For everything else it is only safe to
+ */
+    __pyx_t_6 = (PyBytes_CheckExact(__pyx_v_buf) != 0);
+    if (__pyx_t_6) {
+
+      /* "uvloop/handles/stream.pyx":157
+ *                 # immutable.  For everything else it is only safe to
+ *                 # use buffer protocol.
+ *                 p_uvbufs[uv_bufs_idx].base = PyBytes_AS_STRING(buf)             # <<<<<<<<<<<<<<
+ *                 p_uvbufs[uv_bufs_idx].len = Py_SIZE(buf)
+ * 
+ */
+      (__pyx_v_p_uvbufs[__pyx_v_uv_bufs_idx]).base = PyBytes_AS_STRING(__pyx_v_buf);
+
+      /* "uvloop/handles/stream.pyx":158
+ *                 # use buffer protocol.
+ *                 p_uvbufs[uv_bufs_idx].base = PyBytes_AS_STRING(buf)
+ *                 p_uvbufs[uv_bufs_idx].len = Py_SIZE(buf)             # <<<<<<<<<<<<<<
+ * 
+ *             else:
+ */
+      (__pyx_v_p_uvbufs[__pyx_v_uv_bufs_idx]).len = Py_SIZE(__pyx_v_buf);
+
+      /* "uvloop/handles/stream.pyx":153
+ *         py_bufs_len = 0
+ *         for buf in buffers:
+ *             if PyBytes_CheckExact(buf):             # <<<<<<<<<<<<<<
+ *                 # We can only use this hack for bytes since it's
+ *                 # immutable.  For everything else it is only safe to
+ */
+      goto __pyx_L17;
+    }
+
+    /* "uvloop/handles/stream.pyx":161
+ * 
+ *             else:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     PyObject_GetBuffer(
+ *                         buf, &p_pybufs[py_bufs_len], PyBUF_SIMPLE)
+ */
+    /*else*/ {
+      {
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+        __Pyx_XGOTREF(__pyx_t_11);
+        __Pyx_XGOTREF(__pyx_t_12);
+        __Pyx_XGOTREF(__pyx_t_13);
+        /*try:*/ {
+
+          /* "uvloop/handles/stream.pyx":162
+ *             else:
+ *                 try:
+ *                     PyObject_GetBuffer(             # <<<<<<<<<<<<<<
+ *                         buf, &p_pybufs[py_bufs_len], PyBUF_SIMPLE)
+ *                 except Exception:
+ */
+          __pyx_t_14 = PyObject_GetBuffer(__pyx_v_buf, (&(__pyx_v_p_pybufs[__pyx_v_py_bufs_len])), PyBUF_SIMPLE); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(18, 162, __pyx_L18_error)
+
+          /* "uvloop/handles/stream.pyx":161
+ * 
+ *             else:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     PyObject_GetBuffer(
+ *                         buf, &p_pybufs[py_bufs_len], PyBUF_SIMPLE)
+ */
+        }
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+        goto __pyx_L25_try_end;
+        __pyx_L18_error:;
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+        /* "uvloop/handles/stream.pyx":164
+ *                     PyObject_GetBuffer(
+ *                         buf, &p_pybufs[py_bufs_len], PyBUF_SIMPLE)
+ *                 except Exception:             # <<<<<<<<<<<<<<
+ *                     # This shouldn't ever happen, as `UVStream._write`
+ *                     # casts non-bytes objects to `memoryviews`.
+ */
+        __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+        if (__pyx_t_14) {
+          __Pyx_AddTraceback("uvloop.loop._StreamWriteContext.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_8) < 0) __PYX_ERR(18, 164, __pyx_L20_except_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_GOTREF(__pyx_t_8);
+
+          /* "uvloop/handles/stream.pyx":167
+ *                     # This shouldn't ever happen, as `UVStream._write`
+ *                     # casts non-bytes objects to `memoryviews`.
+ *                     ctx.py_bufs_len = py_bufs_len             # <<<<<<<<<<<<<<
+ *                     ctx.free_bufs()
+ *                     raise
+ */
+          __pyx_v_ctx->py_bufs_len = __pyx_v_py_bufs_len;
+
+          /* "uvloop/handles/stream.pyx":168
+ *                     # casts non-bytes objects to `memoryviews`.
+ *                     ctx.py_bufs_len = py_bufs_len
+ *                     ctx.free_bufs()             # <<<<<<<<<<<<<<
+ *                     raise
+ * 
+ */
+          __pyx_t_15 = ((struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *)__pyx_v_ctx->__pyx_vtab)->free_bufs(__pyx_v_ctx); if (unlikely(!__pyx_t_15)) __PYX_ERR(18, 168, __pyx_L20_except_error)
+          __Pyx_GOTREF(__pyx_t_15);
+          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+          /* "uvloop/handles/stream.pyx":169
+ *                     ctx.py_bufs_len = py_bufs_len
+ *                     ctx.free_bufs()
+ *                     raise             # <<<<<<<<<<<<<<
+ * 
+ *                 p_uvbufs[uv_bufs_idx].base = <char*>p_pybufs[py_bufs_len].buf
+ */
+          __Pyx_GIVEREF(__pyx_t_7);
+          __Pyx_GIVEREF(__pyx_t_4);
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_4, __pyx_t_8);
+          __pyx_t_7 = 0; __pyx_t_4 = 0; __pyx_t_8 = 0; 
+          __PYX_ERR(18, 169, __pyx_L20_except_error)
+        }
+        goto __pyx_L20_except_error;
+        __pyx_L20_except_error:;
+
+        /* "uvloop/handles/stream.pyx":161
+ * 
+ *             else:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     PyObject_GetBuffer(
+ *                         buf, &p_pybufs[py_bufs_len], PyBUF_SIMPLE)
+ */
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+        goto __pyx_L1_error;
+        __pyx_L25_try_end:;
+      }
+
+      /* "uvloop/handles/stream.pyx":171
+ *                     raise
+ * 
+ *                 p_uvbufs[uv_bufs_idx].base = <char*>p_pybufs[py_bufs_len].buf             # <<<<<<<<<<<<<<
+ *                 p_uvbufs[uv_bufs_idx].len = p_pybufs[py_bufs_len].len
+ * 
+ */
+      (__pyx_v_p_uvbufs[__pyx_v_uv_bufs_idx]).base = ((char *)(__pyx_v_p_pybufs[__pyx_v_py_bufs_len]).buf);
+
+      /* "uvloop/handles/stream.pyx":172
+ * 
+ *                 p_uvbufs[uv_bufs_idx].base = <char*>p_pybufs[py_bufs_len].buf
+ *                 p_uvbufs[uv_bufs_idx].len = p_pybufs[py_bufs_len].len             # <<<<<<<<<<<<<<
+ * 
+ *                 py_bufs_len += 1
+ */
+      __pyx_t_16 = (__pyx_v_p_pybufs[__pyx_v_py_bufs_len]).len;
+      (__pyx_v_p_uvbufs[__pyx_v_uv_bufs_idx]).len = __pyx_t_16;
+
+      /* "uvloop/handles/stream.pyx":174
+ *                 p_uvbufs[uv_bufs_idx].len = p_pybufs[py_bufs_len].len
+ * 
+ *                 py_bufs_len += 1             # <<<<<<<<<<<<<<
+ * 
+ *             uv_bufs_idx += 1
+ */
+      __pyx_v_py_bufs_len = (__pyx_v_py_bufs_len + 1);
+    }
+    __pyx_L17:;
+
+    /* "uvloop/handles/stream.pyx":176
+ *                 py_bufs_len += 1
+ * 
+ *             uv_bufs_idx += 1             # <<<<<<<<<<<<<<
+ * 
+ *         ctx.uv_bufs_start = p_uvbufs
+ */
+    __pyx_v_uv_bufs_idx = (__pyx_v_uv_bufs_idx + 1);
+
+    /* "uvloop/handles/stream.pyx":152
+ * 
+ *         py_bufs_len = 0
+ *         for buf in buffers:             # <<<<<<<<<<<<<<
+ *             if PyBytes_CheckExact(buf):
+ *                 # We can only use this hack for bytes since it's
+ */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":178
+ *             uv_bufs_idx += 1
+ * 
+ *         ctx.uv_bufs_start = p_uvbufs             # <<<<<<<<<<<<<<
+ *         ctx.uv_bufs_len = uv_bufs_idx
+ * 
+ */
+  __pyx_v_ctx->uv_bufs_start = __pyx_v_p_uvbufs;
+
+  /* "uvloop/handles/stream.pyx":179
+ * 
+ *         ctx.uv_bufs_start = p_uvbufs
+ *         ctx.uv_bufs_len = uv_bufs_idx             # <<<<<<<<<<<<<<
+ * 
+ *         ctx.py_bufs_len = py_bufs_len
+ */
+  __pyx_v_ctx->uv_bufs_len = __pyx_v_uv_bufs_idx;
+
+  /* "uvloop/handles/stream.pyx":181
+ *         ctx.uv_bufs_len = uv_bufs_idx
+ * 
+ *         ctx.py_bufs_len = py_bufs_len             # <<<<<<<<<<<<<<
+ *         ctx.req.data = <void*> ctx
+ * 
+ */
+  __pyx_v_ctx->py_bufs_len = __pyx_v_py_bufs_len;
+
+  /* "uvloop/handles/stream.pyx":182
+ * 
+ *         ctx.py_bufs_len = py_bufs_len
+ *         ctx.req.data = <void*> ctx             # <<<<<<<<<<<<<<
+ * 
+ *         if UVLOOP_DEBUG:
+ */
+  __pyx_v_ctx->req.data = ((void *)__pyx_v_ctx);
+
+  /* "uvloop/handles/stream.pyx":184
+ *         ctx.req.data = <void*> ctx
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             stream._loop._debug_stream_write_ctx_total += 1
+ *             stream._loop._debug_stream_write_ctx_cnt += 1
+ */
+  __pyx_t_6 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_6) {
+
+    /* "uvloop/handles/stream.pyx":185
+ * 
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_write_ctx_total += 1             # <<<<<<<<<<<<<<
+ *             stream._loop._debug_stream_write_ctx_cnt += 1
+ * 
+ */
+    __Pyx_INCREF(((PyObject *)__pyx_v_stream->__pyx_base.__pyx_base.__pyx_base._loop));
+    __pyx_t_17 = __pyx_v_stream->__pyx_base.__pyx_base.__pyx_base._loop;
+    __pyx_t_17->_debug_stream_write_ctx_total = (__pyx_t_17->_debug_stream_write_ctx_total + 1);
+    __Pyx_DECREF(((PyObject *)__pyx_t_17)); __pyx_t_17 = 0;
+
+    /* "uvloop/handles/stream.pyx":186
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_write_ctx_total += 1
+ *             stream._loop._debug_stream_write_ctx_cnt += 1             # <<<<<<<<<<<<<<
+ * 
+ *         # Do incref after everything else is done.
+ */
+    __Pyx_INCREF(((PyObject *)__pyx_v_stream->__pyx_base.__pyx_base.__pyx_base._loop));
+    __pyx_t_17 = __pyx_v_stream->__pyx_base.__pyx_base.__pyx_base._loop;
+    __pyx_t_17->_debug_stream_write_ctx_cnt = (__pyx_t_17->_debug_stream_write_ctx_cnt + 1);
+    __Pyx_DECREF(((PyObject *)__pyx_t_17)); __pyx_t_17 = 0;
+
+    /* "uvloop/handles/stream.pyx":184
+ *         ctx.req.data = <void*> ctx
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             stream._loop._debug_stream_write_ctx_total += 1
+ *             stream._loop._debug_stream_write_ctx_cnt += 1
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":191
+ *         # Under no circumstances we want `ctx` to be GCed while
+ *         # libuv is still working with `ctx.uv_bufs`.
+ *         Py_INCREF(ctx)             # <<<<<<<<<<<<<<
+ *         ctx.closed = 0
+ *         return ctx
+ */
+  Py_INCREF(((PyObject *)__pyx_v_ctx));
+
+  /* "uvloop/handles/stream.pyx":192
+ *         # libuv is still working with `ctx.uv_bufs`.
+ *         Py_INCREF(ctx)
+ *         ctx.closed = 0             # <<<<<<<<<<<<<<
+ *         return ctx
+ * 
+ */
+  __pyx_v_ctx->closed = 0;
+
+  /* "uvloop/handles/stream.pyx":193
+ *         Py_INCREF(ctx)
+ *         ctx.closed = 0
+ *         return ctx             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_ctx));
+  __pyx_r = __pyx_v_ctx;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/stream.pyx":98
+ * 
+ *     @staticmethod
+ *     cdef _StreamWriteContext new(UVStream stream, list buffers):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             _StreamWriteContext ctx
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_15);
+  __Pyx_XDECREF(((PyObject *)__pyx_t_17));
+  __Pyx_AddTraceback("uvloop.loop._StreamWriteContext.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_ctx);
+  __Pyx_XDECREF(__pyx_v_buf);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":195
+ *         return ctx
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if not self.closed:
+ *             # Because we do an INCREF in _StreamWriteContext.new,
+ */
+
+/* Python wrapper */
+static void __pyx_pw_6uvloop_4loop_19_StreamWriteContext_1__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_6uvloop_4loop_19_StreamWriteContext_1__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_6uvloop_4loop_19_StreamWriteContext___dealloc__(((struct __pyx_obj_6uvloop_4loop__StreamWriteContext *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_6uvloop_4loop_19_StreamWriteContext___dealloc__(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "uvloop/handles/stream.pyx":196
+ * 
+ *     def __dealloc__(self):
+ *         if not self.closed:             # <<<<<<<<<<<<<<
+ *             # Because we do an INCREF in _StreamWriteContext.new,
+ *             # __dealloc__ shouldn't ever happen with `self.closed == 1`
+ */
+  __pyx_t_1 = ((!(__pyx_v_self->closed != 0)) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/stream.pyx":199
+ *             # Because we do an INCREF in _StreamWriteContext.new,
+ *             # __dealloc__ shouldn't ever happen with `self.closed == 1`
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'open _StreamWriteContext is being deallocated')
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__144, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 199, __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(18, 199, __pyx_L1_error)
+
+    /* "uvloop/handles/stream.pyx":196
+ * 
+ *     def __dealloc__(self):
+ *         if not self.closed:             # <<<<<<<<<<<<<<
+ *             # Because we do an INCREF in _StreamWriteContext.new,
+ *             # __dealloc__ shouldn't ever happen with `self.closed == 1`
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":202
+ *                 'open _StreamWriteContext is being deallocated')
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if self.stream is not None:
+ *                 self.stream._loop._debug_stream_write_ctx_cnt -= 1
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":203
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if self.stream is not None:             # <<<<<<<<<<<<<<
+ *                 self.stream._loop._debug_stream_write_ctx_cnt -= 1
+ *                 self.stream = None
+ */
+    __pyx_t_1 = (((PyObject *)__pyx_v_self->stream) != Py_None);
+    __pyx_t_3 = (__pyx_t_1 != 0);
+    if (__pyx_t_3) {
+
+      /* "uvloop/handles/stream.pyx":204
+ *         if UVLOOP_DEBUG:
+ *             if self.stream is not None:
+ *                 self.stream._loop._debug_stream_write_ctx_cnt -= 1             # <<<<<<<<<<<<<<
+ *                 self.stream = None
+ * 
+ */
+      __Pyx_INCREF(((PyObject *)__pyx_v_self->stream->__pyx_base.__pyx_base.__pyx_base._loop));
+      __pyx_t_4 = __pyx_v_self->stream->__pyx_base.__pyx_base.__pyx_base._loop;
+      __pyx_t_4->_debug_stream_write_ctx_cnt = (__pyx_t_4->_debug_stream_write_ctx_cnt - 1);
+      __Pyx_DECREF(((PyObject *)__pyx_t_4)); __pyx_t_4 = 0;
+
+      /* "uvloop/handles/stream.pyx":205
+ *             if self.stream is not None:
+ *                 self.stream._loop._debug_stream_write_ctx_cnt -= 1
+ *                 self.stream = None             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+      __Pyx_INCREF(Py_None);
+      __Pyx_GIVEREF(Py_None);
+      __Pyx_GOTREF(__pyx_v_self->stream);
+      __Pyx_DECREF(((PyObject *)__pyx_v_self->stream));
+      __pyx_v_self->stream = ((struct __pyx_obj_6uvloop_4loop_UVStream *)Py_None);
+
+      /* "uvloop/handles/stream.pyx":203
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if self.stream is not None:             # <<<<<<<<<<<<<<
+ *                 self.stream._loop._debug_stream_write_ctx_cnt -= 1
+ *                 self.stream = None
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":202
+ *                 'open _StreamWriteContext is being deallocated')
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if self.stream is not None:
+ *                 self.stream._loop._debug_stream_write_ctx_cnt -= 1
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":195
+ *         return ctx
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if not self.closed:
+ *             # Because we do an INCREF in _StreamWriteContext.new,
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(((PyObject *)__pyx_t_4));
+  __Pyx_WriteUnraisable("uvloop.loop._StreamWriteContext.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_19_StreamWriteContext_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_19_StreamWriteContext_2__reduce_cython__[] = "_StreamWriteContext.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_19_StreamWriteContext_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_6uvloop_4loop_19_StreamWriteContext_2__reduce_cython__(((struct __pyx_obj_6uvloop_4loop__StreamWriteContext *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_19_StreamWriteContext_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__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);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__145, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 2, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start 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("uvloop.loop._StreamWriteContext.__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("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_19_StreamWriteContext_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_19_StreamWriteContext_4__setstate_cython__[] = "_StreamWriteContext.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_19_StreamWriteContext_5__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_6uvloop_4loop_19_StreamWriteContext_4__setstate_cython__(((struct __pyx_obj_6uvloop_4loop__StreamWriteContext *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_19_StreamWriteContext_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__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);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__146, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 4, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._StreamWriteContext.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":211
+ * cdef class UVStream(UVBaseTransport):
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.__shutting_down = 0
+ *         self.__reading = 0
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_8UVStream_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_8UVStream_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVStream___cinit__(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_8UVStream___cinit__(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  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);
+
+  /* "uvloop/handles/stream.pyx":212
+ * 
+ *     def __cinit__(self):
+ *         self.__shutting_down = 0             # <<<<<<<<<<<<<<
+ *         self.__reading = 0
+ *         self.__read_error_close = 0
+ */
+  __pyx_v_self->__pyx___shutting_down = 0;
+
+  /* "uvloop/handles/stream.pyx":213
+ *     def __cinit__(self):
+ *         self.__shutting_down = 0
+ *         self.__reading = 0             # <<<<<<<<<<<<<<
+ *         self.__read_error_close = 0
+ *         self.__buffered = 0
+ */
+  __pyx_v_self->__pyx___reading = 0;
+
+  /* "uvloop/handles/stream.pyx":214
+ *         self.__shutting_down = 0
+ *         self.__reading = 0
+ *         self.__read_error_close = 0             # <<<<<<<<<<<<<<
+ *         self.__buffered = 0
+ *         self._eof = 0
+ */
+  __pyx_v_self->__pyx___read_error_close = 0;
+
+  /* "uvloop/handles/stream.pyx":215
+ *         self.__reading = 0
+ *         self.__read_error_close = 0
+ *         self.__buffered = 0             # <<<<<<<<<<<<<<
+ *         self._eof = 0
+ *         self._buffer = []
+ */
+  __pyx_v_self->__pyx___buffered = 0;
+
+  /* "uvloop/handles/stream.pyx":216
+ *         self.__read_error_close = 0
+ *         self.__buffered = 0
+ *         self._eof = 0             # <<<<<<<<<<<<<<
+ *         self._buffer = []
+ *         self._buffer_size = 0
+ */
+  __pyx_v_self->_eof = 0;
+
+  /* "uvloop/handles/stream.pyx":217
+ *         self.__buffered = 0
+ *         self._eof = 0
+ *         self._buffer = []             # <<<<<<<<<<<<<<
+ *         self._buffer_size = 0
+ * 
+ */
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_buffer);
+  __Pyx_DECREF(__pyx_v_self->_buffer);
+  __pyx_v_self->_buffer = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":218
+ *         self._eof = 0
+ *         self._buffer = []
+ *         self._buffer_size = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._protocol_get_buffer = None
+ */
+  __pyx_v_self->_buffer_size = 0;
+
+  /* "uvloop/handles/stream.pyx":220
+ *         self._buffer_size = 0
+ * 
+ *         self._protocol_get_buffer = None             # <<<<<<<<<<<<<<
+ *         self._protocol_buffer_updated = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_protocol_get_buffer);
+  __Pyx_DECREF(__pyx_v_self->_protocol_get_buffer);
+  __pyx_v_self->_protocol_get_buffer = Py_None;
+
+  /* "uvloop/handles/stream.pyx":221
+ * 
+ *         self._protocol_get_buffer = None
+ *         self._protocol_buffer_updated = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._read_pybuf_acquired = False
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_protocol_buffer_updated);
+  __Pyx_DECREF(__pyx_v_self->_protocol_buffer_updated);
+  __pyx_v_self->_protocol_buffer_updated = Py_None;
+
+  /* "uvloop/handles/stream.pyx":223
+ *         self._protocol_buffer_updated = None
+ * 
+ *         self._read_pybuf_acquired = False             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _set_protocol(self, object protocol):
+ */
+  __pyx_v_self->_read_pybuf_acquired = 0;
+
+  /* "uvloop/handles/stream.pyx":211
+ * cdef class UVStream(UVBaseTransport):
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.__shutting_down = 0
+ *         self.__reading = 0
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStream.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":225
+ *         self._read_pybuf_acquired = False
+ * 
+ *     cdef _set_protocol(self, object protocol):             # <<<<<<<<<<<<<<
+ *         if protocol is None:
+ *             raise TypeError('protocol is required')
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8UVStream__set_protocol(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_protocol) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_set_protocol", 0);
+
+  /* "uvloop/handles/stream.pyx":226
+ * 
+ *     cdef _set_protocol(self, object protocol):
+ *         if protocol is None:             # <<<<<<<<<<<<<<
+ *             raise TypeError('protocol is required')
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_protocol == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/stream.pyx":227
+ *     cdef _set_protocol(self, object protocol):
+ *         if protocol is None:
+ *             raise TypeError('protocol is required')             # <<<<<<<<<<<<<<
+ * 
+ *         UVBaseTransport._set_protocol(self, protocol)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__147, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 227, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(18, 227, __pyx_L1_error)
+
+    /* "uvloop/handles/stream.pyx":226
+ * 
+ *     cdef _set_protocol(self, object protocol):
+ *         if protocol is None:             # <<<<<<<<<<<<<<
+ *             raise TypeError('protocol is required')
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":229
+ *             raise TypeError('protocol is required')
+ * 
+ *         UVBaseTransport._set_protocol(self, protocol)             # <<<<<<<<<<<<<<
+ * 
+ *         if (hasattr(protocol, 'get_buffer') and
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_15UVBaseTransport__set_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self), __pyx_v_protocol); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/stream.pyx":231
+ *         UVBaseTransport._set_protocol(self, protocol)
+ * 
+ *         if (hasattr(protocol, 'get_buffer') and             # <<<<<<<<<<<<<<
+ *                 not isinstance(protocol, aio_Protocol)):
+ *             try:
+ */
+  __pyx_t_1 = __Pyx_HasAttr(__pyx_v_protocol, __pyx_n_u_get_buffer); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 231, __pyx_L1_error)
+  __pyx_t_4 = (__pyx_t_1 != 0);
+  if (__pyx_t_4) {
+  } else {
+    __pyx_t_2 = __pyx_t_4;
+    goto __pyx_L5_bool_binop_done;
+  }
+
+  /* "uvloop/handles/stream.pyx":232
+ * 
+ *         if (hasattr(protocol, 'get_buffer') and
+ *                 not isinstance(protocol, aio_Protocol)):             # <<<<<<<<<<<<<<
+ *             try:
+ *                 self._protocol_get_buffer = protocol.get_buffer
+ */
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_aio_Protocol;
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_t_4 = PyObject_IsInstance(__pyx_v_protocol, __pyx_t_3); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(18, 232, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0);
+  __pyx_t_2 = __pyx_t_1;
+  __pyx_L5_bool_binop_done:;
+
+  /* "uvloop/handles/stream.pyx":231
+ *         UVBaseTransport._set_protocol(self, protocol)
+ * 
+ *         if (hasattr(protocol, 'get_buffer') and             # <<<<<<<<<<<<<<
+ *                 not isinstance(protocol, aio_Protocol)):
+ *             try:
+ */
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/stream.pyx":233
+ *         if (hasattr(protocol, 'get_buffer') and
+ *                 not isinstance(protocol, aio_Protocol)):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self._protocol_get_buffer = protocol.get_buffer
+ *                 self._protocol_buffer_updated = protocol.buffer_updated
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      /*try:*/ {
+
+        /* "uvloop/handles/stream.pyx":234
+ *                 not isinstance(protocol, aio_Protocol)):
+ *             try:
+ *                 self._protocol_get_buffer = protocol.get_buffer             # <<<<<<<<<<<<<<
+ *                 self._protocol_buffer_updated = protocol.buffer_updated
+ *                 self.__buffered = 1
+ */
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_protocol, __pyx_n_s_get_buffer); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 234, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GIVEREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_v_self->_protocol_get_buffer);
+        __Pyx_DECREF(__pyx_v_self->_protocol_get_buffer);
+        __pyx_v_self->_protocol_get_buffer = __pyx_t_3;
+        __pyx_t_3 = 0;
+
+        /* "uvloop/handles/stream.pyx":235
+ *             try:
+ *                 self._protocol_get_buffer = protocol.get_buffer
+ *                 self._protocol_buffer_updated = protocol.buffer_updated             # <<<<<<<<<<<<<<
+ *                 self.__buffered = 1
+ *             except AttributeError:
+ */
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_protocol, __pyx_n_s_buffer_updated); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 235, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GIVEREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_v_self->_protocol_buffer_updated);
+        __Pyx_DECREF(__pyx_v_self->_protocol_buffer_updated);
+        __pyx_v_self->_protocol_buffer_updated = __pyx_t_3;
+        __pyx_t_3 = 0;
+
+        /* "uvloop/handles/stream.pyx":236
+ *                 self._protocol_get_buffer = protocol.get_buffer
+ *                 self._protocol_buffer_updated = protocol.buffer_updated
+ *                 self.__buffered = 1             # <<<<<<<<<<<<<<
+ *             except AttributeError:
+ *                 pass
+ */
+        __pyx_v_self->__pyx___buffered = 1;
+
+        /* "uvloop/handles/stream.pyx":233
+ *         if (hasattr(protocol, 'get_buffer') and
+ *                 not isinstance(protocol, aio_Protocol)):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self._protocol_get_buffer = protocol.get_buffer
+ *                 self._protocol_buffer_updated = protocol.buffer_updated
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L12_try_end;
+      __pyx_L7_error:;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/stream.pyx":237
+ *                 self._protocol_buffer_updated = protocol.buffer_updated
+ *                 self.__buffered = 1
+ *             except AttributeError:             # <<<<<<<<<<<<<<
+ *                 pass
+ *         else:
+ */
+      __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError);
+      if (__pyx_t_8) {
+        __Pyx_ErrRestore(0,0,0);
+        goto __pyx_L8_exception_handled;
+      }
+      goto __pyx_L9_except_error;
+      __pyx_L9_except_error:;
+
+      /* "uvloop/handles/stream.pyx":233
+ *         if (hasattr(protocol, 'get_buffer') and
+ *                 not isinstance(protocol, aio_Protocol)):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self._protocol_get_buffer = protocol.get_buffer
+ *                 self._protocol_buffer_updated = protocol.buffer_updated
+ */
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+      goto __pyx_L1_error;
+      __pyx_L8_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+      __pyx_L12_try_end:;
+    }
+
+    /* "uvloop/handles/stream.pyx":231
+ *         UVBaseTransport._set_protocol(self, protocol)
+ * 
+ *         if (hasattr(protocol, 'get_buffer') and             # <<<<<<<<<<<<<<
+ *                 not isinstance(protocol, aio_Protocol)):
+ *             try:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/handles/stream.pyx":240
+ *                 pass
+ *         else:
+ *             self.__buffered = 0             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _clear_protocol(self):
+ */
+  /*else*/ {
+    __pyx_v_self->__pyx___buffered = 0;
+  }
+  __pyx_L4:;
+
+  /* "uvloop/handles/stream.pyx":225
+ *         self._read_pybuf_acquired = False
+ * 
+ *     cdef _set_protocol(self, object protocol):             # <<<<<<<<<<<<<<
+ *         if protocol is None:
+ *             raise TypeError('protocol is required')
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._set_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":242
+ *             self.__buffered = 0
+ * 
+ *     cdef _clear_protocol(self):             # <<<<<<<<<<<<<<
+ *         UVBaseTransport._clear_protocol(self)
+ *         self._protocol_get_buffer = None
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8UVStream__clear_protocol(struct __pyx_obj_6uvloop_4loop_UVStream *__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("_clear_protocol", 0);
+
+  /* "uvloop/handles/stream.pyx":243
+ * 
+ *     cdef _clear_protocol(self):
+ *         UVBaseTransport._clear_protocol(self)             # <<<<<<<<<<<<<<
+ *         self._protocol_get_buffer = None
+ *         self._protocol_buffer_updated = None
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_15UVBaseTransport__clear_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":244
+ *     cdef _clear_protocol(self):
+ *         UVBaseTransport._clear_protocol(self)
+ *         self._protocol_get_buffer = None             # <<<<<<<<<<<<<<
+ *         self._protocol_buffer_updated = None
+ *         self.__buffered = 0
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_protocol_get_buffer);
+  __Pyx_DECREF(__pyx_v_self->_protocol_get_buffer);
+  __pyx_v_self->_protocol_get_buffer = Py_None;
+
+  /* "uvloop/handles/stream.pyx":245
+ *         UVBaseTransport._clear_protocol(self)
+ *         self._protocol_get_buffer = None
+ *         self._protocol_buffer_updated = None             # <<<<<<<<<<<<<<
+ *         self.__buffered = 0
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_protocol_buffer_updated);
+  __Pyx_DECREF(__pyx_v_self->_protocol_buffer_updated);
+  __pyx_v_self->_protocol_buffer_updated = Py_None;
+
+  /* "uvloop/handles/stream.pyx":246
+ *         self._protocol_get_buffer = None
+ *         self._protocol_buffer_updated = None
+ *         self.__buffered = 0             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _shutdown(self):
+ */
+  __pyx_v_self->__pyx___buffered = 0;
+
+  /* "uvloop/handles/stream.pyx":242
+ *             self.__buffered = 0
+ * 
+ *     cdef _clear_protocol(self):             # <<<<<<<<<<<<<<
+ *         UVBaseTransport._clear_protocol(self)
+ *         self._protocol_get_buffer = None
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._clear_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":248
+ *         self.__buffered = 0
+ * 
+ *     cdef inline _shutdown(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__shutdown(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("_shutdown", 0);
+
+  /* "uvloop/handles/stream.pyx":251
+ *         cdef int err
+ * 
+ *         if self.__shutting_down:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.__shutting_down = 1
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx___shutting_down != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":252
+ * 
+ *         if self.__shutting_down:
+ *             return             # <<<<<<<<<<<<<<
+ *         self.__shutting_down = 1
+ * 
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":251
+ *         cdef int err
+ * 
+ *         if self.__shutting_down:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.__shutting_down = 1
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":253
+ *         if self.__shutting_down:
+ *             return
+ *         self.__shutting_down = 1             # <<<<<<<<<<<<<<
+ * 
+ *         self._ensure_alive()
+ */
+  __pyx_v_self->__pyx___shutting_down = 1;
+
+  /* "uvloop/handles/stream.pyx":255
+ *         self.__shutting_down = 1
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         self._shutdown_req.data = <void*> self
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/stream.pyx":257
+ *         self._ensure_alive()
+ * 
+ *         self._shutdown_req.data = <void*> self             # <<<<<<<<<<<<<<
+ *         err = uv.uv_shutdown(&self._shutdown_req,
+ *                              <uv.uv_stream_t*> self._handle,
+ */
+  __pyx_v_self->_shutdown_req.data = ((void *)__pyx_v_self);
+
+  /* "uvloop/handles/stream.pyx":258
+ * 
+ *         self._shutdown_req.data = <void*> self
+ *         err = uv.uv_shutdown(&self._shutdown_req,             # <<<<<<<<<<<<<<
+ *                              <uv.uv_stream_t*> self._handle,
+ *                              __uv_stream_on_shutdown)
+ */
+  __pyx_v_err = uv_shutdown((&__pyx_v_self->_shutdown_req), ((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_f_6uvloop_4loop___uv_stream_on_shutdown);
+
+  /* "uvloop/handles/stream.pyx":261
+ *                              <uv.uv_stream_t*> self._handle,
+ *                              __uv_stream_on_shutdown)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":262
+ *                              __uv_stream_on_shutdown)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 262, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":263
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 263, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":264
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _accept(self, UVStream server):
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":261
+ *                              <uv.uv_stream_t*> self._handle,
+ *                              __uv_stream_on_shutdown)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":248
+ *         self.__buffered = 0
+ * 
+ *     cdef inline _shutdown(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":266
+ *             return
+ * 
+ *     cdef inline _accept(self, UVStream server):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         self._ensure_alive()
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__accept(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_server) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_accept", 0);
+
+  /* "uvloop/handles/stream.pyx":268
+ *     cdef inline _accept(self, UVStream server):
+ *         cdef int err
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_accept(<uv.uv_stream_t*>server._handle,
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 268, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":270
+ *         self._ensure_alive()
+ * 
+ *         err = uv.uv_accept(<uv.uv_stream_t*>server._handle,             # <<<<<<<<<<<<<<
+ *                            <uv.uv_stream_t*>self._handle)
+ *         if err < 0:
+ */
+  __pyx_v_err = uv_accept(((uv_stream_t *)__pyx_v_server->__pyx_base.__pyx_base.__pyx_base._handle), ((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle));
+
+  /* "uvloop/handles/stream.pyx":272
+ *         err = uv.uv_accept(<uv.uv_stream_t*>server._handle,
+ *                            <uv.uv_stream_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/stream.pyx":273
+ *                            <uv.uv_stream_t*>self._handle)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 273, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/stream.pyx":274
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 274, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/stream.pyx":275
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._on_accept()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":272
+ *         err = uv.uv_accept(<uv.uv_stream_t*>server._handle,
+ *                            <uv.uv_stream_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":277
+ *             return
+ * 
+ *         self._on_accept()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _close_on_read_error(self):
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_8UVStream__on_accept(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 277, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":266
+ *             return
+ * 
+ *     cdef inline _accept(self, UVStream server):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         self._ensure_alive()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._accept", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":279
+ *         self._on_accept()
+ * 
+ *     cdef inline _close_on_read_error(self):             # <<<<<<<<<<<<<<
+ *         self.__read_error_close = 1
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__close_on_read_error(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_close_on_read_error", 0);
+
+  /* "uvloop/handles/stream.pyx":280
+ * 
+ *     cdef inline _close_on_read_error(self):
+ *         self.__read_error_close = 1             # <<<<<<<<<<<<<<
+ * 
+ *     cdef bint _is_reading(self):
+ */
+  __pyx_v_self->__pyx___read_error_close = 1;
+
+  /* "uvloop/handles/stream.pyx":279
+ *         self._on_accept()
+ * 
+ *     cdef inline _close_on_read_error(self):             # <<<<<<<<<<<<<<
+ *         self.__read_error_close = 1
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":282
+ *         self.__read_error_close = 1
+ * 
+ *     cdef bint _is_reading(self):             # <<<<<<<<<<<<<<
+ *         return self.__reading
+ * 
+ */
+
+static int __pyx_f_6uvloop_4loop_8UVStream__is_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_is_reading", 0);
+
+  /* "uvloop/handles/stream.pyx":283
+ * 
+ *     cdef bint _is_reading(self):
+ *         return self.__reading             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _start_reading(self):
+ */
+  __pyx_r = __pyx_v_self->__pyx___reading;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/stream.pyx":282
+ *         self.__read_error_close = 1
+ * 
+ *     cdef bint _is_reading(self):             # <<<<<<<<<<<<<<
+ *         return self.__reading
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":285
+ *         return self.__reading
+ * 
+ *     cdef _start_reading(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8UVStream__start_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("_start_reading", 0);
+
+  /* "uvloop/handles/stream.pyx":288
+ *         cdef int err
+ * 
+ *         if self._closing:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx_base._closing != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":289
+ * 
+ *         if self._closing:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._ensure_alive()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":288
+ *         cdef int err
+ * 
+ *         if self._closing:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":291
+ *             return
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         if self.__reading:
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 291, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/stream.pyx":293
+ *         self._ensure_alive()
+ * 
+ *         if self.__reading:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx___reading != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":294
+ * 
+ *         if self.__reading:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if self.__buffered:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":293
+ *         self._ensure_alive()
+ * 
+ *         if self.__reading:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":296
+ *             return
+ * 
+ *         if self.__buffered:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_read_start(<uv.uv_stream_t*>self._handle,
+ *                                    __uv_stream_buffered_alloc,
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx___buffered != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":297
+ * 
+ *         if self.__buffered:
+ *             err = uv.uv_read_start(<uv.uv_stream_t*>self._handle,             # <<<<<<<<<<<<<<
+ *                                    __uv_stream_buffered_alloc,
+ *                                    __uv_stream_buffered_on_read)
+ */
+    __pyx_v_err = uv_read_start(((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_f_6uvloop_4loop___uv_stream_buffered_alloc, __pyx_f_6uvloop_4loop___uv_stream_buffered_on_read);
+
+    /* "uvloop/handles/stream.pyx":296
+ *             return
+ * 
+ *         if self.__buffered:             # <<<<<<<<<<<<<<
+ *             err = uv.uv_read_start(<uv.uv_stream_t*>self._handle,
+ *                                    __uv_stream_buffered_alloc,
+ */
+    goto __pyx_L5;
+  }
+
+  /* "uvloop/handles/stream.pyx":301
+ *                                    __uv_stream_buffered_on_read)
+ *         else:
+ *             err = uv.uv_read_start(<uv.uv_stream_t*>self._handle,             # <<<<<<<<<<<<<<
+ *                                    __loop_alloc_buffer,
+ *                                    __uv_stream_on_read)
+ */
+  /*else*/ {
+
+    /* "uvloop/handles/stream.pyx":303
+ *             err = uv.uv_read_start(<uv.uv_stream_t*>self._handle,
+ *                                    __loop_alloc_buffer,
+ *                                    __uv_stream_on_read)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             exc = convert_error(err)
+ */
+    __pyx_v_err = uv_read_start(((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_f_6uvloop_4loop___loop_alloc_buffer, __pyx_f_6uvloop_4loop___uv_stream_on_read);
+  }
+  __pyx_L5:;
+
+  /* "uvloop/handles/stream.pyx":304
+ *                                    __loop_alloc_buffer,
+ *                                    __uv_stream_on_read)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":305
+ *                                    __uv_stream_on_read)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 305, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":306
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ *         else:
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 306, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":307
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ *         else:
+ *             # UVStream must live until the read callback is called
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":304
+ *                                    __loop_alloc_buffer,
+ *                                    __uv_stream_on_read)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":310
+ *         else:
+ *             # UVStream must live until the read callback is called
+ *             self.__reading_started()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline __reading_started(self):
+ */
+  /*else*/ {
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_8UVStream___reading_started(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 310, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+
+  /* "uvloop/handles/stream.pyx":285
+ *         return self.__reading
+ * 
+ *     cdef _start_reading(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._start_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":312
+ *             self.__reading_started()
+ * 
+ *     cdef inline __reading_started(self):             # <<<<<<<<<<<<<<
+ *         if self.__reading:
+ *             return
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream___reading_started(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__reading_started", 0);
+
+  /* "uvloop/handles/stream.pyx":313
+ * 
+ *     cdef inline __reading_started(self):
+ *         if self.__reading:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.__reading = 1
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx___reading != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":314
+ *     cdef inline __reading_started(self):
+ *         if self.__reading:
+ *             return             # <<<<<<<<<<<<<<
+ *         self.__reading = 1
+ *         Py_INCREF(self)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":313
+ * 
+ *     cdef inline __reading_started(self):
+ *         if self.__reading:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.__reading = 1
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":315
+ *         if self.__reading:
+ *             return
+ *         self.__reading = 1             # <<<<<<<<<<<<<<
+ *         Py_INCREF(self)
+ * 
+ */
+  __pyx_v_self->__pyx___reading = 1;
+
+  /* "uvloop/handles/stream.pyx":316
+ *             return
+ *         self.__reading = 1
+ *         Py_INCREF(self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline __reading_stopped(self):
+ */
+  Py_INCREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/handles/stream.pyx":312
+ *             self.__reading_started()
+ * 
+ *     cdef inline __reading_started(self):             # <<<<<<<<<<<<<<
+ *         if self.__reading:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":318
+ *         Py_INCREF(self)
+ * 
+ *     cdef inline __reading_stopped(self):             # <<<<<<<<<<<<<<
+ *         if not self.__reading:
+ *             return
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream___reading_stopped(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__reading_stopped", 0);
+
+  /* "uvloop/handles/stream.pyx":319
+ * 
+ *     cdef inline __reading_stopped(self):
+ *         if not self.__reading:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.__reading = 0
+ */
+  __pyx_t_1 = ((!(__pyx_v_self->__pyx___reading != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":320
+ *     cdef inline __reading_stopped(self):
+ *         if not self.__reading:
+ *             return             # <<<<<<<<<<<<<<
+ *         self.__reading = 0
+ *         Py_DECREF(self)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":319
+ * 
+ *     cdef inline __reading_stopped(self):
+ *         if not self.__reading:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.__reading = 0
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":321
+ *         if not self.__reading:
+ *             return
+ *         self.__reading = 0             # <<<<<<<<<<<<<<
+ *         Py_DECREF(self)
+ * 
+ */
+  __pyx_v_self->__pyx___reading = 0;
+
+  /* "uvloop/handles/stream.pyx":322
+ *             return
+ *         self.__reading = 0
+ *         Py_DECREF(self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _stop_reading(self):
+ */
+  Py_DECREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/handles/stream.pyx":318
+ *         Py_INCREF(self)
+ * 
+ *     cdef inline __reading_stopped(self):             # <<<<<<<<<<<<<<
+ *         if not self.__reading:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":324
+ *         Py_DECREF(self)
+ * 
+ *     cdef _stop_reading(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8UVStream__stop_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("_stop_reading", 0);
+
+  /* "uvloop/handles/stream.pyx":327
+ *         cdef int err
+ * 
+ *         if not self.__reading:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((!(__pyx_v_self->__pyx___reading != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":328
+ * 
+ *         if not self.__reading:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._ensure_alive()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":327
+ *         cdef int err
+ * 
+ *         if not self.__reading:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":330
+ *             return
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         # From libuv docs:
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 330, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/stream.pyx":335
+ *         #    This function is idempotent and may be safely
+ *         #    called on a stopped stream.
+ *         err = uv.uv_read_stop(<uv.uv_stream_t*>self._handle)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             exc = convert_error(err)
+ */
+  __pyx_v_err = uv_read_stop(((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle));
+
+  /* "uvloop/handles/stream.pyx":336
+ *         #    called on a stopped stream.
+ *         err = uv.uv_read_stop(<uv.uv_stream_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":337
+ *         err = uv.uv_read_stop(<uv.uv_stream_t*>self._handle)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 337, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":338
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ *         else:
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 338, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":339
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ *         else:
+ *             self.__reading_stopped()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":336
+ *         #    called on a stopped stream.
+ *         err = uv.uv_read_stop(<uv.uv_stream_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":341
+ *             return
+ *         else:
+ *             self.__reading_stopped()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _try_write(self, object data):
+ */
+  /*else*/ {
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_8UVStream___reading_stopped(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 341, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+
+  /* "uvloop/handles/stream.pyx":324
+ *         Py_DECREF(self)
+ * 
+ *     cdef _stop_reading(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._stop_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":343
+ *             self.__reading_stopped()
+ * 
+ *     cdef inline _try_write(self, object data):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             ssize_t written
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__try_write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_data) {
+  Py_ssize_t __pyx_v_written;
+  int __pyx_v_used_buf;
+  Py_buffer __pyx_v_py_buf;
+  void *__pyx_v_buf;
+  size_t __pyx_v_blen;
+  int __pyx_v_saved_errno;
+  int __pyx_v_fd;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  void *__pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  int __pyx_t_6;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_try_write", 0);
+
+  /* "uvloop/handles/stream.pyx":346
+ *         cdef:
+ *             ssize_t written
+ *             bint used_buf = 0             # <<<<<<<<<<<<<<
+ *             Py_buffer py_buf
+ *             void* buf
+ */
+  __pyx_v_used_buf = 0;
+
+  /* "uvloop/handles/stream.pyx":353
+ *             int fd
+ * 
+ *         if (<uv.uv_stream_t*>self._handle).write_queue_size != 0:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'UVStream._try_write called with data in uv buffers')
+ */
+  __pyx_t_1 = ((((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle)->write_queue_size != 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/stream.pyx":354
+ * 
+ *         if (<uv.uv_stream_t*>self._handle).write_queue_size != 0:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'UVStream._try_write called with data in uv buffers')
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__148, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 354, __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(18, 354, __pyx_L1_error)
+
+    /* "uvloop/handles/stream.pyx":353
+ *             int fd
+ * 
+ *         if (<uv.uv_stream_t*>self._handle).write_queue_size != 0:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'UVStream._try_write called with data in uv buffers')
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":357
+ *                 'UVStream._try_write called with data in uv buffers')
+ * 
+ *         if PyBytes_CheckExact(data):             # <<<<<<<<<<<<<<
+ *             # We can only use this hack for bytes since it's
+ *             # immutable.  For everything else it is only safe to
+ */
+  __pyx_t_1 = (PyBytes_CheckExact(__pyx_v_data) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":361
+ *             # immutable.  For everything else it is only safe to
+ *             # use buffer protocol.
+ *             buf = <void*>PyBytes_AS_STRING(data)             # <<<<<<<<<<<<<<
+ *             blen = Py_SIZE(data)
+ *         else:
+ */
+    __pyx_v_buf = ((void *)PyBytes_AS_STRING(__pyx_v_data));
+
+    /* "uvloop/handles/stream.pyx":362
+ *             # use buffer protocol.
+ *             buf = <void*>PyBytes_AS_STRING(data)
+ *             blen = Py_SIZE(data)             # <<<<<<<<<<<<<<
+ *         else:
+ *             PyObject_GetBuffer(data, &py_buf, PyBUF_SIMPLE)
+ */
+    __pyx_v_blen = Py_SIZE(__pyx_v_data);
+
+    /* "uvloop/handles/stream.pyx":357
+ *                 'UVStream._try_write called with data in uv buffers')
+ * 
+ *         if PyBytes_CheckExact(data):             # <<<<<<<<<<<<<<
+ *             # We can only use this hack for bytes since it's
+ *             # immutable.  For everything else it is only safe to
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/handles/stream.pyx":364
+ *             blen = Py_SIZE(data)
+ *         else:
+ *             PyObject_GetBuffer(data, &py_buf, PyBUF_SIMPLE)             # <<<<<<<<<<<<<<
+ *             used_buf = 1
+ *             buf = py_buf.buf
+ */
+  /*else*/ {
+    __pyx_t_3 = PyObject_GetBuffer(__pyx_v_data, (&__pyx_v_py_buf), PyBUF_SIMPLE); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(18, 364, __pyx_L1_error)
+
+    /* "uvloop/handles/stream.pyx":365
+ *         else:
+ *             PyObject_GetBuffer(data, &py_buf, PyBUF_SIMPLE)
+ *             used_buf = 1             # <<<<<<<<<<<<<<
+ *             buf = py_buf.buf
+ *             blen = py_buf.len
+ */
+    __pyx_v_used_buf = 1;
+
+    /* "uvloop/handles/stream.pyx":366
+ *             PyObject_GetBuffer(data, &py_buf, PyBUF_SIMPLE)
+ *             used_buf = 1
+ *             buf = py_buf.buf             # <<<<<<<<<<<<<<
+ *             blen = py_buf.len
+ * 
+ */
+    __pyx_t_4 = __pyx_v_py_buf.buf;
+    __pyx_v_buf = __pyx_t_4;
+
+    /* "uvloop/handles/stream.pyx":367
+ *             used_buf = 1
+ *             buf = py_buf.buf
+ *             blen = py_buf.len             # <<<<<<<<<<<<<<
+ * 
+ *         if blen == 0:
+ */
+    __pyx_t_5 = __pyx_v_py_buf.len;
+    __pyx_v_blen = __pyx_t_5;
+  }
+  __pyx_L4:;
+
+  /* "uvloop/handles/stream.pyx":369
+ *             blen = py_buf.len
+ * 
+ *         if blen == 0:             # <<<<<<<<<<<<<<
+ *             # Empty data, do nothing.
+ *             return 0
+ */
+  __pyx_t_1 = ((__pyx_v_blen == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":371
+ *         if blen == 0:
+ *             # Empty data, do nothing.
+ *             return 0             # <<<<<<<<<<<<<<
+ * 
+ *         fd = self._fileno()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_int_0);
+    __pyx_r = __pyx_int_0;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":369
+ *             blen = py_buf.len
+ * 
+ *         if blen == 0:             # <<<<<<<<<<<<<<
+ *             # Empty data, do nothing.
+ *             return 0
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":373
+ *             return 0
+ * 
+ *         fd = self._fileno()             # <<<<<<<<<<<<<<
+ *         # Use `unistd.h/write` directly, it's faster than
+ *         # uv_try_write -- less layers of code.  The error
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._fileno(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 373, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(18, 373, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_fd = __pyx_t_3;
+
+  /* "uvloop/handles/stream.pyx":377
+ *         # uv_try_write -- less layers of code.  The error
+ *         # checking logic is copied from libuv.
+ *         written = system.write(fd, buf, blen)             # <<<<<<<<<<<<<<
+ *         while written == -1 and (
+ *                 errno.errno == errno.EINTR or
+ */
+  __pyx_v_written = write(__pyx_v_fd, __pyx_v_buf, __pyx_v_blen);
+
+  /* "uvloop/handles/stream.pyx":378
+ *         # checking logic is copied from libuv.
+ *         written = system.write(fd, buf, blen)
+ *         while written == -1 and (             # <<<<<<<<<<<<<<
+ *                 errno.errno == errno.EINTR or
+ *                 (system.PLATFORM_IS_APPLE and
+ */
+  while (1) {
+    __pyx_t_6 = ((__pyx_v_written == -1L) != 0);
+    if (__pyx_t_6) {
+    } else {
+      __pyx_t_1 = __pyx_t_6;
+      goto __pyx_L8_bool_binop_done;
+    }
+
+    /* "uvloop/handles/stream.pyx":379
+ *         written = system.write(fd, buf, blen)
+ *         while written == -1 and (
+ *                 errno.errno == errno.EINTR or             # <<<<<<<<<<<<<<
+ *                 (system.PLATFORM_IS_APPLE and
+ *                     errno.errno == errno.EPROTOTYPE)):
+ */
+    __pyx_t_6 = ((errno == EINTR) != 0);
+    if (!__pyx_t_6) {
+    } else {
+      __pyx_t_1 = __pyx_t_6;
+      goto __pyx_L8_bool_binop_done;
+    }
+
+    /* "uvloop/handles/stream.pyx":380
+ *         while written == -1 and (
+ *                 errno.errno == errno.EINTR or
+ *                 (system.PLATFORM_IS_APPLE and             # <<<<<<<<<<<<<<
+ *                     errno.errno == errno.EPROTOTYPE)):
+ *             # From libuv code (unix/stream.c):
+ */
+    __pyx_t_6 = (PLATFORM_IS_APPLE != 0);
+    if (__pyx_t_6) {
+    } else {
+      __pyx_t_1 = __pyx_t_6;
+      goto __pyx_L8_bool_binop_done;
+    }
+
+    /* "uvloop/handles/stream.pyx":381
+ *                 errno.errno == errno.EINTR or
+ *                 (system.PLATFORM_IS_APPLE and
+ *                     errno.errno == errno.EPROTOTYPE)):             # <<<<<<<<<<<<<<
+ *             # From libuv code (unix/stream.c):
+ *             #   Due to a possible kernel bug at least in OS X 10.10 "Yosemite",
+ */
+    __pyx_t_6 = ((errno == EPROTOTYPE) != 0);
+    __pyx_t_1 = __pyx_t_6;
+    __pyx_L8_bool_binop_done:;
+    if (!__pyx_t_1) break;
+
+    /* "uvloop/handles/stream.pyx":387
+ *             #   that is shutting down. If we retry the write, we should get
+ *             #   the expected EPIPE instead.
+ *             written = system.write(fd, buf, blen)             # <<<<<<<<<<<<<<
+ *         saved_errno = errno.errno
+ * 
+ */
+    __pyx_v_written = write(__pyx_v_fd, __pyx_v_buf, __pyx_v_blen);
+  }
+
+  /* "uvloop/handles/stream.pyx":388
+ *             #   the expected EPIPE instead.
+ *             written = system.write(fd, buf, blen)
+ *         saved_errno = errno.errno             # <<<<<<<<<<<<<<
+ * 
+ *         if used_buf:
+ */
+  __pyx_v_saved_errno = errno;
+
+  /* "uvloop/handles/stream.pyx":390
+ *         saved_errno = errno.errno
+ * 
+ *         if used_buf:             # <<<<<<<<<<<<<<
+ *             PyBuffer_Release(&py_buf)
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_used_buf != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":391
+ * 
+ *         if used_buf:
+ *             PyBuffer_Release(&py_buf)             # <<<<<<<<<<<<<<
+ * 
+ *         if written < 0:
+ */
+    PyBuffer_Release((&__pyx_v_py_buf));
+
+    /* "uvloop/handles/stream.pyx":390
+ *         saved_errno = errno.errno
+ * 
+ *         if used_buf:             # <<<<<<<<<<<<<<
+ *             PyBuffer_Release(&py_buf)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":393
+ *             PyBuffer_Release(&py_buf)
+ * 
+ *         if written < 0:             # <<<<<<<<<<<<<<
+ *             if saved_errno == errno.EAGAIN or \
+ *                     saved_errno == system.EWOULDBLOCK:
+ */
+  __pyx_t_1 = ((__pyx_v_written < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":394
+ * 
+ *         if written < 0:
+ *             if saved_errno == errno.EAGAIN or \             # <<<<<<<<<<<<<<
+ *                     saved_errno == system.EWOULDBLOCK:
+ *                 return -1
+ */
+    __pyx_t_6 = ((__pyx_v_saved_errno == EAGAIN) != 0);
+    if (!__pyx_t_6) {
+    } else {
+      __pyx_t_1 = __pyx_t_6;
+      goto __pyx_L15_bool_binop_done;
+    }
+
+    /* "uvloop/handles/stream.pyx":395
+ *         if written < 0:
+ *             if saved_errno == errno.EAGAIN or \
+ *                     saved_errno == system.EWOULDBLOCK:             # <<<<<<<<<<<<<<
+ *                 return -1
+ *             else:
+ */
+    __pyx_t_6 = ((__pyx_v_saved_errno == EWOULDBLOCK) != 0);
+    __pyx_t_1 = __pyx_t_6;
+    __pyx_L15_bool_binop_done:;
+
+    /* "uvloop/handles/stream.pyx":394
+ * 
+ *         if written < 0:
+ *             if saved_errno == errno.EAGAIN or \             # <<<<<<<<<<<<<<
+ *                     saved_errno == system.EWOULDBLOCK:
+ *                 return -1
+ */
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":396
+ *             if saved_errno == errno.EAGAIN or \
+ *                     saved_errno == system.EWOULDBLOCK:
+ *                 return -1             # <<<<<<<<<<<<<<
+ *             else:
+ *                 exc = convert_error(-saved_errno)
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __Pyx_INCREF(__pyx_int_neg_1);
+      __pyx_r = __pyx_int_neg_1;
+      goto __pyx_L0;
+
+      /* "uvloop/handles/stream.pyx":394
+ * 
+ *         if written < 0:
+ *             if saved_errno == errno.EAGAIN or \             # <<<<<<<<<<<<<<
+ *                     saved_errno == system.EWOULDBLOCK:
+ *                 return -1
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":398
+ *                 return -1
+ *             else:
+ *                 exc = convert_error(-saved_errno)             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, True)
+ *                 return
+ */
+    /*else*/ {
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error((-__pyx_v_saved_errno)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 398, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_v_exc = __pyx_t_2;
+      __pyx_t_2 = 0;
+
+      /* "uvloop/handles/stream.pyx":399
+ *             else:
+ *                 exc = convert_error(-saved_errno)
+ *                 self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *                 return
+ * 
+ */
+      __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 399, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/stream.pyx":400
+ *                 exc = convert_error(-saved_errno)
+ *                 self._fatal_error(exc, True)
+ *                 return             # <<<<<<<<<<<<<<
+ * 
+ *         if UVLOOP_DEBUG:
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+    }
+
+    /* "uvloop/handles/stream.pyx":393
+ *             PyBuffer_Release(&py_buf)
+ * 
+ *         if written < 0:             # <<<<<<<<<<<<<<
+ *             if saved_errno == errno.EAGAIN or \
+ *                     saved_errno == system.EWOULDBLOCK:
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":402
+ *                 return
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             self._loop._debug_stream_write_tries += 1
+ * 
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":403
+ * 
+ *         if UVLOOP_DEBUG:
+ *             self._loop._debug_stream_write_tries += 1             # <<<<<<<<<<<<<<
+ * 
+ *         if <size_t>written == blen:
+ */
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._loop));
+    __pyx_t_7 = __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._loop;
+    __pyx_t_7->_debug_stream_write_tries = (__pyx_t_7->_debug_stream_write_tries + 1);
+    __Pyx_DECREF(((PyObject *)__pyx_t_7)); __pyx_t_7 = 0;
+
+    /* "uvloop/handles/stream.pyx":402
+ *                 return
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             self._loop._debug_stream_write_tries += 1
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":405
+ *             self._loop._debug_stream_write_tries += 1
+ * 
+ *         if <size_t>written == blen:             # <<<<<<<<<<<<<<
+ *             return 0
+ * 
+ */
+  __pyx_t_1 = ((((size_t)__pyx_v_written) == __pyx_v_blen) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":406
+ * 
+ *         if <size_t>written == blen:
+ *             return 0             # <<<<<<<<<<<<<<
+ * 
+ *         return written
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_int_0);
+    __pyx_r = __pyx_int_0;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":405
+ *             self._loop._debug_stream_write_tries += 1
+ * 
+ *         if <size_t>written == blen:             # <<<<<<<<<<<<<<
+ *             return 0
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":408
+ *             return 0
+ * 
+ *         return written             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _write(self, object data):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_written); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 408, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/stream.pyx":343
+ *             self.__reading_stopped()
+ * 
+ *     cdef inline _try_write(self, object data):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             ssize_t written
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(((PyObject *)__pyx_t_7));
+  __Pyx_AddTraceback("uvloop.loop.UVStream._try_write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":410
+ *         return written
+ * 
+ *     cdef inline _write(self, object data):             # <<<<<<<<<<<<<<
+ *         cdef int dlen
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_data) {
+  int __pyx_v_dlen;
+  PyObject *__pyx_v_all_sent = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  Py_ssize_t __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("_write", 0);
+  __Pyx_INCREF(__pyx_v_data);
+
+  /* "uvloop/handles/stream.pyx":413
+ *         cdef int dlen
+ * 
+ *         if not PyBytes_CheckExact(data):             # <<<<<<<<<<<<<<
+ *             data = memoryview(data).cast('b')
+ * 
+ */
+  __pyx_t_1 = ((!(PyBytes_CheckExact(__pyx_v_data) != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":414
+ * 
+ *         if not PyBytes_CheckExact(data):
+ *             data = memoryview(data).cast('b')             # <<<<<<<<<<<<<<
+ * 
+ *         dlen = len(data)
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 414, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_data); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 414, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_cast); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 414, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_n_u_b) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_n_u_b);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 414, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF_SET(__pyx_v_data, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":413
+ *         cdef int dlen
+ * 
+ *         if not PyBytes_CheckExact(data):             # <<<<<<<<<<<<<<
+ *             data = memoryview(data).cast('b')
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":416
+ *             data = memoryview(data).cast('b')
+ * 
+ *         dlen = len(data)             # <<<<<<<<<<<<<<
+ *         if not dlen:
+ *             return
+ */
+  __pyx_t_5 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(18, 416, __pyx_L1_error)
+  __pyx_v_dlen = __pyx_t_5;
+
+  /* "uvloop/handles/stream.pyx":417
+ * 
+ *         dlen = len(data)
+ *         if not dlen:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((!(__pyx_v_dlen != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":418
+ *         dlen = len(data)
+ *         if not dlen:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._buffer_size += dlen
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":417
+ * 
+ *         dlen = len(data)
+ *         if not dlen:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":420
+ *             return
+ * 
+ *         self._buffer_size += dlen             # <<<<<<<<<<<<<<
+ *         self._buffer.append(data)
+ * 
+ */
+  __pyx_v_self->_buffer_size = (__pyx_v_self->_buffer_size + __pyx_v_dlen);
+
+  /* "uvloop/handles/stream.pyx":421
+ * 
+ *         self._buffer_size += dlen
+ *         self._buffer.append(data)             # <<<<<<<<<<<<<<
+ * 
+ *         if (not self._protocol_paused and
+ */
+  if (unlikely(__pyx_v_self->_buffer == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+    __PYX_ERR(18, 421, __pyx_L1_error)
+  }
+  __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_self->_buffer, __pyx_v_data); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(18, 421, __pyx_L1_error)
+
+  /* "uvloop/handles/stream.pyx":423
+ *         self._buffer.append(data)
+ * 
+ *         if (not self._protocol_paused and             # <<<<<<<<<<<<<<
+ *                 (<uv.uv_stream_t*>self._handle).write_queue_size == 0 and
+ *                 self._buffer_size > self._high_water):
+ */
+  __pyx_t_7 = ((!(__pyx_v_self->__pyx_base._protocol_paused != 0)) != 0);
+  if (__pyx_t_7) {
+  } else {
+    __pyx_t_1 = __pyx_t_7;
+    goto __pyx_L6_bool_binop_done;
+  }
+
+  /* "uvloop/handles/stream.pyx":424
+ * 
+ *         if (not self._protocol_paused and
+ *                 (<uv.uv_stream_t*>self._handle).write_queue_size == 0 and             # <<<<<<<<<<<<<<
+ *                 self._buffer_size > self._high_water):
+ *             # Fast-path.  If:
+ */
+  __pyx_t_7 = ((((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle)->write_queue_size == 0) != 0);
+  if (__pyx_t_7) {
+  } else {
+    __pyx_t_1 = __pyx_t_7;
+    goto __pyx_L6_bool_binop_done;
+  }
+
+  /* "uvloop/handles/stream.pyx":425
+ *         if (not self._protocol_paused and
+ *                 (<uv.uv_stream_t*>self._handle).write_queue_size == 0 and
+ *                 self._buffer_size > self._high_water):             # <<<<<<<<<<<<<<
+ *             # Fast-path.  If:
+ *             #   - the protocol isn't yet paused,
+ */
+  __pyx_t_7 = ((__pyx_v_self->_buffer_size > __pyx_v_self->__pyx_base._high_water) != 0);
+  __pyx_t_1 = __pyx_t_7;
+  __pyx_L6_bool_binop_done:;
+
+  /* "uvloop/handles/stream.pyx":423
+ *         self._buffer.append(data)
+ * 
+ *         if (not self._protocol_paused and             # <<<<<<<<<<<<<<
+ *                 (<uv.uv_stream_t*>self._handle).write_queue_size == 0 and
+ *                 self._buffer_size > self._high_water):
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":433
+ *             # Then:
+ *             #   - Try to write all buffered data right now.
+ *             all_sent = self._exec_write()             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 if self._buffer_size != 0 or self._buffer != []:
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_8UVStream__exec_write(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 433, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_all_sent = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":434
+ *             #   - Try to write all buffered data right now.
+ *             all_sent = self._exec_write()
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 if self._buffer_size != 0 or self._buffer != []:
+ *                     raise RuntimeError(
+ */
+    __pyx_t_1 = (UVLOOP_DEBUG != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":435
+ *             all_sent = self._exec_write()
+ *             if UVLOOP_DEBUG:
+ *                 if self._buffer_size != 0 or self._buffer != []:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '_buffer_size is not 0 after a successful _exec_write')
+ */
+      __pyx_t_7 = ((__pyx_v_self->_buffer_size != 0) != 0);
+      if (!__pyx_t_7) {
+      } else {
+        __pyx_t_1 = __pyx_t_7;
+        goto __pyx_L11_bool_binop_done;
+      }
+      __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 435, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_self->_buffer, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 435, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(18, 435, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_1 = __pyx_t_7;
+      __pyx_L11_bool_binop_done:;
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/handles/stream.pyx":436
+ *             if UVLOOP_DEBUG:
+ *                 if self._buffer_size != 0 or self._buffer != []:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '_buffer_size is not 0 after a successful _exec_write')
+ * 
+ */
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__149, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 436, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(18, 436, __pyx_L1_error)
+
+        /* "uvloop/handles/stream.pyx":435
+ *             all_sent = self._exec_write()
+ *             if UVLOOP_DEBUG:
+ *                 if self._buffer_size != 0 or self._buffer != []:             # <<<<<<<<<<<<<<
+ *                     raise RuntimeError(
+ *                         '_buffer_size is not 0 after a successful _exec_write')
+ */
+      }
+
+      /* "uvloop/handles/stream.pyx":434
+ *             #   - Try to write all buffered data right now.
+ *             all_sent = self._exec_write()
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 if self._buffer_size != 0 or self._buffer != []:
+ *                     raise RuntimeError(
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":442
+ *             # as `uv_write` should be called already.
+ * 
+ *             if not all_sent:             # <<<<<<<<<<<<<<
+ *                 # If not all of the data was sent successfully,
+ *                 # we might need to pause the protocol.
+ */
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_all_sent); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(18, 442, __pyx_L1_error)
+    __pyx_t_7 = ((!__pyx_t_1) != 0);
+    if (__pyx_t_7) {
+
+      /* "uvloop/handles/stream.pyx":445
+ *                 # If not all of the data was sent successfully,
+ *                 # we might need to pause the protocol.
+ *                 self._maybe_pause_protocol()             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._maybe_pause_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 445, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/stream.pyx":442
+ *             # as `uv_write` should be called already.
+ * 
+ *             if not all_sent:             # <<<<<<<<<<<<<<
+ *                 # If not all of the data was sent successfully,
+ *                 # we might need to pause the protocol.
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":446
+ *                 # we might need to pause the protocol.
+ *                 self._maybe_pause_protocol()
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._maybe_pause_protocol()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":423
+ *         self._buffer.append(data)
+ * 
+ *         if (not self._protocol_paused and             # <<<<<<<<<<<<<<
+ *                 (<uv.uv_stream_t*>self._handle).write_queue_size == 0 and
+ *                 self._buffer_size > self._high_water):
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":448
+ *             return
+ * 
+ *         self._maybe_pause_protocol()             # <<<<<<<<<<<<<<
+ *         self._loop._queue_write(self)
+ * 
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._maybe_pause_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 448, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/stream.pyx":449
+ * 
+ *         self._maybe_pause_protocol()
+ *         self._loop._queue_write(self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _exec_write(self):
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__queue_write(__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._loop, __pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 449, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/stream.pyx":410
+ *         return written
+ * 
+ *     cdef inline _write(self, object data):             # <<<<<<<<<<<<<<
+ *         cdef int dlen
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_all_sent);
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":451
+ *         self._loop._queue_write(self)
+ * 
+ *     cdef inline _exec_write(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int err
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__exec_write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  int __pyx_v_err;
+  int __pyx_v_buf_len;
+  struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_ctx = 0;
+  PyObject *__pyx_v_data = NULL;
+  PyObject *__pyx_v_sent = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  size_t __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_t_15;
+  char const *__pyx_t_16;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_exec_write", 0);
+
+  /* "uvloop/handles/stream.pyx":455
+ *             int err
+ *             int buf_len
+ *             _StreamWriteContext ctx = None             # <<<<<<<<<<<<<<
+ * 
+ *         if self._closed:
+ */
+  __Pyx_INCREF(Py_None);
+  __pyx_v_ctx = ((struct __pyx_obj_6uvloop_4loop__StreamWriteContext *)Py_None);
+
+  /* "uvloop/handles/stream.pyx":457
+ *             _StreamWriteContext ctx = None
+ * 
+ *         if self._closed:             # <<<<<<<<<<<<<<
+ *             # If the handle is closed, just return, it's too
+ *             # late to do anything.
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._closed != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":460
+ *             # If the handle is closed, just return, it's too
+ *             # late to do anything.
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         buf_len = len(self._buffer)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":457
+ *             _StreamWriteContext ctx = None
+ * 
+ *         if self._closed:             # <<<<<<<<<<<<<<
+ *             # If the handle is closed, just return, it's too
+ *             # late to do anything.
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":462
+ *             return
+ * 
+ *         buf_len = len(self._buffer)             # <<<<<<<<<<<<<<
+ *         if not buf_len:
+ *             return
+ */
+  __pyx_t_2 = __pyx_v_self->_buffer;
+  __Pyx_INCREF(__pyx_t_2);
+  if (unlikely(__pyx_t_2 == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(18, 462, __pyx_L1_error)
+  }
+  __pyx_t_3 = PyList_GET_SIZE(__pyx_t_2); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(18, 462, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_buf_len = __pyx_t_3;
+
+  /* "uvloop/handles/stream.pyx":463
+ * 
+ *         buf_len = len(self._buffer)
+ *         if not buf_len:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((!(__pyx_v_buf_len != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":464
+ *         buf_len = len(self._buffer)
+ *         if not buf_len:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if (<uv.uv_stream_t*>self._handle).write_queue_size == 0:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":463
+ * 
+ *         buf_len = len(self._buffer)
+ *         if not buf_len:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":466
+ *             return
+ * 
+ *         if (<uv.uv_stream_t*>self._handle).write_queue_size == 0:             # <<<<<<<<<<<<<<
+ *             # libuv internal write buffers for this stream are empty.
+ *             if buf_len == 1:
+ */
+  __pyx_t_1 = ((((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle)->write_queue_size == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":468
+ *         if (<uv.uv_stream_t*>self._handle).write_queue_size == 0:
+ *             # libuv internal write buffers for this stream are empty.
+ *             if buf_len == 1:             # <<<<<<<<<<<<<<
+ *                 # If we only have one piece of data to send, let's
+ *                 # use our fast implementation of try_write.
+ */
+    __pyx_t_1 = ((__pyx_v_buf_len == 1) != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":471
+ *                 # If we only have one piece of data to send, let's
+ *                 # use our fast implementation of try_write.
+ *                 data = self._buffer[0]             # <<<<<<<<<<<<<<
+ *                 sent = self._try_write(data)
+ * 
+ */
+      if (unlikely(__pyx_v_self->_buffer == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(18, 471, __pyx_L1_error)
+      }
+      __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_self->_buffer, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 471, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_v_data = __pyx_t_2;
+      __pyx_t_2 = 0;
+
+      /* "uvloop/handles/stream.pyx":472
+ *                 # use our fast implementation of try_write.
+ *                 data = self._buffer[0]
+ *                 sent = self._try_write(data)             # <<<<<<<<<<<<<<
+ * 
+ *                 if sent is None:
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_8UVStream__try_write(__pyx_v_self, __pyx_v_data); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 472, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_v_sent = __pyx_t_2;
+      __pyx_t_2 = 0;
+
+      /* "uvloop/handles/stream.pyx":474
+ *                 sent = self._try_write(data)
+ * 
+ *                 if sent is None:             # <<<<<<<<<<<<<<
+ *                     # A `self._fatal_error` was called.
+ *                     # It might not raise an exception under some
+ */
+      __pyx_t_1 = (__pyx_v_sent == Py_None);
+      __pyx_t_4 = (__pyx_t_1 != 0);
+      if (__pyx_t_4) {
+
+        /* "uvloop/handles/stream.pyx":478
+ *                     # It might not raise an exception under some
+ *                     # conditions.
+ *                     self._buffer_size = 0             # <<<<<<<<<<<<<<
+ *                     self._buffer.clear()
+ *                     if not self._closing:
+ */
+        __pyx_v_self->_buffer_size = 0;
+
+        /* "uvloop/handles/stream.pyx":479
+ *                     # conditions.
+ *                     self._buffer_size = 0
+ *                     self._buffer.clear()             # <<<<<<<<<<<<<<
+ *                     if not self._closing:
+ *                         # This should never happen.
+ */
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_buffer, __pyx_n_s_clear); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 479, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __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_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_5, function);
+          }
+        }
+        __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(18, 479, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/handles/stream.pyx":480
+ *                     self._buffer_size = 0
+ *                     self._buffer.clear()
+ *                     if not self._closing:             # <<<<<<<<<<<<<<
+ *                         # This should never happen.
+ *                         raise RuntimeError(
+ */
+        __pyx_t_4 = ((!(__pyx_v_self->__pyx_base._closing != 0)) != 0);
+        if (unlikely(__pyx_t_4)) {
+
+          /* "uvloop/handles/stream.pyx":482
+ *                     if not self._closing:
+ *                         # This should never happen.
+ *                         raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                             'stream is open after UVStream._try_write '
+ *                             'returned None')
+ */
+          __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__150, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 482, __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(18, 482, __pyx_L1_error)
+
+          /* "uvloop/handles/stream.pyx":480
+ *                     self._buffer_size = 0
+ *                     self._buffer.clear()
+ *                     if not self._closing:             # <<<<<<<<<<<<<<
+ *                         # This should never happen.
+ *                         raise RuntimeError(
+ */
+        }
+
+        /* "uvloop/handles/stream.pyx":485
+ *                             'stream is open after UVStream._try_write '
+ *                             'returned None')
+ *                     return             # <<<<<<<<<<<<<<
+ * 
+ *                 if sent == 0:
+ */
+        __Pyx_XDECREF(__pyx_r);
+        __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+        goto __pyx_L0;
+
+        /* "uvloop/handles/stream.pyx":474
+ *                 sent = self._try_write(data)
+ * 
+ *                 if sent is None:             # <<<<<<<<<<<<<<
+ *                     # A `self._fatal_error` was called.
+ *                     # It might not raise an exception under some
+ */
+      }
+
+      /* "uvloop/handles/stream.pyx":487
+ *                     return
+ * 
+ *                 if sent == 0:             # <<<<<<<<<<<<<<
+ *                     # All data was successfully written.
+ *                     self._buffer_size = 0
+ */
+      __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_v_sent, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 487, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(18, 487, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      if (__pyx_t_4) {
+
+        /* "uvloop/handles/stream.pyx":489
+ *                 if sent == 0:
+ *                     # All data was successfully written.
+ *                     self._buffer_size = 0             # <<<<<<<<<<<<<<
+ *                     self._buffer.clear()
+ *                     # on_write will call "maybe_resume_protocol".
+ */
+        __pyx_v_self->_buffer_size = 0;
+
+        /* "uvloop/handles/stream.pyx":490
+ *                     # All data was successfully written.
+ *                     self._buffer_size = 0
+ *                     self._buffer.clear()             # <<<<<<<<<<<<<<
+ *                     # on_write will call "maybe_resume_protocol".
+ *                     self._on_write()
+ */
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_buffer, __pyx_n_s_clear); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 490, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __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_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_5, function);
+          }
+        }
+        __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(18, 490, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/handles/stream.pyx":492
+ *                     self._buffer.clear()
+ *                     # on_write will call "maybe_resume_protocol".
+ *                     self._on_write()             # <<<<<<<<<<<<<<
+ *                     return True
+ * 
+ */
+        __pyx_t_2 = __pyx_f_6uvloop_4loop_8UVStream__on_write(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 492, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/handles/stream.pyx":493
+ *                     # on_write will call "maybe_resume_protocol".
+ *                     self._on_write()
+ *                     return True             # <<<<<<<<<<<<<<
+ * 
+ *                 if sent > 0:
+ */
+        __Pyx_XDECREF(__pyx_r);
+        __Pyx_INCREF(Py_True);
+        __pyx_r = Py_True;
+        goto __pyx_L0;
+
+        /* "uvloop/handles/stream.pyx":487
+ *                     return
+ * 
+ *                 if sent == 0:             # <<<<<<<<<<<<<<
+ *                     # All data was successfully written.
+ *                     self._buffer_size = 0
+ */
+      }
+
+      /* "uvloop/handles/stream.pyx":495
+ *                     return True
+ * 
+ *                 if sent > 0:             # <<<<<<<<<<<<<<
+ *                     if UVLOOP_DEBUG:
+ *                         if sent == len(data):
+ */
+      __pyx_t_2 = PyObject_RichCompare(__pyx_v_sent, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 495, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(18, 495, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      if (__pyx_t_4) {
+
+        /* "uvloop/handles/stream.pyx":496
+ * 
+ *                 if sent > 0:
+ *                     if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                         if sent == len(data):
+ *                             raise RuntimeError(
+ */
+        __pyx_t_4 = (UVLOOP_DEBUG != 0);
+        if (__pyx_t_4) {
+
+          /* "uvloop/handles/stream.pyx":497
+ *                 if sent > 0:
+ *                     if UVLOOP_DEBUG:
+ *                         if sent == len(data):             # <<<<<<<<<<<<<<
+ *                             raise RuntimeError(
+ *                                 '_try_write sent all data and returned '
+ */
+          __pyx_t_3 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(18, 497, __pyx_L1_error)
+          __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 497, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __pyx_t_5 = PyObject_RichCompare(__pyx_v_sent, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 497, __pyx_L1_error)
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(18, 497, __pyx_L1_error)
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+          if (unlikely(__pyx_t_4)) {
+
+            /* "uvloop/handles/stream.pyx":498
+ *                     if UVLOOP_DEBUG:
+ *                         if sent == len(data):
+ *                             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                                 '_try_write sent all data and returned '
+ *                                 'non-zero')
+ */
+            __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__151, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 498, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+            __PYX_ERR(18, 498, __pyx_L1_error)
+
+            /* "uvloop/handles/stream.pyx":497
+ *                 if sent > 0:
+ *                     if UVLOOP_DEBUG:
+ *                         if sent == len(data):             # <<<<<<<<<<<<<<
+ *                             raise RuntimeError(
+ *                                 '_try_write sent all data and returned '
+ */
+          }
+
+          /* "uvloop/handles/stream.pyx":496
+ * 
+ *                 if sent > 0:
+ *                     if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                         if sent == len(data):
+ *                             raise RuntimeError(
+ */
+        }
+
+        /* "uvloop/handles/stream.pyx":502
+ *                                 'non-zero')
+ * 
+ *                     if PyBytes_CheckExact(data):             # <<<<<<<<<<<<<<
+ *                         # Cast bytes to memoryview to avoid copying
+ *                         # data that wasn't sent.
+ */
+        __pyx_t_4 = (PyBytes_CheckExact(__pyx_v_data) != 0);
+        if (__pyx_t_4) {
+
+          /* "uvloop/handles/stream.pyx":505
+ *                         # Cast bytes to memoryview to avoid copying
+ *                         # data that wasn't sent.
+ *                         data = memoryview(data)             # <<<<<<<<<<<<<<
+ *                     data = data[sent:]
+ * 
+ */
+          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 505, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_data); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 505, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_DECREF_SET(__pyx_v_data, __pyx_t_2);
+          __pyx_t_2 = 0;
+
+          /* "uvloop/handles/stream.pyx":502
+ *                                 'non-zero')
+ * 
+ *                     if PyBytes_CheckExact(data):             # <<<<<<<<<<<<<<
+ *                         # Cast bytes to memoryview to avoid copying
+ *                         # data that wasn't sent.
+ */
+        }
+
+        /* "uvloop/handles/stream.pyx":506
+ *                         # data that wasn't sent.
+ *                         data = memoryview(data)
+ *                     data = data[sent:]             # <<<<<<<<<<<<<<
+ * 
+ *                     self._buffer_size -= sent
+ */
+        __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_data, 0, 0, &__pyx_v_sent, NULL, NULL, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 506, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF_SET(__pyx_v_data, __pyx_t_2);
+        __pyx_t_2 = 0;
+
+        /* "uvloop/handles/stream.pyx":508
+ *                     data = data[sent:]
+ * 
+ *                     self._buffer_size -= sent             # <<<<<<<<<<<<<<
+ *                     self._buffer[0] = data
+ * 
+ */
+        __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_v_self->_buffer_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 508, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_5 = PyNumber_InPlaceSubtract(__pyx_t_2, __pyx_v_sent); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 508, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_5); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(18, 508, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __pyx_v_self->_buffer_size = __pyx_t_7;
+
+        /* "uvloop/handles/stream.pyx":509
+ * 
+ *                     self._buffer_size -= sent
+ *                     self._buffer[0] = data             # <<<<<<<<<<<<<<
+ * 
+ *                 # At this point it's either data was sent partially,
+ */
+        if (unlikely(__pyx_v_self->_buffer == Py_None)) {
+          PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+          __PYX_ERR(18, 509, __pyx_L1_error)
+        }
+        if (unlikely(__Pyx_SetItemInt(__pyx_v_self->_buffer, 0, __pyx_v_data, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(18, 509, __pyx_L1_error)
+
+        /* "uvloop/handles/stream.pyx":495
+ *                     return True
+ * 
+ *                 if sent > 0:             # <<<<<<<<<<<<<<
+ *                     if UVLOOP_DEBUG:
+ *                         if sent == len(data):
+ */
+      }
+
+      /* "uvloop/handles/stream.pyx":468
+ *         if (<uv.uv_stream_t*>self._handle).write_queue_size == 0:
+ *             # libuv internal write buffers for this stream are empty.
+ *             if buf_len == 1:             # <<<<<<<<<<<<<<
+ *                 # If we only have one piece of data to send, let's
+ *                 # use our fast implementation of try_write.
+ */
+      goto __pyx_L6;
+    }
+
+    /* "uvloop/handles/stream.pyx":515
+ * 
+ *             else:
+ *                 ctx = _StreamWriteContext.new(self, self._buffer)             # <<<<<<<<<<<<<<
+ * 
+ *                 err = uv.uv_try_write(<uv.uv_stream_t*>self._handle,
+ */
+    /*else*/ {
+      __pyx_t_5 = __pyx_v_self->_buffer;
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_t_2 = ((PyObject *)__pyx_f_6uvloop_4loop_19_StreamWriteContext_new(__pyx_v_self, ((PyObject*)__pyx_t_5))); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 515, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF_SET(__pyx_v_ctx, ((struct __pyx_obj_6uvloop_4loop__StreamWriteContext *)__pyx_t_2));
+      __pyx_t_2 = 0;
+
+      /* "uvloop/handles/stream.pyx":517
+ *                 ctx = _StreamWriteContext.new(self, self._buffer)
+ * 
+ *                 err = uv.uv_try_write(<uv.uv_stream_t*>self._handle,             # <<<<<<<<<<<<<<
+ *                                       ctx.uv_bufs_start,
+ *                                       ctx.uv_bufs_len)
+ */
+      __pyx_v_err = uv_try_write(((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_v_ctx->uv_bufs_start, __pyx_v_ctx->uv_bufs_len);
+
+      /* "uvloop/handles/stream.pyx":521
+ *                                       ctx.uv_bufs_len)
+ * 
+ *                 if err > 0:             # <<<<<<<<<<<<<<
+ *                     # Some data was successfully sent.
+ * 
+ */
+      __pyx_t_4 = ((__pyx_v_err > 0) != 0);
+      if (__pyx_t_4) {
+
+        /* "uvloop/handles/stream.pyx":524
+ *                     # Some data was successfully sent.
+ * 
+ *                     if <size_t>err == self._buffer_size:             # <<<<<<<<<<<<<<
+ *                         # Everything was sent.
+ *                         ctx.close()
+ */
+        __pyx_t_4 = ((((size_t)__pyx_v_err) == __pyx_v_self->_buffer_size) != 0);
+        if (__pyx_t_4) {
+
+          /* "uvloop/handles/stream.pyx":526
+ *                     if <size_t>err == self._buffer_size:
+ *                         # Everything was sent.
+ *                         ctx.close()             # <<<<<<<<<<<<<<
+ *                         self._buffer.clear()
+ *                         self._buffer_size = 0
+ */
+          __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *)__pyx_v_ctx->__pyx_vtab)->close(__pyx_v_ctx); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 526, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+          /* "uvloop/handles/stream.pyx":527
+ *                         # Everything was sent.
+ *                         ctx.close()
+ *                         self._buffer.clear()             # <<<<<<<<<<<<<<
+ *                         self._buffer_size = 0
+ *                         # on_write will call "maybe_resume_protocol".
+ */
+          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_buffer, __pyx_n_s_clear); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 527, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __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_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_5, function);
+            }
+          }
+          __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(18, 527, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+          /* "uvloop/handles/stream.pyx":528
+ *                         ctx.close()
+ *                         self._buffer.clear()
+ *                         self._buffer_size = 0             # <<<<<<<<<<<<<<
+ *                         # on_write will call "maybe_resume_protocol".
+ *                         self._on_write()
+ */
+          __pyx_v_self->_buffer_size = 0;
+
+          /* "uvloop/handles/stream.pyx":530
+ *                         self._buffer_size = 0
+ *                         # on_write will call "maybe_resume_protocol".
+ *                         self._on_write()             # <<<<<<<<<<<<<<
+ *                         return True
+ * 
+ */
+          __pyx_t_2 = __pyx_f_6uvloop_4loop_8UVStream__on_write(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 530, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+          /* "uvloop/handles/stream.pyx":531
+ *                         # on_write will call "maybe_resume_protocol".
+ *                         self._on_write()
+ *                         return True             # <<<<<<<<<<<<<<
+ * 
+ *                     try:
+ */
+          __Pyx_XDECREF(__pyx_r);
+          __Pyx_INCREF(Py_True);
+          __pyx_r = Py_True;
+          goto __pyx_L0;
+
+          /* "uvloop/handles/stream.pyx":524
+ *                     # Some data was successfully sent.
+ * 
+ *                     if <size_t>err == self._buffer_size:             # <<<<<<<<<<<<<<
+ *                         # Everything was sent.
+ *                         ctx.close()
+ */
+        }
+
+        /* "uvloop/handles/stream.pyx":533
+ *                         return True
+ * 
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         # Advance pointers to uv_bufs in `ctx`,
+ *                         # we will reuse it soon for a uv_write
+ */
+        {
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+          __Pyx_XGOTREF(__pyx_t_8);
+          __Pyx_XGOTREF(__pyx_t_9);
+          __Pyx_XGOTREF(__pyx_t_10);
+          /*try:*/ {
+
+            /* "uvloop/handles/stream.pyx":537
+ *                         # we will reuse it soon for a uv_write
+ *                         # call.
+ *                         ctx.advance_uv_buf(<ssize_t>err)             # <<<<<<<<<<<<<<
+ *                     except Exception as ex:  # This should never happen.
+ *                         # Let's try to close the `ctx` anyways.
+ */
+            __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *)__pyx_v_ctx->__pyx_vtab)->advance_uv_buf(__pyx_v_ctx, ((Py_ssize_t)__pyx_v_err)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 537, __pyx_L16_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+            /* "uvloop/handles/stream.pyx":533
+ *                         return True
+ * 
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         # Advance pointers to uv_bufs in `ctx`,
+ *                         # we will reuse it soon for a uv_write
+ */
+          }
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          goto __pyx_L21_try_end;
+          __pyx_L16_error:;
+          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+          /* "uvloop/handles/stream.pyx":538
+ *                         # call.
+ *                         ctx.advance_uv_buf(<ssize_t>err)
+ *                     except Exception as ex:  # This should never happen.             # <<<<<<<<<<<<<<
+ *                         # Let's try to close the `ctx` anyways.
+ *                         ctx.close()
+ */
+          __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+          if (__pyx_t_11) {
+            __Pyx_AddTraceback("uvloop.loop.UVStream._exec_write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+            if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(18, 538, __pyx_L18_except_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_GOTREF(__pyx_t_6);
+            __Pyx_INCREF(__pyx_t_5);
+            __pyx_v_ex = __pyx_t_5;
+            /*try:*/ {
+
+              /* "uvloop/handles/stream.pyx":540
+ *                     except Exception as ex:  # This should never happen.
+ *                         # Let's try to close the `ctx` anyways.
+ *                         ctx.close()             # <<<<<<<<<<<<<<
+ *                         self._fatal_error(ex, True)
+ *                         self._buffer.clear()
+ */
+              __pyx_t_12 = ((struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *)__pyx_v_ctx->__pyx_vtab)->close(__pyx_v_ctx); if (unlikely(!__pyx_t_12)) __PYX_ERR(18, 540, __pyx_L27_error)
+              __Pyx_GOTREF(__pyx_t_12);
+              __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+
+              /* "uvloop/handles/stream.pyx":541
+ *                         # Let's try to close the `ctx` anyways.
+ *                         ctx.close()
+ *                         self._fatal_error(ex, True)             # <<<<<<<<<<<<<<
+ *                         self._buffer.clear()
+ *                         self._buffer_size = 0
+ */
+              __pyx_t_12 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_ex, Py_True, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(18, 541, __pyx_L27_error)
+              __Pyx_GOTREF(__pyx_t_12);
+              __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+
+              /* "uvloop/handles/stream.pyx":542
+ *                         ctx.close()
+ *                         self._fatal_error(ex, True)
+ *                         self._buffer.clear()             # <<<<<<<<<<<<<<
+ *                         self._buffer_size = 0
+ *                         return
+ */
+              __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_buffer, __pyx_n_s_clear); if (unlikely(!__pyx_t_13)) __PYX_ERR(18, 542, __pyx_L27_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __pyx_t_14 = NULL;
+              if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) {
+                __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13);
+                if (likely(__pyx_t_14)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+                  __Pyx_INCREF(__pyx_t_14);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_13, function);
+                }
+              }
+              __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_14) : __Pyx_PyObject_CallNoArg(__pyx_t_13);
+              __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+              if (unlikely(!__pyx_t_12)) __PYX_ERR(18, 542, __pyx_L27_error)
+              __Pyx_GOTREF(__pyx_t_12);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+
+              /* "uvloop/handles/stream.pyx":543
+ *                         self._fatal_error(ex, True)
+ *                         self._buffer.clear()
+ *                         self._buffer_size = 0             # <<<<<<<<<<<<<<
+ *                         return
+ * 
+ */
+              __pyx_v_self->_buffer_size = 0;
+
+              /* "uvloop/handles/stream.pyx":544
+ *                         self._buffer.clear()
+ *                         self._buffer_size = 0
+ *                         return             # <<<<<<<<<<<<<<
+ * 
+ *                 elif err != uv.UV_EAGAIN:
+ */
+              __Pyx_XDECREF(__pyx_r);
+              __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+              goto __pyx_L26_return;
+            }
+
+            /* "uvloop/handles/stream.pyx":538
+ *                         # call.
+ *                         ctx.advance_uv_buf(<ssize_t>err)
+ *                     except Exception as ex:  # This should never happen.             # <<<<<<<<<<<<<<
+ *                         # Let's try to close the `ctx` anyways.
+ *                         ctx.close()
+ */
+            /*finally:*/ {
+              __pyx_L27_error:;
+              /*exception exit:*/{
+                __Pyx_PyThreadState_declare
+                __Pyx_PyThreadState_assign
+                __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+                __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+                __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+                if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
+                if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+                __Pyx_XGOTREF(__pyx_t_17);
+                __Pyx_XGOTREF(__pyx_t_18);
+                __Pyx_XGOTREF(__pyx_t_19);
+                __Pyx_XGOTREF(__pyx_t_20);
+                __Pyx_XGOTREF(__pyx_t_21);
+                __Pyx_XGOTREF(__pyx_t_22);
+                __pyx_t_11 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename;
+                {
+                  __Pyx_DECREF(__pyx_v_ex);
+                  __pyx_v_ex = NULL;
+                }
+                if (PY_MAJOR_VERSION >= 3) {
+                  __Pyx_XGIVEREF(__pyx_t_20);
+                  __Pyx_XGIVEREF(__pyx_t_21);
+                  __Pyx_XGIVEREF(__pyx_t_22);
+                  __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
+                }
+                __Pyx_XGIVEREF(__pyx_t_17);
+                __Pyx_XGIVEREF(__pyx_t_18);
+                __Pyx_XGIVEREF(__pyx_t_19);
+                __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+                __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+                __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16;
+                goto __pyx_L18_except_error;
+              }
+              __pyx_L26_return: {
+                __pyx_t_22 = __pyx_r;
+                __pyx_r = 0;
+                __Pyx_DECREF(__pyx_v_ex);
+                __pyx_v_ex = NULL;
+                __pyx_r = __pyx_t_22;
+                __pyx_t_22 = 0;
+                goto __pyx_L19_except_return;
+              }
+            }
+          }
+          goto __pyx_L18_except_error;
+          __pyx_L18_except_error:;
+
+          /* "uvloop/handles/stream.pyx":533
+ *                         return True
+ * 
+ *                     try:             # <<<<<<<<<<<<<<
+ *                         # Advance pointers to uv_bufs in `ctx`,
+ *                         # we will reuse it soon for a uv_write
+ */
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __Pyx_XGIVEREF(__pyx_t_10);
+          __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+          goto __pyx_L1_error;
+          __pyx_L19_except_return:;
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __Pyx_XGIVEREF(__pyx_t_10);
+          __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+          goto __pyx_L0;
+          __pyx_L21_try_end:;
+        }
+
+        /* "uvloop/handles/stream.pyx":521
+ *                                       ctx.uv_bufs_len)
+ * 
+ *                 if err > 0:             # <<<<<<<<<<<<<<
+ *                     # Some data was successfully sent.
+ * 
+ */
+        goto __pyx_L14;
+      }
+
+      /* "uvloop/handles/stream.pyx":546
+ *                         return
+ * 
+ *                 elif err != uv.UV_EAGAIN:             # <<<<<<<<<<<<<<
+ *                     ctx.close()
+ *                     exc = convert_error(err)
+ */
+      __pyx_t_4 = ((__pyx_v_err != UV_EAGAIN) != 0);
+      if (__pyx_t_4) {
+
+        /* "uvloop/handles/stream.pyx":547
+ * 
+ *                 elif err != uv.UV_EAGAIN:
+ *                     ctx.close()             # <<<<<<<<<<<<<<
+ *                     exc = convert_error(err)
+ *                     self._fatal_error(exc, True)
+ */
+        __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *)__pyx_v_ctx->__pyx_vtab)->close(__pyx_v_ctx); if (unlikely(!__pyx_t_6)) __PYX_ERR(18, 547, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+        /* "uvloop/handles/stream.pyx":548
+ *                 elif err != uv.UV_EAGAIN:
+ *                     ctx.close()
+ *                     exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *                     self._fatal_error(exc, True)
+ *                     self._buffer.clear()
+ */
+        __pyx_t_6 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_6)) __PYX_ERR(18, 548, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __pyx_v_exc = __pyx_t_6;
+        __pyx_t_6 = 0;
+
+        /* "uvloop/handles/stream.pyx":549
+ *                     ctx.close()
+ *                     exc = convert_error(err)
+ *                     self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *                     self._buffer.clear()
+ *                     self._buffer_size = 0
+ */
+        __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(18, 549, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+        /* "uvloop/handles/stream.pyx":550
+ *                     exc = convert_error(err)
+ *                     self._fatal_error(exc, True)
+ *                     self._buffer.clear()             # <<<<<<<<<<<<<<
+ *                     self._buffer_size = 0
+ *                     return
+ */
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_buffer, __pyx_n_s_clear); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 550, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_2 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+          __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
+          if (likely(__pyx_t_2)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+            __Pyx_INCREF(__pyx_t_2);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_5, function);
+          }
+        }
+        __pyx_t_6 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_5);
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        if (unlikely(!__pyx_t_6)) __PYX_ERR(18, 550, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+        /* "uvloop/handles/stream.pyx":551
+ *                     self._fatal_error(exc, True)
+ *                     self._buffer.clear()
+ *                     self._buffer_size = 0             # <<<<<<<<<<<<<<
+ *                     return
+ * 
+ */
+        __pyx_v_self->_buffer_size = 0;
+
+        /* "uvloop/handles/stream.pyx":552
+ *                     self._buffer.clear()
+ *                     self._buffer_size = 0
+ *                     return             # <<<<<<<<<<<<<<
+ * 
+ *                 # fall through
+ */
+        __Pyx_XDECREF(__pyx_r);
+        __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+        goto __pyx_L0;
+
+        /* "uvloop/handles/stream.pyx":546
+ *                         return
+ * 
+ *                 elif err != uv.UV_EAGAIN:             # <<<<<<<<<<<<<<
+ *                     ctx.close()
+ *                     exc = convert_error(err)
+ */
+      }
+      __pyx_L14:;
+    }
+    __pyx_L6:;
+
+    /* "uvloop/handles/stream.pyx":466
+ *             return
+ * 
+ *         if (<uv.uv_stream_t*>self._handle).write_queue_size == 0:             # <<<<<<<<<<<<<<
+ *             # libuv internal write buffers for this stream are empty.
+ *             if buf_len == 1:
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":556
+ *                 # fall through
+ * 
+ *         if ctx is None:             # <<<<<<<<<<<<<<
+ *             ctx = _StreamWriteContext.new(self, self._buffer)
+ * 
+ */
+  __pyx_t_4 = (((PyObject *)__pyx_v_ctx) == Py_None);
+  __pyx_t_1 = (__pyx_t_4 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":557
+ * 
+ *         if ctx is None:
+ *             ctx = _StreamWriteContext.new(self, self._buffer)             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_write(&ctx.req,
+ */
+    __pyx_t_6 = __pyx_v_self->_buffer;
+    __Pyx_INCREF(__pyx_t_6);
+    __pyx_t_5 = ((PyObject *)__pyx_f_6uvloop_4loop_19_StreamWriteContext_new(__pyx_v_self, ((PyObject*)__pyx_t_6))); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 557, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF_SET(__pyx_v_ctx, ((struct __pyx_obj_6uvloop_4loop__StreamWriteContext *)__pyx_t_5));
+    __pyx_t_5 = 0;
+
+    /* "uvloop/handles/stream.pyx":556
+ *                 # fall through
+ * 
+ *         if ctx is None:             # <<<<<<<<<<<<<<
+ *             ctx = _StreamWriteContext.new(self, self._buffer)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":559
+ *             ctx = _StreamWriteContext.new(self, self._buffer)
+ * 
+ *         err = uv.uv_write(&ctx.req,             # <<<<<<<<<<<<<<
+ *                           <uv.uv_stream_t*>self._handle,
+ *                           ctx.uv_bufs_start,
+ */
+  __pyx_v_err = uv_write((&__pyx_v_ctx->req), ((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_v_ctx->uv_bufs_start, __pyx_v_ctx->uv_bufs_len, __pyx_f_6uvloop_4loop___uv_stream_on_write);
+
+  /* "uvloop/handles/stream.pyx":565
+ *                           __uv_stream_on_write)
+ * 
+ *         self._buffer_size = 0             # <<<<<<<<<<<<<<
+ *         # Can't use `_buffer.clear()` here: `ctx` holds a reference to
+ *         # the `_buffer`.
+ */
+  __pyx_v_self->_buffer_size = 0;
+
+  /* "uvloop/handles/stream.pyx":568
+ *         # Can't use `_buffer.clear()` here: `ctx` holds a reference to
+ *         # the `_buffer`.
+ *         self._buffer = []             # <<<<<<<<<<<<<<
+ * 
+ *         if err < 0:
+ */
+  __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 568, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __Pyx_GOTREF(__pyx_v_self->_buffer);
+  __Pyx_DECREF(__pyx_v_self->_buffer);
+  __pyx_v_self->_buffer = ((PyObject*)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/handles/stream.pyx":570
+ *         self._buffer = []
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             # close write context
+ *             ctx.close()
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":572
+ *         if err < 0:
+ *             # close write context
+ *             ctx.close()             # <<<<<<<<<<<<<<
+ * 
+ *             exc = convert_error(err)
+ */
+    __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *)__pyx_v_ctx->__pyx_vtab)->close(__pyx_v_ctx); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 572, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/handles/stream.pyx":574
+ *             ctx.close()
+ * 
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_5 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 574, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_v_exc = __pyx_t_5;
+    __pyx_t_5 = 0;
+
+    /* "uvloop/handles/stream.pyx":575
+ * 
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 575, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/handles/stream.pyx":576
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._maybe_resume_protocol()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":570
+ *         self._buffer = []
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             # close write context
+ *             ctx.close()
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":578
+ *             return
+ * 
+ *         self._maybe_resume_protocol()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef size_t _get_write_buffer_size(self):
+ */
+  __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._maybe_resume_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 578, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/handles/stream.pyx":451
+ *         self._loop._queue_write(self)
+ * 
+ *     cdef inline _exec_write(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int err
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._exec_write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_ctx);
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XDECREF(__pyx_v_sent);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":580
+ *         self._maybe_resume_protocol()
+ * 
+ *     cdef size_t _get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         if self._handle is NULL:
+ *             return 0
+ */
+
+static size_t __pyx_f_6uvloop_4loop_8UVStream__get_write_buffer_size(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  size_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("_get_write_buffer_size", 0);
+
+  /* "uvloop/handles/stream.pyx":581
+ * 
+ *     cdef size_t _get_write_buffer_size(self):
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             return 0
+ *         return ((<uv.uv_stream_t*>self._handle).write_queue_size +
+ */
+  __pyx_t_1 = ((__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":582
+ *     cdef size_t _get_write_buffer_size(self):
+ *         if self._handle is NULL:
+ *             return 0             # <<<<<<<<<<<<<<
+ *         return ((<uv.uv_stream_t*>self._handle).write_queue_size +
+ *                 self._buffer_size)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":581
+ * 
+ *     cdef size_t _get_write_buffer_size(self):
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             return 0
+ *         return ((<uv.uv_stream_t*>self._handle).write_queue_size +
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":583
+ *         if self._handle is NULL:
+ *             return 0
+ *         return ((<uv.uv_stream_t*>self._handle).write_queue_size +             # <<<<<<<<<<<<<<
+ *                 self._buffer_size)
+ * 
+ */
+  __pyx_r = (((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle)->write_queue_size + __pyx_v_self->_buffer_size);
+  goto __pyx_L0;
+
+  /* "uvloop/handles/stream.pyx":580
+ *         self._maybe_resume_protocol()
+ * 
+ *     cdef size_t _get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         if self._handle is NULL:
+ *             return 0
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":586
+ *                 self._buffer_size)
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         try:
+ *             if self._read_pybuf_acquired:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8UVStream__close(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __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;
+  int __pyx_t_7;
+  char const *__pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_close", 0);
+
+  /* "uvloop/handles/stream.pyx":587
+ * 
+ *     cdef _close(self):
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self._read_pybuf_acquired:
+ *                 # Should never happen. libuv always calls uv_alloc/uv_read
+ */
+  /*try:*/ {
+
+    /* "uvloop/handles/stream.pyx":588
+ *     cdef _close(self):
+ *         try:
+ *             if self._read_pybuf_acquired:             # <<<<<<<<<<<<<<
+ *                 # Should never happen. libuv always calls uv_alloc/uv_read
+ *                 # in pairs.
+ */
+    __pyx_t_1 = (__pyx_v_self->_read_pybuf_acquired != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":591
+ *                 # Should never happen. libuv always calls uv_alloc/uv_read
+ *                 # in pairs.
+ *                 self._loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *                     'transport': self,
+ *                     'message': 'XXX: an allocated buffer in transport._close()'
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 591, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_3);
+
+      /* "uvloop/handles/stream.pyx":592
+ *                 # in pairs.
+ *                 self._loop.call_exception_handler({
+ *                     'transport': self,             # <<<<<<<<<<<<<<
+ *                     'message': 'XXX: an allocated buffer in transport._close()'
+ *                 })
+ */
+      __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 592, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (PyDict_SetItem(__pyx_t_4, __pyx_n_u_transport, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(18, 592, __pyx_L4_error)
+      if (PyDict_SetItem(__pyx_t_4, __pyx_n_u_message, __pyx_kp_u_XXX_an_allocated_buffer_in_trans) < 0) __PYX_ERR(18, 592, __pyx_L4_error)
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3, function);
+        }
+      }
+      __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(18, 591, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/stream.pyx":595
+ *                     'message': 'XXX: an allocated buffer in transport._close()'
+ *                 })
+ *                 self._read_pybuf_acquired = 0             # <<<<<<<<<<<<<<
+ *                 PyBuffer_Release(&self._read_pybuf)
+ * 
+ */
+      __pyx_v_self->_read_pybuf_acquired = 0;
+
+      /* "uvloop/handles/stream.pyx":596
+ *                 })
+ *                 self._read_pybuf_acquired = 0
+ *                 PyBuffer_Release(&self._read_pybuf)             # <<<<<<<<<<<<<<
+ * 
+ *             self._stop_reading()
+ */
+      PyBuffer_Release((&__pyx_v_self->_read_pybuf));
+
+      /* "uvloop/handles/stream.pyx":588
+ *     cdef _close(self):
+ *         try:
+ *             if self._read_pybuf_acquired:             # <<<<<<<<<<<<<<
+ *                 # Should never happen. libuv always calls uv_alloc/uv_read
+ *                 # in pairs.
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":598
+ *                 PyBuffer_Release(&self._read_pybuf)
+ * 
+ *             self._stop_reading()             # <<<<<<<<<<<<<<
+ *         finally:
+ *             UVSocketHandle._close(<UVHandle>self)
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._stop_reading(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 598, __pyx_L4_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+
+  /* "uvloop/handles/stream.pyx":600
+ *             self._stop_reading()
+ *         finally:
+ *             UVSocketHandle._close(<UVHandle>self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _on_accept(self):
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      if (!(likely(((((PyObject *)__pyx_v_self)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_self), __pyx_ptype_6uvloop_4loop_UVSocketHandle))))) __PYX_ERR(18, 600, __pyx_L1_error)
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_14UVSocketHandle__close(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self))); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 600, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      goto __pyx_L5;
+    }
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __pyx_t_6 = __pyx_lineno; __pyx_t_7 = __pyx_clineno; __pyx_t_8 = __pyx_filename;
+      {
+        if (!(likely(((((PyObject *)__pyx_v_self)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_self), __pyx_ptype_6uvloop_4loop_UVSocketHandle))))) __PYX_ERR(18, 600, __pyx_L8_error)
+        __pyx_t_2 = __pyx_f_6uvloop_4loop_14UVSocketHandle__close(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self))); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 600, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __Pyx_ErrRestore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_7; __pyx_filename = __pyx_t_8;
+      goto __pyx_L1_error;
+      __pyx_L8_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L5:;
+  }
+
+  /* "uvloop/handles/stream.pyx":586
+ *                 self._buffer_size)
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         try:
+ *             if self._read_pybuf_acquired:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":602
+ *             UVSocketHandle._close(<UVHandle>self)
+ * 
+ *     cdef inline _on_accept(self):             # <<<<<<<<<<<<<<
+ *         # Ultimately called by __uv_stream_on_listen.
+ *         self._init_protocol()
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_accept(struct __pyx_obj_6uvloop_4loop_UVStream *__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("_on_accept", 0);
+
+  /* "uvloop/handles/stream.pyx":604
+ *     cdef inline _on_accept(self):
+ *         # Ultimately called by __uv_stream_on_listen.
+ *         self._init_protocol()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _on_eof(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 604, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":602
+ *             UVSocketHandle._close(<UVHandle>self)
+ * 
+ *     cdef inline _on_accept(self):             # <<<<<<<<<<<<<<
+ *         # Ultimately called by __uv_stream_on_listen.
+ *         self._init_protocol()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._on_accept", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":606
+ *         self._init_protocol()
+ * 
+ *     cdef inline _on_eof(self):             # <<<<<<<<<<<<<<
+ *         # Any exception raised here will be caught in
+ *         # __uv_stream_on_read.
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_eof(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  PyObject *__pyx_v_meth = NULL;
+  PyObject *__pyx_v_keep_open = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_eof", 0);
+
+  /* "uvloop/handles/stream.pyx":610
+ *         # __uv_stream_on_read.
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             meth = self._protocol.eof_received
+ *         except AttributeError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/handles/stream.pyx":611
+ * 
+ *         try:
+ *             meth = self._protocol.eof_received             # <<<<<<<<<<<<<<
+ *         except AttributeError:
+ *             keep_open = False
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base._protocol, __pyx_n_s_eof_received); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 611, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_v_meth = __pyx_t_4;
+      __pyx_t_4 = 0;
+
+      /* "uvloop/handles/stream.pyx":610
+ *         # __uv_stream_on_read.
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             meth = self._protocol.eof_received
+ *         except AttributeError:
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":615
+ *             keep_open = False
+ *         else:
+ *             keep_open = run_in_context(self.context, meth)             # <<<<<<<<<<<<<<
+ * 
+ *         if keep_open:
+ */
+    /*else:*/ {
+      __pyx_t_4 = __pyx_v_self->__pyx_base.__pyx_base.__pyx_base.context;
+      __Pyx_INCREF(__pyx_t_4);
+      __pyx_t_5 = __pyx_f_6uvloop_4loop_run_in_context(__pyx_t_4, __pyx_v_meth); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 615, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_v_keep_open = __pyx_t_5;
+      __pyx_t_5 = 0;
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/handles/stream.pyx":612
+ *         try:
+ *             meth = self._protocol.eof_received
+ *         except AttributeError:             # <<<<<<<<<<<<<<
+ *             keep_open = False
+ *         else:
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("uvloop.loop.UVStream._on_eof", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(18, 612, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "uvloop/handles/stream.pyx":613
+ *             meth = self._protocol.eof_received
+ *         except AttributeError:
+ *             keep_open = False             # <<<<<<<<<<<<<<
+ *         else:
+ *             keep_open = run_in_context(self.context, meth)
+ */
+      __Pyx_INCREF(Py_False);
+      __pyx_v_keep_open = Py_False;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/handles/stream.pyx":610
+ *         # __uv_stream_on_read.
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             meth = self._protocol.eof_received
+ *         except AttributeError:
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/handles/stream.pyx":617
+ *             keep_open = run_in_context(self.context, meth)
+ * 
+ *         if keep_open:             # <<<<<<<<<<<<<<
+ *             # We're keeping the connection open so the
+ *             # protocol can write more, but we still can't
+ */
+  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_keep_open); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(18, 617, __pyx_L1_error)
+  if (__pyx_t_8) {
+
+    /* "uvloop/handles/stream.pyx":621
+ *             # protocol can write more, but we still can't
+ *             # receive more, so remove the reader callback.
+ *             self._stop_reading()             # <<<<<<<<<<<<<<
+ *         else:
+ *             self.close()
+ */
+    __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._stop_reading(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_7)) __PYX_ERR(18, 621, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/handles/stream.pyx":617
+ *             keep_open = run_in_context(self.context, meth)
+ * 
+ *         if keep_open:             # <<<<<<<<<<<<<<
+ *             # We're keeping the connection open so the
+ *             # protocol can write more, but we still can't
+ */
+    goto __pyx_L11;
+  }
+
+  /* "uvloop/handles/stream.pyx":623
+ *             self._stop_reading()
+ *         else:
+ *             self.close()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _on_write(self):
+ */
+  /*else*/ {
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 623, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_7 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_7)) __PYX_ERR(18, 623, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_L11:;
+
+  /* "uvloop/handles/stream.pyx":606
+ *         self._init_protocol()
+ * 
+ *     cdef inline _on_eof(self):             # <<<<<<<<<<<<<<
+ *         # Any exception raised here will be caught in
+ *         # __uv_stream_on_read.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._on_eof", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_meth);
+  __Pyx_XDECREF(__pyx_v_keep_open);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":625
+ *             self.close()
+ * 
+ *     cdef inline _on_write(self):             # <<<<<<<<<<<<<<
+ *         self._maybe_resume_protocol()
+ *         if not self._get_write_buffer_size():
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_write", 0);
+
+  /* "uvloop/handles/stream.pyx":626
+ * 
+ *     cdef inline _on_write(self):
+ *         self._maybe_resume_protocol()             # <<<<<<<<<<<<<<
+ *         if not self._get_write_buffer_size():
+ *             if self._closing:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._maybe_resume_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 626, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":627
+ *     cdef inline _on_write(self):
+ *         self._maybe_resume_protocol()
+ *         if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *             if self._closing:
+ *                 self._schedule_call_connection_lost(None)
+ */
+  __pyx_t_2 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._get_write_buffer_size(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)) != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/stream.pyx":628
+ *         self._maybe_resume_protocol()
+ *         if not self._get_write_buffer_size():
+ *             if self._closing:             # <<<<<<<<<<<<<<
+ *                 self._schedule_call_connection_lost(None)
+ *             elif self._eof:
+ */
+    __pyx_t_2 = (__pyx_v_self->__pyx_base._closing != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/handles/stream.pyx":629
+ *         if not self._get_write_buffer_size():
+ *             if self._closing:
+ *                 self._schedule_call_connection_lost(None)             # <<<<<<<<<<<<<<
+ *             elif self._eof:
+ *                 self._shutdown()
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._schedule_call_connection_lost(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self), Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 629, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/stream.pyx":628
+ *         self._maybe_resume_protocol()
+ *         if not self._get_write_buffer_size():
+ *             if self._closing:             # <<<<<<<<<<<<<<
+ *                 self._schedule_call_connection_lost(None)
+ *             elif self._eof:
+ */
+      goto __pyx_L4;
+    }
+
+    /* "uvloop/handles/stream.pyx":630
+ *             if self._closing:
+ *                 self._schedule_call_connection_lost(None)
+ *             elif self._eof:             # <<<<<<<<<<<<<<
+ *                 self._shutdown()
+ * 
+ */
+    __pyx_t_2 = (__pyx_v_self->_eof != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/handles/stream.pyx":631
+ *                 self._schedule_call_connection_lost(None)
+ *             elif self._eof:
+ *                 self._shutdown()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _init(self, Loop loop, object protocol, Server server,
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop_8UVStream__shutdown(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 631, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/stream.pyx":630
+ *             if self._closing:
+ *                 self._schedule_call_connection_lost(None)
+ *             elif self._eof:             # <<<<<<<<<<<<<<
+ *                 self._shutdown()
+ * 
+ */
+    }
+    __pyx_L4:;
+
+    /* "uvloop/handles/stream.pyx":627
+ *     cdef inline _on_write(self):
+ *         self._maybe_resume_protocol()
+ *         if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *             if self._closing:
+ *                 self._schedule_call_connection_lost(None)
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":625
+ *             self.close()
+ * 
+ *     cdef inline _on_write(self):             # <<<<<<<<<<<<<<
+ *         self._maybe_resume_protocol()
+ *         if not self._get_write_buffer_size():
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._on_write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":633
+ *                 self._shutdown()
+ * 
+ *     cdef inline _init(self, Loop loop, object protocol, Server server,             # <<<<<<<<<<<<<<
+ *                       object waiter, object context):
+ *         self.context = context
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__init(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter, PyObject *__pyx_v_context) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init", 0);
+
+  /* "uvloop/handles/stream.pyx":635
+ *     cdef inline _init(self, Loop loop, object protocol, Server server,
+ *                       object waiter, object context):
+ *         self.context = context             # <<<<<<<<<<<<<<
+ *         self._set_protocol(protocol)
+ *         self._start_init(loop)
+ */
+  __Pyx_INCREF(__pyx_v_context);
+  __Pyx_GIVEREF(__pyx_v_context);
+  __Pyx_GOTREF(__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.context);
+  __Pyx_DECREF(__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.context);
+  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base.context = __pyx_v_context;
+
+  /* "uvloop/handles/stream.pyx":636
+ *                       object waiter, object context):
+ *         self.context = context
+ *         self._set_protocol(protocol)             # <<<<<<<<<<<<<<
+ *         self._start_init(loop)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._set_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self), __pyx_v_protocol); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 636, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":637
+ *         self.context = context
+ *         self._set_protocol(protocol)
+ *         self._start_init(loop)             # <<<<<<<<<<<<<<
+ * 
+ *         if server is not None:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._start_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 637, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":639
+ *         self._start_init(loop)
+ * 
+ *         if server is not None:             # <<<<<<<<<<<<<<
+ *             self._set_server(server)
+ * 
+ */
+  __pyx_t_2 = (((PyObject *)__pyx_v_server) != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/stream.pyx":640
+ * 
+ *         if server is not None:
+ *             self._set_server(server)             # <<<<<<<<<<<<<<
+ * 
+ *         if waiter is not None:
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._set_server(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self), __pyx_v_server); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 640, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/stream.pyx":639
+ *         self._start_init(loop)
+ * 
+ *         if server is not None:             # <<<<<<<<<<<<<<
+ *             self._set_server(server)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":642
+ *             self._set_server(server)
+ * 
+ *         if waiter is not None:             # <<<<<<<<<<<<<<
+ *             self._set_waiter(waiter)
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_waiter != Py_None);
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/stream.pyx":643
+ * 
+ *         if waiter is not None:
+ *             self._set_waiter(waiter)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _on_connect(self, object exc):
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._set_waiter(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self), __pyx_v_waiter); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 643, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/stream.pyx":642
+ *             self._set_server(server)
+ * 
+ *         if waiter is not None:             # <<<<<<<<<<<<<<
+ *             self._set_waiter(waiter)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":633
+ *                 self._shutdown()
+ * 
+ *     cdef inline _init(self, Loop loop, object protocol, Server server,             # <<<<<<<<<<<<<<
+ *                       object waiter, object context):
+ *         self.context = context
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":645
+ *             self._set_waiter(waiter)
+ * 
+ *     cdef inline _on_connect(self, object exc):             # <<<<<<<<<<<<<<
+ *         # Called from __tcp_connect_callback (tcp.pyx) and
+ *         # __pipe_connect_callback (pipe.pyx).
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_connect(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_exc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_connect", 0);
+
+  /* "uvloop/handles/stream.pyx":648
+ *         # Called from __tcp_connect_callback (tcp.pyx) and
+ *         # __pipe_connect_callback (pipe.pyx).
+ *         if exc is None:             # <<<<<<<<<<<<<<
+ *             self._init_protocol()
+ *         else:
+ */
+  __pyx_t_1 = (__pyx_v_exc == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/stream.pyx":649
+ *         # __pipe_connect_callback (pipe.pyx).
+ *         if exc is None:
+ *             self._init_protocol()             # <<<<<<<<<<<<<<
+ *         else:
+ *             if self._waiter is None:
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 649, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/stream.pyx":648
+ *         # Called from __tcp_connect_callback (tcp.pyx) and
+ *         # __pipe_connect_callback (pipe.pyx).
+ *         if exc is None:             # <<<<<<<<<<<<<<
+ *             self._init_protocol()
+ *         else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/stream.pyx":651
+ *             self._init_protocol()
+ *         else:
+ *             if self._waiter is None:             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, False, "connect failed")
+ *             elif self._waiter.cancelled():
+ */
+  /*else*/ {
+    __pyx_t_2 = (__pyx_v_self->__pyx_base._waiter == Py_None);
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":652
+ *         else:
+ *             if self._waiter is None:
+ *                 self._fatal_error(exc, False, "connect failed")             # <<<<<<<<<<<<<<
+ *             elif self._waiter.cancelled():
+ *                 # Connect call was cancelled; just close the transport
+ */
+      __pyx_t_4.__pyx_n = 1;
+      __pyx_t_4.reason = __pyx_kp_u_connect_failed;
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_False, &__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 652, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/stream.pyx":651
+ *             self._init_protocol()
+ *         else:
+ *             if self._waiter is None:             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, False, "connect failed")
+ *             elif self._waiter.cancelled():
+ */
+      goto __pyx_L4;
+    }
+
+    /* "uvloop/handles/stream.pyx":653
+ *             if self._waiter is None:
+ *                 self._fatal_error(exc, False, "connect failed")
+ *             elif self._waiter.cancelled():             # <<<<<<<<<<<<<<
+ *                 # Connect call was cancelled; just close the transport
+ *                 # silently.
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base._waiter, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 653, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_3 = (__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_3)) __PYX_ERR(18, 653, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(18, 653, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":656
+ *                 # Connect call was cancelled; just close the transport
+ *                 # silently.
+ *                 self._close()             # <<<<<<<<<<<<<<
+ *             elif self._waiter.done():
+ *                 self._fatal_error(exc, False, "connect failed")
+ */
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 656, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/stream.pyx":653
+ *             if self._waiter is None:
+ *                 self._fatal_error(exc, False, "connect failed")
+ *             elif self._waiter.cancelled():             # <<<<<<<<<<<<<<
+ *                 # Connect call was cancelled; just close the transport
+ *                 # silently.
+ */
+      goto __pyx_L4;
+    }
+
+    /* "uvloop/handles/stream.pyx":657
+ *                 # silently.
+ *                 self._close()
+ *             elif self._waiter.done():             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, False, "connect failed")
+ *             else:
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base._waiter, __pyx_n_s_done); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 657, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_3 = (__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_3)) __PYX_ERR(18, 657, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(18, 657, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":658
+ *                 self._close()
+ *             elif self._waiter.done():
+ *                 self._fatal_error(exc, False, "connect failed")             # <<<<<<<<<<<<<<
+ *             else:
+ *                 self._waiter.set_exception(exc)
+ */
+      __pyx_t_4.__pyx_n = 1;
+      __pyx_t_4.reason = __pyx_kp_u_connect_failed;
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_False, &__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 658, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/stream.pyx":657
+ *                 # silently.
+ *                 self._close()
+ *             elif self._waiter.done():             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, False, "connect failed")
+ *             else:
+ */
+      goto __pyx_L4;
+    }
+
+    /* "uvloop/handles/stream.pyx":660
+ *                 self._fatal_error(exc, False, "connect failed")
+ *             else:
+ *                 self._waiter.set_exception(exc)             # <<<<<<<<<<<<<<
+ *                 self._close()
+ * 
+ */
+    /*else*/ {
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base._waiter, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 660, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __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_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_exc);
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 660, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/stream.pyx":661
+ *             else:
+ *                 self._waiter.set_exception(exc)
+ *                 self._close()             # <<<<<<<<<<<<<<
+ * 
+ *     # === Public API ===
+ */
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 661, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+    __pyx_L4:;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/stream.pyx":645
+ *             self._set_waiter(waiter)
+ * 
+ *     cdef inline _on_connect(self, object exc):             # <<<<<<<<<<<<<<
+ *         # Called from __tcp_connect_callback (tcp.pyx) and
+ *         # __pipe_connect_callback (pipe.pyx).
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.UVStream._on_connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":665
+ *     # === Public API ===
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return '<{} closed={} reading={} {:#x}>'.format(
+ *             self.__class__.__name__,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_3__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVStream_2__repr__(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_2__repr__(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "uvloop/handles/stream.pyx":666
+ * 
+ *     def __repr__(self):
+ *         return '<{} closed={} reading={} {:#x}>'.format(             # <<<<<<<<<<<<<<
+ *             self.__class__.__name__,
+ *             self._closed,
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_closed_reading_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 666, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/handles/stream.pyx":667
+ *     def __repr__(self):
+ *         return '<{} closed={} reading={} {:#x}>'.format(
+ *             self.__class__.__name__,             # <<<<<<<<<<<<<<
+ *             self._closed,
+ *             self.__reading,
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 667, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 667, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/stream.pyx":668
+ *         return '<{} closed={} reading={} {:#x}>'.format(
+ *             self.__class__.__name__,
+ *             self._closed,             # <<<<<<<<<<<<<<
+ *             self.__reading,
+ *             id(self))
+ */
+  __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._closed); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 668, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/handles/stream.pyx":669
+ *             self.__class__.__name__,
+ *             self._closed,
+ *             self.__reading,             # <<<<<<<<<<<<<<
+ *             id(self))
+ * 
+ */
+  __pyx_t_5 = __Pyx_PyBool_FromLong(__pyx_v_self->__pyx___reading); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 669, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+
+  /* "uvloop/handles/stream.pyx":670
+ *             self._closed,
+ *             self.__reading,
+ *             id(self))             # <<<<<<<<<<<<<<
+ * 
+ *     def write(self, object buf):
+ */
+  __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(18, 670, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = NULL;
+  __pyx_t_8 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_8 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_t_4, __pyx_t_3, __pyx_t_5, __pyx_t_6};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 666, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_t_4, __pyx_t_3, __pyx_t_5, __pyx_t_6};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 666, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_9 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(18, 666, __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_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_8, __pyx_t_6);
+    __pyx_t_4 = 0;
+    __pyx_t_3 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 666, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/stream.pyx":665
+ *     # === Public API ===
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return '<{} closed={} reading={} {:#x}>'.format(
+ *             self.__class__.__name__,
+ */
+
+  /* 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_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.UVStream.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":672
+ *             id(self))
+ * 
+ *     def write(self, object buf):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_5write(PyObject *__pyx_v_self, PyObject *__pyx_v_buf); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8UVStream_4write[] = "UVStream.write(self, buf)";
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_5write(PyObject *__pyx_v_self, PyObject *__pyx_v_buf) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("write (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVStream_4write(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self), ((PyObject *)__pyx_v_buf));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_4write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_buf) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("write", 0);
+
+  /* "uvloop/handles/stream.pyx":673
+ * 
+ *     def write(self, object buf):
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._eof:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 673, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":675
+ *         self._ensure_alive()
+ * 
+ *         if self._eof:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Cannot call write() after write_eof()')
+ *         if not buf:
+ */
+  __pyx_t_2 = (__pyx_v_self->_eof != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/stream.pyx":676
+ * 
+ *         if self._eof:
+ *             raise RuntimeError('Cannot call write() after write_eof()')             # <<<<<<<<<<<<<<
+ *         if not buf:
+ *             return
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__152, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 676, __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(18, 676, __pyx_L1_error)
+
+    /* "uvloop/handles/stream.pyx":675
+ *         self._ensure_alive()
+ * 
+ *         if self._eof:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Cannot call write() after write_eof()')
+ *         if not buf:
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":677
+ *         if self._eof:
+ *             raise RuntimeError('Cannot call write() after write_eof()')
+ *         if not buf:             # <<<<<<<<<<<<<<
+ *             return
+ *         if self._conn_lost:
+ */
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_buf); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(18, 677, __pyx_L1_error)
+  __pyx_t_3 = ((!__pyx_t_2) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/stream.pyx":678
+ *             raise RuntimeError('Cannot call write() after write_eof()')
+ *         if not buf:
+ *             return             # <<<<<<<<<<<<<<
+ *         if self._conn_lost:
+ *             self._conn_lost += 1
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":677
+ *         if self._eof:
+ *             raise RuntimeError('Cannot call write() after write_eof()')
+ *         if not buf:             # <<<<<<<<<<<<<<
+ *             return
+ *         if self._conn_lost:
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":679
+ *         if not buf:
+ *             return
+ *         if self._conn_lost:             # <<<<<<<<<<<<<<
+ *             self._conn_lost += 1
+ *             return
+ */
+  __pyx_t_3 = (__pyx_v_self->__pyx_base._conn_lost != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/stream.pyx":680
+ *             return
+ *         if self._conn_lost:
+ *             self._conn_lost += 1             # <<<<<<<<<<<<<<
+ *             return
+ *         self._write(buf)
+ */
+    __pyx_v_self->__pyx_base._conn_lost = (__pyx_v_self->__pyx_base._conn_lost + 1);
+
+    /* "uvloop/handles/stream.pyx":681
+ *         if self._conn_lost:
+ *             self._conn_lost += 1
+ *             return             # <<<<<<<<<<<<<<
+ *         self._write(buf)
+ * 
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":679
+ *         if not buf:
+ *             return
+ *         if self._conn_lost:             # <<<<<<<<<<<<<<
+ *             self._conn_lost += 1
+ *             return
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":682
+ *             self._conn_lost += 1
+ *             return
+ *         self._write(buf)             # <<<<<<<<<<<<<<
+ * 
+ *     def writelines(self, bufs):
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_8UVStream__write(__pyx_v_self, __pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 682, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":672
+ *             id(self))
+ * 
+ *     def write(self, object buf):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStream.write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":684
+ *         self._write(buf)
+ * 
+ *     def writelines(self, bufs):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_7writelines(PyObject *__pyx_v_self, PyObject *__pyx_v_bufs); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8UVStream_6writelines[] = "UVStream.writelines(self, bufs)";
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_7writelines(PyObject *__pyx_v_self, PyObject *__pyx_v_bufs) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("writelines (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVStream_6writelines(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self), ((PyObject *)__pyx_v_bufs));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_6writelines(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_bufs) {
+  PyObject *__pyx_v_buf = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  PyObject *(*__pyx_t_4)(PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("writelines", 0);
+
+  /* "uvloop/handles/stream.pyx":685
+ * 
+ *     def writelines(self, bufs):
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._eof:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 685, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":687
+ *         self._ensure_alive()
+ * 
+ *         if self._eof:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Cannot call writelines() after write_eof()')
+ *         if self._conn_lost:
+ */
+  __pyx_t_2 = (__pyx_v_self->_eof != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/stream.pyx":688
+ * 
+ *         if self._eof:
+ *             raise RuntimeError('Cannot call writelines() after write_eof()')             # <<<<<<<<<<<<<<
+ *         if self._conn_lost:
+ *             self._conn_lost += 1
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__153, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 688, __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(18, 688, __pyx_L1_error)
+
+    /* "uvloop/handles/stream.pyx":687
+ *         self._ensure_alive()
+ * 
+ *         if self._eof:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('Cannot call writelines() after write_eof()')
+ *         if self._conn_lost:
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":689
+ *         if self._eof:
+ *             raise RuntimeError('Cannot call writelines() after write_eof()')
+ *         if self._conn_lost:             # <<<<<<<<<<<<<<
+ *             self._conn_lost += 1
+ *             return
+ */
+  __pyx_t_2 = (__pyx_v_self->__pyx_base._conn_lost != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/stream.pyx":690
+ *             raise RuntimeError('Cannot call writelines() after write_eof()')
+ *         if self._conn_lost:
+ *             self._conn_lost += 1             # <<<<<<<<<<<<<<
+ *             return
+ *         for buf in bufs:
+ */
+    __pyx_v_self->__pyx_base._conn_lost = (__pyx_v_self->__pyx_base._conn_lost + 1);
+
+    /* "uvloop/handles/stream.pyx":691
+ *         if self._conn_lost:
+ *             self._conn_lost += 1
+ *             return             # <<<<<<<<<<<<<<
+ *         for buf in bufs:
+ *             self._write(buf)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":689
+ *         if self._eof:
+ *             raise RuntimeError('Cannot call writelines() after write_eof()')
+ *         if self._conn_lost:             # <<<<<<<<<<<<<<
+ *             self._conn_lost += 1
+ *             return
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":692
+ *             self._conn_lost += 1
+ *             return
+ *         for buf in bufs:             # <<<<<<<<<<<<<<
+ *             self._write(buf)
+ * 
+ */
+  if (likely(PyList_CheckExact(__pyx_v_bufs)) || PyTuple_CheckExact(__pyx_v_bufs)) {
+    __pyx_t_1 = __pyx_v_bufs; __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = 0;
+    __pyx_t_4 = NULL;
+  } else {
+    __pyx_t_3 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_bufs); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 692, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 692, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_4)) {
+      if (likely(PyList_CheckExact(__pyx_t_1))) {
+        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_1)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(18, 692, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 692, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      } else {
+        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(18, 692, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 692, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      }
+    } else {
+      __pyx_t_5 = __pyx_t_4(__pyx_t_1);
+      if (unlikely(!__pyx_t_5)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(18, 692, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_5);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_buf, __pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "uvloop/handles/stream.pyx":693
+ *             return
+ *         for buf in bufs:
+ *             self._write(buf)             # <<<<<<<<<<<<<<
+ * 
+ *     def write_eof(self):
+ */
+    __pyx_t_5 = __pyx_f_6uvloop_4loop_8UVStream__write(__pyx_v_self, __pyx_v_buf); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 693, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/handles/stream.pyx":692
+ *             self._conn_lost += 1
+ *             return
+ *         for buf in bufs:             # <<<<<<<<<<<<<<
+ *             self._write(buf)
+ * 
+ */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":684
+ *         self._write(buf)
+ * 
+ *     def writelines(self, bufs):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVStream.writelines", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_buf);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":695
+ *             self._write(buf)
+ * 
+ *     def write_eof(self):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_9write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8UVStream_8write_eof[] = "UVStream.write_eof(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_9write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("write_eof (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVStream_8write_eof(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_8write_eof(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("write_eof", 0);
+
+  /* "uvloop/handles/stream.pyx":696
+ * 
+ *     def write_eof(self):
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._eof:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 696, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":698
+ *         self._ensure_alive()
+ * 
+ *         if self._eof:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_self->_eof != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/stream.pyx":699
+ * 
+ *         if self._eof:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._eof = 1
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":698
+ *         self._ensure_alive()
+ * 
+ *         if self._eof:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":701
+ *             return
+ * 
+ *         self._eof = 1             # <<<<<<<<<<<<<<
+ *         if not self._get_write_buffer_size():
+ *             self._shutdown()
+ */
+  __pyx_v_self->_eof = 1;
+
+  /* "uvloop/handles/stream.pyx":702
+ * 
+ *         self._eof = 1
+ *         if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *             self._shutdown()
+ * 
+ */
+  __pyx_t_2 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._get_write_buffer_size(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)) != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/stream.pyx":703
+ *         self._eof = 1
+ *         if not self._get_write_buffer_size():
+ *             self._shutdown()             # <<<<<<<<<<<<<<
+ * 
+ *     def can_write_eof(self):
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_8UVStream__shutdown(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 703, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/stream.pyx":702
+ * 
+ *         self._eof = 1
+ *         if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *             self._shutdown()
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":695
+ *             self._write(buf)
+ * 
+ *     def write_eof(self):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStream.write_eof", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":705
+ *             self._shutdown()
+ * 
+ *     def can_write_eof(self):             # <<<<<<<<<<<<<<
+ *         return True
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_11can_write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8UVStream_10can_write_eof[] = "UVStream.can_write_eof(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_11can_write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("can_write_eof (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVStream_10can_write_eof(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_10can_write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("can_write_eof", 0);
+
+  /* "uvloop/handles/stream.pyx":706
+ * 
+ *     def can_write_eof(self):
+ *         return True             # <<<<<<<<<<<<<<
+ * 
+ *     def is_reading(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(Py_True);
+  __pyx_r = Py_True;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/stream.pyx":705
+ *             self._shutdown()
+ * 
+ *     def can_write_eof(self):             # <<<<<<<<<<<<<<
+ *         return True
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":708
+ *         return True
+ * 
+ *     def is_reading(self):             # <<<<<<<<<<<<<<
+ *         return self._is_reading()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_13is_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8UVStream_12is_reading[] = "UVStream.is_reading(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_13is_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_reading (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVStream_12is_reading(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_12is_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__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("is_reading", 0);
+
+  /* "uvloop/handles/stream.pyx":709
+ * 
+ *     def is_reading(self):
+ *         return self._is_reading()             # <<<<<<<<<<<<<<
+ * 
+ *     def pause_reading(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._is_reading(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self))); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 709, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/stream.pyx":708
+ *         return True
+ * 
+ *     def is_reading(self):             # <<<<<<<<<<<<<<
+ *         return self._is_reading()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStream.is_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":711
+ *         return self._is_reading()
+ * 
+ *     def pause_reading(self):             # <<<<<<<<<<<<<<
+ *         if self._closing or not self._is_reading():
+ *             return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_15pause_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8UVStream_14pause_reading[] = "UVStream.pause_reading(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_15pause_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("pause_reading (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVStream_14pause_reading(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_14pause_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("pause_reading", 0);
+
+  /* "uvloop/handles/stream.pyx":712
+ * 
+ *     def pause_reading(self):
+ *         if self._closing or not self._is_reading():             # <<<<<<<<<<<<<<
+ *             return
+ *         self._stop_reading()
+ */
+  __pyx_t_2 = (__pyx_v_self->__pyx_base._closing != 0);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._is_reading(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)) != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":713
+ *     def pause_reading(self):
+ *         if self._closing or not self._is_reading():
+ *             return             # <<<<<<<<<<<<<<
+ *         self._stop_reading()
+ * 
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":712
+ * 
+ *     def pause_reading(self):
+ *         if self._closing or not self._is_reading():             # <<<<<<<<<<<<<<
+ *             return
+ *         self._stop_reading()
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":714
+ *         if self._closing or not self._is_reading():
+ *             return
+ *         self._stop_reading()             # <<<<<<<<<<<<<<
+ * 
+ *     def resume_reading(self):
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._stop_reading(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 714, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/stream.pyx":711
+ *         return self._is_reading()
+ * 
+ *     def pause_reading(self):             # <<<<<<<<<<<<<<
+ *         if self._closing or not self._is_reading():
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVStream.pause_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":716
+ *         self._stop_reading()
+ * 
+ *     def resume_reading(self):             # <<<<<<<<<<<<<<
+ *         if self._is_reading() or self._closing:
+ *             return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_17resume_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8UVStream_16resume_reading[] = "UVStream.resume_reading(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_17resume_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resume_reading (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_8UVStream_16resume_reading(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_16resume_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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("resume_reading", 0);
+
+  /* "uvloop/handles/stream.pyx":717
+ * 
+ *     def resume_reading(self):
+ *         if self._is_reading() or self._closing:             # <<<<<<<<<<<<<<
+ *             return
+ *         self._start_reading()
+ */
+  __pyx_t_2 = (((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._is_reading(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)) != 0);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_v_self->__pyx_base._closing != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":718
+ *     def resume_reading(self):
+ *         if self._is_reading() or self._closing:
+ *             return             # <<<<<<<<<<<<<<
+ *         self._start_reading()
+ * 
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":717
+ * 
+ *     def resume_reading(self):
+ *         if self._is_reading() or self._closing:             # <<<<<<<<<<<<<<
+ *             return
+ *         self._start_reading()
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":719
+ *         if self._is_reading() or self._closing:
+ *             return
+ *         self._start_reading()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._start_reading(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 719, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/stream.pyx":716
+ *         self._stop_reading()
+ * 
+ *     def resume_reading(self):             # <<<<<<<<<<<<<<
+ *         if self._is_reading() or self._closing:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVStream.resume_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8UVStream_18__reduce_cython__[] = "UVStream.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_19__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_6uvloop_4loop_8UVStream_18__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStream *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__154, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStream.__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_6uvloop_4loop_8UVStream_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8UVStream_20__setstate_cython__[] = "UVStream.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_8UVStream_21__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_6uvloop_4loop_8UVStream_20__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStream *__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);
+
+  /* "(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__155, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStream.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":722
+ * 
+ * 
+ * cdef void __uv_stream_on_shutdown(uv.uv_shutdown_t* req,             # <<<<<<<<<<<<<<
+ *                                   int status) with gil:
+ * 
+ */
+
+static void __pyx_f_6uvloop_4loop___uv_stream_on_shutdown(uv_shutdown_t *__pyx_v_req, int __pyx_v_status) {
+  struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_stream = 0;
+  PyObject *__pyx_v_exc = NULL;
+  __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;
+  int __pyx_t_8;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_9 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error __pyx_t_10;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uv_stream_on_shutdown", 0);
+
+  /* "uvloop/handles/stream.pyx":727
+ *     # callback for uv_shutdown
+ * 
+ *     if req.data is NULL:             # <<<<<<<<<<<<<<
+ *         aio_logger.error(
+ *             'UVStream.shutdown callback called with NULL req.data, status=%r',
+ */
+  __pyx_t_1 = ((__pyx_v_req->data == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":728
+ * 
+ *     if req.data is NULL:
+ *         aio_logger.error(             # <<<<<<<<<<<<<<
+ *             'UVStream.shutdown callback called with NULL req.data, status=%r',
+ *             status)
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 728, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/handles/stream.pyx":730
+ *         aio_logger.error(
+ *             'UVStream.shutdown callback called with NULL req.data, status=%r',
+ *             status)             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 730, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    __pyx_t_6 = 0;
+    if (CYTHON_UNPACK_METHODS && 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_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_u_UVStream_shutdown_callback_calle, __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(18, 728, __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_u_UVStream_shutdown_callback_calle, __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(18, 728, __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
+    {
+      __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(18, 728, __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_u_UVStream_shutdown_callback_calle);
+      __Pyx_GIVEREF(__pyx_kp_u_UVStream_shutdown_callback_calle);
+      PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_u_UVStream_shutdown_callback_calle);
+      __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(18, 728, __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_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":731
+ *             'UVStream.shutdown callback called with NULL req.data, status=%r',
+ *             status)
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef UVStream stream = <UVStream> req.data
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":727
+ *     # callback for uv_shutdown
+ * 
+ *     if req.data is NULL:             # <<<<<<<<<<<<<<
+ *         aio_logger.error(
+ *             'UVStream.shutdown callback called with NULL req.data, status=%r',
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":733
+ *         return
+ * 
+ *     cdef UVStream stream = <UVStream> req.data             # <<<<<<<<<<<<<<
+ * 
+ *     if status < 0 and status != uv.UV_ECANCELED:
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_req->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_stream = ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/stream.pyx":735
+ *     cdef UVStream stream = <UVStream> req.data
+ * 
+ *     if status < 0 and status != uv.UV_ECANCELED:             # <<<<<<<<<<<<<<
+ *         # From libuv source code:
+ *         #     The ECANCELED error code is a lie, the shutdown(2) syscall is a
+ */
+  __pyx_t_8 = ((__pyx_v_status < 0) != 0);
+  if (__pyx_t_8) {
+  } else {
+    __pyx_t_1 = __pyx_t_8;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_8 = ((__pyx_v_status != UV_ECANCELED) != 0);
+  __pyx_t_1 = __pyx_t_8;
+  __pyx_L5_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":742
+ *         #     informs the callee that the handle has been destroyed.
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             stream._loop._debug_stream_shutdown_errors_total += 1
+ * 
+ */
+    __pyx_t_1 = (UVLOOP_DEBUG != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":743
+ * 
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_shutdown_errors_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *         exc = convert_error(status)
+ */
+      __Pyx_INCREF(((PyObject *)__pyx_v_stream->__pyx_base.__pyx_base.__pyx_base._loop));
+      __pyx_t_9 = __pyx_v_stream->__pyx_base.__pyx_base.__pyx_base._loop;
+      __pyx_t_9->_debug_stream_shutdown_errors_total = (__pyx_t_9->_debug_stream_shutdown_errors_total + 1);
+      __Pyx_DECREF(((PyObject *)__pyx_t_9)); __pyx_t_9 = 0;
+
+      /* "uvloop/handles/stream.pyx":742
+ *         #     informs the callee that the handle has been destroyed.
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             stream._loop._debug_stream_shutdown_errors_total += 1
+ * 
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":745
+ *             stream._loop._debug_stream_shutdown_errors_total += 1
+ * 
+ *         exc = convert_error(status)             # <<<<<<<<<<<<<<
+ *         stream._fatal_error(
+ *             exc, False, "error status in uv_stream_t.shutdown callback")
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_status); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 745, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":746
+ * 
+ *         exc = convert_error(status)
+ *         stream._fatal_error(             # <<<<<<<<<<<<<<
+ *             exc, False, "error status in uv_stream_t.shutdown callback")
+ *         return
+ */
+    __pyx_t_10.__pyx_n = 1;
+    __pyx_t_10.reason = __pyx_kp_u_error_status_in_uv_stream_t_shut;
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_stream->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_stream), __pyx_v_exc, Py_False, &__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 746, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":748
+ *         stream._fatal_error(
+ *             exc, False, "error status in uv_stream_t.shutdown callback")
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":735
+ *     cdef UVStream stream = <UVStream> req.data
+ * 
+ *     if status < 0 and status != uv.UV_ECANCELED:             # <<<<<<<<<<<<<<
+ *         # From libuv source code:
+ *         #     The ECANCELED error code is a lie, the shutdown(2) syscall is a
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":722
+ * 
+ * 
+ * cdef void __uv_stream_on_shutdown(uv.uv_shutdown_t* req,             # <<<<<<<<<<<<<<
+ *                                   int status) with gil:
+ * 
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __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_7);
+  __Pyx_XDECREF(((PyObject *)__pyx_t_9));
+  __Pyx_WriteUnraisable("uvloop.loop.__uv_stream_on_shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_stream);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/stream.pyx":751
+ * 
+ * 
+ * cdef inline bint __uv_stream_on_read_common(UVStream sc, Loop loop,             # <<<<<<<<<<<<<<
+ *                                             ssize_t nread):
+ *     if sc._closed:
+ */
+
+static CYTHON_INLINE int __pyx_f_6uvloop_4loop___uv_stream_on_read_common(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_sc, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, Py_ssize_t __pyx_v_nread) {
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_v_exc = NULL;
+  int __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;
+  int __pyx_t_10;
+  char const *__pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error __pyx_t_18;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__uv_stream_on_read_common", 0);
+
+  /* "uvloop/handles/stream.pyx":753
+ * cdef inline bint __uv_stream_on_read_common(UVStream sc, Loop loop,
+ *                                             ssize_t nread):
+ *     if sc._closed:             # <<<<<<<<<<<<<<
+ *         # The stream was closed, there is no reason to
+ *         # do any work now.
+ */
+  __pyx_t_1 = (__pyx_v_sc->__pyx_base.__pyx_base.__pyx_base._closed != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":756
+ *         # The stream was closed, there is no reason to
+ *         # do any work now.
+ *         sc.__reading_stopped()  # Just in case.             # <<<<<<<<<<<<<<
+ *         return True
+ * 
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_8UVStream___reading_stopped(__pyx_v_sc); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 756, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/stream.pyx":757
+ *         # do any work now.
+ *         sc.__reading_stopped()  # Just in case.
+ *         return True             # <<<<<<<<<<<<<<
+ * 
+ *     if nread == uv.UV_EOF:
+ */
+    __pyx_r = 1;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":753
+ * cdef inline bint __uv_stream_on_read_common(UVStream sc, Loop loop,
+ *                                             ssize_t nread):
+ *     if sc._closed:             # <<<<<<<<<<<<<<
+ *         # The stream was closed, there is no reason to
+ *         # do any work now.
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":759
+ *         return True
+ * 
+ *     if nread == uv.UV_EOF:             # <<<<<<<<<<<<<<
+ *         # From libuv docs:
+ *         #     The callee is responsible for stopping closing the stream
+ */
+  __pyx_t_1 = ((__pyx_v_nread == UV_EOF) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":764
+ *         #     when an error happens by calling uv_read_stop() or uv_close().
+ *         #     Trying to read from the stream again is undefined.
+ *         try:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 loop._debug_stream_read_eof_total += 1
+ */
+    /*try:*/ {
+      {
+        __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:*/ {
+
+          /* "uvloop/handles/stream.pyx":765
+ *         #     Trying to read from the stream again is undefined.
+ *         try:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 loop._debug_stream_read_eof_total += 1
+ * 
+ */
+          __pyx_t_1 = (UVLOOP_DEBUG != 0);
+          if (__pyx_t_1) {
+
+            /* "uvloop/handles/stream.pyx":766
+ *         try:
+ *             if UVLOOP_DEBUG:
+ *                 loop._debug_stream_read_eof_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *             sc._stop_reading()
+ */
+            __pyx_v_loop->_debug_stream_read_eof_total = (__pyx_v_loop->_debug_stream_read_eof_total + 1);
+
+            /* "uvloop/handles/stream.pyx":765
+ *         #     Trying to read from the stream again is undefined.
+ *         try:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 loop._debug_stream_read_eof_total += 1
+ * 
+ */
+          }
+
+          /* "uvloop/handles/stream.pyx":768
+ *                 loop._debug_stream_read_eof_total += 1
+ * 
+ *             sc._stop_reading()             # <<<<<<<<<<<<<<
+ *             sc._on_eof()
+ *         except BaseException as ex:
+ */
+          __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_sc->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._stop_reading(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_sc)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 768, __pyx_L8_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+          /* "uvloop/handles/stream.pyx":769
+ * 
+ *             sc._stop_reading()
+ *             sc._on_eof()             # <<<<<<<<<<<<<<
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:
+ */
+          __pyx_t_2 = __pyx_f_6uvloop_4loop_8UVStream__on_eof(__pyx_v_sc); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 769, __pyx_L8_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+          /* "uvloop/handles/stream.pyx":764
+ *         #     when an error happens by calling uv_read_stop() or uv_close().
+ *         #     Trying to read from the stream again is undefined.
+ *         try:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 loop._debug_stream_read_eof_total += 1
+ */
+        }
+        __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_L13_try_end;
+        __pyx_L8_error:;
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/handles/stream.pyx":770
+ *             sc._stop_reading()
+ *             sc._on_eof()
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 loop._debug_stream_read_eof_cb_errors_total += 1
+ */
+        __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+        if (__pyx_t_6) {
+          __Pyx_AddTraceback("uvloop.loop.__uv_stream_on_read_common", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(18, 770, __pyx_L10_except_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_GOTREF(__pyx_t_8);
+          __Pyx_INCREF(__pyx_t_7);
+          __pyx_v_ex = __pyx_t_7;
+          /*try:*/ {
+
+            /* "uvloop/handles/stream.pyx":771
+ *             sc._on_eof()
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 loop._debug_stream_read_eof_cb_errors_total += 1
+ * 
+ */
+            __pyx_t_1 = (UVLOOP_DEBUG != 0);
+            if (__pyx_t_1) {
+
+              /* "uvloop/handles/stream.pyx":772
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:
+ *                 loop._debug_stream_read_eof_cb_errors_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *             sc._fatal_error(ex, False)
+ */
+              __pyx_v_loop->_debug_stream_read_eof_cb_errors_total = (__pyx_v_loop->_debug_stream_read_eof_cb_errors_total + 1);
+
+              /* "uvloop/handles/stream.pyx":771
+ *             sc._on_eof()
+ *         except BaseException as ex:
+ *             if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *                 loop._debug_stream_read_eof_cb_errors_total += 1
+ * 
+ */
+            }
+
+            /* "uvloop/handles/stream.pyx":774
+ *                 loop._debug_stream_read_eof_cb_errors_total += 1
+ * 
+ *             sc._fatal_error(ex, False)             # <<<<<<<<<<<<<<
+ *         finally:
+ *             return True
+ */
+            __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_sc->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_sc), __pyx_v_ex, Py_False, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(18, 774, __pyx_L20_error)
+            __Pyx_GOTREF(__pyx_t_9);
+            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          }
+
+          /* "uvloop/handles/stream.pyx":770
+ *             sc._stop_reading()
+ *             sc._on_eof()
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 loop._debug_stream_read_eof_cb_errors_total += 1
+ */
+          /*finally:*/ {
+            /*normal exit:*/{
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+              goto __pyx_L21;
+            }
+            __pyx_L20_error:;
+            /*exception exit:*/{
+              __Pyx_PyThreadState_declare
+              __Pyx_PyThreadState_assign
+              __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+              __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+              if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+              if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+              __Pyx_XGOTREF(__pyx_t_12);
+              __Pyx_XGOTREF(__pyx_t_13);
+              __Pyx_XGOTREF(__pyx_t_14);
+              __Pyx_XGOTREF(__pyx_t_15);
+              __Pyx_XGOTREF(__pyx_t_16);
+              __Pyx_XGOTREF(__pyx_t_17);
+              __pyx_t_6 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
+              {
+                __Pyx_DECREF(__pyx_v_ex);
+                __pyx_v_ex = NULL;
+              }
+              if (PY_MAJOR_VERSION >= 3) {
+                __Pyx_XGIVEREF(__pyx_t_15);
+                __Pyx_XGIVEREF(__pyx_t_16);
+                __Pyx_XGIVEREF(__pyx_t_17);
+                __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+              }
+              __Pyx_XGIVEREF(__pyx_t_12);
+              __Pyx_XGIVEREF(__pyx_t_13);
+              __Pyx_XGIVEREF(__pyx_t_14);
+              __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+              __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+              __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
+              goto __pyx_L10_except_error;
+            }
+            __pyx_L21:;
+          }
+          __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;
+          goto __pyx_L9_exception_handled;
+        }
+        goto __pyx_L10_except_error;
+        __pyx_L10_except_error:;
+
+        /* "uvloop/handles/stream.pyx":764
+ *         #     when an error happens by calling uv_read_stop() or uv_close().
+ *         #     Trying to read from the stream again is undefined.
+ *         try:             # <<<<<<<<<<<<<<
+ *             if UVLOOP_DEBUG:
+ *                 loop._debug_stream_read_eof_total += 1
+ */
+        __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_L6_error;
+        __pyx_L9_exception_handled:;
+        __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);
+        __pyx_L13_try_end:;
+      }
+    }
+
+    /* "uvloop/handles/stream.pyx":776
+ *             sc._fatal_error(ex, False)
+ *         finally:
+ *             return True             # <<<<<<<<<<<<<<
+ * 
+ *     if nread == 0:
+ */
+    /*finally:*/ {
+      /*normal exit:*/{
+        __pyx_r = 1;
+        goto __pyx_L0;
+      }
+      __pyx_L6_error:;
+      /*exception exit:*/{
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+        __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;
+        if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_16, &__pyx_t_15);
+        if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3);
+        __Pyx_XGOTREF(__pyx_t_5);
+        __Pyx_XGOTREF(__pyx_t_4);
+        __Pyx_XGOTREF(__pyx_t_3);
+        __Pyx_XGOTREF(__pyx_t_17);
+        __Pyx_XGOTREF(__pyx_t_16);
+        __Pyx_XGOTREF(__pyx_t_15);
+        {
+          __pyx_r = 1;
+          goto __pyx_L27_return;
+        }
+        __pyx_L27_return:;
+        if (PY_MAJOR_VERSION >= 3) {
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15);
+        }
+        __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;
+        __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+        goto __pyx_L0;
+      }
+    }
+
+    /* "uvloop/handles/stream.pyx":759
+ *         return True
+ * 
+ *     if nread == uv.UV_EOF:             # <<<<<<<<<<<<<<
+ *         # From libuv docs:
+ *         #     The callee is responsible for stopping closing the stream
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":778
+ *             return True
+ * 
+ *     if nread == 0:             # <<<<<<<<<<<<<<
+ *         # From libuv docs:
+ *         #     nread might be 0, which does not indicate an error or EOF.
+ */
+  __pyx_t_1 = ((__pyx_v_nread == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":782
+ *         #     nread might be 0, which does not indicate an error or EOF.
+ *         #     This is equivalent to EAGAIN or EWOULDBLOCK under read(2).
+ *         return True             # <<<<<<<<<<<<<<
+ * 
+ *     if nread < 0:
+ */
+    __pyx_r = 1;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":778
+ *             return True
+ * 
+ *     if nread == 0:             # <<<<<<<<<<<<<<
+ *         # From libuv docs:
+ *         #     nread might be 0, which does not indicate an error or EOF.
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":784
+ *         return True
+ * 
+ *     if nread < 0:             # <<<<<<<<<<<<<<
+ *         # From libuv docs:
+ *         #     The callee is responsible for stopping closing the stream
+ */
+  __pyx_t_1 = ((__pyx_v_nread < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":794
+ *         # we don't need try...finally here.
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_stream_read_errors_total += 1
+ * 
+ */
+    __pyx_t_1 = (UVLOOP_DEBUG != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":795
+ * 
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_errors_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *         if sc.__read_error_close:
+ */
+      __pyx_v_loop->_debug_stream_read_errors_total = (__pyx_v_loop->_debug_stream_read_errors_total + 1);
+
+      /* "uvloop/handles/stream.pyx":794
+ *         # we don't need try...finally here.
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_stream_read_errors_total += 1
+ * 
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":797
+ *             loop._debug_stream_read_errors_total += 1
+ * 
+ *         if sc.__read_error_close:             # <<<<<<<<<<<<<<
+ *             # Used for getting notified when a pipe is closed.
+ *             # See WriteUnixTransport for the explanation.
+ */
+    __pyx_t_1 = (__pyx_v_sc->__pyx___read_error_close != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":800
+ *             # Used for getting notified when a pipe is closed.
+ *             # See WriteUnixTransport for the explanation.
+ *             sc._on_eof()             # <<<<<<<<<<<<<<
+ *             return True
+ * 
+ */
+      __pyx_t_8 = __pyx_f_6uvloop_4loop_8UVStream__on_eof(__pyx_v_sc); if (unlikely(!__pyx_t_8)) __PYX_ERR(18, 800, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "uvloop/handles/stream.pyx":801
+ *             # See WriteUnixTransport for the explanation.
+ *             sc._on_eof()
+ *             return True             # <<<<<<<<<<<<<<
+ * 
+ *         exc = convert_error(nread)
+ */
+      __pyx_r = 1;
+      goto __pyx_L0;
+
+      /* "uvloop/handles/stream.pyx":797
+ *             loop._debug_stream_read_errors_total += 1
+ * 
+ *         if sc.__read_error_close:             # <<<<<<<<<<<<<<
+ *             # Used for getting notified when a pipe is closed.
+ *             # See WriteUnixTransport for the explanation.
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":803
+ *             return True
+ * 
+ *         exc = convert_error(nread)             # <<<<<<<<<<<<<<
+ *         sc._fatal_error(
+ *             exc, False, "error status in uv_stream_t.read callback")
+ */
+    __pyx_t_8 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_nread); if (unlikely(!__pyx_t_8)) __PYX_ERR(18, 803, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_v_exc = __pyx_t_8;
+    __pyx_t_8 = 0;
+
+    /* "uvloop/handles/stream.pyx":804
+ * 
+ *         exc = convert_error(nread)
+ *         sc._fatal_error(             # <<<<<<<<<<<<<<
+ *             exc, False, "error status in uv_stream_t.read callback")
+ *         return True
+ */
+    __pyx_t_18.__pyx_n = 1;
+    __pyx_t_18.reason = __pyx_kp_u_error_status_in_uv_stream_t_read;
+    __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_sc->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_sc), __pyx_v_exc, Py_False, &__pyx_t_18); if (unlikely(!__pyx_t_8)) __PYX_ERR(18, 804, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+    /* "uvloop/handles/stream.pyx":806
+ *         sc._fatal_error(
+ *             exc, False, "error status in uv_stream_t.read callback")
+ *         return True             # <<<<<<<<<<<<<<
+ * 
+ *     return False
+ */
+    __pyx_r = 1;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":784
+ *         return True
+ * 
+ *     if nread < 0:             # <<<<<<<<<<<<<<
+ *         # From libuv docs:
+ *         #     The callee is responsible for stopping closing the stream
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":808
+ *         return True
+ * 
+ *     return False             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/stream.pyx":751
+ * 
+ * 
+ * cdef inline bint __uv_stream_on_read_common(UVStream sc, Loop loop,             # <<<<<<<<<<<<<<
+ *                                             ssize_t nread):
+ *     if sc._closed:
+ */
+
+  /* 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_WriteUnraisable("uvloop.loop.__uv_stream_on_read_common", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/stream.pyx":811
+ * 
+ * 
+ * cdef inline void __uv_stream_on_read_impl(uv.uv_stream_t* stream,             # <<<<<<<<<<<<<<
+ *                                           ssize_t nread,
+ *                                           const uv.uv_buf_t* buf):
+ */
+
+static CYTHON_INLINE void __pyx_f_6uvloop_4loop___uv_stream_on_read_impl(uv_stream_t *__pyx_v_stream, Py_ssize_t __pyx_v_nread, CYTHON_UNUSED uv_buf_t const *__pyx_v_buf) {
+  struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_sc = 0;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  PyObject *__pyx_v_exc = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = 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;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  char const *__pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__uv_stream_on_read_impl", 0);
+
+  /* "uvloop/handles/stream.pyx":815
+ *                                           const uv.uv_buf_t* buf):
+ *     cdef:
+ *         UVStream sc = <UVStream>stream.data             # <<<<<<<<<<<<<<
+ *         Loop loop = sc._loop
+ * 
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_stream->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_sc = ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":816
+ *     cdef:
+ *         UVStream sc = <UVStream>stream.data
+ *         Loop loop = sc._loop             # <<<<<<<<<<<<<<
+ * 
+ *     # It's OK to free the buffer early, since nothing will
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_sc->__pyx_base.__pyx_base.__pyx_base._loop);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":820
+ *     # It's OK to free the buffer early, since nothing will
+ *     # be able to touch it until this method is done.
+ *     __loop_free_buffer(loop)             # <<<<<<<<<<<<<<
+ * 
+ *     if __uv_stream_on_read_common(sc, loop, nread):
+ */
+  __pyx_f_6uvloop_4loop___loop_free_buffer(__pyx_v_loop);
+
+  /* "uvloop/handles/stream.pyx":822
+ *     __loop_free_buffer(loop)
+ * 
+ *     if __uv_stream_on_read_common(sc, loop, nread):             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_2 = (__pyx_f_6uvloop_4loop___uv_stream_on_read_common(__pyx_v_sc, __pyx_v_loop, __pyx_v_nread) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/stream.pyx":823
+ * 
+ *     if __uv_stream_on_read_common(sc, loop, nread):
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":822
+ *     __loop_free_buffer(loop)
+ * 
+ *     if __uv_stream_on_read_common(sc, loop, nread):             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":825
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_cb_total += 1
+ */
+  {
+    __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:*/ {
+
+      /* "uvloop/handles/stream.pyx":826
+ * 
+ *     try:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_stream_read_cb_total += 1
+ * 
+ */
+      __pyx_t_2 = (UVLOOP_DEBUG != 0);
+      if (__pyx_t_2) {
+
+        /* "uvloop/handles/stream.pyx":827
+ *     try:
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_cb_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *         run_in_context1(
+ */
+        __pyx_v_loop->_debug_stream_read_cb_total = (__pyx_v_loop->_debug_stream_read_cb_total + 1);
+
+        /* "uvloop/handles/stream.pyx":826
+ * 
+ *     try:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_stream_read_cb_total += 1
+ * 
+ */
+      }
+
+      /* "uvloop/handles/stream.pyx":830
+ * 
+ *         run_in_context1(
+ *             sc.context,             # <<<<<<<<<<<<<<
+ *             sc._protocol_data_received,
+ *             loop._recv_buffer[:nread],
+ */
+      __pyx_t_1 = __pyx_v_sc->__pyx_base.__pyx_base.__pyx_base.context;
+      __Pyx_INCREF(__pyx_t_1);
+
+      /* "uvloop/handles/stream.pyx":831
+ *         run_in_context1(
+ *             sc.context,
+ *             sc._protocol_data_received,             # <<<<<<<<<<<<<<
+ *             loop._recv_buffer[:nread],
+ *         )
+ */
+      __pyx_t_6 = __pyx_v_sc->__pyx_base._protocol_data_received;
+      __Pyx_INCREF(__pyx_t_6);
+
+      /* "uvloop/handles/stream.pyx":832
+ *             sc.context,
+ *             sc._protocol_data_received,
+ *             loop._recv_buffer[:nread],             # <<<<<<<<<<<<<<
+ *         )
+ *     except BaseException as exc:
+ */
+      __pyx_t_7 = __Pyx_PyBytes_FromStringAndSize(((const char*)__pyx_v_loop->_recv_buffer) + 0, __pyx_v_nread - 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(18, 832, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "uvloop/handles/stream.pyx":829
+ *             loop._debug_stream_read_cb_total += 1
+ * 
+ *         run_in_context1(             # <<<<<<<<<<<<<<
+ *             sc.context,
+ *             sc._protocol_data_received,
+ */
+      __pyx_t_8 = __pyx_f_6uvloop_4loop_run_in_context1(__pyx_t_1, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(18, 829, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "uvloop/handles/stream.pyx":825
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_cb_total += 1
+ */
+    }
+    __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_1); __pyx_t_1 = 0;
+    __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;
+
+    /* "uvloop/handles/stream.pyx":834
+ *             loop._recv_buffer[:nread],
+ *         )
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_cb_errors_total += 1
+ */
+    __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_9) {
+      __Pyx_AddTraceback("uvloop.loop.__uv_stream_on_read_impl", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(18, 834, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_7);
+      __pyx_v_exc = __pyx_t_7;
+      /*try:*/ {
+
+        /* "uvloop/handles/stream.pyx":835
+ *         )
+ *     except BaseException as exc:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_stream_read_cb_errors_total += 1
+ * 
+ */
+        __pyx_t_2 = (UVLOOP_DEBUG != 0);
+        if (__pyx_t_2) {
+
+          /* "uvloop/handles/stream.pyx":836
+ *     except BaseException as exc:
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_cb_errors_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *         sc._fatal_error(exc, False)
+ */
+          __pyx_v_loop->_debug_stream_read_cb_errors_total = (__pyx_v_loop->_debug_stream_read_cb_errors_total + 1);
+
+          /* "uvloop/handles/stream.pyx":835
+ *         )
+ *     except BaseException as exc:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_stream_read_cb_errors_total += 1
+ * 
+ */
+        }
+
+        /* "uvloop/handles/stream.pyx":838
+ *             loop._debug_stream_read_cb_errors_total += 1
+ * 
+ *         sc._fatal_error(exc, False)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+        __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_sc->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_sc), __pyx_v_exc, Py_False, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 838, __pyx_L16_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      }
+
+      /* "uvloop/handles/stream.pyx":834
+ *             loop._recv_buffer[:nread],
+ *         )
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_cb_errors_total += 1
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L17;
+        }
+        __pyx_L16_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_12);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __pyx_t_9 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+          }
+          __Pyx_XGIVEREF(__pyx_t_12);
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+          __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+          __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
+          goto __pyx_L6_except_error;
+        }
+        __pyx_L17:;
+      }
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L5_exception_handled;
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/handles/stream.pyx":825
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_cb_total += 1
+ */
+    __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_L5_exception_handled:;
+    __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);
+    __pyx_L9_try_end:;
+  }
+
+  /* "uvloop/handles/stream.pyx":811
+ * 
+ * 
+ * cdef inline void __uv_stream_on_read_impl(uv.uv_stream_t* stream,             # <<<<<<<<<<<<<<
+ *                                           ssize_t nread,
+ *                                           const uv.uv_buf_t* buf):
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_WriteUnraisable("uvloop.loop.__uv_stream_on_read_impl", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sc);
+  __Pyx_XDECREF((PyObject *)__pyx_v_loop);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/handles/stream.pyx":841
+ * 
+ * 
+ * cdef inline void __uv_stream_on_write_impl(uv.uv_write_t* req, int status):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         _StreamWriteContext ctx = <_StreamWriteContext> req.data
+ */
+
+static CYTHON_INLINE void __pyx_f_6uvloop_4loop___uv_stream_on_write_impl(uv_write_t *__pyx_v_req, int __pyx_v_status) {
+  struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_ctx = 0;
+  struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_stream = 0;
+  PyObject *__pyx_v_exc = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_3 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_t_12;
+  char const *__pyx_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__uv_stream_on_write_impl", 0);
+
+  /* "uvloop/handles/stream.pyx":843
+ * cdef inline void __uv_stream_on_write_impl(uv.uv_write_t* req, int status):
+ *     cdef:
+ *         _StreamWriteContext ctx = <_StreamWriteContext> req.data             # <<<<<<<<<<<<<<
+ *         UVStream stream = <UVStream>ctx.stream
+ * 
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_req->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_ctx = ((struct __pyx_obj_6uvloop_4loop__StreamWriteContext *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":844
+ *     cdef:
+ *         _StreamWriteContext ctx = <_StreamWriteContext> req.data
+ *         UVStream stream = <UVStream>ctx.stream             # <<<<<<<<<<<<<<
+ * 
+ *     ctx.close()
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_ctx->stream);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_stream = ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":846
+ *         UVStream stream = <UVStream>ctx.stream
+ * 
+ *     ctx.close()             # <<<<<<<<<<<<<<
+ * 
+ *     if stream._closed:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *)__pyx_v_ctx->__pyx_vtab)->close(__pyx_v_ctx); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 846, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/stream.pyx":848
+ *     ctx.close()
+ * 
+ *     if stream._closed:             # <<<<<<<<<<<<<<
+ *         # The stream was closed, there is nothing to do.
+ *         # Even if there is an error, like EPIPE, there
+ */
+  __pyx_t_2 = (__pyx_v_stream->__pyx_base.__pyx_base.__pyx_base._closed != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/stream.pyx":852
+ *         # Even if there is an error, like EPIPE, there
+ *         # is no reason to report it.
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     if status < 0:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":848
+ *     ctx.close()
+ * 
+ *     if stream._closed:             # <<<<<<<<<<<<<<
+ *         # The stream was closed, there is nothing to do.
+ *         # Even if there is an error, like EPIPE, there
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":854
+ *         return
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_write_errors_total += 1
+ */
+  __pyx_t_2 = ((__pyx_v_status < 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/stream.pyx":855
+ * 
+ *     if status < 0:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             stream._loop._debug_stream_write_errors_total += 1
+ * 
+ */
+    __pyx_t_2 = (UVLOOP_DEBUG != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/handles/stream.pyx":856
+ *     if status < 0:
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_write_errors_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *         exc = convert_error(status)
+ */
+      __Pyx_INCREF(((PyObject *)__pyx_v_stream->__pyx_base.__pyx_base.__pyx_base._loop));
+      __pyx_t_3 = __pyx_v_stream->__pyx_base.__pyx_base.__pyx_base._loop;
+      __pyx_t_3->_debug_stream_write_errors_total = (__pyx_t_3->_debug_stream_write_errors_total + 1);
+      __Pyx_DECREF(((PyObject *)__pyx_t_3)); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/stream.pyx":855
+ * 
+ *     if status < 0:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             stream._loop._debug_stream_write_errors_total += 1
+ * 
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":858
+ *             stream._loop._debug_stream_write_errors_total += 1
+ * 
+ *         exc = convert_error(status)             # <<<<<<<<<<<<<<
+ *         stream._fatal_error(
+ *             exc, False, "error status in uv_stream_t.write callback")
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_status); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 858, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/stream.pyx":859
+ * 
+ *         exc = convert_error(status)
+ *         stream._fatal_error(             # <<<<<<<<<<<<<<
+ *             exc, False, "error status in uv_stream_t.write callback")
+ *         return
+ */
+    __pyx_t_4.__pyx_n = 1;
+    __pyx_t_4.reason = __pyx_kp_u_error_status_in_uv_stream_t_writ;
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_stream->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_stream), __pyx_v_exc, Py_False, &__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 859, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/stream.pyx":861
+ *         stream._fatal_error(
+ *             exc, False, "error status in uv_stream_t.write callback")
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":854
+ *         return
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_write_errors_total += 1
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":863
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         stream._on_write()
+ *     except BaseException as exc:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_7);
+    /*try:*/ {
+
+      /* "uvloop/handles/stream.pyx":864
+ * 
+ *     try:
+ *         stream._on_write()             # <<<<<<<<<<<<<<
+ *     except BaseException as exc:
+ *         if UVLOOP_DEBUG:
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop_8UVStream__on_write(__pyx_v_stream); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 864, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/stream.pyx":863
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         stream._on_write()
+ *     except BaseException as exc:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    goto __pyx_L11_try_end;
+    __pyx_L6_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(((PyObject *)__pyx_t_3)); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/stream.pyx":865
+ *     try:
+ *         stream._on_write()
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_write_cb_errors_total += 1
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("uvloop.loop.__uv_stream_on_write_impl", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_9, &__pyx_t_10) < 0) __PYX_ERR(18, 865, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_GOTREF(__pyx_t_10);
+      __Pyx_INCREF(__pyx_t_9);
+      __pyx_v_exc = __pyx_t_9;
+      /*try:*/ {
+
+        /* "uvloop/handles/stream.pyx":866
+ *         stream._on_write()
+ *     except BaseException as exc:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             stream._loop._debug_stream_write_cb_errors_total += 1
+ * 
+ */
+        __pyx_t_2 = (UVLOOP_DEBUG != 0);
+        if (__pyx_t_2) {
+
+          /* "uvloop/handles/stream.pyx":867
+ *     except BaseException as exc:
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_write_cb_errors_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *         stream._fatal_error(exc, False)
+ */
+          __Pyx_INCREF(((PyObject *)__pyx_v_stream->__pyx_base.__pyx_base.__pyx_base._loop));
+          __pyx_t_3 = __pyx_v_stream->__pyx_base.__pyx_base.__pyx_base._loop;
+          __pyx_t_3->_debug_stream_write_cb_errors_total = (__pyx_t_3->_debug_stream_write_cb_errors_total + 1);
+          __Pyx_DECREF(((PyObject *)__pyx_t_3)); __pyx_t_3 = 0;
+
+          /* "uvloop/handles/stream.pyx":866
+ *         stream._on_write()
+ *     except BaseException as exc:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             stream._loop._debug_stream_write_cb_errors_total += 1
+ * 
+ */
+        }
+
+        /* "uvloop/handles/stream.pyx":869
+ *             stream._loop._debug_stream_write_cb_errors_total += 1
+ * 
+ *         stream._fatal_error(exc, False)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+        __pyx_t_11 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_stream->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_stream), __pyx_v_exc, Py_False, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(18, 869, __pyx_L17_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      }
+
+      /* "uvloop/handles/stream.pyx":865
+ *     try:
+ *         stream._on_write()
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_write_cb_errors_total += 1
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L18;
+        }
+        __pyx_L17_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_XDECREF(((PyObject *)__pyx_t_3)); __pyx_t_3 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __pyx_t_8 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+          }
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+          __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+          __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13;
+          goto __pyx_L8_except_error;
+        }
+        __pyx_L18:;
+      }
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      goto __pyx_L7_exception_handled;
+    }
+    goto __pyx_L8_except_error;
+    __pyx_L8_except_error:;
+
+    /* "uvloop/handles/stream.pyx":863
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         stream._on_write()
+ *     except BaseException as exc:
+ */
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_7);
+    __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+    goto __pyx_L1_error;
+    __pyx_L7_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_7);
+    __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+    __pyx_L11_try_end:;
+  }
+
+  /* "uvloop/handles/stream.pyx":841
+ * 
+ * 
+ * cdef inline void __uv_stream_on_write_impl(uv.uv_write_t* req, int status):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         _StreamWriteContext ctx = <_StreamWriteContext> req.data
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(((PyObject *)__pyx_t_3));
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_WriteUnraisable("uvloop.loop.__uv_stream_on_write_impl", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_ctx);
+  __Pyx_XDECREF((PyObject *)__pyx_v_stream);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/handles/stream.pyx":872
+ * 
+ * 
+ * cdef void __uv_stream_on_read(uv.uv_stream_t* stream,             # <<<<<<<<<<<<<<
+ *                               ssize_t nread,
+ *                               const uv.uv_buf_t* buf) with gil:
+ */
+
+static void __pyx_f_6uvloop_4loop___uv_stream_on_read(uv_stream_t *__pyx_v_stream, Py_ssize_t __pyx_v_nread, uv_buf_t const *__pyx_v_buf) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uv_stream_on_read", 0);
+
+  /* "uvloop/handles/stream.pyx":877
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,
+ *                             "UVStream read callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_f_6uvloop_4loop___ensure_handle_data(((uv_handle_t *)__pyx_v_stream), ((char const *)"UVStream read callback")) == 0) != 0);
+
+  /* "uvloop/handles/stream.pyx":876
+ *                               const uv.uv_buf_t* buf) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,             # <<<<<<<<<<<<<<
+ *                             "UVStream read callback") == 0:
+ *         return
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":878
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,
+ *                             "UVStream read callback") == 0:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     # Don't need try-finally, __uv_stream_on_read_impl is void
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":876
+ *                               const uv.uv_buf_t* buf) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,             # <<<<<<<<<<<<<<
+ *                             "UVStream read callback") == 0:
+ *         return
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":881
+ * 
+ *     # Don't need try-finally, __uv_stream_on_read_impl is void
+ *     __uv_stream_on_read_impl(stream, nread, buf)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_f_6uvloop_4loop___uv_stream_on_read_impl(__pyx_v_stream, __pyx_v_nread, __pyx_v_buf);
+
+  /* "uvloop/handles/stream.pyx":872
+ * 
+ * 
+ * cdef void __uv_stream_on_read(uv.uv_stream_t* stream,             # <<<<<<<<<<<<<<
+ *                               ssize_t nread,
+ *                               const uv.uv_buf_t* buf) with gil:
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/stream.pyx":884
+ * 
+ * 
+ * cdef void __uv_stream_on_write(uv.uv_write_t* req, int status) with gil:             # <<<<<<<<<<<<<<
+ * 
+ *     if UVLOOP_DEBUG:
+ */
+
+static void __pyx_f_6uvloop_4loop___uv_stream_on_write(uv_write_t *__pyx_v_req, int __pyx_v_status) {
+  __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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uv_stream_on_write", 0);
+
+  /* "uvloop/handles/stream.pyx":886
+ * cdef void __uv_stream_on_write(uv.uv_write_t* req, int status) with gil:
+ * 
+ *     if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *         if req.data is NULL:
+ *             aio_logger.error(
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":887
+ * 
+ *     if UVLOOP_DEBUG:
+ *         if req.data is NULL:             # <<<<<<<<<<<<<<
+ *             aio_logger.error(
+ *                 'UVStream.write callback called with NULL req.data, status=%r',
+ */
+    __pyx_t_1 = ((__pyx_v_req->data == NULL) != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":888
+ *     if UVLOOP_DEBUG:
+ *         if req.data is NULL:
+ *             aio_logger.error(             # <<<<<<<<<<<<<<
+ *                 'UVStream.write callback called with NULL req.data, status=%r',
+ *                 status)
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 888, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+
+      /* "uvloop/handles/stream.pyx":890
+ *             aio_logger.error(
+ *                 'UVStream.write callback called with NULL req.data, status=%r',
+ *                 status)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 890, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      __pyx_t_6 = 0;
+      if (CYTHON_UNPACK_METHODS && 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_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_u_UVStream_write_callback_called_w, __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(18, 888, __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_u_UVStream_write_callback_called_w, __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(18, 888, __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
+      {
+        __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(18, 888, __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_u_UVStream_write_callback_called_w);
+        __Pyx_GIVEREF(__pyx_kp_u_UVStream_write_callback_called_w);
+        PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_u_UVStream_write_callback_called_w);
+        __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(18, 888, __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_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/stream.pyx":891
+ *                 'UVStream.write callback called with NULL req.data, status=%r',
+ *                 status)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *     # Don't need try-finally, __uv_stream_on_write_impl is void
+ */
+      goto __pyx_L0;
+
+      /* "uvloop/handles/stream.pyx":887
+ * 
+ *     if UVLOOP_DEBUG:
+ *         if req.data is NULL:             # <<<<<<<<<<<<<<
+ *             aio_logger.error(
+ *                 'UVStream.write callback called with NULL req.data, status=%r',
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":886
+ * cdef void __uv_stream_on_write(uv.uv_write_t* req, int status) with gil:
+ * 
+ *     if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *         if req.data is NULL:
+ *             aio_logger.error(
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":894
+ * 
+ *     # Don't need try-finally, __uv_stream_on_write_impl is void
+ *     __uv_stream_on_write_impl(req, status)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_f_6uvloop_4loop___uv_stream_on_write_impl(__pyx_v_req, __pyx_v_status);
+
+  /* "uvloop/handles/stream.pyx":884
+ * 
+ * 
+ * cdef void __uv_stream_on_write(uv.uv_write_t* req, int status) with gil:             # <<<<<<<<<<<<<<
+ * 
+ *     if UVLOOP_DEBUG:
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __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_7);
+  __Pyx_WriteUnraisable("uvloop.loop.__uv_stream_on_write", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/stream.pyx":897
+ * 
+ * 
+ * cdef void __uv_stream_buffered_alloc(uv.uv_handle_t* stream,             # <<<<<<<<<<<<<<
+ *                                      size_t suggested_size,
+ *                                      uv.uv_buf_t* uvbuf) with gil:
+ */
+
+static void __pyx_f_6uvloop_4loop___uv_stream_buffered_alloc(uv_handle_t *__pyx_v_stream, size_t __pyx_v_suggested_size, uv_buf_t *__pyx_v_uvbuf) {
+  struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_sc = 0;
+  CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  Py_buffer *__pyx_v_pybuf;
+  int __pyx_v_got_buf;
+  PyObject *__pyx_v_buf = NULL;
+  CYTHON_UNUSED PyObject *__pyx_v_exc = NULL;
+  __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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  Py_ssize_t __pyx_t_10;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uv_stream_buffered_alloc", 0);
+
+  /* "uvloop/handles/stream.pyx":902
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,
+ *                             "UVStream alloc buffer callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_f_6uvloop_4loop___ensure_handle_data(((uv_handle_t *)__pyx_v_stream), ((char const *)"UVStream alloc buffer callback")) == 0) != 0);
+
+  /* "uvloop/handles/stream.pyx":901
+ *                                      uv.uv_buf_t* uvbuf) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,             # <<<<<<<<<<<<<<
+ *                             "UVStream alloc buffer callback") == 0:
+ *         return
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":903
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,
+ *                             "UVStream alloc buffer callback") == 0:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":901
+ *                                      uv.uv_buf_t* uvbuf) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,             # <<<<<<<<<<<<<<
+ *                             "UVStream alloc buffer callback") == 0:
+ *         return
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":906
+ * 
+ *     cdef:
+ *         UVStream sc = <UVStream>stream.data             # <<<<<<<<<<<<<<
+ *         Loop loop = sc._loop
+ *         Py_buffer* pybuf = &sc._read_pybuf
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_stream->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_sc = ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/stream.pyx":907
+ *     cdef:
+ *         UVStream sc = <UVStream>stream.data
+ *         Loop loop = sc._loop             # <<<<<<<<<<<<<<
+ *         Py_buffer* pybuf = &sc._read_pybuf
+ *         int got_buf = 0
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_sc->__pyx_base.__pyx_base.__pyx_base._loop);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/stream.pyx":908
+ *         UVStream sc = <UVStream>stream.data
+ *         Loop loop = sc._loop
+ *         Py_buffer* pybuf = &sc._read_pybuf             # <<<<<<<<<<<<<<
+ *         int got_buf = 0
+ * 
+ */
+  __pyx_v_pybuf = (&__pyx_v_sc->_read_pybuf);
+
+  /* "uvloop/handles/stream.pyx":909
+ *         Loop loop = sc._loop
+ *         Py_buffer* pybuf = &sc._read_pybuf
+ *         int got_buf = 0             # <<<<<<<<<<<<<<
+ * 
+ *     if sc._read_pybuf_acquired:
+ */
+  __pyx_v_got_buf = 0;
+
+  /* "uvloop/handles/stream.pyx":911
+ *         int got_buf = 0
+ * 
+ *     if sc._read_pybuf_acquired:             # <<<<<<<<<<<<<<
+ *         uvbuf.len = 0
+ *         uvbuf.base = NULL
+ */
+  __pyx_t_1 = (__pyx_v_sc->_read_pybuf_acquired != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":912
+ * 
+ *     if sc._read_pybuf_acquired:
+ *         uvbuf.len = 0             # <<<<<<<<<<<<<<
+ *         uvbuf.base = NULL
+ *         return
+ */
+    __pyx_v_uvbuf->len = 0;
+
+    /* "uvloop/handles/stream.pyx":913
+ *     if sc._read_pybuf_acquired:
+ *         uvbuf.len = 0
+ *         uvbuf.base = NULL             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+    __pyx_v_uvbuf->base = NULL;
+
+    /* "uvloop/handles/stream.pyx":914
+ *         uvbuf.len = 0
+ *         uvbuf.base = NULL
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     sc._read_pybuf_acquired = 0
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":911
+ *         int got_buf = 0
+ * 
+ *     if sc._read_pybuf_acquired:             # <<<<<<<<<<<<<<
+ *         uvbuf.len = 0
+ *         uvbuf.base = NULL
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":916
+ *         return
+ * 
+ *     sc._read_pybuf_acquired = 0             # <<<<<<<<<<<<<<
+ *     try:
+ *         buf = run_in_context1(
+ */
+  __pyx_v_sc->_read_pybuf_acquired = 0;
+
+  /* "uvloop/handles/stream.pyx":917
+ * 
+ *     sc._read_pybuf_acquired = 0
+ *     try:             # <<<<<<<<<<<<<<
+ *         buf = run_in_context1(
+ *             sc.context,
+ */
+  {
+    __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:*/ {
+
+      /* "uvloop/handles/stream.pyx":919
+ *     try:
+ *         buf = run_in_context1(
+ *             sc.context,             # <<<<<<<<<<<<<<
+ *             sc._protocol_get_buffer,
+ *             suggested_size,
+ */
+      __pyx_t_2 = __pyx_v_sc->__pyx_base.__pyx_base.__pyx_base.context;
+      __Pyx_INCREF(__pyx_t_2);
+
+      /* "uvloop/handles/stream.pyx":920
+ *         buf = run_in_context1(
+ *             sc.context,
+ *             sc._protocol_get_buffer,             # <<<<<<<<<<<<<<
+ *             suggested_size,
+ *         )
+ */
+      __pyx_t_6 = __pyx_v_sc->_protocol_get_buffer;
+      __Pyx_INCREF(__pyx_t_6);
+
+      /* "uvloop/handles/stream.pyx":921
+ *             sc.context,
+ *             sc._protocol_get_buffer,
+ *             suggested_size,             # <<<<<<<<<<<<<<
+ *         )
+ *         PyObject_GetBuffer(buf, pybuf, PyBUF_WRITABLE)
+ */
+      __pyx_t_7 = __Pyx_PyInt_FromSize_t(__pyx_v_suggested_size); if (unlikely(!__pyx_t_7)) __PYX_ERR(18, 921, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "uvloop/handles/stream.pyx":918
+ *     sc._read_pybuf_acquired = 0
+ *     try:
+ *         buf = run_in_context1(             # <<<<<<<<<<<<<<
+ *             sc.context,
+ *             sc._protocol_get_buffer,
+ */
+      __pyx_t_8 = __pyx_f_6uvloop_4loop_run_in_context1(__pyx_t_2, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(18, 918, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __pyx_v_buf = __pyx_t_8;
+      __pyx_t_8 = 0;
+
+      /* "uvloop/handles/stream.pyx":923
+ *             suggested_size,
+ *         )
+ *         PyObject_GetBuffer(buf, pybuf, PyBUF_WRITABLE)             # <<<<<<<<<<<<<<
+ *         got_buf = 1
+ *     except BaseException as exc:
+ */
+      __pyx_t_9 = PyObject_GetBuffer(__pyx_v_buf, __pyx_v_pybuf, PyBUF_WRITABLE); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(18, 923, __pyx_L5_error)
+
+      /* "uvloop/handles/stream.pyx":924
+ *         )
+ *         PyObject_GetBuffer(buf, pybuf, PyBUF_WRITABLE)
+ *         got_buf = 1             # <<<<<<<<<<<<<<
+ *     except BaseException as exc:
+ *         # Can't call 'sc._fatal_error' or 'sc._close', libuv will SF.
+ */
+      __pyx_v_got_buf = 1;
+
+      /* "uvloop/handles/stream.pyx":917
+ * 
+ *     sc._read_pybuf_acquired = 0
+ *     try:             # <<<<<<<<<<<<<<
+ *         buf = run_in_context1(
+ *             sc.context,
+ */
+    }
+    __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_L10_try_end;
+    __pyx_L5_error:;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __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;
+
+    /* "uvloop/handles/stream.pyx":925
+ *         PyObject_GetBuffer(buf, pybuf, PyBUF_WRITABLE)
+ *         got_buf = 1
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         # Can't call 'sc._fatal_error' or 'sc._close', libuv will SF.
+ *         # We'll do it later in __uv_stream_buffered_on_read when we
+ */
+    __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_9) {
+      __Pyx_AddTraceback("uvloop.loop.__uv_stream_buffered_alloc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(18, 925, __pyx_L7_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_7);
+      __pyx_v_exc = __pyx_t_7;
+      /*try:*/ {
+
+        /* "uvloop/handles/stream.pyx":929
+ *         # We'll do it later in __uv_stream_buffered_on_read when we
+ *         # receive UV_ENOBUFS.
+ *         uvbuf.len = 0             # <<<<<<<<<<<<<<
+ *         uvbuf.base = NULL
+ *         return
+ */
+        __pyx_v_uvbuf->len = 0;
+
+        /* "uvloop/handles/stream.pyx":930
+ *         # receive UV_ENOBUFS.
+ *         uvbuf.len = 0
+ *         uvbuf.base = NULL             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+        __pyx_v_uvbuf->base = NULL;
+
+        /* "uvloop/handles/stream.pyx":931
+ *         uvbuf.len = 0
+ *         uvbuf.base = NULL
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     if not pybuf.len:
+ */
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        goto __pyx_L15_return;
+      }
+
+      /* "uvloop/handles/stream.pyx":925
+ *         PyObject_GetBuffer(buf, pybuf, PyBUF_WRITABLE)
+ *         got_buf = 1
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         # Can't call 'sc._fatal_error' or 'sc._close', libuv will SF.
+ *         # We'll do it later in __uv_stream_buffered_on_read when we
+ */
+      /*finally:*/ {
+        __pyx_L15_return: {
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L8_except_return;
+        }
+      }
+    }
+    goto __pyx_L7_except_error;
+    __pyx_L7_except_error:;
+
+    /* "uvloop/handles/stream.pyx":917
+ * 
+ *     sc._read_pybuf_acquired = 0
+ *     try:             # <<<<<<<<<<<<<<
+ *         buf = run_in_context1(
+ *             sc.context,
+ */
+    __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_L8_except_return:;
+    __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_L0;
+    __pyx_L10_try_end:;
+  }
+
+  /* "uvloop/handles/stream.pyx":933
+ *         return
+ * 
+ *     if not pybuf.len:             # <<<<<<<<<<<<<<
+ *         uvbuf.len = 0
+ *         uvbuf.base = NULL
+ */
+  __pyx_t_1 = ((!(__pyx_v_pybuf->len != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":934
+ * 
+ *     if not pybuf.len:
+ *         uvbuf.len = 0             # <<<<<<<<<<<<<<
+ *         uvbuf.base = NULL
+ *         if got_buf:
+ */
+    __pyx_v_uvbuf->len = 0;
+
+    /* "uvloop/handles/stream.pyx":935
+ *     if not pybuf.len:
+ *         uvbuf.len = 0
+ *         uvbuf.base = NULL             # <<<<<<<<<<<<<<
+ *         if got_buf:
+ *             PyBuffer_Release(pybuf)
+ */
+    __pyx_v_uvbuf->base = NULL;
+
+    /* "uvloop/handles/stream.pyx":936
+ *         uvbuf.len = 0
+ *         uvbuf.base = NULL
+ *         if got_buf:             # <<<<<<<<<<<<<<
+ *             PyBuffer_Release(pybuf)
+ *         return
+ */
+    __pyx_t_1 = (__pyx_v_got_buf != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/stream.pyx":937
+ *         uvbuf.base = NULL
+ *         if got_buf:
+ *             PyBuffer_Release(pybuf)             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+      PyBuffer_Release(__pyx_v_pybuf);
+
+      /* "uvloop/handles/stream.pyx":936
+ *         uvbuf.len = 0
+ *         uvbuf.base = NULL
+ *         if got_buf:             # <<<<<<<<<<<<<<
+ *             PyBuffer_Release(pybuf)
+ *         return
+ */
+    }
+
+    /* "uvloop/handles/stream.pyx":938
+ *         if got_buf:
+ *             PyBuffer_Release(pybuf)
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     sc._read_pybuf_acquired = 1
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":933
+ *         return
+ * 
+ *     if not pybuf.len:             # <<<<<<<<<<<<<<
+ *         uvbuf.len = 0
+ *         uvbuf.base = NULL
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":940
+ *         return
+ * 
+ *     sc._read_pybuf_acquired = 1             # <<<<<<<<<<<<<<
+ *     uvbuf.base = <char*>pybuf.buf
+ *     uvbuf.len = pybuf.len
+ */
+  __pyx_v_sc->_read_pybuf_acquired = 1;
+
+  /* "uvloop/handles/stream.pyx":941
+ * 
+ *     sc._read_pybuf_acquired = 1
+ *     uvbuf.base = <char*>pybuf.buf             # <<<<<<<<<<<<<<
+ *     uvbuf.len = pybuf.len
+ * 
+ */
+  __pyx_v_uvbuf->base = ((char *)__pyx_v_pybuf->buf);
+
+  /* "uvloop/handles/stream.pyx":942
+ *     sc._read_pybuf_acquired = 1
+ *     uvbuf.base = <char*>pybuf.buf
+ *     uvbuf.len = pybuf.len             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_10 = __pyx_v_pybuf->len;
+  __pyx_v_uvbuf->len = __pyx_t_10;
+
+  /* "uvloop/handles/stream.pyx":897
+ * 
+ * 
+ * cdef void __uv_stream_buffered_alloc(uv.uv_handle_t* stream,             # <<<<<<<<<<<<<<
+ *                                      size_t suggested_size,
+ *                                      uv.uv_buf_t* uvbuf) with gil:
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_WriteUnraisable("uvloop.loop.__uv_stream_buffered_alloc", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sc);
+  __Pyx_XDECREF((PyObject *)__pyx_v_loop);
+  __Pyx_XDECREF(__pyx_v_buf);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/stream.pyx":945
+ * 
+ * 
+ * cdef void __uv_stream_buffered_on_read(uv.uv_stream_t* stream,             # <<<<<<<<<<<<<<
+ *                                        ssize_t nread,
+ *                                        const uv.uv_buf_t* buf) with gil:
+ */
+
+static void __pyx_f_6uvloop_4loop___uv_stream_buffered_on_read(uv_stream_t *__pyx_v_stream, Py_ssize_t __pyx_v_nread, CYTHON_UNUSED uv_buf_t const *__pyx_v_buf) {
+  struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_sc = 0;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  Py_buffer *__pyx_v_pybuf;
+  PyObject *__pyx_v_exc = NULL;
+  __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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_t_10;
+  int __pyx_t_11;
+  char const *__pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  char const *__pyx_t_19;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uv_stream_buffered_on_read", 0);
+
+  /* "uvloop/handles/stream.pyx":950
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,
+ *                             "UVStream buffered read callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_f_6uvloop_4loop___ensure_handle_data(((uv_handle_t *)__pyx_v_stream), ((char const *)"UVStream buffered read callback")) == 0) != 0);
+
+  /* "uvloop/handles/stream.pyx":949
+ *                                        const uv.uv_buf_t* buf) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,             # <<<<<<<<<<<<<<
+ *                             "UVStream buffered read callback") == 0:
+ *         return
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":951
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,
+ *                             "UVStream buffered read callback") == 0:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":949
+ *                                        const uv.uv_buf_t* buf) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>stream,             # <<<<<<<<<<<<<<
+ *                             "UVStream buffered read callback") == 0:
+ *         return
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":954
+ * 
+ *     cdef:
+ *         UVStream sc = <UVStream>stream.data             # <<<<<<<<<<<<<<
+ *         Loop loop = sc._loop
+ *         Py_buffer* pybuf = &sc._read_pybuf
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_stream->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_sc = ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/stream.pyx":955
+ *     cdef:
+ *         UVStream sc = <UVStream>stream.data
+ *         Loop loop = sc._loop             # <<<<<<<<<<<<<<
+ *         Py_buffer* pybuf = &sc._read_pybuf
+ * 
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_sc->__pyx_base.__pyx_base.__pyx_base._loop);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/stream.pyx":956
+ *         UVStream sc = <UVStream>stream.data
+ *         Loop loop = sc._loop
+ *         Py_buffer* pybuf = &sc._read_pybuf             # <<<<<<<<<<<<<<
+ * 
+ *     if nread == uv.UV_ENOBUFS:
+ */
+  __pyx_v_pybuf = (&__pyx_v_sc->_read_pybuf);
+
+  /* "uvloop/handles/stream.pyx":958
+ *         Py_buffer* pybuf = &sc._read_pybuf
+ * 
+ *     if nread == uv.UV_ENOBUFS:             # <<<<<<<<<<<<<<
+ *         sc._fatal_error(
+ *             RuntimeError(
+ */
+  __pyx_t_1 = ((__pyx_v_nread == UV_ENOBUFS) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/stream.pyx":960
+ *     if nread == uv.UV_ENOBUFS:
+ *         sc._fatal_error(
+ *             RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'unhandled error (or an empty buffer) in get_buffer()'),
+ *             False)
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__156, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 960, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+
+    /* "uvloop/handles/stream.pyx":959
+ * 
+ *     if nread == uv.UV_ENOBUFS:
+ *         sc._fatal_error(             # <<<<<<<<<<<<<<
+ *             RuntimeError(
+ *                 'unhandled error (or an empty buffer) in get_buffer()'),
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_sc->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_sc), __pyx_t_2, Py_False, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 959, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/stream.pyx":963
+ *                 'unhandled error (or an empty buffer) in get_buffer()'),
+ *             False)
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/stream.pyx":958
+ *         Py_buffer* pybuf = &sc._read_pybuf
+ * 
+ *     if nread == uv.UV_ENOBUFS:             # <<<<<<<<<<<<<<
+ *         sc._fatal_error(
+ *             RuntimeError(
+ */
+  }
+
+  /* "uvloop/handles/stream.pyx":965
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if nread > 0 and not sc._read_pybuf_acquired:
+ *             # From libuv docs:
+ */
+  /*try:*/ {
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      /*try:*/ {
+
+        /* "uvloop/handles/stream.pyx":966
+ * 
+ *     try:
+ *         if nread > 0 and not sc._read_pybuf_acquired:             # <<<<<<<<<<<<<<
+ *             # From libuv docs:
+ *             #     nread is > 0 if there is data available or < 0 on error. When
+ */
+        __pyx_t_7 = ((__pyx_v_nread > 0) != 0);
+        if (__pyx_t_7) {
+        } else {
+          __pyx_t_1 = __pyx_t_7;
+          goto __pyx_L15_bool_binop_done;
+        }
+        __pyx_t_7 = ((!(__pyx_v_sc->_read_pybuf_acquired != 0)) != 0);
+        __pyx_t_1 = __pyx_t_7;
+        __pyx_L15_bool_binop_done:;
+        if (unlikely(__pyx_t_1)) {
+
+          /* "uvloop/handles/stream.pyx":973
+ *             #     buffer; in that case buf.len and buf.base are both set to 0.
+ *             raise RuntimeError(
+ *                 f'no python buffer is allocated in on_read; nread={nread}')             # <<<<<<<<<<<<<<
+ * 
+ *         if nread == 0:
+ */
+          __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_nread, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 973, __pyx_L8_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_no_python_buffer_is_allocated_in, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 973, __pyx_L8_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+          /* "uvloop/handles/stream.pyx":972
+ *             #     nread < 0, the buf parameter might not point to a valid
+ *             #     buffer; in that case buf.len and buf.base are both set to 0.
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 f'no python buffer is allocated in on_read; nread={nread}')
+ * 
+ */
+          __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 972, __pyx_L8_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __PYX_ERR(18, 972, __pyx_L8_error)
+
+          /* "uvloop/handles/stream.pyx":966
+ * 
+ *     try:
+ *         if nread > 0 and not sc._read_pybuf_acquired:             # <<<<<<<<<<<<<<
+ *             # From libuv docs:
+ *             #     nread is > 0 if there is data available or < 0 on error. When
+ */
+        }
+
+        /* "uvloop/handles/stream.pyx":975
+ *                 f'no python buffer is allocated in on_read; nread={nread}')
+ * 
+ *         if nread == 0:             # <<<<<<<<<<<<<<
+ *             # From libuv docs:
+ *             #     nread might be 0, which does not indicate an error or EOF.
+ */
+        __pyx_t_1 = ((__pyx_v_nread == 0) != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/handles/stream.pyx":979
+ *             #     nread might be 0, which does not indicate an error or EOF.
+ *             #     This is equivalent to EAGAIN or EWOULDBLOCK under read(2).
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if __uv_stream_on_read_common(sc, loop, nread):
+ */
+          goto __pyx_L12_try_return;
+
+          /* "uvloop/handles/stream.pyx":975
+ *                 f'no python buffer is allocated in on_read; nread={nread}')
+ * 
+ *         if nread == 0:             # <<<<<<<<<<<<<<
+ *             # From libuv docs:
+ *             #     nread might be 0, which does not indicate an error or EOF.
+ */
+        }
+
+        /* "uvloop/handles/stream.pyx":981
+ *             return
+ * 
+ *         if __uv_stream_on_read_common(sc, loop, nread):             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+        __pyx_t_1 = (__pyx_f_6uvloop_4loop___uv_stream_on_read_common(__pyx_v_sc, __pyx_v_loop, __pyx_v_nread) != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/handles/stream.pyx":982
+ * 
+ *         if __uv_stream_on_read_common(sc, loop, nread):
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if UVLOOP_DEBUG:
+ */
+          goto __pyx_L12_try_return;
+
+          /* "uvloop/handles/stream.pyx":981
+ *             return
+ * 
+ *         if __uv_stream_on_read_common(sc, loop, nread):             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+        }
+
+        /* "uvloop/handles/stream.pyx":984
+ *             return
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_stream_read_cb_total += 1
+ * 
+ */
+        __pyx_t_1 = (UVLOOP_DEBUG != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/handles/stream.pyx":985
+ * 
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_cb_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *         run_in_context1(sc.context, sc._protocol_buffer_updated, nread)
+ */
+          __pyx_v_loop->_debug_stream_read_cb_total = (__pyx_v_loop->_debug_stream_read_cb_total + 1);
+
+          /* "uvloop/handles/stream.pyx":984
+ *             return
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_stream_read_cb_total += 1
+ * 
+ */
+        }
+
+        /* "uvloop/handles/stream.pyx":987
+ *             loop._debug_stream_read_cb_total += 1
+ * 
+ *         run_in_context1(sc.context, sc._protocol_buffer_updated, nread)             # <<<<<<<<<<<<<<
+ *     except BaseException as exc:
+ *         if UVLOOP_DEBUG:
+ */
+        __pyx_t_3 = __pyx_v_sc->__pyx_base.__pyx_base.__pyx_base.context;
+        __Pyx_INCREF(__pyx_t_3);
+        __pyx_t_2 = __pyx_v_sc->_protocol_buffer_updated;
+        __Pyx_INCREF(__pyx_t_2);
+        __pyx_t_8 = PyInt_FromSsize_t(__pyx_v_nread); if (unlikely(!__pyx_t_8)) __PYX_ERR(18, 987, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __pyx_t_9 = __pyx_f_6uvloop_4loop_run_in_context1(__pyx_t_3, __pyx_t_2, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(18, 987, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        /* "uvloop/handles/stream.pyx":965
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if nread > 0 and not sc._read_pybuf_acquired:
+ *             # From libuv docs:
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L13_try_end;
+      __pyx_L8_error:;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/handles/stream.pyx":988
+ * 
+ *         run_in_context1(sc.context, sc._protocol_buffer_updated, nread)
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_cb_errors_total += 1
+ */
+      __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_10) {
+        __Pyx_AddTraceback("uvloop.loop.__uv_stream_buffered_on_read", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_8, &__pyx_t_2) < 0) __PYX_ERR(18, 988, __pyx_L10_except_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_8);
+        __pyx_v_exc = __pyx_t_8;
+        /*try:*/ {
+
+          /* "uvloop/handles/stream.pyx":989
+ *         run_in_context1(sc.context, sc._protocol_buffer_updated, nread)
+ *     except BaseException as exc:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_stream_read_cb_errors_total += 1
+ * 
+ */
+          __pyx_t_1 = (UVLOOP_DEBUG != 0);
+          if (__pyx_t_1) {
+
+            /* "uvloop/handles/stream.pyx":990
+ *     except BaseException as exc:
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_cb_errors_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *         sc._fatal_error(exc, False)
+ */
+            __pyx_v_loop->_debug_stream_read_cb_errors_total = (__pyx_v_loop->_debug_stream_read_cb_errors_total + 1);
+
+            /* "uvloop/handles/stream.pyx":989
+ *         run_in_context1(sc.context, sc._protocol_buffer_updated, nread)
+ *     except BaseException as exc:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             loop._debug_stream_read_cb_errors_total += 1
+ * 
+ */
+          }
+
+          /* "uvloop/handles/stream.pyx":992
+ *             loop._debug_stream_read_cb_errors_total += 1
+ * 
+ *         sc._fatal_error(exc, False)             # <<<<<<<<<<<<<<
+ *     finally:
+ *         sc._read_pybuf_acquired = 0
+ */
+          __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_sc->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_sc), __pyx_v_exc, Py_False, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 992, __pyx_L25_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        }
+
+        /* "uvloop/handles/stream.pyx":988
+ * 
+ *         run_in_context1(sc.context, sc._protocol_buffer_updated, nread)
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             loop._debug_stream_read_cb_errors_total += 1
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+            goto __pyx_L26;
+          }
+          __pyx_L25_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+            __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_13);
+            __Pyx_XGOTREF(__pyx_t_14);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __pyx_t_10 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_exc);
+              __pyx_v_exc = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_16);
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+            }
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+            __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+            __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12;
+            goto __pyx_L10_except_error;
+          }
+          __pyx_L26:;
+        }
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        goto __pyx_L9_exception_handled;
+      }
+      goto __pyx_L10_except_error;
+      __pyx_L10_except_error:;
+
+      /* "uvloop/handles/stream.pyx":965
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if nread > 0 and not sc._read_pybuf_acquired:
+ *             # From libuv docs:
+ */
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      goto __pyx_L6_error;
+      __pyx_L12_try_return:;
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      goto __pyx_L5_return;
+      __pyx_L9_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      __pyx_L13_try_end:;
+    }
+  }
+
+  /* "uvloop/handles/stream.pyx":994
+ *         sc._fatal_error(exc, False)
+ *     finally:
+ *         sc._read_pybuf_acquired = 0             # <<<<<<<<<<<<<<
+ *         PyBuffer_Release(pybuf)
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_v_sc->_read_pybuf_acquired = 0;
+
+      /* "uvloop/handles/stream.pyx":995
+ *     finally:
+ *         sc._read_pybuf_acquired = 0
+ *         PyBuffer_Release(pybuf)             # <<<<<<<<<<<<<<
+ */
+      PyBuffer_Release(__pyx_v_pybuf);
+      goto __pyx_L7;
+    }
+    __pyx_L6_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4) < 0)) __Pyx_ErrFetch(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_18);
+      __Pyx_XGOTREF(__pyx_t_17);
+      __Pyx_XGOTREF(__pyx_t_16);
+      __pyx_t_11 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_19 = __pyx_filename;
+      {
+
+        /* "uvloop/handles/stream.pyx":994
+ *         sc._fatal_error(exc, False)
+ *     finally:
+ *         sc._read_pybuf_acquired = 0             # <<<<<<<<<<<<<<
+ *         PyBuffer_Release(pybuf)
+ */
+        __pyx_v_sc->_read_pybuf_acquired = 0;
+
+        /* "uvloop/handles/stream.pyx":995
+ *     finally:
+ *         sc._read_pybuf_acquired = 0
+ *         PyBuffer_Release(pybuf)             # <<<<<<<<<<<<<<
+ */
+        PyBuffer_Release(__pyx_v_pybuf);
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_18);
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_17, __pyx_t_16);
+      }
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ErrRestore(__pyx_t_6, __pyx_t_5, __pyx_t_4);
+      __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0;
+      __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_19;
+      goto __pyx_L1_error;
+    }
+    __pyx_L5_return: {
+
+      /* "uvloop/handles/stream.pyx":994
+ *         sc._fatal_error(exc, False)
+ *     finally:
+ *         sc._read_pybuf_acquired = 0             # <<<<<<<<<<<<<<
+ *         PyBuffer_Release(pybuf)
+ */
+      __pyx_v_sc->_read_pybuf_acquired = 0;
+
+      /* "uvloop/handles/stream.pyx":995
+ *     finally:
+ *         sc._read_pybuf_acquired = 0
+ *         PyBuffer_Release(pybuf)             # <<<<<<<<<<<<<<
+ */
+      PyBuffer_Release(__pyx_v_pybuf);
+      goto __pyx_L0;
+    }
+    __pyx_L7:;
+  }
+
+  /* "uvloop/handles/stream.pyx":945
+ * 
+ * 
+ * cdef void __uv_stream_buffered_on_read(uv.uv_stream_t* stream,             # <<<<<<<<<<<<<<
+ *                                        ssize_t nread,
+ *                                        const uv.uv_buf_t* buf) with gil:
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_WriteUnraisable("uvloop.loop.__uv_stream_buffered_on_read", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sc);
+  __Pyx_XDECREF((PyObject *)__pyx_v_loop);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/streamserver.pyx":4
+ * cdef class UVStreamServer(UVSocketHandle):
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.opened = 0
+ *         self._server = None
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_14UVStreamServer_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_14UVStreamServer_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_6uvloop_4loop_14UVStreamServer___cinit__(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_14UVStreamServer___cinit__(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "uvloop/handles/streamserver.pyx":5
+ * 
+ *     def __cinit__(self):
+ *         self.opened = 0             # <<<<<<<<<<<<<<
+ *         self._server = None
+ *         self.ssl = None
+ */
+  __pyx_v_self->opened = 0;
+
+  /* "uvloop/handles/streamserver.pyx":6
+ *     def __cinit__(self):
+ *         self.opened = 0
+ *         self._server = None             # <<<<<<<<<<<<<<
+ *         self.ssl = None
+ *         self.ssl_handshake_timeout = None
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_server);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_server));
+  __pyx_v_self->_server = ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None);
+
+  /* "uvloop/handles/streamserver.pyx":7
+ *         self.opened = 0
+ *         self._server = None
+ *         self.ssl = None             # <<<<<<<<<<<<<<
+ *         self.ssl_handshake_timeout = None
+ *         self.ssl_shutdown_timeout = None
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->ssl);
+  __Pyx_DECREF(__pyx_v_self->ssl);
+  __pyx_v_self->ssl = Py_None;
+
+  /* "uvloop/handles/streamserver.pyx":8
+ *         self._server = None
+ *         self.ssl = None
+ *         self.ssl_handshake_timeout = None             # <<<<<<<<<<<<<<
+ *         self.ssl_shutdown_timeout = None
+ *         self.protocol_factory = None
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->ssl_handshake_timeout);
+  __Pyx_DECREF(__pyx_v_self->ssl_handshake_timeout);
+  __pyx_v_self->ssl_handshake_timeout = Py_None;
+
+  /* "uvloop/handles/streamserver.pyx":9
+ *         self.ssl = None
+ *         self.ssl_handshake_timeout = None
+ *         self.ssl_shutdown_timeout = None             # <<<<<<<<<<<<<<
+ *         self.protocol_factory = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->ssl_shutdown_timeout);
+  __Pyx_DECREF(__pyx_v_self->ssl_shutdown_timeout);
+  __pyx_v_self->ssl_shutdown_timeout = Py_None;
+
+  /* "uvloop/handles/streamserver.pyx":10
+ *         self.ssl_handshake_timeout = None
+ *         self.ssl_shutdown_timeout = None
+ *         self.protocol_factory = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _init(self, Loop loop, object protocol_factory,
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->protocol_factory);
+  __Pyx_DECREF(__pyx_v_self->protocol_factory);
+  __pyx_v_self->protocol_factory = Py_None;
+
+  /* "uvloop/handles/streamserver.pyx":4
+ * cdef class UVStreamServer(UVSocketHandle):
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.opened = 0
+ *         self._server = None
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/streamserver.pyx":12
+ *         self.protocol_factory = None
+ * 
+ *     cdef inline _init(self, Loop loop, object protocol_factory,             # <<<<<<<<<<<<<<
+ *                       Server server,
+ *                       object backlog,
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__init(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol_factory, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_backlog, PyObject *__pyx_v_ssl, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init", 0);
+
+  /* "uvloop/handles/streamserver.pyx":19
+ *                       object ssl_shutdown_timeout):
+ * 
+ *         if not isinstance(backlog, int):             # <<<<<<<<<<<<<<
+ *             # Don't allow floats
+ *             raise TypeError('integer argument expected, got {}'.format(
+ */
+  __pyx_t_1 = PyInt_Check(__pyx_v_backlog); 
+  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/streamserver.pyx":21
+ *         if not isinstance(backlog, int):
+ *             # Don't allow floats
+ *             raise TypeError('integer argument expected, got {}'.format(             # <<<<<<<<<<<<<<
+ *                 type(backlog).__name__))
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_integer_argument_expected_got, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "uvloop/handles/streamserver.pyx":22
+ *             # Don't allow floats
+ *             raise TypeError('integer argument expected, got {}'.format(
+ *                 type(backlog).__name__))             # <<<<<<<<<<<<<<
+ * 
+ *         if ssl is not None:
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_backlog)), __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 22, __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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __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(19, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":21
+ *         if not isinstance(backlog, int):
+ *             # Don't allow floats
+ *             raise TypeError('integer argument expected, got {}'.format(             # <<<<<<<<<<<<<<
+ *                 type(backlog).__name__))
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(19, 21, __pyx_L1_error)
+
+    /* "uvloop/handles/streamserver.pyx":19
+ *                       object ssl_shutdown_timeout):
+ * 
+ *         if not isinstance(backlog, int):             # <<<<<<<<<<<<<<
+ *             # Don't allow floats
+ *             raise TypeError('integer argument expected, got {}'.format(
+ */
+  }
+
+  /* "uvloop/handles/streamserver.pyx":24
+ *                 type(backlog).__name__))
+ * 
+ *         if ssl is not None:             # <<<<<<<<<<<<<<
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError(
+ */
+  __pyx_t_2 = (__pyx_v_ssl != Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/streamserver.pyx":25
+ * 
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):             # <<<<<<<<<<<<<<
+ *                 raise TypeError(
+ *                     'ssl is expected to be None or an instance of '
+ */
+    __pyx_t_4 = __pyx_v_6uvloop_4loop_ssl_SSLContext;
+    __Pyx_INCREF(__pyx_t_4);
+    __pyx_t_1 = PyObject_IsInstance(__pyx_v_ssl, __pyx_t_4); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 25, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/handles/streamserver.pyx":28
+ *                 raise TypeError(
+ *                     'ssl is expected to be None or an instance of '
+ *                     'ssl.SSLContext, got {!r}'.format(ssl))             # <<<<<<<<<<<<<<
+ *         else:
+ *             if ssl_handshake_timeout is not None:
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_ssl_is_expected_to_be_None_or_an, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 28, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3, function);
+        }
+      }
+      __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_v_ssl) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_ssl);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 28, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/streamserver.pyx":26
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError(             # <<<<<<<<<<<<<<
+ *                     'ssl is expected to be None or an instance of '
+ *                     'ssl.SSLContext, got {!r}'.format(ssl))
+ */
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 26, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(19, 26, __pyx_L1_error)
+
+      /* "uvloop/handles/streamserver.pyx":25
+ * 
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):             # <<<<<<<<<<<<<<
+ *                 raise TypeError(
+ *                     'ssl is expected to be None or an instance of '
+ */
+    }
+
+    /* "uvloop/handles/streamserver.pyx":24
+ *                 type(backlog).__name__))
+ * 
+ *         if ssl is not None:             # <<<<<<<<<<<<<<
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError(
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/handles/streamserver.pyx":30
+ *                     'ssl.SSLContext, got {!r}'.format(ssl))
+ *         else:
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+  /*else*/ {
+    __pyx_t_2 = (__pyx_v_ssl_handshake_timeout != Py_None);
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/handles/streamserver.pyx":31
+ *         else:
+ *             if ssl_handshake_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 31, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(19, 31, __pyx_L1_error)
+
+      /* "uvloop/handles/streamserver.pyx":30
+ *                     'ssl.SSLContext, got {!r}'.format(ssl))
+ *         else:
+ *             if ssl_handshake_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ */
+    }
+
+    /* "uvloop/handles/streamserver.pyx":33
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    __pyx_t_1 = (__pyx_v_ssl_shutdown_timeout != Py_None);
+    __pyx_t_2 = (__pyx_t_1 != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/handles/streamserver.pyx":34
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 34, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(19, 34, __pyx_L1_error)
+
+      /* "uvloop/handles/streamserver.pyx":33
+ *                 raise ValueError(
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ */
+    }
+  }
+  __pyx_L4:;
+
+  /* "uvloop/handles/streamserver.pyx":37
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ *         self.backlog = backlog             # <<<<<<<<<<<<<<
+ *         self.ssl = ssl
+ *         self.ssl_handshake_timeout = ssl_handshake_timeout
+ */
+  __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_backlog); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(19, 37, __pyx_L1_error)
+  __pyx_v_self->backlog = __pyx_t_7;
+
+  /* "uvloop/handles/streamserver.pyx":38
+ * 
+ *         self.backlog = backlog
+ *         self.ssl = ssl             # <<<<<<<<<<<<<<
+ *         self.ssl_handshake_timeout = ssl_handshake_timeout
+ *         self.ssl_shutdown_timeout = ssl_shutdown_timeout
+ */
+  __Pyx_INCREF(__pyx_v_ssl);
+  __Pyx_GIVEREF(__pyx_v_ssl);
+  __Pyx_GOTREF(__pyx_v_self->ssl);
+  __Pyx_DECREF(__pyx_v_self->ssl);
+  __pyx_v_self->ssl = __pyx_v_ssl;
+
+  /* "uvloop/handles/streamserver.pyx":39
+ *         self.backlog = backlog
+ *         self.ssl = ssl
+ *         self.ssl_handshake_timeout = ssl_handshake_timeout             # <<<<<<<<<<<<<<
+ *         self.ssl_shutdown_timeout = ssl_shutdown_timeout
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_ssl_handshake_timeout);
+  __Pyx_GIVEREF(__pyx_v_ssl_handshake_timeout);
+  __Pyx_GOTREF(__pyx_v_self->ssl_handshake_timeout);
+  __Pyx_DECREF(__pyx_v_self->ssl_handshake_timeout);
+  __pyx_v_self->ssl_handshake_timeout = __pyx_v_ssl_handshake_timeout;
+
+  /* "uvloop/handles/streamserver.pyx":40
+ *         self.ssl = ssl
+ *         self.ssl_handshake_timeout = ssl_handshake_timeout
+ *         self.ssl_shutdown_timeout = ssl_shutdown_timeout             # <<<<<<<<<<<<<<
+ * 
+ *         self._start_init(loop)
+ */
+  __Pyx_INCREF(__pyx_v_ssl_shutdown_timeout);
+  __Pyx_GIVEREF(__pyx_v_ssl_shutdown_timeout);
+  __Pyx_GOTREF(__pyx_v_self->ssl_shutdown_timeout);
+  __Pyx_DECREF(__pyx_v_self->ssl_shutdown_timeout);
+  __pyx_v_self->ssl_shutdown_timeout = __pyx_v_ssl_shutdown_timeout;
+
+  /* "uvloop/handles/streamserver.pyx":42
+ *         self.ssl_shutdown_timeout = ssl_shutdown_timeout
+ * 
+ *         self._start_init(loop)             # <<<<<<<<<<<<<<
+ *         self.protocol_factory = protocol_factory
+ *         self._server = server
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._start_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_loop); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/streamserver.pyx":43
+ * 
+ *         self._start_init(loop)
+ *         self.protocol_factory = protocol_factory             # <<<<<<<<<<<<<<
+ *         self._server = server
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_protocol_factory);
+  __Pyx_GIVEREF(__pyx_v_protocol_factory);
+  __Pyx_GOTREF(__pyx_v_self->protocol_factory);
+  __Pyx_DECREF(__pyx_v_self->protocol_factory);
+  __pyx_v_self->protocol_factory = __pyx_v_protocol_factory;
+
+  /* "uvloop/handles/streamserver.pyx":44
+ *         self._start_init(loop)
+ *         self.protocol_factory = protocol_factory
+ *         self._server = server             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline listen(self):
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_server));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_server));
+  __Pyx_GOTREF(__pyx_v_self->_server);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_server));
+  __pyx_v_self->_server = __pyx_v_server;
+
+  /* "uvloop/handles/streamserver.pyx":12
+ *         self.protocol_factory = None
+ * 
+ *     cdef inline _init(self, Loop loop, object protocol_factory,             # <<<<<<<<<<<<<<
+ *                       Server server,
+ *                       object backlog,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.UVStreamServer._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/streamserver.pyx":46
+ *         self._server = server
+ * 
+ *     cdef inline listen(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         self._ensure_alive()
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer_listen(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("listen", 0);
+
+  /* "uvloop/handles/streamserver.pyx":48
+ *     cdef inline listen(self):
+ *         cdef int err
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         if self.protocol_factory is None:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/streamserver.pyx":50
+ *         self._ensure_alive()
+ * 
+ *         if self.protocol_factory is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('unable to listen(); no protocol_factory')
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_self->protocol_factory == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/handles/streamserver.pyx":51
+ * 
+ *         if self.protocol_factory is None:
+ *             raise RuntimeError('unable to listen(); no protocol_factory')             # <<<<<<<<<<<<<<
+ * 
+ *         if self.opened != 1:
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__157, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 51, __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(19, 51, __pyx_L1_error)
+
+    /* "uvloop/handles/streamserver.pyx":50
+ *         self._ensure_alive()
+ * 
+ *         if self.protocol_factory is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('unable to listen(); no protocol_factory')
+ * 
+ */
+  }
+
+  /* "uvloop/handles/streamserver.pyx":53
+ *             raise RuntimeError('unable to listen(); no protocol_factory')
+ * 
+ *         if self.opened != 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('unopened TCPServer')
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_self->opened != 1) != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/handles/streamserver.pyx":54
+ * 
+ *         if self.opened != 1:
+ *             raise RuntimeError('unopened TCPServer')             # <<<<<<<<<<<<<<
+ * 
+ *         self.context = Context_CopyCurrent()
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__158, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 54, __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(19, 54, __pyx_L1_error)
+
+    /* "uvloop/handles/streamserver.pyx":53
+ *             raise RuntimeError('unable to listen(); no protocol_factory')
+ * 
+ *         if self.opened != 1:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('unopened TCPServer')
+ * 
+ */
+  }
+
+  /* "uvloop/handles/streamserver.pyx":56
+ *             raise RuntimeError('unopened TCPServer')
+ * 
+ *         self.context = Context_CopyCurrent()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_listen(<uv.uv_stream_t*> self._handle,
+ */
+  __pyx_t_1 = Context_CopyCurrent(); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->__pyx_base.__pyx_base.context);
+  __Pyx_DECREF(__pyx_v_self->__pyx_base.__pyx_base.context);
+  __pyx_v_self->__pyx_base.__pyx_base.context = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/streamserver.pyx":58
+ *         self.context = Context_CopyCurrent()
+ * 
+ *         err = uv.uv_listen(<uv.uv_stream_t*> self._handle,             # <<<<<<<<<<<<<<
+ *                            self.backlog,
+ *                            __uv_streamserver_on_listen)
+ */
+  __pyx_v_err = uv_listen(((uv_stream_t *)__pyx_v_self->__pyx_base.__pyx_base._handle), __pyx_v_self->backlog, __pyx_f_6uvloop_4loop___uv_streamserver_on_listen);
+
+  /* "uvloop/handles/streamserver.pyx":61
+ *                            self.backlog,
+ *                            __uv_streamserver_on_listen)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  __pyx_t_3 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/streamserver.pyx":62
+ *                            __uv_streamserver_on_listen)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 62, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":63
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 63, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":64
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _on_listen(self):
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/streamserver.pyx":61
+ *                            self.backlog,
+ *                            __uv_streamserver_on_listen)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  }
+
+  /* "uvloop/handles/streamserver.pyx":46
+ *         self._server = server
+ * 
+ *     cdef inline listen(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         self._ensure_alive()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStreamServer.listen", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/streamserver.pyx":66
+ *             return
+ * 
+ *     cdef inline _on_listen(self):             # <<<<<<<<<<<<<<
+ *         cdef UVStream client
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__on_listen(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self) {
+  struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_client = 0;
+  PyObject *__pyx_v_protocol = NULL;
+  PyObject *__pyx_v_waiter = NULL;
+  struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_ssl_protocol = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_listen", 0);
+
+  /* "uvloop/handles/streamserver.pyx":69
+ *         cdef UVStream client
+ * 
+ *         protocol = run_in_context(self.context, self.protocol_factory)             # <<<<<<<<<<<<<<
+ * 
+ *         if self.ssl is None:
+ */
+  __pyx_t_1 = __pyx_v_self->__pyx_base.__pyx_base.context;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_self->protocol_factory;
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_run_in_context(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 69, __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;
+  __pyx_v_protocol = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/handles/streamserver.pyx":71
+ *         protocol = run_in_context(self.context, self.protocol_factory)
+ * 
+ *         if self.ssl is None:             # <<<<<<<<<<<<<<
+ *             client = self._make_new_transport(protocol, None, self.context)
+ * 
+ */
+  __pyx_t_4 = (__pyx_v_self->ssl == Py_None);
+  __pyx_t_5 = (__pyx_t_4 != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/handles/streamserver.pyx":72
+ * 
+ *         if self.ssl is None:
+ *             client = self._make_new_transport(protocol, None, self.context)             # <<<<<<<<<<<<<<
+ * 
+ *         else:
+ */
+    __pyx_t_3 = __pyx_v_self->__pyx_base.__pyx_base.context;
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_2 = ((PyObject *)((struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_make_new_transport(__pyx_v_self, __pyx_v_protocol, Py_None, __pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 72, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_client = ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":71
+ *         protocol = run_in_context(self.context, self.protocol_factory)
+ * 
+ *         if self.ssl is None:             # <<<<<<<<<<<<<<
+ *             client = self._make_new_transport(protocol, None, self.context)
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/streamserver.pyx":75
+ * 
+ *         else:
+ *             waiter = self._loop._new_future()             # <<<<<<<<<<<<<<
+ * 
+ *             ssl_protocol = SSLProtocol(
+ */
+  /*else*/ {
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self->__pyx_base.__pyx_base._loop); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 75, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_waiter = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":77
+ *             waiter = self._loop._new_future()
+ * 
+ *             ssl_protocol = SSLProtocol(             # <<<<<<<<<<<<<<
+ *                 self._loop, protocol, self.ssl,
+ *                 waiter,
+ */
+    __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 77, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop));
+    PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop));
+    __Pyx_INCREF(__pyx_v_protocol);
+    __Pyx_GIVEREF(__pyx_v_protocol);
+    PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_protocol);
+    __Pyx_INCREF(__pyx_v_self->ssl);
+    __Pyx_GIVEREF(__pyx_v_self->ssl);
+    PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_self->ssl);
+    __Pyx_INCREF(__pyx_v_waiter);
+    __Pyx_GIVEREF(__pyx_v_waiter);
+    PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_v_waiter);
+
+    /* "uvloop/handles/streamserver.pyx":80
+ *                 self._loop, protocol, self.ssl,
+ *                 waiter,
+ *                 server_side=True,             # <<<<<<<<<<<<<<
+ *                 server_hostname=None,
+ *                 ssl_handshake_timeout=self.ssl_handshake_timeout,
+ */
+    __pyx_t_3 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 80, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_server_side, Py_True) < 0) __PYX_ERR(19, 80, __pyx_L1_error)
+
+    /* "uvloop/handles/streamserver.pyx":81
+ *                 waiter,
+ *                 server_side=True,
+ *                 server_hostname=None,             # <<<<<<<<<<<<<<
+ *                 ssl_handshake_timeout=self.ssl_handshake_timeout,
+ *                 ssl_shutdown_timeout=self.ssl_shutdown_timeout)
+ */
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_server_hostname, Py_None) < 0) __PYX_ERR(19, 80, __pyx_L1_error)
+
+    /* "uvloop/handles/streamserver.pyx":82
+ *                 server_side=True,
+ *                 server_hostname=None,
+ *                 ssl_handshake_timeout=self.ssl_handshake_timeout,             # <<<<<<<<<<<<<<
+ *                 ssl_shutdown_timeout=self.ssl_shutdown_timeout)
+ * 
+ */
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_ssl_handshake_timeout, __pyx_v_self->ssl_handshake_timeout) < 0) __PYX_ERR(19, 80, __pyx_L1_error)
+
+    /* "uvloop/handles/streamserver.pyx":83
+ *                 server_hostname=None,
+ *                 ssl_handshake_timeout=self.ssl_handshake_timeout,
+ *                 ssl_shutdown_timeout=self.ssl_shutdown_timeout)             # <<<<<<<<<<<<<<
+ * 
+ *             client = self._make_new_transport(ssl_protocol, None, self.context)
+ */
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_ssl_shutdown_timeout, __pyx_v_self->ssl_shutdown_timeout) < 0) __PYX_ERR(19, 80, __pyx_L1_error)
+
+    /* "uvloop/handles/streamserver.pyx":77
+ *             waiter = self._loop._new_future()
+ * 
+ *             ssl_protocol = SSLProtocol(             # <<<<<<<<<<<<<<
+ *                 self._loop, protocol, self.ssl,
+ *                 waiter,
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_SSLProtocol), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 77, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_ssl_protocol = ((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":85
+ *                 ssl_shutdown_timeout=self.ssl_shutdown_timeout)
+ * 
+ *             client = self._make_new_transport(ssl_protocol, None, self.context)             # <<<<<<<<<<<<<<
+ * 
+ *             waiter.add_done_callback(
+ */
+    __pyx_t_1 = __pyx_v_self->__pyx_base.__pyx_base.context;
+    __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_3 = ((PyObject *)((struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_make_new_transport(__pyx_v_self, ((PyObject *)__pyx_v_ssl_protocol), Py_None, __pyx_t_1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_v_client = ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":87
+ *             client = self._make_new_transport(ssl_protocol, None, self.context)
+ * 
+ *             waiter.add_done_callback(             # <<<<<<<<<<<<<<
+ *                 ft_partial(self.__on_ssl_connected, client))
+ * 
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_add_done_callback); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 87, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+
+    /* "uvloop/handles/streamserver.pyx":88
+ * 
+ *             waiter.add_done_callback(
+ *                 ft_partial(self.__on_ssl_connected, client))             # <<<<<<<<<<<<<<
+ * 
+ *         client._accept(<UVStream>self)
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_on_ssl_connected); if (unlikely(!__pyx_t_6)) __PYX_ERR(19, 88, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_ft_partial);
+    __pyx_t_7 = __pyx_v_6uvloop_4loop_ft_partial; __pyx_t_8 = NULL;
+    __pyx_t_9 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+        __pyx_t_9 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_7)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, ((PyObject *)__pyx_v_client)};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 88, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, ((PyObject *)__pyx_v_client)};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 88, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(19, 88, __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_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6);
+      __Pyx_INCREF(((PyObject *)__pyx_v_client));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_client));
+      PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, ((PyObject *)__pyx_v_client));
+      __pyx_t_6 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 88, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_7, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2);
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 87, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/streamserver.pyx":90
+ *                 ft_partial(self.__on_ssl_connected, client))
+ * 
+ *         client._accept(<UVStream>self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop_8UVStream__accept(__pyx_v_client, ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/streamserver.pyx":66
+ *             return
+ * 
+ *     cdef inline _on_listen(self):             # <<<<<<<<<<<<<<
+ *         cdef UVStream client
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("uvloop.loop.UVStreamServer._on_listen", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_client);
+  __Pyx_XDECREF(__pyx_v_protocol);
+  __Pyx_XDECREF(__pyx_v_waiter);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ssl_protocol);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/streamserver.pyx":92
+ *         client._accept(<UVStream>self)
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):             # <<<<<<<<<<<<<<
+ *         # Overload UVHandle._fatal_error
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__fatal_error(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_14UVStreamServer__fatal_error *__pyx_optional_args) {
+  PyObject *__pyx_v_reason = ((PyObject *)Py_None);
+  PyObject *__pyx_v_msg = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  Py_ssize_t __pyx_t_6;
+  Py_UCS4 __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_fatal_error", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_reason = __pyx_optional_args->reason;
+    }
+  }
+
+  /* "uvloop/handles/streamserver.pyx":95
+ *         # Overload UVHandle._fatal_error
+ * 
+ *         self._close()             # <<<<<<<<<<<<<<
+ * 
+ *         if not isinstance(exc, OSError):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/streamserver.pyx":97
+ *         self._close()
+ * 
+ *         if not isinstance(exc, OSError):             # <<<<<<<<<<<<<<
+ * 
+ *             if throw or self._loop is None:
+ */
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_exc, __pyx_builtin_OSError); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 97, __pyx_L1_error)
+  __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/streamserver.pyx":99
+ *         if not isinstance(exc, OSError):
+ * 
+ *             if throw or self._loop is None:             # <<<<<<<<<<<<<<
+ *                 raise exc
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_throw); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(19, 99, __pyx_L1_error)
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_3 = __pyx_t_2;
+      goto __pyx_L5_bool_binop_done;
+    }
+    __pyx_t_2 = (((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop) == Py_None);
+    __pyx_t_4 = (__pyx_t_2 != 0);
+    __pyx_t_3 = __pyx_t_4;
+    __pyx_L5_bool_binop_done:;
+    if (unlikely(__pyx_t_3)) {
+
+      /* "uvloop/handles/streamserver.pyx":100
+ * 
+ *             if throw or self._loop is None:
+ *                 raise exc             # <<<<<<<<<<<<<<
+ * 
+ *             msg = f'Fatal error on server {self.__class__.__name__}'
+ */
+      __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+      __PYX_ERR(19, 100, __pyx_L1_error)
+
+      /* "uvloop/handles/streamserver.pyx":99
+ *         if not isinstance(exc, OSError):
+ * 
+ *             if throw or self._loop is None:             # <<<<<<<<<<<<<<
+ *                 raise exc
+ * 
+ */
+    }
+
+    /* "uvloop/handles/streamserver.pyx":102
+ *                 raise exc
+ * 
+ *             msg = f'Fatal error on server {self.__class__.__name__}'             # <<<<<<<<<<<<<<
+ *             if reason is not None:
+ *                 msg = f'{msg} ({reason})'
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 102, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 102, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 102, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Fatal_error_on_server, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 102, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_v_msg = ((PyObject*)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":103
+ * 
+ *             msg = f'Fatal error on server {self.__class__.__name__}'
+ *             if reason is not None:             # <<<<<<<<<<<<<<
+ *                 msg = f'{msg} ({reason})'
+ * 
+ */
+    __pyx_t_3 = (__pyx_v_reason != Py_None);
+    __pyx_t_4 = (__pyx_t_3 != 0);
+    if (__pyx_t_4) {
+
+      /* "uvloop/handles/streamserver.pyx":104
+ *             msg = f'Fatal error on server {self.__class__.__name__}'
+ *             if reason is not None:
+ *                 msg = f'{msg} ({reason})'             # <<<<<<<<<<<<<<
+ * 
+ *             self._loop.call_exception_handler({
+ */
+      __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 104, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_6 = 0;
+      __pyx_t_7 = 127;
+      __Pyx_INCREF(__pyx_v_msg);
+      __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_v_msg) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_v_msg) : __pyx_t_7;
+      __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_v_msg);
+      __Pyx_GIVEREF(__pyx_v_msg);
+      PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_msg);
+      __Pyx_INCREF(__pyx_kp_u__133);
+      __pyx_t_6 += 2;
+      __Pyx_GIVEREF(__pyx_kp_u__133);
+      PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_kp_u__133);
+      __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_reason, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 104, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_7;
+      __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_1);
+      PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_1);
+      __pyx_t_1 = 0;
+      __Pyx_INCREF(__pyx_kp_u__134);
+      __pyx_t_6 += 1;
+      __Pyx_GIVEREF(__pyx_kp_u__134);
+      PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_kp_u__134);
+      __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_5, 4, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 104, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF_SET(__pyx_v_msg, ((PyObject*)__pyx_t_1));
+      __pyx_t_1 = 0;
+
+      /* "uvloop/handles/streamserver.pyx":103
+ * 
+ *             msg = f'Fatal error on server {self.__class__.__name__}'
+ *             if reason is not None:             # <<<<<<<<<<<<<<
+ *                 msg = f'{msg} ({reason})'
+ * 
+ */
+    }
+
+    /* "uvloop/handles/streamserver.pyx":106
+ *                 msg = f'{msg} ({reason})'
+ * 
+ *             self._loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *                 'message': msg,
+ *                 'exception': exc,
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 106, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+
+    /* "uvloop/handles/streamserver.pyx":107
+ * 
+ *             self._loop.call_exception_handler({
+ *                 'message': msg,             # <<<<<<<<<<<<<<
+ *                 'exception': exc,
+ *             })
+ */
+    __pyx_t_8 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(19, 107, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    if (PyDict_SetItem(__pyx_t_8, __pyx_n_u_message, __pyx_v_msg) < 0) __PYX_ERR(19, 107, __pyx_L1_error)
+
+    /* "uvloop/handles/streamserver.pyx":108
+ *             self._loop.call_exception_handler({
+ *                 'message': msg,
+ *                 'exception': exc,             # <<<<<<<<<<<<<<
+ *             })
+ * 
+ */
+    if (PyDict_SetItem(__pyx_t_8, __pyx_n_u_exception, __pyx_v_exc) < 0) __PYX_ERR(19, 107, __pyx_L1_error)
+    __pyx_t_9 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_9, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_8);
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 106, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":97
+ *         self._close()
+ * 
+ *         if not isinstance(exc, OSError):             # <<<<<<<<<<<<<<
+ * 
+ *             if throw or self._loop is None:
+ */
+  }
+
+  /* "uvloop/handles/streamserver.pyx":92
+ *         client._accept(<UVStream>self)
+ * 
+ *     cdef _fatal_error(self, exc, throw, reason=None):             # <<<<<<<<<<<<<<
+ *         # Overload UVHandle._fatal_error
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.UVStreamServer._fatal_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_msg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/streamserver.pyx":111
+ *             })
+ * 
+ *     cdef inline _mark_as_open(self):             # <<<<<<<<<<<<<<
+ *         self.opened = 1
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__mark_as_open(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_mark_as_open", 0);
+
+  /* "uvloop/handles/streamserver.pyx":112
+ * 
+ *     cdef inline _mark_as_open(self):
+ *         self.opened = 1             # <<<<<<<<<<<<<<
+ * 
+ *     cdef UVStream _make_new_transport(self, object protocol, object waiter,
+ */
+  __pyx_v_self->opened = 1;
+
+  /* "uvloop/handles/streamserver.pyx":111
+ *             })
+ * 
+ *     cdef inline _mark_as_open(self):             # <<<<<<<<<<<<<<
+ *         self.opened = 1
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/streamserver.pyx":114
+ *         self.opened = 1
+ * 
+ *     cdef UVStream _make_new_transport(self, object protocol, object waiter,             # <<<<<<<<<<<<<<
+ *                                       object context):
+ *         raise NotImplementedError
+ */
+
+static struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_f_6uvloop_4loop_14UVStreamServer__make_new_transport(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_protocol, CYTHON_UNUSED PyObject *__pyx_v_waiter, CYTHON_UNUSED PyObject *__pyx_v_context) {
+  struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_make_new_transport", 0);
+
+  /* "uvloop/handles/streamserver.pyx":116
+ *     cdef UVStream _make_new_transport(self, object protocol, object waiter,
+ *                                       object context):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     def __on_ssl_connected(self, transport, fut):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(19, 116, __pyx_L1_error)
+
+  /* "uvloop/handles/streamserver.pyx":114
+ *         self.opened = 1
+ * 
+ *     cdef UVStream _make_new_transport(self, object protocol, object waiter,             # <<<<<<<<<<<<<<
+ *                                       object context):
+ *         raise NotImplementedError
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVStreamServer._make_new_transport", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/streamserver.pyx":118
+ *         raise NotImplementedError
+ * 
+ *     def __on_ssl_connected(self, transport, fut):             # <<<<<<<<<<<<<<
+ *         exc = fut.exception()
+ *         if exc is not None:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_14UVStreamServer_3__on_ssl_connected(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_14UVStreamServer_2__on_ssl_connected[] = "UVStreamServer.__on_ssl_connected(self, transport, fut)";
+static PyObject *__pyx_pw_6uvloop_4loop_14UVStreamServer_3__on_ssl_connected(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_transport = 0;
+  PyObject *__pyx_v_fut = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__on_ssl_connected (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_transport,&__pyx_n_s_fut,0};
+    PyObject* values[2] = {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  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_transport)) != 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_fut)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__on_ssl_connected", 1, 2, 2, 1); __PYX_ERR(19, 118, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__on_ssl_connected") < 0)) __PYX_ERR(19, 118, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_transport = values[0];
+    __pyx_v_fut = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__on_ssl_connected", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 118, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVStreamServer.__on_ssl_connected", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_14UVStreamServer_2__on_ssl_connected(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_self), __pyx_v_transport, __pyx_v_fut);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_14UVStreamServer_2__on_ssl_connected(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, PyObject *__pyx_v_transport, PyObject *__pyx_v_fut) {
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__on_ssl_connected", 0);
+
+  /* "uvloop/handles/streamserver.pyx":119
+ * 
+ *     def __on_ssl_connected(self, transport, fut):
+ *         exc = fut.exception()             # <<<<<<<<<<<<<<
+ *         if exc is not None:
+ *             transport._force_close(exc)
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_exception); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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(19, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_exc = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/streamserver.pyx":120
+ *     def __on_ssl_connected(self, transport, fut):
+ *         exc = fut.exception()
+ *         if exc is not None:             # <<<<<<<<<<<<<<
+ *             transport._force_close(exc)
+ * 
+ */
+  __pyx_t_4 = (__pyx_v_exc != Py_None);
+  __pyx_t_5 = (__pyx_t_4 != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/handles/streamserver.pyx":121
+ *         exc = fut.exception()
+ *         if exc is not None:
+ *             transport._force_close(exc)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_transport, __pyx_n_s_force_close); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 121, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_exc);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 121, __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;
+
+    /* "uvloop/handles/streamserver.pyx":120
+ *     def __on_ssl_connected(self, transport, fut):
+ *         exc = fut.exception()
+ *         if exc is not None:             # <<<<<<<<<<<<<<
+ *             transport._force_close(exc)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/streamserver.pyx":118
+ *         raise NotImplementedError
+ * 
+ *     def __on_ssl_connected(self, transport, fut):             # <<<<<<<<<<<<<<
+ *         exc = fut.exception()
+ *         if exc is not None:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVStreamServer.__on_ssl_connected", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_14UVStreamServer_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_14UVStreamServer_4__reduce_cython__[] = "UVStreamServer.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_14UVStreamServer_5__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_6uvloop_4loop_14UVStreamServer_4__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_14UVStreamServer_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStreamServer *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__159, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStreamServer.__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_6uvloop_4loop_14UVStreamServer_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_14UVStreamServer_6__setstate_cython__[] = "UVStreamServer.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_14UVStreamServer_7__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_6uvloop_4loop_14UVStreamServer_6__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_14UVStreamServer_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStreamServer *__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);
+
+  /* "(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__160, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVStreamServer.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/streamserver.pyx":124
+ * 
+ * 
+ * cdef void __uv_streamserver_on_listen(uv.uv_stream_t* handle,             # <<<<<<<<<<<<<<
+ *                                       int status) with gil:
+ * 
+ */
+
+static void __pyx_f_6uvloop_4loop___uv_streamserver_on_listen(uv_stream_t *__pyx_v_handle, int __pyx_v_status) {
+  struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_stream = 0;
+  PyObject *__pyx_v_exc = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_3 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_t_12;
+  char const *__pyx_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uv_streamserver_on_listen", 0);
+
+  /* "uvloop/handles/streamserver.pyx":130
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,
+ *                             "UVStream listen callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_f_6uvloop_4loop___ensure_handle_data(((uv_handle_t *)__pyx_v_handle), ((char const *)"UVStream listen callback")) == 0) != 0);
+
+  /* "uvloop/handles/streamserver.pyx":129
+ *     # callback for uv_listen
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,             # <<<<<<<<<<<<<<
+ *                             "UVStream listen callback") == 0:
+ *         return
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/streamserver.pyx":131
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,
+ *                             "UVStream listen callback") == 0:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/streamserver.pyx":129
+ *     # callback for uv_listen
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,             # <<<<<<<<<<<<<<
+ *                             "UVStream listen callback") == 0:
+ *         return
+ */
+  }
+
+  /* "uvloop/handles/streamserver.pyx":134
+ * 
+ *     cdef:
+ *         UVStreamServer stream = <UVStreamServer> handle.data             # <<<<<<<<<<<<<<
+ * 
+ *     if status < 0:
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_handle->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_stream = ((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/streamserver.pyx":136
+ *         UVStreamServer stream = <UVStreamServer> handle.data
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_listen_errors_total += 1
+ */
+  __pyx_t_1 = ((__pyx_v_status < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/streamserver.pyx":137
+ * 
+ *     if status < 0:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             stream._loop._debug_stream_listen_errors_total += 1
+ * 
+ */
+    __pyx_t_1 = (UVLOOP_DEBUG != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/streamserver.pyx":138
+ *     if status < 0:
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_listen_errors_total += 1             # <<<<<<<<<<<<<<
+ * 
+ *         exc = convert_error(status)
+ */
+      __Pyx_INCREF(((PyObject *)__pyx_v_stream->__pyx_base.__pyx_base._loop));
+      __pyx_t_3 = __pyx_v_stream->__pyx_base.__pyx_base._loop;
+      __pyx_t_3->_debug_stream_listen_errors_total = (__pyx_t_3->_debug_stream_listen_errors_total + 1);
+      __Pyx_DECREF(((PyObject *)__pyx_t_3)); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/streamserver.pyx":137
+ * 
+ *     if status < 0:
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             stream._loop._debug_stream_listen_errors_total += 1
+ * 
+ */
+    }
+
+    /* "uvloop/handles/streamserver.pyx":140
+ *             stream._loop._debug_stream_listen_errors_total += 1
+ * 
+ *         exc = convert_error(status)             # <<<<<<<<<<<<<<
+ *         stream._fatal_error(
+ *             exc, False, "error status in uv_stream_t.listen callback")
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_status); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 140, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":141
+ * 
+ *         exc = convert_error(status)
+ *         stream._fatal_error(             # <<<<<<<<<<<<<<
+ *             exc, False, "error status in uv_stream_t.listen callback")
+ *         return
+ */
+    __pyx_t_4.__pyx_n = 1;
+    __pyx_t_4.reason = __pyx_kp_u_error_status_in_uv_stream_t_list;
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *)__pyx_v_stream->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_stream), __pyx_v_exc, Py_False, &__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 141, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":143
+ *         stream._fatal_error(
+ *             exc, False, "error status in uv_stream_t.listen callback")
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/streamserver.pyx":136
+ *         UVStreamServer stream = <UVStreamServer> handle.data
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             stream._loop._debug_stream_listen_errors_total += 1
+ */
+  }
+
+  /* "uvloop/handles/streamserver.pyx":145
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         stream._on_listen()
+ *     except BaseException as exc:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_7);
+    /*try:*/ {
+
+      /* "uvloop/handles/streamserver.pyx":146
+ * 
+ *     try:
+ *         stream._on_listen()             # <<<<<<<<<<<<<<
+ *     except BaseException as exc:
+ *         stream._error(exc, False)
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_14UVStreamServer__on_listen(__pyx_v_stream); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 146, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/streamserver.pyx":145
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         stream._on_listen()
+ *     except BaseException as exc:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    goto __pyx_L11_try_end;
+    __pyx_L6_error:;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(((PyObject *)__pyx_t_3)); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/streamserver.pyx":147
+ *     try:
+ *         stream._on_listen()
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         stream._error(exc, False)
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("uvloop.loop.__uv_streamserver_on_listen", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_9, &__pyx_t_10) < 0) __PYX_ERR(19, 147, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_GOTREF(__pyx_t_10);
+      __Pyx_INCREF(__pyx_t_9);
+      __pyx_v_exc = __pyx_t_9;
+      /*try:*/ {
+
+        /* "uvloop/handles/streamserver.pyx":148
+ *         stream._on_listen()
+ *     except BaseException as exc:
+ *         stream._error(exc, False)             # <<<<<<<<<<<<<<
+ */
+        __pyx_t_11 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *)__pyx_v_stream->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_stream), __pyx_v_exc, Py_False); if (unlikely(!__pyx_t_11)) __PYX_ERR(19, 148, __pyx_L17_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      }
+
+      /* "uvloop/handles/streamserver.pyx":147
+ *     try:
+ *         stream._on_listen()
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         stream._error(exc, False)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L18;
+        }
+        __pyx_L17_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_XDECREF(((PyObject *)__pyx_t_3)); __pyx_t_3 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __pyx_t_8 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+          }
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+          __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+          __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13;
+          goto __pyx_L8_except_error;
+        }
+        __pyx_L18:;
+      }
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      goto __pyx_L7_exception_handled;
+    }
+    goto __pyx_L8_except_error;
+    __pyx_L8_except_error:;
+
+    /* "uvloop/handles/streamserver.pyx":145
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         stream._on_listen()
+ *     except BaseException as exc:
+ */
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_7);
+    __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+    goto __pyx_L1_error;
+    __pyx_L7_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_7);
+    __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+    __pyx_L11_try_end:;
+  }
+
+  /* "uvloop/handles/streamserver.pyx":124
+ * 
+ * 
+ * cdef void __uv_streamserver_on_listen(uv.uv_stream_t* handle,             # <<<<<<<<<<<<<<
+ *                                       int status) with gil:
+ * 
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(((PyObject *)__pyx_t_3));
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_WriteUnraisable("uvloop.loop.__uv_streamserver_on_listen", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_stream);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/tcp.pyx":1
+ * cdef __tcp_init_uv_handle(UVStream handle, Loop loop, unsigned int flags):             # <<<<<<<<<<<<<<
+ *     cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___tcp_init_uv_handle(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_handle, CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, unsigned int __pyx_v_flags) {
+  int __pyx_v_err;
+  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("__tcp_init_uv_handle", 0);
+
+  /* "uvloop/handles/tcp.pyx":4
+ *     cdef int err
+ * 
+ *     handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_tcp_t))             # <<<<<<<<<<<<<<
+ *     if handle._handle is NULL:
+ *         handle._abort_init()
+ */
+  __pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._handle = ((uv_handle_t *)PyMem_RawMalloc((sizeof(uv_tcp_t))));
+
+  /* "uvloop/handles/tcp.pyx":5
+ * 
+ *     handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_tcp_t))
+ *     if handle._handle is NULL:             # <<<<<<<<<<<<<<
+ *         handle._abort_init()
+ *         raise MemoryError()
+ */
+  __pyx_t_1 = ((__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._handle == NULL) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/tcp.pyx":6
+ *     handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_tcp_t))
+ *     if handle._handle is NULL:
+ *         handle._abort_init()             # <<<<<<<<<<<<<<
+ *         raise MemoryError()
+ * 
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/tcp.pyx":7
+ *     if handle._handle is NULL:
+ *         handle._abort_init()
+ *         raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *     err = uv.uv_tcp_init_ex(handle._loop.uvloop,
+ */
+    PyErr_NoMemory(); __PYX_ERR(3, 7, __pyx_L1_error)
+
+    /* "uvloop/handles/tcp.pyx":5
+ * 
+ *     handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_tcp_t))
+ *     if handle._handle is NULL:             # <<<<<<<<<<<<<<
+ *         handle._abort_init()
+ *         raise MemoryError()
+ */
+  }
+
+  /* "uvloop/handles/tcp.pyx":9
+ *         raise MemoryError()
+ * 
+ *     err = uv.uv_tcp_init_ex(handle._loop.uvloop,             # <<<<<<<<<<<<<<
+ *                             <uv.uv_tcp_t*>handle._handle,
+ *                             flags)
+ */
+  __pyx_v_err = uv_tcp_init_ex(__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._loop->uvloop, ((uv_tcp_t *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_v_flags);
+
+  /* "uvloop/handles/tcp.pyx":12
+ *                             <uv.uv_tcp_t*>handle._handle,
+ *                             flags)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         handle._abort_init()
+ *         raise convert_error(err)
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/tcp.pyx":13
+ *                             flags)
+ *     if err < 0:
+ *         handle._abort_init()             # <<<<<<<<<<<<<<
+ *         raise convert_error(err)
+ * 
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 13, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/tcp.pyx":14
+ *     if err < 0:
+ *         handle._abort_init()
+ *         raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *     handle._finish_init()
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 14, __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(3, 14, __pyx_L1_error)
+
+    /* "uvloop/handles/tcp.pyx":12
+ *                             <uv.uv_tcp_t*>handle._handle,
+ *                             flags)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         handle._abort_init()
+ *         raise convert_error(err)
+ */
+  }
+
+  /* "uvloop/handles/tcp.pyx":16
+ *         raise convert_error(err)
+ * 
+ *     handle._finish_init()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._finish_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/tcp.pyx":1
+ * cdef __tcp_init_uv_handle(UVStream handle, Loop loop, unsigned int flags):             # <<<<<<<<<<<<<<
+ *     cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.__tcp_init_uv_handle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":19
+ * 
+ * 
+ * cdef __tcp_bind(UVStream handle, system.sockaddr* addr, unsigned int flags):             # <<<<<<<<<<<<<<
+ *     cdef int err
+ *     err = uv.uv_tcp_bind(<uv.uv_tcp_t *>handle._handle,
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___tcp_bind(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_handle, struct sockaddr *__pyx_v_addr, unsigned int __pyx_v_flags) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("__tcp_bind", 0);
+
+  /* "uvloop/handles/tcp.pyx":21
+ * cdef __tcp_bind(UVStream handle, system.sockaddr* addr, unsigned int flags):
+ *     cdef int err
+ *     err = uv.uv_tcp_bind(<uv.uv_tcp_t *>handle._handle,             # <<<<<<<<<<<<<<
+ *                          addr, flags)
+ *     if err < 0:
+ */
+  __pyx_v_err = uv_tcp_bind(((uv_tcp_t *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_v_addr, __pyx_v_flags);
+
+  /* "uvloop/handles/tcp.pyx":23
+ *     err = uv.uv_tcp_bind(<uv.uv_tcp_t *>handle._handle,
+ *                          addr, flags)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(err)
+ *         raise exc
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/tcp.pyx":24
+ *                          addr, flags)
+ *     if err < 0:
+ *         exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *         raise exc
+ * 
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 24, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/tcp.pyx":25
+ *     if err < 0:
+ *         exc = convert_error(err)
+ *         raise exc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(3, 25, __pyx_L1_error)
+
+    /* "uvloop/handles/tcp.pyx":23
+ *     err = uv.uv_tcp_bind(<uv.uv_tcp_t *>handle._handle,
+ *                          addr, flags)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(err)
+ *         raise exc
+ */
+  }
+
+  /* "uvloop/handles/tcp.pyx":19
+ * 
+ * 
+ * cdef __tcp_bind(UVStream handle, system.sockaddr* addr, unsigned int flags):             # <<<<<<<<<<<<<<
+ *     cdef int err
+ *     err = uv.uv_tcp_bind(<uv.uv_tcp_t *>handle._handle,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.__tcp_bind", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":28
+ * 
+ * 
+ * cdef __tcp_open(UVStream handle, int sockfd):             # <<<<<<<<<<<<<<
+ *     cdef int err
+ *     err = uv.uv_tcp_open(<uv.uv_tcp_t *>handle._handle,
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___tcp_open(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_handle, int __pyx_v_sockfd) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("__tcp_open", 0);
+
+  /* "uvloop/handles/tcp.pyx":30
+ * cdef __tcp_open(UVStream handle, int sockfd):
+ *     cdef int err
+ *     err = uv.uv_tcp_open(<uv.uv_tcp_t *>handle._handle,             # <<<<<<<<<<<<<<
+ *                          <uv.uv_os_sock_t>sockfd)
+ *     if err < 0:
+ */
+  __pyx_v_err = uv_tcp_open(((uv_tcp_t *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._handle), ((uv_os_sock_t)__pyx_v_sockfd));
+
+  /* "uvloop/handles/tcp.pyx":32
+ *     err = uv.uv_tcp_open(<uv.uv_tcp_t *>handle._handle,
+ *                          <uv.uv_os_sock_t>sockfd)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(err)
+ *         raise exc
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/tcp.pyx":33
+ *                          <uv.uv_os_sock_t>sockfd)
+ *     if err < 0:
+ *         exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *         raise exc
+ * 
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 33, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/tcp.pyx":34
+ *     if err < 0:
+ *         exc = convert_error(err)
+ *         raise exc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(3, 34, __pyx_L1_error)
+
+    /* "uvloop/handles/tcp.pyx":32
+ *     err = uv.uv_tcp_open(<uv.uv_tcp_t *>handle._handle,
+ *                          <uv.uv_os_sock_t>sockfd)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(err)
+ *         raise exc
+ */
+  }
+
+  /* "uvloop/handles/tcp.pyx":28
+ * 
+ * 
+ * cdef __tcp_open(UVStream handle, int sockfd):             # <<<<<<<<<<<<<<
+ *     cdef int err
+ *     err = uv.uv_tcp_open(<uv.uv_tcp_t *>handle._handle,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.__tcp_open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":37
+ * 
+ * 
+ * cdef __tcp_get_socket(UVSocketHandle handle):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int buf_len = sizeof(system.sockaddr_storage)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___tcp_get_socket(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_handle) {
+  int __pyx_v_buf_len;
+  int __pyx_v_fileno;
+  int __pyx_v_err;
+  struct sockaddr_storage __pyx_v_buf;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__tcp_get_socket", 0);
+
+  /* "uvloop/handles/tcp.pyx":39
+ * cdef __tcp_get_socket(UVSocketHandle handle):
+ *     cdef:
+ *         int buf_len = sizeof(system.sockaddr_storage)             # <<<<<<<<<<<<<<
+ *         int fileno
+ *         int err
+ */
+  __pyx_v_buf_len = (sizeof(struct sockaddr_storage));
+
+  /* "uvloop/handles/tcp.pyx":44
+ *         system.sockaddr_storage buf
+ * 
+ *     fileno = handle._fileno()             # <<<<<<<<<<<<<<
+ * 
+ *     err = uv.uv_tcp_getsockname(<uv.uv_tcp_t*>handle._handle,
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle *)__pyx_v_handle->__pyx_base.__pyx_vtab)->_fileno(__pyx_v_handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 44, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_fileno = __pyx_t_2;
+
+  /* "uvloop/handles/tcp.pyx":46
+ *     fileno = handle._fileno()
+ * 
+ *     err = uv.uv_tcp_getsockname(<uv.uv_tcp_t*>handle._handle,             # <<<<<<<<<<<<<<
+ *                                 <system.sockaddr*>&buf,
+ *                                 &buf_len)
+ */
+  __pyx_v_err = uv_tcp_getsockname(((uv_tcp_t *)__pyx_v_handle->__pyx_base._handle), ((struct sockaddr *)(&__pyx_v_buf)), (&__pyx_v_buf_len));
+
+  /* "uvloop/handles/tcp.pyx":49
+ *                                 <system.sockaddr*>&buf,
+ *                                 &buf_len)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         raise convert_error(err)
+ * 
+ */
+  __pyx_t_3 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/handles/tcp.pyx":50
+ *                                 &buf_len)
+ *     if err < 0:
+ *         raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *     return PseudoSocket(buf.ss_family, uv.SOCK_STREAM, 0, fileno)
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 50, __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(3, 50, __pyx_L1_error)
+
+    /* "uvloop/handles/tcp.pyx":49
+ *                                 <system.sockaddr*>&buf,
+ *                                 &buf_len)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         raise convert_error(err)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/tcp.pyx":52
+ *         raise convert_error(err)
+ * 
+ *     return PseudoSocket(buf.ss_family, uv.SOCK_STREAM, 0, fileno)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_short(__pyx_v_buf.ss_family); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyInt_From_int(SOCK_STREAM); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_fileno); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_4);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_int_0);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_PseudoSocket), __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/tcp.pyx":37
+ * 
+ * 
+ * cdef __tcp_get_socket(UVSocketHandle handle):             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int buf_len = sizeof(system.sockaddr_storage)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.__tcp_get_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":59
+ * 
+ *     @staticmethod
+ *     cdef TCPServer new(Loop loop, object protocol_factory, Server server,             # <<<<<<<<<<<<<<
+ *                        unsigned int flags,
+ *                        object backlog,
+ */
+
+static struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_f_6uvloop_4loop_9TCPServer_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol_factory, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, unsigned int __pyx_v_flags, PyObject *__pyx_v_backlog, PyObject *__pyx_v_ssl, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout) {
+  struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_handle = 0;
+  struct __pyx_obj_6uvloop_4loop_TCPServer *__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("new", 0);
+
+  /* "uvloop/handles/tcp.pyx":67
+ * 
+ *         cdef TCPServer handle
+ *         handle = TCPServer.__new__(TCPServer)             # <<<<<<<<<<<<<<
+ *         handle._init(loop, protocol_factory, server, backlog,
+ *                      ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_TCPServer(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_TCPServer), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 67, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_TCPServer *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":68
+ *         cdef TCPServer handle
+ *         handle = TCPServer.__new__(TCPServer)
+ *         handle._init(loop, protocol_factory, server, backlog,             # <<<<<<<<<<<<<<
+ *                      ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ *         __tcp_init_uv_handle(<UVStream>handle, loop, flags)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_handle), __pyx_v_loop, __pyx_v_protocol_factory, __pyx_v_server, __pyx_v_backlog, __pyx_v_ssl, __pyx_v_ssl_handshake_timeout, __pyx_v_ssl_shutdown_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":70
+ *         handle._init(loop, protocol_factory, server, backlog,
+ *                      ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ *         __tcp_init_uv_handle(<UVStream>handle, loop, flags)             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___tcp_init_uv_handle(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_handle), __pyx_v_loop, __pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":71
+ *                      ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ *         __tcp_init_uv_handle(<UVStream>handle, loop, flags)
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _new_socket(self):
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/tcp.pyx":59
+ * 
+ *     @staticmethod
+ *     cdef TCPServer new(Loop loop, object protocol_factory, Server server,             # <<<<<<<<<<<<<<
+ *                        unsigned int flags,
+ *                        object backlog,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TCPServer.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":73
+ *         return handle
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __tcp_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9TCPServer__new_socket(struct __pyx_obj_6uvloop_4loop_TCPServer *__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("_new_socket", 0);
+
+  /* "uvloop/handles/tcp.pyx":74
+ * 
+ *     cdef _new_socket(self):
+ *         return __tcp_get_socket(<UVSocketHandle>self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _open(self, int sockfd):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___tcp_get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/tcp.pyx":73
+ *         return handle
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __tcp_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TCPServer._new_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":76
+ *         return __tcp_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ *         try:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9TCPServer__open(struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self, int __pyx_v_sockfd) {
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  char const *__pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_open", 0);
+
+  /* "uvloop/handles/tcp.pyx":77
+ * 
+ *     cdef _open(self, int sockfd):
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ *         try:
+ *             __tcp_open(<UVStream>self, sockfd)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":78
+ *     cdef _open(self, int sockfd):
+ *         self._ensure_alive()
+ *         try:             # <<<<<<<<<<<<<<
+ *             __tcp_open(<UVStream>self, sockfd)
+ *         except Exception as exc:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "uvloop/handles/tcp.pyx":79
+ *         self._ensure_alive()
+ *         try:
+ *             __tcp_open(<UVStream>self, sockfd)             # <<<<<<<<<<<<<<
+ *         except Exception as exc:
+ *             self._fatal_error(exc, True)
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop___tcp_open(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self), __pyx_v_sockfd); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 79, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/tcp.pyx":78
+ *     cdef _open(self, int sockfd):
+ *         self._ensure_alive()
+ *         try:             # <<<<<<<<<<<<<<
+ *             __tcp_open(<UVStream>self, sockfd)
+ *         except Exception as exc:
+ */
+    }
+
+    /* "uvloop/handles/tcp.pyx":83
+ *             self._fatal_error(exc, True)
+ *         else:
+ *             self._mark_as_open()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+ */
+    /*else:*/ {
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._mark_as_open(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 83, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    }
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/tcp.pyx":80
+ *         try:
+ *             __tcp_open(<UVStream>self, sockfd)
+ *         except Exception as exc:             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *         else:
+ */
+    __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_5) {
+      __Pyx_AddTraceback("uvloop.loop.TCPServer._open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 80, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_v_exc = __pyx_t_6;
+      /*try:*/ {
+
+        /* "uvloop/handles/tcp.pyx":81
+ *             __tcp_open(<UVStream>self, sockfd)
+ *         except Exception as exc:
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._mark_as_open()
+ */
+        __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 81, __pyx_L14_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+
+      /* "uvloop/handles/tcp.pyx":80
+ *         try:
+ *             __tcp_open(<UVStream>self, sockfd)
+ *         except Exception as exc:             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *         else:
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L15;
+        }
+        __pyx_L14_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_11);
+          __Pyx_XGOTREF(__pyx_t_12);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __pyx_t_5 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+          }
+          __Pyx_XGIVEREF(__pyx_t_11);
+          __Pyx_XGIVEREF(__pyx_t_12);
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+          __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+          __pyx_lineno = __pyx_t_5; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10;
+          goto __pyx_L5_except_error;
+        }
+        __pyx_L15:;
+      }
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/handles/tcp.pyx":78
+ *     cdef _open(self, int sockfd):
+ *         self._ensure_alive()
+ *         try:             # <<<<<<<<<<<<<<
+ *             __tcp_open(<UVStream>self, sockfd)
+ *         except Exception as exc:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/handles/tcp.pyx":76
+ *         return __tcp_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ *         try:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.TCPServer._open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":85
+ *             self._mark_as_open()
+ * 
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ *         try:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9TCPServer_bind(struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self, struct sockaddr *__pyx_v_addr, struct __pyx_opt_args_6uvloop_4loop_9TCPServer_bind *__pyx_optional_args) {
+  unsigned int __pyx_v_flags = ((unsigned int)0);
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  char const *__pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("bind", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_flags = __pyx_optional_args->flags;
+    }
+  }
+
+  /* "uvloop/handles/tcp.pyx":86
+ * 
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ *         try:
+ *             __tcp_bind(<UVStream>self, addr, flags)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":87
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+ *         self._ensure_alive()
+ *         try:             # <<<<<<<<<<<<<<
+ *             __tcp_bind(<UVStream>self, addr, flags)
+ *         except Exception as exc:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "uvloop/handles/tcp.pyx":88
+ *         self._ensure_alive()
+ *         try:
+ *             __tcp_bind(<UVStream>self, addr, flags)             # <<<<<<<<<<<<<<
+ *         except Exception as exc:
+ *             self._fatal_error(exc, True)
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop___tcp_bind(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self), __pyx_v_addr, __pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 88, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/tcp.pyx":87
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+ *         self._ensure_alive()
+ *         try:             # <<<<<<<<<<<<<<
+ *             __tcp_bind(<UVStream>self, addr, flags)
+ *         except Exception as exc:
+ */
+    }
+
+    /* "uvloop/handles/tcp.pyx":92
+ *             self._fatal_error(exc, True)
+ *         else:
+ *             self._mark_as_open()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef UVStream _make_new_transport(self, object protocol, object waiter,
+ */
+    /*else:*/ {
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._mark_as_open(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 92, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    }
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/tcp.pyx":89
+ *         try:
+ *             __tcp_bind(<UVStream>self, addr, flags)
+ *         except Exception as exc:             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *         else:
+ */
+    __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_5) {
+      __Pyx_AddTraceback("uvloop.loop.TCPServer.bind", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 89, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_v_exc = __pyx_t_6;
+      /*try:*/ {
+
+        /* "uvloop/handles/tcp.pyx":90
+ *             __tcp_bind(<UVStream>self, addr, flags)
+ *         except Exception as exc:
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._mark_as_open()
+ */
+        __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 90, __pyx_L14_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+
+      /* "uvloop/handles/tcp.pyx":89
+ *         try:
+ *             __tcp_bind(<UVStream>self, addr, flags)
+ *         except Exception as exc:             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *         else:
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L15;
+        }
+        __pyx_L14_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_11);
+          __Pyx_XGOTREF(__pyx_t_12);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __pyx_t_5 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+          }
+          __Pyx_XGIVEREF(__pyx_t_11);
+          __Pyx_XGIVEREF(__pyx_t_12);
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+          __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+          __pyx_lineno = __pyx_t_5; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10;
+          goto __pyx_L5_except_error;
+        }
+        __pyx_L15:;
+      }
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/handles/tcp.pyx":87
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+ *         self._ensure_alive()
+ *         try:             # <<<<<<<<<<<<<<
+ *             __tcp_bind(<UVStream>self, addr, flags)
+ *         except Exception as exc:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/handles/tcp.pyx":85
+ *             self._mark_as_open()
+ * 
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ *         try:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.TCPServer.bind", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":94
+ *             self._mark_as_open()
+ * 
+ *     cdef UVStream _make_new_transport(self, object protocol, object waiter,             # <<<<<<<<<<<<<<
+ *                                       object context):
+ *         cdef TCPTransport tr
+ */
+
+static struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_f_6uvloop_4loop_9TCPServer__make_new_transport(struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self, PyObject *__pyx_v_protocol, PyObject *__pyx_v_waiter, PyObject *__pyx_v_context) {
+  struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_tr = 0;
+  struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("_make_new_transport", 0);
+
+  /* "uvloop/handles/tcp.pyx":97
+ *                                       object context):
+ *         cdef TCPTransport tr
+ *         tr = TCPTransport.new(self._loop, protocol, self._server, waiter,             # <<<<<<<<<<<<<<
+ *                               context)
+ *         return <UVStream>tr
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._loop);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = ((PyObject *)__pyx_v_self->__pyx_base._server);
+  __Pyx_INCREF(__pyx_t_2);
+
+  /* "uvloop/handles/tcp.pyx":98
+ *         cdef TCPTransport tr
+ *         tr = TCPTransport.new(self._loop, protocol, self._server, waiter,
+ *                               context)             # <<<<<<<<<<<<<<
+ *         return <UVStream>tr
+ * 
+ */
+  __pyx_t_3 = ((PyObject *)__pyx_f_6uvloop_4loop_12TCPTransport_new(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_1), __pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_t_2), __pyx_v_waiter, __pyx_v_context)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 97, __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;
+  __pyx_v_tr = ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/handles/tcp.pyx":99
+ *         tr = TCPTransport.new(self._loop, protocol, self._server, waiter,
+ *                               context)
+ *         return <UVStream>tr             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_tr)));
+  __pyx_r = ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_tr);
+  goto __pyx_L0;
+
+  /* "uvloop/handles/tcp.pyx":94
+ *             self._mark_as_open()
+ * 
+ *     cdef UVStream _make_new_transport(self, object protocol, object waiter,             # <<<<<<<<<<<<<<
+ *                                       object context):
+ *         cdef TCPTransport tr
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.TCPServer._make_new_transport", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_tr);
+  __Pyx_XGIVEREF((PyObject *)__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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_9TCPServer_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_9TCPServer___reduce_cython__[] = "TCPServer.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_9TCPServer_1__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_6uvloop_4loop_9TCPServer___reduce_cython__(((struct __pyx_obj_6uvloop_4loop_TCPServer *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_9TCPServer___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TCPServer *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__161, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TCPServer.__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_6uvloop_4loop_9TCPServer_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_9TCPServer_2__setstate_cython__[] = "TCPServer.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_9TCPServer_3__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_6uvloop_4loop_9TCPServer_2__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_TCPServer *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_9TCPServer_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TCPServer *__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);
+
+  /* "(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__162, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TCPServer.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":106
+ * 
+ *     @staticmethod
+ *     cdef TCPTransport new(Loop loop, object protocol, Server server,             # <<<<<<<<<<<<<<
+ *                           object waiter, object context):
+ * 
+ */
+
+static struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_f_6uvloop_4loop_12TCPTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter, PyObject *__pyx_v_context) {
+  struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_handle = 0;
+  struct __pyx_obj_6uvloop_4loop_TCPTransport *__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("new", 0);
+
+  /* "uvloop/handles/tcp.pyx":110
+ * 
+ *         cdef TCPTransport handle
+ *         handle = TCPTransport.__new__(TCPTransport)             # <<<<<<<<<<<<<<
+ *         handle._init(loop, protocol, server, waiter, context)
+ *         __tcp_init_uv_handle(<UVStream>handle, loop, uv.AF_UNSPEC)
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_TCPTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_TCPTransport), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 110, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":111
+ *         cdef TCPTransport handle
+ *         handle = TCPTransport.__new__(TCPTransport)
+ *         handle._init(loop, protocol, server, waiter, context)             # <<<<<<<<<<<<<<
+ *         __tcp_init_uv_handle(<UVStream>handle, loop, uv.AF_UNSPEC)
+ *         handle.__peername_set = 0
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_handle), __pyx_v_loop, __pyx_v_protocol, __pyx_v_server, __pyx_v_waiter, __pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":112
+ *         handle = TCPTransport.__new__(TCPTransport)
+ *         handle._init(loop, protocol, server, waiter, context)
+ *         __tcp_init_uv_handle(<UVStream>handle, loop, uv.AF_UNSPEC)             # <<<<<<<<<<<<<<
+ *         handle.__peername_set = 0
+ *         handle.__sockname_set = 0
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___tcp_init_uv_handle(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_handle), __pyx_v_loop, AF_UNSPEC); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":113
+ *         handle._init(loop, protocol, server, waiter, context)
+ *         __tcp_init_uv_handle(<UVStream>handle, loop, uv.AF_UNSPEC)
+ *         handle.__peername_set = 0             # <<<<<<<<<<<<<<
+ *         handle.__sockname_set = 0
+ *         handle._set_nodelay()
+ */
+  __pyx_v_handle->__pyx___peername_set = 0;
+
+  /* "uvloop/handles/tcp.pyx":114
+ *         __tcp_init_uv_handle(<UVStream>handle, loop, uv.AF_UNSPEC)
+ *         handle.__peername_set = 0
+ *         handle.__sockname_set = 0             # <<<<<<<<<<<<<<
+ *         handle._set_nodelay()
+ *         return handle
+ */
+  __pyx_v_handle->__pyx___sockname_set = 0;
+
+  /* "uvloop/handles/tcp.pyx":115
+ *         handle.__peername_set = 0
+ *         handle.__sockname_set = 0
+ *         handle._set_nodelay()             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_set_nodelay(__pyx_v_handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 115, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":116
+ *         handle.__sockname_set = 0
+ *         handle._set_nodelay()
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _set_nodelay(self):
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/tcp.pyx":106
+ * 
+ *     @staticmethod
+ *     cdef TCPTransport new(Loop loop, object protocol, Server server,             # <<<<<<<<<<<<<<
+ *                           object waiter, object context):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TCPTransport.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":118
+ *         return handle
+ * 
+ *     cdef _set_nodelay(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         self._ensure_alive()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport__set_nodelay(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_set_nodelay", 0);
+
+  /* "uvloop/handles/tcp.pyx":120
+ *     cdef _set_nodelay(self):
+ *         cdef int err
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ *         err = uv.uv_tcp_nodelay(<uv.uv_tcp_t*>self._handle, 1)
+ *         if err < 0:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":121
+ *         cdef int err
+ *         self._ensure_alive()
+ *         err = uv.uv_tcp_nodelay(<uv.uv_tcp_t*>self._handle, 1)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             raise convert_error(err)
+ */
+  __pyx_v_err = uv_tcp_nodelay(((uv_tcp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base._handle), 1);
+
+  /* "uvloop/handles/tcp.pyx":122
+ *         self._ensure_alive()
+ *         err = uv.uv_tcp_nodelay(<uv.uv_tcp_t*>self._handle, 1)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/tcp.pyx":123
+ *         err = uv.uv_tcp_nodelay(<uv.uv_tcp_t*>self._handle, 1)
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _call_connection_made(self):
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 123, __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(3, 123, __pyx_L1_error)
+
+    /* "uvloop/handles/tcp.pyx":122
+ *         self._ensure_alive()
+ *         err = uv.uv_tcp_nodelay(<uv.uv_tcp_t*>self._handle, 1)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/tcp.pyx":118
+ *         return handle
+ * 
+ *     cdef _set_nodelay(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         self._ensure_alive()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TCPTransport._set_nodelay", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":125
+ *             raise convert_error(err)
+ * 
+ *     cdef _call_connection_made(self):             # <<<<<<<<<<<<<<
+ *         # asyncio saves peername & sockname when transports are instantiated,
+ *         # so that they're accessible even after the transport is closed.
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport__call_connection_made(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self) {
+  int __pyx_v_err;
+  int __pyx_v_buf_len;
+  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("_call_connection_made", 0);
+
+  /* "uvloop/handles/tcp.pyx":135
+ *             int buf_len
+ * 
+ *         buf_len = sizeof(system.sockaddr_storage)             # <<<<<<<<<<<<<<
+ *         err = uv.uv_tcp_getsockname(<uv.uv_tcp_t*>self._handle,
+ *                                     <system.sockaddr*>&self.__sockname,
+ */
+  __pyx_v_buf_len = (sizeof(struct sockaddr_storage));
+
+  /* "uvloop/handles/tcp.pyx":136
+ * 
+ *         buf_len = sizeof(system.sockaddr_storage)
+ *         err = uv.uv_tcp_getsockname(<uv.uv_tcp_t*>self._handle,             # <<<<<<<<<<<<<<
+ *                                     <system.sockaddr*>&self.__sockname,
+ *                                     &buf_len)
+ */
+  __pyx_v_err = uv_tcp_getsockname(((uv_tcp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base._handle), ((struct sockaddr *)(&__pyx_v_self->__pyx___sockname)), (&__pyx_v_buf_len));
+
+  /* "uvloop/handles/tcp.pyx":139
+ *                                     <system.sockaddr*>&self.__sockname,
+ *                                     &buf_len)
+ *         if err >= 0:             # <<<<<<<<<<<<<<
+ *             # Ignore errors, this is an optional thing.
+ *             # If something serious is going on, the transport
+ */
+  __pyx_t_1 = ((__pyx_v_err >= 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/tcp.pyx":144
+ *             # will crash later (in roughly the same way how
+ *             # an asyncio transport would.)
+ *             self.__sockname_set = 1             # <<<<<<<<<<<<<<
+ * 
+ *         buf_len = sizeof(system.sockaddr_storage)
+ */
+    __pyx_v_self->__pyx___sockname_set = 1;
+
+    /* "uvloop/handles/tcp.pyx":139
+ *                                     <system.sockaddr*>&self.__sockname,
+ *                                     &buf_len)
+ *         if err >= 0:             # <<<<<<<<<<<<<<
+ *             # Ignore errors, this is an optional thing.
+ *             # If something serious is going on, the transport
+ */
+  }
+
+  /* "uvloop/handles/tcp.pyx":146
+ *             self.__sockname_set = 1
+ * 
+ *         buf_len = sizeof(system.sockaddr_storage)             # <<<<<<<<<<<<<<
+ *         err = uv.uv_tcp_getpeername(<uv.uv_tcp_t*>self._handle,
+ *                                     <system.sockaddr*>&self.__peername,
+ */
+  __pyx_v_buf_len = (sizeof(struct sockaddr_storage));
+
+  /* "uvloop/handles/tcp.pyx":147
+ * 
+ *         buf_len = sizeof(system.sockaddr_storage)
+ *         err = uv.uv_tcp_getpeername(<uv.uv_tcp_t*>self._handle,             # <<<<<<<<<<<<<<
+ *                                     <system.sockaddr*>&self.__peername,
+ *                                     &buf_len)
+ */
+  __pyx_v_err = uv_tcp_getpeername(((uv_tcp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base._handle), ((struct sockaddr *)(&__pyx_v_self->__pyx___peername)), (&__pyx_v_buf_len));
+
+  /* "uvloop/handles/tcp.pyx":150
+ *                                     <system.sockaddr*>&self.__peername,
+ *                                     &buf_len)
+ *         if err >= 0:             # <<<<<<<<<<<<<<
+ *             # Same as few lines above -- we don't really care
+ *             # about error case here.
+ */
+  __pyx_t_1 = ((__pyx_v_err >= 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/tcp.pyx":153
+ *             # Same as few lines above -- we don't really care
+ *             # about error case here.
+ *             self.__peername_set = 1             # <<<<<<<<<<<<<<
+ * 
+ *         UVBaseTransport._call_connection_made(self)
+ */
+    __pyx_v_self->__pyx___peername_set = 1;
+
+    /* "uvloop/handles/tcp.pyx":150
+ *                                     <system.sockaddr*>&self.__peername,
+ *                                     &buf_len)
+ *         if err >= 0:             # <<<<<<<<<<<<<<
+ *             # Same as few lines above -- we don't really care
+ *             # about error case here.
+ */
+  }
+
+  /* "uvloop/handles/tcp.pyx":155
+ *             self.__peername_set = 1
+ * 
+ *         UVBaseTransport._call_connection_made(self)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_extra_info(self, name, default=None):
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop_15UVBaseTransport__call_connection_made(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/tcp.pyx":125
+ *             raise convert_error(err)
+ * 
+ *     cdef _call_connection_made(self):             # <<<<<<<<<<<<<<
+ *         # asyncio saves peername & sockname when transports are instantiated,
+ *         # so that they're accessible even after the transport is closed.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.TCPTransport._call_connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":157
+ *         UVBaseTransport._call_connection_made(self)
+ * 
+ *     def get_extra_info(self, name, default=None):             # <<<<<<<<<<<<<<
+ *         if name == 'sockname':
+ *             if self.__sockname_set:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12TCPTransport_1get_extra_info(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12TCPTransport_get_extra_info[] = "TCPTransport.get_extra_info(self, name, default=None)";
+static PyObject *__pyx_pw_6uvloop_4loop_12TCPTransport_1get_extra_info(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_name = 0;
+  PyObject *__pyx_v_default = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_extra_info (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name_2,&__pyx_n_s_default,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)Py_None);
+    if (unlikely(__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);
+        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_2)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_default);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_extra_info") < 0)) __PYX_ERR(3, 157, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_name = values[0];
+    __pyx_v_default = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_extra_info", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 157, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.TCPTransport.get_extra_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12TCPTransport_get_extra_info(((struct __pyx_obj_6uvloop_4loop_TCPTransport *)__pyx_v_self), __pyx_v_name, __pyx_v_default);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12TCPTransport_get_extra_info(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_default) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = 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("get_extra_info", 0);
+
+  /* "uvloop/handles/tcp.pyx":158
+ * 
+ *     def get_extra_info(self, name, default=None):
+ *         if name == 'sockname':             # <<<<<<<<<<<<<<
+ *             if self.__sockname_set:
+ *                 return __convert_sockaddr_to_pyaddr(
+ */
+  __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_name, __pyx_n_u_sockname, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 158, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/tcp.pyx":159
+ *     def get_extra_info(self, name, default=None):
+ *         if name == 'sockname':
+ *             if self.__sockname_set:             # <<<<<<<<<<<<<<
+ *                 return __convert_sockaddr_to_pyaddr(
+ *                     <system.sockaddr*>&self.__sockname)
+ */
+    __pyx_t_1 = (__pyx_v_self->__pyx___sockname_set != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/tcp.pyx":160
+ *         if name == 'sockname':
+ *             if self.__sockname_set:
+ *                 return __convert_sockaddr_to_pyaddr(             # <<<<<<<<<<<<<<
+ *                     <system.sockaddr*>&self.__sockname)
+ *         elif name == 'peername':
+ */
+      __Pyx_XDECREF(__pyx_r);
+
+      /* "uvloop/handles/tcp.pyx":161
+ *             if self.__sockname_set:
+ *                 return __convert_sockaddr_to_pyaddr(
+ *                     <system.sockaddr*>&self.__sockname)             # <<<<<<<<<<<<<<
+ *         elif name == 'peername':
+ *             if self.__peername_set:
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop___convert_sockaddr_to_pyaddr(((struct sockaddr *)(&__pyx_v_self->__pyx___sockname))); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 160, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_r = __pyx_t_2;
+      __pyx_t_2 = 0;
+      goto __pyx_L0;
+
+      /* "uvloop/handles/tcp.pyx":159
+ *     def get_extra_info(self, name, default=None):
+ *         if name == 'sockname':
+ *             if self.__sockname_set:             # <<<<<<<<<<<<<<
+ *                 return __convert_sockaddr_to_pyaddr(
+ *                     <system.sockaddr*>&self.__sockname)
+ */
+    }
+
+    /* "uvloop/handles/tcp.pyx":158
+ * 
+ *     def get_extra_info(self, name, default=None):
+ *         if name == 'sockname':             # <<<<<<<<<<<<<<
+ *             if self.__sockname_set:
+ *                 return __convert_sockaddr_to_pyaddr(
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/tcp.pyx":162
+ *                 return __convert_sockaddr_to_pyaddr(
+ *                     <system.sockaddr*>&self.__sockname)
+ *         elif name == 'peername':             # <<<<<<<<<<<<<<
+ *             if self.__peername_set:
+ *                 return __convert_sockaddr_to_pyaddr(
+ */
+  __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_name, __pyx_n_u_peername, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 162, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/tcp.pyx":163
+ *                     <system.sockaddr*>&self.__sockname)
+ *         elif name == 'peername':
+ *             if self.__peername_set:             # <<<<<<<<<<<<<<
+ *                 return __convert_sockaddr_to_pyaddr(
+ *                     <system.sockaddr*>&self.__peername)
+ */
+    __pyx_t_1 = (__pyx_v_self->__pyx___peername_set != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/tcp.pyx":164
+ *         elif name == 'peername':
+ *             if self.__peername_set:
+ *                 return __convert_sockaddr_to_pyaddr(             # <<<<<<<<<<<<<<
+ *                     <system.sockaddr*>&self.__peername)
+ *         return super().get_extra_info(name, default)
+ */
+      __Pyx_XDECREF(__pyx_r);
+
+      /* "uvloop/handles/tcp.pyx":165
+ *             if self.__peername_set:
+ *                 return __convert_sockaddr_to_pyaddr(
+ *                     <system.sockaddr*>&self.__peername)             # <<<<<<<<<<<<<<
+ *         return super().get_extra_info(name, default)
+ * 
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop___convert_sockaddr_to_pyaddr(((struct sockaddr *)(&__pyx_v_self->__pyx___peername))); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 164, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_r = __pyx_t_2;
+      __pyx_t_2 = 0;
+      goto __pyx_L0;
+
+      /* "uvloop/handles/tcp.pyx":163
+ *                     <system.sockaddr*>&self.__sockname)
+ *         elif name == 'peername':
+ *             if self.__peername_set:             # <<<<<<<<<<<<<<
+ *                 return __convert_sockaddr_to_pyaddr(
+ *                     <system.sockaddr*>&self.__peername)
+ */
+    }
+
+    /* "uvloop/handles/tcp.pyx":162
+ *                 return __convert_sockaddr_to_pyaddr(
+ *                     <system.sockaddr*>&self.__sockname)
+ *         elif name == 'peername':             # <<<<<<<<<<<<<<
+ *             if self.__peername_set:
+ *                 return __convert_sockaddr_to_pyaddr(
+ */
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/tcp.pyx":166
+ *                 return __convert_sockaddr_to_pyaddr(
+ *                     <system.sockaddr*>&self.__peername)
+ *         return super().get_extra_info(name, default)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _new_socket(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(((PyObject *)__pyx_ptype_6uvloop_4loop_TCPTransport));
+  __Pyx_GIVEREF(((PyObject *)__pyx_ptype_6uvloop_4loop_TCPTransport));
+  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_ptype_6uvloop_4loop_TCPTransport));
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_self));
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_get_extra_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(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;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_name, __pyx_v_default};
+    __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(3, 166, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_name, __pyx_v_default};
+    __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(3, 166, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else
+  #endif
+  {
+    __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 166, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (__pyx_t_4) {
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
+    }
+    __Pyx_INCREF(__pyx_v_name);
+    __Pyx_GIVEREF(__pyx_v_name);
+    PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_name);
+    __Pyx_INCREF(__pyx_v_default);
+    __Pyx_GIVEREF(__pyx_v_default);
+    PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_default);
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 166, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/tcp.pyx":157
+ *         UVBaseTransport._call_connection_made(self)
+ * 
+ *     def get_extra_info(self, name, default=None):             # <<<<<<<<<<<<<<
+ *         if name == 'sockname':
+ *             if self.__sockname_set:
+ */
+
+  /* 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_6);
+  __Pyx_AddTraceback("uvloop.loop.TCPTransport.get_extra_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":168
+ *         return super().get_extra_info(name, default)
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __tcp_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport__new_socket(struct __pyx_obj_6uvloop_4loop_TCPTransport *__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("_new_socket", 0);
+
+  /* "uvloop/handles/tcp.pyx":169
+ * 
+ *     cdef _new_socket(self):
+ *         return __tcp_get_socket(<UVSocketHandle>self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___tcp_get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/tcp.pyx":168
+ *         return super().get_extra_info(name, default)
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __tcp_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TCPTransport._new_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":171
+ *         return __tcp_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ *         __tcp_bind(<UVStream>self, addr, flags)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport_bind(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr, struct __pyx_opt_args_6uvloop_4loop_12TCPTransport_bind *__pyx_optional_args) {
+  unsigned int __pyx_v_flags = ((unsigned int)0);
+  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("bind", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_flags = __pyx_optional_args->flags;
+    }
+  }
+
+  /* "uvloop/handles/tcp.pyx":172
+ * 
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ *         __tcp_bind(<UVStream>self, addr, flags)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":173
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+ *         self._ensure_alive()
+ *         __tcp_bind(<UVStream>self, addr, flags)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _open(self, int sockfd):
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___tcp_bind(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self), __pyx_v_addr, __pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":171
+ *         return __tcp_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef bind(self, system.sockaddr* addr, unsigned int flags=0):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ *         __tcp_bind(<UVStream>self, addr, flags)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TCPTransport.bind", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":175
+ *         __tcp_bind(<UVStream>self, addr, flags)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ *         __tcp_open(<UVStream>self, sockfd)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport__open(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, int __pyx_v_sockfd) {
+  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("_open", 0);
+
+  /* "uvloop/handles/tcp.pyx":176
+ * 
+ *     cdef _open(self, int sockfd):
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ *         __tcp_open(<UVStream>self, sockfd)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":177
+ *     cdef _open(self, int sockfd):
+ *         self._ensure_alive()
+ *         __tcp_open(<UVStream>self, sockfd)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef connect(self, system.sockaddr* addr):
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___tcp_open(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self), __pyx_v_sockfd); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":175
+ *         __tcp_bind(<UVStream>self, addr, flags)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ *         __tcp_open(<UVStream>self, sockfd)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TCPTransport._open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":179
+ *         __tcp_open(<UVStream>self, sockfd)
+ * 
+ *     cdef connect(self, system.sockaddr* addr):             # <<<<<<<<<<<<<<
+ *         cdef _TCPConnectRequest req
+ *         req = _TCPConnectRequest(self._loop, self)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport_connect(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr) {
+  struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__pyx_v_req = 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("connect", 0);
+
+  /* "uvloop/handles/tcp.pyx":181
+ *     cdef connect(self, system.sockaddr* addr):
+ *         cdef _TCPConnectRequest req
+ *         req = _TCPConnectRequest(self._loop, self)             # <<<<<<<<<<<<<<
+ *         req.connect(addr)
+ * 
+ */
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 181, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base._loop));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base._loop));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base._loop));
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop__TCPConnectRequest), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 181, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_req = ((struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/tcp.pyx":182
+ *         cdef _TCPConnectRequest req
+ *         req = _TCPConnectRequest(self._loop, self)
+ *         req.connect(addr)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop__TCPConnectRequest *)__pyx_v_req->__pyx_base.__pyx_vtab)->connect(__pyx_v_req, __pyx_v_addr); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/tcp.pyx":179
+ *         __tcp_open(<UVStream>self, sockfd)
+ * 
+ *     cdef connect(self, system.sockaddr* addr):             # <<<<<<<<<<<<<<
+ *         cdef _TCPConnectRequest req
+ *         req = _TCPConnectRequest(self._loop, self)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.TCPTransport.connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_req);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12TCPTransport_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12TCPTransport_2__reduce_cython__[] = "TCPTransport.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12TCPTransport_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_6uvloop_4loop_12TCPTransport_2__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_TCPTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12TCPTransport_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TCPTransport *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__163, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TCPTransport.__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_6uvloop_4loop_12TCPTransport_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12TCPTransport_4__setstate_cython__[] = "TCPTransport.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_12TCPTransport_5__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_6uvloop_4loop_12TCPTransport_4__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_TCPTransport *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12TCPTransport_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_TCPTransport *__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);
+
+  /* "(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__164, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.TCPTransport.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":190
+ *         uv.uv_connect_t _req_data
+ * 
+ *     def __cinit__(self, loop, transport):             # <<<<<<<<<<<<<<
+ *         self.request = <uv.uv_req_t*>&self._req_data
+ *         self.request.data = <void*>self
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_18_TCPConnectRequest_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_18_TCPConnectRequest_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_loop = 0;
+  PyObject *__pyx_v_transport = 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_loop,&__pyx_n_s_transport,0};
+    PyObject* values[2] = {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  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_loop)) != 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_transport)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, 1); __PYX_ERR(3, 190, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(3, 190, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_loop = values[0];
+    __pyx_v_transport = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 190, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop._TCPConnectRequest.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_18_TCPConnectRequest___cinit__(((struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *)__pyx_v_self), __pyx_v_loop, __pyx_v_transport);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_18_TCPConnectRequest___cinit__(struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_loop, PyObject *__pyx_v_transport) {
+  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);
+
+  /* "uvloop/handles/tcp.pyx":191
+ * 
+ *     def __cinit__(self, loop, transport):
+ *         self.request = <uv.uv_req_t*>&self._req_data             # <<<<<<<<<<<<<<
+ *         self.request.data = <void*>self
+ *         self.transport = transport
+ */
+  __pyx_v_self->__pyx_base.request = ((uv_req_t *)(&__pyx_v_self->_req_data));
+
+  /* "uvloop/handles/tcp.pyx":192
+ *     def __cinit__(self, loop, transport):
+ *         self.request = <uv.uv_req_t*>&self._req_data
+ *         self.request.data = <void*>self             # <<<<<<<<<<<<<<
+ *         self.transport = transport
+ * 
+ */
+  __pyx_v_self->__pyx_base.request->data = ((void *)__pyx_v_self);
+
+  /* "uvloop/handles/tcp.pyx":193
+ *         self.request = <uv.uv_req_t*>&self._req_data
+ *         self.request.data = <void*>self
+ *         self.transport = transport             # <<<<<<<<<<<<<<
+ * 
+ *     cdef connect(self, system.sockaddr* addr):
+ */
+  if (!(likely(((__pyx_v_transport) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_transport, __pyx_ptype_6uvloop_4loop_TCPTransport))))) __PYX_ERR(3, 193, __pyx_L1_error)
+  __pyx_t_1 = __pyx_v_transport;
+  __Pyx_INCREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->transport);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->transport));
+  __pyx_v_self->transport = ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":190
+ *         uv.uv_connect_t _req_data
+ * 
+ *     def __cinit__(self, loop, transport):             # <<<<<<<<<<<<<<
+ *         self.request = <uv.uv_req_t*>&self._req_data
+ *         self.request.data = <void*>self
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._TCPConnectRequest.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":195
+ *         self.transport = transport
+ * 
+ *     cdef connect(self, system.sockaddr* addr):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         err = uv.uv_tcp_connect(<uv.uv_connect_t*>self.request,
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18_TCPConnectRequest_connect(struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__pyx_v_self, struct sockaddr *__pyx_v_addr) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("connect", 0);
+
+  /* "uvloop/handles/tcp.pyx":197
+ *     cdef connect(self, system.sockaddr* addr):
+ *         cdef int err
+ *         err = uv.uv_tcp_connect(<uv.uv_connect_t*>self.request,             # <<<<<<<<<<<<<<
+ *                                 <uv.uv_tcp_t*>self.transport._handle,
+ *                                 addr,
+ */
+  __pyx_v_err = uv_tcp_connect(((uv_connect_t *)__pyx_v_self->__pyx_base.request), ((uv_tcp_t *)__pyx_v_self->transport->__pyx_base.__pyx_base.__pyx_base.__pyx_base._handle), __pyx_v_addr, __pyx_f_6uvloop_4loop___tcp_connect_callback);
+
+  /* "uvloop/handles/tcp.pyx":201
+ *                                 addr,
+ *                                 __tcp_connect_callback)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self.on_done()
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/tcp.pyx":202
+ *                                 __tcp_connect_callback)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self.on_done()
+ *             raise exc
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/tcp.pyx":203
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self.on_done()             # <<<<<<<<<<<<<<
+ *             raise exc
+ * 
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop__TCPConnectRequest *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/tcp.pyx":204
+ *             exc = convert_error(err)
+ *             self.on_done()
+ *             raise exc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(3, 204, __pyx_L1_error)
+
+    /* "uvloop/handles/tcp.pyx":201
+ *                                 addr,
+ *                                 __tcp_connect_callback)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self.on_done()
+ */
+  }
+
+  /* "uvloop/handles/tcp.pyx":195
+ *         self.transport = transport
+ * 
+ *     cdef connect(self, system.sockaddr* addr):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         err = uv.uv_tcp_connect(<uv.uv_connect_t*>self.request,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop._TCPConnectRequest.connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18_TCPConnectRequest_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18_TCPConnectRequest_2__reduce_cython__[] = "_TCPConnectRequest.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18_TCPConnectRequest_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_6uvloop_4loop_18_TCPConnectRequest_2__reduce_cython__(((struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18_TCPConnectRequest_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__165, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._TCPConnectRequest.__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_6uvloop_4loop_18_TCPConnectRequest_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18_TCPConnectRequest_4__setstate_cython__[] = "_TCPConnectRequest.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_18_TCPConnectRequest_5__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_6uvloop_4loop_18_TCPConnectRequest_4__setstate_cython__(((struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18_TCPConnectRequest_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__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);
+
+  /* "(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__166, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._TCPConnectRequest.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/tcp.pyx":207
+ * 
+ * 
+ * cdef void __tcp_connect_callback(uv.uv_connect_t* req, int status) with gil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         _TCPConnectRequest wrapper
+ */
+
+static void __pyx_f_6uvloop_4loop___tcp_connect_callback(uv_connect_t *__pyx_v_req, int __pyx_v_status) {
+  struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__pyx_v_wrapper = 0;
+  struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_transport = 0;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  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;
+  int __pyx_t_10;
+  char const *__pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  char const *__pyx_t_18;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__tcp_connect_callback", 0);
+
+  /* "uvloop/handles/tcp.pyx":212
+ *         TCPTransport transport
+ * 
+ *     wrapper = <_TCPConnectRequest> req.data             # <<<<<<<<<<<<<<
+ *     transport = wrapper.transport
+ * 
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_req->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_wrapper = ((struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":213
+ * 
+ *     wrapper = <_TCPConnectRequest> req.data
+ *     transport = wrapper.transport             # <<<<<<<<<<<<<<
+ * 
+ *     if status < 0:
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_wrapper->transport);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_transport = ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/tcp.pyx":215
+ *     transport = wrapper.transport
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(status)
+ *     else:
+ */
+  __pyx_t_2 = ((__pyx_v_status < 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/tcp.pyx":216
+ * 
+ *     if status < 0:
+ *         exc = convert_error(status)             # <<<<<<<<<<<<<<
+ *     else:
+ *         exc = None
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_status); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 216, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/tcp.pyx":215
+ *     transport = wrapper.transport
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(status)
+ *     else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/tcp.pyx":218
+ *         exc = convert_error(status)
+ *     else:
+ *         exc = None             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+  /*else*/ {
+    __Pyx_INCREF(Py_None);
+    __pyx_v_exc = Py_None;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/tcp.pyx":220
+ *         exc = None
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:
+ */
+  /*try:*/ {
+    {
+      __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:*/ {
+
+        /* "uvloop/handles/tcp.pyx":221
+ * 
+ *     try:
+ *         transport._on_connect(exc)             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         wrapper.transport._fatal_error(ex, False)
+ */
+        __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_v_transport->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._on_connect(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_transport), __pyx_v_exc); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 221, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+        /* "uvloop/handles/tcp.pyx":220
+ *         exc = None
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:
+ */
+      }
+      __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_L12_try_end;
+      __pyx_L7_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/tcp.pyx":222
+ *     try:
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         wrapper.transport._fatal_error(ex, False)
+ *     finally:
+ */
+      __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_6) {
+        __Pyx_AddTraceback("uvloop.loop.__tcp_connect_callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(3, 222, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_7);
+        __pyx_v_ex = __pyx_t_7;
+        /*try:*/ {
+
+          /* "uvloop/handles/tcp.pyx":223
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:
+ *         wrapper.transport._fatal_error(ex, False)             # <<<<<<<<<<<<<<
+ *     finally:
+ *         wrapper.on_done()
+ */
+          __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_v_wrapper->transport->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_wrapper->transport), __pyx_v_ex, Py_False, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 223, __pyx_L18_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        }
+
+        /* "uvloop/handles/tcp.pyx":222
+ *     try:
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         wrapper.transport._fatal_error(ex, False)
+ *     finally:
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L19;
+          }
+          __pyx_L18_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+            __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+            __Pyx_XGOTREF(__pyx_t_12);
+            __Pyx_XGOTREF(__pyx_t_13);
+            __Pyx_XGOTREF(__pyx_t_14);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __pyx_t_6 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_15);
+              __Pyx_XGIVEREF(__pyx_t_16);
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+            }
+            __Pyx_XGIVEREF(__pyx_t_12);
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+            __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+            __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
+            goto __pyx_L9_except_error;
+          }
+          __pyx_L19:;
+        }
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        goto __pyx_L8_exception_handled;
+      }
+      goto __pyx_L9_except_error;
+      __pyx_L9_except_error:;
+
+      /* "uvloop/handles/tcp.pyx":220
+ *         exc = None
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:
+ */
+      __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_L5_error;
+      __pyx_L8_exception_handled:;
+      __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);
+      __pyx_L12_try_end:;
+    }
+  }
+
+  /* "uvloop/handles/tcp.pyx":225
+ *         wrapper.transport._fatal_error(ex, False)
+ *     finally:
+ *         wrapper.on_done()             # <<<<<<<<<<<<<<
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop__TCPConnectRequest *)__pyx_v_wrapper->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_wrapper)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 225, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_16, &__pyx_t_15);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_17);
+      __Pyx_XGOTREF(__pyx_t_16);
+      __Pyx_XGOTREF(__pyx_t_15);
+      __pyx_t_10 = __pyx_lineno; __pyx_t_6 = __pyx_clineno; __pyx_t_18 = __pyx_filename;
+      {
+        __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop__TCPConnectRequest *)__pyx_v_wrapper->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_wrapper)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 225, __pyx_L25_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15);
+      }
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_ErrRestore(__pyx_t_5, __pyx_t_4, __pyx_t_3);
+      __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+      __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_6; __pyx_filename = __pyx_t_18;
+      goto __pyx_L1_error;
+      __pyx_L25_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15);
+      }
+      __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;
+      __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/handles/tcp.pyx":207
+ * 
+ * 
+ * cdef void __tcp_connect_callback(uv.uv_connect_t* req, int status) with gil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         _TCPConnectRequest wrapper
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_WriteUnraisable("uvloop.loop.__tcp_connect_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_wrapper);
+  __Pyx_XDECREF((PyObject *)__pyx_v_transport);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/pipe.pyx":1
+ * cdef __pipe_init_uv_handle(UVStream handle, Loop loop):             # <<<<<<<<<<<<<<
+ *     cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___pipe_init_uv_handle(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_handle, CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop) {
+  int __pyx_v_err;
+  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("__pipe_init_uv_handle", 0);
+
+  /* "uvloop/handles/pipe.pyx":4
+ *     cdef int err
+ * 
+ *     handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_pipe_t))             # <<<<<<<<<<<<<<
+ *     if handle._handle is NULL:
+ *         handle._abort_init()
+ */
+  __pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._handle = ((uv_handle_t *)PyMem_RawMalloc((sizeof(uv_pipe_t))));
+
+  /* "uvloop/handles/pipe.pyx":5
+ * 
+ *     handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_pipe_t))
+ *     if handle._handle is NULL:             # <<<<<<<<<<<<<<
+ *         handle._abort_init()
+ *         raise MemoryError()
+ */
+  __pyx_t_1 = ((__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._handle == NULL) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/pipe.pyx":6
+ *     handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_pipe_t))
+ *     if handle._handle is NULL:
+ *         handle._abort_init()             # <<<<<<<<<<<<<<
+ *         raise MemoryError()
+ * 
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 6, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/pipe.pyx":7
+ *     if handle._handle is NULL:
+ *         handle._abort_init()
+ *         raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *     # Initialize pipe handle with ipc=0.
+ */
+    PyErr_NoMemory(); __PYX_ERR(20, 7, __pyx_L1_error)
+
+    /* "uvloop/handles/pipe.pyx":5
+ * 
+ *     handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_pipe_t))
+ *     if handle._handle is NULL:             # <<<<<<<<<<<<<<
+ *         handle._abort_init()
+ *         raise MemoryError()
+ */
+  }
+
+  /* "uvloop/handles/pipe.pyx":12
+ *     # ipc=1 means that libuv will use recvmsg/sendmsg
+ *     # instead of recv/send.
+ *     err = uv.uv_pipe_init(handle._loop.uvloop,             # <<<<<<<<<<<<<<
+ *                           <uv.uv_pipe_t*>handle._handle,
+ *                           0)
+ */
+  __pyx_v_err = uv_pipe_init(__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._loop->uvloop, ((uv_pipe_t *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._handle), 0);
+
+  /* "uvloop/handles/pipe.pyx":17
+ *     # UV_HANDLE_READABLE allows calling uv_read_start() on this pipe
+ *     # even if it is O_WRONLY, see also #317, libuv/libuv#2058
+ *     handle._handle.flags |= uv.UV_INTERNAL_HANDLE_READABLE             # <<<<<<<<<<<<<<
+ *     if err < 0:
+ *         handle._abort_init()
+ */
+  __pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._handle->flags = (__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._handle->flags | __pyx_e_6uvloop_8includes_2uv_UV_INTERNAL_HANDLE_READABLE);
+
+  /* "uvloop/handles/pipe.pyx":18
+ *     # even if it is O_WRONLY, see also #317, libuv/libuv#2058
+ *     handle._handle.flags |= uv.UV_INTERNAL_HANDLE_READABLE
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         handle._abort_init()
+ *         raise convert_error(err)
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/pipe.pyx":19
+ *     handle._handle.flags |= uv.UV_INTERNAL_HANDLE_READABLE
+ *     if err < 0:
+ *         handle._abort_init()             # <<<<<<<<<<<<<<
+ *         raise convert_error(err)
+ * 
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 19, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/pipe.pyx":20
+ *     if err < 0:
+ *         handle._abort_init()
+ *         raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *     handle._finish_init()
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 20, __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(20, 20, __pyx_L1_error)
+
+    /* "uvloop/handles/pipe.pyx":18
+ *     # even if it is O_WRONLY, see also #317, libuv/libuv#2058
+ *     handle._handle.flags |= uv.UV_INTERNAL_HANDLE_READABLE
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         handle._abort_init()
+ *         raise convert_error(err)
+ */
+  }
+
+  /* "uvloop/handles/pipe.pyx":22
+ *         raise convert_error(err)
+ * 
+ *     handle._finish_init()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._finish_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/pipe.pyx":1
+ * cdef __pipe_init_uv_handle(UVStream handle, Loop loop):             # <<<<<<<<<<<<<<
+ *     cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.__pipe_init_uv_handle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":25
+ * 
+ * 
+ * cdef __pipe_open(UVStream handle, int fd):             # <<<<<<<<<<<<<<
+ *     cdef int err
+ *     err = uv.uv_pipe_open(<uv.uv_pipe_t *>handle._handle,
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___pipe_open(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_handle, int __pyx_v_fd) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("__pipe_open", 0);
+
+  /* "uvloop/handles/pipe.pyx":27
+ * cdef __pipe_open(UVStream handle, int fd):
+ *     cdef int err
+ *     err = uv.uv_pipe_open(<uv.uv_pipe_t *>handle._handle,             # <<<<<<<<<<<<<<
+ *                           <uv.uv_file>fd)
+ *     if err < 0:
+ */
+  __pyx_v_err = uv_pipe_open(((uv_pipe_t *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base._handle), ((uv_file)__pyx_v_fd));
+
+  /* "uvloop/handles/pipe.pyx":29
+ *     err = uv.uv_pipe_open(<uv.uv_pipe_t *>handle._handle,
+ *                           <uv.uv_file>fd)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(err)
+ *         raise exc
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/pipe.pyx":30
+ *                           <uv.uv_file>fd)
+ *     if err < 0:
+ *         exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *         raise exc
+ * 
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 30, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/pipe.pyx":31
+ *     if err < 0:
+ *         exc = convert_error(err)
+ *         raise exc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(20, 31, __pyx_L1_error)
+
+    /* "uvloop/handles/pipe.pyx":29
+ *     err = uv.uv_pipe_open(<uv.uv_pipe_t *>handle._handle,
+ *                           <uv.uv_file>fd)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(err)
+ *         raise exc
+ */
+  }
+
+  /* "uvloop/handles/pipe.pyx":25
+ * 
+ * 
+ * cdef __pipe_open(UVStream handle, int fd):             # <<<<<<<<<<<<<<
+ *     cdef int err
+ *     err = uv.uv_pipe_open(<uv.uv_pipe_t *>handle._handle,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.__pipe_open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":34
+ * 
+ * 
+ * cdef __pipe_get_socket(UVSocketHandle handle):             # <<<<<<<<<<<<<<
+ *     fileno = handle._fileno()
+ *     return PseudoSocket(uv.AF_UNIX, uv.SOCK_STREAM, 0, fileno)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___pipe_get_socket(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_handle) {
+  PyObject *__pyx_v_fileno = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("__pipe_get_socket", 0);
+
+  /* "uvloop/handles/pipe.pyx":35
+ * 
+ * cdef __pipe_get_socket(UVSocketHandle handle):
+ *     fileno = handle._fileno()             # <<<<<<<<<<<<<<
+ *     return PseudoSocket(uv.AF_UNIX, uv.SOCK_STREAM, 0, fileno)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle *)__pyx_v_handle->__pyx_base.__pyx_vtab)->_fileno(__pyx_v_handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 35, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fileno = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":36
+ * cdef __pipe_get_socket(UVSocketHandle handle):
+ *     fileno = handle._fileno()
+ *     return PseudoSocket(uv.AF_UNIX, uv.SOCK_STREAM, 0, fileno)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_From_int(SOCK_STREAM); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_int_0);
+  __Pyx_INCREF(__pyx_v_fileno);
+  __Pyx_GIVEREF(__pyx_v_fileno);
+  PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v_fileno);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_PseudoSocket), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/pipe.pyx":34
+ * 
+ * 
+ * cdef __pipe_get_socket(UVSocketHandle handle):             # <<<<<<<<<<<<<<
+ *     fileno = handle._fileno()
+ *     return PseudoSocket(uv.AF_UNIX, uv.SOCK_STREAM, 0, fileno)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.__pipe_get_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fileno);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":43
+ * 
+ *     @staticmethod
+ *     cdef UnixServer new(Loop loop, object protocol_factory, Server server,             # <<<<<<<<<<<<<<
+ *                         object backlog,
+ *                         object ssl,
+ */
+
+static struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_f_6uvloop_4loop_10UnixServer_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol_factory, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_backlog, PyObject *__pyx_v_ssl, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout) {
+  struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_handle = 0;
+  struct __pyx_obj_6uvloop_4loop_UnixServer *__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("new", 0);
+
+  /* "uvloop/handles/pipe.pyx":50
+ * 
+ *         cdef UnixServer handle
+ *         handle = UnixServer.__new__(UnixServer)             # <<<<<<<<<<<<<<
+ *         handle._init(loop, protocol_factory, server, backlog,
+ *                      ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UnixServer(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UnixServer), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 50, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_UnixServer *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":51
+ *         cdef UnixServer handle
+ *         handle = UnixServer.__new__(UnixServer)
+ *         handle._init(loop, protocol_factory, server, backlog,             # <<<<<<<<<<<<<<
+ *                      ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_handle), __pyx_v_loop, __pyx_v_protocol_factory, __pyx_v_server, __pyx_v_backlog, __pyx_v_ssl, __pyx_v_ssl_handshake_timeout, __pyx_v_ssl_shutdown_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":53
+ *         handle._init(loop, protocol_factory, server, backlog,
+ *                      ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pipe_init_uv_handle(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_handle), __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":54
+ *                      ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _new_socket(self):
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/pipe.pyx":43
+ * 
+ *     @staticmethod
+ *     cdef UnixServer new(Loop loop, object protocol_factory, Server server,             # <<<<<<<<<<<<<<
+ *                         object backlog,
+ *                         object ssl,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UnixServer.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":56
+ *         return handle
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_10UnixServer__new_socket(struct __pyx_obj_6uvloop_4loop_UnixServer *__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("_new_socket", 0);
+
+  /* "uvloop/handles/pipe.pyx":57
+ * 
+ *     cdef _new_socket(self):
+ *         return __pipe_get_socket(<UVSocketHandle>self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _open(self, int sockfd):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pipe_get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/pipe.pyx":56
+ *         return handle
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UnixServer._new_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":59
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ *         __pipe_open(<UVStream>self, sockfd)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_10UnixServer__open(struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self, int __pyx_v_sockfd) {
+  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("_open", 0);
+
+  /* "uvloop/handles/pipe.pyx":60
+ * 
+ *     cdef _open(self, int sockfd):
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ *         __pipe_open(<UVStream>self, sockfd)
+ *         self._mark_as_open()
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":61
+ *     cdef _open(self, int sockfd):
+ *         self._ensure_alive()
+ *         __pipe_open(<UVStream>self, sockfd)             # <<<<<<<<<<<<<<
+ *         self._mark_as_open()
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pipe_open(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self), __pyx_v_sockfd); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":62
+ *         self._ensure_alive()
+ *         __pipe_open(<UVStream>self, sockfd)
+ *         self._mark_as_open()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef bind(self, str path):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._mark_as_open(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":59
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         self._ensure_alive()
+ *         __pipe_open(<UVStream>self, sockfd)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UnixServer._open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":64
+ *         self._mark_as_open()
+ * 
+ *     cdef bind(self, str path):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         self._ensure_alive()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_10UnixServer_bind(struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self, PyObject *__pyx_v_path) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  char const *__pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("bind", 0);
+
+  /* "uvloop/handles/pipe.pyx":66
+ *     cdef bind(self, str path):
+ *         cdef int err
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ *         err = uv.uv_pipe_bind(<uv.uv_pipe_t *>self._handle,
+ *                               path.encode())
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":68
+ *         self._ensure_alive()
+ *         err = uv.uv_pipe_bind(<uv.uv_pipe_t *>self._handle,
+ *                               path.encode())             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             exc = convert_error(err)
+ */
+  if (unlikely(__pyx_v_path == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode");
+    __PYX_ERR(20, 68, __pyx_L1_error)
+  }
+  __pyx_t_1 = PyUnicode_AsEncodedString(__pyx_v_path, NULL, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_t_1); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(20, 68, __pyx_L1_error)
+
+  /* "uvloop/handles/pipe.pyx":67
+ *         cdef int err
+ *         self._ensure_alive()
+ *         err = uv.uv_pipe_bind(<uv.uv_pipe_t *>self._handle,             # <<<<<<<<<<<<<<
+ *                               path.encode())
+ *         if err < 0:
+ */
+  __pyx_v_err = uv_pipe_bind(((uv_pipe_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":69
+ *         err = uv.uv_pipe_bind(<uv.uv_pipe_t *>self._handle,
+ *                               path.encode())
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  __pyx_t_3 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/pipe.pyx":70
+ *                               path.encode())
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 70, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/pipe.pyx":71
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 71, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/pipe.pyx":72
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._mark_as_open()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/pipe.pyx":69
+ *         err = uv.uv_pipe_bind(<uv.uv_pipe_t *>self._handle,
+ *                               path.encode())
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  }
+
+  /* "uvloop/handles/pipe.pyx":74
+ *             return
+ * 
+ *         self._mark_as_open()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef UVStream _make_new_transport(self, object protocol, object waiter,
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._mark_as_open(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":64
+ *         self._mark_as_open()
+ * 
+ *     cdef bind(self, str path):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         self._ensure_alive()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UnixServer.bind", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":76
+ *         self._mark_as_open()
+ * 
+ *     cdef UVStream _make_new_transport(self, object protocol, object waiter,             # <<<<<<<<<<<<<<
+ *                                       object context):
+ *         cdef UnixTransport tr
+ */
+
+static struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_f_6uvloop_4loop_10UnixServer__make_new_transport(struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self, PyObject *__pyx_v_protocol, PyObject *__pyx_v_waiter, PyObject *__pyx_v_context) {
+  struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_tr = 0;
+  struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("_make_new_transport", 0);
+
+  /* "uvloop/handles/pipe.pyx":79
+ *                                       object context):
+ *         cdef UnixTransport tr
+ *         tr = UnixTransport.new(self._loop, protocol, self._server, waiter,             # <<<<<<<<<<<<<<
+ *                                context)
+ *         return <UVStream>tr
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._loop);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_2 = ((PyObject *)__pyx_v_self->__pyx_base._server);
+  __Pyx_INCREF(__pyx_t_2);
+
+  /* "uvloop/handles/pipe.pyx":80
+ *         cdef UnixTransport tr
+ *         tr = UnixTransport.new(self._loop, protocol, self._server, waiter,
+ *                                context)             # <<<<<<<<<<<<<<
+ *         return <UVStream>tr
+ * 
+ */
+  __pyx_t_3 = ((PyObject *)__pyx_f_6uvloop_4loop_13UnixTransport_new(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_1), __pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_t_2), __pyx_v_waiter, __pyx_v_context)); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 79, __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;
+  __pyx_v_tr = ((struct __pyx_obj_6uvloop_4loop_UnixTransport *)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/handles/pipe.pyx":81
+ *         tr = UnixTransport.new(self._loop, protocol, self._server, waiter,
+ *                                context)
+ *         return <UVStream>tr             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_tr)));
+  __pyx_r = ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_tr);
+  goto __pyx_L0;
+
+  /* "uvloop/handles/pipe.pyx":76
+ *         self._mark_as_open()
+ * 
+ *     cdef UVStream _make_new_transport(self, object protocol, object waiter,             # <<<<<<<<<<<<<<
+ *                                       object context):
+ *         cdef UnixTransport tr
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UnixServer._make_new_transport", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_tr);
+  __Pyx_XGIVEREF((PyObject *)__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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_10UnixServer_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_10UnixServer___reduce_cython__[] = "UnixServer.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_10UnixServer_1__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_6uvloop_4loop_10UnixServer___reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UnixServer *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_10UnixServer___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UnixServer *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__167, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UnixServer.__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_6uvloop_4loop_10UnixServer_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_10UnixServer_2__setstate_cython__[] = "UnixServer.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_10UnixServer_3__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_6uvloop_4loop_10UnixServer_2__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UnixServer *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_10UnixServer_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UnixServer *__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);
+
+  /* "(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__168, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UnixServer.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":88
+ * 
+ *     @staticmethod
+ *     cdef UnixTransport new(Loop loop, object protocol, Server server,             # <<<<<<<<<<<<<<
+ *                            object waiter, object context):
+ * 
+ */
+
+static struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_f_6uvloop_4loop_13UnixTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter, PyObject *__pyx_v_context) {
+  struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_handle = 0;
+  struct __pyx_obj_6uvloop_4loop_UnixTransport *__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("new", 0);
+
+  /* "uvloop/handles/pipe.pyx":92
+ * 
+ *         cdef UnixTransport handle
+ *         handle = UnixTransport.__new__(UnixTransport)             # <<<<<<<<<<<<<<
+ *         handle._init(loop, protocol, server, waiter, context)
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UnixTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UnixTransport), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 92, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_UnixTransport *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":93
+ *         cdef UnixTransport handle
+ *         handle = UnixTransport.__new__(UnixTransport)
+ *         handle._init(loop, protocol, server, waiter, context)             # <<<<<<<<<<<<<<
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)
+ *         return handle
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_handle), __pyx_v_loop, __pyx_v_protocol, __pyx_v_server, __pyx_v_waiter, __pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":94
+ *         handle = UnixTransport.__new__(UnixTransport)
+ *         handle._init(loop, protocol, server, waiter, context)
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pipe_init_uv_handle(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_handle), __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":95
+ *         handle._init(loop, protocol, server, waiter, context)
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _new_socket(self):
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/pipe.pyx":88
+ * 
+ *     @staticmethod
+ *     cdef UnixTransport new(Loop loop, object protocol, Server server,             # <<<<<<<<<<<<<<
+ *                            object waiter, object context):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UnixTransport.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":97
+ *         return handle
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_13UnixTransport__new_socket(struct __pyx_obj_6uvloop_4loop_UnixTransport *__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("_new_socket", 0);
+
+  /* "uvloop/handles/pipe.pyx":98
+ * 
+ *     cdef _new_socket(self):
+ *         return __pipe_get_socket(<UVSocketHandle>self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _open(self, int sockfd):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pipe_get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/pipe.pyx":97
+ *         return handle
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UnixTransport._new_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":100
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_13UnixTransport__open(struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_self, int __pyx_v_sockfd) {
+  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("_open", 0);
+
+  /* "uvloop/handles/pipe.pyx":101
+ * 
+ *     cdef _open(self, int sockfd):
+ *         __pipe_open(<UVStream>self, sockfd)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef connect(self, char* addr):
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pipe_open(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self), __pyx_v_sockfd); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":100
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UnixTransport._open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":103
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ *     cdef connect(self, char* addr):             # <<<<<<<<<<<<<<
+ *         cdef _PipeConnectRequest req
+ *         req = _PipeConnectRequest(self._loop, self)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_13UnixTransport_connect(struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_self, char *__pyx_v_addr) {
+  struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__pyx_v_req = 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("connect", 0);
+
+  /* "uvloop/handles/pipe.pyx":105
+ *     cdef connect(self, char* addr):
+ *         cdef _PipeConnectRequest req
+ *         req = _PipeConnectRequest(self._loop, self)             # <<<<<<<<<<<<<<
+ *         req.connect(addr)
+ * 
+ */
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 105, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base._loop));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base._loop));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_base._loop));
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop__PipeConnectRequest), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 105, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_req = ((struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/pipe.pyx":106
+ *         cdef _PipeConnectRequest req
+ *         req = _PipeConnectRequest(self._loop, self)
+ *         req.connect(addr)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop__PipeConnectRequest *)__pyx_v_req->__pyx_base.__pyx_vtab)->connect(__pyx_v_req, __pyx_v_addr); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/pipe.pyx":103
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ *     cdef connect(self, char* addr):             # <<<<<<<<<<<<<<
+ *         cdef _PipeConnectRequest req
+ *         req = _PipeConnectRequest(self._loop, self)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UnixTransport.connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_req);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_13UnixTransport_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_13UnixTransport___reduce_cython__[] = "UnixTransport.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_13UnixTransport_1__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_6uvloop_4loop_13UnixTransport___reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UnixTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_13UnixTransport___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UnixTransport *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__169, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UnixTransport.__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_6uvloop_4loop_13UnixTransport_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_13UnixTransport_2__setstate_cython__[] = "UnixTransport.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_13UnixTransport_3__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_6uvloop_4loop_13UnixTransport_2__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UnixTransport *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_13UnixTransport_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UnixTransport *__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);
+
+  /* "(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__170, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UnixTransport.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":113
+ * 
+ *     @staticmethod
+ *     cdef ReadUnixTransport new(Loop loop, object protocol, Server server,             # <<<<<<<<<<<<<<
+ *                                object waiter):
+ *         cdef ReadUnixTransport handle
+ */
+
+static struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_f_6uvloop_4loop_17ReadUnixTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter) {
+  struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_handle = 0;
+  struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__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("new", 0);
+
+  /* "uvloop/handles/pipe.pyx":116
+ *                                object waiter):
+ *         cdef ReadUnixTransport handle
+ *         handle = ReadUnixTransport.__new__(ReadUnixTransport)             # <<<<<<<<<<<<<<
+ *         # This is only used in connect_read_pipe() and subprocess_shell/exec()
+ *         # directly, we could simply copy the current context.
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_ReadUnixTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_ReadUnixTransport), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 116, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":119
+ *         # This is only used in connect_read_pipe() and subprocess_shell/exec()
+ *         # directly, we could simply copy the current context.
+ *         handle._init(loop, protocol, server, waiter, Context_CopyCurrent())             # <<<<<<<<<<<<<<
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)
+ *         return handle
+ */
+  __pyx_t_1 = Context_CopyCurrent(); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_handle), __pyx_v_loop, __pyx_v_protocol, __pyx_v_server, __pyx_v_waiter, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/pipe.pyx":120
+ *         # directly, we could simply copy the current context.
+ *         handle._init(loop, protocol, server, waiter, Context_CopyCurrent())
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop___pipe_init_uv_handle(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_handle), __pyx_v_loop); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/pipe.pyx":121
+ *         handle._init(loop, protocol, server, waiter, Context_CopyCurrent())
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _new_socket(self):
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/pipe.pyx":113
+ * 
+ *     @staticmethod
+ *     cdef ReadUnixTransport new(Loop loop, object protocol, Server server,             # <<<<<<<<<<<<<<
+ *                                object waiter):
+ *         cdef ReadUnixTransport handle
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":123
+ *         return handle
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_17ReadUnixTransport__new_socket(struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__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("_new_socket", 0);
+
+  /* "uvloop/handles/pipe.pyx":124
+ * 
+ *     cdef _new_socket(self):
+ *         return __pipe_get_socket(<UVSocketHandle>self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _open(self, int sockfd):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pipe_get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/pipe.pyx":123
+ *         return handle
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport._new_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":126
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_17ReadUnixTransport__open(struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, int __pyx_v_sockfd) {
+  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("_open", 0);
+
+  /* "uvloop/handles/pipe.pyx":127
+ * 
+ *     cdef _open(self, int sockfd):
+ *         __pipe_open(<UVStream>self, sockfd)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_write_buffer_limits(self):
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pipe_open(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self), __pyx_v_sockfd); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":126
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport._open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":129
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ *     def get_write_buffer_limits(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_1get_write_buffer_limits(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_17ReadUnixTransport_get_write_buffer_limits[] = "ReadUnixTransport.get_write_buffer_limits(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_1get_write_buffer_limits(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_write_buffer_limits (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_17ReadUnixTransport_get_write_buffer_limits(((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_get_write_buffer_limits(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_write_buffer_limits", 0);
+
+  /* "uvloop/handles/pipe.pyx":130
+ * 
+ *     def get_write_buffer_limits(self):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     def set_write_buffer_limits(self, high=None, low=None):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(20, 130, __pyx_L1_error)
+
+  /* "uvloop/handles/pipe.pyx":129
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ *     def get_write_buffer_limits(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.get_write_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":132
+ *         raise NotImplementedError
+ * 
+ *     def set_write_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_3set_write_buffer_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_17ReadUnixTransport_2set_write_buffer_limits[] = "ReadUnixTransport.set_write_buffer_limits(self, high=None, low=None)";
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_3set_write_buffer_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_high = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_low = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_write_buffer_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,0};
+    PyObject* values[2] = {0,0};
+    values[0] = ((PyObject *)Py_None);
+    values[1] = ((PyObject *)Py_None);
+    if (unlikely(__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);
+        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 (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high);
+          if (value) { values[0] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_write_buffer_limits") < 0)) __PYX_ERR(20, 132, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        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;
+      }
+    }
+    __pyx_v_high = values[0];
+    __pyx_v_low = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_write_buffer_limits", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 132, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.set_write_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_17ReadUnixTransport_2set_write_buffer_limits(((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self), __pyx_v_high, __pyx_v_low);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_2set_write_buffer_limits(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_high, CYTHON_UNUSED PyObject *__pyx_v_low) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_write_buffer_limits", 0);
+
+  /* "uvloop/handles/pipe.pyx":133
+ * 
+ *     def set_write_buffer_limits(self, high=None, low=None):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     def get_write_buffer_size(self):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(20, 133, __pyx_L1_error)
+
+  /* "uvloop/handles/pipe.pyx":132
+ *         raise NotImplementedError
+ * 
+ *     def set_write_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.set_write_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":135
+ *         raise NotImplementedError
+ * 
+ *     def get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_5get_write_buffer_size(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_17ReadUnixTransport_4get_write_buffer_size[] = "ReadUnixTransport.get_write_buffer_size(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_5get_write_buffer_size(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_write_buffer_size (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_17ReadUnixTransport_4get_write_buffer_size(((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_4get_write_buffer_size(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_write_buffer_size", 0);
+
+  /* "uvloop/handles/pipe.pyx":136
+ * 
+ *     def get_write_buffer_size(self):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     def write(self, data):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(20, 136, __pyx_L1_error)
+
+  /* "uvloop/handles/pipe.pyx":135
+ *         raise NotImplementedError
+ * 
+ *     def get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.get_write_buffer_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":138
+ *         raise NotImplementedError
+ * 
+ *     def write(self, data):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_7write(PyObject *__pyx_v_self, PyObject *__pyx_v_data); /*proto*/
+static char __pyx_doc_6uvloop_4loop_17ReadUnixTransport_6write[] = "ReadUnixTransport.write(self, data)";
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_7write(PyObject *__pyx_v_self, PyObject *__pyx_v_data) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("write (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_17ReadUnixTransport_6write(((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self), ((PyObject *)__pyx_v_data));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_6write(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_data) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("write", 0);
+
+  /* "uvloop/handles/pipe.pyx":139
+ * 
+ *     def write(self, data):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     def writelines(self, list_of_data):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(20, 139, __pyx_L1_error)
+
+  /* "uvloop/handles/pipe.pyx":138
+ *         raise NotImplementedError
+ * 
+ *     def write(self, data):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":141
+ *         raise NotImplementedError
+ * 
+ *     def writelines(self, list_of_data):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_9writelines(PyObject *__pyx_v_self, PyObject *__pyx_v_list_of_data); /*proto*/
+static char __pyx_doc_6uvloop_4loop_17ReadUnixTransport_8writelines[] = "ReadUnixTransport.writelines(self, list_of_data)";
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_9writelines(PyObject *__pyx_v_self, PyObject *__pyx_v_list_of_data) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("writelines (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_17ReadUnixTransport_8writelines(((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self), ((PyObject *)__pyx_v_list_of_data));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_8writelines(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_list_of_data) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("writelines", 0);
+
+  /* "uvloop/handles/pipe.pyx":142
+ * 
+ *     def writelines(self, list_of_data):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     def write_eof(self):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(20, 142, __pyx_L1_error)
+
+  /* "uvloop/handles/pipe.pyx":141
+ *         raise NotImplementedError
+ * 
+ *     def writelines(self, list_of_data):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.writelines", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":144
+ *         raise NotImplementedError
+ * 
+ *     def write_eof(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_11write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_17ReadUnixTransport_10write_eof[] = "ReadUnixTransport.write_eof(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_11write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("write_eof (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_17ReadUnixTransport_10write_eof(((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_10write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("write_eof", 0);
+
+  /* "uvloop/handles/pipe.pyx":145
+ * 
+ *     def write_eof(self):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     def can_write_eof(self):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(20, 145, __pyx_L1_error)
+
+  /* "uvloop/handles/pipe.pyx":144
+ *         raise NotImplementedError
+ * 
+ *     def write_eof(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.write_eof", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":147
+ *         raise NotImplementedError
+ * 
+ *     def can_write_eof(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_13can_write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_17ReadUnixTransport_12can_write_eof[] = "ReadUnixTransport.can_write_eof(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_13can_write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("can_write_eof (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_17ReadUnixTransport_12can_write_eof(((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_12can_write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("can_write_eof", 0);
+
+  /* "uvloop/handles/pipe.pyx":148
+ * 
+ *     def can_write_eof(self):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     def abort(self):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(20, 148, __pyx_L1_error)
+
+  /* "uvloop/handles/pipe.pyx":147
+ *         raise NotImplementedError
+ * 
+ *     def can_write_eof(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.can_write_eof", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":150
+ *         raise NotImplementedError
+ * 
+ *     def abort(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_15abort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_17ReadUnixTransport_14abort[] = "ReadUnixTransport.abort(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_15abort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("abort (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_17ReadUnixTransport_14abort(((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_14abort(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("abort", 0);
+
+  /* "uvloop/handles/pipe.pyx":151
+ * 
+ *     def abort(self):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(20, 151, __pyx_L1_error)
+
+  /* "uvloop/handles/pipe.pyx":150
+ *         raise NotImplementedError
+ * 
+ *     def abort(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.abort", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_17__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_17ReadUnixTransport_16__reduce_cython__[] = "ReadUnixTransport.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_17__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_6uvloop_4loop_17ReadUnixTransport_16__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__171, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.__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_6uvloop_4loop_17ReadUnixTransport_19__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_17ReadUnixTransport_18__setstate_cython__[] = "ReadUnixTransport.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_17ReadUnixTransport_19__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_6uvloop_4loop_17ReadUnixTransport_18__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__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);
+
+  /* "(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__172, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.ReadUnixTransport.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":158
+ * 
+ *     @staticmethod
+ *     cdef WriteUnixTransport new(Loop loop, object protocol, Server server,             # <<<<<<<<<<<<<<
+ *                                 object waiter):
+ *         cdef WriteUnixTransport handle
+ */
+
+static struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_f_6uvloop_4loop_18WriteUnixTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter) {
+  struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_handle = 0;
+  struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__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("new", 0);
+
+  /* "uvloop/handles/pipe.pyx":161
+ *                                 object waiter):
+ *         cdef WriteUnixTransport handle
+ *         handle = WriteUnixTransport.__new__(WriteUnixTransport)             # <<<<<<<<<<<<<<
+ * 
+ *         # We listen for read events on write-end of the pipe. When
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_WriteUnixTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_WriteUnixTransport), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 161, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":167
+ *         # receive an error -- we want to silence that error, and just
+ *         # close the transport.
+ *         handle._close_on_read_error()             # <<<<<<<<<<<<<<
+ * 
+ *         # This is only used in connect_write_pipe() and subprocess_shell/exec()
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._close_on_read_error(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_handle)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":171
+ *         # This is only used in connect_write_pipe() and subprocess_shell/exec()
+ *         # directly, we could simply copy the current context.
+ *         handle._init(loop, protocol, server, waiter, Context_CopyCurrent())             # <<<<<<<<<<<<<<
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)
+ *         return handle
+ */
+  __pyx_t_1 = Context_CopyCurrent(); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_handle), __pyx_v_loop, __pyx_v_protocol, __pyx_v_server, __pyx_v_waiter, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/pipe.pyx":172
+ *         # directly, we could simply copy the current context.
+ *         handle._init(loop, protocol, server, waiter, Context_CopyCurrent())
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)             # <<<<<<<<<<<<<<
+ *         return handle
+ * 
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop___pipe_init_uv_handle(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_handle), __pyx_v_loop); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/pipe.pyx":173
+ *         handle._init(loop, protocol, server, waiter, Context_CopyCurrent())
+ *         __pipe_init_uv_handle(<UVStream>handle, loop)
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _new_socket(self):
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/pipe.pyx":158
+ * 
+ *     @staticmethod
+ *     cdef WriteUnixTransport new(Loop loop, object protocol, Server server,             # <<<<<<<<<<<<<<
+ *                                 object waiter):
+ *         cdef WriteUnixTransport handle
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.WriteUnixTransport.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":175
+ *         return handle
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18WriteUnixTransport__new_socket(struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__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("_new_socket", 0);
+
+  /* "uvloop/handles/pipe.pyx":176
+ * 
+ *     cdef _new_socket(self):
+ *         return __pipe_get_socket(<UVSocketHandle>self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _open(self, int sockfd):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pipe_get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/pipe.pyx":175
+ *         return handle
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.WriteUnixTransport._new_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":178
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18WriteUnixTransport__open(struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self, int __pyx_v_sockfd) {
+  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("_open", 0);
+
+  /* "uvloop/handles/pipe.pyx":179
+ * 
+ *     cdef _open(self, int sockfd):
+ *         __pipe_open(<UVStream>self, sockfd)             # <<<<<<<<<<<<<<
+ * 
+ *     def pause_reading(self):
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___pipe_open(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_self), __pyx_v_sockfd); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":178
+ *         return __pipe_get_socket(<UVSocketHandle>self)
+ * 
+ *     cdef _open(self, int sockfd):             # <<<<<<<<<<<<<<
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.WriteUnixTransport._open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":181
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ *     def pause_reading(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18WriteUnixTransport_1pause_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18WriteUnixTransport_pause_reading[] = "WriteUnixTransport.pause_reading(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18WriteUnixTransport_1pause_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("pause_reading (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18WriteUnixTransport_pause_reading(((struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18WriteUnixTransport_pause_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("pause_reading", 0);
+
+  /* "uvloop/handles/pipe.pyx":182
+ * 
+ *     def pause_reading(self):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     def resume_reading(self):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(20, 182, __pyx_L1_error)
+
+  /* "uvloop/handles/pipe.pyx":181
+ *         __pipe_open(<UVStream>self, sockfd)
+ * 
+ *     def pause_reading(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.WriteUnixTransport.pause_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":184
+ *         raise NotImplementedError
+ * 
+ *     def resume_reading(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18WriteUnixTransport_3resume_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18WriteUnixTransport_2resume_reading[] = "WriteUnixTransport.resume_reading(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18WriteUnixTransport_3resume_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resume_reading (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18WriteUnixTransport_2resume_reading(((struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18WriteUnixTransport_2resume_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("resume_reading", 0);
+
+  /* "uvloop/handles/pipe.pyx":185
+ * 
+ *     def resume_reading(self):
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(20, 185, __pyx_L1_error)
+
+  /* "uvloop/handles/pipe.pyx":184
+ *         raise NotImplementedError
+ * 
+ *     def resume_reading(self):             # <<<<<<<<<<<<<<
+ *         raise NotImplementedError
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.WriteUnixTransport.resume_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18WriteUnixTransport_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18WriteUnixTransport_4__reduce_cython__[] = "WriteUnixTransport.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18WriteUnixTransport_5__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_6uvloop_4loop_18WriteUnixTransport_4__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18WriteUnixTransport_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__173, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.WriteUnixTransport.__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_6uvloop_4loop_18WriteUnixTransport_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18WriteUnixTransport_6__setstate_cython__[] = "WriteUnixTransport.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_18WriteUnixTransport_7__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_6uvloop_4loop_18WriteUnixTransport_6__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18WriteUnixTransport_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__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);
+
+  /* "(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__174, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.WriteUnixTransport.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":193
+ *         uv.uv_connect_t _req_data
+ * 
+ *     def __cinit__(self, loop, transport):             # <<<<<<<<<<<<<<
+ *         self.request = <uv.uv_req_t*> &self._req_data
+ *         self.request.data = <void*>self
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_19_PipeConnectRequest_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_19_PipeConnectRequest_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_loop = 0;
+  PyObject *__pyx_v_transport = 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_loop,&__pyx_n_s_transport,0};
+    PyObject* values[2] = {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  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_loop)) != 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_transport)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, 1); __PYX_ERR(20, 193, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(20, 193, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_loop = values[0];
+    __pyx_v_transport = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 193, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop._PipeConnectRequest.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_19_PipeConnectRequest___cinit__(((struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *)__pyx_v_self), __pyx_v_loop, __pyx_v_transport);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_19_PipeConnectRequest___cinit__(struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_loop, PyObject *__pyx_v_transport) {
+  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);
+
+  /* "uvloop/handles/pipe.pyx":194
+ * 
+ *     def __cinit__(self, loop, transport):
+ *         self.request = <uv.uv_req_t*> &self._req_data             # <<<<<<<<<<<<<<
+ *         self.request.data = <void*>self
+ *         self.transport = transport
+ */
+  __pyx_v_self->__pyx_base.request = ((uv_req_t *)(&__pyx_v_self->_req_data));
+
+  /* "uvloop/handles/pipe.pyx":195
+ *     def __cinit__(self, loop, transport):
+ *         self.request = <uv.uv_req_t*> &self._req_data
+ *         self.request.data = <void*>self             # <<<<<<<<<<<<<<
+ *         self.transport = transport
+ * 
+ */
+  __pyx_v_self->__pyx_base.request->data = ((void *)__pyx_v_self);
+
+  /* "uvloop/handles/pipe.pyx":196
+ *         self.request = <uv.uv_req_t*> &self._req_data
+ *         self.request.data = <void*>self
+ *         self.transport = transport             # <<<<<<<<<<<<<<
+ * 
+ *     cdef connect(self, char* addr):
+ */
+  if (!(likely(((__pyx_v_transport) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_transport, __pyx_ptype_6uvloop_4loop_UnixTransport))))) __PYX_ERR(20, 196, __pyx_L1_error)
+  __pyx_t_1 = __pyx_v_transport;
+  __Pyx_INCREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->transport);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->transport));
+  __pyx_v_self->transport = ((struct __pyx_obj_6uvloop_4loop_UnixTransport *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":193
+ *         uv.uv_connect_t _req_data
+ * 
+ *     def __cinit__(self, loop, transport):             # <<<<<<<<<<<<<<
+ *         self.request = <uv.uv_req_t*> &self._req_data
+ *         self.request.data = <void*>self
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._PipeConnectRequest.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":198
+ *         self.transport = transport
+ * 
+ *     cdef connect(self, char* addr):             # <<<<<<<<<<<<<<
+ *         # uv_pipe_connect returns void
+ *         uv.uv_pipe_connect(<uv.uv_connect_t*>self.request,
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_19_PipeConnectRequest_connect(struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__pyx_v_self, char *__pyx_v_addr) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connect", 0);
+
+  /* "uvloop/handles/pipe.pyx":200
+ *     cdef connect(self, char* addr):
+ *         # uv_pipe_connect returns void
+ *         uv.uv_pipe_connect(<uv.uv_connect_t*>self.request,             # <<<<<<<<<<<<<<
+ *                            <uv.uv_pipe_t*>self.transport._handle,
+ *                            addr,
+ */
+  uv_pipe_connect(((uv_connect_t *)__pyx_v_self->__pyx_base.request), ((uv_pipe_t *)__pyx_v_self->transport->__pyx_base.__pyx_base.__pyx_base.__pyx_base._handle), __pyx_v_addr, __pyx_f_6uvloop_4loop___pipe_connect_callback);
+
+  /* "uvloop/handles/pipe.pyx":198
+ *         self.transport = transport
+ * 
+ *     cdef connect(self, char* addr):             # <<<<<<<<<<<<<<
+ *         # uv_pipe_connect returns void
+ *         uv.uv_pipe_connect(<uv.uv_connect_t*>self.request,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_19_PipeConnectRequest_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_19_PipeConnectRequest_2__reduce_cython__[] = "_PipeConnectRequest.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_19_PipeConnectRequest_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_6uvloop_4loop_19_PipeConnectRequest_2__reduce_cython__(((struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_19_PipeConnectRequest_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__175, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._PipeConnectRequest.__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_6uvloop_4loop_19_PipeConnectRequest_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_19_PipeConnectRequest_4__setstate_cython__[] = "_PipeConnectRequest.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_19_PipeConnectRequest_5__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_6uvloop_4loop_19_PipeConnectRequest_4__setstate_cython__(((struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_19_PipeConnectRequest_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__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);
+
+  /* "(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__176, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._PipeConnectRequest.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/pipe.pyx":205
+ *                            __pipe_connect_callback)
+ * 
+ * cdef void __pipe_connect_callback(uv.uv_connect_t* req, int status) with gil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         _PipeConnectRequest wrapper
+ */
+
+static void __pyx_f_6uvloop_4loop___pipe_connect_callback(uv_connect_t *__pyx_v_req, int __pyx_v_status) {
+  struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__pyx_v_wrapper = 0;
+  struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_transport = 0;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  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;
+  int __pyx_t_10;
+  char const *__pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  char const *__pyx_t_18;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__pipe_connect_callback", 0);
+
+  /* "uvloop/handles/pipe.pyx":210
+ *         UnixTransport transport
+ * 
+ *     wrapper = <_PipeConnectRequest> req.data             # <<<<<<<<<<<<<<
+ *     transport = wrapper.transport
+ * 
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_req->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_wrapper = ((struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":211
+ * 
+ *     wrapper = <_PipeConnectRequest> req.data
+ *     transport = wrapper.transport             # <<<<<<<<<<<<<<
+ * 
+ *     if status < 0:
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_wrapper->transport);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_transport = ((struct __pyx_obj_6uvloop_4loop_UnixTransport *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/pipe.pyx":213
+ *     transport = wrapper.transport
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(status)
+ *     else:
+ */
+  __pyx_t_2 = ((__pyx_v_status < 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/pipe.pyx":214
+ * 
+ *     if status < 0:
+ *         exc = convert_error(status)             # <<<<<<<<<<<<<<
+ *     else:
+ *         exc = None
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_status); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 214, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/pipe.pyx":213
+ *     transport = wrapper.transport
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(status)
+ *     else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/pipe.pyx":216
+ *         exc = convert_error(status)
+ *     else:
+ *         exc = None             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+  /*else*/ {
+    __Pyx_INCREF(Py_None);
+    __pyx_v_exc = Py_None;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/pipe.pyx":218
+ *         exc = None
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:
+ */
+  /*try:*/ {
+    {
+      __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:*/ {
+
+        /* "uvloop/handles/pipe.pyx":219
+ * 
+ *     try:
+ *         transport._on_connect(exc)             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         wrapper.transport._fatal_error(ex, False)
+ */
+        __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_v_transport->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._on_connect(((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_v_transport), __pyx_v_exc); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 219, __pyx_L7_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+        /* "uvloop/handles/pipe.pyx":218
+ *         exc = None
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:
+ */
+      }
+      __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_L12_try_end;
+      __pyx_L7_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/pipe.pyx":220
+ *     try:
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         wrapper.transport._fatal_error(ex, False)
+ *     finally:
+ */
+      __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_6) {
+        __Pyx_AddTraceback("uvloop.loop.__pipe_connect_callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(20, 220, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_7);
+        __pyx_v_ex = __pyx_t_7;
+        /*try:*/ {
+
+          /* "uvloop/handles/pipe.pyx":221
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:
+ *         wrapper.transport._fatal_error(ex, False)             # <<<<<<<<<<<<<<
+ *     finally:
+ *         wrapper.on_done()
+ */
+          __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_v_wrapper->transport->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_wrapper->transport), __pyx_v_ex, Py_False, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(20, 221, __pyx_L18_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        }
+
+        /* "uvloop/handles/pipe.pyx":220
+ *     try:
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         wrapper.transport._fatal_error(ex, False)
+ *     finally:
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L19;
+          }
+          __pyx_L18_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+            __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+            __Pyx_XGOTREF(__pyx_t_12);
+            __Pyx_XGOTREF(__pyx_t_13);
+            __Pyx_XGOTREF(__pyx_t_14);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __pyx_t_6 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_15);
+              __Pyx_XGIVEREF(__pyx_t_16);
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+            }
+            __Pyx_XGIVEREF(__pyx_t_12);
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+            __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+            __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
+            goto __pyx_L9_except_error;
+          }
+          __pyx_L19:;
+        }
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        goto __pyx_L8_exception_handled;
+      }
+      goto __pyx_L9_except_error;
+      __pyx_L9_except_error:;
+
+      /* "uvloop/handles/pipe.pyx":218
+ *         exc = None
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         transport._on_connect(exc)
+ *     except BaseException as ex:
+ */
+      __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_L5_error;
+      __pyx_L8_exception_handled:;
+      __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);
+      __pyx_L12_try_end:;
+    }
+  }
+
+  /* "uvloop/handles/pipe.pyx":223
+ *         wrapper.transport._fatal_error(ex, False)
+ *     finally:
+ *         wrapper.on_done()             # <<<<<<<<<<<<<<
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop__PipeConnectRequest *)__pyx_v_wrapper->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_wrapper)); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 223, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_16, &__pyx_t_15);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_17);
+      __Pyx_XGOTREF(__pyx_t_16);
+      __Pyx_XGOTREF(__pyx_t_15);
+      __pyx_t_10 = __pyx_lineno; __pyx_t_6 = __pyx_clineno; __pyx_t_18 = __pyx_filename;
+      {
+        __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop__PipeConnectRequest *)__pyx_v_wrapper->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_wrapper)); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 223, __pyx_L25_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15);
+      }
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_ErrRestore(__pyx_t_5, __pyx_t_4, __pyx_t_3);
+      __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+      __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_6; __pyx_filename = __pyx_t_18;
+      goto __pyx_L1_error;
+      __pyx_L25_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_17);
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15);
+      }
+      __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;
+      __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/handles/pipe.pyx":205
+ *                            __pipe_connect_callback)
+ * 
+ * cdef void __pipe_connect_callback(uv.uv_connect_t* req, int status) with gil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         _PipeConnectRequest wrapper
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_WriteUnraisable("uvloop.loop.__pipe_connect_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_wrapper);
+  __Pyx_XDECREF((PyObject *)__pyx_v_transport);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/process.pyx":5
+ *     """Abstract class; wrapper over uv_process_t handle."""
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.uv_opt_env = NULL
+ *         self.uv_opt_args = NULL
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_9UVProcess_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_9UVProcess_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_6uvloop_4loop_9UVProcess___cinit__(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_9UVProcess___cinit__(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self) {
+  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);
+
+  /* "uvloop/handles/process.pyx":6
+ * 
+ *     def __cinit__(self):
+ *         self.uv_opt_env = NULL             # <<<<<<<<<<<<<<
+ *         self.uv_opt_args = NULL
+ *         self._returncode = None
+ */
+  __pyx_v_self->uv_opt_env = NULL;
+
+  /* "uvloop/handles/process.pyx":7
+ *     def __cinit__(self):
+ *         self.uv_opt_env = NULL
+ *         self.uv_opt_args = NULL             # <<<<<<<<<<<<<<
+ *         self._returncode = None
+ *         self._pid = None
+ */
+  __pyx_v_self->uv_opt_args = NULL;
+
+  /* "uvloop/handles/process.pyx":8
+ *         self.uv_opt_env = NULL
+ *         self.uv_opt_args = NULL
+ *         self._returncode = None             # <<<<<<<<<<<<<<
+ *         self._pid = None
+ *         self._fds_to_close = set()
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_returncode);
+  __Pyx_DECREF(__pyx_v_self->_returncode);
+  __pyx_v_self->_returncode = Py_None;
+
+  /* "uvloop/handles/process.pyx":9
+ *         self.uv_opt_args = NULL
+ *         self._returncode = None
+ *         self._pid = None             # <<<<<<<<<<<<<<
+ *         self._fds_to_close = set()
+ *         self._preexec_fn = None
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_pid);
+  __Pyx_DECREF(__pyx_v_self->_pid);
+  __pyx_v_self->_pid = Py_None;
+
+  /* "uvloop/handles/process.pyx":10
+ *         self._returncode = None
+ *         self._pid = None
+ *         self._fds_to_close = set()             # <<<<<<<<<<<<<<
+ *         self._preexec_fn = None
+ *         self._restore_signals = True
+ */
+  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 10, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_fds_to_close);
+  __Pyx_DECREF(__pyx_v_self->_fds_to_close);
+  __pyx_v_self->_fds_to_close = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":11
+ *         self._pid = None
+ *         self._fds_to_close = set()
+ *         self._preexec_fn = None             # <<<<<<<<<<<<<<
+ *         self._restore_signals = True
+ *         self.context = Context_CopyCurrent()
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_preexec_fn);
+  __Pyx_DECREF(__pyx_v_self->_preexec_fn);
+  __pyx_v_self->_preexec_fn = Py_None;
+
+  /* "uvloop/handles/process.pyx":12
+ *         self._fds_to_close = set()
+ *         self._preexec_fn = None
+ *         self._restore_signals = True             # <<<<<<<<<<<<<<
+ *         self.context = Context_CopyCurrent()
+ * 
+ */
+  __pyx_v_self->_restore_signals = 1;
+
+  /* "uvloop/handles/process.pyx":13
+ *         self._preexec_fn = None
+ *         self._restore_signals = True
+ *         self.context = Context_CopyCurrent()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _close_process_handle(self):
+ */
+  __pyx_t_1 = Context_CopyCurrent(); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 13, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->__pyx_base.context);
+  __Pyx_DECREF(__pyx_v_self->__pyx_base.context);
+  __pyx_v_self->__pyx_base.context = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":5
+ *     """Abstract class; wrapper over uv_process_t handle."""
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.uv_opt_env = NULL
+ *         self.uv_opt_args = NULL
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":15
+ *         self.context = Context_CopyCurrent()
+ * 
+ *     cdef _close_process_handle(self):             # <<<<<<<<<<<<<<
+ *         # XXX: This is a workaround for a libuv bug:
+ *         # - https://github.com/libuv/libuv/issues/1933
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__close_process_handle(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("_close_process_handle", 0);
+
+  /* "uvloop/handles/process.pyx":19
+ *         # - https://github.com/libuv/libuv/issues/1933
+ *         # - https://github.com/libuv/libuv/pull/551
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             return
+ *         self._handle.data = NULL
+ */
+  __pyx_t_1 = ((__pyx_v_self->__pyx_base._handle == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":20
+ *         # - https://github.com/libuv/libuv/pull/551
+ *         if self._handle is NULL:
+ *             return             # <<<<<<<<<<<<<<
+ *         self._handle.data = NULL
+ *         uv.uv_close(self._handle, __uv_close_process_handle_cb)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/process.pyx":19
+ *         # - https://github.com/libuv/libuv/issues/1933
+ *         # - https://github.com/libuv/libuv/pull/551
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             return
+ *         self._handle.data = NULL
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":21
+ *         if self._handle is NULL:
+ *             return
+ *         self._handle.data = NULL             # <<<<<<<<<<<<<<
+ *         uv.uv_close(self._handle, __uv_close_process_handle_cb)
+ *         self._handle = NULL  # close callback will free() the memory
+ */
+  __pyx_v_self->__pyx_base._handle->data = NULL;
+
+  /* "uvloop/handles/process.pyx":22
+ *             return
+ *         self._handle.data = NULL
+ *         uv.uv_close(self._handle, __uv_close_process_handle_cb)             # <<<<<<<<<<<<<<
+ *         self._handle = NULL  # close callback will free() the memory
+ * 
+ */
+  uv_close(__pyx_v_self->__pyx_base._handle, __pyx_f_6uvloop_4loop___uv_close_process_handle_cb);
+
+  /* "uvloop/handles/process.pyx":23
+ *         self._handle.data = NULL
+ *         uv.uv_close(self._handle, __uv_close_process_handle_cb)
+ *         self._handle = NULL  # close callback will free() the memory             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _init(self, Loop loop, list args, dict env,
+ */
+  __pyx_v_self->__pyx_base._handle = NULL;
+
+  /* "uvloop/handles/process.pyx":15
+ *         self.context = Context_CopyCurrent()
+ * 
+ *     cdef _close_process_handle(self):             # <<<<<<<<<<<<<<
+ *         # XXX: This is a workaround for a libuv bug:
+ *         # - https://github.com/libuv/libuv/issues/1933
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":25
+ *         self._handle = NULL  # close callback will free() the memory
+ * 
+ *     cdef _init(self, Loop loop, list args, dict env,             # <<<<<<<<<<<<<<
+ *                cwd, start_new_session,
+ *                _stdin, _stdout, _stderr,  # std* can be defined as macros in C
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_args, PyObject *__pyx_v_env, PyObject *__pyx_v_cwd, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr, PyObject *__pyx_v_pass_fds, PyObject *__pyx_v_debug_flags, PyObject *__pyx_v_preexec_fn, PyObject *__pyx_v_restore_signals) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_restore_inheritable = NULL;
+  PyObject *__pyx_v_fd = NULL;
+  PyObject *__pyx_v_errpipe_data = NULL;
+  PyObject *__pyx_v_part = NULL;
+  PyObject *__pyx_v_fds_to_close = NULL;
+  PyObject *__pyx_v_exc_name = NULL;
+  PyObject *__pyx_v_exc_msg = NULL;
+  PyObject *__pyx_v_exc_cls = NULL;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  Py_ssize_t __pyx_t_6;
+  PyObject *(*__pyx_t_7)(PyObject *);
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  int __pyx_t_12;
+  int __pyx_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_t_15;
+  PyObject *(*__pyx_t_16)(PyObject *);
+  Py_ssize_t __pyx_t_17;
+  int __pyx_t_18;
+  char const *__pyx_t_19;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  PyObject *__pyx_t_23 = NULL;
+  PyObject *__pyx_t_24 = NULL;
+  PyObject *__pyx_t_25 = NULL;
+  int __pyx_t_26;
+  int __pyx_t_27;
+  PyObject *__pyx_t_28 = NULL;
+  PyObject *__pyx_t_29 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init", 0);
+
+  /* "uvloop/handles/process.pyx":36
+ *         cdef int err
+ * 
+ *         self._start_init(loop)             # <<<<<<<<<<<<<<
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._start_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":38
+ *         self._start_init(loop)
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(             # <<<<<<<<<<<<<<
+ *             sizeof(uv.uv_process_t))
+ *         if self._handle is NULL:
+ */
+  __pyx_v_self->__pyx_base._handle = ((uv_handle_t *)PyMem_RawMalloc((sizeof(uv_process_t))));
+
+  /* "uvloop/handles/process.pyx":40
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(
+ *             sizeof(uv.uv_process_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  __pyx_t_2 = ((__pyx_v_self->__pyx_base._handle == NULL) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/process.pyx":41
+ *             sizeof(uv.uv_process_t))
+ *         if self._handle is NULL:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 41, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/process.pyx":42
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *         # Too early to call _finish_init, but still a lot of work to do.
+ */
+    PyErr_NoMemory(); __PYX_ERR(4, 42, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":40
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(
+ *             sizeof(uv.uv_process_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":47
+ *         # Let's set handle.data to NULL, so in case something goes wrong,
+ *         # callbacks have a chance to avoid casting *something* into UVHandle.
+ *         self._handle.data = NULL             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_v_self->__pyx_base._handle->data = NULL;
+
+  /* "uvloop/handles/process.pyx":49
+ *         self._handle.data = NULL
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._init_options(args, env, cwd, start_new_session,
+ *                                _stdin, _stdout, _stderr)
+ */
+  {
+    __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:*/ {
+
+      /* "uvloop/handles/process.pyx":50
+ * 
+ *         try:
+ *             self._init_options(args, env, cwd, start_new_session,             # <<<<<<<<<<<<<<
+ *                                _stdin, _stdout, _stderr)
+ * 
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->_init_options(__pyx_v_self, __pyx_v_args, __pyx_v_env, __pyx_v_cwd, __pyx_v_start_new_session, __pyx_v__stdin, __pyx_v__stdout, __pyx_v__stderr); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 50, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/process.pyx":53
+ *                                _stdin, _stdout, _stderr)
+ * 
+ *             restore_inheritable = set()             # <<<<<<<<<<<<<<
+ *             if pass_fds:
+ *                 for fd in pass_fds:
+ */
+      __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 53, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_v_restore_inheritable = ((PyObject*)__pyx_t_1);
+      __pyx_t_1 = 0;
+
+      /* "uvloop/handles/process.pyx":54
+ * 
+ *             restore_inheritable = set()
+ *             if pass_fds:             # <<<<<<<<<<<<<<
+ *                 for fd in pass_fds:
+ *                     if not os_get_inheritable(fd):
+ */
+      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_pass_fds); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(4, 54, __pyx_L4_error)
+      if (__pyx_t_2) {
+
+        /* "uvloop/handles/process.pyx":55
+ *             restore_inheritable = set()
+ *             if pass_fds:
+ *                 for fd in pass_fds:             # <<<<<<<<<<<<<<
+ *                     if not os_get_inheritable(fd):
+ *                         restore_inheritable.add(fd)
+ */
+        if (likely(PyList_CheckExact(__pyx_v_pass_fds)) || PyTuple_CheckExact(__pyx_v_pass_fds)) {
+          __pyx_t_1 = __pyx_v_pass_fds; __Pyx_INCREF(__pyx_t_1); __pyx_t_6 = 0;
+          __pyx_t_7 = NULL;
+        } else {
+          __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_pass_fds); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 55, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __pyx_t_7 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 55, __pyx_L4_error)
+        }
+        for (;;) {
+          if (likely(!__pyx_t_7)) {
+            if (likely(PyList_CheckExact(__pyx_t_1))) {
+              if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_1)) break;
+              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+              __pyx_t_8 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(4, 55, __pyx_L4_error)
+              #else
+              __pyx_t_8 = PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 55, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_8);
+              #endif
+            } else {
+              if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+              __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(4, 55, __pyx_L4_error)
+              #else
+              __pyx_t_8 = PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 55, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_8);
+              #endif
+            }
+          } else {
+            __pyx_t_8 = __pyx_t_7(__pyx_t_1);
+            if (unlikely(!__pyx_t_8)) {
+              PyObject* exc_type = PyErr_Occurred();
+              if (exc_type) {
+                if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+                else __PYX_ERR(4, 55, __pyx_L4_error)
+              }
+              break;
+            }
+            __Pyx_GOTREF(__pyx_t_8);
+          }
+          __Pyx_XDECREF_SET(__pyx_v_fd, __pyx_t_8);
+          __pyx_t_8 = 0;
+
+          /* "uvloop/handles/process.pyx":56
+ *             if pass_fds:
+ *                 for fd in pass_fds:
+ *                     if not os_get_inheritable(fd):             # <<<<<<<<<<<<<<
+ *                         restore_inheritable.add(fd)
+ *                         os_set_inheritable(fd, True)
+ */
+          __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_get_inheritable);
+          __pyx_t_9 = __pyx_v_6uvloop_4loop_os_get_inheritable; __pyx_t_10 = NULL;
+          if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
+            __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9);
+            if (likely(__pyx_t_10)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+              __Pyx_INCREF(__pyx_t_10);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_9, function);
+            }
+          }
+          __pyx_t_8 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_10, __pyx_v_fd) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_fd);
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 56, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_8);
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(4, 56, __pyx_L4_error)
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __pyx_t_11 = ((!__pyx_t_2) != 0);
+          if (__pyx_t_11) {
+
+            /* "uvloop/handles/process.pyx":57
+ *                 for fd in pass_fds:
+ *                     if not os_get_inheritable(fd):
+ *                         restore_inheritable.add(fd)             # <<<<<<<<<<<<<<
+ *                         os_set_inheritable(fd, True)
+ *         except Exception:
+ */
+            __pyx_t_12 = PySet_Add(__pyx_v_restore_inheritable, __pyx_v_fd); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(4, 57, __pyx_L4_error)
+
+            /* "uvloop/handles/process.pyx":58
+ *                     if not os_get_inheritable(fd):
+ *                         restore_inheritable.add(fd)
+ *                         os_set_inheritable(fd, True)             # <<<<<<<<<<<<<<
+ *         except Exception:
+ *             self._abort_init()
+ */
+            __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+            __pyx_t_9 = __pyx_v_6uvloop_4loop_os_set_inheritable; __pyx_t_10 = NULL;
+            __pyx_t_13 = 0;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
+              __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9);
+              if (likely(__pyx_t_10)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+                __Pyx_INCREF(__pyx_t_10);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_9, function);
+                __pyx_t_13 = 1;
+              }
+            }
+            #if CYTHON_FAST_PYCALL
+            if (PyFunction_Check(__pyx_t_9)) {
+              PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_fd, Py_True};
+              __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 58, __pyx_L4_error)
+              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __Pyx_GOTREF(__pyx_t_8);
+            } else
+            #endif
+            #if CYTHON_FAST_PYCCALL
+            if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) {
+              PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_fd, Py_True};
+              __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 58, __pyx_L4_error)
+              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __Pyx_GOTREF(__pyx_t_8);
+            } else
+            #endif
+            {
+              __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 58, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_14);
+              if (__pyx_t_10) {
+                __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_10); __pyx_t_10 = NULL;
+              }
+              __Pyx_INCREF(__pyx_v_fd);
+              __Pyx_GIVEREF(__pyx_v_fd);
+              PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_v_fd);
+              __Pyx_INCREF(Py_True);
+              __Pyx_GIVEREF(Py_True);
+              PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, Py_True);
+              __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_14, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 58, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_8);
+              __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+            }
+            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+            /* "uvloop/handles/process.pyx":56
+ *             if pass_fds:
+ *                 for fd in pass_fds:
+ *                     if not os_get_inheritable(fd):             # <<<<<<<<<<<<<<
+ *                         restore_inheritable.add(fd)
+ *                         os_set_inheritable(fd, True)
+ */
+          }
+
+          /* "uvloop/handles/process.pyx":55
+ *             restore_inheritable = set()
+ *             if pass_fds:
+ *                 for fd in pass_fds:             # <<<<<<<<<<<<<<
+ *                     if not os_get_inheritable(fd):
+ *                         restore_inheritable.add(fd)
+ */
+        }
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+        /* "uvloop/handles/process.pyx":54
+ * 
+ *             restore_inheritable = set()
+ *             if pass_fds:             # <<<<<<<<<<<<<<
+ *                 for fd in pass_fds:
+ *                     if not os_get_inheritable(fd):
+ */
+      }
+
+      /* "uvloop/handles/process.pyx":49
+ *         self._handle.data = NULL
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._init_options(args, env, cwd, start_new_session,
+ *                                _stdin, _stdout, _stderr)
+ */
+    }
+    __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_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/handles/process.pyx":59
+ *                         restore_inheritable.add(fd)
+ *                         os_set_inheritable(fd, True)
+ *         except Exception:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise
+ */
+    __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_13) {
+      __Pyx_AddTraceback("uvloop.loop.UVProcess._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(4, 59, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_GOTREF(__pyx_t_9);
+
+      /* "uvloop/handles/process.pyx":60
+ *                         os_set_inheritable(fd, True)
+ *         except Exception:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise
+ * 
+ */
+      __pyx_t_14 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 60, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_14);
+      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+
+      /* "uvloop/handles/process.pyx":61
+ *         except Exception:
+ *             self._abort_init()
+ *             raise             # <<<<<<<<<<<<<<
+ * 
+ *         if __forking or loop.active_process_handler is not None:
+ */
+      __Pyx_GIVEREF(__pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_8, __pyx_t_9);
+      __pyx_t_1 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; 
+      __PYX_ERR(4, 61, __pyx_L6_except_error)
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/handles/process.pyx":49
+ *         self._handle.data = NULL
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._init_options(args, env, cwd, start_new_session,
+ *                                _stdin, _stdout, _stderr)
+ */
+    __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:;
+  }
+
+  /* "uvloop/handles/process.pyx":63
+ *             raise
+ * 
+ *         if __forking or loop.active_process_handler is not None:             # <<<<<<<<<<<<<<
+ *             # Our pthread_atfork handlers won't work correctly when
+ *             # another loop is forking in another thread (even though
+ */
+  __pyx_t_2 = (__pyx_v_6uvloop_4loop___forking != 0);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_11 = __pyx_t_2;
+    goto __pyx_L17_bool_binop_done;
+  }
+  __pyx_t_2 = (((PyObject *)__pyx_v_loop->active_process_handler) != Py_None);
+  __pyx_t_15 = (__pyx_t_2 != 0);
+  __pyx_t_11 = __pyx_t_15;
+  __pyx_L17_bool_binop_done:;
+  if (unlikely(__pyx_t_11)) {
+
+    /* "uvloop/handles/process.pyx":67
+ *             # another loop is forking in another thread (even though
+ *             # GIL should help us to avoid that.)
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'Racing with another loop to spawn a process.')
+ */
+    __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 67, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/handles/process.pyx":68
+ *             # GIL should help us to avoid that.)
+ *             self._abort_init()
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'Racing with another loop to spawn a process.')
+ * 
+ */
+    __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__177, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 68, __pyx_L1_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(4, 68, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":63
+ *             raise
+ * 
+ *         if __forking or loop.active_process_handler is not None:             # <<<<<<<<<<<<<<
+ *             # Our pthread_atfork handlers won't work correctly when
+ *             # another loop is forking in another thread (even though
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":71
+ *                 'Racing with another loop to spawn a process.')
+ * 
+ *         self._errpipe_read, self._errpipe_write = os_pipe()             # <<<<<<<<<<<<<<
+ *         try:
+ *             os_set_inheritable(self._errpipe_write, True)
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_pipe);
+  __pyx_t_8 = __pyx_v_6uvloop_4loop_os_pipe; __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_8);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_8, function);
+    }
+  }
+  __pyx_t_9 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_9))) || (PyList_CheckExact(__pyx_t_9))) {
+    PyObject* sequence = __pyx_t_9;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(4, 71, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_8 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_1 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_8);
+    __Pyx_INCREF(__pyx_t_1);
+    #else
+    __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 71, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 71, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    #endif
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_14 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 71, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_14);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_16 = Py_TYPE(__pyx_t_14)->tp_iternext;
+    index = 0; __pyx_t_8 = __pyx_t_16(__pyx_t_14); if (unlikely(!__pyx_t_8)) goto __pyx_L19_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_8);
+    index = 1; __pyx_t_1 = __pyx_t_16(__pyx_t_14); if (unlikely(!__pyx_t_1)) goto __pyx_L19_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_1);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_14), 2) < 0) __PYX_ERR(4, 71, __pyx_L1_error)
+    __pyx_t_16 = NULL;
+    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+    goto __pyx_L20_unpacking_done;
+    __pyx_L19_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+    __pyx_t_16 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(4, 71, __pyx_L1_error)
+    __pyx_L20_unpacking_done:;
+  }
+  __Pyx_GIVEREF(__pyx_t_8);
+  __Pyx_GOTREF(__pyx_v_self->_errpipe_read);
+  __Pyx_DECREF(__pyx_v_self->_errpipe_read);
+  __pyx_v_self->_errpipe_read = __pyx_t_8;
+  __pyx_t_8 = 0;
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_errpipe_write);
+  __Pyx_DECREF(__pyx_v_self->_errpipe_write);
+  __pyx_v_self->_errpipe_write = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":72
+ * 
+ *         self._errpipe_read, self._errpipe_write = os_pipe()
+ *         try:             # <<<<<<<<<<<<<<
+ *             os_set_inheritable(self._errpipe_write, True)
+ * 
+ */
+  /*try:*/ {
+
+    /* "uvloop/handles/process.pyx":73
+ *         self._errpipe_read, self._errpipe_write = os_pipe()
+ *         try:
+ *             os_set_inheritable(self._errpipe_write, True)             # <<<<<<<<<<<<<<
+ * 
+ *             self._preexec_fn = preexec_fn
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+    __pyx_t_1 = __pyx_v_6uvloop_4loop_os_set_inheritable; __pyx_t_8 = NULL;
+    __pyx_t_13 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+        __pyx_t_13 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_self->_errpipe_write, Py_True};
+      __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 73, __pyx_L22_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_GOTREF(__pyx_t_9);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_self->_errpipe_write, Py_True};
+      __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 73, __pyx_L22_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_GOTREF(__pyx_t_9);
+    } else
+    #endif
+    {
+      __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 73, __pyx_L22_error)
+      __Pyx_GOTREF(__pyx_t_14);
+      if (__pyx_t_8) {
+        __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_8); __pyx_t_8 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_self->_errpipe_write);
+      __Pyx_GIVEREF(__pyx_v_self->_errpipe_write);
+      PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_v_self->_errpipe_write);
+      __Pyx_INCREF(Py_True);
+      __Pyx_GIVEREF(Py_True);
+      PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, Py_True);
+      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_14, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 73, __pyx_L22_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/handles/process.pyx":75
+ *             os_set_inheritable(self._errpipe_write, True)
+ * 
+ *             self._preexec_fn = preexec_fn             # <<<<<<<<<<<<<<
+ *             self._restore_signals = restore_signals
+ * 
+ */
+    __Pyx_INCREF(__pyx_v_preexec_fn);
+    __Pyx_GIVEREF(__pyx_v_preexec_fn);
+    __Pyx_GOTREF(__pyx_v_self->_preexec_fn);
+    __Pyx_DECREF(__pyx_v_self->_preexec_fn);
+    __pyx_v_self->_preexec_fn = __pyx_v_preexec_fn;
+
+    /* "uvloop/handles/process.pyx":76
+ * 
+ *             self._preexec_fn = preexec_fn
+ *             self._restore_signals = restore_signals             # <<<<<<<<<<<<<<
+ * 
+ *             loop.active_process_handler = self
+ */
+    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_restore_signals); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 76, __pyx_L22_error)
+    __pyx_v_self->_restore_signals = __pyx_t_11;
+
+    /* "uvloop/handles/process.pyx":78
+ *             self._restore_signals = restore_signals
+ * 
+ *             loop.active_process_handler = self             # <<<<<<<<<<<<<<
+ *             __forking = 1
+ *             __forking_loop = loop
+ */
+    __Pyx_INCREF(((PyObject *)__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+    __Pyx_GOTREF(__pyx_v_loop->active_process_handler);
+    __Pyx_DECREF(((PyObject *)__pyx_v_loop->active_process_handler));
+    __pyx_v_loop->active_process_handler = __pyx_v_self;
+
+    /* "uvloop/handles/process.pyx":79
+ * 
+ *             loop.active_process_handler = self
+ *             __forking = 1             # <<<<<<<<<<<<<<
+ *             __forking_loop = loop
+ *             system.setForkHandler(<system.OnForkHandler>&__get_fork_handler)
+ */
+    __pyx_v_6uvloop_4loop___forking = 1;
+
+    /* "uvloop/handles/process.pyx":80
+ *             loop.active_process_handler = self
+ *             __forking = 1
+ *             __forking_loop = loop             # <<<<<<<<<<<<<<
+ *             system.setForkHandler(<system.OnForkHandler>&__get_fork_handler)
+ * 
+ */
+    __Pyx_INCREF(((PyObject *)__pyx_v_loop));
+    __Pyx_XGOTREF(((PyObject *)__pyx_v_6uvloop_4loop___forking_loop));
+    __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop___forking_loop, __pyx_v_loop);
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_loop));
+
+    /* "uvloop/handles/process.pyx":81
+ *             __forking = 1
+ *             __forking_loop = loop
+ *             system.setForkHandler(<system.OnForkHandler>&__get_fork_handler)             # <<<<<<<<<<<<<<
+ * 
+ *             PyOS_BeforeFork()
+ */
+    setForkHandler(((OnForkHandler)(&__pyx_f_6uvloop_4loop___get_fork_handler)));
+
+    /* "uvloop/handles/process.pyx":83
+ *             system.setForkHandler(<system.OnForkHandler>&__get_fork_handler)
+ * 
+ *             PyOS_BeforeFork()             # <<<<<<<<<<<<<<
+ * 
+ *             err = uv.uv_spawn(loop.uvloop,
+ */
+    PyOS_BeforeFork();
+
+    /* "uvloop/handles/process.pyx":85
+ *             PyOS_BeforeFork()
+ * 
+ *             err = uv.uv_spawn(loop.uvloop,             # <<<<<<<<<<<<<<
+ *                               <uv.uv_process_t*>self._handle,
+ *                               &self.options)
+ */
+    __pyx_v_err = uv_spawn(__pyx_v_loop->uvloop, ((uv_process_t *)__pyx_v_self->__pyx_base._handle), (&__pyx_v_self->options));
+
+    /* "uvloop/handles/process.pyx":89
+ *                               &self.options)
+ * 
+ *             __forking = 0             # <<<<<<<<<<<<<<
+ *             __forking_loop = None
+ *             system.resetForkHandler()
+ */
+    __pyx_v_6uvloop_4loop___forking = 0;
+
+    /* "uvloop/handles/process.pyx":90
+ * 
+ *             __forking = 0
+ *             __forking_loop = None             # <<<<<<<<<<<<<<
+ *             system.resetForkHandler()
+ *             loop.active_process_handler = None
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_XGOTREF(((PyObject *)__pyx_v_6uvloop_4loop___forking_loop));
+    __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop___forking_loop, ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None));
+    __Pyx_GIVEREF(Py_None);
+
+    /* "uvloop/handles/process.pyx":91
+ *             __forking = 0
+ *             __forking_loop = None
+ *             system.resetForkHandler()             # <<<<<<<<<<<<<<
+ *             loop.active_process_handler = None
+ * 
+ */
+    resetForkHandler();
+
+    /* "uvloop/handles/process.pyx":92
+ *             __forking_loop = None
+ *             system.resetForkHandler()
+ *             loop.active_process_handler = None             # <<<<<<<<<<<<<<
+ * 
+ *             PyOS_AfterFork_Parent()
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_loop->active_process_handler);
+    __Pyx_DECREF(((PyObject *)__pyx_v_loop->active_process_handler));
+    __pyx_v_loop->active_process_handler = ((struct __pyx_obj_6uvloop_4loop_UVProcess *)Py_None);
+
+    /* "uvloop/handles/process.pyx":94
+ *             loop.active_process_handler = None
+ * 
+ *             PyOS_AfterFork_Parent()             # <<<<<<<<<<<<<<
+ * 
+ *             if err < 0:
+ */
+    PyOS_AfterFork_Parent();
+
+    /* "uvloop/handles/process.pyx":96
+ *             PyOS_AfterFork_Parent()
+ * 
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 self._close_process_handle()
+ *                 self._abort_init()
+ */
+    __pyx_t_11 = ((__pyx_v_err < 0) != 0);
+    if (unlikely(__pyx_t_11)) {
+
+      /* "uvloop/handles/process.pyx":97
+ * 
+ *             if err < 0:
+ *                 self._close_process_handle()             # <<<<<<<<<<<<<<
+ *                 self._abort_init()
+ *                 raise convert_error(err)
+ */
+      __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->_close_process_handle(__pyx_v_self); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 97, __pyx_L22_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/handles/process.pyx":98
+ *             if err < 0:
+ *                 self._close_process_handle()
+ *                 self._abort_init()             # <<<<<<<<<<<<<<
+ *                 raise convert_error(err)
+ * 
+ */
+      __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 98, __pyx_L22_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/handles/process.pyx":99
+ *                 self._close_process_handle()
+ *                 self._abort_init()
+ *                 raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *             self._finish_init()
+ */
+      __pyx_t_9 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 99, __pyx_L22_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(4, 99, __pyx_L22_error)
+
+      /* "uvloop/handles/process.pyx":96
+ *             PyOS_AfterFork_Parent()
+ * 
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 self._close_process_handle()
+ *                 self._abort_init()
+ */
+    }
+
+    /* "uvloop/handles/process.pyx":101
+ *                 raise convert_error(err)
+ * 
+ *             self._finish_init()             # <<<<<<<<<<<<<<
+ * 
+ *             os_close(self._errpipe_write)
+ */
+    __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._finish_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 101, __pyx_L22_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/handles/process.pyx":103
+ *             self._finish_init()
+ * 
+ *             os_close(self._errpipe_write)             # <<<<<<<<<<<<<<
+ * 
+ *             if preexec_fn is not None:
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_close);
+    __pyx_t_1 = __pyx_v_6uvloop_4loop_os_close; __pyx_t_14 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_14)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_14);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+      }
+    }
+    __pyx_t_9 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_14, __pyx_v_self->_errpipe_write) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_self->_errpipe_write);
+    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+    if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 103, __pyx_L22_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/handles/process.pyx":105
+ *             os_close(self._errpipe_write)
+ * 
+ *             if preexec_fn is not None:             # <<<<<<<<<<<<<<
+ *                 errpipe_data = bytearray()
+ *                 while True:
+ */
+    __pyx_t_11 = (__pyx_v_preexec_fn != Py_None);
+    __pyx_t_15 = (__pyx_t_11 != 0);
+    if (__pyx_t_15) {
+
+      /* "uvloop/handles/process.pyx":106
+ * 
+ *             if preexec_fn is not None:
+ *                 errpipe_data = bytearray()             # <<<<<<<<<<<<<<
+ *                 while True:
+ *                     # XXX: This is a blocking code that has to be
+ */
+      __pyx_t_9 = __Pyx_PyObject_CallNoArg(((PyObject *)(&PyByteArray_Type))); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 106, __pyx_L22_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_v_errpipe_data = __pyx_t_9;
+      __pyx_t_9 = 0;
+
+      /* "uvloop/handles/process.pyx":107
+ *             if preexec_fn is not None:
+ *                 errpipe_data = bytearray()
+ *                 while True:             # <<<<<<<<<<<<<<
+ *                     # XXX: This is a blocking code that has to be
+ *                     # rewritten (using loop.connect_read_pipe() or
+ */
+      while (1) {
+
+        /* "uvloop/handles/process.pyx":111
+ *                     # rewritten (using loop.connect_read_pipe() or
+ *                     # otherwise.)
+ *                     part = os_read(self._errpipe_read, 50000)             # <<<<<<<<<<<<<<
+ *                     errpipe_data += part
+ *                     if not part or len(errpipe_data) > 50000:
+ */
+        __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_read);
+        __pyx_t_1 = __pyx_v_6uvloop_4loop_os_read; __pyx_t_14 = NULL;
+        __pyx_t_13 = 0;
+        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+          __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_1);
+          if (likely(__pyx_t_14)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+            __Pyx_INCREF(__pyx_t_14);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_1, function);
+            __pyx_t_13 = 1;
+          }
+        }
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_1)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_14, __pyx_v_self->_errpipe_read, __pyx_int_50000};
+          __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 111, __pyx_L22_error)
+          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+          __Pyx_GOTREF(__pyx_t_9);
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_14, __pyx_v_self->_errpipe_read, __pyx_int_50000};
+          __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 111, __pyx_L22_error)
+          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+          __Pyx_GOTREF(__pyx_t_9);
+        } else
+        #endif
+        {
+          __pyx_t_8 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 111, __pyx_L22_error)
+          __Pyx_GOTREF(__pyx_t_8);
+          if (__pyx_t_14) {
+            __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_14); __pyx_t_14 = NULL;
+          }
+          __Pyx_INCREF(__pyx_v_self->_errpipe_read);
+          __Pyx_GIVEREF(__pyx_v_self->_errpipe_read);
+          PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_13, __pyx_v_self->_errpipe_read);
+          __Pyx_INCREF(__pyx_int_50000);
+          __Pyx_GIVEREF(__pyx_int_50000);
+          PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_13, __pyx_int_50000);
+          __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 111, __pyx_L22_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_XDECREF_SET(__pyx_v_part, __pyx_t_9);
+        __pyx_t_9 = 0;
+
+        /* "uvloop/handles/process.pyx":112
+ *                     # otherwise.)
+ *                     part = os_read(self._errpipe_read, 50000)
+ *                     errpipe_data += part             # <<<<<<<<<<<<<<
+ *                     if not part or len(errpipe_data) > 50000:
+ *                         break
+ */
+        __pyx_t_9 = PyNumber_InPlaceAdd(__pyx_v_errpipe_data, __pyx_v_part); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 112, __pyx_L22_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF_SET(__pyx_v_errpipe_data, __pyx_t_9);
+        __pyx_t_9 = 0;
+
+        /* "uvloop/handles/process.pyx":113
+ *                     part = os_read(self._errpipe_read, 50000)
+ *                     errpipe_data += part
+ *                     if not part or len(errpipe_data) > 50000:             # <<<<<<<<<<<<<<
+ *                         break
+ * 
+ */
+        __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_part); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(4, 113, __pyx_L22_error)
+        __pyx_t_2 = ((!__pyx_t_11) != 0);
+        if (!__pyx_t_2) {
+        } else {
+          __pyx_t_15 = __pyx_t_2;
+          goto __pyx_L29_bool_binop_done;
+        }
+        __pyx_t_6 = PyObject_Length(__pyx_v_errpipe_data); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(4, 113, __pyx_L22_error)
+        __pyx_t_2 = ((__pyx_t_6 > 0xC350) != 0);
+        __pyx_t_15 = __pyx_t_2;
+        __pyx_L29_bool_binop_done:;
+        if (__pyx_t_15) {
+
+          /* "uvloop/handles/process.pyx":114
+ *                     errpipe_data += part
+ *                     if not part or len(errpipe_data) > 50000:
+ *                         break             # <<<<<<<<<<<<<<
+ * 
+ *         finally:
+ */
+          goto __pyx_L27_break;
+
+          /* "uvloop/handles/process.pyx":113
+ *                     part = os_read(self._errpipe_read, 50000)
+ *                     errpipe_data += part
+ *                     if not part or len(errpipe_data) > 50000:             # <<<<<<<<<<<<<<
+ *                         break
+ * 
+ */
+        }
+      }
+      __pyx_L27_break:;
+
+      /* "uvloop/handles/process.pyx":105
+ *             os_close(self._errpipe_write)
+ * 
+ *             if preexec_fn is not None:             # <<<<<<<<<<<<<<
+ *                 errpipe_data = bytearray()
+ *                 while True:
+ */
+    }
+  }
+
+  /* "uvloop/handles/process.pyx":117
+ * 
+ *         finally:
+ *             os_close(self._errpipe_read)             # <<<<<<<<<<<<<<
+ *             try:
+ *                 os_close(self._errpipe_write)
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_close);
+      __pyx_t_1 = __pyx_v_6uvloop_4loop_os_close; __pyx_t_8 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1);
+        if (likely(__pyx_t_8)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+          __Pyx_INCREF(__pyx_t_8);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_1, function);
+        }
+      }
+      __pyx_t_9 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_8, __pyx_v_self->_errpipe_read) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_self->_errpipe_read);
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 117, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/handles/process.pyx":118
+ *         finally:
+ *             os_close(self._errpipe_read)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 os_close(self._errpipe_write)
+ *             except OSError:
+ */
+      {
+        __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:*/ {
+
+          /* "uvloop/handles/process.pyx":119
+ *             os_close(self._errpipe_read)
+ *             try:
+ *                 os_close(self._errpipe_write)             # <<<<<<<<<<<<<<
+ *             except OSError:
+ *                 # Might be already closed
+ */
+          __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_close);
+          __pyx_t_1 = __pyx_v_6uvloop_4loop_os_close; __pyx_t_8 = NULL;
+          if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+            __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1);
+            if (likely(__pyx_t_8)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+              __Pyx_INCREF(__pyx_t_8);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_1, function);
+            }
+          }
+          __pyx_t_9 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_8, __pyx_v_self->_errpipe_write) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_self->_errpipe_write);
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 119, __pyx_L31_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+          /* "uvloop/handles/process.pyx":118
+ *         finally:
+ *             os_close(self._errpipe_read)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 os_close(self._errpipe_write)
+ *             except OSError:
+ */
+        }
+        __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_L36_try_end;
+        __pyx_L31_error:;
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        /* "uvloop/handles/process.pyx":120
+ *             try:
+ *                 os_close(self._errpipe_write)
+ *             except OSError:             # <<<<<<<<<<<<<<
+ *                 # Might be already closed
+ *                 pass
+ */
+        __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
+        if (__pyx_t_13) {
+          __Pyx_ErrRestore(0,0,0);
+          goto __pyx_L32_exception_handled;
+        }
+        goto __pyx_L33_except_error;
+        __pyx_L33_except_error:;
+
+        /* "uvloop/handles/process.pyx":118
+ *         finally:
+ *             os_close(self._errpipe_read)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 os_close(self._errpipe_write)
+ *             except OSError:
+ */
+        __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_L32_exception_handled:;
+        __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);
+        __pyx_L36_try_end:;
+      }
+
+      /* "uvloop/handles/process.pyx":124
+ *                 pass
+ * 
+ *             fds_to_close = self._fds_to_close             # <<<<<<<<<<<<<<
+ *             self._fds_to_close = None
+ *             for fd in fds_to_close:
+ */
+      __pyx_t_9 = __pyx_v_self->_fds_to_close;
+      __Pyx_INCREF(__pyx_t_9);
+      __pyx_v_fds_to_close = ((PyObject*)__pyx_t_9);
+      __pyx_t_9 = 0;
+
+      /* "uvloop/handles/process.pyx":125
+ * 
+ *             fds_to_close = self._fds_to_close
+ *             self._fds_to_close = None             # <<<<<<<<<<<<<<
+ *             for fd in fds_to_close:
+ *                 os_close(fd)
+ */
+      __Pyx_INCREF(Py_None);
+      __Pyx_GIVEREF(Py_None);
+      __Pyx_GOTREF(__pyx_v_self->_fds_to_close);
+      __Pyx_DECREF(__pyx_v_self->_fds_to_close);
+      __pyx_v_self->_fds_to_close = ((PyObject*)Py_None);
+
+      /* "uvloop/handles/process.pyx":126
+ *             fds_to_close = self._fds_to_close
+ *             self._fds_to_close = None
+ *             for fd in fds_to_close:             # <<<<<<<<<<<<<<
+ *                 os_close(fd)
+ * 
+ */
+      __pyx_t_6 = 0;
+      __pyx_t_1 = __Pyx_set_iterator(__pyx_v_fds_to_close, 1, (&__pyx_t_17), (&__pyx_t_13)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 126, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_XDECREF(__pyx_t_9);
+      __pyx_t_9 = __pyx_t_1;
+      __pyx_t_1 = 0;
+      while (1) {
+        __pyx_t_18 = __Pyx_set_iter_next(__pyx_t_9, __pyx_t_17, &__pyx_t_6, &__pyx_t_1, __pyx_t_13);
+        if (unlikely(__pyx_t_18 == 0)) break;
+        if (unlikely(__pyx_t_18 == -1)) __PYX_ERR(4, 126, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_XDECREF_SET(__pyx_v_fd, __pyx_t_1);
+        __pyx_t_1 = 0;
+
+        /* "uvloop/handles/process.pyx":127
+ *             self._fds_to_close = None
+ *             for fd in fds_to_close:
+ *                 os_close(fd)             # <<<<<<<<<<<<<<
+ * 
+ *             for fd in restore_inheritable:
+ */
+        __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_close);
+        __pyx_t_8 = __pyx_v_6uvloop_4loop_os_close; __pyx_t_14 = NULL;
+        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+          __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_8);
+          if (likely(__pyx_t_14)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+            __Pyx_INCREF(__pyx_t_14);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_8, function);
+          }
+        }
+        __pyx_t_1 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_14, __pyx_v_fd) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_fd);
+        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 127, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/handles/process.pyx":129
+ *                 os_close(fd)
+ * 
+ *             for fd in restore_inheritable:             # <<<<<<<<<<<<<<
+ *                 os_set_inheritable(fd, False)
+ * 
+ */
+      __pyx_t_17 = 0;
+      __pyx_t_1 = __Pyx_set_iterator(__pyx_v_restore_inheritable, 1, (&__pyx_t_6), (&__pyx_t_13)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 129, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_XDECREF(__pyx_t_9);
+      __pyx_t_9 = __pyx_t_1;
+      __pyx_t_1 = 0;
+      while (1) {
+        __pyx_t_18 = __Pyx_set_iter_next(__pyx_t_9, __pyx_t_6, &__pyx_t_17, &__pyx_t_1, __pyx_t_13);
+        if (unlikely(__pyx_t_18 == 0)) break;
+        if (unlikely(__pyx_t_18 == -1)) __PYX_ERR(4, 129, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_XDECREF_SET(__pyx_v_fd, __pyx_t_1);
+        __pyx_t_1 = 0;
+
+        /* "uvloop/handles/process.pyx":130
+ * 
+ *             for fd in restore_inheritable:
+ *                 os_set_inheritable(fd, False)             # <<<<<<<<<<<<<<
+ * 
+ *         # asyncio caches the PID in BaseSubprocessTransport,
+ */
+        __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+        __pyx_t_8 = __pyx_v_6uvloop_4loop_os_set_inheritable; __pyx_t_14 = NULL;
+        __pyx_t_18 = 0;
+        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+          __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_8);
+          if (likely(__pyx_t_14)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+            __Pyx_INCREF(__pyx_t_14);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_8, function);
+            __pyx_t_18 = 1;
+          }
+        }
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_8)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_14, __pyx_v_fd, Py_False};
+          __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_18, 2+__pyx_t_18); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 130, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+          __Pyx_GOTREF(__pyx_t_1);
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_14, __pyx_v_fd, Py_False};
+          __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_18, 2+__pyx_t_18); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 130, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+          __Pyx_GOTREF(__pyx_t_1);
+        } else
+        #endif
+        {
+          __pyx_t_10 = PyTuple_New(2+__pyx_t_18); if (unlikely(!__pyx_t_10)) __PYX_ERR(4, 130, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          if (__pyx_t_14) {
+            __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_14); __pyx_t_14 = NULL;
+          }
+          __Pyx_INCREF(__pyx_v_fd);
+          __Pyx_GIVEREF(__pyx_v_fd);
+          PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_18, __pyx_v_fd);
+          __Pyx_INCREF(Py_False);
+          __Pyx_GIVEREF(Py_False);
+          PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_18, Py_False);
+          __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 130, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      goto __pyx_L23;
+    }
+    __pyx_L22_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5) < 0)) __Pyx_ErrFetch(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_20);
+      __Pyx_XGOTREF(__pyx_t_21);
+      __Pyx_XGOTREF(__pyx_t_22);
+      __pyx_t_13 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename;
+      {
+
+        /* "uvloop/handles/process.pyx":117
+ * 
+ *         finally:
+ *             os_close(self._errpipe_read)             # <<<<<<<<<<<<<<
+ *             try:
+ *                 os_close(self._errpipe_write)
+ */
+        __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_close);
+        __pyx_t_1 = __pyx_v_6uvloop_4loop_os_close; __pyx_t_8 = NULL;
+        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1);
+          if (likely(__pyx_t_8)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+            __Pyx_INCREF(__pyx_t_8);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_1, function);
+          }
+        }
+        __pyx_t_9 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_8, __pyx_v_self->_errpipe_read) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_self->_errpipe_read);
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 117, __pyx_L42_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        /* "uvloop/handles/process.pyx":118
+ *         finally:
+ *             os_close(self._errpipe_read)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 os_close(self._errpipe_write)
+ *             except OSError:
+ */
+        {
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __Pyx_ExceptionSave(&__pyx_t_23, &__pyx_t_24, &__pyx_t_25);
+          __Pyx_XGOTREF(__pyx_t_23);
+          __Pyx_XGOTREF(__pyx_t_24);
+          __Pyx_XGOTREF(__pyx_t_25);
+          /*try:*/ {
+
+            /* "uvloop/handles/process.pyx":119
+ *             os_close(self._errpipe_read)
+ *             try:
+ *                 os_close(self._errpipe_write)             # <<<<<<<<<<<<<<
+ *             except OSError:
+ *                 # Might be already closed
+ */
+            __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_close);
+            __pyx_t_1 = __pyx_v_6uvloop_4loop_os_close; __pyx_t_8 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+              __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1);
+              if (likely(__pyx_t_8)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+                __Pyx_INCREF(__pyx_t_8);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_1, function);
+              }
+            }
+            __pyx_t_9 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_8, __pyx_v_self->_errpipe_write) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_self->_errpipe_write);
+            __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+            if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 119, __pyx_L43_error)
+            __Pyx_GOTREF(__pyx_t_9);
+            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+            /* "uvloop/handles/process.pyx":118
+ *         finally:
+ *             os_close(self._errpipe_read)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 os_close(self._errpipe_write)
+ *             except OSError:
+ */
+          }
+          __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
+          __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
+          __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
+          goto __pyx_L48_try_end;
+          __pyx_L43_error:;
+          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+          /* "uvloop/handles/process.pyx":120
+ *             try:
+ *                 os_close(self._errpipe_write)
+ *             except OSError:             # <<<<<<<<<<<<<<
+ *                 # Might be already closed
+ *                 pass
+ */
+          __pyx_t_26 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
+          if (__pyx_t_26) {
+            __Pyx_ErrRestore(0,0,0);
+            goto __pyx_L44_exception_handled;
+          }
+          goto __pyx_L45_except_error;
+          __pyx_L45_except_error:;
+
+          /* "uvloop/handles/process.pyx":118
+ *         finally:
+ *             os_close(self._errpipe_read)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 os_close(self._errpipe_write)
+ *             except OSError:
+ */
+          __Pyx_XGIVEREF(__pyx_t_23);
+          __Pyx_XGIVEREF(__pyx_t_24);
+          __Pyx_XGIVEREF(__pyx_t_25);
+          __Pyx_ExceptionReset(__pyx_t_23, __pyx_t_24, __pyx_t_25);
+          goto __pyx_L42_error;
+          __pyx_L44_exception_handled:;
+          __Pyx_XGIVEREF(__pyx_t_23);
+          __Pyx_XGIVEREF(__pyx_t_24);
+          __Pyx_XGIVEREF(__pyx_t_25);
+          __Pyx_ExceptionReset(__pyx_t_23, __pyx_t_24, __pyx_t_25);
+          __pyx_L48_try_end:;
+        }
+
+        /* "uvloop/handles/process.pyx":124
+ *                 pass
+ * 
+ *             fds_to_close = self._fds_to_close             # <<<<<<<<<<<<<<
+ *             self._fds_to_close = None
+ *             for fd in fds_to_close:
+ */
+        __pyx_t_9 = __pyx_v_self->_fds_to_close;
+        __Pyx_INCREF(__pyx_t_9);
+        __pyx_v_fds_to_close = ((PyObject*)__pyx_t_9);
+        __pyx_t_9 = 0;
+
+        /* "uvloop/handles/process.pyx":125
+ * 
+ *             fds_to_close = self._fds_to_close
+ *             self._fds_to_close = None             # <<<<<<<<<<<<<<
+ *             for fd in fds_to_close:
+ *                 os_close(fd)
+ */
+        __Pyx_INCREF(Py_None);
+        __Pyx_GIVEREF(Py_None);
+        __Pyx_GOTREF(__pyx_v_self->_fds_to_close);
+        __Pyx_DECREF(__pyx_v_self->_fds_to_close);
+        __pyx_v_self->_fds_to_close = ((PyObject*)Py_None);
+
+        /* "uvloop/handles/process.pyx":126
+ *             fds_to_close = self._fds_to_close
+ *             self._fds_to_close = None
+ *             for fd in fds_to_close:             # <<<<<<<<<<<<<<
+ *                 os_close(fd)
+ * 
+ */
+        __pyx_t_6 = 0;
+        __pyx_t_1 = __Pyx_set_iterator(__pyx_v_fds_to_close, 1, (&__pyx_t_17), (&__pyx_t_26)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 126, __pyx_L42_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_XDECREF(__pyx_t_9);
+        __pyx_t_9 = __pyx_t_1;
+        __pyx_t_1 = 0;
+        while (1) {
+          __pyx_t_27 = __Pyx_set_iter_next(__pyx_t_9, __pyx_t_17, &__pyx_t_6, &__pyx_t_1, __pyx_t_26);
+          if (unlikely(__pyx_t_27 == 0)) break;
+          if (unlikely(__pyx_t_27 == -1)) __PYX_ERR(4, 126, __pyx_L42_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_XDECREF_SET(__pyx_v_fd, __pyx_t_1);
+          __pyx_t_1 = 0;
+
+          /* "uvloop/handles/process.pyx":127
+ *             self._fds_to_close = None
+ *             for fd in fds_to_close:
+ *                 os_close(fd)             # <<<<<<<<<<<<<<
+ * 
+ *             for fd in restore_inheritable:
+ */
+          __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_close);
+          __pyx_t_8 = __pyx_v_6uvloop_4loop_os_close; __pyx_t_10 = NULL;
+          if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+            __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8);
+            if (likely(__pyx_t_10)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+              __Pyx_INCREF(__pyx_t_10);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_8, function);
+            }
+          }
+          __pyx_t_1 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_10, __pyx_v_fd) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_fd);
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 127, __pyx_L42_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        /* "uvloop/handles/process.pyx":129
+ *                 os_close(fd)
+ * 
+ *             for fd in restore_inheritable:             # <<<<<<<<<<<<<<
+ *                 os_set_inheritable(fd, False)
+ * 
+ */
+        __pyx_t_17 = 0;
+        __pyx_t_1 = __Pyx_set_iterator(__pyx_v_restore_inheritable, 1, (&__pyx_t_6), (&__pyx_t_26)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 129, __pyx_L42_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_XDECREF(__pyx_t_9);
+        __pyx_t_9 = __pyx_t_1;
+        __pyx_t_1 = 0;
+        while (1) {
+          __pyx_t_27 = __Pyx_set_iter_next(__pyx_t_9, __pyx_t_6, &__pyx_t_17, &__pyx_t_1, __pyx_t_26);
+          if (unlikely(__pyx_t_27 == 0)) break;
+          if (unlikely(__pyx_t_27 == -1)) __PYX_ERR(4, 129, __pyx_L42_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_XDECREF_SET(__pyx_v_fd, __pyx_t_1);
+          __pyx_t_1 = 0;
+
+          /* "uvloop/handles/process.pyx":130
+ * 
+ *             for fd in restore_inheritable:
+ *                 os_set_inheritable(fd, False)             # <<<<<<<<<<<<<<
+ * 
+ *         # asyncio caches the PID in BaseSubprocessTransport,
+ */
+          __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+          __pyx_t_8 = __pyx_v_6uvloop_4loop_os_set_inheritable; __pyx_t_10 = NULL;
+          __pyx_t_27 = 0;
+          if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+            __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8);
+            if (likely(__pyx_t_10)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+              __Pyx_INCREF(__pyx_t_10);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_8, function);
+              __pyx_t_27 = 1;
+            }
+          }
+          #if CYTHON_FAST_PYCALL
+          if (PyFunction_Check(__pyx_t_8)) {
+            PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_fd, Py_False};
+            __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_27, 2+__pyx_t_27); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 130, __pyx_L42_error)
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_GOTREF(__pyx_t_1);
+          } else
+          #endif
+          #if CYTHON_FAST_PYCCALL
+          if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
+            PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_fd, Py_False};
+            __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_27, 2+__pyx_t_27); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 130, __pyx_L42_error)
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_GOTREF(__pyx_t_1);
+          } else
+          #endif
+          {
+            __pyx_t_14 = PyTuple_New(2+__pyx_t_27); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 130, __pyx_L42_error)
+            __Pyx_GOTREF(__pyx_t_14);
+            if (__pyx_t_10) {
+              __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_10); __pyx_t_10 = NULL;
+            }
+            __Pyx_INCREF(__pyx_v_fd);
+            __Pyx_GIVEREF(__pyx_v_fd);
+            PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_27, __pyx_v_fd);
+            __Pyx_INCREF(Py_False);
+            __Pyx_GIVEREF(Py_False);
+            PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_27, Py_False);
+            __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 130, __pyx_L42_error)
+            __Pyx_GOTREF(__pyx_t_1);
+            __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+          }
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_20);
+        __Pyx_XGIVEREF(__pyx_t_21);
+        __Pyx_XGIVEREF(__pyx_t_22);
+        __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
+      }
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_ErrRestore(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+      __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+      __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19;
+      goto __pyx_L1_error;
+      __pyx_L42_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_20);
+        __Pyx_XGIVEREF(__pyx_t_21);
+        __Pyx_XGIVEREF(__pyx_t_22);
+        __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
+      }
+      __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_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L23:;
+  }
+
+  /* "uvloop/handles/process.pyx":135
+ *         # so that the transport knows what the PID was even
+ *         # after the process is finished.
+ *         self._pid = (<uv.uv_process_t*>self._handle).pid             # <<<<<<<<<<<<<<
+ * 
+ *         # Track the process handle (create a strong ref to it)
+ */
+  __pyx_t_9 = __Pyx_PyInt_From_int(((uv_process_t *)__pyx_v_self->__pyx_base._handle)->pid); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_GIVEREF(__pyx_t_9);
+  __Pyx_GOTREF(__pyx_v_self->_pid);
+  __Pyx_DECREF(__pyx_v_self->_pid);
+  __pyx_v_self->_pid = __pyx_t_9;
+  __pyx_t_9 = 0;
+
+  /* "uvloop/handles/process.pyx":143
+ *         # which will call `UVProcess._close()`, which will, in turn,
+ *         # untrack this handle.
+ *         self._loop._track_process(self)             # <<<<<<<<<<<<<<
+ * 
+ *         if debug_flags & __PROCESS_DEBUG_SLEEP_AFTER_FORK:
+ */
+  __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_base._loop->__pyx_vtab)->_track_process(__pyx_v_self->__pyx_base._loop, __pyx_v_self); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+  /* "uvloop/handles/process.pyx":145
+ *         self._loop._track_process(self)
+ * 
+ *         if debug_flags & __PROCESS_DEBUG_SLEEP_AFTER_FORK:             # <<<<<<<<<<<<<<
+ *             time_sleep(1)
+ * 
+ */
+  __pyx_t_9 = __Pyx_PyInt_AndObjC(__pyx_v_debug_flags, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 145, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_15 < 0)) __PYX_ERR(4, 145, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  if (__pyx_t_15) {
+
+    /* "uvloop/handles/process.pyx":146
+ * 
+ *         if debug_flags & __PROCESS_DEBUG_SLEEP_AFTER_FORK:
+ *             time_sleep(1)             # <<<<<<<<<<<<<<
+ * 
+ *         if preexec_fn is not None and errpipe_data:
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_time_sleep);
+    __pyx_t_1 = __pyx_v_6uvloop_4loop_time_sleep; __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+      }
+    }
+    __pyx_t_9 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_8, __pyx_int_1) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_int_1);
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 146, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/handles/process.pyx":145
+ *         self._loop._track_process(self)
+ * 
+ *         if debug_flags & __PROCESS_DEBUG_SLEEP_AFTER_FORK:             # <<<<<<<<<<<<<<
+ *             time_sleep(1)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":148
+ *             time_sleep(1)
+ * 
+ *         if preexec_fn is not None and errpipe_data:             # <<<<<<<<<<<<<<
+ *             # preexec_fn has raised an exception.  The child
+ *             # process must be dead now.
+ */
+  __pyx_t_2 = (__pyx_v_preexec_fn != Py_None);
+  __pyx_t_11 = (__pyx_t_2 != 0);
+  if (__pyx_t_11) {
+  } else {
+    __pyx_t_15 = __pyx_t_11;
+    goto __pyx_L55_bool_binop_done;
+  }
+  if (unlikely(!__pyx_v_errpipe_data)) { __Pyx_RaiseUnboundLocalError("errpipe_data"); __PYX_ERR(4, 148, __pyx_L1_error) }
+  __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_errpipe_data); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(4, 148, __pyx_L1_error)
+  __pyx_t_15 = __pyx_t_11;
+  __pyx_L55_bool_binop_done:;
+  if (__pyx_t_15) {
+
+    /* "uvloop/handles/process.pyx":151
+ *             # preexec_fn has raised an exception.  The child
+ *             # process must be dead now.
+ *             try:             # <<<<<<<<<<<<<<
+ *                 exc_name, exc_msg = errpipe_data.split(b':', 1)
+ *                 exc_name = exc_name.decode()
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_22, &__pyx_t_21, &__pyx_t_20);
+      __Pyx_XGOTREF(__pyx_t_22);
+      __Pyx_XGOTREF(__pyx_t_21);
+      __Pyx_XGOTREF(__pyx_t_20);
+      /*try:*/ {
+
+        /* "uvloop/handles/process.pyx":152
+ *             # process must be dead now.
+ *             try:
+ *                 exc_name, exc_msg = errpipe_data.split(b':', 1)             # <<<<<<<<<<<<<<
+ *                 exc_name = exc_name.decode()
+ *                 exc_msg = exc_msg.decode()
+ */
+        if (unlikely(!__pyx_v_errpipe_data)) { __Pyx_RaiseUnboundLocalError("errpipe_data"); __PYX_ERR(4, 152, __pyx_L57_error) }
+        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_errpipe_data, __pyx_n_s_split); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 152, __pyx_L57_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_tuple__179, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 152, __pyx_L57_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 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);
+          if (unlikely(size != 2)) {
+            if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+            else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+            __PYX_ERR(4, 152, __pyx_L57_error)
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          if (likely(PyTuple_CheckExact(sequence))) {
+            __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); 
+            __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); 
+          } else {
+            __pyx_t_9 = PyList_GET_ITEM(sequence, 0); 
+            __pyx_t_8 = PyList_GET_ITEM(sequence, 1); 
+          }
+          __Pyx_INCREF(__pyx_t_9);
+          __Pyx_INCREF(__pyx_t_8);
+          #else
+          __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 152, __pyx_L57_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 152, __pyx_L57_error)
+          __Pyx_GOTREF(__pyx_t_8);
+          #endif
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        } else {
+          Py_ssize_t index = -1;
+          __pyx_t_14 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 152, __pyx_L57_error)
+          __Pyx_GOTREF(__pyx_t_14);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __pyx_t_16 = Py_TYPE(__pyx_t_14)->tp_iternext;
+          index = 0; __pyx_t_9 = __pyx_t_16(__pyx_t_14); if (unlikely(!__pyx_t_9)) goto __pyx_L63_unpacking_failed;
+          __Pyx_GOTREF(__pyx_t_9);
+          index = 1; __pyx_t_8 = __pyx_t_16(__pyx_t_14); if (unlikely(!__pyx_t_8)) goto __pyx_L63_unpacking_failed;
+          __Pyx_GOTREF(__pyx_t_8);
+          if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_14), 2) < 0) __PYX_ERR(4, 152, __pyx_L57_error)
+          __pyx_t_16 = NULL;
+          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+          goto __pyx_L64_unpacking_done;
+          __pyx_L63_unpacking_failed:;
+          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+          __pyx_t_16 = NULL;
+          if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+          __PYX_ERR(4, 152, __pyx_L57_error)
+          __pyx_L64_unpacking_done:;
+        }
+        __pyx_v_exc_name = __pyx_t_9;
+        __pyx_t_9 = 0;
+        __pyx_v_exc_msg = __pyx_t_8;
+        __pyx_t_8 = 0;
+
+        /* "uvloop/handles/process.pyx":153
+ *             try:
+ *                 exc_name, exc_msg = errpipe_data.split(b':', 1)
+ *                 exc_name = exc_name.decode()             # <<<<<<<<<<<<<<
+ *                 exc_msg = exc_msg.decode()
+ *             except Exception:
+ */
+        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_exc_name, __pyx_n_s_decode); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 153, __pyx_L57_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __pyx_t_9 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+          __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+          if (likely(__pyx_t_9)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+            __Pyx_INCREF(__pyx_t_9);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_8, function);
+          }
+        }
+        __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_8);
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 153, __pyx_L57_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF_SET(__pyx_v_exc_name, __pyx_t_1);
+        __pyx_t_1 = 0;
+
+        /* "uvloop/handles/process.pyx":154
+ *                 exc_name, exc_msg = errpipe_data.split(b':', 1)
+ *                 exc_name = exc_name.decode()
+ *                 exc_msg = exc_msg.decode()             # <<<<<<<<<<<<<<
+ *             except Exception:
+ *                 self._close()
+ */
+        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_exc_msg, __pyx_n_s_decode); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 154, __pyx_L57_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __pyx_t_9 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+          __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+          if (likely(__pyx_t_9)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+            __Pyx_INCREF(__pyx_t_9);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_8, function);
+          }
+        }
+        __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_8);
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 154, __pyx_L57_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF_SET(__pyx_v_exc_msg, __pyx_t_1);
+        __pyx_t_1 = 0;
+
+        /* "uvloop/handles/process.pyx":151
+ *             # preexec_fn has raised an exception.  The child
+ *             # process must be dead now.
+ *             try:             # <<<<<<<<<<<<<<
+ *                 exc_name, exc_msg = errpipe_data.split(b':', 1)
+ *                 exc_name = exc_name.decode()
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
+      __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
+      __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+      goto __pyx_L62_try_end;
+      __pyx_L57_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/handles/process.pyx":155
+ *                 exc_name = exc_name.decode()
+ *                 exc_msg = exc_msg.decode()
+ *             except Exception:             # <<<<<<<<<<<<<<
+ *                 self._close()
+ *                 raise subprocess_SubprocessError(
+ */
+      __pyx_t_18 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+      if (__pyx_t_18) {
+        __Pyx_AddTraceback("uvloop.loop.UVProcess._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(4, 155, __pyx_L59_except_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_9);
+
+        /* "uvloop/handles/process.pyx":156
+ *                 exc_msg = exc_msg.decode()
+ *             except Exception:
+ *                 self._close()             # <<<<<<<<<<<<<<
+ *                 raise subprocess_SubprocessError(
+ *                     'Bad exception data from child: {!r}'.format(
+ */
+        __pyx_t_14 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 156, __pyx_L59_except_error)
+        __Pyx_GOTREF(__pyx_t_14);
+        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+
+        /* "uvloop/handles/process.pyx":158
+ *                 self._close()
+ *                 raise subprocess_SubprocessError(
+ *                     'Bad exception data from child: {!r}'.format(             # <<<<<<<<<<<<<<
+ *                         errpipe_data))
+ *             exc_cls = getattr(__builtins__, exc_name,
+ */
+        __pyx_t_28 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Bad_exception_data_from_child_r, __pyx_n_s_format); if (unlikely(!__pyx_t_28)) __PYX_ERR(4, 158, __pyx_L59_except_error)
+        __Pyx_GOTREF(__pyx_t_28);
+
+        /* "uvloop/handles/process.pyx":159
+ *                 raise subprocess_SubprocessError(
+ *                     'Bad exception data from child: {!r}'.format(
+ *                         errpipe_data))             # <<<<<<<<<<<<<<
+ *             exc_cls = getattr(__builtins__, exc_name,
+ *                               subprocess_SubprocessError)
+ */
+        if (unlikely(!__pyx_v_errpipe_data)) { __Pyx_RaiseUnboundLocalError("errpipe_data"); __PYX_ERR(4, 159, __pyx_L59_except_error) }
+        __pyx_t_29 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_28))) {
+          __pyx_t_29 = PyMethod_GET_SELF(__pyx_t_28);
+          if (likely(__pyx_t_29)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_28);
+            __Pyx_INCREF(__pyx_t_29);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_28, function);
+          }
+        }
+        __pyx_t_10 = (__pyx_t_29) ? __Pyx_PyObject_Call2Args(__pyx_t_28, __pyx_t_29, __pyx_v_errpipe_data) : __Pyx_PyObject_CallOneArg(__pyx_t_28, __pyx_v_errpipe_data);
+        __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0;
+        if (unlikely(!__pyx_t_10)) __PYX_ERR(4, 158, __pyx_L59_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_28); __pyx_t_28 = 0;
+        __Pyx_INCREF(__pyx_v_6uvloop_4loop_subprocess_SubprocessError);
+        __pyx_t_28 = __pyx_v_6uvloop_4loop_subprocess_SubprocessError; __pyx_t_29 = NULL;
+        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_28))) {
+          __pyx_t_29 = PyMethod_GET_SELF(__pyx_t_28);
+          if (likely(__pyx_t_29)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_28);
+            __Pyx_INCREF(__pyx_t_29);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_28, function);
+          }
+        }
+        __pyx_t_14 = (__pyx_t_29) ? __Pyx_PyObject_Call2Args(__pyx_t_28, __pyx_t_29, __pyx_t_10) : __Pyx_PyObject_CallOneArg(__pyx_t_28, __pyx_t_10);
+        __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0;
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 157, __pyx_L59_except_error)
+        __Pyx_GOTREF(__pyx_t_14);
+        __Pyx_DECREF(__pyx_t_28); __pyx_t_28 = 0;
+        __Pyx_Raise(__pyx_t_14, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __PYX_ERR(4, 157, __pyx_L59_except_error)
+      }
+      goto __pyx_L59_except_error;
+      __pyx_L59_except_error:;
+
+      /* "uvloop/handles/process.pyx":151
+ *             # preexec_fn has raised an exception.  The child
+ *             # process must be dead now.
+ *             try:             # <<<<<<<<<<<<<<
+ *                 exc_name, exc_msg = errpipe_data.split(b':', 1)
+ *                 exc_name = exc_name.decode()
+ */
+      __Pyx_XGIVEREF(__pyx_t_22);
+      __Pyx_XGIVEREF(__pyx_t_21);
+      __Pyx_XGIVEREF(__pyx_t_20);
+      __Pyx_ExceptionReset(__pyx_t_22, __pyx_t_21, __pyx_t_20);
+      goto __pyx_L1_error;
+      __pyx_L62_try_end:;
+    }
+
+    /* "uvloop/handles/process.pyx":160
+ *                     'Bad exception data from child: {!r}'.format(
+ *                         errpipe_data))
+ *             exc_cls = getattr(__builtins__, exc_name,             # <<<<<<<<<<<<<<
+ *                               subprocess_SubprocessError)
+ * 
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_builtins); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 160, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+
+    /* "uvloop/handles/process.pyx":161
+ *                         errpipe_data))
+ *             exc_cls = getattr(__builtins__, exc_name,
+ *                               subprocess_SubprocessError)             # <<<<<<<<<<<<<<
+ * 
+ *             exc = subprocess_SubprocessError(
+ */
+    __pyx_t_8 = __pyx_v_6uvloop_4loop_subprocess_SubprocessError;
+    __Pyx_INCREF(__pyx_t_8);
+
+    /* "uvloop/handles/process.pyx":160
+ *                     'Bad exception data from child: {!r}'.format(
+ *                         errpipe_data))
+ *             exc_cls = getattr(__builtins__, exc_name,             # <<<<<<<<<<<<<<
+ *                               subprocess_SubprocessError)
+ * 
+ */
+    __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_9, __pyx_v_exc_name, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 160, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_v_exc_cls = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/process.pyx":163
+ *                               subprocess_SubprocessError)
+ * 
+ *             exc = subprocess_SubprocessError(             # <<<<<<<<<<<<<<
+ *                 'Exception occurred in preexec_fn.')
+ *             exc.__cause__ = exc_cls(exc_msg)
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_subprocess_SubprocessError);
+    __pyx_t_8 = __pyx_v_6uvloop_4loop_subprocess_SubprocessError; __pyx_t_9 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_8, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_kp_u_Exception_occurred_in_preexec_fn) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_kp_u_Exception_occurred_in_preexec_fn);
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 163, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/process.pyx":165
+ *             exc = subprocess_SubprocessError(
+ *                 'Exception occurred in preexec_fn.')
+ *             exc.__cause__ = exc_cls(exc_msg)             # <<<<<<<<<<<<<<
+ *             self._close()
+ *             raise exc
+ */
+    __Pyx_INCREF(__pyx_v_exc_cls);
+    __pyx_t_8 = __pyx_v_exc_cls; __pyx_t_9 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_8, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_v_exc_msg) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_exc_msg);
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 165, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_exc, __pyx_n_s_cause, __pyx_t_1) < 0) __PYX_ERR(4, 165, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/process.pyx":166
+ *                 'Exception occurred in preexec_fn.')
+ *             exc.__cause__ = exc_cls(exc_msg)
+ *             self._close()             # <<<<<<<<<<<<<<
+ *             raise exc
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 166, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/process.pyx":167
+ *             exc.__cause__ = exc_cls(exc_msg)
+ *             self._close()
+ *             raise exc             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _after_fork(self):
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(4, 167, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":148
+ *             time_sleep(1)
+ * 
+ *         if preexec_fn is not None and errpipe_data:             # <<<<<<<<<<<<<<
+ *             # preexec_fn has raised an exception.  The child
+ *             # process must be dead now.
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":25
+ *         self._handle = NULL  # close callback will free() the memory
+ * 
+ *     cdef _init(self, Loop loop, list args, dict env,             # <<<<<<<<<<<<<<
+ *                cwd, start_new_session,
+ *                _stdin, _stdout, _stderr,  # std* can be defined as macros in C
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_XDECREF(__pyx_t_28);
+  __Pyx_XDECREF(__pyx_t_29);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_restore_inheritable);
+  __Pyx_XDECREF(__pyx_v_fd);
+  __Pyx_XDECREF(__pyx_v_errpipe_data);
+  __Pyx_XDECREF(__pyx_v_part);
+  __Pyx_XDECREF(__pyx_v_fds_to_close);
+  __Pyx_XDECREF(__pyx_v_exc_name);
+  __Pyx_XDECREF(__pyx_v_exc_msg);
+  __Pyx_XDECREF(__pyx_v_exc_cls);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":169
+ *             raise exc
+ * 
+ *     cdef _after_fork(self):             # <<<<<<<<<<<<<<
+ *         # See CPython/_posixsubprocess.c for details
+ *         cdef int err
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__after_fork(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_v_f = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  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;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_after_fork", 0);
+
+  /* "uvloop/handles/process.pyx":173
+ *         cdef int err
+ * 
+ *         if self._restore_signals:             # <<<<<<<<<<<<<<
+ *             _Py_RestoreSignals()
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->_restore_signals != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":174
+ * 
+ *         if self._restore_signals:
+ *             _Py_RestoreSignals()             # <<<<<<<<<<<<<<
+ * 
+ *         PyOS_AfterFork_Child()
+ */
+    _Py_RestoreSignals();
+
+    /* "uvloop/handles/process.pyx":173
+ *         cdef int err
+ * 
+ *         if self._restore_signals:             # <<<<<<<<<<<<<<
+ *             _Py_RestoreSignals()
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":176
+ *             _Py_RestoreSignals()
+ * 
+ *         PyOS_AfterFork_Child()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_loop_fork(self._loop.uvloop)
+ */
+  PyOS_AfterFork_Child();
+
+  /* "uvloop/handles/process.pyx":178
+ *         PyOS_AfterFork_Child()
+ * 
+ *         err = uv.uv_loop_fork(self._loop.uvloop)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             raise convert_error(err)
+ */
+  __pyx_v_err = uv_loop_fork(__pyx_v_self->__pyx_base._loop->uvloop);
+
+  /* "uvloop/handles/process.pyx":179
+ * 
+ *         err = uv.uv_loop_fork(self._loop.uvloop)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/process.pyx":180
+ *         err = uv.uv_loop_fork(self._loop.uvloop)
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         if self._preexec_fn is not None:
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 180, __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(4, 180, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":179
+ * 
+ *         err = uv.uv_loop_fork(self._loop.uvloop)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":182
+ *             raise convert_error(err)
+ * 
+ *         if self._preexec_fn is not None:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 gc_disable()
+ */
+  __pyx_t_1 = (__pyx_v_self->_preexec_fn != Py_None);
+  __pyx_t_3 = (__pyx_t_1 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/process.pyx":183
+ * 
+ *         if self._preexec_fn is not None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 gc_disable()
+ *                 self._preexec_fn()
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      /*try:*/ {
+
+        /* "uvloop/handles/process.pyx":184
+ *         if self._preexec_fn is not None:
+ *             try:
+ *                 gc_disable()             # <<<<<<<<<<<<<<
+ *                 self._preexec_fn()
+ *             except BaseException as ex:
+ */
+        __Pyx_INCREF(__pyx_v_6uvloop_4loop_gc_disable);
+        __pyx_t_7 = __pyx_v_6uvloop_4loop_gc_disable; __pyx_t_8 = NULL;
+        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+          if (likely(__pyx_t_8)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+            __Pyx_INCREF(__pyx_t_8);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_7, function);
+          }
+        }
+        __pyx_t_2 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 184, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/handles/process.pyx":185
+ *             try:
+ *                 gc_disable()
+ *                 self._preexec_fn()             # <<<<<<<<<<<<<<
+ *             except BaseException as ex:
+ *                 try:
+ */
+        __Pyx_INCREF(__pyx_v_self->_preexec_fn);
+        __pyx_t_7 = __pyx_v_self->_preexec_fn; __pyx_t_8 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+          if (likely(__pyx_t_8)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+            __Pyx_INCREF(__pyx_t_8);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_7, function);
+          }
+        }
+        __pyx_t_2 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 185, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/handles/process.pyx":183
+ * 
+ *         if self._preexec_fn is not None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 gc_disable()
+ *                 self._preexec_fn()
+ */
+      }
+
+      /* "uvloop/handles/process.pyx":196
+ *                     return
+ *             else:
+ *                 os_close(self._errpipe_write)             # <<<<<<<<<<<<<<
+ *         else:
+ *             os_close(self._errpipe_write)
+ */
+      /*else:*/ {
+        __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_close);
+        __pyx_t_7 = __pyx_v_6uvloop_4loop_os_close; __pyx_t_8 = NULL;
+        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+          if (likely(__pyx_t_8)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+            __Pyx_INCREF(__pyx_t_8);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_7, function);
+          }
+        }
+        __pyx_t_2 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_v_self->_errpipe_write) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_self->_errpipe_write);
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 196, __pyx_L8_except_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      }
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L11_try_end;
+      __pyx_L6_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;
+
+      /* "uvloop/handles/process.pyx":186
+ *                 gc_disable()
+ *                 self._preexec_fn()
+ *             except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     with open(self._errpipe_write, 'wb') as f:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.UVProcess._after_fork", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(4, 186, __pyx_L8_except_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_7);
+        __pyx_v_ex = __pyx_t_7;
+        /*try:*/ {
+
+          /* "uvloop/handles/process.pyx":187
+ *                 self._preexec_fn()
+ *             except BaseException as ex:
+ *                 try:             # <<<<<<<<<<<<<<
+ *                     with open(self._errpipe_write, 'wb') as f:
+ *                         f.write(str(ex.__class__.__name__).encode())
+ */
+          /*try:*/ {
+
+            /* "uvloop/handles/process.pyx":188
+ *             except BaseException as ex:
+ *                 try:
+ *                     with open(self._errpipe_write, 'wb') as f:             # <<<<<<<<<<<<<<
+ *                         f.write(str(ex.__class__.__name__).encode())
+ *                         f.write(b':')
+ */
+            /*with:*/ {
+              __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(4, 188, __pyx_L22_error)
+              __Pyx_GOTREF(__pyx_t_10);
+              __Pyx_INCREF(__pyx_v_self->_errpipe_write);
+              __Pyx_GIVEREF(__pyx_v_self->_errpipe_write);
+              PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_self->_errpipe_write);
+              __Pyx_INCREF(__pyx_n_u_wb);
+              __Pyx_GIVEREF(__pyx_n_u_wb);
+              PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_n_u_wb);
+              __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_open, __pyx_t_10, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 188, __pyx_L22_error)
+              __Pyx_GOTREF(__pyx_t_11);
+              __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __pyx_t_12 = __Pyx_PyObject_LookupSpecial(__pyx_t_11, __pyx_n_s_exit); if (unlikely(!__pyx_t_12)) __PYX_ERR(4, 188, __pyx_L22_error)
+              __Pyx_GOTREF(__pyx_t_12);
+              __pyx_t_13 = __Pyx_PyObject_LookupSpecial(__pyx_t_11, __pyx_n_s_enter); if (unlikely(!__pyx_t_13)) __PYX_ERR(4, 188, __pyx_L24_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __pyx_t_14 = NULL;
+              if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) {
+                __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13);
+                if (likely(__pyx_t_14)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+                  __Pyx_INCREF(__pyx_t_14);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_13, function);
+                }
+              }
+              __pyx_t_10 = (__pyx_t_14) ? __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_14) : __Pyx_PyObject_CallNoArg(__pyx_t_13);
+              __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+              if (unlikely(!__pyx_t_10)) __PYX_ERR(4, 188, __pyx_L24_error)
+              __Pyx_GOTREF(__pyx_t_10);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_13 = __pyx_t_10;
+              __pyx_t_10 = 0;
+              __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+              /*try:*/ {
+                {
+                  __Pyx_PyThreadState_declare
+                  __Pyx_PyThreadState_assign
+                  __Pyx_ExceptionSave(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+                  __Pyx_XGOTREF(__pyx_t_15);
+                  __Pyx_XGOTREF(__pyx_t_16);
+                  __Pyx_XGOTREF(__pyx_t_17);
+                  /*try:*/ {
+                    __pyx_v_f = __pyx_t_13;
+                    __pyx_t_13 = 0;
+
+                    /* "uvloop/handles/process.pyx":189
+ *                 try:
+ *                     with open(self._errpipe_write, 'wb') as f:
+ *                         f.write(str(ex.__class__.__name__).encode())             # <<<<<<<<<<<<<<
+ *                         f.write(b':')
+ *                         f.write(str(ex.args[0]).encode())
+ */
+                    __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_write); if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 189, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_11);
+                    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_ex, __pyx_n_s_class); if (unlikely(!__pyx_t_10)) __PYX_ERR(4, 189, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_10);
+                    __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_name); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 189, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_14);
+                    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+                    __pyx_t_10 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_14); if (unlikely(!__pyx_t_10)) __PYX_ERR(4, 189, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_10);
+                    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+                    __pyx_t_14 = PyUnicode_AsEncodedString(((PyObject*)__pyx_t_10), NULL, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 189, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_14);
+                    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+                    __pyx_t_10 = NULL;
+                    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+                      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_11);
+                      if (likely(__pyx_t_10)) {
+                        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+                        __Pyx_INCREF(__pyx_t_10);
+                        __Pyx_INCREF(function);
+                        __Pyx_DECREF_SET(__pyx_t_11, function);
+                      }
+                    }
+                    __pyx_t_13 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_10, __pyx_t_14) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_14);
+                    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+                    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+                    if (unlikely(!__pyx_t_13)) __PYX_ERR(4, 189, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_13);
+                    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+                    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+                    /* "uvloop/handles/process.pyx":190
+ *                     with open(self._errpipe_write, 'wb') as f:
+ *                         f.write(str(ex.__class__.__name__).encode())
+ *                         f.write(b':')             # <<<<<<<<<<<<<<
+ *                         f.write(str(ex.args[0]).encode())
+ *                 finally:
+ */
+                    __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_write); if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 190, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_11);
+                    __pyx_t_14 = NULL;
+                    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+                      __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_11);
+                      if (likely(__pyx_t_14)) {
+                        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+                        __Pyx_INCREF(__pyx_t_14);
+                        __Pyx_INCREF(function);
+                        __Pyx_DECREF_SET(__pyx_t_11, function);
+                      }
+                    }
+                    __pyx_t_13 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_14, __pyx_kp_b__178) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_kp_b__178);
+                    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+                    if (unlikely(!__pyx_t_13)) __PYX_ERR(4, 190, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_13);
+                    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+                    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+                    /* "uvloop/handles/process.pyx":191
+ *                         f.write(str(ex.__class__.__name__).encode())
+ *                         f.write(b':')
+ *                         f.write(str(ex.args[0]).encode())             # <<<<<<<<<<<<<<
+ *                 finally:
+ *                     system._exit(255)
+ */
+                    __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_write); if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 191, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_11);
+                    __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_ex, __pyx_n_s_args); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 191, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_14);
+                    __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_14, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(4, 191, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_10);
+                    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+                    __pyx_t_14 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_10); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 191, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_14);
+                    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+                    __pyx_t_10 = PyUnicode_AsEncodedString(((PyObject*)__pyx_t_14), NULL, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(4, 191, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_10);
+                    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+                    __pyx_t_14 = NULL;
+                    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+                      __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_11);
+                      if (likely(__pyx_t_14)) {
+                        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+                        __Pyx_INCREF(__pyx_t_14);
+                        __Pyx_INCREF(function);
+                        __Pyx_DECREF_SET(__pyx_t_11, function);
+                      }
+                    }
+                    __pyx_t_13 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_14, __pyx_t_10) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_10);
+                    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+                    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+                    if (unlikely(!__pyx_t_13)) __PYX_ERR(4, 191, __pyx_L30_error)
+                    __Pyx_GOTREF(__pyx_t_13);
+                    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+                    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+                    /* "uvloop/handles/process.pyx":188
+ *             except BaseException as ex:
+ *                 try:
+ *                     with open(self._errpipe_write, 'wb') as f:             # <<<<<<<<<<<<<<
+ *                         f.write(str(ex.__class__.__name__).encode())
+ *                         f.write(b':')
+ */
+                  }
+                  __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+                  __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+                  __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
+                  goto __pyx_L37_try_end;
+                  __pyx_L30_error:;
+                  __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+                  __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+                  __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+                  __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+                  /*except:*/ {
+                    __Pyx_AddTraceback("uvloop.loop.UVProcess._after_fork", __pyx_clineno, __pyx_lineno, __pyx_filename);
+                    if (__Pyx_GetException(&__pyx_t_13, &__pyx_t_11, &__pyx_t_10) < 0) __PYX_ERR(4, 188, __pyx_L32_except_error)
+                    __Pyx_GOTREF(__pyx_t_13);
+                    __Pyx_GOTREF(__pyx_t_11);
+                    __Pyx_GOTREF(__pyx_t_10);
+                    __pyx_t_14 = PyTuple_Pack(3, __pyx_t_13, __pyx_t_11, __pyx_t_10); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 188, __pyx_L32_except_error)
+                    __Pyx_GOTREF(__pyx_t_14);
+                    __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_14, NULL);
+                    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+                    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+                    if (unlikely(!__pyx_t_18)) __PYX_ERR(4, 188, __pyx_L32_except_error)
+                    __Pyx_GOTREF(__pyx_t_18);
+                    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_18);
+                    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+                    if (__pyx_t_3 < 0) __PYX_ERR(4, 188, __pyx_L32_except_error)
+                    __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0);
+                    if (__pyx_t_1) {
+                      __Pyx_GIVEREF(__pyx_t_13);
+                      __Pyx_GIVEREF(__pyx_t_11);
+                      __Pyx_XGIVEREF(__pyx_t_10);
+                      __Pyx_ErrRestoreWithState(__pyx_t_13, __pyx_t_11, __pyx_t_10);
+                      __pyx_t_13 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; 
+                      __PYX_ERR(4, 188, __pyx_L32_except_error)
+                    }
+                    __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+                    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+                    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+                    goto __pyx_L31_exception_handled;
+                  }
+                  __pyx_L32_except_error:;
+                  __Pyx_XGIVEREF(__pyx_t_15);
+                  __Pyx_XGIVEREF(__pyx_t_16);
+                  __Pyx_XGIVEREF(__pyx_t_17);
+                  __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+                  goto __pyx_L22_error;
+                  __pyx_L31_exception_handled:;
+                  __Pyx_XGIVEREF(__pyx_t_15);
+                  __Pyx_XGIVEREF(__pyx_t_16);
+                  __Pyx_XGIVEREF(__pyx_t_17);
+                  __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+                  __pyx_L37_try_end:;
+                }
+              }
+              /*finally:*/ {
+                /*normal exit:*/{
+                  if (__pyx_t_12) {
+                    __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_tuple__180, NULL);
+                    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+                    if (unlikely(!__pyx_t_17)) __PYX_ERR(4, 188, __pyx_L22_error)
+                    __Pyx_GOTREF(__pyx_t_17);
+                    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
+                  }
+                  goto __pyx_L29;
+                }
+                __pyx_L29:;
+              }
+              goto __pyx_L41;
+              __pyx_L24_error:;
+              __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+              goto __pyx_L22_error;
+              __pyx_L41:;
+            }
+          }
+
+          /* "uvloop/handles/process.pyx":193
+ *                         f.write(str(ex.args[0]).encode())
+ *                 finally:
+ *                     system._exit(255)             # <<<<<<<<<<<<<<
+ *                     return
+ *             else:
+ */
+          /*finally:*/ {
+            /*normal exit:*/{
+              _exit(0xFF);
+
+              /* "uvloop/handles/process.pyx":194
+ *                 finally:
+ *                     system._exit(255)
+ *                     return             # <<<<<<<<<<<<<<
+ *             else:
+ *                 os_close(self._errpipe_write)
+ */
+              __Pyx_XDECREF(__pyx_r);
+              __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+              goto __pyx_L16_return;
+            }
+            __pyx_L22_error:;
+            /*exception exit:*/{
+              __Pyx_PyThreadState_declare
+              __Pyx_PyThreadState_assign
+              __pyx_t_12 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+              __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+              if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_18, &__pyx_t_19);
+              if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_17, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_17, &__pyx_t_16);
+              __Pyx_XGOTREF(__pyx_t_12);
+              __Pyx_XGOTREF(__pyx_t_17);
+              __Pyx_XGOTREF(__pyx_t_16);
+              __Pyx_XGOTREF(__pyx_t_15);
+              __Pyx_XGOTREF(__pyx_t_18);
+              __Pyx_XGOTREF(__pyx_t_19);
+              {
+
+                /* "uvloop/handles/process.pyx":193
+ *                         f.write(str(ex.args[0]).encode())
+ *                 finally:
+ *                     system._exit(255)             # <<<<<<<<<<<<<<
+ *                     return
+ *             else:
+ */
+                _exit(0xFF);
+
+                /* "uvloop/handles/process.pyx":194
+ *                 finally:
+ *                     system._exit(255)
+ *                     return             # <<<<<<<<<<<<<<
+ *             else:
+ *                 os_close(self._errpipe_write)
+ */
+                __Pyx_XDECREF(__pyx_r);
+                __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+                __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+                goto __pyx_L44_return;
+              }
+              __pyx_L44_return:;
+              if (PY_MAJOR_VERSION >= 3) {
+                __Pyx_XGIVEREF(__pyx_t_15);
+                __Pyx_XGIVEREF(__pyx_t_18);
+                __Pyx_XGIVEREF(__pyx_t_19);
+                __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_18, __pyx_t_19);
+              }
+              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+              __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
+              __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+              __pyx_t_15 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+              goto __pyx_L16_return;
+            }
+          }
+        }
+
+        /* "uvloop/handles/process.pyx":186
+ *                 gc_disable()
+ *                 self._preexec_fn()
+ *             except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                 try:
+ *                     with open(self._errpipe_write, 'wb') as f:
+ */
+        /*finally:*/ {
+          __pyx_L16_return: {
+            __pyx_t_19 = __pyx_r;
+            __pyx_r = 0;
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            __pyx_r = __pyx_t_19;
+            __pyx_t_19 = 0;
+            goto __pyx_L9_except_return;
+          }
+        }
+      }
+      goto __pyx_L8_except_error;
+      __pyx_L8_except_error:;
+
+      /* "uvloop/handles/process.pyx":183
+ * 
+ *         if self._preexec_fn is not None:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 gc_disable()
+ *                 self._preexec_fn()
+ */
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      goto __pyx_L1_error;
+      __pyx_L9_except_return:;
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      goto __pyx_L0;
+      __pyx_L11_try_end:;
+    }
+
+    /* "uvloop/handles/process.pyx":182
+ *             raise convert_error(err)
+ * 
+ *         if self._preexec_fn is not None:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 gc_disable()
+ */
+    goto __pyx_L5;
+  }
+
+  /* "uvloop/handles/process.pyx":198
+ *                 os_close(self._errpipe_write)
+ *         else:
+ *             os_close(self._errpipe_write)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _close_after_spawn(self, int fd):
+ */
+  /*else*/ {
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_close);
+    __pyx_t_7 = __pyx_v_6uvloop_4loop_os_close; __pyx_t_2 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_2)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_2);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+      }
+    }
+    __pyx_t_8 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_2, __pyx_v_self->_errpipe_write) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_self->_errpipe_write);
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 198, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  }
+  __pyx_L5:;
+
+  /* "uvloop/handles/process.pyx":169
+ *             raise exc
+ * 
+ *     cdef _after_fork(self):             # <<<<<<<<<<<<<<
+ *         # See CPython/_posixsubprocess.c for details
+ *         cdef int err
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess._after_fork", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XDECREF(__pyx_v_f);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":200
+ *             os_close(self._errpipe_write)
+ * 
+ *     cdef _close_after_spawn(self, int fd):             # <<<<<<<<<<<<<<
+ *         if self._fds_to_close is None:
+ *             raise RuntimeError(
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__close_after_spawn(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, int __pyx_v_fd) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_close_after_spawn", 0);
+
+  /* "uvloop/handles/process.pyx":201
+ * 
+ *     cdef _close_after_spawn(self, int fd):
+ *         if self._fds_to_close is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'UVProcess._close_after_spawn called after uv_spawn')
+ */
+  __pyx_t_1 = (__pyx_v_self->_fds_to_close == ((PyObject*)Py_None));
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/process.pyx":202
+ *     cdef _close_after_spawn(self, int fd):
+ *         if self._fds_to_close is None:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'UVProcess._close_after_spawn called after uv_spawn')
+ *         self._fds_to_close.add(fd)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__181, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(4, 202, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":201
+ * 
+ *     cdef _close_after_spawn(self, int fd):
+ *         if self._fds_to_close is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'UVProcess._close_after_spawn called after uv_spawn')
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":204
+ *             raise RuntimeError(
+ *                 'UVProcess._close_after_spawn called after uv_spawn')
+ *         self._fds_to_close.add(fd)             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  if (unlikely(__pyx_v_self->_fds_to_close == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "add");
+    __PYX_ERR(4, 204, __pyx_L1_error)
+  }
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PySet_Add(__pyx_v_self->_fds_to_close, __pyx_t_3); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(4, 204, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/process.pyx":200
+ *             os_close(self._errpipe_write)
+ * 
+ *     cdef _close_after_spawn(self, int fd):             # <<<<<<<<<<<<<<
+ *         if self._fds_to_close is None:
+ *             raise RuntimeError(
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess._close_after_spawn", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":206
+ *         self._fds_to_close.add(fd)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self.uv_opt_env is not NULL:
+ *             PyMem_RawFree(self.uv_opt_env)
+ */
+
+/* Python wrapper */
+static void __pyx_pw_6uvloop_4loop_9UVProcess_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_6uvloop_4loop_9UVProcess_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_6uvloop_4loop_9UVProcess_2__dealloc__(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_6uvloop_4loop_9UVProcess_2__dealloc__(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "uvloop/handles/process.pyx":207
+ * 
+ *     def __dealloc__(self):
+ *         if self.uv_opt_env is not NULL:             # <<<<<<<<<<<<<<
+ *             PyMem_RawFree(self.uv_opt_env)
+ *             self.uv_opt_env = NULL
+ */
+  __pyx_t_1 = ((__pyx_v_self->uv_opt_env != NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":208
+ *     def __dealloc__(self):
+ *         if self.uv_opt_env is not NULL:
+ *             PyMem_RawFree(self.uv_opt_env)             # <<<<<<<<<<<<<<
+ *             self.uv_opt_env = NULL
+ * 
+ */
+    PyMem_RawFree(__pyx_v_self->uv_opt_env);
+
+    /* "uvloop/handles/process.pyx":209
+ *         if self.uv_opt_env is not NULL:
+ *             PyMem_RawFree(self.uv_opt_env)
+ *             self.uv_opt_env = NULL             # <<<<<<<<<<<<<<
+ * 
+ *         if self.uv_opt_args is not NULL:
+ */
+    __pyx_v_self->uv_opt_env = NULL;
+
+    /* "uvloop/handles/process.pyx":207
+ * 
+ *     def __dealloc__(self):
+ *         if self.uv_opt_env is not NULL:             # <<<<<<<<<<<<<<
+ *             PyMem_RawFree(self.uv_opt_env)
+ *             self.uv_opt_env = NULL
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":211
+ *             self.uv_opt_env = NULL
+ * 
+ *         if self.uv_opt_args is not NULL:             # <<<<<<<<<<<<<<
+ *             PyMem_RawFree(self.uv_opt_args)
+ *             self.uv_opt_args = NULL
+ */
+  __pyx_t_1 = ((__pyx_v_self->uv_opt_args != NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":212
+ * 
+ *         if self.uv_opt_args is not NULL:
+ *             PyMem_RawFree(self.uv_opt_args)             # <<<<<<<<<<<<<<
+ *             self.uv_opt_args = NULL
+ * 
+ */
+    PyMem_RawFree(__pyx_v_self->uv_opt_args);
+
+    /* "uvloop/handles/process.pyx":213
+ *         if self.uv_opt_args is not NULL:
+ *             PyMem_RawFree(self.uv_opt_args)
+ *             self.uv_opt_args = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     cdef char** __to_cstring_array(self, list arr):
+ */
+    __pyx_v_self->uv_opt_args = NULL;
+
+    /* "uvloop/handles/process.pyx":211
+ *             self.uv_opt_env = NULL
+ * 
+ *         if self.uv_opt_args is not NULL:             # <<<<<<<<<<<<<<
+ *             PyMem_RawFree(self.uv_opt_args)
+ *             self.uv_opt_args = NULL
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":206
+ *         self._fds_to_close.add(fd)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self.uv_opt_env is not NULL:
+ *             PyMem_RawFree(self.uv_opt_env)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/handles/process.pyx":215
+ *             self.uv_opt_args = NULL
+ * 
+ *     cdef char** __to_cstring_array(self, list arr):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int i
+ */
+
+static char **__pyx_f_6uvloop_4loop_9UVProcess___to_cstring_array(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_arr) {
+  int __pyx_v_i;
+  Py_ssize_t __pyx_v_arr_len;
+  PyObject *__pyx_v_el = 0;
+  char **__pyx_v_ret;
+  char **__pyx_r;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  char *__pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__to_cstring_array", 0);
+
+  /* "uvloop/handles/process.pyx":218
+ *         cdef:
+ *             int i
+ *             ssize_t arr_len = len(arr)             # <<<<<<<<<<<<<<
+ *             bytes el
+ * 
+ */
+  if (unlikely(__pyx_v_arr == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(4, 218, __pyx_L1_error)
+  }
+  __pyx_t_1 = PyList_GET_SIZE(__pyx_v_arr); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(4, 218, __pyx_L1_error)
+  __pyx_v_arr_len = __pyx_t_1;
+
+  /* "uvloop/handles/process.pyx":223
+ *             char **ret
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             assert arr_len > 0
+ * 
+ */
+  __pyx_t_2 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/process.pyx":224
+ * 
+ *         if UVLOOP_DEBUG:
+ *             assert arr_len > 0             # <<<<<<<<<<<<<<
+ * 
+ *         ret = <char **>PyMem_RawMalloc((arr_len + 1) * sizeof(char *))
+ */
+    #ifndef CYTHON_WITHOUT_ASSERTIONS
+    if (unlikely(!Py_OptimizeFlag)) {
+      if (unlikely(!((__pyx_v_arr_len > 0) != 0))) {
+        PyErr_SetNone(PyExc_AssertionError);
+        __PYX_ERR(4, 224, __pyx_L1_error)
+      }
+    }
+    #endif
+
+    /* "uvloop/handles/process.pyx":223
+ *             char **ret
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             assert arr_len > 0
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":226
+ *             assert arr_len > 0
+ * 
+ *         ret = <char **>PyMem_RawMalloc((arr_len + 1) * sizeof(char *))             # <<<<<<<<<<<<<<
+ *         if ret is NULL:
+ *             raise MemoryError()
+ */
+  __pyx_v_ret = ((char **)PyMem_RawMalloc(((__pyx_v_arr_len + 1) * (sizeof(char *)))));
+
+  /* "uvloop/handles/process.pyx":227
+ * 
+ *         ret = <char **>PyMem_RawMalloc((arr_len + 1) * sizeof(char *))
+ *         if ret is NULL:             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_ret == NULL) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/process.pyx":228
+ *         ret = <char **>PyMem_RawMalloc((arr_len + 1) * sizeof(char *))
+ *         if ret is NULL:
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(arr_len):
+ */
+    PyErr_NoMemory(); __PYX_ERR(4, 228, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":227
+ * 
+ *         ret = <char **>PyMem_RawMalloc((arr_len + 1) * sizeof(char *))
+ *         if ret is NULL:             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":230
+ *             raise MemoryError()
+ * 
+ *         for i in range(arr_len):             # <<<<<<<<<<<<<<
+ *             el = arr[i]
+ *             # NB: PyBytes_AsString doesn't copy the data;
+ */
+  __pyx_t_3 = __pyx_v_arr_len;
+  __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;
+
+    /* "uvloop/handles/process.pyx":231
+ * 
+ *         for i in range(arr_len):
+ *             el = arr[i]             # <<<<<<<<<<<<<<
+ *             # NB: PyBytes_AsString doesn't copy the data;
+ *             # we have to be careful when the "arr" is GCed,
+ */
+    if (unlikely(__pyx_v_arr == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(4, 231, __pyx_L1_error)
+    }
+    __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_arr, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 231, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (!(likely(PyBytes_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_6)->tp_name), 0))) __PYX_ERR(4, 231, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_el, ((PyObject*)__pyx_t_6));
+    __pyx_t_6 = 0;
+
+    /* "uvloop/handles/process.pyx":235
+ *             # we have to be careful when the "arr" is GCed,
+ *             # and it shouldn't be ever mutated.
+ *             ret[i] = PyBytes_AsString(el)             # <<<<<<<<<<<<<<
+ * 
+ *         ret[arr_len] = NULL
+ */
+    __pyx_t_7 = PyBytes_AsString(__pyx_v_el); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(4, 235, __pyx_L1_error)
+    (__pyx_v_ret[__pyx_v_i]) = __pyx_t_7;
+  }
+
+  /* "uvloop/handles/process.pyx":237
+ *             ret[i] = PyBytes_AsString(el)
+ * 
+ *         ret[arr_len] = NULL             # <<<<<<<<<<<<<<
+ *         return ret
+ * 
+ */
+  (__pyx_v_ret[__pyx_v_arr_len]) = NULL;
+
+  /* "uvloop/handles/process.pyx":238
+ * 
+ *         ret[arr_len] = NULL
+ *         return ret             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _init_options(self, list args, dict env, cwd, start_new_session,
+ */
+  __pyx_r = __pyx_v_ret;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":215
+ *             self.uv_opt_args = NULL
+ * 
+ *     cdef char** __to_cstring_array(self, list arr):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int i
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_WriteUnraisable("uvloop.loop.UVProcess.__to_cstring_array", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_el);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":240
+ *         return ret
+ * 
+ *     cdef _init_options(self, list args, dict env, cwd, start_new_session,             # <<<<<<<<<<<<<<
+ *                        _stdin, _stdout, _stderr):
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_options(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_env, PyObject *__pyx_v_cwd, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  char **__pyx_t_2;
+  char *__pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init_options", 0);
+  __Pyx_INCREF(__pyx_v_cwd);
+
+  /* "uvloop/handles/process.pyx":243
+ *                        _stdin, _stdout, _stderr):
+ * 
+ *         memset(&self.options, 0, sizeof(uv.uv_process_options_t))             # <<<<<<<<<<<<<<
+ * 
+ *         self._init_env(env)
+ */
+  (void)(memset((&__pyx_v_self->options), 0, (sizeof(uv_process_options_t))));
+
+  /* "uvloop/handles/process.pyx":245
+ *         memset(&self.options, 0, sizeof(uv.uv_process_options_t))
+ * 
+ *         self._init_env(env)             # <<<<<<<<<<<<<<
+ *         self.options.env = self.uv_opt_env
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->_init_env(__pyx_v_self, __pyx_v_env); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 245, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":246
+ * 
+ *         self._init_env(env)
+ *         self.options.env = self.uv_opt_env             # <<<<<<<<<<<<<<
+ * 
+ *         self._init_args(args)
+ */
+  __pyx_t_2 = __pyx_v_self->uv_opt_env;
+  __pyx_v_self->options.env = __pyx_t_2;
+
+  /* "uvloop/handles/process.pyx":248
+ *         self.options.env = self.uv_opt_env
+ * 
+ *         self._init_args(args)             # <<<<<<<<<<<<<<
+ *         self.options.file = self.uv_opt_file
+ *         self.options.args = self.uv_opt_args
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->_init_args(__pyx_v_self, __pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":249
+ * 
+ *         self._init_args(args)
+ *         self.options.file = self.uv_opt_file             # <<<<<<<<<<<<<<
+ *         self.options.args = self.uv_opt_args
+ * 
+ */
+  __pyx_t_3 = __pyx_v_self->uv_opt_file;
+  __pyx_v_self->options.file = __pyx_t_3;
+
+  /* "uvloop/handles/process.pyx":250
+ *         self._init_args(args)
+ *         self.options.file = self.uv_opt_file
+ *         self.options.args = self.uv_opt_args             # <<<<<<<<<<<<<<
+ * 
+ *         if start_new_session:
+ */
+  __pyx_t_2 = __pyx_v_self->uv_opt_args;
+  __pyx_v_self->options.args = __pyx_t_2;
+
+  /* "uvloop/handles/process.pyx":252
+ *         self.options.args = self.uv_opt_args
+ * 
+ *         if start_new_session:             # <<<<<<<<<<<<<<
+ *             self.options.flags |= uv.UV_PROCESS_DETACHED
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_start_new_session); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(4, 252, __pyx_L1_error)
+  if (__pyx_t_4) {
+
+    /* "uvloop/handles/process.pyx":253
+ * 
+ *         if start_new_session:
+ *             self.options.flags |= uv.UV_PROCESS_DETACHED             # <<<<<<<<<<<<<<
+ * 
+ *         if cwd is not None:
+ */
+    __pyx_v_self->options.flags = (__pyx_v_self->options.flags | UV_PROCESS_DETACHED);
+
+    /* "uvloop/handles/process.pyx":252
+ *         self.options.args = self.uv_opt_args
+ * 
+ *         if start_new_session:             # <<<<<<<<<<<<<<
+ *             self.options.flags |= uv.UV_PROCESS_DETACHED
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":255
+ *             self.options.flags |= uv.UV_PROCESS_DETACHED
+ * 
+ *         if cwd is not None:             # <<<<<<<<<<<<<<
+ *             cwd = os_fspath(cwd)
+ * 
+ */
+  __pyx_t_4 = (__pyx_v_cwd != Py_None);
+  __pyx_t_5 = (__pyx_t_4 != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/handles/process.pyx":256
+ * 
+ *         if cwd is not None:
+ *             cwd = os_fspath(cwd)             # <<<<<<<<<<<<<<
+ * 
+ *             if isinstance(cwd, str):
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_fspath);
+    __pyx_t_6 = __pyx_v_6uvloop_4loop_os_fspath; __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_v_cwd) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_cwd);
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 256, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF_SET(__pyx_v_cwd, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/process.pyx":258
+ *             cwd = os_fspath(cwd)
+ * 
+ *             if isinstance(cwd, str):             # <<<<<<<<<<<<<<
+ *                 cwd = PyUnicode_EncodeFSDefault(cwd)
+ *             if not isinstance(cwd, bytes):
+ */
+    __pyx_t_5 = PyUnicode_Check(__pyx_v_cwd); 
+    __pyx_t_4 = (__pyx_t_5 != 0);
+    if (__pyx_t_4) {
+
+      /* "uvloop/handles/process.pyx":259
+ * 
+ *             if isinstance(cwd, str):
+ *                 cwd = PyUnicode_EncodeFSDefault(cwd)             # <<<<<<<<<<<<<<
+ *             if not isinstance(cwd, bytes):
+ *                 raise ValueError('cwd must be a str or bytes object')
+ */
+      __pyx_t_1 = PyUnicode_EncodeFSDefault(__pyx_v_cwd); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 259, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF_SET(__pyx_v_cwd, __pyx_t_1);
+      __pyx_t_1 = 0;
+
+      /* "uvloop/handles/process.pyx":258
+ *             cwd = os_fspath(cwd)
+ * 
+ *             if isinstance(cwd, str):             # <<<<<<<<<<<<<<
+ *                 cwd = PyUnicode_EncodeFSDefault(cwd)
+ *             if not isinstance(cwd, bytes):
+ */
+    }
+
+    /* "uvloop/handles/process.pyx":260
+ *             if isinstance(cwd, str):
+ *                 cwd = PyUnicode_EncodeFSDefault(cwd)
+ *             if not isinstance(cwd, bytes):             # <<<<<<<<<<<<<<
+ *                 raise ValueError('cwd must be a str or bytes object')
+ * 
+ */
+    __pyx_t_4 = PyBytes_Check(__pyx_v_cwd); 
+    __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0);
+    if (unlikely(__pyx_t_5)) {
+
+      /* "uvloop/handles/process.pyx":261
+ *                 cwd = PyUnicode_EncodeFSDefault(cwd)
+ *             if not isinstance(cwd, bytes):
+ *                 raise ValueError('cwd must be a str or bytes object')             # <<<<<<<<<<<<<<
+ * 
+ *             self.__cwd = cwd
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__182, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 261, __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(4, 261, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":260
+ *             if isinstance(cwd, str):
+ *                 cwd = PyUnicode_EncodeFSDefault(cwd)
+ *             if not isinstance(cwd, bytes):             # <<<<<<<<<<<<<<
+ *                 raise ValueError('cwd must be a str or bytes object')
+ * 
+ */
+    }
+
+    /* "uvloop/handles/process.pyx":263
+ *                 raise ValueError('cwd must be a str or bytes object')
+ * 
+ *             self.__cwd = cwd             # <<<<<<<<<<<<<<
+ *             self.options.cwd = PyBytes_AsString(self.__cwd)
+ * 
+ */
+    if (!(likely(PyBytes_CheckExact(__pyx_v_cwd))||((__pyx_v_cwd) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_cwd)->tp_name), 0))) __PYX_ERR(4, 263, __pyx_L1_error)
+    __pyx_t_1 = __pyx_v_cwd;
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_1);
+    __Pyx_GOTREF(__pyx_v_self->__pyx___cwd);
+    __Pyx_DECREF(__pyx_v_self->__pyx___cwd);
+    __pyx_v_self->__pyx___cwd = ((PyObject*)__pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/process.pyx":264
+ * 
+ *             self.__cwd = cwd
+ *             self.options.cwd = PyBytes_AsString(self.__cwd)             # <<<<<<<<<<<<<<
+ * 
+ *         self.options.exit_cb = &__uvprocess_on_exit_callback
+ */
+    __pyx_t_1 = __pyx_v_self->__pyx___cwd;
+    __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_3 = PyBytes_AsString(__pyx_t_1); if (unlikely(__pyx_t_3 == ((char *)NULL))) __PYX_ERR(4, 264, __pyx_L1_error)
+    __pyx_v_self->options.cwd = __pyx_t_3;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/process.pyx":255
+ *             self.options.flags |= uv.UV_PROCESS_DETACHED
+ * 
+ *         if cwd is not None:             # <<<<<<<<<<<<<<
+ *             cwd = os_fspath(cwd)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":266
+ *             self.options.cwd = PyBytes_AsString(self.__cwd)
+ * 
+ *         self.options.exit_cb = &__uvprocess_on_exit_callback             # <<<<<<<<<<<<<<
+ * 
+ *         self._init_files(_stdin, _stdout, _stderr)
+ */
+  __pyx_v_self->options.exit_cb = (&__pyx_f_6uvloop_4loop___uvprocess_on_exit_callback);
+
+  /* "uvloop/handles/process.pyx":268
+ *         self.options.exit_cb = &__uvprocess_on_exit_callback
+ * 
+ *         self._init_files(_stdin, _stdout, _stderr)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _init_args(self, list args):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->_init_files(__pyx_v_self, __pyx_v__stdin, __pyx_v__stdout, __pyx_v__stderr); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 268, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":240
+ *         return ret
+ * 
+ *     cdef _init_options(self, list args, dict env, cwd, start_new_session,             # <<<<<<<<<<<<<<
+ *                        _stdin, _stdout, _stderr):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess._init_options", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_cwd);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":270
+ *         self._init_files(_stdin, _stdout, _stderr)
+ * 
+ *     cdef _init_args(self, list args):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             bytes path
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_args(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_args) {
+  PyObject *__pyx_v_path = 0;
+  int __pyx_v_an;
+  int __pyx_v_i;
+  PyObject *__pyx_v_arg = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_t_10;
+  char *__pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init_args", 0);
+
+  /* "uvloop/handles/process.pyx":273
+ *         cdef:
+ *             bytes path
+ *             int an = len(args)             # <<<<<<<<<<<<<<
+ * 
+ *         if an < 1:
+ */
+  if (unlikely(__pyx_v_args == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(4, 273, __pyx_L1_error)
+  }
+  __pyx_t_1 = PyList_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(4, 273, __pyx_L1_error)
+  __pyx_v_an = __pyx_t_1;
+
+  /* "uvloop/handles/process.pyx":275
+ *             int an = len(args)
+ * 
+ *         if an < 1:             # <<<<<<<<<<<<<<
+ *             raise ValueError('cannot spawn a process: args are empty')
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_an < 1) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/process.pyx":276
+ * 
+ *         if an < 1:
+ *             raise ValueError('cannot spawn a process: args are empty')             # <<<<<<<<<<<<<<
+ * 
+ *         self.__args = args.copy()
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__183, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 276, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(4, 276, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":275
+ *             int an = len(args)
+ * 
+ *         if an < 1:             # <<<<<<<<<<<<<<
+ *             raise ValueError('cannot spawn a process: args are empty')
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":278
+ *             raise ValueError('cannot spawn a process: args are empty')
+ * 
+ *         self.__args = args.copy()             # <<<<<<<<<<<<<<
+ *         for i in range(an):
+ *             arg = os_fspath(args[i])
+ */
+  __pyx_t_3 = __Pyx_CallUnboundCMethod0(&__pyx_umethod_PyList_Type_copy, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 278, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (!(likely(PyList_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(4, 278, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_v_self->__pyx___args);
+  __Pyx_DECREF(__pyx_v_self->__pyx___args);
+  __pyx_v_self->__pyx___args = ((PyObject*)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/handles/process.pyx":279
+ * 
+ *         self.__args = args.copy()
+ *         for i in range(an):             # <<<<<<<<<<<<<<
+ *             arg = os_fspath(args[i])
+ *             if isinstance(arg, str):
+ */
+  __pyx_t_4 = __pyx_v_an;
+  __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;
+
+    /* "uvloop/handles/process.pyx":280
+ *         self.__args = args.copy()
+ *         for i in range(an):
+ *             arg = os_fspath(args[i])             # <<<<<<<<<<<<<<
+ *             if isinstance(arg, str):
+ *                 self.__args[i] = PyUnicode_EncodeFSDefault(arg)
+ */
+    if (unlikely(__pyx_v_args == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(4, 280, __pyx_L1_error)
+    }
+    __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_args, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 280, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_fspath);
+    __pyx_t_8 = __pyx_v_6uvloop_4loop_os_fspath; __pyx_t_9 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_8, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7);
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 280, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_arg, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/handles/process.pyx":281
+ *         for i in range(an):
+ *             arg = os_fspath(args[i])
+ *             if isinstance(arg, str):             # <<<<<<<<<<<<<<
+ *                 self.__args[i] = PyUnicode_EncodeFSDefault(arg)
+ *             elif not isinstance(arg, bytes):
+ */
+    __pyx_t_2 = PyUnicode_Check(__pyx_v_arg); 
+    __pyx_t_10 = (__pyx_t_2 != 0);
+    if (__pyx_t_10) {
+
+      /* "uvloop/handles/process.pyx":282
+ *             arg = os_fspath(args[i])
+ *             if isinstance(arg, str):
+ *                 self.__args[i] = PyUnicode_EncodeFSDefault(arg)             # <<<<<<<<<<<<<<
+ *             elif not isinstance(arg, bytes):
+ *                 raise TypeError('all args must be str or bytes')
+ */
+      __pyx_t_3 = PyUnicode_EncodeFSDefault(__pyx_v_arg); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 282, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      if (unlikely(__pyx_v_self->__pyx___args == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(4, 282, __pyx_L1_error)
+      }
+      if (unlikely(__Pyx_SetItemInt(__pyx_v_self->__pyx___args, __pyx_v_i, __pyx_t_3, int, 1, __Pyx_PyInt_From_int, 1, 1, 1) < 0)) __PYX_ERR(4, 282, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/process.pyx":281
+ *         for i in range(an):
+ *             arg = os_fspath(args[i])
+ *             if isinstance(arg, str):             # <<<<<<<<<<<<<<
+ *                 self.__args[i] = PyUnicode_EncodeFSDefault(arg)
+ *             elif not isinstance(arg, bytes):
+ */
+      goto __pyx_L6;
+    }
+
+    /* "uvloop/handles/process.pyx":283
+ *             if isinstance(arg, str):
+ *                 self.__args[i] = PyUnicode_EncodeFSDefault(arg)
+ *             elif not isinstance(arg, bytes):             # <<<<<<<<<<<<<<
+ *                 raise TypeError('all args must be str or bytes')
+ * 
+ */
+    __pyx_t_10 = PyBytes_Check(__pyx_v_arg); 
+    __pyx_t_2 = ((!(__pyx_t_10 != 0)) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/handles/process.pyx":284
+ *                 self.__args[i] = PyUnicode_EncodeFSDefault(arg)
+ *             elif not isinstance(arg, bytes):
+ *                 raise TypeError('all args must be str or bytes')             # <<<<<<<<<<<<<<
+ * 
+ *         path = self.__args[0]
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__184, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 284, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(4, 284, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":283
+ *             if isinstance(arg, str):
+ *                 self.__args[i] = PyUnicode_EncodeFSDefault(arg)
+ *             elif not isinstance(arg, bytes):             # <<<<<<<<<<<<<<
+ *                 raise TypeError('all args must be str or bytes')
+ * 
+ */
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/handles/process.pyx":286
+ *                 raise TypeError('all args must be str or bytes')
+ * 
+ *         path = self.__args[0]             # <<<<<<<<<<<<<<
+ *         self.uv_opt_file = PyBytes_AsString(path)
+ *         self.uv_opt_args = self.__to_cstring_array(self.__args)
+ */
+  if (unlikely(__pyx_v_self->__pyx___args == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(4, 286, __pyx_L1_error)
+  }
+  __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_self->__pyx___args, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  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(4, 286, __pyx_L1_error)
+  __pyx_v_path = ((PyObject*)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/handles/process.pyx":287
+ * 
+ *         path = self.__args[0]
+ *         self.uv_opt_file = PyBytes_AsString(path)             # <<<<<<<<<<<<<<
+ *         self.uv_opt_args = self.__to_cstring_array(self.__args)
+ * 
+ */
+  __pyx_t_11 = PyBytes_AsString(__pyx_v_path); if (unlikely(__pyx_t_11 == ((char *)NULL))) __PYX_ERR(4, 287, __pyx_L1_error)
+  __pyx_v_self->uv_opt_file = __pyx_t_11;
+
+  /* "uvloop/handles/process.pyx":288
+ *         path = self.__args[0]
+ *         self.uv_opt_file = PyBytes_AsString(path)
+ *         self.uv_opt_args = self.__to_cstring_array(self.__args)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _init_env(self, dict env):
+ */
+  __pyx_t_3 = __pyx_v_self->__pyx___args;
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_v_self->uv_opt_args = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx___to_cstring_array(__pyx_v_self, ((PyObject*)__pyx_t_3));
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/process.pyx":270
+ *         self._init_files(_stdin, _stdout, _stderr)
+ * 
+ *     cdef _init_args(self, list args):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             bytes path
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess._init_args", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_path);
+  __Pyx_XDECREF(__pyx_v_arg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":290
+ *         self.uv_opt_args = self.__to_cstring_array(self.__args)
+ * 
+ *     cdef _init_env(self, dict env):             # <<<<<<<<<<<<<<
+ *         if env is not None and len(env):
+ *             self.__env = list()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_env(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_env) {
+  PyObject *__pyx_v_key = NULL;
+  PyObject *__pyx_v_val = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  Py_ssize_t __pyx_t_6;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init_env", 0);
+
+  /* "uvloop/handles/process.pyx":291
+ * 
+ *     cdef _init_env(self, dict env):
+ *         if env is not None and len(env):             # <<<<<<<<<<<<<<
+ *             self.__env = list()
+ *             for key in env:
+ */
+  __pyx_t_2 = (__pyx_v_env != ((PyObject*)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_env == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(4, 291, __pyx_L1_error)
+  }
+  __pyx_t_4 = PyDict_Size(__pyx_v_env); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(4, 291, __pyx_L1_error)
+  __pyx_t_3 = (__pyx_t_4 != 0);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":292
+ *     cdef _init_env(self, dict env):
+ *         if env is not None and len(env):
+ *             self.__env = list()             # <<<<<<<<<<<<<<
+ *             for key in env:
+ *                 val = env[key]
+ */
+    __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 292, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_5);
+    __Pyx_GOTREF(__pyx_v_self->__pyx___env);
+    __Pyx_DECREF(__pyx_v_self->__pyx___env);
+    __pyx_v_self->__pyx___env = ((PyObject*)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "uvloop/handles/process.pyx":293
+ *         if env is not None and len(env):
+ *             self.__env = list()
+ *             for key in env:             # <<<<<<<<<<<<<<
+ *                 val = env[key]
+ * 
+ */
+    __pyx_t_4 = 0;
+    if (unlikely(__pyx_v_env == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+      __PYX_ERR(4, 293, __pyx_L1_error)
+    }
+    __pyx_t_8 = __Pyx_dict_iterator(__pyx_v_env, 1, ((PyObject *)NULL), (&__pyx_t_6), (&__pyx_t_7)); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 293, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_XDECREF(__pyx_t_5);
+    __pyx_t_5 = __pyx_t_8;
+    __pyx_t_8 = 0;
+    while (1) {
+      __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_5, __pyx_t_6, &__pyx_t_4, &__pyx_t_8, NULL, NULL, __pyx_t_7);
+      if (unlikely(__pyx_t_9 == 0)) break;
+      if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(4, 293, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_8);
+      __pyx_t_8 = 0;
+
+      /* "uvloop/handles/process.pyx":294
+ *             self.__env = list()
+ *             for key in env:
+ *                 val = env[key]             # <<<<<<<<<<<<<<
+ * 
+ *                 if isinstance(key, str):
+ */
+      if (unlikely(__pyx_v_env == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(4, 294, __pyx_L1_error)
+      }
+      __pyx_t_8 = __Pyx_PyDict_GetItem(__pyx_v_env, __pyx_v_key); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 294, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_XDECREF_SET(__pyx_v_val, __pyx_t_8);
+      __pyx_t_8 = 0;
+
+      /* "uvloop/handles/process.pyx":296
+ *                 val = env[key]
+ * 
+ *                 if isinstance(key, str):             # <<<<<<<<<<<<<<
+ *                     key = PyUnicode_EncodeFSDefault(key)
+ *                 elif not isinstance(key, bytes):
+ */
+      __pyx_t_1 = PyUnicode_Check(__pyx_v_key); 
+      __pyx_t_3 = (__pyx_t_1 != 0);
+      if (__pyx_t_3) {
+
+        /* "uvloop/handles/process.pyx":297
+ * 
+ *                 if isinstance(key, str):
+ *                     key = PyUnicode_EncodeFSDefault(key)             # <<<<<<<<<<<<<<
+ *                 elif not isinstance(key, bytes):
+ *                     raise TypeError(
+ */
+        __pyx_t_8 = PyUnicode_EncodeFSDefault(__pyx_v_key); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 297, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF_SET(__pyx_v_key, __pyx_t_8);
+        __pyx_t_8 = 0;
+
+        /* "uvloop/handles/process.pyx":296
+ *                 val = env[key]
+ * 
+ *                 if isinstance(key, str):             # <<<<<<<<<<<<<<
+ *                     key = PyUnicode_EncodeFSDefault(key)
+ *                 elif not isinstance(key, bytes):
+ */
+        goto __pyx_L8;
+      }
+
+      /* "uvloop/handles/process.pyx":298
+ *                 if isinstance(key, str):
+ *                     key = PyUnicode_EncodeFSDefault(key)
+ *                 elif not isinstance(key, bytes):             # <<<<<<<<<<<<<<
+ *                     raise TypeError(
+ *                         'all environment vars must be bytes or str')
+ */
+      __pyx_t_3 = PyBytes_Check(__pyx_v_key); 
+      __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0);
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/handles/process.pyx":299
+ *                     key = PyUnicode_EncodeFSDefault(key)
+ *                 elif not isinstance(key, bytes):
+ *                     raise TypeError(             # <<<<<<<<<<<<<<
+ *                         'all environment vars must be bytes or str')
+ * 
+ */
+        __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__185, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 299, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __PYX_ERR(4, 299, __pyx_L1_error)
+
+        /* "uvloop/handles/process.pyx":298
+ *                 if isinstance(key, str):
+ *                     key = PyUnicode_EncodeFSDefault(key)
+ *                 elif not isinstance(key, bytes):             # <<<<<<<<<<<<<<
+ *                     raise TypeError(
+ *                         'all environment vars must be bytes or str')
+ */
+      }
+      __pyx_L8:;
+
+      /* "uvloop/handles/process.pyx":302
+ *                         'all environment vars must be bytes or str')
+ * 
+ *                 if isinstance(val, str):             # <<<<<<<<<<<<<<
+ *                     val = PyUnicode_EncodeFSDefault(val)
+ *                 elif not isinstance(val, bytes):
+ */
+      __pyx_t_1 = PyUnicode_Check(__pyx_v_val); 
+      __pyx_t_3 = (__pyx_t_1 != 0);
+      if (__pyx_t_3) {
+
+        /* "uvloop/handles/process.pyx":303
+ * 
+ *                 if isinstance(val, str):
+ *                     val = PyUnicode_EncodeFSDefault(val)             # <<<<<<<<<<<<<<
+ *                 elif not isinstance(val, bytes):
+ *                     raise TypeError(
+ */
+        __pyx_t_8 = PyUnicode_EncodeFSDefault(__pyx_v_val); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 303, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF_SET(__pyx_v_val, __pyx_t_8);
+        __pyx_t_8 = 0;
+
+        /* "uvloop/handles/process.pyx":302
+ *                         'all environment vars must be bytes or str')
+ * 
+ *                 if isinstance(val, str):             # <<<<<<<<<<<<<<
+ *                     val = PyUnicode_EncodeFSDefault(val)
+ *                 elif not isinstance(val, bytes):
+ */
+        goto __pyx_L9;
+      }
+
+      /* "uvloop/handles/process.pyx":304
+ *                 if isinstance(val, str):
+ *                     val = PyUnicode_EncodeFSDefault(val)
+ *                 elif not isinstance(val, bytes):             # <<<<<<<<<<<<<<
+ *                     raise TypeError(
+ *                         'all environment values must be bytes or str')
+ */
+      __pyx_t_3 = PyBytes_Check(__pyx_v_val); 
+      __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0);
+      if (unlikely(__pyx_t_1)) {
+
+        /* "uvloop/handles/process.pyx":305
+ *                     val = PyUnicode_EncodeFSDefault(val)
+ *                 elif not isinstance(val, bytes):
+ *                     raise TypeError(             # <<<<<<<<<<<<<<
+ *                         'all environment values must be bytes or str')
+ * 
+ */
+        __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__186, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 305, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __PYX_ERR(4, 305, __pyx_L1_error)
+
+        /* "uvloop/handles/process.pyx":304
+ *                 if isinstance(val, str):
+ *                     val = PyUnicode_EncodeFSDefault(val)
+ *                 elif not isinstance(val, bytes):             # <<<<<<<<<<<<<<
+ *                     raise TypeError(
+ *                         'all environment values must be bytes or str')
+ */
+      }
+      __pyx_L9:;
+
+      /* "uvloop/handles/process.pyx":308
+ *                         'all environment values must be bytes or str')
+ * 
+ *                 self.__env.append(key + b'=' + val)             # <<<<<<<<<<<<<<
+ * 
+ *             self.uv_opt_env = self.__to_cstring_array(self.__env)
+ */
+      if (unlikely(__pyx_v_self->__pyx___env == Py_None)) {
+        PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+        __PYX_ERR(4, 308, __pyx_L1_error)
+      }
+      __pyx_t_8 = PyNumber_Add(__pyx_v_key, __pyx_kp_b__187); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 308, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __pyx_t_10 = PyNumber_Add(__pyx_t_8, __pyx_v_val); if (unlikely(!__pyx_t_10)) __PYX_ERR(4, 308, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_self->__pyx___env, __pyx_t_10); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(4, 308, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/handles/process.pyx":310
+ *                 self.__env.append(key + b'=' + val)
+ * 
+ *             self.uv_opt_env = self.__to_cstring_array(self.__env)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self.__env = None
+ */
+    __pyx_t_5 = __pyx_v_self->__pyx___env;
+    __Pyx_INCREF(__pyx_t_5);
+    __pyx_v_self->uv_opt_env = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx___to_cstring_array(__pyx_v_self, ((PyObject*)__pyx_t_5));
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/handles/process.pyx":291
+ * 
+ *     cdef _init_env(self, dict env):
+ *         if env is not None and len(env):             # <<<<<<<<<<<<<<
+ *             self.__env = list()
+ *             for key in env:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/process.pyx":312
+ *             self.uv_opt_env = self.__to_cstring_array(self.__env)
+ *         else:
+ *             self.__env = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _init_files(self, _stdin, _stdout, _stderr):
+ */
+  /*else*/ {
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->__pyx___env);
+    __Pyx_DECREF(__pyx_v_self->__pyx___env);
+    __pyx_v_self->__pyx___env = ((PyObject*)Py_None);
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/process.pyx":290
+ *         self.uv_opt_args = self.__to_cstring_array(self.__args)
+ * 
+ *     cdef _init_env(self, dict env):             # <<<<<<<<<<<<<<
+ *         if env is not None and len(env):
+ *             self.__env = list()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess._init_env", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_key);
+  __Pyx_XDECREF(__pyx_v_val);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":314
+ *             self.__env = None
+ * 
+ *     cdef _init_files(self, _stdin, _stdout, _stderr):             # <<<<<<<<<<<<<<
+ *         self.options.stdio_count = 0
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_files(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v__stdin, CYTHON_UNUSED PyObject *__pyx_v__stdout, CYTHON_UNUSED PyObject *__pyx_v__stderr) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_init_files", 0);
+
+  /* "uvloop/handles/process.pyx":315
+ * 
+ *     cdef _init_files(self, _stdin, _stdout, _stderr):
+ *         self.options.stdio_count = 0             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _kill(self, int signum):
+ */
+  __pyx_v_self->options.stdio_count = 0;
+
+  /* "uvloop/handles/process.pyx":314
+ *             self.__env = None
+ * 
+ *     cdef _init_files(self, _stdin, _stdout, _stderr):             # <<<<<<<<<<<<<<
+ *         self.options.stdio_count = 0
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":317
+ *         self.options.stdio_count = 0
+ * 
+ *     cdef _kill(self, int signum):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         self._ensure_alive()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__kill(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, int __pyx_v_signum) {
+  int __pyx_v_err;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_kill", 0);
+
+  /* "uvloop/handles/process.pyx":319
+ *     cdef _kill(self, int signum):
+ *         cdef int err
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ *         err = uv.uv_process_kill(<uv.uv_process_t*>self._handle, signum)
+ *         if err < 0:
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 319, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":320
+ *         cdef int err
+ *         self._ensure_alive()
+ *         err = uv.uv_process_kill(<uv.uv_process_t*>self._handle, signum)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             raise convert_error(err)
+ */
+  __pyx_v_err = uv_process_kill(((uv_process_t *)__pyx_v_self->__pyx_base._handle), __pyx_v_signum);
+
+  /* "uvloop/handles/process.pyx":321
+ *         self._ensure_alive()
+ *         err = uv.uv_process_kill(<uv.uv_process_t*>self._handle, signum)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/process.pyx":322
+ *         err = uv.uv_process_kill(<uv.uv_process_t*>self._handle, signum)
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_exit(self, int64_t exit_status, int term_signal):
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 322, __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(4, 322, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":321
+ *         self._ensure_alive()
+ *         err = uv.uv_process_kill(<uv.uv_process_t*>self._handle, signum)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":317
+ *         self.options.stdio_count = 0
+ * 
+ *     cdef _kill(self, int signum):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         self._ensure_alive()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess._kill", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":324
+ *             raise convert_error(err)
+ * 
+ *     cdef _on_exit(self, int64_t exit_status, int term_signal):             # <<<<<<<<<<<<<<
+ *         if term_signal:
+ *             # From Python docs:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__on_exit(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, int64_t __pyx_v_exit_status, int __pyx_v_term_signal) {
+  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("_on_exit", 0);
+
+  /* "uvloop/handles/process.pyx":325
+ * 
+ *     cdef _on_exit(self, int64_t exit_status, int term_signal):
+ *         if term_signal:             # <<<<<<<<<<<<<<
+ *             # From Python docs:
+ *             #    A negative value -N indicates that the child was
+ */
+  __pyx_t_1 = (__pyx_v_term_signal != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":329
+ *             #    A negative value -N indicates that the child was
+ *             #    terminated by signal N (POSIX only).
+ *             self._returncode = -term_signal             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._returncode = exit_status
+ */
+    __pyx_t_2 = __Pyx_PyInt_From_int((-__pyx_v_term_signal)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 329, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_2);
+    __Pyx_GOTREF(__pyx_v_self->_returncode);
+    __Pyx_DECREF(__pyx_v_self->_returncode);
+    __pyx_v_self->_returncode = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/process.pyx":325
+ * 
+ *     cdef _on_exit(self, int64_t exit_status, int term_signal):
+ *         if term_signal:             # <<<<<<<<<<<<<<
+ *             # From Python docs:
+ *             #    A negative value -N indicates that the child was
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/process.pyx":331
+ *             self._returncode = -term_signal
+ *         else:
+ *             self._returncode = exit_status             # <<<<<<<<<<<<<<
+ * 
+ *         self._close()
+ */
+  /*else*/ {
+    __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_v_exit_status); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 331, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_2);
+    __Pyx_GOTREF(__pyx_v_self->_returncode);
+    __Pyx_DECREF(__pyx_v_self->_returncode);
+    __pyx_v_self->_returncode = __pyx_t_2;
+    __pyx_t_2 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/process.pyx":333
+ *             self._returncode = exit_status
+ * 
+ *         self._close()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _close(self):
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 333, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/process.pyx":324
+ *             raise convert_error(err)
+ * 
+ *     cdef _on_exit(self, int64_t exit_status, int term_signal):             # <<<<<<<<<<<<<<
+ *         if term_signal:
+ *             # From Python docs:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess._on_exit", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":335
+ *         self._close()
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         try:
+ *             if self._loop is not None:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__close(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  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("_close", 0);
+
+  /* "uvloop/handles/process.pyx":336
+ * 
+ *     cdef _close(self):
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self._loop is not None:
+ *                 self._loop._untrack_process(self)
+ */
+  /*try:*/ {
+
+    /* "uvloop/handles/process.pyx":337
+ *     cdef _close(self):
+ *         try:
+ *             if self._loop is not None:             # <<<<<<<<<<<<<<
+ *                 self._loop._untrack_process(self)
+ *         finally:
+ */
+    __pyx_t_1 = (((PyObject *)__pyx_v_self->__pyx_base._loop) != Py_None);
+    __pyx_t_2 = (__pyx_t_1 != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/handles/process.pyx":338
+ *         try:
+ *             if self._loop is not None:
+ *                 self._loop._untrack_process(self)             # <<<<<<<<<<<<<<
+ *         finally:
+ *             UVHandle._close(self)
+ */
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_base._loop->__pyx_vtab)->_untrack_process(__pyx_v_self->__pyx_base._loop, __pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 338, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/process.pyx":337
+ *     cdef _close(self):
+ *         try:
+ *             if self._loop is not None:             # <<<<<<<<<<<<<<
+ *                 self._loop._untrack_process(self)
+ *         finally:
+ */
+    }
+  }
+
+  /* "uvloop/handles/process.pyx":340
+ *                 self._loop._untrack_process(self)
+ *         finally:
+ *             UVHandle._close(self)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_3 = __pyx_f_6uvloop_4loop_8UVHandle__close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 340, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      goto __pyx_L5;
+    }
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __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_3); __pyx_t_3 = 0;
+      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_XGOTREF(__pyx_t_12);
+      __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
+      {
+        __pyx_t_3 = __pyx_f_6uvloop_4loop_8UVHandle__close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 340, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+      }
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __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_L8_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+      }
+      __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;
+      __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L5:;
+  }
+
+  /* "uvloop/handles/process.pyx":335
+ *         self._close()
+ * 
+ *     cdef _close(self):             # <<<<<<<<<<<<<<
+ *         try:
+ *             if self._loop is not None:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess._close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_9UVProcess_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_9UVProcess_4__reduce_cython__[] = "UVProcess.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_9UVProcess_5__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_6uvloop_4loop_9UVProcess_4__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_9UVProcess_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcess *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__188, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess.__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_6uvloop_4loop_9UVProcess_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_9UVProcess_6__setstate_cython__[] = "UVProcess.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_9UVProcess_7__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_6uvloop_4loop_9UVProcess_6__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_9UVProcess_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcess *__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);
+
+  /* "(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__189, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcess.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":351
+ * @cython.no_gc_clear
+ * cdef class UVProcessTransport(UVProcess):
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._exit_waiters = []
+ *         self._protocol = None
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_18UVProcessTransport_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_18UVProcessTransport_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport___cinit__(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_18UVProcessTransport___cinit__(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self) {
+  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);
+
+  /* "uvloop/handles/process.pyx":352
+ * cdef class UVProcessTransport(UVProcess):
+ *     def __cinit__(self):
+ *         self._exit_waiters = []             # <<<<<<<<<<<<<<
+ *         self._protocol = None
+ * 
+ */
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 352, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_exit_waiters);
+  __Pyx_DECREF(__pyx_v_self->_exit_waiters);
+  __pyx_v_self->_exit_waiters = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":353
+ *     def __cinit__(self):
+ *         self._exit_waiters = []
+ *         self._protocol = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._init_futs = []
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_protocol);
+  __Pyx_DECREF(__pyx_v_self->_protocol);
+  __pyx_v_self->_protocol = Py_None;
+
+  /* "uvloop/handles/process.pyx":355
+ *         self._protocol = None
+ * 
+ *         self._init_futs = []             # <<<<<<<<<<<<<<
+ *         self._pending_calls = []
+ *         self._stdio_ready = 0
+ */
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 355, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_init_futs);
+  __Pyx_DECREF(__pyx_v_self->_init_futs);
+  __pyx_v_self->_init_futs = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":356
+ * 
+ *         self._init_futs = []
+ *         self._pending_calls = []             # <<<<<<<<<<<<<<
+ *         self._stdio_ready = 0
+ * 
+ */
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 356, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_pending_calls);
+  __Pyx_DECREF(__pyx_v_self->_pending_calls);
+  __pyx_v_self->_pending_calls = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":357
+ *         self._init_futs = []
+ *         self._pending_calls = []
+ *         self._stdio_ready = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._stdin = self._stdout = self._stderr = None
+ */
+  __pyx_v_self->_stdio_ready = 0;
+
+  /* "uvloop/handles/process.pyx":359
+ *         self._stdio_ready = 0
+ * 
+ *         self._stdin = self._stdout = self._stderr = None             # <<<<<<<<<<<<<<
+ *         self.stdin_proto = self.stdout_proto = self.stderr_proto = None
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_stdin);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_stdin));
+  __pyx_v_self->_stdin = ((struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *)Py_None);
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_stdout);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_stdout));
+  __pyx_v_self->_stdout = ((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)Py_None);
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_stderr);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_stderr));
+  __pyx_v_self->_stderr = ((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)Py_None);
+
+  /* "uvloop/handles/process.pyx":360
+ * 
+ *         self._stdin = self._stdout = self._stderr = None
+ *         self.stdin_proto = self.stdout_proto = self.stderr_proto = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._finished = 0
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->stdin_proto);
+  __Pyx_DECREF(__pyx_v_self->stdin_proto);
+  __pyx_v_self->stdin_proto = Py_None;
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->stdout_proto);
+  __Pyx_DECREF(__pyx_v_self->stdout_proto);
+  __pyx_v_self->stdout_proto = Py_None;
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->stderr_proto);
+  __Pyx_DECREF(__pyx_v_self->stderr_proto);
+  __pyx_v_self->stderr_proto = Py_None;
+
+  /* "uvloop/handles/process.pyx":362
+ *         self.stdin_proto = self.stdout_proto = self.stderr_proto = None
+ * 
+ *         self._finished = 0             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_exit(self, int64_t exit_status, int term_signal):
+ */
+  __pyx_v_self->_finished = 0;
+
+  /* "uvloop/handles/process.pyx":351
+ * @cython.no_gc_clear
+ * cdef class UVProcessTransport(UVProcess):
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._exit_waiters = []
+ *         self._protocol = None
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":364
+ *         self._finished = 0
+ * 
+ *     cdef _on_exit(self, int64_t exit_status, int term_signal):             # <<<<<<<<<<<<<<
+ *         UVProcess._on_exit(self, exit_status, term_signal)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__on_exit(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int64_t __pyx_v_exit_status, int __pyx_v_term_signal) {
+  PyObject *__pyx_v_waiter = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  Py_ssize_t __pyx_t_7;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_exit", 0);
+
+  /* "uvloop/handles/process.pyx":365
+ * 
+ *     cdef _on_exit(self, int64_t exit_status, int term_signal):
+ *         UVProcess._on_exit(self, exit_status, term_signal)             # <<<<<<<<<<<<<<
+ * 
+ *         if self._stdio_ready:
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_9UVProcess__on_exit(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), __pyx_v_exit_status, __pyx_v_term_signal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 365, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":367
+ *         UVProcess._on_exit(self, exit_status, term_signal)
+ * 
+ *         if self._stdio_ready:             # <<<<<<<<<<<<<<
+ *             self._loop.call_soon(self._protocol.process_exited,
+ *                                  context=self.context)
+ */
+  __pyx_t_2 = (__pyx_v_self->_stdio_ready != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/process.pyx":368
+ * 
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.process_exited,             # <<<<<<<<<<<<<<
+ *                                  context=self.context)
+ *         else:
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop), __pyx_n_s_call_soon); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 368, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_n_s_process_exited); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 368, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 368, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/handles/process.pyx":369
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.process_exited,
+ *                                  context=self.context)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._pending_calls.append((_CALL_PROCESS_EXITED, None, None))
+ */
+    __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 369, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_context, __pyx_v_self->__pyx_base.__pyx_base.context) < 0) __PYX_ERR(4, 369, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":368
+ * 
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.process_exited,             # <<<<<<<<<<<<<<
+ *                                  context=self.context)
+ *         else:
+ */
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 368, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/handles/process.pyx":367
+ *         UVProcess._on_exit(self, exit_status, term_signal)
+ * 
+ *         if self._stdio_ready:             # <<<<<<<<<<<<<<
+ *             self._loop.call_soon(self._protocol.process_exited,
+ *                                  context=self.context)
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/process.pyx":371
+ *                                  context=self.context)
+ *         else:
+ *             self._pending_calls.append((_CALL_PROCESS_EXITED, None, None))             # <<<<<<<<<<<<<<
+ * 
+ *         self._try_finish()
+ */
+  /*else*/ {
+    if (unlikely(__pyx_v_self->_pending_calls == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+      __PYX_ERR(4, 371, __pyx_L1_error)
+    }
+    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_self->_pending_calls, __pyx_tuple__190); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(4, 371, __pyx_L1_error)
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/process.pyx":373
+ *             self._pending_calls.append((_CALL_PROCESS_EXITED, None, None))
+ * 
+ *         self._try_finish()             # <<<<<<<<<<<<<<
+ * 
+ *         for waiter in self._exit_waiters:
+ */
+  __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_try_finish(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 373, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/handles/process.pyx":375
+ *         self._try_finish()
+ * 
+ *         for waiter in self._exit_waiters:             # <<<<<<<<<<<<<<
+ *             if not waiter.cancelled():
+ *                 waiter.set_result(self._returncode)
+ */
+  if (unlikely(__pyx_v_self->_exit_waiters == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(4, 375, __pyx_L1_error)
+  }
+  __pyx_t_5 = __pyx_v_self->_exit_waiters; __Pyx_INCREF(__pyx_t_5); __pyx_t_7 = 0;
+  for (;;) {
+    if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_5)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_3 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_7); __Pyx_INCREF(__pyx_t_3); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(4, 375, __pyx_L1_error)
+    #else
+    __pyx_t_3 = PySequence_ITEM(__pyx_t_5, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 375, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_waiter, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/handles/process.pyx":376
+ * 
+ *         for waiter in self._exit_waiters:
+ *             if not waiter.cancelled():             # <<<<<<<<<<<<<<
+ *                 waiter.set_result(self._returncode)
+ *         self._exit_waiters.clear()
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 376, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_1 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 376, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(4, 376, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_8 = ((!__pyx_t_2) != 0);
+    if (__pyx_t_8) {
+
+      /* "uvloop/handles/process.pyx":377
+ *         for waiter in self._exit_waiters:
+ *             if not waiter.cancelled():
+ *                 waiter.set_result(self._returncode)             # <<<<<<<<<<<<<<
+ *         self._exit_waiters.clear()
+ * 
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 377, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_1 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+        if (likely(__pyx_t_1)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+          __Pyx_INCREF(__pyx_t_1);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_4, function);
+        }
+      }
+      __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_v_self->__pyx_base._returncode) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_self->__pyx_base._returncode);
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 377, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/process.pyx":376
+ * 
+ *         for waiter in self._exit_waiters:
+ *             if not waiter.cancelled():             # <<<<<<<<<<<<<<
+ *                 waiter.set_result(self._returncode)
+ *         self._exit_waiters.clear()
+ */
+    }
+
+    /* "uvloop/handles/process.pyx":375
+ *         self._try_finish()
+ * 
+ *         for waiter in self._exit_waiters:             # <<<<<<<<<<<<<<
+ *             if not waiter.cancelled():
+ *                 waiter.set_result(self._returncode)
+ */
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/handles/process.pyx":378
+ *             if not waiter.cancelled():
+ *                 waiter.set_result(self._returncode)
+ *         self._exit_waiters.clear()             # <<<<<<<<<<<<<<
+ * 
+ *         self._close()
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_exit_waiters, __pyx_n_s_clear); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/handles/process.pyx":380
+ *         self._exit_waiters.clear()
+ * 
+ *         self._close()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _check_proc(self):
+ */
+  __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 380, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/handles/process.pyx":364
+ *         self._finished = 0
+ * 
+ *     cdef _on_exit(self, int64_t exit_status, int term_signal):             # <<<<<<<<<<<<<<
+ *         UVProcess._on_exit(self, exit_status, term_signal)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._on_exit", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_waiter);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":382
+ *         self._close()
+ * 
+ *     cdef _check_proc(self):             # <<<<<<<<<<<<<<
+ *         if not self._is_alive() or self._returncode is not None:
+ *             raise ProcessLookupError()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__check_proc(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_check_proc", 0);
+
+  /* "uvloop/handles/process.pyx":383
+ * 
+ *     cdef _check_proc(self):
+ *         if not self._is_alive() or self._returncode is not None:             # <<<<<<<<<<<<<<
+ *             raise ProcessLookupError()
+ * 
+ */
+  __pyx_t_2 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)) != 0)) != 0);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_v_self->__pyx_base._returncode != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/process.pyx":384
+ *     cdef _check_proc(self):
+ *         if not self._is_alive() or self._returncode is not None:
+ *             raise ProcessLookupError()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _pipe_connection_lost(self, int fd, exc):
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ProcessLookupError); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 384, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 384, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __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(4, 384, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":383
+ * 
+ *     cdef _check_proc(self):
+ *         if not self._is_alive() or self._returncode is not None:             # <<<<<<<<<<<<<<
+ *             raise ProcessLookupError()
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":382
+ *         self._close()
+ * 
+ *     cdef _check_proc(self):             # <<<<<<<<<<<<<<
+ *         if not self._is_alive() or self._returncode is not None:
+ *             raise ProcessLookupError()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._check_proc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":386
+ *             raise ProcessLookupError()
+ * 
+ *     cdef _pipe_connection_lost(self, int fd, exc):             # <<<<<<<<<<<<<<
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.pipe_connection_lost, fd, exc,
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__pipe_connection_lost(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_fd, PyObject *__pyx_v_exc) {
+  PyObject *__pyx_r = NULL;
+  __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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_pipe_connection_lost", 0);
+
+  /* "uvloop/handles/process.pyx":387
+ * 
+ *     cdef _pipe_connection_lost(self, int fd, exc):
+ *         if self._stdio_ready:             # <<<<<<<<<<<<<<
+ *             self._loop.call_soon(self._protocol.pipe_connection_lost, fd, exc,
+ *                                  context=self.context)
+ */
+  __pyx_t_1 = (__pyx_v_self->_stdio_ready != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":388
+ *     cdef _pipe_connection_lost(self, int fd, exc):
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.pipe_connection_lost, fd, exc,             # <<<<<<<<<<<<<<
+ *                                  context=self.context)
+ *             self._try_finish()
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop), __pyx_n_s_call_soon); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 388, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_n_s_pipe_connection_lost); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 388, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 388, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 388, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+    __Pyx_INCREF(__pyx_v_exc);
+    __Pyx_GIVEREF(__pyx_v_exc);
+    PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_exc);
+    __pyx_t_3 = 0;
+    __pyx_t_4 = 0;
+
+    /* "uvloop/handles/process.pyx":389
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.pipe_connection_lost, fd, exc,
+ *                                  context=self.context)             # <<<<<<<<<<<<<<
+ *             self._try_finish()
+ *         else:
+ */
+    __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 389, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_context, __pyx_v_self->__pyx_base.__pyx_base.context) < 0) __PYX_ERR(4, 389, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":388
+ *     cdef _pipe_connection_lost(self, int fd, exc):
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.pipe_connection_lost, fd, exc,             # <<<<<<<<<<<<<<
+ *                                  context=self.context)
+ *             self._try_finish()
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 388, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __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;
+
+    /* "uvloop/handles/process.pyx":390
+ *             self._loop.call_soon(self._protocol.pipe_connection_lost, fd, exc,
+ *                                  context=self.context)
+ *             self._try_finish()             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._pending_calls.append((_CALL_PIPE_CONNECTION_LOST, fd, exc))
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_try_finish(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 390, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/process.pyx":387
+ * 
+ *     cdef _pipe_connection_lost(self, int fd, exc):
+ *         if self._stdio_ready:             # <<<<<<<<<<<<<<
+ *             self._loop.call_soon(self._protocol.pipe_connection_lost, fd, exc,
+ *                                  context=self.context)
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/process.pyx":392
+ *             self._try_finish()
+ *         else:
+ *             self._pending_calls.append((_CALL_PIPE_CONNECTION_LOST, fd, exc))             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _pipe_data_received(self, int fd, data):
+ */
+  /*else*/ {
+    if (unlikely(__pyx_v_self->_pending_calls == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+      __PYX_ERR(4, 392, __pyx_L1_error)
+    }
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 392, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 392, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx_int_1);
+    __Pyx_GIVEREF(__pyx_int_1);
+    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_1);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+    __Pyx_INCREF(__pyx_v_exc);
+    __Pyx_GIVEREF(__pyx_v_exc);
+    PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_exc);
+    __pyx_t_3 = 0;
+    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_self->_pending_calls, __pyx_t_4); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(4, 392, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/process.pyx":386
+ *             raise ProcessLookupError()
+ * 
+ *     cdef _pipe_connection_lost(self, int fd, exc):             # <<<<<<<<<<<<<<
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.pipe_connection_lost, fd, exc,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._pipe_connection_lost", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":394
+ *             self._pending_calls.append((_CALL_PIPE_CONNECTION_LOST, fd, exc))
+ * 
+ *     cdef _pipe_data_received(self, int fd, data):             # <<<<<<<<<<<<<<
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.pipe_data_received, fd, data,
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__pipe_data_received(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_fd, PyObject *__pyx_v_data) {
+  PyObject *__pyx_r = NULL;
+  __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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_pipe_data_received", 0);
+
+  /* "uvloop/handles/process.pyx":395
+ * 
+ *     cdef _pipe_data_received(self, int fd, data):
+ *         if self._stdio_ready:             # <<<<<<<<<<<<<<
+ *             self._loop.call_soon(self._protocol.pipe_data_received, fd, data,
+ *                                  context=self.context)
+ */
+  __pyx_t_1 = (__pyx_v_self->_stdio_ready != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":396
+ *     cdef _pipe_data_received(self, int fd, data):
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.pipe_data_received, fd, data,             # <<<<<<<<<<<<<<
+ *                                  context=self.context)
+ *         else:
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop), __pyx_n_s_call_soon); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 396, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_n_s_pipe_data_received); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 396, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 396, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 396, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+    __Pyx_INCREF(__pyx_v_data);
+    __Pyx_GIVEREF(__pyx_v_data);
+    PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_data);
+    __pyx_t_3 = 0;
+    __pyx_t_4 = 0;
+
+    /* "uvloop/handles/process.pyx":397
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.pipe_data_received, fd, data,
+ *                                  context=self.context)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._pending_calls.append((_CALL_PIPE_DATA_RECEIVED, fd, data))
+ */
+    __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 397, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_context, __pyx_v_self->__pyx_base.__pyx_base.context) < 0) __PYX_ERR(4, 397, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":396
+ *     cdef _pipe_data_received(self, int fd, data):
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.pipe_data_received, fd, data,             # <<<<<<<<<<<<<<
+ *                                  context=self.context)
+ *         else:
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 396, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __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;
+
+    /* "uvloop/handles/process.pyx":395
+ * 
+ *     cdef _pipe_data_received(self, int fd, data):
+ *         if self._stdio_ready:             # <<<<<<<<<<<<<<
+ *             self._loop.call_soon(self._protocol.pipe_data_received, fd, data,
+ *                                  context=self.context)
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/process.pyx":399
+ *                                  context=self.context)
+ *         else:
+ *             self._pending_calls.append((_CALL_PIPE_DATA_RECEIVED, fd, data))             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _file_redirect_stdio(self, int fd):
+ */
+  /*else*/ {
+    if (unlikely(__pyx_v_self->_pending_calls == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+      __PYX_ERR(4, 399, __pyx_L1_error)
+    }
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 399, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 399, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx_int_0);
+    __Pyx_GIVEREF(__pyx_int_0);
+    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_0);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+    __Pyx_INCREF(__pyx_v_data);
+    __Pyx_GIVEREF(__pyx_v_data);
+    PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_data);
+    __pyx_t_3 = 0;
+    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_self->_pending_calls, __pyx_t_4); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(4, 399, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/process.pyx":394
+ *             self._pending_calls.append((_CALL_PIPE_CONNECTION_LOST, fd, exc))
+ * 
+ *     cdef _pipe_data_received(self, int fd, data):             # <<<<<<<<<<<<<<
+ *         if self._stdio_ready:
+ *             self._loop.call_soon(self._protocol.pipe_data_received, fd, data,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._pipe_data_received", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":401
+ *             self._pending_calls.append((_CALL_PIPE_DATA_RECEIVED, fd, data))
+ * 
+ *     cdef _file_redirect_stdio(self, int fd):             # <<<<<<<<<<<<<<
+ *         fd = os_dup(fd)
+ *         os_set_inheritable(fd, True)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_redirect_stdio(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_fd) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = 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("_file_redirect_stdio", 0);
+
+  /* "uvloop/handles/process.pyx":402
+ * 
+ *     cdef _file_redirect_stdio(self, int fd):
+ *         fd = os_dup(fd)             # <<<<<<<<<<<<<<
+ *         os_set_inheritable(fd, True)
+ *         self._close_after_spawn(fd)
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 402, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_dup);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_os_dup; __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_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 402, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 402, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_fd = __pyx_t_5;
+
+  /* "uvloop/handles/process.pyx":403
+ *     cdef _file_redirect_stdio(self, int fd):
+ *         fd = os_dup(fd)
+ *         os_set_inheritable(fd, True)             # <<<<<<<<<<<<<<
+ *         self._close_after_spawn(fd)
+ *         return fd
+ */
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 403, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+  __pyx_t_2 = __pyx_v_6uvloop_4loop_os_set_inheritable; __pyx_t_4 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(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;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, Py_True};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 403, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, Py_True};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 403, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 403, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (__pyx_t_4) {
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_t_3);
+    __Pyx_INCREF(Py_True);
+    __Pyx_GIVEREF(Py_True);
+    PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, Py_True);
+    __pyx_t_3 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 403, __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_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":404
+ *         fd = os_dup(fd)
+ *         os_set_inheritable(fd, True)
+ *         self._close_after_spawn(fd)             # <<<<<<<<<<<<<<
+ *         return fd
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._close_after_spawn(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 404, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":405
+ *         os_set_inheritable(fd, True)
+ *         self._close_after_spawn(fd)
+ *         return fd             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _file_devnull(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 405, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":401
+ *             self._pending_calls.append((_CALL_PIPE_DATA_RECEIVED, fd, data))
+ * 
+ *     cdef _file_redirect_stdio(self, int fd):             # <<<<<<<<<<<<<<
+ *         fd = os_dup(fd)
+ *         os_set_inheritable(fd, True)
+ */
+
+  /* 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_6);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._file_redirect_stdio", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":407
+ *         return fd
+ * 
+ *     cdef _file_devnull(self):             # <<<<<<<<<<<<<<
+ *         dn = os_open(os_devnull, os_O_RDWR)
+ *         os_set_inheritable(dn, True)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_devnull(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self) {
+  PyObject *__pyx_v_dn = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = 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("_file_devnull", 0);
+
+  /* "uvloop/handles/process.pyx":408
+ * 
+ *     cdef _file_devnull(self):
+ *         dn = os_open(os_devnull, os_O_RDWR)             # <<<<<<<<<<<<<<
+ *         os_set_inheritable(dn, True)
+ *         self._close_after_spawn(dn)
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_open);
+  __pyx_t_2 = __pyx_v_6uvloop_4loop_os_open; __pyx_t_3 = NULL;
+  __pyx_t_4 = 0;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_4 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_6uvloop_4loop_os_devnull, __pyx_v_6uvloop_4loop_os_O_RDWR};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 408, __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[3] = {__pyx_t_3, __pyx_v_6uvloop_4loop_os_devnull, __pyx_v_6uvloop_4loop_os_O_RDWR};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 408, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  {
+    __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 408, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (__pyx_t_3) {
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+    }
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_devnull);
+    __Pyx_GIVEREF(__pyx_v_6uvloop_4loop_os_devnull);
+    PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_6uvloop_4loop_os_devnull);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_O_RDWR);
+    __Pyx_GIVEREF(__pyx_v_6uvloop_4loop_os_O_RDWR);
+    PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_6uvloop_4loop_os_O_RDWR);
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 408, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_dn = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":409
+ *     cdef _file_devnull(self):
+ *         dn = os_open(os_devnull, os_O_RDWR)
+ *         os_set_inheritable(dn, True)             # <<<<<<<<<<<<<<
+ *         self._close_after_spawn(dn)
+ *         return dn
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+  __pyx_t_2 = __pyx_v_6uvloop_4loop_os_set_inheritable; __pyx_t_5 = NULL;
+  __pyx_t_4 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_4 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_dn, Py_True};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 409, __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_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_dn, Py_True};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 409, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  {
+    __pyx_t_3 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 409, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__pyx_t_5) {
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5); __pyx_t_5 = NULL;
+    }
+    __Pyx_INCREF(__pyx_v_dn);
+    __Pyx_GIVEREF(__pyx_v_dn);
+    PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_4, __pyx_v_dn);
+    __Pyx_INCREF(Py_True);
+    __Pyx_GIVEREF(Py_True);
+    PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_4, Py_True);
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 409, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __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;
+
+  /* "uvloop/handles/process.pyx":410
+ *         dn = os_open(os_devnull, os_O_RDWR)
+ *         os_set_inheritable(dn, True)
+ *         self._close_after_spawn(dn)             # <<<<<<<<<<<<<<
+ *         return dn
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_dn); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 410, __pyx_L1_error)
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._close_after_spawn(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 410, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":411
+ *         os_set_inheritable(dn, True)
+ *         self._close_after_spawn(dn)
+ *         return dn             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _file_outpipe(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_dn);
+  __pyx_r = __pyx_v_dn;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":407
+ *         return fd
+ * 
+ *     cdef _file_devnull(self):             # <<<<<<<<<<<<<<
+ *         dn = os_open(os_devnull, os_O_RDWR)
+ *         os_set_inheritable(dn, True)
+ */
+
+  /* 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_5);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._file_devnull", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_dn);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":413
+ *         return dn
+ * 
+ *     cdef _file_outpipe(self):             # <<<<<<<<<<<<<<
+ *         r, w = __socketpair()
+ *         os_set_inheritable(w, True)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_outpipe(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self) {
+  PyObject *__pyx_v_r = NULL;
+  PyObject *__pyx_v_w = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_file_outpipe", 0);
+
+  /* "uvloop/handles/process.pyx":414
+ * 
+ *     cdef _file_outpipe(self):
+ *         r, w = __socketpair()             # <<<<<<<<<<<<<<
+ *         os_set_inheritable(w, True)
+ *         self._close_after_spawn(w)
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___socketpair(); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 414, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  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);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(4, 414, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_3);
+    #else
+    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 414, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 414, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __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(4, 414, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __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_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;
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(4, 414, __pyx_L1_error)
+    __pyx_t_5 = NULL;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L4_unpacking_done;
+    __pyx_L3_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(4, 414, __pyx_L1_error)
+    __pyx_L4_unpacking_done:;
+  }
+  __pyx_v_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  __pyx_v_w = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/handles/process.pyx":415
+ *     cdef _file_outpipe(self):
+ *         r, w = __socketpair()
+ *         os_set_inheritable(w, True)             # <<<<<<<<<<<<<<
+ *         self._close_after_spawn(w)
+ *         return r, w
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_os_set_inheritable; __pyx_t_2 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __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_2, __pyx_v_w, Py_True};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 415, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_w, Py_True};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 415, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  {
+    __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 415, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (__pyx_t_2) {
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+    }
+    __Pyx_INCREF(__pyx_v_w);
+    __Pyx_GIVEREF(__pyx_v_w);
+    PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, __pyx_v_w);
+    __Pyx_INCREF(Py_True);
+    __Pyx_GIVEREF(Py_True);
+    PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, Py_True);
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 415, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __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;
+
+  /* "uvloop/handles/process.pyx":416
+ *         r, w = __socketpair()
+ *         os_set_inheritable(w, True)
+ *         self._close_after_spawn(w)             # <<<<<<<<<<<<<<
+ *         return r, w
+ * 
+ */
+  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_w); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 416, __pyx_L1_error)
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._close_after_spawn(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 416, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":417
+ *         os_set_inheritable(w, True)
+ *         self._close_after_spawn(w)
+ *         return r, w             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _file_inpipe(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 417, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_v_r);
+  __Pyx_GIVEREF(__pyx_v_r);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_r);
+  __Pyx_INCREF(__pyx_v_w);
+  __Pyx_GIVEREF(__pyx_v_w);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_w);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":413
+ *         return dn
+ * 
+ *     cdef _file_outpipe(self):             # <<<<<<<<<<<<<<
+ *         r, w = __socketpair()
+ *         os_set_inheritable(w, True)
+ */
+
+  /* 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_AddTraceback("uvloop.loop.UVProcessTransport._file_outpipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_r);
+  __Pyx_XDECREF(__pyx_v_w);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":419
+ *         return r, w
+ * 
+ *     cdef _file_inpipe(self):             # <<<<<<<<<<<<<<
+ *         r, w = __socketpair()
+ *         os_set_inheritable(r, True)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_inpipe(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self) {
+  PyObject *__pyx_v_r = NULL;
+  PyObject *__pyx_v_w = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_file_inpipe", 0);
+
+  /* "uvloop/handles/process.pyx":420
+ * 
+ *     cdef _file_inpipe(self):
+ *         r, w = __socketpair()             # <<<<<<<<<<<<<<
+ *         os_set_inheritable(r, True)
+ *         self._close_after_spawn(r)
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___socketpair(); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 420, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  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);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(4, 420, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_3);
+    #else
+    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 420, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 420, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __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(4, 420, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __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_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;
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(4, 420, __pyx_L1_error)
+    __pyx_t_5 = NULL;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L4_unpacking_done;
+    __pyx_L3_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(4, 420, __pyx_L1_error)
+    __pyx_L4_unpacking_done:;
+  }
+  __pyx_v_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  __pyx_v_w = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/handles/process.pyx":421
+ *     cdef _file_inpipe(self):
+ *         r, w = __socketpair()
+ *         os_set_inheritable(r, True)             # <<<<<<<<<<<<<<
+ *         self._close_after_spawn(r)
+ *         return r, w
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_os_set_inheritable; __pyx_t_2 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __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_2, __pyx_v_r, Py_True};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 421, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_r, Py_True};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 421, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  {
+    __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 421, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (__pyx_t_2) {
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+    }
+    __Pyx_INCREF(__pyx_v_r);
+    __Pyx_GIVEREF(__pyx_v_r);
+    PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, __pyx_v_r);
+    __Pyx_INCREF(Py_True);
+    __Pyx_GIVEREF(Py_True);
+    PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, Py_True);
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 421, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __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;
+
+  /* "uvloop/handles/process.pyx":422
+ *         r, w = __socketpair()
+ *         os_set_inheritable(r, True)
+ *         self._close_after_spawn(r)             # <<<<<<<<<<<<<<
+ *         return r, w
+ * 
+ */
+  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_r); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 422, __pyx_L1_error)
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._close_after_spawn(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":423
+ *         os_set_inheritable(r, True)
+ *         self._close_after_spawn(r)
+ *         return r, w             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _init_files(self, _stdin, _stdout, _stderr):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 423, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_v_r);
+  __Pyx_GIVEREF(__pyx_v_r);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_r);
+  __Pyx_INCREF(__pyx_v_w);
+  __Pyx_GIVEREF(__pyx_v_w);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_w);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":419
+ *         return r, w
+ * 
+ *     cdef _file_inpipe(self):             # <<<<<<<<<<<<<<
+ *         r, w = __socketpair()
+ *         os_set_inheritable(r, True)
+ */
+
+  /* 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_AddTraceback("uvloop.loop.UVProcessTransport._file_inpipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_r);
+  __Pyx_XDECREF(__pyx_v_w);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":425
+ *         return r, w
+ * 
+ *     cdef _init_files(self, _stdin, _stdout, _stderr):             # <<<<<<<<<<<<<<
+ *         cdef uv.uv_stdio_container_t *iocnt
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__init_files(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr) {
+  uv_stdio_container_t *__pyx_v_iocnt;
+  PyObject *__pyx_v_io = NULL;
+  PyObject *__pyx_v_r = NULL;
+  PyObject *__pyx_v_w = NULL;
+  PyObject *__pyx_v_waiter = NULL;
+  PyObject *__pyx_v_newfd = NULL;
+  long __pyx_v_idx;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  uv_stdio_container_t *__pyx_t_2;
+  int __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)(PyObject *);
+  int __pyx_t_9;
+  int __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  long __pyx_t_12;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init_files", 0);
+
+  /* "uvloop/handles/process.pyx":428
+ *         cdef uv.uv_stdio_container_t *iocnt
+ * 
+ *         UVProcess._init_files(self, _stdin, _stdout, _stderr)             # <<<<<<<<<<<<<<
+ * 
+ *         io = [None, None, None]
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_9UVProcess__init_files(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), __pyx_v__stdin, __pyx_v__stdout, __pyx_v__stderr); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 428, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":430
+ *         UVProcess._init_files(self, _stdin, _stdout, _stderr)
+ * 
+ *         io = [None, None, None]             # <<<<<<<<<<<<<<
+ * 
+ *         self.options.stdio_count = 3
+ */
+  __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 430, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  PyList_SET_ITEM(__pyx_t_1, 0, Py_None);
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  PyList_SET_ITEM(__pyx_t_1, 1, Py_None);
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  PyList_SET_ITEM(__pyx_t_1, 2, Py_None);
+  __pyx_v_io = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":432
+ *         io = [None, None, None]
+ * 
+ *         self.options.stdio_count = 3             # <<<<<<<<<<<<<<
+ *         self.options.stdio = self.iocnt
+ * 
+ */
+  __pyx_v_self->__pyx_base.options.stdio_count = 3;
+
+  /* "uvloop/handles/process.pyx":433
+ * 
+ *         self.options.stdio_count = 3
+ *         self.options.stdio = self.iocnt             # <<<<<<<<<<<<<<
+ * 
+ *         if _stdin is not None:
+ */
+  __pyx_t_2 = __pyx_v_self->__pyx_base.iocnt;
+  __pyx_v_self->__pyx_base.options.stdio = __pyx_t_2;
+
+  /* "uvloop/handles/process.pyx":435
+ *         self.options.stdio = self.iocnt
+ * 
+ *         if _stdin is not None:             # <<<<<<<<<<<<<<
+ *             if _stdin == subprocess_PIPE:
+ *                 r, w = self._file_inpipe()
+ */
+  __pyx_t_3 = (__pyx_v__stdin != Py_None);
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  if (__pyx_t_4) {
+
+    /* "uvloop/handles/process.pyx":436
+ * 
+ *         if _stdin is not None:
+ *             if _stdin == subprocess_PIPE:             # <<<<<<<<<<<<<<
+ *                 r, w = self._file_inpipe()
+ *                 io[0] = r
+ */
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_PIPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 436, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = PyObject_RichCompare(__pyx_v__stdin, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 436, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(4, 436, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (__pyx_t_4) {
+
+      /* "uvloop/handles/process.pyx":437
+ *         if _stdin is not None:
+ *             if _stdin == subprocess_PIPE:
+ *                 r, w = self._file_inpipe()             # <<<<<<<<<<<<<<
+ *                 io[0] = r
+ * 
+ */
+      __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_inpipe(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 437, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
+        PyObject* sequence = __pyx_t_5;
+        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+        if (unlikely(size != 2)) {
+          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+          __PYX_ERR(4, 437, __pyx_L1_error)
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        if (likely(PyTuple_CheckExact(sequence))) {
+          __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); 
+          __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); 
+        } else {
+          __pyx_t_1 = PyList_GET_ITEM(sequence, 0); 
+          __pyx_t_6 = PyList_GET_ITEM(sequence, 1); 
+        }
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_6);
+        #else
+        __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 437, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 437, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      } else {
+        Py_ssize_t index = -1;
+        __pyx_t_7 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 437, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
+        index = 0; __pyx_t_1 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_1)) goto __pyx_L5_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_1);
+        index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_6);
+        if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(4, 437, __pyx_L1_error)
+        __pyx_t_8 = NULL;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L6_unpacking_done;
+        __pyx_L5_unpacking_failed:;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __pyx_t_8 = NULL;
+        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+        __PYX_ERR(4, 437, __pyx_L1_error)
+        __pyx_L6_unpacking_done:;
+      }
+      __pyx_v_r = __pyx_t_1;
+      __pyx_t_1 = 0;
+      __pyx_v_w = __pyx_t_6;
+      __pyx_t_6 = 0;
+
+      /* "uvloop/handles/process.pyx":438
+ *             if _stdin == subprocess_PIPE:
+ *                 r, w = self._file_inpipe()
+ *                 io[0] = r             # <<<<<<<<<<<<<<
+ * 
+ *                 self.stdin_proto = WriteSubprocessPipeProto(self, 0)
+ */
+      if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 0, __pyx_v_r, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 438, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":440
+ *                 io[0] = r
+ * 
+ *                 self.stdin_proto = WriteSubprocessPipeProto(self, 0)             # <<<<<<<<<<<<<<
+ *                 waiter = self._loop._new_future()
+ *                 self._stdin = WriteUnixTransport.new(
+ */
+      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_WriteSubprocessPipeProto); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 440, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_1 = NULL;
+      __pyx_t_9 = 0;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_1)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_1);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+          __pyx_t_9 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_1, ((PyObject *)__pyx_v_self), __pyx_int_0};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 440, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_1, ((PyObject *)__pyx_v_self), __pyx_int_0};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 440, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_7 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 440, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        if (__pyx_t_1) {
+          __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __pyx_t_1 = NULL;
+        }
+        __Pyx_INCREF(((PyObject *)__pyx_v_self));
+        __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+        PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_9, ((PyObject *)__pyx_v_self));
+        __Pyx_INCREF(__pyx_int_0);
+        __Pyx_GIVEREF(__pyx_int_0);
+        PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_9, __pyx_int_0);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 440, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GIVEREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_v_self->stdin_proto);
+      __Pyx_DECREF(__pyx_v_self->stdin_proto);
+      __pyx_v_self->stdin_proto = __pyx_t_5;
+      __pyx_t_5 = 0;
+
+      /* "uvloop/handles/process.pyx":441
+ * 
+ *                 self.stdin_proto = WriteSubprocessPipeProto(self, 0)
+ *                 waiter = self._loop._new_future()             # <<<<<<<<<<<<<<
+ *                 self._stdin = WriteUnixTransport.new(
+ *                     self._loop, self.stdin_proto, None, waiter)
+ */
+      __pyx_t_5 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self->__pyx_base.__pyx_base._loop); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 441, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_v_waiter = __pyx_t_5;
+      __pyx_t_5 = 0;
+
+      /* "uvloop/handles/process.pyx":443
+ *                 waiter = self._loop._new_future()
+ *                 self._stdin = WriteUnixTransport.new(
+ *                     self._loop, self.stdin_proto, None, waiter)             # <<<<<<<<<<<<<<
+ *                 self._init_futs.append(waiter)
+ *                 self._stdin._open(w)
+ */
+      __pyx_t_5 = ((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_t_6 = __pyx_v_self->stdin_proto;
+      __Pyx_INCREF(__pyx_t_6);
+
+      /* "uvloop/handles/process.pyx":442
+ *                 self.stdin_proto = WriteSubprocessPipeProto(self, 0)
+ *                 waiter = self._loop._new_future()
+ *                 self._stdin = WriteUnixTransport.new(             # <<<<<<<<<<<<<<
+ *                     self._loop, self.stdin_proto, None, waiter)
+ *                 self._init_futs.append(waiter)
+ */
+      __pyx_t_7 = ((PyObject *)__pyx_f_6uvloop_4loop_18WriteUnixTransport_new(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_5), __pyx_t_6, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_v_waiter)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 442, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GIVEREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_v_self->_stdin);
+      __Pyx_DECREF(((PyObject *)__pyx_v_self->_stdin));
+      __pyx_v_self->_stdin = ((struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *)__pyx_t_7);
+      __pyx_t_7 = 0;
+
+      /* "uvloop/handles/process.pyx":444
+ *                 self._stdin = WriteUnixTransport.new(
+ *                     self._loop, self.stdin_proto, None, waiter)
+ *                 self._init_futs.append(waiter)             # <<<<<<<<<<<<<<
+ *                 self._stdin._open(w)
+ *                 self._stdin._init_protocol()
+ */
+      if (unlikely(__pyx_v_self->_init_futs == Py_None)) {
+        PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+        __PYX_ERR(4, 444, __pyx_L1_error)
+      }
+      __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_self->_init_futs, __pyx_v_waiter); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(4, 444, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":445
+ *                     self._loop, self.stdin_proto, None, waiter)
+ *                 self._init_futs.append(waiter)
+ *                 self._stdin._open(w)             # <<<<<<<<<<<<<<
+ *                 self._stdin._init_protocol()
+ *             elif _stdin == subprocess_DEVNULL:
+ */
+      __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_w); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 445, __pyx_L1_error)
+      __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_v_self->_stdin->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self->_stdin), __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 445, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/handles/process.pyx":446
+ *                 self._init_futs.append(waiter)
+ *                 self._stdin._open(w)
+ *                 self._stdin._init_protocol()             # <<<<<<<<<<<<<<
+ *             elif _stdin == subprocess_DEVNULL:
+ *                 io[0] = self._file_devnull()
+ */
+      __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_v_self->_stdin->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->_stdin)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 446, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/handles/process.pyx":436
+ * 
+ *         if _stdin is not None:
+ *             if _stdin == subprocess_PIPE:             # <<<<<<<<<<<<<<
+ *                 r, w = self._file_inpipe()
+ *                 io[0] = r
+ */
+      goto __pyx_L4;
+    }
+
+    /* "uvloop/handles/process.pyx":447
+ *                 self._stdin._open(w)
+ *                 self._stdin._init_protocol()
+ *             elif _stdin == subprocess_DEVNULL:             # <<<<<<<<<<<<<<
+ *                 io[0] = self._file_devnull()
+ *             elif _stdout == subprocess_STDOUT:
+ */
+    __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_DEVNULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 447, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_6 = PyObject_RichCompare(__pyx_v__stdin, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 447, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(4, 447, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (__pyx_t_4) {
+
+      /* "uvloop/handles/process.pyx":448
+ *                 self._stdin._init_protocol()
+ *             elif _stdin == subprocess_DEVNULL:
+ *                 io[0] = self._file_devnull()             # <<<<<<<<<<<<<<
+ *             elif _stdout == subprocess_STDOUT:
+ *                 raise ValueError(
+ */
+      __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_devnull(__pyx_v_self); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 448, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 0, __pyx_t_6, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 448, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/handles/process.pyx":447
+ *                 self._stdin._open(w)
+ *                 self._stdin._init_protocol()
+ *             elif _stdin == subprocess_DEVNULL:             # <<<<<<<<<<<<<<
+ *                 io[0] = self._file_devnull()
+ *             elif _stdout == subprocess_STDOUT:
+ */
+      goto __pyx_L4;
+    }
+
+    /* "uvloop/handles/process.pyx":449
+ *             elif _stdin == subprocess_DEVNULL:
+ *                 io[0] = self._file_devnull()
+ *             elif _stdout == subprocess_STDOUT:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'subprocess.STDOUT is supported only by stderr parameter')
+ */
+    __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_STDOUT); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 449, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = PyObject_RichCompare(__pyx_v__stdout, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 449, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(4, 449, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(__pyx_t_4)) {
+
+      /* "uvloop/handles/process.pyx":450
+ *                 io[0] = self._file_devnull()
+ *             elif _stdout == subprocess_STDOUT:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'subprocess.STDOUT is supported only by stderr parameter')
+ *             else:
+ */
+      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__191, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 450, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __PYX_ERR(4, 450, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":449
+ *             elif _stdin == subprocess_DEVNULL:
+ *                 io[0] = self._file_devnull()
+ *             elif _stdout == subprocess_STDOUT:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'subprocess.STDOUT is supported only by stderr parameter')
+ */
+    }
+
+    /* "uvloop/handles/process.pyx":453
+ *                     'subprocess.STDOUT is supported only by stderr parameter')
+ *             else:
+ *                 io[0] = self._file_redirect_stdio(_stdin)             # <<<<<<<<<<<<<<
+ *         else:
+ *             io[0] = self._file_redirect_stdio(0)
+ */
+    /*else*/ {
+      __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v__stdin); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 453, __pyx_L1_error)
+      __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_redirect_stdio(__pyx_v_self, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 453, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 0, __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 453, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    }
+    __pyx_L4:;
+
+    /* "uvloop/handles/process.pyx":435
+ *         self.options.stdio = self.iocnt
+ * 
+ *         if _stdin is not None:             # <<<<<<<<<<<<<<
+ *             if _stdin == subprocess_PIPE:
+ *                 r, w = self._file_inpipe()
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/process.pyx":455
+ *                 io[0] = self._file_redirect_stdio(_stdin)
+ *         else:
+ *             io[0] = self._file_redirect_stdio(0)             # <<<<<<<<<<<<<<
+ * 
+ *         if _stdout is not None:
+ */
+  /*else*/ {
+    __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_redirect_stdio(__pyx_v_self, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 455, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 0, __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 455, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/process.pyx":457
+ *             io[0] = self._file_redirect_stdio(0)
+ * 
+ *         if _stdout is not None:             # <<<<<<<<<<<<<<
+ *             if _stdout == subprocess_PIPE:
+ *                 # We can't use UV_CREATE_PIPE here, since 'stderr' might be
+ */
+  __pyx_t_4 = (__pyx_v__stdout != Py_None);
+  __pyx_t_3 = (__pyx_t_4 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/process.pyx":458
+ * 
+ *         if _stdout is not None:
+ *             if _stdout == subprocess_PIPE:             # <<<<<<<<<<<<<<
+ *                 # We can't use UV_CREATE_PIPE here, since 'stderr' might be
+ *                 # set to 'subprocess.STDOUT', and there is no way to
+ */
+    __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_PIPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 458, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_6 = PyObject_RichCompare(__pyx_v__stdout, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 458, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(4, 458, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (__pyx_t_3) {
+
+      /* "uvloop/handles/process.pyx":465
+ *                 # stderr manually.
+ * 
+ *                 r, w = self._file_outpipe()             # <<<<<<<<<<<<<<
+ *                 io[1] = w
+ * 
+ */
+      __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_outpipe(__pyx_v_self); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 465, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) {
+        PyObject* sequence = __pyx_t_6;
+        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+        if (unlikely(size != 2)) {
+          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+          __PYX_ERR(4, 465, __pyx_L1_error)
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        if (likely(PyTuple_CheckExact(sequence))) {
+          __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); 
+          __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); 
+        } else {
+          __pyx_t_7 = PyList_GET_ITEM(sequence, 0); 
+          __pyx_t_5 = PyList_GET_ITEM(sequence, 1); 
+        }
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_5);
+        #else
+        __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 465, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 465, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      } else {
+        Py_ssize_t index = -1;
+        __pyx_t_1 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 465, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __pyx_t_8 = Py_TYPE(__pyx_t_1)->tp_iternext;
+        index = 0; __pyx_t_7 = __pyx_t_8(__pyx_t_1); if (unlikely(!__pyx_t_7)) goto __pyx_L9_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_7);
+        index = 1; __pyx_t_5 = __pyx_t_8(__pyx_t_1); if (unlikely(!__pyx_t_5)) goto __pyx_L9_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_5);
+        if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_1), 2) < 0) __PYX_ERR(4, 465, __pyx_L1_error)
+        __pyx_t_8 = NULL;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        goto __pyx_L10_unpacking_done;
+        __pyx_L9_unpacking_failed:;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __pyx_t_8 = NULL;
+        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+        __PYX_ERR(4, 465, __pyx_L1_error)
+        __pyx_L10_unpacking_done:;
+      }
+      __Pyx_XDECREF_SET(__pyx_v_r, __pyx_t_7);
+      __pyx_t_7 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_w, __pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/handles/process.pyx":466
+ * 
+ *                 r, w = self._file_outpipe()
+ *                 io[1] = w             # <<<<<<<<<<<<<<
+ * 
+ *                 self.stdout_proto = ReadSubprocessPipeProto(self, 1)
+ */
+      if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 1, __pyx_v_w, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 466, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":468
+ *                 io[1] = w
+ * 
+ *                 self.stdout_proto = ReadSubprocessPipeProto(self, 1)             # <<<<<<<<<<<<<<
+ *                 waiter = self._loop._new_future()
+ *                 self._stdout = ReadUnixTransport.new(
+ */
+      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_ReadSubprocessPipeProto); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 468, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_7 = NULL;
+      __pyx_t_9 = 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)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+          __pyx_t_9 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_7, ((PyObject *)__pyx_v_self), __pyx_int_1};
+        __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 468, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_6);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_7, ((PyObject *)__pyx_v_self), __pyx_int_1};
+        __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 468, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_6);
+      } else
+      #endif
+      {
+        __pyx_t_1 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 468, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        if (__pyx_t_7) {
+          __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        }
+        __Pyx_INCREF(((PyObject *)__pyx_v_self));
+        __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+        PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_9, ((PyObject *)__pyx_v_self));
+        __Pyx_INCREF(__pyx_int_1);
+        __Pyx_GIVEREF(__pyx_int_1);
+        PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_9, __pyx_int_1);
+        __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 468, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GIVEREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_v_self->stdout_proto);
+      __Pyx_DECREF(__pyx_v_self->stdout_proto);
+      __pyx_v_self->stdout_proto = __pyx_t_6;
+      __pyx_t_6 = 0;
+
+      /* "uvloop/handles/process.pyx":469
+ * 
+ *                 self.stdout_proto = ReadSubprocessPipeProto(self, 1)
+ *                 waiter = self._loop._new_future()             # <<<<<<<<<<<<<<
+ *                 self._stdout = ReadUnixTransport.new(
+ *                     self._loop, self.stdout_proto, None, waiter)
+ */
+      __pyx_t_6 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self->__pyx_base.__pyx_base._loop); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 469, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_XDECREF_SET(__pyx_v_waiter, __pyx_t_6);
+      __pyx_t_6 = 0;
+
+      /* "uvloop/handles/process.pyx":471
+ *                 waiter = self._loop._new_future()
+ *                 self._stdout = ReadUnixTransport.new(
+ *                     self._loop, self.stdout_proto, None, waiter)             # <<<<<<<<<<<<<<
+ *                 self._init_futs.append(waiter)
+ *                 self._stdout._open(r)
+ */
+      __pyx_t_6 = ((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_t_5 = __pyx_v_self->stdout_proto;
+      __Pyx_INCREF(__pyx_t_5);
+
+      /* "uvloop/handles/process.pyx":470
+ *                 self.stdout_proto = ReadSubprocessPipeProto(self, 1)
+ *                 waiter = self._loop._new_future()
+ *                 self._stdout = ReadUnixTransport.new(             # <<<<<<<<<<<<<<
+ *                     self._loop, self.stdout_proto, None, waiter)
+ *                 self._init_futs.append(waiter)
+ */
+      __pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_17ReadUnixTransport_new(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_6), __pyx_t_5, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_v_waiter)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 470, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GIVEREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_v_self->_stdout);
+      __Pyx_DECREF(((PyObject *)__pyx_v_self->_stdout));
+      __pyx_v_self->_stdout = ((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_t_1);
+      __pyx_t_1 = 0;
+
+      /* "uvloop/handles/process.pyx":472
+ *                 self._stdout = ReadUnixTransport.new(
+ *                     self._loop, self.stdout_proto, None, waiter)
+ *                 self._init_futs.append(waiter)             # <<<<<<<<<<<<<<
+ *                 self._stdout._open(r)
+ *                 self._stdout._init_protocol()
+ */
+      if (unlikely(__pyx_v_self->_init_futs == Py_None)) {
+        PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+        __PYX_ERR(4, 472, __pyx_L1_error)
+      }
+      __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_self->_init_futs, __pyx_v_waiter); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(4, 472, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":473
+ *                     self._loop, self.stdout_proto, None, waiter)
+ *                 self._init_futs.append(waiter)
+ *                 self._stdout._open(r)             # <<<<<<<<<<<<<<
+ *                 self._stdout._init_protocol()
+ *             elif _stdout == subprocess_DEVNULL:
+ */
+      __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_r); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 473, __pyx_L1_error)
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self->_stdout->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self->_stdout), __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 473, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/process.pyx":474
+ *                 self._init_futs.append(waiter)
+ *                 self._stdout._open(r)
+ *                 self._stdout._init_protocol()             # <<<<<<<<<<<<<<
+ *             elif _stdout == subprocess_DEVNULL:
+ *                 io[1] = self._file_devnull()
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self->_stdout->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->_stdout)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 474, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/process.pyx":458
+ * 
+ *         if _stdout is not None:
+ *             if _stdout == subprocess_PIPE:             # <<<<<<<<<<<<<<
+ *                 # We can't use UV_CREATE_PIPE here, since 'stderr' might be
+ *                 # set to 'subprocess.STDOUT', and there is no way to
+ */
+      goto __pyx_L8;
+    }
+
+    /* "uvloop/handles/process.pyx":475
+ *                 self._stdout._open(r)
+ *                 self._stdout._init_protocol()
+ *             elif _stdout == subprocess_DEVNULL:             # <<<<<<<<<<<<<<
+ *                 io[1] = self._file_devnull()
+ *             elif _stdout == subprocess_STDOUT:
+ */
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_DEVNULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 475, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = PyObject_RichCompare(__pyx_v__stdout, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 475, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(4, 475, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (__pyx_t_3) {
+
+      /* "uvloop/handles/process.pyx":476
+ *                 self._stdout._init_protocol()
+ *             elif _stdout == subprocess_DEVNULL:
+ *                 io[1] = self._file_devnull()             # <<<<<<<<<<<<<<
+ *             elif _stdout == subprocess_STDOUT:
+ *                 raise ValueError(
+ */
+      __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_devnull(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 476, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 1, __pyx_t_5, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 476, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+      /* "uvloop/handles/process.pyx":475
+ *                 self._stdout._open(r)
+ *                 self._stdout._init_protocol()
+ *             elif _stdout == subprocess_DEVNULL:             # <<<<<<<<<<<<<<
+ *                 io[1] = self._file_devnull()
+ *             elif _stdout == subprocess_STDOUT:
+ */
+      goto __pyx_L8;
+    }
+
+    /* "uvloop/handles/process.pyx":477
+ *             elif _stdout == subprocess_DEVNULL:
+ *                 io[1] = self._file_devnull()
+ *             elif _stdout == subprocess_STDOUT:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'subprocess.STDOUT is supported only by stderr parameter')
+ */
+    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_STDOUT); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 477, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_1 = PyObject_RichCompare(__pyx_v__stdout, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 477, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(4, 477, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (unlikely(__pyx_t_3)) {
+
+      /* "uvloop/handles/process.pyx":478
+ *                 io[1] = self._file_devnull()
+ *             elif _stdout == subprocess_STDOUT:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'subprocess.STDOUT is supported only by stderr parameter')
+ *             else:
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__191, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 478, __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(4, 478, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":477
+ *             elif _stdout == subprocess_DEVNULL:
+ *                 io[1] = self._file_devnull()
+ *             elif _stdout == subprocess_STDOUT:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     'subprocess.STDOUT is supported only by stderr parameter')
+ */
+    }
+
+    /* "uvloop/handles/process.pyx":481
+ *                     'subprocess.STDOUT is supported only by stderr parameter')
+ *             else:
+ *                 io[1] = self._file_redirect_stdio(_stdout)             # <<<<<<<<<<<<<<
+ *         else:
+ *             io[1] = self._file_redirect_stdio(1)
+ */
+    /*else*/ {
+      __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v__stdout); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 481, __pyx_L1_error)
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_redirect_stdio(__pyx_v_self, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 481, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 1, __pyx_t_1, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 481, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    }
+    __pyx_L8:;
+
+    /* "uvloop/handles/process.pyx":457
+ *             io[0] = self._file_redirect_stdio(0)
+ * 
+ *         if _stdout is not None:             # <<<<<<<<<<<<<<
+ *             if _stdout == subprocess_PIPE:
+ *                 # We can't use UV_CREATE_PIPE here, since 'stderr' might be
+ */
+    goto __pyx_L7;
+  }
+
+  /* "uvloop/handles/process.pyx":483
+ *                 io[1] = self._file_redirect_stdio(_stdout)
+ *         else:
+ *             io[1] = self._file_redirect_stdio(1)             # <<<<<<<<<<<<<<
+ * 
+ *         if _stderr is not None:
+ */
+  /*else*/ {
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_redirect_stdio(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 483, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 1, __pyx_t_1, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 483, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
+  __pyx_L7:;
+
+  /* "uvloop/handles/process.pyx":485
+ *             io[1] = self._file_redirect_stdio(1)
+ * 
+ *         if _stderr is not None:             # <<<<<<<<<<<<<<
+ *             if _stderr == subprocess_PIPE:
+ *                 r, w = self._file_outpipe()
+ */
+  __pyx_t_3 = (__pyx_v__stderr != Py_None);
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  if (__pyx_t_4) {
+
+    /* "uvloop/handles/process.pyx":486
+ * 
+ *         if _stderr is not None:
+ *             if _stderr == subprocess_PIPE:             # <<<<<<<<<<<<<<
+ *                 r, w = self._file_outpipe()
+ *                 io[2] = w
+ */
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_PIPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 486, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = PyObject_RichCompare(__pyx_v__stderr, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 486, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(4, 486, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (__pyx_t_4) {
+
+      /* "uvloop/handles/process.pyx":487
+ *         if _stderr is not None:
+ *             if _stderr == subprocess_PIPE:
+ *                 r, w = self._file_outpipe()             # <<<<<<<<<<<<<<
+ *                 io[2] = w
+ * 
+ */
+      __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_outpipe(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 487, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
+        PyObject* sequence = __pyx_t_5;
+        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+        if (unlikely(size != 2)) {
+          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+          __PYX_ERR(4, 487, __pyx_L1_error)
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        if (likely(PyTuple_CheckExact(sequence))) {
+          __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); 
+          __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); 
+        } else {
+          __pyx_t_1 = PyList_GET_ITEM(sequence, 0); 
+          __pyx_t_6 = PyList_GET_ITEM(sequence, 1); 
+        }
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_6);
+        #else
+        __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 487, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 487, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      } else {
+        Py_ssize_t index = -1;
+        __pyx_t_7 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 487, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
+        index = 0; __pyx_t_1 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_1)) goto __pyx_L13_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_1);
+        index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L13_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_6);
+        if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(4, 487, __pyx_L1_error)
+        __pyx_t_8 = NULL;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L14_unpacking_done;
+        __pyx_L13_unpacking_failed:;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __pyx_t_8 = NULL;
+        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+        __PYX_ERR(4, 487, __pyx_L1_error)
+        __pyx_L14_unpacking_done:;
+      }
+      __Pyx_XDECREF_SET(__pyx_v_r, __pyx_t_1);
+      __pyx_t_1 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_w, __pyx_t_6);
+      __pyx_t_6 = 0;
+
+      /* "uvloop/handles/process.pyx":488
+ *             if _stderr == subprocess_PIPE:
+ *                 r, w = self._file_outpipe()
+ *                 io[2] = w             # <<<<<<<<<<<<<<
+ * 
+ *                 self.stderr_proto = ReadSubprocessPipeProto(self, 2)
+ */
+      if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 2, __pyx_v_w, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 488, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":490
+ *                 io[2] = w
+ * 
+ *                 self.stderr_proto = ReadSubprocessPipeProto(self, 2)             # <<<<<<<<<<<<<<
+ *                 waiter = self._loop._new_future()
+ *                 self._stderr = ReadUnixTransport.new(
+ */
+      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ReadSubprocessPipeProto); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 490, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_1 = NULL;
+      __pyx_t_9 = 0;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_1)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_1);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+          __pyx_t_9 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_1, ((PyObject *)__pyx_v_self), __pyx_int_2};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 490, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_1, ((PyObject *)__pyx_v_self), __pyx_int_2};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 490, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_7 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 490, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        if (__pyx_t_1) {
+          __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __pyx_t_1 = NULL;
+        }
+        __Pyx_INCREF(((PyObject *)__pyx_v_self));
+        __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+        PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_9, ((PyObject *)__pyx_v_self));
+        __Pyx_INCREF(__pyx_int_2);
+        __Pyx_GIVEREF(__pyx_int_2);
+        PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_9, __pyx_int_2);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 490, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GIVEREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_v_self->stderr_proto);
+      __Pyx_DECREF(__pyx_v_self->stderr_proto);
+      __pyx_v_self->stderr_proto = __pyx_t_5;
+      __pyx_t_5 = 0;
+
+      /* "uvloop/handles/process.pyx":491
+ * 
+ *                 self.stderr_proto = ReadSubprocessPipeProto(self, 2)
+ *                 waiter = self._loop._new_future()             # <<<<<<<<<<<<<<
+ *                 self._stderr = ReadUnixTransport.new(
+ *                     self._loop, self.stderr_proto, None, waiter)
+ */
+      __pyx_t_5 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self->__pyx_base.__pyx_base._loop); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 491, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_XDECREF_SET(__pyx_v_waiter, __pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/handles/process.pyx":493
+ *                 waiter = self._loop._new_future()
+ *                 self._stderr = ReadUnixTransport.new(
+ *                     self._loop, self.stderr_proto, None, waiter)             # <<<<<<<<<<<<<<
+ *                 self._init_futs.append(waiter)
+ *                 self._stderr._open(r)
+ */
+      __pyx_t_5 = ((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_t_6 = __pyx_v_self->stderr_proto;
+      __Pyx_INCREF(__pyx_t_6);
+
+      /* "uvloop/handles/process.pyx":492
+ *                 self.stderr_proto = ReadSubprocessPipeProto(self, 2)
+ *                 waiter = self._loop._new_future()
+ *                 self._stderr = ReadUnixTransport.new(             # <<<<<<<<<<<<<<
+ *                     self._loop, self.stderr_proto, None, waiter)
+ *                 self._init_futs.append(waiter)
+ */
+      __pyx_t_7 = ((PyObject *)__pyx_f_6uvloop_4loop_17ReadUnixTransport_new(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_5), __pyx_t_6, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_v_waiter)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 492, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GIVEREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_v_self->_stderr);
+      __Pyx_DECREF(((PyObject *)__pyx_v_self->_stderr));
+      __pyx_v_self->_stderr = ((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_t_7);
+      __pyx_t_7 = 0;
+
+      /* "uvloop/handles/process.pyx":494
+ *                 self._stderr = ReadUnixTransport.new(
+ *                     self._loop, self.stderr_proto, None, waiter)
+ *                 self._init_futs.append(waiter)             # <<<<<<<<<<<<<<
+ *                 self._stderr._open(r)
+ *                 self._stderr._init_protocol()
+ */
+      if (unlikely(__pyx_v_self->_init_futs == Py_None)) {
+        PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+        __PYX_ERR(4, 494, __pyx_L1_error)
+      }
+      __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_self->_init_futs, __pyx_v_waiter); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(4, 494, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":495
+ *                     self._loop, self.stderr_proto, None, waiter)
+ *                 self._init_futs.append(waiter)
+ *                 self._stderr._open(r)             # <<<<<<<<<<<<<<
+ *                 self._stderr._init_protocol()
+ *             elif _stderr == subprocess_STDOUT:
+ */
+      __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_r); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 495, __pyx_L1_error)
+      __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self->_stderr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self->_stderr), __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 495, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/handles/process.pyx":496
+ *                 self._init_futs.append(waiter)
+ *                 self._stderr._open(r)
+ *                 self._stderr._init_protocol()             # <<<<<<<<<<<<<<
+ *             elif _stderr == subprocess_STDOUT:
+ *                 if io[1] is None:
+ */
+      __pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_v_self->_stderr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self->_stderr)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 496, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/handles/process.pyx":486
+ * 
+ *         if _stderr is not None:
+ *             if _stderr == subprocess_PIPE:             # <<<<<<<<<<<<<<
+ *                 r, w = self._file_outpipe()
+ *                 io[2] = w
+ */
+      goto __pyx_L12;
+    }
+
+    /* "uvloop/handles/process.pyx":497
+ *                 self._stderr._open(r)
+ *                 self._stderr._init_protocol()
+ *             elif _stderr == subprocess_STDOUT:             # <<<<<<<<<<<<<<
+ *                 if io[1] is None:
+ *                     # shouldn't ever happen
+ */
+    __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_STDOUT); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 497, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_6 = PyObject_RichCompare(__pyx_v__stderr, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 497, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(4, 497, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (__pyx_t_4) {
+
+      /* "uvloop/handles/process.pyx":498
+ *                 self._stderr._init_protocol()
+ *             elif _stderr == subprocess_STDOUT:
+ *                 if io[1] is None:             # <<<<<<<<<<<<<<
+ *                     # shouldn't ever happen
+ *                     raise RuntimeError('cannot apply subprocess.STDOUT')
+ */
+      __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_io, 1, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 498, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_4 = (__pyx_t_6 == Py_None);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __pyx_t_3 = (__pyx_t_4 != 0);
+      if (unlikely(__pyx_t_3)) {
+
+        /* "uvloop/handles/process.pyx":500
+ *                 if io[1] is None:
+ *                     # shouldn't ever happen
+ *                     raise RuntimeError('cannot apply subprocess.STDOUT')             # <<<<<<<<<<<<<<
+ * 
+ *                 newfd = os_dup(io[1])
+ */
+        __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__192, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 500, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __PYX_ERR(4, 500, __pyx_L1_error)
+
+        /* "uvloop/handles/process.pyx":498
+ *                 self._stderr._init_protocol()
+ *             elif _stderr == subprocess_STDOUT:
+ *                 if io[1] is None:             # <<<<<<<<<<<<<<
+ *                     # shouldn't ever happen
+ *                     raise RuntimeError('cannot apply subprocess.STDOUT')
+ */
+      }
+
+      /* "uvloop/handles/process.pyx":502
+ *                     raise RuntimeError('cannot apply subprocess.STDOUT')
+ * 
+ *                 newfd = os_dup(io[1])             # <<<<<<<<<<<<<<
+ *                 os_set_inheritable(newfd, True)
+ *                 self._close_after_spawn(newfd)
+ */
+      __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_io, 1, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 502, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_dup);
+      __pyx_t_5 = __pyx_v_6uvloop_4loop_os_dup; __pyx_t_1 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_1)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_1);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_6 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_7);
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 502, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_v_newfd = __pyx_t_6;
+      __pyx_t_6 = 0;
+
+      /* "uvloop/handles/process.pyx":503
+ * 
+ *                 newfd = os_dup(io[1])
+ *                 os_set_inheritable(newfd, True)             # <<<<<<<<<<<<<<
+ *                 self._close_after_spawn(newfd)
+ *                 io[2] = newfd
+ */
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+      __pyx_t_5 = __pyx_v_6uvloop_4loop_os_set_inheritable; __pyx_t_7 = NULL;
+      __pyx_t_9 = 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)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+          __pyx_t_9 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_newfd, Py_True};
+        __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 503, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_6);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_newfd, Py_True};
+        __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 503, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_6);
+      } else
+      #endif
+      {
+        __pyx_t_1 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 503, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        if (__pyx_t_7) {
+          __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        }
+        __Pyx_INCREF(__pyx_v_newfd);
+        __Pyx_GIVEREF(__pyx_v_newfd);
+        PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_9, __pyx_v_newfd);
+        __Pyx_INCREF(Py_True);
+        __Pyx_GIVEREF(Py_True);
+        PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_9, Py_True);
+        __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 503, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/handles/process.pyx":504
+ *                 newfd = os_dup(io[1])
+ *                 os_set_inheritable(newfd, True)
+ *                 self._close_after_spawn(newfd)             # <<<<<<<<<<<<<<
+ *                 io[2] = newfd
+ *             elif _stderr == subprocess_DEVNULL:
+ */
+      __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_newfd); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 504, __pyx_L1_error)
+      __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._close_after_spawn(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 504, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/handles/process.pyx":505
+ *                 os_set_inheritable(newfd, True)
+ *                 self._close_after_spawn(newfd)
+ *                 io[2] = newfd             # <<<<<<<<<<<<<<
+ *             elif _stderr == subprocess_DEVNULL:
+ *                 io[2] = self._file_devnull()
+ */
+      if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 2, __pyx_v_newfd, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 505, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":497
+ *                 self._stderr._open(r)
+ *                 self._stderr._init_protocol()
+ *             elif _stderr == subprocess_STDOUT:             # <<<<<<<<<<<<<<
+ *                 if io[1] is None:
+ *                     # shouldn't ever happen
+ */
+      goto __pyx_L12;
+    }
+
+    /* "uvloop/handles/process.pyx":506
+ *                 self._close_after_spawn(newfd)
+ *                 io[2] = newfd
+ *             elif _stderr == subprocess_DEVNULL:             # <<<<<<<<<<<<<<
+ *                 io[2] = self._file_devnull()
+ *             else:
+ */
+    __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_DEVNULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 506, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_5 = PyObject_RichCompare(__pyx_v__stderr, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 506, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(4, 506, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (__pyx_t_3) {
+
+      /* "uvloop/handles/process.pyx":507
+ *                 io[2] = newfd
+ *             elif _stderr == subprocess_DEVNULL:
+ *                 io[2] = self._file_devnull()             # <<<<<<<<<<<<<<
+ *             else:
+ *                 io[2] = self._file_redirect_stdio(_stderr)
+ */
+      __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_devnull(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 507, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 2, __pyx_t_5, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 507, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+      /* "uvloop/handles/process.pyx":506
+ *                 self._close_after_spawn(newfd)
+ *                 io[2] = newfd
+ *             elif _stderr == subprocess_DEVNULL:             # <<<<<<<<<<<<<<
+ *                 io[2] = self._file_devnull()
+ *             else:
+ */
+      goto __pyx_L12;
+    }
+
+    /* "uvloop/handles/process.pyx":509
+ *                 io[2] = self._file_devnull()
+ *             else:
+ *                 io[2] = self._file_redirect_stdio(_stderr)             # <<<<<<<<<<<<<<
+ *         else:
+ *             io[2] = self._file_redirect_stdio(2)
+ */
+    /*else*/ {
+      __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v__stderr); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 509, __pyx_L1_error)
+      __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_redirect_stdio(__pyx_v_self, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 509, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 2, __pyx_t_5, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 509, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+    __pyx_L12:;
+
+    /* "uvloop/handles/process.pyx":485
+ *             io[1] = self._file_redirect_stdio(1)
+ * 
+ *         if _stderr is not None:             # <<<<<<<<<<<<<<
+ *             if _stderr == subprocess_PIPE:
+ *                 r, w = self._file_outpipe()
+ */
+    goto __pyx_L11;
+  }
+
+  /* "uvloop/handles/process.pyx":511
+ *                 io[2] = self._file_redirect_stdio(_stderr)
+ *         else:
+ *             io[2] = self._file_redirect_stdio(2)             # <<<<<<<<<<<<<<
+ * 
+ *         assert len(io) == 3
+ */
+  /*else*/ {
+    __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_file_redirect_stdio(__pyx_v_self, 2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 511, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(__Pyx_SetItemInt(__pyx_v_io, 2, __pyx_t_5, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(4, 511, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+  __pyx_L11:;
+
+  /* "uvloop/handles/process.pyx":513
+ *             io[2] = self._file_redirect_stdio(2)
+ * 
+ *         assert len(io) == 3             # <<<<<<<<<<<<<<
+ *         for idx in range(3):
+ *             iocnt = &self.iocnt[idx]
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    __pyx_t_11 = PyList_GET_SIZE(__pyx_v_io); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(4, 513, __pyx_L1_error)
+    if (unlikely(!((__pyx_t_11 == 3) != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(4, 513, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "uvloop/handles/process.pyx":514
+ * 
+ *         assert len(io) == 3
+ *         for idx in range(3):             # <<<<<<<<<<<<<<
+ *             iocnt = &self.iocnt[idx]
+ *             if io[idx] is not None:
+ */
+  for (__pyx_t_12 = 0; __pyx_t_12 < 3; __pyx_t_12+=1) {
+    __pyx_v_idx = __pyx_t_12;
+
+    /* "uvloop/handles/process.pyx":515
+ *         assert len(io) == 3
+ *         for idx in range(3):
+ *             iocnt = &self.iocnt[idx]             # <<<<<<<<<<<<<<
+ *             if io[idx] is not None:
+ *                 iocnt.flags = uv.UV_INHERIT_FD
+ */
+    __pyx_v_iocnt = (&(__pyx_v_self->__pyx_base.iocnt[__pyx_v_idx]));
+
+    /* "uvloop/handles/process.pyx":516
+ *         for idx in range(3):
+ *             iocnt = &self.iocnt[idx]
+ *             if io[idx] is not None:             # <<<<<<<<<<<<<<
+ *                 iocnt.flags = uv.UV_INHERIT_FD
+ *                 iocnt.data.fd = io[idx]
+ */
+    __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_io, __pyx_v_idx, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 516, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = (__pyx_t_5 != Py_None);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_4 = (__pyx_t_3 != 0);
+    if (__pyx_t_4) {
+
+      /* "uvloop/handles/process.pyx":517
+ *             iocnt = &self.iocnt[idx]
+ *             if io[idx] is not None:
+ *                 iocnt.flags = uv.UV_INHERIT_FD             # <<<<<<<<<<<<<<
+ *                 iocnt.data.fd = io[idx]
+ *             else:
+ */
+      __pyx_v_iocnt->flags = UV_INHERIT_FD;
+
+      /* "uvloop/handles/process.pyx":518
+ *             if io[idx] is not None:
+ *                 iocnt.flags = uv.UV_INHERIT_FD
+ *                 iocnt.data.fd = io[idx]             # <<<<<<<<<<<<<<
+ *             else:
+ *                 iocnt.flags = uv.UV_IGNORE
+ */
+      __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_io, __pyx_v_idx, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 518, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 518, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_v_iocnt->data.fd = __pyx_t_9;
+
+      /* "uvloop/handles/process.pyx":516
+ *         for idx in range(3):
+ *             iocnt = &self.iocnt[idx]
+ *             if io[idx] is not None:             # <<<<<<<<<<<<<<
+ *                 iocnt.flags = uv.UV_INHERIT_FD
+ *                 iocnt.data.fd = io[idx]
+ */
+      goto __pyx_L18;
+    }
+
+    /* "uvloop/handles/process.pyx":520
+ *                 iocnt.data.fd = io[idx]
+ *             else:
+ *                 iocnt.flags = uv.UV_IGNORE             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _call_connection_made(self, waiter):
+ */
+    /*else*/ {
+      __pyx_v_iocnt->flags = UV_IGNORE;
+    }
+    __pyx_L18:;
+  }
+
+  /* "uvloop/handles/process.pyx":425
+ *         return r, w
+ * 
+ *     cdef _init_files(self, _stdin, _stdout, _stderr):             # <<<<<<<<<<<<<<
+ *         cdef uv.uv_stdio_container_t *iocnt
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._init_files", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_io);
+  __Pyx_XDECREF(__pyx_v_r);
+  __Pyx_XDECREF(__pyx_v_w);
+  __Pyx_XDECREF(__pyx_v_waiter);
+  __Pyx_XDECREF(__pyx_v_newfd);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":522
+ *                 iocnt.flags = uv.UV_IGNORE
+ * 
+ *     cdef _call_connection_made(self, waiter):             # <<<<<<<<<<<<<<
+ *         try:
+ *             # we're always called in the right context, so just call the user's
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__call_connection_made(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_waiter) {
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_v_pending_calls = NULL;
+  PyObject *__pyx_v_type = NULL;
+  PyObject *__pyx_v_fd = NULL;
+  PyObject *__pyx_v_arg = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_t_14;
+  char const *__pyx_t_15;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  Py_ssize_t __pyx_t_22;
+  PyObject *(*__pyx_t_23)(PyObject *);
+  PyObject *(*__pyx_t_24)(PyObject *);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_call_connection_made", 0);
+
+  /* "uvloop/handles/process.pyx":523
+ * 
+ *     cdef _call_connection_made(self, waiter):
+ *         try:             # <<<<<<<<<<<<<<
+ *             # we're always called in the right context, so just call the user's
+ *             self._protocol.connection_made(self)
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/handles/process.pyx":525
+ *         try:
+ *             # we're always called in the right context, so just call the user's
+ *             self._protocol.connection_made(self)             # <<<<<<<<<<<<<<
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_n_s_connection_made); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 525, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __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_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_5, ((PyObject *)__pyx_v_self));
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 525, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/handles/process.pyx":523
+ * 
+ *     cdef _call_connection_made(self, waiter):
+ *         try:             # <<<<<<<<<<<<<<
+ *             # we're always called in the right context, so just call the user's
+ *             self._protocol.connection_made(self)
+ */
+    }
+
+    /* "uvloop/handles/process.pyx":534
+ *                 raise
+ *         else:
+ *             if waiter is not None and not waiter.cancelled():             # <<<<<<<<<<<<<<
+ *                 waiter.set_result(True)
+ * 
+ */
+    /*else:*/ {
+      __pyx_t_8 = (__pyx_v_waiter != Py_None);
+      __pyx_t_9 = (__pyx_t_8 != 0);
+      if (__pyx_t_9) {
+      } else {
+        __pyx_t_7 = __pyx_t_9;
+        goto __pyx_L10_bool_binop_done;
+      }
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 534, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __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_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_4 = (__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_4)) __PYX_ERR(4, 534, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(4, 534, __pyx_L5_except_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_8 = ((!__pyx_t_9) != 0);
+      __pyx_t_7 = __pyx_t_8;
+      __pyx_L10_bool_binop_done:;
+      if (__pyx_t_7) {
+
+        /* "uvloop/handles/process.pyx":535
+ *         else:
+ *             if waiter is not None and not waiter.cancelled():
+ *                 waiter.set_result(True)             # <<<<<<<<<<<<<<
+ * 
+ *         self._stdio_ready = 1
+ */
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 535, __pyx_L5_except_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __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_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_5, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, Py_True) : __Pyx_PyObject_CallOneArg(__pyx_t_5, Py_True);
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 535, __pyx_L5_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/handles/process.pyx":534
+ *                 raise
+ *         else:
+ *             if waiter is not None and not waiter.cancelled():             # <<<<<<<<<<<<<<
+ *                 waiter.set_result(True)
+ * 
+ */
+      }
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/handles/process.pyx":526
+ *             # we're always called in the right context, so just call the user's
+ *             self._protocol.connection_made(self)
+ *         except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *             raise
+ *         except BaseException as ex:
+ */
+    __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+    if (__pyx_t_10) {
+      __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._call_connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(4, 526, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+
+      /* "uvloop/handles/process.pyx":527
+ *             self._protocol.connection_made(self)
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise             # <<<<<<<<<<<<<<
+ *         except BaseException as ex:
+ *             if waiter is not None and not waiter.cancelled():
+ */
+      __Pyx_GIVEREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; 
+      __PYX_ERR(4, 527, __pyx_L5_except_error)
+    }
+
+    /* "uvloop/handles/process.pyx":528
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             if waiter is not None and not waiter.cancelled():
+ *                 waiter.set_exception(ex)
+ */
+    __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_10) {
+      __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._call_connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(4, 528, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_v_ex = __pyx_t_5;
+      /*try:*/ {
+
+        /* "uvloop/handles/process.pyx":529
+ *             raise
+ *         except BaseException as ex:
+ *             if waiter is not None and not waiter.cancelled():             # <<<<<<<<<<<<<<
+ *                 waiter.set_exception(ex)
+ *             else:
+ */
+        __pyx_t_8 = (__pyx_v_waiter != Py_None);
+        __pyx_t_9 = (__pyx_t_8 != 0);
+        if (__pyx_t_9) {
+        } else {
+          __pyx_t_7 = __pyx_t_9;
+          goto __pyx_L22_bool_binop_done;
+        }
+        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_12)) __PYX_ERR(4, 529, __pyx_L19_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __pyx_t_13 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) {
+          __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_12);
+          if (likely(__pyx_t_13)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
+            __Pyx_INCREF(__pyx_t_13);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_12, function);
+          }
+        }
+        __pyx_t_11 = (__pyx_t_13) ? __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_13) : __Pyx_PyObject_CallNoArg(__pyx_t_12);
+        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+        if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 529, __pyx_L19_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(4, 529, __pyx_L19_error)
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __pyx_t_8 = ((!__pyx_t_9) != 0);
+        __pyx_t_7 = __pyx_t_8;
+        __pyx_L22_bool_binop_done:;
+        if (likely(__pyx_t_7)) {
+
+          /* "uvloop/handles/process.pyx":530
+ *         except BaseException as ex:
+ *             if waiter is not None and not waiter.cancelled():
+ *                 waiter.set_exception(ex)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise
+ */
+          __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_12)) __PYX_ERR(4, 530, __pyx_L19_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          __pyx_t_13 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) {
+            __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_12);
+            if (likely(__pyx_t_13)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
+              __Pyx_INCREF(__pyx_t_13);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_12, function);
+            }
+          }
+          __pyx_t_11 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_12, __pyx_t_13, __pyx_v_ex) : __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_v_ex);
+          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+          if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 530, __pyx_L19_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+
+          /* "uvloop/handles/process.pyx":529
+ *             raise
+ *         except BaseException as ex:
+ *             if waiter is not None and not waiter.cancelled():             # <<<<<<<<<<<<<<
+ *                 waiter.set_exception(ex)
+ *             else:
+ */
+          goto __pyx_L21;
+        }
+
+        /* "uvloop/handles/process.pyx":532
+ *                 waiter.set_exception(ex)
+ *             else:
+ *                 raise             # <<<<<<<<<<<<<<
+ *         else:
+ *             if waiter is not None and not waiter.cancelled():
+ */
+        /*else*/ {
+          __Pyx_GIVEREF(__pyx_t_6);
+          __Pyx_GIVEREF(__pyx_t_5);
+          __Pyx_XGIVEREF(__pyx_t_4);
+          __Pyx_ErrRestoreWithState(__pyx_t_6, __pyx_t_5, __pyx_t_4);
+          __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; 
+          __PYX_ERR(4, 532, __pyx_L19_error)
+        }
+        __pyx_L21:;
+      }
+
+      /* "uvloop/handles/process.pyx":528
+ *         except (KeyboardInterrupt, SystemExit):
+ *             raise
+ *         except BaseException as ex:             # <<<<<<<<<<<<<<
+ *             if waiter is not None and not waiter.cancelled():
+ *                 waiter.set_exception(ex)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L20;
+        }
+        __pyx_L19_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_20);
+          __Pyx_XGOTREF(__pyx_t_21);
+          __pyx_t_10 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_XGIVEREF(__pyx_t_21);
+            __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
+          }
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __Pyx_XGIVEREF(__pyx_t_18);
+          __Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+          __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
+          __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
+          goto __pyx_L5_except_error;
+        }
+        __pyx_L20:;
+      }
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/handles/process.pyx":523
+ * 
+ *     cdef _call_connection_made(self, waiter):
+ *         try:             # <<<<<<<<<<<<<<
+ *             # we're always called in the right context, so just call the user's
+ *             self._protocol.connection_made(self)
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/handles/process.pyx":537
+ *                 waiter.set_result(True)
+ * 
+ *         self._stdio_ready = 1             # <<<<<<<<<<<<<<
+ *         if self._pending_calls:
+ *             pending_calls = self._pending_calls.copy()
+ */
+  __pyx_v_self->_stdio_ready = 1;
+
+  /* "uvloop/handles/process.pyx":538
+ * 
+ *         self._stdio_ready = 1
+ *         if self._pending_calls:             # <<<<<<<<<<<<<<
+ *             pending_calls = self._pending_calls.copy()
+ *             self._pending_calls.clear()
+ */
+  __pyx_t_7 = (__pyx_v_self->_pending_calls != Py_None)&&(PyList_GET_SIZE(__pyx_v_self->_pending_calls) != 0);
+  if (__pyx_t_7) {
+
+    /* "uvloop/handles/process.pyx":539
+ *         self._stdio_ready = 1
+ *         if self._pending_calls:
+ *             pending_calls = self._pending_calls.copy()             # <<<<<<<<<<<<<<
+ *             self._pending_calls.clear()
+ *             for (type, fd, arg) in pending_calls:
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_pending_calls, __pyx_n_s_copy); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 539, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_4 = (__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_4)) __PYX_ERR(4, 539, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_v_pending_calls = __pyx_t_4;
+    __pyx_t_4 = 0;
+
+    /* "uvloop/handles/process.pyx":540
+ *         if self._pending_calls:
+ *             pending_calls = self._pending_calls.copy()
+ *             self._pending_calls.clear()             # <<<<<<<<<<<<<<
+ *             for (type, fd, arg) in pending_calls:
+ *                 if type == _CALL_PIPE_CONNECTION_LOST:
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_pending_calls, __pyx_n_s_clear); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 540, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_4 = (__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_4)) __PYX_ERR(4, 540, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/handles/process.pyx":541
+ *             pending_calls = self._pending_calls.copy()
+ *             self._pending_calls.clear()
+ *             for (type, fd, arg) in pending_calls:             # <<<<<<<<<<<<<<
+ *                 if type == _CALL_PIPE_CONNECTION_LOST:
+ *                     self._pipe_connection_lost(fd, arg)
+ */
+    if (likely(PyList_CheckExact(__pyx_v_pending_calls)) || PyTuple_CheckExact(__pyx_v_pending_calls)) {
+      __pyx_t_4 = __pyx_v_pending_calls; __Pyx_INCREF(__pyx_t_4); __pyx_t_22 = 0;
+      __pyx_t_23 = NULL;
+    } else {
+      __pyx_t_22 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_pending_calls); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 541, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_23 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_23)) __PYX_ERR(4, 541, __pyx_L1_error)
+    }
+    for (;;) {
+      if (likely(!__pyx_t_23)) {
+        if (likely(PyList_CheckExact(__pyx_t_4))) {
+          if (__pyx_t_22 >= PyList_GET_SIZE(__pyx_t_4)) break;
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_5 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_22); __Pyx_INCREF(__pyx_t_5); __pyx_t_22++; if (unlikely(0 < 0)) __PYX_ERR(4, 541, __pyx_L1_error)
+          #else
+          __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_22); __pyx_t_22++; if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 541, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          #endif
+        } else {
+          if (__pyx_t_22 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_22); __Pyx_INCREF(__pyx_t_5); __pyx_t_22++; if (unlikely(0 < 0)) __PYX_ERR(4, 541, __pyx_L1_error)
+          #else
+          __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_22); __pyx_t_22++; if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 541, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          #endif
+        }
+      } else {
+        __pyx_t_5 = __pyx_t_23(__pyx_t_4);
+        if (unlikely(!__pyx_t_5)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+            else __PYX_ERR(4, 541, __pyx_L1_error)
+          }
+          break;
+        }
+        __Pyx_GOTREF(__pyx_t_5);
+      }
+      if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
+        PyObject* sequence = __pyx_t_5;
+        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+        if (unlikely(size != 3)) {
+          if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+          __PYX_ERR(4, 541, __pyx_L1_error)
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        if (likely(PyTuple_CheckExact(sequence))) {
+          __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); 
+          __pyx_t_11 = PyTuple_GET_ITEM(sequence, 1); 
+          __pyx_t_12 = PyTuple_GET_ITEM(sequence, 2); 
+        } else {
+          __pyx_t_6 = PyList_GET_ITEM(sequence, 0); 
+          __pyx_t_11 = PyList_GET_ITEM(sequence, 1); 
+          __pyx_t_12 = PyList_GET_ITEM(sequence, 2); 
+        }
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_11);
+        __Pyx_INCREF(__pyx_t_12);
+        #else
+        __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 541, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __pyx_t_11 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 541, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __pyx_t_12 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_12)) __PYX_ERR(4, 541, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        #endif
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      } else {
+        Py_ssize_t index = -1;
+        __pyx_t_13 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_13)) __PYX_ERR(4, 541, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_13);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __pyx_t_24 = Py_TYPE(__pyx_t_13)->tp_iternext;
+        index = 0; __pyx_t_6 = __pyx_t_24(__pyx_t_13); if (unlikely(!__pyx_t_6)) goto __pyx_L31_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_6);
+        index = 1; __pyx_t_11 = __pyx_t_24(__pyx_t_13); if (unlikely(!__pyx_t_11)) goto __pyx_L31_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_11);
+        index = 2; __pyx_t_12 = __pyx_t_24(__pyx_t_13); if (unlikely(!__pyx_t_12)) goto __pyx_L31_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_12);
+        if (__Pyx_IternextUnpackEndCheck(__pyx_t_24(__pyx_t_13), 3) < 0) __PYX_ERR(4, 541, __pyx_L1_error)
+        __pyx_t_24 = NULL;
+        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+        goto __pyx_L32_unpacking_done;
+        __pyx_L31_unpacking_failed:;
+        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+        __pyx_t_24 = NULL;
+        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+        __PYX_ERR(4, 541, __pyx_L1_error)
+        __pyx_L32_unpacking_done:;
+      }
+      __Pyx_XDECREF_SET(__pyx_v_type, __pyx_t_6);
+      __pyx_t_6 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_fd, __pyx_t_11);
+      __pyx_t_11 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_arg, __pyx_t_12);
+      __pyx_t_12 = 0;
+
+      /* "uvloop/handles/process.pyx":542
+ *             self._pending_calls.clear()
+ *             for (type, fd, arg) in pending_calls:
+ *                 if type == _CALL_PIPE_CONNECTION_LOST:             # <<<<<<<<<<<<<<
+ *                     self._pipe_connection_lost(fd, arg)
+ *                 elif type == _CALL_PIPE_DATA_RECEIVED:
+ */
+      __pyx_t_5 = __Pyx_PyInt_EqObjC(__pyx_v_type, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 542, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(4, 542, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (__pyx_t_7) {
+
+        /* "uvloop/handles/process.pyx":543
+ *             for (type, fd, arg) in pending_calls:
+ *                 if type == _CALL_PIPE_CONNECTION_LOST:
+ *                     self._pipe_connection_lost(fd, arg)             # <<<<<<<<<<<<<<
+ *                 elif type == _CALL_PIPE_DATA_RECEIVED:
+ *                     self._pipe_data_received(fd, arg)
+ */
+        __pyx_t_14 = __Pyx_PyInt_As_int(__pyx_v_fd); if (unlikely((__pyx_t_14 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 543, __pyx_L1_error)
+        __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_pipe_connection_lost(__pyx_v_self, __pyx_t_14, __pyx_v_arg); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 543, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/handles/process.pyx":542
+ *             self._pending_calls.clear()
+ *             for (type, fd, arg) in pending_calls:
+ *                 if type == _CALL_PIPE_CONNECTION_LOST:             # <<<<<<<<<<<<<<
+ *                     self._pipe_connection_lost(fd, arg)
+ *                 elif type == _CALL_PIPE_DATA_RECEIVED:
+ */
+        goto __pyx_L33;
+      }
+
+      /* "uvloop/handles/process.pyx":544
+ *                 if type == _CALL_PIPE_CONNECTION_LOST:
+ *                     self._pipe_connection_lost(fd, arg)
+ *                 elif type == _CALL_PIPE_DATA_RECEIVED:             # <<<<<<<<<<<<<<
+ *                     self._pipe_data_received(fd, arg)
+ *                 elif type == _CALL_PROCESS_EXITED:
+ */
+      __pyx_t_5 = __Pyx_PyInt_EqObjC(__pyx_v_type, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 544, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(4, 544, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (__pyx_t_7) {
+
+        /* "uvloop/handles/process.pyx":545
+ *                     self._pipe_connection_lost(fd, arg)
+ *                 elif type == _CALL_PIPE_DATA_RECEIVED:
+ *                     self._pipe_data_received(fd, arg)             # <<<<<<<<<<<<<<
+ *                 elif type == _CALL_PROCESS_EXITED:
+ *                     self._loop.call_soon(self._protocol.process_exited)
+ */
+        __pyx_t_14 = __Pyx_PyInt_As_int(__pyx_v_fd); if (unlikely((__pyx_t_14 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 545, __pyx_L1_error)
+        __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_pipe_data_received(__pyx_v_self, __pyx_t_14, __pyx_v_arg); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 545, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/handles/process.pyx":544
+ *                 if type == _CALL_PIPE_CONNECTION_LOST:
+ *                     self._pipe_connection_lost(fd, arg)
+ *                 elif type == _CALL_PIPE_DATA_RECEIVED:             # <<<<<<<<<<<<<<
+ *                     self._pipe_data_received(fd, arg)
+ *                 elif type == _CALL_PROCESS_EXITED:
+ */
+        goto __pyx_L33;
+      }
+
+      /* "uvloop/handles/process.pyx":546
+ *                 elif type == _CALL_PIPE_DATA_RECEIVED:
+ *                     self._pipe_data_received(fd, arg)
+ *                 elif type == _CALL_PROCESS_EXITED:             # <<<<<<<<<<<<<<
+ *                     self._loop.call_soon(self._protocol.process_exited)
+ *                 elif type == _CALL_CONNECTION_LOST:
+ */
+      __pyx_t_5 = __Pyx_PyInt_EqObjC(__pyx_v_type, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 546, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(4, 546, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (__pyx_t_7) {
+
+        /* "uvloop/handles/process.pyx":547
+ *                     self._pipe_data_received(fd, arg)
+ *                 elif type == _CALL_PROCESS_EXITED:
+ *                     self._loop.call_soon(self._protocol.process_exited)             # <<<<<<<<<<<<<<
+ *                 elif type == _CALL_CONNECTION_LOST:
+ *                     self._loop.call_soon(self._protocol.connection_lost, None)
+ */
+        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop), __pyx_n_s_call_soon); if (unlikely(!__pyx_t_12)) __PYX_ERR(4, 547, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_n_s_process_exited); if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 547, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __pyx_t_6 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) {
+          __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_12);
+          if (likely(__pyx_t_6)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
+            __Pyx_INCREF(__pyx_t_6);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_12, function);
+          }
+        }
+        __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_12, __pyx_t_6, __pyx_t_11) : __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_11);
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 547, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/handles/process.pyx":546
+ *                 elif type == _CALL_PIPE_DATA_RECEIVED:
+ *                     self._pipe_data_received(fd, arg)
+ *                 elif type == _CALL_PROCESS_EXITED:             # <<<<<<<<<<<<<<
+ *                     self._loop.call_soon(self._protocol.process_exited)
+ *                 elif type == _CALL_CONNECTION_LOST:
+ */
+        goto __pyx_L33;
+      }
+
+      /* "uvloop/handles/process.pyx":548
+ *                 elif type == _CALL_PROCESS_EXITED:
+ *                     self._loop.call_soon(self._protocol.process_exited)
+ *                 elif type == _CALL_CONNECTION_LOST:             # <<<<<<<<<<<<<<
+ *                     self._loop.call_soon(self._protocol.connection_lost, None)
+ * 
+ */
+      __pyx_t_5 = __Pyx_PyInt_EqObjC(__pyx_v_type, __pyx_int_3, 3, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 548, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(4, 548, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (__pyx_t_7) {
+
+        /* "uvloop/handles/process.pyx":549
+ *                     self._loop.call_soon(self._protocol.process_exited)
+ *                 elif type == _CALL_CONNECTION_LOST:
+ *                     self._loop.call_soon(self._protocol.connection_lost, None)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _try_finish(self):
+ */
+        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop), __pyx_n_s_call_soon); if (unlikely(!__pyx_t_12)) __PYX_ERR(4, 549, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_n_s_connection_lost); if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 549, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __pyx_t_6 = NULL;
+        __pyx_t_14 = 0;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) {
+          __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_12);
+          if (likely(__pyx_t_6)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
+            __Pyx_INCREF(__pyx_t_6);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_12, function);
+            __pyx_t_14 = 1;
+          }
+        }
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_12)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_11, Py_None};
+          __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 549, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_12)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_11, Py_None};
+          __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 549, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        } else
+        #endif
+        {
+          __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) __PYX_ERR(4, 549, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_13);
+          if (__pyx_t_6) {
+            __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_6); __pyx_t_6 = NULL;
+          }
+          __Pyx_GIVEREF(__pyx_t_11);
+          PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_t_11);
+          __Pyx_INCREF(Py_None);
+          __Pyx_GIVEREF(Py_None);
+          PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, Py_None);
+          __pyx_t_11 = 0;
+          __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 549, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/handles/process.pyx":548
+ *                 elif type == _CALL_PROCESS_EXITED:
+ *                     self._loop.call_soon(self._protocol.process_exited)
+ *                 elif type == _CALL_CONNECTION_LOST:             # <<<<<<<<<<<<<<
+ *                     self._loop.call_soon(self._protocol.connection_lost, None)
+ * 
+ */
+      }
+      __pyx_L33:;
+
+      /* "uvloop/handles/process.pyx":541
+ *             pending_calls = self._pending_calls.copy()
+ *             self._pending_calls.clear()
+ *             for (type, fd, arg) in pending_calls:             # <<<<<<<<<<<<<<
+ *                 if type == _CALL_PIPE_CONNECTION_LOST:
+ *                     self._pipe_connection_lost(fd, arg)
+ */
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/handles/process.pyx":538
+ * 
+ *         self._stdio_ready = 1
+ *         if self._pending_calls:             # <<<<<<<<<<<<<<
+ *             pending_calls = self._pending_calls.copy()
+ *             self._pending_calls.clear()
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":522
+ *                 iocnt.flags = uv.UV_IGNORE
+ * 
+ *     cdef _call_connection_made(self, waiter):             # <<<<<<<<<<<<<<
+ *         try:
+ *             # we're always called in the right context, so just call the user's
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._call_connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XDECREF(__pyx_v_pending_calls);
+  __Pyx_XDECREF(__pyx_v_type);
+  __Pyx_XDECREF(__pyx_v_fd);
+  __Pyx_XDECREF(__pyx_v_arg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":551
+ *                     self._loop.call_soon(self._protocol.connection_lost, None)
+ * 
+ *     cdef _try_finish(self):             # <<<<<<<<<<<<<<
+ *         if self._returncode is None or self._finished:
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__try_finish(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_try_finish", 0);
+
+  /* "uvloop/handles/process.pyx":552
+ * 
+ *     cdef _try_finish(self):
+ *         if self._returncode is None or self._finished:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_self->__pyx_base._returncode == 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;
+  }
+  __pyx_t_3 = (__pyx_v_self->_finished != 0);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":553
+ *     cdef _try_finish(self):
+ *         if self._returncode is None or self._finished:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if ((self.stdin_proto is None or self.stdin_proto.disconnected) and
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/process.pyx":552
+ * 
+ *     cdef _try_finish(self):
+ *         if self._returncode is None or self._finished:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":555
+ *             return
+ * 
+ *         if ((self.stdin_proto is None or self.stdin_proto.disconnected) and             # <<<<<<<<<<<<<<
+ *                 (self.stdout_proto is None or
+ *                     self.stdout_proto.disconnected) and
+ */
+  __pyx_t_3 = (__pyx_v_self->stdin_proto == Py_None);
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (!__pyx_t_2) {
+  } else {
+    goto __pyx_L8_next_and;
+  }
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->stdin_proto, __pyx_n_s_disconnected); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 555, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(4, 555, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L7_bool_binop_done;
+  }
+  __pyx_L8_next_and:;
+
+  /* "uvloop/handles/process.pyx":556
+ * 
+ *         if ((self.stdin_proto is None or self.stdin_proto.disconnected) and
+ *                 (self.stdout_proto is None or             # <<<<<<<<<<<<<<
+ *                     self.stdout_proto.disconnected) and
+ *                 (self.stderr_proto is None or
+ */
+  __pyx_t_2 = (__pyx_v_self->stdout_proto == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (!__pyx_t_3) {
+  } else {
+    goto __pyx_L10_next_and;
+  }
+
+  /* "uvloop/handles/process.pyx":557
+ *         if ((self.stdin_proto is None or self.stdin_proto.disconnected) and
+ *                 (self.stdout_proto is None or
+ *                     self.stdout_proto.disconnected) and             # <<<<<<<<<<<<<<
+ *                 (self.stderr_proto is None or
+ *                     self.stderr_proto.disconnected)):
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->stdout_proto, __pyx_n_s_disconnected); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 557, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(4, 557, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (__pyx_t_3) {
+  } else {
+    __pyx_t_1 = __pyx_t_3;
+    goto __pyx_L7_bool_binop_done;
+  }
+  __pyx_L10_next_and:;
+
+  /* "uvloop/handles/process.pyx":558
+ *                 (self.stdout_proto is None or
+ *                     self.stdout_proto.disconnected) and
+ *                 (self.stderr_proto is None or             # <<<<<<<<<<<<<<
+ *                     self.stderr_proto.disconnected)):
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_self->stderr_proto == Py_None);
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L7_bool_binop_done;
+  }
+
+  /* "uvloop/handles/process.pyx":559
+ *                     self.stdout_proto.disconnected) and
+ *                 (self.stderr_proto is None or
+ *                     self.stderr_proto.disconnected)):             # <<<<<<<<<<<<<<
+ * 
+ *             self._finished = 1
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->stderr_proto, __pyx_n_s_disconnected); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 559, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(4, 559, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L7_bool_binop_done:;
+
+  /* "uvloop/handles/process.pyx":555
+ *             return
+ * 
+ *         if ((self.stdin_proto is None or self.stdin_proto.disconnected) and             # <<<<<<<<<<<<<<
+ *                 (self.stdout_proto is None or
+ *                     self.stdout_proto.disconnected) and
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":561
+ *                     self.stderr_proto.disconnected)):
+ * 
+ *             self._finished = 1             # <<<<<<<<<<<<<<
+ * 
+ *             if self._stdio_ready:
+ */
+    __pyx_v_self->_finished = 1;
+
+    /* "uvloop/handles/process.pyx":563
+ *             self._finished = 1
+ * 
+ *             if self._stdio_ready:             # <<<<<<<<<<<<<<
+ *                 # copy self.context for simplicity
+ *                 self._loop.call_soon(self._protocol.connection_lost, None,
+ */
+    __pyx_t_1 = (__pyx_v_self->_stdio_ready != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/process.pyx":565
+ *             if self._stdio_ready:
+ *                 # copy self.context for simplicity
+ *                 self._loop.call_soon(self._protocol.connection_lost, None,             # <<<<<<<<<<<<<<
+ *                                      context=self.context)
+ *             else:
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop), __pyx_n_s_call_soon); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 565, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_n_s_connection_lost); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 565, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 565, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5);
+      __Pyx_INCREF(Py_None);
+      __Pyx_GIVEREF(Py_None);
+      PyTuple_SET_ITEM(__pyx_t_6, 1, Py_None);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/handles/process.pyx":566
+ *                 # copy self.context for simplicity
+ *                 self._loop.call_soon(self._protocol.connection_lost, None,
+ *                                      context=self.context)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 self._pending_calls.append((_CALL_CONNECTION_LOST, None, None))
+ */
+      __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 566, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_context, __pyx_v_self->__pyx_base.__pyx_base.context) < 0) __PYX_ERR(4, 566, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":565
+ *             if self._stdio_ready:
+ *                 # copy self.context for simplicity
+ *                 self._loop.call_soon(self._protocol.connection_lost, None,             # <<<<<<<<<<<<<<
+ *                                      context=self.context)
+ *             else:
+ */
+      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 565, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/handles/process.pyx":563
+ *             self._finished = 1
+ * 
+ *             if self._stdio_ready:             # <<<<<<<<<<<<<<
+ *                 # copy self.context for simplicity
+ *                 self._loop.call_soon(self._protocol.connection_lost, None,
+ */
+      goto __pyx_L13;
+    }
+
+    /* "uvloop/handles/process.pyx":568
+ *                                      context=self.context)
+ *             else:
+ *                 self._pending_calls.append((_CALL_CONNECTION_LOST, None, None))             # <<<<<<<<<<<<<<
+ * 
+ *     def __stdio_inited(self, waiter, stdio_fut):
+ */
+    /*else*/ {
+      if (unlikely(__pyx_v_self->_pending_calls == Py_None)) {
+        PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+        __PYX_ERR(4, 568, __pyx_L1_error)
+      }
+      __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_self->_pending_calls, __pyx_tuple__193); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(4, 568, __pyx_L1_error)
+    }
+    __pyx_L13:;
+
+    /* "uvloop/handles/process.pyx":555
+ *             return
+ * 
+ *         if ((self.stdin_proto is None or self.stdin_proto.disconnected) and             # <<<<<<<<<<<<<<
+ *                 (self.stdout_proto is None or
+ *                     self.stdout_proto.disconnected) and
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":551
+ *                     self._loop.call_soon(self._protocol.connection_lost, None)
+ * 
+ *     cdef _try_finish(self):             # <<<<<<<<<<<<<<
+ *         if self._returncode is None or self._finished:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._try_finish", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":570
+ *                 self._pending_calls.append((_CALL_CONNECTION_LOST, None, None))
+ * 
+ *     def __stdio_inited(self, waiter, stdio_fut):             # <<<<<<<<<<<<<<
+ *         exc = stdio_fut.exception()
+ *         if exc is not None:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_3__stdio_inited(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_2__stdio_inited[] = "UVProcessTransport.__stdio_inited(self, waiter, stdio_fut)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_3__stdio_inited(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_waiter = 0;
+  PyObject *__pyx_v_stdio_fut = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__stdio_inited (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_waiter,&__pyx_n_s_stdio_fut,0};
+    PyObject* values[2] = {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  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_waiter)) != 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_stdio_fut)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__stdio_inited", 1, 2, 2, 1); __PYX_ERR(4, 570, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__stdio_inited") < 0)) __PYX_ERR(4, 570, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_waiter = values[0];
+    __pyx_v_stdio_fut = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__stdio_inited", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(4, 570, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.__stdio_inited", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_2__stdio_inited(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self), __pyx_v_waiter, __pyx_v_stdio_fut);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_2__stdio_inited(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_waiter, PyObject *__pyx_v_stdio_fut) {
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__stdio_inited", 0);
+
+  /* "uvloop/handles/process.pyx":571
+ * 
+ *     def __stdio_inited(self, waiter, stdio_fut):
+ *         exc = stdio_fut.exception()             # <<<<<<<<<<<<<<
+ *         if exc is not None:
+ *             if waiter is None:
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_stdio_fut, __pyx_n_s_exception); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 571, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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(4, 571, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_exc = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":572
+ *     def __stdio_inited(self, waiter, stdio_fut):
+ *         exc = stdio_fut.exception()
+ *         if exc is not None:             # <<<<<<<<<<<<<<
+ *             if waiter is None:
+ *                 raise exc
+ */
+  __pyx_t_4 = (__pyx_v_exc != Py_None);
+  __pyx_t_5 = (__pyx_t_4 != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/handles/process.pyx":573
+ *         exc = stdio_fut.exception()
+ *         if exc is not None:
+ *             if waiter is None:             # <<<<<<<<<<<<<<
+ *                 raise exc
+ *             else:
+ */
+    __pyx_t_5 = (__pyx_v_waiter == Py_None);
+    __pyx_t_4 = (__pyx_t_5 != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "uvloop/handles/process.pyx":574
+ *         if exc is not None:
+ *             if waiter is None:
+ *                 raise exc             # <<<<<<<<<<<<<<
+ *             else:
+ *                 waiter.set_exception(exc)
+ */
+      __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+      __PYX_ERR(4, 574, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":573
+ *         exc = stdio_fut.exception()
+ *         if exc is not None:
+ *             if waiter is None:             # <<<<<<<<<<<<<<
+ *                 raise exc
+ *             else:
+ */
+    }
+
+    /* "uvloop/handles/process.pyx":576
+ *                 raise exc
+ *             else:
+ *                 waiter.set_exception(exc)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._loop._call_soon_handle(
+ */
+    /*else*/ {
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 576, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_3 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_exc);
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 576, __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;
+    }
+
+    /* "uvloop/handles/process.pyx":572
+ *     def __stdio_inited(self, waiter, stdio_fut):
+ *         exc = stdio_fut.exception()
+ *         if exc is not None:             # <<<<<<<<<<<<<<
+ *             if waiter is None:
+ *                 raise exc
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/process.pyx":578
+ *                 waiter.set_exception(exc)
+ *         else:
+ *             self._loop._call_soon_handle(             # <<<<<<<<<<<<<<
+ *                 new_MethodHandle1(self._loop,
+ *                                   "UVProcessTransport._call_connection_made",
+ */
+  /*else*/ {
+
+    /* "uvloop/handles/process.pyx":579
+ *         else:
+ *             self._loop._call_soon_handle(
+ *                 new_MethodHandle1(self._loop,             # <<<<<<<<<<<<<<
+ *                                   "UVProcessTransport._call_connection_made",
+ *                                   <method1_t>self._call_connection_made,
+ */
+    __pyx_t_1 = ((PyObject *)__pyx_v_self->__pyx_base.__pyx_base._loop);
+    __Pyx_INCREF(__pyx_t_1);
+
+    /* "uvloop/handles/process.pyx":583
+ *                                   <method1_t>self._call_connection_made,
+ *                                   None,  # means to copy the current context
+ *                                   self, waiter))             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_new_MethodHandle1(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_1), __pyx_kp_u_UVProcessTransport__call_connect, ((__pyx_t_6uvloop_4loop_method1_t)((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_call_connection_made), Py_None, ((PyObject *)__pyx_v_self), __pyx_v_waiter); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 579, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/process.pyx":579
+ *         else:
+ *             self._loop._call_soon_handle(
+ *                 new_MethodHandle1(self._loop,             # <<<<<<<<<<<<<<
+ *                                   "UVProcessTransport._call_connection_made",
+ *                                   <method1_t>self._call_connection_made,
+ */
+    if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(4, 579, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":578
+ *                 waiter.set_exception(exc)
+ *         else:
+ *             self._loop._call_soon_handle(             # <<<<<<<<<<<<<<
+ *                 new_MethodHandle1(self._loop,
+ *                                   "UVProcessTransport._call_connection_made",
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_self->__pyx_base.__pyx_base._loop, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 578, __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;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/process.pyx":570
+ *                 self._pending_calls.append((_CALL_CONNECTION_LOST, None, None))
+ * 
+ *     def __stdio_inited(self, waiter, stdio_fut):             # <<<<<<<<<<<<<<
+ *         exc = stdio_fut.exception()
+ *         if exc is not None:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.__stdio_inited", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":586
+ * 
+ *     @staticmethod
+ *     cdef UVProcessTransport new(Loop loop, protocol, args, env,             # <<<<<<<<<<<<<<
+ *                                 cwd, start_new_session,
+ *                                 _stdin, _stdout, _stderr, pass_fds,
+ */
+
+static struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_f_6uvloop_4loop_18UVProcessTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, PyObject *__pyx_v_args, PyObject *__pyx_v_env, PyObject *__pyx_v_cwd, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr, PyObject *__pyx_v_pass_fds, PyObject *__pyx_v_waiter, PyObject *__pyx_v_debug_flags, PyObject *__pyx_v_preexec_fn, PyObject *__pyx_v_restore_signals) {
+  struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_handle = 0;
+  PyObject *__pyx_v_init_fut = NULL;
+  struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("new", 0);
+
+  /* "uvloop/handles/process.pyx":595
+ * 
+ *         cdef UVProcessTransport handle
+ *         handle = UVProcessTransport.__new__(UVProcessTransport)             # <<<<<<<<<<<<<<
+ *         handle._protocol = protocol
+ *         handle._init(loop, args, env, cwd, start_new_session,
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_UVProcessTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UVProcessTransport), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 595, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":596
+ *         cdef UVProcessTransport handle
+ *         handle = UVProcessTransport.__new__(UVProcessTransport)
+ *         handle._protocol = protocol             # <<<<<<<<<<<<<<
+ *         handle._init(loop, args, env, cwd, start_new_session,
+ *                      __process_convert_fileno(_stdin),
+ */
+  __Pyx_INCREF(__pyx_v_protocol);
+  __Pyx_GIVEREF(__pyx_v_protocol);
+  __Pyx_GOTREF(__pyx_v_handle->_protocol);
+  __Pyx_DECREF(__pyx_v_handle->_protocol);
+  __pyx_v_handle->_protocol = __pyx_v_protocol;
+
+  /* "uvloop/handles/process.pyx":597
+ *         handle = UVProcessTransport.__new__(UVProcessTransport)
+ *         handle._protocol = protocol
+ *         handle._init(loop, args, env, cwd, start_new_session,             # <<<<<<<<<<<<<<
+ *                      __process_convert_fileno(_stdin),
+ *                      __process_convert_fileno(_stdout),
+ */
+  if (!(likely(PyList_CheckExact(__pyx_v_args))||((__pyx_v_args) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_args)->tp_name), 0))) __PYX_ERR(4, 597, __pyx_L1_error)
+  if (!(likely(PyDict_CheckExact(__pyx_v_env))||((__pyx_v_env) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_env)->tp_name), 0))) __PYX_ERR(4, 597, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":598
+ *         handle._protocol = protocol
+ *         handle._init(loop, args, env, cwd, start_new_session,
+ *                      __process_convert_fileno(_stdin),             # <<<<<<<<<<<<<<
+ *                      __process_convert_fileno(_stdout),
+ *                      __process_convert_fileno(_stderr),
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___process_convert_fileno(__pyx_v__stdin); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 598, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+
+  /* "uvloop/handles/process.pyx":599
+ *         handle._init(loop, args, env, cwd, start_new_session,
+ *                      __process_convert_fileno(_stdin),
+ *                      __process_convert_fileno(_stdout),             # <<<<<<<<<<<<<<
+ *                      __process_convert_fileno(_stderr),
+ *                      pass_fds,
+ */
+  __pyx_t_2 = __pyx_f_6uvloop_4loop___process_convert_fileno(__pyx_v__stdout); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 599, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/handles/process.pyx":600
+ *                      __process_convert_fileno(_stdin),
+ *                      __process_convert_fileno(_stdout),
+ *                      __process_convert_fileno(_stderr),             # <<<<<<<<<<<<<<
+ *                      pass_fds,
+ *                      debug_flags,
+ */
+  __pyx_t_3 = __pyx_f_6uvloop_4loop___process_convert_fileno(__pyx_v__stderr); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 600, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "uvloop/handles/process.pyx":597
+ *         handle = UVProcessTransport.__new__(UVProcessTransport)
+ *         handle._protocol = protocol
+ *         handle._init(loop, args, env, cwd, start_new_session,             # <<<<<<<<<<<<<<
+ *                      __process_convert_fileno(_stdin),
+ *                      __process_convert_fileno(_stdout),
+ */
+  __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_handle), __pyx_v_loop, ((PyObject*)__pyx_v_args), ((PyObject*)__pyx_v_env), __pyx_v_cwd, __pyx_v_start_new_session, __pyx_t_1, __pyx_t_2, __pyx_t_3, __pyx_v_pass_fds, __pyx_v_debug_flags, __pyx_v_preexec_fn, __pyx_v_restore_signals); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 597, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __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;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/handles/process.pyx":606
+ *                      restore_signals)
+ * 
+ *         if handle._init_futs:             # <<<<<<<<<<<<<<
+ *             handle._stdio_ready = 0
+ *             init_fut = aio_gather(*handle._init_futs)
+ */
+  __pyx_t_5 = (__pyx_v_handle->_init_futs != Py_None)&&(PyList_GET_SIZE(__pyx_v_handle->_init_futs) != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/handles/process.pyx":607
+ * 
+ *         if handle._init_futs:
+ *             handle._stdio_ready = 0             # <<<<<<<<<<<<<<
+ *             init_fut = aio_gather(*handle._init_futs)
+ *             # add_done_callback will copy the current context and run the
+ */
+    __pyx_v_handle->_stdio_ready = 0;
+
+    /* "uvloop/handles/process.pyx":608
+ *         if handle._init_futs:
+ *             handle._stdio_ready = 0
+ *             init_fut = aio_gather(*handle._init_futs)             # <<<<<<<<<<<<<<
+ *             # add_done_callback will copy the current context and run the
+ *             # callback within the context
+ */
+    __pyx_t_4 = PySequence_Tuple(__pyx_v_handle->_init_futs); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 608, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_gather, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 608, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_v_init_fut = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/handles/process.pyx":611
+ *             # add_done_callback will copy the current context and run the
+ *             # callback within the context
+ *             init_fut.add_done_callback(             # <<<<<<<<<<<<<<
+ *                 ft_partial(handle.__stdio_inited, waiter))
+ *         else:
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_init_fut, __pyx_n_s_add_done_callback); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 611, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "uvloop/handles/process.pyx":612
+ *             # callback within the context
+ *             init_fut.add_done_callback(
+ *                 ft_partial(handle.__stdio_inited, waiter))             # <<<<<<<<<<<<<<
+ *         else:
+ *             handle._stdio_ready = 1
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_handle), __pyx_n_s_stdio_inited); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 612, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_ft_partial);
+    __pyx_t_6 = __pyx_v_6uvloop_4loop_ft_partial; __pyx_t_7 = NULL;
+    __pyx_t_8 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+        __pyx_t_8 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_6)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_1, __pyx_v_waiter};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 612, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 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_6)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_1, __pyx_v_waiter};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 612, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 612, __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_GIVEREF(__pyx_t_1);
+      PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_1);
+      __Pyx_INCREF(__pyx_v_waiter);
+      __Pyx_GIVEREF(__pyx_v_waiter);
+      PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_waiter);
+      __pyx_t_1 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 612, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2);
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 611, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/process.pyx":606
+ *                      restore_signals)
+ * 
+ *         if handle._init_futs:             # <<<<<<<<<<<<<<
+ *             handle._stdio_ready = 0
+ *             init_fut = aio_gather(*handle._init_futs)
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/process.pyx":614
+ *                 ft_partial(handle.__stdio_inited, waiter))
+ *         else:
+ *             handle._stdio_ready = 1             # <<<<<<<<<<<<<<
+ *             loop._call_soon_handle(
+ *                 new_MethodHandle1(loop,
+ */
+  /*else*/ {
+    __pyx_v_handle->_stdio_ready = 1;
+
+    /* "uvloop/handles/process.pyx":616
+ *             handle._stdio_ready = 1
+ *             loop._call_soon_handle(
+ *                 new_MethodHandle1(loop,             # <<<<<<<<<<<<<<
+ *                                   "UVProcessTransport._call_connection_made",
+ *                                   <method1_t>handle._call_connection_made,
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_new_MethodHandle1(__pyx_v_loop, __pyx_kp_u_UVProcessTransport__call_connect, ((__pyx_t_6uvloop_4loop_method1_t)((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_handle->__pyx_base.__pyx_base.__pyx_vtab)->_call_connection_made), Py_None, ((PyObject *)__pyx_v_handle), __pyx_v_waiter); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 616, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(4, 616, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":615
+ *         else:
+ *             handle._stdio_ready = 1
+ *             loop._call_soon_handle(             # <<<<<<<<<<<<<<
+ *                 new_MethodHandle1(loop,
+ *                                   "UVProcessTransport._call_connection_made",
+ */
+    __pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_loop, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 615, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/process.pyx":622
+ *                                   handle, waiter))
+ * 
+ *         return handle             # <<<<<<<<<<<<<<
+ * 
+ *     def get_protocol(self):
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":586
+ * 
+ *     @staticmethod
+ *     cdef UVProcessTransport new(Loop loop, protocol, args, env,             # <<<<<<<<<<<<<<
+ *                                 cwd, start_new_session,
+ *                                 _stdin, _stdout, _stderr, pass_fds,
+ */
+
+  /* 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_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
+  __Pyx_XDECREF(__pyx_v_init_fut);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":624
+ *         return handle
+ * 
+ *     def get_protocol(self):             # <<<<<<<<<<<<<<
+ *         return self._protocol
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_5get_protocol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_4get_protocol[] = "UVProcessTransport.get_protocol(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_5get_protocol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_protocol (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_4get_protocol(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_4get_protocol(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_protocol", 0);
+
+  /* "uvloop/handles/process.pyx":625
+ * 
+ *     def get_protocol(self):
+ *         return self._protocol             # <<<<<<<<<<<<<<
+ * 
+ *     def set_protocol(self, protocol):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_protocol);
+  __pyx_r = __pyx_v_self->_protocol;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":624
+ *         return handle
+ * 
+ *     def get_protocol(self):             # <<<<<<<<<<<<<<
+ *         return self._protocol
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":627
+ *         return self._protocol
+ * 
+ *     def set_protocol(self, protocol):             # <<<<<<<<<<<<<<
+ *         self._protocol = protocol
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_7set_protocol(PyObject *__pyx_v_self, PyObject *__pyx_v_protocol); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_6set_protocol[] = "UVProcessTransport.set_protocol(self, protocol)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_7set_protocol(PyObject *__pyx_v_self, PyObject *__pyx_v_protocol) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_protocol (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_6set_protocol(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self), ((PyObject *)__pyx_v_protocol));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_6set_protocol(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_protocol) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_protocol", 0);
+
+  /* "uvloop/handles/process.pyx":628
+ * 
+ *     def set_protocol(self, protocol):
+ *         self._protocol = protocol             # <<<<<<<<<<<<<<
+ * 
+ *     def get_pid(self):
+ */
+  __Pyx_INCREF(__pyx_v_protocol);
+  __Pyx_GIVEREF(__pyx_v_protocol);
+  __Pyx_GOTREF(__pyx_v_self->_protocol);
+  __Pyx_DECREF(__pyx_v_self->_protocol);
+  __pyx_v_self->_protocol = __pyx_v_protocol;
+
+  /* "uvloop/handles/process.pyx":627
+ *         return self._protocol
+ * 
+ *     def set_protocol(self, protocol):             # <<<<<<<<<<<<<<
+ *         self._protocol = protocol
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":630
+ *         self._protocol = protocol
+ * 
+ *     def get_pid(self):             # <<<<<<<<<<<<<<
+ *         return self._pid
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_9get_pid(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_8get_pid[] = "UVProcessTransport.get_pid(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_9get_pid(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_pid (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_8get_pid(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_8get_pid(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_pid", 0);
+
+  /* "uvloop/handles/process.pyx":631
+ * 
+ *     def get_pid(self):
+ *         return self._pid             # <<<<<<<<<<<<<<
+ * 
+ *     def get_returncode(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->__pyx_base._pid);
+  __pyx_r = __pyx_v_self->__pyx_base._pid;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":630
+ *         self._protocol = protocol
+ * 
+ *     def get_pid(self):             # <<<<<<<<<<<<<<
+ *         return self._pid
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":633
+ *         return self._pid
+ * 
+ *     def get_returncode(self):             # <<<<<<<<<<<<<<
+ *         return self._returncode
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_11get_returncode(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_10get_returncode[] = "UVProcessTransport.get_returncode(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_11get_returncode(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_returncode (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_10get_returncode(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_10get_returncode(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_returncode", 0);
+
+  /* "uvloop/handles/process.pyx":634
+ * 
+ *     def get_returncode(self):
+ *         return self._returncode             # <<<<<<<<<<<<<<
+ * 
+ *     def get_pipe_transport(self, fd):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->__pyx_base._returncode);
+  __pyx_r = __pyx_v_self->__pyx_base._returncode;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":633
+ *         return self._pid
+ * 
+ *     def get_returncode(self):             # <<<<<<<<<<<<<<
+ *         return self._returncode
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":636
+ *         return self._returncode
+ * 
+ *     def get_pipe_transport(self, fd):             # <<<<<<<<<<<<<<
+ *         if fd == 0:
+ *             return self._stdin
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_13get_pipe_transport(PyObject *__pyx_v_self, PyObject *__pyx_v_fd); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_12get_pipe_transport[] = "UVProcessTransport.get_pipe_transport(self, fd)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_13get_pipe_transport(PyObject *__pyx_v_self, PyObject *__pyx_v_fd) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_pipe_transport (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_12get_pipe_transport(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self), ((PyObject *)__pyx_v_fd));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_12get_pipe_transport(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_fd) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_pipe_transport", 0);
+
+  /* "uvloop/handles/process.pyx":637
+ * 
+ *     def get_pipe_transport(self, fd):
+ *         if fd == 0:             # <<<<<<<<<<<<<<
+ *             return self._stdin
+ *         elif fd == 1:
+ */
+  __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_fd, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 637, __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(4, 637, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/process.pyx":638
+ *     def get_pipe_transport(self, fd):
+ *         if fd == 0:
+ *             return self._stdin             # <<<<<<<<<<<<<<
+ *         elif fd == 1:
+ *             return self._stdout
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->_stdin));
+    __pyx_r = ((PyObject *)__pyx_v_self->_stdin);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/process.pyx":637
+ * 
+ *     def get_pipe_transport(self, fd):
+ *         if fd == 0:             # <<<<<<<<<<<<<<
+ *             return self._stdin
+ *         elif fd == 1:
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":639
+ *         if fd == 0:
+ *             return self._stdin
+ *         elif fd == 1:             # <<<<<<<<<<<<<<
+ *             return self._stdout
+ *         elif fd == 2:
+ */
+  __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_fd, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 639, __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(4, 639, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/process.pyx":640
+ *             return self._stdin
+ *         elif fd == 1:
+ *             return self._stdout             # <<<<<<<<<<<<<<
+ *         elif fd == 2:
+ *             return self._stderr
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->_stdout));
+    __pyx_r = ((PyObject *)__pyx_v_self->_stdout);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/process.pyx":639
+ *         if fd == 0:
+ *             return self._stdin
+ *         elif fd == 1:             # <<<<<<<<<<<<<<
+ *             return self._stdout
+ *         elif fd == 2:
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":641
+ *         elif fd == 1:
+ *             return self._stdout
+ *         elif fd == 2:             # <<<<<<<<<<<<<<
+ *             return self._stderr
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_fd, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 641, __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(4, 641, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/process.pyx":642
+ *             return self._stdout
+ *         elif fd == 2:
+ *             return self._stderr             # <<<<<<<<<<<<<<
+ * 
+ *     def terminate(self):
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->_stderr));
+    __pyx_r = ((PyObject *)__pyx_v_self->_stderr);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/process.pyx":641
+ *         elif fd == 1:
+ *             return self._stdout
+ *         elif fd == 2:             # <<<<<<<<<<<<<<
+ *             return self._stderr
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":636
+ *         return self._returncode
+ * 
+ *     def get_pipe_transport(self, fd):             # <<<<<<<<<<<<<<
+ *         if fd == 0:
+ *             return self._stdin
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.get_pipe_transport", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":644
+ *             return self._stderr
+ * 
+ *     def terminate(self):             # <<<<<<<<<<<<<<
+ *         self._check_proc()
+ *         self._kill(uv.SIGTERM)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_15terminate(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_14terminate[] = "UVProcessTransport.terminate(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_15terminate(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("terminate (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_14terminate(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_14terminate(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__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("terminate", 0);
+
+  /* "uvloop/handles/process.pyx":645
+ * 
+ *     def terminate(self):
+ *         self._check_proc()             # <<<<<<<<<<<<<<
+ *         self._kill(uv.SIGTERM)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_check_proc(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 645, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":646
+ *     def terminate(self):
+ *         self._check_proc()
+ *         self._kill(uv.SIGTERM)             # <<<<<<<<<<<<<<
+ * 
+ *     def kill(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._kill(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), SIGTERM); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 646, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":644
+ *             return self._stderr
+ * 
+ *     def terminate(self):             # <<<<<<<<<<<<<<
+ *         self._check_proc()
+ *         self._kill(uv.SIGTERM)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.terminate", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":648
+ *         self._kill(uv.SIGTERM)
+ * 
+ *     def kill(self):             # <<<<<<<<<<<<<<
+ *         self._check_proc()
+ *         self._kill(uv.SIGKILL)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_17kill(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_16kill[] = "UVProcessTransport.kill(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_17kill(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("kill (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_16kill(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_16kill(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__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("kill", 0);
+
+  /* "uvloop/handles/process.pyx":649
+ * 
+ *     def kill(self):
+ *         self._check_proc()             # <<<<<<<<<<<<<<
+ *         self._kill(uv.SIGKILL)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_check_proc(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 649, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":650
+ *     def kill(self):
+ *         self._check_proc()
+ *         self._kill(uv.SIGKILL)             # <<<<<<<<<<<<<<
+ * 
+ *     def send_signal(self, int signal):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._kill(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), SIGKILL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 650, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":648
+ *         self._kill(uv.SIGTERM)
+ * 
+ *     def kill(self):             # <<<<<<<<<<<<<<
+ *         self._check_proc()
+ *         self._kill(uv.SIGKILL)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.kill", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":652
+ *         self._kill(uv.SIGKILL)
+ * 
+ *     def send_signal(self, int signal):             # <<<<<<<<<<<<<<
+ *         self._check_proc()
+ *         self._kill(signal)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_19send_signal(PyObject *__pyx_v_self, PyObject *__pyx_arg_signal); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_18send_signal[] = "UVProcessTransport.send_signal(self, int signal)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_19send_signal(PyObject *__pyx_v_self, PyObject *__pyx_arg_signal) {
+  int __pyx_v_signal;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("send_signal (wrapper)", 0);
+  assert(__pyx_arg_signal); {
+    __pyx_v_signal = __Pyx_PyInt_As_int(__pyx_arg_signal); if (unlikely((__pyx_v_signal == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 652, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.send_signal", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_18send_signal(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self), ((int)__pyx_v_signal));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_18send_signal(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_signal) {
+  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("send_signal", 0);
+
+  /* "uvloop/handles/process.pyx":653
+ * 
+ *     def send_signal(self, int signal):
+ *         self._check_proc()             # <<<<<<<<<<<<<<
+ *         self._kill(signal)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->_check_proc(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 653, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":654
+ *     def send_signal(self, int signal):
+ *         self._check_proc()
+ *         self._kill(signal)             # <<<<<<<<<<<<<<
+ * 
+ *     def is_closing(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._kill(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), __pyx_v_signal); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 654, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":652
+ *         self._kill(uv.SIGKILL)
+ * 
+ *     def send_signal(self, int signal):             # <<<<<<<<<<<<<<
+ *         self._check_proc()
+ *         self._kill(signal)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.send_signal", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":656
+ *         self._kill(signal)
+ * 
+ *     def is_closing(self):             # <<<<<<<<<<<<<<
+ *         return self._closed
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_21is_closing(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_20is_closing[] = "UVProcessTransport.is_closing(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_21is_closing(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_closing (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_20is_closing(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_20is_closing(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__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("is_closing", 0);
+
+  /* "uvloop/handles/process.pyx":657
+ * 
+ *     def is_closing(self):
+ *         return self._closed             # <<<<<<<<<<<<<<
+ * 
+ *     def close(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->__pyx_base.__pyx_base._closed); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 657, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":656
+ *         self._kill(signal)
+ * 
+ *     def is_closing(self):             # <<<<<<<<<<<<<<
+ *         return self._closed
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.is_closing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":659
+ *         return self._closed
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         if self._returncode is None:
+ *             self._kill(uv.SIGKILL)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_23close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_22close[] = "UVProcessTransport.close(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_23close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("close (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_22close(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_22close(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  __Pyx_RefNannySetupContext("close", 0);
+
+  /* "uvloop/handles/process.pyx":660
+ * 
+ *     def close(self):
+ *         if self._returncode is None:             # <<<<<<<<<<<<<<
+ *             self._kill(uv.SIGKILL)
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx_base._returncode == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/process.pyx":661
+ *     def close(self):
+ *         if self._returncode is None:
+ *             self._kill(uv.SIGKILL)             # <<<<<<<<<<<<<<
+ * 
+ *         if self._stdin is not None:
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._kill(((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_v_self), SIGKILL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 661, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/process.pyx":660
+ * 
+ *     def close(self):
+ *         if self._returncode is None:             # <<<<<<<<<<<<<<
+ *             self._kill(uv.SIGKILL)
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":663
+ *             self._kill(uv.SIGKILL)
+ * 
+ *         if self._stdin is not None:             # <<<<<<<<<<<<<<
+ *             self._stdin.close()
+ *         if self._stdout is not None:
+ */
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->_stdin) != Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":664
+ * 
+ *         if self._stdin is not None:
+ *             self._stdin.close()             # <<<<<<<<<<<<<<
+ *         if self._stdout is not None:
+ *             self._stdout.close()
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_stdin), __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 664, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 664, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/process.pyx":663
+ *             self._kill(uv.SIGKILL)
+ * 
+ *         if self._stdin is not None:             # <<<<<<<<<<<<<<
+ *             self._stdin.close()
+ *         if self._stdout is not None:
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":665
+ *         if self._stdin is not None:
+ *             self._stdin.close()
+ *         if self._stdout is not None:             # <<<<<<<<<<<<<<
+ *             self._stdout.close()
+ *         if self._stderr is not None:
+ */
+  __pyx_t_1 = (((PyObject *)__pyx_v_self->_stdout) != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/process.pyx":666
+ *             self._stdin.close()
+ *         if self._stdout is not None:
+ *             self._stdout.close()             # <<<<<<<<<<<<<<
+ *         if self._stderr is not None:
+ *             self._stderr.close()
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_stdout), __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 666, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 666, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/process.pyx":665
+ *         if self._stdin is not None:
+ *             self._stdin.close()
+ *         if self._stdout is not None:             # <<<<<<<<<<<<<<
+ *             self._stdout.close()
+ *         if self._stderr is not None:
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":667
+ *         if self._stdout is not None:
+ *             self._stdout.close()
+ *         if self._stderr is not None:             # <<<<<<<<<<<<<<
+ *             self._stderr.close()
+ * 
+ */
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->_stderr) != Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":668
+ *             self._stdout.close()
+ *         if self._stderr is not None:
+ *             self._stderr.close()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._returncode is not None:
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_stderr), __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 668, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 668, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/process.pyx":667
+ *         if self._stdout is not None:
+ *             self._stdout.close()
+ *         if self._stderr is not None:             # <<<<<<<<<<<<<<
+ *             self._stderr.close()
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":670
+ *             self._stderr.close()
+ * 
+ *         if self._returncode is not None:             # <<<<<<<<<<<<<<
+ *             # The process is dead, just close the UV handle.
+ *             #
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx_base._returncode != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/process.pyx":677
+ *             # which the transport will be GC'ed and the uvhandle will be
+ *             # closed in UVHandle.__dealloc__.)
+ *             self._close()             # <<<<<<<<<<<<<<
+ * 
+ *     def get_extra_info(self, name, default=None):
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 677, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/handles/process.pyx":670
+ *             self._stderr.close()
+ * 
+ *         if self._returncode is not None:             # <<<<<<<<<<<<<<
+ *             # The process is dead, just close the UV handle.
+ *             #
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":659
+ *         return self._closed
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         if self._returncode is None:
+ *             self._kill(uv.SIGKILL)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":679
+ *             self._close()
+ * 
+ *     def get_extra_info(self, name, default=None):             # <<<<<<<<<<<<<<
+ *         return default
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_25get_extra_info(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_24get_extra_info[] = "UVProcessTransport.get_extra_info(self, name, default=None)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_25get_extra_info(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_name = 0;
+  PyObject *__pyx_v_default = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_extra_info (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name_2,&__pyx_n_s_default,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)Py_None);
+    if (unlikely(__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);
+        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_2)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_default);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_extra_info") < 0)) __PYX_ERR(4, 679, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_name = values[0];
+    __pyx_v_default = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_extra_info", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(4, 679, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.get_extra_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_24get_extra_info(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self), __pyx_v_name, __pyx_v_default);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_24get_extra_info(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_name, PyObject *__pyx_v_default) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_extra_info", 0);
+
+  /* "uvloop/handles/process.pyx":680
+ * 
+ *     def get_extra_info(self, name, default=None):
+ *         return default             # <<<<<<<<<<<<<<
+ * 
+ *     def _wait(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_default);
+  __pyx_r = __pyx_v_default;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":679
+ *             self._close()
+ * 
+ *     def get_extra_info(self, name, default=None):             # <<<<<<<<<<<<<<
+ *         return default
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":682
+ *         return default
+ * 
+ *     def _wait(self):             # <<<<<<<<<<<<<<
+ *         fut = self._loop._new_future()
+ *         if self._returncode is not None:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_27_wait(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_26_wait[] = "UVProcessTransport._wait(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_27_wait(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_wait (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_18UVProcessTransport_26_wait(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_26_wait(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self) {
+  PyObject *__pyx_v_fut = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_wait", 0);
+
+  /* "uvloop/handles/process.pyx":683
+ * 
+ *     def _wait(self):
+ *         fut = self._loop._new_future()             # <<<<<<<<<<<<<<
+ *         if self._returncode is not None:
+ *             fut.set_result(self._returncode)
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self->__pyx_base.__pyx_base._loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 683, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fut = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":684
+ *     def _wait(self):
+ *         fut = self._loop._new_future()
+ *         if self._returncode is not None:             # <<<<<<<<<<<<<<
+ *             fut.set_result(self._returncode)
+ *             return fut
+ */
+  __pyx_t_2 = (__pyx_v_self->__pyx_base._returncode != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/process.pyx":685
+ *         fut = self._loop._new_future()
+ *         if self._returncode is not None:
+ *             fut.set_result(self._returncode)             # <<<<<<<<<<<<<<
+ *             return fut
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 685, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_self->__pyx_base._returncode) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_self->__pyx_base._returncode);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 685, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/process.pyx":686
+ *         if self._returncode is not None:
+ *             fut.set_result(self._returncode)
+ *             return fut             # <<<<<<<<<<<<<<
+ * 
+ *         self._exit_waiters.append(fut)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_fut);
+    __pyx_r = __pyx_v_fut;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/process.pyx":684
+ *     def _wait(self):
+ *         fut = self._loop._new_future()
+ *         if self._returncode is not None:             # <<<<<<<<<<<<<<
+ *             fut.set_result(self._returncode)
+ *             return fut
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":688
+ *             return fut
+ * 
+ *         self._exit_waiters.append(fut)             # <<<<<<<<<<<<<<
+ *         return fut
+ * 
+ */
+  if (unlikely(__pyx_v_self->_exit_waiters == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+    __PYX_ERR(4, 688, __pyx_L1_error)
+  }
+  __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_self->_exit_waiters, __pyx_v_fut); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(4, 688, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":689
+ * 
+ *         self._exit_waiters.append(fut)
+ *         return fut             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_fut);
+  __pyx_r = __pyx_v_fut;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":682
+ *         return default
+ * 
+ *     def _wait(self):             # <<<<<<<<<<<<<<
+ *         fut = self._loop._new_future()
+ *         if self._returncode is not None:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport._wait", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fut);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_29__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_28__reduce_cython__[] = "UVProcessTransport.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_29__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_6uvloop_4loop_18UVProcessTransport_28__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__194, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.__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_6uvloop_4loop_18UVProcessTransport_31__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_18UVProcessTransport_30__setstate_cython__[] = "UVProcessTransport.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_18UVProcessTransport_31__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_6uvloop_4loop_18UVProcessTransport_30__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__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);
+
+  /* "(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__195, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVProcessTransport.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":694
+ * class WriteSubprocessPipeProto(aio_BaseProtocol):
+ * 
+ *     def __init__(self, proc, fd):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if type(proc) is not UVProcessTransport:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto___init__[] = "WriteSubprocessPipeProto.__init__(self, proc, fd)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_1__init__ = {"__init__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_1__init__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto___init__};
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_proc = 0;
+  PyObject *__pyx_v_fd = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self_2,&__pyx_n_s_proc,&__pyx_n_s_fd,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_self_2)) != 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_proc)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 1); __PYX_ERR(4, 694, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fd)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 2); __PYX_ERR(4, 694, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(4, 694, __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_self = values[0];
+    __pyx_v_proc = values[1];
+    __pyx_v_fd = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(4, 694, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.WriteSubprocessPipeProto.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto___init__(__pyx_self, __pyx_v_self, __pyx_v_proc, __pyx_v_fd);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_proc, PyObject *__pyx_v_fd) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  /* "uvloop/handles/process.pyx":695
+ * 
+ *     def __init__(self, proc, fd):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if type(proc) is not UVProcessTransport:
+ *                 raise TypeError
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":696
+ *     def __init__(self, proc, fd):
+ *         if UVLOOP_DEBUG:
+ *             if type(proc) is not UVProcessTransport:             # <<<<<<<<<<<<<<
+ *                 raise TypeError
+ *             if not isinstance(fd, int):
+ */
+    __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_proc)) != ((PyObject *)__pyx_ptype_6uvloop_4loop_UVProcessTransport));
+    __pyx_t_2 = (__pyx_t_1 != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/handles/process.pyx":697
+ *         if UVLOOP_DEBUG:
+ *             if type(proc) is not UVProcessTransport:
+ *                 raise TypeError             # <<<<<<<<<<<<<<
+ *             if not isinstance(fd, int):
+ *                 raise TypeError
+ */
+      __Pyx_Raise(__pyx_builtin_TypeError, 0, 0, 0);
+      __PYX_ERR(4, 697, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":696
+ *     def __init__(self, proc, fd):
+ *         if UVLOOP_DEBUG:
+ *             if type(proc) is not UVProcessTransport:             # <<<<<<<<<<<<<<
+ *                 raise TypeError
+ *             if not isinstance(fd, int):
+ */
+    }
+
+    /* "uvloop/handles/process.pyx":698
+ *             if type(proc) is not UVProcessTransport:
+ *                 raise TypeError
+ *             if not isinstance(fd, int):             # <<<<<<<<<<<<<<
+ *                 raise TypeError
+ *         self.proc = proc
+ */
+    __pyx_t_2 = PyInt_Check(__pyx_v_fd); 
+    __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/handles/process.pyx":699
+ *                 raise TypeError
+ *             if not isinstance(fd, int):
+ *                 raise TypeError             # <<<<<<<<<<<<<<
+ *         self.proc = proc
+ *         self.fd = fd
+ */
+      __Pyx_Raise(__pyx_builtin_TypeError, 0, 0, 0);
+      __PYX_ERR(4, 699, __pyx_L1_error)
+
+      /* "uvloop/handles/process.pyx":698
+ *             if type(proc) is not UVProcessTransport:
+ *                 raise TypeError
+ *             if not isinstance(fd, int):             # <<<<<<<<<<<<<<
+ *                 raise TypeError
+ *         self.proc = proc
+ */
+    }
+
+    /* "uvloop/handles/process.pyx":695
+ * 
+ *     def __init__(self, proc, fd):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if type(proc) is not UVProcessTransport:
+ *                 raise TypeError
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":700
+ *             if not isinstance(fd, int):
+ *                 raise TypeError
+ *         self.proc = proc             # <<<<<<<<<<<<<<
+ *         self.fd = fd
+ *         self.pipe = None
+ */
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_proc, __pyx_v_proc) < 0) __PYX_ERR(4, 700, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":701
+ *                 raise TypeError
+ *         self.proc = proc
+ *         self.fd = fd             # <<<<<<<<<<<<<<
+ *         self.pipe = None
+ *         self.disconnected = False
+ */
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_fd, __pyx_v_fd) < 0) __PYX_ERR(4, 701, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":702
+ *         self.proc = proc
+ *         self.fd = fd
+ *         self.pipe = None             # <<<<<<<<<<<<<<
+ *         self.disconnected = False
+ * 
+ */
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_pipe, Py_None) < 0) __PYX_ERR(4, 702, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":703
+ *         self.fd = fd
+ *         self.pipe = None
+ *         self.disconnected = False             # <<<<<<<<<<<<<<
+ * 
+ *     def connection_made(self, transport):
+ */
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_disconnected, Py_False) < 0) __PYX_ERR(4, 703, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":694
+ * class WriteSubprocessPipeProto(aio_BaseProtocol):
+ * 
+ *     def __init__(self, proc, fd):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if type(proc) is not UVProcessTransport:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.WriteSubprocessPipeProto.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":705
+ *         self.disconnected = False
+ * 
+ *     def connection_made(self, transport):             # <<<<<<<<<<<<<<
+ *         self.pipe = transport
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_3connection_made(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto_2connection_made[] = "WriteSubprocessPipeProto.connection_made(self, transport)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_3connection_made = {"connection_made", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_3connection_made, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto_2connection_made};
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_3connection_made(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_transport = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connection_made (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self_2,&__pyx_n_s_transport,0};
+    PyObject* values[2] = {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  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_self_2)) != 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_transport)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("connection_made", 1, 2, 2, 1); __PYX_ERR(4, 705, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "connection_made") < 0)) __PYX_ERR(4, 705, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_transport = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("connection_made", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(4, 705, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.WriteSubprocessPipeProto.connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_2connection_made(__pyx_self, __pyx_v_self, __pyx_v_transport);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_2connection_made(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_transport) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("connection_made", 0);
+
+  /* "uvloop/handles/process.pyx":706
+ * 
+ *     def connection_made(self, transport):
+ *         self.pipe = transport             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_pipe, __pyx_v_transport) < 0) __PYX_ERR(4, 706, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":705
+ *         self.disconnected = False
+ * 
+ *     def connection_made(self, transport):             # <<<<<<<<<<<<<<
+ *         self.pipe = transport
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.WriteSubprocessPipeProto.connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":708
+ *         self.pipe = transport
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return ('<%s fd=%s pipe=%r>'
+ *                 % (self.__class__.__name__, self.fd, self.pipe))
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_5__repr__(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static char __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto_4__repr__[] = "WriteSubprocessPipeProto.__repr__(self)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_5__repr__ = {"__repr__", (PyCFunction)__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_5__repr__, METH_O, __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto_4__repr__};
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_5__repr__(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_4__repr__(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_4__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  Py_UCS4 __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "uvloop/handles/process.pyx":709
+ * 
+ *     def __repr__(self):
+ *         return ('<%s fd=%s pipe=%r>'             # <<<<<<<<<<<<<<
+ *                 % (self.__class__.__name__, self.fd, self.pipe))
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 709, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 127;
+  __Pyx_INCREF(__pyx_kp_u__103);
+  __pyx_t_2 += 1;
+  __Pyx_GIVEREF(__pyx_kp_u__103);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u__103);
+
+  /* "uvloop/handles/process.pyx":710
+ *     def __repr__(self):
+ *         return ('<%s fd=%s pipe=%r>'
+ *                 % (self.__class__.__name__, self.fd, self.pipe))             # <<<<<<<<<<<<<<
+ * 
+ *     def connection_lost(self, exc):
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 710, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 710, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Unicode(__pyx_t_5), __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 710, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_3;
+  __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __Pyx_INCREF(__pyx_kp_u_fd_2);
+  __pyx_t_2 += 4;
+  __Pyx_GIVEREF(__pyx_kp_u_fd_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_fd_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_fd); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 710, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Unicode(__pyx_t_4), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 710, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3;
+  __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __Pyx_INCREF(__pyx_kp_u_pipe_2);
+  __pyx_t_2 += 6;
+  __Pyx_GIVEREF(__pyx_kp_u_pipe_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_pipe_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_pipe); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 710, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_5), __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 710, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_3;
+  __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __Pyx_INCREF(__pyx_kp_u__105);
+  __pyx_t_2 += 1;
+  __Pyx_GIVEREF(__pyx_kp_u__105);
+  PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__105);
+
+  /* "uvloop/handles/process.pyx":709
+ * 
+ *     def __repr__(self):
+ *         return ('<%s fd=%s pipe=%r>'             # <<<<<<<<<<<<<<
+ *                 % (self.__class__.__name__, self.fd, self.pipe))
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 709, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":708
+ *         self.pipe = transport
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return ('<%s fd=%s pipe=%r>'
+ *                 % (self.__class__.__name__, self.fd, self.pipe))
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.WriteSubprocessPipeProto.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":712
+ *                 % (self.__class__.__name__, self.fd, self.pipe))
+ * 
+ *     def connection_lost(self, exc):             # <<<<<<<<<<<<<<
+ *         self.disconnected = True
+ *         (<UVProcessTransport>self.proc)._pipe_connection_lost(self.fd, exc)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_7connection_lost(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto_6connection_lost[] = "WriteSubprocessPipeProto.connection_lost(self, exc)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_7connection_lost = {"connection_lost", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_7connection_lost, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto_6connection_lost};
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_7connection_lost(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_exc = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connection_lost (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self_2,&__pyx_n_s_exc,0};
+    PyObject* values[2] = {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  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_self_2)) != 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_exc)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("connection_lost", 1, 2, 2, 1); __PYX_ERR(4, 712, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "connection_lost") < 0)) __PYX_ERR(4, 712, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_exc = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("connection_lost", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(4, 712, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.WriteSubprocessPipeProto.connection_lost", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_6connection_lost(__pyx_self, __pyx_v_self, __pyx_v_exc);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_6connection_lost(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_exc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("connection_lost", 0);
+
+  /* "uvloop/handles/process.pyx":713
+ * 
+ *     def connection_lost(self, exc):
+ *         self.disconnected = True             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._pipe_connection_lost(self.fd, exc)
+ *         self.proc = None
+ */
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_disconnected, Py_True) < 0) __PYX_ERR(4, 713, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":714
+ *     def connection_lost(self, exc):
+ *         self.disconnected = True
+ *         (<UVProcessTransport>self.proc)._pipe_connection_lost(self.fd, exc)             # <<<<<<<<<<<<<<
+ *         self.proc = None
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_proc); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 714, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 714, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 714, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_t_1)->__pyx_base.__pyx_base.__pyx_vtab)->_pipe_connection_lost(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_t_1), __pyx_t_3, __pyx_v_exc); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 714, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/process.pyx":715
+ *         self.disconnected = True
+ *         (<UVProcessTransport>self.proc)._pipe_connection_lost(self.fd, exc)
+ *         self.proc = None             # <<<<<<<<<<<<<<
+ * 
+ *     def pause_writing(self):
+ */
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_proc, Py_None) < 0) __PYX_ERR(4, 715, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":712
+ *                 % (self.__class__.__name__, self.fd, self.pipe))
+ * 
+ *     def connection_lost(self, exc):             # <<<<<<<<<<<<<<
+ *         self.disconnected = True
+ *         (<UVProcessTransport>self.proc)._pipe_connection_lost(self.fd, exc)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.WriteSubprocessPipeProto.connection_lost", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":717
+ *         self.proc = None
+ * 
+ *     def pause_writing(self):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._protocol.pause_writing()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_9pause_writing(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static char __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto_8pause_writing[] = "WriteSubprocessPipeProto.pause_writing(self)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_9pause_writing = {"pause_writing", (PyCFunction)__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_9pause_writing, METH_O, __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto_8pause_writing};
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_9pause_writing(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("pause_writing (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_8pause_writing(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_8pause_writing(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("pause_writing", 0);
+
+  /* "uvloop/handles/process.pyx":718
+ * 
+ *     def pause_writing(self):
+ *         (<UVProcessTransport>self.proc)._protocol.pause_writing()             # <<<<<<<<<<<<<<
+ * 
+ *     def resume_writing(self):
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_proc); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 718, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_t_2)->_protocol, __pyx_n_s_pause_writing); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 718, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 718, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":717
+ *         self.proc = None
+ * 
+ *     def pause_writing(self):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._protocol.pause_writing()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.WriteSubprocessPipeProto.pause_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":720
+ *         (<UVProcessTransport>self.proc)._protocol.pause_writing()
+ * 
+ *     def resume_writing(self):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._protocol.resume_writing()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_11resume_writing(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static char __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto_10resume_writing[] = "WriteSubprocessPipeProto.resume_writing(self)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_11resume_writing = {"resume_writing", (PyCFunction)__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_11resume_writing, METH_O, __pyx_doc_6uvloop_4loop_24WriteSubprocessPipeProto_10resume_writing};
+static PyObject *__pyx_pw_6uvloop_4loop_24WriteSubprocessPipeProto_11resume_writing(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resume_writing (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_10resume_writing(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_10resume_writing(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("resume_writing", 0);
+
+  /* "uvloop/handles/process.pyx":721
+ * 
+ *     def resume_writing(self):
+ *         (<UVProcessTransport>self.proc)._protocol.resume_writing()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_proc); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 721, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_t_2)->_protocol, __pyx_n_s_resume_writing); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 721, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 721, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/process.pyx":720
+ *         (<UVProcessTransport>self.proc)._protocol.pause_writing()
+ * 
+ *     def resume_writing(self):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._protocol.resume_writing()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.WriteSubprocessPipeProto.resume_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":727
+ *                               aio_Protocol):
+ * 
+ *     def data_received(self, data):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._pipe_data_received(self.fd, data)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_23ReadSubprocessPipeProto_1data_received(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_23ReadSubprocessPipeProto_data_received[] = "ReadSubprocessPipeProto.data_received(self, data)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_23ReadSubprocessPipeProto_1data_received = {"data_received", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_23ReadSubprocessPipeProto_1data_received, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_23ReadSubprocessPipeProto_data_received};
+static PyObject *__pyx_pw_6uvloop_4loop_23ReadSubprocessPipeProto_1data_received(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_data = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("data_received (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self_2,&__pyx_n_s_data,0};
+    PyObject* values[2] = {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  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_self_2)) != 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_data)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("data_received", 1, 2, 2, 1); __PYX_ERR(4, 727, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "data_received") < 0)) __PYX_ERR(4, 727, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_data = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("data_received", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(4, 727, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.ReadSubprocessPipeProto.data_received", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_23ReadSubprocessPipeProto_data_received(__pyx_self, __pyx_v_self, __pyx_v_data);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_23ReadSubprocessPipeProto_data_received(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_data) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("data_received", 0);
+
+  /* "uvloop/handles/process.pyx":728
+ * 
+ *     def data_received(self, data):
+ *         (<UVProcessTransport>self.proc)._pipe_data_received(self.fd, data)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_proc); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 728, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 728, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 728, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *)((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_t_1)->__pyx_base.__pyx_base.__pyx_vtab)->_pipe_data_received(((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_t_1), __pyx_t_3, __pyx_v_data); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 728, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/process.pyx":727
+ *                               aio_Protocol):
+ * 
+ *     def data_received(self, data):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._pipe_data_received(self.fd, data)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.ReadSubprocessPipeProto.data_received", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":731
+ * 
+ * 
+ * cdef __process_convert_fileno(object obj):             # <<<<<<<<<<<<<<
+ *     if obj is None or isinstance(obj, int):
+ *         return obj
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___process_convert_fileno(PyObject *__pyx_v_obj) {
+  PyObject *__pyx_v_fileno = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__process_convert_fileno", 0);
+
+  /* "uvloop/handles/process.pyx":732
+ * 
+ * cdef __process_convert_fileno(object obj):
+ *     if obj is None or isinstance(obj, int):             # <<<<<<<<<<<<<<
+ *         return obj
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_obj == 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;
+  }
+  __pyx_t_3 = PyInt_Check(__pyx_v_obj); 
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":733
+ * cdef __process_convert_fileno(object obj):
+ *     if obj is None or isinstance(obj, int):
+ *         return obj             # <<<<<<<<<<<<<<
+ * 
+ *     fileno = obj.fileno()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_obj);
+    __pyx_r = __pyx_v_obj;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/process.pyx":732
+ * 
+ * cdef __process_convert_fileno(object obj):
+ *     if obj is None or isinstance(obj, int):             # <<<<<<<<<<<<<<
+ *         return obj
+ * 
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":735
+ *         return obj
+ * 
+ *     fileno = obj.fileno()             # <<<<<<<<<<<<<<
+ *     if not isinstance(fileno, int):
+ *         raise TypeError(
+ */
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_fileno); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 735, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __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_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  __pyx_t_4 = (__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_4)) __PYX_ERR(4, 735, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_fileno = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "uvloop/handles/process.pyx":736
+ * 
+ *     fileno = obj.fileno()
+ *     if not isinstance(fileno, int):             # <<<<<<<<<<<<<<
+ *         raise TypeError(
+ *             '{!r}.fileno() returned non-integer'.format(obj))
+ */
+  __pyx_t_1 = PyInt_Check(__pyx_v_fileno); 
+  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/process.pyx":738
+ *     if not isinstance(fileno, int):
+ *         raise TypeError(
+ *             '{!r}.fileno() returned non-integer'.format(obj))             # <<<<<<<<<<<<<<
+ *     return fileno
+ * 
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_r_fileno_returned_non_integer, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 738, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_v_obj) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_obj);
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 738, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/handles/process.pyx":737
+ *     fileno = obj.fileno()
+ *     if not isinstance(fileno, int):
+ *         raise TypeError(             # <<<<<<<<<<<<<<
+ *             '{!r}.fileno() returned non-integer'.format(obj))
+ *     return fileno
+ */
+    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 737, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __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(4, 737, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":736
+ * 
+ *     fileno = obj.fileno()
+ *     if not isinstance(fileno, int):             # <<<<<<<<<<<<<<
+ *         raise TypeError(
+ *             '{!r}.fileno() returned non-integer'.format(obj))
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":739
+ *         raise TypeError(
+ *             '{!r}.fileno() returned non-integer'.format(obj))
+ *     return fileno             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_fileno);
+  __pyx_r = __pyx_v_fileno;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":731
+ * 
+ * 
+ * cdef __process_convert_fileno(object obj):             # <<<<<<<<<<<<<<
+ *     if obj is None or isinstance(obj, int):
+ *         return obj
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.__process_convert_fileno", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fileno);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":742
+ * 
+ * 
+ * cdef void __uvprocess_on_exit_callback(uv.uv_process_t *handle,             # <<<<<<<<<<<<<<
+ *                                        int64_t exit_status,
+ *                                        int term_signal) with gil:
+ */
+
+static void __pyx_f_6uvloop_4loop___uvprocess_on_exit_callback(uv_process_t *__pyx_v_handle, int64_t __pyx_v_exit_status, int __pyx_v_term_signal) {
+  struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_proc = 0;
+  PyObject *__pyx_v_ex = NULL;
+  __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;
+  int __pyx_t_10;
+  char const *__pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uvprocess_on_exit_callback", 0);
+
+  /* "uvloop/handles/process.pyx":747
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,
+ *                             "UVProcess exit callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_f_6uvloop_4loop___ensure_handle_data(((uv_handle_t *)__pyx_v_handle), ((char const *)"UVProcess exit callback")) == 0) != 0);
+
+  /* "uvloop/handles/process.pyx":746
+ *                                        int term_signal) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,             # <<<<<<<<<<<<<<
+ *                             "UVProcess exit callback") == 0:
+ *         return
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/process.pyx":748
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,
+ *                             "UVProcess exit callback") == 0:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef UVProcess proc = <UVProcess> handle.data
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/process.pyx":746
+ *                                        int term_signal) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,             # <<<<<<<<<<<<<<
+ *                             "UVProcess exit callback") == 0:
+ *         return
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":750
+ *         return
+ * 
+ *     cdef UVProcess proc = <UVProcess> handle.data             # <<<<<<<<<<<<<<
+ *     try:
+ *         proc._on_exit(exit_status, term_signal)
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_handle->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_proc = ((struct __pyx_obj_6uvloop_4loop_UVProcess *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/process.pyx":751
+ * 
+ *     cdef UVProcess proc = <UVProcess> handle.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         proc._on_exit(exit_status, term_signal)
+ *     except BaseException as ex:
+ */
+  {
+    __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:*/ {
+
+      /* "uvloop/handles/process.pyx":752
+ *     cdef UVProcess proc = <UVProcess> handle.data
+ *     try:
+ *         proc._on_exit(exit_status, term_signal)             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         proc._error(ex, False)
+ */
+      __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_proc->__pyx_base.__pyx_vtab)->_on_exit(__pyx_v_proc, __pyx_v_exit_status, __pyx_v_term_signal); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 752, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/process.pyx":751
+ * 
+ *     cdef UVProcess proc = <UVProcess> handle.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         proc._on_exit(exit_status, term_signal)
+ *     except BaseException as ex:
+ */
+    }
+    __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;
+
+    /* "uvloop/handles/process.pyx":753
+ *     try:
+ *         proc._on_exit(exit_status, term_signal)
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         proc._error(ex, False)
+ * 
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("uvloop.loop.__uvprocess_on_exit_callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(4, 753, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_7);
+      __pyx_v_ex = __pyx_t_7;
+      /*try:*/ {
+
+        /* "uvloop/handles/process.pyx":754
+ *         proc._on_exit(exit_status, term_signal)
+ *     except BaseException as ex:
+ *         proc._error(ex, False)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+        __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_proc->__pyx_base.__pyx_vtab)->__pyx_base._error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_proc), __pyx_v_ex, Py_False); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 754, __pyx_L15_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      }
+
+      /* "uvloop/handles/process.pyx":753
+ *     try:
+ *         proc._on_exit(exit_status, term_signal)
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         proc._error(ex, False)
+ * 
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L16;
+        }
+        __pyx_L15_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_12);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __pyx_t_6 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+          }
+          __Pyx_XGIVEREF(__pyx_t_12);
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+          __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
+          __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
+          goto __pyx_L6_except_error;
+        }
+        __pyx_L16:;
+      }
+      __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;
+      goto __pyx_L5_exception_handled;
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/handles/process.pyx":751
+ * 
+ *     cdef UVProcess proc = <UVProcess> handle.data
+ *     try:             # <<<<<<<<<<<<<<
+ *         proc._on_exit(exit_status, term_signal)
+ *     except BaseException as ex:
+ */
+    __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_L5_exception_handled:;
+    __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);
+    __pyx_L9_try_end:;
+  }
+
+  /* "uvloop/handles/process.pyx":742
+ * 
+ * 
+ * cdef void __uvprocess_on_exit_callback(uv.uv_process_t *handle,             # <<<<<<<<<<<<<<
+ *                                        int64_t exit_status,
+ *                                        int term_signal) with gil:
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_WriteUnraisable("uvloop.loop.__uvprocess_on_exit_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_proc);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/process.pyx":757
+ * 
+ * 
+ * cdef __socketpair():             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int fds[2]
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___socketpair(void) {
+  int __pyx_v_fds[2];
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__socketpair", 0);
+
+  /* "uvloop/handles/process.pyx":762
+ *         int err
+ * 
+ *     err = system.socketpair(uv.AF_UNIX, uv.SOCK_STREAM, 0, fds)             # <<<<<<<<<<<<<<
+ *     if err:
+ *         exc = convert_error(-err)
+ */
+  __pyx_v_err = socketpair(AF_UNIX, SOCK_STREAM, 0, __pyx_v_fds);
+
+  /* "uvloop/handles/process.pyx":763
+ * 
+ *     err = system.socketpair(uv.AF_UNIX, uv.SOCK_STREAM, 0, fds)
+ *     if err:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(-err)
+ *         raise exc
+ */
+  __pyx_t_1 = (__pyx_v_err != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/process.pyx":764
+ *     err = system.socketpair(uv.AF_UNIX, uv.SOCK_STREAM, 0, fds)
+ *     if err:
+ *         exc = convert_error(-err)             # <<<<<<<<<<<<<<
+ *         raise exc
+ * 
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error((-__pyx_v_err)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 764, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/process.pyx":765
+ *     if err:
+ *         exc = convert_error(-err)
+ *         raise exc             # <<<<<<<<<<<<<<
+ * 
+ *     os_set_inheritable(fds[0], False)
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(4, 765, __pyx_L1_error)
+
+    /* "uvloop/handles/process.pyx":763
+ * 
+ *     err = system.socketpair(uv.AF_UNIX, uv.SOCK_STREAM, 0, fds)
+ *     if err:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(-err)
+ *         raise exc
+ */
+  }
+
+  /* "uvloop/handles/process.pyx":767
+ *         raise exc
+ * 
+ *     os_set_inheritable(fds[0], False)             # <<<<<<<<<<<<<<
+ *     os_set_inheritable(fds[1], False)
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_fds[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 767, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+  __pyx_t_4 = __pyx_v_6uvloop_4loop_os_set_inheritable; __pyx_t_5 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && 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);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, Py_False};
+    __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(4, 767, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __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_5, __pyx_t_3, Py_False};
+    __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(4, 767, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __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(4, 767, __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_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+    __Pyx_INCREF(Py_False);
+    __Pyx_GIVEREF(Py_False);
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, Py_False);
+    __pyx_t_3 = 0;
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 767, __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_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/process.pyx":768
+ * 
+ *     os_set_inheritable(fds[0], False)
+ *     os_set_inheritable(fds[1], False)             # <<<<<<<<<<<<<<
+ * 
+ *     return fds[0], fds[1]
+ */
+  __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_fds[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 768, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+  __pyx_t_7 = __pyx_v_6uvloop_4loop_os_set_inheritable; __pyx_t_3 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_7, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_7)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_4, Py_False};
+    __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 768, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 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_7)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_4, Py_False};
+    __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 768, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_5 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 768, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (__pyx_t_3) {
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_6, __pyx_t_4);
+    __Pyx_INCREF(Py_False);
+    __Pyx_GIVEREF(Py_False);
+    PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, Py_False);
+    __pyx_t_4 = 0;
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 768, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/process.pyx":770
+ *     os_set_inheritable(fds[1], False)
+ * 
+ *     return fds[0], fds[1]             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyInt_From_int((__pyx_v_fds[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 770, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_7 = __Pyx_PyInt_From_int((__pyx_v_fds[1])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 770, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 770, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_7);
+  __pyx_t_2 = 0;
+  __pyx_t_7 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/process.pyx":757
+ * 
+ * 
+ * cdef __socketpair():             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int fds[2]
+ */
+
+  /* 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_7);
+  __Pyx_AddTraceback("uvloop.loop.__socketpair", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/process.pyx":773
+ * 
+ * 
+ * cdef void __uv_close_process_handle_cb(uv.uv_handle_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     PyMem_RawFree(handle)
+ */
+
+static void __pyx_f_6uvloop_4loop___uv_close_process_handle_cb(uv_handle_t *__pyx_v_handle) {
+  __Pyx_RefNannyDeclarations
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uv_close_process_handle_cb", 0);
+
+  /* "uvloop/handles/process.pyx":774
+ * 
+ * cdef void __uv_close_process_handle_cb(uv.uv_handle_t* handle) with gil:
+ *     PyMem_RawFree(handle)             # <<<<<<<<<<<<<<
+ */
+  PyMem_RawFree(__pyx_v_handle);
+
+  /* "uvloop/handles/process.pyx":773
+ * 
+ * 
+ * cdef void __uv_close_process_handle_cb(uv.uv_handle_t* handle) with gil:             # <<<<<<<<<<<<<<
+ *     PyMem_RawFree(handle)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/request.pyx":10
+ *     """
+ * 
+ *     def __cinit__(self, Loop loop, *_):             # <<<<<<<<<<<<<<
+ *         self.request = NULL
+ *         self.loop = loop
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_9UVRequest_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_9UVRequest_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  CYTHON_UNUSED PyObject *__pyx_v__ = 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 (PyTuple_GET_SIZE(__pyx_args) > 1) {
+    __pyx_v__ = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args));
+    if (unlikely(!__pyx_v__)) {
+      __Pyx_RefNannyFinishContext();
+      return -1;
+    }
+    __Pyx_GOTREF(__pyx_v__);
+  } else {
+    __pyx_v__ = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
+  }
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,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) {
+        default:
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "__cinit__") < 0)) __PYX_ERR(21, 10, __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_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 10, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_DECREF(__pyx_v__); __pyx_v__ = 0;
+  __Pyx_AddTraceback("uvloop.loop.UVRequest.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6uvloop_4loop_Loop, 1, "loop", 0))) __PYX_ERR(21, 10, __pyx_L1_error)
+  __pyx_r = __pyx_pf_6uvloop_4loop_9UVRequest___cinit__(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_self), __pyx_v_loop, __pyx_v__);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v__);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_9UVRequest___cinit__(struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, CYTHON_UNUSED PyObject *__pyx_v__) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "uvloop/request.pyx":11
+ * 
+ *     def __cinit__(self, Loop loop, *_):
+ *         self.request = NULL             # <<<<<<<<<<<<<<
+ *         self.loop = loop
+ *         self.done = 0
+ */
+  __pyx_v_self->request = NULL;
+
+  /* "uvloop/request.pyx":12
+ *     def __cinit__(self, Loop loop, *_):
+ *         self.request = NULL
+ *         self.loop = loop             # <<<<<<<<<<<<<<
+ *         self.done = 0
+ *         Py_INCREF(self)
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GOTREF(__pyx_v_self->loop);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->loop));
+  __pyx_v_self->loop = __pyx_v_loop;
+
+  /* "uvloop/request.pyx":13
+ *         self.request = NULL
+ *         self.loop = loop
+ *         self.done = 0             # <<<<<<<<<<<<<<
+ *         Py_INCREF(self)
+ * 
+ */
+  __pyx_v_self->done = 0;
+
+  /* "uvloop/request.pyx":14
+ *         self.loop = loop
+ *         self.done = 0
+ *         Py_INCREF(self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef on_done(self):
+ */
+  Py_INCREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/request.pyx":10
+ *     """
+ * 
+ *     def __cinit__(self, Loop loop, *_):             # <<<<<<<<<<<<<<
+ *         self.request = NULL
+ *         self.loop = loop
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/request.pyx":16
+ *         Py_INCREF(self)
+ * 
+ *     cdef on_done(self):             # <<<<<<<<<<<<<<
+ *         self.done = 1
+ *         Py_DECREF(self)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVRequest_on_done(struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("on_done", 0);
+
+  /* "uvloop/request.pyx":17
+ * 
+ *     cdef on_done(self):
+ *         self.done = 1             # <<<<<<<<<<<<<<
+ *         Py_DECREF(self)
+ * 
+ */
+  __pyx_v_self->done = 1;
+
+  /* "uvloop/request.pyx":18
+ *     cdef on_done(self):
+ *         self.done = 1
+ *         Py_DECREF(self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef cancel(self):
+ */
+  Py_DECREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/request.pyx":16
+ *         Py_INCREF(self)
+ * 
+ *     cdef on_done(self):             # <<<<<<<<<<<<<<
+ *         self.done = 1
+ *         Py_DECREF(self)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/request.pyx":20
+ *         Py_DECREF(self)
+ * 
+ *     cdef cancel(self):             # <<<<<<<<<<<<<<
+ *         # Most requests are implemented using a threadpool.  It's only
+ *         # possible to cancel a request when it's still in a threadpool's
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_9UVRequest_cancel(struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("cancel", 0);
+
+  /* "uvloop/request.pyx":29
+ *         cdef int err
+ * 
+ *         if self.done == 1:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->done == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/request.pyx":30
+ * 
+ *         if self.done == 1:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if UVLOOP_DEBUG:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/request.pyx":29
+ *         cdef int err
+ * 
+ *         if self.done == 1:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/request.pyx":32
+ *             return
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if self.request is NULL:
+ *                 raise RuntimeError(
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/request.pyx":33
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if self.request is NULL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request is NULL'.format(
+ */
+    __pyx_t_1 = ((__pyx_v_self->request == NULL) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/request.pyx":35
+ *             if self.request is NULL:
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request is NULL'.format(             # <<<<<<<<<<<<<<
+ *                         self.__class__.__name__))
+ * 
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cancel_request_is_NULL, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 35, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+
+      /* "uvloop/request.pyx":36
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request is NULL'.format(
+ *                         self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *             if self.request.data is NULL:
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 36, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(21, 36, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 35, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/request.pyx":34
+ *         if UVLOOP_DEBUG:
+ *             if self.request is NULL:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     '{}.cancel: .request is NULL'.format(
+ *                         self.__class__.__name__))
+ */
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 34, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(21, 34, __pyx_L1_error)
+
+      /* "uvloop/request.pyx":33
+ * 
+ *         if UVLOOP_DEBUG:
+ *             if self.request is NULL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request is NULL'.format(
+ */
+    }
+
+    /* "uvloop/request.pyx":38
+ *                         self.__class__.__name__))
+ * 
+ *             if self.request.data is NULL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request.data is NULL'.format(
+ */
+    __pyx_t_1 = ((__pyx_v_self->request->data == NULL) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/request.pyx":40
+ *             if self.request.data is NULL:
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request.data is NULL'.format(             # <<<<<<<<<<<<<<
+ *                         self.__class__.__name__))
+ * 
+ */
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cancel_request_data_is_NULL, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 40, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+
+      /* "uvloop/request.pyx":41
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request.data is NULL'.format(
+ *                         self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *             if <UVRequest>self.request.data is not self:
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(21, 41, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 41, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+        if (likely(__pyx_t_5)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+          __Pyx_INCREF(__pyx_t_5);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_2, function);
+        }
+      }
+      __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __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_3)) __PYX_ERR(21, 40, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/request.pyx":39
+ * 
+ *             if self.request.data is NULL:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     '{}.cancel: .request.data is NULL'.format(
+ *                         self.__class__.__name__))
+ */
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 39, __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(21, 39, __pyx_L1_error)
+
+      /* "uvloop/request.pyx":38
+ *                         self.__class__.__name__))
+ * 
+ *             if self.request.data is NULL:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request.data is NULL'.format(
+ */
+    }
+
+    /* "uvloop/request.pyx":43
+ *                         self.__class__.__name__))
+ * 
+ *             if <UVRequest>self.request.data is not self:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request.data is not UVRequest'.format(
+ */
+    __pyx_t_1 = (((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_self->request->data) != __pyx_v_self);
+    __pyx_t_6 = (__pyx_t_1 != 0);
+    if (unlikely(__pyx_t_6)) {
+
+      /* "uvloop/request.pyx":45
+ *             if <UVRequest>self.request.data is not self:
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request.data is not UVRequest'.format(             # <<<<<<<<<<<<<<
+ *                         self.__class__.__name__))
+ * 
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cancel_request_data_is_not_UVRe, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 45, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+
+      /* "uvloop/request.pyx":46
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request.data is not UVRequest'.format(
+ *                         self.__class__.__name__))             # <<<<<<<<<<<<<<
+ * 
+ *         # We only can cancel pending requests.  Let's try.
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 46, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(21, 46, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 45, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/request.pyx":44
+ * 
+ *             if <UVRequest>self.request.data is not self:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     '{}.cancel: .request.data is not UVRequest'.format(
+ *                         self.__class__.__name__))
+ */
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 44, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(21, 44, __pyx_L1_error)
+
+      /* "uvloop/request.pyx":43
+ *                         self.__class__.__name__))
+ * 
+ *             if <UVRequest>self.request.data is not self:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     '{}.cancel: .request.data is not UVRequest'.format(
+ */
+    }
+
+    /* "uvloop/request.pyx":32
+ *             return
+ * 
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if self.request is NULL:
+ *                 raise RuntimeError(
+ */
+  }
+
+  /* "uvloop/request.pyx":49
+ * 
+ *         # We only can cancel pending requests.  Let's try.
+ *         err = uv.uv_cancel(self.request)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             if err == uv.UV_EBUSY:
+ */
+  __pyx_v_err = uv_cancel(__pyx_v_self->request);
+
+  /* "uvloop/request.pyx":50
+ *         # We only can cancel pending requests.  Let's try.
+ *         err = uv.uv_cancel(self.request)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             if err == uv.UV_EBUSY:
+ *                 # Can't close the request -- it's executing (see the first
+ */
+  __pyx_t_6 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_6) {
+
+    /* "uvloop/request.pyx":51
+ *         err = uv.uv_cancel(self.request)
+ *         if err < 0:
+ *             if err == uv.UV_EBUSY:             # <<<<<<<<<<<<<<
+ *                 # Can't close the request -- it's executing (see the first
+ *                 # comment).  Loop will have to wait until the callback
+ */
+    __pyx_t_6 = ((__pyx_v_err == UV_EBUSY) != 0);
+    if (__pyx_t_6) {
+      goto __pyx_L9;
+    }
+
+    /* "uvloop/request.pyx":56
+ *                 # fires.
+ *                 pass
+ *             elif err == uv.UV_EINVAL:             # <<<<<<<<<<<<<<
+ *                 # From libuv docs:
+ *                 #
+ */
+    __pyx_t_6 = ((__pyx_v_err == UV_EINVAL) != 0);
+    if (__pyx_t_6) {
+
+      /* "uvloop/request.pyx":62
+ *                 #     uv_getnameinfo_t and uv_work_t requests is currently
+ *                 #     supported.
+ *                 return             # <<<<<<<<<<<<<<
+ *             else:
+ *                 ex = convert_error(err)
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      goto __pyx_L0;
+
+      /* "uvloop/request.pyx":56
+ *                 # fires.
+ *                 pass
+ *             elif err == uv.UV_EINVAL:             # <<<<<<<<<<<<<<
+ *                 # From libuv docs:
+ *                 #
+ */
+    }
+
+    /* "uvloop/request.pyx":64
+ *                 return
+ *             else:
+ *                 ex = convert_error(err)             # <<<<<<<<<<<<<<
+ *                 self.loop._handle_exception(ex)
+ */
+    /*else*/ {
+      __pyx_t_3 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 64, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_v_ex = __pyx_t_3;
+      __pyx_t_3 = 0;
+
+      /* "uvloop/request.pyx":65
+ *             else:
+ *                 ex = convert_error(err)
+ *                 self.loop._handle_exception(ex)             # <<<<<<<<<<<<<<
+ */
+      ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->loop->__pyx_vtab)->_handle_exception(__pyx_v_self->loop, __pyx_v_ex);
+    }
+    __pyx_L9:;
+
+    /* "uvloop/request.pyx":50
+ *         # We only can cancel pending requests.  Let's try.
+ *         err = uv.uv_cancel(self.request)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             if err == uv.UV_EBUSY:
+ *                 # Can't close the request -- it's executing (see the first
+ */
+  }
+
+  /* "uvloop/request.pyx":20
+ *         Py_DECREF(self)
+ * 
+ *     cdef cancel(self):             # <<<<<<<<<<<<<<
+ *         # Most requests are implemented using a threadpool.  It's only
+ *         # possible to cancel a request when it's still in a threadpool's
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UVRequest.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ex);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_9UVRequest_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_9UVRequest_2__reduce_cython__[] = "UVRequest.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_9UVRequest_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_6uvloop_4loop_9UVRequest_2__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_9UVRequest_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVRequest *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__196, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVRequest.__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_6uvloop_4loop_9UVRequest_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_9UVRequest_4__setstate_cython__[] = "UVRequest.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_9UVRequest_5__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_6uvloop_4loop_9UVRequest_4__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_9UVRequest_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVRequest *__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);
+
+  /* "(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__197, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UVRequest.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":1
+ * cdef __port_to_int(port, proto):             # <<<<<<<<<<<<<<
+ *     if type(port) is int:
+ *         return port
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___port_to_int(PyObject *__pyx_v_port, PyObject *__pyx_v_proto) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__port_to_int", 0);
+  __Pyx_INCREF(__pyx_v_port);
+
+  /* "uvloop/dns.pyx":2
+ * cdef __port_to_int(port, proto):
+ *     if type(port) is int:             # <<<<<<<<<<<<<<
+ *         return port
+ * 
+ */
+  __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_port)) == ((PyObject *)(&PyInt_Type)));
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/dns.pyx":3
+ * cdef __port_to_int(port, proto):
+ *     if type(port) is int:
+ *         return port             # <<<<<<<<<<<<<<
+ * 
+ *     if port is None or port == '' or port == b'':
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_port);
+    __pyx_r = __pyx_v_port;
+    goto __pyx_L0;
+
+    /* "uvloop/dns.pyx":2
+ * cdef __port_to_int(port, proto):
+ *     if type(port) is int:             # <<<<<<<<<<<<<<
+ *         return port
+ * 
+ */
+  }
+
+  /* "uvloop/dns.pyx":5
+ *         return port
+ * 
+ *     if port is None or port == '' or port == b'':             # <<<<<<<<<<<<<<
+ *         return 0
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_port == Py_None);
+  __pyx_t_3 = (__pyx_t_1 != 0);
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_port, __pyx_kp_u__8, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(5, 5, __pyx_L1_error)
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_3 = (__Pyx_PyBytes_Equals(__pyx_v_port, __pyx_kp_b__8, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(5, 5, __pyx_L1_error)
+  __pyx_t_2 = __pyx_t_3;
+  __pyx_L5_bool_binop_done:;
+  if (__pyx_t_2) {
+
+    /* "uvloop/dns.pyx":6
+ * 
+ *     if port is None or port == '' or port == b'':
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_int_0);
+    __pyx_r = __pyx_int_0;
+    goto __pyx_L0;
+
+    /* "uvloop/dns.pyx":5
+ *         return port
+ * 
+ *     if port is None or port == '' or port == b'':             # <<<<<<<<<<<<<<
+ *         return 0
+ * 
+ */
+  }
+
+  /* "uvloop/dns.pyx":8
+ *         return 0
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         return int(port)
+ *     except (ValueError, TypeError):
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_6);
+    /*try:*/ {
+
+      /* "uvloop/dns.pyx":9
+ * 
+ *     try:
+ *         return int(port)             # <<<<<<<<<<<<<<
+ *     except (ValueError, TypeError):
+ *         pass
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_t_7 = __Pyx_PyNumber_Int(__pyx_v_port); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 9, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_r = __pyx_t_7;
+      __pyx_t_7 = 0;
+      goto __pyx_L12_try_return;
+
+      /* "uvloop/dns.pyx":8
+ *         return 0
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         return int(port)
+ *     except (ValueError, TypeError):
+ */
+    }
+    __pyx_L8_error:;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/dns.pyx":10
+ *     try:
+ *         return int(port)
+ *     except (ValueError, TypeError):             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError);
+    if (__pyx_t_8) {
+      __Pyx_ErrRestore(0,0,0);
+      goto __pyx_L9_exception_handled;
+    }
+    goto __pyx_L10_except_error;
+    __pyx_L10_except_error:;
+
+    /* "uvloop/dns.pyx":8
+ *         return 0
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         return int(port)
+ *     except (ValueError, TypeError):
+ */
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L1_error;
+    __pyx_L12_try_return:;
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+    goto __pyx_L0;
+    __pyx_L9_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+  }
+
+  /* "uvloop/dns.pyx":13
+ *         pass
+ * 
+ *     if isinstance(port, bytes):             # <<<<<<<<<<<<<<
+ *         port = port.decode()
+ * 
+ */
+  __pyx_t_2 = PyBytes_Check(__pyx_v_port); 
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/dns.pyx":14
+ * 
+ *     if isinstance(port, bytes):
+ *         port = port.decode()             # <<<<<<<<<<<<<<
+ * 
+ *     if isinstance(port, str) and proto is not None:
+ */
+    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_port, __pyx_n_s_decode); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_10 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) {
+      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9);
+      if (likely(__pyx_t_10)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+        __Pyx_INCREF(__pyx_t_10);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_9, function);
+      }
+    }
+    __pyx_t_7 = (__pyx_t_10) ? __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_10) : __Pyx_PyObject_CallNoArg(__pyx_t_9);
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF_SET(__pyx_v_port, __pyx_t_7);
+    __pyx_t_7 = 0;
+
+    /* "uvloop/dns.pyx":13
+ *         pass
+ * 
+ *     if isinstance(port, bytes):             # <<<<<<<<<<<<<<
+ *         port = port.decode()
+ * 
+ */
+  }
+
+  /* "uvloop/dns.pyx":16
+ *         port = port.decode()
+ * 
+ *     if isinstance(port, str) and proto is not None:             # <<<<<<<<<<<<<<
+ *         if proto == uv.IPPROTO_TCP:
+ *             return socket_getservbyname(port, 'tcp')
+ */
+  __pyx_t_2 = PyUnicode_Check(__pyx_v_port); 
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+  } else {
+    __pyx_t_3 = __pyx_t_1;
+    goto __pyx_L16_bool_binop_done;
+  }
+  __pyx_t_1 = (__pyx_v_proto != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  __pyx_t_3 = __pyx_t_2;
+  __pyx_L16_bool_binop_done:;
+  if (__pyx_t_3) {
+
+    /* "uvloop/dns.pyx":17
+ * 
+ *     if isinstance(port, str) and proto is not None:
+ *         if proto == uv.IPPROTO_TCP:             # <<<<<<<<<<<<<<
+ *             return socket_getservbyname(port, 'tcp')
+ *         elif proto == uv.IPPROTO_UDP:
+ */
+    __pyx_t_7 = __Pyx_PyInt_From_int(IPPROTO_TCP); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 17, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_9 = PyObject_RichCompare(__pyx_v_proto, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 17, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(5, 17, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    if (__pyx_t_3) {
+
+      /* "uvloop/dns.pyx":18
+ *     if isinstance(port, str) and proto is not None:
+ *         if proto == uv.IPPROTO_TCP:
+ *             return socket_getservbyname(port, 'tcp')             # <<<<<<<<<<<<<<
+ *         elif proto == uv.IPPROTO_UDP:
+ *             return socket_getservbyname(port, 'udp')
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_getservbyname);
+      __pyx_t_7 = __pyx_v_6uvloop_4loop_socket_getservbyname; __pyx_t_10 = NULL;
+      __pyx_t_8 = 0;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+        __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7);
+        if (likely(__pyx_t_10)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+          __Pyx_INCREF(__pyx_t_10);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_7, function);
+          __pyx_t_8 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_7)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_port, __pyx_n_u_tcp};
+        __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 18, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_GOTREF(__pyx_t_9);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_port, __pyx_n_u_tcp};
+        __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 18, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_GOTREF(__pyx_t_9);
+      } else
+      #endif
+      {
+        __pyx_t_11 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(5, 18, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        if (__pyx_t_10) {
+          __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL;
+        }
+        __Pyx_INCREF(__pyx_v_port);
+        __Pyx_GIVEREF(__pyx_v_port);
+        PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_8, __pyx_v_port);
+        __Pyx_INCREF(__pyx_n_u_tcp);
+        __Pyx_GIVEREF(__pyx_n_u_tcp);
+        PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_8, __pyx_n_u_tcp);
+        __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_11, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 18, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __pyx_r = __pyx_t_9;
+      __pyx_t_9 = 0;
+      goto __pyx_L0;
+
+      /* "uvloop/dns.pyx":17
+ * 
+ *     if isinstance(port, str) and proto is not None:
+ *         if proto == uv.IPPROTO_TCP:             # <<<<<<<<<<<<<<
+ *             return socket_getservbyname(port, 'tcp')
+ *         elif proto == uv.IPPROTO_UDP:
+ */
+    }
+
+    /* "uvloop/dns.pyx":19
+ *         if proto == uv.IPPROTO_TCP:
+ *             return socket_getservbyname(port, 'tcp')
+ *         elif proto == uv.IPPROTO_UDP:             # <<<<<<<<<<<<<<
+ *             return socket_getservbyname(port, 'udp')
+ * 
+ */
+    __pyx_t_9 = __Pyx_PyInt_From_int(IPPROTO_UDP); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 19, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_7 = PyObject_RichCompare(__pyx_v_proto, __pyx_t_9, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 19, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(5, 19, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (__pyx_t_3) {
+
+      /* "uvloop/dns.pyx":20
+ *             return socket_getservbyname(port, 'tcp')
+ *         elif proto == uv.IPPROTO_UDP:
+ *             return socket_getservbyname(port, 'udp')             # <<<<<<<<<<<<<<
+ * 
+ *     raise OSError('service/proto not found')
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_getservbyname);
+      __pyx_t_9 = __pyx_v_6uvloop_4loop_socket_getservbyname; __pyx_t_11 = NULL;
+      __pyx_t_8 = 0;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
+        __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_9);
+        if (likely(__pyx_t_11)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+          __Pyx_INCREF(__pyx_t_11);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_9, function);
+          __pyx_t_8 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_9)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_11, __pyx_v_port, __pyx_n_u_udp};
+        __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 20, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_GOTREF(__pyx_t_7);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_11, __pyx_v_port, __pyx_n_u_udp};
+        __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 20, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_GOTREF(__pyx_t_7);
+      } else
+      #endif
+      {
+        __pyx_t_10 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(5, 20, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        if (__pyx_t_11) {
+          __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_11); __pyx_t_11 = NULL;
+        }
+        __Pyx_INCREF(__pyx_v_port);
+        __Pyx_GIVEREF(__pyx_v_port);
+        PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_8, __pyx_v_port);
+        __Pyx_INCREF(__pyx_n_u_udp);
+        __Pyx_GIVEREF(__pyx_n_u_udp);
+        PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_8, __pyx_n_u_udp);
+        __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 20, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_r = __pyx_t_7;
+      __pyx_t_7 = 0;
+      goto __pyx_L0;
+
+      /* "uvloop/dns.pyx":19
+ *         if proto == uv.IPPROTO_TCP:
+ *             return socket_getservbyname(port, 'tcp')
+ *         elif proto == uv.IPPROTO_UDP:             # <<<<<<<<<<<<<<
+ *             return socket_getservbyname(port, 'udp')
+ * 
+ */
+    }
+
+    /* "uvloop/dns.pyx":16
+ *         port = port.decode()
+ * 
+ *     if isinstance(port, str) and proto is not None:             # <<<<<<<<<<<<<<
+ *         if proto == uv.IPPROTO_TCP:
+ *             return socket_getservbyname(port, 'tcp')
+ */
+  }
+
+  /* "uvloop/dns.pyx":22
+ *             return socket_getservbyname(port, 'udp')
+ * 
+ *     raise OSError('service/proto not found')             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_tuple__198, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __PYX_ERR(5, 22, __pyx_L1_error)
+
+  /* "uvloop/dns.pyx":1
+ * cdef __port_to_int(port, proto):             # <<<<<<<<<<<<<<
+ *     if type(port) is int:
+ *         return port
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("uvloop.loop.__port_to_int", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_port);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":25
+ * 
+ * 
+ * cdef __convert_sockaddr_to_pyaddr(const system.sockaddr* addr):             # <<<<<<<<<<<<<<
+ *     # Converts sockaddr structs into what Python socket
+ *     # module can understand:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___convert_sockaddr_to_pyaddr(struct sockaddr const *__pyx_v_addr) {
+  char __pyx_v_buf[0x80];
+  int __pyx_v_err;
+  struct sockaddr_in *__pyx_v_addr4;
+  struct sockaddr_in6 *__pyx_v_addr6;
+  struct sockaddr_un *__pyx_v_addr_un;
+  PyObject *__pyx_r = NULL;
+  __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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__convert_sockaddr_to_pyaddr", 0);
+
+  /* "uvloop/dns.pyx":38
+ *         system.sockaddr_un *addr_un
+ * 
+ *     if addr.sa_family == uv.AF_INET:             # <<<<<<<<<<<<<<
+ *         addr4 = <system.sockaddr_in*>addr
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_addr->sa_family == AF_INET) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/dns.pyx":39
+ * 
+ *     if addr.sa_family == uv.AF_INET:
+ *         addr4 = <system.sockaddr_in*>addr             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_ip4_name(addr4, buf, sizeof(buf))
+ */
+    __pyx_v_addr4 = ((struct sockaddr_in *)__pyx_v_addr);
+
+    /* "uvloop/dns.pyx":41
+ *         addr4 = <system.sockaddr_in*>addr
+ * 
+ *         err = uv.uv_ip4_name(addr4, buf, sizeof(buf))             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             raise convert_error(err)
+ */
+    __pyx_v_err = uv_ip4_name(__pyx_v_addr4, __pyx_v_buf, (sizeof(__pyx_v_buf)));
+
+    /* "uvloop/dns.pyx":42
+ * 
+ *         err = uv.uv_ip4_name(addr4, buf, sizeof(buf))
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/dns.pyx":43
+ *         err = uv.uv_ip4_name(addr4, buf, sizeof(buf))
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         return (
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 43, __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(5, 43, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":42
+ * 
+ *         err = uv.uv_ip4_name(addr4, buf, sizeof(buf))
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    }
+
+    /* "uvloop/dns.pyx":45
+ *             raise convert_error(err)
+ * 
+ *         return (             # <<<<<<<<<<<<<<
+ *             PyUnicode_FromString(buf),
+ *             system.ntohs(addr4.sin_port)
+ */
+    __Pyx_XDECREF(__pyx_r);
+
+    /* "uvloop/dns.pyx":46
+ * 
+ *         return (
+ *             PyUnicode_FromString(buf),             # <<<<<<<<<<<<<<
+ *             system.ntohs(addr4.sin_port)
+ *         )
+ */
+    __pyx_t_2 = PyUnicode_FromString(__pyx_v_buf); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 46, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+
+    /* "uvloop/dns.pyx":47
+ *         return (
+ *             PyUnicode_FromString(buf),
+ *             system.ntohs(addr4.sin_port)             # <<<<<<<<<<<<<<
+ *         )
+ * 
+ */
+    __pyx_t_3 = __Pyx_PyInt_From_int(ntohs(__pyx_v_addr4->sin_port)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 47, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/dns.pyx":46
+ * 
+ *         return (
+ *             PyUnicode_FromString(buf),             # <<<<<<<<<<<<<<
+ *             system.ntohs(addr4.sin_port)
+ *         )
+ */
+    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 46, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+    __pyx_t_2 = 0;
+    __pyx_t_3 = 0;
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/dns.pyx":38
+ *         system.sockaddr_un *addr_un
+ * 
+ *     if addr.sa_family == uv.AF_INET:             # <<<<<<<<<<<<<<
+ *         addr4 = <system.sockaddr_in*>addr
+ * 
+ */
+  }
+
+  /* "uvloop/dns.pyx":50
+ *         )
+ * 
+ *     elif addr.sa_family == uv.AF_INET6:             # <<<<<<<<<<<<<<
+ *         addr6 = <system.sockaddr_in6*>addr
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_addr->sa_family == AF_INET6) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/dns.pyx":51
+ * 
+ *     elif addr.sa_family == uv.AF_INET6:
+ *         addr6 = <system.sockaddr_in6*>addr             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_ip6_name(addr6, buf, sizeof(buf))
+ */
+    __pyx_v_addr6 = ((struct sockaddr_in6 *)__pyx_v_addr);
+
+    /* "uvloop/dns.pyx":53
+ *         addr6 = <system.sockaddr_in6*>addr
+ * 
+ *         err = uv.uv_ip6_name(addr6, buf, sizeof(buf))             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             raise convert_error(err)
+ */
+    __pyx_v_err = uv_ip6_name(__pyx_v_addr6, __pyx_v_buf, (sizeof(__pyx_v_buf)));
+
+    /* "uvloop/dns.pyx":54
+ * 
+ *         err = uv.uv_ip6_name(addr6, buf, sizeof(buf))
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/dns.pyx":55
+ *         err = uv.uv_ip6_name(addr6, buf, sizeof(buf))
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         return (
+ */
+      __pyx_t_4 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 55, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __PYX_ERR(5, 55, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":54
+ * 
+ *         err = uv.uv_ip6_name(addr6, buf, sizeof(buf))
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    }
+
+    /* "uvloop/dns.pyx":57
+ *             raise convert_error(err)
+ * 
+ *         return (             # <<<<<<<<<<<<<<
+ *             PyUnicode_FromString(buf),
+ *             system.ntohs(addr6.sin6_port),
+ */
+    __Pyx_XDECREF(__pyx_r);
+
+    /* "uvloop/dns.pyx":58
+ * 
+ *         return (
+ *             PyUnicode_FromString(buf),             # <<<<<<<<<<<<<<
+ *             system.ntohs(addr6.sin6_port),
+ *             system.ntohl(addr6.sin6_flowinfo),
+ */
+    __pyx_t_4 = PyUnicode_FromString(__pyx_v_buf); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 58, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "uvloop/dns.pyx":59
+ *         return (
+ *             PyUnicode_FromString(buf),
+ *             system.ntohs(addr6.sin6_port),             # <<<<<<<<<<<<<<
+ *             system.ntohl(addr6.sin6_flowinfo),
+ *             addr6.sin6_scope_id
+ */
+    __pyx_t_3 = __Pyx_PyInt_From_int(ntohs(__pyx_v_addr6->sin6_port)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 59, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/dns.pyx":60
+ *             PyUnicode_FromString(buf),
+ *             system.ntohs(addr6.sin6_port),
+ *             system.ntohl(addr6.sin6_flowinfo),             # <<<<<<<<<<<<<<
+ *             addr6.sin6_scope_id
+ *         )
+ */
+    __pyx_t_2 = __Pyx_PyInt_From_int(ntohl(__pyx_v_addr6->sin6_flowinfo)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 60, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+
+    /* "uvloop/dns.pyx":61
+ *             system.ntohs(addr6.sin6_port),
+ *             system.ntohl(addr6.sin6_flowinfo),
+ *             addr6.sin6_scope_id             # <<<<<<<<<<<<<<
+ *         )
+ * 
+ */
+    __pyx_t_5 = __Pyx_PyInt_From_unsigned_long(__pyx_v_addr6->sin6_scope_id); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 61, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+
+    /* "uvloop/dns.pyx":58
+ * 
+ *         return (
+ *             PyUnicode_FromString(buf),             # <<<<<<<<<<<<<<
+ *             system.ntohs(addr6.sin6_port),
+ *             system.ntohl(addr6.sin6_flowinfo),
+ */
+    __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 58, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
+    __pyx_t_4 = 0;
+    __pyx_t_3 = 0;
+    __pyx_t_2 = 0;
+    __pyx_t_5 = 0;
+    __pyx_r = __pyx_t_6;
+    __pyx_t_6 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/dns.pyx":50
+ *         )
+ * 
+ *     elif addr.sa_family == uv.AF_INET6:             # <<<<<<<<<<<<<<
+ *         addr6 = <system.sockaddr_in6*>addr
+ * 
+ */
+  }
+
+  /* "uvloop/dns.pyx":64
+ *         )
+ * 
+ *     elif addr.sa_family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *         addr_un = <system.sockaddr_un*>addr
+ *         return system.MakeUnixSockPyAddr(addr_un)
+ */
+  __pyx_t_1 = ((__pyx_v_addr->sa_family == AF_UNIX) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/dns.pyx":65
+ * 
+ *     elif addr.sa_family == uv.AF_UNIX:
+ *         addr_un = <system.sockaddr_un*>addr             # <<<<<<<<<<<<<<
+ *         return system.MakeUnixSockPyAddr(addr_un)
+ * 
+ */
+    __pyx_v_addr_un = ((struct sockaddr_un *)__pyx_v_addr);
+
+    /* "uvloop/dns.pyx":66
+ *     elif addr.sa_family == uv.AF_UNIX:
+ *         addr_un = <system.sockaddr_un*>addr
+ *         return system.MakeUnixSockPyAddr(addr_un)             # <<<<<<<<<<<<<<
+ * 
+ *     raise RuntimeError("cannot convert sockaddr into Python object")
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_6 = MakeUnixSockPyAddr(__pyx_v_addr_un); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 66, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_r = __pyx_t_6;
+    __pyx_t_6 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/dns.pyx":64
+ *         )
+ * 
+ *     elif addr.sa_family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *         addr_un = <system.sockaddr_un*>addr
+ *         return system.MakeUnixSockPyAddr(addr_un)
+ */
+  }
+
+  /* "uvloop/dns.pyx":68
+ *         return system.MakeUnixSockPyAddr(addr_un)
+ * 
+ *     raise RuntimeError("cannot convert sockaddr into Python object")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__199, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __PYX_ERR(5, 68, __pyx_L1_error)
+
+  /* "uvloop/dns.pyx":25
+ * 
+ * 
+ * cdef __convert_sockaddr_to_pyaddr(const system.sockaddr* addr):             # <<<<<<<<<<<<<<
+ *     # Converts sockaddr structs into what Python socket
+ *     # module can understand:
+ */
+
+  /* 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("uvloop.loop.__convert_sockaddr_to_pyaddr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_14SockAddrHolder_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_14SockAddrHolder___reduce_cython__[] = "SockAddrHolder.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_14SockAddrHolder_1__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_6uvloop_4loop_14SockAddrHolder___reduce_cython__(((struct __pyx_obj_6uvloop_4loop_SockAddrHolder *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_14SockAddrHolder___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_SockAddrHolder *__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);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__200, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 2, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.SockAddrHolder.__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("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_14SockAddrHolder_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_14SockAddrHolder_2__setstate_cython__[] = "SockAddrHolder.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_14SockAddrHolder_3__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_6uvloop_4loop_14SockAddrHolder_2__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_SockAddrHolder *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_14SockAddrHolder_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_SockAddrHolder *__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);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")             # <<<<<<<<<<<<<<
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__201, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 4, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.SockAddrHolder.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":82
+ * 
+ * 
+ * cdef __convert_pyaddr_to_sockaddr(int family, object addr,             # <<<<<<<<<<<<<<
+ *                                   system.sockaddr* res):
+ *     cdef:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___convert_pyaddr_to_sockaddr(int __pyx_v_family, PyObject *__pyx_v_addr, struct sockaddr *__pyx_v_res) {
+  int __pyx_v_err;
+  int __pyx_v_addr_len;
+  int __pyx_v_scope_id;
+  int __pyx_v_flowinfo;
+  char *__pyx_v_buf;
+  Py_ssize_t __pyx_v_buflen;
+  struct __pyx_obj_6uvloop_4loop_SockAddrHolder *__pyx_v_ret = 0;
+  PyObject *__pyx_v_host = NULL;
+  PyObject *__pyx_v_port = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *(*__pyx_t_8)(PyObject *);
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  char const *__pyx_t_16;
+  char const *__pyx_t_17;
+  Py_UCS4 __pyx_t_18;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__convert_pyaddr_to_sockaddr", 0);
+  __Pyx_INCREF(__pyx_v_addr);
+
+  /* "uvloop/dns.pyx":87
+ *         int err
+ *         int addr_len
+ *         int scope_id = 0             # <<<<<<<<<<<<<<
+ *         int flowinfo = 0
+ *         char *buf
+ */
+  __pyx_v_scope_id = 0;
+
+  /* "uvloop/dns.pyx":88
+ *         int addr_len
+ *         int scope_id = 0
+ *         int flowinfo = 0             # <<<<<<<<<<<<<<
+ *         char *buf
+ *         Py_ssize_t buflen
+ */
+  __pyx_v_flowinfo = 0;
+
+  /* "uvloop/dns.pyx":93
+ *         SockAddrHolder ret
+ * 
+ *     ret = sockaddrs.get(addr, None)             # <<<<<<<<<<<<<<
+ *     if ret is not None and ret.family == family:
+ *         memcpy(res, &ret.addr, ret.addr_size)
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop_8LruCache_get(__pyx_v_6uvloop_4loop_sockaddrs, __pyx_v_addr, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6uvloop_4loop_SockAddrHolder))))) __PYX_ERR(5, 93, __pyx_L1_error)
+  __pyx_v_ret = ((struct __pyx_obj_6uvloop_4loop_SockAddrHolder *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/dns.pyx":94
+ * 
+ *     ret = sockaddrs.get(addr, None)
+ *     if ret is not None and ret.family == family:             # <<<<<<<<<<<<<<
+ *         memcpy(res, &ret.addr, ret.addr_size)
+ *         return
+ */
+  __pyx_t_3 = (((PyObject *)__pyx_v_ret) != Py_None);
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  if (__pyx_t_4) {
+  } else {
+    __pyx_t_2 = __pyx_t_4;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_4 = ((__pyx_v_ret->family == __pyx_v_family) != 0);
+  __pyx_t_2 = __pyx_t_4;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_2) {
+
+    /* "uvloop/dns.pyx":95
+ *     ret = sockaddrs.get(addr, None)
+ *     if ret is not None and ret.family == family:
+ *         memcpy(res, &ret.addr, ret.addr_size)             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+    (void)(memcpy(__pyx_v_res, (&__pyx_v_ret->addr), __pyx_v_ret->addr_size));
+
+    /* "uvloop/dns.pyx":96
+ *     if ret is not None and ret.family == family:
+ *         memcpy(res, &ret.addr, ret.addr_size)
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     ret = SockAddrHolder.__new__(SockAddrHolder)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/dns.pyx":94
+ * 
+ *     ret = sockaddrs.get(addr, None)
+ *     if ret is not None and ret.family == family:             # <<<<<<<<<<<<<<
+ *         memcpy(res, &ret.addr, ret.addr_size)
+ *         return
+ */
+  }
+
+  /* "uvloop/dns.pyx":98
+ *         return
+ * 
+ *     ret = SockAddrHolder.__new__(SockAddrHolder)             # <<<<<<<<<<<<<<
+ *     if family == uv.AF_INET:
+ *         if not isinstance(addr, tuple):
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop_SockAddrHolder(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_SockAddrHolder), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 98, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_ret, ((struct __pyx_obj_6uvloop_4loop_SockAddrHolder *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  /* "uvloop/dns.pyx":99
+ * 
+ *     ret = SockAddrHolder.__new__(SockAddrHolder)
+ *     if family == uv.AF_INET:             # <<<<<<<<<<<<<<
+ *         if not isinstance(addr, tuple):
+ *             raise TypeError('AF_INET address must be tuple')
+ */
+  __pyx_t_2 = ((__pyx_v_family == AF_INET) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/dns.pyx":100
+ *     ret = SockAddrHolder.__new__(SockAddrHolder)
+ *     if family == uv.AF_INET:
+ *         if not isinstance(addr, tuple):             # <<<<<<<<<<<<<<
+ *             raise TypeError('AF_INET address must be tuple')
+ *         if len(addr) != 2:
+ */
+    __pyx_t_2 = PyTuple_Check(__pyx_v_addr); 
+    __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "uvloop/dns.pyx":101
+ *     if family == uv.AF_INET:
+ *         if not isinstance(addr, tuple):
+ *             raise TypeError('AF_INET address must be tuple')             # <<<<<<<<<<<<<<
+ *         if len(addr) != 2:
+ *             raise ValueError('AF_INET address must be tuple of (host, port)')
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__202, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 101, __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(5, 101, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":100
+ *     ret = SockAddrHolder.__new__(SockAddrHolder)
+ *     if family == uv.AF_INET:
+ *         if not isinstance(addr, tuple):             # <<<<<<<<<<<<<<
+ *             raise TypeError('AF_INET address must be tuple')
+ *         if len(addr) != 2:
+ */
+    }
+
+    /* "uvloop/dns.pyx":102
+ *         if not isinstance(addr, tuple):
+ *             raise TypeError('AF_INET address must be tuple')
+ *         if len(addr) != 2:             # <<<<<<<<<<<<<<
+ *             raise ValueError('AF_INET address must be tuple of (host, port)')
+ *         host, port = addr
+ */
+    __pyx_t_5 = PyObject_Length(__pyx_v_addr); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(5, 102, __pyx_L1_error)
+    __pyx_t_4 = ((__pyx_t_5 != 2) != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "uvloop/dns.pyx":103
+ *             raise TypeError('AF_INET address must be tuple')
+ *         if len(addr) != 2:
+ *             raise ValueError('AF_INET address must be tuple of (host, port)')             # <<<<<<<<<<<<<<
+ *         host, port = addr
+ *         if isinstance(host, str):
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__203, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 103, __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(5, 103, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":102
+ *         if not isinstance(addr, tuple):
+ *             raise TypeError('AF_INET address must be tuple')
+ *         if len(addr) != 2:             # <<<<<<<<<<<<<<
+ *             raise ValueError('AF_INET address must be tuple of (host, port)')
+ *         host, port = addr
+ */
+    }
+
+    /* "uvloop/dns.pyx":104
+ *         if len(addr) != 2:
+ *             raise ValueError('AF_INET address must be tuple of (host, port)')
+ *         host, port = addr             # <<<<<<<<<<<<<<
+ *         if isinstance(host, str):
+ *             try:
+ */
+    if ((likely(PyTuple_CheckExact(__pyx_v_addr))) || (PyList_CheckExact(__pyx_v_addr))) {
+      PyObject* sequence = __pyx_v_addr;
+      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+      if (unlikely(size != 2)) {
+        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(5, 104, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      if (likely(PyTuple_CheckExact(sequence))) {
+        __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); 
+        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); 
+      } else {
+        __pyx_t_1 = PyList_GET_ITEM(sequence, 0); 
+        __pyx_t_6 = PyList_GET_ITEM(sequence, 1); 
+      }
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_6);
+      #else
+      __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 104, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 104, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      #endif
+    } else {
+      Py_ssize_t index = -1;
+      __pyx_t_7 = PyObject_GetIter(__pyx_v_addr); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 104, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
+      index = 0; __pyx_t_1 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_1)) goto __pyx_L9_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_1);
+      index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L9_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_6);
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(5, 104, __pyx_L1_error)
+      __pyx_t_8 = NULL;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L10_unpacking_done;
+      __pyx_L9_unpacking_failed:;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __pyx_t_8 = NULL;
+      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+      __PYX_ERR(5, 104, __pyx_L1_error)
+      __pyx_L10_unpacking_done:;
+    }
+    __pyx_v_host = __pyx_t_1;
+    __pyx_t_1 = 0;
+    __pyx_v_port = __pyx_t_6;
+    __pyx_t_6 = 0;
+
+    /* "uvloop/dns.pyx":105
+ *             raise ValueError('AF_INET address must be tuple of (host, port)')
+ *         host, port = addr
+ *         if isinstance(host, str):             # <<<<<<<<<<<<<<
+ *             try:
+ *                 # idna codec is rather slow, so we try ascii first.
+ */
+    __pyx_t_4 = PyUnicode_Check(__pyx_v_host); 
+    __pyx_t_2 = (__pyx_t_4 != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/dns.pyx":106
+ *         host, port = addr
+ *         if isinstance(host, str):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # idna codec is rather slow, so we try ascii first.
+ *                 host = host.encode('ascii')
+ */
+      {
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+        __Pyx_XGOTREF(__pyx_t_9);
+        __Pyx_XGOTREF(__pyx_t_10);
+        __Pyx_XGOTREF(__pyx_t_11);
+        /*try:*/ {
+
+          /* "uvloop/dns.pyx":108
+ *             try:
+ *                 # idna codec is rather slow, so we try ascii first.
+ *                 host = host.encode('ascii')             # <<<<<<<<<<<<<<
+ *             except UnicodeEncodeError:
+ *                 host = host.encode('idna')
+ */
+          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_host, __pyx_n_s_encode); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 108, __pyx_L12_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __pyx_t_7 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+            __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1);
+            if (likely(__pyx_t_7)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+              __Pyx_INCREF(__pyx_t_7);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_1, function);
+            }
+          }
+          __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_7, __pyx_n_u_ascii) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_n_u_ascii);
+          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+          if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 108, __pyx_L12_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_DECREF_SET(__pyx_v_host, __pyx_t_6);
+          __pyx_t_6 = 0;
+
+          /* "uvloop/dns.pyx":106
+ *         host, port = addr
+ *         if isinstance(host, str):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # idna codec is rather slow, so we try ascii first.
+ *                 host = host.encode('ascii')
+ */
+        }
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        goto __pyx_L17_try_end;
+        __pyx_L12_error:;
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+        /* "uvloop/dns.pyx":109
+ *                 # idna codec is rather slow, so we try ascii first.
+ *                 host = host.encode('ascii')
+ *             except UnicodeEncodeError:             # <<<<<<<<<<<<<<
+ *                 host = host.encode('idna')
+ *         if not isinstance(host, (bytes, bytearray)):
+ */
+        __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_UnicodeEncodeError);
+        if (__pyx_t_12) {
+          __Pyx_AddTraceback("uvloop.loop.__convert_pyaddr_to_sockaddr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(5, 109, __pyx_L14_except_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_GOTREF(__pyx_t_7);
+
+          /* "uvloop/dns.pyx":110
+ *                 host = host.encode('ascii')
+ *             except UnicodeEncodeError:
+ *                 host = host.encode('idna')             # <<<<<<<<<<<<<<
+ *         if not isinstance(host, (bytes, bytearray)):
+ *             raise TypeError('host must be a string or bytes object')
+ */
+          __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_host, __pyx_n_s_encode); if (unlikely(!__pyx_t_14)) __PYX_ERR(5, 110, __pyx_L14_except_error)
+          __Pyx_GOTREF(__pyx_t_14);
+          __pyx_t_15 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) {
+            __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14);
+            if (likely(__pyx_t_15)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
+              __Pyx_INCREF(__pyx_t_15);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_14, function);
+            }
+          }
+          __pyx_t_13 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_14, __pyx_t_15, __pyx_n_u_idna) : __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_n_u_idna);
+          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+          if (unlikely(!__pyx_t_13)) __PYX_ERR(5, 110, __pyx_L14_except_error)
+          __Pyx_GOTREF(__pyx_t_13);
+          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+          __Pyx_DECREF_SET(__pyx_v_host, __pyx_t_13);
+          __pyx_t_13 = 0;
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+          goto __pyx_L13_exception_handled;
+        }
+        goto __pyx_L14_except_error;
+        __pyx_L14_except_error:;
+
+        /* "uvloop/dns.pyx":106
+ *         host, port = addr
+ *         if isinstance(host, str):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # idna codec is rather slow, so we try ascii first.
+ *                 host = host.encode('ascii')
+ */
+        __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);
+        goto __pyx_L1_error;
+        __pyx_L13_exception_handled:;
+        __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_L17_try_end:;
+      }
+
+      /* "uvloop/dns.pyx":105
+ *             raise ValueError('AF_INET address must be tuple of (host, port)')
+ *         host, port = addr
+ *         if isinstance(host, str):             # <<<<<<<<<<<<<<
+ *             try:
+ *                 # idna codec is rather slow, so we try ascii first.
+ */
+    }
+
+    /* "uvloop/dns.pyx":111
+ *             except UnicodeEncodeError:
+ *                 host = host.encode('idna')
+ *         if not isinstance(host, (bytes, bytearray)):             # <<<<<<<<<<<<<<
+ *             raise TypeError('host must be a string or bytes object')
+ * 
+ */
+    __pyx_t_4 = PyBytes_Check(__pyx_v_host); 
+    __pyx_t_3 = (__pyx_t_4 != 0);
+    if (!__pyx_t_3) {
+    } else {
+      __pyx_t_2 = __pyx_t_3;
+      goto __pyx_L21_bool_binop_done;
+    }
+    __pyx_t_3 = PyByteArray_Check(__pyx_v_host); 
+    __pyx_t_4 = (__pyx_t_3 != 0);
+    __pyx_t_2 = __pyx_t_4;
+    __pyx_L21_bool_binop_done:;
+    __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "uvloop/dns.pyx":112
+ *                 host = host.encode('idna')
+ *         if not isinstance(host, (bytes, bytearray)):
+ *             raise TypeError('host must be a string or bytes object')             # <<<<<<<<<<<<<<
+ * 
+ *         port = __port_to_int(port, None)
+ */
+      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__204, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 112, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __PYX_ERR(5, 112, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":111
+ *             except UnicodeEncodeError:
+ *                 host = host.encode('idna')
+ *         if not isinstance(host, (bytes, bytearray)):             # <<<<<<<<<<<<<<
+ *             raise TypeError('host must be a string or bytes object')
+ * 
+ */
+    }
+
+    /* "uvloop/dns.pyx":114
+ *             raise TypeError('host must be a string or bytes object')
+ * 
+ *         port = __port_to_int(port, None)             # <<<<<<<<<<<<<<
+ * 
+ *         ret.addr_size = sizeof(system.sockaddr_in)
+ */
+    __pyx_t_7 = __pyx_f_6uvloop_4loop___port_to_int(__pyx_v_port, Py_None); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 114, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF_SET(__pyx_v_port, __pyx_t_7);
+    __pyx_t_7 = 0;
+
+    /* "uvloop/dns.pyx":116
+ *         port = __port_to_int(port, None)
+ * 
+ *         ret.addr_size = sizeof(system.sockaddr_in)             # <<<<<<<<<<<<<<
+ *         err = uv.uv_ip4_addr(host, <int>port, <system.sockaddr_in*>&ret.addr)
+ *         if err < 0:
+ */
+    __pyx_v_ret->addr_size = (sizeof(struct sockaddr_in));
+
+    /* "uvloop/dns.pyx":117
+ * 
+ *         ret.addr_size = sizeof(system.sockaddr_in)
+ *         err = uv.uv_ip4_addr(host, <int>port, <system.sockaddr_in*>&ret.addr)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             raise convert_error(err)
+ */
+    __pyx_t_16 = __Pyx_PyObject_AsString(__pyx_v_host); if (unlikely((!__pyx_t_16) && PyErr_Occurred())) __PYX_ERR(5, 117, __pyx_L1_error)
+    __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_v_port); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 117, __pyx_L1_error)
+    __pyx_v_err = uv_ip4_addr(__pyx_t_16, ((int)__pyx_t_12), ((struct sockaddr_in *)(&__pyx_v_ret->addr)));
+
+    /* "uvloop/dns.pyx":118
+ *         ret.addr_size = sizeof(system.sockaddr_in)
+ *         err = uv.uv_ip4_addr(host, <int>port, <system.sockaddr_in*>&ret.addr)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    __pyx_t_4 = ((__pyx_v_err < 0) != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "uvloop/dns.pyx":119
+ *         err = uv.uv_ip4_addr(host, <int>port, <system.sockaddr_in*>&ret.addr)
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *     elif family == uv.AF_INET6:
+ */
+      __pyx_t_7 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 119, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __PYX_ERR(5, 119, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":118
+ *         ret.addr_size = sizeof(system.sockaddr_in)
+ *         err = uv.uv_ip4_addr(host, <int>port, <system.sockaddr_in*>&ret.addr)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    }
+
+    /* "uvloop/dns.pyx":99
+ * 
+ *     ret = SockAddrHolder.__new__(SockAddrHolder)
+ *     if family == uv.AF_INET:             # <<<<<<<<<<<<<<
+ *         if not isinstance(addr, tuple):
+ *             raise TypeError('AF_INET address must be tuple')
+ */
+    goto __pyx_L6;
+  }
+
+  /* "uvloop/dns.pyx":121
+ *             raise convert_error(err)
+ * 
+ *     elif family == uv.AF_INET6:             # <<<<<<<<<<<<<<
+ *         if not isinstance(addr, tuple):
+ *             raise TypeError('AF_INET6 address must be tuple')
+ */
+  __pyx_t_4 = ((__pyx_v_family == AF_INET6) != 0);
+  if (__pyx_t_4) {
+
+    /* "uvloop/dns.pyx":122
+ * 
+ *     elif family == uv.AF_INET6:
+ *         if not isinstance(addr, tuple):             # <<<<<<<<<<<<<<
+ *             raise TypeError('AF_INET6 address must be tuple')
+ * 
+ */
+    __pyx_t_4 = PyTuple_Check(__pyx_v_addr); 
+    __pyx_t_2 = ((!(__pyx_t_4 != 0)) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/dns.pyx":123
+ *     elif family == uv.AF_INET6:
+ *         if not isinstance(addr, tuple):
+ *             raise TypeError('AF_INET6 address must be tuple')             # <<<<<<<<<<<<<<
+ * 
+ *         addr_len = len(addr)
+ */
+      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__205, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 123, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __PYX_ERR(5, 123, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":122
+ * 
+ *     elif family == uv.AF_INET6:
+ *         if not isinstance(addr, tuple):             # <<<<<<<<<<<<<<
+ *             raise TypeError('AF_INET6 address must be tuple')
+ * 
+ */
+    }
+
+    /* "uvloop/dns.pyx":125
+ *             raise TypeError('AF_INET6 address must be tuple')
+ * 
+ *         addr_len = len(addr)             # <<<<<<<<<<<<<<
+ *         if addr_len < 2 or addr_len > 4:
+ *             raise ValueError(
+ */
+    __pyx_t_5 = PyObject_Length(__pyx_v_addr); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(5, 125, __pyx_L1_error)
+    __pyx_v_addr_len = __pyx_t_5;
+
+    /* "uvloop/dns.pyx":126
+ * 
+ *         addr_len = len(addr)
+ *         if addr_len < 2 or addr_len > 4:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'AF_INET6 must be a tuple of 2-4 parameters: '
+ */
+    __pyx_t_4 = ((__pyx_v_addr_len < 2) != 0);
+    if (!__pyx_t_4) {
+    } else {
+      __pyx_t_2 = __pyx_t_4;
+      goto __pyx_L26_bool_binop_done;
+    }
+    __pyx_t_4 = ((__pyx_v_addr_len > 4) != 0);
+    __pyx_t_2 = __pyx_t_4;
+    __pyx_L26_bool_binop_done:;
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/dns.pyx":127
+ *         addr_len = len(addr)
+ *         if addr_len < 2 or addr_len > 4:
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'AF_INET6 must be a tuple of 2-4 parameters: '
+ *                 '(host, port, flowinfo?, scope_id?)')
+ */
+      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__206, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 127, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __PYX_ERR(5, 127, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":126
+ * 
+ *         addr_len = len(addr)
+ *         if addr_len < 2 or addr_len > 4:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 'AF_INET6 must be a tuple of 2-4 parameters: '
+ */
+    }
+
+    /* "uvloop/dns.pyx":131
+ *                 '(host, port, flowinfo?, scope_id?)')
+ * 
+ *         host = addr[0]             # <<<<<<<<<<<<<<
+ *         if isinstance(host, str):
+ *             try:
+ */
+    __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_addr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 131, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_v_host = __pyx_t_7;
+    __pyx_t_7 = 0;
+
+    /* "uvloop/dns.pyx":132
+ * 
+ *         host = addr[0]
+ *         if isinstance(host, str):             # <<<<<<<<<<<<<<
+ *             try:
+ *                 # idna codec is rather slow, so we try ascii first.
+ */
+    __pyx_t_2 = PyUnicode_Check(__pyx_v_host); 
+    __pyx_t_4 = (__pyx_t_2 != 0);
+    if (__pyx_t_4) {
+
+      /* "uvloop/dns.pyx":133
+ *         host = addr[0]
+ *         if isinstance(host, str):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # idna codec is rather slow, so we try ascii first.
+ *                 host = host.encode('ascii')
+ */
+      {
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9);
+        __Pyx_XGOTREF(__pyx_t_11);
+        __Pyx_XGOTREF(__pyx_t_10);
+        __Pyx_XGOTREF(__pyx_t_9);
+        /*try:*/ {
+
+          /* "uvloop/dns.pyx":135
+ *             try:
+ *                 # idna codec is rather slow, so we try ascii first.
+ *                 host = host.encode('ascii')             # <<<<<<<<<<<<<<
+ *             except UnicodeEncodeError:
+ *                 host = host.encode('idna')
+ */
+          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_host, __pyx_n_s_encode); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 135, __pyx_L29_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __pyx_t_6 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+            __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1);
+            if (likely(__pyx_t_6)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+              __Pyx_INCREF(__pyx_t_6);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_1, function);
+            }
+          }
+          __pyx_t_7 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_n_u_ascii) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_n_u_ascii);
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 135, __pyx_L29_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_DECREF_SET(__pyx_v_host, __pyx_t_7);
+          __pyx_t_7 = 0;
+
+          /* "uvloop/dns.pyx":133
+ *         host = addr[0]
+ *         if isinstance(host, str):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # idna codec is rather slow, so we try ascii first.
+ *                 host = host.encode('ascii')
+ */
+        }
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        goto __pyx_L34_try_end;
+        __pyx_L29_error:;
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+        /* "uvloop/dns.pyx":136
+ *                 # idna codec is rather slow, so we try ascii first.
+ *                 host = host.encode('ascii')
+ *             except UnicodeEncodeError:             # <<<<<<<<<<<<<<
+ *                 host = host.encode('idna')
+ *         if not isinstance(host, (bytes, bytearray)):
+ */
+        __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_UnicodeEncodeError);
+        if (__pyx_t_12) {
+          __Pyx_AddTraceback("uvloop.loop.__convert_pyaddr_to_sockaddr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_1, &__pyx_t_6) < 0) __PYX_ERR(5, 136, __pyx_L31_except_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_GOTREF(__pyx_t_6);
+
+          /* "uvloop/dns.pyx":137
+ *                 host = host.encode('ascii')
+ *             except UnicodeEncodeError:
+ *                 host = host.encode('idna')             # <<<<<<<<<<<<<<
+ *         if not isinstance(host, (bytes, bytearray)):
+ *             raise TypeError('host must be a string or bytes object')
+ */
+          __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_host, __pyx_n_s_encode); if (unlikely(!__pyx_t_14)) __PYX_ERR(5, 137, __pyx_L31_except_error)
+          __Pyx_GOTREF(__pyx_t_14);
+          __pyx_t_15 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) {
+            __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14);
+            if (likely(__pyx_t_15)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
+              __Pyx_INCREF(__pyx_t_15);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_14, function);
+            }
+          }
+          __pyx_t_13 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_14, __pyx_t_15, __pyx_n_u_idna) : __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_n_u_idna);
+          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+          if (unlikely(!__pyx_t_13)) __PYX_ERR(5, 137, __pyx_L31_except_error)
+          __Pyx_GOTREF(__pyx_t_13);
+          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+          __Pyx_DECREF_SET(__pyx_v_host, __pyx_t_13);
+          __pyx_t_13 = 0;
+          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          goto __pyx_L30_exception_handled;
+        }
+        goto __pyx_L31_except_error;
+        __pyx_L31_except_error:;
+
+        /* "uvloop/dns.pyx":133
+ *         host = addr[0]
+ *         if isinstance(host, str):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 # idna codec is rather slow, so we try ascii first.
+ *                 host = host.encode('ascii')
+ */
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_9);
+        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9);
+        goto __pyx_L1_error;
+        __pyx_L30_exception_handled:;
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_9);
+        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9);
+        __pyx_L34_try_end:;
+      }
+
+      /* "uvloop/dns.pyx":132
+ * 
+ *         host = addr[0]
+ *         if isinstance(host, str):             # <<<<<<<<<<<<<<
+ *             try:
+ *                 # idna codec is rather slow, so we try ascii first.
+ */
+    }
+
+    /* "uvloop/dns.pyx":138
+ *             except UnicodeEncodeError:
+ *                 host = host.encode('idna')
+ *         if not isinstance(host, (bytes, bytearray)):             # <<<<<<<<<<<<<<
+ *             raise TypeError('host must be a string or bytes object')
+ * 
+ */
+    __pyx_t_2 = PyBytes_Check(__pyx_v_host); 
+    __pyx_t_3 = (__pyx_t_2 != 0);
+    if (!__pyx_t_3) {
+    } else {
+      __pyx_t_4 = __pyx_t_3;
+      goto __pyx_L38_bool_binop_done;
+    }
+    __pyx_t_3 = PyByteArray_Check(__pyx_v_host); 
+    __pyx_t_2 = (__pyx_t_3 != 0);
+    __pyx_t_4 = __pyx_t_2;
+    __pyx_L38_bool_binop_done:;
+    __pyx_t_2 = ((!(__pyx_t_4 != 0)) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/dns.pyx":139
+ *                 host = host.encode('idna')
+ *         if not isinstance(host, (bytes, bytearray)):
+ *             raise TypeError('host must be a string or bytes object')             # <<<<<<<<<<<<<<
+ * 
+ *         port = __port_to_int(addr[1], None)
+ */
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__204, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 139, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __PYX_ERR(5, 139, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":138
+ *             except UnicodeEncodeError:
+ *                 host = host.encode('idna')
+ *         if not isinstance(host, (bytes, bytearray)):             # <<<<<<<<<<<<<<
+ *             raise TypeError('host must be a string or bytes object')
+ * 
+ */
+    }
+
+    /* "uvloop/dns.pyx":141
+ *             raise TypeError('host must be a string or bytes object')
+ * 
+ *         port = __port_to_int(addr[1], None)             # <<<<<<<<<<<<<<
+ * 
+ *         if addr_len > 2:
+ */
+    __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_addr, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 141, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_1 = __pyx_f_6uvloop_4loop___port_to_int(__pyx_t_6, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 141, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_v_port = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/dns.pyx":143
+ *         port = __port_to_int(addr[1], None)
+ * 
+ *         if addr_len > 2:             # <<<<<<<<<<<<<<
+ *             flowinfo = addr[2]
+ *         if addr_len > 3:
+ */
+    __pyx_t_2 = ((__pyx_v_addr_len > 2) != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/dns.pyx":144
+ * 
+ *         if addr_len > 2:
+ *             flowinfo = addr[2]             # <<<<<<<<<<<<<<
+ *         if addr_len > 3:
+ *             scope_id = addr[3]
+ */
+      __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_addr, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 144, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 144, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_v_flowinfo = __pyx_t_12;
+
+      /* "uvloop/dns.pyx":143
+ *         port = __port_to_int(addr[1], None)
+ * 
+ *         if addr_len > 2:             # <<<<<<<<<<<<<<
+ *             flowinfo = addr[2]
+ *         if addr_len > 3:
+ */
+    }
+
+    /* "uvloop/dns.pyx":145
+ *         if addr_len > 2:
+ *             flowinfo = addr[2]
+ *         if addr_len > 3:             # <<<<<<<<<<<<<<
+ *             scope_id = addr[3]
+ * 
+ */
+    __pyx_t_2 = ((__pyx_v_addr_len > 3) != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/dns.pyx":146
+ *             flowinfo = addr[2]
+ *         if addr_len > 3:
+ *             scope_id = addr[3]             # <<<<<<<<<<<<<<
+ * 
+ *         ret.addr_size = sizeof(system.sockaddr_in6)
+ */
+      __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_addr, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 146, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 146, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_v_scope_id = __pyx_t_12;
+
+      /* "uvloop/dns.pyx":145
+ *         if addr_len > 2:
+ *             flowinfo = addr[2]
+ *         if addr_len > 3:             # <<<<<<<<<<<<<<
+ *             scope_id = addr[3]
+ * 
+ */
+    }
+
+    /* "uvloop/dns.pyx":148
+ *             scope_id = addr[3]
+ * 
+ *         ret.addr_size = sizeof(system.sockaddr_in6)             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_ip6_addr(host, port, <system.sockaddr_in6*>&ret.addr)
+ */
+    __pyx_v_ret->addr_size = (sizeof(struct sockaddr_in6));
+
+    /* "uvloop/dns.pyx":150
+ *         ret.addr_size = sizeof(system.sockaddr_in6)
+ * 
+ *         err = uv.uv_ip6_addr(host, port, <system.sockaddr_in6*>&ret.addr)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             raise convert_error(err)
+ */
+    __pyx_t_17 = __Pyx_PyObject_AsString(__pyx_v_host); if (unlikely((!__pyx_t_17) && PyErr_Occurred())) __PYX_ERR(5, 150, __pyx_L1_error)
+    __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_v_port); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 150, __pyx_L1_error)
+    __pyx_v_err = uv_ip6_addr(__pyx_t_17, __pyx_t_12, ((struct sockaddr_in6 *)(&__pyx_v_ret->addr)));
+
+    /* "uvloop/dns.pyx":151
+ * 
+ *         err = uv.uv_ip6_addr(host, port, <system.sockaddr_in6*>&ret.addr)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/dns.pyx":152
+ *         err = uv.uv_ip6_addr(host, port, <system.sockaddr_in6*>&ret.addr)
+ *         if err < 0:
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         (<system.sockaddr_in6*>&ret.addr).sin6_flowinfo = flowinfo
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 152, __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(5, 152, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":151
+ * 
+ *         err = uv.uv_ip6_addr(host, port, <system.sockaddr_in6*>&ret.addr)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    }
+
+    /* "uvloop/dns.pyx":154
+ *             raise convert_error(err)
+ * 
+ *         (<system.sockaddr_in6*>&ret.addr).sin6_flowinfo = flowinfo             # <<<<<<<<<<<<<<
+ *         (<system.sockaddr_in6*>&ret.addr).sin6_scope_id = scope_id
+ * 
+ */
+    ((struct sockaddr_in6 *)(&__pyx_v_ret->addr))->sin6_flowinfo = __pyx_v_flowinfo;
+
+    /* "uvloop/dns.pyx":155
+ * 
+ *         (<system.sockaddr_in6*>&ret.addr).sin6_flowinfo = flowinfo
+ *         (<system.sockaddr_in6*>&ret.addr).sin6_scope_id = scope_id             # <<<<<<<<<<<<<<
+ * 
+ *     elif family == uv.AF_UNIX:
+ */
+    ((struct sockaddr_in6 *)(&__pyx_v_ret->addr))->sin6_scope_id = __pyx_v_scope_id;
+
+    /* "uvloop/dns.pyx":121
+ *             raise convert_error(err)
+ * 
+ *     elif family == uv.AF_INET6:             # <<<<<<<<<<<<<<
+ *         if not isinstance(addr, tuple):
+ *             raise TypeError('AF_INET6 address must be tuple')
+ */
+    goto __pyx_L6;
+  }
+
+  /* "uvloop/dns.pyx":157
+ *         (<system.sockaddr_in6*>&ret.addr).sin6_scope_id = scope_id
+ * 
+ *     elif family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *         if isinstance(addr, str):
+ *             addr = addr.encode(sys_getfilesystemencoding())
+ */
+  __pyx_t_2 = ((__pyx_v_family == AF_UNIX) != 0);
+  if (likely(__pyx_t_2)) {
+
+    /* "uvloop/dns.pyx":158
+ * 
+ *     elif family == uv.AF_UNIX:
+ *         if isinstance(addr, str):             # <<<<<<<<<<<<<<
+ *             addr = addr.encode(sys_getfilesystemencoding())
+ *         elif not isinstance(addr, bytes):
+ */
+    __pyx_t_2 = PyUnicode_Check(__pyx_v_addr); 
+    __pyx_t_4 = (__pyx_t_2 != 0);
+    if (__pyx_t_4) {
+
+      /* "uvloop/dns.pyx":159
+ *     elif family == uv.AF_UNIX:
+ *         if isinstance(addr, str):
+ *             addr = addr.encode(sys_getfilesystemencoding())             # <<<<<<<<<<<<<<
+ *         elif not isinstance(addr, bytes):
+ *             raise TypeError('AF_UNIX address must be a str or a bytes object')
+ */
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_addr, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 159, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_v_6uvloop_4loop_sys_getfilesystemencoding);
+      __pyx_t_13 = __pyx_v_6uvloop_4loop_sys_getfilesystemencoding; __pyx_t_14 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
+        __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13);
+        if (likely(__pyx_t_14)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+          __Pyx_INCREF(__pyx_t_14);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_13, function);
+        }
+      }
+      __pyx_t_7 = (__pyx_t_14) ? __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_14) : __Pyx_PyObject_CallNoArg(__pyx_t_13);
+      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+      if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 159, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __pyx_t_13 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_13)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_13);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_1 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_13, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7);
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 159, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF_SET(__pyx_v_addr, __pyx_t_1);
+      __pyx_t_1 = 0;
+
+      /* "uvloop/dns.pyx":158
+ * 
+ *     elif family == uv.AF_UNIX:
+ *         if isinstance(addr, str):             # <<<<<<<<<<<<<<
+ *             addr = addr.encode(sys_getfilesystemencoding())
+ *         elif not isinstance(addr, bytes):
+ */
+      goto __pyx_L43;
+    }
+
+    /* "uvloop/dns.pyx":160
+ *         if isinstance(addr, str):
+ *             addr = addr.encode(sys_getfilesystemencoding())
+ *         elif not isinstance(addr, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError('AF_UNIX address must be a str or a bytes object')
+ * 
+ */
+    __pyx_t_4 = PyBytes_Check(__pyx_v_addr); 
+    __pyx_t_2 = ((!(__pyx_t_4 != 0)) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/dns.pyx":161
+ *             addr = addr.encode(sys_getfilesystemencoding())
+ *         elif not isinstance(addr, bytes):
+ *             raise TypeError('AF_UNIX address must be a str or a bytes object')             # <<<<<<<<<<<<<<
+ * 
+ *         PyBytes_AsStringAndSize(addr, &buf, &buflen)
+ */
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__207, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 161, __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(5, 161, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":160
+ *         if isinstance(addr, str):
+ *             addr = addr.encode(sys_getfilesystemencoding())
+ *         elif not isinstance(addr, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError('AF_UNIX address must be a str or a bytes object')
+ * 
+ */
+    }
+    __pyx_L43:;
+
+    /* "uvloop/dns.pyx":163
+ *             raise TypeError('AF_UNIX address must be a str or a bytes object')
+ * 
+ *         PyBytes_AsStringAndSize(addr, &buf, &buflen)             # <<<<<<<<<<<<<<
+ *         if buflen > 107:
+ *             raise ValueError(
+ */
+    __pyx_t_12 = PyBytes_AsStringAndSize(__pyx_v_addr, (&__pyx_v_buf), (&__pyx_v_buflen)); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(5, 163, __pyx_L1_error)
+
+    /* "uvloop/dns.pyx":164
+ * 
+ *         PyBytes_AsStringAndSize(addr, &buf, &buflen)
+ *         if buflen > 107:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 f'unix socket path {addr!r} is longer than 107 characters')
+ */
+    __pyx_t_2 = ((__pyx_v_buflen > 0x6B) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/dns.pyx":166
+ *         if buflen > 107:
+ *             raise ValueError(
+ *                 f'unix socket path {addr!r} is longer than 107 characters')             # <<<<<<<<<<<<<<
+ * 
+ *         ret.addr_size = sizeof(system.sockaddr_un)
+ */
+      __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 166, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_5 = 0;
+      __pyx_t_18 = 127;
+      __Pyx_INCREF(__pyx_kp_u_unix_socket_path);
+      __pyx_t_5 += 17;
+      __Pyx_GIVEREF(__pyx_kp_u_unix_socket_path);
+      PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_unix_socket_path);
+      __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_addr), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 166, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_18 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_18) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_18;
+      __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6);
+      __pyx_t_6 = 0;
+      __Pyx_INCREF(__pyx_kp_u_is_longer_than_107_characters);
+      __pyx_t_5 += 30;
+      __Pyx_GIVEREF(__pyx_kp_u_is_longer_than_107_characters);
+      PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_is_longer_than_107_characters);
+      __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_5, __pyx_t_18); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 166, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/dns.pyx":165
+ *         PyBytes_AsStringAndSize(addr, &buf, &buflen)
+ *         if buflen > 107:
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 f'unix socket path {addr!r} is longer than 107 characters')
+ * 
+ */
+      __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 165, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __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(5, 165, __pyx_L1_error)
+
+      /* "uvloop/dns.pyx":164
+ * 
+ *         PyBytes_AsStringAndSize(addr, &buf, &buflen)
+ *         if buflen > 107:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 f'unix socket path {addr!r} is longer than 107 characters')
+ */
+    }
+
+    /* "uvloop/dns.pyx":168
+ *                 f'unix socket path {addr!r} is longer than 107 characters')
+ * 
+ *         ret.addr_size = sizeof(system.sockaddr_un)             # <<<<<<<<<<<<<<
+ *         memset(&ret.addr, 0, sizeof(system.sockaddr_un))
+ *         (<system.sockaddr_un*>&ret.addr).sun_family = uv.AF_UNIX
+ */
+    __pyx_v_ret->addr_size = (sizeof(struct sockaddr_un));
+
+    /* "uvloop/dns.pyx":169
+ * 
+ *         ret.addr_size = sizeof(system.sockaddr_un)
+ *         memset(&ret.addr, 0, sizeof(system.sockaddr_un))             # <<<<<<<<<<<<<<
+ *         (<system.sockaddr_un*>&ret.addr).sun_family = uv.AF_UNIX
+ *         memcpy((<system.sockaddr_un*>&ret.addr).sun_path, buf, buflen)
+ */
+    (void)(memset((&__pyx_v_ret->addr), 0, (sizeof(struct sockaddr_un))));
+
+    /* "uvloop/dns.pyx":170
+ *         ret.addr_size = sizeof(system.sockaddr_un)
+ *         memset(&ret.addr, 0, sizeof(system.sockaddr_un))
+ *         (<system.sockaddr_un*>&ret.addr).sun_family = uv.AF_UNIX             # <<<<<<<<<<<<<<
+ *         memcpy((<system.sockaddr_un*>&ret.addr).sun_path, buf, buflen)
+ * 
+ */
+    ((struct sockaddr_un *)(&__pyx_v_ret->addr))->sun_family = AF_UNIX;
+
+    /* "uvloop/dns.pyx":171
+ *         memset(&ret.addr, 0, sizeof(system.sockaddr_un))
+ *         (<system.sockaddr_un*>&ret.addr).sun_family = uv.AF_UNIX
+ *         memcpy((<system.sockaddr_un*>&ret.addr).sun_path, buf, buflen)             # <<<<<<<<<<<<<<
+ * 
+ *     else:
+ */
+    (void)(memcpy(((struct sockaddr_un *)(&__pyx_v_ret->addr))->sun_path, __pyx_v_buf, __pyx_v_buflen));
+
+    /* "uvloop/dns.pyx":157
+ *         (<system.sockaddr_in6*>&ret.addr).sin6_scope_id = scope_id
+ * 
+ *     elif family == uv.AF_UNIX:             # <<<<<<<<<<<<<<
+ *         if isinstance(addr, str):
+ *             addr = addr.encode(sys_getfilesystemencoding())
+ */
+    goto __pyx_L6;
+  }
+
+  /* "uvloop/dns.pyx":174
+ * 
+ *     else:
+ *         raise ValueError(             # <<<<<<<<<<<<<<
+ *             f'expected AF_INET, AF_INET6, or AF_UNIX family, got {family}')
+ * 
+ */
+  /*else*/ {
+
+    /* "uvloop/dns.pyx":175
+ *     else:
+ *         raise ValueError(
+ *             f'expected AF_INET, AF_INET6, or AF_UNIX family, got {family}')             # <<<<<<<<<<<<<<
+ * 
+ *     ret.family = family
+ */
+    __pyx_t_1 = __Pyx_PyUnicode_From_int(__pyx_v_family, 0, ' ', 'd'); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 175, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_AF_INET_AF_INET6_or_AF, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 175, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/dns.pyx":174
+ * 
+ *     else:
+ *         raise ValueError(             # <<<<<<<<<<<<<<
+ *             f'expected AF_INET, AF_INET6, or AF_UNIX family, got {family}')
+ * 
+ */
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 174, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __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(5, 174, __pyx_L1_error)
+  }
+  __pyx_L6:;
+
+  /* "uvloop/dns.pyx":177
+ *             f'expected AF_INET, AF_INET6, or AF_UNIX family, got {family}')
+ * 
+ *     ret.family = family             # <<<<<<<<<<<<<<
+ *     sockaddrs[addr] = ret
+ *     memcpy(res, &ret.addr, ret.addr_size)
+ */
+  __pyx_v_ret->family = __pyx_v_family;
+
+  /* "uvloop/dns.pyx":178
+ * 
+ *     ret.family = family
+ *     sockaddrs[addr] = ret             # <<<<<<<<<<<<<<
+ *     memcpy(res, &ret.addr, ret.addr_size)
+ * 
+ */
+  if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_6uvloop_4loop_sockaddrs), __pyx_v_addr, ((PyObject *)__pyx_v_ret)) < 0)) __PYX_ERR(5, 178, __pyx_L1_error)
+
+  /* "uvloop/dns.pyx":179
+ *     ret.family = family
+ *     sockaddrs[addr] = ret
+ *     memcpy(res, &ret.addr, ret.addr_size)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  (void)(memcpy(__pyx_v_res, (&__pyx_v_ret->addr), __pyx_v_ret->addr_size));
+
+  /* "uvloop/dns.pyx":82
+ * 
+ * 
+ * cdef __convert_pyaddr_to_sockaddr(int family, object addr,             # <<<<<<<<<<<<<<
+ *                                   system.sockaddr* res):
+ *     cdef:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_XDECREF(__pyx_t_15);
+  __Pyx_AddTraceback("uvloop.loop.__convert_pyaddr_to_sockaddr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_ret);
+  __Pyx_XDECREF(__pyx_v_host);
+  __Pyx_XDECREF(__pyx_v_port);
+  __Pyx_XDECREF(__pyx_v_addr);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":182
+ * 
+ * 
+ * cdef __static_getaddrinfo(object host, object port,             # <<<<<<<<<<<<<<
+ *                           int family, int type,
+ *                           int proto,
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___static_getaddrinfo(PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, struct sockaddr *__pyx_v_addr) {
+  PyObject *__pyx_v_hp = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  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;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__static_getaddrinfo", 0);
+  __Pyx_INCREF(__pyx_v_port);
+
+  /* "uvloop/dns.pyx":187
+ *                           system.sockaddr *addr):
+ * 
+ *     if proto not in {0, uv.IPPROTO_TCP, uv.IPPROTO_UDP}:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = __pyx_v_proto;
+  __pyx_t_3 = ((__pyx_t_1 != 0) != 0);
+  if (__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_3 = ((__pyx_t_1 != IPPROTO_TCP) != 0);
+  if (__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_3 = ((__pyx_t_1 != IPPROTO_UDP) != 0);
+  __pyx_t_2 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/dns.pyx":188
+ * 
+ *     if proto not in {0, uv.IPPROTO_TCP, uv.IPPROTO_UDP}:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     if _is_sock_stream(type):
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/dns.pyx":187
+ *                           system.sockaddr *addr):
+ * 
+ *     if proto not in {0, uv.IPPROTO_TCP, uv.IPPROTO_UDP}:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  }
+
+  /* "uvloop/dns.pyx":190
+ *         return
+ * 
+ *     if _is_sock_stream(type):             # <<<<<<<<<<<<<<
+ *         proto = uv.IPPROTO_TCP
+ *     elif _is_sock_dgram(type):
+ */
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __pyx_f_6uvloop_4loop__is_sock_stream(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(5, 190, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (__pyx_t_3) {
+
+    /* "uvloop/dns.pyx":191
+ * 
+ *     if _is_sock_stream(type):
+ *         proto = uv.IPPROTO_TCP             # <<<<<<<<<<<<<<
+ *     elif _is_sock_dgram(type):
+ *         proto = uv.IPPROTO_UDP
+ */
+    __pyx_v_proto = IPPROTO_TCP;
+
+    /* "uvloop/dns.pyx":190
+ *         return
+ * 
+ *     if _is_sock_stream(type):             # <<<<<<<<<<<<<<
+ *         proto = uv.IPPROTO_TCP
+ *     elif _is_sock_dgram(type):
+ */
+    goto __pyx_L7;
+  }
+
+  /* "uvloop/dns.pyx":192
+ *     if _is_sock_stream(type):
+ *         proto = uv.IPPROTO_TCP
+ *     elif _is_sock_dgram(type):             # <<<<<<<<<<<<<<
+ *         proto = uv.IPPROTO_UDP
+ *     else:
+ */
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __pyx_f_6uvloop_4loop__is_sock_dgram(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(5, 192, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (__pyx_t_3) {
+
+    /* "uvloop/dns.pyx":193
+ *         proto = uv.IPPROTO_TCP
+ *     elif _is_sock_dgram(type):
+ *         proto = uv.IPPROTO_UDP             # <<<<<<<<<<<<<<
+ *     else:
+ *         return
+ */
+    __pyx_v_proto = IPPROTO_UDP;
+
+    /* "uvloop/dns.pyx":192
+ *     if _is_sock_stream(type):
+ *         proto = uv.IPPROTO_TCP
+ *     elif _is_sock_dgram(type):             # <<<<<<<<<<<<<<
+ *         proto = uv.IPPROTO_UDP
+ *     else:
+ */
+    goto __pyx_L7;
+  }
+
+  /* "uvloop/dns.pyx":195
+ *         proto = uv.IPPROTO_UDP
+ *     else:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+  }
+  __pyx_L7:;
+
+  /* "uvloop/dns.pyx":197
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         port = __port_to_int(port, proto)
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_7);
+    __Pyx_XGOTREF(__pyx_t_8);
+    /*try:*/ {
+
+      /* "uvloop/dns.pyx":198
+ * 
+ *     try:
+ *         port = __port_to_int(port, proto)             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         return
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_proto); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 198, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __pyx_f_6uvloop_4loop___port_to_int(__pyx_v_port, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 198, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF_SET(__pyx_v_port, __pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/dns.pyx":197
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         port = __port_to_int(port, proto)
+ *     except Exception:
+ */
+    }
+    __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;
+    goto __pyx_L13_try_end;
+    __pyx_L8_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/dns.pyx":199
+ *     try:
+ *         port = __port_to_int(port, proto)
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+    __pyx_t_1 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_1) {
+      __Pyx_AddTraceback("uvloop.loop.__static_getaddrinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_9) < 0) __PYX_ERR(5, 199, __pyx_L10_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_9);
+
+      /* "uvloop/dns.pyx":200
+ *         port = __port_to_int(port, proto)
+ *     except Exception:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     hp = (host, port)
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      goto __pyx_L11_except_return;
+    }
+    goto __pyx_L10_except_error;
+    __pyx_L10_except_error:;
+
+    /* "uvloop/dns.pyx":197
+ *         return
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         port = __port_to_int(port, proto)
+ *     except Exception:
+ */
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_7);
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+    goto __pyx_L1_error;
+    __pyx_L11_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_7);
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+    goto __pyx_L0;
+    __pyx_L13_try_end:;
+  }
+
+  /* "uvloop/dns.pyx":202
+ *         return
+ * 
+ *     hp = (host, port)             # <<<<<<<<<<<<<<
+ *     if family == uv.AF_UNSPEC:
+ *         try:
+ */
+  __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_INCREF(__pyx_v_host);
+  __Pyx_GIVEREF(__pyx_v_host);
+  PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_v_host);
+  __Pyx_INCREF(__pyx_v_port);
+  __Pyx_GIVEREF(__pyx_v_port);
+  PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_v_port);
+  __pyx_v_hp = ((PyObject*)__pyx_t_9);
+  __pyx_t_9 = 0;
+
+  /* "uvloop/dns.pyx":203
+ * 
+ *     hp = (host, port)
+ *     if family == uv.AF_UNSPEC:             # <<<<<<<<<<<<<<
+ *         try:
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET, hp, addr)
+ */
+  __pyx_t_3 = ((__pyx_v_family == AF_UNSPEC) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/dns.pyx":204
+ *     hp = (host, port)
+ *     if family == uv.AF_UNSPEC:
+ *         try:             # <<<<<<<<<<<<<<
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET, hp, addr)
+ *         except Exception:
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_6);
+      /*try:*/ {
+
+        /* "uvloop/dns.pyx":205
+ *     if family == uv.AF_UNSPEC:
+ *         try:
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET, hp, addr)             # <<<<<<<<<<<<<<
+ *         except Exception:
+ *             pass
+ */
+        __pyx_t_9 = __pyx_f_6uvloop_4loop___convert_pyaddr_to_sockaddr(AF_INET, __pyx_v_hp, __pyx_v_addr); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 205, __pyx_L17_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        /* "uvloop/dns.pyx":204
+ *     hp = (host, port)
+ *     if family == uv.AF_UNSPEC:
+ *         try:             # <<<<<<<<<<<<<<
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET, hp, addr)
+ *         except Exception:
+ */
+      }
+
+      /* "uvloop/dns.pyx":209
+ *             pass
+ *         else:
+ *             return (uv.AF_INET, type, proto)             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+      /*else:*/ {
+        __Pyx_XDECREF(__pyx_r);
+        __pyx_t_9 = __Pyx_PyInt_From_int(AF_INET); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 209, __pyx_L19_except_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 209, __pyx_L19_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_proto); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 209, __pyx_L19_except_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_10 = PyTuple_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(5, 209, __pyx_L19_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_GIVEREF(__pyx_t_9);
+        PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9);
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_5);
+        PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_t_5);
+        __pyx_t_9 = 0;
+        __pyx_t_4 = 0;
+        __pyx_t_5 = 0;
+        __pyx_r = __pyx_t_10;
+        __pyx_t_10 = 0;
+        goto __pyx_L20_except_return;
+      }
+      __pyx_L17_error:;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/dns.pyx":206
+ *         try:
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET, hp, addr)
+ *         except Exception:             # <<<<<<<<<<<<<<
+ *             pass
+ *         else:
+ */
+      __pyx_t_1 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+      if (__pyx_t_1) {
+        __Pyx_ErrRestore(0,0,0);
+        goto __pyx_L18_exception_handled;
+      }
+      goto __pyx_L19_except_error;
+      __pyx_L19_except_error:;
+
+      /* "uvloop/dns.pyx":204
+ *     hp = (host, port)
+ *     if family == uv.AF_UNSPEC:
+ *         try:             # <<<<<<<<<<<<<<
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET, hp, addr)
+ *         except Exception:
+ */
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_7, __pyx_t_6);
+      goto __pyx_L1_error;
+      __pyx_L20_except_return:;
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_7, __pyx_t_6);
+      goto __pyx_L0;
+      __pyx_L18_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_7, __pyx_t_6);
+    }
+
+    /* "uvloop/dns.pyx":211
+ *             return (uv.AF_INET, type, proto)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET6, hp, addr)
+ *         except Exception:
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
+      /*try:*/ {
+
+        /* "uvloop/dns.pyx":212
+ * 
+ *         try:
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET6, hp, addr)             # <<<<<<<<<<<<<<
+ *         except Exception:
+ *             pass
+ */
+        __pyx_t_10 = __pyx_f_6uvloop_4loop___convert_pyaddr_to_sockaddr(AF_INET6, __pyx_v_hp, __pyx_v_addr); if (unlikely(!__pyx_t_10)) __PYX_ERR(5, 212, __pyx_L23_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+        /* "uvloop/dns.pyx":211
+ *             return (uv.AF_INET, type, proto)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET6, hp, addr)
+ *         except Exception:
+ */
+      }
+
+      /* "uvloop/dns.pyx":216
+ *             pass
+ *         else:
+ *             return (uv.AF_INET6, type, proto)             # <<<<<<<<<<<<<<
+ * 
+ *     else:
+ */
+      /*else:*/ {
+        __Pyx_XDECREF(__pyx_r);
+        __pyx_t_10 = __Pyx_PyInt_From_int(AF_INET6); if (unlikely(!__pyx_t_10)) __PYX_ERR(5, 216, __pyx_L25_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 216, __pyx_L25_except_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_proto); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 216, __pyx_L25_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_9 = PyTuple_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 216, __pyx_L25_except_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_GIVEREF(__pyx_t_10);
+        PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10);
+        __Pyx_GIVEREF(__pyx_t_5);
+        PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_5);
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_t_4);
+        __pyx_t_10 = 0;
+        __pyx_t_5 = 0;
+        __pyx_t_4 = 0;
+        __pyx_r = __pyx_t_9;
+        __pyx_t_9 = 0;
+        goto __pyx_L26_except_return;
+      }
+      __pyx_L23_error:;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/dns.pyx":213
+ *         try:
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET6, hp, addr)
+ *         except Exception:             # <<<<<<<<<<<<<<
+ *             pass
+ *         else:
+ */
+      __pyx_t_1 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+      if (__pyx_t_1) {
+        __Pyx_ErrRestore(0,0,0);
+        goto __pyx_L24_exception_handled;
+      }
+      goto __pyx_L25_except_error;
+      __pyx_L25_except_error:;
+
+      /* "uvloop/dns.pyx":211
+ *             return (uv.AF_INET, type, proto)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET6, hp, addr)
+ *         except Exception:
+ */
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      goto __pyx_L1_error;
+      __pyx_L26_except_return:;
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      goto __pyx_L0;
+      __pyx_L24_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+    }
+
+    /* "uvloop/dns.pyx":203
+ * 
+ *     hp = (host, port)
+ *     if family == uv.AF_UNSPEC:             # <<<<<<<<<<<<<<
+ *         try:
+ *             __convert_pyaddr_to_sockaddr(uv.AF_INET, hp, addr)
+ */
+    goto __pyx_L16;
+  }
+
+  /* "uvloop/dns.pyx":219
+ * 
+ *     else:
+ *         try:             # <<<<<<<<<<<<<<
+ *             __convert_pyaddr_to_sockaddr(family, hp, addr)
+ *         except Exception:
+ */
+  /*else*/ {
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_6);
+      /*try:*/ {
+
+        /* "uvloop/dns.pyx":220
+ *     else:
+ *         try:
+ *             __convert_pyaddr_to_sockaddr(family, hp, addr)             # <<<<<<<<<<<<<<
+ *         except Exception:
+ *             pass
+ */
+        __pyx_t_9 = __pyx_f_6uvloop_4loop___convert_pyaddr_to_sockaddr(__pyx_v_family, __pyx_v_hp, __pyx_v_addr); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 220, __pyx_L29_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        /* "uvloop/dns.pyx":219
+ * 
+ *     else:
+ *         try:             # <<<<<<<<<<<<<<
+ *             __convert_pyaddr_to_sockaddr(family, hp, addr)
+ *         except Exception:
+ */
+      }
+
+      /* "uvloop/dns.pyx":224
+ *             pass
+ *         else:
+ *             return (family, type, proto)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+      /*else:*/ {
+        __Pyx_XDECREF(__pyx_r);
+        __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_family); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 224, __pyx_L31_except_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 224, __pyx_L31_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_proto); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 224, __pyx_L31_except_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_10 = PyTuple_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(5, 224, __pyx_L31_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_GIVEREF(__pyx_t_9);
+        PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9);
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_5);
+        PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_t_5);
+        __pyx_t_9 = 0;
+        __pyx_t_4 = 0;
+        __pyx_t_5 = 0;
+        __pyx_r = __pyx_t_10;
+        __pyx_t_10 = 0;
+        goto __pyx_L32_except_return;
+      }
+      __pyx_L29_error:;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/dns.pyx":221
+ *         try:
+ *             __convert_pyaddr_to_sockaddr(family, hp, addr)
+ *         except Exception:             # <<<<<<<<<<<<<<
+ *             pass
+ *         else:
+ */
+      __pyx_t_1 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+      if (__pyx_t_1) {
+        __Pyx_ErrRestore(0,0,0);
+        goto __pyx_L30_exception_handled;
+      }
+      goto __pyx_L31_except_error;
+      __pyx_L31_except_error:;
+
+      /* "uvloop/dns.pyx":219
+ * 
+ *     else:
+ *         try:             # <<<<<<<<<<<<<<
+ *             __convert_pyaddr_to_sockaddr(family, hp, addr)
+ *         except Exception:
+ */
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_7, __pyx_t_6);
+      goto __pyx_L1_error;
+      __pyx_L32_except_return:;
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_7, __pyx_t_6);
+      goto __pyx_L0;
+      __pyx_L30_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_7, __pyx_t_6);
+    }
+  }
+  __pyx_L16:;
+
+  /* "uvloop/dns.pyx":182
+ * 
+ * 
+ * cdef __static_getaddrinfo(object host, object port,             # <<<<<<<<<<<<<<
+ *                           int family, int type,
+ *                           int proto,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("uvloop.loop.__static_getaddrinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_hp);
+  __Pyx_XDECREF(__pyx_v_port);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":227
+ * 
+ * 
+ * cdef __static_getaddrinfo_pyaddr(object host, object port,             # <<<<<<<<<<<<<<
+ *                                  int family, int type,
+ *                                  int proto, int flags):
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___static_getaddrinfo_pyaddr(PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, CYTHON_UNUSED int __pyx_v_flags) {
+  struct sockaddr_storage __pyx_v_addr;
+  PyObject *__pyx_v_triplet = 0;
+  PyObject *__pyx_v_af = NULL;
+  PyObject *__pyx_v_pyaddr = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *(*__pyx_t_7)(PyObject *);
+  int __pyx_t_8;
+  int __pyx_t_9;
+  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("__static_getaddrinfo_pyaddr", 0);
+
+  /* "uvloop/dns.pyx":235
+ *         object triplet
+ * 
+ *     triplet = __static_getaddrinfo(             # <<<<<<<<<<<<<<
+ *         host, port, family, type,
+ *         proto, <system.sockaddr*>&addr)
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___static_getaddrinfo(__pyx_v_host, __pyx_v_port, __pyx_v_family, __pyx_v_type, __pyx_v_proto, ((struct sockaddr *)(&__pyx_v_addr))); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_triplet = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/dns.pyx":238
+ *         host, port, family, type,
+ *         proto, <system.sockaddr*>&addr)
+ *     if triplet is None:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_triplet == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/dns.pyx":239
+ *         proto, <system.sockaddr*>&addr)
+ *     if triplet is None:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     af, type, proto = triplet
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/dns.pyx":238
+ *         host, port, family, type,
+ *         proto, <system.sockaddr*>&addr)
+ *     if triplet is None:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  }
+
+  /* "uvloop/dns.pyx":241
+ *         return
+ * 
+ *     af, type, proto = triplet             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+  if ((likely(PyTuple_CheckExact(__pyx_v_triplet))) || (PyList_CheckExact(__pyx_v_triplet))) {
+    PyObject* sequence = __pyx_v_triplet;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(5, 241, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_5 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_1 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_4 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_5 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_5);
+    #else
+    __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 241, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 241, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 241, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    #endif
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_6 = PyObject_GetIter(__pyx_v_triplet); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 241, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext;
+    index = 0; __pyx_t_1 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_1)) goto __pyx_L4_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_1);
+    index = 1; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L4_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_4);
+    index = 2; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L4_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_5);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 3) < 0) __PYX_ERR(5, 241, __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_6); __pyx_t_6 = 0;
+    __pyx_t_7 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(5, 241, __pyx_L1_error)
+    __pyx_L5_unpacking_done:;
+  }
+  __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 241, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 241, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_af = __pyx_t_1;
+  __pyx_t_1 = 0;
+  __pyx_v_type = __pyx_t_8;
+  __pyx_v_proto = __pyx_t_9;
+
+  /* "uvloop/dns.pyx":243
+ *     af, type, proto = triplet
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyaddr = __convert_sockaddr_to_pyaddr(<system.sockaddr*>&addr)
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
+    __Pyx_XGOTREF(__pyx_t_10);
+    __Pyx_XGOTREF(__pyx_t_11);
+    __Pyx_XGOTREF(__pyx_t_12);
+    /*try:*/ {
+
+      /* "uvloop/dns.pyx":244
+ * 
+ *     try:
+ *         pyaddr = __convert_sockaddr_to_pyaddr(<system.sockaddr*>&addr)             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         return
+ */
+      __pyx_t_5 = __pyx_f_6uvloop_4loop___convert_sockaddr_to_pyaddr(((struct sockaddr *)(&__pyx_v_addr))); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 244, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_v_pyaddr = __pyx_t_5;
+      __pyx_t_5 = 0;
+
+      /* "uvloop/dns.pyx":243
+ *     af, type, proto = triplet
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyaddr = __convert_sockaddr_to_pyaddr(<system.sockaddr*>&addr)
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+    goto __pyx_L11_try_end;
+    __pyx_L6_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/dns.pyx":245
+ *     try:
+ *         pyaddr = __convert_sockaddr_to_pyaddr(<system.sockaddr*>&addr)
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+    __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_9) {
+      __Pyx_AddTraceback("uvloop.loop.__static_getaddrinfo_pyaddr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_1) < 0) __PYX_ERR(5, 245, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_1);
+
+      /* "uvloop/dns.pyx":246
+ *         pyaddr = __convert_sockaddr_to_pyaddr(<system.sockaddr*>&addr)
+ *     except Exception:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     return af, type, proto, '', pyaddr
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      goto __pyx_L9_except_return;
+    }
+    goto __pyx_L8_except_error;
+    __pyx_L8_except_error:;
+
+    /* "uvloop/dns.pyx":243
+ *     af, type, proto = triplet
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         pyaddr = __convert_sockaddr_to_pyaddr(<system.sockaddr*>&addr)
+ *     except Exception:
+ */
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_XGIVEREF(__pyx_t_11);
+    __Pyx_XGIVEREF(__pyx_t_12);
+    __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+    goto __pyx_L1_error;
+    __pyx_L9_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_XGIVEREF(__pyx_t_11);
+    __Pyx_XGIVEREF(__pyx_t_12);
+    __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+    goto __pyx_L0;
+    __pyx_L11_try_end:;
+  }
+
+  /* "uvloop/dns.pyx":248
+ *         return
+ * 
+ *     return af, type, proto, '', pyaddr             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_proto); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(__pyx_v_af);
+  __Pyx_GIVEREF(__pyx_v_af);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_af);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
+  __Pyx_INCREF(__pyx_kp_u__8);
+  __Pyx_GIVEREF(__pyx_kp_u__8);
+  PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_kp_u__8);
+  __Pyx_INCREF(__pyx_v_pyaddr);
+  __Pyx_GIVEREF(__pyx_v_pyaddr);
+  PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_v_pyaddr);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/dns.pyx":227
+ * 
+ * 
+ * cdef __static_getaddrinfo_pyaddr(object host, object port,             # <<<<<<<<<<<<<<
+ *                                  int family, int type,
+ *                                  int proto, int flags):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.__static_getaddrinfo_pyaddr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_triplet);
+  __Pyx_XDECREF(__pyx_v_af);
+  __Pyx_XDECREF(__pyx_v_pyaddr);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":256
+ *         system.addrinfo *data
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.data = NULL
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_8AddrInfo_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_8AddrInfo_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_6uvloop_4loop_8AddrInfo___cinit__(((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_8AddrInfo___cinit__(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "uvloop/dns.pyx":257
+ * 
+ *     def __cinit__(self):
+ *         self.data = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->data = NULL;
+
+  /* "uvloop/dns.pyx":256
+ *         system.addrinfo *data
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.data = NULL
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":259
+ *         self.data = NULL
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self.data is not NULL:
+ *             uv.uv_freeaddrinfo(self.data)  # returns void
+ */
+
+/* Python wrapper */
+static void __pyx_pw_6uvloop_4loop_8AddrInfo_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_6uvloop_4loop_8AddrInfo_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_6uvloop_4loop_8AddrInfo_2__dealloc__(((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_6uvloop_4loop_8AddrInfo_2__dealloc__(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "uvloop/dns.pyx":260
+ * 
+ *     def __dealloc__(self):
+ *         if self.data is not NULL:             # <<<<<<<<<<<<<<
+ *             uv.uv_freeaddrinfo(self.data)  # returns void
+ *             self.data = NULL
+ */
+  __pyx_t_1 = ((__pyx_v_self->data != NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/dns.pyx":261
+ *     def __dealloc__(self):
+ *         if self.data is not NULL:
+ *             uv.uv_freeaddrinfo(self.data)  # returns void             # <<<<<<<<<<<<<<
+ *             self.data = NULL
+ * 
+ */
+    uv_freeaddrinfo(__pyx_v_self->data);
+
+    /* "uvloop/dns.pyx":262
+ *         if self.data is not NULL:
+ *             uv.uv_freeaddrinfo(self.data)  # returns void
+ *             self.data = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     cdef void set_data(self, system.addrinfo *data):
+ */
+    __pyx_v_self->data = NULL;
+
+    /* "uvloop/dns.pyx":260
+ * 
+ *     def __dealloc__(self):
+ *         if self.data is not NULL:             # <<<<<<<<<<<<<<
+ *             uv.uv_freeaddrinfo(self.data)  # returns void
+ *             self.data = NULL
+ */
+  }
+
+  /* "uvloop/dns.pyx":259
+ *         self.data = NULL
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self.data is not NULL:
+ *             uv.uv_freeaddrinfo(self.data)  # returns void
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/dns.pyx":264
+ *             self.data = NULL
+ * 
+ *     cdef void set_data(self, system.addrinfo *data):             # <<<<<<<<<<<<<<
+ *         self.data = data
+ * 
+ */
+
+static void __pyx_f_6uvloop_4loop_8AddrInfo_set_data(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self, struct addrinfo *__pyx_v_data) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_data", 0);
+
+  /* "uvloop/dns.pyx":265
+ * 
+ *     cdef void set_data(self, system.addrinfo *data):
+ *         self.data = data             # <<<<<<<<<<<<<<
+ * 
+ *     cdef unpack(self):
+ */
+  __pyx_v_self->data = __pyx_v_data;
+
+  /* "uvloop/dns.pyx":264
+ *             self.data = NULL
+ * 
+ *     cdef void set_data(self, system.addrinfo *data):             # <<<<<<<<<<<<<<
+ *         self.data = data
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/dns.pyx":267
+ *         self.data = data
+ * 
+ *     cdef unpack(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             list result = []
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_8AddrInfo_unpack(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self) {
+  PyObject *__pyx_v_result = 0;
+  struct addrinfo *__pyx_v_ptr;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  struct addrinfo *__pyx_t_3;
+  unsigned short __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("unpack", 0);
+
+  /* "uvloop/dns.pyx":269
+ *     cdef unpack(self):
+ *         cdef:
+ *             list result = []             # <<<<<<<<<<<<<<
+ *             system.addrinfo *ptr
+ * 
+ */
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_result = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/dns.pyx":272
+ *             system.addrinfo *ptr
+ * 
+ *         if self.data is NULL:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('AddrInfo.data is NULL')
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_self->data == NULL) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/dns.pyx":273
+ * 
+ *         if self.data is NULL:
+ *             raise RuntimeError('AddrInfo.data is NULL')             # <<<<<<<<<<<<<<
+ * 
+ *         ptr = self.data
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__208, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 273, __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(5, 273, __pyx_L1_error)
+
+    /* "uvloop/dns.pyx":272
+ *             system.addrinfo *ptr
+ * 
+ *         if self.data is NULL:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('AddrInfo.data is NULL')
+ * 
+ */
+  }
+
+  /* "uvloop/dns.pyx":275
+ *             raise RuntimeError('AddrInfo.data is NULL')
+ * 
+ *         ptr = self.data             # <<<<<<<<<<<<<<
+ *         while ptr != NULL:
+ *             if ptr.ai_addr.sa_family in (uv.AF_INET, uv.AF_INET6):
+ */
+  __pyx_t_3 = __pyx_v_self->data;
+  __pyx_v_ptr = __pyx_t_3;
+
+  /* "uvloop/dns.pyx":276
+ * 
+ *         ptr = self.data
+ *         while ptr != NULL:             # <<<<<<<<<<<<<<
+ *             if ptr.ai_addr.sa_family in (uv.AF_INET, uv.AF_INET6):
+ *                 result.append((
+ */
+  while (1) {
+    __pyx_t_2 = ((__pyx_v_ptr != NULL) != 0);
+    if (!__pyx_t_2) break;
+
+    /* "uvloop/dns.pyx":277
+ *         ptr = self.data
+ *         while ptr != NULL:
+ *             if ptr.ai_addr.sa_family in (uv.AF_INET, uv.AF_INET6):             # <<<<<<<<<<<<<<
+ *                 result.append((
+ *                     ptr.ai_family,
+ */
+    __pyx_t_4 = __pyx_v_ptr->ai_addr->sa_family;
+    __pyx_t_5 = ((__pyx_t_4 == AF_INET) != 0);
+    if (!__pyx_t_5) {
+    } else {
+      __pyx_t_2 = __pyx_t_5;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_5 = ((__pyx_t_4 == AF_INET6) != 0);
+    __pyx_t_2 = __pyx_t_5;
+    __pyx_L7_bool_binop_done:;
+    __pyx_t_5 = (__pyx_t_2 != 0);
+    if (__pyx_t_5) {
+
+      /* "uvloop/dns.pyx":279
+ *             if ptr.ai_addr.sa_family in (uv.AF_INET, uv.AF_INET6):
+ *                 result.append((
+ *                     ptr.ai_family,             # <<<<<<<<<<<<<<
+ *                     ptr.ai_socktype,
+ *                     ptr.ai_protocol,
+ */
+      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ptr->ai_family); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 279, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+
+      /* "uvloop/dns.pyx":280
+ *                 result.append((
+ *                     ptr.ai_family,
+ *                     ptr.ai_socktype,             # <<<<<<<<<<<<<<
+ *                     ptr.ai_protocol,
+ *                     ('' if ptr.ai_canonname is NULL else
+ */
+      __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_ptr->ai_socktype); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 280, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+
+      /* "uvloop/dns.pyx":281
+ *                     ptr.ai_family,
+ *                     ptr.ai_socktype,
+ *                     ptr.ai_protocol,             # <<<<<<<<<<<<<<
+ *                     ('' if ptr.ai_canonname is NULL else
+ *                         (<bytes>ptr.ai_canonname).decode()),
+ */
+      __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_ptr->ai_protocol); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 281, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "uvloop/dns.pyx":282
+ *                     ptr.ai_socktype,
+ *                     ptr.ai_protocol,
+ *                     ('' if ptr.ai_canonname is NULL else             # <<<<<<<<<<<<<<
+ *                         (<bytes>ptr.ai_canonname).decode()),
+ *                     __convert_sockaddr_to_pyaddr(ptr.ai_addr)
+ */
+      if (((__pyx_v_ptr->ai_canonname == NULL) != 0)) {
+        __Pyx_INCREF(__pyx_kp_u__8);
+        __pyx_t_8 = __pyx_kp_u__8;
+      } else {
+
+        /* "uvloop/dns.pyx":283
+ *                     ptr.ai_protocol,
+ *                     ('' if ptr.ai_canonname is NULL else
+ *                         (<bytes>ptr.ai_canonname).decode()),             # <<<<<<<<<<<<<<
+ *                     __convert_sockaddr_to_pyaddr(ptr.ai_addr)
+ *                 ))
+ */
+        __pyx_t_9 = __Pyx_PyBytes_FromString(__pyx_v_ptr->ai_canonname); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 283, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        if (unlikely(__pyx_t_9 == Py_None)) {
+          PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode");
+          __PYX_ERR(5, 283, __pyx_L1_error)
+        }
+        __pyx_t_10 = __Pyx_decode_bytes(((PyObject*)__pyx_t_9), 0, PY_SSIZE_T_MAX, NULL, NULL, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(5, 283, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __pyx_t_8 = __pyx_t_10;
+        __pyx_t_10 = 0;
+      }
+
+      /* "uvloop/dns.pyx":284
+ *                     ('' if ptr.ai_canonname is NULL else
+ *                         (<bytes>ptr.ai_canonname).decode()),
+ *                     __convert_sockaddr_to_pyaddr(ptr.ai_addr)             # <<<<<<<<<<<<<<
+ *                 ))
+ * 
+ */
+      __pyx_t_10 = __pyx_f_6uvloop_4loop___convert_sockaddr_to_pyaddr(__pyx_v_ptr->ai_addr); if (unlikely(!__pyx_t_10)) __PYX_ERR(5, 284, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+
+      /* "uvloop/dns.pyx":279
+ *             if ptr.ai_addr.sa_family in (uv.AF_INET, uv.AF_INET6):
+ *                 result.append((
+ *                     ptr.ai_family,             # <<<<<<<<<<<<<<
+ *                     ptr.ai_socktype,
+ *                     ptr.ai_protocol,
+ */
+      __pyx_t_9 = PyTuple_New(5); if (unlikely(!__pyx_t_9)) __PYX_ERR(5, 279, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_GIVEREF(__pyx_t_1);
+      PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_7);
+      PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_t_7);
+      __Pyx_GIVEREF(__pyx_t_8);
+      PyTuple_SET_ITEM(__pyx_t_9, 3, __pyx_t_8);
+      __Pyx_GIVEREF(__pyx_t_10);
+      PyTuple_SET_ITEM(__pyx_t_9, 4, __pyx_t_10);
+      __pyx_t_1 = 0;
+      __pyx_t_6 = 0;
+      __pyx_t_7 = 0;
+      __pyx_t_8 = 0;
+      __pyx_t_10 = 0;
+
+      /* "uvloop/dns.pyx":278
+ *         while ptr != NULL:
+ *             if ptr.ai_addr.sa_family in (uv.AF_INET, uv.AF_INET6):
+ *                 result.append((             # <<<<<<<<<<<<<<
+ *                     ptr.ai_family,
+ *                     ptr.ai_socktype,
+ */
+      __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_9); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(5, 278, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/dns.pyx":277
+ *         ptr = self.data
+ *         while ptr != NULL:
+ *             if ptr.ai_addr.sa_family in (uv.AF_INET, uv.AF_INET6):             # <<<<<<<<<<<<<<
+ *                 result.append((
+ *                     ptr.ai_family,
+ */
+    }
+
+    /* "uvloop/dns.pyx":287
+ *                 ))
+ * 
+ *             ptr = ptr.ai_next             # <<<<<<<<<<<<<<
+ * 
+ *         return result
+ */
+    __pyx_t_3 = __pyx_v_ptr->ai_next;
+    __pyx_v_ptr = __pyx_t_3;
+  }
+
+  /* "uvloop/dns.pyx":289
+ *             ptr = ptr.ai_next
+ * 
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_result);
+  __pyx_r = __pyx_v_result;
+  goto __pyx_L0;
+
+  /* "uvloop/dns.pyx":267
+ *         self.data = data
+ * 
+ *     cdef unpack(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             list result = []
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("uvloop.loop.AddrInfo.unpack", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":292
+ * 
+ *     @staticmethod
+ *     cdef int isinstance(object other):             # <<<<<<<<<<<<<<
+ *         return type(other) is AddrInfo
+ * 
+ */
+
+static int __pyx_f_6uvloop_4loop_8AddrInfo_isinstance(PyObject *__pyx_v_other) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("isinstance", 0);
+
+  /* "uvloop/dns.pyx":293
+ *     @staticmethod
+ *     cdef int isinstance(object other):
+ *         return type(other) is AddrInfo             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_other)) == ((PyObject *)__pyx_ptype_6uvloop_4loop_AddrInfo));
+  __pyx_r = __pyx_t_1;
+  goto __pyx_L0;
+
+  /* "uvloop/dns.pyx":292
+ * 
+ *     @staticmethod
+ *     cdef int isinstance(object other):             # <<<<<<<<<<<<<<
+ *         return type(other) is AddrInfo
+ * 
+ */
+
+  /* function exit code */
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_8AddrInfo_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8AddrInfo_4__reduce_cython__[] = "AddrInfo.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_8AddrInfo_5__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_6uvloop_4loop_8AddrInfo_4__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8AddrInfo_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_AddrInfo *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__209, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.AddrInfo.__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_6uvloop_4loop_8AddrInfo_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_8AddrInfo_6__setstate_cython__[] = "AddrInfo.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_8AddrInfo_7__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_6uvloop_4loop_8AddrInfo_6__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_8AddrInfo_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_AddrInfo *__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);
+
+  /* "(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__210, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.AddrInfo.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":302
+ *         uv.uv_getaddrinfo_t _req_data
+ * 
+ *     def __cinit__(self, Loop loop,             # <<<<<<<<<<<<<<
+ *                   bytes host, bytes port,
+ *                   int family, int type, int proto, int flags,
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_15AddrInfoRequest_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_15AddrInfoRequest_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  PyObject *__pyx_v_host = 0;
+  PyObject *__pyx_v_port = 0;
+  int __pyx_v_family;
+  int __pyx_v_type;
+  int __pyx_v_proto;
+  int __pyx_v_flags;
+  PyObject *__pyx_v_callback = 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_loop,&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_family,&__pyx_n_s_type,&__pyx_n_s_proto,&__pyx_n_s_flags,&__pyx_n_s_callback,0};
+    PyObject* values[8] = {0,0,0,0,0,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  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+        CYTHON_FALLTHROUGH;
+        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+        CYTHON_FALLTHROUGH;
+        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+        CYTHON_FALLTHROUGH;
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        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);
+        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_loop)) != 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_host)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 8, 8, 1); __PYX_ERR(5, 302, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_port)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 8, 8, 2); __PYX_ERR(5, 302, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_family)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 8, 8, 3); __PYX_ERR(5, 302, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_type)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 8, 8, 4); __PYX_ERR(5, 302, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  5:
+        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_proto)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 8, 8, 5); __PYX_ERR(5, 302, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  6:
+        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 8, 8, 6); __PYX_ERR(5, 302, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  7:
+        if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 8, 8, 7); __PYX_ERR(5, 302, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(5, 302, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 8) {
+      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[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+      values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+      values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+    }
+    __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)values[0]);
+    __pyx_v_host = ((PyObject*)values[1]);
+    __pyx_v_port = ((PyObject*)values[2]);
+    __pyx_v_family = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_family == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 304, __pyx_L3_error)
+    __pyx_v_type = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 304, __pyx_L3_error)
+    __pyx_v_proto = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_proto == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 304, __pyx_L3_error)
+    __pyx_v_flags = __Pyx_PyInt_As_int(values[6]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 304, __pyx_L3_error)
+    __pyx_v_callback = values[7];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 8, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(5, 302, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.AddrInfoRequest.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6uvloop_4loop_Loop, 1, "loop", 0))) __PYX_ERR(5, 302, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_host), (&PyBytes_Type), 1, "host", 1))) __PYX_ERR(5, 303, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_port), (&PyBytes_Type), 1, "port", 1))) __PYX_ERR(5, 303, __pyx_L1_error)
+  __pyx_r = __pyx_pf_6uvloop_4loop_15AddrInfoRequest___cinit__(((struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *)__pyx_v_self), __pyx_v_loop, __pyx_v_host, __pyx_v_port, __pyx_v_family, __pyx_v_type, __pyx_v_proto, __pyx_v_flags, __pyx_v_callback);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_15AddrInfoRequest___cinit__(struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_flags, PyObject *__pyx_v_callback) {
+  int __pyx_v_err;
+  char *__pyx_v_chost;
+  char *__pyx_v_cport;
+  PyObject *__pyx_v_msg = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  char *__pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  char const *__pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "uvloop/dns.pyx":312
+ *             char *cport
+ * 
+ *         if host is None:             # <<<<<<<<<<<<<<
+ *             chost = NULL
+ *         else:
+ */
+  __pyx_t_1 = (__pyx_v_host == ((PyObject*)Py_None));
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/dns.pyx":313
+ * 
+ *         if host is None:
+ *             chost = NULL             # <<<<<<<<<<<<<<
+ *         else:
+ *             chost = <char*>host
+ */
+    __pyx_v_chost = NULL;
+
+    /* "uvloop/dns.pyx":312
+ *             char *cport
+ * 
+ *         if host is None:             # <<<<<<<<<<<<<<
+ *             chost = NULL
+ *         else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/dns.pyx":315
+ *             chost = NULL
+ *         else:
+ *             chost = <char*>host             # <<<<<<<<<<<<<<
+ * 
+ *         if port is None:
+ */
+  /*else*/ {
+    if (unlikely(__pyx_v_host == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
+      __PYX_ERR(5, 315, __pyx_L1_error)
+    }
+    __pyx_t_3 = __Pyx_PyBytes_AsWritableString(__pyx_v_host); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(5, 315, __pyx_L1_error)
+    __pyx_v_chost = ((char *)__pyx_t_3);
+  }
+  __pyx_L3:;
+
+  /* "uvloop/dns.pyx":317
+ *             chost = <char*>host
+ * 
+ *         if port is None:             # <<<<<<<<<<<<<<
+ *             cport = NULL
+ *         else:
+ */
+  __pyx_t_2 = (__pyx_v_port == ((PyObject*)Py_None));
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/dns.pyx":318
+ * 
+ *         if port is None:
+ *             cport = NULL             # <<<<<<<<<<<<<<
+ *         else:
+ *             cport = <char*>port
+ */
+    __pyx_v_cport = NULL;
+
+    /* "uvloop/dns.pyx":317
+ *             chost = <char*>host
+ * 
+ *         if port is None:             # <<<<<<<<<<<<<<
+ *             cport = NULL
+ *         else:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/dns.pyx":320
+ *             cport = NULL
+ *         else:
+ *             cport = <char*>port             # <<<<<<<<<<<<<<
+ * 
+ *         if cport is NULL and chost is NULL:
+ */
+  /*else*/ {
+    if (unlikely(__pyx_v_port == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
+      __PYX_ERR(5, 320, __pyx_L1_error)
+    }
+    __pyx_t_3 = __Pyx_PyBytes_AsWritableString(__pyx_v_port); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(5, 320, __pyx_L1_error)
+    __pyx_v_cport = ((char *)__pyx_t_3);
+  }
+  __pyx_L4:;
+
+  /* "uvloop/dns.pyx":322
+ *             cport = <char*>port
+ * 
+ *         if cport is NULL and chost is NULL:             # <<<<<<<<<<<<<<
+ *             self.on_done()
+ *             msg = system.gai_strerror(socket_EAI_NONAME).decode('utf-8')
+ */
+  __pyx_t_2 = ((__pyx_v_cport == NULL) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_2 = ((__pyx_v_chost == NULL) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L6_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/dns.pyx":323
+ * 
+ *         if cport is NULL and chost is NULL:
+ *             self.on_done()             # <<<<<<<<<<<<<<
+ *             msg = system.gai_strerror(socket_EAI_NONAME).decode('utf-8')
+ *             ex = socket_gaierror(socket_EAI_NONAME, msg)
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_AddrInfoRequest *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 323, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/dns.pyx":324
+ *         if cport is NULL and chost is NULL:
+ *             self.on_done()
+ *             msg = system.gai_strerror(socket_EAI_NONAME).decode('utf-8')             # <<<<<<<<<<<<<<
+ *             ex = socket_gaierror(socket_EAI_NONAME, msg)
+ *             callback(ex)
+ */
+    __pyx_t_5 = gai_strerror(__pyx_v_6uvloop_4loop_socket_EAI_NONAME);
+    __pyx_t_4 = __Pyx_decode_c_string(__pyx_t_5, 0, strlen(__pyx_t_5), NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 324, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_4);
+    __pyx_v_msg = __pyx_t_4;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/dns.pyx":325
+ *             self.on_done()
+ *             msg = system.gai_strerror(socket_EAI_NONAME).decode('utf-8')
+ *             ex = socket_gaierror(socket_EAI_NONAME, msg)             # <<<<<<<<<<<<<<
+ *             callback(ex)
+ *             return
+ */
+    __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_socket_EAI_NONAME); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 325, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_gaierror);
+    __pyx_t_7 = __pyx_v_6uvloop_4loop_socket_gaierror; __pyx_t_8 = NULL;
+    __pyx_t_9 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+        __pyx_t_9 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_7)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_v_msg};
+      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 325, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 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_7)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_v_msg};
+      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 325, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(5, 325, __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_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6);
+      __Pyx_INCREF(__pyx_v_msg);
+      __Pyx_GIVEREF(__pyx_v_msg);
+      PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_v_msg);
+      __pyx_t_6 = 0;
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 325, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_v_ex = __pyx_t_4;
+    __pyx_t_4 = 0;
+
+    /* "uvloop/dns.pyx":326
+ *             msg = system.gai_strerror(socket_EAI_NONAME).decode('utf-8')
+ *             ex = socket_gaierror(socket_EAI_NONAME, msg)
+ *             callback(ex)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __Pyx_INCREF(__pyx_v_callback);
+    __pyx_t_7 = __pyx_v_callback; __pyx_t_10 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_10)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_10);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_10, __pyx_v_ex) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_ex);
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 326, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/dns.pyx":327
+ *             ex = socket_gaierror(socket_EAI_NONAME, msg)
+ *             callback(ex)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         memset(&self.hints, 0, sizeof(system.addrinfo))
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/dns.pyx":322
+ *             cport = <char*>port
+ * 
+ *         if cport is NULL and chost is NULL:             # <<<<<<<<<<<<<<
+ *             self.on_done()
+ *             msg = system.gai_strerror(socket_EAI_NONAME).decode('utf-8')
+ */
+  }
+
+  /* "uvloop/dns.pyx":329
+ *             return
+ * 
+ *         memset(&self.hints, 0, sizeof(system.addrinfo))             # <<<<<<<<<<<<<<
+ *         self.hints.ai_flags = flags
+ *         self.hints.ai_family = family
+ */
+  (void)(memset((&__pyx_v_self->hints), 0, (sizeof(struct addrinfo))));
+
+  /* "uvloop/dns.pyx":330
+ * 
+ *         memset(&self.hints, 0, sizeof(system.addrinfo))
+ *         self.hints.ai_flags = flags             # <<<<<<<<<<<<<<
+ *         self.hints.ai_family = family
+ *         self.hints.ai_socktype = type
+ */
+  __pyx_v_self->hints.ai_flags = __pyx_v_flags;
+
+  /* "uvloop/dns.pyx":331
+ *         memset(&self.hints, 0, sizeof(system.addrinfo))
+ *         self.hints.ai_flags = flags
+ *         self.hints.ai_family = family             # <<<<<<<<<<<<<<
+ *         self.hints.ai_socktype = type
+ *         self.hints.ai_protocol = proto
+ */
+  __pyx_v_self->hints.ai_family = __pyx_v_family;
+
+  /* "uvloop/dns.pyx":332
+ *         self.hints.ai_flags = flags
+ *         self.hints.ai_family = family
+ *         self.hints.ai_socktype = type             # <<<<<<<<<<<<<<
+ *         self.hints.ai_protocol = proto
+ * 
+ */
+  __pyx_v_self->hints.ai_socktype = __pyx_v_type;
+
+  /* "uvloop/dns.pyx":333
+ *         self.hints.ai_family = family
+ *         self.hints.ai_socktype = type
+ *         self.hints.ai_protocol = proto             # <<<<<<<<<<<<<<
+ * 
+ *         self.request = <uv.uv_req_t*> &self._req_data
+ */
+  __pyx_v_self->hints.ai_protocol = __pyx_v_proto;
+
+  /* "uvloop/dns.pyx":335
+ *         self.hints.ai_protocol = proto
+ * 
+ *         self.request = <uv.uv_req_t*> &self._req_data             # <<<<<<<<<<<<<<
+ *         self.callback = callback
+ *         self.request.data = <void*>self
+ */
+  __pyx_v_self->__pyx_base.request = ((uv_req_t *)(&__pyx_v_self->_req_data));
+
+  /* "uvloop/dns.pyx":336
+ * 
+ *         self.request = <uv.uv_req_t*> &self._req_data
+ *         self.callback = callback             # <<<<<<<<<<<<<<
+ *         self.request.data = <void*>self
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_callback);
+  __Pyx_GIVEREF(__pyx_v_callback);
+  __Pyx_GOTREF(__pyx_v_self->callback);
+  __Pyx_DECREF(__pyx_v_self->callback);
+  __pyx_v_self->callback = __pyx_v_callback;
+
+  /* "uvloop/dns.pyx":337
+ *         self.request = <uv.uv_req_t*> &self._req_data
+ *         self.callback = callback
+ *         self.request.data = <void*>self             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_getaddrinfo(loop.uvloop,
+ */
+  __pyx_v_self->__pyx_base.request->data = ((void *)__pyx_v_self);
+
+  /* "uvloop/dns.pyx":339
+ *         self.request.data = <void*>self
+ * 
+ *         err = uv.uv_getaddrinfo(loop.uvloop,             # <<<<<<<<<<<<<<
+ *                                 <uv.uv_getaddrinfo_t*>self.request,
+ *                                 __on_addrinfo_resolved,
+ */
+  __pyx_v_err = uv_getaddrinfo(__pyx_v_loop->uvloop, ((uv_getaddrinfo_t *)__pyx_v_self->__pyx_base.request), __pyx_f_6uvloop_4loop___on_addrinfo_resolved, __pyx_v_chost, __pyx_v_cport, (&__pyx_v_self->hints));
+
+  /* "uvloop/dns.pyx":346
+ *                                 &self.hints)
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self.on_done()
+ *             callback(convert_error(err))
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/dns.pyx":347
+ * 
+ *         if err < 0:
+ *             self.on_done()             # <<<<<<<<<<<<<<
+ *             callback(convert_error(err))
+ * 
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_AddrInfoRequest *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 347, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/dns.pyx":348
+ *         if err < 0:
+ *             self.on_done()
+ *             callback(convert_error(err))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_7 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 348, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_INCREF(__pyx_v_callback);
+    __pyx_t_10 = __pyx_v_callback; __pyx_t_6 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_10);
+      if (likely(__pyx_t_6)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_10, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_7);
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 348, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/dns.pyx":346
+ *                                 &self.hints)
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self.on_done()
+ *             callback(convert_error(err))
+ */
+  }
+
+  /* "uvloop/dns.pyx":302
+ *         uv.uv_getaddrinfo_t _req_data
+ * 
+ *     def __cinit__(self, Loop loop,             # <<<<<<<<<<<<<<
+ *                   bytes host, bytes port,
+ *                   int family, int type, int proto, int flags,
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("uvloop.loop.AddrInfoRequest.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_msg);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15AddrInfoRequest_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15AddrInfoRequest_2__reduce_cython__[] = "AddrInfoRequest.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_15AddrInfoRequest_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_6uvloop_4loop_15AddrInfoRequest_2__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15AddrInfoRequest_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__211, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.AddrInfoRequest.__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_6uvloop_4loop_15AddrInfoRequest_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15AddrInfoRequest_4__setstate_cython__[] = "AddrInfoRequest.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_15AddrInfoRequest_5__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_6uvloop_4loop_15AddrInfoRequest_4__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15AddrInfoRequest_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *__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);
+
+  /* "(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__212, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.AddrInfoRequest.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":356
+ *         uv.uv_getnameinfo_t _req_data
+ * 
+ *     def __cinit__(self, Loop loop, callback):             # <<<<<<<<<<<<<<
+ *         self.request = <uv.uv_req_t*> &self._req_data
+ *         self.callback = callback
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_15NameInfoRequest_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_15NameInfoRequest_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  PyObject *__pyx_v_callback = 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_loop,&__pyx_n_s_callback,0};
+    PyObject* values[2] = {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  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_loop)) != 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_callback)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, 1); __PYX_ERR(5, 356, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(5, 356, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)values[0]);
+    __pyx_v_callback = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(5, 356, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.NameInfoRequest.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6uvloop_4loop_Loop, 1, "loop", 0))) __PYX_ERR(5, 356, __pyx_L1_error)
+  __pyx_r = __pyx_pf_6uvloop_4loop_15NameInfoRequest___cinit__(((struct __pyx_obj_6uvloop_4loop_NameInfoRequest *)__pyx_v_self), __pyx_v_loop, __pyx_v_callback);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_15NameInfoRequest___cinit__(struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__pyx_v_self, CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_callback) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "uvloop/dns.pyx":357
+ * 
+ *     def __cinit__(self, Loop loop, callback):
+ *         self.request = <uv.uv_req_t*> &self._req_data             # <<<<<<<<<<<<<<
+ *         self.callback = callback
+ *         self.request.data = <void*>self
+ */
+  __pyx_v_self->__pyx_base.request = ((uv_req_t *)(&__pyx_v_self->_req_data));
+
+  /* "uvloop/dns.pyx":358
+ *     def __cinit__(self, Loop loop, callback):
+ *         self.request = <uv.uv_req_t*> &self._req_data
+ *         self.callback = callback             # <<<<<<<<<<<<<<
+ *         self.request.data = <void*>self
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_callback);
+  __Pyx_GIVEREF(__pyx_v_callback);
+  __Pyx_GOTREF(__pyx_v_self->callback);
+  __Pyx_DECREF(__pyx_v_self->callback);
+  __pyx_v_self->callback = __pyx_v_callback;
+
+  /* "uvloop/dns.pyx":359
+ *         self.request = <uv.uv_req_t*> &self._req_data
+ *         self.callback = callback
+ *         self.request.data = <void*>self             # <<<<<<<<<<<<<<
+ * 
+ *     cdef query(self, system.sockaddr *addr, int flags):
+ */
+  __pyx_v_self->__pyx_base.request->data = ((void *)__pyx_v_self);
+
+  /* "uvloop/dns.pyx":356
+ *         uv.uv_getnameinfo_t _req_data
+ * 
+ *     def __cinit__(self, Loop loop, callback):             # <<<<<<<<<<<<<<
+ *         self.request = <uv.uv_req_t*> &self._req_data
+ *         self.callback = callback
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":361
+ *         self.request.data = <void*>self
+ * 
+ *     cdef query(self, system.sockaddr *addr, int flags):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         err = uv.uv_getnameinfo(self.loop.uvloop,
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_15NameInfoRequest_query(struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__pyx_v_self, struct sockaddr *__pyx_v_addr, int __pyx_v_flags) {
+  int __pyx_v_err;
+  PyObject *__pyx_r = NULL;
+  __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_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("query", 0);
+
+  /* "uvloop/dns.pyx":363
+ *     cdef query(self, system.sockaddr *addr, int flags):
+ *         cdef int err
+ *         err = uv.uv_getnameinfo(self.loop.uvloop,             # <<<<<<<<<<<<<<
+ *                                 <uv.uv_getnameinfo_t*>self.request,
+ *                                 __on_nameinfo_resolved,
+ */
+  __pyx_v_err = uv_getnameinfo(__pyx_v_self->__pyx_base.loop->uvloop, ((uv_getnameinfo_t *)__pyx_v_self->__pyx_base.request), __pyx_f_6uvloop_4loop___on_nameinfo_resolved, __pyx_v_addr, __pyx_v_flags);
+
+  /* "uvloop/dns.pyx":368
+ *                                 addr,
+ *                                 flags)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self.on_done()
+ *             self.callback(convert_error(err))
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/dns.pyx":369
+ *                                 flags)
+ *         if err < 0:
+ *             self.on_done()             # <<<<<<<<<<<<<<
+ *             self.callback(convert_error(err))
+ * 
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_NameInfoRequest *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 369, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/dns.pyx":370
+ *         if err < 0:
+ *             self.on_done()
+ *             self.callback(convert_error(err))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 370, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_v_self->callback);
+    __pyx_t_4 = __pyx_v_self->callback; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_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(5, 370, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/dns.pyx":368
+ *                                 addr,
+ *                                 flags)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self.on_done()
+ *             self.callback(convert_error(err))
+ */
+  }
+
+  /* "uvloop/dns.pyx":361
+ *         self.request.data = <void*>self
+ * 
+ *     cdef query(self, system.sockaddr *addr, int flags):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         err = uv.uv_getnameinfo(self.loop.uvloop,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.NameInfoRequest.query", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15NameInfoRequest_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15NameInfoRequest_2__reduce_cython__[] = "NameInfoRequest.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_15NameInfoRequest_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_6uvloop_4loop_15NameInfoRequest_2__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_NameInfoRequest *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15NameInfoRequest_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__213, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.NameInfoRequest.__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_6uvloop_4loop_15NameInfoRequest_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15NameInfoRequest_4__setstate_cython__[] = "NameInfoRequest.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_15NameInfoRequest_5__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_6uvloop_4loop_15NameInfoRequest_4__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_NameInfoRequest *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15NameInfoRequest_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__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);
+
+  /* "(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__214, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.NameInfoRequest.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/dns.pyx":373
+ * 
+ * 
+ * cdef void __on_addrinfo_resolved(uv.uv_getaddrinfo_t *resolver,             # <<<<<<<<<<<<<<
+ *                                  int status, system.addrinfo *res) with gil:
+ * 
+ */
+
+static void __pyx_f_6uvloop_4loop___on_addrinfo_resolved(uv_getaddrinfo_t *__pyx_v_resolver, int __pyx_v_status, struct addrinfo *__pyx_v_res) {
+  struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *__pyx_v_request = 0;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  PyObject *__pyx_v_callback = 0;
+  struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_ai = 0;
+  PyObject *__pyx_v_ex = NULL;
+  __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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  char const *__pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__on_addrinfo_resolved", 0);
+
+  /* "uvloop/dns.pyx":376
+ *                                  int status, system.addrinfo *res) with gil:
+ * 
+ *     if resolver.data is NULL:             # <<<<<<<<<<<<<<
+ *         aio_logger.error(
+ *             'AddrInfoRequest callback called with NULL resolver.data')
+ */
+  __pyx_t_1 = ((__pyx_v_resolver->data == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/dns.pyx":377
+ * 
+ *     if resolver.data is NULL:
+ *         aio_logger.error(             # <<<<<<<<<<<<<<
+ *             'AddrInfoRequest callback called with NULL resolver.data')
+ *         return
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 377, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_AddrInfoRequest_callback_called) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_AddrInfoRequest_callback_called);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 377, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/dns.pyx":379
+ *         aio_logger.error(
+ *             'AddrInfoRequest callback called with NULL resolver.data')
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/dns.pyx":376
+ *                                  int status, system.addrinfo *res) with gil:
+ * 
+ *     if resolver.data is NULL:             # <<<<<<<<<<<<<<
+ *         aio_logger.error(
+ *             'AddrInfoRequest callback called with NULL resolver.data')
+ */
+  }
+
+  /* "uvloop/dns.pyx":382
+ * 
+ *     cdef:
+ *         AddrInfoRequest request = <AddrInfoRequest> resolver.data             # <<<<<<<<<<<<<<
+ *         Loop loop = request.loop
+ *         object callback = request.callback
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_resolver->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_request = ((struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/dns.pyx":383
+ *     cdef:
+ *         AddrInfoRequest request = <AddrInfoRequest> resolver.data
+ *         Loop loop = request.loop             # <<<<<<<<<<<<<<
+ *         object callback = request.callback
+ *         AddrInfo ai
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_request->__pyx_base.loop);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/dns.pyx":384
+ *         AddrInfoRequest request = <AddrInfoRequest> resolver.data
+ *         Loop loop = request.loop
+ *         object callback = request.callback             # <<<<<<<<<<<<<<
+ *         AddrInfo ai
+ * 
+ */
+  __pyx_t_2 = __pyx_v_request->callback;
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_callback = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "uvloop/dns.pyx":387
+ *         AddrInfo ai
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if status < 0:
+ *             callback(convert_error(status))
+ */
+  /*try:*/ {
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      /*try:*/ {
+
+        /* "uvloop/dns.pyx":388
+ * 
+ *     try:
+ *         if status < 0:             # <<<<<<<<<<<<<<
+ *             callback(convert_error(status))
+ *         else:
+ */
+        __pyx_t_1 = ((__pyx_v_status < 0) != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/dns.pyx":389
+ *     try:
+ *         if status < 0:
+ *             callback(convert_error(status))             # <<<<<<<<<<<<<<
+ *         else:
+ *             ai = AddrInfo()
+ */
+          __pyx_t_3 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 389, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_INCREF(__pyx_v_callback);
+          __pyx_t_4 = __pyx_v_callback; __pyx_t_8 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+            __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4);
+            if (likely(__pyx_t_8)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+              __Pyx_INCREF(__pyx_t_8);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_4, function);
+            }
+          }
+          __pyx_t_2 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_8, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3);
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 389, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+          /* "uvloop/dns.pyx":388
+ * 
+ *     try:
+ *         if status < 0:             # <<<<<<<<<<<<<<
+ *             callback(convert_error(status))
+ *         else:
+ */
+          goto __pyx_L13;
+        }
+
+        /* "uvloop/dns.pyx":391
+ *             callback(convert_error(status))
+ *         else:
+ *             ai = AddrInfo()             # <<<<<<<<<<<<<<
+ *             ai.set_data(res)
+ *             callback(ai)
+ */
+        /*else*/ {
+          __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6uvloop_4loop_AddrInfo)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 391, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __pyx_v_ai = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_t_2);
+          __pyx_t_2 = 0;
+
+          /* "uvloop/dns.pyx":392
+ *         else:
+ *             ai = AddrInfo()
+ *             ai.set_data(res)             # <<<<<<<<<<<<<<
+ *             callback(ai)
+ *     except (KeyboardInterrupt, SystemExit):
+ */
+          ((struct __pyx_vtabstruct_6uvloop_4loop_AddrInfo *)__pyx_v_ai->__pyx_vtab)->set_data(__pyx_v_ai, __pyx_v_res);
+
+          /* "uvloop/dns.pyx":393
+ *             ai = AddrInfo()
+ *             ai.set_data(res)
+ *             callback(ai)             # <<<<<<<<<<<<<<
+ *     except (KeyboardInterrupt, SystemExit):
+ *         raise
+ */
+          __Pyx_INCREF(__pyx_v_callback);
+          __pyx_t_4 = __pyx_v_callback; __pyx_t_3 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+            __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+            if (likely(__pyx_t_3)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+              __Pyx_INCREF(__pyx_t_3);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_4, function);
+            }
+          }
+          __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_3, ((PyObject *)__pyx_v_ai)) : __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_v_ai));
+          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+          if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 393, __pyx_L7_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        }
+        __pyx_L13:;
+
+        /* "uvloop/dns.pyx":387
+ *         AddrInfo ai
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if status < 0:
+ *             callback(convert_error(status))
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L12_try_end;
+      __pyx_L7_error:;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "uvloop/dns.pyx":394
+ *             ai.set_data(res)
+ *             callback(ai)
+ *     except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *         raise
+ *     except BaseException as ex:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.__on_addrinfo_resolved", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_3) < 0) __PYX_ERR(5, 394, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_3);
+
+        /* "uvloop/dns.pyx":395
+ *             callback(ai)
+ *     except (KeyboardInterrupt, SystemExit):
+ *         raise             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         loop._handle_exception(ex)
+ */
+        __Pyx_GIVEREF(__pyx_t_2);
+        __Pyx_GIVEREF(__pyx_t_4);
+        __Pyx_XGIVEREF(__pyx_t_3);
+        __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_4, __pyx_t_3);
+        __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_t_3 = 0; 
+        __PYX_ERR(5, 395, __pyx_L9_except_error)
+      }
+
+      /* "uvloop/dns.pyx":396
+ *     except (KeyboardInterrupt, SystemExit):
+ *         raise
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         loop._handle_exception(ex)
+ *     finally:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.__on_addrinfo_resolved", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_4, &__pyx_t_2) < 0) __PYX_ERR(5, 396, __pyx_L9_except_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_4);
+        __pyx_v_ex = __pyx_t_4;
+        /*try:*/ {
+
+          /* "uvloop/dns.pyx":397
+ *         raise
+ *     except BaseException as ex:
+ *         loop._handle_exception(ex)             # <<<<<<<<<<<<<<
+ *     finally:
+ *         request.on_done()
+ */
+          ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_loop->__pyx_vtab)->_handle_exception(__pyx_v_loop, __pyx_v_ex);
+        }
+
+        /* "uvloop/dns.pyx":396
+ *     except (KeyboardInterrupt, SystemExit):
+ *         raise
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         loop._handle_exception(ex)
+ *     finally:
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L22;
+          }
+          __pyx_L22:;
+        }
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        goto __pyx_L8_exception_handled;
+      }
+      goto __pyx_L9_except_error;
+      __pyx_L9_except_error:;
+
+      /* "uvloop/dns.pyx":387
+ *         AddrInfo ai
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if status < 0:
+ *             callback(convert_error(status))
+ */
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+      goto __pyx_L5_error;
+      __pyx_L8_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+      __pyx_L12_try_end:;
+    }
+  }
+
+  /* "uvloop/dns.pyx":399
+ *         loop._handle_exception(ex)
+ *     finally:
+ *         request.on_done()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_AddrInfoRequest *)__pyx_v_request->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_request)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 399, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __pyx_t_9 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
+      {
+        __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_AddrInfoRequest *)__pyx_v_request->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_request)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 399, __pyx_L24_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_ErrRestore(__pyx_t_7, __pyx_t_6, __pyx_t_5);
+      __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
+      goto __pyx_L1_error;
+      __pyx_L24_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/dns.pyx":373
+ * 
+ * 
+ * cdef void __on_addrinfo_resolved(uv.uv_getaddrinfo_t *resolver,             # <<<<<<<<<<<<<<
+ *                                  int status, system.addrinfo *res) with gil:
+ * 
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_WriteUnraisable("uvloop.loop.__on_addrinfo_resolved", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_request);
+  __Pyx_XDECREF((PyObject *)__pyx_v_loop);
+  __Pyx_XDECREF(__pyx_v_callback);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ai);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/dns.pyx":402
+ * 
+ * 
+ * cdef void __on_nameinfo_resolved(uv.uv_getnameinfo_t* req,             # <<<<<<<<<<<<<<
+ *                                  int status,
+ *                                  const char* hostname,
+ */
+
+static void __pyx_f_6uvloop_4loop___on_nameinfo_resolved(uv_getnameinfo_t *__pyx_v_req, int __pyx_v_status, char const *__pyx_v_hostname, char const *__pyx_v_service) {
+  struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__pyx_v_request = 0;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  PyObject *__pyx_v_callback = 0;
+  PyObject *__pyx_v_ex = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  char const *__pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__on_nameinfo_resolved", 0);
+
+  /* "uvloop/dns.pyx":407
+ *                                  const char* service) with gil:
+ *     cdef:
+ *         NameInfoRequest request = <NameInfoRequest> req.data             # <<<<<<<<<<<<<<
+ *         Loop loop = request.loop
+ *         object callback = request.callback
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_req->data);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_request = ((struct __pyx_obj_6uvloop_4loop_NameInfoRequest *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/dns.pyx":408
+ *     cdef:
+ *         NameInfoRequest request = <NameInfoRequest> req.data
+ *         Loop loop = request.loop             # <<<<<<<<<<<<<<
+ *         object callback = request.callback
+ * 
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_v_request->__pyx_base.loop);
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/dns.pyx":409
+ *         NameInfoRequest request = <NameInfoRequest> req.data
+ *         Loop loop = request.loop
+ *         object callback = request.callback             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+  __pyx_t_1 = __pyx_v_request->callback;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_callback = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/dns.pyx":411
+ *         object callback = request.callback
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if status < 0:
+ *             callback(convert_error(status))
+ */
+  /*try:*/ {
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_2);
+      __Pyx_XGOTREF(__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_4);
+      /*try:*/ {
+
+        /* "uvloop/dns.pyx":412
+ * 
+ *     try:
+ *         if status < 0:             # <<<<<<<<<<<<<<
+ *             callback(convert_error(status))
+ *         else:
+ */
+        __pyx_t_5 = ((__pyx_v_status < 0) != 0);
+        if (__pyx_t_5) {
+
+          /* "uvloop/dns.pyx":413
+ *     try:
+ *         if status < 0:
+ *             callback(convert_error(status))             # <<<<<<<<<<<<<<
+ *         else:
+ *             callback(((<bytes>hostname).decode(),
+ */
+          __pyx_t_6 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 413, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_INCREF(__pyx_v_callback);
+          __pyx_t_7 = __pyx_v_callback; __pyx_t_8 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+            __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+            if (likely(__pyx_t_8)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+              __Pyx_INCREF(__pyx_t_8);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_7, function);
+            }
+          }
+          __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6);
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+          if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 413, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+          /* "uvloop/dns.pyx":412
+ * 
+ *     try:
+ *         if status < 0:             # <<<<<<<<<<<<<<
+ *             callback(convert_error(status))
+ *         else:
+ */
+          goto __pyx_L12;
+        }
+
+        /* "uvloop/dns.pyx":415
+ *             callback(convert_error(status))
+ *         else:
+ *             callback(((<bytes>hostname).decode(),             # <<<<<<<<<<<<<<
+ *                       (<bytes>service).decode()))
+ *     except (KeyboardInterrupt, SystemExit):
+ */
+        /*else*/ {
+          __pyx_t_7 = __Pyx_PyBytes_FromString(__pyx_v_hostname); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 415, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          if (unlikely(__pyx_t_7 == Py_None)) {
+            PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode");
+            __PYX_ERR(5, 415, __pyx_L6_error)
+          }
+          __pyx_t_6 = __Pyx_decode_bytes(((PyObject*)__pyx_t_7), 0, PY_SSIZE_T_MAX, NULL, NULL, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 415, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+          /* "uvloop/dns.pyx":416
+ *         else:
+ *             callback(((<bytes>hostname).decode(),
+ *                       (<bytes>service).decode()))             # <<<<<<<<<<<<<<
+ *     except (KeyboardInterrupt, SystemExit):
+ *         raise
+ */
+          __pyx_t_7 = __Pyx_PyBytes_FromString(__pyx_v_service); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 416, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          if (unlikely(__pyx_t_7 == Py_None)) {
+            PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode");
+            __PYX_ERR(5, 416, __pyx_L6_error)
+          }
+          __pyx_t_8 = __Pyx_decode_bytes(((PyObject*)__pyx_t_7), 0, PY_SSIZE_T_MAX, NULL, NULL, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 416, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_8);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+          /* "uvloop/dns.pyx":415
+ *             callback(convert_error(status))
+ *         else:
+ *             callback(((<bytes>hostname).decode(),             # <<<<<<<<<<<<<<
+ *                       (<bytes>service).decode()))
+ *     except (KeyboardInterrupt, SystemExit):
+ */
+          __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 415, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_GIVEREF(__pyx_t_6);
+          PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6);
+          __Pyx_GIVEREF(__pyx_t_8);
+          PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8);
+          __pyx_t_6 = 0;
+          __pyx_t_8 = 0;
+          __Pyx_INCREF(__pyx_v_callback);
+          __pyx_t_8 = __pyx_v_callback; __pyx_t_6 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+            __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_8);
+            if (likely(__pyx_t_6)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+              __Pyx_INCREF(__pyx_t_6);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_8, function);
+            }
+          }
+          __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7);
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+          if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 415, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        }
+        __pyx_L12:;
+
+        /* "uvloop/dns.pyx":411
+ *         object callback = request.callback
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if status < 0:
+ *             callback(convert_error(status))
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L11_try_end;
+      __pyx_L6_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __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;
+
+      /* "uvloop/dns.pyx":417
+ *             callback(((<bytes>hostname).decode(),
+ *                       (<bytes>service).decode()))
+ *     except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *         raise
+ *     except BaseException as ex:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.__on_nameinfo_resolved", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(5, 417, __pyx_L8_except_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_7);
+
+        /* "uvloop/dns.pyx":418
+ *                       (<bytes>service).decode()))
+ *     except (KeyboardInterrupt, SystemExit):
+ *         raise             # <<<<<<<<<<<<<<
+ *     except BaseException as ex:
+ *         loop._handle_exception(ex)
+ */
+        __Pyx_GIVEREF(__pyx_t_1);
+        __Pyx_GIVEREF(__pyx_t_8);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_8, __pyx_t_7);
+        __pyx_t_1 = 0; __pyx_t_8 = 0; __pyx_t_7 = 0; 
+        __PYX_ERR(5, 418, __pyx_L8_except_error)
+      }
+
+      /* "uvloop/dns.pyx":419
+ *     except (KeyboardInterrupt, SystemExit):
+ *         raise
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         loop._handle_exception(ex)
+ *     finally:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.__on_nameinfo_resolved", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_1) < 0) __PYX_ERR(5, 419, __pyx_L8_except_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_8);
+        __pyx_v_ex = __pyx_t_8;
+        /*try:*/ {
+
+          /* "uvloop/dns.pyx":420
+ *         raise
+ *     except BaseException as ex:
+ *         loop._handle_exception(ex)             # <<<<<<<<<<<<<<
+ *     finally:
+ *         request.on_done()
+ */
+          ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_loop->__pyx_vtab)->_handle_exception(__pyx_v_loop, __pyx_v_ex);
+        }
+
+        /* "uvloop/dns.pyx":419
+ *     except (KeyboardInterrupt, SystemExit):
+ *         raise
+ *     except BaseException as ex:             # <<<<<<<<<<<<<<
+ *         loop._handle_exception(ex)
+ *     finally:
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L21;
+          }
+          __pyx_L21:;
+        }
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        goto __pyx_L7_exception_handled;
+      }
+      goto __pyx_L8_except_error;
+      __pyx_L8_except_error:;
+
+      /* "uvloop/dns.pyx":411
+ *         object callback = request.callback
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         if status < 0:
+ *             callback(convert_error(status))
+ */
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+      goto __pyx_L4_error;
+      __pyx_L7_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+      __pyx_L11_try_end:;
+    }
+  }
+
+  /* "uvloop/dns.pyx":422
+ *         loop._handle_exception(ex)
+ *     finally:
+ *         request.on_done()             # <<<<<<<<<<<<<<
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_NameInfoRequest *)__pyx_v_request->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_request)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 422, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      goto __pyx_L5;
+    }
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __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;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2) < 0)) __Pyx_ErrFetch(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_2);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __pyx_t_9 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
+      {
+        __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_NameInfoRequest *)__pyx_v_request->__pyx_base.__pyx_vtab)->__pyx_base.on_done(((struct __pyx_obj_6uvloop_4loop_UVRequest *)__pyx_v_request)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 422, __pyx_L23_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_ErrRestore(__pyx_t_4, __pyx_t_3, __pyx_t_2);
+      __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
+      goto __pyx_L1_error;
+      __pyx_L23_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L5:;
+  }
+
+  /* "uvloop/dns.pyx":402
+ * 
+ * 
+ * cdef void __on_nameinfo_resolved(uv.uv_getnameinfo_t* req,             # <<<<<<<<<<<<<<
+ *                                  int status,
+ *                                  const char* hostname,
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_WriteUnraisable("uvloop.loop.__on_nameinfo_resolved", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_request);
+  __Pyx_XDECREF((PyObject *)__pyx_v_loop);
+  __Pyx_XDECREF(__pyx_v_callback);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/sslproto.pyx":1
+ * cdef _create_transport_context(server_side, server_hostname):             # <<<<<<<<<<<<<<
+ *     if server_side:
+ *         raise ValueError('Server side SSL needs a valid SSLContext')
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop__create_transport_context(PyObject *__pyx_v_server_side, PyObject *__pyx_v_server_hostname) {
+  PyObject *__pyx_v_sslcontext = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_create_transport_context", 0);
+
+  /* "uvloop/sslproto.pyx":2
+ * cdef _create_transport_context(server_side, server_hostname):
+ *     if server_side:             # <<<<<<<<<<<<<<
+ *         raise ValueError('Server side SSL needs a valid SSLContext')
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_server_side); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(22, 2, __pyx_L1_error)
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/sslproto.pyx":3
+ * cdef _create_transport_context(server_side, server_hostname):
+ *     if server_side:
+ *         raise ValueError('Server side SSL needs a valid SSLContext')             # <<<<<<<<<<<<<<
+ * 
+ *     # Client side may pass ssl=True to use a default
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__215, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 3, __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(22, 3, __pyx_L1_error)
+
+    /* "uvloop/sslproto.pyx":2
+ * cdef _create_transport_context(server_side, server_hostname):
+ *     if server_side:             # <<<<<<<<<<<<<<
+ *         raise ValueError('Server side SSL needs a valid SSLContext')
+ * 
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":9
+ *     # The default is secure for client connections.
+ *     # Python 3.4+: use up-to-date strong settings.
+ *     sslcontext = ssl_create_default_context()             # <<<<<<<<<<<<<<
+ *     if not server_hostname:
+ *         sslcontext.check_hostname = False
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_ssl_create_default_context);
+  __pyx_t_3 = __pyx_v_6uvloop_4loop_ssl_create_default_context; __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_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_sslcontext = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "uvloop/sslproto.pyx":10
+ *     # Python 3.4+: use up-to-date strong settings.
+ *     sslcontext = ssl_create_default_context()
+ *     if not server_hostname:             # <<<<<<<<<<<<<<
+ *         sslcontext.check_hostname = False
+ *     return sslcontext
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_server_hostname); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(22, 10, __pyx_L1_error)
+  __pyx_t_5 = ((!__pyx_t_1) != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/sslproto.pyx":11
+ *     sslcontext = ssl_create_default_context()
+ *     if not server_hostname:
+ *         sslcontext.check_hostname = False             # <<<<<<<<<<<<<<
+ *     return sslcontext
+ * 
+ */
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_sslcontext, __pyx_n_s_check_hostname, Py_False) < 0) __PYX_ERR(22, 11, __pyx_L1_error)
+
+    /* "uvloop/sslproto.pyx":10
+ *     # Python 3.4+: use up-to-date strong settings.
+ *     sslcontext = ssl_create_default_context()
+ *     if not server_hostname:             # <<<<<<<<<<<<<<
+ *         sslcontext.check_hostname = False
+ *     return sslcontext
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":12
+ *     if not server_hostname:
+ *         sslcontext.check_hostname = False
+ *     return sslcontext             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_sslcontext);
+  __pyx_r = __pyx_v_sslcontext;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":1
+ * cdef _create_transport_context(server_side, server_hostname):             # <<<<<<<<<<<<<<
+ *     if server_side:
+ *         raise ValueError('Server side SSL needs a valid SSLContext')
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop._create_transport_context", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sslcontext);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":20
+ *     # _sendfile_compatible = constants._SendfileMode.FALLBACK
+ * 
+ *     def __cinit__(self, Loop loop, ssl_protocol, context):             # <<<<<<<<<<<<<<
+ *         self._loop = loop
+ *         # SSLProtocol instance
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  PyObject *__pyx_v_ssl_protocol = 0;
+  PyObject *__pyx_v_context = 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_loop,&__pyx_n_s_ssl_protocol,&__pyx_n_s_context,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_loop)) != 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_ssl_protocol)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 1); __PYX_ERR(22, 20, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_context)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 2); __PYX_ERR(22, 20, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(22, 20, __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_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)values[0]);
+    __pyx_v_ssl_protocol = values[1];
+    __pyx_v_context = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(22, 20, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6uvloop_4loop_Loop, 1, "loop", 0))) __PYX_ERR(22, 20, __pyx_L1_error)
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport___cinit__(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self), __pyx_v_loop, __pyx_v_ssl_protocol, __pyx_v_context);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport___cinit__(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_ssl_protocol, PyObject *__pyx_v_context) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_INCREF(__pyx_v_context);
+
+  /* "uvloop/sslproto.pyx":21
+ * 
+ *     def __cinit__(self, Loop loop, ssl_protocol, context):
+ *         self._loop = loop             # <<<<<<<<<<<<<<
+ *         # SSLProtocol instance
+ *         self._ssl_protocol = ssl_protocol
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GOTREF(__pyx_v_self->_loop);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_loop));
+  __pyx_v_self->_loop = __pyx_v_loop;
+
+  /* "uvloop/sslproto.pyx":23
+ *         self._loop = loop
+ *         # SSLProtocol instance
+ *         self._ssl_protocol = ssl_protocol             # <<<<<<<<<<<<<<
+ *         self._closed = False
+ *         if context is None:
+ */
+  if (!(likely(((__pyx_v_ssl_protocol) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_ssl_protocol, __pyx_ptype_6uvloop_4loop_SSLProtocol))))) __PYX_ERR(22, 23, __pyx_L1_error)
+  __pyx_t_1 = __pyx_v_ssl_protocol;
+  __Pyx_INCREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_ssl_protocol);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_ssl_protocol));
+  __pyx_v_self->_ssl_protocol = ((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":24
+ *         # SSLProtocol instance
+ *         self._ssl_protocol = ssl_protocol
+ *         self._closed = False             # <<<<<<<<<<<<<<
+ *         if context is None:
+ *             context = Context_CopyCurrent()
+ */
+  __pyx_v_self->_closed = 0;
+
+  /* "uvloop/sslproto.pyx":25
+ *         self._ssl_protocol = ssl_protocol
+ *         self._closed = False
+ *         if context is None:             # <<<<<<<<<<<<<<
+ *             context = Context_CopyCurrent()
+ *         self.context = context
+ */
+  __pyx_t_2 = (__pyx_v_context == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/sslproto.pyx":26
+ *         self._closed = False
+ *         if context is None:
+ *             context = Context_CopyCurrent()             # <<<<<<<<<<<<<<
+ *         self.context = context
+ * 
+ */
+    __pyx_t_1 = Context_CopyCurrent(); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 26, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF_SET(__pyx_v_context, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":25
+ *         self._ssl_protocol = ssl_protocol
+ *         self._closed = False
+ *         if context is None:             # <<<<<<<<<<<<<<
+ *             context = Context_CopyCurrent()
+ *         self.context = context
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":27
+ *         if context is None:
+ *             context = Context_CopyCurrent()
+ *         self.context = context             # <<<<<<<<<<<<<<
+ * 
+ *     def get_extra_info(self, name, default=None):
+ */
+  __Pyx_INCREF(__pyx_v_context);
+  __Pyx_GIVEREF(__pyx_v_context);
+  __Pyx_GOTREF(__pyx_v_self->context);
+  __Pyx_DECREF(__pyx_v_self->context);
+  __pyx_v_self->context = __pyx_v_context;
+
+  /* "uvloop/sslproto.pyx":20
+ *     # _sendfile_compatible = constants._SendfileMode.FALLBACK
+ * 
+ *     def __cinit__(self, Loop loop, ssl_protocol, context):             # <<<<<<<<<<<<<<
+ *         self._loop = loop
+ *         # SSLProtocol instance
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_context);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":29
+ *         self.context = context
+ * 
+ *     def get_extra_info(self, name, default=None):             # <<<<<<<<<<<<<<
+ *         """Get optional transport information."""
+ *         return self._ssl_protocol._get_extra_info(name, default)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_3get_extra_info(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_2get_extra_info[] = "_SSLProtocolTransport.get_extra_info(self, name, default=None)\nGet optional transport information.";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_3get_extra_info(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_name = 0;
+  PyObject *__pyx_v_default = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_extra_info (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name_2,&__pyx_n_s_default,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)Py_None);
+    if (unlikely(__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);
+        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_2)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_default);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_extra_info") < 0)) __PYX_ERR(22, 29, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_name = values[0];
+    __pyx_v_default = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_extra_info", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(22, 29, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.get_extra_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_2get_extra_info(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self), __pyx_v_name, __pyx_v_default);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_2get_extra_info(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_default) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__get_extra_info __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_extra_info", 0);
+
+  /* "uvloop/sslproto.pyx":31
+ *     def get_extra_info(self, name, default=None):
+ *         """Get optional transport information."""
+ *         return self._ssl_protocol._get_extra_info(name, default)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_protocol(self, protocol):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2.__pyx_n = 1;
+  __pyx_t_2.__pyx_default = __pyx_v_default;
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_get_extra_info(__pyx_v_self->_ssl_protocol, __pyx_v_name, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":29
+ *         self.context = context
+ * 
+ *     def get_extra_info(self, name, default=None):             # <<<<<<<<<<<<<<
+ *         """Get optional transport information."""
+ *         return self._ssl_protocol._get_extra_info(name, default)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.get_extra_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":33
+ *         return self._ssl_protocol._get_extra_info(name, default)
+ * 
+ *     def set_protocol(self, protocol):             # <<<<<<<<<<<<<<
+ *         self._ssl_protocol._set_app_protocol(protocol)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_5set_protocol(PyObject *__pyx_v_self, PyObject *__pyx_v_protocol); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_4set_protocol[] = "_SSLProtocolTransport.set_protocol(self, protocol)";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_5set_protocol(PyObject *__pyx_v_self, PyObject *__pyx_v_protocol) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_protocol (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_4set_protocol(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self), ((PyObject *)__pyx_v_protocol));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_4set_protocol(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_protocol) {
+  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("set_protocol", 0);
+
+  /* "uvloop/sslproto.pyx":34
+ * 
+ *     def set_protocol(self, protocol):
+ *         self._ssl_protocol._set_app_protocol(protocol)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_protocol(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_set_app_protocol(__pyx_v_self->_ssl_protocol, __pyx_v_protocol); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":33
+ *         return self._ssl_protocol._get_extra_info(name, default)
+ * 
+ *     def set_protocol(self, protocol):             # <<<<<<<<<<<<<<
+ *         self._ssl_protocol._set_app_protocol(protocol)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.set_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":36
+ *         self._ssl_protocol._set_app_protocol(protocol)
+ * 
+ *     def get_protocol(self):             # <<<<<<<<<<<<<<
+ *         return self._ssl_protocol._app_protocol
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_7get_protocol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_6get_protocol[] = "_SSLProtocolTransport.get_protocol(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_7get_protocol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_protocol (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_6get_protocol(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_6get_protocol(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_protocol", 0);
+
+  /* "uvloop/sslproto.pyx":37
+ * 
+ *     def get_protocol(self):
+ *         return self._ssl_protocol._app_protocol             # <<<<<<<<<<<<<<
+ * 
+ *     def is_closing(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_ssl_protocol->_app_protocol);
+  __pyx_r = __pyx_v_self->_ssl_protocol->_app_protocol;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":36
+ *         self._ssl_protocol._set_app_protocol(protocol)
+ * 
+ *     def get_protocol(self):             # <<<<<<<<<<<<<<
+ *         return self._ssl_protocol._app_protocol
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":39
+ *         return self._ssl_protocol._app_protocol
+ * 
+ *     def is_closing(self):             # <<<<<<<<<<<<<<
+ *         return self._closed
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_9is_closing(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_8is_closing[] = "_SSLProtocolTransport.is_closing(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_9is_closing(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_closing (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_8is_closing(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_8is_closing(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__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("is_closing", 0);
+
+  /* "uvloop/sslproto.pyx":40
+ * 
+ *     def is_closing(self):
+ *         return self._closed             # <<<<<<<<<<<<<<
+ * 
+ *     def close(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_closed); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":39
+ *         return self._ssl_protocol._app_protocol
+ * 
+ *     def is_closing(self):             # <<<<<<<<<<<<<<
+ *         return self._closed
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.is_closing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":42
+ *         return self._closed
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         """Close the transport.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_11close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_10close[] = "_SSLProtocolTransport.close(self)\nClose the transport.\n\n        Buffered data will be flushed asynchronously.  No more data\n        will be received.  After all buffered data is flushed, the\n        protocol's connection_lost() method will (eventually) called\n        with None as its argument.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_11close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("close (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_10close(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_10close(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__start_shutdown __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("close", 0);
+
+  /* "uvloop/sslproto.pyx":50
+ *         with None as its argument.
+ *         """
+ *         self._closed = True             # <<<<<<<<<<<<<<
+ *         self._ssl_protocol._start_shutdown(self.context.copy())
+ * 
+ */
+  __pyx_v_self->_closed = 1;
+
+  /* "uvloop/sslproto.pyx":51
+ *         """
+ *         self._closed = True
+ *         self._ssl_protocol._start_shutdown(self.context.copy())             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->context, __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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(22, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4.__pyx_n = 1;
+  __pyx_t_4.context = __pyx_t_1;
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_start_shutdown(__pyx_v_self->_ssl_protocol, &__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/sslproto.pyx":42
+ *         return self._closed
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         """Close the transport.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":53
+ *         self._ssl_protocol._start_shutdown(self.context.copy())
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if not self._closed:
+ *             self._closed = True
+ */
+
+/* Python wrapper */
+static void __pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_13__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_13__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_12__dealloc__(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_12__dealloc__(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self) {
+  __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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "uvloop/sslproto.pyx":54
+ * 
+ *     def __dealloc__(self):
+ *         if not self._closed:             # <<<<<<<<<<<<<<
+ *             self._closed = True
+ *             warnings_warn(
+ */
+  __pyx_t_1 = ((!(__pyx_v_self->_closed != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":55
+ *     def __dealloc__(self):
+ *         if not self._closed:
+ *             self._closed = True             # <<<<<<<<<<<<<<
+ *             warnings_warn(
+ *                 "unclosed transport <uvloop.loop._SSLProtocolTransport "
+ */
+    __pyx_v_self->_closed = 1;
+
+    /* "uvloop/sslproto.pyx":58
+ *             warnings_warn(
+ *                 "unclosed transport <uvloop.loop._SSLProtocolTransport "
+ *                 "object>", ResourceWarning)             # <<<<<<<<<<<<<<
+ * 
+ *     def is_reading(self):
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ResourceWarning); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 58, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_warnings_warn);
+    __pyx_t_4 = __pyx_v_6uvloop_4loop_warnings_warn; __pyx_t_5 = NULL;
+    __pyx_t_6 = 0;
+    if (CYTHON_UNPACK_METHODS && 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);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_6 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_u_unclosed_transport_uvloop_loop, __pyx_t_3};
+      __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(22, 56, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __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_5, __pyx_kp_u_unclosed_transport_uvloop_loop, __pyx_t_3};
+      __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(22, 56, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __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(22, 56, __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_u_unclosed_transport_uvloop_loop);
+      __Pyx_GIVEREF(__pyx_kp_u_unclosed_transport_uvloop_loop);
+      PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_u_unclosed_transport_uvloop_loop);
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 56, __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_2); __pyx_t_2 = 0;
+
+    /* "uvloop/sslproto.pyx":54
+ * 
+ *     def __dealloc__(self):
+ *         if not self._closed:             # <<<<<<<<<<<<<<
+ *             self._closed = True
+ *             warnings_warn(
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":53
+ *         self._ssl_protocol._start_shutdown(self.context.copy())
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if not self._closed:
+ *             self._closed = True
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __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_7);
+  __Pyx_WriteUnraisable("uvloop.loop._SSLProtocolTransport.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/sslproto.pyx":60
+ *                 "object>", ResourceWarning)
+ * 
+ *     def is_reading(self):             # <<<<<<<<<<<<<<
+ *         return not self._ssl_protocol._app_reading_paused
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_15is_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_14is_reading[] = "_SSLProtocolTransport.is_reading(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_15is_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_reading (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_14is_reading(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_14is_reading(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__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("is_reading", 0);
+
+  /* "uvloop/sslproto.pyx":61
+ * 
+ *     def is_reading(self):
+ *         return not self._ssl_protocol._app_reading_paused             # <<<<<<<<<<<<<<
+ * 
+ *     def pause_reading(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong((!(__pyx_v_self->_ssl_protocol->_app_reading_paused != 0))); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":60
+ *                 "object>", ResourceWarning)
+ * 
+ *     def is_reading(self):             # <<<<<<<<<<<<<<
+ *         return not self._ssl_protocol._app_reading_paused
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.is_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":63
+ *         return not self._ssl_protocol._app_reading_paused
+ * 
+ *     def pause_reading(self):             # <<<<<<<<<<<<<<
+ *         """Pause the receiving end.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_17pause_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_16pause_reading[] = "_SSLProtocolTransport.pause_reading(self)\nPause the receiving end.\n\n        No data will be passed to the protocol's data_received()\n        method until resume_reading() is called.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_17pause_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("pause_reading (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_16pause_reading(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_16pause_reading(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__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("pause_reading", 0);
+
+  /* "uvloop/sslproto.pyx":69
+ *         method until resume_reading() is called.
+ *         """
+ *         self._ssl_protocol._pause_reading()             # <<<<<<<<<<<<<<
+ * 
+ *     def resume_reading(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_pause_reading(__pyx_v_self->_ssl_protocol); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":63
+ *         return not self._ssl_protocol._app_reading_paused
+ * 
+ *     def pause_reading(self):             # <<<<<<<<<<<<<<
+ *         """Pause the receiving end.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.pause_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":71
+ *         self._ssl_protocol._pause_reading()
+ * 
+ *     def resume_reading(self):             # <<<<<<<<<<<<<<
+ *         """Resume the receiving end.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_19resume_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_18resume_reading[] = "_SSLProtocolTransport.resume_reading(self)\nResume the receiving end.\n\n        Data received will once again be passed to the protocol's\n        data_received() method.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_19resume_reading(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resume_reading (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_18resume_reading(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_18resume_reading(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("resume_reading", 0);
+
+  /* "uvloop/sslproto.pyx":77
+ *         data_received() method.
+ *         """
+ *         self._ssl_protocol._resume_reading(self.context.copy())             # <<<<<<<<<<<<<<
+ * 
+ *     def set_write_buffer_limits(self, high=None, low=None):
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->context, __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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(22, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_resume_reading(__pyx_v_self->_ssl_protocol, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/sslproto.pyx":71
+ *         self._ssl_protocol._pause_reading()
+ * 
+ *     def resume_reading(self):             # <<<<<<<<<<<<<<
+ *         """Resume the receiving end.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.resume_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":79
+ *         self._ssl_protocol._resume_reading(self.context.copy())
+ * 
+ *     def set_write_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         """Set the high- and low-water limits for write flow control.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_21set_write_buffer_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_20set_write_buffer_limits[] = "_SSLProtocolTransport.set_write_buffer_limits(self, high=None, low=None)\nSet the high- and low-water limits for write flow control.\n\n        These two values control when to call the protocol's\n        pause_writing() and resume_writing() methods.  If specified,\n        the low-water limit must be less than or equal to the\n        high-water limit.  Neither value can be negative.\n\n        The defaults are implementation-specific.  If only the\n        high-water limit is given, the low-water limit defaults to an\n        implementation-specific value less than or equal to the\n        high-water limit.  Setting high to zero forces low to zero as\n        well, and causes pause_writing() to be called whenever the\n        buffer becomes non-empty.  Setting low to zero causes\n        resume_writing() to be called only once the buffer is empty.\n        Use of zero for either limit is generally sub-optimal as it\n        reduces opportunities for doing I/O and computation\n        concurrently.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_21set_write_buffer_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_high = 0;
+  PyObject *__pyx_v_low = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_write_buffer_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,0};
+    PyObject* values[2] = {0,0};
+    values[0] = ((PyObject *)Py_None);
+    values[1] = ((PyObject *)Py_None);
+    if (unlikely(__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);
+        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 (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high);
+          if (value) { values[0] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_write_buffer_limits") < 0)) __PYX_ERR(22, 79, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        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;
+      }
+    }
+    __pyx_v_high = values[0];
+    __pyx_v_low = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_write_buffer_limits", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(22, 79, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.set_write_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_20set_write_buffer_limits(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self), __pyx_v_high, __pyx_v_low);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_20set_write_buffer_limits(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_high, PyObject *__pyx_v_low) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_write_buffer_limits __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__control_app_writing __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_write_buffer_limits", 0);
+
+  /* "uvloop/sslproto.pyx":98
+ *         concurrently.
+ *         """
+ *         self._ssl_protocol._set_write_buffer_limits(high, low)             # <<<<<<<<<<<<<<
+ *         self._ssl_protocol._control_app_writing(self.context.copy())
+ * 
+ */
+  __pyx_t_2.__pyx_n = 2;
+  __pyx_t_2.high = __pyx_v_high;
+  __pyx_t_2.low = __pyx_v_low;
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_set_write_buffer_limits(__pyx_v_self->_ssl_protocol, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":99
+ *         """
+ *         self._ssl_protocol._set_write_buffer_limits(high, low)
+ *         self._ssl_protocol._control_app_writing(self.context.copy())             # <<<<<<<<<<<<<<
+ * 
+ *     def get_write_buffer_limits(self):
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->context, __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 99, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 99, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_5.__pyx_n = 1;
+  __pyx_t_5.context = __pyx_t_1;
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_control_app_writing(__pyx_v_self->_ssl_protocol, &__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 99, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":79
+ *         self._ssl_protocol._resume_reading(self.context.copy())
+ * 
+ *     def set_write_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         """Set the high- and low-water limits for write flow control.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.set_write_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":101
+ *         self._ssl_protocol._control_app_writing(self.context.copy())
+ * 
+ *     def get_write_buffer_limits(self):             # <<<<<<<<<<<<<<
+ *         return (self._ssl_protocol._outgoing_low_water,
+ *                 self._ssl_protocol._outgoing_high_water)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_23get_write_buffer_limits(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_22get_write_buffer_limits[] = "_SSLProtocolTransport.get_write_buffer_limits(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_23get_write_buffer_limits(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_write_buffer_limits (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_22get_write_buffer_limits(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_22get_write_buffer_limits(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("get_write_buffer_limits", 0);
+
+  /* "uvloop/sslproto.pyx":102
+ * 
+ *     def get_write_buffer_limits(self):
+ *         return (self._ssl_protocol._outgoing_low_water,             # <<<<<<<<<<<<<<
+ *                 self._ssl_protocol._outgoing_high_water)
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_self->_ssl_protocol->_outgoing_low_water); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+
+  /* "uvloop/sslproto.pyx":103
+ *     def get_write_buffer_limits(self):
+ *         return (self._ssl_protocol._outgoing_low_water,
+ *                 self._ssl_protocol._outgoing_high_water)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_write_buffer_size(self):
+ */
+  __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_v_self->_ssl_protocol->_outgoing_high_water); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 103, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/sslproto.pyx":102
+ * 
+ *     def get_write_buffer_limits(self):
+ *         return (self._ssl_protocol._outgoing_low_water,             # <<<<<<<<<<<<<<
+ *                 self._ssl_protocol._outgoing_high_water)
+ * 
+ */
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":101
+ *         self._ssl_protocol._control_app_writing(self.context.copy())
+ * 
+ *     def get_write_buffer_limits(self):             # <<<<<<<<<<<<<<
+ *         return (self._ssl_protocol._outgoing_low_water,
+ *                 self._ssl_protocol._outgoing_high_water)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.get_write_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":105
+ *                 self._ssl_protocol._outgoing_high_water)
+ * 
+ *     def get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         """Return the current size of the write buffers."""
+ *         return self._ssl_protocol._get_write_buffer_size()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_25get_write_buffer_size(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_24get_write_buffer_size[] = "_SSLProtocolTransport.get_write_buffer_size(self)\nReturn the current size of the write buffers.";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_25get_write_buffer_size(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_write_buffer_size (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_24get_write_buffer_size(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_24get_write_buffer_size(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__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_write_buffer_size", 0);
+
+  /* "uvloop/sslproto.pyx":107
+ *     def get_write_buffer_size(self):
+ *         """Return the current size of the write buffers."""
+ *         return self._ssl_protocol._get_write_buffer_size()             # <<<<<<<<<<<<<<
+ * 
+ *     def set_read_buffer_limits(self, high=None, low=None):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_get_write_buffer_size(__pyx_v_self->_ssl_protocol)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 107, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":105
+ *                 self._ssl_protocol._outgoing_high_water)
+ * 
+ *     def get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         """Return the current size of the write buffers."""
+ *         return self._ssl_protocol._get_write_buffer_size()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.get_write_buffer_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":109
+ *         return self._ssl_protocol._get_write_buffer_size()
+ * 
+ *     def set_read_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         """Set the high- and low-water limits for read flow control.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_27set_read_buffer_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_26set_read_buffer_limits[] = "_SSLProtocolTransport.set_read_buffer_limits(self, high=None, low=None)\nSet the high- and low-water limits for read flow control.\n\n        These two values control when to call the upstream transport's\n        pause_reading() and resume_reading() methods.  If specified,\n        the low-water limit must be less than or equal to the\n        high-water limit.  Neither value can be negative.\n\n        The defaults are implementation-specific.  If only the\n        high-water limit is given, the low-water limit defaults to an\n        implementation-specific value less than or equal to the\n        high-water limit.  Setting high to zero forces low to zero as\n        well, and causes pause_reading() to be called whenever the\n        buffer becomes non-empty.  Setting low to zero causes\n        resume_reading() to be called only once the buffer is empty.\n        Use of zero for either limit is generally sub-optimal as it\n        reduces opportunities for doing I/O and computation\n        concurrently.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_27set_read_buffer_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_high = 0;
+  PyObject *__pyx_v_low = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_read_buffer_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,0};
+    PyObject* values[2] = {0,0};
+    values[0] = ((PyObject *)Py_None);
+    values[1] = ((PyObject *)Py_None);
+    if (unlikely(__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);
+        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 (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high);
+          if (value) { values[0] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_read_buffer_limits") < 0)) __PYX_ERR(22, 109, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        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;
+      }
+    }
+    __pyx_v_high = values[0];
+    __pyx_v_low = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_read_buffer_limits", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(22, 109, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.set_read_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_26set_read_buffer_limits(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self), __pyx_v_high, __pyx_v_low);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_26set_read_buffer_limits(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_high, PyObject *__pyx_v_low) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_read_buffer_limits __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_read_buffer_limits", 0);
+
+  /* "uvloop/sslproto.pyx":128
+ *         concurrently.
+ *         """
+ *         self._ssl_protocol._set_read_buffer_limits(high, low)             # <<<<<<<<<<<<<<
+ *         self._ssl_protocol._control_ssl_reading()
+ * 
+ */
+  __pyx_t_2.__pyx_n = 2;
+  __pyx_t_2.high = __pyx_v_high;
+  __pyx_t_2.low = __pyx_v_low;
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_set_read_buffer_limits(__pyx_v_self->_ssl_protocol, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":129
+ *         """
+ *         self._ssl_protocol._set_read_buffer_limits(high, low)
+ *         self._ssl_protocol._control_ssl_reading()             # <<<<<<<<<<<<<<
+ * 
+ *     def get_read_buffer_limits(self):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_control_ssl_reading(__pyx_v_self->_ssl_protocol); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":109
+ *         return self._ssl_protocol._get_write_buffer_size()
+ * 
+ *     def set_read_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         """Set the high- and low-water limits for read flow control.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.set_read_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":131
+ *         self._ssl_protocol._control_ssl_reading()
+ * 
+ *     def get_read_buffer_limits(self):             # <<<<<<<<<<<<<<
+ *         return (self._ssl_protocol._incoming_low_water,
+ *                 self._ssl_protocol._incoming_high_water)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_29get_read_buffer_limits(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_28get_read_buffer_limits[] = "_SSLProtocolTransport.get_read_buffer_limits(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_29get_read_buffer_limits(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_read_buffer_limits (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_28get_read_buffer_limits(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_28get_read_buffer_limits(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("get_read_buffer_limits", 0);
+
+  /* "uvloop/sslproto.pyx":132
+ * 
+ *     def get_read_buffer_limits(self):
+ *         return (self._ssl_protocol._incoming_low_water,             # <<<<<<<<<<<<<<
+ *                 self._ssl_protocol._incoming_high_water)
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_self->_ssl_protocol->_incoming_low_water); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+
+  /* "uvloop/sslproto.pyx":133
+ *     def get_read_buffer_limits(self):
+ *         return (self._ssl_protocol._incoming_low_water,
+ *                 self._ssl_protocol._incoming_high_water)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_read_buffer_size(self):
+ */
+  __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_v_self->_ssl_protocol->_incoming_high_water); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/sslproto.pyx":132
+ * 
+ *     def get_read_buffer_limits(self):
+ *         return (self._ssl_protocol._incoming_low_water,             # <<<<<<<<<<<<<<
+ *                 self._ssl_protocol._incoming_high_water)
+ * 
+ */
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":131
+ *         self._ssl_protocol._control_ssl_reading()
+ * 
+ *     def get_read_buffer_limits(self):             # <<<<<<<<<<<<<<
+ *         return (self._ssl_protocol._incoming_low_water,
+ *                 self._ssl_protocol._incoming_high_water)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.get_read_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":135
+ *                 self._ssl_protocol._incoming_high_water)
+ * 
+ *     def get_read_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         """Return the current size of the read buffer."""
+ *         return self._ssl_protocol._get_read_buffer_size()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_31get_read_buffer_size(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_30get_read_buffer_size[] = "_SSLProtocolTransport.get_read_buffer_size(self)\nReturn the current size of the read buffer.";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_31get_read_buffer_size(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_read_buffer_size (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_30get_read_buffer_size(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_30get_read_buffer_size(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__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_read_buffer_size", 0);
+
+  /* "uvloop/sslproto.pyx":137
+ *     def get_read_buffer_size(self):
+ *         """Return the current size of the read buffer."""
+ *         return self._ssl_protocol._get_read_buffer_size()             # <<<<<<<<<<<<<<
+ * 
+ *     @property
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_get_read_buffer_size(__pyx_v_self->_ssl_protocol)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":135
+ *                 self._ssl_protocol._incoming_high_water)
+ * 
+ *     def get_read_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         """Return the current size of the read buffer."""
+ *         return self._ssl_protocol._get_read_buffer_size()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.get_read_buffer_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":140
+ * 
+ *     @property
+ *     def _protocol_paused(self):             # <<<<<<<<<<<<<<
+ *         # Required for sendfile fallback pause_writing/resume_writing logic
+ *         return self._ssl_protocol._app_writing_paused
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_16_protocol_paused_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_16_protocol_paused_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_16_protocol_paused___get__(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_16_protocol_paused___get__(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__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);
+
+  /* "uvloop/sslproto.pyx":142
+ *     def _protocol_paused(self):
+ *         # Required for sendfile fallback pause_writing/resume_writing logic
+ *         return self._ssl_protocol._app_writing_paused             # <<<<<<<<<<<<<<
+ * 
+ *     def write(self, data):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_ssl_protocol->_app_writing_paused); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":140
+ * 
+ *     @property
+ *     def _protocol_paused(self):             # <<<<<<<<<<<<<<
+ *         # Required for sendfile fallback pause_writing/resume_writing logic
+ *         return self._ssl_protocol._app_writing_paused
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport._protocol_paused.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":144
+ *         return self._ssl_protocol._app_writing_paused
+ * 
+ *     def write(self, data):             # <<<<<<<<<<<<<<
+ *         """Write some data bytes to the transport.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_33write(PyObject *__pyx_v_self, PyObject *__pyx_v_data); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_32write[] = "_SSLProtocolTransport.write(self, data)\nWrite some data bytes to the transport.\n\n        This does not block; it buffers the data and arranges for it\n        to be sent out asynchronously.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_33write(PyObject *__pyx_v_self, PyObject *__pyx_v_data) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("write (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_32write(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self), ((PyObject *)__pyx_v_data));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_32write(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_data) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("write", 0);
+
+  /* "uvloop/sslproto.pyx":150
+ *         to be sent out asynchronously.
+ *         """
+ *         if not isinstance(data, (bytes, bytearray, memoryview)):             # <<<<<<<<<<<<<<
+ *             raise TypeError(f"data: expecting a bytes-like instance, "
+ *                             f"got {type(data).__name__}")
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyBytes_Check(__pyx_v_data); 
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  if (!__pyx_t_4) {
+  } else {
+    __pyx_t_2 = __pyx_t_4;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_4 = PyByteArray_Check(__pyx_v_data); 
+  __pyx_t_3 = (__pyx_t_4 != 0);
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_3 = PyObject_IsInstance(__pyx_v_data, __pyx_t_1); 
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  __pyx_t_2 = __pyx_t_4;
+  __pyx_L4_bool_binop_done:;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0);
+  if (unlikely(__pyx_t_4)) {
+
+    /* "uvloop/sslproto.pyx":152
+ *         if not isinstance(data, (bytes, bytearray, memoryview)):
+ *             raise TypeError(f"data: expecting a bytes-like instance, "
+ *                             f"got {type(data).__name__}")             # <<<<<<<<<<<<<<
+ *         if not data:
+ *             return
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_data)), __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 152, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 152, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":151
+ *         """
+ *         if not isinstance(data, (bytes, bytearray, memoryview)):
+ *             raise TypeError(f"data: expecting a bytes-like instance, "             # <<<<<<<<<<<<<<
+ *                             f"got {type(data).__name__}")
+ *         if not data:
+ */
+    __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_kp_u_data_expecting_a_bytes_like_inst, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 151, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 151, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(22, 151, __pyx_L1_error)
+
+    /* "uvloop/sslproto.pyx":150
+ *         to be sent out asynchronously.
+ *         """
+ *         if not isinstance(data, (bytes, bytearray, memoryview)):             # <<<<<<<<<<<<<<
+ *             raise TypeError(f"data: expecting a bytes-like instance, "
+ *                             f"got {type(data).__name__}")
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":153
+ *             raise TypeError(f"data: expecting a bytes-like instance, "
+ *                             f"got {type(data).__name__}")
+ *         if not data:             # <<<<<<<<<<<<<<
+ *             return
+ *         self._ssl_protocol._write_appdata((data,), self.context.copy())
+ */
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_data); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(22, 153, __pyx_L1_error)
+  __pyx_t_2 = ((!__pyx_t_4) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":154
+ *                             f"got {type(data).__name__}")
+ *         if not data:
+ *             return             # <<<<<<<<<<<<<<
+ *         self._ssl_protocol._write_appdata((data,), self.context.copy())
+ * 
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/sslproto.pyx":153
+ *             raise TypeError(f"data: expecting a bytes-like instance, "
+ *                             f"got {type(data).__name__}")
+ *         if not data:             # <<<<<<<<<<<<<<
+ *             return
+ *         self._ssl_protocol._write_appdata((data,), self.context.copy())
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":155
+ *         if not data:
+ *             return
+ *         self._ssl_protocol._write_appdata((data,), self.context.copy())             # <<<<<<<<<<<<<<
+ * 
+ *     def writelines(self, list_of_data):
+ */
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(__pyx_v_data);
+  __Pyx_GIVEREF(__pyx_v_data);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_data);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->context, __pyx_n_s_copy); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_write_appdata(__pyx_v_self->_ssl_protocol, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "uvloop/sslproto.pyx":144
+ *         return self._ssl_protocol._app_writing_paused
+ * 
+ *     def write(self, data):             # <<<<<<<<<<<<<<
+ *         """Write some data bytes to the transport.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":157
+ *         self._ssl_protocol._write_appdata((data,), self.context.copy())
+ * 
+ *     def writelines(self, list_of_data):             # <<<<<<<<<<<<<<
+ *         """Write a list (or any iterable) of data bytes to the transport.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_35writelines(PyObject *__pyx_v_self, PyObject *__pyx_v_list_of_data); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_34writelines[] = "_SSLProtocolTransport.writelines(self, list_of_data)\nWrite a list (or any iterable) of data bytes to the transport.\n\n        The default implementation concatenates the arguments and\n        calls write() on the result.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_35writelines(PyObject *__pyx_v_self, PyObject *__pyx_v_list_of_data) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("writelines (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_34writelines(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self), ((PyObject *)__pyx_v_list_of_data));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_34writelines(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_list_of_data) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("writelines", 0);
+
+  /* "uvloop/sslproto.pyx":163
+ *         calls write() on the result.
+ *         """
+ *         self._ssl_protocol._write_appdata(list_of_data, self.context.copy())             # <<<<<<<<<<<<<<
+ * 
+ *     def write_eof(self):
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->context, __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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(22, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_write_appdata(__pyx_v_self->_ssl_protocol, __pyx_v_list_of_data, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/sslproto.pyx":157
+ *         self._ssl_protocol._write_appdata((data,), self.context.copy())
+ * 
+ *     def writelines(self, list_of_data):             # <<<<<<<<<<<<<<
+ *         """Write a list (or any iterable) of data bytes to the transport.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.writelines", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":165
+ *         self._ssl_protocol._write_appdata(list_of_data, self.context.copy())
+ * 
+ *     def write_eof(self):             # <<<<<<<<<<<<<<
+ *         """Close the write end after flushing buffered data.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_37write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_36write_eof[] = "_SSLProtocolTransport.write_eof(self)\nClose the write end after flushing buffered data.\n\n        This raises :exc:`NotImplementedError` right now.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_37write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("write_eof (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_36write_eof(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_36write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("write_eof", 0);
+
+  /* "uvloop/sslproto.pyx":170
+ *         This raises :exc:`NotImplementedError` right now.
+ *         """
+ *         raise NotImplementedError             # <<<<<<<<<<<<<<
+ * 
+ *     def can_write_eof(self):
+ */
+  __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
+  __PYX_ERR(22, 170, __pyx_L1_error)
+
+  /* "uvloop/sslproto.pyx":165
+ *         self._ssl_protocol._write_appdata(list_of_data, self.context.copy())
+ * 
+ *     def write_eof(self):             # <<<<<<<<<<<<<<
+ *         """Close the write end after flushing buffered data.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.write_eof", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":172
+ *         raise NotImplementedError
+ * 
+ *     def can_write_eof(self):             # <<<<<<<<<<<<<<
+ *         """Return True if this transport supports write_eof(), False if not."""
+ *         return False
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_39can_write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_38can_write_eof[] = "_SSLProtocolTransport.can_write_eof(self)\nReturn True if this transport supports write_eof(), False if not.";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_39can_write_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("can_write_eof (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_38can_write_eof(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_38can_write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("can_write_eof", 0);
+
+  /* "uvloop/sslproto.pyx":174
+ *     def can_write_eof(self):
+ *         """Return True if this transport supports write_eof(), False if not."""
+ *         return False             # <<<<<<<<<<<<<<
+ * 
+ *     def abort(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(Py_False);
+  __pyx_r = Py_False;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":172
+ *         raise NotImplementedError
+ * 
+ *     def can_write_eof(self):             # <<<<<<<<<<<<<<
+ *         """Return True if this transport supports write_eof(), False if not."""
+ *         return False
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":176
+ *         return False
+ * 
+ *     def abort(self):             # <<<<<<<<<<<<<<
+ *         """Close the transport immediately.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_41abort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_40abort[] = "_SSLProtocolTransport.abort(self)\nClose the transport immediately.\n\n        Buffered data will be lost.  No more data will be received.\n        The protocol's connection_lost() method will (eventually) be\n        called with None as its argument.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_41abort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("abort (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_40abort(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_40abort(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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_RefNannySetupContext("abort", 0);
+
+  /* "uvloop/sslproto.pyx":183
+ *         called with None as its argument.
+ *         """
+ *         self._force_close(None)             # <<<<<<<<<<<<<<
+ * 
+ *     def _force_close(self, exc):
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_force_close); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 183, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, Py_None) : __Pyx_PyObject_CallOneArg(__pyx_t_2, Py_None);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 183, __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;
+
+  /* "uvloop/sslproto.pyx":176
+ *         return False
+ * 
+ *     def abort(self):             # <<<<<<<<<<<<<<
+ *         """Close the transport immediately.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.abort", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":185
+ *         self._force_close(None)
+ * 
+ *     def _force_close(self, exc):             # <<<<<<<<<<<<<<
+ *         self._closed = True
+ *         self._ssl_protocol._abort(exc)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_43_force_close(PyObject *__pyx_v_self, PyObject *__pyx_v_exc); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_42_force_close[] = "_SSLProtocolTransport._force_close(self, exc)";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_43_force_close(PyObject *__pyx_v_self, PyObject *__pyx_v_exc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_force_close (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_42_force_close(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self), ((PyObject *)__pyx_v_exc));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_42_force_close(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_exc) {
+  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("_force_close", 0);
+
+  /* "uvloop/sslproto.pyx":186
+ * 
+ *     def _force_close(self, exc):
+ *         self._closed = True             # <<<<<<<<<<<<<<
+ *         self._ssl_protocol._abort(exc)
+ * 
+ */
+  __pyx_v_self->_closed = 1;
+
+  /* "uvloop/sslproto.pyx":187
+ *     def _force_close(self, exc):
+ *         self._closed = True
+ *         self._ssl_protocol._abort(exc)             # <<<<<<<<<<<<<<
+ * 
+ *     def _test__append_write_backlog(self, data):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->_ssl_protocol->__pyx_vtab)->_abort(__pyx_v_self->_ssl_protocol, __pyx_v_exc); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":185
+ *         self._force_close(None)
+ * 
+ *     def _force_close(self, exc):             # <<<<<<<<<<<<<<
+ *         self._closed = True
+ *         self._ssl_protocol._abort(exc)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport._force_close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":189
+ *         self._ssl_protocol._abort(exc)
+ * 
+ *     def _test__append_write_backlog(self, data):             # <<<<<<<<<<<<<<
+ *         # for test only
+ *         self._ssl_protocol._write_backlog.append(data)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_45_test__append_write_backlog(PyObject *__pyx_v_self, PyObject *__pyx_v_data); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_44_test__append_write_backlog[] = "_SSLProtocolTransport._test__append_write_backlog(self, data)";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_45_test__append_write_backlog(PyObject *__pyx_v_self, PyObject *__pyx_v_data) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_test__append_write_backlog (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_44_test__append_write_backlog(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self), ((PyObject *)__pyx_v_data));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_44_test__append_write_backlog(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__pyx_v_self, PyObject *__pyx_v_data) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_test__append_write_backlog", 0);
+
+  /* "uvloop/sslproto.pyx":191
+ *     def _test__append_write_backlog(self, data):
+ *         # for test only
+ *         self._ssl_protocol._write_backlog.append(data)             # <<<<<<<<<<<<<<
+ *         self._ssl_protocol._write_buffer_size += len(data)
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Append(__pyx_v_self->_ssl_protocol->_write_backlog, __pyx_v_data); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(22, 191, __pyx_L1_error)
+
+  /* "uvloop/sslproto.pyx":192
+ *         # for test only
+ *         self._ssl_protocol._write_backlog.append(data)
+ *         self._ssl_protocol._write_buffer_size += len(data)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_self->_ssl_protocol));
+  __pyx_t_2 = __pyx_v_self->_ssl_protocol;
+  __pyx_t_3 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(22, 192, __pyx_L1_error)
+  __pyx_t_2->_write_buffer_size = (__pyx_t_2->_write_buffer_size + __pyx_t_3);
+  __Pyx_DECREF(((PyObject *)__pyx_t_2)); __pyx_t_2 = 0;
+
+  /* "uvloop/sslproto.pyx":189
+ *         self._ssl_protocol._abort(exc)
+ * 
+ *     def _test__append_write_backlog(self, data):             # <<<<<<<<<<<<<<
+ *         # for test only
+ *         self._ssl_protocol._write_backlog.append(data)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(((PyObject *)__pyx_t_2));
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport._test__append_write_backlog", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_47__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_46__reduce_cython__[] = "_SSLProtocolTransport.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_47__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_6uvloop_4loop_21_SSLProtocolTransport_46__reduce_cython__(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_46__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__216, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.__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_6uvloop_4loop_21_SSLProtocolTransport_49__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_48__setstate_cython__[] = "_SSLProtocolTransport.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_49__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_6uvloop_4loop_21_SSLProtocolTransport_48__setstate_cython__(((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_21_SSLProtocolTransport_48__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *__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);
+
+  /* "(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__217, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._SSLProtocolTransport.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":202
+ *     """
+ * 
+ *     def __cinit__(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._ssl_buffer_len = SSL_READ_MAX_SIZE
+ *         self._ssl_buffer = <char*>PyMem_RawMalloc(self._ssl_buffer_len)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_11SSLProtocol_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_11SSLProtocol_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 1))) return -1;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_args = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_11SSLProtocol___cinit__(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_kwargs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_11SSLProtocol___cinit__(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
+  int __pyx_r;
+  __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("__cinit__", 0);
+
+  /* "uvloop/sslproto.pyx":203
+ * 
+ *     def __cinit__(self, *args, **kwargs):
+ *         self._ssl_buffer_len = SSL_READ_MAX_SIZE             # <<<<<<<<<<<<<<
+ *         self._ssl_buffer = <char*>PyMem_RawMalloc(self._ssl_buffer_len)
+ *         if not self._ssl_buffer:
+ */
+  __pyx_v_self->_ssl_buffer_len = 0x40000;
+
+  /* "uvloop/sslproto.pyx":204
+ *     def __cinit__(self, *args, **kwargs):
+ *         self._ssl_buffer_len = SSL_READ_MAX_SIZE
+ *         self._ssl_buffer = <char*>PyMem_RawMalloc(self._ssl_buffer_len)             # <<<<<<<<<<<<<<
+ *         if not self._ssl_buffer:
+ *             raise MemoryError()
+ */
+  __pyx_v_self->_ssl_buffer = ((char *)PyMem_RawMalloc(__pyx_v_self->_ssl_buffer_len));
+
+  /* "uvloop/sslproto.pyx":205
+ *         self._ssl_buffer_len = SSL_READ_MAX_SIZE
+ *         self._ssl_buffer = <char*>PyMem_RawMalloc(self._ssl_buffer_len)
+ *         if not self._ssl_buffer:             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ *         self._ssl_buffer_view = PyMemoryView_FromMemory(
+ */
+  __pyx_t_1 = ((!(__pyx_v_self->_ssl_buffer != 0)) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/sslproto.pyx":206
+ *         self._ssl_buffer = <char*>PyMem_RawMalloc(self._ssl_buffer_len)
+ *         if not self._ssl_buffer:
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ *         self._ssl_buffer_view = PyMemoryView_FromMemory(
+ *             self._ssl_buffer, self._ssl_buffer_len, PyBUF_WRITE)
+ */
+    PyErr_NoMemory(); __PYX_ERR(22, 206, __pyx_L1_error)
+
+    /* "uvloop/sslproto.pyx":205
+ *         self._ssl_buffer_len = SSL_READ_MAX_SIZE
+ *         self._ssl_buffer = <char*>PyMem_RawMalloc(self._ssl_buffer_len)
+ *         if not self._ssl_buffer:             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ *         self._ssl_buffer_view = PyMemoryView_FromMemory(
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":207
+ *         if not self._ssl_buffer:
+ *             raise MemoryError()
+ *         self._ssl_buffer_view = PyMemoryView_FromMemory(             # <<<<<<<<<<<<<<
+ *             self._ssl_buffer, self._ssl_buffer_len, PyBUF_WRITE)
+ * 
+ */
+  __pyx_t_2 = PyMemoryView_FromMemory(__pyx_v_self->_ssl_buffer, __pyx_v_self->_ssl_buffer_len, PyBUF_WRITE); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __Pyx_GOTREF(__pyx_v_self->_ssl_buffer_view);
+  __Pyx_DECREF(__pyx_v_self->_ssl_buffer_view);
+  __pyx_v_self->_ssl_buffer_view = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "uvloop/sslproto.pyx":202
+ *     """
+ * 
+ *     def __cinit__(self, *args, **kwargs):             # <<<<<<<<<<<<<<
+ *         self._ssl_buffer_len = SSL_READ_MAX_SIZE
+ *         self._ssl_buffer = <char*>PyMem_RawMalloc(self._ssl_buffer_len)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":210
+ *             self._ssl_buffer, self._ssl_buffer_len, PyBUF_WRITE)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         self._ssl_buffer_view = None
+ *         PyMem_RawFree(self._ssl_buffer)
+ */
+
+/* Python wrapper */
+static void __pyx_pw_6uvloop_4loop_11SSLProtocol_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_6uvloop_4loop_11SSLProtocol_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_6uvloop_4loop_11SSLProtocol_2__dealloc__(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_6uvloop_4loop_11SSLProtocol_2__dealloc__(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "uvloop/sslproto.pyx":211
+ * 
+ *     def __dealloc__(self):
+ *         self._ssl_buffer_view = None             # <<<<<<<<<<<<<<
+ *         PyMem_RawFree(self._ssl_buffer)
+ *         self._ssl_buffer = NULL
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_ssl_buffer_view);
+  __Pyx_DECREF(__pyx_v_self->_ssl_buffer_view);
+  __pyx_v_self->_ssl_buffer_view = Py_None;
+
+  /* "uvloop/sslproto.pyx":212
+ *     def __dealloc__(self):
+ *         self._ssl_buffer_view = None
+ *         PyMem_RawFree(self._ssl_buffer)             # <<<<<<<<<<<<<<
+ *         self._ssl_buffer = NULL
+ *         self._ssl_buffer_len = 0
+ */
+  PyMem_RawFree(__pyx_v_self->_ssl_buffer);
+
+  /* "uvloop/sslproto.pyx":213
+ *         self._ssl_buffer_view = None
+ *         PyMem_RawFree(self._ssl_buffer)
+ *         self._ssl_buffer = NULL             # <<<<<<<<<<<<<<
+ *         self._ssl_buffer_len = 0
+ * 
+ */
+  __pyx_v_self->_ssl_buffer = NULL;
+
+  /* "uvloop/sslproto.pyx":214
+ *         PyMem_RawFree(self._ssl_buffer)
+ *         self._ssl_buffer = NULL
+ *         self._ssl_buffer_len = 0             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self, loop, app_protocol, sslcontext, waiter,
+ */
+  __pyx_v_self->_ssl_buffer_len = 0;
+
+  /* "uvloop/sslproto.pyx":210
+ *             self._ssl_buffer, self._ssl_buffer_len, PyBUF_WRITE)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         self._ssl_buffer_view = None
+ *         PyMem_RawFree(self._ssl_buffer)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "uvloop/sslproto.pyx":216
+ *         self._ssl_buffer_len = 0
+ * 
+ *     def __init__(self, loop, app_protocol, sslcontext, waiter,             # <<<<<<<<<<<<<<
+ *                  server_side=False, server_hostname=None,
+ *                  call_connection_made=True,
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_11SSLProtocol_5__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_11SSLProtocol_5__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_loop = 0;
+  PyObject *__pyx_v_app_protocol = 0;
+  PyObject *__pyx_v_sslcontext = 0;
+  PyObject *__pyx_v_waiter = 0;
+  PyObject *__pyx_v_server_side = 0;
+  PyObject *__pyx_v_server_hostname = 0;
+  PyObject *__pyx_v_call_connection_made = 0;
+  PyObject *__pyx_v_ssl_handshake_timeout = 0;
+  PyObject *__pyx_v_ssl_shutdown_timeout = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_app_protocol,&__pyx_n_s_sslcontext,&__pyx_n_s_waiter,&__pyx_n_s_server_side,&__pyx_n_s_server_hostname,&__pyx_n_s_call_connection_made,&__pyx_n_s_ssl_handshake_timeout,&__pyx_n_s_ssl_shutdown_timeout,0};
+    PyObject* values[9] = {0,0,0,0,0,0,0,0,0};
+
+    /* "uvloop/sslproto.pyx":217
+ * 
+ *     def __init__(self, loop, app_protocol, sslcontext, waiter,
+ *                  server_side=False, server_hostname=None,             # <<<<<<<<<<<<<<
+ *                  call_connection_made=True,
+ *                  ssl_handshake_timeout=None,
+ */
+    values[4] = ((PyObject *)Py_False);
+    values[5] = ((PyObject *)Py_None);
+
+    /* "uvloop/sslproto.pyx":218
+ *     def __init__(self, loop, app_protocol, sslcontext, waiter,
+ *                  server_side=False, server_hostname=None,
+ *                  call_connection_made=True,             # <<<<<<<<<<<<<<
+ *                  ssl_handshake_timeout=None,
+ *                  ssl_shutdown_timeout=None):
+ */
+    values[6] = ((PyObject *)Py_True);
+
+    /* "uvloop/sslproto.pyx":219
+ *                  server_side=False, server_hostname=None,
+ *                  call_connection_made=True,
+ *                  ssl_handshake_timeout=None,             # <<<<<<<<<<<<<<
+ *                  ssl_shutdown_timeout=None):
+ *         if ssl_handshake_timeout is None:
+ */
+    values[7] = ((PyObject *)Py_None);
+
+    /* "uvloop/sslproto.pyx":220
+ *                  call_connection_made=True,
+ *                  ssl_handshake_timeout=None,
+ *                  ssl_shutdown_timeout=None):             # <<<<<<<<<<<<<<
+ *         if ssl_handshake_timeout is None:
+ *             ssl_handshake_timeout = SSL_HANDSHAKE_TIMEOUT
+ */
+    values[8] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
+        CYTHON_FALLTHROUGH;
+        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+        CYTHON_FALLTHROUGH;
+        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+        CYTHON_FALLTHROUGH;
+        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+        CYTHON_FALLTHROUGH;
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        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);
+        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_loop)) != 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_app_protocol)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 0, 4, 9, 1); __PYX_ERR(22, 216, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sslcontext)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 0, 4, 9, 2); __PYX_ERR(22, 216, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_waiter)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 0, 4, 9, 3); __PYX_ERR(22, 216, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_server_side);
+          if (value) { values[4] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  5:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_server_hostname);
+          if (value) { values[5] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  6:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_call_connection_made);
+          if (value) { values[6] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  7:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ssl_handshake_timeout);
+          if (value) { values[7] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  8:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ssl_shutdown_timeout);
+          if (value) { values[8] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(22, 216, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
+        CYTHON_FALLTHROUGH;
+        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+        CYTHON_FALLTHROUGH;
+        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+        CYTHON_FALLTHROUGH;
+        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+        CYTHON_FALLTHROUGH;
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 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);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_loop = values[0];
+    __pyx_v_app_protocol = values[1];
+    __pyx_v_sslcontext = values[2];
+    __pyx_v_waiter = values[3];
+    __pyx_v_server_side = values[4];
+    __pyx_v_server_hostname = values[5];
+    __pyx_v_call_connection_made = values[6];
+    __pyx_v_ssl_handshake_timeout = values[7];
+    __pyx_v_ssl_shutdown_timeout = values[8];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 0, 4, 9, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(22, 216, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_11SSLProtocol_4__init__(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self), __pyx_v_loop, __pyx_v_app_protocol, __pyx_v_sslcontext, __pyx_v_waiter, __pyx_v_server_side, __pyx_v_server_hostname, __pyx_v_call_connection_made, __pyx_v_ssl_handshake_timeout, __pyx_v_ssl_shutdown_timeout);
+
+  /* "uvloop/sslproto.pyx":216
+ *         self._ssl_buffer_len = 0
+ * 
+ *     def __init__(self, loop, app_protocol, sslcontext, waiter,             # <<<<<<<<<<<<<<
+ *                  server_side=False, server_hostname=None,
+ *                  call_connection_made=True,
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_11SSLProtocol_4__init__(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_loop, PyObject *__pyx_v_app_protocol, PyObject *__pyx_v_sslcontext, PyObject *__pyx_v_waiter, PyObject *__pyx_v_server_side, PyObject *__pyx_v_server_hostname, PyObject *__pyx_v_call_connection_made, PyObject *__pyx_v_ssl_handshake_timeout, PyObject *__pyx_v_ssl_shutdown_timeout) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = 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("__init__", 0);
+  __Pyx_INCREF(__pyx_v_sslcontext);
+  __Pyx_INCREF(__pyx_v_ssl_handshake_timeout);
+  __Pyx_INCREF(__pyx_v_ssl_shutdown_timeout);
+
+  /* "uvloop/sslproto.pyx":221
+ *                  ssl_handshake_timeout=None,
+ *                  ssl_shutdown_timeout=None):
+ *         if ssl_handshake_timeout is None:             # <<<<<<<<<<<<<<
+ *             ssl_handshake_timeout = SSL_HANDSHAKE_TIMEOUT
+ *         elif ssl_handshake_timeout <= 0:
+ */
+  __pyx_t_1 = (__pyx_v_ssl_handshake_timeout == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":222
+ *                  ssl_shutdown_timeout=None):
+ *         if ssl_handshake_timeout is None:
+ *             ssl_handshake_timeout = SSL_HANDSHAKE_TIMEOUT             # <<<<<<<<<<<<<<
+ *         elif ssl_handshake_timeout <= 0:
+ *             raise ValueError(
+ */
+    __Pyx_INCREF(__pyx_float_60_0);
+    __Pyx_DECREF_SET(__pyx_v_ssl_handshake_timeout, __pyx_float_60_0);
+
+    /* "uvloop/sslproto.pyx":221
+ *                  ssl_handshake_timeout=None,
+ *                  ssl_shutdown_timeout=None):
+ *         if ssl_handshake_timeout is None:             # <<<<<<<<<<<<<<
+ *             ssl_handshake_timeout = SSL_HANDSHAKE_TIMEOUT
+ *         elif ssl_handshake_timeout <= 0:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/sslproto.pyx":223
+ *         if ssl_handshake_timeout is None:
+ *             ssl_handshake_timeout = SSL_HANDSHAKE_TIMEOUT
+ *         elif ssl_handshake_timeout <= 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 f"ssl_handshake_timeout should be a positive number, "
+ */
+  __pyx_t_3 = PyObject_RichCompare(__pyx_v_ssl_handshake_timeout, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 223, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(22, 223, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/sslproto.pyx":226
+ *             raise ValueError(
+ *                 f"ssl_handshake_timeout should be a positive number, "
+ *                 f"got {ssl_handshake_timeout}")             # <<<<<<<<<<<<<<
+ *         if ssl_shutdown_timeout is None:
+ *             ssl_shutdown_timeout = SSL_SHUTDOWN_TIMEOUT
+ */
+    __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_ssl_handshake_timeout, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 226, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/sslproto.pyx":225
+ *         elif ssl_handshake_timeout <= 0:
+ *             raise ValueError(
+ *                 f"ssl_handshake_timeout should be a positive number, "             # <<<<<<<<<<<<<<
+ *                 f"got {ssl_handshake_timeout}")
+ *         if ssl_shutdown_timeout is None:
+ */
+    __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_ssl_handshake_timeout_should_be, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 225, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":224
+ *             ssl_handshake_timeout = SSL_HANDSHAKE_TIMEOUT
+ *         elif ssl_handshake_timeout <= 0:
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 f"ssl_handshake_timeout should be a positive number, "
+ *                 f"got {ssl_handshake_timeout}")
+ */
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 224, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(22, 224, __pyx_L1_error)
+
+    /* "uvloop/sslproto.pyx":223
+ *         if ssl_handshake_timeout is None:
+ *             ssl_handshake_timeout = SSL_HANDSHAKE_TIMEOUT
+ *         elif ssl_handshake_timeout <= 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 f"ssl_handshake_timeout should be a positive number, "
+ */
+  }
+  __pyx_L3:;
+
+  /* "uvloop/sslproto.pyx":227
+ *                 f"ssl_handshake_timeout should be a positive number, "
+ *                 f"got {ssl_handshake_timeout}")
+ *         if ssl_shutdown_timeout is None:             # <<<<<<<<<<<<<<
+ *             ssl_shutdown_timeout = SSL_SHUTDOWN_TIMEOUT
+ *         elif ssl_shutdown_timeout <= 0:
+ */
+  __pyx_t_2 = (__pyx_v_ssl_shutdown_timeout == Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":228
+ *                 f"got {ssl_handshake_timeout}")
+ *         if ssl_shutdown_timeout is None:
+ *             ssl_shutdown_timeout = SSL_SHUTDOWN_TIMEOUT             # <<<<<<<<<<<<<<
+ *         elif ssl_shutdown_timeout <= 0:
+ *             raise ValueError(
+ */
+    __Pyx_INCREF(__pyx_float_30_0);
+    __Pyx_DECREF_SET(__pyx_v_ssl_shutdown_timeout, __pyx_float_30_0);
+
+    /* "uvloop/sslproto.pyx":227
+ *                 f"ssl_handshake_timeout should be a positive number, "
+ *                 f"got {ssl_handshake_timeout}")
+ *         if ssl_shutdown_timeout is None:             # <<<<<<<<<<<<<<
+ *             ssl_shutdown_timeout = SSL_SHUTDOWN_TIMEOUT
+ *         elif ssl_shutdown_timeout <= 0:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/sslproto.pyx":229
+ *         if ssl_shutdown_timeout is None:
+ *             ssl_shutdown_timeout = SSL_SHUTDOWN_TIMEOUT
+ *         elif ssl_shutdown_timeout <= 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 f"ssl_shutdown_timeout should be a positive number, "
+ */
+  __pyx_t_3 = PyObject_RichCompare(__pyx_v_ssl_shutdown_timeout, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 229, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(22, 229, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/sslproto.pyx":232
+ *             raise ValueError(
+ *                 f"ssl_shutdown_timeout should be a positive number, "
+ *                 f"got {ssl_shutdown_timeout}")             # <<<<<<<<<<<<<<
+ * 
+ *         if not sslcontext:
+ */
+    __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_ssl_shutdown_timeout, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 232, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/sslproto.pyx":231
+ *         elif ssl_shutdown_timeout <= 0:
+ *             raise ValueError(
+ *                 f"ssl_shutdown_timeout should be a positive number, "             # <<<<<<<<<<<<<<
+ *                 f"got {ssl_shutdown_timeout}")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_ssl_shutdown_timeout_should_be_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 231, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":230
+ *             ssl_shutdown_timeout = SSL_SHUTDOWN_TIMEOUT
+ *         elif ssl_shutdown_timeout <= 0:
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 f"ssl_shutdown_timeout should be a positive number, "
+ *                 f"got {ssl_shutdown_timeout}")
+ */
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 230, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(22, 230, __pyx_L1_error)
+
+    /* "uvloop/sslproto.pyx":229
+ *         if ssl_shutdown_timeout is None:
+ *             ssl_shutdown_timeout = SSL_SHUTDOWN_TIMEOUT
+ *         elif ssl_shutdown_timeout <= 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError(
+ *                 f"ssl_shutdown_timeout should be a positive number, "
+ */
+  }
+  __pyx_L4:;
+
+  /* "uvloop/sslproto.pyx":234
+ *                 f"got {ssl_shutdown_timeout}")
+ * 
+ *         if not sslcontext:             # <<<<<<<<<<<<<<
+ *             sslcontext = _create_transport_context(
+ *                 server_side, server_hostname)
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_sslcontext); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(22, 234, __pyx_L1_error)
+  __pyx_t_2 = ((!__pyx_t_1) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":235
+ * 
+ *         if not sslcontext:
+ *             sslcontext = _create_transport_context(             # <<<<<<<<<<<<<<
+ *                 server_side, server_hostname)
+ * 
+ */
+    __pyx_t_3 = __pyx_f_6uvloop_4loop__create_transport_context(__pyx_v_server_side, __pyx_v_server_hostname); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 235, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF_SET(__pyx_v_sslcontext, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":234
+ *                 f"got {ssl_shutdown_timeout}")
+ * 
+ *         if not sslcontext:             # <<<<<<<<<<<<<<
+ *             sslcontext = _create_transport_context(
+ *                 server_side, server_hostname)
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":238
+ *                 server_side, server_hostname)
+ * 
+ *         self._server_side = server_side             # <<<<<<<<<<<<<<
+ *         if server_hostname and not server_side:
+ *             self._server_hostname = server_hostname
+ */
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_server_side); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(22, 238, __pyx_L1_error)
+  __pyx_v_self->_server_side = __pyx_t_2;
+
+  /* "uvloop/sslproto.pyx":239
+ * 
+ *         self._server_side = server_side
+ *         if server_hostname and not server_side:             # <<<<<<<<<<<<<<
+ *             self._server_hostname = server_hostname
+ *         else:
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_server_hostname); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(22, 239, __pyx_L1_error)
+  if (__pyx_t_1) {
+  } else {
+    __pyx_t_2 = __pyx_t_1;
+    goto __pyx_L7_bool_binop_done;
+  }
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_server_side); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(22, 239, __pyx_L1_error)
+  __pyx_t_5 = ((!__pyx_t_1) != 0);
+  __pyx_t_2 = __pyx_t_5;
+  __pyx_L7_bool_binop_done:;
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":240
+ *         self._server_side = server_side
+ *         if server_hostname and not server_side:
+ *             self._server_hostname = server_hostname             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._server_hostname = None
+ */
+    if (!(likely(PyUnicode_CheckExact(__pyx_v_server_hostname))||((__pyx_v_server_hostname) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_server_hostname)->tp_name), 0))) __PYX_ERR(22, 240, __pyx_L1_error)
+    __pyx_t_3 = __pyx_v_server_hostname;
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __Pyx_GOTREF(__pyx_v_self->_server_hostname);
+    __Pyx_DECREF(__pyx_v_self->_server_hostname);
+    __pyx_v_self->_server_hostname = ((PyObject*)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":239
+ * 
+ *         self._server_side = server_side
+ *         if server_hostname and not server_side:             # <<<<<<<<<<<<<<
+ *             self._server_hostname = server_hostname
+ *         else:
+ */
+    goto __pyx_L6;
+  }
+
+  /* "uvloop/sslproto.pyx":242
+ *             self._server_hostname = server_hostname
+ *         else:
+ *             self._server_hostname = None             # <<<<<<<<<<<<<<
+ *         self._sslcontext = sslcontext
+ *         # SSL-specific extra info. More info are set when the handshake
+ */
+  /*else*/ {
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_server_hostname);
+    __Pyx_DECREF(__pyx_v_self->_server_hostname);
+    __pyx_v_self->_server_hostname = ((PyObject*)Py_None);
+  }
+  __pyx_L6:;
+
+  /* "uvloop/sslproto.pyx":243
+ *         else:
+ *             self._server_hostname = None
+ *         self._sslcontext = sslcontext             # <<<<<<<<<<<<<<
+ *         # SSL-specific extra info. More info are set when the handshake
+ *         # completes.
+ */
+  __Pyx_INCREF(__pyx_v_sslcontext);
+  __Pyx_GIVEREF(__pyx_v_sslcontext);
+  __Pyx_GOTREF(__pyx_v_self->_sslcontext);
+  __Pyx_DECREF(__pyx_v_self->_sslcontext);
+  __pyx_v_self->_sslcontext = __pyx_v_sslcontext;
+
+  /* "uvloop/sslproto.pyx":246
+ *         # SSL-specific extra info. More info are set when the handshake
+ *         # completes.
+ *         self._extra = dict(sslcontext=sslcontext)             # <<<<<<<<<<<<<<
+ * 
+ *         # App data write buffering
+ */
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_sslcontext, __pyx_v_sslcontext) < 0) __PYX_ERR(22, 246, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_v_self->_extra);
+  __Pyx_DECREF(__pyx_v_self->_extra);
+  __pyx_v_self->_extra = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":249
+ * 
+ *         # App data write buffering
+ *         self._write_backlog = col_deque()             # <<<<<<<<<<<<<<
+ *         self._write_buffer_size = 0
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_col_deque);
+  __pyx_t_4 = __pyx_v_6uvloop_4loop_col_deque; __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_4, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 249, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_v_self->_write_backlog);
+  __Pyx_DECREF(__pyx_v_self->_write_backlog);
+  __pyx_v_self->_write_backlog = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":250
+ *         # App data write buffering
+ *         self._write_backlog = col_deque()
+ *         self._write_buffer_size = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._waiter = waiter
+ */
+  __pyx_v_self->_write_buffer_size = 0;
+
+  /* "uvloop/sslproto.pyx":252
+ *         self._write_buffer_size = 0
+ * 
+ *         self._waiter = waiter             # <<<<<<<<<<<<<<
+ *         self._loop = loop
+ *         self._set_app_protocol(app_protocol)
+ */
+  __Pyx_INCREF(__pyx_v_waiter);
+  __Pyx_GIVEREF(__pyx_v_waiter);
+  __Pyx_GOTREF(__pyx_v_self->_waiter);
+  __Pyx_DECREF(__pyx_v_self->_waiter);
+  __pyx_v_self->_waiter = __pyx_v_waiter;
+
+  /* "uvloop/sslproto.pyx":253
+ * 
+ *         self._waiter = waiter
+ *         self._loop = loop             # <<<<<<<<<<<<<<
+ *         self._set_app_protocol(app_protocol)
+ *         self._app_transport = None
+ */
+  if (!(likely(((__pyx_v_loop) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_loop, __pyx_ptype_6uvloop_4loop_Loop))))) __PYX_ERR(22, 253, __pyx_L1_error)
+  __pyx_t_3 = __pyx_v_loop;
+  __Pyx_INCREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_v_self->_loop);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_loop));
+  __pyx_v_self->_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":254
+ *         self._waiter = waiter
+ *         self._loop = loop
+ *         self._set_app_protocol(app_protocol)             # <<<<<<<<<<<<<<
+ *         self._app_transport = None
+ *         self._app_transport_created = False
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_set_app_protocol(__pyx_v_self, __pyx_v_app_protocol); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":255
+ *         self._loop = loop
+ *         self._set_app_protocol(app_protocol)
+ *         self._app_transport = None             # <<<<<<<<<<<<<<
+ *         self._app_transport_created = False
+ *         # transport, ex: SelectorSocketTransport
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_app_transport);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_app_transport));
+  __pyx_v_self->_app_transport = ((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)Py_None);
+
+  /* "uvloop/sslproto.pyx":256
+ *         self._set_app_protocol(app_protocol)
+ *         self._app_transport = None
+ *         self._app_transport_created = False             # <<<<<<<<<<<<<<
+ *         # transport, ex: SelectorSocketTransport
+ *         self._transport = None
+ */
+  __pyx_v_self->_app_transport_created = 0;
+
+  /* "uvloop/sslproto.pyx":258
+ *         self._app_transport_created = False
+ *         # transport, ex: SelectorSocketTransport
+ *         self._transport = None             # <<<<<<<<<<<<<<
+ *         self._ssl_handshake_timeout = ssl_handshake_timeout
+ *         self._ssl_shutdown_timeout = ssl_shutdown_timeout
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_transport);
+  __Pyx_DECREF(__pyx_v_self->_transport);
+  __pyx_v_self->_transport = Py_None;
+
+  /* "uvloop/sslproto.pyx":259
+ *         # transport, ex: SelectorSocketTransport
+ *         self._transport = None
+ *         self._ssl_handshake_timeout = ssl_handshake_timeout             # <<<<<<<<<<<<<<
+ *         self._ssl_shutdown_timeout = ssl_shutdown_timeout
+ *         # SSL and state machine
+ */
+  __Pyx_INCREF(__pyx_v_ssl_handshake_timeout);
+  __Pyx_GIVEREF(__pyx_v_ssl_handshake_timeout);
+  __Pyx_GOTREF(__pyx_v_self->_ssl_handshake_timeout);
+  __Pyx_DECREF(__pyx_v_self->_ssl_handshake_timeout);
+  __pyx_v_self->_ssl_handshake_timeout = __pyx_v_ssl_handshake_timeout;
+
+  /* "uvloop/sslproto.pyx":260
+ *         self._transport = None
+ *         self._ssl_handshake_timeout = ssl_handshake_timeout
+ *         self._ssl_shutdown_timeout = ssl_shutdown_timeout             # <<<<<<<<<<<<<<
+ *         # SSL and state machine
+ *         self._sslobj = None
+ */
+  __Pyx_INCREF(__pyx_v_ssl_shutdown_timeout);
+  __Pyx_GIVEREF(__pyx_v_ssl_shutdown_timeout);
+  __Pyx_GOTREF(__pyx_v_self->_ssl_shutdown_timeout);
+  __Pyx_DECREF(__pyx_v_self->_ssl_shutdown_timeout);
+  __pyx_v_self->_ssl_shutdown_timeout = __pyx_v_ssl_shutdown_timeout;
+
+  /* "uvloop/sslproto.pyx":262
+ *         self._ssl_shutdown_timeout = ssl_shutdown_timeout
+ *         # SSL and state machine
+ *         self._sslobj = None             # <<<<<<<<<<<<<<
+ *         self._incoming = ssl_MemoryBIO()
+ *         self._incoming_write = self._incoming.write
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_sslobj);
+  __Pyx_DECREF(__pyx_v_self->_sslobj);
+  __pyx_v_self->_sslobj = Py_None;
+
+  /* "uvloop/sslproto.pyx":263
+ *         # SSL and state machine
+ *         self._sslobj = None
+ *         self._incoming = ssl_MemoryBIO()             # <<<<<<<<<<<<<<
+ *         self._incoming_write = self._incoming.write
+ *         self._outgoing = ssl_MemoryBIO()
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_ssl_MemoryBIO);
+  __pyx_t_4 = __pyx_v_6uvloop_4loop_ssl_MemoryBIO; __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_4, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 263, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_v_self->_incoming);
+  __Pyx_DECREF(__pyx_v_self->_incoming);
+  __pyx_v_self->_incoming = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":264
+ *         self._sslobj = None
+ *         self._incoming = ssl_MemoryBIO()
+ *         self._incoming_write = self._incoming.write             # <<<<<<<<<<<<<<
+ *         self._outgoing = ssl_MemoryBIO()
+ *         self._outgoing_read = self._outgoing.read
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_incoming, __pyx_n_s_write); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 264, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_v_self->_incoming_write);
+  __Pyx_DECREF(__pyx_v_self->_incoming_write);
+  __pyx_v_self->_incoming_write = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":265
+ *         self._incoming = ssl_MemoryBIO()
+ *         self._incoming_write = self._incoming.write
+ *         self._outgoing = ssl_MemoryBIO()             # <<<<<<<<<<<<<<
+ *         self._outgoing_read = self._outgoing.read
+ *         self._state = UNWRAPPED
+ */
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_ssl_MemoryBIO);
+  __pyx_t_4 = __pyx_v_6uvloop_4loop_ssl_MemoryBIO; __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_4, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 265, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_v_self->_outgoing);
+  __Pyx_DECREF(__pyx_v_self->_outgoing);
+  __pyx_v_self->_outgoing = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":266
+ *         self._incoming_write = self._incoming.write
+ *         self._outgoing = ssl_MemoryBIO()
+ *         self._outgoing_read = self._outgoing.read             # <<<<<<<<<<<<<<
+ *         self._state = UNWRAPPED
+ *         self._conn_lost = 0  # Set when connection_lost called
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_outgoing, __pyx_n_s_read); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_v_self->_outgoing_read);
+  __Pyx_DECREF(__pyx_v_self->_outgoing_read);
+  __pyx_v_self->_outgoing_read = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":267
+ *         self._outgoing = ssl_MemoryBIO()
+ *         self._outgoing_read = self._outgoing.read
+ *         self._state = UNWRAPPED             # <<<<<<<<<<<<<<
+ *         self._conn_lost = 0  # Set when connection_lost called
+ *         if call_connection_made:
+ */
+  __pyx_v_self->_state = __pyx_e_6uvloop_4loop_UNWRAPPED;
+
+  /* "uvloop/sslproto.pyx":268
+ *         self._outgoing_read = self._outgoing.read
+ *         self._state = UNWRAPPED
+ *         self._conn_lost = 0  # Set when connection_lost called             # <<<<<<<<<<<<<<
+ *         if call_connection_made:
+ *             self._app_state = STATE_INIT
+ */
+  __pyx_v_self->_conn_lost = 0;
+
+  /* "uvloop/sslproto.pyx":269
+ *         self._state = UNWRAPPED
+ *         self._conn_lost = 0  # Set when connection_lost called
+ *         if call_connection_made:             # <<<<<<<<<<<<<<
+ *             self._app_state = STATE_INIT
+ *         else:
+ */
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_call_connection_made); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(22, 269, __pyx_L1_error)
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":270
+ *         self._conn_lost = 0  # Set when connection_lost called
+ *         if call_connection_made:
+ *             self._app_state = STATE_INIT             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._app_state = STATE_CON_MADE
+ */
+    __pyx_v_self->_app_state = __pyx_e_6uvloop_4loop_STATE_INIT;
+
+    /* "uvloop/sslproto.pyx":269
+ *         self._state = UNWRAPPED
+ *         self._conn_lost = 0  # Set when connection_lost called
+ *         if call_connection_made:             # <<<<<<<<<<<<<<
+ *             self._app_state = STATE_INIT
+ *         else:
+ */
+    goto __pyx_L9;
+  }
+
+  /* "uvloop/sslproto.pyx":272
+ *             self._app_state = STATE_INIT
+ *         else:
+ *             self._app_state = STATE_CON_MADE             # <<<<<<<<<<<<<<
+ * 
+ *         # Flow Control
+ */
+  /*else*/ {
+    __pyx_v_self->_app_state = __pyx_e_6uvloop_4loop_STATE_CON_MADE;
+  }
+  __pyx_L9:;
+
+  /* "uvloop/sslproto.pyx":276
+ *         # Flow Control
+ * 
+ *         self._ssl_writing_paused = False             # <<<<<<<<<<<<<<
+ * 
+ *         self._app_reading_paused = False
+ */
+  __pyx_v_self->_ssl_writing_paused = 0;
+
+  /* "uvloop/sslproto.pyx":278
+ *         self._ssl_writing_paused = False
+ * 
+ *         self._app_reading_paused = False             # <<<<<<<<<<<<<<
+ * 
+ *         self._ssl_reading_paused = False
+ */
+  __pyx_v_self->_app_reading_paused = 0;
+
+  /* "uvloop/sslproto.pyx":280
+ *         self._app_reading_paused = False
+ * 
+ *         self._ssl_reading_paused = False             # <<<<<<<<<<<<<<
+ *         self._incoming_high_water = 0
+ *         self._incoming_low_water = 0
+ */
+  __pyx_v_self->_ssl_reading_paused = 0;
+
+  /* "uvloop/sslproto.pyx":281
+ * 
+ *         self._ssl_reading_paused = False
+ *         self._incoming_high_water = 0             # <<<<<<<<<<<<<<
+ *         self._incoming_low_water = 0
+ *         self._set_read_buffer_limits()
+ */
+  __pyx_v_self->_incoming_high_water = 0;
+
+  /* "uvloop/sslproto.pyx":282
+ *         self._ssl_reading_paused = False
+ *         self._incoming_high_water = 0
+ *         self._incoming_low_water = 0             # <<<<<<<<<<<<<<
+ *         self._set_read_buffer_limits()
+ * 
+ */
+  __pyx_v_self->_incoming_low_water = 0;
+
+  /* "uvloop/sslproto.pyx":283
+ *         self._incoming_high_water = 0
+ *         self._incoming_low_water = 0
+ *         self._set_read_buffer_limits()             # <<<<<<<<<<<<<<
+ * 
+ *         self._app_writing_paused = False
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_set_read_buffer_limits(__pyx_v_self, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 283, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":285
+ *         self._set_read_buffer_limits()
+ * 
+ *         self._app_writing_paused = False             # <<<<<<<<<<<<<<
+ *         self._outgoing_high_water = 0
+ *         self._outgoing_low_water = 0
+ */
+  __pyx_v_self->_app_writing_paused = 0;
+
+  /* "uvloop/sslproto.pyx":286
+ * 
+ *         self._app_writing_paused = False
+ *         self._outgoing_high_water = 0             # <<<<<<<<<<<<<<
+ *         self._outgoing_low_water = 0
+ *         self._set_write_buffer_limits()
+ */
+  __pyx_v_self->_outgoing_high_water = 0;
+
+  /* "uvloop/sslproto.pyx":287
+ *         self._app_writing_paused = False
+ *         self._outgoing_high_water = 0
+ *         self._outgoing_low_water = 0             # <<<<<<<<<<<<<<
+ *         self._set_write_buffer_limits()
+ * 
+ */
+  __pyx_v_self->_outgoing_low_water = 0;
+
+  /* "uvloop/sslproto.pyx":288
+ *         self._outgoing_high_water = 0
+ *         self._outgoing_low_water = 0
+ *         self._set_write_buffer_limits()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _set_app_protocol(self, app_protocol):
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_set_write_buffer_limits(__pyx_v_self, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 288, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":216
+ *         self._ssl_buffer_len = 0
+ * 
+ *     def __init__(self, loop, app_protocol, sslcontext, waiter,             # <<<<<<<<<<<<<<
+ *                  server_side=False, server_hostname=None,
+ *                  call_connection_made=True,
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sslcontext);
+  __Pyx_XDECREF(__pyx_v_ssl_handshake_timeout);
+  __Pyx_XDECREF(__pyx_v_ssl_shutdown_timeout);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":290
+ *         self._set_write_buffer_limits()
+ * 
+ *     cdef _set_app_protocol(self, app_protocol):             # <<<<<<<<<<<<<<
+ *         self._app_protocol = app_protocol
+ *         if (hasattr(app_protocol, 'get_buffer') and
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__set_app_protocol(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_app_protocol) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_set_app_protocol", 0);
+
+  /* "uvloop/sslproto.pyx":291
+ * 
+ *     cdef _set_app_protocol(self, app_protocol):
+ *         self._app_protocol = app_protocol             # <<<<<<<<<<<<<<
+ *         if (hasattr(app_protocol, 'get_buffer') and
+ *                 not isinstance(app_protocol, aio_Protocol)):
+ */
+  __Pyx_INCREF(__pyx_v_app_protocol);
+  __Pyx_GIVEREF(__pyx_v_app_protocol);
+  __Pyx_GOTREF(__pyx_v_self->_app_protocol);
+  __Pyx_DECREF(__pyx_v_self->_app_protocol);
+  __pyx_v_self->_app_protocol = __pyx_v_app_protocol;
+
+  /* "uvloop/sslproto.pyx":292
+ *     cdef _set_app_protocol(self, app_protocol):
+ *         self._app_protocol = app_protocol
+ *         if (hasattr(app_protocol, 'get_buffer') and             # <<<<<<<<<<<<<<
+ *                 not isinstance(app_protocol, aio_Protocol)):
+ *             self._app_protocol_get_buffer = app_protocol.get_buffer
+ */
+  __pyx_t_2 = __Pyx_HasAttr(__pyx_v_app_protocol, __pyx_n_u_get_buffer); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(22, 292, __pyx_L1_error)
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+  } else {
+    __pyx_t_1 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+
+  /* "uvloop/sslproto.pyx":293
+ *         self._app_protocol = app_protocol
+ *         if (hasattr(app_protocol, 'get_buffer') and
+ *                 not isinstance(app_protocol, aio_Protocol)):             # <<<<<<<<<<<<<<
+ *             self._app_protocol_get_buffer = app_protocol.get_buffer
+ *             self._app_protocol_buffer_updated = app_protocol.buffer_updated
+ */
+  __pyx_t_4 = __pyx_v_6uvloop_4loop_aio_Protocol;
+  __Pyx_INCREF(__pyx_t_4);
+  __pyx_t_3 = PyObject_IsInstance(__pyx_v_app_protocol, __pyx_t_4); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(22, 293, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+
+  /* "uvloop/sslproto.pyx":292
+ *     cdef _set_app_protocol(self, app_protocol):
+ *         self._app_protocol = app_protocol
+ *         if (hasattr(app_protocol, 'get_buffer') and             # <<<<<<<<<<<<<<
+ *                 not isinstance(app_protocol, aio_Protocol)):
+ *             self._app_protocol_get_buffer = app_protocol.get_buffer
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":294
+ *         if (hasattr(app_protocol, 'get_buffer') and
+ *                 not isinstance(app_protocol, aio_Protocol)):
+ *             self._app_protocol_get_buffer = app_protocol.get_buffer             # <<<<<<<<<<<<<<
+ *             self._app_protocol_buffer_updated = app_protocol.buffer_updated
+ *             self._app_protocol_is_buffer = True
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_app_protocol, __pyx_n_s_get_buffer); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 294, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_4);
+    __Pyx_GOTREF(__pyx_v_self->_app_protocol_get_buffer);
+    __Pyx_DECREF(__pyx_v_self->_app_protocol_get_buffer);
+    __pyx_v_self->_app_protocol_get_buffer = __pyx_t_4;
+    __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":295
+ *                 not isinstance(app_protocol, aio_Protocol)):
+ *             self._app_protocol_get_buffer = app_protocol.get_buffer
+ *             self._app_protocol_buffer_updated = app_protocol.buffer_updated             # <<<<<<<<<<<<<<
+ *             self._app_protocol_is_buffer = True
+ *         else:
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_app_protocol, __pyx_n_s_buffer_updated); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 295, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_4);
+    __Pyx_GOTREF(__pyx_v_self->_app_protocol_buffer_updated);
+    __Pyx_DECREF(__pyx_v_self->_app_protocol_buffer_updated);
+    __pyx_v_self->_app_protocol_buffer_updated = __pyx_t_4;
+    __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":296
+ *             self._app_protocol_get_buffer = app_protocol.get_buffer
+ *             self._app_protocol_buffer_updated = app_protocol.buffer_updated
+ *             self._app_protocol_is_buffer = True             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._app_protocol_is_buffer = False
+ */
+    __pyx_v_self->_app_protocol_is_buffer = 1;
+
+    /* "uvloop/sslproto.pyx":292
+ *     cdef _set_app_protocol(self, app_protocol):
+ *         self._app_protocol = app_protocol
+ *         if (hasattr(app_protocol, 'get_buffer') and             # <<<<<<<<<<<<<<
+ *                 not isinstance(app_protocol, aio_Protocol)):
+ *             self._app_protocol_get_buffer = app_protocol.get_buffer
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/sslproto.pyx":298
+ *             self._app_protocol_is_buffer = True
+ *         else:
+ *             self._app_protocol_is_buffer = False             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _wakeup_waiter(self, exc=None):
+ */
+  /*else*/ {
+    __pyx_v_self->_app_protocol_is_buffer = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/sslproto.pyx":290
+ *         self._set_write_buffer_limits()
+ * 
+ *     cdef _set_app_protocol(self, app_protocol):             # <<<<<<<<<<<<<<
+ *         self._app_protocol = app_protocol
+ *         if (hasattr(app_protocol, 'get_buffer') and
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._set_app_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":300
+ *             self._app_protocol_is_buffer = False
+ * 
+ *     cdef _wakeup_waiter(self, exc=None):             # <<<<<<<<<<<<<<
+ *         if self._waiter is None:
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__wakeup_waiter(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__wakeup_waiter *__pyx_optional_args) {
+  PyObject *__pyx_v_exc = ((PyObject *)Py_None);
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  __Pyx_RefNannySetupContext("_wakeup_waiter", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_exc = __pyx_optional_args->exc;
+    }
+  }
+
+  /* "uvloop/sslproto.pyx":301
+ * 
+ *     cdef _wakeup_waiter(self, exc=None):
+ *         if self._waiter is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         if not self._waiter.cancelled():
+ */
+  __pyx_t_1 = (__pyx_v_self->_waiter == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":302
+ *     cdef _wakeup_waiter(self, exc=None):
+ *         if self._waiter is None:
+ *             return             # <<<<<<<<<<<<<<
+ *         if not self._waiter.cancelled():
+ *             if exc is not None:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/sslproto.pyx":301
+ * 
+ *     cdef _wakeup_waiter(self, exc=None):
+ *         if self._waiter is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         if not self._waiter.cancelled():
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":303
+ *         if self._waiter is None:
+ *             return
+ *         if not self._waiter.cancelled():             # <<<<<<<<<<<<<<
+ *             if exc is not None:
+ *                 self._waiter.set_exception(exc)
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_waiter, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 303, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 303, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(22, 303, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((!__pyx_t_2) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":304
+ *             return
+ *         if not self._waiter.cancelled():
+ *             if exc is not None:             # <<<<<<<<<<<<<<
+ *                 self._waiter.set_exception(exc)
+ *             else:
+ */
+    __pyx_t_1 = (__pyx_v_exc != Py_None);
+    __pyx_t_2 = (__pyx_t_1 != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/sslproto.pyx":305
+ *         if not self._waiter.cancelled():
+ *             if exc is not None:
+ *                 self._waiter.set_exception(exc)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 self._waiter.set_result(None)
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_waiter, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 305, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_exc);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 305, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/sslproto.pyx":304
+ *             return
+ *         if not self._waiter.cancelled():
+ *             if exc is not None:             # <<<<<<<<<<<<<<
+ *                 self._waiter.set_exception(exc)
+ *             else:
+ */
+      goto __pyx_L5;
+    }
+
+    /* "uvloop/sslproto.pyx":307
+ *                 self._waiter.set_exception(exc)
+ *             else:
+ *                 self._waiter.set_result(None)             # <<<<<<<<<<<<<<
+ *         self._waiter = None
+ * 
+ */
+    /*else*/ {
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 307, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, Py_None) : __Pyx_PyObject_CallOneArg(__pyx_t_4, Py_None);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 307, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+    __pyx_L5:;
+
+    /* "uvloop/sslproto.pyx":303
+ *         if self._waiter is None:
+ *             return
+ *         if not self._waiter.cancelled():             # <<<<<<<<<<<<<<
+ *             if exc is not None:
+ *                 self._waiter.set_exception(exc)
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":308
+ *             else:
+ *                 self._waiter.set_result(None)
+ *         self._waiter = None             # <<<<<<<<<<<<<<
+ * 
+ *     def _get_app_transport(self, context=None):
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_waiter);
+  __Pyx_DECREF(__pyx_v_self->_waiter);
+  __pyx_v_self->_waiter = Py_None;
+
+  /* "uvloop/sslproto.pyx":300
+ *             self._app_protocol_is_buffer = False
+ * 
+ *     cdef _wakeup_waiter(self, exc=None):             # <<<<<<<<<<<<<<
+ *         if self._waiter is None:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._wakeup_waiter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":310
+ *         self._waiter = None
+ * 
+ *     def _get_app_transport(self, context=None):             # <<<<<<<<<<<<<<
+ *         if self._app_transport is None:
+ *             if self._app_transport_created:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_7_get_app_transport(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11SSLProtocol_6_get_app_transport[] = "SSLProtocol._get_app_transport(self, context=None)";
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_7_get_app_transport(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_context = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_get_app_transport (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_context,0};
+    PyObject* values[1] = {0};
+    values[0] = ((PyObject *)Py_None);
+    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 (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_context);
+          if (value) { values[0] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_get_app_transport") < 0)) __PYX_ERR(22, 310, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_context = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_get_app_transport", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(22, 310, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._get_app_transport", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_11SSLProtocol_6_get_app_transport(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self), __pyx_v_context);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_6_get_app_transport(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_context) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_get_app_transport", 0);
+
+  /* "uvloop/sslproto.pyx":311
+ * 
+ *     def _get_app_transport(self, context=None):
+ *         if self._app_transport is None:             # <<<<<<<<<<<<<<
+ *             if self._app_transport_created:
+ *                 raise RuntimeError('Creating _SSLProtocolTransport twice')
+ */
+  __pyx_t_1 = (((PyObject *)__pyx_v_self->_app_transport) == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":312
+ *     def _get_app_transport(self, context=None):
+ *         if self._app_transport is None:
+ *             if self._app_transport_created:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError('Creating _SSLProtocolTransport twice')
+ *             self._app_transport = _SSLProtocolTransport(self._loop, self,
+ */
+    __pyx_t_2 = (__pyx_v_self->_app_transport_created != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/sslproto.pyx":313
+ *         if self._app_transport is None:
+ *             if self._app_transport_created:
+ *                 raise RuntimeError('Creating _SSLProtocolTransport twice')             # <<<<<<<<<<<<<<
+ *             self._app_transport = _SSLProtocolTransport(self._loop, self,
+ *                                                         context)
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__218, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 313, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(22, 313, __pyx_L1_error)
+
+      /* "uvloop/sslproto.pyx":312
+ *     def _get_app_transport(self, context=None):
+ *         if self._app_transport is None:
+ *             if self._app_transport_created:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError('Creating _SSLProtocolTransport twice')
+ *             self._app_transport = _SSLProtocolTransport(self._loop, self,
+ */
+    }
+
+    /* "uvloop/sslproto.pyx":314
+ *             if self._app_transport_created:
+ *                 raise RuntimeError('Creating _SSLProtocolTransport twice')
+ *             self._app_transport = _SSLProtocolTransport(self._loop, self,             # <<<<<<<<<<<<<<
+ *                                                         context)
+ *             self._app_transport_created = True
+ */
+    __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 314, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(((PyObject *)__pyx_v_self->_loop));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_self->_loop));
+    PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self->_loop));
+    __Pyx_INCREF(((PyObject *)__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+    PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_self));
+    __Pyx_INCREF(__pyx_v_context);
+    __Pyx_GIVEREF(__pyx_v_context);
+    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_context);
+    __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop__SSLProtocolTransport), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 314, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GIVEREF(__pyx_t_4);
+    __Pyx_GOTREF(__pyx_v_self->_app_transport);
+    __Pyx_DECREF(((PyObject *)__pyx_v_self->_app_transport));
+    __pyx_v_self->_app_transport = ((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":316
+ *             self._app_transport = _SSLProtocolTransport(self._loop, self,
+ *                                                         context)
+ *             self._app_transport_created = True             # <<<<<<<<<<<<<<
+ *         return self._app_transport
+ * 
+ */
+    __pyx_v_self->_app_transport_created = 1;
+
+    /* "uvloop/sslproto.pyx":311
+ * 
+ *     def _get_app_transport(self, context=None):
+ *         if self._app_transport is None:             # <<<<<<<<<<<<<<
+ *             if self._app_transport_created:
+ *                 raise RuntimeError('Creating _SSLProtocolTransport twice')
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":317
+ *                                                         context)
+ *             self._app_transport_created = True
+ *         return self._app_transport             # <<<<<<<<<<<<<<
+ * 
+ *     def connection_made(self, transport):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self->_app_transport));
+  __pyx_r = ((PyObject *)__pyx_v_self->_app_transport);
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":310
+ *         self._waiter = None
+ * 
+ *     def _get_app_transport(self, context=None):             # <<<<<<<<<<<<<<
+ *         if self._app_transport is None:
+ *             if self._app_transport_created:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._get_app_transport", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":319
+ *         return self._app_transport
+ * 
+ *     def connection_made(self, transport):             # <<<<<<<<<<<<<<
+ *         """Called when the low-level connection is made.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_9connection_made(PyObject *__pyx_v_self, PyObject *__pyx_v_transport); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11SSLProtocol_8connection_made[] = "SSLProtocol.connection_made(self, transport)\nCalled when the low-level connection is made.\n\n        Start the SSL handshake.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_9connection_made(PyObject *__pyx_v_self, PyObject *__pyx_v_transport) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connection_made (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11SSLProtocol_8connection_made(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self), ((PyObject *)__pyx_v_transport));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_8connection_made(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_transport) {
+  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("connection_made", 0);
+
+  /* "uvloop/sslproto.pyx":324
+ *         Start the SSL handshake.
+ *         """
+ *         self._transport = transport             # <<<<<<<<<<<<<<
+ *         self._start_handshake()
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_transport);
+  __Pyx_GIVEREF(__pyx_v_transport);
+  __Pyx_GOTREF(__pyx_v_self->_transport);
+  __Pyx_DECREF(__pyx_v_self->_transport);
+  __pyx_v_self->_transport = __pyx_v_transport;
+
+  /* "uvloop/sslproto.pyx":325
+ *         """
+ *         self._transport = transport
+ *         self._start_handshake()             # <<<<<<<<<<<<<<
+ * 
+ *     def connection_lost(self, exc):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_start_handshake(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 325, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":319
+ *         return self._app_transport
+ * 
+ *     def connection_made(self, transport):             # <<<<<<<<<<<<<<
+ *         """Called when the low-level connection is made.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":327
+ *         self._start_handshake()
+ * 
+ *     def connection_lost(self, exc):             # <<<<<<<<<<<<<<
+ *         """Called when the low-level connection is lost or closed.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_11connection_lost(PyObject *__pyx_v_self, PyObject *__pyx_v_exc); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11SSLProtocol_10connection_lost[] = "SSLProtocol.connection_lost(self, exc)\nCalled when the low-level connection is lost or closed.\n\n        The argument is an exception object or None (the latter\n        meaning a regular EOF is received or the connection was\n        aborted or closed).\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_11connection_lost(PyObject *__pyx_v_self, PyObject *__pyx_v_exc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("connection_lost (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11SSLProtocol_10connection_lost(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self), ((PyObject *)__pyx_v_exc));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_10connection_lost(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_exc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__wakeup_waiter __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("connection_lost", 0);
+
+  /* "uvloop/sslproto.pyx":334
+ *         aborted or closed).
+ *         """
+ *         self._write_backlog.clear()             # <<<<<<<<<<<<<<
+ *         self._outgoing_read()
+ *         self._conn_lost += 1
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_write_backlog, __pyx_n_s_clear); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 334, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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(22, 334, __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;
+
+  /* "uvloop/sslproto.pyx":335
+ *         """
+ *         self._write_backlog.clear()
+ *         self._outgoing_read()             # <<<<<<<<<<<<<<
+ *         self._conn_lost += 1
+ * 
+ */
+  __Pyx_INCREF(__pyx_v_self->_outgoing_read);
+  __pyx_t_2 = __pyx_v_self->_outgoing_read; __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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(22, 335, __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;
+
+  /* "uvloop/sslproto.pyx":336
+ *         self._write_backlog.clear()
+ *         self._outgoing_read()
+ *         self._conn_lost += 1             # <<<<<<<<<<<<<<
+ * 
+ *         # Just mark the app transport as closed so that its __dealloc__
+ */
+  __pyx_v_self->_conn_lost = (__pyx_v_self->_conn_lost + 1);
+
+  /* "uvloop/sslproto.pyx":340
+ *         # Just mark the app transport as closed so that its __dealloc__
+ *         # doesn't complain.
+ *         if self._app_transport is not None:             # <<<<<<<<<<<<<<
+ *             self._app_transport._closed = True
+ * 
+ */
+  __pyx_t_4 = (((PyObject *)__pyx_v_self->_app_transport) != Py_None);
+  __pyx_t_5 = (__pyx_t_4 != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/sslproto.pyx":341
+ *         # doesn't complain.
+ *         if self._app_transport is not None:
+ *             self._app_transport._closed = True             # <<<<<<<<<<<<<<
+ * 
+ *         if self._state != DO_HANDSHAKE:
+ */
+    __pyx_v_self->_app_transport->_closed = 1;
+
+    /* "uvloop/sslproto.pyx":340
+ *         # Just mark the app transport as closed so that its __dealloc__
+ *         # doesn't complain.
+ *         if self._app_transport is not None:             # <<<<<<<<<<<<<<
+ *             self._app_transport._closed = True
+ * 
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":343
+ *             self._app_transport._closed = True
+ * 
+ *         if self._state != DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *             if self._app_state == STATE_CON_MADE or \
+ *                     self._app_state == STATE_EOF:
+ */
+  __pyx_t_5 = ((__pyx_v_self->_state != __pyx_e_6uvloop_4loop_DO_HANDSHAKE) != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/sslproto.pyx":344
+ * 
+ *         if self._state != DO_HANDSHAKE:
+ *             if self._app_state == STATE_CON_MADE or \             # <<<<<<<<<<<<<<
+ *                     self._app_state == STATE_EOF:
+ *                 self._app_state = STATE_CON_LOST
+ */
+    switch (__pyx_v_self->_app_state) {
+      case __pyx_e_6uvloop_4loop_STATE_CON_MADE:
+      case __pyx_e_6uvloop_4loop_STATE_EOF:
+
+      /* "uvloop/sslproto.pyx":346
+ *             if self._app_state == STATE_CON_MADE or \
+ *                     self._app_state == STATE_EOF:
+ *                 self._app_state = STATE_CON_LOST             # <<<<<<<<<<<<<<
+ *                 self._loop.call_soon(self._app_protocol.connection_lost, exc)
+ *         self._set_state(UNWRAPPED)
+ */
+      __pyx_v_self->_app_state = __pyx_e_6uvloop_4loop_STATE_CON_LOST;
+
+      /* "uvloop/sslproto.pyx":347
+ *                     self._app_state == STATE_EOF:
+ *                 self._app_state = STATE_CON_LOST
+ *                 self._loop.call_soon(self._app_protocol.connection_lost, exc)             # <<<<<<<<<<<<<<
+ *         self._set_state(UNWRAPPED)
+ *         self._transport = None
+ */
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_loop), __pyx_n_s_call_soon); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 347, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_app_protocol, __pyx_n_s_connection_lost); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 347, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_6 = NULL;
+      __pyx_t_7 = 0;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
+        if (likely(__pyx_t_6)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+          __Pyx_INCREF(__pyx_t_6);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_2, function);
+          __pyx_t_7 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_v_exc};
+        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 347, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_v_exc};
+        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 347, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(22, 347, __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_GIVEREF(__pyx_t_3);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3);
+        __Pyx_INCREF(__pyx_v_exc);
+        __Pyx_GIVEREF(__pyx_v_exc);
+        PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_exc);
+        __pyx_t_3 = 0;
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 347, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/sslproto.pyx":344
+ * 
+ *         if self._state != DO_HANDSHAKE:
+ *             if self._app_state == STATE_CON_MADE or \             # <<<<<<<<<<<<<<
+ *                     self._app_state == STATE_EOF:
+ *                 self._app_state = STATE_CON_LOST
+ */
+      break;
+      default: break;
+    }
+
+    /* "uvloop/sslproto.pyx":343
+ *             self._app_transport._closed = True
+ * 
+ *         if self._state != DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *             if self._app_state == STATE_CON_MADE or \
+ *                     self._app_state == STATE_EOF:
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":348
+ *                 self._app_state = STATE_CON_LOST
+ *                 self._loop.call_soon(self._app_protocol.connection_lost, exc)
+ *         self._set_state(UNWRAPPED)             # <<<<<<<<<<<<<<
+ *         self._transport = None
+ *         self._app_transport = None
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_6uvloop_4loop_UNWRAPPED); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 348, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":349
+ *                 self._loop.call_soon(self._app_protocol.connection_lost, exc)
+ *         self._set_state(UNWRAPPED)
+ *         self._transport = None             # <<<<<<<<<<<<<<
+ *         self._app_transport = None
+ *         self._app_protocol = None
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_transport);
+  __Pyx_DECREF(__pyx_v_self->_transport);
+  __pyx_v_self->_transport = Py_None;
+
+  /* "uvloop/sslproto.pyx":350
+ *         self._set_state(UNWRAPPED)
+ *         self._transport = None
+ *         self._app_transport = None             # <<<<<<<<<<<<<<
+ *         self._app_protocol = None
+ *         self._wakeup_waiter(exc)
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_app_transport);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_app_transport));
+  __pyx_v_self->_app_transport = ((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)Py_None);
+
+  /* "uvloop/sslproto.pyx":351
+ *         self._transport = None
+ *         self._app_transport = None
+ *         self._app_protocol = None             # <<<<<<<<<<<<<<
+ *         self._wakeup_waiter(exc)
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_app_protocol);
+  __Pyx_DECREF(__pyx_v_self->_app_protocol);
+  __pyx_v_self->_app_protocol = Py_None;
+
+  /* "uvloop/sslproto.pyx":352
+ *         self._app_transport = None
+ *         self._app_protocol = None
+ *         self._wakeup_waiter(exc)             # <<<<<<<<<<<<<<
+ * 
+ *         if self._shutdown_timeout_handle:
+ */
+  __pyx_t_9.__pyx_n = 1;
+  __pyx_t_9.exc = __pyx_v_exc;
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_wakeup_waiter(__pyx_v_self, &__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 352, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":354
+ *         self._wakeup_waiter(exc)
+ * 
+ *         if self._shutdown_timeout_handle:             # <<<<<<<<<<<<<<
+ *             self._shutdown_timeout_handle.cancel()
+ *             self._shutdown_timeout_handle = None
+ */
+  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_self->_shutdown_timeout_handle); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(22, 354, __pyx_L1_error)
+  if (__pyx_t_5) {
+
+    /* "uvloop/sslproto.pyx":355
+ * 
+ *         if self._shutdown_timeout_handle:
+ *             self._shutdown_timeout_handle.cancel()             # <<<<<<<<<<<<<<
+ *             self._shutdown_timeout_handle = None
+ *         if self._handshake_timeout_handle:
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_shutdown_timeout_handle, __pyx_n_s_cancel); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 355, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 355, __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;
+
+    /* "uvloop/sslproto.pyx":356
+ *         if self._shutdown_timeout_handle:
+ *             self._shutdown_timeout_handle.cancel()
+ *             self._shutdown_timeout_handle = None             # <<<<<<<<<<<<<<
+ *         if self._handshake_timeout_handle:
+ *             self._handshake_timeout_handle.cancel()
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_shutdown_timeout_handle);
+    __Pyx_DECREF(__pyx_v_self->_shutdown_timeout_handle);
+    __pyx_v_self->_shutdown_timeout_handle = Py_None;
+
+    /* "uvloop/sslproto.pyx":354
+ *         self._wakeup_waiter(exc)
+ * 
+ *         if self._shutdown_timeout_handle:             # <<<<<<<<<<<<<<
+ *             self._shutdown_timeout_handle.cancel()
+ *             self._shutdown_timeout_handle = None
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":357
+ *             self._shutdown_timeout_handle.cancel()
+ *             self._shutdown_timeout_handle = None
+ *         if self._handshake_timeout_handle:             # <<<<<<<<<<<<<<
+ *             self._handshake_timeout_handle.cancel()
+ *             self._handshake_timeout_handle = None
+ */
+  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_self->_handshake_timeout_handle); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(22, 357, __pyx_L1_error)
+  if (__pyx_t_5) {
+
+    /* "uvloop/sslproto.pyx":358
+ *             self._shutdown_timeout_handle = None
+ *         if self._handshake_timeout_handle:
+ *             self._handshake_timeout_handle.cancel()             # <<<<<<<<<<<<<<
+ *             self._handshake_timeout_handle = None
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_handshake_timeout_handle, __pyx_n_s_cancel); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 358, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 358, __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;
+
+    /* "uvloop/sslproto.pyx":359
+ *         if self._handshake_timeout_handle:
+ *             self._handshake_timeout_handle.cancel()
+ *             self._handshake_timeout_handle = None             # <<<<<<<<<<<<<<
+ * 
+ *     def get_buffer(self, n):
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_handshake_timeout_handle);
+    __Pyx_DECREF(__pyx_v_self->_handshake_timeout_handle);
+    __pyx_v_self->_handshake_timeout_handle = Py_None;
+
+    /* "uvloop/sslproto.pyx":357
+ *             self._shutdown_timeout_handle.cancel()
+ *             self._shutdown_timeout_handle = None
+ *         if self._handshake_timeout_handle:             # <<<<<<<<<<<<<<
+ *             self._handshake_timeout_handle.cancel()
+ *             self._handshake_timeout_handle = None
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":327
+ *         self._start_handshake()
+ * 
+ *     def connection_lost(self, exc):             # <<<<<<<<<<<<<<
+ *         """Called when the low-level connection is lost or closed.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.connection_lost", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":361
+ *             self._handshake_timeout_handle = None
+ * 
+ *     def get_buffer(self, n):             # <<<<<<<<<<<<<<
+ *         cdef size_t want = n
+ *         if want > SSL_READ_MAX_SIZE:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_13get_buffer(PyObject *__pyx_v_self, PyObject *__pyx_v_n); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11SSLProtocol_12get_buffer[] = "SSLProtocol.get_buffer(self, n)";
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_13get_buffer(PyObject *__pyx_v_self, PyObject *__pyx_v_n) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_buffer (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11SSLProtocol_12get_buffer(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self), ((PyObject *)__pyx_v_n));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_12get_buffer(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_n) {
+  size_t __pyx_v_want;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  size_t __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("get_buffer", 0);
+
+  /* "uvloop/sslproto.pyx":362
+ * 
+ *     def get_buffer(self, n):
+ *         cdef size_t want = n             # <<<<<<<<<<<<<<
+ *         if want > SSL_READ_MAX_SIZE:
+ *             want = SSL_READ_MAX_SIZE
+ */
+  __pyx_t_1 = __Pyx_PyInt_As_size_t(__pyx_v_n); if (unlikely((__pyx_t_1 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(22, 362, __pyx_L1_error)
+  __pyx_v_want = __pyx_t_1;
+
+  /* "uvloop/sslproto.pyx":363
+ *     def get_buffer(self, n):
+ *         cdef size_t want = n
+ *         if want > SSL_READ_MAX_SIZE:             # <<<<<<<<<<<<<<
+ *             want = SSL_READ_MAX_SIZE
+ *         if self._ssl_buffer_len < want:
+ */
+  __pyx_t_2 = ((__pyx_v_want > 0x40000) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":364
+ *         cdef size_t want = n
+ *         if want > SSL_READ_MAX_SIZE:
+ *             want = SSL_READ_MAX_SIZE             # <<<<<<<<<<<<<<
+ *         if self._ssl_buffer_len < want:
+ *             self._ssl_buffer = <char*>PyMem_RawRealloc(self._ssl_buffer, want)
+ */
+    __pyx_v_want = 0x40000;
+
+    /* "uvloop/sslproto.pyx":363
+ *     def get_buffer(self, n):
+ *         cdef size_t want = n
+ *         if want > SSL_READ_MAX_SIZE:             # <<<<<<<<<<<<<<
+ *             want = SSL_READ_MAX_SIZE
+ *         if self._ssl_buffer_len < want:
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":365
+ *         if want > SSL_READ_MAX_SIZE:
+ *             want = SSL_READ_MAX_SIZE
+ *         if self._ssl_buffer_len < want:             # <<<<<<<<<<<<<<
+ *             self._ssl_buffer = <char*>PyMem_RawRealloc(self._ssl_buffer, want)
+ *             if not self._ssl_buffer:
+ */
+  __pyx_t_2 = ((__pyx_v_self->_ssl_buffer_len < __pyx_v_want) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":366
+ *             want = SSL_READ_MAX_SIZE
+ *         if self._ssl_buffer_len < want:
+ *             self._ssl_buffer = <char*>PyMem_RawRealloc(self._ssl_buffer, want)             # <<<<<<<<<<<<<<
+ *             if not self._ssl_buffer:
+ *                 raise MemoryError()
+ */
+    __pyx_v_self->_ssl_buffer = ((char *)PyMem_RawRealloc(__pyx_v_self->_ssl_buffer, __pyx_v_want));
+
+    /* "uvloop/sslproto.pyx":367
+ *         if self._ssl_buffer_len < want:
+ *             self._ssl_buffer = <char*>PyMem_RawRealloc(self._ssl_buffer, want)
+ *             if not self._ssl_buffer:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError()
+ *             self._ssl_buffer_len = want
+ */
+    __pyx_t_2 = ((!(__pyx_v_self->_ssl_buffer != 0)) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "uvloop/sslproto.pyx":368
+ *             self._ssl_buffer = <char*>PyMem_RawRealloc(self._ssl_buffer, want)
+ *             if not self._ssl_buffer:
+ *                 raise MemoryError()             # <<<<<<<<<<<<<<
+ *             self._ssl_buffer_len = want
+ *             self._ssl_buffer_view = PyMemoryView_FromMemory(
+ */
+      PyErr_NoMemory(); __PYX_ERR(22, 368, __pyx_L1_error)
+
+      /* "uvloop/sslproto.pyx":367
+ *         if self._ssl_buffer_len < want:
+ *             self._ssl_buffer = <char*>PyMem_RawRealloc(self._ssl_buffer, want)
+ *             if not self._ssl_buffer:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError()
+ *             self._ssl_buffer_len = want
+ */
+    }
+
+    /* "uvloop/sslproto.pyx":369
+ *             if not self._ssl_buffer:
+ *                 raise MemoryError()
+ *             self._ssl_buffer_len = want             # <<<<<<<<<<<<<<
+ *             self._ssl_buffer_view = PyMemoryView_FromMemory(
+ *                 self._ssl_buffer, want, PyBUF_WRITE)
+ */
+    __pyx_v_self->_ssl_buffer_len = __pyx_v_want;
+
+    /* "uvloop/sslproto.pyx":370
+ *                 raise MemoryError()
+ *             self._ssl_buffer_len = want
+ *             self._ssl_buffer_view = PyMemoryView_FromMemory(             # <<<<<<<<<<<<<<
+ *                 self._ssl_buffer, want, PyBUF_WRITE)
+ *         return self._ssl_buffer_view
+ */
+    __pyx_t_3 = PyMemoryView_FromMemory(__pyx_v_self->_ssl_buffer, __pyx_v_want, PyBUF_WRITE); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 370, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_3);
+    __Pyx_GOTREF(__pyx_v_self->_ssl_buffer_view);
+    __Pyx_DECREF(__pyx_v_self->_ssl_buffer_view);
+    __pyx_v_self->_ssl_buffer_view = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":365
+ *         if want > SSL_READ_MAX_SIZE:
+ *             want = SSL_READ_MAX_SIZE
+ *         if self._ssl_buffer_len < want:             # <<<<<<<<<<<<<<
+ *             self._ssl_buffer = <char*>PyMem_RawRealloc(self._ssl_buffer, want)
+ *             if not self._ssl_buffer:
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":372
+ *             self._ssl_buffer_view = PyMemoryView_FromMemory(
+ *                 self._ssl_buffer, want, PyBUF_WRITE)
+ *         return self._ssl_buffer_view             # <<<<<<<<<<<<<<
+ * 
+ *     def buffer_updated(self, nbytes):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_ssl_buffer_view);
+  __pyx_r = __pyx_v_self->_ssl_buffer_view;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":361
+ *             self._handshake_timeout_handle = None
+ * 
+ *     def get_buffer(self, n):             # <<<<<<<<<<<<<<
+ *         cdef size_t want = n
+ *         if want > SSL_READ_MAX_SIZE:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.get_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":374
+ *         return self._ssl_buffer_view
+ * 
+ *     def buffer_updated(self, nbytes):             # <<<<<<<<<<<<<<
+ *         self._incoming_write(PyMemoryView_FromMemory(
+ *             self._ssl_buffer, nbytes, PyBUF_WRITE))
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_15buffer_updated(PyObject *__pyx_v_self, PyObject *__pyx_v_nbytes); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11SSLProtocol_14buffer_updated[] = "SSLProtocol.buffer_updated(self, nbytes)";
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_15buffer_updated(PyObject *__pyx_v_self, PyObject *__pyx_v_nbytes) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("buffer_updated (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11SSLProtocol_14buffer_updated(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self), ((PyObject *)__pyx_v_nbytes));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_14buffer_updated(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_nbytes) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  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;
+  __Pyx_RefNannySetupContext("buffer_updated", 0);
+
+  /* "uvloop/sslproto.pyx":376
+ *     def buffer_updated(self, nbytes):
+ *         self._incoming_write(PyMemoryView_FromMemory(
+ *             self._ssl_buffer, nbytes, PyBUF_WRITE))             # <<<<<<<<<<<<<<
+ * 
+ *         if self._state == DO_HANDSHAKE:
+ */
+  __pyx_t_2 = PyInt_AsSsize_t(__pyx_v_nbytes); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(22, 376, __pyx_L1_error)
+
+  /* "uvloop/sslproto.pyx":375
+ * 
+ *     def buffer_updated(self, nbytes):
+ *         self._incoming_write(PyMemoryView_FromMemory(             # <<<<<<<<<<<<<<
+ *             self._ssl_buffer, nbytes, PyBUF_WRITE))
+ * 
+ */
+  __pyx_t_3 = PyMemoryView_FromMemory(__pyx_v_self->_ssl_buffer, __pyx_t_2, PyBUF_WRITE); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 375, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_v_self->_incoming_write);
+  __pyx_t_4 = __pyx_v_self->_incoming_write; __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_1 = (__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_1)) __PYX_ERR(22, 375, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":378
+ *             self._ssl_buffer, nbytes, PyBUF_WRITE))
+ * 
+ *         if self._state == DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *             self._do_handshake()
+ * 
+ */
+  switch (__pyx_v_self->_state) {
+    case __pyx_e_6uvloop_4loop_DO_HANDSHAKE:
+
+    /* "uvloop/sslproto.pyx":379
+ * 
+ *         if self._state == DO_HANDSHAKE:
+ *             self._do_handshake()             # <<<<<<<<<<<<<<
+ * 
+ *         elif self._state == WRAPPED:
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_handshake(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 379, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":378
+ *             self._ssl_buffer, nbytes, PyBUF_WRITE))
+ * 
+ *         if self._state == DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *             self._do_handshake()
+ * 
+ */
+    break;
+    case __pyx_e_6uvloop_4loop_WRAPPED:
+
+    /* "uvloop/sslproto.pyx":382
+ * 
+ *         elif self._state == WRAPPED:
+ *             self._do_read()             # <<<<<<<<<<<<<<
+ * 
+ *         elif self._state == FLUSHING:
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_read(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 382, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":381
+ *             self._do_handshake()
+ * 
+ *         elif self._state == WRAPPED:             # <<<<<<<<<<<<<<
+ *             self._do_read()
+ * 
+ */
+    break;
+    case __pyx_e_6uvloop_4loop_FLUSHING:
+
+    /* "uvloop/sslproto.pyx":385
+ * 
+ *         elif self._state == FLUSHING:
+ *             self._do_flush()             # <<<<<<<<<<<<<<
+ * 
+ *         elif self._state == SHUTDOWN:
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_flush(__pyx_v_self, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 385, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":384
+ *             self._do_read()
+ * 
+ *         elif self._state == FLUSHING:             # <<<<<<<<<<<<<<
+ *             self._do_flush()
+ * 
+ */
+    break;
+    case __pyx_e_6uvloop_4loop_SHUTDOWN:
+
+    /* "uvloop/sslproto.pyx":388
+ * 
+ *         elif self._state == SHUTDOWN:
+ *             self._do_shutdown()             # <<<<<<<<<<<<<<
+ * 
+ *     def eof_received(self):
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_shutdown(__pyx_v_self, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 388, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":387
+ *             self._do_flush()
+ * 
+ *         elif self._state == SHUTDOWN:             # <<<<<<<<<<<<<<
+ *             self._do_shutdown()
+ * 
+ */
+    break;
+    default: break;
+  }
+
+  /* "uvloop/sslproto.pyx":374
+ *         return self._ssl_buffer_view
+ * 
+ *     def buffer_updated(self, nbytes):             # <<<<<<<<<<<<<<
+ *         self._incoming_write(PyMemoryView_FromMemory(
+ *             self._ssl_buffer, nbytes, PyBUF_WRITE))
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.buffer_updated", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":390
+ *             self._do_shutdown()
+ * 
+ *     def eof_received(self):             # <<<<<<<<<<<<<<
+ *         """Called when the other end of the low-level stream
+ *         is half-closed.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_17eof_received(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11SSLProtocol_16eof_received[] = "SSLProtocol.eof_received(self)\nCalled when the other end of the low-level stream\n        is half-closed.\n\n        If this returns a false value (including None), the transport\n        will close itself.  If it returns a true value, closing the\n        transport is up to the protocol.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_17eof_received(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("eof_received (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11SSLProtocol_16eof_received(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_16eof_received(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("eof_received", 0);
+
+  /* "uvloop/sslproto.pyx":398
+ *         transport is up to the protocol.
+ *         """
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self._loop.get_debug():
+ *                 aio_logger.debug("%r received EOF", self)
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/sslproto.pyx":399
+ *         """
+ *         try:
+ *             if self._loop.get_debug():             # <<<<<<<<<<<<<<
+ *                 aio_logger.debug("%r received EOF", self)
+ * 
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_loop), __pyx_n_s_get_debug); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 399, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __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_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_4 = (__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_4)) __PYX_ERR(22, 399, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(22, 399, __pyx_L3_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_7) {
+
+        /* "uvloop/sslproto.pyx":400
+ *         try:
+ *             if self._loop.get_debug():
+ *                 aio_logger.debug("%r received EOF", self)             # <<<<<<<<<<<<<<
+ * 
+ *             if self._state == DO_HANDSHAKE:
+ */
+        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_debug); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 400, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_6 = NULL;
+        __pyx_t_8 = 0;
+        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_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_6, __pyx_kp_u_r_received_EOF, ((PyObject *)__pyx_v_self)};
+          __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(22, 400, __pyx_L3_error)
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_GOTREF(__pyx_t_4);
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_r_received_EOF, ((PyObject *)__pyx_v_self)};
+          __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(22, 400, __pyx_L3_error)
+          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_GOTREF(__pyx_t_4);
+        } else
+        #endif
+        {
+          __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(22, 400, __pyx_L3_error)
+          __Pyx_GOTREF(__pyx_t_9);
+          if (__pyx_t_6) {
+            __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); __pyx_t_6 = NULL;
+          }
+          __Pyx_INCREF(__pyx_kp_u_r_received_EOF);
+          __Pyx_GIVEREF(__pyx_kp_u_r_received_EOF);
+          PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_kp_u_r_received_EOF);
+          __Pyx_INCREF(((PyObject *)__pyx_v_self));
+          __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+          PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, ((PyObject *)__pyx_v_self));
+          __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 400, __pyx_L3_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_4); __pyx_t_4 = 0;
+
+        /* "uvloop/sslproto.pyx":399
+ *         """
+ *         try:
+ *             if self._loop.get_debug():             # <<<<<<<<<<<<<<
+ *                 aio_logger.debug("%r received EOF", self)
+ * 
+ */
+      }
+
+      /* "uvloop/sslproto.pyx":402
+ *                 aio_logger.debug("%r received EOF", self)
+ * 
+ *             if self._state == DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *                 self._on_handshake_complete(ConnectionResetError)
+ * 
+ */
+      switch (__pyx_v_self->_state) {
+        case __pyx_e_6uvloop_4loop_DO_HANDSHAKE:
+
+        /* "uvloop/sslproto.pyx":403
+ * 
+ *             if self._state == DO_HANDSHAKE:
+ *                 self._on_handshake_complete(ConnectionResetError)             # <<<<<<<<<<<<<<
+ * 
+ *             elif self._state == WRAPPED or self._state == FLUSHING:
+ */
+        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ConnectionResetError); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 403, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_on_handshake_complete(__pyx_v_self, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 403, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/sslproto.pyx":402
+ *                 aio_logger.debug("%r received EOF", self)
+ * 
+ *             if self._state == DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *                 self._on_handshake_complete(ConnectionResetError)
+ * 
+ */
+        break;
+        case __pyx_e_6uvloop_4loop_WRAPPED:
+
+        /* "uvloop/sslproto.pyx":405
+ *                 self._on_handshake_complete(ConnectionResetError)
+ * 
+ *             elif self._state == WRAPPED or self._state == FLUSHING:             # <<<<<<<<<<<<<<
+ *                 # We treat a low-level EOF as a critical situation similar to a
+ *                 # broken connection - just send whatever is in the buffer and
+ */
+        case __pyx_e_6uvloop_4loop_FLUSHING:
+
+        /* "uvloop/sslproto.pyx":411
+ *                 # because we don't want the user to think that this is a
+ *                 # graceful shutdown triggered by SSL "close_notify".
+ *                 self._set_state(SHUTDOWN)             # <<<<<<<<<<<<<<
+ *                 self._on_shutdown_complete(None)
+ * 
+ */
+        __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_6uvloop_4loop_SHUTDOWN); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 411, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/sslproto.pyx":412
+ *                 # graceful shutdown triggered by SSL "close_notify".
+ *                 self._set_state(SHUTDOWN)
+ *                 self._on_shutdown_complete(None)             # <<<<<<<<<<<<<<
+ * 
+ *             elif self._state == SHUTDOWN:
+ */
+        __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_on_shutdown_complete(__pyx_v_self, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 412, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/sslproto.pyx":405
+ *                 self._on_handshake_complete(ConnectionResetError)
+ * 
+ *             elif self._state == WRAPPED or self._state == FLUSHING:             # <<<<<<<<<<<<<<
+ *                 # We treat a low-level EOF as a critical situation similar to a
+ *                 # broken connection - just send whatever is in the buffer and
+ */
+        break;
+        case __pyx_e_6uvloop_4loop_SHUTDOWN:
+
+        /* "uvloop/sslproto.pyx":415
+ * 
+ *             elif self._state == SHUTDOWN:
+ *                 self._on_shutdown_complete(None)             # <<<<<<<<<<<<<<
+ * 
+ *         except Exception:
+ */
+        __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_on_shutdown_complete(__pyx_v_self, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 415, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/sslproto.pyx":414
+ *                 self._on_shutdown_complete(None)
+ * 
+ *             elif self._state == SHUTDOWN:             # <<<<<<<<<<<<<<
+ *                 self._on_shutdown_complete(None)
+ * 
+ */
+        break;
+        default: break;
+      }
+
+      /* "uvloop/sslproto.pyx":398
+ *         transport is up to the protocol.
+ *         """
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self._loop.get_debug():
+ *                 aio_logger.debug("%r received EOF", self)
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/sslproto.pyx":417
+ *                 self._on_shutdown_complete(None)
+ * 
+ *         except Exception:             # <<<<<<<<<<<<<<
+ *             self._transport.close()
+ *             raise
+ */
+    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol.eof_received", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_9) < 0) __PYX_ERR(22, 417, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_9);
+
+      /* "uvloop/sslproto.pyx":418
+ * 
+ *         except Exception:
+ *             self._transport.close()             # <<<<<<<<<<<<<<
+ *             raise
+ * 
+ */
+      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_transport, __pyx_n_s_close); if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 418, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_11 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
+        __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10);
+        if (likely(__pyx_t_11)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+          __Pyx_INCREF(__pyx_t_11);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_10, function);
+        }
+      }
+      __pyx_t_6 = (__pyx_t_11) ? __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_11) : __Pyx_PyObject_CallNoArg(__pyx_t_10);
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 418, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/sslproto.pyx":419
+ *         except Exception:
+ *             self._transport.close()
+ *             raise             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _get_extra_info(self, name, default=None):
+ */
+      __Pyx_GIVEREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_4, __pyx_t_9);
+      __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_9 = 0; 
+      __PYX_ERR(22, 419, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/sslproto.pyx":398
+ *         transport is up to the protocol.
+ *         """
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self._loop.get_debug():
+ *                 aio_logger.debug("%r received EOF", self)
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/sslproto.pyx":390
+ *             self._do_shutdown()
+ * 
+ *     def eof_received(self):             # <<<<<<<<<<<<<<
+ *         """Called when the other end of the low-level stream
+ *         is half-closed.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.eof_received", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":421
+ *             raise
+ * 
+ *     cdef _get_extra_info(self, name, default=None):             # <<<<<<<<<<<<<<
+ *         if name == 'uvloop.sslproto':
+ *             return self
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__get_extra_info(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_name, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__get_extra_info *__pyx_optional_args) {
+  PyObject *__pyx_v_default = ((PyObject *)Py_None);
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_get_extra_info", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_default = __pyx_optional_args->__pyx_default;
+    }
+  }
+
+  /* "uvloop/sslproto.pyx":422
+ * 
+ *     cdef _get_extra_info(self, name, default=None):
+ *         if name == 'uvloop.sslproto':             # <<<<<<<<<<<<<<
+ *             return self
+ *         elif name in self._extra:
+ */
+  __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_name, __pyx_kp_u_uvloop_sslproto, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(22, 422, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":423
+ *     cdef _get_extra_info(self, name, default=None):
+ *         if name == 'uvloop.sslproto':
+ *             return self             # <<<<<<<<<<<<<<
+ *         elif name in self._extra:
+ *             return self._extra[name]
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(((PyObject *)__pyx_v_self));
+    __pyx_r = ((PyObject *)__pyx_v_self);
+    goto __pyx_L0;
+
+    /* "uvloop/sslproto.pyx":422
+ * 
+ *     cdef _get_extra_info(self, name, default=None):
+ *         if name == 'uvloop.sslproto':             # <<<<<<<<<<<<<<
+ *             return self
+ *         elif name in self._extra:
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":424
+ *         if name == 'uvloop.sslproto':
+ *             return self
+ *         elif name in self._extra:             # <<<<<<<<<<<<<<
+ *             return self._extra[name]
+ *         elif self._transport is not None:
+ */
+  __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_v_self->_extra, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(22, 424, __pyx_L1_error)
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":425
+ *             return self
+ *         elif name in self._extra:
+ *             return self._extra[name]             # <<<<<<<<<<<<<<
+ *         elif self._transport is not None:
+ *             return self._transport.get_extra_info(name, default)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_self->_extra, __pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 425, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/sslproto.pyx":424
+ *         if name == 'uvloop.sslproto':
+ *             return self
+ *         elif name in self._extra:             # <<<<<<<<<<<<<<
+ *             return self._extra[name]
+ *         elif self._transport is not None:
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":426
+ *         elif name in self._extra:
+ *             return self._extra[name]
+ *         elif self._transport is not None:             # <<<<<<<<<<<<<<
+ *             return self._transport.get_extra_info(name, default)
+ *         else:
+ */
+  __pyx_t_2 = (__pyx_v_self->_transport != Py_None);
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":427
+ *             return self._extra[name]
+ *         elif self._transport is not None:
+ *             return self._transport.get_extra_info(name, default)             # <<<<<<<<<<<<<<
+ *         else:
+ *             return default
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_transport, __pyx_n_s_get_extra_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 427, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    __pyx_t_6 = 0;
+    if (CYTHON_UNPACK_METHODS && 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;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_name, __pyx_v_default};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 427, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_name, __pyx_v_default};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 427, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else
+    #endif
+    {
+      __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(22, 427, __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_v_name);
+      __Pyx_GIVEREF(__pyx_v_name);
+      PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_v_name);
+      __Pyx_INCREF(__pyx_v_default);
+      __Pyx_GIVEREF(__pyx_v_default);
+      PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_default);
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 427, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/sslproto.pyx":426
+ *         elif name in self._extra:
+ *             return self._extra[name]
+ *         elif self._transport is not None:             # <<<<<<<<<<<<<<
+ *             return self._transport.get_extra_info(name, default)
+ *         else:
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":429
+ *             return self._transport.get_extra_info(name, default)
+ *         else:
+ *             return default             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _set_state(self, SSLProtocolState new_state):
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_default);
+    __pyx_r = __pyx_v_default;
+    goto __pyx_L0;
+  }
+
+  /* "uvloop/sslproto.pyx":421
+ *             raise
+ * 
+ *     cdef _get_extra_info(self, name, default=None):             # <<<<<<<<<<<<<<
+ *         if name == 'uvloop.sslproto':
+ *             return self
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._get_extra_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":431
+ *             return default
+ * 
+ *     cdef _set_state(self, SSLProtocolState new_state):             # <<<<<<<<<<<<<<
+ *         cdef bint allowed = False
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__set_state(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, enum __pyx_t_6uvloop_4loop_SSLProtocolState __pyx_v_new_state) {
+  int __pyx_v_allowed;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_set_state", 0);
+
+  /* "uvloop/sslproto.pyx":432
+ * 
+ *     cdef _set_state(self, SSLProtocolState new_state):
+ *         cdef bint allowed = False             # <<<<<<<<<<<<<<
+ * 
+ *         if new_state == UNWRAPPED:
+ */
+  __pyx_v_allowed = 0;
+
+  /* "uvloop/sslproto.pyx":434
+ *         cdef bint allowed = False
+ * 
+ *         if new_state == UNWRAPPED:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_new_state == __pyx_e_6uvloop_4loop_UNWRAPPED) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":435
+ * 
+ *         if new_state == UNWRAPPED:
+ *             allowed = True             # <<<<<<<<<<<<<<
+ * 
+ *         elif self._state == UNWRAPPED and new_state == DO_HANDSHAKE:
+ */
+    __pyx_v_allowed = 1;
+
+    /* "uvloop/sslproto.pyx":434
+ *         cdef bint allowed = False
+ * 
+ *         if new_state == UNWRAPPED:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/sslproto.pyx":437
+ *             allowed = True
+ * 
+ *         elif self._state == UNWRAPPED and new_state == DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_self->_state == __pyx_e_6uvloop_4loop_UNWRAPPED) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = ((__pyx_v_new_state == __pyx_e_6uvloop_4loop_DO_HANDSHAKE) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":438
+ * 
+ *         elif self._state == UNWRAPPED and new_state == DO_HANDSHAKE:
+ *             allowed = True             # <<<<<<<<<<<<<<
+ * 
+ *         elif self._state == DO_HANDSHAKE and new_state == WRAPPED:
+ */
+    __pyx_v_allowed = 1;
+
+    /* "uvloop/sslproto.pyx":437
+ *             allowed = True
+ * 
+ *         elif self._state == UNWRAPPED and new_state == DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/sslproto.pyx":440
+ *             allowed = True
+ * 
+ *         elif self._state == DO_HANDSHAKE and new_state == WRAPPED:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_self->_state == __pyx_e_6uvloop_4loop_DO_HANDSHAKE) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_2 = ((__pyx_v_new_state == __pyx_e_6uvloop_4loop_WRAPPED) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L6_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":441
+ * 
+ *         elif self._state == DO_HANDSHAKE and new_state == WRAPPED:
+ *             allowed = True             # <<<<<<<<<<<<<<
+ * 
+ *         elif self._state == WRAPPED and new_state == FLUSHING:
+ */
+    __pyx_v_allowed = 1;
+
+    /* "uvloop/sslproto.pyx":440
+ *             allowed = True
+ * 
+ *         elif self._state == DO_HANDSHAKE and new_state == WRAPPED:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/sslproto.pyx":443
+ *             allowed = True
+ * 
+ *         elif self._state == WRAPPED and new_state == FLUSHING:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_self->_state == __pyx_e_6uvloop_4loop_WRAPPED) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L8_bool_binop_done;
+  }
+  __pyx_t_2 = ((__pyx_v_new_state == __pyx_e_6uvloop_4loop_FLUSHING) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L8_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":444
+ * 
+ *         elif self._state == WRAPPED and new_state == FLUSHING:
+ *             allowed = True             # <<<<<<<<<<<<<<
+ * 
+ *         elif self._state == WRAPPED and new_state == SHUTDOWN:
+ */
+    __pyx_v_allowed = 1;
+
+    /* "uvloop/sslproto.pyx":443
+ *             allowed = True
+ * 
+ *         elif self._state == WRAPPED and new_state == FLUSHING:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/sslproto.pyx":446
+ *             allowed = True
+ * 
+ *         elif self._state == WRAPPED and new_state == SHUTDOWN:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_self->_state == __pyx_e_6uvloop_4loop_WRAPPED) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L10_bool_binop_done;
+  }
+  __pyx_t_2 = ((__pyx_v_new_state == __pyx_e_6uvloop_4loop_SHUTDOWN) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L10_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":447
+ * 
+ *         elif self._state == WRAPPED and new_state == SHUTDOWN:
+ *             allowed = True             # <<<<<<<<<<<<<<
+ * 
+ *         elif self._state == FLUSHING and new_state == SHUTDOWN:
+ */
+    __pyx_v_allowed = 1;
+
+    /* "uvloop/sslproto.pyx":446
+ *             allowed = True
+ * 
+ *         elif self._state == WRAPPED and new_state == SHUTDOWN:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/sslproto.pyx":449
+ *             allowed = True
+ * 
+ *         elif self._state == FLUSHING and new_state == SHUTDOWN:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_self->_state == __pyx_e_6uvloop_4loop_FLUSHING) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L12_bool_binop_done;
+  }
+  __pyx_t_2 = ((__pyx_v_new_state == __pyx_e_6uvloop_4loop_SHUTDOWN) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L12_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":450
+ * 
+ *         elif self._state == FLUSHING and new_state == SHUTDOWN:
+ *             allowed = True             # <<<<<<<<<<<<<<
+ * 
+ *         if allowed:
+ */
+    __pyx_v_allowed = 1;
+
+    /* "uvloop/sslproto.pyx":449
+ *             allowed = True
+ * 
+ *         elif self._state == FLUSHING and new_state == SHUTDOWN:             # <<<<<<<<<<<<<<
+ *             allowed = True
+ * 
+ */
+  }
+  __pyx_L3:;
+
+  /* "uvloop/sslproto.pyx":452
+ *             allowed = True
+ * 
+ *         if allowed:             # <<<<<<<<<<<<<<
+ *             self._state = new_state
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_allowed != 0);
+  if (likely(__pyx_t_1)) {
+
+    /* "uvloop/sslproto.pyx":453
+ * 
+ *         if allowed:
+ *             self._state = new_state             # <<<<<<<<<<<<<<
+ * 
+ *         else:
+ */
+    __pyx_v_self->_state = __pyx_v_new_state;
+
+    /* "uvloop/sslproto.pyx":452
+ *             allowed = True
+ * 
+ *         if allowed:             # <<<<<<<<<<<<<<
+ *             self._state = new_state
+ * 
+ */
+    goto __pyx_L14;
+  }
+
+  /* "uvloop/sslproto.pyx":456
+ * 
+ *         else:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'cannot switch state from {} to {}'.format(
+ *                     self._state, new_state))
+ */
+  /*else*/ {
+
+    /* "uvloop/sslproto.pyx":457
+ *         else:
+ *             raise RuntimeError(
+ *                 'cannot switch state from {} to {}'.format(             # <<<<<<<<<<<<<<
+ *                     self._state, new_state))
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cannot_switch_state_from_to, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 457, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "uvloop/sslproto.pyx":458
+ *             raise RuntimeError(
+ *                 'cannot switch state from {} to {}'.format(
+ *                     self._state, new_state))             # <<<<<<<<<<<<<<
+ * 
+ *     # Handshake flow
+ */
+    __pyx_t_5 = __Pyx_PyInt_From_enum____pyx_t_6uvloop_4loop_SSLProtocolState(__pyx_v_self->_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 458, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = __Pyx_PyInt_From_enum____pyx_t_6uvloop_4loop_SSLProtocolState(__pyx_v_new_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 458, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = NULL;
+    __pyx_t_8 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_8 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_6};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 457, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_6};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 457, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __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(22, 457, __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_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6);
+      __pyx_t_5 = 0;
+      __pyx_t_6 = 0;
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 457, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":456
+ * 
+ *         else:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'cannot switch state from {} to {}'.format(
+ *                     self._state, new_state))
+ */
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 456, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(22, 456, __pyx_L1_error)
+  }
+  __pyx_L14:;
+
+  /* "uvloop/sslproto.pyx":431
+ *             return default
+ * 
+ *     cdef _set_state(self, SSLProtocolState new_state):             # <<<<<<<<<<<<<<
+ *         cdef bint allowed = False
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":474
+ *         self._handshake_timeout_handle = \
+ *             self._loop.call_later(self._ssl_handshake_timeout,
+ *                                   lambda: self._check_handshake_timeout())             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_16_start_handshake_lambda4(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyMethodDef __pyx_mdef_6uvloop_4loop_11SSLProtocol_16_start_handshake_lambda4 = {"lambda4", (PyCFunction)__pyx_pw_6uvloop_4loop_11SSLProtocol_16_start_handshake_lambda4, METH_NOARGS, 0};
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_16_start_handshake_lambda4(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("lambda4 (wrapper)", 0);
+  __pyx_r = __pyx_lambda_funcdef_lambda4(__pyx_self);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_lambda_funcdef_lambda4(PyObject *__pyx_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *__pyx_cur_scope;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *__pyx_outer_scope;
+  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("lambda4", 0);
+  __pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *) __Pyx_CyFunction_GetClosure(__pyx_self);
+  __pyx_cur_scope = __pyx_outer_scope;
+  __Pyx_XDECREF(__pyx_r);
+  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(22, 474, __pyx_L1_error) }
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_check_handshake_timeout(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 474, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._start_handshake.lambda4", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":462
+ *     # Handshake flow
+ * 
+ *     cdef _start_handshake(self):             # <<<<<<<<<<<<<<
+ *         if self._loop.get_debug():
+ *             aio_logger.debug("%r starts SSL handshake", self)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__start_handshake(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *__pyx_cur_scope;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  char const *__pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_start_handshake", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_28__start_handshake(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_28__start_handshake, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(22, 462, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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);
+
+  /* "uvloop/sslproto.pyx":463
+ * 
+ *     cdef _start_handshake(self):
+ *         if self._loop.get_debug():             # <<<<<<<<<<<<<<
+ *             aio_logger.debug("%r starts SSL handshake", self)
+ *             self._handshake_start_time = self._loop.time()
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self->_loop), __pyx_n_s_get_debug); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 463, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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(22, 463, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(22, 463, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_4) {
+
+    /* "uvloop/sslproto.pyx":464
+ *     cdef _start_handshake(self):
+ *         if self._loop.get_debug():
+ *             aio_logger.debug("%r starts SSL handshake", self)             # <<<<<<<<<<<<<<
+ *             self._handshake_start_time = self._loop.time()
+ *         else:
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 464, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = NULL;
+    __pyx_t_5 = 0;
+    if (CYTHON_UNPACK_METHODS && 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_5 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_kp_u_r_starts_SSL_handshake, ((PyObject *)__pyx_cur_scope->__pyx_v_self)};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 464, __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[3] = {__pyx_t_3, __pyx_kp_u_r_starts_SSL_handshake, ((PyObject *)__pyx_cur_scope->__pyx_v_self)};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 464, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 464, __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_kp_u_r_starts_SSL_handshake);
+      __Pyx_GIVEREF(__pyx_kp_u_r_starts_SSL_handshake);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_kp_u_r_starts_SSL_handshake);
+      __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+      __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+      PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 464, __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_1); __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":465
+ *         if self._loop.get_debug():
+ *             aio_logger.debug("%r starts SSL handshake", self)
+ *             self._handshake_start_time = self._loop.time()             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._handshake_start_time = None
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self->_loop), __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 465, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_6 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_6)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 465, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GIVEREF(__pyx_t_1);
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_handshake_start_time);
+    __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_handshake_start_time);
+    __pyx_cur_scope->__pyx_v_self->_handshake_start_time = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":463
+ * 
+ *     cdef _start_handshake(self):
+ *         if self._loop.get_debug():             # <<<<<<<<<<<<<<
+ *             aio_logger.debug("%r starts SSL handshake", self)
+ *             self._handshake_start_time = self._loop.time()
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/sslproto.pyx":467
+ *             self._handshake_start_time = self._loop.time()
+ *         else:
+ *             self._handshake_start_time = None             # <<<<<<<<<<<<<<
+ * 
+ *         self._set_state(DO_HANDSHAKE)
+ */
+  /*else*/ {
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_handshake_start_time);
+    __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_handshake_start_time);
+    __pyx_cur_scope->__pyx_v_self->_handshake_start_time = Py_None;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/sslproto.pyx":469
+ *             self._handshake_start_time = None
+ * 
+ *         self._set_state(DO_HANDSHAKE)             # <<<<<<<<<<<<<<
+ * 
+ *         # start handshake timeout count down
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_set_state(__pyx_cur_scope->__pyx_v_self, __pyx_e_6uvloop_4loop_DO_HANDSHAKE); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 469, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":473
+ *         # start handshake timeout count down
+ *         self._handshake_timeout_handle = \
+ *             self._loop.call_later(self._ssl_handshake_timeout,             # <<<<<<<<<<<<<<
+ *                                   lambda: self._check_handshake_timeout())
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self->_loop), __pyx_n_s_call_later); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 473, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "uvloop/sslproto.pyx":474
+ *         self._handshake_timeout_handle = \
+ *             self._loop.call_later(self._ssl_handshake_timeout,
+ *                                   lambda: self._check_handshake_timeout())             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_11SSLProtocol_16_start_handshake_lambda4, 0, __pyx_n_s_SSLProtocol__start_handshake_loc, ((PyObject*)__pyx_cur_scope), __pyx_n_s_uvloop_loop, __pyx_d, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 474, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_3 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && 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_5 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_cur_scope->__pyx_v_self->_ssl_handshake_timeout, __pyx_t_6};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 473, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_cur_scope->__pyx_v_self->_ssl_handshake_timeout, __pyx_t_6};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 473, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(22, 473, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (__pyx_t_3) {
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
+    }
+    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_self->_ssl_handshake_timeout);
+    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_self->_ssl_handshake_timeout);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_5, __pyx_cur_scope->__pyx_v_self->_ssl_handshake_timeout);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_5, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 473, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/sslproto.pyx":472
+ * 
+ *         # start handshake timeout count down
+ *         self._handshake_timeout_handle = \             # <<<<<<<<<<<<<<
+ *             self._loop.call_later(self._ssl_handshake_timeout,
+ *                                   lambda: self._check_handshake_timeout())
+ */
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_handshake_timeout_handle);
+  __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_handshake_timeout_handle);
+  __pyx_cur_scope->__pyx_v_self->_handshake_timeout_handle = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":476
+ *                                   lambda: self._check_handshake_timeout())
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._sslobj = self._sslcontext.wrap_bio(
+ *                 self._incoming, self._outgoing,
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+    __Pyx_XGOTREF(__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_9);
+    __Pyx_XGOTREF(__pyx_t_10);
+    /*try:*/ {
+
+      /* "uvloop/sslproto.pyx":477
+ * 
+ *         try:
+ *             self._sslobj = self._sslcontext.wrap_bio(             # <<<<<<<<<<<<<<
+ *                 self._incoming, self._outgoing,
+ *                 server_side=self._server_side,
+ */
+      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self->_sslcontext, __pyx_n_s_wrap_bio); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 477, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_1);
+
+      /* "uvloop/sslproto.pyx":478
+ *         try:
+ *             self._sslobj = self._sslcontext.wrap_bio(
+ *                 self._incoming, self._outgoing,             # <<<<<<<<<<<<<<
+ *                 server_side=self._server_side,
+ *                 server_hostname=self._server_hostname)
+ */
+      __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 477, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_self->_incoming);
+      __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_self->_incoming);
+      PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_cur_scope->__pyx_v_self->_incoming);
+      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_self->_outgoing);
+      __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_self->_outgoing);
+      PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_cur_scope->__pyx_v_self->_outgoing);
+
+      /* "uvloop/sslproto.pyx":479
+ *             self._sslobj = self._sslcontext.wrap_bio(
+ *                 self._incoming, self._outgoing,
+ *                 server_side=self._server_side,             # <<<<<<<<<<<<<<
+ *                 server_hostname=self._server_hostname)
+ *             self._sslobj_read = self._sslobj.read
+ */
+      __pyx_t_7 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(22, 479, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_cur_scope->__pyx_v_self->_server_side); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 479, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_server_side, __pyx_t_6) < 0) __PYX_ERR(22, 479, __pyx_L4_error)
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/sslproto.pyx":480
+ *                 self._incoming, self._outgoing,
+ *                 server_side=self._server_side,
+ *                 server_hostname=self._server_hostname)             # <<<<<<<<<<<<<<
+ *             self._sslobj_read = self._sslobj.read
+ *             self._sslobj_write = self._sslobj.write
+ */
+      if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_server_hostname, __pyx_cur_scope->__pyx_v_self->_server_hostname) < 0) __PYX_ERR(22, 479, __pyx_L4_error)
+
+      /* "uvloop/sslproto.pyx":477
+ * 
+ *         try:
+ *             self._sslobj = self._sslcontext.wrap_bio(             # <<<<<<<<<<<<<<
+ *                 self._incoming, self._outgoing,
+ *                 server_side=self._server_side,
+ */
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 477, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GIVEREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_sslobj);
+      __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_sslobj);
+      __pyx_cur_scope->__pyx_v_self->_sslobj = __pyx_t_6;
+      __pyx_t_6 = 0;
+
+      /* "uvloop/sslproto.pyx":481
+ *                 server_side=self._server_side,
+ *                 server_hostname=self._server_hostname)
+ *             self._sslobj_read = self._sslobj.read             # <<<<<<<<<<<<<<
+ *             self._sslobj_write = self._sslobj.write
+ *         except Exception as ex:
+ */
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self->_sslobj, __pyx_n_s_read); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 481, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_sslobj_read);
+      __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_sslobj_read);
+      __pyx_cur_scope->__pyx_v_self->_sslobj_read = __pyx_t_6;
+      __pyx_t_6 = 0;
+
+      /* "uvloop/sslproto.pyx":482
+ *                 server_hostname=self._server_hostname)
+ *             self._sslobj_read = self._sslobj.read
+ *             self._sslobj_write = self._sslobj.write             # <<<<<<<<<<<<<<
+ *         except Exception as ex:
+ *             self._on_handshake_complete(ex)
+ */
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self->_sslobj, __pyx_n_s_write); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 482, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_sslobj_write);
+      __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_sslobj_write);
+      __pyx_cur_scope->__pyx_v_self->_sslobj_write = __pyx_t_6;
+      __pyx_t_6 = 0;
+
+      /* "uvloop/sslproto.pyx":476
+ *                                   lambda: self._check_handshake_timeout())
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._sslobj = self._sslcontext.wrap_bio(
+ *                 self._incoming, self._outgoing,
+ */
+    }
+
+    /* "uvloop/sslproto.pyx":486
+ *             self._on_handshake_complete(ex)
+ *         else:
+ *             self._do_handshake()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _check_handshake_timeout(self):
+ */
+    /*else:*/ {
+      __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_do_handshake(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 486, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    goto __pyx_L9_try_end;
+    __pyx_L4_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/sslproto.pyx":483
+ *             self._sslobj_read = self._sslobj.read
+ *             self._sslobj_write = self._sslobj.write
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._on_handshake_complete(ex)
+ *         else:
+ */
+    __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_5) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._start_handshake", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_2) < 0) __PYX_ERR(22, 483, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_7);
+      __pyx_v_ex = __pyx_t_7;
+      /*try:*/ {
+
+        /* "uvloop/sslproto.pyx":484
+ *             self._sslobj_write = self._sslobj.write
+ *         except Exception as ex:
+ *             self._on_handshake_complete(ex)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._do_handshake()
+ */
+        __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_on_handshake_complete(__pyx_cur_scope->__pyx_v_self, __pyx_v_ex); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 484, __pyx_L15_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      }
+
+      /* "uvloop/sslproto.pyx":483
+ *             self._sslobj_read = self._sslobj.read
+ *             self._sslobj_write = self._sslobj.write
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._on_handshake_complete(ex)
+ *         else:
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L16;
+        }
+        __pyx_L15_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __pyx_t_5 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+          }
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __pyx_lineno = __pyx_t_5; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12;
+          goto __pyx_L6_except_error;
+        }
+        __pyx_L16:;
+      }
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      goto __pyx_L5_exception_handled;
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/sslproto.pyx":476
+ *                                   lambda: self._check_handshake_timeout())
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._sslobj = self._sslcontext.wrap_bio(
+ *                 self._incoming, self._outgoing,
+ */
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    goto __pyx_L1_error;
+    __pyx_L5_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    __pyx_L9_try_end:;
+  }
+
+  /* "uvloop/sslproto.pyx":462
+ *     # Handshake flow
+ * 
+ *     cdef _start_handshake(self):             # <<<<<<<<<<<<<<
+ *         if self._loop.get_debug():
+ *             aio_logger.debug("%r starts SSL handshake", self)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._start_handshake", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":488
+ *             self._do_handshake()
+ * 
+ *     cdef _check_handshake_timeout(self):             # <<<<<<<<<<<<<<
+ *         if self._state == DO_HANDSHAKE:
+ *             msg = (
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__check_handshake_timeout(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  PyObject *__pyx_v_msg = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  Py_UCS4 __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_check_handshake_timeout", 0);
+
+  /* "uvloop/sslproto.pyx":489
+ * 
+ *     cdef _check_handshake_timeout(self):
+ *         if self._state == DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *             msg = (
+ *                 f"SSL handshake is taking longer than "
+ */
+  __pyx_t_1 = ((__pyx_v_self->_state == __pyx_e_6uvloop_4loop_DO_HANDSHAKE) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":491
+ *         if self._state == DO_HANDSHAKE:
+ *             msg = (
+ *                 f"SSL handshake is taking longer than "             # <<<<<<<<<<<<<<
+ *                 f"{self._ssl_handshake_timeout} seconds: "
+ *                 f"aborting the connection"
+ */
+    __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 491, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = 0;
+    __pyx_t_4 = 127;
+    __Pyx_INCREF(__pyx_kp_u_SSL_handshake_is_taking_longer_t);
+    __pyx_t_3 += 36;
+    __Pyx_GIVEREF(__pyx_kp_u_SSL_handshake_is_taking_longer_t);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_SSL_handshake_is_taking_longer_t);
+
+    /* "uvloop/sslproto.pyx":492
+ *             msg = (
+ *                 f"SSL handshake is taking longer than "
+ *                 f"{self._ssl_handshake_timeout} seconds: "             # <<<<<<<<<<<<<<
+ *                 f"aborting the connection"
+ *             )
+ */
+    __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_self->_ssl_handshake_timeout, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 492, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_4 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_4) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_4;
+    __pyx_t_3 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_5);
+    __pyx_t_5 = 0;
+    __Pyx_INCREF(__pyx_kp_u_seconds_aborting_the_connection);
+    __pyx_t_3 += 33;
+    __Pyx_GIVEREF(__pyx_kp_u_seconds_aborting_the_connection);
+    PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_seconds_aborting_the_connection);
+
+    /* "uvloop/sslproto.pyx":491
+ *         if self._state == DO_HANDSHAKE:
+ *             msg = (
+ *                 f"SSL handshake is taking longer than "             # <<<<<<<<<<<<<<
+ *                 f"{self._ssl_handshake_timeout} seconds: "
+ *                 f"aborting the connection"
+ */
+    __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 491, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_v_msg = ((PyObject*)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "uvloop/sslproto.pyx":495
+ *                 f"aborting the connection"
+ *             )
+ *             self._fatal_error(ConnectionAbortedError(msg))             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _do_handshake(self):
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_ConnectionAbortedError); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 495, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_msg); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 495, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_fatal_error(__pyx_v_self, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 495, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/sslproto.pyx":489
+ * 
+ *     cdef _check_handshake_timeout(self):
+ *         if self._state == DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *             msg = (
+ *                 f"SSL handshake is taking longer than "
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":488
+ *             self._do_handshake()
+ * 
+ *     cdef _check_handshake_timeout(self):             # <<<<<<<<<<<<<<
+ *         if self._state == DO_HANDSHAKE:
+ *             msg = (
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._check_handshake_timeout", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_msg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":497
+ *             self._fatal_error(ConnectionAbortedError(msg))
+ * 
+ *     cdef _do_handshake(self):             # <<<<<<<<<<<<<<
+ *         try:
+ *             self._sslobj.do_handshake()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_handshake(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  char const *__pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  char const *__pyx_t_17;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_do_handshake", 0);
+
+  /* "uvloop/sslproto.pyx":498
+ * 
+ *     cdef _do_handshake(self):
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._sslobj.do_handshake()
+ *         except ssl_SSLAgainErrors as exc:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/sslproto.pyx":499
+ *     cdef _do_handshake(self):
+ *         try:
+ *             self._sslobj.do_handshake()             # <<<<<<<<<<<<<<
+ *         except ssl_SSLAgainErrors as exc:
+ *             self._process_outgoing()
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_sslobj, __pyx_n_s_do_handshake); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 499, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __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_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+        }
+      }
+      __pyx_t_4 = (__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_4)) __PYX_ERR(22, 499, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/sslproto.pyx":498
+ * 
+ *     cdef _do_handshake(self):
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._sslobj.do_handshake()
+ *         except ssl_SSLAgainErrors as exc:
+ */
+    }
+
+    /* "uvloop/sslproto.pyx":505
+ *             self._on_handshake_complete(exc)
+ *         else:
+ *             self._on_handshake_complete(None)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_handshake_complete(self, handshake_exc):
+ */
+    /*else:*/ {
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_on_handshake_complete(__pyx_v_self, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 505, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/sslproto.pyx":500
+ *         try:
+ *             self._sslobj.do_handshake()
+ *         except ssl_SSLAgainErrors as exc:             # <<<<<<<<<<<<<<
+ *             self._process_outgoing()
+ *         except ssl_SSLError as exc:
+ */
+    __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_ssl_SSLAgainErrors);
+    if (__pyx_t_7) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_handshake", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(22, 500, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_v_exc = __pyx_t_5;
+      /*try:*/ {
+
+        /* "uvloop/sslproto.pyx":501
+ *             self._sslobj.do_handshake()
+ *         except ssl_SSLAgainErrors as exc:
+ *             self._process_outgoing()             # <<<<<<<<<<<<<<
+ *         except ssl_SSLError as exc:
+ *             self._on_handshake_complete(exc)
+ */
+        __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_process_outgoing(__pyx_v_self); if (unlikely(!__pyx_t_8)) __PYX_ERR(22, 501, __pyx_L14_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+
+      /* "uvloop/sslproto.pyx":500
+ *         try:
+ *             self._sslobj.do_handshake()
+ *         except ssl_SSLAgainErrors as exc:             # <<<<<<<<<<<<<<
+ *             self._process_outgoing()
+ *         except ssl_SSLError as exc:
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L15;
+        }
+        __pyx_L14_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_11);
+          __Pyx_XGOTREF(__pyx_t_12);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __pyx_t_7 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+          }
+          __Pyx_XGIVEREF(__pyx_t_11);
+          __Pyx_XGIVEREF(__pyx_t_12);
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+          __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+          __pyx_lineno = __pyx_t_7; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10;
+          goto __pyx_L5_except_error;
+        }
+        __pyx_L15:;
+      }
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+
+    /* "uvloop/sslproto.pyx":502
+ *         except ssl_SSLAgainErrors as exc:
+ *             self._process_outgoing()
+ *         except ssl_SSLError as exc:             # <<<<<<<<<<<<<<
+ *             self._on_handshake_complete(exc)
+ *         else:
+ */
+    __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_ssl_SSLError);
+    if (__pyx_t_9) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_handshake", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(22, 502, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_v_exc = __pyx_t_5;
+      /*try:*/ {
+
+        /* "uvloop/sslproto.pyx":503
+ *             self._process_outgoing()
+ *         except ssl_SSLError as exc:
+ *             self._on_handshake_complete(exc)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._on_handshake_complete(None)
+ */
+        __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_on_handshake_complete(__pyx_v_self, __pyx_v_exc); if (unlikely(!__pyx_t_8)) __PYX_ERR(22, 503, __pyx_L25_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+
+      /* "uvloop/sslproto.pyx":502
+ *         except ssl_SSLAgainErrors as exc:
+ *             self._process_outgoing()
+ *         except ssl_SSLError as exc:             # <<<<<<<<<<<<<<
+ *             self._on_handshake_complete(exc)
+ *         else:
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L26;
+        }
+        __pyx_L25_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0;
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_15, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_15, &__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_12);
+          __Pyx_XGOTREF(__pyx_t_11);
+          __pyx_t_9 = __pyx_lineno; __pyx_t_7 = __pyx_clineno; __pyx_t_17 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_XGIVEREF(__pyx_t_12);
+            __Pyx_XGIVEREF(__pyx_t_11);
+            __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_12, __pyx_t_11);
+          }
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_ErrRestore(__pyx_t_16, __pyx_t_15, __pyx_t_14);
+          __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0;
+          __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_7; __pyx_filename = __pyx_t_17;
+          goto __pyx_L5_except_error;
+        }
+        __pyx_L26:;
+      }
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/sslproto.pyx":498
+ * 
+ *     cdef _do_handshake(self):
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._sslobj.do_handshake()
+ *         except ssl_SSLAgainErrors as exc:
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/sslproto.pyx":497
+ *             self._fatal_error(ConnectionAbortedError(msg))
+ * 
+ *     cdef _do_handshake(self):             # <<<<<<<<<<<<<<
+ *         try:
+ *             self._sslobj.do_handshake()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_handshake", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":507
+ *             self._on_handshake_complete(None)
+ * 
+ *     cdef _on_handshake_complete(self, handshake_exc):             # <<<<<<<<<<<<<<
+ *         if self._handshake_timeout_handle is not None:
+ *             self._handshake_timeout_handle.cancel()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__on_handshake_complete(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_handshake_exc) {
+  PyObject *__pyx_v_sslobj = NULL;
+  PyObject *__pyx_v_peercert = NULL;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_v_msg = NULL;
+  PyObject *__pyx_v_dt = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__fatal_error __pyx_t_11;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__wakeup_waiter __pyx_t_12;
+  int __pyx_t_13;
+  char const *__pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_handshake_complete", 0);
+
+  /* "uvloop/sslproto.pyx":508
+ * 
+ *     cdef _on_handshake_complete(self, handshake_exc):
+ *         if self._handshake_timeout_handle is not None:             # <<<<<<<<<<<<<<
+ *             self._handshake_timeout_handle.cancel()
+ *             self._handshake_timeout_handle = None
+ */
+  __pyx_t_1 = (__pyx_v_self->_handshake_timeout_handle != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":509
+ *     cdef _on_handshake_complete(self, handshake_exc):
+ *         if self._handshake_timeout_handle is not None:
+ *             self._handshake_timeout_handle.cancel()             # <<<<<<<<<<<<<<
+ *             self._handshake_timeout_handle = None
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_handshake_timeout_handle, __pyx_n_s_cancel); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 509, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 509, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":510
+ *         if self._handshake_timeout_handle is not None:
+ *             self._handshake_timeout_handle.cancel()
+ *             self._handshake_timeout_handle = None             # <<<<<<<<<<<<<<
+ * 
+ *         sslobj = self._sslobj
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_handshake_timeout_handle);
+    __Pyx_DECREF(__pyx_v_self->_handshake_timeout_handle);
+    __pyx_v_self->_handshake_timeout_handle = Py_None;
+
+    /* "uvloop/sslproto.pyx":508
+ * 
+ *     cdef _on_handshake_complete(self, handshake_exc):
+ *         if self._handshake_timeout_handle is not None:             # <<<<<<<<<<<<<<
+ *             self._handshake_timeout_handle.cancel()
+ *             self._handshake_timeout_handle = None
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":512
+ *             self._handshake_timeout_handle = None
+ * 
+ *         sslobj = self._sslobj             # <<<<<<<<<<<<<<
+ *         try:
+ *             if handshake_exc is None:
+ */
+  __pyx_t_3 = __pyx_v_self->_sslobj;
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_v_sslobj = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":513
+ * 
+ *         sslobj = self._sslobj
+ *         try:             # <<<<<<<<<<<<<<
+ *             if handshake_exc is None:
+ *                 self._set_state(WRAPPED)
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_7);
+    __Pyx_XGOTREF(__pyx_t_8);
+    /*try:*/ {
+
+      /* "uvloop/sslproto.pyx":514
+ *         sslobj = self._sslobj
+ *         try:
+ *             if handshake_exc is None:             # <<<<<<<<<<<<<<
+ *                 self._set_state(WRAPPED)
+ *             else:
+ */
+      __pyx_t_2 = (__pyx_v_handshake_exc == Py_None);
+      __pyx_t_1 = (__pyx_t_2 != 0);
+      if (likely(__pyx_t_1)) {
+
+        /* "uvloop/sslproto.pyx":515
+ *         try:
+ *             if handshake_exc is None:
+ *                 self._set_state(WRAPPED)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise handshake_exc
+ */
+        __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_6uvloop_4loop_WRAPPED); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 515, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+        /* "uvloop/sslproto.pyx":514
+ *         sslobj = self._sslobj
+ *         try:
+ *             if handshake_exc is None:             # <<<<<<<<<<<<<<
+ *                 self._set_state(WRAPPED)
+ *             else:
+ */
+        goto __pyx_L10;
+      }
+
+      /* "uvloop/sslproto.pyx":517
+ *                 self._set_state(WRAPPED)
+ *             else:
+ *                 raise handshake_exc             # <<<<<<<<<<<<<<
+ * 
+ *             peercert = sslobj.getpeercert()
+ */
+      /*else*/ {
+        __Pyx_Raise(__pyx_v_handshake_exc, 0, 0, 0);
+        __PYX_ERR(22, 517, __pyx_L4_error)
+      }
+      __pyx_L10:;
+
+      /* "uvloop/sslproto.pyx":519
+ *                 raise handshake_exc
+ * 
+ *             peercert = sslobj.getpeercert()             # <<<<<<<<<<<<<<
+ *         except Exception as exc:
+ *             self._set_state(UNWRAPPED)
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sslobj, __pyx_n_s_getpeercert); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 519, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 519, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_v_peercert = __pyx_t_3;
+      __pyx_t_3 = 0;
+
+      /* "uvloop/sslproto.pyx":513
+ * 
+ *         sslobj = self._sslobj
+ *         try:             # <<<<<<<<<<<<<<
+ *             if handshake_exc is None:
+ *                 self._set_state(WRAPPED)
+ */
+    }
+    __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;
+    goto __pyx_L9_try_end;
+    __pyx_L4_error:;
+    __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;
+
+    /* "uvloop/sslproto.pyx":520
+ * 
+ *             peercert = sslobj.getpeercert()
+ *         except Exception as exc:             # <<<<<<<<<<<<<<
+ *             self._set_state(UNWRAPPED)
+ *             if isinstance(exc, ssl_CertificateError):
+ */
+    __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_9) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._on_handshake_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(22, 520, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_4);
+      __pyx_v_exc = __pyx_t_4;
+      /*try:*/ {
+
+        /* "uvloop/sslproto.pyx":521
+ *             peercert = sslobj.getpeercert()
+ *         except Exception as exc:
+ *             self._set_state(UNWRAPPED)             # <<<<<<<<<<<<<<
+ *             if isinstance(exc, ssl_CertificateError):
+ *                 msg = 'SSL handshake failed on verifying the certificate'
+ */
+        __pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_6uvloop_4loop_UNWRAPPED); if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 521, __pyx_L16_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+        /* "uvloop/sslproto.pyx":522
+ *         except Exception as exc:
+ *             self._set_state(UNWRAPPED)
+ *             if isinstance(exc, ssl_CertificateError):             # <<<<<<<<<<<<<<
+ *                 msg = 'SSL handshake failed on verifying the certificate'
+ *             else:
+ */
+        __pyx_t_10 = __pyx_v_6uvloop_4loop_ssl_CertificateError;
+        __Pyx_INCREF(__pyx_t_10);
+        __pyx_t_1 = PyObject_IsInstance(__pyx_v_exc, __pyx_t_10); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(22, 522, __pyx_L16_error)
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __pyx_t_2 = (__pyx_t_1 != 0);
+        if (__pyx_t_2) {
+
+          /* "uvloop/sslproto.pyx":523
+ *             self._set_state(UNWRAPPED)
+ *             if isinstance(exc, ssl_CertificateError):
+ *                 msg = 'SSL handshake failed on verifying the certificate'             # <<<<<<<<<<<<<<
+ *             else:
+ *                 msg = 'SSL handshake failed'
+ */
+          __Pyx_INCREF(__pyx_kp_u_SSL_handshake_failed_on_verifyin);
+          __pyx_v_msg = __pyx_kp_u_SSL_handshake_failed_on_verifyin;
+
+          /* "uvloop/sslproto.pyx":522
+ *         except Exception as exc:
+ *             self._set_state(UNWRAPPED)
+ *             if isinstance(exc, ssl_CertificateError):             # <<<<<<<<<<<<<<
+ *                 msg = 'SSL handshake failed on verifying the certificate'
+ *             else:
+ */
+          goto __pyx_L18;
+        }
+
+        /* "uvloop/sslproto.pyx":525
+ *                 msg = 'SSL handshake failed on verifying the certificate'
+ *             else:
+ *                 msg = 'SSL handshake failed'             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, msg)
+ *             self._wakeup_waiter(exc)
+ */
+        /*else*/ {
+          __Pyx_INCREF(__pyx_kp_u_SSL_handshake_failed);
+          __pyx_v_msg = __pyx_kp_u_SSL_handshake_failed;
+        }
+        __pyx_L18:;
+
+        /* "uvloop/sslproto.pyx":526
+ *             else:
+ *                 msg = 'SSL handshake failed'
+ *             self._fatal_error(exc, msg)             # <<<<<<<<<<<<<<
+ *             self._wakeup_waiter(exc)
+ *             return
+ */
+        __pyx_t_11.__pyx_n = 1;
+        __pyx_t_11.message = __pyx_v_msg;
+        __pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_fatal_error(__pyx_v_self, __pyx_v_exc, &__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 526, __pyx_L16_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+        /* "uvloop/sslproto.pyx":527
+ *                 msg = 'SSL handshake failed'
+ *             self._fatal_error(exc, msg)
+ *             self._wakeup_waiter(exc)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+        __pyx_t_12.__pyx_n = 1;
+        __pyx_t_12.exc = __pyx_v_exc;
+        __pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_wakeup_waiter(__pyx_v_self, &__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 527, __pyx_L16_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+        /* "uvloop/sslproto.pyx":528
+ *             self._fatal_error(exc, msg)
+ *             self._wakeup_waiter(exc)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if self._loop.get_debug():
+ */
+        __Pyx_XDECREF(__pyx_r);
+        __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        goto __pyx_L15_return;
+      }
+
+      /* "uvloop/sslproto.pyx":520
+ * 
+ *             peercert = sslobj.getpeercert()
+ *         except Exception as exc:             # <<<<<<<<<<<<<<
+ *             self._set_state(UNWRAPPED)
+ *             if isinstance(exc, ssl_CertificateError):
+ */
+      /*finally:*/ {
+        __pyx_L16_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_20);
+          __pyx_t_9 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+          }
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+          __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+          __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
+          goto __pyx_L6_except_error;
+        }
+        __pyx_L15_return: {
+          __pyx_t_20 = __pyx_r;
+          __pyx_r = 0;
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          __pyx_r = __pyx_t_20;
+          __pyx_t_20 = 0;
+          goto __pyx_L7_except_return;
+        }
+      }
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/sslproto.pyx":513
+ * 
+ *         sslobj = self._sslobj
+ *         try:             # <<<<<<<<<<<<<<
+ *             if handshake_exc is None:
+ *                 self._set_state(WRAPPED)
+ */
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_7);
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+    goto __pyx_L1_error;
+    __pyx_L7_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_7);
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+    goto __pyx_L0;
+    __pyx_L9_try_end:;
+  }
+
+  /* "uvloop/sslproto.pyx":530
+ *             return
+ * 
+ *         if self._loop.get_debug():             # <<<<<<<<<<<<<<
+ *             dt = self._loop.time() - self._handshake_start_time
+ *             aio_logger.debug("%r: SSL handshake took %.1f ms", self, dt * 1e3)
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_loop), __pyx_n_s_get_debug); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 530, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 530, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(22, 530, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":531
+ * 
+ *         if self._loop.get_debug():
+ *             dt = self._loop.time() - self._handshake_start_time             # <<<<<<<<<<<<<<
+ *             aio_logger.debug("%r: SSL handshake took %.1f ms", self, dt * 1e3)
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_loop), __pyx_n_s_time); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 531, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 531, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = PyNumber_Subtract(__pyx_t_5, __pyx_v_self->_handshake_start_time); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 531, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_v_dt = __pyx_t_4;
+    __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":532
+ *         if self._loop.get_debug():
+ *             dt = self._loop.time() - self._handshake_start_time
+ *             aio_logger.debug("%r: SSL handshake took %.1f ms", self, dt * 1e3)             # <<<<<<<<<<<<<<
+ * 
+ *         # Add extra info that becomes available after handshake.
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_debug); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 532, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = PyNumber_Multiply(__pyx_v_dt, __pyx_float_1e3); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 532, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_10 = NULL;
+    __pyx_t_13 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_10)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_10);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+        __pyx_t_13 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_5)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_kp_u_r_SSL_handshake_took_1f_ms, ((PyObject *)__pyx_v_self), __pyx_t_3};
+      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_13, 3+__pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 532, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_kp_u_r_SSL_handshake_took_1f_ms, ((PyObject *)__pyx_v_self), __pyx_t_3};
+      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_13, 3+__pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 532, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_21 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_21)) __PYX_ERR(22, 532, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_21);
+      if (__pyx_t_10) {
+        __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_10); __pyx_t_10 = NULL;
+      }
+      __Pyx_INCREF(__pyx_kp_u_r_SSL_handshake_took_1f_ms);
+      __Pyx_GIVEREF(__pyx_kp_u_r_SSL_handshake_took_1f_ms);
+      PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_13, __pyx_kp_u_r_SSL_handshake_took_1f_ms);
+      __Pyx_INCREF(((PyObject *)__pyx_v_self));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+      PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_13, ((PyObject *)__pyx_v_self));
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_21, 2+__pyx_t_13, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_21, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 532, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":530
+ *             return
+ * 
+ *         if self._loop.get_debug():             # <<<<<<<<<<<<<<
+ *             dt = self._loop.time() - self._handshake_start_time
+ *             aio_logger.debug("%r: SSL handshake took %.1f ms", self, dt * 1e3)
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":535
+ * 
+ *         # Add extra info that becomes available after handshake.
+ *         self._extra.update(peercert=peercert,             # <<<<<<<<<<<<<<
+ *                            cipher=sslobj.cipher(),
+ *                            compression=sslobj.compression(),
+ */
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_extra, __pyx_n_s_update); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 535, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 535, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_peercert, __pyx_v_peercert) < 0) __PYX_ERR(22, 535, __pyx_L1_error)
+
+  /* "uvloop/sslproto.pyx":536
+ *         # Add extra info that becomes available after handshake.
+ *         self._extra.update(peercert=peercert,
+ *                            cipher=sslobj.cipher(),             # <<<<<<<<<<<<<<
+ *                            compression=sslobj.compression(),
+ *                            ssl_object=sslobj)
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sslobj, __pyx_n_s_cipher); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 536, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_10 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_10)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_10);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_21 = (__pyx_t_10) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_10) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+  if (unlikely(!__pyx_t_21)) __PYX_ERR(22, 536, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_21);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_cipher, __pyx_t_21) < 0) __PYX_ERR(22, 535, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
+
+  /* "uvloop/sslproto.pyx":537
+ *         self._extra.update(peercert=peercert,
+ *                            cipher=sslobj.cipher(),
+ *                            compression=sslobj.compression(),             # <<<<<<<<<<<<<<
+ *                            ssl_object=sslobj)
+ *         if self._app_state == STATE_INIT:
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sslobj, __pyx_n_s_compression); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 537, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_10 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_10)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_10);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_21 = (__pyx_t_10) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_10) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+  if (unlikely(!__pyx_t_21)) __PYX_ERR(22, 537, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_21);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_compression, __pyx_t_21) < 0) __PYX_ERR(22, 535, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
+
+  /* "uvloop/sslproto.pyx":538
+ *                            cipher=sslobj.cipher(),
+ *                            compression=sslobj.compression(),
+ *                            ssl_object=sslobj)             # <<<<<<<<<<<<<<
+ *         if self._app_state == STATE_INIT:
+ *             self._app_state = STATE_CON_MADE
+ */
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_ssl_object, __pyx_v_sslobj) < 0) __PYX_ERR(22, 535, __pyx_L1_error)
+
+  /* "uvloop/sslproto.pyx":535
+ * 
+ *         # Add extra info that becomes available after handshake.
+ *         self._extra.update(peercert=peercert,             # <<<<<<<<<<<<<<
+ *                            cipher=sslobj.cipher(),
+ *                            compression=sslobj.compression(),
+ */
+  __pyx_t_21 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_21)) __PYX_ERR(22, 535, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_21);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
+
+  /* "uvloop/sslproto.pyx":539
+ *                            compression=sslobj.compression(),
+ *                            ssl_object=sslobj)
+ *         if self._app_state == STATE_INIT:             # <<<<<<<<<<<<<<
+ *             self._app_state = STATE_CON_MADE
+ *             self._app_protocol.connection_made(self._get_app_transport())
+ */
+  __pyx_t_2 = ((__pyx_v_self->_app_state == __pyx_e_6uvloop_4loop_STATE_INIT) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":540
+ *                            ssl_object=sslobj)
+ *         if self._app_state == STATE_INIT:
+ *             self._app_state = STATE_CON_MADE             # <<<<<<<<<<<<<<
+ *             self._app_protocol.connection_made(self._get_app_transport())
+ *         self._wakeup_waiter()
+ */
+    __pyx_v_self->_app_state = __pyx_e_6uvloop_4loop_STATE_CON_MADE;
+
+    /* "uvloop/sslproto.pyx":541
+ *         if self._app_state == STATE_INIT:
+ *             self._app_state = STATE_CON_MADE
+ *             self._app_protocol.connection_made(self._get_app_transport())             # <<<<<<<<<<<<<<
+ *         self._wakeup_waiter()
+ * 
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_app_protocol, __pyx_n_s_connection_made); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 541, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_app_transport); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 541, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_10 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_10)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_10);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_10) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_10) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 541, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_21 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_21)) __PYX_ERR(22, 541, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_21);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
+
+    /* "uvloop/sslproto.pyx":539
+ *                            compression=sslobj.compression(),
+ *                            ssl_object=sslobj)
+ *         if self._app_state == STATE_INIT:             # <<<<<<<<<<<<<<
+ *             self._app_state = STATE_CON_MADE
+ *             self._app_protocol.connection_made(self._get_app_transport())
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":542
+ *             self._app_state = STATE_CON_MADE
+ *             self._app_protocol.connection_made(self._get_app_transport())
+ *         self._wakeup_waiter()             # <<<<<<<<<<<<<<
+ * 
+ *         # We should wakeup user code before sending the first data below. In
+ */
+  __pyx_t_21 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_wakeup_waiter(__pyx_v_self, NULL); if (unlikely(!__pyx_t_21)) __PYX_ERR(22, 542, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_21);
+  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
+
+  /* "uvloop/sslproto.pyx":551
+ *         # before having to handle the first data.
+ *         self._loop._call_soon_handle(
+ *             new_MethodHandle(self._loop,             # <<<<<<<<<<<<<<
+ *                              "SSLProtocol._do_read",
+ *                              <method_t> self._do_read,
+ */
+  __pyx_t_21 = ((PyObject *)__pyx_v_self->_loop);
+  __Pyx_INCREF(__pyx_t_21);
+
+  /* "uvloop/sslproto.pyx":555
+ *                              <method_t> self._do_read,
+ *                              None,  # current context is good
+ *                              self))             # <<<<<<<<<<<<<<
+ * 
+ *     # Shutdown flow
+ */
+  __pyx_t_5 = __pyx_f_6uvloop_4loop_new_MethodHandle(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_21), __pyx_kp_u_SSLProtocol__do_read, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_read), Py_None, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 551, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
+
+  /* "uvloop/sslproto.pyx":551
+ *         # before having to handle the first data.
+ *         self._loop._call_soon_handle(
+ *             new_MethodHandle(self._loop,             # <<<<<<<<<<<<<<
+ *                              "SSLProtocol._do_read",
+ *                              <method_t> self._do_read,
+ */
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(22, 551, __pyx_L1_error)
+
+  /* "uvloop/sslproto.pyx":550
+ *         # that the user get a chance to e.g. check ALPN with the transport
+ *         # before having to handle the first data.
+ *         self._loop._call_soon_handle(             # <<<<<<<<<<<<<<
+ *             new_MethodHandle(self._loop,
+ *                              "SSLProtocol._do_read",
+ */
+  __pyx_t_21 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_self->_loop, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_5)); if (unlikely(!__pyx_t_21)) __PYX_ERR(22, 550, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_21);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
+
+  /* "uvloop/sslproto.pyx":507
+ *             self._on_handshake_complete(None)
+ * 
+ *     cdef _on_handshake_complete(self, handshake_exc):             # <<<<<<<<<<<<<<
+ *         if self._handshake_timeout_handle is not None:
+ *             self._handshake_timeout_handle.cancel()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_21);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._on_handshake_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sslobj);
+  __Pyx_XDECREF(__pyx_v_peercert);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XDECREF(__pyx_v_msg);
+  __Pyx_XDECREF(__pyx_v_dt);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":573
+ *             self._shutdown_timeout_handle = \
+ *                 self._loop.call_later(self._ssl_shutdown_timeout,
+ *                                       lambda: self._check_shutdown_timeout())             # <<<<<<<<<<<<<<
+ *             self._do_flush(context)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_15_start_shutdown_lambda5(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyMethodDef __pyx_mdef_6uvloop_4loop_11SSLProtocol_15_start_shutdown_lambda5 = {"lambda5", (PyCFunction)__pyx_pw_6uvloop_4loop_11SSLProtocol_15_start_shutdown_lambda5, METH_NOARGS, 0};
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_15_start_shutdown_lambda5(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("lambda5 (wrapper)", 0);
+  __pyx_r = __pyx_lambda_funcdef_lambda5(__pyx_self);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_lambda_funcdef_lambda5(PyObject *__pyx_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *__pyx_cur_scope;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *__pyx_outer_scope;
+  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("lambda5", 0);
+  __pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *) __Pyx_CyFunction_GetClosure(__pyx_self);
+  __pyx_cur_scope = __pyx_outer_scope;
+  __Pyx_XDECREF(__pyx_r);
+  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(22, 573, __pyx_L1_error) }
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_check_shutdown_timeout(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 573, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._start_shutdown.lambda5", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":559
+ *     # Shutdown flow
+ * 
+ *     cdef _start_shutdown(self, object context=None):             # <<<<<<<<<<<<<<
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__start_shutdown(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__start_shutdown *__pyx_optional_args) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *__pyx_cur_scope;
+  PyObject *__pyx_v_context = ((PyObject *)Py_None);
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_flush __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_start_shutdown", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_29__start_shutdown(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_29__start_shutdown, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(22, 559, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__pyx_cur_scope);
+  }
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_context = __pyx_optional_args->context;
+    }
+  }
+  __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);
+
+  /* "uvloop/sslproto.pyx":560
+ * 
+ *     cdef _start_shutdown(self, object context=None):
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):             # <<<<<<<<<<<<<<
+ *             return
+ *         # we don't need the context for _abort or the timeout, because
+ */
+  switch (__pyx_cur_scope->__pyx_v_self->_state) {
+    case __pyx_e_6uvloop_4loop_FLUSHING:
+    case __pyx_e_6uvloop_4loop_SHUTDOWN:
+    case __pyx_e_6uvloop_4loop_UNWRAPPED:
+
+    /* "uvloop/sslproto.pyx":561
+ *     cdef _start_shutdown(self, object context=None):
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+ *             return             # <<<<<<<<<<<<<<
+ *         # we don't need the context for _abort or the timeout, because
+ *         # TCP transport._force_close() should be able to call
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/sslproto.pyx":560
+ * 
+ *     cdef _start_shutdown(self, object context=None):
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):             # <<<<<<<<<<<<<<
+ *             return
+ *         # we don't need the context for _abort or the timeout, because
+ */
+    break;
+    default: break;
+  }
+
+  /* "uvloop/sslproto.pyx":565
+ *         # TCP transport._force_close() should be able to call
+ *         # connection_lost() in the right context
+ *         if self._app_transport is not None:             # <<<<<<<<<<<<<<
+ *             self._app_transport._closed = True
+ *         if self._state == DO_HANDSHAKE:
+ */
+  __pyx_t_1 = (((PyObject *)__pyx_cur_scope->__pyx_v_self->_app_transport) != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":566
+ *         # connection_lost() in the right context
+ *         if self._app_transport is not None:
+ *             self._app_transport._closed = True             # <<<<<<<<<<<<<<
+ *         if self._state == DO_HANDSHAKE:
+ *             self._abort(None)
+ */
+    __pyx_cur_scope->__pyx_v_self->_app_transport->_closed = 1;
+
+    /* "uvloop/sslproto.pyx":565
+ *         # TCP transport._force_close() should be able to call
+ *         # connection_lost() in the right context
+ *         if self._app_transport is not None:             # <<<<<<<<<<<<<<
+ *             self._app_transport._closed = True
+ *         if self._state == DO_HANDSHAKE:
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":567
+ *         if self._app_transport is not None:
+ *             self._app_transport._closed = True
+ *         if self._state == DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *             self._abort(None)
+ *         else:
+ */
+  __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_self->_state == __pyx_e_6uvloop_4loop_DO_HANDSHAKE) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":568
+ *             self._app_transport._closed = True
+ *         if self._state == DO_HANDSHAKE:
+ *             self._abort(None)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._set_state(FLUSHING)
+ */
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_abort(__pyx_cur_scope->__pyx_v_self, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 568, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":567
+ *         if self._app_transport is not None:
+ *             self._app_transport._closed = True
+ *         if self._state == DO_HANDSHAKE:             # <<<<<<<<<<<<<<
+ *             self._abort(None)
+ *         else:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/sslproto.pyx":570
+ *             self._abort(None)
+ *         else:
+ *             self._set_state(FLUSHING)             # <<<<<<<<<<<<<<
+ *             self._shutdown_timeout_handle = \
+ *                 self._loop.call_later(self._ssl_shutdown_timeout,
+ */
+  /*else*/ {
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_set_state(__pyx_cur_scope->__pyx_v_self, __pyx_e_6uvloop_4loop_FLUSHING); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 570, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":572
+ *             self._set_state(FLUSHING)
+ *             self._shutdown_timeout_handle = \
+ *                 self._loop.call_later(self._ssl_shutdown_timeout,             # <<<<<<<<<<<<<<
+ *                                       lambda: self._check_shutdown_timeout())
+ *             self._do_flush(context)
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self->_loop), __pyx_n_s_call_later); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 572, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "uvloop/sslproto.pyx":573
+ *             self._shutdown_timeout_handle = \
+ *                 self._loop.call_later(self._ssl_shutdown_timeout,
+ *                                       lambda: self._check_shutdown_timeout())             # <<<<<<<<<<<<<<
+ *             self._do_flush(context)
+ * 
+ */
+    __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_11SSLProtocol_15_start_shutdown_lambda5, 0, __pyx_n_s_SSLProtocol__start_shutdown_loca, ((PyObject*)__pyx_cur_scope), __pyx_n_s_uvloop_loop, __pyx_d, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 573, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = NULL;
+    __pyx_t_7 = 0;
+    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_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_7 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_self->_ssl_shutdown_timeout, __pyx_t_5};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 572, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __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[3] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_self->_ssl_shutdown_timeout, __pyx_t_5};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 572, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(22, 572, __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_cur_scope->__pyx_v_self->_ssl_shutdown_timeout);
+      __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_self->_ssl_shutdown_timeout);
+      PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_cur_scope->__pyx_v_self->_ssl_shutdown_timeout);
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5);
+      __pyx_t_5 = 0;
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 572, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":571
+ *         else:
+ *             self._set_state(FLUSHING)
+ *             self._shutdown_timeout_handle = \             # <<<<<<<<<<<<<<
+ *                 self._loop.call_later(self._ssl_shutdown_timeout,
+ *                                       lambda: self._check_shutdown_timeout())
+ */
+    __Pyx_GIVEREF(__pyx_t_3);
+    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_shutdown_timeout_handle);
+    __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_shutdown_timeout_handle);
+    __pyx_cur_scope->__pyx_v_self->_shutdown_timeout_handle = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":574
+ *                 self._loop.call_later(self._ssl_shutdown_timeout,
+ *                                       lambda: self._check_shutdown_timeout())
+ *             self._do_flush(context)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _check_shutdown_timeout(self):
+ */
+    __pyx_t_9.__pyx_n = 1;
+    __pyx_t_9.context = __pyx_v_context;
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_do_flush(__pyx_cur_scope->__pyx_v_self, &__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 574, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_L4:;
+
+  /* "uvloop/sslproto.pyx":559
+ *     # Shutdown flow
+ * 
+ *     cdef _start_shutdown(self, object context=None):             # <<<<<<<<<<<<<<
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._start_shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":576
+ *             self._do_flush(context)
+ * 
+ *     cdef _check_shutdown_timeout(self):             # <<<<<<<<<<<<<<
+ *         if self._state in (FLUSHING, SHUTDOWN):
+ *             self._transport._force_close(
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__check_shutdown_timeout(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  __Pyx_RefNannySetupContext("_check_shutdown_timeout", 0);
+
+  /* "uvloop/sslproto.pyx":577
+ * 
+ *     cdef _check_shutdown_timeout(self):
+ *         if self._state in (FLUSHING, SHUTDOWN):             # <<<<<<<<<<<<<<
+ *             self._transport._force_close(
+ *                 aio_TimeoutError('SSL shutdown timed out'))
+ */
+  switch (__pyx_v_self->_state) {
+    case __pyx_e_6uvloop_4loop_FLUSHING:
+    case __pyx_e_6uvloop_4loop_SHUTDOWN:
+
+    /* "uvloop/sslproto.pyx":578
+ *     cdef _check_shutdown_timeout(self):
+ *         if self._state in (FLUSHING, SHUTDOWN):
+ *             self._transport._force_close(             # <<<<<<<<<<<<<<
+ *                 aio_TimeoutError('SSL shutdown timed out'))
+ * 
+ */
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_transport, __pyx_n_s_force_close); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 578, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+
+    /* "uvloop/sslproto.pyx":579
+ *         if self._state in (FLUSHING, SHUTDOWN):
+ *             self._transport._force_close(
+ *                 aio_TimeoutError('SSL shutdown timed out'))             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _do_read_into_void(self, object context):
+ */
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_TimeoutError);
+    __pyx_t_4 = __pyx_v_6uvloop_4loop_aio_TimeoutError; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_kp_u_SSL_shutdown_timed_out) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_SSL_shutdown_timed_out);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 579, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_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(22, 578, __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;
+
+    /* "uvloop/sslproto.pyx":577
+ * 
+ *     cdef _check_shutdown_timeout(self):
+ *         if self._state in (FLUSHING, SHUTDOWN):             # <<<<<<<<<<<<<<
+ *             self._transport._force_close(
+ *                 aio_TimeoutError('SSL shutdown timed out'))
+ */
+    break;
+    default: break;
+  }
+
+  /* "uvloop/sslproto.pyx":576
+ *             self._do_flush(context)
+ * 
+ *     cdef _check_shutdown_timeout(self):             # <<<<<<<<<<<<<<
+ *         if self._state in (FLUSHING, SHUTDOWN):
+ *             self._transport._force_close(
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._check_shutdown_timeout", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":581
+ *                 aio_TimeoutError('SSL shutdown timed out'))
+ * 
+ *     cdef _do_read_into_void(self, object context):             # <<<<<<<<<<<<<<
+ *         """Consume and discard incoming application data.
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_read_into_void(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_context) {
+  int __pyx_v_close_notify;
+  CYTHON_UNUSED PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__call_eof_received __pyx_t_10;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_do_read_into_void", 0);
+
+  /* "uvloop/sslproto.pyx":587
+ *         """
+ *         cdef:
+ *             bint close_notify = False             # <<<<<<<<<<<<<<
+ *         try:
+ *             while True:
+ */
+  __pyx_v_close_notify = 0;
+
+  /* "uvloop/sslproto.pyx":588
+ *         cdef:
+ *             bint close_notify = False
+ *         try:             # <<<<<<<<<<<<<<
+ *             while True:
+ *                 if not self._sslobj_read(SSL_READ_MAX_SIZE):
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/sslproto.pyx":589
+ *             bint close_notify = False
+ *         try:
+ *             while True:             # <<<<<<<<<<<<<<
+ *                 if not self._sslobj_read(SSL_READ_MAX_SIZE):
+ *                     close_notify = True
+ */
+      while (1) {
+
+        /* "uvloop/sslproto.pyx":590
+ *         try:
+ *             while True:
+ *                 if not self._sslobj_read(SSL_READ_MAX_SIZE):             # <<<<<<<<<<<<<<
+ *                     close_notify = True
+ *                     break
+ */
+        __Pyx_INCREF(__pyx_v_self->_sslobj_read);
+        __pyx_t_5 = __pyx_v_self->_sslobj_read; __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_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_5, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_int_262144) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_int_262144);
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 590, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(22, 590, __pyx_L3_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_8 = ((!__pyx_t_7) != 0);
+        if (__pyx_t_8) {
+
+          /* "uvloop/sslproto.pyx":591
+ *             while True:
+ *                 if not self._sslobj_read(SSL_READ_MAX_SIZE):
+ *                     close_notify = True             # <<<<<<<<<<<<<<
+ *                     break
+ *         except ssl_SSLAgainErrors as exc:
+ */
+          __pyx_v_close_notify = 1;
+
+          /* "uvloop/sslproto.pyx":592
+ *                 if not self._sslobj_read(SSL_READ_MAX_SIZE):
+ *                     close_notify = True
+ *                     break             # <<<<<<<<<<<<<<
+ *         except ssl_SSLAgainErrors as exc:
+ *             pass
+ */
+          goto __pyx_L10_break;
+
+          /* "uvloop/sslproto.pyx":590
+ *         try:
+ *             while True:
+ *                 if not self._sslobj_read(SSL_READ_MAX_SIZE):             # <<<<<<<<<<<<<<
+ *                     close_notify = True
+ *                     break
+ */
+        }
+      }
+      __pyx_L10_break:;
+
+      /* "uvloop/sslproto.pyx":588
+ *         cdef:
+ *             bint close_notify = False
+ *         try:             # <<<<<<<<<<<<<<
+ *             while True:
+ *                 if not self._sslobj_read(SSL_READ_MAX_SIZE):
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/sslproto.pyx":593
+ *                     close_notify = True
+ *                     break
+ *         except ssl_SSLAgainErrors as exc:             # <<<<<<<<<<<<<<
+ *             pass
+ *         except ssl_SSLZeroReturnError:
+ */
+    __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_ssl_SSLAgainErrors);
+    if (__pyx_t_9) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_read_into_void", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(22, 593, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_v_exc = __pyx_t_5;
+      /*try:*/ {
+      }
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L18;
+        }
+        __pyx_L18:;
+      }
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+
+    /* "uvloop/sslproto.pyx":595
+ *         except ssl_SSLAgainErrors as exc:
+ *             pass
+ *         except ssl_SSLZeroReturnError:             # <<<<<<<<<<<<<<
+ *             close_notify = True
+ *         if close_notify:
+ */
+    __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_ssl_SSLZeroReturnError);
+    if (__pyx_t_9) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_read_into_void", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(22, 595, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/sslproto.pyx":596
+ *             pass
+ *         except ssl_SSLZeroReturnError:
+ *             close_notify = True             # <<<<<<<<<<<<<<
+ *         if close_notify:
+ *             self._call_eof_received(context)
+ */
+      __pyx_v_close_notify = 1;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/sslproto.pyx":588
+ *         cdef:
+ *             bint close_notify = False
+ *         try:             # <<<<<<<<<<<<<<
+ *             while True:
+ *                 if not self._sslobj_read(SSL_READ_MAX_SIZE):
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/sslproto.pyx":597
+ *         except ssl_SSLZeroReturnError:
+ *             close_notify = True
+ *         if close_notify:             # <<<<<<<<<<<<<<
+ *             self._call_eof_received(context)
+ * 
+ */
+  __pyx_t_8 = (__pyx_v_close_notify != 0);
+  if (__pyx_t_8) {
+
+    /* "uvloop/sslproto.pyx":598
+ *             close_notify = True
+ *         if close_notify:
+ *             self._call_eof_received(context)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _do_flush(self, object context=None):
+ */
+    __pyx_t_10.__pyx_n = 1;
+    __pyx_t_10.context = __pyx_v_context;
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_call_eof_received(__pyx_v_self, &__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 598, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":597
+ *         except ssl_SSLZeroReturnError:
+ *             close_notify = True
+ *         if close_notify:             # <<<<<<<<<<<<<<
+ *             self._call_eof_received(context)
+ * 
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":581
+ *                 aio_TimeoutError('SSL shutdown timed out'))
+ * 
+ *     cdef _do_read_into_void(self, object context):             # <<<<<<<<<<<<<<
+ *         """Consume and discard incoming application data.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_read_into_void", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":600
+ *             self._call_eof_received(context)
+ * 
+ *     cdef _do_flush(self, object context=None):             # <<<<<<<<<<<<<<
+ *         """Flush the write backlog, discarding new data received.
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_flush(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_flush *__pyx_optional_args) {
+  PyObject *__pyx_v_context = ((PyObject *)Py_None);
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_shutdown __pyx_t_6;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  char const *__pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_do_flush", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_context = __pyx_optional_args->context;
+    }
+  }
+
+  /* "uvloop/sslproto.pyx":608
+ *         in FLUSHING, as we could fully manage the flow control internally.
+ *         """
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._do_read_into_void(context)
+ *             self._do_write()
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/sslproto.pyx":609
+ *         """
+ *         try:
+ *             self._do_read_into_void(context)             # <<<<<<<<<<<<<<
+ *             self._do_write()
+ *             self._process_outgoing()
+ */
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_read_into_void(__pyx_v_self, __pyx_v_context); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 609, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/sslproto.pyx":610
+ *         try:
+ *             self._do_read_into_void(context)
+ *             self._do_write()             # <<<<<<<<<<<<<<
+ *             self._process_outgoing()
+ *             self._control_ssl_reading()
+ */
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_write(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 610, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/sslproto.pyx":611
+ *             self._do_read_into_void(context)
+ *             self._do_write()
+ *             self._process_outgoing()             # <<<<<<<<<<<<<<
+ *             self._control_ssl_reading()
+ *         except Exception as ex:
+ */
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_process_outgoing(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 611, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/sslproto.pyx":612
+ *             self._do_write()
+ *             self._process_outgoing()
+ *             self._control_ssl_reading()             # <<<<<<<<<<<<<<
+ *         except Exception as ex:
+ *             self._on_shutdown_complete(ex)
+ */
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_control_ssl_reading(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 612, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/sslproto.pyx":608
+ *         in FLUSHING, as we could fully manage the flow control internally.
+ *         """
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._do_read_into_void(context)
+ *             self._do_write()
+ */
+    }
+
+    /* "uvloop/sslproto.pyx":616
+ *             self._on_shutdown_complete(ex)
+ *         else:
+ *             if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *                 self._set_state(SHUTDOWN)
+ *                 self._do_shutdown(context)
+ */
+    /*else:*/ {
+      __pyx_t_5 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_get_write_buffer_size(__pyx_v_self) != 0)) != 0);
+      if (__pyx_t_5) {
+
+        /* "uvloop/sslproto.pyx":617
+ *         else:
+ *             if not self._get_write_buffer_size():
+ *                 self._set_state(SHUTDOWN)             # <<<<<<<<<<<<<<
+ *                 self._do_shutdown(context)
+ * 
+ */
+        __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_6uvloop_4loop_SHUTDOWN); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 617, __pyx_L5_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/sslproto.pyx":618
+ *             if not self._get_write_buffer_size():
+ *                 self._set_state(SHUTDOWN)
+ *                 self._do_shutdown(context)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _do_shutdown(self, object context=None):
+ */
+        __pyx_t_6.__pyx_n = 1;
+        __pyx_t_6.context = __pyx_v_context;
+        __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_shutdown(__pyx_v_self, &__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 618, __pyx_L5_except_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "uvloop/sslproto.pyx":616
+ *             self._on_shutdown_complete(ex)
+ *         else:
+ *             if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *                 self._set_state(SHUTDOWN)
+ *                 self._do_shutdown(context)
+ */
+      }
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":613
+ *             self._process_outgoing()
+ *             self._control_ssl_reading()
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._on_shutdown_complete(ex)
+ *         else:
+ */
+    __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_7) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_flush", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(22, 613, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_INCREF(__pyx_t_8);
+      __pyx_v_ex = __pyx_t_8;
+      /*try:*/ {
+
+        /* "uvloop/sslproto.pyx":614
+ *             self._control_ssl_reading()
+ *         except Exception as ex:
+ *             self._on_shutdown_complete(ex)             # <<<<<<<<<<<<<<
+ *         else:
+ *             if not self._get_write_buffer_size():
+ */
+        __pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_on_shutdown_complete(__pyx_v_self, __pyx_v_ex); if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 614, __pyx_L15_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      }
+
+      /* "uvloop/sslproto.pyx":613
+ *             self._process_outgoing()
+ *             self._control_ssl_reading()
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._on_shutdown_complete(ex)
+ *         else:
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L16;
+        }
+        __pyx_L15_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __pyx_t_7 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+          }
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __pyx_lineno = __pyx_t_7; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12;
+          goto __pyx_L5_except_error;
+        }
+        __pyx_L16:;
+      }
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/sslproto.pyx":608
+ *         in FLUSHING, as we could fully manage the flow control internally.
+ *         """
+ *         try:             # <<<<<<<<<<<<<<
+ *             self._do_read_into_void(context)
+ *             self._do_write()
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/sslproto.pyx":600
+ *             self._call_eof_received(context)
+ * 
+ *     cdef _do_flush(self, object context=None):             # <<<<<<<<<<<<<<
+ *         """Flush the write backlog, discarding new data received.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_flush", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":620
+ *                 self._do_shutdown(context)
+ * 
+ *     cdef _do_shutdown(self, object context=None):             # <<<<<<<<<<<<<<
+ *         """Send close_notify and wait for the same from the peer."""
+ *         try:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_shutdown(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_shutdown *__pyx_optional_args) {
+  PyObject *__pyx_v_context = ((PyObject *)Py_None);
+  CYTHON_UNUSED PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_t_10;
+  int __pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_t_13;
+  char const *__pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  char const *__pyx_t_21;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_do_shutdown", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_context = __pyx_optional_args->context;
+    }
+  }
+
+  /* "uvloop/sslproto.pyx":622
+ *     cdef _do_shutdown(self, object context=None):
+ *         """Send close_notify and wait for the same from the peer."""
+ *         try:             # <<<<<<<<<<<<<<
+ *             # we must skip all application data (if any) before unwrap
+ *             self._do_read_into_void(context)
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/sslproto.pyx":624
+ *         try:
+ *             # we must skip all application data (if any) before unwrap
+ *             self._do_read_into_void(context)             # <<<<<<<<<<<<<<
+ *             try:
+ *                 self._sslobj.unwrap()
+ */
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_read_into_void(__pyx_v_self, __pyx_v_context); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 624, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/sslproto.pyx":625
+ *             # we must skip all application data (if any) before unwrap
+ *             self._do_read_into_void(context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self._sslobj.unwrap()
+ *             except ssl_SSLAgainErrors as exc:
+ */
+      {
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
+        __Pyx_XGOTREF(__pyx_t_5);
+        __Pyx_XGOTREF(__pyx_t_6);
+        __Pyx_XGOTREF(__pyx_t_7);
+        /*try:*/ {
+
+          /* "uvloop/sslproto.pyx":626
+ *             self._do_read_into_void(context)
+ *             try:
+ *                 self._sslobj.unwrap()             # <<<<<<<<<<<<<<
+ *             except ssl_SSLAgainErrors as exc:
+ *                 self._process_outgoing()
+ */
+          __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_sslobj, __pyx_n_s_unwrap); if (unlikely(!__pyx_t_8)) __PYX_ERR(22, 626, __pyx_L9_error)
+          __Pyx_GOTREF(__pyx_t_8);
+          __pyx_t_9 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+            __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+            if (likely(__pyx_t_9)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+              __Pyx_INCREF(__pyx_t_9);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_8, function);
+            }
+          }
+          __pyx_t_4 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_8);
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 626, __pyx_L9_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+          /* "uvloop/sslproto.pyx":625
+ *             # we must skip all application data (if any) before unwrap
+ *             self._do_read_into_void(context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self._sslobj.unwrap()
+ *             except ssl_SSLAgainErrors as exc:
+ */
+        }
+
+        /* "uvloop/sslproto.pyx":630
+ *                 self._process_outgoing()
+ *             else:
+ *                 self._process_outgoing()             # <<<<<<<<<<<<<<
+ *                 if not self._get_write_buffer_size():
+ *                     self._on_shutdown_complete(None)
+ */
+        /*else:*/ {
+          __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_process_outgoing(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 630, __pyx_L11_except_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+          /* "uvloop/sslproto.pyx":631
+ *             else:
+ *                 self._process_outgoing()
+ *                 if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *                     self._on_shutdown_complete(None)
+ *         except Exception as ex:
+ */
+          __pyx_t_10 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_get_write_buffer_size(__pyx_v_self) != 0)) != 0);
+          if (__pyx_t_10) {
+
+            /* "uvloop/sslproto.pyx":632
+ *                 self._process_outgoing()
+ *                 if not self._get_write_buffer_size():
+ *                     self._on_shutdown_complete(None)             # <<<<<<<<<<<<<<
+ *         except Exception as ex:
+ *             self._on_shutdown_complete(ex)
+ */
+            __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_on_shutdown_complete(__pyx_v_self, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 632, __pyx_L11_except_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+            /* "uvloop/sslproto.pyx":631
+ *             else:
+ *                 self._process_outgoing()
+ *                 if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *                     self._on_shutdown_complete(None)
+ *         except Exception as ex:
+ */
+          }
+        }
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L14_try_end;
+        __pyx_L9_error:;
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        /* "uvloop/sslproto.pyx":627
+ *             try:
+ *                 self._sslobj.unwrap()
+ *             except ssl_SSLAgainErrors as exc:             # <<<<<<<<<<<<<<
+ *                 self._process_outgoing()
+ *             else:
+ */
+        __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_ssl_SSLAgainErrors);
+        if (__pyx_t_11) {
+          __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(22, 627, __pyx_L11_except_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_GOTREF(__pyx_t_8);
+          __Pyx_GOTREF(__pyx_t_9);
+          __Pyx_INCREF(__pyx_t_8);
+          __pyx_v_exc = __pyx_t_8;
+          /*try:*/ {
+
+            /* "uvloop/sslproto.pyx":628
+ *                 self._sslobj.unwrap()
+ *             except ssl_SSLAgainErrors as exc:
+ *                 self._process_outgoing()             # <<<<<<<<<<<<<<
+ *             else:
+ *                 self._process_outgoing()
+ */
+            __pyx_t_12 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_process_outgoing(__pyx_v_self); if (unlikely(!__pyx_t_12)) __PYX_ERR(22, 628, __pyx_L21_error)
+            __Pyx_GOTREF(__pyx_t_12);
+            __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+          }
+
+          /* "uvloop/sslproto.pyx":627
+ *             try:
+ *                 self._sslobj.unwrap()
+ *             except ssl_SSLAgainErrors as exc:             # <<<<<<<<<<<<<<
+ *                 self._process_outgoing()
+ *             else:
+ */
+          /*finally:*/ {
+            /*normal exit:*/{
+              __Pyx_DECREF(__pyx_v_exc);
+              __pyx_v_exc = NULL;
+              goto __pyx_L22;
+            }
+            __pyx_L21_error:;
+            /*exception exit:*/{
+              __Pyx_PyThreadState_declare
+              __Pyx_PyThreadState_assign
+              __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+              if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+              if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+              __Pyx_XGOTREF(__pyx_t_15);
+              __Pyx_XGOTREF(__pyx_t_16);
+              __Pyx_XGOTREF(__pyx_t_17);
+              __Pyx_XGOTREF(__pyx_t_18);
+              __Pyx_XGOTREF(__pyx_t_19);
+              __Pyx_XGOTREF(__pyx_t_20);
+              __pyx_t_11 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
+              {
+                __Pyx_DECREF(__pyx_v_exc);
+                __pyx_v_exc = NULL;
+              }
+              if (PY_MAJOR_VERSION >= 3) {
+                __Pyx_XGIVEREF(__pyx_t_18);
+                __Pyx_XGIVEREF(__pyx_t_19);
+                __Pyx_XGIVEREF(__pyx_t_20);
+                __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+              }
+              __Pyx_XGIVEREF(__pyx_t_15);
+              __Pyx_XGIVEREF(__pyx_t_16);
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+              __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+              __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
+              goto __pyx_L11_except_error;
+            }
+            __pyx_L22:;
+          }
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          goto __pyx_L10_exception_handled;
+        }
+        goto __pyx_L11_except_error;
+        __pyx_L11_except_error:;
+
+        /* "uvloop/sslproto.pyx":625
+ *             # we must skip all application data (if any) before unwrap
+ *             self._do_read_into_void(context)
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self._sslobj.unwrap()
+ *             except ssl_SSLAgainErrors as exc:
+ */
+        __Pyx_XGIVEREF(__pyx_t_5);
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+        goto __pyx_L3_error;
+        __pyx_L10_exception_handled:;
+        __Pyx_XGIVEREF(__pyx_t_5);
+        __Pyx_XGIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_7);
+        __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+        __pyx_L14_try_end:;
+      }
+
+      /* "uvloop/sslproto.pyx":622
+ *     cdef _do_shutdown(self, object context=None):
+ *         """Send close_notify and wait for the same from the peer."""
+ *         try:             # <<<<<<<<<<<<<<
+ *             # we must skip all application data (if any) before unwrap
+ *             self._do_read_into_void(context)
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/sslproto.pyx":633
+ *                 if not self._get_write_buffer_size():
+ *                     self._on_shutdown_complete(None)
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._on_shutdown_complete(ex)
+ * 
+ */
+    __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_13) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_8, &__pyx_t_4) < 0) __PYX_ERR(22, 633, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_8);
+      __pyx_v_ex = __pyx_t_8;
+      /*try:*/ {
+
+        /* "uvloop/sslproto.pyx":634
+ *                     self._on_shutdown_complete(None)
+ *         except Exception as ex:
+ *             self._on_shutdown_complete(ex)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_shutdown_complete(self, shutdown_exc):
+ */
+        __pyx_t_12 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_on_shutdown_complete(__pyx_v_self, __pyx_v_ex); if (unlikely(!__pyx_t_12)) __PYX_ERR(22, 634, __pyx_L32_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      }
+
+      /* "uvloop/sslproto.pyx":633
+ *                 if not self._get_write_buffer_size():
+ *                     self._on_shutdown_complete(None)
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._on_shutdown_complete(ex)
+ * 
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L33;
+        }
+        __pyx_L32_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0;
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5);
+          __Pyx_XGOTREF(__pyx_t_7);
+          __Pyx_XGOTREF(__pyx_t_6);
+          __Pyx_XGOTREF(__pyx_t_5);
+          __Pyx_XGOTREF(__pyx_t_20);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __pyx_t_13 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_21 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_19, __pyx_t_18);
+          }
+          __Pyx_XGIVEREF(__pyx_t_7);
+          __Pyx_XGIVEREF(__pyx_t_6);
+          __Pyx_XGIVEREF(__pyx_t_5);
+          __Pyx_ErrRestore(__pyx_t_7, __pyx_t_6, __pyx_t_5);
+          __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0;
+          __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_21;
+          goto __pyx_L5_except_error;
+        }
+        __pyx_L33:;
+      }
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/sslproto.pyx":622
+ *     cdef _do_shutdown(self, object context=None):
+ *         """Send close_notify and wait for the same from the peer."""
+ *         try:             # <<<<<<<<<<<<<<
+ *             # we must skip all application data (if any) before unwrap
+ *             self._do_read_into_void(context)
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/sslproto.pyx":620
+ *                 self._do_shutdown(context)
+ * 
+ *     cdef _do_shutdown(self, object context=None):             # <<<<<<<<<<<<<<
+ *         """Send close_notify and wait for the same from the peer."""
+ *         try:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":636
+ *             self._on_shutdown_complete(ex)
+ * 
+ *     cdef _on_shutdown_complete(self, shutdown_exc):             # <<<<<<<<<<<<<<
+ *         if self._shutdown_timeout_handle is not None:
+ *             self._shutdown_timeout_handle.cancel()
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__on_shutdown_complete(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_shutdown_exc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__fatal_error __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_shutdown_complete", 0);
+
+  /* "uvloop/sslproto.pyx":637
+ * 
+ *     cdef _on_shutdown_complete(self, shutdown_exc):
+ *         if self._shutdown_timeout_handle is not None:             # <<<<<<<<<<<<<<
+ *             self._shutdown_timeout_handle.cancel()
+ *             self._shutdown_timeout_handle = None
+ */
+  __pyx_t_1 = (__pyx_v_self->_shutdown_timeout_handle != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":638
+ *     cdef _on_shutdown_complete(self, shutdown_exc):
+ *         if self._shutdown_timeout_handle is not None:
+ *             self._shutdown_timeout_handle.cancel()             # <<<<<<<<<<<<<<
+ *             self._shutdown_timeout_handle = None
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_shutdown_timeout_handle, __pyx_n_s_cancel); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 638, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 638, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":639
+ *         if self._shutdown_timeout_handle is not None:
+ *             self._shutdown_timeout_handle.cancel()
+ *             self._shutdown_timeout_handle = None             # <<<<<<<<<<<<<<
+ * 
+ *         # we don't need the context here because TCP transport.close() should
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_shutdown_timeout_handle);
+    __Pyx_DECREF(__pyx_v_self->_shutdown_timeout_handle);
+    __pyx_v_self->_shutdown_timeout_handle = Py_None;
+
+    /* "uvloop/sslproto.pyx":637
+ * 
+ *     cdef _on_shutdown_complete(self, shutdown_exc):
+ *         if self._shutdown_timeout_handle is not None:             # <<<<<<<<<<<<<<
+ *             self._shutdown_timeout_handle.cancel()
+ *             self._shutdown_timeout_handle = None
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":643
+ *         # we don't need the context here because TCP transport.close() should
+ *         # be able to call connection_made() in the right context
+ *         if shutdown_exc:             # <<<<<<<<<<<<<<
+ *             self._fatal_error(shutdown_exc, 'Error occurred during shutdown')
+ *         else:
+ */
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_shutdown_exc); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(22, 643, __pyx_L1_error)
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":644
+ *         # be able to call connection_made() in the right context
+ *         if shutdown_exc:
+ *             self._fatal_error(shutdown_exc, 'Error occurred during shutdown')             # <<<<<<<<<<<<<<
+ *         else:
+ *             self._transport.close()
+ */
+    __pyx_t_6.__pyx_n = 1;
+    __pyx_t_6.message = __pyx_kp_u_Error_occurred_during_shutdown;
+    __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_fatal_error(__pyx_v_self, __pyx_v_shutdown_exc, &__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 644, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":643
+ *         # we don't need the context here because TCP transport.close() should
+ *         # be able to call connection_made() in the right context
+ *         if shutdown_exc:             # <<<<<<<<<<<<<<
+ *             self._fatal_error(shutdown_exc, 'Error occurred during shutdown')
+ *         else:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/sslproto.pyx":646
+ *             self._fatal_error(shutdown_exc, 'Error occurred during shutdown')
+ *         else:
+ *             self._transport.close()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _abort(self, exc):
+ */
+  /*else*/ {
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_transport, __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 646, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 646, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_L4:;
+
+  /* "uvloop/sslproto.pyx":636
+ *             self._on_shutdown_complete(ex)
+ * 
+ *     cdef _on_shutdown_complete(self, shutdown_exc):             # <<<<<<<<<<<<<<
+ *         if self._shutdown_timeout_handle is not None:
+ *             self._shutdown_timeout_handle.cancel()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._on_shutdown_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":648
+ *             self._transport.close()
+ * 
+ *     cdef _abort(self, exc):             # <<<<<<<<<<<<<<
+ *         self._set_state(UNWRAPPED)
+ *         if self._transport is not None:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__abort(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_exc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_abort", 0);
+
+  /* "uvloop/sslproto.pyx":649
+ * 
+ *     cdef _abort(self, exc):
+ *         self._set_state(UNWRAPPED)             # <<<<<<<<<<<<<<
+ *         if self._transport is not None:
+ *             self._transport._force_close(exc)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_6uvloop_4loop_UNWRAPPED); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 649, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":650
+ *     cdef _abort(self, exc):
+ *         self._set_state(UNWRAPPED)
+ *         if self._transport is not None:             # <<<<<<<<<<<<<<
+ *             self._transport._force_close(exc)
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_self->_transport != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/sslproto.pyx":651
+ *         self._set_state(UNWRAPPED)
+ *         if self._transport is not None:
+ *             self._transport._force_close(exc)             # <<<<<<<<<<<<<<
+ * 
+ *     # Outgoing flow
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_transport, __pyx_n_s_force_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 651, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_exc);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 651, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":650
+ *     cdef _abort(self, exc):
+ *         self._set_state(UNWRAPPED)
+ *         if self._transport is not None:             # <<<<<<<<<<<<<<
+ *             self._transport._force_close(exc)
+ * 
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":648
+ *             self._transport.close()
+ * 
+ *     cdef _abort(self, exc):             # <<<<<<<<<<<<<<
+ *         self._set_state(UNWRAPPED)
+ *         if self._transport is not None:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._abort", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":655
+ *     # Outgoing flow
+ * 
+ *     cdef _write_appdata(self, list_of_data, object context):             # <<<<<<<<<<<<<<
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__write_appdata(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_list_of_data, PyObject *__pyx_v_context) {
+  PyObject *__pyx_v_data = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  Py_ssize_t __pyx_t_5;
+  PyObject *(*__pyx_t_6)(PyObject *);
+  int __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__control_app_writing __pyx_t_12;
+  int __pyx_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__fatal_error __pyx_t_15;
+  int __pyx_t_16;
+  char const *__pyx_t_17;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  PyObject *__pyx_t_22 = NULL;
+  PyObject *__pyx_t_23 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_write_appdata", 0);
+
+  /* "uvloop/sslproto.pyx":656
+ * 
+ *     cdef _write_appdata(self, list_of_data, object context):
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):             # <<<<<<<<<<<<<<
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+ *                 aio_logger.warning('SSL connection is closed')
+ */
+  switch (__pyx_v_self->_state) {
+    case __pyx_e_6uvloop_4loop_FLUSHING:
+    case __pyx_e_6uvloop_4loop_SHUTDOWN:
+    case __pyx_e_6uvloop_4loop_UNWRAPPED:
+
+    /* "uvloop/sslproto.pyx":657
+ *     cdef _write_appdata(self, list_of_data, object context):
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:             # <<<<<<<<<<<<<<
+ *                 aio_logger.warning('SSL connection is closed')
+ *             self._conn_lost += 1
+ */
+    __pyx_t_1 = ((__pyx_v_self->_conn_lost >= 5) != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/sslproto.pyx":658
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+ *                 aio_logger.warning('SSL connection is closed')             # <<<<<<<<<<<<<<
+ *             self._conn_lost += 1
+ *             return
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_warning); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 658, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_SSL_connection_is_closed) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_SSL_connection_is_closed);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 658, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/sslproto.pyx":657
+ *     cdef _write_appdata(self, list_of_data, object context):
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:             # <<<<<<<<<<<<<<
+ *                 aio_logger.warning('SSL connection is closed')
+ *             self._conn_lost += 1
+ */
+    }
+
+    /* "uvloop/sslproto.pyx":659
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+ *                 aio_logger.warning('SSL connection is closed')
+ *             self._conn_lost += 1             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_v_self->_conn_lost = (__pyx_v_self->_conn_lost + 1);
+
+    /* "uvloop/sslproto.pyx":660
+ *                 aio_logger.warning('SSL connection is closed')
+ *             self._conn_lost += 1
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         for data in list_of_data:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/sslproto.pyx":656
+ * 
+ *     cdef _write_appdata(self, list_of_data, object context):
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):             # <<<<<<<<<<<<<<
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+ *                 aio_logger.warning('SSL connection is closed')
+ */
+    break;
+    default: break;
+  }
+
+  /* "uvloop/sslproto.pyx":662
+ *             return
+ * 
+ *         for data in list_of_data:             # <<<<<<<<<<<<<<
+ *             self._write_backlog.append(data)
+ *             self._write_buffer_size += len(data)
+ */
+  if (likely(PyList_CheckExact(__pyx_v_list_of_data)) || PyTuple_CheckExact(__pyx_v_list_of_data)) {
+    __pyx_t_2 = __pyx_v_list_of_data; __Pyx_INCREF(__pyx_t_2); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+  } else {
+    __pyx_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_list_of_data); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 662, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_6 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 662, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_6)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(22, 662, __pyx_L1_error)
+        #else
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 662, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        #endif
+      } else {
+        if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(22, 662, __pyx_L1_error)
+        #else
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 662, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        #endif
+      }
+    } else {
+      __pyx_t_3 = __pyx_t_6(__pyx_t_2);
+      if (unlikely(!__pyx_t_3)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(22, 662, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_3);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_data, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":663
+ * 
+ *         for data in list_of_data:
+ *             self._write_backlog.append(data)             # <<<<<<<<<<<<<<
+ *             self._write_buffer_size += len(data)
+ * 
+ */
+    __pyx_t_7 = __Pyx_PyObject_Append(__pyx_v_self->_write_backlog, __pyx_v_data); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(22, 663, __pyx_L1_error)
+
+    /* "uvloop/sslproto.pyx":664
+ *         for data in list_of_data:
+ *             self._write_backlog.append(data)
+ *             self._write_buffer_size += len(data)             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+    __pyx_t_8 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(22, 664, __pyx_L1_error)
+    __pyx_v_self->_write_buffer_size = (__pyx_v_self->_write_buffer_size + __pyx_t_8);
+
+    /* "uvloop/sslproto.pyx":662
+ *             return
+ * 
+ *         for data in list_of_data:             # <<<<<<<<<<<<<<
+ *             self._write_backlog.append(data)
+ *             self._write_buffer_size += len(data)
+ */
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/sslproto.pyx":666
+ *             self._write_buffer_size += len(data)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self._state == WRAPPED:
+ *                 self._do_write()
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+    __Pyx_XGOTREF(__pyx_t_9);
+    __Pyx_XGOTREF(__pyx_t_10);
+    __Pyx_XGOTREF(__pyx_t_11);
+    /*try:*/ {
+
+      /* "uvloop/sslproto.pyx":667
+ * 
+ *         try:
+ *             if self._state == WRAPPED:             # <<<<<<<<<<<<<<
+ *                 self._do_write()
+ *                 self._process_outgoing()
+ */
+      __pyx_t_1 = ((__pyx_v_self->_state == __pyx_e_6uvloop_4loop_WRAPPED) != 0);
+      if (__pyx_t_1) {
+
+        /* "uvloop/sslproto.pyx":668
+ *         try:
+ *             if self._state == WRAPPED:
+ *                 self._do_write()             # <<<<<<<<<<<<<<
+ *                 self._process_outgoing()
+ *                 self._control_app_writing(context)
+ */
+        __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_write(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 668, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/sslproto.pyx":669
+ *             if self._state == WRAPPED:
+ *                 self._do_write()
+ *                 self._process_outgoing()             # <<<<<<<<<<<<<<
+ *                 self._control_app_writing(context)
+ * 
+ */
+        __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_process_outgoing(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 669, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/sslproto.pyx":670
+ *                 self._do_write()
+ *                 self._process_outgoing()
+ *                 self._control_app_writing(context)             # <<<<<<<<<<<<<<
+ * 
+ *         except Exception as ex:
+ */
+        __pyx_t_12.__pyx_n = 1;
+        __pyx_t_12.context = __pyx_v_context;
+        __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_control_app_writing(__pyx_v_self, &__pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 670, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+        /* "uvloop/sslproto.pyx":667
+ * 
+ *         try:
+ *             if self._state == WRAPPED:             # <<<<<<<<<<<<<<
+ *                 self._do_write()
+ *                 self._process_outgoing()
+ */
+      }
+
+      /* "uvloop/sslproto.pyx":666
+ *             self._write_buffer_size += len(data)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self._state == WRAPPED:
+ *                 self._do_write()
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+    goto __pyx_L11_try_end;
+    __pyx_L6_error:;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":672
+ *                 self._control_app_writing(context)
+ * 
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._fatal_error(ex, 'Fatal error on SSL protocol')
+ * 
+ */
+    __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_13) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._write_appdata", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4) < 0) __PYX_ERR(22, 672, __pyx_L8_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_3);
+      __pyx_v_ex = __pyx_t_3;
+      /*try:*/ {
+
+        /* "uvloop/sslproto.pyx":673
+ * 
+ *         except Exception as ex:
+ *             self._fatal_error(ex, 'Fatal error on SSL protocol')             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _do_write(self):
+ */
+        __pyx_t_15.__pyx_n = 1;
+        __pyx_t_15.message = __pyx_kp_u_Fatal_error_on_SSL_protocol;
+        __pyx_t_14 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_fatal_error(__pyx_v_self, __pyx_v_ex, &__pyx_t_15); if (unlikely(!__pyx_t_14)) __PYX_ERR(22, 673, __pyx_L18_error)
+        __Pyx_GOTREF(__pyx_t_14);
+        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+      }
+
+      /* "uvloop/sslproto.pyx":672
+ *                 self._control_app_writing(context)
+ * 
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._fatal_error(ex, 'Fatal error on SSL protocol')
+ * 
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L19;
+        }
+        __pyx_L18_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0;
+          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_19);
+          __Pyx_XGOTREF(__pyx_t_20);
+          __Pyx_XGOTREF(__pyx_t_21);
+          __Pyx_XGOTREF(__pyx_t_22);
+          __Pyx_XGOTREF(__pyx_t_23);
+          __pyx_t_13 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_21);
+            __Pyx_XGIVEREF(__pyx_t_22);
+            __Pyx_XGIVEREF(__pyx_t_23);
+            __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_22, __pyx_t_23);
+          }
+          __Pyx_XGIVEREF(__pyx_t_18);
+          __Pyx_XGIVEREF(__pyx_t_19);
+          __Pyx_XGIVEREF(__pyx_t_20);
+          __Pyx_ErrRestore(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+          __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0;
+          __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17;
+          goto __pyx_L8_except_error;
+        }
+        __pyx_L19:;
+      }
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L7_exception_handled;
+    }
+    goto __pyx_L8_except_error;
+    __pyx_L8_except_error:;
+
+    /* "uvloop/sslproto.pyx":666
+ *             self._write_buffer_size += len(data)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self._state == WRAPPED:
+ *                 self._do_write()
+ */
+    __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);
+    goto __pyx_L1_error;
+    __pyx_L7_exception_handled:;
+    __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_L11_try_end:;
+  }
+
+  /* "uvloop/sslproto.pyx":655
+ *     # Outgoing flow
+ * 
+ *     cdef _write_appdata(self, list_of_data, object context):             # <<<<<<<<<<<<<<
+ *         if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._write_appdata", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":675
+ *             self._fatal_error(ex, 'Fatal error on SSL protocol')
+ * 
+ *     cdef _do_write(self):             # <<<<<<<<<<<<<<
+ *         """Do SSL write, consumes write backlog and fills outgoing BIO."""
+ *         cdef size_t data_len, count
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_write(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  size_t __pyx_v_data_len;
+  size_t __pyx_v_count;
+  PyObject *__pyx_v_data = NULL;
+  CYTHON_UNUSED PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  size_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  int __pyx_t_10;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_do_write", 0);
+
+  /* "uvloop/sslproto.pyx":678
+ *         """Do SSL write, consumes write backlog and fills outgoing BIO."""
+ *         cdef size_t data_len, count
+ *         try:             # <<<<<<<<<<<<<<
+ *             while self._write_backlog:
+ *                 data = self._write_backlog[0]
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/sslproto.pyx":679
+ *         cdef size_t data_len, count
+ *         try:
+ *             while self._write_backlog:             # <<<<<<<<<<<<<<
+ *                 data = self._write_backlog[0]
+ *                 count = self._sslobj_write(data)
+ */
+      while (1) {
+        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_write_backlog); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(22, 679, __pyx_L3_error)
+        if (!__pyx_t_4) break;
+
+        /* "uvloop/sslproto.pyx":680
+ *         try:
+ *             while self._write_backlog:
+ *                 data = self._write_backlog[0]             # <<<<<<<<<<<<<<
+ *                 count = self._sslobj_write(data)
+ *                 data_len = len(data)
+ */
+        __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_self->_write_backlog, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 680, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_XDECREF_SET(__pyx_v_data, __pyx_t_5);
+        __pyx_t_5 = 0;
+
+        /* "uvloop/sslproto.pyx":681
+ *             while self._write_backlog:
+ *                 data = self._write_backlog[0]
+ *                 count = self._sslobj_write(data)             # <<<<<<<<<<<<<<
+ *                 data_len = len(data)
+ *                 if count < data_len:
+ */
+        __Pyx_INCREF(__pyx_v_self->_sslobj_write);
+        __pyx_t_6 = __pyx_v_self->_sslobj_write; __pyx_t_7 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+          __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+          if (likely(__pyx_t_7)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+            __Pyx_INCREF(__pyx_t_7);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_6, function);
+          }
+        }
+        __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_v_data) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_data);
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 681, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_5); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(22, 681, __pyx_L3_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __pyx_v_count = __pyx_t_8;
+
+        /* "uvloop/sslproto.pyx":682
+ *                 data = self._write_backlog[0]
+ *                 count = self._sslobj_write(data)
+ *                 data_len = len(data)             # <<<<<<<<<<<<<<
+ *                 if count < data_len:
+ *                     if not PyMemoryView_Check(data):
+ */
+        __pyx_t_9 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(22, 682, __pyx_L3_error)
+        __pyx_v_data_len = __pyx_t_9;
+
+        /* "uvloop/sslproto.pyx":683
+ *                 count = self._sslobj_write(data)
+ *                 data_len = len(data)
+ *                 if count < data_len:             # <<<<<<<<<<<<<<
+ *                     if not PyMemoryView_Check(data):
+ *                         data = PyMemoryView_FromObject(data)
+ */
+        __pyx_t_4 = ((__pyx_v_count < __pyx_v_data_len) != 0);
+        if (__pyx_t_4) {
+
+          /* "uvloop/sslproto.pyx":684
+ *                 data_len = len(data)
+ *                 if count < data_len:
+ *                     if not PyMemoryView_Check(data):             # <<<<<<<<<<<<<<
+ *                         data = PyMemoryView_FromObject(data)
+ *                     self._write_backlog[0] = data[count:]
+ */
+          __pyx_t_4 = ((!(PyMemoryView_Check(__pyx_v_data) != 0)) != 0);
+          if (__pyx_t_4) {
+
+            /* "uvloop/sslproto.pyx":685
+ *                 if count < data_len:
+ *                     if not PyMemoryView_Check(data):
+ *                         data = PyMemoryView_FromObject(data)             # <<<<<<<<<<<<<<
+ *                     self._write_backlog[0] = data[count:]
+ *                     self._write_buffer_size -= count
+ */
+            __pyx_t_5 = PyMemoryView_FromObject(__pyx_v_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 685, __pyx_L3_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_DECREF_SET(__pyx_v_data, __pyx_t_5);
+            __pyx_t_5 = 0;
+
+            /* "uvloop/sslproto.pyx":684
+ *                 data_len = len(data)
+ *                 if count < data_len:
+ *                     if not PyMemoryView_Check(data):             # <<<<<<<<<<<<<<
+ *                         data = PyMemoryView_FromObject(data)
+ *                     self._write_backlog[0] = data[count:]
+ */
+          }
+
+          /* "uvloop/sslproto.pyx":686
+ *                     if not PyMemoryView_Check(data):
+ *                         data = PyMemoryView_FromObject(data)
+ *                     self._write_backlog[0] = data[count:]             # <<<<<<<<<<<<<<
+ *                     self._write_buffer_size -= count
+ *                 else:
+ */
+          __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_v_data, __pyx_v_count, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 686, __pyx_L3_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          if (unlikely(__Pyx_SetItemInt(__pyx_v_self->_write_backlog, 0, __pyx_t_5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) __PYX_ERR(22, 686, __pyx_L3_error)
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+          /* "uvloop/sslproto.pyx":687
+ *                         data = PyMemoryView_FromObject(data)
+ *                     self._write_backlog[0] = data[count:]
+ *                     self._write_buffer_size -= count             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     del self._write_backlog[0]
+ */
+          __pyx_v_self->_write_buffer_size = (__pyx_v_self->_write_buffer_size - __pyx_v_count);
+
+          /* "uvloop/sslproto.pyx":683
+ *                 count = self._sslobj_write(data)
+ *                 data_len = len(data)
+ *                 if count < data_len:             # <<<<<<<<<<<<<<
+ *                     if not PyMemoryView_Check(data):
+ *                         data = PyMemoryView_FromObject(data)
+ */
+          goto __pyx_L11;
+        }
+
+        /* "uvloop/sslproto.pyx":689
+ *                     self._write_buffer_size -= count
+ *                 else:
+ *                     del self._write_backlog[0]             # <<<<<<<<<<<<<<
+ *                     self._write_buffer_size -= data_len
+ *         except ssl_SSLAgainErrors as exc:
+ */
+        /*else*/ {
+          if (unlikely(__Pyx_DelItemInt(__pyx_v_self->_write_backlog, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) __PYX_ERR(22, 689, __pyx_L3_error)
+
+          /* "uvloop/sslproto.pyx":690
+ *                 else:
+ *                     del self._write_backlog[0]
+ *                     self._write_buffer_size -= data_len             # <<<<<<<<<<<<<<
+ *         except ssl_SSLAgainErrors as exc:
+ *             pass
+ */
+          __pyx_v_self->_write_buffer_size = (__pyx_v_self->_write_buffer_size - __pyx_v_data_len);
+        }
+        __pyx_L11:;
+      }
+
+      /* "uvloop/sslproto.pyx":678
+ *         """Do SSL write, consumes write backlog and fills outgoing BIO."""
+ *         cdef size_t data_len, count
+ *         try:             # <<<<<<<<<<<<<<
+ *             while self._write_backlog:
+ *                 data = self._write_backlog[0]
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/sslproto.pyx":691
+ *                     del self._write_backlog[0]
+ *                     self._write_buffer_size -= data_len
+ *         except ssl_SSLAgainErrors as exc:             # <<<<<<<<<<<<<<
+ *             pass
+ * 
+ */
+    __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_ssl_SSLAgainErrors);
+    if (__pyx_t_10) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(22, 691, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_v_exc = __pyx_t_6;
+      /*try:*/ {
+      }
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L19;
+        }
+        __pyx_L19:;
+      }
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/sslproto.pyx":678
+ *         """Do SSL write, consumes write backlog and fills outgoing BIO."""
+ *         cdef size_t data_len, count
+ *         try:             # <<<<<<<<<<<<<<
+ *             while self._write_backlog:
+ *                 data = self._write_backlog[0]
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/sslproto.pyx":675
+ *             self._fatal_error(ex, 'Fatal error on SSL protocol')
+ * 
+ *     cdef _do_write(self):             # <<<<<<<<<<<<<<
+ *         """Do SSL write, consumes write backlog and fills outgoing BIO."""
+ *         cdef size_t data_len, count
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":694
+ *             pass
+ * 
+ *     cdef _process_outgoing(self):             # <<<<<<<<<<<<<<
+ *         """Send bytes from the outgoing BIO."""
+ *         if not self._ssl_writing_paused:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__process_outgoing(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  PyObject *__pyx_v_data = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  Py_ssize_t __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_process_outgoing", 0);
+
+  /* "uvloop/sslproto.pyx":696
+ *     cdef _process_outgoing(self):
+ *         """Send bytes from the outgoing BIO."""
+ *         if not self._ssl_writing_paused:             # <<<<<<<<<<<<<<
+ *             data = self._outgoing_read()
+ *             if len(data):
+ */
+  __pyx_t_1 = ((!(__pyx_v_self->_ssl_writing_paused != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":697
+ *         """Send bytes from the outgoing BIO."""
+ *         if not self._ssl_writing_paused:
+ *             data = self._outgoing_read()             # <<<<<<<<<<<<<<
+ *             if len(data):
+ *                 self._transport.write(data)
+ */
+    __Pyx_INCREF(__pyx_v_self->_outgoing_read);
+    __pyx_t_3 = __pyx_v_self->_outgoing_read; __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 697, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_data = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/sslproto.pyx":698
+ *         if not self._ssl_writing_paused:
+ *             data = self._outgoing_read()
+ *             if len(data):             # <<<<<<<<<<<<<<
+ *                 self._transport.write(data)
+ * 
+ */
+    __pyx_t_5 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(22, 698, __pyx_L1_error)
+    __pyx_t_1 = (__pyx_t_5 != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/sslproto.pyx":699
+ *             data = self._outgoing_read()
+ *             if len(data):
+ *                 self._transport.write(data)             # <<<<<<<<<<<<<<
+ * 
+ *     # Incoming flow
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_transport, __pyx_n_s_write); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 699, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_data) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_data);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 699, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/sslproto.pyx":698
+ *         if not self._ssl_writing_paused:
+ *             data = self._outgoing_read()
+ *             if len(data):             # <<<<<<<<<<<<<<
+ *                 self._transport.write(data)
+ * 
+ */
+    }
+
+    /* "uvloop/sslproto.pyx":696
+ *     cdef _process_outgoing(self):
+ *         """Send bytes from the outgoing BIO."""
+ *         if not self._ssl_writing_paused:             # <<<<<<<<<<<<<<
+ *             data = self._outgoing_read()
+ *             if len(data):
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":694
+ *             pass
+ * 
+ *     cdef _process_outgoing(self):             # <<<<<<<<<<<<<<
+ *         """Send bytes from the outgoing BIO."""
+ *         if not self._ssl_writing_paused:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._process_outgoing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":703
+ *     # Incoming flow
+ * 
+ *     cdef _do_read(self):             # <<<<<<<<<<<<<<
+ *         if self._state != WRAPPED:
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_read(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __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;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__fatal_error __pyx_t_10;
+  int __pyx_t_11;
+  char const *__pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_do_read", 0);
+
+  /* "uvloop/sslproto.pyx":704
+ * 
+ *     cdef _do_read(self):
+ *         if self._state != WRAPPED:             # <<<<<<<<<<<<<<
+ *             return
+ *         try:
+ */
+  __pyx_t_1 = ((__pyx_v_self->_state != __pyx_e_6uvloop_4loop_WRAPPED) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":705
+ *     cdef _do_read(self):
+ *         if self._state != WRAPPED:
+ *             return             # <<<<<<<<<<<<<<
+ *         try:
+ *             if not self._app_reading_paused:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/sslproto.pyx":704
+ * 
+ *     cdef _do_read(self):
+ *         if self._state != WRAPPED:             # <<<<<<<<<<<<<<
+ *             return
+ *         try:
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":706
+ *         if self._state != WRAPPED:
+ *             return
+ *         try:             # <<<<<<<<<<<<<<
+ *             if not self._app_reading_paused:
+ *                 if self._app_protocol_is_buffer:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "uvloop/sslproto.pyx":707
+ *             return
+ *         try:
+ *             if not self._app_reading_paused:             # <<<<<<<<<<<<<<
+ *                 if self._app_protocol_is_buffer:
+ *                     self._do_read__buffered()
+ */
+      __pyx_t_1 = ((!(__pyx_v_self->_app_reading_paused != 0)) != 0);
+      if (__pyx_t_1) {
+
+        /* "uvloop/sslproto.pyx":708
+ *         try:
+ *             if not self._app_reading_paused:
+ *                 if self._app_protocol_is_buffer:             # <<<<<<<<<<<<<<
+ *                     self._do_read__buffered()
+ *                 else:
+ */
+        __pyx_t_1 = (__pyx_v_self->_app_protocol_is_buffer != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/sslproto.pyx":709
+ *             if not self._app_reading_paused:
+ *                 if self._app_protocol_is_buffer:
+ *                     self._do_read__buffered()             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     self._do_read__copied()
+ */
+          __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_read__buffered(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 709, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+          /* "uvloop/sslproto.pyx":708
+ *         try:
+ *             if not self._app_reading_paused:
+ *                 if self._app_protocol_is_buffer:             # <<<<<<<<<<<<<<
+ *                     self._do_read__buffered()
+ *                 else:
+ */
+          goto __pyx_L11;
+        }
+
+        /* "uvloop/sslproto.pyx":711
+ *                     self._do_read__buffered()
+ *                 else:
+ *                     self._do_read__copied()             # <<<<<<<<<<<<<<
+ *                 if self._write_backlog:
+ *                     self._do_write()
+ */
+        /*else*/ {
+          __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_read__copied(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 711, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        }
+        __pyx_L11:;
+
+        /* "uvloop/sslproto.pyx":712
+ *                 else:
+ *                     self._do_read__copied()
+ *                 if self._write_backlog:             # <<<<<<<<<<<<<<
+ *                     self._do_write()
+ *                 self._process_outgoing()
+ */
+        __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_write_backlog); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(22, 712, __pyx_L4_error)
+        if (__pyx_t_1) {
+
+          /* "uvloop/sslproto.pyx":713
+ *                     self._do_read__copied()
+ *                 if self._write_backlog:
+ *                     self._do_write()             # <<<<<<<<<<<<<<
+ *                 self._process_outgoing()
+ *                 self._control_app_writing()
+ */
+          __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_write(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 713, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+          /* "uvloop/sslproto.pyx":712
+ *                 else:
+ *                     self._do_read__copied()
+ *                 if self._write_backlog:             # <<<<<<<<<<<<<<
+ *                     self._do_write()
+ *                 self._process_outgoing()
+ */
+        }
+
+        /* "uvloop/sslproto.pyx":714
+ *                 if self._write_backlog:
+ *                     self._do_write()
+ *                 self._process_outgoing()             # <<<<<<<<<<<<<<
+ *                 self._control_app_writing()
+ *             self._control_ssl_reading()
+ */
+        __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_process_outgoing(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 714, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/sslproto.pyx":715
+ *                     self._do_write()
+ *                 self._process_outgoing()
+ *                 self._control_app_writing()             # <<<<<<<<<<<<<<
+ *             self._control_ssl_reading()
+ *         except Exception as ex:
+ */
+        __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_control_app_writing(__pyx_v_self, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 715, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+        /* "uvloop/sslproto.pyx":707
+ *             return
+ *         try:
+ *             if not self._app_reading_paused:             # <<<<<<<<<<<<<<
+ *                 if self._app_protocol_is_buffer:
+ *                     self._do_read__buffered()
+ */
+      }
+
+      /* "uvloop/sslproto.pyx":716
+ *                 self._process_outgoing()
+ *                 self._control_app_writing()
+ *             self._control_ssl_reading()             # <<<<<<<<<<<<<<
+ *         except Exception as ex:
+ *             self._fatal_error(ex, 'Fatal error on SSL protocol')
+ */
+      __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_control_ssl_reading(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 716, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+      /* "uvloop/sslproto.pyx":706
+ *         if self._state != WRAPPED:
+ *             return
+ *         try:             # <<<<<<<<<<<<<<
+ *             if not self._app_reading_paused:
+ *                 if self._app_protocol_is_buffer:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L9_try_end;
+    __pyx_L4_error:;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/sslproto.pyx":717
+ *                 self._control_app_writing()
+ *             self._control_ssl_reading()
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._fatal_error(ex, 'Fatal error on SSL protocol')
+ * 
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_read", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(22, 717, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_7);
+      __pyx_v_ex = __pyx_t_7;
+      /*try:*/ {
+
+        /* "uvloop/sslproto.pyx":718
+ *             self._control_ssl_reading()
+ *         except Exception as ex:
+ *             self._fatal_error(ex, 'Fatal error on SSL protocol')             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _do_read__buffered(self):
+ */
+        __pyx_t_10.__pyx_n = 1;
+        __pyx_t_10.message = __pyx_kp_u_Fatal_error_on_SSL_protocol;
+        __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_fatal_error(__pyx_v_self, __pyx_v_ex, &__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(22, 718, __pyx_L18_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      }
+
+      /* "uvloop/sslproto.pyx":717
+ *                 self._control_app_writing()
+ *             self._control_ssl_reading()
+ *         except Exception as ex:             # <<<<<<<<<<<<<<
+ *             self._fatal_error(ex, 'Fatal error on SSL protocol')
+ * 
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_ex);
+          __pyx_v_ex = NULL;
+          goto __pyx_L19;
+        }
+        __pyx_L18_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __pyx_t_6 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+          }
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12;
+          goto __pyx_L6_except_error;
+        }
+        __pyx_L19:;
+      }
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      goto __pyx_L5_exception_handled;
+    }
+    goto __pyx_L6_except_error;
+    __pyx_L6_except_error:;
+
+    /* "uvloop/sslproto.pyx":706
+ *         if self._state != WRAPPED:
+ *             return
+ *         try:             # <<<<<<<<<<<<<<
+ *             if not self._app_reading_paused:
+ *                 if self._app_protocol_is_buffer:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L5_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    __pyx_L9_try_end:;
+  }
+
+  /* "uvloop/sslproto.pyx":703
+ *     # Incoming flow
+ * 
+ *     cdef _do_read(self):             # <<<<<<<<<<<<<<
+ *         if self._state != WRAPPED:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_read", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":720
+ *             self._fatal_error(ex, 'Fatal error on SSL protocol')
+ * 
+ *     cdef _do_read__buffered(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             Py_buffer pybuf
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_read__buffered(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  Py_buffer __pyx_v_pybuf;
+  int __pyx_v_pybuf_inited;
+  size_t __pyx_v_wants;
+  size_t __pyx_v_offset;
+  int __pyx_v_count;
+  PyObject *__pyx_v_buf = 0;
+  CYTHON_UNUSED PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  Py_ssize_t __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  int __pyx_t_12;
+  char const *__pyx_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_do_read__buffered", 0);
+
+  /* "uvloop/sslproto.pyx":723
+ *         cdef:
+ *             Py_buffer pybuf
+ *             bint pybuf_inited = False             # <<<<<<<<<<<<<<
+ *             size_t wants, offset = 0
+ *             int count = 1
+ */
+  __pyx_v_pybuf_inited = 0;
+
+  /* "uvloop/sslproto.pyx":724
+ *             Py_buffer pybuf
+ *             bint pybuf_inited = False
+ *             size_t wants, offset = 0             # <<<<<<<<<<<<<<
+ *             int count = 1
+ *             object buf
+ */
+  __pyx_v_offset = 0;
+
+  /* "uvloop/sslproto.pyx":725
+ *             bint pybuf_inited = False
+ *             size_t wants, offset = 0
+ *             int count = 1             # <<<<<<<<<<<<<<
+ *             object buf
+ * 
+ */
+  __pyx_v_count = 1;
+
+  /* "uvloop/sslproto.pyx":728
+ *             object buf
+ * 
+ *         buf = self._app_protocol_get_buffer(self._get_read_buffer_size())             # <<<<<<<<<<<<<<
+ *         wants = len(buf)
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_FromSize_t(((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_get_read_buffer_size(__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 728, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_self->_app_protocol_get_buffer);
+  __pyx_t_3 = __pyx_v_self->_app_protocol_get_buffer; __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 728, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_buf = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/sslproto.pyx":729
+ * 
+ *         buf = self._app_protocol_get_buffer(self._get_read_buffer_size())
+ *         wants = len(buf)             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_t_5 = PyObject_Length(__pyx_v_buf); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(22, 729, __pyx_L1_error)
+  __pyx_v_wants = __pyx_t_5;
+
+  /* "uvloop/sslproto.pyx":731
+ *         wants = len(buf)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             count = self._sslobj_read(wants, buf)
+ * 
+ */
+  /*try:*/ {
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
+      /*try:*/ {
+
+        /* "uvloop/sslproto.pyx":732
+ * 
+ *         try:
+ *             count = self._sslobj_read(wants, buf)             # <<<<<<<<<<<<<<
+ * 
+ *             if count > 0:
+ */
+        __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_wants); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 732, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_INCREF(__pyx_v_self->_sslobj_read);
+        __pyx_t_2 = __pyx_v_self->_sslobj_read; __pyx_t_4 = NULL;
+        __pyx_t_9 = 0;
+        if (CYTHON_UNPACK_METHODS && 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_9 = 1;
+          }
+        }
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_2)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_buf};
+          __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 732, __pyx_L6_error)
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_buf};
+          __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 732, __pyx_L6_error)
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        } else
+        #endif
+        {
+          __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 732, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          if (__pyx_t_4) {
+            __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_4); __pyx_t_4 = NULL;
+          }
+          __Pyx_GIVEREF(__pyx_t_3);
+          PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_3);
+          __Pyx_INCREF(__pyx_v_buf);
+          __Pyx_GIVEREF(__pyx_v_buf);
+          PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_v_buf);
+          __pyx_t_3 = 0;
+          __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 732, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(22, 732, __pyx_L6_error)
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __pyx_v_count = __pyx_t_9;
+
+        /* "uvloop/sslproto.pyx":734
+ *             count = self._sslobj_read(wants, buf)
+ * 
+ *             if count > 0:             # <<<<<<<<<<<<<<
+ *                 offset = count
+ *                 if offset < wants:
+ */
+        __pyx_t_11 = ((__pyx_v_count > 0) != 0);
+        if (__pyx_t_11) {
+
+          /* "uvloop/sslproto.pyx":735
+ * 
+ *             if count > 0:
+ *                 offset = count             # <<<<<<<<<<<<<<
+ *                 if offset < wants:
+ *                     PyObject_GetBuffer(buf, &pybuf, PyBUF_WRITABLE)
+ */
+          __pyx_v_offset = __pyx_v_count;
+
+          /* "uvloop/sslproto.pyx":736
+ *             if count > 0:
+ *                 offset = count
+ *                 if offset < wants:             # <<<<<<<<<<<<<<
+ *                     PyObject_GetBuffer(buf, &pybuf, PyBUF_WRITABLE)
+ *                     pybuf_inited = True
+ */
+          __pyx_t_11 = ((__pyx_v_offset < __pyx_v_wants) != 0);
+          if (__pyx_t_11) {
+
+            /* "uvloop/sslproto.pyx":737
+ *                 offset = count
+ *                 if offset < wants:
+ *                     PyObject_GetBuffer(buf, &pybuf, PyBUF_WRITABLE)             # <<<<<<<<<<<<<<
+ *                     pybuf_inited = True
+ *                 while offset < wants:
+ */
+            __pyx_t_9 = PyObject_GetBuffer(__pyx_v_buf, (&__pyx_v_pybuf), PyBUF_WRITABLE); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(22, 737, __pyx_L6_error)
+
+            /* "uvloop/sslproto.pyx":738
+ *                 if offset < wants:
+ *                     PyObject_GetBuffer(buf, &pybuf, PyBUF_WRITABLE)
+ *                     pybuf_inited = True             # <<<<<<<<<<<<<<
+ *                 while offset < wants:
+ *                     buf = PyMemoryView_FromMemory(
+ */
+            __pyx_v_pybuf_inited = 1;
+
+            /* "uvloop/sslproto.pyx":736
+ *             if count > 0:
+ *                 offset = count
+ *                 if offset < wants:             # <<<<<<<<<<<<<<
+ *                     PyObject_GetBuffer(buf, &pybuf, PyBUF_WRITABLE)
+ *                     pybuf_inited = True
+ */
+          }
+
+          /* "uvloop/sslproto.pyx":739
+ *                     PyObject_GetBuffer(buf, &pybuf, PyBUF_WRITABLE)
+ *                     pybuf_inited = True
+ *                 while offset < wants:             # <<<<<<<<<<<<<<
+ *                     buf = PyMemoryView_FromMemory(
+ *                         (<char*>pybuf.buf) + offset,
+ */
+          while (1) {
+            __pyx_t_11 = ((__pyx_v_offset < __pyx_v_wants) != 0);
+            if (!__pyx_t_11) break;
+
+            /* "uvloop/sslproto.pyx":740
+ *                     pybuf_inited = True
+ *                 while offset < wants:
+ *                     buf = PyMemoryView_FromMemory(             # <<<<<<<<<<<<<<
+ *                         (<char*>pybuf.buf) + offset,
+ *                         wants - offset,
+ */
+            __pyx_t_1 = PyMemoryView_FromMemory((((char *)__pyx_v_pybuf.buf) + __pyx_v_offset), (__pyx_v_wants - __pyx_v_offset), PyBUF_WRITE); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 740, __pyx_L6_error)
+            __Pyx_GOTREF(__pyx_t_1);
+            __Pyx_DECREF_SET(__pyx_v_buf, __pyx_t_1);
+            __pyx_t_1 = 0;
+
+            /* "uvloop/sslproto.pyx":744
+ *                         wants - offset,
+ *                         PyBUF_WRITE)
+ *                     count = self._sslobj_read(wants - offset, buf)             # <<<<<<<<<<<<<<
+ *                     if count > 0:
+ *                         offset += count
+ */
+            __pyx_t_2 = __Pyx_PyInt_FromSize_t((__pyx_v_wants - __pyx_v_offset)); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 744, __pyx_L6_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __Pyx_INCREF(__pyx_v_self->_sslobj_read);
+            __pyx_t_10 = __pyx_v_self->_sslobj_read; __pyx_t_3 = NULL;
+            __pyx_t_9 = 0;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
+              __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_10);
+              if (likely(__pyx_t_3)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+                __Pyx_INCREF(__pyx_t_3);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_10, function);
+                __pyx_t_9 = 1;
+              }
+            }
+            #if CYTHON_FAST_PYCALL
+            if (PyFunction_Check(__pyx_t_10)) {
+              PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_v_buf};
+              __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 744, __pyx_L6_error)
+              __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __Pyx_GOTREF(__pyx_t_1);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            } else
+            #endif
+            #if CYTHON_FAST_PYCCALL
+            if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) {
+              PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_v_buf};
+              __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 744, __pyx_L6_error)
+              __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __Pyx_GOTREF(__pyx_t_1);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            } else
+            #endif
+            {
+              __pyx_t_4 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 744, __pyx_L6_error)
+              __Pyx_GOTREF(__pyx_t_4);
+              if (__pyx_t_3) {
+                __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
+              }
+              __Pyx_GIVEREF(__pyx_t_2);
+              PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_9, __pyx_t_2);
+              __Pyx_INCREF(__pyx_v_buf);
+              __Pyx_GIVEREF(__pyx_v_buf);
+              PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_9, __pyx_v_buf);
+              __pyx_t_2 = 0;
+              __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 744, __pyx_L6_error)
+              __Pyx_GOTREF(__pyx_t_1);
+              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            }
+            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(22, 744, __pyx_L6_error)
+            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+            __pyx_v_count = __pyx_t_9;
+
+            /* "uvloop/sslproto.pyx":745
+ *                         PyBUF_WRITE)
+ *                     count = self._sslobj_read(wants - offset, buf)
+ *                     if count > 0:             # <<<<<<<<<<<<<<
+ *                         offset += count
+ *                     else:
+ */
+            __pyx_t_11 = ((__pyx_v_count > 0) != 0);
+            if (__pyx_t_11) {
+
+              /* "uvloop/sslproto.pyx":746
+ *                     count = self._sslobj_read(wants - offset, buf)
+ *                     if count > 0:
+ *                         offset += count             # <<<<<<<<<<<<<<
+ *                     else:
+ *                         break
+ */
+              __pyx_v_offset = (__pyx_v_offset + __pyx_v_count);
+
+              /* "uvloop/sslproto.pyx":745
+ *                         PyBUF_WRITE)
+ *                     count = self._sslobj_read(wants - offset, buf)
+ *                     if count > 0:             # <<<<<<<<<<<<<<
+ *                         offset += count
+ *                     else:
+ */
+              goto __pyx_L16;
+            }
+
+            /* "uvloop/sslproto.pyx":748
+ *                         offset += count
+ *                     else:
+ *                         break             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     self._loop._call_soon_handle(
+ */
+            /*else*/ {
+              goto __pyx_L15_break;
+            }
+            __pyx_L16:;
+          }
+
+          /* "uvloop/sslproto.pyx":750
+ *                         break
+ *                 else:
+ *                     self._loop._call_soon_handle(             # <<<<<<<<<<<<<<
+ *                         new_MethodHandle(self._loop,
+ *                                          "SSLProtocol._do_read",
+ */
+          /*else*/ {
+
+            /* "uvloop/sslproto.pyx":751
+ *                 else:
+ *                     self._loop._call_soon_handle(
+ *                         new_MethodHandle(self._loop,             # <<<<<<<<<<<<<<
+ *                                          "SSLProtocol._do_read",
+ *                                          <method_t>self._do_read,
+ */
+            __pyx_t_1 = ((PyObject *)__pyx_v_self->_loop);
+            __Pyx_INCREF(__pyx_t_1);
+
+            /* "uvloop/sslproto.pyx":755
+ *                                          <method_t>self._do_read,
+ *                                          None,  # current context is good
+ *                                          self))             # <<<<<<<<<<<<<<
+ *         except ssl_SSLAgainErrors as exc:
+ *             pass
+ */
+            __pyx_t_10 = __pyx_f_6uvloop_4loop_new_MethodHandle(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_1), __pyx_kp_u_SSLProtocol__do_read, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_read), Py_None, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 751, __pyx_L6_error)
+            __Pyx_GOTREF(__pyx_t_10);
+            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+            /* "uvloop/sslproto.pyx":751
+ *                 else:
+ *                     self._loop._call_soon_handle(
+ *                         new_MethodHandle(self._loop,             # <<<<<<<<<<<<<<
+ *                                          "SSLProtocol._do_read",
+ *                                          <method_t>self._do_read,
+ */
+            if (!(likely(((__pyx_t_10) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_10, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(22, 751, __pyx_L6_error)
+
+            /* "uvloop/sslproto.pyx":750
+ *                         break
+ *                 else:
+ *                     self._loop._call_soon_handle(             # <<<<<<<<<<<<<<
+ *                         new_MethodHandle(self._loop,
+ *                                          "SSLProtocol._do_read",
+ */
+            __pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_self->_loop, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 750, __pyx_L6_error)
+            __Pyx_GOTREF(__pyx_t_1);
+            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          }
+          __pyx_L15_break:;
+
+          /* "uvloop/sslproto.pyx":734
+ *             count = self._sslobj_read(wants, buf)
+ * 
+ *             if count > 0:             # <<<<<<<<<<<<<<
+ *                 offset = count
+ *                 if offset < wants:
+ */
+        }
+
+        /* "uvloop/sslproto.pyx":731
+ *         wants = len(buf)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             count = self._sslobj_read(wants, buf)
+ * 
+ */
+      }
+      __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;
+      goto __pyx_L11_try_end;
+      __pyx_L6_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/sslproto.pyx":756
+ *                                          None,  # current context is good
+ *                                          self))
+ *         except ssl_SSLAgainErrors as exc:             # <<<<<<<<<<<<<<
+ *             pass
+ *         finally:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_ssl_SSLAgainErrors);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_read__buffered", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_10, &__pyx_t_4) < 0) __PYX_ERR(22, 756, __pyx_L8_except_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_10);
+        __pyx_v_exc = __pyx_t_10;
+        /*try:*/ {
+        }
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+            goto __pyx_L23;
+          }
+          __pyx_L23:;
+        }
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        goto __pyx_L7_exception_handled;
+      }
+      goto __pyx_L8_except_error;
+      __pyx_L8_except_error:;
+
+      /* "uvloop/sslproto.pyx":731
+ *         wants = len(buf)
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             count = self._sslobj_read(wants, buf)
+ * 
+ */
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      goto __pyx_L4_error;
+      __pyx_L7_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      __pyx_L11_try_end:;
+    }
+  }
+
+  /* "uvloop/sslproto.pyx":759
+ *             pass
+ *         finally:
+ *             if pybuf_inited:             # <<<<<<<<<<<<<<
+ *                 PyBuffer_Release(&pybuf)
+ *         if offset > 0:
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_11 = (__pyx_v_pybuf_inited != 0);
+      if (__pyx_t_11) {
+
+        /* "uvloop/sslproto.pyx":760
+ *         finally:
+ *             if pybuf_inited:
+ *                 PyBuffer_Release(&pybuf)             # <<<<<<<<<<<<<<
+ *         if offset > 0:
+ *             self._app_protocol_buffer_updated(offset)
+ */
+        PyBuffer_Release((&__pyx_v_pybuf));
+
+        /* "uvloop/sslproto.pyx":759
+ *             pass
+ *         finally:
+ *             if pybuf_inited:             # <<<<<<<<<<<<<<
+ *                 PyBuffer_Release(&pybuf)
+ *         if offset > 0:
+ */
+      }
+      goto __pyx_L5;
+    }
+    __pyx_L4_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0)) __Pyx_ErrFetch(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __Pyx_XGOTREF(__pyx_t_15);
+      __Pyx_XGOTREF(__pyx_t_16);
+      __pyx_t_9 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename;
+      {
+        __pyx_t_11 = (__pyx_v_pybuf_inited != 0);
+        if (__pyx_t_11) {
+
+          /* "uvloop/sslproto.pyx":760
+ *         finally:
+ *             if pybuf_inited:
+ *                 PyBuffer_Release(&pybuf)             # <<<<<<<<<<<<<<
+ *         if offset > 0:
+ *             self._app_protocol_buffer_updated(offset)
+ */
+          PyBuffer_Release((&__pyx_v_pybuf));
+
+          /* "uvloop/sslproto.pyx":759
+ *             pass
+ *         finally:
+ *             if pybuf_inited:             # <<<<<<<<<<<<<<
+ *                 PyBuffer_Release(&pybuf)
+ *         if offset > 0:
+ */
+        }
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_XGIVEREF(__pyx_t_15);
+        __Pyx_XGIVEREF(__pyx_t_16);
+        __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+      }
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ErrRestore(__pyx_t_8, __pyx_t_7, __pyx_t_6);
+      __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
+      __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13;
+      goto __pyx_L1_error;
+    }
+    __pyx_L5:;
+  }
+
+  /* "uvloop/sslproto.pyx":761
+ *             if pybuf_inited:
+ *                 PyBuffer_Release(&pybuf)
+ *         if offset > 0:             # <<<<<<<<<<<<<<
+ *             self._app_protocol_buffer_updated(offset)
+ *         if not count:
+ */
+  __pyx_t_11 = ((__pyx_v_offset > 0) != 0);
+  if (__pyx_t_11) {
+
+    /* "uvloop/sslproto.pyx":762
+ *                 PyBuffer_Release(&pybuf)
+ *         if offset > 0:
+ *             self._app_protocol_buffer_updated(offset)             # <<<<<<<<<<<<<<
+ *         if not count:
+ *             # close_notify
+ */
+    __pyx_t_10 = __Pyx_PyInt_FromSize_t(__pyx_v_offset); if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 762, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __Pyx_INCREF(__pyx_v_self->_app_protocol_buffer_updated);
+    __pyx_t_1 = __pyx_v_self->_app_protocol_buffer_updated; __pyx_t_2 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_10) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_10);
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 762, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":761
+ *             if pybuf_inited:
+ *                 PyBuffer_Release(&pybuf)
+ *         if offset > 0:             # <<<<<<<<<<<<<<
+ *             self._app_protocol_buffer_updated(offset)
+ *         if not count:
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":763
+ *         if offset > 0:
+ *             self._app_protocol_buffer_updated(offset)
+ *         if not count:             # <<<<<<<<<<<<<<
+ *             # close_notify
+ *             self._call_eof_received()
+ */
+  __pyx_t_11 = ((!(__pyx_v_count != 0)) != 0);
+  if (__pyx_t_11) {
+
+    /* "uvloop/sslproto.pyx":765
+ *         if not count:
+ *             # close_notify
+ *             self._call_eof_received()             # <<<<<<<<<<<<<<
+ *             self._start_shutdown()
+ * 
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_call_eof_received(__pyx_v_self, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 765, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":766
+ *             # close_notify
+ *             self._call_eof_received()
+ *             self._start_shutdown()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _do_read__copied(self):
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_start_shutdown(__pyx_v_self, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 766, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/sslproto.pyx":763
+ *         if offset > 0:
+ *             self._app_protocol_buffer_updated(offset)
+ *         if not count:             # <<<<<<<<<<<<<<
+ *             # close_notify
+ *             self._call_eof_received()
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":720
+ *             self._fatal_error(ex, 'Fatal error on SSL protocol')
+ * 
+ *     cdef _do_read__buffered(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             Py_buffer pybuf
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_10);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_read__buffered", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_buf);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":768
+ *             self._start_shutdown()
+ * 
+ *     cdef _do_read__copied(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             list data
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__do_read__copied(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  PyObject *__pyx_v_data = 0;
+  PyObject *__pyx_v_first = 0;
+  PyObject *__pyx_v_chunk = 0;
+  int __pyx_v_zero;
+  int __pyx_v_one;
+  CYTHON_UNUSED PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_do_read__copied", 0);
+
+  /* "uvloop/sslproto.pyx":771
+ *         cdef:
+ *             list data
+ *             bytes first, chunk = b'1'             # <<<<<<<<<<<<<<
+ *             bint zero = True, one = False
+ * 
+ */
+  __Pyx_INCREF(__pyx_kp_b_1);
+  __pyx_v_chunk = __pyx_kp_b_1;
+
+  /* "uvloop/sslproto.pyx":772
+ *             list data
+ *             bytes first, chunk = b'1'
+ *             bint zero = True, one = False             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_v_zero = 1;
+  __pyx_v_one = 0;
+
+  /* "uvloop/sslproto.pyx":774
+ *             bint zero = True, one = False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             while True:
+ *                 chunk = self._sslobj_read(SSL_READ_MAX_SIZE)
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "uvloop/sslproto.pyx":775
+ * 
+ *         try:
+ *             while True:             # <<<<<<<<<<<<<<
+ *                 chunk = self._sslobj_read(SSL_READ_MAX_SIZE)
+ *                 if not chunk:
+ */
+      while (1) {
+
+        /* "uvloop/sslproto.pyx":776
+ *         try:
+ *             while True:
+ *                 chunk = self._sslobj_read(SSL_READ_MAX_SIZE)             # <<<<<<<<<<<<<<
+ *                 if not chunk:
+ *                     break
+ */
+        __Pyx_INCREF(__pyx_v_self->_sslobj_read);
+        __pyx_t_5 = __pyx_v_self->_sslobj_read; __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_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_5, function);
+          }
+        }
+        __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_int_262144) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_int_262144);
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 776, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(22, 776, __pyx_L3_error)
+        __Pyx_DECREF_SET(__pyx_v_chunk, ((PyObject*)__pyx_t_4));
+        __pyx_t_4 = 0;
+
+        /* "uvloop/sslproto.pyx":777
+ *             while True:
+ *                 chunk = self._sslobj_read(SSL_READ_MAX_SIZE)
+ *                 if not chunk:             # <<<<<<<<<<<<<<
+ *                     break
+ *                 if zero:
+ */
+        __pyx_t_7 = (__pyx_v_chunk != Py_None)&&(PyBytes_GET_SIZE(__pyx_v_chunk) != 0);
+        __pyx_t_8 = ((!__pyx_t_7) != 0);
+        if (__pyx_t_8) {
+
+          /* "uvloop/sslproto.pyx":778
+ *                 chunk = self._sslobj_read(SSL_READ_MAX_SIZE)
+ *                 if not chunk:
+ *                     break             # <<<<<<<<<<<<<<
+ *                 if zero:
+ *                     zero = False
+ */
+          goto __pyx_L10_break;
+
+          /* "uvloop/sslproto.pyx":777
+ *             while True:
+ *                 chunk = self._sslobj_read(SSL_READ_MAX_SIZE)
+ *                 if not chunk:             # <<<<<<<<<<<<<<
+ *                     break
+ *                 if zero:
+ */
+        }
+
+        /* "uvloop/sslproto.pyx":779
+ *                 if not chunk:
+ *                     break
+ *                 if zero:             # <<<<<<<<<<<<<<
+ *                     zero = False
+ *                     one = True
+ */
+        __pyx_t_8 = (__pyx_v_zero != 0);
+        if (__pyx_t_8) {
+
+          /* "uvloop/sslproto.pyx":780
+ *                     break
+ *                 if zero:
+ *                     zero = False             # <<<<<<<<<<<<<<
+ *                     one = True
+ *                     first = chunk
+ */
+          __pyx_v_zero = 0;
+
+          /* "uvloop/sslproto.pyx":781
+ *                 if zero:
+ *                     zero = False
+ *                     one = True             # <<<<<<<<<<<<<<
+ *                     first = chunk
+ *                 elif one:
+ */
+          __pyx_v_one = 1;
+
+          /* "uvloop/sslproto.pyx":782
+ *                     zero = False
+ *                     one = True
+ *                     first = chunk             # <<<<<<<<<<<<<<
+ *                 elif one:
+ *                     one = False
+ */
+          __Pyx_INCREF(__pyx_v_chunk);
+          __Pyx_XDECREF_SET(__pyx_v_first, __pyx_v_chunk);
+
+          /* "uvloop/sslproto.pyx":779
+ *                 if not chunk:
+ *                     break
+ *                 if zero:             # <<<<<<<<<<<<<<
+ *                     zero = False
+ *                     one = True
+ */
+          goto __pyx_L12;
+        }
+
+        /* "uvloop/sslproto.pyx":783
+ *                     one = True
+ *                     first = chunk
+ *                 elif one:             # <<<<<<<<<<<<<<
+ *                     one = False
+ *                     data = [first, chunk]
+ */
+        __pyx_t_8 = (__pyx_v_one != 0);
+        if (__pyx_t_8) {
+
+          /* "uvloop/sslproto.pyx":784
+ *                     first = chunk
+ *                 elif one:
+ *                     one = False             # <<<<<<<<<<<<<<
+ *                     data = [first, chunk]
+ *                 else:
+ */
+          __pyx_v_one = 0;
+
+          /* "uvloop/sslproto.pyx":785
+ *                 elif one:
+ *                     one = False
+ *                     data = [first, chunk]             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     data.append(chunk)
+ */
+          if (unlikely(!__pyx_v_first)) { __Pyx_RaiseUnboundLocalError("first"); __PYX_ERR(22, 785, __pyx_L3_error) }
+          __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 785, __pyx_L3_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_INCREF(__pyx_v_first);
+          __Pyx_GIVEREF(__pyx_v_first);
+          PyList_SET_ITEM(__pyx_t_4, 0, __pyx_v_first);
+          __Pyx_INCREF(__pyx_v_chunk);
+          __Pyx_GIVEREF(__pyx_v_chunk);
+          PyList_SET_ITEM(__pyx_t_4, 1, __pyx_v_chunk);
+          __Pyx_XDECREF_SET(__pyx_v_data, ((PyObject*)__pyx_t_4));
+          __pyx_t_4 = 0;
+
+          /* "uvloop/sslproto.pyx":783
+ *                     one = True
+ *                     first = chunk
+ *                 elif one:             # <<<<<<<<<<<<<<
+ *                     one = False
+ *                     data = [first, chunk]
+ */
+          goto __pyx_L12;
+        }
+
+        /* "uvloop/sslproto.pyx":787
+ *                     data = [first, chunk]
+ *                 else:
+ *                     data.append(chunk)             # <<<<<<<<<<<<<<
+ *         except ssl_SSLAgainErrors as exc:
+ *             pass
+ */
+        /*else*/ {
+          if (unlikely(!__pyx_v_data)) { __Pyx_RaiseUnboundLocalError("data"); __PYX_ERR(22, 787, __pyx_L3_error) }
+          __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_data, __pyx_v_chunk); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(22, 787, __pyx_L3_error)
+        }
+        __pyx_L12:;
+      }
+      __pyx_L10_break:;
+
+      /* "uvloop/sslproto.pyx":774
+ *             bint zero = True, one = False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             while True:
+ *                 chunk = self._sslobj_read(SSL_READ_MAX_SIZE)
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/sslproto.pyx":788
+ *                 else:
+ *                     data.append(chunk)
+ *         except ssl_SSLAgainErrors as exc:             # <<<<<<<<<<<<<<
+ *             pass
+ *         if one:
+ */
+    __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_v_6uvloop_4loop_ssl_SSLAgainErrors);
+    if (__pyx_t_10) {
+      __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_read__copied", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(22, 788, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_v_exc = __pyx_t_5;
+      /*try:*/ {
+      }
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L19;
+        }
+        __pyx_L19:;
+      }
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L4_exception_handled;
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "uvloop/sslproto.pyx":774
+ *             bint zero = True, one = False
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             while True:
+ *                 chunk = self._sslobj_read(SSL_READ_MAX_SIZE)
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L4_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    __pyx_L8_try_end:;
+  }
+
+  /* "uvloop/sslproto.pyx":790
+ *         except ssl_SSLAgainErrors as exc:
+ *             pass
+ *         if one:             # <<<<<<<<<<<<<<
+ *             self._app_protocol.data_received(first)
+ *         elif not zero:
+ */
+  __pyx_t_8 = (__pyx_v_one != 0);
+  if (__pyx_t_8) {
+
+    /* "uvloop/sslproto.pyx":791
+ *             pass
+ *         if one:
+ *             self._app_protocol.data_received(first)             # <<<<<<<<<<<<<<
+ *         elif not zero:
+ *             self._app_protocol.data_received(b''.join(data))
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_app_protocol, __pyx_n_s_data_received); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 791, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(!__pyx_v_first)) { __Pyx_RaiseUnboundLocalError("first"); __PYX_ERR(22, 791, __pyx_L1_error) }
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_v_first) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_first);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 791, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/sslproto.pyx":790
+ *         except ssl_SSLAgainErrors as exc:
+ *             pass
+ *         if one:             # <<<<<<<<<<<<<<
+ *             self._app_protocol.data_received(first)
+ *         elif not zero:
+ */
+    goto __pyx_L20;
+  }
+
+  /* "uvloop/sslproto.pyx":792
+ *         if one:
+ *             self._app_protocol.data_received(first)
+ *         elif not zero:             # <<<<<<<<<<<<<<
+ *             self._app_protocol.data_received(b''.join(data))
+ *         if not chunk:
+ */
+  __pyx_t_8 = ((!(__pyx_v_zero != 0)) != 0);
+  if (__pyx_t_8) {
+
+    /* "uvloop/sslproto.pyx":793
+ *             self._app_protocol.data_received(first)
+ *         elif not zero:
+ *             self._app_protocol.data_received(b''.join(data))             # <<<<<<<<<<<<<<
+ *         if not chunk:
+ *             # close_notify
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_app_protocol, __pyx_n_s_data_received); if (unlikely(!__pyx_t_5)) __PYX_ERR(22, 793, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(!__pyx_v_data)) { __Pyx_RaiseUnboundLocalError("data"); __PYX_ERR(22, 793, __pyx_L1_error) }
+    __pyx_t_4 = __Pyx_PyBytes_Join(__pyx_kp_b__8, __pyx_v_data); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 793, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_11 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_11)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_11);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_6 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_11, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 793, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/sslproto.pyx":792
+ *         if one:
+ *             self._app_protocol.data_received(first)
+ *         elif not zero:             # <<<<<<<<<<<<<<
+ *             self._app_protocol.data_received(b''.join(data))
+ *         if not chunk:
+ */
+  }
+  __pyx_L20:;
+
+  /* "uvloop/sslproto.pyx":794
+ *         elif not zero:
+ *             self._app_protocol.data_received(b''.join(data))
+ *         if not chunk:             # <<<<<<<<<<<<<<
+ *             # close_notify
+ *             self._call_eof_received()
+ */
+  __pyx_t_8 = (__pyx_v_chunk != Py_None)&&(PyBytes_GET_SIZE(__pyx_v_chunk) != 0);
+  __pyx_t_7 = ((!__pyx_t_8) != 0);
+  if (__pyx_t_7) {
+
+    /* "uvloop/sslproto.pyx":796
+ *         if not chunk:
+ *             # close_notify
+ *             self._call_eof_received()             # <<<<<<<<<<<<<<
+ *             self._start_shutdown()
+ * 
+ */
+    __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_call_eof_received(__pyx_v_self, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 796, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/sslproto.pyx":797
+ *             # close_notify
+ *             self._call_eof_received()
+ *             self._start_shutdown()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _call_eof_received(self, object context=None):
+ */
+    __pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_start_shutdown(__pyx_v_self, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 797, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/sslproto.pyx":794
+ *         elif not zero:
+ *             self._app_protocol.data_received(b''.join(data))
+ *         if not chunk:             # <<<<<<<<<<<<<<
+ *             # close_notify
+ *             self._call_eof_received()
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":768
+ *             self._start_shutdown()
+ * 
+ *     cdef _do_read__copied(self):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             list data
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._do_read__copied", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XDECREF(__pyx_v_first);
+  __Pyx_XDECREF(__pyx_v_chunk);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":799
+ *             self._start_shutdown()
+ * 
+ *     cdef _call_eof_received(self, object context=None):             # <<<<<<<<<<<<<<
+ *         if self._app_state == STATE_CON_MADE:
+ *             self._app_state = STATE_EOF
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__call_eof_received(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__call_eof_received *__pyx_optional_args) {
+  PyObject *__pyx_v_context = ((PyObject *)Py_None);
+  PyObject *__pyx_v_keep_open = NULL;
+  PyObject *__pyx_v_ex = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__fatal_error __pyx_t_11;
+  int __pyx_t_12;
+  char const *__pyx_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_call_eof_received", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_context = __pyx_optional_args->context;
+    }
+  }
+
+  /* "uvloop/sslproto.pyx":800
+ * 
+ *     cdef _call_eof_received(self, object context=None):
+ *         if self._app_state == STATE_CON_MADE:             # <<<<<<<<<<<<<<
+ *             self._app_state = STATE_EOF
+ *             try:
+ */
+  __pyx_t_1 = ((__pyx_v_self->_app_state == __pyx_e_6uvloop_4loop_STATE_CON_MADE) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":801
+ *     cdef _call_eof_received(self, object context=None):
+ *         if self._app_state == STATE_CON_MADE:
+ *             self._app_state = STATE_EOF             # <<<<<<<<<<<<<<
+ *             try:
+ *                 if context is None:
+ */
+    __pyx_v_self->_app_state = __pyx_e_6uvloop_4loop_STATE_EOF;
+
+    /* "uvloop/sslproto.pyx":802
+ *         if self._app_state == STATE_CON_MADE:
+ *             self._app_state = STATE_EOF
+ *             try:             # <<<<<<<<<<<<<<
+ *                 if context is None:
+ *                     # If the caller didn't provide a context, we assume the
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_2);
+      __Pyx_XGOTREF(__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_4);
+      /*try:*/ {
+
+        /* "uvloop/sslproto.pyx":803
+ *             self._app_state = STATE_EOF
+ *             try:
+ *                 if context is None:             # <<<<<<<<<<<<<<
+ *                     # If the caller didn't provide a context, we assume the
+ *                     # caller is already in the right context, which is usually
+ */
+        __pyx_t_1 = (__pyx_v_context == Py_None);
+        __pyx_t_5 = (__pyx_t_1 != 0);
+        if (__pyx_t_5) {
+
+          /* "uvloop/sslproto.pyx":807
+ *                     # caller is already in the right context, which is usually
+ *                     # inside the upstream callbacks like buffer_updated()
+ *                     keep_open = self._app_protocol.eof_received()             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     keep_open = run_in_context(
+ */
+          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_app_protocol, __pyx_n_s_eof_received); if (unlikely(!__pyx_t_7)) __PYX_ERR(22, 807, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __pyx_t_8 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+            __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+            if (likely(__pyx_t_8)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+              __Pyx_INCREF(__pyx_t_8);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_7, function);
+            }
+          }
+          __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 807, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __pyx_v_keep_open = __pyx_t_6;
+          __pyx_t_6 = 0;
+
+          /* "uvloop/sslproto.pyx":803
+ *             self._app_state = STATE_EOF
+ *             try:
+ *                 if context is None:             # <<<<<<<<<<<<<<
+ *                     # If the caller didn't provide a context, we assume the
+ *                     # caller is already in the right context, which is usually
+ */
+          goto __pyx_L10;
+        }
+
+        /* "uvloop/sslproto.pyx":809
+ *                     keep_open = self._app_protocol.eof_received()
+ *                 else:
+ *                     keep_open = run_in_context(             # <<<<<<<<<<<<<<
+ *                         context, self._app_protocol.eof_received,
+ *                     )
+ */
+        /*else*/ {
+
+          /* "uvloop/sslproto.pyx":810
+ *                 else:
+ *                     keep_open = run_in_context(
+ *                         context, self._app_protocol.eof_received,             # <<<<<<<<<<<<<<
+ *                     )
+ *             except (KeyboardInterrupt, SystemExit):
+ */
+          __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_app_protocol, __pyx_n_s_eof_received); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 810, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_6);
+
+          /* "uvloop/sslproto.pyx":809
+ *                     keep_open = self._app_protocol.eof_received()
+ *                 else:
+ *                     keep_open = run_in_context(             # <<<<<<<<<<<<<<
+ *                         context, self._app_protocol.eof_received,
+ *                     )
+ */
+          __pyx_t_7 = __pyx_f_6uvloop_4loop_run_in_context(__pyx_v_context, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(22, 809, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __pyx_v_keep_open = __pyx_t_7;
+          __pyx_t_7 = 0;
+        }
+        __pyx_L10:;
+
+        /* "uvloop/sslproto.pyx":802
+ *         if self._app_state == STATE_CON_MADE:
+ *             self._app_state = STATE_EOF
+ *             try:             # <<<<<<<<<<<<<<
+ *                 if context is None:
+ *                     # If the caller didn't provide a context, we assume the
+ */
+      }
+
+      /* "uvloop/sslproto.pyx":817
+ *                 self._fatal_error(ex, 'Error calling eof_received()')
+ *             else:
+ *                 if keep_open:             # <<<<<<<<<<<<<<
+ *                     aio_logger.warning('returning true from eof_received() '
+ *                                        'has no effect when using ssl')
+ */
+      /*else:*/ {
+        __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_keep_open); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(22, 817, __pyx_L6_except_error)
+        if (__pyx_t_5) {
+
+          /* "uvloop/sslproto.pyx":818
+ *             else:
+ *                 if keep_open:
+ *                     aio_logger.warning('returning true from eof_received() '             # <<<<<<<<<<<<<<
+ *                                        'has no effect when using ssl')
+ * 
+ */
+          __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_warning); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 818, __pyx_L6_except_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __pyx_t_8 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(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_6, function);
+            }
+          }
+          __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_kp_u_returning_true_from_eof_received) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_returning_true_from_eof_received);
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (unlikely(!__pyx_t_7)) __PYX_ERR(22, 818, __pyx_L6_except_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+          /* "uvloop/sslproto.pyx":817
+ *                 self._fatal_error(ex, 'Error calling eof_received()')
+ *             else:
+ *                 if keep_open:             # <<<<<<<<<<<<<<
+ *                     aio_logger.warning('returning true from eof_received() '
+ *                                        'has no effect when using ssl')
+ */
+        }
+      }
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L9_try_end;
+      __pyx_L4_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;
+
+      /* "uvloop/sslproto.pyx":812
+ *                         context, self._app_protocol.eof_received,
+ *                     )
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException as ex:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.SSLProtocol._call_eof_received", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_8) < 0) __PYX_ERR(22, 812, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_8);
+
+        /* "uvloop/sslproto.pyx":813
+ *                     )
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException as ex:
+ *                 self._fatal_error(ex, 'Error calling eof_received()')
+ */
+        __Pyx_GIVEREF(__pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_6, __pyx_t_8);
+        __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_8 = 0; 
+        __PYX_ERR(22, 813, __pyx_L6_except_error)
+      }
+
+      /* "uvloop/sslproto.pyx":814
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(ex, 'Error calling eof_received()')
+ *             else:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.SSLProtocol._call_eof_received", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(22, 814, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_6);
+        __pyx_v_ex = __pyx_t_6;
+        /*try:*/ {
+
+          /* "uvloop/sslproto.pyx":815
+ *                 raise
+ *             except BaseException as ex:
+ *                 self._fatal_error(ex, 'Error calling eof_received()')             # <<<<<<<<<<<<<<
+ *             else:
+ *                 if keep_open:
+ */
+          __pyx_t_11.__pyx_n = 1;
+          __pyx_t_11.message = __pyx_kp_u_Error_calling_eof_received;
+          __pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_fatal_error(__pyx_v_self, __pyx_v_ex, &__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 815, __pyx_L19_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        }
+
+        /* "uvloop/sslproto.pyx":814
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as ex:             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(ex, 'Error calling eof_received()')
+ *             else:
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_ex);
+            __pyx_v_ex = NULL;
+            goto __pyx_L20;
+          }
+          __pyx_L19_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_14);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __pyx_t_9 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_ex);
+              __pyx_v_ex = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19);
+            }
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16);
+            __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
+            __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13;
+            goto __pyx_L6_except_error;
+          }
+          __pyx_L20:;
+        }
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L5_exception_handled;
+      }
+      goto __pyx_L6_except_error;
+      __pyx_L6_except_error:;
+
+      /* "uvloop/sslproto.pyx":802
+ *         if self._app_state == STATE_CON_MADE:
+ *             self._app_state = STATE_EOF
+ *             try:             # <<<<<<<<<<<<<<
+ *                 if context is None:
+ *                     # If the caller didn't provide a context, we assume the
+ */
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+      goto __pyx_L1_error;
+      __pyx_L5_exception_handled:;
+      __Pyx_XGIVEREF(__pyx_t_2);
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+      __pyx_L9_try_end:;
+    }
+
+    /* "uvloop/sslproto.pyx":800
+ * 
+ *     cdef _call_eof_received(self, object context=None):
+ *         if self._app_state == STATE_CON_MADE:             # <<<<<<<<<<<<<<
+ *             self._app_state = STATE_EOF
+ *             try:
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":799
+ *             self._start_shutdown()
+ * 
+ *     cdef _call_eof_received(self, object context=None):             # <<<<<<<<<<<<<<
+ *         if self._app_state == STATE_CON_MADE:
+ *             self._app_state = STATE_EOF
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._call_eof_received", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_keep_open);
+  __Pyx_XDECREF(__pyx_v_ex);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":823
+ *     # Flow control for writes from APP socket
+ * 
+ *     cdef _control_app_writing(self, object context=None):             # <<<<<<<<<<<<<<
+ *         cdef size_t size = self._get_write_buffer_size()
+ *         if size >= self._outgoing_high_water and not self._app_writing_paused:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__control_app_writing(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__control_app_writing *__pyx_optional_args) {
+  PyObject *__pyx_v_context = ((PyObject *)Py_None);
+  size_t __pyx_v_size;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_t_14;
+  char const *__pyx_t_15;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  char const *__pyx_t_22;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_control_app_writing", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_context = __pyx_optional_args->context;
+    }
+  }
+
+  /* "uvloop/sslproto.pyx":824
+ * 
+ *     cdef _control_app_writing(self, object context=None):
+ *         cdef size_t size = self._get_write_buffer_size()             # <<<<<<<<<<<<<<
+ *         if size >= self._outgoing_high_water and not self._app_writing_paused:
+ *             self._app_writing_paused = True
+ */
+  __pyx_v_size = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_get_write_buffer_size(__pyx_v_self);
+
+  /* "uvloop/sslproto.pyx":825
+ *     cdef _control_app_writing(self, object context=None):
+ *         cdef size_t size = self._get_write_buffer_size()
+ *         if size >= self._outgoing_high_water and not self._app_writing_paused:             # <<<<<<<<<<<<<<
+ *             self._app_writing_paused = True
+ *             try:
+ */
+  __pyx_t_2 = ((__pyx_v_size >= __pyx_v_self->_outgoing_high_water) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = ((!(__pyx_v_self->_app_writing_paused != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":826
+ *         cdef size_t size = self._get_write_buffer_size()
+ *         if size >= self._outgoing_high_water and not self._app_writing_paused:
+ *             self._app_writing_paused = True             # <<<<<<<<<<<<<<
+ *             try:
+ *                 if context is None:
+ */
+    __pyx_v_self->_app_writing_paused = 1;
+
+    /* "uvloop/sslproto.pyx":827
+ *         if size >= self._outgoing_high_water and not self._app_writing_paused:
+ *             self._app_writing_paused = True
+ *             try:             # <<<<<<<<<<<<<<
+ *                 if context is None:
+ *                     # If the caller didn't provide a context, we assume the
+ */
+    {
+      __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:*/ {
+
+        /* "uvloop/sslproto.pyx":828
+ *             self._app_writing_paused = True
+ *             try:
+ *                 if context is None:             # <<<<<<<<<<<<<<
+ *                     # If the caller didn't provide a context, we assume the
+ *                     # caller is already in the right context, which is usually
+ */
+        __pyx_t_1 = (__pyx_v_context == Py_None);
+        __pyx_t_2 = (__pyx_t_1 != 0);
+        if (__pyx_t_2) {
+
+          /* "uvloop/sslproto.pyx":832
+ *                     # caller is already in the right context, which is usually
+ *                     # inside the upstream callbacks like buffer_updated()
+ *                     self._app_protocol.pause_writing()             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     run_in_context(context, self._app_protocol.pause_writing)
+ */
+          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_app_protocol, __pyx_n_s_pause_writing); if (unlikely(!__pyx_t_7)) __PYX_ERR(22, 832, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __pyx_t_8 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+            __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+            if (likely(__pyx_t_8)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+              __Pyx_INCREF(__pyx_t_8);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_7, function);
+            }
+          }
+          __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_7);
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 832, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+          /* "uvloop/sslproto.pyx":828
+ *             self._app_writing_paused = True
+ *             try:
+ *                 if context is None:             # <<<<<<<<<<<<<<
+ *                     # If the caller didn't provide a context, we assume the
+ *                     # caller is already in the right context, which is usually
+ */
+          goto __pyx_L12;
+        }
+
+        /* "uvloop/sslproto.pyx":834
+ *                     self._app_protocol.pause_writing()
+ *                 else:
+ *                     run_in_context(context, self._app_protocol.pause_writing)             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        /*else*/ {
+          __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_app_protocol, __pyx_n_s_pause_writing); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 834, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __pyx_t_7 = __pyx_f_6uvloop_4loop_run_in_context(__pyx_v_context, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(22, 834, __pyx_L6_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        }
+        __pyx_L12:;
+
+        /* "uvloop/sslproto.pyx":827
+ *         if size >= self._outgoing_high_water and not self._app_writing_paused:
+ *             self._app_writing_paused = True
+ *             try:             # <<<<<<<<<<<<<<
+ *                 if context is None:
+ *                     # If the caller didn't provide a context, we assume the
+ */
+      }
+      __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_L11_try_end;
+      __pyx_L6_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;
+
+      /* "uvloop/sslproto.pyx":835
+ *                 else:
+ *                     run_in_context(context, self._app_protocol.pause_writing)
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException as exc:
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.SSLProtocol._control_app_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_8) < 0) __PYX_ERR(22, 835, __pyx_L8_except_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_8);
+
+        /* "uvloop/sslproto.pyx":836
+ *                     run_in_context(context, self._app_protocol.pause_writing)
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({
+ */
+        __Pyx_GIVEREF(__pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_6);
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_6, __pyx_t_8);
+        __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_8 = 0; 
+        __PYX_ERR(22, 836, __pyx_L8_except_error)
+      }
+
+      /* "uvloop/sslproto.pyx":837
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as exc:             # <<<<<<<<<<<<<<
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.pause_writing() failed',
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("uvloop.loop.SSLProtocol._control_app_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(22, 837, __pyx_L8_except_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_6);
+        __pyx_v_exc = __pyx_t_6;
+        /*try:*/ {
+
+          /* "uvloop/sslproto.pyx":838
+ *                 raise
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *                     'message': 'protocol.pause_writing() failed',
+ *                     'exception': exc,
+ */
+          __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_11)) __PYX_ERR(22, 838, __pyx_L20_error)
+          __Pyx_GOTREF(__pyx_t_11);
+
+          /* "uvloop/sslproto.pyx":839
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.pause_writing() failed',             # <<<<<<<<<<<<<<
+ *                     'exception': exc,
+ *                     'transport': self._app_transport,
+ */
+          __pyx_t_12 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_12)) __PYX_ERR(22, 839, __pyx_L20_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_message, __pyx_kp_u_protocol_pause_writing_failed) < 0) __PYX_ERR(22, 839, __pyx_L20_error)
+
+          /* "uvloop/sslproto.pyx":840
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.pause_writing() failed',
+ *                     'exception': exc,             # <<<<<<<<<<<<<<
+ *                     'transport': self._app_transport,
+ *                     'protocol': self,
+ */
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_exception, __pyx_v_exc) < 0) __PYX_ERR(22, 839, __pyx_L20_error)
+
+          /* "uvloop/sslproto.pyx":841
+ *                     'message': 'protocol.pause_writing() failed',
+ *                     'exception': exc,
+ *                     'transport': self._app_transport,             # <<<<<<<<<<<<<<
+ *                     'protocol': self,
+ *                 })
+ */
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_transport, ((PyObject *)__pyx_v_self->_app_transport)) < 0) __PYX_ERR(22, 839, __pyx_L20_error)
+
+          /* "uvloop/sslproto.pyx":842
+ *                     'exception': exc,
+ *                     'transport': self._app_transport,
+ *                     'protocol': self,             # <<<<<<<<<<<<<<
+ *                 })
+ *         elif size <= self._outgoing_low_water and self._app_writing_paused:
+ */
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_protocol, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(22, 839, __pyx_L20_error)
+          __pyx_t_13 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+            __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_11);
+            if (likely(__pyx_t_13)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+              __Pyx_INCREF(__pyx_t_13);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_11, function);
+            }
+          }
+          __pyx_t_10 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_13, __pyx_t_12) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_12);
+          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 838, __pyx_L20_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        }
+
+        /* "uvloop/sslproto.pyx":837
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as exc:             # <<<<<<<<<<<<<<
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.pause_writing() failed',
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+            goto __pyx_L21;
+          }
+          __pyx_L20_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __Pyx_XGOTREF(__pyx_t_21);
+            __pyx_t_9 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_exc);
+              __pyx_v_exc = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_XGIVEREF(__pyx_t_21);
+              __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
+            }
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+            __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
+            __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
+            goto __pyx_L8_except_error;
+          }
+          __pyx_L21:;
+        }
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        goto __pyx_L7_exception_handled;
+      }
+      goto __pyx_L8_except_error;
+      __pyx_L8_except_error:;
+
+      /* "uvloop/sslproto.pyx":827
+ *         if size >= self._outgoing_high_water and not self._app_writing_paused:
+ *             self._app_writing_paused = True
+ *             try:             # <<<<<<<<<<<<<<
+ *                 if context is None:
+ *                     # If the caller didn't provide a context, we assume the
+ */
+      __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_L7_exception_handled:;
+      __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);
+      __pyx_L11_try_end:;
+    }
+
+    /* "uvloop/sslproto.pyx":825
+ *     cdef _control_app_writing(self, object context=None):
+ *         cdef size_t size = self._get_write_buffer_size()
+ *         if size >= self._outgoing_high_water and not self._app_writing_paused:             # <<<<<<<<<<<<<<
+ *             self._app_writing_paused = True
+ *             try:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/sslproto.pyx":844
+ *                     'protocol': self,
+ *                 })
+ *         elif size <= self._outgoing_low_water and self._app_writing_paused:             # <<<<<<<<<<<<<<
+ *             self._app_writing_paused = False
+ *             try:
+ */
+  __pyx_t_1 = ((__pyx_v_size <= __pyx_v_self->_outgoing_low_water) != 0);
+  if (__pyx_t_1) {
+  } else {
+    __pyx_t_2 = __pyx_t_1;
+    goto __pyx_L26_bool_binop_done;
+  }
+  __pyx_t_1 = (__pyx_v_self->_app_writing_paused != 0);
+  __pyx_t_2 = __pyx_t_1;
+  __pyx_L26_bool_binop_done:;
+  if (__pyx_t_2) {
+
+    /* "uvloop/sslproto.pyx":845
+ *                 })
+ *         elif size <= self._outgoing_low_water and self._app_writing_paused:
+ *             self._app_writing_paused = False             # <<<<<<<<<<<<<<
+ *             try:
+ *                 if context is None:
+ */
+    __pyx_v_self->_app_writing_paused = 0;
+
+    /* "uvloop/sslproto.pyx":846
+ *         elif size <= self._outgoing_low_water and self._app_writing_paused:
+ *             self._app_writing_paused = False
+ *             try:             # <<<<<<<<<<<<<<
+ *                 if context is None:
+ *                     # If the caller didn't provide a context, we assume the
+ */
+    {
+      __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:*/ {
+
+        /* "uvloop/sslproto.pyx":847
+ *             self._app_writing_paused = False
+ *             try:
+ *                 if context is None:             # <<<<<<<<<<<<<<
+ *                     # If the caller didn't provide a context, we assume the
+ *                     # caller is already in the right context, which is usually
+ */
+        __pyx_t_2 = (__pyx_v_context == Py_None);
+        __pyx_t_1 = (__pyx_t_2 != 0);
+        if (__pyx_t_1) {
+
+          /* "uvloop/sslproto.pyx":851
+ *                     # caller is already in the right context, which is usually
+ *                     # inside the upstream callbacks like resume_writing()
+ *                     self._app_protocol.resume_writing()             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     run_in_context(context, self._app_protocol.resume_writing)
+ */
+          __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_app_protocol, __pyx_n_s_resume_writing); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 851, __pyx_L28_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __pyx_t_8 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(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_6, function);
+            }
+          }
+          __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (unlikely(!__pyx_t_7)) __PYX_ERR(22, 851, __pyx_L28_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+          /* "uvloop/sslproto.pyx":847
+ *             self._app_writing_paused = False
+ *             try:
+ *                 if context is None:             # <<<<<<<<<<<<<<
+ *                     # If the caller didn't provide a context, we assume the
+ *                     # caller is already in the right context, which is usually
+ */
+          goto __pyx_L34;
+        }
+
+        /* "uvloop/sslproto.pyx":853
+ *                     self._app_protocol.resume_writing()
+ *                 else:
+ *                     run_in_context(context, self._app_protocol.resume_writing)             # <<<<<<<<<<<<<<
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ */
+        /*else*/ {
+          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_app_protocol, __pyx_n_s_resume_writing); if (unlikely(!__pyx_t_7)) __PYX_ERR(22, 853, __pyx_L28_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __pyx_t_6 = __pyx_f_6uvloop_4loop_run_in_context(__pyx_v_context, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 853, __pyx_L28_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        }
+        __pyx_L34:;
+
+        /* "uvloop/sslproto.pyx":846
+ *         elif size <= self._outgoing_low_water and self._app_writing_paused:
+ *             self._app_writing_paused = False
+ *             try:             # <<<<<<<<<<<<<<
+ *                 if context is None:
+ *                     # If the caller didn't provide a context, we assume the
+ */
+      }
+      __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_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __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;
+
+      /* "uvloop/sslproto.pyx":854
+ *                 else:
+ *                     run_in_context(context, self._app_protocol.resume_writing)
+ *             except (KeyboardInterrupt, SystemExit):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except BaseException as exc:
+ */
+      __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_SystemExit);
+      if (__pyx_t_14) {
+        __Pyx_AddTraceback("uvloop.loop.SSLProtocol._control_app_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(22, 854, __pyx_L30_except_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_8);
+
+        /* "uvloop/sslproto.pyx":855
+ *                     run_in_context(context, self._app_protocol.resume_writing)
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({
+ */
+        __Pyx_GIVEREF(__pyx_t_6);
+        __Pyx_GIVEREF(__pyx_t_7);
+        __Pyx_XGIVEREF(__pyx_t_8);
+        __Pyx_ErrRestoreWithState(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+        __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; 
+        __PYX_ERR(22, 855, __pyx_L30_except_error)
+      }
+
+      /* "uvloop/sslproto.pyx":856
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as exc:             # <<<<<<<<<<<<<<
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.resume_writing() failed',
+ */
+      __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_14) {
+        __Pyx_AddTraceback("uvloop.loop.SSLProtocol._control_app_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(22, 856, __pyx_L30_except_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_7);
+        __pyx_v_exc = __pyx_t_7;
+        /*try:*/ {
+
+          /* "uvloop/sslproto.pyx":857
+ *                 raise
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *                     'message': 'protocol.resume_writing() failed',
+ *                     'exception': exc,
+ */
+          __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_11)) __PYX_ERR(22, 857, __pyx_L42_error)
+          __Pyx_GOTREF(__pyx_t_11);
+
+          /* "uvloop/sslproto.pyx":858
+ *             except BaseException as exc:
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.resume_writing() failed',             # <<<<<<<<<<<<<<
+ *                     'exception': exc,
+ *                     'transport': self._app_transport,
+ */
+          __pyx_t_12 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_12)) __PYX_ERR(22, 858, __pyx_L42_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_message, __pyx_kp_u_protocol_resume_writing_failed) < 0) __PYX_ERR(22, 858, __pyx_L42_error)
+
+          /* "uvloop/sslproto.pyx":859
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.resume_writing() failed',
+ *                     'exception': exc,             # <<<<<<<<<<<<<<
+ *                     'transport': self._app_transport,
+ *                     'protocol': self,
+ */
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_exception, __pyx_v_exc) < 0) __PYX_ERR(22, 858, __pyx_L42_error)
+
+          /* "uvloop/sslproto.pyx":860
+ *                     'message': 'protocol.resume_writing() failed',
+ *                     'exception': exc,
+ *                     'transport': self._app_transport,             # <<<<<<<<<<<<<<
+ *                     'protocol': self,
+ *                 })
+ */
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_transport, ((PyObject *)__pyx_v_self->_app_transport)) < 0) __PYX_ERR(22, 858, __pyx_L42_error)
+
+          /* "uvloop/sslproto.pyx":861
+ *                     'exception': exc,
+ *                     'transport': self._app_transport,
+ *                     'protocol': self,             # <<<<<<<<<<<<<<
+ *                 })
+ * 
+ */
+          if (PyDict_SetItem(__pyx_t_12, __pyx_n_u_protocol, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(22, 858, __pyx_L42_error)
+          __pyx_t_13 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+            __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_11);
+            if (likely(__pyx_t_13)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+              __Pyx_INCREF(__pyx_t_13);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_11, function);
+            }
+          }
+          __pyx_t_10 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_13, __pyx_t_12) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_12);
+          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+          if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 857, __pyx_L42_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        }
+
+        /* "uvloop/sslproto.pyx":856
+ *             except (KeyboardInterrupt, SystemExit):
+ *                 raise
+ *             except BaseException as exc:             # <<<<<<<<<<<<<<
+ *                 self._loop.call_exception_handler({
+ *                     'message': 'protocol.resume_writing() failed',
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+            goto __pyx_L43;
+          }
+          __pyx_L42_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_21, &__pyx_t_20, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_21, &__pyx_t_20, &__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_21);
+            __Pyx_XGOTREF(__pyx_t_20);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __pyx_t_14 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_22 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_exc);
+              __pyx_v_exc = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_XGIVEREF(__pyx_t_16);
+              __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_17, __pyx_t_16);
+            }
+            __Pyx_XGIVEREF(__pyx_t_21);
+            __Pyx_XGIVEREF(__pyx_t_20);
+            __Pyx_XGIVEREF(__pyx_t_19);
+            __Pyx_ErrRestore(__pyx_t_21, __pyx_t_20, __pyx_t_19);
+            __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0;
+            __pyx_lineno = __pyx_t_14; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_22;
+            goto __pyx_L30_except_error;
+          }
+          __pyx_L43:;
+        }
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        goto __pyx_L29_exception_handled;
+      }
+      goto __pyx_L30_except_error;
+      __pyx_L30_except_error:;
+
+      /* "uvloop/sslproto.pyx":846
+ *         elif size <= self._outgoing_low_water and self._app_writing_paused:
+ *             self._app_writing_paused = False
+ *             try:             # <<<<<<<<<<<<<<
+ *                 if context is None:
+ *                     # If the caller didn't provide a context, we assume the
+ */
+      __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_L29_exception_handled:;
+      __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);
+      __pyx_L33_try_end:;
+    }
+
+    /* "uvloop/sslproto.pyx":844
+ *                     'protocol': self,
+ *                 })
+ *         elif size <= self._outgoing_low_water and self._app_writing_paused:             # <<<<<<<<<<<<<<
+ *             self._app_writing_paused = False
+ *             try:
+ */
+  }
+  __pyx_L3:;
+
+  /* "uvloop/sslproto.pyx":823
+ *     # Flow control for writes from APP socket
+ * 
+ *     cdef _control_app_writing(self, object context=None):             # <<<<<<<<<<<<<<
+ *         cdef size_t size = self._get_write_buffer_size()
+ *         if size >= self._outgoing_high_water and not self._app_writing_paused:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._control_app_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":864
+ *                 })
+ * 
+ *     cdef size_t _get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         return self._outgoing.pending + self._write_buffer_size
+ * 
+ */
+
+static size_t __pyx_f_6uvloop_4loop_11SSLProtocol__get_write_buffer_size(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  size_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  size_t __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_get_write_buffer_size", 0);
+
+  /* "uvloop/sslproto.pyx":865
+ * 
+ *     cdef size_t _get_write_buffer_size(self):
+ *         return self._outgoing.pending + self._write_buffer_size             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _set_write_buffer_limits(self, high=None, low=None):
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_outgoing, __pyx_n_s_pending); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 865, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_v_self->_write_buffer_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 865, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 865, __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;
+  __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(22, 865, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_4;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":864
+ *                 })
+ * 
+ *     cdef size_t _get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         return self._outgoing.pending + self._write_buffer_size
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_WriteUnraisable("uvloop.loop.SSLProtocol._get_write_buffer_size", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":867
+ *         return self._outgoing.pending + self._write_buffer_size
+ * 
+ *     cdef _set_write_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         high, low = add_flowcontrol_defaults(
+ *             high, low, FLOW_CONTROL_HIGH_WATER_SSL_WRITE)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__set_write_buffer_limits(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_write_buffer_limits *__pyx_optional_args) {
+  PyObject *__pyx_v_high = ((PyObject *)Py_None);
+  PyObject *__pyx_v_low = ((PyObject *)Py_None);
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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 *);
+  size_t __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_set_write_buffer_limits", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_high = __pyx_optional_args->high;
+      if (__pyx_optional_args->__pyx_n > 1) {
+        __pyx_v_low = __pyx_optional_args->low;
+      }
+    }
+  }
+  __Pyx_INCREF(__pyx_v_high);
+  __Pyx_INCREF(__pyx_v_low);
+
+  /* "uvloop/sslproto.pyx":868
+ * 
+ *     cdef _set_write_buffer_limits(self, high=None, low=None):
+ *         high, low = add_flowcontrol_defaults(             # <<<<<<<<<<<<<<
+ *             high, low, FLOW_CONTROL_HIGH_WATER_SSL_WRITE)
+ *         self._outgoing_high_water = high
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_8includes_11flowcontrol_add_flowcontrol_defaults(__pyx_v_high, __pyx_v_low, 0x200); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 868, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  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);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(22, 868, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_3);
+    #else
+    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 868, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 868, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __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(22, 868, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __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_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;
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(22, 868, __pyx_L1_error)
+    __pyx_t_5 = NULL;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L4_unpacking_done;
+    __pyx_L3_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(22, 868, __pyx_L1_error)
+    __pyx_L4_unpacking_done:;
+  }
+  __Pyx_DECREF_SET(__pyx_v_high, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __Pyx_DECREF_SET(__pyx_v_low, __pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":870
+ *         high, low = add_flowcontrol_defaults(
+ *             high, low, FLOW_CONTROL_HIGH_WATER_SSL_WRITE)
+ *         self._outgoing_high_water = high             # <<<<<<<<<<<<<<
+ *         self._outgoing_low_water = low
+ * 
+ */
+  __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_v_high); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(22, 870, __pyx_L1_error)
+  __pyx_v_self->_outgoing_high_water = __pyx_t_6;
+
+  /* "uvloop/sslproto.pyx":871
+ *             high, low, FLOW_CONTROL_HIGH_WATER_SSL_WRITE)
+ *         self._outgoing_high_water = high
+ *         self._outgoing_low_water = low             # <<<<<<<<<<<<<<
+ * 
+ *     # Flow control for reads to APP socket
+ */
+  __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_v_low); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(22, 871, __pyx_L1_error)
+  __pyx_v_self->_outgoing_low_water = __pyx_t_6;
+
+  /* "uvloop/sslproto.pyx":867
+ *         return self._outgoing.pending + self._write_buffer_size
+ * 
+ *     cdef _set_write_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         high, low = add_flowcontrol_defaults(
+ *             high, low, FLOW_CONTROL_HIGH_WATER_SSL_WRITE)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_AddTraceback("uvloop.loop.SSLProtocol._set_write_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_high);
+  __Pyx_XDECREF(__pyx_v_low);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":875
+ *     # Flow control for reads to APP socket
+ * 
+ *     cdef _pause_reading(self):             # <<<<<<<<<<<<<<
+ *         self._app_reading_paused = True
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__pause_reading(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_pause_reading", 0);
+
+  /* "uvloop/sslproto.pyx":876
+ * 
+ *     cdef _pause_reading(self):
+ *         self._app_reading_paused = True             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _resume_reading(self, object context):
+ */
+  __pyx_v_self->_app_reading_paused = 1;
+
+  /* "uvloop/sslproto.pyx":875
+ *     # Flow control for reads to APP socket
+ * 
+ *     cdef _pause_reading(self):             # <<<<<<<<<<<<<<
+ *         self._app_reading_paused = True
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":878
+ *         self._app_reading_paused = True
+ * 
+ *     cdef _resume_reading(self, object context):             # <<<<<<<<<<<<<<
+ *         if self._app_reading_paused:
+ *             self._app_reading_paused = False
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__resume_reading(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_context) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_resume_reading", 0);
+
+  /* "uvloop/sslproto.pyx":879
+ * 
+ *     cdef _resume_reading(self, object context):
+ *         if self._app_reading_paused:             # <<<<<<<<<<<<<<
+ *             self._app_reading_paused = False
+ *             if self._state == WRAPPED:
+ */
+  __pyx_t_1 = (__pyx_v_self->_app_reading_paused != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":880
+ *     cdef _resume_reading(self, object context):
+ *         if self._app_reading_paused:
+ *             self._app_reading_paused = False             # <<<<<<<<<<<<<<
+ *             if self._state == WRAPPED:
+ *                 self._loop._call_soon_handle(
+ */
+    __pyx_v_self->_app_reading_paused = 0;
+
+    /* "uvloop/sslproto.pyx":881
+ *         if self._app_reading_paused:
+ *             self._app_reading_paused = False
+ *             if self._state == WRAPPED:             # <<<<<<<<<<<<<<
+ *                 self._loop._call_soon_handle(
+ *                     new_MethodHandle(self._loop,
+ */
+    __pyx_t_1 = ((__pyx_v_self->_state == __pyx_e_6uvloop_4loop_WRAPPED) != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/sslproto.pyx":883
+ *             if self._state == WRAPPED:
+ *                 self._loop._call_soon_handle(
+ *                     new_MethodHandle(self._loop,             # <<<<<<<<<<<<<<
+ *                                      "SSLProtocol._do_read",
+ *                                      <method_t>self._do_read,
+ */
+      __pyx_t_2 = ((PyObject *)__pyx_v_self->_loop);
+      __Pyx_INCREF(__pyx_t_2);
+
+      /* "uvloop/sslproto.pyx":887
+ *                                      <method_t>self._do_read,
+ *                                      context,
+ *                                      self))             # <<<<<<<<<<<<<<
+ * 
+ *     # Flow control for reads from SSL socket
+ */
+      __pyx_t_3 = __pyx_f_6uvloop_4loop_new_MethodHandle(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_2), __pyx_kp_u_SSLProtocol__do_read, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_read), __pyx_v_context, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 883, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/sslproto.pyx":883
+ *             if self._state == WRAPPED:
+ *                 self._loop._call_soon_handle(
+ *                     new_MethodHandle(self._loop,             # <<<<<<<<<<<<<<
+ *                                      "SSLProtocol._do_read",
+ *                                      <method_t>self._do_read,
+ */
+      if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(22, 883, __pyx_L1_error)
+
+      /* "uvloop/sslproto.pyx":882
+ *             self._app_reading_paused = False
+ *             if self._state == WRAPPED:
+ *                 self._loop._call_soon_handle(             # <<<<<<<<<<<<<<
+ *                     new_MethodHandle(self._loop,
+ *                                      "SSLProtocol._do_read",
+ */
+      __pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_self->_loop, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 882, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/sslproto.pyx":881
+ *         if self._app_reading_paused:
+ *             self._app_reading_paused = False
+ *             if self._state == WRAPPED:             # <<<<<<<<<<<<<<
+ *                 self._loop._call_soon_handle(
+ *                     new_MethodHandle(self._loop,
+ */
+    }
+
+    /* "uvloop/sslproto.pyx":879
+ * 
+ *     cdef _resume_reading(self, object context):
+ *         if self._app_reading_paused:             # <<<<<<<<<<<<<<
+ *             self._app_reading_paused = False
+ *             if self._state == WRAPPED:
+ */
+  }
+
+  /* "uvloop/sslproto.pyx":878
+ *         self._app_reading_paused = True
+ * 
+ *     cdef _resume_reading(self, object context):             # <<<<<<<<<<<<<<
+ *         if self._app_reading_paused:
+ *             self._app_reading_paused = False
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._resume_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":891
+ *     # Flow control for reads from SSL socket
+ * 
+ *     cdef _control_ssl_reading(self):             # <<<<<<<<<<<<<<
+ *         cdef size_t size = self._get_read_buffer_size()
+ *         if size >= self._incoming_high_water and not self._ssl_reading_paused:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__control_ssl_reading(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  size_t __pyx_v_size;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  __Pyx_RefNannySetupContext("_control_ssl_reading", 0);
+
+  /* "uvloop/sslproto.pyx":892
+ * 
+ *     cdef _control_ssl_reading(self):
+ *         cdef size_t size = self._get_read_buffer_size()             # <<<<<<<<<<<<<<
+ *         if size >= self._incoming_high_water and not self._ssl_reading_paused:
+ *             self._ssl_reading_paused = True
+ */
+  __pyx_v_size = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_get_read_buffer_size(__pyx_v_self);
+
+  /* "uvloop/sslproto.pyx":893
+ *     cdef _control_ssl_reading(self):
+ *         cdef size_t size = self._get_read_buffer_size()
+ *         if size >= self._incoming_high_water and not self._ssl_reading_paused:             # <<<<<<<<<<<<<<
+ *             self._ssl_reading_paused = True
+ *             self._transport.pause_reading()
+ */
+  __pyx_t_2 = ((__pyx_v_size >= __pyx_v_self->_incoming_high_water) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = ((!(__pyx_v_self->_ssl_reading_paused != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":894
+ *         cdef size_t size = self._get_read_buffer_size()
+ *         if size >= self._incoming_high_water and not self._ssl_reading_paused:
+ *             self._ssl_reading_paused = True             # <<<<<<<<<<<<<<
+ *             self._transport.pause_reading()
+ *         elif size <= self._incoming_low_water and self._ssl_reading_paused:
+ */
+    __pyx_v_self->_ssl_reading_paused = 1;
+
+    /* "uvloop/sslproto.pyx":895
+ *         if size >= self._incoming_high_water and not self._ssl_reading_paused:
+ *             self._ssl_reading_paused = True
+ *             self._transport.pause_reading()             # <<<<<<<<<<<<<<
+ *         elif size <= self._incoming_low_water and self._ssl_reading_paused:
+ *             self._ssl_reading_paused = False
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_transport, __pyx_n_s_pause_reading); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 895, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 895, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":893
+ *     cdef _control_ssl_reading(self):
+ *         cdef size_t size = self._get_read_buffer_size()
+ *         if size >= self._incoming_high_water and not self._ssl_reading_paused:             # <<<<<<<<<<<<<<
+ *             self._ssl_reading_paused = True
+ *             self._transport.pause_reading()
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/sslproto.pyx":896
+ *             self._ssl_reading_paused = True
+ *             self._transport.pause_reading()
+ *         elif size <= self._incoming_low_water and self._ssl_reading_paused:             # <<<<<<<<<<<<<<
+ *             self._ssl_reading_paused = False
+ *             self._transport.resume_reading()
+ */
+  __pyx_t_2 = ((__pyx_v_size <= __pyx_v_self->_incoming_low_water) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_v_self->_ssl_reading_paused != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L6_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":897
+ *             self._transport.pause_reading()
+ *         elif size <= self._incoming_low_water and self._ssl_reading_paused:
+ *             self._ssl_reading_paused = False             # <<<<<<<<<<<<<<
+ *             self._transport.resume_reading()
+ * 
+ */
+    __pyx_v_self->_ssl_reading_paused = 0;
+
+    /* "uvloop/sslproto.pyx":898
+ *         elif size <= self._incoming_low_water and self._ssl_reading_paused:
+ *             self._ssl_reading_paused = False
+ *             self._transport.resume_reading()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _set_read_buffer_limits(self, high=None, low=None):
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_transport, __pyx_n_s_resume_reading); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 898, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 898, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/sslproto.pyx":896
+ *             self._ssl_reading_paused = True
+ *             self._transport.pause_reading()
+ *         elif size <= self._incoming_low_water and self._ssl_reading_paused:             # <<<<<<<<<<<<<<
+ *             self._ssl_reading_paused = False
+ *             self._transport.resume_reading()
+ */
+  }
+  __pyx_L3:;
+
+  /* "uvloop/sslproto.pyx":891
+ *     # Flow control for reads from SSL socket
+ * 
+ *     cdef _control_ssl_reading(self):             # <<<<<<<<<<<<<<
+ *         cdef size_t size = self._get_read_buffer_size()
+ *         if size >= self._incoming_high_water and not self._ssl_reading_paused:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._control_ssl_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":900
+ *             self._transport.resume_reading()
+ * 
+ *     cdef _set_read_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         high, low = add_flowcontrol_defaults(
+ *             high, low, FLOW_CONTROL_HIGH_WATER_SSL_READ)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__set_read_buffer_limits(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_read_buffer_limits *__pyx_optional_args) {
+  PyObject *__pyx_v_high = ((PyObject *)Py_None);
+  PyObject *__pyx_v_low = ((PyObject *)Py_None);
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  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 *);
+  size_t __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_set_read_buffer_limits", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_high = __pyx_optional_args->high;
+      if (__pyx_optional_args->__pyx_n > 1) {
+        __pyx_v_low = __pyx_optional_args->low;
+      }
+    }
+  }
+  __Pyx_INCREF(__pyx_v_high);
+  __Pyx_INCREF(__pyx_v_low);
+
+  /* "uvloop/sslproto.pyx":901
+ * 
+ *     cdef _set_read_buffer_limits(self, high=None, low=None):
+ *         high, low = add_flowcontrol_defaults(             # <<<<<<<<<<<<<<
+ *             high, low, FLOW_CONTROL_HIGH_WATER_SSL_READ)
+ *         self._incoming_high_water = high
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_8includes_11flowcontrol_add_flowcontrol_defaults(__pyx_v_high, __pyx_v_low, 0x100); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 901, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  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);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(22, 901, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_3);
+    #else
+    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 901, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 901, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __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(22, 901, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __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_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;
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(22, 901, __pyx_L1_error)
+    __pyx_t_5 = NULL;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L4_unpacking_done;
+    __pyx_L3_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(22, 901, __pyx_L1_error)
+    __pyx_L4_unpacking_done:;
+  }
+  __Pyx_DECREF_SET(__pyx_v_high, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __Pyx_DECREF_SET(__pyx_v_low, __pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "uvloop/sslproto.pyx":903
+ *         high, low = add_flowcontrol_defaults(
+ *             high, low, FLOW_CONTROL_HIGH_WATER_SSL_READ)
+ *         self._incoming_high_water = high             # <<<<<<<<<<<<<<
+ *         self._incoming_low_water = low
+ * 
+ */
+  __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_v_high); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(22, 903, __pyx_L1_error)
+  __pyx_v_self->_incoming_high_water = __pyx_t_6;
+
+  /* "uvloop/sslproto.pyx":904
+ *             high, low, FLOW_CONTROL_HIGH_WATER_SSL_READ)
+ *         self._incoming_high_water = high
+ *         self._incoming_low_water = low             # <<<<<<<<<<<<<<
+ * 
+ *     cdef size_t _get_read_buffer_size(self):
+ */
+  __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_v_low); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(22, 904, __pyx_L1_error)
+  __pyx_v_self->_incoming_low_water = __pyx_t_6;
+
+  /* "uvloop/sslproto.pyx":900
+ *             self._transport.resume_reading()
+ * 
+ *     cdef _set_read_buffer_limits(self, high=None, low=None):             # <<<<<<<<<<<<<<
+ *         high, low = add_flowcontrol_defaults(
+ *             high, low, FLOW_CONTROL_HIGH_WATER_SSL_READ)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  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_AddTraceback("uvloop.loop.SSLProtocol._set_read_buffer_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_high);
+  __Pyx_XDECREF(__pyx_v_low);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":906
+ *         self._incoming_low_water = low
+ * 
+ *     cdef size_t _get_read_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         return self._incoming.pending
+ * 
+ */
+
+static size_t __pyx_f_6uvloop_4loop_11SSLProtocol__get_read_buffer_size(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  size_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_get_read_buffer_size", 0);
+
+  /* "uvloop/sslproto.pyx":907
+ * 
+ *     cdef size_t _get_read_buffer_size(self):
+ *         return self._incoming.pending             # <<<<<<<<<<<<<<
+ * 
+ *     # Flow control for writes to SSL socket
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_incoming, __pyx_n_s_pending); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 907, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_size_t(__pyx_t_1); if (unlikely((__pyx_t_2 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(22, 907, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  goto __pyx_L0;
+
+  /* "uvloop/sslproto.pyx":906
+ *         self._incoming_low_water = low
+ * 
+ *     cdef size_t _get_read_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         return self._incoming.pending
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_WriteUnraisable("uvloop.loop.SSLProtocol._get_read_buffer_size", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":911
+ *     # Flow control for writes to SSL socket
+ * 
+ *     def pause_writing(self):             # <<<<<<<<<<<<<<
+ *         """Called when the low-level transport's buffer goes over
+ *         the high-water mark.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_19pause_writing(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11SSLProtocol_18pause_writing[] = "SSLProtocol.pause_writing(self)\nCalled when the low-level transport's buffer goes over\n        the high-water mark.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_19pause_writing(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("pause_writing (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11SSLProtocol_18pause_writing(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_18pause_writing(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("pause_writing", 0);
+
+  /* "uvloop/sslproto.pyx":915
+ *         the high-water mark.
+ *         """
+ *         assert not self._ssl_writing_paused             # <<<<<<<<<<<<<<
+ *         self._ssl_writing_paused = True
+ * 
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    if (unlikely(!((!(__pyx_v_self->_ssl_writing_paused != 0)) != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(22, 915, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "uvloop/sslproto.pyx":916
+ *         """
+ *         assert not self._ssl_writing_paused
+ *         self._ssl_writing_paused = True             # <<<<<<<<<<<<<<
+ * 
+ *     def resume_writing(self):
+ */
+  __pyx_v_self->_ssl_writing_paused = 1;
+
+  /* "uvloop/sslproto.pyx":911
+ *     # Flow control for writes to SSL socket
+ * 
+ *     def pause_writing(self):             # <<<<<<<<<<<<<<
+ *         """Called when the low-level transport's buffer goes over
+ *         the high-water mark.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.pause_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":918
+ *         self._ssl_writing_paused = True
+ * 
+ *     def resume_writing(self):             # <<<<<<<<<<<<<<
+ *         """Called when the low-level transport's buffer drains below
+ *         the low-water mark.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_21resume_writing(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11SSLProtocol_20resume_writing[] = "SSLProtocol.resume_writing(self)\nCalled when the low-level transport's buffer drains below\n        the low-water mark.\n        ";
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_21resume_writing(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resume_writing (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_11SSLProtocol_20resume_writing(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_20resume_writing(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__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("resume_writing", 0);
+
+  /* "uvloop/sslproto.pyx":922
+ *         the low-water mark.
+ *         """
+ *         assert self._ssl_writing_paused             # <<<<<<<<<<<<<<
+ *         self._ssl_writing_paused = False
+ * 
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    if (unlikely(!(__pyx_v_self->_ssl_writing_paused != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(22, 922, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "uvloop/sslproto.pyx":923
+ *         """
+ *         assert self._ssl_writing_paused
+ *         self._ssl_writing_paused = False             # <<<<<<<<<<<<<<
+ * 
+ *         if self._state == WRAPPED:
+ */
+  __pyx_v_self->_ssl_writing_paused = 0;
+
+  /* "uvloop/sslproto.pyx":925
+ *         self._ssl_writing_paused = False
+ * 
+ *         if self._state == WRAPPED:             # <<<<<<<<<<<<<<
+ *             self._process_outgoing()
+ *             self._control_app_writing()
+ */
+  switch (__pyx_v_self->_state) {
+    case __pyx_e_6uvloop_4loop_WRAPPED:
+
+    /* "uvloop/sslproto.pyx":926
+ * 
+ *         if self._state == WRAPPED:
+ *             self._process_outgoing()             # <<<<<<<<<<<<<<
+ *             self._control_app_writing()
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_process_outgoing(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 926, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":927
+ *         if self._state == WRAPPED:
+ *             self._process_outgoing()
+ *             self._control_app_writing()             # <<<<<<<<<<<<<<
+ * 
+ *         elif self._state == FLUSHING:
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_control_app_writing(__pyx_v_self, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 927, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":925
+ *         self._ssl_writing_paused = False
+ * 
+ *         if self._state == WRAPPED:             # <<<<<<<<<<<<<<
+ *             self._process_outgoing()
+ *             self._control_app_writing()
+ */
+    break;
+    case __pyx_e_6uvloop_4loop_FLUSHING:
+
+    /* "uvloop/sslproto.pyx":930
+ * 
+ *         elif self._state == FLUSHING:
+ *             self._do_flush()             # <<<<<<<<<<<<<<
+ * 
+ *         elif self._state == SHUTDOWN:
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_flush(__pyx_v_self, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 930, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":929
+ *             self._control_app_writing()
+ * 
+ *         elif self._state == FLUSHING:             # <<<<<<<<<<<<<<
+ *             self._do_flush()
+ * 
+ */
+    break;
+    case __pyx_e_6uvloop_4loop_SHUTDOWN:
+
+    /* "uvloop/sslproto.pyx":933
+ * 
+ *         elif self._state == SHUTDOWN:
+ *             self._do_shutdown()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _fatal_error(self, exc, message='Fatal error on transport'):
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol *)__pyx_v_self->__pyx_vtab)->_do_shutdown(__pyx_v_self, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 933, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/sslproto.pyx":932
+ *             self._do_flush()
+ * 
+ *         elif self._state == SHUTDOWN:             # <<<<<<<<<<<<<<
+ *             self._do_shutdown()
+ * 
+ */
+    break;
+    default: break;
+  }
+
+  /* "uvloop/sslproto.pyx":918
+ *         self._ssl_writing_paused = True
+ * 
+ *     def resume_writing(self):             # <<<<<<<<<<<<<<
+ *         """Called when the low-level transport's buffer drains below
+ *         the low-water mark.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.resume_writing", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/sslproto.pyx":935
+ *             self._do_shutdown()
+ * 
+ *     cdef _fatal_error(self, exc, message='Fatal error on transport'):             # <<<<<<<<<<<<<<
+ *         if self._app_transport:
+ *             self._app_transport._force_close(exc)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_11SSLProtocol__fatal_error(struct __pyx_obj_6uvloop_4loop_SSLProtocol *__pyx_v_self, PyObject *__pyx_v_exc, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__fatal_error *__pyx_optional_args) {
+  PyObject *__pyx_v_message = ((PyObject *)__pyx_kp_u_Fatal_error_on_transport_2);
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = 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("_fatal_error", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_message = __pyx_optional_args->message;
+    }
+  }
+
+  /* "uvloop/sslproto.pyx":936
+ * 
+ *     cdef _fatal_error(self, exc, message='Fatal error on transport'):
+ *         if self._app_transport:             # <<<<<<<<<<<<<<
+ *             self._app_transport._force_close(exc)
+ *         elif self._transport:
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_self->_app_transport)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(22, 936, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":937
+ *     cdef _fatal_error(self, exc, message='Fatal error on transport'):
+ *         if self._app_transport:
+ *             self._app_transport._force_close(exc)             # <<<<<<<<<<<<<<
+ *         elif self._transport:
+ *             self._transport._force_close(exc)
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_app_transport), __pyx_n_s_force_close); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 937, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_exc);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 937, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/sslproto.pyx":936
+ * 
+ *     cdef _fatal_error(self, exc, message='Fatal error on transport'):
+ *         if self._app_transport:             # <<<<<<<<<<<<<<
+ *             self._app_transport._force_close(exc)
+ *         elif self._transport:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/sslproto.pyx":938
+ *         if self._app_transport:
+ *             self._app_transport._force_close(exc)
+ *         elif self._transport:             # <<<<<<<<<<<<<<
+ *             self._transport._force_close(exc)
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_transport); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(22, 938, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":939
+ *             self._app_transport._force_close(exc)
+ *         elif self._transport:
+ *             self._transport._force_close(exc)             # <<<<<<<<<<<<<<
+ * 
+ *         if isinstance(exc, OSError):
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_transport, __pyx_n_s_force_close); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 939, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_exc) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_exc);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 939, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/sslproto.pyx":938
+ *         if self._app_transport:
+ *             self._app_transport._force_close(exc)
+ *         elif self._transport:             # <<<<<<<<<<<<<<
+ *             self._transport._force_close(exc)
+ * 
+ */
+  }
+  __pyx_L3:;
+
+  /* "uvloop/sslproto.pyx":941
+ *             self._transport._force_close(exc)
+ * 
+ *         if isinstance(exc, OSError):             # <<<<<<<<<<<<<<
+ *             if self._loop.get_debug():
+ *                 aio_logger.debug("%r: %s", self, message, exc_info=True)
+ */
+  __pyx_t_1 = PyObject_IsInstance(__pyx_v_exc, __pyx_builtin_OSError); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(22, 941, __pyx_L1_error)
+  __pyx_t_5 = (__pyx_t_1 != 0);
+  if (__pyx_t_5) {
+
+    /* "uvloop/sslproto.pyx":942
+ * 
+ *         if isinstance(exc, OSError):
+ *             if self._loop.get_debug():             # <<<<<<<<<<<<<<
+ *                 aio_logger.debug("%r: %s", self, message, exc_info=True)
+ *         elif not isinstance(exc, aio_CancelledError):
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_loop), __pyx_n_s_get_debug); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 942, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 942, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(22, 942, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (__pyx_t_5) {
+
+      /* "uvloop/sslproto.pyx":943
+ *         if isinstance(exc, OSError):
+ *             if self._loop.get_debug():
+ *                 aio_logger.debug("%r: %s", self, message, exc_info=True)             # <<<<<<<<<<<<<<
+ *         elif not isinstance(exc, aio_CancelledError):
+ *             self._loop.call_exception_handler({
+ */
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 943, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 943, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_INCREF(__pyx_kp_u_r_s);
+      __Pyx_GIVEREF(__pyx_kp_u_r_s);
+      PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_r_s);
+      __Pyx_INCREF(((PyObject *)__pyx_v_self));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+      PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_self));
+      __Pyx_INCREF(__pyx_v_message);
+      __Pyx_GIVEREF(__pyx_v_message);
+      PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_message);
+      __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 943, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_exc_info, Py_True) < 0) __PYX_ERR(22, 943, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(22, 943, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+      /* "uvloop/sslproto.pyx":942
+ * 
+ *         if isinstance(exc, OSError):
+ *             if self._loop.get_debug():             # <<<<<<<<<<<<<<
+ *                 aio_logger.debug("%r: %s", self, message, exc_info=True)
+ *         elif not isinstance(exc, aio_CancelledError):
+ */
+    }
+
+    /* "uvloop/sslproto.pyx":941
+ *             self._transport._force_close(exc)
+ * 
+ *         if isinstance(exc, OSError):             # <<<<<<<<<<<<<<
+ *             if self._loop.get_debug():
+ *                 aio_logger.debug("%r: %s", self, message, exc_info=True)
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/sslproto.pyx":944
+ *             if self._loop.get_debug():
+ *                 aio_logger.debug("%r: %s", self, message, exc_info=True)
+ *         elif not isinstance(exc, aio_CancelledError):             # <<<<<<<<<<<<<<
+ *             self._loop.call_exception_handler({
+ *                 'message': message,
+ */
+  __pyx_t_6 = __pyx_v_6uvloop_4loop_aio_CancelledError;
+  __Pyx_INCREF(__pyx_t_6);
+  __pyx_t_5 = PyObject_IsInstance(__pyx_v_exc, __pyx_t_6); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(22, 944, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/sslproto.pyx":945
+ *                 aio_logger.debug("%r: %s", self, message, exc_info=True)
+ *         elif not isinstance(exc, aio_CancelledError):
+ *             self._loop.call_exception_handler({             # <<<<<<<<<<<<<<
+ *                 'message': message,
+ *                 'exception': exc,
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_loop), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_4)) __PYX_ERR(22, 945, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "uvloop/sslproto.pyx":946
+ *         elif not isinstance(exc, aio_CancelledError):
+ *             self._loop.call_exception_handler({
+ *                 'message': message,             # <<<<<<<<<<<<<<
+ *                 'exception': exc,
+ *                 'transport': self._transport,
+ */
+    __pyx_t_3 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 946, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_message, __pyx_v_message) < 0) __PYX_ERR(22, 946, __pyx_L1_error)
+
+    /* "uvloop/sslproto.pyx":947
+ *             self._loop.call_exception_handler({
+ *                 'message': message,
+ *                 'exception': exc,             # <<<<<<<<<<<<<<
+ *                 'transport': self._transport,
+ *                 'protocol': self,
+ */
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_exception, __pyx_v_exc) < 0) __PYX_ERR(22, 946, __pyx_L1_error)
+
+    /* "uvloop/sslproto.pyx":948
+ *                 'message': message,
+ *                 'exception': exc,
+ *                 'transport': self._transport,             # <<<<<<<<<<<<<<
+ *                 'protocol': self,
+ *             })
+ */
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_transport, __pyx_v_self->_transport) < 0) __PYX_ERR(22, 946, __pyx_L1_error)
+
+    /* "uvloop/sslproto.pyx":949
+ *                 'exception': exc,
+ *                 'transport': self._transport,
+ *                 'protocol': self,             # <<<<<<<<<<<<<<
+ *             })
+ */
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_protocol, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(22, 946, __pyx_L1_error)
+    __pyx_t_2 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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);
+        __Pyx_INCREF(__pyx_t_2);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_6 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __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_6)) __PYX_ERR(22, 945, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "uvloop/sslproto.pyx":944
+ *             if self._loop.get_debug():
+ *                 aio_logger.debug("%r: %s", self, message, exc_info=True)
+ *         elif not isinstance(exc, aio_CancelledError):             # <<<<<<<<<<<<<<
+ *             self._loop.call_exception_handler({
+ *                 'message': message,
+ */
+  }
+  __pyx_L4:;
+
+  /* "uvloop/sslproto.pyx":935
+ *             self._do_shutdown()
+ * 
+ *     cdef _fatal_error(self, exc, message='Fatal error on transport'):             # <<<<<<<<<<<<<<
+ *         if self._app_transport:
+ *             self._app_transport._force_close(exc)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol._fatal_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_23__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11SSLProtocol_22__reduce_cython__[] = "SSLProtocol.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_23__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_6uvloop_4loop_11SSLProtocol_22__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_22__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_SSLProtocol *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__219, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.__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_6uvloop_4loop_11SSLProtocol_25__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_11SSLProtocol_24__setstate_cython__[] = "SSLProtocol.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_11SSLProtocol_25__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_6uvloop_4loop_11SSLProtocol_24__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_11SSLProtocol_24__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_SSLProtocol *__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);
+
+  /* "(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__220, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.SSLProtocol.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":16
+ *         bint            closed
+ * 
+ *     cdef close(self):             # <<<<<<<<<<<<<<
+ *         if self.closed:
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_15_UDPSendContext_close(struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("close", 0);
+
+  /* "uvloop/handles/udp.pyx":17
+ * 
+ *     cdef close(self):
+ *         if self.closed:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->closed != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":18
+ *     cdef close(self):
+ *         if self.closed:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self.closed = 1
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":17
+ * 
+ *     cdef close(self):
+ *         if self.closed:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":20
+ *             return
+ * 
+ *         self.closed = 1             # <<<<<<<<<<<<<<
+ *         PyBuffer_Release(&self.py_buf)  # void
+ *         self.req.data = NULL
+ */
+  __pyx_v_self->closed = 1;
+
+  /* "uvloop/handles/udp.pyx":21
+ * 
+ *         self.closed = 1
+ *         PyBuffer_Release(&self.py_buf)  # void             # <<<<<<<<<<<<<<
+ *         self.req.data = NULL
+ *         self.uv_buf.base = NULL
+ */
+  PyBuffer_Release((&__pyx_v_self->py_buf));
+
+  /* "uvloop/handles/udp.pyx":22
+ *         self.closed = 1
+ *         PyBuffer_Release(&self.py_buf)  # void
+ *         self.req.data = NULL             # <<<<<<<<<<<<<<
+ *         self.uv_buf.base = NULL
+ *         Py_DECREF(self)
+ */
+  __pyx_v_self->req.data = NULL;
+
+  /* "uvloop/handles/udp.pyx":23
+ *         PyBuffer_Release(&self.py_buf)  # void
+ *         self.req.data = NULL
+ *         self.uv_buf.base = NULL             # <<<<<<<<<<<<<<
+ *         Py_DECREF(self)
+ *         self.udp = None
+ */
+  __pyx_v_self->uv_buf.base = NULL;
+
+  /* "uvloop/handles/udp.pyx":24
+ *         self.req.data = NULL
+ *         self.uv_buf.base = NULL
+ *         Py_DECREF(self)             # <<<<<<<<<<<<<<
+ *         self.udp = None
+ * 
+ */
+  Py_DECREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/handles/udp.pyx":25
+ *         self.uv_buf.base = NULL
+ *         Py_DECREF(self)
+ *         self.udp = None             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->udp);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->udp));
+  __pyx_v_self->udp = ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)Py_None);
+
+  /* "uvloop/handles/udp.pyx":16
+ *         bint            closed
+ * 
+ *     cdef close(self):             # <<<<<<<<<<<<<<
+ *         if self.closed:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":28
+ * 
+ *     @staticmethod
+ *     cdef _UDPSendContext new(UDPTransport udp, object data):             # <<<<<<<<<<<<<<
+ *         cdef _UDPSendContext ctx
+ *         ctx = _UDPSendContext.__new__(_UDPSendContext)
+ */
+
+static struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_f_6uvloop_4loop_15_UDPSendContext_new(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_udp, PyObject *__pyx_v_data) {
+  struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_v_ctx = 0;
+  struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("new", 0);
+
+  /* "uvloop/handles/udp.pyx":30
+ *     cdef _UDPSendContext new(UDPTransport udp, object data):
+ *         cdef _UDPSendContext ctx
+ *         ctx = _UDPSendContext.__new__(_UDPSendContext)             # <<<<<<<<<<<<<<
+ *         ctx.udp = None
+ *         ctx.closed = 1
+ */
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_6uvloop_4loop__UDPSendContext(((PyTypeObject *)__pyx_ptype_6uvloop_4loop__UDPSendContext), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 30, __pyx_L1_error)
+  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_v_ctx = ((struct __pyx_obj_6uvloop_4loop__UDPSendContext *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/udp.pyx":31
+ *         cdef _UDPSendContext ctx
+ *         ctx = _UDPSendContext.__new__(_UDPSendContext)
+ *         ctx.udp = None             # <<<<<<<<<<<<<<
+ *         ctx.closed = 1
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_ctx->udp);
+  __Pyx_DECREF(((PyObject *)__pyx_v_ctx->udp));
+  __pyx_v_ctx->udp = ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)Py_None);
+
+  /* "uvloop/handles/udp.pyx":32
+ *         ctx = _UDPSendContext.__new__(_UDPSendContext)
+ *         ctx.udp = None
+ *         ctx.closed = 1             # <<<<<<<<<<<<<<
+ * 
+ *         ctx.req.data = <void*> ctx
+ */
+  __pyx_v_ctx->closed = 1;
+
+  /* "uvloop/handles/udp.pyx":34
+ *         ctx.closed = 1
+ * 
+ *         ctx.req.data = <void*> ctx             # <<<<<<<<<<<<<<
+ *         Py_INCREF(ctx)
+ * 
+ */
+  __pyx_v_ctx->req.data = ((void *)__pyx_v_ctx);
+
+  /* "uvloop/handles/udp.pyx":35
+ * 
+ *         ctx.req.data = <void*> ctx
+ *         Py_INCREF(ctx)             # <<<<<<<<<<<<<<
+ * 
+ *         PyObject_GetBuffer(data, &ctx.py_buf, PyBUF_SIMPLE)
+ */
+  Py_INCREF(((PyObject *)__pyx_v_ctx));
+
+  /* "uvloop/handles/udp.pyx":37
+ *         Py_INCREF(ctx)
+ * 
+ *         PyObject_GetBuffer(data, &ctx.py_buf, PyBUF_SIMPLE)             # <<<<<<<<<<<<<<
+ *         ctx.uv_buf.base = <char*>ctx.py_buf.buf
+ *         ctx.uv_buf.len = ctx.py_buf.len
+ */
+  __pyx_t_2 = PyObject_GetBuffer(__pyx_v_data, (&__pyx_v_ctx->py_buf), PyBUF_SIMPLE); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(23, 37, __pyx_L1_error)
+
+  /* "uvloop/handles/udp.pyx":38
+ * 
+ *         PyObject_GetBuffer(data, &ctx.py_buf, PyBUF_SIMPLE)
+ *         ctx.uv_buf.base = <char*>ctx.py_buf.buf             # <<<<<<<<<<<<<<
+ *         ctx.uv_buf.len = ctx.py_buf.len
+ *         ctx.udp = udp
+ */
+  __pyx_v_ctx->uv_buf.base = ((char *)__pyx_v_ctx->py_buf.buf);
+
+  /* "uvloop/handles/udp.pyx":39
+ *         PyObject_GetBuffer(data, &ctx.py_buf, PyBUF_SIMPLE)
+ *         ctx.uv_buf.base = <char*>ctx.py_buf.buf
+ *         ctx.uv_buf.len = ctx.py_buf.len             # <<<<<<<<<<<<<<
+ *         ctx.udp = udp
+ * 
+ */
+  __pyx_t_3 = __pyx_v_ctx->py_buf.len;
+  __pyx_v_ctx->uv_buf.len = __pyx_t_3;
+
+  /* "uvloop/handles/udp.pyx":40
+ *         ctx.uv_buf.base = <char*>ctx.py_buf.buf
+ *         ctx.uv_buf.len = ctx.py_buf.len
+ *         ctx.udp = udp             # <<<<<<<<<<<<<<
+ * 
+ *         ctx.closed = 0
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_udp));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_udp));
+  __Pyx_GOTREF(__pyx_v_ctx->udp);
+  __Pyx_DECREF(((PyObject *)__pyx_v_ctx->udp));
+  __pyx_v_ctx->udp = __pyx_v_udp;
+
+  /* "uvloop/handles/udp.pyx":42
+ *         ctx.udp = udp
+ * 
+ *         ctx.closed = 0             # <<<<<<<<<<<<<<
+ *         return ctx
+ * 
+ */
+  __pyx_v_ctx->closed = 0;
+
+  /* "uvloop/handles/udp.pyx":43
+ * 
+ *         ctx.closed = 0
+ *         return ctx             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_ctx));
+  __pyx_r = __pyx_v_ctx;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/udp.pyx":28
+ * 
+ *     @staticmethod
+ *     cdef _UDPSendContext new(UDPTransport udp, object data):             # <<<<<<<<<<<<<<
+ *         cdef _UDPSendContext ctx
+ *         ctx = _UDPSendContext.__new__(_UDPSendContext)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._UDPSendContext.new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_ctx);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":45
+ *         return ctx
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if not self.closed:
+ */
+
+/* Python wrapper */
+static void __pyx_pw_6uvloop_4loop_15_UDPSendContext_1__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_6uvloop_4loop_15_UDPSendContext_1__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_6uvloop_4loop_15_UDPSendContext___dealloc__(((struct __pyx_obj_6uvloop_4loop__UDPSendContext *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_6uvloop_4loop_15_UDPSendContext___dealloc__(struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_v_self) {
+  __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("__dealloc__", 0);
+
+  /* "uvloop/handles/udp.pyx":46
+ * 
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if not self.closed:
+ *                 raise RuntimeError(
+ */
+  __pyx_t_1 = (UVLOOP_DEBUG != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":47
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG:
+ *             if not self.closed:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     'open _UDPSendContext is being deallocated')
+ */
+    __pyx_t_1 = ((!(__pyx_v_self->closed != 0)) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/handles/udp.pyx":48
+ *         if UVLOOP_DEBUG:
+ *             if not self.closed:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     'open _UDPSendContext is being deallocated')
+ *         self.udp = None
+ */
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__221, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 48, __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(23, 48, __pyx_L1_error)
+
+      /* "uvloop/handles/udp.pyx":47
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG:
+ *             if not self.closed:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(
+ *                     'open _UDPSendContext is being deallocated')
+ */
+    }
+
+    /* "uvloop/handles/udp.pyx":46
+ * 
+ *     def __dealloc__(self):
+ *         if UVLOOP_DEBUG:             # <<<<<<<<<<<<<<
+ *             if not self.closed:
+ *                 raise RuntimeError(
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":50
+ *                 raise RuntimeError(
+ *                     'open _UDPSendContext is being deallocated')
+ *         self.udp = None             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->udp);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->udp));
+  __pyx_v_self->udp = ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)Py_None);
+
+  /* "uvloop/handles/udp.pyx":45
+ *         return ctx
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if not self.closed:
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_WriteUnraisable("uvloop.loop._UDPSendContext.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15_UDPSendContext_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15_UDPSendContext_2__reduce_cython__[] = "_UDPSendContext.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_15_UDPSendContext_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_6uvloop_4loop_15_UDPSendContext_2__reduce_cython__(((struct __pyx_obj_6uvloop_4loop__UDPSendContext *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15_UDPSendContext_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__UDPSendContext *__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);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__222, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 2, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("self.py_buf,self.req 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("uvloop.loop._UDPSendContext.__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("self.py_buf,self.req cannot be converted to a Python object for pickling")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_15_UDPSendContext_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_15_UDPSendContext_4__setstate_cython__[] = "_UDPSendContext.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_15_UDPSendContext_5__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_6uvloop_4loop_15_UDPSendContext_4__setstate_cython__(((struct __pyx_obj_6uvloop_4loop__UDPSendContext *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_15_UDPSendContext_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop__UDPSendContext *__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);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__223, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 4, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop._UDPSendContext.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":55
+ * @cython.no_gc_clear
+ * cdef class UDPTransport(UVBaseTransport):
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._family = uv.AF_UNSPEC
+ *         self.__receiving = 0
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_12UDPTransport_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_12UDPTransport_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  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;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12UDPTransport___cinit__(((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_12UDPTransport___cinit__(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self) {
+  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);
+
+  /* "uvloop/handles/udp.pyx":56
+ * cdef class UDPTransport(UVBaseTransport):
+ *     def __cinit__(self):
+ *         self._family = uv.AF_UNSPEC             # <<<<<<<<<<<<<<
+ *         self.__receiving = 0
+ *         self._address = None
+ */
+  __pyx_v_self->_family = AF_UNSPEC;
+
+  /* "uvloop/handles/udp.pyx":57
+ *     def __cinit__(self):
+ *         self._family = uv.AF_UNSPEC
+ *         self.__receiving = 0             # <<<<<<<<<<<<<<
+ *         self._address = None
+ *         self.context = Context_CopyCurrent()
+ */
+  __pyx_v_self->__pyx___receiving = 0;
+
+  /* "uvloop/handles/udp.pyx":58
+ *         self._family = uv.AF_UNSPEC
+ *         self.__receiving = 0
+ *         self._address = None             # <<<<<<<<<<<<<<
+ *         self.context = Context_CopyCurrent()
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_address);
+  __Pyx_DECREF(__pyx_v_self->_address);
+  __pyx_v_self->_address = Py_None;
+
+  /* "uvloop/handles/udp.pyx":59
+ *         self.__receiving = 0
+ *         self._address = None
+ *         self.context = Context_CopyCurrent()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _init(self, Loop loop, unsigned int family):
+ */
+  __pyx_t_1 = Context_CopyCurrent(); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.context);
+  __Pyx_DECREF(__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.context);
+  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base.context = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/udp.pyx":55
+ * @cython.no_gc_clear
+ * cdef class UDPTransport(UVBaseTransport):
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self._family = uv.AF_UNSPEC
+ *         self.__receiving = 0
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":61
+ *         self.context = Context_CopyCurrent()
+ * 
+ *     cdef _init(self, Loop loop, unsigned int family):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__init(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, unsigned int __pyx_v_family) {
+  int __pyx_v_err;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  unsigned int __pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_init", 0);
+
+  /* "uvloop/handles/udp.pyx":64
+ *         cdef int err
+ * 
+ *         self._start_init(loop)             # <<<<<<<<<<<<<<
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_udp_t))
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._start_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/udp.pyx":66
+ *         self._start_init(loop)
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_udp_t))             # <<<<<<<<<<<<<<
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ */
+  __pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle = ((uv_handle_t *)PyMem_RawMalloc((sizeof(uv_udp_t))));
+
+  /* "uvloop/handles/udp.pyx":67
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_udp_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  __pyx_t_2 = ((__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle == NULL) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/udp.pyx":68
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_udp_t))
+ *         if self._handle is NULL:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise MemoryError()
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 68, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/udp.pyx":69
+ *         if self._handle is NULL:
+ *             self._abort_init()
+ *             raise MemoryError()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_udp_init_ex(loop.uvloop,
+ */
+    PyErr_NoMemory(); __PYX_ERR(23, 69, __pyx_L1_error)
+
+    /* "uvloop/handles/udp.pyx":67
+ * 
+ *         self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_udp_t))
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise MemoryError()
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":71
+ *             raise MemoryError()
+ * 
+ *         err = uv.uv_udp_init_ex(loop.uvloop,             # <<<<<<<<<<<<<<
+ *                                 <uv.uv_udp_t*>self._handle,
+ *                                 family)
+ */
+  __pyx_v_err = uv_udp_init_ex(__pyx_v_loop->uvloop, ((uv_udp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_v_family);
+
+  /* "uvloop/handles/udp.pyx":74
+ *                                 <uv.uv_udp_t*>self._handle,
+ *                                 family)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/udp.pyx":75
+ *                                 family)
+ *         if err < 0:
+ *             self._abort_init()             # <<<<<<<<<<<<<<
+ *             raise convert_error(err)
+ * 
+ */
+    __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._abort_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 75, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/handles/udp.pyx":76
+ *         if err < 0:
+ *             self._abort_init()
+ *             raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ *         if family in (uv.AF_INET, uv.AF_INET6):
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 76, __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(23, 76, __pyx_L1_error)
+
+    /* "uvloop/handles/udp.pyx":74
+ *                                 <uv.uv_udp_t*>self._handle,
+ *                                 family)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             self._abort_init()
+ *             raise convert_error(err)
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":78
+ *             raise convert_error(err)
+ * 
+ *         if family in (uv.AF_INET, uv.AF_INET6):             # <<<<<<<<<<<<<<
+ *             self._family = family
+ * 
+ */
+  __pyx_t_3 = __pyx_v_family;
+  __pyx_t_4 = ((__pyx_t_3 == AF_INET) != 0);
+  if (!__pyx_t_4) {
+  } else {
+    __pyx_t_2 = __pyx_t_4;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_4 = ((__pyx_t_3 == AF_INET6) != 0);
+  __pyx_t_2 = __pyx_t_4;
+  __pyx_L6_bool_binop_done:;
+  __pyx_t_4 = (__pyx_t_2 != 0);
+  if (__pyx_t_4) {
+
+    /* "uvloop/handles/udp.pyx":79
+ * 
+ *         if family in (uv.AF_INET, uv.AF_INET6):
+ *             self._family = family             # <<<<<<<<<<<<<<
+ * 
+ *         self._finish_init()
+ */
+    __pyx_v_self->_family = __pyx_v_family;
+
+    /* "uvloop/handles/udp.pyx":78
+ *             raise convert_error(err)
+ * 
+ *         if family in (uv.AF_INET, uv.AF_INET6):             # <<<<<<<<<<<<<<
+ *             self._family = family
+ * 
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":81
+ *             self._family = family
+ * 
+ *         self._finish_init()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _set_address(self, system.addrinfo *addr):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._finish_init(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/udp.pyx":61
+ *         self.context = Context_CopyCurrent()
+ * 
+ *     cdef _init(self, Loop loop, unsigned int family):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport._init", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":83
+ *         self._finish_init()
+ * 
+ *     cdef _set_address(self, system.addrinfo *addr):             # <<<<<<<<<<<<<<
+ *         self._address = __convert_sockaddr_to_pyaddr(addr.ai_addr)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__set_address(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, struct addrinfo *__pyx_v_addr) {
+  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("_set_address", 0);
+
+  /* "uvloop/handles/udp.pyx":84
+ * 
+ *     cdef _set_address(self, system.addrinfo *addr):
+ *         self._address = __convert_sockaddr_to_pyaddr(addr.ai_addr)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _connect(self, system.sockaddr* addr, size_t addr_len):
+ */
+  __pyx_t_1 = __pyx_f_6uvloop_4loop___convert_sockaddr_to_pyaddr(__pyx_v_addr->ai_addr); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_address);
+  __Pyx_DECREF(__pyx_v_self->_address);
+  __pyx_v_self->_address = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "uvloop/handles/udp.pyx":83
+ *         self._finish_init()
+ * 
+ *     cdef _set_address(self, system.addrinfo *addr):             # <<<<<<<<<<<<<<
+ *         self._address = __convert_sockaddr_to_pyaddr(addr.ai_addr)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport._set_address", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":86
+ *         self._address = __convert_sockaddr_to_pyaddr(addr.ai_addr)
+ * 
+ *     cdef _connect(self, system.sockaddr* addr, size_t addr_len):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         err = uv.uv_udp_connect(<uv.uv_udp_t*>self._handle, addr)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__connect(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr, CYTHON_UNUSED size_t __pyx_v_addr_len) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("_connect", 0);
+
+  /* "uvloop/handles/udp.pyx":88
+ *     cdef _connect(self, system.sockaddr* addr, size_t addr_len):
+ *         cdef int err
+ *         err = uv.uv_udp_connect(<uv.uv_udp_t*>self._handle, addr)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             exc = convert_error(err)
+ */
+  __pyx_v_err = uv_udp_connect(((uv_udp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_v_addr);
+
+  /* "uvloop/handles/udp.pyx":89
+ *         cdef int err
+ *         err = uv.uv_udp_connect(<uv.uv_udp_t*>self._handle, addr)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             raise exc
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/handles/udp.pyx":90
+ *         err = uv.uv_udp_connect(<uv.uv_udp_t*>self._handle, addr)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             raise exc
+ * 
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 90, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/udp.pyx":91
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             raise exc             # <<<<<<<<<<<<<<
+ * 
+ *     cdef open(self, int family, int sockfd):
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(23, 91, __pyx_L1_error)
+
+    /* "uvloop/handles/udp.pyx":89
+ *         cdef int err
+ *         err = uv.uv_udp_connect(<uv.uv_udp_t*>self._handle, addr)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             raise exc
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":86
+ *         self._address = __convert_sockaddr_to_pyaddr(addr.ai_addr)
+ * 
+ *     cdef _connect(self, system.sockaddr* addr, size_t addr_len):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ *         err = uv.uv_udp_connect(<uv.uv_udp_t*>self._handle, addr)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport._connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":93
+ *             raise exc
+ * 
+ *     cdef open(self, int family, int sockfd):             # <<<<<<<<<<<<<<
+ *         if family in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+ *             self._family = family
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport_open(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, int __pyx_v_family, int __pyx_v_sockfd) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("open", 0);
+
+  /* "uvloop/handles/udp.pyx":94
+ * 
+ *     cdef open(self, int family, int sockfd):
+ *         if family in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):             # <<<<<<<<<<<<<<
+ *             self._family = family
+ *         else:
+ */
+  __pyx_t_1 = __pyx_v_family;
+  __pyx_t_3 = ((__pyx_t_1 == AF_INET) != 0);
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_3 = ((__pyx_t_1 == AF_INET6) != 0);
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_3 = ((__pyx_t_1 == AF_UNIX) != 0);
+  __pyx_t_2 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (likely(__pyx_t_3)) {
+
+    /* "uvloop/handles/udp.pyx":95
+ *     cdef open(self, int family, int sockfd):
+ *         if family in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+ *             self._family = family             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise ValueError(
+ */
+    __pyx_v_self->_family = __pyx_v_family;
+
+    /* "uvloop/handles/udp.pyx":94
+ * 
+ *     cdef open(self, int family, int sockfd):
+ *         if family in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):             # <<<<<<<<<<<<<<
+ *             self._family = family
+ *         else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/udp.pyx":97
+ *             self._family = family
+ *         else:
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'cannot open a UDP handle, invalid family {}'.format(family))
+ * 
+ */
+  /*else*/ {
+
+    /* "uvloop/handles/udp.pyx":98
+ *         else:
+ *             raise ValueError(
+ *                 'cannot open a UDP handle, invalid family {}'.format(family))             # <<<<<<<<<<<<<<
+ * 
+ *         cdef int err
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cannot_open_a_UDP_handle_invalid, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 98, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_family); if (unlikely(!__pyx_t_6)) __PYX_ERR(23, 98, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(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_5, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6);
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 98, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/handles/udp.pyx":97
+ *             self._family = family
+ *         else:
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'cannot open a UDP handle, invalid family {}'.format(family))
+ * 
+ */
+    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 97, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __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(23, 97, __pyx_L1_error)
+  }
+  __pyx_L3:;
+
+  /* "uvloop/handles/udp.pyx":101
+ * 
+ *         cdef int err
+ *         err = uv.uv_udp_open(<uv.uv_udp_t*>self._handle,             # <<<<<<<<<<<<<<
+ *                              <uv.uv_os_sock_t>sockfd)
+ * 
+ */
+  __pyx_v_err = uv_udp_open(((uv_udp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), ((uv_os_sock_t)__pyx_v_sockfd));
+
+  /* "uvloop/handles/udp.pyx":104
+ *                              <uv.uv_os_sock_t>sockfd)
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             raise exc
+ */
+  __pyx_t_3 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/handles/udp.pyx":105
+ * 
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             raise exc
+ * 
+ */
+    __pyx_t_5 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 105, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_v_exc = __pyx_t_5;
+    __pyx_t_5 = 0;
+
+    /* "uvloop/handles/udp.pyx":106
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             raise exc             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _bind(self, system.sockaddr* addr):
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(23, 106, __pyx_L1_error)
+
+    /* "uvloop/handles/udp.pyx":104
+ *                              <uv.uv_os_sock_t>sockfd)
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             raise exc
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":93
+ *             raise exc
+ * 
+ *     cdef open(self, int family, int sockfd):             # <<<<<<<<<<<<<<
+ *         if family in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+ *             self._family = family
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport.open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":108
+ *             raise exc
+ * 
+ *     cdef _bind(self, system.sockaddr* addr):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int err
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__bind(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr) {
+  int __pyx_v_err;
+  int __pyx_v_flags;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_bind", 0);
+
+  /* "uvloop/handles/udp.pyx":111
+ *         cdef:
+ *             int err
+ *             int flags = 0             # <<<<<<<<<<<<<<
+ * 
+ *         self._ensure_alive()
+ */
+  __pyx_v_flags = 0;
+
+  /* "uvloop/handles/udp.pyx":113
+ *             int flags = 0
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_udp_bind(<uv.uv_udp_t*>self._handle, addr, flags)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/udp.pyx":115
+ *         self._ensure_alive()
+ * 
+ *         err = uv.uv_udp_bind(<uv.uv_udp_t*>self._handle, addr, flags)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             exc = convert_error(err)
+ */
+  __pyx_v_err = uv_udp_bind(((uv_udp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_v_addr, __pyx_v_flags);
+
+  /* "uvloop/handles/udp.pyx":116
+ * 
+ *         err = uv.uv_udp_bind(<uv.uv_udp_t*>self._handle, addr, flags)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             raise exc
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/udp.pyx":117
+ *         err = uv.uv_udp_bind(<uv.uv_udp_t*>self._handle, addr, flags)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             raise exc
+ * 
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 117, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/udp.pyx":118
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             raise exc             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _set_broadcast(self, bint on):
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(23, 118, __pyx_L1_error)
+
+    /* "uvloop/handles/udp.pyx":116
+ * 
+ *         err = uv.uv_udp_bind(<uv.uv_udp_t*>self._handle, addr, flags)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             raise exc
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":108
+ *             raise exc
+ * 
+ *     cdef _bind(self, system.sockaddr* addr):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             int err
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport._bind", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":120
+ *             raise exc
+ * 
+ *     cdef _set_broadcast(self, bint on):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__set_broadcast(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, int __pyx_v_on) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_set_broadcast", 0);
+
+  /* "uvloop/handles/udp.pyx":123
+ *         cdef int err
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_udp_set_broadcast(<uv.uv_udp_t*>self._handle, on)
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/udp.pyx":125
+ *         self._ensure_alive()
+ * 
+ *         err = uv.uv_udp_set_broadcast(<uv.uv_udp_t*>self._handle, on)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             exc = convert_error(err)
+ */
+  __pyx_v_err = uv_udp_set_broadcast(((uv_udp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_v_on);
+
+  /* "uvloop/handles/udp.pyx":126
+ * 
+ *         err = uv.uv_udp_set_broadcast(<uv.uv_udp_t*>self._handle, on)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             raise exc
+ */
+  __pyx_t_2 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/handles/udp.pyx":127
+ *         err = uv.uv_udp_set_broadcast(<uv.uv_udp_t*>self._handle, on)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             raise exc
+ * 
+ */
+    __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 127, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_exc = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/udp.pyx":128
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             raise exc             # <<<<<<<<<<<<<<
+ * 
+ *     cdef size_t _get_write_buffer_size(self):
+ */
+    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
+    __PYX_ERR(23, 128, __pyx_L1_error)
+
+    /* "uvloop/handles/udp.pyx":126
+ * 
+ *         err = uv.uv_udp_set_broadcast(<uv.uv_udp_t*>self._handle, on)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             raise exc
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":120
+ *             raise exc
+ * 
+ *     cdef _set_broadcast(self, bint on):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport._set_broadcast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":130
+ *             raise exc
+ * 
+ *     cdef size_t _get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         if self._handle is NULL:
+ *             return 0
+ */
+
+static size_t __pyx_f_6uvloop_4loop_12UDPTransport__get_write_buffer_size(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self) {
+  size_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("_get_write_buffer_size", 0);
+
+  /* "uvloop/handles/udp.pyx":131
+ * 
+ *     cdef size_t _get_write_buffer_size(self):
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             return 0
+ *         return (<uv.uv_udp_t*>self._handle).send_queue_size
+ */
+  __pyx_t_1 = ((__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":132
+ *     cdef size_t _get_write_buffer_size(self):
+ *         if self._handle is NULL:
+ *             return 0             # <<<<<<<<<<<<<<
+ *         return (<uv.uv_udp_t*>self._handle).send_queue_size
+ * 
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":131
+ * 
+ *     cdef size_t _get_write_buffer_size(self):
+ *         if self._handle is NULL:             # <<<<<<<<<<<<<<
+ *             return 0
+ *         return (<uv.uv_udp_t*>self._handle).send_queue_size
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":133
+ *         if self._handle is NULL:
+ *             return 0
+ *         return (<uv.uv_udp_t*>self._handle).send_queue_size             # <<<<<<<<<<<<<<
+ * 
+ *     cdef bint _is_reading(self):
+ */
+  __pyx_r = ((uv_udp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle)->send_queue_size;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/udp.pyx":130
+ *             raise exc
+ * 
+ *     cdef size_t _get_write_buffer_size(self):             # <<<<<<<<<<<<<<
+ *         if self._handle is NULL:
+ *             return 0
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":135
+ *         return (<uv.uv_udp_t*>self._handle).send_queue_size
+ * 
+ *     cdef bint _is_reading(self):             # <<<<<<<<<<<<<<
+ *         return self.__receiving
+ * 
+ */
+
+static int __pyx_f_6uvloop_4loop_12UDPTransport__is_reading(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_is_reading", 0);
+
+  /* "uvloop/handles/udp.pyx":136
+ * 
+ *     cdef bint _is_reading(self):
+ *         return self.__receiving             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _start_reading(self):
+ */
+  __pyx_r = __pyx_v_self->__pyx___receiving;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/udp.pyx":135
+ *         return (<uv.uv_udp_t*>self._handle).send_queue_size
+ * 
+ *     cdef bint _is_reading(self):             # <<<<<<<<<<<<<<
+ *         return self.__receiving
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":138
+ *         return self.__receiving
+ * 
+ *     cdef _start_reading(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__start_reading(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("_start_reading", 0);
+
+  /* "uvloop/handles/udp.pyx":141
+ *         cdef int err
+ * 
+ *         if self.__receiving:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx___receiving != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":142
+ * 
+ *         if self.__receiving:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._ensure_alive()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":141
+ *         cdef int err
+ * 
+ *         if self.__receiving:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":144
+ *             return
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_udp_recv_start(<uv.uv_udp_t*>self._handle,
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/udp.pyx":146
+ *         self._ensure_alive()
+ * 
+ *         err = uv.uv_udp_recv_start(<uv.uv_udp_t*>self._handle,             # <<<<<<<<<<<<<<
+ *                                    __loop_alloc_buffer,
+ *                                    __uv_udp_on_receive)
+ */
+  __pyx_v_err = uv_udp_recv_start(((uv_udp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), __pyx_f_6uvloop_4loop___loop_alloc_buffer, __pyx_f_6uvloop_4loop___uv_udp_on_receive);
+
+  /* "uvloop/handles/udp.pyx":150
+ *                                    __uv_udp_on_receive)
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":151
+ * 
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 151, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/udp.pyx":152
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ *         else:
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 152, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/udp.pyx":153
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ *         else:
+ *             # UDPTransport must live until the read callback is called
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":150
+ *                                    __uv_udp_on_receive)
+ * 
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":156
+ *         else:
+ *             # UDPTransport must live until the read callback is called
+ *             self.__receiving_started()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _stop_reading(self):
+ */
+  /*else*/ {
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_12UDPTransport___receiving_started(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 156, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+
+  /* "uvloop/handles/udp.pyx":138
+ *         return self.__receiving
+ * 
+ *     cdef _start_reading(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport._start_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":158
+ *             self.__receiving_started()
+ * 
+ *     cdef _stop_reading(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__stop_reading(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self) {
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = 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("_stop_reading", 0);
+
+  /* "uvloop/handles/udp.pyx":161
+ *         cdef int err
+ * 
+ *         if not self.__receiving:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = ((!(__pyx_v_self->__pyx___receiving != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":162
+ * 
+ *         if not self.__receiving:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._ensure_alive()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":161
+ *         cdef int err
+ * 
+ *         if not self.__receiving:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":164
+ *             return
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         err = uv.uv_udp_recv_stop(<uv.uv_udp_t*>self._handle)
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/udp.pyx":166
+ *         self._ensure_alive()
+ * 
+ *         err = uv.uv_udp_recv_stop(<uv.uv_udp_t*>self._handle)             # <<<<<<<<<<<<<<
+ *         if err < 0:
+ *             exc = convert_error(err)
+ */
+  __pyx_v_err = uv_udp_recv_stop(((uv_udp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle));
+
+  /* "uvloop/handles/udp.pyx":167
+ * 
+ *         err = uv.uv_udp_recv_stop(<uv.uv_udp_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":168
+ *         err = uv.uv_udp_recv_stop(<uv.uv_udp_t*>self._handle)
+ *         if err < 0:
+ *             exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *             self._fatal_error(exc, True)
+ *             return
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 168, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/udp.pyx":169
+ *         if err < 0:
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             return
+ *         else:
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 169, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/udp.pyx":170
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ *             return             # <<<<<<<<<<<<<<
+ *         else:
+ *             self.__receiving_stopped()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":167
+ * 
+ *         err = uv.uv_udp_recv_stop(<uv.uv_udp_t*>self._handle)
+ *         if err < 0:             # <<<<<<<<<<<<<<
+ *             exc = convert_error(err)
+ *             self._fatal_error(exc, True)
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":172
+ *             return
+ *         else:
+ *             self.__receiving_stopped()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline __receiving_started(self):
+ */
+  /*else*/ {
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_12UDPTransport___receiving_stopped(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 172, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+
+  /* "uvloop/handles/udp.pyx":158
+ *             self.__receiving_started()
+ * 
+ *     cdef _stop_reading(self):             # <<<<<<<<<<<<<<
+ *         cdef int err
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport._stop_reading", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":174
+ *             self.__receiving_stopped()
+ * 
+ *     cdef inline __receiving_started(self):             # <<<<<<<<<<<<<<
+ *         if self.__receiving:
+ *             return
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_12UDPTransport___receiving_started(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__receiving_started", 0);
+
+  /* "uvloop/handles/udp.pyx":175
+ * 
+ *     cdef inline __receiving_started(self):
+ *         if self.__receiving:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.__receiving = 1
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx___receiving != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":176
+ *     cdef inline __receiving_started(self):
+ *         if self.__receiving:
+ *             return             # <<<<<<<<<<<<<<
+ *         self.__receiving = 1
+ *         Py_INCREF(self)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":175
+ * 
+ *     cdef inline __receiving_started(self):
+ *         if self.__receiving:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.__receiving = 1
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":177
+ *         if self.__receiving:
+ *             return
+ *         self.__receiving = 1             # <<<<<<<<<<<<<<
+ *         Py_INCREF(self)
+ * 
+ */
+  __pyx_v_self->__pyx___receiving = 1;
+
+  /* "uvloop/handles/udp.pyx":178
+ *             return
+ *         self.__receiving = 1
+ *         Py_INCREF(self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline __receiving_stopped(self):
+ */
+  Py_INCREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/handles/udp.pyx":174
+ *             self.__receiving_stopped()
+ * 
+ *     cdef inline __receiving_started(self):             # <<<<<<<<<<<<<<
+ *         if self.__receiving:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":180
+ *         Py_INCREF(self)
+ * 
+ *     cdef inline __receiving_stopped(self):             # <<<<<<<<<<<<<<
+ *         if not self.__receiving:
+ *             return
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_12UDPTransport___receiving_stopped(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__receiving_stopped", 0);
+
+  /* "uvloop/handles/udp.pyx":181
+ * 
+ *     cdef inline __receiving_stopped(self):
+ *         if not self.__receiving:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.__receiving = 0
+ */
+  __pyx_t_1 = ((!(__pyx_v_self->__pyx___receiving != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":182
+ *     cdef inline __receiving_stopped(self):
+ *         if not self.__receiving:
+ *             return             # <<<<<<<<<<<<<<
+ *         self.__receiving = 0
+ *         Py_DECREF(self)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":181
+ * 
+ *     cdef inline __receiving_stopped(self):
+ *         if not self.__receiving:             # <<<<<<<<<<<<<<
+ *             return
+ *         self.__receiving = 0
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":183
+ *         if not self.__receiving:
+ *             return
+ *         self.__receiving = 0             # <<<<<<<<<<<<<<
+ *         Py_DECREF(self)
+ * 
+ */
+  __pyx_v_self->__pyx___receiving = 0;
+
+  /* "uvloop/handles/udp.pyx":184
+ *             return
+ *         self.__receiving = 0
+ *         Py_DECREF(self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _new_socket(self):
+ */
+  Py_DECREF(((PyObject *)__pyx_v_self));
+
+  /* "uvloop/handles/udp.pyx":180
+ *         Py_INCREF(self)
+ * 
+ *     cdef inline __receiving_stopped(self):             # <<<<<<<<<<<<<<
+ *         if not self.__receiving:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":186
+ *         Py_DECREF(self)
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+ *             raise RuntimeError(
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__new_socket(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self) {
+  PyObject *__pyx_v_fileno = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_new_socket", 0);
+
+  /* "uvloop/handles/udp.pyx":187
+ * 
+ *     cdef _new_socket(self):
+ *         if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'UDPTransport.family is undefined; '
+ */
+  __pyx_t_1 = __pyx_v_self->_family;
+  __pyx_t_3 = ((__pyx_t_1 != AF_INET) != 0);
+  if (__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_3 = ((__pyx_t_1 != AF_INET6) != 0);
+  if (__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_3 = ((__pyx_t_1 != AF_UNIX) != 0);
+  __pyx_t_2 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (unlikely(__pyx_t_3)) {
+
+    /* "uvloop/handles/udp.pyx":188
+ *     cdef _new_socket(self):
+ *         if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'UDPTransport.family is undefined; '
+ *                 'cannot create python socket')
+ */
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__224, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 188, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(23, 188, __pyx_L1_error)
+
+    /* "uvloop/handles/udp.pyx":187
+ * 
+ *     cdef _new_socket(self):
+ *         if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 'UDPTransport.family is undefined; '
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":192
+ *                 'cannot create python socket')
+ * 
+ *         fileno = self._fileno()             # <<<<<<<<<<<<<<
+ *         return PseudoSocket(self._family, uv.SOCK_DGRAM, 0, fileno)
+ * 
+ */
+  __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._fileno(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_v_fileno = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "uvloop/handles/udp.pyx":193
+ * 
+ *         fileno = self._fileno()
+ *         return PseudoSocket(self._family, uv.SOCK_DGRAM, 0, fileno)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _send(self, object data, object addr):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_self->_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyInt_From_int(SOCK_DGRAM); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(23, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_int_0);
+  __Pyx_INCREF(__pyx_v_fileno);
+  __Pyx_GIVEREF(__pyx_v_fileno);
+  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_v_fileno);
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_PseudoSocket), __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/handles/udp.pyx":186
+ *         Py_DECREF(self)
+ * 
+ *     cdef _new_socket(self):             # <<<<<<<<<<<<<<
+ *         if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+ *             raise RuntimeError(
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport._new_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fileno);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":195
+ *         return PseudoSocket(self._family, uv.SOCK_DGRAM, 0, fileno)
+ * 
+ *     cdef _send(self, object data, object addr):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             _UDPSendContext ctx
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__send(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_data, PyObject *__pyx_v_addr) {
+  struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_v_ctx = 0;
+  struct sockaddr_storage __pyx_v_saddr_st;
+  struct sockaddr *__pyx_v_saddr;
+  Py_buffer __pyx_v_try_pybuf;
+  uv_buf_t __pyx_v_try_uvbuf;
+  int __pyx_v_err;
+  PyObject *__pyx_v_exc = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __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;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  Py_ssize_t __pyx_t_12;
+  struct __pyx_opt_args_6uvloop_4loop_12UDPTransport__on_sent __pyx_t_13;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_send", 0);
+
+  /* "uvloop/handles/udp.pyx":203
+ *             uv.uv_buf_t     try_uvbuf
+ * 
+ *         self._ensure_alive()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._ensure_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 203, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/handles/udp.pyx":205
+ *         self._ensure_alive()
+ * 
+ *         if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('UDPTransport.family is undefined; cannot send')
+ * 
+ */
+  __pyx_t_2 = __pyx_v_self->_family;
+  __pyx_t_4 = ((__pyx_t_2 != AF_INET) != 0);
+  if (__pyx_t_4) {
+  } else {
+    __pyx_t_3 = __pyx_t_4;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_4 = ((__pyx_t_2 != AF_INET6) != 0);
+  if (__pyx_t_4) {
+  } else {
+    __pyx_t_3 = __pyx_t_4;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_4 = ((__pyx_t_2 != AF_UNIX) != 0);
+  __pyx_t_3 = __pyx_t_4;
+  __pyx_L4_bool_binop_done:;
+  __pyx_t_4 = (__pyx_t_3 != 0);
+  if (unlikely(__pyx_t_4)) {
+
+    /* "uvloop/handles/udp.pyx":206
+ * 
+ *         if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+ *             raise RuntimeError('UDPTransport.family is undefined; cannot send')             # <<<<<<<<<<<<<<
+ * 
+ *         if addr is None:
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__225, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 206, __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(23, 206, __pyx_L1_error)
+
+    /* "uvloop/handles/udp.pyx":205
+ *         self._ensure_alive()
+ * 
+ *         if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):             # <<<<<<<<<<<<<<
+ *             raise RuntimeError('UDPTransport.family is undefined; cannot send')
+ * 
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":208
+ *             raise RuntimeError('UDPTransport.family is undefined; cannot send')
+ * 
+ *         if addr is None:             # <<<<<<<<<<<<<<
+ *             saddr = NULL
+ *         else:
+ */
+  __pyx_t_4 = (__pyx_v_addr == Py_None);
+  __pyx_t_3 = (__pyx_t_4 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/udp.pyx":209
+ * 
+ *         if addr is None:
+ *             saddr = NULL             # <<<<<<<<<<<<<<
+ *         else:
+ *             try:
+ */
+    __pyx_v_saddr = NULL;
+
+    /* "uvloop/handles/udp.pyx":208
+ *             raise RuntimeError('UDPTransport.family is undefined; cannot send')
+ * 
+ *         if addr is None:             # <<<<<<<<<<<<<<
+ *             saddr = NULL
+ *         else:
+ */
+    goto __pyx_L7;
+  }
+
+  /* "uvloop/handles/udp.pyx":211
+ *             saddr = NULL
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 __convert_pyaddr_to_sockaddr(self._family, addr,
+ *                                              <system.sockaddr*>&saddr_st)
+ */
+  /*else*/ {
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      /*try:*/ {
+
+        /* "uvloop/handles/udp.pyx":212
+ *         else:
+ *             try:
+ *                 __convert_pyaddr_to_sockaddr(self._family, addr,             # <<<<<<<<<<<<<<
+ *                                              <system.sockaddr*>&saddr_st)
+ *             except (ValueError, TypeError):
+ */
+        __pyx_t_1 = __pyx_f_6uvloop_4loop___convert_pyaddr_to_sockaddr(__pyx_v_self->_family, __pyx_v_addr, ((struct sockaddr *)(&__pyx_v_saddr_st))); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 212, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+        /* "uvloop/handles/udp.pyx":211
+ *             saddr = NULL
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 __convert_pyaddr_to_sockaddr(self._family, addr,
+ *                                              <system.sockaddr*>&saddr_st)
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L13_try_end;
+      __pyx_L8_error:;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/udp.pyx":214
+ *                 __convert_pyaddr_to_sockaddr(self._family, addr,
+ *                                              <system.sockaddr*>&saddr_st)
+ *             except (ValueError, TypeError):             # <<<<<<<<<<<<<<
+ *                 raise
+ *             except Exception:
+ */
+      __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError);
+      if (__pyx_t_2) {
+        __Pyx_AddTraceback("uvloop.loop.UDPTransport._send", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(23, 214, __pyx_L10_except_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_9);
+
+        /* "uvloop/handles/udp.pyx":215
+ *                                              <system.sockaddr*>&saddr_st)
+ *             except (ValueError, TypeError):
+ *                 raise             # <<<<<<<<<<<<<<
+ *             except Exception:
+ *                 raise ValueError(
+ */
+        __Pyx_GIVEREF(__pyx_t_1);
+        __Pyx_GIVEREF(__pyx_t_8);
+        __Pyx_XGIVEREF(__pyx_t_9);
+        __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_8, __pyx_t_9);
+        __pyx_t_1 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; 
+        __PYX_ERR(23, 215, __pyx_L10_except_error)
+      }
+
+      /* "uvloop/handles/udp.pyx":216
+ *             except (ValueError, TypeError):
+ *                 raise
+ *             except Exception:             # <<<<<<<<<<<<<<
+ *                 raise ValueError(
+ *                     f'{addr!r}: socket family mismatch or '
+ */
+      __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+      if (__pyx_t_2) {
+        __Pyx_AddTraceback("uvloop.loop.UDPTransport._send", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_8, &__pyx_t_1) < 0) __PYX_ERR(23, 216, __pyx_L10_except_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_1);
+
+        /* "uvloop/handles/udp.pyx":218
+ *             except Exception:
+ *                 raise ValueError(
+ *                     f'{addr!r}: socket family mismatch or '             # <<<<<<<<<<<<<<
+ *                     f'a DNS lookup is required')
+ *             saddr = <system.sockaddr*>(&saddr_st)
+ */
+        __pyx_t_10 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_addr), __pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(23, 218, __pyx_L10_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __pyx_t_11 = __Pyx_PyUnicode_Concat(__pyx_t_10, __pyx_kp_u_socket_family_mismatch_or_a_DNS); if (unlikely(!__pyx_t_11)) __PYX_ERR(23, 218, __pyx_L10_except_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+        /* "uvloop/handles/udp.pyx":217
+ *                 raise
+ *             except Exception:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     f'{addr!r}: socket family mismatch or '
+ *                     f'a DNS lookup is required')
+ */
+        __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(23, 217, __pyx_L10_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_Raise(__pyx_t_10, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __PYX_ERR(23, 217, __pyx_L10_except_error)
+      }
+      goto __pyx_L10_except_error;
+      __pyx_L10_except_error:;
+
+      /* "uvloop/handles/udp.pyx":211
+ *             saddr = NULL
+ *         else:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 __convert_pyaddr_to_sockaddr(self._family, addr,
+ *                                              <system.sockaddr*>&saddr_st)
+ */
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
+      goto __pyx_L1_error;
+      __pyx_L13_try_end:;
+    }
+
+    /* "uvloop/handles/udp.pyx":220
+ *                     f'{addr!r}: socket family mismatch or '
+ *                     f'a DNS lookup is required')
+ *             saddr = <system.sockaddr*>(&saddr_st)             # <<<<<<<<<<<<<<
+ * 
+ *         if self._get_write_buffer_size() == 0:
+ */
+    __pyx_v_saddr = ((struct sockaddr *)(&__pyx_v_saddr_st));
+  }
+  __pyx_L7:;
+
+  /* "uvloop/handles/udp.pyx":222
+ *             saddr = <system.sockaddr*>(&saddr_st)
+ * 
+ *         if self._get_write_buffer_size() == 0:             # <<<<<<<<<<<<<<
+ *             PyObject_GetBuffer(data, &try_pybuf, PyBUF_SIMPLE)
+ *             try_uvbuf.base = <char*>try_pybuf.buf
+ */
+  __pyx_t_3 = ((((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._get_write_buffer_size(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)) == 0) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/udp.pyx":223
+ * 
+ *         if self._get_write_buffer_size() == 0:
+ *             PyObject_GetBuffer(data, &try_pybuf, PyBUF_SIMPLE)             # <<<<<<<<<<<<<<
+ *             try_uvbuf.base = <char*>try_pybuf.buf
+ *             try_uvbuf.len = try_pybuf.len
+ */
+    __pyx_t_2 = PyObject_GetBuffer(__pyx_v_data, (&__pyx_v_try_pybuf), PyBUF_SIMPLE); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(23, 223, __pyx_L1_error)
+
+    /* "uvloop/handles/udp.pyx":224
+ *         if self._get_write_buffer_size() == 0:
+ *             PyObject_GetBuffer(data, &try_pybuf, PyBUF_SIMPLE)
+ *             try_uvbuf.base = <char*>try_pybuf.buf             # <<<<<<<<<<<<<<
+ *             try_uvbuf.len = try_pybuf.len
+ *             err = uv.uv_udp_try_send(<uv.uv_udp_t*>self._handle,
+ */
+    __pyx_v_try_uvbuf.base = ((char *)__pyx_v_try_pybuf.buf);
+
+    /* "uvloop/handles/udp.pyx":225
+ *             PyObject_GetBuffer(data, &try_pybuf, PyBUF_SIMPLE)
+ *             try_uvbuf.base = <char*>try_pybuf.buf
+ *             try_uvbuf.len = try_pybuf.len             # <<<<<<<<<<<<<<
+ *             err = uv.uv_udp_try_send(<uv.uv_udp_t*>self._handle,
+ *                                      &try_uvbuf,
+ */
+    __pyx_t_12 = __pyx_v_try_pybuf.len;
+    __pyx_v_try_uvbuf.len = __pyx_t_12;
+
+    /* "uvloop/handles/udp.pyx":226
+ *             try_uvbuf.base = <char*>try_pybuf.buf
+ *             try_uvbuf.len = try_pybuf.len
+ *             err = uv.uv_udp_try_send(<uv.uv_udp_t*>self._handle,             # <<<<<<<<<<<<<<
+ *                                      &try_uvbuf,
+ *                                      1,
+ */
+    __pyx_v_err = uv_udp_try_send(((uv_udp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), (&__pyx_v_try_uvbuf), 1, __pyx_v_saddr);
+
+    /* "uvloop/handles/udp.pyx":230
+ *                                      1,
+ *                                      saddr)
+ *             PyBuffer_Release(&try_pybuf)             # <<<<<<<<<<<<<<
+ *         else:
+ *             err = uv.UV_EAGAIN
+ */
+    PyBuffer_Release((&__pyx_v_try_pybuf));
+
+    /* "uvloop/handles/udp.pyx":222
+ *             saddr = <system.sockaddr*>(&saddr_st)
+ * 
+ *         if self._get_write_buffer_size() == 0:             # <<<<<<<<<<<<<<
+ *             PyObject_GetBuffer(data, &try_pybuf, PyBUF_SIMPLE)
+ *             try_uvbuf.base = <char*>try_pybuf.buf
+ */
+    goto __pyx_L18;
+  }
+
+  /* "uvloop/handles/udp.pyx":232
+ *             PyBuffer_Release(&try_pybuf)
+ *         else:
+ *             err = uv.UV_EAGAIN             # <<<<<<<<<<<<<<
+ * 
+ *         if err == uv.UV_EAGAIN:
+ */
+  /*else*/ {
+    __pyx_v_err = UV_EAGAIN;
+  }
+  __pyx_L18:;
+
+  /* "uvloop/handles/udp.pyx":234
+ *             err = uv.UV_EAGAIN
+ * 
+ *         if err == uv.UV_EAGAIN:             # <<<<<<<<<<<<<<
+ *             ctx = _UDPSendContext.new(self, data)
+ *             err = uv.uv_udp_send(&ctx.req,
+ */
+  __pyx_t_3 = ((__pyx_v_err == UV_EAGAIN) != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/handles/udp.pyx":235
+ * 
+ *         if err == uv.UV_EAGAIN:
+ *             ctx = _UDPSendContext.new(self, data)             # <<<<<<<<<<<<<<
+ *             err = uv.uv_udp_send(&ctx.req,
+ *                                  <uv.uv_udp_t*>self._handle,
+ */
+    __pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_15_UDPSendContext_new(__pyx_v_self, __pyx_v_data)); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 235, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_ctx = ((struct __pyx_obj_6uvloop_4loop__UDPSendContext *)__pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "uvloop/handles/udp.pyx":236
+ *         if err == uv.UV_EAGAIN:
+ *             ctx = _UDPSendContext.new(self, data)
+ *             err = uv.uv_udp_send(&ctx.req,             # <<<<<<<<<<<<<<
+ *                                  <uv.uv_udp_t*>self._handle,
+ *                                  &ctx.uv_buf,
+ */
+    __pyx_v_err = uv_udp_send((&__pyx_v_ctx->req), ((uv_udp_t *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base._handle), (&__pyx_v_ctx->uv_buf), 1, __pyx_v_saddr, __pyx_f_6uvloop_4loop___uv_udp_on_send);
+
+    /* "uvloop/handles/udp.pyx":243
+ *                                  __uv_udp_on_send)
+ * 
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 ctx.close()
+ * 
+ */
+    __pyx_t_3 = ((__pyx_v_err < 0) != 0);
+    if (__pyx_t_3) {
+
+      /* "uvloop/handles/udp.pyx":244
+ * 
+ *             if err < 0:
+ *                 ctx.close()             # <<<<<<<<<<<<<<
+ * 
+ *                 exc = convert_error(err)
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop__UDPSendContext *)__pyx_v_ctx->__pyx_vtab)->close(__pyx_v_ctx); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 244, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/udp.pyx":246
+ *                 ctx.close()
+ * 
+ *                 exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, True)
+ *             else:
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 246, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_v_exc = __pyx_t_1;
+      __pyx_t_1 = 0;
+
+      /* "uvloop/handles/udp.pyx":247
+ * 
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 self._maybe_pause_protocol()
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 247, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/udp.pyx":243
+ *                                  __uv_udp_on_send)
+ * 
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 ctx.close()
+ * 
+ */
+      goto __pyx_L20;
+    }
+
+    /* "uvloop/handles/udp.pyx":249
+ *                 self._fatal_error(exc, True)
+ *             else:
+ *                 self._maybe_pause_protocol()             # <<<<<<<<<<<<<<
+ * 
+ *         else:
+ */
+    /*else*/ {
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._maybe_pause_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 249, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    }
+    __pyx_L20:;
+
+    /* "uvloop/handles/udp.pyx":234
+ *             err = uv.UV_EAGAIN
+ * 
+ *         if err == uv.UV_EAGAIN:             # <<<<<<<<<<<<<<
+ *             ctx = _UDPSendContext.new(self, data)
+ *             err = uv.uv_udp_send(&ctx.req,
+ */
+    goto __pyx_L19;
+  }
+
+  /* "uvloop/handles/udp.pyx":252
+ * 
+ *         else:
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+  /*else*/ {
+    __pyx_t_3 = ((__pyx_v_err < 0) != 0);
+    if (__pyx_t_3) {
+
+      /* "uvloop/handles/udp.pyx":253
+ *         else:
+ *             if err < 0:
+ *                 exc = convert_error(err)             # <<<<<<<<<<<<<<
+ *                 self._fatal_error(exc, True)
+ *             else:
+ */
+      __pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 253, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_v_exc = __pyx_t_1;
+      __pyx_t_1 = 0;
+
+      /* "uvloop/handles/udp.pyx":254
+ *             if err < 0:
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 self._on_sent(None, self.context.copy())
+ */
+      __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_True, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 254, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "uvloop/handles/udp.pyx":252
+ * 
+ *         else:
+ *             if err < 0:             # <<<<<<<<<<<<<<
+ *                 exc = convert_error(err)
+ *                 self._fatal_error(exc, True)
+ */
+      goto __pyx_L21;
+    }
+
+    /* "uvloop/handles/udp.pyx":256
+ *                 self._fatal_error(exc, True)
+ *             else:
+ *                 self._on_sent(None, self.context.copy())             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_receive(self, bytes data, object exc, object addr):
+ */
+    /*else*/ {
+      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.context, __pyx_n_s_copy); if (unlikely(!__pyx_t_8)) __PYX_ERR(23, 256, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __pyx_t_9 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+        __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+        if (likely(__pyx_t_9)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+          __Pyx_INCREF(__pyx_t_9);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_8, function);
+        }
+      }
+      __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_8);
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 256, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __pyx_t_13.__pyx_n = 1;
+      __pyx_t_13.context = __pyx_t_1;
+      __pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_on_sent(__pyx_v_self, Py_None, &__pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(23, 256, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    }
+    __pyx_L21:;
+  }
+  __pyx_L19:;
+
+  /* "uvloop/handles/udp.pyx":195
+ *         return PseudoSocket(self._family, uv.SOCK_DGRAM, 0, fileno)
+ * 
+ *     cdef _send(self, object data, object addr):             # <<<<<<<<<<<<<<
+ *         cdef:
+ *             _UDPSendContext ctx
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport._send", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_ctx);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":258
+ *                 self._on_sent(None, self.context.copy())
+ * 
+ *     cdef _on_receive(self, bytes data, object exc, object addr):             # <<<<<<<<<<<<<<
+ *         if exc is None:
+ *             run_in_context2(
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__on_receive(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_data, PyObject *__pyx_v_exc, PyObject *__pyx_v_addr) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  __Pyx_RefNannySetupContext("_on_receive", 0);
+
+  /* "uvloop/handles/udp.pyx":259
+ * 
+ *     cdef _on_receive(self, bytes data, object exc, object addr):
+ *         if exc is None:             # <<<<<<<<<<<<<<
+ *             run_in_context2(
+ *                 self.context, self._protocol.datagram_received, data, addr,
+ */
+  __pyx_t_1 = (__pyx_v_exc == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/udp.pyx":261
+ *         if exc is None:
+ *             run_in_context2(
+ *                 self.context, self._protocol.datagram_received, data, addr,             # <<<<<<<<<<<<<<
+ *             )
+ *         else:
+ */
+    __pyx_t_3 = __pyx_v_self->__pyx_base.__pyx_base.__pyx_base.context;
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base._protocol, __pyx_n_s_datagram_received); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 261, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "uvloop/handles/udp.pyx":260
+ *     cdef _on_receive(self, bytes data, object exc, object addr):
+ *         if exc is None:
+ *             run_in_context2(             # <<<<<<<<<<<<<<
+ *                 self.context, self._protocol.datagram_received, data, addr,
+ *             )
+ */
+    __pyx_t_5 = __pyx_f_6uvloop_4loop_run_in_context2(__pyx_t_3, __pyx_t_4, __pyx_v_data, __pyx_v_addr); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 260, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "uvloop/handles/udp.pyx":259
+ * 
+ *     cdef _on_receive(self, bytes data, object exc, object addr):
+ *         if exc is None:             # <<<<<<<<<<<<<<
+ *             run_in_context2(
+ *                 self.context, self._protocol.datagram_received, data, addr,
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/handles/udp.pyx":264
+ *             )
+ *         else:
+ *             run_in_context1(self.context, self._protocol.error_received, exc)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _on_sent(self, object exc, object context=None):
+ */
+  /*else*/ {
+    __pyx_t_5 = __pyx_v_self->__pyx_base.__pyx_base.__pyx_base.context;
+    __Pyx_INCREF(__pyx_t_5);
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base._protocol, __pyx_n_s_error_received); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 264, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = __pyx_f_6uvloop_4loop_run_in_context1(__pyx_t_5, __pyx_t_4, __pyx_v_exc); if (unlikely(!__pyx_t_3)) __PYX_ERR(23, 264, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __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_L3:;
+
+  /* "uvloop/handles/udp.pyx":258
+ *                 self._on_sent(None, self.context.copy())
+ * 
+ *     cdef _on_receive(self, bytes data, object exc, object addr):             # <<<<<<<<<<<<<<
+ *         if exc is None:
+ *             run_in_context2(
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport._on_receive", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":266
+ *             run_in_context1(self.context, self._protocol.error_received, exc)
+ * 
+ *     cdef _on_sent(self, object exc, object context=None):             # <<<<<<<<<<<<<<
+ *         if exc is not None:
+ *             if isinstance(exc, OSError):
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__on_sent(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_exc, struct __pyx_opt_args_6uvloop_4loop_12UDPTransport__on_sent *__pyx_optional_args) {
+  PyObject *__pyx_v_context = ((PyObject *)Py_None);
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_on_sent", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_context = __pyx_optional_args->context;
+    }
+  }
+  __Pyx_INCREF(__pyx_v_context);
+
+  /* "uvloop/handles/udp.pyx":267
+ * 
+ *     cdef _on_sent(self, object exc, object context=None):
+ *         if exc is not None:             # <<<<<<<<<<<<<<
+ *             if isinstance(exc, OSError):
+ *                 if context is None:
+ */
+  __pyx_t_1 = (__pyx_v_exc != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/udp.pyx":268
+ *     cdef _on_sent(self, object exc, object context=None):
+ *         if exc is not None:
+ *             if isinstance(exc, OSError):             # <<<<<<<<<<<<<<
+ *                 if context is None:
+ *                     context = self.context
+ */
+    __pyx_t_2 = PyObject_IsInstance(__pyx_v_exc, __pyx_builtin_OSError); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(23, 268, __pyx_L1_error)
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/udp.pyx":269
+ *         if exc is not None:
+ *             if isinstance(exc, OSError):
+ *                 if context is None:             # <<<<<<<<<<<<<<
+ *                     context = self.context
+ *                 run_in_context1(context, self._protocol.error_received, exc)
+ */
+      __pyx_t_1 = (__pyx_v_context == Py_None);
+      __pyx_t_2 = (__pyx_t_1 != 0);
+      if (__pyx_t_2) {
+
+        /* "uvloop/handles/udp.pyx":270
+ *             if isinstance(exc, OSError):
+ *                 if context is None:
+ *                     context = self.context             # <<<<<<<<<<<<<<
+ *                 run_in_context1(context, self._protocol.error_received, exc)
+ *             else:
+ */
+        __pyx_t_3 = __pyx_v_self->__pyx_base.__pyx_base.__pyx_base.context;
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_DECREF_SET(__pyx_v_context, __pyx_t_3);
+        __pyx_t_3 = 0;
+
+        /* "uvloop/handles/udp.pyx":269
+ *         if exc is not None:
+ *             if isinstance(exc, OSError):
+ *                 if context is None:             # <<<<<<<<<<<<<<
+ *                     context = self.context
+ *                 run_in_context1(context, self._protocol.error_received, exc)
+ */
+      }
+
+      /* "uvloop/handles/udp.pyx":271
+ *                 if context is None:
+ *                     context = self.context
+ *                 run_in_context1(context, self._protocol.error_received, exc)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 self._fatal_error(
+ */
+      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base._protocol, __pyx_n_s_error_received); if (unlikely(!__pyx_t_3)) __PYX_ERR(23, 271, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = __pyx_f_6uvloop_4loop_run_in_context1(__pyx_v_context, __pyx_t_3, __pyx_v_exc); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 271, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/handles/udp.pyx":268
+ *     cdef _on_sent(self, object exc, object context=None):
+ *         if exc is not None:
+ *             if isinstance(exc, OSError):             # <<<<<<<<<<<<<<
+ *                 if context is None:
+ *                     context = self.context
+ */
+      goto __pyx_L4;
+    }
+
+    /* "uvloop/handles/udp.pyx":273
+ *                 run_in_context1(context, self._protocol.error_received, exc)
+ *             else:
+ *                 self._fatal_error(             # <<<<<<<<<<<<<<
+ *                     exc, False, 'Fatal write error on datagram transport')
+ * 
+ */
+    /*else*/ {
+
+      /* "uvloop/handles/udp.pyx":274
+ *             else:
+ *                 self._fatal_error(
+ *                     exc, False, 'Fatal write error on datagram transport')             # <<<<<<<<<<<<<<
+ * 
+ *         self._maybe_resume_protocol()
+ */
+      __pyx_t_5.__pyx_n = 1;
+      __pyx_t_5.reason = __pyx_kp_u_Fatal_write_error_on_datagram_tr;
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._fatal_error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self), __pyx_v_exc, Py_False, &__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 273, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __pyx_L4:;
+
+    /* "uvloop/handles/udp.pyx":267
+ * 
+ *     cdef _on_sent(self, object exc, object context=None):
+ *         if exc is not None:             # <<<<<<<<<<<<<<
+ *             if isinstance(exc, OSError):
+ *                 if context is None:
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":276
+ *                     exc, False, 'Fatal write error on datagram transport')
+ * 
+ *         self._maybe_resume_protocol()             # <<<<<<<<<<<<<<
+ *         if not self._get_write_buffer_size():
+ *             if self._closing:
+ */
+  __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._maybe_resume_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 276, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "uvloop/handles/udp.pyx":277
+ * 
+ *         self._maybe_resume_protocol()
+ *         if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *             if self._closing:
+ *                 self._schedule_call_connection_lost(None)
+ */
+  __pyx_t_2 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._get_write_buffer_size(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self)) != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/udp.pyx":278
+ *         self._maybe_resume_protocol()
+ *         if not self._get_write_buffer_size():
+ *             if self._closing:             # <<<<<<<<<<<<<<
+ *                 self._schedule_call_connection_lost(None)
+ * 
+ */
+    __pyx_t_2 = (__pyx_v_self->__pyx_base._closing != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/handles/udp.pyx":279
+ *         if not self._get_write_buffer_size():
+ *             if self._closing:
+ *                 self._schedule_call_connection_lost(None)             # <<<<<<<<<<<<<<
+ * 
+ *     # === Public API ===
+ */
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._schedule_call_connection_lost(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_v_self), Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 279, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/handles/udp.pyx":278
+ *         self._maybe_resume_protocol()
+ *         if not self._get_write_buffer_size():
+ *             if self._closing:             # <<<<<<<<<<<<<<
+ *                 self._schedule_call_connection_lost(None)
+ * 
+ */
+    }
+
+    /* "uvloop/handles/udp.pyx":277
+ * 
+ *         self._maybe_resume_protocol()
+ *         if not self._get_write_buffer_size():             # <<<<<<<<<<<<<<
+ *             if self._closing:
+ *                 self._schedule_call_connection_lost(None)
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":266
+ *             run_in_context1(self.context, self._protocol.error_received, exc)
+ * 
+ *     cdef _on_sent(self, object exc, object context=None):             # <<<<<<<<<<<<<<
+ *         if exc is not None:
+ *             if isinstance(exc, OSError):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport._on_sent", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_context);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":283
+ *     # === Public API ===
+ * 
+ *     def sendto(self, data, addr=None):             # <<<<<<<<<<<<<<
+ *         if not data:
+ *             # Replicating asyncio logic here.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12UDPTransport_3sendto(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12UDPTransport_2sendto[] = "UDPTransport.sendto(self, data, addr=None)";
+static PyObject *__pyx_pw_6uvloop_4loop_12UDPTransport_3sendto(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_data = 0;
+  PyObject *__pyx_v_addr = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("sendto (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,&__pyx_n_s_addr,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)Py_None);
+    if (unlikely(__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);
+        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_data)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_addr);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "sendto") < 0)) __PYX_ERR(23, 283, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_data = values[0];
+    __pyx_v_addr = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("sendto", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(23, 283, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport.sendto", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_12UDPTransport_2sendto(((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_v_self), __pyx_v_data, __pyx_v_addr);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12UDPTransport_2sendto(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_data, PyObject *__pyx_v_addr) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  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;
+  __Pyx_RefNannySetupContext("sendto", 0);
+  __Pyx_INCREF(__pyx_v_addr);
+
+  /* "uvloop/handles/udp.pyx":284
+ * 
+ *     def sendto(self, data, addr=None):
+ *         if not data:             # <<<<<<<<<<<<<<
+ *             # Replicating asyncio logic here.
+ *             return
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_data); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(23, 284, __pyx_L1_error)
+  __pyx_t_2 = ((!__pyx_t_1) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/udp.pyx":286
+ *         if not data:
+ *             # Replicating asyncio logic here.
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         if self._address:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":284
+ * 
+ *     def sendto(self, data, addr=None):
+ *         if not data:             # <<<<<<<<<<<<<<
+ *             # Replicating asyncio logic here.
+ *             return
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":288
+ *             return
+ * 
+ *         if self._address:             # <<<<<<<<<<<<<<
+ *             if addr not in (None, self._address):
+ *                 # Replicating asyncio logic here.
+ */
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_self->_address); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(23, 288, __pyx_L1_error)
+  if (__pyx_t_2) {
+
+    /* "uvloop/handles/udp.pyx":289
+ * 
+ *         if self._address:
+ *             if addr not in (None, self._address):             # <<<<<<<<<<<<<<
+ *                 # Replicating asyncio logic here.
+ *                 raise ValueError(
+ */
+    __Pyx_INCREF(__pyx_v_addr);
+    __pyx_t_3 = __pyx_v_addr;
+    __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 289, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(23, 289, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (__pyx_t_1) {
+    } else {
+      __pyx_t_2 = __pyx_t_1;
+      goto __pyx_L6_bool_binop_done;
+    }
+    __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_self->_address, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 289, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(23, 289, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_2 = __pyx_t_1;
+    __pyx_L6_bool_binop_done:;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "uvloop/handles/udp.pyx":292
+ *                 # Replicating asyncio logic here.
+ *                 raise ValueError(
+ *                     'Invalid address: must be None or %s' % (self._address,))             # <<<<<<<<<<<<<<
+ * 
+ *             # Instead of setting addr to self._address below like what asyncio
+ */
+      __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Unicode(__pyx_v_self->_address), __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(23, 292, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Invalid_address_must_be_None_or, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 292, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/udp.pyx":291
+ *             if addr not in (None, self._address):
+ *                 # Replicating asyncio logic here.
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'Invalid address: must be None or %s' % (self._address,))
+ * 
+ */
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(23, 291, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(23, 291, __pyx_L1_error)
+
+      /* "uvloop/handles/udp.pyx":289
+ * 
+ *         if self._address:
+ *             if addr not in (None, self._address):             # <<<<<<<<<<<<<<
+ *                 # Replicating asyncio logic here.
+ *                 raise ValueError(
+ */
+    }
+
+    /* "uvloop/handles/udp.pyx":296
+ *             # Instead of setting addr to self._address below like what asyncio
+ *             # does, we depend on previous uv_udp_connect() to set the address
+ *             addr = None             # <<<<<<<<<<<<<<
+ * 
+ *         if self._conn_lost:
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_DECREF_SET(__pyx_v_addr, Py_None);
+
+    /* "uvloop/handles/udp.pyx":288
+ *             return
+ * 
+ *         if self._address:             # <<<<<<<<<<<<<<
+ *             if addr not in (None, self._address):
+ *                 # Replicating asyncio logic here.
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":298
+ *             addr = None
+ * 
+ *         if self._conn_lost:             # <<<<<<<<<<<<<<
+ *             # Replicating asyncio logic here.
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+ */
+  __pyx_t_1 = (__pyx_v_self->__pyx_base._conn_lost != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":300
+ *         if self._conn_lost:
+ *             # Replicating asyncio logic here.
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:             # <<<<<<<<<<<<<<
+ *                 aio_logger.warning('socket.send() raised exception.')
+ *             self._conn_lost += 1
+ */
+    __pyx_t_1 = ((__pyx_v_self->__pyx_base._conn_lost >= 5) != 0);
+    if (__pyx_t_1) {
+
+      /* "uvloop/handles/udp.pyx":301
+ *             # Replicating asyncio logic here.
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+ *                 aio_logger.warning('socket.send() raised exception.')             # <<<<<<<<<<<<<<
+ *             self._conn_lost += 1
+ *             return
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_warning); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 301, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_kp_u_socket_send_raised_exception) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_socket_send_raised_exception);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(23, 301, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/handles/udp.pyx":300
+ *         if self._conn_lost:
+ *             # Replicating asyncio logic here.
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:             # <<<<<<<<<<<<<<
+ *                 aio_logger.warning('socket.send() raised exception.')
+ *             self._conn_lost += 1
+ */
+    }
+
+    /* "uvloop/handles/udp.pyx":302
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+ *                 aio_logger.warning('socket.send() raised exception.')
+ *             self._conn_lost += 1             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+    __pyx_v_self->__pyx_base._conn_lost = (__pyx_v_self->__pyx_base._conn_lost + 1);
+
+    /* "uvloop/handles/udp.pyx":303
+ *                 aio_logger.warning('socket.send() raised exception.')
+ *             self._conn_lost += 1
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._send(data, addr)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":298
+ *             addr = None
+ * 
+ *         if self._conn_lost:             # <<<<<<<<<<<<<<
+ *             # Replicating asyncio logic here.
+ *             if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":305
+ *             return
+ * 
+ *         self._send(data, addr)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_send(__pyx_v_self, __pyx_v_data, __pyx_v_addr); if (unlikely(!__pyx_t_3)) __PYX_ERR(23, 305, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/handles/udp.pyx":283
+ *     # === Public API ===
+ * 
+ *     def sendto(self, data, addr=None):             # <<<<<<<<<<<<<<
+ *         if not data:
+ *             # Replicating asyncio logic here.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport.sendto", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_addr);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_12UDPTransport_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12UDPTransport_4__reduce_cython__[] = "UDPTransport.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_12UDPTransport_5__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_6uvloop_4loop_12UDPTransport_4__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12UDPTransport_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UDPTransport *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__226, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport.__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_6uvloop_4loop_12UDPTransport_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_12UDPTransport_6__setstate_cython__[] = "UDPTransport.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_12UDPTransport_7__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_6uvloop_4loop_12UDPTransport_6__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_12UDPTransport_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UDPTransport *__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);
+
+  /* "(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__227, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.UDPTransport.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/handles/udp.pyx":308
+ * 
+ * 
+ * cdef void __uv_udp_on_receive(uv.uv_udp_t* handle,             # <<<<<<<<<<<<<<
+ *                               ssize_t nread,
+ *                               const uv.uv_buf_t* buf,
+ */
+
+static void __pyx_f_6uvloop_4loop___uv_udp_on_receive(uv_udp_t *__pyx_v_handle, Py_ssize_t __pyx_v_nread, CYTHON_UNUSED uv_buf_t const *__pyx_v_buf, struct sockaddr const *__pyx_v_addr, CYTHON_UNUSED unsigned int __pyx_v_flags) {
+  struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_udp = 0;
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
+  PyObject *__pyx_v_data = 0;
+  PyObject *__pyx_v_pyaddr = 0;
+  PyObject *__pyx_v_exc = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  char const *__pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  char const *__pyx_t_19;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uv_udp_on_receive", 0);
+
+  /* "uvloop/handles/udp.pyx":315
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,
+ *                             "UDPTransport receive callback") == 0:             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+  __pyx_t_1 = ((__pyx_f_6uvloop_4loop___ensure_handle_data(((uv_handle_t *)__pyx_v_handle), ((char const *)"UDPTransport receive callback")) == 0) != 0);
+
+  /* "uvloop/handles/udp.pyx":314
+ *                               unsigned flags) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,             # <<<<<<<<<<<<<<
+ *                             "UDPTransport receive callback") == 0:
+ *         return
+ */
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":316
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,
+ *                             "UDPTransport receive callback") == 0:
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":314
+ *                               unsigned flags) with gil:
+ * 
+ *     if __ensure_handle_data(<uv.uv_handle_t*>handle,             # <<<<<<<<<<<<<<
+ *                             "UDPTransport receive callback") == 0:
+ *         return
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":319
+ * 
+ *     cdef:
+ *         UDPTransport udp = <UDPTransport>handle.data             # <<<<<<<<<<<<<<
+ *         Loop loop = udp._loop
+ *         bytes data
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_handle->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_udp = ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/udp.pyx":320
+ *     cdef:
+ *         UDPTransport udp = <UDPTransport>handle.data
+ *         Loop loop = udp._loop             # <<<<<<<<<<<<<<
+ *         bytes data
+ *         object pyaddr
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base._loop);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/udp.pyx":326
+ *     # It's OK to free the buffer early, since nothing will
+ *     # be able to touch it until this method is done.
+ *     __loop_free_buffer(loop)             # <<<<<<<<<<<<<<
+ * 
+ *     if udp._closed:
+ */
+  __pyx_f_6uvloop_4loop___loop_free_buffer(__pyx_v_loop);
+
+  /* "uvloop/handles/udp.pyx":328
+ *     __loop_free_buffer(loop)
+ * 
+ *     if udp._closed:             # <<<<<<<<<<<<<<
+ *         # The handle was closed, there is no reason to
+ *         # do any work now.
+ */
+  __pyx_t_1 = (__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base._closed != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":331
+ *         # The handle was closed, there is no reason to
+ *         # do any work now.
+ *         udp.__receiving_stopped()  # Just in case.             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_12UDPTransport___receiving_stopped(__pyx_v_udp); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 331, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/udp.pyx":332
+ *         # do any work now.
+ *         udp.__receiving_stopped()  # Just in case.
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     if addr is NULL and nread == 0:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":328
+ *     __loop_free_buffer(loop)
+ * 
+ *     if udp._closed:             # <<<<<<<<<<<<<<
+ *         # The handle was closed, there is no reason to
+ *         # do any work now.
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":334
+ *         return
+ * 
+ *     if addr is NULL and nread == 0:             # <<<<<<<<<<<<<<
+ *         # From libuv docs:
+ *         #      addr: struct sockaddr* containing the address
+ */
+  __pyx_t_3 = ((__pyx_v_addr == NULL) != 0);
+  if (__pyx_t_3) {
+  } else {
+    __pyx_t_1 = __pyx_t_3;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_3 = ((__pyx_v_nread == 0) != 0);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L6_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":345
+ *         #      addr != NULL when an empty UDP packet is
+ *         #      received.
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     if addr is NULL:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":334
+ *         return
+ * 
+ *     if addr is NULL and nread == 0:             # <<<<<<<<<<<<<<
+ *         # From libuv docs:
+ *         #      addr: struct sockaddr* containing the address
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":347
+ *         return
+ * 
+ *     if addr is NULL:             # <<<<<<<<<<<<<<
+ *         pyaddr = None
+ *     elif addr.sa_family == uv.AF_UNSPEC:
+ */
+  __pyx_t_1 = ((__pyx_v_addr == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":348
+ * 
+ *     if addr is NULL:
+ *         pyaddr = None             # <<<<<<<<<<<<<<
+ *     elif addr.sa_family == uv.AF_UNSPEC:
+ *         # https://github.com/MagicStack/uvloop/issues/304
+ */
+    __Pyx_INCREF(Py_None);
+    __pyx_v_pyaddr = Py_None;
+
+    /* "uvloop/handles/udp.pyx":347
+ *         return
+ * 
+ *     if addr is NULL:             # <<<<<<<<<<<<<<
+ *         pyaddr = None
+ *     elif addr.sa_family == uv.AF_UNSPEC:
+ */
+    goto __pyx_L8;
+  }
+
+  /* "uvloop/handles/udp.pyx":349
+ *     if addr is NULL:
+ *         pyaddr = None
+ *     elif addr.sa_family == uv.AF_UNSPEC:             # <<<<<<<<<<<<<<
+ *         # https://github.com/MagicStack/uvloop/issues/304
+ *         IF UNAME_SYSNAME == "Linux":
+ */
+  __pyx_t_1 = ((__pyx_v_addr->sa_family == AF_UNSPEC) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":354
+ *             pyaddr = None
+ *         ELSE:
+ *             pyaddr = ''             # <<<<<<<<<<<<<<
+ *     else:
+ *         try:
+ */
+    __Pyx_INCREF(__pyx_kp_u__8);
+    __pyx_v_pyaddr = __pyx_kp_u__8;
+
+    /* "uvloop/handles/udp.pyx":349
+ *     if addr is NULL:
+ *         pyaddr = None
+ *     elif addr.sa_family == uv.AF_UNSPEC:             # <<<<<<<<<<<<<<
+ *         # https://github.com/MagicStack/uvloop/issues/304
+ *         IF UNAME_SYSNAME == "Linux":
+ */
+    goto __pyx_L8;
+  }
+
+  /* "uvloop/handles/udp.pyx":356
+ *             pyaddr = ''
+ *     else:
+ *         try:             # <<<<<<<<<<<<<<
+ *             pyaddr = __convert_sockaddr_to_pyaddr(addr)
+ *         except BaseException as exc:
+ */
+  /*else*/ {
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      /*try:*/ {
+
+        /* "uvloop/handles/udp.pyx":357
+ *     else:
+ *         try:
+ *             pyaddr = __convert_sockaddr_to_pyaddr(addr)             # <<<<<<<<<<<<<<
+ *         except BaseException as exc:
+ *             udp._error(exc, False)
+ */
+        __pyx_t_2 = __pyx_f_6uvloop_4loop___convert_sockaddr_to_pyaddr(__pyx_v_addr); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 357, __pyx_L9_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_v_pyaddr = __pyx_t_2;
+        __pyx_t_2 = 0;
+
+        /* "uvloop/handles/udp.pyx":356
+ *             pyaddr = ''
+ *     else:
+ *         try:             # <<<<<<<<<<<<<<
+ *             pyaddr = __convert_sockaddr_to_pyaddr(addr)
+ *         except BaseException as exc:
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      goto __pyx_L14_try_end;
+      __pyx_L9_error:;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/udp.pyx":358
+ *         try:
+ *             pyaddr = __convert_sockaddr_to_pyaddr(addr)
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             udp._error(exc, False)
+ *             return
+ */
+      __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+      if (__pyx_t_7) {
+        __Pyx_AddTraceback("uvloop.loop.__uv_udp_on_receive", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(23, 358, __pyx_L11_except_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_INCREF(__pyx_t_8);
+        __pyx_v_exc = __pyx_t_8;
+        /*try:*/ {
+
+          /* "uvloop/handles/udp.pyx":359
+ *             pyaddr = __convert_sockaddr_to_pyaddr(addr)
+ *         except BaseException as exc:
+ *             udp._error(exc, False)             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+          __pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_udp), __pyx_v_exc, Py_False); if (unlikely(!__pyx_t_10)) __PYX_ERR(23, 359, __pyx_L20_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+          /* "uvloop/handles/udp.pyx":360
+ *         except BaseException as exc:
+ *             udp._error(exc, False)
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *     if nread < 0:
+ */
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          goto __pyx_L19_return;
+        }
+
+        /* "uvloop/handles/udp.pyx":358
+ *         try:
+ *             pyaddr = __convert_sockaddr_to_pyaddr(addr)
+ *         except BaseException as exc:             # <<<<<<<<<<<<<<
+ *             udp._error(exc, False)
+ *             return
+ */
+        /*finally:*/ {
+          __pyx_L20_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_declare
+            __Pyx_PyThreadState_assign
+            __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_13);
+            __Pyx_XGOTREF(__pyx_t_14);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __pyx_t_7 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename;
+            {
+              __Pyx_DECREF(__pyx_v_exc);
+              __pyx_v_exc = NULL;
+            }
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_16);
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+            }
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+            __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+            __pyx_lineno = __pyx_t_7; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12;
+            goto __pyx_L11_except_error;
+          }
+          __pyx_L19_return: {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+            goto __pyx_L12_except_return;
+          }
+        }
+      }
+      goto __pyx_L11_except_error;
+      __pyx_L11_except_error:;
+
+      /* "uvloop/handles/udp.pyx":356
+ *             pyaddr = ''
+ *     else:
+ *         try:             # <<<<<<<<<<<<<<
+ *             pyaddr = __convert_sockaddr_to_pyaddr(addr)
+ *         except BaseException as exc:
+ */
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      goto __pyx_L1_error;
+      __pyx_L12_except_return:;
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
+      goto __pyx_L0;
+      __pyx_L14_try_end:;
+    }
+  }
+  __pyx_L8:;
+
+  /* "uvloop/handles/udp.pyx":362
+ *             return
+ * 
+ *     if nread < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(nread)
+ *         udp._on_receive(None, exc, pyaddr)
+ */
+  __pyx_t_1 = ((__pyx_v_nread < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":363
+ * 
+ *     if nread < 0:
+ *         exc = convert_error(nread)             # <<<<<<<<<<<<<<
+ *         udp._on_receive(None, exc, pyaddr)
+ *         return
+ */
+    __pyx_t_9 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_nread); if (unlikely(!__pyx_t_9)) __PYX_ERR(23, 363, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_v_exc = __pyx_t_9;
+    __pyx_t_9 = 0;
+
+    /* "uvloop/handles/udp.pyx":364
+ *     if nread < 0:
+ *         exc = convert_error(nread)
+ *         udp._on_receive(None, exc, pyaddr)             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+    __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_on_receive(__pyx_v_udp, ((PyObject*)Py_None), __pyx_v_exc, __pyx_v_pyaddr); if (unlikely(!__pyx_t_9)) __PYX_ERR(23, 364, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/handles/udp.pyx":365
+ *         exc = convert_error(nread)
+ *         udp._on_receive(None, exc, pyaddr)
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     if nread == 0:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":362
+ *             return
+ * 
+ *     if nread < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(nread)
+ *         udp._on_receive(None, exc, pyaddr)
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":367
+ *         return
+ * 
+ *     if nread == 0:             # <<<<<<<<<<<<<<
+ *         data = b''
+ *     else:
+ */
+  __pyx_t_1 = ((__pyx_v_nread == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":368
+ * 
+ *     if nread == 0:
+ *         data = b''             # <<<<<<<<<<<<<<
+ *     else:
+ *         data = loop._recv_buffer[:nread]
+ */
+    __Pyx_INCREF(__pyx_kp_b__8);
+    __pyx_v_data = __pyx_kp_b__8;
+
+    /* "uvloop/handles/udp.pyx":367
+ *         return
+ * 
+ *     if nread == 0:             # <<<<<<<<<<<<<<
+ *         data = b''
+ *     else:
+ */
+    goto __pyx_L27;
+  }
+
+  /* "uvloop/handles/udp.pyx":370
+ *         data = b''
+ *     else:
+ *         data = loop._recv_buffer[:nread]             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+  /*else*/ {
+    __pyx_t_9 = __Pyx_PyBytes_FromStringAndSize(((const char*)__pyx_v_loop->_recv_buffer) + 0, __pyx_v_nread - 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(23, 370, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_v_data = ((PyObject*)__pyx_t_9);
+    __pyx_t_9 = 0;
+  }
+  __pyx_L27:;
+
+  /* "uvloop/handles/udp.pyx":372
+ *         data = loop._recv_buffer[:nread]
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         udp._on_receive(data, None, pyaddr)
+ *     except BaseException as exc:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_6);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "uvloop/handles/udp.pyx":373
+ * 
+ *     try:
+ *         udp._on_receive(data, None, pyaddr)             # <<<<<<<<<<<<<<
+ *     except BaseException as exc:
+ *         udp._error(exc, False)
+ */
+      __pyx_t_9 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_on_receive(__pyx_v_udp, __pyx_v_data, Py_None, __pyx_v_pyaddr); if (unlikely(!__pyx_t_9)) __PYX_ERR(23, 373, __pyx_L28_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+      /* "uvloop/handles/udp.pyx":372
+ *         data = loop._recv_buffer[:nread]
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         udp._on_receive(data, None, pyaddr)
+ *     except BaseException as exc:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L33_try_end;
+    __pyx_L28_error:;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "uvloop/handles/udp.pyx":374
+ *     try:
+ *         udp._on_receive(data, None, pyaddr)
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         udp._error(exc, False)
+ * 
+ */
+    __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_11) {
+      __Pyx_AddTraceback("uvloop.loop.__uv_udp_on_receive", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_8, &__pyx_t_2) < 0) __PYX_ERR(23, 374, __pyx_L30_except_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_8);
+      __pyx_v_exc = __pyx_t_8;
+      /*try:*/ {
+
+        /* "uvloop/handles/udp.pyx":375
+ *         udp._on_receive(data, None, pyaddr)
+ *     except BaseException as exc:
+ *         udp._error(exc, False)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+        __pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_udp), __pyx_v_exc, Py_False); if (unlikely(!__pyx_t_10)) __PYX_ERR(23, 375, __pyx_L39_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      }
+
+      /* "uvloop/handles/udp.pyx":374
+ *     try:
+ *         udp._on_receive(data, None, pyaddr)
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         udp._error(exc, False)
+ * 
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L40;
+        }
+        __pyx_L39_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0;
+          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __pyx_t_11 = __pyx_lineno; __pyx_t_7 = __pyx_clineno; __pyx_t_19 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_15);
+            __Pyx_XGIVEREF(__pyx_t_14);
+            __Pyx_XGIVEREF(__pyx_t_13);
+            __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_14, __pyx_t_13);
+          }
+          __Pyx_XGIVEREF(__pyx_t_18);
+          __Pyx_XGIVEREF(__pyx_t_17);
+          __Pyx_XGIVEREF(__pyx_t_16);
+          __Pyx_ErrRestore(__pyx_t_18, __pyx_t_17, __pyx_t_16);
+          __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0;
+          __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_7; __pyx_filename = __pyx_t_19;
+          goto __pyx_L30_except_error;
+        }
+        __pyx_L40:;
+      }
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      goto __pyx_L29_exception_handled;
+    }
+    goto __pyx_L30_except_error;
+    __pyx_L30_except_error:;
+
+    /* "uvloop/handles/udp.pyx":372
+ *         data = loop._recv_buffer[:nread]
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         udp._on_receive(data, None, pyaddr)
+ *     except BaseException as exc:
+ */
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_5, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L29_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_6);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_5, __pyx_t_4);
+    __pyx_L33_try_end:;
+  }
+
+  /* "uvloop/handles/udp.pyx":308
+ * 
+ * 
+ * cdef void __uv_udp_on_receive(uv.uv_udp_t* handle,             # <<<<<<<<<<<<<<
+ *                               ssize_t nread,
+ *                               const uv.uv_buf_t* buf,
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_WriteUnraisable("uvloop.loop.__uv_udp_on_receive", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_udp);
+  __Pyx_XDECREF((PyObject *)__pyx_v_loop);
+  __Pyx_XDECREF(__pyx_v_data);
+  __Pyx_XDECREF(__pyx_v_pyaddr);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/handles/udp.pyx":378
+ * 
+ * 
+ * cdef void __uv_udp_on_send(uv.uv_udp_send_t* req, int status) with gil:             # <<<<<<<<<<<<<<
+ * 
+ *     if req.data is NULL:
+ */
+
+static void __pyx_f_6uvloop_4loop___uv_udp_on_send(uv_udp_send_t *__pyx_v_req, int __pyx_v_status) {
+  struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_v_ctx = 0;
+  struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_udp = 0;
+  PyObject *__pyx_v_exc = NULL;
+  __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;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  char const *__pyx_t_12;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("__uv_udp_on_send", 0);
+
+  /* "uvloop/handles/udp.pyx":380
+ * cdef void __uv_udp_on_send(uv.uv_udp_send_t* req, int status) with gil:
+ * 
+ *     if req.data is NULL:             # <<<<<<<<<<<<<<
+ *         # Shouldn't happen as:
+ *         #    - _UDPSendContext does an extra INCREF in its 'init()'
+ */
+  __pyx_t_1 = ((__pyx_v_req->data == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":384
+ *         #    - _UDPSendContext does an extra INCREF in its 'init()'
+ *         #    - _UDPSendContext holds a ref to the relevant UDPTransport
+ *         aio_logger.error(             # <<<<<<<<<<<<<<
+ *             'UVStream.write callback called with NULL req.data, status=%r',
+ *             status)
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(23, 384, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "uvloop/handles/udp.pyx":386
+ *         aio_logger.error(
+ *             'UVStream.write callback called with NULL req.data, status=%r',
+ *             status)             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 386, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    __pyx_t_6 = 0;
+    if (CYTHON_UNPACK_METHODS && 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_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_u_UVStream_write_callback_called_w, __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(23, 384, __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_u_UVStream_write_callback_called_w, __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(23, 384, __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
+    {
+      __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(23, 384, __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_u_UVStream_write_callback_called_w);
+      __Pyx_GIVEREF(__pyx_kp_u_UVStream_write_callback_called_w);
+      PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_u_UVStream_write_callback_called_w);
+      __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(23, 384, __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_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/udp.pyx":387
+ *             'UVStream.write callback called with NULL req.data, status=%r',
+ *             status)
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+    goto __pyx_L0;
+
+    /* "uvloop/handles/udp.pyx":380
+ * cdef void __uv_udp_on_send(uv.uv_udp_send_t* req, int status) with gil:
+ * 
+ *     if req.data is NULL:             # <<<<<<<<<<<<<<
+ *         # Shouldn't happen as:
+ *         #    - _UDPSendContext does an extra INCREF in its 'init()'
+ */
+  }
+
+  /* "uvloop/handles/udp.pyx":390
+ * 
+ *     cdef:
+ *         _UDPSendContext ctx = <_UDPSendContext> req.data             # <<<<<<<<<<<<<<
+ *         UDPTransport udp = <UDPTransport>ctx.udp
+ * 
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_req->data);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_ctx = ((struct __pyx_obj_6uvloop_4loop__UDPSendContext *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/udp.pyx":391
+ *     cdef:
+ *         _UDPSendContext ctx = <_UDPSendContext> req.data
+ *         UDPTransport udp = <UDPTransport>ctx.udp             # <<<<<<<<<<<<<<
+ * 
+ *     ctx.close()
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_ctx->udp);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_udp = ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/handles/udp.pyx":393
+ *         UDPTransport udp = <UDPTransport>ctx.udp
+ * 
+ *     ctx.close()             # <<<<<<<<<<<<<<
+ * 
+ *     if status < 0:
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop__UDPSendContext *)__pyx_v_ctx->__pyx_vtab)->close(__pyx_v_ctx); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 393, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/handles/udp.pyx":395
+ *     ctx.close()
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(status)
+ *         print(exc)
+ */
+  __pyx_t_1 = ((__pyx_v_status < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/handles/udp.pyx":396
+ * 
+ *     if status < 0:
+ *         exc = convert_error(status)             # <<<<<<<<<<<<<<
+ *         print(exc)
+ *     else:
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_status); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 396, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_exc = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "uvloop/handles/udp.pyx":397
+ *     if status < 0:
+ *         exc = convert_error(status)
+ *         print(exc)             # <<<<<<<<<<<<<<
+ *     else:
+ *         exc = None
+ */
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_v_exc); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 397, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "uvloop/handles/udp.pyx":395
+ *     ctx.close()
+ * 
+ *     if status < 0:             # <<<<<<<<<<<<<<
+ *         exc = convert_error(status)
+ *         print(exc)
+ */
+    goto __pyx_L4;
+  }
+
+  /* "uvloop/handles/udp.pyx":399
+ *         print(exc)
+ *     else:
+ *         exc = None             # <<<<<<<<<<<<<<
+ * 
+ *     try:
+ */
+  /*else*/ {
+    __Pyx_INCREF(Py_None);
+    __pyx_v_exc = Py_None;
+  }
+  __pyx_L4:;
+
+  /* "uvloop/handles/udp.pyx":401
+ *         exc = None
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         udp._on_sent(exc)
+ *     except BaseException as exc:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+    __Pyx_XGOTREF(__pyx_t_8);
+    __Pyx_XGOTREF(__pyx_t_9);
+    __Pyx_XGOTREF(__pyx_t_10);
+    /*try:*/ {
+
+      /* "uvloop/handles/udp.pyx":402
+ * 
+ *     try:
+ *         udp._on_sent(exc)             # <<<<<<<<<<<<<<
+ *     except BaseException as exc:
+ *         udp._error(exc, False)
+ */
+      __pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_on_sent(__pyx_v_udp, __pyx_v_exc, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(23, 402, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "uvloop/handles/udp.pyx":401
+ *         exc = None
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         udp._on_sent(exc)
+ *     except BaseException as exc:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L5_error:;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 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;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/handles/udp.pyx":403
+ *     try:
+ *         udp._on_sent(exc)
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         udp._error(exc, False)
+ */
+    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
+    if (__pyx_t_6) {
+      __Pyx_AddTraceback("uvloop.loop.__uv_udp_on_send", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_3, &__pyx_t_7) < 0) __PYX_ERR(23, 403, __pyx_L7_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_DECREF_SET(__pyx_v_exc, __pyx_t_3);
+      /*try:*/ {
+
+        /* "uvloop/handles/udp.pyx":404
+ *         udp._on_sent(exc)
+ *     except BaseException as exc:
+ *         udp._error(exc, False)             # <<<<<<<<<<<<<<
+ */
+        __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._error(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_udp), __pyx_v_exc, Py_False); if (unlikely(!__pyx_t_4)) __PYX_ERR(23, 404, __pyx_L16_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+
+      /* "uvloop/handles/udp.pyx":403
+ *     try:
+ *         udp._on_sent(exc)
+ *     except BaseException as exc:             # <<<<<<<<<<<<<<
+ *         udp._error(exc, False)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          __Pyx_DECREF(__pyx_v_exc);
+          __pyx_v_exc = NULL;
+          goto __pyx_L17;
+        }
+        __pyx_L16_error:;
+        /*exception exit:*/{
+          __Pyx_PyThreadState_declare
+          __Pyx_PyThreadState_assign
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+          if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_13);
+          __Pyx_XGOTREF(__pyx_t_14);
+          __Pyx_XGOTREF(__pyx_t_15);
+          __Pyx_XGOTREF(__pyx_t_16);
+          __Pyx_XGOTREF(__pyx_t_17);
+          __Pyx_XGOTREF(__pyx_t_18);
+          __pyx_t_6 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename;
+          {
+            __Pyx_DECREF(__pyx_v_exc);
+            __pyx_v_exc = NULL;
+          }
+          if (PY_MAJOR_VERSION >= 3) {
+            __Pyx_XGIVEREF(__pyx_t_16);
+            __Pyx_XGIVEREF(__pyx_t_17);
+            __Pyx_XGIVEREF(__pyx_t_18);
+            __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+          }
+          __Pyx_XGIVEREF(__pyx_t_13);
+          __Pyx_XGIVEREF(__pyx_t_14);
+          __Pyx_XGIVEREF(__pyx_t_15);
+          __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15);
+          __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
+          __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12;
+          goto __pyx_L7_except_error;
+        }
+        __pyx_L17:;
+      }
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      goto __pyx_L6_exception_handled;
+    }
+    goto __pyx_L7_except_error;
+    __pyx_L7_except_error:;
+
+    /* "uvloop/handles/udp.pyx":401
+ *         exc = None
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         udp._on_sent(exc)
+ *     except BaseException as exc:
+ */
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    goto __pyx_L1_error;
+    __pyx_L6_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_8);
+    __Pyx_XGIVEREF(__pyx_t_9);
+    __Pyx_XGIVEREF(__pyx_t_10);
+    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+    __pyx_L10_try_end:;
+  }
+
+  /* "uvloop/handles/udp.pyx":378
+ * 
+ * 
+ * cdef void __uv_udp_on_send(uv.uv_udp_send_t* req, int status) with gil:             # <<<<<<<<<<<<<<
+ * 
+ *     if req.data is NULL:
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __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_7);
+  __Pyx_WriteUnraisable("uvloop.loop.__uv_udp_on_send", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_ctx);
+  __Pyx_XDECREF((PyObject *)__pyx_v_udp);
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/server.pyx":5
+ * 
+ * cdef class Server:
+ *     def __cinit__(self, Loop loop):             # <<<<<<<<<<<<<<
+ *         self._loop = loop
+ *         self._servers = []
+ */
+
+/* Python wrapper */
+static int __pyx_pw_6uvloop_4loop_6Server_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_6uvloop_4loop_6Server_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 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_loop,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_loop)) != 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(24, 5, __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_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)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(24, 5, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.Server.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6uvloop_4loop_Loop, 1, "loop", 0))) __PYX_ERR(24, 5, __pyx_L1_error)
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Server___cinit__(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self), __pyx_v_loop);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_6uvloop_4loop_6Server___cinit__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop) {
+  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);
+
+  /* "uvloop/server.pyx":6
+ * cdef class Server:
+ *     def __cinit__(self, Loop loop):
+ *         self._loop = loop             # <<<<<<<<<<<<<<
+ *         self._servers = []
+ *         self._waiters = []
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_loop));
+  __Pyx_GOTREF(__pyx_v_self->_loop);
+  __Pyx_DECREF(((PyObject *)__pyx_v_self->_loop));
+  __pyx_v_self->_loop = __pyx_v_loop;
+
+  /* "uvloop/server.pyx":7
+ *     def __cinit__(self, Loop loop):
+ *         self._loop = loop
+ *         self._servers = []             # <<<<<<<<<<<<<<
+ *         self._waiters = []
+ *         self._active_count = 0
+ */
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(24, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_servers);
+  __Pyx_DECREF(__pyx_v_self->_servers);
+  __pyx_v_self->_servers = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/server.pyx":8
+ *         self._loop = loop
+ *         self._servers = []
+ *         self._waiters = []             # <<<<<<<<<<<<<<
+ *         self._active_count = 0
+ *         self._serving_forever_fut = None
+ */
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(24, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v_self->_waiters);
+  __Pyx_DECREF(__pyx_v_self->_waiters);
+  __pyx_v_self->_waiters = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/server.pyx":9
+ *         self._servers = []
+ *         self._waiters = []
+ *         self._active_count = 0             # <<<<<<<<<<<<<<
+ *         self._serving_forever_fut = None
+ * 
+ */
+  __pyx_v_self->_active_count = 0;
+
+  /* "uvloop/server.pyx":10
+ *         self._waiters = []
+ *         self._active_count = 0
+ *         self._serving_forever_fut = None             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _add_server(self, UVStreamServer srv):
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_serving_forever_fut);
+  __Pyx_DECREF(__pyx_v_self->_serving_forever_fut);
+  __pyx_v_self->_serving_forever_fut = Py_None;
+
+  /* "uvloop/server.pyx":5
+ * 
+ * cdef class Server:
+ *     def __cinit__(self, Loop loop):             # <<<<<<<<<<<<<<
+ *         self._loop = loop
+ *         self._servers = []
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Server.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":12
+ *         self._serving_forever_fut = None
+ * 
+ *     cdef _add_server(self, UVStreamServer srv):             # <<<<<<<<<<<<<<
+ *         self._servers.append(srv)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6Server__add_server(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_srv) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_add_server", 0);
+
+  /* "uvloop/server.pyx":13
+ * 
+ *     cdef _add_server(self, UVStreamServer srv):
+ *         self._servers.append(srv)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _start_serving(self):
+ */
+  if (unlikely(__pyx_v_self->_servers == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+    __PYX_ERR(24, 13, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_PyList_Append(__pyx_v_self->_servers, ((PyObject *)__pyx_v_srv)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(24, 13, __pyx_L1_error)
+
+  /* "uvloop/server.pyx":12
+ *         self._serving_forever_fut = None
+ * 
+ *     cdef _add_server(self, UVStreamServer srv):             # <<<<<<<<<<<<<<
+ *         self._servers.append(srv)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Server._add_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":15
+ *         self._servers.append(srv)
+ * 
+ *     cdef _start_serving(self):             # <<<<<<<<<<<<<<
+ *         if self._serving:
+ *             return
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6Server__start_serving(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  PyObject *__pyx_v_server = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_start_serving", 0);
+
+  /* "uvloop/server.pyx":16
+ * 
+ *     cdef _start_serving(self):
+ *         if self._serving:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->_serving != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/server.pyx":17
+ *     cdef _start_serving(self):
+ *         if self._serving:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         self._serving = 1
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/server.pyx":16
+ * 
+ *     cdef _start_serving(self):
+ *         if self._serving:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/server.pyx":19
+ *             return
+ * 
+ *         self._serving = 1             # <<<<<<<<<<<<<<
+ *         for server in self._servers:
+ *             (<UVStreamServer>server).listen()
+ */
+  __pyx_v_self->_serving = 1;
+
+  /* "uvloop/server.pyx":20
+ * 
+ *         self._serving = 1
+ *         for server in self._servers:             # <<<<<<<<<<<<<<
+ *             (<UVStreamServer>server).listen()
+ * 
+ */
+  if (unlikely(__pyx_v_self->_servers == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(24, 20, __pyx_L1_error)
+  }
+  __pyx_t_2 = __pyx_v_self->_servers; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
+  for (;;) {
+    if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(24, 20, __pyx_L1_error)
+    #else
+    __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(24, 20, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_server, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "uvloop/server.pyx":21
+ *         self._serving = 1
+ *         for server in self._servers:
+ *             (<UVStreamServer>server).listen()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _wakeup(self):
+ */
+    __pyx_t_4 = __pyx_f_6uvloop_4loop_14UVStreamServer_listen(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_server)); if (unlikely(!__pyx_t_4)) __PYX_ERR(24, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/server.pyx":20
+ * 
+ *         self._serving = 1
+ *         for server in self._servers:             # <<<<<<<<<<<<<<
+ *             (<UVStreamServer>server).listen()
+ * 
+ */
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/server.pyx":15
+ *         self._servers.append(srv)
+ * 
+ *     cdef _start_serving(self):             # <<<<<<<<<<<<<<
+ *         if self._serving:
+ *             return
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Server._start_serving", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_server);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":23
+ *             (<UVStreamServer>server).listen()
+ * 
+ *     cdef _wakeup(self):             # <<<<<<<<<<<<<<
+ *         cdef list waiters
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6Server__wakeup(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  PyObject *__pyx_v_waiters = 0;
+  PyObject *__pyx_v_waiter = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_wakeup", 0);
+
+  /* "uvloop/server.pyx":26
+ *         cdef list waiters
+ * 
+ *         waiters = self._waiters             # <<<<<<<<<<<<<<
+ *         self._waiters = None
+ *         for waiter in waiters:
+ */
+  __pyx_t_1 = __pyx_v_self->_waiters;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_waiters = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/server.pyx":27
+ * 
+ *         waiters = self._waiters
+ *         self._waiters = None             # <<<<<<<<<<<<<<
+ *         for waiter in waiters:
+ *             if not waiter.done():
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  __Pyx_GOTREF(__pyx_v_self->_waiters);
+  __Pyx_DECREF(__pyx_v_self->_waiters);
+  __pyx_v_self->_waiters = ((PyObject*)Py_None);
+
+  /* "uvloop/server.pyx":28
+ *         waiters = self._waiters
+ *         self._waiters = None
+ *         for waiter in waiters:             # <<<<<<<<<<<<<<
+ *             if not waiter.done():
+ *                 waiter.set_result(waiter)
+ */
+  if (unlikely(__pyx_v_waiters == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(24, 28, __pyx_L1_error)
+  }
+  __pyx_t_1 = __pyx_v_waiters; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+  for (;;) {
+    if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(24, 28, __pyx_L1_error)
+    #else
+    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 28, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_waiter, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/server.pyx":29
+ *         self._waiters = None
+ *         for waiter in waiters:
+ *             if not waiter.done():             # <<<<<<<<<<<<<<
+ *                 waiter.set_result(waiter)
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_done); if (unlikely(!__pyx_t_4)) __PYX_ERR(24, 29, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 29, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(24, 29, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_7 = ((!__pyx_t_6) != 0);
+    if (__pyx_t_7) {
+
+      /* "uvloop/server.pyx":30
+ *         for waiter in waiters:
+ *             if not waiter.done():
+ *                 waiter.set_result(waiter)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _attach(self):
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(24, 30, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_waiter) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_waiter);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 30, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/server.pyx":29
+ *         self._waiters = None
+ *         for waiter in waiters:
+ *             if not waiter.done():             # <<<<<<<<<<<<<<
+ *                 waiter.set_result(waiter)
+ * 
+ */
+    }
+
+    /* "uvloop/server.pyx":28
+ *         waiters = self._waiters
+ *         self._waiters = None
+ *         for waiter in waiters:             # <<<<<<<<<<<<<<
+ *             if not waiter.done():
+ *                 waiter.set_result(waiter)
+ */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/server.pyx":23
+ *             (<UVStreamServer>server).listen()
+ * 
+ *     cdef _wakeup(self):             # <<<<<<<<<<<<<<
+ *         cdef list waiters
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.Server._wakeup", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_waiters);
+  __Pyx_XDECREF(__pyx_v_waiter);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":32
+ *                 waiter.set_result(waiter)
+ * 
+ *     cdef _attach(self):             # <<<<<<<<<<<<<<
+ *         assert self._servers is not None
+ *         self._active_count += 1
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6Server__attach(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_attach", 0);
+
+  /* "uvloop/server.pyx":33
+ * 
+ *     cdef _attach(self):
+ *         assert self._servers is not None             # <<<<<<<<<<<<<<
+ *         self._active_count += 1
+ * 
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    __pyx_t_1 = (__pyx_v_self->_servers != ((PyObject*)Py_None));
+    if (unlikely(!(__pyx_t_1 != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(24, 33, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "uvloop/server.pyx":34
+ *     cdef _attach(self):
+ *         assert self._servers is not None
+ *         self._active_count += 1             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _detach(self):
+ */
+  __pyx_v_self->_active_count = (__pyx_v_self->_active_count + 1);
+
+  /* "uvloop/server.pyx":32
+ *                 waiter.set_result(waiter)
+ * 
+ *     cdef _attach(self):             # <<<<<<<<<<<<<<
+ *         assert self._servers is not None
+ *         self._active_count += 1
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Server._attach", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":36
+ *         self._active_count += 1
+ * 
+ *     cdef _detach(self):             # <<<<<<<<<<<<<<
+ *         assert self._active_count > 0
+ *         self._active_count -= 1
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6Server__detach(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_detach", 0);
+
+  /* "uvloop/server.pyx":37
+ * 
+ *     cdef _detach(self):
+ *         assert self._active_count > 0             # <<<<<<<<<<<<<<
+ *         self._active_count -= 1
+ *         if self._active_count == 0 and self._servers is None:
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    if (unlikely(!((__pyx_v_self->_active_count > 0) != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(24, 37, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "uvloop/server.pyx":38
+ *     cdef _detach(self):
+ *         assert self._active_count > 0
+ *         self._active_count -= 1             # <<<<<<<<<<<<<<
+ *         if self._active_count == 0 and self._servers is None:
+ *             self._wakeup()
+ */
+  __pyx_v_self->_active_count = (__pyx_v_self->_active_count - 1);
+
+  /* "uvloop/server.pyx":39
+ *         assert self._active_count > 0
+ *         self._active_count -= 1
+ *         if self._active_count == 0 and self._servers is None:             # <<<<<<<<<<<<<<
+ *             self._wakeup()
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_self->_active_count == 0) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_v_self->_servers == ((PyObject*)Py_None));
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  __pyx_t_1 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/server.pyx":40
+ *         self._active_count -= 1
+ *         if self._active_count == 0 and self._servers is None:
+ *             self._wakeup()             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _ref(self):
+ */
+    __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_v_self->__pyx_vtab)->_wakeup(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(24, 40, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "uvloop/server.pyx":39
+ *         assert self._active_count > 0
+ *         self._active_count -= 1
+ *         if self._active_count == 0 and self._servers is None:             # <<<<<<<<<<<<<<
+ *             self._wakeup()
+ * 
+ */
+  }
+
+  /* "uvloop/server.pyx":36
+ *         self._active_count += 1
+ * 
+ *     cdef _detach(self):             # <<<<<<<<<<<<<<
+ *         assert self._active_count > 0
+ *         self._active_count -= 1
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Server._detach", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":42
+ *             self._wakeup()
+ * 
+ *     cdef _ref(self):             # <<<<<<<<<<<<<<
+ *         # Keep the server object alive while it's not explicitly closed.
+ *         self._loop._servers.add(self)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6Server__ref(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ref", 0);
+
+  /* "uvloop/server.pyx":44
+ *     cdef _ref(self):
+ *         # Keep the server object alive while it's not explicitly closed.
+ *         self._loop._servers.add(self)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _unref(self):
+ */
+  if (unlikely(__pyx_v_self->_loop->_servers == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "add");
+    __PYX_ERR(24, 44, __pyx_L1_error)
+  }
+  __pyx_t_1 = PySet_Add(__pyx_v_self->_loop->_servers, ((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(24, 44, __pyx_L1_error)
+
+  /* "uvloop/server.pyx":42
+ *             self._wakeup()
+ * 
+ *     cdef _ref(self):             # <<<<<<<<<<<<<<
+ *         # Keep the server object alive while it's not explicitly closed.
+ *         self._loop._servers.add(self)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Server._ref", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":46
+ *         self._loop._servers.add(self)
+ * 
+ *     cdef _unref(self):             # <<<<<<<<<<<<<<
+ *         self._loop._servers.discard(self)
+ * 
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop_6Server__unref(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_unref", 0);
+
+  /* "uvloop/server.pyx":47
+ * 
+ *     cdef _unref(self):
+ *         self._loop._servers.discard(self)             # <<<<<<<<<<<<<<
+ * 
+ *     # Public API
+ */
+  if (unlikely(__pyx_v_self->_loop->_servers == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "discard");
+    __PYX_ERR(24, 47, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_PySet_Discard(__pyx_v_self->_loop->_servers, ((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(24, 47, __pyx_L1_error)
+
+  /* "uvloop/server.pyx":46
+ *         self._loop._servers.add(self)
+ * 
+ *     cdef _unref(self):             # <<<<<<<<<<<<<<
+ *         self._loop._servers.discard(self)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Server._unref", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_6Server_4generator21(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/server.pyx":52
+ * 
+ *     @cython.iterable_coroutine
+ *     async def __aenter__(self):             # <<<<<<<<<<<<<<
+ *         return self
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_3__aenter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Server_2__aenter__[] = "Server.__aenter__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_3__aenter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__aenter__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Server_2__aenter__(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_2__aenter__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__aenter__", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_30___aenter__(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_30___aenter__, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(24, 52, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_6Server_4generator21, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_aenter, __pyx_n_s_Server___aenter, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(24, 52, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Server.__aenter__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_6Server_4generator21(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__aenter__", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(24, 52, __pyx_L1_error)
+
+  /* "uvloop/server.pyx":53
+ *     @cython.iterable_coroutine
+ *     async def __aenter__(self):
+ *         return self             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(((PyObject *)__pyx_cur_scope->__pyx_v_self));
+  goto __pyx_L0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/server.pyx":52
+ * 
+ *     @cython.iterable_coroutine
+ *     async def __aenter__(self):             # <<<<<<<<<<<<<<
+ *         return self
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("__aenter__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_6Server_7generator22(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/server.pyx":56
+ * 
+ *     @cython.iterable_coroutine
+ *     async def __aexit__(self, *exc):             # <<<<<<<<<<<<<<
+ *         self.close()
+ *         await self.wait_closed()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_6__aexit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Server_5__aexit__[] = "Server.__aexit__(self, *exc)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_6__aexit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED PyObject *__pyx_v_exc = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__aexit__ (wrapper)", 0);
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__aexit__", 0))) return NULL;
+  __Pyx_INCREF(__pyx_args);
+  __pyx_v_exc = __pyx_args;
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Server_5__aexit__(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self), __pyx_v_exc);
+
+  /* function exit code */
+  __Pyx_XDECREF(__pyx_v_exc);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_5__aexit__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__aexit__", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_31___aexit__(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_31___aexit__, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(24, 56, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_exc = __pyx_v_exc;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_exc);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_exc);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_6Server_7generator22, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_aexit, __pyx_n_s_Server___aexit, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(24, 56, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Server.__aexit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_6Server_7generator22(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  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
+  __Pyx_RefNannySetupContext("__aexit__", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L4_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(24, 56, __pyx_L1_error)
+
+  /* "uvloop/server.pyx":57
+ *     @cython.iterable_coroutine
+ *     async def __aexit__(self, *exc):
+ *         self.close()             # <<<<<<<<<<<<<<
+ *         await self.wait_closed()
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_close); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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(24, 57, __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;
+
+  /* "uvloop/server.pyx":58
+ *     async def __aexit__(self, *exc):
+ *         self.close()
+ *         await self.wait_closed()             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_wait_closed); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_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(24, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 1;
+    return __pyx_r;
+    __pyx_L4_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(24, 58, __pyx_L1_error)
+  } else {
+    PyObject* exc_type = __Pyx_PyErr_Occurred();
+    if (exc_type) {
+      if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+      else __PYX_ERR(24, 58, __pyx_L1_error)
+    }
+  }
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/server.pyx":56
+ * 
+ *     @cython.iterable_coroutine
+ *     async def __aexit__(self, *exc):             # <<<<<<<<<<<<<<
+ *         self.close()
+ *         await self.wait_closed()
+ */
+
+  /* function exit code */
+  PyErr_SetNone(PyExc_StopIteration);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("__aexit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":60
+ *         await self.wait_closed()
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return '<%s sockets=%r>' % (self.__class__.__name__, self.sockets)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_9__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_9__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Server_8__repr__(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_8__repr__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  Py_UCS4 __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "uvloop/server.pyx":61
+ * 
+ *     def __repr__(self):
+ *         return '<%s sockets=%r>' % (self.__class__.__name__, self.sockets)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_loop(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(24, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 127;
+  __Pyx_INCREF(__pyx_kp_u__103);
+  __pyx_t_2 += 1;
+  __Pyx_GIVEREF(__pyx_kp_u__103);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u__103);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(24, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(24, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Unicode(__pyx_t_5), __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(24, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_3;
+  __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __Pyx_INCREF(__pyx_kp_u_sockets);
+  __pyx_t_2 += 9;
+  __Pyx_GIVEREF(__pyx_kp_u_sockets);
+  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_sockets);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_sockets_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(24, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(24, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3;
+  __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __Pyx_INCREF(__pyx_kp_u__105);
+  __pyx_t_2 += 1;
+  __Pyx_GIVEREF(__pyx_kp_u__105);
+  PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u__105);
+  __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 5, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(24, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/server.pyx":60
+ *         await self.wait_closed()
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return '<%s sockets=%r>' % (self.__class__.__name__, self.sockets)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.Server.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":63
+ *         return '<%s sockets=%r>' % (self.__class__.__name__, self.sockets)
+ * 
+ *     def get_loop(self):             # <<<<<<<<<<<<<<
+ *         return self._loop
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_11get_loop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Server_10get_loop[] = "Server.get_loop(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_11get_loop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_loop (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Server_10get_loop(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_10get_loop(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_loop", 0);
+
+  /* "uvloop/server.pyx":64
+ * 
+ *     def get_loop(self):
+ *         return self._loop             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self->_loop));
+  __pyx_r = ((PyObject *)__pyx_v_self->_loop);
+  goto __pyx_L0;
+
+  /* "uvloop/server.pyx":63
+ *         return '<%s sockets=%r>' % (self.__class__.__name__, self.sockets)
+ * 
+ *     def get_loop(self):             # <<<<<<<<<<<<<<
+ *         return self._loop
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_6Server_14generator23(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/server.pyx":67
+ * 
+ *     @cython.iterable_coroutine
+ *     async def wait_closed(self):             # <<<<<<<<<<<<<<
+ *         # Do not remove `self._servers is None` below
+ *         # because close() method only closes server sockets
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_13wait_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Server_12wait_closed[] = "Server.wait_closed(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_13wait_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("wait_closed (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Server_12wait_closed(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_12wait_closed(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("wait_closed", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_32_wait_closed(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_32_wait_closed, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(24, 67, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_6Server_14generator23, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_wait_closed, __pyx_n_s_Server_wait_closed, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(24, 67, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Server.wait_closed", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_6Server_14generator23(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("wait_closed", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L7_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(24, 67, __pyx_L1_error)
+
+  /* "uvloop/server.pyx":71
+ *         # because close() method only closes server sockets
+ *         # and existing client connections are left open.
+ *         if self._servers is None or self._waiters is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         waiter = self._loop._new_future()
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->_servers == ((PyObject*)Py_None));
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_1 = __pyx_t_3;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_3 = (__pyx_cur_scope->__pyx_v_self->_waiters == ((PyObject*)Py_None));
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L5_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "uvloop/server.pyx":72
+ *         # and existing client connections are left open.
+ *         if self._servers is None or self._waiters is None:
+ *             return             # <<<<<<<<<<<<<<
+ *         waiter = self._loop._new_future()
+ *         self._waiters.append(waiter)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = NULL;
+    goto __pyx_L0;
+
+    /* "uvloop/server.pyx":71
+ *         # because close() method only closes server sockets
+ *         # and existing client connections are left open.
+ *         if self._servers is None or self._waiters is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         waiter = self._loop._new_future()
+ */
+  }
+
+  /* "uvloop/server.pyx":73
+ *         if self._servers is None or self._waiters is None:
+ *             return
+ *         waiter = self._loop._new_future()             # <<<<<<<<<<<<<<
+ *         self._waiters.append(waiter)
+ *         await waiter
+ */
+  __pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self->_loop); if (unlikely(!__pyx_t_4)) __PYX_ERR(24, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_4);
+  __pyx_cur_scope->__pyx_v_waiter = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "uvloop/server.pyx":74
+ *             return
+ *         waiter = self._loop._new_future()
+ *         self._waiters.append(waiter)             # <<<<<<<<<<<<<<
+ *         await waiter
+ * 
+ */
+  if (unlikely(__pyx_cur_scope->__pyx_v_self->_waiters == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+    __PYX_ERR(24, 74, __pyx_L1_error)
+  }
+  __pyx_t_5 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_self->_waiters, __pyx_cur_scope->__pyx_v_waiter); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(24, 74, __pyx_L1_error)
+
+  /* "uvloop/server.pyx":75
+ *         waiter = self._loop._new_future()
+ *         self._waiters.append(waiter)
+ *         await waiter             # <<<<<<<<<<<<<<
+ * 
+ *     def close(self):
+ */
+  __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
+  __Pyx_XGOTREF(__pyx_r);
+  if (likely(__pyx_r)) {
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, awaiting value */
+    __pyx_generator->resume_label = 1;
+    return __pyx_r;
+    __pyx_L7_resume_from_await:;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(24, 75, __pyx_L1_error)
+  } else {
+    PyObject* exc_type = __Pyx_PyErr_Occurred();
+    if (exc_type) {
+      if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+      else __PYX_ERR(24, 75, __pyx_L1_error)
+    }
+  }
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/server.pyx":67
+ * 
+ *     @cython.iterable_coroutine
+ *     async def wait_closed(self):             # <<<<<<<<<<<<<<
+ *         # Do not remove `self._servers is None` below
+ *         # because close() method only closes server sockets
+ */
+
+  /* function exit code */
+  PyErr_SetNone(PyExc_StopIteration);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("wait_closed", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":77
+ *         await waiter
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         cdef list servers
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_16close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Server_15close[] = "Server.close(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_16close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("close (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Server_15close(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_15close(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  PyObject *__pyx_v_servers = 0;
+  PyObject *__pyx_v_server = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  Py_ssize_t __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  char const *__pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("close", 0);
+
+  /* "uvloop/server.pyx":80
+ *         cdef list servers
+ * 
+ *         if self._servers is None:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->_servers == ((PyObject*)Py_None));
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/server.pyx":81
+ * 
+ *         if self._servers is None:
+ *             return             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/server.pyx":80
+ *         cdef list servers
+ * 
+ *         if self._servers is None:             # <<<<<<<<<<<<<<
+ *             return
+ * 
+ */
+  }
+
+  /* "uvloop/server.pyx":83
+ *             return
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             servers = self._servers
+ *             self._servers = None
+ */
+  /*try:*/ {
+
+    /* "uvloop/server.pyx":84
+ * 
+ *         try:
+ *             servers = self._servers             # <<<<<<<<<<<<<<
+ *             self._servers = None
+ *             self._serving = 0
+ */
+    __pyx_t_3 = __pyx_v_self->_servers;
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_v_servers = ((PyObject*)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "uvloop/server.pyx":85
+ *         try:
+ *             servers = self._servers
+ *             self._servers = None             # <<<<<<<<<<<<<<
+ *             self._serving = 0
+ * 
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_self->_servers);
+    __Pyx_DECREF(__pyx_v_self->_servers);
+    __pyx_v_self->_servers = ((PyObject*)Py_None);
+
+    /* "uvloop/server.pyx":86
+ *             servers = self._servers
+ *             self._servers = None
+ *             self._serving = 0             # <<<<<<<<<<<<<<
+ * 
+ *             for server in servers:
+ */
+    __pyx_v_self->_serving = 0;
+
+    /* "uvloop/server.pyx":88
+ *             self._serving = 0
+ * 
+ *             for server in servers:             # <<<<<<<<<<<<<<
+ *                 (<UVStreamServer>server)._close()
+ * 
+ */
+    if (unlikely(__pyx_v_servers == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+      __PYX_ERR(24, 88, __pyx_L5_error)
+    }
+    __pyx_t_3 = __pyx_v_servers; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0;
+    for (;;) {
+      if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break;
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_5); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(24, 88, __pyx_L5_error)
+      #else
+      __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) __PYX_ERR(24, 88, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      #endif
+      __Pyx_XDECREF_SET(__pyx_v_server, __pyx_t_5);
+      __pyx_t_5 = 0;
+
+      /* "uvloop/server.pyx":89
+ * 
+ *             for server in servers:
+ *                 (<UVStreamServer>server)._close()             # <<<<<<<<<<<<<<
+ * 
+ *             if self._active_count == 0:
+ */
+      __pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *)((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_server)->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_server))); if (unlikely(!__pyx_t_5)) __PYX_ERR(24, 89, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+      /* "uvloop/server.pyx":88
+ *             self._serving = 0
+ * 
+ *             for server in servers:             # <<<<<<<<<<<<<<
+ *                 (<UVStreamServer>server)._close()
+ * 
+ */
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/server.pyx":91
+ *                 (<UVStreamServer>server)._close()
+ * 
+ *             if self._active_count == 0:             # <<<<<<<<<<<<<<
+ *                 self._wakeup()
+ *         finally:
+ */
+    __pyx_t_2 = ((__pyx_v_self->_active_count == 0) != 0);
+    if (__pyx_t_2) {
+
+      /* "uvloop/server.pyx":92
+ * 
+ *             if self._active_count == 0:
+ *                 self._wakeup()             # <<<<<<<<<<<<<<
+ *         finally:
+ *             self._unref()
+ */
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_v_self->__pyx_vtab)->_wakeup(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 92, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "uvloop/server.pyx":91
+ *                 (<UVStreamServer>server)._close()
+ * 
+ *             if self._active_count == 0:             # <<<<<<<<<<<<<<
+ *                 self._wakeup()
+ *         finally:
+ */
+    }
+  }
+
+  /* "uvloop/server.pyx":94
+ *                 self._wakeup()
+ *         finally:
+ *             self._unref()             # <<<<<<<<<<<<<<
+ * 
+ *     def is_serving(self):
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_v_self->__pyx_vtab)->_unref(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 94, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      goto __pyx_L6;
+    }
+    __pyx_L5_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __Pyx_XGOTREF(__pyx_t_13);
+      __Pyx_XGOTREF(__pyx_t_14);
+      __pyx_t_6 = __pyx_lineno; __pyx_t_7 = __pyx_clineno; __pyx_t_8 = __pyx_filename;
+      {
+        __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_v_self->__pyx_vtab)->_unref(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 94, __pyx_L11_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_XGIVEREF(__pyx_t_11);
+      __Pyx_ErrRestore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
+      __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_7; __pyx_filename = __pyx_t_8;
+      goto __pyx_L1_error;
+      __pyx_L11_error:;
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_XGIVEREF(__pyx_t_14);
+        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+      }
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
+      goto __pyx_L1_error;
+    }
+    __pyx_L6:;
+  }
+
+  /* "uvloop/server.pyx":77
+ *         await waiter
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         cdef list servers
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("uvloop.loop.Server.close", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_servers);
+  __Pyx_XDECREF(__pyx_v_server);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":96
+ *             self._unref()
+ * 
+ *     def is_serving(self):             # <<<<<<<<<<<<<<
+ *         return self._serving
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_18is_serving(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Server_17is_serving[] = "Server.is_serving(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_18is_serving(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_serving (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Server_17is_serving(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_17is_serving(struct __pyx_obj_6uvloop_4loop_Server *__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("is_serving", 0);
+
+  /* "uvloop/server.pyx":97
+ * 
+ *     def is_serving(self):
+ *         return self._serving             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_serving); if (unlikely(!__pyx_t_1)) __PYX_ERR(24, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "uvloop/server.pyx":96
+ *             self._unref()
+ * 
+ *     def is_serving(self):             # <<<<<<<<<<<<<<
+ *         return self._serving
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Server.is_serving", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_6Server_21generator24(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/server.pyx":100
+ * 
+ *     @cython.iterable_coroutine
+ *     async def start_serving(self):             # <<<<<<<<<<<<<<
+ *         self._start_serving()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_20start_serving(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Server_19start_serving[] = "Server.start_serving(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_20start_serving(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("start_serving (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Server_19start_serving(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_19start_serving(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("start_serving", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_33_start_serving(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_33_start_serving, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(24, 100, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_6Server_21generator24, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_start_serving, __pyx_n_s_Server_start_serving, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(24, 100, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Server.start_serving", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_6Server_21generator24(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("start_serving", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(24, 100, __pyx_L1_error)
+
+  /* "uvloop/server.pyx":101
+ *     @cython.iterable_coroutine
+ *     async def start_serving(self):
+ *         self._start_serving()             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.iterable_coroutine
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_start_serving(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(24, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/server.pyx":100
+ * 
+ *     @cython.iterable_coroutine
+ *     async def start_serving(self):             # <<<<<<<<<<<<<<
+ *         self._start_serving()
+ * 
+ */
+
+  /* function exit code */
+  PyErr_SetNone(PyExc_StopIteration);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("start_serving", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_6Server_24generator25(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/server.pyx":104
+ * 
+ *     @cython.iterable_coroutine
+ *     async def serve_forever(self):             # <<<<<<<<<<<<<<
+ *         if self._serving_forever_fut is not None:
+ *             raise RuntimeError(
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_23serve_forever(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Server_22serve_forever[] = "Server.serve_forever(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_23serve_forever(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("serve_forever (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Server_22serve_forever(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_22serve_forever(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("serve_forever", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_34_serve_forever(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_34_serve_forever, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(24, 104, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__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_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_6Server_24generator25, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_serve_forever, __pyx_n_s_Server_serve_forever, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(24, 104, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop.Server.serve_forever", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_6Server_24generator25(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  Py_ssize_t __pyx_t_4;
+  Py_UCS4 __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  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_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  int __pyx_t_21;
+  char const *__pyx_t_22;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("serve_forever", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L15_resume_from_await;
+    case 2: goto __pyx_L23_resume_from_await;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(24, 104, __pyx_L1_error)
+
+  /* "uvloop/server.pyx":105
+ *     @cython.iterable_coroutine
+ *     async def serve_forever(self):
+ *         if self._serving_forever_fut is not None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 f'server {self!r} is already being awaited on serve_forever()')
+ */
+  __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->_serving_forever_fut != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "uvloop/server.pyx":107
+ *         if self._serving_forever_fut is not None:
+ *             raise RuntimeError(
+ *                 f'server {self!r} is already being awaited on serve_forever()')             # <<<<<<<<<<<<<<
+ *         if self._servers is None:
+ *             raise RuntimeError(f'server {self!r} is closed')
+ */
+    __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 107, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 127;
+    __Pyx_INCREF(__pyx_kp_u_server);
+    __pyx_t_4 += 7;
+    __Pyx_GIVEREF(__pyx_kp_u_server);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_server);
+    __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(((PyObject *)__pyx_cur_scope->__pyx_v_self)), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(24, 107, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_5 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_5) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_5;
+    __pyx_t_4 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __Pyx_INCREF(__pyx_kp_u_is_already_being_awaited_on_ser);
+    __pyx_t_4 += 44;
+    __Pyx_GIVEREF(__pyx_kp_u_is_already_being_awaited_on_ser);
+    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_is_already_being_awaited_on_ser);
+    __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(24, 107, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "uvloop/server.pyx":106
+ *     async def serve_forever(self):
+ *         if self._serving_forever_fut is not None:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 f'server {self!r} is already being awaited on serve_forever()')
+ *         if self._servers is None:
+ */
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 106, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(24, 106, __pyx_L1_error)
+
+    /* "uvloop/server.pyx":105
+ *     @cython.iterable_coroutine
+ *     async def serve_forever(self):
+ *         if self._serving_forever_fut is not None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(
+ *                 f'server {self!r} is already being awaited on serve_forever()')
+ */
+  }
+
+  /* "uvloop/server.pyx":108
+ *             raise RuntimeError(
+ *                 f'server {self!r} is already being awaited on serve_forever()')
+ *         if self._servers is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(f'server {self!r} is closed')
+ * 
+ */
+  __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->_servers == ((PyObject*)Py_None));
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/server.pyx":109
+ *                 f'server {self!r} is already being awaited on serve_forever()')
+ *         if self._servers is None:
+ *             raise RuntimeError(f'server {self!r} is closed')             # <<<<<<<<<<<<<<
+ * 
+ *         self._start_serving()
+ */
+    __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 109, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 127;
+    __Pyx_INCREF(__pyx_kp_u_server);
+    __pyx_t_4 += 7;
+    __Pyx_GIVEREF(__pyx_kp_u_server);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_server);
+    __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(((PyObject *)__pyx_cur_scope->__pyx_v_self)), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(24, 109, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_5 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_5) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_5;
+    __pyx_t_4 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __Pyx_INCREF(__pyx_kp_u_is_closed_2);
+    __pyx_t_4 += 10;
+    __Pyx_GIVEREF(__pyx_kp_u_is_closed_2);
+    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_is_closed_2);
+    __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(24, 109, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 109, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(24, 109, __pyx_L1_error)
+
+    /* "uvloop/server.pyx":108
+ *             raise RuntimeError(
+ *                 f'server {self!r} is already being awaited on serve_forever()')
+ *         if self._servers is None:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(f'server {self!r} is closed')
+ * 
+ */
+  }
+
+  /* "uvloop/server.pyx":111
+ *             raise RuntimeError(f'server {self!r} is closed')
+ * 
+ *         self._start_serving()             # <<<<<<<<<<<<<<
+ *         self._serving_forever_fut = self._loop.create_future()
+ * 
+ */
+  __pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_start_serving(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "uvloop/server.pyx":112
+ * 
+ *         self._start_serving()
+ *         self._serving_forever_fut = self._loop.create_future()             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self->_loop), __pyx_n_s_create_future); if (unlikely(!__pyx_t_6)) __PYX_ERR(24, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_serving_forever_fut);
+  __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_serving_forever_fut);
+  __pyx_cur_scope->__pyx_v_self->_serving_forever_fut = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "uvloop/server.pyx":114
+ *         self._serving_forever_fut = self._loop.create_future()
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             await self._serving_forever_fut
+ *         except asyncio.CancelledError:
+ */
+  /*try:*/ {
+    {
+      __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      /*try:*/ {
+
+        /* "uvloop/server.pyx":115
+ * 
+ *         try:
+ *             await self._serving_forever_fut             # <<<<<<<<<<<<<<
+ *         except asyncio.CancelledError:
+ *             try:
+ */
+        __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->_serving_forever_fut);
+        __Pyx_XGOTREF(__pyx_r);
+        if (likely(__pyx_r)) {
+          __Pyx_XGIVEREF(__pyx_t_8);
+          __pyx_cur_scope->__pyx_t_0 = __pyx_t_8;
+          __Pyx_XGIVEREF(__pyx_t_9);
+          __pyx_cur_scope->__pyx_t_1 = __pyx_t_9;
+          __Pyx_XGIVEREF(__pyx_t_10);
+          __pyx_cur_scope->__pyx_t_2 = __pyx_t_10;
+          __Pyx_XGIVEREF(__pyx_r);
+          __Pyx_RefNannyFinishContext();
+          __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+          /* return from generator, awaiting value */
+          __pyx_generator->resume_label = 1;
+          return __pyx_r;
+          __pyx_L15_resume_from_await:;
+          __pyx_t_8 = __pyx_cur_scope->__pyx_t_0;
+          __pyx_cur_scope->__pyx_t_0 = 0;
+          __Pyx_XGOTREF(__pyx_t_8);
+          __pyx_t_9 = __pyx_cur_scope->__pyx_t_1;
+          __pyx_cur_scope->__pyx_t_1 = 0;
+          __Pyx_XGOTREF(__pyx_t_9);
+          __pyx_t_10 = __pyx_cur_scope->__pyx_t_2;
+          __pyx_cur_scope->__pyx_t_2 = 0;
+          __Pyx_XGOTREF(__pyx_t_10);
+          if (unlikely(!__pyx_sent_value)) __PYX_ERR(24, 115, __pyx_L9_error)
+        } else {
+          PyObject* exc_type = __Pyx_PyErr_Occurred();
+          if (exc_type) {
+            if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+            else __PYX_ERR(24, 115, __pyx_L9_error)
+          }
+        }
+
+        /* "uvloop/server.pyx":114
+ *         self._serving_forever_fut = self._loop.create_future()
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             await self._serving_forever_fut
+ *         except asyncio.CancelledError:
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      goto __pyx_L14_try_end;
+      __pyx_L9_error:;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      /* "uvloop/server.pyx":116
+ *         try:
+ *             await self._serving_forever_fut
+ *         except asyncio.CancelledError:             # <<<<<<<<<<<<<<
+ *             try:
+ *                 self.close()
+ */
+      __Pyx_ErrFetch(&__pyx_t_3, &__pyx_t_6, &__pyx_t_7);
+      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_11)) __PYX_ERR(24, 116, __pyx_L11_except_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_CancelledError); if (unlikely(!__pyx_t_12)) __PYX_ERR(24, 116, __pyx_L11_except_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __pyx_t_13 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_3, __pyx_t_12);
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_ErrRestore(__pyx_t_3, __pyx_t_6, __pyx_t_7);
+      __pyx_t_3 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0;
+      if (__pyx_t_13) {
+        __Pyx_AddTraceback("uvloop.loop.Server.serve_forever", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_3) < 0) __PYX_ERR(24, 116, __pyx_L11_except_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_GOTREF(__pyx_t_3);
+
+        /* "uvloop/server.pyx":117
+ *             await self._serving_forever_fut
+ *         except asyncio.CancelledError:
+ *             try:             # <<<<<<<<<<<<<<
+ *                 self.close()
+ *                 await self.wait_closed()
+ */
+        /*try:*/ {
+
+          /* "uvloop/server.pyx":118
+ *         except asyncio.CancelledError:
+ *             try:
+ *                 self.close()             # <<<<<<<<<<<<<<
+ *                 await self.wait_closed()
+ *             finally:
+ */
+          __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_close); if (unlikely(!__pyx_t_11)) __PYX_ERR(24, 118, __pyx_L21_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __pyx_t_14 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+            __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_11);
+            if (likely(__pyx_t_14)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+              __Pyx_INCREF(__pyx_t_14);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_11, function);
+            }
+          }
+          __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_14) : __Pyx_PyObject_CallNoArg(__pyx_t_11);
+          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+          if (unlikely(!__pyx_t_12)) __PYX_ERR(24, 118, __pyx_L21_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+
+          /* "uvloop/server.pyx":119
+ *             try:
+ *                 self.close()
+ *                 await self.wait_closed()             # <<<<<<<<<<<<<<
+ *             finally:
+ *                 raise
+ */
+          __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_wait_closed); if (unlikely(!__pyx_t_11)) __PYX_ERR(24, 119, __pyx_L21_error)
+          __Pyx_GOTREF(__pyx_t_11);
+          __pyx_t_14 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
+            __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_11);
+            if (likely(__pyx_t_14)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+              __Pyx_INCREF(__pyx_t_14);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_11, function);
+            }
+          }
+          __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_14) : __Pyx_PyObject_CallNoArg(__pyx_t_11);
+          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+          if (unlikely(!__pyx_t_12)) __PYX_ERR(24, 119, __pyx_L21_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_12);
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_XGOTREF(__pyx_r);
+          if (likely(__pyx_r)) {
+            __Pyx_XGIVEREF(__pyx_t_3);
+            __pyx_cur_scope->__pyx_t_0 = __pyx_t_3;
+            __Pyx_XGIVEREF(__pyx_t_6);
+            __pyx_cur_scope->__pyx_t_1 = __pyx_t_6;
+            __Pyx_XGIVEREF(__pyx_t_7);
+            __pyx_cur_scope->__pyx_t_2 = __pyx_t_7;
+            __Pyx_XGIVEREF(__pyx_t_8);
+            __pyx_cur_scope->__pyx_t_3 = __pyx_t_8;
+            __Pyx_XGIVEREF(__pyx_t_9);
+            __pyx_cur_scope->__pyx_t_4 = __pyx_t_9;
+            __Pyx_XGIVEREF(__pyx_t_10);
+            __pyx_cur_scope->__pyx_t_5 = __pyx_t_10;
+            __Pyx_XGIVEREF(__pyx_r);
+            __Pyx_RefNannyFinishContext();
+            __Pyx_Coroutine_SwapException(__pyx_generator);
+            /* return from generator, awaiting value */
+            __pyx_generator->resume_label = 2;
+            return __pyx_r;
+            __pyx_L23_resume_from_await:;
+            __pyx_t_3 = __pyx_cur_scope->__pyx_t_0;
+            __pyx_cur_scope->__pyx_t_0 = 0;
+            __Pyx_XGOTREF(__pyx_t_3);
+            __pyx_t_6 = __pyx_cur_scope->__pyx_t_1;
+            __pyx_cur_scope->__pyx_t_1 = 0;
+            __Pyx_XGOTREF(__pyx_t_6);
+            __pyx_t_7 = __pyx_cur_scope->__pyx_t_2;
+            __pyx_cur_scope->__pyx_t_2 = 0;
+            __Pyx_XGOTREF(__pyx_t_7);
+            __pyx_t_8 = __pyx_cur_scope->__pyx_t_3;
+            __pyx_cur_scope->__pyx_t_3 = 0;
+            __Pyx_XGOTREF(__pyx_t_8);
+            __pyx_t_9 = __pyx_cur_scope->__pyx_t_4;
+            __pyx_cur_scope->__pyx_t_4 = 0;
+            __Pyx_XGOTREF(__pyx_t_9);
+            __pyx_t_10 = __pyx_cur_scope->__pyx_t_5;
+            __pyx_cur_scope->__pyx_t_5 = 0;
+            __Pyx_XGOTREF(__pyx_t_10);
+            if (unlikely(!__pyx_sent_value)) __PYX_ERR(24, 119, __pyx_L21_error)
+          } else {
+            PyObject* exc_type = __Pyx_PyErr_Occurred();
+            if (exc_type) {
+              if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();
+              else __PYX_ERR(24, 119, __pyx_L21_error)
+            }
+          }
+        }
+
+        /* "uvloop/server.pyx":121
+ *                 await self.wait_closed()
+ *             finally:
+ *                 raise             # <<<<<<<<<<<<<<
+ *         finally:
+ *             self._serving_forever_fut = None
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            __Pyx_GIVEREF(__pyx_t_7);
+            __Pyx_GIVEREF(__pyx_t_6);
+            __Pyx_XGIVEREF(__pyx_t_3);
+            __Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_6, __pyx_t_3);
+            __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_3 = 0; 
+            __PYX_ERR(24, 121, __pyx_L11_except_error)
+          }
+          __pyx_L21_error:;
+          /*exception exit:*/{
+            __Pyx_PyThreadState_assign
+            __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+            if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
+            if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_15);
+            __Pyx_XGOTREF(__pyx_t_16);
+            __Pyx_XGOTREF(__pyx_t_17);
+            __Pyx_XGOTREF(__pyx_t_18);
+            __Pyx_XGOTREF(__pyx_t_19);
+            __Pyx_XGOTREF(__pyx_t_20);
+            {
+              __Pyx_GIVEREF(__pyx_t_15);
+              __Pyx_GIVEREF(__pyx_t_16);
+              __Pyx_XGIVEREF(__pyx_t_17);
+              __Pyx_ErrRestoreWithState(__pyx_t_15, __pyx_t_16, __pyx_t_17);
+              __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; 
+              __PYX_ERR(24, 121, __pyx_L27_error)
+            }
+            __pyx_L27_error:;
+            if (PY_MAJOR_VERSION >= 3) {
+              __Pyx_XGIVEREF(__pyx_t_18);
+              __Pyx_XGIVEREF(__pyx_t_19);
+              __Pyx_XGIVEREF(__pyx_t_20);
+              __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
+            }
+            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+            __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+            __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
+            __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
+            goto __pyx_L11_except_error;
+          }
+        }
+      }
+      goto __pyx_L11_except_error;
+      __pyx_L11_except_error:;
+
+      /* "uvloop/server.pyx":114
+ *         self._serving_forever_fut = self._loop.create_future()
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             await self._serving_forever_fut
+ *         except asyncio.CancelledError:
+ */
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      goto __pyx_L7_error;
+      __pyx_L14_try_end:;
+    }
+  }
+
+  /* "uvloop/server.pyx":123
+ *                 raise
+ *         finally:
+ *             self._serving_forever_fut = None             # <<<<<<<<<<<<<<
+ * 
+ *     property sockets:
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      __Pyx_INCREF(Py_None);
+      __Pyx_GIVEREF(Py_None);
+      __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_serving_forever_fut);
+      __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_serving_forever_fut);
+      __pyx_cur_scope->__pyx_v_self->_serving_forever_fut = Py_None;
+      goto __pyx_L8;
+    }
+    __pyx_L7_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_assign
+      __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0;
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_10, &__pyx_t_9, &__pyx_t_8) < 0)) __Pyx_ErrFetch(&__pyx_t_10, &__pyx_t_9, &__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_20);
+      __Pyx_XGOTREF(__pyx_t_19);
+      __Pyx_XGOTREF(__pyx_t_18);
+      __pyx_t_13 = __pyx_lineno; __pyx_t_21 = __pyx_clineno; __pyx_t_22 = __pyx_filename;
+      {
+        __Pyx_INCREF(Py_None);
+        __Pyx_GIVEREF(Py_None);
+        __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_serving_forever_fut);
+        __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_serving_forever_fut);
+        __pyx_cur_scope->__pyx_v_self->_serving_forever_fut = Py_None;
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_20);
+        __Pyx_XGIVEREF(__pyx_t_19);
+        __Pyx_XGIVEREF(__pyx_t_18);
+        __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_19, __pyx_t_18);
+      }
+      __Pyx_XGIVEREF(__pyx_t_10);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ErrRestore(__pyx_t_10, __pyx_t_9, __pyx_t_8);
+      __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0;
+      __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_21; __pyx_filename = __pyx_t_22;
+      goto __pyx_L1_error;
+    }
+    __pyx_L8:;
+  }
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* "uvloop/server.pyx":104
+ * 
+ *     @cython.iterable_coroutine
+ *     async def serve_forever(self):             # <<<<<<<<<<<<<<
+ *         if self._serving_forever_fut is not None:
+ *             raise RuntimeError(
+ */
+
+  /* function exit code */
+  PyErr_SetNone(PyExc_StopIteration);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("serve_forever", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/server.pyx":126
+ * 
+ *     property sockets:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             cdef list sockets = []
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_7sockets_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_7sockets_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop_6Server_7sockets___get__(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_7sockets___get__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self) {
+  PyObject *__pyx_v_sockets = 0;
+  PyObject *__pyx_v_server = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "uvloop/server.pyx":127
+ *     property sockets:
+ *         def __get__(self):
+ *             cdef list sockets = []             # <<<<<<<<<<<<<<
+ * 
+ *             # Guard against `self._servers is None`
+ */
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(24, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_sockets = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/server.pyx":130
+ * 
+ *             # Guard against `self._servers is None`
+ *             if self._servers:             # <<<<<<<<<<<<<<
+ *                 for server in self._servers:
+ *                     sockets.append(
+ */
+  __pyx_t_2 = (__pyx_v_self->_servers != Py_None)&&(PyList_GET_SIZE(__pyx_v_self->_servers) != 0);
+  if (__pyx_t_2) {
+
+    /* "uvloop/server.pyx":131
+ *             # Guard against `self._servers is None`
+ *             if self._servers:
+ *                 for server in self._servers:             # <<<<<<<<<<<<<<
+ *                     sockets.append(
+ *                         (<UVStreamServer>server)._get_socket()
+ */
+    if (unlikely(__pyx_v_self->_servers == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+      __PYX_ERR(24, 131, __pyx_L1_error)
+    }
+    __pyx_t_1 = __pyx_v_self->_servers; __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = 0;
+    for (;;) {
+      if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_1)) break;
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(24, 131, __pyx_L1_error)
+      #else
+      __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(24, 131, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      #endif
+      __Pyx_XDECREF_SET(__pyx_v_server, __pyx_t_4);
+      __pyx_t_4 = 0;
+
+      /* "uvloop/server.pyx":133
+ *                 for server in self._servers:
+ *                     sockets.append(
+ *                         (<UVStreamServer>server)._get_socket()             # <<<<<<<<<<<<<<
+ *                     )
+ * 
+ */
+      __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *)((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_server)->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_server))); if (unlikely(!__pyx_t_4)) __PYX_ERR(24, 133, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+
+      /* "uvloop/server.pyx":132
+ *             if self._servers:
+ *                 for server in self._servers:
+ *                     sockets.append(             # <<<<<<<<<<<<<<
+ *                         (<UVStreamServer>server)._get_socket()
+ *                     )
+ */
+      __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_sockets, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(24, 132, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "uvloop/server.pyx":131
+ *             # Guard against `self._servers is None`
+ *             if self._servers:
+ *                 for server in self._servers:             # <<<<<<<<<<<<<<
+ *                     sockets.append(
+ *                         (<UVStreamServer>server)._get_socket()
+ */
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "uvloop/server.pyx":130
+ * 
+ *             # Guard against `self._servers is None`
+ *             if self._servers:             # <<<<<<<<<<<<<<
+ *                 for server in self._servers:
+ *                     sockets.append(
+ */
+  }
+
+  /* "uvloop/server.pyx":136
+ *                     )
+ * 
+ *             return sockets             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_sockets);
+  __pyx_r = __pyx_v_sockets;
+  goto __pyx_L0;
+
+  /* "uvloop/server.pyx":126
+ * 
+ *     property sockets:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             cdef list sockets = []
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop.Server.sockets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_sockets);
+  __Pyx_XDECREF(__pyx_v_server);
+  __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):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_26__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Server_25__reduce_cython__[] = "Server.__reduce_cython__(self)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_26__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_6uvloop_4loop_6Server_25__reduce_cython__(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_25__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Server *__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);
+
+  /* "(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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__228, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Server.__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_6uvloop_4loop_6Server_28__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static char __pyx_doc_6uvloop_4loop_6Server_27__setstate_cython__[] = "Server.__setstate_cython__(self, __pyx_state)";
+static PyObject *__pyx_pw_6uvloop_4loop_6Server_28__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_6uvloop_4loop_6Server_27__setstate_cython__(((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_6Server_27__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Server *__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);
+
+  /* "(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__229, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 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(7, 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__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("uvloop.loop.Server.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3283
+ * 
+ * 
+ * cdef void __get_fork_handler() nogil:             # <<<<<<<<<<<<<<
+ *     global __forking
+ *     global __forking_loop
+ */
+
+static void __pyx_f_6uvloop_4loop___get_fork_handler(void) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save;
+  #endif
+  __Pyx_RefNannySetupContext("__get_fork_handler", 1);
+
+  /* "uvloop/loop.pyx":3284
+ * 
+ * cdef void __get_fork_handler() nogil:
+ *     global __forking             # <<<<<<<<<<<<<<
+ *     global __forking_loop
+ * 
+ */
+  /*try:*/ {
+
+    /* "uvloop/loop.pyx":3287
+ *     global __forking_loop
+ * 
+ *     with gil:             # <<<<<<<<<<<<<<
+ *         if (__forking and __forking_loop is not None and
+ *                 __forking_loop.active_process_handler is not None):
+ */
+    {
+        #ifdef WITH_THREAD
+        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+        #endif
+        /*try:*/ {
+
+          /* "uvloop/loop.pyx":3288
+ * 
+ *     with gil:
+ *         if (__forking and __forking_loop is not None and             # <<<<<<<<<<<<<<
+ *                 __forking_loop.active_process_handler is not None):
+ *             __forking_loop.active_process_handler._after_fork()
+ */
+          __pyx_t_2 = (__pyx_v_6uvloop_4loop___forking != 0);
+          if (__pyx_t_2) {
+          } else {
+            __pyx_t_1 = __pyx_t_2;
+            goto __pyx_L10_bool_binop_done;
+          }
+          __pyx_t_2 = (((PyObject *)__pyx_v_6uvloop_4loop___forking_loop) != Py_None);
+          __pyx_t_3 = (__pyx_t_2 != 0);
+          if (__pyx_t_3) {
+          } else {
+            __pyx_t_1 = __pyx_t_3;
+            goto __pyx_L10_bool_binop_done;
+          }
+
+          /* "uvloop/loop.pyx":3289
+ *     with gil:
+ *         if (__forking and __forking_loop is not None and
+ *                 __forking_loop.active_process_handler is not None):             # <<<<<<<<<<<<<<
+ *             __forking_loop.active_process_handler._after_fork()
+ * 
+ */
+          __pyx_t_3 = (((PyObject *)__pyx_v_6uvloop_4loop___forking_loop->active_process_handler) != Py_None);
+          __pyx_t_2 = (__pyx_t_3 != 0);
+          __pyx_t_1 = __pyx_t_2;
+          __pyx_L10_bool_binop_done:;
+
+          /* "uvloop/loop.pyx":3288
+ * 
+ *     with gil:
+ *         if (__forking and __forking_loop is not None and             # <<<<<<<<<<<<<<
+ *                 __forking_loop.active_process_handler is not None):
+ *             __forking_loop.active_process_handler._after_fork()
+ */
+          if (__pyx_t_1) {
+
+            /* "uvloop/loop.pyx":3290
+ *         if (__forking and __forking_loop is not None and
+ *                 __forking_loop.active_process_handler is not None):
+ *             __forking_loop.active_process_handler._after_fork()             # <<<<<<<<<<<<<<
+ * 
+ * cdef __install_atfork():
+ */
+            __pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *)__pyx_v_6uvloop_4loop___forking_loop->active_process_handler->__pyx_base.__pyx_vtab)->_after_fork(__pyx_v_6uvloop_4loop___forking_loop->active_process_handler); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3290, __pyx_L7_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+            /* "uvloop/loop.pyx":3288
+ * 
+ *     with gil:
+ *         if (__forking and __forking_loop is not None and             # <<<<<<<<<<<<<<
+ *                 __forking_loop.active_process_handler is not None):
+ *             __forking_loop.active_process_handler._after_fork()
+ */
+          }
+        }
+
+        /* "uvloop/loop.pyx":3287
+ *     global __forking_loop
+ * 
+ *     with gil:             # <<<<<<<<<<<<<<
+ *         if (__forking and __forking_loop is not None and
+ *                 __forking_loop.active_process_handler is not None):
+ */
+        /*finally:*/ {
+          /*normal exit:*/{
+            #ifdef WITH_THREAD
+            __Pyx_PyGILState_Release(__pyx_gilstate_save);
+            #endif
+            goto __pyx_L8;
+          }
+          __pyx_L7_error: {
+            #ifdef WITH_THREAD
+            __Pyx_PyGILState_Release(__pyx_gilstate_save);
+            #endif
+            goto __pyx_L4_error;
+          }
+          __pyx_L8:;
+        }
+    }
+  }
+
+  /* "uvloop/loop.pyx":3284
+ * 
+ * cdef void __get_fork_handler() nogil:
+ *     global __forking             # <<<<<<<<<<<<<<
+ *     global __forking_loop
+ * 
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      #ifdef WITH_THREAD
+      __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+      #endif
+      goto __pyx_L5;
+    }
+    __pyx_L4_error: {
+      #ifdef WITH_THREAD
+      __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+      #endif
+      goto __pyx_L1_error;
+    }
+    __pyx_L5:;
+  }
+
+  /* "uvloop/loop.pyx":3283
+ * 
+ * 
+ * cdef void __get_fork_handler() nogil:             # <<<<<<<<<<<<<<
+ *     global __forking
+ *     global __forking_loop
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_WriteUnraisable("uvloop.loop.__get_fork_handler", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
+  __pyx_L0:;
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "uvloop/loop.pyx":3292
+ *             __forking_loop.active_process_handler._after_fork()
+ * 
+ * cdef __install_atfork():             # <<<<<<<<<<<<<<
+ *     global __atfork_installed
+ *     if __atfork_installed:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___install_atfork(void) {
+  int __pyx_v_err;
+  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("__install_atfork", 0);
+
+  /* "uvloop/loop.pyx":3294
+ * cdef __install_atfork():
+ *     global __atfork_installed
+ *     if __atfork_installed:             # <<<<<<<<<<<<<<
+ *         return
+ *     __atfork_installed = 1
+ */
+  __pyx_t_1 = (__pyx_v_6uvloop_4loop___atfork_installed != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":3295
+ *     global __atfork_installed
+ *     if __atfork_installed:
+ *         return             # <<<<<<<<<<<<<<
+ *     __atfork_installed = 1
+ * 
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":3294
+ * cdef __install_atfork():
+ *     global __atfork_installed
+ *     if __atfork_installed:             # <<<<<<<<<<<<<<
+ *         return
+ *     __atfork_installed = 1
+ */
+  }
+
+  /* "uvloop/loop.pyx":3296
+ *     if __atfork_installed:
+ *         return
+ *     __atfork_installed = 1             # <<<<<<<<<<<<<<
+ * 
+ *     cdef int err
+ */
+  __pyx_v_6uvloop_4loop___atfork_installed = 1;
+
+  /* "uvloop/loop.pyx":3300
+ *     cdef int err
+ * 
+ *     err = system.pthread_atfork(NULL, NULL, &system.handleAtFork)             # <<<<<<<<<<<<<<
+ *     if err:
+ *         __atfork_installed = 0
+ */
+  __pyx_v_err = pthread_atfork(NULL, NULL, (&handleAtFork));
+
+  /* "uvloop/loop.pyx":3301
+ * 
+ *     err = system.pthread_atfork(NULL, NULL, &system.handleAtFork)
+ *     if err:             # <<<<<<<<<<<<<<
+ *         __atfork_installed = 0
+ *         raise convert_error(-err)
+ */
+  __pyx_t_1 = (__pyx_v_err != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":3302
+ *     err = system.pthread_atfork(NULL, NULL, &system.handleAtFork)
+ *     if err:
+ *         __atfork_installed = 0             # <<<<<<<<<<<<<<
+ *         raise convert_error(-err)
+ * 
+ */
+    __pyx_v_6uvloop_4loop___atfork_installed = 0;
+
+    /* "uvloop/loop.pyx":3303
+ *     if err:
+ *         __atfork_installed = 0
+ *         raise convert_error(-err)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error((-__pyx_v_err)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3303, __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(0, 3303, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":3301
+ * 
+ *     err = system.pthread_atfork(NULL, NULL, &system.handleAtFork)
+ *     if err:             # <<<<<<<<<<<<<<
+ *         __atfork_installed = 0
+ *         raise convert_error(-err)
+ */
+  }
+
+  /* "uvloop/loop.pyx":3292
+ *             __forking_loop.active_process_handler._after_fork()
+ * 
+ * cdef __install_atfork():             # <<<<<<<<<<<<<<
+ *     global __atfork_installed
+ *     if __atfork_installed:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.__install_atfork", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3308
+ * # Install PyMem* memory allocators
+ * cdef vint __mem_installed = 0
+ * cdef __install_pymem():             # <<<<<<<<<<<<<<
+ *     global __mem_installed
+ *     if __mem_installed:
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___install_pymem(void) {
+  int __pyx_v_err;
+  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("__install_pymem", 0);
+
+  /* "uvloop/loop.pyx":3310
+ * cdef __install_pymem():
+ *     global __mem_installed
+ *     if __mem_installed:             # <<<<<<<<<<<<<<
+ *         return
+ *     __mem_installed = 1
+ */
+  __pyx_t_1 = (__pyx_v_6uvloop_4loop___mem_installed != 0);
+  if (__pyx_t_1) {
+
+    /* "uvloop/loop.pyx":3311
+ *     global __mem_installed
+ *     if __mem_installed:
+ *         return             # <<<<<<<<<<<<<<
+ *     __mem_installed = 1
+ * 
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":3310
+ * cdef __install_pymem():
+ *     global __mem_installed
+ *     if __mem_installed:             # <<<<<<<<<<<<<<
+ *         return
+ *     __mem_installed = 1
+ */
+  }
+
+  /* "uvloop/loop.pyx":3312
+ *     if __mem_installed:
+ *         return
+ *     __mem_installed = 1             # <<<<<<<<<<<<<<
+ * 
+ *     cdef int err
+ */
+  __pyx_v_6uvloop_4loop___mem_installed = 1;
+
+  /* "uvloop/loop.pyx":3315
+ * 
+ *     cdef int err
+ *     err = uv.uv_replace_allocator(<uv.uv_malloc_func>PyMem_RawMalloc,             # <<<<<<<<<<<<<<
+ *                                   <uv.uv_realloc_func>PyMem_RawRealloc,
+ *                                   <uv.uv_calloc_func>PyMem_RawCalloc,
+ */
+  __pyx_v_err = uv_replace_allocator(((uv_malloc_func)PyMem_RawMalloc), ((uv_realloc_func)PyMem_RawRealloc), ((uv_calloc_func)PyMem_RawCalloc), ((uv_free_func)PyMem_RawFree));
+
+  /* "uvloop/loop.pyx":3319
+ *                                   <uv.uv_calloc_func>PyMem_RawCalloc,
+ *                                   <uv.uv_free_func>PyMem_RawFree)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         __mem_installed = 0
+ *         raise convert_error(err)
+ */
+  __pyx_t_1 = ((__pyx_v_err < 0) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "uvloop/loop.pyx":3320
+ *                                   <uv.uv_free_func>PyMem_RawFree)
+ *     if err < 0:
+ *         __mem_installed = 0             # <<<<<<<<<<<<<<
+ *         raise convert_error(err)
+ * 
+ */
+    __pyx_v_6uvloop_4loop___mem_installed = 0;
+
+    /* "uvloop/loop.pyx":3321
+ *     if err < 0:
+ *         __mem_installed = 0
+ *         raise convert_error(err)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3321, __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(0, 3321, __pyx_L1_error)
+
+    /* "uvloop/loop.pyx":3319
+ *                                   <uv.uv_calloc_func>PyMem_RawCalloc,
+ *                                   <uv.uv_free_func>PyMem_RawFree)
+ *     if err < 0:             # <<<<<<<<<<<<<<
+ *         __mem_installed = 0
+ *         raise convert_error(err)
+ */
+  }
+
+  /* "uvloop/loop.pyx":3308
+ * # Install PyMem* memory allocators
+ * cdef vint __mem_installed = 0
+ * cdef __install_pymem():             # <<<<<<<<<<<<<<
+ *     global __mem_installed
+ *     if __mem_installed:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("uvloop.loop.__install_pymem", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "uvloop/loop.pyx":3324
+ * 
+ * 
+ * cdef _set_signal_wakeup_fd(fd):             # <<<<<<<<<<<<<<
+ *     if fd >= 0:
+ *         return signal_set_wakeup_fd(fd, warn_on_full_buffer=False)
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop__set_signal_wakeup_fd(PyObject *__pyx_v_fd) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_set_signal_wakeup_fd", 0);
+
+  /* "uvloop/loop.pyx":3325
+ * 
+ * cdef _set_signal_wakeup_fd(fd):
+ *     if fd >= 0:             # <<<<<<<<<<<<<<
+ *         return signal_set_wakeup_fd(fd, warn_on_full_buffer=False)
+ *     else:
+ */
+  __pyx_t_1 = PyObject_RichCompare(__pyx_v_fd, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3325, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3325, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_2) {
+
+    /* "uvloop/loop.pyx":3326
+ * cdef _set_signal_wakeup_fd(fd):
+ *     if fd >= 0:
+ *         return signal_set_wakeup_fd(fd, warn_on_full_buffer=False)             # <<<<<<<<<<<<<<
+ *     else:
+ *         return signal_set_wakeup_fd(fd)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3326, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_v_fd);
+    __Pyx_GIVEREF(__pyx_v_fd);
+    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_fd);
+    __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3326, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_warn_on_full_buffer, Py_False) < 0) __PYX_ERR(0, 3326, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_signal_set_wakeup_fd, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3326, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
+
+    /* "uvloop/loop.pyx":3325
+ * 
+ * cdef _set_signal_wakeup_fd(fd):
+ *     if fd >= 0:             # <<<<<<<<<<<<<<
+ *         return signal_set_wakeup_fd(fd, warn_on_full_buffer=False)
+ *     else:
+ */
+  }
+
+  /* "uvloop/loop.pyx":3328
+ *         return signal_set_wakeup_fd(fd, warn_on_full_buffer=False)
+ *     else:
+ *         return signal_set_wakeup_fd(fd)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_set_wakeup_fd);
+    __pyx_t_3 = __pyx_v_6uvloop_4loop_signal_set_wakeup_fd; __pyx_t_1 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+      }
+    }
+    __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_fd) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_fd);
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3328, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "uvloop/loop.pyx":3324
+ * 
+ * 
+ * cdef _set_signal_wakeup_fd(fd):             # <<<<<<<<<<<<<<
+ *     if fd >= 0:
+ *         return signal_set_wakeup_fd(fd, warn_on_full_buffer=False)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("uvloop.loop._set_signal_wakeup_fd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_6uvloop_4loop_2generator26(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "uvloop/loop.pyx":3334
+ * 
+ * @cython.iterable_coroutine
+ * async def _test_coroutine_1():             # <<<<<<<<<<<<<<
+ *     return 42
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_1_test_coroutine_1(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_6uvloop_4loop__test_coroutine_1[] = "_test_coroutine_1()";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_1_test_coroutine_1 = {"_test_coroutine_1", (PyCFunction)__pyx_pw_6uvloop_4loop_1_test_coroutine_1, METH_NOARGS, __pyx_doc_6uvloop_4loop__test_coroutine_1};
+static PyObject *__pyx_pw_6uvloop_4loop_1_test_coroutine_1(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_test_coroutine_1 (wrapper)", 0);
+  __pyx_r = __pyx_pf_6uvloop_4loop__test_coroutine_1(__pyx_self);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop__test_coroutine_1(CYTHON_UNUSED PyObject *__pyx_self) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_test_coroutine_1", 0);
+  __pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 3334, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__pyx_cur_scope);
+  }
+  {
+    __pyx_CoroutineObject *gen = __Pyx_IterableCoroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_2generator26, __pyx_codeobj__230, (PyObject *) __pyx_cur_scope, __pyx_n_s_test_coroutine_1, __pyx_n_s_test_coroutine_1, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(0, 3334, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("uvloop.loop._test_coroutine_1", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_6uvloop_4loop_2generator26(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  PyObject *__pyx_r = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_test_coroutine_1", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 3334, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3335
+ * @cython.iterable_coroutine
+ * async def _test_coroutine_1():
+ *     return 42             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_int_42);
+  goto __pyx_L0;
+
+  /* "uvloop/loop.pyx":3334
+ * 
+ * @cython.iterable_coroutine
+ * async def _test_coroutine_1():             # <<<<<<<<<<<<<<
+ *     return 42
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("_test_coroutine_1", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __pyx_unpickle_PseudoSocket(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_4__pyx_unpickle_PseudoSocket(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_3__pyx_unpickle_PseudoSocket[] = "__pyx_unpickle_PseudoSocket(__pyx_type, long __pyx_checksum, __pyx_state)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_4__pyx_unpickle_PseudoSocket = {"__pyx_unpickle_PseudoSocket", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4__pyx_unpickle_PseudoSocket, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_3__pyx_unpickle_PseudoSocket};
+static PyObject *__pyx_pw_6uvloop_4loop_4__pyx_unpickle_PseudoSocket(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v___pyx_type = 0;
+  long __pyx_v___pyx_checksum;
+  PyObject *__pyx_v___pyx_state = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__pyx_unpickle_PseudoSocket (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,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_pyx_type)) != 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_pyx_checksum)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PseudoSocket", 1, 3, 3, 1); __PYX_ERR(7, 1, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PseudoSocket", 1, 3, 3, 2); __PYX_ERR(7, 1, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_PseudoSocket") < 0)) __PYX_ERR(7, 1, __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___pyx_type = values[0];
+    __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(7, 1, __pyx_L3_error)
+    __pyx_v___pyx_state = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PseudoSocket", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(7, 1, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.__pyx_unpickle_PseudoSocket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_3__pyx_unpickle_PseudoSocket(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_3__pyx_unpickle_PseudoSocket(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_v___pyx_PickleError = 0;
+  PyObject *__pyx_v___pyx_result = 0;
+  PyObject *__pyx_r = NULL;
+  __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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__pyx_unpickle_PseudoSocket", 0);
+
+  /* "(tree fragment)":4
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ *     if __pyx_checksum != 0x88c0b03:             # <<<<<<<<<<<<<<
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x88c0b03 = (_family, _fd, _peername, _proto, _sockname, _type))" % __pyx_checksum)
+ */
+  __pyx_t_1 = ((__pyx_v___pyx_checksum != 0x88c0b03) != 0);
+  if (__pyx_t_1) {
+
+    /* "(tree fragment)":5
+ *     cdef object __pyx_result
+ *     if __pyx_checksum != 0x88c0b03:
+ *         from pickle import PickleError as __pyx_PickleError             # <<<<<<<<<<<<<<
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x88c0b03 = (_family, _fd, _peername, _proto, _sockname, _type))" % __pyx_checksum)
+ *     __pyx_result = PseudoSocket.__new__(__pyx_type)
+ */
+    __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 5, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_n_s_PickleError);
+    __Pyx_GIVEREF(__pyx_n_s_PickleError);
+    PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError);
+    __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 5, __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_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 5, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_2);
+    __pyx_v___pyx_PickleError = __pyx_t_2;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "(tree fragment)":6
+ *     if __pyx_checksum != 0x88c0b03:
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x88c0b03 = (_family, _fd, _peername, _proto, _sockname, _type))" % __pyx_checksum)             # <<<<<<<<<<<<<<
+ *     __pyx_result = PseudoSocket.__new__(__pyx_type)
+ *     if __pyx_state is not None:
+ */
+    __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 6, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0x88, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(7, 6, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_INCREF(__pyx_v___pyx_PickleError);
+    __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_5)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __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_3)) __PYX_ERR(7, 6, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(7, 6, __pyx_L1_error)
+
+    /* "(tree fragment)":4
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ *     if __pyx_checksum != 0x88c0b03:             # <<<<<<<<<<<<<<
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x88c0b03 = (_family, _fd, _peername, _proto, _sockname, _type))" % __pyx_checksum)
+ */
+  }
+
+  /* "(tree fragment)":7
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x88c0b03 = (_family, _fd, _peername, _proto, _sockname, _type))" % __pyx_checksum)
+ *     __pyx_result = PseudoSocket.__new__(__pyx_type)             # <<<<<<<<<<<<<<
+ *     if __pyx_state is not None:
+ *         __pyx_unpickle_PseudoSocket__set_state(<PseudoSocket> __pyx_result, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6uvloop_4loop_PseudoSocket), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v___pyx_result = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "(tree fragment)":8
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x88c0b03 = (_family, _fd, _peername, _proto, _sockname, _type))" % __pyx_checksum)
+ *     __pyx_result = PseudoSocket.__new__(__pyx_type)
+ *     if __pyx_state is not None:             # <<<<<<<<<<<<<<
+ *         __pyx_unpickle_PseudoSocket__set_state(<PseudoSocket> __pyx_result, __pyx_state)
+ *     return __pyx_result
+ */
+  __pyx_t_1 = (__pyx_v___pyx_state != Py_None);
+  __pyx_t_6 = (__pyx_t_1 != 0);
+  if (__pyx_t_6) {
+
+    /* "(tree fragment)":9
+ *     __pyx_result = PseudoSocket.__new__(__pyx_type)
+ *     if __pyx_state is not None:
+ *         __pyx_unpickle_PseudoSocket__set_state(<PseudoSocket> __pyx_result, __pyx_state)             # <<<<<<<<<<<<<<
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PseudoSocket__set_state(PseudoSocket __pyx_result, tuple __pyx_state):
+ */
+    if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(7, 9, __pyx_L1_error)
+    __pyx_t_3 = __pyx_f_6uvloop_4loop___pyx_unpickle_PseudoSocket__set_state(((struct __pyx_obj_6uvloop_4loop_PseudoSocket *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 9, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "(tree fragment)":8
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x88c0b03 = (_family, _fd, _peername, _proto, _sockname, _type))" % __pyx_checksum)
+ *     __pyx_result = PseudoSocket.__new__(__pyx_type)
+ *     if __pyx_state is not None:             # <<<<<<<<<<<<<<
+ *         __pyx_unpickle_PseudoSocket__set_state(<PseudoSocket> __pyx_result, __pyx_state)
+ *     return __pyx_result
+ */
+  }
+
+  /* "(tree fragment)":10
+ *     if __pyx_state is not None:
+ *         __pyx_unpickle_PseudoSocket__set_state(<PseudoSocket> __pyx_result, __pyx_state)
+ *     return __pyx_result             # <<<<<<<<<<<<<<
+ * cdef __pyx_unpickle_PseudoSocket__set_state(PseudoSocket __pyx_result, tuple __pyx_state):
+ *     __pyx_result._family = __pyx_state[0]; __pyx_result._fd = __pyx_state[1]; __pyx_result._peername = __pyx_state[2]; __pyx_result._proto = __pyx_state[3]; __pyx_result._sockname = __pyx_state[4]; __pyx_result._type = __pyx_state[5]
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v___pyx_result);
+  __pyx_r = __pyx_v___pyx_result;
+  goto __pyx_L0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_PseudoSocket(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+
+  /* 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_AddTraceback("uvloop.loop.__pyx_unpickle_PseudoSocket", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v___pyx_PickleError);
+  __Pyx_XDECREF(__pyx_v___pyx_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":11
+ *         __pyx_unpickle_PseudoSocket__set_state(<PseudoSocket> __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PseudoSocket__set_state(PseudoSocket __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result._family = __pyx_state[0]; __pyx_result._fd = __pyx_state[1]; __pyx_result._peername = __pyx_state[2]; __pyx_result._proto = __pyx_state[3]; __pyx_result._sockname = __pyx_state[4]; __pyx_result._type = __pyx_state[5]
+ *     if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'):
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___pyx_unpickle_PseudoSocket__set_state(struct __pyx_obj_6uvloop_4loop_PseudoSocket *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__pyx_unpickle_PseudoSocket__set_state", 0);
+
+  /* "(tree fragment)":12
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PseudoSocket__set_state(PseudoSocket __pyx_result, tuple __pyx_state):
+ *     __pyx_result._family = __pyx_state[0]; __pyx_result._fd = __pyx_state[1]; __pyx_result._peername = __pyx_state[2]; __pyx_result._proto = __pyx_state[3]; __pyx_result._sockname = __pyx_state[4]; __pyx_result._type = __pyx_state[5]             # <<<<<<<<<<<<<<
+ *     if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[6])
+ */
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(7, 12, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v___pyx_result->_family = __pyx_t_2;
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(7, 12, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v___pyx_result->_fd = __pyx_t_2;
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(7, 12, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v___pyx_result->_peername);
+  __Pyx_DECREF(__pyx_v___pyx_result->_peername);
+  __pyx_v___pyx_result->_peername = __pyx_t_1;
+  __pyx_t_1 = 0;
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(7, 12, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v___pyx_result->_proto = __pyx_t_2;
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(7, 12, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v___pyx_result->_sockname);
+  __Pyx_DECREF(__pyx_v___pyx_result->_sockname);
+  __pyx_v___pyx_result->_sockname = __pyx_t_1;
+  __pyx_t_1 = 0;
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(7, 12, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v___pyx_result->_type = __pyx_t_2;
+
+  /* "(tree fragment)":13
+ * cdef __pyx_unpickle_PseudoSocket__set_state(PseudoSocket __pyx_result, tuple __pyx_state):
+ *     __pyx_result._family = __pyx_state[0]; __pyx_result._fd = __pyx_state[1]; __pyx_result._peername = __pyx_state[2]; __pyx_result._proto = __pyx_state[3]; __pyx_result._sockname = __pyx_state[4]; __pyx_result._type = __pyx_state[5]
+ *     if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'):             # <<<<<<<<<<<<<<
+ *         __pyx_result.__dict__.update(__pyx_state[6])
+ */
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(7, 13, __pyx_L1_error)
+  }
+  __pyx_t_4 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(7, 13, __pyx_L1_error)
+  __pyx_t_5 = ((__pyx_t_4 > 6) != 0);
+  if (__pyx_t_5) {
+  } else {
+    __pyx_t_3 = __pyx_t_5;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(7, 13, __pyx_L1_error)
+  __pyx_t_6 = (__pyx_t_5 != 0);
+  __pyx_t_3 = __pyx_t_6;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_3) {
+
+    /* "(tree fragment)":14
+ *     __pyx_result._family = __pyx_state[0]; __pyx_result._fd = __pyx_state[1]; __pyx_result._peername = __pyx_state[2]; __pyx_result._proto = __pyx_state[3]; __pyx_result._sockname = __pyx_state[4]; __pyx_result._type = __pyx_state[5]
+ *     if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[6])             # <<<<<<<<<<<<<<
+ */
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(7, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_update); if (unlikely(!__pyx_t_8)) __PYX_ERR(7, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(__pyx_v___pyx_state == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(7, 14, __pyx_L1_error)
+    }
+    __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(7, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_9 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_8, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7);
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "(tree fragment)":13
+ * cdef __pyx_unpickle_PseudoSocket__set_state(PseudoSocket __pyx_result, tuple __pyx_state):
+ *     __pyx_result._family = __pyx_state[0]; __pyx_result._fd = __pyx_state[1]; __pyx_result._peername = __pyx_state[2]; __pyx_result._proto = __pyx_state[3]; __pyx_result._sockname = __pyx_state[4]; __pyx_result._type = __pyx_state[5]
+ *     if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'):             # <<<<<<<<<<<<<<
+ *         __pyx_result.__dict__.update(__pyx_state[6])
+ */
+  }
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_PseudoSocket__set_state(<PseudoSocket> __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PseudoSocket__set_state(PseudoSocket __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result._family = __pyx_state[0]; __pyx_result._fd = __pyx_state[1]; __pyx_result._peername = __pyx_state[2]; __pyx_result._proto = __pyx_state[3]; __pyx_result._sockname = __pyx_state[4]; __pyx_result._type = __pyx_state[5]
+ *     if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.__pyx_unpickle_PseudoSocket__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __pyx_unpickle_LruCache(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_6uvloop_4loop_6__pyx_unpickle_LruCache(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_6uvloop_4loop_5__pyx_unpickle_LruCache[] = "__pyx_unpickle_LruCache(__pyx_type, long __pyx_checksum, __pyx_state)";
+static PyMethodDef __pyx_mdef_6uvloop_4loop_6__pyx_unpickle_LruCache = {"__pyx_unpickle_LruCache", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_6__pyx_unpickle_LruCache, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_5__pyx_unpickle_LruCache};
+static PyObject *__pyx_pw_6uvloop_4loop_6__pyx_unpickle_LruCache(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v___pyx_type = 0;
+  long __pyx_v___pyx_checksum;
+  PyObject *__pyx_v___pyx_state = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__pyx_unpickle_LruCache (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,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_pyx_type)) != 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_pyx_checksum)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_LruCache", 1, 3, 3, 1); __PYX_ERR(7, 1, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_LruCache", 1, 3, 3, 2); __PYX_ERR(7, 1, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_LruCache") < 0)) __PYX_ERR(7, 1, __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___pyx_type = values[0];
+    __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(7, 1, __pyx_L3_error)
+    __pyx_v___pyx_state = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_LruCache", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(7, 1, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("uvloop.loop.__pyx_unpickle_LruCache", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6uvloop_4loop_5__pyx_unpickle_LruCache(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6uvloop_4loop_5__pyx_unpickle_LruCache(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_v___pyx_PickleError = 0;
+  PyObject *__pyx_v___pyx_result = 0;
+  PyObject *__pyx_r = NULL;
+  __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;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__pyx_unpickle_LruCache", 0);
+
+  /* "(tree fragment)":4
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ *     if __pyx_checksum != 0x53368d7:             # <<<<<<<<<<<<<<
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x53368d7 = (_dict, _dict_get, _dict_move_to_end, _maxsize))" % __pyx_checksum)
+ */
+  __pyx_t_1 = ((__pyx_v___pyx_checksum != 0x53368d7) != 0);
+  if (__pyx_t_1) {
+
+    /* "(tree fragment)":5
+ *     cdef object __pyx_result
+ *     if __pyx_checksum != 0x53368d7:
+ *         from pickle import PickleError as __pyx_PickleError             # <<<<<<<<<<<<<<
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x53368d7 = (_dict, _dict_get, _dict_move_to_end, _maxsize))" % __pyx_checksum)
+ *     __pyx_result = LruCache.__new__(__pyx_type)
+ */
+    __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 5, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_n_s_PickleError);
+    __Pyx_GIVEREF(__pyx_n_s_PickleError);
+    PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError);
+    __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 5, __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_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 5, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_2);
+    __pyx_v___pyx_PickleError = __pyx_t_2;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "(tree fragment)":6
+ *     if __pyx_checksum != 0x53368d7:
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x53368d7 = (_dict, _dict_get, _dict_move_to_end, _maxsize))" % __pyx_checksum)             # <<<<<<<<<<<<<<
+ *     __pyx_result = LruCache.__new__(__pyx_type)
+ *     if __pyx_state is not None:
+ */
+    __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 6, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0x53, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(7, 6, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_INCREF(__pyx_v___pyx_PickleError);
+    __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_5)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __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_3)) __PYX_ERR(7, 6, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(7, 6, __pyx_L1_error)
+
+    /* "(tree fragment)":4
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ *     if __pyx_checksum != 0x53368d7:             # <<<<<<<<<<<<<<
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x53368d7 = (_dict, _dict_get, _dict_move_to_end, _maxsize))" % __pyx_checksum)
+ */
+  }
+
+  /* "(tree fragment)":7
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x53368d7 = (_dict, _dict_get, _dict_move_to_end, _maxsize))" % __pyx_checksum)
+ *     __pyx_result = LruCache.__new__(__pyx_type)             # <<<<<<<<<<<<<<
+ *     if __pyx_state is not None:
+ *         __pyx_unpickle_LruCache__set_state(<LruCache> __pyx_result, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6uvloop_4loop_LruCache), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && 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_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v___pyx_result = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "(tree fragment)":8
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x53368d7 = (_dict, _dict_get, _dict_move_to_end, _maxsize))" % __pyx_checksum)
+ *     __pyx_result = LruCache.__new__(__pyx_type)
+ *     if __pyx_state is not None:             # <<<<<<<<<<<<<<
+ *         __pyx_unpickle_LruCache__set_state(<LruCache> __pyx_result, __pyx_state)
+ *     return __pyx_result
+ */
+  __pyx_t_1 = (__pyx_v___pyx_state != Py_None);
+  __pyx_t_6 = (__pyx_t_1 != 0);
+  if (__pyx_t_6) {
+
+    /* "(tree fragment)":9
+ *     __pyx_result = LruCache.__new__(__pyx_type)
+ *     if __pyx_state is not None:
+ *         __pyx_unpickle_LruCache__set_state(<LruCache> __pyx_result, __pyx_state)             # <<<<<<<<<<<<<<
+ *     return __pyx_result
+ * cdef __pyx_unpickle_LruCache__set_state(LruCache __pyx_result, tuple __pyx_state):
+ */
+    if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(7, 9, __pyx_L1_error)
+    __pyx_t_3 = __pyx_f_6uvloop_4loop___pyx_unpickle_LruCache__set_state(((struct __pyx_obj_6uvloop_4loop_LruCache *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 9, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "(tree fragment)":8
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0x53368d7 = (_dict, _dict_get, _dict_move_to_end, _maxsize))" % __pyx_checksum)
+ *     __pyx_result = LruCache.__new__(__pyx_type)
+ *     if __pyx_state is not None:             # <<<<<<<<<<<<<<
+ *         __pyx_unpickle_LruCache__set_state(<LruCache> __pyx_result, __pyx_state)
+ *     return __pyx_result
+ */
+  }
+
+  /* "(tree fragment)":10
+ *     if __pyx_state is not None:
+ *         __pyx_unpickle_LruCache__set_state(<LruCache> __pyx_result, __pyx_state)
+ *     return __pyx_result             # <<<<<<<<<<<<<<
+ * cdef __pyx_unpickle_LruCache__set_state(LruCache __pyx_result, tuple __pyx_state):
+ *     __pyx_result._dict = __pyx_state[0]; __pyx_result._dict_get = __pyx_state[1]; __pyx_result._dict_move_to_end = __pyx_state[2]; __pyx_result._maxsize = __pyx_state[3]
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v___pyx_result);
+  __pyx_r = __pyx_v___pyx_result;
+  goto __pyx_L0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_LruCache(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+
+  /* 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_AddTraceback("uvloop.loop.__pyx_unpickle_LruCache", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v___pyx_PickleError);
+  __Pyx_XDECREF(__pyx_v___pyx_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":11
+ *         __pyx_unpickle_LruCache__set_state(<LruCache> __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_LruCache__set_state(LruCache __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result._dict = __pyx_state[0]; __pyx_result._dict_get = __pyx_state[1]; __pyx_result._dict_move_to_end = __pyx_state[2]; __pyx_result._maxsize = __pyx_state[3]
+ *     if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'):
+ */
+
+static PyObject *__pyx_f_6uvloop_4loop___pyx_unpickle_LruCache__set_state(struct __pyx_obj_6uvloop_4loop_LruCache *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__pyx_unpickle_LruCache__set_state", 0);
+
+  /* "(tree fragment)":12
+ *     return __pyx_result
+ * cdef __pyx_unpickle_LruCache__set_state(LruCache __pyx_result, tuple __pyx_state):
+ *     __pyx_result._dict = __pyx_state[0]; __pyx_result._dict_get = __pyx_state[1]; __pyx_result._dict_move_to_end = __pyx_state[2]; __pyx_result._maxsize = __pyx_state[3]             # <<<<<<<<<<<<<<
+ *     if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[4])
+ */
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(7, 12, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v___pyx_result->_dict);
+  __Pyx_DECREF(__pyx_v___pyx_result->_dict);
+  __pyx_v___pyx_result->_dict = __pyx_t_1;
+  __pyx_t_1 = 0;
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(7, 12, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v___pyx_result->_dict_get);
+  __Pyx_DECREF(__pyx_v___pyx_result->_dict_get);
+  __pyx_v___pyx_result->_dict_get = __pyx_t_1;
+  __pyx_t_1 = 0;
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(7, 12, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v___pyx_result->_dict_move_to_end);
+  __Pyx_DECREF(__pyx_v___pyx_result->_dict_move_to_end);
+  __pyx_v___pyx_result->_dict_move_to_end = __pyx_t_1;
+  __pyx_t_1 = 0;
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(7, 12, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(7, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v___pyx_result->_maxsize = __pyx_t_2;
+
+  /* "(tree fragment)":13
+ * cdef __pyx_unpickle_LruCache__set_state(LruCache __pyx_result, tuple __pyx_state):
+ *     __pyx_result._dict = __pyx_state[0]; __pyx_result._dict_get = __pyx_state[1]; __pyx_result._dict_move_to_end = __pyx_state[2]; __pyx_result._maxsize = __pyx_state[3]
+ *     if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'):             # <<<<<<<<<<<<<<
+ *         __pyx_result.__dict__.update(__pyx_state[4])
+ */
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(7, 13, __pyx_L1_error)
+  }
+  __pyx_t_4 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(7, 13, __pyx_L1_error)
+  __pyx_t_5 = ((__pyx_t_4 > 4) != 0);
+  if (__pyx_t_5) {
+  } else {
+    __pyx_t_3 = __pyx_t_5;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(7, 13, __pyx_L1_error)
+  __pyx_t_6 = (__pyx_t_5 != 0);
+  __pyx_t_3 = __pyx_t_6;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_3) {
+
+    /* "(tree fragment)":14
+ *     __pyx_result._dict = __pyx_state[0]; __pyx_result._dict_get = __pyx_state[1]; __pyx_result._dict_move_to_end = __pyx_state[2]; __pyx_result._maxsize = __pyx_state[3]
+ *     if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[4])             # <<<<<<<<<<<<<<
+ */
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(7, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_update); if (unlikely(!__pyx_t_8)) __PYX_ERR(7, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(__pyx_v___pyx_state == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(7, 14, __pyx_L1_error)
+    }
+    __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(7, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_9 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_8, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7);
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "(tree fragment)":13
+ * cdef __pyx_unpickle_LruCache__set_state(LruCache __pyx_result, tuple __pyx_state):
+ *     __pyx_result._dict = __pyx_state[0]; __pyx_result._dict_get = __pyx_state[1]; __pyx_result._dict_move_to_end = __pyx_state[2]; __pyx_result._maxsize = __pyx_state[3]
+ *     if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'):             # <<<<<<<<<<<<<<
+ *         __pyx_result.__dict__.update(__pyx_state[4])
+ */
+  }
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_LruCache__set_state(<LruCache> __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_LruCache__set_state(LruCache __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result._dict = __pyx_state[0]; __pyx_result._dict_get = __pyx_state[1]; __pyx_result._dict_move_to_end = __pyx_state[2]; __pyx_result._maxsize = __pyx_state[3]
+ *     if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("uvloop.loop.__pyx_unpickle_LruCache__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "includes/flowcontrol.pxd":4
+ * 
+ * 
+ * cdef inline add_flowcontrol_defaults(high, low, int kb):             # <<<<<<<<<<<<<<
+ *     cdef int h, l
+ *     if high is None:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_6uvloop_8includes_11flowcontrol_add_flowcontrol_defaults(PyObject *__pyx_v_high, PyObject *__pyx_v_low, int __pyx_v_kb) {
+  int __pyx_v_h;
+  int __pyx_v_l;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  Py_ssize_t __pyx_t_5;
+  Py_UCS4 __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("add_flowcontrol_defaults", 0);
+
+  /* "includes/flowcontrol.pxd":6
+ * cdef inline add_flowcontrol_defaults(high, low, int kb):
+ *     cdef int h, l
+ *     if high is None:             # <<<<<<<<<<<<<<
+ *         if low is None:
+ *             h = kb * 1024
+ */
+  __pyx_t_1 = (__pyx_v_high == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "includes/flowcontrol.pxd":7
+ *     cdef int h, l
+ *     if high is None:
+ *         if low is None:             # <<<<<<<<<<<<<<
+ *             h = kb * 1024
+ *         else:
+ */
+    __pyx_t_2 = (__pyx_v_low == Py_None);
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (__pyx_t_1) {
+
+      /* "includes/flowcontrol.pxd":8
+ *     if high is None:
+ *         if low is None:
+ *             h = kb * 1024             # <<<<<<<<<<<<<<
+ *         else:
+ *             l = low
+ */
+      __pyx_v_h = (__pyx_v_kb * 0x400);
+
+      /* "includes/flowcontrol.pxd":7
+ *     cdef int h, l
+ *     if high is None:
+ *         if low is None:             # <<<<<<<<<<<<<<
+ *             h = kb * 1024
+ *         else:
+ */
+      goto __pyx_L4;
+    }
+
+    /* "includes/flowcontrol.pxd":10
+ *             h = kb * 1024
+ *         else:
+ *             l = low             # <<<<<<<<<<<<<<
+ *             h = 4 * l
+ *     else:
+ */
+    /*else*/ {
+      __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_low); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(25, 10, __pyx_L1_error)
+      __pyx_v_l = __pyx_t_3;
+
+      /* "includes/flowcontrol.pxd":11
+ *         else:
+ *             l = low
+ *             h = 4 * l             # <<<<<<<<<<<<<<
+ *     else:
+ *         h = high
+ */
+      __pyx_v_h = (4 * __pyx_v_l);
+    }
+    __pyx_L4:;
+
+    /* "includes/flowcontrol.pxd":6
+ * cdef inline add_flowcontrol_defaults(high, low, int kb):
+ *     cdef int h, l
+ *     if high is None:             # <<<<<<<<<<<<<<
+ *         if low is None:
+ *             h = kb * 1024
+ */
+    goto __pyx_L3;
+  }
+
+  /* "includes/flowcontrol.pxd":13
+ *             h = 4 * l
+ *     else:
+ *         h = high             # <<<<<<<<<<<<<<
+ *     if low is None:
+ *         l = h // 4
+ */
+  /*else*/ {
+    __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_high); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(25, 13, __pyx_L1_error)
+    __pyx_v_h = __pyx_t_3;
+  }
+  __pyx_L3:;
+
+  /* "includes/flowcontrol.pxd":14
+ *     else:
+ *         h = high
+ *     if low is None:             # <<<<<<<<<<<<<<
+ *         l = h // 4
+ *     else:
+ */
+  __pyx_t_1 = (__pyx_v_low == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "includes/flowcontrol.pxd":15
+ *         h = high
+ *     if low is None:
+ *         l = h // 4             # <<<<<<<<<<<<<<
+ *     else:
+ *         l = low
+ */
+    __pyx_v_l = __Pyx_div_long(__pyx_v_h, 4);
+
+    /* "includes/flowcontrol.pxd":14
+ *     else:
+ *         h = high
+ *     if low is None:             # <<<<<<<<<<<<<<
+ *         l = h // 4
+ *     else:
+ */
+    goto __pyx_L5;
+  }
+
+  /* "includes/flowcontrol.pxd":17
+ *         l = h // 4
+ *     else:
+ *         l = low             # <<<<<<<<<<<<<<
+ * 
+ *     if not h >= l >= 0:
+ */
+  /*else*/ {
+    __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_low); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(25, 17, __pyx_L1_error)
+    __pyx_v_l = __pyx_t_3;
+  }
+  __pyx_L5:;
+
+  /* "includes/flowcontrol.pxd":19
+ *         l = low
+ * 
+ *     if not h >= l >= 0:             # <<<<<<<<<<<<<<
+ *         raise ValueError('high (%r) must be >= low (%r) must be >= 0' %
+ *                          (h, l))
+ */
+  __pyx_t_2 = (__pyx_v_h >= __pyx_v_l);
+  if (__pyx_t_2) {
+    __pyx_t_2 = (__pyx_v_l >= 0);
+  }
+  __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "includes/flowcontrol.pxd":20
+ * 
+ *     if not h >= l >= 0:
+ *         raise ValueError('high (%r) must be >= low (%r) must be >= 0' %             # <<<<<<<<<<<<<<
+ *                          (h, l))
+ * 
+ */
+    __pyx_t_4 = PyTuple_New(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 20, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 127;
+    __Pyx_INCREF(__pyx_kp_u_high_2);
+    __pyx_t_5 += 6;
+    __Pyx_GIVEREF(__pyx_kp_u_high_2);
+    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_high_2);
+
+    /* "includes/flowcontrol.pxd":21
+ *     if not h >= l >= 0:
+ *         raise ValueError('high (%r) must be >= low (%r) must be >= 0' %
+ *                          (h, l))             # <<<<<<<<<<<<<<
+ * 
+ *     return h, l
+ */
+    __pyx_t_7 = __Pyx_PyUnicode_From_int(__pyx_v_h, 0, ' ', 'd'); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_7);
+    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_7);
+    __pyx_t_7 = 0;
+    __Pyx_INCREF(__pyx_kp_u_must_be_low);
+    __pyx_t_5 += 18;
+    __Pyx_GIVEREF(__pyx_kp_u_must_be_low);
+    PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u_must_be_low);
+    __pyx_t_7 = __Pyx_PyUnicode_From_int(__pyx_v_l, 0, ' ', 'd'); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_7);
+    PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_7);
+    __pyx_t_7 = 0;
+    __Pyx_INCREF(__pyx_kp_u_must_be_0);
+    __pyx_t_5 += 14;
+    __Pyx_GIVEREF(__pyx_kp_u_must_be_0);
+    PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_kp_u_must_be_0);
+
+    /* "includes/flowcontrol.pxd":20
+ * 
+ *     if not h >= l >= 0:
+ *         raise ValueError('high (%r) must be >= low (%r) must be >= 0' %             # <<<<<<<<<<<<<<
+ *                          (h, l))
+ * 
+ */
+    __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_4, 5, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 20, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 20, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(25, 20, __pyx_L1_error)
+
+    /* "includes/flowcontrol.pxd":19
+ *         l = low
+ * 
+ *     if not h >= l >= 0:             # <<<<<<<<<<<<<<
+ *         raise ValueError('high (%r) must be >= low (%r) must be >= 0' %
+ *                          (h, l))
+ */
+  }
+
+  /* "includes/flowcontrol.pxd":23
+ *                          (h, l))
+ * 
+ *     return h, l             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_h); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_l); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(25, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7);
+  __pyx_t_4 = 0;
+  __pyx_t_7 = 0;
+  __pyx_r = __pyx_t_8;
+  __pyx_t_8 = 0;
+  goto __pyx_L0;
+
+  /* "includes/flowcontrol.pxd":4
+ * 
+ * 
+ * cdef inline add_flowcontrol_defaults(high, low, int kb):             # <<<<<<<<<<<<<<
+ *     cdef int h, l
+ *     if high is None:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("uvloop.includes.flowcontrol.add_flowcontrol_defaults", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "cfunc.to_py":65
+ * @cname("__Pyx_CFunc_object____Loop____bint___to_py")
+ * cdef object __Pyx_CFunc_object____Loop____bint___to_py(object (*f)(Loop, bint) ):
+ *     def wrap(Loop self, bint enabled):             # <<<<<<<<<<<<<<
+ *         """wrap(self: 'Loop', enabled: bool)"""
+ *         return f(self, enabled)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11cfunc_dot_to_py_42__Pyx_CFunc_object____Loop____bint___to_py_1wrap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_11cfunc_dot_to_py_42__Pyx_CFunc_object____Loop____bint___to_py_wrap[] = "wrap(self: 'Loop', enabled: bool)";
+static PyMethodDef __pyx_mdef_11cfunc_dot_to_py_42__Pyx_CFunc_object____Loop____bint___to_py_1wrap = {"wrap", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_11cfunc_dot_to_py_42__Pyx_CFunc_object____Loop____bint___to_py_1wrap, METH_VARARGS|METH_KEYWORDS, __pyx_doc_11cfunc_dot_to_py_42__Pyx_CFunc_object____Loop____bint___to_py_wrap};
+static PyObject *__pyx_pw_11cfunc_dot_to_py_42__Pyx_CFunc_object____Loop____bint___to_py_1wrap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self = 0;
+  int __pyx_v_enabled;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("wrap (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self_2,&__pyx_n_s_enabled,0};
+    PyObject* values[2] = {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  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_self_2)) != 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_enabled)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("wrap", 1, 2, 2, 1); __PYX_ERR(7, 65, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "wrap") < 0)) __PYX_ERR(7, 65, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_self = ((struct __pyx_obj_6uvloop_4loop_Loop *)values[0]);
+    __pyx_v_enabled = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_enabled == (int)-1) && PyErr_Occurred())) __PYX_ERR(7, 65, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("wrap", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(7, 65, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("cfunc.to_py.__Pyx_CFunc_object____Loop____bint___to_py.wrap", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_self), __pyx_ptype_6uvloop_4loop_Loop, 1, "self", 0))) __PYX_ERR(7, 65, __pyx_L1_error)
+  __pyx_r = __pyx_pf_11cfunc_dot_to_py_42__Pyx_CFunc_object____Loop____bint___to_py_wrap(__pyx_self, __pyx_v_self, __pyx_v_enabled);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11cfunc_dot_to_py_42__Pyx_CFunc_object____Loop____bint___to_py_wrap(PyObject *__pyx_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, int __pyx_v_enabled) {
+  struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py *__pyx_cur_scope;
+  struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py *__pyx_outer_scope;
+  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("wrap", 0);
+  __pyx_outer_scope = (struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py *) __Pyx_CyFunction_GetClosure(__pyx_self);
+  __pyx_cur_scope = __pyx_outer_scope;
+
+  /* "cfunc.to_py":67
+ *     def wrap(Loop self, bint enabled):
+ *         """wrap(self: 'Loop', enabled: bool)"""
+ *         return f(self, enabled)             # <<<<<<<<<<<<<<
+ *     return wrap
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_cur_scope->__pyx_v_f(__pyx_v_self, __pyx_v_enabled); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "cfunc.to_py":65
+ * @cname("__Pyx_CFunc_object____Loop____bint___to_py")
+ * cdef object __Pyx_CFunc_object____Loop____bint___to_py(object (*f)(Loop, bint) ):
+ *     def wrap(Loop self, bint enabled):             # <<<<<<<<<<<<<<
+ *         """wrap(self: 'Loop', enabled: bool)"""
+ *         return f(self, enabled)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("cfunc.to_py.__Pyx_CFunc_object____Loop____bint___to_py.wrap", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "cfunc.to_py":64
+ * 
+ * @cname("__Pyx_CFunc_object____Loop____bint___to_py")
+ * cdef object __Pyx_CFunc_object____Loop____bint___to_py(object (*f)(Loop, bint) ):             # <<<<<<<<<<<<<<
+ *     def wrap(Loop self, bint enabled):
+ *         """wrap(self: 'Loop', enabled: bool)"""
+ */
+
+static PyObject *__Pyx_CFunc_object____Loop____bint___to_py(PyObject *(*__pyx_v_f)(struct __pyx_obj_6uvloop_4loop_Loop *, int)) {
+  struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py *__pyx_cur_scope;
+  PyObject *__pyx_v_wrap = 0;
+  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("__Pyx_CFunc_object____Loop____bint___to_py", 0);
+  __pyx_cur_scope = (struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py *)__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py(__pyx_ptype___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(7, 64, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__pyx_cur_scope);
+  }
+  __pyx_cur_scope->__pyx_v_f = __pyx_v_f;
+
+  /* "cfunc.to_py":65
+ * @cname("__Pyx_CFunc_object____Loop____bint___to_py")
+ * cdef object __Pyx_CFunc_object____Loop____bint___to_py(object (*f)(Loop, bint) ):
+ *     def wrap(Loop self, bint enabled):             # <<<<<<<<<<<<<<
+ *         """wrap(self: 'Loop', enabled: bool)"""
+ *         return f(self, enabled)
+ */
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_11cfunc_dot_to_py_42__Pyx_CFunc_object____Loop____bint___to_py_1wrap, 0, __pyx_n_s_Pyx_CFunc_object____Loop____bi, ((PyObject*)__pyx_cur_scope), __pyx_n_s_cfunc_to_py, __pyx_d, ((PyObject *)__pyx_codeobj__232)); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_wrap = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "cfunc.to_py":68
+ *         """wrap(self: 'Loop', enabled: bool)"""
+ *         return f(self, enabled)
+ *     return wrap             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_wrap);
+  __pyx_r = __pyx_v_wrap;
+  goto __pyx_L0;
+
+  /* "cfunc.to_py":64
+ * 
+ * @cname("__Pyx_CFunc_object____Loop____bint___to_py")
+ * cdef object __Pyx_CFunc_object____Loop____bint___to_py(object (*f)(Loop, bint) ):             # <<<<<<<<<<<<<<
+ *     def wrap(Loop self, bint enabled):
+ *         """wrap(self: 'Loop', enabled: bool)"""
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("cfunc.to_py.__Pyx_CFunc_object____Loop____bint___to_py", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_wrap);
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_vtable_6uvloop_4loop_UVHandle;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVHandle(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVHandle *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_6uvloop_4loop_UVHandle *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop_UVHandle;
+  p->_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  p->_source_traceback = Py_None; Py_INCREF(Py_None);
+  p->context = Py_None; Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_8UVHandle_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVHandle(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVHandle *p = (struct __pyx_obj_6uvloop_4loop_UVHandle *)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_6uvloop_4loop_8UVHandle_5__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->_loop);
+  Py_CLEAR(p->_source_traceback);
+  Py_CLEAR(p->context);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVHandle(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVHandle *p = (struct __pyx_obj_6uvloop_4loop_UVHandle *)o;
+  if (p->_loop) {
+    e = (*v)(((PyObject *)p->_loop), a); if (e) return e;
+  }
+  if (p->_source_traceback) {
+    e = (*v)(p->_source_traceback, a); if (e) return e;
+  }
+  if (p->context) {
+    e = (*v)(p->context, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop_UVHandle(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop_UVHandle *p = (struct __pyx_obj_6uvloop_4loop_UVHandle *)o;
+  tmp = ((PyObject*)p->_loop);
+  p->_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_source_traceback);
+  p->_source_traceback = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->context);
+  p->context = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_8UVHandle__source_traceback(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_8UVHandle_17_source_traceback_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVHandle[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_8UVHandle_9__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_8UVHandle_8__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_8UVHandle_11__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_8UVHandle_10__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_6uvloop_4loop_UVHandle[] = {
+  {(char *)"_source_traceback", __pyx_getprop_6uvloop_4loop_8UVHandle__source_traceback, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVHandle = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVHandle", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVHandle), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVHandle, /*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
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*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*/
+  "UVHandle()\nA base class for all libuv handles.\n\n    Automatically manages memory deallocation and closing.\n\n    Important:\n\n       1. call \"_ensure_alive()\" before calling any libuv functions on\n          your handles.\n\n       2. call \"__ensure_handle_data\" in *all* libuv handle callbacks.\n    ", /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop_UVHandle, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop_UVHandle, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVHandle, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_6uvloop_4loop_UVHandle, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVHandle, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle __pyx_vtable_6uvloop_4loop_UVSocketHandle;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVSocketHandle(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVSocketHandle *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVHandle(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UVSocketHandle;
+  p->_fileobj = Py_None; Py_INCREF(Py_None);
+  p->__pyx___cached_socket = Py_None; Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_14UVSocketHandle_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVSocketHandle(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVSocketHandle *p = (struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)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);
+  Py_CLEAR(p->_fileobj);
+  Py_CLEAR(p->__pyx___cached_socket);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVHandle(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVSocketHandle(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVSocketHandle *p = (struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVHandle(o, v, a); if (e) return e;
+  if (p->_fileobj) {
+    e = (*v)(p->_fileobj, a); if (e) return e;
+  }
+  if (p->__pyx___cached_socket) {
+    e = (*v)(p->__pyx___cached_socket, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop_UVSocketHandle(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop_UVSocketHandle *p = (struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)o;
+  __pyx_tp_clear_6uvloop_4loop_UVHandle(o);
+  tmp = ((PyObject*)p->_fileobj);
+  p->_fileobj = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->__pyx___cached_socket);
+  p->__pyx___cached_socket = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVSocketHandle[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_14UVSocketHandle_3__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_14UVSocketHandle_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_14UVSocketHandle_5__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_14UVSocketHandle_4__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVSocketHandle = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVSocketHandle", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVSocketHandle), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVSocketHandle, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVSocketHandle, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop_UVSocketHandle, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVSocketHandle, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVSocketHandle, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVAsync __pyx_vtable_6uvloop_4loop_UVAsync;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVAsync(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVAsync *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVHandle(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UVAsync *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UVAsync;
+  p->ctx = Py_None; Py_INCREF(Py_None);
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVAsync(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVAsync *p = (struct __pyx_obj_6uvloop_4loop_UVAsync *)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);
+  Py_CLEAR(p->ctx);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVHandle(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVAsync(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVAsync *p = (struct __pyx_obj_6uvloop_4loop_UVAsync *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVHandle(o, v, a); if (e) return e;
+  if (p->ctx) {
+    e = (*v)(p->ctx, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVAsync[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_7UVAsync_1__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_7UVAsync___reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_7UVAsync_3__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_7UVAsync_2__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVAsync = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVAsync", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVAsync), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVAsync, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVAsync, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVAsync, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVAsync, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVTimer __pyx_vtable_6uvloop_4loop_UVTimer;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVTimer(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVTimer *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVHandle(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UVTimer *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UVTimer;
+  p->ctx = Py_None; Py_INCREF(Py_None);
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVTimer(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVTimer *p = (struct __pyx_obj_6uvloop_4loop_UVTimer *)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);
+  Py_CLEAR(p->ctx);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVHandle(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVTimer(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVTimer *p = (struct __pyx_obj_6uvloop_4loop_UVTimer *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVHandle(o, v, a); if (e) return e;
+  if (p->ctx) {
+    e = (*v)(p->ctx, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVTimer[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_7UVTimer_1__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_7UVTimer___reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_7UVTimer_3__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_7UVTimer_2__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVTimer = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVTimer", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVTimer), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVTimer, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVTimer, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVTimer, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVTimer, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVIdle __pyx_vtable_6uvloop_4loop_UVIdle;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVIdle(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVIdle *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVHandle(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UVIdle *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UVIdle;
+  p->h = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None); Py_INCREF(Py_None);
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVIdle(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVIdle *p = (struct __pyx_obj_6uvloop_4loop_UVIdle *)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);
+  Py_CLEAR(p->h);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVHandle(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVIdle(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVIdle *p = (struct __pyx_obj_6uvloop_4loop_UVIdle *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVHandle(o, v, a); if (e) return e;
+  if (p->h) {
+    e = (*v)(((PyObject *)p->h), a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVIdle[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_6UVIdle_1__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_6UVIdle___reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_6UVIdle_3__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_6UVIdle_2__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVIdle = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVIdle", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVIdle), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVIdle, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVIdle, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVIdle, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVIdle, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport __pyx_vtable_6uvloop_4loop_UVBaseTransport;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVBaseTransport(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVBaseTransport *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVSocketHandle(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)o);
+  p->__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UVBaseTransport;
+  p->_protocol_data_received = Py_None; Py_INCREF(Py_None);
+  p->_protocol = Py_None; Py_INCREF(Py_None);
+  p->_server = ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None); Py_INCREF(Py_None);
+  p->_waiter = Py_None; Py_INCREF(Py_None);
+  p->_extra_info = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_15UVBaseTransport_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVBaseTransport(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVBaseTransport *p = (struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)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);
+  if (p->__weakref__) PyObject_ClearWeakRefs(o);
+  Py_CLEAR(p->_protocol_data_received);
+  Py_CLEAR(p->_protocol);
+  Py_CLEAR(p->_server);
+  Py_CLEAR(p->_waiter);
+  Py_CLEAR(p->_extra_info);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVSocketHandle(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVBaseTransport(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVBaseTransport *p = (struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVSocketHandle(o, v, a); if (e) return e;
+  if (p->_protocol_data_received) {
+    e = (*v)(p->_protocol_data_received, a); if (e) return e;
+  }
+  if (p->_protocol) {
+    e = (*v)(p->_protocol, a); if (e) return e;
+  }
+  if (p->_server) {
+    e = (*v)(((PyObject *)p->_server), a); if (e) return e;
+  }
+  if (p->_waiter) {
+    e = (*v)(p->_waiter, a); if (e) return e;
+  }
+  if (p->_extra_info) {
+    e = (*v)(p->_extra_info, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop_UVBaseTransport(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop_UVBaseTransport *p = (struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)o;
+  __pyx_tp_clear_6uvloop_4loop_UVSocketHandle(o);
+  tmp = ((PyObject*)p->_protocol_data_received);
+  p->_protocol_data_received = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_protocol);
+  p->_protocol = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_server);
+  p->_server = ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_waiter);
+  p->_waiter = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_extra_info);
+  p->_extra_info = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_15UVBaseTransport__paused(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_15UVBaseTransport_7_paused_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_15UVBaseTransport__closing(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_15UVBaseTransport_8_closing_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVBaseTransport[] = {
+  {"get_protocol", (PyCFunction)__pyx_pw_6uvloop_4loop_15UVBaseTransport_3get_protocol, METH_NOARGS, __pyx_doc_6uvloop_4loop_15UVBaseTransport_2get_protocol},
+  {"set_protocol", (PyCFunction)__pyx_pw_6uvloop_4loop_15UVBaseTransport_5set_protocol, METH_O, __pyx_doc_6uvloop_4loop_15UVBaseTransport_4set_protocol},
+  {"_force_close", (PyCFunction)__pyx_pw_6uvloop_4loop_15UVBaseTransport_7_force_close, METH_O, __pyx_doc_6uvloop_4loop_15UVBaseTransport_6_force_close},
+  {"abort", (PyCFunction)__pyx_pw_6uvloop_4loop_15UVBaseTransport_9abort, METH_NOARGS, __pyx_doc_6uvloop_4loop_15UVBaseTransport_8abort},
+  {"close", (PyCFunction)__pyx_pw_6uvloop_4loop_15UVBaseTransport_11close, METH_NOARGS, __pyx_doc_6uvloop_4loop_15UVBaseTransport_10close},
+  {"is_closing", (PyCFunction)__pyx_pw_6uvloop_4loop_15UVBaseTransport_13is_closing, METH_NOARGS, __pyx_doc_6uvloop_4loop_15UVBaseTransport_12is_closing},
+  {"get_write_buffer_size", (PyCFunction)__pyx_pw_6uvloop_4loop_15UVBaseTransport_15get_write_buffer_size, METH_NOARGS, __pyx_doc_6uvloop_4loop_15UVBaseTransport_14get_write_buffer_size},
+  {"set_write_buffer_limits", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_15UVBaseTransport_17set_write_buffer_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_15UVBaseTransport_16set_write_buffer_limits},
+  {"get_write_buffer_limits", (PyCFunction)__pyx_pw_6uvloop_4loop_15UVBaseTransport_19get_write_buffer_limits, METH_NOARGS, __pyx_doc_6uvloop_4loop_15UVBaseTransport_18get_write_buffer_limits},
+  {"get_extra_info", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_15UVBaseTransport_21get_extra_info, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_15UVBaseTransport_20get_extra_info},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_15UVBaseTransport_23__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_15UVBaseTransport_22__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_15UVBaseTransport_25__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_15UVBaseTransport_24__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_6uvloop_4loop_UVBaseTransport[] = {
+  {(char *)"_paused", __pyx_getprop_6uvloop_4loop_15UVBaseTransport__paused, 0, (char *)0, 0},
+  {(char *)"_closing", __pyx_getprop_6uvloop_4loop_15UVBaseTransport__closing, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVBaseTransport = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVBaseTransport", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVBaseTransport), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVBaseTransport, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVBaseTransport, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop_UVBaseTransport, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVBaseTransport, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_6uvloop_4loop_UVBaseTransport, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVBaseTransport, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_Loop __pyx_vtable_6uvloop_4loop_Loop;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_Loop(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_Loop *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_6uvloop_4loop_Loop *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop_Loop;
+  p->slow_callback_duration = Py_None; Py_INCREF(Py_None);
+  p->_task_factory = Py_None; Py_INCREF(Py_None);
+  p->_exception_handler = Py_None; Py_INCREF(Py_None);
+  p->_default_executor = Py_None; Py_INCREF(Py_None);
+  p->_ready = Py_None; Py_INCREF(Py_None);
+  p->_queued_streams = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_servers = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_transports = Py_None; Py_INCREF(Py_None);
+  p->_processes = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_fd_to_reader_fileobj = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_fd_to_writer_fileobj = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_signals = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_signal_handlers = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_ssock = Py_None; Py_INCREF(Py_None);
+  p->_csock = Py_None; Py_INCREF(Py_None);
+  p->_timers = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_polls = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->active_process_handler = ((struct __pyx_obj_6uvloop_4loop_UVProcess *)Py_None); Py_INCREF(Py_None);
+  p->handler_async = ((struct __pyx_obj_6uvloop_4loop_UVAsync *)Py_None); Py_INCREF(Py_None);
+  p->handler_idle = ((struct __pyx_obj_6uvloop_4loop_UVIdle *)Py_None); Py_INCREF(Py_None);
+  p->handler_check__exec_writes = ((struct __pyx_obj_6uvloop_4loop_UVCheck *)Py_None); Py_INCREF(Py_None);
+  p->_last_error = Py_None; Py_INCREF(Py_None);
+  p->_asyncgens = Py_None; Py_INCREF(Py_None);
+  p->_debug_handles_total = Py_None; Py_INCREF(Py_None);
+  p->_debug_handles_closed = Py_None; Py_INCREF(Py_None);
+  p->_debug_handles_current = Py_None; Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_4Loop_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_Loop(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_Loop *p = (struct __pyx_obj_6uvloop_4loop_Loop *)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_6uvloop_4loop_4Loop_5__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  if (p->__weakref__) PyObject_ClearWeakRefs(o);
+  Py_CLEAR(p->slow_callback_duration);
+  Py_CLEAR(p->_task_factory);
+  Py_CLEAR(p->_exception_handler);
+  Py_CLEAR(p->_default_executor);
+  Py_CLEAR(p->_ready);
+  Py_CLEAR(p->_queued_streams);
+  Py_CLEAR(p->_servers);
+  Py_CLEAR(p->_transports);
+  Py_CLEAR(p->_processes);
+  Py_CLEAR(p->_fd_to_reader_fileobj);
+  Py_CLEAR(p->_fd_to_writer_fileobj);
+  Py_CLEAR(p->_signals);
+  Py_CLEAR(p->_signal_handlers);
+  Py_CLEAR(p->_ssock);
+  Py_CLEAR(p->_csock);
+  Py_CLEAR(p->_timers);
+  Py_CLEAR(p->_polls);
+  Py_CLEAR(p->active_process_handler);
+  Py_CLEAR(p->handler_async);
+  Py_CLEAR(p->handler_idle);
+  Py_CLEAR(p->handler_check__exec_writes);
+  Py_CLEAR(p->_last_error);
+  Py_CLEAR(p->_asyncgens);
+  Py_CLEAR(p->_debug_handles_total);
+  Py_CLEAR(p->_debug_handles_closed);
+  Py_CLEAR(p->_debug_handles_current);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_Loop(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_Loop *p = (struct __pyx_obj_6uvloop_4loop_Loop *)o;
+  if (p->slow_callback_duration) {
+    e = (*v)(p->slow_callback_duration, a); if (e) return e;
+  }
+  if (p->_task_factory) {
+    e = (*v)(p->_task_factory, a); if (e) return e;
+  }
+  if (p->_exception_handler) {
+    e = (*v)(p->_exception_handler, a); if (e) return e;
+  }
+  if (p->_default_executor) {
+    e = (*v)(p->_default_executor, a); if (e) return e;
+  }
+  if (p->_ready) {
+    e = (*v)(p->_ready, a); if (e) return e;
+  }
+  if (p->_queued_streams) {
+    e = (*v)(p->_queued_streams, a); if (e) return e;
+  }
+  if (p->_servers) {
+    e = (*v)(p->_servers, a); if (e) return e;
+  }
+  if (p->_transports) {
+    e = (*v)(p->_transports, a); if (e) return e;
+  }
+  if (p->_processes) {
+    e = (*v)(p->_processes, a); if (e) return e;
+  }
+  if (p->_fd_to_reader_fileobj) {
+    e = (*v)(p->_fd_to_reader_fileobj, a); if (e) return e;
+  }
+  if (p->_fd_to_writer_fileobj) {
+    e = (*v)(p->_fd_to_writer_fileobj, a); if (e) return e;
+  }
+  if (p->_signals) {
+    e = (*v)(p->_signals, a); if (e) return e;
+  }
+  if (p->_signal_handlers) {
+    e = (*v)(p->_signal_handlers, a); if (e) return e;
+  }
+  if (p->_ssock) {
+    e = (*v)(p->_ssock, a); if (e) return e;
+  }
+  if (p->_csock) {
+    e = (*v)(p->_csock, a); if (e) return e;
+  }
+  if (p->_timers) {
+    e = (*v)(p->_timers, a); if (e) return e;
+  }
+  if (p->_polls) {
+    e = (*v)(p->_polls, a); if (e) return e;
+  }
+  if (p->active_process_handler) {
+    e = (*v)(((PyObject *)p->active_process_handler), a); if (e) return e;
+  }
+  if (p->handler_async) {
+    e = (*v)(((PyObject *)p->handler_async), a); if (e) return e;
+  }
+  if (p->handler_idle) {
+    e = (*v)(((PyObject *)p->handler_idle), a); if (e) return e;
+  }
+  if (p->handler_check__exec_writes) {
+    e = (*v)(((PyObject *)p->handler_check__exec_writes), a); if (e) return e;
+  }
+  if (p->_last_error) {
+    e = (*v)(p->_last_error, a); if (e) return e;
+  }
+  if (p->_asyncgens) {
+    e = (*v)(p->_asyncgens, a); if (e) return e;
+  }
+  if (p->_debug_handles_total) {
+    e = (*v)(p->_debug_handles_total, a); if (e) return e;
+  }
+  if (p->_debug_handles_closed) {
+    e = (*v)(p->_debug_handles_closed, a); if (e) return e;
+  }
+  if (p->_debug_handles_current) {
+    e = (*v)(p->_debug_handles_current, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop_print_debug_info(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_16print_debug_info_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop_slow_callback_duration(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_1__get__(o);
+}
+
+static int __pyx_setprop_6uvloop_4loop_4Loop_slow_callback_duration(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_3__set__(o, v);
+  }
+  else {
+    return __pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_5__del__(o);
+  }
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__closed(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_7_closed_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_cc(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_9_debug_cc_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_handles_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_20_debug_handles_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_handles_closed(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_21_debug_handles_closed_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_handles_current(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_22_debug_handles_current_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_uv_handles_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_23_debug_uv_handles_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_uv_handles_freed(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_23_debug_uv_handles_freed_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_cb_handles_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_23_debug_cb_handles_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_cb_handles_count(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_23_debug_cb_handles_count_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_cb_timer_handles_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_cb_timer_handles_count(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_count_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_shutdown_errors_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_35_debug_stream_shutdown_errors_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_listen_errors_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_33_debug_stream_listen_errors_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_read_cb_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_27_debug_stream_read_cb_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_read_cb_errors_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_34_debug_stream_read_cb_errors_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_read_eof_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_28_debug_stream_read_eof_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_read_eof_cb_errors_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_38_debug_stream_read_eof_cb_errors_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_read_errors_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_31_debug_stream_read_errors_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_write_tries(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_25_debug_stream_write_tries_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_write_errors_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_32_debug_stream_write_errors_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_write_ctx_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_29_debug_stream_write_ctx_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_write_ctx_cnt(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_27_debug_stream_write_ctx_cnt_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_stream_write_cb_errors_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_35_debug_stream_write_cb_errors_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__poll_read_events_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_23_poll_read_events_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__poll_read_cb_errors_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_26_poll_read_cb_errors_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__poll_write_events_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_24_poll_write_events_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__poll_write_cb_errors_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_27_poll_write_cb_errors_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__sock_try_write_total(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_21_sock_try_write_total_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_4Loop__debug_exception_handler_cnt(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_4Loop_28_debug_exception_handler_cnt_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_Loop[] = {
+  {"__sighandler", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_7__sighandler, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_6__sighandler},
+  {"_get_backend_id", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_9_get_backend_id, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_8_get_backend_id},
+  {"call_soon", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_13call_soon, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_12call_soon},
+  {"call_soon_threadsafe", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_15call_soon_threadsafe, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_14call_soon_threadsafe},
+  {"call_later", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_17call_later, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_16call_later},
+  {"call_at", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_19call_at, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_18call_at},
+  {"time", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_21time, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_20time},
+  {"stop", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_23stop, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_22stop},
+  {"run_forever", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_25run_forever, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_24run_forever},
+  {"close", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_27close, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_26close},
+  {"get_debug", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_29get_debug, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_28get_debug},
+  {"set_debug", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_31set_debug, METH_O, __pyx_doc_6uvloop_4loop_4Loop_30set_debug},
+  {"is_running", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_33is_running, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_32is_running},
+  {"is_closed", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_35is_closed, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_34is_closed},
+  {"create_future", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_37create_future, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_36create_future},
+  {"create_task", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_39create_task, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_38create_task},
+  {"set_task_factory", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_41set_task_factory, METH_O, __pyx_doc_6uvloop_4loop_4Loop_40set_task_factory},
+  {"get_task_factory", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_43get_task_factory, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_42get_task_factory},
+  {"run_until_complete", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_45run_until_complete, METH_O, __pyx_doc_6uvloop_4loop_4Loop_44run_until_complete},
+  {"getaddrinfo", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_47getaddrinfo, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_46getaddrinfo},
+  {"getnameinfo", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_50getnameinfo, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_49getnameinfo},
+  {"start_tls", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_53start_tls, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_52start_tls},
+  {"create_server", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_56create_server, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_55create_server},
+  {"create_connection", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_59create_connection, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_58create_connection},
+  {"create_unix_server", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_62create_unix_server, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_61create_unix_server},
+  {"create_unix_connection", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_65create_unix_connection, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_64create_unix_connection},
+  {"default_exception_handler", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_68default_exception_handler, METH_O, __pyx_doc_6uvloop_4loop_4Loop_67default_exception_handler},
+  {"get_exception_handler", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_70get_exception_handler, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_69get_exception_handler},
+  {"set_exception_handler", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_72set_exception_handler, METH_O, __pyx_doc_6uvloop_4loop_4Loop_71set_exception_handler},
+  {"call_exception_handler", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_74call_exception_handler, METH_O, __pyx_doc_6uvloop_4loop_4Loop_73call_exception_handler},
+  {"add_reader", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_76add_reader, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_75add_reader},
+  {"remove_reader", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_78remove_reader, METH_O, __pyx_doc_6uvloop_4loop_4Loop_77remove_reader},
+  {"add_writer", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_80add_writer, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_79add_writer},
+  {"remove_writer", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_82remove_writer, METH_O, __pyx_doc_6uvloop_4loop_4Loop_81remove_writer},
+  {"sock_recv", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_84sock_recv, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_83sock_recv},
+  {"sock_recv_into", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_87sock_recv_into, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_86sock_recv_into},
+  {"sock_sendall", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_90sock_sendall, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_89sock_sendall},
+  {"sock_accept", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_93sock_accept, METH_O, __pyx_doc_6uvloop_4loop_4Loop_92sock_accept},
+  {"sock_connect", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_96sock_connect, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_95sock_connect},
+  {"connect_accepted_socket", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_99connect_accepted_socket, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_98connect_accepted_socket},
+  {"run_in_executor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_102run_in_executor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_101run_in_executor},
+  {"set_default_executor", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_104set_default_executor, METH_O, __pyx_doc_6uvloop_4loop_4Loop_103set_default_executor},
+  {"__subprocess_run", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_106__subprocess_run, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_105__subprocess_run},
+  {"subprocess_shell", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_109subprocess_shell, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_108subprocess_shell},
+  {"subprocess_exec", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_112subprocess_exec, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_111subprocess_exec},
+  {"connect_read_pipe", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_115connect_read_pipe, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_114connect_read_pipe},
+  {"connect_write_pipe", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_118connect_write_pipe, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_117connect_write_pipe},
+  {"add_signal_handler", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_121add_signal_handler, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_120add_signal_handler},
+  {"remove_signal_handler", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_123remove_signal_handler, METH_O, __pyx_doc_6uvloop_4loop_4Loop_122remove_signal_handler},
+  {"create_datagram_endpoint", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_4Loop_125create_datagram_endpoint, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_4Loop_124create_datagram_endpoint},
+  {"_check_default_executor", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_128_check_default_executor, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_127_check_default_executor},
+  {"_asyncgen_finalizer_hook", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_130_asyncgen_finalizer_hook, METH_O, __pyx_doc_6uvloop_4loop_4Loop_129_asyncgen_finalizer_hook},
+  {"_asyncgen_firstiter_hook", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_132_asyncgen_firstiter_hook, METH_O, __pyx_doc_6uvloop_4loop_4Loop_131_asyncgen_firstiter_hook},
+  {"shutdown_asyncgens", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_134shutdown_asyncgens, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_133shutdown_asyncgens},
+  {"shutdown_default_executor", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_137shutdown_default_executor, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_136shutdown_default_executor},
+  {"_do_shutdown", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_140_do_shutdown, METH_O, __pyx_doc_6uvloop_4loop_4Loop_139_do_shutdown},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_142__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_4Loop_141__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_144__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_4Loop_143__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_6uvloop_4loop_Loop[] = {
+  {(char *)"print_debug_info", __pyx_getprop_6uvloop_4loop_4Loop_print_debug_info, 0, (char *)0, 0},
+  {(char *)"slow_callback_duration", __pyx_getprop_6uvloop_4loop_4Loop_slow_callback_duration, __pyx_setprop_6uvloop_4loop_4Loop_slow_callback_duration, (char *)"slow_callback_duration: object", 0},
+  {(char *)"_closed", __pyx_getprop_6uvloop_4loop_4Loop__closed, 0, (char *)0, 0},
+  {(char *)"_debug_cc", __pyx_getprop_6uvloop_4loop_4Loop__debug_cc, 0, (char *)0, 0},
+  {(char *)"_debug_handles_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_handles_total, 0, (char *)0, 0},
+  {(char *)"_debug_handles_closed", __pyx_getprop_6uvloop_4loop_4Loop__debug_handles_closed, 0, (char *)0, 0},
+  {(char *)"_debug_handles_current", __pyx_getprop_6uvloop_4loop_4Loop__debug_handles_current, 0, (char *)0, 0},
+  {(char *)"_debug_uv_handles_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_uv_handles_total, 0, (char *)0, 0},
+  {(char *)"_debug_uv_handles_freed", __pyx_getprop_6uvloop_4loop_4Loop__debug_uv_handles_freed, 0, (char *)0, 0},
+  {(char *)"_debug_cb_handles_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_cb_handles_total, 0, (char *)0, 0},
+  {(char *)"_debug_cb_handles_count", __pyx_getprop_6uvloop_4loop_4Loop__debug_cb_handles_count, 0, (char *)0, 0},
+  {(char *)"_debug_cb_timer_handles_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_cb_timer_handles_total, 0, (char *)0, 0},
+  {(char *)"_debug_cb_timer_handles_count", __pyx_getprop_6uvloop_4loop_4Loop__debug_cb_timer_handles_count, 0, (char *)0, 0},
+  {(char *)"_debug_stream_shutdown_errors_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_shutdown_errors_total, 0, (char *)0, 0},
+  {(char *)"_debug_stream_listen_errors_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_listen_errors_total, 0, (char *)0, 0},
+  {(char *)"_debug_stream_read_cb_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_read_cb_total, 0, (char *)0, 0},
+  {(char *)"_debug_stream_read_cb_errors_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_read_cb_errors_total, 0, (char *)0, 0},
+  {(char *)"_debug_stream_read_eof_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_read_eof_total, 0, (char *)0, 0},
+  {(char *)"_debug_stream_read_eof_cb_errors_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_read_eof_cb_errors_total, 0, (char *)0, 0},
+  {(char *)"_debug_stream_read_errors_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_read_errors_total, 0, (char *)0, 0},
+  {(char *)"_debug_stream_write_tries", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_write_tries, 0, (char *)0, 0},
+  {(char *)"_debug_stream_write_errors_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_write_errors_total, 0, (char *)0, 0},
+  {(char *)"_debug_stream_write_ctx_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_write_ctx_total, 0, (char *)0, 0},
+  {(char *)"_debug_stream_write_ctx_cnt", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_write_ctx_cnt, 0, (char *)0, 0},
+  {(char *)"_debug_stream_write_cb_errors_total", __pyx_getprop_6uvloop_4loop_4Loop__debug_stream_write_cb_errors_total, 0, (char *)0, 0},
+  {(char *)"_poll_read_events_total", __pyx_getprop_6uvloop_4loop_4Loop__poll_read_events_total, 0, (char *)0, 0},
+  {(char *)"_poll_read_cb_errors_total", __pyx_getprop_6uvloop_4loop_4Loop__poll_read_cb_errors_total, 0, (char *)0, 0},
+  {(char *)"_poll_write_events_total", __pyx_getprop_6uvloop_4loop_4Loop__poll_write_events_total, 0, (char *)0, 0},
+  {(char *)"_poll_write_cb_errors_total", __pyx_getprop_6uvloop_4loop_4Loop__poll_write_cb_errors_total, 0, (char *)0, 0},
+  {(char *)"_sock_try_write_total", __pyx_getprop_6uvloop_4loop_4Loop__sock_try_write_total, 0, (char *)0, 0},
+  {(char *)"_debug_exception_handler_cnt", __pyx_getprop_6uvloop_4loop_4Loop__debug_exception_handler_cnt, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_Loop = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.Loop", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_Loop), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_Loop, /*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
+  __pyx_pw_6uvloop_4loop_4Loop_11__repr__, /*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*/
+  "Loop()", /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop_Loop, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_Loop, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_6uvloop_4loop_Loop, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  __pyx_pw_6uvloop_4loop_4Loop_3__init__, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_Loop, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_Handle __pyx_vtable_6uvloop_4loop_Handle;
+
+static struct __pyx_obj_6uvloop_4loop_Handle *__pyx_freelist_6uvloop_4loop_Handle[250];
+static int __pyx_freecount_6uvloop_4loop_Handle = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_Handle(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_Handle *p;
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop_Handle > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop_Handle)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop_Handle[--__pyx_freecount_6uvloop_4loop_Handle];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop_Handle));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    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_6uvloop_4loop_Handle *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop_Handle;
+  p->loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  p->context = Py_None; Py_INCREF(Py_None);
+  p->meth_name = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->arg1 = Py_None; Py_INCREF(Py_None);
+  p->arg2 = Py_None; Py_INCREF(Py_None);
+  p->arg3 = Py_None; Py_INCREF(Py_None);
+  p->arg4 = Py_None; Py_INCREF(Py_None);
+  p->_source_traceback = Py_None; Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_6Handle_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_Handle(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_Handle *p = (struct __pyx_obj_6uvloop_4loop_Handle *)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_6uvloop_4loop_6Handle_3__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  if (p->__weakref__) PyObject_ClearWeakRefs(o);
+  Py_CLEAR(p->loop);
+  Py_CLEAR(p->context);
+  Py_CLEAR(p->meth_name);
+  Py_CLEAR(p->arg1);
+  Py_CLEAR(p->arg2);
+  Py_CLEAR(p->arg3);
+  Py_CLEAR(p->arg4);
+  Py_CLEAR(p->_source_traceback);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop_Handle < 250) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop_Handle)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    __pyx_freelist_6uvloop_4loop_Handle[__pyx_freecount_6uvloop_4loop_Handle++] = ((struct __pyx_obj_6uvloop_4loop_Handle *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_Handle(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_Handle *p = (struct __pyx_obj_6uvloop_4loop_Handle *)o;
+  if (p->loop) {
+    e = (*v)(((PyObject *)p->loop), a); if (e) return e;
+  }
+  if (p->context) {
+    e = (*v)(p->context, a); if (e) return e;
+  }
+  if (p->arg1) {
+    e = (*v)(p->arg1, a); if (e) return e;
+  }
+  if (p->arg2) {
+    e = (*v)(p->arg2, a); if (e) return e;
+  }
+  if (p->arg3) {
+    e = (*v)(p->arg3, a); if (e) return e;
+  }
+  if (p->arg4) {
+    e = (*v)(p->arg4, a); if (e) return e;
+  }
+  if (p->_source_traceback) {
+    e = (*v)(p->_source_traceback, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_6Handle__source_traceback(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_6Handle_17_source_traceback_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_Handle[] = {
+  {"cancel", (PyCFunction)__pyx_pw_6uvloop_4loop_6Handle_9cancel, METH_NOARGS, __pyx_doc_6uvloop_4loop_6Handle_8cancel},
+  {"cancelled", (PyCFunction)__pyx_pw_6uvloop_4loop_6Handle_11cancelled, METH_NOARGS, __pyx_doc_6uvloop_4loop_6Handle_10cancelled},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_6Handle_13__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_6Handle_12__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_6Handle_15__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_6Handle_14__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_6uvloop_4loop_Handle[] = {
+  {(char *)"_source_traceback", __pyx_getprop_6uvloop_4loop_6Handle__source_traceback, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_Handle = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.Handle", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_Handle), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_Handle, /*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
+  __pyx_pw_6uvloop_4loop_6Handle_7__repr__, /*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*/
+  "Handle()", /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop_Handle, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_Handle, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_6uvloop_4loop_Handle, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  __pyx_pw_6uvloop_4loop_6Handle_5__init__, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_Handle, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_TimerHandle __pyx_vtable_6uvloop_4loop_TimerHandle;
+
+static struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_freelist_6uvloop_4loop_TimerHandle[250];
+static int __pyx_freecount_6uvloop_4loop_TimerHandle = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_TimerHandle(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_TimerHandle *p;
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop_TimerHandle > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop_TimerHandle)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop_TimerHandle[--__pyx_freecount_6uvloop_4loop_TimerHandle];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop_TimerHandle));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    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_6uvloop_4loop_TimerHandle *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop_TimerHandle;
+  p->callback = Py_None; Py_INCREF(Py_None);
+  p->args = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->timer = ((struct __pyx_obj_6uvloop_4loop_UVTimer *)Py_None); Py_INCREF(Py_None);
+  p->loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  p->context = Py_None; Py_INCREF(Py_None);
+  p->_debug_info = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_11TimerHandle_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_TimerHandle(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_TimerHandle *p = (struct __pyx_obj_6uvloop_4loop_TimerHandle *)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_6uvloop_4loop_11TimerHandle_3__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  if (p->__weakref__) PyObject_ClearWeakRefs(o);
+  Py_CLEAR(p->callback);
+  Py_CLEAR(p->args);
+  Py_CLEAR(p->timer);
+  Py_CLEAR(p->loop);
+  Py_CLEAR(p->context);
+  Py_CLEAR(p->_debug_info);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop_TimerHandle < 250) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop_TimerHandle)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    __pyx_freelist_6uvloop_4loop_TimerHandle[__pyx_freecount_6uvloop_4loop_TimerHandle++] = ((struct __pyx_obj_6uvloop_4loop_TimerHandle *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_TimerHandle(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_TimerHandle *p = (struct __pyx_obj_6uvloop_4loop_TimerHandle *)o;
+  if (p->callback) {
+    e = (*v)(p->callback, a); if (e) return e;
+  }
+  if (p->args) {
+    e = (*v)(p->args, a); if (e) return e;
+  }
+  if (p->timer) {
+    e = (*v)(((PyObject *)p->timer), a); if (e) return e;
+  }
+  if (p->loop) {
+    e = (*v)(((PyObject *)p->loop), a); if (e) return e;
+  }
+  if (p->context) {
+    e = (*v)(p->context, a); if (e) return e;
+  }
+  if (p->_debug_info) {
+    e = (*v)(p->_debug_info, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_11TimerHandle__source_traceback(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_11TimerHandle_17_source_traceback_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_TimerHandle[] = {
+  {"cancelled", (PyCFunction)__pyx_pw_6uvloop_4loop_11TimerHandle_7cancelled, METH_NOARGS, __pyx_doc_6uvloop_4loop_11TimerHandle_6cancelled},
+  {"cancel", (PyCFunction)__pyx_pw_6uvloop_4loop_11TimerHandle_9cancel, METH_NOARGS, __pyx_doc_6uvloop_4loop_11TimerHandle_8cancel},
+  {"when", (PyCFunction)__pyx_pw_6uvloop_4loop_11TimerHandle_11when, METH_NOARGS, __pyx_doc_6uvloop_4loop_11TimerHandle_10when},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_11TimerHandle_13__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_11TimerHandle_12__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_11TimerHandle_15__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_11TimerHandle_14__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_6uvloop_4loop_TimerHandle[] = {
+  {(char *)"_source_traceback", __pyx_getprop_6uvloop_4loop_11TimerHandle__source_traceback, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_TimerHandle = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.TimerHandle", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_TimerHandle), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_TimerHandle, /*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
+  __pyx_pw_6uvloop_4loop_11TimerHandle_5__repr__, /*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_6uvloop_4loop_TimerHandle, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_TimerHandle, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_6uvloop_4loop_TimerHandle, /*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_6uvloop_4loop_TimerHandle, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVCheck __pyx_vtable_6uvloop_4loop_UVCheck;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVCheck(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVCheck *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVHandle(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UVCheck *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UVCheck;
+  p->h = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None); Py_INCREF(Py_None);
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVCheck(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVCheck *p = (struct __pyx_obj_6uvloop_4loop_UVCheck *)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);
+  Py_CLEAR(p->h);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVHandle(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVCheck(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVCheck *p = (struct __pyx_obj_6uvloop_4loop_UVCheck *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVHandle(o, v, a); if (e) return e;
+  if (p->h) {
+    e = (*v)(((PyObject *)p->h), a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVCheck[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_7UVCheck_1__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_7UVCheck___reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_7UVCheck_3__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_7UVCheck_2__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVCheck = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVCheck", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVCheck), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVCheck, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVCheck, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVCheck, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVCheck, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVPoll __pyx_vtable_6uvloop_4loop_UVPoll;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVPoll(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVPoll *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVHandle(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UVPoll;
+  p->reading_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None); Py_INCREF(Py_None);
+  p->writing_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None); Py_INCREF(Py_None);
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVPoll(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVPoll *p = (struct __pyx_obj_6uvloop_4loop_UVPoll *)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);
+  Py_CLEAR(p->reading_handle);
+  Py_CLEAR(p->writing_handle);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVHandle(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVPoll(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVPoll *p = (struct __pyx_obj_6uvloop_4loop_UVPoll *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVHandle(o, v, a); if (e) return e;
+  if (p->reading_handle) {
+    e = (*v)(((PyObject *)p->reading_handle), a); if (e) return e;
+  }
+  if (p->writing_handle) {
+    e = (*v)(((PyObject *)p->writing_handle), a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVPoll[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_6UVPoll_1__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_6UVPoll___reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_6UVPoll_3__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_6UVPoll_2__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVPoll = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVPoll", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVPoll), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVPoll, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVPoll, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVPoll, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVPoll, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVStream __pyx_vtable_6uvloop_4loop_UVStream;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVStream(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVStream *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVBaseTransport(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UVStream *)o);
+  p->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UVStream;
+  p->_protocol_get_buffer = Py_None; Py_INCREF(Py_None);
+  p->_protocol_buffer_updated = Py_None; Py_INCREF(Py_None);
+  p->_buffer = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_read_pybuf.obj = NULL;
+  if (unlikely(__pyx_pw_6uvloop_4loop_8UVStream_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVStream(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVStream *p = (struct __pyx_obj_6uvloop_4loop_UVStream *)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);
+  Py_CLEAR(p->_protocol_get_buffer);
+  Py_CLEAR(p->_protocol_buffer_updated);
+  Py_CLEAR(p->_buffer);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVBaseTransport(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVStream(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVStream *p = (struct __pyx_obj_6uvloop_4loop_UVStream *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVBaseTransport(o, v, a); if (e) return e;
+  if (p->_protocol_get_buffer) {
+    e = (*v)(p->_protocol_get_buffer, a); if (e) return e;
+  }
+  if (p->_protocol_buffer_updated) {
+    e = (*v)(p->_protocol_buffer_updated, a); if (e) return e;
+  }
+  if (p->_buffer) {
+    e = (*v)(p->_buffer, a); if (e) return e;
+  }
+  if (p->_read_pybuf.obj) {
+    e = (*v)(p->_read_pybuf.obj, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVStream[] = {
+  {"write", (PyCFunction)__pyx_pw_6uvloop_4loop_8UVStream_5write, METH_O, __pyx_doc_6uvloop_4loop_8UVStream_4write},
+  {"writelines", (PyCFunction)__pyx_pw_6uvloop_4loop_8UVStream_7writelines, METH_O, __pyx_doc_6uvloop_4loop_8UVStream_6writelines},
+  {"write_eof", (PyCFunction)__pyx_pw_6uvloop_4loop_8UVStream_9write_eof, METH_NOARGS, __pyx_doc_6uvloop_4loop_8UVStream_8write_eof},
+  {"can_write_eof", (PyCFunction)__pyx_pw_6uvloop_4loop_8UVStream_11can_write_eof, METH_NOARGS, __pyx_doc_6uvloop_4loop_8UVStream_10can_write_eof},
+  {"is_reading", (PyCFunction)__pyx_pw_6uvloop_4loop_8UVStream_13is_reading, METH_NOARGS, __pyx_doc_6uvloop_4loop_8UVStream_12is_reading},
+  {"pause_reading", (PyCFunction)__pyx_pw_6uvloop_4loop_8UVStream_15pause_reading, METH_NOARGS, __pyx_doc_6uvloop_4loop_8UVStream_14pause_reading},
+  {"resume_reading", (PyCFunction)__pyx_pw_6uvloop_4loop_8UVStream_17resume_reading, METH_NOARGS, __pyx_doc_6uvloop_4loop_8UVStream_16resume_reading},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_8UVStream_19__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_8UVStream_18__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_8UVStream_21__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_8UVStream_20__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVStream = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVStream", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVStream), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVStream, /*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
+  __pyx_pw_6uvloop_4loop_8UVStream_3__repr__, /*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_6uvloop_4loop_UVStream, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVStream, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVStream, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer __pyx_vtable_6uvloop_4loop_UVStreamServer;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVStreamServer(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVStreamServer *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVSocketHandle(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)o);
+  p->__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UVStreamServer;
+  p->ssl = Py_None; Py_INCREF(Py_None);
+  p->ssl_handshake_timeout = Py_None; Py_INCREF(Py_None);
+  p->ssl_shutdown_timeout = Py_None; Py_INCREF(Py_None);
+  p->protocol_factory = Py_None; Py_INCREF(Py_None);
+  p->_server = ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None); Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_14UVStreamServer_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVStreamServer(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVStreamServer *p = (struct __pyx_obj_6uvloop_4loop_UVStreamServer *)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);
+  Py_CLEAR(p->ssl);
+  Py_CLEAR(p->ssl_handshake_timeout);
+  Py_CLEAR(p->ssl_shutdown_timeout);
+  Py_CLEAR(p->protocol_factory);
+  Py_CLEAR(p->_server);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVSocketHandle(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVStreamServer(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVStreamServer *p = (struct __pyx_obj_6uvloop_4loop_UVStreamServer *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVSocketHandle(o, v, a); if (e) return e;
+  if (p->ssl) {
+    e = (*v)(p->ssl, a); if (e) return e;
+  }
+  if (p->ssl_handshake_timeout) {
+    e = (*v)(p->ssl_handshake_timeout, a); if (e) return e;
+  }
+  if (p->ssl_shutdown_timeout) {
+    e = (*v)(p->ssl_shutdown_timeout, a); if (e) return e;
+  }
+  if (p->protocol_factory) {
+    e = (*v)(p->protocol_factory, a); if (e) return e;
+  }
+  if (p->_server) {
+    e = (*v)(((PyObject *)p->_server), a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVStreamServer[] = {
+  {"__on_ssl_connected", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_14UVStreamServer_3__on_ssl_connected, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_14UVStreamServer_2__on_ssl_connected},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_14UVStreamServer_5__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_14UVStreamServer_4__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_14UVStreamServer_7__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_14UVStreamServer_6__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVStreamServer = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVStreamServer", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVStreamServer), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVStreamServer, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVStreamServer, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVStreamServer, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVStreamServer, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_TCPServer __pyx_vtable_6uvloop_4loop_TCPServer;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_TCPServer(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_TCPServer *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVStreamServer(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_TCPServer *)o);
+  p->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_TCPServer;
+  return o;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_TCPServer[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_9TCPServer_1__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_9TCPServer___reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_9TCPServer_3__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_9TCPServer_2__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_TCPServer = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.TCPServer", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_TCPServer), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVStreamServer, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVStreamServer, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_TCPServer, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_TCPServer, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport __pyx_vtable_6uvloop_4loop_TCPTransport;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_TCPTransport(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_TCPTransport *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVStream(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)o);
+  p->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_TCPTransport;
+  return o;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_TCPTransport[] = {
+  {"get_extra_info", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12TCPTransport_1get_extra_info, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12TCPTransport_get_extra_info},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_12TCPTransport_3__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_12TCPTransport_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_12TCPTransport_5__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_12TCPTransport_4__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_TCPTransport = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.TCPTransport", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_TCPTransport), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVStream, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVStream_3__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVStream, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_TCPTransport, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_TCPTransport, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UnixServer __pyx_vtable_6uvloop_4loop_UnixServer;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UnixServer(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UnixServer *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVStreamServer(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UnixServer *)o);
+  p->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UnixServer;
+  return o;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UnixServer[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_10UnixServer_1__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_10UnixServer___reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_10UnixServer_3__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_10UnixServer_2__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UnixServer = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UnixServer", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UnixServer), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVStreamServer, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVStreamServer, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UnixServer, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UnixServer, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport __pyx_vtable_6uvloop_4loop_UnixTransport;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UnixTransport(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UnixTransport *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVStream(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UnixTransport *)o);
+  p->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UnixTransport;
+  return o;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UnixTransport[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_13UnixTransport_1__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_13UnixTransport___reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_13UnixTransport_3__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_13UnixTransport_2__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UnixTransport = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UnixTransport", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UnixTransport), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVStream, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVStream_3__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVStream, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UnixTransport, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UnixTransport, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport __pyx_vtable_6uvloop_4loop_ReadUnixTransport;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_ReadUnixTransport(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVStream(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)o);
+  p->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_ReadUnixTransport;
+  return o;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_ReadUnixTransport[] = {
+  {"get_write_buffer_limits", (PyCFunction)__pyx_pw_6uvloop_4loop_17ReadUnixTransport_1get_write_buffer_limits, METH_NOARGS, __pyx_doc_6uvloop_4loop_17ReadUnixTransport_get_write_buffer_limits},
+  {"set_write_buffer_limits", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_17ReadUnixTransport_3set_write_buffer_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_17ReadUnixTransport_2set_write_buffer_limits},
+  {"get_write_buffer_size", (PyCFunction)__pyx_pw_6uvloop_4loop_17ReadUnixTransport_5get_write_buffer_size, METH_NOARGS, __pyx_doc_6uvloop_4loop_17ReadUnixTransport_4get_write_buffer_size},
+  {"write", (PyCFunction)__pyx_pw_6uvloop_4loop_17ReadUnixTransport_7write, METH_O, __pyx_doc_6uvloop_4loop_17ReadUnixTransport_6write},
+  {"writelines", (PyCFunction)__pyx_pw_6uvloop_4loop_17ReadUnixTransport_9writelines, METH_O, __pyx_doc_6uvloop_4loop_17ReadUnixTransport_8writelines},
+  {"write_eof", (PyCFunction)__pyx_pw_6uvloop_4loop_17ReadUnixTransport_11write_eof, METH_NOARGS, __pyx_doc_6uvloop_4loop_17ReadUnixTransport_10write_eof},
+  {"can_write_eof", (PyCFunction)__pyx_pw_6uvloop_4loop_17ReadUnixTransport_13can_write_eof, METH_NOARGS, __pyx_doc_6uvloop_4loop_17ReadUnixTransport_12can_write_eof},
+  {"abort", (PyCFunction)__pyx_pw_6uvloop_4loop_17ReadUnixTransport_15abort, METH_NOARGS, __pyx_doc_6uvloop_4loop_17ReadUnixTransport_14abort},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_17ReadUnixTransport_17__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_17ReadUnixTransport_16__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_17ReadUnixTransport_19__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_17ReadUnixTransport_18__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_ReadUnixTransport = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.ReadUnixTransport", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_ReadUnixTransport), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVStream, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVStream_3__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVStream, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_ReadUnixTransport, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_ReadUnixTransport, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport __pyx_vtable_6uvloop_4loop_WriteUnixTransport;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_WriteUnixTransport(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVStream(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *)o);
+  p->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_WriteUnixTransport;
+  return o;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_WriteUnixTransport[] = {
+  {"pause_reading", (PyCFunction)__pyx_pw_6uvloop_4loop_18WriteUnixTransport_1pause_reading, METH_NOARGS, __pyx_doc_6uvloop_4loop_18WriteUnixTransport_pause_reading},
+  {"resume_reading", (PyCFunction)__pyx_pw_6uvloop_4loop_18WriteUnixTransport_3resume_reading, METH_NOARGS, __pyx_doc_6uvloop_4loop_18WriteUnixTransport_2resume_reading},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_18WriteUnixTransport_5__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_18WriteUnixTransport_4__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_18WriteUnixTransport_7__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_18WriteUnixTransport_6__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_WriteUnixTransport = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.WriteUnixTransport", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_WriteUnixTransport), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVStream, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVStream_3__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVStream, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_WriteUnixTransport, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_WriteUnixTransport, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVProcess __pyx_vtable_6uvloop_4loop_UVProcess;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVProcess(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVProcess *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVHandle(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UVProcess *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UVProcess;
+  p->_returncode = Py_None; Py_INCREF(Py_None);
+  p->_pid = Py_None; Py_INCREF(Py_None);
+  p->_errpipe_read = Py_None; Py_INCREF(Py_None);
+  p->_errpipe_write = Py_None; Py_INCREF(Py_None);
+  p->_preexec_fn = Py_None; Py_INCREF(Py_None);
+  p->_fds_to_close = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->__pyx___env = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->__pyx___args = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->__pyx___cwd = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_9UVProcess_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVProcess(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVProcess *p = (struct __pyx_obj_6uvloop_4loop_UVProcess *)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_6uvloop_4loop_9UVProcess_3__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->_returncode);
+  Py_CLEAR(p->_pid);
+  Py_CLEAR(p->_errpipe_read);
+  Py_CLEAR(p->_errpipe_write);
+  Py_CLEAR(p->_preexec_fn);
+  Py_CLEAR(p->_fds_to_close);
+  Py_CLEAR(p->__pyx___env);
+  Py_CLEAR(p->__pyx___args);
+  Py_CLEAR(p->__pyx___cwd);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVHandle(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVProcess(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVProcess *p = (struct __pyx_obj_6uvloop_4loop_UVProcess *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVHandle(o, v, a); if (e) return e;
+  if (p->_returncode) {
+    e = (*v)(p->_returncode, a); if (e) return e;
+  }
+  if (p->_pid) {
+    e = (*v)(p->_pid, a); if (e) return e;
+  }
+  if (p->_errpipe_read) {
+    e = (*v)(p->_errpipe_read, a); if (e) return e;
+  }
+  if (p->_errpipe_write) {
+    e = (*v)(p->_errpipe_write, a); if (e) return e;
+  }
+  if (p->_preexec_fn) {
+    e = (*v)(p->_preexec_fn, a); if (e) return e;
+  }
+  if (p->_fds_to_close) {
+    e = (*v)(p->_fds_to_close, a); if (e) return e;
+  }
+  if (p->__pyx___env) {
+    e = (*v)(p->__pyx___env, a); if (e) return e;
+  }
+  if (p->__pyx___args) {
+    e = (*v)(p->__pyx___args, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVProcess[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_9UVProcess_5__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_9UVProcess_4__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_9UVProcess_7__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_9UVProcess_6__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVProcess = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVProcess", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVProcess), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVProcess, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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*/
+  "Abstract class; wrapper over uv_process_t handle.", /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop_UVProcess, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVProcess, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVProcess, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport __pyx_vtable_6uvloop_4loop_UVProcessTransport;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVProcessTransport(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVProcessTransport *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVProcess(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)o);
+  p->__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UVProcessTransport;
+  p->_exit_waiters = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_init_futs = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_pending_calls = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_protocol = Py_None; Py_INCREF(Py_None);
+  p->_stdin = ((struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *)Py_None); Py_INCREF(Py_None);
+  p->_stdout = ((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)Py_None); Py_INCREF(Py_None);
+  p->_stderr = ((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)Py_None); Py_INCREF(Py_None);
+  p->stdin_proto = Py_None; Py_INCREF(Py_None);
+  p->stdout_proto = Py_None; Py_INCREF(Py_None);
+  p->stderr_proto = Py_None; Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_18UVProcessTransport_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVProcessTransport(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVProcessTransport *p = (struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)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);
+  Py_CLEAR(p->_exit_waiters);
+  Py_CLEAR(p->_init_futs);
+  Py_CLEAR(p->_pending_calls);
+  Py_CLEAR(p->_protocol);
+  Py_CLEAR(p->_stdin);
+  Py_CLEAR(p->_stdout);
+  Py_CLEAR(p->_stderr);
+  Py_CLEAR(p->stdin_proto);
+  Py_CLEAR(p->stdout_proto);
+  Py_CLEAR(p->stderr_proto);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVProcess(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVProcessTransport(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVProcessTransport *p = (struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVProcess(o, v, a); if (e) return e;
+  if (p->_exit_waiters) {
+    e = (*v)(p->_exit_waiters, a); if (e) return e;
+  }
+  if (p->_init_futs) {
+    e = (*v)(p->_init_futs, a); if (e) return e;
+  }
+  if (p->_pending_calls) {
+    e = (*v)(p->_pending_calls, a); if (e) return e;
+  }
+  if (p->_protocol) {
+    e = (*v)(p->_protocol, a); if (e) return e;
+  }
+  if (p->_stdin) {
+    e = (*v)(((PyObject *)p->_stdin), a); if (e) return e;
+  }
+  if (p->_stdout) {
+    e = (*v)(((PyObject *)p->_stdout), a); if (e) return e;
+  }
+  if (p->_stderr) {
+    e = (*v)(((PyObject *)p->_stderr), a); if (e) return e;
+  }
+  if (p->stdin_proto) {
+    e = (*v)(p->stdin_proto, a); if (e) return e;
+  }
+  if (p->stdout_proto) {
+    e = (*v)(p->stdout_proto, a); if (e) return e;
+  }
+  if (p->stderr_proto) {
+    e = (*v)(p->stderr_proto, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVProcessTransport[] = {
+  {"__stdio_inited", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_18UVProcessTransport_3__stdio_inited, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_18UVProcessTransport_2__stdio_inited},
+  {"get_protocol", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_5get_protocol, METH_NOARGS, __pyx_doc_6uvloop_4loop_18UVProcessTransport_4get_protocol},
+  {"set_protocol", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_7set_protocol, METH_O, __pyx_doc_6uvloop_4loop_18UVProcessTransport_6set_protocol},
+  {"get_pid", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_9get_pid, METH_NOARGS, __pyx_doc_6uvloop_4loop_18UVProcessTransport_8get_pid},
+  {"get_returncode", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_11get_returncode, METH_NOARGS, __pyx_doc_6uvloop_4loop_18UVProcessTransport_10get_returncode},
+  {"get_pipe_transport", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_13get_pipe_transport, METH_O, __pyx_doc_6uvloop_4loop_18UVProcessTransport_12get_pipe_transport},
+  {"terminate", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_15terminate, METH_NOARGS, __pyx_doc_6uvloop_4loop_18UVProcessTransport_14terminate},
+  {"kill", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_17kill, METH_NOARGS, __pyx_doc_6uvloop_4loop_18UVProcessTransport_16kill},
+  {"send_signal", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_19send_signal, METH_O, __pyx_doc_6uvloop_4loop_18UVProcessTransport_18send_signal},
+  {"is_closing", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_21is_closing, METH_NOARGS, __pyx_doc_6uvloop_4loop_18UVProcessTransport_20is_closing},
+  {"close", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_23close, METH_NOARGS, __pyx_doc_6uvloop_4loop_18UVProcessTransport_22close},
+  {"get_extra_info", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_18UVProcessTransport_25get_extra_info, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_18UVProcessTransport_24get_extra_info},
+  {"_wait", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_27_wait, METH_NOARGS, __pyx_doc_6uvloop_4loop_18UVProcessTransport_26_wait},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_29__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_18UVProcessTransport_28__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_18UVProcessTransport_31__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_18UVProcessTransport_30__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVProcessTransport = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVProcessTransport", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVProcessTransport), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVProcessTransport, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UVProcessTransport, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVProcessTransport, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UVProcessTransport, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UVRequest __pyx_vtable_6uvloop_4loop_UVRequest;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UVRequest(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UVRequest *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_6uvloop_4loop_UVRequest *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop_UVRequest;
+  p->loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_9UVRequest_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UVRequest(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UVRequest *p = (struct __pyx_obj_6uvloop_4loop_UVRequest *)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);
+  Py_CLEAR(p->loop);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UVRequest(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UVRequest *p = (struct __pyx_obj_6uvloop_4loop_UVRequest *)o;
+  if (p->loop) {
+    e = (*v)(((PyObject *)p->loop), a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop_UVRequest(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop_UVRequest *p = (struct __pyx_obj_6uvloop_4loop_UVRequest *)o;
+  tmp = ((PyObject*)p->loop);
+  p->loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UVRequest[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_9UVRequest_3__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_9UVRequest_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_9UVRequest_5__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_9UVRequest_4__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UVRequest = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UVRequest", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UVRequest), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UVRequest, /*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*/
+  "A base class for all libuv requests (uv_getaddrinfo_t, etc).\n\n    Important: it's a responsibility of the subclass to call the\n    \"on_done\" method in the request's callback.\n\n    If \"on_done\" isn't called, the request object will never die.\n    ", /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop_UVRequest, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop_UVRequest, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UVRequest, /*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_6uvloop_4loop_UVRequest, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_6uvloop_4loop__SSLProtocolTransport(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *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_6uvloop_4loop__SSLProtocolTransport *)o);
+  p->_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  p->_ssl_protocol = ((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)Py_None); Py_INCREF(Py_None);
+  p->context = Py_None; Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop__SSLProtocolTransport(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *p = (struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)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_6uvloop_4loop_21_SSLProtocolTransport_13__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->_loop);
+  Py_CLEAR(p->_ssl_protocol);
+  Py_CLEAR(p->context);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop__SSLProtocolTransport(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *p = (struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)o;
+  if (p->_loop) {
+    e = (*v)(((PyObject *)p->_loop), a); if (e) return e;
+  }
+  if (p->_ssl_protocol) {
+    e = (*v)(((PyObject *)p->_ssl_protocol), a); if (e) return e;
+  }
+  if (p->context) {
+    e = (*v)(p->context, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop__SSLProtocolTransport(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *p = (struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)o;
+  tmp = ((PyObject*)p->_loop);
+  p->_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_ssl_protocol);
+  p->_ssl_protocol = ((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->context);
+  p->context = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_21_SSLProtocolTransport__protocol_paused(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_16_protocol_paused_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop__SSLProtocolTransport[] = {
+  {"get_extra_info", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_3get_extra_info, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_2get_extra_info},
+  {"set_protocol", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_5set_protocol, METH_O, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_4set_protocol},
+  {"get_protocol", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_7get_protocol, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_6get_protocol},
+  {"is_closing", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_9is_closing, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_8is_closing},
+  {"close", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_11close, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_10close},
+  {"is_reading", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_15is_reading, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_14is_reading},
+  {"pause_reading", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_17pause_reading, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_16pause_reading},
+  {"resume_reading", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_19resume_reading, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_18resume_reading},
+  {"set_write_buffer_limits", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_21set_write_buffer_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_20set_write_buffer_limits},
+  {"get_write_buffer_limits", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_23get_write_buffer_limits, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_22get_write_buffer_limits},
+  {"get_write_buffer_size", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_25get_write_buffer_size, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_24get_write_buffer_size},
+  {"set_read_buffer_limits", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_27set_read_buffer_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_26set_read_buffer_limits},
+  {"get_read_buffer_limits", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_29get_read_buffer_limits, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_28get_read_buffer_limits},
+  {"get_read_buffer_size", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_31get_read_buffer_size, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_30get_read_buffer_size},
+  {"write", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_33write, METH_O, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_32write},
+  {"writelines", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_35writelines, METH_O, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_34writelines},
+  {"write_eof", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_37write_eof, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_36write_eof},
+  {"can_write_eof", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_39can_write_eof, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_38can_write_eof},
+  {"abort", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_41abort, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_40abort},
+  {"_force_close", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_43_force_close, METH_O, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_42_force_close},
+  {"_test__append_write_backlog", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_45_test__append_write_backlog, METH_O, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_44_test__append_write_backlog},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_47__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_46__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_21_SSLProtocolTransport_49__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_21_SSLProtocolTransport_48__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_6uvloop_4loop__SSLProtocolTransport[] = {
+  {(char *)"_protocol_paused", __pyx_getprop_6uvloop_4loop_21_SSLProtocolTransport__protocol_paused, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop__SSLProtocolTransport = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop._SSLProtocolTransport", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop__SSLProtocolTransport, /*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_6uvloop_4loop__SSLProtocolTransport, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop__SSLProtocolTransport, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop__SSLProtocolTransport, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_6uvloop_4loop__SSLProtocolTransport, /*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_6uvloop_4loop__SSLProtocolTransport, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_SSLProtocol __pyx_vtable_6uvloop_4loop_SSLProtocol;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_SSLProtocol(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_SSLProtocol *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_6uvloop_4loop_SSLProtocol *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop_SSLProtocol;
+  p->_server_hostname = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_sslcontext = Py_None; Py_INCREF(Py_None);
+  p->_extra = Py_None; Py_INCREF(Py_None);
+  p->_write_backlog = Py_None; Py_INCREF(Py_None);
+  p->_waiter = Py_None; Py_INCREF(Py_None);
+  p->_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  p->_app_transport = ((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)Py_None); Py_INCREF(Py_None);
+  p->_transport = Py_None; Py_INCREF(Py_None);
+  p->_ssl_handshake_timeout = Py_None; Py_INCREF(Py_None);
+  p->_ssl_shutdown_timeout = Py_None; Py_INCREF(Py_None);
+  p->_sslobj = Py_None; Py_INCREF(Py_None);
+  p->_sslobj_read = Py_None; Py_INCREF(Py_None);
+  p->_sslobj_write = Py_None; Py_INCREF(Py_None);
+  p->_incoming = Py_None; Py_INCREF(Py_None);
+  p->_incoming_write = Py_None; Py_INCREF(Py_None);
+  p->_outgoing = Py_None; Py_INCREF(Py_None);
+  p->_outgoing_read = Py_None; Py_INCREF(Py_None);
+  p->_ssl_buffer_view = Py_None; Py_INCREF(Py_None);
+  p->_app_protocol = Py_None; Py_INCREF(Py_None);
+  p->_app_protocol_get_buffer = Py_None; Py_INCREF(Py_None);
+  p->_app_protocol_buffer_updated = Py_None; Py_INCREF(Py_None);
+  p->_handshake_start_time = Py_None; Py_INCREF(Py_None);
+  p->_handshake_timeout_handle = Py_None; Py_INCREF(Py_None);
+  p->_shutdown_timeout_handle = Py_None; Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_11SSLProtocol_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_SSLProtocol(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_SSLProtocol *p = (struct __pyx_obj_6uvloop_4loop_SSLProtocol *)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_6uvloop_4loop_11SSLProtocol_3__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->_server_hostname);
+  Py_CLEAR(p->_sslcontext);
+  Py_CLEAR(p->_extra);
+  Py_CLEAR(p->_write_backlog);
+  Py_CLEAR(p->_waiter);
+  Py_CLEAR(p->_loop);
+  Py_CLEAR(p->_app_transport);
+  Py_CLEAR(p->_transport);
+  Py_CLEAR(p->_ssl_handshake_timeout);
+  Py_CLEAR(p->_ssl_shutdown_timeout);
+  Py_CLEAR(p->_sslobj);
+  Py_CLEAR(p->_sslobj_read);
+  Py_CLEAR(p->_sslobj_write);
+  Py_CLEAR(p->_incoming);
+  Py_CLEAR(p->_incoming_write);
+  Py_CLEAR(p->_outgoing);
+  Py_CLEAR(p->_outgoing_read);
+  Py_CLEAR(p->_ssl_buffer_view);
+  Py_CLEAR(p->_app_protocol);
+  Py_CLEAR(p->_app_protocol_get_buffer);
+  Py_CLEAR(p->_app_protocol_buffer_updated);
+  Py_CLEAR(p->_handshake_start_time);
+  Py_CLEAR(p->_handshake_timeout_handle);
+  Py_CLEAR(p->_shutdown_timeout_handle);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_SSLProtocol(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_SSLProtocol *p = (struct __pyx_obj_6uvloop_4loop_SSLProtocol *)o;
+  if (p->_sslcontext) {
+    e = (*v)(p->_sslcontext, a); if (e) return e;
+  }
+  if (p->_extra) {
+    e = (*v)(p->_extra, a); if (e) return e;
+  }
+  if (p->_write_backlog) {
+    e = (*v)(p->_write_backlog, a); if (e) return e;
+  }
+  if (p->_waiter) {
+    e = (*v)(p->_waiter, a); if (e) return e;
+  }
+  if (p->_loop) {
+    e = (*v)(((PyObject *)p->_loop), a); if (e) return e;
+  }
+  if (p->_app_transport) {
+    e = (*v)(((PyObject *)p->_app_transport), a); if (e) return e;
+  }
+  if (p->_transport) {
+    e = (*v)(p->_transport, a); if (e) return e;
+  }
+  if (p->_ssl_handshake_timeout) {
+    e = (*v)(p->_ssl_handshake_timeout, a); if (e) return e;
+  }
+  if (p->_ssl_shutdown_timeout) {
+    e = (*v)(p->_ssl_shutdown_timeout, a); if (e) return e;
+  }
+  if (p->_sslobj) {
+    e = (*v)(p->_sslobj, a); if (e) return e;
+  }
+  if (p->_sslobj_read) {
+    e = (*v)(p->_sslobj_read, a); if (e) return e;
+  }
+  if (p->_sslobj_write) {
+    e = (*v)(p->_sslobj_write, a); if (e) return e;
+  }
+  if (p->_incoming) {
+    e = (*v)(p->_incoming, a); if (e) return e;
+  }
+  if (p->_incoming_write) {
+    e = (*v)(p->_incoming_write, a); if (e) return e;
+  }
+  if (p->_outgoing) {
+    e = (*v)(p->_outgoing, a); if (e) return e;
+  }
+  if (p->_outgoing_read) {
+    e = (*v)(p->_outgoing_read, a); if (e) return e;
+  }
+  if (p->_ssl_buffer_view) {
+    e = (*v)(p->_ssl_buffer_view, a); if (e) return e;
+  }
+  if (p->_app_protocol) {
+    e = (*v)(p->_app_protocol, a); if (e) return e;
+  }
+  if (p->_app_protocol_get_buffer) {
+    e = (*v)(p->_app_protocol_get_buffer, a); if (e) return e;
+  }
+  if (p->_app_protocol_buffer_updated) {
+    e = (*v)(p->_app_protocol_buffer_updated, a); if (e) return e;
+  }
+  if (p->_handshake_start_time) {
+    e = (*v)(p->_handshake_start_time, a); if (e) return e;
+  }
+  if (p->_handshake_timeout_handle) {
+    e = (*v)(p->_handshake_timeout_handle, a); if (e) return e;
+  }
+  if (p->_shutdown_timeout_handle) {
+    e = (*v)(p->_shutdown_timeout_handle, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop_SSLProtocol(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop_SSLProtocol *p = (struct __pyx_obj_6uvloop_4loop_SSLProtocol *)o;
+  tmp = ((PyObject*)p->_sslcontext);
+  p->_sslcontext = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_extra);
+  p->_extra = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_write_backlog);
+  p->_write_backlog = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_waiter);
+  p->_waiter = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_loop);
+  p->_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_app_transport);
+  p->_app_transport = ((struct __pyx_obj_6uvloop_4loop__SSLProtocolTransport *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_transport);
+  p->_transport = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_ssl_handshake_timeout);
+  p->_ssl_handshake_timeout = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_ssl_shutdown_timeout);
+  p->_ssl_shutdown_timeout = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_sslobj);
+  p->_sslobj = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_sslobj_read);
+  p->_sslobj_read = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_sslobj_write);
+  p->_sslobj_write = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_incoming);
+  p->_incoming = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_incoming_write);
+  p->_incoming_write = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_outgoing);
+  p->_outgoing = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_outgoing_read);
+  p->_outgoing_read = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_ssl_buffer_view);
+  p->_ssl_buffer_view = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_app_protocol);
+  p->_app_protocol = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_app_protocol_get_buffer);
+  p->_app_protocol_get_buffer = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_app_protocol_buffer_updated);
+  p->_app_protocol_buffer_updated = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_handshake_start_time);
+  p->_handshake_start_time = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_handshake_timeout_handle);
+  p->_handshake_timeout_handle = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_shutdown_timeout_handle);
+  p->_shutdown_timeout_handle = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_SSLProtocol[] = {
+  {"_get_app_transport", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_11SSLProtocol_7_get_app_transport, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_11SSLProtocol_6_get_app_transport},
+  {"connection_made", (PyCFunction)__pyx_pw_6uvloop_4loop_11SSLProtocol_9connection_made, METH_O, __pyx_doc_6uvloop_4loop_11SSLProtocol_8connection_made},
+  {"connection_lost", (PyCFunction)__pyx_pw_6uvloop_4loop_11SSLProtocol_11connection_lost, METH_O, __pyx_doc_6uvloop_4loop_11SSLProtocol_10connection_lost},
+  {"get_buffer", (PyCFunction)__pyx_pw_6uvloop_4loop_11SSLProtocol_13get_buffer, METH_O, __pyx_doc_6uvloop_4loop_11SSLProtocol_12get_buffer},
+  {"buffer_updated", (PyCFunction)__pyx_pw_6uvloop_4loop_11SSLProtocol_15buffer_updated, METH_O, __pyx_doc_6uvloop_4loop_11SSLProtocol_14buffer_updated},
+  {"eof_received", (PyCFunction)__pyx_pw_6uvloop_4loop_11SSLProtocol_17eof_received, METH_NOARGS, __pyx_doc_6uvloop_4loop_11SSLProtocol_16eof_received},
+  {"pause_writing", (PyCFunction)__pyx_pw_6uvloop_4loop_11SSLProtocol_19pause_writing, METH_NOARGS, __pyx_doc_6uvloop_4loop_11SSLProtocol_18pause_writing},
+  {"resume_writing", (PyCFunction)__pyx_pw_6uvloop_4loop_11SSLProtocol_21resume_writing, METH_NOARGS, __pyx_doc_6uvloop_4loop_11SSLProtocol_20resume_writing},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_11SSLProtocol_23__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_11SSLProtocol_22__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_11SSLProtocol_25__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_11SSLProtocol_24__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_SSLProtocol = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.SSLProtocol", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_SSLProtocol), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_SSLProtocol, /*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*/
+  "SSLProtocol(loop, app_protocol, sslcontext, waiter, server_side=False, server_hostname=None, call_connection_made=True, ssl_handshake_timeout=None, ssl_shutdown_timeout=None)\nSSL protocol.\n\n    Implementation of SSL on top of a socket using incoming and outgoing\n    buffers which are ssl.MemoryBIO objects.\n    ", /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop_SSLProtocol, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop_SSLProtocol, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_SSLProtocol, /*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*/
+  __pyx_pw_6uvloop_4loop_11SSLProtocol_5__init__, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_SSLProtocol, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport __pyx_vtable_6uvloop_4loop_UDPTransport;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_UDPTransport(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_UDPTransport *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVBaseTransport(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)o);
+  p->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVHandle*)__pyx_vtabptr_6uvloop_4loop_UDPTransport;
+  p->_address = Py_None; Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_12UDPTransport_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_UDPTransport(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_UDPTransport *p = (struct __pyx_obj_6uvloop_4loop_UDPTransport *)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);
+  Py_CLEAR(p->_address);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVBaseTransport(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_UDPTransport(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_UDPTransport *p = (struct __pyx_obj_6uvloop_4loop_UDPTransport *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVBaseTransport(o, v, a); if (e) return e;
+  if (p->_address) {
+    e = (*v)(p->_address, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_UDPTransport[] = {
+  {"sendto", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12UDPTransport_3sendto, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12UDPTransport_2sendto},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_12UDPTransport_5__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_12UDPTransport_4__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_12UDPTransport_7__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_12UDPTransport_6__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_UDPTransport = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.UDPTransport", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_UDPTransport), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_UDPTransport, /*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
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_7__repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  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_6uvloop_4loop_UDPTransport, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_UDPTransport, /*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*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_pw_6uvloop_4loop_8UVHandle_3__init__, /*tp_init*/
+  #else
+  0, /*tp_init*/
+  #endif
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_UDPTransport, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_Server __pyx_vtable_6uvloop_4loop_Server;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_Server(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_Server *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_6uvloop_4loop_Server *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop_Server;
+  p->_servers = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_waiters = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  p->_serving_forever_fut = Py_None; Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_6Server_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_Server(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_Server *p = (struct __pyx_obj_6uvloop_4loop_Server *)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);
+  if (p->__weakref__) PyObject_ClearWeakRefs(o);
+  Py_CLEAR(p->_servers);
+  Py_CLEAR(p->_waiters);
+  Py_CLEAR(p->_loop);
+  Py_CLEAR(p->_serving_forever_fut);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_Server(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_Server *p = (struct __pyx_obj_6uvloop_4loop_Server *)o;
+  if (p->_servers) {
+    e = (*v)(p->_servers, a); if (e) return e;
+  }
+  if (p->_waiters) {
+    e = (*v)(p->_waiters, a); if (e) return e;
+  }
+  if (p->_loop) {
+    e = (*v)(((PyObject *)p->_loop), a); if (e) return e;
+  }
+  if (p->_serving_forever_fut) {
+    e = (*v)(p->_serving_forever_fut, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop_Server(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop_Server *p = (struct __pyx_obj_6uvloop_4loop_Server *)o;
+  tmp = ((PyObject*)p->_servers);
+  p->_servers = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_waiters);
+  p->_waiters = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_loop);
+  p->_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_serving_forever_fut);
+  p->_serving_forever_fut = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_6Server_sockets(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_6Server_7sockets_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_Server[] = {
+  {"__aenter__", (PyCFunction)__pyx_pw_6uvloop_4loop_6Server_3__aenter__, METH_NOARGS, __pyx_doc_6uvloop_4loop_6Server_2__aenter__},
+  {"__aexit__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_6Server_6__aexit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_6Server_5__aexit__},
+  {"get_loop", (PyCFunction)__pyx_pw_6uvloop_4loop_6Server_11get_loop, METH_NOARGS, __pyx_doc_6uvloop_4loop_6Server_10get_loop},
+  {"wait_closed", (PyCFunction)__pyx_pw_6uvloop_4loop_6Server_13wait_closed, METH_NOARGS, __pyx_doc_6uvloop_4loop_6Server_12wait_closed},
+  {"close", (PyCFunction)__pyx_pw_6uvloop_4loop_6Server_16close, METH_NOARGS, __pyx_doc_6uvloop_4loop_6Server_15close},
+  {"is_serving", (PyCFunction)__pyx_pw_6uvloop_4loop_6Server_18is_serving, METH_NOARGS, __pyx_doc_6uvloop_4loop_6Server_17is_serving},
+  {"start_serving", (PyCFunction)__pyx_pw_6uvloop_4loop_6Server_20start_serving, METH_NOARGS, __pyx_doc_6uvloop_4loop_6Server_19start_serving},
+  {"serve_forever", (PyCFunction)__pyx_pw_6uvloop_4loop_6Server_23serve_forever, METH_NOARGS, __pyx_doc_6uvloop_4loop_6Server_22serve_forever},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_6Server_26__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_6Server_25__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_6Server_28__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_6Server_27__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_6uvloop_4loop_Server[] = {
+  {(char *)"sockets", __pyx_getprop_6uvloop_4loop_6Server_sockets, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_Server = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.Server", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_Server), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_Server, /*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
+  __pyx_pw_6uvloop_4loop_6Server_9__repr__, /*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_6uvloop_4loop_Server, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop_Server, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_Server, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_6uvloop_4loop_Server, /*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_6uvloop_4loop_Server, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_PseudoSocket __pyx_vtable_6uvloop_4loop_PseudoSocket;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_PseudoSocket(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_PseudoSocket *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_6uvloop_4loop_PseudoSocket *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop_PseudoSocket;
+  p->_peername = Py_None; Py_INCREF(Py_None);
+  p->_sockname = Py_None; Py_INCREF(Py_None);
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_PseudoSocket(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_PseudoSocket *p = (struct __pyx_obj_6uvloop_4loop_PseudoSocket *)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);
+  Py_CLEAR(p->_peername);
+  Py_CLEAR(p->_sockname);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_PseudoSocket(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_PseudoSocket *p = (struct __pyx_obj_6uvloop_4loop_PseudoSocket *)o;
+  if (p->_peername) {
+    e = (*v)(p->_peername, a); if (e) return e;
+  }
+  if (p->_sockname) {
+    e = (*v)(p->_sockname, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop_PseudoSocket(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop_PseudoSocket *p = (struct __pyx_obj_6uvloop_4loop_PseudoSocket *)o;
+  tmp = ((PyObject*)p->_peername);
+  p->_peername = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_sockname);
+  p->_sockname = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_12PseudoSocket_family(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_12PseudoSocket_6family_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_12PseudoSocket_type(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_12PseudoSocket_4type_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_6uvloop_4loop_12PseudoSocket_proto(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_6uvloop_4loop_12PseudoSocket_5proto_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_PseudoSocket[] = {
+  {"__getstate__", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_5__getstate__, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_4__getstate__},
+  {"fileno", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_7fileno, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_6fileno},
+  {"dup", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_9dup, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_8dup},
+  {"get_inheritable", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_11get_inheritable, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_10get_inheritable},
+  {"set_inheritable", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_13set_inheritable, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_12set_inheritable},
+  {"ioctl", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_15ioctl, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_14ioctl},
+  {"getsockopt", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_17getsockopt, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_16getsockopt},
+  {"setsockopt", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_19setsockopt, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_18setsockopt},
+  {"getpeername", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_21getpeername, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_20getpeername},
+  {"getsockname", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_23getsockname, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_22getsockname},
+  {"share", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_25share, METH_O, __pyx_doc_6uvloop_4loop_12PseudoSocket_24share},
+  {"accept", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_27accept, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_26accept},
+  {"connect", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_29connect, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_28connect},
+  {"connect_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_31connect_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_30connect_ex},
+  {"bind", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_33bind, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_32bind},
+  {"listen", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_35listen, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_34listen},
+  {"makefile", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_37makefile, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_36makefile},
+  {"sendfile", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_39sendfile, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_38sendfile},
+  {"close", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_41close, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_40close},
+  {"detach", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_43detach, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_42detach},
+  {"shutdown", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_45shutdown, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_44shutdown},
+  {"sendmsg_afalg", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_47sendmsg_afalg, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_46sendmsg_afalg},
+  {"sendmsg", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_49sendmsg, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_48sendmsg},
+  {"sendto", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_51sendto, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_50sendto},
+  {"send", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_53send, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_52send},
+  {"sendall", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_55sendall, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_54sendall},
+  {"recv_into", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_57recv_into, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_56recv_into},
+  {"recvfrom_into", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_59recvfrom_into, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_58recvfrom_into},
+  {"recvmsg_into", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_61recvmsg_into, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_60recvmsg_into},
+  {"recvmsg", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_63recvmsg, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_62recvmsg},
+  {"recvfrom", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_65recvfrom, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_64recvfrom},
+  {"recv", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_67recv, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_66recv},
+  {"settimeout", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_69settimeout, METH_O, __pyx_doc_6uvloop_4loop_12PseudoSocket_68settimeout},
+  {"gettimeout", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_71gettimeout, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_70gettimeout},
+  {"setblocking", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_73setblocking, METH_O, __pyx_doc_6uvloop_4loop_12PseudoSocket_72setblocking},
+  {"__enter__", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_75__enter__, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_74__enter__},
+  {"__exit__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6uvloop_4loop_12PseudoSocket_77__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6uvloop_4loop_12PseudoSocket_76__exit__},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_79__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_12PseudoSocket_78__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_12PseudoSocket_81__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_12PseudoSocket_80__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_6uvloop_4loop_PseudoSocket[] = {
+  {(char *)"family", __pyx_getprop_6uvloop_4loop_12PseudoSocket_family, 0, (char *)0, 0},
+  {(char *)"type", __pyx_getprop_6uvloop_4loop_12PseudoSocket_type, 0, (char *)0, 0},
+  {(char *)"proto", __pyx_getprop_6uvloop_4loop_12PseudoSocket_proto, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_PseudoSocket = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.PseudoSocket", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_PseudoSocket), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_PseudoSocket, /*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
+  __pyx_pw_6uvloop_4loop_12PseudoSocket_3__repr__, /*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*/
+  "PseudoSocket(int family, int type, int proto, int fd)", /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop_PseudoSocket, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop_PseudoSocket, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_PseudoSocket, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_6uvloop_4loop_PseudoSocket, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  __pyx_pw_6uvloop_4loop_12PseudoSocket_1__init__, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_PseudoSocket, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_LruCache __pyx_vtable_6uvloop_4loop_LruCache;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_LruCache(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_LruCache *p;
+  PyObject *o;
+  o = (*t->tp_alloc)(t, 0);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_LruCache *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop_LruCache;
+  p->_dict = Py_None; Py_INCREF(Py_None);
+  p->_dict_move_to_end = Py_None; Py_INCREF(Py_None);
+  p->_dict_get = Py_None; Py_INCREF(Py_None);
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_LruCache(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_LruCache *p = (struct __pyx_obj_6uvloop_4loop_LruCache *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->_dict);
+  Py_CLEAR(p->_dict_move_to_end);
+  Py_CLEAR(p->_dict_get);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_LruCache(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_LruCache *p = (struct __pyx_obj_6uvloop_4loop_LruCache *)o;
+  if (p->_dict) {
+    e = (*v)(p->_dict, a); if (e) return e;
+  }
+  if (p->_dict_move_to_end) {
+    e = (*v)(p->_dict_move_to_end, a); if (e) return e;
+  }
+  if (p->_dict_get) {
+    e = (*v)(p->_dict_get, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop_LruCache(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop_LruCache *p = (struct __pyx_obj_6uvloop_4loop_LruCache *)o;
+  tmp = ((PyObject*)p->_dict);
+  p->_dict = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_dict_move_to_end);
+  p->_dict_move_to_end = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_dict_get);
+  p->_dict_get = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+static PyObject *__pyx_sq_item_6uvloop_4loop_LruCache(PyObject *o, Py_ssize_t i) {
+  PyObject *r;
+  PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
+  r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
+  Py_DECREF(x);
+  return r;
+}
+
+static int __pyx_mp_ass_subscript_6uvloop_4loop_LruCache(PyObject *o, PyObject *i, PyObject *v) {
+  if (v) {
+    return __pyx_pw_6uvloop_4loop_8LruCache_5__setitem__(o, i, v);
+  }
+  else {
+    return __pyx_pw_6uvloop_4loop_8LruCache_7__delitem__(o, i);
+  }
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_LruCache[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_8LruCache_15__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_8LruCache_14__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_8LruCache_17__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_8LruCache_16__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PySequenceMethods __pyx_tp_as_sequence_LruCache = {
+  __pyx_pw_6uvloop_4loop_8LruCache_11__len__, /*sq_length*/
+  0, /*sq_concat*/
+  0, /*sq_repeat*/
+  __pyx_sq_item_6uvloop_4loop_LruCache, /*sq_item*/
+  0, /*sq_slice*/
+  0, /*sq_ass_item*/
+  0, /*sq_ass_slice*/
+  __pyx_pw_6uvloop_4loop_8LruCache_9__contains__, /*sq_contains*/
+  0, /*sq_inplace_concat*/
+  0, /*sq_inplace_repeat*/
+};
+
+static PyMappingMethods __pyx_tp_as_mapping_LruCache = {
+  __pyx_pw_6uvloop_4loop_8LruCache_11__len__, /*mp_length*/
+  __pyx_pw_6uvloop_4loop_8LruCache_3__getitem__, /*mp_subscript*/
+  __pyx_mp_ass_subscript_6uvloop_4loop_LruCache, /*mp_ass_subscript*/
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_LruCache = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.LruCache", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_LruCache), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_LruCache, /*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*/
+  &__pyx_tp_as_sequence_LruCache, /*tp_as_sequence*/
+  &__pyx_tp_as_mapping_LruCache, /*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_HAVE_GC, /*tp_flags*/
+  "LruCache(maxsize, *)", /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop_LruCache, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop_LruCache, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  __pyx_pw_6uvloop_4loop_8LruCache_13__iter__, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_LruCache, /*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*/
+  __pyx_pw_6uvloop_4loop_8LruCache_1__init__, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_6uvloop_4loop_LruCache, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext __pyx_vtable_6uvloop_4loop__StreamWriteContext;
+
+static struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_freelist_6uvloop_4loop__StreamWriteContext[250];
+static int __pyx_freecount_6uvloop_4loop__StreamWriteContext = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop__StreamWriteContext(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop__StreamWriteContext *p;
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop__StreamWriteContext > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop__StreamWriteContext)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop__StreamWriteContext[--__pyx_freecount_6uvloop_4loop__StreamWriteContext];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop__StreamWriteContext));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    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_6uvloop_4loop__StreamWriteContext *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop__StreamWriteContext;
+  p->buffers = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->stream = ((struct __pyx_obj_6uvloop_4loop_UVStream *)Py_None); Py_INCREF(Py_None);
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop__StreamWriteContext(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop__StreamWriteContext *p = (struct __pyx_obj_6uvloop_4loop__StreamWriteContext *)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_6uvloop_4loop_19_StreamWriteContext_1__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->buffers);
+  Py_CLEAR(p->stream);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop__StreamWriteContext < 250) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop__StreamWriteContext)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    __pyx_freelist_6uvloop_4loop__StreamWriteContext[__pyx_freecount_6uvloop_4loop__StreamWriteContext++] = ((struct __pyx_obj_6uvloop_4loop__StreamWriteContext *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop__StreamWriteContext(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop__StreamWriteContext *p = (struct __pyx_obj_6uvloop_4loop__StreamWriteContext *)o;
+  if (p->buffers) {
+    e = (*v)(p->buffers, a); if (e) return e;
+  }
+  if (p->stream) {
+    e = (*v)(((PyObject *)p->stream), a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop__StreamWriteContext[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_19_StreamWriteContext_3__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_19_StreamWriteContext_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_19_StreamWriteContext_5__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_19_StreamWriteContext_4__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop__StreamWriteContext = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop._StreamWriteContext", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop__StreamWriteContext), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop__StreamWriteContext, /*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_6uvloop_4loop__StreamWriteContext, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop__StreamWriteContext, /*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_6uvloop_4loop__StreamWriteContext, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop__TCPConnectRequest __pyx_vtable_6uvloop_4loop__TCPConnectRequest;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop__TCPConnectRequest(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVRequest(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVRequest*)__pyx_vtabptr_6uvloop_4loop__TCPConnectRequest;
+  p->transport = ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)Py_None); Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_18_TCPConnectRequest_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop__TCPConnectRequest(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *p = (struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *)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);
+  Py_CLEAR(p->transport);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVRequest(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop__TCPConnectRequest(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *p = (struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVRequest(o, v, a); if (e) return e;
+  if (p->transport) {
+    e = (*v)(((PyObject *)p->transport), a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop__TCPConnectRequest(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *p = (struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *)o;
+  __pyx_tp_clear_6uvloop_4loop_UVRequest(o);
+  tmp = ((PyObject*)p->transport);
+  p->transport = ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop__TCPConnectRequest[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_18_TCPConnectRequest_3__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_18_TCPConnectRequest_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_18_TCPConnectRequest_5__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_18_TCPConnectRequest_4__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop__TCPConnectRequest = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop._TCPConnectRequest", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop__TCPConnectRequest), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop__TCPConnectRequest, /*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_6uvloop_4loop__TCPConnectRequest, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop__TCPConnectRequest, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop__TCPConnectRequest, /*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_6uvloop_4loop__TCPConnectRequest, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop__PipeConnectRequest __pyx_vtable_6uvloop_4loop__PipeConnectRequest;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop__PipeConnectRequest(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVRequest(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVRequest*)__pyx_vtabptr_6uvloop_4loop__PipeConnectRequest;
+  p->transport = ((struct __pyx_obj_6uvloop_4loop_UnixTransport *)Py_None); Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_19_PipeConnectRequest_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop__PipeConnectRequest(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *p = (struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *)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);
+  Py_CLEAR(p->transport);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVRequest(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop__PipeConnectRequest(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *p = (struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVRequest(o, v, a); if (e) return e;
+  if (p->transport) {
+    e = (*v)(((PyObject *)p->transport), a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop__PipeConnectRequest(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *p = (struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *)o;
+  __pyx_tp_clear_6uvloop_4loop_UVRequest(o);
+  tmp = ((PyObject*)p->transport);
+  p->transport = ((struct __pyx_obj_6uvloop_4loop_UnixTransport *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop__PipeConnectRequest[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_19_PipeConnectRequest_3__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_19_PipeConnectRequest_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_19_PipeConnectRequest_5__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_19_PipeConnectRequest_4__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop__PipeConnectRequest = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop._PipeConnectRequest", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop__PipeConnectRequest), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop__PipeConnectRequest, /*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_6uvloop_4loop__PipeConnectRequest, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop__PipeConnectRequest, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop__PipeConnectRequest, /*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_6uvloop_4loop__PipeConnectRequest, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop_SockAddrHolder *__pyx_freelist_6uvloop_4loop_SockAddrHolder[250];
+static int __pyx_freecount_6uvloop_4loop_SockAddrHolder = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_SockAddrHolder(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop_SockAddrHolder > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop_SockAddrHolder)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop_SockAddrHolder[--__pyx_freecount_6uvloop_4loop_SockAddrHolder];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop_SockAddrHolder));
+    (void) PyObject_INIT(o, t);
+  } else {
+    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;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_SockAddrHolder(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
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop_SockAddrHolder < 250) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop_SockAddrHolder)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    __pyx_freelist_6uvloop_4loop_SockAddrHolder[__pyx_freecount_6uvloop_4loop_SockAddrHolder++] = ((struct __pyx_obj_6uvloop_4loop_SockAddrHolder *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_SockAddrHolder[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_14SockAddrHolder_1__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_14SockAddrHolder___reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_14SockAddrHolder_3__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_14SockAddrHolder_2__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_SockAddrHolder = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.SockAddrHolder", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_SockAddrHolder), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_SockAddrHolder, /*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*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_SockAddrHolder, /*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_6uvloop_4loop_SockAddrHolder, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_AddrInfo __pyx_vtable_6uvloop_4loop_AddrInfo;
+
+static struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_freelist_6uvloop_4loop_AddrInfo[250];
+static int __pyx_freecount_6uvloop_4loop_AddrInfo = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_AddrInfo(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_AddrInfo *p;
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop_AddrInfo > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop_AddrInfo)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop_AddrInfo[--__pyx_freecount_6uvloop_4loop_AddrInfo];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop_AddrInfo));
+    (void) PyObject_INIT(o, t);
+  } else {
+    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_6uvloop_4loop_AddrInfo *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop_AddrInfo;
+  if (unlikely(__pyx_pw_6uvloop_4loop_8AddrInfo_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_AddrInfo(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
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
+    __pyx_pw_6uvloop_4loop_8AddrInfo_3__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop_AddrInfo < 250) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop_AddrInfo)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    __pyx_freelist_6uvloop_4loop_AddrInfo[__pyx_freecount_6uvloop_4loop_AddrInfo++] = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_AddrInfo[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_8AddrInfo_5__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_8AddrInfo_4__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_8AddrInfo_7__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_8AddrInfo_6__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_AddrInfo = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.AddrInfo", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_AddrInfo), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_AddrInfo, /*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*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_AddrInfo, /*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_6uvloop_4loop_AddrInfo, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_AddrInfoRequest __pyx_vtable_6uvloop_4loop_AddrInfoRequest;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_AddrInfoRequest(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVRequest(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVRequest*)__pyx_vtabptr_6uvloop_4loop_AddrInfoRequest;
+  p->callback = Py_None; Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_15AddrInfoRequest_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_AddrInfoRequest(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *p = (struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *)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);
+  Py_CLEAR(p->callback);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVRequest(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_AddrInfoRequest(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *p = (struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVRequest(o, v, a); if (e) return e;
+  if (p->callback) {
+    e = (*v)(p->callback, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop_AddrInfoRequest(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *p = (struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *)o;
+  __pyx_tp_clear_6uvloop_4loop_UVRequest(o);
+  tmp = ((PyObject*)p->callback);
+  p->callback = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_AddrInfoRequest[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_15AddrInfoRequest_3__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_15AddrInfoRequest_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_15AddrInfoRequest_5__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_15AddrInfoRequest_4__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_AddrInfoRequest = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.AddrInfoRequest", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_AddrInfoRequest), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_AddrInfoRequest, /*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_6uvloop_4loop_AddrInfoRequest, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop_AddrInfoRequest, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_AddrInfoRequest, /*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_6uvloop_4loop_AddrInfoRequest, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop_NameInfoRequest __pyx_vtable_6uvloop_4loop_NameInfoRequest;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop_NameInfoRequest(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop_NameInfoRequest *p;
+  PyObject *o = __pyx_tp_new_6uvloop_4loop_UVRequest(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_6uvloop_4loop_NameInfoRequest *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6uvloop_4loop_UVRequest*)__pyx_vtabptr_6uvloop_4loop_NameInfoRequest;
+  p->callback = Py_None; Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_6uvloop_4loop_15NameInfoRequest_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop_NameInfoRequest(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop_NameInfoRequest *p = (struct __pyx_obj_6uvloop_4loop_NameInfoRequest *)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);
+  Py_CLEAR(p->callback);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_6uvloop_4loop_UVRequest(o);
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop_NameInfoRequest(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop_NameInfoRequest *p = (struct __pyx_obj_6uvloop_4loop_NameInfoRequest *)o;
+  e = __pyx_tp_traverse_6uvloop_4loop_UVRequest(o, v, a); if (e) return e;
+  if (p->callback) {
+    e = (*v)(p->callback, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop_NameInfoRequest(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop_NameInfoRequest *p = (struct __pyx_obj_6uvloop_4loop_NameInfoRequest *)o;
+  __pyx_tp_clear_6uvloop_4loop_UVRequest(o);
+  tmp = ((PyObject*)p->callback);
+  p->callback = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop_NameInfoRequest[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_15NameInfoRequest_3__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_15NameInfoRequest_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_15NameInfoRequest_5__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_15NameInfoRequest_4__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop_NameInfoRequest = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.NameInfoRequest", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop_NameInfoRequest), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop_NameInfoRequest, /*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_6uvloop_4loop_NameInfoRequest, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop_NameInfoRequest, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop_NameInfoRequest, /*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_6uvloop_4loop_NameInfoRequest, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_6uvloop_4loop__UDPSendContext __pyx_vtable_6uvloop_4loop__UDPSendContext;
+
+static struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_freelist_6uvloop_4loop__UDPSendContext[250];
+static int __pyx_freecount_6uvloop_4loop__UDPSendContext = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop__UDPSendContext(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_6uvloop_4loop__UDPSendContext *p;
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop__UDPSendContext > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop__UDPSendContext)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop__UDPSendContext[--__pyx_freecount_6uvloop_4loop__UDPSendContext];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop__UDPSendContext));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    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_6uvloop_4loop__UDPSendContext *)o);
+  p->__pyx_vtab = __pyx_vtabptr_6uvloop_4loop__UDPSendContext;
+  p->udp = ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)Py_None); Py_INCREF(Py_None);
+  p->py_buf.obj = NULL;
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop__UDPSendContext(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop__UDPSendContext *p = (struct __pyx_obj_6uvloop_4loop__UDPSendContext *)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_6uvloop_4loop_15_UDPSendContext_1__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->udp);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop__UDPSendContext < 250) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop__UDPSendContext)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) {
+    __pyx_freelist_6uvloop_4loop__UDPSendContext[__pyx_freecount_6uvloop_4loop__UDPSendContext++] = ((struct __pyx_obj_6uvloop_4loop__UDPSendContext *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop__UDPSendContext(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop__UDPSendContext *p = (struct __pyx_obj_6uvloop_4loop__UDPSendContext *)o;
+  if (p->udp) {
+    e = (*v)(((PyObject *)p->udp), a); if (e) return e;
+  }
+  if (p->py_buf.obj) {
+    e = (*v)(p->py_buf.obj, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_6uvloop_4loop__UDPSendContext[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_15_UDPSendContext_3__reduce_cython__, METH_NOARGS, __pyx_doc_6uvloop_4loop_15_UDPSendContext_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw_6uvloop_4loop_15_UDPSendContext_5__setstate_cython__, METH_O, __pyx_doc_6uvloop_4loop_15_UDPSendContext_4__setstate_cython__},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_6uvloop_4loop__UDPSendContext = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop._UDPSendContext", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop__UDPSendContext), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop__UDPSendContext, /*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_6uvloop_4loop__UDPSendContext, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_6uvloop_4loop__UDPSendContext, /*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_6uvloop_4loop__UDPSendContext, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *__pyx_freelist_6uvloop_4loop___pyx_scope_struct___getaddrinfo[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct___getaddrinfo = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct___getaddrinfo(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct___getaddrinfo > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct___getaddrinfo[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct___getaddrinfo];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct___getaddrinfo(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_fut);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct___getaddrinfo < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct___getaddrinfo[__pyx_freecount_6uvloop_4loop___pyx_scope_struct___getaddrinfo++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct___getaddrinfo(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *)o;
+  if (p->__pyx_v_fut) {
+    e = (*v)(p->__pyx_v_fut, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct___getaddrinfo(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *)o;
+  tmp = ((PyObject*)p->__pyx_v_fut);
+  p->__pyx_v_fut = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct___getaddrinfo = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct___getaddrinfo", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct___getaddrinfo, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct___getaddrinfo, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct___getaddrinfo, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct___getaddrinfo, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_1__getnameinfo[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_1__getnameinfo = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_1__getnameinfo(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_1__getnameinfo > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_1__getnameinfo[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_1__getnameinfo];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_1__getnameinfo(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_fut);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_1__getnameinfo < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_1__getnameinfo[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_1__getnameinfo++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_1__getnameinfo(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *)o;
+  if (p->__pyx_v_fut) {
+    e = (*v)(p->__pyx_v_fut, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct_1__getnameinfo(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *)o;
+  tmp = ((PyObject*)p->__pyx_v_fut);
+  p->__pyx_v_fut = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_1__getnameinfo = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_1__getnameinfo", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_1__getnameinfo, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_1__getnameinfo, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct_1__getnameinfo, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_1__getnameinfo, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_2___get__[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_2___get__ = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_2___get__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_2___get__ > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_2___get__[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_2___get__];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_2___get__(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_self);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_2___get__ < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_2___get__[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_2___get__++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_2___get__(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *)o;
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct_2___get__(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__ *)o;
+  tmp = ((PyObject*)p->__pyx_v_self);
+  p->__pyx_v_self = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_2___get__ = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_2___get__", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2___get__), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_2___get__, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_2___get__, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct_2___get__, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_2___get__, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_3_run_until_complete[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_3_run_until_complete = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_3_run_until_complete(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_3_run_until_complete > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_3_run_until_complete[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_3_run_until_complete];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_3_run_until_complete(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_self);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_3_run_until_complete < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_3_run_until_complete[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_3_run_until_complete++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_3_run_until_complete(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *)o;
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct_3_run_until_complete(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *)o;
+  tmp = ((PyObject*)p->__pyx_v_self);
+  p->__pyx_v_self = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_3_run_until_complete = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_3_run_until_complete", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_3_run_until_complete, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_3_run_until_complete, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct_3_run_until_complete, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_3_run_until_complete, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_addr);
+  Py_CLEAR(p->__pyx_v_fut);
+  Py_CLEAR(p->__pyx_v_host);
+  Py_CLEAR(p->__pyx_v_port);
+  Py_CLEAR(p->__pyx_v_self);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo *)o;
+  if (p->__pyx_v_addr) {
+    e = (*v)(p->__pyx_v_addr, a); if (e) return e;
+  }
+  if (p->__pyx_v_fut) {
+    e = (*v)(p->__pyx_v_fut, a); if (e) return e;
+  }
+  if (p->__pyx_v_host) {
+    e = (*v)(p->__pyx_v_host, a); if (e) return e;
+  }
+  if (p->__pyx_v_port) {
+    e = (*v)(p->__pyx_v_port, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_4_getaddrinfo", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_5_getnameinfo[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_5_getnameinfo = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_5_getnameinfo(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_5_getnameinfo > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_5_getnameinfo[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_5_getnameinfo];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_5_getnameinfo(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_ai_cnt);
+  Py_CLEAR(p->__pyx_v_flowinfo);
+  Py_CLEAR(p->__pyx_v_scope_id);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_sockaddr);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_5_getnameinfo < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_5_getnameinfo[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_5_getnameinfo++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_5_getnameinfo(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo *)o;
+  if (p->__pyx_v_ai_cnt) {
+    e = (*v)(((PyObject *)p->__pyx_v_ai_cnt), a); if (e) return e;
+  }
+  if (p->__pyx_v_flowinfo) {
+    e = (*v)(p->__pyx_v_flowinfo, a); if (e) return e;
+  }
+  if (p->__pyx_v_scope_id) {
+    e = (*v)(p->__pyx_v_scope_id, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_sockaddr) {
+    e = (*v)(p->__pyx_v_sockaddr, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_5_getnameinfo = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_5_getnameinfo", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_getnameinfo), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_5_getnameinfo, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_5_getnameinfo, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_5_getnameinfo, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_6_start_tls[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_6_start_tls = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_6_start_tls(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_6_start_tls > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_6_start_tls[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_6_start_tls];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_6_start_tls(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_app_transport);
+  Py_CLEAR(p->__pyx_v_conmade_cb);
+  Py_CLEAR(p->__pyx_v_context);
+  Py_CLEAR(p->__pyx_v_protocol);
+  Py_CLEAR(p->__pyx_v_resume_cb);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_server_hostname);
+  Py_CLEAR(p->__pyx_v_server_side);
+  Py_CLEAR(p->__pyx_v_ssl_handshake_timeout);
+  Py_CLEAR(p->__pyx_v_ssl_protocol);
+  Py_CLEAR(p->__pyx_v_ssl_shutdown_timeout);
+  Py_CLEAR(p->__pyx_v_sslcontext);
+  Py_CLEAR(p->__pyx_v_transport);
+  Py_CLEAR(p->__pyx_v_waiter);
+  Py_CLEAR(p->__pyx_t_0);
+  Py_CLEAR(p->__pyx_t_1);
+  Py_CLEAR(p->__pyx_t_2);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_6_start_tls < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_6_start_tls[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_6_start_tls++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_6_start_tls(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls *)o;
+  if (p->__pyx_v_app_transport) {
+    e = (*v)(p->__pyx_v_app_transport, a); if (e) return e;
+  }
+  if (p->__pyx_v_conmade_cb) {
+    e = (*v)(p->__pyx_v_conmade_cb, a); if (e) return e;
+  }
+  if (p->__pyx_v_context) {
+    e = (*v)(p->__pyx_v_context, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol) {
+    e = (*v)(p->__pyx_v_protocol, a); if (e) return e;
+  }
+  if (p->__pyx_v_resume_cb) {
+    e = (*v)(p->__pyx_v_resume_cb, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_server_hostname) {
+    e = (*v)(p->__pyx_v_server_hostname, a); if (e) return e;
+  }
+  if (p->__pyx_v_server_side) {
+    e = (*v)(p->__pyx_v_server_side, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_handshake_timeout) {
+    e = (*v)(p->__pyx_v_ssl_handshake_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_protocol) {
+    e = (*v)(((PyObject *)p->__pyx_v_ssl_protocol), a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_shutdown_timeout) {
+    e = (*v)(p->__pyx_v_ssl_shutdown_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_sslcontext) {
+    e = (*v)(p->__pyx_v_sslcontext, a); if (e) return e;
+  }
+  if (p->__pyx_v_transport) {
+    e = (*v)(p->__pyx_v_transport, a); if (e) return e;
+  }
+  if (p->__pyx_v_waiter) {
+    e = (*v)(p->__pyx_v_waiter, a); if (e) return e;
+  }
+  if (p->__pyx_t_0) {
+    e = (*v)(p->__pyx_t_0, a); if (e) return e;
+  }
+  if (p->__pyx_t_1) {
+    e = (*v)(p->__pyx_t_1, a); if (e) return e;
+  }
+  if (p->__pyx_t_2) {
+    e = (*v)(p->__pyx_t_2, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_6_start_tls = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_6_start_tls", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_start_tls), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_6_start_tls, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_6_start_tls, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_6_start_tls, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_7_create_server[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_7_create_server = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_7_create_server(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_7_create_server > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_7_create_server[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_7_create_server];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_7_create_server(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_backlog);
+  Py_CLEAR(p->__pyx_v_err);
+  Py_CLEAR(p->__pyx_v_fs);
+  Py_CLEAR(p->__pyx_7genexpr__pyx_v_host);
+  Py_CLEAR(p->__pyx_v_host);
+  Py_CLEAR(p->__pyx_v_hosts);
+  Py_CLEAR(p->__pyx_v_info);
+  Py_CLEAR(p->__pyx_v_infos);
+  Py_CLEAR(p->__pyx_v_port);
+  Py_CLEAR(p->__pyx_v_protocol_factory);
+  Py_CLEAR(p->__pyx_v_pyaddr);
+  Py_CLEAR(p->__pyx_v_reuse_address);
+  Py_CLEAR(p->__pyx_v_reuse_port);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_server);
+  Py_CLEAR(p->__pyx_v_sock);
+  Py_CLEAR(p->__pyx_v_ssl);
+  Py_CLEAR(p->__pyx_v_ssl_handshake_timeout);
+  Py_CLEAR(p->__pyx_v_ssl_shutdown_timeout);
+  Py_CLEAR(p->__pyx_v_start_serving);
+  Py_CLEAR(p->__pyx_v_tcp);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_7_create_server < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_7_create_server[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_7_create_server++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_7_create_server(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server *)o;
+  if (p->__pyx_v_backlog) {
+    e = (*v)(p->__pyx_v_backlog, a); if (e) return e;
+  }
+  if (p->__pyx_v_err) {
+    e = (*v)(p->__pyx_v_err, a); if (e) return e;
+  }
+  if (p->__pyx_v_fs) {
+    e = (*v)(p->__pyx_v_fs, a); if (e) return e;
+  }
+  if (p->__pyx_7genexpr__pyx_v_host) {
+    e = (*v)(p->__pyx_7genexpr__pyx_v_host, a); if (e) return e;
+  }
+  if (p->__pyx_v_host) {
+    e = (*v)(p->__pyx_v_host, a); if (e) return e;
+  }
+  if (p->__pyx_v_hosts) {
+    e = (*v)(p->__pyx_v_hosts, a); if (e) return e;
+  }
+  if (p->__pyx_v_info) {
+    e = (*v)(p->__pyx_v_info, a); if (e) return e;
+  }
+  if (p->__pyx_v_infos) {
+    e = (*v)(p->__pyx_v_infos, a); if (e) return e;
+  }
+  if (p->__pyx_v_port) {
+    e = (*v)(p->__pyx_v_port, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol_factory) {
+    e = (*v)(p->__pyx_v_protocol_factory, a); if (e) return e;
+  }
+  if (p->__pyx_v_pyaddr) {
+    e = (*v)(p->__pyx_v_pyaddr, a); if (e) return e;
+  }
+  if (p->__pyx_v_reuse_address) {
+    e = (*v)(p->__pyx_v_reuse_address, a); if (e) return e;
+  }
+  if (p->__pyx_v_reuse_port) {
+    e = (*v)(p->__pyx_v_reuse_port, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_server) {
+    e = (*v)(((PyObject *)p->__pyx_v_server), a); if (e) return e;
+  }
+  if (p->__pyx_v_sock) {
+    e = (*v)(p->__pyx_v_sock, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl) {
+    e = (*v)(p->__pyx_v_ssl, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_handshake_timeout) {
+    e = (*v)(p->__pyx_v_ssl_handshake_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_shutdown_timeout) {
+    e = (*v)(p->__pyx_v_ssl_shutdown_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_start_serving) {
+    e = (*v)(p->__pyx_v_start_serving, a); if (e) return e;
+  }
+  if (p->__pyx_v_tcp) {
+    e = (*v)(((PyObject *)p->__pyx_v_tcp), a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_7_create_server = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_7_create_server", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_create_server), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_7_create_server, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_7_create_server, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_7_create_server, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_8_create_connection[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_8_create_connection = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_8_create_connection(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_8_create_connection > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_8_create_connection[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_8_create_connection];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_8_create_connection(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_addr);
+  Py_CLEAR(p->__pyx_v_ai_local);
+  Py_CLEAR(p->__pyx_v_ai_remote);
+  Py_CLEAR(p->__pyx_v_app_protocol);
+  Py_CLEAR(p->__pyx_v_app_transport);
+  Py_CLEAR(p->__pyx_v_context);
+  Py_CLEAR(p->__pyx_v_exc);
+  Py_CLEAR(p->__pyx_v_exceptions);
+  Py_CLEAR(p->__pyx_v_f1);
+  Py_CLEAR(p->__pyx_v_f2);
+  Py_CLEAR(p->__pyx_v_family);
+  Py_CLEAR(p->__pyx_v_flags);
+  Py_CLEAR(p->__pyx_v_fs);
+  Py_CLEAR(p->__pyx_v_genexpr);
+  Py_CLEAR(p->__pyx_v_host);
+  Py_CLEAR(p->__pyx_v_local_addr);
+  Py_CLEAR(p->__pyx_v_model);
+  Py_CLEAR(p->__pyx_v_port);
+  Py_CLEAR(p->__pyx_v_proto);
+  Py_CLEAR(p->__pyx_v_protocol);
+  Py_CLEAR(p->__pyx_v_protocol_factory);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_server_hostname);
+  Py_CLEAR(p->__pyx_v_sock);
+  Py_CLEAR(p->__pyx_v_ssl);
+  Py_CLEAR(p->__pyx_v_ssl_handshake_timeout);
+  Py_CLEAR(p->__pyx_v_ssl_shutdown_timeout);
+  Py_CLEAR(p->__pyx_v_ssl_waiter);
+  Py_CLEAR(p->__pyx_v_sslcontext);
+  Py_CLEAR(p->__pyx_v_tr);
+  Py_CLEAR(p->__pyx_v_waiter);
+  Py_CLEAR(p->__pyx_t_0);
+  Py_CLEAR(p->__pyx_t_1);
+  Py_CLEAR(p->__pyx_t_2);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_8_create_connection < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_8_create_connection[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_8_create_connection++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_8_create_connection(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection *)o;
+  if (p->__pyx_v_addr) {
+    e = (*v)(p->__pyx_v_addr, a); if (e) return e;
+  }
+  if (p->__pyx_v_ai_local) {
+    e = (*v)(((PyObject *)p->__pyx_v_ai_local), a); if (e) return e;
+  }
+  if (p->__pyx_v_ai_remote) {
+    e = (*v)(((PyObject *)p->__pyx_v_ai_remote), a); if (e) return e;
+  }
+  if (p->__pyx_v_app_protocol) {
+    e = (*v)(p->__pyx_v_app_protocol, a); if (e) return e;
+  }
+  if (p->__pyx_v_app_transport) {
+    e = (*v)(p->__pyx_v_app_transport, a); if (e) return e;
+  }
+  if (p->__pyx_v_context) {
+    e = (*v)(p->__pyx_v_context, a); if (e) return e;
+  }
+  if (p->__pyx_v_exc) {
+    e = (*v)(p->__pyx_v_exc, a); if (e) return e;
+  }
+  if (p->__pyx_v_exceptions) {
+    e = (*v)(p->__pyx_v_exceptions, a); if (e) return e;
+  }
+  if (p->__pyx_v_f1) {
+    e = (*v)(p->__pyx_v_f1, a); if (e) return e;
+  }
+  if (p->__pyx_v_f2) {
+    e = (*v)(p->__pyx_v_f2, a); if (e) return e;
+  }
+  if (p->__pyx_v_family) {
+    e = (*v)(p->__pyx_v_family, a); if (e) return e;
+  }
+  if (p->__pyx_v_flags) {
+    e = (*v)(p->__pyx_v_flags, a); if (e) return e;
+  }
+  if (p->__pyx_v_fs) {
+    e = (*v)(p->__pyx_v_fs, a); if (e) return e;
+  }
+  if (p->__pyx_v_genexpr) {
+    e = (*v)(p->__pyx_v_genexpr, a); if (e) return e;
+  }
+  if (p->__pyx_v_host) {
+    e = (*v)(p->__pyx_v_host, a); if (e) return e;
+  }
+  if (p->__pyx_v_local_addr) {
+    e = (*v)(p->__pyx_v_local_addr, a); if (e) return e;
+  }
+  if (p->__pyx_v_model) {
+    e = (*v)(p->__pyx_v_model, a); if (e) return e;
+  }
+  if (p->__pyx_v_port) {
+    e = (*v)(p->__pyx_v_port, a); if (e) return e;
+  }
+  if (p->__pyx_v_proto) {
+    e = (*v)(p->__pyx_v_proto, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol) {
+    e = (*v)(p->__pyx_v_protocol, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol_factory) {
+    e = (*v)(p->__pyx_v_protocol_factory, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_server_hostname) {
+    e = (*v)(p->__pyx_v_server_hostname, a); if (e) return e;
+  }
+  if (p->__pyx_v_sock) {
+    e = (*v)(p->__pyx_v_sock, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl) {
+    e = (*v)(p->__pyx_v_ssl, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_handshake_timeout) {
+    e = (*v)(p->__pyx_v_ssl_handshake_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_shutdown_timeout) {
+    e = (*v)(p->__pyx_v_ssl_shutdown_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_waiter) {
+    e = (*v)(p->__pyx_v_ssl_waiter, a); if (e) return e;
+  }
+  if (p->__pyx_v_sslcontext) {
+    e = (*v)(p->__pyx_v_sslcontext, a); if (e) return e;
+  }
+  if (p->__pyx_v_tr) {
+    e = (*v)(((PyObject *)p->__pyx_v_tr), a); if (e) return e;
+  }
+  if (p->__pyx_v_waiter) {
+    e = (*v)(p->__pyx_v_waiter, a); if (e) return e;
+  }
+  if (p->__pyx_t_0) {
+    e = (*v)(p->__pyx_t_0, a); if (e) return e;
+  }
+  if (p->__pyx_t_1) {
+    e = (*v)(p->__pyx_t_1, a); if (e) return e;
+  }
+  if (p->__pyx_t_2) {
+    e = (*v)(p->__pyx_t_2, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_8_create_connection = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_8_create_connection", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_create_connection), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_8_create_connection, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_8_create_connection, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_8_create_connection, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_9_genexpr[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_9_genexpr = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_9_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_9_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_9_genexpr[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_9_genexpr];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_9_genexpr(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_outer_scope);
+  Py_CLEAR(p->__pyx_v_exc);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_9_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_9_genexpr[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_9_genexpr++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_9_genexpr(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr *)o;
+  if (p->__pyx_outer_scope) {
+    e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e;
+  }
+  if (p->__pyx_v_exc) {
+    e = (*v)(p->__pyx_v_exc, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_9_genexpr = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_9_genexpr", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_genexpr), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_9_genexpr, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_9_genexpr, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_9_genexpr, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_10_genexpr[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_10_genexpr = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_10_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_10_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_10_genexpr[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_10_genexpr];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_10_genexpr(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_outer_scope);
+  Py_CLEAR(p->__pyx_v_exc);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_10_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_10_genexpr[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_10_genexpr++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_10_genexpr(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr *)o;
+  if (p->__pyx_outer_scope) {
+    e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e;
+  }
+  if (p->__pyx_v_exc) {
+    e = (*v)(p->__pyx_v_exc, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_10_genexpr = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_10_genexpr", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_genexpr), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_10_genexpr, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_10_genexpr, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_10_genexpr, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_11_create_unix_server[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_11_create_unix_server = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_11_create_unix_server(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_11_create_unix_server > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_11_create_unix_server[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_11_create_unix_server];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_11_create_unix_server(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_backlog);
+  Py_CLEAR(p->__pyx_v_err);
+  Py_CLEAR(p->__pyx_v_exc);
+  Py_CLEAR(p->__pyx_v_msg);
+  Py_CLEAR(p->__pyx_v_orig_path);
+  Py_CLEAR(p->__pyx_v_path);
+  Py_CLEAR(p->__pyx_v_pipe);
+  Py_CLEAR(p->__pyx_v_protocol_factory);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_server);
+  Py_CLEAR(p->__pyx_v_sock);
+  Py_CLEAR(p->__pyx_v_ssl);
+  Py_CLEAR(p->__pyx_v_ssl_handshake_timeout);
+  Py_CLEAR(p->__pyx_v_ssl_shutdown_timeout);
+  Py_CLEAR(p->__pyx_v_start_serving);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_11_create_unix_server < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_11_create_unix_server[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_11_create_unix_server++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_11_create_unix_server(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server *)o;
+  if (p->__pyx_v_backlog) {
+    e = (*v)(p->__pyx_v_backlog, a); if (e) return e;
+  }
+  if (p->__pyx_v_err) {
+    e = (*v)(p->__pyx_v_err, a); if (e) return e;
+  }
+  if (p->__pyx_v_exc) {
+    e = (*v)(p->__pyx_v_exc, a); if (e) return e;
+  }
+  if (p->__pyx_v_msg) {
+    e = (*v)(p->__pyx_v_msg, a); if (e) return e;
+  }
+  if (p->__pyx_v_orig_path) {
+    e = (*v)(p->__pyx_v_orig_path, a); if (e) return e;
+  }
+  if (p->__pyx_v_path) {
+    e = (*v)(p->__pyx_v_path, a); if (e) return e;
+  }
+  if (p->__pyx_v_pipe) {
+    e = (*v)(((PyObject *)p->__pyx_v_pipe), a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol_factory) {
+    e = (*v)(p->__pyx_v_protocol_factory, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_server) {
+    e = (*v)(((PyObject *)p->__pyx_v_server), a); if (e) return e;
+  }
+  if (p->__pyx_v_sock) {
+    e = (*v)(p->__pyx_v_sock, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl) {
+    e = (*v)(p->__pyx_v_ssl, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_handshake_timeout) {
+    e = (*v)(p->__pyx_v_ssl_handshake_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_shutdown_timeout) {
+    e = (*v)(p->__pyx_v_ssl_shutdown_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_start_serving) {
+    e = (*v)(p->__pyx_v_start_serving, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_11_create_unix_server = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_11_create_unix_server", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_create_unix_server), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_11_create_unix_server, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_11_create_unix_server, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_11_create_unix_server, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_app_protocol);
+  Py_CLEAR(p->__pyx_v_app_transport);
+  Py_CLEAR(p->__pyx_v_context);
+  Py_CLEAR(p->__pyx_v_path);
+  Py_CLEAR(p->__pyx_v_protocol);
+  Py_CLEAR(p->__pyx_v_protocol_factory);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_server_hostname);
+  Py_CLEAR(p->__pyx_v_sock);
+  Py_CLEAR(p->__pyx_v_ssl);
+  Py_CLEAR(p->__pyx_v_ssl_handshake_timeout);
+  Py_CLEAR(p->__pyx_v_ssl_shutdown_timeout);
+  Py_CLEAR(p->__pyx_v_ssl_waiter);
+  Py_CLEAR(p->__pyx_v_sslcontext);
+  Py_CLEAR(p->__pyx_v_tr);
+  Py_CLEAR(p->__pyx_v_waiter);
+  Py_CLEAR(p->__pyx_t_0);
+  Py_CLEAR(p->__pyx_t_1);
+  Py_CLEAR(p->__pyx_t_2);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection *)o;
+  if (p->__pyx_v_app_protocol) {
+    e = (*v)(p->__pyx_v_app_protocol, a); if (e) return e;
+  }
+  if (p->__pyx_v_app_transport) {
+    e = (*v)(p->__pyx_v_app_transport, a); if (e) return e;
+  }
+  if (p->__pyx_v_context) {
+    e = (*v)(p->__pyx_v_context, a); if (e) return e;
+  }
+  if (p->__pyx_v_path) {
+    e = (*v)(p->__pyx_v_path, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol) {
+    e = (*v)(p->__pyx_v_protocol, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol_factory) {
+    e = (*v)(p->__pyx_v_protocol_factory, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_server_hostname) {
+    e = (*v)(p->__pyx_v_server_hostname, a); if (e) return e;
+  }
+  if (p->__pyx_v_sock) {
+    e = (*v)(p->__pyx_v_sock, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl) {
+    e = (*v)(p->__pyx_v_ssl, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_handshake_timeout) {
+    e = (*v)(p->__pyx_v_ssl_handshake_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_shutdown_timeout) {
+    e = (*v)(p->__pyx_v_ssl_shutdown_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_waiter) {
+    e = (*v)(p->__pyx_v_ssl_waiter, a); if (e) return e;
+  }
+  if (p->__pyx_v_sslcontext) {
+    e = (*v)(p->__pyx_v_sslcontext, a); if (e) return e;
+  }
+  if (p->__pyx_v_tr) {
+    e = (*v)(((PyObject *)p->__pyx_v_tr), a); if (e) return e;
+  }
+  if (p->__pyx_v_waiter) {
+    e = (*v)(p->__pyx_v_waiter, a); if (e) return e;
+  }
+  if (p->__pyx_t_0) {
+    e = (*v)(p->__pyx_t_0, a); if (e) return e;
+  }
+  if (p->__pyx_t_1) {
+    e = (*v)(p->__pyx_t_1, a); if (e) return e;
+  }
+  if (p->__pyx_t_2) {
+    e = (*v)(p->__pyx_t_2, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_12_create_unix_connection", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_13_sock_recv[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_13_sock_recv = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_13_sock_recv(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_13_sock_recv > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_13_sock_recv[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_13_sock_recv];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_13_sock_recv(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_fut);
+  Py_CLEAR(p->__pyx_v_handle);
+  Py_CLEAR(p->__pyx_v_n);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_sock);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_13_sock_recv < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_13_sock_recv[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_13_sock_recv++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_13_sock_recv(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv *)o;
+  if (p->__pyx_v_fut) {
+    e = (*v)(p->__pyx_v_fut, a); if (e) return e;
+  }
+  if (p->__pyx_v_handle) {
+    e = (*v)(((PyObject *)p->__pyx_v_handle), a); if (e) return e;
+  }
+  if (p->__pyx_v_n) {
+    e = (*v)(p->__pyx_v_n, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_sock) {
+    e = (*v)(p->__pyx_v_sock, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_13_sock_recv = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_13_sock_recv", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_sock_recv), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_13_sock_recv, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_13_sock_recv, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_13_sock_recv, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_buf);
+  Py_CLEAR(p->__pyx_v_fut);
+  Py_CLEAR(p->__pyx_v_handle);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_sock);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into *)o;
+  if (p->__pyx_v_buf) {
+    e = (*v)(p->__pyx_v_buf, a); if (e) return e;
+  }
+  if (p->__pyx_v_fut) {
+    e = (*v)(p->__pyx_v_fut, a); if (e) return e;
+  }
+  if (p->__pyx_v_handle) {
+    e = (*v)(((PyObject *)p->__pyx_v_handle), a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_sock) {
+    e = (*v)(p->__pyx_v_sock, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_14_sock_recv_into", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_15_sock_sendall[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_15_sock_sendall = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_15_sock_sendall(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_15_sock_sendall > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_15_sock_sendall[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_15_sock_sendall];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_15_sock_sendall(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_data);
+  Py_CLEAR(p->__pyx_v_fut);
+  Py_CLEAR(p->__pyx_v_handle);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_sock);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_15_sock_sendall < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_15_sock_sendall[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_15_sock_sendall++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_15_sock_sendall(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall *)o;
+  if (p->__pyx_v_data) {
+    e = (*v)(p->__pyx_v_data, a); if (e) return e;
+  }
+  if (p->__pyx_v_fut) {
+    e = (*v)(p->__pyx_v_fut, a); if (e) return e;
+  }
+  if (p->__pyx_v_handle) {
+    e = (*v)(((PyObject *)p->__pyx_v_handle), a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_sock) {
+    e = (*v)(p->__pyx_v_sock, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_15_sock_sendall = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_15_sock_sendall", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_sock_sendall), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_15_sock_sendall, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_15_sock_sendall, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_15_sock_sendall, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_16_sock_accept[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_16_sock_accept = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_16_sock_accept(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_16_sock_accept > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_16_sock_accept[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_16_sock_accept];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_16_sock_accept(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_fut);
+  Py_CLEAR(p->__pyx_v_handle);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_sock);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_16_sock_accept < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_16_sock_accept[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_16_sock_accept++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_16_sock_accept(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept *)o;
+  if (p->__pyx_v_fut) {
+    e = (*v)(p->__pyx_v_fut, a); if (e) return e;
+  }
+  if (p->__pyx_v_handle) {
+    e = (*v)(((PyObject *)p->__pyx_v_handle), a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_sock) {
+    e = (*v)(p->__pyx_v_sock, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_16_sock_accept = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_16_sock_accept", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_sock_accept), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_16_sock_accept, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_16_sock_accept, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_16_sock_accept, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_17_sock_connect[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_17_sock_connect = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_17_sock_connect(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_17_sock_connect > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_17_sock_connect[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_17_sock_connect];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_17_sock_connect(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v__);
+  Py_CLEAR(p->__pyx_v_address);
+  Py_CLEAR(p->__pyx_v_addrs);
+  Py_CLEAR(p->__pyx_v_fut);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_sock);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_17_sock_connect < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_17_sock_connect[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_17_sock_connect++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_17_sock_connect(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect *)o;
+  if (p->__pyx_v__) {
+    e = (*v)(p->__pyx_v__, a); if (e) return e;
+  }
+  if (p->__pyx_v_address) {
+    e = (*v)(p->__pyx_v_address, a); if (e) return e;
+  }
+  if (p->__pyx_v_addrs) {
+    e = (*v)(p->__pyx_v_addrs, a); if (e) return e;
+  }
+  if (p->__pyx_v_fut) {
+    e = (*v)(p->__pyx_v_fut, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_sock) {
+    e = (*v)(p->__pyx_v_sock, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_17_sock_connect = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_17_sock_connect", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_sock_connect), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_17_sock_connect, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_17_sock_connect, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_17_sock_connect, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_app_protocol);
+  Py_CLEAR(p->__pyx_v_app_transport);
+  Py_CLEAR(p->__pyx_v_context);
+  Py_CLEAR(p->__pyx_v_protocol);
+  Py_CLEAR(p->__pyx_v_protocol_factory);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_sock);
+  Py_CLEAR(p->__pyx_v_ssl);
+  Py_CLEAR(p->__pyx_v_ssl_handshake_timeout);
+  Py_CLEAR(p->__pyx_v_ssl_shutdown_timeout);
+  Py_CLEAR(p->__pyx_v_transport);
+  Py_CLEAR(p->__pyx_v_transport_waiter);
+  Py_CLEAR(p->__pyx_v_waiter);
+  Py_CLEAR(p->__pyx_t_0);
+  Py_CLEAR(p->__pyx_t_1);
+  Py_CLEAR(p->__pyx_t_2);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket *)o;
+  if (p->__pyx_v_app_protocol) {
+    e = (*v)(p->__pyx_v_app_protocol, a); if (e) return e;
+  }
+  if (p->__pyx_v_app_transport) {
+    e = (*v)(p->__pyx_v_app_transport, a); if (e) return e;
+  }
+  if (p->__pyx_v_context) {
+    e = (*v)(p->__pyx_v_context, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol) {
+    e = (*v)(p->__pyx_v_protocol, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol_factory) {
+    e = (*v)(p->__pyx_v_protocol_factory, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_sock) {
+    e = (*v)(p->__pyx_v_sock, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl) {
+    e = (*v)(p->__pyx_v_ssl, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_handshake_timeout) {
+    e = (*v)(p->__pyx_v_ssl_handshake_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_ssl_shutdown_timeout) {
+    e = (*v)(p->__pyx_v_ssl_shutdown_timeout, a); if (e) return e;
+  }
+  if (p->__pyx_v_transport) {
+    e = (*v)(((PyObject *)p->__pyx_v_transport), a); if (e) return e;
+  }
+  if (p->__pyx_v_transport_waiter) {
+    e = (*v)(p->__pyx_v_transport_waiter, a); if (e) return e;
+  }
+  if (p->__pyx_v_waiter) {
+    e = (*v)(p->__pyx_v_waiter, a); if (e) return e;
+  }
+  if (p->__pyx_t_0) {
+    e = (*v)(p->__pyx_t_0, a); if (e) return e;
+  }
+  if (p->__pyx_t_1) {
+    e = (*v)(p->__pyx_t_1, a); if (e) return e;
+  }
+  if (p->__pyx_t_2) {
+    e = (*v)(p->__pyx_t_2, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_18_connect_accepted_socket", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_19___subprocess_run[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_19___subprocess_run = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_19___subprocess_run(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_19___subprocess_run > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_19___subprocess_run[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_19___subprocess_run];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_19___subprocess_run(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v___uvloop_sleep_after_fork);
+  Py_CLEAR(p->__pyx_v_args);
+  Py_CLEAR(p->__pyx_v_bufsize);
+  Py_CLEAR(p->__pyx_v_close_fds);
+  Py_CLEAR(p->__pyx_v_creationflags);
+  Py_CLEAR(p->__pyx_v_cwd);
+  Py_CLEAR(p->__pyx_v_env);
+  Py_CLEAR(p->__pyx_v_executable);
+  Py_CLEAR(p->__pyx_v_pass_fds);
+  Py_CLEAR(p->__pyx_v_preexec_fn);
+  Py_CLEAR(p->__pyx_v_proc);
+  Py_CLEAR(p->__pyx_v_protocol);
+  Py_CLEAR(p->__pyx_v_protocol_factory);
+  Py_CLEAR(p->__pyx_v_restore_signals);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_shell);
+  Py_CLEAR(p->__pyx_v_start_new_session);
+  Py_CLEAR(p->__pyx_v_startupinfo);
+  Py_CLEAR(p->__pyx_v_stderr);
+  Py_CLEAR(p->__pyx_v_stdin);
+  Py_CLEAR(p->__pyx_v_stdout);
+  Py_CLEAR(p->__pyx_v_universal_newlines);
+  Py_CLEAR(p->__pyx_v_waiter);
+  Py_CLEAR(p->__pyx_t_0);
+  Py_CLEAR(p->__pyx_t_1);
+  Py_CLEAR(p->__pyx_t_2);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_19___subprocess_run < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_19___subprocess_run[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_19___subprocess_run++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_19___subprocess_run(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run *)o;
+  if (p->__pyx_v___uvloop_sleep_after_fork) {
+    e = (*v)(p->__pyx_v___uvloop_sleep_after_fork, a); if (e) return e;
+  }
+  if (p->__pyx_v_args) {
+    e = (*v)(p->__pyx_v_args, a); if (e) return e;
+  }
+  if (p->__pyx_v_bufsize) {
+    e = (*v)(p->__pyx_v_bufsize, a); if (e) return e;
+  }
+  if (p->__pyx_v_close_fds) {
+    e = (*v)(p->__pyx_v_close_fds, a); if (e) return e;
+  }
+  if (p->__pyx_v_creationflags) {
+    e = (*v)(p->__pyx_v_creationflags, a); if (e) return e;
+  }
+  if (p->__pyx_v_cwd) {
+    e = (*v)(p->__pyx_v_cwd, a); if (e) return e;
+  }
+  if (p->__pyx_v_env) {
+    e = (*v)(p->__pyx_v_env, a); if (e) return e;
+  }
+  if (p->__pyx_v_executable) {
+    e = (*v)(p->__pyx_v_executable, a); if (e) return e;
+  }
+  if (p->__pyx_v_pass_fds) {
+    e = (*v)(p->__pyx_v_pass_fds, a); if (e) return e;
+  }
+  if (p->__pyx_v_preexec_fn) {
+    e = (*v)(p->__pyx_v_preexec_fn, a); if (e) return e;
+  }
+  if (p->__pyx_v_proc) {
+    e = (*v)(((PyObject *)p->__pyx_v_proc), a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol) {
+    e = (*v)(p->__pyx_v_protocol, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol_factory) {
+    e = (*v)(p->__pyx_v_protocol_factory, a); if (e) return e;
+  }
+  if (p->__pyx_v_restore_signals) {
+    e = (*v)(p->__pyx_v_restore_signals, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_shell) {
+    e = (*v)(p->__pyx_v_shell, a); if (e) return e;
+  }
+  if (p->__pyx_v_start_new_session) {
+    e = (*v)(p->__pyx_v_start_new_session, a); if (e) return e;
+  }
+  if (p->__pyx_v_startupinfo) {
+    e = (*v)(p->__pyx_v_startupinfo, a); if (e) return e;
+  }
+  if (p->__pyx_v_stderr) {
+    e = (*v)(p->__pyx_v_stderr, a); if (e) return e;
+  }
+  if (p->__pyx_v_stdin) {
+    e = (*v)(p->__pyx_v_stdin, a); if (e) return e;
+  }
+  if (p->__pyx_v_stdout) {
+    e = (*v)(p->__pyx_v_stdout, a); if (e) return e;
+  }
+  if (p->__pyx_v_universal_newlines) {
+    e = (*v)(p->__pyx_v_universal_newlines, a); if (e) return e;
+  }
+  if (p->__pyx_v_waiter) {
+    e = (*v)(p->__pyx_v_waiter, a); if (e) return e;
+  }
+  if (p->__pyx_t_0) {
+    e = (*v)(p->__pyx_t_0, a); if (e) return e;
+  }
+  if (p->__pyx_t_1) {
+    e = (*v)(p->__pyx_t_1, a); if (e) return e;
+  }
+  if (p->__pyx_t_2) {
+    e = (*v)(p->__pyx_t_2, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_19___subprocess_run = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_19___subprocess_run", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19___subprocess_run), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_19___subprocess_run, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_19___subprocess_run, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_19___subprocess_run, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_args);
+  Py_CLEAR(p->__pyx_v_cmd);
+  Py_CLEAR(p->__pyx_v_kwargs);
+  Py_CLEAR(p->__pyx_v_protocol_factory);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_shell);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell *)o;
+  if (p->__pyx_v_args) {
+    e = (*v)(p->__pyx_v_args, a); if (e) return e;
+  }
+  if (p->__pyx_v_cmd) {
+    e = (*v)(p->__pyx_v_cmd, a); if (e) return e;
+  }
+  if (p->__pyx_v_kwargs) {
+    e = (*v)(p->__pyx_v_kwargs, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol_factory) {
+    e = (*v)(p->__pyx_v_protocol_factory, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_shell) {
+    e = (*v)(p->__pyx_v_shell, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_20_subprocess_shell", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_args);
+  Py_CLEAR(p->__pyx_v_kwargs);
+  Py_CLEAR(p->__pyx_v_program);
+  Py_CLEAR(p->__pyx_v_protocol_factory);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_shell);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec *)o;
+  if (p->__pyx_v_args) {
+    e = (*v)(p->__pyx_v_args, a); if (e) return e;
+  }
+  if (p->__pyx_v_kwargs) {
+    e = (*v)(p->__pyx_v_kwargs, a); if (e) return e;
+  }
+  if (p->__pyx_v_program) {
+    e = (*v)(p->__pyx_v_program, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol_factory) {
+    e = (*v)(p->__pyx_v_protocol_factory, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_shell) {
+    e = (*v)(p->__pyx_v_shell, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_21_subprocess_exec", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_pipe);
+  Py_CLEAR(p->__pyx_v_proto);
+  Py_CLEAR(p->__pyx_v_proto_factory);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_transp);
+  Py_CLEAR(p->__pyx_v_waiter);
+  Py_CLEAR(p->__pyx_t_0);
+  Py_CLEAR(p->__pyx_t_1);
+  Py_CLEAR(p->__pyx_t_2);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe *)o;
+  if (p->__pyx_v_pipe) {
+    e = (*v)(p->__pyx_v_pipe, a); if (e) return e;
+  }
+  if (p->__pyx_v_proto) {
+    e = (*v)(p->__pyx_v_proto, a); if (e) return e;
+  }
+  if (p->__pyx_v_proto_factory) {
+    e = (*v)(p->__pyx_v_proto_factory, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_transp) {
+    e = (*v)(((PyObject *)p->__pyx_v_transp), a); if (e) return e;
+  }
+  if (p->__pyx_v_waiter) {
+    e = (*v)(p->__pyx_v_waiter, a); if (e) return e;
+  }
+  if (p->__pyx_t_0) {
+    e = (*v)(p->__pyx_t_0, a); if (e) return e;
+  }
+  if (p->__pyx_t_1) {
+    e = (*v)(p->__pyx_t_1, a); if (e) return e;
+  }
+  if (p->__pyx_t_2) {
+    e = (*v)(p->__pyx_t_2, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_22_connect_read_pipe", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_pipe);
+  Py_CLEAR(p->__pyx_v_proto);
+  Py_CLEAR(p->__pyx_v_proto_factory);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_transp);
+  Py_CLEAR(p->__pyx_v_waiter);
+  Py_CLEAR(p->__pyx_t_0);
+  Py_CLEAR(p->__pyx_t_1);
+  Py_CLEAR(p->__pyx_t_2);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe *)o;
+  if (p->__pyx_v_pipe) {
+    e = (*v)(p->__pyx_v_pipe, a); if (e) return e;
+  }
+  if (p->__pyx_v_proto) {
+    e = (*v)(p->__pyx_v_proto, a); if (e) return e;
+  }
+  if (p->__pyx_v_proto_factory) {
+    e = (*v)(p->__pyx_v_proto_factory, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_transp) {
+    e = (*v)(((PyObject *)p->__pyx_v_transp), a); if (e) return e;
+  }
+  if (p->__pyx_v_waiter) {
+    e = (*v)(p->__pyx_v_waiter, a); if (e) return e;
+  }
+  if (p->__pyx_t_0) {
+    e = (*v)(p->__pyx_t_0, a); if (e) return e;
+  }
+  if (p->__pyx_t_1) {
+    e = (*v)(p->__pyx_t_1, a); if (e) return e;
+  }
+  if (p->__pyx_t_2) {
+    e = (*v)(p->__pyx_t_2, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_23_connect_write_pipe", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_allow_broadcast);
+  Py_CLEAR(p->__pyx_v_ctx);
+  Py_CLEAR(p->__pyx_v_ex);
+  Py_CLEAR(p->__pyx_v_excs);
+  Py_CLEAR(p->__pyx_v_family);
+  Py_CLEAR(p->__pyx_v_flags);
+  Py_CLEAR(p->__pyx_v_genexpr);
+  Py_CLEAR(p->__pyx_v_lads);
+  Py_CLEAR(p->__pyx_v_local_addr);
+  Py_CLEAR(p->__pyx_v_opts);
+  Py_CLEAR(p->__pyx_v_problems);
+  Py_CLEAR(p->__pyx_v_proto);
+  Py_CLEAR(p->__pyx_v_protocol);
+  Py_CLEAR(p->__pyx_v_protocol_factory);
+  Py_CLEAR(p->__pyx_v_rads);
+  Py_CLEAR(p->__pyx_v_remote_addr);
+  Py_CLEAR(p->__pyx_v_reuse_address);
+  Py_CLEAR(p->__pyx_v_reuse_port);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_sock);
+  Py_CLEAR(p->__pyx_v_udp);
+  Py_CLEAR(p->__pyx_v_waiter);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint *)o;
+  if (p->__pyx_v_allow_broadcast) {
+    e = (*v)(p->__pyx_v_allow_broadcast, a); if (e) return e;
+  }
+  if (p->__pyx_v_ctx) {
+    e = (*v)(p->__pyx_v_ctx, a); if (e) return e;
+  }
+  if (p->__pyx_v_ex) {
+    e = (*v)(p->__pyx_v_ex, a); if (e) return e;
+  }
+  if (p->__pyx_v_excs) {
+    e = (*v)(p->__pyx_v_excs, a); if (e) return e;
+  }
+  if (p->__pyx_v_family) {
+    e = (*v)(p->__pyx_v_family, a); if (e) return e;
+  }
+  if (p->__pyx_v_flags) {
+    e = (*v)(p->__pyx_v_flags, a); if (e) return e;
+  }
+  if (p->__pyx_v_genexpr) {
+    e = (*v)(p->__pyx_v_genexpr, a); if (e) return e;
+  }
+  if (p->__pyx_v_lads) {
+    e = (*v)(p->__pyx_v_lads, a); if (e) return e;
+  }
+  if (p->__pyx_v_local_addr) {
+    e = (*v)(p->__pyx_v_local_addr, a); if (e) return e;
+  }
+  if (p->__pyx_v_opts) {
+    e = (*v)(p->__pyx_v_opts, a); if (e) return e;
+  }
+  if (p->__pyx_v_proto) {
+    e = (*v)(p->__pyx_v_proto, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol) {
+    e = (*v)(p->__pyx_v_protocol, a); if (e) return e;
+  }
+  if (p->__pyx_v_protocol_factory) {
+    e = (*v)(p->__pyx_v_protocol_factory, a); if (e) return e;
+  }
+  if (p->__pyx_v_rads) {
+    e = (*v)(p->__pyx_v_rads, a); if (e) return e;
+  }
+  if (p->__pyx_v_remote_addr) {
+    e = (*v)(p->__pyx_v_remote_addr, a); if (e) return e;
+  }
+  if (p->__pyx_v_reuse_address) {
+    e = (*v)(p->__pyx_v_reuse_address, a); if (e) return e;
+  }
+  if (p->__pyx_v_reuse_port) {
+    e = (*v)(p->__pyx_v_reuse_port, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_sock) {
+    e = (*v)(p->__pyx_v_sock, a); if (e) return e;
+  }
+  if (p->__pyx_v_udp) {
+    e = (*v)(((PyObject *)p->__pyx_v_udp), a); if (e) return e;
+  }
+  if (p->__pyx_v_waiter) {
+    e = (*v)(p->__pyx_v_waiter, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_24_create_datagram_endpoint", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_25_genexpr[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_25_genexpr = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_25_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_25_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_25_genexpr[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_25_genexpr];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_25_genexpr(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_outer_scope);
+  Py_CLEAR(p->__pyx_v_k);
+  Py_CLEAR(p->__pyx_v_v);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_25_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_25_genexpr[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_25_genexpr++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_25_genexpr(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr *)o;
+  if (p->__pyx_outer_scope) {
+    e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e;
+  }
+  if (p->__pyx_v_k) {
+    e = (*v)(p->__pyx_v_k, a); if (e) return e;
+  }
+  if (p->__pyx_v_v) {
+    e = (*v)(p->__pyx_v_v, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_25_genexpr = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_25_genexpr", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_25_genexpr), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_25_genexpr, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_25_genexpr, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_25_genexpr, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_8genexpr4__pyx_v_ag);
+  Py_CLEAR(p->__pyx_v_agen);
+  Py_CLEAR(p->__pyx_v_closing_agens);
+  Py_CLEAR(p->__pyx_v_result);
+  Py_CLEAR(p->__pyx_v_results);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_shutdown_coro);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens *)o;
+  if (p->__pyx_8genexpr4__pyx_v_ag) {
+    e = (*v)(p->__pyx_8genexpr4__pyx_v_ag, a); if (e) return e;
+  }
+  if (p->__pyx_v_agen) {
+    e = (*v)(p->__pyx_v_agen, a); if (e) return e;
+  }
+  if (p->__pyx_v_closing_agens) {
+    e = (*v)(p->__pyx_v_closing_agens, a); if (e) return e;
+  }
+  if (p->__pyx_v_result) {
+    e = (*v)(p->__pyx_v_result, a); if (e) return e;
+  }
+  if (p->__pyx_v_results) {
+    e = (*v)(p->__pyx_v_results, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_shutdown_coro) {
+    e = (*v)(p->__pyx_v_shutdown_coro, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_26_shutdown_asyncgens", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_future);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_thread);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor *)o;
+  if (p->__pyx_v_future) {
+    e = (*v)(p->__pyx_v_future, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_thread) {
+    e = (*v)(p->__pyx_v_thread, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_27_shutdown_default_executor", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_28__start_handshake[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_28__start_handshake = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_28__start_handshake(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_28__start_handshake > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_28__start_handshake[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_28__start_handshake];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_28__start_handshake(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_self);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_28__start_handshake < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_28__start_handshake[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_28__start_handshake++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_28__start_handshake(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *)o;
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct_28__start_handshake(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake *)o;
+  tmp = ((PyObject*)p->__pyx_v_self);
+  p->__pyx_v_self = ((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_28__start_handshake = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_28__start_handshake", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_28__start_handshake), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_28__start_handshake, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_28__start_handshake, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct_28__start_handshake, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_28__start_handshake, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_29__start_shutdown[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_29__start_shutdown = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_29__start_shutdown(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_29__start_shutdown > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_29__start_shutdown[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_29__start_shutdown];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_29__start_shutdown(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_self);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_29__start_shutdown < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_29__start_shutdown[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_29__start_shutdown++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_29__start_shutdown(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *)o;
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct_29__start_shutdown(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown *)o;
+  tmp = ((PyObject*)p->__pyx_v_self);
+  p->__pyx_v_self = ((struct __pyx_obj_6uvloop_4loop_SSLProtocol *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_29__start_shutdown = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_29__start_shutdown", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_29__start_shutdown), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_29__start_shutdown, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_29__start_shutdown, /*tp_traverse*/
+  __pyx_tp_clear_6uvloop_4loop___pyx_scope_struct_29__start_shutdown, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_29__start_shutdown, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_30___aenter__[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_30___aenter__ = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_30___aenter__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_30___aenter__ > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_30___aenter__[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_30___aenter__];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_30___aenter__(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_self);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_30___aenter__ < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_30___aenter__[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_30___aenter__++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_30___aenter__(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__ *)o;
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_30___aenter__ = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_30___aenter__", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_30___aenter__), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_30___aenter__, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_30___aenter__, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_30___aenter__, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_31___aexit__[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_31___aexit__ = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_31___aexit__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_31___aexit__ > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_31___aexit__[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_31___aexit__];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_31___aexit__(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_exc);
+  Py_CLEAR(p->__pyx_v_self);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_31___aexit__ < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_31___aexit__[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_31___aexit__++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_31___aexit__(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__ *)o;
+  if (p->__pyx_v_exc) {
+    e = (*v)(p->__pyx_v_exc, a); if (e) return e;
+  }
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_31___aexit__ = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_31___aexit__", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_31___aexit__), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_31___aexit__, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_31___aexit__, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_31___aexit__, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_32_wait_closed[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_32_wait_closed = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_32_wait_closed(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_32_wait_closed > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_32_wait_closed[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_32_wait_closed];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_32_wait_closed(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_v_waiter);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_32_wait_closed < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_32_wait_closed[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_32_wait_closed++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_32_wait_closed(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed *)o;
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_v_waiter) {
+    e = (*v)(p->__pyx_v_waiter, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_32_wait_closed = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_32_wait_closed", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_32_wait_closed), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_32_wait_closed, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_32_wait_closed, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_32_wait_closed, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_33_start_serving[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_33_start_serving = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_33_start_serving(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_33_start_serving > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_33_start_serving[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_33_start_serving];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_33_start_serving(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_self);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_33_start_serving < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_33_start_serving[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_33_start_serving++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_33_start_serving(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving *)o;
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_33_start_serving = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_33_start_serving", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_33_start_serving), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_33_start_serving, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_33_start_serving, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_33_start_serving, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_34_serve_forever[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_34_serve_forever = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_34_serve_forever(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_34_serve_forever > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_34_serve_forever[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_34_serve_forever];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_34_serve_forever(PyObject *o) {
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever *)o;
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_v_self);
+  Py_CLEAR(p->__pyx_t_0);
+  Py_CLEAR(p->__pyx_t_1);
+  Py_CLEAR(p->__pyx_t_2);
+  Py_CLEAR(p->__pyx_t_3);
+  Py_CLEAR(p->__pyx_t_4);
+  Py_CLEAR(p->__pyx_t_5);
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_34_serve_forever < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_34_serve_forever[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_34_serve_forever++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static int __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_34_serve_forever(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever *p = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever *)o;
+  if (p->__pyx_v_self) {
+    e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e;
+  }
+  if (p->__pyx_t_0) {
+    e = (*v)(p->__pyx_t_0, a); if (e) return e;
+  }
+  if (p->__pyx_t_1) {
+    e = (*v)(p->__pyx_t_1, a); if (e) return e;
+  }
+  if (p->__pyx_t_2) {
+    e = (*v)(p->__pyx_t_2, a); if (e) return e;
+  }
+  if (p->__pyx_t_3) {
+    e = (*v)(p->__pyx_t_3, a); if (e) return e;
+  }
+  if (p->__pyx_t_4) {
+    e = (*v)(p->__pyx_t_4, a); if (e) return e;
+  }
+  if (p->__pyx_t_5) {
+    e = (*v)(p->__pyx_t_5, a); if (e) return e;
+  }
+  return 0;
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_34_serve_forever = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_34_serve_forever", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_34_serve_forever), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_34_serve_forever, /*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_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_6uvloop_4loop___pyx_scope_struct_34_serve_forever, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_34_serve_forever, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 *__pyx_freelist_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1[8];
+static int __pyx_freecount_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 = 0;
+
+static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1)))) {
+    o = (PyObject*)__pyx_freelist_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1[--__pyx_freecount_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1];
+    memset(o, 0, sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1));
+    (void) PyObject_INIT(o, t);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1(PyObject *o) {
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1)))) {
+    __pyx_freelist_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1[__pyx_freecount_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1++] = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static PyTypeObject __pyx_type_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct_35__test_coroutine_1", /*tp_name*/
+  sizeof(struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1, /*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, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py *__pyx_freelist___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py[8];
+static int __pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py = 0;
+
+static PyObject *__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py)))) {
+    o = (PyObject*)__pyx_freelist___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py[--__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py];
+    memset(o, 0, sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py));
+    (void) PyObject_INIT(o, t);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py(PyObject *o) {
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py)))) {
+    __pyx_freelist___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py[__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py++] = ((struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static PyTypeObject __pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "uvloop.loop.__pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py", /*tp_name*/
+  sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py, /*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, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*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___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py, /*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
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #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_loop(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_loop},
+  {0, NULL}
+};
+#endif
+
+static struct PyModuleDef __pyx_moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "loop",
+    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
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+    #define CYTHON_SMALL_CODE __attribute__((cold))
+#else
+    #define CYTHON_SMALL_CODE
+#endif
+#endif
+
+static __Pyx_StringTabEntry __pyx_string_tab[] = {
+  {&__pyx_kp_b_1, __pyx_k_1, sizeof(__pyx_k_1), 0, 0, 0, 0},
+  {&__pyx_kp_u_18_7_7_7, __pyx_k_18_7_7_7, sizeof(__pyx_k_18_7_7_7), 0, 1, 0, 0},
+  {&__pyx_kp_u_AF_INET6_address_must_be_tuple, __pyx_k_AF_INET6_address_must_be_tuple, sizeof(__pyx_k_AF_INET6_address_must_be_tuple), 0, 1, 0, 0},
+  {&__pyx_kp_u_AF_INET6_must_be_a_tuple_of_2_4, __pyx_k_AF_INET6_must_be_a_tuple_of_2_4, sizeof(__pyx_k_AF_INET6_must_be_a_tuple_of_2_4), 0, 1, 0, 0},
+  {&__pyx_kp_u_AF_INET_address_must_be_tuple, __pyx_k_AF_INET_address_must_be_tuple, sizeof(__pyx_k_AF_INET_address_must_be_tuple), 0, 1, 0, 0},
+  {&__pyx_kp_u_AF_INET_address_must_be_tuple_of, __pyx_k_AF_INET_address_must_be_tuple_of, sizeof(__pyx_k_AF_INET_address_must_be_tuple_of), 0, 1, 0, 0},
+  {&__pyx_kp_u_AF_UNIX_address_must_be_a_str_or, __pyx_k_AF_UNIX_address_must_be_a_str_or, sizeof(__pyx_k_AF_UNIX_address_must_be_a_str_or), 0, 1, 0, 0},
+  {&__pyx_kp_u_AF_UNSPEC_in_DNS_results, __pyx_k_AF_UNSPEC_in_DNS_results, sizeof(__pyx_k_AF_UNSPEC_in_DNS_results), 0, 1, 0, 0},
+  {&__pyx_kp_u_A_Stream_Socket_was_expected_got, __pyx_k_A_Stream_Socket_was_expected_got, sizeof(__pyx_k_A_Stream_Socket_was_expected_got), 0, 1, 0, 0},
+  {&__pyx_kp_u_A_UDP_Socket_was_expected_got_r, __pyx_k_A_UDP_Socket_was_expected_got_r, sizeof(__pyx_k_A_UDP_Socket_was_expected_got_r), 0, 1, 0, 0},
+  {&__pyx_kp_u_A_UNIX_Domain_Stream_Socket_was, __pyx_k_A_UNIX_Domain_Stream_Socket_was, sizeof(__pyx_k_A_UNIX_Domain_Stream_Socket_was), 0, 1, 0, 0},
+  {&__pyx_kp_u_A_callable_object_or_None_is_exp, __pyx_k_A_callable_object_or_None_is_exp, sizeof(__pyx_k_A_callable_object_or_None_is_exp), 0, 1, 0, 0},
+  {&__pyx_n_s_AbstractChildWatcher, __pyx_k_AbstractChildWatcher, sizeof(__pyx_k_AbstractChildWatcher), 0, 0, 1, 1},
+  {&__pyx_n_s_AddrInfo, __pyx_k_AddrInfo, sizeof(__pyx_k_AddrInfo), 0, 0, 1, 1},
+  {&__pyx_n_s_AddrInfoRequest, __pyx_k_AddrInfoRequest, sizeof(__pyx_k_AddrInfoRequest), 0, 0, 1, 1},
+  {&__pyx_kp_u_AddrInfoRequest_callback_called, __pyx_k_AddrInfoRequest_callback_called, sizeof(__pyx_k_AddrInfoRequest_callback_called), 0, 1, 0, 0},
+  {&__pyx_kp_u_AddrInfo_data_is_NULL, __pyx_k_AddrInfo_data_is_NULL, sizeof(__pyx_k_AddrInfo_data_is_NULL), 0, 1, 0, 0},
+  {&__pyx_n_s_AddressFamily, __pyx_k_AddressFamily, sizeof(__pyx_k_AddressFamily), 0, 0, 1, 1},
+  {&__pyx_kp_u_Address_r_is_already_in_use, __pyx_k_Address_r_is_already_in_use, sizeof(__pyx_k_Address_r_is_already_in_use), 0, 1, 0, 0},
+  {&__pyx_n_s_AttributeError, __pyx_k_AttributeError, sizeof(__pyx_k_AttributeError), 0, 0, 1, 1},
+  {&__pyx_kp_u_Bad_exception_data_from_child_r, __pyx_k_Bad_exception_data_from_child_r, sizeof(__pyx_k_Bad_exception_data_from_child_r), 0, 1, 0, 0},
+  {&__pyx_n_s_BaseException, __pyx_k_BaseException, sizeof(__pyx_k_BaseException), 0, 0, 1, 1},
+  {&__pyx_n_s_BaseProtocol, __pyx_k_BaseProtocol, sizeof(__pyx_k_BaseProtocol), 0, 0, 1, 1},
+  {&__pyx_n_s_BlockingIOError, __pyx_k_BlockingIOError, sizeof(__pyx_k_BlockingIOError), 0, 0, 1, 1},
+  {&__pyx_n_s_BrokenPipeError, __pyx_k_BrokenPipeError, sizeof(__pyx_k_BrokenPipeError), 0, 0, 1, 1},
+  {&__pyx_kp_u_Callback_handles_8, __pyx_k_Callback_handles_8, sizeof(__pyx_k_Callback_handles_8), 0, 1, 0, 0},
+  {&__pyx_n_s_CancelledError, __pyx_k_CancelledError, sizeof(__pyx_k_CancelledError), 0, 0, 1, 1},
+  {&__pyx_kp_u_Cannot_call_write_after_write_eo, __pyx_k_Cannot_call_write_after_write_eo, sizeof(__pyx_k_Cannot_call_write_after_write_eo), 0, 1, 0, 0},
+  {&__pyx_kp_u_Cannot_call_writelines_after_wri, __pyx_k_Cannot_call_writelines_after_wri, sizeof(__pyx_k_Cannot_call_writelines_after_wri), 0, 1, 0, 0},
+  {&__pyx_kp_u_Cannot_close_a_running_event_loo, __pyx_k_Cannot_close_a_running_event_loo, sizeof(__pyx_k_Cannot_close_a_running_event_loo), 0, 1, 0, 0},
+  {&__pyx_kp_u_Cannot_run_the_event_loop_while, __pyx_k_Cannot_run_the_event_loop_while, sizeof(__pyx_k_Cannot_run_the_event_loop_while), 0, 1, 0, 0},
+  {&__pyx_kp_u_Cannot_serialize_socket_object, __pyx_k_Cannot_serialize_socket_object, sizeof(__pyx_k_Cannot_serialize_socket_object), 0, 1, 0, 0},
+  {&__pyx_n_s_CertificateError, __pyx_k_CertificateError, sizeof(__pyx_k_CertificateError), 0, 0, 1, 1},
+  {&__pyx_kp_u_Connect_call_failed, __pyx_k_Connect_call_failed, sizeof(__pyx_k_Connect_call_failed), 0, 1, 0, 0},
+  {&__pyx_n_s_ConnectionAbortedError, __pyx_k_ConnectionAbortedError, sizeof(__pyx_k_ConnectionAbortedError), 0, 0, 1, 1},
+  {&__pyx_n_s_ConnectionRefusedError, __pyx_k_ConnectionRefusedError, sizeof(__pyx_k_ConnectionRefusedError), 0, 0, 1, 1},
+  {&__pyx_n_s_ConnectionResetError, __pyx_k_ConnectionResetError, sizeof(__pyx_k_ConnectionResetError), 0, 0, 1, 1},
+  {&__pyx_n_s_Counter, __pyx_k_Counter, sizeof(__pyx_k_Counter), 0, 0, 1, 1},
+  {&__pyx_kp_u_Creating__SSLProtocolTransport_t, __pyx_k_Creating__SSLProtocolTransport_t, sizeof(__pyx_k_Creating__SSLProtocolTransport_t), 0, 1, 0, 0},
+  {&__pyx_n_s_DEVNULL, __pyx_k_DEVNULL, sizeof(__pyx_k_DEVNULL), 0, 0, 1, 1},
+  {&__pyx_n_s_DeprecationWarning, __pyx_k_DeprecationWarning, sizeof(__pyx_k_DeprecationWarning), 0, 0, 1, 1},
+  {&__pyx_n_u_EAI_ADDRFAMILY, __pyx_k_EAI_ADDRFAMILY, sizeof(__pyx_k_EAI_ADDRFAMILY), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_AGAIN, __pyx_k_EAI_AGAIN, sizeof(__pyx_k_EAI_AGAIN), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_BADFLAGS, __pyx_k_EAI_BADFLAGS, sizeof(__pyx_k_EAI_BADFLAGS), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_BADHINTS, __pyx_k_EAI_BADHINTS, sizeof(__pyx_k_EAI_BADHINTS), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_CANCELED, __pyx_k_EAI_CANCELED, sizeof(__pyx_k_EAI_CANCELED), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_FAIL, __pyx_k_EAI_FAIL, sizeof(__pyx_k_EAI_FAIL), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_FAMILY, __pyx_k_EAI_FAMILY, sizeof(__pyx_k_EAI_FAMILY), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_MEMORY, __pyx_k_EAI_MEMORY, sizeof(__pyx_k_EAI_MEMORY), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_NODATA, __pyx_k_EAI_NODATA, sizeof(__pyx_k_EAI_NODATA), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_NONAME, __pyx_k_EAI_NONAME, sizeof(__pyx_k_EAI_NONAME), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_OVERFLOW, __pyx_k_EAI_OVERFLOW, sizeof(__pyx_k_EAI_OVERFLOW), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_PROTOCOL, __pyx_k_EAI_PROTOCOL, sizeof(__pyx_k_EAI_PROTOCOL), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_SERVICE, __pyx_k_EAI_SERVICE, sizeof(__pyx_k_EAI_SERVICE), 0, 1, 0, 1},
+  {&__pyx_n_u_EAI_SOCKTYPE, __pyx_k_EAI_SOCKTYPE, sizeof(__pyx_k_EAI_SOCKTYPE), 0, 1, 0, 1},
+  {&__pyx_kp_u_Error_calling_eof_received, __pyx_k_Error_calling_eof_received, sizeof(__pyx_k_Error_calling_eof_received), 0, 1, 0, 0},
+  {&__pyx_kp_u_Error_occurred_during_shutdown, __pyx_k_Error_occurred_during_shutdown, sizeof(__pyx_k_Error_occurred_during_shutdown), 0, 1, 0, 0},
+  {&__pyx_kp_u_Errors_logged, __pyx_k_Errors_logged, sizeof(__pyx_k_Errors_logged), 0, 1, 0, 0},
+  {&__pyx_kp_u_Event_loop_is_closed, __pyx_k_Event_loop_is_closed, sizeof(__pyx_k_Event_loop_is_closed), 0, 1, 0, 0},
+  {&__pyx_kp_u_Event_loop_stopped_before_Future, __pyx_k_Event_loop_stopped_before_Future, sizeof(__pyx_k_Event_loop_stopped_before_Future), 0, 1, 0, 0},
+  {&__pyx_kp_u_Exception_in___repr___r_value_ty, __pyx_k_Exception_in___repr___r_value_ty, sizeof(__pyx_k_Exception_in___repr___r_value_ty), 0, 1, 0, 0},
+  {&__pyx_kp_u_Exception_in_callback, __pyx_k_Exception_in_callback, sizeof(__pyx_k_Exception_in_callback), 0, 1, 0, 0},
+  {&__pyx_kp_u_Exception_in_default_exception_h, __pyx_k_Exception_in_default_exception_h, sizeof(__pyx_k_Exception_in_default_exception_h), 0, 1, 0, 0},
+  {&__pyx_kp_u_Exception_in_default_exception_h_2, __pyx_k_Exception_in_default_exception_h_2, sizeof(__pyx_k_Exception_in_default_exception_h_2), 0, 1, 0, 0},
+  {&__pyx_kp_u_Exception_occurred_in_preexec_fn, __pyx_k_Exception_occurred_in_preexec_fn, sizeof(__pyx_k_Exception_occurred_in_preexec_fn), 0, 1, 0, 0},
+  {&__pyx_kp_u_Executing_r_took_3f_seconds, __pyx_k_Executing_r_took_3f_seconds, sizeof(__pyx_k_Executing_r_took_3f_seconds), 0, 1, 0, 0},
+  {&__pyx_kp_u_Executing_s_took_3f_seconds, __pyx_k_Executing_s_took_3f_seconds, sizeof(__pyx_k_Executing_s_took_3f_seconds), 0, 1, 0, 0},
+  {&__pyx_kp_u_Executor_shutdown_has_been_calle, __pyx_k_Executor_shutdown_has_been_calle, sizeof(__pyx_k_Executor_shutdown_has_been_calle), 0, 1, 0, 0},
+  {&__pyx_kp_u_Fatal_error_on_SSL_protocol, __pyx_k_Fatal_error_on_SSL_protocol, sizeof(__pyx_k_Fatal_error_on_SSL_protocol), 0, 1, 0, 0},
+  {&__pyx_kp_u_Fatal_error_on_server, __pyx_k_Fatal_error_on_server, sizeof(__pyx_k_Fatal_error_on_server), 0, 1, 0, 0},
+  {&__pyx_kp_u_Fatal_error_on_transport, __pyx_k_Fatal_error_on_transport, sizeof(__pyx_k_Fatal_error_on_transport), 0, 1, 0, 0},
+  {&__pyx_kp_u_Fatal_error_on_transport_2, __pyx_k_Fatal_error_on_transport_2, sizeof(__pyx_k_Fatal_error_on_transport_2), 0, 1, 0, 0},
+  {&__pyx_kp_u_Fatal_write_error_on_datagram_tr, __pyx_k_Fatal_write_error_on_datagram_tr, sizeof(__pyx_k_Fatal_write_error_on_datagram_tr), 0, 1, 0, 0},
+  {&__pyx_n_s_FileExistsError, __pyx_k_FileExistsError, sizeof(__pyx_k_FileExistsError), 0, 0, 1, 1},
+  {&__pyx_n_s_FileNotFoundError, __pyx_k_FileNotFoundError, sizeof(__pyx_k_FileNotFoundError), 0, 0, 1, 1},
+  {&__pyx_kp_u_File_descriptor_r_is_used_by_tra, __pyx_k_File_descriptor_r_is_used_by_tra, sizeof(__pyx_k_File_descriptor_r_is_used_by_tra), 0, 1, 0, 0},
+  {&__pyx_n_s_FlowControlMixin, __pyx_k_FlowControlMixin, sizeof(__pyx_k_FlowControlMixin), 0, 0, 1, 1},
+  {&__pyx_n_s_Future, __pyx_k_Future, sizeof(__pyx_k_Future), 0, 0, 1, 1},
+  {&__pyx_n_s_Handle, __pyx_k_Handle, sizeof(__pyx_k_Handle), 0, 0, 1, 1},
+  {&__pyx_kp_u_Handle_loop_is_None_in_Handle, __pyx_k_Handle_loop_is_None_in_Handle, sizeof(__pyx_k_Handle_loop_is_None_in_Handle), 0, 1, 0, 0},
+  {&__pyx_n_u_IPV6_V6ONLY, __pyx_k_IPV6_V6ONLY, sizeof(__pyx_k_IPV6_V6ONLY), 0, 1, 0, 1},
+  {&__pyx_kp_u_IPv4_sockaddr_must_be_2_tuple, __pyx_k_IPv4_sockaddr_must_be_2_tuple, sizeof(__pyx_k_IPv4_sockaddr_must_be_2_tuple), 0, 1, 0, 0},
+  {&__pyx_kp_s_Incompatible_checksums_s_vs_0x53, __pyx_k_Incompatible_checksums_s_vs_0x53, sizeof(__pyx_k_Incompatible_checksums_s_vs_0x53), 0, 0, 1, 0},
+  {&__pyx_kp_s_Incompatible_checksums_s_vs_0x88, __pyx_k_Incompatible_checksums_s_vs_0x88, sizeof(__pyx_k_Incompatible_checksums_s_vs_0x88), 0, 0, 1, 0},
+  {&__pyx_n_s_InterruptedError, __pyx_k_InterruptedError, sizeof(__pyx_k_InterruptedError), 0, 0, 1, 1},
+  {&__pyx_n_s_InvalidStateError, __pyx_k_InvalidStateError, sizeof(__pyx_k_InvalidStateError), 0, 0, 1, 1},
+  {&__pyx_kp_u_Invalid_address_must_be_None_or, __pyx_k_Invalid_address_must_be_None_or, sizeof(__pyx_k_Invalid_address_must_be_None_or), 0, 1, 0, 0},
+  {&__pyx_kp_u_Invalid_file_descriptor, __pyx_k_Invalid_file_descriptor, sizeof(__pyx_k_Invalid_file_descriptor), 0, 1, 0, 0},
+  {&__pyx_kp_u_Invalid_file_object_r, __pyx_k_Invalid_file_object_r, sizeof(__pyx_k_Invalid_file_object_r), 0, 1, 0, 0},
+  {&__pyx_n_s_IsADirectoryError, __pyx_k_IsADirectoryError, sizeof(__pyx_k_IsADirectoryError), 0, 0, 1, 1},
+  {&__pyx_n_s_Iterable, __pyx_k_Iterable, sizeof(__pyx_k_Iterable), 0, 0, 1, 1},
+  {&__pyx_n_s_KeyError, __pyx_k_KeyError, sizeof(__pyx_k_KeyError), 0, 0, 1, 1},
+  {&__pyx_n_s_KeyboardInterrupt, __pyx_k_KeyboardInterrupt, sizeof(__pyx_k_KeyboardInterrupt), 0, 0, 1, 1},
+  {&__pyx_kp_u_Listen_errors, __pyx_k_Listen_errors, sizeof(__pyx_k_Listen_errors), 0, 1, 0, 0},
+  {&__pyx_n_s_Loop, __pyx_k_Loop, sizeof(__pyx_k_Loop), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop___get___locals_lambda, __pyx_k_Loop___get___locals_lambda, sizeof(__pyx_k_Loop___get___locals_lambda), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop___subprocess_run, __pyx_k_Loop___subprocess_run, sizeof(__pyx_k_Loop___subprocess_run), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop__getaddrinfo_locals_callbac, __pyx_k_Loop__getaddrinfo_locals_callbac, sizeof(__pyx_k_Loop__getaddrinfo_locals_callbac), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop__getnameinfo_locals_callbac, __pyx_k_Loop__getnameinfo_locals_callbac, sizeof(__pyx_k_Loop__getnameinfo_locals_callbac), 0, 0, 1, 1},
+  {&__pyx_kp_u_Loop__read_from_self, __pyx_k_Loop__read_from_self, sizeof(__pyx_k_Loop__read_from_self), 0, 1, 0, 0},
+  {&__pyx_kp_u_Loop__sock_accept, __pyx_k_Loop__sock_accept, sizeof(__pyx_k_Loop__sock_accept), 0, 1, 0, 0},
+  {&__pyx_kp_u_Loop__sock_connect, __pyx_k_Loop__sock_connect, sizeof(__pyx_k_Loop__sock_connect), 0, 1, 0, 0},
+  {&__pyx_kp_u_Loop__sock_recv, __pyx_k_Loop__sock_recv, sizeof(__pyx_k_Loop__sock_recv), 0, 1, 0, 0},
+  {&__pyx_kp_u_Loop__sock_recv_into, __pyx_k_Loop__sock_recv_into, sizeof(__pyx_k_Loop__sock_recv_into), 0, 1, 0, 0},
+  {&__pyx_kp_u_Loop__sock_sendall, __pyx_k_Loop__sock_sendall, sizeof(__pyx_k_Loop__sock_sendall), 0, 1, 0, 0},
+  {&__pyx_kp_u_Loop__stop, __pyx_k_Loop__stop, sizeof(__pyx_k_Loop__stop), 0, 1, 0, 0},
+  {&__pyx_n_s_Loop_connect_accepted_socket, __pyx_k_Loop_connect_accepted_socket, sizeof(__pyx_k_Loop_connect_accepted_socket), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_connect_read_pipe, __pyx_k_Loop_connect_read_pipe, sizeof(__pyx_k_Loop_connect_read_pipe), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_connect_write_pipe, __pyx_k_Loop_connect_write_pipe, sizeof(__pyx_k_Loop_connect_write_pipe), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_create_connection, __pyx_k_Loop_create_connection, sizeof(__pyx_k_Loop_create_connection), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_create_datagram_endpoint, __pyx_k_Loop_create_datagram_endpoint, sizeof(__pyx_k_Loop_create_datagram_endpoint), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_create_server, __pyx_k_Loop_create_server, sizeof(__pyx_k_Loop_create_server), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_create_unix_connection, __pyx_k_Loop_create_unix_connection, sizeof(__pyx_k_Loop_create_unix_connection), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_create_unix_server, __pyx_k_Loop_create_unix_server, sizeof(__pyx_k_Loop_create_unix_server), 0, 0, 1, 1},
+  {&__pyx_kp_u_Loop_debug_info, __pyx_k_Loop_debug_info, sizeof(__pyx_k_Loop_debug_info), 0, 1, 0, 0},
+  {&__pyx_n_s_Loop_getaddrinfo, __pyx_k_Loop_getaddrinfo, sizeof(__pyx_k_Loop_getaddrinfo), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_getnameinfo, __pyx_k_Loop_getnameinfo, sizeof(__pyx_k_Loop_getnameinfo), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_shutdown_asyncgens, __pyx_k_Loop_shutdown_asyncgens, sizeof(__pyx_k_Loop_shutdown_asyncgens), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_shutdown_default_executor, __pyx_k_Loop_shutdown_default_executor, sizeof(__pyx_k_Loop_shutdown_default_executor), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_sock_accept, __pyx_k_Loop_sock_accept, sizeof(__pyx_k_Loop_sock_accept), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_sock_connect, __pyx_k_Loop_sock_connect, sizeof(__pyx_k_Loop_sock_connect), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_sock_recv, __pyx_k_Loop_sock_recv, sizeof(__pyx_k_Loop_sock_recv), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_sock_recv_into, __pyx_k_Loop_sock_recv_into, sizeof(__pyx_k_Loop_sock_recv_into), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_sock_sendall, __pyx_k_Loop_sock_sendall, sizeof(__pyx_k_Loop_sock_sendall), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_start_tls, __pyx_k_Loop_start_tls, sizeof(__pyx_k_Loop_start_tls), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_subprocess_exec, __pyx_k_Loop_subprocess_exec, sizeof(__pyx_k_Loop_subprocess_exec), 0, 0, 1, 1},
+  {&__pyx_n_s_Loop_subprocess_shell, __pyx_k_Loop_subprocess_shell, sizeof(__pyx_k_Loop_subprocess_shell), 0, 0, 1, 1},
+  {&__pyx_kp_u_Loop_time, __pyx_k_Loop_time, sizeof(__pyx_k_Loop_time), 0, 1, 0, 0},
+  {&__pyx_n_s_LruCache, __pyx_k_LruCache, sizeof(__pyx_k_LruCache), 0, 0, 1, 1},
+  {&__pyx_n_s_MemoryBIO, __pyx_k_MemoryBIO, sizeof(__pyx_k_MemoryBIO), 0, 0, 1, 1},
+  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
+  {&__pyx_kp_u_Multiple_exceptions, __pyx_k_Multiple_exceptions, sizeof(__pyx_k_Multiple_exceptions), 0, 1, 0, 0},
+  {&__pyx_n_s_NSIG, __pyx_k_NSIG, sizeof(__pyx_k_NSIG), 0, 0, 1, 1},
+  {&__pyx_n_s_NameInfoRequest, __pyx_k_NameInfoRequest, sizeof(__pyx_k_NameInfoRequest), 0, 0, 1, 1},
+  {&__pyx_kp_u_Neither_host_port_nor_sock_were, __pyx_k_Neither_host_port_nor_sock_were, sizeof(__pyx_k_Neither_host_port_nor_sock_were), 0, 1, 0, 0},
+  {&__pyx_kp_u_Non_thread_safe_operation_invoke, __pyx_k_Non_thread_safe_operation_invoke, sizeof(__pyx_k_Non_thread_safe_operation_invoke), 0, 1, 0, 0},
+  {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1},
+  {&__pyx_kp_u_Number_of_signals, __pyx_k_Number_of_signals, sizeof(__pyx_k_Number_of_signals), 0, 1, 0, 0},
+  {&__pyx_n_s_OSError, __pyx_k_OSError, sizeof(__pyx_k_OSError), 0, 0, 1, 1},
+  {&__pyx_n_s_O_RDWR, __pyx_k_O_RDWR, sizeof(__pyx_k_O_RDWR), 0, 0, 1, 1},
+  {&__pyx_kp_u_Object_created_at_most_recent_ca, __pyx_k_Object_created_at_most_recent_ca, sizeof(__pyx_k_Object_created_at_most_recent_ca), 0, 1, 0, 0},
+  {&__pyx_n_s_OrderedDict, __pyx_k_OrderedDict, sizeof(__pyx_k_OrderedDict), 0, 0, 1, 1},
+  {&__pyx_n_s_OverflowError, __pyx_k_OverflowError, sizeof(__pyx_k_OverflowError), 0, 0, 1, 1},
+  {&__pyx_n_s_PIPE, __pyx_k_PIPE, sizeof(__pyx_k_PIPE), 0, 0, 1, 1},
+  {&__pyx_n_u_PYTHONASYNCIODEBUG, __pyx_k_PYTHONASYNCIODEBUG, sizeof(__pyx_k_PYTHONASYNCIODEBUG), 0, 1, 0, 1},
+  {&__pyx_kp_u_Passing_reuse_address_True_is_no, __pyx_k_Passing_reuse_address_True_is_no, sizeof(__pyx_k_Passing_reuse_address_True_is_no), 0, 1, 0, 0},
+  {&__pyx_n_s_PermissionError, __pyx_k_PermissionError, sizeof(__pyx_k_PermissionError), 0, 0, 1, 1},
+  {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1},
+  {&__pyx_kp_s_Pickling_of_struct_members_such, __pyx_k_Pickling_of_struct_members_such, sizeof(__pyx_k_Pickling_of_struct_members_such), 0, 0, 1, 0},
+  {&__pyx_n_s_PipeConnectRequest, __pyx_k_PipeConnectRequest, sizeof(__pyx_k_PipeConnectRequest), 0, 0, 1, 1},
+  {&__pyx_kp_u_Polls_debug_info, __pyx_k_Polls_debug_info, sizeof(__pyx_k_Polls_debug_info), 0, 1, 0, 0},
+  {&__pyx_n_s_ProcessLookupError, __pyx_k_ProcessLookupError, sizeof(__pyx_k_ProcessLookupError), 0, 0, 1, 1},
+  {&__pyx_kp_u_Process_info, __pyx_k_Process_info, sizeof(__pyx_k_Process_info), 0, 1, 0, 0},
+  {&__pyx_kp_u_Process_memory, __pyx_k_Process_memory, sizeof(__pyx_k_Process_memory), 0, 1, 0, 0},
+  {&__pyx_n_s_Protocol, __pyx_k_Protocol, sizeof(__pyx_k_Protocol), 0, 0, 1, 1},
+  {&__pyx_n_s_PseudoSocket, __pyx_k_PseudoSocket, sizeof(__pyx_k_PseudoSocket), 0, 0, 1, 1},
+  {&__pyx_n_s_Pyx_CFunc_object____Loop____bi, __pyx_k_Pyx_CFunc_object____Loop____bi, sizeof(__pyx_k_Pyx_CFunc_object____Loop____bi), 0, 0, 1, 1},
+  {&__pyx_kp_u_Racing_with_another_loop_to_spaw, __pyx_k_Racing_with_another_loop_to_spaw, sizeof(__pyx_k_Racing_with_another_loop_to_spaw), 0, 1, 0, 0},
+  {&__pyx_n_s_ReadSubprocessPipeProto, __pyx_k_ReadSubprocessPipeProto, sizeof(__pyx_k_ReadSubprocessPipeProto), 0, 0, 1, 1},
+  {&__pyx_n_s_ReadSubprocessPipeProto_data_rec, __pyx_k_ReadSubprocessPipeProto_data_rec, sizeof(__pyx_k_ReadSubprocessPipeProto_data_rec), 0, 0, 1, 1},
+  {&__pyx_n_s_ReadUnixTransport, __pyx_k_ReadUnixTransport, sizeof(__pyx_k_ReadUnixTransport), 0, 0, 1, 1},
+  {&__pyx_kp_u_Read_EOF_failed_callbacks, __pyx_k_Read_EOF_failed_callbacks, sizeof(__pyx_k_Read_EOF_failed_callbacks), 0, 1, 0, 0},
+  {&__pyx_kp_u_Read_EOFs, __pyx_k_Read_EOFs, sizeof(__pyx_k_Read_EOFs), 0, 1, 0, 0},
+  {&__pyx_kp_u_Read_callbacks, __pyx_k_Read_callbacks, sizeof(__pyx_k_Read_callbacks), 0, 1, 0, 0},
+  {&__pyx_kp_u_Read_callbacks_failed, __pyx_k_Read_callbacks_failed, sizeof(__pyx_k_Read_callbacks_failed), 0, 1, 0, 0},
+  {&__pyx_kp_u_Read_errors, __pyx_k_Read_errors, sizeof(__pyx_k_Read_errors), 0, 1, 0, 0},
+  {&__pyx_kp_u_Read_events, __pyx_k_Read_events, sizeof(__pyx_k_Read_events), 0, 1, 0, 0},
+  {&__pyx_kp_u_Read_failed_callbacks, __pyx_k_Read_failed_callbacks, sizeof(__pyx_k_Read_failed_callbacks), 0, 1, 0, 0},
+  {&__pyx_n_s_ResourceWarning, __pyx_k_ResourceWarning, sizeof(__pyx_k_ResourceWarning), 0, 0, 1, 1},
+  {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
+  {&__pyx_n_s_RuntimeWarning, __pyx_k_RuntimeWarning, sizeof(__pyx_k_RuntimeWarning), 0, 0, 1, 1},
+  {&__pyx_n_s_SIG_DFL, __pyx_k_SIG_DFL, sizeof(__pyx_k_SIG_DFL), 0, 0, 1, 1},
+  {&__pyx_n_u_SOCK_NONBLOCK, __pyx_k_SOCK_NONBLOCK, sizeof(__pyx_k_SOCK_NONBLOCK), 0, 1, 0, 1},
+  {&__pyx_n_u_SO_BROADCAST, __pyx_k_SO_BROADCAST, sizeof(__pyx_k_SO_BROADCAST), 0, 1, 0, 1},
+  {&__pyx_n_u_SO_REUSEPORT, __pyx_k_SO_REUSEPORT, sizeof(__pyx_k_SO_REUSEPORT), 0, 1, 0, 1},
+  {&__pyx_n_s_SSLContext, __pyx_k_SSLContext, sizeof(__pyx_k_SSLContext), 0, 0, 1, 1},
+  {&__pyx_n_s_SSLError, __pyx_k_SSLError, sizeof(__pyx_k_SSLError), 0, 0, 1, 1},
+  {&__pyx_n_s_SSLProtocol, __pyx_k_SSLProtocol, sizeof(__pyx_k_SSLProtocol), 0, 0, 1, 1},
+  {&__pyx_n_s_SSLProtocolTransport, __pyx_k_SSLProtocolTransport, sizeof(__pyx_k_SSLProtocolTransport), 0, 0, 1, 1},
+  {&__pyx_kp_u_SSLProtocol__do_read, __pyx_k_SSLProtocol__do_read, sizeof(__pyx_k_SSLProtocol__do_read), 0, 1, 0, 0},
+  {&__pyx_n_s_SSLProtocol__start_handshake_loc, __pyx_k_SSLProtocol__start_handshake_loc, sizeof(__pyx_k_SSLProtocol__start_handshake_loc), 0, 0, 1, 1},
+  {&__pyx_n_s_SSLProtocol__start_shutdown_loca, __pyx_k_SSLProtocol__start_shutdown_loca, sizeof(__pyx_k_SSLProtocol__start_shutdown_loca), 0, 0, 1, 1},
+  {&__pyx_n_s_SSLSyscallError, __pyx_k_SSLSyscallError, sizeof(__pyx_k_SSLSyscallError), 0, 0, 1, 1},
+  {&__pyx_n_s_SSLWantReadError, __pyx_k_SSLWantReadError, sizeof(__pyx_k_SSLWantReadError), 0, 0, 1, 1},
+  {&__pyx_n_s_SSLZeroReturnError, __pyx_k_SSLZeroReturnError, sizeof(__pyx_k_SSLZeroReturnError), 0, 0, 1, 1},
+  {&__pyx_n_s_SSL_ERROR_SYSCALL, __pyx_k_SSL_ERROR_SYSCALL, sizeof(__pyx_k_SSL_ERROR_SYSCALL), 0, 0, 1, 1},
+  {&__pyx_n_s_SSL_ERROR_WANT_READ, __pyx_k_SSL_ERROR_WANT_READ, sizeof(__pyx_k_SSL_ERROR_WANT_READ), 0, 0, 1, 1},
+  {&__pyx_n_s_SSL_ERROR_WANT_WRITE, __pyx_k_SSL_ERROR_WANT_WRITE, sizeof(__pyx_k_SSL_ERROR_WANT_WRITE), 0, 0, 1, 1},
+  {&__pyx_kp_u_SSL_connection_is_closed, __pyx_k_SSL_connection_is_closed, sizeof(__pyx_k_SSL_connection_is_closed), 0, 1, 0, 0},
+  {&__pyx_kp_u_SSL_handshake_failed, __pyx_k_SSL_handshake_failed, sizeof(__pyx_k_SSL_handshake_failed), 0, 1, 0, 0},
+  {&__pyx_kp_u_SSL_handshake_failed_on_verifyin, __pyx_k_SSL_handshake_failed_on_verifyin, sizeof(__pyx_k_SSL_handshake_failed_on_verifyin), 0, 1, 0, 0},
+  {&__pyx_kp_u_SSL_handshake_is_taking_longer_t, __pyx_k_SSL_handshake_is_taking_longer_t, sizeof(__pyx_k_SSL_handshake_is_taking_longer_t), 0, 1, 0, 0},
+  {&__pyx_kp_u_SSL_shutdown_timed_out, __pyx_k_SSL_shutdown_timed_out, sizeof(__pyx_k_SSL_shutdown_timed_out), 0, 1, 0, 0},
+  {&__pyx_n_s_STDOUT, __pyx_k_STDOUT, sizeof(__pyx_k_STDOUT), 0, 0, 1, 1},
+  {&__pyx_n_s_S_ISSOCK, __pyx_k_S_ISSOCK, sizeof(__pyx_k_S_ISSOCK), 0, 0, 1, 1},
+  {&__pyx_n_s_Server, __pyx_k_Server, sizeof(__pyx_k_Server), 0, 0, 1, 1},
+  {&__pyx_n_s_Server___aenter, __pyx_k_Server___aenter, sizeof(__pyx_k_Server___aenter), 0, 0, 1, 1},
+  {&__pyx_n_s_Server___aexit, __pyx_k_Server___aexit, sizeof(__pyx_k_Server___aexit), 0, 0, 1, 1},
+  {&__pyx_n_s_Server_serve_forever, __pyx_k_Server_serve_forever, sizeof(__pyx_k_Server_serve_forever), 0, 0, 1, 1},
+  {&__pyx_kp_u_Server_side_SSL_needs_a_valid_SS, __pyx_k_Server_side_SSL_needs_a_valid_SS, sizeof(__pyx_k_Server_side_SSL_needs_a_valid_SS), 0, 1, 0, 0},
+  {&__pyx_n_s_Server_start_serving, __pyx_k_Server_start_serving, sizeof(__pyx_k_Server_start_serving), 0, 0, 1, 1},
+  {&__pyx_n_s_Server_wait_closed, __pyx_k_Server_wait_closed, sizeof(__pyx_k_Server_wait_closed), 0, 0, 1, 1},
+  {&__pyx_kp_u_Shutdown_errors, __pyx_k_Shutdown_errors, sizeof(__pyx_k_Shutdown_errors), 0, 1, 0, 0},
+  {&__pyx_n_s_SockAddrHolder, __pyx_k_SockAddrHolder, sizeof(__pyx_k_SockAddrHolder), 0, 0, 1, 1},
+  {&__pyx_kp_u_Sock_ops_successful_on_1st_try, __pyx_k_Sock_ops_successful_on_1st_try, sizeof(__pyx_k_Sock_ops_successful_on_1st_try), 0, 1, 0, 0},
+  {&__pyx_n_s_SocketKind, __pyx_k_SocketKind, sizeof(__pyx_k_SocketKind), 0, 0, 1, 1},
+  {&__pyx_kp_u_Socket_try_writes, __pyx_k_Socket_try_writes, sizeof(__pyx_k_Socket_try_writes), 0, 1, 0, 0},
+  {&__pyx_n_s_StackSummary, __pyx_k_StackSummary, sizeof(__pyx_k_StackSummary), 0, 0, 1, 1},
+  {&__pyx_n_s_StreamWriteContext, __pyx_k_StreamWriteContext, sizeof(__pyx_k_StreamWriteContext), 0, 0, 1, 1},
+  {&__pyx_kp_u_StreamWriteContext_close_py_buf, __pyx_k_StreamWriteContext_close_py_buf, sizeof(__pyx_k_StreamWriteContext_close_py_buf), 0, 1, 0, 0},
+  {&__pyx_kp_u_StreamWriteContext_close_uv_buf, __pyx_k_StreamWriteContext_close_uv_buf, sizeof(__pyx_k_StreamWriteContext_close_uv_buf), 0, 1, 0, 0},
+  {&__pyx_kp_u_Streams_debug_info, __pyx_k_Streams_debug_info, sizeof(__pyx_k_Streams_debug_info), 0, 1, 0, 0},
+  {&__pyx_n_s_SubprocessError, __pyx_k_SubprocessError, sizeof(__pyx_k_SubprocessError), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketReaderFuture, __pyx_k_SyncSocketReaderFuture, sizeof(__pyx_k_SyncSocketReaderFuture), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketReaderFuture___init, __pyx_k_SyncSocketReaderFuture___init, sizeof(__pyx_k_SyncSocketReaderFuture___init), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketReaderFuture___remove, __pyx_k_SyncSocketReaderFuture___remove, sizeof(__pyx_k_SyncSocketReaderFuture___remove), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketReaderFuture__loop, __pyx_k_SyncSocketReaderFuture__loop, sizeof(__pyx_k_SyncSocketReaderFuture__loop), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketReaderFuture__remove, __pyx_k_SyncSocketReaderFuture__remove, sizeof(__pyx_k_SyncSocketReaderFuture__remove), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketReaderFuture__sock, __pyx_k_SyncSocketReaderFuture__sock, sizeof(__pyx_k_SyncSocketReaderFuture__sock), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketReaderFuture_cancel, __pyx_k_SyncSocketReaderFuture_cancel, sizeof(__pyx_k_SyncSocketReaderFuture_cancel), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketWriterFuture, __pyx_k_SyncSocketWriterFuture, sizeof(__pyx_k_SyncSocketWriterFuture), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketWriterFuture___init, __pyx_k_SyncSocketWriterFuture___init, sizeof(__pyx_k_SyncSocketWriterFuture___init), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketWriterFuture___remove, __pyx_k_SyncSocketWriterFuture___remove, sizeof(__pyx_k_SyncSocketWriterFuture___remove), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketWriterFuture__loop, __pyx_k_SyncSocketWriterFuture__loop, sizeof(__pyx_k_SyncSocketWriterFuture__loop), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketWriterFuture__remove, __pyx_k_SyncSocketWriterFuture__remove, sizeof(__pyx_k_SyncSocketWriterFuture__remove), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketWriterFuture__sock, __pyx_k_SyncSocketWriterFuture__sock, sizeof(__pyx_k_SyncSocketWriterFuture__sock), 0, 0, 1, 1},
+  {&__pyx_n_s_SyncSocketWriterFuture_cancel, __pyx_k_SyncSocketWriterFuture_cancel, sizeof(__pyx_k_SyncSocketWriterFuture_cancel), 0, 0, 1, 1},
+  {&__pyx_n_s_SystemExit, __pyx_k_SystemExit, sizeof(__pyx_k_SystemExit), 0, 0, 1, 1},
+  {&__pyx_n_s_TCPConnectRequest, __pyx_k_TCPConnectRequest, sizeof(__pyx_k_TCPConnectRequest), 0, 0, 1, 1},
+  {&__pyx_n_s_TCPServer, __pyx_k_TCPServer, sizeof(__pyx_k_TCPServer), 0, 0, 1, 1},
+  {&__pyx_n_s_TCPTransport, __pyx_k_TCPTransport, sizeof(__pyx_k_TCPTransport), 0, 0, 1, 1},
+  {&__pyx_n_s_Task, __pyx_k_Task, sizeof(__pyx_k_Task), 0, 0, 1, 1},
+  {&__pyx_kp_u_The_reuse_address_parameter_has, __pyx_k_The_reuse_address_parameter_has, sizeof(__pyx_k_The_reuse_address_parameter_has), 0, 1, 0, 0},
+  {&__pyx_n_s_Thread, __pyx_k_Thread, sizeof(__pyx_k_Thread), 0, 0, 1, 1},
+  {&__pyx_n_s_ThreadPoolExecutor, __pyx_k_ThreadPoolExecutor, sizeof(__pyx_k_ThreadPoolExecutor), 0, 0, 1, 1},
+  {&__pyx_n_s_TimeoutError, __pyx_k_TimeoutError, sizeof(__pyx_k_TimeoutError), 0, 0, 1, 1},
+  {&__pyx_n_s_TimerHandle, __pyx_k_TimerHandle, sizeof(__pyx_k_TimerHandle), 0, 0, 1, 1},
+  {&__pyx_kp_u_Timer_handles_8, __pyx_k_Timer_handles_8, sizeof(__pyx_k_Timer_handles_8), 0, 1, 0, 0},
+  {&__pyx_n_s_Transport, __pyx_k_Transport, sizeof(__pyx_k_Transport), 0, 0, 1, 1},
+  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+  {&__pyx_n_s_UDPSendContext, __pyx_k_UDPSendContext, sizeof(__pyx_k_UDPSendContext), 0, 0, 1, 1},
+  {&__pyx_n_s_UDPTransport, __pyx_k_UDPTransport, sizeof(__pyx_k_UDPTransport), 0, 0, 1, 1},
+  {&__pyx_kp_u_UDPTransport_family_is_undefined, __pyx_k_UDPTransport_family_is_undefined, sizeof(__pyx_k_UDPTransport_family_is_undefined), 0, 1, 0, 0},
+  {&__pyx_kp_u_UDPTransport_family_is_undefined_2, __pyx_k_UDPTransport_family_is_undefined_2, sizeof(__pyx_k_UDPTransport_family_is_undefined_2), 0, 1, 0, 0},
+  {&__pyx_n_s_UVAsync, __pyx_k_UVAsync, sizeof(__pyx_k_UVAsync), 0, 0, 1, 1},
+  {&__pyx_n_s_UVBaseTransport, __pyx_k_UVBaseTransport, sizeof(__pyx_k_UVBaseTransport), 0, 0, 1, 1},
+  {&__pyx_n_s_UVCheck, __pyx_k_UVCheck, sizeof(__pyx_k_UVCheck), 0, 0, 1, 1},
+  {&__pyx_n_s_UVHandle, __pyx_k_UVHandle, sizeof(__pyx_k_UVHandle), 0, 0, 1, 1},
+  {&__pyx_kp_u_UVHandles_python_libuv_total, __pyx_k_UVHandles_python_libuv_total, sizeof(__pyx_k_UVHandles_python_libuv_total), 0, 1, 0, 0},
+  {&__pyx_n_s_UVIdle, __pyx_k_UVIdle, sizeof(__pyx_k_UVIdle), 0, 0, 1, 1},
+  {&__pyx_n_s_UVPoll, __pyx_k_UVPoll, sizeof(__pyx_k_UVPoll), 0, 0, 1, 1},
+  {&__pyx_n_s_UVProcess, __pyx_k_UVProcess, sizeof(__pyx_k_UVProcess), 0, 0, 1, 1},
+  {&__pyx_n_s_UVProcessTransport, __pyx_k_UVProcessTransport, sizeof(__pyx_k_UVProcessTransport), 0, 0, 1, 1},
+  {&__pyx_kp_u_UVProcessTransport__call_connect, __pyx_k_UVProcessTransport__call_connect, sizeof(__pyx_k_UVProcessTransport__call_connect), 0, 1, 0, 0},
+  {&__pyx_kp_u_UVProcess__close_after_spawn_cal, __pyx_k_UVProcess__close_after_spawn_cal, sizeof(__pyx_k_UVProcess__close_after_spawn_cal), 0, 1, 0, 0},
+  {&__pyx_n_s_UVRequest, __pyx_k_UVRequest, sizeof(__pyx_k_UVRequest), 0, 0, 1, 1},
+  {&__pyx_n_s_UVSocketHandle, __pyx_k_UVSocketHandle, sizeof(__pyx_k_UVSocketHandle), 0, 0, 1, 1},
+  {&__pyx_n_s_UVStream, __pyx_k_UVStream, sizeof(__pyx_k_UVStream), 0, 0, 1, 1},
+  {&__pyx_n_s_UVStreamServer, __pyx_k_UVStreamServer, sizeof(__pyx_k_UVStreamServer), 0, 0, 1, 1},
+  {&__pyx_kp_u_UVStream__try_write_called_with, __pyx_k_UVStream__try_write_called_with, sizeof(__pyx_k_UVStream__try_write_called_with), 0, 1, 0, 0},
+  {&__pyx_kp_u_UVStream_shutdown_callback_calle, __pyx_k_UVStream_shutdown_callback_calle, sizeof(__pyx_k_UVStream_shutdown_callback_calle), 0, 1, 0, 0},
+  {&__pyx_kp_u_UVStream_write_callback_called_w, __pyx_k_UVStream_write_callback_called_w, sizeof(__pyx_k_UVStream_write_callback_called_w), 0, 1, 0, 0},
+  {&__pyx_n_s_UVTimer, __pyx_k_UVTimer, sizeof(__pyx_k_UVTimer), 0, 0, 1, 1},
+  {&__pyx_kp_u_UVTransport__call_connection_los, __pyx_k_UVTransport__call_connection_los, sizeof(__pyx_k_UVTransport__call_connection_los), 0, 1, 0, 0},
+  {&__pyx_kp_u_UVTransport__call_connection_mad, __pyx_k_UVTransport__call_connection_mad, sizeof(__pyx_k_UVTransport__call_connection_mad), 0, 1, 0, 0},
+  {&__pyx_kp_u_Unable_to_check_or_remove_stale, __pyx_k_Unable_to_check_or_remove_stale, sizeof(__pyx_k_Unable_to_check_or_remove_stale), 0, 1, 0, 0},
+  {&__pyx_kp_u_Unhandled_error_in_exception_han, __pyx_k_Unhandled_error_in_exception_han, sizeof(__pyx_k_Unhandled_error_in_exception_han), 0, 1, 0, 0},
+  {&__pyx_kp_u_Unhandled_exception_in_event_loo, __pyx_k_Unhandled_exception_in_event_loo, sizeof(__pyx_k_Unhandled_exception_in_event_loo), 0, 1, 0, 0},
+  {&__pyx_n_s_UnicodeEncodeError, __pyx_k_UnicodeEncodeError, sizeof(__pyx_k_UnicodeEncodeError), 0, 0, 1, 1},
+  {&__pyx_n_s_UnixServer, __pyx_k_UnixServer, sizeof(__pyx_k_UnixServer), 0, 0, 1, 1},
+  {&__pyx_n_s_UnixTransport, __pyx_k_UnixTransport, sizeof(__pyx_k_UnixTransport), 0, 0, 1, 1},
+  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
+  {&__pyx_n_s_WeakSet, __pyx_k_WeakSet, sizeof(__pyx_k_WeakSet), 0, 0, 1, 1},
+  {&__pyx_n_s_WeakValueDictionary, __pyx_k_WeakValueDictionary, sizeof(__pyx_k_WeakValueDictionary), 0, 0, 1, 1},
+  {&__pyx_n_s_WriteSubprocessPipeProto, __pyx_k_WriteSubprocessPipeProto, sizeof(__pyx_k_WriteSubprocessPipeProto), 0, 0, 1, 1},
+  {&__pyx_n_s_WriteSubprocessPipeProto___init, __pyx_k_WriteSubprocessPipeProto___init, sizeof(__pyx_k_WriteSubprocessPipeProto___init), 0, 0, 1, 1},
+  {&__pyx_n_s_WriteSubprocessPipeProto___repr, __pyx_k_WriteSubprocessPipeProto___repr, sizeof(__pyx_k_WriteSubprocessPipeProto___repr), 0, 0, 1, 1},
+  {&__pyx_n_s_WriteSubprocessPipeProto_connect, __pyx_k_WriteSubprocessPipeProto_connect, sizeof(__pyx_k_WriteSubprocessPipeProto_connect), 0, 0, 1, 1},
+  {&__pyx_n_s_WriteSubprocessPipeProto_connect_2, __pyx_k_WriteSubprocessPipeProto_connect_2, sizeof(__pyx_k_WriteSubprocessPipeProto_connect_2), 0, 0, 1, 1},
+  {&__pyx_n_s_WriteSubprocessPipeProto_pause_w, __pyx_k_WriteSubprocessPipeProto_pause_w, sizeof(__pyx_k_WriteSubprocessPipeProto_pause_w), 0, 0, 1, 1},
+  {&__pyx_n_s_WriteSubprocessPipeProto_resume, __pyx_k_WriteSubprocessPipeProto_resume, sizeof(__pyx_k_WriteSubprocessPipeProto_resume), 0, 0, 1, 1},
+  {&__pyx_n_s_WriteUnixTransport, __pyx_k_WriteUnixTransport, sizeof(__pyx_k_WriteUnixTransport), 0, 0, 1, 1},
+  {&__pyx_kp_u_Write_callbacks_failed, __pyx_k_Write_callbacks_failed, sizeof(__pyx_k_Write_callbacks_failed), 0, 1, 0, 0},
+  {&__pyx_kp_u_Write_contexts_8, __pyx_k_Write_contexts_8, sizeof(__pyx_k_Write_contexts_8), 0, 1, 0, 0},
+  {&__pyx_kp_u_Write_errors, __pyx_k_Write_errors, sizeof(__pyx_k_Write_errors), 0, 1, 0, 0},
+  {&__pyx_kp_u_Write_events, __pyx_k_Write_events, sizeof(__pyx_k_Write_events), 0, 1, 0, 0},
+  {&__pyx_kp_u_Write_failed_callbacks, __pyx_k_Write_failed_callbacks, sizeof(__pyx_k_Write_failed_callbacks), 0, 1, 0, 0},
+  {&__pyx_kp_u_Write_without_poll, __pyx_k_Write_without_poll, sizeof(__pyx_k_Write_without_poll), 0, 1, 0, 0},
+  {&__pyx_kp_u_XXX_an_allocated_buffer_in_trans, __pyx_k_XXX_an_allocated_buffer_in_trans, sizeof(__pyx_k_XXX_an_allocated_buffer_in_trans), 0, 1, 0, 0},
+  {&__pyx_kp_u_You_must_set_server_hostname_whe, __pyx_k_You_must_set_server_hostname_whe, sizeof(__pyx_k_You_must_set_server_hostname_whe), 0, 1, 0, 0},
+  {&__pyx_kp_u__103, __pyx_k__103, sizeof(__pyx_k__103), 0, 1, 0, 0},
+  {&__pyx_kp_u__104, __pyx_k__104, sizeof(__pyx_k__104), 0, 1, 0, 0},
+  {&__pyx_kp_u__105, __pyx_k__105, sizeof(__pyx_k__105), 0, 1, 0, 0},
+  {&__pyx_kp_u__133, __pyx_k__133, sizeof(__pyx_k__133), 0, 1, 0, 0},
+  {&__pyx_kp_u__134, __pyx_k__134, sizeof(__pyx_k__134), 0, 1, 0, 0},
+  {&__pyx_kp_b__178, __pyx_k__178, sizeof(__pyx_k__178), 0, 0, 0, 0},
+  {&__pyx_kp_b__187, __pyx_k__187, sizeof(__pyx_k__187), 0, 0, 0, 0},
+  {&__pyx_kp_u__32, __pyx_k__32, sizeof(__pyx_k__32), 0, 1, 0, 0},
+  {&__pyx_kp_u__56, __pyx_k__56, sizeof(__pyx_k__56), 0, 1, 0, 0},
+  {&__pyx_kp_u__63, __pyx_k__63, sizeof(__pyx_k__63), 0, 1, 0, 0},
+  {&__pyx_kp_u__68, __pyx_k__68, sizeof(__pyx_k__68), 0, 1, 0, 0},
+  {&__pyx_kp_u__69, __pyx_k__69, sizeof(__pyx_k__69), 0, 1, 0, 0},
+  {&__pyx_n_s__8, __pyx_k__8, sizeof(__pyx_k__8), 0, 0, 1, 1},
+  {&__pyx_kp_b__8, __pyx_k__8, sizeof(__pyx_k__8), 0, 0, 0, 0},
+  {&__pyx_kp_u__8, __pyx_k__8, sizeof(__pyx_k__8), 0, 1, 0, 0},
+  {&__pyx_kp_u__91, __pyx_k__91, sizeof(__pyx_k__91), 0, 1, 0, 0},
+  {&__pyx_n_s_abc, __pyx_k_abc, sizeof(__pyx_k_abc), 0, 0, 1, 1},
+  {&__pyx_kp_u_abort_init__closed_is_set, __pyx_k_abort_init__closed_is_set, sizeof(__pyx_k_abort_init__closed_is_set), 0, 1, 0, 0},
+  {&__pyx_kp_u_abort_init__inited_is_set, __pyx_k_abort_init__inited_is_set, sizeof(__pyx_k_abort_init__inited_is_set), 0, 1, 0, 0},
+  {&__pyx_n_s_accept, __pyx_k_accept, sizeof(__pyx_k_accept), 0, 0, 1, 1},
+  {&__pyx_kp_u_accept_method, __pyx_k_accept_method, sizeof(__pyx_k_accept_method), 0, 1, 0, 0},
+  {&__pyx_n_s_aclose, __pyx_k_aclose, sizeof(__pyx_k_aclose), 0, 0, 1, 1},
+  {&__pyx_kp_u_active_TimerHandle_is_deallacati, __pyx_k_active_TimerHandle_is_deallacati, sizeof(__pyx_k_active_TimerHandle_is_deallacati), 0, 1, 0, 0},
+  {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1},
+  {&__pyx_n_s_add_done_callback, __pyx_k_add_done_callback, sizeof(__pyx_k_add_done_callback), 0, 0, 1, 1},
+  {&__pyx_kp_u_add_signal_handler_can_only_be_c, __pyx_k_add_signal_handler_can_only_be_c, sizeof(__pyx_k_add_signal_handler_can_only_be_c), 0, 1, 0, 0},
+  {&__pyx_n_s_addr, __pyx_k_addr, sizeof(__pyx_k_addr), 0, 0, 1, 1},
+  {&__pyx_n_s_address, __pyx_k_address, sizeof(__pyx_k_address), 0, 0, 1, 1},
+  {&__pyx_n_s_aenter, __pyx_k_aenter, sizeof(__pyx_k_aenter), 0, 0, 1, 1},
+  {&__pyx_n_s_aexit, __pyx_k_aexit, sizeof(__pyx_k_aexit), 0, 0, 1, 1},
+  {&__pyx_kp_u_alive_closed, __pyx_k_alive_closed, sizeof(__pyx_k_alive_closed), 0, 1, 0, 0},
+  {&__pyx_kp_u_all_args_must_be_str_or_bytes, __pyx_k_all_args_must_be_str_or_bytes, sizeof(__pyx_k_all_args_must_be_str_or_bytes), 0, 1, 0, 0},
+  {&__pyx_kp_u_all_environment_values_must_be_b, __pyx_k_all_environment_values_must_be_b, sizeof(__pyx_k_all_environment_values_must_be_b), 0, 1, 0, 0},
+  {&__pyx_kp_u_all_environment_vars_must_be_byt, __pyx_k_all_environment_vars_must_be_byt, sizeof(__pyx_k_all_environment_vars_must_be_byt), 0, 1, 0, 0},
+  {&__pyx_n_s_allow_broadcast, __pyx_k_allow_broadcast, sizeof(__pyx_k_allow_broadcast), 0, 0, 1, 1},
+  {&__pyx_kp_u_an_error_occurred_during_closing, __pyx_k_an_error_occurred_during_closing, sizeof(__pyx_k_an_error_occurred_during_closing), 0, 1, 0, 0},
+  {&__pyx_n_s_app_protocol, __pyx_k_app_protocol, sizeof(__pyx_k_app_protocol), 0, 0, 1, 1},
+  {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1},
+  {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1},
+  {&__pyx_n_u_ascii, __pyx_k_ascii, sizeof(__pyx_k_ascii), 0, 1, 0, 1},
+  {&__pyx_n_u_asyncgen, __pyx_k_asyncgen, sizeof(__pyx_k_asyncgen), 0, 1, 0, 1},
+  {&__pyx_n_s_asyncgen_finalizer_hook, __pyx_k_asyncgen_finalizer_hook, sizeof(__pyx_k_asyncgen_finalizer_hook), 0, 0, 1, 1},
+  {&__pyx_n_s_asyncgen_firstiter_hook, __pyx_k_asyncgen_firstiter_hook, sizeof(__pyx_k_asyncgen_firstiter_hook), 0, 0, 1, 1},
+  {&__pyx_kp_u_asynchronous_generator_r_was_sch, __pyx_k_asynchronous_generator_r_was_sch, sizeof(__pyx_k_asynchronous_generator_r_was_sch), 0, 1, 0, 0},
+  {&__pyx_n_s_asyncio, __pyx_k_asyncio, sizeof(__pyx_k_asyncio), 0, 0, 1, 1},
+  {&__pyx_n_s_asyncio_base_events, __pyx_k_asyncio_base_events, sizeof(__pyx_k_asyncio_base_events), 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_asyncio_futures, __pyx_k_asyncio_futures, sizeof(__pyx_k_asyncio_futures), 0, 0, 1, 1},
+  {&__pyx_kp_u_asyncio_is_trying_to_install_it, __pyx_k_asyncio_is_trying_to_install_it, sizeof(__pyx_k_asyncio_is_trying_to_install_it), 0, 1, 0, 0},
+  {&__pyx_n_s_asyncio_log, __pyx_k_asyncio_log, sizeof(__pyx_k_asyncio_log), 0, 0, 1, 1},
+  {&__pyx_n_s_asyncio_sslproto, __pyx_k_asyncio_sslproto, sizeof(__pyx_k_asyncio_sslproto), 0, 0, 1, 1},
+  {&__pyx_n_s_asyncio_tasks, __pyx_k_asyncio_tasks, sizeof(__pyx_k_asyncio_tasks), 0, 0, 1, 1},
+  {&__pyx_n_s_asyncio_transports, __pyx_k_asyncio_transports, sizeof(__pyx_k_asyncio_transports), 0, 0, 1, 1},
+  {&__pyx_n_s_await, __pyx_k_await, sizeof(__pyx_k_await), 0, 0, 1, 1},
+  {&__pyx_n_u_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 1, 0, 1},
+  {&__pyx_n_s_backlog, __pyx_k_backlog, sizeof(__pyx_k_backlog), 0, 0, 1, 1},
+  {&__pyx_kp_b_bin_sh, __pyx_k_bin_sh, sizeof(__pyx_k_bin_sh), 0, 0, 0, 0},
+  {&__pyx_n_s_bind, __pyx_k_bind, sizeof(__pyx_k_bind), 0, 0, 1, 1},
+  {&__pyx_kp_u_bind_method, __pyx_k_bind_method, sizeof(__pyx_k_bind_method), 0, 1, 0, 0},
+  {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1},
+  {&__pyx_kp_u_buffer_size_is_not_0_after_a_su, __pyx_k_buffer_size_is_not_0_after_a_su, sizeof(__pyx_k_buffer_size_is_not_0_after_a_su), 0, 1, 0, 0},
+  {&__pyx_n_s_buffer_updated, __pyx_k_buffer_updated, sizeof(__pyx_k_buffer_updated), 0, 0, 1, 1},
+  {&__pyx_n_s_bufsize, __pyx_k_bufsize, sizeof(__pyx_k_bufsize), 0, 0, 1, 1},
+  {&__pyx_kp_u_bufsize_must_be_0, __pyx_k_bufsize_must_be_0, sizeof(__pyx_k_bufsize_must_be_0), 0, 1, 0, 0},
+  {&__pyx_n_s_builtins, __pyx_k_builtins, sizeof(__pyx_k_builtins), 0, 0, 1, 1},
+  {&__pyx_kp_b_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 0, 0},
+  {&__pyx_n_s_call_connection_made, __pyx_k_call_connection_made, sizeof(__pyx_k_call_connection_made), 0, 0, 1, 1},
+  {&__pyx_n_s_call_exception_handler, __pyx_k_call_exception_handler, sizeof(__pyx_k_call_exception_handler), 0, 0, 1, 1},
+  {&__pyx_n_s_call_later, __pyx_k_call_later, sizeof(__pyx_k_call_later), 0, 0, 1, 1},
+  {&__pyx_n_s_call_soon, __pyx_k_call_soon, sizeof(__pyx_k_call_soon), 0, 0, 1, 1},
+  {&__pyx_n_s_call_soon_threadsafe, __pyx_k_call_soon_threadsafe, sizeof(__pyx_k_call_soon_threadsafe), 0, 0, 1, 1},
+  {&__pyx_n_s_callback, __pyx_k_callback, sizeof(__pyx_k_callback), 0, 0, 1, 1},
+  {&__pyx_kp_u_called_after_destroying_the_UVH, __pyx_k_called_after_destroying_the_UVH, sizeof(__pyx_k_called_after_destroying_the_UVH), 0, 1, 0, 0},
+  {&__pyx_kp_u_called_with_handle_data_NULL, __pyx_k_called_with_handle_data_NULL, sizeof(__pyx_k_called_with_handle_data_NULL), 0, 1, 0, 0},
+  {&__pyx_n_s_cancel, __pyx_k_cancel, sizeof(__pyx_k_cancel), 0, 0, 1, 1},
+  {&__pyx_kp_u_cancel_request_data_is_NULL, __pyx_k_cancel_request_data_is_NULL, sizeof(__pyx_k_cancel_request_data_is_NULL), 0, 1, 0, 0},
+  {&__pyx_kp_u_cancel_request_data_is_not_UVRe, __pyx_k_cancel_request_data_is_not_UVRe, sizeof(__pyx_k_cancel_request_data_is_not_UVRe), 0, 1, 0, 0},
+  {&__pyx_kp_u_cancel_request_is_NULL, __pyx_k_cancel_request_is_NULL, sizeof(__pyx_k_cancel_request_is_NULL), 0, 1, 0, 0},
+  {&__pyx_n_s_cancelled, __pyx_k_cancelled, sizeof(__pyx_k_cancelled), 0, 0, 1, 1},
+  {&__pyx_n_u_cancelled, __pyx_k_cancelled, sizeof(__pyx_k_cancelled), 0, 1, 0, 1},
+  {&__pyx_kp_u_cannot_add_a_signal_handler_for, __pyx_k_cannot_add_a_signal_handler_for, sizeof(__pyx_k_cannot_add_a_signal_handler_for), 0, 1, 0, 0},
+  {&__pyx_kp_u_cannot_apply_subprocess_STDOUT, __pyx_k_cannot_apply_subprocess_STDOUT, sizeof(__pyx_k_cannot_apply_subprocess_STDOUT), 0, 1, 0, 0},
+  {&__pyx_kp_u_cannot_cleanup_signal_handlers_c, __pyx_k_cannot_cleanup_signal_handlers_c, sizeof(__pyx_k_cannot_cleanup_signal_handlers_c), 0, 1, 0, 0},
+  {&__pyx_kp_u_cannot_convert_sockaddr_into_Pyt, __pyx_k_cannot_convert_sockaddr_into_Pyt, sizeof(__pyx_k_cannot_convert_sockaddr_into_Pyt), 0, 1, 0, 0},
+  {&__pyx_kp_u_cannot_open_a_UDP_handle_invalid, __pyx_k_cannot_open_a_UDP_handle_invalid, sizeof(__pyx_k_cannot_open_a_UDP_handle_invalid), 0, 1, 0, 0},
+  {&__pyx_kp_u_cannot_pause_signals_handling_no, __pyx_k_cannot_pause_signals_handling_no, sizeof(__pyx_k_cannot_pause_signals_handling_no), 0, 1, 0, 0},
+  {&__pyx_kp_u_cannot_run_Handle_callback_is_no, __pyx_k_cannot_run_Handle_callback_is_no, sizeof(__pyx_k_cannot_run_Handle_callback_is_no), 0, 1, 0, 0},
+  {&__pyx_kp_u_cannot_run_TimerHandle_callback, __pyx_k_cannot_run_TimerHandle_callback, sizeof(__pyx_k_cannot_run_TimerHandle_callback), 0, 1, 0, 0},
+  {&__pyx_kp_u_cannot_shutdown_signals_handling, __pyx_k_cannot_shutdown_signals_handling, sizeof(__pyx_k_cannot_shutdown_signals_handling), 0, 1, 0, 0},
+  {&__pyx_kp_u_cannot_spawn_a_process_args_are, __pyx_k_cannot_spawn_a_process_args_are, sizeof(__pyx_k_cannot_spawn_a_process_args_are), 0, 1, 0, 0},
+  {&__pyx_kp_u_cannot_switch_state_from_to, __pyx_k_cannot_switch_state_from_to, sizeof(__pyx_k_cannot_switch_state_from_to), 0, 1, 0, 0},
+  {&__pyx_n_s_cast, __pyx_k_cast, sizeof(__pyx_k_cast), 0, 0, 1, 1},
+  {&__pyx_n_s_cause, __pyx_k_cause, sizeof(__pyx_k_cause), 0, 0, 1, 1},
+  {&__pyx_n_s_cfunc_to_py, __pyx_k_cfunc_to_py, sizeof(__pyx_k_cfunc_to_py), 0, 0, 1, 1},
+  {&__pyx_n_s_chain, __pyx_k_chain, sizeof(__pyx_k_chain), 0, 0, 1, 1},
+  {&__pyx_n_s_check_default_executor, __pyx_k_check_default_executor, sizeof(__pyx_k_check_default_executor), 0, 0, 1, 1},
+  {&__pyx_n_s_check_hostname, __pyx_k_check_hostname, sizeof(__pyx_k_check_hostname), 0, 0, 1, 1},
+  {&__pyx_n_s_cipher, __pyx_k_cipher, sizeof(__pyx_k_cipher), 0, 0, 1, 1},
+  {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1},
+  {&__pyx_n_s_clear, __pyx_k_clear, sizeof(__pyx_k_clear), 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_close__handle_data_is_NULL, __pyx_k_close__handle_data_is_NULL, sizeof(__pyx_k_close__handle_data_is_NULL), 0, 1, 0, 0},
+  {&__pyx_kp_u_close__handle_data_is_not_UVHa, __pyx_k_close__handle_data_is_not_UVHa, sizeof(__pyx_k_close__handle_data_is_not_UVHa), 0, 1, 0, 0},
+  {&__pyx_n_s_close_fds, __pyx_k_close_fds, sizeof(__pyx_k_close_fds), 0, 0, 1, 1},
+  {&__pyx_kp_u_close_method, __pyx_k_close_method, sizeof(__pyx_k_close_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_close_uv_is_closing_is_true, __pyx_k_close_uv_is_closing_is_true, sizeof(__pyx_k_close_uv_is_closing_is_true), 0, 1, 0, 0},
+  {&__pyx_kp_u_closed_Transport_handle_and_unse, __pyx_k_closed_Transport_handle_and_unse, sizeof(__pyx_k_closed_Transport_handle_and_unse), 0, 1, 0, 0},
+  {&__pyx_kp_u_closed_reading_x, __pyx_k_closed_reading_x, sizeof(__pyx_k_closed_reading_x), 0, 1, 0, 0},
+  {&__pyx_kp_u_closed_x, __pyx_k_closed_x, sizeof(__pyx_k_closed_x), 0, 1, 0, 0},
+  {&__pyx_n_s_cmd, __pyx_k_cmd, sizeof(__pyx_k_cmd), 0, 0, 1, 1},
+  {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1},
+  {&__pyx_n_s_collections_abc, __pyx_k_collections_abc, sizeof(__pyx_k_collections_abc), 0, 0, 1, 1},
+  {&__pyx_n_s_compression, __pyx_k_compression, sizeof(__pyx_k_compression), 0, 0, 1, 1},
+  {&__pyx_n_s_concurrent, __pyx_k_concurrent, sizeof(__pyx_k_concurrent), 0, 0, 1, 1},
+  {&__pyx_kp_u_concurrent_allocations, __pyx_k_concurrent_allocations, sizeof(__pyx_k_concurrent_allocations), 0, 1, 0, 0},
+  {&__pyx_n_s_concurrent_futures, __pyx_k_concurrent_futures, sizeof(__pyx_k_concurrent_futures), 0, 0, 1, 1},
+  {&__pyx_n_s_connect, __pyx_k_connect, sizeof(__pyx_k_connect), 0, 0, 1, 1},
+  {&__pyx_n_s_connect_accepted_socket, __pyx_k_connect_accepted_socket, sizeof(__pyx_k_connect_accepted_socket), 0, 0, 1, 1},
+  {&__pyx_kp_u_connect_ex_method, __pyx_k_connect_ex_method, sizeof(__pyx_k_connect_ex_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_connect_failed, __pyx_k_connect_failed, sizeof(__pyx_k_connect_failed), 0, 1, 0, 0},
+  {&__pyx_kp_u_connect_method, __pyx_k_connect_method, sizeof(__pyx_k_connect_method), 0, 1, 0, 0},
+  {&__pyx_n_s_connect_read_pipe, __pyx_k_connect_read_pipe, sizeof(__pyx_k_connect_read_pipe), 0, 0, 1, 1},
+  {&__pyx_n_s_connect_write_pipe, __pyx_k_connect_write_pipe, sizeof(__pyx_k_connect_write_pipe), 0, 0, 1, 1},
+  {&__pyx_n_s_connection_lost, __pyx_k_connection_lost, sizeof(__pyx_k_connection_lost), 0, 0, 1, 1},
+  {&__pyx_n_s_connection_made, __pyx_k_connection_made, sizeof(__pyx_k_connection_made), 0, 0, 1, 1},
+  {&__pyx_n_s_context, __pyx_k_context, sizeof(__pyx_k_context), 0, 0, 1, 1},
+  {&__pyx_n_u_context, __pyx_k_context, sizeof(__pyx_k_context), 0, 1, 0, 1},
+  {&__pyx_kp_u_context_manager_protocol, __pyx_k_context_manager_protocol, sizeof(__pyx_k_context_manager_protocol), 0, 1, 0, 0},
+  {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1},
+  {&__pyx_n_s_coro, __pyx_k_coro, sizeof(__pyx_k_coro), 0, 0, 1, 1},
+  {&__pyx_n_s_coroutines, __pyx_k_coroutines, sizeof(__pyx_k_coroutines), 0, 0, 1, 1},
+  {&__pyx_kp_u_coroutines_cannot_be_used_with_a, __pyx_k_coroutines_cannot_be_used_with_a, sizeof(__pyx_k_coroutines_cannot_be_used_with_a), 0, 1, 0, 0},
+  {&__pyx_kp_u_coroutines_cannot_be_used_with_r, __pyx_k_coroutines_cannot_be_used_with_r, sizeof(__pyx_k_coroutines_cannot_be_used_with_r), 0, 1, 0, 0},
+  {&__pyx_kp_u_could_not_bind_to_local_addr, __pyx_k_could_not_bind_to_local_addr, sizeof(__pyx_k_could_not_bind_to_local_addr), 0, 1, 0, 0},
+  {&__pyx_kp_u_could_not_bind_to_remote_addr, __pyx_k_could_not_bind_to_remote_addr, sizeof(__pyx_k_could_not_bind_to_remote_addr), 0, 1, 0, 0},
+  {&__pyx_kp_u_could_not_close_attached_file_ob, __pyx_k_could_not_close_attached_file_ob, sizeof(__pyx_k_could_not_close_attached_file_ob), 0, 1, 0, 0},
+  {&__pyx_n_s_create_connection, __pyx_k_create_connection, sizeof(__pyx_k_create_connection), 0, 0, 1, 1},
+  {&__pyx_n_s_create_connection_locals_genexpr, __pyx_k_create_connection_locals_genexpr, sizeof(__pyx_k_create_connection_locals_genexpr), 0, 0, 1, 1},
+  {&__pyx_n_s_create_datagram_endpoint, __pyx_k_create_datagram_endpoint, sizeof(__pyx_k_create_datagram_endpoint), 0, 0, 1, 1},
+  {&__pyx_n_s_create_datagram_endpoint_locals, __pyx_k_create_datagram_endpoint_locals, sizeof(__pyx_k_create_datagram_endpoint_locals), 0, 0, 1, 1},
+  {&__pyx_n_s_create_default_context, __pyx_k_create_default_context, sizeof(__pyx_k_create_default_context), 0, 0, 1, 1},
+  {&__pyx_n_s_create_future, __pyx_k_create_future, sizeof(__pyx_k_create_future), 0, 0, 1, 1},
+  {&__pyx_n_s_create_server, __pyx_k_create_server, sizeof(__pyx_k_create_server), 0, 0, 1, 1},
+  {&__pyx_kp_u_create_server_failed_to_create_s, __pyx_k_create_server_failed_to_create_s, sizeof(__pyx_k_create_server_failed_to_create_s), 0, 1, 0, 0},
+  {&__pyx_n_s_create_task, __pyx_k_create_task, sizeof(__pyx_k_create_task), 0, 0, 1, 1},
+  {&__pyx_n_s_create_unix_connection, __pyx_k_create_unix_connection, sizeof(__pyx_k_create_unix_connection), 0, 0, 1, 1},
+  {&__pyx_n_s_create_unix_server, __pyx_k_create_unix_server, sizeof(__pyx_k_create_unix_server), 0, 0, 1, 1},
+  {&__pyx_kp_u_created_at, __pyx_k_created_at, sizeof(__pyx_k_created_at), 0, 1, 0, 0},
+  {&__pyx_n_s_creationflags, __pyx_k_creationflags, sizeof(__pyx_k_creationflags), 0, 0, 1, 1},
+  {&__pyx_kp_u_creationflags_is_not_supported, __pyx_k_creationflags_is_not_supported, sizeof(__pyx_k_creationflags_is_not_supported), 0, 1, 0, 0},
+  {&__pyx_n_s_cwd, __pyx_k_cwd, sizeof(__pyx_k_cwd), 0, 0, 1, 1},
+  {&__pyx_kp_u_cwd_must_be_a_str_or_bytes_objec, __pyx_k_cwd_must_be_a_str_or_bytes_objec, sizeof(__pyx_k_cwd_must_be_a_str_or_bytes_objec), 0, 1, 0, 0},
+  {&__pyx_n_u_cygwin, __pyx_k_cygwin, sizeof(__pyx_k_cygwin), 0, 1, 0, 1},
+  {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1},
+  {&__pyx_kp_u_data_expecting_a_bytes_like_inst, __pyx_k_data_expecting_a_bytes_like_inst, sizeof(__pyx_k_data_expecting_a_bytes_like_inst), 0, 1, 0, 0},
+  {&__pyx_n_s_data_received, __pyx_k_data_received, sizeof(__pyx_k_data_received), 0, 0, 1, 1},
+  {&__pyx_n_s_datagram_received, __pyx_k_datagram_received, sizeof(__pyx_k_datagram_received), 0, 0, 1, 1},
+  {&__pyx_kp_u_dealloc____handle_is_NULL__cl, __pyx_k_dealloc____handle_is_NULL__cl, sizeof(__pyx_k_dealloc____handle_is_NULL__cl), 0, 1, 0, 0},
+  {&__pyx_kp_u_deallocating_a_running_event_loo, __pyx_k_deallocating_a_running_event_loo, sizeof(__pyx_k_deallocating_a_running_event_loo), 0, 1, 0, 0},
+  {&__pyx_kp_u_deallocating_an_open_event_loop, __pyx_k_deallocating_an_open_event_loop, sizeof(__pyx_k_deallocating_an_open_event_loop), 0, 1, 0, 0},
+  {&__pyx_n_s_debug, __pyx_k_debug, sizeof(__pyx_k_debug), 0, 0, 1, 1},
+  {&__pyx_n_u_debug_wrapper, __pyx_k_debug_wrapper, sizeof(__pyx_k_debug_wrapper), 0, 1, 0, 1},
+  {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1},
+  {&__pyx_n_s_decref_socketios, __pyx_k_decref_socketios, sizeof(__pyx_k_decref_socketios), 0, 0, 1, 1},
+  {&__pyx_n_s_default, __pyx_k_default, sizeof(__pyx_k_default), 0, 0, 1, 1},
+  {&__pyx_n_s_default_exception_handler, __pyx_k_default_exception_handler, sizeof(__pyx_k_default_exception_handler), 0, 0, 1, 1},
+  {&__pyx_n_s_default_int_handler, __pyx_k_default_int_handler, sizeof(__pyx_k_default_int_handler), 0, 0, 1, 1},
+  {&__pyx_n_s_delay, __pyx_k_delay, sizeof(__pyx_k_delay), 0, 0, 1, 1},
+  {&__pyx_n_s_deque, __pyx_k_deque, sizeof(__pyx_k_deque), 0, 0, 1, 1},
+  {&__pyx_n_s_detach, __pyx_k_detach, sizeof(__pyx_k_detach), 0, 0, 1, 1},
+  {&__pyx_kp_u_detach_method, __pyx_k_detach_method, sizeof(__pyx_k_detach_method), 0, 1, 0, 0},
+  {&__pyx_n_s_devnull, __pyx_k_devnull, sizeof(__pyx_k_devnull), 0, 0, 1, 1},
+  {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1},
+  {&__pyx_n_s_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 0, 1, 1},
+  {&__pyx_n_s_discard, __pyx_k_discard, sizeof(__pyx_k_discard), 0, 0, 1, 1},
+  {&__pyx_n_s_disconnected, __pyx_k_disconnected, sizeof(__pyx_k_disconnected), 0, 0, 1, 1},
+  {&__pyx_n_s_do_handshake, __pyx_k_do_handshake, sizeof(__pyx_k_do_handshake), 0, 0, 1, 1},
+  {&__pyx_n_s_do_shutdown, __pyx_k_do_shutdown, sizeof(__pyx_k_do_shutdown), 0, 0, 1, 1},
+  {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1},
+  {&__pyx_kp_u_does_not_have_a_reader_in_the, __pyx_k_does_not_have_a_reader_in_the, sizeof(__pyx_k_does_not_have_a_reader_in_the), 0, 1, 0, 0},
+  {&__pyx_kp_u_does_not_have_a_reader_in_the_2, __pyx_k_does_not_have_a_reader_in_the_2, sizeof(__pyx_k_does_not_have_a_reader_in_the_2), 0, 1, 0, 0},
+  {&__pyx_kp_u_does_not_have_a_writer_in_the, __pyx_k_does_not_have_a_writer_in_the, sizeof(__pyx_k_does_not_have_a_writer_in_the), 0, 1, 0, 0},
+  {&__pyx_kp_u_does_not_have_a_writer_in_the_2, __pyx_k_does_not_have_a_writer_in_the_2, sizeof(__pyx_k_does_not_have_a_writer_in_the_2), 0, 1, 0, 0},
+  {&__pyx_n_s_done, __pyx_k_done, sizeof(__pyx_k_done), 0, 0, 1, 1},
+  {&__pyx_n_s_done_cb, __pyx_k_done_cb, sizeof(__pyx_k_done_cb), 0, 0, 1, 1},
+  {&__pyx_n_s_dup, __pyx_k_dup, sizeof(__pyx_k_dup), 0, 0, 1, 1},
+  {&__pyx_n_s_enabled, __pyx_k_enabled, sizeof(__pyx_k_enabled), 0, 0, 1, 1},
+  {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1},
+  {&__pyx_n_s_ensure_future, __pyx_k_ensure_future, sizeof(__pyx_k_ensure_future), 0, 0, 1, 1},
+  {&__pyx_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 0, 0, 1, 1},
+  {&__pyx_n_s_env, __pyx_k_env, sizeof(__pyx_k_env), 0, 0, 1, 1},
+  {&__pyx_n_s_environ, __pyx_k_environ, sizeof(__pyx_k_environ), 0, 0, 1, 1},
+  {&__pyx_n_s_eof_received, __pyx_k_eof_received, sizeof(__pyx_k_eof_received), 0, 0, 1, 1},
+  {&__pyx_n_s_errno, __pyx_k_errno, sizeof(__pyx_k_errno), 0, 0, 1, 1},
+  {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1},
+  {&__pyx_n_s_error_received, __pyx_k_error_received, sizeof(__pyx_k_error_received), 0, 0, 1, 1},
+  {&__pyx_kp_u_error_status_in_uv_stream_t_list, __pyx_k_error_status_in_uv_stream_t_list, sizeof(__pyx_k_error_status_in_uv_stream_t_list), 0, 1, 0, 0},
+  {&__pyx_kp_u_error_status_in_uv_stream_t_read, __pyx_k_error_status_in_uv_stream_t_read, sizeof(__pyx_k_error_status_in_uv_stream_t_read), 0, 1, 0, 0},
+  {&__pyx_kp_u_error_status_in_uv_stream_t_shut, __pyx_k_error_status_in_uv_stream_t_shut, sizeof(__pyx_k_error_status_in_uv_stream_t_shut), 0, 1, 0, 0},
+  {&__pyx_kp_u_error_status_in_uv_stream_t_writ, __pyx_k_error_status_in_uv_stream_t_writ, sizeof(__pyx_k_error_status_in_uv_stream_t_writ), 0, 1, 0, 0},
+  {&__pyx_kp_u_error_while_attempting_to_bind_o, __pyx_k_error_while_attempting_to_bind_o, sizeof(__pyx_k_error_while_attempting_to_bind_o), 0, 1, 0, 0},
+  {&__pyx_n_s_ex, __pyx_k_ex, sizeof(__pyx_k_ex), 0, 0, 1, 1},
+  {&__pyx_n_s_exc, __pyx_k_exc, sizeof(__pyx_k_exc), 0, 0, 1, 1},
+  {&__pyx_n_s_exc_info, __pyx_k_exc_info, sizeof(__pyx_k_exc_info), 0, 0, 1, 1},
+  {&__pyx_n_s_exception, __pyx_k_exception, sizeof(__pyx_k_exception), 0, 0, 1, 1},
+  {&__pyx_n_u_exception, __pyx_k_exception, sizeof(__pyx_k_exception), 0, 1, 0, 1},
+  {&__pyx_kp_u_exception_in_Task___repr, __pyx_k_exception_in_Task___repr, sizeof(__pyx_k_exception_in_Task___repr), 0, 1, 0, 0},
+  {&__pyx_n_s_executable, __pyx_k_executable, sizeof(__pyx_k_executable), 0, 0, 1, 1},
+  {&__pyx_n_s_executor, __pyx_k_executor, sizeof(__pyx_k_executor), 0, 0, 1, 1},
+  {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1},
+  {&__pyx_kp_u_expected_AF_INET_AF_INET6_or_AF, __pyx_k_expected_AF_INET_AF_INET6_or_AF, sizeof(__pyx_k_expected_AF_INET_AF_INET6_or_AF), 0, 1, 0, 0},
+  {&__pyx_kp_u_expected_asyncio_Future, __pyx_k_expected_asyncio_Future, sizeof(__pyx_k_expected_asyncio_Future), 0, 1, 0, 0},
+  {&__pyx_n_s_extract, __pyx_k_extract, sizeof(__pyx_k_extract), 0, 0, 1, 1},
+  {&__pyx_n_s_family, __pyx_k_family, sizeof(__pyx_k_family), 0, 0, 1, 1},
+  {&__pyx_kp_u_fatal_Could_not_advance__StreamW, __pyx_k_fatal_Could_not_advance__StreamW, sizeof(__pyx_k_fatal_Could_not_advance__StreamW), 0, 1, 0, 0},
+  {&__pyx_kp_u_fatal_sent_0_in_advance_uv_buf, __pyx_k_fatal_sent_0_in_advance_uv_buf, sizeof(__pyx_k_fatal_sent_0_in_advance_uv_buf), 0, 1, 0, 0},
+  {&__pyx_n_s_fd, __pyx_k_fd, sizeof(__pyx_k_fd), 0, 0, 1, 1},
+  {&__pyx_kp_u_fd_2, __pyx_k_fd_2, sizeof(__pyx_k_fd_2), 0, 1, 0, 0},
+  {&__pyx_n_s_fileno, __pyx_k_fileno, sizeof(__pyx_k_fileno), 0, 0, 1, 1},
+  {&__pyx_n_s_fileobj, __pyx_k_fileobj, sizeof(__pyx_k_fileobj), 0, 0, 1, 1},
+  {&__pyx_n_s_finalizer, __pyx_k_finalizer, sizeof(__pyx_k_finalizer), 0, 0, 1, 1},
+  {&__pyx_n_s_firstiter, __pyx_k_firstiter, sizeof(__pyx_k_firstiter), 0, 0, 1, 1},
+  {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1},
+  {&__pyx_n_s_flush, __pyx_k_flush, sizeof(__pyx_k_flush), 0, 0, 1, 1},
+  {&__pyx_n_s_force_close, __pyx_k_force_close, sizeof(__pyx_k_force_close), 0, 0, 1, 1},
+  {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1},
+  {&__pyx_n_s_format_list, __pyx_k_format_list, sizeof(__pyx_k_format_list), 0, 0, 1, 1},
+  {&__pyx_n_s_frame, __pyx_k_frame, sizeof(__pyx_k_frame), 0, 0, 1, 1},
+  {&__pyx_n_s_fspath, __pyx_k_fspath, sizeof(__pyx_k_fspath), 0, 0, 1, 1},
+  {&__pyx_n_s_func, __pyx_k_func, sizeof(__pyx_k_func), 0, 0, 1, 1},
+  {&__pyx_n_s_functools, __pyx_k_functools, sizeof(__pyx_k_functools), 0, 0, 1, 1},
+  {&__pyx_n_s_fut, __pyx_k_fut, sizeof(__pyx_k_fut), 0, 0, 1, 1},
+  {&__pyx_n_s_futures, __pyx_k_futures, sizeof(__pyx_k_futures), 0, 0, 1, 1},
+  {&__pyx_n_s_gaierror, __pyx_k_gaierror, sizeof(__pyx_k_gaierror), 0, 0, 1, 1},
+  {&__pyx_n_s_gather, __pyx_k_gather, sizeof(__pyx_k_gather), 0, 0, 1, 1},
+  {&__pyx_n_s_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 0, 1, 1},
+  {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1},
+  {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1},
+  {&__pyx_n_s_get_app_transport, __pyx_k_get_app_transport, sizeof(__pyx_k_get_app_transport), 0, 0, 1, 1},
+  {&__pyx_n_s_get_asyncgen_hooks, __pyx_k_get_asyncgen_hooks, sizeof(__pyx_k_get_asyncgen_hooks), 0, 0, 1, 1},
+  {&__pyx_n_s_get_buffer, __pyx_k_get_buffer, sizeof(__pyx_k_get_buffer), 0, 0, 1, 1},
+  {&__pyx_n_u_get_buffer, __pyx_k_get_buffer, sizeof(__pyx_k_get_buffer), 0, 1, 0, 1},
+  {&__pyx_n_s_get_coroutine_origin_tracking_de, __pyx_k_get_coroutine_origin_tracking_de, sizeof(__pyx_k_get_coroutine_origin_tracking_de), 0, 0, 1, 1},
+  {&__pyx_n_u_get_coroutine_wrapper, __pyx_k_get_coroutine_wrapper, sizeof(__pyx_k_get_coroutine_wrapper), 0, 1, 0, 1},
+  {&__pyx_n_s_get_debug, __pyx_k_get_debug, sizeof(__pyx_k_get_debug), 0, 0, 1, 1},
+  {&__pyx_n_s_get_event_loop, __pyx_k_get_event_loop, sizeof(__pyx_k_get_event_loop), 0, 0, 1, 1},
+  {&__pyx_n_s_get_extra_info, __pyx_k_get_extra_info, sizeof(__pyx_k_get_extra_info), 0, 0, 1, 1},
+  {&__pyx_n_s_get_inheritable, __pyx_k_get_inheritable, sizeof(__pyx_k_get_inheritable), 0, 0, 1, 1},
+  {&__pyx_n_u_get_running_loop, __pyx_k_get_running_loop, sizeof(__pyx_k_get_running_loop), 0, 1, 0, 1},
+  {&__pyx_n_s_getaddrinfo, __pyx_k_getaddrinfo, sizeof(__pyx_k_getaddrinfo), 0, 0, 1, 1},
+  {&__pyx_kp_u_getaddrinfo_returned_empty_list, __pyx_k_getaddrinfo_returned_empty_list, sizeof(__pyx_k_getaddrinfo_returned_empty_list), 0, 1, 0, 0},
+  {&__pyx_kp_u_getaddrinfo_returned_empty_list_2, __pyx_k_getaddrinfo_returned_empty_list_2, sizeof(__pyx_k_getaddrinfo_returned_empty_list_2), 0, 1, 0, 0},
+  {&__pyx_n_s_getfilesystemencoding, __pyx_k_getfilesystemencoding, sizeof(__pyx_k_getfilesystemencoding), 0, 0, 1, 1},
+  {&__pyx_n_s_getframe, __pyx_k_getframe, sizeof(__pyx_k_getframe), 0, 0, 1, 1},
+  {&__pyx_n_s_getnameinfo, __pyx_k_getnameinfo, sizeof(__pyx_k_getnameinfo), 0, 0, 1, 1},
+  {&__pyx_kp_u_getnameinfo_argument_1_must_be_a, __pyx_k_getnameinfo_argument_1_must_be_a, sizeof(__pyx_k_getnameinfo_argument_1_must_be_a), 0, 1, 0, 0},
+  {&__pyx_kp_u_getnameinfo_flowinfo_must_be_0_1, __pyx_k_getnameinfo_flowinfo_must_be_0_1, sizeof(__pyx_k_getnameinfo_flowinfo_must_be_0_1), 0, 1, 0, 0},
+  {&__pyx_n_s_getpeercert, __pyx_k_getpeercert, sizeof(__pyx_k_getpeercert), 0, 0, 1, 1},
+  {&__pyx_n_s_getpeername, __pyx_k_getpeername, sizeof(__pyx_k_getpeername), 0, 0, 1, 1},
+  {&__pyx_n_s_getservbyname, __pyx_k_getservbyname, sizeof(__pyx_k_getservbyname), 0, 0, 1, 1},
+  {&__pyx_kp_u_getsockaddrarg_scope_id_must_be, __pyx_k_getsockaddrarg_scope_id_must_be, sizeof(__pyx_k_getsockaddrarg_scope_id_must_be), 0, 1, 0, 0},
+  {&__pyx_n_s_getsockname, __pyx_k_getsockname, sizeof(__pyx_k_getsockname), 0, 0, 1, 1},
+  {&__pyx_n_s_getsockopt, __pyx_k_getsockopt, sizeof(__pyx_k_getsockopt), 0, 0, 1, 1},
+  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+  {&__pyx_n_s_gettimeout, __pyx_k_gettimeout, sizeof(__pyx_k_gettimeout), 0, 0, 1, 1},
+  {&__pyx_n_u_handle, __pyx_k_handle, sizeof(__pyx_k_handle), 0, 1, 0, 1},
+  {&__pyx_kp_u_handle_data_is_NULL_in___close_a, __pyx_k_handle_data_is_NULL_in___close_a, sizeof(__pyx_k_handle_data_is_NULL_in___close_a), 0, 1, 0, 0},
+  {&__pyx_kp_u_handle_loop_data_is_NULL_in___en, __pyx_k_handle_loop_data_is_NULL_in___en, sizeof(__pyx_k_handle_loop_data_is_NULL_in___en), 0, 1, 0, 0},
+  {&__pyx_kp_u_handle_loop_is_NULL_in___ensure, __pyx_k_handle_loop_is_NULL_in___ensure, sizeof(__pyx_k_handle_loop_is_NULL_in___ensure), 0, 1, 0, 0},
+  {&__pyx_kp_u_has_handle_0_in___uv_close_handl, __pyx_k_has_handle_0_in___uv_close_handl, sizeof(__pyx_k_has_handle_0_in___uv_close_handl), 0, 1, 0, 0},
+  {&__pyx_n_s_high, __pyx_k_high, sizeof(__pyx_k_high), 0, 0, 1, 1},
+  {&__pyx_kp_u_high_2, __pyx_k_high_2, sizeof(__pyx_k_high_2), 0, 1, 0, 0},
+  {&__pyx_n_s_host, __pyx_k_host, sizeof(__pyx_k_host), 0, 0, 1, 1},
+  {&__pyx_kp_u_host_and_port_was_not_specified, __pyx_k_host_and_port_was_not_specified, sizeof(__pyx_k_host_and_port_was_not_specified), 0, 1, 0, 0},
+  {&__pyx_kp_u_host_must_be_a_str_or_bytes, __pyx_k_host_must_be_a_str_or_bytes, sizeof(__pyx_k_host_must_be_a_str_or_bytes), 0, 1, 0, 0},
+  {&__pyx_kp_u_host_must_be_a_string_or_bytes_o, __pyx_k_host_must_be_a_string_or_bytes_o, sizeof(__pyx_k_host_must_be_a_string_or_bytes_o), 0, 1, 0, 0},
+  {&__pyx_kp_u_host_port_and_sock_can_not_be_sp, __pyx_k_host_port_and_sock_can_not_be_sp, sizeof(__pyx_k_host_port_and_sock_can_not_be_sp), 0, 1, 0, 0},
+  {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1},
+  {&__pyx_n_s_ident, __pyx_k_ident, sizeof(__pyx_k_ident), 0, 0, 1, 1},
+  {&__pyx_n_u_idna, __pyx_k_idna, sizeof(__pyx_k_idna), 0, 1, 0, 1},
+  {&__pyx_n_s_ignore_environment, __pyx_k_ignore_environment, sizeof(__pyx_k_ignore_environment), 0, 0, 1, 1},
+  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+  {&__pyx_n_u_inf, __pyx_k_inf, sizeof(__pyx_k_inf), 0, 1, 0, 1},
+  {&__pyx_n_s_info, __pyx_k_info, sizeof(__pyx_k_info), 0, 0, 1, 1},
+  {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1},
+  {&__pyx_n_s_inspect, __pyx_k_inspect, sizeof(__pyx_k_inspect), 0, 0, 1, 1},
+  {&__pyx_kp_u_integer_argument_expected_got, __pyx_k_integer_argument_expected_got, sizeof(__pyx_k_integer_argument_expected_got), 0, 1, 0, 0},
+  {&__pyx_kp_u_invalid_Handle_cb_type, __pyx_k_invalid_Handle_cb_type, sizeof(__pyx_k_invalid_Handle_cb_type), 0, 1, 0, 0},
+  {&__pyx_kp_u_invalid__init_protocol_call, __pyx_k_invalid__init_protocol_call, sizeof(__pyx_k_invalid__init_protocol_call), 0, 1, 0, 0},
+  {&__pyx_kp_u_invalid_data_in_writebuf_an_inst, __pyx_k_invalid_data_in_writebuf_an_inst, sizeof(__pyx_k_invalid_data_in_writebuf_an_inst), 0, 1, 0, 0},
+  {&__pyx_kp_u_invalid_socket_family_expected_A, __pyx_k_invalid_socket_family_expected_A, sizeof(__pyx_k_invalid_socket_family_expected_A), 0, 1, 0, 0},
+  {&__pyx_kp_u_invalid_waiter_object, __pyx_k_invalid_waiter_object, sizeof(__pyx_k_invalid_waiter_object), 0, 1, 0, 0},
+  {&__pyx_n_s_io_refs, __pyx_k_io_refs, sizeof(__pyx_k_io_refs), 0, 0, 1, 1},
+  {&__pyx_kp_u_is_alive_but__handle_data_is_no, __pyx_k_is_alive_but__handle_data_is_no, sizeof(__pyx_k_is_alive_but__handle_data_is_no), 0, 1, 0, 0},
+  {&__pyx_kp_u_is_alive_but__handle_is_NULL, __pyx_k_is_alive_but__handle_is_NULL, sizeof(__pyx_k_is_alive_but__handle_is_NULL), 0, 1, 0, 0},
+  {&__pyx_kp_u_is_alive_but__handle_loop_is_no, __pyx_k_is_alive_but__handle_loop_is_no, sizeof(__pyx_k_is_alive_but__handle_loop_is_no), 0, 1, 0, 0},
+  {&__pyx_kp_u_is_alive_but__loop_is_None, __pyx_k_is_alive_but__loop_is_None, sizeof(__pyx_k_is_alive_but__loop_is_None), 0, 1, 0, 0},
+  {&__pyx_kp_u_is_already_being_awaited_on_ser, __pyx_k_is_already_being_awaited_on_ser, sizeof(__pyx_k_is_already_being_awaited_on_ser), 0, 1, 0, 0},
+  {&__pyx_n_s_is_closed, __pyx_k_is_closed, sizeof(__pyx_k_is_closed), 0, 0, 1, 1},
+  {&__pyx_kp_u_is_closed_2, __pyx_k_is_closed_2, sizeof(__pyx_k_is_closed_2), 0, 1, 0, 0},
+  {&__pyx_kp_u_is_longer_than_107_characters, __pyx_k_is_longer_than_107_characters, sizeof(__pyx_k_is_longer_than_107_characters), 0, 1, 0, 0},
+  {&__pyx_kp_u_is_not_supported_by_start_tls, __pyx_k_is_not_supported_by_start_tls, sizeof(__pyx_k_is_not_supported_by_start_tls), 0, 1, 0, 0},
+  {&__pyx_kp_u_is_not_supposed_to_be_instantia, __pyx_k_is_not_supposed_to_be_instantia, sizeof(__pyx_k_is_not_supposed_to_be_instantia), 0, 1, 0, 0},
+  {&__pyx_kp_u_is_open_in___dealloc___with_loo, __pyx_k_is_open_in___dealloc___with_loo, sizeof(__pyx_k_is_open_in___dealloc___with_loo), 0, 1, 0, 0},
+  {&__pyx_n_s_is_running, __pyx_k_is_running, sizeof(__pyx_k_is_running), 0, 0, 1, 1},
+  {&__pyx_n_s_iscoroutine, __pyx_k_iscoroutine, sizeof(__pyx_k_iscoroutine), 0, 0, 1, 1},
+  {&__pyx_n_s_iscoroutinefunction, __pyx_k_iscoroutinefunction, sizeof(__pyx_k_iscoroutinefunction), 0, 0, 1, 1},
+  {&__pyx_n_u_isfuture, __pyx_k_isfuture, sizeof(__pyx_k_isfuture), 0, 1, 0, 1},
+  {&__pyx_n_s_isgenerator, __pyx_k_isgenerator, sizeof(__pyx_k_isgenerator), 0, 0, 1, 1},
+  {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1},
+  {&__pyx_n_s_itertools, __pyx_k_itertools, sizeof(__pyx_k_itertools), 0, 0, 1, 1},
+  {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1},
+  {&__pyx_kp_u_laddr_s, __pyx_k_laddr_s, sizeof(__pyx_k_laddr_s), 0, 1, 0, 0},
+  {&__pyx_n_s_last, __pyx_k_last, sizeof(__pyx_k_last), 0, 0, 1, 1},
+  {&__pyx_n_s_limit, __pyx_k_limit, sizeof(__pyx_k_limit), 0, 0, 1, 1},
+  {&__pyx_kp_u_listen_method, __pyx_k_listen_method, sizeof(__pyx_k_listen_method), 0, 1, 0, 0},
+  {&__pyx_n_s_local_addr, __pyx_k_local_addr, sizeof(__pyx_k_local_addr), 0, 0, 1, 1},
+  {&__pyx_kp_u_local_addr_must_be_a_tuple_of_ho, __pyx_k_local_addr_must_be_a_tuple_of_ho, sizeof(__pyx_k_local_addr_must_be_a_tuple_of_ho), 0, 1, 0, 0},
+  {&__pyx_kp_u_local_addr_must_be_a_tuple_of_ho_2, __pyx_k_local_addr_must_be_a_tuple_of_ho_2, sizeof(__pyx_k_local_addr_must_be_a_tuple_of_ho_2), 0, 1, 0, 0},
+  {&__pyx_n_s_log, __pyx_k_log, sizeof(__pyx_k_log), 0, 0, 1, 1},
+  {&__pyx_n_s_log_destroy_pending, __pyx_k_log_destroy_pending, sizeof(__pyx_k_log_destroy_pending), 0, 0, 1, 1},
+  {&__pyx_n_s_logger, __pyx_k_logger, sizeof(__pyx_k_logger), 0, 0, 1, 1},
+  {&__pyx_n_s_lookup_lines, __pyx_k_lookup_lines, sizeof(__pyx_k_lookup_lines), 0, 0, 1, 1},
+  {&__pyx_n_s_loop, __pyx_k_loop, sizeof(__pyx_k_loop), 0, 0, 1, 1},
+  {&__pyx_kp_u_loop__exec_queued_writes, __pyx_k_loop__exec_queued_writes, sizeof(__pyx_k_loop__exec_queued_writes), 0, 1, 0, 0},
+  {&__pyx_kp_u_loop__on_idle, __pyx_k_loop__on_idle, sizeof(__pyx_k_loop__on_idle), 0, 1, 0, 0},
+  {&__pyx_kp_u_loop__queued_streams_are_not_emp, __pyx_k_loop__queued_streams_are_not_emp, sizeof(__pyx_k_loop__queued_streams_are_not_emp), 0, 1, 0, 0},
+  {&__pyx_n_s_low, __pyx_k_low, sizeof(__pyx_k_low), 0, 0, 1, 1},
+  {&__pyx_n_s_lower, __pyx_k_lower, sizeof(__pyx_k_lower), 0, 0, 1, 1},
+  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+  {&__pyx_n_s_main_thread, __pyx_k_main_thread, sizeof(__pyx_k_main_thread), 0, 0, 1, 1},
+  {&__pyx_kp_u_makefile_method, __pyx_k_makefile_method, sizeof(__pyx_k_makefile_method), 0, 1, 0, 0},
+  {&__pyx_n_s_maxsize, __pyx_k_maxsize, sizeof(__pyx_k_maxsize), 0, 0, 1, 1},
+  {&__pyx_kp_u_maxsize_is_expected_to_be_greate, __pyx_k_maxsize_is_expected_to_be_greate, sizeof(__pyx_k_maxsize_is_expected_to_be_greate), 0, 1, 0, 0},
+  {&__pyx_n_s_memoryview, __pyx_k_memoryview, sizeof(__pyx_k_memoryview), 0, 0, 1, 1},
+  {&__pyx_n_u_message, __pyx_k_message, sizeof(__pyx_k_message), 0, 1, 0, 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_monotonic, __pyx_k_monotonic, sizeof(__pyx_k_monotonic), 0, 0, 1, 1},
+  {&__pyx_n_s_move_to_end, __pyx_k_move_to_end, sizeof(__pyx_k_move_to_end), 0, 0, 1, 1},
+  {&__pyx_n_s_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1},
+  {&__pyx_kp_u_must_be_0, __pyx_k_must_be_0, sizeof(__pyx_k_must_be_0), 0, 1, 0, 0},
+  {&__pyx_kp_u_must_be_low, __pyx_k_must_be_low, sizeof(__pyx_k_must_be_low), 0, 1, 0, 0},
+  {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1},
+  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+  {&__pyx_n_u_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 1, 0, 1},
+  {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1},
+  {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1},
+  {&__pyx_kp_u_new_callbacks_were_queued_during, __pyx_k_new_callbacks_were_queued_during, sizeof(__pyx_k_new_callbacks_were_queued_during), 0, 1, 0, 0},
+  {&__pyx_kp_u_new_poll_handles_were_queued_dur, __pyx_k_new_poll_handles_were_queued_dur, sizeof(__pyx_k_new_poll_handles_were_queued_dur), 0, 1, 0, 0},
+  {&__pyx_kp_u_new_timers_were_queued_during_lo, __pyx_k_new_timers_were_queued_during_lo, sizeof(__pyx_k_new_timers_were_queued_during_lo), 0, 1, 0, 0},
+  {&__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_kp_u_no_path_and_sock_were_specified, __pyx_k_no_path_and_sock_were_specified, sizeof(__pyx_k_no_path_and_sock_were_specified), 0, 1, 0, 0},
+  {&__pyx_kp_u_no_python_buffer_is_allocated_in, __pyx_k_no_python_buffer_is_allocated_in, sizeof(__pyx_k_no_python_buffer_is_allocated_in), 0, 1, 0, 0},
+  {&__pyx_n_s_noop, __pyx_k_noop, sizeof(__pyx_k_noop), 0, 0, 1, 1},
+  {&__pyx_n_s_noop_2, __pyx_k_noop_2, sizeof(__pyx_k_noop_2), 0, 0, 1, 1},
+  {&__pyx_n_s_object, __pyx_k_object, sizeof(__pyx_k_object), 0, 0, 1, 1},
+  {&__pyx_kp_u_object_created_at_most_recent_ca, __pyx_k_object_created_at_most_recent_ca, sizeof(__pyx_k_object_created_at_most_recent_ca), 0, 1, 0, 0},
+  {&__pyx_kp_u_objs_handles, __pyx_k_objs_handles, sizeof(__pyx_k_objs_handles), 0, 1, 0, 0},
+  {&__pyx_n_s_on_ssl_connected, __pyx_k_on_ssl_connected, sizeof(__pyx_k_on_ssl_connected), 0, 0, 1, 1},
+  {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1},
+  {&__pyx_kp_u_open__StreamWriteContext_is_bein, __pyx_k_open__StreamWriteContext_is_bein, sizeof(__pyx_k_open__StreamWriteContext_is_bein), 0, 1, 0, 0},
+  {&__pyx_kp_u_open__UDPSendContext_is_being_de, __pyx_k_open__UDPSendContext_is_being_de, sizeof(__pyx_k_open__UDPSendContext_is_being_de), 0, 1, 0, 0},
+  {&__pyx_n_s_os, __pyx_k_os, sizeof(__pyx_k_os), 0, 0, 1, 1},
+  {&__pyx_n_s_partial, __pyx_k_partial, sizeof(__pyx_k_partial), 0, 0, 1, 1},
+  {&__pyx_n_s_pass_fds, __pyx_k_pass_fds, sizeof(__pyx_k_pass_fds), 0, 0, 1, 1},
+  {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1},
+  {&__pyx_kp_u_path_and_sock_can_not_be_specifi, __pyx_k_path_and_sock_can_not_be_specifi, sizeof(__pyx_k_path_and_sock_can_not_be_specifi), 0, 1, 0, 0},
+  {&__pyx_kp_u_path_was_not_specified_and_no_so, __pyx_k_path_was_not_specified_and_no_so, sizeof(__pyx_k_path_was_not_specified_and_no_so), 0, 1, 0, 0},
+  {&__pyx_n_s_pause_reading, __pyx_k_pause_reading, sizeof(__pyx_k_pause_reading), 0, 0, 1, 1},
+  {&__pyx_n_s_pause_writing, __pyx_k_pause_writing, sizeof(__pyx_k_pause_writing), 0, 0, 1, 1},
+  {&__pyx_n_s_peercert, __pyx_k_peercert, sizeof(__pyx_k_peercert), 0, 0, 1, 1},
+  {&__pyx_n_u_peername, __pyx_k_peername, sizeof(__pyx_k_peername), 0, 1, 0, 1},
+  {&__pyx_n_s_pending, __pyx_k_pending, sizeof(__pyx_k_pending), 0, 0, 1, 1},
+  {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1},
+  {&__pyx_n_s_pipe, __pyx_k_pipe, sizeof(__pyx_k_pipe), 0, 0, 1, 1},
+  {&__pyx_n_u_pipe, __pyx_k_pipe, sizeof(__pyx_k_pipe), 0, 1, 0, 1},
+  {&__pyx_kp_u_pipe_2, __pyx_k_pipe_2, sizeof(__pyx_k_pipe_2), 0, 1, 0, 0},
+  {&__pyx_n_s_pipe_connection_lost, __pyx_k_pipe_connection_lost, sizeof(__pyx_k_pipe_connection_lost), 0, 0, 1, 1},
+  {&__pyx_n_s_pipe_data_received, __pyx_k_pipe_data_received, sizeof(__pyx_k_pipe_data_received), 0, 0, 1, 1},
+  {&__pyx_n_s_platform, __pyx_k_platform, sizeof(__pyx_k_platform), 0, 0, 1, 1},
+  {&__pyx_n_s_pop, __pyx_k_pop, sizeof(__pyx_k_pop), 0, 0, 1, 1},
+  {&__pyx_n_s_popitem, __pyx_k_popitem, sizeof(__pyx_k_popitem), 0, 0, 1, 1},
+  {&__pyx_n_s_popleft, __pyx_k_popleft, sizeof(__pyx_k_popleft), 0, 0, 1, 1},
+  {&__pyx_n_s_port, __pyx_k_port, sizeof(__pyx_k_port), 0, 0, 1, 1},
+  {&__pyx_kp_u_port_must_be_a_str_bytes_or_int, __pyx_k_port_must_be_a_str_bytes_or_int, sizeof(__pyx_k_port_must_be_a_str_bytes_or_int), 0, 1, 0, 0},
+  {&__pyx_n_u_posix, __pyx_k_posix, sizeof(__pyx_k_posix), 0, 1, 0, 1},
+  {&__pyx_n_s_preexec_fn, __pyx_k_preexec_fn, sizeof(__pyx_k_preexec_fn), 0, 0, 1, 1},
+  {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1},
+  {&__pyx_n_s_print, __pyx_k_print, sizeof(__pyx_k_print), 0, 0, 1, 1},
+  {&__pyx_n_u_print_debug_info, __pyx_k_print_debug_info, sizeof(__pyx_k_print_debug_info), 0, 1, 0, 1},
+  {&__pyx_n_s_proc, __pyx_k_proc, sizeof(__pyx_k_proc), 0, 0, 1, 1},
+  {&__pyx_n_s_process_exited, __pyx_k_process_exited, sizeof(__pyx_k_process_exited), 0, 0, 1, 1},
+  {&__pyx_n_s_program, __pyx_k_program, sizeof(__pyx_k_program), 0, 0, 1, 1},
+  {&__pyx_n_s_proto, __pyx_k_proto, sizeof(__pyx_k_proto), 0, 0, 1, 1},
+  {&__pyx_n_s_proto_factory, __pyx_k_proto_factory, sizeof(__pyx_k_proto_factory), 0, 0, 1, 1},
+  {&__pyx_n_s_protocol, __pyx_k_protocol, sizeof(__pyx_k_protocol), 0, 0, 1, 1},
+  {&__pyx_n_u_protocol, __pyx_k_protocol, sizeof(__pyx_k_protocol), 0, 1, 0, 1},
+  {&__pyx_n_s_protocol_factory, __pyx_k_protocol_factory, sizeof(__pyx_k_protocol_factory), 0, 0, 1, 1},
+  {&__pyx_kp_u_protocol_is_not_set_cannot_call, __pyx_k_protocol_is_not_set_cannot_call, sizeof(__pyx_k_protocol_is_not_set_cannot_call), 0, 1, 0, 0},
+  {&__pyx_kp_u_protocol_is_required, __pyx_k_protocol_is_required, sizeof(__pyx_k_protocol_is_required), 0, 1, 0, 0},
+  {&__pyx_kp_u_protocol_pause_writing_failed, __pyx_k_protocol_pause_writing_failed, sizeof(__pyx_k_protocol_pause_writing_failed), 0, 1, 0, 0},
+  {&__pyx_kp_u_protocol_resume_writing_failed, __pyx_k_protocol_resume_writing_failed, sizeof(__pyx_k_protocol_resume_writing_failed), 0, 1, 0, 0},
+  {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 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_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_unpickle_LruCache, __pyx_k_pyx_unpickle_LruCache, sizeof(__pyx_k_pyx_unpickle_LruCache), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_unpickle_PseudoSocket, __pyx_k_pyx_unpickle_PseudoSocket, sizeof(__pyx_k_pyx_unpickle_PseudoSocket), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1},
+  {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1},
+  {&__pyx_n_u_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 1, 0, 1},
+  {&__pyx_kp_u_r_SSL_handshake_took_1f_ms, __pyx_k_r_SSL_handshake_took_1f_ms, sizeof(__pyx_k_r_SSL_handshake_took_1f_ms), 0, 1, 0, 0},
+  {&__pyx_kp_u_r_fileno_returned_non_integer, __pyx_k_r_fileno_returned_non_integer, sizeof(__pyx_k_r_fileno_returned_non_integer), 0, 1, 0, 0},
+  {&__pyx_kp_u_r_received_EOF, __pyx_k_r_received_EOF, sizeof(__pyx_k_r_received_EOF), 0, 1, 0, 0},
+  {&__pyx_kp_u_r_s, __pyx_k_r_s, sizeof(__pyx_k_r_s), 0, 1, 0, 0},
+  {&__pyx_kp_u_r_starts_SSL_handshake, __pyx_k_r_starts_SSL_handshake, sizeof(__pyx_k_r_starts_SSL_handshake), 0, 1, 0, 0},
+  {&__pyx_kp_u_raddr_s, __pyx_k_raddr_s, sizeof(__pyx_k_raddr_s), 0, 1, 0, 0},
+  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
+  {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1},
+  {&__pyx_n_s_recv, __pyx_k_recv, sizeof(__pyx_k_recv), 0, 0, 1, 1},
+  {&__pyx_n_s_recv_into, __pyx_k_recv_into, sizeof(__pyx_k_recv_into), 0, 0, 1, 1},
+  {&__pyx_kp_u_recv_into_method, __pyx_k_recv_into_method, sizeof(__pyx_k_recv_into_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_recv_method, __pyx_k_recv_method, sizeof(__pyx_k_recv_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_recvfrom_into_method, __pyx_k_recvfrom_into_method, sizeof(__pyx_k_recvfrom_into_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_recvfrom_method, __pyx_k_recvfrom_method, sizeof(__pyx_k_recvfrom_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_recvmsg_into_method, __pyx_k_recvmsg_into_method, sizeof(__pyx_k_recvmsg_into_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_recvmsg_method, __pyx_k_recvmsg_method, sizeof(__pyx_k_recvmsg_method), 0, 1, 0, 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_remote_addr, __pyx_k_remote_addr, sizeof(__pyx_k_remote_addr), 0, 0, 1, 1},
+  {&__pyx_kp_u_remote_addr_must_be_a_tuple_of_h, __pyx_k_remote_addr_must_be_a_tuple_of_h, sizeof(__pyx_k_remote_addr_must_be_a_tuple_of_h), 0, 1, 0, 0},
+  {&__pyx_n_s_remove, __pyx_k_remove, sizeof(__pyx_k_remove), 0, 0, 1, 1},
+  {&__pyx_n_s_remove_done_callback, __pyx_k_remove_done_callback, sizeof(__pyx_k_remove_done_callback), 0, 0, 1, 1},
+  {&__pyx_n_s_remove_reader, __pyx_k_remove_reader, sizeof(__pyx_k_remove_reader), 0, 0, 1, 1},
+  {&__pyx_n_s_remove_reader_2, __pyx_k_remove_reader_2, sizeof(__pyx_k_remove_reader_2), 0, 0, 1, 1},
+  {&__pyx_n_s_remove_signal_handler, __pyx_k_remove_signal_handler, sizeof(__pyx_k_remove_signal_handler), 0, 0, 1, 1},
+  {&__pyx_kp_u_remove_signal_handler_can_only_b, __pyx_k_remove_signal_handler_can_only_b, sizeof(__pyx_k_remove_signal_handler_can_only_b), 0, 1, 0, 0},
+  {&__pyx_n_s_remove_writer, __pyx_k_remove_writer, sizeof(__pyx_k_remove_writer), 0, 0, 1, 1},
+  {&__pyx_n_s_remove_writer_2, __pyx_k_remove_writer_2, sizeof(__pyx_k_remove_writer_2), 0, 0, 1, 1},
+  {&__pyx_n_s_repr, __pyx_k_repr, sizeof(__pyx_k_repr), 0, 0, 1, 1},
+  {&__pyx_n_s_restore_signals, __pyx_k_restore_signals, sizeof(__pyx_k_restore_signals), 0, 0, 1, 1},
+  {&__pyx_n_s_result, __pyx_k_result, sizeof(__pyx_k_result), 0, 0, 1, 1},
+  {&__pyx_n_s_resume_reading, __pyx_k_resume_reading, sizeof(__pyx_k_resume_reading), 0, 0, 1, 1},
+  {&__pyx_n_s_resume_writing, __pyx_k_resume_writing, sizeof(__pyx_k_resume_writing), 0, 0, 1, 1},
+  {&__pyx_n_s_return_exceptions, __pyx_k_return_exceptions, sizeof(__pyx_k_return_exceptions), 0, 0, 1, 1},
+  {&__pyx_kp_u_returning_true_from_eof_received, __pyx_k_returning_true_from_eof_received, sizeof(__pyx_k_returning_true_from_eof_received), 0, 1, 0, 0},
+  {&__pyx_n_s_reuse_address, __pyx_k_reuse_address, sizeof(__pyx_k_reuse_address), 0, 0, 1, 1},
+  {&__pyx_n_s_reuse_port, __pyx_k_reuse_port, sizeof(__pyx_k_reuse_port), 0, 0, 1, 1},
+  {&__pyx_kp_u_reuse_port_not_supported_by_sock, __pyx_k_reuse_port_not_supported_by_sock, sizeof(__pyx_k_reuse_port_not_supported_by_sock), 0, 1, 0, 0},
+  {&__pyx_n_s_reverse, __pyx_k_reverse, sizeof(__pyx_k_reverse), 0, 0, 1, 1},
+  {&__pyx_n_s_round, __pyx_k_round, sizeof(__pyx_k_round), 0, 0, 1, 1},
+  {&__pyx_n_s_rstrip, __pyx_k_rstrip, sizeof(__pyx_k_rstrip), 0, 0, 1, 1},
+  {&__pyx_n_s_run, __pyx_k_run, sizeof(__pyx_k_run), 0, 0, 1, 1},
+  {&__pyx_n_s_run_forever, __pyx_k_run_forever, sizeof(__pyx_k_run_forever), 0, 0, 1, 1},
+  {&__pyx_n_s_run_until_complete_locals_done_c, __pyx_k_run_until_complete_locals_done_c, sizeof(__pyx_k_run_until_complete_locals_done_c), 0, 0, 1, 1},
+  {&__pyx_kp_u_running_closed_debug, __pyx_k_running_closed_debug, sizeof(__pyx_k_running_closed_debug), 0, 1, 0, 0},
+  {&__pyx_kp_u_seconds_aborting_the_connection, __pyx_k_seconds_aborting_the_connection, sizeof(__pyx_k_seconds_aborting_the_connection), 0, 1, 0, 0},
+  {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+  {&__pyx_n_u_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 1, 0, 1},
+  {&__pyx_n_s_self_2, __pyx_k_self_2, sizeof(__pyx_k_self_2), 0, 0, 1, 1},
+  {&__pyx_kp_u_self_pipe_exists_before_loop_run, __pyx_k_self_pipe_exists_before_loop_run, sizeof(__pyx_k_self_pipe_exists_before_loop_run), 0, 1, 0, 0},
+  {&__pyx_kp_u_self_pipe_was_not_cleaned_up_aft, __pyx_k_self_pipe_was_not_cleaned_up_aft, sizeof(__pyx_k_self_pipe_was_not_cleaned_up_aft), 0, 1, 0, 0},
+  {&__pyx_kp_s_self_py_buf_self_req_cannot_be_c, __pyx_k_self_py_buf_self_req_cannot_be_c, sizeof(__pyx_k_self_py_buf_self_req_cannot_be_c), 0, 0, 1, 0},
+  {&__pyx_kp_s_self_py_bufs_self_py_bufs_sml_se, __pyx_k_self_py_bufs_self_py_bufs_sml_se, sizeof(__pyx_k_self_py_bufs_self_py_bufs_sml_se), 0, 0, 1, 0},
+  {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1},
+  {&__pyx_kp_u_send_method, __pyx_k_send_method, sizeof(__pyx_k_send_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_sendall_method, __pyx_k_sendall_method, sizeof(__pyx_k_sendall_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_sendfile_method, __pyx_k_sendfile_method, sizeof(__pyx_k_sendfile_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_sendmsg_afalg_method, __pyx_k_sendmsg_afalg_method, sizeof(__pyx_k_sendmsg_afalg_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_sendmsg_method, __pyx_k_sendmsg_method, sizeof(__pyx_k_sendmsg_method), 0, 1, 0, 0},
+  {&__pyx_kp_u_sendto_method, __pyx_k_sendto_method, sizeof(__pyx_k_sendto_method), 0, 1, 0, 0},
+  {&__pyx_n_s_serve_forever, __pyx_k_serve_forever, sizeof(__pyx_k_serve_forever), 0, 0, 1, 1},
+  {&__pyx_kp_u_server, __pyx_k_server, sizeof(__pyx_k_server), 0, 1, 0, 0},
+  {&__pyx_n_s_server_hostname, __pyx_k_server_hostname, sizeof(__pyx_k_server_hostname), 0, 0, 1, 1},
+  {&__pyx_kp_u_server_hostname_is_only_meaningf, __pyx_k_server_hostname_is_only_meaningf, sizeof(__pyx_k_server_hostname_is_only_meaningf), 0, 1, 0, 0},
+  {&__pyx_n_s_server_side, __pyx_k_server_side, sizeof(__pyx_k_server_side), 0, 0, 1, 1},
+  {&__pyx_kp_u_service_proto_not_found, __pyx_k_service_proto_not_found, sizeof(__pyx_k_service_proto_not_found), 0, 1, 0, 0},
+  {&__pyx_n_s_set_asyncgen_hooks, __pyx_k_set_asyncgen_hooks, sizeof(__pyx_k_set_asyncgen_hooks), 0, 0, 1, 1},
+  {&__pyx_n_s_set_coroutine_origin_tracking_de, __pyx_k_set_coroutine_origin_tracking_de, sizeof(__pyx_k_set_coroutine_origin_tracking_de), 0, 0, 1, 1},
+  {&__pyx_n_u_set_coroutine_wrapper, __pyx_k_set_coroutine_wrapper, sizeof(__pyx_k_set_coroutine_wrapper), 0, 1, 0, 1},
+  {&__pyx_n_s_set_debug, __pyx_k_set_debug, sizeof(__pyx_k_set_debug), 0, 0, 1, 1},
+  {&__pyx_n_s_set_exception, __pyx_k_set_exception, sizeof(__pyx_k_set_exception), 0, 0, 1, 1},
+  {&__pyx_n_s_set_inheritable, __pyx_k_set_inheritable, sizeof(__pyx_k_set_inheritable), 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_set_protocol, __pyx_k_set_protocol, sizeof(__pyx_k_set_protocol), 0, 0, 1, 1},
+  {&__pyx_n_s_set_result, __pyx_k_set_result, sizeof(__pyx_k_set_result), 0, 0, 1, 1},
+  {&__pyx_n_u_set_running_loop, __pyx_k_set_running_loop, sizeof(__pyx_k_set_running_loop), 0, 1, 0, 1},
+  {&__pyx_n_s_set_wakeup_fd, __pyx_k_set_wakeup_fd, sizeof(__pyx_k_set_wakeup_fd), 0, 0, 1, 1},
+  {&__pyx_kp_u_set_wakeup_fd_1_failed_s, __pyx_k_set_wakeup_fd_1_failed_s, sizeof(__pyx_k_set_wakeup_fd_1_failed_s), 0, 1, 0, 0},
+  {&__pyx_n_s_setblocking, __pyx_k_setblocking, sizeof(__pyx_k_setblocking), 0, 0, 1, 1},
+  {&__pyx_kp_u_setblocking_transport_sockets_ca, __pyx_k_setblocking_transport_sockets_ca, sizeof(__pyx_k_setblocking_transport_sockets_ca), 0, 1, 0, 0},
+  {&__pyx_n_s_setsockopt, __pyx_k_setsockopt, sizeof(__pyx_k_setsockopt), 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_settimeout, __pyx_k_settimeout, sizeof(__pyx_k_settimeout), 0, 0, 1, 1},
+  {&__pyx_kp_u_settimeout_only_0_timeout_is_all, __pyx_k_settimeout_only_0_timeout_is_all, sizeof(__pyx_k_settimeout_only_0_timeout_is_all), 0, 1, 0, 0},
+  {&__pyx_n_s_share, __pyx_k_share, sizeof(__pyx_k_share), 0, 0, 1, 1},
+  {&__pyx_n_s_shell, __pyx_k_shell, sizeof(__pyx_k_shell), 0, 0, 1, 1},
+  {&__pyx_kp_u_shell_must_be_False, __pyx_k_shell_must_be_False, sizeof(__pyx_k_shell_must_be_False), 0, 1, 0, 0},
+  {&__pyx_kp_u_shell_must_be_True, __pyx_k_shell_must_be_True, sizeof(__pyx_k_shell_must_be_True), 0, 1, 0, 0},
+  {&__pyx_n_s_shutdown, __pyx_k_shutdown, sizeof(__pyx_k_shutdown), 0, 0, 1, 1},
+  {&__pyx_n_s_shutdown_asyncgens, __pyx_k_shutdown_asyncgens, sizeof(__pyx_k_shutdown_asyncgens), 0, 0, 1, 1},
+  {&__pyx_n_s_shutdown_default_executor, __pyx_k_shutdown_default_executor, sizeof(__pyx_k_shutdown_default_executor), 0, 0, 1, 1},
+  {&__pyx_kp_u_shutdown_method, __pyx_k_shutdown_method, sizeof(__pyx_k_shutdown_method), 0, 1, 0, 0},
+  {&__pyx_n_s_sig, __pyx_k_sig, sizeof(__pyx_k_sig), 0, 0, 1, 1},
+  {&__pyx_kp_u_sig_cannot_be_caught, __pyx_k_sig_cannot_be_caught, sizeof(__pyx_k_sig_cannot_be_caught), 0, 1, 0, 0},
+  {&__pyx_kp_u_sig_must_be_an_int_not_r, __pyx_k_sig_must_be_an_int_not_r, sizeof(__pyx_k_sig_must_be_an_int_not_r), 0, 1, 0, 0},
+  {&__pyx_kp_u_sig_out_of_range_1, __pyx_k_sig_out_of_range_1, sizeof(__pyx_k_sig_out_of_range_1), 0, 1, 0, 0},
+  {&__pyx_n_s_sighandler, __pyx_k_sighandler, sizeof(__pyx_k_sighandler), 0, 0, 1, 1},
+  {&__pyx_n_s_siginterrupt, __pyx_k_siginterrupt, sizeof(__pyx_k_siginterrupt), 0, 0, 1, 1},
+  {&__pyx_n_s_signal, __pyx_k_signal, sizeof(__pyx_k_signal), 0, 0, 1, 1},
+  {&__pyx_kp_u_signals_handling_has_been_alread, __pyx_k_signals_handling_has_been_alread, sizeof(__pyx_k_signals_handling_has_been_alread), 0, 1, 0, 0},
+  {&__pyx_kp_u_signals_handling_has_not_been_se, __pyx_k_signals_handling_has_not_been_se, sizeof(__pyx_k_signals_handling_has_not_been_se), 0, 1, 0, 0},
+  {&__pyx_n_s_signum, __pyx_k_signum, sizeof(__pyx_k_signum), 0, 0, 1, 1},
+  {&__pyx_n_s_sleep, __pyx_k_sleep, sizeof(__pyx_k_sleep), 0, 0, 1, 1},
+  {&__pyx_n_s_sock, __pyx_k_sock, sizeof(__pyx_k_sock), 0, 0, 1, 1},
+  {&__pyx_n_s_sock_accept, __pyx_k_sock_accept, sizeof(__pyx_k_sock_accept), 0, 0, 1, 1},
+  {&__pyx_n_s_sock_connect, __pyx_k_sock_connect, sizeof(__pyx_k_sock_connect), 0, 0, 1, 1},
+  {&__pyx_kp_u_sock_connect_cb_is_called_on_a, __pyx_k_sock_connect_cb_is_called_on_a, sizeof(__pyx_k_sock_connect_cb_is_called_on_a), 0, 1, 0, 0},
+  {&__pyx_n_s_sock_recv, __pyx_k_sock_recv, sizeof(__pyx_k_sock_recv), 0, 0, 1, 1},
+  {&__pyx_n_s_sock_recv_into, __pyx_k_sock_recv_into, sizeof(__pyx_k_sock_recv_into), 0, 0, 1, 1},
+  {&__pyx_kp_u_sock_recv_into_is_called_on_a_c, __pyx_k_sock_recv_into_is_called_on_a_c, sizeof(__pyx_k_sock_recv_into_is_called_on_a_c), 0, 1, 0, 0},
+  {&__pyx_kp_u_sock_recv_is_called_on_a_cancel, __pyx_k_sock_recv_is_called_on_a_cancel, sizeof(__pyx_k_sock_recv_is_called_on_a_cancel), 0, 1, 0, 0},
+  {&__pyx_n_s_sock_sendall, __pyx_k_sock_sendall, sizeof(__pyx_k_sock_sendall), 0, 0, 1, 1},
+  {&__pyx_kp_u_sock_sendall_is_called_on_a_can, __pyx_k_sock_sendall_is_called_on_a_can, sizeof(__pyx_k_sock_sendall_is_called_on_a_can), 0, 1, 0, 0},
+  {&__pyx_n_s_sockaddr, __pyx_k_sockaddr, sizeof(__pyx_k_sockaddr), 0, 0, 1, 1},
+  {&__pyx_kp_u_sockaddr_must_be_a_tuple_of_2_3, __pyx_k_sockaddr_must_be_a_tuple_of_2_3, sizeof(__pyx_k_sockaddr_must_be_a_tuple_of_2_3), 0, 1, 0, 0},
+  {&__pyx_kp_u_sockaddr_resolved_to_multiple_ad, __pyx_k_sockaddr_resolved_to_multiple_ad, sizeof(__pyx_k_sockaddr_resolved_to_multiple_ad), 0, 1, 0, 0},
+  {&__pyx_kp_u_socket, __pyx_k_socket, sizeof(__pyx_k_socket), 0, 1, 0, 0},
+  {&__pyx_n_s_socket_2, __pyx_k_socket_2, sizeof(__pyx_k_socket_2), 0, 0, 1, 1},
+  {&__pyx_n_u_socket_2, __pyx_k_socket_2, sizeof(__pyx_k_socket_2), 0, 1, 0, 1},
+  {&__pyx_kp_u_socket_family_mismatch_or_a_DNS, __pyx_k_socket_family_mismatch_or_a_DNS, sizeof(__pyx_k_socket_family_mismatch_or_a_DNS), 0, 1, 0, 0},
+  {&__pyx_kp_u_socket_modifier_keyword_argument, __pyx_k_socket_modifier_keyword_argument, sizeof(__pyx_k_socket_modifier_keyword_argument), 0, 1, 0, 0},
+  {&__pyx_kp_u_socket_send_raised_exception, __pyx_k_socket_send_raised_exception, sizeof(__pyx_k_socket_send_raised_exception), 0, 1, 0, 0},
+  {&__pyx_n_s_socketpair, __pyx_k_socketpair, sizeof(__pyx_k_socketpair), 0, 0, 1, 1},
+  {&__pyx_kp_u_sockets, __pyx_k_sockets, sizeof(__pyx_k_sockets), 0, 1, 0, 0},
+  {&__pyx_n_s_sockets_2, __pyx_k_sockets_2, sizeof(__pyx_k_sockets_2), 0, 0, 1, 1},
+  {&__pyx_n_u_sockname, __pyx_k_sockname, sizeof(__pyx_k_sockname), 0, 1, 0, 1},
+  {&__pyx_n_s_source, __pyx_k_source, sizeof(__pyx_k_source), 0, 0, 1, 1},
+  {&__pyx_n_u_source_traceback, __pyx_k_source_traceback, sizeof(__pyx_k_source_traceback), 0, 1, 0, 1},
+  {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1},
+  {&__pyx_n_s_ssl, __pyx_k_ssl, sizeof(__pyx_k_ssl), 0, 0, 1, 1},
+  {&__pyx_kp_u_ssl_argument_must_be_an_SSLConte, __pyx_k_ssl_argument_must_be_an_SSLConte, sizeof(__pyx_k_ssl_argument_must_be_an_SSLConte), 0, 1, 0, 0},
+  {&__pyx_n_s_ssl_handshake_timeout, __pyx_k_ssl_handshake_timeout, sizeof(__pyx_k_ssl_handshake_timeout), 0, 0, 1, 1},
+  {&__pyx_kp_u_ssl_handshake_timeout_is_only_me, __pyx_k_ssl_handshake_timeout_is_only_me, sizeof(__pyx_k_ssl_handshake_timeout_is_only_me), 0, 1, 0, 0},
+  {&__pyx_kp_u_ssl_handshake_timeout_should_be, __pyx_k_ssl_handshake_timeout_should_be, sizeof(__pyx_k_ssl_handshake_timeout_should_be), 0, 1, 0, 0},
+  {&__pyx_kp_u_ssl_is_expected_to_be_None_or_an, __pyx_k_ssl_is_expected_to_be_None_or_an, sizeof(__pyx_k_ssl_is_expected_to_be_None_or_an), 0, 1, 0, 0},
+  {&__pyx_n_s_ssl_object, __pyx_k_ssl_object, sizeof(__pyx_k_ssl_object), 0, 0, 1, 1},
+  {&__pyx_n_s_ssl_protocol, __pyx_k_ssl_protocol, sizeof(__pyx_k_ssl_protocol), 0, 0, 1, 1},
+  {&__pyx_n_s_ssl_shutdown_timeout, __pyx_k_ssl_shutdown_timeout, sizeof(__pyx_k_ssl_shutdown_timeout), 0, 0, 1, 1},
+  {&__pyx_kp_u_ssl_shutdown_timeout_is_only_mea, __pyx_k_ssl_shutdown_timeout_is_only_mea, sizeof(__pyx_k_ssl_shutdown_timeout_is_only_mea), 0, 1, 0, 0},
+  {&__pyx_kp_u_ssl_shutdown_timeout_should_be_a, __pyx_k_ssl_shutdown_timeout_should_be_a, sizeof(__pyx_k_ssl_shutdown_timeout_should_be_a), 0, 1, 0, 0},
+  {&__pyx_n_s_sslcontext, __pyx_k_sslcontext, sizeof(__pyx_k_sslcontext), 0, 0, 1, 1},
+  {&__pyx_kp_u_sslcontext_is_expected_to_be_an, __pyx_k_sslcontext_is_expected_to_be_an, sizeof(__pyx_k_sslcontext_is_expected_to_be_an), 0, 1, 0, 0},
+  {&__pyx_n_s_st_mode, __pyx_k_st_mode, sizeof(__pyx_k_st_mode), 0, 0, 1, 1},
+  {&__pyx_n_s_stacklevel, __pyx_k_stacklevel, sizeof(__pyx_k_stacklevel), 0, 0, 1, 1},
+  {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1},
+  {&__pyx_kp_u_start_init_can_only_be_called, __pyx_k_start_init_can_only_be_called, sizeof(__pyx_k_start_init_can_only_be_called), 0, 1, 0, 0},
+  {&__pyx_n_s_start_new_session, __pyx_k_start_new_session, sizeof(__pyx_k_start_new_session), 0, 0, 1, 1},
+  {&__pyx_n_s_start_serving, __pyx_k_start_serving, sizeof(__pyx_k_start_serving), 0, 0, 1, 1},
+  {&__pyx_n_s_start_tls, __pyx_k_start_tls, sizeof(__pyx_k_start_tls), 0, 0, 1, 1},
+  {&__pyx_n_s_startupinfo, __pyx_k_startupinfo, sizeof(__pyx_k_startupinfo), 0, 0, 1, 1},
+  {&__pyx_kp_u_startupinfo_is_not_supported, __pyx_k_startupinfo_is_not_supported, sizeof(__pyx_k_startupinfo_is_not_supported), 0, 1, 0, 0},
+  {&__pyx_n_s_stat, __pyx_k_stat, sizeof(__pyx_k_stat), 0, 0, 1, 1},
+  {&__pyx_n_s_stderr, __pyx_k_stderr, sizeof(__pyx_k_stderr), 0, 0, 1, 1},
+  {&__pyx_n_s_stdin, __pyx_k_stdin, sizeof(__pyx_k_stdin), 0, 0, 1, 1},
+  {&__pyx_n_s_stdio_fut, __pyx_k_stdio_fut, sizeof(__pyx_k_stdio_fut), 0, 0, 1, 1},
+  {&__pyx_n_s_stdio_inited, __pyx_k_stdio_inited, sizeof(__pyx_k_stdio_inited), 0, 0, 1, 1},
+  {&__pyx_n_s_stdout, __pyx_k_stdout, sizeof(__pyx_k_stdout), 0, 0, 1, 1},
+  {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1},
+  {&__pyx_kp_u_stream_is_open_after_UVStream__t, __pyx_k_stream_is_open_after_UVStream__t, sizeof(__pyx_k_stream_is_open_after_UVStream__t), 0, 1, 0, 0},
+  {&__pyx_n_s_strerror, __pyx_k_strerror, sizeof(__pyx_k_strerror), 0, 0, 1, 1},
+  {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+  {&__pyx_n_s_submit, __pyx_k_submit, sizeof(__pyx_k_submit), 0, 0, 1, 1},
+  {&__pyx_n_s_subprocess, __pyx_k_subprocess, sizeof(__pyx_k_subprocess), 0, 0, 1, 1},
+  {&__pyx_kp_u_subprocess_STDOUT_is_supported_o, __pyx_k_subprocess_STDOUT_is_supported_o, sizeof(__pyx_k_subprocess_STDOUT_is_supported_o), 0, 1, 0, 0},
+  {&__pyx_n_s_subprocess_exec, __pyx_k_subprocess_exec, sizeof(__pyx_k_subprocess_exec), 0, 0, 1, 1},
+  {&__pyx_n_s_subprocess_run, __pyx_k_subprocess_run, sizeof(__pyx_k_subprocess_run), 0, 0, 1, 1},
+  {&__pyx_n_s_subprocess_shell, __pyx_k_subprocess_shell, sizeof(__pyx_k_subprocess_shell), 0, 0, 1, 1},
+  {&__pyx_n_s_subtract, __pyx_k_subtract, sizeof(__pyx_k_subtract), 0, 0, 1, 1},
+  {&__pyx_n_s_super, __pyx_k_super, sizeof(__pyx_k_super), 0, 0, 1, 1},
+  {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1},
+  {&__pyx_n_s_target, __pyx_k_target, sizeof(__pyx_k_target), 0, 0, 1, 1},
+  {&__pyx_n_u_task, __pyx_k_task, sizeof(__pyx_k_task), 0, 1, 0, 1},
+  {&__pyx_kp_u_task_factory_must_be_a_callable, __pyx_k_task_factory_must_be_a_callable, sizeof(__pyx_k_task_factory_must_be_a_callable), 0, 1, 0, 0},
+  {&__pyx_n_u_tcp, __pyx_k_tcp, sizeof(__pyx_k_tcp), 0, 1, 0, 1},
+  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+  {&__pyx_n_s_test_coroutine_1, __pyx_k_test_coroutine_1, sizeof(__pyx_k_test_coroutine_1), 0, 0, 1, 1},
+  {&__pyx_kp_u_the_socket_must_be_non_blocking, __pyx_k_the_socket_must_be_non_blocking, sizeof(__pyx_k_the_socket_must_be_non_blocking), 0, 1, 0, 0},
+  {&__pyx_kp_u_this_event_loop_is_already_runni, __pyx_k_this_event_loop_is_already_runni, sizeof(__pyx_k_this_event_loop_is_already_runni), 0, 1, 0, 0},
+  {&__pyx_n_s_threading, __pyx_k_threading, sizeof(__pyx_k_threading), 0, 0, 1, 1},
+  {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1},
+  {&__pyx_n_s_time, __pyx_k_time, sizeof(__pyx_k_time), 0, 0, 1, 1},
+  {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1},
+  {&__pyx_n_s_traceback, __pyx_k_traceback, sizeof(__pyx_k_traceback), 0, 0, 1, 1},
+  {&__pyx_n_s_traceback_2, __pyx_k_traceback_2, sizeof(__pyx_k_traceback_2), 0, 0, 1, 1},
+  {&__pyx_n_s_transport, __pyx_k_transport, sizeof(__pyx_k_transport), 0, 0, 1, 1},
+  {&__pyx_n_u_transport, __pyx_k_transport, sizeof(__pyx_k_transport), 0, 1, 0, 1},
+  {&__pyx_kp_u_transport_2, __pyx_k_transport_2, sizeof(__pyx_k_transport_2), 0, 1, 0, 0},
+  {&__pyx_kp_u_transport_sockets_do_not_support, __pyx_k_transport_sockets_do_not_support, sizeof(__pyx_k_transport_sockets_do_not_support), 0, 1, 0, 0},
+  {&__pyx_n_s_transports, __pyx_k_transports, sizeof(__pyx_k_transports), 0, 0, 1, 1},
+  {&__pyx_kp_u_try_write_sent_all_data_and_ret, __pyx_k_try_write_sent_all_data_and_ret, sizeof(__pyx_k_try_write_sent_all_data_and_ret), 0, 1, 0, 0},
+  {&__pyx_n_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1},
+  {&__pyx_n_u_udp, __pyx_k_udp, sizeof(__pyx_k_udp), 0, 1, 0, 1},
+  {&__pyx_kp_u_unable_to_listen_no_protocol_fac, __pyx_k_unable_to_listen_no_protocol_fac, sizeof(__pyx_k_unable_to_listen_no_protocol_fac), 0, 1, 0, 0},
+  {&__pyx_kp_u_unable_to_perform_operation_on_r, __pyx_k_unable_to_perform_operation_on_r, sizeof(__pyx_k_unable_to_perform_operation_on_r), 0, 1, 0, 0},
+  {&__pyx_kp_u_unable_to_start_the_loop_it_was, __pyx_k_unable_to_start_the_loop_it_was, sizeof(__pyx_k_unable_to_start_the_loop_it_was), 0, 1, 0, 0},
+  {&__pyx_kp_u_unclosed_resource_r, __pyx_k_unclosed_resource_r, sizeof(__pyx_k_unclosed_resource_r), 0, 1, 0, 0},
+  {&__pyx_kp_u_unclosed_resource_r_2, __pyx_k_unclosed_resource_r_2, sizeof(__pyx_k_unclosed_resource_r_2), 0, 1, 0, 0},
+  {&__pyx_kp_u_unclosed_resource_r_could_not_se, __pyx_k_unclosed_resource_r_could_not_se, sizeof(__pyx_k_unclosed_resource_r_could_not_se), 0, 1, 0, 0},
+  {&__pyx_kp_u_unclosed_transport_uvloop_loop, __pyx_k_unclosed_transport_uvloop_loop, sizeof(__pyx_k_unclosed_transport_uvloop_loop), 0, 1, 0, 0},
+  {&__pyx_kp_u_unexpected_address_family, __pyx_k_unexpected_address_family, sizeof(__pyx_k_unexpected_address_family), 0, 1, 0, 0},
+  {&__pyx_kp_u_unhandled_error_or_an_empty_buff, __pyx_k_unhandled_error_or_an_empty_buff, sizeof(__pyx_k_unhandled_error_or_an_empty_buff), 0, 1, 0, 0},
+  {&__pyx_n_s_universal_newlines, __pyx_k_universal_newlines, sizeof(__pyx_k_universal_newlines), 0, 0, 1, 1},
+  {&__pyx_kp_u_universal_newlines_must_be_False, __pyx_k_universal_newlines_must_be_False, sizeof(__pyx_k_universal_newlines_must_be_False), 0, 1, 0, 0},
+  {&__pyx_kp_u_unix_socket_path, __pyx_k_unix_socket_path, sizeof(__pyx_k_unix_socket_path), 0, 1, 0, 0},
+  {&__pyx_kp_u_unopened_TCPServer, __pyx_k_unopened_TCPServer, sizeof(__pyx_k_unopened_TCPServer), 0, 1, 0, 0},
+  {&__pyx_n_s_unset, __pyx_k_unset, sizeof(__pyx_k_unset), 0, 0, 1, 1},
+  {&__pyx_n_s_unwrap, __pyx_k_unwrap, sizeof(__pyx_k_unwrap), 0, 0, 1, 1},
+  {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1},
+  {&__pyx_kp_u_uv_close_handle_cb_handle_loop, __pyx_k_uv_close_handle_cb_handle_loop, sizeof(__pyx_k_uv_close_handle_cb_handle_loop), 0, 1, 0, 0},
+  {&__pyx_kp_u_uv_handle_t_current_freed_total, __pyx_k_uv_handle_t_current_freed_total, sizeof(__pyx_k_uv_handle_t_current_freed_total), 0, 1, 0, 0},
+  {&__pyx_kp_u_uvloop_PseudoSocket_fd_family_s, __pyx_k_uvloop_PseudoSocket_fd_family_s, sizeof(__pyx_k_uvloop_PseudoSocket_fd_family_s), 0, 1, 0, 0},
+  {&__pyx_kp_s_uvloop_handles_process_pyx, __pyx_k_uvloop_handles_process_pyx, sizeof(__pyx_k_uvloop_handles_process_pyx), 0, 0, 1, 0},
+  {&__pyx_n_s_uvloop_loop, __pyx_k_uvloop_loop, sizeof(__pyx_k_uvloop_loop), 0, 0, 1, 1},
+  {&__pyx_kp_s_uvloop_loop_pyx, __pyx_k_uvloop_loop_pyx, sizeof(__pyx_k_uvloop_loop_pyx), 0, 0, 1, 0},
+  {&__pyx_n_s_uvloop_sleep_after_fork, __pyx_k_uvloop_sleep_after_fork, sizeof(__pyx_k_uvloop_sleep_after_fork), 0, 0, 1, 1},
+  {&__pyx_kp_u_uvloop_sslproto, __pyx_k_uvloop_sslproto, sizeof(__pyx_k_uvloop_sslproto), 0, 1, 0, 0},
+  {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1},
+  {&__pyx_n_s_version_info, __pyx_k_version_info, sizeof(__pyx_k_version_info), 0, 0, 1, 1},
+  {&__pyx_n_s_wait, __pyx_k_wait, sizeof(__pyx_k_wait), 0, 0, 1, 1},
+  {&__pyx_n_s_wait_closed, __pyx_k_wait_closed, sizeof(__pyx_k_wait_closed), 0, 0, 1, 1},
+  {&__pyx_n_s_waiter, __pyx_k_waiter, sizeof(__pyx_k_waiter), 0, 0, 1, 1},
+  {&__pyx_n_s_walk_stack, __pyx_k_walk_stack, sizeof(__pyx_k_walk_stack), 0, 0, 1, 1},
+  {&__pyx_n_s_warn, __pyx_k_warn, sizeof(__pyx_k_warn), 0, 0, 1, 1},
+  {&__pyx_n_s_warn_on_full_buffer, __pyx_k_warn_on_full_buffer, sizeof(__pyx_k_warn_on_full_buffer), 0, 0, 1, 1},
+  {&__pyx_n_s_warning, __pyx_k_warning, sizeof(__pyx_k_warning), 0, 0, 1, 1},
+  {&__pyx_n_s_warnings, __pyx_k_warnings, sizeof(__pyx_k_warnings), 0, 0, 1, 1},
+  {&__pyx_n_u_wb, __pyx_k_wb, sizeof(__pyx_k_wb), 0, 1, 0, 1},
+  {&__pyx_n_s_weakref, __pyx_k_weakref, sizeof(__pyx_k_weakref), 0, 0, 1, 1},
+  {&__pyx_n_s_when, __pyx_k_when, sizeof(__pyx_k_when), 0, 0, 1, 1},
+  {&__pyx_kp_u_without_no_gc_clear_loop_was_se, __pyx_k_without_no_gc_clear_loop_was_se, sizeof(__pyx_k_without_no_gc_clear_loop_was_se), 0, 1, 0, 0},
+  {&__pyx_n_s_wrap, __pyx_k_wrap, sizeof(__pyx_k_wrap), 0, 0, 1, 1},
+  {&__pyx_n_s_wrap_bio, __pyx_k_wrap_bio, sizeof(__pyx_k_wrap_bio), 0, 0, 1, 1},
+  {&__pyx_n_s_wrap_future, __pyx_k_wrap_future, sizeof(__pyx_k_wrap_future), 0, 0, 1, 1},
+  {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1},
+  {&__pyx_n_s_zip, __pyx_k_zip, sizeof(__pyx_k_zip), 0, 0, 1, 1},
+  {0, 0, 0, 0, 0, 0, 0}
+};
+static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
+  __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) __PYX_ERR(0, 122, __pyx_L1_error)
+  __pyx_builtin_OSError = __Pyx_GetBuiltinName(__pyx_n_s_OSError); if (!__pyx_builtin_OSError) __PYX_ERR(1, 13, __pyx_L1_error)
+  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 138, __pyx_L1_error)
+  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(0, 226, __pyx_L1_error)
+  __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(0, 420, __pyx_L1_error)
+  __pyx_builtin_BaseException = __Pyx_GetBuiltinName(__pyx_n_s_BaseException); if (!__pyx_builtin_BaseException) __PYX_ERR(0, 452, __pyx_L1_error)
+  __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 695, __pyx_L1_error)
+  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 698, __pyx_L1_error)
+  __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) __PYX_ERR(0, 747, __pyx_L1_error)
+  __pyx_builtin_KeyboardInterrupt = __Pyx_GetBuiltinName(__pyx_n_s_KeyboardInterrupt); if (!__pyx_builtin_KeyboardInterrupt) __PYX_ERR(0, 919, __pyx_L1_error)
+  __pyx_builtin_SystemExit = __Pyx_GetBuiltinName(__pyx_n_s_SystemExit); if (!__pyx_builtin_SystemExit) __PYX_ERR(0, 919, __pyx_L1_error)
+  __pyx_builtin_print = __Pyx_GetBuiltinName(__pyx_n_s_print); if (!__pyx_builtin_print) __PYX_ERR(0, 1165, __pyx_L1_error)
+  __pyx_builtin_round = __Pyx_GetBuiltinName(__pyx_n_s_round); if (!__pyx_builtin_round) __PYX_ERR(0, 1324, __pyx_L1_error)
+  __pyx_builtin_OverflowError = __Pyx_GetBuiltinName(__pyx_n_s_OverflowError); if (!__pyx_builtin_OverflowError) __PYX_ERR(0, 1535, __pyx_L1_error)
+  __pyx_builtin_RuntimeWarning = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeWarning); if (!__pyx_builtin_RuntimeWarning) __PYX_ERR(0, 2879, __pyx_L1_error)
+  __pyx_builtin_DeprecationWarning = __Pyx_GetBuiltinName(__pyx_n_s_DeprecationWarning); if (!__pyx_builtin_DeprecationWarning) __PYX_ERR(0, 3019, __pyx_L1_error)
+  __pyx_builtin_zip = __Pyx_GetBuiltinName(__pyx_n_s_zip); if (!__pyx_builtin_zip) __PYX_ERR(0, 3153, __pyx_L1_error)
+  __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(2, 218, __pyx_L1_error)
+  __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(2, 240, __pyx_L1_error)
+  __pyx_builtin_super = __Pyx_GetBuiltinName(__pyx_n_s_super); if (!__pyx_builtin_super) __PYX_ERR(3, 166, __pyx_L1_error)
+  __pyx_builtin_open = __Pyx_GetBuiltinName(__pyx_n_s_open); if (!__pyx_builtin_open) __PYX_ERR(4, 188, __pyx_L1_error)
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(4, 230, __pyx_L1_error)
+  __pyx_builtin_UnicodeEncodeError = __Pyx_GetBuiltinName(__pyx_n_s_UnicodeEncodeError); if (!__pyx_builtin_UnicodeEncodeError) __PYX_ERR(5, 109, __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);
+
+  /* "uvloop/loop.pyx":226
+ *     def __dealloc__(self):
+ *         if self._running == 1:
+ *             raise RuntimeError('deallocating a running event loop!')             # <<<<<<<<<<<<<<
+ *         if self._closed == 0:
+ *             aio_logger.error("deallocating an open event loop")
+ */
+  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_deallocating_a_running_event_loo); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple_);
+  __Pyx_GIVEREF(__pyx_tuple_);
+
+  /* "uvloop/loop.pyx":283
+ * 
+ *         if self._listening_signals:
+ *             raise RuntimeError('signals handling has been already setup')             # <<<<<<<<<<<<<<
+ * 
+ *         if self._ssock is not None:
+ */
+  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_signals_handling_has_been_alread); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 283, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__2);
+  __Pyx_GIVEREF(__pyx_tuple__2);
+
+  /* "uvloop/loop.pyx":286
+ * 
+ *         if self._ssock is not None:
+ *             raise RuntimeError('self-pipe exists before loop run')             # <<<<<<<<<<<<<<
+ * 
+ *         # Create a self-pipe and call set_signal_wakeup_fd() with one
+ */
+  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_self_pipe_exists_before_loop_run); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+
+  /* "uvloop/loop.pyx":327
+ *         if not self._is_main_thread():
+ *             if self._listening_signals:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     'cannot pause signals handling; no longer running in '
+ *                     'the main thread')
+ */
+  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_cannot_pause_signals_handling_no); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 327, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
+
+  /* "uvloop/loop.pyx":334
+ * 
+ *         if not self._listening_signals:
+ *             raise RuntimeError('signals handling has not been setup')             # <<<<<<<<<<<<<<
+ * 
+ *         self._listening_signals = False
+ */
+  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_signals_handling_has_not_been_se); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 334, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+
+  /* "uvloop/loop.pyx":355
+ * 
+ *         if self._listening_signals:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'cannot shutdown signals handling as it has not been paused')
+ * 
+ */
+  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_cannot_shutdown_signals_handling); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 355, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+
+  /* "uvloop/loop.pyx":359
+ * 
+ *         if self._ssock:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'self-pipe was not cleaned up after loop was run')
+ * 
+ */
+  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_self_pipe_was_not_cleaned_up_aft); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 359, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+
+  /* "uvloop/loop.pyx":508
+ * 
+ *         if self._closed == 1:
+ *             raise RuntimeError('unable to start the loop; it was closed')             # <<<<<<<<<<<<<<
+ * 
+ *         if self._running == 1:
+ */
+  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_unable_to_start_the_loop_it_was); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 508, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__9);
+  __Pyx_GIVEREF(__pyx_tuple__9);
+
+  /* "uvloop/loop.pyx":511
+ * 
+ *         if self._running == 1:
+ *             raise RuntimeError('this event loop is already running.')             # <<<<<<<<<<<<<<
+ * 
+ *         if (aio_get_running_loop is not None and
+ */
+  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_this_event_loop_is_already_runni); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 511, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
+
+  /* "uvloop/loop.pyx":515
+ *         if (aio_get_running_loop is not None and
+ *                 aio_get_running_loop() is not None):
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'Cannot run the event loop while another loop is running')
+ * 
+ */
+  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_Cannot_run_the_event_loop_while); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 515, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__11);
+  __Pyx_GIVEREF(__pyx_tuple__11);
+
+  /* "uvloop/loop.pyx":556
+ * 
+ *         if self._running == 1:
+ *             raise RuntimeError("Cannot close a running event loop")             # <<<<<<<<<<<<<<
+ * 
+ *         if self._closed == 1:
+ */
+  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_Cannot_close_a_running_event_loo); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 556, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__12);
+  __Pyx_GIVEREF(__pyx_tuple__12);
+
+  /* "uvloop/loop.pyx":655
+ *         if UVLOOP_DEBUG:
+ *             if len(self._queued_streams) != queued_len:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     'loop._queued_streams are not empty after '
+ *                     '_exec_queued_writes')
+ */
+  __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_u_loop__queued_streams_are_not_emp); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 655, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__13);
+  __Pyx_GIVEREF(__pyx_tuple__13);
+
+  /* "uvloop/loop.pyx":703
+ *     cdef inline _check_closed(self):
+ *         if self._closed == 1:
+ *             raise RuntimeError('Event loop is closed')             # <<<<<<<<<<<<<<
+ * 
+ *     cdef inline _check_thread(self):
+ */
+  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_u_Event_loop_is_closed); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 703, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
+
+  /* "uvloop/loop.pyx":713
+ * 
+ *         if thread_id != self._thread_id:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 "Non-thread-safe operation invoked on an event loop other "
+ *                 "than the current one")
+ */
+  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_u_Non_thread_safe_operation_invoke); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 713, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__15);
+  __Pyx_GIVEREF(__pyx_tuple__15);
+
+  /* "uvloop/loop.pyx":902
+ *             port = str(port).encode()
+ *         if port is not None and not isinstance(port, bytes):
+ *             raise TypeError('port must be a str, bytes or int')             # <<<<<<<<<<<<<<
+ * 
+ *         if isinstance(host, str):
+ */
+  __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_u_port_must_be_a_str_bytes_or_int); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 902, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
+
+  /* "uvloop/loop.pyx":908
+ *         if host is not None:
+ *             if not isinstance(host, bytes):
+ *                 raise TypeError('host must be a str or bytes')             # <<<<<<<<<<<<<<
+ * 
+ *         fut = self._new_future()
+ */
+  __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_u_host_must_be_a_str_or_bytes); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 908, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
+  __Pyx_GIVEREF(__pyx_tuple__17);
+
+  /* "uvloop/loop.pyx":912
+ *         fut = self._new_future()
+ * 
+ *         def callback(result):             # <<<<<<<<<<<<<<
+ *             if AddrInfo.isinstance(result):
+ *                 try:
+ */
+  __pyx_tuple__18 = PyTuple_Pack(3, __pyx_n_s_result, __pyx_n_s_data, __pyx_n_s_ex); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 912, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__18);
+  __Pyx_GIVEREF(__pyx_tuple__18);
+  __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 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_uvloop_loop_pyx, __pyx_n_s_callback, 912, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 912, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":938
+ *         fut = self._new_future()
+ * 
+ *         def callback(result):             # <<<<<<<<<<<<<<
+ *             if isinstance(result, tuple):
+ *                 fut.set_result(result)
+ */
+  __pyx_tuple__20 = PyTuple_Pack(1, __pyx_n_s_result); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 938, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__20);
+  __Pyx_GIVEREF(__pyx_tuple__20);
+  __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_loop_pyx, __pyx_n_s_callback, 938, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 938, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":952
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'_sock_recv is called on a cancelled Future')
+ * 
+ */
+  __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_u_sock_recv_is_called_on_a_cancel); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 952, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__22);
+  __Pyx_GIVEREF(__pyx_tuple__22);
+
+  /* "uvloop/loop.pyx":979
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketReaderFuture.
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'_sock_recv_into is called on a cancelled Future')
+ * 
+ */
+  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_u_sock_recv_into_is_called_on_a_c); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 979, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__23);
+  __Pyx_GIVEREF(__pyx_tuple__23);
+
+  /* "uvloop/loop.pyx":1010
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'_sock_sendall is called on a cancelled Future')
+ * 
+ */
+  __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_u_sock_sendall_is_called_on_a_can); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 1010, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__24);
+  __Pyx_GIVEREF(__pyx_tuple__24);
+
+  /* "uvloop/loop.pyx":1094
+ *             if fut.cancelled():
+ *                 # Shouldn't happen with _SyncSocketWriterFuture.
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     f'_sock_connect_cb is called on a cancelled Future')
+ * 
+ */
+  __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_u_sock_connect_cb_is_called_on_a); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 1094, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__25);
+  __Pyx_GIVEREF(__pyx_tuple__25);
+
+  /* "uvloop/loop.pyx":1165
+ *         # OS
+ * 
+ *         print('---- Process info: -----')             # <<<<<<<<<<<<<<
+ *         print('Process memory:            {}'.format(rusage.ru_maxrss))
+ *         print('Number of signals:         {}'.format(rusage.ru_nsignals))
+ */
+  __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_u_Process_info); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 1165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__26);
+  __Pyx_GIVEREF(__pyx_tuple__26);
+
+  /* "uvloop/loop.pyx":1168
+ *         print('Process memory:            {}'.format(rusage.ru_maxrss))
+ *         print('Number of signals:         {}'.format(rusage.ru_nsignals))
+ *         print('')             # <<<<<<<<<<<<<<
+ * 
+ *         # Loop
+ */
+  __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_u__8); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 1168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__27);
+  __Pyx_GIVEREF(__pyx_tuple__27);
+
+  /* "uvloop/loop.pyx":1172
+ *         # Loop
+ * 
+ *         print('--- Loop debug info: ---')             # <<<<<<<<<<<<<<
+ *         print('Loop time:                 {}'.format(self.time()))
+ *         print('Errors logged:             {}'.format(
+ */
+  __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_u_Loop_debug_info); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 1172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__28);
+  __Pyx_GIVEREF(__pyx_tuple__28);
+
+  /* "uvloop/loop.pyx":1185
+ *         print()
+ * 
+ *         print('                        alive  | closed  |')             # <<<<<<<<<<<<<<
+ *         print('UVHandles               python | libuv   | total')
+ *         print('                        objs   | handles |')
+ */
+  __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_u_alive_closed); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 1185, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__29);
+  __Pyx_GIVEREF(__pyx_tuple__29);
+
+  /* "uvloop/loop.pyx":1186
+ * 
+ *         print('                        alive  | closed  |')
+ *         print('UVHandles               python | libuv   | total')             # <<<<<<<<<<<<<<
+ *         print('                        objs   | handles |')
+ *         print('-------------------------------+---------+---------')
+ */
+  __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_u_UVHandles_python_libuv_total); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 1186, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__30);
+  __Pyx_GIVEREF(__pyx_tuple__30);
+
+  /* "uvloop/loop.pyx":1187
+ *         print('                        alive  | closed  |')
+ *         print('UVHandles               python | libuv   | total')
+ *         print('                        objs   | handles |')             # <<<<<<<<<<<<<<
+ *         print('-------------------------------+---------+---------')
+ *         for name in sorted(self._debug_handles_total):
+ */
+  __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_u_objs_handles); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 1187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__31);
+  __Pyx_GIVEREF(__pyx_tuple__31);
+
+  /* "uvloop/loop.pyx":1188
+ *         print('UVHandles               python | libuv   | total')
+ *         print('                        objs   | handles |')
+ *         print('-------------------------------+---------+---------')             # <<<<<<<<<<<<<<
+ *         for name in sorted(self._debug_handles_total):
+ *             print('    {: <18} {: >7} | {: >7} | {: >7}'.format(
+ */
+  __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_u__32); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 1188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__33);
+  __Pyx_GIVEREF(__pyx_tuple__33);
+
+  /* "uvloop/loop.pyx":1203
+ *         print()
+ * 
+ *         print('--- Streams debug info: ---')             # <<<<<<<<<<<<<<
+ *         print('Write errors:              {}'.format(
+ *             self._debug_stream_write_errors_total))
+ */
+  __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_u_Streams_debug_info); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 1203, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__34);
+  __Pyx_GIVEREF(__pyx_tuple__34);
+
+  /* "uvloop/loop.pyx":1231
+ *         print()
+ * 
+ *         print('--- Polls debug info: ---')             # <<<<<<<<<<<<<<
+ *         print('Read events:               {}'.format(
+ *             self._poll_read_events_total))
+ */
+  __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_u_Polls_debug_info); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 1231, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__35);
+  __Pyx_GIVEREF(__pyx_tuple__35);
+
+  /* "uvloop/loop.pyx":1242
+ *         print()
+ * 
+ *         print('--- Sock ops successful on 1st try: ---')             # <<<<<<<<<<<<<<
+ *         print('Socket try-writes:         {}'.format(
+ *             self._sock_try_write_total))
+ */
+  __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_u_Sock_ops_successful_on_1st_try); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 1242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__36);
+  __Pyx_GIVEREF(__pyx_tuple__36);
+
+  /* "uvloop/loop.pyx":1253
+ *                 return lambda: self._print_debug_info()
+ *             else:
+ *                 raise AttributeError('print_debug_info')             # <<<<<<<<<<<<<<
+ * 
+ *     # Public API
+ */
+  __pyx_tuple__37 = PyTuple_Pack(1, __pyx_n_u_print_debug_info); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 1253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__37);
+  __Pyx_GIVEREF(__pyx_tuple__37);
+
+  /* "uvloop/loop.pyx":1450
+ *         """
+ *         if factory is not None and not callable(factory):
+ *             raise TypeError('task factory must be a callable or None')             # <<<<<<<<<<<<<<
+ *         self._task_factory = factory
+ * 
+ */
+  __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_u_task_factory_must_be_a_callable); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 1450, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__38);
+  __Pyx_GIVEREF(__pyx_tuple__38);
+
+  /* "uvloop/loop.pyx":1477
+ *             future._log_destroy_pending = False
+ * 
+ *         def done_cb(fut):             # <<<<<<<<<<<<<<
+ *             if not fut.cancelled():
+ *                 exc = fut.exception()
+ */
+  __pyx_tuple__39 = PyTuple_Pack(2, __pyx_n_s_fut, __pyx_n_s_exc); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 1477, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__39);
+  __Pyx_GIVEREF(__pyx_tuple__39);
+  __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 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_uvloop_loop_pyx, __pyx_n_s_done_cb, 1477, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(0, 1477, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":1499
+ *             future.remove_done_callback(done_cb)
+ *         if not future.done():
+ *             raise RuntimeError('Event loop stopped before Future completed.')             # <<<<<<<<<<<<<<
+ * 
+ *         return future.result()
+ */
+  __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_u_Event_loop_stopped_before_Future); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 1499, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__41);
+  __Pyx_GIVEREF(__pyx_tuple__41);
+
+  /* "uvloop/loop.pyx":1525
+ * 
+ *         if not isinstance(sockaddr, tuple):
+ *             raise TypeError('getnameinfo() argument 1 must be a tuple')             # <<<<<<<<<<<<<<
+ * 
+ *         sl = len(sockaddr)
+ */
+  __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_u_getnameinfo_argument_1_must_be_a); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 1525, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__42);
+  __Pyx_GIVEREF(__pyx_tuple__42);
+
+  /* "uvloop/loop.pyx":1530
+ * 
+ *         if sl < 2 or sl > 4:
+ *             raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')             # <<<<<<<<<<<<<<
+ * 
+ *         if sl > 2:
+ */
+  __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_u_sockaddr_must_be_a_tuple_of_2_3); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 1530, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__43);
+  __Pyx_GIVEREF(__pyx_tuple__43);
+
+  /* "uvloop/loop.pyx":1535
+ *             flowinfo = sockaddr[2]
+ *             if flowinfo < 0 or flowinfo > 0xfffff:
+ *                 raise OverflowError(             # <<<<<<<<<<<<<<
+ *                     'getnameinfo(): flowinfo must be 0-1048575.')
+ *         else:
+ */
+  __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_u_getnameinfo_flowinfo_must_be_0_1); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 1535, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__44);
+  __Pyx_GIVEREF(__pyx_tuple__44);
+
+  /* "uvloop/loop.pyx":1543
+ *             scope_id = sockaddr[3]
+ *             if scope_id < 0 or scope_id > 2 ** 32:
+ *                 raise OverflowError(             # <<<<<<<<<<<<<<
+ *                     'getsockaddrarg: scope_id must be unsigned 32 bit integer')
+ *         else:
+ */
+  __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_u_getsockaddrarg_scope_id_must_be); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 1543, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__45);
+  __Pyx_GIVEREF(__pyx_tuple__45);
+
+  /* "uvloop/loop.pyx":1559
+ * 
+ *         if ai.ai_next:
+ *             raise OSError("sockaddr resolved to multiple addresses")             # <<<<<<<<<<<<<<
+ * 
+ *         if ai.ai_family == uv.AF_INET:
+ */
+  __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_u_sockaddr_resolved_to_multiple_ad); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 1559, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__46);
+  __Pyx_GIVEREF(__pyx_tuple__46);
+
+  /* "uvloop/loop.pyx":1563
+ *         if ai.ai_family == uv.AF_INET:
+ *             if sl > 2:
+ *                 raise OSError("IPv4 sockaddr must be 2 tuple")             # <<<<<<<<<<<<<<
+ *         elif ai.ai_family == uv.AF_INET6:
+ *             # Modify some fields in `ai`
+ */
+  __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_u_IPv4_sockaddr_must_be_2_tuple); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 1563, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__47);
+  __Pyx_GIVEREF(__pyx_tuple__47);
+
+  /* "uvloop/loop.pyx":1691
+ *         if sock is not None and sock.family == uv.AF_UNIX:
+ *             if host is not None or port is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'host/port and sock can not be specified at the same time')
+ *             return await self.create_unix_server(
+ */
+  __pyx_tuple__50 = PyTuple_Pack(1, __pyx_kp_u_host_port_and_sock_can_not_be_sp); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 1691, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__50);
+  __Pyx_GIVEREF(__pyx_tuple__50);
+
+  /* "uvloop/loop.pyx":1701
+ *         if ssl is not None:
+ *             if not isinstance(ssl, ssl_SSLContext):
+ *                 raise TypeError('ssl argument must be an SSLContext or None')             # <<<<<<<<<<<<<<
+ *         else:
+ *             if ssl_handshake_timeout is not None:
+ */
+  __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_u_ssl_argument_must_be_an_SSLConte); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 1701, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__51);
+  __Pyx_GIVEREF(__pyx_tuple__51);
+
+  /* "uvloop/loop.pyx":1704
+ *         else:
+ *             if ssl_handshake_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ */
+  __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_u_ssl_handshake_timeout_is_only_me); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 1704, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__52);
+  __Pyx_GIVEREF(__pyx_tuple__52);
+
+  /* "uvloop/loop.pyx":1707
+ *                     'ssl_handshake_timeout is only meaningful with ssl')
+ *             if ssl_shutdown_timeout is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'ssl_shutdown_timeout is only meaningful with ssl')
+ * 
+ */
+  __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_u_ssl_shutdown_timeout_is_only_mea); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(0, 1707, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__53);
+  __Pyx_GIVEREF(__pyx_tuple__53);
+
+  /* "uvloop/loop.pyx":1719
+ *             reuse_port = bool(reuse_port)
+ *             if reuse_port and not has_SO_REUSEPORT:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'reuse_port not supported by socket module')
+ * 
+ */
+  __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_u_reuse_port_not_supported_by_sock); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 1719, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__54);
+  __Pyx_GIVEREF(__pyx_tuple__54);
+
+  /* "uvloop/loop.pyx":1742
+ *                     while addrinfo != NULL:
+ *                         if addrinfo.ai_family == uv.AF_UNSPEC:
+ *                             raise RuntimeError('AF_UNSPEC in DNS results')             # <<<<<<<<<<<<<<
+ * 
+ *                         try:
+ */
+  __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_u_AF_UNSPEC_in_DNS_results); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(0, 1742, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__55);
+  __Pyx_GIVEREF(__pyx_tuple__55);
+
+  /* "uvloop/loop.pyx":1807
+ *         else:
+ *             if sock is None:
+ *                 raise ValueError('Neither host/port nor sock were specified')             # <<<<<<<<<<<<<<
+ *             if not _is_sock_stream(sock.type):
+ *                 raise ValueError(
+ */
+  __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_u_Neither_host_port_nor_sock_were); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(0, 1807, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__57);
+  __Pyx_GIVEREF(__pyx_tuple__57);
+
+  /* "uvloop/loop.pyx":1892
+ *             if server_hostname is None:
+ *                 if not host:
+ *                     raise ValueError('You must set server_hostname '             # <<<<<<<<<<<<<<
+ *                                      'when using ssl without a host')
+ *                 server_hostname = host
+ */
+  __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_u_You_must_set_server_hostname_whe); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 1892, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__58);
+  __Pyx_GIVEREF(__pyx_tuple__58);
+
+  /* "uvloop/loop.pyx":1905
+ *         else:
+ *             if server_hostname is not None:
+ *                 raise ValueError('server_hostname is only meaningful with ssl')             # <<<<<<<<<<<<<<
+ *             if ssl_handshake_timeout is not None:
+ *                 raise ValueError(
+ */
+  __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_u_server_hostname_is_only_meaningf); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 1905, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__59);
+  __Pyx_GIVEREF(__pyx_tuple__59);
+
+  /* "uvloop/loop.pyx":1940
+ *                 if not isinstance(local_addr, (tuple, list)) or \
+ *                         len(local_addr) != 2:
+ *                     raise ValueError(             # <<<<<<<<<<<<<<
+ *                         'local_addr must be a tuple of host and port')
+ * 
+ */
+  __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_u_local_addr_must_be_a_tuple_of_ho); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 1940, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__60);
+  __Pyx_GIVEREF(__pyx_tuple__60);
+
+  /* "uvloop/loop.pyx":1965
+ *                 ai_remote = f1.result()
+ *                 if ai_remote.data is NULL:
+ *                     raise OSError('getaddrinfo() returned empty list')             # <<<<<<<<<<<<<<
+ *                 rai = ai_remote.data
+ * 
+ */
+  __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_u_getaddrinfo_returned_empty_list); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 1965, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__61);
+  __Pyx_GIVEREF(__pyx_tuple__61);
+
+  /* "uvloop/loop.pyx":1971
+ *                 ai_local = f2.result()
+ *                 if ai_local.data is NULL:
+ *                     raise OSError(             # <<<<<<<<<<<<<<
+ *                         'getaddrinfo() returned empty list for local_addr')
+ *                 lai = ai_local.data
+ */
+  __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_u_getaddrinfo_returned_empty_list_2); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 1971, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__62);
+  __Pyx_GIVEREF(__pyx_tuple__62);
+
+  /* "uvloop/loop.pyx":2031
+ *         else:
+ *             if sock is None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'host and port was not specified and no sock specified')
+ *             if not _is_sock_stream(sock.type):
+ */
+  __pyx_tuple__64 = PyTuple_Pack(1, __pyx_kp_u_host_and_port_was_not_specified); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(0, 2031, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__64);
+  __Pyx_GIVEREF(__pyx_tuple__64);
+
+  /* "uvloop/loop.pyx":2122
+ *         if path is not None:
+ *             if sock is not None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'path and sock can not be specified at the same time')
+ *             orig_path = path
+ */
+  __pyx_tuple__65 = PyTuple_Pack(1, __pyx_kp_u_path_and_sock_can_not_be_specifi); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(0, 2122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__65);
+  __Pyx_GIVEREF(__pyx_tuple__65);
+
+  /* "uvloop/loop.pyx":2169
+ *         else:
+ *             if sock is None:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'path was not specified, and no sock specified')
+ * 
+ */
+  __pyx_tuple__66 = PyTuple_Pack(1, __pyx_kp_u_path_was_not_specified_and_no_so); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(0, 2169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__66);
+  __Pyx_GIVEREF(__pyx_tuple__66);
+
+  /* "uvloop/loop.pyx":2264
+ *         else:
+ *             if sock is None:
+ *                 raise ValueError('no path and sock were specified')             # <<<<<<<<<<<<<<
+ * 
+ *             if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
+ */
+  __pyx_tuple__67 = PyTuple_Pack(1, __pyx_kp_u_no_path_and_sock_were_specified); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(0, 2264, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__67);
+  __Pyx_GIVEREF(__pyx_tuple__67);
+
+  /* "uvloop/loop.pyx":2396
+ *                 # in the default implementation, as well as for subclassed
+ *                 # event loops with overloaded "default_exception_handler".
+ *                 aio_logger.error('Exception in default exception handler',             # <<<<<<<<<<<<<<
+ *                                  exc_info=True)
+ *         else:
+ */
+  __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_u_Exception_in_default_exception_h); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(0, 2396, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__70);
+  __Pyx_GIVEREF(__pyx_tuple__70);
+
+  /* "uvloop/loop.pyx":2417
+ *                     # Guard 'default_exception_handler' in case it is
+ *                     # overloaded.
+ *                     aio_logger.error('Exception in default exception handler '             # <<<<<<<<<<<<<<
+ *                                      'while handling an unexpected error '
+ *                                      'in custom exception handler',
+ */
+  __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_u_Exception_in_default_exception_h_2); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(0, 2417, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__71);
+  __Pyx_GIVEREF(__pyx_tuple__71);
+
+  /* "uvloop/loop.pyx":2456
+ * 
+ *         if self._debug and sock.gettimeout() != 0:
+ *             raise ValueError("the socket must be non-blocking")             # <<<<<<<<<<<<<<
+ * 
+ *         fut = _SyncSocketReaderFuture(sock, self)
+ */
+  __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_u_the_socket_must_be_non_blocking); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(0, 2456, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__72);
+  __Pyx_GIVEREF(__pyx_tuple__72);
+
+  /* "uvloop/loop.pyx":2595
+ *             else:
+ *                 addrs = await self.getaddrinfo(
+ *                     *address[:2], family=sock.family)             # <<<<<<<<<<<<<<
+ * 
+ *                 _, _, _, _, address = addrs[0]
+ */
+  __pyx_slice__73 = PySlice_New(Py_None, __pyx_int_2, Py_None); if (unlikely(!__pyx_slice__73)) __PYX_ERR(0, 2595, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__73);
+  __Pyx_GIVEREF(__pyx_slice__73);
+
+  /* "uvloop/loop.pyx":2661
+ * 
+ *         if transport is None:
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
+ * 
+ */
+  __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_u_invalid_socket_family_expected_A); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(0, 2661, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__74);
+  __Pyx_GIVEREF(__pyx_tuple__74);
+
+  /* "uvloop/loop.pyx":2690
+ *     def run_in_executor(self, executor, func, *args):
+ *         if aio_iscoroutine(func) or aio_iscoroutinefunction(func):
+ *             raise TypeError("coroutines cannot be used with run_in_executor()")             # <<<<<<<<<<<<<<
+ * 
+ *         self._check_closed()
+ */
+  __pyx_tuple__75 = PyTuple_Pack(1, __pyx_kp_u_coroutines_cannot_be_used_with_r); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(0, 2690, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__75);
+  __Pyx_GIVEREF(__pyx_tuple__75);
+
+  /* "uvloop/loop.pyx":2735
+ * 
+ *         if universal_newlines:
+ *             raise ValueError("universal_newlines must be False")             # <<<<<<<<<<<<<<
+ *         if bufsize != 0:
+ *             raise ValueError("bufsize must be 0")
+ */
+  __pyx_tuple__79 = PyTuple_Pack(1, __pyx_kp_u_universal_newlines_must_be_False); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(0, 2735, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__79);
+  __Pyx_GIVEREF(__pyx_tuple__79);
+
+  /* "uvloop/loop.pyx":2737
+ *             raise ValueError("universal_newlines must be False")
+ *         if bufsize != 0:
+ *             raise ValueError("bufsize must be 0")             # <<<<<<<<<<<<<<
+ *         if startupinfo is not None:
+ *             raise ValueError('startupinfo is not supported')
+ */
+  __pyx_tuple__80 = PyTuple_Pack(1, __pyx_kp_u_bufsize_must_be_0); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 2737, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__80);
+  __Pyx_GIVEREF(__pyx_tuple__80);
+
+  /* "uvloop/loop.pyx":2739
+ *             raise ValueError("bufsize must be 0")
+ *         if startupinfo is not None:
+ *             raise ValueError('startupinfo is not supported')             # <<<<<<<<<<<<<<
+ *         if creationflags != 0:
+ *             raise ValueError('creationflags is not supported')
+ */
+  __pyx_tuple__81 = PyTuple_Pack(1, __pyx_kp_u_startupinfo_is_not_supported); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 2739, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__81);
+  __Pyx_GIVEREF(__pyx_tuple__81);
+
+  /* "uvloop/loop.pyx":2741
+ *             raise ValueError('startupinfo is not supported')
+ *         if creationflags != 0:
+ *             raise ValueError('creationflags is not supported')             # <<<<<<<<<<<<<<
+ * 
+ *         if executable is not None:
+ */
+  __pyx_tuple__82 = PyTuple_Pack(1, __pyx_kp_u_creationflags_is_not_supported); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 2741, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__82);
+  __Pyx_GIVEREF(__pyx_tuple__82);
+
+  /* "uvloop/loop.pyx":2775
+ * 
+ *         if not shell:
+ *             raise ValueError("shell must be True")             # <<<<<<<<<<<<<<
+ * 
+ *         args = [cmd]
+ */
+  __pyx_tuple__83 = PyTuple_Pack(1, __pyx_kp_u_shell_must_be_True); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(0, 2775, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__83);
+  __Pyx_GIVEREF(__pyx_tuple__83);
+
+  /* "uvloop/loop.pyx":2789
+ * 
+ *         if shell:
+ *             raise ValueError("shell must be False")             # <<<<<<<<<<<<<<
+ * 
+ *         args = list((program,) + args)
+ */
+  __pyx_tuple__84 = PyTuple_Pack(1, __pyx_kp_u_shell_must_be_False); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(0, 2789, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__84);
+  __Pyx_GIVEREF(__pyx_tuple__84);
+
+  /* "uvloop/loop.pyx":2860
+ * 
+ *         if not self._is_main_thread():
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'add_signal_handler() can only be called from '
+ *                 'the main thread')
+ */
+  __pyx_tuple__85 = PyTuple_Pack(1, __pyx_kp_u_add_signal_handler_can_only_be_c); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(0, 2860, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__85);
+  __Pyx_GIVEREF(__pyx_tuple__85);
+
+  /* "uvloop/loop.pyx":2866
+ *         if (aio_iscoroutine(callback)
+ *                 or aio_iscoroutinefunction(callback)):
+ *             raise TypeError(             # <<<<<<<<<<<<<<
+ *                 "coroutines cannot be used with add_signal_handler()")
+ * 
+ */
+  __pyx_tuple__86 = PyTuple_Pack(1, __pyx_kp_u_coroutines_cannot_be_used_with_a); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(0, 2866, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__86);
+  __Pyx_GIVEREF(__pyx_tuple__86);
+
+  /* "uvloop/loop.pyx":2873
+ *                     isinstance(callback.__self__, aio_AbstractChildWatcher)):
+ * 
+ *                 warnings_warn(             # <<<<<<<<<<<<<<
+ *                     "!!! asyncio is trying to install its ChildWatcher for "
+ *                     "SIGCHLD signal !!!\n\nThis is probably because a uvloop "
+ */
+  __pyx_tuple__87 = PyTuple_Pack(2, __pyx_kp_u_asyncio_is_trying_to_install_it, __pyx_builtin_RuntimeWarning); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(0, 2873, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__87);
+  __Pyx_GIVEREF(__pyx_tuple__87);
+
+  /* "uvloop/loop.pyx":2888
+ *                 return
+ * 
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'cannot add a signal handler for SIGCHLD: it is used '
+ *                 'by the event loop to track subprocesses')
+ */
+  __pyx_tuple__88 = PyTuple_Pack(1, __pyx_kp_u_cannot_add_a_signal_handler_for); if (unlikely(!__pyx_tuple__88)) __PYX_ERR(0, 2888, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__88);
+  __Pyx_GIVEREF(__pyx_tuple__88);
+
+  /* "uvloop/loop.pyx":2925
+ * 
+ *         if not self._is_main_thread():
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'remove_signal_handler() can only be called from '
+ *                 'the main thread')
+ */
+  __pyx_tuple__89 = PyTuple_Pack(1, __pyx_kp_u_remove_signal_handler_can_only_b); if (unlikely(!__pyx_tuple__89)) __PYX_ERR(0, 2925, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__89);
+  __Pyx_GIVEREF(__pyx_tuple__89);
+
+  /* "uvloop/loop.pyx":3013
+ *             if reuse_address is not _unset:
+ *                 if reuse_address:
+ *                     raise ValueError("Passing `reuse_address=True` is no "             # <<<<<<<<<<<<<<
+ *                                      "longer supported, as the usage of "
+ *                                      "SO_REUSEPORT in UDP poses a significant "
+ */
+  __pyx_tuple__92 = PyTuple_Pack(1, __pyx_kp_u_Passing_reuse_address_True_is_no); if (unlikely(!__pyx_tuple__92)) __PYX_ERR(0, 3013, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__92);
+  __Pyx_GIVEREF(__pyx_tuple__92);
+
+  /* "uvloop/loop.pyx":3018
+ *                                      "security concern.")
+ *                 else:
+ *                     warnings_warn("The *reuse_address* parameter has been "             # <<<<<<<<<<<<<<
+ *                                   "deprecated as of 0.15.", DeprecationWarning,
+ *                                   stacklevel=2)
+ */
+  __pyx_tuple__93 = PyTuple_Pack(2, __pyx_kp_u_The_reuse_address_parameter_has, __pyx_builtin_DeprecationWarning); if (unlikely(!__pyx_tuple__93)) __PYX_ERR(0, 3018, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__93);
+  __Pyx_GIVEREF(__pyx_tuple__93);
+
+  /* "uvloop/loop.pyx":3030
+ *                 if (not isinstance(local_addr, (tuple, list)) or
+ *                         len(local_addr) != 2):
+ *                     raise TypeError(             # <<<<<<<<<<<<<<
+ *                         'local_addr must be a tuple of (host, port)')
+ *                 lads = await self._getaddrinfo(
+ */
+  __pyx_tuple__94 = PyTuple_Pack(1, __pyx_kp_u_local_addr_must_be_a_tuple_of_ho_2); if (unlikely(!__pyx_tuple__94)) __PYX_ERR(0, 3030, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__94);
+  __Pyx_GIVEREF(__pyx_tuple__94);
+
+  /* "uvloop/loop.pyx":3041
+ *                 if (not isinstance(remote_addr, (tuple, list)) or
+ *                         len(remote_addr) != 2):
+ *                     raise TypeError(             # <<<<<<<<<<<<<<
+ *                         'remote_addr must be a tuple of (host, port)')
+ *                 rads = await self._getaddrinfo(
+ */
+  __pyx_tuple__95 = PyTuple_Pack(1, __pyx_kp_u_remote_addr_must_be_a_tuple_of_h); if (unlikely(!__pyx_tuple__95)) __PYX_ERR(0, 3041, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__95);
+  __Pyx_GIVEREF(__pyx_tuple__95);
+
+  /* "uvloop/loop.pyx":3058
+ *                 else:
+ *                     if family not in (uv.AF_INET, uv.AF_INET6):
+ *                         raise ValueError('unexpected address family')             # <<<<<<<<<<<<<<
+ *                     udp = UDPTransport.__new__(UDPTransport)
+ *                     udp._init(self, family)
+ */
+  __pyx_tuple__96 = PyTuple_Pack(1, __pyx_kp_u_unexpected_address_family); if (unlikely(!__pyx_tuple__96)) __PYX_ERR(0, 3058, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__96);
+  __Pyx_GIVEREF(__pyx_tuple__96);
+
+  /* "uvloop/loop.pyx":3121
+ *     def _check_default_executor(self):
+ *         if self._executor_shutdown_called:
+ *             raise RuntimeError('Executor shutdown has been called')             # <<<<<<<<<<<<<<
+ * 
+ *     def _asyncgen_finalizer_hook(self, agen):
+ */
+  __pyx_tuple__97 = PyTuple_Pack(1, __pyx_kp_u_Executor_shutdown_has_been_calle); if (unlikely(!__pyx_tuple__97)) __PYX_ERR(0, 3121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__97);
+  __Pyx_GIVEREF(__pyx_tuple__97);
+
+  /* "(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__98 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__98)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__98);
+  __Pyx_GIVEREF(__pyx_tuple__98);
+
+  /* "(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__99 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__99)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__99);
+  __Pyx_GIVEREF(__pyx_tuple__99);
+
+  /* "uvloop/loop.pyx":3192
+ *     if loop._recv_buffer_in_use == 1:
+ *         buf.len = 0
+ *         exc = RuntimeError('concurrent allocations')             # <<<<<<<<<<<<<<
+ *         loop._handle_exception(exc)
+ *         return
+ */
+  __pyx_tuple__100 = PyTuple_Pack(1, __pyx_kp_u_concurrent_allocations); if (unlikely(!__pyx_tuple__100)) __PYX_ERR(0, 3192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__100);
+  __Pyx_GIVEREF(__pyx_tuple__100);
+
+  /* "uvloop/cbhandles.pyx":26
+ *             self.loop._debug_cb_handles_count -= 1
+ *         if self.loop is None:
+ *             raise RuntimeError('Handle.loop is None in Handle.__dealloc__')             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self):
+ */
+  __pyx_tuple__101 = PyTuple_Pack(1, __pyx_kp_u_Handle_loop_is_None_in_Handle); if (unlikely(!__pyx_tuple__101)) __PYX_ERR(8, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__101);
+  __Pyx_GIVEREF(__pyx_tuple__101);
+
+  /* "uvloop/cbhandles.pyx":55
+ *                 callback = self.arg1
+ *                 if callback is None:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         'cannot run Handle; callback is not set')
+ * 
+ */
+  __pyx_tuple__102 = PyTuple_Pack(1, __pyx_kp_u_cannot_run_Handle_callback_is_no); if (unlikely(!__pyx_tuple__102)) __PYX_ERR(8, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__102);
+  __Pyx_GIVEREF(__pyx_tuple__102);
+
+  /* "(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__106 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__106)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__106);
+  __Pyx_GIVEREF(__pyx_tuple__106);
+
+  /* "(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__107 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__107)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__107);
+  __Pyx_GIVEREF(__pyx_tuple__107);
+
+  /* "uvloop/cbhandles.pyx":209
+ *             self.loop._debug_cb_timer_handles_count -= 1
+ *         if self.timer is not None:
+ *             raise RuntimeError('active TimerHandle is deallacating')             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _cancel(self):
+ */
+  __pyx_tuple__108 = PyTuple_Pack(1, __pyx_kp_u_active_TimerHandle_is_deallacati); if (unlikely(!__pyx_tuple__108)) __PYX_ERR(8, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__108);
+  __Pyx_GIVEREF(__pyx_tuple__108);
+
+  /* "uvloop/cbhandles.pyx":234
+ *             return
+ *         if self.callback is None:
+ *             raise RuntimeError('cannot run TimerHandle; callback is not set')             # <<<<<<<<<<<<<<
+ * 
+ *         callback = self.callback
+ */
+  __pyx_tuple__109 = PyTuple_Pack(1, __pyx_kp_u_cannot_run_TimerHandle_callback); if (unlikely(!__pyx_tuple__109)) __PYX_ERR(8, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__109);
+  __Pyx_GIVEREF(__pyx_tuple__109);
+
+  /* "(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__110 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__110)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__110);
+  __Pyx_GIVEREF(__pyx_tuple__110);
+
+  /* "(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__111 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__111)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__111);
+  __Pyx_GIVEREF(__pyx_tuple__111);
+
+  /* "uvloop/pseudosock.pyx":64
+ * 
+ *     def __getstate__(self):
+ *         raise TypeError("Cannot serialize socket object")             # <<<<<<<<<<<<<<
+ * 
+ *     def fileno(self):
+ */
+  __pyx_tuple__112 = PyTuple_Pack(1, __pyx_kp_u_Cannot_serialize_socket_object); if (unlikely(!__pyx_tuple__112)) __PYX_ERR(9, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__112);
+  __Pyx_GIVEREF(__pyx_tuple__112);
+
+  /* "uvloop/pseudosock.pyx":193
+ *         if value == 0:
+ *             return
+ *         raise ValueError(             # <<<<<<<<<<<<<<
+ *             'settimeout(): only 0 timeout is allowed on transport sockets')
+ * 
+ */
+  __pyx_tuple__113 = PyTuple_Pack(1, __pyx_kp_u_settimeout_only_0_timeout_is_all); if (unlikely(!__pyx_tuple__113)) __PYX_ERR(9, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__113);
+  __Pyx_GIVEREF(__pyx_tuple__113);
+
+  /* "uvloop/pseudosock.pyx":202
+ *         if not flag:
+ *             return
+ *         raise ValueError(             # <<<<<<<<<<<<<<
+ *             'setblocking(): transport sockets cannot be blocking')
+ * 
+ */
+  __pyx_tuple__114 = PyTuple_Pack(1, __pyx_kp_u_setblocking_transport_sockets_ca); if (unlikely(!__pyx_tuple__114)) __PYX_ERR(9, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__114);
+  __Pyx_GIVEREF(__pyx_tuple__114);
+
+  /* "(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__115 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__115)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__115);
+  __Pyx_GIVEREF(__pyx_tuple__115);
+
+  /* "(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__116 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__116)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__116);
+  __Pyx_GIVEREF(__pyx_tuple__116);
+
+  /* "(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__117 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__117)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__117);
+  __Pyx_GIVEREF(__pyx_tuple__117);
+
+  /* "(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__118 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__118)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__118);
+  __Pyx_GIVEREF(__pyx_tuple__118);
+
+  /* "uvloop/handles/handle.pyx":311
+ *     if UVLOOP_DEBUG:
+ *         if handle.loop is NULL:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'handle.loop is NULL in __ensure_handle_data')
+ * 
+ */
+  __pyx_tuple__119 = PyTuple_Pack(1, __pyx_kp_u_handle_loop_is_NULL_in___ensure); if (unlikely(!__pyx_tuple__119)) __PYX_ERR(2, 311, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__119);
+  __Pyx_GIVEREF(__pyx_tuple__119);
+
+  /* "uvloop/handles/handle.pyx":315
+ * 
+ *         if handle.loop.data is NULL:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'handle.loop.data is NULL in __ensure_handle_data')
+ * 
+ */
+  __pyx_tuple__120 = PyTuple_Pack(1, __pyx_kp_u_handle_loop_data_is_NULL_in___en); if (unlikely(!__pyx_tuple__120)) __PYX_ERR(2, 315, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__120);
+  __Pyx_GIVEREF(__pyx_tuple__120);
+
+  /* "uvloop/handles/handle.pyx":347
+ *         if UVLOOP_DEBUG:
+ *             if handle.loop == NULL or handle.loop.data == NULL:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     '__uv_close_handle_cb: handle.loop is invalid')
+ *             (<Loop>handle.loop.data)._debug_uv_handles_freed += 1
+ */
+  __pyx_tuple__121 = PyTuple_Pack(1, __pyx_kp_u_uv_close_handle_cb_handle_loop); if (unlikely(!__pyx_tuple__121)) __PYX_ERR(2, 347, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__121);
+  __Pyx_GIVEREF(__pyx_tuple__121);
+
+  /* "uvloop/handles/handle.pyx":357
+ *             if UVLOOP_DEBUG:
+ *                 if not h._has_handle:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         'has_handle=0 in __uv_close_handle_cb')
+ *                 h._loop._debug_handles_closed.update([
+ */
+  __pyx_tuple__122 = PyTuple_Pack(1, __pyx_kp_u_has_handle_0_in___uv_close_handl); if (unlikely(!__pyx_tuple__122)) __PYX_ERR(2, 357, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__122);
+  __Pyx_GIVEREF(__pyx_tuple__122);
+
+  /* "(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__123 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__123)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__123);
+  __Pyx_GIVEREF(__pyx_tuple__123);
+
+  /* "(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__124 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__124)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__124);
+  __Pyx_GIVEREF(__pyx_tuple__124);
+
+  /* "(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__125 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__125)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__125);
+  __Pyx_GIVEREF(__pyx_tuple__125);
+
+  /* "(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__126 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__126)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__126);
+  __Pyx_GIVEREF(__pyx_tuple__126);
+
+  /* "(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__127 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__127)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__127);
+  __Pyx_GIVEREF(__pyx_tuple__127);
+
+  /* "(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__128 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__128)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__128);
+  __Pyx_GIVEREF(__pyx_tuple__128);
+
+  /* "(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__129 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__129)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__129);
+  __Pyx_GIVEREF(__pyx_tuple__129);
+
+  /* "(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__130 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__130)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__130);
+  __Pyx_GIVEREF(__pyx_tuple__130);
+
+  /* "(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__131 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__131)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__131);
+  __Pyx_GIVEREF(__pyx_tuple__131);
+
+  /* "(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__132 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__132)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__132);
+  __Pyx_GIVEREF(__pyx_tuple__132);
+
+  /* "uvloop/handles/basetransport.pyx":114
+ *                 if not self._is_alive():
+ *                     self._waiter.set_exception(
+ *                         RuntimeError(             # <<<<<<<<<<<<<<
+ *                             'closed Transport handle and unset waiter'))
+ *                 else:
+ */
+  __pyx_tuple__135 = PyTuple_Pack(1, __pyx_kp_u_closed_Transport_handle_and_unse); if (unlikely(!__pyx_tuple__135)) __PYX_ERR(16, 114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__135);
+  __Pyx_GIVEREF(__pyx_tuple__135);
+
+  /* "uvloop/handles/basetransport.pyx":122
+ *     cdef _call_connection_made(self):
+ *         if self._protocol is None:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'protocol is not set, cannot call connection_made()')
+ * 
+ */
+  __pyx_tuple__136 = PyTuple_Pack(1, __pyx_kp_u_protocol_is_not_set_cannot_call); if (unlikely(!__pyx_tuple__136)) __PYX_ERR(16, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__136);
+  __Pyx_GIVEREF(__pyx_tuple__136);
+
+  /* "uvloop/handles/basetransport.pyx":206
+ *         self._loop._track_transport(self)
+ *         if self._protocol is None:
+ *             raise RuntimeError('invalid _init_protocol call')             # <<<<<<<<<<<<<<
+ *         self._schedule_call_connection_made()
+ * 
+ */
+  __pyx_tuple__137 = PyTuple_Pack(1, __pyx_kp_u_invalid__init_protocol_call); if (unlikely(!__pyx_tuple__137)) __PYX_ERR(16, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__137);
+  __Pyx_GIVEREF(__pyx_tuple__137);
+
+  /* "(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__138 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__138)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__138);
+  __Pyx_GIVEREF(__pyx_tuple__138);
+
+  /* "(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__139 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__139)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__139);
+  __Pyx_GIVEREF(__pyx_tuple__139);
+
+  /* "uvloop/handles/stream.pyx":37
+ *             if UVLOOP_DEBUG:
+ *                 if self.py_bufs_sml_inuse:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '_StreamWriteContext.close: uv_bufs != NULL and '
+ *                         'py_bufs_sml_inuse is True')
+ */
+  __pyx_tuple__140 = PyTuple_Pack(1, __pyx_kp_u_StreamWriteContext_close_uv_buf); if (unlikely(!__pyx_tuple__140)) __PYX_ERR(18, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__140);
+  __Pyx_GIVEREF(__pyx_tuple__140);
+
+  /* "uvloop/handles/stream.pyx":48
+ *             if UVLOOP_DEBUG:
+ *                 if self.py_bufs_sml_inuse:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '_StreamWriteContext.close: py_bufs != NULL and '
+ *                         'py_bufs_sml_inuse is True')
+ */
+  __pyx_tuple__141 = PyTuple_Pack(1, __pyx_kp_u_StreamWriteContext_close_py_buf); if (unlikely(!__pyx_tuple__141)) __PYX_ERR(18, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__141);
+  __Pyx_GIVEREF(__pyx_tuple__141);
+
+  /* "uvloop/handles/stream.pyx":93
+ *             if UVLOOP_DEBUG:
+ *                 if sent < 0:
+ *                     raise RuntimeError('fatal: sent < 0 in advance_uv_buf')             # <<<<<<<<<<<<<<
+ * 
+ *         raise RuntimeError('fatal: Could not advance _StreamWriteContext')
+ */
+  __pyx_tuple__142 = PyTuple_Pack(1, __pyx_kp_u_fatal_sent_0_in_advance_uv_buf); if (unlikely(!__pyx_tuple__142)) __PYX_ERR(18, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__142);
+  __Pyx_GIVEREF(__pyx_tuple__142);
+
+  /* "uvloop/handles/stream.pyx":95
+ *                     raise RuntimeError('fatal: sent < 0 in advance_uv_buf')
+ * 
+ *         raise RuntimeError('fatal: Could not advance _StreamWriteContext')             # <<<<<<<<<<<<<<
+ * 
+ *     @staticmethod
+ */
+  __pyx_tuple__143 = PyTuple_Pack(1, __pyx_kp_u_fatal_Could_not_advance__StreamW); if (unlikely(!__pyx_tuple__143)) __PYX_ERR(18, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__143);
+  __Pyx_GIVEREF(__pyx_tuple__143);
+
+  /* "uvloop/handles/stream.pyx":199
+ *             # Because we do an INCREF in _StreamWriteContext.new,
+ *             # __dealloc__ shouldn't ever happen with `self.closed == 1`
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'open _StreamWriteContext is being deallocated')
+ * 
+ */
+  __pyx_tuple__144 = PyTuple_Pack(1, __pyx_kp_u_open__StreamWriteContext_is_bein); if (unlikely(!__pyx_tuple__144)) __PYX_ERR(18, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__144);
+  __Pyx_GIVEREF(__pyx_tuple__144);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")
+ */
+  __pyx_tuple__145 = PyTuple_Pack(1, __pyx_kp_s_self_py_bufs_self_py_bufs_sml_se); if (unlikely(!__pyx_tuple__145)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__145);
+  __Pyx_GIVEREF(__pyx_tuple__145);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("self.py_bufs,self.py_bufs_sml,self.req,self.uv_bufs,self.uv_bufs_start cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
+ */
+  __pyx_tuple__146 = PyTuple_Pack(1, __pyx_kp_s_self_py_bufs_self_py_bufs_sml_se); if (unlikely(!__pyx_tuple__146)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__146);
+  __Pyx_GIVEREF(__pyx_tuple__146);
+
+  /* "uvloop/handles/stream.pyx":227
+ *     cdef _set_protocol(self, object protocol):
+ *         if protocol is None:
+ *             raise TypeError('protocol is required')             # <<<<<<<<<<<<<<
+ * 
+ *         UVBaseTransport._set_protocol(self, protocol)
+ */
+  __pyx_tuple__147 = PyTuple_Pack(1, __pyx_kp_u_protocol_is_required); if (unlikely(!__pyx_tuple__147)) __PYX_ERR(18, 227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__147);
+  __Pyx_GIVEREF(__pyx_tuple__147);
+
+  /* "uvloop/handles/stream.pyx":354
+ * 
+ *         if (<uv.uv_stream_t*>self._handle).write_queue_size != 0:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'UVStream._try_write called with data in uv buffers')
+ * 
+ */
+  __pyx_tuple__148 = PyTuple_Pack(1, __pyx_kp_u_UVStream__try_write_called_with); if (unlikely(!__pyx_tuple__148)) __PYX_ERR(18, 354, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__148);
+  __Pyx_GIVEREF(__pyx_tuple__148);
+
+  /* "uvloop/handles/stream.pyx":436
+ *             if UVLOOP_DEBUG:
+ *                 if self._buffer_size != 0 or self._buffer != []:
+ *                     raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                         '_buffer_size is not 0 after a successful _exec_write')
+ * 
+ */
+  __pyx_tuple__149 = PyTuple_Pack(1, __pyx_kp_u_buffer_size_is_not_0_after_a_su); if (unlikely(!__pyx_tuple__149)) __PYX_ERR(18, 436, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__149);
+  __Pyx_GIVEREF(__pyx_tuple__149);
+
+  /* "uvloop/handles/stream.pyx":482
+ *                     if not self._closing:
+ *                         # This should never happen.
+ *                         raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                             'stream is open after UVStream._try_write '
+ *                             'returned None')
+ */
+  __pyx_tuple__150 = PyTuple_Pack(1, __pyx_kp_u_stream_is_open_after_UVStream__t); if (unlikely(!__pyx_tuple__150)) __PYX_ERR(18, 482, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__150);
+  __Pyx_GIVEREF(__pyx_tuple__150);
+
+  /* "uvloop/handles/stream.pyx":498
+ *                     if UVLOOP_DEBUG:
+ *                         if sent == len(data):
+ *                             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                                 '_try_write sent all data and returned '
+ *                                 'non-zero')
+ */
+  __pyx_tuple__151 = PyTuple_Pack(1, __pyx_kp_u_try_write_sent_all_data_and_ret); if (unlikely(!__pyx_tuple__151)) __PYX_ERR(18, 498, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__151);
+  __Pyx_GIVEREF(__pyx_tuple__151);
+
+  /* "uvloop/handles/stream.pyx":676
+ * 
+ *         if self._eof:
+ *             raise RuntimeError('Cannot call write() after write_eof()')             # <<<<<<<<<<<<<<
+ *         if not buf:
+ *             return
+ */
+  __pyx_tuple__152 = PyTuple_Pack(1, __pyx_kp_u_Cannot_call_write_after_write_eo); if (unlikely(!__pyx_tuple__152)) __PYX_ERR(18, 676, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__152);
+  __Pyx_GIVEREF(__pyx_tuple__152);
+
+  /* "uvloop/handles/stream.pyx":688
+ * 
+ *         if self._eof:
+ *             raise RuntimeError('Cannot call writelines() after write_eof()')             # <<<<<<<<<<<<<<
+ *         if self._conn_lost:
+ *             self._conn_lost += 1
+ */
+  __pyx_tuple__153 = PyTuple_Pack(1, __pyx_kp_u_Cannot_call_writelines_after_wri); if (unlikely(!__pyx_tuple__153)) __PYX_ERR(18, 688, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__153);
+  __Pyx_GIVEREF(__pyx_tuple__153);
+
+  /* "(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__154 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__154)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__154);
+  __Pyx_GIVEREF(__pyx_tuple__154);
+
+  /* "(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__155 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__155)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__155);
+  __Pyx_GIVEREF(__pyx_tuple__155);
+
+  /* "uvloop/handles/stream.pyx":960
+ *     if nread == uv.UV_ENOBUFS:
+ *         sc._fatal_error(
+ *             RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'unhandled error (or an empty buffer) in get_buffer()'),
+ *             False)
+ */
+  __pyx_tuple__156 = PyTuple_Pack(1, __pyx_kp_u_unhandled_error_or_an_empty_buff); if (unlikely(!__pyx_tuple__156)) __PYX_ERR(18, 960, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__156);
+  __Pyx_GIVEREF(__pyx_tuple__156);
+
+  /* "uvloop/handles/streamserver.pyx":51
+ * 
+ *         if self.protocol_factory is None:
+ *             raise RuntimeError('unable to listen(); no protocol_factory')             # <<<<<<<<<<<<<<
+ * 
+ *         if self.opened != 1:
+ */
+  __pyx_tuple__157 = PyTuple_Pack(1, __pyx_kp_u_unable_to_listen_no_protocol_fac); if (unlikely(!__pyx_tuple__157)) __PYX_ERR(19, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__157);
+  __Pyx_GIVEREF(__pyx_tuple__157);
+
+  /* "uvloop/handles/streamserver.pyx":54
+ * 
+ *         if self.opened != 1:
+ *             raise RuntimeError('unopened TCPServer')             # <<<<<<<<<<<<<<
+ * 
+ *         self.context = Context_CopyCurrent()
+ */
+  __pyx_tuple__158 = PyTuple_Pack(1, __pyx_kp_u_unopened_TCPServer); if (unlikely(!__pyx_tuple__158)) __PYX_ERR(19, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__158);
+  __Pyx_GIVEREF(__pyx_tuple__158);
+
+  /* "(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__159 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__159)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__159);
+  __Pyx_GIVEREF(__pyx_tuple__159);
+
+  /* "(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__160 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__160)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__160);
+  __Pyx_GIVEREF(__pyx_tuple__160);
+
+  /* "(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__161 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__161)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__161);
+  __Pyx_GIVEREF(__pyx_tuple__161);
+
+  /* "(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__162 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__162)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__162);
+  __Pyx_GIVEREF(__pyx_tuple__162);
+
+  /* "(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__163 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__163)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__163);
+  __Pyx_GIVEREF(__pyx_tuple__163);
+
+  /* "(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__164 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__164)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__164);
+  __Pyx_GIVEREF(__pyx_tuple__164);
+
+  /* "(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__165 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__165)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__165);
+  __Pyx_GIVEREF(__pyx_tuple__165);
+
+  /* "(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__166 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__166)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__166);
+  __Pyx_GIVEREF(__pyx_tuple__166);
+
+  /* "(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__167 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__167)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__167);
+  __Pyx_GIVEREF(__pyx_tuple__167);
+
+  /* "(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__168 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__168)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__168);
+  __Pyx_GIVEREF(__pyx_tuple__168);
+
+  /* "(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__169 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__169)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__169);
+  __Pyx_GIVEREF(__pyx_tuple__169);
+
+  /* "(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__170 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__170)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__170);
+  __Pyx_GIVEREF(__pyx_tuple__170);
+
+  /* "(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__171 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__171)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__171);
+  __Pyx_GIVEREF(__pyx_tuple__171);
+
+  /* "(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__172 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__172)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__172);
+  __Pyx_GIVEREF(__pyx_tuple__172);
+
+  /* "(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__173 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__173)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__173);
+  __Pyx_GIVEREF(__pyx_tuple__173);
+
+  /* "(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__174 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__174)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__174);
+  __Pyx_GIVEREF(__pyx_tuple__174);
+
+  /* "(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__175 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__175)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__175);
+  __Pyx_GIVEREF(__pyx_tuple__175);
+
+  /* "(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__176 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__176)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__176);
+  __Pyx_GIVEREF(__pyx_tuple__176);
+
+  /* "uvloop/handles/process.pyx":68
+ *             # GIL should help us to avoid that.)
+ *             self._abort_init()
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'Racing with another loop to spawn a process.')
+ * 
+ */
+  __pyx_tuple__177 = PyTuple_Pack(1, __pyx_kp_u_Racing_with_another_loop_to_spaw); if (unlikely(!__pyx_tuple__177)) __PYX_ERR(4, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__177);
+  __Pyx_GIVEREF(__pyx_tuple__177);
+
+  /* "uvloop/handles/process.pyx":152
+ *             # process must be dead now.
+ *             try:
+ *                 exc_name, exc_msg = errpipe_data.split(b':', 1)             # <<<<<<<<<<<<<<
+ *                 exc_name = exc_name.decode()
+ *                 exc_msg = exc_msg.decode()
+ */
+  __pyx_tuple__179 = PyTuple_Pack(2, __pyx_kp_b__178, __pyx_int_1); if (unlikely(!__pyx_tuple__179)) __PYX_ERR(4, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__179);
+  __Pyx_GIVEREF(__pyx_tuple__179);
+
+  /* "uvloop/handles/process.pyx":188
+ *             except BaseException as ex:
+ *                 try:
+ *                     with open(self._errpipe_write, 'wb') as f:             # <<<<<<<<<<<<<<
+ *                         f.write(str(ex.__class__.__name__).encode())
+ *                         f.write(b':')
+ */
+  __pyx_tuple__180 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__180)) __PYX_ERR(4, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__180);
+  __Pyx_GIVEREF(__pyx_tuple__180);
+
+  /* "uvloop/handles/process.pyx":202
+ *     cdef _close_after_spawn(self, int fd):
+ *         if self._fds_to_close is None:
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'UVProcess._close_after_spawn called after uv_spawn')
+ *         self._fds_to_close.add(fd)
+ */
+  __pyx_tuple__181 = PyTuple_Pack(1, __pyx_kp_u_UVProcess__close_after_spawn_cal); if (unlikely(!__pyx_tuple__181)) __PYX_ERR(4, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__181);
+  __Pyx_GIVEREF(__pyx_tuple__181);
+
+  /* "uvloop/handles/process.pyx":261
+ *                 cwd = PyUnicode_EncodeFSDefault(cwd)
+ *             if not isinstance(cwd, bytes):
+ *                 raise ValueError('cwd must be a str or bytes object')             # <<<<<<<<<<<<<<
+ * 
+ *             self.__cwd = cwd
+ */
+  __pyx_tuple__182 = PyTuple_Pack(1, __pyx_kp_u_cwd_must_be_a_str_or_bytes_objec); if (unlikely(!__pyx_tuple__182)) __PYX_ERR(4, 261, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__182);
+  __Pyx_GIVEREF(__pyx_tuple__182);
+
+  /* "uvloop/handles/process.pyx":276
+ * 
+ *         if an < 1:
+ *             raise ValueError('cannot spawn a process: args are empty')             # <<<<<<<<<<<<<<
+ * 
+ *         self.__args = args.copy()
+ */
+  __pyx_tuple__183 = PyTuple_Pack(1, __pyx_kp_u_cannot_spawn_a_process_args_are); if (unlikely(!__pyx_tuple__183)) __PYX_ERR(4, 276, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__183);
+  __Pyx_GIVEREF(__pyx_tuple__183);
+
+  /* "uvloop/handles/process.pyx":284
+ *                 self.__args[i] = PyUnicode_EncodeFSDefault(arg)
+ *             elif not isinstance(arg, bytes):
+ *                 raise TypeError('all args must be str or bytes')             # <<<<<<<<<<<<<<
+ * 
+ *         path = self.__args[0]
+ */
+  __pyx_tuple__184 = PyTuple_Pack(1, __pyx_kp_u_all_args_must_be_str_or_bytes); if (unlikely(!__pyx_tuple__184)) __PYX_ERR(4, 284, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__184);
+  __Pyx_GIVEREF(__pyx_tuple__184);
+
+  /* "uvloop/handles/process.pyx":299
+ *                     key = PyUnicode_EncodeFSDefault(key)
+ *                 elif not isinstance(key, bytes):
+ *                     raise TypeError(             # <<<<<<<<<<<<<<
+ *                         'all environment vars must be bytes or str')
+ * 
+ */
+  __pyx_tuple__185 = PyTuple_Pack(1, __pyx_kp_u_all_environment_vars_must_be_byt); if (unlikely(!__pyx_tuple__185)) __PYX_ERR(4, 299, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__185);
+  __Pyx_GIVEREF(__pyx_tuple__185);
+
+  /* "uvloop/handles/process.pyx":305
+ *                     val = PyUnicode_EncodeFSDefault(val)
+ *                 elif not isinstance(val, bytes):
+ *                     raise TypeError(             # <<<<<<<<<<<<<<
+ *                         'all environment values must be bytes or str')
+ * 
+ */
+  __pyx_tuple__186 = PyTuple_Pack(1, __pyx_kp_u_all_environment_values_must_be_b); if (unlikely(!__pyx_tuple__186)) __PYX_ERR(4, 305, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__186);
+  __Pyx_GIVEREF(__pyx_tuple__186);
+
+  /* "(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__188 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__188)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__188);
+  __Pyx_GIVEREF(__pyx_tuple__188);
+
+  /* "(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__189 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__189)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__189);
+  __Pyx_GIVEREF(__pyx_tuple__189);
+
+  /* "uvloop/handles/process.pyx":371
+ *                                  context=self.context)
+ *         else:
+ *             self._pending_calls.append((_CALL_PROCESS_EXITED, None, None))             # <<<<<<<<<<<<<<
+ * 
+ *         self._try_finish()
+ */
+  __pyx_tuple__190 = PyTuple_Pack(3, __pyx_int_2, Py_None, Py_None); if (unlikely(!__pyx_tuple__190)) __PYX_ERR(4, 371, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__190);
+  __Pyx_GIVEREF(__pyx_tuple__190);
+
+  /* "uvloop/handles/process.pyx":450
+ *                 io[0] = self._file_devnull()
+ *             elif _stdout == subprocess_STDOUT:
+ *                 raise ValueError(             # <<<<<<<<<<<<<<
+ *                     'subprocess.STDOUT is supported only by stderr parameter')
+ *             else:
+ */
+  __pyx_tuple__191 = PyTuple_Pack(1, __pyx_kp_u_subprocess_STDOUT_is_supported_o); if (unlikely(!__pyx_tuple__191)) __PYX_ERR(4, 450, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__191);
+  __Pyx_GIVEREF(__pyx_tuple__191);
+
+  /* "uvloop/handles/process.pyx":500
+ *                 if io[1] is None:
+ *                     # shouldn't ever happen
+ *                     raise RuntimeError('cannot apply subprocess.STDOUT')             # <<<<<<<<<<<<<<
+ * 
+ *                 newfd = os_dup(io[1])
+ */
+  __pyx_tuple__192 = PyTuple_Pack(1, __pyx_kp_u_cannot_apply_subprocess_STDOUT); if (unlikely(!__pyx_tuple__192)) __PYX_ERR(4, 500, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__192);
+  __Pyx_GIVEREF(__pyx_tuple__192);
+
+  /* "uvloop/handles/process.pyx":568
+ *                                      context=self.context)
+ *             else:
+ *                 self._pending_calls.append((_CALL_CONNECTION_LOST, None, None))             # <<<<<<<<<<<<<<
+ * 
+ *     def __stdio_inited(self, waiter, stdio_fut):
+ */
+  __pyx_tuple__193 = PyTuple_Pack(3, __pyx_int_3, Py_None, Py_None); if (unlikely(!__pyx_tuple__193)) __PYX_ERR(4, 568, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__193);
+  __Pyx_GIVEREF(__pyx_tuple__193);
+
+  /* "(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__194 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__194)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__194);
+  __Pyx_GIVEREF(__pyx_tuple__194);
+
+  /* "(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__195 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__195)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__195);
+  __Pyx_GIVEREF(__pyx_tuple__195);
+
+  /* "(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__196 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__196)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__196);
+  __Pyx_GIVEREF(__pyx_tuple__196);
+
+  /* "(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__197 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__197)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__197);
+  __Pyx_GIVEREF(__pyx_tuple__197);
+
+  /* "uvloop/dns.pyx":22
+ *             return socket_getservbyname(port, 'udp')
+ * 
+ *     raise OSError('service/proto not found')             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_tuple__198 = PyTuple_Pack(1, __pyx_kp_u_service_proto_not_found); if (unlikely(!__pyx_tuple__198)) __PYX_ERR(5, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__198);
+  __Pyx_GIVEREF(__pyx_tuple__198);
+
+  /* "uvloop/dns.pyx":68
+ *         return system.MakeUnixSockPyAddr(addr_un)
+ * 
+ *     raise RuntimeError("cannot convert sockaddr into Python object")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_tuple__199 = PyTuple_Pack(1, __pyx_kp_u_cannot_convert_sockaddr_into_Pyt); if (unlikely(!__pyx_tuple__199)) __PYX_ERR(5, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__199);
+  __Pyx_GIVEREF(__pyx_tuple__199);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")
+ */
+  __pyx_tuple__200 = PyTuple_Pack(1, __pyx_kp_s_Pickling_of_struct_members_such); if (unlikely(!__pyx_tuple__200)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__200);
+  __Pyx_GIVEREF(__pyx_tuple__200);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("Pickling of struct members such as self.addr must be explicitly requested with @auto_pickle(True)")             # <<<<<<<<<<<<<<
+ */
+  __pyx_tuple__201 = PyTuple_Pack(1, __pyx_kp_s_Pickling_of_struct_members_such); if (unlikely(!__pyx_tuple__201)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__201);
+  __Pyx_GIVEREF(__pyx_tuple__201);
+
+  /* "uvloop/dns.pyx":101
+ *     if family == uv.AF_INET:
+ *         if not isinstance(addr, tuple):
+ *             raise TypeError('AF_INET address must be tuple')             # <<<<<<<<<<<<<<
+ *         if len(addr) != 2:
+ *             raise ValueError('AF_INET address must be tuple of (host, port)')
+ */
+  __pyx_tuple__202 = PyTuple_Pack(1, __pyx_kp_u_AF_INET_address_must_be_tuple); if (unlikely(!__pyx_tuple__202)) __PYX_ERR(5, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__202);
+  __Pyx_GIVEREF(__pyx_tuple__202);
+
+  /* "uvloop/dns.pyx":103
+ *             raise TypeError('AF_INET address must be tuple')
+ *         if len(addr) != 2:
+ *             raise ValueError('AF_INET address must be tuple of (host, port)')             # <<<<<<<<<<<<<<
+ *         host, port = addr
+ *         if isinstance(host, str):
+ */
+  __pyx_tuple__203 = PyTuple_Pack(1, __pyx_kp_u_AF_INET_address_must_be_tuple_of); if (unlikely(!__pyx_tuple__203)) __PYX_ERR(5, 103, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__203);
+  __Pyx_GIVEREF(__pyx_tuple__203);
+
+  /* "uvloop/dns.pyx":112
+ *                 host = host.encode('idna')
+ *         if not isinstance(host, (bytes, bytearray)):
+ *             raise TypeError('host must be a string or bytes object')             # <<<<<<<<<<<<<<
+ * 
+ *         port = __port_to_int(port, None)
+ */
+  __pyx_tuple__204 = PyTuple_Pack(1, __pyx_kp_u_host_must_be_a_string_or_bytes_o); if (unlikely(!__pyx_tuple__204)) __PYX_ERR(5, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__204);
+  __Pyx_GIVEREF(__pyx_tuple__204);
+
+  /* "uvloop/dns.pyx":123
+ *     elif family == uv.AF_INET6:
+ *         if not isinstance(addr, tuple):
+ *             raise TypeError('AF_INET6 address must be tuple')             # <<<<<<<<<<<<<<
+ * 
+ *         addr_len = len(addr)
+ */
+  __pyx_tuple__205 = PyTuple_Pack(1, __pyx_kp_u_AF_INET6_address_must_be_tuple); if (unlikely(!__pyx_tuple__205)) __PYX_ERR(5, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__205);
+  __Pyx_GIVEREF(__pyx_tuple__205);
+
+  /* "uvloop/dns.pyx":127
+ *         addr_len = len(addr)
+ *         if addr_len < 2 or addr_len > 4:
+ *             raise ValueError(             # <<<<<<<<<<<<<<
+ *                 'AF_INET6 must be a tuple of 2-4 parameters: '
+ *                 '(host, port, flowinfo?, scope_id?)')
+ */
+  __pyx_tuple__206 = PyTuple_Pack(1, __pyx_kp_u_AF_INET6_must_be_a_tuple_of_2_4); if (unlikely(!__pyx_tuple__206)) __PYX_ERR(5, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__206);
+  __Pyx_GIVEREF(__pyx_tuple__206);
+
+  /* "uvloop/dns.pyx":161
+ *             addr = addr.encode(sys_getfilesystemencoding())
+ *         elif not isinstance(addr, bytes):
+ *             raise TypeError('AF_UNIX address must be a str or a bytes object')             # <<<<<<<<<<<<<<
+ * 
+ *         PyBytes_AsStringAndSize(addr, &buf, &buflen)
+ */
+  __pyx_tuple__207 = PyTuple_Pack(1, __pyx_kp_u_AF_UNIX_address_must_be_a_str_or); if (unlikely(!__pyx_tuple__207)) __PYX_ERR(5, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__207);
+  __Pyx_GIVEREF(__pyx_tuple__207);
+
+  /* "uvloop/dns.pyx":273
+ * 
+ *         if self.data is NULL:
+ *             raise RuntimeError('AddrInfo.data is NULL')             # <<<<<<<<<<<<<<
+ * 
+ *         ptr = self.data
+ */
+  __pyx_tuple__208 = PyTuple_Pack(1, __pyx_kp_u_AddrInfo_data_is_NULL); if (unlikely(!__pyx_tuple__208)) __PYX_ERR(5, 273, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__208);
+  __Pyx_GIVEREF(__pyx_tuple__208);
+
+  /* "(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__209 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__209)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__209);
+  __Pyx_GIVEREF(__pyx_tuple__209);
+
+  /* "(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__210 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__210)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__210);
+  __Pyx_GIVEREF(__pyx_tuple__210);
+
+  /* "(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__211 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__211)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__211);
+  __Pyx_GIVEREF(__pyx_tuple__211);
+
+  /* "(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__212 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__212)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__212);
+  __Pyx_GIVEREF(__pyx_tuple__212);
+
+  /* "(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__213 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__213)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__213);
+  __Pyx_GIVEREF(__pyx_tuple__213);
+
+  /* "(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__214 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__214)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__214);
+  __Pyx_GIVEREF(__pyx_tuple__214);
+
+  /* "uvloop/sslproto.pyx":3
+ * cdef _create_transport_context(server_side, server_hostname):
+ *     if server_side:
+ *         raise ValueError('Server side SSL needs a valid SSLContext')             # <<<<<<<<<<<<<<
+ * 
+ *     # Client side may pass ssl=True to use a default
+ */
+  __pyx_tuple__215 = PyTuple_Pack(1, __pyx_kp_u_Server_side_SSL_needs_a_valid_SS); if (unlikely(!__pyx_tuple__215)) __PYX_ERR(22, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__215);
+  __Pyx_GIVEREF(__pyx_tuple__215);
+
+  /* "(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__216 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__216)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__216);
+  __Pyx_GIVEREF(__pyx_tuple__216);
+
+  /* "(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__217 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__217)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__217);
+  __Pyx_GIVEREF(__pyx_tuple__217);
+
+  /* "uvloop/sslproto.pyx":313
+ *         if self._app_transport is None:
+ *             if self._app_transport_created:
+ *                 raise RuntimeError('Creating _SSLProtocolTransport twice')             # <<<<<<<<<<<<<<
+ *             self._app_transport = _SSLProtocolTransport(self._loop, self,
+ *                                                         context)
+ */
+  __pyx_tuple__218 = PyTuple_Pack(1, __pyx_kp_u_Creating__SSLProtocolTransport_t); if (unlikely(!__pyx_tuple__218)) __PYX_ERR(22, 313, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__218);
+  __Pyx_GIVEREF(__pyx_tuple__218);
+
+  /* "(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__219 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__219)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__219);
+  __Pyx_GIVEREF(__pyx_tuple__219);
+
+  /* "(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__220 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__220)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__220);
+  __Pyx_GIVEREF(__pyx_tuple__220);
+
+  /* "uvloop/handles/udp.pyx":48
+ *         if UVLOOP_DEBUG:
+ *             if not self.closed:
+ *                 raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                     'open _UDPSendContext is being deallocated')
+ *         self.udp = None
+ */
+  __pyx_tuple__221 = PyTuple_Pack(1, __pyx_kp_u_open__UDPSendContext_is_being_de); if (unlikely(!__pyx_tuple__221)) __PYX_ERR(23, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__221);
+  __Pyx_GIVEREF(__pyx_tuple__221);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")
+ */
+  __pyx_tuple__222 = PyTuple_Pack(1, __pyx_kp_s_self_py_buf_self_req_cannot_be_c); if (unlikely(!__pyx_tuple__222)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__222);
+  __Pyx_GIVEREF(__pyx_tuple__222);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("self.py_buf,self.req cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
+ */
+  __pyx_tuple__223 = PyTuple_Pack(1, __pyx_kp_s_self_py_buf_self_req_cannot_be_c); if (unlikely(!__pyx_tuple__223)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__223);
+  __Pyx_GIVEREF(__pyx_tuple__223);
+
+  /* "uvloop/handles/udp.pyx":188
+ *     cdef _new_socket(self):
+ *         if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+ *             raise RuntimeError(             # <<<<<<<<<<<<<<
+ *                 'UDPTransport.family is undefined; '
+ *                 'cannot create python socket')
+ */
+  __pyx_tuple__224 = PyTuple_Pack(1, __pyx_kp_u_UDPTransport_family_is_undefined); if (unlikely(!__pyx_tuple__224)) __PYX_ERR(23, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__224);
+  __Pyx_GIVEREF(__pyx_tuple__224);
+
+  /* "uvloop/handles/udp.pyx":206
+ * 
+ *         if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+ *             raise RuntimeError('UDPTransport.family is undefined; cannot send')             # <<<<<<<<<<<<<<
+ * 
+ *         if addr is None:
+ */
+  __pyx_tuple__225 = PyTuple_Pack(1, __pyx_kp_u_UDPTransport_family_is_undefined_2); if (unlikely(!__pyx_tuple__225)) __PYX_ERR(23, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__225);
+  __Pyx_GIVEREF(__pyx_tuple__225);
+
+  /* "(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__226 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__226)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__226);
+  __Pyx_GIVEREF(__pyx_tuple__226);
+
+  /* "(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__227 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__227)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__227);
+  __Pyx_GIVEREF(__pyx_tuple__227);
+
+  /* "(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__228 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__228)) __PYX_ERR(7, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__228);
+  __Pyx_GIVEREF(__pyx_tuple__228);
+
+  /* "(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__229 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__229)) __PYX_ERR(7, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__229);
+  __Pyx_GIVEREF(__pyx_tuple__229);
+
+  /* "cfunc.to_py":65
+ * @cname("__Pyx_CFunc_object____Loop____bint___to_py")
+ * cdef object __Pyx_CFunc_object____Loop____bint___to_py(object (*f)(Loop, bint) ):
+ *     def wrap(Loop self, bint enabled):             # <<<<<<<<<<<<<<
+ *         """wrap(self: 'Loop', enabled: bool)"""
+ *         return f(self, enabled)
+ */
+  __pyx_tuple__231 = PyTuple_Pack(2, __pyx_n_s_self_2, __pyx_n_s_enabled); if (unlikely(!__pyx_tuple__231)) __PYX_ERR(7, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__231);
+  __Pyx_GIVEREF(__pyx_tuple__231);
+  __pyx_codeobj__232 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__231, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_wrap, 65, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__232)) __PYX_ERR(7, 65, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3207
+ * class _SyncSocketReaderFuture(aio_Future):
+ * 
+ *     def __init__(self, sock, loop):             # <<<<<<<<<<<<<<
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock
+ */
+  __pyx_tuple__233 = PyTuple_Pack(3, __pyx_n_s_self_2, __pyx_n_s_sock, __pyx_n_s_loop); if (unlikely(!__pyx_tuple__233)) __PYX_ERR(0, 3207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__233);
+  __Pyx_GIVEREF(__pyx_tuple__233);
+  __pyx_codeobj__234 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__233, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_loop_pyx, __pyx_n_s_init, 3207, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__234)) __PYX_ERR(0, 3207, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3212
+ *         self.__loop = loop
+ * 
+ *     def __remove_reader(self):             # <<<<<<<<<<<<<<
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_reader(self.__sock)
+ */
+  __pyx_tuple__235 = PyTuple_Pack(1, __pyx_n_s_self_2); if (unlikely(!__pyx_tuple__235)) __PYX_ERR(0, 3212, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__235);
+  __Pyx_GIVEREF(__pyx_tuple__235);
+  __pyx_codeobj__236 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__235, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_loop_pyx, __pyx_n_s_remove_reader_2, 3212, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__236)) __PYX_ERR(0, 3212, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3218
+ * 
+ *     if PY39:
+ *         def cancel(self, msg=None):             # <<<<<<<<<<<<<<
+ *             self.__remove_reader()
+ *             aio_Future.cancel(self, msg=msg)
+ */
+  __pyx_tuple__237 = PyTuple_Pack(2, __pyx_n_s_self_2, __pyx_n_s_msg); if (unlikely(!__pyx_tuple__237)) __PYX_ERR(0, 3218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__237);
+  __Pyx_GIVEREF(__pyx_tuple__237);
+  __pyx_codeobj__238 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__237, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_loop_pyx, __pyx_n_s_cancel, 3218, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__238)) __PYX_ERR(0, 3218, __pyx_L1_error)
+  __pyx_tuple__239 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__239)) __PYX_ERR(0, 3218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__239);
+  __Pyx_GIVEREF(__pyx_tuple__239);
+
+  /* "uvloop/loop.pyx":3223
+ * 
+ *     else:
+ *         def cancel(self):             # <<<<<<<<<<<<<<
+ *             self.__remove_reader()
+ *             aio_Future.cancel(self)
+ */
+  __pyx_tuple__240 = PyTuple_Pack(1, __pyx_n_s_self_2); if (unlikely(!__pyx_tuple__240)) __PYX_ERR(0, 3223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__240);
+  __Pyx_GIVEREF(__pyx_tuple__240);
+  __pyx_codeobj__241 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__240, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_loop_pyx, __pyx_n_s_cancel, 3223, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__241)) __PYX_ERR(0, 3223, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3230
+ * class _SyncSocketWriterFuture(aio_Future):
+ * 
+ *     def __init__(self, sock, loop):             # <<<<<<<<<<<<<<
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock
+ */
+  __pyx_tuple__242 = PyTuple_Pack(3, __pyx_n_s_self_2, __pyx_n_s_sock, __pyx_n_s_loop); if (unlikely(!__pyx_tuple__242)) __PYX_ERR(0, 3230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__242);
+  __Pyx_GIVEREF(__pyx_tuple__242);
+  __pyx_codeobj__243 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__242, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_loop_pyx, __pyx_n_s_init, 3230, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__243)) __PYX_ERR(0, 3230, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3235
+ *         self.__loop = loop
+ * 
+ *     def __remove_writer(self):             # <<<<<<<<<<<<<<
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_writer(self.__sock)
+ */
+  __pyx_tuple__244 = PyTuple_Pack(1, __pyx_n_s_self_2); if (unlikely(!__pyx_tuple__244)) __PYX_ERR(0, 3235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__244);
+  __Pyx_GIVEREF(__pyx_tuple__244);
+  __pyx_codeobj__245 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__244, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_loop_pyx, __pyx_n_s_remove_writer_2, 3235, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__245)) __PYX_ERR(0, 3235, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3241
+ * 
+ *     if PY39:
+ *         def cancel(self, msg=None):             # <<<<<<<<<<<<<<
+ *             self.__remove_writer()
+ *             aio_Future.cancel(self, msg=msg)
+ */
+  __pyx_tuple__246 = PyTuple_Pack(2, __pyx_n_s_self_2, __pyx_n_s_msg); if (unlikely(!__pyx_tuple__246)) __PYX_ERR(0, 3241, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__246);
+  __Pyx_GIVEREF(__pyx_tuple__246);
+  __pyx_codeobj__247 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__246, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_loop_pyx, __pyx_n_s_cancel, 3241, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__247)) __PYX_ERR(0, 3241, __pyx_L1_error)
+  __pyx_tuple__248 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__248)) __PYX_ERR(0, 3241, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__248);
+  __Pyx_GIVEREF(__pyx_tuple__248);
+
+  /* "uvloop/loop.pyx":3246
+ * 
+ *     else:
+ *         def cancel(self):             # <<<<<<<<<<<<<<
+ *             self.__remove_writer()
+ *             aio_Future.cancel(self)
+ */
+  __pyx_tuple__249 = PyTuple_Pack(1, __pyx_n_s_self_2); if (unlikely(!__pyx_tuple__249)) __PYX_ERR(0, 3246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__249);
+  __Pyx_GIVEREF(__pyx_tuple__249);
+  __pyx_codeobj__250 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__249, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_loop_pyx, __pyx_n_s_cancel, 3246, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__250)) __PYX_ERR(0, 3246, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":694
+ * class WriteSubprocessPipeProto(aio_BaseProtocol):
+ * 
+ *     def __init__(self, proc, fd):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if type(proc) is not UVProcessTransport:
+ */
+  __pyx_tuple__251 = PyTuple_Pack(3, __pyx_n_s_self_2, __pyx_n_s_proc, __pyx_n_s_fd); if (unlikely(!__pyx_tuple__251)) __PYX_ERR(4, 694, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__251);
+  __Pyx_GIVEREF(__pyx_tuple__251);
+  __pyx_codeobj__252 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__251, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_handles_process_pyx, __pyx_n_s_init, 694, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__252)) __PYX_ERR(4, 694, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":705
+ *         self.disconnected = False
+ * 
+ *     def connection_made(self, transport):             # <<<<<<<<<<<<<<
+ *         self.pipe = transport
+ * 
+ */
+  __pyx_tuple__253 = PyTuple_Pack(2, __pyx_n_s_self_2, __pyx_n_s_transport); if (unlikely(!__pyx_tuple__253)) __PYX_ERR(4, 705, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__253);
+  __Pyx_GIVEREF(__pyx_tuple__253);
+  __pyx_codeobj__254 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__253, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_handles_process_pyx, __pyx_n_s_connection_made, 705, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__254)) __PYX_ERR(4, 705, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":708
+ *         self.pipe = transport
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return ('<%s fd=%s pipe=%r>'
+ *                 % (self.__class__.__name__, self.fd, self.pipe))
+ */
+  __pyx_tuple__255 = PyTuple_Pack(1, __pyx_n_s_self_2); if (unlikely(!__pyx_tuple__255)) __PYX_ERR(4, 708, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__255);
+  __Pyx_GIVEREF(__pyx_tuple__255);
+  __pyx_codeobj__256 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__255, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_handles_process_pyx, __pyx_n_s_repr, 708, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__256)) __PYX_ERR(4, 708, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":712
+ *                 % (self.__class__.__name__, self.fd, self.pipe))
+ * 
+ *     def connection_lost(self, exc):             # <<<<<<<<<<<<<<
+ *         self.disconnected = True
+ *         (<UVProcessTransport>self.proc)._pipe_connection_lost(self.fd, exc)
+ */
+  __pyx_tuple__257 = PyTuple_Pack(2, __pyx_n_s_self_2, __pyx_n_s_exc); if (unlikely(!__pyx_tuple__257)) __PYX_ERR(4, 712, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__257);
+  __Pyx_GIVEREF(__pyx_tuple__257);
+  __pyx_codeobj__258 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__257, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_handles_process_pyx, __pyx_n_s_connection_lost, 712, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__258)) __PYX_ERR(4, 712, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":717
+ *         self.proc = None
+ * 
+ *     def pause_writing(self):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._protocol.pause_writing()
+ * 
+ */
+  __pyx_tuple__259 = PyTuple_Pack(1, __pyx_n_s_self_2); if (unlikely(!__pyx_tuple__259)) __PYX_ERR(4, 717, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__259);
+  __Pyx_GIVEREF(__pyx_tuple__259);
+  __pyx_codeobj__260 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__259, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_handles_process_pyx, __pyx_n_s_pause_writing, 717, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__260)) __PYX_ERR(4, 717, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":720
+ *         (<UVProcessTransport>self.proc)._protocol.pause_writing()
+ * 
+ *     def resume_writing(self):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._protocol.resume_writing()
+ * 
+ */
+  __pyx_tuple__261 = PyTuple_Pack(1, __pyx_n_s_self_2); if (unlikely(!__pyx_tuple__261)) __PYX_ERR(4, 720, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__261);
+  __Pyx_GIVEREF(__pyx_tuple__261);
+  __pyx_codeobj__262 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__261, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_handles_process_pyx, __pyx_n_s_resume_writing, 720, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__262)) __PYX_ERR(4, 720, __pyx_L1_error)
+
+  /* "uvloop/handles/process.pyx":727
+ *                               aio_Protocol):
+ * 
+ *     def data_received(self, data):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._pipe_data_received(self.fd, data)
+ * 
+ */
+  __pyx_tuple__263 = PyTuple_Pack(2, __pyx_n_s_self_2, __pyx_n_s_data); if (unlikely(!__pyx_tuple__263)) __PYX_ERR(4, 727, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__263);
+  __Pyx_GIVEREF(__pyx_tuple__263);
+  __pyx_codeobj__264 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__263, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_uvloop_handles_process_pyx, __pyx_n_s_data_received, 727, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__264)) __PYX_ERR(4, 727, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":3334
+ * 
+ * @cython.iterable_coroutine
+ * async def _test_coroutine_1():             # <<<<<<<<<<<<<<
+ *     return 42
+ */
+  __pyx_codeobj__230 = (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_uvloop_loop_pyx, __pyx_n_s_test_coroutine_1, 3334, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__230)) __PYX_ERR(0, 3334, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_PseudoSocket(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_tuple__265 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__265)) __PYX_ERR(7, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__265);
+  __Pyx_GIVEREF(__pyx_tuple__265);
+  __pyx_codeobj__266 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__265, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PseudoSocket, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__266)) __PYX_ERR(7, 1, __pyx_L1_error)
+  __pyx_tuple__267 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__267)) __PYX_ERR(7, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__267);
+  __Pyx_GIVEREF(__pyx_tuple__267);
+  __pyx_codeobj__268 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__267, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_LruCache, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__268)) __PYX_ERR(7, 1, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  __pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type;
+  __pyx_umethod_PyList_Type_copy.type = (PyObject*)&PyList_Type;
+  __pyx_umethod_PyUnicode_Type_rstrip.type = (PyObject*)&PyUnicode_Type;
+  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  __pyx_float_0_1 = PyFloat_FromDouble(0.1); if (unlikely(!__pyx_float_0_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_float_1e3 = PyFloat_FromDouble(1e3); if (unlikely(!__pyx_float_1e3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_float_1eneg_3 = PyFloat_FromDouble(1e-3); if (unlikely(!__pyx_float_1eneg_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_float_30_0 = PyFloat_FromDouble(30.0); if (unlikely(!__pyx_float_30_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_float_60_0 = PyFloat_FromDouble(60.0); if (unlikely(!__pyx_float_60_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_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_15 = PyInt_FromLong(15); if (unlikely(!__pyx_int_15)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_42 = PyInt_FromLong(42); if (unlikely(!__pyx_int_42)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_100 = PyInt_FromLong(100); if (unlikely(!__pyx_int_100)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_1000 = PyInt_FromLong(1000); if (unlikely(!__pyx_int_1000)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_2048 = PyInt_FromLong(2048); if (unlikely(!__pyx_int_2048)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_50000 = PyInt_FromLong(50000L); if (unlikely(!__pyx_int_50000)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_65536 = PyInt_FromLong(65536L); if (unlikely(!__pyx_int_65536)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_262144 = PyInt_FromLong(262144L); if (unlikely(!__pyx_int_262144)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_1048575 = PyInt_FromLong(1048575L); if (unlikely(!__pyx_int_1048575)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_87255255 = PyInt_FromLong(87255255L); if (unlikely(!__pyx_int_87255255)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_143395587 = PyInt_FromLong(143395587L); if (unlikely(!__pyx_int_143395587)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_4294967296 = PyInt_FromString((char *)"4294967296", 0, 0); if (unlikely(!__pyx_int_4294967296)) __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)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+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_v_6uvloop_4loop_aio_get_event_loop = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_CancelledError = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_InvalidStateError = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_TimeoutError = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_Future = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_Task = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_ensure_future = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_gather = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_wait = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_wrap_future = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_logger = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_iscoroutine = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_iscoroutinefunction = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_BaseProtocol = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_Protocol = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_isfuture = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_get_running_loop = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_set_running_loop = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_debug_wrapper = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_AbstractChildWatcher = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_Transport = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_aio_FlowControlMixin = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_col_deque = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_col_Iterable = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_col_Counter = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_col_OrderedDict = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_cc_ThreadPoolExecutor = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_cc_Future = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_errno_EBADF = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_errno_EINVAL = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_ft_partial = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_gc_disable = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_iter_chain = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_inspect_isgenerator = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_socket_gaierror = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_socket_error = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_socket_timeout = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_socket_socket = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_socket_socketpair = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_socket_getservbyname = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_socket_AddressFamily = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_socket_SocketKind = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_name = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_environ = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_dup = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_set_inheritable = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_get_inheritable = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_close = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_open = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_devnull = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_O_RDWR = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_pipe = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_read = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_remove = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_stat = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_os_fspath = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_stat_S_ISSOCK = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_sys_ignore_environment = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_sys_exc_info = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_sys_set_coroutine_wrapper = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_sys_get_coroutine_wrapper = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_sys_getframe = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_sys_version_info = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_sys_getfilesystemencoding = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_sys_platform = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_ssl_SSLContext = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_ssl_MemoryBIO = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_ssl_create_default_context = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_ssl_SSLError = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_ssl_SSLAgainErrors = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_ssl_SSLZeroReturnError = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_ssl_CertificateError = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_threading_Thread = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_subprocess_SubprocessError = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_signal_signal = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_signal_siginterrupt = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_signal_set_wakeup_fd = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_signal_default_int_handler = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_signal_SIG_DFL = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_time_sleep = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_time_monotonic = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_tb_StackSummary = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_tb_walk_stack = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_tb_format_list = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_warnings_warn = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_weakref_WeakValueDictionary = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_weakref_WeakSet = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_py_inf = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop__LRU_MARKER = Py_None; Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop_sockaddrs = ((struct __pyx_obj_6uvloop_4loop_LruCache *)Py_None); Py_INCREF(Py_None);
+  __pyx_v_6uvloop_4loop___forking_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None); Py_INCREF(Py_None);
+  __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 ---*/
+  __pyx_vtabptr_6uvloop_4loop_UVHandle = &__pyx_vtable_6uvloop_4loop_UVHandle;
+  __pyx_vtable_6uvloop_4loop_UVHandle._start_init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *, struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_8UVHandle__start_init;
+  __pyx_vtable_6uvloop_4loop_UVHandle._abort_init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *))__pyx_f_6uvloop_4loop_8UVHandle__abort_init;
+  __pyx_vtable_6uvloop_4loop_UVHandle._finish_init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *))__pyx_f_6uvloop_4loop_8UVHandle__finish_init;
+  __pyx_vtable_6uvloop_4loop_UVHandle._is_alive = (int (*)(struct __pyx_obj_6uvloop_4loop_UVHandle *))__pyx_f_6uvloop_4loop_8UVHandle__is_alive;
+  __pyx_vtable_6uvloop_4loop_UVHandle._ensure_alive = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *))__pyx_f_6uvloop_4loop_8UVHandle__ensure_alive;
+  __pyx_vtable_6uvloop_4loop_UVHandle._error = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_8UVHandle__error;
+  __pyx_vtable_6uvloop_4loop_UVHandle._fatal_error = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *, PyObject *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error *__pyx_optional_args))__pyx_f_6uvloop_4loop_8UVHandle__fatal_error;
+  __pyx_vtable_6uvloop_4loop_UVHandle._warn_unclosed = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *))__pyx_f_6uvloop_4loop_8UVHandle__warn_unclosed;
+  __pyx_vtable_6uvloop_4loop_UVHandle._free = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *))__pyx_f_6uvloop_4loop_8UVHandle__free;
+  __pyx_vtable_6uvloop_4loop_UVHandle._close = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *))__pyx_f_6uvloop_4loop_8UVHandle__close;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVHandle) < 0) __PYX_ERR(2, 1, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVHandle.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVHandle.tp_dictoffset && __pyx_type_6uvloop_4loop_UVHandle.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVHandle.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVHandle.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVHandle) < 0) __PYX_ERR(2, 1, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVHandle, (PyObject *)&__pyx_type_6uvloop_4loop_UVHandle) < 0) __PYX_ERR(2, 1, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVHandle) < 0) __PYX_ERR(2, 1, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVHandle = &__pyx_type_6uvloop_4loop_UVHandle;
+  __pyx_vtabptr_6uvloop_4loop_UVSocketHandle = &__pyx_vtable_6uvloop_4loop_UVSocketHandle;
+  __pyx_vtable_6uvloop_4loop_UVSocketHandle.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVHandle;
+  __pyx_vtable_6uvloop_4loop_UVSocketHandle.__pyx_base._close = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *))__pyx_f_6uvloop_4loop_14UVSocketHandle__close;
+  __pyx_vtable_6uvloop_4loop_UVSocketHandle._fileno = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *))__pyx_f_6uvloop_4loop_14UVSocketHandle__fileno;
+  __pyx_vtable_6uvloop_4loop_UVSocketHandle._new_socket = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *))__pyx_f_6uvloop_4loop_14UVSocketHandle__new_socket;
+  __pyx_vtable_6uvloop_4loop_UVSocketHandle._get_socket = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *))__pyx_f_6uvloop_4loop_14UVSocketHandle__get_socket;
+  __pyx_vtable_6uvloop_4loop_UVSocketHandle._attach_fileobj = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, PyObject *))__pyx_f_6uvloop_4loop_14UVSocketHandle__attach_fileobj;
+  __pyx_vtable_6uvloop_4loop_UVSocketHandle._open = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, int))__pyx_f_6uvloop_4loop_14UVSocketHandle__open;
+  __pyx_type_6uvloop_4loop_UVSocketHandle.tp_base = __pyx_ptype_6uvloop_4loop_UVHandle;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVSocketHandle) < 0) __PYX_ERR(2, 221, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVSocketHandle.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVSocketHandle.tp_dictoffset && __pyx_type_6uvloop_4loop_UVSocketHandle.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVSocketHandle.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVSocketHandle.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVSocketHandle) < 0) __PYX_ERR(2, 221, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVSocketHandle, (PyObject *)&__pyx_type_6uvloop_4loop_UVSocketHandle) < 0) __PYX_ERR(2, 221, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVSocketHandle) < 0) __PYX_ERR(2, 221, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVSocketHandle = &__pyx_type_6uvloop_4loop_UVSocketHandle;
+  __pyx_vtabptr_6uvloop_4loop_UVAsync = &__pyx_vtable_6uvloop_4loop_UVAsync;
+  __pyx_vtable_6uvloop_4loop_UVAsync.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVHandle;
+  __pyx_vtable_6uvloop_4loop_UVAsync._init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVAsync *, struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *))__pyx_f_6uvloop_4loop_7UVAsync__init;
+  __pyx_vtable_6uvloop_4loop_UVAsync.send = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVAsync *))__pyx_f_6uvloop_4loop_7UVAsync_send;
+  __pyx_vtable_6uvloop_4loop_UVAsync.new = (struct __pyx_obj_6uvloop_4loop_UVAsync *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *))__pyx_f_6uvloop_4loop_7UVAsync_new;
+  __pyx_type_6uvloop_4loop_UVAsync.tp_base = __pyx_ptype_6uvloop_4loop_UVHandle;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVAsync) < 0) __PYX_ERR(11, 2, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVAsync.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVAsync.tp_dictoffset && __pyx_type_6uvloop_4loop_UVAsync.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVAsync.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVAsync.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVAsync) < 0) __PYX_ERR(11, 2, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVAsync, (PyObject *)&__pyx_type_6uvloop_4loop_UVAsync) < 0) __PYX_ERR(11, 2, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVAsync) < 0) __PYX_ERR(11, 2, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVAsync = &__pyx_type_6uvloop_4loop_UVAsync;
+  __pyx_vtabptr_6uvloop_4loop_UVTimer = &__pyx_vtable_6uvloop_4loop_UVTimer;
+  __pyx_vtable_6uvloop_4loop_UVTimer.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVHandle;
+  __pyx_vtable_6uvloop_4loop_UVTimer._init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVTimer *, struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *, uint64_t))__pyx_f_6uvloop_4loop_7UVTimer__init;
+  __pyx_vtable_6uvloop_4loop_UVTimer.stop = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVTimer *))__pyx_f_6uvloop_4loop_7UVTimer_stop;
+  __pyx_vtable_6uvloop_4loop_UVTimer.start = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVTimer *))__pyx_f_6uvloop_4loop_7UVTimer_start;
+  __pyx_vtable_6uvloop_4loop_UVTimer.get_when = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVTimer *))__pyx_f_6uvloop_4loop_7UVTimer_get_when;
+  __pyx_vtable_6uvloop_4loop_UVTimer.new = (struct __pyx_obj_6uvloop_4loop_UVTimer *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *, uint64_t))__pyx_f_6uvloop_4loop_7UVTimer_new;
+  __pyx_type_6uvloop_4loop_UVTimer.tp_base = __pyx_ptype_6uvloop_4loop_UVHandle;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVTimer) < 0) __PYX_ERR(14, 2, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVTimer.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVTimer.tp_dictoffset && __pyx_type_6uvloop_4loop_UVTimer.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVTimer.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVTimer.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVTimer) < 0) __PYX_ERR(14, 2, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVTimer, (PyObject *)&__pyx_type_6uvloop_4loop_UVTimer) < 0) __PYX_ERR(14, 2, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVTimer) < 0) __PYX_ERR(14, 2, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVTimer = &__pyx_type_6uvloop_4loop_UVTimer;
+  __pyx_vtabptr_6uvloop_4loop_UVIdle = &__pyx_vtable_6uvloop_4loop_UVIdle;
+  __pyx_vtable_6uvloop_4loop_UVIdle.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVHandle;
+  __pyx_vtable_6uvloop_4loop_UVIdle._init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVIdle *, struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_6UVIdle__init;
+  __pyx_vtable_6uvloop_4loop_UVIdle.stop = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVIdle *))__pyx_f_6uvloop_4loop_6UVIdle_stop;
+  __pyx_vtable_6uvloop_4loop_UVIdle.start = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVIdle *))__pyx_f_6uvloop_4loop_6UVIdle_start;
+  __pyx_vtable_6uvloop_4loop_UVIdle.new = (struct __pyx_obj_6uvloop_4loop_UVIdle *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_6UVIdle_new;
+  __pyx_type_6uvloop_4loop_UVIdle.tp_base = __pyx_ptype_6uvloop_4loop_UVHandle;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVIdle) < 0) __PYX_ERR(12, 2, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVIdle.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVIdle.tp_dictoffset && __pyx_type_6uvloop_4loop_UVIdle.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVIdle.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVIdle.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVIdle) < 0) __PYX_ERR(12, 2, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVIdle, (PyObject *)&__pyx_type_6uvloop_4loop_UVIdle) < 0) __PYX_ERR(12, 2, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVIdle) < 0) __PYX_ERR(12, 2, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVIdle = &__pyx_type_6uvloop_4loop_UVIdle;
+  __pyx_vtabptr_6uvloop_4loop_UVBaseTransport = &__pyx_vtable_6uvloop_4loop_UVBaseTransport;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVSocketHandle;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport.__pyx_base.__pyx_base._fatal_error = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *, PyObject *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error *__pyx_optional_args))__pyx_f_6uvloop_4loop_15UVBaseTransport__fatal_error;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._maybe_pause_protocol = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_pause_protocol;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._maybe_resume_protocol = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_resume_protocol;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._schedule_call_connection_made = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_made;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._schedule_call_connection_lost = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *))__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_lost;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._wakeup_waiter = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_15UVBaseTransport__wakeup_waiter;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._call_connection_made = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_15UVBaseTransport__call_connection_made;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._call_connection_lost = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *))__pyx_f_6uvloop_4loop_15UVBaseTransport__call_connection_lost;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._set_server = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, struct __pyx_obj_6uvloop_4loop_Server *))__pyx_f_6uvloop_4loop_15UVBaseTransport__set_server;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._set_waiter = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *))__pyx_f_6uvloop_4loop_15UVBaseTransport__set_waiter;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._set_protocol = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *))__pyx_f_6uvloop_4loop_15UVBaseTransport__set_protocol;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._clear_protocol = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_15UVBaseTransport__clear_protocol;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._init_protocol = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_15UVBaseTransport__init_protocol;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._add_extra_info = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_15UVBaseTransport__add_extra_info;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._get_write_buffer_size = (size_t (*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_15UVBaseTransport__get_write_buffer_size;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._is_reading = (int (*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_15UVBaseTransport__is_reading;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._start_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_15UVBaseTransport__start_reading;
+  __pyx_vtable_6uvloop_4loop_UVBaseTransport._stop_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_15UVBaseTransport__stop_reading;
+  __pyx_type_6uvloop_4loop_UVBaseTransport.tp_base = __pyx_ptype_6uvloop_4loop_UVSocketHandle;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVBaseTransport) < 0) __PYX_ERR(16, 1, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVBaseTransport.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVBaseTransport.tp_dictoffset && __pyx_type_6uvloop_4loop_UVBaseTransport.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVBaseTransport.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVBaseTransport.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVBaseTransport) < 0) __PYX_ERR(16, 1, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVBaseTransport, (PyObject *)&__pyx_type_6uvloop_4loop_UVBaseTransport) < 0) __PYX_ERR(16, 1, __pyx_L1_error)
+  if (__pyx_type_6uvloop_4loop_UVBaseTransport.tp_weaklistoffset == 0) __pyx_type_6uvloop_4loop_UVBaseTransport.tp_weaklistoffset = offsetof(struct __pyx_obj_6uvloop_4loop_UVBaseTransport, __weakref__);
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVBaseTransport) < 0) __PYX_ERR(16, 1, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVBaseTransport = &__pyx_type_6uvloop_4loop_UVBaseTransport;
+  __pyx_vtabptr_6uvloop_4loop_Loop = &__pyx_vtable_6uvloop_4loop_Loop;
+  __pyx_vtable_6uvloop_4loop_Loop._init_debug_fields = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__init_debug_fields;
+  __pyx_vtable_6uvloop_4loop_Loop._on_wake = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__on_wake;
+  __pyx_vtable_6uvloop_4loop_Loop._on_idle = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__on_idle;
+  __pyx_vtable_6uvloop_4loop_Loop.__pyx___run = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, uv_run_mode))__pyx_f_6uvloop_4loop_4Loop___run;
+  __pyx_vtable_6uvloop_4loop_Loop._run = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, uv_run_mode))__pyx_f_6uvloop_4loop_4Loop__run;
+  __pyx_vtable_6uvloop_4loop_Loop._close = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__close;
+  __pyx_vtable_6uvloop_4loop_Loop._stop = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__stop;
+  __pyx_vtable_6uvloop_4loop_Loop._time = (uint64_t (*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__time;
+  __pyx_vtable_6uvloop_4loop_Loop._queue_write = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVStream *))__pyx_f_6uvloop_4loop_4Loop__queue_write;
+  __pyx_vtable_6uvloop_4loop_Loop._exec_queued_writes = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__exec_queued_writes;
+  __pyx_vtable_6uvloop_4loop_Loop._call_soon = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__call_soon;
+  __pyx_vtable_6uvloop_4loop_Loop._append_ready_handle = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_4Loop__append_ready_handle;
+  __pyx_vtable_6uvloop_4loop_Loop._call_soon_handle = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_4Loop__call_soon_handle;
+  __pyx_vtable_6uvloop_4loop_Loop._call_later = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, uint64_t, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__call_later;
+  __pyx_vtable_6uvloop_4loop_Loop._handle_exception = (void (*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__handle_exception;
+  __pyx_vtable_6uvloop_4loop_Loop._is_main_thread = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__is_main_thread;
+  __pyx_vtable_6uvloop_4loop_Loop._new_future = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__new_future;
+  __pyx_vtable_6uvloop_4loop_Loop._check_signal = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__check_signal;
+  __pyx_vtable_6uvloop_4loop_Loop._check_closed = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__check_closed;
+  __pyx_vtable_6uvloop_4loop_Loop._check_thread = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__check_thread;
+  __pyx_vtable_6uvloop_4loop_Loop._getaddrinfo = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, int, int, int, int, int))__pyx_f_6uvloop_4loop_4Loop__getaddrinfo;
+  __pyx_vtable_6uvloop_4loop_Loop._getnameinfo = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, struct sockaddr *, int))__pyx_f_6uvloop_4loop_4Loop__getnameinfo;
+  __pyx_vtable_6uvloop_4loop_Loop._track_transport = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_4Loop__track_transport;
+  __pyx_vtable_6uvloop_4loop_Loop._fileobj_to_fd = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__fileobj_to_fd;
+  __pyx_vtable_6uvloop_4loop_Loop._ensure_fd_no_transport = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__ensure_fd_no_transport;
+  __pyx_vtable_6uvloop_4loop_Loop._track_process = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVProcess *))__pyx_f_6uvloop_4loop_4Loop__track_process;
+  __pyx_vtable_6uvloop_4loop_Loop._untrack_process = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVProcess *))__pyx_f_6uvloop_4loop_4Loop__untrack_process;
+  __pyx_vtable_6uvloop_4loop_Loop._add_reader = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_4Loop__add_reader;
+  __pyx_vtable_6uvloop_4loop_Loop._has_reader = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__has_reader;
+  __pyx_vtable_6uvloop_4loop_Loop._remove_reader = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__remove_reader;
+  __pyx_vtable_6uvloop_4loop_Loop._add_writer = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_4Loop__add_writer;
+  __pyx_vtable_6uvloop_4loop_Loop._has_writer = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__has_writer;
+  __pyx_vtable_6uvloop_4loop_Loop._remove_writer = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__remove_writer;
+  __pyx_vtable_6uvloop_4loop_Loop._sock_recv = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__sock_recv;
+  __pyx_vtable_6uvloop_4loop_Loop._sock_recv_into = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__sock_recv_into;
+  __pyx_vtable_6uvloop_4loop_Loop._sock_sendall = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__sock_sendall;
+  __pyx_vtable_6uvloop_4loop_Loop._sock_accept = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__sock_accept;
+  __pyx_vtable_6uvloop_4loop_Loop._sock_connect = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__sock_connect;
+  __pyx_vtable_6uvloop_4loop_Loop._sock_connect_cb = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__sock_connect_cb;
+  __pyx_vtable_6uvloop_4loop_Loop._sock_set_reuseport = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, int))__pyx_f_6uvloop_4loop_4Loop__sock_set_reuseport;
+  __pyx_vtable_6uvloop_4loop_Loop._setup_or_resume_signals = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__setup_or_resume_signals;
+  __pyx_vtable_6uvloop_4loop_Loop._shutdown_signals = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__shutdown_signals;
+  __pyx_vtable_6uvloop_4loop_Loop._pause_signals = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__pause_signals;
+  __pyx_vtable_6uvloop_4loop_Loop._handle_signal = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__handle_signal;
+  __pyx_vtable_6uvloop_4loop_Loop._read_from_self = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__read_from_self;
+  __pyx_vtable_6uvloop_4loop_Loop._ceval_process_signals = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__ceval_process_signals;
+  __pyx_vtable_6uvloop_4loop_Loop._invoke_signals = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *))__pyx_f_6uvloop_4loop_4Loop__invoke_signals;
+  __pyx_vtable_6uvloop_4loop_Loop._set_coroutine_debug = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, int))__pyx_f_6uvloop_4loop_4Loop__set_coroutine_debug;
+  __pyx_vtable_6uvloop_4loop_Loop._print_debug_info = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_4Loop__print_debug_info;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_Loop) < 0) __PYX_ERR(0, 126, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_Loop.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_Loop.tp_dictoffset && __pyx_type_6uvloop_4loop_Loop.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_Loop.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_Loop.tp_dict, __pyx_vtabptr_6uvloop_4loop_Loop) < 0) __PYX_ERR(0, 126, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Loop, (PyObject *)&__pyx_type_6uvloop_4loop_Loop) < 0) __PYX_ERR(0, 126, __pyx_L1_error)
+  if (__pyx_type_6uvloop_4loop_Loop.tp_weaklistoffset == 0) __pyx_type_6uvloop_4loop_Loop.tp_weaklistoffset = offsetof(struct __pyx_obj_6uvloop_4loop_Loop, __weakref__);
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_Loop) < 0) __PYX_ERR(0, 126, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_Loop = &__pyx_type_6uvloop_4loop_Loop;
+  __pyx_vtabptr_6uvloop_4loop_Handle = &__pyx_vtable_6uvloop_4loop_Handle;
+  __pyx_vtable_6uvloop_4loop_Handle._set_loop = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Handle *, struct __pyx_obj_6uvloop_4loop_Loop *))__pyx_f_6uvloop_4loop_6Handle__set_loop;
+  __pyx_vtable_6uvloop_4loop_Handle._set_context = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Handle *, PyObject *))__pyx_f_6uvloop_4loop_6Handle__set_context;
+  __pyx_vtable_6uvloop_4loop_Handle._run = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_6Handle__run;
+  __pyx_vtable_6uvloop_4loop_Handle._cancel = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_6Handle__cancel;
+  __pyx_vtable_6uvloop_4loop_Handle._format_handle = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_6Handle__format_handle;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_Handle) < 0) __PYX_ERR(8, 3, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_Handle.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_Handle.tp_dictoffset && __pyx_type_6uvloop_4loop_Handle.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_Handle.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_Handle.tp_dict, __pyx_vtabptr_6uvloop_4loop_Handle) < 0) __PYX_ERR(8, 3, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Handle, (PyObject *)&__pyx_type_6uvloop_4loop_Handle) < 0) __PYX_ERR(8, 3, __pyx_L1_error)
+  if (__pyx_type_6uvloop_4loop_Handle.tp_weaklistoffset == 0) __pyx_type_6uvloop_4loop_Handle.tp_weaklistoffset = offsetof(struct __pyx_obj_6uvloop_4loop_Handle, __weakref__);
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_Handle) < 0) __PYX_ERR(8, 3, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_Handle = &__pyx_type_6uvloop_4loop_Handle;
+  __pyx_vtabptr_6uvloop_4loop_TimerHandle = &__pyx_vtable_6uvloop_4loop_TimerHandle;
+  __pyx_vtable_6uvloop_4loop_TimerHandle._run = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_TimerHandle *))__pyx_f_6uvloop_4loop_11TimerHandle__run;
+  __pyx_vtable_6uvloop_4loop_TimerHandle._cancel = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_TimerHandle *))__pyx_f_6uvloop_4loop_11TimerHandle__cancel;
+  __pyx_vtable_6uvloop_4loop_TimerHandle._clear = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_TimerHandle *))__pyx_f_6uvloop_4loop_11TimerHandle__clear;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_TimerHandle) < 0) __PYX_ERR(8, 167, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_TimerHandle.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_TimerHandle.tp_dictoffset && __pyx_type_6uvloop_4loop_TimerHandle.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_TimerHandle.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_TimerHandle.tp_dict, __pyx_vtabptr_6uvloop_4loop_TimerHandle) < 0) __PYX_ERR(8, 167, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_TimerHandle, (PyObject *)&__pyx_type_6uvloop_4loop_TimerHandle) < 0) __PYX_ERR(8, 167, __pyx_L1_error)
+  if (__pyx_type_6uvloop_4loop_TimerHandle.tp_weaklistoffset == 0) __pyx_type_6uvloop_4loop_TimerHandle.tp_weaklistoffset = offsetof(struct __pyx_obj_6uvloop_4loop_TimerHandle, __weakref__);
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_TimerHandle) < 0) __PYX_ERR(8, 167, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_TimerHandle = &__pyx_type_6uvloop_4loop_TimerHandle;
+  __pyx_vtabptr_6uvloop_4loop_UVCheck = &__pyx_vtable_6uvloop_4loop_UVCheck;
+  __pyx_vtable_6uvloop_4loop_UVCheck.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVHandle;
+  __pyx_vtable_6uvloop_4loop_UVCheck._init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVCheck *, struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_7UVCheck__init;
+  __pyx_vtable_6uvloop_4loop_UVCheck.stop = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVCheck *))__pyx_f_6uvloop_4loop_7UVCheck_stop;
+  __pyx_vtable_6uvloop_4loop_UVCheck.start = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVCheck *))__pyx_f_6uvloop_4loop_7UVCheck_start;
+  __pyx_vtable_6uvloop_4loop_UVCheck.new = (struct __pyx_obj_6uvloop_4loop_UVCheck *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_7UVCheck_new;
+  __pyx_type_6uvloop_4loop_UVCheck.tp_base = __pyx_ptype_6uvloop_4loop_UVHandle;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVCheck) < 0) __PYX_ERR(13, 2, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVCheck.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVCheck.tp_dictoffset && __pyx_type_6uvloop_4loop_UVCheck.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVCheck.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVCheck.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVCheck) < 0) __PYX_ERR(13, 2, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVCheck, (PyObject *)&__pyx_type_6uvloop_4loop_UVCheck) < 0) __PYX_ERR(13, 2, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVCheck) < 0) __PYX_ERR(13, 2, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVCheck = &__pyx_type_6uvloop_4loop_UVCheck;
+  __pyx_vtabptr_6uvloop_4loop_UVPoll = &__pyx_vtable_6uvloop_4loop_UVPoll;
+  __pyx_vtable_6uvloop_4loop_UVPoll.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVHandle;
+  __pyx_vtable_6uvloop_4loop_UVPoll.__pyx_base._fatal_error = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *, PyObject *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error *__pyx_optional_args))__pyx_f_6uvloop_4loop_6UVPoll__fatal_error;
+  __pyx_vtable_6uvloop_4loop_UVPoll.__pyx_base._close = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *))__pyx_f_6uvloop_4loop_6UVPoll__close;
+  __pyx_vtable_6uvloop_4loop_UVPoll._init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVPoll *, struct __pyx_obj_6uvloop_4loop_Loop *, int))__pyx_f_6uvloop_4loop_6UVPoll__init;
+  __pyx_vtable_6uvloop_4loop_UVPoll._poll_start = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVPoll *, int))__pyx_f_6uvloop_4loop_6UVPoll__poll_start;
+  __pyx_vtable_6uvloop_4loop_UVPoll._poll_stop = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVPoll *))__pyx_f_6uvloop_4loop_6UVPoll__poll_stop;
+  __pyx_vtable_6uvloop_4loop_UVPoll.is_active = (int (*)(struct __pyx_obj_6uvloop_4loop_UVPoll *))__pyx_f_6uvloop_4loop_6UVPoll_is_active;
+  __pyx_vtable_6uvloop_4loop_UVPoll.is_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVPoll *))__pyx_f_6uvloop_4loop_6UVPoll_is_reading;
+  __pyx_vtable_6uvloop_4loop_UVPoll.is_writing = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVPoll *))__pyx_f_6uvloop_4loop_6UVPoll_is_writing;
+  __pyx_vtable_6uvloop_4loop_UVPoll.start_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVPoll *, struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_6UVPoll_start_reading;
+  __pyx_vtable_6uvloop_4loop_UVPoll.start_writing = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVPoll *, struct __pyx_obj_6uvloop_4loop_Handle *))__pyx_f_6uvloop_4loop_6UVPoll_start_writing;
+  __pyx_vtable_6uvloop_4loop_UVPoll.stop_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVPoll *))__pyx_f_6uvloop_4loop_6UVPoll_stop_reading;
+  __pyx_vtable_6uvloop_4loop_UVPoll.stop_writing = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVPoll *))__pyx_f_6uvloop_4loop_6UVPoll_stop_writing;
+  __pyx_vtable_6uvloop_4loop_UVPoll.stop = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVPoll *))__pyx_f_6uvloop_4loop_6UVPoll_stop;
+  __pyx_vtable_6uvloop_4loop_UVPoll.new = (struct __pyx_obj_6uvloop_4loop_UVPoll *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, int))__pyx_f_6uvloop_4loop_6UVPoll_new;
+  __pyx_type_6uvloop_4loop_UVPoll.tp_base = __pyx_ptype_6uvloop_4loop_UVHandle;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVPoll) < 0) __PYX_ERR(15, 2, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVPoll.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVPoll.tp_dictoffset && __pyx_type_6uvloop_4loop_UVPoll.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVPoll.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVPoll.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVPoll) < 0) __PYX_ERR(15, 2, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVPoll, (PyObject *)&__pyx_type_6uvloop_4loop_UVPoll) < 0) __PYX_ERR(15, 2, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVPoll) < 0) __PYX_ERR(15, 2, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVPoll = &__pyx_type_6uvloop_4loop_UVPoll;
+  __pyx_vtabptr_6uvloop_4loop_UVStream = &__pyx_vtable_6uvloop_4loop_UVStream;
+  __pyx_vtable_6uvloop_4loop_UVStream.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVBaseTransport;
+  __pyx_vtable_6uvloop_4loop_UVStream.__pyx_base.__pyx_base.__pyx_base._close = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *))__pyx_f_6uvloop_4loop_8UVStream__close;
+  __pyx_vtable_6uvloop_4loop_UVStream.__pyx_base._set_protocol = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *))__pyx_f_6uvloop_4loop_8UVStream__set_protocol;
+  __pyx_vtable_6uvloop_4loop_UVStream.__pyx_base._clear_protocol = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_8UVStream__clear_protocol;
+  __pyx_vtable_6uvloop_4loop_UVStream.__pyx_base._get_write_buffer_size = (size_t (*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_8UVStream__get_write_buffer_size;
+  __pyx_vtable_6uvloop_4loop_UVStream.__pyx_base._is_reading = (int (*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_8UVStream__is_reading;
+  __pyx_vtable_6uvloop_4loop_UVStream.__pyx_base._start_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_8UVStream__start_reading;
+  __pyx_vtable_6uvloop_4loop_UVStream.__pyx_base._stop_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_8UVStream__stop_reading;
+  __pyx_vtable_6uvloop_4loop_UVStream._init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_8UVStream__init;
+  __pyx_vtable_6uvloop_4loop_UVStream._exec_write = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *))__pyx_f_6uvloop_4loop_8UVStream__exec_write;
+  __pyx_vtable_6uvloop_4loop_UVStream._shutdown = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *))__pyx_f_6uvloop_4loop_8UVStream__shutdown;
+  __pyx_vtable_6uvloop_4loop_UVStream._accept = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_UVStream *))__pyx_f_6uvloop_4loop_8UVStream__accept;
+  __pyx_vtable_6uvloop_4loop_UVStream._close_on_read_error = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *))__pyx_f_6uvloop_4loop_8UVStream__close_on_read_error;
+  __pyx_vtable_6uvloop_4loop_UVStream.__pyx___reading_started = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *))__pyx_f_6uvloop_4loop_8UVStream___reading_started;
+  __pyx_vtable_6uvloop_4loop_UVStream.__pyx___reading_stopped = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *))__pyx_f_6uvloop_4loop_8UVStream___reading_stopped;
+  __pyx_vtable_6uvloop_4loop_UVStream._write = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *))__pyx_f_6uvloop_4loop_8UVStream__write;
+  __pyx_vtable_6uvloop_4loop_UVStream._try_write = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *))__pyx_f_6uvloop_4loop_8UVStream__try_write;
+  __pyx_vtable_6uvloop_4loop_UVStream._on_accept = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *))__pyx_f_6uvloop_4loop_8UVStream__on_accept;
+  __pyx_vtable_6uvloop_4loop_UVStream._on_eof = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *))__pyx_f_6uvloop_4loop_8UVStream__on_eof;
+  __pyx_vtable_6uvloop_4loop_UVStream._on_write = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *))__pyx_f_6uvloop_4loop_8UVStream__on_write;
+  __pyx_vtable_6uvloop_4loop_UVStream._on_connect = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *))__pyx_f_6uvloop_4loop_8UVStream__on_connect;
+  __pyx_type_6uvloop_4loop_UVStream.tp_base = __pyx_ptype_6uvloop_4loop_UVBaseTransport;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVStream) < 0) __PYX_ERR(18, 209, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVStream.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVStream.tp_dictoffset && __pyx_type_6uvloop_4loop_UVStream.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVStream.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVStream.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVStream) < 0) __PYX_ERR(18, 209, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVStream, (PyObject *)&__pyx_type_6uvloop_4loop_UVStream) < 0) __PYX_ERR(18, 209, __pyx_L1_error)
+  if (__pyx_type_6uvloop_4loop_UVStream.tp_weaklistoffset == 0) __pyx_type_6uvloop_4loop_UVStream.tp_weaklistoffset = offsetof(struct __pyx_obj_6uvloop_4loop_UVStream, __pyx_base.__weakref__);
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVStream) < 0) __PYX_ERR(18, 209, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVStream = &__pyx_type_6uvloop_4loop_UVStream;
+  __pyx_vtabptr_6uvloop_4loop_UVStreamServer = &__pyx_vtable_6uvloop_4loop_UVStreamServer;
+  __pyx_vtable_6uvloop_4loop_UVStreamServer.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVSocketHandle;
+  __pyx_vtable_6uvloop_4loop_UVStreamServer.__pyx_base.__pyx_base._fatal_error = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *, PyObject *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error *__pyx_optional_args))__pyx_f_6uvloop_4loop_14UVStreamServer__fatal_error;
+  __pyx_vtable_6uvloop_4loop_UVStreamServer._init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_14UVStreamServer__init;
+  __pyx_vtable_6uvloop_4loop_UVStreamServer._mark_as_open = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *))__pyx_f_6uvloop_4loop_14UVStreamServer__mark_as_open;
+  __pyx_vtable_6uvloop_4loop_UVStreamServer.listen = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *))__pyx_f_6uvloop_4loop_14UVStreamServer_listen;
+  __pyx_vtable_6uvloop_4loop_UVStreamServer._on_listen = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *))__pyx_f_6uvloop_4loop_14UVStreamServer__on_listen;
+  __pyx_vtable_6uvloop_4loop_UVStreamServer._make_new_transport = (struct __pyx_obj_6uvloop_4loop_UVStream *(*)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_14UVStreamServer__make_new_transport;
+  __pyx_type_6uvloop_4loop_UVStreamServer.tp_base = __pyx_ptype_6uvloop_4loop_UVSocketHandle;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVStreamServer) < 0) __PYX_ERR(19, 2, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVStreamServer.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVStreamServer.tp_dictoffset && __pyx_type_6uvloop_4loop_UVStreamServer.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVStreamServer.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVStreamServer.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVStreamServer) < 0) __PYX_ERR(19, 2, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVStreamServer, (PyObject *)&__pyx_type_6uvloop_4loop_UVStreamServer) < 0) __PYX_ERR(19, 2, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVStreamServer) < 0) __PYX_ERR(19, 2, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVStreamServer = &__pyx_type_6uvloop_4loop_UVStreamServer;
+  __pyx_vtabptr_6uvloop_4loop_TCPServer = &__pyx_vtable_6uvloop_4loop_TCPServer;
+  __pyx_vtable_6uvloop_4loop_TCPServer.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVStreamServer;
+  __pyx_vtable_6uvloop_4loop_TCPServer.__pyx_base.__pyx_base._new_socket = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *))__pyx_f_6uvloop_4loop_9TCPServer__new_socket;
+  __pyx_vtable_6uvloop_4loop_TCPServer.__pyx_base.__pyx_base._open = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, int))__pyx_f_6uvloop_4loop_9TCPServer__open;
+  __pyx_vtable_6uvloop_4loop_TCPServer.__pyx_base._make_new_transport = (struct __pyx_obj_6uvloop_4loop_UVStream *(*)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_9TCPServer__make_new_transport;
+  __pyx_vtable_6uvloop_4loop_TCPServer.bind = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_TCPServer *, struct sockaddr *, struct __pyx_opt_args_6uvloop_4loop_9TCPServer_bind *__pyx_optional_args))__pyx_f_6uvloop_4loop_9TCPServer_bind;
+  __pyx_vtable_6uvloop_4loop_TCPServer.new = (struct __pyx_obj_6uvloop_4loop_TCPServer *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, unsigned int, PyObject *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_9TCPServer_new;
+  __pyx_type_6uvloop_4loop_TCPServer.tp_base = __pyx_ptype_6uvloop_4loop_UVStreamServer;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_TCPServer) < 0) __PYX_ERR(3, 56, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_TCPServer.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_TCPServer.tp_dictoffset && __pyx_type_6uvloop_4loop_TCPServer.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_TCPServer.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_TCPServer.tp_dict, __pyx_vtabptr_6uvloop_4loop_TCPServer) < 0) __PYX_ERR(3, 56, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_TCPServer, (PyObject *)&__pyx_type_6uvloop_4loop_TCPServer) < 0) __PYX_ERR(3, 56, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_TCPServer) < 0) __PYX_ERR(3, 56, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_TCPServer = &__pyx_type_6uvloop_4loop_TCPServer;
+  __pyx_vtabptr_6uvloop_4loop_TCPTransport = &__pyx_vtable_6uvloop_4loop_TCPTransport;
+  __pyx_vtable_6uvloop_4loop_TCPTransport.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVStream;
+  __pyx_vtable_6uvloop_4loop_TCPTransport.__pyx_base.__pyx_base.__pyx_base._new_socket = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *))__pyx_f_6uvloop_4loop_12TCPTransport__new_socket;
+  __pyx_vtable_6uvloop_4loop_TCPTransport.__pyx_base.__pyx_base.__pyx_base._open = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, int))__pyx_f_6uvloop_4loop_12TCPTransport__open;
+  __pyx_vtable_6uvloop_4loop_TCPTransport.__pyx_base.__pyx_base._call_connection_made = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_12TCPTransport__call_connection_made;
+  __pyx_vtable_6uvloop_4loop_TCPTransport.bind = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_TCPTransport *, struct sockaddr *, struct __pyx_opt_args_6uvloop_4loop_12TCPTransport_bind *__pyx_optional_args))__pyx_f_6uvloop_4loop_12TCPTransport_bind;
+  __pyx_vtable_6uvloop_4loop_TCPTransport.connect = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_TCPTransport *, struct sockaddr *))__pyx_f_6uvloop_4loop_12TCPTransport_connect;
+  __pyx_vtable_6uvloop_4loop_TCPTransport._set_nodelay = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_TCPTransport *))__pyx_f_6uvloop_4loop_12TCPTransport__set_nodelay;
+  __pyx_vtable_6uvloop_4loop_TCPTransport.new = (struct __pyx_obj_6uvloop_4loop_TCPTransport *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_12TCPTransport_new;
+  __pyx_type_6uvloop_4loop_TCPTransport.tp_base = __pyx_ptype_6uvloop_4loop_UVStream;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_TCPTransport) < 0) __PYX_ERR(3, 103, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_TCPTransport.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_TCPTransport.tp_dictoffset && __pyx_type_6uvloop_4loop_TCPTransport.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_TCPTransport.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_TCPTransport.tp_dict, __pyx_vtabptr_6uvloop_4loop_TCPTransport) < 0) __PYX_ERR(3, 103, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_TCPTransport, (PyObject *)&__pyx_type_6uvloop_4loop_TCPTransport) < 0) __PYX_ERR(3, 103, __pyx_L1_error)
+  if (__pyx_type_6uvloop_4loop_TCPTransport.tp_weaklistoffset == 0) __pyx_type_6uvloop_4loop_TCPTransport.tp_weaklistoffset = offsetof(struct __pyx_obj_6uvloop_4loop_TCPTransport, __pyx_base.__pyx_base.__weakref__);
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_TCPTransport) < 0) __PYX_ERR(3, 103, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_TCPTransport = &__pyx_type_6uvloop_4loop_TCPTransport;
+  __pyx_vtabptr_6uvloop_4loop_UnixServer = &__pyx_vtable_6uvloop_4loop_UnixServer;
+  __pyx_vtable_6uvloop_4loop_UnixServer.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVStreamServer;
+  __pyx_vtable_6uvloop_4loop_UnixServer.__pyx_base.__pyx_base._new_socket = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *))__pyx_f_6uvloop_4loop_10UnixServer__new_socket;
+  __pyx_vtable_6uvloop_4loop_UnixServer.__pyx_base.__pyx_base._open = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, int))__pyx_f_6uvloop_4loop_10UnixServer__open;
+  __pyx_vtable_6uvloop_4loop_UnixServer.__pyx_base._make_new_transport = (struct __pyx_obj_6uvloop_4loop_UVStream *(*)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_10UnixServer__make_new_transport;
+  __pyx_vtable_6uvloop_4loop_UnixServer.bind = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UnixServer *, PyObject *))__pyx_f_6uvloop_4loop_10UnixServer_bind;
+  __pyx_vtable_6uvloop_4loop_UnixServer.new = (struct __pyx_obj_6uvloop_4loop_UnixServer *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_10UnixServer_new;
+  __pyx_type_6uvloop_4loop_UnixServer.tp_base = __pyx_ptype_6uvloop_4loop_UVStreamServer;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UnixServer) < 0) __PYX_ERR(20, 40, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UnixServer.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UnixServer.tp_dictoffset && __pyx_type_6uvloop_4loop_UnixServer.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UnixServer.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UnixServer.tp_dict, __pyx_vtabptr_6uvloop_4loop_UnixServer) < 0) __PYX_ERR(20, 40, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UnixServer, (PyObject *)&__pyx_type_6uvloop_4loop_UnixServer) < 0) __PYX_ERR(20, 40, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UnixServer) < 0) __PYX_ERR(20, 40, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UnixServer = &__pyx_type_6uvloop_4loop_UnixServer;
+  __pyx_vtabptr_6uvloop_4loop_UnixTransport = &__pyx_vtable_6uvloop_4loop_UnixTransport;
+  __pyx_vtable_6uvloop_4loop_UnixTransport.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVStream;
+  __pyx_vtable_6uvloop_4loop_UnixTransport.__pyx_base.__pyx_base.__pyx_base._new_socket = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *))__pyx_f_6uvloop_4loop_13UnixTransport__new_socket;
+  __pyx_vtable_6uvloop_4loop_UnixTransport.__pyx_base.__pyx_base.__pyx_base._open = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, int))__pyx_f_6uvloop_4loop_13UnixTransport__open;
+  __pyx_vtable_6uvloop_4loop_UnixTransport.new = (struct __pyx_obj_6uvloop_4loop_UnixTransport *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_13UnixTransport_new;
+  __pyx_vtable_6uvloop_4loop_UnixTransport.connect = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UnixTransport *, char *))__pyx_f_6uvloop_4loop_13UnixTransport_connect;
+  __pyx_type_6uvloop_4loop_UnixTransport.tp_base = __pyx_ptype_6uvloop_4loop_UVStream;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UnixTransport) < 0) __PYX_ERR(20, 85, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UnixTransport.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UnixTransport.tp_dictoffset && __pyx_type_6uvloop_4loop_UnixTransport.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UnixTransport.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UnixTransport.tp_dict, __pyx_vtabptr_6uvloop_4loop_UnixTransport) < 0) __PYX_ERR(20, 85, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UnixTransport, (PyObject *)&__pyx_type_6uvloop_4loop_UnixTransport) < 0) __PYX_ERR(20, 85, __pyx_L1_error)
+  if (__pyx_type_6uvloop_4loop_UnixTransport.tp_weaklistoffset == 0) __pyx_type_6uvloop_4loop_UnixTransport.tp_weaklistoffset = offsetof(struct __pyx_obj_6uvloop_4loop_UnixTransport, __pyx_base.__pyx_base.__weakref__);
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UnixTransport) < 0) __PYX_ERR(20, 85, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UnixTransport = &__pyx_type_6uvloop_4loop_UnixTransport;
+  __pyx_vtabptr_6uvloop_4loop_ReadUnixTransport = &__pyx_vtable_6uvloop_4loop_ReadUnixTransport;
+  __pyx_vtable_6uvloop_4loop_ReadUnixTransport.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVStream;
+  __pyx_vtable_6uvloop_4loop_ReadUnixTransport.__pyx_base.__pyx_base.__pyx_base._new_socket = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *))__pyx_f_6uvloop_4loop_17ReadUnixTransport__new_socket;
+  __pyx_vtable_6uvloop_4loop_ReadUnixTransport.__pyx_base.__pyx_base.__pyx_base._open = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, int))__pyx_f_6uvloop_4loop_17ReadUnixTransport__open;
+  __pyx_vtable_6uvloop_4loop_ReadUnixTransport.new = (struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *))__pyx_f_6uvloop_4loop_17ReadUnixTransport_new;
+  __pyx_type_6uvloop_4loop_ReadUnixTransport.tp_base = __pyx_ptype_6uvloop_4loop_UVStream;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_ReadUnixTransport) < 0) __PYX_ERR(20, 110, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_ReadUnixTransport.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_ReadUnixTransport.tp_dictoffset && __pyx_type_6uvloop_4loop_ReadUnixTransport.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_ReadUnixTransport.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_ReadUnixTransport.tp_dict, __pyx_vtabptr_6uvloop_4loop_ReadUnixTransport) < 0) __PYX_ERR(20, 110, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ReadUnixTransport, (PyObject *)&__pyx_type_6uvloop_4loop_ReadUnixTransport) < 0) __PYX_ERR(20, 110, __pyx_L1_error)
+  if (__pyx_type_6uvloop_4loop_ReadUnixTransport.tp_weaklistoffset == 0) __pyx_type_6uvloop_4loop_ReadUnixTransport.tp_weaklistoffset = offsetof(struct __pyx_obj_6uvloop_4loop_ReadUnixTransport, __pyx_base.__pyx_base.__weakref__);
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_ReadUnixTransport) < 0) __PYX_ERR(20, 110, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_ReadUnixTransport = &__pyx_type_6uvloop_4loop_ReadUnixTransport;
+  __pyx_vtabptr_6uvloop_4loop_WriteUnixTransport = &__pyx_vtable_6uvloop_4loop_WriteUnixTransport;
+  __pyx_vtable_6uvloop_4loop_WriteUnixTransport.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVStream;
+  __pyx_vtable_6uvloop_4loop_WriteUnixTransport.__pyx_base.__pyx_base.__pyx_base._new_socket = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *))__pyx_f_6uvloop_4loop_18WriteUnixTransport__new_socket;
+  __pyx_vtable_6uvloop_4loop_WriteUnixTransport.__pyx_base.__pyx_base.__pyx_base._open = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, int))__pyx_f_6uvloop_4loop_18WriteUnixTransport__open;
+  __pyx_vtable_6uvloop_4loop_WriteUnixTransport.new = (struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *))__pyx_f_6uvloop_4loop_18WriteUnixTransport_new;
+  __pyx_type_6uvloop_4loop_WriteUnixTransport.tp_base = __pyx_ptype_6uvloop_4loop_UVStream;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_WriteUnixTransport) < 0) __PYX_ERR(20, 155, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_WriteUnixTransport.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_WriteUnixTransport.tp_dictoffset && __pyx_type_6uvloop_4loop_WriteUnixTransport.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_WriteUnixTransport.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_WriteUnixTransport.tp_dict, __pyx_vtabptr_6uvloop_4loop_WriteUnixTransport) < 0) __PYX_ERR(20, 155, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_WriteUnixTransport, (PyObject *)&__pyx_type_6uvloop_4loop_WriteUnixTransport) < 0) __PYX_ERR(20, 155, __pyx_L1_error)
+  if (__pyx_type_6uvloop_4loop_WriteUnixTransport.tp_weaklistoffset == 0) __pyx_type_6uvloop_4loop_WriteUnixTransport.tp_weaklistoffset = offsetof(struct __pyx_obj_6uvloop_4loop_WriteUnixTransport, __pyx_base.__pyx_base.__weakref__);
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_WriteUnixTransport) < 0) __PYX_ERR(20, 155, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_WriteUnixTransport = &__pyx_type_6uvloop_4loop_WriteUnixTransport;
+  __pyx_vtabptr_6uvloop_4loop_UVProcess = &__pyx_vtable_6uvloop_4loop_UVProcess;
+  __pyx_vtable_6uvloop_4loop_UVProcess.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVHandle;
+  __pyx_vtable_6uvloop_4loop_UVProcess.__pyx_base._close = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVHandle *))__pyx_f_6uvloop_4loop_9UVProcess__close;
+  __pyx_vtable_6uvloop_4loop_UVProcess._close_process_handle = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *))__pyx_f_6uvloop_4loop_9UVProcess__close_process_handle;
+  __pyx_vtable_6uvloop_4loop_UVProcess._init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_9UVProcess__init;
+  __pyx_vtable_6uvloop_4loop_UVProcess._after_fork = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *))__pyx_f_6uvloop_4loop_9UVProcess__after_fork;
+  __pyx_vtable_6uvloop_4loop_UVProcess.__pyx___to_cstring_array = (char **(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *))__pyx_f_6uvloop_4loop_9UVProcess___to_cstring_array;
+  __pyx_vtable_6uvloop_4loop_UVProcess._init_args = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *))__pyx_f_6uvloop_4loop_9UVProcess__init_args;
+  __pyx_vtable_6uvloop_4loop_UVProcess._init_env = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *))__pyx_f_6uvloop_4loop_9UVProcess__init_env;
+  __pyx_vtable_6uvloop_4loop_UVProcess._init_files = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_9UVProcess__init_files;
+  __pyx_vtable_6uvloop_4loop_UVProcess._init_options = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_9UVProcess__init_options;
+  __pyx_vtable_6uvloop_4loop_UVProcess._close_after_spawn = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *, int))__pyx_f_6uvloop_4loop_9UVProcess__close_after_spawn;
+  __pyx_vtable_6uvloop_4loop_UVProcess._on_exit = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *, int64_t, int))__pyx_f_6uvloop_4loop_9UVProcess__on_exit;
+  __pyx_vtable_6uvloop_4loop_UVProcess._kill = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *, int))__pyx_f_6uvloop_4loop_9UVProcess__kill;
+  __pyx_type_6uvloop_4loop_UVProcess.tp_base = __pyx_ptype_6uvloop_4loop_UVHandle;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVProcess) < 0) __PYX_ERR(4, 2, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVProcess.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVProcess.tp_dictoffset && __pyx_type_6uvloop_4loop_UVProcess.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVProcess.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVProcess.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVProcess) < 0) __PYX_ERR(4, 2, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVProcess, (PyObject *)&__pyx_type_6uvloop_4loop_UVProcess) < 0) __PYX_ERR(4, 2, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVProcess) < 0) __PYX_ERR(4, 2, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVProcess = &__pyx_type_6uvloop_4loop_UVProcess;
+  __pyx_vtabptr_6uvloop_4loop_UVProcessTransport = &__pyx_vtable_6uvloop_4loop_UVProcessTransport;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVProcess;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport.__pyx_base._init_files = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_18UVProcessTransport__init_files;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport.__pyx_base._on_exit = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcess *, int64_t, int))__pyx_f_6uvloop_4loop_18UVProcessTransport__on_exit;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport._file_redirect_stdio = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, int))__pyx_f_6uvloop_4loop_18UVProcessTransport__file_redirect_stdio;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport._file_devnull = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *))__pyx_f_6uvloop_4loop_18UVProcessTransport__file_devnull;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport._file_inpipe = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *))__pyx_f_6uvloop_4loop_18UVProcessTransport__file_inpipe;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport._file_outpipe = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *))__pyx_f_6uvloop_4loop_18UVProcessTransport__file_outpipe;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport._check_proc = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *))__pyx_f_6uvloop_4loop_18UVProcessTransport__check_proc;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport._pipe_connection_lost = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, int, PyObject *))__pyx_f_6uvloop_4loop_18UVProcessTransport__pipe_connection_lost;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport._pipe_data_received = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, int, PyObject *))__pyx_f_6uvloop_4loop_18UVProcessTransport__pipe_data_received;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport._call_connection_made = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, PyObject *))__pyx_f_6uvloop_4loop_18UVProcessTransport__call_connection_made;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport._try_finish = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *))__pyx_f_6uvloop_4loop_18UVProcessTransport__try_finish;
+  __pyx_vtable_6uvloop_4loop_UVProcessTransport.new = (struct __pyx_obj_6uvloop_4loop_UVProcessTransport *(*)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_18UVProcessTransport_new;
+  __pyx_type_6uvloop_4loop_UVProcessTransport.tp_base = __pyx_ptype_6uvloop_4loop_UVProcess;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVProcessTransport) < 0) __PYX_ERR(4, 350, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVProcessTransport.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVProcessTransport.tp_dictoffset && __pyx_type_6uvloop_4loop_UVProcessTransport.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVProcessTransport.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVProcessTransport.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVProcessTransport) < 0) __PYX_ERR(4, 350, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVProcessTransport, (PyObject *)&__pyx_type_6uvloop_4loop_UVProcessTransport) < 0) __PYX_ERR(4, 350, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVProcessTransport) < 0) __PYX_ERR(4, 350, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVProcessTransport = &__pyx_type_6uvloop_4loop_UVProcessTransport;
+  __pyx_vtabptr_6uvloop_4loop_UVRequest = &__pyx_vtable_6uvloop_4loop_UVRequest;
+  __pyx_vtable_6uvloop_4loop_UVRequest.on_done = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVRequest *))__pyx_f_6uvloop_4loop_9UVRequest_on_done;
+  __pyx_vtable_6uvloop_4loop_UVRequest.cancel = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVRequest *))__pyx_f_6uvloop_4loop_9UVRequest_cancel;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UVRequest) < 0) __PYX_ERR(21, 1, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UVRequest.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UVRequest.tp_dictoffset && __pyx_type_6uvloop_4loop_UVRequest.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UVRequest.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UVRequest.tp_dict, __pyx_vtabptr_6uvloop_4loop_UVRequest) < 0) __PYX_ERR(21, 1, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UVRequest, (PyObject *)&__pyx_type_6uvloop_4loop_UVRequest) < 0) __PYX_ERR(21, 1, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UVRequest) < 0) __PYX_ERR(21, 1, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UVRequest = &__pyx_type_6uvloop_4loop_UVRequest;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop__SSLProtocolTransport) < 0) __PYX_ERR(22, 15, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop__SSLProtocolTransport.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop__SSLProtocolTransport.tp_dictoffset && __pyx_type_6uvloop_4loop__SSLProtocolTransport.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop__SSLProtocolTransport.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SSLProtocolTransport, (PyObject *)&__pyx_type_6uvloop_4loop__SSLProtocolTransport) < 0) __PYX_ERR(22, 15, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop__SSLProtocolTransport) < 0) __PYX_ERR(22, 15, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop__SSLProtocolTransport = &__pyx_type_6uvloop_4loop__SSLProtocolTransport;
+  __pyx_vtabptr_6uvloop_4loop_SSLProtocol = &__pyx_vtable_6uvloop_4loop_SSLProtocol;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._set_app_protocol = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *))__pyx_f_6uvloop_4loop_11SSLProtocol__set_app_protocol;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._wakeup_waiter = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__wakeup_waiter *__pyx_optional_args))__pyx_f_6uvloop_4loop_11SSLProtocol__wakeup_waiter;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._get_extra_info = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__get_extra_info *__pyx_optional_args))__pyx_f_6uvloop_4loop_11SSLProtocol__get_extra_info;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._set_state = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, enum __pyx_t_6uvloop_4loop_SSLProtocolState))__pyx_f_6uvloop_4loop_11SSLProtocol__set_state;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._start_handshake = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__start_handshake;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._check_handshake_timeout = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__check_handshake_timeout;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._do_handshake = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__do_handshake;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._on_handshake_complete = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *))__pyx_f_6uvloop_4loop_11SSLProtocol__on_handshake_complete;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._start_shutdown = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__start_shutdown *__pyx_optional_args))__pyx_f_6uvloop_4loop_11SSLProtocol__start_shutdown;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._check_shutdown_timeout = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__check_shutdown_timeout;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._do_read_into_void = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *))__pyx_f_6uvloop_4loop_11SSLProtocol__do_read_into_void;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._do_flush = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_flush *__pyx_optional_args))__pyx_f_6uvloop_4loop_11SSLProtocol__do_flush;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._do_shutdown = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__do_shutdown *__pyx_optional_args))__pyx_f_6uvloop_4loop_11SSLProtocol__do_shutdown;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._on_shutdown_complete = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *))__pyx_f_6uvloop_4loop_11SSLProtocol__on_shutdown_complete;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._abort = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *))__pyx_f_6uvloop_4loop_11SSLProtocol__abort;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._write_appdata = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_11SSLProtocol__write_appdata;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._do_write = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__do_write;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._process_outgoing = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__process_outgoing;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._do_read = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__do_read;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._do_read__buffered = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__do_read__buffered;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._do_read__copied = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__do_read__copied;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._call_eof_received = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__call_eof_received *__pyx_optional_args))__pyx_f_6uvloop_4loop_11SSLProtocol__call_eof_received;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._control_app_writing = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__control_app_writing *__pyx_optional_args))__pyx_f_6uvloop_4loop_11SSLProtocol__control_app_writing;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._get_write_buffer_size = (size_t (*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__get_write_buffer_size;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._set_write_buffer_limits = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_write_buffer_limits *__pyx_optional_args))__pyx_f_6uvloop_4loop_11SSLProtocol__set_write_buffer_limits;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._pause_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__pause_reading;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._resume_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *))__pyx_f_6uvloop_4loop_11SSLProtocol__resume_reading;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._control_ssl_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__control_ssl_reading;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._set_read_buffer_limits = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__set_read_buffer_limits *__pyx_optional_args))__pyx_f_6uvloop_4loop_11SSLProtocol__set_read_buffer_limits;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._get_read_buffer_size = (size_t (*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *))__pyx_f_6uvloop_4loop_11SSLProtocol__get_read_buffer_size;
+  __pyx_vtable_6uvloop_4loop_SSLProtocol._fatal_error = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_SSLProtocol *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_11SSLProtocol__fatal_error *__pyx_optional_args))__pyx_f_6uvloop_4loop_11SSLProtocol__fatal_error;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_SSLProtocol) < 0) __PYX_ERR(22, 195, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_SSLProtocol.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_SSLProtocol.tp_dictoffset && __pyx_type_6uvloop_4loop_SSLProtocol.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_SSLProtocol.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_SSLProtocol.tp_dict, __pyx_vtabptr_6uvloop_4loop_SSLProtocol) < 0) __PYX_ERR(22, 195, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SSLProtocol, (PyObject *)&__pyx_type_6uvloop_4loop_SSLProtocol) < 0) __PYX_ERR(22, 195, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_SSLProtocol) < 0) __PYX_ERR(22, 195, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_SSLProtocol = &__pyx_type_6uvloop_4loop_SSLProtocol;
+  __pyx_vtabptr_6uvloop_4loop_UDPTransport = &__pyx_vtable_6uvloop_4loop_UDPTransport;
+  __pyx_vtable_6uvloop_4loop_UDPTransport.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVBaseTransport;
+  __pyx_vtable_6uvloop_4loop_UDPTransport.__pyx_base.__pyx_base._new_socket = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *))__pyx_f_6uvloop_4loop_12UDPTransport__new_socket;
+  __pyx_vtable_6uvloop_4loop_UDPTransport.__pyx_base._get_write_buffer_size = (size_t (*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_12UDPTransport__get_write_buffer_size;
+  __pyx_vtable_6uvloop_4loop_UDPTransport.__pyx_base._is_reading = (int (*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_12UDPTransport__is_reading;
+  __pyx_vtable_6uvloop_4loop_UDPTransport.__pyx_base._start_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_12UDPTransport__start_reading;
+  __pyx_vtable_6uvloop_4loop_UDPTransport.__pyx_base._stop_reading = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *))__pyx_f_6uvloop_4loop_12UDPTransport__stop_reading;
+  __pyx_vtable_6uvloop_4loop_UDPTransport._init = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, struct __pyx_obj_6uvloop_4loop_Loop *, unsigned int))__pyx_f_6uvloop_4loop_12UDPTransport__init;
+  __pyx_vtable_6uvloop_4loop_UDPTransport._set_address = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, struct addrinfo *))__pyx_f_6uvloop_4loop_12UDPTransport__set_address;
+  __pyx_vtable_6uvloop_4loop_UDPTransport._connect = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, struct sockaddr *, size_t))__pyx_f_6uvloop_4loop_12UDPTransport__connect;
+  __pyx_vtable_6uvloop_4loop_UDPTransport._bind = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, struct sockaddr *))__pyx_f_6uvloop_4loop_12UDPTransport__bind;
+  __pyx_vtable_6uvloop_4loop_UDPTransport.open = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, int, int))__pyx_f_6uvloop_4loop_12UDPTransport_open;
+  __pyx_vtable_6uvloop_4loop_UDPTransport._set_broadcast = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, int))__pyx_f_6uvloop_4loop_12UDPTransport__set_broadcast;
+  __pyx_vtable_6uvloop_4loop_UDPTransport.__pyx___receiving_started = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *))__pyx_f_6uvloop_4loop_12UDPTransport___receiving_started;
+  __pyx_vtable_6uvloop_4loop_UDPTransport.__pyx___receiving_stopped = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *))__pyx_f_6uvloop_4loop_12UDPTransport___receiving_stopped;
+  __pyx_vtable_6uvloop_4loop_UDPTransport._send = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_12UDPTransport__send;
+  __pyx_vtable_6uvloop_4loop_UDPTransport._on_receive = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_12UDPTransport__on_receive;
+  __pyx_vtable_6uvloop_4loop_UDPTransport._on_sent = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_12UDPTransport__on_sent *__pyx_optional_args))__pyx_f_6uvloop_4loop_12UDPTransport__on_sent;
+  __pyx_type_6uvloop_4loop_UDPTransport.tp_base = __pyx_ptype_6uvloop_4loop_UVBaseTransport;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_UDPTransport) < 0) __PYX_ERR(23, 54, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_UDPTransport.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_UDPTransport.tp_dictoffset && __pyx_type_6uvloop_4loop_UDPTransport.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_UDPTransport.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_UDPTransport.tp_dict, __pyx_vtabptr_6uvloop_4loop_UDPTransport) < 0) __PYX_ERR(23, 54, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UDPTransport, (PyObject *)&__pyx_type_6uvloop_4loop_UDPTransport) < 0) __PYX_ERR(23, 54, __pyx_L1_error)
+  if (__pyx_type_6uvloop_4loop_UDPTransport.tp_weaklistoffset == 0) __pyx_type_6uvloop_4loop_UDPTransport.tp_weaklistoffset = offsetof(struct __pyx_obj_6uvloop_4loop_UDPTransport, __pyx_base.__weakref__);
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_UDPTransport) < 0) __PYX_ERR(23, 54, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_UDPTransport = &__pyx_type_6uvloop_4loop_UDPTransport;
+  __pyx_vtabptr_6uvloop_4loop_Server = &__pyx_vtable_6uvloop_4loop_Server;
+  __pyx_vtable_6uvloop_4loop_Server._add_server = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Server *, struct __pyx_obj_6uvloop_4loop_UVStreamServer *))__pyx_f_6uvloop_4loop_6Server__add_server;
+  __pyx_vtable_6uvloop_4loop_Server._start_serving = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Server *))__pyx_f_6uvloop_4loop_6Server__start_serving;
+  __pyx_vtable_6uvloop_4loop_Server._wakeup = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Server *))__pyx_f_6uvloop_4loop_6Server__wakeup;
+  __pyx_vtable_6uvloop_4loop_Server._attach = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Server *))__pyx_f_6uvloop_4loop_6Server__attach;
+  __pyx_vtable_6uvloop_4loop_Server._detach = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Server *))__pyx_f_6uvloop_4loop_6Server__detach;
+  __pyx_vtable_6uvloop_4loop_Server._ref = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Server *))__pyx_f_6uvloop_4loop_6Server__ref;
+  __pyx_vtable_6uvloop_4loop_Server._unref = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_Server *))__pyx_f_6uvloop_4loop_6Server__unref;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_Server) < 0) __PYX_ERR(24, 4, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_Server.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_Server.tp_dictoffset && __pyx_type_6uvloop_4loop_Server.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_Server.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_Server.tp_dict, __pyx_vtabptr_6uvloop_4loop_Server) < 0) __PYX_ERR(24, 4, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Server, (PyObject *)&__pyx_type_6uvloop_4loop_Server) < 0) __PYX_ERR(24, 4, __pyx_L1_error)
+  if (__pyx_type_6uvloop_4loop_Server.tp_weaklistoffset == 0) __pyx_type_6uvloop_4loop_Server.tp_weaklistoffset = offsetof(struct __pyx_obj_6uvloop_4loop_Server, __weakref__);
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_Server) < 0) __PYX_ERR(24, 4, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_Server = &__pyx_type_6uvloop_4loop_Server;
+  __pyx_vtabptr_6uvloop_4loop_PseudoSocket = &__pyx_vtable_6uvloop_4loop_PseudoSocket;
+  __pyx_vtable_6uvloop_4loop_PseudoSocket._na = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_PseudoSocket *, PyObject *))__pyx_f_6uvloop_4loop_12PseudoSocket__na;
+  __pyx_vtable_6uvloop_4loop_PseudoSocket._make_sock = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_PseudoSocket *))__pyx_f_6uvloop_4loop_12PseudoSocket__make_sock;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_PseudoSocket) < 0) __PYX_ERR(9, 1, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_PseudoSocket.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_PseudoSocket.tp_dictoffset && __pyx_type_6uvloop_4loop_PseudoSocket.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_PseudoSocket.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_PseudoSocket.tp_dict, __pyx_vtabptr_6uvloop_4loop_PseudoSocket) < 0) __PYX_ERR(9, 1, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PseudoSocket, (PyObject *)&__pyx_type_6uvloop_4loop_PseudoSocket) < 0) __PYX_ERR(9, 1, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_PseudoSocket) < 0) __PYX_ERR(9, 1, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_PseudoSocket = &__pyx_type_6uvloop_4loop_PseudoSocket;
+  __pyx_vtabptr_6uvloop_4loop_LruCache = &__pyx_vtable_6uvloop_4loop_LruCache;
+  __pyx_vtable_6uvloop_4loop_LruCache.get = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_LruCache *, PyObject *, PyObject *))__pyx_f_6uvloop_4loop_8LruCache_get;
+  __pyx_vtable_6uvloop_4loop_LruCache.needs_cleanup = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_LruCache *))__pyx_f_6uvloop_4loop_8LruCache_needs_cleanup;
+  __pyx_vtable_6uvloop_4loop_LruCache.cleanup_one = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_LruCache *))__pyx_f_6uvloop_4loop_8LruCache_cleanup_one;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_LruCache) < 0) __PYX_ERR(10, 5, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_LruCache.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_LruCache.tp_dictoffset && __pyx_type_6uvloop_4loop_LruCache.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_LruCache.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_LruCache.tp_dict, __pyx_vtabptr_6uvloop_4loop_LruCache) < 0) __PYX_ERR(10, 5, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_LruCache, (PyObject *)&__pyx_type_6uvloop_4loop_LruCache) < 0) __PYX_ERR(10, 5, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_LruCache) < 0) __PYX_ERR(10, 5, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_LruCache = &__pyx_type_6uvloop_4loop_LruCache;
+  __pyx_vtabptr_6uvloop_4loop__StreamWriteContext = &__pyx_vtable_6uvloop_4loop__StreamWriteContext;
+  __pyx_vtable_6uvloop_4loop__StreamWriteContext.free_bufs = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *))__pyx_f_6uvloop_4loop_19_StreamWriteContext_free_bufs;
+  __pyx_vtable_6uvloop_4loop__StreamWriteContext.close = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *))__pyx_f_6uvloop_4loop_19_StreamWriteContext_close;
+  __pyx_vtable_6uvloop_4loop__StreamWriteContext.advance_uv_buf = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *, size_t))__pyx_f_6uvloop_4loop_19_StreamWriteContext_advance_uv_buf;
+  __pyx_vtable_6uvloop_4loop__StreamWriteContext.new = (struct __pyx_obj_6uvloop_4loop__StreamWriteContext *(*)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *))__pyx_f_6uvloop_4loop_19_StreamWriteContext_new;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop__StreamWriteContext) < 0) __PYX_ERR(18, 6, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop__StreamWriteContext.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop__StreamWriteContext.tp_dictoffset && __pyx_type_6uvloop_4loop__StreamWriteContext.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop__StreamWriteContext.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop__StreamWriteContext.tp_dict, __pyx_vtabptr_6uvloop_4loop__StreamWriteContext) < 0) __PYX_ERR(18, 6, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_StreamWriteContext, (PyObject *)&__pyx_type_6uvloop_4loop__StreamWriteContext) < 0) __PYX_ERR(18, 6, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop__StreamWriteContext) < 0) __PYX_ERR(18, 6, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop__StreamWriteContext = &__pyx_type_6uvloop_4loop__StreamWriteContext;
+  __pyx_vtabptr_6uvloop_4loop__TCPConnectRequest = &__pyx_vtable_6uvloop_4loop__TCPConnectRequest;
+  __pyx_vtable_6uvloop_4loop__TCPConnectRequest.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVRequest;
+  __pyx_vtable_6uvloop_4loop__TCPConnectRequest.connect = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *, struct sockaddr *))__pyx_f_6uvloop_4loop_18_TCPConnectRequest_connect;
+  __pyx_type_6uvloop_4loop__TCPConnectRequest.tp_base = __pyx_ptype_6uvloop_4loop_UVRequest;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop__TCPConnectRequest) < 0) __PYX_ERR(3, 185, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop__TCPConnectRequest.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop__TCPConnectRequest.tp_dictoffset && __pyx_type_6uvloop_4loop__TCPConnectRequest.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop__TCPConnectRequest.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop__TCPConnectRequest.tp_dict, __pyx_vtabptr_6uvloop_4loop__TCPConnectRequest) < 0) __PYX_ERR(3, 185, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_TCPConnectRequest, (PyObject *)&__pyx_type_6uvloop_4loop__TCPConnectRequest) < 0) __PYX_ERR(3, 185, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop__TCPConnectRequest) < 0) __PYX_ERR(3, 185, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop__TCPConnectRequest = &__pyx_type_6uvloop_4loop__TCPConnectRequest;
+  __pyx_vtabptr_6uvloop_4loop__PipeConnectRequest = &__pyx_vtable_6uvloop_4loop__PipeConnectRequest;
+  __pyx_vtable_6uvloop_4loop__PipeConnectRequest.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVRequest;
+  __pyx_vtable_6uvloop_4loop__PipeConnectRequest.connect = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *, char *))__pyx_f_6uvloop_4loop_19_PipeConnectRequest_connect;
+  __pyx_type_6uvloop_4loop__PipeConnectRequest.tp_base = __pyx_ptype_6uvloop_4loop_UVRequest;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop__PipeConnectRequest) < 0) __PYX_ERR(20, 188, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop__PipeConnectRequest.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop__PipeConnectRequest.tp_dictoffset && __pyx_type_6uvloop_4loop__PipeConnectRequest.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop__PipeConnectRequest.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop__PipeConnectRequest.tp_dict, __pyx_vtabptr_6uvloop_4loop__PipeConnectRequest) < 0) __PYX_ERR(20, 188, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PipeConnectRequest, (PyObject *)&__pyx_type_6uvloop_4loop__PipeConnectRequest) < 0) __PYX_ERR(20, 188, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop__PipeConnectRequest) < 0) __PYX_ERR(20, 188, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop__PipeConnectRequest = &__pyx_type_6uvloop_4loop__PipeConnectRequest;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_SockAddrHolder) < 0) __PYX_ERR(5, 72, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_SockAddrHolder.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_SockAddrHolder.tp_dictoffset && __pyx_type_6uvloop_4loop_SockAddrHolder.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_SockAddrHolder.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SockAddrHolder, (PyObject *)&__pyx_type_6uvloop_4loop_SockAddrHolder) < 0) __PYX_ERR(5, 72, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_SockAddrHolder) < 0) __PYX_ERR(5, 72, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_SockAddrHolder = &__pyx_type_6uvloop_4loop_SockAddrHolder;
+  __pyx_vtabptr_6uvloop_4loop_AddrInfo = &__pyx_vtable_6uvloop_4loop_AddrInfo;
+  __pyx_vtable_6uvloop_4loop_AddrInfo.set_data = (void (*)(struct __pyx_obj_6uvloop_4loop_AddrInfo *, struct addrinfo *))__pyx_f_6uvloop_4loop_8AddrInfo_set_data;
+  __pyx_vtable_6uvloop_4loop_AddrInfo.unpack = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_AddrInfo *))__pyx_f_6uvloop_4loop_8AddrInfo_unpack;
+  __pyx_vtable_6uvloop_4loop_AddrInfo.isinstance = (int (*)(PyObject *))__pyx_f_6uvloop_4loop_8AddrInfo_isinstance;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_AddrInfo) < 0) __PYX_ERR(5, 252, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_AddrInfo.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_AddrInfo.tp_dictoffset && __pyx_type_6uvloop_4loop_AddrInfo.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_AddrInfo.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_AddrInfo.tp_dict, __pyx_vtabptr_6uvloop_4loop_AddrInfo) < 0) __PYX_ERR(5, 252, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_AddrInfo, (PyObject *)&__pyx_type_6uvloop_4loop_AddrInfo) < 0) __PYX_ERR(5, 252, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_AddrInfo) < 0) __PYX_ERR(5, 252, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_AddrInfo = &__pyx_type_6uvloop_4loop_AddrInfo;
+  __pyx_vtabptr_6uvloop_4loop_AddrInfoRequest = &__pyx_vtable_6uvloop_4loop_AddrInfoRequest;
+  __pyx_vtable_6uvloop_4loop_AddrInfoRequest.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVRequest;
+  __pyx_type_6uvloop_4loop_AddrInfoRequest.tp_base = __pyx_ptype_6uvloop_4loop_UVRequest;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_AddrInfoRequest) < 0) __PYX_ERR(5, 296, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_AddrInfoRequest.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_AddrInfoRequest.tp_dictoffset && __pyx_type_6uvloop_4loop_AddrInfoRequest.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_AddrInfoRequest.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_AddrInfoRequest.tp_dict, __pyx_vtabptr_6uvloop_4loop_AddrInfoRequest) < 0) __PYX_ERR(5, 296, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_AddrInfoRequest, (PyObject *)&__pyx_type_6uvloop_4loop_AddrInfoRequest) < 0) __PYX_ERR(5, 296, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_AddrInfoRequest) < 0) __PYX_ERR(5, 296, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_AddrInfoRequest = &__pyx_type_6uvloop_4loop_AddrInfoRequest;
+  __pyx_vtabptr_6uvloop_4loop_NameInfoRequest = &__pyx_vtable_6uvloop_4loop_NameInfoRequest;
+  __pyx_vtable_6uvloop_4loop_NameInfoRequest.__pyx_base = *__pyx_vtabptr_6uvloop_4loop_UVRequest;
+  __pyx_vtable_6uvloop_4loop_NameInfoRequest.query = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop_NameInfoRequest *, struct sockaddr *, int))__pyx_f_6uvloop_4loop_15NameInfoRequest_query;
+  __pyx_type_6uvloop_4loop_NameInfoRequest.tp_base = __pyx_ptype_6uvloop_4loop_UVRequest;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop_NameInfoRequest) < 0) __PYX_ERR(5, 351, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop_NameInfoRequest.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop_NameInfoRequest.tp_dictoffset && __pyx_type_6uvloop_4loop_NameInfoRequest.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop_NameInfoRequest.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop_NameInfoRequest.tp_dict, __pyx_vtabptr_6uvloop_4loop_NameInfoRequest) < 0) __PYX_ERR(5, 351, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_NameInfoRequest, (PyObject *)&__pyx_type_6uvloop_4loop_NameInfoRequest) < 0) __PYX_ERR(5, 351, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop_NameInfoRequest) < 0) __PYX_ERR(5, 351, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop_NameInfoRequest = &__pyx_type_6uvloop_4loop_NameInfoRequest;
+  __pyx_vtabptr_6uvloop_4loop__UDPSendContext = &__pyx_vtable_6uvloop_4loop__UDPSendContext;
+  __pyx_vtable_6uvloop_4loop__UDPSendContext.close = (PyObject *(*)(struct __pyx_obj_6uvloop_4loop__UDPSendContext *))__pyx_f_6uvloop_4loop_15_UDPSendContext_close;
+  __pyx_vtable_6uvloop_4loop__UDPSendContext.new = (struct __pyx_obj_6uvloop_4loop__UDPSendContext *(*)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *))__pyx_f_6uvloop_4loop_15_UDPSendContext_new;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop__UDPSendContext) < 0) __PYX_ERR(23, 3, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop__UDPSendContext.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop__UDPSendContext.tp_dictoffset && __pyx_type_6uvloop_4loop__UDPSendContext.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop__UDPSendContext.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type_6uvloop_4loop__UDPSendContext.tp_dict, __pyx_vtabptr_6uvloop_4loop__UDPSendContext) < 0) __PYX_ERR(23, 3, __pyx_L1_error)
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UDPSendContext, (PyObject *)&__pyx_type_6uvloop_4loop__UDPSendContext) < 0) __PYX_ERR(23, 3, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_6uvloop_4loop__UDPSendContext) < 0) __PYX_ERR(23, 3, __pyx_L1_error)
+  __pyx_ptype_6uvloop_4loop__UDPSendContext = &__pyx_type_6uvloop_4loop__UDPSendContext;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct___getaddrinfo) < 0) __PYX_ERR(0, 892, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct___getaddrinfo.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct___getaddrinfo.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct___getaddrinfo.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct___getaddrinfo.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct___getaddrinfo = &__pyx_type_6uvloop_4loop___pyx_scope_struct___getaddrinfo;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_1__getnameinfo) < 0) __PYX_ERR(0, 934, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_1__getnameinfo.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_1__getnameinfo.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_1__getnameinfo.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_1__getnameinfo.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_1__getnameinfo = &__pyx_type_6uvloop_4loop___pyx_scope_struct_1__getnameinfo;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_2___get__) < 0) __PYX_ERR(0, 1249, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_2___get__.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_2___get__.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_2___get__.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_2___get__.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_2___get__ = &__pyx_type_6uvloop_4loop___pyx_scope_struct_2___get__;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_3_run_until_complete) < 0) __PYX_ERR(0, 1457, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_3_run_until_complete.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_3_run_until_complete.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_3_run_until_complete.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_3_run_until_complete.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_3_run_until_complete = &__pyx_type_6uvloop_4loop___pyx_scope_struct_3_run_until_complete;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo) < 0) __PYX_ERR(0, 1504, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo = &__pyx_type_6uvloop_4loop___pyx_scope_struct_4_getaddrinfo;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_5_getnameinfo) < 0) __PYX_ERR(0, 1518, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_5_getnameinfo.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_5_getnameinfo.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_5_getnameinfo.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_5_getnameinfo.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_5_getnameinfo = &__pyx_type_6uvloop_4loop___pyx_scope_struct_5_getnameinfo;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_6_start_tls) < 0) __PYX_ERR(0, 1573, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_6_start_tls.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_6_start_tls.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_6_start_tls.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_6_start_tls.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_6_start_tls = &__pyx_type_6uvloop_4loop___pyx_scope_struct_6_start_tls;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_7_create_server) < 0) __PYX_ERR(0, 1629, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_7_create_server.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_7_create_server.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_7_create_server.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_7_create_server.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_7_create_server = &__pyx_type_6uvloop_4loop___pyx_scope_struct_7_create_server;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_8_create_connection) < 0) __PYX_ERR(0, 1839, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_8_create_connection.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_8_create_connection.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_8_create_connection.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_8_create_connection.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_8_create_connection = &__pyx_type_6uvloop_4loop___pyx_scope_struct_8_create_connection;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_9_genexpr) < 0) __PYX_ERR(0, 2023, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_9_genexpr.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_9_genexpr.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_9_genexpr.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_9_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_9_genexpr = &__pyx_type_6uvloop_4loop___pyx_scope_struct_9_genexpr;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_10_genexpr) < 0) __PYX_ERR(0, 2028, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_10_genexpr.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_10_genexpr.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_10_genexpr.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_10_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_10_genexpr = &__pyx_type_6uvloop_4loop___pyx_scope_struct_10_genexpr;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_11_create_unix_server) < 0) __PYX_ERR(0, 2075, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_11_create_unix_server.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_11_create_unix_server.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_11_create_unix_server.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_11_create_unix_server.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_11_create_unix_server = &__pyx_type_6uvloop_4loop___pyx_scope_struct_11_create_unix_server;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection) < 0) __PYX_ERR(0, 2203, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection = &__pyx_type_6uvloop_4loop___pyx_scope_struct_12_create_unix_connection;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_13_sock_recv) < 0) __PYX_ERR(0, 2443, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_13_sock_recv.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_13_sock_recv.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_13_sock_recv.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_13_sock_recv.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_13_sock_recv = &__pyx_type_6uvloop_4loop___pyx_scope_struct_13_sock_recv;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into) < 0) __PYX_ERR(0, 2471, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into = &__pyx_type_6uvloop_4loop___pyx_scope_struct_14_sock_recv_into;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_15_sock_sendall) < 0) __PYX_ERR(0, 2498, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_15_sock_sendall.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_15_sock_sendall.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_15_sock_sendall.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_15_sock_sendall.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_15_sock_sendall = &__pyx_type_6uvloop_4loop___pyx_scope_struct_15_sock_sendall;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_16_sock_accept) < 0) __PYX_ERR(0, 2552, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_16_sock_accept.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_16_sock_accept.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_16_sock_accept.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_16_sock_accept.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_16_sock_accept = &__pyx_type_6uvloop_4loop___pyx_scope_struct_16_sock_accept;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_17_sock_connect) < 0) __PYX_ERR(0, 2581, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_17_sock_connect.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_17_sock_connect.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_17_sock_connect.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_17_sock_connect.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_17_sock_connect = &__pyx_type_6uvloop_4loop___pyx_scope_struct_17_sock_connect;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket) < 0) __PYX_ERR(0, 2605, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket = &__pyx_type_6uvloop_4loop___pyx_scope_struct_18_connect_accepted_socket;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_19___subprocess_run) < 0) __PYX_ERR(0, 2708, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_19___subprocess_run.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_19___subprocess_run.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_19___subprocess_run.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_19___subprocess_run.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_19___subprocess_run = &__pyx_type_6uvloop_4loop___pyx_scope_struct_19___subprocess_run;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell) < 0) __PYX_ERR(0, 2770, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell = &__pyx_type_6uvloop_4loop___pyx_scope_struct_20_subprocess_shell;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec) < 0) __PYX_ERR(0, 2785, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec = &__pyx_type_6uvloop_4loop___pyx_scope_struct_21_subprocess_exec;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe) < 0) __PYX_ERR(0, 2797, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe = &__pyx_type_6uvloop_4loop___pyx_scope_struct_22_connect_read_pipe;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe) < 0) __PYX_ERR(0, 2824, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe = &__pyx_type_6uvloop_4loop___pyx_scope_struct_23_connect_write_pipe;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint) < 0) __PYX_ERR(0, 2955, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint = &__pyx_type_6uvloop_4loop___pyx_scope_struct_24_create_datagram_endpoint;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_25_genexpr) < 0) __PYX_ERR(0, 3001, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_25_genexpr.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_25_genexpr.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_25_genexpr.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_25_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_25_genexpr = &__pyx_type_6uvloop_4loop___pyx_scope_struct_25_genexpr;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens) < 0) __PYX_ERR(0, 3138, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens = &__pyx_type_6uvloop_4loop___pyx_scope_struct_26_shutdown_asyncgens;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor) < 0) __PYX_ERR(0, 3163, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor = &__pyx_type_6uvloop_4loop___pyx_scope_struct_27_shutdown_default_executor;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_28__start_handshake) < 0) __PYX_ERR(22, 462, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_28__start_handshake.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_28__start_handshake.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_28__start_handshake.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_28__start_handshake.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_28__start_handshake = &__pyx_type_6uvloop_4loop___pyx_scope_struct_28__start_handshake;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_29__start_shutdown) < 0) __PYX_ERR(22, 559, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_29__start_shutdown.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_29__start_shutdown.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_29__start_shutdown.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_29__start_shutdown.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_29__start_shutdown = &__pyx_type_6uvloop_4loop___pyx_scope_struct_29__start_shutdown;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_30___aenter__) < 0) __PYX_ERR(24, 52, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_30___aenter__.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_30___aenter__.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_30___aenter__.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_30___aenter__.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_30___aenter__ = &__pyx_type_6uvloop_4loop___pyx_scope_struct_30___aenter__;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_31___aexit__) < 0) __PYX_ERR(24, 56, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_31___aexit__.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_31___aexit__.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_31___aexit__.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_31___aexit__.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_31___aexit__ = &__pyx_type_6uvloop_4loop___pyx_scope_struct_31___aexit__;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_32_wait_closed) < 0) __PYX_ERR(24, 67, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_32_wait_closed.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_32_wait_closed.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_32_wait_closed.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_32_wait_closed.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_32_wait_closed = &__pyx_type_6uvloop_4loop___pyx_scope_struct_32_wait_closed;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_33_start_serving) < 0) __PYX_ERR(24, 100, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_33_start_serving.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_33_start_serving.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_33_start_serving.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_33_start_serving.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_33_start_serving = &__pyx_type_6uvloop_4loop___pyx_scope_struct_33_start_serving;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_34_serve_forever) < 0) __PYX_ERR(24, 104, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_34_serve_forever.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_34_serve_forever.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_34_serve_forever.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_34_serve_forever.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_34_serve_forever = &__pyx_type_6uvloop_4loop___pyx_scope_struct_34_serve_forever;
+  if (PyType_Ready(&__pyx_type_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1) < 0) __PYX_ERR(0, 3334, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1.tp_dictoffset && __pyx_type_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1 = &__pyx_type_6uvloop_4loop___pyx_scope_struct_35__test_coroutine_1;
+  if (PyType_Ready(&__pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py) < 0) __PYX_ERR(7, 64, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py.tp_dictoffset && __pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype___pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py = &__pyx_scope_struct____Pyx_CFunc_object____Loop____bint___to_py;
+  __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(26, 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(26, 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(27, 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(27, 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(28, 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(28, 15, __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
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
+  /*--- Function import code ---*/
+  __Pyx_RefNannyFinishContext();
+  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
+#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 initloop(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC initloop(void)
+#else
+__Pyx_PyMODINIT_FUNC PyInit_loop(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC PyInit_loop(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;
+}
+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);
+        }
+        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, 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;
+}
+
+
+static CYTHON_SMALL_CODE int __pyx_pymod_exec_loop(PyObject *__pyx_pyinit_module)
+#endif
+#endif
+{
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  int64_t __pyx_t_6;
+  PyObject *__pyx_t_7 = 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 'loop' 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");
+}
+#endif
+  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_loop(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("loop", __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_uvloop__loop) {
+    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, "uvloop.loop")) {
+      if (unlikely(PyDict_SetItemString(modules, "uvloop.loop", __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();
+  (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_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  (void)__Pyx_modinit_variable_import_code();
+  (void)__Pyx_modinit_function_import_code();
+  /*--- Execution code ---*/
+  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+
+  /* "uvloop/loop.pyx":3
+ * # cython: language_level=3, embedsignature=True
+ * 
+ * import asyncio             # <<<<<<<<<<<<<<
+ * cimport cython
+ * 
+ */
+  __pyx_t_1 = __Pyx_patch_asyncio(__Pyx_Import(__pyx_n_s_asyncio, 0, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_asyncio, __pyx_t_1) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "uvloop/loop.pyx":42
+ * )
+ * 
+ * from . import _noop             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_n_s_noop);
+  __Pyx_GIVEREF(__pyx_n_s_noop);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_noop);
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s__8, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __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_noop); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_noop, __pyx_t_1) < 0) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":4
+ * 
+ * 
+ * import asyncio, asyncio.log, asyncio.base_events, \             # <<<<<<<<<<<<<<
+ *        asyncio.sslproto, asyncio.coroutines, \
+ *        asyncio.futures, asyncio.transports
+ */
+  __pyx_t_2 = __Pyx_patch_asyncio(__Pyx_Import(__pyx_n_s_asyncio, 0, 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_asyncio, __pyx_t_2) < 0) __PYX_ERR(29, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_asyncio_log, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_asyncio, __pyx_t_2) < 0) __PYX_ERR(29, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_asyncio_base_events, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_asyncio, __pyx_t_2) < 0) __PYX_ERR(29, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":5
+ * 
+ * import asyncio, asyncio.log, asyncio.base_events, \
+ *        asyncio.sslproto, asyncio.coroutines, \             # <<<<<<<<<<<<<<
+ *        asyncio.futures, asyncio.transports
+ * import collections.abc
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_asyncio_sslproto, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_asyncio, __pyx_t_2) < 0) __PYX_ERR(29, 5, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_asyncio_coroutines, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_asyncio, __pyx_t_2) < 0) __PYX_ERR(29, 5, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":6
+ * import asyncio, asyncio.log, asyncio.base_events, \
+ *        asyncio.sslproto, asyncio.coroutines, \
+ *        asyncio.futures, asyncio.transports             # <<<<<<<<<<<<<<
+ * import collections.abc
+ * import concurrent.futures
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_asyncio_futures, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_asyncio, __pyx_t_2) < 0) __PYX_ERR(29, 6, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_asyncio_transports, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_asyncio, __pyx_t_2) < 0) __PYX_ERR(29, 6, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":7
+ *        asyncio.sslproto, asyncio.coroutines, \
+ *        asyncio.futures, asyncio.transports
+ * import collections.abc             # <<<<<<<<<<<<<<
+ * import concurrent.futures
+ * import errno
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_collections_abc, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_collections, __pyx_t_2) < 0) __PYX_ERR(29, 7, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":8
+ *        asyncio.futures, asyncio.transports
+ * import collections.abc
+ * import concurrent.futures             # <<<<<<<<<<<<<<
+ * import errno
+ * import functools
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_concurrent_futures, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_concurrent, __pyx_t_2) < 0) __PYX_ERR(29, 8, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":9
+ * import collections.abc
+ * import concurrent.futures
+ * import errno             # <<<<<<<<<<<<<<
+ * import functools
+ * import gc
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_errno, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_errno, __pyx_t_2) < 0) __PYX_ERR(29, 9, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":10
+ * import concurrent.futures
+ * import errno
+ * import functools             # <<<<<<<<<<<<<<
+ * import gc
+ * import inspect
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_functools, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 10, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_functools, __pyx_t_2) < 0) __PYX_ERR(29, 10, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":11
+ * import errno
+ * import functools
+ * import gc             # <<<<<<<<<<<<<<
+ * import inspect
+ * import itertools
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_gc, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_gc, __pyx_t_2) < 0) __PYX_ERR(29, 11, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":12
+ * import functools
+ * import gc
+ * import inspect             # <<<<<<<<<<<<<<
+ * import itertools
+ * import os
+ */
+  __pyx_t_2 = __Pyx_patch_inspect(__Pyx_Import(__pyx_n_s_inspect, 0, 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_inspect, __pyx_t_2) < 0) __PYX_ERR(29, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":13
+ * import gc
+ * import inspect
+ * import itertools             # <<<<<<<<<<<<<<
+ * import os
+ * import signal
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_itertools, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 13, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_itertools, __pyx_t_2) < 0) __PYX_ERR(29, 13, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":14
+ * import inspect
+ * import itertools
+ * import os             # <<<<<<<<<<<<<<
+ * import signal
+ * import socket
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_os, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 14, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_2) < 0) __PYX_ERR(29, 14, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":15
+ * import itertools
+ * import os
+ * import signal             # <<<<<<<<<<<<<<
+ * import socket
+ * import subprocess
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_signal, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 15, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_signal, __pyx_t_2) < 0) __PYX_ERR(29, 15, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":16
+ * import os
+ * import signal
+ * import socket             # <<<<<<<<<<<<<<
+ * import subprocess
+ * import ssl
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_socket_2, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_socket_2, __pyx_t_2) < 0) __PYX_ERR(29, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":17
+ * import signal
+ * import socket
+ * import subprocess             # <<<<<<<<<<<<<<
+ * import ssl
+ * import stat
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_subprocess, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_subprocess, __pyx_t_2) < 0) __PYX_ERR(29, 17, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":18
+ * import socket
+ * import subprocess
+ * import ssl             # <<<<<<<<<<<<<<
+ * import stat
+ * import sys
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_ssl, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ssl, __pyx_t_2) < 0) __PYX_ERR(29, 18, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":19
+ * import subprocess
+ * import ssl
+ * import stat             # <<<<<<<<<<<<<<
+ * import sys
+ * import threading
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_stat, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stat, __pyx_t_2) < 0) __PYX_ERR(29, 19, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":20
+ * import ssl
+ * import stat
+ * import sys             # <<<<<<<<<<<<<<
+ * import threading
+ * import traceback
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_sys, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_2) < 0) __PYX_ERR(29, 20, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":21
+ * import stat
+ * import sys
+ * import threading             # <<<<<<<<<<<<<<
+ * import traceback
+ * import time
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_threading, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_threading, __pyx_t_2) < 0) __PYX_ERR(29, 21, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":22
+ * import sys
+ * import threading
+ * import traceback             # <<<<<<<<<<<<<<
+ * import time
+ * import warnings
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_traceback_2, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_traceback_2, __pyx_t_2) < 0) __PYX_ERR(29, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":23
+ * import threading
+ * import traceback
+ * import time             # <<<<<<<<<<<<<<
+ * import warnings
+ * import weakref
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_time, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_2) < 0) __PYX_ERR(29, 23, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":24
+ * import traceback
+ * import time
+ * import warnings             # <<<<<<<<<<<<<<
+ * import weakref
+ * 
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_warnings, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_warnings, __pyx_t_2) < 0) __PYX_ERR(29, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":25
+ * import time
+ * import warnings
+ * import weakref             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_weakref, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 25, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_weakref, __pyx_t_2) < 0) __PYX_ERR(29, 25, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":28
+ * 
+ * 
+ * cdef aio_get_event_loop = asyncio.get_event_loop             # <<<<<<<<<<<<<<
+ * cdef aio_CancelledError = asyncio.CancelledError
+ * cdef aio_InvalidStateError = asyncio.InvalidStateError
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get_event_loop); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_get_event_loop);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_get_event_loop, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":29
+ * 
+ * cdef aio_get_event_loop = asyncio.get_event_loop
+ * cdef aio_CancelledError = asyncio.CancelledError             # <<<<<<<<<<<<<<
+ * cdef aio_InvalidStateError = asyncio.InvalidStateError
+ * cdef aio_TimeoutError = asyncio.TimeoutError
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_CancelledError); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_CancelledError);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_CancelledError, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":30
+ * cdef aio_get_event_loop = asyncio.get_event_loop
+ * cdef aio_CancelledError = asyncio.CancelledError
+ * cdef aio_InvalidStateError = asyncio.InvalidStateError             # <<<<<<<<<<<<<<
+ * cdef aio_TimeoutError = asyncio.TimeoutError
+ * cdef aio_Future = asyncio.Future
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_InvalidStateError); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_InvalidStateError);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_InvalidStateError, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":31
+ * cdef aio_CancelledError = asyncio.CancelledError
+ * cdef aio_InvalidStateError = asyncio.InvalidStateError
+ * cdef aio_TimeoutError = asyncio.TimeoutError             # <<<<<<<<<<<<<<
+ * cdef aio_Future = asyncio.Future
+ * cdef aio_Task = asyncio.Task
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_TimeoutError); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_TimeoutError);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_TimeoutError, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":32
+ * cdef aio_InvalidStateError = asyncio.InvalidStateError
+ * cdef aio_TimeoutError = asyncio.TimeoutError
+ * cdef aio_Future = asyncio.Future             # <<<<<<<<<<<<<<
+ * cdef aio_Task = asyncio.Task
+ * cdef aio_ensure_future = asyncio.ensure_future
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Future); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_Future);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_Future, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":33
+ * cdef aio_TimeoutError = asyncio.TimeoutError
+ * cdef aio_Future = asyncio.Future
+ * cdef aio_Task = asyncio.Task             # <<<<<<<<<<<<<<
+ * cdef aio_ensure_future = asyncio.ensure_future
+ * cdef aio_gather = asyncio.gather
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 33, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Task); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 33, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_Task);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_Task, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":34
+ * cdef aio_Future = asyncio.Future
+ * cdef aio_Task = asyncio.Task
+ * cdef aio_ensure_future = asyncio.ensure_future             # <<<<<<<<<<<<<<
+ * cdef aio_gather = asyncio.gather
+ * cdef aio_wait = asyncio.wait
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ensure_future); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_ensure_future);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_ensure_future, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":35
+ * cdef aio_Task = asyncio.Task
+ * cdef aio_ensure_future = asyncio.ensure_future
+ * cdef aio_gather = asyncio.gather             # <<<<<<<<<<<<<<
+ * cdef aio_wait = asyncio.wait
+ * cdef aio_wrap_future = asyncio.wrap_future
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 35, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_gather); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 35, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_gather);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_gather, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":36
+ * cdef aio_ensure_future = asyncio.ensure_future
+ * cdef aio_gather = asyncio.gather
+ * cdef aio_wait = asyncio.wait             # <<<<<<<<<<<<<<
+ * cdef aio_wrap_future = asyncio.wrap_future
+ * cdef aio_logger = asyncio.log.logger
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_wait); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_wait);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_wait, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":37
+ * cdef aio_gather = asyncio.gather
+ * cdef aio_wait = asyncio.wait
+ * cdef aio_wrap_future = asyncio.wrap_future             # <<<<<<<<<<<<<<
+ * cdef aio_logger = asyncio.log.logger
+ * cdef aio_iscoroutine = asyncio.iscoroutine
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_wrap_future); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_wrap_future);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_wrap_future, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":38
+ * cdef aio_wait = asyncio.wait
+ * cdef aio_wrap_future = asyncio.wrap_future
+ * cdef aio_logger = asyncio.log.logger             # <<<<<<<<<<<<<<
+ * cdef aio_iscoroutine = asyncio.iscoroutine
+ * cdef aio_iscoroutinefunction = asyncio.iscoroutinefunction
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_logger); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_logger);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_logger, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":39
+ * cdef aio_wrap_future = asyncio.wrap_future
+ * cdef aio_logger = asyncio.log.logger
+ * cdef aio_iscoroutine = asyncio.iscoroutine             # <<<<<<<<<<<<<<
+ * cdef aio_iscoroutinefunction = asyncio.iscoroutinefunction
+ * cdef aio_BaseProtocol = asyncio.BaseProtocol
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 39, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_iscoroutine); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 39, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_iscoroutine);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_iscoroutine, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":40
+ * cdef aio_logger = asyncio.log.logger
+ * cdef aio_iscoroutine = asyncio.iscoroutine
+ * cdef aio_iscoroutinefunction = asyncio.iscoroutinefunction             # <<<<<<<<<<<<<<
+ * cdef aio_BaseProtocol = asyncio.BaseProtocol
+ * cdef aio_Protocol = asyncio.Protocol
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_iscoroutinefunction); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_iscoroutinefunction);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_iscoroutinefunction, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":41
+ * cdef aio_iscoroutine = asyncio.iscoroutine
+ * cdef aio_iscoroutinefunction = asyncio.iscoroutinefunction
+ * cdef aio_BaseProtocol = asyncio.BaseProtocol             # <<<<<<<<<<<<<<
+ * cdef aio_Protocol = asyncio.Protocol
+ * cdef aio_isfuture = getattr(asyncio, 'isfuture', None)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_BaseProtocol); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_BaseProtocol);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_BaseProtocol, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":42
+ * cdef aio_iscoroutinefunction = asyncio.iscoroutinefunction
+ * cdef aio_BaseProtocol = asyncio.BaseProtocol
+ * cdef aio_Protocol = asyncio.Protocol             # <<<<<<<<<<<<<<
+ * cdef aio_isfuture = getattr(asyncio, 'isfuture', None)
+ * cdef aio_get_running_loop = getattr(asyncio, '_get_running_loop', None)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Protocol); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_Protocol);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_Protocol, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":43
+ * cdef aio_BaseProtocol = asyncio.BaseProtocol
+ * cdef aio_Protocol = asyncio.Protocol
+ * cdef aio_isfuture = getattr(asyncio, 'isfuture', None)             # <<<<<<<<<<<<<<
+ * cdef aio_get_running_loop = getattr(asyncio, '_get_running_loop', None)
+ * cdef aio_set_running_loop = getattr(asyncio, '_set_running_loop', None)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_isfuture, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_isfuture);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_isfuture, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":44
+ * cdef aio_Protocol = asyncio.Protocol
+ * cdef aio_isfuture = getattr(asyncio, 'isfuture', None)
+ * cdef aio_get_running_loop = getattr(asyncio, '_get_running_loop', None)             # <<<<<<<<<<<<<<
+ * cdef aio_set_running_loop = getattr(asyncio, '_set_running_loop', None)
+ * cdef aio_debug_wrapper = getattr(asyncio.coroutines, 'debug_wrapper', None)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr3(__pyx_t_1, __pyx_n_u_get_running_loop, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_get_running_loop);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_get_running_loop, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":45
+ * cdef aio_isfuture = getattr(asyncio, 'isfuture', None)
+ * cdef aio_get_running_loop = getattr(asyncio, '_get_running_loop', None)
+ * cdef aio_set_running_loop = getattr(asyncio, '_set_running_loop', None)             # <<<<<<<<<<<<<<
+ * cdef aio_debug_wrapper = getattr(asyncio.coroutines, 'debug_wrapper', None)
+ * cdef aio_AbstractChildWatcher = asyncio.AbstractChildWatcher
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_set_running_loop, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_set_running_loop);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_set_running_loop, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":46
+ * cdef aio_get_running_loop = getattr(asyncio, '_get_running_loop', None)
+ * cdef aio_set_running_loop = getattr(asyncio, '_set_running_loop', None)
+ * cdef aio_debug_wrapper = getattr(asyncio.coroutines, 'debug_wrapper', None)             # <<<<<<<<<<<<<<
+ * cdef aio_AbstractChildWatcher = asyncio.AbstractChildWatcher
+ * cdef aio_Transport = asyncio.Transport
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_coroutines); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_debug_wrapper, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_debug_wrapper);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_debug_wrapper, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":47
+ * cdef aio_set_running_loop = getattr(asyncio, '_set_running_loop', None)
+ * cdef aio_debug_wrapper = getattr(asyncio.coroutines, 'debug_wrapper', None)
+ * cdef aio_AbstractChildWatcher = asyncio.AbstractChildWatcher             # <<<<<<<<<<<<<<
+ * cdef aio_Transport = asyncio.Transport
+ * cdef aio_FlowControlMixin = asyncio.transports._FlowControlMixin
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 47, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_AbstractChildWatcher); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 47, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_AbstractChildWatcher);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_AbstractChildWatcher, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":48
+ * cdef aio_debug_wrapper = getattr(asyncio.coroutines, 'debug_wrapper', None)
+ * cdef aio_AbstractChildWatcher = asyncio.AbstractChildWatcher
+ * cdef aio_Transport = asyncio.Transport             # <<<<<<<<<<<<<<
+ * cdef aio_FlowControlMixin = asyncio.transports._FlowControlMixin
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Transport); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_Transport);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_Transport, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":49
+ * cdef aio_AbstractChildWatcher = asyncio.AbstractChildWatcher
+ * cdef aio_Transport = asyncio.Transport
+ * cdef aio_FlowControlMixin = asyncio.transports._FlowControlMixin             # <<<<<<<<<<<<<<
+ * 
+ * cdef col_deque = collections.deque
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_transports); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_FlowControlMixin); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_aio_FlowControlMixin);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_aio_FlowControlMixin, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":51
+ * cdef aio_FlowControlMixin = asyncio.transports._FlowControlMixin
+ * 
+ * cdef col_deque = collections.deque             # <<<<<<<<<<<<<<
+ * cdef col_Iterable = collections.abc.Iterable
+ * cdef col_Counter = collections.Counter
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_collections); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_deque); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_col_deque);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_col_deque, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":52
+ * 
+ * cdef col_deque = collections.deque
+ * cdef col_Iterable = collections.abc.Iterable             # <<<<<<<<<<<<<<
+ * cdef col_Counter = collections.Counter
+ * cdef col_OrderedDict = collections.OrderedDict
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_collections); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_abc); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Iterable); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_col_Iterable);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_col_Iterable, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":53
+ * cdef col_deque = collections.deque
+ * cdef col_Iterable = collections.abc.Iterable
+ * cdef col_Counter = collections.Counter             # <<<<<<<<<<<<<<
+ * cdef col_OrderedDict = collections.OrderedDict
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_collections); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Counter); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_col_Counter);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_col_Counter, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":54
+ * cdef col_Iterable = collections.abc.Iterable
+ * cdef col_Counter = collections.Counter
+ * cdef col_OrderedDict = collections.OrderedDict             # <<<<<<<<<<<<<<
+ * 
+ * cdef cc_ThreadPoolExecutor = concurrent.futures.ThreadPoolExecutor
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_collections); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_col_OrderedDict);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_col_OrderedDict, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":56
+ * cdef col_OrderedDict = collections.OrderedDict
+ * 
+ * cdef cc_ThreadPoolExecutor = concurrent.futures.ThreadPoolExecutor             # <<<<<<<<<<<<<<
+ * cdef cc_Future = concurrent.futures.Future
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_concurrent); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_futures); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ThreadPoolExecutor); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_cc_ThreadPoolExecutor);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_cc_ThreadPoolExecutor, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":57
+ * 
+ * cdef cc_ThreadPoolExecutor = concurrent.futures.ThreadPoolExecutor
+ * cdef cc_Future = concurrent.futures.Future             # <<<<<<<<<<<<<<
+ * 
+ * cdef errno_EBADF = errno.EBADF
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_concurrent); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_futures); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Future); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_cc_Future);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_cc_Future, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":59
+ * cdef cc_Future = concurrent.futures.Future
+ * 
+ * cdef errno_EBADF = errno.EBADF             # <<<<<<<<<<<<<<
+ * cdef errno_EINVAL = errno.EINVAL
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(EBADF); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_errno_EBADF);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_errno_EBADF, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":60
+ * 
+ * cdef errno_EBADF = errno.EBADF
+ * cdef errno_EINVAL = errno.EINVAL             # <<<<<<<<<<<<<<
+ * 
+ * cdef ft_partial = functools.partial
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(EINVAL); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_errno_EINVAL);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_errno_EINVAL, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":62
+ * cdef errno_EINVAL = errno.EINVAL
+ * 
+ * cdef ft_partial = functools.partial             # <<<<<<<<<<<<<<
+ * 
+ * cdef gc_disable = gc.disable
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_functools); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_partial); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_ft_partial);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_ft_partial, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":64
+ * cdef ft_partial = functools.partial
+ * 
+ * cdef gc_disable = gc.disable             # <<<<<<<<<<<<<<
+ * 
+ * cdef iter_chain = itertools.chain
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_gc); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_disable); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_gc_disable);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_gc_disable, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":66
+ * cdef gc_disable = gc.disable
+ * 
+ * cdef iter_chain = itertools.chain             # <<<<<<<<<<<<<<
+ * cdef inspect_isgenerator = inspect.isgenerator
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_itertools); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_chain); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_iter_chain);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_iter_chain, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":67
+ * 
+ * cdef iter_chain = itertools.chain
+ * cdef inspect_isgenerator = inspect.isgenerator             # <<<<<<<<<<<<<<
+ * 
+ * cdef int has_IPV6_V6ONLY = hasattr(socket, 'IPV6_V6ONLY')
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_inspect); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_isgenerator); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_inspect_isgenerator);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_inspect_isgenerator, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":69
+ * cdef inspect_isgenerator = inspect.isgenerator
+ * 
+ * cdef int has_IPV6_V6ONLY = hasattr(socket, 'IPV6_V6ONLY')             # <<<<<<<<<<<<<<
+ * cdef int IPV6_V6ONLY = getattr(socket, 'IPV6_V6ONLY', -1)
+ * cdef int has_SO_REUSEPORT = hasattr(socket, 'SO_REUSEPORT')
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_HasAttr(__pyx_t_2, __pyx_n_u_IPV6_V6ONLY); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(29, 69, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_has_IPV6_V6ONLY = __pyx_t_3;
+
+  /* "uvloop/includes/stdlib.pxi":70
+ * 
+ * cdef int has_IPV6_V6ONLY = hasattr(socket, 'IPV6_V6ONLY')
+ * cdef int IPV6_V6ONLY = getattr(socket, 'IPV6_V6ONLY', -1)             # <<<<<<<<<<<<<<
+ * cdef int has_SO_REUSEPORT = hasattr(socket, 'SO_REUSEPORT')
+ * cdef int SO_REUSEPORT = getattr(socket, 'SO_REUSEPORT', 0)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_IPV6_V6ONLY, __pyx_int_neg_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 70, __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(29, 70, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_6uvloop_4loop_IPV6_V6ONLY = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":71
+ * cdef int has_IPV6_V6ONLY = hasattr(socket, 'IPV6_V6ONLY')
+ * cdef int IPV6_V6ONLY = getattr(socket, 'IPV6_V6ONLY', -1)
+ * cdef int has_SO_REUSEPORT = hasattr(socket, 'SO_REUSEPORT')             # <<<<<<<<<<<<<<
+ * cdef int SO_REUSEPORT = getattr(socket, 'SO_REUSEPORT', 0)
+ * cdef int SO_BROADCAST = getattr(socket, 'SO_BROADCAST')
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_HasAttr(__pyx_t_1, __pyx_n_u_SO_REUSEPORT); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(29, 71, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_6uvloop_4loop_has_SO_REUSEPORT = __pyx_t_3;
+
+  /* "uvloop/includes/stdlib.pxi":72
+ * cdef int IPV6_V6ONLY = getattr(socket, 'IPV6_V6ONLY', -1)
+ * cdef int has_SO_REUSEPORT = hasattr(socket, 'SO_REUSEPORT')
+ * cdef int SO_REUSEPORT = getattr(socket, 'SO_REUSEPORT', 0)             # <<<<<<<<<<<<<<
+ * cdef int SO_BROADCAST = getattr(socket, 'SO_BROADCAST')
+ * cdef int SOCK_NONBLOCK = getattr(socket, 'SOCK_NONBLOCK', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr3(__pyx_t_1, __pyx_n_u_SO_REUSEPORT, __pyx_int_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 72, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_SO_REUSEPORT = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":73
+ * cdef int has_SO_REUSEPORT = hasattr(socket, 'SO_REUSEPORT')
+ * cdef int SO_REUSEPORT = getattr(socket, 'SO_REUSEPORT', 0)
+ * cdef int SO_BROADCAST = getattr(socket, 'SO_BROADCAST')             # <<<<<<<<<<<<<<
+ * cdef int SOCK_NONBLOCK = getattr(socket, 'SOCK_NONBLOCK', -1)
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr(__pyx_t_2, __pyx_n_u_SO_BROADCAST); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 73, __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(29, 73, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_6uvloop_4loop_SO_BROADCAST = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":74
+ * cdef int SO_REUSEPORT = getattr(socket, 'SO_REUSEPORT', 0)
+ * cdef int SO_BROADCAST = getattr(socket, 'SO_BROADCAST')
+ * cdef int SOCK_NONBLOCK = getattr(socket, 'SOCK_NONBLOCK', -1)             # <<<<<<<<<<<<<<
+ * 
+ * cdef socket_gaierror = socket.gaierror
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr3(__pyx_t_1, __pyx_n_u_SOCK_NONBLOCK, __pyx_int_neg_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 74, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_SOCK_NONBLOCK = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":76
+ * cdef int SOCK_NONBLOCK = getattr(socket, 'SOCK_NONBLOCK', -1)
+ * 
+ * cdef socket_gaierror = socket.gaierror             # <<<<<<<<<<<<<<
+ * cdef socket_error = socket.error
+ * cdef socket_timeout = socket.timeout
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_gaierror); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_socket_gaierror);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_socket_gaierror, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":77
+ * 
+ * cdef socket_gaierror = socket.gaierror
+ * cdef socket_error = socket.error             # <<<<<<<<<<<<<<
+ * cdef socket_timeout = socket.timeout
+ * cdef socket_socket = socket.socket
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_error); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_socket_error);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_socket_error, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":78
+ * cdef socket_gaierror = socket.gaierror
+ * cdef socket_error = socket.error
+ * cdef socket_timeout = socket.timeout             # <<<<<<<<<<<<<<
+ * cdef socket_socket = socket.socket
+ * cdef socket_socketpair = socket.socketpair
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_socket_timeout);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_socket_timeout, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":79
+ * cdef socket_error = socket.error
+ * cdef socket_timeout = socket.timeout
+ * cdef socket_socket = socket.socket             # <<<<<<<<<<<<<<
+ * cdef socket_socketpair = socket.socketpair
+ * cdef socket_getservbyname = socket.getservbyname
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_socket_socket);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_socket_socket, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":80
+ * cdef socket_timeout = socket.timeout
+ * cdef socket_socket = socket.socket
+ * cdef socket_socketpair = socket.socketpair             # <<<<<<<<<<<<<<
+ * cdef socket_getservbyname = socket.getservbyname
+ * cdef socket_AddressFamily = socket.AddressFamily
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_socketpair); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_socket_socketpair);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_socket_socketpair, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":81
+ * cdef socket_socket = socket.socket
+ * cdef socket_socketpair = socket.socketpair
+ * cdef socket_getservbyname = socket.getservbyname             # <<<<<<<<<<<<<<
+ * cdef socket_AddressFamily = socket.AddressFamily
+ * cdef socket_SocketKind = socket.SocketKind
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getservbyname); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_socket_getservbyname);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_socket_getservbyname, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":82
+ * cdef socket_socketpair = socket.socketpair
+ * cdef socket_getservbyname = socket.getservbyname
+ * cdef socket_AddressFamily = socket.AddressFamily             # <<<<<<<<<<<<<<
+ * cdef socket_SocketKind = socket.SocketKind
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_AddressFamily); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_socket_AddressFamily);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_socket_AddressFamily, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":83
+ * cdef socket_getservbyname = socket.getservbyname
+ * cdef socket_AddressFamily = socket.AddressFamily
+ * cdef socket_SocketKind = socket.SocketKind             # <<<<<<<<<<<<<<
+ * 
+ * cdef int socket_EAI_ADDRFAMILY = getattr(socket, 'EAI_ADDRFAMILY', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 83, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_SocketKind); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 83, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_socket_SocketKind);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_socket_SocketKind, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":85
+ * cdef socket_SocketKind = socket.SocketKind
+ * 
+ * cdef int socket_EAI_ADDRFAMILY = getattr(socket, 'EAI_ADDRFAMILY', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_AGAIN      = getattr(socket, 'EAI_AGAIN', -1)
+ * cdef int socket_EAI_BADFLAGS   = getattr(socket, 'EAI_BADFLAGS', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 85, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_EAI_ADDRFAMILY, __pyx_int_neg_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 85, __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(29, 85, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_ADDRFAMILY = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":86
+ * 
+ * cdef int socket_EAI_ADDRFAMILY = getattr(socket, 'EAI_ADDRFAMILY', -1)
+ * cdef int socket_EAI_AGAIN      = getattr(socket, 'EAI_AGAIN', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_BADFLAGS   = getattr(socket, 'EAI_BADFLAGS', -1)
+ * cdef int socket_EAI_BADHINTS   = getattr(socket, 'EAI_BADHINTS', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr3(__pyx_t_1, __pyx_n_u_EAI_AGAIN, __pyx_int_neg_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 86, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_AGAIN = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":87
+ * cdef int socket_EAI_ADDRFAMILY = getattr(socket, 'EAI_ADDRFAMILY', -1)
+ * cdef int socket_EAI_AGAIN      = getattr(socket, 'EAI_AGAIN', -1)
+ * cdef int socket_EAI_BADFLAGS   = getattr(socket, 'EAI_BADFLAGS', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_BADHINTS   = getattr(socket, 'EAI_BADHINTS', -1)
+ * cdef int socket_EAI_CANCELED   = getattr(socket, 'EAI_CANCELED', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 87, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_EAI_BADFLAGS, __pyx_int_neg_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 87, __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(29, 87, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_BADFLAGS = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":88
+ * cdef int socket_EAI_AGAIN      = getattr(socket, 'EAI_AGAIN', -1)
+ * cdef int socket_EAI_BADFLAGS   = getattr(socket, 'EAI_BADFLAGS', -1)
+ * cdef int socket_EAI_BADHINTS   = getattr(socket, 'EAI_BADHINTS', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_CANCELED   = getattr(socket, 'EAI_CANCELED', -1)
+ * cdef int socket_EAI_FAIL       = getattr(socket, 'EAI_FAIL', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr3(__pyx_t_1, __pyx_n_u_EAI_BADHINTS, __pyx_int_neg_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 88, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_BADHINTS = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":89
+ * cdef int socket_EAI_BADFLAGS   = getattr(socket, 'EAI_BADFLAGS', -1)
+ * cdef int socket_EAI_BADHINTS   = getattr(socket, 'EAI_BADHINTS', -1)
+ * cdef int socket_EAI_CANCELED   = getattr(socket, 'EAI_CANCELED', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_FAIL       = getattr(socket, 'EAI_FAIL', -1)
+ * cdef int socket_EAI_FAMILY     = getattr(socket, 'EAI_FAMILY', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 89, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_EAI_CANCELED, __pyx_int_neg_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 89, __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(29, 89, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_CANCELED = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":90
+ * cdef int socket_EAI_BADHINTS   = getattr(socket, 'EAI_BADHINTS', -1)
+ * cdef int socket_EAI_CANCELED   = getattr(socket, 'EAI_CANCELED', -1)
+ * cdef int socket_EAI_FAIL       = getattr(socket, 'EAI_FAIL', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_FAMILY     = getattr(socket, 'EAI_FAMILY', -1)
+ * cdef int socket_EAI_MEMORY     = getattr(socket, 'EAI_MEMORY', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr3(__pyx_t_1, __pyx_n_u_EAI_FAIL, __pyx_int_neg_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 90, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_FAIL = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":91
+ * cdef int socket_EAI_CANCELED   = getattr(socket, 'EAI_CANCELED', -1)
+ * cdef int socket_EAI_FAIL       = getattr(socket, 'EAI_FAIL', -1)
+ * cdef int socket_EAI_FAMILY     = getattr(socket, 'EAI_FAMILY', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_MEMORY     = getattr(socket, 'EAI_MEMORY', -1)
+ * cdef int socket_EAI_NODATA     = getattr(socket, 'EAI_NODATA', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 91, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_EAI_FAMILY, __pyx_int_neg_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 91, __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(29, 91, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_FAMILY = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":92
+ * cdef int socket_EAI_FAIL       = getattr(socket, 'EAI_FAIL', -1)
+ * cdef int socket_EAI_FAMILY     = getattr(socket, 'EAI_FAMILY', -1)
+ * cdef int socket_EAI_MEMORY     = getattr(socket, 'EAI_MEMORY', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_NODATA     = getattr(socket, 'EAI_NODATA', -1)
+ * cdef int socket_EAI_NONAME     = getattr(socket, 'EAI_NONAME', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 92, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr3(__pyx_t_1, __pyx_n_u_EAI_MEMORY, __pyx_int_neg_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 92, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 92, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_MEMORY = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":93
+ * cdef int socket_EAI_FAMILY     = getattr(socket, 'EAI_FAMILY', -1)
+ * cdef int socket_EAI_MEMORY     = getattr(socket, 'EAI_MEMORY', -1)
+ * cdef int socket_EAI_NODATA     = getattr(socket, 'EAI_NODATA', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_NONAME     = getattr(socket, 'EAI_NONAME', -1)
+ * cdef int socket_EAI_OVERFLOW   = getattr(socket, 'EAI_OVERFLOW', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_EAI_NODATA, __pyx_int_neg_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 93, __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(29, 93, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_NODATA = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":94
+ * cdef int socket_EAI_MEMORY     = getattr(socket, 'EAI_MEMORY', -1)
+ * cdef int socket_EAI_NODATA     = getattr(socket, 'EAI_NODATA', -1)
+ * cdef int socket_EAI_NONAME     = getattr(socket, 'EAI_NONAME', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_OVERFLOW   = getattr(socket, 'EAI_OVERFLOW', -1)
+ * cdef int socket_EAI_PROTOCOL   = getattr(socket, 'EAI_PROTOCOL', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr3(__pyx_t_1, __pyx_n_u_EAI_NONAME, __pyx_int_neg_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 94, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_NONAME = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":95
+ * cdef int socket_EAI_NODATA     = getattr(socket, 'EAI_NODATA', -1)
+ * cdef int socket_EAI_NONAME     = getattr(socket, 'EAI_NONAME', -1)
+ * cdef int socket_EAI_OVERFLOW   = getattr(socket, 'EAI_OVERFLOW', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_PROTOCOL   = getattr(socket, 'EAI_PROTOCOL', -1)
+ * cdef int socket_EAI_SERVICE    = getattr(socket, 'EAI_SERVICE', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_EAI_OVERFLOW, __pyx_int_neg_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 95, __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(29, 95, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_OVERFLOW = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":96
+ * cdef int socket_EAI_NONAME     = getattr(socket, 'EAI_NONAME', -1)
+ * cdef int socket_EAI_OVERFLOW   = getattr(socket, 'EAI_OVERFLOW', -1)
+ * cdef int socket_EAI_PROTOCOL   = getattr(socket, 'EAI_PROTOCOL', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_SERVICE    = getattr(socket, 'EAI_SERVICE', -1)
+ * cdef int socket_EAI_SOCKTYPE   = getattr(socket, 'EAI_SOCKTYPE', -1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 96, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr3(__pyx_t_1, __pyx_n_u_EAI_PROTOCOL, __pyx_int_neg_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 96, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 96, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_PROTOCOL = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":97
+ * cdef int socket_EAI_OVERFLOW   = getattr(socket, 'EAI_OVERFLOW', -1)
+ * cdef int socket_EAI_PROTOCOL   = getattr(socket, 'EAI_PROTOCOL', -1)
+ * cdef int socket_EAI_SERVICE    = getattr(socket, 'EAI_SERVICE', -1)             # <<<<<<<<<<<<<<
+ * cdef int socket_EAI_SOCKTYPE   = getattr(socket, 'EAI_SOCKTYPE', -1)
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_EAI_SERVICE, __pyx_int_neg_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 97, __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(29, 97, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_SERVICE = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":98
+ * cdef int socket_EAI_PROTOCOL   = getattr(socket, 'EAI_PROTOCOL', -1)
+ * cdef int socket_EAI_SERVICE    = getattr(socket, 'EAI_SERVICE', -1)
+ * cdef int socket_EAI_SOCKTYPE   = getattr(socket, 'EAI_SOCKTYPE', -1)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_socket_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr3(__pyx_t_1, __pyx_n_u_EAI_SOCKTYPE, __pyx_int_neg_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 98, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_socket_EAI_SOCKTYPE = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":101
+ * 
+ * 
+ * cdef str os_name = os.name             # <<<<<<<<<<<<<<
+ * cdef os_environ = os.environ
+ * cdef os_dup = os.dup
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(29, 101, __pyx_L1_error)
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_name);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_name, ((PyObject*)__pyx_t_1));
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":102
+ * 
+ * cdef str os_name = os.name
+ * cdef os_environ = os.environ             # <<<<<<<<<<<<<<
+ * cdef os_dup = os.dup
+ * cdef os_set_inheritable = os.set_inheritable
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_os); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_environ); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_environ);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_environ, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":103
+ * cdef str os_name = os.name
+ * cdef os_environ = os.environ
+ * cdef os_dup = os.dup             # <<<<<<<<<<<<<<
+ * cdef os_set_inheritable = os.set_inheritable
+ * cdef os_get_inheritable = os.get_inheritable
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 103, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_dup); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 103, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_dup);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_dup, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":104
+ * cdef os_environ = os.environ
+ * cdef os_dup = os.dup
+ * cdef os_set_inheritable = os.set_inheritable             # <<<<<<<<<<<<<<
+ * cdef os_get_inheritable = os.get_inheritable
+ * cdef os_close = os.close
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_os); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 104, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_set_inheritable); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 104, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_set_inheritable);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_set_inheritable, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":105
+ * cdef os_dup = os.dup
+ * cdef os_set_inheritable = os.set_inheritable
+ * cdef os_get_inheritable = os.get_inheritable             # <<<<<<<<<<<<<<
+ * cdef os_close = os.close
+ * cdef os_open = os.open
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 105, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get_inheritable); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 105, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_get_inheritable);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_get_inheritable, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":106
+ * cdef os_set_inheritable = os.set_inheritable
+ * cdef os_get_inheritable = os.get_inheritable
+ * cdef os_close = os.close             # <<<<<<<<<<<<<<
+ * cdef os_open = os.open
+ * cdef os_devnull = os.devnull
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_os); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_close); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_close);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_close, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":107
+ * cdef os_get_inheritable = os.get_inheritable
+ * cdef os_close = os.close
+ * cdef os_open = os.open             # <<<<<<<<<<<<<<
+ * cdef os_devnull = os.devnull
+ * cdef os_O_RDWR = os.O_RDWR
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 107, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_open); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 107, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_open);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_open, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":108
+ * cdef os_close = os.close
+ * cdef os_open = os.open
+ * cdef os_devnull = os.devnull             # <<<<<<<<<<<<<<
+ * cdef os_O_RDWR = os.O_RDWR
+ * cdef os_pipe = os.pipe
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_os); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 108, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_devnull); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 108, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_devnull);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_devnull, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":109
+ * cdef os_open = os.open
+ * cdef os_devnull = os.devnull
+ * cdef os_O_RDWR = os.O_RDWR             # <<<<<<<<<<<<<<
+ * cdef os_pipe = os.pipe
+ * cdef os_read = os.read
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 109, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_O_RDWR); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 109, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_O_RDWR);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_O_RDWR, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":110
+ * cdef os_devnull = os.devnull
+ * cdef os_O_RDWR = os.O_RDWR
+ * cdef os_pipe = os.pipe             # <<<<<<<<<<<<<<
+ * cdef os_read = os.read
+ * cdef os_remove = os.remove
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_os); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_pipe); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_pipe);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_pipe, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":111
+ * cdef os_O_RDWR = os.O_RDWR
+ * cdef os_pipe = os.pipe
+ * cdef os_read = os.read             # <<<<<<<<<<<<<<
+ * cdef os_remove = os.remove
+ * cdef os_stat = os.stat
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_read); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_read);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_read, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":112
+ * cdef os_pipe = os.pipe
+ * cdef os_read = os.read
+ * cdef os_remove = os.remove             # <<<<<<<<<<<<<<
+ * cdef os_stat = os.stat
+ * cdef os_fspath = os.fspath
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_os); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_remove); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_remove);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_remove, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":113
+ * cdef os_read = os.read
+ * cdef os_remove = os.remove
+ * cdef os_stat = os.stat             # <<<<<<<<<<<<<<
+ * cdef os_fspath = os.fspath
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_stat); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_stat);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_stat, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":114
+ * cdef os_remove = os.remove
+ * cdef os_stat = os.stat
+ * cdef os_fspath = os.fspath             # <<<<<<<<<<<<<<
+ * 
+ * cdef stat_S_ISSOCK = stat.S_ISSOCK
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_os); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_fspath); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_os_fspath);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_os_fspath, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":116
+ * cdef os_fspath = os.fspath
+ * 
+ * cdef stat_S_ISSOCK = stat.S_ISSOCK             # <<<<<<<<<<<<<<
+ * 
+ * cdef sys_ignore_environment = sys.flags.ignore_environment
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_stat); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_S_ISSOCK); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_stat_S_ISSOCK);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_stat_S_ISSOCK, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":118
+ * cdef stat_S_ISSOCK = stat.S_ISSOCK
+ * 
+ * cdef sys_ignore_environment = sys.flags.ignore_environment             # <<<<<<<<<<<<<<
+ * cdef sys_exc_info = sys.exc_info
+ * cdef sys_set_coroutine_wrapper = getattr(sys, 'set_coroutine_wrapper', None)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ignore_environment); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_sys_ignore_environment);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_sys_ignore_environment, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":119
+ * 
+ * cdef sys_ignore_environment = sys.flags.ignore_environment
+ * cdef sys_exc_info = sys.exc_info             # <<<<<<<<<<<<<<
+ * cdef sys_set_coroutine_wrapper = getattr(sys, 'set_coroutine_wrapper', None)
+ * cdef sys_get_coroutine_wrapper = getattr(sys, 'get_coroutine_wrapper', None)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_sys_exc_info);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_sys_exc_info, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":120
+ * cdef sys_ignore_environment = sys.flags.ignore_environment
+ * cdef sys_exc_info = sys.exc_info
+ * cdef sys_set_coroutine_wrapper = getattr(sys, 'set_coroutine_wrapper', None)             # <<<<<<<<<<<<<<
+ * cdef sys_get_coroutine_wrapper = getattr(sys, 'get_coroutine_wrapper', None)
+ * cdef sys_getframe = sys._getframe
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetAttr3(__pyx_t_2, __pyx_n_u_set_coroutine_wrapper, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_sys_set_coroutine_wrapper);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_sys_set_coroutine_wrapper, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":121
+ * cdef sys_exc_info = sys.exc_info
+ * cdef sys_set_coroutine_wrapper = getattr(sys, 'set_coroutine_wrapper', None)
+ * cdef sys_get_coroutine_wrapper = getattr(sys, 'get_coroutine_wrapper', None)             # <<<<<<<<<<<<<<
+ * cdef sys_getframe = sys._getframe
+ * cdef sys_version_info = sys.version_info
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr3(__pyx_t_1, __pyx_n_u_get_coroutine_wrapper, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_sys_get_coroutine_wrapper);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_sys_get_coroutine_wrapper, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":122
+ * cdef sys_set_coroutine_wrapper = getattr(sys, 'set_coroutine_wrapper', None)
+ * cdef sys_get_coroutine_wrapper = getattr(sys, 'get_coroutine_wrapper', None)
+ * cdef sys_getframe = sys._getframe             # <<<<<<<<<<<<<<
+ * cdef sys_version_info = sys.version_info
+ * cdef sys_getfilesystemencoding = sys.getfilesystemencoding
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_getframe); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_sys_getframe);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_sys_getframe, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":123
+ * cdef sys_get_coroutine_wrapper = getattr(sys, 'get_coroutine_wrapper', None)
+ * cdef sys_getframe = sys._getframe
+ * cdef sys_version_info = sys.version_info             # <<<<<<<<<<<<<<
+ * cdef sys_getfilesystemencoding = sys.getfilesystemencoding
+ * cdef str sys_platform = sys.platform
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_version_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_sys_version_info);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_sys_version_info, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":124
+ * cdef sys_getframe = sys._getframe
+ * cdef sys_version_info = sys.version_info
+ * cdef sys_getfilesystemencoding = sys.getfilesystemencoding             # <<<<<<<<<<<<<<
+ * cdef str sys_platform = sys.platform
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_getfilesystemencoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_sys_getfilesystemencoding);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_sys_getfilesystemencoding, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":125
+ * cdef sys_version_info = sys.version_info
+ * cdef sys_getfilesystemencoding = sys.getfilesystemencoding
+ * cdef str sys_platform = sys.platform             # <<<<<<<<<<<<<<
+ * 
+ * cdef ssl_SSLContext = ssl.SSLContext
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_platform); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(PyUnicode_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(29, 125, __pyx_L1_error)
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_sys_platform);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_sys_platform, ((PyObject*)__pyx_t_2));
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":127
+ * cdef str sys_platform = sys.platform
+ * 
+ * cdef ssl_SSLContext = ssl.SSLContext             # <<<<<<<<<<<<<<
+ * cdef ssl_MemoryBIO = ssl.MemoryBIO
+ * cdef ssl_create_default_context = ssl.create_default_context
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ssl); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SSLContext); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_ssl_SSLContext);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_ssl_SSLContext, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":128
+ * 
+ * cdef ssl_SSLContext = ssl.SSLContext
+ * cdef ssl_MemoryBIO = ssl.MemoryBIO             # <<<<<<<<<<<<<<
+ * cdef ssl_create_default_context = ssl.create_default_context
+ * cdef ssl_SSLError = ssl.SSLError
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ssl); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_MemoryBIO); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_ssl_MemoryBIO);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_ssl_MemoryBIO, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":129
+ * cdef ssl_SSLContext = ssl.SSLContext
+ * cdef ssl_MemoryBIO = ssl.MemoryBIO
+ * cdef ssl_create_default_context = ssl.create_default_context             # <<<<<<<<<<<<<<
+ * cdef ssl_SSLError = ssl.SSLError
+ * cdef ssl_SSLAgainErrors = (ssl.SSLWantReadError, ssl.SSLSyscallError)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ssl); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_create_default_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_ssl_create_default_context);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_ssl_create_default_context, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":130
+ * cdef ssl_MemoryBIO = ssl.MemoryBIO
+ * cdef ssl_create_default_context = ssl.create_default_context
+ * cdef ssl_SSLError = ssl.SSLError             # <<<<<<<<<<<<<<
+ * cdef ssl_SSLAgainErrors = (ssl.SSLWantReadError, ssl.SSLSyscallError)
+ * cdef ssl_SSLZeroReturnError = ssl.SSLZeroReturnError
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ssl); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_SSLError); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_ssl_SSLError);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_ssl_SSLError, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":131
+ * cdef ssl_create_default_context = ssl.create_default_context
+ * cdef ssl_SSLError = ssl.SSLError
+ * cdef ssl_SSLAgainErrors = (ssl.SSLWantReadError, ssl.SSLSyscallError)             # <<<<<<<<<<<<<<
+ * cdef ssl_SSLZeroReturnError = ssl.SSLZeroReturnError
+ * cdef ssl_CertificateError = ssl.CertificateError
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ssl); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SSLWantReadError); if (unlikely(!__pyx_t_1)) __PYX_ERR(29, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ssl); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SSLSyscallError); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_5);
+  __pyx_t_1 = 0;
+  __pyx_t_5 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_ssl_SSLAgainErrors);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_ssl_SSLAgainErrors, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":132
+ * cdef ssl_SSLError = ssl.SSLError
+ * cdef ssl_SSLAgainErrors = (ssl.SSLWantReadError, ssl.SSLSyscallError)
+ * cdef ssl_SSLZeroReturnError = ssl.SSLZeroReturnError             # <<<<<<<<<<<<<<
+ * cdef ssl_CertificateError = ssl.CertificateError
+ * cdef int ssl_SSL_ERROR_WANT_READ = ssl.SSL_ERROR_WANT_READ
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ssl); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SSLZeroReturnError); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_ssl_SSLZeroReturnError);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_ssl_SSLZeroReturnError, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":133
+ * cdef ssl_SSLAgainErrors = (ssl.SSLWantReadError, ssl.SSLSyscallError)
+ * cdef ssl_SSLZeroReturnError = ssl.SSLZeroReturnError
+ * cdef ssl_CertificateError = ssl.CertificateError             # <<<<<<<<<<<<<<
+ * cdef int ssl_SSL_ERROR_WANT_READ = ssl.SSL_ERROR_WANT_READ
+ * cdef int ssl_SSL_ERROR_WANT_WRITE = ssl.SSL_ERROR_WANT_WRITE
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_ssl); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_CertificateError); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_ssl_CertificateError);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_ssl_CertificateError, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":134
+ * cdef ssl_SSLZeroReturnError = ssl.SSLZeroReturnError
+ * cdef ssl_CertificateError = ssl.CertificateError
+ * cdef int ssl_SSL_ERROR_WANT_READ = ssl.SSL_ERROR_WANT_READ             # <<<<<<<<<<<<<<
+ * cdef int ssl_SSL_ERROR_WANT_WRITE = ssl.SSL_ERROR_WANT_WRITE
+ * cdef int ssl_SSL_ERROR_SYSCALL = ssl.SSL_ERROR_SYSCALL
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ssl); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SSL_ERROR_WANT_READ); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 134, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_6uvloop_4loop_ssl_SSL_ERROR_WANT_READ = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":135
+ * cdef ssl_CertificateError = ssl.CertificateError
+ * cdef int ssl_SSL_ERROR_WANT_READ = ssl.SSL_ERROR_WANT_READ
+ * cdef int ssl_SSL_ERROR_WANT_WRITE = ssl.SSL_ERROR_WANT_WRITE             # <<<<<<<<<<<<<<
+ * cdef int ssl_SSL_ERROR_SYSCALL = ssl.SSL_ERROR_SYSCALL
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_ssl); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_SSL_ERROR_WANT_WRITE); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 135, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_ssl_SSL_ERROR_WANT_WRITE = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":136
+ * cdef int ssl_SSL_ERROR_WANT_READ = ssl.SSL_ERROR_WANT_READ
+ * cdef int ssl_SSL_ERROR_WANT_WRITE = ssl.SSL_ERROR_WANT_WRITE
+ * cdef int ssl_SSL_ERROR_SYSCALL = ssl.SSL_ERROR_SYSCALL             # <<<<<<<<<<<<<<
+ * 
+ * cdef uint64_t MAIN_THREAD_ID = <uint64_t><int64_t>threading.main_thread().ident
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ssl); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SSL_ERROR_SYSCALL); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 136, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_6uvloop_4loop_ssl_SSL_ERROR_SYSCALL = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":138
+ * cdef int ssl_SSL_ERROR_SYSCALL = ssl.SSL_ERROR_SYSCALL
+ * 
+ * cdef uint64_t MAIN_THREAD_ID = <uint64_t><int64_t>threading.main_thread().ident             # <<<<<<<<<<<<<<
+ * cdef threading_Thread = threading.Thread
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_threading); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_main_thread); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_ident); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_6 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_6 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(29, 138, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_MAIN_THREAD_ID = ((uint64_t)((int64_t)__pyx_t_6));
+
+  /* "uvloop/includes/stdlib.pxi":139
+ * 
+ * cdef uint64_t MAIN_THREAD_ID = <uint64_t><int64_t>threading.main_thread().ident
+ * cdef threading_Thread = threading.Thread             # <<<<<<<<<<<<<<
+ * 
+ * cdef int subprocess_PIPE = subprocess.PIPE
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_threading); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Thread); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_threading_Thread);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_threading_Thread, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":141
+ * cdef threading_Thread = threading.Thread
+ * 
+ * cdef int subprocess_PIPE = subprocess.PIPE             # <<<<<<<<<<<<<<
+ * cdef int subprocess_STDOUT = subprocess.STDOUT
+ * cdef int subprocess_DEVNULL = subprocess.DEVNULL
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_subprocess); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_PIPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 141, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_subprocess_PIPE = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":142
+ * 
+ * cdef int subprocess_PIPE = subprocess.PIPE
+ * cdef int subprocess_STDOUT = subprocess.STDOUT             # <<<<<<<<<<<<<<
+ * cdef int subprocess_DEVNULL = subprocess.DEVNULL
+ * cdef subprocess_SubprocessError = subprocess.SubprocessError
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_subprocess); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_STDOUT); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 142, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_6uvloop_4loop_subprocess_STDOUT = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":143
+ * cdef int subprocess_PIPE = subprocess.PIPE
+ * cdef int subprocess_STDOUT = subprocess.STDOUT
+ * cdef int subprocess_DEVNULL = subprocess.DEVNULL             # <<<<<<<<<<<<<<
+ * cdef subprocess_SubprocessError = subprocess.SubprocessError
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_subprocess); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_DEVNULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 143, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_subprocess_DEVNULL = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":144
+ * cdef int subprocess_STDOUT = subprocess.STDOUT
+ * cdef int subprocess_DEVNULL = subprocess.DEVNULL
+ * cdef subprocess_SubprocessError = subprocess.SubprocessError             # <<<<<<<<<<<<<<
+ * 
+ * cdef int signal_NSIG = signal.NSIG
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_subprocess); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SubprocessError); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_subprocess_SubprocessError);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_subprocess_SubprocessError, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":146
+ * cdef subprocess_SubprocessError = subprocess.SubprocessError
+ * 
+ * cdef int signal_NSIG = signal.NSIG             # <<<<<<<<<<<<<<
+ * cdef signal_signal = signal.signal
+ * cdef signal_siginterrupt = signal.siginterrupt
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_signal); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_NSIG); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(29, 146, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_6uvloop_4loop_signal_NSIG = __pyx_t_4;
+
+  /* "uvloop/includes/stdlib.pxi":147
+ * 
+ * cdef int signal_NSIG = signal.NSIG
+ * cdef signal_signal = signal.signal             # <<<<<<<<<<<<<<
+ * cdef signal_siginterrupt = signal.siginterrupt
+ * cdef signal_set_wakeup_fd = signal.set_wakeup_fd
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_signal); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_signal); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_signal_signal);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_signal_signal, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":148
+ * cdef int signal_NSIG = signal.NSIG
+ * cdef signal_signal = signal.signal
+ * cdef signal_siginterrupt = signal.siginterrupt             # <<<<<<<<<<<<<<
+ * cdef signal_set_wakeup_fd = signal.set_wakeup_fd
+ * cdef signal_default_int_handler = signal.default_int_handler
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_signal); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_siginterrupt); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_signal_siginterrupt);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_signal_siginterrupt, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":149
+ * cdef signal_signal = signal.signal
+ * cdef signal_siginterrupt = signal.siginterrupt
+ * cdef signal_set_wakeup_fd = signal.set_wakeup_fd             # <<<<<<<<<<<<<<
+ * cdef signal_default_int_handler = signal.default_int_handler
+ * cdef signal_SIG_DFL = signal.SIG_DFL
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_signal); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_set_wakeup_fd); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_signal_set_wakeup_fd);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_signal_set_wakeup_fd, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":150
+ * cdef signal_siginterrupt = signal.siginterrupt
+ * cdef signal_set_wakeup_fd = signal.set_wakeup_fd
+ * cdef signal_default_int_handler = signal.default_int_handler             # <<<<<<<<<<<<<<
+ * cdef signal_SIG_DFL = signal.SIG_DFL
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_signal); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_default_int_handler); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_signal_default_int_handler);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_signal_default_int_handler, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":151
+ * cdef signal_set_wakeup_fd = signal.set_wakeup_fd
+ * cdef signal_default_int_handler = signal.default_int_handler
+ * cdef signal_SIG_DFL = signal.SIG_DFL             # <<<<<<<<<<<<<<
+ * 
+ * cdef time_sleep = time.sleep
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_signal); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SIG_DFL); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_signal_SIG_DFL);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_signal_SIG_DFL, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":153
+ * cdef signal_SIG_DFL = signal.SIG_DFL
+ * 
+ * cdef time_sleep = time.sleep             # <<<<<<<<<<<<<<
+ * cdef time_monotonic = time.monotonic
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_sleep); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_time_sleep);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_time_sleep, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":154
+ * 
+ * cdef time_sleep = time.sleep
+ * cdef time_monotonic = time.monotonic             # <<<<<<<<<<<<<<
+ * 
+ * cdef tb_StackSummary = traceback.StackSummary
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_monotonic); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_time_monotonic);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_time_monotonic, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":156
+ * cdef time_monotonic = time.monotonic
+ * 
+ * cdef tb_StackSummary = traceback.StackSummary             # <<<<<<<<<<<<<<
+ * cdef tb_walk_stack = traceback.walk_stack
+ * cdef tb_format_list = traceback.format_list
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_traceback_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_StackSummary); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_tb_StackSummary);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_tb_StackSummary, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":157
+ * 
+ * cdef tb_StackSummary = traceback.StackSummary
+ * cdef tb_walk_stack = traceback.walk_stack             # <<<<<<<<<<<<<<
+ * cdef tb_format_list = traceback.format_list
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_traceback_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 157, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_walk_stack); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 157, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_tb_walk_stack);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_tb_walk_stack, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":158
+ * cdef tb_StackSummary = traceback.StackSummary
+ * cdef tb_walk_stack = traceback.walk_stack
+ * cdef tb_format_list = traceback.format_list             # <<<<<<<<<<<<<<
+ * 
+ * cdef warnings_warn = warnings.warn
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_traceback_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_format_list); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_tb_format_list);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_tb_format_list, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":160
+ * cdef tb_format_list = traceback.format_list
+ * 
+ * cdef warnings_warn = warnings.warn             # <<<<<<<<<<<<<<
+ * 
+ * cdef weakref_WeakValueDictionary = weakref.WeakValueDictionary
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_warnings); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_warn); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_warnings_warn);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_warnings_warn, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":162
+ * cdef warnings_warn = warnings.warn
+ * 
+ * cdef weakref_WeakValueDictionary = weakref.WeakValueDictionary             # <<<<<<<<<<<<<<
+ * cdef weakref_WeakSet = weakref.WeakSet
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_weakref); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 162, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_WeakValueDictionary); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 162, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_weakref_WeakValueDictionary);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_weakref_WeakValueDictionary, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":163
+ * 
+ * cdef weakref_WeakValueDictionary = weakref.WeakValueDictionary
+ * cdef weakref_WeakSet = weakref.WeakSet             # <<<<<<<<<<<<<<
+ * 
+ * cdef py_inf = float('inf')
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(29, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_WeakSet); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_weakref_WeakSet);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_weakref_WeakSet, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":165
+ * cdef weakref_WeakSet = weakref.WeakSet
+ * 
+ * cdef py_inf = float('inf')             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_5 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_5)) __PYX_ERR(29, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop_py_inf);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_py_inf, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/includes/stdlib.pxi":170
+ * # Cython doesn't clean-up imported objects properly in Py3 mode,
+ * # so we delete refs to all modules manually (except sys)
+ * del asyncio, concurrent, collections, errno             # <<<<<<<<<<<<<<
+ * del functools, inspect, itertools, socket, os, threading
+ * del signal, subprocess, ssl
+ */
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_asyncio) < 0) __PYX_ERR(29, 170, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_concurrent) < 0) __PYX_ERR(29, 170, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_collections) < 0) __PYX_ERR(29, 170, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_errno) < 0) __PYX_ERR(29, 170, __pyx_L1_error)
+
+  /* "uvloop/includes/stdlib.pxi":171
+ * # so we delete refs to all modules manually (except sys)
+ * del asyncio, concurrent, collections, errno
+ * del functools, inspect, itertools, socket, os, threading             # <<<<<<<<<<<<<<
+ * del signal, subprocess, ssl
+ * del time, traceback, warnings, weakref
+ */
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_functools) < 0) __PYX_ERR(29, 171, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_inspect) < 0) __PYX_ERR(29, 171, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_itertools) < 0) __PYX_ERR(29, 171, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_socket_2) < 0) __PYX_ERR(29, 171, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_os) < 0) __PYX_ERR(29, 171, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_threading) < 0) __PYX_ERR(29, 171, __pyx_L1_error)
+
+  /* "uvloop/includes/stdlib.pxi":172
+ * del asyncio, concurrent, collections, errno
+ * del functools, inspect, itertools, socket, os, threading
+ * del signal, subprocess, ssl             # <<<<<<<<<<<<<<
+ * del time, traceback, warnings, weakref
+ */
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_signal) < 0) __PYX_ERR(29, 172, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_subprocess) < 0) __PYX_ERR(29, 172, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_ssl) < 0) __PYX_ERR(29, 172, __pyx_L1_error)
+
+  /* "uvloop/includes/stdlib.pxi":173
+ * del functools, inspect, itertools, socket, os, threading
+ * del signal, subprocess, ssl
+ * del time, traceback, warnings, weakref             # <<<<<<<<<<<<<<
+ */
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_time) < 0) __PYX_ERR(29, 173, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_traceback_2) < 0) __PYX_ERR(29, 173, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_warnings) < 0) __PYX_ERR(29, 173, __pyx_L1_error)
+  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_weakref) < 0) __PYX_ERR(29, 173, __pyx_L1_error)
+
+  /* "uvloop/loop.pyx":51
+ * 
+ * cdef:
+ *     int PY39 = PY_VERSION_HEX >= 0x03090000             # <<<<<<<<<<<<<<
+ *     uint64_t MAX_SLEEP = 3600 * 24 * 365 * 100
+ * 
+ */
+  __pyx_v_6uvloop_4loop_PY39 = (PY_VERSION_HEX >= 0x03090000);
+
+  /* "uvloop/loop.pyx":52
+ * cdef:
+ *     int PY39 = PY_VERSION_HEX >= 0x03090000
+ *     uint64_t MAX_SLEEP = 3600 * 24 * 365 * 100             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_6uvloop_4loop_MAX_SLEEP = 0xBBF81E00;
+
+  /* "uvloop/loop.pyx":122
+ * # Used for deprecation and removal of `loop.create_datagram_endpoint()`'s
+ * # *reuse_address* parameter
+ * _unset = object()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_builtin_object); 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_unset, __pyx_t_5) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":1631
+ *     async def create_server(self, protocol_factory, host=None, port=None,
+ *                             *,
+ *                             int family=uv.AF_UNSPEC,             # <<<<<<<<<<<<<<
+ *                             int flags=uv.AI_PASSIVE,
+ *                             sock=None,
+ */
+  __pyx_k__48 = AF_UNSPEC;
+
+  /* "uvloop/loop.pyx":1632
+ *                             *,
+ *                             int family=uv.AF_UNSPEC,
+ *                             int flags=uv.AI_PASSIVE,             # <<<<<<<<<<<<<<
+ *                             sock=None,
+ *                             backlog=100,
+ */
+  __pyx_k__49 = AI_PASSIVE;
+
+  /* "uvloop/loop.pyx":2709
+ *     @cython.iterable_coroutine
+ *     async def __subprocess_run(self, protocol_factory, args,
+ *                                stdin=subprocess_PIPE,             # <<<<<<<<<<<<<<
+ *                                stdout=subprocess_PIPE,
+ *                                stderr=subprocess_PIPE,
+ */
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_PIPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2709, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_k__76 = __pyx_t_5;
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":2710
+ *     async def __subprocess_run(self, protocol_factory, args,
+ *                                stdin=subprocess_PIPE,
+ *                                stdout=subprocess_PIPE,             # <<<<<<<<<<<<<<
+ *                                stderr=subprocess_PIPE,
+ *                                universal_newlines=False,
+ */
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_PIPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2710, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_k__77 = __pyx_t_5;
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":2711
+ *                                stdin=subprocess_PIPE,
+ *                                stdout=subprocess_PIPE,
+ *                                stderr=subprocess_PIPE,             # <<<<<<<<<<<<<<
+ *                                universal_newlines=False,
+ *                                shell=True,
+ */
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_subprocess_PIPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2711, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_k__78 = __pyx_t_5;
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":2958
+ *                                        local_addr=None, remote_addr=None, *,
+ *                                        family=0, proto=0, flags=0,
+ *                                        reuse_address=_unset, reuse_port=None,             # <<<<<<<<<<<<<<
+ *                                        allow_broadcast=None, sock=None):
+ *         """A coroutine which creates a datagram endpoint.
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_unset); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2958, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_k__90 = __pyx_t_5;
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":3205
+ * 
+ * 
+ * class _SyncSocketReaderFuture(aio_Future):             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self, sock, loop):
+ */
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_Future);
+  __Pyx_GIVEREF(__pyx_v_6uvloop_4loop_aio_Future);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_6uvloop_4loop_aio_Future);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_5, __pyx_n_s_SyncSocketReaderFuture, __pyx_n_s_SyncSocketReaderFuture, (PyObject *) NULL, __pyx_n_s_uvloop_loop, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+
+  /* "uvloop/loop.pyx":3207
+ * class _SyncSocketReaderFuture(aio_Future):
+ * 
+ *     def __init__(self, sock, loop):             # <<<<<<<<<<<<<<
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock
+ */
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_23_SyncSocketReaderFuture_1__init__, 0, __pyx_n_s_SyncSocketReaderFuture___init, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__234)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_init, __pyx_t_7) < 0) __PYX_ERR(0, 3207, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":3212
+ *         self.__loop = loop
+ * 
+ *     def __remove_reader(self):             # <<<<<<<<<<<<<<
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_reader(self.__sock)
+ */
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_23_SyncSocketReaderFuture_3__remove_reader, 0, __pyx_n_s_SyncSocketReaderFuture___remove, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__236)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3212, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SyncSocketReaderFuture__remove, __pyx_t_7) < 0) __PYX_ERR(0, 3212, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":3217
+ *             self.__sock = None
+ * 
+ *     if PY39:             # <<<<<<<<<<<<<<
+ *         def cancel(self, msg=None):
+ *             self.__remove_reader()
+ */
+  __pyx_t_3 = (__pyx_v_6uvloop_4loop_PY39 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":3218
+ * 
+ *     if PY39:
+ *         def cancel(self, msg=None):             # <<<<<<<<<<<<<<
+ *             self.__remove_reader()
+ *             aio_Future.cancel(self, msg=msg)
+ */
+    __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_23_SyncSocketReaderFuture_5cancel, 0, __pyx_n_s_SyncSocketReaderFuture_cancel, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__238)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3218, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_tuple__239);
+    if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_cancel, __pyx_t_7) < 0) __PYX_ERR(0, 3218, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":3217
+ *             self.__sock = None
+ * 
+ *     if PY39:             # <<<<<<<<<<<<<<
+ *         def cancel(self, msg=None):
+ *             self.__remove_reader()
+ */
+    goto __pyx_L2;
+  }
+
+  /* "uvloop/loop.pyx":3223
+ * 
+ *     else:
+ *         def cancel(self):             # <<<<<<<<<<<<<<
+ *             self.__remove_reader()
+ *             aio_Future.cancel(self)
+ */
+  /*else*/ {
+    __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_23_SyncSocketReaderFuture_7cancel, 0, __pyx_n_s_SyncSocketReaderFuture_cancel, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__241)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3223, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_cancel, __pyx_t_7) < 0) __PYX_ERR(0, 3223, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_L2:;
+
+  /* "uvloop/loop.pyx":3205
+ * 
+ * 
+ * class _SyncSocketReaderFuture(aio_Future):             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self, sock, loop):
+ */
+  __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SyncSocketReaderFuture, __pyx_t_5, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SyncSocketReaderFuture, __pyx_t_7) < 0) __PYX_ERR(0, 3205, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 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;
+
+  /* "uvloop/loop.pyx":3228
+ * 
+ * 
+ * class _SyncSocketWriterFuture(aio_Future):             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self, sock, loop):
+ */
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_Future);
+  __Pyx_GIVEREF(__pyx_v_6uvloop_4loop_aio_Future);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_6uvloop_4loop_aio_Future);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_5, __pyx_n_s_SyncSocketWriterFuture, __pyx_n_s_SyncSocketWriterFuture, (PyObject *) NULL, __pyx_n_s_uvloop_loop, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+
+  /* "uvloop/loop.pyx":3230
+ * class _SyncSocketWriterFuture(aio_Future):
+ * 
+ *     def __init__(self, sock, loop):             # <<<<<<<<<<<<<<
+ *         aio_Future.__init__(self, loop=loop)
+ *         self.__sock = sock
+ */
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_23_SyncSocketWriterFuture_1__init__, 0, __pyx_n_s_SyncSocketWriterFuture___init, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__243)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_init, __pyx_t_7) < 0) __PYX_ERR(0, 3230, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":3235
+ *         self.__loop = loop
+ * 
+ *     def __remove_writer(self):             # <<<<<<<<<<<<<<
+ *         if self.__sock is not None and self.__sock.fileno() != -1:
+ *             self.__loop.remove_writer(self.__sock)
+ */
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_23_SyncSocketWriterFuture_3__remove_writer, 0, __pyx_n_s_SyncSocketWriterFuture___remove, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__245)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SyncSocketWriterFuture__remove, __pyx_t_7) < 0) __PYX_ERR(0, 3235, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/loop.pyx":3240
+ *             self.__sock = None
+ * 
+ *     if PY39:             # <<<<<<<<<<<<<<
+ *         def cancel(self, msg=None):
+ *             self.__remove_writer()
+ */
+  __pyx_t_3 = (__pyx_v_6uvloop_4loop_PY39 != 0);
+  if (__pyx_t_3) {
+
+    /* "uvloop/loop.pyx":3241
+ * 
+ *     if PY39:
+ *         def cancel(self, msg=None):             # <<<<<<<<<<<<<<
+ *             self.__remove_writer()
+ *             aio_Future.cancel(self, msg=msg)
+ */
+    __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_23_SyncSocketWriterFuture_5cancel, 0, __pyx_n_s_SyncSocketWriterFuture_cancel, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__247)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3241, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_tuple__248);
+    if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_cancel, __pyx_t_7) < 0) __PYX_ERR(0, 3241, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "uvloop/loop.pyx":3240
+ *             self.__sock = None
+ * 
+ *     if PY39:             # <<<<<<<<<<<<<<
+ *         def cancel(self, msg=None):
+ *             self.__remove_writer()
+ */
+    goto __pyx_L3;
+  }
+
+  /* "uvloop/loop.pyx":3246
+ * 
+ *     else:
+ *         def cancel(self):             # <<<<<<<<<<<<<<
+ *             self.__remove_writer()
+ *             aio_Future.cancel(self)
+ */
+  /*else*/ {
+    __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_23_SyncSocketWriterFuture_7cancel, 0, __pyx_n_s_SyncSocketWriterFuture_cancel, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__250)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3246, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_cancel, __pyx_t_7) < 0) __PYX_ERR(0, 3246, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_L3:;
+
+  /* "uvloop/loop.pyx":3228
+ * 
+ * 
+ * class _SyncSocketWriterFuture(aio_Future):             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self, sock, loop):
+ */
+  __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SyncSocketWriterFuture, __pyx_t_5, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SyncSocketWriterFuture, __pyx_t_7) < 0) __PYX_ERR(0, 3228, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 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;
+
+  /* "uvloop/lru.pyx":1
+ * cdef object _LRU_MARKER = object()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_builtin_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_XGOTREF(__pyx_v_6uvloop_4loop__LRU_MARKER);
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop__LRU_MARKER, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/handles/process.pyx":692
+ * 
+ * 
+ * class WriteSubprocessPipeProto(aio_BaseProtocol):             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self, proc, fd):
+ */
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 692, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_BaseProtocol);
+  __Pyx_GIVEREF(__pyx_v_6uvloop_4loop_aio_BaseProtocol);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_6uvloop_4loop_aio_BaseProtocol);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 692, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_5, __pyx_n_s_WriteSubprocessPipeProto, __pyx_n_s_WriteSubprocessPipeProto, (PyObject *) NULL, __pyx_n_s_uvloop_loop, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 692, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+
+  /* "uvloop/handles/process.pyx":694
+ * class WriteSubprocessPipeProto(aio_BaseProtocol):
+ * 
+ *     def __init__(self, proc, fd):             # <<<<<<<<<<<<<<
+ *         if UVLOOP_DEBUG:
+ *             if type(proc) is not UVProcessTransport:
+ */
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_1__init__, 0, __pyx_n_s_WriteSubprocessPipeProto___init, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__252)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 694, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_init, __pyx_t_7) < 0) __PYX_ERR(4, 694, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/handles/process.pyx":705
+ *         self.disconnected = False
+ * 
+ *     def connection_made(self, transport):             # <<<<<<<<<<<<<<
+ *         self.pipe = transport
+ * 
+ */
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_3connection_made, 0, __pyx_n_s_WriteSubprocessPipeProto_connect, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__254)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 705, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_connection_made, __pyx_t_7) < 0) __PYX_ERR(4, 705, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/handles/process.pyx":708
+ *         self.pipe = transport
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return ('<%s fd=%s pipe=%r>'
+ *                 % (self.__class__.__name__, self.fd, self.pipe))
+ */
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_5__repr__, 0, __pyx_n_s_WriteSubprocessPipeProto___repr, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__256)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 708, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_repr, __pyx_t_7) < 0) __PYX_ERR(4, 708, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/handles/process.pyx":712
+ *                 % (self.__class__.__name__, self.fd, self.pipe))
+ * 
+ *     def connection_lost(self, exc):             # <<<<<<<<<<<<<<
+ *         self.disconnected = True
+ *         (<UVProcessTransport>self.proc)._pipe_connection_lost(self.fd, exc)
+ */
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_7connection_lost, 0, __pyx_n_s_WriteSubprocessPipeProto_connect_2, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__258)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 712, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_connection_lost, __pyx_t_7) < 0) __PYX_ERR(4, 712, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/handles/process.pyx":717
+ *         self.proc = None
+ * 
+ *     def pause_writing(self):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._protocol.pause_writing()
+ * 
+ */
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_9pause_writing, 0, __pyx_n_s_WriteSubprocessPipeProto_pause_w, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__260)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 717, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_pause_writing, __pyx_t_7) < 0) __PYX_ERR(4, 717, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/handles/process.pyx":720
+ *         (<UVProcessTransport>self.proc)._protocol.pause_writing()
+ * 
+ *     def resume_writing(self):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._protocol.resume_writing()
+ * 
+ */
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_24WriteSubprocessPipeProto_11resume_writing, 0, __pyx_n_s_WriteSubprocessPipeProto_resume, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__262)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 720, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_resume_writing, __pyx_t_7) < 0) __PYX_ERR(4, 720, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/handles/process.pyx":692
+ * 
+ * 
+ * class WriteSubprocessPipeProto(aio_BaseProtocol):             # <<<<<<<<<<<<<<
+ * 
+ *     def __init__(self, proc, fd):
+ */
+  __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_WriteSubprocessPipeProto, __pyx_t_5, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 692, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_WriteSubprocessPipeProto, __pyx_t_7) < 0) __PYX_ERR(4, 692, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 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;
+
+  /* "uvloop/handles/process.pyx":724
+ * 
+ * 
+ * class ReadSubprocessPipeProto(WriteSubprocessPipeProto,             # <<<<<<<<<<<<<<
+ *                               aio_Protocol):
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_WriteSubprocessPipeProto); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 724, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+
+  /* "uvloop/handles/process.pyx":725
+ * 
+ * class ReadSubprocessPipeProto(WriteSubprocessPipeProto,
+ *                               aio_Protocol):             # <<<<<<<<<<<<<<
+ * 
+ *     def data_received(self, data):
+ */
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 724, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
+  __Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_Protocol);
+  __Pyx_GIVEREF(__pyx_v_6uvloop_4loop_aio_Protocol);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_6uvloop_4loop_aio_Protocol);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/handles/process.pyx":724
+ * 
+ * 
+ * class ReadSubprocessPipeProto(WriteSubprocessPipeProto,             # <<<<<<<<<<<<<<
+ *                               aio_Protocol):
+ * 
+ */
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 724, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_2, __pyx_n_s_ReadSubprocessPipeProto, __pyx_n_s_ReadSubprocessPipeProto, (PyObject *) NULL, __pyx_n_s_uvloop_loop, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 724, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+
+  /* "uvloop/handles/process.pyx":727
+ *                               aio_Protocol):
+ * 
+ *     def data_received(self, data):             # <<<<<<<<<<<<<<
+ *         (<UVProcessTransport>self.proc)._pipe_data_received(self.fd, data)
+ * 
+ */
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_6uvloop_4loop_23ReadSubprocessPipeProto_1data_received, 0, __pyx_n_s_ReadSubprocessPipeProto_data_rec, NULL, __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__264)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 727, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_data_received, __pyx_t_7) < 0) __PYX_ERR(4, 727, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /* "uvloop/handles/process.pyx":724
+ * 
+ * 
+ * class ReadSubprocessPipeProto(WriteSubprocessPipeProto,             # <<<<<<<<<<<<<<
+ *                               aio_Protocol):
+ * 
+ */
+  __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_ReadSubprocessPipeProto, __pyx_t_2, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 724, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ReadSubprocessPipeProto, __pyx_t_7) < 0) __PYX_ERR(4, 724, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "uvloop/dns.pyx":79
+ * 
+ * 
+ * cdef LruCache sockaddrs = LruCache(maxsize=DNS_PYADDR_TO_SOCKADDR_CACHE_SIZE)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_maxsize, __pyx_int_2048) < 0) __PYX_ERR(5, 79, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_LruCache), __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XGOTREF(((PyObject *)__pyx_v_6uvloop_4loop_sockaddrs));
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop_sockaddrs, ((struct __pyx_obj_6uvloop_4loop_LruCache *)__pyx_t_5));
+  __Pyx_GIVEREF(__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "uvloop/server.pyx":1
+ * import asyncio             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_5 = __Pyx_patch_asyncio(__Pyx_Import(__pyx_n_s_asyncio, 0, 0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(24, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_asyncio, __pyx_t_5) < 0) __PYX_ERR(24, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":3278
+ * 
+ * # Used in UVProcess
+ * cdef vint __atfork_installed = 0             # <<<<<<<<<<<<<<
+ * cdef vint __forking = 0
+ * cdef Loop __forking_loop = None
+ */
+  __pyx_v_6uvloop_4loop___atfork_installed = 0;
+
+  /* "uvloop/loop.pyx":3279
+ * # Used in UVProcess
+ * cdef vint __atfork_installed = 0
+ * cdef vint __forking = 0             # <<<<<<<<<<<<<<
+ * cdef Loop __forking_loop = None
+ * 
+ */
+  __pyx_v_6uvloop_4loop___forking = 0;
+
+  /* "uvloop/loop.pyx":3280
+ * cdef vint __atfork_installed = 0
+ * cdef vint __forking = 0
+ * cdef Loop __forking_loop = None             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_XGOTREF(((PyObject *)__pyx_v_6uvloop_4loop___forking_loop));
+  __Pyx_DECREF_SET(__pyx_v_6uvloop_4loop___forking_loop, ((struct __pyx_obj_6uvloop_4loop_Loop *)Py_None));
+  __Pyx_GIVEREF(Py_None);
+
+  /* "uvloop/loop.pyx":3307
+ * 
+ * # Install PyMem* memory allocators
+ * cdef vint __mem_installed = 0             # <<<<<<<<<<<<<<
+ * cdef __install_pymem():
+ *     global __mem_installed
+ */
+  __pyx_v_6uvloop_4loop___mem_installed = 0;
+
+  /* "uvloop/loop.pyx":3334
+ * 
+ * @cython.iterable_coroutine
+ * async def _test_coroutine_1():             # <<<<<<<<<<<<<<
+ *     return 42
+ */
+  __pyx_t_5 = PyCFunction_NewEx(&__pyx_mdef_6uvloop_4loop_1_test_coroutine_1, NULL, __pyx_n_s_uvloop_loop); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3334, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test_coroutine_1, __pyx_t_5) < 0) __PYX_ERR(0, 3334, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_PseudoSocket(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_5 = PyCFunction_NewEx(&__pyx_mdef_6uvloop_4loop_4__pyx_unpickle_PseudoSocket, NULL, __pyx_n_s_uvloop_loop); if (unlikely(!__pyx_t_5)) __PYX_ERR(7, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PseudoSocket, __pyx_t_5) < 0) __PYX_ERR(7, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_PseudoSocket__set_state(<PseudoSocket> __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PseudoSocket__set_state(PseudoSocket __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result._family = __pyx_state[0]; __pyx_result._fd = __pyx_state[1]; __pyx_result._peername = __pyx_state[2]; __pyx_result._proto = __pyx_state[3]; __pyx_result._sockname = __pyx_state[4]; __pyx_result._type = __pyx_state[5]
+ *     if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_5 = PyCFunction_NewEx(&__pyx_mdef_6uvloop_4loop_6__pyx_unpickle_LruCache, NULL, __pyx_n_s_uvloop_loop); if (unlikely(!__pyx_t_5)) __PYX_ERR(7, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_LruCache, __pyx_t_5) < 0) __PYX_ERR(7, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "uvloop/loop.pyx":1
+ * # cython: language_level=3, embedsignature=True             # <<<<<<<<<<<<<<
+ * 
+ * import asyncio
+ */
+  __pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_5) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "cfunc.to_py":64
+ * 
+ * @cname("__Pyx_CFunc_object____Loop____bint___to_py")
+ * cdef object __Pyx_CFunc_object____Loop____bint___to_py(object (*f)(Loop, bint) ):             # <<<<<<<<<<<<<<
+ *     def wrap(Loop self, bint enabled):
+ *         """wrap(self: 'Loop', enabled: bool)"""
+ */
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  if (__pyx_m) {
+    if (__pyx_d) {
+      __Pyx_AddTraceback("init uvloop.loop", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    Py_CLEAR(__pyx_m);
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init uvloop.loop");
+  }
+  __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
+}
+
+/* --- 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
+
+/* 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)) {
+        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;
+}
+
+/* decode_c_string */
+static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
+         const char* cstring, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
+    Py_ssize_t length;
+    if (unlikely((start < 0) | (stop < 0))) {
+        size_t slen = strlen(cstring);
+        if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "c-string too long to convert to Python");
+            return NULL;
+        }
+        length = (Py_ssize_t) slen;
+        if (start < 0) {
+            start += length;
+            if (start < 0)
+                start = 0;
+        }
+        if (stop < 0)
+            stop += length;
+    }
+    if (unlikely(stop <= start))
+        return __Pyx_NewRef(__pyx_empty_unicode);
+    length = stop - start;
+    cstring += start;
+    if (decode_func) {
+        return decode_func(cstring, length, errors);
+    } else {
+        return PyUnicode_Decode(cstring, length, encoding, errors);
+    }
+}
+
+/* PyDictVersioning */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
+    PyObject **dictptr = NULL;
+    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
+    if (offset) {
+#if CYTHON_COMPILING_IN_CPYTHON
+        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
+#else
+        dictptr = _PyObject_GetDictPtr(obj);
+#endif
+    }
+    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
+}
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
+        return 0;
+    return obj_dict_version == __Pyx_get_object_dict_version(obj);
+}
+#endif
+
+/* GetModuleGlobalName */
+#if CYTHON_USE_DICT_VERSIONS
+static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
+#else
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
+#endif
+{
+    PyObject *result;
+#if !CYTHON_AVOID_BORROWED_REFS
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
+    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)) {
+        return __Pyx_NewRef(result);
+    } else if (unlikely(PyErr_Occurred())) {
+        return NULL;
+    }
+#else
+    result = PyDict_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+#endif
+#else
+    result = PyObject_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+    PyErr_Clear();
+#endif
+    return __Pyx_GetBuiltinName(name);
+}
+
+/* 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;
+    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;
+}
+#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);
+    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_EnterRecursiveCall((char*)" while calling a Python object")) {
+        return NULL;
+    }
+    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
+#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);
+    }
+}
+#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");
+    }
+    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 = PyCFunction_GET_FUNCTION(func);
+    self = PyCFunction_GET_SELF(func);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    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
+
+/* 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
+
+/* 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);
+    }
+#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
+        }
+    }
+    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
+
+/* PyIntBinop */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AndObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) {
+    (void)inplace;
+    (void)zerodivision_check;
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long a = PyInt_AS_LONG(op1);
+            return PyInt_FromLong(a & b);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        const long b = intval;
+        long a, x;
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG llb = intval;
+        PY_LONG_LONG lla, llx;
+#endif
+        const digit* digits = ((PyLongObject*)op1)->ob_digit;
+        const Py_ssize_t size = Py_SIZE(op1);
+        if (likely(__Pyx_sst_abs(size) <= 1)) {
+            a = likely(size) ? digits[0] : 0;
+            if (size == -1) a = -a;
+        } else {
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                default: return PyLong_Type.tp_as_number->nb_and(op1, op2);
+            }
+        }
+                x = a & b;
+            return PyLong_FromLong(x);
+#ifdef HAVE_LONG_LONG
+        long_long:
+                llx = lla & llb;
+            return PyLong_FromLongLong(llx);
+#endif
+        
+        
+    }
+    #endif
+    return (inplace ? PyNumber_InPlaceAnd : PyNumber_And)(op1, op2);
+}
+#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;
+}
+
+/* PyIntBinop */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) {
+    (void)inplace;
+    (void)zerodivision_check;
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long x;
+        long a = PyInt_AS_LONG(op1);
+            x = (long)((unsigned long)a + b);
+            if (likely((x^a) >= 0 || (x^b) >= 0))
+                return PyInt_FromLong(x);
+            return PyLong_Type.tp_as_number->nb_add(op1, op2);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        const long b = intval;
+        long a, x;
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG llb = intval;
+        PY_LONG_LONG lla, llx;
+#endif
+        const digit* digits = ((PyLongObject*)op1)->ob_digit;
+        const Py_ssize_t size = Py_SIZE(op1);
+        if (likely(__Pyx_sst_abs(size) <= 1)) {
+            a = likely(size) ? digits[0] : 0;
+            if (size == -1) a = -a;
+        } else {
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
+            }
+        }
+                x = a + b;
+            return PyLong_FromLong(x);
+#ifdef HAVE_LONG_LONG
+        long_long:
+                llx = lla + llb;
+            return PyLong_FromLongLong(llx);
+#endif
+        
+        
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+        double a = PyFloat_AS_DOUBLE(op1);
+            double result;
+            PyFPE_START_PROTECT("add", return NULL)
+            result = ((double)a) + (double)b;
+            PyFPE_END_PROTECT(result)
+            return PyFloat_FromDouble(result);
+    }
+    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
+}
+#endif
+
+/* PyObjectSetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_setattro))
+        return tp->tp_setattro(obj, attr_name, value);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_setattr))
+        return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value);
+#endif
+    return PyObject_SetAttr(obj, attr_name, value);
+}
+#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
+
+/* 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, *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);
+#endif
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if 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;
+        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);
+#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
+    _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
+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) &&
+           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
+    _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 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;
+    #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
+
+/* 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);
+}
+
+/* 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 ((!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;
+}
+
+/* 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;
+        }
+    }
+    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 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
+        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);
+        }
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#endif
+
+/* ExtTypeTest */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+    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);
+    return 0;
+}
+
+/* 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);
+    }
+    #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);
+    }
+#ifdef WITH_THREAD
+    if (nogil)
+        PyGILState_Release(state);
+#endif
+}
+
+/* RaiseTooManyValuesToUnpack */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
+    PyErr_Format(PyExc_ValueError,
+                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
+}
+
+/* RaiseNeedMoreValuesToUnpack */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+    PyErr_Format(PyExc_ValueError,
+                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
+                 index, (index == 1) ? "" : "s");
+}
+
+/* IterFinish */
+static CYTHON_INLINE int __Pyx_IterFinish(void) {
+#if CYTHON_FAST_THREAD_STATE
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject* exc_type = tstate->curexc_type;
+    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 {
+            return -1;
+        }
+    }
+    return 0;
+#endif
+}
+
+/* UnpackItemEndCheck */
+static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
+    if (unlikely(retval)) {
+        Py_DECREF(retval);
+        __Pyx_RaiseTooManyValuesError(expected);
+        return -1;
+    } else {
+        return __Pyx_IterFinish();
+    }
+    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;
+    }
+#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
+
+/* 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 **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++;
+                }
+            }
+        } 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++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    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;
+}
+
+/* FastTypeChecks */
+#if CYTHON_COMPILING_IN_CPYTHON
+static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
+    while (a) {
+        a = a->tp_base;
+        if (a == b)
+            return 1;
+    }
+    return b == &PyBaseObject_Type;
+}
+static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (a == b) return 1;
+    mro = a->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(a, b);
+}
+#if PY_MAJOR_VERSION == 2
+static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
+    PyObject *exception, *value, *tb;
+    int res;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&exception, &value, &tb);
+    res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0;
+    if (unlikely(res == -1)) {
+        PyErr_WriteUnraisable(err);
+        res = 0;
+    }
+    if (!res) {
+        res = PyObject_IsSubclass(err, exc_type2);
+        if (unlikely(res == -1)) {
+            PyErr_WriteUnraisable(err);
+            res = 0;
+        }
+    }
+    __Pyx_ErrRestore(exception, value, tb);
+    return res;
+}
+#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);
+    }
+    return res;
+}
+#endif
+static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    assert(PyExceptionClass_Check(exc_type));
+    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++) {
+        PyObject *t = PyTuple_GET_ITEM(tuple, i);
+        #if PY_MAJOR_VERSION < 3
+        if (likely(exc_type == t)) return 1;
+        #endif
+        if (likely(PyExceptionClass_Check(t))) {
+            if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
+        } else {
+        }
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
+    if (likely(err == exc_type)) return 1;
+    if (likely(PyExceptionClass_Check(err))) {
+        if (likely(PyExceptionClass_Check(exc_type))) {
+            return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
+        } else if (likely(PyTuple_Check(exc_type))) {
+            return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
+        } else {
+        }
+    }
+    return PyErr_GivenExceptionMatches(err, exc_type);
+}
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
+    assert(PyExceptionClass_Check(exc_type1));
+    assert(PyExceptionClass_Check(exc_type2));
+    if (likely(err == exc_type1 || err == exc_type2)) return 1;
+    if (likely(PyExceptionClass_Check(err))) {
+        return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
+    }
+    return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
+}
+#endif
+
+/* pyfrozenset_new */
+static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it) {
+    if (it) {
+        PyObject* result;
+#if CYTHON_COMPILING_IN_PYPY
+        PyObject* args;
+        args = PyTuple_Pack(1, it);
+        if (unlikely(!args))
+            return NULL;
+        result = PyObject_Call((PyObject*)&PyFrozenSet_Type, args, NULL);
+        Py_DECREF(args);
+        return result;
+#else
+        if (PyFrozenSet_CheckExact(it)) {
+            Py_INCREF(it);
+            return it;
+        }
+        result = PyFrozenSet_New(it);
+        if (unlikely(!result))
+            return NULL;
+        if ((PY_VERSION_HEX >= 0x031000A1) || likely(PySet_GET_SIZE(result)))
+            return result;
+        Py_DECREF(result);
+#endif
+    }
+#if CYTHON_USE_TYPE_SLOTS
+    return PyFrozenSet_Type.tp_new(&PyFrozenSet_Type, __pyx_empty_tuple, NULL);
+#else
+    return PyObject_Call((PyObject*)&PyFrozenSet_Type, __pyx_empty_tuple, NULL);
+#endif
+}
+
+/* py_set_discard_unhashable */
+static int __Pyx_PySet_DiscardUnhashable(PyObject *set, PyObject *key) {
+    PyObject *tmpkey;
+    int rv;
+    if (likely(!PySet_Check(key) || !PyErr_ExceptionMatches(PyExc_TypeError)))
+        return -1;
+    PyErr_Clear();
+    tmpkey = __Pyx_PyFrozenSet_New(key);
+    if (tmpkey == NULL)
+        return -1;
+    rv = PySet_Discard(set, tmpkey);
+    Py_DECREF(tmpkey);
+    return rv;
+}
+
+/* py_set_discard */
+static CYTHON_INLINE int __Pyx_PySet_Discard(PyObject *set, PyObject *key) {
+    int found = PySet_Discard(set, key);
+    if (unlikely(found < 0)) {
+        found = __Pyx_PySet_DiscardUnhashable(set, key);
+    }
+    return found;
+}
+
+/* set_iter */
+static CYTHON_INLINE PyObject* __Pyx_set_iterator(PyObject* iterable, int is_set,
+                                                  Py_ssize_t* p_orig_length, int* p_source_is_set) {
+#if CYTHON_COMPILING_IN_CPYTHON
+    is_set = is_set || likely(PySet_CheckExact(iterable) || PyFrozenSet_CheckExact(iterable));
+    *p_source_is_set = is_set;
+    if (likely(is_set)) {
+        *p_orig_length = PySet_Size(iterable);
+        Py_INCREF(iterable);
+        return iterable;
+    }
+#else
+    (void)is_set;
+    *p_source_is_set = 0;
+#endif
+    *p_orig_length = 0;
+    return PyObject_GetIter(iterable);
+}
+static CYTHON_INLINE int __Pyx_set_iter_next(
+        PyObject* iter_obj, Py_ssize_t orig_length,
+        Py_ssize_t* ppos, PyObject **value,
+        int source_is_set) {
+    if (!CYTHON_COMPILING_IN_CPYTHON || unlikely(!source_is_set)) {
+        *value = PyIter_Next(iter_obj);
+        if (unlikely(!*value)) {
+            return __Pyx_IterFinish();
+        }
+        (void)orig_length;
+        (void)ppos;
+        return 1;
+    }
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (unlikely(PySet_GET_SIZE(iter_obj) != orig_length)) {
+        PyErr_SetString(
+            PyExc_RuntimeError,
+            "set changed size during iteration");
+        return -1;
+    }
+    {
+        Py_hash_t hash;
+        int ret = _PySet_NextEntry(iter_obj, ppos, value, &hash);
+        assert (ret != -1);
+        if (likely(ret)) {
+            Py_INCREF(*value);
+            return 1;
+        }
+    }
+#endif
+    return 0;
+}
+
+/* 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
+
+/* 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;
+}
+
+/* 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;
+}
+
+/* RaiseNoneIterError */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+}
+
+/* UnpackTupleError */
+static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
+    if (t == Py_None) {
+      __Pyx_RaiseNoneNotIterableError();
+    } else if (PyTuple_GET_SIZE(t) < index) {
+      __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t));
+    } else {
+      __Pyx_RaiseTooManyValuesError(index);
+    }
+}
+
+/* UnpackTuple2 */
+static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
+        PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) {
+    PyObject *value1 = NULL, *value2 = NULL;
+#if CYTHON_COMPILING_IN_PYPY
+    value1 = PySequence_ITEM(tuple, 0);  if (unlikely(!value1)) goto bad;
+    value2 = PySequence_ITEM(tuple, 1);  if (unlikely(!value2)) goto bad;
+#else
+    value1 = PyTuple_GET_ITEM(tuple, 0);  Py_INCREF(value1);
+    value2 = PyTuple_GET_ITEM(tuple, 1);  Py_INCREF(value2);
+#endif
+    if (decref_tuple) {
+        Py_DECREF(tuple);
+    }
+    *pvalue1 = value1;
+    *pvalue2 = value2;
+    return 0;
+#if CYTHON_COMPILING_IN_PYPY
+bad:
+    Py_XDECREF(value1);
+    Py_XDECREF(value2);
+    if (decref_tuple) { Py_XDECREF(tuple); }
+    return -1;
+#endif
+}
+static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2,
+                                       int has_known_size, int decref_tuple) {
+    Py_ssize_t index;
+    PyObject *value1 = NULL, *value2 = NULL, *iter = NULL;
+    iternextfunc iternext;
+    iter = PyObject_GetIter(tuple);
+    if (unlikely(!iter)) goto bad;
+    if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; }
+    iternext = Py_TYPE(iter)->tp_iternext;
+    value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; }
+    value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; }
+    if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad;
+    Py_DECREF(iter);
+    *pvalue1 = value1;
+    *pvalue2 = value2;
+    return 0;
+unpacking_failed:
+    if (!has_known_size && __Pyx_IterFinish() == 0)
+        __Pyx_RaiseNeedMoreValuesError(index);
+bad:
+    Py_XDECREF(iter);
+    Py_XDECREF(value1);
+    Py_XDECREF(value2);
+    if (decref_tuple) { Py_XDECREF(tuple); }
+    return -1;
+}
+
+/* dict_iter */
+static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name,
+                                                   Py_ssize_t* p_orig_length, int* p_source_is_dict) {
+    is_dict = is_dict || likely(PyDict_CheckExact(iterable));
+    *p_source_is_dict = is_dict;
+    if (is_dict) {
+#if !CYTHON_COMPILING_IN_PYPY
+        *p_orig_length = PyDict_Size(iterable);
+        Py_INCREF(iterable);
+        return iterable;
+#elif PY_MAJOR_VERSION >= 3
+        static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL;
+        PyObject **pp = NULL;
+        if (method_name) {
+            const char *name = PyUnicode_AsUTF8(method_name);
+            if (strcmp(name, "iteritems") == 0) pp = &py_items;
+            else if (strcmp(name, "iterkeys") == 0) pp = &py_keys;
+            else if (strcmp(name, "itervalues") == 0) pp = &py_values;
+            if (pp) {
+                if (!*pp) {
+                    *pp = PyUnicode_FromString(name + 4);
+                    if (!*pp)
+                        return NULL;
+                }
+                method_name = *pp;
+            }
+        }
+#endif
+    }
+    *p_orig_length = 0;
+    if (method_name) {
+        PyObject* iter;
+        iterable = __Pyx_PyObject_CallMethod0(iterable, method_name);
+        if (!iterable)
+            return NULL;
+#if !CYTHON_COMPILING_IN_PYPY
+        if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable))
+            return iterable;
+#endif
+        iter = PyObject_GetIter(iterable);
+        Py_DECREF(iterable);
+        return iter;
+    }
+    return PyObject_GetIter(iterable);
+}
+static CYTHON_INLINE int __Pyx_dict_iter_next(
+        PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos,
+        PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) {
+    PyObject* next_item;
+#if !CYTHON_COMPILING_IN_PYPY
+    if (source_is_dict) {
+        PyObject *key, *value;
+        if (unlikely(orig_length != PyDict_Size(iter_obj))) {
+            PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration");
+            return -1;
+        }
+        if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) {
+            return 0;
+        }
+        if (pitem) {
+            PyObject* tuple = PyTuple_New(2);
+            if (unlikely(!tuple)) {
+                return -1;
+            }
+            Py_INCREF(key);
+            Py_INCREF(value);
+            PyTuple_SET_ITEM(tuple, 0, key);
+            PyTuple_SET_ITEM(tuple, 1, value);
+            *pitem = tuple;
+        } else {
+            if (pkey) {
+                Py_INCREF(key);
+                *pkey = key;
+            }
+            if (pvalue) {
+                Py_INCREF(value);
+                *pvalue = value;
+            }
+        }
+        return 1;
+    } else if (PyTuple_CheckExact(iter_obj)) {
+        Py_ssize_t pos = *ppos;
+        if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0;
+        *ppos = pos + 1;
+        next_item = PyTuple_GET_ITEM(iter_obj, pos);
+        Py_INCREF(next_item);
+    } else if (PyList_CheckExact(iter_obj)) {
+        Py_ssize_t pos = *ppos;
+        if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0;
+        *ppos = pos + 1;
+        next_item = PyList_GET_ITEM(iter_obj, pos);
+        Py_INCREF(next_item);
+    } else
+#endif
+    {
+        next_item = PyIter_Next(iter_obj);
+        if (unlikely(!next_item)) {
+            return __Pyx_IterFinish();
+        }
+    }
+    if (pitem) {
+        *pitem = next_item;
+    } else if (pkey && pvalue) {
+        if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1))
+            return -1;
+    } else if (pkey) {
+        *pkey = next_item;
+    } else {
+        *pvalue = next_item;
+    }
+    return 1;
+}
+
+/* PyObjectCallMethod1 */
+static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) {
+    PyObject *result = __Pyx_PyObject_CallOneArg(method, arg);
+    Py_DECREF(method);
+    return result;
+}
+static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) {
+    PyObject *method = NULL, *result;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_Call2Args(method, obj, arg);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) return NULL;
+    return __Pyx__PyObject_CallMethod1(method, arg);
+}
+
+/* append */
+static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
+    if (likely(PyList_CheckExact(L))) {
+        if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1;
+    } else {
+        PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_n_s_append, x);
+        if (unlikely(!retval))
+            return -1;
+        Py_DECREF(retval);
+    }
+    return 0;
+}
+
+/* GetItemInt */
+static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
+    PyObject *r;
+    if (!j) return NULL;
+    r = PyObject_GetItem(o, j);
+    Py_DECREF(j);
+    return r;
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    Py_ssize_t wrapped_i = i;
+    if (wraparound & unlikely(i < 0)) {
+        wrapped_i += PyList_GET_SIZE(o);
+    }
+    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) {
+        PyObject *r = PyList_GET_ITEM(o, wrapped_i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    Py_ssize_t wrapped_i = i;
+    if (wraparound & unlikely(i < 0)) {
+        wrapped_i += PyTuple_GET_SIZE(o);
+    }
+    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) {
+        PyObject *r = PyTuple_GET_ITEM(o, wrapped_i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
+                                                     CYTHON_NCP_UNUSED int wraparound,
+                                                     CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
+    if (is_list || PyList_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
+        if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) {
+            PyObject *r = PyList_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    }
+    else if (PyTuple_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
+        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) {
+            PyObject *r = PyTuple_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    } else {
+        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
+        if (likely(m && m->sq_item)) {
+            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
+                Py_ssize_t l = m->sq_length(o);
+                if (likely(l >= 0)) {
+                    i += l;
+                } else {
+                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                        return NULL;
+                    PyErr_Clear();
+                }
+            }
+            return m->sq_item(o, i);
+        }
+    }
+#else
+    if (is_list || PySequence_Check(o)) {
+        return PySequence_GetItem(o, i);
+    }
+#endif
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+}
+
+/* ObjectGetItem */
+#if CYTHON_USE_TYPE_SLOTS
+static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) {
+    PyObject *runerr;
+    Py_ssize_t key_value;
+    PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence;
+    if (unlikely(!(m && m->sq_item))) {
+        PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name);
+        return NULL;
+    }
+    key_value = __Pyx_PyIndex_AsSsize_t(index);
+    if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) {
+        return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1);
+    }
+    if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) {
+        PyErr_Clear();
+        PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name);
+    }
+    return NULL;
+}
+static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) {
+    PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping;
+    if (likely(m && m->mp_subscript)) {
+        return m->mp_subscript(obj, key);
+    }
+    return __Pyx_PyObject_GetIndex(obj, key);
+}
+#endif
+
+/* 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);
+    }
+#endif
+    return 0;
+}
+
+/* CallUnboundCMethod2 */
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1
+static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) {
+    if (likely(cfunc->func)) {
+        PyObject *args[2] = {arg1, arg2};
+        if (cfunc->flag == METH_FASTCALL) {
+            #if PY_VERSION_HEX >= 0x030700A0
+            return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, args, 2);
+            #else
+            return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL);
+            #endif
+        }
+        #if PY_VERSION_HEX >= 0x030700A0
+        if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS))
+            return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL);
+        #endif
+    }
+    return __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2);
+}
+#endif
+static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){
+    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(2);
+        if (unlikely(!args)) goto bad;
+        Py_INCREF(arg1);
+        PyTuple_SET_ITEM(args, 0, arg1);
+        Py_INCREF(arg2);
+        PyTuple_SET_ITEM(args, 1, arg2);
+        if (cfunc->flag & METH_KEYWORDS)
+            result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL);
+        else
+            result = (*cfunc->func)(self, args);
+    } else {
+        args = PyTuple_New(3);
+        if (unlikely(!args)) goto bad;
+        Py_INCREF(self);
+        PyTuple_SET_ITEM(args, 0, self);
+        Py_INCREF(arg1);
+        PyTuple_SET_ITEM(args, 1, arg1);
+        Py_INCREF(arg2);
+        PyTuple_SET_ITEM(args, 2, arg2);
+        result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
+    }
+#else
+    args = PyTuple_Pack(3, self, arg1, arg2);
+    if (unlikely(!args)) goto bad;
+    result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
+#endif
+bad:
+    Py_XDECREF(args);
+    return result;
+}
+
+/* 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);
+        }
+    }
+    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);
+    }
+#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;
+}
+
+/* py_dict_pop */
+static CYTHON_INLINE PyObject *__Pyx_PyDict_Pop(PyObject *d, PyObject *key, PyObject *default_value) {
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B3
+    if ((1)) {
+        return _PyDict_Pop(d, key, default_value);
+    } else
+#endif
+    if (default_value) {
+        return __Pyx_CallUnboundCMethod2(&__pyx_umethod_PyDict_Type_pop, d, key, default_value);
+    } else {
+        return __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyDict_Type_pop, d, key);
+    }
+}
+
+/* None */
+static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) {
+    PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname);
+}
+
+/* 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;
+}
+
+/* CythonFunctionShared */
+#include <structmember.h>
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
+{
+    if (unlikely(op->func_doc == NULL)) {
+        if (op->func.m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(op->func.m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+{
+    PyObject *tmp = op->func_doc;
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    op->func_doc = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+{
+    if (unlikely(op->func_name == NULL)) {
+#if PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(op->func.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, CYTHON_UNUSED void *context)
+{
+    PyObject *tmp;
+#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;
+    }
+    tmp = op->func_name;
+    Py_INCREF(value);
+    op->func_name = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *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)
+{
+    PyObject *tmp;
+#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;
+    }
+    tmp = op->func_qualname;
+    Py_INCREF(value);
+    op->func_qualname = value;
+    Py_XDECREF(tmp);
+    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)
+{
+    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, CYTHON_UNUSED void *context)
+{
+    PyObject *tmp;
+    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;
+    }
+    tmp = op->func_dict;
+    Py_INCREF(value);
+    op->func_dict = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *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)
+{
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    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 = PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = 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, CYTHON_UNUSED void *context) {
+    PyObject* tmp;
+    if (!value) {
+        value = Py_None;
+    } else if (value != Py_None && !PyTuple_Check(value)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    Py_INCREF(value);
+    tmp = op->defaults_tuple;
+    op->defaults_tuple = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+    PyObject* result = op->defaults_tuple;
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (__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, CYTHON_UNUSED void *context) {
+    PyObject* tmp;
+    if (!value) {
+        value = Py_None;
+    } else if (value != Py_None && !PyDict_Check(value)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    Py_INCREF(value);
+    tmp = op->defaults_kwdict;
+    op->defaults_kwdict = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+    PyObject* result = op->defaults_kwdict;
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (__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, CYTHON_UNUSED void *context) {
+    PyObject* tmp;
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (!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);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+    PyObject* result = op->func_annotations;
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+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},
+    {(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},
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0},
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *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);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.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 (unlikely(op == NULL))
+        return NULL;
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+    op->func.m_ml = ml;
+    op->func.m_self = (PyObject *) op;
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+    Py_XINCREF(module);
+    op->func.m_module = module;
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+    op->func_classobj = NULL;
+    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;
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+    Py_CLEAR(m->func.m_module);
+    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);
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    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);
+    PyObject_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);
+    Py_VISIT(m->func.m_module);
+    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);
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    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_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)
+{
+#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) {
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    Py_ssize_t size;
+    switch (f->m_ml->ml_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)) {
+            size = PyTuple_GET_SIZE(arg);
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+            size = PyTuple_GET_SIZE(arg);
+            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;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+            return NULL;
+        }
+        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);
+}
+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);
+            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;
+}
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+    0,
+    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,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+    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_CyFunction_descr_get,
+    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
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+    0,
+#endif
+};
+static int __pyx_CyFunction_init(void) {
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+    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;
+}
+
+/* PyObjectFormatAndDecref */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) {
+    if (unlikely(!s)) return NULL;
+    if (likely(PyUnicode_CheckExact(s))) return s;
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyString_CheckExact(s))) {
+        PyObject *result = PyUnicode_FromEncodedObject(s, NULL, "strict");
+        Py_DECREF(s);
+        return result;
+    }
+    #endif
+    return __Pyx_PyObject_FormatAndDecref(s, f);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) {
+    PyObject *result = PyObject_Format(s, f);
+    Py_DECREF(s);
+    return result;
+}
+
+/* JoinPyUnicode */
+static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength,
+                                      CYTHON_UNUSED Py_UCS4 max_char) {
+#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    PyObject *result_uval;
+    int result_ukind;
+    Py_ssize_t i, char_pos;
+    void *result_udata;
+#if CYTHON_PEP393_ENABLED
+    result_uval = PyUnicode_New(result_ulength, max_char);
+    if (unlikely(!result_uval)) return NULL;
+    result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND;
+    result_udata = PyUnicode_DATA(result_uval);
+#else
+    result_uval = PyUnicode_FromUnicode(NULL, result_ulength);
+    if (unlikely(!result_uval)) return NULL;
+    result_ukind = sizeof(Py_UNICODE);
+    result_udata = PyUnicode_AS_UNICODE(result_uval);
+#endif
+    char_pos = 0;
+    for (i=0; i < value_count; i++) {
+        int ukind;
+        Py_ssize_t ulength;
+        void *udata;
+        PyObject *uval = PyTuple_GET_ITEM(value_tuple, i);
+        if (unlikely(__Pyx_PyUnicode_READY(uval)))
+            goto bad;
+        ulength = __Pyx_PyUnicode_GET_LENGTH(uval);
+        if (unlikely(!ulength))
+            continue;
+        if (unlikely(char_pos + ulength < 0))
+            goto overflow;
+        ukind = __Pyx_PyUnicode_KIND(uval);
+        udata = __Pyx_PyUnicode_DATA(uval);
+        if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) {
+            memcpy((char *)result_udata + char_pos * result_ukind, udata, (size_t) (ulength * result_ukind));
+        } else {
+            #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters)
+            _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength);
+            #else
+            Py_ssize_t j;
+            for (j=0; j < ulength; j++) {
+                Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j);
+                __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar);
+            }
+            #endif
+        }
+        char_pos += ulength;
+    }
+    return result_uval;
+overflow:
+    PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string");
+bad:
+    Py_DECREF(result_uval);
+    return NULL;
+#else
+    result_ulength++;
+    value_count++;
+    return PyUnicode_Join(__pyx_empty_unicode, value_tuple);
+#endif
+}
+
+/* SliceObject */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj,
+        Py_ssize_t cstart, Py_ssize_t cstop,
+        PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice,
+        int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) {
+#if CYTHON_USE_TYPE_SLOTS
+    PyMappingMethods* mp;
+#if PY_MAJOR_VERSION < 3
+    PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence;
+    if (likely(ms && ms->sq_slice)) {
+        if (!has_cstart) {
+            if (_py_start && (*_py_start != Py_None)) {
+                cstart = __Pyx_PyIndex_AsSsize_t(*_py_start);
+                if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+            } else
+                cstart = 0;
+        }
+        if (!has_cstop) {
+            if (_py_stop && (*_py_stop != Py_None)) {
+                cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop);
+                if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+            } else
+                cstop = PY_SSIZE_T_MAX;
+        }
+        if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) {
+            Py_ssize_t l = ms->sq_length(obj);
+            if (likely(l >= 0)) {
+                if (cstop < 0) {
+                    cstop += l;
+                    if (cstop < 0) cstop = 0;
+                }
+                if (cstart < 0) {
+                    cstart += l;
+                    if (cstart < 0) cstart = 0;
+                }
+            } else {
+                if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                    goto bad;
+                PyErr_Clear();
+            }
+        }
+        return ms->sq_slice(obj, cstart, cstop);
+    }
+#endif
+    mp = Py_TYPE(obj)->tp_as_mapping;
+    if (likely(mp && mp->mp_subscript))
+#endif
+    {
+        PyObject* result;
+        PyObject *py_slice, *py_start, *py_stop;
+        if (_py_slice) {
+            py_slice = *_py_slice;
+        } else {
+            PyObject* owned_start = NULL;
+            PyObject* owned_stop = NULL;
+            if (_py_start) {
+                py_start = *_py_start;
+            } else {
+                if (has_cstart) {
+                    owned_start = py_start = PyInt_FromSsize_t(cstart);
+                    if (unlikely(!py_start)) goto bad;
+                } else
+                    py_start = Py_None;
+            }
+            if (_py_stop) {
+                py_stop = *_py_stop;
+            } else {
+                if (has_cstop) {
+                    owned_stop = py_stop = PyInt_FromSsize_t(cstop);
+                    if (unlikely(!py_stop)) {
+                        Py_XDECREF(owned_start);
+                        goto bad;
+                    }
+                } else
+                    py_stop = Py_None;
+            }
+            py_slice = PySlice_New(py_start, py_stop, Py_None);
+            Py_XDECREF(owned_start);
+            Py_XDECREF(owned_stop);
+            if (unlikely(!py_slice)) goto bad;
+        }
+#if CYTHON_USE_TYPE_SLOTS
+        result = mp->mp_subscript(obj, py_slice);
+#else
+        result = PyObject_GetItem(obj, py_slice);
+#endif
+        if (!_py_slice) {
+            Py_DECREF(py_slice);
+        }
+        return result;
+    }
+    PyErr_Format(PyExc_TypeError,
+        "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name);
+bad:
+    return NULL;
+}
+
+/* PyIntCompare */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) {
+    if (op1 == op2) {
+        Py_RETURN_FALSE;
+    }
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long a = PyInt_AS_LONG(op1);
+        if (a != b) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        int unequal;
+        unsigned long uintval;
+        Py_ssize_t size = Py_SIZE(op1);
+        const digit* digits = ((PyLongObject*)op1)->ob_digit;
+        if (intval == 0) {
+            if (size != 0) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+        } else if (intval < 0) {
+            if (size >= 0)
+                Py_RETURN_TRUE;
+            intval = -intval;
+            size = -size;
+        } else {
+            if (size <= 0)
+                Py_RETURN_TRUE;
+        }
+        uintval = (unsigned long) intval;
+#if PyLong_SHIFT * 4 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 4)) {
+            unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 3 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 3)) {
+            unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 2 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 2)) {
+            unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 1 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 1)) {
+            unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+            unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK));
+        if (unequal != 0) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+        double a = PyFloat_AS_DOUBLE(op1);
+        if ((double)a != (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+    }
+    return (
+        PyObject_RichCompare(op1, op2, Py_NE));
+}
+
+/* CoroutineBase */
+#include <structmember.h>
+#include <frameobject.h>
+#define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom)
+static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject **pvalue) {
+    PyObject *et, *ev, *tb;
+    PyObject *value = NULL;
+    __Pyx_ErrFetch(&et, &ev, &tb);
+    if (!et) {
+        Py_XDECREF(tb);
+        Py_XDECREF(ev);
+        Py_INCREF(Py_None);
+        *pvalue = Py_None;
+        return 0;
+    }
+    if (likely(et == PyExc_StopIteration)) {
+        if (!ev) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#if PY_VERSION_HEX >= 0x030300A0
+        else if (Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) {
+            value = ((PyStopIterationObject *)ev)->value;
+            Py_INCREF(value);
+            Py_DECREF(ev);
+        }
+#endif
+        else if (unlikely(PyTuple_Check(ev))) {
+            if (PyTuple_GET_SIZE(ev) >= 1) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                value = PyTuple_GET_ITEM(ev, 0);
+                Py_INCREF(value);
+#else
+                value = PySequence_ITEM(ev, 0);
+#endif
+            } else {
+                Py_INCREF(Py_None);
+                value = Py_None;
+            }
+            Py_DECREF(ev);
+        }
+        else if (!__Pyx_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) {
+            value = ev;
+        }
+        if (likely(value)) {
+            Py_XDECREF(tb);
+            Py_DECREF(et);
+            *pvalue = value;
+            return 0;
+        }
+    } else if (!__Pyx_PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) {
+        __Pyx_ErrRestore(et, ev, tb);
+        return -1;
+    }
+    PyErr_NormalizeException(&et, &ev, &tb);
+    if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) {
+        __Pyx_ErrRestore(et, ev, tb);
+        return -1;
+    }
+    Py_XDECREF(tb);
+    Py_DECREF(et);
+#if PY_VERSION_HEX >= 0x030300A0
+    value = ((PyStopIterationObject *)ev)->value;
+    Py_INCREF(value);
+    Py_DECREF(ev);
+#else
+    {
+        PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args);
+        Py_DECREF(ev);
+        if (likely(args)) {
+            value = PySequence_GetItem(args, 0);
+            Py_DECREF(args);
+        }
+        if (unlikely(!value)) {
+            __Pyx_ErrRestore(NULL, NULL, NULL);
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+    }
+#endif
+    *pvalue = value;
+    return 0;
+}
+static CYTHON_INLINE
+void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) {
+    PyObject *t, *v, *tb;
+    t = exc_state->exc_type;
+    v = exc_state->exc_value;
+    tb = exc_state->exc_traceback;
+    exc_state->exc_type = NULL;
+    exc_state->exc_value = NULL;
+    exc_state->exc_traceback = NULL;
+    Py_XDECREF(t);
+    Py_XDECREF(v);
+    Py_XDECREF(tb);
+}
+#define __Pyx_Coroutine_AlreadyRunningError(gen)  (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL)
+static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineObject *gen) {
+    const char *msg;
+    if ((0)) {
+    #ifdef __Pyx_Coroutine_USED
+    } else if (__Pyx_Coroutine_Check((PyObject*)gen)) {
+        msg = "coroutine already executing";
+    #endif
+    #ifdef __Pyx_AsyncGen_USED
+    } else if (__Pyx_AsyncGen_CheckExact((PyObject*)gen)) {
+        msg = "async generator already executing";
+    #endif
+    } else {
+        msg = "generator already executing";
+    }
+    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) {
+    const char *msg;
+    if ((0)) {
+    #ifdef __Pyx_Coroutine_USED
+    } else if (__Pyx_Coroutine_Check(gen)) {
+        msg = "can't send non-None value to a just-started coroutine";
+    #endif
+    #ifdef __Pyx_AsyncGen_USED
+    } else if (__Pyx_AsyncGen_CheckExact(gen)) {
+        msg = "can't send non-None value to a just-started async generator";
+    #endif
+    } else {
+        msg = "can't send non-None value to a just-started generator";
+    }
+    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) {
+    #ifdef __Pyx_Coroutine_USED
+    if (!closing && __Pyx_Coroutine_Check(gen)) {
+        PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine");
+    } else
+    #endif
+    if (value) {
+        #ifdef __Pyx_AsyncGen_USED
+        if (__Pyx_AsyncGen_CheckExact(gen))
+            PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration);
+        else
+        #endif
+        PyErr_SetNone(PyExc_StopIteration);
+    }
+}
+static
+PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, int closing) {
+    __Pyx_PyThreadState_declare
+    PyThreadState *tstate;
+    __Pyx_ExcInfoStruct *exc_state;
+    PyObject *retval;
+    assert(!self->is_running);
+    if (unlikely(self->resume_label == 0)) {
+        if (unlikely(value && value != Py_None)) {
+            return __Pyx_Coroutine_NotStartedError((PyObject*)self);
+        }
+    }
+    if (unlikely(self->resume_label == -1)) {
+        return __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing);
+    }
+#if CYTHON_FAST_THREAD_STATE
+    __Pyx_PyThreadState_assign
+    tstate = __pyx_tstate;
+#else
+    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
+        #else
+        if (exc_state->exc_traceback) {
+            PyTracebackObject *tb = (PyTracebackObject *) exc_state->exc_traceback;
+            PyFrameObject *f = tb->tb_frame;
+            Py_XINCREF(tstate->frame);
+            assert(f->f_back == NULL);
+            f->f_back = tstate->frame;
+        }
+        #endif
+    }
+#if CYTHON_USE_EXC_INFO_STACK
+    exc_state->previous_item = tstate->exc_info;
+    tstate->exc_info = exc_state;
+#else
+    if (exc_state->exc_type) {
+        __Pyx_ExceptionSwap(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback);
+    } else {
+        __Pyx_Coroutine_ExceptionClear(exc_state);
+        __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback);
+    }
+#endif
+    self->is_running = 1;
+    retval = self->body((PyObject *) self, tstate, value);
+    self->is_running = 0;
+#if CYTHON_USE_EXC_INFO_STACK
+    exc_state = &self->gi_exc_state;
+    tstate->exc_info = exc_state->previous_item;
+    exc_state->previous_item = NULL;
+    __Pyx_Coroutine_ResetFrameBackpointer(exc_state);
+#endif
+    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
+#else
+        PyTracebackObject *tb = (PyTracebackObject *) exc_tb;
+        PyFrameObject *f = tb->tb_frame;
+        Py_CLEAR(f->f_back);
+#endif
+    }
+}
+static CYTHON_INLINE
+PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *retval) {
+    if (unlikely(!retval)) {
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        if (!__Pyx_PyErr_Occurred()) {
+            PyObject *exc = PyExc_StopIteration;
+            #ifdef __Pyx_AsyncGen_USED
+            if (__Pyx_AsyncGen_CheckExact(gen))
+                exc = __Pyx_PyExc_StopAsyncIteration;
+            #endif
+            __Pyx_PyErr_SetNone(exc);
+        }
+    }
+    return retval;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3)
+static CYTHON_INLINE
+PyObject *__Pyx_PyGen_Send(PyGenObject *gen, PyObject *arg) {
+#if PY_VERSION_HEX <= 0x030A00A1
+    return _PyGen_Send(gen, arg);
+#else
+    PyObject *result;
+    if (PyIter_Send((PyObject*)gen, arg ? arg : Py_None, &result) == PYGEN_RETURN) {
+        if (PyAsyncGen_CheckExact(gen)) {
+            assert(result == Py_None);
+            PyErr_SetNone(PyExc_StopAsyncIteration);
+        }
+        else if (result == Py_None) {
+            PyErr_SetNone(PyExc_StopIteration);
+        }
+        else {
+            _PyGen_SetStopIterationValue(result);
+        }
+        Py_CLEAR(result);
+    }
+    return result;
+#endif
+}
+#endif
+static CYTHON_INLINE
+PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) {
+    PyObject *ret;
+    PyObject *val = NULL;
+    __Pyx_Coroutine_Undelegate(gen);
+    __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val);
+    ret = __Pyx_Coroutine_SendEx(gen, val, 0);
+    Py_XDECREF(val);
+    return ret;
+}
+static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) {
+    PyObject *retval;
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self;
+    PyObject *yf = gen->yieldfrom;
+    if (unlikely(gen->is_running))
+        return __Pyx_Coroutine_AlreadyRunningError(gen);
+    if (yf) {
+        PyObject *ret;
+        gen->is_running = 1;
+        #ifdef __Pyx_Generator_USED
+        if (__Pyx_Generator_CheckExact(yf)) {
+            ret = __Pyx_Coroutine_Send(yf, value);
+        } else
+        #endif
+        #ifdef __Pyx_Coroutine_USED
+        if (__Pyx_Coroutine_Check(yf)) {
+            ret = __Pyx_Coroutine_Send(yf, value);
+        } else
+        #endif
+        #ifdef __Pyx_AsyncGen_USED
+        if (__pyx_PyAsyncGenASend_CheckExact(yf)) {
+            ret = __Pyx_async_gen_asend_send(yf, value);
+        } else
+        #endif
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3)
+        if (PyGen_CheckExact(yf)) {
+            ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value);
+        } else
+        #endif
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03050000 && defined(PyCoro_CheckExact) && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3)
+        if (PyCoro_CheckExact(yf)) {
+            ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value);
+        } else
+        #endif
+        {
+            if (value == Py_None)
+                ret = Py_TYPE(yf)->tp_iternext(yf);
+            else
+                ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value);
+        }
+        gen->is_running = 0;
+        if (likely(ret)) {
+            return ret;
+        }
+        retval = __Pyx_Coroutine_FinishDelegation(gen);
+    } else {
+        retval = __Pyx_Coroutine_SendEx(gen, value, 0);
+    }
+    return __Pyx_Coroutine_MethodReturn(self, retval);
+}
+static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) {
+    PyObject *retval = NULL;
+    int err = 0;
+    #ifdef __Pyx_Generator_USED
+    if (__Pyx_Generator_CheckExact(yf)) {
+        retval = __Pyx_Coroutine_Close(yf);
+        if (!retval)
+            return -1;
+    } else
+    #endif
+    #ifdef __Pyx_Coroutine_USED
+    if (__Pyx_Coroutine_Check(yf)) {
+        retval = __Pyx_Coroutine_Close(yf);
+        if (!retval)
+            return -1;
+    } else
+    if (__Pyx_CoroutineAwait_CheckExact(yf)) {
+        retval = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf, NULL);
+        if (!retval)
+            return -1;
+    } else
+    #endif
+    #ifdef __Pyx_AsyncGen_USED
+    if (__pyx_PyAsyncGenASend_CheckExact(yf)) {
+        retval = __Pyx_async_gen_asend_close(yf, NULL);
+    } else
+    if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) {
+        retval = __Pyx_async_gen_athrow_close(yf, NULL);
+    } else
+    #endif
+    {
+        PyObject *meth;
+        gen->is_running = 1;
+        meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close);
+        if (unlikely(!meth)) {
+            if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
+                PyErr_WriteUnraisable(yf);
+            }
+            PyErr_Clear();
+        } else {
+            retval = PyObject_CallFunction(meth, NULL);
+            Py_DECREF(meth);
+            if (!retval)
+                err = -1;
+        }
+        gen->is_running = 0;
+    }
+    Py_XDECREF(retval);
+    return err;
+}
+static PyObject *__Pyx_Generator_Next(PyObject *self) {
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self;
+    PyObject *yf = gen->yieldfrom;
+    if (unlikely(gen->is_running))
+        return __Pyx_Coroutine_AlreadyRunningError(gen);
+    if (yf) {
+        PyObject *ret;
+        gen->is_running = 1;
+        #ifdef __Pyx_Generator_USED
+        if (__Pyx_Generator_CheckExact(yf)) {
+            ret = __Pyx_Generator_Next(yf);
+        } else
+        #endif
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3)
+        if (PyGen_CheckExact(yf)) {
+            ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL);
+        } else
+        #endif
+        #ifdef __Pyx_Coroutine_USED
+        if (__Pyx_Coroutine_Check(yf)) {
+            ret = __Pyx_Coroutine_Send(yf, Py_None);
+        } else
+        #endif
+            ret = Py_TYPE(yf)->tp_iternext(yf);
+        gen->is_running = 0;
+        if (likely(ret)) {
+            return ret;
+        }
+        return __Pyx_Coroutine_FinishDelegation(gen);
+    }
+    return __Pyx_Coroutine_SendEx(gen, Py_None, 0);
+}
+static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, CYTHON_UNUSED PyObject *arg) {
+    return __Pyx_Coroutine_Close(self);
+}
+static PyObject *__Pyx_Coroutine_Close(PyObject *self) {
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self;
+    PyObject *retval, *raised_exception;
+    PyObject *yf = gen->yieldfrom;
+    int err = 0;
+    if (unlikely(gen->is_running))
+        return __Pyx_Coroutine_AlreadyRunningError(gen);
+    if (yf) {
+        Py_INCREF(yf);
+        err = __Pyx_Coroutine_CloseIter(gen, yf);
+        __Pyx_Coroutine_Undelegate(gen);
+        Py_DECREF(yf);
+    }
+    if (err == 0)
+        PyErr_SetNone(PyExc_GeneratorExit);
+    retval = __Pyx_Coroutine_SendEx(gen, NULL, 1);
+    if (unlikely(retval)) {
+        const char *msg;
+        Py_DECREF(retval);
+        if ((0)) {
+        #ifdef __Pyx_Coroutine_USED
+        } else if (__Pyx_Coroutine_Check(self)) {
+            msg = "coroutine ignored GeneratorExit";
+        #endif
+        #ifdef __Pyx_AsyncGen_USED
+        } else if (__Pyx_AsyncGen_CheckExact(self)) {
+#if PY_VERSION_HEX < 0x03060000
+            msg = "async generator ignored GeneratorExit - might require Python 3.6+ finalisation (PEP 525)";
+#else
+            msg = "async generator ignored GeneratorExit";
+#endif
+        #endif
+        } else {
+            msg = "generator ignored GeneratorExit";
+        }
+        PyErr_SetString(PyExc_RuntimeError, msg);
+        return NULL;
+    }
+    raised_exception = PyErr_Occurred();
+    if (likely(!raised_exception || __Pyx_PyErr_GivenExceptionMatches2(raised_exception, PyExc_GeneratorExit, PyExc_StopIteration))) {
+        if (raised_exception) PyErr_Clear();
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    return NULL;
+}
+static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb,
+                                        PyObject *args, int close_on_genexit) {
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self;
+    PyObject *yf = gen->yieldfrom;
+    if (unlikely(gen->is_running))
+        return __Pyx_Coroutine_AlreadyRunningError(gen);
+    if (yf) {
+        PyObject *ret;
+        Py_INCREF(yf);
+        if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) {
+            int err = __Pyx_Coroutine_CloseIter(gen, yf);
+            Py_DECREF(yf);
+            __Pyx_Coroutine_Undelegate(gen);
+            if (err < 0)
+                return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0));
+            goto throw_here;
+        }
+        gen->is_running = 1;
+        if (0
+        #ifdef __Pyx_Generator_USED
+            || __Pyx_Generator_CheckExact(yf)
+        #endif
+        #ifdef __Pyx_Coroutine_USED
+            || __Pyx_Coroutine_Check(yf)
+        #endif
+            ) {
+            ret = __Pyx__Coroutine_Throw(yf, typ, val, tb, args, close_on_genexit);
+        #ifdef __Pyx_Coroutine_USED
+        } else if (__Pyx_CoroutineAwait_CheckExact(yf)) {
+            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);
+            if (unlikely(!meth)) {
+                Py_DECREF(yf);
+                if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
+                    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);
+            } else {
+                ret = PyObject_CallFunctionObjArgs(meth, typ, val, tb, NULL);
+            }
+            Py_DECREF(meth);
+        }
+        gen->is_running = 0;
+        Py_DECREF(yf);
+        if (!ret) {
+            ret = __Pyx_Coroutine_FinishDelegation(gen);
+        }
+        return __Pyx_Coroutine_MethodReturn(self, ret);
+    }
+throw_here:
+    __Pyx_Raise(typ, val, tb, NULL);
+    return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0));
+}
+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))
+        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) {
+    Py_VISIT(exc_state->exc_type);
+    Py_VISIT(exc_state->exc_value);
+    Py_VISIT(exc_state->exc_traceback);
+    return 0;
+}
+static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) {
+    Py_VISIT(gen->closure);
+    Py_VISIT(gen->classobj);
+    Py_VISIT(gen->yieldfrom);
+    return __Pyx_Coroutine_traverse_excstate(&gen->gi_exc_state, visit, arg);
+}
+static int __Pyx_Coroutine_clear(PyObject *self) {
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self;
+    Py_CLEAR(gen->closure);
+    Py_CLEAR(gen->classobj);
+    Py_CLEAR(gen->yieldfrom);
+    __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state);
+#ifdef __Pyx_AsyncGen_USED
+    if (__Pyx_AsyncGen_CheckExact(self)) {
+        Py_CLEAR(((__pyx_PyAsyncGenObject*)gen)->ag_finalizer);
+    }
+#endif
+    Py_CLEAR(gen->gi_code);
+    Py_CLEAR(gen->gi_frame);
+    Py_CLEAR(gen->gi_name);
+    Py_CLEAR(gen->gi_qualname);
+    Py_CLEAR(gen->gi_modulename);
+    return 0;
+}
+static void __Pyx_Coroutine_dealloc(PyObject *self) {
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self;
+    PyObject_GC_UnTrack(gen);
+    if (gen->gi_weakreflist != NULL)
+        PyObject_ClearWeakRefs(self);
+    if (gen->resume_label >= 0) {
+        PyObject_GC_Track(self);
+#if PY_VERSION_HEX >= 0x030400a1 && CYTHON_USE_TP_FINALIZE
+        if (PyObject_CallFinalizerFromDealloc(self))
+#else
+        Py_TYPE(gen)->tp_del(self);
+        if (Py_REFCNT(self) > 0)
+#endif
+        {
+            return;
+        }
+        PyObject_GC_UnTrack(self);
+    }
+#ifdef __Pyx_AsyncGen_USED
+    if (__Pyx_AsyncGen_CheckExact(self)) {
+        /* We have to handle this case for asynchronous generators
+           right here, because this code has to be between UNTRACK
+           and GC_Del. */
+        Py_CLEAR(((__pyx_PyAsyncGenObject*)self)->ag_finalizer);
+    }
+#endif
+    __Pyx_Coroutine_clear(self);
+    PyObject_GC_Del(gen);
+}
+static void __Pyx_Coroutine_del(PyObject *self) {
+    PyObject *error_type, *error_value, *error_traceback;
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self;
+    __Pyx_PyThreadState_declare
+    if (gen->resume_label < 0) {
+        return;
+    }
+#if !CYTHON_USE_TP_FINALIZE
+    assert(self->ob_refcnt == 0);
+    __Pyx_SET_REFCNT(self, 1);
+#endif
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&error_type, &error_value, &error_traceback);
+#ifdef __Pyx_AsyncGen_USED
+    if (__Pyx_AsyncGen_CheckExact(self)) {
+        __pyx_PyAsyncGenObject *agen = (__pyx_PyAsyncGenObject*)self;
+        PyObject *finalizer = agen->ag_finalizer;
+        if (finalizer && !agen->ag_closed) {
+            PyObject *res = __Pyx_PyObject_CallOneArg(finalizer, self);
+            if (unlikely(!res)) {
+                PyErr_WriteUnraisable(self);
+            } else {
+                Py_DECREF(res);
+            }
+            __Pyx_ErrRestore(error_type, error_value, error_traceback);
+            return;
+        }
+    }
+#endif
+    if (unlikely(gen->resume_label == 0 && !error_value)) {
+#ifdef __Pyx_Coroutine_USED
+#ifdef __Pyx_Generator_USED
+    if (!__Pyx_Generator_CheckExact(self))
+#endif
+        {
+        PyObject_GC_UnTrack(self);
+#if PY_MAJOR_VERSION >= 3  || defined(PyErr_WarnFormat)
+        if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0))
+            PyErr_WriteUnraisable(self);
+#else
+        {PyObject *msg;
+        char *cmsg;
+        #if CYTHON_COMPILING_IN_PYPY
+        msg = NULL;
+        cmsg = (char*) "coroutine was never awaited";
+        #else
+        char *cname;
+        PyObject *qualname;
+        qualname = gen->gi_qualname;
+        cname = PyString_AS_STRING(qualname);
+        msg = PyString_FromFormat("coroutine '%.50s' was never awaited", cname);
+        if (unlikely(!msg)) {
+            PyErr_Clear();
+            cmsg = (char*) "coroutine was never awaited";
+        } else {
+            cmsg = PyString_AS_STRING(msg);
+        }
+        #endif
+        if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, cmsg, 1) < 0))
+            PyErr_WriteUnraisable(self);
+        Py_XDECREF(msg);}
+#endif
+        PyObject_GC_Track(self);
+        }
+#endif
+    } else {
+        PyObject *res = __Pyx_Coroutine_Close(self);
+        if (unlikely(!res)) {
+            if (PyErr_Occurred())
+                PyErr_WriteUnraisable(self);
+        } else {
+            Py_DECREF(res);
+        }
+    }
+    __Pyx_ErrRestore(error_type, error_value, error_traceback);
+#if !CYTHON_USE_TP_FINALIZE
+    assert(Py_REFCNT(self) > 0);
+    if (--self->ob_refcnt == 0) {
+        return;
+    }
+    {
+        Py_ssize_t refcnt = Py_REFCNT(self);
+        _Py_NewReference(self);
+        __Pyx_SET_REFCNT(self, refcnt);
+    }
+#if CYTHON_COMPILING_IN_CPYTHON
+    assert(PyType_IS_GC(Py_TYPE(self)) &&
+           _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);
+    _Py_DEC_REFTOTAL;
+#endif
+#ifdef COUNT_ALLOCS
+    --Py_TYPE(self)->tp_frees;
+    --Py_TYPE(self)->tp_allocs;
+#endif
+#endif
+}
+static PyObject *
+__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context)
+{
+    PyObject *name = self->gi_name;
+    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)
+{
+    PyObject *tmp;
+#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;
+    }
+    tmp = self->gi_name;
+    Py_INCREF(value);
+    self->gi_name = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context)
+{
+    PyObject *name = self->gi_qualname;
+    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)
+{
+    PyObject *tmp;
+#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;
+    }
+    tmp = self->gi_qualname;
+    Py_INCREF(value);
+    self->gi_qualname = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context)
+{
+    PyObject *frame = self->gi_frame;
+    if (!frame) {
+        if (unlikely(!self->gi_code)) {
+            Py_RETURN_NONE;
+        }
+        frame = (PyObject *) PyFrame_New(
+            PyThreadState_Get(),            /*PyThreadState *tstate,*/
+            (PyCodeObject*) self->gi_code,  /*PyCodeObject *code,*/
+            __pyx_d,                 /*PyObject *globals,*/
+            0                               /*PyObject *locals*/
+        );
+        if (unlikely(!frame))
+            return NULL;
+        self->gi_frame = frame;
+    }
+    Py_INCREF(frame);
+    return frame;
+}
+static __pyx_CoroutineObject *__Pyx__Coroutine_New(
+            PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure,
+            PyObject *name, PyObject *qualname, PyObject *module_name) {
+    __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type);
+    if (unlikely(!gen))
+        return NULL;
+    return __Pyx__Coroutine_NewInit(gen, body, code, closure, name, qualname, module_name);
+}
+static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit(
+            __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure,
+            PyObject *name, PyObject *qualname, PyObject *module_name) {
+    gen->body = body;
+    gen->closure = closure;
+    Py_XINCREF(closure);
+    gen->is_running = 0;
+    gen->resume_label = 0;
+    gen->classobj = NULL;
+    gen->yieldfrom = NULL;
+    gen->gi_exc_state.exc_type = NULL;
+    gen->gi_exc_state.exc_value = NULL;
+    gen->gi_exc_state.exc_traceback = NULL;
+#if CYTHON_USE_EXC_INFO_STACK
+    gen->gi_exc_state.previous_item = NULL;
+#endif
+    gen->gi_weakreflist = NULL;
+    Py_XINCREF(qualname);
+    gen->gi_qualname = qualname;
+    Py_XINCREF(name);
+    gen->gi_name = name;
+    Py_XINCREF(module_name);
+    gen->gi_modulename = module_name;
+    Py_XINCREF(code);
+    gen->gi_code = code;
+    gen->gi_frame = NULL;
+    PyObject_GC_Track(gen);
+    return gen;
+}
+
+/* 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);
+    }
+    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
+
+/* PatchModuleWithCoroutine */
+static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) {
+#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+    int result;
+    PyObject *globals, *result_obj;
+    globals = PyDict_New();  if (unlikely(!globals)) goto ignore;
+    result = PyDict_SetItemString(globals, "_cython_coroutine_type",
+    #ifdef __Pyx_Coroutine_USED
+        (PyObject*)__pyx_CoroutineType);
+    #else
+        Py_None);
+    #endif
+    if (unlikely(result < 0)) goto ignore;
+    result = PyDict_SetItemString(globals, "_cython_generator_type",
+    #ifdef __Pyx_Generator_USED
+        (PyObject*)__pyx_GeneratorType);
+    #else
+        Py_None);
+    #endif
+    if (unlikely(result < 0)) goto ignore;
+    if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore;
+    if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore;
+    result_obj = PyRun_String(py_code, Py_file_input, globals, globals);
+    if (unlikely(!result_obj)) goto ignore;
+    Py_DECREF(result_obj);
+    Py_DECREF(globals);
+    return module;
+ignore:
+    Py_XDECREF(globals);
+    PyErr_WriteUnraisable(module);
+    if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) {
+        Py_DECREF(module);
+        module = NULL;
+    }
+#else
+    py_code++;
+#endif
+    return module;
+}
+
+/* PatchGeneratorABC */
+#ifndef CYTHON_REGISTER_ABCS
+#define CYTHON_REGISTER_ABCS 1
+#endif
+#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+static PyObject* __Pyx_patch_abc_module(PyObject *module);
+static PyObject* __Pyx_patch_abc_module(PyObject *module) {
+    module = __Pyx_Coroutine_patch_module(
+        module, ""
+"if _cython_generator_type is not None:\n"
+"    try: Generator = _module.Generator\n"
+"    except AttributeError: pass\n"
+"    else: Generator.register(_cython_generator_type)\n"
+"if _cython_coroutine_type is not None:\n"
+"    try: Coroutine = _module.Coroutine\n"
+"    except AttributeError: pass\n"
+"    else: Coroutine.register(_cython_coroutine_type)\n"
+    );
+    return module;
+}
+#endif
+static int __Pyx_patch_abc(void) {
+#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+    static int abc_patched = 0;
+    if (CYTHON_REGISTER_ABCS && !abc_patched) {
+        PyObject *module;
+        module = PyImport_ImportModule((PY_MAJOR_VERSION >= 3) ? "collections.abc" : "collections");
+        if (!module) {
+            PyErr_WriteUnraisable(NULL);
+            if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning,
+                    ((PY_MAJOR_VERSION >= 3) ?
+                        "Cython module failed to register with collections.abc module" :
+                        "Cython module failed to register with collections module"), 1) < 0)) {
+                return -1;
+            }
+        } else {
+            module = __Pyx_patch_abc_module(module);
+            abc_patched = 1;
+            if (unlikely(!module))
+                return -1;
+            Py_DECREF(module);
+        }
+        module = PyImport_ImportModule("backports_abc");
+        if (module) {
+            module = __Pyx_patch_abc_module(module);
+            Py_XDECREF(module);
+        }
+        if (!module) {
+            PyErr_Clear();
+        }
+    }
+#else
+    if ((0)) __Pyx_Coroutine_patch_module(NULL, NULL);
+#endif
+    return 0;
+}
+
+/* Coroutine */
+static void __Pyx_CoroutineAwait_dealloc(PyObject *self) {
+    PyObject_GC_UnTrack(self);
+    Py_CLEAR(((__pyx_CoroutineAwaitObject*)self)->coroutine);
+    PyObject_GC_Del(self);
+}
+static int __Pyx_CoroutineAwait_traverse(__pyx_CoroutineAwaitObject *self, visitproc visit, void *arg) {
+    Py_VISIT(self->coroutine);
+    return 0;
+}
+static int __Pyx_CoroutineAwait_clear(__pyx_CoroutineAwaitObject *self) {
+    Py_CLEAR(self->coroutine);
+    return 0;
+}
+static PyObject *__Pyx_CoroutineAwait_Next(__pyx_CoroutineAwaitObject *self) {
+    return __Pyx_Generator_Next(self->coroutine);
+}
+static PyObject *__Pyx_CoroutineAwait_Send(__pyx_CoroutineAwaitObject *self, PyObject *value) {
+    return __Pyx_Coroutine_Send(self->coroutine, value);
+}
+static PyObject *__Pyx_CoroutineAwait_Throw(__pyx_CoroutineAwaitObject *self, PyObject *args) {
+    return __Pyx_Coroutine_Throw(self->coroutine, args);
+}
+static PyObject *__Pyx_CoroutineAwait_Close(__pyx_CoroutineAwaitObject *self, CYTHON_UNUSED PyObject *arg) {
+    return __Pyx_Coroutine_Close(self->coroutine);
+}
+static PyObject *__Pyx_CoroutineAwait_self(PyObject *self) {
+    Py_INCREF(self);
+    return self;
+}
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_CoroutineAwait_no_new(CYTHON_UNUSED PyTypeObject *type, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwargs) {
+    PyErr_SetString(PyExc_TypeError, "cannot instantiate type, use 'await coroutine' instead");
+    return NULL;
+}
+#endif
+static PyMethodDef __pyx_CoroutineAwait_methods[] = {
+    {"send", (PyCFunction) __Pyx_CoroutineAwait_Send, METH_O,
+     (char*) PyDoc_STR("send(arg) -> send 'arg' into coroutine,\nreturn next yielded value or raise StopIteration.")},
+    {"throw", (PyCFunction) __Pyx_CoroutineAwait_Throw, METH_VARARGS,
+     (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in coroutine,\nreturn next yielded value or raise StopIteration.")},
+    {"close", (PyCFunction) __Pyx_CoroutineAwait_Close, METH_NOARGS,
+     (char*) PyDoc_STR("close() -> raise GeneratorExit inside coroutine.")},
+    {0, 0, 0, 0}
+};
+static PyTypeObject __pyx_CoroutineAwaitType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    "coroutine_wrapper",
+    sizeof(__pyx_CoroutineAwaitObject),
+    0,
+    (destructor) __Pyx_CoroutineAwait_dealloc,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+    PyDoc_STR("A wrapper object implementing __await__ for coroutines."),
+    (traverseproc) __Pyx_CoroutineAwait_traverse,
+    (inquiry) __Pyx_CoroutineAwait_clear,
+    0,
+    0,
+    __Pyx_CoroutineAwait_self,
+    (iternextfunc) __Pyx_CoroutineAwait_Next,
+    __pyx_CoroutineAwait_methods,
+    0                         ,
+    0                      ,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if !CYTHON_COMPILING_IN_PYPY
+    __Pyx_CoroutineAwait_no_new,
+#else
+    0,
+#endif
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+    0,
+#endif
+};
+#if PY_VERSION_HEX < 0x030500B1 || defined(__Pyx_IterableCoroutine_USED) || CYTHON_USE_ASYNC_SLOTS
+static CYTHON_INLINE PyObject *__Pyx__Coroutine_await(PyObject *coroutine) {
+    __pyx_CoroutineAwaitObject *await = PyObject_GC_New(__pyx_CoroutineAwaitObject, __pyx_CoroutineAwaitType);
+    if (unlikely(!await)) return NULL;
+    Py_INCREF(coroutine);
+    await->coroutine = coroutine;
+    PyObject_GC_Track(await);
+    return (PyObject*)await;
+}
+#endif
+#if PY_VERSION_HEX < 0x030500B1
+static PyObject *__Pyx_Coroutine_await_method(PyObject *coroutine, CYTHON_UNUSED PyObject *arg) {
+    return __Pyx__Coroutine_await(coroutine);
+}
+#endif
+#if defined(__Pyx_IterableCoroutine_USED) || CYTHON_USE_ASYNC_SLOTS
+static PyObject *__Pyx_Coroutine_await(PyObject *coroutine) {
+    if (unlikely(!coroutine || !__Pyx_Coroutine_Check(coroutine))) {
+        PyErr_SetString(PyExc_TypeError, "invalid input, expected coroutine");
+        return NULL;
+    }
+    return __Pyx__Coroutine_await(coroutine);
+}
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 && PY_VERSION_HEX < 0x030500B1
+static PyObject *__Pyx_Coroutine_compare(PyObject *obj, PyObject *other, int op) {
+    PyObject* result;
+    switch (op) {
+        case Py_EQ: result = (other == obj) ? Py_True : Py_False; break;
+        case Py_NE: result = (other != obj) ? Py_True : Py_False; break;
+        default:
+            result = Py_NotImplemented;
+    }
+    Py_INCREF(result);
+    return result;
+}
+#endif
+static PyMethodDef __pyx_Coroutine_methods[] = {
+    {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O,
+     (char*) PyDoc_STR("send(arg) -> send 'arg' into coroutine,\nreturn next iterated value or raise StopIteration.")},
+    {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS,
+     (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in coroutine,\nreturn next iterated value or raise StopIteration.")},
+    {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS,
+     (char*) PyDoc_STR("close() -> raise GeneratorExit inside coroutine.")},
+#if PY_VERSION_HEX < 0x030500B1
+    {"__await__", (PyCFunction) __Pyx_Coroutine_await_method, METH_NOARGS,
+     (char*) PyDoc_STR("__await__() -> return an iterator to be used in await expression.")},
+#endif
+    {0, 0, 0, 0}
+};
+static PyMemberDef __pyx_Coroutine_memberlist[] = {
+    {(char *) "cr_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL},
+    {(char*) "cr_await", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY,
+     (char*) PyDoc_STR("object being awaited, or None")},
+    {(char*) "cr_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL},
+    {(char *) "__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), PY_WRITE_RESTRICTED, 0},
+    {0, 0, 0, 0, 0}
+};
+static PyGetSetDef __pyx_Coroutine_getsets[] = {
+    {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name,
+     (char*) PyDoc_STR("name of the coroutine"), 0},
+    {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname,
+     (char*) PyDoc_STR("qualified name of the coroutine"), 0},
+    {(char *) "cr_frame", (getter)__Pyx_Coroutine_get_frame, NULL,
+     (char*) PyDoc_STR("Frame of the coroutine"), 0},
+    {0, 0, 0, 0, 0}
+};
+#if CYTHON_USE_ASYNC_SLOTS
+static __Pyx_PyAsyncMethodsStruct __pyx_Coroutine_as_async = {
+    __Pyx_Coroutine_await,
+    0,
+    0,
+};
+#endif
+static PyTypeObject __pyx_CoroutineType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    "coroutine",
+    sizeof(__pyx_CoroutineObject),
+    0,
+    (destructor) __Pyx_Coroutine_dealloc,
+    0,
+    0,
+    0,
+#if CYTHON_USE_ASYNC_SLOTS
+    &__pyx_Coroutine_as_async,
+#else
+    0,
+#endif
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,
+    0,
+    (traverseproc) __Pyx_Coroutine_traverse,
+    0,
+#if CYTHON_USE_ASYNC_SLOTS && CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 && PY_VERSION_HEX < 0x030500B1
+    __Pyx_Coroutine_compare,
+#else
+    0,
+#endif
+    offsetof(__pyx_CoroutineObject, gi_weakreflist),
+    0,
+    0,
+    __pyx_Coroutine_methods,
+    __pyx_Coroutine_memberlist,
+    __pyx_Coroutine_getsets,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if CYTHON_USE_TP_FINALIZE
+    0,
+#else
+    __Pyx_Coroutine_del,
+#endif
+    0,
+#if CYTHON_USE_TP_FINALIZE
+    __Pyx_Coroutine_del,
+#elif PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+    0,
+#endif
+};
+static int __pyx_Coroutine_init(void) {
+    __pyx_CoroutineType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+    __pyx_CoroutineType = __Pyx_FetchCommonType(&__pyx_CoroutineType_type);
+    if (unlikely(!__pyx_CoroutineType))
+        return -1;
+#ifdef __Pyx_IterableCoroutine_USED
+    if (unlikely(__pyx_IterableCoroutine_init() == -1))
+        return -1;
+#endif
+    __pyx_CoroutineAwaitType = __Pyx_FetchCommonType(&__pyx_CoroutineAwaitType_type);
+    if (unlikely(!__pyx_CoroutineAwaitType))
+        return -1;
+    return 0;
+}
+
+/* GetAwaitIter */
+static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAwaitableIter(PyObject *o) {
+#ifdef __Pyx_Coroutine_USED
+    if (__Pyx_Coroutine_Check(o)) {
+        return __Pyx_NewRef(o);
+    }
+#endif
+    return __Pyx__Coroutine_GetAwaitableIter(o);
+}
+static void __Pyx_Coroutine_AwaitableIterError(PyObject *source) {
+#if PY_VERSION_HEX >= 0x030600B3 || defined(_PyErr_FormatFromCause)
+    _PyErr_FormatFromCause(
+        PyExc_TypeError,
+        "'async for' received an invalid object "
+        "from __anext__: %.100s",
+        Py_TYPE(source)->tp_name);
+#elif PY_MAJOR_VERSION >= 3
+    PyObject *exc, *val, *val2, *tb;
+    assert(PyErr_Occurred());
+    PyErr_Fetch(&exc, &val, &tb);
+    PyErr_NormalizeException(&exc, &val, &tb);
+    if (tb != NULL) {
+        PyException_SetTraceback(val, tb);
+        Py_DECREF(tb);
+    }
+    Py_DECREF(exc);
+    assert(!PyErr_Occurred());
+    PyErr_Format(
+        PyExc_TypeError,
+        "'async for' received an invalid object "
+        "from __anext__: %.100s",
+        Py_TYPE(source)->tp_name);
+    PyErr_Fetch(&exc, &val2, &tb);
+    PyErr_NormalizeException(&exc, &val2, &tb);
+    Py_INCREF(val);
+    PyException_SetCause(val2, val);
+    PyException_SetContext(val2, val);
+    PyErr_Restore(exc, val2, tb);
+#else
+    source++;
+#endif
+}
+static PyObject *__Pyx__Coroutine_GetAwaitableIter(PyObject *obj) {
+    PyObject *res;
+#if CYTHON_USE_ASYNC_SLOTS
+    __Pyx_PyAsyncMethodsStruct* am = __Pyx_PyType_AsAsync(obj);
+    if (likely(am && am->am_await)) {
+        res = (*am->am_await)(obj);
+    } else
+#endif
+#if PY_VERSION_HEX >= 0x030500B2 || defined(PyCoro_CheckExact)
+    if (PyCoro_CheckExact(obj)) {
+        return __Pyx_NewRef(obj);
+    } else
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && defined(CO_ITERABLE_COROUTINE)
+    if (PyGen_CheckExact(obj) && ((PyGenObject*)obj)->gi_code && ((PyCodeObject *)((PyGenObject*)obj)->gi_code)->co_flags & CO_ITERABLE_COROUTINE) {
+        return __Pyx_NewRef(obj);
+    } else
+#endif
+    {
+        PyObject *method = NULL;
+        int is_method = __Pyx_PyObject_GetMethod(obj, __pyx_n_s_await, &method);
+        if (likely(is_method)) {
+            res = __Pyx_PyObject_CallOneArg(method, obj);
+        } else if (likely(method)) {
+            res = __Pyx_PyObject_CallNoArg(method);
+        } else
+            goto slot_error;
+        Py_DECREF(method);
+    }
+    if (unlikely(!res)) {
+        __Pyx_Coroutine_AwaitableIterError(obj);
+        goto bad;
+    }
+    if (unlikely(!PyIter_Check(res))) {
+        PyErr_Format(PyExc_TypeError,
+                     "__await__() returned non-iterator of type '%.100s'",
+                     Py_TYPE(res)->tp_name);
+        Py_CLEAR(res);
+    } else {
+        int is_coroutine = 0;
+        #ifdef __Pyx_Coroutine_USED
+        is_coroutine |= __Pyx_Coroutine_Check(res);
+        #endif
+        #if PY_VERSION_HEX >= 0x030500B2 || defined(PyCoro_CheckExact)
+        is_coroutine |= PyCoro_CheckExact(res);
+        #endif
+        if (unlikely(is_coroutine)) {
+            /* __await__ must return an *iterator*, not
+               a coroutine or another awaitable (see PEP 492) */
+            PyErr_SetString(PyExc_TypeError,
+                            "__await__() returned a coroutine");
+            Py_CLEAR(res);
+        }
+    }
+    return res;
+slot_error:
+    PyErr_Format(PyExc_TypeError,
+                 "object %.100s can't be used in 'await' expression",
+                 Py_TYPE(obj)->tp_name);
+bad:
+    return NULL;
+}
+
+/* CoroutineYieldFrom */
+static PyObject* __Pyx__Coroutine_Yield_From_Generic(__pyx_CoroutineObject *gen, PyObject *source) {
+    PyObject *retval;
+    PyObject *source_gen = __Pyx__Coroutine_GetAwaitableIter(source);
+    if (unlikely(!source_gen)) {
+        return NULL;
+    }
+    if (__Pyx_Coroutine_Check(source_gen)) {
+        retval = __Pyx_Generator_Next(source_gen);
+    } else {
+#if CYTHON_USE_TYPE_SLOTS
+        retval = Py_TYPE(source_gen)->tp_iternext(source_gen);
+#else
+        retval = PyIter_Next(source_gen);
+#endif
+    }
+    if (retval) {
+        gen->yieldfrom = source_gen;
+        return retval;
+    }
+    Py_DECREF(source_gen);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_Coroutine_Yield_From(__pyx_CoroutineObject *gen, PyObject *source) {
+    PyObject *retval;
+    if (__Pyx_Coroutine_Check(source)) {
+        if (unlikely(((__pyx_CoroutineObject*)source)->yieldfrom)) {
+            PyErr_SetString(
+                PyExc_RuntimeError,
+                "coroutine is being awaited already");
+            return NULL;
+        }
+        retval = __Pyx_Generator_Next(source);
+#ifdef __Pyx_AsyncGen_USED
+    } else if (__pyx_PyAsyncGenASend_CheckExact(source)) {
+        retval = __Pyx_async_gen_asend_iternext(source);
+#endif
+    } else {
+        return __Pyx__Coroutine_Yield_From_Generic(gen, source);
+    }
+    if (retval) {
+        Py_INCREF(source);
+        gen->yieldfrom = source;
+    }
+    return retval;
+}
+
+/* ReturnWithStopIteration */
+static void __Pyx__ReturnWithStopIteration(PyObject* value) {
+    PyObject *exc, *args;
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_PYSTON
+    __Pyx_PyThreadState_declare
+    if ((PY_VERSION_HEX >= 0x03030000 && PY_VERSION_HEX < 0x030500B1)
+            || unlikely(PyTuple_Check(value) || PyExceptionInstance_Check(value))) {
+        args = PyTuple_New(1);
+        if (unlikely(!args)) return;
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(args, 0, value);
+        exc = PyType_Type.tp_call(PyExc_StopIteration, args, NULL);
+        Py_DECREF(args);
+        if (!exc) return;
+    } else {
+        Py_INCREF(value);
+        exc = value;
+    }
+    #if CYTHON_FAST_THREAD_STATE
+    __Pyx_PyThreadState_assign
+    #if CYTHON_USE_EXC_INFO_STACK
+    if (!__pyx_tstate->exc_info->exc_type)
+    #else
+    if (!__pyx_tstate->exc_type)
+    #endif
+    {
+        Py_INCREF(PyExc_StopIteration);
+        __Pyx_ErrRestore(PyExc_StopIteration, exc, NULL);
+        return;
+    }
+    #endif
+#else
+    args = PyTuple_Pack(1, value);
+    if (unlikely(!args)) return;
+    exc = PyObject_Call(PyExc_StopIteration, args, NULL);
+    Py_DECREF(args);
+    if (unlikely(!exc)) return;
+#endif
+    PyErr_SetObject(PyExc_StopIteration, exc);
+    Py_DECREF(exc);
+}
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY
+    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_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
+    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
+}
+
+/* CallUnboundCMethod0 */
+static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) {
+    PyObject *args, *result = NULL;
+    if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
+#if CYTHON_ASSUME_SAFE_MACROS
+    args = PyTuple_New(1);
+    if (unlikely(!args)) goto bad;
+    Py_INCREF(self);
+    PyTuple_SET_ITEM(args, 0, self);
+#else
+    args = PyTuple_Pack(1, self);
+    if (unlikely(!args)) goto bad;
+#endif
+    result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
+    Py_DECREF(args);
+bad:
+    return result;
+}
+
+/* SetItemInt */
+static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
+    int r;
+    if (!j) return -1;
+    r = PyObject_SetItem(o, j, v);
+    Py_DECREF(j);
+    return r;
+}
+static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list,
+                                               CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
+    if (is_list || PyList_CheckExact(o)) {
+        Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o));
+        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) {
+            PyObject* old = PyList_GET_ITEM(o, n);
+            Py_INCREF(v);
+            PyList_SET_ITEM(o, n, v);
+            Py_DECREF(old);
+            return 1;
+        }
+    } else {
+        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
+        if (likely(m && m->sq_ass_item)) {
+            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
+                Py_ssize_t l = m->sq_length(o);
+                if (likely(l >= 0)) {
+                    i += l;
+                } else {
+                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                        return -1;
+                    PyErr_Clear();
+                }
+            }
+            return m->sq_ass_item(o, i, v);
+        }
+    }
+#else
+#if CYTHON_COMPILING_IN_PYPY
+    if (is_list || (PySequence_Check(o) && !PyDict_Check(o)))
+#else
+    if (is_list || PySequence_Check(o))
+#endif
+    {
+        return PySequence_SetItem(o, i, v);
+    }
+#endif
+    return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
+}
+
+/* MergeKeywords */
+static int __Pyx_MergeKeywords(PyObject *kwdict, PyObject *source_mapping) {
+    PyObject *iter, *key = NULL, *value = NULL;
+    int source_is_dict, result;
+    Py_ssize_t orig_length, ppos = 0;
+    iter = __Pyx_dict_iterator(source_mapping, 0, __pyx_n_s_items, &orig_length, &source_is_dict);
+    if (unlikely(!iter)) {
+        PyObject *args;
+        if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+        PyErr_Clear();
+        args = PyTuple_Pack(1, source_mapping);
+        if (likely(args)) {
+            PyObject *fallback = PyObject_Call((PyObject*)&PyDict_Type, args, NULL);
+            Py_DECREF(args);
+            if (likely(fallback)) {
+                iter = __Pyx_dict_iterator(fallback, 1, __pyx_n_s_items, &orig_length, &source_is_dict);
+                Py_DECREF(fallback);
+            }
+        }
+        if (unlikely(!iter)) goto bad;
+    }
+    while (1) {
+        result = __Pyx_dict_iter_next(iter, orig_length, &ppos, &key, &value, NULL, source_is_dict);
+        if (unlikely(result < 0)) goto bad;
+        if (!result) break;
+        if (unlikely(PyDict_Contains(kwdict, key))) {
+            __Pyx_RaiseDoubleKeywordsError("function", key);
+            result = -1;
+        } else {
+            result = PyDict_SetItem(kwdict, key, value);
+        }
+        Py_DECREF(key);
+        Py_DECREF(value);
+        if (unlikely(result < 0)) goto bad;
+    }
+    Py_XDECREF(iter);
+    return 0;
+bad:
+    Py_XDECREF(iter);
+    return -1;
+}
+
+/* GetAttr */
+static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) {
+#if CYTHON_USE_TYPE_SLOTS
+#if PY_MAJOR_VERSION >= 3
+    if (likely(PyUnicode_Check(n)))
+#else
+    if (likely(PyString_Check(n)))
+#endif
+        return __Pyx_PyObject_GetAttrStr(o, n);
+#endif
+    return PyObject_GetAttr(o, n);
+}
+
+/* HasAttr */
+static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) {
+    PyObject *r;
+    if (unlikely(!__Pyx_PyBaseString_Check(n))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "hasattr(): attribute name must be string");
+        return -1;
+    }
+    r = __Pyx_GetAttr(o, n);
+    if (unlikely(!r)) {
+        PyErr_Clear();
+        return 0;
+    } else {
+        Py_DECREF(r);
+        return 1;
+    }
+}
+
+/* None */
+static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) {
+    PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname);
+}
+
+/* GetAttr3 */
+static PyObject *__Pyx_GetAttr3Default(PyObject *d) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        return NULL;
+    __Pyx_PyErr_Clear();
+    Py_INCREF(d);
+    return d;
+}
+static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) {
+    PyObject *r = __Pyx_GetAttr(o, n);
+    return (likely(r)) ? r : __Pyx_GetAttr3Default(d);
+}
+
+/* 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
+    }
+    else {
+        if (likely(__Pyx_TypeCheck(obj, type))) 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;
+}
+
+/* py_set_remove */
+static int __Pyx_PySet_RemoveNotFound(PyObject *set, PyObject *key, int found) {
+    if (unlikely(found < 0)) {
+        found = __Pyx_PySet_DiscardUnhashable(set, key);
+    }
+    if (likely(found == 0)) {
+        PyObject *tup;
+        tup = PyTuple_Pack(1, key);
+        if (!tup)
+            return -1;
+        PyErr_SetObject(PyExc_KeyError, tup);
+        Py_DECREF(tup);
+        return -1;
+    }
+    return found;
+}
+static CYTHON_INLINE int __Pyx_PySet_Remove(PyObject *set, PyObject *key) {
+    int found = PySet_Discard(set, key);
+    if (unlikely(found != 1)) {
+        return __Pyx_PySet_RemoveNotFound(set, key, found);
+    }
+    return 0;
+}
+
+/* PyIntCompare */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) {
+    if (op1 == op2) {
+        Py_RETURN_TRUE;
+    }
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long a = PyInt_AS_LONG(op1);
+        if (a == b) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        int unequal;
+        unsigned long uintval;
+        Py_ssize_t size = Py_SIZE(op1);
+        const digit* digits = ((PyLongObject*)op1)->ob_digit;
+        if (intval == 0) {
+            if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+        } else if (intval < 0) {
+            if (size >= 0)
+                Py_RETURN_FALSE;
+            intval = -intval;
+            size = -size;
+        } else {
+            if (size <= 0)
+                Py_RETURN_FALSE;
+        }
+        uintval = (unsigned long) intval;
+#if PyLong_SHIFT * 4 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 4)) {
+            unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 3 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 3)) {
+            unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 2 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 2)) {
+            unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 1 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 1)) {
+            unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+            unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK));
+        if (unequal == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+        double a = PyFloat_AS_DOUBLE(op1);
+        if ((double)a == (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+    }
+    return (
+        PyObject_RichCompare(op1, op2, Py_EQ));
+}
+
+/* RaiseKeywordRequired */
+static void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name) {
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() needs keyword-only argument %U", func_name, kw_name);
+        #else
+        "%s() needs keyword-only argument %s", func_name,
+        PyString_AS_STRING(kw_name));
+        #endif
+}
+
+/* CIntToDigits */
+static const char DIGIT_PAIRS_10[2*10*10+1] = {
+    "00010203040506070809"
+    "10111213141516171819"
+    "20212223242526272829"
+    "30313233343536373839"
+    "40414243444546474849"
+    "50515253545556575859"
+    "60616263646566676869"
+    "70717273747576777879"
+    "80818283848586878889"
+    "90919293949596979899"
+};
+static const char DIGIT_PAIRS_8[2*8*8+1] = {
+    "0001020304050607"
+    "1011121314151617"
+    "2021222324252627"
+    "3031323334353637"
+    "4041424344454647"
+    "5051525354555657"
+    "6061626364656667"
+    "7071727374757677"
+};
+static const char DIGITS_HEX[2*16+1] = {
+    "0123456789abcdef"
+    "0123456789ABCDEF"
+};
+
+/* BuildPyUnicode */
+static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength,
+                                                int prepend_sign, char padding_char) {
+    PyObject *uval;
+    Py_ssize_t uoffset = ulength - clength;
+#if CYTHON_USE_UNICODE_INTERNALS
+    Py_ssize_t i;
+#if CYTHON_PEP393_ENABLED
+    void *udata;
+    uval = PyUnicode_New(ulength, 127);
+    if (unlikely(!uval)) return NULL;
+    udata = PyUnicode_DATA(uval);
+#else
+    Py_UNICODE *udata;
+    uval = PyUnicode_FromUnicode(NULL, ulength);
+    if (unlikely(!uval)) return NULL;
+    udata = PyUnicode_AS_UNICODE(uval);
+#endif
+    if (uoffset > 0) {
+        i = 0;
+        if (prepend_sign) {
+            __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-');
+            i++;
+        }
+        for (; i < uoffset; i++) {
+            __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char);
+        }
+    }
+    for (i=0; i < clength; i++) {
+        __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]);
+    }
+#else
+    {
+        PyObject *sign = NULL, *padding = NULL;
+        uval = NULL;
+        if (uoffset > 0) {
+            prepend_sign = !!prepend_sign;
+            if (uoffset > prepend_sign) {
+                padding = PyUnicode_FromOrdinal(padding_char);
+                if (likely(padding) && uoffset > prepend_sign + 1) {
+                    PyObject *tmp;
+                    PyObject *repeat = PyInt_FromSize_t(uoffset - prepend_sign);
+                    if (unlikely(!repeat)) goto done_or_error;
+                    tmp = PyNumber_Multiply(padding, repeat);
+                    Py_DECREF(repeat);
+                    Py_DECREF(padding);
+                    padding = tmp;
+                }
+                if (unlikely(!padding)) goto done_or_error;
+            }
+            if (prepend_sign) {
+                sign = PyUnicode_FromOrdinal('-');
+                if (unlikely(!sign)) goto done_or_error;
+            }
+        }
+        uval = PyUnicode_DecodeASCII(chars, clength, NULL);
+        if (likely(uval) && padding) {
+            PyObject *tmp = PyNumber_Add(padding, uval);
+            Py_DECREF(uval);
+            uval = tmp;
+        }
+        if (likely(uval) && sign) {
+            PyObject *tmp = PyNumber_Add(sign, uval);
+            Py_DECREF(uval);
+            uval = tmp;
+        }
+done_or_error:
+        Py_XDECREF(padding);
+        Py_XDECREF(sign);
+    }
+#endif
+    return uval;
+}
+
+/* CIntToPyUnicode */
+#ifdef _MSC_VER
+    #ifndef _MSC_STDINT_H_
+        #if _MSC_VER < 1300
+           typedef unsigned short    uint16_t;
+        #else
+           typedef unsigned __int16  uint16_t;
+        #endif
+    #endif
+#else
+   #include <stdint.h>
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) {
+    char digits[sizeof(Py_ssize_t)*3+2];
+    char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2;
+    const char *hex_digits = DIGITS_HEX;
+    Py_ssize_t length, ulength;
+    int prepend_sign, last_one_off;
+    Py_ssize_t remaining;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (format_char == 'X') {
+        hex_digits += 16;
+        format_char = 'x';
+    }
+    remaining = value;
+    last_one_off = 0;
+    dpos = end;
+    do {
+        int digit_pos;
+        switch (format_char) {
+        case 'o':
+            digit_pos = abs((int)(remaining % (8*8)));
+            remaining = (Py_ssize_t) (remaining / (8*8));
+            dpos -= 2;
+            *(uint16_t*)dpos = ((const uint16_t*)DIGIT_PAIRS_8)[digit_pos];
+            last_one_off = (digit_pos < 8);
+            break;
+        case 'd':
+            digit_pos = abs((int)(remaining % (10*10)));
+            remaining = (Py_ssize_t) (remaining / (10*10));
+            dpos -= 2;
+            *(uint16_t*)dpos = ((const uint16_t*)DIGIT_PAIRS_10)[digit_pos];
+            last_one_off = (digit_pos < 10);
+            break;
+        case 'x':
+            *(--dpos) = hex_digits[abs((int)(remaining % 16))];
+            remaining = (Py_ssize_t) (remaining / 16);
+            break;
+        default:
+            assert(0);
+            break;
+        }
+    } while (unlikely(remaining != 0));
+    if (last_one_off) {
+        assert(*dpos == '0');
+        dpos++;
+    }
+    length = end - dpos;
+    ulength = length;
+    prepend_sign = 0;
+    if (!is_unsigned && value <= neg_one) {
+        if (padding_char == ' ' || width <= length + 1) {
+            *(--dpos) = '-';
+            ++length;
+        } else {
+            prepend_sign = 1;
+        }
+        ++ulength;
+    }
+    if (width > ulength) {
+        ulength = width;
+    }
+    if (ulength == 1) {
+        return PyUnicode_FromOrdinal(*dpos);
+    }
+    return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char);
+}
+
+/* CIntToPyUnicode */
+#ifdef _MSC_VER
+    #ifndef _MSC_STDINT_H_
+        #if _MSC_VER < 1300
+           typedef unsigned short    uint16_t;
+        #else
+           typedef unsigned __int16  uint16_t;
+        #endif
+    #endif
+#else
+   #include <stdint.h>
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) {
+    char digits[sizeof(int)*3+2];
+    char *dpos, *end = digits + sizeof(int)*3+2;
+    const char *hex_digits = DIGITS_HEX;
+    Py_ssize_t length, ulength;
+    int prepend_sign, last_one_off;
+    int remaining;
+#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 (format_char == 'X') {
+        hex_digits += 16;
+        format_char = 'x';
+    }
+    remaining = value;
+    last_one_off = 0;
+    dpos = end;
+    do {
+        int digit_pos;
+        switch (format_char) {
+        case 'o':
+            digit_pos = abs((int)(remaining % (8*8)));
+            remaining = (int) (remaining / (8*8));
+            dpos -= 2;
+            *(uint16_t*)dpos = ((const uint16_t*)DIGIT_PAIRS_8)[digit_pos];
+            last_one_off = (digit_pos < 8);
+            break;
+        case 'd':
+            digit_pos = abs((int)(remaining % (10*10)));
+            remaining = (int) (remaining / (10*10));
+            dpos -= 2;
+            *(uint16_t*)dpos = ((const uint16_t*)DIGIT_PAIRS_10)[digit_pos];
+            last_one_off = (digit_pos < 10);
+            break;
+        case 'x':
+            *(--dpos) = hex_digits[abs((int)(remaining % 16))];
+            remaining = (int) (remaining / 16);
+            break;
+        default:
+            assert(0);
+            break;
+        }
+    } while (unlikely(remaining != 0));
+    if (last_one_off) {
+        assert(*dpos == '0');
+        dpos++;
+    }
+    length = end - dpos;
+    ulength = length;
+    prepend_sign = 0;
+    if (!is_unsigned && value <= neg_one) {
+        if (padding_char == ' ' || width <= length + 1) {
+            *(--dpos) = '-';
+            ++length;
+        } else {
+            prepend_sign = 1;
+        }
+        ++ulength;
+    }
+    if (width > ulength) {
+        ulength = width;
+    }
+    if (ulength == 1) {
+        return PyUnicode_FromOrdinal(*dpos);
+    }
+    return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char);
+}
+
+/* decode_c_bytes */
+static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes(
+         const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
+    if (unlikely((start < 0) | (stop < 0))) {
+        if (start < 0) {
+            start += length;
+            if (start < 0)
+                start = 0;
+        }
+        if (stop < 0)
+            stop += length;
+    }
+    if (stop > length)
+        stop = length;
+    if (unlikely(stop <= start))
+        return __Pyx_NewRef(__pyx_empty_unicode);
+    length = stop - start;
+    cstring += start;
+    if (decode_func) {
+        return decode_func(cstring, length, errors);
+    } else {
+        return PyUnicode_Decode(cstring, length, encoding, errors);
+    }
+}
+
+/* DelItemInt */
+static int __Pyx_DelItem_Generic(PyObject *o, PyObject *j) {
+    int r;
+    if (!j) return -1;
+    r = PyObject_DelItem(o, j);
+    Py_DECREF(j);
+    return r;
+}
+static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i,
+                                               CYTHON_UNUSED int is_list, CYTHON_NCP_UNUSED int wraparound) {
+#if !CYTHON_USE_TYPE_SLOTS
+    if (is_list || PySequence_Check(o)) {
+        return PySequence_DelItem(o, i);
+    }
+#else
+    PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
+    if (likely(m && m->sq_ass_item)) {
+        if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
+            Py_ssize_t l = m->sq_length(o);
+            if (likely(l >= 0)) {
+                i += l;
+            } else {
+                if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                    return -1;
+                PyErr_Clear();
+            }
+        }
+        return m->sq_ass_item(o, i, (PyObject *)NULL);
+    }
+#endif
+    return __Pyx_DelItem_Generic(o, PyInt_FromSsize_t(i));
+}
+
+/* StringJoin */
+#if !CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) {
+    return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL);
+}
+#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;
+    }
+    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
+        }
+    }
+bad:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(py_import);
+    #endif
+    Py_XDECREF(empty_list);
+    Py_XDECREF(empty_dict);
+    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)) {
+        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;
+}
+
+/* None */
+static CYTHON_INLINE long __Pyx_div_long(long a, long b) {
+    long q = a / b;
+    long r = a - q*b;
+    q -= ((r != 0) & ((r ^ b) < 0));
+    return q;
+}
+
+/* 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
+
+/* SetVTable */
+static int __Pyx_SetVtable(PyObject *dict, void *vtable) {
+#if PY_VERSION_HEX >= 0x02070000
+    PyObject *ob = PyCapsule_New(vtable, 0, 0);
+#else
+    PyObject *ob = PyCObject_FromVoidPtr(vtable, 0);
+#endif
+    if (!ob)
+        goto bad;
+    if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0)
+        goto bad;
+    Py_DECREF(ob);
+    return 0;
+bad:
+    Py_XDECREF(ob);
+    return -1;
+}
+
+/* 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 */
+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 int __Pyx_setup_reduce(PyObject* type_obj) {
+    int ret = 0;
+    PyObject *object_reduce = NULL;
+    PyObject *object_reduce_ex = NULL;
+    PyObject *reduce = NULL;
+    PyObject *reduce_ex = NULL;
+    PyObject *reduce_cython = NULL;
+    PyObject *setstate = NULL;
+    PyObject *setstate_cython = NULL;
+#if CYTHON_USE_PYTYPE_LOOKUP
+    if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
+#else
+    if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
+#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;
+#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_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);
+#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;
+#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;
+#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;
+    }
+    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;
+    }
+    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 (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* PatchInspect */
+static PyObject* __Pyx_patch_inspect(PyObject* module) {
+#if defined(__Pyx_Generator_USED) && (!defined(CYTHON_PATCH_INSPECT) || CYTHON_PATCH_INSPECT)
+    static int inspect_patched = 0;
+    if (unlikely((!inspect_patched) && module)) {
+        module = __Pyx_Coroutine_patch_module(
+            module, ""
+"old_types = getattr(_module.isgenerator, '_cython_generator_types', None)\n"
+"if old_types is None or not isinstance(old_types, set):\n"
+"    old_types = set()\n"
+"    def cy_wrap(orig_func, type=type, cython_generator_types=old_types):\n"
+"        def cy_isgenerator(obj): return type(obj) in cython_generator_types or orig_func(obj)\n"
+"        cy_isgenerator._cython_generator_types = cython_generator_types\n"
+"        return cy_isgenerator\n"
+"    _module.isgenerator = cy_wrap(_module.isgenerator)\n"
+"old_types.add(_cython_generator_type)\n"
+        );
+        inspect_patched = 1;
+    }
+#else
+    if ((0)) return __Pyx_Coroutine_patch_module(module, NULL);
+#endif
+    return module;
+}
+
+/* PatchAsyncIO */
+static PyObject* __Pyx_patch_asyncio(PyObject* module) {
+#if PY_VERSION_HEX < 0x030500B2 &&\
+        (defined(__Pyx_Coroutine_USED) || defined(__Pyx_Generator_USED)) &&\
+        (!defined(CYTHON_PATCH_ASYNCIO) || CYTHON_PATCH_ASYNCIO)
+    PyObject *patch_module = NULL;
+    static int asyncio_patched = 0;
+    if (unlikely((!asyncio_patched) && module)) {
+        PyObject *package;
+        package = __Pyx_Import(__pyx_n_s_asyncio_coroutines, NULL, 0);
+        if (package) {
+            patch_module = __Pyx_Coroutine_patch_module(
+                PyObject_GetAttrString(package, "coroutines"), ""
+"try:\n"
+"    coro_types = _module._COROUTINE_TYPES\n"
+"except AttributeError: pass\n"
+"else:\n"
+"    if _cython_coroutine_type is not None and _cython_coroutine_type not in coro_types:\n"
+"        coro_types = tuple(coro_types) + (_cython_coroutine_type,)\n"
+"    if _cython_generator_type is not None and _cython_generator_type not in coro_types:\n"
+"        coro_types = tuple(coro_types) + (_cython_generator_type,)\n"
+"_module._COROUTINE_TYPES = coro_types\n"
+            );
+        } else {
+            PyErr_Clear();
+            package = __Pyx_Import(__pyx_n_s_asyncio_tasks, NULL, 0);
+            if (unlikely(!package)) goto asyncio_done;
+            patch_module = __Pyx_Coroutine_patch_module(
+                PyObject_GetAttrString(package, "tasks"), ""
+"if hasattr(_module, 'iscoroutine'):\n"
+"    old_types = getattr(_module.iscoroutine, '_cython_coroutine_types', None)\n"
+"    if old_types is None or not isinstance(old_types, set):\n"
+"        old_types = set()\n"
+"        def cy_wrap(orig_func, type=type, cython_coroutine_types=old_types):\n"
+"            def cy_iscoroutine(obj): return type(obj) in cython_coroutine_types or orig_func(obj)\n"
+"            cy_iscoroutine._cython_coroutine_types = cython_coroutine_types\n"
+"            return cy_iscoroutine\n"
+"        _module.iscoroutine = cy_wrap(_module.iscoroutine)\n"
+"    if _cython_coroutine_type is not None:\n"
+"        old_types.add(_cython_coroutine_type)\n"
+"    if _cython_generator_type is not None:\n"
+"        old_types.add(_cython_generator_type)\n"
+            );
+        }
+        Py_DECREF(package);
+        if (unlikely(!patch_module)) goto ignore;
+asyncio_done:
+        PyErr_Clear();
+        asyncio_patched = 1;
+#ifdef __Pyx_Generator_USED
+        {
+            PyObject *inspect_module;
+            if (patch_module) {
+                inspect_module = PyObject_GetAttr(patch_module, __pyx_n_s_inspect);
+                Py_DECREF(patch_module);
+            } else {
+                inspect_module = __Pyx_Import(__pyx_n_s_inspect, NULL, 0);
+            }
+            if (unlikely(!inspect_module)) goto ignore;
+            inspect_module = __Pyx_patch_inspect(inspect_module);
+            if (unlikely(!inspect_module)) {
+                Py_DECREF(module);
+                module = NULL;
+            }
+            Py_XDECREF(inspect_module);
+        }
+#else
+        if ((0)) return __Pyx_patch_inspect(module);
+#endif
+    }
+    return module;
+ignore:
+    PyErr_WriteUnraisable(module);
+    if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch asyncio package with custom generator type", 1) < 0)) {
+        Py_DECREF(module);
+        module = NULL;
+    }
+#else
+    if ((0)) return __Pyx_patch_inspect(__Pyx_Coroutine_patch_module(module, NULL));
+#endif
+    return module;
+}
+
+/* CalculateMetaclass */
+static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) {
+    Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases);
+    for (i=0; i < nbases; i++) {
+        PyTypeObject *tmptype;
+        PyObject *tmp = PyTuple_GET_ITEM(bases, i);
+        tmptype = Py_TYPE(tmp);
+#if PY_MAJOR_VERSION < 3
+        if (tmptype == &PyClass_Type)
+            continue;
+#endif
+        if (!metaclass) {
+            metaclass = tmptype;
+            continue;
+        }
+        if (PyType_IsSubtype(metaclass, tmptype))
+            continue;
+        if (PyType_IsSubtype(tmptype, metaclass)) {
+            metaclass = tmptype;
+            continue;
+        }
+        PyErr_SetString(PyExc_TypeError,
+                        "metaclass conflict: "
+                        "the metaclass of a derived class "
+                        "must be a (non-strict) subclass "
+                        "of the metaclasses of all its bases");
+        return NULL;
+    }
+    if (!metaclass) {
+#if PY_MAJOR_VERSION < 3
+        metaclass = &PyClass_Type;
+#else
+        metaclass = &PyType_Type;
+#endif
+    }
+    Py_INCREF((PyObject*) metaclass);
+    return (PyObject*) metaclass;
+}
+
+/* Py3ClassCreate */
+static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name,
+                                           PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) {
+    PyObject *ns;
+    if (metaclass) {
+        PyObject *prep = __Pyx_PyObject_GetAttrStr(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);
+            Py_DECREF(prep);
+            Py_DECREF(pargs);
+        } else {
+            if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError)))
+                return NULL;
+            PyErr_Clear();
+            ns = PyDict_New();
+        }
+    } else {
+        ns = PyDict_New();
+    }
+    if (unlikely(!ns))
+        return NULL;
+    if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad;
+    if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad;
+    if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad;
+    return ns;
+bad:
+    Py_DECREF(ns);
+    return NULL;
+}
+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 *owned_metaclass = NULL;
+    if (allow_py2_metaclass) {
+        owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass);
+        if (owned_metaclass) {
+            metaclass = owned_metaclass;
+        } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) {
+            PyErr_Clear();
+        } else {
+            return NULL;
+        }
+    }
+    if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) {
+        metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases);
+        Py_XDECREF(owned_metaclass);
+        if (unlikely(!metaclass))
+            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;
+}
+
+/* CLineInTraceback */
+#ifndef CYTHON_CLINE_IN_TRACEBACK
+static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+    PyObject *use_cline;
+    PyObject *ptype, *pvalue, *ptraceback;
+#if CYTHON_COMPILING_IN_CPYTHON
+    PyObject **cython_runtime_dict;
+#endif
+    if (unlikely(!__pyx_cython_runtime)) {
+        return c_line;
+    }
+    __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
+#if CYTHON_COMPILING_IN_CPYTHON
+    cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
+    if (likely(cython_runtime_dict)) {
+        __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
+            use_cline, *cython_runtime_dict,
+            __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback))
+    } else
+#endif
+    {
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__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);
+      } else {
+        PyErr_Clear();
+        use_cline = NULL;
+      }
+    }
+    if (!use_cline) {
+        c_line = 0;
+        PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False);
+    }
+    else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
+        c_line = 0;
+    }
+    __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
+    return c_line;
+}
+#endif
+
+/* CodeObjectCache */
+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) {
+        return count;
+    }
+    while (start < end) {
+        mid = start + (end - start) / 2;
+        if (code_line < entries[mid].code_line) {
+            end = mid;
+        } else if (code_line > entries[mid].code_line) {
+             start = mid + 1;
+        } else {
+            return mid;
+        }
+    }
+    if (code_line <= entries[mid].code_line) {
+        return mid;
+    } else {
+        return mid + 1;
+    }
+}
+static PyCodeObject *__pyx_find_code_object(int code_line) {
+    PyCodeObject* code_object;
+    int pos;
+    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
+        return NULL;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
+        return NULL;
+    }
+    code_object = __pyx_code_cache.entries[pos].code_object;
+    Py_INCREF(code_object);
+    return code_object;
+}
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
+    int pos, i;
+    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    if (unlikely(!code_line)) {
+        return;
+    }
+    if (unlikely(!entries)) {
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (likely(entries)) {
+            __pyx_code_cache.entries = entries;
+            __pyx_code_cache.max_count = 64;
+            __pyx_code_cache.count = 1;
+            entries[0].code_line = code_line;
+            entries[0].code_object = code_object;
+            Py_INCREF(code_object);
+        }
+        return;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
+        PyCodeObject* tmp = entries[pos].code_object;
+        entries[pos].code_object = code_object;
+        Py_DECREF(tmp);
+        return;
+    }
+    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
+        int new_max = __pyx_code_cache.max_count + 64;
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
+            __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));
+        if (unlikely(!entries)) {
+            return;
+        }
+        __pyx_code_cache.entries = entries;
+        __pyx_code_cache.max_count = new_max;
+    }
+    for (i=__pyx_code_cache.count; i>pos; i--) {
+        entries[i] = entries[i-1];
+    }
+    entries[pos].code_line = code_line;
+    entries[pos].code_object = code_object;
+    __pyx_code_cache.count++;
+    Py_INCREF(code_object);
+}
+
+/* AddTraceback */
+#include "compile.h"
+#include "frameobject.h"
+#include "traceback.h"
+static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
+            const char *funcname, int c_line,
+            int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyObject *py_srcfile = 0;
+    PyObject *py_funcname = 0;
+    #if PY_MAJOR_VERSION < 3
+    py_srcfile = PyString_FromString(filename);
+    #else
+    py_srcfile = PyUnicode_FromString(filename);
+    #endif
+    if (!py_srcfile) goto bad;
+    if (c_line) {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #else
+        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #endif
+    }
+    else {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromString(funcname);
+        #else
+        py_funcname = PyUnicode_FromString(funcname);
+        #endif
+    }
+    if (!py_funcname) goto bad;
+    py_code = __Pyx_PyCode_New(
+        0,
+        0,
+        0,
+        0,
+        0,
+        __pyx_empty_bytes, /*PyObject *code,*/
+        __pyx_empty_tuple, /*PyObject *consts,*/
+        __pyx_empty_tuple, /*PyObject *names,*/
+        __pyx_empty_tuple, /*PyObject *varnames,*/
+        __pyx_empty_tuple, /*PyObject *freevars,*/
+        __pyx_empty_tuple, /*PyObject *cellvars,*/
+        py_srcfile,   /*PyObject *filename,*/
+        py_funcname,  /*PyObject *name,*/
+        py_line,
+        __pyx_empty_bytes  /*PyObject *lnotab*/
+    );
+    Py_DECREF(py_srcfile);
+    Py_DECREF(py_funcname);
+    return py_code;
+bad:
+    Py_XDECREF(py_srcfile);
+    Py_XDECREF(py_funcname);
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyFrameObject *py_frame = 0;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    if (c_line) {
+        c_line = __Pyx_CLineForTraceback(tstate, c_line);
+    }
+    py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
+    if (!py_code) {
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, c_line, py_line, filename);
+        if (!py_code) goto bad;
+        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
+    }
+    py_frame = PyFrame_New(
+        tstate,            /*PyThreadState *tstate,*/
+        py_code,           /*PyCodeObject *code,*/
+        __pyx_d,    /*PyObject *globals,*/
+        0                  /*PyObject *locals*/
+    );
+    if (!py_frame) goto bad;
+    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
+    PyTraceBack_Here(py_frame);
+bad:
+    Py_XDECREF(py_code);
+    Py_XDECREF(py_frame);
+}
+
+/* CIntFromPyVerify */
+#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
+#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
+#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
+    {\
+        func_type value = func_value;\
+        if (sizeof(target_type) < sizeof(func_type)) {\
+            if (unlikely(value != (func_type) (target_type) value)) {\
+                func_type zero = 0;\
+                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
+                    return (target_type) -1;\
+                if (is_unsigned && unlikely(value < zero))\
+                    goto raise_neg_overflow;\
+                else\
+                    goto raise_overflow;\
+            }\
+        }\
+        return (target_type) value;\
+    }
+
+/* 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
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
+#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 PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(int) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        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])
+                case 2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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;
+            }
+#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;
+            }
+#endif
+            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))
+#endif
+            }
+        } 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])
+                case -2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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))
+#ifdef HAVE_LONG_LONG
+            } 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");
+#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);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            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:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to int");
+    return (int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to int");
+    return (int) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const int64_t neg_one = (int64_t) -1, const_zero = (int64_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(int64_t) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(int64_t, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (int64_t) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int64_t) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(int64_t, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(int64_t) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int64_t) >= 2 * PyLong_SHIFT) {
+                            return (int64_t) (((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int64_t) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int64_t) >= 3 * PyLong_SHIFT) {
+                            return (int64_t) (((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int64_t) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int64_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(int64_t) >= 4 * PyLong_SHIFT) {
+                            return (int64_t) (((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            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 (int64_t) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(int64_t) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int64_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int64_t) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int64_t) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(int64_t, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(int64_t,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(int64_t) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) {
+                            return (int64_t) (((int64_t)-1)*(((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(int64_t) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) {
+                            return (int64_t) ((((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) {
+                            return (int64_t) (((int64_t)-1)*(((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int64_t) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) {
+                            return (int64_t) ((((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int64_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(int64_t) - 1 > 4 * PyLong_SHIFT) {
+                            return (int64_t) (((int64_t)-1)*(((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int64_t) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int64_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(int64_t) - 1 > 4 * PyLong_SHIFT) {
+                            return (int64_t) ((((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(int64_t) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int64_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int64_t) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int64_t, 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");
+#else
+            int64_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);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (int64_t) -1;
+        }
+    } else {
+        int64_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int64_t) -1;
+        val = __Pyx_PyInt_As_int64_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to int64_t");
+    return (int64_t) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to int64_t");
+    return (int64_t) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(uint64_t) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(uint64_t, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (uint64_t) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (uint64_t) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(uint64_t) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(uint64_t) >= 2 * PyLong_SHIFT) {
+                            return (uint64_t) (((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(uint64_t) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(uint64_t) >= 3 * PyLong_SHIFT) {
+                            return (uint64_t) (((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(uint64_t) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(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(uint64_t) >= 4 * PyLong_SHIFT) {
+                            return (uint64_t) (((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            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 (uint64_t) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(uint64_t) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (uint64_t) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(uint64_t, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(uint64_t,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(uint64_t) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) {
+                            return (uint64_t) (((uint64_t)-1)*(((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(uint64_t) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) {
+                            return (uint64_t) ((((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) {
+                            return (uint64_t) (((uint64_t)-1)*(((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(uint64_t) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) {
+                            return (uint64_t) ((((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(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(uint64_t) - 1 > 4 * PyLong_SHIFT) {
+                            return (uint64_t) (((uint64_t)-1)*(((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(uint64_t) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(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(uint64_t) - 1 > 4 * PyLong_SHIFT) {
+                            return (uint64_t) ((((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(uint64_t) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(uint64_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(uint64_t, 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");
+#else
+            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);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (uint64_t) -1;
+        }
+    } else {
+        uint64_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (uint64_t) -1;
+        val = __Pyx_PyInt_As_uint64_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to uint64_t");
+    return (uint64_t) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to uint64_t");
+    return (uint64_t) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(long) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (long) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        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])
+                case 2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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;
+            }
+#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;
+            }
+#endif
+            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))
+#endif
+            }
+        } 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])
+                case -2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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))
+#ifdef HAVE_LONG_LONG
+            } 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");
+#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;
+            }
+#endif
+            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:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to long");
+    return (long) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to long");
+    return (long) -1;
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(uint64_t) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(uint64_t) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(uint64_t) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(uint64_t),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(long) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(long) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(long),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const unsigned long neg_one = (unsigned long) -1, const_zero = (unsigned long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(unsigned long) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(unsigned long, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (unsigned long) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        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])
+                case 2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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;
+            }
+#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;
+            }
+#endif
+            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))
+#endif
+            }
+        } 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])
+                case -2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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))
+#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))
+#endif
+            }
+        }
+        {
+#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);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            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:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to unsigned long");
+    return (unsigned long) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to unsigned long");
+    return (unsigned long) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(unsigned int) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (unsigned int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        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])
+                case 2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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;
+            }
+#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;
+            }
+#endif
+            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))
+#endif
+            }
+        } 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])
+                case -2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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))
+#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))
+#endif
+            }
+        }
+        {
+#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);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            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:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to unsigned int");
+    return (unsigned int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to unsigned int");
+    return (unsigned int) -1;
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(uint32_t) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(uint32_t) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(uint32_t) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(uint32_t) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(uint32_t),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const size_t neg_one = (size_t) -1, const_zero = (size_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(size_t) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (size_t) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        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])
+                case 2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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;
+            }
+#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;
+            }
+#endif
+            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))
+#endif
+            }
+        } 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])
+                case -2:
+                    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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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) {
+                            __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) {
+                            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))
+#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))
+#endif
+            }
+        }
+        {
+#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);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            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:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to size_t");
+    return (size_t) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to size_t");
+    return (size_t) -1;
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_short(unsigned short value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const unsigned short neg_one = (unsigned short) -1, const_zero = (unsigned short) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(unsigned short) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(unsigned short) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(unsigned short) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(unsigned short) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(unsigned short) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(unsigned short),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_volatile__int(volatile int value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const volatile int neg_one = (volatile int) -1, const_zero = (volatile 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(volatile int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(volatile int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(volatile int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(volatile int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(volatile int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(volatile int),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const int64_t neg_one = (int64_t) -1, const_zero = (int64_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int64_t) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int64_t) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int64_t) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int64_t) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int64_t) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(int64_t),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const unsigned long neg_one = (unsigned long) -1, const_zero = (unsigned long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(unsigned long) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(unsigned long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(unsigned long) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(unsigned long) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(unsigned long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(unsigned long),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum____pyx_t_6uvloop_4loop_SSLProtocolState(enum __pyx_t_6uvloop_4loop_SSLProtocolState value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const enum __pyx_t_6uvloop_4loop_SSLProtocolState neg_one = (enum __pyx_t_6uvloop_4loop_SSLProtocolState) -1, const_zero = (enum __pyx_t_6uvloop_4loop_SSLProtocolState) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(enum __pyx_t_6uvloop_4loop_SSLProtocolState) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(enum __pyx_t_6uvloop_4loop_SSLProtocolState) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum __pyx_t_6uvloop_4loop_SSLProtocolState) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(enum __pyx_t_6uvloop_4loop_SSLProtocolState) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum __pyx_t_6uvloop_4loop_SSLProtocolState) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(enum __pyx_t_6uvloop_4loop_SSLProtocolState),
+                                     little, !is_unsigned);
+    }
+}
+
+/* IterableCoroutine */
+static PyTypeObject __pyx_IterableCoroutineType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    "iterable_coroutine",
+    sizeof(__pyx_CoroutineObject),
+    0,
+    (destructor) __Pyx_Coroutine_dealloc,
+    0,
+    0,
+    0,
+#if CYTHON_USE_ASYNC_SLOTS
+    &__pyx_Coroutine_as_async,
+#else
+    0,
+#endif
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,
+    0,
+    (traverseproc) __Pyx_Coroutine_traverse,
+    0,
+#if CYTHON_USE_ASYNC_SLOTS && CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 && PY_VERSION_HEX < 0x030500B1
+    __Pyx_Coroutine_compare,
+#else
+    0,
+#endif
+    offsetof(__pyx_CoroutineObject, gi_weakreflist),
+    __Pyx_Coroutine_await,
+    (iternextfunc) __Pyx_Generator_Next,
+    __pyx_Coroutine_methods,
+    __pyx_Coroutine_memberlist,
+    __pyx_Coroutine_getsets,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#else
+    __Pyx_Coroutine_del,
+#endif
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    __Pyx_Coroutine_del,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+    0,
+#endif
+};
+static int __pyx_IterableCoroutine_init(void) {
+    __pyx_IterableCoroutineType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+    __pyx_IterableCoroutineType = __Pyx_FetchCommonType(&__pyx_IterableCoroutineType_type);
+    if (unlikely(!__pyx_IterableCoroutineType))
+        return -1;
+    return 0;
+}
+
+/* Generator */
+static PyMethodDef __pyx_Generator_methods[] = {
+    {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O,
+     (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")},
+    {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS,
+     (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")},
+    {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS,
+     (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")},
+    {0, 0, 0, 0}
+};
+static PyMemberDef __pyx_Generator_memberlist[] = {
+    {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL},
+    {(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},
+    {0, 0, 0, 0, 0}
+};
+static PyGetSetDef __pyx_Generator_getsets[] = {
+    {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name,
+     (char*) PyDoc_STR("name of the generator"), 0},
+    {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname,
+     (char*) PyDoc_STR("qualified name of the generator"), 0},
+    {(char *) "gi_frame", (getter)__Pyx_Coroutine_get_frame, NULL,
+     (char*) PyDoc_STR("Frame of the generator"), 0},
+    {0, 0, 0, 0, 0}
+};
+static PyTypeObject __pyx_GeneratorType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    "generator",
+    sizeof(__pyx_CoroutineObject),
+    0,
+    (destructor) __Pyx_Coroutine_dealloc,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,
+    0,
+    (traverseproc) __Pyx_Coroutine_traverse,
+    0,
+    0,
+    offsetof(__pyx_CoroutineObject, gi_weakreflist),
+    0,
+    (iternextfunc) __Pyx_Generator_Next,
+    __pyx_Generator_methods,
+    __pyx_Generator_memberlist,
+    __pyx_Generator_getsets,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if CYTHON_USE_TP_FINALIZE
+    0,
+#else
+    __Pyx_Coroutine_del,
+#endif
+    0,
+#if CYTHON_USE_TP_FINALIZE
+    __Pyx_Coroutine_del,
+#elif PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+    0,
+#endif
+};
+static int __pyx_Generator_init(void) {
+    __pyx_GeneratorType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+    __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter;
+    __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type);
+    if (unlikely(!__pyx_GeneratorType)) {
+        return -1;
+    }
+    return 0;
+}
+
+/* CheckBinaryVersion */
+static int __Pyx_check_binary_version(void) {
+    char ctversion[4], rtversion[4];
+    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
+    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
+    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
+        char message[200];
+        PyOS_snprintf(message, sizeof(message),
+                      "compiletime version %s of module '%.100s' "
+                      "does not match runtime version %s",
+                      ctversion, __Pyx_MODULE_NAME, rtversion);
+        return PyErr_WarnEx(NULL, message, 1);
+    }
+    return 0;
+}
+
+/* InitStrings */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
+    while (t->p) {
+        #if PY_MAJOR_VERSION < 3
+        if (t->is_unicode) {
+            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
+        } else if (t->intern) {
+            *t->p = PyString_InternFromString(t->s);
+        } 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;
+        ++t;
+    }
+    return 0;
+}
+
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+}
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
+    Py_ssize_t ignore;
+    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#if !CYTHON_PEP393_ENABLED
+static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    char* defenc_c;
+    PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
+    if (!defenc) return NULL;
+    defenc_c = PyBytes_AS_STRING(defenc);
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    {
+        char* end = defenc_c + PyBytes_GET_SIZE(defenc);
+        char* c;
+        for (c = defenc_c; c < end; c++) {
+            if ((unsigned char) (*c) >= 128) {
+                PyUnicode_AsASCIIString(o);
+                return NULL;
+            }
+        }
+    }
+#endif
+    *length = PyBytes_GET_SIZE(defenc);
+    return defenc_c;
+}
+#else
+static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    if (likely(PyUnicode_IS_ASCII(o))) {
+        *length = PyUnicode_GET_LENGTH(o);
+        return PyUnicode_AsUTF8(o);
+    } else {
+        PyUnicode_AsASCIIString(o);
+        return NULL;
+    }
+#else
+    return PyUnicode_AsUTF8AndSize(o, length);
+#endif
+}
+#endif
+#endif
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+    if (
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+            __Pyx_sys_getdefaultencoding_not_ascii &&
+#endif
+            PyUnicode_Check(o)) {
+        return __Pyx_PyUnicode_AsStringAndSize(o, length);
+    } else
+#endif
+#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+    if (PyByteArray_Check(o)) {
+        *length = PyByteArray_GET_SIZE(o);
+        return PyByteArray_AS_STRING(o);
+    } else
+#endif
+    {
+        char* result;
+        int r = PyBytes_AsStringAndSize(o, &result, length);
+        if (unlikely(r < 0)) {
+            return NULL;
+        } else {
+            return result;
+        }
+    }
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+   int is_true = x == Py_True;
+   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
+   else return PyObject_IsTrue(x);
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
+    int retval;
+    if (unlikely(!x)) return -1;
+    retval = __Pyx_PyObject_IsTrue(x);
+    Py_DECREF(x);
+    return retval;
+}
+static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+#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)) {
+            Py_DECREF(result);
+            return NULL;
+        }
+        return result;
+    }
+#endif
+    PyErr_Format(PyExc_TypeError,
+                 "__%.4s__ returned non-%.4s (type %.200s)",
+                 type_name, type_name, Py_TYPE(result)->tp_name);
+    Py_DECREF(result);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
+#if CYTHON_USE_TYPE_SLOTS
+  PyNumberMethods *m;
+#endif
+  const char *name = NULL;
+  PyObject *res = NULL;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_Check(x) || PyLong_Check(x)))
+#else
+  if (likely(PyLong_Check(x)))
+#endif
+    return __Pyx_NewRef(x);
+#if CYTHON_USE_TYPE_SLOTS
+  m = Py_TYPE(x)->tp_as_number;
+  #if PY_MAJOR_VERSION < 3
+  if (m && m->nb_int) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  else if (m && m->nb_long) {
+    name = "long";
+    res = m->nb_long(x);
+  }
+  #else
+  if (likely(m && m->nb_int)) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  #endif
+#else
+  if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
+    res = PyNumber_Int(x);
+  }
+#endif
+  if (likely(res)) {
+#if PY_MAJOR_VERSION < 3
+    if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) {
+#else
+    if (unlikely(!PyLong_CheckExact(res))) {
+#endif
+        return __Pyx_PyNumber_IntOrLongWrongResultType(res, name);
+    }
+  }
+  else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_TypeError,
+                    "an integer is required");
+  }
+  return res;
+}
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+  Py_ssize_t ival;
+  PyObject *x;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_CheckExact(b))) {
+    if (sizeof(Py_ssize_t) >= sizeof(long))
+        return PyInt_AS_LONG(b);
+    else
+        return PyInt_AsSsize_t(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;
+    } else {
+      switch (size) {
+         case 2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((((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(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return -(Py_ssize_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
+    return PyLong_AsSsize_t(b);
+  }
+  x = PyNumber_Index(b);
+  if (!x) return -1;
+  ival = PyInt_AsSsize_t(x);
+  Py_DECREF(x);
+  return ival;
+}
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
+  return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);
+}
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+    return PyInt_FromSize_t(ival);
+}
+
+
+#endif /* Py_PYTHON_H */
diff --git a/myenv/lib/python3.9/site-packages/uvloop/loop.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/uvloop/loop.cpython-39-darwin.so
new file mode 100755
index 0000000..30f4603
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/uvloop/loop.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/uvloop/loop.pxd b/myenv/lib/python3.9/site-packages/uvloop/loop.pxd
new file mode 100644
index 0000000..06bee85
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/loop.pxd
@@ -0,0 +1,229 @@
+# cython: language_level=3
+
+
+from .includes cimport uv
+from .includes cimport system
+
+from libc.stdint cimport uint64_t, uint32_t, int64_t
+
+
+include "includes/consts.pxi"
+
+
+cdef extern from *:
+    ctypedef int vint "volatile int"
+
+
+cdef class UVHandle
+cdef class UVSocketHandle(UVHandle)
+
+cdef class UVAsync(UVHandle)
+cdef class UVTimer(UVHandle)
+cdef class UVIdle(UVHandle)
+
+cdef class UVBaseTransport(UVSocketHandle)
+
+ctypedef object (*method_t)(object)
+ctypedef object (*method1_t)(object, object)
+ctypedef object (*method2_t)(object, object, object)
+ctypedef object (*method3_t)(object, object, object, object)
+
+
+cdef class Loop:
+    cdef:
+        uv.uv_loop_t *uvloop
+
+        bint _coroutine_debug_set
+        int _coroutine_origin_tracking_saved_depth
+
+        public slow_callback_duration
+
+        readonly bint _closed
+        bint _debug
+        bint _running
+        bint _stopping
+
+        uint64_t _thread_id
+        bint _thread_is_main
+
+        object _task_factory
+        object _exception_handler
+        object _default_executor
+        object _ready
+        set _queued_streams
+        Py_ssize_t _ready_len
+
+        set _servers
+
+        object _transports
+        set _processes
+        dict _fd_to_reader_fileobj
+        dict _fd_to_writer_fileobj
+
+        set _signals
+        dict _signal_handlers
+        object _ssock
+        object _csock
+        bint _listening_signals
+        int _old_signal_wakeup_id
+
+        set _timers
+        dict _polls
+
+        UVProcess active_process_handler
+
+        UVAsync handler_async
+        UVIdle handler_idle
+        UVCheck handler_check__exec_writes
+
+        object _last_error
+
+        cdef object __weakref__
+
+        object _asyncgens
+        bint _asyncgens_shutdown_called
+
+        bint _executor_shutdown_called
+
+        char _recv_buffer[UV_STREAM_RECV_BUF_SIZE]
+        bint _recv_buffer_in_use
+
+        # DEBUG fields
+        # True when compiled with DEBUG.
+        # Used only in unittests.
+        readonly bint _debug_cc
+
+        readonly object _debug_handles_total
+        readonly object _debug_handles_closed
+        readonly object _debug_handles_current
+
+        readonly uint64_t _debug_uv_handles_total
+        readonly uint64_t _debug_uv_handles_freed
+
+        readonly uint64_t _debug_cb_handles_total
+        readonly uint64_t _debug_cb_handles_count
+        readonly uint64_t _debug_cb_timer_handles_total
+        readonly uint64_t _debug_cb_timer_handles_count
+
+        readonly uint64_t _debug_stream_shutdown_errors_total
+        readonly uint64_t _debug_stream_listen_errors_total
+
+        readonly uint64_t _debug_stream_read_cb_total
+        readonly uint64_t _debug_stream_read_cb_errors_total
+        readonly uint64_t _debug_stream_read_eof_total
+        readonly uint64_t _debug_stream_read_eof_cb_errors_total
+        readonly uint64_t _debug_stream_read_errors_total
+
+        readonly uint64_t _debug_stream_write_tries
+        readonly uint64_t _debug_stream_write_errors_total
+        readonly uint64_t _debug_stream_write_ctx_total
+        readonly uint64_t _debug_stream_write_ctx_cnt
+        readonly uint64_t _debug_stream_write_cb_errors_total
+
+        readonly uint64_t _poll_read_events_total
+        readonly uint64_t _poll_read_cb_errors_total
+        readonly uint64_t _poll_write_events_total
+        readonly uint64_t _poll_write_cb_errors_total
+
+        readonly uint64_t _sock_try_write_total
+
+        readonly uint64_t _debug_exception_handler_cnt
+
+    cdef _init_debug_fields(self)
+
+    cdef _on_wake(self)
+    cdef _on_idle(self)
+
+    cdef __run(self, uv.uv_run_mode)
+    cdef _run(self, uv.uv_run_mode)
+
+    cdef _close(self)
+    cdef _stop(self, exc)
+    cdef uint64_t _time(self)
+
+    cdef inline _queue_write(self, UVStream stream)
+    cdef _exec_queued_writes(self)
+
+    cdef inline _call_soon(self, object callback, object args, object context)
+    cdef inline _append_ready_handle(self, Handle handle)
+    cdef inline _call_soon_handle(self, Handle handle)
+
+    cdef _call_later(self, uint64_t delay, object callback, object args,
+                     object context)
+
+    cdef void _handle_exception(self, object ex)
+
+    cdef inline _is_main_thread(self)
+
+    cdef inline _new_future(self)
+    cdef inline _check_signal(self, sig)
+    cdef inline _check_closed(self)
+    cdef inline _check_thread(self)
+
+    cdef _getaddrinfo(self, object host, object port,
+                      int family, int type,
+                      int proto, int flags,
+                      int unpack)
+
+    cdef _getnameinfo(self, system.sockaddr *addr, int flags)
+
+    cdef _track_transport(self, UVBaseTransport transport)
+    cdef _fileobj_to_fd(self, fileobj)
+    cdef _ensure_fd_no_transport(self, fd)
+
+    cdef _track_process(self, UVProcess proc)
+    cdef _untrack_process(self, UVProcess proc)
+
+    cdef _add_reader(self, fd, Handle handle)
+    cdef _has_reader(self, fd)
+    cdef _remove_reader(self, fd)
+
+    cdef _add_writer(self, fd, Handle handle)
+    cdef _has_writer(self, fd)
+    cdef _remove_writer(self, fd)
+
+    cdef _sock_recv(self, fut, sock, n)
+    cdef _sock_recv_into(self, fut, sock, buf)
+    cdef _sock_sendall(self, fut, sock, data)
+    cdef _sock_accept(self, fut, sock)
+
+    cdef _sock_connect(self, sock, address)
+    cdef _sock_connect_cb(self, fut, sock, address)
+
+    cdef _sock_set_reuseport(self, int fd)
+
+    cdef _setup_or_resume_signals(self)
+    cdef _shutdown_signals(self)
+    cdef _pause_signals(self)
+
+    cdef _handle_signal(self, sig)
+    cdef _read_from_self(self)
+    cdef inline _ceval_process_signals(self)
+    cdef _invoke_signals(self, bytes data)
+
+    cdef _set_coroutine_debug(self, bint enabled)
+
+    cdef _print_debug_info(self)
+
+
+include "cbhandles.pxd"
+
+include "handles/handle.pxd"
+include "handles/async_.pxd"
+include "handles/idle.pxd"
+include "handles/check.pxd"
+include "handles/timer.pxd"
+include "handles/poll.pxd"
+include "handles/basetransport.pxd"
+include "handles/stream.pxd"
+include "handles/streamserver.pxd"
+include "handles/tcp.pxd"
+include "handles/pipe.pxd"
+include "handles/process.pxd"
+
+include "request.pxd"
+include "sslproto.pxd"
+
+include "handles/udp.pxd"
+
+include "server.pxd"
diff --git a/myenv/lib/python3.9/site-packages/uvloop/loop.pyi b/myenv/lib/python3.9/site-packages/uvloop/loop.pyi
new file mode 100644
index 0000000..39285fc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/loop.pyi
@@ -0,0 +1,289 @@
+import asyncio
+import ssl
+from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket
+from typing import (
+    IO,
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+    overload,
+)
+
+_T = TypeVar('_T')
+_Context = Dict[str, Any]
+_ExceptionHandler = Callable[[asyncio.AbstractEventLoop, _Context], Any]
+_SSLContext = Union[bool, None, ssl.SSLContext]
+
+class Loop:
+    def call_soon(
+        self, callback: Callable[..., Any], *args: Any, context: Optional[Any] = ...
+    ) -> asyncio.Handle: ...
+    def call_soon_threadsafe(
+        self, callback: Callable[..., Any], *args: Any, context: Optional[Any] = ...
+    ) -> asyncio.Handle: ...
+    def call_later(
+        self, delay: float, callback: Callable[..., Any], *args: Any, context: Optional[Any] = ...
+    ) -> asyncio.TimerHandle: ...
+    def call_at(
+        self, when: float, callback: Callable[..., Any], *args: Any, context: Optional[Any] = ...
+    ) -> asyncio.TimerHandle: ...
+    def time(self) -> float: ...
+    def stop(self) -> None: ...
+    def run_forever(self) -> None: ...
+    def close(self) -> None: ...
+    def get_debug(self) -> bool: ...
+    def set_debug(self, enabled: bool) -> None: ...
+    def is_running(self) -> bool: ...
+    def is_closed(self) -> bool: ...
+    def create_future(self) -> asyncio.Future[Any]: ...
+    def create_task(
+        self,
+        coro: Union[Awaitable[_T], Generator[Any, None, _T]],
+        *,
+        name: Optional[str] = ...,
+    ) -> asyncio.Task[_T]: ...
+    def set_task_factory(
+        self,
+        factory: Optional[
+            Callable[[asyncio.AbstractEventLoop, Generator[Any, None, _T]], asyncio.Future[_T]]
+        ],
+    ) -> None: ...
+    def get_task_factory(
+        self,
+    ) -> Optional[
+        Callable[[asyncio.AbstractEventLoop, Generator[Any, None, _T]], asyncio.Future[_T]]
+    ]: ...
+    @overload
+    def run_until_complete(self, future: Generator[Any, None, _T]) -> _T: ...
+    @overload
+    def run_until_complete(self, future: Awaitable[_T]) -> _T: ...
+    async def getaddrinfo(
+        self,
+        host: Optional[Union[str, bytes]],
+        port: Optional[Union[str, bytes, int]],
+        *,
+        family: int = ...,
+        type: int = ...,
+        proto: int = ...,
+        flags: int = ...,
+    ) -> List[
+        Tuple[
+            AddressFamily,
+            SocketKind,
+            int,
+            str,
+            Union[Tuple[str, int], Tuple[str, int, int, int]],
+        ]
+    ]: ...
+    async def getnameinfo(
+        self,
+        sockaddr: Union[
+            Tuple[str, int],
+            Tuple[str, int, int],
+            Tuple[str, int, int, int]
+        ],
+        flags: int = ...,
+    ) -> Tuple[str, str]: ...
+    async def start_tls(
+        self,
+        transport: asyncio.BaseTransport,
+        protocol: asyncio.BaseProtocol,
+        sslcontext: ssl.SSLContext,
+        *,
+        server_side: bool = ...,
+        server_hostname: Optional[str] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+    ) -> asyncio.BaseTransport: ...
+    @overload
+    async def create_server(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        host: Optional[Union[str, Sequence[str]]] = ...,
+        port: int = ...,
+        *,
+        family: int = ...,
+        flags: int = ...,
+        sock: None = ...,
+        backlog: int = ...,
+        ssl: _SSLContext = ...,
+        reuse_address: Optional[bool] = ...,
+        reuse_port: Optional[bool] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+        start_serving: bool = ...,
+    ) -> asyncio.AbstractServer: ...
+    @overload
+    async def create_server(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        host: None = ...,
+        port: None = ...,
+        *,
+        family: int = ...,
+        flags: int = ...,
+        sock: socket = ...,
+        backlog: int = ...,
+        ssl: _SSLContext = ...,
+        reuse_address: Optional[bool] = ...,
+        reuse_port: Optional[bool] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+        start_serving: bool = ...,
+    ) -> asyncio.AbstractServer: ...
+    @overload
+    async def create_connection(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        host: str = ...,
+        port: int = ...,
+        *,
+        ssl: _SSLContext = ...,
+        family: int = ...,
+        proto: int = ...,
+        flags: int = ...,
+        sock: None = ...,
+        local_addr: Optional[Tuple[str, int]] = ...,
+        server_hostname: Optional[str] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+    ) -> asyncio.events._TransProtPair: ...
+    @overload
+    async def create_connection(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        host: None = ...,
+        port: None = ...,
+        *,
+        ssl: _SSLContext = ...,
+        family: int = ...,
+        proto: int = ...,
+        flags: int = ...,
+        sock: socket,
+        local_addr: None = ...,
+        server_hostname: Optional[str] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+    ) -> asyncio.events._TransProtPair: ...
+    async def create_unix_server(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        path: Optional[str] = ...,
+        *,
+        backlog: int = ...,
+        sock: Optional[socket] = ...,
+        ssl: _SSLContext = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+        start_serving: bool = ...,
+    ) -> asyncio.AbstractServer: ...
+    async def create_unix_connection(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        path: Optional[str] = ...,
+        *,
+        ssl: _SSLContext = ...,
+        sock: Optional[socket] = ...,
+        server_hostname: Optional[str] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+    ) -> asyncio.events._TransProtPair: ...
+    def default_exception_handler(self, context: _Context) -> None: ...
+    def get_exception_handler(self) -> Optional[_ExceptionHandler]: ...
+    def set_exception_handler(self, handler: Optional[_ExceptionHandler]) -> None: ...
+    def call_exception_handler(self, context: _Context) -> None: ...
+    def add_reader(self, fd: Any, callback: Callable[..., Any], *args: Any) -> None: ...
+    def remove_reader(self, fd: Any) -> None: ...
+    def add_writer(self, fd: Any, callback: Callable[..., Any], *args: Any) -> None: ...
+    def remove_writer(self, fd: Any) -> None: ...
+    async def sock_recv(self, sock: socket, nbytes: int) -> bytes: ...
+    async def sock_recv_into(self, sock: socket, buf: bytearray) -> int: ...
+    async def sock_sendall(self, sock: socket, data: bytes) -> None: ...
+    async def sock_accept(self, sock: socket) -> Tuple[socket, _RetAddress]: ...
+    async def sock_connect(self, sock: socket, address: _Address) -> None: ...
+    async def connect_accepted_socket(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        sock: socket,
+        *,
+        ssl: _SSLContext = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+    ) -> asyncio.events._TransProtPair: ...
+    async def run_in_executor(
+        self, executor: Any, func: Callable[..., _T], *args: Any
+    ) -> _T: ...
+    def set_default_executor(self, executor: Any) -> None: ...
+    async def subprocess_shell(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        cmd: Union[bytes, str],
+        *,
+        stdin: Any = ...,
+        stdout: Any = ...,
+        stderr: Any = ...,
+        **kwargs: Any,
+    ) -> asyncio.events._TransProtPair: ...
+    async def subprocess_exec(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        *args: Any,
+        stdin: Any = ...,
+        stdout: Any = ...,
+        stderr: Any = ...,
+        **kwargs: Any,
+    ) -> asyncio.events._TransProtPair: ...
+    async def connect_read_pipe(
+        self, protocol_factory: asyncio.events._ProtocolFactory, pipe: Any
+    ) -> asyncio.events._TransProtPair: ...
+    async def connect_write_pipe(
+        self, protocol_factory: asyncio.events._ProtocolFactory, pipe: Any
+    ) -> asyncio.events._TransProtPair: ...
+    def add_signal_handler(
+        self, sig: int, callback: Callable[..., Any], *args: Any
+    ) -> None: ...
+    def remove_signal_handler(self, sig: int) -> bool: ...
+    async def create_datagram_endpoint(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        local_addr: Optional[Tuple[str, int]] = ...,
+        remote_addr: Optional[Tuple[str, int]] = ...,
+        *,
+        family: int = ...,
+        proto: int = ...,
+        flags: int = ...,
+        reuse_address: Optional[bool] = ...,
+        reuse_port: Optional[bool] = ...,
+        allow_broadcast: Optional[bool] = ...,
+        sock: Optional[socket] = ...,
+    ) -> asyncio.events._TransProtPair: ...
+    async def shutdown_asyncgens(self) -> None: ...
+    async def shutdown_default_executor(self) -> None: ...
+    # Loop doesn't implement these, but since they are marked as abstract in typeshed,
+    # we have to put them in so mypy thinks the base methods are overridden
+    async def sendfile(
+        self,
+        transport: asyncio.BaseTransport,
+        file: IO[bytes],
+        offset: int = ...,
+        count: Optional[int] = ...,
+        *,
+        fallback: bool = ...,
+    ) -> int: ...
+    async def sock_sendfile(
+        self,
+        sock: socket,
+        file: IO[bytes],
+        offset: int = ...,
+        count: Optional[int] = ...,
+        *,
+        fallback: bool = ...
+    ) -> int: ...
diff --git a/myenv/lib/python3.9/site-packages/uvloop/loop.pyx b/myenv/lib/python3.9/site-packages/uvloop/loop.pyx
new file mode 100644
index 0000000..d9b5aaa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/loop.pyx
@@ -0,0 +1,3335 @@
+# cython: language_level=3, embedsignature=True
+
+import asyncio
+cimport cython
+
+from .includes.debug cimport UVLOOP_DEBUG
+from .includes cimport uv
+from .includes cimport system
+from .includes.python cimport (
+    PY_VERSION_HEX,
+    PyMem_RawMalloc, PyMem_RawFree,
+    PyMem_RawCalloc, PyMem_RawRealloc,
+    PyUnicode_EncodeFSDefault,
+    PyErr_SetInterrupt,
+    _Py_RestoreSignals,
+    Context_CopyCurrent,
+    Context_Enter,
+    Context_Exit,
+    PyMemoryView_FromMemory, PyBUF_WRITE,
+    PyMemoryView_FromObject, PyMemoryView_Check,
+    PyOS_AfterFork_Parent, PyOS_AfterFork_Child,
+    PyOS_BeforeFork,
+    PyUnicode_FromString
+)
+from .includes.flowcontrol cimport add_flowcontrol_defaults
+
+from libc.stdint cimport uint64_t
+from libc.string cimport memset, strerror, memcpy
+from libc cimport errno
+
+from cpython cimport PyObject
+from cpython cimport PyErr_CheckSignals, PyErr_Occurred
+from cpython cimport PyThread_get_thread_ident
+from cpython cimport Py_INCREF, Py_DECREF, Py_XDECREF, Py_XINCREF
+from cpython cimport (
+    PyObject_GetBuffer, PyBuffer_Release, PyBUF_SIMPLE,
+    Py_buffer, PyBytes_AsString, PyBytes_CheckExact,
+    PyBytes_AsStringAndSize,
+    Py_SIZE, PyBytes_AS_STRING, PyBUF_WRITABLE
+)
+
+from . import _noop
+
+
+include "includes/consts.pxi"
+include "includes/stdlib.pxi"
+
+include "errors.pyx"
+
+cdef:
+    int PY39 = PY_VERSION_HEX >= 0x03090000
+    uint64_t MAX_SLEEP = 3600 * 24 * 365 * 100
+
+
+cdef _is_sock_stream(sock_type):
+    if SOCK_NONBLOCK == -1:
+        return sock_type == uv.SOCK_STREAM
+    else:
+        # Linux's socket.type is a bitmask that can include extra info
+        # about socket (like SOCK_NONBLOCK bit), therefore we can't do simple
+        # `sock_type == socket.SOCK_STREAM`, see
+        # https://github.com/torvalds/linux/blob/v4.13/include/linux/net.h#L77
+        # for more details.
+        return (sock_type & 0xF) == uv.SOCK_STREAM
+
+
+cdef _is_sock_dgram(sock_type):
+    if SOCK_NONBLOCK == -1:
+        return sock_type == uv.SOCK_DGRAM
+    else:
+        # Read the comment in `_is_sock_stream`.
+        return (sock_type & 0xF) == uv.SOCK_DGRAM
+
+
+cdef isfuture(obj):
+    if aio_isfuture is None:
+        return isinstance(obj, aio_Future)
+    else:
+        return aio_isfuture(obj)
+
+
+cdef inline socket_inc_io_ref(sock):
+    if isinstance(sock, socket_socket):
+        sock._io_refs += 1
+
+
+cdef inline socket_dec_io_ref(sock):
+    if isinstance(sock, socket_socket):
+        sock._decref_socketios()
+
+
+cdef inline run_in_context(context, method):
+    # This method is internally used to workaround a reference issue that in
+    # certain circumstances, inlined context.run() will not hold a reference to
+    # the given method instance, which - if deallocated - will cause segault.
+    # See also: edgedb/edgedb#2222
+    Py_INCREF(method)
+    try:
+        return context.run(method)
+    finally:
+        Py_DECREF(method)
+
+
+cdef inline run_in_context1(context, method, arg):
+    Py_INCREF(method)
+    try:
+        return context.run(method, arg)
+    finally:
+        Py_DECREF(method)
+
+
+cdef inline run_in_context2(context, method, arg1, arg2):
+    Py_INCREF(method)
+    try:
+        return context.run(method, arg1, arg2)
+    finally:
+        Py_DECREF(method)
+
+
+# Used for deprecation and removal of `loop.create_datagram_endpoint()`'s
+# *reuse_address* parameter
+_unset = object()
+
+
+@cython.no_gc_clear
+cdef class Loop:
+    def __cinit__(self):
+        cdef int err
+
+        # Install PyMem* memory allocators if they aren't installed yet.
+        __install_pymem()
+
+        # Install pthread_atfork handlers
+        __install_atfork()
+
+        self.uvloop = <uv.uv_loop_t*>PyMem_RawMalloc(sizeof(uv.uv_loop_t))
+        if self.uvloop is NULL:
+            raise MemoryError()
+
+        self.slow_callback_duration = 0.1
+
+        self._closed = 0
+        self._debug = 0
+        self._thread_is_main = 0
+        self._thread_id = 0
+        self._running = 0
+        self._stopping = 0
+
+        self._transports = weakref_WeakValueDictionary()
+        self._processes = set()
+
+        # Used to keep a reference (and hence keep the fileobj alive)
+        # for as long as its registered by add_reader or add_writer.
+        # This is how the selector module and hence asyncio behaves.
+        self._fd_to_reader_fileobj = {}
+        self._fd_to_writer_fileobj = {}
+
+        self._timers = set()
+        self._polls = {}
+
+        self._recv_buffer_in_use = 0
+
+        err = uv.uv_loop_init(self.uvloop)
+        if err < 0:
+            raise convert_error(err)
+        self.uvloop.data = <void*> self
+
+        self._init_debug_fields()
+
+        self.active_process_handler = None
+
+        self._last_error = None
+
+        self._task_factory = None
+        self._exception_handler = None
+        self._default_executor = None
+
+        self._queued_streams = set()
+        self._ready = col_deque()
+        self._ready_len = 0
+
+        self.handler_async = UVAsync.new(
+            self, <method_t>self._on_wake, self)
+
+        self.handler_idle = UVIdle.new(
+            self,
+            new_MethodHandle(
+                self, "loop._on_idle", <method_t>self._on_idle, None, self))
+
+        # Needed to call `UVStream._exec_write` for writes scheduled
+        # during `Protocol.data_received`.
+        self.handler_check__exec_writes = UVCheck.new(
+            self,
+            new_MethodHandle(
+                self, "loop._exec_queued_writes",
+                <method_t>self._exec_queued_writes, None, self))
+
+        self._signals = set()
+        self._ssock = self._csock = None
+        self._signal_handlers = {}
+        self._listening_signals = False
+        self._old_signal_wakeup_id = -1
+
+        self._coroutine_debug_set = False
+
+        # A weak set of all asynchronous generators that are
+        # being iterated by the loop.
+        self._asyncgens = weakref_WeakSet()
+
+        # Set to True when `loop.shutdown_asyncgens` is called.
+        self._asyncgens_shutdown_called = False
+        # Set to True when `loop.shutdown_default_executor` is called.
+        self._executor_shutdown_called = False
+
+        self._servers = set()
+
+    cdef inline _is_main_thread(self):
+        return MAIN_THREAD_ID == PyThread_get_thread_ident()
+
+    def __init__(self):
+        self.set_debug((not sys_ignore_environment
+                        and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
+
+    def __dealloc__(self):
+        if self._running == 1:
+            raise RuntimeError('deallocating a running event loop!')
+        if self._closed == 0:
+            aio_logger.error("deallocating an open event loop")
+            return
+        PyMem_RawFree(self.uvloop)
+        self.uvloop = NULL
+
+    cdef _init_debug_fields(self):
+        self._debug_cc = bool(UVLOOP_DEBUG)
+
+        if UVLOOP_DEBUG:
+            self._debug_handles_current = col_Counter()
+            self._debug_handles_closed = col_Counter()
+            self._debug_handles_total = col_Counter()
+        else:
+            self._debug_handles_current = None
+            self._debug_handles_closed = None
+            self._debug_handles_total = None
+
+        self._debug_uv_handles_total = 0
+        self._debug_uv_handles_freed = 0
+
+        self._debug_stream_read_cb_total = 0
+        self._debug_stream_read_eof_total = 0
+        self._debug_stream_read_errors_total = 0
+        self._debug_stream_read_cb_errors_total = 0
+        self._debug_stream_read_eof_cb_errors_total = 0
+
+        self._debug_stream_shutdown_errors_total = 0
+        self._debug_stream_listen_errors_total = 0
+
+        self._debug_stream_write_tries = 0
+        self._debug_stream_write_errors_total = 0
+        self._debug_stream_write_ctx_total = 0
+        self._debug_stream_write_ctx_cnt = 0
+        self._debug_stream_write_cb_errors_total = 0
+
+        self._debug_cb_handles_total = 0
+        self._debug_cb_handles_count = 0
+
+        self._debug_cb_timer_handles_total = 0
+        self._debug_cb_timer_handles_count = 0
+
+        self._poll_read_events_total = 0
+        self._poll_read_cb_errors_total = 0
+        self._poll_write_events_total = 0
+        self._poll_write_cb_errors_total = 0
+
+        self._sock_try_write_total = 0
+
+        self._debug_exception_handler_cnt = 0
+
+    cdef _setup_or_resume_signals(self):
+        if not self._is_main_thread():
+            return
+
+        if self._listening_signals:
+            raise RuntimeError('signals handling has been already setup')
+
+        if self._ssock is not None:
+            raise RuntimeError('self-pipe exists before loop run')
+
+        # Create a self-pipe and call set_signal_wakeup_fd() with one
+        # of its ends.  This is needed so that libuv knows that it needs
+        # to wakeup on ^C (no matter if the SIGINT handler is still the
+        # standard Python's one or or user set their own.)
+
+        self._ssock, self._csock = socket_socketpair()
+        try:
+            self._ssock.setblocking(False)
+            self._csock.setblocking(False)
+
+            fileno = self._csock.fileno()
+
+            self._old_signal_wakeup_id = _set_signal_wakeup_fd(fileno)
+        except Exception:
+            # Out of all statements in the try block, only the
+            # "_set_signal_wakeup_fd()" call can fail, but it shouldn't,
+            # as we ensure that the current thread is the main thread.
+            # Still, if something goes horribly wrong we want to clean up
+            # the socket pair.
+            self._ssock.close()
+            self._csock.close()
+            self._ssock = None
+            self._csock = None
+            raise
+
+        self._add_reader(
+            self._ssock,
+            new_MethodHandle(
+                self,
+                "Loop._read_from_self",
+                <method_t>self._read_from_self,
+                None,
+                self))
+
+        self._listening_signals = True
+
+    cdef _pause_signals(self):
+        if not self._is_main_thread():
+            if self._listening_signals:
+                raise RuntimeError(
+                    'cannot pause signals handling; no longer running in '
+                    'the main thread')
+            else:
+                return
+
+        if not self._listening_signals:
+            raise RuntimeError('signals handling has not been setup')
+
+        self._listening_signals = False
+
+        _set_signal_wakeup_fd(self._old_signal_wakeup_id)
+
+        self._remove_reader(self._ssock)
+        self._ssock.close()
+        self._csock.close()
+        self._ssock = None
+        self._csock = None
+
+    cdef _shutdown_signals(self):
+        if not self._is_main_thread():
+            if self._signal_handlers:
+                aio_logger.warning(
+                    'cannot cleanup signal handlers: closing the event loop '
+                    'in a non-main OS thread')
+            return
+
+        if self._listening_signals:
+            raise RuntimeError(
+                'cannot shutdown signals handling as it has not been paused')
+
+        if self._ssock:
+            raise RuntimeError(
+                'self-pipe was not cleaned up after loop was run')
+
+        for sig in list(self._signal_handlers):
+            self.remove_signal_handler(sig)
+
+    def __sighandler(self, signum, frame):
+        self._signals.add(signum)
+
+    cdef inline _ceval_process_signals(self):
+        # Invoke CPython eval loop to let process signals.
+        PyErr_CheckSignals()
+        # Calling a pure-Python function will invoke
+        # _PyEval_EvalFrameDefault which will process
+        # pending signal callbacks.
+        _noop.noop()  # Might raise ^C
+
+    cdef _read_from_self(self):
+        cdef bytes sigdata
+        sigdata = b''
+        while True:
+            try:
+                data = self._ssock.recv(65536)
+                if not data:
+                    break
+                sigdata += data
+            except InterruptedError:
+                continue
+            except BlockingIOError:
+                break
+        if sigdata:
+            self._invoke_signals(sigdata)
+
+    cdef _invoke_signals(self, bytes data):
+        cdef set sigs
+
+        self._ceval_process_signals()
+
+        sigs = self._signals.copy()
+        self._signals.clear()
+        for signum in data:
+            if not signum:
+                # ignore null bytes written by set_wakeup_fd()
+                continue
+            sigs.discard(signum)
+            self._handle_signal(signum)
+
+        for signum in sigs:
+            # Since not all signals are registered by add_signal_handler()
+            # (for instance, we use the default SIGINT handler) not all
+            # signals will trigger loop.__sighandler() callback.  Therefore
+            # we combine two datasources: one is self-pipe, one is data
+            # from __sighandler; this ensures that signals shouldn't be
+            # lost even if set_wakeup_fd() couldn't write to the self-pipe.
+            self._handle_signal(signum)
+
+    cdef _handle_signal(self, sig):
+        cdef Handle handle
+
+        try:
+            handle = <Handle>(self._signal_handlers[sig])
+        except KeyError:
+            handle = None
+
+        if handle is None:
+            self._ceval_process_signals()
+            return
+
+        if handle._cancelled:
+            self.remove_signal_handler(sig)  # Remove it properly.
+        else:
+            self._append_ready_handle(handle)
+            self.handler_async.send()
+
+    cdef _on_wake(self):
+        if ((self._ready_len > 0 or self._stopping) and
+                not self.handler_idle.running):
+            self.handler_idle.start()
+
+    cdef _on_idle(self):
+        cdef:
+            int i, ntodo
+            object popleft = self._ready.popleft
+            Handle handler
+
+        ntodo = len(self._ready)
+        if self._debug:
+            for i from 0 <= i < ntodo:
+                handler = <Handle> popleft()
+                if handler._cancelled == 0:
+                    try:
+                        started = time_monotonic()
+                        handler._run()
+                    except BaseException as ex:
+                        self._stop(ex)
+                        return
+                    else:
+                        delta = time_monotonic() - started
+                        if delta > self.slow_callback_duration:
+                            aio_logger.warning(
+                                'Executing %s took %.3f seconds',
+                                handler._format_handle(), delta)
+
+        else:
+            for i from 0 <= i < ntodo:
+                handler = <Handle> popleft()
+                if handler._cancelled == 0:
+                    try:
+                        handler._run()
+                    except BaseException as ex:
+                        self._stop(ex)
+                        return
+
+        if len(self._queued_streams):
+            self._exec_queued_writes()
+
+        self._ready_len = len(self._ready)
+        if self._ready_len == 0 and self.handler_idle.running:
+            self.handler_idle.stop()
+
+        if self._stopping:
+            uv.uv_stop(self.uvloop)  # void
+
+    cdef _stop(self, exc):
+        if exc is not None:
+            self._last_error = exc
+        if self._stopping == 1:
+            return
+        self._stopping = 1
+        if not self.handler_idle.running:
+            self.handler_idle.start()
+
+    cdef __run(self, uv.uv_run_mode mode):
+        # Although every UVHandle holds a reference to the loop,
+        # we want to do everything to ensure that the loop will
+        # never deallocate during the run -- so we do some
+        # manual refs management.
+        Py_INCREF(self)
+        with nogil:
+            err = uv.uv_run(self.uvloop, mode)
+        Py_DECREF(self)
+
+        if err < 0:
+            raise convert_error(err)
+
+    cdef _run(self, uv.uv_run_mode mode):
+        cdef int err
+
+        if self._closed == 1:
+            raise RuntimeError('unable to start the loop; it was closed')
+
+        if self._running == 1:
+            raise RuntimeError('this event loop is already running.')
+
+        if (aio_get_running_loop is not None and
+                aio_get_running_loop() is not None):
+            raise RuntimeError(
+                'Cannot run the event loop while another loop is running')
+
+        # reset _last_error
+        self._last_error = None
+
+        self._thread_id = PyThread_get_thread_ident()
+        self._thread_is_main = MAIN_THREAD_ID == self._thread_id
+        self._running = 1
+
+        self.handler_check__exec_writes.start()
+        self.handler_idle.start()
+
+        self._setup_or_resume_signals()
+
+        if aio_set_running_loop is not None:
+            aio_set_running_loop(self)
+        try:
+            self.__run(mode)
+        finally:
+            if aio_set_running_loop is not None:
+                aio_set_running_loop(None)
+
+            self.handler_check__exec_writes.stop()
+            self.handler_idle.stop()
+
+            self._pause_signals()
+
+            self._thread_is_main = 0
+            self._thread_id = 0
+            self._running = 0
+            self._stopping = 0
+
+        if self._last_error is not None:
+            # The loop was stopped with an error with 'loop._stop(error)' call
+            raise self._last_error
+
+    cdef _close(self):
+        cdef int err
+
+        if self._running == 1:
+            raise RuntimeError("Cannot close a running event loop")
+
+        if self._closed == 1:
+            return
+
+        self._closed = 1
+
+        for cb_handle in self._ready:
+            cb_handle.cancel()
+        self._ready.clear()
+        self._ready_len = 0
+
+        if self._polls:
+            for poll_handle in self._polls.values():
+                (<UVHandle>poll_handle)._close()
+
+            self._polls.clear()
+
+        if self._timers:
+            for timer_cbhandle in tuple(self._timers):
+                timer_cbhandle.cancel()
+
+        # Close all remaining handles
+        self.handler_async._close()
+        self.handler_idle._close()
+        self.handler_check__exec_writes._close()
+        __close_all_handles(self)
+        self._shutdown_signals()
+        # During this run there should be no open handles,
+        # so it should finish right away
+        self.__run(uv.UV_RUN_DEFAULT)
+
+        if self._fd_to_writer_fileobj:
+            for fileobj in self._fd_to_writer_fileobj.values():
+                socket_dec_io_ref(fileobj)
+            self._fd_to_writer_fileobj.clear()
+
+        if self._fd_to_reader_fileobj:
+            for fileobj in self._fd_to_reader_fileobj.values():
+                socket_dec_io_ref(fileobj)
+            self._fd_to_reader_fileobj.clear()
+
+        if self._timers:
+            raise RuntimeError(
+                f"new timers were queued during loop closing: {self._timers}")
+
+        if self._polls:
+            raise RuntimeError(
+                f"new poll handles were queued during loop closing: "
+                f"{self._polls}")
+
+        if self._ready:
+            raise RuntimeError(
+                f"new callbacks were queued during loop closing: "
+                f"{self._ready}")
+
+        err = uv.uv_loop_close(self.uvloop)
+        if err < 0:
+            raise convert_error(err)
+
+        self.handler_async = None
+        self.handler_idle = None
+        self.handler_check__exec_writes = None
+
+        self._executor_shutdown_called = True
+        executor = self._default_executor
+        if executor is not None:
+            self._default_executor = None
+            executor.shutdown(wait=False)
+
+    cdef uint64_t _time(self):
+        # asyncio doesn't have a time cache, neither should uvloop.
+        uv.uv_update_time(self.uvloop)  # void
+        return uv.uv_now(self.uvloop)
+
+    cdef inline _queue_write(self, UVStream stream):
+        self._queued_streams.add(stream)
+        if not self.handler_check__exec_writes.running:
+            self.handler_check__exec_writes.start()
+
+    cdef _exec_queued_writes(self):
+        if len(self._queued_streams) == 0:
+            if self.handler_check__exec_writes.running:
+                self.handler_check__exec_writes.stop()
+            return
+
+        cdef:
+            UVStream stream
+            int queued_len
+
+        if UVLOOP_DEBUG:
+            queued_len = len(self._queued_streams)
+
+        for pystream in self._queued_streams:
+            stream = <UVStream>pystream
+            stream._exec_write()
+
+        if UVLOOP_DEBUG:
+            if len(self._queued_streams) != queued_len:
+                raise RuntimeError(
+                    'loop._queued_streams are not empty after '
+                    '_exec_queued_writes')
+
+        self._queued_streams.clear()
+
+        if self.handler_check__exec_writes.running:
+            self.handler_check__exec_writes.stop()
+
+    cdef inline _call_soon(self, object callback, object args, object context):
+        cdef Handle handle
+        handle = new_Handle(self, callback, args, context)
+        self._call_soon_handle(handle)
+        return handle
+
+    cdef inline _append_ready_handle(self, Handle handle):
+        self._check_closed()
+        self._ready.append(handle)
+        self._ready_len += 1
+
+    cdef inline _call_soon_handle(self, Handle handle):
+        self._append_ready_handle(handle)
+        if not self.handler_idle.running:
+            self.handler_idle.start()
+
+    cdef _call_later(self, uint64_t delay, object callback, object args,
+                     object context):
+        return TimerHandle(self, callback, args, delay, context)
+
+    cdef void _handle_exception(self, object ex):
+        if isinstance(ex, Exception):
+            self.call_exception_handler({'exception': ex})
+        else:
+            # BaseException
+            self._last_error = ex
+            # Exit ASAP
+            self._stop(None)
+
+    cdef inline _check_signal(self, sig):
+        if not isinstance(sig, int):
+            raise TypeError('sig must be an int, not {!r}'.format(sig))
+
+        if not (1 <= sig < signal_NSIG):
+            raise ValueError(
+                'sig {} out of range(1, {})'.format(sig, signal_NSIG))
+
+    cdef inline _check_closed(self):
+        if self._closed == 1:
+            raise RuntimeError('Event loop is closed')
+
+    cdef inline _check_thread(self):
+        if self._thread_id == 0:
+            return
+
+        cdef uint64_t thread_id
+        thread_id = <uint64_t><int64_t>PyThread_get_thread_ident()
+
+        if thread_id != self._thread_id:
+            raise RuntimeError(
+                "Non-thread-safe operation invoked on an event loop other "
+                "than the current one")
+
+    cdef inline _new_future(self):
+        return aio_Future(loop=self)
+
+    cdef _track_transport(self, UVBaseTransport transport):
+        self._transports[transport._fileno()] = transport
+
+    cdef _track_process(self, UVProcess proc):
+        self._processes.add(proc)
+
+    cdef _untrack_process(self, UVProcess proc):
+        self._processes.discard(proc)
+
+    cdef _fileobj_to_fd(self, fileobj):
+        """Return a file descriptor from a file object.
+
+        Parameters:
+        fileobj -- file object or file descriptor
+
+        Returns:
+        corresponding file descriptor
+
+        Raises:
+        ValueError if the object is invalid
+        """
+        # Copy of the `selectors._fileobj_to_fd()` function.
+        if isinstance(fileobj, int):
+            fd = fileobj
+        else:
+            try:
+                fd = int(fileobj.fileno())
+            except (AttributeError, TypeError, ValueError):
+                raise ValueError("Invalid file object: "
+                                 "{!r}".format(fileobj)) from None
+        if fd < 0:
+            raise ValueError("Invalid file descriptor: {}".format(fd))
+        return fd
+
+    cdef _ensure_fd_no_transport(self, fd):
+        cdef UVBaseTransport tr
+        try:
+            tr = <UVBaseTransport>(self._transports[fd])
+        except KeyError:
+            pass
+        else:
+            if tr._is_alive():
+                raise RuntimeError(
+                    'File descriptor {!r} is used by transport {!r}'.format(
+                        fd, tr))
+
+    cdef _add_reader(self, fileobj, Handle handle):
+        cdef:
+            UVPoll poll
+
+        self._check_closed()
+        fd = self._fileobj_to_fd(fileobj)
+        self._ensure_fd_no_transport(fd)
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            poll = UVPoll.new(self, fd)
+            self._polls[fd] = poll
+
+        poll.start_reading(handle)
+
+        old_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+        if old_fileobj is not None:
+            socket_dec_io_ref(old_fileobj)
+
+        self._fd_to_reader_fileobj[fd] = fileobj
+        socket_inc_io_ref(fileobj)
+
+    cdef _remove_reader(self, fileobj):
+        cdef:
+            UVPoll poll
+
+        fd = self._fileobj_to_fd(fileobj)
+        self._ensure_fd_no_transport(fd)
+
+        mapped_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+        if mapped_fileobj is not None:
+            socket_dec_io_ref(mapped_fileobj)
+
+        if self._closed == 1:
+            return False
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            return False
+
+        result = poll.stop_reading()
+        if not poll.is_active():
+            del self._polls[fd]
+            poll._close()
+
+        return result
+
+    cdef _has_reader(self, fileobj):
+        cdef:
+            UVPoll poll
+
+        self._check_closed()
+        fd = self._fileobj_to_fd(fileobj)
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            return False
+
+        return poll.is_reading()
+
+    cdef _add_writer(self, fileobj, Handle handle):
+        cdef:
+            UVPoll poll
+
+        self._check_closed()
+        fd = self._fileobj_to_fd(fileobj)
+        self._ensure_fd_no_transport(fd)
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            poll = UVPoll.new(self, fd)
+            self._polls[fd] = poll
+
+        poll.start_writing(handle)
+
+        old_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+        if old_fileobj is not None:
+            socket_dec_io_ref(old_fileobj)
+
+        self._fd_to_writer_fileobj[fd] = fileobj
+        socket_inc_io_ref(fileobj)
+
+    cdef _remove_writer(self, fileobj):
+        cdef:
+            UVPoll poll
+
+        fd = self._fileobj_to_fd(fileobj)
+        self._ensure_fd_no_transport(fd)
+
+        mapped_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+        if mapped_fileobj is not None:
+            socket_dec_io_ref(mapped_fileobj)
+
+        if self._closed == 1:
+            return False
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            return False
+
+        result = poll.stop_writing()
+        if not poll.is_active():
+            del self._polls[fd]
+            poll._close()
+
+        return result
+
+    cdef _has_writer(self, fileobj):
+        cdef:
+            UVPoll poll
+
+        self._check_closed()
+        fd = self._fileobj_to_fd(fileobj)
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            return False
+
+        return poll.is_writing()
+
+    cdef _getaddrinfo(self, object host, object port,
+                      int family, int type,
+                      int proto, int flags,
+                      int unpack):
+
+        if isinstance(port, str):
+            port = port.encode()
+        elif isinstance(port, int):
+            port = str(port).encode()
+        if port is not None and not isinstance(port, bytes):
+            raise TypeError('port must be a str, bytes or int')
+
+        if isinstance(host, str):
+            host = host.encode('idna')
+        if host is not None:
+            if not isinstance(host, bytes):
+                raise TypeError('host must be a str or bytes')
+
+        fut = self._new_future()
+
+        def callback(result):
+            if AddrInfo.isinstance(result):
+                try:
+                    if unpack == 0:
+                        data = result
+                    else:
+                        data = (<AddrInfo>result).unpack()
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except BaseException as ex:
+                    if not fut.cancelled():
+                        fut.set_exception(ex)
+                else:
+                    if not fut.cancelled():
+                        fut.set_result(data)
+            else:
+                if not fut.cancelled():
+                    fut.set_exception(result)
+
+        AddrInfoRequest(self, host, port, family, type, proto, flags, callback)
+        return fut
+
+    cdef _getnameinfo(self, system.sockaddr *addr, int flags):
+        cdef NameInfoRequest nr
+        fut = self._new_future()
+
+        def callback(result):
+            if isinstance(result, tuple):
+                fut.set_result(result)
+            else:
+                fut.set_exception(result)
+
+        nr = NameInfoRequest(self, callback)
+        nr.query(addr, flags)
+        return fut
+
+    cdef _sock_recv(self, fut, sock, n):
+        if UVLOOP_DEBUG:
+            if fut.cancelled():
+                # Shouldn't happen with _SyncSocketReaderFuture.
+                raise RuntimeError(
+                    f'_sock_recv is called on a cancelled Future')
+
+            if not self._has_reader(sock):
+                raise RuntimeError(
+                    f'socket {sock!r} does not have a reader '
+                    f'in the _sock_recv callback')
+
+        try:
+            data = sock.recv(n)
+        except (BlockingIOError, InterruptedError):
+            # No need to re-add the reader, let's just wait until
+            # the poll handler calls this callback again.
+            pass
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            fut.set_exception(exc)
+            self._remove_reader(sock)
+        else:
+            fut.set_result(data)
+            self._remove_reader(sock)
+
+    cdef _sock_recv_into(self, fut, sock, buf):
+        if UVLOOP_DEBUG:
+            if fut.cancelled():
+                # Shouldn't happen with _SyncSocketReaderFuture.
+                raise RuntimeError(
+                    f'_sock_recv_into is called on a cancelled Future')
+
+            if not self._has_reader(sock):
+                raise RuntimeError(
+                    f'socket {sock!r} does not have a reader '
+                    f'in the _sock_recv_into callback')
+
+        try:
+            data = sock.recv_into(buf)
+        except (BlockingIOError, InterruptedError):
+            # No need to re-add the reader, let's just wait until
+            # the poll handler calls this callback again.
+            pass
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            fut.set_exception(exc)
+            self._remove_reader(sock)
+        else:
+            fut.set_result(data)
+            self._remove_reader(sock)
+
+    cdef _sock_sendall(self, fut, sock, data):
+        cdef:
+            Handle handle
+            int n
+
+        if UVLOOP_DEBUG:
+            if fut.cancelled():
+                # Shouldn't happen with _SyncSocketWriterFuture.
+                raise RuntimeError(
+                    f'_sock_sendall is called on a cancelled Future')
+
+            if not self._has_writer(sock):
+                raise RuntimeError(
+                    f'socket {sock!r} does not have a writer '
+                    f'in the _sock_sendall callback')
+
+        try:
+            n = sock.send(data)
+        except (BlockingIOError, InterruptedError):
+            # Try next time.
+            return
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            fut.set_exception(exc)
+            self._remove_writer(sock)
+            return
+
+        self._remove_writer(sock)
+
+        if n == len(data):
+            fut.set_result(None)
+        else:
+            if n:
+                if not isinstance(data, memoryview):
+                    data = memoryview(data)
+                data = data[n:]
+
+            handle = new_MethodHandle3(
+                self,
+                "Loop._sock_sendall",
+                <method3_t>self._sock_sendall,
+                None,
+                self,
+                fut, sock, data)
+
+            self._add_writer(sock, handle)
+
+    cdef _sock_accept(self, fut, sock):
+        try:
+            conn, address = sock.accept()
+            conn.setblocking(False)
+        except (BlockingIOError, InterruptedError):
+            # There is an active reader for _sock_accept, so
+            # do nothing, it will be called again.
+            pass
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            fut.set_exception(exc)
+            self._remove_reader(sock)
+        else:
+            fut.set_result((conn, address))
+            self._remove_reader(sock)
+
+    cdef _sock_connect(self, sock, address):
+        cdef:
+            Handle handle
+
+        try:
+            sock.connect(address)
+        except (BlockingIOError, InterruptedError):
+            pass
+        else:
+            return
+
+        fut = _SyncSocketWriterFuture(sock, self)
+        handle = new_MethodHandle3(
+            self,
+            "Loop._sock_connect",
+            <method3_t>self._sock_connect_cb,
+            None,
+            self,
+            fut, sock, address)
+
+        self._add_writer(sock, handle)
+        return fut
+
+    cdef _sock_connect_cb(self, fut, sock, address):
+        if UVLOOP_DEBUG:
+            if fut.cancelled():
+                # Shouldn't happen with _SyncSocketWriterFuture.
+                raise RuntimeError(
+                    f'_sock_connect_cb is called on a cancelled Future')
+
+            if not self._has_writer(sock):
+                raise RuntimeError(
+                    f'socket {sock!r} does not have a writer '
+                    f'in the _sock_connect_cb callback')
+
+        try:
+            err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
+            if err != 0:
+                # Jump to any except clause below.
+                raise OSError(err, 'Connect call failed %s' % (address,))
+        except (BlockingIOError, InterruptedError):
+            # socket is still registered, the callback will be retried later
+            pass
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            fut.set_exception(exc)
+            self._remove_writer(sock)
+        else:
+            fut.set_result(None)
+            self._remove_writer(sock)
+
+    cdef _sock_set_reuseport(self, int fd):
+        cdef:
+            int err
+            int reuseport_flag = 1
+
+        err = system.setsockopt(
+            fd,
+            uv.SOL_SOCKET,
+            SO_REUSEPORT,
+            <char*>&reuseport_flag,
+            sizeof(reuseport_flag))
+
+        if err < 0:
+            raise convert_error(-errno.errno)
+
+    cdef _set_coroutine_debug(self, bint enabled):
+        enabled = bool(enabled)
+        if self._coroutine_debug_set == enabled:
+            return
+
+        if enabled:
+            self._coroutine_origin_tracking_saved_depth = (
+                sys.get_coroutine_origin_tracking_depth())
+            sys.set_coroutine_origin_tracking_depth(
+                DEBUG_STACK_DEPTH)
+        else:
+            sys.set_coroutine_origin_tracking_depth(
+                self._coroutine_origin_tracking_saved_depth)
+
+        self._coroutine_debug_set = enabled
+
+    def _get_backend_id(self):
+        """This method is used by uvloop tests and is not part of the API."""
+        return uv.uv_backend_fd(self.uvloop)
+
+    cdef _print_debug_info(self):
+        cdef:
+            int err
+            uv.uv_rusage_t rusage
+
+        err = uv.uv_getrusage(&rusage)
+        if err < 0:
+            raise convert_error(err)
+
+        # OS
+
+        print('---- Process info: -----')
+        print('Process memory:            {}'.format(rusage.ru_maxrss))
+        print('Number of signals:         {}'.format(rusage.ru_nsignals))
+        print('')
+
+        # Loop
+
+        print('--- Loop debug info: ---')
+        print('Loop time:                 {}'.format(self.time()))
+        print('Errors logged:             {}'.format(
+            self._debug_exception_handler_cnt))
+        print()
+        print('Callback handles:          {: <8} | {}'.format(
+            self._debug_cb_handles_count,
+            self._debug_cb_handles_total))
+        print('Timer handles:             {: <8} | {}'.format(
+            self._debug_cb_timer_handles_count,
+            self._debug_cb_timer_handles_total))
+        print()
+
+        print('                        alive  | closed  |')
+        print('UVHandles               python | libuv   | total')
+        print('                        objs   | handles |')
+        print('-------------------------------+---------+---------')
+        for name in sorted(self._debug_handles_total):
+            print('    {: <18} {: >7} | {: >7} | {: >7}'.format(
+                name,
+                self._debug_handles_current[name],
+                self._debug_handles_closed[name],
+                self._debug_handles_total[name]))
+        print()
+
+        print('uv_handle_t (current: {}; freed: {}; total: {})'.format(
+            self._debug_uv_handles_total - self._debug_uv_handles_freed,
+            self._debug_uv_handles_freed,
+            self._debug_uv_handles_total))
+        print()
+
+        print('--- Streams debug info: ---')
+        print('Write errors:              {}'.format(
+            self._debug_stream_write_errors_total))
+        print('Write without poll:        {}'.format(
+            self._debug_stream_write_tries))
+        print('Write contexts:            {: <8} | {}'.format(
+            self._debug_stream_write_ctx_cnt,
+            self._debug_stream_write_ctx_total))
+        print('Write failed callbacks:    {}'.format(
+            self._debug_stream_write_cb_errors_total))
+        print()
+        print('Read errors:               {}'.format(
+            self._debug_stream_read_errors_total))
+        print('Read callbacks:            {}'.format(
+            self._debug_stream_read_cb_total))
+        print('Read failed callbacks:     {}'.format(
+            self._debug_stream_read_cb_errors_total))
+        print('Read EOFs:                 {}'.format(
+            self._debug_stream_read_eof_total))
+        print('Read EOF failed callbacks: {}'.format(
+            self._debug_stream_read_eof_cb_errors_total))
+        print()
+        print('Listen errors:             {}'.format(
+            self._debug_stream_listen_errors_total))
+        print('Shutdown errors            {}'.format(
+            self._debug_stream_shutdown_errors_total))
+        print()
+
+        print('--- Polls debug info: ---')
+        print('Read events:               {}'.format(
+            self._poll_read_events_total))
+        print('Read callbacks failed:     {}'.format(
+            self._poll_read_cb_errors_total))
+        print('Write events:              {}'.format(
+            self._poll_write_events_total))
+        print('Write callbacks failed:    {}'.format(
+            self._poll_write_cb_errors_total))
+        print()
+
+        print('--- Sock ops successful on 1st try: ---')
+        print('Socket try-writes:         {}'.format(
+            self._sock_try_write_total))
+
+        print(flush=True)
+
+    property print_debug_info:
+        def __get__(self):
+            if UVLOOP_DEBUG:
+                return lambda: self._print_debug_info()
+            else:
+                raise AttributeError('print_debug_info')
+
+    # Public API
+
+    def __repr__(self):
+        return '<{}.{} running={} closed={} debug={}>'.format(
+            self.__class__.__module__,
+            self.__class__.__name__,
+            self.is_running(),
+            self.is_closed(),
+            self.get_debug()
+        )
+
+    def call_soon(self, callback, *args, context=None):
+        """Arrange for a callback to be called as soon as possible.
+
+        This operates as a FIFO queue: callbacks are called in the
+        order in which they are registered.  Each callback will be
+        called exactly once.
+
+        Any positional arguments after the callback will be passed to
+        the callback when it is called.
+        """
+        if self._debug == 1:
+            self._check_thread()
+        if args:
+            return self._call_soon(callback, args, context)
+        else:
+            return self._call_soon(callback, None, context)
+
+    def call_soon_threadsafe(self, callback, *args, context=None):
+        """Like call_soon(), but thread-safe."""
+        if not args:
+            args = None
+        cdef Handle handle = new_Handle(self, callback, args, context)
+        self._append_ready_handle(handle)  # deque append is atomic
+        # libuv async handler is thread-safe while the idle handler is not -
+        # we only set the async handler here, which will start the idle handler
+        # in _on_wake() from the loop and eventually call the callback.
+        self.handler_async.send()
+        return handle
+
+    def call_later(self, delay, callback, *args, context=None):
+        """Arrange for a callback to be called at a given time.
+
+        Return a Handle: an opaque object with a cancel() method that
+        can be used to cancel the call.
+
+        The delay can be an int or float, expressed in seconds.  It is
+        always relative to the current time.
+
+        Each callback will be called exactly once.  If two callbacks
+        are scheduled for exactly the same time, it undefined which
+        will be called first.
+
+        Any positional arguments after the callback will be passed to
+        the callback when it is called.
+        """
+        cdef uint64_t when
+
+        self._check_closed()
+        if self._debug == 1:
+            self._check_thread()
+
+        if delay < 0:
+            delay = 0
+        elif delay == py_inf or delay > MAX_SLEEP:
+            # ~100 years sounds like a good approximation of
+            # infinity for a Python application.
+            delay = MAX_SLEEP
+
+        when = <uint64_t>round(delay * 1000)
+        if not args:
+            args = None
+        if when == 0:
+            return self._call_soon(callback, args, context)
+        else:
+            return self._call_later(when, callback, args, context)
+
+    def call_at(self, when, callback, *args, context=None):
+        """Like call_later(), but uses an absolute time.
+
+        Absolute time corresponds to the event loop's time() method.
+        """
+        return self.call_later(
+            when - self.time(), callback, *args, context=context)
+
+    def time(self):
+        """Return the time according to the event loop's clock.
+
+        This is a float expressed in seconds since an epoch, but the
+        epoch, precision, accuracy and drift are unspecified and may
+        differ per event loop.
+        """
+        return self._time() / 1000
+
+    def stop(self):
+        """Stop running the event loop.
+
+        Every callback already scheduled will still run.  This simply informs
+        run_forever to stop looping after a complete iteration.
+        """
+        self._call_soon_handle(
+            new_MethodHandle1(
+                self,
+                "Loop._stop",
+                <method1_t>self._stop,
+                None,
+                self,
+                None))
+
+    def run_forever(self):
+        """Run the event loop until stop() is called."""
+        self._check_closed()
+        mode = uv.UV_RUN_DEFAULT
+        if self._stopping:
+            # loop.stop() was called right before loop.run_forever().
+            # This is how asyncio loop behaves.
+            mode = uv.UV_RUN_NOWAIT
+        self._set_coroutine_debug(self._debug)
+        old_agen_hooks = sys.get_asyncgen_hooks()
+        sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
+                               finalizer=self._asyncgen_finalizer_hook)
+        try:
+            self._run(mode)
+        finally:
+            self._set_coroutine_debug(False)
+            sys.set_asyncgen_hooks(*old_agen_hooks)
+
+    def close(self):
+        """Close the event loop.
+
+        The event loop must not be running.
+
+        This is idempotent and irreversible.
+
+        No other methods should be called after this one.
+        """
+        self._close()
+
+    def get_debug(self):
+        return bool(self._debug)
+
+    def set_debug(self, enabled):
+        self._debug = bool(enabled)
+        if self.is_running():
+            self.call_soon_threadsafe(
+                self._set_coroutine_debug, self, self._debug)
+
+    def is_running(self):
+        """Return whether the event loop is currently running."""
+        return bool(self._running)
+
+    def is_closed(self):
+        """Returns True if the event loop was closed."""
+        return bool(self._closed)
+
+    def create_future(self):
+        """Create a Future object attached to the loop."""
+        return self._new_future()
+
+    def create_task(self, coro, *, name=None):
+        """Schedule a coroutine object.
+
+        Return a task object.
+
+        If name is not None, task.set_name(name) will be called if the task
+        object has the set_name attribute, true for default Task in Python 3.8.
+        """
+        self._check_closed()
+        if self._task_factory is None:
+            task = aio_Task(coro, loop=self)
+        else:
+            task = self._task_factory(self, coro)
+
+        # copied from asyncio.tasks._set_task_name (bpo-34270)
+        if name is not None:
+            try:
+                set_name = task.set_name
+            except AttributeError:
+                pass
+            else:
+                set_name(name)
+
+        return task
+
+    def set_task_factory(self, factory):
+        """Set a task factory that will be used by loop.create_task().
+
+        If factory is None the default task factory will be set.
+
+        If factory is a callable, it should have a signature matching
+        '(loop, coro)', where 'loop' will be a reference to the active
+        event loop, 'coro' will be a coroutine object.  The callable
+        must return a Future.
+        """
+        if factory is not None and not callable(factory):
+            raise TypeError('task factory must be a callable or None')
+        self._task_factory = factory
+
+    def get_task_factory(self):
+        """Return a task factory, or None if the default one is in use."""
+        return self._task_factory
+
+    def run_until_complete(self, future):
+        """Run until the Future is done.
+
+        If the argument is a coroutine, it is wrapped in a Task.
+
+        WARNING: It would be disastrous to call run_until_complete()
+        with the same coroutine twice -- it would wrap it in two
+        different Tasks and that can't be good.
+
+        Return the Future's result, or raise its exception.
+        """
+        self._check_closed()
+
+        new_task = not isfuture(future)
+        future = aio_ensure_future(future, loop=self)
+        if new_task:
+            # An exception is raised if the future didn't complete, so there
+            # is no need to log the "destroy pending task" message
+            future._log_destroy_pending = False
+
+        def done_cb(fut):
+            if not fut.cancelled():
+                exc = fut.exception()
+                if isinstance(exc, (SystemExit, KeyboardInterrupt)):
+                    # Issue #336: run_forever() already finished,
+                    # no need to stop it.
+                    return
+            self.stop()
+
+        future.add_done_callback(done_cb)
+        try:
+            self.run_forever()
+        except BaseException:
+            if new_task and future.done() and not future.cancelled():
+                # The coroutine raised a BaseException. Consume the exception
+                # to not log a warning, the caller doesn't have access to the
+                # local task.
+                future.exception()
+            raise
+        finally:
+            future.remove_done_callback(done_cb)
+        if not future.done():
+            raise RuntimeError('Event loop stopped before Future completed.')
+
+        return future.result()
+
+    @cython.iterable_coroutine
+    async def getaddrinfo(self, object host, object port, *,
+                          int family=0, int type=0, int proto=0, int flags=0):
+
+        addr = __static_getaddrinfo_pyaddr(host, port, family,
+                                           type, proto, flags)
+        if addr is not None:
+            fut = self._new_future()
+            fut.set_result([addr])
+            return await fut
+
+        return await self._getaddrinfo(
+            host, port, family, type, proto, flags, 1)
+
+    @cython.iterable_coroutine
+    async def getnameinfo(self, sockaddr, int flags=0):
+        cdef:
+            AddrInfo ai_cnt
+            system.addrinfo *ai
+            system.sockaddr_in6 *sin6
+
+        if not isinstance(sockaddr, tuple):
+            raise TypeError('getnameinfo() argument 1 must be a tuple')
+
+        sl = len(sockaddr)
+
+        if sl < 2 or sl > 4:
+            raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')
+
+        if sl > 2:
+            flowinfo = sockaddr[2]
+            if flowinfo < 0 or flowinfo > 0xfffff:
+                raise OverflowError(
+                    'getnameinfo(): flowinfo must be 0-1048575.')
+        else:
+            flowinfo = 0
+
+        if sl > 3:
+            scope_id = sockaddr[3]
+            if scope_id < 0 or scope_id > 2 ** 32:
+                raise OverflowError(
+                    'getsockaddrarg: scope_id must be unsigned 32 bit integer')
+        else:
+            scope_id = 0
+
+        ai_cnt = await self._getaddrinfo(
+            sockaddr[0], sockaddr[1],
+            uv.AF_UNSPEC,         # family
+            uv.SOCK_DGRAM,        # type
+            0,                    # proto
+            uv.AI_NUMERICHOST,    # flags
+            0)                    # unpack
+
+        ai = ai_cnt.data
+
+        if ai.ai_next:
+            raise OSError("sockaddr resolved to multiple addresses")
+
+        if ai.ai_family == uv.AF_INET:
+            if sl > 2:
+                raise OSError("IPv4 sockaddr must be 2 tuple")
+        elif ai.ai_family == uv.AF_INET6:
+            # Modify some fields in `ai`
+            sin6 = <system.sockaddr_in6*> ai.ai_addr
+            sin6.sin6_flowinfo = system.htonl(flowinfo)
+            sin6.sin6_scope_id = scope_id
+
+        return await self._getnameinfo(ai.ai_addr, flags)
+
+    @cython.iterable_coroutine
+    async def start_tls(self, transport, protocol, sslcontext, *,
+                        server_side=False,
+                        server_hostname=None,
+                        ssl_handshake_timeout=None,
+                        ssl_shutdown_timeout=None):
+        """Upgrade transport to TLS.
+
+        Return a new transport that *protocol* should start using
+        immediately.
+        """
+        if not isinstance(sslcontext, ssl_SSLContext):
+            raise TypeError(
+                f'sslcontext is expected to be an instance of ssl.SSLContext, '
+                f'got {sslcontext!r}')
+
+        if isinstance(transport, (TCPTransport, UnixTransport)):
+            context = (<UVStream>transport).context
+        elif isinstance(transport, _SSLProtocolTransport):
+            context = (<_SSLProtocolTransport>transport).context
+        else:
+            raise TypeError(
+                f'transport {transport!r} is not supported by start_tls()')
+
+        waiter = self._new_future()
+        ssl_protocol = SSLProtocol(
+            self, protocol, sslcontext, waiter,
+            server_side, server_hostname,
+            ssl_handshake_timeout=ssl_handshake_timeout,
+            ssl_shutdown_timeout=ssl_shutdown_timeout,
+            call_connection_made=False)
+
+        # Pause early so that "ssl_protocol.data_received()" doesn't
+        # have a chance to get called before "ssl_protocol.connection_made()".
+        transport.pause_reading()
+
+        transport.set_protocol(ssl_protocol)
+        conmade_cb = self.call_soon(ssl_protocol.connection_made, transport,
+                                    context=context)
+        # transport.resume_reading() will use the right context
+        # (transport.context) to call e.g. data_received()
+        resume_cb = self.call_soon(transport.resume_reading)
+        app_transport = ssl_protocol._get_app_transport(context)
+
+        try:
+            await waiter
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException:
+            app_transport.close()
+            conmade_cb.cancel()
+            resume_cb.cancel()
+            raise
+
+        return app_transport
+
+    @cython.iterable_coroutine
+    async def create_server(self, protocol_factory, host=None, port=None,
+                            *,
+                            int family=uv.AF_UNSPEC,
+                            int flags=uv.AI_PASSIVE,
+                            sock=None,
+                            backlog=100,
+                            ssl=None,
+                            reuse_address=None,
+                            reuse_port=None,
+                            ssl_handshake_timeout=None,
+                            ssl_shutdown_timeout=None,
+                            start_serving=True):
+        """A coroutine which creates a TCP server bound to host and port.
+
+        The return value is a Server object which can be used to stop
+        the service.
+
+        If host is an empty string or None all interfaces are assumed
+        and a list of multiple sockets will be returned (most likely
+        one for IPv4 and another one for IPv6). The host parameter can also be
+        a sequence (e.g. list) of hosts to bind to.
+
+        family can be set to either AF_INET or AF_INET6 to force the
+        socket to use IPv4 or IPv6. If not set it will be determined
+        from host (defaults to AF_UNSPEC).
+
+        flags is a bitmask for getaddrinfo().
+
+        sock can optionally be specified in order to use a preexisting
+        socket object.
+
+        backlog is the maximum number of queued connections passed to
+        listen() (defaults to 100).
+
+        ssl can be set to an SSLContext to enable SSL over the
+        accepted connections.
+
+        reuse_address tells the kernel to reuse a local socket in
+        TIME_WAIT state, without waiting for its natural timeout to
+        expire. If not specified will automatically be set to True on
+        UNIX.
+
+        reuse_port tells the kernel to allow this endpoint to be bound to
+        the same port as other existing endpoints are bound to, so long as
+        they all set this flag when being created. This option is not
+        supported on Windows.
+
+        ssl_handshake_timeout is the time in seconds that an SSL server
+        will wait for completion of the SSL handshake before aborting the
+        connection. Default is 60s.
+
+        ssl_shutdown_timeout is the time in seconds that an SSL server
+        will wait for completion of the SSL shutdown before aborting the
+        connection. Default is 30s.
+        """
+        cdef:
+            TCPServer tcp
+            system.addrinfo *addrinfo
+            Server server
+
+        if sock is not None and sock.family == uv.AF_UNIX:
+            if host is not None or port is not None:
+                raise ValueError(
+                    'host/port and sock can not be specified at the same time')
+            return await self.create_unix_server(
+                protocol_factory, sock=sock, backlog=backlog, ssl=ssl,
+                start_serving=start_serving)
+
+        server = Server(self)
+
+        if ssl is not None:
+            if not isinstance(ssl, ssl_SSLContext):
+                raise TypeError('ssl argument must be an SSLContext or None')
+        else:
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        if host is not None or port is not None:
+            if sock is not None:
+                raise ValueError(
+                    'host/port and sock can not be specified at the same time')
+
+            if reuse_address is None:
+                reuse_address = os_name == 'posix' and sys_platform != 'cygwin'
+            reuse_port = bool(reuse_port)
+            if reuse_port and not has_SO_REUSEPORT:
+                raise ValueError(
+                    'reuse_port not supported by socket module')
+
+            if host == '':
+                hosts = [None]
+            elif (isinstance(host, str) or not isinstance(host, col_Iterable)):
+                hosts = [host]
+            else:
+                hosts = host
+
+            fs = [self._getaddrinfo(host, port, family,
+                                    uv.SOCK_STREAM, 0, flags,
+                                    0) for host in hosts]
+
+            infos = await aio_gather(*fs)
+
+            completed = False
+            sock = None
+            try:
+                for info in infos:
+                    addrinfo = (<AddrInfo>info).data
+                    while addrinfo != NULL:
+                        if addrinfo.ai_family == uv.AF_UNSPEC:
+                            raise RuntimeError('AF_UNSPEC in DNS results')
+
+                        try:
+                            sock = socket_socket(addrinfo.ai_family,
+                                                 addrinfo.ai_socktype,
+                                                 addrinfo.ai_protocol)
+                        except socket_error:
+                            # Assume it's a bad family/type/protocol
+                            # combination.
+                            if self._debug:
+                                aio_logger.warning(
+                                    'create_server() failed to create '
+                                    'socket.socket(%r, %r, %r)',
+                                    addrinfo.ai_family,
+                                    addrinfo.ai_socktype,
+                                    addrinfo.ai_protocol, exc_info=True)
+                            continue
+
+                        if reuse_address:
+                            sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEADDR, 1)
+                        if reuse_port:
+                            sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEPORT, 1)
+                        # Disable IPv4/IPv6 dual stack support (enabled by
+                        # default on Linux) which makes a single socket
+                        # listen on both address families.
+                        if (addrinfo.ai_family == uv.AF_INET6 and
+                                has_IPV6_V6ONLY):
+                            sock.setsockopt(uv.IPPROTO_IPV6, IPV6_V6ONLY, 1)
+
+                        pyaddr = __convert_sockaddr_to_pyaddr(addrinfo.ai_addr)
+                        try:
+                            sock.bind(pyaddr)
+                        except OSError as err:
+                            raise OSError(
+                                err.errno, 'error while attempting '
+                                'to bind on address %r: %s'
+                                % (pyaddr, err.strerror.lower())) from None
+
+                        tcp = TCPServer.new(self, protocol_factory, server,
+                                            uv.AF_UNSPEC, backlog,
+                                            ssl, ssl_handshake_timeout,
+                                            ssl_shutdown_timeout)
+
+                        try:
+                            tcp._open(sock.fileno())
+                        except (KeyboardInterrupt, SystemExit):
+                            raise
+                        except BaseException:
+                            tcp._close()
+                            raise
+
+                        server._add_server(tcp)
+                        sock.detach()
+                        sock = None
+
+                        addrinfo = addrinfo.ai_next
+
+                completed = True
+            finally:
+                if not completed:
+                    if sock is not None:
+                        sock.close()
+                    server.close()
+        else:
+            if sock is None:
+                raise ValueError('Neither host/port nor sock were specified')
+            if not _is_sock_stream(sock.type):
+                raise ValueError(
+                    'A Stream Socket was expected, got {!r}'.format(sock))
+
+            # libuv will set the socket to non-blocking mode, but
+            # we want Python socket object to notice that.
+            sock.setblocking(False)
+
+            tcp = TCPServer.new(self, protocol_factory, server,
+                                uv.AF_UNSPEC, backlog,
+                                ssl, ssl_handshake_timeout,
+                                ssl_shutdown_timeout)
+
+            try:
+                tcp._open(sock.fileno())
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                tcp._close()
+                raise
+
+            tcp._attach_fileobj(sock)
+            server._add_server(tcp)
+
+        if start_serving:
+            server._start_serving()
+
+        server._ref()
+        return server
+
+    @cython.iterable_coroutine
+    async def create_connection(self, protocol_factory, host=None, port=None,
+                                *,
+                                ssl=None,
+                                family=0, proto=0, flags=0, sock=None,
+                                local_addr=None, server_hostname=None,
+                                ssl_handshake_timeout=None,
+                                ssl_shutdown_timeout=None):
+        """Connect to a TCP server.
+
+        Create a streaming transport connection to a given Internet host and
+        port: socket family AF_INET or socket.AF_INET6 depending on host (or
+        family if specified), socket type SOCK_STREAM. protocol_factory must be
+        a callable returning a protocol instance.
+
+        This method is a coroutine which will try to establish the connection
+        in the background.  When successful, the coroutine returns a
+        (transport, protocol) pair.
+        """
+        cdef:
+            AddrInfo ai_local = None
+            AddrInfo ai_remote
+            TCPTransport tr
+
+            system.addrinfo *rai = NULL
+            system.addrinfo *lai = NULL
+
+            system.addrinfo *rai_iter = NULL
+            system.addrinfo *lai_iter = NULL
+
+            system.addrinfo rai_static
+            system.sockaddr_storage rai_addr_static
+            system.addrinfo lai_static
+            system.sockaddr_storage lai_addr_static
+
+            object app_protocol
+            object app_transport
+            object protocol
+            object ssl_waiter
+
+        if sock is not None and sock.family == uv.AF_UNIX:
+            if host is not None or port is not None:
+                raise ValueError(
+                    'host/port and sock can not be specified at the same time')
+            return await self.create_unix_connection(
+                protocol_factory, None,
+                sock=sock, ssl=ssl, server_hostname=server_hostname)
+
+        app_protocol = protocol = protocol_factory()
+        ssl_waiter = None
+        context = Context_CopyCurrent()
+        if ssl:
+            if server_hostname is None:
+                if not host:
+                    raise ValueError('You must set server_hostname '
+                                     'when using ssl without a host')
+                server_hostname = host
+
+            ssl_waiter = self._new_future()
+            sslcontext = None if isinstance(ssl, bool) else ssl
+            protocol = SSLProtocol(
+                self, app_protocol, sslcontext, ssl_waiter,
+                False, server_hostname,
+                ssl_handshake_timeout=ssl_handshake_timeout,
+                ssl_shutdown_timeout=ssl_shutdown_timeout)
+        else:
+            if server_hostname is not None:
+                raise ValueError('server_hostname is only meaningful with ssl')
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        if host is not None or port is not None:
+            if sock is not None:
+                raise ValueError(
+                    'host/port and sock can not be specified at the same time')
+
+            fs = []
+            f1 = f2 = None
+
+            addr = __static_getaddrinfo(
+                host, port, family, uv.SOCK_STREAM,
+                proto, <system.sockaddr*>&rai_addr_static)
+
+            if addr is None:
+                f1 = self._getaddrinfo(
+                    host, port, family,
+                    uv.SOCK_STREAM, proto, flags,
+                    0)  # 0 == don't unpack
+
+                fs.append(f1)
+            else:
+                rai_static.ai_addr = <system.sockaddr*>&rai_addr_static
+                rai_static.ai_next = NULL
+                rai = &rai_static
+
+            if local_addr is not None:
+                if not isinstance(local_addr, (tuple, list)) or \
+                        len(local_addr) != 2:
+                    raise ValueError(
+                        'local_addr must be a tuple of host and port')
+
+                addr = __static_getaddrinfo(
+                    local_addr[0], local_addr[1],
+                    family, uv.SOCK_STREAM,
+                    proto, <system.sockaddr*>&lai_addr_static)
+                if addr is None:
+                    f2 = self._getaddrinfo(
+                        local_addr[0], local_addr[1], family,
+                        uv.SOCK_STREAM, proto, flags,
+                        0)  # 0 == don't unpack
+
+                    fs.append(f2)
+                else:
+                    lai_static.ai_addr = <system.sockaddr*>&lai_addr_static
+                    lai_static.ai_next = NULL
+                    lai = &lai_static
+
+            if len(fs):
+                await aio_wait(fs)
+
+            if rai is NULL:
+                ai_remote = f1.result()
+                if ai_remote.data is NULL:
+                    raise OSError('getaddrinfo() returned empty list')
+                rai = ai_remote.data
+
+            if lai is NULL and f2 is not None:
+                ai_local = f2.result()
+                if ai_local.data is NULL:
+                    raise OSError(
+                        'getaddrinfo() returned empty list for local_addr')
+                lai = ai_local.data
+
+            exceptions = []
+            rai_iter = rai
+            while rai_iter is not NULL:
+                tr = None
+                try:
+                    waiter = self._new_future()
+                    tr = TCPTransport.new(self, protocol, None, waiter,
+                                          context)
+
+                    if lai is not NULL:
+                        lai_iter = lai
+                        while lai_iter is not NULL:
+                            try:
+                                tr.bind(lai_iter.ai_addr)
+                                break
+                            except OSError as exc:
+                                exceptions.append(exc)
+                            lai_iter = lai_iter.ai_next
+                        else:
+                            tr._close()
+                            tr = None
+
+                            rai_iter = rai_iter.ai_next
+                            continue
+
+                    tr.connect(rai_iter.ai_addr)
+                    await waiter
+
+                except OSError as exc:
+                    if tr is not None:
+                        tr._close()
+                        tr = None
+                    exceptions.append(exc)
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except BaseException:
+                    if tr is not None:
+                        tr._close()
+                        tr = None
+                    raise
+                else:
+                    break
+
+                rai_iter = rai_iter.ai_next
+
+            else:
+                # If they all have the same str(), raise one.
+                model = str(exceptions[0])
+                if all(str(exc) == model for exc in exceptions):
+                    raise exceptions[0]
+                # Raise a combined exception so the user can see all
+                # the various error messages.
+                raise OSError('Multiple exceptions: {}'.format(
+                    ', '.join(str(exc) for exc in exceptions)))
+        else:
+            if sock is None:
+                raise ValueError(
+                    'host and port was not specified and no sock specified')
+            if not _is_sock_stream(sock.type):
+                raise ValueError(
+                    'A Stream Socket was expected, got {!r}'.format(sock))
+
+            # libuv will set the socket to non-blocking mode, but
+            # we want Python socket object to notice that.
+            sock.setblocking(False)
+
+            waiter = self._new_future()
+            tr = TCPTransport.new(self, protocol, None, waiter, context)
+            try:
+                # libuv will make socket non-blocking
+                tr._open(sock.fileno())
+                tr._init_protocol()
+                await waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                # It's OK to call `_close()` here, as opposed to
+                # `_force_close()` or `close()` as we want to terminate the
+                # transport immediately.  The `waiter` can only be waken
+                # up in `Transport._call_connection_made()`, and calling
+                # `_close()` before it is fine.
+                tr._close()
+                raise
+
+            tr._attach_fileobj(sock)
+
+        if ssl:
+            app_transport = protocol._get_app_transport(context)
+            try:
+                await ssl_waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                app_transport.close()
+                raise
+            return app_transport, app_protocol
+        else:
+            return tr, protocol
+
+    @cython.iterable_coroutine
+    async def create_unix_server(self, protocol_factory, path=None,
+                                 *, backlog=100, sock=None, ssl=None,
+                                 ssl_handshake_timeout=None,
+                                 ssl_shutdown_timeout=None,
+                                 start_serving=True):
+        """A coroutine which creates a UNIX Domain Socket server.
+
+        The return value is a Server object, which can be used to stop
+        the service.
+
+        path is a str, representing a file systsem path to bind the
+        server socket to.
+
+        sock can optionally be specified in order to use a preexisting
+        socket object.
+
+        backlog is the maximum number of queued connections passed to
+        listen() (defaults to 100).
+
+        ssl can be set to an SSLContext to enable SSL over the
+        accepted connections.
+
+        ssl_handshake_timeout is the time in seconds that an SSL server
+        will wait for completion of the SSL handshake before aborting the
+        connection. Default is 60s.
+
+        ssl_shutdown_timeout is the time in seconds that an SSL server
+        will wait for completion of the SSL shutdown before aborting the
+        connection. Default is 30s.
+        """
+        cdef:
+            UnixServer pipe
+            Server server = Server(self)
+
+        if ssl is not None:
+            if not isinstance(ssl, ssl_SSLContext):
+                raise TypeError('ssl argument must be an SSLContext or None')
+        else:
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        if path is not None:
+            if sock is not None:
+                raise ValueError(
+                    'path and sock can not be specified at the same time')
+            orig_path = path
+
+            path = os_fspath(path)
+
+            if isinstance(path, str):
+                path = PyUnicode_EncodeFSDefault(path)
+
+            # Check for abstract socket.
+            if path[0] != 0:
+                try:
+                    if stat_S_ISSOCK(os_stat(path).st_mode):
+                        os_remove(path)
+                except FileNotFoundError:
+                    pass
+                except OSError as err:
+                    # Directory may have permissions only to create socket.
+                    aio_logger.error(
+                        'Unable to check or remove stale UNIX socket %r: %r',
+                        orig_path, err)
+
+            # We use Python sockets to create a UNIX server socket because
+            # when UNIX sockets are created by libuv, libuv removes the path
+            # they were bound to.  This is different from asyncio, which
+            # doesn't cleanup the socket path.
+            sock = socket_socket(uv.AF_UNIX)
+
+            try:
+                sock.bind(path)
+            except OSError as exc:
+                sock.close()
+                if exc.errno == errno.EADDRINUSE:
+                    # Let's improve the error message by adding
+                    # with what exact address it occurs.
+                    msg = 'Address {!r} is already in use'.format(orig_path)
+                    raise OSError(errno.EADDRINUSE, msg) from None
+                else:
+                    raise
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                sock.close()
+                raise
+
+        else:
+            if sock is None:
+                raise ValueError(
+                    'path was not specified, and no sock specified')
+
+            if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
+                raise ValueError(
+                    'A UNIX Domain Stream Socket was expected, got {!r}'
+                    .format(sock))
+
+            # libuv will set the socket to non-blocking mode, but
+            # we want Python socket object to notice that.
+            sock.setblocking(False)
+
+        pipe = UnixServer.new(
+            self, protocol_factory, server, backlog,
+            ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+
+        try:
+            pipe._open(sock.fileno())
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException:
+            pipe._close()
+            sock.close()
+            raise
+
+        pipe._attach_fileobj(sock)
+        server._add_server(pipe)
+
+        if start_serving:
+            server._start_serving()
+
+        return server
+
+    @cython.iterable_coroutine
+    async def create_unix_connection(self, protocol_factory, path=None, *,
+                                     ssl=None, sock=None,
+                                     server_hostname=None,
+                                     ssl_handshake_timeout=None,
+                                     ssl_shutdown_timeout=None):
+
+        cdef:
+            UnixTransport tr
+            object app_protocol
+            object app_transport
+            object protocol
+            object ssl_waiter
+
+        app_protocol = protocol = protocol_factory()
+        ssl_waiter = None
+        context = Context_CopyCurrent()
+        if ssl:
+            if server_hostname is None:
+                raise ValueError('You must set server_hostname '
+                                 'when using ssl without a host')
+
+            ssl_waiter = self._new_future()
+            sslcontext = None if isinstance(ssl, bool) else ssl
+            protocol = SSLProtocol(
+                self, app_protocol, sslcontext, ssl_waiter,
+                False, server_hostname,
+                ssl_handshake_timeout=ssl_handshake_timeout,
+                ssl_shutdown_timeout=ssl_shutdown_timeout)
+        else:
+            if server_hostname is not None:
+                raise ValueError('server_hostname is only meaningful with ssl')
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        if path is not None:
+            if sock is not None:
+                raise ValueError(
+                    'path and sock can not be specified at the same time')
+
+            path = os_fspath(path)
+
+            if isinstance(path, str):
+                path = PyUnicode_EncodeFSDefault(path)
+
+            waiter = self._new_future()
+            tr = UnixTransport.new(self, protocol, None, waiter, context)
+            tr.connect(path)
+            try:
+                await waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                tr._close()
+                raise
+
+        else:
+            if sock is None:
+                raise ValueError('no path and sock were specified')
+
+            if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
+                raise ValueError(
+                    'A UNIX Domain Stream Socket was expected, got {!r}'
+                    .format(sock))
+
+            # libuv will set the socket to non-blocking mode, but
+            # we want Python socket object to notice that.
+            sock.setblocking(False)
+
+            waiter = self._new_future()
+            tr = UnixTransport.new(self, protocol, None, waiter, context)
+            try:
+                tr._open(sock.fileno())
+                tr._init_protocol()
+                await waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                tr._close()
+                raise
+
+            tr._attach_fileobj(sock)
+
+        if ssl:
+            app_transport = protocol._get_app_transport(Context_CopyCurrent())
+            try:
+                await ssl_waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                app_transport.close()
+                raise
+            return app_transport, app_protocol
+        else:
+            return tr, protocol
+
+    def default_exception_handler(self, context):
+        """Default exception handler.
+
+        This is called when an exception occurs and no exception
+        handler is set, and can be called by a custom exception
+        handler that wants to defer to the default behavior.
+
+        The context parameter has the same meaning as in
+        `call_exception_handler()`.
+        """
+        message = context.get('message')
+        if not message:
+            message = 'Unhandled exception in event loop'
+
+        exception = context.get('exception')
+        if exception is not None:
+            exc_info = (type(exception), exception, exception.__traceback__)
+        else:
+            exc_info = False
+
+        log_lines = [message]
+        for key in sorted(context):
+            if key in {'message', 'exception'}:
+                continue
+            value = context[key]
+            if key == 'source_traceback':
+                tb = ''.join(tb_format_list(value))
+                value = 'Object created at (most recent call last):\n'
+                value += tb.rstrip()
+            else:
+                try:
+                    value = repr(value)
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except BaseException as ex:
+                    value = ('Exception in __repr__ {!r}; '
+                             'value type: {!r}'.format(ex, type(value)))
+            log_lines.append('{}: {}'.format(key, value))
+
+        aio_logger.error('\n'.join(log_lines), exc_info=exc_info)
+
+    def get_exception_handler(self):
+        """Return an exception handler, or None if the default one is in use.
+        """
+        return self._exception_handler
+
+    def set_exception_handler(self, handler):
+        """Set handler as the new event loop exception handler.
+
+        If handler is None, the default exception handler will
+        be set.
+
+        If handler is a callable object, it should have a
+        signature matching '(loop, context)', where 'loop'
+        will be a reference to the active event loop, 'context'
+        will be a dict object (see `call_exception_handler()`
+        documentation for details about context).
+        """
+        if handler is not None and not callable(handler):
+            raise TypeError('A callable object or None is expected, '
+                            'got {!r}'.format(handler))
+        self._exception_handler = handler
+
+    def call_exception_handler(self, context):
+        """Call the current event loop's exception handler.
+
+        The context argument is a dict containing the following keys:
+
+        - 'message': Error message;
+        - 'exception' (optional): Exception object;
+        - 'future' (optional): Future instance;
+        - 'handle' (optional): Handle instance;
+        - 'protocol' (optional): Protocol instance;
+        - 'transport' (optional): Transport instance;
+        - 'socket' (optional): Socket instance.
+
+        New keys maybe introduced in the future.
+
+        Note: do not overload this method in an event loop subclass.
+        For custom exception handling, use the
+        `set_exception_handler()` method.
+        """
+        if UVLOOP_DEBUG:
+            self._debug_exception_handler_cnt += 1
+
+        if self._exception_handler is None:
+            try:
+                self.default_exception_handler(context)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                # Second protection layer for unexpected errors
+                # in the default implementation, as well as for subclassed
+                # event loops with overloaded "default_exception_handler".
+                aio_logger.error('Exception in default exception handler',
+                                 exc_info=True)
+        else:
+            try:
+                self._exception_handler(self, context)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as exc:
+                # Exception in the user set custom exception handler.
+                try:
+                    # Let's try default handler.
+                    self.default_exception_handler({
+                        'message': 'Unhandled error in exception handler',
+                        'exception': exc,
+                        'context': context,
+                    })
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except BaseException:
+                    # Guard 'default_exception_handler' in case it is
+                    # overloaded.
+                    aio_logger.error('Exception in default exception handler '
+                                     'while handling an unexpected error '
+                                     'in custom exception handler',
+                                     exc_info=True)
+
+    def add_reader(self, fileobj, callback, *args):
+        """Add a reader callback."""
+        if len(args) == 0:
+            args = None
+        self._add_reader(fileobj, new_Handle(self, callback, args, None))
+
+    def remove_reader(self, fileobj):
+        """Remove a reader callback."""
+        self._remove_reader(fileobj)
+
+    def add_writer(self, fileobj, callback, *args):
+        """Add a writer callback.."""
+        if len(args) == 0:
+            args = None
+        self._add_writer(fileobj, new_Handle(self, callback, args, None))
+
+    def remove_writer(self, fileobj):
+        """Remove a writer callback."""
+        self._remove_writer(fileobj)
+
+    @cython.iterable_coroutine
+    async def sock_recv(self, sock, n):
+        """Receive data from the socket.
+
+        The return value is a bytes object representing the data received.
+        The maximum amount of data to be received at once is specified by
+        nbytes.
+
+        This method is a coroutine.
+        """
+        cdef:
+            Handle handle
+
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
+
+        fut = _SyncSocketReaderFuture(sock, self)
+        handle = new_MethodHandle3(
+            self,
+            "Loop._sock_recv",
+            <method3_t>self._sock_recv,
+            None,
+            self,
+            fut, sock, n)
+
+        self._add_reader(sock, handle)
+        return await fut
+
+    @cython.iterable_coroutine
+    async def sock_recv_into(self, sock, buf):
+        """Receive data from the socket.
+
+        The received data is written into *buf* (a writable buffer).
+        The return value is the number of bytes written.
+
+        This method is a coroutine.
+        """
+        cdef:
+            Handle handle
+
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
+
+        fut = _SyncSocketReaderFuture(sock, self)
+        handle = new_MethodHandle3(
+            self,
+            "Loop._sock_recv_into",
+            <method3_t>self._sock_recv_into,
+            None,
+            self,
+            fut, sock, buf)
+
+        self._add_reader(sock, handle)
+        return await fut
+
+    @cython.iterable_coroutine
+    async def sock_sendall(self, sock, data):
+        """Send data to the socket.
+
+        The socket must be connected to a remote socket. This method continues
+        to send data from data until either all data has been sent or an
+        error occurs. None is returned on success. On error, an exception is
+        raised, and there is no way to determine how much data, if any, was
+        successfully processed by the receiving end of the connection.
+
+        This method is a coroutine.
+        """
+        cdef:
+            Handle handle
+            ssize_t n
+
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
+
+        if not data:
+            return
+
+        socket_inc_io_ref(sock)
+        try:
+            try:
+                n = sock.send(data)
+            except (BlockingIOError, InterruptedError):
+                pass
+            else:
+                if UVLOOP_DEBUG:
+                    # This can be a partial success, i.e. only part
+                    # of the data was sent
+                    self._sock_try_write_total += 1
+
+                if n == len(data):
+                    return
+                if not isinstance(data, memoryview):
+                    data = memoryview(data)
+                data = data[n:]
+
+            fut = _SyncSocketWriterFuture(sock, self)
+            handle = new_MethodHandle3(
+                self,
+                "Loop._sock_sendall",
+                <method3_t>self._sock_sendall,
+                None,
+                self,
+                fut, sock, data)
+
+            self._add_writer(sock, handle)
+            return await fut
+        finally:
+            socket_dec_io_ref(sock)
+
+    @cython.iterable_coroutine
+    async def sock_accept(self, sock):
+        """Accept a connection.
+
+        The socket must be bound to an address and listening for connections.
+        The return value is a pair (conn, address) where conn is a new socket
+        object usable to send and receive data on the connection, and address
+        is the address bound to the socket on the other end of the connection.
+
+        This method is a coroutine.
+        """
+        cdef:
+            Handle handle
+
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
+
+        fut = _SyncSocketReaderFuture(sock, self)
+        handle = new_MethodHandle2(
+            self,
+            "Loop._sock_accept",
+            <method2_t>self._sock_accept,
+            None,
+            self,
+            fut, sock)
+
+        self._add_reader(sock, handle)
+        return await fut
+
+    @cython.iterable_coroutine
+    async def sock_connect(self, sock, address):
+        """Connect to a remote socket at address.
+
+        This method is a coroutine.
+        """
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
+
+        socket_inc_io_ref(sock)
+        try:
+            if sock.family == uv.AF_UNIX:
+                fut = self._sock_connect(sock, address)
+            else:
+                addrs = await self.getaddrinfo(
+                    *address[:2], family=sock.family)
+
+                _, _, _, _, address = addrs[0]
+                fut = self._sock_connect(sock, address)
+            if fut is not None:
+                await fut
+        finally:
+            socket_dec_io_ref(sock)
+
+    @cython.iterable_coroutine
+    async def connect_accepted_socket(self, protocol_factory, sock, *,
+                                      ssl=None,
+                                      ssl_handshake_timeout=None,
+                                      ssl_shutdown_timeout=None):
+        """Handle an accepted connection.
+
+        This is used by servers that accept connections outside of
+        asyncio but that use asyncio to handle connections.
+
+        This method is a coroutine.  When completed, the coroutine
+        returns a (transport, protocol) pair.
+        """
+
+        cdef:
+            UVStream transport = None
+
+        if ssl is not None:
+            if not isinstance(ssl, ssl_SSLContext):
+                raise TypeError('ssl argument must be an SSLContext or None')
+        else:
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        if not _is_sock_stream(sock.type):
+            raise ValueError(
+                'A Stream Socket was expected, got {!r}'.format(sock))
+
+        app_protocol = protocol_factory()
+        waiter = self._new_future()
+        transport_waiter = None
+        context = Context_CopyCurrent()
+
+        if ssl is None:
+            protocol = app_protocol
+            transport_waiter = waiter
+        else:
+            protocol = SSLProtocol(
+                self, app_protocol, ssl, waiter,
+                server_side=True,
+                server_hostname=None,
+                ssl_handshake_timeout=ssl_handshake_timeout,
+                ssl_shutdown_timeout=ssl_shutdown_timeout)
+            transport_waiter = None
+
+        if sock.family == uv.AF_UNIX:
+            transport = <UVStream>UnixTransport.new(
+                self, protocol, None, transport_waiter, context)
+        elif sock.family in (uv.AF_INET, uv.AF_INET6):
+            transport = <UVStream>TCPTransport.new(
+                self, protocol, None, transport_waiter, context)
+
+        if transport is None:
+            raise ValueError(
+                'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
+
+        transport._open(sock.fileno())
+        transport._init_protocol()
+        transport._attach_fileobj(sock)
+
+        if ssl:
+            app_transport = protocol._get_app_transport(context)
+            try:
+                await waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                app_transport.close()
+                raise
+            return app_transport, protocol
+        else:
+            try:
+                await waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                transport._close()
+                raise
+            return transport, protocol
+
+    def run_in_executor(self, executor, func, *args):
+        if aio_iscoroutine(func) or aio_iscoroutinefunction(func):
+            raise TypeError("coroutines cannot be used with run_in_executor()")
+
+        self._check_closed()
+
+        if executor is None:
+            executor = self._default_executor
+            # Only check when the default executor is being used
+            self._check_default_executor()
+            if executor is None:
+                executor = cc_ThreadPoolExecutor()
+                self._default_executor = executor
+
+        return aio_wrap_future(executor.submit(func, *args), loop=self)
+
+    def set_default_executor(self, executor):
+        self._default_executor = executor
+
+    @cython.iterable_coroutine
+    async def __subprocess_run(self, protocol_factory, args,
+                               stdin=subprocess_PIPE,
+                               stdout=subprocess_PIPE,
+                               stderr=subprocess_PIPE,
+                               universal_newlines=False,
+                               shell=True,
+                               bufsize=0,
+                               preexec_fn=None,
+                               close_fds=None,
+                               cwd=None,
+                               env=None,
+                               startupinfo=None,
+                               creationflags=0,
+                               restore_signals=True,
+                               start_new_session=False,
+                               executable=None,
+                               pass_fds=(),
+                               # For tests only! Do not use in your code. Ever.
+                               __uvloop_sleep_after_fork=False):
+
+        # TODO: Implement close_fds (might not be very important in
+        # Python 3.5, since all FDs aren't inheritable by default.)
+
+        cdef:
+            int debug_flags = 0
+
+        if universal_newlines:
+            raise ValueError("universal_newlines must be False")
+        if bufsize != 0:
+            raise ValueError("bufsize must be 0")
+        if startupinfo is not None:
+            raise ValueError('startupinfo is not supported')
+        if creationflags != 0:
+            raise ValueError('creationflags is not supported')
+
+        if executable is not None:
+            args[0] = executable
+
+        if __uvloop_sleep_after_fork:
+            debug_flags |= __PROCESS_DEBUG_SLEEP_AFTER_FORK
+
+        waiter = self._new_future()
+        protocol = protocol_factory()
+        proc = UVProcessTransport.new(self, protocol,
+                                      args, env, cwd, start_new_session,
+                                      stdin, stdout, stderr, pass_fds,
+                                      waiter,
+                                      debug_flags,
+                                      preexec_fn,
+                                      restore_signals)
+
+        try:
+            await waiter
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException:
+            proc.close()
+            raise
+
+        return proc, protocol
+
+    @cython.iterable_coroutine
+    async def subprocess_shell(self, protocol_factory, cmd, *,
+                               shell=True,
+                               **kwargs):
+
+        if not shell:
+            raise ValueError("shell must be True")
+
+        args = [cmd]
+        if shell:
+            args = [b'/bin/sh', b'-c'] + args
+
+        return await self.__subprocess_run(protocol_factory, args, shell=True,
+                                           **kwargs)
+
+    @cython.iterable_coroutine
+    async def subprocess_exec(self, protocol_factory, program, *args,
+                              shell=False, **kwargs):
+
+        if shell:
+            raise ValueError("shell must be False")
+
+        args = list((program,) + args)
+
+        return await self.__subprocess_run(protocol_factory, args, shell=False,
+                                           **kwargs)
+
+    @cython.iterable_coroutine
+    async def connect_read_pipe(self, proto_factory, pipe):
+        """Register read pipe in event loop. Set the pipe to non-blocking mode.
+
+        protocol_factory should instantiate object with Protocol interface.
+        pipe is a file-like object.
+        Return pair (transport, protocol), where transport supports the
+        ReadTransport interface."""
+        cdef:
+            ReadUnixTransport transp
+
+        waiter = self._new_future()
+        proto = proto_factory()
+        transp = ReadUnixTransport.new(self, proto, None, waiter)
+        transp._add_extra_info('pipe', pipe)
+        try:
+            transp._open(pipe.fileno())
+            transp._init_protocol()
+            await waiter
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException:
+            transp._close()
+            raise
+        transp._attach_fileobj(pipe)
+        return transp, proto
+
+    @cython.iterable_coroutine
+    async def connect_write_pipe(self, proto_factory, pipe):
+        """Register write pipe in event loop.
+
+        protocol_factory should instantiate object with BaseProtocol interface.
+        Pipe is file-like object already switched to nonblocking.
+        Return pair (transport, protocol), where transport support
+        WriteTransport interface."""
+        cdef:
+            WriteUnixTransport transp
+
+        waiter = self._new_future()
+        proto = proto_factory()
+        transp = WriteUnixTransport.new(self, proto, None, waiter)
+        transp._add_extra_info('pipe', pipe)
+        try:
+            transp._open(pipe.fileno())
+            transp._init_protocol()
+            await waiter
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException:
+            transp._close()
+            raise
+        transp._attach_fileobj(pipe)
+        return transp, proto
+
+    def add_signal_handler(self, sig, callback, *args):
+        """Add a handler for a signal.  UNIX only.
+
+        Raise ValueError if the signal number is invalid or uncatchable.
+        Raise RuntimeError if there is a problem setting up the handler.
+        """
+        cdef:
+            Handle h
+
+        if not self._is_main_thread():
+            raise ValueError(
+                'add_signal_handler() can only be called from '
+                'the main thread')
+
+        if (aio_iscoroutine(callback)
+                or aio_iscoroutinefunction(callback)):
+            raise TypeError(
+                "coroutines cannot be used with add_signal_handler()")
+
+        if sig == uv.SIGCHLD:
+            if (hasattr(callback, '__self__') and
+                    isinstance(callback.__self__, aio_AbstractChildWatcher)):
+
+                warnings_warn(
+                    "!!! asyncio is trying to install its ChildWatcher for "
+                    "SIGCHLD signal !!!\n\nThis is probably because a uvloop "
+                    "instance is used with asyncio.set_event_loop(). "
+                    "The correct way to use uvloop is to install its policy: "
+                    "`asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())`"
+                    "\n\n", RuntimeWarning, source=self)
+
+                # TODO: ideally we should always raise an error here,
+                # but that would be a backwards incompatible change,
+                # because we recommended using "asyncio.set_event_loop()"
+                # in our README.  Need to start a deprecation period
+                # at some point to turn this warning into an error.
+                return
+
+            raise RuntimeError(
+                'cannot add a signal handler for SIGCHLD: it is used '
+                'by the event loop to track subprocesses')
+
+        self._check_signal(sig)
+        self._check_closed()
+
+        h = new_Handle(self, callback, args or None, None)
+        self._signal_handlers[sig] = h
+
+        try:
+            # Register a dummy signal handler to ask Python to write the signal
+            # number in the wakeup file descriptor.
+            signal_signal(sig, self.__sighandler)
+
+            # Set SA_RESTART to limit EINTR occurrences.
+            signal_siginterrupt(sig, False)
+        except OSError as exc:
+            del self._signal_handlers[sig]
+            if not self._signal_handlers:
+                try:
+                    signal_set_wakeup_fd(-1)
+                except (ValueError, OSError) as nexc:
+                    aio_logger.info('set_wakeup_fd(-1) failed: %s', nexc)
+
+            if exc.errno == errno_EINVAL:
+                raise RuntimeError('sig {} cannot be caught'.format(sig))
+            else:
+                raise
+
+    def remove_signal_handler(self, sig):
+        """Remove a handler for a signal.  UNIX only.
+
+        Return True if a signal handler was removed, False if not.
+        """
+
+        if not self._is_main_thread():
+            raise ValueError(
+                'remove_signal_handler() can only be called from '
+                'the main thread')
+
+        self._check_signal(sig)
+
+        if not self._listening_signals:
+            return False
+
+        try:
+            del self._signal_handlers[sig]
+        except KeyError:
+            return False
+
+        if sig == uv.SIGINT:
+            handler = signal_default_int_handler
+        else:
+            handler = signal_SIG_DFL
+
+        try:
+            signal_signal(sig, handler)
+        except OSError as exc:
+            if exc.errno == errno_EINVAL:
+                raise RuntimeError('sig {} cannot be caught'.format(sig))
+            else:
+                raise
+
+        return True
+
+    @cython.iterable_coroutine
+    async def create_datagram_endpoint(self, protocol_factory,
+                                       local_addr=None, remote_addr=None, *,
+                                       family=0, proto=0, flags=0,
+                                       reuse_address=_unset, reuse_port=None,
+                                       allow_broadcast=None, sock=None):
+        """A coroutine which creates a datagram endpoint.
+
+        This method will try to establish the endpoint in the background.
+        When successful, the coroutine returns a (transport, protocol) pair.
+
+        protocol_factory must be a callable returning a protocol instance.
+
+        socket family AF_INET or socket.AF_INET6 depending on host (or
+        family if specified), socket type SOCK_DGRAM.
+
+        reuse_port tells the kernel to allow this endpoint to be bound to
+        the same port as other existing endpoints are bound to, so long as
+        they all set this flag when being created. This option is not
+        supported on Windows and some UNIX's. If the
+        :py:data:`~socket.SO_REUSEPORT` constant is not defined then this
+        capability is unsupported.
+
+        allow_broadcast tells the kernel to allow this endpoint to send
+        messages to the broadcast address.
+
+        sock can optionally be specified in order to use a preexisting
+        socket object.
+        """
+        cdef:
+            UDPTransport udp = None
+            system.addrinfo * lai
+            system.addrinfo * rai
+
+        if sock is not None:
+            if not _is_sock_dgram(sock.type):
+                raise ValueError(
+                    'A UDP Socket was expected, got {!r}'.format(sock))
+            if (local_addr or remote_addr or
+                    family or proto or flags or
+                    reuse_port or allow_broadcast):
+                # show the problematic kwargs in exception msg
+                opts = dict(local_addr=local_addr, remote_addr=remote_addr,
+                            family=family, proto=proto, flags=flags,
+                            reuse_address=reuse_address, reuse_port=reuse_port,
+                            allow_broadcast=allow_broadcast)
+                problems = ', '.join(
+                    '{}={}'.format(k, v) for k, v in opts.items() if v)
+                raise ValueError(
+                    'socket modifier keyword arguments can not be used '
+                    'when sock is specified. ({})'.format(problems))
+            sock.setblocking(False)
+            udp = UDPTransport.__new__(UDPTransport)
+            udp._init(self, uv.AF_UNSPEC)
+            udp.open(sock.family, sock.fileno())
+            udp._attach_fileobj(sock)
+        else:
+            if reuse_address is not _unset:
+                if reuse_address:
+                    raise ValueError("Passing `reuse_address=True` is no "
+                                     "longer supported, as the usage of "
+                                     "SO_REUSEPORT in UDP poses a significant "
+                                     "security concern.")
+                else:
+                    warnings_warn("The *reuse_address* parameter has been "
+                                  "deprecated as of 0.15.", DeprecationWarning,
+                                  stacklevel=2)
+            reuse_port = bool(reuse_port)
+            if reuse_port and not has_SO_REUSEPORT:
+                raise ValueError(
+                    'reuse_port not supported by socket module')
+
+            lads = None
+            if local_addr is not None:
+                if (not isinstance(local_addr, (tuple, list)) or
+                        len(local_addr) != 2):
+                    raise TypeError(
+                        'local_addr must be a tuple of (host, port)')
+                lads = await self._getaddrinfo(
+                    local_addr[0], local_addr[1],
+                    family, uv.SOCK_DGRAM, proto, flags,
+                    0)
+
+            rads = None
+            if remote_addr is not None:
+                if (not isinstance(remote_addr, (tuple, list)) or
+                        len(remote_addr) != 2):
+                    raise TypeError(
+                        'remote_addr must be a tuple of (host, port)')
+                rads = await self._getaddrinfo(
+                    remote_addr[0], remote_addr[1],
+                    family, uv.SOCK_DGRAM, proto, flags,
+                    0)
+
+            excs = []
+            if lads is None:
+                if rads is not None:
+                    udp = UDPTransport.__new__(UDPTransport)
+                    rai = (<AddrInfo>rads).data
+                    udp._init(self, rai.ai_family)
+                    udp._connect(rai.ai_addr, rai.ai_addrlen)
+                    udp._set_address(rai)
+                else:
+                    if family not in (uv.AF_INET, uv.AF_INET6):
+                        raise ValueError('unexpected address family')
+                    udp = UDPTransport.__new__(UDPTransport)
+                    udp._init(self, family)
+
+                if reuse_port:
+                    self._sock_set_reuseport(udp._fileno())
+
+            else:
+                lai = (<AddrInfo>lads).data
+                while lai is not NULL:
+                    try:
+                        udp = UDPTransport.__new__(UDPTransport)
+                        udp._init(self, lai.ai_family)
+                        if reuse_port:
+                            self._sock_set_reuseport(udp._fileno())
+                        udp._bind(lai.ai_addr)
+                    except (KeyboardInterrupt, SystemExit):
+                        raise
+                    except BaseException as ex:
+                        lai = lai.ai_next
+                        excs.append(ex)
+                        continue
+                    else:
+                        break
+                else:
+                    ctx = None
+                    if len(excs):
+                        ctx = excs[0]
+                    raise OSError('could not bind to local_addr {}'.format(
+                        local_addr)) from ctx
+
+                if rads is not None:
+                    rai = (<AddrInfo>rads).data
+                    while rai is not NULL:
+                        if rai.ai_family != lai.ai_family:
+                            rai = rai.ai_next
+                            continue
+                        if rai.ai_protocol != lai.ai_protocol:
+                            rai = rai.ai_next
+                            continue
+                        udp._connect(rai.ai_addr, rai.ai_addrlen)
+                        udp._set_address(rai)
+                        break
+                    else:
+                        raise OSError(
+                            'could not bind to remote_addr {}'.format(
+                                remote_addr))
+
+        if allow_broadcast:
+            udp._set_broadcast(1)
+
+        protocol = protocol_factory()
+        waiter = self._new_future()
+        assert udp is not None
+        udp._set_protocol(protocol)
+        udp._set_waiter(waiter)
+        udp._init_protocol()
+
+        await waiter
+        return udp, protocol
+
+    def _check_default_executor(self):
+        if self._executor_shutdown_called:
+            raise RuntimeError('Executor shutdown has been called')
+
+    def _asyncgen_finalizer_hook(self, agen):
+        self._asyncgens.discard(agen)
+        if not self.is_closed():
+            self.call_soon_threadsafe(self.create_task, agen.aclose())
+
+    def _asyncgen_firstiter_hook(self, agen):
+        if self._asyncgens_shutdown_called:
+            warnings_warn(
+                "asynchronous generator {!r} was scheduled after "
+                "loop.shutdown_asyncgens() call".format(agen),
+                ResourceWarning, source=self)
+
+        self._asyncgens.add(agen)
+
+    @cython.iterable_coroutine
+    async def shutdown_asyncgens(self):
+        """Shutdown all active asynchronous generators."""
+        self._asyncgens_shutdown_called = True
+
+        if not len(self._asyncgens):
+            return
+
+        closing_agens = list(self._asyncgens)
+        self._asyncgens.clear()
+
+        shutdown_coro = aio_gather(
+            *[ag.aclose() for ag in closing_agens],
+            return_exceptions=True)
+
+        results = await shutdown_coro
+        for result, agen in zip(results, closing_agens):
+            if isinstance(result, Exception):
+                self.call_exception_handler({
+                    'message': 'an error occurred during closing of '
+                               'asynchronous generator {!r}'.format(agen),
+                    'exception': result,
+                    'asyncgen': agen
+                })
+
+    @cython.iterable_coroutine
+    async def shutdown_default_executor(self):
+        """Schedule the shutdown of the default executor."""
+        self._executor_shutdown_called = True
+        if self._default_executor is None:
+            return
+        future = self.create_future()
+        thread = threading_Thread(target=self._do_shutdown, args=(future,))
+        thread.start()
+        try:
+            await future
+        finally:
+            thread.join()
+
+    def _do_shutdown(self, future):
+        try:
+            self._default_executor.shutdown(wait=True)
+            self.call_soon_threadsafe(future.set_result, None)
+        except Exception as ex:
+            self.call_soon_threadsafe(future.set_exception, ex)
+
+
+cdef void __loop_alloc_buffer(uv.uv_handle_t* uvhandle,
+                              size_t suggested_size,
+                              uv.uv_buf_t* buf) with gil:
+    cdef:
+        Loop loop = (<UVHandle>uvhandle.data)._loop
+
+    if loop._recv_buffer_in_use == 1:
+        buf.len = 0
+        exc = RuntimeError('concurrent allocations')
+        loop._handle_exception(exc)
+        return
+
+    loop._recv_buffer_in_use = 1
+    buf.base = loop._recv_buffer
+    buf.len = sizeof(loop._recv_buffer)
+
+
+cdef inline void __loop_free_buffer(Loop loop):
+    loop._recv_buffer_in_use = 0
+
+
+class _SyncSocketReaderFuture(aio_Future):
+
+    def __init__(self, sock, loop):
+        aio_Future.__init__(self, loop=loop)
+        self.__sock = sock
+        self.__loop = loop
+
+    def __remove_reader(self):
+        if self.__sock is not None and self.__sock.fileno() != -1:
+            self.__loop.remove_reader(self.__sock)
+            self.__sock = None
+
+    if PY39:
+        def cancel(self, msg=None):
+            self.__remove_reader()
+            aio_Future.cancel(self, msg=msg)
+
+    else:
+        def cancel(self):
+            self.__remove_reader()
+            aio_Future.cancel(self)
+
+
+class _SyncSocketWriterFuture(aio_Future):
+
+    def __init__(self, sock, loop):
+        aio_Future.__init__(self, loop=loop)
+        self.__sock = sock
+        self.__loop = loop
+
+    def __remove_writer(self):
+        if self.__sock is not None and self.__sock.fileno() != -1:
+            self.__loop.remove_writer(self.__sock)
+            self.__sock = None
+
+    if PY39:
+        def cancel(self, msg=None):
+            self.__remove_writer()
+            aio_Future.cancel(self, msg=msg)
+
+    else:
+        def cancel(self):
+            self.__remove_writer()
+            aio_Future.cancel(self)
+
+
+include "cbhandles.pyx"
+include "pseudosock.pyx"
+include "lru.pyx"
+
+include "handles/handle.pyx"
+include "handles/async_.pyx"
+include "handles/idle.pyx"
+include "handles/check.pyx"
+include "handles/timer.pyx"
+include "handles/poll.pyx"
+include "handles/basetransport.pyx"
+include "handles/stream.pyx"
+include "handles/streamserver.pyx"
+include "handles/tcp.pyx"
+include "handles/pipe.pyx"
+include "handles/process.pyx"
+
+include "request.pyx"
+include "dns.pyx"
+include "sslproto.pyx"
+
+include "handles/udp.pyx"
+
+include "server.pyx"
+
+
+# Used in UVProcess
+cdef vint __atfork_installed = 0
+cdef vint __forking = 0
+cdef Loop __forking_loop = None
+
+
+cdef void __get_fork_handler() nogil:
+    global __forking
+    global __forking_loop
+
+    with gil:
+        if (__forking and __forking_loop is not None and
+                __forking_loop.active_process_handler is not None):
+            __forking_loop.active_process_handler._after_fork()
+
+cdef __install_atfork():
+    global __atfork_installed
+    if __atfork_installed:
+        return
+    __atfork_installed = 1
+
+    cdef int err
+
+    err = system.pthread_atfork(NULL, NULL, &system.handleAtFork)
+    if err:
+        __atfork_installed = 0
+        raise convert_error(-err)
+
+
+# Install PyMem* memory allocators
+cdef vint __mem_installed = 0
+cdef __install_pymem():
+    global __mem_installed
+    if __mem_installed:
+        return
+    __mem_installed = 1
+
+    cdef int err
+    err = uv.uv_replace_allocator(<uv.uv_malloc_func>PyMem_RawMalloc,
+                                  <uv.uv_realloc_func>PyMem_RawRealloc,
+                                  <uv.uv_calloc_func>PyMem_RawCalloc,
+                                  <uv.uv_free_func>PyMem_RawFree)
+    if err < 0:
+        __mem_installed = 0
+        raise convert_error(err)
+
+
+cdef _set_signal_wakeup_fd(fd):
+    if fd >= 0:
+        return signal_set_wakeup_fd(fd, warn_on_full_buffer=False)
+    else:
+        return signal_set_wakeup_fd(fd)
+
+
+# Helpers for tests
+
+@cython.iterable_coroutine
+async def _test_coroutine_1():
+    return 42
diff --git a/myenv/lib/python3.9/site-packages/uvloop/lru.pyx b/myenv/lib/python3.9/site-packages/uvloop/lru.pyx
new file mode 100644
index 0000000..cc7ea1d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/lru.pyx
@@ -0,0 +1,79 @@
+cdef object _LRU_MARKER = object()
+
+
+@cython.final
+cdef class LruCache:
+
+    cdef:
+        object _dict
+        int _maxsize
+        object _dict_move_to_end
+        object _dict_get
+
+    # We use an OrderedDict for LRU implementation.  Operations:
+    #
+    # * We use a simple `__setitem__` to push a new entry:
+    #       `entries[key] = new_entry`
+    #   That will push `new_entry` to the *end* of the entries dict.
+    #
+    # * When we have a cache hit, we call
+    #       `entries.move_to_end(key, last=True)`
+    #   to move the entry to the *end* of the entries dict.
+    #
+    # * When we need to remove entries to maintain `max_size`, we call
+    #       `entries.popitem(last=False)`
+    #   to remove an entry from the *beginning* of the entries dict.
+    #
+    # So new entries and hits are always promoted to the end of the
+    # entries dict, whereas the unused one will group in the
+    # beginning of it.
+
+    def __init__(self, *, maxsize):
+        if maxsize <= 0:
+            raise ValueError(
+                f'maxsize is expected to be greater than 0, got {maxsize}')
+
+        self._dict = col_OrderedDict()
+        self._dict_move_to_end = self._dict.move_to_end
+        self._dict_get = self._dict.get
+        self._maxsize = maxsize
+
+    cdef get(self, key, default):
+        o = self._dict_get(key, _LRU_MARKER)
+        if o is _LRU_MARKER:
+            return default
+        self._dict_move_to_end(key)  # last=True
+        return o
+
+    cdef inline needs_cleanup(self):
+        return len(self._dict) > self._maxsize
+
+    cdef inline cleanup_one(self):
+        k, _ = self._dict.popitem(last=False)
+        return k
+
+    def __getitem__(self, key):
+        o = self._dict[key]
+        self._dict_move_to_end(key)  # last=True
+        return o
+
+    def __setitem__(self, key, o):
+        if key in self._dict:
+            self._dict[key] = o
+            self._dict_move_to_end(key)  # last=True
+        else:
+            self._dict[key] = o
+        while self.needs_cleanup():
+            self.cleanup_one()
+
+    def __delitem__(self, key):
+        del self._dict[key]
+
+    def __contains__(self, key):
+        return key in self._dict
+
+    def __len__(self):
+        return len(self._dict)
+
+    def __iter__(self):
+        return iter(self._dict)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/pseudosock.pyx b/myenv/lib/python3.9/site-packages/uvloop/pseudosock.pyx
new file mode 100644
index 0000000..70e114d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/pseudosock.pyx
@@ -0,0 +1,209 @@
+cdef class PseudoSocket:
+    cdef:
+        int _family
+        int _type
+        int _proto
+        int _fd
+        object _peername
+        object _sockname
+
+    def __init__(self, int family, int type, int proto, int fd):
+        self._family = family
+        self._type = type
+        self._proto = proto
+        self._fd = fd
+        self._peername = None
+        self._sockname = None
+
+    cdef _na(self, what):
+        raise TypeError('transport sockets do not support {}'.format(what))
+
+    cdef _make_sock(self):
+        return socket_socket(self._family, self._type, self._proto, self._fd)
+
+    property family:
+        def __get__(self):
+            try:
+                return socket_AddressFamily(self._family)
+            except ValueError:
+                return self._family
+
+    property type:
+        def __get__(self):
+            try:
+                return socket_SocketKind(self._type)
+            except ValueError:
+                return self._type
+
+    property proto:
+        def __get__(self):
+            return self._proto
+
+    def __repr__(self):
+        s = ("<uvloop.PseudoSocket fd={}, family={!s}, "
+             "type={!s}, proto={}").format(self.fileno(), self.family,
+                                           self.type, self.proto)
+
+        if self._fd != -1:
+            try:
+                laddr = self.getsockname()
+                if laddr:
+                    s += ", laddr=%s" % str(laddr)
+            except socket_error:
+                pass
+            try:
+                raddr = self.getpeername()
+                if raddr:
+                    s += ", raddr=%s" % str(raddr)
+            except socket_error:
+                pass
+        s += '>'
+        return s
+
+    def __getstate__(self):
+        raise TypeError("Cannot serialize socket object")
+
+    def fileno(self):
+        return self._fd
+
+    def dup(self):
+        fd = os_dup(self._fd)
+        sock = socket_socket(self._family, self._type, self._proto, fileno=fd)
+        sock.settimeout(0)
+        return sock
+
+    def get_inheritable(self):
+        return os_get_inheritable(self._fd)
+
+    def set_inheritable(self):
+        os_set_inheritable(self._fd)
+
+    def ioctl(self, *args, **kwargs):
+        pass
+
+    def getsockopt(self, *args, **kwargs):
+        sock = self._make_sock()
+        try:
+            return sock.getsockopt(*args, **kwargs)
+        finally:
+            sock.detach()
+
+    def setsockopt(self, *args, **kwargs):
+        sock = self._make_sock()
+        try:
+            return sock.setsockopt(*args, **kwargs)
+        finally:
+            sock.detach()
+
+    def getpeername(self):
+        if self._peername is not None:
+            return self._peername
+
+        sock = self._make_sock()
+        try:
+            self._peername = sock.getpeername()
+            return self._peername
+        finally:
+            sock.detach()
+
+    def getsockname(self):
+        if self._sockname is not None:
+            return self._sockname
+
+        sock = self._make_sock()
+        try:
+            self._sockname = sock.getsockname()
+            return self._sockname
+        finally:
+            sock.detach()
+
+    def share(self, process_id):
+        sock = self._make_sock()
+        try:
+            return sock.share(process_id)
+        finally:
+            sock.detach()
+
+    def accept(self):
+        self._na('accept() method')
+
+    def connect(self, *args):
+        self._na('connect() method')
+
+    def connect_ex(self, *args):
+        self._na('connect_ex() method')
+
+    def bind(self, *args):
+        self._na('bind() method')
+
+    def listen(self, *args, **kwargs):
+        self._na('listen() method')
+
+    def makefile(self):
+        self._na('makefile() method')
+
+    def sendfile(self, *args, **kwargs):
+        self._na('sendfile() method')
+
+    def close(self):
+        self._na('close() method')
+
+    def detach(self):
+        self._na('detach() method')
+
+    def shutdown(self, *args):
+        self._na('shutdown() method')
+
+    def sendmsg_afalg(self, *args, **kwargs):
+        self._na('sendmsg_afalg() method')
+
+    def sendmsg(self):
+        self._na('sendmsg() method')
+
+    def sendto(self, *args, **kwargs):
+        self._na('sendto() method')
+
+    def send(self, *args, **kwargs):
+        self._na('send() method')
+
+    def sendall(self, *args, **kwargs):
+        self._na('sendall() method')
+
+    def recv_into(self, *args, **kwargs):
+        self._na('recv_into() method')
+
+    def recvfrom_into(self, *args, **kwargs):
+        self._na('recvfrom_into() method')
+
+    def recvmsg_into(self, *args, **kwargs):
+        self._na('recvmsg_into() method')
+
+    def recvmsg(self, *args, **kwargs):
+        self._na('recvmsg() method')
+
+    def recvfrom(self, *args, **kwargs):
+        self._na('recvfrom() method')
+
+    def recv(self, *args, **kwargs):
+        self._na('recv() method')
+
+    def settimeout(self, value):
+        if value == 0:
+            return
+        raise ValueError(
+            'settimeout(): only 0 timeout is allowed on transport sockets')
+
+    def gettimeout(self):
+        return 0
+
+    def setblocking(self, flag):
+        if not flag:
+            return
+        raise ValueError(
+            'setblocking(): transport sockets cannot be blocking')
+
+    def __enter__(self):
+        self._na('context manager protocol')
+
+    def __exit__(self, *err):
+        self._na('context manager protocol')
diff --git a/myenv/lib/python3.9/site-packages/uvloop/py.typed b/myenv/lib/python3.9/site-packages/uvloop/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/uvloop/request.pxd b/myenv/lib/python3.9/site-packages/uvloop/request.pxd
new file mode 100644
index 0000000..bafa51d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/request.pxd
@@ -0,0 +1,8 @@
+cdef class UVRequest:
+    cdef:
+        uv.uv_req_t *request
+        bint done
+        Loop loop
+
+    cdef on_done(self)
+    cdef cancel(self)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/request.pyx b/myenv/lib/python3.9/site-packages/uvloop/request.pyx
new file mode 100644
index 0000000..f15103a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/request.pyx
@@ -0,0 +1,65 @@
+cdef class UVRequest:
+    """A base class for all libuv requests (uv_getaddrinfo_t, etc).
+
+    Important: it's a responsibility of the subclass to call the
+    "on_done" method in the request's callback.
+
+    If "on_done" isn't called, the request object will never die.
+    """
+
+    def __cinit__(self, Loop loop, *_):
+        self.request = NULL
+        self.loop = loop
+        self.done = 0
+        Py_INCREF(self)
+
+    cdef on_done(self):
+        self.done = 1
+        Py_DECREF(self)
+
+    cdef cancel(self):
+        # Most requests are implemented using a threadpool.  It's only
+        # possible to cancel a request when it's still in a threadpool's
+        # queue.  Once it's started to execute, we have to wait until
+        # it finishes and calls its callback (and callback *must* call
+        # UVRequest.on_done).
+
+        cdef int err
+
+        if self.done == 1:
+            return
+
+        if UVLOOP_DEBUG:
+            if self.request is NULL:
+                raise RuntimeError(
+                    '{}.cancel: .request is NULL'.format(
+                        self.__class__.__name__))
+
+            if self.request.data is NULL:
+                raise RuntimeError(
+                    '{}.cancel: .request.data is NULL'.format(
+                        self.__class__.__name__))
+
+            if <UVRequest>self.request.data is not self:
+                raise RuntimeError(
+                    '{}.cancel: .request.data is not UVRequest'.format(
+                        self.__class__.__name__))
+
+        # We only can cancel pending requests.  Let's try.
+        err = uv.uv_cancel(self.request)
+        if err < 0:
+            if err == uv.UV_EBUSY:
+                # Can't close the request -- it's executing (see the first
+                # comment).  Loop will have to wait until the callback
+                # fires.
+                pass
+            elif err == uv.UV_EINVAL:
+                # From libuv docs:
+                #
+                #     Only cancellation of uv_fs_t, uv_getaddrinfo_t,
+                #     uv_getnameinfo_t and uv_work_t requests is currently
+                #     supported.
+                return
+            else:
+                ex = convert_error(err)
+                self.loop._handle_exception(ex)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/server.pxd b/myenv/lib/python3.9/site-packages/uvloop/server.pxd
new file mode 100644
index 0000000..ef10f81
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/server.pxd
@@ -0,0 +1,19 @@
+cdef class Server:
+    cdef:
+        list _servers
+        list _waiters
+        int _active_count
+        Loop _loop
+        bint _serving
+        object _serving_forever_fut
+        object __weakref__
+
+    cdef _add_server(self, UVStreamServer srv)
+    cdef _start_serving(self)
+    cdef _wakeup(self)
+
+    cdef _attach(self)
+    cdef _detach(self)
+
+    cdef _ref(self)
+    cdef _unref(self)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/server.pyx b/myenv/lib/python3.9/site-packages/uvloop/server.pyx
new file mode 100644
index 0000000..845bcfd
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/server.pyx
@@ -0,0 +1,136 @@
+import asyncio
+
+
+cdef class Server:
+    def __cinit__(self, Loop loop):
+        self._loop = loop
+        self._servers = []
+        self._waiters = []
+        self._active_count = 0
+        self._serving_forever_fut = None
+
+    cdef _add_server(self, UVStreamServer srv):
+        self._servers.append(srv)
+
+    cdef _start_serving(self):
+        if self._serving:
+            return
+
+        self._serving = 1
+        for server in self._servers:
+            (<UVStreamServer>server).listen()
+
+    cdef _wakeup(self):
+        cdef list waiters
+
+        waiters = self._waiters
+        self._waiters = None
+        for waiter in waiters:
+            if not waiter.done():
+                waiter.set_result(waiter)
+
+    cdef _attach(self):
+        assert self._servers is not None
+        self._active_count += 1
+
+    cdef _detach(self):
+        assert self._active_count > 0
+        self._active_count -= 1
+        if self._active_count == 0 and self._servers is None:
+            self._wakeup()
+
+    cdef _ref(self):
+        # Keep the server object alive while it's not explicitly closed.
+        self._loop._servers.add(self)
+
+    cdef _unref(self):
+        self._loop._servers.discard(self)
+
+    # Public API
+
+    @cython.iterable_coroutine
+    async def __aenter__(self):
+        return self
+
+    @cython.iterable_coroutine
+    async def __aexit__(self, *exc):
+        self.close()
+        await self.wait_closed()
+
+    def __repr__(self):
+        return '<%s sockets=%r>' % (self.__class__.__name__, self.sockets)
+
+    def get_loop(self):
+        return self._loop
+
+    @cython.iterable_coroutine
+    async def wait_closed(self):
+        # Do not remove `self._servers is None` below
+        # because close() method only closes server sockets
+        # and existing client connections are left open.
+        if self._servers is None or self._waiters is None:
+            return
+        waiter = self._loop._new_future()
+        self._waiters.append(waiter)
+        await waiter
+
+    def close(self):
+        cdef list servers
+
+        if self._servers is None:
+            return
+
+        try:
+            servers = self._servers
+            self._servers = None
+            self._serving = 0
+
+            for server in servers:
+                (<UVStreamServer>server)._close()
+
+            if self._active_count == 0:
+                self._wakeup()
+        finally:
+            self._unref()
+
+    def is_serving(self):
+        return self._serving
+
+    @cython.iterable_coroutine
+    async def start_serving(self):
+        self._start_serving()
+
+    @cython.iterable_coroutine
+    async def serve_forever(self):
+        if self._serving_forever_fut is not None:
+            raise RuntimeError(
+                f'server {self!r} is already being awaited on serve_forever()')
+        if self._servers is None:
+            raise RuntimeError(f'server {self!r} is closed')
+
+        self._start_serving()
+        self._serving_forever_fut = self._loop.create_future()
+
+        try:
+            await self._serving_forever_fut
+        except asyncio.CancelledError:
+            try:
+                self.close()
+                await self.wait_closed()
+            finally:
+                raise
+        finally:
+            self._serving_forever_fut = None
+
+    property sockets:
+        def __get__(self):
+            cdef list sockets = []
+
+            # Guard against `self._servers is None`
+            if self._servers:
+                for server in self._servers:
+                    sockets.append(
+                        (<UVStreamServer>server)._get_socket()
+                    )
+
+            return sockets
diff --git a/myenv/lib/python3.9/site-packages/uvloop/sslproto.pxd b/myenv/lib/python3.9/site-packages/uvloop/sslproto.pxd
new file mode 100644
index 0000000..3da10f0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/sslproto.pxd
@@ -0,0 +1,138 @@
+cdef enum SSLProtocolState:
+    UNWRAPPED = 0
+    DO_HANDSHAKE = 1
+    WRAPPED = 2
+    FLUSHING = 3
+    SHUTDOWN = 4
+
+
+cdef enum AppProtocolState:
+    # This tracks the state of app protocol (https://git.io/fj59P):
+    #
+    #     INIT -cm-> CON_MADE [-dr*->] [-er-> EOF?] -cl-> CON_LOST
+    #
+    # * cm: connection_made()
+    # * dr: data_received()
+    # * er: eof_received()
+    # * cl: connection_lost()
+
+    STATE_INIT = 0
+    STATE_CON_MADE = 1
+    STATE_EOF = 2
+    STATE_CON_LOST = 3
+
+
+cdef class _SSLProtocolTransport:
+    cdef:
+        Loop _loop
+        SSLProtocol _ssl_protocol
+        bint _closed
+        object context
+
+
+cdef class SSLProtocol:
+    cdef:
+        bint _server_side
+        str _server_hostname
+        object _sslcontext
+
+        object _extra
+
+        object _write_backlog
+        size_t _write_buffer_size
+
+        object _waiter
+        Loop _loop
+        _SSLProtocolTransport _app_transport
+        bint _app_transport_created
+
+        object _transport
+        object _ssl_handshake_timeout
+        object _ssl_shutdown_timeout
+
+        object _sslobj
+        object _sslobj_read
+        object _sslobj_write
+        object _incoming
+        object _incoming_write
+        object _outgoing
+        object _outgoing_read
+        char* _ssl_buffer
+        size_t _ssl_buffer_len
+        object _ssl_buffer_view
+        SSLProtocolState _state
+        size_t _conn_lost
+        AppProtocolState _app_state
+
+        bint _ssl_writing_paused
+        bint _app_reading_paused
+
+        size_t _incoming_high_water
+        size_t _incoming_low_water
+        bint _ssl_reading_paused
+
+        bint _app_writing_paused
+        size_t _outgoing_high_water
+        size_t _outgoing_low_water
+
+        object _app_protocol
+        bint _app_protocol_is_buffer
+        object _app_protocol_get_buffer
+        object _app_protocol_buffer_updated
+
+        object _handshake_start_time
+        object _handshake_timeout_handle
+        object _shutdown_timeout_handle
+
+    cdef _set_app_protocol(self, app_protocol)
+    cdef _wakeup_waiter(self, exc=*)
+    cdef _get_extra_info(self, name, default=*)
+    cdef _set_state(self, SSLProtocolState new_state)
+
+    # Handshake flow
+
+    cdef _start_handshake(self)
+    cdef _check_handshake_timeout(self)
+    cdef _do_handshake(self)
+    cdef _on_handshake_complete(self, handshake_exc)
+
+    # Shutdown flow
+
+    cdef _start_shutdown(self, object context=*)
+    cdef _check_shutdown_timeout(self)
+    cdef _do_read_into_void(self, object context)
+    cdef _do_flush(self, object context=*)
+    cdef _do_shutdown(self, object context=*)
+    cdef _on_shutdown_complete(self, shutdown_exc)
+    cdef _abort(self, exc)
+
+    # Outgoing flow
+
+    cdef _write_appdata(self, list_of_data, object context)
+    cdef _do_write(self)
+    cdef _process_outgoing(self)
+
+    # Incoming flow
+
+    cdef _do_read(self)
+    cdef _do_read__buffered(self)
+    cdef _do_read__copied(self)
+    cdef _call_eof_received(self, object context=*)
+
+    # Flow control for writes from APP socket
+
+    cdef _control_app_writing(self, object context=*)
+    cdef size_t _get_write_buffer_size(self)
+    cdef _set_write_buffer_limits(self, high=*, low=*)
+
+    # Flow control for reads to APP socket
+
+    cdef _pause_reading(self)
+    cdef _resume_reading(self, object context)
+
+    # Flow control for reads from SSL socket
+
+    cdef _control_ssl_reading(self)
+    cdef _set_read_buffer_limits(self, high=*, low=*)
+    cdef size_t _get_read_buffer_size(self)
+    cdef _fatal_error(self, exc, message=*)
diff --git a/myenv/lib/python3.9/site-packages/uvloop/sslproto.pyx b/myenv/lib/python3.9/site-packages/uvloop/sslproto.pyx
new file mode 100644
index 0000000..42bb764
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/uvloop/sslproto.pyx
@@ -0,0 +1,950 @@
+cdef _create_transport_context(server_side, server_hostname):
+    if server_side:
+        raise ValueError('Server side SSL needs a valid SSLContext')
+
+    # Client side may pass ssl=True to use a default
+    # context; in that case the sslcontext passed is None.
+    # The default is secure for client connections.
+    # Python 3.4+: use up-to-date strong settings.
+    sslcontext = ssl_create_default_context()
+    if not server_hostname:
+        sslcontext.check_hostname = False
+    return sslcontext
+
+
+cdef class _SSLProtocolTransport:
+
+    # TODO:
+    # _sendfile_compatible = constants._SendfileMode.FALLBACK
+
+    def __cinit__(self, Loop loop, ssl_protocol, context):
+        self._loop = loop
+        # SSLProtocol instance
+        self._ssl_protocol = ssl_protocol
+        self._closed = False
+        if context is None:
+            context = Context_CopyCurrent()
+        self.context = context
+
+    def get_extra_info(self, name, default=None):
+        """Get optional transport information."""
+        return self._ssl_protocol._get_extra_info(name, default)
+
+    def set_protocol(self, protocol):
+        self._ssl_protocol._set_app_protocol(protocol)
+
+    def get_protocol(self):
+        return self._ssl_protocol._app_protocol
+
+    def is_closing(self):
+        return self._closed
+
+    def close(self):
+        """Close the transport.
+
+        Buffered data will be flushed asynchronously.  No more data
+        will be received.  After all buffered data is flushed, the
+        protocol's connection_lost() method will (eventually) called
+        with None as its argument.
+        """
+        self._closed = True
+        self._ssl_protocol._start_shutdown(self.context.copy())
+
+    def __dealloc__(self):
+        if not self._closed:
+            self._closed = True
+            warnings_warn(
+                "unclosed transport <uvloop.loop._SSLProtocolTransport "
+                "object>", ResourceWarning)
+
+    def is_reading(self):
+        return not self._ssl_protocol._app_reading_paused
+
+    def pause_reading(self):
+        """Pause the receiving end.
+
+        No data will be passed to the protocol's data_received()
+        method until resume_reading() is called.
+        """
+        self._ssl_protocol._pause_reading()
+
+    def resume_reading(self):
+        """Resume the receiving end.
+
+        Data received will once again be passed to the protocol's
+        data_received() method.
+        """
+        self._ssl_protocol._resume_reading(self.context.copy())
+
+    def set_write_buffer_limits(self, high=None, low=None):
+        """Set the high- and low-water limits for write flow control.
+
+        These two values control when to call the protocol's
+        pause_writing() and resume_writing() methods.  If specified,
+        the low-water limit must be less than or equal to the
+        high-water limit.  Neither value can be negative.
+
+        The defaults are implementation-specific.  If only the
+        high-water limit is given, the low-water limit defaults to an
+        implementation-specific value less than or equal to the
+        high-water limit.  Setting high to zero forces low to zero as
+        well, and causes pause_writing() to be called whenever the
+        buffer becomes non-empty.  Setting low to zero causes
+        resume_writing() to be called only once the buffer is empty.
+        Use of zero for either limit is generally sub-optimal as it
+        reduces opportunities for doing I/O and computation
+        concurrently.
+        """
+        self._ssl_protocol._set_write_buffer_limits(high, low)
+        self._ssl_protocol._control_app_writing(self.context.copy())
+
+    def get_write_buffer_limits(self):
+        return (self._ssl_protocol._outgoing_low_water,
+                self._ssl_protocol._outgoing_high_water)
+
+    def get_write_buffer_size(self):
+        """Return the current size of the write buffers."""
+        return self._ssl_protocol._get_write_buffer_size()
+
+    def set_read_buffer_limits(self, high=None, low=None):
+        """Set the high- and low-water limits for read flow control.
+
+        These two values control when to call the upstream transport's
+        pause_reading() and resume_reading() methods.  If specified,
+        the low-water limit must be less than or equal to the
+        high-water limit.  Neither value can be negative.
+
+        The defaults are implementation-specific.  If only the
+        high-water limit is given, the low-water limit defaults to an
+        implementation-specific value less than or equal to the
+        high-water limit.  Setting high to zero forces low to zero as
+        well, and causes pause_reading() to be called whenever the
+        buffer becomes non-empty.  Setting low to zero causes
+        resume_reading() to be called only once the buffer is empty.
+        Use of zero for either limit is generally sub-optimal as it
+        reduces opportunities for doing I/O and computation
+        concurrently.
+        """
+        self._ssl_protocol._set_read_buffer_limits(high, low)
+        self._ssl_protocol._control_ssl_reading()
+
+    def get_read_buffer_limits(self):
+        return (self._ssl_protocol._incoming_low_water,
+                self._ssl_protocol._incoming_high_water)
+
+    def get_read_buffer_size(self):
+        """Return the current size of the read buffer."""
+        return self._ssl_protocol._get_read_buffer_size()
+
+    @property
+    def _protocol_paused(self):
+        # Required for sendfile fallback pause_writing/resume_writing logic
+        return self._ssl_protocol._app_writing_paused
+
+    def write(self, data):
+        """Write some data bytes to the transport.
+
+        This does not block; it buffers the data and arranges for it
+        to be sent out asynchronously.
+        """
+        if not isinstance(data, (bytes, bytearray, memoryview)):
+            raise TypeError(f"data: expecting a bytes-like instance, "
+                            f"got {type(data).__name__}")
+        if not data:
+            return
+        self._ssl_protocol._write_appdata((data,), self.context.copy())
+
+    def writelines(self, list_of_data):
+        """Write a list (or any iterable) of data bytes to the transport.
+
+        The default implementation concatenates the arguments and
+        calls write() on the result.
+        """
+        self._ssl_protocol._write_appdata(list_of_data, self.context.copy())
+
+    def write_eof(self):
+        """Close the write end after flushing buffered data.
+
+        This raises :exc:`NotImplementedError` right now.
+        """
+        raise NotImplementedError
+
+    def can_write_eof(self):
+        """Return True if this transport supports write_eof(), False if not."""
+        return False
+
+    def abort(self):
+        """Close the transport immediately.
+
+        Buffered data will be lost.  No more data will be received.
+        The protocol's connection_lost() method will (eventually) be
+        called with None as its argument.
+        """
+        self._force_close(None)
+
+    def _force_close(self, exc):
+        self._closed = True
+        self._ssl_protocol._abort(exc)
+
+    def _test__append_write_backlog(self, data):
+        # for test only
+        self._ssl_protocol._write_backlog.append(data)
+        self._ssl_protocol._write_buffer_size += len(data)
+
+
+cdef class SSLProtocol:
+    """SSL protocol.
+
+    Implementation of SSL on top of a socket using incoming and outgoing
+    buffers which are ssl.MemoryBIO objects.
+    """
+
+    def __cinit__(self, *args, **kwargs):
+        self._ssl_buffer_len = SSL_READ_MAX_SIZE
+        self._ssl_buffer = <char*>PyMem_RawMalloc(self._ssl_buffer_len)
+        if not self._ssl_buffer:
+            raise MemoryError()
+        self._ssl_buffer_view = PyMemoryView_FromMemory(
+            self._ssl_buffer, self._ssl_buffer_len, PyBUF_WRITE)
+
+    def __dealloc__(self):
+        self._ssl_buffer_view = None
+        PyMem_RawFree(self._ssl_buffer)
+        self._ssl_buffer = NULL
+        self._ssl_buffer_len = 0
+
+    def __init__(self, loop, app_protocol, sslcontext, waiter,
+                 server_side=False, server_hostname=None,
+                 call_connection_made=True,
+                 ssl_handshake_timeout=None,
+                 ssl_shutdown_timeout=None):
+        if ssl_handshake_timeout is None:
+            ssl_handshake_timeout = SSL_HANDSHAKE_TIMEOUT
+        elif ssl_handshake_timeout <= 0:
+            raise ValueError(
+                f"ssl_handshake_timeout should be a positive number, "
+                f"got {ssl_handshake_timeout}")
+        if ssl_shutdown_timeout is None:
+            ssl_shutdown_timeout = SSL_SHUTDOWN_TIMEOUT
+        elif ssl_shutdown_timeout <= 0:
+            raise ValueError(
+                f"ssl_shutdown_timeout should be a positive number, "
+                f"got {ssl_shutdown_timeout}")
+
+        if not sslcontext:
+            sslcontext = _create_transport_context(
+                server_side, server_hostname)
+
+        self._server_side = server_side
+        if server_hostname and not server_side:
+            self._server_hostname = server_hostname
+        else:
+            self._server_hostname = None
+        self._sslcontext = sslcontext
+        # SSL-specific extra info. More info are set when the handshake
+        # completes.
+        self._extra = dict(sslcontext=sslcontext)
+
+        # App data write buffering
+        self._write_backlog = col_deque()
+        self._write_buffer_size = 0
+
+        self._waiter = waiter
+        self._loop = loop
+        self._set_app_protocol(app_protocol)
+        self._app_transport = None
+        self._app_transport_created = False
+        # transport, ex: SelectorSocketTransport
+        self._transport = None
+        self._ssl_handshake_timeout = ssl_handshake_timeout
+        self._ssl_shutdown_timeout = ssl_shutdown_timeout
+        # SSL and state machine
+        self._sslobj = None
+        self._incoming = ssl_MemoryBIO()
+        self._incoming_write = self._incoming.write
+        self._outgoing = ssl_MemoryBIO()
+        self._outgoing_read = self._outgoing.read
+        self._state = UNWRAPPED
+        self._conn_lost = 0  # Set when connection_lost called
+        if call_connection_made:
+            self._app_state = STATE_INIT
+        else:
+            self._app_state = STATE_CON_MADE
+
+        # Flow Control
+
+        self._ssl_writing_paused = False
+
+        self._app_reading_paused = False
+
+        self._ssl_reading_paused = False
+        self._incoming_high_water = 0
+        self._incoming_low_water = 0
+        self._set_read_buffer_limits()
+
+        self._app_writing_paused = False
+        self._outgoing_high_water = 0
+        self._outgoing_low_water = 0
+        self._set_write_buffer_limits()
+
+    cdef _set_app_protocol(self, app_protocol):
+        self._app_protocol = app_protocol
+        if (hasattr(app_protocol, 'get_buffer') and
+                not isinstance(app_protocol, aio_Protocol)):
+            self._app_protocol_get_buffer = app_protocol.get_buffer
+            self._app_protocol_buffer_updated = app_protocol.buffer_updated
+            self._app_protocol_is_buffer = True
+        else:
+            self._app_protocol_is_buffer = False
+
+    cdef _wakeup_waiter(self, exc=None):
+        if self._waiter is None:
+            return
+        if not self._waiter.cancelled():
+            if exc is not None:
+                self._waiter.set_exception(exc)
+            else:
+                self._waiter.set_result(None)
+        self._waiter = None
+
+    def _get_app_transport(self, context=None):
+        if self._app_transport is None:
+            if self._app_transport_created:
+                raise RuntimeError('Creating _SSLProtocolTransport twice')
+            self._app_transport = _SSLProtocolTransport(self._loop, self,
+                                                        context)
+            self._app_transport_created = True
+        return self._app_transport
+
+    def connection_made(self, transport):
+        """Called when the low-level connection is made.
+
+        Start the SSL handshake.
+        """
+        self._transport = transport
+        self._start_handshake()
+
+    def connection_lost(self, exc):
+        """Called when the low-level connection is lost or closed.
+
+        The argument is an exception object or None (the latter
+        meaning a regular EOF is received or the connection was
+        aborted or closed).
+        """
+        self._write_backlog.clear()
+        self._outgoing_read()
+        self._conn_lost += 1
+
+        # Just mark the app transport as closed so that its __dealloc__
+        # doesn't complain.
+        if self._app_transport is not None:
+            self._app_transport._closed = True
+
+        if self._state != DO_HANDSHAKE:
+            if self._app_state == STATE_CON_MADE or \
+                    self._app_state == STATE_EOF:
+                self._app_state = STATE_CON_LOST
+                self._loop.call_soon(self._app_protocol.connection_lost, exc)
+        self._set_state(UNWRAPPED)
+        self._transport = None
+        self._app_transport = None
+        self._app_protocol = None
+        self._wakeup_waiter(exc)
+
+        if self._shutdown_timeout_handle:
+            self._shutdown_timeout_handle.cancel()
+            self._shutdown_timeout_handle = None
+        if self._handshake_timeout_handle:
+            self._handshake_timeout_handle.cancel()
+            self._handshake_timeout_handle = None
+
+    def get_buffer(self, n):
+        cdef size_t want = n
+        if want > SSL_READ_MAX_SIZE:
+            want = SSL_READ_MAX_SIZE
+        if self._ssl_buffer_len < want:
+            self._ssl_buffer = <char*>PyMem_RawRealloc(self._ssl_buffer, want)
+            if not self._ssl_buffer:
+                raise MemoryError()
+            self._ssl_buffer_len = want
+            self._ssl_buffer_view = PyMemoryView_FromMemory(
+                self._ssl_buffer, want, PyBUF_WRITE)
+        return self._ssl_buffer_view
+
+    def buffer_updated(self, nbytes):
+        self._incoming_write(PyMemoryView_FromMemory(
+            self._ssl_buffer, nbytes, PyBUF_WRITE))
+
+        if self._state == DO_HANDSHAKE:
+            self._do_handshake()
+
+        elif self._state == WRAPPED:
+            self._do_read()
+
+        elif self._state == FLUSHING:
+            self._do_flush()
+
+        elif self._state == SHUTDOWN:
+            self._do_shutdown()
+
+    def eof_received(self):
+        """Called when the other end of the low-level stream
+        is half-closed.
+
+        If this returns a false value (including None), the transport
+        will close itself.  If it returns a true value, closing the
+        transport is up to the protocol.
+        """
+        try:
+            if self._loop.get_debug():
+                aio_logger.debug("%r received EOF", self)
+
+            if self._state == DO_HANDSHAKE:
+                self._on_handshake_complete(ConnectionResetError)
+
+            elif self._state == WRAPPED or self._state == FLUSHING:
+                # We treat a low-level EOF as a critical situation similar to a
+                # broken connection - just send whatever is in the buffer and
+                # close. No application level eof_received() is called -
+                # because we don't want the user to think that this is a
+                # graceful shutdown triggered by SSL "close_notify".
+                self._set_state(SHUTDOWN)
+                self._on_shutdown_complete(None)
+
+            elif self._state == SHUTDOWN:
+                self._on_shutdown_complete(None)
+
+        except Exception:
+            self._transport.close()
+            raise
+
+    cdef _get_extra_info(self, name, default=None):
+        if name == 'uvloop.sslproto':
+            return self
+        elif name in self._extra:
+            return self._extra[name]
+        elif self._transport is not None:
+            return self._transport.get_extra_info(name, default)
+        else:
+            return default
+
+    cdef _set_state(self, SSLProtocolState new_state):
+        cdef bint allowed = False
+
+        if new_state == UNWRAPPED:
+            allowed = True
+
+        elif self._state == UNWRAPPED and new_state == DO_HANDSHAKE:
+            allowed = True
+
+        elif self._state == DO_HANDSHAKE and new_state == WRAPPED:
+            allowed = True
+
+        elif self._state == WRAPPED and new_state == FLUSHING:
+            allowed = True
+
+        elif self._state == WRAPPED and new_state == SHUTDOWN:
+            allowed = True
+
+        elif self._state == FLUSHING and new_state == SHUTDOWN:
+            allowed = True
+
+        if allowed:
+            self._state = new_state
+
+        else:
+            raise RuntimeError(
+                'cannot switch state from {} to {}'.format(
+                    self._state, new_state))
+
+    # Handshake flow
+
+    cdef _start_handshake(self):
+        if self._loop.get_debug():
+            aio_logger.debug("%r starts SSL handshake", self)
+            self._handshake_start_time = self._loop.time()
+        else:
+            self._handshake_start_time = None
+
+        self._set_state(DO_HANDSHAKE)
+
+        # start handshake timeout count down
+        self._handshake_timeout_handle = \
+            self._loop.call_later(self._ssl_handshake_timeout,
+                                  lambda: self._check_handshake_timeout())
+
+        try:
+            self._sslobj = self._sslcontext.wrap_bio(
+                self._incoming, self._outgoing,
+                server_side=self._server_side,
+                server_hostname=self._server_hostname)
+            self._sslobj_read = self._sslobj.read
+            self._sslobj_write = self._sslobj.write
+        except Exception as ex:
+            self._on_handshake_complete(ex)
+        else:
+            self._do_handshake()
+
+    cdef _check_handshake_timeout(self):
+        if self._state == DO_HANDSHAKE:
+            msg = (
+                f"SSL handshake is taking longer than "
+                f"{self._ssl_handshake_timeout} seconds: "
+                f"aborting the connection"
+            )
+            self._fatal_error(ConnectionAbortedError(msg))
+
+    cdef _do_handshake(self):
+        try:
+            self._sslobj.do_handshake()
+        except ssl_SSLAgainErrors as exc:
+            self._process_outgoing()
+        except ssl_SSLError as exc:
+            self._on_handshake_complete(exc)
+        else:
+            self._on_handshake_complete(None)
+
+    cdef _on_handshake_complete(self, handshake_exc):
+        if self._handshake_timeout_handle is not None:
+            self._handshake_timeout_handle.cancel()
+            self._handshake_timeout_handle = None
+
+        sslobj = self._sslobj
+        try:
+            if handshake_exc is None:
+                self._set_state(WRAPPED)
+            else:
+                raise handshake_exc
+
+            peercert = sslobj.getpeercert()
+        except Exception as exc:
+            self._set_state(UNWRAPPED)
+            if isinstance(exc, ssl_CertificateError):
+                msg = 'SSL handshake failed on verifying the certificate'
+            else:
+                msg = 'SSL handshake failed'
+            self._fatal_error(exc, msg)
+            self._wakeup_waiter(exc)
+            return
+
+        if self._loop.get_debug():
+            dt = self._loop.time() - self._handshake_start_time
+            aio_logger.debug("%r: SSL handshake took %.1f ms", self, dt * 1e3)
+
+        # Add extra info that becomes available after handshake.
+        self._extra.update(peercert=peercert,
+                           cipher=sslobj.cipher(),
+                           compression=sslobj.compression(),
+                           ssl_object=sslobj)
+        if self._app_state == STATE_INIT:
+            self._app_state = STATE_CON_MADE
+            self._app_protocol.connection_made(self._get_app_transport())
+        self._wakeup_waiter()
+
+        # We should wakeup user code before sending the first data below. In
+        # case of `start_tls()`, the user can only get the SSLTransport in the
+        # wakeup callback, because `connection_made()` is not called again.
+        # We should schedule the first data later than the wakeup callback so
+        # that the user get a chance to e.g. check ALPN with the transport
+        # before having to handle the first data.
+        self._loop._call_soon_handle(
+            new_MethodHandle(self._loop,
+                             "SSLProtocol._do_read",
+                             <method_t> self._do_read,
+                             None,  # current context is good
+                             self))
+
+    # Shutdown flow
+
+    cdef _start_shutdown(self, object context=None):
+        if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+            return
+        # we don't need the context for _abort or the timeout, because
+        # TCP transport._force_close() should be able to call
+        # connection_lost() in the right context
+        if self._app_transport is not None:
+            self._app_transport._closed = True
+        if self._state == DO_HANDSHAKE:
+            self._abort(None)
+        else:
+            self._set_state(FLUSHING)
+            self._shutdown_timeout_handle = \
+                self._loop.call_later(self._ssl_shutdown_timeout,
+                                      lambda: self._check_shutdown_timeout())
+            self._do_flush(context)
+
+    cdef _check_shutdown_timeout(self):
+        if self._state in (FLUSHING, SHUTDOWN):
+            self._transport._force_close(
+                aio_TimeoutError('SSL shutdown timed out'))
+
+    cdef _do_read_into_void(self, object context):
+        """Consume and discard incoming application data.
+
+        If close_notify is received for the first time, call eof_received.
+        """
+        cdef:
+            bint close_notify = False
+        try:
+            while True:
+                if not self._sslobj_read(SSL_READ_MAX_SIZE):
+                    close_notify = True
+                    break
+        except ssl_SSLAgainErrors as exc:
+            pass
+        except ssl_SSLZeroReturnError:
+            close_notify = True
+        if close_notify:
+            self._call_eof_received(context)
+
+    cdef _do_flush(self, object context=None):
+        """Flush the write backlog, discarding new data received.
+
+        We don't send close_notify in FLUSHING because we still want to send
+        the remaining data over SSL, even if we received a close_notify. Also,
+        no application-level resume_writing() or pause_writing() will be called
+        in FLUSHING, as we could fully manage the flow control internally.
+        """
+        try:
+            self._do_read_into_void(context)
+            self._do_write()
+            self._process_outgoing()
+            self._control_ssl_reading()
+        except Exception as ex:
+            self._on_shutdown_complete(ex)
+        else:
+            if not self._get_write_buffer_size():
+                self._set_state(SHUTDOWN)
+                self._do_shutdown(context)
+
+    cdef _do_shutdown(self, object context=None):
+        """Send close_notify and wait for the same from the peer."""
+        try:
+            # we must skip all application data (if any) before unwrap
+            self._do_read_into_void(context)
+            try:
+                self._sslobj.unwrap()
+            except ssl_SSLAgainErrors as exc:
+                self._process_outgoing()
+            else:
+                self._process_outgoing()
+                if not self._get_write_buffer_size():
+                    self._on_shutdown_complete(None)
+        except Exception as ex:
+            self._on_shutdown_complete(ex)
+
+    cdef _on_shutdown_complete(self, shutdown_exc):
+        if self._shutdown_timeout_handle is not None:
+            self._shutdown_timeout_handle.cancel()
+            self._shutdown_timeout_handle = None
+
+        # we don't need the context here because TCP transport.close() should
+        # be able to call connection_made() in the right context
+        if shutdown_exc:
+            self._fatal_error(shutdown_exc, 'Error occurred during shutdown')
+        else:
+            self._transport.close()
+
+    cdef _abort(self, exc):
+        self._set_state(UNWRAPPED)
+        if self._transport is not None:
+            self._transport._force_close(exc)
+
+    # Outgoing flow
+
+    cdef _write_appdata(self, list_of_data, object context):
+        if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+            if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+                aio_logger.warning('SSL connection is closed')
+            self._conn_lost += 1
+            return
+
+        for data in list_of_data:
+            self._write_backlog.append(data)
+            self._write_buffer_size += len(data)
+
+        try:
+            if self._state == WRAPPED:
+                self._do_write()
+                self._process_outgoing()
+                self._control_app_writing(context)
+
+        except Exception as ex:
+            self._fatal_error(ex, 'Fatal error on SSL protocol')
+
+    cdef _do_write(self):
+        """Do SSL write, consumes write backlog and fills outgoing BIO."""
+        cdef size_t data_len, count
+        try:
+            while self._write_backlog:
+                data = self._write_backlog[0]
+                count = self._sslobj_write(data)
+                data_len = len(data)
+                if count < data_len:
+                    if not PyMemoryView_Check(data):
+                        data = PyMemoryView_FromObject(data)
+                    self._write_backlog[0] = data[count:]
+                    self._write_buffer_size -= count
+                else:
+                    del self._write_backlog[0]
+                    self._write_buffer_size -= data_len
+        except ssl_SSLAgainErrors as exc:
+            pass
+
+    cdef _process_outgoing(self):
+        """Send bytes from the outgoing BIO."""
+        if not self._ssl_writing_paused:
+            data = self._outgoing_read()
+            if len(data):
+                self._transport.write(data)
+
+    # Incoming flow
+
+    cdef _do_read(self):
+        if self._state != WRAPPED:
+            return
+        try:
+            if not self._app_reading_paused:
+                if self._app_protocol_is_buffer:
+                    self._do_read__buffered()
+                else:
+                    self._do_read__copied()
+                if self._write_backlog:
+                    self._do_write()
+                self._process_outgoing()
+                self._control_app_writing()
+            self._control_ssl_reading()
+        except Exception as ex:
+            self._fatal_error(ex, 'Fatal error on SSL protocol')
+
+    cdef _do_read__buffered(self):
+        cdef:
+            Py_buffer pybuf
+            bint pybuf_inited = False
+            size_t wants, offset = 0
+            int count = 1
+            object buf
+
+        buf = self._app_protocol_get_buffer(self._get_read_buffer_size())
+        wants = len(buf)
+
+        try:
+            count = self._sslobj_read(wants, buf)
+
+            if count > 0:
+                offset = count
+                if offset < wants:
+                    PyObject_GetBuffer(buf, &pybuf, PyBUF_WRITABLE)
+                    pybuf_inited = True
+                while offset < wants:
+                    buf = PyMemoryView_FromMemory(
+                        (<char*>pybuf.buf) + offset,
+                        wants - offset,
+                        PyBUF_WRITE)
+                    count = self._sslobj_read(wants - offset, buf)
+                    if count > 0:
+                        offset += count
+                    else:
+                        break
+                else:
+                    self._loop._call_soon_handle(
+                        new_MethodHandle(self._loop,
+                                         "SSLProtocol._do_read",
+                                         <method_t>self._do_read,
+                                         None,  # current context is good
+                                         self))
+        except ssl_SSLAgainErrors as exc:
+            pass
+        finally:
+            if pybuf_inited:
+                PyBuffer_Release(&pybuf)
+        if offset > 0:
+            self._app_protocol_buffer_updated(offset)
+        if not count:
+            # close_notify
+            self._call_eof_received()
+            self._start_shutdown()
+
+    cdef _do_read__copied(self):
+        cdef:
+            list data
+            bytes first, chunk = b'1'
+            bint zero = True, one = False
+
+        try:
+            while True:
+                chunk = self._sslobj_read(SSL_READ_MAX_SIZE)
+                if not chunk:
+                    break
+                if zero:
+                    zero = False
+                    one = True
+                    first = chunk
+                elif one:
+                    one = False
+                    data = [first, chunk]
+                else:
+                    data.append(chunk)
+        except ssl_SSLAgainErrors as exc:
+            pass
+        if one:
+            self._app_protocol.data_received(first)
+        elif not zero:
+            self._app_protocol.data_received(b''.join(data))
+        if not chunk:
+            # close_notify
+            self._call_eof_received()
+            self._start_shutdown()
+
+    cdef _call_eof_received(self, object context=None):
+        if self._app_state == STATE_CON_MADE:
+            self._app_state = STATE_EOF
+            try:
+                if context is None:
+                    # If the caller didn't provide a context, we assume the
+                    # caller is already in the right context, which is usually
+                    # inside the upstream callbacks like buffer_updated()
+                    keep_open = self._app_protocol.eof_received()
+                else:
+                    keep_open = run_in_context(
+                        context, self._app_protocol.eof_received,
+                    )
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as ex:
+                self._fatal_error(ex, 'Error calling eof_received()')
+            else:
+                if keep_open:
+                    aio_logger.warning('returning true from eof_received() '
+                                       'has no effect when using ssl')
+
+    # Flow control for writes from APP socket
+
+    cdef _control_app_writing(self, object context=None):
+        cdef size_t size = self._get_write_buffer_size()
+        if size >= self._outgoing_high_water and not self._app_writing_paused:
+            self._app_writing_paused = True
+            try:
+                if context is None:
+                    # If the caller didn't provide a context, we assume the
+                    # caller is already in the right context, which is usually
+                    # inside the upstream callbacks like buffer_updated()
+                    self._app_protocol.pause_writing()
+                else:
+                    run_in_context(context, self._app_protocol.pause_writing)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as exc:
+                self._loop.call_exception_handler({
+                    'message': 'protocol.pause_writing() failed',
+                    'exception': exc,
+                    'transport': self._app_transport,
+                    'protocol': self,
+                })
+        elif size <= self._outgoing_low_water and self._app_writing_paused:
+            self._app_writing_paused = False
+            try:
+                if context is None:
+                    # If the caller didn't provide a context, we assume the
+                    # caller is already in the right context, which is usually
+                    # inside the upstream callbacks like resume_writing()
+                    self._app_protocol.resume_writing()
+                else:
+                    run_in_context(context, self._app_protocol.resume_writing)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as exc:
+                self._loop.call_exception_handler({
+                    'message': 'protocol.resume_writing() failed',
+                    'exception': exc,
+                    'transport': self._app_transport,
+                    'protocol': self,
+                })
+
+    cdef size_t _get_write_buffer_size(self):
+        return self._outgoing.pending + self._write_buffer_size
+
+    cdef _set_write_buffer_limits(self, high=None, low=None):
+        high, low = add_flowcontrol_defaults(
+            high, low, FLOW_CONTROL_HIGH_WATER_SSL_WRITE)
+        self._outgoing_high_water = high
+        self._outgoing_low_water = low
+
+    # Flow control for reads to APP socket
+
+    cdef _pause_reading(self):
+        self._app_reading_paused = True
+
+    cdef _resume_reading(self, object context):
+        if self._app_reading_paused:
+            self._app_reading_paused = False
+            if self._state == WRAPPED:
+                self._loop._call_soon_handle(
+                    new_MethodHandle(self._loop,
+                                     "SSLProtocol._do_read",
+                                     <method_t>self._do_read,
+                                     context,
+                                     self))
+
+    # Flow control for reads from SSL socket
+
+    cdef _control_ssl_reading(self):
+        cdef size_t size = self._get_read_buffer_size()
+        if size >= self._incoming_high_water and not self._ssl_reading_paused:
+            self._ssl_reading_paused = True
+            self._transport.pause_reading()
+        elif size <= self._incoming_low_water and self._ssl_reading_paused:
+            self._ssl_reading_paused = False
+            self._transport.resume_reading()
+
+    cdef _set_read_buffer_limits(self, high=None, low=None):
+        high, low = add_flowcontrol_defaults(
+            high, low, FLOW_CONTROL_HIGH_WATER_SSL_READ)
+        self._incoming_high_water = high
+        self._incoming_low_water = low
+
+    cdef size_t _get_read_buffer_size(self):
+        return self._incoming.pending
+
+    # Flow control for writes to SSL socket
+
+    def pause_writing(self):
+        """Called when the low-level transport's buffer goes over
+        the high-water mark.
+        """
+        assert not self._ssl_writing_paused
+        self._ssl_writing_paused = True
+
+    def resume_writing(self):
+        """Called when the low-level transport's buffer drains below
+        the low-water mark.
+        """
+        assert self._ssl_writing_paused
+        self._ssl_writing_paused = False
+
+        if self._state == WRAPPED:
+            self._process_outgoing()
+            self._control_app_writing()
+
+        elif self._state == FLUSHING:
+            self._do_flush()
+
+        elif self._state == SHUTDOWN:
+            self._do_shutdown()
+
+    cdef _fatal_error(self, exc, message='Fatal error on transport'):
+        if self._app_transport:
+            self._app_transport._force_close(exc)
+        elif self._transport:
+            self._transport._force_close(exc)
+
+        if isinstance(exc, OSError):
+            if self._loop.get_debug():
+                aio_logger.debug("%r: %s", self, message, exc_info=True)
+        elif not isinstance(exc, aio_CancelledError):
+            self._loop.call_exception_handler({
+                'message': message,
+                'exception': exc,
+                'transport': self._transport,
+                'protocol': self,
+            })
diff --git a/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/LICENSE
new file mode 100644
index 0000000..cbbbc9f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017, 2018, 2019, 2020 Samuel Colvin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/METADATA b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/METADATA
new file mode 100644
index 0000000..5d5e4ae
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/METADATA
@@ -0,0 +1,219 @@
+Metadata-Version: 2.1
+Name: watchgod
+Version: 0.8.2
+Summary: Simple, modern file watching and code reload in python.
+Home-page: https://github.com/samuelcolvin/watchfiles
+Author: Samuel Colvin
+Author-email: s@muelcolvin.com
+License: MIT
+Platform: UNKNOWN
+Classifier: Development Status :: 7 - Inactive
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Environment :: MacOS X
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Filesystems
+Classifier: Framework :: AnyIO
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anyio (<4,>=3.0.0)
+
+# watchgod
+
+[![CI](https://github.com/samuelcolvin/watchgod/workflows/ci/badge.svg?event=push)](https://github.com/samuelcolvin/watchgod/actions?query=event%3Apush+branch%3Amaster+workflow%3Aci)
+[![Coverage](https://codecov.io/gh/samuelcolvin/watchgod/branch/master/graph/badge.svg)](https://codecov.io/gh/samuelcolvin/watchgod)
+[![pypi](https://img.shields.io/pypi/v/watchgod.svg)](https://pypi.python.org/pypi/watchgod)
+[![license](https://img.shields.io/github/license/samuelcolvin/watchgod.svg)](https://github.com/samuelcolvin/watchgod/blob/master/LICENSE)
+
+Simple, modern file watching and code reload in python.
+
+---
+
+## NOTICE - Package Renamed to `watchfiles`
+
+**Please note:** This package (watchgod) has been renamed to [watchfiles](https://pypi.org/project/watchfiles/). 
+Please replace `watchgod` with `watchfiles`, see [the migration guide](https://watchfiles.helpmanual.io/migrating/)
+for help and instructions on switching.
+
+As well as a better name, `watchfiles` has a whole new backend based on rust-notify which makes watching
+for filesystem events much more efficient.
+
+**The package under the name `watchgod` will not be further developed and will only receive critical security fixes.**
+
+---
+
+## Usage
+
+To watch for changes in a directory:
+
+```python
+from watchgod import watch
+
+for changes in watch('./path/to/dir'):
+    print(changes)
+```
+
+To run a function and restart it when code changes:
+
+```python
+from watchgod import run_process
+
+def foobar(a, b, c):
+    ...
+
+run_process('./path/to/dir', foobar, args=(1, 2, 3))
+```
+
+`run_process` uses `PythonWatcher` so only changes to python files will prompt a
+reload, see **custom watchers** below.
+
+If you need notifications about change events as well as to restart a process you can
+use the `callback` argument to pass a function which will be called on every file change
+with one argument: the set of file changes.
+
+## Installation
+
+```bash
+pip install watchgod
+```
+
+## Asynchronous Methods
+
+*watchgod* comes with an asynchronous equivalents of `watch`: `awatch` which uses
+a `ThreadPoolExecutor` to iterate over files.
+
+```python
+import asyncio
+from watchgod import awatch
+
+async def main():
+    async for changes in awatch('/path/to/dir'):
+        print(changes)
+
+asyncio.run(main())
+```
+
+There's also an asynchronous equivalents of `run_process`: `arun_process` which in turn
+uses `awatch`:
+
+```python
+import asyncio
+from watchgod import arun_process
+
+def foobar(a, b, c):
+    ...
+
+async def main():
+    await arun_process('./path/to/dir', foobar, args=(1, 2, 3))
+
+asyncio.run(main())
+```
+
+`arun_process` uses `PythonWatcher` so only changes to python files will prompt a
+reload, see **custom watchers** below.
+
+The signature of `arun_process` is almost identical to `run_process` except that
+the optional `callback` argument must be a coroutine, not a function.
+
+## Custom Watchers
+
+
+*watchgod* comes with the following watcher classes which can be used via the `watcher_cls`
+keyword argument to any of the methods above.
+
+For example:
+
+```python
+for changes in watch(directoryin, watcher_cls=RegExpWatcher, watcher_kwargs=dict(re_files=r'^.*(\.mp3)$')):
+   print (changes)
+```
+
+For more details, checkout
+[`watcher.py`](https://github.com/samuelcolvin/watchgod/blob/master/watchgod/watcher.py),
+it's pretty simple.
+
+* **AllWatcher** The base watcher, all files are checked for changes.
+
+* **DefaultWatcher** The watcher used by default by `watch` and `awatch`, commonly ignored files
+  like `*.swp`, `*.pyc` and `*~` are ignored along with directories like
+  `.git`.
+
+* **PythonWatcher** Specific to python files, only `*.py`, `*.pyx` and `*.pyd` files are watched.
+
+* **DefaultDirWatcher** Is the base for `DefaultWatcher` and `DefaultDirWatcher`. It takes care of ignoring
+  some regular directories.
+
+
+If these classes aren't sufficient you can define your own watcher, in particular
+you will want to override `should_watch_dir` and `should_watch_file`. Unless you're
+doing something very odd, you'll want to inherit from `DefaultDirWatcher`.
+
+Note that events related to *directories* are not reported (e.g. creation of a
+directory), but new files in new directories will be reported.
+
+## CLI
+
+*watchgod* also comes with a CLI for running and reloading python code.
+
+Lets say you have `foobar.py`:
+
+```python
+from aiohttp import web
+
+async def handle(request):
+    return web.Response(text='testing')
+
+app = web.Application()
+app.router.add_get('/', handle)
+
+def main():
+    web.run_app(app, port=8000)
+```
+
+You could run this and reload it when any file in the current directory changes with::
+
+    watchgod foobar.main
+
+In case you need to ignore certain files or directories, you can use the argument
+ `--ignore-paths`.
+
+Run `watchgod --help` for more options. *watchgod* is also available as a python executable module
+via `python -m watchgod ...`.
+
+## Why no inotify / kqueue / fsevent / winapi support
+
+*watchgod* (for now) uses file polling rather than the OS's built in file change notifications.
+
+This is not an oversight, it's a decision with the following rationale:
+
+1. Polling is "fast enough", particularly since PEP 471 introduced fast `scandir`.
+  For reasonably large projects like the TutorCruncher code base with 850 files and 300k lines
+  of code, *watchgod* can scan the entire tree in ~24ms. With a scan interval of 400ms that is roughly
+  5% of one CPU - perfectly acceptable load during development.
+2. The clue is in the title, there are at least 4 different file notification systems to integrate
+  with, most of them not trivial. That is all before we get to changes between different OS versions.
+3. Polling works well when you want to group or "debounce" changes.
+  Let's say you're running a dev server and you change branch in git, 100 files change.
+  Do you want to reload the dev server 100 times or once? Right.
+  Polling periodically will likely group these changes into one event. If you're receiving a
+  stream of events you need to delay execution of the reload when you receive the first event
+  to see if it's part of a group of file changes. This is not trivial.
+
+All that said, I might still use rust's "notify" crate to do the heavy lifting of file watching,
+see[#25](https://github.com/samuelcolvin/watchgod/issues/25).
+
+
diff --git a/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/RECORD b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/RECORD
new file mode 100644
index 0000000..0f1585d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/RECORD
@@ -0,0 +1,16 @@
+../../../bin/watchgod,sha256=lvdnyddK6n0zgbhpATPOuMiOzZoW3grz7m05sN52WbI,250
+watchgod/__init__.py,sha256=TTApdQi_i9cU_P7NfUfi0Vl3XOUVOttB0hC2SENasGE,432
+watchgod/__main__.py,sha256=JgErYkiskih8Y6oRwowALtR-rwQhAAdqOYWjQraRIPI,59
+watchgod/cli.py,sha256=TBqC-fBPGsK5CgYws-D_x30fH8JhhAvF_UW_l24vtMA,5031
+watchgod/main.py,sha256=Jem-VPZ_BCDJV7cGYFt2dkGPRgUCdTtEBup0ojz6M6Q,7616
+watchgod/py.typed,sha256=Lqp1dHMxexvJoNFXUuA0K-LwWbIQPMQnWXmA0anEeGI,67
+watchgod/version.py,sha256=ymslJ_JmRRiPPaD-FG4SZU18gYvYefzU9UgXDJQa-uE,42
+watchgod/watcher.py,sha256=gM_KcIrelT0X4Kn-Nf6099HFHl7S2qllDydsQNUE79w,5303
+watchgod-0.8.2.dist-info/LICENSE,sha256=r9rzqp7OWkZ3Fcd5ukg1m3DfEXtd77oFKsFowwezsYQ,1098
+watchgod-0.8.2.dist-info/METADATA,sha256=Uu2kZaZklyDivJKdlr2E3t8sGVOMP-y8vz96X7KZpk0,7580
+watchgod-0.8.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+watchgod-0.8.2.dist-info/entry_points.txt,sha256=4okmG87LuUNDyD4K5d86sT06LgYoJB4xBLqHQklSCfo,46
+watchgod-0.8.2.dist-info/top_level.txt,sha256=vDSixV-_cAsdN83qBhOQS4kBblDTqO0aePPJlkJylQg,9
+watchgod-0.8.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+watchgod-0.8.2.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+watchgod-0.8.2.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/WHEEL
new file mode 100644
index 0000000..becc9a6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/entry_points.txt b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/entry_points.txt
new file mode 100644
index 0000000..1bd8b4b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+watchgod = watchgod.cli:cli
diff --git a/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/top_level.txt
new file mode 100644
index 0000000..4c6c908
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/top_level.txt
@@ -0,0 +1 @@
+watchgod
diff --git a/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/zip-safe b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/zip-safe
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod-0.8.2.dist-info/zip-safe
@@ -0,0 +1 @@
+
diff --git a/myenv/lib/python3.9/site-packages/watchgod/__init__.py b/myenv/lib/python3.9/site-packages/watchgod/__init__.py
new file mode 100644
index 0000000..ed3e82b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod/__init__.py
@@ -0,0 +1,18 @@
+from .main import arun_process, awatch, run_process, watch
+from .version import VERSION
+from .watcher import AllWatcher, Change, DefaultDirWatcher, DefaultWatcher, PythonWatcher, RegExpWatcher
+
+__version__ = VERSION
+__all__ = (
+    'watch',
+    'awatch',
+    'run_process',
+    'arun_process',
+    'Change',
+    'AllWatcher',
+    'DefaultDirWatcher',
+    'DefaultWatcher',
+    'PythonWatcher',
+    'RegExpWatcher',
+    'VERSION',
+)
diff --git a/myenv/lib/python3.9/site-packages/watchgod/__main__.py b/myenv/lib/python3.9/site-packages/watchgod/__main__.py
new file mode 100644
index 0000000..d396c2a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod/__main__.py
@@ -0,0 +1,4 @@
+from .cli import cli
+
+if __name__ == '__main__':
+    cli()
diff --git a/myenv/lib/python3.9/site-packages/watchgod/cli.py b/myenv/lib/python3.9/site-packages/watchgod/cli.py
new file mode 100644
index 0000000..0ef3054
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod/cli.py
@@ -0,0 +1,145 @@
+import argparse
+import contextlib
+import logging
+import os
+import sys
+from importlib import import_module
+from multiprocessing import set_start_method
+from pathlib import Path
+from typing import Any, Dict, Generator, List, Optional, Sized
+
+from .main import run_process
+
+logger = logging.getLogger('watchgod.cli')
+
+
+def import_string(dotted_path: str) -> Any:
+    """
+    Stolen approximately from django. Import a dotted module path and return the attribute/class designated by the
+    last name in the path. Raise ImportError if the import fails.
+    """
+    try:
+        module_path, class_name = dotted_path.strip(' ').rsplit('.', 1)
+    except ValueError as e:
+        raise ImportError('"{}" doesn\'t look like a module path'.format(dotted_path)) from e
+
+    module = import_module(module_path)
+    try:
+        return getattr(module, class_name)
+    except AttributeError as e:
+        raise ImportError('Module "{}" does not define a "{}" attribute'.format(module_path, class_name)) from e
+
+
+@contextlib.contextmanager
+def set_tty(tty_path: Optional[str]) -> Generator[None, None, None]:
+    if tty_path:
+        try:
+            with open(tty_path) as tty:  # pragma: no cover
+                sys.stdin = tty
+                yield
+        except OSError:
+            # eg. "No such device or address: '/dev/tty'", see https://github.com/samuelcolvin/watchgod/issues/40
+            yield
+    else:
+        # currently on windows tty_path is None and there's nothing we can do here
+        yield
+
+
+def run_function(function: str, tty_path: Optional[str]) -> None:
+    with set_tty(tty_path):
+        func = import_string(function)
+        func()
+
+
+def callback(changes: Sized) -> None:
+    logger.info('%d files changed, reloading', len(changes))
+
+
+def sys_argv(function: str) -> List[str]:
+    """
+    Remove watchgod-related arguments from sys.argv and prepend with func's script path.
+    """
+    bases_ = function.split('.')[:-1]  # remove function and leave only file path
+    base = os.path.join(*bases_) + '.py'
+    base = os.path.abspath(base)
+    for i, arg in enumerate(sys.argv):
+        if arg in {'-a', '--args'}:
+            return [base] + sys.argv[i + 1 :]
+    return [base]  # strip all args if no additional args were provided
+
+
+def cli(*args_: str) -> None:
+    args = args_ or sys.argv[1:]
+    parser = argparse.ArgumentParser(
+        prog='watchgod', description='Watch a directory and execute a python function on changes.'
+    )
+    parser.add_argument('function', help='Path to python function to execute.')
+    parser.add_argument('path', nargs='?', default='.', help='Filesystem path to watch, defaults to current directory.')
+    parser.add_argument('--verbosity', nargs='?', type=int, default=1, help='0, 1 (default) or 2')
+    parser.add_argument(
+        '--ignore-paths',
+        nargs='*',
+        type=str,
+        default=[],
+        help='Specify paths to files or directories to ignore their updates',
+    )
+    parser.add_argument('--extensions', nargs='*', type=str, default=(), help='File extensions to additionally watch')
+    parser.add_argument(
+        '--args',
+        '-a',
+        nargs=argparse.REMAINDER,
+        help='Arguments for argparser inside executed function. Ex.: module.func path --args --inner arg -v',
+    )
+    arg_namespace = parser.parse_args(args)
+
+    log_level = {0: logging.WARNING, 1: logging.INFO, 2: logging.DEBUG}[arg_namespace.verbosity]
+    hdlr = logging.StreamHandler()
+    hdlr.setLevel(log_level)
+    hdlr.setFormatter(logging.Formatter(fmt='[%(asctime)s] %(message)s', datefmt='%H:%M:%S'))
+    wg_logger = logging.getLogger('watchgod')
+    wg_logger.addHandler(hdlr)
+    wg_logger.setLevel(log_level)
+
+    sys.path.append(os.getcwd())
+    try:
+        import_string(arg_namespace.function)
+    except ImportError as e:
+        print('ImportError: {}'.format(e), file=sys.stderr)
+        sys.exit(1)
+        return
+
+    path = Path(arg_namespace.path)
+    if not path.exists():
+        print('path "{}" does not exist'.format(path), file=sys.stderr)
+        sys.exit(1)
+        return
+
+    path = path.resolve()
+
+    try:
+        tty_path: Optional[str] = os.ttyname(sys.stdin.fileno())
+    except OSError:
+        # fileno() always fails with pytest
+        tty_path = '/dev/tty'
+    except AttributeError:
+        # on windows. No idea of a better solution
+        tty_path = None
+    logger.info('watching "%s" and reloading "%s" on changes...', path, arg_namespace.function)
+    set_start_method('spawn')
+    sys.argv = sys_argv(arg_namespace.function)
+
+    watcher_kwargs: Dict[str, Any] = {}
+    if arg_namespace.ignore_paths:
+        watcher_kwargs['ignored_paths'] = {str(Path(p).resolve()) for p in arg_namespace.ignore_paths}
+
+    extensions = arg_namespace.extensions
+    if arg_namespace.extensions:
+        watcher_kwargs['extensions'] = tuple(extensions)
+
+    run_process(
+        path,
+        run_function,
+        args=(arg_namespace.function, tty_path),
+        callback=callback,
+        watcher_kwargs=watcher_kwargs,
+    )
diff --git a/myenv/lib/python3.9/site-packages/watchgod/main.py b/myenv/lib/python3.9/site-packages/watchgod/main.py
new file mode 100644
index 0000000..9913399
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod/main.py
@@ -0,0 +1,229 @@
+import functools
+import logging
+import os
+import signal
+from functools import partial
+from multiprocessing import get_context
+from pathlib import Path
+from time import time
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, Generator, Optional, Set, Tuple, Type, Union, cast
+
+import anyio
+
+from .watcher import DefaultWatcher, PythonWatcher
+
+__all__ = 'watch', 'awatch', 'run_process', 'arun_process'
+logger = logging.getLogger('watchgod.main')
+
+if TYPE_CHECKING:
+    import asyncio
+    from multiprocessing.context import SpawnProcess
+
+    import trio
+
+    from .watcher import AllWatcher, FileChange
+
+    FileChanges = Set[FileChange]
+    AnyCallable = Callable[..., Any]
+    AnyEvent = Union[anyio.Event, asyncio.Event, trio.Event]
+
+# Use spawn context to make sure code run in subprocess
+# does not reuse imported modules in main process/context
+spawn_context = get_context('spawn')
+
+
+def unix_ms() -> int:
+    return int(round(time() * 1000))
+
+
+def watch(path: Union[Path, str], **kwargs: Any) -> Generator['FileChanges', None, None]:
+    """
+    Watch a directory and yield a set of changes whenever files change in that directory or its subdirectories.
+    """
+    try:
+        _awatch = awatch(path, **kwargs)
+        while True:
+            try:
+                yield anyio.run(_awatch.__anext__)
+            except StopAsyncIteration:
+                break
+    except KeyboardInterrupt:
+        logger.debug('KeyboardInterrupt, exiting')
+
+
+class awatch:
+    """
+    asynchronous equivalent of watch using a threaded executor.
+
+    3.5 doesn't support yield in coroutines so we need all this fluff. Yawwwwn.
+    """
+
+    __slots__ = (
+        '_path',
+        '_watcher_cls',
+        '_watcher_kwargs',
+        '_debounce',
+        '_min_sleep',
+        '_stop_event',
+        '_normal_sleep',
+        '_w',
+        'lock',
+        '_thread_limiter',
+    )
+
+    def __init__(
+        self,
+        path: Union[Path, str],
+        *,
+        watcher_cls: Type['AllWatcher'] = DefaultWatcher,
+        watcher_kwargs: Optional[Dict[str, Any]] = None,
+        debounce: int = 1600,
+        normal_sleep: int = 400,
+        min_sleep: int = 50,
+        stop_event: Optional['AnyEvent'] = None,
+    ) -> None:
+        self._thread_limiter: Optional[anyio.CapacityLimiter] = None
+        self._path = path
+        self._watcher_cls = watcher_cls
+        self._watcher_kwargs = watcher_kwargs or dict()
+        self._debounce = debounce
+        self._normal_sleep = normal_sleep
+        self._min_sleep = min_sleep
+        self._stop_event = stop_event
+        self._w: Optional['AllWatcher'] = None
+        self.lock = anyio.Lock()
+
+    def __aiter__(self) -> 'awatch':
+        return self
+
+    async def __anext__(self) -> 'FileChanges':
+        if self._w:
+            watcher = self._w
+        else:
+            watcher = self._w = await self.run_in_executor(
+                functools.partial(self._watcher_cls, self._path, **self._watcher_kwargs)
+            )
+        check_time = 0
+        changes: 'FileChanges' = set()
+        last_change = 0
+        while True:
+            if self._stop_event and self._stop_event.is_set():
+                raise StopAsyncIteration()
+            async with self.lock:
+                if not changes:
+                    last_change = unix_ms()
+
+                if check_time:
+                    if changes:
+                        sleep_time = self._min_sleep
+                    else:
+                        sleep_time = max(self._normal_sleep - check_time, self._min_sleep)
+                    await anyio.sleep(sleep_time / 1000)
+
+                s = unix_ms()
+                new_changes = await self.run_in_executor(watcher.check)
+                changes.update(new_changes)
+                now = unix_ms()
+                check_time = now - s
+                debounced = now - last_change
+                if logger.isEnabledFor(logging.DEBUG) and changes:
+                    logger.debug(
+                        '%s time=%0.0fms debounced=%0.0fms files=%d changes=%d (%d)',
+                        self._path,
+                        check_time,
+                        debounced,
+                        len(watcher.files),
+                        len(changes),
+                        len(new_changes),
+                    )
+
+                if changes and (not new_changes or debounced > self._debounce):
+                    logger.debug('%s changes released debounced=%0.0fms', self._path, debounced)
+                    return changes
+
+    async def run_in_executor(self, func: 'AnyCallable', *args: Any) -> Any:
+        if self._thread_limiter is None:
+            self._thread_limiter = anyio.CapacityLimiter(4)
+        return await anyio.to_thread.run_sync(func, *args, limiter=self._thread_limiter)
+
+
+def _start_process(target: 'AnyCallable', args: Tuple[Any, ...], kwargs: Optional[Dict[str, Any]]) -> 'SpawnProcess':
+    process = spawn_context.Process(target=target, args=args, kwargs=kwargs or {})
+    process.start()
+    return process
+
+
+def _stop_process(process: 'SpawnProcess') -> None:
+    if process.is_alive():
+        logger.debug('stopping process...')
+        pid = cast(int, process.pid)
+        os.kill(pid, signal.SIGINT)
+        process.join(5)
+        if process.exitcode is None:
+            logger.warning('process has not terminated, sending SIGKILL')
+            os.kill(pid, signal.SIGKILL)
+            process.join(1)
+        else:
+            logger.debug('process stopped')
+    else:
+        logger.warning('process already dead, exit code: %d', process.exitcode)
+
+
+def run_process(
+    path: Union[Path, str],
+    target: 'AnyCallable',
+    *,
+    args: Tuple[Any, ...] = (),
+    kwargs: Optional[Dict[str, Any]] = None,
+    callback: Optional[Callable[[Set['FileChange']], None]] = None,
+    watcher_cls: Type['AllWatcher'] = PythonWatcher,
+    watcher_kwargs: Optional[Dict[str, Any]] = None,
+    debounce: int = 400,
+    min_sleep: int = 100,
+) -> int:
+    """
+    Run a function in a subprocess using multiprocessing.Process, restart it whenever files change in path.
+    """
+
+    process = _start_process(target=target, args=args, kwargs=kwargs)
+    reloads = 0
+
+    try:
+        for changes in watch(
+            path, watcher_cls=watcher_cls, debounce=debounce, min_sleep=min_sleep, watcher_kwargs=watcher_kwargs
+        ):
+            callback and callback(changes)
+            _stop_process(process)
+            process = _start_process(target=target, args=args, kwargs=kwargs)
+            reloads += 1
+    finally:
+        _stop_process(process)
+    return reloads
+
+
+async def arun_process(
+    path: Union[Path, str],
+    target: 'AnyCallable',
+    *,
+    args: Tuple[Any, ...] = (),
+    kwargs: Optional[Dict[str, Any]] = None,
+    callback: Optional[Callable[['FileChanges'], Awaitable[None]]] = None,
+    watcher_cls: Type['AllWatcher'] = PythonWatcher,
+    debounce: int = 400,
+    min_sleep: int = 100,
+) -> int:
+    """
+    Run a function in a subprocess using multiprocessing.Process, restart it whenever files change in path.
+    """
+    watcher = awatch(path, watcher_cls=watcher_cls, debounce=debounce, min_sleep=min_sleep)
+    start_process = partial(_start_process, target=target, args=args, kwargs=kwargs)
+    process = await watcher.run_in_executor(start_process)
+    reloads = 0
+
+    async for changes in watcher:
+        callback and await callback(changes)
+        await watcher.run_in_executor(_stop_process, process)
+        process = await watcher.run_in_executor(start_process)
+        reloads += 1
+    await watcher.run_in_executor(_stop_process, process)
+    return reloads
diff --git a/myenv/lib/python3.9/site-packages/watchgod/py.typed b/myenv/lib/python3.9/site-packages/watchgod/py.typed
new file mode 100644
index 0000000..2d5ffb6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod/py.typed
@@ -0,0 +1 @@
+# Marker file for PEP 561. The watchgod package uses inline types.
diff --git a/myenv/lib/python3.9/site-packages/watchgod/version.py b/myenv/lib/python3.9/site-packages/watchgod/version.py
new file mode 100644
index 0000000..22705be
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod/version.py
@@ -0,0 +1,3 @@
+__all__ = ('VERSION',)
+
+VERSION = '0.8.2'
diff --git a/myenv/lib/python3.9/site-packages/watchgod/watcher.py b/myenv/lib/python3.9/site-packages/watchgod/watcher.py
new file mode 100644
index 0000000..9d0459e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/watchgod/watcher.py
@@ -0,0 +1,141 @@
+import logging
+import os
+import re
+from enum import IntEnum
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict, Optional, Pattern, Set, Tuple, Union
+
+__all__ = 'Change', 'AllWatcher', 'DefaultDirWatcher', 'DefaultWatcher', 'PythonWatcher', 'RegExpWatcher'
+logger = logging.getLogger('watchgod.watcher')
+
+
+class Change(IntEnum):
+    added = 1
+    modified = 2
+    deleted = 3
+
+
+if TYPE_CHECKING:
+    FileChange = Tuple[Change, str]
+    DirEntry = os.DirEntry[str]
+    StatResult = os.stat_result
+
+
+class AllWatcher:
+    def __init__(self, root_path: Union[Path, str], ignored_paths: Optional[Set[str]] = None) -> None:
+        self.files: Dict[str, float] = {}
+        self.root_path = str(root_path)
+        self.ignored_paths = ignored_paths
+        self.check()
+
+    def should_watch_dir(self, entry: 'DirEntry') -> bool:
+        return True
+
+    def should_watch_file(self, entry: 'DirEntry') -> bool:
+        return True
+
+    def _walk(self, path: str, changes: Set['FileChange'], new_files: Dict[str, float]) -> None:
+        if os.path.isfile(path):
+            self._watch_file(path, changes, new_files, os.stat(path))
+        else:
+            self._walk_dir(path, changes, new_files)
+
+    def _watch_file(
+        self, path: str, changes: Set['FileChange'], new_files: Dict[str, float], stat: 'StatResult'
+    ) -> None:
+        mtime = stat.st_mtime
+        new_files[path] = mtime
+        old_mtime = self.files.get(path)
+        if not old_mtime:
+            changes.add((Change.added, path))
+        elif old_mtime != mtime:
+            changes.add((Change.modified, path))
+
+    def _walk_dir(self, dir_path: str, changes: Set['FileChange'], new_files: Dict[str, float]) -> None:
+        for entry in os.scandir(dir_path):
+            if self.ignored_paths is not None and os.path.join(dir_path, entry) in self.ignored_paths:
+                continue
+
+            try:
+                if entry.is_dir():
+                    if self.should_watch_dir(entry):
+                        self._walk_dir(entry.path, changes, new_files)
+                elif self.should_watch_file(entry):
+                    self._watch_file(entry.path, changes, new_files, entry.stat())
+            except FileNotFoundError:  # pragma: no cover
+                # sometimes we can't find the file. If it was deleted since
+                # `entry` was allocated, then it doesn't matter and can be
+                # ignored.  It might also be a bad symlink, in which case we
+                # should silently skip it - users don't want to constantly spam
+                # warnings, esp if they can't remove the symlink (e.g. from a
+                # node_modules directory).
+                pass
+
+    def check(self) -> Set['FileChange']:
+        changes: Set['FileChange'] = set()
+        new_files: Dict[str, float] = {}
+        try:
+            self._walk(self.root_path, changes, new_files)
+        except OSError as e:
+            # check for unexpected errors
+            logger.warning('error walking file system: %s %s', e.__class__.__name__, e)
+
+        # look for deleted
+        deleted = self.files.keys() - new_files.keys()
+        if deleted:
+            changes |= {(Change.deleted, entry) for entry in deleted}
+
+        self.files = new_files
+        return changes
+
+
+class DefaultDirWatcher(AllWatcher):
+    ignored_dirs = {'.git', '__pycache__', 'site-packages', '.idea', 'node_modules'}
+
+    def should_watch_dir(self, entry: 'DirEntry') -> bool:
+        return entry.name not in self.ignored_dirs
+
+
+class DefaultWatcher(DefaultDirWatcher):
+    ignored_file_regexes = r'\.py[cod]$', r'\.___jb_...___$', r'\.sw.$', '~$', r'^\.\#', r'^flycheck_'
+
+    def __init__(self, root_path: Union[str, Path]) -> None:
+        self._ignored_file_regexes = tuple(re.compile(r) for r in self.ignored_file_regexes)
+        super().__init__(root_path)
+
+    def should_watch_file(self, entry: 'DirEntry') -> bool:
+        return not any(r.search(entry.name) for r in self._ignored_file_regexes)
+
+
+class PythonWatcher(DefaultDirWatcher):
+    def __init__(
+        self,
+        root_path: Union[Path, str],
+        ignored_paths: Optional[Set[str]] = None,
+        *,
+        extra_extensions: Tuple[str, ...] = (),
+    ) -> None:
+        self.extensions = ('.py', '.pyx', '.pyd') + extra_extensions
+        super().__init__(root_path, ignored_paths)
+
+    def should_watch_file(self, entry: 'DirEntry') -> bool:
+        return entry.name.endswith(self.extensions)
+
+
+class RegExpWatcher(AllWatcher):
+    def __init__(self, root_path: Union[str, Path], re_files: Optional[str] = None, re_dirs: Optional[str] = None):
+        self.re_files: Optional[Pattern[str]] = re.compile(re_files) if re_files is not None else re_files
+        self.re_dirs: Optional[Pattern[str]] = re.compile(re_dirs) if re_dirs is not None else re_dirs
+        super().__init__(root_path)
+
+    def should_watch_file(self, entry: 'DirEntry') -> bool:
+        if self.re_files is not None:
+            return bool(self.re_files.match(entry.path))
+        else:
+            return super().should_watch_file(entry)
+
+    def should_watch_dir(self, entry: 'DirEntry') -> bool:
+        if self.re_dirs is not None:
+            return bool(self.re_dirs.match(entry.path))
+        else:
+            return super().should_watch_dir(entry)
diff --git a/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/LICENSE
new file mode 100644
index 0000000..119b29e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/LICENSE
@@ -0,0 +1,25 @@
+Copyright (c) 2013-2021 Aymeric Augustin and contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * 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 websockets nor the names of its contributors may
+      be used to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/METADATA b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/METADATA
new file mode 100644
index 0000000..3b042a3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/METADATA
@@ -0,0 +1,174 @@
+Metadata-Version: 2.1
+Name: websockets
+Version: 10.3
+Summary: An implementation of the WebSocket Protocol (RFC 6455 & 7692)
+Home-page: https://github.com/aaugustin/websockets
+Author: Aymeric Augustin
+Author-email: aymeric.augustin@m4x.org
+License: BSD
+Project-URL: Changelog, https://websockets.readthedocs.io/en/stable/project/changelog.html
+Project-URL: Documentation, https://websockets.readthedocs.io/
+Project-URL: Funding, https://tidelift.com/subscription/pkg/pypi-websockets?utm_source=pypi-websockets&utm_medium=referral&utm_campaign=readme
+Project-URL: Tracker, https://github.com/aaugustin/websockets/issues
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.7
+License-File: LICENSE
+
+.. image:: logo/horizontal.svg
+   :width: 480px
+   :alt: websockets
+
+|licence| |version| |pyversions| |wheel| |tests| |docs|
+
+.. |licence| image:: https://img.shields.io/pypi/l/websockets.svg
+    :target: https://pypi.python.org/pypi/websockets
+
+.. |version| image:: https://img.shields.io/pypi/v/websockets.svg
+    :target: https://pypi.python.org/pypi/websockets
+
+.. |pyversions| image:: https://img.shields.io/pypi/pyversions/websockets.svg
+    :target: https://pypi.python.org/pypi/websockets
+
+.. |wheel| image:: https://img.shields.io/pypi/wheel/websockets.svg
+    :target: https://pypi.python.org/pypi/websockets
+
+.. |tests| image:: https://img.shields.io/github/checks-status/aaugustin/websockets/main
+   :target: https://github.com/aaugustin/websockets/actions/workflows/tests.yml
+
+.. |docs| image:: https://img.shields.io/readthedocs/websockets.svg
+   :target: https://websockets.readthedocs.io/
+
+What is ``websockets``?
+-----------------------
+
+websockets is a library for building WebSocket_ servers and clients in Python
+with a focus on correctness, simplicity, robustness, and performance.
+
+.. _WebSocket: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API
+
+Built on top of ``asyncio``, Python's standard asynchronous I/O framework, it
+provides an elegant coroutine-based API.
+
+`Documentation is available on Read the Docs. <https://websockets.readthedocs.io/>`_
+
+Here's how a client sends and receives messages:
+
+.. copy-pasted because GitHub doesn't support the include directive
+
+.. code:: python
+
+    #!/usr/bin/env python
+
+    import asyncio
+    from websockets import connect
+
+    async def hello(uri):
+        async with connect(uri) as websocket:
+            await websocket.send("Hello world!")
+            await websocket.recv()
+
+    asyncio.run(hello("ws://localhost:8765"))
+
+And here's an echo server:
+
+.. code:: python
+
+    #!/usr/bin/env python
+
+    import asyncio
+    from websockets import serve
+
+    async def echo(websocket):
+        async for message in websocket:
+            await websocket.send(message)
+
+    async def main():
+        async with serve(echo, "localhost", 8765):
+            await asyncio.Future()  # run forever
+
+    asyncio.run(main())
+
+Does that look good?
+
+`Get started with the tutorial! <https://websockets.readthedocs.io/en/stable/intro/index.html>`_
+
+Why should I use ``websockets``?
+--------------------------------
+
+The development of ``websockets`` is shaped by four principles:
+
+1. **Correctness**: ``websockets`` is heavily tested for compliance
+   with :rfc:`6455`. Continuous integration fails under 100% branch
+   coverage.
+
+2. **Simplicity**: all you need to understand is ``msg = await ws.recv()`` and
+   ``await ws.send(msg)``. ``websockets`` takes care of managing connections
+   so you can focus on your application.
+
+3. **Robustness**: ``websockets`` is built for production. For example, it was
+   the only library to `handle backpressure correctly`_ before the issue
+   became widely known in the Python community.
+
+4. **Performance**: memory usage is optimized and configurable. A C extension
+   accelerates expensive operations. It's pre-compiled for Linux, macOS and
+   Windows and packaged in the wheel format for each system and Python version.
+
+Documentation is a first class concern in the project. Head over to `Read the
+Docs`_ and see for yourself.
+
+.. _Read the Docs: https://websockets.readthedocs.io/
+.. _handle backpressure correctly: https://vorpus.org/blog/some-thoughts-on-asynchronous-api-design-in-a-post-asyncawait-world/#websocket-servers
+
+Why shouldn't I use ``websockets``?
+-----------------------------------
+
+* If you prefer callbacks over coroutines: ``websockets`` was created to
+  provide the best coroutine-based API to manage WebSocket connections in
+  Python. Pick another library for a callback-based API.
+
+* If you're looking for a mixed HTTP / WebSocket library: ``websockets`` aims
+  at being an excellent implementation of :rfc:`6455`: The WebSocket Protocol
+  and :rfc:`7692`: Compression Extensions for WebSocket. Its support for HTTP
+  is minimal — just enough for a HTTP health check.
+
+  If you want to do both in the same server, look at HTTP frameworks that
+  build on top of ``websockets`` to support WebSocket connections, like
+  Sanic_.
+
+.. _Sanic: https://sanicframework.org/en/
+
+What else?
+----------
+
+Bug reports, patches and suggestions are welcome!
+
+To report a security vulnerability, please use the `Tidelift security
+contact`_. Tidelift will coordinate the fix and disclosure.
+
+.. _Tidelift security contact: https://tidelift.com/security
+
+For anything else, please open an issue_ or send a `pull request`_.
+
+.. _issue: https://github.com/aaugustin/websockets/issues/new
+.. _pull request: https://github.com/aaugustin/websockets/compare/
+
+Participants must uphold the `Contributor Covenant code of conduct`_.
+
+.. _Contributor Covenant code of conduct: https://github.com/aaugustin/websockets/blob/main/CODE_OF_CONDUCT.md
+
+``websockets`` is released under the `BSD license`_.
+
+.. _BSD license: https://github.com/aaugustin/websockets/blob/main/LICENSE
+
+
diff --git a/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/RECORD b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/RECORD
new file mode 100644
index 0000000..003f469
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/RECORD
@@ -0,0 +1,39 @@
+websockets/auth.py,sha256=5XuTnxp6f2jzaNvTKhtOZ-OmM2gpTk7VQf6cy4yt60A,147
+websockets/server.py,sha256=Iiny4xr22P3LwhXR7JqJ1RnjHj8vhIF_JUrRmFG2NhU,18589
+websockets/streams.py,sha256=8nv62HYyS74t_JSWGie4SoYAz8-jMcQacaHnD0RkK90,4038
+websockets/version.py,sha256=yhNElABLU-tOd0GRXWsx90TMQ875wbtWnTCTOjsyF8A,2721
+websockets/speedups.c,sha256=ghPq-NF35VLVNkMv0uFDIruNpVISyW-qvoZgPpE65qw,5834
+websockets/client.py,sha256=MSMgw7EDQdMmCne1G9waC7d_ZDAvjCLlmPeziVBOomQ,11958
+websockets/__init__.py,sha256=bUXfO7WIhkYVe5PYiEMKqe2WUhb8UHX9kg0aKI7IiR4,3436
+websockets/imports.py,sha256=SXXs0glid-UHcwla5yjR72DIbGeUTrS9VFagPvPvRNY,2790
+websockets/http11.py,sha256=RaDWkRj1Sxch5fgxx650ugCH4aL9cwje7-FWDffQtUA,12690
+websockets/connection.py,sha256=-idouSlNUOSAMcvVpZTxLehKpsS7_2_YL7_pWEQl3OI,23665
+websockets/frames.py,sha256=y6SqLUM2-0amivtm6it_52FhSwNsXQOsJwVcchdjH3E,12381
+websockets/utils.py,sha256=QBhgbXn9ZvvLEzj-X8-zSHWVMkUqc6Wm-_HBjga5RNM,1150
+websockets/uri.py,sha256=HNPqnMY_PHyWGTu24L8Qx4VMrEU3wiH9zmDZaOJNznE,3201
+websockets/http.py,sha256=HR_IIij3xpoKkiLzGp4h5_NkVr2a8ZeCqGUopo6U4Rs,644
+websockets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+websockets/exceptions.py,sha256=Fxb5U01EEyS4I39OC1eFZ435Mzpp39g4di9XH-kMvBo,10049
+websockets/headers.py,sha256=RYryH2zqB_2Y02BTF2KsQFfYxAM6-Kh-A3Dv_32opAA,16120
+websockets/datastructures.py,sha256=pcT7RdCI6ZfYddHWMcwPR-1A89GRpj26xgdtmZsRgiA,5738
+websockets/typing.py,sha256=yx0SxSmil5JfG4fUtj-dgyR1UcW5wwmvgqtEOmcJxm4,1384
+websockets/__main__.py,sha256=q35Sx_FtGpvypZe9bhMQE9-Gn7SycFIJs-rZplO2Ai4,7255
+websockets/speedups.cpython-39-darwin.so,sha256=-xEAr5cFbefrG9nRnf-RFpcejl6Mck_ge3orzzmtwek,34664
+websockets/legacy/auth.py,sha256=1Vz32WAia2JNnQt1dYVkIg3sErcH68jnaK4U-ypIH_Q,6477
+websockets/legacy/handshake.py,sha256=RK_ui9O5TLQrb-eBKcX_5s8Xc7BOlLjC_gNFvui4wi4,5476
+websockets/legacy/compatibility.py,sha256=fWvZfzx13bBU2eOUIJrZCJJS8N3fSyZjO5RD1tYn0K0,314
+websockets/legacy/server.py,sha256=FaBeyhAHvpLeV5XX36-9UurEJFiRc9hWCAC7uGoqbak,43078
+websockets/legacy/protocol.py,sha256=VKSkPqlAf0DCdp3Nwpt6tLBcKVym8Z-3bpW14wTUY4w,61829
+websockets/legacy/client.py,sha256=hbKDT2clB7tHzIulYZaNzLnzno2VsDK7YaBGu3nWn2Q,26009
+websockets/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+websockets/legacy/http.py,sha256=Ax9ovi_244l3hhooYGfcTTn_onBCkGrlT1RBilAa_Z4,6930
+websockets/legacy/framing.py,sha256=HERjiS62WPoBoogDb84InG8AcLaQw3HtXN1F8Ka3MwY,5021
+websockets/extensions/permessage_deflate.py,sha256=AeOA-tTty6i-VHpGF5UcGsKx7bhy0jDDiiwVtM4u8Ns,24783
+websockets/extensions/__init__.py,sha256=QkZsxaJVllVSp1uhdD5uPGibdbx_091GrVVfS5LXcpw,98
+websockets/extensions/base.py,sha256=pD-rkuMKayftnwJ2dT3w_GgmEi7jI30dsICBFj1Qj2s,3101
+websockets-10.3.dist-info/LICENSE,sha256=2uyhG_NgjaNeVG6gwyvhiViovhRB-j3py9IOTIvHGOY,1536
+websockets-10.3.dist-info/WHEEL,sha256=JIE30nfOWUuazI4Vcfiuv_cYm-SkZCh6YOqQQjhm90A,109
+websockets-10.3.dist-info/top_level.txt,sha256=AmmQQqhFwjoCEKzNajXY5f28yxLP_cgVflJES82E_cs,51
+websockets-10.3.dist-info/METADATA,sha256=WmVHPSlLRfuF4mgoL8iR6ZcWzt28qG077rtpGHsF6XU,6309
+websockets-10.3.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+websockets-10.3.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/WHEEL
new file mode 100644
index 0000000..9c3644e
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_9_x86_64
+
diff --git a/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/top_level.txt
new file mode 100644
index 0000000..5474af7
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets-10.3.dist-info/top_level.txt
@@ -0,0 +1,3 @@
+websockets
+websockets/extensions
+websockets/legacy
diff --git a/myenv/lib/python3.9/site-packages/websockets/__init__.py b/myenv/lib/python3.9/site-packages/websockets/__init__.py
new file mode 100644
index 0000000..ec34841
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/__init__.py
@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from .imports import lazy_import
+from .version import version as __version__  # noqa
+
+
+__all__ = [  # noqa
+    "AbortHandshake",
+    "basic_auth_protocol_factory",
+    "BasicAuthWebSocketServerProtocol",
+    "broadcast",
+    "ClientConnection",
+    "connect",
+    "ConnectionClosed",
+    "ConnectionClosedError",
+    "ConnectionClosedOK",
+    "Data",
+    "DuplicateParameter",
+    "ExtensionName",
+    "ExtensionParameter",
+    "InvalidHandshake",
+    "InvalidHeader",
+    "InvalidHeaderFormat",
+    "InvalidHeaderValue",
+    "InvalidMessage",
+    "InvalidOrigin",
+    "InvalidParameterName",
+    "InvalidParameterValue",
+    "InvalidState",
+    "InvalidStatus",
+    "InvalidStatusCode",
+    "InvalidUpgrade",
+    "InvalidURI",
+    "LoggerLike",
+    "NegotiationError",
+    "Origin",
+    "parse_uri",
+    "PayloadTooBig",
+    "ProtocolError",
+    "RedirectHandshake",
+    "SecurityError",
+    "serve",
+    "ServerConnection",
+    "Subprotocol",
+    "unix_connect",
+    "unix_serve",
+    "WebSocketClientProtocol",
+    "WebSocketCommonProtocol",
+    "WebSocketException",
+    "WebSocketProtocolError",
+    "WebSocketServer",
+    "WebSocketServerProtocol",
+    "WebSocketURI",
+]
+
+lazy_import(
+    globals(),
+    aliases={
+        "auth": ".legacy",
+        "basic_auth_protocol_factory": ".legacy.auth",
+        "BasicAuthWebSocketServerProtocol": ".legacy.auth",
+        "broadcast": ".legacy.protocol",
+        "ClientConnection": ".client",
+        "connect": ".legacy.client",
+        "unix_connect": ".legacy.client",
+        "WebSocketClientProtocol": ".legacy.client",
+        "Headers": ".datastructures",
+        "MultipleValuesError": ".datastructures",
+        "WebSocketException": ".exceptions",
+        "ConnectionClosed": ".exceptions",
+        "ConnectionClosedError": ".exceptions",
+        "ConnectionClosedOK": ".exceptions",
+        "InvalidHandshake": ".exceptions",
+        "SecurityError": ".exceptions",
+        "InvalidMessage": ".exceptions",
+        "InvalidHeader": ".exceptions",
+        "InvalidHeaderFormat": ".exceptions",
+        "InvalidHeaderValue": ".exceptions",
+        "InvalidOrigin": ".exceptions",
+        "InvalidUpgrade": ".exceptions",
+        "InvalidStatus": ".exceptions",
+        "InvalidStatusCode": ".exceptions",
+        "NegotiationError": ".exceptions",
+        "DuplicateParameter": ".exceptions",
+        "InvalidParameterName": ".exceptions",
+        "InvalidParameterValue": ".exceptions",
+        "AbortHandshake": ".exceptions",
+        "RedirectHandshake": ".exceptions",
+        "InvalidState": ".exceptions",
+        "InvalidURI": ".exceptions",
+        "PayloadTooBig": ".exceptions",
+        "ProtocolError": ".exceptions",
+        "WebSocketProtocolError": ".exceptions",
+        "protocol": ".legacy",
+        "WebSocketCommonProtocol": ".legacy.protocol",
+        "ServerConnection": ".server",
+        "serve": ".legacy.server",
+        "unix_serve": ".legacy.server",
+        "WebSocketServerProtocol": ".legacy.server",
+        "WebSocketServer": ".legacy.server",
+        "Data": ".typing",
+        "LoggerLike": ".typing",
+        "Origin": ".typing",
+        "ExtensionHeader": ".typing",
+        "ExtensionParameter": ".typing",
+        "Subprotocol": ".typing",
+    },
+    deprecated_aliases={
+        "framing": ".legacy",
+        "handshake": ".legacy",
+        "parse_uri": ".uri",
+        "WebSocketURI": ".uri",
+    },
+)
diff --git a/myenv/lib/python3.9/site-packages/websockets/__main__.py b/myenv/lib/python3.9/site-packages/websockets/__main__.py
new file mode 100644
index 0000000..c562d21
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/__main__.py
@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import signal
+import sys
+import threading
+from typing import Any, Set
+
+from .exceptions import ConnectionClosed
+from .frames import Close
+from .legacy.client import connect
+from .version import version as websockets_version
+
+
+if sys.platform == "win32":
+
+    def win_enable_vt100() -> None:
+        """
+        Enable VT-100 for console output on Windows.
+
+        See also https://bugs.python.org/issue29059.
+
+        """
+        import ctypes
+
+        STD_OUTPUT_HANDLE = ctypes.c_uint(-11)
+        INVALID_HANDLE_VALUE = ctypes.c_uint(-1)
+        ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x004
+
+        handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+        if handle == INVALID_HANDLE_VALUE:
+            raise RuntimeError("unable to obtain stdout handle")
+
+        cur_mode = ctypes.c_uint()
+        if ctypes.windll.kernel32.GetConsoleMode(handle, ctypes.byref(cur_mode)) == 0:
+            raise RuntimeError("unable to query current console mode")
+
+        # ctypes ints lack support for the required bit-OR operation.
+        # Temporarily convert to Py int, do the OR and convert back.
+        py_int_mode = int.from_bytes(cur_mode, sys.byteorder)
+        new_mode = ctypes.c_uint(py_int_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+
+        if ctypes.windll.kernel32.SetConsoleMode(handle, new_mode) == 0:
+            raise RuntimeError("unable to set console mode")
+
+
+def exit_from_event_loop_thread(
+    loop: asyncio.AbstractEventLoop,
+    stop: asyncio.Future[None],
+) -> None:
+    loop.stop()
+    if not stop.done():
+        # When exiting the thread that runs the event loop, raise
+        # KeyboardInterrupt in the main thread to exit the program.
+        if sys.platform == "win32":
+            ctrl_c = signal.CTRL_C_EVENT
+        else:
+            ctrl_c = signal.SIGINT
+        os.kill(os.getpid(), ctrl_c)
+
+
+def print_during_input(string: str) -> None:
+    sys.stdout.write(
+        # Save cursor position
+        "\N{ESC}7"
+        # Add a new line
+        "\N{LINE FEED}"
+        # Move cursor up
+        "\N{ESC}[A"
+        # Insert blank line, scroll last line down
+        "\N{ESC}[L"
+        # Print string in the inserted blank line
+        f"{string}\N{LINE FEED}"
+        # Restore cursor position
+        "\N{ESC}8"
+        # Move cursor down
+        "\N{ESC}[B"
+    )
+    sys.stdout.flush()
+
+
+def print_over_input(string: str) -> None:
+    sys.stdout.write(
+        # Move cursor to beginning of line
+        "\N{CARRIAGE RETURN}"
+        # Delete current line
+        "\N{ESC}[K"
+        # Print string
+        f"{string}\N{LINE FEED}"
+    )
+    sys.stdout.flush()
+
+
+async def run_client(
+    uri: str,
+    loop: asyncio.AbstractEventLoop,
+    inputs: asyncio.Queue[str],
+    stop: asyncio.Future[None],
+) -> None:
+    try:
+        websocket = await connect(uri)
+    except Exception as exc:
+        print_over_input(f"Failed to connect to {uri}: {exc}.")
+        exit_from_event_loop_thread(loop, stop)
+        return
+    else:
+        print_during_input(f"Connected to {uri}.")
+
+    try:
+        while True:
+            incoming: asyncio.Future[Any] = asyncio.create_task(websocket.recv())
+            outgoing: asyncio.Future[Any] = asyncio.create_task(inputs.get())
+            done: Set[asyncio.Future[Any]]
+            pending: Set[asyncio.Future[Any]]
+            done, pending = await asyncio.wait(
+                [incoming, outgoing, stop], return_when=asyncio.FIRST_COMPLETED
+            )
+
+            # Cancel pending tasks to avoid leaking them.
+            if incoming in pending:
+                incoming.cancel()
+            if outgoing in pending:
+                outgoing.cancel()
+
+            if incoming in done:
+                try:
+                    message = incoming.result()
+                except ConnectionClosed:
+                    break
+                else:
+                    if isinstance(message, str):
+                        print_during_input("< " + message)
+                    else:
+                        print_during_input("< (binary) " + message.hex())
+
+            if outgoing in done:
+                message = outgoing.result()
+                await websocket.send(message)
+
+            if stop in done:
+                break
+
+    finally:
+        await websocket.close()
+        assert websocket.close_code is not None and websocket.close_reason is not None
+        close_status = Close(websocket.close_code, websocket.close_reason)
+
+        print_over_input(f"Connection closed: {close_status}.")
+
+        exit_from_event_loop_thread(loop, stop)
+
+
+def main() -> None:
+    # Parse command line arguments.
+    parser = argparse.ArgumentParser(
+        prog="python -m websockets",
+        description="Interactive WebSocket client.",
+        add_help=False,
+    )
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("--version", action="store_true")
+    group.add_argument("uri", metavar="<uri>", nargs="?")
+    args = parser.parse_args()
+
+    if args.version:
+        print(f"websockets {websockets_version}")
+        return
+
+    if args.uri is None:
+        parser.error("the following arguments are required: <uri>")
+
+    # If we're on Windows, enable VT100 terminal support.
+    if sys.platform == "win32":
+        try:
+            win_enable_vt100()
+        except RuntimeError as exc:
+            sys.stderr.write(
+                f"Unable to set terminal to VT100 mode. This is only "
+                f"supported since Win10 anniversary update. Expect "
+                f"weird symbols on the terminal.\nError: {exc}\n"
+            )
+            sys.stderr.flush()
+
+    try:
+        import readline  # noqa
+    except ImportError:  # Windows has no `readline` normally
+        pass
+
+    # Create an event loop that will run in a background thread.
+    loop = asyncio.new_event_loop()
+
+    # Due to zealous removal of the loop parameter in the Queue constructor,
+    # we need a factory coroutine to run in the freshly created event loop.
+    async def queue_factory() -> asyncio.Queue[str]:
+        return asyncio.Queue()
+
+    # Create a queue of user inputs. There's no need to limit its size.
+    inputs: asyncio.Queue[str] = loop.run_until_complete(queue_factory())
+
+    # Create a stop condition when receiving SIGINT or SIGTERM.
+    stop: asyncio.Future[None] = loop.create_future()
+
+    # Schedule the task that will manage the connection.
+    loop.create_task(run_client(args.uri, loop, inputs, stop))
+
+    # Start the event loop in a background thread.
+    thread = threading.Thread(target=loop.run_forever)
+    thread.start()
+
+    # Read from stdin in the main thread in order to receive signals.
+    try:
+        while True:
+            # Since there's no size limit, put_nowait is identical to put.
+            message = input("> ")
+            loop.call_soon_threadsafe(inputs.put_nowait, message)
+    except (KeyboardInterrupt, EOFError):  # ^C, ^D
+        loop.call_soon_threadsafe(stop.set_result, None)
+
+    # Wait for the event loop to terminate.
+    thread.join()
+
+    # For reasons unclear, even though the loop is closed in the thread,
+    # it still thinks it's running here.
+    loop.close()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/myenv/lib/python3.9/site-packages/websockets/auth.py b/myenv/lib/python3.9/site-packages/websockets/auth.py
new file mode 100644
index 0000000..afcb38c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/auth.py
@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+# See #940 for why lazy_import isn't used here for backwards compatibility.
+from .legacy.auth import *  # noqa
diff --git a/myenv/lib/python3.9/site-packages/websockets/client.py b/myenv/lib/python3.9/site-packages/websockets/client.py
new file mode 100644
index 0000000..df8e534
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/client.py
@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+from typing import Generator, List, Optional, Sequence
+
+from .connection import CLIENT, CONNECTING, OPEN, Connection, State
+from .datastructures import Headers, MultipleValuesError
+from .exceptions import (
+    InvalidHandshake,
+    InvalidHeader,
+    InvalidHeaderValue,
+    InvalidStatus,
+    InvalidUpgrade,
+    NegotiationError,
+)
+from .extensions import ClientExtensionFactory, Extension
+from .headers import (
+    build_authorization_basic,
+    build_extension,
+    build_host,
+    build_subprotocol,
+    parse_connection,
+    parse_extension,
+    parse_subprotocol,
+    parse_upgrade,
+)
+from .http import USER_AGENT
+from .http11 import Request, Response
+from .typing import (
+    ConnectionOption,
+    ExtensionHeader,
+    LoggerLike,
+    Origin,
+    Subprotocol,
+    UpgradeProtocol,
+)
+from .uri import WebSocketURI
+from .utils import accept_key, generate_key
+
+
+# See #940 for why lazy_import isn't used here for backwards compatibility.
+from .legacy.client import *  # isort:skip  # noqa
+
+
+__all__ = ["ClientConnection"]
+
+
+class ClientConnection(Connection):
+    """
+    Sans-I/O implementation of a WebSocket client connection.
+
+    Args:
+        wsuri: URI of the WebSocket server, parsed
+            with :func:`~websockets.uri.parse_uri`.
+        origin: value of the ``Origin`` header. This is useful when connecting
+            to a server that validates the ``Origin`` header to defend against
+            Cross-Site WebSocket Hijacking attacks.
+        extensions: list of supported extensions, in order in which they
+            should be tried.
+        subprotocols: list of supported subprotocols, in order of decreasing
+            preference.
+        state: initial state of the WebSocket connection.
+        max_size: maximum size of incoming messages in bytes;
+            :obj:`None` to disable the limit.
+        logger: logger for this connection;
+            defaults to ``logging.getLogger("websockets.client")``;
+            see the :doc:`logging guide <../topics/logging>` for details.
+
+    """
+
+    def __init__(
+        self,
+        wsuri: WebSocketURI,
+        origin: Optional[Origin] = None,
+        extensions: Optional[Sequence[ClientExtensionFactory]] = None,
+        subprotocols: Optional[Sequence[Subprotocol]] = None,
+        state: State = CONNECTING,
+        max_size: Optional[int] = 2**20,
+        logger: Optional[LoggerLike] = None,
+    ):
+        super().__init__(
+            side=CLIENT,
+            state=state,
+            max_size=max_size,
+            logger=logger,
+        )
+        self.wsuri = wsuri
+        self.origin = origin
+        self.available_extensions = extensions
+        self.available_subprotocols = subprotocols
+        self.key = generate_key()
+
+    def connect(self) -> Request:  # noqa: F811
+        """
+        Create a handshake request to open a connection.
+
+        You must send the handshake request with :meth:`send_request`.
+
+        You can modify it before sending it, for example to add HTTP headers.
+
+        Returns:
+            Request: WebSocket handshake request event to send to the server.
+
+        """
+        headers = Headers()
+
+        headers["Host"] = build_host(
+            self.wsuri.host, self.wsuri.port, self.wsuri.secure
+        )
+
+        if self.wsuri.user_info:
+            headers["Authorization"] = build_authorization_basic(*self.wsuri.user_info)
+
+        if self.origin is not None:
+            headers["Origin"] = self.origin
+
+        headers["Upgrade"] = "websocket"
+        headers["Connection"] = "Upgrade"
+        headers["Sec-WebSocket-Key"] = self.key
+        headers["Sec-WebSocket-Version"] = "13"
+
+        if self.available_extensions is not None:
+            extensions_header = build_extension(
+                [
+                    (extension_factory.name, extension_factory.get_request_params())
+                    for extension_factory in self.available_extensions
+                ]
+            )
+            headers["Sec-WebSocket-Extensions"] = extensions_header
+
+        if self.available_subprotocols is not None:
+            protocol_header = build_subprotocol(self.available_subprotocols)
+            headers["Sec-WebSocket-Protocol"] = protocol_header
+
+        headers["User-Agent"] = USER_AGENT
+
+        return Request(self.wsuri.resource_name, headers)
+
+    def process_response(self, response: Response) -> None:
+        """
+        Check a handshake response.
+
+        Args:
+            request: WebSocket handshake response received from the server.
+
+        Raises:
+            InvalidHandshake: if the handshake response is invalid.
+
+        """
+
+        if response.status_code != 101:
+            raise InvalidStatus(response)
+
+        headers = response.headers
+
+        connection: List[ConnectionOption] = sum(
+            [parse_connection(value) for value in headers.get_all("Connection")], []
+        )
+
+        if not any(value.lower() == "upgrade" for value in connection):
+            raise InvalidUpgrade(
+                "Connection", ", ".join(connection) if connection else None
+            )
+
+        upgrade: List[UpgradeProtocol] = sum(
+            [parse_upgrade(value) for value in headers.get_all("Upgrade")], []
+        )
+
+        # For compatibility with non-strict implementations, ignore case when
+        # checking the Upgrade header. It's supposed to be 'WebSocket'.
+        if not (len(upgrade) == 1 and upgrade[0].lower() == "websocket"):
+            raise InvalidUpgrade("Upgrade", ", ".join(upgrade) if upgrade else None)
+
+        try:
+            s_w_accept = headers["Sec-WebSocket-Accept"]
+        except KeyError as exc:
+            raise InvalidHeader("Sec-WebSocket-Accept") from exc
+        except MultipleValuesError as exc:
+            raise InvalidHeader(
+                "Sec-WebSocket-Accept",
+                "more than one Sec-WebSocket-Accept header found",
+            ) from exc
+
+        if s_w_accept != accept_key(self.key):
+            raise InvalidHeaderValue("Sec-WebSocket-Accept", s_w_accept)
+
+        self.extensions = self.process_extensions(headers)
+
+        self.subprotocol = self.process_subprotocol(headers)
+
+    def process_extensions(self, headers: Headers) -> List[Extension]:
+        """
+        Handle the Sec-WebSocket-Extensions HTTP response header.
+
+        Check that each extension is supported, as well as its parameters.
+
+        :rfc:`6455` leaves the rules up to the specification of each
+        extension.
+
+        To provide this level of flexibility, for each extension accepted by
+        the server, we check for a match with each extension available in the
+        client configuration. If no match is found, an exception is raised.
+
+        If several variants of the same extension are accepted by the server,
+        it may be configured several times, which won't make sense in general.
+        Extensions must implement their own requirements. For this purpose,
+        the list of previously accepted extensions is provided.
+
+        Other requirements, for example related to mandatory extensions or the
+        order of extensions, may be implemented by overriding this method.
+
+        Args:
+            headers: WebSocket handshake response headers.
+
+        Returns:
+            List[Extension]: List of accepted extensions.
+
+        Raises:
+            InvalidHandshake: to abort the handshake.
+
+        """
+        accepted_extensions: List[Extension] = []
+
+        extensions = headers.get_all("Sec-WebSocket-Extensions")
+
+        if extensions:
+
+            if self.available_extensions is None:
+                raise InvalidHandshake("no extensions supported")
+
+            parsed_extensions: List[ExtensionHeader] = sum(
+                [parse_extension(header_value) for header_value in extensions], []
+            )
+
+            for name, response_params in parsed_extensions:
+
+                for extension_factory in self.available_extensions:
+
+                    # Skip non-matching extensions based on their name.
+                    if extension_factory.name != name:
+                        continue
+
+                    # Skip non-matching extensions based on their params.
+                    try:
+                        extension = extension_factory.process_response_params(
+                            response_params, accepted_extensions
+                        )
+                    except NegotiationError:
+                        continue
+
+                    # Add matching extension to the final list.
+                    accepted_extensions.append(extension)
+
+                    # Break out of the loop once we have a match.
+                    break
+
+                # If we didn't break from the loop, no extension in our list
+                # matched what the server sent. Fail the connection.
+                else:
+                    raise NegotiationError(
+                        f"Unsupported extension: "
+                        f"name = {name}, params = {response_params}"
+                    )
+
+        return accepted_extensions
+
+    def process_subprotocol(self, headers: Headers) -> Optional[Subprotocol]:
+        """
+        Handle the Sec-WebSocket-Protocol HTTP response header.
+
+        If provided, check that it contains exactly one supported subprotocol.
+
+        Args:
+            headers: WebSocket handshake response headers.
+
+        Returns:
+           Optional[Subprotocol]: Subprotocol, if one was selected.
+
+        """
+        subprotocol: Optional[Subprotocol] = None
+
+        subprotocols = headers.get_all("Sec-WebSocket-Protocol")
+
+        if subprotocols:
+
+            if self.available_subprotocols is None:
+                raise InvalidHandshake("no subprotocols supported")
+
+            parsed_subprotocols: Sequence[Subprotocol] = sum(
+                [parse_subprotocol(header_value) for header_value in subprotocols], []
+            )
+
+            if len(parsed_subprotocols) > 1:
+                subprotocols_display = ", ".join(parsed_subprotocols)
+                raise InvalidHandshake(f"multiple subprotocols: {subprotocols_display}")
+
+            subprotocol = parsed_subprotocols[0]
+
+            if subprotocol not in self.available_subprotocols:
+                raise NegotiationError(f"unsupported subprotocol: {subprotocol}")
+
+        return subprotocol
+
+    def send_request(self, request: Request) -> None:
+        """
+        Send a handshake request to the server.
+
+        Args:
+            request: WebSocket handshake request event.
+
+        """
+        if self.debug:
+            self.logger.debug("> GET %s HTTP/1.1", request.path)
+            for key, value in request.headers.raw_items():
+                self.logger.debug("> %s: %s", key, value)
+
+        self.writes.append(request.serialize())
+
+    def parse(self) -> Generator[None, None, None]:
+        if self.state is CONNECTING:
+            response = yield from Response.parse(
+                self.reader.read_line,
+                self.reader.read_exact,
+                self.reader.read_to_eof,
+            )
+
+            if self.debug:
+                code, phrase = response.status_code, response.reason_phrase
+                self.logger.debug("< HTTP/1.1 %d %s", code, phrase)
+                for key, value in response.headers.raw_items():
+                    self.logger.debug("< %s: %s", key, value)
+                if response.body is not None:
+                    self.logger.debug("< [body] (%d bytes)", len(response.body))
+
+            try:
+                self.process_response(response)
+            except InvalidHandshake as exc:
+                response._exception = exc
+                self.handshake_exc = exc
+                self.parser = self.discard()
+                next(self.parser)  # start coroutine
+            else:
+                assert self.state is CONNECTING
+                self.state = OPEN
+            finally:
+                self.events.append(response)
+
+        yield from super().parse()
diff --git a/myenv/lib/python3.9/site-packages/websockets/connection.py b/myenv/lib/python3.9/site-packages/websockets/connection.py
new file mode 100644
index 0000000..db8b536
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/connection.py
@@ -0,0 +1,702 @@
+from __future__ import annotations
+
+import enum
+import logging
+import uuid
+from typing import Generator, List, Optional, Type, Union
+
+from .exceptions import (
+    ConnectionClosed,
+    ConnectionClosedError,
+    ConnectionClosedOK,
+    InvalidState,
+    PayloadTooBig,
+    ProtocolError,
+)
+from .extensions import Extension
+from .frames import (
+    OK_CLOSE_CODES,
+    OP_BINARY,
+    OP_CLOSE,
+    OP_CONT,
+    OP_PING,
+    OP_PONG,
+    OP_TEXT,
+    Close,
+    Frame,
+)
+from .http11 import Request, Response
+from .streams import StreamReader
+from .typing import LoggerLike, Origin, Subprotocol
+
+
+__all__ = [
+    "Connection",
+    "Side",
+    "State",
+    "SEND_EOF",
+]
+
+Event = Union[Request, Response, Frame]
+"""Events that :meth:`~Connection.events_received` may return."""
+
+
+class Side(enum.IntEnum):
+    """A WebSocket connection is either a server or a client."""
+
+    SERVER, CLIENT = range(2)
+
+
+SERVER = Side.SERVER
+CLIENT = Side.CLIENT
+
+
+class State(enum.IntEnum):
+    """A WebSocket connection is in one of these four states."""
+
+    CONNECTING, OPEN, CLOSING, CLOSED = range(4)
+
+
+CONNECTING = State.CONNECTING
+OPEN = State.OPEN
+CLOSING = State.CLOSING
+CLOSED = State.CLOSED
+
+
+SEND_EOF = b""
+"""Sentinel signaling that the TCP connection must be half-closed."""
+
+
+class Connection:
+    """
+    Sans-I/O implementation of a WebSocket connection.
+
+    Args:
+        side: :attr:`~Side.CLIENT` or :attr:`~Side.SERVER`.
+        state: initial state of the WebSocket connection.
+        max_size: maximum size of incoming messages in bytes;
+            :obj:`None` to disable the limit.
+        logger: logger for this connection; depending on ``side``,
+            defaults to ``logging.getLogger("websockets.client")``
+            or ``logging.getLogger("websockets.server")``;
+            see the :doc:`logging guide <../topics/logging>` for details.
+
+    """
+
+    def __init__(
+        self,
+        side: Side,
+        state: State = OPEN,
+        max_size: Optional[int] = 2**20,
+        logger: Optional[LoggerLike] = None,
+    ) -> None:
+        # Unique identifier. For logs.
+        self.id: uuid.UUID = uuid.uuid4()
+        """Unique identifier of the connection. Useful in logs."""
+
+        # Logger or LoggerAdapter for this connection.
+        if logger is None:
+            logger = logging.getLogger(f"websockets.{side.name.lower()}")
+        self.logger: LoggerLike = logger
+        """Logger for this connection."""
+
+        # Track if DEBUG is enabled. Shortcut logging calls if it isn't.
+        self.debug = logger.isEnabledFor(logging.DEBUG)
+
+        # Connection side. CLIENT or SERVER.
+        self.side = side
+
+        # Connection state. Initially OPEN because subclasses handle CONNECTING.
+        self.state = state
+
+        # Maximum size of incoming messages in bytes.
+        self.max_size = max_size
+
+        # Current size of incoming message in bytes. Only set while reading a
+        # fragmented message i.e. a data frames with the FIN bit not set.
+        self.cur_size: Optional[int] = None
+
+        # True while sending a fragmented message i.e. a data frames with the
+        # FIN bit not set.
+        self.expect_continuation_frame = False
+
+        # WebSocket protocol parameters.
+        self.origin: Optional[Origin] = None
+        self.extensions: List[Extension] = []
+        self.subprotocol: Optional[Subprotocol] = None
+
+        # Close code and reason, set when a close frame is sent or received.
+        self.close_rcvd: Optional[Close] = None
+        self.close_sent: Optional[Close] = None
+        self.close_rcvd_then_sent: Optional[bool] = None
+
+        # Track if an exception happened during the handshake.
+        self.handshake_exc: Optional[Exception] = None
+        """
+        Exception to raise if the opening handshake failed.
+
+        :obj:`None` if the opening handshake succeeded.
+
+        """
+
+        # Track if send_eof() was called.
+        self.eof_sent = False
+
+        # Parser state.
+        self.reader = StreamReader()
+        self.events: List[Event] = []
+        self.writes: List[bytes] = []
+        self.parser = self.parse()
+        next(self.parser)  # start coroutine
+        self.parser_exc: Optional[Exception] = None
+
+    @property
+    def state(self) -> State:
+        """
+        WebSocket connection state.
+
+        Defined in 4.1, 4.2, 7.1.3, and 7.1.4 of :rfc:`6455`.
+
+        """
+        return self._state
+
+    @state.setter
+    def state(self, state: State) -> None:
+        if self.debug:
+            self.logger.debug("= connection is %s", state.name)
+        self._state = state
+
+    @property
+    def close_code(self) -> Optional[int]:
+        """
+        `WebSocket close code`_.
+
+        .. _WebSocket close code:
+            https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.5
+
+        :obj:`None` if the connection isn't closed yet.
+
+        """
+        if self.state is not CLOSED:
+            return None
+        elif self.close_rcvd is None:
+            return 1006
+        else:
+            return self.close_rcvd.code
+
+    @property
+    def close_reason(self) -> Optional[str]:
+        """
+        `WebSocket close reason`_.
+
+        .. _WebSocket close reason:
+            https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.6
+
+        :obj:`None` if the connection isn't closed yet.
+
+        """
+        if self.state is not CLOSED:
+            return None
+        elif self.close_rcvd is None:
+            return ""
+        else:
+            return self.close_rcvd.reason
+
+    @property
+    def close_exc(self) -> ConnectionClosed:
+        """
+        Exception to raise when trying to interact with a closed connection.
+
+        Don't raise this exception while the connection :attr:`state`
+        is :attr:`~websockets.connection.State.CLOSING`; wait until
+        it's :attr:`~websockets.connection.State.CLOSED`.
+
+        Indeed, the exception includes the close code and reason, which are
+        known only once the connection is closed.
+
+        Raises:
+            AssertionError: if the connection isn't closed yet.
+
+        """
+        assert self.state is CLOSED, "connection isn't closed yet"
+        exc_type: Type[ConnectionClosed]
+        if (
+            self.close_rcvd is not None
+            and self.close_sent is not None
+            and self.close_rcvd.code in OK_CLOSE_CODES
+            and self.close_sent.code in OK_CLOSE_CODES
+        ):
+            exc_type = ConnectionClosedOK
+        else:
+            exc_type = ConnectionClosedError
+        exc: ConnectionClosed = exc_type(
+            self.close_rcvd,
+            self.close_sent,
+            self.close_rcvd_then_sent,
+        )
+        # Chain to the exception raised in the parser, if any.
+        exc.__cause__ = self.parser_exc
+        return exc
+
+    # Public methods for receiving data.
+
+    def receive_data(self, data: bytes) -> None:
+        """
+        Receive data from the network.
+
+        After calling this method:
+
+        - You must call :meth:`data_to_send` and send this data to the network.
+        - You should call :meth:`events_received` and process resulting events.
+
+        Raises:
+            EOFError: if :meth:`receive_eof` was called earlier.
+
+        """
+        self.reader.feed_data(data)
+        next(self.parser)
+
+    def receive_eof(self) -> None:
+        """
+        Receive the end of the data stream from the network.
+
+        After calling this method:
+
+        - You must call :meth:`data_to_send` and send this data to the network.
+        - You aren't expected to call :meth:`events_received`; it won't return
+          any new events.
+
+        Raises:
+            EOFError: if :meth:`receive_eof` was called earlier.
+
+        """
+        self.reader.feed_eof()
+        next(self.parser)
+
+    # Public methods for sending events.
+
+    def send_continuation(self, data: bytes, fin: bool) -> None:
+        """
+        Send a `Continuation frame`_.
+
+        .. _Continuation frame:
+            https://datatracker.ietf.org/doc/html/rfc6455#section-5.6
+
+        Parameters:
+            data: payload containing the same kind of data
+                as the initial frame.
+            fin: FIN bit; set it to :obj:`True` if this is the last frame
+                of a fragmented message and to :obj:`False` otherwise.
+
+        Raises:
+            ProtocolError: if a fragmented message isn't in progress.
+
+        """
+        if not self.expect_continuation_frame:
+            raise ProtocolError("unexpected continuation frame")
+        self.expect_continuation_frame = not fin
+        self.send_frame(Frame(OP_CONT, data, fin))
+
+    def send_text(self, data: bytes, fin: bool = True) -> None:
+        """
+        Send a `Text frame`_.
+
+        .. _Text frame:
+            https://datatracker.ietf.org/doc/html/rfc6455#section-5.6
+
+        Parameters:
+            data: payload containing text encoded with UTF-8.
+            fin: FIN bit; set it to :obj:`False` if this is the first frame of
+                a fragmented message.
+
+        Raises:
+            ProtocolError: if a fragmented message is in progress.
+
+        """
+        if self.expect_continuation_frame:
+            raise ProtocolError("expected a continuation frame")
+        self.expect_continuation_frame = not fin
+        self.send_frame(Frame(OP_TEXT, data, fin))
+
+    def send_binary(self, data: bytes, fin: bool = True) -> None:
+        """
+        Send a `Binary frame`_.
+
+        .. _Binary frame:
+            https://datatracker.ietf.org/doc/html/rfc6455#section-5.6
+
+        Parameters:
+            data: payload containing arbitrary binary data.
+            fin: FIN bit; set it to :obj:`False` if this is the first frame of
+                a fragmented message.
+
+        Raises:
+            ProtocolError: if a fragmented message is in progress.
+
+        """
+        if self.expect_continuation_frame:
+            raise ProtocolError("expected a continuation frame")
+        self.expect_continuation_frame = not fin
+        self.send_frame(Frame(OP_BINARY, data, fin))
+
+    def send_close(self, code: Optional[int] = None, reason: str = "") -> None:
+        """
+        Send a `Close frame`_.
+
+        .. _Close frame:
+            https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.1
+
+        Parameters:
+            code: close code.
+            reason: close reason.
+
+        Raises:
+            ProtocolError: if a fragmented message is being sent, if the code
+                isn't valid, or if a reason is provided without a code
+
+        """
+        if self.expect_continuation_frame:
+            raise ProtocolError("expected a continuation frame")
+        if code is None:
+            if reason != "":
+                raise ProtocolError("cannot send a reason without a code")
+            close = Close(1005, "")
+            data = b""
+        else:
+            close = Close(code, reason)
+            data = close.serialize()
+        # send_frame() guarantees that self.state is OPEN at this point.
+        # 7.1.3. The WebSocket Closing Handshake is Started
+        self.send_frame(Frame(OP_CLOSE, data))
+        self.close_sent = close
+        self.state = CLOSING
+
+    def send_ping(self, data: bytes) -> None:
+        """
+        Send a `Ping frame`_.
+
+        .. _Ping frame:
+            https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2
+
+        Parameters:
+            data: payload containing arbitrary binary data.
+
+        """
+        self.send_frame(Frame(OP_PING, data))
+
+    def send_pong(self, data: bytes) -> None:
+        """
+        Send a `Pong frame`_.
+
+        .. _Pong frame:
+            https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3
+
+        Parameters:
+            data: payload containing arbitrary binary data.
+
+        """
+        self.send_frame(Frame(OP_PONG, data))
+
+    def fail(self, code: int, reason: str = "") -> None:
+        """
+        `Fail the WebSocket connection`_.
+
+        .. _Fail the WebSocket connection:
+            https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.7
+
+        Parameters:
+            code: close code
+            reason: close reason
+
+        Raises:
+            ProtocolError: if the code isn't valid.
+        """
+        # 7.1.7. Fail the WebSocket Connection
+
+        # Send a close frame when the state is OPEN (a close frame was already
+        # sent if it's CLOSING), except when failing the connection because
+        # of an error reading from or writing to the network.
+        if self.state is OPEN:
+            if code != 1006:
+                close = Close(code, reason)
+                data = close.serialize()
+                self.send_frame(Frame(OP_CLOSE, data))
+                self.close_sent = close
+                self.state = CLOSING
+
+        # When failing the connection, a server closes the TCP connection
+        # without waiting for the client to complete the handshake, while a
+        # client waits for the server to close the TCP connection, possibly
+        # after sending a close frame that the client will ignore.
+        if self.side is SERVER and not self.eof_sent:
+            self.send_eof()
+
+        # 7.1.7. Fail the WebSocket Connection "An endpoint MUST NOT continue
+        # to attempt to process data(including a responding Close frame) from
+        # the remote endpoint after being instructed to _Fail the WebSocket
+        # Connection_."
+        self.parser = self.discard()
+        next(self.parser)  # start coroutine
+
+    # Public method for getting incoming events after receiving data.
+
+    def events_received(self) -> List[Event]:
+        """
+        Fetch events generated from data received from the network.
+
+        Call this method immediately after any of the ``receive_*()`` methods.
+
+        Process resulting events, likely by passing them to the application.
+
+        Returns:
+            List[Event]: Events read from the connection.
+        """
+        events, self.events = self.events, []
+        return events
+
+    # Public method for getting outgoing data after receiving data or sending events.
+
+    def data_to_send(self) -> List[bytes]:
+        """
+        Obtain data to send to the network.
+
+        Call this method immediately after any of the ``receive_*()``,
+        ``send_*()``, or :meth:`fail` methods.
+
+        Write resulting data to the connection.
+
+        The empty bytestring :data:`~websockets.connection.SEND_EOF` signals
+        the end of the data stream. When you receive it, half-close the TCP
+        connection.
+
+        Returns:
+            List[bytes]: Data to write to the connection.
+
+        """
+        writes, self.writes = self.writes, []
+        return writes
+
+    def close_expected(self) -> bool:
+        """
+        Tell if the TCP connection is expected to close soon.
+
+        Call this method immediately after any of the ``receive_*()`` or
+        :meth:`fail` methods.
+
+        If it returns :obj:`True`, schedule closing the TCP connection after a
+        short timeout if the other side hasn't already closed it.
+
+        Returns:
+            bool: Whether the TCP connection is expected to close soon.
+
+        """
+        # We expect a TCP close if and only if we sent a close frame:
+        # * Normal closure: once we send a close frame, we expect a TCP close:
+        #   server waits for client to complete the TCP closing handshake;
+        #   client waits for server to initiate the TCP closing handshake.
+        # * Abnormal closure: we always send a close frame and the same logic
+        #   applies, except on EOFError where we don't send a close frame
+        #   because we already received the TCP close, so we don't expect it.
+        # We already got a TCP Close if and only if the state is CLOSED.
+        return self.state is CLOSING or self.handshake_exc is not None
+
+    # Private methods for receiving data.
+
+    def parse(self) -> Generator[None, None, None]:
+        """
+        Parse incoming data into frames.
+
+        :meth:`receive_data` and :meth:`receive_eof` run this generator
+        coroutine until it needs more data or reaches EOF.
+
+        """
+        try:
+            while True:
+                if (yield from self.reader.at_eof()):
+                    if self.debug:
+                        self.logger.debug("< EOF")
+                    # If the WebSocket connection is closed cleanly, with a
+                    # closing handhshake, recv_frame() substitutes parse()
+                    # with discard(). This branch is reached only when the
+                    # connection isn't closed cleanly.
+                    raise EOFError("unexpected end of stream")
+
+                if self.max_size is None:
+                    max_size = None
+                elif self.cur_size is None:
+                    max_size = self.max_size
+                else:
+                    max_size = self.max_size - self.cur_size
+
+                # During a normal closure, execution ends here on the next
+                # iteration of the loop after receiving a close frame. At
+                # this point, recv_frame() replaced parse() by discard().
+                frame = yield from Frame.parse(
+                    self.reader.read_exact,
+                    mask=self.side is SERVER,
+                    max_size=max_size,
+                    extensions=self.extensions,
+                )
+
+                if self.debug:
+                    self.logger.debug("< %s", frame)
+
+                self.recv_frame(frame)
+
+        except ProtocolError as exc:
+            self.fail(1002, str(exc))
+            self.parser_exc = exc
+
+        except EOFError as exc:
+            self.fail(1006, str(exc))
+            self.parser_exc = exc
+
+        except UnicodeDecodeError as exc:
+            self.fail(1007, f"{exc.reason} at position {exc.start}")
+            self.parser_exc = exc
+
+        except PayloadTooBig as exc:
+            self.fail(1009, str(exc))
+            self.parser_exc = exc
+
+        except Exception as exc:
+            self.logger.error("parser failed", exc_info=True)
+            # Don't include exception details, which may be security-sensitive.
+            self.fail(1011)
+            self.parser_exc = exc
+
+        # During an abnormal closure, execution ends here after catching an
+        # exception. At this point, fail() replaced parse() by discard().
+        yield
+        raise AssertionError("parse() shouldn't step after error")  # pragma: no cover
+
+    def discard(self) -> Generator[None, None, None]:
+        """
+        Discard incoming data.
+
+        This coroutine replaces :meth:`parse`:
+
+        - after receiving a close frame, during a normal closure (1.4);
+        - after sending a close frame, during an abnormal closure (7.1.7).
+
+        """
+        # The server close the TCP connection in the same circumstances where
+        # discard() replaces parse(). The client closes the connection later,
+        # after the server closes the connection or a timeout elapses.
+        # (The latter case cannot be handled in this Sans-I/O layer.)
+        assert (self.side is SERVER) == (self.eof_sent)
+        while not (yield from self.reader.at_eof()):
+            self.reader.discard()
+        if self.debug:
+            self.logger.debug("< EOF")
+        # A server closes the TCP connection immediately, while a client
+        # waits for the server to close the TCP connection.
+        if self.side is CLIENT:
+            self.send_eof()
+        self.state = CLOSED
+        # If discard() completes normally, execution ends here.
+        yield
+        # Once the reader reaches EOF, its feed_data/eof() methods raise an
+        # error, so our receive_data/eof() methods don't step the generator.
+        raise AssertionError("discard() shouldn't step after EOF")  # pragma: no cover
+
+    def recv_frame(self, frame: Frame) -> None:
+        """
+        Process an incoming frame.
+
+        """
+        if frame.opcode is OP_TEXT or frame.opcode is OP_BINARY:
+            if self.cur_size is not None:
+                raise ProtocolError("expected a continuation frame")
+            if frame.fin:
+                self.cur_size = None
+            else:
+                self.cur_size = len(frame.data)
+
+        elif frame.opcode is OP_CONT:
+            if self.cur_size is None:
+                raise ProtocolError("unexpected continuation frame")
+            if frame.fin:
+                self.cur_size = None
+            else:
+                self.cur_size += len(frame.data)
+
+        elif frame.opcode is OP_PING:
+            # 5.5.2. Ping: "Upon receipt of a Ping frame, an endpoint MUST
+            # send a Pong frame in response"
+            pong_frame = Frame(OP_PONG, frame.data)
+            self.send_frame(pong_frame)
+
+        elif frame.opcode is OP_PONG:
+            # 5.5.3 Pong: "A response to an unsolicited Pong frame is not
+            # expected."
+            pass
+
+        elif frame.opcode is OP_CLOSE:
+            # 7.1.5.  The WebSocket Connection Close Code
+            # 7.1.6.  The WebSocket Connection Close Reason
+            self.close_rcvd = Close.parse(frame.data)
+            if self.state is CLOSING:
+                assert self.close_sent is not None
+                self.close_rcvd_then_sent = False
+
+            if self.cur_size is not None:
+                raise ProtocolError("incomplete fragmented message")
+
+            # 5.5.1 Close: "If an endpoint receives a Close frame and did
+            # not previously send a Close frame, the endpoint MUST send a
+            # Close frame in response. (When sending a Close frame in
+            # response, the endpoint typically echos the status code it
+            # received.)"
+
+            if self.state is OPEN:
+                # Echo the original data instead of re-serializing it with
+                # Close.serialize() because that fails when the close frame
+                # is empty and Close.parse() synthetizes a 1005 close code.
+                # The rest is identical to send_close().
+                self.send_frame(Frame(OP_CLOSE, frame.data))
+                self.close_sent = self.close_rcvd
+                self.close_rcvd_then_sent = True
+                self.state = CLOSING
+
+            # 7.1.2. Start the WebSocket Closing Handshake: "Once an
+            # endpoint has both sent and received a Close control frame,
+            # that endpoint SHOULD _Close the WebSocket Connection_"
+
+            # A server closes the TCP connection immediately, while a client
+            # waits for the server to close the TCP connection.
+            if self.side is SERVER:
+                self.send_eof()
+
+            # 1.4. Closing Handshake: "after receiving a control frame
+            # indicating the connection should be closed, a peer discards
+            # any further data received."
+            self.parser = self.discard()
+            next(self.parser)  # start coroutine
+
+        else:  # pragma: no cover
+            # This can't happen because Frame.parse() validates opcodes.
+            raise AssertionError(f"unexpected opcode: {frame.opcode:02x}")
+
+        self.events.append(frame)
+
+    # Private methods for sending events.
+
+    def send_frame(self, frame: Frame) -> None:
+        if self.state is not OPEN:
+            raise InvalidState(
+                f"cannot write to a WebSocket in the {self.state.name} state"
+            )
+
+        if self.debug:
+            self.logger.debug("> %s", frame)
+        self.writes.append(
+            frame.serialize(mask=self.side is CLIENT, extensions=self.extensions)
+        )
+
+    def send_eof(self) -> None:
+        assert not self.eof_sent
+        self.eof_sent = True
+        if self.debug:
+            self.logger.debug("> EOF")
+        self.writes.append(SEND_EOF)
diff --git a/myenv/lib/python3.9/site-packages/websockets/datastructures.py b/myenv/lib/python3.9/site-packages/websockets/datastructures.py
new file mode 100644
index 0000000..36a2cba
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/datastructures.py
@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import sys
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    MutableMapping,
+    Tuple,
+    Union,
+)
+
+
+if sys.version_info[:2] >= (3, 8):
+    from typing import Protocol
+else:  # pragma: no cover
+    Protocol = object  # mypy will report errors on Python 3.7.
+
+
+__all__ = ["Headers", "HeadersLike", "MultipleValuesError"]
+
+
+class MultipleValuesError(LookupError):
+    """
+    Exception raised when :class:`Headers` has more than one value for a key.
+
+    """
+
+    def __str__(self) -> str:
+        # Implement the same logic as KeyError_str in Objects/exceptions.c.
+        if len(self.args) == 1:
+            return repr(self.args[0])
+        return super().__str__()
+
+
+class Headers(MutableMapping[str, str]):
+    """
+    Efficient data structure for manipulating HTTP headers.
+
+    A :class:`list` of ``(name, values)`` is inefficient for lookups.
+
+    A :class:`dict` doesn't suffice because header names are case-insensitive
+    and multiple occurrences of headers with the same name are possible.
+
+    :class:`Headers` stores HTTP headers in a hybrid data structure to provide
+    efficient insertions and lookups while preserving the original data.
+
+    In order to account for multiple values with minimal hassle,
+    :class:`Headers` follows this logic:
+
+    - When getting a header with ``headers[name]``:
+        - if there's no value, :exc:`KeyError` is raised;
+        - if there's exactly one value, it's returned;
+        - if there's more than one value, :exc:`MultipleValuesError` is raised.
+
+    - When setting a header with ``headers[name] = value``, the value is
+      appended to the list of values for that header.
+
+    - When deleting a header with ``del headers[name]``, all values for that
+      header are removed (this is slow).
+
+    Other methods for manipulating headers are consistent with this logic.
+
+    As long as no header occurs multiple times, :class:`Headers` behaves like
+    :class:`dict`, except keys are lower-cased to provide case-insensitivity.
+
+    Two methods support manipulating multiple values explicitly:
+
+    - :meth:`get_all` returns a list of all values for a header;
+    - :meth:`raw_items` returns an iterator of ``(name, values)`` pairs.
+
+    """
+
+    __slots__ = ["_dict", "_list"]
+
+    # Like dict, Headers accepts an optional "mapping or iterable" argument.
+    def __init__(self, *args: HeadersLike, **kwargs: str) -> None:
+        self._dict: Dict[str, List[str]] = {}
+        self._list: List[Tuple[str, str]] = []
+        self.update(*args, **kwargs)
+
+    def __str__(self) -> str:
+        return "".join(f"{key}: {value}\r\n" for key, value in self._list) + "\r\n"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self._list!r})"
+
+    def copy(self) -> Headers:
+        copy = self.__class__()
+        copy._dict = self._dict.copy()
+        copy._list = self._list.copy()
+        return copy
+
+    def serialize(self) -> bytes:
+        # Since headers only contain ASCII characters, we can keep this simple.
+        return str(self).encode()
+
+    # Collection methods
+
+    def __contains__(self, key: object) -> bool:
+        return isinstance(key, str) and key.lower() in self._dict
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._dict)
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    # MutableMapping methods
+
+    def __getitem__(self, key: str) -> str:
+        value = self._dict[key.lower()]
+        if len(value) == 1:
+            return value[0]
+        else:
+            raise MultipleValuesError(key)
+
+    def __setitem__(self, key: str, value: str) -> None:
+        self._dict.setdefault(key.lower(), []).append(value)
+        self._list.append((key, value))
+
+    def __delitem__(self, key: str) -> None:
+        key_lower = key.lower()
+        self._dict.__delitem__(key_lower)
+        # This is inefficient. Fortunately deleting HTTP headers is uncommon.
+        self._list = [(k, v) for k, v in self._list if k.lower() != key_lower]
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Headers):
+            return NotImplemented
+        return self._dict == other._dict
+
+    def clear(self) -> None:
+        """
+        Remove all headers.
+
+        """
+        self._dict = {}
+        self._list = []
+
+    def update(self, *args: HeadersLike, **kwargs: str) -> None:
+        """
+        Update from a :class:`Headers` instance and/or keyword arguments.
+
+        """
+        args = tuple(
+            arg.raw_items() if isinstance(arg, Headers) else arg for arg in args
+        )
+        super().update(*args, **kwargs)
+
+    # Methods for handling multiple values
+
+    def get_all(self, key: str) -> List[str]:
+        """
+        Return the (possibly empty) list of all values for a header.
+
+        Args:
+            key: header name.
+
+        """
+        return self._dict.get(key.lower(), [])
+
+    def raw_items(self) -> Iterator[Tuple[str, str]]:
+        """
+        Return an iterator of all values as ``(name, value)`` pairs.
+
+        """
+        return iter(self._list)
+
+
+# copy of _typeshed.SupportsKeysAndGetItem.
+class SupportsKeysAndGetItem(Protocol):  # pragma: no cover
+    """
+    Dict-like types with ``keys() -> str`` and ``__getitem__(key: str) -> str`` methods.
+
+    """
+
+    def keys(self) -> Iterable[str]:
+        ...
+
+    def __getitem__(self, key: str) -> str:
+        ...
+
+
+HeadersLike = Union[
+    Headers,
+    Mapping[str, str],
+    Iterable[Tuple[str, str]],
+    SupportsKeysAndGetItem,
+]
+"""
+Types accepted where :class:`Headers` is expected.
+
+In addition to :class:`Headers` itself, this includes dict-like types where both
+keys and values are :class:`str`.
+
+"""
diff --git a/myenv/lib/python3.9/site-packages/websockets/exceptions.py b/myenv/lib/python3.9/site-packages/websockets/exceptions.py
new file mode 100644
index 0000000..0c4fc51
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/exceptions.py
@@ -0,0 +1,398 @@
+"""
+:mod:`websockets.exceptions` defines the following exception hierarchy:
+
+* :exc:`WebSocketException`
+    * :exc:`ConnectionClosed`
+        * :exc:`ConnectionClosedError`
+        * :exc:`ConnectionClosedOK`
+    * :exc:`InvalidHandshake`
+        * :exc:`SecurityError`
+        * :exc:`InvalidMessage`
+        * :exc:`InvalidHeader`
+            * :exc:`InvalidHeaderFormat`
+            * :exc:`InvalidHeaderValue`
+            * :exc:`InvalidOrigin`
+            * :exc:`InvalidUpgrade`
+        * :exc:`InvalidStatus`
+        * :exc:`InvalidStatusCode` (legacy)
+        * :exc:`NegotiationError`
+            * :exc:`DuplicateParameter`
+            * :exc:`InvalidParameterName`
+            * :exc:`InvalidParameterValue`
+        * :exc:`AbortHandshake`
+        * :exc:`RedirectHandshake`
+    * :exc:`InvalidState`
+    * :exc:`InvalidURI`
+    * :exc:`PayloadTooBig`
+    * :exc:`ProtocolError`
+
+"""
+
+from __future__ import annotations
+
+import http
+from typing import Optional
+
+from . import datastructures, frames, http11
+
+
+__all__ = [
+    "WebSocketException",
+    "ConnectionClosed",
+    "ConnectionClosedError",
+    "ConnectionClosedOK",
+    "InvalidHandshake",
+    "SecurityError",
+    "InvalidMessage",
+    "InvalidHeader",
+    "InvalidHeaderFormat",
+    "InvalidHeaderValue",
+    "InvalidOrigin",
+    "InvalidUpgrade",
+    "InvalidStatus",
+    "InvalidStatusCode",
+    "NegotiationError",
+    "DuplicateParameter",
+    "InvalidParameterName",
+    "InvalidParameterValue",
+    "AbortHandshake",
+    "RedirectHandshake",
+    "InvalidState",
+    "InvalidURI",
+    "PayloadTooBig",
+    "ProtocolError",
+    "WebSocketProtocolError",
+]
+
+
+class WebSocketException(Exception):
+    """
+    Base class for all exceptions defined by websockets.
+
+    """
+
+
+class ConnectionClosed(WebSocketException):
+    """
+    Raised when trying to interact with a closed connection.
+
+    Attributes:
+        rcvd (Optional[Close]): if a close frame was received, its code and
+            reason are available in ``rcvd.code`` and ``rcvd.reason``.
+        sent (Optional[Close]): if a close frame was sent, its code and reason
+            are available in ``sent.code`` and ``sent.reason``.
+        rcvd_then_sent (Optional[bool]): if close frames were received and
+            sent, this attribute tells in which order this happened, from the
+            perspective of this side of the connection.
+
+    """
+
+    def __init__(
+        self,
+        rcvd: Optional[frames.Close],
+        sent: Optional[frames.Close],
+        rcvd_then_sent: Optional[bool] = None,
+    ) -> None:
+        self.rcvd = rcvd
+        self.sent = sent
+        self.rcvd_then_sent = rcvd_then_sent
+
+    def __str__(self) -> str:
+        if self.rcvd is None:
+            if self.sent is None:
+                assert self.rcvd_then_sent is None
+                return "no close frame received or sent"
+            else:
+                assert self.rcvd_then_sent is None
+                return f"sent {self.sent}; no close frame received"
+        else:
+            if self.sent is None:
+                assert self.rcvd_then_sent is None
+                return f"received {self.rcvd}; no close frame sent"
+            else:
+                assert self.rcvd_then_sent is not None
+                if self.rcvd_then_sent:
+                    return f"received {self.rcvd}; then sent {self.sent}"
+                else:
+                    return f"sent {self.sent}; then received {self.rcvd}"
+
+    # code and reason attributes are provided for backwards-compatibility
+
+    @property
+    def code(self) -> int:
+        return 1006 if self.rcvd is None else self.rcvd.code
+
+    @property
+    def reason(self) -> str:
+        return "" if self.rcvd is None else self.rcvd.reason
+
+
+class ConnectionClosedError(ConnectionClosed):
+    """
+    Like :exc:`ConnectionClosed`, when the connection terminated with an error.
+
+    A close code other than 1000 (OK) or 1001 (going away) was received or
+    sent, or the closing handshake didn't complete properly.
+
+    """
+
+
+class ConnectionClosedOK(ConnectionClosed):
+    """
+    Like :exc:`ConnectionClosed`, when the connection terminated properly.
+
+    A close code 1000 (OK) or 1001 (going away) was received and sent.
+
+    """
+
+
+class InvalidHandshake(WebSocketException):
+    """
+    Raised during the handshake when the WebSocket connection fails.
+
+    """
+
+
+class SecurityError(InvalidHandshake):
+    """
+    Raised when a handshake request or response breaks a security rule.
+
+    Security limits are hard coded.
+
+    """
+
+
+class InvalidMessage(InvalidHandshake):
+    """
+    Raised when a handshake request or response is malformed.
+
+    """
+
+
+class InvalidHeader(InvalidHandshake):
+    """
+    Raised when a HTTP header doesn't have a valid format or value.
+
+    """
+
+    def __init__(self, name: str, value: Optional[str] = None) -> None:
+        self.name = name
+        self.value = value
+
+    def __str__(self) -> str:
+        if self.value is None:
+            return f"missing {self.name} header"
+        elif self.value == "":
+            return f"empty {self.name} header"
+        else:
+            return f"invalid {self.name} header: {self.value}"
+
+
+class InvalidHeaderFormat(InvalidHeader):
+    """
+    Raised when a HTTP header cannot be parsed.
+
+    The format of the header doesn't match the grammar for that header.
+
+    """
+
+    def __init__(self, name: str, error: str, header: str, pos: int) -> None:
+        super().__init__(name, f"{error} at {pos} in {header}")
+
+
+class InvalidHeaderValue(InvalidHeader):
+    """
+    Raised when a HTTP header has a wrong value.
+
+    The format of the header is correct but a value isn't acceptable.
+
+    """
+
+
+class InvalidOrigin(InvalidHeader):
+    """
+    Raised when the Origin header in a request isn't allowed.
+
+    """
+
+    def __init__(self, origin: Optional[str]) -> None:
+        super().__init__("Origin", origin)
+
+
+class InvalidUpgrade(InvalidHeader):
+    """
+    Raised when the Upgrade or Connection header isn't correct.
+
+    """
+
+
+class InvalidStatus(InvalidHandshake):
+    """
+    Raised when a handshake response rejects the WebSocket upgrade.
+
+    """
+
+    def __init__(self, response: http11.Response) -> None:
+        self.response = response
+
+    def __str__(self) -> str:
+        return (
+            "server rejected WebSocket connection: "
+            f"HTTP {self.response.status_code:d}"
+        )
+
+
+class InvalidStatusCode(InvalidHandshake):
+    """
+    Raised when a handshake response status code is invalid.
+
+    """
+
+    def __init__(self, status_code: int, headers: datastructures.Headers) -> None:
+        self.status_code = status_code
+        self.headers = headers
+
+    def __str__(self) -> str:
+        return f"server rejected WebSocket connection: HTTP {self.status_code}"
+
+
+class NegotiationError(InvalidHandshake):
+    """
+    Raised when negotiating an extension fails.
+
+    """
+
+
+class DuplicateParameter(NegotiationError):
+    """
+    Raised when a parameter name is repeated in an extension header.
+
+    """
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def __str__(self) -> str:
+        return f"duplicate parameter: {self.name}"
+
+
+class InvalidParameterName(NegotiationError):
+    """
+    Raised when a parameter name in an extension header is invalid.
+
+    """
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def __str__(self) -> str:
+        return f"invalid parameter name: {self.name}"
+
+
+class InvalidParameterValue(NegotiationError):
+    """
+    Raised when a parameter value in an extension header is invalid.
+
+    """
+
+    def __init__(self, name: str, value: Optional[str]) -> None:
+        self.name = name
+        self.value = value
+
+    def __str__(self) -> str:
+        if self.value is None:
+            return f"missing value for parameter {self.name}"
+        elif self.value == "":
+            return f"empty value for parameter {self.name}"
+        else:
+            return f"invalid value for parameter {self.name}: {self.value}"
+
+
+class AbortHandshake(InvalidHandshake):
+    """
+    Raised to abort the handshake on purpose and return a HTTP response.
+
+    This exception is an implementation detail.
+
+    The public API
+    is :meth:`~websockets.server.WebSocketServerProtocol.process_request`.
+
+    Attributes:
+        status (~http.HTTPStatus): HTTP status code.
+        headers (Headers): HTTP response headers.
+        body (bytes): HTTP response body.
+    """
+
+    def __init__(
+        self,
+        status: http.HTTPStatus,
+        headers: datastructures.HeadersLike,
+        body: bytes = b"",
+    ) -> None:
+        self.status = status
+        self.headers = datastructures.Headers(headers)
+        self.body = body
+
+    def __str__(self) -> str:
+        return (
+            f"HTTP {self.status:d}, "
+            f"{len(self.headers)} headers, "
+            f"{len(self.body)} bytes"
+        )
+
+
+class RedirectHandshake(InvalidHandshake):
+    """
+    Raised when a handshake gets redirected.
+
+    This exception is an implementation detail.
+
+    """
+
+    def __init__(self, uri: str) -> None:
+        self.uri = uri
+
+    def __str__(self) -> str:
+        return f"redirect to {self.uri}"
+
+
+class InvalidState(WebSocketException, AssertionError):
+    """
+    Raised when an operation is forbidden in the current state.
+
+    This exception is an implementation detail.
+
+    It should never be raised in normal circumstances.
+
+    """
+
+
+class InvalidURI(WebSocketException):
+    """
+    Raised when connecting to an URI that isn't a valid WebSocket URI.
+
+    """
+
+    def __init__(self, uri: str, msg: str) -> None:
+        self.uri = uri
+        self.msg = msg
+
+    def __str__(self) -> str:
+        return f"{self.uri} isn't a valid URI: {self.msg}"
+
+
+class PayloadTooBig(WebSocketException):
+    """
+    Raised when receiving a frame with a payload exceeding the maximum size.
+
+    """
+
+
+class ProtocolError(WebSocketException):
+    """
+    Raised when a frame breaks the protocol.
+
+    """
+
+
+WebSocketProtocolError = ProtocolError  # for backwards compatibility
diff --git a/myenv/lib/python3.9/site-packages/websockets/extensions/__init__.py b/myenv/lib/python3.9/site-packages/websockets/extensions/__init__.py
new file mode 100644
index 0000000..02838b9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/extensions/__init__.py
@@ -0,0 +1,4 @@
+from .base import *
+
+
+__all__ = ["Extension", "ClientExtensionFactory", "ServerExtensionFactory"]
diff --git a/myenv/lib/python3.9/site-packages/websockets/extensions/base.py b/myenv/lib/python3.9/site-packages/websockets/extensions/base.py
new file mode 100644
index 0000000..0609676
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/extensions/base.py
@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from typing import List, Optional, Sequence, Tuple
+
+from .. import frames
+from ..typing import ExtensionName, ExtensionParameter
+
+
+__all__ = ["Extension", "ClientExtensionFactory", "ServerExtensionFactory"]
+
+
+class Extension:
+    """
+    Base class for extensions.
+
+    """
+
+    name: ExtensionName
+    """Extension identifier."""
+
+    def decode(
+        self,
+        frame: frames.Frame,
+        *,
+        max_size: Optional[int] = None,
+    ) -> frames.Frame:
+        """
+        Decode an incoming frame.
+
+        Args:
+            frame (Frame): incoming frame.
+            max_size: maximum payload size in bytes.
+
+        Returns:
+            Frame: Decoded frame.
+
+        Raises:
+            PayloadTooBig: if decoding the payload exceeds ``max_size``.
+
+        """
+
+    def encode(self, frame: frames.Frame) -> frames.Frame:
+        """
+        Encode an outgoing frame.
+
+        Args:
+            frame (Frame): outgoing frame.
+
+        Returns:
+            Frame: Encoded frame.
+
+        """
+
+
+class ClientExtensionFactory:
+    """
+    Base class for client-side extension factories.
+
+    """
+
+    name: ExtensionName
+    """Extension identifier."""
+
+    def get_request_params(self) -> List[ExtensionParameter]:
+        """
+        Build parameters to send to the server for this extension.
+
+        Returns:
+            List[ExtensionParameter]: Parameters to send to the server.
+
+        """
+
+    def process_response_params(
+        self,
+        params: Sequence[ExtensionParameter],
+        accepted_extensions: Sequence[Extension],
+    ) -> Extension:
+        """
+        Process parameters received from the server.
+
+        Args:
+            params (Sequence[ExtensionParameter]): parameters received from
+                the server for this extension.
+            accepted_extensions (Sequence[Extension]): list of previously
+                accepted extensions.
+
+        Returns:
+            Extension: An extension instance.
+
+        Raises:
+            NegotiationError: if parameters aren't acceptable.
+
+        """
+
+
+class ServerExtensionFactory:
+    """
+    Base class for server-side extension factories.
+
+    """
+
+    name: ExtensionName
+    """Extension identifier."""
+
+    def process_request_params(
+        self,
+        params: Sequence[ExtensionParameter],
+        accepted_extensions: Sequence[Extension],
+    ) -> Tuple[List[ExtensionParameter], Extension]:
+        """
+        Process parameters received from the client.
+
+        Args:
+            params (Sequence[ExtensionParameter]): parameters received from
+                the client for this extension.
+            accepted_extensions (Sequence[Extension]): list of previously
+                accepted extensions.
+
+        Returns:
+            Tuple[List[ExtensionParameter], Extension]: To accept the offer,
+            parameters to send to the client for this extension and an
+            extension instance.
+
+        Raises:
+            NegotiationError: to reject the offer, if parameters received from
+                the client aren't acceptable.
+
+        """
diff --git a/myenv/lib/python3.9/site-packages/websockets/extensions/permessage_deflate.py b/myenv/lib/python3.9/site-packages/websockets/extensions/permessage_deflate.py
new file mode 100644
index 0000000..e0de5e8
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/extensions/permessage_deflate.py
@@ -0,0 +1,661 @@
+from __future__ import annotations
+
+import dataclasses
+import zlib
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+from .. import exceptions, frames
+from ..typing import ExtensionName, ExtensionParameter
+from .base import ClientExtensionFactory, Extension, ServerExtensionFactory
+
+
+__all__ = [
+    "PerMessageDeflate",
+    "ClientPerMessageDeflateFactory",
+    "enable_client_permessage_deflate",
+    "ServerPerMessageDeflateFactory",
+    "enable_server_permessage_deflate",
+]
+
+_EMPTY_UNCOMPRESSED_BLOCK = b"\x00\x00\xff\xff"
+
+_MAX_WINDOW_BITS_VALUES = [str(bits) for bits in range(8, 16)]
+
+
+class PerMessageDeflate(Extension):
+    """
+    Per-Message Deflate extension.
+
+    """
+
+    name = ExtensionName("permessage-deflate")
+
+    def __init__(
+        self,
+        remote_no_context_takeover: bool,
+        local_no_context_takeover: bool,
+        remote_max_window_bits: int,
+        local_max_window_bits: int,
+        compress_settings: Optional[Dict[Any, Any]] = None,
+    ) -> None:
+        """
+        Configure the Per-Message Deflate extension.
+
+        """
+        if compress_settings is None:
+            compress_settings = {}
+
+        assert remote_no_context_takeover in [False, True]
+        assert local_no_context_takeover in [False, True]
+        assert 8 <= remote_max_window_bits <= 15
+        assert 8 <= local_max_window_bits <= 15
+        assert "wbits" not in compress_settings
+
+        self.remote_no_context_takeover = remote_no_context_takeover
+        self.local_no_context_takeover = local_no_context_takeover
+        self.remote_max_window_bits = remote_max_window_bits
+        self.local_max_window_bits = local_max_window_bits
+        self.compress_settings = compress_settings
+
+        if not self.remote_no_context_takeover:
+            self.decoder = zlib.decompressobj(wbits=-self.remote_max_window_bits)
+
+        if not self.local_no_context_takeover:
+            self.encoder = zlib.compressobj(
+                wbits=-self.local_max_window_bits, **self.compress_settings
+            )
+
+        # To handle continuation frames properly, we must keep track of
+        # whether that initial frame was encoded.
+        self.decode_cont_data = False
+        # There's no need for self.encode_cont_data because we always encode
+        # outgoing frames, so it would always be True.
+
+    def __repr__(self) -> str:
+        return (
+            f"PerMessageDeflate("
+            f"remote_no_context_takeover={self.remote_no_context_takeover}, "
+            f"local_no_context_takeover={self.local_no_context_takeover}, "
+            f"remote_max_window_bits={self.remote_max_window_bits}, "
+            f"local_max_window_bits={self.local_max_window_bits})"
+        )
+
+    def decode(
+        self,
+        frame: frames.Frame,
+        *,
+        max_size: Optional[int] = None,
+    ) -> frames.Frame:
+        """
+        Decode an incoming frame.
+
+        """
+        # Skip control frames.
+        if frame.opcode in frames.CTRL_OPCODES:
+            return frame
+
+        # Handle continuation data frames:
+        # - skip if the message isn't encoded
+        # - reset "decode continuation data" flag if it's a final frame
+        if frame.opcode is frames.OP_CONT:
+            if not self.decode_cont_data:
+                return frame
+            if frame.fin:
+                self.decode_cont_data = False
+
+        # Handle text and binary data frames:
+        # - skip if the message isn't encoded
+        # - unset the rsv1 flag on the first frame of a compressed message
+        # - set "decode continuation data" flag if it's a non-final frame
+        else:
+            if not frame.rsv1:
+                return frame
+            frame = dataclasses.replace(frame, rsv1=False)
+            if not frame.fin:
+                self.decode_cont_data = True
+
+            # Re-initialize per-message decoder.
+            if self.remote_no_context_takeover:
+                self.decoder = zlib.decompressobj(wbits=-self.remote_max_window_bits)
+
+        # Uncompress data. Protect against zip bombs by preventing zlib from
+        # decompressing more than max_length bytes (except when the limit is
+        # disabled with max_size = None).
+        data = frame.data
+        if frame.fin:
+            data += _EMPTY_UNCOMPRESSED_BLOCK
+        max_length = 0 if max_size is None else max_size
+        try:
+            data = self.decoder.decompress(data, max_length)
+        except zlib.error as exc:
+            raise exceptions.ProtocolError("decompression failed") from exc
+        if self.decoder.unconsumed_tail:
+            raise exceptions.PayloadTooBig(f"over size limit (? > {max_size} bytes)")
+
+        # Allow garbage collection of the decoder if it won't be reused.
+        if frame.fin and self.remote_no_context_takeover:
+            del self.decoder
+
+        return dataclasses.replace(frame, data=data)
+
+    def encode(self, frame: frames.Frame) -> frames.Frame:
+        """
+        Encode an outgoing frame.
+
+        """
+        # Skip control frames.
+        if frame.opcode in frames.CTRL_OPCODES:
+            return frame
+
+        # Since we always encode messages, there's no "encode continuation
+        # data" flag similar to "decode continuation data" at this time.
+
+        if frame.opcode is not frames.OP_CONT:
+            # Set the rsv1 flag on the first frame of a compressed message.
+            frame = dataclasses.replace(frame, rsv1=True)
+            # Re-initialize per-message decoder.
+            if self.local_no_context_takeover:
+                self.encoder = zlib.compressobj(
+                    wbits=-self.local_max_window_bits, **self.compress_settings
+                )
+
+        # Compress data.
+        data = self.encoder.compress(frame.data) + self.encoder.flush(zlib.Z_SYNC_FLUSH)
+        if frame.fin and data.endswith(_EMPTY_UNCOMPRESSED_BLOCK):
+            data = data[:-4]
+
+        # Allow garbage collection of the encoder if it won't be reused.
+        if frame.fin and self.local_no_context_takeover:
+            del self.encoder
+
+        return dataclasses.replace(frame, data=data)
+
+
+def _build_parameters(
+    server_no_context_takeover: bool,
+    client_no_context_takeover: bool,
+    server_max_window_bits: Optional[int],
+    client_max_window_bits: Optional[Union[int, bool]],
+) -> List[ExtensionParameter]:
+    """
+    Build a list of ``(name, value)`` pairs for some compression parameters.
+
+    """
+    params: List[ExtensionParameter] = []
+    if server_no_context_takeover:
+        params.append(("server_no_context_takeover", None))
+    if client_no_context_takeover:
+        params.append(("client_no_context_takeover", None))
+    if server_max_window_bits:
+        params.append(("server_max_window_bits", str(server_max_window_bits)))
+    if client_max_window_bits is True:  # only in handshake requests
+        params.append(("client_max_window_bits", None))
+    elif client_max_window_bits:
+        params.append(("client_max_window_bits", str(client_max_window_bits)))
+    return params
+
+
+def _extract_parameters(
+    params: Sequence[ExtensionParameter], *, is_server: bool
+) -> Tuple[bool, bool, Optional[int], Optional[Union[int, bool]]]:
+    """
+    Extract compression parameters from a list of ``(name, value)`` pairs.
+
+    If ``is_server`` is :obj:`True`, ``client_max_window_bits`` may be
+    provided without a value. This is only allowed in handshake requests.
+
+    """
+    server_no_context_takeover: bool = False
+    client_no_context_takeover: bool = False
+    server_max_window_bits: Optional[int] = None
+    client_max_window_bits: Optional[Union[int, bool]] = None
+
+    for name, value in params:
+
+        if name == "server_no_context_takeover":
+            if server_no_context_takeover:
+                raise exceptions.DuplicateParameter(name)
+            if value is None:
+                server_no_context_takeover = True
+            else:
+                raise exceptions.InvalidParameterValue(name, value)
+
+        elif name == "client_no_context_takeover":
+            if client_no_context_takeover:
+                raise exceptions.DuplicateParameter(name)
+            if value is None:
+                client_no_context_takeover = True
+            else:
+                raise exceptions.InvalidParameterValue(name, value)
+
+        elif name == "server_max_window_bits":
+            if server_max_window_bits is not None:
+                raise exceptions.DuplicateParameter(name)
+            if value in _MAX_WINDOW_BITS_VALUES:
+                server_max_window_bits = int(value)
+            else:
+                raise exceptions.InvalidParameterValue(name, value)
+
+        elif name == "client_max_window_bits":
+            if client_max_window_bits is not None:
+                raise exceptions.DuplicateParameter(name)
+            if is_server and value is None:  # only in handshake requests
+                client_max_window_bits = True
+            elif value in _MAX_WINDOW_BITS_VALUES:
+                client_max_window_bits = int(value)
+            else:
+                raise exceptions.InvalidParameterValue(name, value)
+
+        else:
+            raise exceptions.InvalidParameterName(name)
+
+    return (
+        server_no_context_takeover,
+        client_no_context_takeover,
+        server_max_window_bits,
+        client_max_window_bits,
+    )
+
+
+class ClientPerMessageDeflateFactory(ClientExtensionFactory):
+    """
+    Client-side extension factory for the Per-Message Deflate extension.
+
+    Parameters behave as described in `section 7.1 of RFC 7692`_.
+
+    .. _section 7.1 of RFC 7692: https://www.rfc-editor.org/rfc/rfc7692.html#section-7.1
+
+    Set them to :obj:`True` to include them in the negotiation offer without a
+    value or to an integer value to include them with this value.
+
+    Args:
+        server_no_context_takeover: prevent server from using context takeover.
+        client_no_context_takeover: prevent client from using context takeover.
+        server_max_window_bits: maximum size of the server's LZ77 sliding window
+            in bits, between 8 and 15.
+        client_max_window_bits: maximum size of the client's LZ77 sliding window
+            in bits, between 8 and 15, or :obj:`True` to indicate support without
+            setting a limit.
+        compress_settings: additional keyword arguments for :func:`zlib.compressobj`,
+            excluding ``wbits``.
+
+    """
+
+    name = ExtensionName("permessage-deflate")
+
+    def __init__(
+        self,
+        server_no_context_takeover: bool = False,
+        client_no_context_takeover: bool = False,
+        server_max_window_bits: Optional[int] = None,
+        client_max_window_bits: Optional[Union[int, bool]] = True,
+        compress_settings: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """
+        Configure the Per-Message Deflate extension factory.
+
+        """
+        if not (server_max_window_bits is None or 8 <= server_max_window_bits <= 15):
+            raise ValueError("server_max_window_bits must be between 8 and 15")
+        if not (
+            client_max_window_bits is None
+            or client_max_window_bits is True
+            or 8 <= client_max_window_bits <= 15
+        ):
+            raise ValueError("client_max_window_bits must be between 8 and 15")
+        if compress_settings is not None and "wbits" in compress_settings:
+            raise ValueError(
+                "compress_settings must not include wbits, "
+                "set client_max_window_bits instead"
+            )
+
+        self.server_no_context_takeover = server_no_context_takeover
+        self.client_no_context_takeover = client_no_context_takeover
+        self.server_max_window_bits = server_max_window_bits
+        self.client_max_window_bits = client_max_window_bits
+        self.compress_settings = compress_settings
+
+    def get_request_params(self) -> List[ExtensionParameter]:
+        """
+        Build request parameters.
+
+        """
+        return _build_parameters(
+            self.server_no_context_takeover,
+            self.client_no_context_takeover,
+            self.server_max_window_bits,
+            self.client_max_window_bits,
+        )
+
+    def process_response_params(
+        self,
+        params: Sequence[ExtensionParameter],
+        accepted_extensions: Sequence[Extension],
+    ) -> PerMessageDeflate:
+        """
+        Process response parameters.
+
+        Return an extension instance.
+
+        """
+        if any(other.name == self.name for other in accepted_extensions):
+            raise exceptions.NegotiationError(f"received duplicate {self.name}")
+
+        # Request parameters are available in instance variables.
+
+        # Load response parameters in local variables.
+        (
+            server_no_context_takeover,
+            client_no_context_takeover,
+            server_max_window_bits,
+            client_max_window_bits,
+        ) = _extract_parameters(params, is_server=False)
+
+        # After comparing the request and the response, the final
+        # configuration must be available in the local variables.
+
+        # server_no_context_takeover
+        #
+        #   Req.    Resp.   Result
+        #   ------  ------  --------------------------------------------------
+        #   False   False   False
+        #   False   True    True
+        #   True    False   Error!
+        #   True    True    True
+
+        if self.server_no_context_takeover:
+            if not server_no_context_takeover:
+                raise exceptions.NegotiationError("expected server_no_context_takeover")
+
+        # client_no_context_takeover
+        #
+        #   Req.    Resp.   Result
+        #   ------  ------  --------------------------------------------------
+        #   False   False   False
+        #   False   True    True
+        #   True    False   True - must change value
+        #   True    True    True
+
+        if self.client_no_context_takeover:
+            if not client_no_context_takeover:
+                client_no_context_takeover = True
+
+        # server_max_window_bits
+
+        #   Req.    Resp.   Result
+        #   ------  ------  --------------------------------------------------
+        #   None    None    None
+        #   None    8≤M≤15  M
+        #   8≤N≤15  None    Error!
+        #   8≤N≤15  8≤M≤N   M
+        #   8≤N≤15  N<M≤15  Error!
+
+        if self.server_max_window_bits is None:
+            pass
+
+        else:
+            if server_max_window_bits is None:
+                raise exceptions.NegotiationError("expected server_max_window_bits")
+            elif server_max_window_bits > self.server_max_window_bits:
+                raise exceptions.NegotiationError("unsupported server_max_window_bits")
+
+        # client_max_window_bits
+
+        #   Req.    Resp.   Result
+        #   ------  ------  --------------------------------------------------
+        #   None    None    None
+        #   None    8≤M≤15  Error!
+        #   True    None    None
+        #   True    8≤M≤15  M
+        #   8≤N≤15  None    N - must change value
+        #   8≤N≤15  8≤M≤N   M
+        #   8≤N≤15  N<M≤15  Error!
+
+        if self.client_max_window_bits is None:
+            if client_max_window_bits is not None:
+                raise exceptions.NegotiationError("unexpected client_max_window_bits")
+
+        elif self.client_max_window_bits is True:
+            pass
+
+        else:
+            if client_max_window_bits is None:
+                client_max_window_bits = self.client_max_window_bits
+            elif client_max_window_bits > self.client_max_window_bits:
+                raise exceptions.NegotiationError("unsupported client_max_window_bits")
+
+        return PerMessageDeflate(
+            server_no_context_takeover,  # remote_no_context_takeover
+            client_no_context_takeover,  # local_no_context_takeover
+            server_max_window_bits or 15,  # remote_max_window_bits
+            client_max_window_bits or 15,  # local_max_window_bits
+            self.compress_settings,
+        )
+
+
+def enable_client_permessage_deflate(
+    extensions: Optional[Sequence[ClientExtensionFactory]],
+) -> Sequence[ClientExtensionFactory]:
+    """
+    Enable Per-Message Deflate with default settings in client extensions.
+
+    If the extension is already present, perhaps with non-default settings,
+    the configuration isn't changed.
+
+    """
+    if extensions is None:
+        extensions = []
+    if not any(
+        extension_factory.name == ClientPerMessageDeflateFactory.name
+        for extension_factory in extensions
+    ):
+        extensions = list(extensions) + [
+            ClientPerMessageDeflateFactory(
+                compress_settings={"memLevel": 5},
+            )
+        ]
+    return extensions
+
+
+class ServerPerMessageDeflateFactory(ServerExtensionFactory):
+    """
+    Server-side extension factory for the Per-Message Deflate extension.
+
+    Parameters behave as described in `section 7.1 of RFC 7692`_.
+
+    .. _section 7.1 of RFC 7692: https://www.rfc-editor.org/rfc/rfc7692.html#section-7.1
+
+    Set them to :obj:`True` to include them in the negotiation offer without a
+    value or to an integer value to include them with this value.
+
+    Args:
+        server_no_context_takeover: prevent server from using context takeover.
+        client_no_context_takeover: prevent client from using context takeover.
+        server_max_window_bits: maximum size of the server's LZ77 sliding window
+            in bits, between 8 and 15.
+        client_max_window_bits: maximum size of the client's LZ77 sliding window
+            in bits, between 8 and 15.
+        compress_settings: additional keyword arguments for :func:`zlib.compressobj`,
+            excluding ``wbits``.
+        require_client_max_window_bits: do not enable compression at all if
+            client doesn't advertise support for ``client_max_window_bits``;
+            the default behavior is to enable compression without enforcing
+            ``client_max_window_bits``.
+
+    """
+
+    name = ExtensionName("permessage-deflate")
+
+    def __init__(
+        self,
+        server_no_context_takeover: bool = False,
+        client_no_context_takeover: bool = False,
+        server_max_window_bits: Optional[int] = None,
+        client_max_window_bits: Optional[int] = None,
+        compress_settings: Optional[Dict[str, Any]] = None,
+        require_client_max_window_bits: bool = False,
+    ) -> None:
+        """
+        Configure the Per-Message Deflate extension factory.
+
+        """
+        if not (server_max_window_bits is None or 8 <= server_max_window_bits <= 15):
+            raise ValueError("server_max_window_bits must be between 8 and 15")
+        if not (client_max_window_bits is None or 8 <= client_max_window_bits <= 15):
+            raise ValueError("client_max_window_bits must be between 8 and 15")
+        if compress_settings is not None and "wbits" in compress_settings:
+            raise ValueError(
+                "compress_settings must not include wbits, "
+                "set server_max_window_bits instead"
+            )
+        if client_max_window_bits is None and require_client_max_window_bits:
+            raise ValueError(
+                "require_client_max_window_bits is enabled, "
+                "but client_max_window_bits isn't configured"
+            )
+
+        self.server_no_context_takeover = server_no_context_takeover
+        self.client_no_context_takeover = client_no_context_takeover
+        self.server_max_window_bits = server_max_window_bits
+        self.client_max_window_bits = client_max_window_bits
+        self.compress_settings = compress_settings
+        self.require_client_max_window_bits = require_client_max_window_bits
+
+    def process_request_params(
+        self,
+        params: Sequence[ExtensionParameter],
+        accepted_extensions: Sequence[Extension],
+    ) -> Tuple[List[ExtensionParameter], PerMessageDeflate]:
+        """
+        Process request parameters.
+
+        Return response params and an extension instance.
+
+        """
+        if any(other.name == self.name for other in accepted_extensions):
+            raise exceptions.NegotiationError(f"skipped duplicate {self.name}")
+
+        # Load request parameters in local variables.
+        (
+            server_no_context_takeover,
+            client_no_context_takeover,
+            server_max_window_bits,
+            client_max_window_bits,
+        ) = _extract_parameters(params, is_server=True)
+
+        # Configuration parameters are available in instance variables.
+
+        # After comparing the request and the configuration, the response must
+        # be available in the local variables.
+
+        # server_no_context_takeover
+        #
+        #   Config  Req.    Resp.
+        #   ------  ------  --------------------------------------------------
+        #   False   False   False
+        #   False   True    True
+        #   True    False   True - must change value to True
+        #   True    True    True
+
+        if self.server_no_context_takeover:
+            if not server_no_context_takeover:
+                server_no_context_takeover = True
+
+        # client_no_context_takeover
+        #
+        #   Config  Req.    Resp.
+        #   ------  ------  --------------------------------------------------
+        #   False   False   False
+        #   False   True    True (or False)
+        #   True    False   True - must change value to True
+        #   True    True    True (or False)
+
+        if self.client_no_context_takeover:
+            if not client_no_context_takeover:
+                client_no_context_takeover = True
+
+        # server_max_window_bits
+
+        #   Config  Req.    Resp.
+        #   ------  ------  --------------------------------------------------
+        #   None    None    None
+        #   None    8≤M≤15  M
+        #   8≤N≤15  None    N - must change value
+        #   8≤N≤15  8≤M≤N   M
+        #   8≤N≤15  N<M≤15  N - must change value
+
+        if self.server_max_window_bits is None:
+            pass
+
+        else:
+            if server_max_window_bits is None:
+                server_max_window_bits = self.server_max_window_bits
+            elif server_max_window_bits > self.server_max_window_bits:
+                server_max_window_bits = self.server_max_window_bits
+
+        # client_max_window_bits
+
+        #   Config  Req.    Resp.
+        #   ------  ------  --------------------------------------------------
+        #   None    None    None
+        #   None    True    None - must change value
+        #   None    8≤M≤15  M (or None)
+        #   8≤N≤15  None    None or Error!
+        #   8≤N≤15  True    N - must change value
+        #   8≤N≤15  8≤M≤N   M (or None)
+        #   8≤N≤15  N<M≤15  N
+
+        if self.client_max_window_bits is None:
+            if client_max_window_bits is True:
+                client_max_window_bits = self.client_max_window_bits
+
+        else:
+            if client_max_window_bits is None:
+                if self.require_client_max_window_bits:
+                    raise exceptions.NegotiationError("required client_max_window_bits")
+            elif client_max_window_bits is True:
+                client_max_window_bits = self.client_max_window_bits
+            elif self.client_max_window_bits < client_max_window_bits:
+                client_max_window_bits = self.client_max_window_bits
+
+        return (
+            _build_parameters(
+                server_no_context_takeover,
+                client_no_context_takeover,
+                server_max_window_bits,
+                client_max_window_bits,
+            ),
+            PerMessageDeflate(
+                client_no_context_takeover,  # remote_no_context_takeover
+                server_no_context_takeover,  # local_no_context_takeover
+                client_max_window_bits or 15,  # remote_max_window_bits
+                server_max_window_bits or 15,  # local_max_window_bits
+                self.compress_settings,
+            ),
+        )
+
+
+def enable_server_permessage_deflate(
+    extensions: Optional[Sequence[ServerExtensionFactory]],
+) -> Sequence[ServerExtensionFactory]:
+    """
+    Enable Per-Message Deflate with default settings in server extensions.
+
+    If the extension is already present, perhaps with non-default settings,
+    the configuration isn't changed.
+
+    """
+    if extensions is None:
+        extensions = []
+    if not any(
+        ext_factory.name == ServerPerMessageDeflateFactory.name
+        for ext_factory in extensions
+    ):
+        extensions = list(extensions) + [
+            ServerPerMessageDeflateFactory(
+                server_max_window_bits=12,
+                client_max_window_bits=12,
+                compress_settings={"memLevel": 5},
+            )
+        ]
+    return extensions
diff --git a/myenv/lib/python3.9/site-packages/websockets/frames.py b/myenv/lib/python3.9/site-packages/websockets/frames.py
new file mode 100644
index 0000000..043b688
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/frames.py
@@ -0,0 +1,443 @@
+from __future__ import annotations
+
+import dataclasses
+import enum
+import io
+import secrets
+import struct
+from typing import Callable, Generator, Optional, Sequence, Tuple
+
+from . import exceptions, extensions
+from .typing import Data
+
+
+try:
+    from .speedups import apply_mask
+except ImportError:  # pragma: no cover
+    from .utils import apply_mask
+
+
+__all__ = [
+    "Opcode",
+    "OP_CONT",
+    "OP_TEXT",
+    "OP_BINARY",
+    "OP_CLOSE",
+    "OP_PING",
+    "OP_PONG",
+    "DATA_OPCODES",
+    "CTRL_OPCODES",
+    "Frame",
+    "prepare_data",
+    "prepare_ctrl",
+    "Close",
+]
+
+
+class Opcode(enum.IntEnum):
+    """Opcode values for WebSocket frames."""
+
+    CONT, TEXT, BINARY = 0x00, 0x01, 0x02
+    CLOSE, PING, PONG = 0x08, 0x09, 0x0A
+
+
+OP_CONT = Opcode.CONT
+OP_TEXT = Opcode.TEXT
+OP_BINARY = Opcode.BINARY
+OP_CLOSE = Opcode.CLOSE
+OP_PING = Opcode.PING
+OP_PONG = Opcode.PONG
+
+DATA_OPCODES = OP_CONT, OP_TEXT, OP_BINARY
+CTRL_OPCODES = OP_CLOSE, OP_PING, OP_PONG
+
+
+# See https://www.iana.org/assignments/websocket/websocket.xhtml
+CLOSE_CODES = {
+    1000: "OK",
+    1001: "going away",
+    1002: "protocol error",
+    1003: "unsupported type",
+    # 1004 is reserved
+    1005: "no status code [internal]",
+    1006: "connection closed abnormally [internal]",
+    1007: "invalid data",
+    1008: "policy violation",
+    1009: "message too big",
+    1010: "extension required",
+    1011: "unexpected error",
+    1012: "service restart",
+    1013: "try again later",
+    1014: "bad gateway",
+    1015: "TLS failure [internal]",
+}
+
+
+# Close code that are allowed in a close frame.
+# Using a set optimizes `code in EXTERNAL_CLOSE_CODES`.
+EXTERNAL_CLOSE_CODES = {
+    1000,
+    1001,
+    1002,
+    1003,
+    1007,
+    1008,
+    1009,
+    1010,
+    1011,
+    1012,
+    1013,
+    1014,
+}
+
+OK_CLOSE_CODES = {1000, 1001}
+
+
+BytesLike = bytes, bytearray, memoryview
+
+
+@dataclasses.dataclass
+class Frame:
+    """
+    WebSocket frame.
+
+    Attributes:
+        opcode: Opcode.
+        data: Payload data.
+        fin: FIN bit.
+        rsv1: RSV1 bit.
+        rsv2: RSV2 bit.
+        rsv3: RSV3 bit.
+
+    Only these fields are needed. The MASK bit, payload length and masking-key
+    are handled on the fly when parsing and serializing frames.
+
+    """
+
+    opcode: Opcode
+    data: bytes
+    fin: bool = True
+    rsv1: bool = False
+    rsv2: bool = False
+    rsv3: bool = False
+
+    def __str__(self) -> str:
+        """
+        Return a human-readable represention of a frame.
+
+        """
+        coding = None
+        length = f"{len(self.data)} byte{'' if len(self.data) == 1 else 's'}"
+        non_final = "" if self.fin else "continued"
+
+        if self.opcode is OP_TEXT:
+            # Decoding only the beginning and the end is needlessly hard.
+            # Decode the entire payload then elide later if necessary.
+            data = repr(self.data.decode())
+        elif self.opcode is OP_BINARY:
+            # We'll show at most the first 16 bytes and the last 8 bytes.
+            # Encode just what we need, plus two dummy bytes to elide later.
+            binary = self.data
+            if len(binary) > 25:
+                binary = b"".join([binary[:16], b"\x00\x00", binary[-8:]])
+            data = " ".join(f"{byte:02x}" for byte in binary)
+        elif self.opcode is OP_CLOSE:
+            data = str(Close.parse(self.data))
+        elif self.data:
+            # We don't know if a Continuation frame contains text or binary.
+            # Ping and Pong frames could contain UTF-8.
+            # Attempt to decode as UTF-8 and display it as text; fallback to
+            # binary. If self.data is a memoryview, it has no decode() method,
+            # which raises AttributeError.
+            try:
+                data = repr(self.data.decode())
+                coding = "text"
+            except (UnicodeDecodeError, AttributeError):
+                binary = self.data
+                if len(binary) > 25:
+                    binary = b"".join([binary[:16], b"\x00\x00", binary[-8:]])
+                data = " ".join(f"{byte:02x}" for byte in binary)
+                coding = "binary"
+        else:
+            data = "''"
+
+        if len(data) > 75:
+            data = data[:48] + "..." + data[-24:]
+
+        metadata = ", ".join(filter(None, [coding, length, non_final]))
+
+        return f"{self.opcode.name} {data} [{metadata}]"
+
+    @classmethod
+    def parse(
+        cls,
+        read_exact: Callable[[int], Generator[None, None, bytes]],
+        *,
+        mask: bool,
+        max_size: Optional[int] = None,
+        extensions: Optional[Sequence[extensions.Extension]] = None,
+    ) -> Generator[None, None, Frame]:
+        """
+        Parse a WebSocket frame.
+
+        This is a generator-based coroutine.
+
+        Args:
+            read_exact: generator-based coroutine that reads the requested
+                bytes or raises an exception if there isn't enough data.
+            mask: whether the frame should be masked i.e. whether the read
+                happens on the server side.
+            max_size: maximum payload size in bytes.
+            extensions: list of extensions, applied in reverse order.
+
+        Raises:
+            PayloadTooBig: if the frame's payload size exceeds ``max_size``.
+            ProtocolError: if the frame contains incorrect values.
+
+        """
+        # Read the header.
+        data = yield from read_exact(2)
+        head1, head2 = struct.unpack("!BB", data)
+
+        # While not Pythonic, this is marginally faster than calling bool().
+        fin = True if head1 & 0b10000000 else False
+        rsv1 = True if head1 & 0b01000000 else False
+        rsv2 = True if head1 & 0b00100000 else False
+        rsv3 = True if head1 & 0b00010000 else False
+
+        try:
+            opcode = Opcode(head1 & 0b00001111)
+        except ValueError as exc:
+            raise exceptions.ProtocolError("invalid opcode") from exc
+
+        if (True if head2 & 0b10000000 else False) != mask:
+            raise exceptions.ProtocolError("incorrect masking")
+
+        length = head2 & 0b01111111
+        if length == 126:
+            data = yield from read_exact(2)
+            (length,) = struct.unpack("!H", data)
+        elif length == 127:
+            data = yield from read_exact(8)
+            (length,) = struct.unpack("!Q", data)
+        if max_size is not None and length > max_size:
+            raise exceptions.PayloadTooBig(
+                f"over size limit ({length} > {max_size} bytes)"
+            )
+        if mask:
+            mask_bytes = yield from read_exact(4)
+
+        # Read the data.
+        data = yield from read_exact(length)
+        if mask:
+            data = apply_mask(data, mask_bytes)
+
+        frame = cls(opcode, data, fin, rsv1, rsv2, rsv3)
+
+        if extensions is None:
+            extensions = []
+        for extension in reversed(extensions):
+            frame = extension.decode(frame, max_size=max_size)
+
+        frame.check()
+
+        return frame
+
+    def serialize(
+        self,
+        *,
+        mask: bool,
+        extensions: Optional[Sequence[extensions.Extension]] = None,
+    ) -> bytes:
+        """
+        Serialize a WebSocket frame.
+
+        Args:
+            mask: whether the frame should be masked i.e. whether the write
+                happens on the client side.
+            extensions: list of extensions, applied in order.
+
+        Raises:
+            ProtocolError: if the frame contains incorrect values.
+
+        """
+        self.check()
+
+        if extensions is None:
+            extensions = []
+        for extension in extensions:
+            self = extension.encode(self)
+
+        output = io.BytesIO()
+
+        # Prepare the header.
+        head1 = (
+            (0b10000000 if self.fin else 0)
+            | (0b01000000 if self.rsv1 else 0)
+            | (0b00100000 if self.rsv2 else 0)
+            | (0b00010000 if self.rsv3 else 0)
+            | self.opcode
+        )
+
+        head2 = 0b10000000 if mask else 0
+
+        length = len(self.data)
+        if length < 126:
+            output.write(struct.pack("!BB", head1, head2 | length))
+        elif length < 65536:
+            output.write(struct.pack("!BBH", head1, head2 | 126, length))
+        else:
+            output.write(struct.pack("!BBQ", head1, head2 | 127, length))
+
+        if mask:
+            mask_bytes = secrets.token_bytes(4)
+            output.write(mask_bytes)
+
+        # Prepare the data.
+        if mask:
+            data = apply_mask(self.data, mask_bytes)
+        else:
+            data = self.data
+        output.write(data)
+
+        return output.getvalue()
+
+    def check(self) -> None:
+        """
+        Check that reserved bits and opcode have acceptable values.
+
+        Raises:
+            ProtocolError: if a reserved bit or the opcode is invalid.
+
+        """
+        if self.rsv1 or self.rsv2 or self.rsv3:
+            raise exceptions.ProtocolError("reserved bits must be 0")
+
+        if self.opcode in CTRL_OPCODES:
+            if len(self.data) > 125:
+                raise exceptions.ProtocolError("control frame too long")
+            if not self.fin:
+                raise exceptions.ProtocolError("fragmented control frame")
+
+
+def prepare_data(data: Data) -> Tuple[int, bytes]:
+    """
+    Convert a string or byte-like object to an opcode and a bytes-like object.
+
+    This function is designed for data frames.
+
+    If ``data`` is a :class:`str`, return ``OP_TEXT`` and a :class:`bytes`
+    object encoding ``data`` in UTF-8.
+
+    If ``data`` is a bytes-like object, return ``OP_BINARY`` and a bytes-like
+    object.
+
+    Raises:
+        TypeError: if ``data`` doesn't have a supported type.
+
+    """
+    if isinstance(data, str):
+        return OP_TEXT, data.encode("utf-8")
+    elif isinstance(data, BytesLike):
+        return OP_BINARY, data
+    else:
+        raise TypeError("data must be str or bytes-like")
+
+
+def prepare_ctrl(data: Data) -> bytes:
+    """
+    Convert a string or byte-like object to bytes.
+
+    This function is designed for ping and pong frames.
+
+    If ``data`` is a :class:`str`, return a :class:`bytes` object encoding
+    ``data`` in UTF-8.
+
+    If ``data`` is a bytes-like object, return a :class:`bytes` object.
+
+    Raises:
+        TypeError: if ``data`` doesn't have a supported type.
+
+    """
+    if isinstance(data, str):
+        return data.encode("utf-8")
+    elif isinstance(data, BytesLike):
+        return bytes(data)
+    else:
+        raise TypeError("data must be str or bytes-like")
+
+
+@dataclasses.dataclass
+class Close:
+    """
+    Code and reason for WebSocket close frames.
+
+    Attributes:
+        code: Close code.
+        reason: Close reason.
+
+    """
+
+    code: int
+    reason: str
+
+    def __str__(self) -> str:
+        """
+        Return a human-readable represention of a close code and reason.
+
+        """
+        if 3000 <= self.code < 4000:
+            explanation = "registered"
+        elif 4000 <= self.code < 5000:
+            explanation = "private use"
+        else:
+            explanation = CLOSE_CODES.get(self.code, "unknown")
+        result = f"{self.code} ({explanation})"
+
+        if self.reason:
+            result = f"{result} {self.reason}"
+
+        return result
+
+    @classmethod
+    def parse(cls, data: bytes) -> Close:
+        """
+        Parse the payload of a close frame.
+
+        Args:
+            data: payload of the close frame.
+
+        Raises:
+            ProtocolError: if data is ill-formed.
+            UnicodeDecodeError: if the reason isn't valid UTF-8.
+
+        """
+        if len(data) >= 2:
+            (code,) = struct.unpack("!H", data[:2])
+            reason = data[2:].decode("utf-8")
+            close = cls(code, reason)
+            close.check()
+            return close
+        elif len(data) == 0:
+            return cls(1005, "")
+        else:
+            raise exceptions.ProtocolError("close frame too short")
+
+    def serialize(self) -> bytes:
+        """
+        Serialize the payload of a close frame.
+
+        """
+        self.check()
+        return struct.pack("!H", self.code) + self.reason.encode("utf-8")
+
+    def check(self) -> None:
+        """
+        Check that the close code has a valid value for a close frame.
+
+        Raises:
+            ProtocolError: if the close code is invalid.
+
+        """
+        if not (self.code in EXTERNAL_CLOSE_CODES or 3000 <= self.code < 5000):
+            raise exceptions.ProtocolError("invalid status code")
diff --git a/myenv/lib/python3.9/site-packages/websockets/headers.py b/myenv/lib/python3.9/site-packages/websockets/headers.py
new file mode 100644
index 0000000..9ae3035
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/headers.py
@@ -0,0 +1,587 @@
+from __future__ import annotations
+
+import base64
+import binascii
+import ipaddress
+import re
+from typing import Callable, List, Optional, Sequence, Tuple, TypeVar, cast
+
+from . import exceptions
+from .typing import (
+    ConnectionOption,
+    ExtensionHeader,
+    ExtensionName,
+    ExtensionParameter,
+    Subprotocol,
+    UpgradeProtocol,
+)
+
+
+__all__ = [
+    "build_host",
+    "parse_connection",
+    "parse_upgrade",
+    "parse_extension",
+    "build_extension",
+    "parse_subprotocol",
+    "build_subprotocol",
+    "validate_subprotocols",
+    "build_www_authenticate_basic",
+    "parse_authorization_basic",
+    "build_authorization_basic",
+]
+
+
+T = TypeVar("T")
+
+
+def build_host(host: str, port: int, secure: bool) -> str:
+    """
+    Build a ``Host`` header.
+
+    """
+    # https://www.rfc-editor.org/rfc/rfc3986.html#section-3.2.2
+    # IPv6 addresses must be enclosed in brackets.
+    try:
+        address = ipaddress.ip_address(host)
+    except ValueError:
+        # host is a hostname
+        pass
+    else:
+        # host is an IP address
+        if address.version == 6:
+            host = f"[{host}]"
+
+    if port != (443 if secure else 80):
+        host = f"{host}:{port}"
+
+    return host
+
+
+# To avoid a dependency on a parsing library, we implement manually the ABNF
+# described in https://www.rfc-editor.org/rfc/rfc6455.html#section-9.1 and
+# https://www.rfc-editor.org/rfc/rfc7230.html#appendix-B.
+
+
+def peek_ahead(header: str, pos: int) -> Optional[str]:
+    """
+    Return the next character from ``header`` at the given position.
+
+    Return :obj:`None` at the end of ``header``.
+
+    We never need to peek more than one character ahead.
+
+    """
+    return None if pos == len(header) else header[pos]
+
+
+_OWS_re = re.compile(r"[\t ]*")
+
+
+def parse_OWS(header: str, pos: int) -> int:
+    """
+    Parse optional whitespace from ``header`` at the given position.
+
+    Return the new position.
+
+    The whitespace itself isn't returned because it isn't significant.
+
+    """
+    # There's always a match, possibly empty, whose content doesn't matter.
+    match = _OWS_re.match(header, pos)
+    assert match is not None
+    return match.end()
+
+
+_token_re = re.compile(r"[-!#$%&\'*+.^_`|~0-9a-zA-Z]+")
+
+
+def parse_token(header: str, pos: int, header_name: str) -> Tuple[str, int]:
+    """
+    Parse a token from ``header`` at the given position.
+
+    Return the token value and the new position.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    match = _token_re.match(header, pos)
+    if match is None:
+        raise exceptions.InvalidHeaderFormat(header_name, "expected token", header, pos)
+    return match.group(), match.end()
+
+
+_quoted_string_re = re.compile(
+    r'"(?:[\x09\x20-\x21\x23-\x5b\x5d-\x7e]|\\[\x09\x20-\x7e\x80-\xff])*"'
+)
+
+
+_unquote_re = re.compile(r"\\([\x09\x20-\x7e\x80-\xff])")
+
+
+def parse_quoted_string(header: str, pos: int, header_name: str) -> Tuple[str, int]:
+    """
+    Parse a quoted string from ``header`` at the given position.
+
+    Return the unquoted value and the new position.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    match = _quoted_string_re.match(header, pos)
+    if match is None:
+        raise exceptions.InvalidHeaderFormat(
+            header_name, "expected quoted string", header, pos
+        )
+    return _unquote_re.sub(r"\1", match.group()[1:-1]), match.end()
+
+
+_quotable_re = re.compile(r"[\x09\x20-\x7e\x80-\xff]*")
+
+
+_quote_re = re.compile(r"([\x22\x5c])")
+
+
+def build_quoted_string(value: str) -> str:
+    """
+    Format ``value`` as a quoted string.
+
+    This is the reverse of :func:`parse_quoted_string`.
+
+    """
+    match = _quotable_re.fullmatch(value)
+    if match is None:
+        raise ValueError("invalid characters for quoted-string encoding")
+    return '"' + _quote_re.sub(r"\\\1", value) + '"'
+
+
+def parse_list(
+    parse_item: Callable[[str, int, str], Tuple[T, int]],
+    header: str,
+    pos: int,
+    header_name: str,
+) -> List[T]:
+    """
+    Parse a comma-separated list from ``header`` at the given position.
+
+    This is appropriate for parsing values with the following grammar:
+
+        1#item
+
+    ``parse_item`` parses one item.
+
+    ``header`` is assumed not to start or end with whitespace.
+
+    (This function is designed for parsing an entire header value and
+    :func:`~websockets.http.read_headers` strips whitespace from values.)
+
+    Return a list of items.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    # Per https://www.rfc-editor.org/rfc/rfc7230.html#section-7, "a recipient
+    # MUST parse and ignore a reasonable number of empty list elements";
+    # hence while loops that remove extra delimiters.
+
+    # Remove extra delimiters before the first item.
+    while peek_ahead(header, pos) == ",":
+        pos = parse_OWS(header, pos + 1)
+
+    items = []
+    while True:
+        # Loop invariant: a item starts at pos in header.
+        item, pos = parse_item(header, pos, header_name)
+        items.append(item)
+        pos = parse_OWS(header, pos)
+
+        # We may have reached the end of the header.
+        if pos == len(header):
+            break
+
+        # There must be a delimiter after each element except the last one.
+        if peek_ahead(header, pos) == ",":
+            pos = parse_OWS(header, pos + 1)
+        else:
+            raise exceptions.InvalidHeaderFormat(
+                header_name, "expected comma", header, pos
+            )
+
+        # Remove extra delimiters before the next item.
+        while peek_ahead(header, pos) == ",":
+            pos = parse_OWS(header, pos + 1)
+
+        # We may have reached the end of the header.
+        if pos == len(header):
+            break
+
+    # Since we only advance in the header by one character with peek_ahead()
+    # or with the end position of a regex match, we can't overshoot the end.
+    assert pos == len(header)
+
+    return items
+
+
+def parse_connection_option(
+    header: str, pos: int, header_name: str
+) -> Tuple[ConnectionOption, int]:
+    """
+    Parse a Connection option from ``header`` at the given position.
+
+    Return the protocol value and the new position.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    item, pos = parse_token(header, pos, header_name)
+    return cast(ConnectionOption, item), pos
+
+
+def parse_connection(header: str) -> List[ConnectionOption]:
+    """
+    Parse a ``Connection`` header.
+
+    Return a list of HTTP connection options.
+
+    Args
+        header: value of the ``Connection`` header.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    return parse_list(parse_connection_option, header, 0, "Connection")
+
+
+_protocol_re = re.compile(
+    r"[-!#$%&\'*+.^_`|~0-9a-zA-Z]+(?:/[-!#$%&\'*+.^_`|~0-9a-zA-Z]+)?"
+)
+
+
+def parse_upgrade_protocol(
+    header: str, pos: int, header_name: str
+) -> Tuple[UpgradeProtocol, int]:
+    """
+    Parse an Upgrade protocol from ``header`` at the given position.
+
+    Return the protocol value and the new position.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    match = _protocol_re.match(header, pos)
+    if match is None:
+        raise exceptions.InvalidHeaderFormat(
+            header_name, "expected protocol", header, pos
+        )
+    return cast(UpgradeProtocol, match.group()), match.end()
+
+
+def parse_upgrade(header: str) -> List[UpgradeProtocol]:
+    """
+    Parse an ``Upgrade`` header.
+
+    Return a list of HTTP protocols.
+
+    Args:
+        header: value of the ``Upgrade`` header.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    return parse_list(parse_upgrade_protocol, header, 0, "Upgrade")
+
+
+def parse_extension_item_param(
+    header: str, pos: int, header_name: str
+) -> Tuple[ExtensionParameter, int]:
+    """
+    Parse a single extension parameter from ``header`` at the given position.
+
+    Return a ``(name, value)`` pair and the new position.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    # Extract parameter name.
+    name, pos = parse_token(header, pos, header_name)
+    pos = parse_OWS(header, pos)
+    # Extract parameter value, if there is one.
+    value: Optional[str] = None
+    if peek_ahead(header, pos) == "=":
+        pos = parse_OWS(header, pos + 1)
+        if peek_ahead(header, pos) == '"':
+            pos_before = pos  # for proper error reporting below
+            value, pos = parse_quoted_string(header, pos, header_name)
+            # https://www.rfc-editor.org/rfc/rfc6455.html#section-9.1 says:
+            # the value after quoted-string unescaping MUST conform to
+            # the 'token' ABNF.
+            if _token_re.fullmatch(value) is None:
+                raise exceptions.InvalidHeaderFormat(
+                    header_name, "invalid quoted header content", header, pos_before
+                )
+        else:
+            value, pos = parse_token(header, pos, header_name)
+        pos = parse_OWS(header, pos)
+
+    return (name, value), pos
+
+
+def parse_extension_item(
+    header: str, pos: int, header_name: str
+) -> Tuple[ExtensionHeader, int]:
+    """
+    Parse an extension definition from ``header`` at the given position.
+
+    Return an ``(extension name, parameters)`` pair, where ``parameters`` is a
+    list of ``(name, value)`` pairs, and the new position.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    # Extract extension name.
+    name, pos = parse_token(header, pos, header_name)
+    pos = parse_OWS(header, pos)
+    # Extract all parameters.
+    parameters = []
+    while peek_ahead(header, pos) == ";":
+        pos = parse_OWS(header, pos + 1)
+        parameter, pos = parse_extension_item_param(header, pos, header_name)
+        parameters.append(parameter)
+    return (cast(ExtensionName, name), parameters), pos
+
+
+def parse_extension(header: str) -> List[ExtensionHeader]:
+    """
+    Parse a ``Sec-WebSocket-Extensions`` header.
+
+    Return a list of WebSocket extensions and their parameters in this format::
+
+        [
+            (
+                'extension name',
+                [
+                    ('parameter name', 'parameter value'),
+                    ....
+                ]
+            ),
+            ...
+        ]
+
+    Parameter values are :obj:`None` when no value is provided.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    return parse_list(parse_extension_item, header, 0, "Sec-WebSocket-Extensions")
+
+
+parse_extension_list = parse_extension  # alias for backwards compatibility
+
+
+def build_extension_item(
+    name: ExtensionName, parameters: List[ExtensionParameter]
+) -> str:
+    """
+    Build an extension definition.
+
+    This is the reverse of :func:`parse_extension_item`.
+
+    """
+    return "; ".join(
+        [cast(str, name)]
+        + [
+            # Quoted strings aren't necessary because values are always tokens.
+            name if value is None else f"{name}={value}"
+            for name, value in parameters
+        ]
+    )
+
+
+def build_extension(extensions: Sequence[ExtensionHeader]) -> str:
+    """
+    Build a ``Sec-WebSocket-Extensions`` header.
+
+    This is the reverse of :func:`parse_extension`.
+
+    """
+    return ", ".join(
+        build_extension_item(name, parameters) for name, parameters in extensions
+    )
+
+
+build_extension_list = build_extension  # alias for backwards compatibility
+
+
+def parse_subprotocol_item(
+    header: str, pos: int, header_name: str
+) -> Tuple[Subprotocol, int]:
+    """
+    Parse a subprotocol from ``header`` at the given position.
+
+    Return the subprotocol value and the new position.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    item, pos = parse_token(header, pos, header_name)
+    return cast(Subprotocol, item), pos
+
+
+def parse_subprotocol(header: str) -> List[Subprotocol]:
+    """
+    Parse a ``Sec-WebSocket-Protocol`` header.
+
+    Return a list of WebSocket subprotocols.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    return parse_list(parse_subprotocol_item, header, 0, "Sec-WebSocket-Protocol")
+
+
+parse_subprotocol_list = parse_subprotocol  # alias for backwards compatibility
+
+
+def build_subprotocol(subprotocols: Sequence[Subprotocol]) -> str:
+    """
+    Build a ``Sec-WebSocket-Protocol`` header.
+
+    This is the reverse of :func:`parse_subprotocol`.
+
+    """
+    return ", ".join(subprotocols)
+
+
+build_subprotocol_list = build_subprotocol  # alias for backwards compatibility
+
+
+def validate_subprotocols(subprotocols: Sequence[Subprotocol]) -> None:
+    """
+    Validate that ``subprotocols`` is suitable for :func:`build_subprotocol`.
+
+    """
+    if not isinstance(subprotocols, Sequence):
+        raise TypeError("subprotocols must be a list")
+    if isinstance(subprotocols, str):
+        raise TypeError("subprotocols must be a list, not a str")
+    for subprotocol in subprotocols:
+        if not _token_re.fullmatch(subprotocol):
+            raise ValueError(f"invalid subprotocol: {subprotocol}")
+
+
+def build_www_authenticate_basic(realm: str) -> str:
+    """
+    Build a ``WWW-Authenticate`` header for HTTP Basic Auth.
+
+    Args:
+        realm: identifier of the protection space.
+
+    """
+    # https://www.rfc-editor.org/rfc/rfc7617.html#section-2
+    realm = build_quoted_string(realm)
+    charset = build_quoted_string("UTF-8")
+    return f"Basic realm={realm}, charset={charset}"
+
+
+_token68_re = re.compile(r"[A-Za-z0-9-._~+/]+=*")
+
+
+def parse_token68(header: str, pos: int, header_name: str) -> Tuple[str, int]:
+    """
+    Parse a token68 from ``header`` at the given position.
+
+    Return the token value and the new position.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+
+    """
+    match = _token68_re.match(header, pos)
+    if match is None:
+        raise exceptions.InvalidHeaderFormat(
+            header_name, "expected token68", header, pos
+        )
+    return match.group(), match.end()
+
+
+def parse_end(header: str, pos: int, header_name: str) -> None:
+    """
+    Check that parsing reached the end of header.
+
+    """
+    if pos < len(header):
+        raise exceptions.InvalidHeaderFormat(header_name, "trailing data", header, pos)
+
+
+def parse_authorization_basic(header: str) -> Tuple[str, str]:
+    """
+    Parse an ``Authorization`` header for HTTP Basic Auth.
+
+    Return a ``(username, password)`` tuple.
+
+    Args:
+        header: value of the ``Authorization`` header.
+
+    Raises:
+        InvalidHeaderFormat: on invalid inputs.
+        InvalidHeaderValue: on unsupported inputs.
+
+    """
+    # https://www.rfc-editor.org/rfc/rfc7235.html#section-2.1
+    # https://www.rfc-editor.org/rfc/rfc7617.html#section-2
+    scheme, pos = parse_token(header, 0, "Authorization")
+    if scheme.lower() != "basic":
+        raise exceptions.InvalidHeaderValue(
+            "Authorization",
+            f"unsupported scheme: {scheme}",
+        )
+    if peek_ahead(header, pos) != " ":
+        raise exceptions.InvalidHeaderFormat(
+            "Authorization", "expected space after scheme", header, pos
+        )
+    pos += 1
+    basic_credentials, pos = parse_token68(header, pos, "Authorization")
+    parse_end(header, pos, "Authorization")
+
+    try:
+        user_pass = base64.b64decode(basic_credentials.encode()).decode()
+    except binascii.Error:
+        raise exceptions.InvalidHeaderValue(
+            "Authorization",
+            "expected base64-encoded credentials",
+        ) from None
+    try:
+        username, password = user_pass.split(":", 1)
+    except ValueError:
+        raise exceptions.InvalidHeaderValue(
+            "Authorization",
+            "expected username:password credentials",
+        ) from None
+
+    return username, password
+
+
+def build_authorization_basic(username: str, password: str) -> str:
+    """
+    Build an ``Authorization`` header for HTTP Basic Auth.
+
+    This is the reverse of :func:`parse_authorization_basic`.
+
+    """
+    # https://www.rfc-editor.org/rfc/rfc7617.html#section-2
+    assert ":" not in username
+    user_pass = f"{username}:{password}"
+    basic_credentials = base64.b64encode(user_pass.encode()).decode()
+    return "Basic " + basic_credentials
diff --git a/myenv/lib/python3.9/site-packages/websockets/http.py b/myenv/lib/python3.9/site-packages/websockets/http.py
new file mode 100644
index 0000000..b14fa94
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/http.py
@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import sys
+
+from .imports import lazy_import
+from .version import version as websockets_version
+
+
+# For backwards compatibility:
+
+
+lazy_import(
+    globals(),
+    # Headers and MultipleValuesError used to be defined in this module.
+    aliases={
+        "Headers": ".datastructures",
+        "MultipleValuesError": ".datastructures",
+    },
+    deprecated_aliases={
+        "read_request": ".legacy.http",
+        "read_response": ".legacy.http",
+    },
+)
+
+
+__all__ = ["USER_AGENT"]
+
+
+PYTHON_VERSION = "{}.{}".format(*sys.version_info)
+USER_AGENT = f"Python/{PYTHON_VERSION} websockets/{websockets_version}"
diff --git a/myenv/lib/python3.9/site-packages/websockets/http11.py b/myenv/lib/python3.9/site-packages/websockets/http11.py
new file mode 100644
index 0000000..84048fa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/http11.py
@@ -0,0 +1,366 @@
+from __future__ import annotations
+
+import dataclasses
+import re
+import warnings
+from typing import Callable, Generator, Optional
+
+from . import datastructures, exceptions
+
+
+# Maximum total size of headers is around 256 * 4 KiB = 1 MiB
+MAX_HEADERS = 256
+
+# We can use the same limit for the request line and header lines:
+# "GET <4096 bytes> HTTP/1.1\r\n" = 4111 bytes
+# "Set-Cookie: <4097 bytes>\r\n" = 4111 bytes
+# (RFC requires 4096 bytes; for some reason Firefox supports 4097 bytes.)
+MAX_LINE = 4111
+
+# Support for HTTP response bodies is intended to read an error message
+# returned by a server. It isn't designed to perform large file transfers.
+MAX_BODY = 2**20  # 1 MiB
+
+
+def d(value: bytes) -> str:
+    """
+    Decode a bytestring for interpolating into an error message.
+
+    """
+    return value.decode(errors="backslashreplace")
+
+
+# See https://www.rfc-editor.org/rfc/rfc7230.html#appendix-B.
+
+# Regex for validating header names.
+
+_token_re = re.compile(rb"[-!#$%&\'*+.^_`|~0-9a-zA-Z]+")
+
+# Regex for validating header values.
+
+# We don't attempt to support obsolete line folding.
+
+# Include HTAB (\x09), SP (\x20), VCHAR (\x21-\x7e), obs-text (\x80-\xff).
+
+# The ABNF is complicated because it attempts to express that optional
+# whitespace is ignored. We strip whitespace and don't revalidate that.
+
+# See also https://www.rfc-editor.org/errata_search.php?rfc=7230&eid=4189
+
+_value_re = re.compile(rb"[\x09\x20-\x7e\x80-\xff]*")
+
+
+@dataclasses.dataclass
+class Request:
+    """
+    WebSocket handshake request.
+
+    Attributes:
+        path: Request path, including optional query.
+        headers: Request headers.
+    """
+
+    path: str
+    headers: datastructures.Headers
+    # body isn't useful is the context of this library.
+
+    _exception: Optional[Exception] = None
+
+    @property
+    def exception(self) -> Optional[Exception]:  # pragma: no cover
+        warnings.warn(
+            "Request.exception is deprecated; "
+            "use ServerConnection.handshake_exc instead",
+            DeprecationWarning,
+        )
+        return self._exception
+
+    @classmethod
+    def parse(
+        cls,
+        read_line: Callable[[int], Generator[None, None, bytes]],
+    ) -> Generator[None, None, Request]:
+        """
+        Parse a WebSocket handshake request.
+
+        This is a generator-based coroutine.
+
+        The request path isn't URL-decoded or validated in any way.
+
+        The request path and headers are expected to contain only ASCII
+        characters. Other characters are represented with surrogate escapes.
+
+        :meth:`parse` doesn't attempt to read the request body because
+        WebSocket handshake requests don't have one. If the request contains a
+        body, it may be read from the data stream after :meth:`parse` returns.
+
+        Args:
+            read_line: generator-based coroutine that reads a LF-terminated
+                line or raises an exception if there isn't enough data
+
+        Raises:
+            EOFError: if the connection is closed without a full HTTP request.
+            SecurityError: if the request exceeds a security limit.
+            ValueError: if the request isn't well formatted.
+
+        """
+        # https://www.rfc-editor.org/rfc/rfc7230.html#section-3.1.1
+
+        # Parsing is simple because fixed values are expected for method and
+        # version and because path isn't checked. Since WebSocket software tends
+        # to implement HTTP/1.1 strictly, there's little need for lenient parsing.
+
+        try:
+            request_line = yield from parse_line(read_line)
+        except EOFError as exc:
+            raise EOFError("connection closed while reading HTTP request line") from exc
+
+        try:
+            method, raw_path, version = request_line.split(b" ", 2)
+        except ValueError:  # not enough values to unpack (expected 3, got 1-2)
+            raise ValueError(f"invalid HTTP request line: {d(request_line)}") from None
+
+        if method != b"GET":
+            raise ValueError(f"unsupported HTTP method: {d(method)}")
+        if version != b"HTTP/1.1":
+            raise ValueError(f"unsupported HTTP version: {d(version)}")
+        path = raw_path.decode("ascii", "surrogateescape")
+
+        headers = yield from parse_headers(read_line)
+
+        # https://www.rfc-editor.org/rfc/rfc7230.html#section-3.3.3
+
+        if "Transfer-Encoding" in headers:
+            raise NotImplementedError("transfer codings aren't supported")
+
+        if "Content-Length" in headers:
+            raise ValueError("unsupported request body")
+
+        return cls(path, headers)
+
+    def serialize(self) -> bytes:
+        """
+        Serialize a WebSocket handshake request.
+
+        """
+        # Since the request line and headers only contain ASCII characters,
+        # we can keep this simple.
+        request = f"GET {self.path} HTTP/1.1\r\n".encode()
+        request += self.headers.serialize()
+        return request
+
+
+@dataclasses.dataclass
+class Response:
+    """
+    WebSocket handshake response.
+
+    Attributes:
+        status_code: Response code.
+        reason_phrase: Response reason.
+        headers: Response headers.
+        body: Response body, if any.
+
+    """
+
+    status_code: int
+    reason_phrase: str
+    headers: datastructures.Headers
+    body: Optional[bytes] = None
+
+    _exception: Optional[Exception] = None
+
+    @property
+    def exception(self) -> Optional[Exception]:  # pragma: no cover
+        warnings.warn(
+            "Response.exception is deprecated; "
+            "use ClientConnection.handshake_exc instead",
+            DeprecationWarning,
+        )
+        return self._exception
+
+    @classmethod
+    def parse(
+        cls,
+        read_line: Callable[[int], Generator[None, None, bytes]],
+        read_exact: Callable[[int], Generator[None, None, bytes]],
+        read_to_eof: Callable[[int], Generator[None, None, bytes]],
+    ) -> Generator[None, None, Response]:
+        """
+        Parse a WebSocket handshake response.
+
+        This is a generator-based coroutine.
+
+        The reason phrase and headers are expected to contain only ASCII
+        characters. Other characters are represented with surrogate escapes.
+
+        Args:
+            read_line: generator-based coroutine that reads a LF-terminated
+                line or raises an exception if there isn't enough data.
+            read_exact: generator-based coroutine that reads the requested
+                bytes or raises an exception if there isn't enough data.
+            read_to_eof: generator-based coroutine that reads until the end
+                of the stream.
+
+        Raises:
+            EOFError: if the connection is closed without a full HTTP response.
+            SecurityError: if the response exceeds a security limit.
+            LookupError: if the response isn't well formatted.
+            ValueError: if the response isn't well formatted.
+
+        """
+        # https://www.rfc-editor.org/rfc/rfc7230.html#section-3.1.2
+
+        try:
+            status_line = yield from parse_line(read_line)
+        except EOFError as exc:
+            raise EOFError("connection closed while reading HTTP status line") from exc
+
+        try:
+            version, raw_status_code, raw_reason = status_line.split(b" ", 2)
+        except ValueError:  # not enough values to unpack (expected 3, got 1-2)
+            raise ValueError(f"invalid HTTP status line: {d(status_line)}") from None
+
+        if version != b"HTTP/1.1":
+            raise ValueError(f"unsupported HTTP version: {d(version)}")
+        try:
+            status_code = int(raw_status_code)
+        except ValueError:  # invalid literal for int() with base 10
+            raise ValueError(
+                f"invalid HTTP status code: {d(raw_status_code)}"
+            ) from None
+        if not 100 <= status_code < 1000:
+            raise ValueError(f"unsupported HTTP status code: {d(raw_status_code)}")
+        if not _value_re.fullmatch(raw_reason):
+            raise ValueError(f"invalid HTTP reason phrase: {d(raw_reason)}")
+        reason = raw_reason.decode()
+
+        headers = yield from parse_headers(read_line)
+
+        # https://www.rfc-editor.org/rfc/rfc7230.html#section-3.3.3
+
+        if "Transfer-Encoding" in headers:
+            raise NotImplementedError("transfer codings aren't supported")
+
+        # Since websockets only does GET requests (no HEAD, no CONNECT), all
+        # responses except 1xx, 204, and 304 include a message body.
+        if 100 <= status_code < 200 or status_code == 204 or status_code == 304:
+            body = None
+        else:
+            content_length: Optional[int]
+            try:
+                # MultipleValuesError is sufficiently unlikely that we don't
+                # attempt to handle it. Instead we document that its parent
+                # class, LookupError, may be raised.
+                raw_content_length = headers["Content-Length"]
+            except KeyError:
+                content_length = None
+            else:
+                content_length = int(raw_content_length)
+
+            if content_length is None:
+                try:
+                    body = yield from read_to_eof(MAX_BODY)
+                except RuntimeError:
+                    raise exceptions.SecurityError(
+                        f"body too large: over {MAX_BODY} bytes"
+                    )
+            elif content_length > MAX_BODY:
+                raise exceptions.SecurityError(
+                    f"body too large: {content_length} bytes"
+                )
+            else:
+                body = yield from read_exact(content_length)
+
+        return cls(status_code, reason, headers, body)
+
+    def serialize(self) -> bytes:
+        """
+        Serialize a WebSocket handshake response.
+
+        """
+        # Since the status line and headers only contain ASCII characters,
+        # we can keep this simple.
+        response = f"HTTP/1.1 {self.status_code} {self.reason_phrase}\r\n".encode()
+        response += self.headers.serialize()
+        if self.body is not None:
+            response += self.body
+        return response
+
+
+def parse_headers(
+    read_line: Callable[[int], Generator[None, None, bytes]],
+) -> Generator[None, None, datastructures.Headers]:
+    """
+    Parse HTTP headers.
+
+    Non-ASCII characters are represented with surrogate escapes.
+
+    Args:
+        read_line: generator-based coroutine that reads a LF-terminated line
+            or raises an exception if there isn't enough data.
+
+    Raises:
+        EOFError: if the connection is closed without complete headers.
+        SecurityError: if the request exceeds a security limit.
+        ValueError: if the request isn't well formatted.
+
+    """
+    # https://www.rfc-editor.org/rfc/rfc7230.html#section-3.2
+
+    # We don't attempt to support obsolete line folding.
+
+    headers = datastructures.Headers()
+    for _ in range(MAX_HEADERS + 1):
+        try:
+            line = yield from parse_line(read_line)
+        except EOFError as exc:
+            raise EOFError("connection closed while reading HTTP headers") from exc
+        if line == b"":
+            break
+
+        try:
+            raw_name, raw_value = line.split(b":", 1)
+        except ValueError:  # not enough values to unpack (expected 2, got 1)
+            raise ValueError(f"invalid HTTP header line: {d(line)}") from None
+        if not _token_re.fullmatch(raw_name):
+            raise ValueError(f"invalid HTTP header name: {d(raw_name)}")
+        raw_value = raw_value.strip(b" \t")
+        if not _value_re.fullmatch(raw_value):
+            raise ValueError(f"invalid HTTP header value: {d(raw_value)}")
+
+        name = raw_name.decode("ascii")  # guaranteed to be ASCII at this point
+        value = raw_value.decode("ascii", "surrogateescape")
+        headers[name] = value
+
+    else:
+        raise exceptions.SecurityError("too many HTTP headers")
+
+    return headers
+
+
+def parse_line(
+    read_line: Callable[[int], Generator[None, None, bytes]],
+) -> Generator[None, None, bytes]:
+    """
+    Parse a single line.
+
+    CRLF is stripped from the return value.
+
+    Args:
+        read_line: generator-based coroutine that reads a LF-terminated line
+            or raises an exception if there isn't enough data.
+
+    Raises:
+        EOFError: if the connection is closed without a CRLF.
+        SecurityError: if the response exceeds a security limit.
+
+    """
+    try:
+        line = yield from read_line(MAX_LINE)
+    except RuntimeError:
+        raise exceptions.SecurityError("line too long")
+    # Not mandatory but safe - https://www.rfc-editor.org/rfc/rfc7230.html#section-3.5
+    if not line.endswith(b"\r\n"):
+        raise EOFError("line without CRLF")
+    return line[:-2]
diff --git a/myenv/lib/python3.9/site-packages/websockets/imports.py b/myenv/lib/python3.9/site-packages/websockets/imports.py
new file mode 100644
index 0000000..a6a59d4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/imports.py
@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import warnings
+from typing import Any, Dict, Iterable, Optional
+
+
+__all__ = ["lazy_import"]
+
+
+def import_name(name: str, source: str, namespace: Dict[str, Any]) -> Any:
+    """
+    Import ``name`` from ``source`` in ``namespace``.
+
+    There are two use cases:
+
+    - ``name`` is an object defined in ``source``;
+    - ``name`` is a submodule of ``source``.
+
+    Neither :func:`__import__` nor :func:`~importlib.import_module` does
+    exactly this. :func:`__import__` is closer to the intended behavior.
+
+    """
+    level = 0
+    while source[level] == ".":
+        level += 1
+        assert level < len(source), "importing from parent isn't supported"
+    module = __import__(source[level:], namespace, None, [name], level)
+    return getattr(module, name)
+
+
+def lazy_import(
+    namespace: Dict[str, Any],
+    aliases: Optional[Dict[str, str]] = None,
+    deprecated_aliases: Optional[Dict[str, str]] = None,
+) -> None:
+    """
+    Provide lazy, module-level imports.
+
+    Typical use::
+
+        __getattr__, __dir__ = lazy_import(
+            globals(),
+            aliases={
+                "<name>": "<source module>",
+                ...
+            },
+            deprecated_aliases={
+                ...,
+            }
+        )
+
+    This function defines ``__getattr__`` and ``__dir__`` per :pep:`562`.
+
+    """
+    if aliases is None:
+        aliases = {}
+    if deprecated_aliases is None:
+        deprecated_aliases = {}
+
+    namespace_set = set(namespace)
+    aliases_set = set(aliases)
+    deprecated_aliases_set = set(deprecated_aliases)
+
+    assert not namespace_set & aliases_set, "namespace conflict"
+    assert not namespace_set & deprecated_aliases_set, "namespace conflict"
+    assert not aliases_set & deprecated_aliases_set, "namespace conflict"
+
+    package = namespace["__name__"]
+
+    def __getattr__(name: str) -> Any:
+        assert aliases is not None  # mypy cannot figure this out
+        try:
+            source = aliases[name]
+        except KeyError:
+            pass
+        else:
+            return import_name(name, source, namespace)
+
+        assert deprecated_aliases is not None  # mypy cannot figure this out
+        try:
+            source = deprecated_aliases[name]
+        except KeyError:
+            pass
+        else:
+            warnings.warn(
+                f"{package}.{name} is deprecated",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            return import_name(name, source, namespace)
+
+        raise AttributeError(f"module {package!r} has no attribute {name!r}")
+
+    namespace["__getattr__"] = __getattr__
+
+    def __dir__() -> Iterable[str]:
+        return sorted(namespace_set | aliases_set | deprecated_aliases_set)
+
+    namespace["__dir__"] = __dir__
diff --git a/myenv/lib/python3.9/site-packages/websockets/legacy/__init__.py b/myenv/lib/python3.9/site-packages/websockets/legacy/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/websockets/legacy/auth.py b/myenv/lib/python3.9/site-packages/websockets/legacy/auth.py
new file mode 100644
index 0000000..8825c14
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/legacy/auth.py
@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import functools
+import hmac
+import http
+from typing import Any, Awaitable, Callable, Iterable, Optional, Tuple, Union, cast
+
+from ..datastructures import Headers
+from ..exceptions import InvalidHeader
+from ..headers import build_www_authenticate_basic, parse_authorization_basic
+from .server import HTTPResponse, WebSocketServerProtocol
+
+
+__all__ = ["BasicAuthWebSocketServerProtocol", "basic_auth_protocol_factory"]
+
+Credentials = Tuple[str, str]
+
+
+def is_credentials(value: Any) -> bool:
+    try:
+        username, password = value
+    except (TypeError, ValueError):
+        return False
+    else:
+        return isinstance(username, str) and isinstance(password, str)
+
+
+class BasicAuthWebSocketServerProtocol(WebSocketServerProtocol):
+    """
+    WebSocket server protocol that enforces HTTP Basic Auth.
+
+    """
+
+    realm: str = ""
+    """
+    Scope of protection.
+
+    If provided, it should contain only ASCII characters because the
+    encoding of non-ASCII characters is undefined.
+    """
+
+    username: Optional[str] = None
+    """Username of the authenticated user."""
+
+    def __init__(
+        self,
+        *args: Any,
+        realm: Optional[str] = None,
+        check_credentials: Optional[Callable[[str, str], Awaitable[bool]]] = None,
+        **kwargs: Any,
+    ) -> None:
+        if realm is not None:
+            self.realm = realm  # shadow class attribute
+        self._check_credentials = check_credentials
+        super().__init__(*args, **kwargs)
+
+    async def check_credentials(self, username: str, password: str) -> bool:
+        """
+        Check whether credentials are authorized.
+
+        This coroutine may be overridden in a subclass, for example to
+        authenticate against a database or an external service.
+
+        Args:
+            username: HTTP Basic Auth username.
+            password: HTTP Basic Auth password.
+
+        Returns:
+            bool: :obj:`True` if the handshake should continue;
+            :obj:`False` if it should fail with a HTTP 401 error.
+
+        """
+        if self._check_credentials is not None:
+            return await self._check_credentials(username, password)
+
+        return False
+
+    async def process_request(
+        self,
+        path: str,
+        request_headers: Headers,
+    ) -> Optional[HTTPResponse]:
+        """
+        Check HTTP Basic Auth and return a HTTP 401 response if needed.
+
+        """
+        try:
+            authorization = request_headers["Authorization"]
+        except KeyError:
+            return (
+                http.HTTPStatus.UNAUTHORIZED,
+                [("WWW-Authenticate", build_www_authenticate_basic(self.realm))],
+                b"Missing credentials\n",
+            )
+
+        try:
+            username, password = parse_authorization_basic(authorization)
+        except InvalidHeader:
+            return (
+                http.HTTPStatus.UNAUTHORIZED,
+                [("WWW-Authenticate", build_www_authenticate_basic(self.realm))],
+                b"Unsupported credentials\n",
+            )
+
+        if not await self.check_credentials(username, password):
+            return (
+                http.HTTPStatus.UNAUTHORIZED,
+                [("WWW-Authenticate", build_www_authenticate_basic(self.realm))],
+                b"Invalid credentials\n",
+            )
+
+        self.username = username
+
+        return await super().process_request(path, request_headers)
+
+
+def basic_auth_protocol_factory(
+    realm: Optional[str] = None,
+    credentials: Optional[Union[Credentials, Iterable[Credentials]]] = None,
+    check_credentials: Optional[Callable[[str, str], Awaitable[bool]]] = None,
+    create_protocol: Optional[Callable[[Any], BasicAuthWebSocketServerProtocol]] = None,
+) -> Callable[[Any], BasicAuthWebSocketServerProtocol]:
+    """
+    Protocol factory that enforces HTTP Basic Auth.
+
+    :func:`basic_auth_protocol_factory` is designed to integrate with
+    :func:`~websockets.server.serve` like this::
+
+        websockets.serve(
+            ...,
+            create_protocol=websockets.basic_auth_protocol_factory(
+                realm="my dev server",
+                credentials=("hello", "iloveyou"),
+            )
+        )
+
+    Args:
+        realm: indicates the scope of protection. It should contain only ASCII
+            characters because the encoding of non-ASCII characters is
+            undefined. Refer to section 2.2 of :rfc:`7235` for details.
+        credentials: defines hard coded authorized credentials. It can be a
+            ``(username, password)`` pair or a list of such pairs.
+        check_credentials: defines a coroutine that verifies credentials.
+            This coroutine receives ``username`` and ``password`` arguments
+            and returns a :class:`bool`. One of ``credentials`` or
+            ``check_credentials`` must be provided but not both.
+        create_protocol: factory that creates the protocol. By default, this
+            is :class:`BasicAuthWebSocketServerProtocol`. It can be replaced
+            by a subclass.
+    Raises:
+        TypeError: if the ``credentials`` or ``check_credentials`` argument is
+            wrong.
+
+    """
+    if (credentials is None) == (check_credentials is None):
+        raise TypeError("provide either credentials or check_credentials")
+
+    if credentials is not None:
+        if is_credentials(credentials):
+            credentials_list = [cast(Credentials, credentials)]
+        elif isinstance(credentials, Iterable):
+            credentials_list = list(credentials)
+            if not all(is_credentials(item) for item in credentials_list):
+                raise TypeError(f"invalid credentials argument: {credentials}")
+        else:
+            raise TypeError(f"invalid credentials argument: {credentials}")
+
+        credentials_dict = dict(credentials_list)
+
+        async def check_credentials(username: str, password: str) -> bool:
+            try:
+                expected_password = credentials_dict[username]
+            except KeyError:
+                return False
+            return hmac.compare_digest(expected_password, password)
+
+    if create_protocol is None:
+        # Not sure why mypy cannot figure this out.
+        create_protocol = cast(
+            Callable[[Any], BasicAuthWebSocketServerProtocol],
+            BasicAuthWebSocketServerProtocol,
+        )
+
+    return functools.partial(
+        create_protocol,
+        realm=realm,
+        check_credentials=check_credentials,
+    )
diff --git a/myenv/lib/python3.9/site-packages/websockets/legacy/client.py b/myenv/lib/python3.9/site-packages/websockets/legacy/client.py
new file mode 100644
index 0000000..fadc3ef
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/legacy/client.py
@@ -0,0 +1,709 @@
+from __future__ import annotations
+
+import asyncio
+import functools
+import logging
+import random
+import urllib.parse
+import warnings
+from types import TracebackType
+from typing import (
+    Any,
+    AsyncIterator,
+    Callable,
+    Generator,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    cast,
+)
+
+from ..datastructures import Headers, HeadersLike
+from ..exceptions import (
+    InvalidHandshake,
+    InvalidHeader,
+    InvalidMessage,
+    InvalidStatusCode,
+    NegotiationError,
+    RedirectHandshake,
+    SecurityError,
+)
+from ..extensions import ClientExtensionFactory, Extension
+from ..extensions.permessage_deflate import enable_client_permessage_deflate
+from ..headers import (
+    build_authorization_basic,
+    build_extension,
+    build_host,
+    build_subprotocol,
+    parse_extension,
+    parse_subprotocol,
+    validate_subprotocols,
+)
+from ..http import USER_AGENT
+from ..typing import ExtensionHeader, LoggerLike, Origin, Subprotocol
+from ..uri import WebSocketURI, parse_uri
+from .handshake import build_request, check_response
+from .http import read_response
+from .protocol import WebSocketCommonProtocol
+
+
+__all__ = ["connect", "unix_connect", "WebSocketClientProtocol"]
+
+
+class WebSocketClientProtocol(WebSocketCommonProtocol):
+    """
+    WebSocket client connection.
+
+    :class:`WebSocketClientProtocol` provides :meth:`recv` and :meth:`send`
+    coroutines for receiving and sending messages.
+
+    It supports asynchronous iteration to receive incoming messages::
+
+        async for message in websocket:
+            await process(message)
+
+    The iterator exits normally when the connection is closed with close code
+    1000 (OK) or 1001 (going away). It raises
+    a :exc:`~websockets.exceptions.ConnectionClosedError` when the connection
+    is closed with any other code.
+
+    See :func:`connect` for the documentation of ``logger``, ``origin``,
+    ``extensions``, ``subprotocols``, and ``extra_headers``.
+
+    See :class:`~websockets.legacy.protocol.WebSocketCommonProtocol` for the
+    documentation of ``ping_interval``, ``ping_timeout``, ``close_timeout``,
+    ``max_size``, ``max_queue``, ``read_limit``, and ``write_limit``.
+
+    """
+
+    is_client = True
+    side = "client"
+
+    def __init__(
+        self,
+        *,
+        logger: Optional[LoggerLike] = None,
+        origin: Optional[Origin] = None,
+        extensions: Optional[Sequence[ClientExtensionFactory]] = None,
+        subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLike] = None,
+        **kwargs: Any,
+    ) -> None:
+        if logger is None:
+            logger = logging.getLogger("websockets.client")
+        super().__init__(logger=logger, **kwargs)
+        self.origin = origin
+        self.available_extensions = extensions
+        self.available_subprotocols = subprotocols
+        self.extra_headers = extra_headers
+
+    def write_http_request(self, path: str, headers: Headers) -> None:
+        """
+        Write request line and headers to the HTTP request.
+
+        """
+        self.path = path
+        self.request_headers = headers
+
+        if self.debug:
+            self.logger.debug("> GET %s HTTP/1.1", path)
+            for key, value in headers.raw_items():
+                self.logger.debug("> %s: %s", key, value)
+
+        # Since the path and headers only contain ASCII characters,
+        # we can keep this simple.
+        request = f"GET {path} HTTP/1.1\r\n"
+        request += str(headers)
+
+        self.transport.write(request.encode())
+
+    async def read_http_response(self) -> Tuple[int, Headers]:
+        """
+        Read status line and headers from the HTTP response.
+
+        If the response contains a body, it may be read from ``self.reader``
+        after this coroutine returns.
+
+        Raises:
+            InvalidMessage: if the HTTP message is malformed or isn't an
+                HTTP/1.1 GET response.
+
+        """
+        try:
+            status_code, reason, headers = await read_response(self.reader)
+        # Remove this branch when dropping support for Python < 3.8
+        # because CancelledError no longer inherits Exception.
+        except asyncio.CancelledError:  # pragma: no cover
+            raise
+        except Exception as exc:
+            raise InvalidMessage("did not receive a valid HTTP response") from exc
+
+        if self.debug:
+            self.logger.debug("< HTTP/1.1 %d %s", status_code, reason)
+            for key, value in headers.raw_items():
+                self.logger.debug("< %s: %s", key, value)
+
+        self.response_headers = headers
+
+        return status_code, self.response_headers
+
+    @staticmethod
+    def process_extensions(
+        headers: Headers,
+        available_extensions: Optional[Sequence[ClientExtensionFactory]],
+    ) -> List[Extension]:
+        """
+        Handle the Sec-WebSocket-Extensions HTTP response header.
+
+        Check that each extension is supported, as well as its parameters.
+
+        Return the list of accepted extensions.
+
+        Raise :exc:`~websockets.exceptions.InvalidHandshake` to abort the
+        connection.
+
+        :rfc:`6455` leaves the rules up to the specification of each
+        :extension.
+
+        To provide this level of flexibility, for each extension accepted by
+        the server, we check for a match with each extension available in the
+        client configuration. If no match is found, an exception is raised.
+
+        If several variants of the same extension are accepted by the server,
+        it may be configured several times, which won't make sense in general.
+        Extensions must implement their own requirements. For this purpose,
+        the list of previously accepted extensions is provided.
+
+        Other requirements, for example related to mandatory extensions or the
+        order of extensions, may be implemented by overriding this method.
+
+        """
+        accepted_extensions: List[Extension] = []
+
+        header_values = headers.get_all("Sec-WebSocket-Extensions")
+
+        if header_values:
+
+            if available_extensions is None:
+                raise InvalidHandshake("no extensions supported")
+
+            parsed_header_values: List[ExtensionHeader] = sum(
+                [parse_extension(header_value) for header_value in header_values], []
+            )
+
+            for name, response_params in parsed_header_values:
+
+                for extension_factory in available_extensions:
+
+                    # Skip non-matching extensions based on their name.
+                    if extension_factory.name != name:
+                        continue
+
+                    # Skip non-matching extensions based on their params.
+                    try:
+                        extension = extension_factory.process_response_params(
+                            response_params, accepted_extensions
+                        )
+                    except NegotiationError:
+                        continue
+
+                    # Add matching extension to the final list.
+                    accepted_extensions.append(extension)
+
+                    # Break out of the loop once we have a match.
+                    break
+
+                # If we didn't break from the loop, no extension in our list
+                # matched what the server sent. Fail the connection.
+                else:
+                    raise NegotiationError(
+                        f"Unsupported extension: "
+                        f"name = {name}, params = {response_params}"
+                    )
+
+        return accepted_extensions
+
+    @staticmethod
+    def process_subprotocol(
+        headers: Headers, available_subprotocols: Optional[Sequence[Subprotocol]]
+    ) -> Optional[Subprotocol]:
+        """
+        Handle the Sec-WebSocket-Protocol HTTP response header.
+
+        Check that it contains exactly one supported subprotocol.
+
+        Return the selected subprotocol.
+
+        """
+        subprotocol: Optional[Subprotocol] = None
+
+        header_values = headers.get_all("Sec-WebSocket-Protocol")
+
+        if header_values:
+
+            if available_subprotocols is None:
+                raise InvalidHandshake("no subprotocols supported")
+
+            parsed_header_values: Sequence[Subprotocol] = sum(
+                [parse_subprotocol(header_value) for header_value in header_values], []
+            )
+
+            if len(parsed_header_values) > 1:
+                subprotocols = ", ".join(parsed_header_values)
+                raise InvalidHandshake(f"multiple subprotocols: {subprotocols}")
+
+            subprotocol = parsed_header_values[0]
+
+            if subprotocol not in available_subprotocols:
+                raise NegotiationError(f"unsupported subprotocol: {subprotocol}")
+
+        return subprotocol
+
+    async def handshake(
+        self,
+        wsuri: WebSocketURI,
+        origin: Optional[Origin] = None,
+        available_extensions: Optional[Sequence[ClientExtensionFactory]] = None,
+        available_subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLike] = None,
+    ) -> None:
+        """
+        Perform the client side of the opening handshake.
+
+        Args:
+            wsuri: URI of the WebSocket server.
+            origin: value of the ``Origin`` header.
+            available_extensions: list of supported extensions, in order in
+                which they should be tried.
+            available_subprotocols: list of supported subprotocols, in order
+                of decreasing preference.
+            extra_headers: arbitrary HTTP headers to add to the request.
+
+        Raises:
+            InvalidHandshake: if the handshake fails.
+
+        """
+        request_headers = Headers()
+
+        request_headers["Host"] = build_host(wsuri.host, wsuri.port, wsuri.secure)
+
+        if wsuri.user_info:
+            request_headers["Authorization"] = build_authorization_basic(
+                *wsuri.user_info
+            )
+
+        if origin is not None:
+            request_headers["Origin"] = origin
+
+        key = build_request(request_headers)
+
+        if available_extensions is not None:
+            extensions_header = build_extension(
+                [
+                    (extension_factory.name, extension_factory.get_request_params())
+                    for extension_factory in available_extensions
+                ]
+            )
+            request_headers["Sec-WebSocket-Extensions"] = extensions_header
+
+        if available_subprotocols is not None:
+            protocol_header = build_subprotocol(available_subprotocols)
+            request_headers["Sec-WebSocket-Protocol"] = protocol_header
+
+        if self.extra_headers is not None:
+            request_headers.update(self.extra_headers)
+
+        request_headers.setdefault("User-Agent", USER_AGENT)
+
+        self.write_http_request(wsuri.resource_name, request_headers)
+
+        status_code, response_headers = await self.read_http_response()
+        if status_code in (301, 302, 303, 307, 308):
+            if "Location" not in response_headers:
+                raise InvalidHeader("Location")
+            raise RedirectHandshake(response_headers["Location"])
+        elif status_code != 101:
+            raise InvalidStatusCode(status_code, response_headers)
+
+        check_response(response_headers, key)
+
+        self.extensions = self.process_extensions(
+            response_headers, available_extensions
+        )
+
+        self.subprotocol = self.process_subprotocol(
+            response_headers, available_subprotocols
+        )
+
+        self.connection_open()
+
+
+class Connect:
+    """
+    Connect to the WebSocket server at ``uri``.
+
+    Awaiting :func:`connect` yields a :class:`WebSocketClientProtocol` which
+    can then be used to send and receive messages.
+
+    :func:`connect` can be used as a asynchronous context manager::
+
+        async with websockets.connect(...) as websocket:
+            ...
+
+    The connection is closed automatically when exiting the context.
+
+    :func:`connect` can be used as an infinite asynchronous iterator to
+    reconnect automatically on errors::
+
+        async for websocket in websockets.connect(...):
+            try:
+                ...
+            except websockets.ConnectionClosed:
+                continue
+
+    The connection is closed automatically after each iteration of the loop.
+
+    If an error occurs while establishing the connection, :func:`connect`
+    retries with exponential backoff. The backoff delay starts at three
+    seconds and increases up to one minute.
+
+    If an error occurs in the body of the loop, you can handle the exception
+    and :func:`connect` will reconnect with the next iteration; or you can
+    let the exception bubble up and break out of the loop. This lets you
+    decide which errors trigger a reconnection and which errors are fatal.
+
+    Args:
+        uri: URI of the WebSocket server.
+        create_protocol: factory for the :class:`asyncio.Protocol` managing
+            the connection; defaults to :class:`WebSocketClientProtocol`; may
+            be set to a wrapper or a subclass to customize connection handling.
+        logger: logger for this connection;
+            defaults to ``logging.getLogger("websockets.client")``;
+            see the :doc:`logging guide <../topics/logging>` for details.
+        compression: shortcut that enables the "permessage-deflate" extension
+            by default; may be set to :obj:`None` to disable compression;
+            see the :doc:`compression guide <../topics/compression>` for details.
+        origin: value of the ``Origin`` header. This is useful when connecting
+            to a server that validates the ``Origin`` header to defend against
+            Cross-Site WebSocket Hijacking attacks.
+        extensions: list of supported extensions, in order in which they
+            should be tried.
+        subprotocols: list of supported subprotocols, in order of decreasing
+            preference.
+        extra_headers: arbitrary HTTP headers to add to the request.
+        open_timeout: timeout for opening the connection in seconds;
+            :obj:`None` to disable the timeout
+
+    See :class:`~websockets.legacy.protocol.WebSocketCommonProtocol` for the
+    documentation of ``ping_interval``, ``ping_timeout``, ``close_timeout``,
+    ``max_size``, ``max_queue``, ``read_limit``, and ``write_limit``.
+
+    Any other keyword arguments are passed the event loop's
+    :meth:`~asyncio.loop.create_connection` method.
+
+    For example:
+
+    * You can set ``ssl`` to a :class:`~ssl.SSLContext` to enforce TLS
+      settings. When connecting to a ``wss://`` URI, if ``ssl`` isn't
+      provided, a TLS context is created
+      with :func:`~ssl.create_default_context`.
+
+    * You can set ``host`` and ``port`` to connect to a different host and
+      port from those found in ``uri``. This only changes the destination of
+      the TCP connection. The host name from ``uri`` is still used in the TLS
+      handshake for secure connections and in the ``Host`` header.
+
+    Returns:
+        WebSocketClientProtocol: WebSocket connection.
+
+    Raises:
+        InvalidURI: if ``uri`` isn't a valid WebSocket URI.
+        InvalidHandshake: if the opening handshake fails.
+        ~asyncio.TimeoutError: if the opening handshake times out.
+
+    """
+
+    MAX_REDIRECTS_ALLOWED = 10
+
+    def __init__(
+        self,
+        uri: str,
+        *,
+        create_protocol: Optional[Callable[[Any], WebSocketClientProtocol]] = None,
+        logger: Optional[LoggerLike] = None,
+        compression: Optional[str] = "deflate",
+        origin: Optional[Origin] = None,
+        extensions: Optional[Sequence[ClientExtensionFactory]] = None,
+        subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLike] = None,
+        open_timeout: Optional[float] = 10,
+        ping_interval: Optional[float] = 20,
+        ping_timeout: Optional[float] = 20,
+        close_timeout: Optional[float] = None,
+        max_size: Optional[int] = 2**20,
+        max_queue: Optional[int] = 2**5,
+        read_limit: int = 2**16,
+        write_limit: int = 2**16,
+        **kwargs: Any,
+    ) -> None:
+        # Backwards compatibility: close_timeout used to be called timeout.
+        timeout: Optional[float] = kwargs.pop("timeout", None)
+        if timeout is None:
+            timeout = 10
+        else:
+            warnings.warn("rename timeout to close_timeout", DeprecationWarning)
+        # If both are specified, timeout is ignored.
+        if close_timeout is None:
+            close_timeout = timeout
+
+        # Backwards compatibility: create_protocol used to be called klass.
+        klass: Optional[Type[WebSocketClientProtocol]] = kwargs.pop("klass", None)
+        if klass is None:
+            klass = WebSocketClientProtocol
+        else:
+            warnings.warn("rename klass to create_protocol", DeprecationWarning)
+        # If both are specified, klass is ignored.
+        if create_protocol is None:
+            create_protocol = klass
+
+        # Backwards compatibility: recv() used to return None on closed connections
+        legacy_recv: bool = kwargs.pop("legacy_recv", False)
+
+        # Backwards compatibility: the loop parameter used to be supported.
+        _loop: Optional[asyncio.AbstractEventLoop] = kwargs.pop("loop", None)
+        if _loop is None:
+            loop = asyncio.get_event_loop()
+        else:
+            loop = _loop
+            warnings.warn("remove loop argument", DeprecationWarning)
+
+        wsuri = parse_uri(uri)
+        if wsuri.secure:
+            kwargs.setdefault("ssl", True)
+        elif kwargs.get("ssl") is not None:
+            raise ValueError(
+                "connect() received a ssl argument for a ws:// URI, "
+                "use a wss:// URI to enable TLS"
+            )
+
+        if compression == "deflate":
+            extensions = enable_client_permessage_deflate(extensions)
+        elif compression is not None:
+            raise ValueError(f"unsupported compression: {compression}")
+
+        if subprotocols is not None:
+            validate_subprotocols(subprotocols)
+
+        factory = functools.partial(
+            create_protocol,
+            logger=logger,
+            origin=origin,
+            extensions=extensions,
+            subprotocols=subprotocols,
+            extra_headers=extra_headers,
+            ping_interval=ping_interval,
+            ping_timeout=ping_timeout,
+            close_timeout=close_timeout,
+            max_size=max_size,
+            max_queue=max_queue,
+            read_limit=read_limit,
+            write_limit=write_limit,
+            host=wsuri.host,
+            port=wsuri.port,
+            secure=wsuri.secure,
+            legacy_recv=legacy_recv,
+            loop=_loop,
+        )
+
+        if kwargs.pop("unix", False):
+            path: Optional[str] = kwargs.pop("path", None)
+            create_connection = functools.partial(
+                loop.create_unix_connection, factory, path, **kwargs
+            )
+        else:
+            host: Optional[str]
+            port: Optional[int]
+            if kwargs.get("sock") is None:
+                host, port = wsuri.host, wsuri.port
+            else:
+                # If sock is given, host and port shouldn't be specified.
+                host, port = None, None
+            # If host and port are given, override values from the URI.
+            host = kwargs.pop("host", host)
+            port = kwargs.pop("port", port)
+            create_connection = functools.partial(
+                loop.create_connection, factory, host, port, **kwargs
+            )
+
+        self.open_timeout = open_timeout
+        if logger is None:
+            logger = logging.getLogger("websockets.client")
+        self.logger = logger
+
+        # This is a coroutine function.
+        self._create_connection = create_connection
+        self._uri = uri
+        self._wsuri = wsuri
+
+    def handle_redirect(self, uri: str) -> None:
+        # Update the state of this instance to connect to a new URI.
+        old_uri = self._uri
+        old_wsuri = self._wsuri
+        new_uri = urllib.parse.urljoin(old_uri, uri)
+        new_wsuri = parse_uri(new_uri)
+
+        # Forbid TLS downgrade.
+        if old_wsuri.secure and not new_wsuri.secure:
+            raise SecurityError("redirect from WSS to WS")
+
+        same_origin = (
+            old_wsuri.host == new_wsuri.host and old_wsuri.port == new_wsuri.port
+        )
+
+        # Rewrite the host and port arguments for cross-origin redirects.
+        # This preserves connection overrides with the host and port
+        # arguments if the redirect points to the same host and port.
+        if not same_origin:
+            # Replace the host and port argument passed to the protocol factory.
+            factory = self._create_connection.args[0]
+            factory = functools.partial(
+                factory.func,
+                *factory.args,
+                **dict(factory.keywords, host=new_wsuri.host, port=new_wsuri.port),
+            )
+            # Replace the host and port argument passed to create_connection.
+            self._create_connection = functools.partial(
+                self._create_connection.func,
+                *(factory, new_wsuri.host, new_wsuri.port),
+                **self._create_connection.keywords,
+            )
+
+        # Set the new WebSocket URI. This suffices for same-origin redirects.
+        self._uri = new_uri
+        self._wsuri = new_wsuri
+
+    # async for ... in connect(...):
+
+    BACKOFF_MIN = 1.92
+    BACKOFF_MAX = 60.0
+    BACKOFF_FACTOR = 1.618
+    BACKOFF_INITIAL = 5
+
+    async def __aiter__(self) -> AsyncIterator[WebSocketClientProtocol]:
+        backoff_delay = self.BACKOFF_MIN
+        while True:
+            try:
+                async with self as protocol:
+                    yield protocol
+            # Remove this branch when dropping support for Python < 3.8
+            # because CancelledError no longer inherits Exception.
+            except asyncio.CancelledError:  # pragma: no cover
+                raise
+            except Exception:
+                # Add a random initial delay between 0 and 5 seconds.
+                # See 7.2.3. Recovering from Abnormal Closure in RFC 6544.
+                if backoff_delay == self.BACKOFF_MIN:
+                    initial_delay = random.random() * self.BACKOFF_INITIAL
+                    self.logger.info(
+                        "! connect failed; reconnecting in %.1f seconds",
+                        initial_delay,
+                        exc_info=True,
+                    )
+                    await asyncio.sleep(initial_delay)
+                else:
+                    self.logger.info(
+                        "! connect failed again; retrying in %d seconds",
+                        int(backoff_delay),
+                        exc_info=True,
+                    )
+                    await asyncio.sleep(int(backoff_delay))
+                # Increase delay with truncated exponential backoff.
+                backoff_delay = backoff_delay * self.BACKOFF_FACTOR
+                backoff_delay = min(backoff_delay, self.BACKOFF_MAX)
+                continue
+            else:
+                # Connection succeeded - reset backoff delay
+                backoff_delay = self.BACKOFF_MIN
+
+    # async with connect(...) as ...:
+
+    async def __aenter__(self) -> WebSocketClientProtocol:
+        return await self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        await self.protocol.close()
+
+    # ... = await connect(...)
+
+    def __await__(self) -> Generator[Any, None, WebSocketClientProtocol]:
+        # Create a suitable iterator by calling __await__ on a coroutine.
+        return self.__await_impl_timeout__().__await__()
+
+    async def __await_impl_timeout__(self) -> WebSocketClientProtocol:
+        return await asyncio.wait_for(self.__await_impl__(), self.open_timeout)
+
+    async def __await_impl__(self) -> WebSocketClientProtocol:
+        for redirects in range(self.MAX_REDIRECTS_ALLOWED):
+            transport, protocol = await self._create_connection()
+            protocol = cast(WebSocketClientProtocol, protocol)
+
+            try:
+                await protocol.handshake(
+                    self._wsuri,
+                    origin=protocol.origin,
+                    available_extensions=protocol.available_extensions,
+                    available_subprotocols=protocol.available_subprotocols,
+                    extra_headers=protocol.extra_headers,
+                )
+            except RedirectHandshake as exc:
+                protocol.fail_connection()
+                await protocol.wait_closed()
+                self.handle_redirect(exc.uri)
+            # Avoid leaking a connected socket when the handshake fails.
+            except (Exception, asyncio.CancelledError):
+                protocol.fail_connection()
+                await protocol.wait_closed()
+                raise
+            else:
+                self.protocol = protocol
+                return protocol
+        else:
+            raise SecurityError("too many redirects")
+
+    # ... = yield from connect(...) - remove when dropping Python < 3.10
+
+    __iter__ = __await__
+
+
+connect = Connect
+
+
+def unix_connect(
+    path: Optional[str] = None,
+    uri: str = "ws://localhost/",
+    **kwargs: Any,
+) -> Connect:
+    """
+    Similar to :func:`connect`, but for connecting to a Unix socket.
+
+    This function builds upon the event loop's
+    :meth:`~asyncio.loop.create_unix_connection` method.
+
+    It is only available on Unix.
+
+    It's mainly useful for debugging servers listening on Unix sockets.
+
+    Args:
+        path: file system path to the Unix socket.
+        uri: URI of the WebSocket server; the host is used in the TLS
+            handshake for secure connections and in the ``Host`` header.
+
+    """
+    return connect(uri=uri, path=path, unix=True, **kwargs)
diff --git a/myenv/lib/python3.9/site-packages/websockets/legacy/compatibility.py b/myenv/lib/python3.9/site-packages/websockets/legacy/compatibility.py
new file mode 100644
index 0000000..df81de9
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/legacy/compatibility.py
@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+from typing import Any, Dict
+
+
+def loop_if_py_lt_38(loop: asyncio.AbstractEventLoop) -> Dict[str, Any]:
+    """
+    Helper for the removal of the loop argument in Python 3.10.
+
+    """
+    return {"loop": loop} if sys.version_info[:2] < (3, 8) else {}
diff --git a/myenv/lib/python3.9/site-packages/websockets/legacy/framing.py b/myenv/lib/python3.9/site-packages/websockets/legacy/framing.py
new file mode 100644
index 0000000..c4de7eb
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/legacy/framing.py
@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import dataclasses
+import struct
+from typing import Any, Awaitable, Callable, NamedTuple, Optional, Sequence, Tuple
+
+from .. import extensions, frames
+from ..exceptions import PayloadTooBig, ProtocolError
+
+
+try:
+    from ..speedups import apply_mask
+except ImportError:  # pragma: no cover
+    from ..utils import apply_mask
+
+
+class Frame(NamedTuple):
+
+    fin: bool
+    opcode: frames.Opcode
+    data: bytes
+    rsv1: bool = False
+    rsv2: bool = False
+    rsv3: bool = False
+
+    @property
+    def new_frame(self) -> frames.Frame:
+        return frames.Frame(
+            self.opcode,
+            self.data,
+            self.fin,
+            self.rsv1,
+            self.rsv2,
+            self.rsv3,
+        )
+
+    def __str__(self) -> str:
+        return str(self.new_frame)
+
+    def check(self) -> None:
+        return self.new_frame.check()
+
+    @classmethod
+    async def read(
+        cls,
+        reader: Callable[[int], Awaitable[bytes]],
+        *,
+        mask: bool,
+        max_size: Optional[int] = None,
+        extensions: Optional[Sequence[extensions.Extension]] = None,
+    ) -> Frame:
+        """
+        Read a WebSocket frame.
+
+        Args:
+            reader: coroutine that reads exactly the requested number of
+                bytes, unless the end of file is reached.
+            mask: whether the frame should be masked i.e. whether the read
+                happens on the server side.
+            max_size: maximum payload size in bytes.
+            extensions: list of extensions, applied in reverse order.
+
+        Raises:
+            PayloadTooBig: if the frame exceeds ``max_size``.
+            ProtocolError: if the frame contains incorrect values.
+
+        """
+
+        # Read the header.
+        data = await reader(2)
+        head1, head2 = struct.unpack("!BB", data)
+
+        # While not Pythonic, this is marginally faster than calling bool().
+        fin = True if head1 & 0b10000000 else False
+        rsv1 = True if head1 & 0b01000000 else False
+        rsv2 = True if head1 & 0b00100000 else False
+        rsv3 = True if head1 & 0b00010000 else False
+
+        try:
+            opcode = frames.Opcode(head1 & 0b00001111)
+        except ValueError as exc:
+            raise ProtocolError("invalid opcode") from exc
+
+        if (True if head2 & 0b10000000 else False) != mask:
+            raise ProtocolError("incorrect masking")
+
+        length = head2 & 0b01111111
+        if length == 126:
+            data = await reader(2)
+            (length,) = struct.unpack("!H", data)
+        elif length == 127:
+            data = await reader(8)
+            (length,) = struct.unpack("!Q", data)
+        if max_size is not None and length > max_size:
+            raise PayloadTooBig(f"over size limit ({length} > {max_size} bytes)")
+        if mask:
+            mask_bits = await reader(4)
+
+        # Read the data.
+        data = await reader(length)
+        if mask:
+            data = apply_mask(data, mask_bits)
+
+        new_frame = frames.Frame(opcode, data, fin, rsv1, rsv2, rsv3)
+
+        if extensions is None:
+            extensions = []
+        for extension in reversed(extensions):
+            new_frame = extension.decode(new_frame, max_size=max_size)
+
+        new_frame.check()
+
+        return cls(
+            new_frame.fin,
+            new_frame.opcode,
+            new_frame.data,
+            new_frame.rsv1,
+            new_frame.rsv2,
+            new_frame.rsv3,
+        )
+
+    def write(
+        self,
+        write: Callable[[bytes], Any],
+        *,
+        mask: bool,
+        extensions: Optional[Sequence[extensions.Extension]] = None,
+    ) -> None:
+        """
+        Write a WebSocket frame.
+
+        Args:
+            frame: frame to write.
+            write: function that writes bytes.
+            mask: whether the frame should be masked i.e. whether the write
+                happens on the client side.
+            extensions: list of extensions, applied in order.
+
+        Raises:
+            ProtocolError: if the frame contains incorrect values.
+
+        """
+        # The frame is written in a single call to write in order to prevent
+        # TCP fragmentation. See #68 for details. This also makes it safe to
+        # send frames concurrently from multiple coroutines.
+        write(self.new_frame.serialize(mask=mask, extensions=extensions))
+
+
+# Backwards compatibility with previously documented public APIs
+
+from ..frames import Close, prepare_ctrl as encode_data, prepare_data  # noqa
+
+
+def parse_close(data: bytes) -> Tuple[int, str]:
+    """
+    Parse the payload from a close frame.
+
+    Returns:
+        Tuple[int, str]: close code and reason.
+
+    Raises:
+        ProtocolError: if data is ill-formed.
+        UnicodeDecodeError: if the reason isn't valid UTF-8.
+
+    """
+    return dataclasses.astuple(Close.parse(data))  # type: ignore
+
+
+def serialize_close(code: int, reason: str) -> bytes:
+    """
+    Serialize the payload for a close frame.
+
+    """
+    return Close(code, reason).serialize()
diff --git a/myenv/lib/python3.9/site-packages/websockets/legacy/handshake.py b/myenv/lib/python3.9/site-packages/websockets/legacy/handshake.py
new file mode 100644
index 0000000..569937b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/legacy/handshake.py
@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import base64
+import binascii
+from typing import List
+
+from ..datastructures import Headers, MultipleValuesError
+from ..exceptions import InvalidHeader, InvalidHeaderValue, InvalidUpgrade
+from ..headers import parse_connection, parse_upgrade
+from ..typing import ConnectionOption, UpgradeProtocol
+from ..utils import accept_key as accept, generate_key
+
+
+__all__ = ["build_request", "check_request", "build_response", "check_response"]
+
+
+def build_request(headers: Headers) -> str:
+    """
+    Build a handshake request to send to the server.
+
+    Update request headers passed in argument.
+
+    Args:
+        headers: handshake request headers.
+
+    Returns:
+        str: ``key`` that must be passed to :func:`check_response`.
+
+    """
+    key = generate_key()
+    headers["Upgrade"] = "websocket"
+    headers["Connection"] = "Upgrade"
+    headers["Sec-WebSocket-Key"] = key
+    headers["Sec-WebSocket-Version"] = "13"
+    return key
+
+
+def check_request(headers: Headers) -> str:
+    """
+    Check a handshake request received from the client.
+
+    This function doesn't verify that the request is an HTTP/1.1 or higher GET
+    request and doesn't perform ``Host`` and ``Origin`` checks. These controls
+    are usually performed earlier in the HTTP request handling code. They're
+    the responsibility of the caller.
+
+    Args:
+        headers: handshake request headers.
+
+    Returns:
+        str: ``key`` that must be passed to :func:`build_response`.
+
+    Raises:
+        InvalidHandshake: if the handshake request is invalid;
+            then the server must return 400 Bad Request error.
+
+    """
+    connection: List[ConnectionOption] = sum(
+        [parse_connection(value) for value in headers.get_all("Connection")], []
+    )
+
+    if not any(value.lower() == "upgrade" for value in connection):
+        raise InvalidUpgrade("Connection", ", ".join(connection))
+
+    upgrade: List[UpgradeProtocol] = sum(
+        [parse_upgrade(value) for value in headers.get_all("Upgrade")], []
+    )
+
+    # For compatibility with non-strict implementations, ignore case when
+    # checking the Upgrade header. The RFC always uses "websocket", except
+    # in section 11.2. (IANA registration) where it uses "WebSocket".
+    if not (len(upgrade) == 1 and upgrade[0].lower() == "websocket"):
+        raise InvalidUpgrade("Upgrade", ", ".join(upgrade))
+
+    try:
+        s_w_key = headers["Sec-WebSocket-Key"]
+    except KeyError as exc:
+        raise InvalidHeader("Sec-WebSocket-Key") from exc
+    except MultipleValuesError as exc:
+        raise InvalidHeader(
+            "Sec-WebSocket-Key", "more than one Sec-WebSocket-Key header found"
+        ) from exc
+
+    try:
+        raw_key = base64.b64decode(s_w_key.encode(), validate=True)
+    except binascii.Error as exc:
+        raise InvalidHeaderValue("Sec-WebSocket-Key", s_w_key) from exc
+    if len(raw_key) != 16:
+        raise InvalidHeaderValue("Sec-WebSocket-Key", s_w_key)
+
+    try:
+        s_w_version = headers["Sec-WebSocket-Version"]
+    except KeyError as exc:
+        raise InvalidHeader("Sec-WebSocket-Version") from exc
+    except MultipleValuesError as exc:
+        raise InvalidHeader(
+            "Sec-WebSocket-Version", "more than one Sec-WebSocket-Version header found"
+        ) from exc
+
+    if s_w_version != "13":
+        raise InvalidHeaderValue("Sec-WebSocket-Version", s_w_version)
+
+    return s_w_key
+
+
+def build_response(headers: Headers, key: str) -> None:
+    """
+    Build a handshake response to send to the client.
+
+    Update response headers passed in argument.
+
+    Args:
+        headers: handshake response headers.
+        key: returned by :func:`check_request`.
+
+    """
+    headers["Upgrade"] = "websocket"
+    headers["Connection"] = "Upgrade"
+    headers["Sec-WebSocket-Accept"] = accept(key)
+
+
+def check_response(headers: Headers, key: str) -> None:
+    """
+    Check a handshake response received from the server.
+
+    This function doesn't verify that the response is an HTTP/1.1 or higher
+    response with a 101 status code. These controls are the responsibility of
+    the caller.
+
+    Args:
+        headers: handshake response headers.
+        key: returned by :func:`build_request`.
+
+    Raises:
+        InvalidHandshake: if the handshake response is invalid.
+
+    """
+    connection: List[ConnectionOption] = sum(
+        [parse_connection(value) for value in headers.get_all("Connection")], []
+    )
+
+    if not any(value.lower() == "upgrade" for value in connection):
+        raise InvalidUpgrade("Connection", " ".join(connection))
+
+    upgrade: List[UpgradeProtocol] = sum(
+        [parse_upgrade(value) for value in headers.get_all("Upgrade")], []
+    )
+
+    # For compatibility with non-strict implementations, ignore case when
+    # checking the Upgrade header. The RFC always uses "websocket", except
+    # in section 11.2. (IANA registration) where it uses "WebSocket".
+    if not (len(upgrade) == 1 and upgrade[0].lower() == "websocket"):
+        raise InvalidUpgrade("Upgrade", ", ".join(upgrade))
+
+    try:
+        s_w_accept = headers["Sec-WebSocket-Accept"]
+    except KeyError as exc:
+        raise InvalidHeader("Sec-WebSocket-Accept") from exc
+    except MultipleValuesError as exc:
+        raise InvalidHeader(
+            "Sec-WebSocket-Accept", "more than one Sec-WebSocket-Accept header found"
+        ) from exc
+
+    if s_w_accept != accept(key):
+        raise InvalidHeaderValue("Sec-WebSocket-Accept", s_w_accept)
diff --git a/myenv/lib/python3.9/site-packages/websockets/legacy/http.py b/myenv/lib/python3.9/site-packages/websockets/legacy/http.py
new file mode 100644
index 0000000..cc2ef1f
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/legacy/http.py
@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import asyncio
+import re
+from typing import Tuple
+
+from ..datastructures import Headers
+from ..exceptions import SecurityError
+
+
+__all__ = ["read_request", "read_response"]
+
+MAX_HEADERS = 256
+MAX_LINE = 4110
+
+
+def d(value: bytes) -> str:
+    """
+    Decode a bytestring for interpolating into an error message.
+
+    """
+    return value.decode(errors="backslashreplace")
+
+
+# See https://www.rfc-editor.org/rfc/rfc7230.html#appendix-B.
+
+# Regex for validating header names.
+
+_token_re = re.compile(rb"[-!#$%&\'*+.^_`|~0-9a-zA-Z]+")
+
+# Regex for validating header values.
+
+# We don't attempt to support obsolete line folding.
+
+# Include HTAB (\x09), SP (\x20), VCHAR (\x21-\x7e), obs-text (\x80-\xff).
+
+# The ABNF is complicated because it attempts to express that optional
+# whitespace is ignored. We strip whitespace and don't revalidate that.
+
+# See also https://www.rfc-editor.org/errata_search.php?rfc=7230&eid=4189
+
+_value_re = re.compile(rb"[\x09\x20-\x7e\x80-\xff]*")
+
+
+async def read_request(stream: asyncio.StreamReader) -> Tuple[str, Headers]:
+    """
+    Read an HTTP/1.1 GET request and return ``(path, headers)``.
+
+    ``path`` isn't URL-decoded or validated in any way.
+
+    ``path`` and ``headers`` are expected to contain only ASCII characters.
+    Other characters are represented with surrogate escapes.
+
+    :func:`read_request` doesn't attempt to read the request body because
+    WebSocket handshake requests don't have one. If the request contains a
+    body, it may be read from ``stream`` after this coroutine returns.
+
+    Args:
+        stream: input to read the request from
+
+    Raises:
+        EOFError: if the connection is closed without a full HTTP request
+        SecurityError: if the request exceeds a security limit
+        ValueError: if the request isn't well formatted
+
+    """
+    # https://www.rfc-editor.org/rfc/rfc7230.html#section-3.1.1
+
+    # Parsing is simple because fixed values are expected for method and
+    # version and because path isn't checked. Since WebSocket software tends
+    # to implement HTTP/1.1 strictly, there's little need for lenient parsing.
+
+    try:
+        request_line = await read_line(stream)
+    except EOFError as exc:
+        raise EOFError("connection closed while reading HTTP request line") from exc
+
+    try:
+        method, raw_path, version = request_line.split(b" ", 2)
+    except ValueError:  # not enough values to unpack (expected 3, got 1-2)
+        raise ValueError(f"invalid HTTP request line: {d(request_line)}") from None
+
+    if method != b"GET":
+        raise ValueError(f"unsupported HTTP method: {d(method)}")
+    if version != b"HTTP/1.1":
+        raise ValueError(f"unsupported HTTP version: {d(version)}")
+    path = raw_path.decode("ascii", "surrogateescape")
+
+    headers = await read_headers(stream)
+
+    return path, headers
+
+
+async def read_response(stream: asyncio.StreamReader) -> Tuple[int, str, Headers]:
+    """
+    Read an HTTP/1.1 response and return ``(status_code, reason, headers)``.
+
+    ``reason`` and ``headers`` are expected to contain only ASCII characters.
+    Other characters are represented with surrogate escapes.
+
+    :func:`read_request` doesn't attempt to read the response body because
+    WebSocket handshake responses don't have one. If the response contains a
+    body, it may be read from ``stream`` after this coroutine returns.
+
+    Args:
+        stream: input to read the response from
+
+    Raises:
+        EOFError: if the connection is closed without a full HTTP response
+        SecurityError: if the response exceeds a security limit
+        ValueError: if the response isn't well formatted
+
+    """
+    # https://www.rfc-editor.org/rfc/rfc7230.html#section-3.1.2
+
+    # As in read_request, parsing is simple because a fixed value is expected
+    # for version, status_code is a 3-digit number, and reason can be ignored.
+
+    try:
+        status_line = await read_line(stream)
+    except EOFError as exc:
+        raise EOFError("connection closed while reading HTTP status line") from exc
+
+    try:
+        version, raw_status_code, raw_reason = status_line.split(b" ", 2)
+    except ValueError:  # not enough values to unpack (expected 3, got 1-2)
+        raise ValueError(f"invalid HTTP status line: {d(status_line)}") from None
+
+    if version != b"HTTP/1.1":
+        raise ValueError(f"unsupported HTTP version: {d(version)}")
+    try:
+        status_code = int(raw_status_code)
+    except ValueError:  # invalid literal for int() with base 10
+        raise ValueError(f"invalid HTTP status code: {d(raw_status_code)}") from None
+    if not 100 <= status_code < 1000:
+        raise ValueError(f"unsupported HTTP status code: {d(raw_status_code)}")
+    if not _value_re.fullmatch(raw_reason):
+        raise ValueError(f"invalid HTTP reason phrase: {d(raw_reason)}")
+    reason = raw_reason.decode()
+
+    headers = await read_headers(stream)
+
+    return status_code, reason, headers
+
+
+async def read_headers(stream: asyncio.StreamReader) -> Headers:
+    """
+    Read HTTP headers from ``stream``.
+
+    Non-ASCII characters are represented with surrogate escapes.
+
+    """
+    # https://www.rfc-editor.org/rfc/rfc7230.html#section-3.2
+
+    # We don't attempt to support obsolete line folding.
+
+    headers = Headers()
+    for _ in range(MAX_HEADERS + 1):
+        try:
+            line = await read_line(stream)
+        except EOFError as exc:
+            raise EOFError("connection closed while reading HTTP headers") from exc
+        if line == b"":
+            break
+
+        try:
+            raw_name, raw_value = line.split(b":", 1)
+        except ValueError:  # not enough values to unpack (expected 2, got 1)
+            raise ValueError(f"invalid HTTP header line: {d(line)}") from None
+        if not _token_re.fullmatch(raw_name):
+            raise ValueError(f"invalid HTTP header name: {d(raw_name)}")
+        raw_value = raw_value.strip(b" \t")
+        if not _value_re.fullmatch(raw_value):
+            raise ValueError(f"invalid HTTP header value: {d(raw_value)}")
+
+        name = raw_name.decode("ascii")  # guaranteed to be ASCII at this point
+        value = raw_value.decode("ascii", "surrogateescape")
+        headers[name] = value
+
+    else:
+        raise SecurityError("too many HTTP headers")
+
+    return headers
+
+
+async def read_line(stream: asyncio.StreamReader) -> bytes:
+    """
+    Read a single line from ``stream``.
+
+    CRLF is stripped from the return value.
+
+    """
+    # Security: this is bounded by the StreamReader's limit (default = 32 KiB).
+    line = await stream.readline()
+    # Security: this guarantees header values are small (hard-coded = 4 KiB)
+    if len(line) > MAX_LINE:
+        raise SecurityError("line too long")
+    # Not mandatory but safe - https://www.rfc-editor.org/rfc/rfc7230.html#section-3.5
+    if not line.endswith(b"\r\n"):
+        raise EOFError("line without CRLF")
+    return line[:-2]
diff --git a/myenv/lib/python3.9/site-packages/websockets/legacy/protocol.py b/myenv/lib/python3.9/site-packages/websockets/legacy/protocol.py
new file mode 100644
index 0000000..d1d52bf
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/legacy/protocol.py
@@ -0,0 +1,1605 @@
+from __future__ import annotations
+
+import asyncio
+import codecs
+import collections
+import logging
+import random
+import ssl
+import struct
+import uuid
+import warnings
+from typing import (
+    Any,
+    AsyncIterable,
+    AsyncIterator,
+    Awaitable,
+    Deque,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Union,
+    cast,
+)
+
+from ..connection import State
+from ..datastructures import Headers
+from ..exceptions import (
+    ConnectionClosed,
+    ConnectionClosedError,
+    ConnectionClosedOK,
+    InvalidState,
+    PayloadTooBig,
+    ProtocolError,
+)
+from ..extensions import Extension
+from ..frames import (
+    OK_CLOSE_CODES,
+    OP_BINARY,
+    OP_CLOSE,
+    OP_CONT,
+    OP_PING,
+    OP_PONG,
+    OP_TEXT,
+    Close,
+    Opcode,
+    prepare_ctrl,
+    prepare_data,
+)
+from ..typing import Data, LoggerLike, Subprotocol
+from .compatibility import loop_if_py_lt_38
+from .framing import Frame
+
+
+__all__ = ["WebSocketCommonProtocol", "broadcast"]
+
+
+# In order to ensure consistency, the code always checks the current value of
+# WebSocketCommonProtocol.state before assigning a new value and never yields
+# between the check and the assignment.
+
+
+class WebSocketCommonProtocol(asyncio.Protocol):
+    """
+    WebSocket connection.
+
+    :class:`WebSocketCommonProtocol` provides APIs shared between WebSocket
+    servers and clients. You shouldn't use it directly. Instead, use
+    :class:`~websockets.client.WebSocketClientProtocol` or
+    :class:`~websockets.server.WebSocketServerProtocol`.
+
+    This documentation focuses on low-level details that aren't covered in the
+    documentation of :class:`~websockets.client.WebSocketClientProtocol` and
+    :class:`~websockets.server.WebSocketServerProtocol` for the sake of
+    simplicity.
+
+    Once the connection is open, a Ping_ frame is sent every ``ping_interval``
+    seconds. This serves as a keepalive. It helps keeping the connection
+    open, especially in the presence of proxies with short timeouts on
+    inactive connections. Set ``ping_interval`` to :obj:`None` to disable
+    this behavior.
+
+    .. _Ping: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.5.2
+
+    If the corresponding Pong_ frame isn't received within ``ping_timeout``
+    seconds, the connection is considered unusable and is closed with code
+    1011. This ensures that the remote endpoint remains responsive. Set
+    ``ping_timeout`` to :obj:`None` to disable this behavior.
+
+    .. _Pong: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.5.3
+
+    The ``close_timeout`` parameter defines a maximum wait time for completing
+    the closing handshake and terminating the TCP connection. For legacy
+    reasons, :meth:`close` completes in at most ``5 * close_timeout`` seconds
+    for clients and ``4 * close_timeout`` for servers.
+
+    See the discussion of :doc:`timeouts <../topics/timeouts>` for details.
+
+    ``close_timeout`` needs to be a parameter of the protocol because
+    websockets usually calls :meth:`close` implicitly upon exit:
+
+    * on the client side, when :func:`~websockets.client.connect` is used as a
+      context manager;
+    * on the server side, when the connection handler terminates;
+
+    To apply a timeout to any other API, wrap it in :func:`~asyncio.wait_for`.
+
+    The ``max_size`` parameter enforces the maximum size for incoming messages
+    in bytes. The default value is 1 MiB. If a larger message is received,
+    :meth:`recv` will raise :exc:`~websockets.exceptions.ConnectionClosedError`
+    and the connection will be closed with code 1009.
+
+    The ``max_queue`` parameter sets the maximum length of the queue that
+    holds incoming messages. The default value is ``32``. Messages are added
+    to an in-memory queue when they're received; then :meth:`recv` pops from
+    that queue. In order to prevent excessive memory consumption when
+    messages are received faster than they can be processed, the queue must
+    be bounded. If the queue fills up, the protocol stops processing incoming
+    data until :meth:`recv` is called. In this situation, various receive
+    buffers (at least in :mod:`asyncio` and in the OS) will fill up, then the
+    TCP receive window will shrink, slowing down transmission to avoid packet
+    loss.
+
+    Since Python can use up to 4 bytes of memory to represent a single
+    character, each connection may use up to ``4 * max_size * max_queue``
+    bytes of memory to store incoming messages. By default, this is 128 MiB.
+    You may want to lower the limits, depending on your application's
+    requirements.
+
+    The ``read_limit`` argument sets the high-water limit of the buffer for
+    incoming bytes. The low-water limit is half the high-water limit. The
+    default value is 64 KiB, half of asyncio's default (based on the current
+    implementation of :class:`~asyncio.StreamReader`).
+
+    The ``write_limit`` argument sets the high-water limit of the buffer for
+    outgoing bytes. The low-water limit is a quarter of the high-water limit.
+    The default value is 64 KiB, equal to asyncio's default (based on the
+    current implementation of ``FlowControlMixin``).
+
+    See the discussion of :doc:`memory usage <../topics/memory>` for details.
+
+    Args:
+        logger: logger for this connection;
+            defaults to ``logging.getLogger("websockets.protocol")``;
+            see the :doc:`logging guide <../topics/logging>` for details.
+        ping_interval: delay between keepalive pings in seconds;
+            :obj:`None` to disable keepalive pings.
+        ping_timeout: timeout for keepalive pings in seconds;
+            :obj:`None` to disable timeouts.
+        close_timeout: timeout for closing the connection in seconds;
+            for legacy reasons, the actual timeout is 4 or 5 times larger.
+        max_size: maximum size of incoming messages in bytes;
+            :obj:`None` to disable the limit.
+        max_queue: maximum number of incoming messages in receive buffer;
+            :obj:`None` to disable the limit.
+        read_limit: high-water mark of read buffer in bytes.
+        write_limit: high-water mark of write buffer in bytes.
+
+    """
+
+    # There are only two differences between the client-side and server-side
+    # behavior: masking the payload and closing the underlying TCP connection.
+    # Set is_client = True/False and side = "client"/"server" to pick a side.
+    is_client: bool
+    side: str = "undefined"
+
+    def __init__(
+        self,
+        *,
+        logger: Optional[LoggerLike] = None,
+        ping_interval: Optional[float] = 20,
+        ping_timeout: Optional[float] = 20,
+        close_timeout: Optional[float] = None,
+        max_size: Optional[int] = 2**20,
+        max_queue: Optional[int] = 2**5,
+        read_limit: int = 2**16,
+        write_limit: int = 2**16,
+        # The following arguments are kept only for backwards compatibility.
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        secure: Optional[bool] = None,
+        legacy_recv: bool = False,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
+        if legacy_recv:  # pragma: no cover
+            warnings.warn("legacy_recv is deprecated", DeprecationWarning)
+
+        # Backwards compatibility: close_timeout used to be called timeout.
+        if timeout is None:
+            timeout = 10
+        else:
+            warnings.warn("rename timeout to close_timeout", DeprecationWarning)
+        # If both are specified, timeout is ignored.
+        if close_timeout is None:
+            close_timeout = timeout
+
+        # Backwards compatibility: the loop parameter used to be supported.
+        if loop is None:
+            loop = asyncio.get_event_loop()
+        else:
+            warnings.warn("remove loop argument", DeprecationWarning)
+
+        self.ping_interval = ping_interval
+        self.ping_timeout = ping_timeout
+        self.close_timeout = close_timeout
+        self.max_size = max_size
+        self.max_queue = max_queue
+        self.read_limit = read_limit
+        self.write_limit = write_limit
+
+        # Unique identifier. For logs.
+        self.id: uuid.UUID = uuid.uuid4()
+        """Unique identifier of the connection. Useful in logs."""
+
+        # Logger or LoggerAdapter for this connection.
+        if logger is None:
+            logger = logging.getLogger("websockets.protocol")
+        # https://github.com/python/typeshed/issues/5561
+        logger = cast(logging.Logger, logger)
+        self.logger: LoggerLike = logging.LoggerAdapter(logger, {"websocket": self})
+        """Logger for this connection."""
+
+        # Track if DEBUG is enabled. Shortcut logging calls if it isn't.
+        self.debug = logger.isEnabledFor(logging.DEBUG)
+
+        self.loop = loop
+
+        self._host = host
+        self._port = port
+        self._secure = secure
+        self.legacy_recv = legacy_recv
+
+        # Configure read buffer limits. The high-water limit is defined by
+        # ``self.read_limit``. The ``limit`` argument controls the line length
+        # limit and half the buffer limit of :class:`~asyncio.StreamReader`.
+        # That's why it must be set to half of ``self.read_limit``.
+        self.reader = asyncio.StreamReader(limit=read_limit // 2, loop=loop)
+
+        # Copied from asyncio.FlowControlMixin
+        self._paused = False
+        self._drain_waiter: Optional[asyncio.Future[None]] = None
+
+        self._drain_lock = asyncio.Lock(**loop_if_py_lt_38(loop))
+
+        # This class implements the data transfer and closing handshake, which
+        # are shared between the client-side and the server-side.
+        # Subclasses implement the opening handshake and, on success, execute
+        # :meth:`connection_open` to change the state to OPEN.
+        self.state = State.CONNECTING
+        if self.debug:
+            self.logger.debug("= connection is CONNECTING")
+
+        # HTTP protocol parameters.
+        self.path: str
+        """Path of the opening handshake request."""
+        self.request_headers: Headers
+        """Opening handshake request headers."""
+        self.response_headers: Headers
+        """Opening handshake response headers."""
+
+        # WebSocket protocol parameters.
+        self.extensions: List[Extension] = []
+        self.subprotocol: Optional[Subprotocol] = None
+        """Subprotocol, if one was negotiated."""
+
+        # Close code and reason, set when a close frame is sent or received.
+        self.close_rcvd: Optional[Close] = None
+        self.close_sent: Optional[Close] = None
+        self.close_rcvd_then_sent: Optional[bool] = None
+
+        # Completed when the connection state becomes CLOSED. Translates the
+        # :meth:`connection_lost` callback to a :class:`~asyncio.Future`
+        # that can be awaited. (Other :class:`~asyncio.Protocol` callbacks are
+        # translated by ``self.stream_reader``).
+        self.connection_lost_waiter: asyncio.Future[None] = loop.create_future()
+
+        # Queue of received messages.
+        self.messages: Deque[Data] = collections.deque()
+        self._pop_message_waiter: Optional[asyncio.Future[None]] = None
+        self._put_message_waiter: Optional[asyncio.Future[None]] = None
+
+        # Protect sending fragmented messages.
+        self._fragmented_message_waiter: Optional[asyncio.Future[None]] = None
+
+        # Mapping of ping IDs to pong waiters, in chronological order.
+        self.pings: Dict[bytes, asyncio.Future[None]] = {}
+
+        # Task running the data transfer.
+        self.transfer_data_task: asyncio.Task[None]
+
+        # Exception that occurred during data transfer, if any.
+        self.transfer_data_exc: Optional[BaseException] = None
+
+        # Task sending keepalive pings.
+        self.keepalive_ping_task: asyncio.Task[None]
+
+        # Task closing the TCP connection.
+        self.close_connection_task: asyncio.Task[None]
+
+    # Copied from asyncio.FlowControlMixin
+    async def _drain_helper(self) -> None:  # pragma: no cover
+        if self.connection_lost_waiter.done():
+            raise ConnectionResetError("Connection lost")
+        if not self._paused:
+            return
+        waiter = self._drain_waiter
+        assert waiter is None or waiter.cancelled()
+        waiter = self.loop.create_future()
+        self._drain_waiter = waiter
+        await waiter
+
+    # Copied from asyncio.StreamWriter
+    async def _drain(self) -> None:  # pragma: no cover
+        if self.reader is not None:
+            exc = self.reader.exception()
+            if exc is not None:
+                raise exc
+        if self.transport is not None:
+            if self.transport.is_closing():
+                # Yield to the event loop so connection_lost() may be
+                # called.  Without this, _drain_helper() would return
+                # immediately, and code that calls
+                #     write(...); yield from drain()
+                # in a loop would never call connection_lost(), so it
+                # would not see an error when the socket is closed.
+                await asyncio.sleep(0, **loop_if_py_lt_38(self.loop))
+        await self._drain_helper()
+
+    def connection_open(self) -> None:
+        """
+        Callback when the WebSocket opening handshake completes.
+
+        Enter the OPEN state and start the data transfer phase.
+
+        """
+        # 4.1. The WebSocket Connection is Established.
+        assert self.state is State.CONNECTING
+        self.state = State.OPEN
+        if self.debug:
+            self.logger.debug("= connection is OPEN")
+        # Start the task that receives incoming WebSocket messages.
+        self.transfer_data_task = self.loop.create_task(self.transfer_data())
+        # Start the task that sends pings at regular intervals.
+        self.keepalive_ping_task = self.loop.create_task(self.keepalive_ping())
+        # Start the task that eventually closes the TCP connection.
+        self.close_connection_task = self.loop.create_task(self.close_connection())
+
+    @property
+    def host(self) -> Optional[str]:
+        alternative = "remote_address" if self.is_client else "local_address"
+        warnings.warn(f"use {alternative}[0] instead of host", DeprecationWarning)
+        return self._host
+
+    @property
+    def port(self) -> Optional[int]:
+        alternative = "remote_address" if self.is_client else "local_address"
+        warnings.warn(f"use {alternative}[1] instead of port", DeprecationWarning)
+        return self._port
+
+    @property
+    def secure(self) -> Optional[bool]:
+        warnings.warn("don't use secure", DeprecationWarning)
+        return self._secure
+
+    # Public API
+
+    @property
+    def local_address(self) -> Any:
+        """
+        Local address of the connection.
+
+        For IPv4 connections, this is a ``(host, port)`` tuple.
+
+        The format of the address depends on the address family;
+        see :meth:`~socket.socket.getsockname`.
+
+        :obj:`None` if the TCP connection isn't established yet.
+
+        """
+        try:
+            transport = self.transport
+        except AttributeError:
+            return None
+        else:
+            return transport.get_extra_info("sockname")
+
+    @property
+    def remote_address(self) -> Any:
+        """
+        Remote address of the connection.
+
+        For IPv4 connections, this is a ``(host, port)`` tuple.
+
+        The format of the address depends on the address family;
+        see :meth:`~socket.socket.getpeername`.
+
+        :obj:`None` if the TCP connection isn't established yet.
+
+        """
+        try:
+            transport = self.transport
+        except AttributeError:
+            return None
+        else:
+            return transport.get_extra_info("peername")
+
+    @property
+    def open(self) -> bool:
+        """
+        :obj:`True` when the connection is open; :obj:`False` otherwise.
+
+        This attribute may be used to detect disconnections. However, this
+        approach is discouraged per the EAFP_ principle. Instead, you should
+        handle :exc:`~websockets.exceptions.ConnectionClosed` exceptions.
+
+        .. _EAFP: https://docs.python.org/3/glossary.html#term-eafp
+
+        """
+        return self.state is State.OPEN and not self.transfer_data_task.done()
+
+    @property
+    def closed(self) -> bool:
+        """
+        :obj:`True` when the connection is closed; :obj:`False` otherwise.
+
+        Be aware that both :attr:`open` and :attr:`closed` are :obj:`False`
+        during the opening and closing sequences.
+
+        """
+        return self.state is State.CLOSED
+
+    @property
+    def close_code(self) -> Optional[int]:
+        """
+        WebSocket close code, defined in `section 7.1.5 of RFC 6455`_.
+
+        .. _section 7.1.5 of RFC 6455:
+            https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.5
+
+        :obj:`None` if the connection isn't closed yet.
+
+        """
+        if self.state is not State.CLOSED:
+            return None
+        elif self.close_rcvd is None:
+            return 1006
+        else:
+            return self.close_rcvd.code
+
+    @property
+    def close_reason(self) -> Optional[str]:
+        """
+        WebSocket close reason, defined in `section 7.1.6 of RFC 6455`_.
+
+        .. _section 7.1.6 of RFC 6455:
+            https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.6
+
+        :obj:`None` if the connection isn't closed yet.
+
+        """
+        if self.state is not State.CLOSED:
+            return None
+        elif self.close_rcvd is None:
+            return ""
+        else:
+            return self.close_rcvd.reason
+
+    async def __aiter__(self) -> AsyncIterator[Data]:
+        """
+        Iterate on incoming messages.
+
+        The iterator  exits normally when the connection is closed with the
+        close code 1000 (OK) or 1001(going away). It raises
+        a :exc:`~websockets.exceptions.ConnectionClosedError` exception when
+        the connection is closed with any other code.
+
+        """
+        try:
+            while True:
+                yield await self.recv()
+        except ConnectionClosedOK:
+            return
+
+    async def recv(self) -> Data:
+        """
+        Receive the next message.
+
+        When the connection is closed, :meth:`recv` raises
+        :exc:`~websockets.exceptions.ConnectionClosed`. Specifically, it
+        raises :exc:`~websockets.exceptions.ConnectionClosedOK` after a normal
+        connection closure and
+        :exc:`~websockets.exceptions.ConnectionClosedError` after a protocol
+        error or a network failure. This is how you detect the end of the
+        message stream.
+
+        Canceling :meth:`recv` is safe. There's no risk of losing the next
+        message. The next invocation of :meth:`recv` will return it.
+
+        This makes it possible to enforce a timeout by wrapping :meth:`recv`
+        in :func:`~asyncio.wait_for`.
+
+        Returns:
+            Data: A string (:class:`str`) for a Text_ frame. A bytestring
+            (:class:`bytes`) for a Binary_ frame.
+
+            .. _Text: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6
+            .. _Binary: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6
+
+        Raises:
+            ConnectionClosed: when the connection is closed.
+            RuntimeError: if two coroutines call :meth:`recv` concurrently.
+
+        """
+        if self._pop_message_waiter is not None:
+            raise RuntimeError(
+                "cannot call recv while another coroutine "
+                "is already waiting for the next message"
+            )
+
+        # Don't await self.ensure_open() here:
+        # - messages could be available in the queue even if the connection
+        #   is closed;
+        # - messages could be received before the closing frame even if the
+        #   connection is closing.
+
+        # Wait until there's a message in the queue (if necessary) or the
+        # connection is closed.
+        while len(self.messages) <= 0:
+            pop_message_waiter: asyncio.Future[None] = self.loop.create_future()
+            self._pop_message_waiter = pop_message_waiter
+            try:
+                # If asyncio.wait() is canceled, it doesn't cancel
+                # pop_message_waiter and self.transfer_data_task.
+                await asyncio.wait(
+                    [pop_message_waiter, self.transfer_data_task],
+                    return_when=asyncio.FIRST_COMPLETED,
+                    **loop_if_py_lt_38(self.loop),
+                )
+            finally:
+                self._pop_message_waiter = None
+
+            # If asyncio.wait(...) exited because self.transfer_data_task
+            # completed before receiving a new message, raise a suitable
+            # exception (or return None if legacy_recv is enabled).
+            if not pop_message_waiter.done():
+                if self.legacy_recv:
+                    return None  # type: ignore
+                else:
+                    # Wait until the connection is closed to raise
+                    # ConnectionClosed with the correct code and reason.
+                    await self.ensure_open()
+
+        # Pop a message from the queue.
+        message = self.messages.popleft()
+
+        # Notify transfer_data().
+        if self._put_message_waiter is not None:
+            self._put_message_waiter.set_result(None)
+            self._put_message_waiter = None
+
+        return message
+
+    async def send(
+        self,
+        message: Union[Data, Iterable[Data], AsyncIterable[Data]],
+    ) -> None:
+        """
+        Send a message.
+
+        A string (:class:`str`) is sent as a Text_ frame. A bytestring or
+        bytes-like object (:class:`bytes`, :class:`bytearray`, or
+        :class:`memoryview`) is sent as a Binary_ frame.
+
+        .. _Text: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6
+        .. _Binary: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6
+
+        :meth:`send` also accepts an iterable or an asynchronous iterable of
+        strings, bytestrings, or bytes-like objects to enable fragmentation_.
+        Each item is treated as a message fragment and sent in its own frame.
+        All items must be of the same type, or else :meth:`send` will raise a
+        :exc:`TypeError` and the connection will be closed.
+
+        .. _fragmentation: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.4
+
+        :meth:`send` rejects dict-like objects because this is often an error.
+        (If you want to send the keys of a dict-like object as fragments, call
+        its :meth:`~dict.keys` method and pass the result to :meth:`send`.)
+
+        Canceling :meth:`send` is discouraged. Instead, you should close the
+        connection with :meth:`close`. Indeed, there are only two situations
+        where :meth:`send` may yield control to the event loop and then get
+        canceled; in both cases, :meth:`close` has the same effect and is
+        more clear:
+
+        1. The write buffer is full. If you don't want to wait until enough
+           data is sent, your only alternative is to close the connection.
+           :meth:`close` will likely time out then abort the TCP connection.
+        2. ``message`` is an asynchronous iterator that yields control.
+           Stopping in the middle of a fragmented message will cause a
+           protocol error and the connection will be closed.
+
+        When the connection is closed, :meth:`send` raises
+        :exc:`~websockets.exceptions.ConnectionClosed`. Specifically, it
+        raises :exc:`~websockets.exceptions.ConnectionClosedOK` after a normal
+        connection closure and
+        :exc:`~websockets.exceptions.ConnectionClosedError` after a protocol
+        error or a network failure.
+
+        Args:
+            message (Union[Data, Iterable[Data], AsyncIterable[Data]): message
+                to send.
+
+        Raises:
+            ConnectionClosed: when the connection is closed.
+            TypeError: if ``message`` doesn't have a supported type.
+
+        """
+        await self.ensure_open()
+
+        # While sending a fragmented message, prevent sending other messages
+        # until all fragments are sent.
+        while self._fragmented_message_waiter is not None:
+            await asyncio.shield(self._fragmented_message_waiter)
+
+        # Unfragmented message -- this case must be handled first because
+        # strings and bytes-like objects are iterable.
+
+        if isinstance(message, (str, bytes, bytearray, memoryview)):
+            opcode, data = prepare_data(message)
+            await self.write_frame(True, opcode, data)
+
+        # Catch a common mistake -- passing a dict to send().
+
+        elif isinstance(message, Mapping):
+            raise TypeError("data is a dict-like object")
+
+        # Fragmented message -- regular iterator.
+
+        elif isinstance(message, Iterable):
+
+            # Work around https://github.com/python/mypy/issues/6227
+            message = cast(Iterable[Data], message)
+
+            iter_message = iter(message)
+            try:
+                message_chunk = next(iter_message)
+            except StopIteration:
+                return
+            opcode, data = prepare_data(message_chunk)
+
+            self._fragmented_message_waiter = asyncio.Future()
+            try:
+                # First fragment.
+                await self.write_frame(False, opcode, data)
+
+                # Other fragments.
+                for message_chunk in iter_message:
+                    confirm_opcode, data = prepare_data(message_chunk)
+                    if confirm_opcode != opcode:
+                        raise TypeError("data contains inconsistent types")
+                    await self.write_frame(False, OP_CONT, data)
+
+                # Final fragment.
+                await self.write_frame(True, OP_CONT, b"")
+
+            except (Exception, asyncio.CancelledError):
+                # We're half-way through a fragmented message and we can't
+                # complete it. This makes the connection unusable.
+                self.fail_connection(1011)
+                raise
+
+            finally:
+                self._fragmented_message_waiter.set_result(None)
+                self._fragmented_message_waiter = None
+
+        # Fragmented message -- asynchronous iterator
+
+        elif isinstance(message, AsyncIterable):
+            # aiter_message = aiter(message) without aiter
+            # https://github.com/python/mypy/issues/5738
+            aiter_message = type(message).__aiter__(message)  # type: ignore
+            try:
+                # message_chunk = anext(aiter_message) without anext
+                # https://github.com/python/mypy/issues/5738
+                message_chunk = await type(aiter_message).__anext__(  # type: ignore
+                    aiter_message
+                )
+            except StopAsyncIteration:
+                return
+            opcode, data = prepare_data(message_chunk)
+
+            self._fragmented_message_waiter = asyncio.Future()
+            try:
+                # First fragment.
+                await self.write_frame(False, opcode, data)
+
+                # Other fragments.
+                # https://github.com/python/mypy/issues/5738
+                # coverage reports this code as not covered, but it is
+                # exercised by tests - changing it breaks the tests!
+                async for message_chunk in aiter_message:  # type: ignore  # pragma: no cover  # noqa
+                    confirm_opcode, data = prepare_data(message_chunk)
+                    if confirm_opcode != opcode:
+                        raise TypeError("data contains inconsistent types")
+                    await self.write_frame(False, OP_CONT, data)
+
+                # Final fragment.
+                await self.write_frame(True, OP_CONT, b"")
+
+            except (Exception, asyncio.CancelledError):
+                # We're half-way through a fragmented message and we can't
+                # complete it. This makes the connection unusable.
+                self.fail_connection(1011)
+                raise
+
+            finally:
+                self._fragmented_message_waiter.set_result(None)
+                self._fragmented_message_waiter = None
+
+        else:
+            raise TypeError("data must be str, bytes-like, or iterable")
+
+    async def close(self, code: int = 1000, reason: str = "") -> None:
+        """
+        Perform the closing handshake.
+
+        :meth:`close` waits for the other end to complete the handshake and
+        for the TCP connection to terminate. As a consequence, there's no need
+        to await :meth:`wait_closed` after :meth:`close`.
+
+        :meth:`close` is idempotent: it doesn't do anything once the
+        connection is closed.
+
+        Wrapping :func:`close` in :func:`~asyncio.create_task` is safe, given
+        that errors during connection termination aren't particularly useful.
+
+        Canceling :meth:`close` is discouraged. If it takes too long, you can
+        set a shorter ``close_timeout``. If you don't want to wait, let the
+        Python process exit, then the OS will take care of closing the TCP
+        connection.
+
+        Args:
+            code: WebSocket close code.
+            reason: WebSocket close reason.
+
+        """
+        try:
+            await asyncio.wait_for(
+                self.write_close_frame(Close(code, reason)),
+                self.close_timeout,
+                **loop_if_py_lt_38(self.loop),
+            )
+        except asyncio.TimeoutError:
+            # If the close frame cannot be sent because the send buffers
+            # are full, the closing handshake won't complete anyway.
+            # Fail the connection to shut down faster.
+            self.fail_connection()
+
+        # If no close frame is received within the timeout, wait_for() cancels
+        # the data transfer task and raises TimeoutError.
+
+        # If close() is called multiple times concurrently and one of these
+        # calls hits the timeout, the data transfer task will be canceled.
+        # Other calls will receive a CancelledError here.
+
+        try:
+            # If close() is canceled during the wait, self.transfer_data_task
+            # is canceled before the timeout elapses.
+            await asyncio.wait_for(
+                self.transfer_data_task,
+                self.close_timeout,
+                **loop_if_py_lt_38(self.loop),
+            )
+        except (asyncio.TimeoutError, asyncio.CancelledError):
+            pass
+
+        # Wait for the close connection task to close the TCP connection.
+        await asyncio.shield(self.close_connection_task)
+
+    async def wait_closed(self) -> None:
+        """
+        Wait until the connection is closed.
+
+        This coroutine is identical to the :attr:`closed` attribute, except it
+        can be awaited.
+
+        This can make it easier to detect connection termination, regardless
+        of its cause, in tasks that interact with the WebSocket connection.
+
+        """
+        await asyncio.shield(self.connection_lost_waiter)
+
+    async def ping(self, data: Optional[Data] = None) -> Awaitable[None]:
+        """
+        Send a Ping_.
+
+        .. _Ping: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.5.2
+
+        A ping may serve as a keepalive or as a check that the remote endpoint
+        received all messages up to this point
+
+        Canceling :meth:`ping` is discouraged. If :meth:`ping` doesn't return
+        immediately, it means the write buffer is full. If you don't want to
+        wait, you should close the connection.
+
+        Canceling the :class:`~asyncio.Future` returned by :meth:`ping` has no
+        effect.
+
+        Args:
+            data (Optional[Data]): payload of the ping; a string will be
+                encoded to UTF-8; or :obj:`None` to generate a payload
+                containing four random bytes.
+
+        Returns:
+            ~asyncio.Future: A future that will be completed when the
+            corresponding pong is received. You can ignore it if you
+            don't intend to wait.
+
+            ::
+
+                pong_waiter = await ws.ping()
+                await pong_waiter  # only if you want to wait for the pong
+
+        Raises:
+            ConnectionClosed: when the connection is closed.
+            RuntimeError: if another ping was sent with the same data and
+                the corresponding pong wasn't received yet.
+
+        """
+        await self.ensure_open()
+
+        if data is not None:
+            data = prepare_ctrl(data)
+
+        # Protect against duplicates if a payload is explicitly set.
+        if data in self.pings:
+            raise RuntimeError("already waiting for a pong with the same data")
+
+        # Generate a unique random payload otherwise.
+        while data is None or data in self.pings:
+            data = struct.pack("!I", random.getrandbits(32))
+
+        self.pings[data] = self.loop.create_future()
+
+        await self.write_frame(True, OP_PING, data)
+
+        return asyncio.shield(self.pings[data])
+
+    async def pong(self, data: Data = b"") -> None:
+        """
+        Send a Pong_.
+
+        .. _Pong: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.5.3
+
+        An unsolicited pong may serve as a unidirectional heartbeat.
+
+        Canceling :meth:`pong` is discouraged. If :meth:`pong` doesn't return
+        immediately, it means the write buffer is full. If you don't want to
+        wait, you should close the connection.
+
+        Args:
+            data (Data): payload of the pong; a string will be encoded to
+                UTF-8.
+
+        Raises:
+            ConnectionClosed: when the connection is closed.
+
+        """
+        await self.ensure_open()
+
+        data = prepare_ctrl(data)
+
+        await self.write_frame(True, OP_PONG, data)
+
+    # Private methods - no guarantees.
+
+    def connection_closed_exc(self) -> ConnectionClosed:
+        exc: ConnectionClosed
+        if (
+            self.close_rcvd is not None
+            and self.close_rcvd.code in OK_CLOSE_CODES
+            and self.close_sent is not None
+            and self.close_sent.code in OK_CLOSE_CODES
+        ):
+            exc = ConnectionClosedOK(
+                self.close_rcvd,
+                self.close_sent,
+                self.close_rcvd_then_sent,
+            )
+        else:
+            exc = ConnectionClosedError(
+                self.close_rcvd,
+                self.close_sent,
+                self.close_rcvd_then_sent,
+            )
+        # Chain to the exception that terminated data transfer, if any.
+        exc.__cause__ = self.transfer_data_exc
+        return exc
+
+    async def ensure_open(self) -> None:
+        """
+        Check that the WebSocket connection is open.
+
+        Raise :exc:`~websockets.exceptions.ConnectionClosed` if it isn't.
+
+        """
+        # Handle cases from most common to least common for performance.
+        if self.state is State.OPEN:
+            # If self.transfer_data_task exited without a closing handshake,
+            # self.close_connection_task may be closing the connection, going
+            # straight from OPEN to CLOSED.
+            if self.transfer_data_task.done():
+                await asyncio.shield(self.close_connection_task)
+                raise self.connection_closed_exc()
+            else:
+                return
+
+        if self.state is State.CLOSED:
+            raise self.connection_closed_exc()
+
+        if self.state is State.CLOSING:
+            # If we started the closing handshake, wait for its completion to
+            # get the proper close code and reason. self.close_connection_task
+            # will complete within 4 or 5 * close_timeout after close(). The
+            # CLOSING state also occurs when failing the connection. In that
+            # case self.close_connection_task will complete even faster.
+            await asyncio.shield(self.close_connection_task)
+            raise self.connection_closed_exc()
+
+        # Control may only reach this point in buggy third-party subclasses.
+        assert self.state is State.CONNECTING
+        raise InvalidState("WebSocket connection isn't established yet")
+
+    async def transfer_data(self) -> None:
+        """
+        Read incoming messages and put them in a queue.
+
+        This coroutine runs in a task until the closing handshake is started.
+
+        """
+        try:
+            while True:
+                message = await self.read_message()
+
+                # Exit the loop when receiving a close frame.
+                if message is None:
+                    break
+
+                # Wait until there's room in the queue (if necessary).
+                if self.max_queue is not None:
+                    while len(self.messages) >= self.max_queue:
+                        self._put_message_waiter = self.loop.create_future()
+                        try:
+                            await asyncio.shield(self._put_message_waiter)
+                        finally:
+                            self._put_message_waiter = None
+
+                # Put the message in the queue.
+                self.messages.append(message)
+
+                # Notify recv().
+                if self._pop_message_waiter is not None:
+                    self._pop_message_waiter.set_result(None)
+                    self._pop_message_waiter = None
+
+        except asyncio.CancelledError as exc:
+            self.transfer_data_exc = exc
+            # If fail_connection() cancels this task, avoid logging the error
+            # twice and failing the connection again.
+            raise
+
+        except ProtocolError as exc:
+            self.transfer_data_exc = exc
+            self.fail_connection(1002)
+
+        except (ConnectionError, TimeoutError, EOFError, ssl.SSLError) as exc:
+            # Reading data with self.reader.readexactly may raise:
+            # - most subclasses of ConnectionError if the TCP connection
+            #   breaks, is reset, or is aborted;
+            # - TimeoutError if the TCP connection times out;
+            # - IncompleteReadError, a subclass of EOFError, if fewer
+            #   bytes are available than requested;
+            # - ssl.SSLError if the other side infringes the TLS protocol.
+            self.transfer_data_exc = exc
+            self.fail_connection(1006)
+
+        except UnicodeDecodeError as exc:
+            self.transfer_data_exc = exc
+            self.fail_connection(1007)
+
+        except PayloadTooBig as exc:
+            self.transfer_data_exc = exc
+            self.fail_connection(1009)
+
+        except Exception as exc:
+            # This shouldn't happen often because exceptions expected under
+            # regular circumstances are handled above. If it does, consider
+            # catching and handling more exceptions.
+            self.logger.error("data transfer failed", exc_info=True)
+
+            self.transfer_data_exc = exc
+            self.fail_connection(1011)
+
+    async def read_message(self) -> Optional[Data]:
+        """
+        Read a single message from the connection.
+
+        Re-assemble data frames if the message is fragmented.
+
+        Return :obj:`None` when the closing handshake is started.
+
+        """
+        frame = await self.read_data_frame(max_size=self.max_size)
+
+        # A close frame was received.
+        if frame is None:
+            return None
+
+        if frame.opcode == OP_TEXT:
+            text = True
+        elif frame.opcode == OP_BINARY:
+            text = False
+        else:  # frame.opcode == OP_CONT
+            raise ProtocolError("unexpected opcode")
+
+        # Shortcut for the common case - no fragmentation
+        if frame.fin:
+            return frame.data.decode("utf-8") if text else frame.data
+
+        # 5.4. Fragmentation
+        chunks: List[Data] = []
+        max_size = self.max_size
+        if text:
+            decoder_factory = codecs.getincrementaldecoder("utf-8")
+            decoder = decoder_factory(errors="strict")
+            if max_size is None:
+
+                def append(frame: Frame) -> None:
+                    nonlocal chunks
+                    chunks.append(decoder.decode(frame.data, frame.fin))
+
+            else:
+
+                def append(frame: Frame) -> None:
+                    nonlocal chunks, max_size
+                    chunks.append(decoder.decode(frame.data, frame.fin))
+                    assert isinstance(max_size, int)
+                    max_size -= len(frame.data)
+
+        else:
+            if max_size is None:
+
+                def append(frame: Frame) -> None:
+                    nonlocal chunks
+                    chunks.append(frame.data)
+
+            else:
+
+                def append(frame: Frame) -> None:
+                    nonlocal chunks, max_size
+                    chunks.append(frame.data)
+                    assert isinstance(max_size, int)
+                    max_size -= len(frame.data)
+
+        append(frame)
+
+        while not frame.fin:
+            frame = await self.read_data_frame(max_size=max_size)
+            if frame is None:
+                raise ProtocolError("incomplete fragmented message")
+            if frame.opcode != OP_CONT:
+                raise ProtocolError("unexpected opcode")
+            append(frame)
+
+        return ("" if text else b"").join(chunks)
+
+    async def read_data_frame(self, max_size: Optional[int]) -> Optional[Frame]:
+        """
+        Read a single data frame from the connection.
+
+        Process control frames received before the next data frame.
+
+        Return :obj:`None` if a close frame is encountered before any data frame.
+
+        """
+        # 6.2. Receiving Data
+        while True:
+            frame = await self.read_frame(max_size)
+
+            # 5.5. Control Frames
+            if frame.opcode == OP_CLOSE:
+                # 7.1.5.  The WebSocket Connection Close Code
+                # 7.1.6.  The WebSocket Connection Close Reason
+                self.close_rcvd = Close.parse(frame.data)
+                if self.close_sent is not None:
+                    self.close_rcvd_then_sent = False
+                try:
+                    # Echo the original data instead of re-serializing it with
+                    # Close.serialize() because that fails when the close frame
+                    # is empty and Close.parse() synthetizes a 1005 close code.
+                    await self.write_close_frame(self.close_rcvd, frame.data)
+                except ConnectionClosed:
+                    # Connection closed before we could echo the close frame.
+                    pass
+                return None
+
+            elif frame.opcode == OP_PING:
+                # Answer pings, unless connection is CLOSING.
+                if self.state is State.OPEN:
+                    try:
+                        await self.pong(frame.data)
+                    except ConnectionClosed:
+                        # Connection closed while draining write buffer.
+                        pass
+
+            elif frame.opcode == OP_PONG:
+                if frame.data in self.pings:
+                    # Sending a pong for only the most recent ping is legal.
+                    # Acknowledge all previous pings too in that case.
+                    ping_id = None
+                    ping_ids = []
+                    for ping_id, ping in self.pings.items():
+                        ping_ids.append(ping_id)
+                        if not ping.done():
+                            ping.set_result(None)
+                        if ping_id == frame.data:
+                            break
+                    else:  # pragma: no cover
+                        assert False, "ping_id is in self.pings"
+                    # Remove acknowledged pings from self.pings.
+                    for ping_id in ping_ids:
+                        del self.pings[ping_id]
+
+            # 5.6. Data Frames
+            else:
+                return frame
+
+    async def read_frame(self, max_size: Optional[int]) -> Frame:
+        """
+        Read a single frame from the connection.
+
+        """
+        frame = await Frame.read(
+            self.reader.readexactly,
+            mask=not self.is_client,
+            max_size=max_size,
+            extensions=self.extensions,
+        )
+        if self.debug:
+            self.logger.debug("< %s", frame)
+        return frame
+
+    def write_frame_sync(self, fin: bool, opcode: int, data: bytes) -> None:
+        frame = Frame(fin, Opcode(opcode), data)
+        if self.debug:
+            self.logger.debug("> %s", frame)
+        frame.write(
+            self.transport.write,
+            mask=self.is_client,
+            extensions=self.extensions,
+        )
+
+    async def drain(self) -> None:
+        try:
+            # drain() cannot be called concurrently by multiple coroutines:
+            # http://bugs.python.org/issue29930. Remove this lock when no
+            # version of Python where this bugs exists is supported anymore.
+            async with self._drain_lock:
+                # Handle flow control automatically.
+                await self._drain()
+        except ConnectionError:
+            # Terminate the connection if the socket died.
+            self.fail_connection()
+            # Wait until the connection is closed to raise ConnectionClosed
+            # with the correct code and reason.
+            await self.ensure_open()
+
+    async def write_frame(
+        self, fin: bool, opcode: int, data: bytes, *, _state: int = State.OPEN
+    ) -> None:
+        # Defensive assertion for protocol compliance.
+        if self.state is not _state:  # pragma: no cover
+            raise InvalidState(
+                f"Cannot write to a WebSocket in the {self.state.name} state"
+            )
+        self.write_frame_sync(fin, opcode, data)
+        await self.drain()
+
+    async def write_close_frame(
+        self, close: Close, data: Optional[bytes] = None
+    ) -> None:
+        """
+        Write a close frame if and only if the connection state is OPEN.
+
+        This dedicated coroutine must be used for writing close frames to
+        ensure that at most one close frame is sent on a given connection.
+
+        """
+        # Test and set the connection state before sending the close frame to
+        # avoid sending two frames in case of concurrent calls.
+        if self.state is State.OPEN:
+            # 7.1.3. The WebSocket Closing Handshake is Started
+            self.state = State.CLOSING
+            if self.debug:
+                self.logger.debug("= connection is CLOSING")
+
+            self.close_sent = close
+            if self.close_rcvd is not None:
+                self.close_rcvd_then_sent = True
+            if data is None:
+                data = close.serialize()
+
+            # 7.1.2. Start the WebSocket Closing Handshake
+            await self.write_frame(True, OP_CLOSE, data, _state=State.CLOSING)
+
+    async def keepalive_ping(self) -> None:
+        """
+        Send a Ping frame and wait for a Pong frame at regular intervals.
+
+        This coroutine exits when the connection terminates and one of the
+        following happens:
+
+        - :meth:`ping` raises :exc:`ConnectionClosed`, or
+        - :meth:`close_connection` cancels :attr:`keepalive_ping_task`.
+
+        """
+        if self.ping_interval is None:
+            return
+
+        try:
+            while True:
+                await asyncio.sleep(
+                    self.ping_interval,
+                    **loop_if_py_lt_38(self.loop),
+                )
+
+                # ping() raises CancelledError if the connection is closed,
+                # when close_connection() cancels self.keepalive_ping_task.
+
+                # ping() raises ConnectionClosed if the connection is lost,
+                # when connection_lost() calls abort_pings().
+
+                self.logger.debug("% sending keepalive ping")
+                pong_waiter = await self.ping()
+
+                if self.ping_timeout is not None:
+                    try:
+                        await asyncio.wait_for(
+                            pong_waiter,
+                            self.ping_timeout,
+                            **loop_if_py_lt_38(self.loop),
+                        )
+                        self.logger.debug("% received keepalive pong")
+                    except asyncio.TimeoutError:
+                        if self.debug:
+                            self.logger.debug("! timed out waiting for keepalive pong")
+                        self.fail_connection(1011, "keepalive ping timeout")
+                        break
+
+        # Remove this branch when dropping support for Python < 3.8
+        # because CancelledError no longer inherits Exception.
+        except asyncio.CancelledError:
+            raise
+
+        except ConnectionClosed:
+            pass
+
+        except Exception:
+            self.logger.error("keepalive ping failed", exc_info=True)
+
+    async def close_connection(self) -> None:
+        """
+        7.1.1. Close the WebSocket Connection
+
+        When the opening handshake succeeds, :meth:`connection_open` starts
+        this coroutine in a task. It waits for the data transfer phase to
+        complete then it closes the TCP connection cleanly.
+
+        When the opening handshake fails, :meth:`fail_connection` does the
+        same. There's no data transfer phase in that case.
+
+        """
+        try:
+            # Wait for the data transfer phase to complete.
+            if hasattr(self, "transfer_data_task"):
+                try:
+                    await self.transfer_data_task
+                except asyncio.CancelledError:
+                    pass
+
+            # Cancel the keepalive ping task.
+            if hasattr(self, "keepalive_ping_task"):
+                self.keepalive_ping_task.cancel()
+
+            # A client should wait for a TCP close from the server.
+            if self.is_client and hasattr(self, "transfer_data_task"):
+                if await self.wait_for_connection_lost():
+                    # Coverage marks this line as a partially executed branch.
+                    # I supect a bug in coverage. Ignore it for now.
+                    return  # pragma: no cover
+                if self.debug:
+                    self.logger.debug("! timed out waiting for TCP close")
+
+            # Half-close the TCP connection if possible (when there's no TLS).
+            if self.transport.can_write_eof():
+                if self.debug:
+                    self.logger.debug("x half-closing TCP connection")
+                # write_eof() doesn't document which exceptions it raises.
+                # "[Errno 107] Transport endpoint is not connected" happens
+                # but it isn't completely clear under which circumstances.
+                # uvloop can raise RuntimeError here.
+                try:
+                    self.transport.write_eof()
+                except (OSError, RuntimeError):  # pragma: no cover
+                    pass
+
+                if await self.wait_for_connection_lost():
+                    # Coverage marks this line as a partially executed branch.
+                    # I supect a bug in coverage. Ignore it for now.
+                    return  # pragma: no cover
+                if self.debug:
+                    self.logger.debug("! timed out waiting for TCP close")
+
+        finally:
+            # The try/finally ensures that the transport never remains open,
+            # even if this coroutine is canceled (for example).
+            await self.close_transport()
+
+    async def close_transport(self) -> None:
+        """
+        Close the TCP connection.
+
+        """
+        # If connection_lost() was called, the TCP connection is closed.
+        # However, if TLS is enabled, the transport still needs closing.
+        # Else asyncio complains: ResourceWarning: unclosed transport.
+        if self.connection_lost_waiter.done() and self.transport.is_closing():
+            return
+
+        # Close the TCP connection. Buffers are flushed asynchronously.
+        if self.debug:
+            self.logger.debug("x closing TCP connection")
+        self.transport.close()
+
+        if await self.wait_for_connection_lost():
+            return
+        if self.debug:
+            self.logger.debug("! timed out waiting for TCP close")
+
+        # Abort the TCP connection. Buffers are discarded.
+        if self.debug:
+            self.logger.debug("x aborting TCP connection")
+        self.transport.abort()
+
+        # connection_lost() is called quickly after aborting.
+        # Coverage marks this line as a partially executed branch.
+        # I supect a bug in coverage. Ignore it for now.
+        await self.wait_for_connection_lost()  # pragma: no cover
+
+    async def wait_for_connection_lost(self) -> bool:
+        """
+        Wait until the TCP connection is closed or ``self.close_timeout`` elapses.
+
+        Return :obj:`True` if the connection is closed and :obj:`False`
+        otherwise.
+
+        """
+        if not self.connection_lost_waiter.done():
+            try:
+                await asyncio.wait_for(
+                    asyncio.shield(self.connection_lost_waiter),
+                    self.close_timeout,
+                    **loop_if_py_lt_38(self.loop),
+                )
+            except asyncio.TimeoutError:
+                pass
+        # Re-check self.connection_lost_waiter.done() synchronously because
+        # connection_lost() could run between the moment the timeout occurs
+        # and the moment this coroutine resumes running.
+        return self.connection_lost_waiter.done()
+
+    def fail_connection(self, code: int = 1006, reason: str = "") -> None:
+        """
+        7.1.7. Fail the WebSocket Connection
+
+        This requires:
+
+        1. Stopping all processing of incoming data, which means cancelling
+           :attr:`transfer_data_task`. The close code will be 1006 unless a
+           close frame was received earlier.
+
+        2. Sending a close frame with an appropriate code if the opening
+           handshake succeeded and the other side is likely to process it.
+
+        3. Closing the connection. :meth:`close_connection` takes care of
+           this once :attr:`transfer_data_task` exits after being canceled.
+
+        (The specification describes these steps in the opposite order.)
+
+        """
+        if self.debug:
+            self.logger.debug("! failing connection with code %d", code)
+
+        # Cancel transfer_data_task if the opening handshake succeeded.
+        # cancel() is idempotent and ignored if the task is done already.
+        if hasattr(self, "transfer_data_task"):
+            self.transfer_data_task.cancel()
+
+        # Send a close frame when the state is OPEN (a close frame was already
+        # sent if it's CLOSING), except when failing the connection because of
+        # an error reading from or writing to the network.
+        # Don't send a close frame if the connection is broken.
+        if code != 1006 and self.state is State.OPEN:
+            close = Close(code, reason)
+
+            # Write the close frame without draining the write buffer.
+
+            # Keeping fail_connection() synchronous guarantees it can't
+            # get stuck and simplifies the implementation of the callers.
+            # Not drainig the write buffer is acceptable in this context.
+
+            # This duplicates a few lines of code from write_close_frame().
+
+            self.state = State.CLOSING
+            if self.debug:
+                self.logger.debug("= connection is CLOSING")
+
+            # If self.close_rcvd was set, the connection state would be
+            # CLOSING. Therefore self.close_rcvd isn't set and we don't
+            # have to set self.close_rcvd_then_sent.
+            assert self.close_rcvd is None
+            self.close_sent = close
+
+            self.write_frame_sync(True, OP_CLOSE, close.serialize())
+
+        # Start close_connection_task if the opening handshake didn't succeed.
+        if not hasattr(self, "close_connection_task"):
+            self.close_connection_task = self.loop.create_task(self.close_connection())
+
+    def abort_pings(self) -> None:
+        """
+        Raise ConnectionClosed in pending keepalive pings.
+
+        They'll never receive a pong once the connection is closed.
+
+        """
+        assert self.state is State.CLOSED
+        exc = self.connection_closed_exc()
+
+        for ping in self.pings.values():
+            ping.set_exception(exc)
+            # If the exception is never retrieved, it will be logged when ping
+            # is garbage-collected. This is confusing for users.
+            # Given that ping is done (with an exception), canceling it does
+            # nothing, but it prevents logging the exception.
+            ping.cancel()
+
+    # asyncio.Protocol methods
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        """
+        Configure write buffer limits.
+
+        The high-water limit is defined by ``self.write_limit``.
+
+        The low-water limit currently defaults to ``self.write_limit // 4`` in
+        :meth:`~asyncio.WriteTransport.set_write_buffer_limits`, which should
+        be all right for reasonable use cases of this library.
+
+        This is the earliest point where we can get hold of the transport,
+        which means it's the best point for configuring it.
+
+        """
+        transport = cast(asyncio.Transport, transport)
+        transport.set_write_buffer_limits(self.write_limit)
+        self.transport = transport
+
+        # Copied from asyncio.StreamReaderProtocol
+        self.reader.set_transport(transport)
+
+    def connection_lost(self, exc: Optional[Exception]) -> None:
+        """
+        7.1.4. The WebSocket Connection is Closed.
+
+        """
+        self.state = State.CLOSED
+        self.logger.debug("= connection is CLOSED")
+
+        self.abort_pings()
+
+        # If self.connection_lost_waiter isn't pending, that's a bug, because:
+        # - it's set only here in connection_lost() which is called only once;
+        # - it must never be canceled.
+        self.connection_lost_waiter.set_result(None)
+
+        if True:  # pragma: no cover
+
+            # Copied from asyncio.StreamReaderProtocol
+            if self.reader is not None:
+                if exc is None:
+                    self.reader.feed_eof()
+                else:
+                    self.reader.set_exception(exc)
+
+            # Copied from asyncio.FlowControlMixin
+            # Wake up the writer if currently paused.
+            if not self._paused:
+                return
+            waiter = self._drain_waiter
+            if waiter is None:
+                return
+            self._drain_waiter = None
+            if waiter.done():
+                return
+            if exc is None:
+                waiter.set_result(None)
+            else:
+                waiter.set_exception(exc)
+
+    def pause_writing(self) -> None:  # pragma: no cover
+        assert not self._paused
+        self._paused = True
+
+    def resume_writing(self) -> None:  # pragma: no cover
+        assert self._paused
+        self._paused = False
+
+        waiter = self._drain_waiter
+        if waiter is not None:
+            self._drain_waiter = None
+            if not waiter.done():
+                waiter.set_result(None)
+
+    def data_received(self, data: bytes) -> None:
+        self.reader.feed_data(data)
+
+    def eof_received(self) -> None:
+        """
+        Close the transport after receiving EOF.
+
+        The WebSocket protocol has its own closing handshake: endpoints close
+        the TCP or TLS connection after sending and receiving a close frame.
+
+        As a consequence, they never need to write after receiving EOF, so
+        there's no reason to keep the transport open by returning :obj:`True`.
+
+        Besides, that doesn't work on TLS connections.
+
+        """
+        self.reader.feed_eof()
+
+
+def broadcast(websockets: Iterable[WebSocketCommonProtocol], message: Data) -> None:
+    """
+    Broadcast a message to several WebSocket connections.
+
+    A string (:class:`str`) is sent as a Text_ frame. A bytestring or
+    bytes-like object (:class:`bytes`, :class:`bytearray`, or
+    :class:`memoryview`) is sent as a Binary_ frame.
+
+    .. _Text: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6
+    .. _Binary: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6
+
+    :func:`broadcast` pushes the message synchronously to all connections even
+    if their write buffers are overflowing. There's no backpressure.
+
+    :func:`broadcast` skips silently connections that aren't open in order to
+    avoid errors on connections where the closing handshake is in progress.
+
+    If you broadcast messages faster than a connection can handle them,
+    messages will pile up in its write buffer until the connection times out.
+    Keep low values for ``ping_interval`` and ``ping_timeout`` to prevent
+    excessive memory usage by slow connections when you use :func:`broadcast`.
+
+    Unlike :meth:`~websockets.server.WebSocketServerProtocol.send`,
+    :func:`broadcast` doesn't support sending fragmented messages. Indeed,
+    fragmentation is useful for sending large messages without buffering
+    them in memory, while :func:`broadcast` buffers one copy per connection
+    as fast as possible.
+
+    Args:
+        websockets (Iterable[WebSocketCommonProtocol]): WebSocket connections
+            to which the message will be sent.
+        message (Data): message to send.
+
+    Raises:
+        RuntimeError: if a connection is busy sending a fragmented message.
+        TypeError: if ``message`` doesn't have a supported type.
+
+    """
+    if not isinstance(message, (str, bytes, bytearray, memoryview)):
+        raise TypeError("data must be str or bytes-like")
+
+    opcode, data = prepare_data(message)
+
+    for websocket in websockets:
+        if websocket.state is not State.OPEN:
+            continue
+
+        if websocket._fragmented_message_waiter is not None:
+            raise RuntimeError("busy sending a fragmented message")
+
+        websocket.write_frame_sync(True, opcode, data)
diff --git a/myenv/lib/python3.9/site-packages/websockets/legacy/server.py b/myenv/lib/python3.9/site-packages/websockets/legacy/server.py
new file mode 100644
index 0000000..3e51db1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/legacy/server.py
@@ -0,0 +1,1156 @@
+from __future__ import annotations
+
+import asyncio
+import email.utils
+import functools
+import http
+import inspect
+import logging
+import socket
+import warnings
+from types import TracebackType
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Generator,
+    Iterable,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+
+from ..connection import State
+from ..datastructures import Headers, HeadersLike, MultipleValuesError
+from ..exceptions import (
+    AbortHandshake,
+    InvalidHandshake,
+    InvalidHeader,
+    InvalidMessage,
+    InvalidOrigin,
+    InvalidUpgrade,
+    NegotiationError,
+)
+from ..extensions import Extension, ServerExtensionFactory
+from ..extensions.permessage_deflate import enable_server_permessage_deflate
+from ..headers import (
+    build_extension,
+    parse_extension,
+    parse_subprotocol,
+    validate_subprotocols,
+)
+from ..http import USER_AGENT
+from ..typing import ExtensionHeader, LoggerLike, Origin, Subprotocol
+from .compatibility import loop_if_py_lt_38
+from .handshake import build_response, check_request
+from .http import read_request
+from .protocol import WebSocketCommonProtocol
+
+
+__all__ = ["serve", "unix_serve", "WebSocketServerProtocol", "WebSocketServer"]
+
+
+HeadersLikeOrCallable = Union[HeadersLike, Callable[[str, Headers], HeadersLike]]
+
+HTTPResponse = Tuple[http.HTTPStatus, HeadersLike, bytes]
+
+
+class WebSocketServerProtocol(WebSocketCommonProtocol):
+    """
+    WebSocket server connection.
+
+    :class:`WebSocketServerProtocol` provides :meth:`recv` and :meth:`send`
+    coroutines for receiving and sending messages.
+
+    It supports asynchronous iteration to receive messages::
+
+        async for message in websocket:
+            await process(message)
+
+    The iterator exits normally when the connection is closed with close code
+    1000 (OK) or 1001 (going away). It raises
+    a :exc:`~websockets.exceptions.ConnectionClosedError` when the connection
+    is closed with any other code.
+
+    You may customize the opening handshake in a subclass by
+    overriding :meth:`process_request` or :meth:`select_subprotocol`.
+
+    Args:
+        ws_server: WebSocket server that created this connection.
+
+    See :func:`serve` for the documentation of ``ws_handler``, ``logger``, ``origins``,
+    ``extensions``, ``subprotocols``, and ``extra_headers``.
+
+    See :class:`~websockets.legacy.protocol.WebSocketCommonProtocol` for the
+    documentation of ``ping_interval``, ``ping_timeout``, ``close_timeout``,
+    ``max_size``, ``max_queue``, ``read_limit``, and ``write_limit``.
+
+    """
+
+    is_client = False
+    side = "server"
+
+    def __init__(
+        self,
+        ws_handler: Union[
+            Callable[[WebSocketServerProtocol], Awaitable[Any]],
+            Callable[[WebSocketServerProtocol, str], Awaitable[Any]],  # deprecated
+        ],
+        ws_server: WebSocketServer,
+        *,
+        logger: Optional[LoggerLike] = None,
+        origins: Optional[Sequence[Optional[Origin]]] = None,
+        extensions: Optional[Sequence[ServerExtensionFactory]] = None,
+        subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLikeOrCallable] = None,
+        process_request: Optional[
+            Callable[[str, Headers], Awaitable[Optional[HTTPResponse]]]
+        ] = None,
+        select_subprotocol: Optional[
+            Callable[[Sequence[Subprotocol], Sequence[Subprotocol]], Subprotocol]
+        ] = None,
+        **kwargs: Any,
+    ) -> None:
+        if logger is None:
+            logger = logging.getLogger("websockets.server")
+        super().__init__(logger=logger, **kwargs)
+        # For backwards compatibility with 6.0 or earlier.
+        if origins is not None and "" in origins:
+            warnings.warn("use None instead of '' in origins", DeprecationWarning)
+            origins = [None if origin == "" else origin for origin in origins]
+        # For backwards compatibility with 10.0 or earlier. Done here in
+        # addition to serve to trigger the deprecation warning on direct
+        # use of WebSocketServerProtocol.
+        self.ws_handler = remove_path_argument(ws_handler)
+        self.ws_server = ws_server
+        self.origins = origins
+        self.available_extensions = extensions
+        self.available_subprotocols = subprotocols
+        self.extra_headers = extra_headers
+        self._process_request = process_request
+        self._select_subprotocol = select_subprotocol
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        """
+        Register connection and initialize a task to handle it.
+
+        """
+        super().connection_made(transport)
+        # Register the connection with the server before creating the handler
+        # task. Registering at the beginning of the handler coroutine would
+        # create a race condition between the creation of the task, which
+        # schedules its execution, and the moment the handler starts running.
+        self.ws_server.register(self)
+        self.handler_task = self.loop.create_task(self.handler())
+
+    async def handler(self) -> None:
+        """
+        Handle the lifecycle of a WebSocket connection.
+
+        Since this method doesn't have a caller able to handle exceptions, it
+        attemps to log relevant ones and guarantees that the TCP connection is
+        closed before exiting.
+
+        """
+        try:
+
+            try:
+                await self.handshake(
+                    origins=self.origins,
+                    available_extensions=self.available_extensions,
+                    available_subprotocols=self.available_subprotocols,
+                    extra_headers=self.extra_headers,
+                )
+            # Remove this branch when dropping support for Python < 3.8
+            # because CancelledError no longer inherits Exception.
+            except asyncio.CancelledError:  # pragma: no cover
+                raise
+            except ConnectionError:
+                raise
+            except Exception as exc:
+                if isinstance(exc, AbortHandshake):
+                    status, headers, body = exc.status, exc.headers, exc.body
+                elif isinstance(exc, InvalidOrigin):
+                    if self.debug:
+                        self.logger.debug("! invalid origin", exc_info=True)
+                    status, headers, body = (
+                        http.HTTPStatus.FORBIDDEN,
+                        Headers(),
+                        f"Failed to open a WebSocket connection: {exc}.\n".encode(),
+                    )
+                elif isinstance(exc, InvalidUpgrade):
+                    if self.debug:
+                        self.logger.debug("! invalid upgrade", exc_info=True)
+                    status, headers, body = (
+                        http.HTTPStatus.UPGRADE_REQUIRED,
+                        Headers([("Upgrade", "websocket")]),
+                        (
+                            f"Failed to open a WebSocket connection: {exc}.\n"
+                            f"\n"
+                            f"You cannot access a WebSocket server directly "
+                            f"with a browser. You need a WebSocket client.\n"
+                        ).encode(),
+                    )
+                elif isinstance(exc, InvalidHandshake):
+                    if self.debug:
+                        self.logger.debug("! invalid handshake", exc_info=True)
+                    status, headers, body = (
+                        http.HTTPStatus.BAD_REQUEST,
+                        Headers(),
+                        f"Failed to open a WebSocket connection: {exc}.\n".encode(),
+                    )
+                else:
+                    self.logger.error("opening handshake failed", exc_info=True)
+                    status, headers, body = (
+                        http.HTTPStatus.INTERNAL_SERVER_ERROR,
+                        Headers(),
+                        (
+                            b"Failed to open a WebSocket connection.\n"
+                            b"See server log for more information.\n"
+                        ),
+                    )
+
+                headers.setdefault("Date", email.utils.formatdate(usegmt=True))
+                headers.setdefault("Server", USER_AGENT)
+                headers.setdefault("Content-Length", str(len(body)))
+                headers.setdefault("Content-Type", "text/plain")
+                headers.setdefault("Connection", "close")
+
+                self.write_http_response(status, headers, body)
+                self.logger.info(
+                    "connection failed (%d %s)", status.value, status.phrase
+                )
+                await self.close_transport()
+                return
+
+            try:
+                await self.ws_handler(self)
+            except Exception:
+                self.logger.error("connection handler failed", exc_info=True)
+                if not self.closed:
+                    self.fail_connection(1011)
+                raise
+
+            try:
+                await self.close()
+            except ConnectionError:
+                raise
+            except Exception:
+                self.logger.error("closing handshake failed", exc_info=True)
+                raise
+
+        except Exception:
+            # Last-ditch attempt to avoid leaking connections on errors.
+            try:
+                self.transport.close()
+            except Exception:  # pragma: no cover
+                pass
+
+        finally:
+            # Unregister the connection with the server when the handler task
+            # terminates. Registration is tied to the lifecycle of the handler
+            # task because the server waits for tasks attached to registered
+            # connections before terminating.
+            self.ws_server.unregister(self)
+            self.logger.info("connection closed")
+
+    async def read_http_request(self) -> Tuple[str, Headers]:
+        """
+        Read request line and headers from the HTTP request.
+
+        If the request contains a body, it may be read from ``self.reader``
+        after this coroutine returns.
+
+        Raises:
+            InvalidMessage: if the HTTP message is malformed or isn't an
+                HTTP/1.1 GET request.
+
+        """
+        try:
+            path, headers = await read_request(self.reader)
+        except asyncio.CancelledError:  # pragma: no cover
+            raise
+        except Exception as exc:
+            raise InvalidMessage("did not receive a valid HTTP request") from exc
+
+        if self.debug:
+            self.logger.debug("< GET %s HTTP/1.1", path)
+            for key, value in headers.raw_items():
+                self.logger.debug("< %s: %s", key, value)
+
+        self.path = path
+        self.request_headers = headers
+
+        return path, headers
+
+    def write_http_response(
+        self, status: http.HTTPStatus, headers: Headers, body: Optional[bytes] = None
+    ) -> None:
+        """
+        Write status line and headers to the HTTP response.
+
+        This coroutine is also able to write a response body.
+
+        """
+        self.response_headers = headers
+
+        if self.debug:
+            self.logger.debug("> HTTP/1.1 %d %s", status.value, status.phrase)
+            for key, value in headers.raw_items():
+                self.logger.debug("> %s: %s", key, value)
+            if body is not None:
+                self.logger.debug("> [body] (%d bytes)", len(body))
+
+        # Since the status line and headers only contain ASCII characters,
+        # we can keep this simple.
+        response = f"HTTP/1.1 {status.value} {status.phrase}\r\n"
+        response += str(headers)
+
+        self.transport.write(response.encode())
+
+        if body is not None:
+            self.transport.write(body)
+
+    async def process_request(
+        self, path: str, request_headers: Headers
+    ) -> Optional[HTTPResponse]:
+        """
+        Intercept the HTTP request and return an HTTP response if appropriate.
+
+        You may override this method in a :class:`WebSocketServerProtocol`
+        subclass, for example:
+
+        * to return a HTTP 200 OK response on a given path; then a load
+          balancer can use this path for a health check;
+        * to authenticate the request and return a HTTP 401 Unauthorized or a
+          HTTP 403 Forbidden when authentication fails.
+
+        You may also override this method with the ``process_request``
+        argument of :func:`serve` and :class:`WebSocketServerProtocol`. This
+        is equivalent, except ``process_request`` won't have access to the
+        protocol instance, so it can't store information for later use.
+
+        :meth:`process_request` is expected to complete quickly. If it may run
+        for a long time, then it should await :meth:`wait_closed` and exit if
+        :meth:`wait_closed` completes, or else it could prevent the server
+        from shutting down.
+
+        Args:
+            path: request path, including optional query string.
+            request_headers: request headers.
+
+        Returns:
+            Optional[Tuple[http.HTTPStatus, HeadersLike, bytes]]: :obj:`None`
+            to continue the WebSocket handshake normally.
+
+            An HTTP response, represented by a 3-uple of the response status,
+            headers, and body, to abort the WebSocket handshake and return
+            that HTTP response instead.
+
+        """
+        if self._process_request is not None:
+            response = self._process_request(path, request_headers)
+            if isinstance(response, Awaitable):
+                return await response
+            else:
+                # For backwards compatibility with 7.0.
+                warnings.warn(
+                    "declare process_request as a coroutine", DeprecationWarning
+                )
+                return response
+        return None
+
+    @staticmethod
+    def process_origin(
+        headers: Headers, origins: Optional[Sequence[Optional[Origin]]] = None
+    ) -> Optional[Origin]:
+        """
+        Handle the Origin HTTP request header.
+
+        Args:
+            headers: request headers.
+            origins: optional list of acceptable origins.
+
+        Raises:
+            InvalidOrigin: if the origin isn't acceptable.
+
+        """
+        # "The user agent MUST NOT include more than one Origin header field"
+        # per https://www.rfc-editor.org/rfc/rfc6454.html#section-7.3.
+        try:
+            origin = cast(Optional[Origin], headers.get("Origin"))
+        except MultipleValuesError as exc:
+            raise InvalidHeader("Origin", "more than one Origin header found") from exc
+        if origins is not None:
+            if origin not in origins:
+                raise InvalidOrigin(origin)
+        return origin
+
+    @staticmethod
+    def process_extensions(
+        headers: Headers,
+        available_extensions: Optional[Sequence[ServerExtensionFactory]],
+    ) -> Tuple[Optional[str], List[Extension]]:
+        """
+        Handle the Sec-WebSocket-Extensions HTTP request header.
+
+        Accept or reject each extension proposed in the client request.
+        Negotiate parameters for accepted extensions.
+
+        Return the Sec-WebSocket-Extensions HTTP response header and the list
+        of accepted extensions.
+
+        :rfc:`6455` leaves the rules up to the specification of each
+        :extension.
+
+        To provide this level of flexibility, for each extension proposed by
+        the client, we check for a match with each extension available in the
+        server configuration. If no match is found, the extension is ignored.
+
+        If several variants of the same extension are proposed by the client,
+        it may be accepted several times, which won't make sense in general.
+        Extensions must implement their own requirements. For this purpose,
+        the list of previously accepted extensions is provided.
+
+        This process doesn't allow the server to reorder extensions. It can
+        only select a subset of the extensions proposed by the client.
+
+        Other requirements, for example related to mandatory extensions or the
+        order of extensions, may be implemented by overriding this method.
+
+        Args:
+            headers: request headers.
+            extensions: optional list of supported extensions.
+
+        Raises:
+            InvalidHandshake: to abort the handshake with an HTTP 400 error.
+
+        """
+        response_header_value: Optional[str] = None
+
+        extension_headers: List[ExtensionHeader] = []
+        accepted_extensions: List[Extension] = []
+
+        header_values = headers.get_all("Sec-WebSocket-Extensions")
+
+        if header_values and available_extensions:
+
+            parsed_header_values: List[ExtensionHeader] = sum(
+                [parse_extension(header_value) for header_value in header_values], []
+            )
+
+            for name, request_params in parsed_header_values:
+
+                for ext_factory in available_extensions:
+
+                    # Skip non-matching extensions based on their name.
+                    if ext_factory.name != name:
+                        continue
+
+                    # Skip non-matching extensions based on their params.
+                    try:
+                        response_params, extension = ext_factory.process_request_params(
+                            request_params, accepted_extensions
+                        )
+                    except NegotiationError:
+                        continue
+
+                    # Add matching extension to the final list.
+                    extension_headers.append((name, response_params))
+                    accepted_extensions.append(extension)
+
+                    # Break out of the loop once we have a match.
+                    break
+
+                # If we didn't break from the loop, no extension in our list
+                # matched what the client sent. The extension is declined.
+
+        # Serialize extension header.
+        if extension_headers:
+            response_header_value = build_extension(extension_headers)
+
+        return response_header_value, accepted_extensions
+
+    # Not @staticmethod because it calls self.select_subprotocol()
+    def process_subprotocol(
+        self, headers: Headers, available_subprotocols: Optional[Sequence[Subprotocol]]
+    ) -> Optional[Subprotocol]:
+        """
+        Handle the Sec-WebSocket-Protocol HTTP request header.
+
+        Return Sec-WebSocket-Protocol HTTP response header, which is the same
+        as the selected subprotocol.
+
+        Args:
+            headers: request headers.
+            available_subprotocols: optional list of supported subprotocols.
+
+        Raises:
+            InvalidHandshake: to abort the handshake with an HTTP 400 error.
+
+        """
+        subprotocol: Optional[Subprotocol] = None
+
+        header_values = headers.get_all("Sec-WebSocket-Protocol")
+
+        if header_values and available_subprotocols:
+
+            parsed_header_values: List[Subprotocol] = sum(
+                [parse_subprotocol(header_value) for header_value in header_values], []
+            )
+
+            subprotocol = self.select_subprotocol(
+                parsed_header_values, available_subprotocols
+            )
+
+        return subprotocol
+
+    def select_subprotocol(
+        self,
+        client_subprotocols: Sequence[Subprotocol],
+        server_subprotocols: Sequence[Subprotocol],
+    ) -> Optional[Subprotocol]:
+        """
+        Pick a subprotocol among those offered by the client.
+
+        If several subprotocols are supported by the client and the server,
+        the default implementation selects the preferred subprotocol by
+        giving equal value to the priorities of the client and the server.
+        If no subprotocol is supported by the client and the server, it
+        proceeds without a subprotocol.
+
+        This is unlikely to be the most useful implementation in practice.
+        Many servers providing a subprotocol will require that the client
+        uses that subprotocol. Such rules can be implemented in a subclass.
+
+        You may also override this method with the ``select_subprotocol``
+        argument of :func:`serve` and :class:`WebSocketServerProtocol`.
+
+        Args:
+            client_subprotocols: list of subprotocols offered by the client.
+            server_subprotocols: list of subprotocols available on the server.
+
+        Returns:
+            Optional[Subprotocol]: Selected subprotocol.
+
+            :obj:`None` to continue without a subprotocol.
+
+
+        """
+        if self._select_subprotocol is not None:
+            return self._select_subprotocol(client_subprotocols, server_subprotocols)
+
+        subprotocols = set(client_subprotocols) & set(server_subprotocols)
+        if not subprotocols:
+            return None
+        priority = lambda p: (
+            client_subprotocols.index(p) + server_subprotocols.index(p)
+        )
+        return sorted(subprotocols, key=priority)[0]
+
+    async def handshake(
+        self,
+        origins: Optional[Sequence[Optional[Origin]]] = None,
+        available_extensions: Optional[Sequence[ServerExtensionFactory]] = None,
+        available_subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLikeOrCallable] = None,
+    ) -> str:
+        """
+        Perform the server side of the opening handshake.
+
+        Args:
+            origins: list of acceptable values of the Origin HTTP header;
+                include :obj:`None` if the lack of an origin is acceptable.
+            extensions: list of supported extensions, in order in which they
+                should be tried.
+            subprotocols: list of supported subprotocols, in order of
+                decreasing preference.
+            extra_headers: arbitrary HTTP headers to add to the response when
+                the handshake succeeds.
+
+        Returns:
+            str: path of the URI of the request.
+
+        Raises:
+            InvalidHandshake: if the handshake fails.
+
+        """
+        path, request_headers = await self.read_http_request()
+
+        # Hook for customizing request handling, for example checking
+        # authentication or treating some paths as plain HTTP endpoints.
+        early_response_awaitable = self.process_request(path, request_headers)
+        if isinstance(early_response_awaitable, Awaitable):
+            early_response = await early_response_awaitable
+        else:
+            # For backwards compatibility with 7.0.
+            warnings.warn("declare process_request as a coroutine", DeprecationWarning)
+            early_response = early_response_awaitable
+
+        # The connection may drop while process_request is running.
+        if self.state is State.CLOSED:
+            raise self.connection_closed_exc()  # pragma: no cover
+
+        # Change the response to a 503 error if the server is shutting down.
+        if not self.ws_server.is_serving():
+            early_response = (
+                http.HTTPStatus.SERVICE_UNAVAILABLE,
+                [],
+                b"Server is shutting down.\n",
+            )
+
+        if early_response is not None:
+            raise AbortHandshake(*early_response)
+
+        key = check_request(request_headers)
+
+        self.origin = self.process_origin(request_headers, origins)
+
+        extensions_header, self.extensions = self.process_extensions(
+            request_headers, available_extensions
+        )
+
+        protocol_header = self.subprotocol = self.process_subprotocol(
+            request_headers, available_subprotocols
+        )
+
+        response_headers = Headers()
+
+        build_response(response_headers, key)
+
+        if extensions_header is not None:
+            response_headers["Sec-WebSocket-Extensions"] = extensions_header
+
+        if protocol_header is not None:
+            response_headers["Sec-WebSocket-Protocol"] = protocol_header
+
+        if callable(extra_headers):
+            extra_headers = extra_headers(path, self.request_headers)
+        if extra_headers is not None:
+            response_headers.update(extra_headers)
+
+        response_headers.setdefault("Date", email.utils.formatdate(usegmt=True))
+        response_headers.setdefault("Server", USER_AGENT)
+
+        self.write_http_response(http.HTTPStatus.SWITCHING_PROTOCOLS, response_headers)
+
+        self.logger.info("connection open")
+
+        self.connection_open()
+
+        return path
+
+
+class WebSocketServer:
+    """
+    WebSocket server returned by :func:`serve`.
+
+    This class provides the same interface as :class:`~asyncio.Server`,
+    notably the :meth:`~asyncio.Server.close`
+    and :meth:`~asyncio.Server.wait_closed` methods.
+
+    It keeps track of WebSocket connections in order to close them properly
+    when shutting down.
+
+    Args:
+        logger: logger for this server;
+            defaults to ``logging.getLogger("websockets.server")``;
+            see the :doc:`logging guide <../topics/logging>` for details.
+
+    """
+
+    def __init__(self, logger: Optional[LoggerLike] = None):
+        if logger is None:
+            logger = logging.getLogger("websockets.server")
+        self.logger = logger
+
+        # Keep track of active connections.
+        self.websockets: Set[WebSocketServerProtocol] = set()
+
+        # Task responsible for closing the server and terminating connections.
+        self.close_task: Optional[asyncio.Task[None]] = None
+
+        # Completed when the server is closed and connections are terminated.
+        self.closed_waiter: asyncio.Future[None]
+
+    def wrap(self, server: asyncio.base_events.Server) -> None:
+        """
+        Attach to a given :class:`~asyncio.Server`.
+
+        Since :meth:`~asyncio.loop.create_server` doesn't support injecting a
+        custom ``Server`` class, the easiest solution that doesn't rely on
+        private :mod:`asyncio` APIs is to:
+
+        - instantiate a :class:`WebSocketServer`
+        - give the protocol factory a reference to that instance
+        - call :meth:`~asyncio.loop.create_server` with the factory
+        - attach the resulting :class:`~asyncio.Server` with this method
+
+        """
+        self.server = server
+        for sock in server.sockets:
+            if sock.family == socket.AF_INET:
+                name = "%s:%d" % sock.getsockname()
+            elif sock.family == socket.AF_INET6:
+                name = "[%s]:%d" % sock.getsockname()[:2]
+            elif sock.family == socket.AF_UNIX:
+                name = sock.getsockname()
+            # In the unlikely event that someone runs websockets over a
+            # protocol other than IP or Unix sockets, avoid crashing.
+            else:  # pragma: no cover
+                name = str(sock.getsockname())
+            self.logger.info("server listening on %s", name)
+
+        # Initialized here because we need a reference to the event loop.
+        # This should be moved back to __init__ in Python 3.10.
+        self.closed_waiter = server.get_loop().create_future()
+
+    def register(self, protocol: WebSocketServerProtocol) -> None:
+        """
+        Register a connection with this server.
+
+        """
+        self.websockets.add(protocol)
+
+    def unregister(self, protocol: WebSocketServerProtocol) -> None:
+        """
+        Unregister a connection with this server.
+
+        """
+        self.websockets.remove(protocol)
+
+    def close(self) -> None:
+        """
+        Close the server.
+
+        This method:
+
+        * closes the underlying :class:`~asyncio.Server`;
+        * rejects new WebSocket connections with an HTTP 503 (service
+          unavailable) error; this happens when the server accepted the TCP
+          connection but didn't complete the WebSocket opening handshake prior
+          to closing;
+        * closes open WebSocket connections with close code 1001 (going away).
+
+        :meth:`close` is idempotent.
+
+        """
+        if self.close_task is None:
+            self.close_task = self.get_loop().create_task(self._close())
+
+    async def _close(self) -> None:
+        """
+        Implementation of :meth:`close`.
+
+        This calls :meth:`~asyncio.Server.close` on the underlying
+        :class:`~asyncio.Server` object to stop accepting new connections and
+        then closes open connections with close code 1001.
+
+        """
+        self.logger.info("server closing")
+
+        # Stop accepting new connections.
+        self.server.close()
+
+        # Wait until self.server.close() completes.
+        await self.server.wait_closed()
+
+        # Wait until all accepted connections reach connection_made() and call
+        # register(). See https://bugs.python.org/issue34852 for details.
+        await asyncio.sleep(0, **loop_if_py_lt_38(self.get_loop()))
+
+        # Close OPEN connections with status code 1001. Since the server was
+        # closed, handshake() closes OPENING connections with a HTTP 503
+        # error. Wait until all connections are closed.
+
+        close_tasks = [
+            asyncio.create_task(websocket.close(1001))
+            for websocket in self.websockets
+            if websocket.state is not State.CONNECTING
+        ]
+        # asyncio.wait doesn't accept an empty first argument.
+        if close_tasks:
+            await asyncio.wait(
+                close_tasks,
+                **loop_if_py_lt_38(self.get_loop()),
+            )
+
+        # Wait until all connection handlers are complete.
+
+        # asyncio.wait doesn't accept an empty first argument.
+        if self.websockets:
+            await asyncio.wait(
+                [websocket.handler_task for websocket in self.websockets],
+                **loop_if_py_lt_38(self.get_loop()),
+            )
+
+        # Tell wait_closed() to return.
+        self.closed_waiter.set_result(None)
+
+        self.logger.info("server closed")
+
+    async def wait_closed(self) -> None:
+        """
+        Wait until the server is closed.
+
+        When :meth:`wait_closed` returns, all TCP connections are closed and
+        all connection handlers have returned.
+
+        To ensure a fast shutdown, a connection handler should always be
+        awaiting at least one of:
+
+        * :meth:`~WebSocketServerProtocol.recv`: when the connection is closed,
+          it raises :exc:`~websockets.exceptions.ConnectionClosedOK`;
+        * :meth:`~WebSocketServerProtocol.wait_closed`: when the connection is
+          closed, it returns.
+
+        Then the connection handler is immediately notified of the shutdown;
+        it can clean up and exit.
+
+        """
+        await asyncio.shield(self.closed_waiter)
+
+    def get_loop(self) -> asyncio.AbstractEventLoop:
+        """
+        See :meth:`asyncio.Server.get_loop`.
+
+        """
+        return self.server.get_loop()
+
+    def is_serving(self) -> bool:
+        """
+        See :meth:`asyncio.Server.is_serving`.
+
+        """
+        return self.server.is_serving()
+
+    async def start_serving(self) -> None:
+        """
+        See :meth:`asyncio.Server.start_serving`.
+
+        """
+        await self.server.start_serving()  # pragma: no cover
+
+    async def serve_forever(self) -> None:
+        """
+        See :meth:`asyncio.Server.serve_forever`.
+
+        """
+        await self.server.serve_forever()  # pragma: no cover
+
+    @property
+    def sockets(self) -> Iterable[socket.socket]:
+        """
+        See :attr:`asyncio.Server.sockets`.
+
+        """
+        return self.server.sockets
+
+    async def __aenter__(self) -> WebSocketServer:
+        return self  # pragma: no cover
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        self.close()  # pragma: no cover
+        await self.wait_closed()  # pragma: no cover
+
+
+class Serve:
+    """
+    Start a WebSocket server listening on ``host`` and ``port``.
+
+    Whenever a client connects, the server creates a
+    :class:`WebSocketServerProtocol`, performs the opening handshake, and
+    delegates to the connection handler, ``ws_handler``.
+
+    The handler receives the :class:`WebSocketServerProtocol` and uses it to
+    send and receive messages.
+
+    Once the handler completes, either normally or with an exception, the
+    server performs the closing handshake and closes the connection.
+
+    Awaiting :func:`serve` yields a :class:`WebSocketServer`. This object
+    provides :meth:`~WebSocketServer.close` and
+    :meth:`~WebSocketServer.wait_closed` methods for shutting down the server.
+
+    :func:`serve` can be used as an asynchronous context manager::
+
+        stop = asyncio.Future()  # set this future to exit the server
+
+        async with serve(...):
+            await stop
+
+    The server is shut down automatically when exiting the context.
+
+    Args:
+        ws_handler: connection handler. It receives the WebSocket connection,
+            which is a :class:`WebSocketServerProtocol`, in argument.
+        host: network interfaces the server is bound to;
+            see :meth:`~asyncio.loop.create_server` for details.
+        port: TCP port the server listens on;
+            see :meth:`~asyncio.loop.create_server` for details.
+        create_protocol: factory for the :class:`asyncio.Protocol` managing
+            the connection; defaults to :class:`WebSocketServerProtocol`; may
+            be set to a wrapper or a subclass to customize connection handling.
+        logger: logger for this server;
+            defaults to ``logging.getLogger("websockets.server")``;
+            see the :doc:`logging guide <../topics/logging>` for details.
+        compression: shortcut that enables the "permessage-deflate" extension
+            by default; may be set to :obj:`None` to disable compression;
+            see the :doc:`compression guide <../topics/compression>` for details.
+        origins: acceptable values of the ``Origin`` header; include
+            :obj:`None` in the list if the lack of an origin is acceptable.
+            This is useful for defending against Cross-Site WebSocket
+            Hijacking attacks.
+        extensions: list of supported extensions, in order in which they
+            should be tried.
+        subprotocols: list of supported subprotocols, in order of decreasing
+            preference.
+        extra_headers (Union[HeadersLike, Callable[[str, Headers], HeadersLike]]):
+            arbitrary HTTP headers to add to the request; this can be
+            a :data:`~websockets.datastructures.HeadersLike` or a callable
+            taking the request path and headers in arguments and returning
+            a :data:`~websockets.datastructures.HeadersLike`.
+        process_request (Optional[Callable[[str, Headers], \
+            Awaitable[Optional[Tuple[http.HTTPStatus, HeadersLike, bytes]]]]]):
+            intercept HTTP request before the opening handshake;
+            see :meth:`~WebSocketServerProtocol.process_request` for details.
+        select_subprotocol: select a subprotocol supported by the client;
+            see :meth:`~WebSocketServerProtocol.select_subprotocol` for details.
+
+    See :class:`~websockets.legacy.protocol.WebSocketCommonProtocol` for the
+    documentation of ``ping_interval``, ``ping_timeout``, ``close_timeout``,
+    ``max_size``, ``max_queue``, ``read_limit``, and ``write_limit``.
+
+    Any other keyword arguments are passed the event loop's
+    :meth:`~asyncio.loop.create_server` method.
+
+    For example:
+
+    * You can set ``ssl`` to a :class:`~ssl.SSLContext` to enable TLS.
+
+    * You can set ``sock`` to a :obj:`~socket.socket` that you created
+      outside of websockets.
+
+    Returns:
+        WebSocketServer: WebSocket server.
+
+    """
+
+    def __init__(
+        self,
+        ws_handler: Union[
+            Callable[[WebSocketServerProtocol], Awaitable[Any]],
+            Callable[[WebSocketServerProtocol, str], Awaitable[Any]],  # deprecated
+        ],
+        host: Optional[Union[str, Sequence[str]]] = None,
+        port: Optional[int] = None,
+        *,
+        create_protocol: Optional[Callable[[Any], WebSocketServerProtocol]] = None,
+        logger: Optional[LoggerLike] = None,
+        compression: Optional[str] = "deflate",
+        origins: Optional[Sequence[Optional[Origin]]] = None,
+        extensions: Optional[Sequence[ServerExtensionFactory]] = None,
+        subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLikeOrCallable] = None,
+        process_request: Optional[
+            Callable[[str, Headers], Awaitable[Optional[HTTPResponse]]]
+        ] = None,
+        select_subprotocol: Optional[
+            Callable[[Sequence[Subprotocol], Sequence[Subprotocol]], Subprotocol]
+        ] = None,
+        ping_interval: Optional[float] = 20,
+        ping_timeout: Optional[float] = 20,
+        close_timeout: Optional[float] = None,
+        max_size: Optional[int] = 2**20,
+        max_queue: Optional[int] = 2**5,
+        read_limit: int = 2**16,
+        write_limit: int = 2**16,
+        **kwargs: Any,
+    ) -> None:
+        # Backwards compatibility: close_timeout used to be called timeout.
+        timeout: Optional[float] = kwargs.pop("timeout", None)
+        if timeout is None:
+            timeout = 10
+        else:
+            warnings.warn("rename timeout to close_timeout", DeprecationWarning)
+        # If both are specified, timeout is ignored.
+        if close_timeout is None:
+            close_timeout = timeout
+
+        # Backwards compatibility: create_protocol used to be called klass.
+        klass: Optional[Type[WebSocketServerProtocol]] = kwargs.pop("klass", None)
+        if klass is None:
+            klass = WebSocketServerProtocol
+        else:
+            warnings.warn("rename klass to create_protocol", DeprecationWarning)
+        # If both are specified, klass is ignored.
+        if create_protocol is None:
+            create_protocol = klass
+
+        # Backwards compatibility: recv() used to return None on closed connections
+        legacy_recv: bool = kwargs.pop("legacy_recv", False)
+
+        # Backwards compatibility: the loop parameter used to be supported.
+        _loop: Optional[asyncio.AbstractEventLoop] = kwargs.pop("loop", None)
+        if _loop is None:
+            loop = asyncio.get_event_loop()
+        else:
+            loop = _loop
+            warnings.warn("remove loop argument", DeprecationWarning)
+
+        ws_server = WebSocketServer(logger=logger)
+
+        secure = kwargs.get("ssl") is not None
+
+        if compression == "deflate":
+            extensions = enable_server_permessage_deflate(extensions)
+        elif compression is not None:
+            raise ValueError(f"unsupported compression: {compression}")
+
+        if subprotocols is not None:
+            validate_subprotocols(subprotocols)
+
+        factory = functools.partial(
+            create_protocol,
+            # For backwards compatibility with 10.0 or earlier. Done here in
+            # addition to WebSocketServerProtocol to trigger the deprecation
+            # warning once per serve() call rather than once per connection.
+            remove_path_argument(ws_handler),
+            ws_server,
+            host=host,
+            port=port,
+            secure=secure,
+            ping_interval=ping_interval,
+            ping_timeout=ping_timeout,
+            close_timeout=close_timeout,
+            max_size=max_size,
+            max_queue=max_queue,
+            read_limit=read_limit,
+            write_limit=write_limit,
+            loop=_loop,
+            legacy_recv=legacy_recv,
+            origins=origins,
+            extensions=extensions,
+            subprotocols=subprotocols,
+            extra_headers=extra_headers,
+            process_request=process_request,
+            select_subprotocol=select_subprotocol,
+            logger=logger,
+        )
+
+        if kwargs.pop("unix", False):
+            path: Optional[str] = kwargs.pop("path", None)
+            # unix_serve(path) must not specify host and port parameters.
+            assert host is None and port is None
+            create_server = functools.partial(
+                loop.create_unix_server, factory, path, **kwargs
+            )
+        else:
+            create_server = functools.partial(
+                loop.create_server, factory, host, port, **kwargs
+            )
+
+        # This is a coroutine function.
+        self._create_server = create_server
+        self.ws_server = ws_server
+
+    # async with serve(...)
+
+    async def __aenter__(self) -> WebSocketServer:
+        return await self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        self.ws_server.close()
+        await self.ws_server.wait_closed()
+
+    # await serve(...)
+
+    def __await__(self) -> Generator[Any, None, WebSocketServer]:
+        # Create a suitable iterator by calling __await__ on a coroutine.
+        return self.__await_impl__().__await__()
+
+    async def __await_impl__(self) -> WebSocketServer:
+        server = await self._create_server()
+        self.ws_server.wrap(server)
+        return self.ws_server
+
+    # yield from serve(...) - remove when dropping Python < 3.10
+
+    __iter__ = __await__
+
+
+serve = Serve
+
+
+def unix_serve(
+    ws_handler: Union[
+        Callable[[WebSocketServerProtocol], Awaitable[Any]],
+        Callable[[WebSocketServerProtocol, str], Awaitable[Any]],  # deprecated
+    ],
+    path: Optional[str] = None,
+    **kwargs: Any,
+) -> Serve:
+    """
+    Similar to :func:`serve`, but for listening on Unix sockets.
+
+    This function builds upon the event
+    loop's :meth:`~asyncio.loop.create_unix_server` method.
+
+    It is only available on Unix.
+
+    It's useful for deploying a server behind a reverse proxy such as nginx.
+
+    Args:
+        path: file system path to the Unix socket.
+
+    """
+    return serve(ws_handler, path=path, unix=True, **kwargs)
+
+
+def remove_path_argument(
+    ws_handler: Union[
+        Callable[[WebSocketServerProtocol], Awaitable[Any]],
+        Callable[[WebSocketServerProtocol, str], Awaitable[Any]],
+    ]
+) -> Callable[[WebSocketServerProtocol], Awaitable[Any]]:
+    try:
+        inspect.signature(ws_handler).bind(None)
+    except TypeError:
+        try:
+            inspect.signature(ws_handler).bind(None, "")
+        except TypeError:  # pragma: no cover
+            # ws_handler accepts neither one nor two arguments; leave it alone.
+            pass
+        else:
+            # ws_handler accepts two arguments; activate backwards compatibility.
+
+            # Enable deprecation warning and announce deprecation in 11.0.
+            # warnings.warn("remove second argument of ws_handler", DeprecationWarning)
+
+            async def _ws_handler(websocket: WebSocketServerProtocol) -> Any:
+                return await cast(
+                    Callable[[WebSocketServerProtocol, str], Awaitable[Any]],
+                    ws_handler,
+                )(websocket, websocket.path)
+
+            return _ws_handler
+
+    return cast(
+        Callable[[WebSocketServerProtocol], Awaitable[Any]],
+        ws_handler,
+    )
diff --git a/myenv/lib/python3.9/site-packages/websockets/py.typed b/myenv/lib/python3.9/site-packages/websockets/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/myenv/lib/python3.9/site-packages/websockets/server.py b/myenv/lib/python3.9/site-packages/websockets/server.py
new file mode 100644
index 0000000..5dad50b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/server.py
@@ -0,0 +1,521 @@
+from __future__ import annotations
+
+import base64
+import binascii
+import email.utils
+import http
+from typing import Generator, List, Optional, Sequence, Tuple, cast
+
+from .connection import CONNECTING, OPEN, SERVER, Connection, State
+from .datastructures import Headers, MultipleValuesError
+from .exceptions import (
+    InvalidHandshake,
+    InvalidHeader,
+    InvalidHeaderValue,
+    InvalidOrigin,
+    InvalidStatus,
+    InvalidUpgrade,
+    NegotiationError,
+)
+from .extensions import Extension, ServerExtensionFactory
+from .headers import (
+    build_extension,
+    parse_connection,
+    parse_extension,
+    parse_subprotocol,
+    parse_upgrade,
+)
+from .http import USER_AGENT
+from .http11 import Request, Response
+from .typing import (
+    ConnectionOption,
+    ExtensionHeader,
+    LoggerLike,
+    Origin,
+    Subprotocol,
+    UpgradeProtocol,
+)
+from .utils import accept_key
+
+
+# See #940 for why lazy_import isn't used here for backwards compatibility.
+from .legacy.server import *  # isort:skip  # noqa
+
+
+__all__ = ["ServerConnection"]
+
+
+class ServerConnection(Connection):
+    """
+    Sans-I/O implementation of a WebSocket server connection.
+
+    Args:
+        origins: acceptable values of the ``Origin`` header; include
+            :obj:`None` in the list if the lack of an origin is acceptable.
+            This is useful for defending against Cross-Site WebSocket
+            Hijacking attacks.
+        extensions: list of supported extensions, in order in which they
+            should be tried.
+        subprotocols: list of supported subprotocols, in order of decreasing
+            preference.
+        state: initial state of the WebSocket connection.
+        max_size: maximum size of incoming messages in bytes;
+            :obj:`None` to disable the limit.
+        logger: logger for this connection;
+            defaults to ``logging.getLogger("websockets.client")``;
+            see the :doc:`logging guide <../topics/logging>` for details.
+
+    """
+
+    def __init__(
+        self,
+        origins: Optional[Sequence[Optional[Origin]]] = None,
+        extensions: Optional[Sequence[ServerExtensionFactory]] = None,
+        subprotocols: Optional[Sequence[Subprotocol]] = None,
+        state: State = CONNECTING,
+        max_size: Optional[int] = 2**20,
+        logger: Optional[LoggerLike] = None,
+    ):
+        super().__init__(
+            side=SERVER,
+            state=state,
+            max_size=max_size,
+            logger=logger,
+        )
+        self.origins = origins
+        self.available_extensions = extensions
+        self.available_subprotocols = subprotocols
+
+    def accept(self, request: Request) -> Response:
+        """
+        Create a handshake response to accept the connection.
+
+        If the connection cannot be established, the handshake response
+        actually rejects the handshake.
+
+        You must send the handshake response with :meth:`send_response`.
+
+        You can modify it before sending it, for example to add HTTP headers.
+
+        Args:
+            request: WebSocket handshake request event received from the client.
+
+        Returns:
+            Response: WebSocket handshake response event to send to the client.
+
+        """
+        try:
+            (
+                accept_header,
+                extensions_header,
+                protocol_header,
+            ) = self.process_request(request)
+        except InvalidOrigin as exc:
+            request._exception = exc
+            self.handshake_exc = exc
+            if self.debug:
+                self.logger.debug("! invalid origin", exc_info=True)
+            return self.reject(
+                http.HTTPStatus.FORBIDDEN,
+                f"Failed to open a WebSocket connection: {exc}.\n",
+            )
+        except InvalidUpgrade as exc:
+            request._exception = exc
+            self.handshake_exc = exc
+            if self.debug:
+                self.logger.debug("! invalid upgrade", exc_info=True)
+            response = self.reject(
+                http.HTTPStatus.UPGRADE_REQUIRED,
+                (
+                    f"Failed to open a WebSocket connection: {exc}.\n"
+                    f"\n"
+                    f"You cannot access a WebSocket server directly "
+                    f"with a browser. You need a WebSocket client.\n"
+                ),
+            )
+            response.headers["Upgrade"] = "websocket"
+            return response
+        except InvalidHandshake as exc:
+            request._exception = exc
+            self.handshake_exc = exc
+            if self.debug:
+                self.logger.debug("! invalid handshake", exc_info=True)
+            return self.reject(
+                http.HTTPStatus.BAD_REQUEST,
+                f"Failed to open a WebSocket connection: {exc}.\n",
+            )
+        except Exception as exc:
+            request._exception = exc
+            self.handshake_exc = exc
+            self.logger.error("opening handshake failed", exc_info=True)
+            return self.reject(
+                http.HTTPStatus.INTERNAL_SERVER_ERROR,
+                (
+                    "Failed to open a WebSocket connection.\n"
+                    "See server log for more information.\n"
+                ),
+            )
+
+        headers = Headers()
+
+        headers["Date"] = email.utils.formatdate(usegmt=True)
+
+        headers["Upgrade"] = "websocket"
+        headers["Connection"] = "Upgrade"
+        headers["Sec-WebSocket-Accept"] = accept_header
+
+        if extensions_header is not None:
+            headers["Sec-WebSocket-Extensions"] = extensions_header
+
+        if protocol_header is not None:
+            headers["Sec-WebSocket-Protocol"] = protocol_header
+
+        headers["Server"] = USER_AGENT
+
+        self.logger.info("connection open")
+        return Response(101, "Switching Protocols", headers)
+
+    def process_request(
+        self, request: Request
+    ) -> Tuple[str, Optional[str], Optional[str]]:
+        """
+        Check a handshake request and negotiate extensions and subprotocol.
+
+        This function doesn't verify that the request is an HTTP/1.1 or higher
+        GET request and doesn't check the ``Host`` header. These controls are
+        usually performed earlier in the HTTP request handling code. They're
+        the responsibility of the caller.
+
+        Args:
+            request: WebSocket handshake request received from the client.
+
+        Returns:
+            Tuple[str, Optional[str], Optional[str]]:
+            ``Sec-WebSocket-Accept``, ``Sec-WebSocket-Extensions``, and
+            ``Sec-WebSocket-Protocol`` headers for the handshake response.
+
+        Raises:
+            InvalidHandshake: if the handshake request is invalid;
+                then the server must return 400 Bad Request error.
+
+        """
+        headers = request.headers
+
+        connection: List[ConnectionOption] = sum(
+            [parse_connection(value) for value in headers.get_all("Connection")], []
+        )
+
+        if not any(value.lower() == "upgrade" for value in connection):
+            raise InvalidUpgrade(
+                "Connection", ", ".join(connection) if connection else None
+            )
+
+        upgrade: List[UpgradeProtocol] = sum(
+            [parse_upgrade(value) for value in headers.get_all("Upgrade")], []
+        )
+
+        # For compatibility with non-strict implementations, ignore case when
+        # checking the Upgrade header. The RFC always uses "websocket", except
+        # in section 11.2. (IANA registration) where it uses "WebSocket".
+        if not (len(upgrade) == 1 and upgrade[0].lower() == "websocket"):
+            raise InvalidUpgrade("Upgrade", ", ".join(upgrade) if upgrade else None)
+
+        try:
+            key = headers["Sec-WebSocket-Key"]
+        except KeyError as exc:
+            raise InvalidHeader("Sec-WebSocket-Key") from exc
+        except MultipleValuesError as exc:
+            raise InvalidHeader(
+                "Sec-WebSocket-Key", "more than one Sec-WebSocket-Key header found"
+            ) from exc
+
+        try:
+            raw_key = base64.b64decode(key.encode(), validate=True)
+        except binascii.Error as exc:
+            raise InvalidHeaderValue("Sec-WebSocket-Key", key) from exc
+        if len(raw_key) != 16:
+            raise InvalidHeaderValue("Sec-WebSocket-Key", key)
+
+        try:
+            version = headers["Sec-WebSocket-Version"]
+        except KeyError as exc:
+            raise InvalidHeader("Sec-WebSocket-Version") from exc
+        except MultipleValuesError as exc:
+            raise InvalidHeader(
+                "Sec-WebSocket-Version",
+                "more than one Sec-WebSocket-Version header found",
+            ) from exc
+
+        if version != "13":
+            raise InvalidHeaderValue("Sec-WebSocket-Version", version)
+
+        accept_header = accept_key(key)
+
+        self.origin = self.process_origin(headers)
+
+        extensions_header, self.extensions = self.process_extensions(headers)
+
+        protocol_header = self.subprotocol = self.process_subprotocol(headers)
+
+        return (
+            accept_header,
+            extensions_header,
+            protocol_header,
+        )
+
+    def process_origin(self, headers: Headers) -> Optional[Origin]:
+        """
+        Handle the Origin HTTP request header.
+
+        Args:
+            headers: WebSocket handshake request headers.
+
+        Returns:
+           Optional[Origin]: origin, if it is acceptable.
+
+        Raises:
+            InvalidOrigin: if the origin isn't acceptable.
+
+        """
+        # "The user agent MUST NOT include more than one Origin header field"
+        # per https://www.rfc-editor.org/rfc/rfc6454.html#section-7.3.
+        try:
+            origin = cast(Optional[Origin], headers.get("Origin"))
+        except MultipleValuesError as exc:
+            raise InvalidHeader("Origin", "more than one Origin header found") from exc
+        if self.origins is not None:
+            if origin not in self.origins:
+                raise InvalidOrigin(origin)
+        return origin
+
+    def process_extensions(
+        self,
+        headers: Headers,
+    ) -> Tuple[Optional[str], List[Extension]]:
+        """
+        Handle the Sec-WebSocket-Extensions HTTP request header.
+
+        Accept or reject each extension proposed in the client request.
+        Negotiate parameters for accepted extensions.
+
+        :rfc:`6455` leaves the rules up to the specification of each
+        :extension.
+
+        To provide this level of flexibility, for each extension proposed by
+        the client, we check for a match with each extension available in the
+        server configuration. If no match is found, the extension is ignored.
+
+        If several variants of the same extension are proposed by the client,
+        it may be accepted several times, which won't make sense in general.
+        Extensions must implement their own requirements. For this purpose,
+        the list of previously accepted extensions is provided.
+
+        This process doesn't allow the server to reorder extensions. It can
+        only select a subset of the extensions proposed by the client.
+
+        Other requirements, for example related to mandatory extensions or the
+        order of extensions, may be implemented by overriding this method.
+
+        Args:
+            headers: WebSocket handshake request headers.
+
+        Returns:
+            Tuple[Optional[str], List[Extension]]: ``Sec-WebSocket-Extensions``
+            HTTP response header and list of accepted extensions.
+
+        Raises:
+            InvalidHandshake: to abort the handshake with an HTTP 400 error.
+
+        """
+        response_header_value: Optional[str] = None
+
+        extension_headers: List[ExtensionHeader] = []
+        accepted_extensions: List[Extension] = []
+
+        header_values = headers.get_all("Sec-WebSocket-Extensions")
+
+        if header_values and self.available_extensions:
+
+            parsed_header_values: List[ExtensionHeader] = sum(
+                [parse_extension(header_value) for header_value in header_values], []
+            )
+
+            for name, request_params in parsed_header_values:
+
+                for ext_factory in self.available_extensions:
+
+                    # Skip non-matching extensions based on their name.
+                    if ext_factory.name != name:
+                        continue
+
+                    # Skip non-matching extensions based on their params.
+                    try:
+                        response_params, extension = ext_factory.process_request_params(
+                            request_params, accepted_extensions
+                        )
+                    except NegotiationError:
+                        continue
+
+                    # Add matching extension to the final list.
+                    extension_headers.append((name, response_params))
+                    accepted_extensions.append(extension)
+
+                    # Break out of the loop once we have a match.
+                    break
+
+                # If we didn't break from the loop, no extension in our list
+                # matched what the client sent. The extension is declined.
+
+        # Serialize extension header.
+        if extension_headers:
+            response_header_value = build_extension(extension_headers)
+
+        return response_header_value, accepted_extensions
+
+    def process_subprotocol(self, headers: Headers) -> Optional[Subprotocol]:
+        """
+        Handle the Sec-WebSocket-Protocol HTTP request header.
+
+        Args:
+            headers: WebSocket handshake request headers.
+
+        Returns:
+           Optional[Subprotocol]: Subprotocol, if one was selected; this is
+           also the value of the ``Sec-WebSocket-Protocol`` response header.
+
+        Raises:
+            InvalidHandshake: to abort the handshake with an HTTP 400 error.
+
+        """
+        subprotocol: Optional[Subprotocol] = None
+
+        header_values = headers.get_all("Sec-WebSocket-Protocol")
+
+        if header_values and self.available_subprotocols:
+
+            parsed_header_values: List[Subprotocol] = sum(
+                [parse_subprotocol(header_value) for header_value in header_values], []
+            )
+
+            subprotocol = self.select_subprotocol(
+                parsed_header_values, self.available_subprotocols
+            )
+
+        return subprotocol
+
+    def select_subprotocol(
+        self,
+        client_subprotocols: Sequence[Subprotocol],
+        server_subprotocols: Sequence[Subprotocol],
+    ) -> Optional[Subprotocol]:
+        """
+        Pick a subprotocol among those offered by the client.
+
+        If several subprotocols are supported by the client and the server,
+        the default implementation selects the preferred subprotocols by
+        giving equal value to the priorities of the client and the server.
+
+        If no common subprotocol is supported by the client and the server, it
+        proceeds without a subprotocol.
+
+        This is unlikely to be the most useful implementation in practice, as
+        many servers providing a subprotocol will require that the client uses
+        that subprotocol.
+
+        Args:
+            client_subprotocols: list of subprotocols offered by the client.
+            server_subprotocols: list of subprotocols available on the server.
+
+        Returns:
+            Optional[Subprotocol]: Subprotocol, if a common subprotocol was
+            found.
+
+        """
+        subprotocols = set(client_subprotocols) & set(server_subprotocols)
+        if not subprotocols:
+            return None
+        priority = lambda p: (
+            client_subprotocols.index(p) + server_subprotocols.index(p)
+        )
+        return sorted(subprotocols, key=priority)[0]
+
+    def reject(
+        self,
+        status: http.HTTPStatus,
+        text: str,
+    ) -> Response:
+        """
+        Create a handshake response to reject the connection.
+
+        A short plain text response is the best fallback when failing to
+        establish a WebSocket connection.
+
+        You must send the handshake response with :meth:`send_response`.
+
+        You can modify it before sending it, for example to alter HTTP headers.
+
+        Args:
+            status: HTTP status code.
+            text: HTTP response body; will be encoded to UTF-8.
+
+        Returns:
+            Response: WebSocket handshake response event to send to the client.
+
+        """
+        body = text.encode()
+        headers = Headers(
+            [
+                ("Date", email.utils.formatdate(usegmt=True)),
+                ("Connection", "close"),
+                ("Content-Length", str(len(body))),
+                ("Content-Type", "text/plain; charset=utf-8"),
+                ("Server", USER_AGENT),
+            ]
+        )
+        response = Response(status.value, status.phrase, headers, body)
+        # When reject() is called from accept(), handshake_exc is already set.
+        # If a user calls reject(), set handshake_exc to guarantee invariant:
+        # "handshake_exc is None if and only if opening handshake succeded."
+        if self.handshake_exc is None:
+            self.handshake_exc = InvalidStatus(response)
+        self.logger.info("connection failed (%d %s)", status.value, status.phrase)
+        return response
+
+    def send_response(self, response: Response) -> None:
+        """
+        Send a handshake response to the client.
+
+        Args:
+            response: WebSocket handshake response event to send.
+
+        """
+        if self.debug:
+            code, phrase = response.status_code, response.reason_phrase
+            self.logger.debug("> HTTP/1.1 %d %s", code, phrase)
+            for key, value in response.headers.raw_items():
+                self.logger.debug("> %s: %s", key, value)
+            if response.body is not None:
+                self.logger.debug("> [body] (%d bytes)", len(response.body))
+
+        self.writes.append(response.serialize())
+
+        if response.status_code == 101:
+            assert self.state is CONNECTING
+            self.state = OPEN
+        else:
+            self.send_eof()
+            self.parser = self.discard()
+            next(self.parser)  # start coroutine
+
+    def parse(self) -> Generator[None, None, None]:
+        if self.state is CONNECTING:
+            request = yield from Request.parse(self.reader.read_line)
+
+            if self.debug:
+                self.logger.debug("< GET %s HTTP/1.1", request.path)
+                for key, value in request.headers.raw_items():
+                    self.logger.debug("< %s: %s", key, value)
+
+            self.events.append(request)
+
+        yield from super().parse()
diff --git a/myenv/lib/python3.9/site-packages/websockets/speedups.c b/myenv/lib/python3.9/site-packages/websockets/speedups.c
new file mode 100644
index 0000000..a195904
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/speedups.c
@@ -0,0 +1,223 @@
+/* C implementation of performance sensitive functions. */
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <stdint.h> /* uint8_t, uint32_t, uint64_t */
+
+#if __ARM_NEON
+#include <arm_neon.h>
+#elif __SSE2__
+#include <emmintrin.h>
+#endif
+
+static const Py_ssize_t MASK_LEN = 4;
+
+/* Similar to PyBytes_AsStringAndSize, but accepts more types */
+
+static int
+_PyBytesLike_AsStringAndSize(PyObject *obj, PyObject **tmp, char **buffer, Py_ssize_t *length)
+{
+    // This supports bytes, bytearrays, and memoryview objects,
+    // which are common data structures for handling byte streams.
+    // websockets.framing.prepare_data() returns only these types.
+    // If *tmp isn't NULL, the caller gets a new reference.
+    if (PyBytes_Check(obj))
+    {
+        *tmp = NULL;
+        *buffer = PyBytes_AS_STRING(obj);
+        *length = PyBytes_GET_SIZE(obj);
+    }
+    else if (PyByteArray_Check(obj))
+    {
+        *tmp = NULL;
+        *buffer = PyByteArray_AS_STRING(obj);
+        *length = PyByteArray_GET_SIZE(obj);
+    }
+    else if (PyMemoryView_Check(obj))
+    {
+        *tmp = PyMemoryView_GetContiguous(obj, PyBUF_READ, 'C');
+        if (*tmp == NULL)
+        {
+            return -1;
+        }
+        Py_buffer *mv_buf;
+        mv_buf = PyMemoryView_GET_BUFFER(*tmp);
+        *buffer = mv_buf->buf;
+        *length = mv_buf->len;
+    }
+    else
+    {
+        PyErr_Format(
+            PyExc_TypeError,
+            "expected a bytes-like object, %.200s found",
+            Py_TYPE(obj)->tp_name);
+        return -1;
+    }
+
+    return 0;
+}
+
+/* C implementation of websockets.utils.apply_mask */
+
+static PyObject *
+apply_mask(PyObject *self, PyObject *args, PyObject *kwds)
+{
+
+    // In order to support various bytes-like types, accept any Python object.
+
+    static char *kwlist[] = {"data", "mask", NULL};
+    PyObject *input_obj;
+    PyObject *mask_obj;
+
+    // A pointer to a char * + length will be extracted from the data and mask
+    // arguments, possibly via a Py_buffer.
+
+    PyObject *input_tmp = NULL;
+    char *input;
+    Py_ssize_t input_len;
+    PyObject *mask_tmp = NULL;
+    char *mask;
+    Py_ssize_t mask_len;
+
+    // Initialize a PyBytesObject then get a pointer to the underlying char *
+    // in order to avoid an extra memory copy in PyBytes_FromStringAndSize.
+
+    PyObject *result = NULL;
+    char *output;
+
+    // Other variables.
+
+    Py_ssize_t i = 0;
+
+    // Parse inputs.
+
+    if (!PyArg_ParseTupleAndKeywords(
+            args, kwds, "OO", kwlist, &input_obj, &mask_obj))
+    {
+        goto exit;
+    }
+
+    if (_PyBytesLike_AsStringAndSize(input_obj, &input_tmp, &input, &input_len) == -1)
+    {
+        goto exit;
+    }
+
+    if (_PyBytesLike_AsStringAndSize(mask_obj, &mask_tmp, &mask, &mask_len) == -1)
+    {
+        goto exit;
+    }
+
+    if (mask_len != MASK_LEN)
+    {
+        PyErr_SetString(PyExc_ValueError, "mask must contain 4 bytes");
+        goto exit;
+    }
+
+    // Create output.
+
+    result = PyBytes_FromStringAndSize(NULL, input_len);
+    if (result == NULL)
+    {
+        goto exit;
+    }
+
+    // Since we just created result, we don't need error checks.
+    output = PyBytes_AS_STRING(result);
+
+    // Perform the masking operation.
+
+    // Apparently GCC cannot figure out the following optimizations by itself.
+
+    // We need a new scope for MSVC 2010 (non C99 friendly)
+    {
+#if __ARM_NEON
+
+        // With NEON support, XOR by blocks of 16 bytes = 128 bits.
+
+        Py_ssize_t input_len_128 = input_len & ~15;
+        uint8x16_t mask_128 = vreinterpretq_u8_u32(vdupq_n_u32(*(uint32_t *)mask));
+
+        for (; i < input_len_128; i += 16)
+        {
+            uint8x16_t in_128 = vld1q_u8((uint8_t *)(input + i));
+            uint8x16_t out_128 = veorq_u8(in_128, mask_128);
+            vst1q_u8((uint8_t *)(output + i), out_128);
+        }
+
+#elif __SSE2__
+
+        // With SSE2 support, XOR by blocks of 16 bytes = 128 bits.
+
+        // Since we cannot control the 16-bytes alignment of input and output
+        // buffers, we rely on loadu/storeu rather than load/store.
+
+        Py_ssize_t input_len_128 = input_len & ~15;
+        __m128i mask_128 = _mm_set1_epi32(*(uint32_t *)mask);
+
+        for (; i < input_len_128; i += 16)
+        {
+            __m128i in_128 = _mm_loadu_si128((__m128i *)(input + i));
+            __m128i out_128 = _mm_xor_si128(in_128, mask_128);
+            _mm_storeu_si128((__m128i *)(output + i), out_128);
+        }
+
+#else
+
+        // Without SSE2 support, XOR by blocks of 8 bytes = 64 bits.
+
+        // We assume the memory allocator aligns everything on 8 bytes boundaries.
+
+        Py_ssize_t input_len_64 = input_len & ~7;
+        uint32_t mask_32 = *(uint32_t *)mask;
+        uint64_t mask_64 = ((uint64_t)mask_32 << 32) | (uint64_t)mask_32;
+
+        for (; i < input_len_64; i += 8)
+        {
+            *(uint64_t *)(output + i) = *(uint64_t *)(input + i) ^ mask_64;
+        }
+
+#endif
+    }
+
+    // XOR the remainder of the input byte by byte.
+
+    for (; i < input_len; i++)
+    {
+        output[i] = input[i] ^ mask[i & (MASK_LEN - 1)];
+    }
+
+exit:
+    Py_XDECREF(input_tmp);
+    Py_XDECREF(mask_tmp);
+    return result;
+
+}
+
+static PyMethodDef speedups_methods[] = {
+    {
+        "apply_mask",
+        (PyCFunction)apply_mask,
+        METH_VARARGS | METH_KEYWORDS,
+        "Apply masking to the data of a WebSocket message.",
+    },
+    {NULL, NULL, 0, NULL},      /* Sentinel */
+};
+
+static struct PyModuleDef speedups_module = {
+    PyModuleDef_HEAD_INIT,
+    "websocket.speedups",       /* m_name */
+    "C implementation of performance sensitive functions.",
+                                /* m_doc */
+    -1,                         /* m_size */
+    speedups_methods,           /* m_methods */
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC
+PyInit_speedups(void)
+{
+    return PyModule_Create(&speedups_module);
+}
diff --git a/myenv/lib/python3.9/site-packages/websockets/speedups.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/websockets/speedups.cpython-39-darwin.so
new file mode 100755
index 0000000..f84f0b4
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/websockets/speedups.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/websockets/streams.py b/myenv/lib/python3.9/site-packages/websockets/streams.py
new file mode 100644
index 0000000..f861d4b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/streams.py
@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from typing import Generator
+
+
+class StreamReader:
+    """
+    Generator-based stream reader.
+
+    This class doesn't support concurrent calls to :meth:`read_line`,
+    :meth:`read_exact`, or :meth:`read_to_eof`. Make sure calls are
+    serialized.
+
+    """
+
+    def __init__(self) -> None:
+        self.buffer = bytearray()
+        self.eof = False
+
+    def read_line(self, m: int) -> Generator[None, None, bytes]:
+        """
+        Read a LF-terminated line from the stream.
+
+        This is a generator-based coroutine.
+
+        The return value includes the LF character.
+
+        Args:
+            m: maximum number bytes to read; this is a security limit.
+
+        Raises:
+            EOFError: if the stream ends without a LF.
+            RuntimeError: if the stream ends in more than ``m`` bytes.
+
+        """
+        n = 0  # number of bytes to read
+        p = 0  # number of bytes without a newline
+        while True:
+            n = self.buffer.find(b"\n", p) + 1
+            if n > 0:
+                break
+            p = len(self.buffer)
+            if p > m:
+                raise RuntimeError(f"read {p} bytes, expected no more than {m} bytes")
+            if self.eof:
+                raise EOFError(f"stream ends after {p} bytes, before end of line")
+            yield
+        if n > m:
+            raise RuntimeError(f"read {n} bytes, expected no more than {m} bytes")
+        r = self.buffer[:n]
+        del self.buffer[:n]
+        return r
+
+    def read_exact(self, n: int) -> Generator[None, None, bytes]:
+        """
+        Read a given number of bytes from the stream.
+
+        This is a generator-based coroutine.
+
+        Args:
+            n: how many bytes to read.
+
+        Raises:
+            EOFError: if the stream ends in less than ``n`` bytes.
+
+        """
+        assert n >= 0
+        while len(self.buffer) < n:
+            if self.eof:
+                p = len(self.buffer)
+                raise EOFError(f"stream ends after {p} bytes, expected {n} bytes")
+            yield
+        r = self.buffer[:n]
+        del self.buffer[:n]
+        return r
+
+    def read_to_eof(self, m: int) -> Generator[None, None, bytes]:
+        """
+        Read all bytes from the stream.
+
+        This is a generator-based coroutine.
+
+        Args:
+            m: maximum number bytes to read; this is a security limit.
+
+        Raises:
+            RuntimeError: if the stream ends in more than ``m`` bytes.
+
+        """
+        while not self.eof:
+            p = len(self.buffer)
+            if p > m:
+                raise RuntimeError(f"read {p} bytes, expected no more than {m} bytes")
+            yield
+        r = self.buffer[:]
+        del self.buffer[:]
+        return r
+
+    def at_eof(self) -> Generator[None, None, bool]:
+        """
+        Tell whether the stream has ended and all data was read.
+
+        This is a generator-based coroutine.
+
+        """
+        while True:
+            if self.buffer:
+                return False
+            if self.eof:
+                return True
+            # When all data was read but the stream hasn't ended, we can't
+            # tell if until either feed_data() or feed_eof() is called.
+            yield
+
+    def feed_data(self, data: bytes) -> None:
+        """
+        Write data to the stream.
+
+        :meth:`feed_data` cannot be called after :meth:`feed_eof`.
+
+        Args:
+            data: data to write.
+
+        Raises:
+            EOFError: if the stream has ended.
+
+        """
+        if self.eof:
+            raise EOFError("stream ended")
+        self.buffer += data
+
+    def feed_eof(self) -> None:
+        """
+        End the stream.
+
+        :meth:`feed_eof` cannot be called more than once.
+
+        Raises:
+            EOFError: if the stream has ended.
+
+        """
+        if self.eof:
+            raise EOFError("stream ended")
+        self.eof = True
+
+    def discard(self) -> None:
+        """
+        Discard all buffered data, but don't end the stream.
+
+        """
+        del self.buffer[:]
diff --git a/myenv/lib/python3.9/site-packages/websockets/typing.py b/myenv/lib/python3.9/site-packages/websockets/typing.py
new file mode 100644
index 0000000..e672ba0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/typing.py
@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import logging
+from typing import List, NewType, Optional, Tuple, Union
+
+
+__all__ = [
+    "Data",
+    "LoggerLike",
+    "Origin",
+    "Subprotocol",
+    "ExtensionName",
+    "ExtensionParameter",
+]
+
+
+# Public types used in the signature of public APIs
+
+Data = Union[str, bytes]
+"""Types supported in a WebSocket message:
+:class:`str` for a Text_ frame, :class:`bytes` for a Binary_.
+
+.. _Text: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6
+.. _Binary : https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6
+
+"""
+
+
+LoggerLike = Union[logging.Logger, logging.LoggerAdapter]
+"""Types accepted where a :class:`~logging.Logger` is expected."""
+
+
+Origin = NewType("Origin", str)
+"""Value of a ``Origin`` header."""
+
+
+Subprotocol = NewType("Subprotocol", str)
+"""Subprotocol in a ``Sec-WebSocket-Protocol`` header."""
+
+
+ExtensionName = NewType("ExtensionName", str)
+"""Name of a WebSocket extension."""
+
+
+ExtensionParameter = Tuple[str, Optional[str]]
+"""Parameter of a WebSocket extension."""
+
+
+# Private types
+
+ExtensionHeader = Tuple[ExtensionName, List[ExtensionParameter]]
+"""Extension in a ``Sec-WebSocket-Extensions`` header."""
+
+
+ConnectionOption = NewType("ConnectionOption", str)
+"""Connection option in a ``Connection`` header."""
+
+
+UpgradeProtocol = NewType("UpgradeProtocol", str)
+"""Upgrade protocol in an ``Upgrade`` header."""
diff --git a/myenv/lib/python3.9/site-packages/websockets/uri.py b/myenv/lib/python3.9/site-packages/websockets/uri.py
new file mode 100644
index 0000000..fff0c38
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/uri.py
@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import dataclasses
+import urllib.parse
+from typing import Optional, Tuple
+
+from . import exceptions
+
+
+__all__ = ["parse_uri", "WebSocketURI"]
+
+
+@dataclasses.dataclass
+class WebSocketURI:
+    """
+    WebSocket URI.
+
+    Attributes:
+        secure: :obj:`True` for a ``wss`` URI, :obj:`False` for a ``ws`` URI.
+        host: Normalized to lower case.
+        port: Always set even if it's the default.
+        path: May be empty.
+        query: May be empty if the URI doesn't include a query component.
+        username: Available when the URI contains `User Information`_.
+        password: Available when the URI contains `User Information`_.
+
+    .. _User Information: https://www.rfc-editor.org/rfc/rfc3986.html#section-3.2.1
+
+    """
+
+    secure: bool
+    host: str
+    port: int
+    path: str
+    query: str
+    username: Optional[str]
+    password: Optional[str]
+
+    @property
+    def resource_name(self) -> str:
+        if self.path:
+            resource_name = self.path
+        else:
+            resource_name = "/"
+        if self.query:
+            resource_name += "?" + self.query
+        return resource_name
+
+    @property
+    def user_info(self) -> Optional[Tuple[str, str]]:
+        if self.username is None:
+            return None
+        assert self.password is not None
+        return (self.username, self.password)
+
+
+# All characters from the gen-delims and sub-delims sets in RFC 3987.
+DELIMS = ":/?#[]@!$&'()*+,;="
+
+
+def parse_uri(uri: str) -> WebSocketURI:
+    """
+    Parse and validate a WebSocket URI.
+
+    Args:
+        uri: WebSocket URI.
+
+    Returns:
+        WebSocketURI: Parsed WebSocket URI.
+
+    Raises:
+        InvalidURI: if ``uri`` isn't a valid WebSocket URI.
+
+    """
+    parsed = urllib.parse.urlparse(uri)
+    if parsed.scheme not in ["ws", "wss"]:
+        raise exceptions.InvalidURI(uri, "scheme isn't ws or wss")
+    if parsed.hostname is None:
+        raise exceptions.InvalidURI(uri, "hostname isn't provided")
+    if parsed.fragment != "":
+        raise exceptions.InvalidURI(uri, "fragment identifier is meaningless")
+
+    secure = parsed.scheme == "wss"
+    host = parsed.hostname
+    port = parsed.port or (443 if secure else 80)
+    path = parsed.path
+    query = parsed.query
+    username = parsed.username
+    password = parsed.password
+    # urllib.parse.urlparse accepts URLs with a username but without a
+    # password. This doesn't make sense for HTTP Basic Auth credentials.
+    if username is not None and password is None:
+        raise exceptions.InvalidURI(uri, "username provided without password")
+
+    try:
+        uri.encode("ascii")
+    except UnicodeEncodeError:
+        # Input contains non-ASCII characters.
+        # It must be an IRI. Convert it to a URI.
+        host = host.encode("idna").decode()
+        path = urllib.parse.quote(path, safe=DELIMS)
+        query = urllib.parse.quote(query, safe=DELIMS)
+        if username is not None:
+            assert password is not None
+            username = urllib.parse.quote(username, safe=DELIMS)
+            password = urllib.parse.quote(password, safe=DELIMS)
+
+    return WebSocketURI(secure, host, port, path, query, username, password)
diff --git a/myenv/lib/python3.9/site-packages/websockets/utils.py b/myenv/lib/python3.9/site-packages/websockets/utils.py
new file mode 100644
index 0000000..c404049
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/utils.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import secrets
+import sys
+
+
+__all__ = ["accept_key", "apply_mask"]
+
+
+GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+
+def generate_key() -> str:
+    """
+    Generate a random key for the Sec-WebSocket-Key header.
+
+    """
+    key = secrets.token_bytes(16)
+    return base64.b64encode(key).decode()
+
+
+def accept_key(key: str) -> str:
+    """
+    Compute the value of the Sec-WebSocket-Accept header.
+
+    Args:
+        key: value of the Sec-WebSocket-Key header.
+
+    """
+    sha1 = hashlib.sha1((key + GUID).encode()).digest()
+    return base64.b64encode(sha1).decode()
+
+
+def apply_mask(data: bytes, mask: bytes) -> bytes:
+    """
+    Apply masking to the data of a WebSocket message.
+
+    Args:
+        data: data to mask.
+        mask: 4-bytes mask.
+
+    """
+    if len(mask) != 4:
+        raise ValueError("mask must contain 4 bytes")
+
+    data_int = int.from_bytes(data, sys.byteorder)
+    mask_repeated = mask * (len(data) // 4) + mask[: len(data) % 4]
+    mask_int = int.from_bytes(mask_repeated, sys.byteorder)
+    return (data_int ^ mask_int).to_bytes(len(data), sys.byteorder)
diff --git a/myenv/lib/python3.9/site-packages/websockets/version.py b/myenv/lib/python3.9/site-packages/websockets/version.py
new file mode 100644
index 0000000..c30bfd6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/websockets/version.py
@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+
+__all__ = ["tag", "version", "commit"]
+
+
+# ========= =========== ===================
+#           release     development
+# ========= =========== ===================
+# tag       X.Y         X.Y (upcoming)
+# version   X.Y         X.Y.dev1+g5678cde
+# commit    X.Y         5678cde
+# ========= =========== ===================
+
+
+# When tagging a release, set `released = True`.
+# After tagging a release, set `released = False` and increment `tag`.
+
+released = True
+
+tag = version = commit = "10.3"
+
+
+if not released:  # pragma: no cover
+    import pathlib
+    import re
+    import subprocess
+
+    def get_version(tag: str) -> str:
+        # Since setup.py executes the contents of src/websockets/version.py,
+        # __file__ can point to either of these two files.
+        file_path = pathlib.Path(__file__)
+        root_dir = file_path.parents[0 if file_path.name == "setup.py" else 2]
+
+        # Read version from git if available. This prevents reading stale
+        # information from src/websockets.egg-info after building a sdist.
+        try:
+            description = subprocess.run(
+                ["git", "describe", "--dirty", "--tags", "--long"],
+                capture_output=True,
+                cwd=root_dir,
+                timeout=1,
+                check=True,
+                text=True,
+            ).stdout.strip()
+        # subprocess.run raises FileNotFoundError if git isn't on $PATH.
+        except (FileNotFoundError, subprocess.CalledProcessError):
+            pass
+        else:
+            description_re = r"[0-9.]+-([0-9]+)-(g[0-9a-f]{7,}(?:-dirty)?)"
+            match = re.fullmatch(description_re, description)
+            assert match is not None
+            distance, remainder = match.groups()
+            remainder = remainder.replace("-", ".")  # required by PEP 440
+            return f"{tag}.dev{distance}+{remainder}"
+
+        # Read version from package metadata if it is installed.
+        try:
+            import importlib.metadata  # move up when dropping Python 3.7
+
+            return importlib.metadata.version("websockets")
+        except ImportError:
+            pass
+
+        # Avoid crashing if the development version cannot be determined.
+        return f"{tag}.dev0+gunknown"
+
+    version = get_version(tag)
+
+    def get_commit(tag: str, version: str) -> str:
+        # Extract commit from version, falling back to tag if not available.
+        version_re = r"[0-9.]+\.dev[0-9]+\+g([0-9a-f]{7,}|unknown)(?:\.dirty)?"
+        match = re.fullmatch(version_re, version)
+        assert match is not None
+        (commit,) = match.groups()
+        return tag if commit == "unknown" else commit
+
+    commit = get_commit(tag, version)
diff --git a/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/INSTALLER b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/INSTALLER
new file mode 100644
index 0000000..2f9ab90
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+Poetry 1.6.1
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/LICENSE b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/LICENSE
new file mode 100644
index 0000000..1cc5117
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/LICENSE
@@ -0,0 +1,24 @@
+Copyright (c) 2013-2022, Graham Dumpleton
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/METADATA b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/METADATA
new file mode 100644
index 0000000..0bd3aaa
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/METADATA
@@ -0,0 +1,174 @@
+Metadata-Version: 2.1
+Name: wrapt
+Version: 1.14.1
+Summary: Module for decorators, wrappers and monkey patching.
+Home-page: https://github.com/GrahamDumpleton/wrapt
+Author: Graham Dumpleton
+Author-email: Graham.Dumpleton@gmail.com
+License: BSD
+Project-URL: Bug Tracker, https://github.com/GrahamDumpleton/wrapt/issues/
+Project-URL: Changelog, https://wrapt.readthedocs.io/en/latest/changes.html
+Project-URL: Documentation, https://wrapt.readthedocs.io/
+Keywords: wrapper,proxy,decorator
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+
+wrapt
+=====
+
+|Actions| |PyPI|
+
+The aim of the **wrapt** module is to provide a transparent object proxy
+for Python, which can be used as the basis for the construction of function
+wrappers and decorator functions.
+
+The **wrapt** module focuses very much on correctness. It therefore goes
+way beyond existing mechanisms such as ``functools.wraps()`` to ensure that
+decorators preserve introspectability, signatures, type checking abilities
+etc. The decorators that can be constructed using this module will work in
+far more scenarios than typical decorators and provide more predictable and
+consistent behaviour.
+
+To ensure that the overhead is as minimal as possible, a C extension module
+is used for performance critical components. An automatic fallback to a
+pure Python implementation is also provided where a target system does not
+have a compiler to allow the C extension to be compiled.
+
+Documentation
+-------------
+
+For further information on the **wrapt** module see:
+
+* http://wrapt.readthedocs.org/
+
+Quick Start
+-----------
+
+To implement your decorator you need to first define a wrapper function.
+This will be called each time a decorated function is called. The wrapper
+function needs to take four positional arguments:
+
+* ``wrapped`` - The wrapped function which in turns needs to be called by your wrapper function.
+* ``instance`` - The object to which the wrapped function was bound when it was called.
+* ``args`` - The list of positional arguments supplied when the decorated function was called.
+* ``kwargs`` - The dictionary of keyword arguments supplied when the decorated function was called.
+
+The wrapper function would do whatever it needs to, but would usually in
+turn call the wrapped function that is passed in via the ``wrapped``
+argument.
+
+The decorator ``@wrapt.decorator`` then needs to be applied to the wrapper
+function to convert it into a decorator which can in turn be applied to
+other functions.
+
+.. code-block:: python
+
+    import wrapt
+    
+    @wrapt.decorator
+    def pass_through(wrapped, instance, args, kwargs):
+        return wrapped(*args, **kwargs)
+
+    @pass_through
+    def function():
+        pass
+
+If you wish to implement a decorator which accepts arguments, then wrap the
+definition of the decorator in a function closure. Any arguments supplied
+to the outer function when the decorator is applied, will be available to
+the inner wrapper when the wrapped function is called.
+
+.. code-block:: python
+
+    import wrapt
+
+    def with_arguments(myarg1, myarg2):
+        @wrapt.decorator
+        def wrapper(wrapped, instance, args, kwargs):
+            return wrapped(*args, **kwargs)
+        return wrapper
+
+    @with_arguments(1, 2)
+    def function():
+        pass
+
+When applied to a normal function or static method, the wrapper function
+when called will be passed ``None`` as the ``instance`` argument.
+
+When applied to an instance method, the wrapper function when called will
+be passed the instance of the class the method is being called on as the
+``instance`` argument. This will be the case even when the instance method
+was called explicitly via the class and the instance passed as the first
+argument. That is, the instance will never be passed as part of ``args``.
+
+When applied to a class method, the wrapper function when called will be
+passed the class type as the ``instance`` argument.
+
+When applied to a class, the wrapper function when called will be passed
+``None`` as the ``instance`` argument. The ``wrapped`` argument in this
+case will be the class.
+
+The above rules can be summarised with the following example.
+
+.. code-block:: python
+
+    import inspect
+    
+    @wrapt.decorator
+    def universal(wrapped, instance, args, kwargs):
+        if instance is None:
+            if inspect.isclass(wrapped):
+                # Decorator was applied to a class.
+                return wrapped(*args, **kwargs)
+            else:
+                # Decorator was applied to a function or staticmethod.
+                return wrapped(*args, **kwargs)
+        else:
+            if inspect.isclass(instance):
+                # Decorator was applied to a classmethod.
+                return wrapped(*args, **kwargs)
+            else:
+                # Decorator was applied to an instancemethod.
+                return wrapped(*args, **kwargs)
+
+Using these checks it is therefore possible to create a universal decorator
+that can be applied in all situations. It is no longer necessary to create
+different variants of decorators for normal functions and instance methods,
+or use additional wrappers to convert a function decorator into one that
+will work for instance methods.
+
+In all cases, the wrapped function passed to the wrapper function is called
+in the same way, with ``args`` and ``kwargs`` being passed. The
+``instance`` argument doesn't need to be used in calling the wrapped
+function.
+
+Repository
+----------
+
+Full source code for the **wrapt** module, including documentation files
+and unit tests, can be obtained from github.
+
+* https://github.com/GrahamDumpleton/wrapt
+
+.. |Actions| image:: https://img.shields.io/github/workflow/status/GrahamDumpleton/wrapt/Test/develop?logo=github&cacheSeconds=600
+   :target: https://github.com/GrahamDumpleton/wrapt/actions
+.. |PyPI| image:: https://img.shields.io/pypi/v/wrapt.svg?logo=python&cacheSeconds=3600
+   :target: https://pypi.python.org/pypi/wrapt
+
+
diff --git a/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/RECORD b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/RECORD
new file mode 100644
index 0000000..cc13cb4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/RECORD
@@ -0,0 +1,12 @@
+wrapt/importer.py,sha256=yxFgVg6-lRTbSVJ2oZbw1TPCtB98fIF4A_qi_Dh2JRc,9981
+wrapt/arguments.py,sha256=RF0nTEdPzPIewJ-jnSY42i4JSzK3ctjPABV1SJxLymg,1746
+wrapt/__init__.py,sha256=Bh0h33Iapc_qaoLWsWfaXK5xJz9KJExF7gQKIWYdSsg,1200
+wrapt/_wrappers.cpython-39-darwin.so,sha256=96miQh4YMFbaAuO-A2z3GKiXZ3_q6TkMn-U8ay9YHhI,74856
+wrapt/wrappers.py,sha256=cckjgzvfj08P-8PWp2fkkJNVas-bn4NDypdPB5p9Lio,35521
+wrapt/decorators.py,sha256=gNy1PVq9NNVDAB9tujaAVhb0xtVKSSzqT-hdGFeWM34,21332
+wrapt-1.14.1.dist-info/LICENSE,sha256=d9KpFZz_4SRz9TmnGj50HzURfmG_0AXr1gw6F3jiwfE,1304
+wrapt-1.14.1.dist-info/WHEEL,sha256=pfjXB0CCNW4PSSqQc2t4Up6p3o0jxBnHy_2o38FQkyE,109
+wrapt-1.14.1.dist-info/top_level.txt,sha256=Jf7kcuXtwjUJMwOL0QzALDg2WiSiXiH9ThKMjN64DW0,6
+wrapt-1.14.1.dist-info/METADATA,sha256=42RcBm75dihDA1YVGIOUFftst1XJ2XOo-EHvfnRYCaQ,6741
+wrapt-1.14.1.dist-info/INSTALLER,sha256=gRgfSaB7mbFTKnL6UjSYEdWrvm1o583nO6nktg_YuCc,12
+wrapt-1.14.1.dist-info/RECORD,,
diff --git a/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/WHEEL b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/WHEEL
new file mode 100644
index 0000000..ef5e11a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_9_x86_64
+
diff --git a/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/top_level.txt b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/top_level.txt
new file mode 100644
index 0000000..ba11553
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/wrapt-1.14.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+wrapt
diff --git a/myenv/lib/python3.9/site-packages/wrapt/__init__.py b/myenv/lib/python3.9/site-packages/wrapt/__init__.py
new file mode 100644
index 0000000..ee6539b
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/wrapt/__init__.py
@@ -0,0 +1,27 @@
+__version_info__ = ('1', '14', '1')
+__version__ = '.'.join(__version_info__)
+
+from .wrappers import (ObjectProxy, CallableObjectProxy, FunctionWrapper,
+        BoundFunctionWrapper, WeakFunctionProxy, PartialCallableObjectProxy,
+        resolve_path, apply_patch, wrap_object, wrap_object_attribute,
+        function_wrapper, wrap_function_wrapper, patch_function_wrapper,
+        transient_function_wrapper)
+
+from .decorators import (adapter_factory, AdapterFactory, decorator,
+        synchronized)
+
+from .importer import (register_post_import_hook, when_imported,
+        notify_module_loaded, discover_post_import_hooks)
+
+# Import of inspect.getcallargs() included for backward compatibility. An
+# implementation of this was previously bundled and made available here for
+# Python <2.7. Avoid using this in future.
+
+from inspect import getcallargs
+
+# Variant of inspect.formatargspec() included here for forward compatibility.
+# This is being done because Python 3.11 dropped inspect.formatargspec() but
+# code for handling signature changing decorators relied on it. Exposing the
+# bundled implementation here in case any user of wrapt was also needing it.
+
+from .arguments import formatargspec
diff --git a/myenv/lib/python3.9/site-packages/wrapt/_wrappers.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/wrapt/_wrappers.cpython-39-darwin.so
new file mode 100755
index 0000000..6a4a488
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/wrapt/_wrappers.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/wrapt/arguments.py b/myenv/lib/python3.9/site-packages/wrapt/arguments.py
new file mode 100644
index 0000000..032bc05
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/wrapt/arguments.py
@@ -0,0 +1,38 @@
+# The inspect.formatargspec() function was dropped in Python 3.11 but we need
+# need it for when constructing signature changing decorators based on result of
+# inspect.getargspec() or inspect.getfullargspec(). The code here implements
+# inspect.formatargspec() base on Parameter and Signature from inspect module,
+# which were added in Python 3.6. Thanks to Cyril Jouve for the implementation.
+
+try:
+    from inspect import Parameter, Signature
+except ImportError:
+    from inspect import formatargspec
+else:
+    def formatargspec(args, varargs=None, varkw=None, defaults=None,
+                      kwonlyargs=(), kwonlydefaults={}, annotations={}):
+        if kwonlydefaults is None:
+            kwonlydefaults = {}
+        ndefaults = len(defaults) if defaults else 0
+        parameters = [
+            Parameter(
+                arg,
+                Parameter.POSITIONAL_OR_KEYWORD,
+                default=defaults[i] if i >= 0 else Parameter.empty,
+                annotation=annotations.get(arg, Parameter.empty),
+            ) for i, arg in enumerate(args, ndefaults - len(args))
+        ]
+        if varargs:
+            parameters.append(Parameter(varargs, Parameter.VAR_POSITIONAL))
+        parameters.extend(
+            Parameter(
+                kwonlyarg,
+                Parameter.KEYWORD_ONLY,
+                default=kwonlydefaults.get(kwonlyarg, Parameter.empty),
+                annotation=annotations.get(kwonlyarg, Parameter.empty),
+            ) for kwonlyarg in kwonlyargs
+        )
+        if varkw:
+            parameters.append(Parameter(varkw, Parameter.VAR_KEYWORD))
+        return_annotation = annotations.get('return', Signature.empty)
+        return str(Signature(parameters, return_annotation=return_annotation))
\ No newline at end of file
diff --git a/myenv/lib/python3.9/site-packages/wrapt/decorators.py b/myenv/lib/python3.9/site-packages/wrapt/decorators.py
new file mode 100644
index 0000000..c3f2547
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/wrapt/decorators.py
@@ -0,0 +1,541 @@
+"""This module implements decorators for implementing other decorators
+as well as some commonly used decorators.
+
+"""
+
+import sys
+
+PY2 = sys.version_info[0] == 2
+
+if PY2:
+    string_types = basestring,
+
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+else:
+    string_types = str,
+
+    import builtins
+
+    exec_ = getattr(builtins, "exec")
+    del builtins
+
+from functools import partial
+from inspect import isclass
+from threading import Lock, RLock
+
+from .arguments import formatargspec
+
+try:
+    from inspect import signature
+except ImportError:
+    pass
+
+from .wrappers import (FunctionWrapper, BoundFunctionWrapper, ObjectProxy,
+    CallableObjectProxy)
+
+# Adapter wrapper for the wrapped function which will overlay certain
+# properties from the adapter function onto the wrapped function so that
+# functions such as inspect.getargspec(), inspect.getfullargspec(),
+# inspect.signature() and inspect.getsource() return the correct results
+# one would expect.
+
+class _AdapterFunctionCode(CallableObjectProxy):
+
+    def __init__(self, wrapped_code, adapter_code):
+        super(_AdapterFunctionCode, self).__init__(wrapped_code)
+        self._self_adapter_code = adapter_code
+
+    @property
+    def co_argcount(self):
+        return self._self_adapter_code.co_argcount
+
+    @property
+    def co_code(self):
+        return self._self_adapter_code.co_code
+
+    @property
+    def co_flags(self):
+        return self._self_adapter_code.co_flags
+
+    @property
+    def co_kwonlyargcount(self):
+        return self._self_adapter_code.co_kwonlyargcount
+
+    @property
+    def co_varnames(self):
+        return self._self_adapter_code.co_varnames
+
+class _AdapterFunctionSurrogate(CallableObjectProxy):
+
+    def __init__(self, wrapped, adapter):
+        super(_AdapterFunctionSurrogate, self).__init__(wrapped)
+        self._self_adapter = adapter
+
+    @property
+    def __code__(self):
+        return _AdapterFunctionCode(self.__wrapped__.__code__,
+                self._self_adapter.__code__)
+
+    @property
+    def __defaults__(self):
+        return self._self_adapter.__defaults__
+
+    @property
+    def __kwdefaults__(self):
+        return self._self_adapter.__kwdefaults__
+
+    @property
+    def __signature__(self):
+        if 'signature' not in globals():
+            return self._self_adapter.__signature__
+        else:
+            return signature(self._self_adapter)
+
+    if PY2:
+        func_code = __code__
+        func_defaults = __defaults__
+
+class _BoundAdapterWrapper(BoundFunctionWrapper):
+
+    @property
+    def __func__(self):
+        return _AdapterFunctionSurrogate(self.__wrapped__.__func__,
+                self._self_parent._self_adapter)
+
+    @property
+    def __signature__(self):
+        if 'signature' not in globals():
+            return self.__wrapped__.__signature__
+        else:
+            return signature(self._self_parent._self_adapter)
+
+    if PY2:
+        im_func = __func__
+
+class AdapterWrapper(FunctionWrapper):
+
+    __bound_function_wrapper__ = _BoundAdapterWrapper
+
+    def __init__(self, *args, **kwargs):
+        adapter = kwargs.pop('adapter')
+        super(AdapterWrapper, self).__init__(*args, **kwargs)
+        self._self_surrogate = _AdapterFunctionSurrogate(
+                self.__wrapped__, adapter)
+        self._self_adapter = adapter
+
+    @property
+    def __code__(self):
+        return self._self_surrogate.__code__
+
+    @property
+    def __defaults__(self):
+        return self._self_surrogate.__defaults__
+
+    @property
+    def __kwdefaults__(self):
+        return self._self_surrogate.__kwdefaults__
+
+    if PY2:
+        func_code = __code__
+        func_defaults = __defaults__
+
+    @property
+    def __signature__(self):
+        return self._self_surrogate.__signature__
+
+class AdapterFactory(object):
+    def __call__(self, wrapped):
+        raise NotImplementedError()
+
+class DelegatedAdapterFactory(AdapterFactory):
+    def __init__(self, factory):
+        super(DelegatedAdapterFactory, self).__init__()
+        self.factory = factory
+    def __call__(self, wrapped):
+        return self.factory(wrapped)
+
+adapter_factory = DelegatedAdapterFactory
+
+# Decorator for creating other decorators. This decorator and the
+# wrappers which they use are designed to properly preserve any name
+# attributes, function signatures etc, in addition to the wrappers
+# themselves acting like a transparent proxy for the original wrapped
+# function so the wrapper is effectively indistinguishable from the
+# original wrapped function.
+
+def decorator(wrapper=None, enabled=None, adapter=None, proxy=FunctionWrapper):
+    # The decorator should be supplied with a single positional argument
+    # which is the wrapper function to be used to implement the
+    # decorator. This may be preceded by a step whereby the keyword
+    # arguments are supplied to customise the behaviour of the
+    # decorator. The 'adapter' argument is used to optionally denote a
+    # separate function which is notionally used by an adapter
+    # decorator. In that case parts of the function '__code__' and
+    # '__defaults__' attributes are used from the adapter function
+    # rather than those of the wrapped function. This allows for the
+    # argument specification from inspect.getfullargspec() and similar
+    # functions to be overridden with a prototype for a different
+    # function than what was wrapped. The 'enabled' argument provides a
+    # way to enable/disable the use of the decorator. If the type of
+    # 'enabled' is a boolean, then it is evaluated immediately and the
+    # wrapper not even applied if it is False. If not a boolean, it will
+    # be evaluated when the wrapper is called for an unbound wrapper,
+    # and when binding occurs for a bound wrapper. When being evaluated,
+    # if 'enabled' is callable it will be called to obtain the value to
+    # be checked. If False, the wrapper will not be called and instead
+    # the original wrapped function will be called directly instead.
+    # The 'proxy' argument provides a way of passing a custom version of
+    # the FunctionWrapper class used in decorating the function.
+
+    if wrapper is not None:
+        # Helper function for creating wrapper of the appropriate
+        # time when we need it down below.
+
+        def _build(wrapped, wrapper, enabled=None, adapter=None):
+            if adapter:
+                if isinstance(adapter, AdapterFactory):
+                    adapter = adapter(wrapped)
+
+                if not callable(adapter):
+                    ns = {}
+
+                    # Check if the signature argument specification has
+                    # annotations. If it does then we need to remember
+                    # it but also drop it when attempting to manufacture
+                    # a standin adapter function. This is necessary else
+                    # it will try and look up any types referenced in
+                    # the annotations in the empty namespace we use,
+                    # which will fail.
+
+                    annotations = {}
+
+                    if not isinstance(adapter, string_types):
+                        if len(adapter) == 7:
+                            annotations = adapter[-1]
+                            adapter = adapter[:-1]
+                        adapter = formatargspec(*adapter)
+
+                    exec_('def adapter{}: pass'.format(adapter), ns, ns)
+                    adapter = ns['adapter']
+
+                    # Override the annotations for the manufactured
+                    # adapter function so they match the original
+                    # adapter signature argument specification.
+
+                    if annotations:
+                        adapter.__annotations__ = annotations
+
+                return AdapterWrapper(wrapped=wrapped, wrapper=wrapper,
+                        enabled=enabled, adapter=adapter)
+
+            return proxy(wrapped=wrapped, wrapper=wrapper, enabled=enabled)
+
+        # The wrapper has been provided so return the final decorator.
+        # The decorator is itself one of our function wrappers so we
+        # can determine when it is applied to functions, instance methods
+        # or class methods. This allows us to bind the instance or class
+        # method so the appropriate self or cls attribute is supplied
+        # when it is finally called.
+
+        def _wrapper(wrapped, instance, args, kwargs):
+            # We first check for the case where the decorator was applied
+            # to a class type.
+            #
+            #     @decorator
+            #     class mydecoratorclass(object):
+            #         def __init__(self, arg=None):
+            #             self.arg = arg
+            #         def __call__(self, wrapped, instance, args, kwargs):
+            #             return wrapped(*args, **kwargs)
+            #
+            #     @mydecoratorclass(arg=1)
+            #     def function():
+            #         pass
+            #
+            # In this case an instance of the class is to be used as the
+            # decorator wrapper function. If args was empty at this point,
+            # then it means that there were optional keyword arguments
+            # supplied to be used when creating an instance of the class
+            # to be used as the wrapper function.
+
+            if instance is None and isclass(wrapped) and not args:
+                # We still need to be passed the target function to be
+                # wrapped as yet, so we need to return a further function
+                # to be able to capture it.
+
+                def _capture(target_wrapped):
+                    # Now have the target function to be wrapped and need
+                    # to create an instance of the class which is to act
+                    # as the decorator wrapper function. Before we do that,
+                    # we need to first check that use of the decorator
+                    # hadn't been disabled by a simple boolean. If it was,
+                    # the target function to be wrapped is returned instead.
+
+                    _enabled = enabled
+                    if type(_enabled) is bool:
+                        if not _enabled:
+                            return target_wrapped
+                        _enabled = None
+
+                    # Now create an instance of the class which is to act
+                    # as the decorator wrapper function. Any arguments had
+                    # to be supplied as keyword only arguments so that is
+                    # all we pass when creating it.
+
+                    target_wrapper = wrapped(**kwargs)
+
+                    # Finally build the wrapper itself and return it.
+
+                    return _build(target_wrapped, target_wrapper,
+                            _enabled, adapter)
+
+                return _capture
+
+            # We should always have the target function to be wrapped at
+            # this point as the first (and only) value in args.
+
+            target_wrapped = args[0]
+
+            # Need to now check that use of the decorator hadn't been
+            # disabled by a simple boolean. If it was, then target
+            # function to be wrapped is returned instead.
+
+            _enabled = enabled
+            if type(_enabled) is bool:
+                if not _enabled:
+                    return target_wrapped
+                _enabled = None
+
+            # We now need to build the wrapper, but there are a couple of
+            # different cases we need to consider.
+
+            if instance is None:
+                if isclass(wrapped):
+                    # In this case the decorator was applied to a class
+                    # type but optional keyword arguments were not supplied
+                    # for initialising an instance of the class to be used
+                    # as the decorator wrapper function.
+                    #
+                    #     @decorator
+                    #     class mydecoratorclass(object):
+                    #         def __init__(self, arg=None):
+                    #             self.arg = arg
+                    #         def __call__(self, wrapped, instance,
+                    #                 args, kwargs):
+                    #             return wrapped(*args, **kwargs)
+                    #
+                    #     @mydecoratorclass
+                    #     def function():
+                    #         pass
+                    #
+                    # We still need to create an instance of the class to
+                    # be used as the decorator wrapper function, but no
+                    # arguments are pass.
+
+                    target_wrapper = wrapped()
+
+                else:
+                    # In this case the decorator was applied to a normal
+                    # function, or possibly a static method of a class.
+                    #
+                    #     @decorator
+                    #     def mydecoratorfuntion(wrapped, instance,
+                    #             args, kwargs):
+                    #         return wrapped(*args, **kwargs)
+                    #
+                    #     @mydecoratorfunction
+                    #     def function():
+                    #         pass
+                    #
+                    # That normal function becomes the decorator wrapper
+                    # function.
+
+                    target_wrapper = wrapper
+
+            else:
+                if isclass(instance):
+                    # In this case the decorator was applied to a class
+                    # method.
+                    #
+                    #     class myclass(object):
+                    #         @decorator
+                    #         @classmethod
+                    #         def decoratorclassmethod(cls, wrapped,
+                    #                 instance, args, kwargs):
+                    #             return wrapped(*args, **kwargs)
+                    #
+                    #     instance = myclass()
+                    #
+                    #     @instance.decoratorclassmethod
+                    #     def function():
+                    #         pass
+                    #
+                    # This one is a bit strange because binding was actually
+                    # performed on the wrapper created by our decorator
+                    # factory. We need to apply that binding to the decorator
+                    # wrapper function that the decorator factory
+                    # was applied to.
+
+                    target_wrapper = wrapper.__get__(None, instance)
+
+                else:
+                    # In this case the decorator was applied to an instance
+                    # method.
+                    #
+                    #     class myclass(object):
+                    #         @decorator
+                    #         def decoratorclassmethod(self, wrapped,
+                    #                 instance, args, kwargs):
+                    #             return wrapped(*args, **kwargs)
+                    #
+                    #     instance = myclass()
+                    #
+                    #     @instance.decoratorclassmethod
+                    #     def function():
+                    #         pass
+                    #
+                    # This one is a bit strange because binding was actually
+                    # performed on the wrapper created by our decorator
+                    # factory. We need to apply that binding to the decorator
+                    # wrapper function that the decorator factory
+                    # was applied to.
+
+                    target_wrapper = wrapper.__get__(instance, type(instance))
+
+            # Finally build the wrapper itself and return it.
+
+            return _build(target_wrapped, target_wrapper, _enabled, adapter)
+
+        # We first return our magic function wrapper here so we can
+        # determine in what context the decorator factory was used. In
+        # other words, it is itself a universal decorator. The decorator
+        # function is used as the adapter so that linters see a signature
+        # corresponding to the decorator and not the wrapper it is being
+        # applied to.
+
+        return _build(wrapper, _wrapper, adapter=decorator)
+
+    else:
+        # The wrapper still has not been provided, so we are just
+        # collecting the optional keyword arguments. Return the
+        # decorator again wrapped in a partial using the collected
+        # arguments.
+
+        return partial(decorator, enabled=enabled, adapter=adapter,
+                proxy=proxy)
+
+# Decorator for implementing thread synchronization. It can be used as a
+# decorator, in which case the synchronization context is determined by
+# what type of function is wrapped, or it can also be used as a context
+# manager, where the user needs to supply the correct synchronization
+# context. It is also possible to supply an object which appears to be a
+# synchronization primitive of some sort, by virtue of having release()
+# and acquire() methods. In that case that will be used directly as the
+# synchronization primitive without creating a separate lock against the
+# derived or supplied context.
+
+def synchronized(wrapped):
+    # Determine if being passed an object which is a synchronization
+    # primitive. We can't check by type for Lock, RLock, Semaphore etc,
+    # as the means of creating them isn't the type. Therefore use the
+    # existence of acquire() and release() methods. This is more
+    # extensible anyway as it allows custom synchronization mechanisms.
+
+    if hasattr(wrapped, 'acquire') and hasattr(wrapped, 'release'):
+        # We remember what the original lock is and then return a new
+        # decorator which accesses and locks it. When returning the new
+        # decorator we wrap it with an object proxy so we can override
+        # the context manager methods in case it is being used to wrap
+        # synchronized statements with a 'with' statement.
+
+        lock = wrapped
+
+        @decorator
+        def _synchronized(wrapped, instance, args, kwargs):
+            # Execute the wrapped function while the original supplied
+            # lock is held.
+
+            with lock:
+                return wrapped(*args, **kwargs)
+
+        class _PartialDecorator(CallableObjectProxy):
+
+            def __enter__(self):
+                lock.acquire()
+                return lock
+
+            def __exit__(self, *args):
+                lock.release()
+
+        return _PartialDecorator(wrapped=_synchronized)
+
+    # Following only apply when the lock is being created automatically
+    # based on the context of what was supplied. In this case we supply
+    # a final decorator, but need to use FunctionWrapper directly as we
+    # want to derive from it to add context manager methods in case it is
+    # being used to wrap synchronized statements with a 'with' statement.
+
+    def _synchronized_lock(context):
+        # Attempt to retrieve the lock for the specific context.
+
+        lock = vars(context).get('_synchronized_lock', None)
+
+        if lock is None:
+            # There is no existing lock defined for the context we
+            # are dealing with so we need to create one. This needs
+            # to be done in a way to guarantee there is only one
+            # created, even if multiple threads try and create it at
+            # the same time. We can't always use the setdefault()
+            # method on the __dict__ for the context. This is the
+            # case where the context is a class, as __dict__ is
+            # actually a dictproxy. What we therefore do is use a
+            # meta lock on this wrapper itself, to control the
+            # creation and assignment of the lock attribute against
+            # the context.
+
+            with synchronized._synchronized_meta_lock:
+                # We need to check again for whether the lock we want
+                # exists in case two threads were trying to create it
+                # at the same time and were competing to create the
+                # meta lock.
+
+                lock = vars(context).get('_synchronized_lock', None)
+
+                if lock is None:
+                    lock = RLock()
+                    setattr(context, '_synchronized_lock', lock)
+
+        return lock
+
+    def _synchronized_wrapper(wrapped, instance, args, kwargs):
+        # Execute the wrapped function while the lock for the
+        # desired context is held. If instance is None then the
+        # wrapped function is used as the context.
+
+        with _synchronized_lock(instance if instance is not None else wrapped):
+            return wrapped(*args, **kwargs)
+
+    class _FinalDecorator(FunctionWrapper):
+
+        def __enter__(self):
+            self._self_lock = _synchronized_lock(self.__wrapped__)
+            self._self_lock.acquire()
+            return self._self_lock
+
+        def __exit__(self, *args):
+            self._self_lock.release()
+
+    return _FinalDecorator(wrapped=wrapped, wrapper=_synchronized_wrapper)
+
+synchronized._synchronized_meta_lock = Lock()
diff --git a/myenv/lib/python3.9/site-packages/wrapt/importer.py b/myenv/lib/python3.9/site-packages/wrapt/importer.py
new file mode 100644
index 0000000..5c4d4cc
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/wrapt/importer.py
@@ -0,0 +1,286 @@
+"""This module implements a post import hook mechanism styled after what is
+described in PEP-369. Note that it doesn't cope with modules being reloaded.
+
+"""
+
+import sys
+import threading
+
+PY2 = sys.version_info[0] == 2
+
+if PY2:
+    string_types = basestring,
+    find_spec = None
+else:
+    string_types = str,
+    from importlib.util import find_spec
+
+from .decorators import synchronized
+
+# The dictionary registering any post import hooks to be triggered once
+# the target module has been imported. Once a module has been imported
+# and the hooks fired, the list of hooks recorded against the target
+# module will be truncated but the list left in the dictionary. This
+# acts as a flag to indicate that the module had already been imported.
+
+_post_import_hooks = {}
+_post_import_hooks_init = False
+_post_import_hooks_lock = threading.RLock()
+
+# Register a new post import hook for the target module name. This
+# differs from the PEP-369 implementation in that it also allows the
+# hook function to be specified as a string consisting of the name of
+# the callback in the form 'module:function'. This will result in a
+# proxy callback being registered which will defer loading of the
+# specified module containing the callback function until required.
+
+def _create_import_hook_from_string(name):
+    def import_hook(module):
+        module_name, function = name.split(':')
+        attrs = function.split('.')
+        __import__(module_name)
+        callback = sys.modules[module_name]
+        for attr in attrs:
+            callback = getattr(callback, attr)
+        return callback(module)
+    return import_hook
+
+@synchronized(_post_import_hooks_lock)
+def register_post_import_hook(hook, name):
+    # Create a deferred import hook if hook is a string name rather than
+    # a callable function.
+
+    if isinstance(hook, string_types):
+        hook = _create_import_hook_from_string(hook)
+
+    # Automatically install the import hook finder if it has not already
+    # been installed.
+
+    global _post_import_hooks_init
+
+    if not _post_import_hooks_init:
+        _post_import_hooks_init = True
+        sys.meta_path.insert(0, ImportHookFinder())
+
+    # Determine if any prior registration of a post import hook for
+    # the target modules has occurred and act appropriately.
+
+    hooks = _post_import_hooks.get(name, None)
+
+    if hooks is None:
+        # No prior registration of post import hooks for the target
+        # module. We need to check whether the module has already been
+        # imported. If it has we fire the hook immediately and add an
+        # empty list to the registry to indicate that the module has
+        # already been imported and hooks have fired. Otherwise add
+        # the post import hook to the registry.
+
+        module = sys.modules.get(name, None)
+
+        if module is not None:
+            _post_import_hooks[name] = []
+            hook(module)
+
+        else:
+            _post_import_hooks[name] = [hook]
+
+    elif hooks == []:
+        # A prior registration of port import hooks for the target
+        # module was done and the hooks already fired. Fire the hook
+        # immediately.
+
+        module = sys.modules[name]
+        hook(module)
+
+    else:
+        # A prior registration of port import hooks for the target
+        # module was done but the module has not yet been imported.
+
+        _post_import_hooks[name].append(hook)
+
+# Register post import hooks defined as package entry points.
+
+def _create_import_hook_from_entrypoint(entrypoint):
+    def import_hook(module):
+        __import__(entrypoint.module_name)
+        callback = sys.modules[entrypoint.module_name]
+        for attr in entrypoint.attrs:
+            callback = getattr(callback, attr)
+        return callback(module)
+    return import_hook
+
+def discover_post_import_hooks(group):
+    try:
+        import pkg_resources
+    except ImportError:
+        return
+
+    for entrypoint in pkg_resources.iter_entry_points(group=group):
+        callback = _create_import_hook_from_entrypoint(entrypoint)
+        register_post_import_hook(callback, entrypoint.name)
+
+# Indicate that a module has been loaded. Any post import hooks which
+# were registered against the target module will be invoked. If an
+# exception is raised in any of the post import hooks, that will cause
+# the import of the target module to fail.
+
+@synchronized(_post_import_hooks_lock)
+def notify_module_loaded(module):
+    name = getattr(module, '__name__', None)
+    hooks = _post_import_hooks.get(name, None)
+
+    if hooks:
+        _post_import_hooks[name] = []
+
+        for hook in hooks:
+            hook(module)
+
+# A custom module import finder. This intercepts attempts to import
+# modules and watches out for attempts to import target modules of
+# interest. When a module of interest is imported, then any post import
+# hooks which are registered will be invoked.
+
+class _ImportHookLoader:
+
+    def load_module(self, fullname):
+        module = sys.modules[fullname]
+        notify_module_loaded(module)
+
+        return module
+
+class _ImportHookChainedLoader:
+
+    def __init__(self, loader):
+        self.loader = loader
+
+        if hasattr(loader, "load_module"):
+          self.load_module = self._load_module
+        if hasattr(loader, "create_module"):
+          self.create_module = self._create_module
+        if hasattr(loader, "exec_module"):
+          self.exec_module = self._exec_module
+
+    def _load_module(self, fullname):
+        module = self.loader.load_module(fullname)
+        notify_module_loaded(module)
+
+        return module
+
+    # Python 3.4 introduced create_module() and exec_module() instead of
+    # load_module() alone. Splitting the two steps.
+
+    def _create_module(self, spec):
+        return self.loader.create_module(spec)
+
+    def _exec_module(self, module):
+        self.loader.exec_module(module)
+        notify_module_loaded(module)
+
+class ImportHookFinder:
+
+    def __init__(self):
+        self.in_progress = {}
+
+    @synchronized(_post_import_hooks_lock)
+    def find_module(self, fullname, path=None):
+        # If the module being imported is not one we have registered
+        # post import hooks for, we can return immediately. We will
+        # take no further part in the importing of this module.
+
+        if not fullname in _post_import_hooks:
+            return None
+
+        # When we are interested in a specific module, we will call back
+        # into the import system a second time to defer to the import
+        # finder that is supposed to handle the importing of the module.
+        # We set an in progress flag for the target module so that on
+        # the second time through we don't trigger another call back
+        # into the import system and cause a infinite loop.
+
+        if fullname in self.in_progress:
+            return None
+
+        self.in_progress[fullname] = True
+
+        # Now call back into the import system again.
+
+        try:
+            if not find_spec:
+                # For Python 2 we don't have much choice but to
+                # call back in to __import__(). This will
+                # actually cause the module to be imported. If no
+                # module could be found then ImportError will be
+                # raised. Otherwise we return a loader which
+                # returns the already loaded module and invokes
+                # the post import hooks.
+
+                __import__(fullname)
+
+                return _ImportHookLoader()
+
+            else:
+                # For Python 3 we need to use find_spec().loader
+                # from the importlib.util module. It doesn't actually
+                # import the target module and only finds the
+                # loader. If a loader is found, we need to return
+                # our own loader which will then in turn call the
+                # real loader to import the module and invoke the
+                # post import hooks.
+
+                loader = getattr(find_spec(fullname), "loader", None)
+
+                if loader and not isinstance(loader, _ImportHookChainedLoader):
+                    return _ImportHookChainedLoader(loader)
+
+        finally:
+            del self.in_progress[fullname]
+
+    def find_spec(self, fullname, path=None, target=None):
+        # Since Python 3.4, you are meant to implement find_spec() method
+        # instead of find_module() and since Python 3.10 you get deprecation
+        # warnings if you don't define find_spec().
+
+        # If the module being imported is not one we have registered
+        # post import hooks for, we can return immediately. We will
+        # take no further part in the importing of this module.
+
+        if not fullname in _post_import_hooks:
+            return None
+
+        # When we are interested in a specific module, we will call back
+        # into the import system a second time to defer to the import
+        # finder that is supposed to handle the importing of the module.
+        # We set an in progress flag for the target module so that on
+        # the second time through we don't trigger another call back
+        # into the import system and cause a infinite loop.
+
+        if fullname in self.in_progress:
+            return None
+
+        self.in_progress[fullname] = True
+
+        # Now call back into the import system again.
+
+        try:
+            # This should only be Python 3 so find_spec() should always
+            # exist so don't need to check.
+
+            spec = find_spec(fullname)
+            loader = getattr(spec, "loader", None)
+
+            if loader and not isinstance(loader, _ImportHookChainedLoader):
+                spec.loader = _ImportHookChainedLoader(loader)
+
+            return spec
+
+        finally:
+            del self.in_progress[fullname]
+
+# Decorator for marking that a function should be called as a post
+# import hook when the target module is imported.
+
+def when_imported(name):
+    def register(hook):
+        register_post_import_hook(hook, name)
+        return hook
+    return register
diff --git a/myenv/lib/python3.9/site-packages/wrapt/wrappers.py b/myenv/lib/python3.9/site-packages/wrapt/wrappers.py
new file mode 100644
index 0000000..2716cd1
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/wrapt/wrappers.py
@@ -0,0 +1,986 @@
+import os
+import sys
+import functools
+import operator
+import weakref
+import inspect
+
+PY2 = sys.version_info[0] == 2
+
+if PY2:
+    string_types = basestring,
+else:
+    string_types = str,
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    return meta("NewBase", bases, {})
+
+class _ObjectProxyMethods(object):
+
+    # We use properties to override the values of __module__ and
+    # __doc__. If we add these in ObjectProxy, the derived class
+    # __dict__ will still be setup to have string variants of these
+    # attributes and the rules of descriptors means that they appear to
+    # take precedence over the properties in the base class. To avoid
+    # that, we copy the properties into the derived class type itself
+    # via a meta class. In that way the properties will always take
+    # precedence.
+
+    @property
+    def __module__(self):
+        return self.__wrapped__.__module__
+
+    @__module__.setter
+    def __module__(self, value):
+        self.__wrapped__.__module__ = value
+
+    @property
+    def __doc__(self):
+        return self.__wrapped__.__doc__
+
+    @__doc__.setter
+    def __doc__(self, value):
+        self.__wrapped__.__doc__ = value
+
+    # We similar use a property for __dict__. We need __dict__ to be
+    # explicit to ensure that vars() works as expected.
+
+    @property
+    def __dict__(self):
+        return self.__wrapped__.__dict__
+
+    # Need to also propagate the special __weakref__ attribute for case
+    # where decorating classes which will define this. If do not define
+    # it and use a function like inspect.getmembers() on a decorator
+    # class it will fail. This can't be in the derived classes.
+
+    @property
+    def __weakref__(self):
+        return self.__wrapped__.__weakref__
+
+class _ObjectProxyMetaType(type):
+    def __new__(cls, name, bases, dictionary):
+        # Copy our special properties into the class so that they
+        # always take precedence over attributes of the same name added
+        # during construction of a derived class. This is to save
+        # duplicating the implementation for them in all derived classes.
+
+        dictionary.update(vars(_ObjectProxyMethods))
+
+        return type.__new__(cls, name, bases, dictionary)
+
+class ObjectProxy(with_metaclass(_ObjectProxyMetaType)):
+
+    __slots__ = '__wrapped__'
+
+    def __init__(self, wrapped):
+        object.__setattr__(self, '__wrapped__', wrapped)
+
+        # Python 3.2+ has the __qualname__ attribute, but it does not
+        # allow it to be overridden using a property and it must instead
+        # be an actual string object instead.
+
+        try:
+            object.__setattr__(self, '__qualname__', wrapped.__qualname__)
+        except AttributeError:
+            pass
+
+        # Python 3.10 onwards also does not allow itself to be overridden
+        # using a property and it must instead be set explicitly.
+
+        try:
+            object.__setattr__(self, '__annotations__', wrapped.__annotations__)
+        except AttributeError:
+            pass
+
+    @property
+    def __name__(self):
+        return self.__wrapped__.__name__
+
+    @__name__.setter
+    def __name__(self, value):
+        self.__wrapped__.__name__ = value
+
+    @property
+    def __class__(self):
+        return self.__wrapped__.__class__
+
+    @__class__.setter
+    def __class__(self, value):
+        self.__wrapped__.__class__ = value
+
+    def __dir__(self):
+        return dir(self.__wrapped__)
+
+    def __str__(self):
+        return str(self.__wrapped__)
+
+    if not PY2:
+        def __bytes__(self):
+            return bytes(self.__wrapped__)
+
+    def __repr__(self):
+        return '<{} at 0x{:x} for {} at 0x{:x}>'.format(
+                type(self).__name__, id(self),
+                type(self.__wrapped__).__name__,
+                id(self.__wrapped__))
+
+    def __reversed__(self):
+        return reversed(self.__wrapped__)
+
+    if not PY2:
+        def __round__(self):
+            return round(self.__wrapped__)
+
+    if sys.hexversion >= 0x03070000:
+        def __mro_entries__(self, bases):
+            return (self.__wrapped__,)
+
+    def __lt__(self, other):
+        return self.__wrapped__ < other
+
+    def __le__(self, other):
+        return self.__wrapped__ <= other
+
+    def __eq__(self, other):
+        return self.__wrapped__ == other
+
+    def __ne__(self, other):
+        return self.__wrapped__ != other
+
+    def __gt__(self, other):
+        return self.__wrapped__ > other
+
+    def __ge__(self, other):
+        return self.__wrapped__ >= other
+
+    def __hash__(self):
+        return hash(self.__wrapped__)
+
+    def __nonzero__(self):
+        return bool(self.__wrapped__)
+
+    def __bool__(self):
+        return bool(self.__wrapped__)
+
+    def __setattr__(self, name, value):
+        if name.startswith('_self_'):
+            object.__setattr__(self, name, value)
+
+        elif name == '__wrapped__':
+            object.__setattr__(self, name, value)
+            try:
+                object.__delattr__(self, '__qualname__')
+            except AttributeError:
+                pass
+            try:
+                object.__setattr__(self, '__qualname__', value.__qualname__)
+            except AttributeError:
+                pass
+            try:
+                object.__delattr__(self, '__annotations__')
+            except AttributeError:
+                pass
+            try:
+                object.__setattr__(self, '__annotations__', value.__annotations__)
+            except AttributeError:
+                pass
+
+        elif name == '__qualname__':
+            setattr(self.__wrapped__, name, value)
+            object.__setattr__(self, name, value)
+
+        elif name == '__annotations__':
+            setattr(self.__wrapped__, name, value)
+            object.__setattr__(self, name, value)
+
+        elif hasattr(type(self), name):
+            object.__setattr__(self, name, value)
+
+        else:
+            setattr(self.__wrapped__, name, value)
+
+    def __getattr__(self, name):
+        # If we are being to lookup '__wrapped__' then the
+        # '__init__()' method cannot have been called.
+
+        if name == '__wrapped__':
+            raise ValueError('wrapper has not been initialised')
+
+        return getattr(self.__wrapped__, name)
+
+    def __delattr__(self, name):
+        if name.startswith('_self_'):
+            object.__delattr__(self, name)
+
+        elif name == '__wrapped__':
+            raise TypeError('__wrapped__ must be an object')
+
+        elif name == '__qualname__':
+            object.__delattr__(self, name)
+            delattr(self.__wrapped__, name)
+
+        elif hasattr(type(self), name):
+            object.__delattr__(self, name)
+
+        else:
+            delattr(self.__wrapped__, name)
+
+    def __add__(self, other):
+        return self.__wrapped__ + other
+
+    def __sub__(self, other):
+        return self.__wrapped__ - other
+
+    def __mul__(self, other):
+        return self.__wrapped__ * other
+
+    def __div__(self, other):
+        return operator.div(self.__wrapped__, other)
+
+    def __truediv__(self, other):
+        return operator.truediv(self.__wrapped__, other)
+
+    def __floordiv__(self, other):
+        return self.__wrapped__ // other
+
+    def __mod__(self, other):
+        return self.__wrapped__ % other
+
+    def __divmod__(self, other):
+        return divmod(self.__wrapped__, other)
+
+    def __pow__(self, other, *args):
+        return pow(self.__wrapped__, other, *args)
+
+    def __lshift__(self, other):
+        return self.__wrapped__ << other
+
+    def __rshift__(self, other):
+        return self.__wrapped__ >> other
+
+    def __and__(self, other):
+        return self.__wrapped__ & other
+
+    def __xor__(self, other):
+        return self.__wrapped__ ^ other
+
+    def __or__(self, other):
+        return self.__wrapped__ | other
+
+    def __radd__(self, other):
+        return other + self.__wrapped__
+
+    def __rsub__(self, other):
+        return other - self.__wrapped__
+
+    def __rmul__(self, other):
+        return other * self.__wrapped__
+
+    def __rdiv__(self, other):
+        return operator.div(other, self.__wrapped__)
+
+    def __rtruediv__(self, other):
+        return operator.truediv(other, self.__wrapped__)
+
+    def __rfloordiv__(self, other):
+        return other // self.__wrapped__
+
+    def __rmod__(self, other):
+        return other % self.__wrapped__
+
+    def __rdivmod__(self, other):
+        return divmod(other, self.__wrapped__)
+
+    def __rpow__(self, other, *args):
+        return pow(other, self.__wrapped__, *args)
+
+    def __rlshift__(self, other):
+        return other << self.__wrapped__
+
+    def __rrshift__(self, other):
+        return other >> self.__wrapped__
+
+    def __rand__(self, other):
+        return other & self.__wrapped__
+
+    def __rxor__(self, other):
+        return other ^ self.__wrapped__
+
+    def __ror__(self, other):
+        return other | self.__wrapped__
+
+    def __iadd__(self, other):
+        self.__wrapped__ += other
+        return self
+
+    def __isub__(self, other):
+        self.__wrapped__ -= other
+        return self
+
+    def __imul__(self, other):
+        self.__wrapped__ *= other
+        return self
+
+    def __idiv__(self, other):
+        self.__wrapped__ = operator.idiv(self.__wrapped__, other)
+        return self
+
+    def __itruediv__(self, other):
+        self.__wrapped__ = operator.itruediv(self.__wrapped__, other)
+        return self
+
+    def __ifloordiv__(self, other):
+        self.__wrapped__ //= other
+        return self
+
+    def __imod__(self, other):
+        self.__wrapped__ %= other
+        return self
+
+    def __ipow__(self, other):
+        self.__wrapped__ **= other
+        return self
+
+    def __ilshift__(self, other):
+        self.__wrapped__ <<= other
+        return self
+
+    def __irshift__(self, other):
+        self.__wrapped__ >>= other
+        return self
+
+    def __iand__(self, other):
+        self.__wrapped__ &= other
+        return self
+
+    def __ixor__(self, other):
+        self.__wrapped__ ^= other
+        return self
+
+    def __ior__(self, other):
+        self.__wrapped__ |= other
+        return self
+
+    def __neg__(self):
+        return -self.__wrapped__
+
+    def __pos__(self):
+        return +self.__wrapped__
+
+    def __abs__(self):
+        return abs(self.__wrapped__)
+
+    def __invert__(self):
+        return ~self.__wrapped__
+
+    def __int__(self):
+        return int(self.__wrapped__)
+
+    def __long__(self):
+        return long(self.__wrapped__)
+
+    def __float__(self):
+        return float(self.__wrapped__)
+
+    def __complex__(self):
+        return complex(self.__wrapped__)
+
+    def __oct__(self):
+        return oct(self.__wrapped__)
+
+    def __hex__(self):
+        return hex(self.__wrapped__)
+
+    def __index__(self):
+        return operator.index(self.__wrapped__)
+
+    def __len__(self):
+        return len(self.__wrapped__)
+
+    def __contains__(self, value):
+        return value in self.__wrapped__
+
+    def __getitem__(self, key):
+        return self.__wrapped__[key]
+
+    def __setitem__(self, key, value):
+        self.__wrapped__[key] = value
+
+    def __delitem__(self, key):
+        del self.__wrapped__[key]
+
+    def __getslice__(self, i, j):
+        return self.__wrapped__[i:j]
+
+    def __setslice__(self, i, j, value):
+        self.__wrapped__[i:j] = value
+
+    def __delslice__(self, i, j):
+        del self.__wrapped__[i:j]
+
+    def __enter__(self):
+        return self.__wrapped__.__enter__()
+
+    def __exit__(self, *args, **kwargs):
+        return self.__wrapped__.__exit__(*args, **kwargs)
+
+    def __iter__(self):
+        return iter(self.__wrapped__)
+
+    def __copy__(self):
+        raise NotImplementedError('object proxy must define __copy__()')
+
+    def __deepcopy__(self, memo):
+        raise NotImplementedError('object proxy must define __deepcopy__()')
+
+    def __reduce__(self):
+        raise NotImplementedError(
+                'object proxy must define __reduce_ex__()')
+
+    def __reduce_ex__(self, protocol):
+        raise NotImplementedError(
+                'object proxy must define __reduce_ex__()')
+
+class CallableObjectProxy(ObjectProxy):
+
+    def __call__(self, *args, **kwargs):
+        return self.__wrapped__(*args, **kwargs)
+
+class PartialCallableObjectProxy(ObjectProxy):
+
+    def __init__(self, *args, **kwargs):
+        if len(args) < 1:
+            raise TypeError('partial type takes at least one argument')
+
+        wrapped, args = args[0], args[1:]
+
+        if not callable(wrapped):
+            raise TypeError('the first argument must be callable')
+
+        super(PartialCallableObjectProxy, self).__init__(wrapped)
+
+        self._self_args = args
+        self._self_kwargs = kwargs
+
+    def __call__(self, *args, **kwargs):
+        _args = self._self_args + args
+
+        _kwargs = dict(self._self_kwargs)
+        _kwargs.update(kwargs)
+
+        return self.__wrapped__(*_args, **_kwargs)
+
+class _FunctionWrapperBase(ObjectProxy):
+
+    __slots__ = ('_self_instance', '_self_wrapper', '_self_enabled',
+            '_self_binding', '_self_parent')
+
+    def __init__(self, wrapped, instance, wrapper, enabled=None,
+            binding='function', parent=None):
+
+        super(_FunctionWrapperBase, self).__init__(wrapped)
+
+        object.__setattr__(self, '_self_instance', instance)
+        object.__setattr__(self, '_self_wrapper', wrapper)
+        object.__setattr__(self, '_self_enabled', enabled)
+        object.__setattr__(self, '_self_binding', binding)
+        object.__setattr__(self, '_self_parent', parent)
+
+    def __get__(self, instance, owner):
+        # This method is actually doing double duty for both unbound and
+        # bound derived wrapper classes. It should possibly be broken up
+        # and the distinct functionality moved into the derived classes.
+        # Can't do that straight away due to some legacy code which is
+        # relying on it being here in this base class.
+        #
+        # The distinguishing attribute which determines whether we are
+        # being called in an unbound or bound wrapper is the parent
+        # attribute. If binding has never occurred, then the parent will
+        # be None.
+        #
+        # First therefore, is if we are called in an unbound wrapper. In
+        # this case we perform the binding.
+        #
+        # We have one special case to worry about here. This is where we
+        # are decorating a nested class. In this case the wrapped class
+        # would not have a __get__() method to call. In that case we
+        # simply return self.
+        #
+        # Note that we otherwise still do binding even if instance is
+        # None and accessing an unbound instance method from a class.
+        # This is because we need to be able to later detect that
+        # specific case as we will need to extract the instance from the
+        # first argument of those passed in.
+
+        if self._self_parent is None:
+            if not inspect.isclass(self.__wrapped__):
+                descriptor = self.__wrapped__.__get__(instance, owner)
+
+                return self.__bound_function_wrapper__(descriptor, instance,
+                        self._self_wrapper, self._self_enabled,
+                        self._self_binding, self)
+
+            return self
+
+        # Now we have the case of binding occurring a second time on what
+        # was already a bound function. In this case we would usually
+        # return ourselves again. This mirrors what Python does.
+        #
+        # The special case this time is where we were originally bound
+        # with an instance of None and we were likely an instance
+        # method. In that case we rebind against the original wrapped
+        # function from the parent again.
+
+        if self._self_instance is None and self._self_binding == 'function':
+            descriptor = self._self_parent.__wrapped__.__get__(
+                    instance, owner)
+
+            return self._self_parent.__bound_function_wrapper__(
+                    descriptor, instance, self._self_wrapper,
+                    self._self_enabled, self._self_binding,
+                    self._self_parent)
+
+        return self
+
+    def __call__(self, *args, **kwargs):
+        # If enabled has been specified, then evaluate it at this point
+        # and if the wrapper is not to be executed, then simply return
+        # the bound function rather than a bound wrapper for the bound
+        # function. When evaluating enabled, if it is callable we call
+        # it, otherwise we evaluate it as a boolean.
+
+        if self._self_enabled is not None:
+            if callable(self._self_enabled):
+                if not self._self_enabled():
+                    return self.__wrapped__(*args, **kwargs)
+            elif not self._self_enabled:
+                return self.__wrapped__(*args, **kwargs)
+
+        # This can occur where initial function wrapper was applied to
+        # a function that was already bound to an instance. In that case
+        # we want to extract the instance from the function and use it.
+
+        if self._self_binding in ('function', 'classmethod'):
+            if self._self_instance is None:
+                instance = getattr(self.__wrapped__, '__self__', None)
+                if instance is not None:
+                    return self._self_wrapper(self.__wrapped__, instance,
+                            args, kwargs)
+
+        # This is generally invoked when the wrapped function is being
+        # called as a normal function and is not bound to a class as an
+        # instance method. This is also invoked in the case where the
+        # wrapped function was a method, but this wrapper was in turn
+        # wrapped using the staticmethod decorator.
+
+        return self._self_wrapper(self.__wrapped__, self._self_instance,
+                args, kwargs)
+
+    def __set_name__(self, owner, name):
+        # This is a special method use to supply information to
+        # descriptors about what the name of variable in a class
+        # definition is. Not wanting to add this to ObjectProxy as not
+        # sure of broader implications of doing that. Thus restrict to
+        # FunctionWrapper used by decorators.
+
+        if hasattr(self.__wrapped__, "__set_name__"):
+            self.__wrapped__.__set_name__(owner, name)
+
+    def __instancecheck__(self, instance):
+        # This is a special method used by isinstance() to make checks
+        # instance of the `__wrapped__`.
+        return isinstance(instance, self.__wrapped__)
+
+    def __subclasscheck__(self, subclass):
+        # This is a special method used by issubclass() to make checks
+        # about inheritance of classes. We need to upwrap any object
+        # proxy. Not wanting to add this to ObjectProxy as not sure of
+        # broader implications of doing that. Thus restrict to
+        # FunctionWrapper used by decorators.
+
+        if hasattr(subclass, "__wrapped__"):
+            return issubclass(subclass.__wrapped__, self.__wrapped__)
+        else:
+            return issubclass(subclass, self.__wrapped__)
+
+class BoundFunctionWrapper(_FunctionWrapperBase):
+
+    def __call__(self, *args, **kwargs):
+        # If enabled has been specified, then evaluate it at this point
+        # and if the wrapper is not to be executed, then simply return
+        # the bound function rather than a bound wrapper for the bound
+        # function. When evaluating enabled, if it is callable we call
+        # it, otherwise we evaluate it as a boolean.
+
+        if self._self_enabled is not None:
+            if callable(self._self_enabled):
+                if not self._self_enabled():
+                    return self.__wrapped__(*args, **kwargs)
+            elif not self._self_enabled:
+                return self.__wrapped__(*args, **kwargs)
+
+        # We need to do things different depending on whether we are
+        # likely wrapping an instance method vs a static method or class
+        # method.
+
+        if self._self_binding == 'function':
+            if self._self_instance is None:
+                # This situation can occur where someone is calling the
+                # instancemethod via the class type and passing the instance
+                # as the first argument. We need to shift the args before
+                # making the call to the wrapper and effectively bind the
+                # instance to the wrapped function using a partial so the
+                # wrapper doesn't see anything as being different.
+
+                if not args:
+                    raise TypeError('missing 1 required positional argument')
+
+                instance, args = args[0], args[1:]
+                wrapped = PartialCallableObjectProxy(self.__wrapped__, instance)
+                return self._self_wrapper(wrapped, instance, args, kwargs)
+
+            return self._self_wrapper(self.__wrapped__, self._self_instance,
+                    args, kwargs)
+
+        else:
+            # As in this case we would be dealing with a classmethod or
+            # staticmethod, then _self_instance will only tell us whether
+            # when calling the classmethod or staticmethod they did it via an
+            # instance of the class it is bound to and not the case where
+            # done by the class type itself. We thus ignore _self_instance
+            # and use the __self__ attribute of the bound function instead.
+            # For a classmethod, this means instance will be the class type
+            # and for a staticmethod it will be None. This is probably the
+            # more useful thing we can pass through even though we loose
+            # knowledge of whether they were called on the instance vs the
+            # class type, as it reflects what they have available in the
+            # decoratored function.
+
+            instance = getattr(self.__wrapped__, '__self__', None)
+
+            return self._self_wrapper(self.__wrapped__, instance, args,
+                    kwargs)
+
+class FunctionWrapper(_FunctionWrapperBase):
+
+    __bound_function_wrapper__ = BoundFunctionWrapper
+
+    def __init__(self, wrapped, wrapper, enabled=None):
+        # What it is we are wrapping here could be anything. We need to
+        # try and detect specific cases though. In particular, we need
+        # to detect when we are given something that is a method of a
+        # class. Further, we need to know when it is likely an instance
+        # method, as opposed to a class or static method. This can
+        # become problematic though as there isn't strictly a fool proof
+        # method of knowing.
+        #
+        # The situations we could encounter when wrapping a method are:
+        #
+        # 1. The wrapper is being applied as part of a decorator which
+        # is a part of the class definition. In this case what we are
+        # given is the raw unbound function, classmethod or staticmethod
+        # wrapper objects.
+        #
+        # The problem here is that we will not know we are being applied
+        # in the context of the class being set up. This becomes
+        # important later for the case of an instance method, because in
+        # that case we just see it as a raw function and can't
+        # distinguish it from wrapping a normal function outside of
+        # a class context.
+        #
+        # 2. The wrapper is being applied when performing monkey
+        # patching of the class type afterwards and the method to be
+        # wrapped was retrieved direct from the __dict__ of the class
+        # type. This is effectively the same as (1) above.
+        #
+        # 3. The wrapper is being applied when performing monkey
+        # patching of the class type afterwards and the method to be
+        # wrapped was retrieved from the class type. In this case
+        # binding will have been performed where the instance against
+        # which the method is bound will be None at that point.
+        #
+        # This case is a problem because we can no longer tell if the
+        # method was a static method, plus if using Python3, we cannot
+        # tell if it was an instance method as the concept of an
+        # unnbound method no longer exists.
+        #
+        # 4. The wrapper is being applied when performing monkey
+        # patching of an instance of a class. In this case binding will
+        # have been perfomed where the instance was not None.
+        #
+        # This case is a problem because we can no longer tell if the
+        # method was a static method.
+        #
+        # Overall, the best we can do is look at the original type of the
+        # object which was wrapped prior to any binding being done and
+        # see if it is an instance of classmethod or staticmethod. In
+        # the case where other decorators are between us and them, if
+        # they do not propagate the __class__  attribute so that the
+        # isinstance() checks works, then likely this will do the wrong
+        # thing where classmethod and staticmethod are used.
+        #
+        # Since it is likely to be very rare that anyone even puts
+        # decorators around classmethod and staticmethod, likelihood of
+        # that being an issue is very small, so we accept it and suggest
+        # that those other decorators be fixed. It is also only an issue
+        # if a decorator wants to actually do things with the arguments.
+        #
+        # As to not being able to identify static methods properly, we
+        # just hope that that isn't something people are going to want
+        # to wrap, or if they do suggest they do it the correct way by
+        # ensuring that it is decorated in the class definition itself,
+        # or patch it in the __dict__ of the class type.
+        #
+        # So to get the best outcome we can, whenever we aren't sure what
+        # it is, we label it as a 'function'. If it was already bound and
+        # that is rebound later, we assume that it will be an instance
+        # method and try an cope with the possibility that the 'self'
+        # argument it being passed as an explicit argument and shuffle
+        # the arguments around to extract 'self' for use as the instance.
+
+        if isinstance(wrapped, classmethod):
+            binding = 'classmethod'
+
+        elif isinstance(wrapped, staticmethod):
+            binding = 'staticmethod'
+
+        elif hasattr(wrapped, '__self__'):
+            if inspect.isclass(wrapped.__self__):
+                binding = 'classmethod'
+            else:
+                binding = 'function'
+
+        else:
+            binding = 'function'
+
+        super(FunctionWrapper, self).__init__(wrapped, None, wrapper,
+                enabled, binding)
+
+try:
+    if not os.environ.get('WRAPT_DISABLE_EXTENSIONS'):
+        from ._wrappers import (ObjectProxy, CallableObjectProxy,
+            PartialCallableObjectProxy, FunctionWrapper,
+            BoundFunctionWrapper, _FunctionWrapperBase)
+except ImportError:
+    pass
+
+# Helper functions for applying wrappers to existing functions.
+
+def resolve_path(module, name):
+    if isinstance(module, string_types):
+        __import__(module)
+        module = sys.modules[module]
+
+    parent = module
+
+    path = name.split('.')
+    attribute = path[0]
+
+    # We can't just always use getattr() because in doing
+    # that on a class it will cause binding to occur which
+    # will complicate things later and cause some things not
+    # to work. For the case of a class we therefore access
+    # the __dict__ directly. To cope though with the wrong
+    # class being given to us, or a method being moved into
+    # a base class, we need to walk the class hierarchy to
+    # work out exactly which __dict__ the method was defined
+    # in, as accessing it from __dict__ will fail if it was
+    # not actually on the class given. Fallback to using
+    # getattr() if we can't find it. If it truly doesn't
+    # exist, then that will fail.
+
+    def lookup_attribute(parent, attribute):
+        if inspect.isclass(parent):
+            for cls in inspect.getmro(parent):
+                if attribute in vars(cls):
+                    return vars(cls)[attribute]
+            else:
+                return getattr(parent, attribute)
+        else:
+            return getattr(parent, attribute)
+
+    original = lookup_attribute(parent, attribute)
+
+    for attribute in path[1:]:
+        parent = original
+        original = lookup_attribute(parent, attribute)
+
+    return (parent, attribute, original)
+
+def apply_patch(parent, attribute, replacement):
+    setattr(parent, attribute, replacement)
+
+def wrap_object(module, name, factory, args=(), kwargs={}):
+    (parent, attribute, original) = resolve_path(module, name)
+    wrapper = factory(original, *args, **kwargs)
+    apply_patch(parent, attribute, wrapper)
+    return wrapper
+
+# Function for applying a proxy object to an attribute of a class
+# instance. The wrapper works by defining an attribute of the same name
+# on the class which is a descriptor and which intercepts access to the
+# instance attribute. Note that this cannot be used on attributes which
+# are themselves defined by a property object.
+
+class AttributeWrapper(object):
+
+    def __init__(self, attribute, factory, args, kwargs):
+        self.attribute = attribute
+        self.factory = factory
+        self.args = args
+        self.kwargs = kwargs
+
+    def __get__(self, instance, owner):
+        value = instance.__dict__[self.attribute]
+        return self.factory(value, *self.args, **self.kwargs)
+
+    def __set__(self, instance, value):
+        instance.__dict__[self.attribute] = value
+
+    def __delete__(self, instance):
+        del instance.__dict__[self.attribute]
+
+def wrap_object_attribute(module, name, factory, args=(), kwargs={}):
+    path, attribute = name.rsplit('.', 1)
+    parent = resolve_path(module, path)[2]
+    wrapper = AttributeWrapper(attribute, factory, args, kwargs)
+    apply_patch(parent, attribute, wrapper)
+    return wrapper
+
+# Functions for creating a simple decorator using a FunctionWrapper,
+# plus short cut functions for applying wrappers to functions. These are
+# for use when doing monkey patching. For a more featured way of
+# creating decorators see the decorator decorator instead.
+
+def function_wrapper(wrapper):
+    def _wrapper(wrapped, instance, args, kwargs):
+        target_wrapped = args[0]
+        if instance is None:
+            target_wrapper = wrapper
+        elif inspect.isclass(instance):
+            target_wrapper = wrapper.__get__(None, instance)
+        else:
+            target_wrapper = wrapper.__get__(instance, type(instance))
+        return FunctionWrapper(target_wrapped, target_wrapper)
+    return FunctionWrapper(wrapper, _wrapper)
+
+def wrap_function_wrapper(module, name, wrapper):
+    return wrap_object(module, name, FunctionWrapper, (wrapper,))
+
+def patch_function_wrapper(module, name):
+    def _wrapper(wrapper):
+        return wrap_object(module, name, FunctionWrapper, (wrapper,))
+    return _wrapper
+
+def transient_function_wrapper(module, name):
+    def _decorator(wrapper):
+        def _wrapper(wrapped, instance, args, kwargs):
+            target_wrapped = args[0]
+            if instance is None:
+                target_wrapper = wrapper
+            elif inspect.isclass(instance):
+                target_wrapper = wrapper.__get__(None, instance)
+            else:
+                target_wrapper = wrapper.__get__(instance, type(instance))
+            def _execute(wrapped, instance, args, kwargs):
+                (parent, attribute, original) = resolve_path(module, name)
+                replacement = FunctionWrapper(original, target_wrapper)
+                setattr(parent, attribute, replacement)
+                try:
+                    return wrapped(*args, **kwargs)
+                finally:
+                    setattr(parent, attribute, original)
+            return FunctionWrapper(target_wrapped, _execute)
+        return FunctionWrapper(wrapper, _wrapper)
+    return _decorator
+
+# A weak function proxy. This will work on instance methods, class
+# methods, static methods and regular functions. Special treatment is
+# needed for the method types because the bound method is effectively a
+# transient object and applying a weak reference to one will immediately
+# result in it being destroyed and the weakref callback called. The weak
+# reference is therefore applied to the instance the method is bound to
+# and the original function. The function is then rebound at the point
+# of a call via the weak function proxy.
+
+def _weak_function_proxy_callback(ref, proxy, callback):
+    if proxy._self_expired:
+        return
+
+    proxy._self_expired = True
+
+    # This could raise an exception. We let it propagate back and let
+    # the weakref.proxy() deal with it, at which point it generally
+    # prints out a short error message direct to stderr and keeps going.
+
+    if callback is not None:
+        callback(proxy)
+
+class WeakFunctionProxy(ObjectProxy):
+
+    __slots__ = ('_self_expired', '_self_instance')
+
+    def __init__(self, wrapped, callback=None):
+        # We need to determine if the wrapped function is actually a
+        # bound method. In the case of a bound method, we need to keep a
+        # reference to the original unbound function and the instance.
+        # This is necessary because if we hold a reference to the bound
+        # function, it will be the only reference and given it is a
+        # temporary object, it will almost immediately expire and
+        # the weakref callback triggered. So what is done is that we
+        # hold a reference to the instance and unbound function and
+        # when called bind the function to the instance once again and
+        # then call it. Note that we avoid using a nested function for
+        # the callback here so as not to cause any odd reference cycles.
+
+        _callback = callback and functools.partial(
+                _weak_function_proxy_callback, proxy=self,
+                callback=callback)
+
+        self._self_expired = False
+
+        if isinstance(wrapped, _FunctionWrapperBase):
+            self._self_instance = weakref.ref(wrapped._self_instance,
+                    _callback)
+
+            if wrapped._self_parent is not None:
+                super(WeakFunctionProxy, self).__init__(
+                        weakref.proxy(wrapped._self_parent, _callback))
+
+            else:
+                super(WeakFunctionProxy, self).__init__(
+                        weakref.proxy(wrapped, _callback))
+
+            return
+
+        try:
+            self._self_instance = weakref.ref(wrapped.__self__, _callback)
+
+            super(WeakFunctionProxy, self).__init__(
+                    weakref.proxy(wrapped.__func__, _callback))
+
+        except AttributeError:
+            self._self_instance = None
+
+            super(WeakFunctionProxy, self).__init__(
+                    weakref.proxy(wrapped, _callback))
+
+    def __call__(self, *args, **kwargs):
+        # We perform a boolean check here on the instance and wrapped
+        # function as that will trigger the reference error prior to
+        # calling if the reference had expired.
+
+        instance = self._self_instance and self._self_instance()
+        function = self.__wrapped__ and self.__wrapped__
+
+        # If the wrapped function was originally a bound function, for
+        # which we retained a reference to the instance and the unbound
+        # function we need to rebind the function and then call it. If
+        # not just called the wrapped function.
+
+        if instance is None:
+            return self.__wrapped__(*args, **kwargs)
+
+        return function.__get__(instance, type(instance))(*args, **kwargs)
diff --git a/myenv/lib/python3.9/site-packages/yaml/__init__.py b/myenv/lib/python3.9/site-packages/yaml/__init__.py
new file mode 100644
index 0000000..465041d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/__init__.py
@@ -0,0 +1,390 @@
+
+from .error import *
+
+from .tokens import *
+from .events import *
+from .nodes import *
+
+from .loader import *
+from .dumper import *
+
+__version__ = '6.0'
+try:
+    from .cyaml import *
+    __with_libyaml__ = True
+except ImportError:
+    __with_libyaml__ = False
+
+import io
+
+#------------------------------------------------------------------------------
+# XXX "Warnings control" is now deprecated. Leaving in the API function to not
+# break code that uses it.
+#------------------------------------------------------------------------------
+def warnings(settings=None):
+    if settings is None:
+        return {}
+
+#------------------------------------------------------------------------------
+def scan(stream, Loader=Loader):
+    """
+    Scan a YAML stream and produce scanning tokens.
+    """
+    loader = Loader(stream)
+    try:
+        while loader.check_token():
+            yield loader.get_token()
+    finally:
+        loader.dispose()
+
+def parse(stream, Loader=Loader):
+    """
+    Parse a YAML stream and produce parsing events.
+    """
+    loader = Loader(stream)
+    try:
+        while loader.check_event():
+            yield loader.get_event()
+    finally:
+        loader.dispose()
+
+def compose(stream, Loader=Loader):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding representation tree.
+    """
+    loader = Loader(stream)
+    try:
+        return loader.get_single_node()
+    finally:
+        loader.dispose()
+
+def compose_all(stream, Loader=Loader):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding representation trees.
+    """
+    loader = Loader(stream)
+    try:
+        while loader.check_node():
+            yield loader.get_node()
+    finally:
+        loader.dispose()
+
+def load(stream, Loader):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+    """
+    loader = Loader(stream)
+    try:
+        return loader.get_single_data()
+    finally:
+        loader.dispose()
+
+def load_all(stream, Loader):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+    """
+    loader = Loader(stream)
+    try:
+        while loader.check_data():
+            yield loader.get_data()
+    finally:
+        loader.dispose()
+
+def full_load(stream):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+
+    Resolve all tags except those known to be
+    unsafe on untrusted input.
+    """
+    return load(stream, FullLoader)
+
+def full_load_all(stream):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+
+    Resolve all tags except those known to be
+    unsafe on untrusted input.
+    """
+    return load_all(stream, FullLoader)
+
+def safe_load(stream):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+
+    Resolve only basic YAML tags. This is known
+    to be safe for untrusted input.
+    """
+    return load(stream, SafeLoader)
+
+def safe_load_all(stream):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+
+    Resolve only basic YAML tags. This is known
+    to be safe for untrusted input.
+    """
+    return load_all(stream, SafeLoader)
+
+def unsafe_load(stream):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+
+    Resolve all tags, even those known to be
+    unsafe on untrusted input.
+    """
+    return load(stream, UnsafeLoader)
+
+def unsafe_load_all(stream):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+
+    Resolve all tags, even those known to be
+    unsafe on untrusted input.
+    """
+    return load_all(stream, UnsafeLoader)
+
+def emit(events, stream=None, Dumper=Dumper,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None):
+    """
+    Emit YAML parsing events into a stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        stream = io.StringIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break)
+    try:
+        for event in events:
+            dumper.emit(event)
+    finally:
+        dumper.dispose()
+    if getvalue:
+        return getvalue()
+
+def serialize_all(nodes, stream=None, Dumper=Dumper,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None,
+        encoding=None, explicit_start=None, explicit_end=None,
+        version=None, tags=None):
+    """
+    Serialize a sequence of representation trees into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        if encoding is None:
+            stream = io.StringIO()
+        else:
+            stream = io.BytesIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break,
+            encoding=encoding, version=version, tags=tags,
+            explicit_start=explicit_start, explicit_end=explicit_end)
+    try:
+        dumper.open()
+        for node in nodes:
+            dumper.serialize(node)
+        dumper.close()
+    finally:
+        dumper.dispose()
+    if getvalue:
+        return getvalue()
+
+def serialize(node, stream=None, Dumper=Dumper, **kwds):
+    """
+    Serialize a representation tree into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    return serialize_all([node], stream, Dumper=Dumper, **kwds)
+
+def dump_all(documents, stream=None, Dumper=Dumper,
+        default_style=None, default_flow_style=False,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None,
+        encoding=None, explicit_start=None, explicit_end=None,
+        version=None, tags=None, sort_keys=True):
+    """
+    Serialize a sequence of Python objects into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        if encoding is None:
+            stream = io.StringIO()
+        else:
+            stream = io.BytesIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, default_style=default_style,
+            default_flow_style=default_flow_style,
+            canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break,
+            encoding=encoding, version=version, tags=tags,
+            explicit_start=explicit_start, explicit_end=explicit_end, sort_keys=sort_keys)
+    try:
+        dumper.open()
+        for data in documents:
+            dumper.represent(data)
+        dumper.close()
+    finally:
+        dumper.dispose()
+    if getvalue:
+        return getvalue()
+
+def dump(data, stream=None, Dumper=Dumper, **kwds):
+    """
+    Serialize a Python object into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all([data], stream, Dumper=Dumper, **kwds)
+
+def safe_dump_all(documents, stream=None, **kwds):
+    """
+    Serialize a sequence of Python objects into a YAML stream.
+    Produce only basic YAML tags.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all(documents, stream, Dumper=SafeDumper, **kwds)
+
+def safe_dump(data, stream=None, **kwds):
+    """
+    Serialize a Python object into a YAML stream.
+    Produce only basic YAML tags.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all([data], stream, Dumper=SafeDumper, **kwds)
+
+def add_implicit_resolver(tag, regexp, first=None,
+        Loader=None, Dumper=Dumper):
+    """
+    Add an implicit scalar detector.
+    If an implicit scalar value matches the given regexp,
+    the corresponding tag is assigned to the scalar.
+    first is a sequence of possible initial characters or None.
+    """
+    if Loader is None:
+        loader.Loader.add_implicit_resolver(tag, regexp, first)
+        loader.FullLoader.add_implicit_resolver(tag, regexp, first)
+        loader.UnsafeLoader.add_implicit_resolver(tag, regexp, first)
+    else:
+        Loader.add_implicit_resolver(tag, regexp, first)
+    Dumper.add_implicit_resolver(tag, regexp, first)
+
+def add_path_resolver(tag, path, kind=None, Loader=None, Dumper=Dumper):
+    """
+    Add a path based resolver for the given tag.
+    A path is a list of keys that forms a path
+    to a node in the representation tree.
+    Keys can be string values, integers, or None.
+    """
+    if Loader is None:
+        loader.Loader.add_path_resolver(tag, path, kind)
+        loader.FullLoader.add_path_resolver(tag, path, kind)
+        loader.UnsafeLoader.add_path_resolver(tag, path, kind)
+    else:
+        Loader.add_path_resolver(tag, path, kind)
+    Dumper.add_path_resolver(tag, path, kind)
+
+def add_constructor(tag, constructor, Loader=None):
+    """
+    Add a constructor for the given tag.
+    Constructor is a function that accepts a Loader instance
+    and a node object and produces the corresponding Python object.
+    """
+    if Loader is None:
+        loader.Loader.add_constructor(tag, constructor)
+        loader.FullLoader.add_constructor(tag, constructor)
+        loader.UnsafeLoader.add_constructor(tag, constructor)
+    else:
+        Loader.add_constructor(tag, constructor)
+
+def add_multi_constructor(tag_prefix, multi_constructor, Loader=None):
+    """
+    Add a multi-constructor for the given tag prefix.
+    Multi-constructor is called for a node if its tag starts with tag_prefix.
+    Multi-constructor accepts a Loader instance, a tag suffix,
+    and a node object and produces the corresponding Python object.
+    """
+    if Loader is None:
+        loader.Loader.add_multi_constructor(tag_prefix, multi_constructor)
+        loader.FullLoader.add_multi_constructor(tag_prefix, multi_constructor)
+        loader.UnsafeLoader.add_multi_constructor(tag_prefix, multi_constructor)
+    else:
+        Loader.add_multi_constructor(tag_prefix, multi_constructor)
+
+def add_representer(data_type, representer, Dumper=Dumper):
+    """
+    Add a representer for the given type.
+    Representer is a function accepting a Dumper instance
+    and an instance of the given data type
+    and producing the corresponding representation node.
+    """
+    Dumper.add_representer(data_type, representer)
+
+def add_multi_representer(data_type, multi_representer, Dumper=Dumper):
+    """
+    Add a representer for the given type.
+    Multi-representer is a function accepting a Dumper instance
+    and an instance of the given data type or subtype
+    and producing the corresponding representation node.
+    """
+    Dumper.add_multi_representer(data_type, multi_representer)
+
+class YAMLObjectMetaclass(type):
+    """
+    The metaclass for YAMLObject.
+    """
+    def __init__(cls, name, bases, kwds):
+        super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds)
+        if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None:
+            if isinstance(cls.yaml_loader, list):
+                for loader in cls.yaml_loader:
+                    loader.add_constructor(cls.yaml_tag, cls.from_yaml)
+            else:
+                cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml)
+
+            cls.yaml_dumper.add_representer(cls, cls.to_yaml)
+
+class YAMLObject(metaclass=YAMLObjectMetaclass):
+    """
+    An object that can dump itself to a YAML stream
+    and load itself from a YAML stream.
+    """
+
+    __slots__ = ()  # no direct instantiation, so allow immutable subclasses
+
+    yaml_loader = [Loader, FullLoader, UnsafeLoader]
+    yaml_dumper = Dumper
+
+    yaml_tag = None
+    yaml_flow_style = None
+
+    @classmethod
+    def from_yaml(cls, loader, node):
+        """
+        Convert a representation node to a Python object.
+        """
+        return loader.construct_yaml_object(node, cls)
+
+    @classmethod
+    def to_yaml(cls, dumper, data):
+        """
+        Convert a Python object to a representation node.
+        """
+        return dumper.represent_yaml_object(cls.yaml_tag, data, cls,
+                flow_style=cls.yaml_flow_style)
+
diff --git a/myenv/lib/python3.9/site-packages/yaml/_yaml.cpython-39-darwin.so b/myenv/lib/python3.9/site-packages/yaml/_yaml.cpython-39-darwin.so
new file mode 100755
index 0000000..dfd48bd
Binary files /dev/null and b/myenv/lib/python3.9/site-packages/yaml/_yaml.cpython-39-darwin.so differ
diff --git a/myenv/lib/python3.9/site-packages/yaml/composer.py b/myenv/lib/python3.9/site-packages/yaml/composer.py
new file mode 100644
index 0000000..6d15cb4
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/composer.py
@@ -0,0 +1,139 @@
+
+__all__ = ['Composer', 'ComposerError']
+
+from .error import MarkedYAMLError
+from .events import *
+from .nodes import *
+
+class ComposerError(MarkedYAMLError):
+    pass
+
+class Composer:
+
+    def __init__(self):
+        self.anchors = {}
+
+    def check_node(self):
+        # Drop the STREAM-START event.
+        if self.check_event(StreamStartEvent):
+            self.get_event()
+
+        # If there are more documents available?
+        return not self.check_event(StreamEndEvent)
+
+    def get_node(self):
+        # Get the root node of the next document.
+        if not self.check_event(StreamEndEvent):
+            return self.compose_document()
+
+    def get_single_node(self):
+        # Drop the STREAM-START event.
+        self.get_event()
+
+        # Compose a document if the stream is not empty.
+        document = None
+        if not self.check_event(StreamEndEvent):
+            document = self.compose_document()
+
+        # Ensure that the stream contains no more documents.
+        if not self.check_event(StreamEndEvent):
+            event = self.get_event()
+            raise ComposerError("expected a single document in the stream",
+                    document.start_mark, "but found another document",
+                    event.start_mark)
+
+        # Drop the STREAM-END event.
+        self.get_event()
+
+        return document
+
+    def compose_document(self):
+        # Drop the DOCUMENT-START event.
+        self.get_event()
+
+        # Compose the root node.
+        node = self.compose_node(None, None)
+
+        # Drop the DOCUMENT-END event.
+        self.get_event()
+
+        self.anchors = {}
+        return node
+
+    def compose_node(self, parent, index):
+        if self.check_event(AliasEvent):
+            event = self.get_event()
+            anchor = event.anchor
+            if anchor not in self.anchors:
+                raise ComposerError(None, None, "found undefined alias %r"
+                        % anchor, event.start_mark)
+            return self.anchors[anchor]
+        event = self.peek_event()
+        anchor = event.anchor
+        if anchor is not None:
+            if anchor in self.anchors:
+                raise ComposerError("found duplicate anchor %r; first occurrence"
+                        % anchor, self.anchors[anchor].start_mark,
+                        "second occurrence", event.start_mark)
+        self.descend_resolver(parent, index)
+        if self.check_event(ScalarEvent):
+            node = self.compose_scalar_node(anchor)
+        elif self.check_event(SequenceStartEvent):
+            node = self.compose_sequence_node(anchor)
+        elif self.check_event(MappingStartEvent):
+            node = self.compose_mapping_node(anchor)
+        self.ascend_resolver()
+        return node
+
+    def compose_scalar_node(self, anchor):
+        event = self.get_event()
+        tag = event.tag
+        if tag is None or tag == '!':
+            tag = self.resolve(ScalarNode, event.value, event.implicit)
+        node = ScalarNode(tag, event.value,
+                event.start_mark, event.end_mark, style=event.style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        return node
+
+    def compose_sequence_node(self, anchor):
+        start_event = self.get_event()
+        tag = start_event.tag
+        if tag is None or tag == '!':
+            tag = self.resolve(SequenceNode, None, start_event.implicit)
+        node = SequenceNode(tag, [],
+                start_event.start_mark, None,
+                flow_style=start_event.flow_style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        index = 0
+        while not self.check_event(SequenceEndEvent):
+            node.value.append(self.compose_node(node, index))
+            index += 1
+        end_event = self.get_event()
+        node.end_mark = end_event.end_mark
+        return node
+
+    def compose_mapping_node(self, anchor):
+        start_event = self.get_event()
+        tag = start_event.tag
+        if tag is None or tag == '!':
+            tag = self.resolve(MappingNode, None, start_event.implicit)
+        node = MappingNode(tag, [],
+                start_event.start_mark, None,
+                flow_style=start_event.flow_style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        while not self.check_event(MappingEndEvent):
+            #key_event = self.peek_event()
+            item_key = self.compose_node(node, None)
+            #if item_key in node.value:
+            #    raise ComposerError("while composing a mapping", start_event.start_mark,
+            #            "found duplicate key", key_event.start_mark)
+            item_value = self.compose_node(node, item_key)
+            #node.value[item_key] = item_value
+            node.value.append((item_key, item_value))
+        end_event = self.get_event()
+        node.end_mark = end_event.end_mark
+        return node
+
diff --git a/myenv/lib/python3.9/site-packages/yaml/constructor.py b/myenv/lib/python3.9/site-packages/yaml/constructor.py
new file mode 100644
index 0000000..619acd3
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/constructor.py
@@ -0,0 +1,748 @@
+
+__all__ = [
+    'BaseConstructor',
+    'SafeConstructor',
+    'FullConstructor',
+    'UnsafeConstructor',
+    'Constructor',
+    'ConstructorError'
+]
+
+from .error import *
+from .nodes import *
+
+import collections.abc, datetime, base64, binascii, re, sys, types
+
+class ConstructorError(MarkedYAMLError):
+    pass
+
+class BaseConstructor:
+
+    yaml_constructors = {}
+    yaml_multi_constructors = {}
+
+    def __init__(self):
+        self.constructed_objects = {}
+        self.recursive_objects = {}
+        self.state_generators = []
+        self.deep_construct = False
+
+    def check_data(self):
+        # If there are more documents available?
+        return self.check_node()
+
+    def check_state_key(self, key):
+        """Block special attributes/methods from being set in a newly created
+        object, to prevent user-controlled methods from being called during
+        deserialization"""
+        if self.get_state_keys_blacklist_regexp().match(key):
+            raise ConstructorError(None, None,
+                "blacklisted key '%s' in instance state found" % (key,), None)
+
+    def get_data(self):
+        # Construct and return the next document.
+        if self.check_node():
+            return self.construct_document(self.get_node())
+
+    def get_single_data(self):
+        # Ensure that the stream contains a single document and construct it.
+        node = self.get_single_node()
+        if node is not None:
+            return self.construct_document(node)
+        return None
+
+    def construct_document(self, node):
+        data = self.construct_object(node)
+        while self.state_generators:
+            state_generators = self.state_generators
+            self.state_generators = []
+            for generator in state_generators:
+                for dummy in generator:
+                    pass
+        self.constructed_objects = {}
+        self.recursive_objects = {}
+        self.deep_construct = False
+        return data
+
+    def construct_object(self, node, deep=False):
+        if node in self.constructed_objects:
+            return self.constructed_objects[node]
+        if deep:
+            old_deep = self.deep_construct
+            self.deep_construct = True
+        if node in self.recursive_objects:
+            raise ConstructorError(None, None,
+                    "found unconstructable recursive node", node.start_mark)
+        self.recursive_objects[node] = None
+        constructor = None
+        tag_suffix = None
+        if node.tag in self.yaml_constructors:
+            constructor = self.yaml_constructors[node.tag]
+        else:
+            for tag_prefix in self.yaml_multi_constructors:
+                if tag_prefix is not None and node.tag.startswith(tag_prefix):
+                    tag_suffix = node.tag[len(tag_prefix):]
+                    constructor = self.yaml_multi_constructors[tag_prefix]
+                    break
+            else:
+                if None in self.yaml_multi_constructors:
+                    tag_suffix = node.tag
+                    constructor = self.yaml_multi_constructors[None]
+                elif None in self.yaml_constructors:
+                    constructor = self.yaml_constructors[None]
+                elif isinstance(node, ScalarNode):
+                    constructor = self.__class__.construct_scalar
+                elif isinstance(node, SequenceNode):
+                    constructor = self.__class__.construct_sequence
+                elif isinstance(node, MappingNode):
+                    constructor = self.__class__.construct_mapping
+        if tag_suffix is None:
+            data = constructor(self, node)
+        else:
+            data = constructor(self, tag_suffix, node)
+        if isinstance(data, types.GeneratorType):
+            generator = data
+            data = next(generator)
+            if self.deep_construct:
+                for dummy in generator:
+                    pass
+            else:
+                self.state_generators.append(generator)
+        self.constructed_objects[node] = data
+        del self.recursive_objects[node]
+        if deep:
+            self.deep_construct = old_deep
+        return data
+
+    def construct_scalar(self, node):
+        if not isinstance(node, ScalarNode):
+            raise ConstructorError(None, None,
+                    "expected a scalar node, but found %s" % node.id,
+                    node.start_mark)
+        return node.value
+
+    def construct_sequence(self, node, deep=False):
+        if not isinstance(node, SequenceNode):
+            raise ConstructorError(None, None,
+                    "expected a sequence node, but found %s" % node.id,
+                    node.start_mark)
+        return [self.construct_object(child, deep=deep)
+                for child in node.value]
+
+    def construct_mapping(self, node, deep=False):
+        if not isinstance(node, MappingNode):
+            raise ConstructorError(None, None,
+                    "expected a mapping node, but found %s" % node.id,
+                    node.start_mark)
+        mapping = {}
+        for key_node, value_node in node.value:
+            key = self.construct_object(key_node, deep=deep)
+            if not isinstance(key, collections.abc.Hashable):
+                raise ConstructorError("while constructing a mapping", node.start_mark,
+                        "found unhashable key", key_node.start_mark)
+            value = self.construct_object(value_node, deep=deep)
+            mapping[key] = value
+        return mapping
+
+    def construct_pairs(self, node, deep=False):
+        if not isinstance(node, MappingNode):
+            raise ConstructorError(None, None,
+                    "expected a mapping node, but found %s" % node.id,
+                    node.start_mark)
+        pairs = []
+        for key_node, value_node in node.value:
+            key = self.construct_object(key_node, deep=deep)
+            value = self.construct_object(value_node, deep=deep)
+            pairs.append((key, value))
+        return pairs
+
+    @classmethod
+    def add_constructor(cls, tag, constructor):
+        if not 'yaml_constructors' in cls.__dict__:
+            cls.yaml_constructors = cls.yaml_constructors.copy()
+        cls.yaml_constructors[tag] = constructor
+
+    @classmethod
+    def add_multi_constructor(cls, tag_prefix, multi_constructor):
+        if not 'yaml_multi_constructors' in cls.__dict__:
+            cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy()
+        cls.yaml_multi_constructors[tag_prefix] = multi_constructor
+
+class SafeConstructor(BaseConstructor):
+
+    def construct_scalar(self, node):
+        if isinstance(node, MappingNode):
+            for key_node, value_node in node.value:
+                if key_node.tag == 'tag:yaml.org,2002:value':
+                    return self.construct_scalar(value_node)
+        return super().construct_scalar(node)
+
+    def flatten_mapping(self, node):
+        merge = []
+        index = 0
+        while index < len(node.value):
+            key_node, value_node = node.value[index]
+            if key_node.tag == 'tag:yaml.org,2002:merge':
+                del node.value[index]
+                if isinstance(value_node, MappingNode):
+                    self.flatten_mapping(value_node)
+                    merge.extend(value_node.value)
+                elif isinstance(value_node, SequenceNode):
+                    submerge = []
+                    for subnode in value_node.value:
+                        if not isinstance(subnode, MappingNode):
+                            raise ConstructorError("while constructing a mapping",
+                                    node.start_mark,
+                                    "expected a mapping for merging, but found %s"
+                                    % subnode.id, subnode.start_mark)
+                        self.flatten_mapping(subnode)
+                        submerge.append(subnode.value)
+                    submerge.reverse()
+                    for value in submerge:
+                        merge.extend(value)
+                else:
+                    raise ConstructorError("while constructing a mapping", node.start_mark,
+                            "expected a mapping or list of mappings for merging, but found %s"
+                            % value_node.id, value_node.start_mark)
+            elif key_node.tag == 'tag:yaml.org,2002:value':
+                key_node.tag = 'tag:yaml.org,2002:str'
+                index += 1
+            else:
+                index += 1
+        if merge:
+            node.value = merge + node.value
+
+    def construct_mapping(self, node, deep=False):
+        if isinstance(node, MappingNode):
+            self.flatten_mapping(node)
+        return super().construct_mapping(node, deep=deep)
+
+    def construct_yaml_null(self, node):
+        self.construct_scalar(node)
+        return None
+
+    bool_values = {
+        'yes':      True,
+        'no':       False,
+        'true':     True,
+        'false':    False,
+        'on':       True,
+        'off':      False,
+    }
+
+    def construct_yaml_bool(self, node):
+        value = self.construct_scalar(node)
+        return self.bool_values[value.lower()]
+
+    def construct_yaml_int(self, node):
+        value = self.construct_scalar(node)
+        value = value.replace('_', '')
+        sign = +1
+        if value[0] == '-':
+            sign = -1
+        if value[0] in '+-':
+            value = value[1:]
+        if value == '0':
+            return 0
+        elif value.startswith('0b'):
+            return sign*int(value[2:], 2)
+        elif value.startswith('0x'):
+            return sign*int(value[2:], 16)
+        elif value[0] == '0':
+            return sign*int(value, 8)
+        elif ':' in value:
+            digits = [int(part) for part in value.split(':')]
+            digits.reverse()
+            base = 1
+            value = 0
+            for digit in digits:
+                value += digit*base
+                base *= 60
+            return sign*value
+        else:
+            return sign*int(value)
+
+    inf_value = 1e300
+    while inf_value != inf_value*inf_value:
+        inf_value *= inf_value
+    nan_value = -inf_value/inf_value   # Trying to make a quiet NaN (like C99).
+
+    def construct_yaml_float(self, node):
+        value = self.construct_scalar(node)
+        value = value.replace('_', '').lower()
+        sign = +1
+        if value[0] == '-':
+            sign = -1
+        if value[0] in '+-':
+            value = value[1:]
+        if value == '.inf':
+            return sign*self.inf_value
+        elif value == '.nan':
+            return self.nan_value
+        elif ':' in value:
+            digits = [float(part) for part in value.split(':')]
+            digits.reverse()
+            base = 1
+            value = 0.0
+            for digit in digits:
+                value += digit*base
+                base *= 60
+            return sign*value
+        else:
+            return sign*float(value)
+
+    def construct_yaml_binary(self, node):
+        try:
+            value = self.construct_scalar(node).encode('ascii')
+        except UnicodeEncodeError as exc:
+            raise ConstructorError(None, None,
+                    "failed to convert base64 data into ascii: %s" % exc,
+                    node.start_mark)
+        try:
+            if hasattr(base64, 'decodebytes'):
+                return base64.decodebytes(value)
+            else:
+                return base64.decodestring(value)
+        except binascii.Error as exc:
+            raise ConstructorError(None, None,
+                    "failed to decode base64 data: %s" % exc, node.start_mark)
+
+    timestamp_regexp = re.compile(
+            r'''^(?P<year>[0-9][0-9][0-9][0-9])
+                -(?P<month>[0-9][0-9]?)
+                -(?P<day>[0-9][0-9]?)
+                (?:(?:[Tt]|[ \t]+)
+                (?P<hour>[0-9][0-9]?)
+                :(?P<minute>[0-9][0-9])
+                :(?P<second>[0-9][0-9])
+                (?:\.(?P<fraction>[0-9]*))?
+                (?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)
+                (?::(?P<tz_minute>[0-9][0-9]))?))?)?$''', re.X)
+
+    def construct_yaml_timestamp(self, node):
+        value = self.construct_scalar(node)
+        match = self.timestamp_regexp.match(node.value)
+        values = match.groupdict()
+        year = int(values['year'])
+        month = int(values['month'])
+        day = int(values['day'])
+        if not values['hour']:
+            return datetime.date(year, month, day)
+        hour = int(values['hour'])
+        minute = int(values['minute'])
+        second = int(values['second'])
+        fraction = 0
+        tzinfo = None
+        if values['fraction']:
+            fraction = values['fraction'][:6]
+            while len(fraction) < 6:
+                fraction += '0'
+            fraction = int(fraction)
+        if values['tz_sign']:
+            tz_hour = int(values['tz_hour'])
+            tz_minute = int(values['tz_minute'] or 0)
+            delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute)
+            if values['tz_sign'] == '-':
+                delta = -delta
+            tzinfo = datetime.timezone(delta)
+        elif values['tz']:
+            tzinfo = datetime.timezone.utc
+        return datetime.datetime(year, month, day, hour, minute, second, fraction,
+                                 tzinfo=tzinfo)
+
+    def construct_yaml_omap(self, node):
+        # Note: we do not check for duplicate keys, because it's too
+        # CPU-expensive.
+        omap = []
+        yield omap
+        if not isinstance(node, SequenceNode):
+            raise ConstructorError("while constructing an ordered map", node.start_mark,
+                    "expected a sequence, but found %s" % node.id, node.start_mark)
+        for subnode in node.value:
+            if not isinstance(subnode, MappingNode):
+                raise ConstructorError("while constructing an ordered map", node.start_mark,
+                        "expected a mapping of length 1, but found %s" % subnode.id,
+                        subnode.start_mark)
+            if len(subnode.value) != 1:
+                raise ConstructorError("while constructing an ordered map", node.start_mark,
+                        "expected a single mapping item, but found %d items" % len(subnode.value),
+                        subnode.start_mark)
+            key_node, value_node = subnode.value[0]
+            key = self.construct_object(key_node)
+            value = self.construct_object(value_node)
+            omap.append((key, value))
+
+    def construct_yaml_pairs(self, node):
+        # Note: the same code as `construct_yaml_omap`.
+        pairs = []
+        yield pairs
+        if not isinstance(node, SequenceNode):
+            raise ConstructorError("while constructing pairs", node.start_mark,
+                    "expected a sequence, but found %s" % node.id, node.start_mark)
+        for subnode in node.value:
+            if not isinstance(subnode, MappingNode):
+                raise ConstructorError("while constructing pairs", node.start_mark,
+                        "expected a mapping of length 1, but found %s" % subnode.id,
+                        subnode.start_mark)
+            if len(subnode.value) != 1:
+                raise ConstructorError("while constructing pairs", node.start_mark,
+                        "expected a single mapping item, but found %d items" % len(subnode.value),
+                        subnode.start_mark)
+            key_node, value_node = subnode.value[0]
+            key = self.construct_object(key_node)
+            value = self.construct_object(value_node)
+            pairs.append((key, value))
+
+    def construct_yaml_set(self, node):
+        data = set()
+        yield data
+        value = self.construct_mapping(node)
+        data.update(value)
+
+    def construct_yaml_str(self, node):
+        return self.construct_scalar(node)
+
+    def construct_yaml_seq(self, node):
+        data = []
+        yield data
+        data.extend(self.construct_sequence(node))
+
+    def construct_yaml_map(self, node):
+        data = {}
+        yield data
+        value = self.construct_mapping(node)
+        data.update(value)
+
+    def construct_yaml_object(self, node, cls):
+        data = cls.__new__(cls)
+        yield data
+        if hasattr(data, '__setstate__'):
+            state = self.construct_mapping(node, deep=True)
+            data.__setstate__(state)
+        else:
+            state = self.construct_mapping(node)
+            data.__dict__.update(state)
+
+    def construct_undefined(self, node):
+        raise ConstructorError(None, None,
+                "could not determine a constructor for the tag %r" % node.tag,
+                node.start_mark)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:null',
+        SafeConstructor.construct_yaml_null)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:bool',
+        SafeConstructor.construct_yaml_bool)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:int',
+        SafeConstructor.construct_yaml_int)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:float',
+        SafeConstructor.construct_yaml_float)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:binary',
+        SafeConstructor.construct_yaml_binary)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:timestamp',
+        SafeConstructor.construct_yaml_timestamp)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:omap',
+        SafeConstructor.construct_yaml_omap)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:pairs',
+        SafeConstructor.construct_yaml_pairs)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:set',
+        SafeConstructor.construct_yaml_set)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:str',
+        SafeConstructor.construct_yaml_str)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:seq',
+        SafeConstructor.construct_yaml_seq)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:map',
+        SafeConstructor.construct_yaml_map)
+
+SafeConstructor.add_constructor(None,
+        SafeConstructor.construct_undefined)
+
+class FullConstructor(SafeConstructor):
+    # 'extend' is blacklisted because it is used by
+    # construct_python_object_apply to add `listitems` to a newly generate
+    # python instance
+    def get_state_keys_blacklist(self):
+        return ['^extend$', '^__.*__$']
+
+    def get_state_keys_blacklist_regexp(self):
+        if not hasattr(self, 'state_keys_blacklist_regexp'):
+            self.state_keys_blacklist_regexp = re.compile('(' + '|'.join(self.get_state_keys_blacklist()) + ')')
+        return self.state_keys_blacklist_regexp
+
+    def construct_python_str(self, node):
+        return self.construct_scalar(node)
+
+    def construct_python_unicode(self, node):
+        return self.construct_scalar(node)
+
+    def construct_python_bytes(self, node):
+        try:
+            value = self.construct_scalar(node).encode('ascii')
+        except UnicodeEncodeError as exc:
+            raise ConstructorError(None, None,
+                    "failed to convert base64 data into ascii: %s" % exc,
+                    node.start_mark)
+        try:
+            if hasattr(base64, 'decodebytes'):
+                return base64.decodebytes(value)
+            else:
+                return base64.decodestring(value)
+        except binascii.Error as exc:
+            raise ConstructorError(None, None,
+                    "failed to decode base64 data: %s" % exc, node.start_mark)
+
+    def construct_python_long(self, node):
+        return self.construct_yaml_int(node)
+
+    def construct_python_complex(self, node):
+       return complex(self.construct_scalar(node))
+
+    def construct_python_tuple(self, node):
+        return tuple(self.construct_sequence(node))
+
+    def find_python_module(self, name, mark, unsafe=False):
+        if not name:
+            raise ConstructorError("while constructing a Python module", mark,
+                    "expected non-empty name appended to the tag", mark)
+        if unsafe:
+            try:
+                __import__(name)
+            except ImportError as exc:
+                raise ConstructorError("while constructing a Python module", mark,
+                        "cannot find module %r (%s)" % (name, exc), mark)
+        if name not in sys.modules:
+            raise ConstructorError("while constructing a Python module", mark,
+                    "module %r is not imported" % name, mark)
+        return sys.modules[name]
+
+    def find_python_name(self, name, mark, unsafe=False):
+        if not name:
+            raise ConstructorError("while constructing a Python object", mark,
+                    "expected non-empty name appended to the tag", mark)
+        if '.' in name:
+            module_name, object_name = name.rsplit('.', 1)
+        else:
+            module_name = 'builtins'
+            object_name = name
+        if unsafe:
+            try:
+                __import__(module_name)
+            except ImportError as exc:
+                raise ConstructorError("while constructing a Python object", mark,
+                        "cannot find module %r (%s)" % (module_name, exc), mark)
+        if module_name not in sys.modules:
+            raise ConstructorError("while constructing a Python object", mark,
+                    "module %r is not imported" % module_name, mark)
+        module = sys.modules[module_name]
+        if not hasattr(module, object_name):
+            raise ConstructorError("while constructing a Python object", mark,
+                    "cannot find %r in the module %r"
+                    % (object_name, module.__name__), mark)
+        return getattr(module, object_name)
+
+    def construct_python_name(self, suffix, node):
+        value = self.construct_scalar(node)
+        if value:
+            raise ConstructorError("while constructing a Python name", node.start_mark,
+                    "expected the empty value, but found %r" % value, node.start_mark)
+        return self.find_python_name(suffix, node.start_mark)
+
+    def construct_python_module(self, suffix, node):
+        value = self.construct_scalar(node)
+        if value:
+            raise ConstructorError("while constructing a Python module", node.start_mark,
+                    "expected the empty value, but found %r" % value, node.start_mark)
+        return self.find_python_module(suffix, node.start_mark)
+
+    def make_python_instance(self, suffix, node,
+            args=None, kwds=None, newobj=False, unsafe=False):
+        if not args:
+            args = []
+        if not kwds:
+            kwds = {}
+        cls = self.find_python_name(suffix, node.start_mark)
+        if not (unsafe or isinstance(cls, type)):
+            raise ConstructorError("while constructing a Python instance", node.start_mark,
+                    "expected a class, but found %r" % type(cls),
+                    node.start_mark)
+        if newobj and isinstance(cls, type):
+            return cls.__new__(cls, *args, **kwds)
+        else:
+            return cls(*args, **kwds)
+
+    def set_python_instance_state(self, instance, state, unsafe=False):
+        if hasattr(instance, '__setstate__'):
+            instance.__setstate__(state)
+        else:
+            slotstate = {}
+            if isinstance(state, tuple) and len(state) == 2:
+                state, slotstate = state
+            if hasattr(instance, '__dict__'):
+                if not unsafe and state:
+                    for key in state.keys():
+                        self.check_state_key(key)
+                instance.__dict__.update(state)
+            elif state:
+                slotstate.update(state)
+            for key, value in slotstate.items():
+                if not unsafe:
+                    self.check_state_key(key)
+                setattr(instance, key, value)
+
+    def construct_python_object(self, suffix, node):
+        # Format:
+        #   !!python/object:module.name { ... state ... }
+        instance = self.make_python_instance(suffix, node, newobj=True)
+        yield instance
+        deep = hasattr(instance, '__setstate__')
+        state = self.construct_mapping(node, deep=deep)
+        self.set_python_instance_state(instance, state)
+
+    def construct_python_object_apply(self, suffix, node, newobj=False):
+        # Format:
+        #   !!python/object/apply       # (or !!python/object/new)
+        #   args: [ ... arguments ... ]
+        #   kwds: { ... keywords ... }
+        #   state: ... state ...
+        #   listitems: [ ... listitems ... ]
+        #   dictitems: { ... dictitems ... }
+        # or short format:
+        #   !!python/object/apply [ ... arguments ... ]
+        # The difference between !!python/object/apply and !!python/object/new
+        # is how an object is created, check make_python_instance for details.
+        if isinstance(node, SequenceNode):
+            args = self.construct_sequence(node, deep=True)
+            kwds = {}
+            state = {}
+            listitems = []
+            dictitems = {}
+        else:
+            value = self.construct_mapping(node, deep=True)
+            args = value.get('args', [])
+            kwds = value.get('kwds', {})
+            state = value.get('state', {})
+            listitems = value.get('listitems', [])
+            dictitems = value.get('dictitems', {})
+        instance = self.make_python_instance(suffix, node, args, kwds, newobj)
+        if state:
+            self.set_python_instance_state(instance, state)
+        if listitems:
+            instance.extend(listitems)
+        if dictitems:
+            for key in dictitems:
+                instance[key] = dictitems[key]
+        return instance
+
+    def construct_python_object_new(self, suffix, node):
+        return self.construct_python_object_apply(suffix, node, newobj=True)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/none',
+    FullConstructor.construct_yaml_null)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/bool',
+    FullConstructor.construct_yaml_bool)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/str',
+    FullConstructor.construct_python_str)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/unicode',
+    FullConstructor.construct_python_unicode)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/bytes',
+    FullConstructor.construct_python_bytes)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/int',
+    FullConstructor.construct_yaml_int)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/long',
+    FullConstructor.construct_python_long)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/float',
+    FullConstructor.construct_yaml_float)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/complex',
+    FullConstructor.construct_python_complex)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/list',
+    FullConstructor.construct_yaml_seq)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/tuple',
+    FullConstructor.construct_python_tuple)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/dict',
+    FullConstructor.construct_yaml_map)
+
+FullConstructor.add_multi_constructor(
+    'tag:yaml.org,2002:python/name:',
+    FullConstructor.construct_python_name)
+
+class UnsafeConstructor(FullConstructor):
+
+    def find_python_module(self, name, mark):
+        return super(UnsafeConstructor, self).find_python_module(name, mark, unsafe=True)
+
+    def find_python_name(self, name, mark):
+        return super(UnsafeConstructor, self).find_python_name(name, mark, unsafe=True)
+
+    def make_python_instance(self, suffix, node, args=None, kwds=None, newobj=False):
+        return super(UnsafeConstructor, self).make_python_instance(
+            suffix, node, args, kwds, newobj, unsafe=True)
+
+    def set_python_instance_state(self, instance, state):
+        return super(UnsafeConstructor, self).set_python_instance_state(
+            instance, state, unsafe=True)
+
+UnsafeConstructor.add_multi_constructor(
+    'tag:yaml.org,2002:python/module:',
+    UnsafeConstructor.construct_python_module)
+
+UnsafeConstructor.add_multi_constructor(
+    'tag:yaml.org,2002:python/object:',
+    UnsafeConstructor.construct_python_object)
+
+UnsafeConstructor.add_multi_constructor(
+    'tag:yaml.org,2002:python/object/new:',
+    UnsafeConstructor.construct_python_object_new)
+
+UnsafeConstructor.add_multi_constructor(
+    'tag:yaml.org,2002:python/object/apply:',
+    UnsafeConstructor.construct_python_object_apply)
+
+# Constructor is same as UnsafeConstructor. Need to leave this in place in case
+# people have extended it directly.
+class Constructor(UnsafeConstructor):
+    pass
diff --git a/myenv/lib/python3.9/site-packages/yaml/cyaml.py b/myenv/lib/python3.9/site-packages/yaml/cyaml.py
new file mode 100644
index 0000000..0c21345
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/cyaml.py
@@ -0,0 +1,101 @@
+
+__all__ = [
+    'CBaseLoader', 'CSafeLoader', 'CFullLoader', 'CUnsafeLoader', 'CLoader',
+    'CBaseDumper', 'CSafeDumper', 'CDumper'
+]
+
+from yaml._yaml import CParser, CEmitter
+
+from .constructor import *
+
+from .serializer import *
+from .representer import *
+
+from .resolver import *
+
+class CBaseLoader(CParser, BaseConstructor, BaseResolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        BaseConstructor.__init__(self)
+        BaseResolver.__init__(self)
+
+class CSafeLoader(CParser, SafeConstructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        SafeConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class CFullLoader(CParser, FullConstructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        FullConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class CUnsafeLoader(CParser, UnsafeConstructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        UnsafeConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class CLoader(CParser, Constructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        Constructor.__init__(self)
+        Resolver.__init__(self)
+
+class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+
+class CSafeDumper(CEmitter, SafeRepresenter, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        SafeRepresenter.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+
+class CDumper(CEmitter, Serializer, Representer, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+
diff --git a/myenv/lib/python3.9/site-packages/yaml/dumper.py b/myenv/lib/python3.9/site-packages/yaml/dumper.py
new file mode 100644
index 0000000..6aadba5
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/dumper.py
@@ -0,0 +1,62 @@
+
+__all__ = ['BaseDumper', 'SafeDumper', 'Dumper']
+
+from .emitter import *
+from .serializer import *
+from .representer import *
+from .resolver import *
+
+class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+
+class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        SafeRepresenter.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+
+class Dumper(Emitter, Serializer, Representer, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+
diff --git a/myenv/lib/python3.9/site-packages/yaml/emitter.py b/myenv/lib/python3.9/site-packages/yaml/emitter.py
new file mode 100644
index 0000000..a664d01
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/emitter.py
@@ -0,0 +1,1137 @@
+
+# Emitter expects events obeying the following grammar:
+# stream ::= STREAM-START document* STREAM-END
+# document ::= DOCUMENT-START node DOCUMENT-END
+# node ::= SCALAR | sequence | mapping
+# sequence ::= SEQUENCE-START node* SEQUENCE-END
+# mapping ::= MAPPING-START (node node)* MAPPING-END
+
+__all__ = ['Emitter', 'EmitterError']
+
+from .error import YAMLError
+from .events import *
+
+class EmitterError(YAMLError):
+    pass
+
+class ScalarAnalysis:
+    def __init__(self, scalar, empty, multiline,
+            allow_flow_plain, allow_block_plain,
+            allow_single_quoted, allow_double_quoted,
+            allow_block):
+        self.scalar = scalar
+        self.empty = empty
+        self.multiline = multiline
+        self.allow_flow_plain = allow_flow_plain
+        self.allow_block_plain = allow_block_plain
+        self.allow_single_quoted = allow_single_quoted
+        self.allow_double_quoted = allow_double_quoted
+        self.allow_block = allow_block
+
+class Emitter:
+
+    DEFAULT_TAG_PREFIXES = {
+        '!' : '!',
+        'tag:yaml.org,2002:' : '!!',
+    }
+
+    def __init__(self, stream, canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None):
+
+        # The stream should have the methods `write` and possibly `flush`.
+        self.stream = stream
+
+        # Encoding can be overridden by STREAM-START.
+        self.encoding = None
+
+        # Emitter is a state machine with a stack of states to handle nested
+        # structures.
+        self.states = []
+        self.state = self.expect_stream_start
+
+        # Current event and the event queue.
+        self.events = []
+        self.event = None
+
+        # The current indentation level and the stack of previous indents.
+        self.indents = []
+        self.indent = None
+
+        # Flow level.
+        self.flow_level = 0
+
+        # Contexts.
+        self.root_context = False
+        self.sequence_context = False
+        self.mapping_context = False
+        self.simple_key_context = False
+
+        # Characteristics of the last emitted character:
+        #  - current position.
+        #  - is it a whitespace?
+        #  - is it an indention character
+        #    (indentation space, '-', '?', or ':')?
+        self.line = 0
+        self.column = 0
+        self.whitespace = True
+        self.indention = True
+
+        # Whether the document requires an explicit document indicator
+        self.open_ended = False
+
+        # Formatting details.
+        self.canonical = canonical
+        self.allow_unicode = allow_unicode
+        self.best_indent = 2
+        if indent and 1 < indent < 10:
+            self.best_indent = indent
+        self.best_width = 80
+        if width and width > self.best_indent*2:
+            self.best_width = width
+        self.best_line_break = '\n'
+        if line_break in ['\r', '\n', '\r\n']:
+            self.best_line_break = line_break
+
+        # Tag prefixes.
+        self.tag_prefixes = None
+
+        # Prepared anchor and tag.
+        self.prepared_anchor = None
+        self.prepared_tag = None
+
+        # Scalar analysis and style.
+        self.analysis = None
+        self.style = None
+
+    def dispose(self):
+        # Reset the state attributes (to clear self-references)
+        self.states = []
+        self.state = None
+
+    def emit(self, event):
+        self.events.append(event)
+        while not self.need_more_events():
+            self.event = self.events.pop(0)
+            self.state()
+            self.event = None
+
+    # In some cases, we wait for a few next events before emitting.
+
+    def need_more_events(self):
+        if not self.events:
+            return True
+        event = self.events[0]
+        if isinstance(event, DocumentStartEvent):
+            return self.need_events(1)
+        elif isinstance(event, SequenceStartEvent):
+            return self.need_events(2)
+        elif isinstance(event, MappingStartEvent):
+            return self.need_events(3)
+        else:
+            return False
+
+    def need_events(self, count):
+        level = 0
+        for event in self.events[1:]:
+            if isinstance(event, (DocumentStartEvent, CollectionStartEvent)):
+                level += 1
+            elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)):
+                level -= 1
+            elif isinstance(event, StreamEndEvent):
+                level = -1
+            if level < 0:
+                return False
+        return (len(self.events) < count+1)
+
+    def increase_indent(self, flow=False, indentless=False):
+        self.indents.append(self.indent)
+        if self.indent is None:
+            if flow:
+                self.indent = self.best_indent
+            else:
+                self.indent = 0
+        elif not indentless:
+            self.indent += self.best_indent
+
+    # States.
+
+    # Stream handlers.
+
+    def expect_stream_start(self):
+        if isinstance(self.event, StreamStartEvent):
+            if self.event.encoding and not hasattr(self.stream, 'encoding'):
+                self.encoding = self.event.encoding
+            self.write_stream_start()
+            self.state = self.expect_first_document_start
+        else:
+            raise EmitterError("expected StreamStartEvent, but got %s"
+                    % self.event)
+
+    def expect_nothing(self):
+        raise EmitterError("expected nothing, but got %s" % self.event)
+
+    # Document handlers.
+
+    def expect_first_document_start(self):
+        return self.expect_document_start(first=True)
+
+    def expect_document_start(self, first=False):
+        if isinstance(self.event, DocumentStartEvent):
+            if (self.event.version or self.event.tags) and self.open_ended:
+                self.write_indicator('...', True)
+                self.write_indent()
+            if self.event.version:
+                version_text = self.prepare_version(self.event.version)
+                self.write_version_directive(version_text)
+            self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy()
+            if self.event.tags:
+                handles = sorted(self.event.tags.keys())
+                for handle in handles:
+                    prefix = self.event.tags[handle]
+                    self.tag_prefixes[prefix] = handle
+                    handle_text = self.prepare_tag_handle(handle)
+                    prefix_text = self.prepare_tag_prefix(prefix)
+                    self.write_tag_directive(handle_text, prefix_text)
+            implicit = (first and not self.event.explicit and not self.canonical
+                    and not self.event.version and not self.event.tags
+                    and not self.check_empty_document())
+            if not implicit:
+                self.write_indent()
+                self.write_indicator('---', True)
+                if self.canonical:
+                    self.write_indent()
+            self.state = self.expect_document_root
+        elif isinstance(self.event, StreamEndEvent):
+            if self.open_ended:
+                self.write_indicator('...', True)
+                self.write_indent()
+            self.write_stream_end()
+            self.state = self.expect_nothing
+        else:
+            raise EmitterError("expected DocumentStartEvent, but got %s"
+                    % self.event)
+
+    def expect_document_end(self):
+        if isinstance(self.event, DocumentEndEvent):
+            self.write_indent()
+            if self.event.explicit:
+                self.write_indicator('...', True)
+                self.write_indent()
+            self.flush_stream()
+            self.state = self.expect_document_start
+        else:
+            raise EmitterError("expected DocumentEndEvent, but got %s"
+                    % self.event)
+
+    def expect_document_root(self):
+        self.states.append(self.expect_document_end)
+        self.expect_node(root=True)
+
+    # Node handlers.
+
+    def expect_node(self, root=False, sequence=False, mapping=False,
+            simple_key=False):
+        self.root_context = root
+        self.sequence_context = sequence
+        self.mapping_context = mapping
+        self.simple_key_context = simple_key
+        if isinstance(self.event, AliasEvent):
+            self.expect_alias()
+        elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)):
+            self.process_anchor('&')
+            self.process_tag()
+            if isinstance(self.event, ScalarEvent):
+                self.expect_scalar()
+            elif isinstance(self.event, SequenceStartEvent):
+                if self.flow_level or self.canonical or self.event.flow_style   \
+                        or self.check_empty_sequence():
+                    self.expect_flow_sequence()
+                else:
+                    self.expect_block_sequence()
+            elif isinstance(self.event, MappingStartEvent):
+                if self.flow_level or self.canonical or self.event.flow_style   \
+                        or self.check_empty_mapping():
+                    self.expect_flow_mapping()
+                else:
+                    self.expect_block_mapping()
+        else:
+            raise EmitterError("expected NodeEvent, but got %s" % self.event)
+
+    def expect_alias(self):
+        if self.event.anchor is None:
+            raise EmitterError("anchor is not specified for alias")
+        self.process_anchor('*')
+        self.state = self.states.pop()
+
+    def expect_scalar(self):
+        self.increase_indent(flow=True)
+        self.process_scalar()
+        self.indent = self.indents.pop()
+        self.state = self.states.pop()
+
+    # Flow sequence handlers.
+
+    def expect_flow_sequence(self):
+        self.write_indicator('[', True, whitespace=True)
+        self.flow_level += 1
+        self.increase_indent(flow=True)
+        self.state = self.expect_first_flow_sequence_item
+
+    def expect_first_flow_sequence_item(self):
+        if isinstance(self.event, SequenceEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            self.write_indicator(']', False)
+            self.state = self.states.pop()
+        else:
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            self.states.append(self.expect_flow_sequence_item)
+            self.expect_node(sequence=True)
+
+    def expect_flow_sequence_item(self):
+        if isinstance(self.event, SequenceEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            if self.canonical:
+                self.write_indicator(',', False)
+                self.write_indent()
+            self.write_indicator(']', False)
+            self.state = self.states.pop()
+        else:
+            self.write_indicator(',', False)
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            self.states.append(self.expect_flow_sequence_item)
+            self.expect_node(sequence=True)
+
+    # Flow mapping handlers.
+
+    def expect_flow_mapping(self):
+        self.write_indicator('{', True, whitespace=True)
+        self.flow_level += 1
+        self.increase_indent(flow=True)
+        self.state = self.expect_first_flow_mapping_key
+
+    def expect_first_flow_mapping_key(self):
+        if isinstance(self.event, MappingEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            self.write_indicator('}', False)
+            self.state = self.states.pop()
+        else:
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            if not self.canonical and self.check_simple_key():
+                self.states.append(self.expect_flow_mapping_simple_value)
+                self.expect_node(mapping=True, simple_key=True)
+            else:
+                self.write_indicator('?', True)
+                self.states.append(self.expect_flow_mapping_value)
+                self.expect_node(mapping=True)
+
+    def expect_flow_mapping_key(self):
+        if isinstance(self.event, MappingEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            if self.canonical:
+                self.write_indicator(',', False)
+                self.write_indent()
+            self.write_indicator('}', False)
+            self.state = self.states.pop()
+        else:
+            self.write_indicator(',', False)
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            if not self.canonical and self.check_simple_key():
+                self.states.append(self.expect_flow_mapping_simple_value)
+                self.expect_node(mapping=True, simple_key=True)
+            else:
+                self.write_indicator('?', True)
+                self.states.append(self.expect_flow_mapping_value)
+                self.expect_node(mapping=True)
+
+    def expect_flow_mapping_simple_value(self):
+        self.write_indicator(':', False)
+        self.states.append(self.expect_flow_mapping_key)
+        self.expect_node(mapping=True)
+
+    def expect_flow_mapping_value(self):
+        if self.canonical or self.column > self.best_width:
+            self.write_indent()
+        self.write_indicator(':', True)
+        self.states.append(self.expect_flow_mapping_key)
+        self.expect_node(mapping=True)
+
+    # Block sequence handlers.
+
+    def expect_block_sequence(self):
+        indentless = (self.mapping_context and not self.indention)
+        self.increase_indent(flow=False, indentless=indentless)
+        self.state = self.expect_first_block_sequence_item
+
+    def expect_first_block_sequence_item(self):
+        return self.expect_block_sequence_item(first=True)
+
+    def expect_block_sequence_item(self, first=False):
+        if not first and isinstance(self.event, SequenceEndEvent):
+            self.indent = self.indents.pop()
+            self.state = self.states.pop()
+        else:
+            self.write_indent()
+            self.write_indicator('-', True, indention=True)
+            self.states.append(self.expect_block_sequence_item)
+            self.expect_node(sequence=True)
+
+    # Block mapping handlers.
+
+    def expect_block_mapping(self):
+        self.increase_indent(flow=False)
+        self.state = self.expect_first_block_mapping_key
+
+    def expect_first_block_mapping_key(self):
+        return self.expect_block_mapping_key(first=True)
+
+    def expect_block_mapping_key(self, first=False):
+        if not first and isinstance(self.event, MappingEndEvent):
+            self.indent = self.indents.pop()
+            self.state = self.states.pop()
+        else:
+            self.write_indent()
+            if self.check_simple_key():
+                self.states.append(self.expect_block_mapping_simple_value)
+                self.expect_node(mapping=True, simple_key=True)
+            else:
+                self.write_indicator('?', True, indention=True)
+                self.states.append(self.expect_block_mapping_value)
+                self.expect_node(mapping=True)
+
+    def expect_block_mapping_simple_value(self):
+        self.write_indicator(':', False)
+        self.states.append(self.expect_block_mapping_key)
+        self.expect_node(mapping=True)
+
+    def expect_block_mapping_value(self):
+        self.write_indent()
+        self.write_indicator(':', True, indention=True)
+        self.states.append(self.expect_block_mapping_key)
+        self.expect_node(mapping=True)
+
+    # Checkers.
+
+    def check_empty_sequence(self):
+        return (isinstance(self.event, SequenceStartEvent) and self.events
+                and isinstance(self.events[0], SequenceEndEvent))
+
+    def check_empty_mapping(self):
+        return (isinstance(self.event, MappingStartEvent) and self.events
+                and isinstance(self.events[0], MappingEndEvent))
+
+    def check_empty_document(self):
+        if not isinstance(self.event, DocumentStartEvent) or not self.events:
+            return False
+        event = self.events[0]
+        return (isinstance(event, ScalarEvent) and event.anchor is None
+                and event.tag is None and event.implicit and event.value == '')
+
+    def check_simple_key(self):
+        length = 0
+        if isinstance(self.event, NodeEvent) and self.event.anchor is not None:
+            if self.prepared_anchor is None:
+                self.prepared_anchor = self.prepare_anchor(self.event.anchor)
+            length += len(self.prepared_anchor)
+        if isinstance(self.event, (ScalarEvent, CollectionStartEvent))  \
+                and self.event.tag is not None:
+            if self.prepared_tag is None:
+                self.prepared_tag = self.prepare_tag(self.event.tag)
+            length += len(self.prepared_tag)
+        if isinstance(self.event, ScalarEvent):
+            if self.analysis is None:
+                self.analysis = self.analyze_scalar(self.event.value)
+            length += len(self.analysis.scalar)
+        return (length < 128 and (isinstance(self.event, AliasEvent)
+            or (isinstance(self.event, ScalarEvent)
+                    and not self.analysis.empty and not self.analysis.multiline)
+            or self.check_empty_sequence() or self.check_empty_mapping()))
+
+    # Anchor, Tag, and Scalar processors.
+
+    def process_anchor(self, indicator):
+        if self.event.anchor is None:
+            self.prepared_anchor = None
+            return
+        if self.prepared_anchor is None:
+            self.prepared_anchor = self.prepare_anchor(self.event.anchor)
+        if self.prepared_anchor:
+            self.write_indicator(indicator+self.prepared_anchor, True)
+        self.prepared_anchor = None
+
+    def process_tag(self):
+        tag = self.event.tag
+        if isinstance(self.event, ScalarEvent):
+            if self.style is None:
+                self.style = self.choose_scalar_style()
+            if ((not self.canonical or tag is None) and
+                ((self.style == '' and self.event.implicit[0])
+                        or (self.style != '' and self.event.implicit[1]))):
+                self.prepared_tag = None
+                return
+            if self.event.implicit[0] and tag is None:
+                tag = '!'
+                self.prepared_tag = None
+        else:
+            if (not self.canonical or tag is None) and self.event.implicit:
+                self.prepared_tag = None
+                return
+        if tag is None:
+            raise EmitterError("tag is not specified")
+        if self.prepared_tag is None:
+            self.prepared_tag = self.prepare_tag(tag)
+        if self.prepared_tag:
+            self.write_indicator(self.prepared_tag, True)
+        self.prepared_tag = None
+
+    def choose_scalar_style(self):
+        if self.analysis is None:
+            self.analysis = self.analyze_scalar(self.event.value)
+        if self.event.style == '"' or self.canonical:
+            return '"'
+        if not self.event.style and self.event.implicit[0]:
+            if (not (self.simple_key_context and
+                    (self.analysis.empty or self.analysis.multiline))
+                and (self.flow_level and self.analysis.allow_flow_plain
+                    or (not self.flow_level and self.analysis.allow_block_plain))):
+                return ''
+        if self.event.style and self.event.style in '|>':
+            if (not self.flow_level and not self.simple_key_context
+                    and self.analysis.allow_block):
+                return self.event.style
+        if not self.event.style or self.event.style == '\'':
+            if (self.analysis.allow_single_quoted and
+                    not (self.simple_key_context and self.analysis.multiline)):
+                return '\''
+        return '"'
+
+    def process_scalar(self):
+        if self.analysis is None:
+            self.analysis = self.analyze_scalar(self.event.value)
+        if self.style is None:
+            self.style = self.choose_scalar_style()
+        split = (not self.simple_key_context)
+        #if self.analysis.multiline and split    \
+        #        and (not self.style or self.style in '\'\"'):
+        #    self.write_indent()
+        if self.style == '"':
+            self.write_double_quoted(self.analysis.scalar, split)
+        elif self.style == '\'':
+            self.write_single_quoted(self.analysis.scalar, split)
+        elif self.style == '>':
+            self.write_folded(self.analysis.scalar)
+        elif self.style == '|':
+            self.write_literal(self.analysis.scalar)
+        else:
+            self.write_plain(self.analysis.scalar, split)
+        self.analysis = None
+        self.style = None
+
+    # Analyzers.
+
+    def prepare_version(self, version):
+        major, minor = version
+        if major != 1:
+            raise EmitterError("unsupported YAML version: %d.%d" % (major, minor))
+        return '%d.%d' % (major, minor)
+
+    def prepare_tag_handle(self, handle):
+        if not handle:
+            raise EmitterError("tag handle must not be empty")
+        if handle[0] != '!' or handle[-1] != '!':
+            raise EmitterError("tag handle must start and end with '!': %r" % handle)
+        for ch in handle[1:-1]:
+            if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'    \
+                    or ch in '-_'):
+                raise EmitterError("invalid character %r in the tag handle: %r"
+                        % (ch, handle))
+        return handle
+
+    def prepare_tag_prefix(self, prefix):
+        if not prefix:
+            raise EmitterError("tag prefix must not be empty")
+        chunks = []
+        start = end = 0
+        if prefix[0] == '!':
+            end = 1
+        while end < len(prefix):
+            ch = prefix[end]
+            if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+                    or ch in '-;/?!:@&=+$,_.~*\'()[]':
+                end += 1
+            else:
+                if start < end:
+                    chunks.append(prefix[start:end])
+                start = end = end+1
+                data = ch.encode('utf-8')
+                for ch in data:
+                    chunks.append('%%%02X' % ord(ch))
+        if start < end:
+            chunks.append(prefix[start:end])
+        return ''.join(chunks)
+
+    def prepare_tag(self, tag):
+        if not tag:
+            raise EmitterError("tag must not be empty")
+        if tag == '!':
+            return tag
+        handle = None
+        suffix = tag
+        prefixes = sorted(self.tag_prefixes.keys())
+        for prefix in prefixes:
+            if tag.startswith(prefix)   \
+                    and (prefix == '!' or len(prefix) < len(tag)):
+                handle = self.tag_prefixes[prefix]
+                suffix = tag[len(prefix):]
+        chunks = []
+        start = end = 0
+        while end < len(suffix):
+            ch = suffix[end]
+            if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+                    or ch in '-;/?:@&=+$,_.~*\'()[]'   \
+                    or (ch == '!' and handle != '!'):
+                end += 1
+            else:
+                if start < end:
+                    chunks.append(suffix[start:end])
+                start = end = end+1
+                data = ch.encode('utf-8')
+                for ch in data:
+                    chunks.append('%%%02X' % ch)
+        if start < end:
+            chunks.append(suffix[start:end])
+        suffix_text = ''.join(chunks)
+        if handle:
+            return '%s%s' % (handle, suffix_text)
+        else:
+            return '!<%s>' % suffix_text
+
+    def prepare_anchor(self, anchor):
+        if not anchor:
+            raise EmitterError("anchor must not be empty")
+        for ch in anchor:
+            if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'    \
+                    or ch in '-_'):
+                raise EmitterError("invalid character %r in the anchor: %r"
+                        % (ch, anchor))
+        return anchor
+
+    def analyze_scalar(self, scalar):
+
+        # Empty scalar is a special case.
+        if not scalar:
+            return ScalarAnalysis(scalar=scalar, empty=True, multiline=False,
+                    allow_flow_plain=False, allow_block_plain=True,
+                    allow_single_quoted=True, allow_double_quoted=True,
+                    allow_block=False)
+
+        # Indicators and special characters.
+        block_indicators = False
+        flow_indicators = False
+        line_breaks = False
+        special_characters = False
+
+        # Important whitespace combinations.
+        leading_space = False
+        leading_break = False
+        trailing_space = False
+        trailing_break = False
+        break_space = False
+        space_break = False
+
+        # Check document indicators.
+        if scalar.startswith('---') or scalar.startswith('...'):
+            block_indicators = True
+            flow_indicators = True
+
+        # First character or preceded by a whitespace.
+        preceded_by_whitespace = True
+
+        # Last character or followed by a whitespace.
+        followed_by_whitespace = (len(scalar) == 1 or
+                scalar[1] in '\0 \t\r\n\x85\u2028\u2029')
+
+        # The previous character is a space.
+        previous_space = False
+
+        # The previous character is a break.
+        previous_break = False
+
+        index = 0
+        while index < len(scalar):
+            ch = scalar[index]
+
+            # Check for indicators.
+            if index == 0:
+                # Leading indicators are special characters.
+                if ch in '#,[]{}&*!|>\'\"%@`':
+                    flow_indicators = True
+                    block_indicators = True
+                if ch in '?:':
+                    flow_indicators = True
+                    if followed_by_whitespace:
+                        block_indicators = True
+                if ch == '-' and followed_by_whitespace:
+                    flow_indicators = True
+                    block_indicators = True
+            else:
+                # Some indicators cannot appear within a scalar as well.
+                if ch in ',?[]{}':
+                    flow_indicators = True
+                if ch == ':':
+                    flow_indicators = True
+                    if followed_by_whitespace:
+                        block_indicators = True
+                if ch == '#' and preceded_by_whitespace:
+                    flow_indicators = True
+                    block_indicators = True
+
+            # Check for line breaks, special, and unicode characters.
+            if ch in '\n\x85\u2028\u2029':
+                line_breaks = True
+            if not (ch == '\n' or '\x20' <= ch <= '\x7E'):
+                if (ch == '\x85' or '\xA0' <= ch <= '\uD7FF'
+                        or '\uE000' <= ch <= '\uFFFD'
+                        or '\U00010000' <= ch < '\U0010ffff') and ch != '\uFEFF':
+                    unicode_characters = True
+                    if not self.allow_unicode:
+                        special_characters = True
+                else:
+                    special_characters = True
+
+            # Detect important whitespace combinations.
+            if ch == ' ':
+                if index == 0:
+                    leading_space = True
+                if index == len(scalar)-1:
+                    trailing_space = True
+                if previous_break:
+                    break_space = True
+                previous_space = True
+                previous_break = False
+            elif ch in '\n\x85\u2028\u2029':
+                if index == 0:
+                    leading_break = True
+                if index == len(scalar)-1:
+                    trailing_break = True
+                if previous_space:
+                    space_break = True
+                previous_space = False
+                previous_break = True
+            else:
+                previous_space = False
+                previous_break = False
+
+            # Prepare for the next character.
+            index += 1
+            preceded_by_whitespace = (ch in '\0 \t\r\n\x85\u2028\u2029')
+            followed_by_whitespace = (index+1 >= len(scalar) or
+                    scalar[index+1] in '\0 \t\r\n\x85\u2028\u2029')
+
+        # Let's decide what styles are allowed.
+        allow_flow_plain = True
+        allow_block_plain = True
+        allow_single_quoted = True
+        allow_double_quoted = True
+        allow_block = True
+
+        # Leading and trailing whitespaces are bad for plain scalars.
+        if (leading_space or leading_break
+                or trailing_space or trailing_break):
+            allow_flow_plain = allow_block_plain = False
+
+        # We do not permit trailing spaces for block scalars.
+        if trailing_space:
+            allow_block = False
+
+        # Spaces at the beginning of a new line are only acceptable for block
+        # scalars.
+        if break_space:
+            allow_flow_plain = allow_block_plain = allow_single_quoted = False
+
+        # Spaces followed by breaks, as well as special character are only
+        # allowed for double quoted scalars.
+        if space_break or special_characters:
+            allow_flow_plain = allow_block_plain =  \
+            allow_single_quoted = allow_block = False
+
+        # Although the plain scalar writer supports breaks, we never emit
+        # multiline plain scalars.
+        if line_breaks:
+            allow_flow_plain = allow_block_plain = False
+
+        # Flow indicators are forbidden for flow plain scalars.
+        if flow_indicators:
+            allow_flow_plain = False
+
+        # Block indicators are forbidden for block plain scalars.
+        if block_indicators:
+            allow_block_plain = False
+
+        return ScalarAnalysis(scalar=scalar,
+                empty=False, multiline=line_breaks,
+                allow_flow_plain=allow_flow_plain,
+                allow_block_plain=allow_block_plain,
+                allow_single_quoted=allow_single_quoted,
+                allow_double_quoted=allow_double_quoted,
+                allow_block=allow_block)
+
+    # Writers.
+
+    def flush_stream(self):
+        if hasattr(self.stream, 'flush'):
+            self.stream.flush()
+
+    def write_stream_start(self):
+        # Write BOM if needed.
+        if self.encoding and self.encoding.startswith('utf-16'):
+            self.stream.write('\uFEFF'.encode(self.encoding))
+
+    def write_stream_end(self):
+        self.flush_stream()
+
+    def write_indicator(self, indicator, need_whitespace,
+            whitespace=False, indention=False):
+        if self.whitespace or not need_whitespace:
+            data = indicator
+        else:
+            data = ' '+indicator
+        self.whitespace = whitespace
+        self.indention = self.indention and indention
+        self.column += len(data)
+        self.open_ended = False
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+
+    def write_indent(self):
+        indent = self.indent or 0
+        if not self.indention or self.column > indent   \
+                or (self.column == indent and not self.whitespace):
+            self.write_line_break()
+        if self.column < indent:
+            self.whitespace = True
+            data = ' '*(indent-self.column)
+            self.column = indent
+            if self.encoding:
+                data = data.encode(self.encoding)
+            self.stream.write(data)
+
+    def write_line_break(self, data=None):
+        if data is None:
+            data = self.best_line_break
+        self.whitespace = True
+        self.indention = True
+        self.line += 1
+        self.column = 0
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+
+    def write_version_directive(self, version_text):
+        data = '%%YAML %s' % version_text
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+        self.write_line_break()
+
+    def write_tag_directive(self, handle_text, prefix_text):
+        data = '%%TAG %s %s' % (handle_text, prefix_text)
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+        self.write_line_break()
+
+    # Scalar streams.
+
+    def write_single_quoted(self, text, split=True):
+        self.write_indicator('\'', True)
+        spaces = False
+        breaks = False
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if spaces:
+                if ch is None or ch != ' ':
+                    if start+1 == end and self.column > self.best_width and split   \
+                            and start != 0 and end != len(text):
+                        self.write_indent()
+                    else:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                    start = end
+            elif breaks:
+                if ch is None or ch not in '\n\x85\u2028\u2029':
+                    if text[start] == '\n':
+                        self.write_line_break()
+                    for br in text[start:end]:
+                        if br == '\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    self.write_indent()
+                    start = end
+            else:
+                if ch is None or ch in ' \n\x85\u2028\u2029' or ch == '\'':
+                    if start < end:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                        start = end
+            if ch == '\'':
+                data = '\'\''
+                self.column += 2
+                if self.encoding:
+                    data = data.encode(self.encoding)
+                self.stream.write(data)
+                start = end + 1
+            if ch is not None:
+                spaces = (ch == ' ')
+                breaks = (ch in '\n\x85\u2028\u2029')
+            end += 1
+        self.write_indicator('\'', False)
+
+    ESCAPE_REPLACEMENTS = {
+        '\0':       '0',
+        '\x07':     'a',
+        '\x08':     'b',
+        '\x09':     't',
+        '\x0A':     'n',
+        '\x0B':     'v',
+        '\x0C':     'f',
+        '\x0D':     'r',
+        '\x1B':     'e',
+        '\"':       '\"',
+        '\\':       '\\',
+        '\x85':     'N',
+        '\xA0':     '_',
+        '\u2028':   'L',
+        '\u2029':   'P',
+    }
+
+    def write_double_quoted(self, text, split=True):
+        self.write_indicator('"', True)
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if ch is None or ch in '"\\\x85\u2028\u2029\uFEFF' \
+                    or not ('\x20' <= ch <= '\x7E'
+                        or (self.allow_unicode
+                            and ('\xA0' <= ch <= '\uD7FF'
+                                or '\uE000' <= ch <= '\uFFFD'))):
+                if start < end:
+                    data = text[start:end]
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    start = end
+                if ch is not None:
+                    if ch in self.ESCAPE_REPLACEMENTS:
+                        data = '\\'+self.ESCAPE_REPLACEMENTS[ch]
+                    elif ch <= '\xFF':
+                        data = '\\x%02X' % ord(ch)
+                    elif ch <= '\uFFFF':
+                        data = '\\u%04X' % ord(ch)
+                    else:
+                        data = '\\U%08X' % ord(ch)
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    start = end+1
+            if 0 < end < len(text)-1 and (ch == ' ' or start >= end)    \
+                    and self.column+(end-start) > self.best_width and split:
+                data = text[start:end]+'\\'
+                if start < end:
+                    start = end
+                self.column += len(data)
+                if self.encoding:
+                    data = data.encode(self.encoding)
+                self.stream.write(data)
+                self.write_indent()
+                self.whitespace = False
+                self.indention = False
+                if text[start] == ' ':
+                    data = '\\'
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+            end += 1
+        self.write_indicator('"', False)
+
+    def determine_block_hints(self, text):
+        hints = ''
+        if text:
+            if text[0] in ' \n\x85\u2028\u2029':
+                hints += str(self.best_indent)
+            if text[-1] not in '\n\x85\u2028\u2029':
+                hints += '-'
+            elif len(text) == 1 or text[-2] in '\n\x85\u2028\u2029':
+                hints += '+'
+        return hints
+
+    def write_folded(self, text):
+        hints = self.determine_block_hints(text)
+        self.write_indicator('>'+hints, True)
+        if hints[-1:] == '+':
+            self.open_ended = True
+        self.write_line_break()
+        leading_space = True
+        spaces = False
+        breaks = True
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if breaks:
+                if ch is None or ch not in '\n\x85\u2028\u2029':
+                    if not leading_space and ch is not None and ch != ' '   \
+                            and text[start] == '\n':
+                        self.write_line_break()
+                    leading_space = (ch == ' ')
+                    for br in text[start:end]:
+                        if br == '\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    if ch is not None:
+                        self.write_indent()
+                    start = end
+            elif spaces:
+                if ch != ' ':
+                    if start+1 == end and self.column > self.best_width:
+                        self.write_indent()
+                    else:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                    start = end
+            else:
+                if ch is None or ch in ' \n\x85\u2028\u2029':
+                    data = text[start:end]
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    if ch is None:
+                        self.write_line_break()
+                    start = end
+            if ch is not None:
+                breaks = (ch in '\n\x85\u2028\u2029')
+                spaces = (ch == ' ')
+            end += 1
+
+    def write_literal(self, text):
+        hints = self.determine_block_hints(text)
+        self.write_indicator('|'+hints, True)
+        if hints[-1:] == '+':
+            self.open_ended = True
+        self.write_line_break()
+        breaks = True
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if breaks:
+                if ch is None or ch not in '\n\x85\u2028\u2029':
+                    for br in text[start:end]:
+                        if br == '\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    if ch is not None:
+                        self.write_indent()
+                    start = end
+            else:
+                if ch is None or ch in '\n\x85\u2028\u2029':
+                    data = text[start:end]
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    if ch is None:
+                        self.write_line_break()
+                    start = end
+            if ch is not None:
+                breaks = (ch in '\n\x85\u2028\u2029')
+            end += 1
+
+    def write_plain(self, text, split=True):
+        if self.root_context:
+            self.open_ended = True
+        if not text:
+            return
+        if not self.whitespace:
+            data = ' '
+            self.column += len(data)
+            if self.encoding:
+                data = data.encode(self.encoding)
+            self.stream.write(data)
+        self.whitespace = False
+        self.indention = False
+        spaces = False
+        breaks = False
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if spaces:
+                if ch != ' ':
+                    if start+1 == end and self.column > self.best_width and split:
+                        self.write_indent()
+                        self.whitespace = False
+                        self.indention = False
+                    else:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                    start = end
+            elif breaks:
+                if ch not in '\n\x85\u2028\u2029':
+                    if text[start] == '\n':
+                        self.write_line_break()
+                    for br in text[start:end]:
+                        if br == '\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    self.write_indent()
+                    self.whitespace = False
+                    self.indention = False
+                    start = end
+            else:
+                if ch is None or ch in ' \n\x85\u2028\u2029':
+                    data = text[start:end]
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    start = end
+            if ch is not None:
+                spaces = (ch == ' ')
+                breaks = (ch in '\n\x85\u2028\u2029')
+            end += 1
diff --git a/myenv/lib/python3.9/site-packages/yaml/error.py b/myenv/lib/python3.9/site-packages/yaml/error.py
new file mode 100644
index 0000000..b796b4d
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/error.py
@@ -0,0 +1,75 @@
+
+__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError']
+
+class Mark:
+
+    def __init__(self, name, index, line, column, buffer, pointer):
+        self.name = name
+        self.index = index
+        self.line = line
+        self.column = column
+        self.buffer = buffer
+        self.pointer = pointer
+
+    def get_snippet(self, indent=4, max_length=75):
+        if self.buffer is None:
+            return None
+        head = ''
+        start = self.pointer
+        while start > 0 and self.buffer[start-1] not in '\0\r\n\x85\u2028\u2029':
+            start -= 1
+            if self.pointer-start > max_length/2-1:
+                head = ' ... '
+                start += 5
+                break
+        tail = ''
+        end = self.pointer
+        while end < len(self.buffer) and self.buffer[end] not in '\0\r\n\x85\u2028\u2029':
+            end += 1
+            if end-self.pointer > max_length/2-1:
+                tail = ' ... '
+                end -= 5
+                break
+        snippet = self.buffer[start:end]
+        return ' '*indent + head + snippet + tail + '\n'  \
+                + ' '*(indent+self.pointer-start+len(head)) + '^'
+
+    def __str__(self):
+        snippet = self.get_snippet()
+        where = "  in \"%s\", line %d, column %d"   \
+                % (self.name, self.line+1, self.column+1)
+        if snippet is not None:
+            where += ":\n"+snippet
+        return where
+
+class YAMLError(Exception):
+    pass
+
+class MarkedYAMLError(YAMLError):
+
+    def __init__(self, context=None, context_mark=None,
+            problem=None, problem_mark=None, note=None):
+        self.context = context
+        self.context_mark = context_mark
+        self.problem = problem
+        self.problem_mark = problem_mark
+        self.note = note
+
+    def __str__(self):
+        lines = []
+        if self.context is not None:
+            lines.append(self.context)
+        if self.context_mark is not None  \
+            and (self.problem is None or self.problem_mark is None
+                    or self.context_mark.name != self.problem_mark.name
+                    or self.context_mark.line != self.problem_mark.line
+                    or self.context_mark.column != self.problem_mark.column):
+            lines.append(str(self.context_mark))
+        if self.problem is not None:
+            lines.append(self.problem)
+        if self.problem_mark is not None:
+            lines.append(str(self.problem_mark))
+        if self.note is not None:
+            lines.append(self.note)
+        return '\n'.join(lines)
+
diff --git a/myenv/lib/python3.9/site-packages/yaml/events.py b/myenv/lib/python3.9/site-packages/yaml/events.py
new file mode 100644
index 0000000..f79ad38
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/events.py
@@ -0,0 +1,86 @@
+
+# Abstract classes.
+
+class Event(object):
+    def __init__(self, start_mark=None, end_mark=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+    def __repr__(self):
+        attributes = [key for key in ['anchor', 'tag', 'implicit', 'value']
+                if hasattr(self, key)]
+        arguments = ', '.join(['%s=%r' % (key, getattr(self, key))
+                for key in attributes])
+        return '%s(%s)' % (self.__class__.__name__, arguments)
+
+class NodeEvent(Event):
+    def __init__(self, anchor, start_mark=None, end_mark=None):
+        self.anchor = anchor
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class CollectionStartEvent(NodeEvent):
+    def __init__(self, anchor, tag, implicit, start_mark=None, end_mark=None,
+            flow_style=None):
+        self.anchor = anchor
+        self.tag = tag
+        self.implicit = implicit
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.flow_style = flow_style
+
+class CollectionEndEvent(Event):
+    pass
+
+# Implementations.
+
+class StreamStartEvent(Event):
+    def __init__(self, start_mark=None, end_mark=None, encoding=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.encoding = encoding
+
+class StreamEndEvent(Event):
+    pass
+
+class DocumentStartEvent(Event):
+    def __init__(self, start_mark=None, end_mark=None,
+            explicit=None, version=None, tags=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.explicit = explicit
+        self.version = version
+        self.tags = tags
+
+class DocumentEndEvent(Event):
+    def __init__(self, start_mark=None, end_mark=None,
+            explicit=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.explicit = explicit
+
+class AliasEvent(NodeEvent):
+    pass
+
+class ScalarEvent(NodeEvent):
+    def __init__(self, anchor, tag, implicit, value,
+            start_mark=None, end_mark=None, style=None):
+        self.anchor = anchor
+        self.tag = tag
+        self.implicit = implicit
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.style = style
+
+class SequenceStartEvent(CollectionStartEvent):
+    pass
+
+class SequenceEndEvent(CollectionEndEvent):
+    pass
+
+class MappingStartEvent(CollectionStartEvent):
+    pass
+
+class MappingEndEvent(CollectionEndEvent):
+    pass
+
diff --git a/myenv/lib/python3.9/site-packages/yaml/loader.py b/myenv/lib/python3.9/site-packages/yaml/loader.py
new file mode 100644
index 0000000..e90c112
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/loader.py
@@ -0,0 +1,63 @@
+
+__all__ = ['BaseLoader', 'FullLoader', 'SafeLoader', 'Loader', 'UnsafeLoader']
+
+from .reader import *
+from .scanner import *
+from .parser import *
+from .composer import *
+from .constructor import *
+from .resolver import *
+
+class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver):
+
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        BaseConstructor.__init__(self)
+        BaseResolver.__init__(self)
+
+class FullLoader(Reader, Scanner, Parser, Composer, FullConstructor, Resolver):
+
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        FullConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver):
+
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        SafeConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver):
+
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        Constructor.__init__(self)
+        Resolver.__init__(self)
+
+# UnsafeLoader is the same as Loader (which is and was always unsafe on
+# untrusted input). Use of either Loader or UnsafeLoader should be rare, since
+# FullLoad should be able to load almost all YAML safely. Loader is left intact
+# to ensure backwards compatibility.
+class UnsafeLoader(Reader, Scanner, Parser, Composer, Constructor, Resolver):
+
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        Constructor.__init__(self)
+        Resolver.__init__(self)
diff --git a/myenv/lib/python3.9/site-packages/yaml/nodes.py b/myenv/lib/python3.9/site-packages/yaml/nodes.py
new file mode 100644
index 0000000..c4f070c
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/nodes.py
@@ -0,0 +1,49 @@
+
+class Node(object):
+    def __init__(self, tag, value, start_mark, end_mark):
+        self.tag = tag
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+    def __repr__(self):
+        value = self.value
+        #if isinstance(value, list):
+        #    if len(value) == 0:
+        #        value = '<empty>'
+        #    elif len(value) == 1:
+        #        value = '<1 item>'
+        #    else:
+        #        value = '<%d items>' % len(value)
+        #else:
+        #    if len(value) > 75:
+        #        value = repr(value[:70]+u' ... ')
+        #    else:
+        #        value = repr(value)
+        value = repr(value)
+        return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value)
+
+class ScalarNode(Node):
+    id = 'scalar'
+    def __init__(self, tag, value,
+            start_mark=None, end_mark=None, style=None):
+        self.tag = tag
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.style = style
+
+class CollectionNode(Node):
+    def __init__(self, tag, value,
+            start_mark=None, end_mark=None, flow_style=None):
+        self.tag = tag
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.flow_style = flow_style
+
+class SequenceNode(CollectionNode):
+    id = 'sequence'
+
+class MappingNode(CollectionNode):
+    id = 'mapping'
+
diff --git a/myenv/lib/python3.9/site-packages/yaml/parser.py b/myenv/lib/python3.9/site-packages/yaml/parser.py
new file mode 100644
index 0000000..13a5995
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/parser.py
@@ -0,0 +1,589 @@
+
+# The following YAML grammar is LL(1) and is parsed by a recursive descent
+# parser.
+#
+# stream            ::= STREAM-START implicit_document? explicit_document* STREAM-END
+# implicit_document ::= block_node DOCUMENT-END*
+# explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+# block_node_or_indentless_sequence ::=
+#                       ALIAS
+#                       | properties (block_content | indentless_block_sequence)?
+#                       | block_content
+#                       | indentless_block_sequence
+# block_node        ::= ALIAS
+#                       | properties block_content?
+#                       | block_content
+# flow_node         ::= ALIAS
+#                       | properties flow_content?
+#                       | flow_content
+# properties        ::= TAG ANCHOR? | ANCHOR TAG?
+# block_content     ::= block_collection | flow_collection | SCALAR
+# flow_content      ::= flow_collection | SCALAR
+# block_collection  ::= block_sequence | block_mapping
+# flow_collection   ::= flow_sequence | flow_mapping
+# block_sequence    ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+# indentless_sequence   ::= (BLOCK-ENTRY block_node?)+
+# block_mapping     ::= BLOCK-MAPPING_START
+#                       ((KEY block_node_or_indentless_sequence?)?
+#                       (VALUE block_node_or_indentless_sequence?)?)*
+#                       BLOCK-END
+# flow_sequence     ::= FLOW-SEQUENCE-START
+#                       (flow_sequence_entry FLOW-ENTRY)*
+#                       flow_sequence_entry?
+#                       FLOW-SEQUENCE-END
+# flow_sequence_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+# flow_mapping      ::= FLOW-MAPPING-START
+#                       (flow_mapping_entry FLOW-ENTRY)*
+#                       flow_mapping_entry?
+#                       FLOW-MAPPING-END
+# flow_mapping_entry    ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+#
+# FIRST sets:
+#
+# stream: { STREAM-START }
+# explicit_document: { DIRECTIVE DOCUMENT-START }
+# implicit_document: FIRST(block_node)
+# block_node: { ALIAS TAG ANCHOR SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# flow_node: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# block_content: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR }
+# flow_content: { FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR }
+# block_collection: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START }
+# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# block_sequence: { BLOCK-SEQUENCE-START }
+# block_mapping: { BLOCK-MAPPING-START }
+# block_node_or_indentless_sequence: { ALIAS ANCHOR TAG SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START BLOCK-ENTRY }
+# indentless_sequence: { ENTRY }
+# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# flow_sequence: { FLOW-SEQUENCE-START }
+# flow_mapping: { FLOW-MAPPING-START }
+# flow_sequence_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY }
+# flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY }
+
+__all__ = ['Parser', 'ParserError']
+
+from .error import MarkedYAMLError
+from .tokens import *
+from .events import *
+from .scanner import *
+
+class ParserError(MarkedYAMLError):
+    pass
+
+class Parser:
+    # Since writing a recursive-descendant parser is a straightforward task, we
+    # do not give many comments here.
+
+    DEFAULT_TAGS = {
+        '!':   '!',
+        '!!':  'tag:yaml.org,2002:',
+    }
+
+    def __init__(self):
+        self.current_event = None
+        self.yaml_version = None
+        self.tag_handles = {}
+        self.states = []
+        self.marks = []
+        self.state = self.parse_stream_start
+
+    def dispose(self):
+        # Reset the state attributes (to clear self-references)
+        self.states = []
+        self.state = None
+
+    def check_event(self, *choices):
+        # Check the type of the next event.
+        if self.current_event is None:
+            if self.state:
+                self.current_event = self.state()
+        if self.current_event is not None:
+            if not choices:
+                return True
+            for choice in choices:
+                if isinstance(self.current_event, choice):
+                    return True
+        return False
+
+    def peek_event(self):
+        # Get the next event.
+        if self.current_event is None:
+            if self.state:
+                self.current_event = self.state()
+        return self.current_event
+
+    def get_event(self):
+        # Get the next event and proceed further.
+        if self.current_event is None:
+            if self.state:
+                self.current_event = self.state()
+        value = self.current_event
+        self.current_event = None
+        return value
+
+    # stream    ::= STREAM-START implicit_document? explicit_document* STREAM-END
+    # implicit_document ::= block_node DOCUMENT-END*
+    # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+
+    def parse_stream_start(self):
+
+        # Parse the stream start.
+        token = self.get_token()
+        event = StreamStartEvent(token.start_mark, token.end_mark,
+                encoding=token.encoding)
+
+        # Prepare the next state.
+        self.state = self.parse_implicit_document_start
+
+        return event
+
+    def parse_implicit_document_start(self):
+
+        # Parse an implicit document.
+        if not self.check_token(DirectiveToken, DocumentStartToken,
+                StreamEndToken):
+            self.tag_handles = self.DEFAULT_TAGS
+            token = self.peek_token()
+            start_mark = end_mark = token.start_mark
+            event = DocumentStartEvent(start_mark, end_mark,
+                    explicit=False)
+
+            # Prepare the next state.
+            self.states.append(self.parse_document_end)
+            self.state = self.parse_block_node
+
+            return event
+
+        else:
+            return self.parse_document_start()
+
+    def parse_document_start(self):
+
+        # Parse any extra document end indicators.
+        while self.check_token(DocumentEndToken):
+            self.get_token()
+
+        # Parse an explicit document.
+        if not self.check_token(StreamEndToken):
+            token = self.peek_token()
+            start_mark = token.start_mark
+            version, tags = self.process_directives()
+            if not self.check_token(DocumentStartToken):
+                raise ParserError(None, None,
+                        "expected '<document start>', but found %r"
+                        % self.peek_token().id,
+                        self.peek_token().start_mark)
+            token = self.get_token()
+            end_mark = token.end_mark
+            event = DocumentStartEvent(start_mark, end_mark,
+                    explicit=True, version=version, tags=tags)
+            self.states.append(self.parse_document_end)
+            self.state = self.parse_document_content
+        else:
+            # Parse the end of the stream.
+            token = self.get_token()
+            event = StreamEndEvent(token.start_mark, token.end_mark)
+            assert not self.states
+            assert not self.marks
+            self.state = None
+        return event
+
+    def parse_document_end(self):
+
+        # Parse the document end.
+        token = self.peek_token()
+        start_mark = end_mark = token.start_mark
+        explicit = False
+        if self.check_token(DocumentEndToken):
+            token = self.get_token()
+            end_mark = token.end_mark
+            explicit = True
+        event = DocumentEndEvent(start_mark, end_mark,
+                explicit=explicit)
+
+        # Prepare the next state.
+        self.state = self.parse_document_start
+
+        return event
+
+    def parse_document_content(self):
+        if self.check_token(DirectiveToken,
+                DocumentStartToken, DocumentEndToken, StreamEndToken):
+            event = self.process_empty_scalar(self.peek_token().start_mark)
+            self.state = self.states.pop()
+            return event
+        else:
+            return self.parse_block_node()
+
+    def process_directives(self):
+        self.yaml_version = None
+        self.tag_handles = {}
+        while self.check_token(DirectiveToken):
+            token = self.get_token()
+            if token.name == 'YAML':
+                if self.yaml_version is not None:
+                    raise ParserError(None, None,
+                            "found duplicate YAML directive", token.start_mark)
+                major, minor = token.value
+                if major != 1:
+                    raise ParserError(None, None,
+                            "found incompatible YAML document (version 1.* is required)",
+                            token.start_mark)
+                self.yaml_version = token.value
+            elif token.name == 'TAG':
+                handle, prefix = token.value
+                if handle in self.tag_handles:
+                    raise ParserError(None, None,
+                            "duplicate tag handle %r" % handle,
+                            token.start_mark)
+                self.tag_handles[handle] = prefix
+        if self.tag_handles:
+            value = self.yaml_version, self.tag_handles.copy()
+        else:
+            value = self.yaml_version, None
+        for key in self.DEFAULT_TAGS:
+            if key not in self.tag_handles:
+                self.tag_handles[key] = self.DEFAULT_TAGS[key]
+        return value
+
+    # block_node_or_indentless_sequence ::= ALIAS
+    #               | properties (block_content | indentless_block_sequence)?
+    #               | block_content
+    #               | indentless_block_sequence
+    # block_node    ::= ALIAS
+    #                   | properties block_content?
+    #                   | block_content
+    # flow_node     ::= ALIAS
+    #                   | properties flow_content?
+    #                   | flow_content
+    # properties    ::= TAG ANCHOR? | ANCHOR TAG?
+    # block_content     ::= block_collection | flow_collection | SCALAR
+    # flow_content      ::= flow_collection | SCALAR
+    # block_collection  ::= block_sequence | block_mapping
+    # flow_collection   ::= flow_sequence | flow_mapping
+
+    def parse_block_node(self):
+        return self.parse_node(block=True)
+
+    def parse_flow_node(self):
+        return self.parse_node()
+
+    def parse_block_node_or_indentless_sequence(self):
+        return self.parse_node(block=True, indentless_sequence=True)
+
+    def parse_node(self, block=False, indentless_sequence=False):
+        if self.check_token(AliasToken):
+            token = self.get_token()
+            event = AliasEvent(token.value, token.start_mark, token.end_mark)
+            self.state = self.states.pop()
+        else:
+            anchor = None
+            tag = None
+            start_mark = end_mark = tag_mark = None
+            if self.check_token(AnchorToken):
+                token = self.get_token()
+                start_mark = token.start_mark
+                end_mark = token.end_mark
+                anchor = token.value
+                if self.check_token(TagToken):
+                    token = self.get_token()
+                    tag_mark = token.start_mark
+                    end_mark = token.end_mark
+                    tag = token.value
+            elif self.check_token(TagToken):
+                token = self.get_token()
+                start_mark = tag_mark = token.start_mark
+                end_mark = token.end_mark
+                tag = token.value
+                if self.check_token(AnchorToken):
+                    token = self.get_token()
+                    end_mark = token.end_mark
+                    anchor = token.value
+            if tag is not None:
+                handle, suffix = tag
+                if handle is not None:
+                    if handle not in self.tag_handles:
+                        raise ParserError("while parsing a node", start_mark,
+                                "found undefined tag handle %r" % handle,
+                                tag_mark)
+                    tag = self.tag_handles[handle]+suffix
+                else:
+                    tag = suffix
+            #if tag == '!':
+            #    raise ParserError("while parsing a node", start_mark,
+            #            "found non-specific tag '!'", tag_mark,
+            #            "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.")
+            if start_mark is None:
+                start_mark = end_mark = self.peek_token().start_mark
+            event = None
+            implicit = (tag is None or tag == '!')
+            if indentless_sequence and self.check_token(BlockEntryToken):
+                end_mark = self.peek_token().end_mark
+                event = SequenceStartEvent(anchor, tag, implicit,
+                        start_mark, end_mark)
+                self.state = self.parse_indentless_sequence_entry
+            else:
+                if self.check_token(ScalarToken):
+                    token = self.get_token()
+                    end_mark = token.end_mark
+                    if (token.plain and tag is None) or tag == '!':
+                        implicit = (True, False)
+                    elif tag is None:
+                        implicit = (False, True)
+                    else:
+                        implicit = (False, False)
+                    event = ScalarEvent(anchor, tag, implicit, token.value,
+                            start_mark, end_mark, style=token.style)
+                    self.state = self.states.pop()
+                elif self.check_token(FlowSequenceStartToken):
+                    end_mark = self.peek_token().end_mark
+                    event = SequenceStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=True)
+                    self.state = self.parse_flow_sequence_first_entry
+                elif self.check_token(FlowMappingStartToken):
+                    end_mark = self.peek_token().end_mark
+                    event = MappingStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=True)
+                    self.state = self.parse_flow_mapping_first_key
+                elif block and self.check_token(BlockSequenceStartToken):
+                    end_mark = self.peek_token().start_mark
+                    event = SequenceStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=False)
+                    self.state = self.parse_block_sequence_first_entry
+                elif block and self.check_token(BlockMappingStartToken):
+                    end_mark = self.peek_token().start_mark
+                    event = MappingStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=False)
+                    self.state = self.parse_block_mapping_first_key
+                elif anchor is not None or tag is not None:
+                    # Empty scalars are allowed even if a tag or an anchor is
+                    # specified.
+                    event = ScalarEvent(anchor, tag, (implicit, False), '',
+                            start_mark, end_mark)
+                    self.state = self.states.pop()
+                else:
+                    if block:
+                        node = 'block'
+                    else:
+                        node = 'flow'
+                    token = self.peek_token()
+                    raise ParserError("while parsing a %s node" % node, start_mark,
+                            "expected the node content, but found %r" % token.id,
+                            token.start_mark)
+        return event
+
+    # block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+
+    def parse_block_sequence_first_entry(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_block_sequence_entry()
+
+    def parse_block_sequence_entry(self):
+        if self.check_token(BlockEntryToken):
+            token = self.get_token()
+            if not self.check_token(BlockEntryToken, BlockEndToken):
+                self.states.append(self.parse_block_sequence_entry)
+                return self.parse_block_node()
+            else:
+                self.state = self.parse_block_sequence_entry
+                return self.process_empty_scalar(token.end_mark)
+        if not self.check_token(BlockEndToken):
+            token = self.peek_token()
+            raise ParserError("while parsing a block collection", self.marks[-1],
+                    "expected <block end>, but found %r" % token.id, token.start_mark)
+        token = self.get_token()
+        event = SequenceEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    # indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+
+    def parse_indentless_sequence_entry(self):
+        if self.check_token(BlockEntryToken):
+            token = self.get_token()
+            if not self.check_token(BlockEntryToken,
+                    KeyToken, ValueToken, BlockEndToken):
+                self.states.append(self.parse_indentless_sequence_entry)
+                return self.parse_block_node()
+            else:
+                self.state = self.parse_indentless_sequence_entry
+                return self.process_empty_scalar(token.end_mark)
+        token = self.peek_token()
+        event = SequenceEndEvent(token.start_mark, token.start_mark)
+        self.state = self.states.pop()
+        return event
+
+    # block_mapping     ::= BLOCK-MAPPING_START
+    #                       ((KEY block_node_or_indentless_sequence?)?
+    #                       (VALUE block_node_or_indentless_sequence?)?)*
+    #                       BLOCK-END
+
+    def parse_block_mapping_first_key(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_block_mapping_key()
+
+    def parse_block_mapping_key(self):
+        if self.check_token(KeyToken):
+            token = self.get_token()
+            if not self.check_token(KeyToken, ValueToken, BlockEndToken):
+                self.states.append(self.parse_block_mapping_value)
+                return self.parse_block_node_or_indentless_sequence()
+            else:
+                self.state = self.parse_block_mapping_value
+                return self.process_empty_scalar(token.end_mark)
+        if not self.check_token(BlockEndToken):
+            token = self.peek_token()
+            raise ParserError("while parsing a block mapping", self.marks[-1],
+                    "expected <block end>, but found %r" % token.id, token.start_mark)
+        token = self.get_token()
+        event = MappingEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    def parse_block_mapping_value(self):
+        if self.check_token(ValueToken):
+            token = self.get_token()
+            if not self.check_token(KeyToken, ValueToken, BlockEndToken):
+                self.states.append(self.parse_block_mapping_key)
+                return self.parse_block_node_or_indentless_sequence()
+            else:
+                self.state = self.parse_block_mapping_key
+                return self.process_empty_scalar(token.end_mark)
+        else:
+            self.state = self.parse_block_mapping_key
+            token = self.peek_token()
+            return self.process_empty_scalar(token.start_mark)
+
+    # flow_sequence     ::= FLOW-SEQUENCE-START
+    #                       (flow_sequence_entry FLOW-ENTRY)*
+    #                       flow_sequence_entry?
+    #                       FLOW-SEQUENCE-END
+    # flow_sequence_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+    #
+    # Note that while production rules for both flow_sequence_entry and
+    # flow_mapping_entry are equal, their interpretations are different.
+    # For `flow_sequence_entry`, the part `KEY flow_node? (VALUE flow_node?)?`
+    # generate an inline mapping (set syntax).
+
+    def parse_flow_sequence_first_entry(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_flow_sequence_entry(first=True)
+
+    def parse_flow_sequence_entry(self, first=False):
+        if not self.check_token(FlowSequenceEndToken):
+            if not first:
+                if self.check_token(FlowEntryToken):
+                    self.get_token()
+                else:
+                    token = self.peek_token()
+                    raise ParserError("while parsing a flow sequence", self.marks[-1],
+                            "expected ',' or ']', but got %r" % token.id, token.start_mark)
+            
+            if self.check_token(KeyToken):
+                token = self.peek_token()
+                event = MappingStartEvent(None, None, True,
+                        token.start_mark, token.end_mark,
+                        flow_style=True)
+                self.state = self.parse_flow_sequence_entry_mapping_key
+                return event
+            elif not self.check_token(FlowSequenceEndToken):
+                self.states.append(self.parse_flow_sequence_entry)
+                return self.parse_flow_node()
+        token = self.get_token()
+        event = SequenceEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    def parse_flow_sequence_entry_mapping_key(self):
+        token = self.get_token()
+        if not self.check_token(ValueToken,
+                FlowEntryToken, FlowSequenceEndToken):
+            self.states.append(self.parse_flow_sequence_entry_mapping_value)
+            return self.parse_flow_node()
+        else:
+            self.state = self.parse_flow_sequence_entry_mapping_value
+            return self.process_empty_scalar(token.end_mark)
+
+    def parse_flow_sequence_entry_mapping_value(self):
+        if self.check_token(ValueToken):
+            token = self.get_token()
+            if not self.check_token(FlowEntryToken, FlowSequenceEndToken):
+                self.states.append(self.parse_flow_sequence_entry_mapping_end)
+                return self.parse_flow_node()
+            else:
+                self.state = self.parse_flow_sequence_entry_mapping_end
+                return self.process_empty_scalar(token.end_mark)
+        else:
+            self.state = self.parse_flow_sequence_entry_mapping_end
+            token = self.peek_token()
+            return self.process_empty_scalar(token.start_mark)
+
+    def parse_flow_sequence_entry_mapping_end(self):
+        self.state = self.parse_flow_sequence_entry
+        token = self.peek_token()
+        return MappingEndEvent(token.start_mark, token.start_mark)
+
+    # flow_mapping  ::= FLOW-MAPPING-START
+    #                   (flow_mapping_entry FLOW-ENTRY)*
+    #                   flow_mapping_entry?
+    #                   FLOW-MAPPING-END
+    # flow_mapping_entry    ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+
+    def parse_flow_mapping_first_key(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_flow_mapping_key(first=True)
+
+    def parse_flow_mapping_key(self, first=False):
+        if not self.check_token(FlowMappingEndToken):
+            if not first:
+                if self.check_token(FlowEntryToken):
+                    self.get_token()
+                else:
+                    token = self.peek_token()
+                    raise ParserError("while parsing a flow mapping", self.marks[-1],
+                            "expected ',' or '}', but got %r" % token.id, token.start_mark)
+            if self.check_token(KeyToken):
+                token = self.get_token()
+                if not self.check_token(ValueToken,
+                        FlowEntryToken, FlowMappingEndToken):
+                    self.states.append(self.parse_flow_mapping_value)
+                    return self.parse_flow_node()
+                else:
+                    self.state = self.parse_flow_mapping_value
+                    return self.process_empty_scalar(token.end_mark)
+            elif not self.check_token(FlowMappingEndToken):
+                self.states.append(self.parse_flow_mapping_empty_value)
+                return self.parse_flow_node()
+        token = self.get_token()
+        event = MappingEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    def parse_flow_mapping_value(self):
+        if self.check_token(ValueToken):
+            token = self.get_token()
+            if not self.check_token(FlowEntryToken, FlowMappingEndToken):
+                self.states.append(self.parse_flow_mapping_key)
+                return self.parse_flow_node()
+            else:
+                self.state = self.parse_flow_mapping_key
+                return self.process_empty_scalar(token.end_mark)
+        else:
+            self.state = self.parse_flow_mapping_key
+            token = self.peek_token()
+            return self.process_empty_scalar(token.start_mark)
+
+    def parse_flow_mapping_empty_value(self):
+        self.state = self.parse_flow_mapping_key
+        return self.process_empty_scalar(self.peek_token().start_mark)
+
+    def process_empty_scalar(self, mark):
+        return ScalarEvent(None, None, (True, False), '', mark, mark)
+
diff --git a/myenv/lib/python3.9/site-packages/yaml/reader.py b/myenv/lib/python3.9/site-packages/yaml/reader.py
new file mode 100644
index 0000000..774b021
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/reader.py
@@ -0,0 +1,185 @@
+# This module contains abstractions for the input stream. You don't have to
+# looks further, there are no pretty code.
+#
+# We define two classes here.
+#
+#   Mark(source, line, column)
+# It's just a record and its only use is producing nice error messages.
+# Parser does not use it for any other purposes.
+#
+#   Reader(source, data)
+# Reader determines the encoding of `data` and converts it to unicode.
+# Reader provides the following methods and attributes:
+#   reader.peek(length=1) - return the next `length` characters
+#   reader.forward(length=1) - move the current position to `length` characters.
+#   reader.index - the number of the current character.
+#   reader.line, stream.column - the line and the column of the current character.
+
+__all__ = ['Reader', 'ReaderError']
+
+from .error import YAMLError, Mark
+
+import codecs, re
+
+class ReaderError(YAMLError):
+
+    def __init__(self, name, position, character, encoding, reason):
+        self.name = name
+        self.character = character
+        self.position = position
+        self.encoding = encoding
+        self.reason = reason
+
+    def __str__(self):
+        if isinstance(self.character, bytes):
+            return "'%s' codec can't decode byte #x%02x: %s\n"  \
+                    "  in \"%s\", position %d"    \
+                    % (self.encoding, ord(self.character), self.reason,
+                            self.name, self.position)
+        else:
+            return "unacceptable character #x%04x: %s\n"    \
+                    "  in \"%s\", position %d"    \
+                    % (self.character, self.reason,
+                            self.name, self.position)
+
+class Reader(object):
+    # Reader:
+    # - determines the data encoding and converts it to a unicode string,
+    # - checks if characters are in allowed range,
+    # - adds '\0' to the end.
+
+    # Reader accepts
+    #  - a `bytes` object,
+    #  - a `str` object,
+    #  - a file-like object with its `read` method returning `str`,
+    #  - a file-like object with its `read` method returning `unicode`.
+
+    # Yeah, it's ugly and slow.
+
+    def __init__(self, stream):
+        self.name = None
+        self.stream = None
+        self.stream_pointer = 0
+        self.eof = True
+        self.buffer = ''
+        self.pointer = 0
+        self.raw_buffer = None
+        self.raw_decode = None
+        self.encoding = None
+        self.index = 0
+        self.line = 0
+        self.column = 0
+        if isinstance(stream, str):
+            self.name = "<unicode string>"
+            self.check_printable(stream)
+            self.buffer = stream+'\0'
+        elif isinstance(stream, bytes):
+            self.name = "<byte string>"
+            self.raw_buffer = stream
+            self.determine_encoding()
+        else:
+            self.stream = stream
+            self.name = getattr(stream, 'name', "<file>")
+            self.eof = False
+            self.raw_buffer = None
+            self.determine_encoding()
+
+    def peek(self, index=0):
+        try:
+            return self.buffer[self.pointer+index]
+        except IndexError:
+            self.update(index+1)
+            return self.buffer[self.pointer+index]
+
+    def prefix(self, length=1):
+        if self.pointer+length >= len(self.buffer):
+            self.update(length)
+        return self.buffer[self.pointer:self.pointer+length]
+
+    def forward(self, length=1):
+        if self.pointer+length+1 >= len(self.buffer):
+            self.update(length+1)
+        while length:
+            ch = self.buffer[self.pointer]
+            self.pointer += 1
+            self.index += 1
+            if ch in '\n\x85\u2028\u2029'  \
+                    or (ch == '\r' and self.buffer[self.pointer] != '\n'):
+                self.line += 1
+                self.column = 0
+            elif ch != '\uFEFF':
+                self.column += 1
+            length -= 1
+
+    def get_mark(self):
+        if self.stream is None:
+            return Mark(self.name, self.index, self.line, self.column,
+                    self.buffer, self.pointer)
+        else:
+            return Mark(self.name, self.index, self.line, self.column,
+                    None, None)
+
+    def determine_encoding(self):
+        while not self.eof and (self.raw_buffer is None or len(self.raw_buffer) < 2):
+            self.update_raw()
+        if isinstance(self.raw_buffer, bytes):
+            if self.raw_buffer.startswith(codecs.BOM_UTF16_LE):
+                self.raw_decode = codecs.utf_16_le_decode
+                self.encoding = 'utf-16-le'
+            elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE):
+                self.raw_decode = codecs.utf_16_be_decode
+                self.encoding = 'utf-16-be'
+            else:
+                self.raw_decode = codecs.utf_8_decode
+                self.encoding = 'utf-8'
+        self.update(1)
+
+    NON_PRINTABLE = re.compile('[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD\U00010000-\U0010ffff]')
+    def check_printable(self, data):
+        match = self.NON_PRINTABLE.search(data)
+        if match:
+            character = match.group()
+            position = self.index+(len(self.buffer)-self.pointer)+match.start()
+            raise ReaderError(self.name, position, ord(character),
+                    'unicode', "special characters are not allowed")
+
+    def update(self, length):
+        if self.raw_buffer is None:
+            return
+        self.buffer = self.buffer[self.pointer:]
+        self.pointer = 0
+        while len(self.buffer) < length:
+            if not self.eof:
+                self.update_raw()
+            if self.raw_decode is not None:
+                try:
+                    data, converted = self.raw_decode(self.raw_buffer,
+                            'strict', self.eof)
+                except UnicodeDecodeError as exc:
+                    character = self.raw_buffer[exc.start]
+                    if self.stream is not None:
+                        position = self.stream_pointer-len(self.raw_buffer)+exc.start
+                    else:
+                        position = exc.start
+                    raise ReaderError(self.name, position, character,
+                            exc.encoding, exc.reason)
+            else:
+                data = self.raw_buffer
+                converted = len(data)
+            self.check_printable(data)
+            self.buffer += data
+            self.raw_buffer = self.raw_buffer[converted:]
+            if self.eof:
+                self.buffer += '\0'
+                self.raw_buffer = None
+                break
+
+    def update_raw(self, size=4096):
+        data = self.stream.read(size)
+        if self.raw_buffer is None:
+            self.raw_buffer = data
+        else:
+            self.raw_buffer += data
+        self.stream_pointer += len(data)
+        if not data:
+            self.eof = True
diff --git a/myenv/lib/python3.9/site-packages/yaml/representer.py b/myenv/lib/python3.9/site-packages/yaml/representer.py
new file mode 100644
index 0000000..808ca06
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/representer.py
@@ -0,0 +1,389 @@
+
+__all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer',
+    'RepresenterError']
+
+from .error import *
+from .nodes import *
+
+import datetime, copyreg, types, base64, collections
+
+class RepresenterError(YAMLError):
+    pass
+
+class BaseRepresenter:
+
+    yaml_representers = {}
+    yaml_multi_representers = {}
+
+    def __init__(self, default_style=None, default_flow_style=False, sort_keys=True):
+        self.default_style = default_style
+        self.sort_keys = sort_keys
+        self.default_flow_style = default_flow_style
+        self.represented_objects = {}
+        self.object_keeper = []
+        self.alias_key = None
+
+    def represent(self, data):
+        node = self.represent_data(data)
+        self.serialize(node)
+        self.represented_objects = {}
+        self.object_keeper = []
+        self.alias_key = None
+
+    def represent_data(self, data):
+        if self.ignore_aliases(data):
+            self.alias_key = None
+        else:
+            self.alias_key = id(data)
+        if self.alias_key is not None:
+            if self.alias_key in self.represented_objects:
+                node = self.represented_objects[self.alias_key]
+                #if node is None:
+                #    raise RepresenterError("recursive objects are not allowed: %r" % data)
+                return node
+            #self.represented_objects[alias_key] = None
+            self.object_keeper.append(data)
+        data_types = type(data).__mro__
+        if data_types[0] in self.yaml_representers:
+            node = self.yaml_representers[data_types[0]](self, data)
+        else:
+            for data_type in data_types:
+                if data_type in self.yaml_multi_representers:
+                    node = self.yaml_multi_representers[data_type](self, data)
+                    break
+            else:
+                if None in self.yaml_multi_representers:
+                    node = self.yaml_multi_representers[None](self, data)
+                elif None in self.yaml_representers:
+                    node = self.yaml_representers[None](self, data)
+                else:
+                    node = ScalarNode(None, str(data))
+        #if alias_key is not None:
+        #    self.represented_objects[alias_key] = node
+        return node
+
+    @classmethod
+    def add_representer(cls, data_type, representer):
+        if not 'yaml_representers' in cls.__dict__:
+            cls.yaml_representers = cls.yaml_representers.copy()
+        cls.yaml_representers[data_type] = representer
+
+    @classmethod
+    def add_multi_representer(cls, data_type, representer):
+        if not 'yaml_multi_representers' in cls.__dict__:
+            cls.yaml_multi_representers = cls.yaml_multi_representers.copy()
+        cls.yaml_multi_representers[data_type] = representer
+
+    def represent_scalar(self, tag, value, style=None):
+        if style is None:
+            style = self.default_style
+        node = ScalarNode(tag, value, style=style)
+        if self.alias_key is not None:
+            self.represented_objects[self.alias_key] = node
+        return node
+
+    def represent_sequence(self, tag, sequence, flow_style=None):
+        value = []
+        node = SequenceNode(tag, value, flow_style=flow_style)
+        if self.alias_key is not None:
+            self.represented_objects[self.alias_key] = node
+        best_style = True
+        for item in sequence:
+            node_item = self.represent_data(item)
+            if not (isinstance(node_item, ScalarNode) and not node_item.style):
+                best_style = False
+            value.append(node_item)
+        if flow_style is None:
+            if self.default_flow_style is not None:
+                node.flow_style = self.default_flow_style
+            else:
+                node.flow_style = best_style
+        return node
+
+    def represent_mapping(self, tag, mapping, flow_style=None):
+        value = []
+        node = MappingNode(tag, value, flow_style=flow_style)
+        if self.alias_key is not None:
+            self.represented_objects[self.alias_key] = node
+        best_style = True
+        if hasattr(mapping, 'items'):
+            mapping = list(mapping.items())
+            if self.sort_keys:
+                try:
+                    mapping = sorted(mapping)
+                except TypeError:
+                    pass
+        for item_key, item_value in mapping:
+            node_key = self.represent_data(item_key)
+            node_value = self.represent_data(item_value)
+            if not (isinstance(node_key, ScalarNode) and not node_key.style):
+                best_style = False
+            if not (isinstance(node_value, ScalarNode) and not node_value.style):
+                best_style = False
+            value.append((node_key, node_value))
+        if flow_style is None:
+            if self.default_flow_style is not None:
+                node.flow_style = self.default_flow_style
+            else:
+                node.flow_style = best_style
+        return node
+
+    def ignore_aliases(self, data):
+        return False
+
+class SafeRepresenter(BaseRepresenter):
+
+    def ignore_aliases(self, data):
+        if data is None:
+            return True
+        if isinstance(data, tuple) and data == ():
+            return True
+        if isinstance(data, (str, bytes, bool, int, float)):
+            return True
+
+    def represent_none(self, data):
+        return self.represent_scalar('tag:yaml.org,2002:null', 'null')
+
+    def represent_str(self, data):
+        return self.represent_scalar('tag:yaml.org,2002:str', data)
+
+    def represent_binary(self, data):
+        if hasattr(base64, 'encodebytes'):
+            data = base64.encodebytes(data).decode('ascii')
+        else:
+            data = base64.encodestring(data).decode('ascii')
+        return self.represent_scalar('tag:yaml.org,2002:binary', data, style='|')
+
+    def represent_bool(self, data):
+        if data:
+            value = 'true'
+        else:
+            value = 'false'
+        return self.represent_scalar('tag:yaml.org,2002:bool', value)
+
+    def represent_int(self, data):
+        return self.represent_scalar('tag:yaml.org,2002:int', str(data))
+
+    inf_value = 1e300
+    while repr(inf_value) != repr(inf_value*inf_value):
+        inf_value *= inf_value
+
+    def represent_float(self, data):
+        if data != data or (data == 0.0 and data == 1.0):
+            value = '.nan'
+        elif data == self.inf_value:
+            value = '.inf'
+        elif data == -self.inf_value:
+            value = '-.inf'
+        else:
+            value = repr(data).lower()
+            # Note that in some cases `repr(data)` represents a float number
+            # without the decimal parts.  For instance:
+            #   >>> repr(1e17)
+            #   '1e17'
+            # Unfortunately, this is not a valid float representation according
+            # to the definition of the `!!float` tag.  We fix this by adding
+            # '.0' before the 'e' symbol.
+            if '.' not in value and 'e' in value:
+                value = value.replace('e', '.0e', 1)
+        return self.represent_scalar('tag:yaml.org,2002:float', value)
+
+    def represent_list(self, data):
+        #pairs = (len(data) > 0 and isinstance(data, list))
+        #if pairs:
+        #    for item in data:
+        #        if not isinstance(item, tuple) or len(item) != 2:
+        #            pairs = False
+        #            break
+        #if not pairs:
+            return self.represent_sequence('tag:yaml.org,2002:seq', data)
+        #value = []
+        #for item_key, item_value in data:
+        #    value.append(self.represent_mapping(u'tag:yaml.org,2002:map',
+        #        [(item_key, item_value)]))
+        #return SequenceNode(u'tag:yaml.org,2002:pairs', value)
+
+    def represent_dict(self, data):
+        return self.represent_mapping('tag:yaml.org,2002:map', data)
+
+    def represent_set(self, data):
+        value = {}
+        for key in data:
+            value[key] = None
+        return self.represent_mapping('tag:yaml.org,2002:set', value)
+
+    def represent_date(self, data):
+        value = data.isoformat()
+        return self.represent_scalar('tag:yaml.org,2002:timestamp', value)
+
+    def represent_datetime(self, data):
+        value = data.isoformat(' ')
+        return self.represent_scalar('tag:yaml.org,2002:timestamp', value)
+
+    def represent_yaml_object(self, tag, data, cls, flow_style=None):
+        if hasattr(data, '__getstate__'):
+            state = data.__getstate__()
+        else:
+            state = data.__dict__.copy()
+        return self.represent_mapping(tag, state, flow_style=flow_style)
+
+    def represent_undefined(self, data):
+        raise RepresenterError("cannot represent an object", data)
+
+SafeRepresenter.add_representer(type(None),
+        SafeRepresenter.represent_none)
+
+SafeRepresenter.add_representer(str,
+        SafeRepresenter.represent_str)
+
+SafeRepresenter.add_representer(bytes,
+        SafeRepresenter.represent_binary)
+
+SafeRepresenter.add_representer(bool,
+        SafeRepresenter.represent_bool)
+
+SafeRepresenter.add_representer(int,
+        SafeRepresenter.represent_int)
+
+SafeRepresenter.add_representer(float,
+        SafeRepresenter.represent_float)
+
+SafeRepresenter.add_representer(list,
+        SafeRepresenter.represent_list)
+
+SafeRepresenter.add_representer(tuple,
+        SafeRepresenter.represent_list)
+
+SafeRepresenter.add_representer(dict,
+        SafeRepresenter.represent_dict)
+
+SafeRepresenter.add_representer(set,
+        SafeRepresenter.represent_set)
+
+SafeRepresenter.add_representer(datetime.date,
+        SafeRepresenter.represent_date)
+
+SafeRepresenter.add_representer(datetime.datetime,
+        SafeRepresenter.represent_datetime)
+
+SafeRepresenter.add_representer(None,
+        SafeRepresenter.represent_undefined)
+
+class Representer(SafeRepresenter):
+
+    def represent_complex(self, data):
+        if data.imag == 0.0:
+            data = '%r' % data.real
+        elif data.real == 0.0:
+            data = '%rj' % data.imag
+        elif data.imag > 0:
+            data = '%r+%rj' % (data.real, data.imag)
+        else:
+            data = '%r%rj' % (data.real, data.imag)
+        return self.represent_scalar('tag:yaml.org,2002:python/complex', data)
+
+    def represent_tuple(self, data):
+        return self.represent_sequence('tag:yaml.org,2002:python/tuple', data)
+
+    def represent_name(self, data):
+        name = '%s.%s' % (data.__module__, data.__name__)
+        return self.represent_scalar('tag:yaml.org,2002:python/name:'+name, '')
+
+    def represent_module(self, data):
+        return self.represent_scalar(
+                'tag:yaml.org,2002:python/module:'+data.__name__, '')
+
+    def represent_object(self, data):
+        # We use __reduce__ API to save the data. data.__reduce__ returns
+        # a tuple of length 2-5:
+        #   (function, args, state, listitems, dictitems)
+
+        # For reconstructing, we calls function(*args), then set its state,
+        # listitems, and dictitems if they are not None.
+
+        # A special case is when function.__name__ == '__newobj__'. In this
+        # case we create the object with args[0].__new__(*args).
+
+        # Another special case is when __reduce__ returns a string - we don't
+        # support it.
+
+        # We produce a !!python/object, !!python/object/new or
+        # !!python/object/apply node.
+
+        cls = type(data)
+        if cls in copyreg.dispatch_table:
+            reduce = copyreg.dispatch_table[cls](data)
+        elif hasattr(data, '__reduce_ex__'):
+            reduce = data.__reduce_ex__(2)
+        elif hasattr(data, '__reduce__'):
+            reduce = data.__reduce__()
+        else:
+            raise RepresenterError("cannot represent an object", data)
+        reduce = (list(reduce)+[None]*5)[:5]
+        function, args, state, listitems, dictitems = reduce
+        args = list(args)
+        if state is None:
+            state = {}
+        if listitems is not None:
+            listitems = list(listitems)
+        if dictitems is not None:
+            dictitems = dict(dictitems)
+        if function.__name__ == '__newobj__':
+            function = args[0]
+            args = args[1:]
+            tag = 'tag:yaml.org,2002:python/object/new:'
+            newobj = True
+        else:
+            tag = 'tag:yaml.org,2002:python/object/apply:'
+            newobj = False
+        function_name = '%s.%s' % (function.__module__, function.__name__)
+        if not args and not listitems and not dictitems \
+                and isinstance(state, dict) and newobj:
+            return self.represent_mapping(
+                    'tag:yaml.org,2002:python/object:'+function_name, state)
+        if not listitems and not dictitems  \
+                and isinstance(state, dict) and not state:
+            return self.represent_sequence(tag+function_name, args)
+        value = {}
+        if args:
+            value['args'] = args
+        if state or not isinstance(state, dict):
+            value['state'] = state
+        if listitems:
+            value['listitems'] = listitems
+        if dictitems:
+            value['dictitems'] = dictitems
+        return self.represent_mapping(tag+function_name, value)
+
+    def represent_ordered_dict(self, data):
+        # Provide uniform representation across different Python versions.
+        data_type = type(data)
+        tag = 'tag:yaml.org,2002:python/object/apply:%s.%s' \
+                % (data_type.__module__, data_type.__name__)
+        items = [[key, value] for key, value in data.items()]
+        return self.represent_sequence(tag, [items])
+
+Representer.add_representer(complex,
+        Representer.represent_complex)
+
+Representer.add_representer(tuple,
+        Representer.represent_tuple)
+
+Representer.add_multi_representer(type,
+        Representer.represent_name)
+
+Representer.add_representer(collections.OrderedDict,
+        Representer.represent_ordered_dict)
+
+Representer.add_representer(types.FunctionType,
+        Representer.represent_name)
+
+Representer.add_representer(types.BuiltinFunctionType,
+        Representer.represent_name)
+
+Representer.add_representer(types.ModuleType,
+        Representer.represent_module)
+
+Representer.add_multi_representer(object,
+        Representer.represent_object)
+
diff --git a/myenv/lib/python3.9/site-packages/yaml/resolver.py b/myenv/lib/python3.9/site-packages/yaml/resolver.py
new file mode 100644
index 0000000..3522bda
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/resolver.py
@@ -0,0 +1,227 @@
+
+__all__ = ['BaseResolver', 'Resolver']
+
+from .error import *
+from .nodes import *
+
+import re
+
+class ResolverError(YAMLError):
+    pass
+
+class BaseResolver:
+
+    DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str'
+    DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq'
+    DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map'
+
+    yaml_implicit_resolvers = {}
+    yaml_path_resolvers = {}
+
+    def __init__(self):
+        self.resolver_exact_paths = []
+        self.resolver_prefix_paths = []
+
+    @classmethod
+    def add_implicit_resolver(cls, tag, regexp, first):
+        if not 'yaml_implicit_resolvers' in cls.__dict__:
+            implicit_resolvers = {}
+            for key in cls.yaml_implicit_resolvers:
+                implicit_resolvers[key] = cls.yaml_implicit_resolvers[key][:]
+            cls.yaml_implicit_resolvers = implicit_resolvers
+        if first is None:
+            first = [None]
+        for ch in first:
+            cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp))
+
+    @classmethod
+    def add_path_resolver(cls, tag, path, kind=None):
+        # Note: `add_path_resolver` is experimental.  The API could be changed.
+        # `new_path` is a pattern that is matched against the path from the
+        # root to the node that is being considered.  `node_path` elements are
+        # tuples `(node_check, index_check)`.  `node_check` is a node class:
+        # `ScalarNode`, `SequenceNode`, `MappingNode` or `None`.  `None`
+        # matches any kind of a node.  `index_check` could be `None`, a boolean
+        # value, a string value, or a number.  `None` and `False` match against
+        # any _value_ of sequence and mapping nodes.  `True` matches against
+        # any _key_ of a mapping node.  A string `index_check` matches against
+        # a mapping value that corresponds to a scalar key which content is
+        # equal to the `index_check` value.  An integer `index_check` matches
+        # against a sequence value with the index equal to `index_check`.
+        if not 'yaml_path_resolvers' in cls.__dict__:
+            cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy()
+        new_path = []
+        for element in path:
+            if isinstance(element, (list, tuple)):
+                if len(element) == 2:
+                    node_check, index_check = element
+                elif len(element) == 1:
+                    node_check = element[0]
+                    index_check = True
+                else:
+                    raise ResolverError("Invalid path element: %s" % element)
+            else:
+                node_check = None
+                index_check = element
+            if node_check is str:
+                node_check = ScalarNode
+            elif node_check is list:
+                node_check = SequenceNode
+            elif node_check is dict:
+                node_check = MappingNode
+            elif node_check not in [ScalarNode, SequenceNode, MappingNode]  \
+                    and not isinstance(node_check, str) \
+                    and node_check is not None:
+                raise ResolverError("Invalid node checker: %s" % node_check)
+            if not isinstance(index_check, (str, int))  \
+                    and index_check is not None:
+                raise ResolverError("Invalid index checker: %s" % index_check)
+            new_path.append((node_check, index_check))
+        if kind is str:
+            kind = ScalarNode
+        elif kind is list:
+            kind = SequenceNode
+        elif kind is dict:
+            kind = MappingNode
+        elif kind not in [ScalarNode, SequenceNode, MappingNode]    \
+                and kind is not None:
+            raise ResolverError("Invalid node kind: %s" % kind)
+        cls.yaml_path_resolvers[tuple(new_path), kind] = tag
+
+    def descend_resolver(self, current_node, current_index):
+        if not self.yaml_path_resolvers:
+            return
+        exact_paths = {}
+        prefix_paths = []
+        if current_node:
+            depth = len(self.resolver_prefix_paths)
+            for path, kind in self.resolver_prefix_paths[-1]:
+                if self.check_resolver_prefix(depth, path, kind,
+                        current_node, current_index):
+                    if len(path) > depth:
+                        prefix_paths.append((path, kind))
+                    else:
+                        exact_paths[kind] = self.yaml_path_resolvers[path, kind]
+        else:
+            for path, kind in self.yaml_path_resolvers:
+                if not path:
+                    exact_paths[kind] = self.yaml_path_resolvers[path, kind]
+                else:
+                    prefix_paths.append((path, kind))
+        self.resolver_exact_paths.append(exact_paths)
+        self.resolver_prefix_paths.append(prefix_paths)
+
+    def ascend_resolver(self):
+        if not self.yaml_path_resolvers:
+            return
+        self.resolver_exact_paths.pop()
+        self.resolver_prefix_paths.pop()
+
+    def check_resolver_prefix(self, depth, path, kind,
+            current_node, current_index):
+        node_check, index_check = path[depth-1]
+        if isinstance(node_check, str):
+            if current_node.tag != node_check:
+                return
+        elif node_check is not None:
+            if not isinstance(current_node, node_check):
+                return
+        if index_check is True and current_index is not None:
+            return
+        if (index_check is False or index_check is None)    \
+                and current_index is None:
+            return
+        if isinstance(index_check, str):
+            if not (isinstance(current_index, ScalarNode)
+                    and index_check == current_index.value):
+                return
+        elif isinstance(index_check, int) and not isinstance(index_check, bool):
+            if index_check != current_index:
+                return
+        return True
+
+    def resolve(self, kind, value, implicit):
+        if kind is ScalarNode and implicit[0]:
+            if value == '':
+                resolvers = self.yaml_implicit_resolvers.get('', [])
+            else:
+                resolvers = self.yaml_implicit_resolvers.get(value[0], [])
+            wildcard_resolvers = self.yaml_implicit_resolvers.get(None, [])
+            for tag, regexp in resolvers + wildcard_resolvers:
+                if regexp.match(value):
+                    return tag
+            implicit = implicit[1]
+        if self.yaml_path_resolvers:
+            exact_paths = self.resolver_exact_paths[-1]
+            if kind in exact_paths:
+                return exact_paths[kind]
+            if None in exact_paths:
+                return exact_paths[None]
+        if kind is ScalarNode:
+            return self.DEFAULT_SCALAR_TAG
+        elif kind is SequenceNode:
+            return self.DEFAULT_SEQUENCE_TAG
+        elif kind is MappingNode:
+            return self.DEFAULT_MAPPING_TAG
+
+class Resolver(BaseResolver):
+    pass
+
+Resolver.add_implicit_resolver(
+        'tag:yaml.org,2002:bool',
+        re.compile(r'''^(?:yes|Yes|YES|no|No|NO
+                    |true|True|TRUE|false|False|FALSE
+                    |on|On|ON|off|Off|OFF)$''', re.X),
+        list('yYnNtTfFoO'))
+
+Resolver.add_implicit_resolver(
+        'tag:yaml.org,2002:float',
+        re.compile(r'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?
+                    |\.[0-9][0-9_]*(?:[eE][-+][0-9]+)?
+                    |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
+                    |[-+]?\.(?:inf|Inf|INF)
+                    |\.(?:nan|NaN|NAN))$''', re.X),
+        list('-+0123456789.'))
+
+Resolver.add_implicit_resolver(
+        'tag:yaml.org,2002:int',
+        re.compile(r'''^(?:[-+]?0b[0-1_]+
+                    |[-+]?0[0-7_]+
+                    |[-+]?(?:0|[1-9][0-9_]*)
+                    |[-+]?0x[0-9a-fA-F_]+
+                    |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X),
+        list('-+0123456789'))
+
+Resolver.add_implicit_resolver(
+        'tag:yaml.org,2002:merge',
+        re.compile(r'^(?:<<)$'),
+        ['<'])
+
+Resolver.add_implicit_resolver(
+        'tag:yaml.org,2002:null',
+        re.compile(r'''^(?: ~
+                    |null|Null|NULL
+                    | )$''', re.X),
+        ['~', 'n', 'N', ''])
+
+Resolver.add_implicit_resolver(
+        'tag:yaml.org,2002:timestamp',
+        re.compile(r'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]
+                    |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]?
+                     (?:[Tt]|[ \t]+)[0-9][0-9]?
+                     :[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)?
+                     (?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X),
+        list('0123456789'))
+
+Resolver.add_implicit_resolver(
+        'tag:yaml.org,2002:value',
+        re.compile(r'^(?:=)$'),
+        ['='])
+
+# The following resolver is only for documentation purposes. It cannot work
+# because plain scalars cannot start with '!', '&', or '*'.
+Resolver.add_implicit_resolver(
+        'tag:yaml.org,2002:yaml',
+        re.compile(r'^(?:!|&|\*)$'),
+        list('!&*'))
+
diff --git a/myenv/lib/python3.9/site-packages/yaml/scanner.py b/myenv/lib/python3.9/site-packages/yaml/scanner.py
new file mode 100644
index 0000000..de925b0
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/scanner.py
@@ -0,0 +1,1435 @@
+
+# Scanner produces tokens of the following types:
+# STREAM-START
+# STREAM-END
+# DIRECTIVE(name, value)
+# DOCUMENT-START
+# DOCUMENT-END
+# BLOCK-SEQUENCE-START
+# BLOCK-MAPPING-START
+# BLOCK-END
+# FLOW-SEQUENCE-START
+# FLOW-MAPPING-START
+# FLOW-SEQUENCE-END
+# FLOW-MAPPING-END
+# BLOCK-ENTRY
+# FLOW-ENTRY
+# KEY
+# VALUE
+# ALIAS(value)
+# ANCHOR(value)
+# TAG(value)
+# SCALAR(value, plain, style)
+#
+# Read comments in the Scanner code for more details.
+#
+
+__all__ = ['Scanner', 'ScannerError']
+
+from .error import MarkedYAMLError
+from .tokens import *
+
+class ScannerError(MarkedYAMLError):
+    pass
+
+class SimpleKey:
+    # See below simple keys treatment.
+
+    def __init__(self, token_number, required, index, line, column, mark):
+        self.token_number = token_number
+        self.required = required
+        self.index = index
+        self.line = line
+        self.column = column
+        self.mark = mark
+
+class Scanner:
+
+    def __init__(self):
+        """Initialize the scanner."""
+        # It is assumed that Scanner and Reader will have a common descendant.
+        # Reader do the dirty work of checking for BOM and converting the
+        # input data to Unicode. It also adds NUL to the end.
+        #
+        # Reader supports the following methods
+        #   self.peek(i=0)       # peek the next i-th character
+        #   self.prefix(l=1)     # peek the next l characters
+        #   self.forward(l=1)    # read the next l characters and move the pointer.
+
+        # Had we reached the end of the stream?
+        self.done = False
+
+        # The number of unclosed '{' and '['. `flow_level == 0` means block
+        # context.
+        self.flow_level = 0
+
+        # List of processed tokens that are not yet emitted.
+        self.tokens = []
+
+        # Add the STREAM-START token.
+        self.fetch_stream_start()
+
+        # Number of tokens that were emitted through the `get_token` method.
+        self.tokens_taken = 0
+
+        # The current indentation level.
+        self.indent = -1
+
+        # Past indentation levels.
+        self.indents = []
+
+        # Variables related to simple keys treatment.
+
+        # A simple key is a key that is not denoted by the '?' indicator.
+        # Example of simple keys:
+        #   ---
+        #   block simple key: value
+        #   ? not a simple key:
+        #   : { flow simple key: value }
+        # We emit the KEY token before all keys, so when we find a potential
+        # simple key, we try to locate the corresponding ':' indicator.
+        # Simple keys should be limited to a single line and 1024 characters.
+
+        # Can a simple key start at the current position? A simple key may
+        # start:
+        # - at the beginning of the line, not counting indentation spaces
+        #       (in block context),
+        # - after '{', '[', ',' (in the flow context),
+        # - after '?', ':', '-' (in the block context).
+        # In the block context, this flag also signifies if a block collection
+        # may start at the current position.
+        self.allow_simple_key = True
+
+        # Keep track of possible simple keys. This is a dictionary. The key
+        # is `flow_level`; there can be no more that one possible simple key
+        # for each level. The value is a SimpleKey record:
+        #   (token_number, required, index, line, column, mark)
+        # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow),
+        # '[', or '{' tokens.
+        self.possible_simple_keys = {}
+
+    # Public methods.
+
+    def check_token(self, *choices):
+        # Check if the next token is one of the given types.
+        while self.need_more_tokens():
+            self.fetch_more_tokens()
+        if self.tokens:
+            if not choices:
+                return True
+            for choice in choices:
+                if isinstance(self.tokens[0], choice):
+                    return True
+        return False
+
+    def peek_token(self):
+        # Return the next token, but do not delete if from the queue.
+        # Return None if no more tokens.
+        while self.need_more_tokens():
+            self.fetch_more_tokens()
+        if self.tokens:
+            return self.tokens[0]
+        else:
+            return None
+
+    def get_token(self):
+        # Return the next token.
+        while self.need_more_tokens():
+            self.fetch_more_tokens()
+        if self.tokens:
+            self.tokens_taken += 1
+            return self.tokens.pop(0)
+
+    # Private methods.
+
+    def need_more_tokens(self):
+        if self.done:
+            return False
+        if not self.tokens:
+            return True
+        # The current token may be a potential simple key, so we
+        # need to look further.
+        self.stale_possible_simple_keys()
+        if self.next_possible_simple_key() == self.tokens_taken:
+            return True
+
+    def fetch_more_tokens(self):
+
+        # Eat whitespaces and comments until we reach the next token.
+        self.scan_to_next_token()
+
+        # Remove obsolete possible simple keys.
+        self.stale_possible_simple_keys()
+
+        # Compare the current indentation and column. It may add some tokens
+        # and decrease the current indentation level.
+        self.unwind_indent(self.column)
+
+        # Peek the next character.
+        ch = self.peek()
+
+        # Is it the end of stream?
+        if ch == '\0':
+            return self.fetch_stream_end()
+
+        # Is it a directive?
+        if ch == '%' and self.check_directive():
+            return self.fetch_directive()
+
+        # Is it the document start?
+        if ch == '-' and self.check_document_start():
+            return self.fetch_document_start()
+
+        # Is it the document end?
+        if ch == '.' and self.check_document_end():
+            return self.fetch_document_end()
+
+        # TODO: support for BOM within a stream.
+        #if ch == '\uFEFF':
+        #    return self.fetch_bom()    <-- issue BOMToken
+
+        # Note: the order of the following checks is NOT significant.
+
+        # Is it the flow sequence start indicator?
+        if ch == '[':
+            return self.fetch_flow_sequence_start()
+
+        # Is it the flow mapping start indicator?
+        if ch == '{':
+            return self.fetch_flow_mapping_start()
+
+        # Is it the flow sequence end indicator?
+        if ch == ']':
+            return self.fetch_flow_sequence_end()
+
+        # Is it the flow mapping end indicator?
+        if ch == '}':
+            return self.fetch_flow_mapping_end()
+
+        # Is it the flow entry indicator?
+        if ch == ',':
+            return self.fetch_flow_entry()
+
+        # Is it the block entry indicator?
+        if ch == '-' and self.check_block_entry():
+            return self.fetch_block_entry()
+
+        # Is it the key indicator?
+        if ch == '?' and self.check_key():
+            return self.fetch_key()
+
+        # Is it the value indicator?
+        if ch == ':' and self.check_value():
+            return self.fetch_value()
+
+        # Is it an alias?
+        if ch == '*':
+            return self.fetch_alias()
+
+        # Is it an anchor?
+        if ch == '&':
+            return self.fetch_anchor()
+
+        # Is it a tag?
+        if ch == '!':
+            return self.fetch_tag()
+
+        # Is it a literal scalar?
+        if ch == '|' and not self.flow_level:
+            return self.fetch_literal()
+
+        # Is it a folded scalar?
+        if ch == '>' and not self.flow_level:
+            return self.fetch_folded()
+
+        # Is it a single quoted scalar?
+        if ch == '\'':
+            return self.fetch_single()
+
+        # Is it a double quoted scalar?
+        if ch == '\"':
+            return self.fetch_double()
+
+        # It must be a plain scalar then.
+        if self.check_plain():
+            return self.fetch_plain()
+
+        # No? It's an error. Let's produce a nice error message.
+        raise ScannerError("while scanning for the next token", None,
+                "found character %r that cannot start any token" % ch,
+                self.get_mark())
+
+    # Simple keys treatment.
+
+    def next_possible_simple_key(self):
+        # Return the number of the nearest possible simple key. Actually we
+        # don't need to loop through the whole dictionary. We may replace it
+        # with the following code:
+        #   if not self.possible_simple_keys:
+        #       return None
+        #   return self.possible_simple_keys[
+        #           min(self.possible_simple_keys.keys())].token_number
+        min_token_number = None
+        for level in self.possible_simple_keys:
+            key = self.possible_simple_keys[level]
+            if min_token_number is None or key.token_number < min_token_number:
+                min_token_number = key.token_number
+        return min_token_number
+
+    def stale_possible_simple_keys(self):
+        # Remove entries that are no longer possible simple keys. According to
+        # the YAML specification, simple keys
+        # - should be limited to a single line,
+        # - should be no longer than 1024 characters.
+        # Disabling this procedure will allow simple keys of any length and
+        # height (may cause problems if indentation is broken though).
+        for level in list(self.possible_simple_keys):
+            key = self.possible_simple_keys[level]
+            if key.line != self.line  \
+                    or self.index-key.index > 1024:
+                if key.required:
+                    raise ScannerError("while scanning a simple key", key.mark,
+                            "could not find expected ':'", self.get_mark())
+                del self.possible_simple_keys[level]
+
+    def save_possible_simple_key(self):
+        # The next token may start a simple key. We check if it's possible
+        # and save its position. This function is called for
+        #   ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'.
+
+        # Check if a simple key is required at the current position.
+        required = not self.flow_level and self.indent == self.column
+
+        # The next token might be a simple key. Let's save it's number and
+        # position.
+        if self.allow_simple_key:
+            self.remove_possible_simple_key()
+            token_number = self.tokens_taken+len(self.tokens)
+            key = SimpleKey(token_number, required,
+                    self.index, self.line, self.column, self.get_mark())
+            self.possible_simple_keys[self.flow_level] = key
+
+    def remove_possible_simple_key(self):
+        # Remove the saved possible key position at the current flow level.
+        if self.flow_level in self.possible_simple_keys:
+            key = self.possible_simple_keys[self.flow_level]
+            
+            if key.required:
+                raise ScannerError("while scanning a simple key", key.mark,
+                        "could not find expected ':'", self.get_mark())
+
+            del self.possible_simple_keys[self.flow_level]
+
+    # Indentation functions.
+
+    def unwind_indent(self, column):
+
+        ## In flow context, tokens should respect indentation.
+        ## Actually the condition should be `self.indent >= column` according to
+        ## the spec. But this condition will prohibit intuitively correct
+        ## constructions such as
+        ## key : {
+        ## }
+        #if self.flow_level and self.indent > column:
+        #    raise ScannerError(None, None,
+        #            "invalid indentation or unclosed '[' or '{'",
+        #            self.get_mark())
+
+        # In the flow context, indentation is ignored. We make the scanner less
+        # restrictive then specification requires.
+        if self.flow_level:
+            return
+
+        # In block context, we may need to issue the BLOCK-END tokens.
+        while self.indent > column:
+            mark = self.get_mark()
+            self.indent = self.indents.pop()
+            self.tokens.append(BlockEndToken(mark, mark))
+
+    def add_indent(self, column):
+        # Check if we need to increase indentation.
+        if self.indent < column:
+            self.indents.append(self.indent)
+            self.indent = column
+            return True
+        return False
+
+    # Fetchers.
+
+    def fetch_stream_start(self):
+        # We always add STREAM-START as the first token and STREAM-END as the
+        # last token.
+
+        # Read the token.
+        mark = self.get_mark()
+        
+        # Add STREAM-START.
+        self.tokens.append(StreamStartToken(mark, mark,
+            encoding=self.encoding))
+        
+
+    def fetch_stream_end(self):
+
+        # Set the current indentation to -1.
+        self.unwind_indent(-1)
+
+        # Reset simple keys.
+        self.remove_possible_simple_key()
+        self.allow_simple_key = False
+        self.possible_simple_keys = {}
+
+        # Read the token.
+        mark = self.get_mark()
+        
+        # Add STREAM-END.
+        self.tokens.append(StreamEndToken(mark, mark))
+
+        # The steam is finished.
+        self.done = True
+
+    def fetch_directive(self):
+        
+        # Set the current indentation to -1.
+        self.unwind_indent(-1)
+
+        # Reset simple keys.
+        self.remove_possible_simple_key()
+        self.allow_simple_key = False
+
+        # Scan and add DIRECTIVE.
+        self.tokens.append(self.scan_directive())
+
+    def fetch_document_start(self):
+        self.fetch_document_indicator(DocumentStartToken)
+
+    def fetch_document_end(self):
+        self.fetch_document_indicator(DocumentEndToken)
+
+    def fetch_document_indicator(self, TokenClass):
+
+        # Set the current indentation to -1.
+        self.unwind_indent(-1)
+
+        # Reset simple keys. Note that there could not be a block collection
+        # after '---'.
+        self.remove_possible_simple_key()
+        self.allow_simple_key = False
+
+        # Add DOCUMENT-START or DOCUMENT-END.
+        start_mark = self.get_mark()
+        self.forward(3)
+        end_mark = self.get_mark()
+        self.tokens.append(TokenClass(start_mark, end_mark))
+
+    def fetch_flow_sequence_start(self):
+        self.fetch_flow_collection_start(FlowSequenceStartToken)
+
+    def fetch_flow_mapping_start(self):
+        self.fetch_flow_collection_start(FlowMappingStartToken)
+
+    def fetch_flow_collection_start(self, TokenClass):
+
+        # '[' and '{' may start a simple key.
+        self.save_possible_simple_key()
+
+        # Increase the flow level.
+        self.flow_level += 1
+
+        # Simple keys are allowed after '[' and '{'.
+        self.allow_simple_key = True
+
+        # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(TokenClass(start_mark, end_mark))
+
+    def fetch_flow_sequence_end(self):
+        self.fetch_flow_collection_end(FlowSequenceEndToken)
+
+    def fetch_flow_mapping_end(self):
+        self.fetch_flow_collection_end(FlowMappingEndToken)
+
+    def fetch_flow_collection_end(self, TokenClass):
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Decrease the flow level.
+        self.flow_level -= 1
+
+        # No simple keys after ']' or '}'.
+        self.allow_simple_key = False
+
+        # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(TokenClass(start_mark, end_mark))
+
+    def fetch_flow_entry(self):
+
+        # Simple keys are allowed after ','.
+        self.allow_simple_key = True
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Add FLOW-ENTRY.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(FlowEntryToken(start_mark, end_mark))
+
+    def fetch_block_entry(self):
+
+        # Block context needs additional checks.
+        if not self.flow_level:
+
+            # Are we allowed to start a new entry?
+            if not self.allow_simple_key:
+                raise ScannerError(None, None,
+                        "sequence entries are not allowed here",
+                        self.get_mark())
+
+            # We may need to add BLOCK-SEQUENCE-START.
+            if self.add_indent(self.column):
+                mark = self.get_mark()
+                self.tokens.append(BlockSequenceStartToken(mark, mark))
+
+        # It's an error for the block entry to occur in the flow context,
+        # but we let the parser detect this.
+        else:
+            pass
+
+        # Simple keys are allowed after '-'.
+        self.allow_simple_key = True
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Add BLOCK-ENTRY.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(BlockEntryToken(start_mark, end_mark))
+
+    def fetch_key(self):
+        
+        # Block context needs additional checks.
+        if not self.flow_level:
+
+            # Are we allowed to start a key (not necessary a simple)?
+            if not self.allow_simple_key:
+                raise ScannerError(None, None,
+                        "mapping keys are not allowed here",
+                        self.get_mark())
+
+            # We may need to add BLOCK-MAPPING-START.
+            if self.add_indent(self.column):
+                mark = self.get_mark()
+                self.tokens.append(BlockMappingStartToken(mark, mark))
+
+        # Simple keys are allowed after '?' in the block context.
+        self.allow_simple_key = not self.flow_level
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Add KEY.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(KeyToken(start_mark, end_mark))
+
+    def fetch_value(self):
+
+        # Do we determine a simple key?
+        if self.flow_level in self.possible_simple_keys:
+
+            # Add KEY.
+            key = self.possible_simple_keys[self.flow_level]
+            del self.possible_simple_keys[self.flow_level]
+            self.tokens.insert(key.token_number-self.tokens_taken,
+                    KeyToken(key.mark, key.mark))
+
+            # If this key starts a new block mapping, we need to add
+            # BLOCK-MAPPING-START.
+            if not self.flow_level:
+                if self.add_indent(key.column):
+                    self.tokens.insert(key.token_number-self.tokens_taken,
+                            BlockMappingStartToken(key.mark, key.mark))
+
+            # There cannot be two simple keys one after another.
+            self.allow_simple_key = False
+
+        # It must be a part of a complex key.
+        else:
+            
+            # Block context needs additional checks.
+            # (Do we really need them? They will be caught by the parser
+            # anyway.)
+            if not self.flow_level:
+
+                # We are allowed to start a complex value if and only if
+                # we can start a simple key.
+                if not self.allow_simple_key:
+                    raise ScannerError(None, None,
+                            "mapping values are not allowed here",
+                            self.get_mark())
+
+            # If this value starts a new block mapping, we need to add
+            # BLOCK-MAPPING-START.  It will be detected as an error later by
+            # the parser.
+            if not self.flow_level:
+                if self.add_indent(self.column):
+                    mark = self.get_mark()
+                    self.tokens.append(BlockMappingStartToken(mark, mark))
+
+            # Simple keys are allowed after ':' in the block context.
+            self.allow_simple_key = not self.flow_level
+
+            # Reset possible simple key on the current level.
+            self.remove_possible_simple_key()
+
+        # Add VALUE.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(ValueToken(start_mark, end_mark))
+
+    def fetch_alias(self):
+
+        # ALIAS could be a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after ALIAS.
+        self.allow_simple_key = False
+
+        # Scan and add ALIAS.
+        self.tokens.append(self.scan_anchor(AliasToken))
+
+    def fetch_anchor(self):
+
+        # ANCHOR could start a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after ANCHOR.
+        self.allow_simple_key = False
+
+        # Scan and add ANCHOR.
+        self.tokens.append(self.scan_anchor(AnchorToken))
+
+    def fetch_tag(self):
+
+        # TAG could start a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after TAG.
+        self.allow_simple_key = False
+
+        # Scan and add TAG.
+        self.tokens.append(self.scan_tag())
+
+    def fetch_literal(self):
+        self.fetch_block_scalar(style='|')
+
+    def fetch_folded(self):
+        self.fetch_block_scalar(style='>')
+
+    def fetch_block_scalar(self, style):
+
+        # A simple key may follow a block scalar.
+        self.allow_simple_key = True
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Scan and add SCALAR.
+        self.tokens.append(self.scan_block_scalar(style))
+
+    def fetch_single(self):
+        self.fetch_flow_scalar(style='\'')
+
+    def fetch_double(self):
+        self.fetch_flow_scalar(style='"')
+
+    def fetch_flow_scalar(self, style):
+
+        # A flow scalar could be a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after flow scalars.
+        self.allow_simple_key = False
+
+        # Scan and add SCALAR.
+        self.tokens.append(self.scan_flow_scalar(style))
+
+    def fetch_plain(self):
+
+        # A plain scalar could be a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after plain scalars. But note that `scan_plain` will
+        # change this flag if the scan is finished at the beginning of the
+        # line.
+        self.allow_simple_key = False
+
+        # Scan and add SCALAR. May change `allow_simple_key`.
+        self.tokens.append(self.scan_plain())
+
+    # Checkers.
+
+    def check_directive(self):
+
+        # DIRECTIVE:        ^ '%' ...
+        # The '%' indicator is already checked.
+        if self.column == 0:
+            return True
+
+    def check_document_start(self):
+
+        # DOCUMENT-START:   ^ '---' (' '|'\n')
+        if self.column == 0:
+            if self.prefix(3) == '---'  \
+                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
+                return True
+
+    def check_document_end(self):
+
+        # DOCUMENT-END:     ^ '...' (' '|'\n')
+        if self.column == 0:
+            if self.prefix(3) == '...'  \
+                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
+                return True
+
+    def check_block_entry(self):
+
+        # BLOCK-ENTRY:      '-' (' '|'\n')
+        return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
+
+    def check_key(self):
+
+        # KEY(flow context):    '?'
+        if self.flow_level:
+            return True
+
+        # KEY(block context):   '?' (' '|'\n')
+        else:
+            return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
+
+    def check_value(self):
+
+        # VALUE(flow context):  ':'
+        if self.flow_level:
+            return True
+
+        # VALUE(block context): ':' (' '|'\n')
+        else:
+            return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
+
+    def check_plain(self):
+
+        # A plain scalar may start with any non-space character except:
+        #   '-', '?', ':', ',', '[', ']', '{', '}',
+        #   '#', '&', '*', '!', '|', '>', '\'', '\"',
+        #   '%', '@', '`'.
+        #
+        # It may also start with
+        #   '-', '?', ':'
+        # if it is followed by a non-space character.
+        #
+        # Note that we limit the last rule to the block context (except the
+        # '-' character) because we want the flow context to be space
+        # independent.
+        ch = self.peek()
+        return ch not in '\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`'  \
+                or (self.peek(1) not in '\0 \t\r\n\x85\u2028\u2029'
+                        and (ch == '-' or (not self.flow_level and ch in '?:')))
+
+    # Scanners.
+
+    def scan_to_next_token(self):
+        # We ignore spaces, line breaks and comments.
+        # If we find a line break in the block context, we set the flag
+        # `allow_simple_key` on.
+        # The byte order mark is stripped if it's the first character in the
+        # stream. We do not yet support BOM inside the stream as the
+        # specification requires. Any such mark will be considered as a part
+        # of the document.
+        #
+        # TODO: We need to make tab handling rules more sane. A good rule is
+        #   Tabs cannot precede tokens
+        #   BLOCK-SEQUENCE-START, BLOCK-MAPPING-START, BLOCK-END,
+        #   KEY(block), VALUE(block), BLOCK-ENTRY
+        # So the checking code is
+        #   if <TAB>:
+        #       self.allow_simple_keys = False
+        # We also need to add the check for `allow_simple_keys == True` to
+        # `unwind_indent` before issuing BLOCK-END.
+        # Scanners for block, flow, and plain scalars need to be modified.
+
+        if self.index == 0 and self.peek() == '\uFEFF':
+            self.forward()
+        found = False
+        while not found:
+            while self.peek() == ' ':
+                self.forward()
+            if self.peek() == '#':
+                while self.peek() not in '\0\r\n\x85\u2028\u2029':
+                    self.forward()
+            if self.scan_line_break():
+                if not self.flow_level:
+                    self.allow_simple_key = True
+            else:
+                found = True
+
+    def scan_directive(self):
+        # See the specification for details.
+        start_mark = self.get_mark()
+        self.forward()
+        name = self.scan_directive_name(start_mark)
+        value = None
+        if name == 'YAML':
+            value = self.scan_yaml_directive_value(start_mark)
+            end_mark = self.get_mark()
+        elif name == 'TAG':
+            value = self.scan_tag_directive_value(start_mark)
+            end_mark = self.get_mark()
+        else:
+            end_mark = self.get_mark()
+            while self.peek() not in '\0\r\n\x85\u2028\u2029':
+                self.forward()
+        self.scan_directive_ignored_line(start_mark)
+        return DirectiveToken(name, value, start_mark, end_mark)
+
+    def scan_directive_name(self, start_mark):
+        # See the specification for details.
+        length = 0
+        ch = self.peek(length)
+        while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \
+                or ch in '-_':
+            length += 1
+            ch = self.peek(length)
+        if not length:
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch, self.get_mark())
+        value = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch not in '\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch, self.get_mark())
+        return value
+
+    def scan_yaml_directive_value(self, start_mark):
+        # See the specification for details.
+        while self.peek() == ' ':
+            self.forward()
+        major = self.scan_yaml_directive_number(start_mark)
+        if self.peek() != '.':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a digit or '.', but found %r" % self.peek(),
+                    self.get_mark())
+        self.forward()
+        minor = self.scan_yaml_directive_number(start_mark)
+        if self.peek() not in '\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a digit or ' ', but found %r" % self.peek(),
+                    self.get_mark())
+        return (major, minor)
+
+    def scan_yaml_directive_number(self, start_mark):
+        # See the specification for details.
+        ch = self.peek()
+        if not ('0' <= ch <= '9'):
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a digit, but found %r" % ch, self.get_mark())
+        length = 0
+        while '0' <= self.peek(length) <= '9':
+            length += 1
+        value = int(self.prefix(length))
+        self.forward(length)
+        return value
+
+    def scan_tag_directive_value(self, start_mark):
+        # See the specification for details.
+        while self.peek() == ' ':
+            self.forward()
+        handle = self.scan_tag_directive_handle(start_mark)
+        while self.peek() == ' ':
+            self.forward()
+        prefix = self.scan_tag_directive_prefix(start_mark)
+        return (handle, prefix)
+
+    def scan_tag_directive_handle(self, start_mark):
+        # See the specification for details.
+        value = self.scan_tag_handle('directive', start_mark)
+        ch = self.peek()
+        if ch != ' ':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected ' ', but found %r" % ch, self.get_mark())
+        return value
+
+    def scan_tag_directive_prefix(self, start_mark):
+        # See the specification for details.
+        value = self.scan_tag_uri('directive', start_mark)
+        ch = self.peek()
+        if ch not in '\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected ' ', but found %r" % ch, self.get_mark())
+        return value
+
+    def scan_directive_ignored_line(self, start_mark):
+        # See the specification for details.
+        while self.peek() == ' ':
+            self.forward()
+        if self.peek() == '#':
+            while self.peek() not in '\0\r\n\x85\u2028\u2029':
+                self.forward()
+        ch = self.peek()
+        if ch not in '\0\r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a comment or a line break, but found %r"
+                        % ch, self.get_mark())
+        self.scan_line_break()
+
+    def scan_anchor(self, TokenClass):
+        # The specification does not restrict characters for anchors and
+        # aliases. This may lead to problems, for instance, the document:
+        #   [ *alias, value ]
+        # can be interpreted in two ways, as
+        #   [ "value" ]
+        # and
+        #   [ *alias , "value" ]
+        # Therefore we restrict aliases to numbers and ASCII letters.
+        start_mark = self.get_mark()
+        indicator = self.peek()
+        if indicator == '*':
+            name = 'alias'
+        else:
+            name = 'anchor'
+        self.forward()
+        length = 0
+        ch = self.peek(length)
+        while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \
+                or ch in '-_':
+            length += 1
+            ch = self.peek(length)
+        if not length:
+            raise ScannerError("while scanning an %s" % name, start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch, self.get_mark())
+        value = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch not in '\0 \t\r\n\x85\u2028\u2029?:,]}%@`':
+            raise ScannerError("while scanning an %s" % name, start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch, self.get_mark())
+        end_mark = self.get_mark()
+        return TokenClass(value, start_mark, end_mark)
+
+    def scan_tag(self):
+        # See the specification for details.
+        start_mark = self.get_mark()
+        ch = self.peek(1)
+        if ch == '<':
+            handle = None
+            self.forward(2)
+            suffix = self.scan_tag_uri('tag', start_mark)
+            if self.peek() != '>':
+                raise ScannerError("while parsing a tag", start_mark,
+                        "expected '>', but found %r" % self.peek(),
+                        self.get_mark())
+            self.forward()
+        elif ch in '\0 \t\r\n\x85\u2028\u2029':
+            handle = None
+            suffix = '!'
+            self.forward()
+        else:
+            length = 1
+            use_handle = False
+            while ch not in '\0 \r\n\x85\u2028\u2029':
+                if ch == '!':
+                    use_handle = True
+                    break
+                length += 1
+                ch = self.peek(length)
+            handle = '!'
+            if use_handle:
+                handle = self.scan_tag_handle('tag', start_mark)
+            else:
+                handle = '!'
+                self.forward()
+            suffix = self.scan_tag_uri('tag', start_mark)
+        ch = self.peek()
+        if ch not in '\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a tag", start_mark,
+                    "expected ' ', but found %r" % ch, self.get_mark())
+        value = (handle, suffix)
+        end_mark = self.get_mark()
+        return TagToken(value, start_mark, end_mark)
+
+    def scan_block_scalar(self, style):
+        # See the specification for details.
+
+        if style == '>':
+            folded = True
+        else:
+            folded = False
+
+        chunks = []
+        start_mark = self.get_mark()
+
+        # Scan the header.
+        self.forward()
+        chomping, increment = self.scan_block_scalar_indicators(start_mark)
+        self.scan_block_scalar_ignored_line(start_mark)
+
+        # Determine the indentation level and go to the first non-empty line.
+        min_indent = self.indent+1
+        if min_indent < 1:
+            min_indent = 1
+        if increment is None:
+            breaks, max_indent, end_mark = self.scan_block_scalar_indentation()
+            indent = max(min_indent, max_indent)
+        else:
+            indent = min_indent+increment-1
+            breaks, end_mark = self.scan_block_scalar_breaks(indent)
+        line_break = ''
+
+        # Scan the inner part of the block scalar.
+        while self.column == indent and self.peek() != '\0':
+            chunks.extend(breaks)
+            leading_non_space = self.peek() not in ' \t'
+            length = 0
+            while self.peek(length) not in '\0\r\n\x85\u2028\u2029':
+                length += 1
+            chunks.append(self.prefix(length))
+            self.forward(length)
+            line_break = self.scan_line_break()
+            breaks, end_mark = self.scan_block_scalar_breaks(indent)
+            if self.column == indent and self.peek() != '\0':
+
+                # Unfortunately, folding rules are ambiguous.
+                #
+                # This is the folding according to the specification:
+                
+                if folded and line_break == '\n'    \
+                        and leading_non_space and self.peek() not in ' \t':
+                    if not breaks:
+                        chunks.append(' ')
+                else:
+                    chunks.append(line_break)
+                
+                # This is Clark Evans's interpretation (also in the spec
+                # examples):
+                #
+                #if folded and line_break == '\n':
+                #    if not breaks:
+                #        if self.peek() not in ' \t':
+                #            chunks.append(' ')
+                #        else:
+                #            chunks.append(line_break)
+                #else:
+                #    chunks.append(line_break)
+            else:
+                break
+
+        # Chomp the tail.
+        if chomping is not False:
+            chunks.append(line_break)
+        if chomping is True:
+            chunks.extend(breaks)
+
+        # We are done.
+        return ScalarToken(''.join(chunks), False, start_mark, end_mark,
+                style)
+
+    def scan_block_scalar_indicators(self, start_mark):
+        # See the specification for details.
+        chomping = None
+        increment = None
+        ch = self.peek()
+        if ch in '+-':
+            if ch == '+':
+                chomping = True
+            else:
+                chomping = False
+            self.forward()
+            ch = self.peek()
+            if ch in '0123456789':
+                increment = int(ch)
+                if increment == 0:
+                    raise ScannerError("while scanning a block scalar", start_mark,
+                            "expected indentation indicator in the range 1-9, but found 0",
+                            self.get_mark())
+                self.forward()
+        elif ch in '0123456789':
+            increment = int(ch)
+            if increment == 0:
+                raise ScannerError("while scanning a block scalar", start_mark,
+                        "expected indentation indicator in the range 1-9, but found 0",
+                        self.get_mark())
+            self.forward()
+            ch = self.peek()
+            if ch in '+-':
+                if ch == '+':
+                    chomping = True
+                else:
+                    chomping = False
+                self.forward()
+        ch = self.peek()
+        if ch not in '\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a block scalar", start_mark,
+                    "expected chomping or indentation indicators, but found %r"
+                    % ch, self.get_mark())
+        return chomping, increment
+
+    def scan_block_scalar_ignored_line(self, start_mark):
+        # See the specification for details.
+        while self.peek() == ' ':
+            self.forward()
+        if self.peek() == '#':
+            while self.peek() not in '\0\r\n\x85\u2028\u2029':
+                self.forward()
+        ch = self.peek()
+        if ch not in '\0\r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a block scalar", start_mark,
+                    "expected a comment or a line break, but found %r" % ch,
+                    self.get_mark())
+        self.scan_line_break()
+
+    def scan_block_scalar_indentation(self):
+        # See the specification for details.
+        chunks = []
+        max_indent = 0
+        end_mark = self.get_mark()
+        while self.peek() in ' \r\n\x85\u2028\u2029':
+            if self.peek() != ' ':
+                chunks.append(self.scan_line_break())
+                end_mark = self.get_mark()
+            else:
+                self.forward()
+                if self.column > max_indent:
+                    max_indent = self.column
+        return chunks, max_indent, end_mark
+
+    def scan_block_scalar_breaks(self, indent):
+        # See the specification for details.
+        chunks = []
+        end_mark = self.get_mark()
+        while self.column < indent and self.peek() == ' ':
+            self.forward()
+        while self.peek() in '\r\n\x85\u2028\u2029':
+            chunks.append(self.scan_line_break())
+            end_mark = self.get_mark()
+            while self.column < indent and self.peek() == ' ':
+                self.forward()
+        return chunks, end_mark
+
+    def scan_flow_scalar(self, style):
+        # See the specification for details.
+        # Note that we loose indentation rules for quoted scalars. Quoted
+        # scalars don't need to adhere indentation because " and ' clearly
+        # mark the beginning and the end of them. Therefore we are less
+        # restrictive then the specification requires. We only need to check
+        # that document separators are not included in scalars.
+        if style == '"':
+            double = True
+        else:
+            double = False
+        chunks = []
+        start_mark = self.get_mark()
+        quote = self.peek()
+        self.forward()
+        chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
+        while self.peek() != quote:
+            chunks.extend(self.scan_flow_scalar_spaces(double, start_mark))
+            chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
+        self.forward()
+        end_mark = self.get_mark()
+        return ScalarToken(''.join(chunks), False, start_mark, end_mark,
+                style)
+
+    ESCAPE_REPLACEMENTS = {
+        '0':    '\0',
+        'a':    '\x07',
+        'b':    '\x08',
+        't':    '\x09',
+        '\t':   '\x09',
+        'n':    '\x0A',
+        'v':    '\x0B',
+        'f':    '\x0C',
+        'r':    '\x0D',
+        'e':    '\x1B',
+        ' ':    '\x20',
+        '\"':   '\"',
+        '\\':   '\\',
+        '/':    '/',
+        'N':    '\x85',
+        '_':    '\xA0',
+        'L':    '\u2028',
+        'P':    '\u2029',
+    }
+
+    ESCAPE_CODES = {
+        'x':    2,
+        'u':    4,
+        'U':    8,
+    }
+
+    def scan_flow_scalar_non_spaces(self, double, start_mark):
+        # See the specification for details.
+        chunks = []
+        while True:
+            length = 0
+            while self.peek(length) not in '\'\"\\\0 \t\r\n\x85\u2028\u2029':
+                length += 1
+            if length:
+                chunks.append(self.prefix(length))
+                self.forward(length)
+            ch = self.peek()
+            if not double and ch == '\'' and self.peek(1) == '\'':
+                chunks.append('\'')
+                self.forward(2)
+            elif (double and ch == '\'') or (not double and ch in '\"\\'):
+                chunks.append(ch)
+                self.forward()
+            elif double and ch == '\\':
+                self.forward()
+                ch = self.peek()
+                if ch in self.ESCAPE_REPLACEMENTS:
+                    chunks.append(self.ESCAPE_REPLACEMENTS[ch])
+                    self.forward()
+                elif ch in self.ESCAPE_CODES:
+                    length = self.ESCAPE_CODES[ch]
+                    self.forward()
+                    for k in range(length):
+                        if self.peek(k) not in '0123456789ABCDEFabcdef':
+                            raise ScannerError("while scanning a double-quoted scalar", start_mark,
+                                    "expected escape sequence of %d hexadecimal numbers, but found %r" %
+                                        (length, self.peek(k)), self.get_mark())
+                    code = int(self.prefix(length), 16)
+                    chunks.append(chr(code))
+                    self.forward(length)
+                elif ch in '\r\n\x85\u2028\u2029':
+                    self.scan_line_break()
+                    chunks.extend(self.scan_flow_scalar_breaks(double, start_mark))
+                else:
+                    raise ScannerError("while scanning a double-quoted scalar", start_mark,
+                            "found unknown escape character %r" % ch, self.get_mark())
+            else:
+                return chunks
+
+    def scan_flow_scalar_spaces(self, double, start_mark):
+        # See the specification for details.
+        chunks = []
+        length = 0
+        while self.peek(length) in ' \t':
+            length += 1
+        whitespaces = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch == '\0':
+            raise ScannerError("while scanning a quoted scalar", start_mark,
+                    "found unexpected end of stream", self.get_mark())
+        elif ch in '\r\n\x85\u2028\u2029':
+            line_break = self.scan_line_break()
+            breaks = self.scan_flow_scalar_breaks(double, start_mark)
+            if line_break != '\n':
+                chunks.append(line_break)
+            elif not breaks:
+                chunks.append(' ')
+            chunks.extend(breaks)
+        else:
+            chunks.append(whitespaces)
+        return chunks
+
+    def scan_flow_scalar_breaks(self, double, start_mark):
+        # See the specification for details.
+        chunks = []
+        while True:
+            # Instead of checking indentation, we check for document
+            # separators.
+            prefix = self.prefix(3)
+            if (prefix == '---' or prefix == '...')   \
+                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
+                raise ScannerError("while scanning a quoted scalar", start_mark,
+                        "found unexpected document separator", self.get_mark())
+            while self.peek() in ' \t':
+                self.forward()
+            if self.peek() in '\r\n\x85\u2028\u2029':
+                chunks.append(self.scan_line_break())
+            else:
+                return chunks
+
+    def scan_plain(self):
+        # See the specification for details.
+        # We add an additional restriction for the flow context:
+        #   plain scalars in the flow context cannot contain ',' or '?'.
+        # We also keep track of the `allow_simple_key` flag here.
+        # Indentation rules are loosed for the flow context.
+        chunks = []
+        start_mark = self.get_mark()
+        end_mark = start_mark
+        indent = self.indent+1
+        # We allow zero indentation for scalars, but then we need to check for
+        # document separators at the beginning of the line.
+        #if indent == 0:
+        #    indent = 1
+        spaces = []
+        while True:
+            length = 0
+            if self.peek() == '#':
+                break
+            while True:
+                ch = self.peek(length)
+                if ch in '\0 \t\r\n\x85\u2028\u2029'    \
+                        or (ch == ':' and
+                                self.peek(length+1) in '\0 \t\r\n\x85\u2028\u2029'
+                                      + (u',[]{}' if self.flow_level else u''))\
+                        or (self.flow_level and ch in ',?[]{}'):
+                    break
+                length += 1
+            if length == 0:
+                break
+            self.allow_simple_key = False
+            chunks.extend(spaces)
+            chunks.append(self.prefix(length))
+            self.forward(length)
+            end_mark = self.get_mark()
+            spaces = self.scan_plain_spaces(indent, start_mark)
+            if not spaces or self.peek() == '#' \
+                    or (not self.flow_level and self.column < indent):
+                break
+        return ScalarToken(''.join(chunks), True, start_mark, end_mark)
+
+    def scan_plain_spaces(self, indent, start_mark):
+        # See the specification for details.
+        # The specification is really confusing about tabs in plain scalars.
+        # We just forbid them completely. Do not use tabs in YAML!
+        chunks = []
+        length = 0
+        while self.peek(length) in ' ':
+            length += 1
+        whitespaces = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch in '\r\n\x85\u2028\u2029':
+            line_break = self.scan_line_break()
+            self.allow_simple_key = True
+            prefix = self.prefix(3)
+            if (prefix == '---' or prefix == '...')   \
+                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
+                return
+            breaks = []
+            while self.peek() in ' \r\n\x85\u2028\u2029':
+                if self.peek() == ' ':
+                    self.forward()
+                else:
+                    breaks.append(self.scan_line_break())
+                    prefix = self.prefix(3)
+                    if (prefix == '---' or prefix == '...')   \
+                            and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
+                        return
+            if line_break != '\n':
+                chunks.append(line_break)
+            elif not breaks:
+                chunks.append(' ')
+            chunks.extend(breaks)
+        elif whitespaces:
+            chunks.append(whitespaces)
+        return chunks
+
+    def scan_tag_handle(self, name, start_mark):
+        # See the specification for details.
+        # For some strange reasons, the specification does not allow '_' in
+        # tag handles. I have allowed it anyway.
+        ch = self.peek()
+        if ch != '!':
+            raise ScannerError("while scanning a %s" % name, start_mark,
+                    "expected '!', but found %r" % ch, self.get_mark())
+        length = 1
+        ch = self.peek(length)
+        if ch != ' ':
+            while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \
+                    or ch in '-_':
+                length += 1
+                ch = self.peek(length)
+            if ch != '!':
+                self.forward(length)
+                raise ScannerError("while scanning a %s" % name, start_mark,
+                        "expected '!', but found %r" % ch, self.get_mark())
+            length += 1
+        value = self.prefix(length)
+        self.forward(length)
+        return value
+
+    def scan_tag_uri(self, name, start_mark):
+        # See the specification for details.
+        # Note: we do not check if URI is well-formed.
+        chunks = []
+        length = 0
+        ch = self.peek(length)
+        while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \
+                or ch in '-;/?:@&=+$,_.!~*\'()[]%':
+            if ch == '%':
+                chunks.append(self.prefix(length))
+                self.forward(length)
+                length = 0
+                chunks.append(self.scan_uri_escapes(name, start_mark))
+            else:
+                length += 1
+            ch = self.peek(length)
+        if length:
+            chunks.append(self.prefix(length))
+            self.forward(length)
+            length = 0
+        if not chunks:
+            raise ScannerError("while parsing a %s" % name, start_mark,
+                    "expected URI, but found %r" % ch, self.get_mark())
+        return ''.join(chunks)
+
+    def scan_uri_escapes(self, name, start_mark):
+        # See the specification for details.
+        codes = []
+        mark = self.get_mark()
+        while self.peek() == '%':
+            self.forward()
+            for k in range(2):
+                if self.peek(k) not in '0123456789ABCDEFabcdef':
+                    raise ScannerError("while scanning a %s" % name, start_mark,
+                            "expected URI escape sequence of 2 hexadecimal numbers, but found %r"
+                            % self.peek(k), self.get_mark())
+            codes.append(int(self.prefix(2), 16))
+            self.forward(2)
+        try:
+            value = bytes(codes).decode('utf-8')
+        except UnicodeDecodeError as exc:
+            raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark)
+        return value
+
+    def scan_line_break(self):
+        # Transforms:
+        #   '\r\n'      :   '\n'
+        #   '\r'        :   '\n'
+        #   '\n'        :   '\n'
+        #   '\x85'      :   '\n'
+        #   '\u2028'    :   '\u2028'
+        #   '\u2029     :   '\u2029'
+        #   default     :   ''
+        ch = self.peek()
+        if ch in '\r\n\x85':
+            if self.prefix(2) == '\r\n':
+                self.forward(2)
+            else:
+                self.forward()
+            return '\n'
+        elif ch in '\u2028\u2029':
+            self.forward()
+            return ch
+        return ''
diff --git a/myenv/lib/python3.9/site-packages/yaml/serializer.py b/myenv/lib/python3.9/site-packages/yaml/serializer.py
new file mode 100644
index 0000000..fe911e6
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/serializer.py
@@ -0,0 +1,111 @@
+
+__all__ = ['Serializer', 'SerializerError']
+
+from .error import YAMLError
+from .events import *
+from .nodes import *
+
+class SerializerError(YAMLError):
+    pass
+
+class Serializer:
+
+    ANCHOR_TEMPLATE = 'id%03d'
+
+    def __init__(self, encoding=None,
+            explicit_start=None, explicit_end=None, version=None, tags=None):
+        self.use_encoding = encoding
+        self.use_explicit_start = explicit_start
+        self.use_explicit_end = explicit_end
+        self.use_version = version
+        self.use_tags = tags
+        self.serialized_nodes = {}
+        self.anchors = {}
+        self.last_anchor_id = 0
+        self.closed = None
+
+    def open(self):
+        if self.closed is None:
+            self.emit(StreamStartEvent(encoding=self.use_encoding))
+            self.closed = False
+        elif self.closed:
+            raise SerializerError("serializer is closed")
+        else:
+            raise SerializerError("serializer is already opened")
+
+    def close(self):
+        if self.closed is None:
+            raise SerializerError("serializer is not opened")
+        elif not self.closed:
+            self.emit(StreamEndEvent())
+            self.closed = True
+
+    #def __del__(self):
+    #    self.close()
+
+    def serialize(self, node):
+        if self.closed is None:
+            raise SerializerError("serializer is not opened")
+        elif self.closed:
+            raise SerializerError("serializer is closed")
+        self.emit(DocumentStartEvent(explicit=self.use_explicit_start,
+            version=self.use_version, tags=self.use_tags))
+        self.anchor_node(node)
+        self.serialize_node(node, None, None)
+        self.emit(DocumentEndEvent(explicit=self.use_explicit_end))
+        self.serialized_nodes = {}
+        self.anchors = {}
+        self.last_anchor_id = 0
+
+    def anchor_node(self, node):
+        if node in self.anchors:
+            if self.anchors[node] is None:
+                self.anchors[node] = self.generate_anchor(node)
+        else:
+            self.anchors[node] = None
+            if isinstance(node, SequenceNode):
+                for item in node.value:
+                    self.anchor_node(item)
+            elif isinstance(node, MappingNode):
+                for key, value in node.value:
+                    self.anchor_node(key)
+                    self.anchor_node(value)
+
+    def generate_anchor(self, node):
+        self.last_anchor_id += 1
+        return self.ANCHOR_TEMPLATE % self.last_anchor_id
+
+    def serialize_node(self, node, parent, index):
+        alias = self.anchors[node]
+        if node in self.serialized_nodes:
+            self.emit(AliasEvent(alias))
+        else:
+            self.serialized_nodes[node] = True
+            self.descend_resolver(parent, index)
+            if isinstance(node, ScalarNode):
+                detected_tag = self.resolve(ScalarNode, node.value, (True, False))
+                default_tag = self.resolve(ScalarNode, node.value, (False, True))
+                implicit = (node.tag == detected_tag), (node.tag == default_tag)
+                self.emit(ScalarEvent(alias, node.tag, implicit, node.value,
+                    style=node.style))
+            elif isinstance(node, SequenceNode):
+                implicit = (node.tag
+                            == self.resolve(SequenceNode, node.value, True))
+                self.emit(SequenceStartEvent(alias, node.tag, implicit,
+                    flow_style=node.flow_style))
+                index = 0
+                for item in node.value:
+                    self.serialize_node(item, node, index)
+                    index += 1
+                self.emit(SequenceEndEvent())
+            elif isinstance(node, MappingNode):
+                implicit = (node.tag
+                            == self.resolve(MappingNode, node.value, True))
+                self.emit(MappingStartEvent(alias, node.tag, implicit,
+                    flow_style=node.flow_style))
+                for key, value in node.value:
+                    self.serialize_node(key, node, None)
+                    self.serialize_node(value, node, key)
+                self.emit(MappingEndEvent())
+            self.ascend_resolver()
+
diff --git a/myenv/lib/python3.9/site-packages/yaml/tokens.py b/myenv/lib/python3.9/site-packages/yaml/tokens.py
new file mode 100644
index 0000000..4d0b48a
--- /dev/null
+++ b/myenv/lib/python3.9/site-packages/yaml/tokens.py
@@ -0,0 +1,104 @@
+
+class Token(object):
+    def __init__(self, start_mark, end_mark):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+    def __repr__(self):
+        attributes = [key for key in self.__dict__
+                if not key.endswith('_mark')]
+        attributes.sort()
+        arguments = ', '.join(['%s=%r' % (key, getattr(self, key))
+                for key in attributes])
+        return '%s(%s)' % (self.__class__.__name__, arguments)
+
+#class BOMToken(Token):
+#    id = '<byte order mark>'
+
+class DirectiveToken(Token):
+    id = '<directive>'
+    def __init__(self, name, value, start_mark, end_mark):
+        self.name = name
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class DocumentStartToken(Token):
+    id = '<document start>'
+
+class DocumentEndToken(Token):
+    id = '<document end>'
+
+class StreamStartToken(Token):
+    id = '<stream start>'
+    def __init__(self, start_mark=None, end_mark=None,
+            encoding=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.encoding = encoding
+
+class StreamEndToken(Token):
+    id = '<stream end>'
+
+class BlockSequenceStartToken(Token):
+    id = '<block sequence start>'
+
+class BlockMappingStartToken(Token):
+    id = '<block mapping start>'
+
+class BlockEndToken(Token):
+    id = '<block end>'
+
+class FlowSequenceStartToken(Token):
+    id = '['
+
+class FlowMappingStartToken(Token):
+    id = '{'
+
+class FlowSequenceEndToken(Token):
+    id = ']'
+
+class FlowMappingEndToken(Token):
+    id = '}'
+
+class KeyToken(Token):
+    id = '?'
+
+class ValueToken(Token):
+    id = ':'
+
+class BlockEntryToken(Token):
+    id = '-'
+
+class FlowEntryToken(Token):
+    id = ','
+
+class AliasToken(Token):
+    id = '<alias>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class AnchorToken(Token):
+    id = '<anchor>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class TagToken(Token):
+    id = '<tag>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class ScalarToken(Token):
+    id = '<scalar>'
+    def __init__(self, value, plain, start_mark, end_mark, style=None):
+        self.value = value
+        self.plain = plain
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.style = style
+
diff --git a/myenv/pyvenv.cfg b/myenv/pyvenv.cfg
new file mode 100644
index 0000000..2c2789b
--- /dev/null
+++ b/myenv/pyvenv.cfg
@@ -0,0 +1,3 @@
+home = /Library/Frameworks/Python.framework/Versions/3.9/bin
+include-system-site-packages = false
+version = 3.9.1
diff --git a/myenv/share/doc/networkx-2.8.5/LICENSE.txt b/myenv/share/doc/networkx-2.8.5/LICENSE.txt
new file mode 100644
index 0000000..a274a66
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/LICENSE.txt
@@ -0,0 +1,37 @@
+NetworkX is distributed with the 3-clause BSD license.
+
+::
+
+   Copyright (C) 2004-2022, NetworkX Developers
+   Aric Hagberg <hagberg@lanl.gov>
+   Dan Schult <dschult@colgate.edu>
+   Pieter Swart <swart@lanl.gov>
+   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 NetworkX Developers nor the names of its
+       contributors may be used to endorse or promote products derived
+       from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/myenv/share/doc/networkx-2.8.5/examples/3d_drawing/README.txt b/myenv/share/doc/networkx-2.8.5/examples/3d_drawing/README.txt
new file mode 100644
index 0000000..1a76682
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/3d_drawing/README.txt
@@ -0,0 +1,2 @@
+3D Drawing
+----------
diff --git a/myenv/share/doc/networkx-2.8.5/examples/3d_drawing/mayavi2_spring.py b/myenv/share/doc/networkx-2.8.5/examples/3d_drawing/mayavi2_spring.py
new file mode 100644
index 0000000..bec0969
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/3d_drawing/mayavi2_spring.py
@@ -0,0 +1,43 @@
+"""
+=======
+Mayavi2
+=======
+
+"""
+
+import networkx as nx
+import numpy as np
+from mayavi import mlab
+
+# some graphs to try
+# H=nx.krackhardt_kite_graph()
+# H=nx.Graph();H.add_edge('a','b');H.add_edge('a','c');H.add_edge('a','d')
+# H=nx.grid_2d_graph(4,5)
+H = nx.cycle_graph(20)
+
+# reorder nodes from 0,len(G)-1
+G = nx.convert_node_labels_to_integers(H)
+# 3d spring layout
+pos = nx.spring_layout(G, dim=3, seed=1001)
+# numpy array of x,y,z positions in sorted node order
+xyz = np.array([pos[v] for v in sorted(G)])
+# scalar colors
+scalars = np.array(list(G.nodes())) + 5
+
+mlab.figure()
+
+pts = mlab.points3d(
+    xyz[:, 0],
+    xyz[:, 1],
+    xyz[:, 2],
+    scalars,
+    scale_factor=0.1,
+    scale_mode="none",
+    colormap="Blues",
+    resolution=20,
+)
+
+pts.mlab_source.dataset.lines = np.array(list(G.edges()))
+tube = mlab.pipeline.tube(pts, tube_radius=0.01)
+mlab.pipeline.surface(tube, color=(0.8, 0.8, 0.8))
+mlab.orientation_axes()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/3d_drawing/plot_basic.py b/myenv/share/doc/networkx-2.8.5/examples/3d_drawing/plot_basic.py
new file mode 100644
index 0000000..75a9c79
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/3d_drawing/plot_basic.py
@@ -0,0 +1,51 @@
+"""
+================
+Basic matplotlib
+================
+
+A basic example of 3D Graph visualization using `mpl_toolkits.mplot_3d`.
+
+"""
+
+import networkx as nx
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+
+# The graph to visualize
+G = nx.cycle_graph(20)
+
+# 3d spring layout
+pos = nx.spring_layout(G, dim=3, seed=779)
+# Extract node and edge positions from the layout
+node_xyz = np.array([pos[v] for v in sorted(G)])
+edge_xyz = np.array([(pos[u], pos[v]) for u, v in G.edges()])
+
+# Create the 3D figure
+fig = plt.figure()
+ax = fig.add_subplot(111, projection="3d")
+
+# Plot the nodes - alpha is scaled by "depth" automatically
+ax.scatter(*node_xyz.T, s=100, ec="w")
+
+# Plot the edges
+for vizedge in edge_xyz:
+    ax.plot(*vizedge.T, color="tab:gray")
+
+
+def _format_axes(ax):
+    """Visualization options for the 3D axes."""
+    # Turn gridlines off
+    ax.grid(False)
+    # Suppress tick labels
+    for dim in (ax.xaxis, ax.yaxis, ax.zaxis):
+        dim.set_ticks([])
+    # Set axes labels
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    ax.set_zlabel("z")
+
+
+_format_axes(ax)
+fig.tight_layout()
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/README.txt b/myenv/share/doc/networkx-2.8.5/examples/README.txt
new file mode 100644
index 0000000..d0049bd
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/README.txt
@@ -0,0 +1,8 @@
+.. _examples_gallery:
+
+Gallery
+=======
+
+General-purpose and introductory examples for NetworkX.
+The `tutorial <../tutorial.html>`_ introduces conventions and basic graph
+manipulations.
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/README.txt b/myenv/share/doc/networkx-2.8.5/examples/algorithms/README.txt
new file mode 100644
index 0000000..a78a4d7
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/README.txt
@@ -0,0 +1,2 @@
+Algorithms
+----------
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/WormNet.v3.benchmark.txt b/myenv/share/doc/networkx-2.8.5/examples/algorithms/WormNet.v3.benchmark.txt
new file mode 100644
index 0000000..824cfa1
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/WormNet.v3.benchmark.txt
@@ -0,0 +1,78736 @@
+C41D11.8	AH9.2
+CD4.2	AH9.2
+K12H4.8	AH9.2
+T07A9.5	AH9.2
+Y113G7A.9	AH9.2
+Y47G6A.8	AH9.2
+Y48B6A.3	AH9.2
+Y56A3A.32	AH9.2
+ZC513.5	B0024.13
+F21F3.5	B0207.12
+K11G12.2	B0207.12
+K11G12.7	B0207.12
+ZC482.1	B0207.12
+C02C6.1	B0207.3
+C09G12.8	B0207.3
+C16A11.1	B0207.3
+C26C6.2	B0207.3
+C33H5.14	B0207.3
+C34D1.3	B0207.3
+C35C5.4	B0207.3
+C38D4.8	B0207.3
+C44F1.5	B0207.3
+C55H1.2	B0207.3
+E02C12.5	B0207.3
+F18E2.5	B0207.3
+F18G5.3	B0207.3
+F22B5.1	B0207.3
+F26H9.6	B0207.3
+F29C12.4	B0207.3
+F38E1.5	B0207.3
+F48C11.1	B0207.3
+F53B1.7	B0207.3
+F56H9.3	B0207.3
+F56H9.4	B0207.3
+K03D3.10	B0207.3
+M01D7.7	B0207.3
+M04C7.1	B0207.3
+R06A10.2	B0207.3
+R07G3.1	B0207.3
+R10H10.5	B0207.3
+T01C2.1	B0207.3
+T07A9.7	B0207.3
+T19C4.6	B0207.3
+W03C9.3	B0207.3
+W03F8.9	B0207.3
+Y51H4A.3	B0207.3
+Y71H2B.7	B0207.3
+Y95B8A.5	B0207.3
+C07A9.3	B0207.4
+F15A2.6	B0207.4
+F43C1.2	B0207.4
+F49E11.1	B0207.4
+F58H12.1	B0207.4
+K07A9.2	B0207.4
+M03A1.1	B0207.4
+T04B2.2	B0207.4
+T25E12.4	B0207.4
+W09C5.5	B0207.4
+Y55D5A.5	B0207.4
+Y60A3A.1	B0207.4
+C10E2.3	B0218.3
+C15H9.6	B0218.3
+C25B8.1	B0218.3
+F42G8.3	B0218.3
+F42G8.4	B0218.3
+F57B10.11	B0218.3
+F58H12.1	B0218.3
+K08H10.1	B0218.3
+Y41C4A.4	B0218.3
+B0238.13	B0238.1
+B0238.7	B0238.1
+C01B10.10	B0238.1
+C01B10.4	B0238.1
+C17H12.4	B0238.1
+C23H4.2	B0238.1
+C23H4.3	B0238.1
+C23H4.7	B0238.1
+C40C9.5	B0238.1
+C42D4.2	B0238.1
+C52A10.1	B0238.1
+C52A10.2	B0238.1
+E01G6.3	B0238.1
+F07C4.12	B0238.1
+F13H6.3	B0238.1
+F13H6.4	B0238.1
+F15A8.6	B0238.1
+F55D10.3	B0238.1
+F55F3.2	B0238.1
+F56C11.6	B0238.1
+K07C11.4	B0238.1
+K11G9.1	B0238.1
+K11G9.2	B0238.1
+K11G9.3	B0238.1
+R12A1.4	B0238.1
+R173.3	B0238.1
+T02B5.1	B0238.1
+T02B5.3	B0238.1
+T22D1.11	B0238.1
+T28C12.4	B0238.1
+T28C12.5	B0238.1
+W02B12.4	B0238.1
+W09B12.1	B0238.1
+Y44E3A.2	B0238.1
+Y48B6A.7	B0238.1
+Y48B6A.8	B0238.1
+Y71H2AM.13	B0238.1
+Y75B8A.3	B0238.1
+ZC376.1	B0238.1
+ZC376.2	B0238.1
+ZC376.3	B0238.1
+ZK994.1	B0238.1
+B0238.7	B0238.13
+C01B10.10	B0238.13
+C01B10.4	B0238.13
+C17H12.4	B0238.13
+C23H4.2	B0238.13
+C23H4.3	B0238.13
+C23H4.7	B0238.13
+C40C9.5	B0238.13
+C42D4.2	B0238.13
+C52A10.1	B0238.13
+C52A10.2	B0238.13
+E01G6.3	B0238.13
+F07C4.12	B0238.13
+F13H6.3	B0238.13
+F13H6.4	B0238.13
+F15A8.6	B0238.13
+F55D10.3	B0238.13
+F55F3.2	B0238.13
+F56C11.6	B0238.13
+K07C11.4	B0238.13
+K11G9.1	B0238.13
+K11G9.2	B0238.13
+K11G9.3	B0238.13
+R12A1.4	B0238.13
+R173.3	B0238.13
+T02B5.1	B0238.13
+T02B5.3	B0238.13
+T22D1.11	B0238.13
+T28C12.4	B0238.13
+T28C12.5	B0238.13
+W02B12.4	B0238.13
+W09B12.1	B0238.13
+Y44E3A.2	B0238.13
+Y48B6A.7	B0238.13
+Y48B6A.8	B0238.13
+Y71H2AM.13	B0238.13
+Y75B8A.3	B0238.13
+ZC376.1	B0238.13
+ZC376.2	B0238.13
+ZC376.3	B0238.13
+ZK994.1	B0238.13
+C01B10.10	B0238.7
+C01B10.4	B0238.7
+C17H12.4	B0238.7
+C23H4.2	B0238.7
+C23H4.3	B0238.7
+C23H4.7	B0238.7
+C40C9.5	B0238.7
+C42D4.2	B0238.7
+C52A10.1	B0238.7
+C52A10.2	B0238.7
+E01G6.3	B0238.7
+F07C4.12	B0238.7
+F13H6.3	B0238.7
+F13H6.4	B0238.7
+F15A8.6	B0238.7
+F55D10.3	B0238.7
+F55F3.2	B0238.7
+F56C11.6	B0238.7
+K07C11.4	B0238.7
+K11G9.1	B0238.7
+K11G9.2	B0238.7
+K11G9.3	B0238.7
+R12A1.4	B0238.7
+R173.3	B0238.7
+T02B5.1	B0238.7
+T02B5.3	B0238.7
+T22D1.11	B0238.7
+T28C12.4	B0238.7
+T28C12.5	B0238.7
+W02B12.4	B0238.7
+W09B12.1	B0238.7
+Y44E3A.2	B0238.7
+Y48B6A.7	B0238.7
+Y48B6A.8	B0238.7
+Y71H2AM.13	B0238.7
+Y75B8A.3	B0238.7
+ZC376.1	B0238.7
+ZC376.2	B0238.7
+ZC376.3	B0238.7
+ZK994.1	B0238.7
+C09G4.1	B0252.2
+R05D11.9	B0252.2
+W03G1.7	B0252.2
+ZK455.4	B0252.2
+C05E4.9	B0286.5
+C25A1.2	B0286.5
+C29F7.4	B0286.5
+C29F7.5	B0286.5
+C47G2.2	B0286.5
+F26A1.2	B0286.5
+F26B1.7	B0286.5
+F26D12.1	B0286.5
+F27E11.3	B0286.5
+F38A6.1	B0286.5
+F40H3.4	B0286.5
+K10G6.1	B0286.5
+T14G12.4	B0286.5
+T28H11.4	B0286.5
+Y34D9B.1	B0286.5
+Y37E11AR.6	B0286.5
+Y71F9B.5	B0286.5
+Y73B6BL.21	B0286.5
+ZK265.4	B0286.5
+B0336.1	B0304.1
+C04A2.3	B0304.1
+C08F8.8	B0304.1
+C16A3.1	B0304.1
+C18A3.8	B0304.1
+C25A1.11	B0304.1
+C26B2.6	B0304.1
+C33D3.1	B0304.1
+C38D4.6	B0304.1
+C47E8.7	B0304.1
+C47G2.2	B0304.1
+C48D5.1	B0304.1
+C54D1.6	B0304.1
+F11A1.3	B0304.1
+F21H11.3	B0304.1
+F38A6.3	B0304.1
+F46G10.6	B0304.1
+F54F7.1	B0304.1
+F56E3.4	B0304.1
+JC8.6	B0304.1
+K03A11.3	B0304.1
+K05C4.6	B0304.1
+M05B5.5	B0304.1
+R06A4.7	B0304.1
+R13H8.1	B0304.1
+T07C4.2	B0304.1
+T07C4.6	B0304.1
+T28H11.4	B0304.1
+W02C12.3	B0304.1
+W09C2.1	B0304.1
+W10C8.2	B0304.1
+Y47D3B.7	B0304.1
+ZK328.8	B0304.1
+ZK863.3	B0304.1
+C09H6.2	B0334.11
+C05E11.1	B0336.1
+C05H8.1	B0336.1
+C06G1.4	B0336.1
+C07A9.3	B0336.1
+C08F8.8	B0336.1
+C33D3.1	B0336.1
+C38D4.6	B0336.1
+C44H4.5	B0336.1
+C47G2.2	B0336.1
+C48D5.1	B0336.1
+C54D1.6	B0336.1
+F11A1.3	B0336.1
+F54F7.1	B0336.1
+F56E3.4	B0336.1
+K05C4.6	B0336.1
+R13H8.1	B0336.1
+T28H11.4	B0336.1
+W09C2.1	B0336.1
+W10C8.2	B0336.1
+C24A3.6	B0365.3
+C24G7.2	B0365.3
+C25B8.1	B0365.3
+C53C9.3	B0365.3
+F02D10.5	B0365.3
+F08B12.3	B0365.3
+F16B3.1	B0365.3
+F34D6.3	B0365.3
+H16O14.1	B0365.3
+H35N03.1	B0365.3
+R13A1.2	B0365.3
+T06H11.1	B0365.3
+Y51A2D.19	B0365.3
+Y54G9A.3	B0365.3
+B0432.3	B0393.1
+C16C10.2	B0393.1
+F33D4.8	B0393.1
+F37C12.11	B0393.1
+R03G5.1	B0393.1
+T08B2.10	B0393.1
+T12G3.5	B0393.1
+Y105E8A.16	B0393.1
+Y41D4B.5	B0393.1
+Y57G11C.34	B0393.1
+C05B5.7	B0393.2
+C29H12.3	B0393.2
+C41G11.3	B0393.2
+F16H9.1	B0393.2
+F28C1.2	B0393.2
+F45B8.1	B0393.2
+F45B8.2	B0393.2
+F52D2.2	B0393.2
+F56B6.2	B0393.2
+K08E3.6	B0393.2
+T07C4.8	B0393.2
+Y38E10A.21	B0393.2
+ZC53.7	B0393.2
+C16C10.2	B0432.3
+F33D4.8	B0432.3
+R03G5.1	B0432.3
+T12G3.5	B0432.3
+Y105E8A.16	B0432.3
+Y57G11C.34	B0432.3
+C05D2.4	B0432.5
+C24F3.2	B0478.1
+T07A9.3	B0478.1
+C05C8.3	B0511.1
+C50F2.6	B0511.1
+D1009.2	B0511.1
+F31D4.3	B0511.1
+Y17G7B.9	B0511.1
+Y18D10A.19	B0511.1
+Y18D10A.25	B0511.1
+Y75B12B.5	B0511.1
+ZC455.10	B0511.1
+Y23H5A.7	B0511.2
+K10B3.9	B0546.1
+C01B10.4	C01B10.10
+C17H12.4	C01B10.10
+C23H4.2	C01B10.10
+C23H4.3	C01B10.10
+C23H4.7	C01B10.10
+C40C9.5	C01B10.10
+C42D4.2	C01B10.10
+C52A10.1	C01B10.10
+C52A10.2	C01B10.10
+E01G6.3	C01B10.10
+F07C4.12	C01B10.10
+F13H6.3	C01B10.10
+F13H6.4	C01B10.10
+F15A8.6	C01B10.10
+F55D10.3	C01B10.10
+F55F3.2	C01B10.10
+F56C11.6	C01B10.10
+K07C11.4	C01B10.10
+K11G9.1	C01B10.10
+K11G9.2	C01B10.10
+K11G9.3	C01B10.10
+R12A1.4	C01B10.10
+R173.3	C01B10.10
+T02B5.1	C01B10.10
+T02B5.3	C01B10.10
+T22D1.11	C01B10.10
+T28C12.4	C01B10.10
+T28C12.5	C01B10.10
+W02B12.4	C01B10.10
+W09B12.1	C01B10.10
+Y44E3A.2	C01B10.10
+Y48B6A.7	C01B10.10
+Y48B6A.8	C01B10.10
+Y71H2AM.13	C01B10.10
+Y75B8A.3	C01B10.10
+ZC376.1	C01B10.10
+ZC376.2	C01B10.10
+ZC376.3	C01B10.10
+ZK994.1	C01B10.10
+C17H12.4	C01B10.4
+C23H4.2	C01B10.4
+C23H4.3	C01B10.4
+C23H4.7	C01B10.4
+C40C9.5	C01B10.4
+C42D4.2	C01B10.4
+C52A10.1	C01B10.4
+C52A10.2	C01B10.4
+E01G6.3	C01B10.4
+F07C4.12	C01B10.4
+F13H6.3	C01B10.4
+F13H6.4	C01B10.4
+F15A8.6	C01B10.4
+F55D10.3	C01B10.4
+F55F3.2	C01B10.4
+F56C11.6	C01B10.4
+K07C11.4	C01B10.4
+K11G9.1	C01B10.4
+K11G9.2	C01B10.4
+K11G9.3	C01B10.4
+R12A1.4	C01B10.4
+R173.3	C01B10.4
+T02B5.1	C01B10.4
+T02B5.3	C01B10.4
+T22D1.11	C01B10.4
+T28C12.4	C01B10.4
+T28C12.5	C01B10.4
+W02B12.4	C01B10.4
+W09B12.1	C01B10.4
+Y44E3A.2	C01B10.4
+Y48B6A.7	C01B10.4
+Y48B6A.8	C01B10.4
+Y71H2AM.13	C01B10.4
+Y75B8A.3	C01B10.4
+ZC376.1	C01B10.4
+ZC376.2	C01B10.4
+ZC376.3	C01B10.4
+ZK994.1	C01B10.4
+C16C10.5	C01B7.6
+C35B1.1	C01B7.6
+C36A4.8	C01B7.6
+K04C2.4	C01B7.6
+M7.1	C01B7.6
+R01H2.6	C01B7.6
+T05H10.5	C01B7.6
+T09B4.10	C01B7.6
+T24C4.6	C01B7.6
+Y65B4BR.4	C01B7.6
+C25A1.10	C01G10.11
+F45E10.1	C01G10.11
+K02A4.2	C01G10.11
+C32C4.2	C01G6.1
+F40F9.9	C01G6.1
+M02F4.8	C01G6.1
+Y69E1A.7	C01G6.1
+F07B10.1	C01G8.2
+ZC190.1	C01G8.2
+C09G12.8	C02C6.1
+C16A11.1	C02C6.1
+C26C6.2	C02C6.1
+C33H5.14	C02C6.1
+C34D1.3	C02C6.1
+C35C5.4	C02C6.1
+C38D4.8	C02C6.1
+C55H1.2	C02C6.1
+E02C12.5	C02C6.1
+F18E2.5	C02C6.1
+F18G5.3	C02C6.1
+F22B5.1	C02C6.1
+F26H9.6	C02C6.1
+F29C12.4	C02C6.1
+F38E1.5	C02C6.1
+F48C11.1	C02C6.1
+F53B1.7	C02C6.1
+F56H9.3	C02C6.1
+F56H9.4	C02C6.1
+K03D3.10	C02C6.1
+M01D7.7	C02C6.1
+M04C7.1	C02C6.1
+R06A10.2	C02C6.1
+R07G3.1	C02C6.1
+R10H10.5	C02C6.1
+T07A9.7	C02C6.1
+T19C4.6	C02C6.1
+W03C9.3	C02C6.1
+W03F8.9	C02C6.1
+Y51H4A.3	C02C6.1
+Y71H2B.7	C02C6.1
+Y95B8A.5	C02C6.1
+C24A8.1	C02D4.2
+K02F2.6	C02D4.2
+Y47H9C.4	C02F5.1
+C25A1.3	C03D6.3
+Y53F4B.13	C03D6.3
+C03G6.19	C03G6.18
+C05E4.1	C03G6.18
+C05E4.3	C03G6.18
+C28G1.2	C03G6.18
+F20D6.3	C03G6.18
+F20D6.4	C03G6.18
+M01G12.2	C03G6.18
+M01G12.5	C03G6.18
+R01H2.4	C03G6.18
+Y32G9A.4	C03G6.18
+C05E4.1	C03G6.19
+C05E4.3	C03G6.19
+C28G1.2	C03G6.19
+F20D6.3	C03G6.19
+F20D6.4	C03G6.19
+M01G12.2	C03G6.19
+M01G12.5	C03G6.19
+R01H2.4	C03G6.19
+Y32G9A.4	C03G6.19
+C16A3.1	C04A2.3
+C26B2.6	C04A2.3
+F21H11.3	C04A2.3
+JC8.6	C04A2.3
+K03A11.3	C04A2.3
+R06A4.7	C04A2.3
+T07C4.2	C04A2.3
+T07C4.6	C04A2.3
+W10C8.2	C04A2.3
+ZK328.8	C04A2.3
+ZK863.3	C04A2.3
+C10H11.9	C04D8.1
+F18G5.3	C04D8.1
+K09H11.3	C04D8.1
+T24C12.2	C04D8.1
+Y75B7AL.4	C04D8.1
+ZK899.8	C04D8.1
+C09D8.1	C04F12.8
+C16A3.2	C04F12.8
+C17G10.4	C04F12.8
+F13D11.3	C04F12.8
+F26A3.4	C04F12.8
+K06A4.3	C04F6.4
+C09D8.1	C05B10.1
+C24F3.2	C05B10.1
+F08B1.1	C05B10.1
+F28C6.8	C05B10.1
+F56D1.4	C05B10.1
+K08B4.1	C05B10.1
+R07G3.5	C05B10.1
+R107.8	C05B10.1
+W08G11.4	C05B10.1
+W09H1.1	C05B10.1
+Y54F10BM.13	C05B10.1
+ZK757.2	C05B10.1
+C29H12.3	C05B5.7
+C41G11.3	C05B5.7
+F16H9.1	C05B5.7
+F28C1.2	C05B5.7
+F45B8.1	C05B5.7
+F45B8.2	C05B5.7
+F52D2.2	C05B5.7
+F56B6.2	C05B5.7
+K08E3.6	C05B5.7
+T07C4.8	C05B5.7
+Y38E10A.21	C05B5.7
+ZC53.7	C05B5.7
+C50F2.6	C05C8.3
+D1009.2	C05C8.3
+F31D4.3	C05C8.3
+Y17G7B.9	C05C8.3
+Y18D10A.19	C05C8.3
+Y18D10A.25	C05C8.3
+Y75B12B.5	C05C8.3
+ZC455.10	C05C8.3
+C06G1.4	C05E11.1
+C05E4.3	C05E4.1
+C28G1.2	C05E4.1
+F20D6.3	C05E4.1
+F20D6.4	C05E4.1
+M01G12.2	C05E4.1
+M01G12.5	C05E4.1
+R01H2.4	C05E4.1
+Y32G9A.4	C05E4.1
+C28G1.2	C05E4.3
+F20D6.3	C05E4.3
+F20D6.4	C05E4.3
+M01G12.2	C05E4.3
+M01G12.5	C05E4.3
+R01H2.4	C05E4.3
+Y32G9A.4	C05E4.3
+C25A1.2	C05E4.9
+C29F7.4	C05E4.9
+C29F7.5	C05E4.9
+F26A1.2	C05E4.9
+F26B1.7	C05E4.9
+F26D12.1	C05E4.9
+F27E11.3	C05E4.9
+F40H3.4	C05E4.9
+K10G6.1	C05E4.9
+Y34D9B.1	C05E4.9
+Y37E11AR.6	C05E4.9
+Y71F9B.5	C05E4.9
+Y73B6BL.21	C05E4.9
+C07A9.3	C05H8.1
+C08F8.8	C05H8.1
+C14F5.1	C05H8.1
+C44H4.5	C05H8.1
+C48D5.1	C05H8.1
+D1007.1	C05H8.1
+F11A1.3	C05H8.1
+F52B5.5	C05H8.1
+F56E3.4	C05H8.1
+F58A3.1	C05H8.1
+F59C12.2	C05H8.1
+K07A9.2	C05H8.1
+R07B1.1	C05H8.1
+T20B12.2	C05H8.1
+W03A3.1	C05H8.1
+W09C2.1	C05H8.1
+Y11D7A.12	C05H8.1
+C33H5.14	C06A1.1
+C41C4.8	C06A1.1
+C52E12.2	C06A1.1
+C52E4.4	C06A1.1
+F32D1.1	C06A1.1
+H12C20.2	C06A1.1
+K04G2.3	C06A1.1
+T28A8.7	C06A1.1
+W06H8.1	C06A1.1
+Y43C5A.6	C06A1.1
+ZK637.5	C06A1.1
+C08G5.1	C06C3.8
+C24B5.2	C06C3.8
+C34B2.6	C06C3.8
+F46F5.5	C06C3.8
+R13H4.6	C06C3.8
+Y75B8A.4	C06C3.8
+C44B7.12	C06G3.5
+C44H4.5	C07A9.3
+F49E11.1	C07A9.3
+F58H12.1	C07A9.3
+K07A9.2	C07A9.3
+T04B2.2	C07A9.3
+Y55D5A.5	C07A9.3
+Y60A3A.1	C07A9.3
+C56A3.7	C07F11.1
+D1009.2	C07G2.3
+F22B7.5	C07G2.3
+F43E2.8	C07G2.3
+F57B10.11	C07G2.3
+K01C8.10	C07G2.3
+T27D1.1	C07G2.3
+Y75B12B.5	C07G2.3
+C29A12.3	C07H6.1
+K07C5.3	C07H6.1
+C17D12.2	C07H6.5
+C37E2.5	C07H6.6
+C10E2.3	C08B11.2
+C53A5.3	C08B11.2
+F02E9.4	C08B11.2
+F52E1.1	C08B11.2
+F54F7.1	C08B11.2
+K05C4.6	C08B11.2
+R06C1.1	C08B11.2
+Y49E10.14	C08B11.2
+Y51H1A.5	C08B11.2
+F29B9.6	C08B6.9
+W02A11.4	C08B6.9
+W10D5.3	C08B6.9
+C14F5.1	C08F8.8
+C33D3.1	C08F8.8
+C38D4.6	C08F8.8
+C47G2.2	C08F8.8
+C48D5.1	C08F8.8
+C54D1.6	C08F8.8
+D1007.1	C08F8.8
+F11A1.3	C08F8.8
+F52B5.5	C08F8.8
+F54F7.1	C08F8.8
+F56E3.4	C08F8.8
+F58A3.1	C08F8.8
+K05C4.6	C08F8.8
+R07B1.1	C08F8.8
+R13H8.1	C08F8.8
+T20B12.2	C08F8.8
+T28H11.4	C08F8.8
+W03A3.1	C08F8.8
+W09C2.1	C08F8.8
+W10C8.2	C08F8.8
+Y11D7A.12	C08F8.8
+C24B5.2	C08G5.1
+C34B2.6	C08G5.1
+F46F5.5	C08G5.1
+R13H4.6	C08G5.1
+Y75B8A.4	C08G5.1
+C16A3.2	C09D8.1
+C17G10.4	C09D8.1
+C24F3.2	C09D8.1
+F08B1.1	C09D8.1
+F13D11.3	C09D8.1
+F26A3.4	C09D8.1
+F28C6.8	C09D8.1
+F56D1.4	C09D8.1
+R07G3.5	C09D8.1
+W08G11.4	C09D8.1
+W09H1.1	C09D8.1
+Y54F10BM.13	C09D8.1
+ZK757.2	C09D8.1
+C16A11.1	C09G12.8
+C26C6.2	C09G12.8
+C33H5.14	C09G12.8
+C34D1.3	C09G12.8
+C35C5.4	C09G12.8
+C38D4.8	C09G12.8
+C55H1.2	C09G12.8
+E02C12.5	C09G12.8
+F18E2.5	C09G12.8
+F18G5.3	C09G12.8
+F22B5.1	C09G12.8
+F26H9.6	C09G12.8
+F29C12.4	C09G12.8
+F38E1.5	C09G12.8
+F48C11.1	C09G12.8
+F53B1.7	C09G12.8
+F54B11.3	C09G12.8
+F56H9.3	C09G12.8
+F56H9.4	C09G12.8
+K03D3.10	C09G12.8
+M01D7.7	C09G12.8
+M04C7.1	C09G12.8
+R06A10.2	C09G12.8
+R07G3.1	C09G12.8
+R10H10.5	C09G12.8
+T07A9.7	C09G12.8
+T19C4.6	C09G12.8
+W01A11.3	C09G12.8
+W03C9.3	C09G12.8
+W03F8.9	C09G12.8
+Y51H4A.3	C09G12.8
+Y55F3AL.1	C09G12.8
+Y71H2B.7	C09G12.8
+Y95B8A.5	C09G12.8
+R13H8.1	C09G4.1
+W03G1.7	C09G4.1
+ZK455.4	C09G4.1
+F54C1.3	C09G4.5
+R06A4.7	C09G4.5
+F59F5.6	C09H6.2
+Y43H11AL.3	C09H6.3
+C25B8.1	C10E2.3
+C53A5.3	C10E2.3
+F02E9.4	C10E2.3
+F42G8.3	C10E2.3
+K08F11.5	C10E2.3
+R06C1.1	C10E2.3
+Y41C4A.4	C10E2.3
+Y51H1A.5	C10E2.3
+R11D1.11	C10F3.4
+F18G5.3	C10H11.9
+F18A11.1	C12C8.3
+W06B11.2	C12C8.3
+Y113G7B.5	C12C8.3
+R05F9.6	C13B9.4
+W09C2.3	C13B9.4
+F20C5.1	C14C11.3
+T14F9.3	C14C11.3
+T20G5.2	C14C11.3
+Y39A1C.4	C14C11.3
+Y51F10.5	C14C11.3
+Y70D2A.2	C14C11.3
+C48D5.1	C14F5.1
+D1007.1	C14F5.1
+F11A1.3	C14F5.1
+F20D6.11	C14F5.1
+F52B5.5	C14F5.1
+F56E3.4	C14F5.1
+F58A3.1	C14F5.1
+R07B1.1	C14F5.1
+T20B12.2	C14F5.1
+W03A3.1	C14F5.1
+W09C2.1	C14F5.1
+Y11D7A.12	C14F5.1
+Y37H9A.6	C14F5.1
+F55D10.3	C15B12.5
+T10H9.4	C15B12.5
+W09B12.1	C15B12.5
+Y48B6A.7	C15B12.5
+Y48B6A.8	C15B12.5
+F01G12.2	C15B12.7
+F35C8.4	C15C7.1
+F48F7.2	C15C7.1
+F55A11.2	C15C7.1
+T01B11.3	C15C7.1
+F55H2.1	C15F1.7
+ZK430.3	C15F1.7
+F42G8.3	C15H9.6
+F42G8.4	C15H9.6
+F57B10.11	C15H9.6
+F58H12.1	C15H9.6
+K08H10.1	C15H9.6
+C26C6.2	C16A11.1
+C33H5.14	C16A11.1
+C34D1.3	C16A11.1
+C35C5.4	C16A11.1
+C38D4.8	C16A11.1
+C44F1.5	C16A11.1
+C55H1.2	C16A11.1
+E02C12.5	C16A11.1
+F18E2.5	C16A11.1
+F18G5.3	C16A11.1
+F22B5.1	C16A11.1
+F26H9.6	C16A11.1
+F29C12.4	C16A11.1
+F38E1.5	C16A11.1
+F48C11.1	C16A11.1
+F53B1.7	C16A11.1
+F56H9.3	C16A11.1
+F56H9.4	C16A11.1
+K03D3.10	C16A11.1
+M01D7.7	C16A11.1
+M04C7.1	C16A11.1
+R06A10.2	C16A11.1
+R07G3.1	C16A11.1
+R10H10.5	C16A11.1
+T01C2.1	C16A11.1
+T07A9.7	C16A11.1
+T19C4.6	C16A11.1
+W03C9.3	C16A11.1
+W03F8.9	C16A11.1
+Y51H4A.3	C16A11.1
+Y71H2B.7	C16A11.1
+Y95B8A.5	C16A11.1
+C26B2.6	C16A3.1
+F18C5.2	C16A3.1
+F21H11.3	C16A3.1
+F43G6.1	C16A3.1
+JC8.6	C16A3.1
+K03A11.3	C16A3.1
+R06A4.7	C16A3.1
+T07C4.2	C16A3.1
+T07C4.6	C16A3.1
+W10C8.2	C16A3.1
+ZK328.8	C16A3.1
+ZK863.3	C16A3.1
+C17G10.4	C16A3.2
+F13D11.3	C16A3.2
+F26A3.4	C16A3.2
+F33D4.8	C16C10.2
+R03G5.1	C16C10.2
+T12G3.5	C16C10.2
+Y105E8A.16	C16C10.2
+Y57G11C.34	C16C10.2
+C35B1.1	C16C10.5
+C36A4.8	C16C10.5
+K04C2.4	C16C10.5
+M7.1	C16C10.5
+R01H2.6	C16C10.5
+T05H10.5	C16C10.5
+T09B4.10	C16C10.5
+T24C4.6	C16C10.5
+Y65B4BR.4	C16C10.5
+C34D4.14	C16C10.7
+F35G12.9	C16C10.7
+F36A2.13	C16C10.7
+F45H7.6	C16C10.7
+M142.6	C16C10.7
+M7.1	C16C10.7
+Y39A1C.2	C16C10.7
+Y48G8AL.1	C16C10.7
+Y65B4BR.4	C16C10.7
+Y67D8C.5	C16C10.7
+Y92H12A.2	C16C10.7
+F28C1.2	C16C2.2
+F13D11.3	C17G10.4
+F26A3.4	C17G10.4
+C23H4.2	C17H12.4
+C23H4.3	C17H12.4
+C23H4.7	C17H12.4
+C40C9.5	C17H12.4
+C42D4.2	C17H12.4
+C52A10.1	C17H12.4
+C52A10.2	C17H12.4
+E01G6.3	C17H12.4
+F07C4.12	C17H12.4
+F13H6.3	C17H12.4
+F13H6.4	C17H12.4
+F15A8.6	C17H12.4
+F55D10.3	C17H12.4
+F55F3.2	C17H12.4
+F56C11.6	C17H12.4
+K07C11.4	C17H12.4
+K11G9.1	C17H12.4
+K11G9.2	C17H12.4
+K11G9.3	C17H12.4
+R12A1.4	C17H12.4
+R173.3	C17H12.4
+T02B5.1	C17H12.4
+T02B5.3	C17H12.4
+T22D1.11	C17H12.4
+T28C12.4	C17H12.4
+T28C12.5	C17H12.4
+W02B12.4	C17H12.4
+W09B12.1	C17H12.4
+Y44E3A.2	C17H12.4
+Y48B6A.7	C17H12.4
+Y48B6A.8	C17H12.4
+Y71H2AM.13	C17H12.4
+Y75B8A.3	C17H12.4
+ZC376.1	C17H12.4
+ZC376.2	C17H12.4
+ZC376.3	C17H12.4
+ZK994.1	C17H12.4
+C25A1.11	C18A3.8
+F38A6.3	C18A3.8
+F46G10.6	C18A3.8
+M05B5.5	C18A3.8
+W02C12.3	C18A3.8
+Y47D3B.7	C18A3.8
+T08A9.3	C18C4.10
+C41C4.5	C18E3.8
+F35H12.3	C18E3.8
+K01A11.4	C18E3.8
+W09C2.3	C18E3.8
+Y73F8A.1	C18E3.8
+ZK256.1	C18E3.8
+ZK524.1	C18E3.8
+C23H4.3	C23H4.2
+C23H4.7	C23H4.2
+C40C9.5	C23H4.2
+C42D4.2	C23H4.2
+C52A10.1	C23H4.2
+C52A10.2	C23H4.2
+E01G6.3	C23H4.2
+F07C4.12	C23H4.2
+F13H6.3	C23H4.2
+F13H6.4	C23H4.2
+F15A8.6	C23H4.2
+F55D10.3	C23H4.2
+F55F3.2	C23H4.2
+F56C11.6	C23H4.2
+K07C11.4	C23H4.2
+K11G9.1	C23H4.2
+K11G9.2	C23H4.2
+K11G9.3	C23H4.2
+R12A1.4	C23H4.2
+R173.3	C23H4.2
+T02B5.1	C23H4.2
+T02B5.3	C23H4.2
+T22D1.11	C23H4.2
+T28C12.4	C23H4.2
+T28C12.5	C23H4.2
+W02B12.4	C23H4.2
+W09B12.1	C23H4.2
+Y44E3A.2	C23H4.2
+Y48B6A.7	C23H4.2
+Y48B6A.8	C23H4.2
+Y71H2AM.13	C23H4.2
+Y75B8A.3	C23H4.2
+ZC376.1	C23H4.2
+ZC376.2	C23H4.2
+ZC376.3	C23H4.2
+ZK994.1	C23H4.2
+C23H4.7	C23H4.3
+C40C9.5	C23H4.3
+C42D4.2	C23H4.3
+C52A10.1	C23H4.3
+C52A10.2	C23H4.3
+E01G6.3	C23H4.3
+F07C4.12	C23H4.3
+F13H6.3	C23H4.3
+F13H6.4	C23H4.3
+F15A8.6	C23H4.3
+F55D10.3	C23H4.3
+F55F3.2	C23H4.3
+F56C11.6	C23H4.3
+K07C11.4	C23H4.3
+K11G9.1	C23H4.3
+K11G9.2	C23H4.3
+K11G9.3	C23H4.3
+R12A1.4	C23H4.3
+R173.3	C23H4.3
+T02B5.1	C23H4.3
+T02B5.3	C23H4.3
+T22D1.11	C23H4.3
+T28C12.4	C23H4.3
+T28C12.5	C23H4.3
+W02B12.4	C23H4.3
+W09B12.1	C23H4.3
+Y44E3A.2	C23H4.3
+Y48B6A.7	C23H4.3
+Y48B6A.8	C23H4.3
+Y71H2AM.13	C23H4.3
+Y75B8A.3	C23H4.3
+ZC376.1	C23H4.3
+ZC376.2	C23H4.3
+ZC376.3	C23H4.3
+ZK994.1	C23H4.3
+C40C9.5	C23H4.7
+C42D4.2	C23H4.7
+C52A10.1	C23H4.7
+C52A10.2	C23H4.7
+E01G6.3	C23H4.7
+F07C4.12	C23H4.7
+F13H6.3	C23H4.7
+F13H6.4	C23H4.7
+F15A8.6	C23H4.7
+F55D10.3	C23H4.7
+F55F3.2	C23H4.7
+F56C11.6	C23H4.7
+K07C11.4	C23H4.7
+K11G9.1	C23H4.7
+K11G9.2	C23H4.7
+K11G9.3	C23H4.7
+R12A1.4	C23H4.7
+R173.3	C23H4.7
+T02B5.1	C23H4.7
+T02B5.3	C23H4.7
+T22D1.11	C23H4.7
+T28C12.4	C23H4.7
+T28C12.5	C23H4.7
+W02B12.4	C23H4.7
+W09B12.1	C23H4.7
+Y44E3A.2	C23H4.7
+Y48B6A.7	C23H4.7
+Y48B6A.8	C23H4.7
+Y71H2AM.13	C23H4.7
+Y75B8A.3	C23H4.7
+ZC376.1	C23H4.7
+ZC376.2	C23H4.7
+ZC376.3	C23H4.7
+ZK994.1	C23H4.7
+C25B8.1	C24A3.6
+C53C9.3	C24A3.6
+F08B12.3	C24A3.6
+F16B3.1	C24A3.6
+F34D6.3	C24A3.6
+H16O14.1	C24A3.6
+H35N03.1	C24A3.6
+R13A1.2	C24A3.6
+T06H11.1	C24A3.6
+Y51A2D.19	C24A3.6
+Y54G9A.3	C24A3.6
+C34B2.6	C24B5.2
+F46F5.5	C24B5.2
+F57B10.12	C24B5.2
+R13H4.6	C24B5.2
+F08B1.1	C24F3.2
+F28C6.8	C24F3.2
+F56D1.4	C24F3.2
+R07G3.5	C24F3.2
+W08G11.4	C24F3.2
+W09H1.1	C24F3.2
+Y54F10BM.13	C24F3.2
+ZK757.2	C24F3.2
+F02D10.5	C24G7.2
+H35N03.1	C24G7.2
+F45E10.1	C25A1.10
+K02A4.2	C25A1.10
+Y53F4B.15	C25A1.10
+C41G7.5	C25A1.11
+F38A6.3	C25A1.11
+F46G10.6	C25A1.11
+M05B5.5	C25A1.11
+W02C12.3	C25A1.11
+Y47D3B.7	C25A1.11
+C29F7.4	C25A1.2
+C29F7.5	C25A1.2
+C47G2.2	C25A1.2
+F26A1.2	C25A1.2
+F26B1.7	C25A1.2
+F26D12.1	C25A1.2
+F27E11.3	C25A1.2
+F38A6.1	C25A1.2
+F40H3.4	C25A1.2
+K10G6.1	C25A1.2
+T14G12.4	C25A1.2
+T28H11.4	C25A1.2
+Y34D9B.1	C25A1.2
+Y37E11AR.6	C25A1.2
+Y71F9B.5	C25A1.2
+Y73B6BL.21	C25A1.2
+ZK265.4	C25A1.2
+Y53F4B.13	C25A1.3
+C53C9.3	C25B8.1
+F08B12.3	C25B8.1
+F16B3.1	C25B8.1
+F34D6.3	C25B8.1
+F42G8.3	C25B8.1
+H16O14.1	C25B8.1
+H35N03.1	C25B8.1
+R13A1.2	C25B8.1
+T06H11.1	C25B8.1
+Y41C4A.4	C25B8.1
+Y51A2D.19	C25B8.1
+Y54G9A.3	C25B8.1
+F13H8.7	C25F6.3
+ZK783.2	C25F6.3
+F21H11.3	C26B2.6
+JC8.6	C26B2.6
+K03A11.3	C26B2.6
+R06A4.7	C26B2.6
+T07C4.2	C26B2.6
+T07C4.6	C26B2.6
+W10C8.2	C26B2.6
+ZK328.8	C26B2.6
+ZK863.3	C26B2.6
+C33H5.14	C26C6.2
+C34D1.3	C26C6.2
+C35C5.4	C26C6.2
+C38D4.8	C26C6.2
+C44F1.5	C26C6.2
+C55H1.2	C26C6.2
+E02C12.5	C26C6.2
+F18E2.5	C26C6.2
+F18G5.3	C26C6.2
+F22B5.1	C26C6.2
+F26H9.6	C26C6.2
+F29C12.4	C26C6.2
+F38E1.5	C26C6.2
+F48C11.1	C26C6.2
+F53B1.7	C26C6.2
+F56H9.3	C26C6.2
+F56H9.4	C26C6.2
+K03D3.10	C26C6.2
+M01D7.7	C26C6.2
+M04C7.1	C26C6.2
+R06A10.2	C26C6.2
+R07G3.1	C26C6.2
+R10H10.5	C26C6.2
+T01C2.1	C26C6.2
+T07A9.7	C26C6.2
+T19C4.6	C26C6.2
+W03C9.3	C26C6.2
+W03F8.9	C26C6.2
+Y51H4A.3	C26C6.2
+Y71H2B.7	C26C6.2
+Y95B8A.5	C26C6.2
+T12D8.1	C26E6.9
+C39E6.6	C26F1.10
+F33D4.3	C26F1.10
+F49E10.3	C26F1.10
+K10B4.4	C26F1.10
+W07E11.2	C26F1.10
+Y23B4A.2	C26F1.10
+Y48D7A.2	C26F1.10
+C54G7.4	C27A7.4
+F46F6.4	C27A7.4
+M04C9.5	C27A7.4
+ZK520.3	C27A7.4
+C54D1.6	C28A5.4
+T03G11.8	C28A5.4
+F20D6.3	C28G1.2
+F20D6.4	C28G1.2
+M01G12.2	C28G1.2
+M01G12.5	C28G1.2
+R01H2.4	C28G1.2
+Y32G9A.4	C28G1.2
+K07C5.3	C29A12.3
+Y54G2A.17	C29E4.7
+F09G8.9	C29F5.4
+K01A2.8	C29F5.4
+T06A4.2	C29F5.4
+C29F7.5	C29F7.4
+C47G2.2	C29F7.4
+F26A1.2	C29F7.4
+F26B1.7	C29F7.4
+F26D12.1	C29F7.4
+F27E11.3	C29F7.4
+F38A6.1	C29F7.4
+F40H3.4	C29F7.4
+K10G6.1	C29F7.4
+T14G12.4	C29F7.4
+T28H11.4	C29F7.4
+Y34D9B.1	C29F7.4
+Y37E11AR.6	C29F7.4
+Y71F9B.5	C29F7.4
+Y73B6BL.21	C29F7.4
+ZK265.4	C29F7.4
+C47G2.2	C29F7.5
+F26A1.2	C29F7.5
+F26B1.7	C29F7.5
+F26D12.1	C29F7.5
+F27E11.3	C29F7.5
+F38A6.1	C29F7.5
+F40H3.4	C29F7.5
+K10G6.1	C29F7.5
+T14G12.4	C29F7.5
+T28H11.4	C29F7.5
+Y34D9B.1	C29F7.5
+Y37E11AR.6	C29F7.5
+Y71F9B.5	C29F7.5
+Y73B6BL.21	C29F7.5
+ZK265.4	C29F7.5
+C41G11.3	C29H12.3
+F16H9.1	C29H12.3
+F28C1.2	C29H12.3
+F45B8.1	C29H12.3
+F45B8.2	C29H12.3
+F52D2.2	C29H12.3
+F56B6.2	C29H12.3
+K08E3.6	C29H12.3
+T07C4.8	C29H12.3
+Y38E10A.21	C29H12.3
+ZC53.7	C29H12.3
+C40H1.1	C30G12.7
+Y54E10A.4	C30G12.7
+F40F9.9	C32C4.2
+M02F4.8	C32C4.2
+Y69E1A.7	C32C4.2
+C38D4.6	C33D3.1
+C47G2.2	C33D3.1
+C48D5.1	C33D3.1
+C54D1.6	C33D3.1
+F11A1.3	C33D3.1
+F54F7.1	C33D3.1
+F56E3.4	C33D3.1
+K05C4.6	C33D3.1
+R13H8.1	C33D3.1
+T28H11.4	C33D3.1
+W09C2.1	C33D3.1
+W10C8.2	C33D3.1
+C34D1.3	C33H5.14
+C35C5.4	C33H5.14
+C38D4.8	C33H5.14
+C41C4.8	C33H5.14
+C52E12.2	C33H5.14
+C52E4.4	C33H5.14
+C55H1.2	C33H5.14
+E02C12.5	C33H5.14
+F18E2.5	C33H5.14
+F18G5.3	C33H5.14
+F22B5.1	C33H5.14
+F26H9.6	C33H5.14
+F29C12.4	C33H5.14
+F32D1.1	C33H5.14
+F38E1.5	C33H5.14
+F48C11.1	C33H5.14
+F53B1.7	C33H5.14
+F56H9.3	C33H5.14
+F56H9.4	C33H5.14
+H12C20.2	C33H5.14
+K03D3.10	C33H5.14
+K04G2.3	C33H5.14
+K08H10.4	C33H5.14
+M01D7.7	C33H5.14
+M04C7.1	C33H5.14
+R06A10.2	C33H5.14
+R07G3.1	C33H5.14
+R10H10.5	C33H5.14
+T07A9.7	C33H5.14
+T19C4.6	C33H5.14
+T28A8.7	C33H5.14
+W03C9.3	C33H5.14
+W03F8.9	C33H5.14
+W06H8.1	C33H5.14
+Y43C5A.6	C33H5.14
+Y51H4A.3	C33H5.14
+Y71H2B.7	C33H5.14
+Y95B8A.5	C33H5.14
+ZK637.5	C33H5.14
+F46F5.5	C34B2.6
+R13H4.6	C34B2.6
+Y75B8A.4	C34B2.6
+C35C5.4	C34D1.3
+C38D4.8	C34D1.3
+C44F1.5	C34D1.3
+C55H1.2	C34D1.3
+E02C12.5	C34D1.3
+F18E2.5	C34D1.3
+F18G5.3	C34D1.3
+F22B5.1	C34D1.3
+F26H9.6	C34D1.3
+F29C12.4	C34D1.3
+F38E1.5	C34D1.3
+F48C11.1	C34D1.3
+F53B1.7	C34D1.3
+F56H9.3	C34D1.3
+F56H9.4	C34D1.3
+K03D3.10	C34D1.3
+M01D7.7	C34D1.3
+M04C7.1	C34D1.3
+R06A10.2	C34D1.3
+R07G3.1	C34D1.3
+R10H10.5	C34D1.3
+T01C2.1	C34D1.3
+T07A9.7	C34D1.3
+T19C4.6	C34D1.3
+W03C9.3	C34D1.3
+W03F8.9	C34D1.3
+Y51H4A.3	C34D1.3
+Y71H2B.7	C34D1.3
+Y95B8A.5	C34D1.3
+F35G12.9	C34D4.14
+F36A2.13	C34D4.14
+F45H7.6	C34D4.14
+M142.6	C34D4.14
+M7.1	C34D4.14
+Y39A1C.2	C34D4.14
+Y48G8AL.1	C34D4.14
+Y65B4BR.4	C34D4.14
+Y67D8C.5	C34D4.14
+Y92H12A.2	C34D4.14
+F28F9.1	C34E10.5
+F44A6.2	C34E10.5
+T23G7.1	C34E10.5
+T28F2.4	C34E10.5
+W02D3.9	C34E10.5
+Y102A5C.18	C34E10.5
+C36A4.8	C35B1.1
+K04C2.4	C35B1.1
+M7.1	C35B1.1
+R01H2.6	C35B1.1
+T05H10.5	C35B1.1
+T09B4.10	C35B1.1
+T24C4.6	C35B1.1
+Y47G6A.8	C35B1.1
+Y65B4BR.4	C35B1.1
+C38D4.8	C35C5.4
+C55H1.2	C35C5.4
+E02C12.5	C35C5.4
+F18E2.5	C35C5.4
+F18G5.3	C35C5.4
+F22B5.1	C35C5.4
+F26H9.6	C35C5.4
+F29C12.4	C35C5.4
+F38E1.5	C35C5.4
+F48C11.1	C35C5.4
+F53B1.7	C35C5.4
+F56H9.3	C35C5.4
+F56H9.4	C35C5.4
+K03D3.10	C35C5.4
+M01D7.7	C35C5.4
+M04C7.1	C35C5.4
+R06A10.2	C35C5.4
+R07G3.1	C35C5.4
+R10H10.5	C35C5.4
+T07A9.7	C35C5.4
+T19C4.6	C35C5.4
+W03C9.3	C35C5.4
+W03F8.9	C35C5.4
+Y51H4A.3	C35C5.4
+Y71H2B.7	C35C5.4
+Y95B8A.5	C35C5.4
+F57B10.10	C35D10.9
+K04C2.4	C36A4.8
+M7.1	C36A4.8
+R01H2.6	C36A4.8
+T05H10.5	C36A4.8
+T09B4.10	C36A4.8
+T24C4.6	C36A4.8
+Y65B4BR.4	C36A4.8
+F39H11.3	C37A2.4
+Y39G10AL.3	C37E2.5
+F55C7.7	C38C3.5
+C47G2.2	C38D4.6
+C48D5.1	C38D4.6
+C54D1.6	C38D4.6
+F11A1.3	C38D4.6
+F54F7.1	C38D4.6
+F56E3.4	C38D4.6
+K05C4.6	C38D4.6
+R13H8.1	C38D4.6
+T28H11.4	C38D4.6
+W09C2.1	C38D4.6
+W10C8.2	C38D4.6
+C55H1.2	C38D4.8
+E02C12.5	C38D4.8
+F18E2.5	C38D4.8
+F18G5.3	C38D4.8
+F22B5.1	C38D4.8
+F26H9.6	C38D4.8
+F29C12.4	C38D4.8
+F38E1.5	C38D4.8
+F48C11.1	C38D4.8
+F53B1.7	C38D4.8
+F56H9.3	C38D4.8
+F56H9.4	C38D4.8
+K03D3.10	C38D4.8
+M01D7.7	C38D4.8
+M04C7.1	C38D4.8
+R06A10.2	C38D4.8
+R07G3.1	C38D4.8
+R10H10.5	C38D4.8
+T07A9.7	C38D4.8
+T19C4.6	C38D4.8
+W03C9.3	C38D4.8
+W03F8.9	C38D4.8
+Y51H4A.3	C38D4.8
+Y71H2B.7	C38D4.8
+Y95B8A.5	C38D4.8
+F33D4.3	C39E6.6
+F49E10.3	C39E6.6
+K10B4.4	C39E6.6
+W07E11.2	C39E6.6
+Y23B4A.2	C39E6.6
+Y48D7A.2	C39E6.6
+C42D4.2	C40C9.5
+C52A10.1	C40C9.5
+C52A10.2	C40C9.5
+E01G6.3	C40C9.5
+F07C4.12	C40C9.5
+F13H6.3	C40C9.5
+F13H6.4	C40C9.5
+F15A8.6	C40C9.5
+F55D10.3	C40C9.5
+F55F3.2	C40C9.5
+F56C11.6	C40C9.5
+K07C11.4	C40C9.5
+K11G9.1	C40C9.5
+K11G9.2	C40C9.5
+K11G9.3	C40C9.5
+R12A1.4	C40C9.5
+R173.3	C40C9.5
+T02B5.1	C40C9.5
+T02B5.3	C40C9.5
+T22D1.11	C40C9.5
+T28C12.4	C40C9.5
+T28C12.5	C40C9.5
+W02B12.4	C40C9.5
+W09B12.1	C40C9.5
+Y44E3A.2	C40C9.5
+Y48B6A.7	C40C9.5
+Y48B6A.8	C40C9.5
+Y71H2AM.13	C40C9.5
+Y75B8A.3	C40C9.5
+ZC376.1	C40C9.5
+ZC376.2	C40C9.5
+ZC376.3	C40C9.5
+ZK994.1	C40C9.5
+Y54E10A.4	C40H1.1
+F35H12.3	C41C4.5
+K01A11.4	C41C4.5
+W09C2.3	C41C4.5
+Y73F8A.1	C41C4.5
+ZK256.1	C41C4.5
+ZK524.1	C41C4.5
+C52E12.2	C41C4.8
+C52E4.4	C41C4.8
+F32D1.1	C41C4.8
+H12C20.2	C41C4.8
+K04G2.3	C41C4.8
+T28A8.7	C41C4.8
+W06H8.1	C41C4.8
+Y43C5A.6	C41C4.8
+ZK637.5	C41C4.8
+CD4.2	C41D11.8
+K12H4.8	C41D11.8
+Y47G6A.8	C41D11.8
+Y56A3A.32	C41D11.8
+F16H9.1	C41G11.3
+F28C1.2	C41G11.3
+F45B8.1	C41G11.3
+F45B8.2	C41G11.3
+F52D2.2	C41G11.3
+F56B6.2	C41G11.3
+K08E3.6	C41G11.3
+T07C4.8	C41G11.3
+Y38E10A.21	C41G11.3
+ZC53.7	C41G11.3
+C52A10.1	C42D4.2
+C52A10.2	C42D4.2
+E01G6.3	C42D4.2
+F07C4.12	C42D4.2
+F13H6.3	C42D4.2
+F13H6.4	C42D4.2
+F15A8.6	C42D4.2
+F55D10.3	C42D4.2
+F55F3.2	C42D4.2
+F56C11.6	C42D4.2
+K07C11.4	C42D4.2
+K11G9.1	C42D4.2
+K11G9.2	C42D4.2
+K11G9.3	C42D4.2
+R12A1.4	C42D4.2
+R173.3	C42D4.2
+T02B5.1	C42D4.2
+T02B5.3	C42D4.2
+T22D1.11	C42D4.2
+T28C12.4	C42D4.2
+T28C12.5	C42D4.2
+W02B12.4	C42D4.2
+W09B12.1	C42D4.2
+Y44E3A.2	C42D4.2
+Y48B6A.7	C42D4.2
+Y48B6A.8	C42D4.2
+Y71H2AM.13	C42D4.2
+Y75B8A.3	C42D4.2
+ZC376.1	C42D4.2
+ZC376.2	C42D4.2
+ZC376.3	C42D4.2
+ZK994.1	C42D4.2
+C54C6.2	C44B11.3
+C55H1.2	C44F1.5
+E02C12.5	C44F1.5
+F18E2.5	C44F1.5
+F18G5.3	C44F1.5
+F38E1.5	C44F1.5
+F48C11.1	C44F1.5
+F53B1.7	C44F1.5
+F56H9.3	C44F1.5
+F56H9.4	C44F1.5
+M01D7.7	C44F1.5
+M04C7.1	C44F1.5
+R10H10.5	C44F1.5
+T01C2.1	C44F1.5
+T07A9.7	C44F1.5
+T19C4.6	C44F1.5
+W03F8.9	C44F1.5
+Y71H2B.7	C44F1.5
+Y95B8A.5	C44F1.5
+F09E8.3	C47D12.8
+H26D21.2	C47D12.8
+K12D12.1	C47D12.8
+R05D3.1	C47D12.8
+R05D3.12	C47D12.8
+T02G5.6	C47D12.8
+Y46H3C.4	C47D12.8
+Y47G6A.11	C47D12.8
+ZK1127.11	C47D12.8
+C55B7.1	C47D2.2
+F49E8.4	C47D2.2
+T21G5.3	C47D2.2
+R06C7.3	C47E12.8
+C48D5.1	C47G2.2
+C54D1.6	C47G2.2
+F11A1.3	C47G2.2
+F26A1.2	C47G2.2
+F26B1.7	C47G2.2
+F26D12.1	C47G2.2
+F38A6.1	C47G2.2
+F40H3.4	C47G2.2
+F54F7.1	C47G2.2
+F56E3.4	C47G2.2
+K05C4.6	C47G2.2
+K10G6.1	C47G2.2
+R13H8.1	C47G2.2
+T14G12.4	C47G2.2
+T28H11.4	C47G2.2
+W09C2.1	C47G2.2
+W10C8.2	C47G2.2
+ZK265.4	C47G2.2
+M01G5.5	C48D1.3
+C54D1.6	C48D5.1
+D1007.1	C48D5.1
+F11A1.3	C48D5.1
+F52B5.5	C48D5.1
+F54F7.1	C48D5.1
+F56E3.4	C48D5.1
+F58A3.1	C48D5.1
+K05C4.6	C48D5.1
+R07B1.1	C48D5.1
+R13H8.1	C48D5.1
+T20B12.2	C48D5.1
+T28H11.4	C48D5.1
+W03A3.1	C48D5.1
+W09C2.1	C48D5.1
+W10C8.2	C48D5.1
+Y11D7A.12	C48D5.1
+T26C12.4	C49H3.1
+ZK896.8	C49H3.1
+ZK1236.3	C50E10.4
+D1009.2	C50F2.6
+F31D4.3	C50F2.6
+Y17G7B.9	C50F2.6
+Y18D10A.19	C50F2.6
+Y18D10A.25	C50F2.6
+Y75B12B.5	C50F2.6
+ZC455.10	C50F2.6
+C52A10.2	C52A10.1
+E01G6.3	C52A10.1
+F07C4.12	C52A10.1
+F13H6.3	C52A10.1
+F13H6.4	C52A10.1
+F15A8.6	C52A10.1
+F55D10.3	C52A10.1
+F55F3.2	C52A10.1
+F56C11.6	C52A10.1
+K07C11.4	C52A10.1
+K11G9.1	C52A10.1
+K11G9.2	C52A10.1
+K11G9.3	C52A10.1
+R12A1.4	C52A10.1
+R173.3	C52A10.1
+T02B5.1	C52A10.1
+T02B5.3	C52A10.1
+T22D1.11	C52A10.1
+T28C12.4	C52A10.1
+T28C12.5	C52A10.1
+W02B12.4	C52A10.1
+W09B12.1	C52A10.1
+Y44E3A.2	C52A10.1
+Y48B6A.7	C52A10.1
+Y48B6A.8	C52A10.1
+Y71H2AM.13	C52A10.1
+Y75B8A.3	C52A10.1
+ZC376.1	C52A10.1
+ZC376.2	C52A10.1
+ZC376.3	C52A10.1
+ZK994.1	C52A10.1
+E01G6.3	C52A10.2
+F07C4.12	C52A10.2
+F13H6.3	C52A10.2
+F13H6.4	C52A10.2
+F15A8.6	C52A10.2
+F55D10.3	C52A10.2
+F55F3.2	C52A10.2
+F56C11.6	C52A10.2
+K07C11.4	C52A10.2
+K11G9.1	C52A10.2
+K11G9.2	C52A10.2
+K11G9.3	C52A10.2
+R12A1.4	C52A10.2
+R173.3	C52A10.2
+T02B5.1	C52A10.2
+T02B5.3	C52A10.2
+T22D1.11	C52A10.2
+T28C12.4	C52A10.2
+T28C12.5	C52A10.2
+W02B12.4	C52A10.2
+W09B12.1	C52A10.2
+Y44E3A.2	C52A10.2
+Y48B6A.7	C52A10.2
+Y48B6A.8	C52A10.2
+Y71H2AM.13	C52A10.2
+Y75B8A.3	C52A10.2
+ZC376.1	C52A10.2
+ZC376.2	C52A10.2
+ZC376.3	C52A10.2
+ZK994.1	C52A10.2
+F15A8.5	C52B11.3
+R06A10.2	C52B11.3
+C52E4.4	C52E12.2
+F32D1.1	C52E12.2
+H12C20.2	C52E12.2
+K04G2.3	C52E12.2
+T28A8.7	C52E12.2
+W06H8.1	C52E12.2
+Y43C5A.6	C52E12.2
+ZK637.5	C52E12.2
+F32D1.1	C52E4.4
+H12C20.2	C52E4.4
+K04G2.3	C52E4.4
+T28A8.7	C52E4.4
+W06H8.1	C52E4.4
+Y38C1AA.2	C52E4.4
+Y43C5A.6	C52E4.4
+ZK637.5	C52E4.4
+F02E9.4	C53A5.3
+R06C1.1	C53A5.3
+Y51H1A.5	C53A5.3
+F56H6.5	C53B4.7
+R01H2.5	C53B4.7
+F08B12.3	C53C9.3
+F16B3.1	C53C9.3
+F34D6.3	C53C9.3
+H16O14.1	C53C9.3
+H35N03.1	C53C9.3
+R13A1.2	C53C9.3
+T06H11.1	C53C9.3
+Y51A2D.19	C53C9.3
+Y54G9A.3	C53C9.3
+F11A1.3	C54D1.6
+F54F7.1	C54D1.6
+F56E3.4	C54D1.6
+K05C4.6	C54D1.6
+R13H8.1	C54D1.6
+T03G11.8	C54D1.6
+T28H11.4	C54D1.6
+W09C2.1	C54D1.6
+W10C8.2	C54D1.6
+F46F6.4	C54G7.4
+M04C9.5	C54G7.4
+ZK520.3	C54G7.4
+T21G5.3	C55B7.1
+E02C12.5	C55H1.2
+F18E2.5	C55H1.2
+F18G5.3	C55H1.2
+F22B5.1	C55H1.2
+F26H9.6	C55H1.2
+F29C12.4	C55H1.2
+F38E1.5	C55H1.2
+F48C11.1	C55H1.2
+F53B1.7	C55H1.2
+F56H9.3	C55H1.2
+F56H9.4	C55H1.2
+K03D3.10	C55H1.2
+M01D7.7	C55H1.2
+M04C7.1	C55H1.2
+R06A10.2	C55H1.2
+R07G3.1	C55H1.2
+R10H10.5	C55H1.2
+T01C2.1	C55H1.2
+T07A9.7	C55H1.2
+T19C4.6	C55H1.2
+W03C9.3	C55H1.2
+W03F8.9	C55H1.2
+Y51H4A.3	C55H1.2
+Y71H2B.7	C55H1.2
+Y95B8A.5	C55H1.2
+Y47G6A.8	CD4.2
+Y56A3A.32	CD4.2
+F11A1.3	D1007.1
+F52B5.5	D1007.1
+F56E3.4	D1007.1
+F58A3.1	D1007.1
+R07B1.1	D1007.1
+T20B12.2	D1007.1
+W03A3.1	D1007.1
+W09C2.1	D1007.1
+Y11D7A.12	D1007.1
+F22B7.5	D1009.2
+F31D4.3	D1009.2
+F43E2.8	D1009.2
+F57B10.11	D1009.2
+K01C8.10	D1009.2
+T27D1.1	D1009.2
+Y17G7B.9	D1009.2
+Y18D10A.19	D1009.2
+Y18D10A.25	D1009.2
+Y75B12B.5	D1009.2
+ZC455.10	D1009.2
+F27E11.3	E01A2.3
+F31E3.1	E01A2.3
+F38E1.7	E01A2.3
+K10B4.6	E01A2.3
+T23D8.1	E01A2.3
+W01B6.1	E01A2.3
+W08D2.1	E01A2.3
+W10C8.2	E01A2.3
+Y34D9B.1	E01A2.3
+Y54G2A.1	E01A2.3
+Y71F9B.5	E01A2.3
+Y73B6BL.21	E01A2.3
+F07C4.12	E01G6.3
+F13H6.3	E01G6.3
+F13H6.4	E01G6.3
+F15A8.6	E01G6.3
+F55D10.3	E01G6.3
+F55F3.2	E01G6.3
+F56C11.6	E01G6.3
+K07C11.4	E01G6.3
+K11G9.1	E01G6.3
+K11G9.2	E01G6.3
+K11G9.3	E01G6.3
+R12A1.4	E01G6.3
+R173.3	E01G6.3
+T02B5.1	E01G6.3
+T02B5.3	E01G6.3
+T22D1.11	E01G6.3
+T28C12.4	E01G6.3
+T28C12.5	E01G6.3
+W02B12.4	E01G6.3
+W09B12.1	E01G6.3
+Y44E3A.2	E01G6.3
+Y48B6A.7	E01G6.3
+Y48B6A.8	E01G6.3
+Y71H2AM.13	E01G6.3
+Y75B8A.3	E01G6.3
+ZC376.1	E01G6.3
+ZC376.2	E01G6.3
+ZC376.3	E01G6.3
+ZK994.1	E01G6.3
+F18E2.5	E02C12.5
+F18G5.3	E02C12.5
+F22B5.1	E02C12.5
+F26H9.6	E02C12.5
+F29C12.4	E02C12.5
+F38E1.5	E02C12.5
+F48C11.1	E02C12.5
+F53B1.7	E02C12.5
+F56H9.3	E02C12.5
+F56H9.4	E02C12.5
+K03D3.10	E02C12.5
+M01D7.7	E02C12.5
+M04C7.1	E02C12.5
+R06A10.2	E02C12.5
+R07G3.1	E02C12.5
+R10H10.5	E02C12.5
+T01C2.1	E02C12.5
+T07A9.7	E02C12.5
+T19C4.6	E02C12.5
+W03C9.3	E02C12.5
+W03F8.9	E02C12.5
+Y51H4A.3	E02C12.5
+Y71H2B.7	E02C12.5
+Y95B8A.5	E02C12.5
+H35N03.1	F02D10.5
+F35G12.10	F02E8.1
+R06C1.1	F02E9.4
+Y51H1A.5	F02E9.4
+ZC190.1	F07B10.1
+F13H6.3	F07C4.12
+F13H6.4	F07C4.12
+F15A8.6	F07C4.12
+F55D10.3	F07C4.12
+F55F3.2	F07C4.12
+F56C11.6	F07C4.12
+K07C11.4	F07C4.12
+K11G9.1	F07C4.12
+K11G9.2	F07C4.12
+K11G9.3	F07C4.12
+R12A1.4	F07C4.12
+R173.3	F07C4.12
+T02B5.1	F07C4.12
+T02B5.3	F07C4.12
+T22D1.11	F07C4.12
+T28C12.4	F07C4.12
+T28C12.5	F07C4.12
+W02B12.4	F07C4.12
+W09B12.1	F07C4.12
+Y44E3A.2	F07C4.12
+Y48B6A.7	F07C4.12
+Y48B6A.8	F07C4.12
+Y71H2AM.13	F07C4.12
+Y75B8A.3	F07C4.12
+ZC376.1	F07C4.12
+ZC376.2	F07C4.12
+ZC376.3	F07C4.12
+ZK994.1	F07C4.12
+F28C6.8	F08B1.1
+F56D1.4	F08B1.1
+R07G3.5	F08B1.1
+W08G11.4	F08B1.1
+W09H1.1	F08B1.1
+Y54F10BM.13	F08B1.1
+ZK757.2	F08B1.1
+T01A4.1	F08B1.2
+F16B3.1	F08B12.3
+F34D6.3	F08B12.3
+H16O14.1	F08B12.3
+H35N03.1	F08B12.3
+R13A1.2	F08B12.3
+T06H11.1	F08B12.3
+Y51A2D.19	F08B12.3
+Y54G9A.3	F08B12.3
+F20C5.2	F08F8.3
+M01E11.6	F08F8.3
+M02B7.3	F08F8.3
+M03D4.1	F08F8.3
+Y50D7A.6	F08F8.3
+H26D21.2	F09E8.3
+T02G5.6	F09E8.3
+Y47G6A.11	F09E8.3
+ZK1127.11	F09E8.3
+K01A2.8	F09G8.9
+T06A4.2	F09G8.9
+T14G12.4	F10C2.4
+T28H11.4	F10C2.4
+Y47D3A.29	F10C2.4
+K08A8.3	F10G7.4
+W02A2.6	F10G7.4
+F59G1.7	F10G8.6
+Y18D10A.9	F10G8.6
+Y54H5A.4	F10G8.6
+F52B5.5	F11A1.3
+F54F7.1	F11A1.3
+F56E3.4	F11A1.3
+F58A3.1	F11A1.3
+K05C4.6	F11A1.3
+R07B1.1	F11A1.3
+R13H8.1	F11A1.3
+T20B12.2	F11A1.3
+T28H11.4	F11A1.3
+W03A3.1	F11A1.3
+W09C2.1	F11A1.3
+W10C8.2	F11A1.3
+Y11D7A.12	F11A1.3
+R08D7.3	F11A3.2
+T05G5.10	F11A3.2
+Y47H9C.7	F11A3.2
+Y54E2A.11	F11A3.2
+ZK1098.4	F11A3.2
+R06C7.10	F11C3.3
+K01G5.6	F12F6.3
+F26A3.4	F13D11.3
+F13H6.4	F13H6.3
+F15A8.6	F13H6.3
+F55D10.3	F13H6.3
+F55F3.2	F13H6.3
+F56C11.6	F13H6.3
+K07C11.4	F13H6.3
+K11G9.1	F13H6.3
+K11G9.2	F13H6.3
+K11G9.3	F13H6.3
+R12A1.4	F13H6.3
+R173.3	F13H6.3
+T02B5.1	F13H6.3
+T02B5.3	F13H6.3
+T22D1.11	F13H6.3
+T28C12.4	F13H6.3
+T28C12.5	F13H6.3
+W02B12.4	F13H6.3
+W09B12.1	F13H6.3
+Y44E3A.2	F13H6.3
+Y48B6A.7	F13H6.3
+Y48B6A.8	F13H6.3
+Y71H2AM.13	F13H6.3
+Y75B8A.3	F13H6.3
+ZC376.1	F13H6.3
+ZC376.2	F13H6.3
+ZC376.3	F13H6.3
+ZK994.1	F13H6.3
+F15A8.6	F13H6.4
+F55D10.3	F13H6.4
+F55F3.2	F13H6.4
+F56C11.6	F13H6.4
+K07C11.4	F13H6.4
+K11G9.1	F13H6.4
+K11G9.2	F13H6.4
+K11G9.3	F13H6.4
+R12A1.4	F13H6.4
+R173.3	F13H6.4
+T02B5.1	F13H6.4
+T02B5.3	F13H6.4
+T22D1.11	F13H6.4
+T28C12.4	F13H6.4
+T28C12.5	F13H6.4
+W02B12.4	F13H6.4
+W09B12.1	F13H6.4
+Y44E3A.2	F13H6.4
+Y48B6A.7	F13H6.4
+Y48B6A.8	F13H6.4
+Y71H2AM.13	F13H6.4
+Y75B8A.3	F13H6.4
+ZC376.1	F13H6.4
+ZC376.2	F13H6.4
+ZC376.3	F13H6.4
+ZK994.1	F13H6.4
+F43C1.2	F15A2.6
+F49E11.1	F15A2.6
+T25E12.4	F15A2.6
+W09C5.5	F15A2.6
+R06A10.2	F15A8.5
+F55D10.3	F15A8.6
+F55F3.2	F15A8.6
+F56C11.6	F15A8.6
+K07C11.4	F15A8.6
+K11G9.1	F15A8.6
+K11G9.2	F15A8.6
+K11G9.3	F15A8.6
+R12A1.4	F15A8.6
+R173.3	F15A8.6
+T02B5.1	F15A8.6
+T02B5.3	F15A8.6
+T22D1.11	F15A8.6
+T28C12.4	F15A8.6
+T28C12.5	F15A8.6
+W02B12.4	F15A8.6
+W09B12.1	F15A8.6
+Y44E3A.2	F15A8.6
+Y48B6A.7	F15A8.6
+Y48B6A.8	F15A8.6
+Y71H2AM.13	F15A8.6
+Y75B8A.3	F15A8.6
+ZC376.1	F15A8.6
+ZC376.2	F15A8.6
+ZC376.3	F15A8.6
+ZK994.1	F15A8.6
+F34D6.3	F16B3.1
+H16O14.1	F16B3.1
+H35N03.1	F16B3.1
+R13A1.2	F16B3.1
+T06H11.1	F16B3.1
+Y51A2D.19	F16B3.1
+Y54G9A.3	F16B3.1
+F28C1.2	F16H9.1
+F45B8.1	F16H9.1
+F45B8.2	F16H9.1
+F52D2.2	F16H9.1
+F56B6.2	F16H9.1
+K08E3.6	F16H9.1
+T07C4.8	F16H9.1
+Y38E10A.21	F16H9.1
+ZC53.7	F16H9.1
+W06B11.2	F18A11.1
+Y113G7B.5	F18A11.1
+F43G6.1	F18C5.2
+F18G5.3	F18E2.5
+F22B5.1	F18E2.5
+F26H9.6	F18E2.5
+F29C12.4	F18E2.5
+F38E1.5	F18E2.5
+F48C11.1	F18E2.5
+F53B1.7	F18E2.5
+F56H9.3	F18E2.5
+F56H9.4	F18E2.5
+K03D3.10	F18E2.5
+M01D7.7	F18E2.5
+M04C7.1	F18E2.5
+R06A10.2	F18E2.5
+R07G3.1	F18E2.5
+R10H10.5	F18E2.5
+T01C2.1	F18E2.5
+T07A9.7	F18E2.5
+T19C4.6	F18E2.5
+W03C9.3	F18E2.5
+W03F8.9	F18E2.5
+Y51H4A.3	F18E2.5
+Y71H2B.7	F18E2.5
+Y95B8A.5	F18E2.5
+F22B5.1	F18G5.3
+F26H9.6	F18G5.3
+F29C12.4	F18G5.3
+F38E1.5	F18G5.3
+F48C11.1	F18G5.3
+F53B1.7	F18G5.3
+F56H9.3	F18G5.3
+F56H9.4	F18G5.3
+K03D3.10	F18G5.3
+M01D7.7	F18G5.3
+M04C7.1	F18G5.3
+R06A10.2	F18G5.3
+R07G3.1	F18G5.3
+R10H10.5	F18G5.3
+T01C2.1	F18G5.3
+T07A9.7	F18G5.3
+T19C4.6	F18G5.3
+W03C9.3	F18G5.3
+W03F8.9	F18G5.3
+Y51H4A.3	F18G5.3
+Y71H2B.7	F18G5.3
+Y95B8A.5	F18G5.3
+T14F9.3	F20C5.1
+T20G5.2	F20C5.1
+Y39A1C.4	F20C5.1
+Y51F10.5	F20C5.1
+Y70D2A.2	F20C5.1
+M01E11.6	F20C5.2
+M02B7.3	F20C5.2
+M03D4.1	F20C5.2
+Y50D7A.6	F20C5.2
+T22C1.10	F20D1.6
+ZK1248.10	F20D1.6
+Y37H9A.6	F20D6.11
+F20D6.4	F20D6.3
+M01G12.2	F20D6.3
+M01G12.5	F20D6.3
+R01H2.4	F20D6.3
+Y32G9A.4	F20D6.3
+M01G12.2	F20D6.4
+M01G12.5	F20D6.4
+R01H2.4	F20D6.4
+Y32G9A.4	F20D6.4
+K04G7.3	F21D5.1
+R05F9.6	F21D5.1
+Y43F4B.5	F21D5.1
+F59F5.6	F21F3.5
+K11G12.2	F21F3.5
+K11G12.7	F21F3.5
+T08G11.5	F21F3.5
+ZC482.1	F21F3.5
+JC8.6	F21H11.3
+K03A11.3	F21H11.3
+R06A4.7	F21H11.3
+T07C4.2	F21H11.3
+T07C4.6	F21H11.3
+W10C8.2	F21H11.3
+ZK328.8	F21H11.3
+ZK863.3	F21H11.3
+F26H9.6	F22B5.1
+F29C12.4	F22B5.1
+F38E1.5	F22B5.1
+F48C11.1	F22B5.1
+F53B1.7	F22B5.1
+F56H9.3	F22B5.1
+F56H9.4	F22B5.1
+K03D3.10	F22B5.1
+M01D7.7	F22B5.1
+M04C7.1	F22B5.1
+R06A10.2	F22B5.1
+R07G3.1	F22B5.1
+R10H10.5	F22B5.1
+T07A9.7	F22B5.1
+T19C4.6	F22B5.1
+W03C9.3	F22B5.1
+W03F8.9	F22B5.1
+Y51H4A.3	F22B5.1
+Y71H2B.7	F22B5.1
+Y95B8A.5	F22B5.1
+F43E2.8	F22B7.5
+F57B10.11	F22B7.5
+K01C8.10	F22B7.5
+T27D1.1	F22B7.5
+Y75B12B.5	F22B7.5
+H26D21.2	F23C8.9
+R151.6	F23C8.9
+Y47D3A.29	F23C8.9
+Y113G7B.16	F25B5.5
+F26B1.7	F26A1.2
+F26D12.1	F26A1.2
+F27E11.3	F26A1.2
+F38A6.1	F26A1.2
+F40H3.4	F26A1.2
+K10G6.1	F26A1.2
+T14G12.4	F26A1.2
+T28H11.4	F26A1.2
+Y34D9B.1	F26A1.2
+Y37E11AR.6	F26A1.2
+Y71F9B.5	F26A1.2
+Y73B6BL.21	F26A1.2
+ZK265.4	F26A1.2
+F26D12.1	F26B1.7
+F27E11.3	F26B1.7
+F38A6.1	F26B1.7
+F40H3.4	F26B1.7
+K10G6.1	F26B1.7
+T14G12.4	F26B1.7
+T28H11.4	F26B1.7
+Y34D9B.1	F26B1.7
+Y37E11AR.6	F26B1.7
+Y71F9B.5	F26B1.7
+Y73B6BL.21	F26B1.7
+ZK265.4	F26B1.7
+F27E11.3	F26D12.1
+F38A6.1	F26D12.1
+F40H3.4	F26D12.1
+K10G6.1	F26D12.1
+T14G12.4	F26D12.1
+T28H11.4	F26D12.1
+Y34D9B.1	F26D12.1
+Y37E11AR.6	F26D12.1
+Y71F9B.5	F26D12.1
+Y73B6BL.21	F26D12.1
+ZK265.4	F26D12.1
+F29C12.4	F26H9.6
+F38E1.5	F26H9.6
+F48C11.1	F26H9.6
+F53B1.7	F26H9.6
+F56H9.3	F26H9.6
+F56H9.4	F26H9.6
+K03D3.10	F26H9.6
+M01D7.7	F26H9.6
+M04C7.1	F26H9.6
+R06A10.2	F26H9.6
+R07G3.1	F26H9.6
+R10H10.5	F26H9.6
+T07A9.7	F26H9.6
+T19C4.6	F26H9.6
+W03C9.3	F26H9.6
+W03F8.9	F26H9.6
+Y51H4A.3	F26H9.6
+Y71H2B.7	F26H9.6
+Y95B8A.5	F26H9.6
+F38E1.7	F27E11.3
+F40H3.4	F27E11.3
+K10B4.6	F27E11.3
+K10G6.1	F27E11.3
+T23D8.1	F27E11.3
+W01B6.1	F27E11.3
+W08D2.1	F27E11.3
+Y34D9B.1	F27E11.3
+Y37E11AR.6	F27E11.3
+Y71F9B.5	F27E11.3
+Y73B6BL.21	F27E11.3
+F45B8.1	F28C1.2
+F45B8.2	F28C1.2
+F52D2.2	F28C1.2
+F56B6.2	F28C1.2
+K08E3.6	F28C1.2
+T07C4.8	F28C1.2
+Y38E10A.21	F28C1.2
+ZC53.7	F28C1.2
+F56D1.4	F28C6.8
+R07G3.5	F28C6.8
+T24A11.1	F28C6.8
+W08G11.4	F28C6.8
+W09H1.1	F28C6.8
+Y54F10BM.13	F28C6.8
+ZK757.2	F28C6.8
+F44A6.2	F28F9.1
+T23G7.1	F28F9.1
+T28F2.4	F28F9.1
+W02D3.9	F28F9.1
+Y102A5C.18	F28F9.1
+Y47H9C.4	F29B9.4
+W02A11.4	F29B9.6
+W10D5.3	F29B9.6
+F38E1.5	F29C12.4
+F48C11.1	F29C12.4
+F53B1.7	F29C12.4
+F56H9.3	F29C12.4
+F56H9.4	F29C12.4
+K03D3.10	F29C12.4
+M01D7.7	F29C12.4
+M04C7.1	F29C12.4
+R06A10.2	F29C12.4
+R07G3.1	F29C12.4
+R10H10.5	F29C12.4
+T07A9.7	F29C12.4
+T19C4.6	F29C12.4
+W03C9.3	F29C12.4
+W03F8.9	F29C12.4
+Y51H4A.3	F29C12.4
+Y71H2B.7	F29C12.4
+Y95B8A.5	F29C12.4
+F29F11.3	F29C4.6
+Y17G7B.9	F31D4.3
+Y18D10A.19	F31D4.3
+Y18D10A.25	F31D4.3
+Y75B12B.5	F31D4.3
+ZC455.10	F31D4.3
+F38E1.7	F31E3.1
+K10B4.6	F31E3.1
+W08D2.1	F31E3.1
+Y54G2A.1	F31E3.1
+T10H9.4	F31E8.2
+K08E5.2	F31F6.6
+R107.1	F31F6.6
+M02F4.8	F32A5.5
+Y69E1A.7	F32A5.5
+H12C20.2	F32D1.1
+K04G2.3	F32D1.1
+T28A8.7	F32D1.1
+W06H8.1	F32D1.1
+Y43C5A.6	F32D1.1
+ZK637.5	F32D1.1
+F49E10.3	F33D4.3
+K10B4.4	F33D4.3
+W07E11.2	F33D4.3
+Y23B4A.2	F33D4.3
+Y48D7A.2	F33D4.3
+R03G5.1	F33D4.8
+T12G3.5	F33D4.8
+Y105E8A.16	F33D4.8
+Y57G11C.34	F33D4.8
+H16O14.1	F34D6.3
+H35N03.1	F34D6.3
+R13A1.2	F34D6.3
+T06H11.1	F34D6.3
+Y51A2D.19	F34D6.3
+Y54G9A.3	F34D6.3
+F48F7.2	F35C8.4
+F55A11.2	F35C8.4
+T01B11.3	F35C8.4
+F36A2.13	F35G12.9
+F45H7.6	F35G12.9
+M142.6	F35G12.9
+M7.1	F35G12.9
+Y39A1C.2	F35G12.9
+Y48G8AL.1	F35G12.9
+Y65B4BR.4	F35G12.9
+Y67D8C.5	F35G12.9
+Y92H12A.2	F35G12.9
+K01A11.4	F35H12.3
+W09C2.3	F35H12.3
+Y73F8A.1	F35H12.3
+ZK256.1	F35H12.3
+ZK524.1	F35H12.3
+F45H7.6	F36A2.13
+M142.6	F36A2.13
+M7.1	F36A2.13
+Y39A1C.2	F36A2.13
+Y48G8AL.1	F36A2.13
+Y65B4BR.4	F36A2.13
+Y67D8C.5	F36A2.13
+Y92H12A.2	F36A2.13
+R02E12.6	F36H1.5
+F42C5.8	F37C12.11
+T07A9.11	F37C12.11
+T07A9.14	F37C12.11
+T08B2.10	F37C12.11
+T26G10.3	F37C12.11
+Y71A12B.1	F37C12.11
+ZC434.2	F37C12.11
+F40H3.4	F38A6.1
+K10G6.1	F38A6.1
+T14G12.4	F38A6.1
+T28H11.4	F38A6.1
+F46G10.6	F38A6.3
+M05B5.5	F38A6.3
+W02C12.3	F38A6.3
+Y47D3B.7	F38A6.3
+F48C11.1	F38E1.5
+F53B1.7	F38E1.5
+F56H9.3	F38E1.5
+F56H9.4	F38E1.5
+K03D3.10	F38E1.5
+M01D7.7	F38E1.5
+M04C7.1	F38E1.5
+R06A10.2	F38E1.5
+R07G3.1	F38E1.5
+R10H10.5	F38E1.5
+T01C2.1	F38E1.5
+T07A9.7	F38E1.5
+T19C4.6	F38E1.5
+W03C9.3	F38E1.5
+W03F8.9	F38E1.5
+Y51H4A.3	F38E1.5
+Y71H2B.7	F38E1.5
+Y95B8A.5	F38E1.5
+K10B4.6	F38E1.7
+T23D8.1	F38E1.7
+W01B6.1	F38E1.7
+W08D2.1	F38E1.7
+W10C8.2	F38E1.7
+Y34D9B.1	F38E1.7
+Y54G2A.1	F38E1.7
+Y71F9B.5	F38E1.7
+Y73B6BL.21	F38E1.7
+M02F4.8	F40F9.9
+Y69E1A.7	F40F9.9
+K10G6.1	F40H3.4
+T14G12.4	F40H3.4
+T28H11.4	F40H3.4
+Y34D9B.1	F40H3.4
+Y37E11AR.6	F40H3.4
+Y71F9B.5	F40H3.4
+Y73B6BL.21	F40H3.4
+ZK265.4	F40H3.4
+F46H5.6	F41E6.2
+W03D2.5	F41E6.2
+W05E7.1	F41E6.2
+T07A9.11	F42C5.8
+T07A9.14	F42C5.8
+T08B2.10	F42C5.8
+T26G10.3	F42C5.8
+F42G8.4	F42G8.3
+F57B10.11	F42G8.3
+F58H12.1	F42G8.3
+K08H10.1	F42G8.3
+Y41C4A.4	F42G8.3
+F57B10.11	F42G8.4
+F58H12.1	F42G8.4
+K08H10.1	F42G8.4
+F49E2.1	F42G8.6
+K10D2.7	F42G8.6
+F49E11.1	F43C1.2
+T25E12.4	F43C1.2
+W09C5.5	F43C1.2
+F57B10.11	F43E2.8
+K01C8.10	F43E2.8
+T27D1.1	F43E2.8
+Y75B12B.5	F43E2.8
+T23G7.1	F44A6.2
+T28F2.4	F44A6.2
+W02D3.9	F44A6.2
+Y102A5C.18	F44A6.2
+R06A10.2	F44F4.5
+F45B8.2	F45B8.1
+F52D2.2	F45B8.1
+F56B6.2	F45B8.1
+K08E3.6	F45B8.1
+T07C4.8	F45B8.1
+Y38E10A.21	F45B8.1
+ZC53.7	F45B8.1
+F52D2.2	F45B8.2
+F56B6.2	F45B8.2
+K08E3.6	F45B8.2
+T07C4.8	F45B8.2
+Y38E10A.21	F45B8.2
+ZC53.7	F45B8.2
+K02A4.2	F45E10.1
+M03F4.2	F45E10.1
+M106.5	F45E10.1
+R01H10.3	F45E10.1
+Y76A2B.1	F45E10.1
+M142.6	F45H7.6
+M7.1	F45H7.6
+Y39A1C.2	F45H7.6
+Y48G8AL.1	F45H7.6
+Y65B4BR.4	F45H7.6
+Y67D8C.5	F45H7.6
+Y92H12A.2	F45H7.6
+R13H4.6	F46F5.5
+Y75B8A.4	F46F5.5
+M04C9.5	F46F6.4
+ZK520.3	F46F6.4
+M05B5.5	F46G10.6
+W02C12.3	F46G10.6
+Y47D3B.7	F46G10.6
+W03D2.5	F46H5.6
+W05E7.1	F46H5.6
+F53B1.7	F48C11.1
+F56H9.3	F48C11.1
+F56H9.4	F48C11.1
+K03D3.10	F48C11.1
+M01D7.7	F48C11.1
+M04C7.1	F48C11.1
+R06A10.2	F48C11.1
+R07G3.1	F48C11.1
+R10H10.5	F48C11.1
+T01C2.1	F48C11.1
+T07A9.7	F48C11.1
+T19C4.6	F48C11.1
+W03C9.3	F48C11.1
+W03F8.9	F48C11.1
+Y51H4A.3	F48C11.1
+Y71H2B.7	F48C11.1
+Y95B8A.5	F48C11.1
+R13H8.1	F48D6.3
+Y55D5A.5	F48D6.3
+F55A11.2	F48F7.2
+T01B11.3	F48F7.2
+K10B4.4	F49E10.3
+W07E11.2	F49E10.3
+Y23B4A.2	F49E10.3
+Y48D7A.2	F49E10.3
+F58H12.1	F49E11.1
+K07A9.2	F49E11.1
+M03A1.1	F49E11.1
+T04B2.2	F49E11.1
+T25E12.4	F49E11.1
+W09C5.5	F49E11.1
+Y55D5A.5	F49E11.1
+Y60A3A.1	F49E11.1
+K10D2.7	F49E2.1
+H16O14.1	F52B5.1
+K06C4.6	F52B5.1
+K12G11.1	F52B5.1
+R13A1.2	F52B5.1
+T23G5.5	F52B5.1
+F56E3.4	F52B5.5
+F58A3.1	F52B5.5
+R07B1.1	F52B5.5
+R09F10.9	F52B5.5
+T20B12.2	F52B5.5
+W03A3.1	F52B5.5
+W09C2.1	F52B5.5
+Y11D7A.12	F52B5.5
+F56B6.2	F52D2.2
+K08E3.6	F52D2.2
+T07C4.8	F52D2.2
+Y38E10A.21	F52D2.2
+ZC53.7	F52D2.2
+F54F7.1	F52E1.1
+K05C4.6	F52E1.1
+R06C1.1	F52E1.1
+Y49E10.14	F52E1.1
+K08A8.1	F52F12.3
+F56H9.3	F53B1.7
+F56H9.4	F53B1.7
+K03D3.10	F53B1.7
+M01D7.7	F53B1.7
+M04C7.1	F53B1.7
+R06A10.2	F53B1.7
+R07G3.1	F53B1.7
+R10H10.5	F53B1.7
+T01C2.1	F53B1.7
+T07A9.7	F53B1.7
+T19C4.6	F53B1.7
+W03C9.3	F53B1.7
+W03F8.9	F53B1.7
+Y51H4A.3	F53B1.7
+Y71H2B.7	F53B1.7
+Y95B8A.5	F53B1.7
+H21P03.3	F53H8.4
+Y22D7AL.8	F53H8.4
+W01A11.3	F54B11.3
+R06A4.7	F54C1.3
+ZK550.4	F54D5.11
+M03F8.2	F54E7.1
+F56E3.4	F54F7.1
+K05C4.6	F54F7.1
+R06C1.1	F54F7.1
+R13H8.1	F54F7.1
+T28H11.4	F54F7.1
+W09C2.1	F54F7.1
+W10C8.2	F54F7.1
+Y49E10.14	F54F7.1
+T01B11.3	F55A11.2
+F55F3.2	F55D10.3
+F56C11.6	F55D10.3
+K07C11.4	F55D10.3
+K11G9.1	F55D10.3
+K11G9.2	F55D10.3
+K11G9.3	F55D10.3
+R12A1.4	F55D10.3
+R173.3	F55D10.3
+T02B5.1	F55D10.3
+T02B5.3	F55D10.3
+T10H9.4	F55D10.3
+T22D1.11	F55D10.3
+T28C12.4	F55D10.3
+T28C12.5	F55D10.3
+W02B12.4	F55D10.3
+W09B12.1	F55D10.3
+Y44E3A.2	F55D10.3
+Y48B6A.7	F55D10.3
+Y48B6A.8	F55D10.3
+Y71H2AM.13	F55D10.3
+Y75B8A.3	F55D10.3
+ZC376.1	F55D10.3
+ZC376.2	F55D10.3
+ZC376.3	F55D10.3
+ZK994.1	F55D10.3
+F56C11.6	F55F3.2
+K07C11.4	F55F3.2
+K11G9.1	F55F3.2
+K11G9.2	F55F3.2
+K11G9.3	F55F3.2
+R12A1.4	F55F3.2
+R173.3	F55F3.2
+T02B5.1	F55F3.2
+T02B5.3	F55F3.2
+T22D1.11	F55F3.2
+T28C12.4	F55F3.2
+T28C12.5	F55F3.2
+W02B12.4	F55F3.2
+W09B12.1	F55F3.2
+Y44E3A.2	F55F3.2
+Y48B6A.7	F55F3.2
+Y48B6A.8	F55F3.2
+Y71H2AM.13	F55F3.2
+Y75B8A.3	F55F3.2
+ZC376.1	F55F3.2
+ZC376.2	F55F3.2
+ZC376.3	F55F3.2
+ZK994.1	F55F3.2
+ZK430.3	F55H2.1
+K08E3.6	F56B6.2
+T07C4.8	F56B6.2
+Y38E10A.21	F56B6.2
+ZC53.7	F56B6.2
+H06O01.1	F56C11.1
+K07C11.4	F56C11.6
+K11G9.1	F56C11.6
+K11G9.2	F56C11.6
+K11G9.3	F56C11.6
+R12A1.4	F56C11.6
+R173.3	F56C11.6
+T02B5.1	F56C11.6
+T02B5.3	F56C11.6
+T22D1.11	F56C11.6
+T28C12.4	F56C11.6
+T28C12.5	F56C11.6
+W02B12.4	F56C11.6
+W09B12.1	F56C11.6
+Y44E3A.2	F56C11.6
+Y48B6A.7	F56C11.6
+Y48B6A.8	F56C11.6
+Y71H2AM.13	F56C11.6
+Y75B8A.3	F56C11.6
+ZC376.1	F56C11.6
+ZC376.2	F56C11.6
+ZC376.3	F56C11.6
+ZK994.1	F56C11.6
+R07G3.5	F56D1.4
+W08G11.4	F56D1.4
+W09H1.1	F56D1.4
+Y54F10BM.13	F56D1.4
+ZK757.2	F56D1.4
+K09B11.2	F56D2.6
+W06E11.4	F56D2.6
+Y51H7C.11	F56D2.6
+Y71A12B.1	F56D2.6
+ZC434.2	F56D2.6
+F58A3.1	F56E3.4
+K05C4.6	F56E3.4
+R07B1.1	F56E3.4
+R13H8.1	F56E3.4
+T20B12.2	F56E3.4
+T28H11.4	F56E3.4
+W03A3.1	F56E3.4
+W09C2.1	F56E3.4
+W10C8.2	F56E3.4
+Y11D7A.12	F56E3.4
+T27D1.1	F56H11.1
+R01H2.5	F56H6.5
+F56H9.4	F56H9.3
+K03D3.10	F56H9.3
+M01D7.7	F56H9.3
+M04C7.1	F56H9.3
+R06A10.2	F56H9.3
+R07G3.1	F56H9.3
+R10H10.5	F56H9.3
+T01C2.1	F56H9.3
+T07A9.7	F56H9.3
+T19C4.6	F56H9.3
+W03C9.3	F56H9.3
+W03F8.9	F56H9.3
+Y51H4A.3	F56H9.3
+Y71H2B.7	F56H9.3
+Y95B8A.5	F56H9.3
+K03D3.10	F56H9.4
+M01D7.7	F56H9.4
+M04C7.1	F56H9.4
+R06A10.2	F56H9.4
+R07G3.1	F56H9.4
+R10H10.5	F56H9.4
+T01C2.1	F56H9.4
+T07A9.7	F56H9.4
+T19C4.6	F56H9.4
+W03C9.3	F56H9.4
+W03F8.9	F56H9.4
+Y51H4A.3	F56H9.4
+Y71H2B.7	F56H9.4
+Y95B8A.5	F56H9.4
+F58H12.1	F57B10.11
+K01C8.10	F57B10.11
+K08H10.1	F57B10.11
+T27D1.1	F57B10.11
+Y75B12B.5	F57B10.11
+Y97E10AR.7	F57B10.11
+R07B1.1	F58A3.1
+T20B12.2	F58A3.1
+W03A3.1	F58A3.1
+W09C2.1	F58A3.1
+Y11D7A.12	F58A3.1
+K07A9.2	F58H12.1
+K08H10.1	F58H12.1
+T04B2.2	F58H12.1
+Y55D5A.5	F58H12.1
+Y60A3A.1	F58H12.1
+K06C4.6	F59C12.2
+Y22D7AR.13	F59C12.2
+T08G11.5	F59F5.6
+Y18D10A.9	F59G1.7
+Y54H5A.4	F59G1.7
+K04G2.3	H12C20.2
+T02G5.6	H12C20.2
+T28A8.7	H12C20.2
+W02A2.6	H12C20.2
+W06H8.1	H12C20.2
+Y43C5A.6	H12C20.2
+Y47G6A.11	H12C20.2
+ZK637.5	H12C20.2
+H35N03.1	H16O14.1
+K06C4.6	H16O14.1
+K12G11.1	H16O14.1
+R13A1.2	H16O14.1
+T06H11.1	H16O14.1
+T23G5.5	H16O14.1
+Y51A2D.19	H16O14.1
+Y54G9A.3	H16O14.1
+Y22D7AL.8	H21P03.3
+T02G5.6	H26D21.2
+W02A2.6	H26D21.2
+Y47G6A.11	H26D21.2
+ZK1127.11	H26D21.2
+R13A1.2	H35N03.1
+T06H11.1	H35N03.1
+Y51A2D.19	H35N03.1
+Y54G9A.3	H35N03.1
+K03A11.3	JC8.6
+R06A4.7	JC8.6
+T07C4.2	JC8.6
+T07C4.6	JC8.6
+W10C8.2	JC8.6
+ZK328.8	JC8.6
+ZK863.3	JC8.6
+W09C2.3	K01A11.4
+Y73F8A.1	K01A11.4
+ZK256.1	K01A11.4
+ZK524.1	K01A11.4
+T06A4.2	K01A2.8
+T27D1.1	K01C8.10
+Y75B12B.5	K01C8.10
+R04B3.2	K01G5.9
+R06A4.7	K03A11.3
+T07C4.2	K03A11.3
+T07C4.6	K03A11.3
+W10C8.2	K03A11.3
+ZK328.8	K03A11.3
+ZK863.3	K03A11.3
+M01D7.7	K03D3.10
+M04C7.1	K03D3.10
+R06A10.2	K03D3.10
+R07G3.1	K03D3.10
+R10H10.5	K03D3.10
+T07A9.7	K03D3.10
+T19C4.6	K03D3.10
+W03C9.3	K03D3.10
+W03F8.9	K03D3.10
+Y51H4A.3	K03D3.10
+Y71H2B.7	K03D3.10
+Y95B8A.5	K03D3.10
+M7.1	K04C2.4
+R01H2.6	K04C2.4
+T05H10.5	K04C2.4
+T09B4.10	K04C2.4
+T24C4.6	K04C2.4
+Y65B4BR.4	K04C2.4
+T21E3.1	K04G2.3
+T28A8.7	K04G2.3
+W06H8.1	K04G2.3
+Y43C5A.6	K04G2.3
+ZK637.5	K04G2.3
+R06C1.1	K05C4.6
+R13H8.1	K05C4.6
+T28H11.4	K05C4.6
+W09C2.1	K05C4.6
+W10C8.2	K05C4.6
+Y49E10.14	K05C4.6
+ZC477.9	K05C4.6
+ZK112.7	K05C4.6
+K12G11.1	K06C4.6
+R13A1.2	K06C4.6
+T23G5.5	K06C4.6
+Y22D7AR.13	K06C4.6
+T04B2.2	K07A9.2
+Y55D5A.5	K07A9.2
+Y60A3A.1	K07A9.2
+K11G9.1	K07C11.4
+K11G9.2	K07C11.4
+K11G9.3	K07C11.4
+R12A1.4	K07C11.4
+R173.3	K07C11.4
+T02B5.1	K07C11.4
+T02B5.3	K07C11.4
+T22D1.11	K07C11.4
+T28C12.4	K07C11.4
+T28C12.5	K07C11.4
+W02B12.4	K07C11.4
+W09B12.1	K07C11.4
+Y44E3A.2	K07C11.4
+Y48B6A.7	K07C11.4
+Y48B6A.8	K07C11.4
+Y71H2AM.13	K07C11.4
+Y75B8A.3	K07C11.4
+ZC376.1	K07C11.4
+ZC376.2	K07C11.4
+ZC376.3	K07C11.4
+ZK994.1	K07C11.4
+W02A2.6	K08A8.3
+R107.8	K08B4.1
+T07C4.8	K08E3.6
+Y38E10A.21	K08E3.6
+ZC53.7	K08E3.6
+T05H10.5	K08E3.7
+T09B4.10	K08E3.7
+R107.1	K08E5.2
+W06E11.4	K09B11.2
+Y51H7C.11	K09B11.2
+Y71A12B.1	K09B11.2
+ZC434.2	K09B11.2
+Y75B7AL.4	K09H11.3
+W07E11.2	K10B4.4
+Y23B4A.2	K10B4.4
+Y48D7A.2	K10B4.4
+T23D8.1	K10B4.6
+W01B6.1	K10B4.6
+W08D2.1	K10B4.6
+W10C8.2	K10B4.6
+Y34D9B.1	K10B4.6
+Y54G2A.1	K10B4.6
+Y71F9B.5	K10B4.6
+Y73B6BL.21	K10B4.6
+T14G12.4	K10G6.1
+T28H11.4	K10G6.1
+Y34D9B.1	K10G6.1
+Y37E11AR.6	K10G6.1
+Y71F9B.5	K10G6.1
+Y73B6BL.21	K10G6.1
+ZK265.4	K10G6.1
+K11G12.7	K11G12.2
+ZC482.1	K11G12.2
+K11G12.4	K11G12.3
+Y69A2AR.4	K11G12.3
+Y69A2AR.4	K11G12.4
+ZC482.1	K11G12.7
+K11G9.2	K11G9.1
+K11G9.3	K11G9.1
+R12A1.4	K11G9.1
+R173.3	K11G9.1
+T02B5.1	K11G9.1
+T02B5.3	K11G9.1
+T22D1.11	K11G9.1
+T28C12.4	K11G9.1
+T28C12.5	K11G9.1
+W02B12.4	K11G9.1
+W09B12.1	K11G9.1
+Y44E3A.2	K11G9.1
+Y48B6A.7	K11G9.1
+Y48B6A.8	K11G9.1
+Y71H2AM.13	K11G9.1
+Y75B8A.3	K11G9.1
+ZC376.1	K11G9.1
+ZC376.2	K11G9.1
+ZC376.3	K11G9.1
+ZK994.1	K11G9.1
+K11G9.3	K11G9.2
+R12A1.4	K11G9.2
+R173.3	K11G9.2
+T02B5.1	K11G9.2
+T02B5.3	K11G9.2
+T22D1.11	K11G9.2
+T28C12.4	K11G9.2
+T28C12.5	K11G9.2
+W02B12.4	K11G9.2
+W09B12.1	K11G9.2
+Y44E3A.2	K11G9.2
+Y48B6A.7	K11G9.2
+Y48B6A.8	K11G9.2
+Y71H2AM.13	K11G9.2
+Y75B8A.3	K11G9.2
+ZC376.1	K11G9.2
+ZC376.2	K11G9.2
+ZC376.3	K11G9.2
+ZK994.1	K11G9.2
+R12A1.4	K11G9.3
+R173.3	K11G9.3
+T02B5.1	K11G9.3
+T02B5.3	K11G9.3
+T22D1.11	K11G9.3
+T28C12.4	K11G9.3
+T28C12.5	K11G9.3
+W02B12.4	K11G9.3
+W09B12.1	K11G9.3
+Y44E3A.2	K11G9.3
+Y48B6A.7	K11G9.3
+Y48B6A.8	K11G9.3
+Y71H2AM.13	K11G9.3
+Y75B8A.3	K11G9.3
+ZC376.1	K11G9.3
+ZC376.2	K11G9.3
+ZC376.3	K11G9.3
+ZK994.1	K11G9.3
+M01E5.5	K12D12.1
+R05D3.1	K12D12.1
+R05D3.12	K12D12.1
+Y46H3C.4	K12D12.1
+R13A1.2	K12G11.1
+T23G5.5	K12G11.1
+T07A9.5	K12H4.8
+Y113G7A.9	K12H4.8
+M04C7.1	M01D7.7
+R06A10.2	M01D7.7
+R07G3.1	M01D7.7
+R10H10.5	M01D7.7
+T01C2.1	M01D7.7
+T07A9.7	M01D7.7
+T19C4.6	M01D7.7
+W03C9.3	M01D7.7
+W03F8.9	M01D7.7
+Y51H4A.3	M01D7.7
+Y71H2B.7	M01D7.7
+Y95B8A.5	M01D7.7
+M02B7.3	M01E11.6
+M03D4.1	M01E11.6
+Y50D7A.6	M01E11.6
+R05D3.1	M01E5.5
+R05D3.12	M01E5.5
+Y46H3C.4	M01E5.5
+M01G12.5	M01G12.2
+R01H2.4	M01G12.2
+Y32G9A.4	M01G12.2
+R01H2.4	M01G12.5
+Y32G9A.4	M01G12.5
+ZC416.8	M01G5.5
+M03D4.1	M02B7.3
+Y50D7A.6	M02B7.3
+Y69E1A.7	M02F4.8
+Y50D7A.6	M03D4.1
+M106.5	M03F4.2
+R01H10.3	M03F4.2
+Y76A2B.1	M03F4.2
+R06A10.2	M04C7.1
+R07G3.1	M04C7.1
+R10H10.5	M04C7.1
+T01C2.1	M04C7.1
+T07A9.7	M04C7.1
+T19C4.6	M04C7.1
+W03C9.3	M04C7.1
+W03F8.9	M04C7.1
+Y51H4A.3	M04C7.1
+Y71H2B.7	M04C7.1
+Y95B8A.5	M04C7.1
+ZK520.3	M04C9.5
+W02C12.3	M05B5.5
+Y47D3B.7	M05B5.5
+R01H10.3	M106.5
+Y76A2B.1	M106.5
+M7.1	M142.6
+Y39A1C.2	M142.6
+Y48G8AL.1	M142.6
+Y65B4BR.4	M142.6
+Y67D8C.5	M142.6
+Y92H12A.2	M142.6
+R01H2.6	M7.1
+T05H10.5	M7.1
+T09B4.10	M7.1
+T24C4.6	M7.1
+Y39A1C.2	M7.1
+Y48G8AL.1	M7.1
+Y65B4BR.4	M7.1
+Y67D8C.5	M7.1
+Y92H12A.2	M7.1
+Y76A2B.1	R01H10.3
+Y32G9A.4	R01H2.4
+T05H10.5	R01H2.6
+T09B4.10	R01H2.6
+T24C4.6	R01H2.6
+Y65B4BR.4	R01H2.6
+T12G3.5	R03G5.1
+Y105E8A.16	R03G5.1
+Y57G11C.34	R03G5.1
+W03G1.7	R05D11.9
+ZK455.4	R05D11.9
+R05D3.12	R05D3.1
+Y46H3C.4	R05D3.1
+Y46H3C.4	R05D3.12
+W09C2.3	R05F9.6
+Y43F4B.5	R05F9.6
+R07G3.1	R06A10.2
+R10H10.5	R06A10.2
+T07A9.7	R06A10.2
+T19C4.6	R06A10.2
+W03C9.3	R06A10.2
+W03F8.9	R06A10.2
+Y51H4A.3	R06A10.2
+Y71H2B.7	R06A10.2
+Y95B8A.5	R06A10.2
+T07C4.2	R06A4.7
+T07C4.6	R06A4.7
+W10C8.2	R06A4.7
+ZK328.8	R06A4.7
+ZK863.3	R06A4.7
+Y49E10.14	R06C1.1
+Y51H1A.5	R06C1.1
+Y106G6E.5	R06C1.3
+T20B12.2	R07B1.1
+W03A3.1	R07B1.1
+W09C2.1	R07B1.1
+Y11D7A.12	R07B1.1
+ZK770.3	R07D5.1
+R10H10.5	R07G3.1
+T07A9.7	R07G3.1
+T19C4.6	R07G3.1
+W03C9.3	R07G3.1
+W03F8.9	R07G3.1
+Y51H4A.3	R07G3.1
+Y71H2B.7	R07G3.1
+Y95B8A.5	R07G3.1
+W08G11.4	R07G3.5
+W09H1.1	R07G3.5
+Y54F10BM.13	R07G3.5
+ZK757.2	R07G3.5
+T05G5.10	R08D7.3
+Y47H9C.7	R08D7.3
+Y54E2A.11	R08D7.3
+ZK1098.4	R08D7.3
+Y56A3A.29	R09B3.1
+T01C2.1	R10H10.5
+T07A9.7	R10H10.5
+T19C4.6	R10H10.5
+W03C9.3	R10H10.5
+W03F8.9	R10H10.5
+Y51H4A.3	R10H10.5
+Y71H2B.7	R10H10.5
+Y95B8A.5	R10H10.5
+R173.3	R12A1.4
+T02B5.1	R12A1.4
+T02B5.3	R12A1.4
+T22D1.11	R12A1.4
+T28C12.4	R12A1.4
+T28C12.5	R12A1.4
+W02B12.4	R12A1.4
+W09B12.1	R12A1.4
+Y44E3A.2	R12A1.4
+Y48B6A.7	R12A1.4
+Y48B6A.8	R12A1.4
+Y71H2AM.13	R12A1.4
+Y75B8A.3	R12A1.4
+ZC376.1	R12A1.4
+ZC376.2	R12A1.4
+ZC376.3	R12A1.4
+ZK994.1	R12A1.4
+T20B12.2	R12B2.5
+T06H11.1	R13A1.2
+T23G5.5	R13A1.2
+Y51A2D.19	R13A1.2
+Y54G9A.3	R13A1.2
+T01H8.5	R13A1.4
+Y75B8A.4	R13H4.6
+T28H11.4	R13H8.1
+W09C2.1	R13H8.1
+W10C8.2	R13H8.1
+Y47G6A.11	R13H8.1
+Y55D5A.5	R13H8.1
+T02B5.1	R173.3
+T02B5.3	R173.3
+T22D1.11	R173.3
+T28C12.4	R173.3
+T28C12.5	R173.3
+W02B12.4	R173.3
+W09B12.1	R173.3
+Y44E3A.2	R173.3
+Y48B6A.7	R173.3
+Y48B6A.8	R173.3
+Y71H2AM.13	R173.3
+Y75B8A.3	R173.3
+ZC376.1	R173.3
+ZC376.2	R173.3
+ZC376.3	R173.3
+ZK994.1	R173.3
+T07A9.7	T01C2.1
+T19C4.6	T01C2.1
+W03F8.9	T01C2.1
+Y71H2B.7	T01C2.1
+Y95B8A.5	T01C2.1
+T02B5.3	T02B5.1
+T22D1.11	T02B5.1
+T28C12.4	T02B5.1
+T28C12.5	T02B5.1
+W02B12.4	T02B5.1
+W09B12.1	T02B5.1
+Y44E3A.2	T02B5.1
+Y48B6A.7	T02B5.1
+Y48B6A.8	T02B5.1
+Y71H2AM.13	T02B5.1
+Y75B8A.3	T02B5.1
+ZC376.1	T02B5.1
+ZC376.2	T02B5.1
+ZC376.3	T02B5.1
+ZK994.1	T02B5.1
+T22D1.11	T02B5.3
+T28C12.4	T02B5.3
+T28C12.5	T02B5.3
+W02B12.4	T02B5.3
+W09B12.1	T02B5.3
+Y44E3A.2	T02B5.3
+Y48B6A.7	T02B5.3
+Y48B6A.8	T02B5.3
+Y71H2AM.13	T02B5.3
+Y75B8A.3	T02B5.3
+ZC376.1	T02B5.3
+ZC376.2	T02B5.3
+ZC376.3	T02B5.3
+ZK994.1	T02B5.3
+T28A8.7	T02G5.6
+W02A2.6	T02G5.6
+Y47G6A.11	T02G5.6
+ZK1127.11	T02G5.6
+Y55D5A.5	T04B2.2
+Y60A3A.1	T04B2.2
+Y47H9C.7	T05G5.10
+Y54E2A.11	T05G5.10
+ZK1098.4	T05G5.10
+T09B4.10	T05H10.5
+T24C4.6	T05H10.5
+Y65B4BR.4	T05H10.5
+ZC168.4	T06E6.2
+Y51A2D.19	T06H11.1
+Y54G9A.3	T06H11.1
+T07A9.14	T07A9.11
+T08B2.10	T07A9.11
+T26G10.3	T07A9.11
+T08B2.10	T07A9.14
+T26G10.3	T07A9.14
+Y113G7A.9	T07A9.5
+T19C4.6	T07A9.7
+W03C9.3	T07A9.7
+W03F8.9	T07A9.7
+Y51H4A.3	T07A9.7
+Y71H2B.7	T07A9.7
+Y95B8A.5	T07A9.7
+T07C4.6	T07C4.2
+W10C8.2	T07C4.2
+ZK328.8	T07C4.2
+ZK863.3	T07C4.2
+T08A9.9	T07C4.4
+W10C8.2	T07C4.6
+ZK328.8	T07C4.6
+ZK863.3	T07C4.6
+Y38E10A.21	T07C4.8
+ZC53.7	T07C4.8
+ZC308.1	T07F8.3
+T26G10.3	T08B2.10
+T24C4.6	T09B4.10
+Y65B4BR.4	T09B4.10
+Y92C3B.2	T10C6.5
+W09B12.1	T10H9.4
+Y48B6A.7	T10H9.4
+Y48B6A.8	T10H9.4
+Y105E8A.16	T12G3.5
+Y57G11C.34	T12G3.5
+T20G5.2	T14F9.3
+Y39A1C.4	T14F9.3
+Y51F10.5	T14F9.3
+Y70D2A.2	T14F9.3
+T28H11.4	T14G12.4
+W03C9.3	T19C4.6
+W03F8.9	T19C4.6
+Y51H4A.3	T19C4.6
+Y71H2B.7	T19C4.6
+Y95B8A.5	T19C4.6
+W03A3.1	T20B12.2
+W09C2.1	T20B12.2
+Y11D7A.12	T20B12.2
+Y39A1C.4	T20G5.2
+Y51F10.5	T20G5.2
+Y70D2A.2	T20G5.2
+T28C12.4	T22D1.11
+T28C12.5	T22D1.11
+W02B12.4	T22D1.11
+W09B12.1	T22D1.11
+Y44E3A.2	T22D1.11
+Y48B6A.7	T22D1.11
+Y48B6A.8	T22D1.11
+Y71H2AM.13	T22D1.11
+Y75B8A.3	T22D1.11
+ZC376.1	T22D1.11
+ZC376.2	T22D1.11
+ZC376.3	T22D1.11
+ZK994.1	T22D1.11
+W01B6.1	T23D8.1
+W08D2.1	T23D8.1
+Y34D9B.1	T23D8.1
+Y71F9B.5	T23D8.1
+Y73B6BL.21	T23D8.1
+T28F2.4	T23G7.1
+W02D3.9	T23G7.1
+Y102A5C.18	T23G7.1
+ZK899.8	T24C12.2
+Y65B4BR.4	T24C4.6
+W09C5.5	T25E12.4
+ZK896.8	T26C12.4
+Y75B12B.5	T27D1.1
+W02A2.6	T28A8.7
+W06H8.1	T28A8.7
+Y43C5A.6	T28A8.7
+Y47G6A.11	T28A8.7
+ZK637.5	T28A8.7
+T28C12.5	T28C12.4
+W02B12.4	T28C12.4
+W09B12.1	T28C12.4
+Y44E3A.2	T28C12.4
+Y48B6A.7	T28C12.4
+Y48B6A.8	T28C12.4
+Y71H2AM.13	T28C12.4
+Y75B8A.3	T28C12.4
+ZC376.1	T28C12.4
+ZC376.2	T28C12.4
+ZC376.3	T28C12.4
+ZK994.1	T28C12.4
+W02B12.4	T28C12.5
+W09B12.1	T28C12.5
+Y44E3A.2	T28C12.5
+Y48B6A.7	T28C12.5
+Y48B6A.8	T28C12.5
+Y71H2AM.13	T28C12.5
+Y75B8A.3	T28C12.5
+ZC376.1	T28C12.5
+ZC376.2	T28C12.5
+ZC376.3	T28C12.5
+ZK994.1	T28C12.5
+W02D3.9	T28F2.4
+Y102A5C.18	T28F2.4
+ZK593.4	T28F2.4
+W09C2.1	T28H11.4
+W10C8.2	T28H11.4
+W08D2.1	W01B6.1
+W10C8.2	W01B6.1
+Y34D9B.1	W01B6.1
+Y71F9B.5	W01B6.1
+Y73B6BL.21	W01B6.1
+W10D5.3	W02A11.4
+Y47G6A.11	W02A2.6
+ZC395.6	W02B12.10
+W09B12.1	W02B12.4
+Y44E3A.2	W02B12.4
+Y48B6A.7	W02B12.4
+Y48B6A.8	W02B12.4
+Y71H2AM.13	W02B12.4
+Y75B8A.3	W02B12.4
+ZC376.1	W02B12.4
+ZC376.2	W02B12.4
+ZC376.3	W02B12.4
+ZK994.1	W02B12.4
+Y47D3B.7	W02C12.3
+Y102A5C.18	W02D3.9
+W09C2.1	W03A3.1
+Y11D7A.12	W03A3.1
+W03F8.9	W03C9.3
+Y51H4A.3	W03C9.3
+Y71H2B.7	W03C9.3
+Y95B8A.5	W03C9.3
+W05E7.1	W03D2.5
+Y51H4A.3	W03F8.9
+Y71H2B.7	W03F8.9
+Y95B8A.5	W03F8.9
+ZK455.4	W03G1.7
+Y113G7B.5	W06B11.2
+Y51H7C.11	W06E11.4
+Y71A12B.1	W06E11.4
+ZC434.2	W06E11.4
+Y43C5A.6	W06H8.1
+ZK637.5	W06H8.1
+Y23B4A.2	W07E11.2
+Y48D7A.2	W07E11.2
+W10C8.2	W08D2.1
+Y34D9B.1	W08D2.1
+Y54G2A.1	W08D2.1
+Y71F9B.5	W08D2.1
+Y73B6BL.21	W08D2.1
+W09H1.1	W08G11.4
+Y54F10BM.13	W08G11.4
+ZK757.2	W08G11.4
+Y44E3A.2	W09B12.1
+Y48B6A.7	W09B12.1
+Y48B6A.8	W09B12.1
+Y71H2AM.13	W09B12.1
+Y75B8A.3	W09B12.1
+ZC376.1	W09B12.1
+ZC376.2	W09B12.1
+ZC376.3	W09B12.1
+ZK994.1	W09B12.1
+W10C8.2	W09C2.1
+Y11D7A.12	W09C2.1
+Y73F8A.1	W09C2.3
+ZK256.1	W09C2.3
+ZK524.1	W09C2.3
+Y54F10BM.13	W09H1.1
+ZK757.2	W09H1.1
+ZK328.8	W10C8.2
+ZK863.3	W10C8.2
+Y57G11C.34	Y105E8A.16
+Y18D10A.19	Y17G7B.9
+Y18D10A.25	Y17G7B.9
+Y75B12B.5	Y17G7B.9
+ZC455.10	Y17G7B.9
+Y18D10A.25	Y18D10A.19
+Y75B12B.5	Y18D10A.19
+ZC455.10	Y18D10A.19
+Y75B12B.5	Y18D10A.25
+ZC455.10	Y18D10A.25
+Y54H5A.4	Y18D10A.9
+Y48D7A.2	Y23B4A.2
+Y37E11AR.6	Y34D9B.1
+Y71F9B.5	Y34D9B.1
+Y73B6BL.21	Y34D9B.1
+Y71F9B.5	Y37E11AR.6
+Y73B6BL.21	Y37E11AR.6
+Y57G11C.47	Y38C1AA.3
+ZC53.7	Y38E10A.21
+Y48G8AL.1	Y39A1C.2
+Y65B4BR.4	Y39A1C.2
+Y67D8C.5	Y39A1C.2
+Y92H12A.2	Y39A1C.2
+Y51F10.5	Y39A1C.4
+Y70D2A.2	Y39A1C.4
+ZK829.6	Y39B6A.35
+ZK637.5	Y43C5A.6
+Y48B6A.7	Y44E3A.2
+Y48B6A.8	Y44E3A.2
+Y71H2AM.13	Y44E3A.2
+Y75B8A.3	Y44E3A.2
+ZC376.1	Y44E3A.2
+ZC376.2	Y44E3A.2
+ZC376.3	Y44E3A.2
+ZK994.1	Y44E3A.2
+ZC395.2	Y45G12B.1
+Y47G6A.8	Y47D3A.29
+ZK1127.11	Y47G6A.11
+Y56A3A.32	Y47G6A.8
+Y54E2A.11	Y47H9C.7
+ZK1098.4	Y47H9C.7
+Y48B6A.8	Y48B6A.7
+Y71H2AM.13	Y48B6A.7
+Y75B8A.3	Y48B6A.7
+ZC376.1	Y48B6A.7
+ZC376.2	Y48B6A.7
+ZC376.3	Y48B6A.7
+ZK994.1	Y48B6A.7
+Y71H2AM.13	Y48B6A.8
+Y75B8A.3	Y48B6A.8
+ZC376.1	Y48B6A.8
+ZC376.2	Y48B6A.8
+ZC376.3	Y48B6A.8
+ZK994.1	Y48B6A.8
+Y65B4BR.4	Y48G8AL.1
+Y67D8C.5	Y48G8AL.1
+Y92H12A.2	Y48G8AL.1
+Y54G9A.3	Y51A2D.19
+Y70D2A.2	Y51F10.5
+Y71H2B.7	Y51H4A.3
+Y95B8A.5	Y51H4A.3
+Y71A12B.1	Y51H7C.11
+ZC434.2	Y51H7C.11
+ZK1098.4	Y54E2A.11
+ZK757.2	Y54F10BM.13
+Y60A3A.1	Y55D5A.5
+Y67D8C.5	Y65B4BR.4
+Y92H12A.2	Y65B4BR.4
+Y92H12A.2	Y67D8C.5
+ZC434.2	Y71A12B.1
+Y73B6BL.21	Y71F9B.5
+Y75B8A.3	Y71H2AM.13
+ZC376.1	Y71H2AM.13
+ZC376.2	Y71H2AM.13
+ZC376.3	Y71H2AM.13
+ZK994.1	Y71H2AM.13
+Y95B8A.5	Y71H2B.7
+ZK256.1	Y73F8A.1
+ZK524.1	Y73F8A.1
+ZC455.10	Y75B12B.5
+ZC376.1	Y75B8A.3
+ZC376.2	Y75B8A.3
+ZC376.3	Y75B8A.3
+ZK994.1	Y75B8A.3
+ZK652.11	Y76A2A.2
+ZC376.2	ZC376.1
+ZC376.3	ZC376.1
+ZK994.1	ZC376.1
+ZC376.3	ZC376.2
+ZK994.1	ZC376.2
+ZK994.1	ZC376.3
+ZK524.1	ZK256.1
+ZK863.3	ZK328.8
+C04C3.3	C01B4.6
+C30H6.7	C01B4.6
+C36A4.9	C01B4.6
+C50D2.7	C01B4.6
+C50F4.2	C01B4.6
+D2063.1	C01B4.6
+F01F1.12	C01B4.6
+F01F1.6	C01B4.6
+F13D12.2	C01B4.6
+F14B4.2	C01B4.6
+F23B12.5	C01B4.6
+F25H5.3	C01B4.6
+F33H1.2	C01B4.6
+F54D8.3	C01B4.6
+F57B10.3	C01B4.6
+H24K24.3	C01B4.6
+K04F1.15	C01B4.6
+K07A3.1	C01B4.6
+K10B3.7	C01B4.6
+K10B3.8	C01B4.6
+K12G11.3	C01B4.6
+K12G11.4	C01B4.6
+LLC1.3	C01B4.6
+R05F9.6	C01B4.6
+R11A5.4	C01B4.6
+T03F1.3	C01B4.6
+T05D4.1	C01B4.6
+T05H10.6	C01B4.6
+T05H4.13	C01B4.6
+T08B1.3	C01B4.6
+T09F3.3	C01B4.6
+T21B10.2	C01B4.6
+W05G11.6	C01B4.6
+Y17G7B.7	C01B4.6
+Y43F4B.5	C01B4.6
+Y69F12A.2	C01B4.6
+Y71H10A.1	C01B4.6
+Y87G2A.8	C01B4.6
+ZK593.1	C01B4.6
+C30H6.7	C04C3.3
+C36A4.9	C04C3.3
+C50D2.7	C04C3.3
+C50F4.2	C04C3.3
+D2063.1	C04C3.3
+F01F1.12	C04C3.3
+F01F1.6	C04C3.3
+F13D12.2	C04C3.3
+F14B4.2	C04C3.3
+F23B12.5	C04C3.3
+F25H5.3	C04C3.3
+F33H1.2	C04C3.3
+F54D8.3	C04C3.3
+F57B10.3	C04C3.3
+H24K24.3	C04C3.3
+K04F1.15	C04C3.3
+K07A3.1	C04C3.3
+K10B3.7	C04C3.3
+K10B3.8	C04C3.3
+K12G11.3	C04C3.3
+K12G11.4	C04C3.3
+LLC1.3	C04C3.3
+R05F9.6	C04C3.3
+R11A5.4	C04C3.3
+T03F1.3	C04C3.3
+T05D4.1	C04C3.3
+T05H10.6	C04C3.3
+T05H4.13	C04C3.3
+T08B1.3	C04C3.3
+T09F3.3	C04C3.3
+T21B10.2	C04C3.3
+W05G11.6	C04C3.3
+Y17G7B.7	C04C3.3
+Y43F4B.5	C04C3.3
+Y69F12A.2	C04C3.3
+Y71H10A.1	C04C3.3
+Y87G2A.8	C04C3.3
+ZK593.1	C04C3.3
+C36A4.9	C30H6.7
+C50D2.7	C30H6.7
+C50F4.2	C30H6.7
+D2063.1	C30H6.7
+F01F1.12	C30H6.7
+F01F1.6	C30H6.7
+F13D12.2	C30H6.7
+F14B4.2	C30H6.7
+F23B12.5	C30H6.7
+F25H5.3	C30H6.7
+F33H1.2	C30H6.7
+F54D8.3	C30H6.7
+F57B10.3	C30H6.7
+H24K24.3	C30H6.7
+K04F1.15	C30H6.7
+K07A3.1	C30H6.7
+K10B3.7	C30H6.7
+K10B3.8	C30H6.7
+K12G11.3	C30H6.7
+K12G11.4	C30H6.7
+LLC1.3	C30H6.7
+R05F9.6	C30H6.7
+R11A5.4	C30H6.7
+T03F1.3	C30H6.7
+T05D4.1	C30H6.7
+T05H10.6	C30H6.7
+T05H4.13	C30H6.7
+T08B1.3	C30H6.7
+T09F3.3	C30H6.7
+T21B10.2	C30H6.7
+W05G11.6	C30H6.7
+Y17G7B.7	C30H6.7
+Y43F4B.5	C30H6.7
+Y69F12A.2	C30H6.7
+Y71H10A.1	C30H6.7
+Y87G2A.8	C30H6.7
+ZK593.1	C30H6.7
+C50D2.7	C36A4.9
+C50F4.2	C36A4.9
+D2063.1	C36A4.9
+F01F1.12	C36A4.9
+F01F1.6	C36A4.9
+F13D12.2	C36A4.9
+F14B4.2	C36A4.9
+F23B12.5	C36A4.9
+F25H5.3	C36A4.9
+F33H1.2	C36A4.9
+F54D8.3	C36A4.9
+F57B10.3	C36A4.9
+H24K24.3	C36A4.9
+K04F1.15	C36A4.9
+K07A3.1	C36A4.9
+K10B3.7	C36A4.9
+K10B3.8	C36A4.9
+K12G11.3	C36A4.9
+K12G11.4	C36A4.9
+LLC1.3	C36A4.9
+R05F9.6	C36A4.9
+R11A5.4	C36A4.9
+T03F1.3	C36A4.9
+T05D4.1	C36A4.9
+T05H10.6	C36A4.9
+T05H4.13	C36A4.9
+T08B1.3	C36A4.9
+T09F3.3	C36A4.9
+T21B10.2	C36A4.9
+W05G11.6	C36A4.9
+Y17G7B.7	C36A4.9
+Y43F4B.5	C36A4.9
+Y69F12A.2	C36A4.9
+Y71H10A.1	C36A4.9
+Y87G2A.8	C36A4.9
+ZK593.1	C36A4.9
+C50F4.2	C50D2.7
+D2063.1	C50D2.7
+F01F1.12	C50D2.7
+F01F1.6	C50D2.7
+F13D12.2	C50D2.7
+F14B4.2	C50D2.7
+F23B12.5	C50D2.7
+F25H5.3	C50D2.7
+F33H1.2	C50D2.7
+F54D8.3	C50D2.7
+F57B10.3	C50D2.7
+H24K24.3	C50D2.7
+K04F1.15	C50D2.7
+K07A3.1	C50D2.7
+K10B3.7	C50D2.7
+K10B3.8	C50D2.7
+K12G11.3	C50D2.7
+K12G11.4	C50D2.7
+LLC1.3	C50D2.7
+R05F9.6	C50D2.7
+R11A5.4	C50D2.7
+T03F1.3	C50D2.7
+T05D4.1	C50D2.7
+T05H10.6	C50D2.7
+T05H4.13	C50D2.7
+T08B1.3	C50D2.7
+T09F3.3	C50D2.7
+T21B10.2	C50D2.7
+W05G11.6	C50D2.7
+Y17G7B.7	C50D2.7
+Y43F4B.5	C50D2.7
+Y69F12A.2	C50D2.7
+Y71H10A.1	C50D2.7
+Y87G2A.8	C50D2.7
+ZK593.1	C50D2.7
+D2063.1	C50F4.2
+F01F1.12	C50F4.2
+F01F1.6	C50F4.2
+F13D12.2	C50F4.2
+F14B4.2	C50F4.2
+F23B12.5	C50F4.2
+F25H5.3	C50F4.2
+F33H1.2	C50F4.2
+F54D8.3	C50F4.2
+F57B10.3	C50F4.2
+H24K24.3	C50F4.2
+K04F1.15	C50F4.2
+K07A3.1	C50F4.2
+K10B3.7	C50F4.2
+K10B3.8	C50F4.2
+K12G11.3	C50F4.2
+K12G11.4	C50F4.2
+LLC1.3	C50F4.2
+R05F9.6	C50F4.2
+R11A5.4	C50F4.2
+T03F1.3	C50F4.2
+T05D4.1	C50F4.2
+T05H10.6	C50F4.2
+T05H4.13	C50F4.2
+T08B1.3	C50F4.2
+T09F3.3	C50F4.2
+T21B10.2	C50F4.2
+W05G11.6	C50F4.2
+Y17G7B.7	C50F4.2
+Y43F4B.5	C50F4.2
+Y69F12A.2	C50F4.2
+Y71H10A.1	C50F4.2
+Y87G2A.8	C50F4.2
+ZK593.1	C50F4.2
+F01F1.12	D2063.1
+F01F1.6	D2063.1
+F13D12.2	D2063.1
+F14B4.2	D2063.1
+F23B12.5	D2063.1
+F25H5.3	D2063.1
+F33H1.2	D2063.1
+F54D8.3	D2063.1
+F57B10.3	D2063.1
+H24K24.3	D2063.1
+K04F1.15	D2063.1
+K07A3.1	D2063.1
+K10B3.7	D2063.1
+K10B3.8	D2063.1
+K12G11.3	D2063.1
+K12G11.4	D2063.1
+LLC1.3	D2063.1
+R05F9.6	D2063.1
+R11A5.4	D2063.1
+T03F1.3	D2063.1
+T05D4.1	D2063.1
+T05H10.6	D2063.1
+T05H4.13	D2063.1
+T08B1.3	D2063.1
+T09F3.3	D2063.1
+T21B10.2	D2063.1
+W05G11.6	D2063.1
+Y17G7B.7	D2063.1
+Y43F4B.5	D2063.1
+Y69F12A.2	D2063.1
+Y71H10A.1	D2063.1
+Y87G2A.8	D2063.1
+ZK593.1	D2063.1
+F01F1.6	F01F1.12
+F13D12.2	F01F1.12
+F14B4.2	F01F1.12
+F23B12.5	F01F1.12
+F25H5.3	F01F1.12
+F33H1.2	F01F1.12
+F54D8.3	F01F1.12
+F57B10.3	F01F1.12
+H24K24.3	F01F1.12
+K04F1.15	F01F1.12
+K07A3.1	F01F1.12
+K10B3.7	F01F1.12
+K10B3.8	F01F1.12
+K12G11.3	F01F1.12
+K12G11.4	F01F1.12
+LLC1.3	F01F1.12
+R05F9.6	F01F1.12
+R11A5.4	F01F1.12
+T03F1.3	F01F1.12
+T05D4.1	F01F1.12
+T05H10.6	F01F1.12
+T05H4.13	F01F1.12
+T08B1.3	F01F1.12
+T09F3.3	F01F1.12
+T21B10.2	F01F1.12
+W05G11.6	F01F1.12
+Y17G7B.7	F01F1.12
+Y43F4B.5	F01F1.12
+Y69F12A.2	F01F1.12
+Y71H10A.1	F01F1.12
+Y87G2A.8	F01F1.12
+ZK593.1	F01F1.12
+F13D12.2	F01F1.6
+F14B4.2	F01F1.6
+F23B12.5	F01F1.6
+F25H5.3	F01F1.6
+F33H1.2	F01F1.6
+F54D8.3	F01F1.6
+F57B10.3	F01F1.6
+H24K24.3	F01F1.6
+K04F1.15	F01F1.6
+K07A3.1	F01F1.6
+K10B3.7	F01F1.6
+K10B3.8	F01F1.6
+K12G11.3	F01F1.6
+K12G11.4	F01F1.6
+LLC1.3	F01F1.6
+R05F9.6	F01F1.6
+R11A5.4	F01F1.6
+T03F1.3	F01F1.6
+T05D4.1	F01F1.6
+T05H10.6	F01F1.6
+T05H4.13	F01F1.6
+T08B1.3	F01F1.6
+T09F3.3	F01F1.6
+T21B10.2	F01F1.6
+W05G11.6	F01F1.6
+Y17G7B.7	F01F1.6
+Y43F4B.5	F01F1.6
+Y69F12A.2	F01F1.6
+Y71H10A.1	F01F1.6
+Y87G2A.8	F01F1.6
+ZK593.1	F01F1.6
+F14B4.2	F13D12.2
+F23B12.5	F13D12.2
+F25H5.3	F13D12.2
+F33H1.2	F13D12.2
+F54D8.3	F13D12.2
+F57B10.3	F13D12.2
+H24K24.3	F13D12.2
+K04F1.15	F13D12.2
+K07A3.1	F13D12.2
+K10B3.7	F13D12.2
+K10B3.8	F13D12.2
+K12G11.3	F13D12.2
+K12G11.4	F13D12.2
+LLC1.3	F13D12.2
+R05F9.6	F13D12.2
+R11A5.4	F13D12.2
+T03F1.3	F13D12.2
+T05D4.1	F13D12.2
+T05H10.6	F13D12.2
+T05H4.13	F13D12.2
+T08B1.3	F13D12.2
+T09F3.3	F13D12.2
+T21B10.2	F13D12.2
+W05G11.6	F13D12.2
+Y17G7B.7	F13D12.2
+Y43F4B.5	F13D12.2
+Y69F12A.2	F13D12.2
+Y71H10A.1	F13D12.2
+Y87G2A.8	F13D12.2
+ZK593.1	F13D12.2
+F23B12.5	F14B4.2
+F25H5.3	F14B4.2
+F33H1.2	F14B4.2
+F54D8.3	F14B4.2
+F57B10.3	F14B4.2
+H24K24.3	F14B4.2
+K04F1.15	F14B4.2
+K07A3.1	F14B4.2
+K10B3.7	F14B4.2
+K10B3.8	F14B4.2
+K12G11.3	F14B4.2
+K12G11.4	F14B4.2
+LLC1.3	F14B4.2
+R05F9.6	F14B4.2
+R11A5.4	F14B4.2
+T03F1.3	F14B4.2
+T05D4.1	F14B4.2
+T05H10.6	F14B4.2
+T05H4.13	F14B4.2
+T08B1.3	F14B4.2
+T09F3.3	F14B4.2
+T21B10.2	F14B4.2
+W05G11.6	F14B4.2
+Y17G7B.7	F14B4.2
+Y43F4B.5	F14B4.2
+Y69F12A.2	F14B4.2
+Y71H10A.1	F14B4.2
+Y87G2A.8	F14B4.2
+ZK593.1	F14B4.2
+F25H5.3	F23B12.5
+F33H1.2	F23B12.5
+F54D8.3	F23B12.5
+F57B10.3	F23B12.5
+H24K24.3	F23B12.5
+K04F1.15	F23B12.5
+K07A3.1	F23B12.5
+K10B3.7	F23B12.5
+K10B3.8	F23B12.5
+K12G11.3	F23B12.5
+K12G11.4	F23B12.5
+LLC1.3	F23B12.5
+R05F9.6	F23B12.5
+R11A5.4	F23B12.5
+T03F1.3	F23B12.5
+T05D4.1	F23B12.5
+T05H10.6	F23B12.5
+T05H4.13	F23B12.5
+T08B1.3	F23B12.5
+T09F3.3	F23B12.5
+T21B10.2	F23B12.5
+W05G11.6	F23B12.5
+Y17G7B.7	F23B12.5
+Y43F4B.5	F23B12.5
+Y69F12A.2	F23B12.5
+Y71H10A.1	F23B12.5
+Y87G2A.8	F23B12.5
+ZK593.1	F23B12.5
+F33H1.2	F25H5.3
+F54D8.3	F25H5.3
+F57B10.3	F25H5.3
+H24K24.3	F25H5.3
+K04F1.15	F25H5.3
+K07A3.1	F25H5.3
+K10B3.7	F25H5.3
+K10B3.8	F25H5.3
+K12G11.3	F25H5.3
+K12G11.4	F25H5.3
+LLC1.3	F25H5.3
+R05F9.6	F25H5.3
+R11A5.4	F25H5.3
+T03F1.3	F25H5.3
+T05D4.1	F25H5.3
+T05H10.6	F25H5.3
+T05H4.13	F25H5.3
+T08B1.3	F25H5.3
+T09F3.3	F25H5.3
+T21B10.2	F25H5.3
+W05G11.6	F25H5.3
+Y17G7B.7	F25H5.3
+Y43F4B.5	F25H5.3
+Y69F12A.2	F25H5.3
+Y71H10A.1	F25H5.3
+Y87G2A.8	F25H5.3
+ZK593.1	F25H5.3
+F54D8.3	F33H1.2
+F57B10.3	F33H1.2
+H24K24.3	F33H1.2
+K04F1.15	F33H1.2
+K07A3.1	F33H1.2
+K10B3.7	F33H1.2
+K10B3.8	F33H1.2
+K12G11.3	F33H1.2
+K12G11.4	F33H1.2
+LLC1.3	F33H1.2
+R05F9.6	F33H1.2
+R11A5.4	F33H1.2
+T03F1.3	F33H1.2
+T05D4.1	F33H1.2
+T05H10.6	F33H1.2
+T05H4.13	F33H1.2
+T08B1.3	F33H1.2
+T09F3.3	F33H1.2
+T21B10.2	F33H1.2
+W05G11.6	F33H1.2
+Y17G7B.7	F33H1.2
+Y43F4B.5	F33H1.2
+Y69F12A.2	F33H1.2
+Y71H10A.1	F33H1.2
+Y87G2A.8	F33H1.2
+ZK593.1	F33H1.2
+F57B10.3	F54D8.3
+H24K24.3	F54D8.3
+K04F1.15	F54D8.3
+K07A3.1	F54D8.3
+K10B3.7	F54D8.3
+K10B3.8	F54D8.3
+K12G11.3	F54D8.3
+K12G11.4	F54D8.3
+LLC1.3	F54D8.3
+R05F9.6	F54D8.3
+R11A5.4	F54D8.3
+T03F1.3	F54D8.3
+T05D4.1	F54D8.3
+T05H10.6	F54D8.3
+T05H4.13	F54D8.3
+T08B1.3	F54D8.3
+T09F3.3	F54D8.3
+T21B10.2	F54D8.3
+W05G11.6	F54D8.3
+Y17G7B.7	F54D8.3
+Y43F4B.5	F54D8.3
+Y69F12A.2	F54D8.3
+Y71H10A.1	F54D8.3
+Y87G2A.8	F54D8.3
+ZK593.1	F54D8.3
+H24K24.3	F57B10.3
+K04F1.15	F57B10.3
+K07A3.1	F57B10.3
+K10B3.7	F57B10.3
+K10B3.8	F57B10.3
+K12G11.3	F57B10.3
+K12G11.4	F57B10.3
+LLC1.3	F57B10.3
+R05F9.6	F57B10.3
+R11A5.4	F57B10.3
+T03F1.3	F57B10.3
+T05D4.1	F57B10.3
+T05H10.6	F57B10.3
+T05H4.13	F57B10.3
+T08B1.3	F57B10.3
+T09F3.3	F57B10.3
+T21B10.2	F57B10.3
+W05G11.6	F57B10.3
+Y17G7B.7	F57B10.3
+Y43F4B.5	F57B10.3
+Y69F12A.2	F57B10.3
+Y71H10A.1	F57B10.3
+Y87G2A.8	F57B10.3
+ZK593.1	F57B10.3
+K04F1.15	H24K24.3
+K07A3.1	H24K24.3
+K10B3.7	H24K24.3
+K10B3.8	H24K24.3
+K12G11.3	H24K24.3
+K12G11.4	H24K24.3
+LLC1.3	H24K24.3
+R05F9.6	H24K24.3
+R11A5.4	H24K24.3
+T03F1.3	H24K24.3
+T05D4.1	H24K24.3
+T05H10.6	H24K24.3
+T05H4.13	H24K24.3
+T08B1.3	H24K24.3
+T09F3.3	H24K24.3
+T21B10.2	H24K24.3
+W05G11.6	H24K24.3
+Y17G7B.7	H24K24.3
+Y43F4B.5	H24K24.3
+Y69F12A.2	H24K24.3
+Y71H10A.1	H24K24.3
+Y87G2A.8	H24K24.3
+ZK593.1	H24K24.3
+K07A3.1	K04F1.15
+K10B3.7	K04F1.15
+K10B3.8	K04F1.15
+K12G11.3	K04F1.15
+K12G11.4	K04F1.15
+LLC1.3	K04F1.15
+R05F9.6	K04F1.15
+R11A5.4	K04F1.15
+T03F1.3	K04F1.15
+T05D4.1	K04F1.15
+T05H10.6	K04F1.15
+T05H4.13	K04F1.15
+T08B1.3	K04F1.15
+T09F3.3	K04F1.15
+T21B10.2	K04F1.15
+W05G11.6	K04F1.15
+Y17G7B.7	K04F1.15
+Y43F4B.5	K04F1.15
+Y69F12A.2	K04F1.15
+Y71H10A.1	K04F1.15
+Y87G2A.8	K04F1.15
+ZK593.1	K04F1.15
+K10B3.7	K07A3.1
+K10B3.8	K07A3.1
+K12G11.3	K07A3.1
+K12G11.4	K07A3.1
+LLC1.3	K07A3.1
+R05F9.6	K07A3.1
+R11A5.4	K07A3.1
+T03F1.3	K07A3.1
+T05D4.1	K07A3.1
+T05H10.6	K07A3.1
+T05H4.13	K07A3.1
+T08B1.3	K07A3.1
+T09F3.3	K07A3.1
+T21B10.2	K07A3.1
+W05G11.6	K07A3.1
+Y17G7B.7	K07A3.1
+Y43F4B.5	K07A3.1
+Y69F12A.2	K07A3.1
+Y71H10A.1	K07A3.1
+Y87G2A.8	K07A3.1
+ZK593.1	K07A3.1
+K10B3.8	K10B3.7
+K12G11.3	K10B3.7
+K12G11.4	K10B3.7
+LLC1.3	K10B3.7
+R05F9.6	K10B3.7
+R11A5.4	K10B3.7
+T03F1.3	K10B3.7
+T05D4.1	K10B3.7
+T05H10.6	K10B3.7
+T05H4.13	K10B3.7
+T08B1.3	K10B3.7
+T09F3.3	K10B3.7
+T21B10.2	K10B3.7
+W05G11.6	K10B3.7
+Y17G7B.7	K10B3.7
+Y43F4B.5	K10B3.7
+Y69F12A.2	K10B3.7
+Y71H10A.1	K10B3.7
+Y87G2A.8	K10B3.7
+ZK593.1	K10B3.7
+K12G11.3	K10B3.8
+K12G11.4	K10B3.8
+LLC1.3	K10B3.8
+R05F9.6	K10B3.8
+R11A5.4	K10B3.8
+T03F1.3	K10B3.8
+T05D4.1	K10B3.8
+T05H10.6	K10B3.8
+T05H4.13	K10B3.8
+T08B1.3	K10B3.8
+T09F3.3	K10B3.8
+T21B10.2	K10B3.8
+W05G11.6	K10B3.8
+Y17G7B.7	K10B3.8
+Y43F4B.5	K10B3.8
+Y69F12A.2	K10B3.8
+Y71H10A.1	K10B3.8
+Y87G2A.8	K10B3.8
+ZK593.1	K10B3.8
+K12G11.4	K12G11.3
+LLC1.3	K12G11.3
+R05F9.6	K12G11.3
+R11A5.4	K12G11.3
+T03F1.3	K12G11.3
+T05D4.1	K12G11.3
+T05H10.6	K12G11.3
+T05H4.13	K12G11.3
+T08B1.3	K12G11.3
+T09F3.3	K12G11.3
+T21B10.2	K12G11.3
+W05G11.6	K12G11.3
+Y17G7B.7	K12G11.3
+Y43F4B.5	K12G11.3
+Y69F12A.2	K12G11.3
+Y71H10A.1	K12G11.3
+Y87G2A.8	K12G11.3
+ZK593.1	K12G11.3
+LLC1.3	K12G11.4
+R05F9.6	K12G11.4
+R11A5.4	K12G11.4
+T03F1.3	K12G11.4
+T05D4.1	K12G11.4
+T05H10.6	K12G11.4
+T05H4.13	K12G11.4
+T08B1.3	K12G11.4
+T09F3.3	K12G11.4
+T21B10.2	K12G11.4
+W05G11.6	K12G11.4
+Y17G7B.7	K12G11.4
+Y43F4B.5	K12G11.4
+Y69F12A.2	K12G11.4
+Y71H10A.1	K12G11.4
+Y87G2A.8	K12G11.4
+ZK593.1	K12G11.4
+R05F9.6	LLC1.3
+R11A5.4	LLC1.3
+T03F1.3	LLC1.3
+T05D4.1	LLC1.3
+T05H10.6	LLC1.3
+T05H4.13	LLC1.3
+T08B1.3	LLC1.3
+T09F3.3	LLC1.3
+T21B10.2	LLC1.3
+W05G11.6	LLC1.3
+Y17G7B.7	LLC1.3
+Y43F4B.5	LLC1.3
+Y69F12A.2	LLC1.3
+Y71H10A.1	LLC1.3
+Y87G2A.8	LLC1.3
+ZK593.1	LLC1.3
+R11A5.4	R05F9.6
+T03F1.3	R05F9.6
+T05D4.1	R05F9.6
+T05H10.6	R05F9.6
+T05H4.13	R05F9.6
+T08B1.3	R05F9.6
+T09F3.3	R05F9.6
+T21B10.2	R05F9.6
+W05G11.6	R05F9.6
+Y17G7B.7	R05F9.6
+Y69F12A.2	R05F9.6
+Y71H10A.1	R05F9.6
+Y87G2A.8	R05F9.6
+ZK593.1	R05F9.6
+T03F1.3	R11A5.4
+T05D4.1	R11A5.4
+T05H10.6	R11A5.4
+T05H4.13	R11A5.4
+T08B1.3	R11A5.4
+T09F3.3	R11A5.4
+T21B10.2	R11A5.4
+W05G11.6	R11A5.4
+Y17G7B.7	R11A5.4
+Y43F4B.5	R11A5.4
+Y69F12A.2	R11A5.4
+Y71H10A.1	R11A5.4
+Y87G2A.8	R11A5.4
+ZK593.1	R11A5.4
+T05D4.1	T03F1.3
+T05H10.6	T03F1.3
+T05H4.13	T03F1.3
+T08B1.3	T03F1.3
+T09F3.3	T03F1.3
+T21B10.2	T03F1.3
+W05G11.6	T03F1.3
+Y17G7B.7	T03F1.3
+Y43F4B.5	T03F1.3
+Y69F12A.2	T03F1.3
+Y71H10A.1	T03F1.3
+Y87G2A.8	T03F1.3
+ZK593.1	T03F1.3
+T05H10.6	T05D4.1
+T05H4.13	T05D4.1
+T08B1.3	T05D4.1
+T09F3.3	T05D4.1
+T21B10.2	T05D4.1
+W05G11.6	T05D4.1
+Y17G7B.7	T05D4.1
+Y43F4B.5	T05D4.1
+Y69F12A.2	T05D4.1
+Y71H10A.1	T05D4.1
+Y87G2A.8	T05D4.1
+ZK593.1	T05D4.1
+T05H4.13	T05H10.6
+T08B1.3	T05H10.6
+T09F3.3	T05H10.6
+T21B10.2	T05H10.6
+W05G11.6	T05H10.6
+Y17G7B.7	T05H10.6
+Y43F4B.5	T05H10.6
+Y69F12A.2	T05H10.6
+Y71H10A.1	T05H10.6
+Y87G2A.8	T05H10.6
+ZK593.1	T05H10.6
+T08B1.3	T05H4.13
+T09F3.3	T05H4.13
+T21B10.2	T05H4.13
+W05G11.6	T05H4.13
+Y17G7B.7	T05H4.13
+Y43F4B.5	T05H4.13
+Y69F12A.2	T05H4.13
+Y71H10A.1	T05H4.13
+Y87G2A.8	T05H4.13
+ZK593.1	T05H4.13
+T09F3.3	T08B1.3
+T21B10.2	T08B1.3
+W05G11.6	T08B1.3
+Y17G7B.7	T08B1.3
+Y43F4B.5	T08B1.3
+Y69F12A.2	T08B1.3
+Y71H10A.1	T08B1.3
+Y87G2A.8	T08B1.3
+ZK593.1	T08B1.3
+T21B10.2	T09F3.3
+W05G11.6	T09F3.3
+Y17G7B.7	T09F3.3
+Y43F4B.5	T09F3.3
+Y69F12A.2	T09F3.3
+Y71H10A.1	T09F3.3
+Y87G2A.8	T09F3.3
+ZK593.1	T09F3.3
+W05G11.6	T21B10.2
+Y17G7B.7	T21B10.2
+Y43F4B.5	T21B10.2
+Y69F12A.2	T21B10.2
+Y71H10A.1	T21B10.2
+Y87G2A.8	T21B10.2
+ZK593.1	T21B10.2
+Y17G7B.7	W05G11.6
+Y43F4B.5	W05G11.6
+Y69F12A.2	W05G11.6
+Y71H10A.1	W05G11.6
+Y87G2A.8	W05G11.6
+ZK593.1	W05G11.6
+Y43F4B.5	Y17G7B.7
+Y69F12A.2	Y17G7B.7
+Y71H10A.1	Y17G7B.7
+Y87G2A.8	Y17G7B.7
+ZK593.1	Y17G7B.7
+Y69F12A.2	Y43F4B.5
+Y71H10A.1	Y43F4B.5
+Y87G2A.8	Y43F4B.5
+ZK593.1	Y43F4B.5
+Y71H10A.1	Y69F12A.2
+Y87G2A.8	Y69F12A.2
+ZK593.1	Y69F12A.2
+Y87G2A.8	Y71H10A.1
+ZK593.1	Y71H10A.1
+ZK593.1	Y87G2A.8
+C03G5.1	B0365.1
+C04C3.3	B0365.1
+C05G5.4	B0365.1
+C30F12.7	B0365.1
+C30H6.7	B0365.1
+C34B2.7	B0365.1
+C34F6.8	B0365.1
+C37E2.1	B0365.1
+C50F7.4	B0365.1
+D1005.1	B0365.1
+D2023.2	B0365.1
+F20H11.3	B0365.1
+F23B12.5	B0365.1
+F23H11.3	B0365.1
+F33A8.5	B0365.1
+F35G12.2	B0365.1
+F42A8.2	B0365.1
+F43G9.1	B0365.1
+F46E10.10	B0365.1
+F47B10.1	B0365.1
+F54H12.1	B0365.1
+F59B8.2	B0365.1
+H14A12.2	B0365.1
+LLC1.3	B0365.1
+R11A5.4	B0365.1
+T05H10.6	B0365.1
+T07C4.7	B0365.1
+T20G5.2	B0365.1
+T22B11.5	B0365.1
+W02F12.5	B0365.1
+W05G11.6	B0365.1
+ZK455.1	B0365.1
+C04C3.3	C03G5.1
+C05G5.4	C03G5.1
+C30F12.7	C03G5.1
+C30H6.7	C03G5.1
+C34B2.7	C03G5.1
+C34F6.8	C03G5.1
+C37E2.1	C03G5.1
+C50F7.4	C03G5.1
+D1005.1	C03G5.1
+D2023.2	C03G5.1
+F20H11.3	C03G5.1
+F23B12.5	C03G5.1
+F23H11.3	C03G5.1
+F33A8.5	C03G5.1
+F35G12.2	C03G5.1
+F42A8.2	C03G5.1
+F43G9.1	C03G5.1
+F46E10.10	C03G5.1
+F47B10.1	C03G5.1
+F54H12.1	C03G5.1
+F59B8.2	C03G5.1
+H14A12.2	C03G5.1
+LLC1.3	C03G5.1
+R11A5.4	C03G5.1
+T05H10.6	C03G5.1
+T07C4.7	C03G5.1
+T20G5.2	C03G5.1
+T22B11.5	C03G5.1
+W02F12.5	C03G5.1
+W05G11.6	C03G5.1
+ZK455.1	C03G5.1
+C05G5.4	C04C3.3
+C30F12.7	C04C3.3
+C34B2.7	C04C3.3
+C34F6.8	C04C3.3
+C37E2.1	C04C3.3
+C50F7.4	C04C3.3
+D1005.1	C04C3.3
+D2023.2	C04C3.3
+F20H11.3	C04C3.3
+F23H11.3	C04C3.3
+F33A8.5	C04C3.3
+F35G12.2	C04C3.3
+F42A8.2	C04C3.3
+F43G9.1	C04C3.3
+F46E10.10	C04C3.3
+F47B10.1	C04C3.3
+F54H12.1	C04C3.3
+F59B8.2	C04C3.3
+H14A12.2	C04C3.3
+T07C4.7	C04C3.3
+T20G5.2	C04C3.3
+T22B11.5	C04C3.3
+W02F12.5	C04C3.3
+ZK455.1	C04C3.3
+C30F12.7	C05G5.4
+C30H6.7	C05G5.4
+C34B2.7	C05G5.4
+C34F6.8	C05G5.4
+C37E2.1	C05G5.4
+C50F7.4	C05G5.4
+D1005.1	C05G5.4
+D2023.2	C05G5.4
+F20H11.3	C05G5.4
+F23B12.5	C05G5.4
+F23H11.3	C05G5.4
+F33A8.5	C05G5.4
+F35G12.2	C05G5.4
+F42A8.2	C05G5.4
+F43G9.1	C05G5.4
+F46E10.10	C05G5.4
+F47B10.1	C05G5.4
+F54H12.1	C05G5.4
+F59B8.2	C05G5.4
+H14A12.2	C05G5.4
+LLC1.3	C05G5.4
+R11A5.4	C05G5.4
+T05H10.6	C05G5.4
+T07C4.7	C05G5.4
+T20G5.2	C05G5.4
+T22B11.5	C05G5.4
+W02F12.5	C05G5.4
+W05G11.6	C05G5.4
+ZK455.1	C05G5.4
+C30H6.7	C30F12.7
+C34B2.7	C30F12.7
+C34F6.8	C30F12.7
+C37E2.1	C30F12.7
+C50F7.4	C30F12.7
+D1005.1	C30F12.7
+D2023.2	C30F12.7
+F20H11.3	C30F12.7
+F23B12.5	C30F12.7
+F23H11.3	C30F12.7
+F33A8.5	C30F12.7
+F35G12.2	C30F12.7
+F42A8.2	C30F12.7
+F43G9.1	C30F12.7
+F46E10.10	C30F12.7
+F47B10.1	C30F12.7
+F54H12.1	C30F12.7
+F59B8.2	C30F12.7
+H14A12.2	C30F12.7
+LLC1.3	C30F12.7
+R11A5.4	C30F12.7
+T05H10.6	C30F12.7
+T07C4.7	C30F12.7
+T20G5.2	C30F12.7
+T22B11.5	C30F12.7
+W02F12.5	C30F12.7
+W05G11.6	C30F12.7
+ZK455.1	C30F12.7
+C34B2.7	C30H6.7
+C34F6.8	C30H6.7
+C37E2.1	C30H6.7
+C50F7.4	C30H6.7
+D1005.1	C30H6.7
+D2023.2	C30H6.7
+F20H11.3	C30H6.7
+F23H11.3	C30H6.7
+F33A8.5	C30H6.7
+F35G12.2	C30H6.7
+F42A8.2	C30H6.7
+F43G9.1	C30H6.7
+F46E10.10	C30H6.7
+F47B10.1	C30H6.7
+F54H12.1	C30H6.7
+F59B8.2	C30H6.7
+H14A12.2	C30H6.7
+T07C4.7	C30H6.7
+T20G5.2	C30H6.7
+T22B11.5	C30H6.7
+W02F12.5	C30H6.7
+ZK455.1	C30H6.7
+C34F6.8	C34B2.7
+C37E2.1	C34B2.7
+C50F7.4	C34B2.7
+D1005.1	C34B2.7
+D2023.2	C34B2.7
+F20H11.3	C34B2.7
+F23B12.5	C34B2.7
+F23H11.3	C34B2.7
+F33A8.5	C34B2.7
+F35G12.2	C34B2.7
+F42A8.2	C34B2.7
+F43G9.1	C34B2.7
+F46E10.10	C34B2.7
+F47B10.1	C34B2.7
+F54H12.1	C34B2.7
+F59B8.2	C34B2.7
+H14A12.2	C34B2.7
+LLC1.3	C34B2.7
+R11A5.4	C34B2.7
+T05H10.6	C34B2.7
+T07C4.7	C34B2.7
+T20G5.2	C34B2.7
+T22B11.5	C34B2.7
+W02F12.5	C34B2.7
+W05G11.6	C34B2.7
+ZK455.1	C34B2.7
+C37E2.1	C34F6.8
+C50F7.4	C34F6.8
+D1005.1	C34F6.8
+D2023.2	C34F6.8
+F20H11.3	C34F6.8
+F23B12.5	C34F6.8
+F23H11.3	C34F6.8
+F33A8.5	C34F6.8
+F35G12.2	C34F6.8
+F42A8.2	C34F6.8
+F43G9.1	C34F6.8
+F46E10.10	C34F6.8
+F47B10.1	C34F6.8
+F54H12.1	C34F6.8
+F59B8.2	C34F6.8
+H14A12.2	C34F6.8
+LLC1.3	C34F6.8
+R11A5.4	C34F6.8
+T05H10.6	C34F6.8
+T07C4.7	C34F6.8
+T20G5.2	C34F6.8
+T22B11.5	C34F6.8
+W02F12.5	C34F6.8
+W05G11.6	C34F6.8
+ZK455.1	C34F6.8
+C50F7.4	C37E2.1
+D1005.1	C37E2.1
+D2023.2	C37E2.1
+F20H11.3	C37E2.1
+F23B12.5	C37E2.1
+F23H11.3	C37E2.1
+F33A8.5	C37E2.1
+F35G12.2	C37E2.1
+F42A8.2	C37E2.1
+F43G9.1	C37E2.1
+F46E10.10	C37E2.1
+F47B10.1	C37E2.1
+F54H12.1	C37E2.1
+F59B8.2	C37E2.1
+H14A12.2	C37E2.1
+LLC1.3	C37E2.1
+R11A5.4	C37E2.1
+T05H10.6	C37E2.1
+T07C4.7	C37E2.1
+T20G5.2	C37E2.1
+T22B11.5	C37E2.1
+W02F12.5	C37E2.1
+W05G11.6	C37E2.1
+ZK455.1	C37E2.1
+D1005.1	C50F7.4
+D2023.2	C50F7.4
+F20H11.3	C50F7.4
+F23B12.5	C50F7.4
+F23H11.3	C50F7.4
+F33A8.5	C50F7.4
+F35G12.2	C50F7.4
+F42A8.2	C50F7.4
+F43G9.1	C50F7.4
+F46E10.10	C50F7.4
+F47B10.1	C50F7.4
+F54H12.1	C50F7.4
+F59B8.2	C50F7.4
+H14A12.2	C50F7.4
+LLC1.3	C50F7.4
+R11A5.4	C50F7.4
+T05H10.6	C50F7.4
+T07C4.7	C50F7.4
+T20G5.2	C50F7.4
+T22B11.5	C50F7.4
+W02F12.5	C50F7.4
+W05G11.6	C50F7.4
+ZK455.1	C50F7.4
+D2023.2	D1005.1
+F20H11.3	D1005.1
+F23B12.5	D1005.1
+F23H11.3	D1005.1
+F33A8.5	D1005.1
+F35G12.2	D1005.1
+F42A8.2	D1005.1
+F43G9.1	D1005.1
+F46E10.10	D1005.1
+F47B10.1	D1005.1
+F54H12.1	D1005.1
+F59B8.2	D1005.1
+H14A12.2	D1005.1
+LLC1.3	D1005.1
+R11A5.4	D1005.1
+T05H10.6	D1005.1
+T07C4.7	D1005.1
+T20G5.2	D1005.1
+T22B11.5	D1005.1
+W02F12.5	D1005.1
+W05G11.6	D1005.1
+ZK455.1	D1005.1
+F20H11.3	D2023.2
+F23B12.5	D2023.2
+F23H11.3	D2023.2
+F33A8.5	D2023.2
+F35G12.2	D2023.2
+F42A8.2	D2023.2
+F43G9.1	D2023.2
+F46E10.10	D2023.2
+F47B10.1	D2023.2
+F54H12.1	D2023.2
+F59B8.2	D2023.2
+H14A12.2	D2023.2
+LLC1.3	D2023.2
+R11A5.4	D2023.2
+T05H10.6	D2023.2
+T07C4.7	D2023.2
+T20G5.2	D2023.2
+T22B11.5	D2023.2
+W02F12.5	D2023.2
+W05G11.6	D2023.2
+ZK455.1	D2023.2
+F23B12.5	F20H11.3
+F23H11.3	F20H11.3
+F33A8.5	F20H11.3
+F35G12.2	F20H11.3
+F42A8.2	F20H11.3
+F43G9.1	F20H11.3
+F46E10.10	F20H11.3
+F47B10.1	F20H11.3
+F54H12.1	F20H11.3
+F59B8.2	F20H11.3
+H14A12.2	F20H11.3
+LLC1.3	F20H11.3
+R11A5.4	F20H11.3
+T05H10.6	F20H11.3
+T07C4.7	F20H11.3
+T20G5.2	F20H11.3
+T22B11.5	F20H11.3
+W02F12.5	F20H11.3
+W05G11.6	F20H11.3
+ZK455.1	F20H11.3
+F23H11.3	F23B12.5
+F33A8.5	F23B12.5
+F35G12.2	F23B12.5
+F42A8.2	F23B12.5
+F43G9.1	F23B12.5
+F46E10.10	F23B12.5
+F47B10.1	F23B12.5
+F54H12.1	F23B12.5
+F59B8.2	F23B12.5
+H14A12.2	F23B12.5
+T07C4.7	F23B12.5
+T20G5.2	F23B12.5
+T22B11.5	F23B12.5
+W02F12.5	F23B12.5
+ZK455.1	F23B12.5
+F33A8.5	F23H11.3
+F35G12.2	F23H11.3
+F42A8.2	F23H11.3
+F43G9.1	F23H11.3
+F46E10.10	F23H11.3
+F47B10.1	F23H11.3
+F54H12.1	F23H11.3
+F59B8.2	F23H11.3
+H14A12.2	F23H11.3
+LLC1.3	F23H11.3
+R11A5.4	F23H11.3
+T05H10.6	F23H11.3
+T07C4.7	F23H11.3
+T20G5.2	F23H11.3
+T22B11.5	F23H11.3
+W02F12.5	F23H11.3
+W05G11.6	F23H11.3
+ZK455.1	F23H11.3
+F35G12.2	F33A8.5
+F42A8.2	F33A8.5
+F43G9.1	F33A8.5
+F46E10.10	F33A8.5
+F47B10.1	F33A8.5
+F54H12.1	F33A8.5
+F59B8.2	F33A8.5
+H14A12.2	F33A8.5
+LLC1.3	F33A8.5
+R11A5.4	F33A8.5
+T05H10.6	F33A8.5
+T07C4.7	F33A8.5
+T20G5.2	F33A8.5
+T22B11.5	F33A8.5
+W02F12.5	F33A8.5
+W05G11.6	F33A8.5
+ZK455.1	F33A8.5
+F42A8.2	F35G12.2
+F43G9.1	F35G12.2
+F46E10.10	F35G12.2
+F47B10.1	F35G12.2
+F54H12.1	F35G12.2
+F59B8.2	F35G12.2
+H14A12.2	F35G12.2
+LLC1.3	F35G12.2
+R11A5.4	F35G12.2
+T05H10.6	F35G12.2
+T07C4.7	F35G12.2
+T20G5.2	F35G12.2
+T22B11.5	F35G12.2
+W02F12.5	F35G12.2
+W05G11.6	F35G12.2
+ZK455.1	F35G12.2
+F43G9.1	F42A8.2
+F46E10.10	F42A8.2
+F47B10.1	F42A8.2
+F54H12.1	F42A8.2
+F59B8.2	F42A8.2
+H14A12.2	F42A8.2
+LLC1.3	F42A8.2
+R11A5.4	F42A8.2
+T05H10.6	F42A8.2
+T07C4.7	F42A8.2
+T20G5.2	F42A8.2
+T22B11.5	F42A8.2
+W02F12.5	F42A8.2
+W05G11.6	F42A8.2
+ZK455.1	F42A8.2
+F46E10.10	F43G9.1
+F47B10.1	F43G9.1
+F54H12.1	F43G9.1
+F59B8.2	F43G9.1
+H14A12.2	F43G9.1
+LLC1.3	F43G9.1
+R11A5.4	F43G9.1
+T05H10.6	F43G9.1
+T07C4.7	F43G9.1
+T20G5.2	F43G9.1
+T22B11.5	F43G9.1
+W02F12.5	F43G9.1
+W05G11.6	F43G9.1
+ZK455.1	F43G9.1
+F47B10.1	F46E10.10
+F54H12.1	F46E10.10
+F59B8.2	F46E10.10
+H14A12.2	F46E10.10
+LLC1.3	F46E10.10
+R11A5.4	F46E10.10
+T05H10.6	F46E10.10
+T07C4.7	F46E10.10
+T20G5.2	F46E10.10
+T22B11.5	F46E10.10
+W02F12.5	F46E10.10
+W05G11.6	F46E10.10
+ZK455.1	F46E10.10
+F54H12.1	F47B10.1
+F59B8.2	F47B10.1
+H14A12.2	F47B10.1
+LLC1.3	F47B10.1
+R11A5.4	F47B10.1
+T05H10.6	F47B10.1
+T07C4.7	F47B10.1
+T20G5.2	F47B10.1
+T22B11.5	F47B10.1
+W02F12.5	F47B10.1
+W05G11.6	F47B10.1
+ZK455.1	F47B10.1
+F59B8.2	F54H12.1
+H14A12.2	F54H12.1
+LLC1.3	F54H12.1
+R11A5.4	F54H12.1
+T05H10.6	F54H12.1
+T07C4.7	F54H12.1
+T20G5.2	F54H12.1
+T22B11.5	F54H12.1
+W02F12.5	F54H12.1
+W05G11.6	F54H12.1
+ZK455.1	F54H12.1
+H14A12.2	F59B8.2
+LLC1.3	F59B8.2
+R11A5.4	F59B8.2
+T05H10.6	F59B8.2
+T07C4.7	F59B8.2
+T20G5.2	F59B8.2
+T22B11.5	F59B8.2
+W02F12.5	F59B8.2
+W05G11.6	F59B8.2
+ZK455.1	F59B8.2
+LLC1.3	H14A12.2
+R11A5.4	H14A12.2
+T05H10.6	H14A12.2
+T07C4.7	H14A12.2
+T20G5.2	H14A12.2
+T22B11.5	H14A12.2
+W02F12.5	H14A12.2
+W05G11.6	H14A12.2
+ZK455.1	H14A12.2
+T07C4.7	LLC1.3
+T20G5.2	LLC1.3
+T22B11.5	LLC1.3
+W02F12.5	LLC1.3
+ZK455.1	LLC1.3
+T07C4.7	R11A5.4
+T20G5.2	R11A5.4
+T22B11.5	R11A5.4
+W02F12.5	R11A5.4
+ZK455.1	R11A5.4
+T07C4.7	T05H10.6
+T20G5.2	T05H10.6
+T22B11.5	T05H10.6
+W02F12.5	T05H10.6
+ZK455.1	T05H10.6
+T20G5.2	T07C4.7
+T22B11.5	T07C4.7
+W02F12.5	T07C4.7
+W05G11.6	T07C4.7
+ZK455.1	T07C4.7
+T22B11.5	T20G5.2
+W02F12.5	T20G5.2
+W05G11.6	T20G5.2
+ZK455.1	T20G5.2
+W02F12.5	T22B11.5
+W05G11.6	T22B11.5
+ZK455.1	T22B11.5
+W05G11.6	W02F12.5
+ZK455.1	W02F12.5
+ZK455.1	W05G11.6
+B0280.3	B0035.5
+C50F4.2	B0035.5
+F01F1.12	B0035.5
+F01G10.1	B0035.5
+F07A11.5	B0035.5
+F08F8.7	B0035.5
+F09E5.3	B0035.5
+F26D11.1	B0035.5
+K07A3.1	B0035.5
+R05F9.6	B0035.5
+R151.2	B0035.5
+T05D4.1	B0035.5
+T25B9.9	B0035.5
+Y24D9A.8	B0035.5
+Y43F4B.5	B0035.5
+Y57G11C.3	B0035.5
+Y71H10A.1	B0035.5
+Y87G2A.8	B0035.5
+C50F4.2	B0280.3
+F01F1.12	B0280.3
+F01G10.1	B0280.3
+F07A11.5	B0280.3
+F08F8.7	B0280.3
+F09E5.3	B0280.3
+F26D11.1	B0280.3
+K07A3.1	B0280.3
+R05F9.6	B0280.3
+R151.2	B0280.3
+T05D4.1	B0280.3
+T25B9.9	B0280.3
+Y24D9A.8	B0280.3
+Y43F4B.5	B0280.3
+Y57G11C.3	B0280.3
+Y71H10A.1	B0280.3
+Y87G2A.8	B0280.3
+F01G10.1	C50F4.2
+F07A11.5	C50F4.2
+F08F8.7	C50F4.2
+F09E5.3	C50F4.2
+F26D11.1	C50F4.2
+R151.2	C50F4.2
+T25B9.9	C50F4.2
+Y24D9A.8	C50F4.2
+Y57G11C.3	C50F4.2
+F01G10.1	F01F1.12
+F07A11.5	F01F1.12
+F08F8.7	F01F1.12
+F09E5.3	F01F1.12
+F26D11.1	F01F1.12
+R151.2	F01F1.12
+T25B9.9	F01F1.12
+Y24D9A.8	F01F1.12
+Y57G11C.3	F01F1.12
+F07A11.5	F01G10.1
+F08F8.7	F01G10.1
+F09E5.3	F01G10.1
+F26D11.1	F01G10.1
+K07A3.1	F01G10.1
+R05F9.6	F01G10.1
+R151.2	F01G10.1
+T05D4.1	F01G10.1
+T25B9.9	F01G10.1
+Y24D9A.8	F01G10.1
+Y43F4B.5	F01G10.1
+Y57G11C.3	F01G10.1
+Y71H10A.1	F01G10.1
+Y87G2A.8	F01G10.1
+F08F8.7	F07A11.5
+F09E5.3	F07A11.5
+F26D11.1	F07A11.5
+K07A3.1	F07A11.5
+R05F9.6	F07A11.5
+R151.2	F07A11.5
+T05D4.1	F07A11.5
+T25B9.9	F07A11.5
+Y24D9A.8	F07A11.5
+Y43F4B.5	F07A11.5
+Y57G11C.3	F07A11.5
+Y71H10A.1	F07A11.5
+Y87G2A.8	F07A11.5
+F09E5.3	F08F8.7
+F26D11.1	F08F8.7
+K07A3.1	F08F8.7
+R05F9.6	F08F8.7
+R151.2	F08F8.7
+T05D4.1	F08F8.7
+T25B9.9	F08F8.7
+Y24D9A.8	F08F8.7
+Y43F4B.5	F08F8.7
+Y57G11C.3	F08F8.7
+Y71H10A.1	F08F8.7
+Y87G2A.8	F08F8.7
+F26D11.1	F09E5.3
+K07A3.1	F09E5.3
+R05F9.6	F09E5.3
+R151.2	F09E5.3
+T05D4.1	F09E5.3
+T25B9.9	F09E5.3
+Y24D9A.8	F09E5.3
+Y43F4B.5	F09E5.3
+Y57G11C.3	F09E5.3
+Y71H10A.1	F09E5.3
+Y87G2A.8	F09E5.3
+K07A3.1	F26D11.1
+R05F9.6	F26D11.1
+R151.2	F26D11.1
+T05D4.1	F26D11.1
+T25B9.9	F26D11.1
+Y24D9A.8	F26D11.1
+Y43F4B.5	F26D11.1
+Y57G11C.3	F26D11.1
+Y71H10A.1	F26D11.1
+Y87G2A.8	F26D11.1
+R151.2	K07A3.1
+T25B9.9	K07A3.1
+Y24D9A.8	K07A3.1
+Y57G11C.3	K07A3.1
+R151.2	R05F9.6
+T25B9.9	R05F9.6
+Y24D9A.8	R05F9.6
+Y57G11C.3	R05F9.6
+T05D4.1	R151.2
+T25B9.9	R151.2
+Y24D9A.8	R151.2
+Y43F4B.5	R151.2
+Y57G11C.3	R151.2
+Y71H10A.1	R151.2
+Y87G2A.8	R151.2
+T25B9.9	T05D4.1
+Y24D9A.8	T05D4.1
+Y57G11C.3	T05D4.1
+Y24D9A.8	T25B9.9
+Y43F4B.5	T25B9.9
+Y57G11C.3	T25B9.9
+Y71H10A.1	T25B9.9
+Y87G2A.8	T25B9.9
+Y43F4B.5	Y24D9A.8
+Y57G11C.3	Y24D9A.8
+Y71H10A.1	Y24D9A.8
+Y87G2A.8	Y24D9A.8
+Y57G11C.3	Y43F4B.5
+Y71H10A.1	Y57G11C.3
+Y87G2A.8	Y57G11C.3
+C17G1.3	B0310.5
+C18C4.3	B0310.5
+F08F8.7	B0310.5
+F29F11.1	B0310.5
+F35H8.6	B0310.5
+F39G3.1	B0310.5
+F54D8.3	B0310.5
+K04F1.15	B0310.5
+K08E3.5	B0310.5
+M88.1	B0310.5
+R08D7.7	B0310.5
+R11D1.11	B0310.5
+T04H1.7	B0310.5
+T04H1.8	B0310.5
+T05H4.13	B0310.5
+T07C5.1	B0310.5
+Y105E8B.9	B0310.5
+Y39G8B.1	B0310.5
+Y71F9B.9	B0310.5
+C18C4.3	C17G1.3
+F08F8.7	C17G1.3
+F29F11.1	C17G1.3
+F35H8.6	C17G1.3
+F39G3.1	C17G1.3
+F54D8.3	C17G1.3
+K04F1.15	C17G1.3
+K08E3.5	C17G1.3
+M88.1	C17G1.3
+R08D7.7	C17G1.3
+R11D1.11	C17G1.3
+T04H1.7	C17G1.3
+T04H1.8	C17G1.3
+T05H4.13	C17G1.3
+T07C5.1	C17G1.3
+Y105E8B.9	C17G1.3
+Y39G8B.1	C17G1.3
+Y71F9B.9	C17G1.3
+F08F8.7	C18C4.3
+F29F11.1	C18C4.3
+F35H8.6	C18C4.3
+F39G3.1	C18C4.3
+F54D8.3	C18C4.3
+K04F1.15	C18C4.3
+K08E3.5	C18C4.3
+M88.1	C18C4.3
+R08D7.7	C18C4.3
+R11D1.11	C18C4.3
+T04H1.7	C18C4.3
+T04H1.8	C18C4.3
+T05H4.13	C18C4.3
+T07C5.1	C18C4.3
+Y105E8B.9	C18C4.3
+Y39G8B.1	C18C4.3
+Y71F9B.9	C18C4.3
+F29F11.1	F08F8.7
+F35H8.6	F08F8.7
+F39G3.1	F08F8.7
+F54D8.3	F08F8.7
+K04F1.15	F08F8.7
+K08E3.5	F08F8.7
+M88.1	F08F8.7
+R08D7.7	F08F8.7
+R11D1.11	F08F8.7
+T04H1.7	F08F8.7
+T04H1.8	F08F8.7
+T05H4.13	F08F8.7
+T07C5.1	F08F8.7
+Y105E8B.9	F08F8.7
+Y39G8B.1	F08F8.7
+Y71F9B.9	F08F8.7
+F35H8.6	F29F11.1
+F39G3.1	F29F11.1
+F54D8.3	F29F11.1
+K04F1.15	F29F11.1
+K08E3.5	F29F11.1
+M88.1	F29F11.1
+R08D7.7	F29F11.1
+R11D1.11	F29F11.1
+T04H1.7	F29F11.1
+T04H1.8	F29F11.1
+T05H4.13	F29F11.1
+T07C5.1	F29F11.1
+Y105E8B.9	F29F11.1
+Y39G8B.1	F29F11.1
+Y71F9B.9	F29F11.1
+F39G3.1	F35H8.6
+F54D8.3	F35H8.6
+K04F1.15	F35H8.6
+K08E3.5	F35H8.6
+M88.1	F35H8.6
+R08D7.7	F35H8.6
+R11D1.11	F35H8.6
+T04H1.7	F35H8.6
+T04H1.8	F35H8.6
+T05H4.13	F35H8.6
+T07C5.1	F35H8.6
+Y105E8B.9	F35H8.6
+Y39G8B.1	F35H8.6
+Y71F9B.9	F35H8.6
+F54D8.3	F39G3.1
+K04F1.15	F39G3.1
+K08E3.5	F39G3.1
+M88.1	F39G3.1
+R08D7.7	F39G3.1
+R11D1.11	F39G3.1
+T04H1.7	F39G3.1
+T04H1.8	F39G3.1
+T05H4.13	F39G3.1
+T07C5.1	F39G3.1
+Y105E8B.9	F39G3.1
+Y39G8B.1	F39G3.1
+Y71F9B.9	F39G3.1
+K08E3.5	F54D8.3
+M88.1	F54D8.3
+R08D7.7	F54D8.3
+R11D1.11	F54D8.3
+T04H1.7	F54D8.3
+T04H1.8	F54D8.3
+T07C5.1	F54D8.3
+Y105E8B.9	F54D8.3
+Y39G8B.1	F54D8.3
+Y71F9B.9	F54D8.3
+K08E3.5	K04F1.15
+M88.1	K04F1.15
+R08D7.7	K04F1.15
+R11D1.11	K04F1.15
+T04H1.7	K04F1.15
+T04H1.8	K04F1.15
+T07C5.1	K04F1.15
+Y105E8B.9	K04F1.15
+Y39G8B.1	K04F1.15
+Y71F9B.9	K04F1.15
+M88.1	K08E3.5
+R08D7.7	K08E3.5
+R11D1.11	K08E3.5
+T04H1.7	K08E3.5
+T04H1.8	K08E3.5
+T05H4.13	K08E3.5
+T07C5.1	K08E3.5
+Y105E8B.9	K08E3.5
+Y39G8B.1	K08E3.5
+Y71F9B.9	K08E3.5
+R08D7.7	M88.1
+R11D1.11	M88.1
+T04H1.7	M88.1
+T04H1.8	M88.1
+T05H4.13	M88.1
+T07C5.1	M88.1
+Y105E8B.9	M88.1
+Y39G8B.1	M88.1
+Y71F9B.9	M88.1
+R11D1.11	R08D7.7
+T04H1.7	R08D7.7
+T04H1.8	R08D7.7
+T05H4.13	R08D7.7
+T07C5.1	R08D7.7
+Y105E8B.9	R08D7.7
+Y39G8B.1	R08D7.7
+Y71F9B.9	R08D7.7
+T04H1.7	R11D1.11
+T04H1.8	R11D1.11
+T05H4.13	R11D1.11
+T07C5.1	R11D1.11
+Y105E8B.9	R11D1.11
+Y39G8B.1	R11D1.11
+Y71F9B.9	R11D1.11
+T04H1.8	T04H1.7
+T05H4.13	T04H1.7
+T07C5.1	T04H1.7
+Y105E8B.9	T04H1.7
+Y39G8B.1	T04H1.7
+Y71F9B.9	T04H1.7
+T05H4.13	T04H1.8
+T07C5.1	T04H1.8
+Y105E8B.9	T04H1.8
+Y39G8B.1	T04H1.8
+Y71F9B.9	T04H1.8
+T07C5.1	T05H4.13
+Y105E8B.9	T05H4.13
+Y39G8B.1	T05H4.13
+Y71F9B.9	T05H4.13
+Y105E8B.9	T07C5.1
+Y39G8B.1	T07C5.1
+Y71F9B.9	T07C5.1
+Y39G8B.1	Y105E8B.9
+Y71F9B.9	Y105E8B.9
+Y71F9B.9	Y39G8B.1
+C05C8.7	B0024.15
+C06B3.4	B0024.15
+C06B3.5	B0024.15
+C42C1.5	B0024.15
+C50F4.2	B0024.15
+C53B4.7	B0024.15
+C56G2.6	B0024.15
+F01F1.12	B0024.15
+F11A5.12	B0024.15
+F14B4.2	B0024.15
+F25G6.5	B0024.15
+F52B11.2	B0024.15
+F53A2.8	B0024.15
+F56H6.5	B0024.15
+K02B2.1	B0024.15
+K03H1.13	B0024.15
+K07A3.1	B0024.15
+R01H2.5	B0024.15
+R04B5.5	B0024.15
+R04B5.6	B0024.15
+T05D4.1	B0024.15
+Y110A7A.6	B0024.15
+Y17G7B.7	B0024.15
+Y39G8B.1	B0024.15
+Y47D9A.1	B0024.15
+Y71H10A.1	B0024.15
+ZK632.4	B0024.15
+C06B3.4	C05C8.7
+C06B3.5	C05C8.7
+C42C1.5	C05C8.7
+C50F4.2	C05C8.7
+C53B4.7	C05C8.7
+C56G2.6	C05C8.7
+F01F1.12	C05C8.7
+F11A5.12	C05C8.7
+F14B4.2	C05C8.7
+F25G6.5	C05C8.7
+F52B11.2	C05C8.7
+F53A2.8	C05C8.7
+F56H6.5	C05C8.7
+K02B2.1	C05C8.7
+K03H1.13	C05C8.7
+K07A3.1	C05C8.7
+R01H2.5	C05C8.7
+R04B5.5	C05C8.7
+R04B5.6	C05C8.7
+T05D4.1	C05C8.7
+Y110A7A.6	C05C8.7
+Y17G7B.7	C05C8.7
+Y39G8B.1	C05C8.7
+Y47D9A.1	C05C8.7
+Y71H10A.1	C05C8.7
+ZK632.4	C05C8.7
+C06B3.5	C06B3.4
+C42C1.5	C06B3.4
+C50F4.2	C06B3.4
+C53B4.7	C06B3.4
+C56G2.6	C06B3.4
+F01F1.12	C06B3.4
+F11A5.12	C06B3.4
+F14B4.2	C06B3.4
+F25G6.5	C06B3.4
+F52B11.2	C06B3.4
+F53A2.8	C06B3.4
+F56H6.5	C06B3.4
+K02B2.1	C06B3.4
+K03H1.13	C06B3.4
+K07A3.1	C06B3.4
+R01H2.5	C06B3.4
+R04B5.5	C06B3.4
+R04B5.6	C06B3.4
+T05D4.1	C06B3.4
+Y110A7A.6	C06B3.4
+Y17G7B.7	C06B3.4
+Y39G8B.1	C06B3.4
+Y47D9A.1	C06B3.4
+Y71H10A.1	C06B3.4
+ZK632.4	C06B3.4
+C42C1.5	C06B3.5
+C50F4.2	C06B3.5
+C53B4.7	C06B3.5
+C56G2.6	C06B3.5
+F01F1.12	C06B3.5
+F11A5.12	C06B3.5
+F14B4.2	C06B3.5
+F25G6.5	C06B3.5
+F52B11.2	C06B3.5
+F53A2.8	C06B3.5
+F56H6.5	C06B3.5
+K02B2.1	C06B3.5
+K03H1.13	C06B3.5
+K07A3.1	C06B3.5
+R01H2.5	C06B3.5
+R04B5.5	C06B3.5
+R04B5.6	C06B3.5
+T05D4.1	C06B3.5
+Y110A7A.6	C06B3.5
+Y17G7B.7	C06B3.5
+Y39G8B.1	C06B3.5
+Y47D9A.1	C06B3.5
+Y71H10A.1	C06B3.5
+ZK632.4	C06B3.5
+C50F4.2	C42C1.5
+C53B4.7	C42C1.5
+C56G2.6	C42C1.5
+F01F1.12	C42C1.5
+F11A5.12	C42C1.5
+F14B4.2	C42C1.5
+F25G6.5	C42C1.5
+F52B11.2	C42C1.5
+F53A2.8	C42C1.5
+F56H6.5	C42C1.5
+K02B2.1	C42C1.5
+K03H1.13	C42C1.5
+K07A3.1	C42C1.5
+R01H2.5	C42C1.5
+R04B5.5	C42C1.5
+R04B5.6	C42C1.5
+T05D4.1	C42C1.5
+Y110A7A.6	C42C1.5
+Y17G7B.7	C42C1.5
+Y39G8B.1	C42C1.5
+Y47D9A.1	C42C1.5
+Y71H10A.1	C42C1.5
+ZK632.4	C42C1.5
+C53B4.7	C50F4.2
+C56G2.6	C50F4.2
+F11A5.12	C50F4.2
+F25G6.5	C50F4.2
+F52B11.2	C50F4.2
+F53A2.8	C50F4.2
+F56H6.5	C50F4.2
+K02B2.1	C50F4.2
+K03H1.13	C50F4.2
+R01H2.5	C50F4.2
+R04B5.5	C50F4.2
+R04B5.6	C50F4.2
+Y110A7A.6	C50F4.2
+Y39G8B.1	C50F4.2
+Y47D9A.1	C50F4.2
+ZK632.4	C50F4.2
+C56G2.6	C53B4.7
+F01F1.12	C53B4.7
+F11A5.12	C53B4.7
+F14B4.2	C53B4.7
+F25G6.5	C53B4.7
+F52B11.2	C53B4.7
+F53A2.8	C53B4.7
+K02B2.1	C53B4.7
+K03H1.13	C53B4.7
+K07A3.1	C53B4.7
+R04B5.5	C53B4.7
+R04B5.6	C53B4.7
+T05D4.1	C53B4.7
+Y110A7A.6	C53B4.7
+Y17G7B.7	C53B4.7
+Y39G8B.1	C53B4.7
+Y47D9A.1	C53B4.7
+Y71H10A.1	C53B4.7
+ZK632.4	C53B4.7
+F01F1.12	C56G2.6
+F11A5.12	C56G2.6
+F14B4.2	C56G2.6
+F25G6.5	C56G2.6
+F52B11.2	C56G2.6
+F53A2.8	C56G2.6
+F56H6.5	C56G2.6
+K02B2.1	C56G2.6
+K03H1.13	C56G2.6
+K07A3.1	C56G2.6
+R01H2.5	C56G2.6
+R04B5.5	C56G2.6
+R04B5.6	C56G2.6
+T05D4.1	C56G2.6
+Y110A7A.6	C56G2.6
+Y17G7B.7	C56G2.6
+Y39G8B.1	C56G2.6
+Y47D9A.1	C56G2.6
+Y71H10A.1	C56G2.6
+ZK632.4	C56G2.6
+F11A5.12	F01F1.12
+F25G6.5	F01F1.12
+F52B11.2	F01F1.12
+F53A2.8	F01F1.12
+F56H6.5	F01F1.12
+K02B2.1	F01F1.12
+K03H1.13	F01F1.12
+R01H2.5	F01F1.12
+R04B5.5	F01F1.12
+R04B5.6	F01F1.12
+Y110A7A.6	F01F1.12
+Y39G8B.1	F01F1.12
+Y47D9A.1	F01F1.12
+ZK632.4	F01F1.12
+F14B4.2	F11A5.12
+F25G6.5	F11A5.12
+F52B11.2	F11A5.12
+F53A2.8	F11A5.12
+F56H6.5	F11A5.12
+K02B2.1	F11A5.12
+K03H1.13	F11A5.12
+K07A3.1	F11A5.12
+R01H2.5	F11A5.12
+R04B5.5	F11A5.12
+R04B5.6	F11A5.12
+T05D4.1	F11A5.12
+Y110A7A.6	F11A5.12
+Y17G7B.7	F11A5.12
+Y39G8B.1	F11A5.12
+Y47D9A.1	F11A5.12
+Y71H10A.1	F11A5.12
+ZK632.4	F11A5.12
+F25G6.5	F14B4.2
+F52B11.2	F14B4.2
+F53A2.8	F14B4.2
+F56H6.5	F14B4.2
+K02B2.1	F14B4.2
+K03H1.13	F14B4.2
+R01H2.5	F14B4.2
+R04B5.5	F14B4.2
+R04B5.6	F14B4.2
+Y110A7A.6	F14B4.2
+Y39G8B.1	F14B4.2
+Y47D9A.1	F14B4.2
+ZK632.4	F14B4.2
+F52B11.2	F25G6.5
+F53A2.8	F25G6.5
+F56H6.5	F25G6.5
+K02B2.1	F25G6.5
+K03H1.13	F25G6.5
+K07A3.1	F25G6.5
+R01H2.5	F25G6.5
+R04B5.5	F25G6.5
+R04B5.6	F25G6.5
+T05D4.1	F25G6.5
+Y110A7A.6	F25G6.5
+Y17G7B.7	F25G6.5
+Y39G8B.1	F25G6.5
+Y47D9A.1	F25G6.5
+Y71H10A.1	F25G6.5
+ZK632.4	F25G6.5
+F53A2.8	F52B11.2
+F56H6.5	F52B11.2
+K02B2.1	F52B11.2
+K03H1.13	F52B11.2
+K07A3.1	F52B11.2
+R01H2.5	F52B11.2
+R04B5.5	F52B11.2
+R04B5.6	F52B11.2
+T05D4.1	F52B11.2
+Y110A7A.6	F52B11.2
+Y17G7B.7	F52B11.2
+Y39G8B.1	F52B11.2
+Y47D9A.1	F52B11.2
+Y71H10A.1	F52B11.2
+ZK632.4	F52B11.2
+F56H6.5	F53A2.8
+K02B2.1	F53A2.8
+K03H1.13	F53A2.8
+K07A3.1	F53A2.8
+R01H2.5	F53A2.8
+R04B5.5	F53A2.8
+R04B5.6	F53A2.8
+T05D4.1	F53A2.8
+Y110A7A.6	F53A2.8
+Y17G7B.7	F53A2.8
+Y39G8B.1	F53A2.8
+Y47D9A.1	F53A2.8
+Y71H10A.1	F53A2.8
+ZK632.4	F53A2.8
+K02B2.1	F56H6.5
+K03H1.13	F56H6.5
+K07A3.1	F56H6.5
+R04B5.5	F56H6.5
+R04B5.6	F56H6.5
+T05D4.1	F56H6.5
+Y110A7A.6	F56H6.5
+Y17G7B.7	F56H6.5
+Y39G8B.1	F56H6.5
+Y47D9A.1	F56H6.5
+Y71H10A.1	F56H6.5
+ZK632.4	F56H6.5
+K03H1.13	K02B2.1
+K07A3.1	K02B2.1
+R01H2.5	K02B2.1
+R04B5.5	K02B2.1
+R04B5.6	K02B2.1
+T05D4.1	K02B2.1
+Y110A7A.6	K02B2.1
+Y17G7B.7	K02B2.1
+Y39G8B.1	K02B2.1
+Y47D9A.1	K02B2.1
+Y71H10A.1	K02B2.1
+ZK632.4	K02B2.1
+K07A3.1	K03H1.13
+R01H2.5	K03H1.13
+R04B5.5	K03H1.13
+R04B5.6	K03H1.13
+T05D4.1	K03H1.13
+Y110A7A.6	K03H1.13
+Y17G7B.7	K03H1.13
+Y39G8B.1	K03H1.13
+Y47D9A.1	K03H1.13
+Y71H10A.1	K03H1.13
+ZK632.4	K03H1.13
+R01H2.5	K07A3.1
+R04B5.5	K07A3.1
+R04B5.6	K07A3.1
+Y110A7A.6	K07A3.1
+Y39G8B.1	K07A3.1
+Y47D9A.1	K07A3.1
+ZK632.4	K07A3.1
+R04B5.5	R01H2.5
+R04B5.6	R01H2.5
+T05D4.1	R01H2.5
+Y110A7A.6	R01H2.5
+Y17G7B.7	R01H2.5
+Y39G8B.1	R01H2.5
+Y47D9A.1	R01H2.5
+Y71H10A.1	R01H2.5
+ZK632.4	R01H2.5
+R04B5.6	R04B5.5
+T05D4.1	R04B5.5
+Y110A7A.6	R04B5.5
+Y17G7B.7	R04B5.5
+Y39G8B.1	R04B5.5
+Y47D9A.1	R04B5.5
+Y71H10A.1	R04B5.5
+ZK632.4	R04B5.5
+T05D4.1	R04B5.6
+Y110A7A.6	R04B5.6
+Y17G7B.7	R04B5.6
+Y39G8B.1	R04B5.6
+Y47D9A.1	R04B5.6
+Y71H10A.1	R04B5.6
+ZK632.4	R04B5.6
+Y110A7A.6	T05D4.1
+Y39G8B.1	T05D4.1
+Y47D9A.1	T05D4.1
+ZK632.4	T05D4.1
+Y17G7B.7	Y110A7A.6
+Y39G8B.1	Y110A7A.6
+Y47D9A.1	Y110A7A.6
+Y71H10A.1	Y110A7A.6
+ZK632.4	Y110A7A.6
+Y39G8B.1	Y17G7B.7
+Y47D9A.1	Y17G7B.7
+ZK632.4	Y17G7B.7
+Y47D9A.1	Y39G8B.1
+Y71H10A.1	Y39G8B.1
+ZK632.4	Y39G8B.1
+Y71H10A.1	Y47D9A.1
+ZK632.4	Y47D9A.1
+ZK632.4	Y71H10A.1
+C50F4.2	C47B2.6
+D2096.3	C47B2.6
+F14B4.2	C47B2.6
+K08E3.5	C47B2.6
+M01D7.4	C47B2.6
+R05F9.6	C47B2.6
+T19B10.3	C47B2.6
+Y39G8B.1	C47B2.6
+Y43F4B.5	C47B2.6
+Y71H10A.1	C47B2.6
+ZK1058.3	C47B2.6
+D2096.3	C50F4.2
+K08E3.5	C50F4.2
+M01D7.4	C50F4.2
+T19B10.3	C50F4.2
+ZK1058.3	C50F4.2
+F14B4.2	D2096.3
+K08E3.5	D2096.3
+M01D7.4	D2096.3
+R05F9.6	D2096.3
+T19B10.3	D2096.3
+Y39G8B.1	D2096.3
+Y43F4B.5	D2096.3
+Y71H10A.1	D2096.3
+ZK1058.3	D2096.3
+K08E3.5	F14B4.2
+M01D7.4	F14B4.2
+T19B10.3	F14B4.2
+ZK1058.3	F14B4.2
+M01D7.4	K08E3.5
+R05F9.6	K08E3.5
+T19B10.3	K08E3.5
+Y43F4B.5	K08E3.5
+Y71H10A.1	K08E3.5
+ZK1058.3	K08E3.5
+R05F9.6	M01D7.4
+T19B10.3	M01D7.4
+Y39G8B.1	M01D7.4
+Y43F4B.5	M01D7.4
+Y71H10A.1	M01D7.4
+ZK1058.3	M01D7.4
+T19B10.3	R05F9.6
+Y39G8B.1	R05F9.6
+ZK1058.3	R05F9.6
+Y39G8B.1	T19B10.3
+Y43F4B.5	T19B10.3
+Y71H10A.1	T19B10.3
+ZK1058.3	T19B10.3
+Y43F4B.5	Y39G8B.1
+ZK1058.3	Y39G8B.1
+ZK1058.3	Y43F4B.5
+ZK1058.3	Y71H10A.1
+C54E4.5	B0310.5
+F01F1.6	B0310.5
+Y69F12A.2	B0310.5
+C54E4.5	C17G1.3
+F01F1.6	C17G1.3
+Y69F12A.2	C17G1.3
+C54E4.5	C18C4.3
+F01F1.6	C18C4.3
+Y69F12A.2	C18C4.3
+F01F1.6	C54E4.5
+F29F11.1	C54E4.5
+F35H8.6	C54E4.5
+F39G3.1	C54E4.5
+F54D8.3	C54E4.5
+K04F1.15	C54E4.5
+M88.1	C54E4.5
+T04H1.7	C54E4.5
+T04H1.8	C54E4.5
+T05H4.13	C54E4.5
+T07C5.1	C54E4.5
+Y69F12A.2	C54E4.5
+F29F11.1	F01F1.6
+F35H8.6	F01F1.6
+F39G3.1	F01F1.6
+M88.1	F01F1.6
+T04H1.7	F01F1.6
+T04H1.8	F01F1.6
+T07C5.1	F01F1.6
+Y69F12A.2	F29F11.1
+Y69F12A.2	F35H8.6
+Y69F12A.2	F39G3.1
+Y69F12A.2	M88.1
+Y69F12A.2	T04H1.7
+Y69F12A.2	T04H1.8
+Y69F12A.2	T07C5.1
+W09B6.1	F32H2.5
+B0303.3	B0272.3
+C15F1.6	B0272.3
+C29F3.1	B0272.3
+F01G10.2	B0272.3
+F01G10.3	B0272.3
+F44C4.5	B0272.3
+F53A2.7	B0272.3
+F54C8.1	B0272.3
+R09B5.6	B0272.3
+T05G5.6	B0272.3
+T08B2.7	B0272.3
+T15B7.2	B0272.3
+W09H1.5	B0272.3
+Y48A6B.9	B0272.3
+C15F1.6	B0303.3
+C29F3.1	B0303.3
+F01G10.2	B0303.3
+F01G10.3	B0303.3
+F44C4.5	B0303.3
+F53A2.7	B0303.3
+F54C8.1	B0303.3
+R09B5.6	B0303.3
+T05G5.6	B0303.3
+T08B2.7	B0303.3
+T15B7.2	B0303.3
+W09H1.5	B0303.3
+Y48A6B.9	B0303.3
+C29F3.1	C15F1.6
+F01G10.2	C15F1.6
+F01G10.3	C15F1.6
+F44C4.5	C15F1.6
+F53A2.7	C15F1.6
+F54C8.1	C15F1.6
+R09B5.6	C15F1.6
+T05G5.6	C15F1.6
+T08B2.7	C15F1.6
+T15B7.2	C15F1.6
+W09H1.5	C15F1.6
+Y48A6B.9	C15F1.6
+F01G10.2	C29F3.1
+F01G10.3	C29F3.1
+F44C4.5	C29F3.1
+F53A2.7	C29F3.1
+F54C8.1	C29F3.1
+R09B5.6	C29F3.1
+T05G5.6	C29F3.1
+T08B2.7	C29F3.1
+T15B7.2	C29F3.1
+W09H1.5	C29F3.1
+Y48A6B.9	C29F3.1
+F01G10.3	F01G10.2
+F44C4.5	F01G10.2
+F53A2.7	F01G10.2
+F54C8.1	F01G10.2
+R09B5.6	F01G10.2
+T05G5.6	F01G10.2
+T08B2.7	F01G10.2
+T15B7.2	F01G10.2
+W09H1.5	F01G10.2
+Y48A6B.9	F01G10.2
+F44C4.5	F01G10.3
+F53A2.7	F01G10.3
+F54C8.1	F01G10.3
+R09B5.6	F01G10.3
+T05G5.6	F01G10.3
+T08B2.7	F01G10.3
+T15B7.2	F01G10.3
+W09H1.5	F01G10.3
+Y48A6B.9	F01G10.3
+F53A2.7	F44C4.5
+F54C8.1	F44C4.5
+R09B5.6	F44C4.5
+T05G5.6	F44C4.5
+T08B2.7	F44C4.5
+T15B7.2	F44C4.5
+W09H1.5	F44C4.5
+Y48A6B.9	F44C4.5
+F54C8.1	F53A2.7
+R09B5.6	F53A2.7
+T05G5.6	F53A2.7
+T08B2.7	F53A2.7
+T15B7.2	F53A2.7
+W09H1.5	F53A2.7
+Y48A6B.9	F53A2.7
+R09B5.6	F54C8.1
+T05G5.6	F54C8.1
+T08B2.7	F54C8.1
+T15B7.2	F54C8.1
+W09H1.5	F54C8.1
+Y48A6B.9	F54C8.1
+T05G5.6	R09B5.6
+T08B2.7	R09B5.6
+T15B7.2	R09B5.6
+W09H1.5	R09B5.6
+Y48A6B.9	R09B5.6
+T08B2.7	T05G5.6
+T15B7.2	T05G5.6
+W09H1.5	T05G5.6
+Y48A6B.9	T05G5.6
+T15B7.2	T08B2.7
+W09H1.5	T08B2.7
+Y48A6B.9	T08B2.7
+W09H1.5	T15B7.2
+Y48A6B.9	T15B7.2
+Y48A6B.9	W09H1.5
+C46F4.2	B0272.3
+C48B4.1	B0272.3
+C49C8.4	B0272.3
+D2063.1	B0272.3
+E04F6.5	B0272.3
+F01F1.6	B0272.3
+F08A8.1	B0272.3
+F08A8.2	B0272.3
+F08A8.3	B0272.3
+F08A8.4	B0272.3
+F28F8.2	B0272.3
+F37C12.7	B0272.3
+F42A9.5	B0272.3
+F47G6.2	B0272.3
+F54D5.7	B0272.3
+F54D8.3	B0272.3
+F58F9.7	B0272.3
+F59F4.1	B0272.3
+H24K24.3	B0272.3
+K04F1.15	B0272.3
+K05F1.3	B0272.3
+K06A5.6	B0272.3
+K09H11.1	B0272.3
+K12G11.3	B0272.3
+K12G11.4	B0272.3
+R06F6.9	B0272.3
+R07C3.4	B0272.3
+R07H5.2	B0272.3
+R08F11.3	B0272.3
+R09E10.3	B0272.3
+R09E10.4	B0272.3
+T02G5.4	B0272.3
+T02G5.7	B0272.3
+T02G5.8	B0272.3
+T05H4.13	B0272.3
+T08B1.6	B0272.3
+T08G2.3	B0272.3
+T25G12.5	B0272.3
+Y46G5A.17	B0272.3
+Y49C4A.9	B0272.3
+Y65B4BL.5	B0272.3
+Y69F12A.2	B0272.3
+Y76A2B.3	B0272.3
+C46F4.2	B0303.3
+C48B4.1	B0303.3
+C49C8.4	B0303.3
+D2063.1	B0303.3
+E04F6.5	B0303.3
+F01F1.6	B0303.3
+F08A8.1	B0303.3
+F08A8.2	B0303.3
+F08A8.3	B0303.3
+F08A8.4	B0303.3
+F28F8.2	B0303.3
+F37C12.7	B0303.3
+F42A9.5	B0303.3
+F47G6.2	B0303.3
+F54D5.7	B0303.3
+F54D8.3	B0303.3
+F58F9.7	B0303.3
+F59F4.1	B0303.3
+H24K24.3	B0303.3
+K04F1.15	B0303.3
+K05F1.3	B0303.3
+K06A5.6	B0303.3
+K09H11.1	B0303.3
+K12G11.3	B0303.3
+K12G11.4	B0303.3
+R06F6.9	B0303.3
+R07C3.4	B0303.3
+R07H5.2	B0303.3
+R08F11.3	B0303.3
+R09E10.3	B0303.3
+R09E10.4	B0303.3
+T02G5.4	B0303.3
+T02G5.7	B0303.3
+T02G5.8	B0303.3
+T05H4.13	B0303.3
+T08B1.6	B0303.3
+T08G2.3	B0303.3
+T25G12.5	B0303.3
+Y46G5A.17	B0303.3
+Y49C4A.9	B0303.3
+Y65B4BL.5	B0303.3
+Y69F12A.2	B0303.3
+Y76A2B.3	B0303.3
+C46F4.2	C29F3.1
+C48B4.1	C29F3.1
+C49C8.4	C29F3.1
+D2063.1	C29F3.1
+E04F6.5	C29F3.1
+F01F1.6	C29F3.1
+F08A8.1	C29F3.1
+F08A8.2	C29F3.1
+F08A8.3	C29F3.1
+F08A8.4	C29F3.1
+F28F8.2	C29F3.1
+F37C12.7	C29F3.1
+F42A9.5	C29F3.1
+F47G6.2	C29F3.1
+F54D5.7	C29F3.1
+F54D8.3	C29F3.1
+F58F9.7	C29F3.1
+F59F4.1	C29F3.1
+H24K24.3	C29F3.1
+K04F1.15	C29F3.1
+K05F1.3	C29F3.1
+K06A5.6	C29F3.1
+K09H11.1	C29F3.1
+K12G11.3	C29F3.1
+K12G11.4	C29F3.1
+R06F6.9	C29F3.1
+R07C3.4	C29F3.1
+R07H5.2	C29F3.1
+R08F11.3	C29F3.1
+R09E10.3	C29F3.1
+R09E10.4	C29F3.1
+T02G5.4	C29F3.1
+T02G5.7	C29F3.1
+T02G5.8	C29F3.1
+T05H4.13	C29F3.1
+T08B1.6	C29F3.1
+T08G2.3	C29F3.1
+T25G12.5	C29F3.1
+Y46G5A.17	C29F3.1
+Y49C4A.9	C29F3.1
+Y65B4BL.5	C29F3.1
+Y69F12A.2	C29F3.1
+Y76A2B.3	C29F3.1
+C48B4.1	C46F4.2
+C49C8.4	C46F4.2
+D2063.1	C46F4.2
+E04F6.5	C46F4.2
+F01F1.6	C46F4.2
+F01G10.2	C46F4.2
+F01G10.3	C46F4.2
+F08A8.1	C46F4.2
+F08A8.2	C46F4.2
+F08A8.3	C46F4.2
+F08A8.4	C46F4.2
+F28F8.2	C46F4.2
+F37C12.7	C46F4.2
+F42A9.5	C46F4.2
+F47G6.2	C46F4.2
+F53A2.7	C46F4.2
+F54C8.1	C46F4.2
+F54D5.7	C46F4.2
+F54D8.3	C46F4.2
+F58F9.7	C46F4.2
+F59F4.1	C46F4.2
+H24K24.3	C46F4.2
+K04F1.15	C46F4.2
+K05F1.3	C46F4.2
+K06A5.6	C46F4.2
+K09H11.1	C46F4.2
+K12G11.3	C46F4.2
+K12G11.4	C46F4.2
+R06F6.9	C46F4.2
+R07C3.4	C46F4.2
+R07H5.2	C46F4.2
+R08F11.3	C46F4.2
+R09B5.6	C46F4.2
+R09E10.3	C46F4.2
+R09E10.4	C46F4.2
+T02G5.4	C46F4.2
+T02G5.7	C46F4.2
+T02G5.8	C46F4.2
+T05G5.6	C46F4.2
+T05H4.13	C46F4.2
+T08B1.6	C46F4.2
+T08B2.7	C46F4.2
+T08G2.3	C46F4.2
+T25G12.5	C46F4.2
+Y46G5A.17	C46F4.2
+Y49C4A.9	C46F4.2
+Y65B4BL.5	C46F4.2
+Y69F12A.2	C46F4.2
+Y76A2B.3	C46F4.2
+C49C8.4	C48B4.1
+D2063.1	C48B4.1
+E04F6.5	C48B4.1
+F01F1.6	C48B4.1
+F01G10.2	C48B4.1
+F01G10.3	C48B4.1
+F08A8.1	C48B4.1
+F08A8.2	C48B4.1
+F08A8.3	C48B4.1
+F08A8.4	C48B4.1
+F28F8.2	C48B4.1
+F37C12.7	C48B4.1
+F42A9.5	C48B4.1
+F47G6.2	C48B4.1
+F53A2.7	C48B4.1
+F54C8.1	C48B4.1
+F54D5.7	C48B4.1
+F54D8.3	C48B4.1
+F58F9.7	C48B4.1
+F59F4.1	C48B4.1
+H24K24.3	C48B4.1
+K04F1.15	C48B4.1
+K05F1.3	C48B4.1
+K06A5.6	C48B4.1
+K09H11.1	C48B4.1
+K12G11.3	C48B4.1
+K12G11.4	C48B4.1
+R06F6.9	C48B4.1
+R07C3.4	C48B4.1
+R07H5.2	C48B4.1
+R08F11.3	C48B4.1
+R09B5.6	C48B4.1
+R09E10.3	C48B4.1
+R09E10.4	C48B4.1
+T02G5.4	C48B4.1
+T02G5.7	C48B4.1
+T02G5.8	C48B4.1
+T05G5.6	C48B4.1
+T05H4.13	C48B4.1
+T08B1.6	C48B4.1
+T08B2.7	C48B4.1
+T08G2.3	C48B4.1
+T25G12.5	C48B4.1
+Y46G5A.17	C48B4.1
+Y49C4A.9	C48B4.1
+Y65B4BL.5	C48B4.1
+Y69F12A.2	C48B4.1
+Y76A2B.3	C48B4.1
+D2063.1	C49C8.4
+E04F6.5	C49C8.4
+F01F1.6	C49C8.4
+F01G10.2	C49C8.4
+F01G10.3	C49C8.4
+F08A8.1	C49C8.4
+F08A8.2	C49C8.4
+F08A8.3	C49C8.4
+F08A8.4	C49C8.4
+F28F8.2	C49C8.4
+F37C12.7	C49C8.4
+F42A9.5	C49C8.4
+F47G6.2	C49C8.4
+F53A2.7	C49C8.4
+F54C8.1	C49C8.4
+F54D5.7	C49C8.4
+F54D8.3	C49C8.4
+F58F9.7	C49C8.4
+F59F4.1	C49C8.4
+H24K24.3	C49C8.4
+K04F1.15	C49C8.4
+K05F1.3	C49C8.4
+K06A5.6	C49C8.4
+K09H11.1	C49C8.4
+K12G11.3	C49C8.4
+K12G11.4	C49C8.4
+R06F6.9	C49C8.4
+R07C3.4	C49C8.4
+R07H5.2	C49C8.4
+R08F11.3	C49C8.4
+R09B5.6	C49C8.4
+R09E10.3	C49C8.4
+R09E10.4	C49C8.4
+T02G5.4	C49C8.4
+T02G5.7	C49C8.4
+T02G5.8	C49C8.4
+T05G5.6	C49C8.4
+T05H4.13	C49C8.4
+T08B1.6	C49C8.4
+T08B2.7	C49C8.4
+T08G2.3	C49C8.4
+T25G12.5	C49C8.4
+Y46G5A.17	C49C8.4
+Y49C4A.9	C49C8.4
+Y65B4BL.5	C49C8.4
+Y69F12A.2	C49C8.4
+Y76A2B.3	C49C8.4
+E04F6.5	D2063.1
+F01G10.2	D2063.1
+F01G10.3	D2063.1
+F08A8.1	D2063.1
+F08A8.2	D2063.1
+F08A8.3	D2063.1
+F08A8.4	D2063.1
+F28F8.2	D2063.1
+F37C12.7	D2063.1
+F42A9.5	D2063.1
+F47G6.2	D2063.1
+F53A2.7	D2063.1
+F54C8.1	D2063.1
+F54D5.7	D2063.1
+F58F9.7	D2063.1
+F59F4.1	D2063.1
+K05F1.3	D2063.1
+K06A5.6	D2063.1
+K09H11.1	D2063.1
+R06F6.9	D2063.1
+R07C3.4	D2063.1
+R07H5.2	D2063.1
+R08F11.3	D2063.1
+R09B5.6	D2063.1
+R09E10.3	D2063.1
+R09E10.4	D2063.1
+T02G5.4	D2063.1
+T02G5.7	D2063.1
+T02G5.8	D2063.1
+T05G5.6	D2063.1
+T08B1.6	D2063.1
+T08B2.7	D2063.1
+T08G2.3	D2063.1
+T25G12.5	D2063.1
+Y46G5A.17	D2063.1
+Y49C4A.9	D2063.1
+Y65B4BL.5	D2063.1
+Y76A2B.3	D2063.1
+F01F1.6	E04F6.5
+F01G10.2	E04F6.5
+F01G10.3	E04F6.5
+F08A8.1	E04F6.5
+F08A8.2	E04F6.5
+F08A8.3	E04F6.5
+F08A8.4	E04F6.5
+F28F8.2	E04F6.5
+F37C12.7	E04F6.5
+F42A9.5	E04F6.5
+F47G6.2	E04F6.5
+F53A2.7	E04F6.5
+F54C8.1	E04F6.5
+F54D5.7	E04F6.5
+F54D8.3	E04F6.5
+F58F9.7	E04F6.5
+F59F4.1	E04F6.5
+H24K24.3	E04F6.5
+K04F1.15	E04F6.5
+K05F1.3	E04F6.5
+K06A5.6	E04F6.5
+K09H11.1	E04F6.5
+K12G11.3	E04F6.5
+K12G11.4	E04F6.5
+R06F6.9	E04F6.5
+R07C3.4	E04F6.5
+R07H5.2	E04F6.5
+R08F11.3	E04F6.5
+R09B5.6	E04F6.5
+R09E10.3	E04F6.5
+R09E10.4	E04F6.5
+T02G5.4	E04F6.5
+T02G5.7	E04F6.5
+T02G5.8	E04F6.5
+T05G5.6	E04F6.5
+T05H4.13	E04F6.5
+T08B1.6	E04F6.5
+T08B2.7	E04F6.5
+T08G2.3	E04F6.5
+T25G12.5	E04F6.5
+Y46G5A.17	E04F6.5
+Y49C4A.9	E04F6.5
+Y65B4BL.5	E04F6.5
+Y69F12A.2	E04F6.5
+Y76A2B.3	E04F6.5
+F01G10.2	F01F1.6
+F01G10.3	F01F1.6
+F08A8.1	F01F1.6
+F08A8.2	F01F1.6
+F08A8.3	F01F1.6
+F08A8.4	F01F1.6
+F28F8.2	F01F1.6
+F37C12.7	F01F1.6
+F42A9.5	F01F1.6
+F47G6.2	F01F1.6
+F53A2.7	F01F1.6
+F54C8.1	F01F1.6
+F54D5.7	F01F1.6
+F58F9.7	F01F1.6
+F59F4.1	F01F1.6
+K05F1.3	F01F1.6
+K06A5.6	F01F1.6
+K09H11.1	F01F1.6
+R06F6.9	F01F1.6
+R07C3.4	F01F1.6
+R07H5.2	F01F1.6
+R08F11.3	F01F1.6
+R09B5.6	F01F1.6
+R09E10.3	F01F1.6
+R09E10.4	F01F1.6
+T02G5.4	F01F1.6
+T02G5.7	F01F1.6
+T02G5.8	F01F1.6
+T05G5.6	F01F1.6
+T08B1.6	F01F1.6
+T08B2.7	F01F1.6
+T08G2.3	F01F1.6
+T25G12.5	F01F1.6
+Y46G5A.17	F01F1.6
+Y49C4A.9	F01F1.6
+Y65B4BL.5	F01F1.6
+Y76A2B.3	F01F1.6
+F08A8.1	F01G10.2
+F08A8.2	F01G10.2
+F08A8.3	F01G10.2
+F08A8.4	F01G10.2
+F28F8.2	F01G10.2
+F37C12.7	F01G10.2
+F42A9.5	F01G10.2
+F47G6.2	F01G10.2
+F54D5.7	F01G10.2
+F54D8.3	F01G10.2
+F58F9.7	F01G10.2
+F59F4.1	F01G10.2
+H24K24.3	F01G10.2
+K04F1.15	F01G10.2
+K05F1.3	F01G10.2
+K06A5.6	F01G10.2
+K09H11.1	F01G10.2
+K12G11.3	F01G10.2
+K12G11.4	F01G10.2
+R06F6.9	F01G10.2
+R07C3.4	F01G10.2
+R07H5.2	F01G10.2
+R08F11.3	F01G10.2
+R09E10.3	F01G10.2
+R09E10.4	F01G10.2
+T02G5.4	F01G10.2
+T02G5.7	F01G10.2
+T02G5.8	F01G10.2
+T05H4.13	F01G10.2
+T08B1.6	F01G10.2
+T08G2.3	F01G10.2
+T25G12.5	F01G10.2
+Y46G5A.17	F01G10.2
+Y49C4A.9	F01G10.2
+Y65B4BL.5	F01G10.2
+Y69F12A.2	F01G10.2
+Y76A2B.3	F01G10.2
+F08A8.1	F01G10.3
+F08A8.2	F01G10.3
+F08A8.3	F01G10.3
+F08A8.4	F01G10.3
+F28F8.2	F01G10.3
+F37C12.7	F01G10.3
+F42A9.5	F01G10.3
+F47G6.2	F01G10.3
+F54D5.7	F01G10.3
+F54D8.3	F01G10.3
+F58F9.7	F01G10.3
+F59F4.1	F01G10.3
+H24K24.3	F01G10.3
+K04F1.15	F01G10.3
+K05F1.3	F01G10.3
+K06A5.6	F01G10.3
+K09H11.1	F01G10.3
+K12G11.3	F01G10.3
+K12G11.4	F01G10.3
+R06F6.9	F01G10.3
+R07C3.4	F01G10.3
+R07H5.2	F01G10.3
+R08F11.3	F01G10.3
+R09E10.3	F01G10.3
+R09E10.4	F01G10.3
+T02G5.4	F01G10.3
+T02G5.7	F01G10.3
+T02G5.8	F01G10.3
+T05H4.13	F01G10.3
+T08B1.6	F01G10.3
+T08G2.3	F01G10.3
+T25G12.5	F01G10.3
+Y46G5A.17	F01G10.3
+Y49C4A.9	F01G10.3
+Y65B4BL.5	F01G10.3
+Y69F12A.2	F01G10.3
+Y76A2B.3	F01G10.3
+F08A8.2	F08A8.1
+F08A8.3	F08A8.1
+F08A8.4	F08A8.1
+F28F8.2	F08A8.1
+F37C12.7	F08A8.1
+F42A9.5	F08A8.1
+F47G6.2	F08A8.1
+F53A2.7	F08A8.1
+F54C8.1	F08A8.1
+F54D5.7	F08A8.1
+F54D8.3	F08A8.1
+F58F9.7	F08A8.1
+F59F4.1	F08A8.1
+H24K24.3	F08A8.1
+K04F1.15	F08A8.1
+K05F1.3	F08A8.1
+K06A5.6	F08A8.1
+K09H11.1	F08A8.1
+K12G11.3	F08A8.1
+K12G11.4	F08A8.1
+R06F6.9	F08A8.1
+R07C3.4	F08A8.1
+R07H5.2	F08A8.1
+R08F11.3	F08A8.1
+R09B5.6	F08A8.1
+R09E10.3	F08A8.1
+R09E10.4	F08A8.1
+T02G5.4	F08A8.1
+T02G5.7	F08A8.1
+T02G5.8	F08A8.1
+T05G5.6	F08A8.1
+T05H4.13	F08A8.1
+T08B1.6	F08A8.1
+T08B2.7	F08A8.1
+T08G2.3	F08A8.1
+T25G12.5	F08A8.1
+Y46G5A.17	F08A8.1
+Y49C4A.9	F08A8.1
+Y65B4BL.5	F08A8.1
+Y69F12A.2	F08A8.1
+Y76A2B.3	F08A8.1
+F08A8.3	F08A8.2
+F08A8.4	F08A8.2
+F28F8.2	F08A8.2
+F37C12.7	F08A8.2
+F42A9.5	F08A8.2
+F47G6.2	F08A8.2
+F53A2.7	F08A8.2
+F54C8.1	F08A8.2
+F54D5.7	F08A8.2
+F54D8.3	F08A8.2
+F58F9.7	F08A8.2
+F59F4.1	F08A8.2
+H24K24.3	F08A8.2
+K04F1.15	F08A8.2
+K05F1.3	F08A8.2
+K06A5.6	F08A8.2
+K09H11.1	F08A8.2
+K12G11.3	F08A8.2
+K12G11.4	F08A8.2
+R06F6.9	F08A8.2
+R07C3.4	F08A8.2
+R07H5.2	F08A8.2
+R08F11.3	F08A8.2
+R09B5.6	F08A8.2
+R09E10.3	F08A8.2
+R09E10.4	F08A8.2
+T02G5.4	F08A8.2
+T02G5.7	F08A8.2
+T02G5.8	F08A8.2
+T05G5.6	F08A8.2
+T05H4.13	F08A8.2
+T08B1.6	F08A8.2
+T08B2.7	F08A8.2
+T08G2.3	F08A8.2
+T25G12.5	F08A8.2
+Y46G5A.17	F08A8.2
+Y49C4A.9	F08A8.2
+Y65B4BL.5	F08A8.2
+Y69F12A.2	F08A8.2
+Y76A2B.3	F08A8.2
+F08A8.4	F08A8.3
+F28F8.2	F08A8.3
+F37C12.7	F08A8.3
+F42A9.5	F08A8.3
+F47G6.2	F08A8.3
+F53A2.7	F08A8.3
+F54C8.1	F08A8.3
+F54D5.7	F08A8.3
+F54D8.3	F08A8.3
+F58F9.7	F08A8.3
+F59F4.1	F08A8.3
+H24K24.3	F08A8.3
+K04F1.15	F08A8.3
+K05F1.3	F08A8.3
+K06A5.6	F08A8.3
+K09H11.1	F08A8.3
+K12G11.3	F08A8.3
+K12G11.4	F08A8.3
+R06F6.9	F08A8.3
+R07C3.4	F08A8.3
+R07H5.2	F08A8.3
+R08F11.3	F08A8.3
+R09B5.6	F08A8.3
+R09E10.3	F08A8.3
+R09E10.4	F08A8.3
+T02G5.4	F08A8.3
+T02G5.7	F08A8.3
+T02G5.8	F08A8.3
+T05G5.6	F08A8.3
+T05H4.13	F08A8.3
+T08B1.6	F08A8.3
+T08B2.7	F08A8.3
+T08G2.3	F08A8.3
+T25G12.5	F08A8.3
+Y46G5A.17	F08A8.3
+Y49C4A.9	F08A8.3
+Y65B4BL.5	F08A8.3
+Y69F12A.2	F08A8.3
+Y76A2B.3	F08A8.3
+F28F8.2	F08A8.4
+F37C12.7	F08A8.4
+F42A9.5	F08A8.4
+F47G6.2	F08A8.4
+F53A2.7	F08A8.4
+F54C8.1	F08A8.4
+F54D5.7	F08A8.4
+F54D8.3	F08A8.4
+F58F9.7	F08A8.4
+F59F4.1	F08A8.4
+H24K24.3	F08A8.4
+K04F1.15	F08A8.4
+K05F1.3	F08A8.4
+K06A5.6	F08A8.4
+K09H11.1	F08A8.4
+K12G11.3	F08A8.4
+K12G11.4	F08A8.4
+R06F6.9	F08A8.4
+R07C3.4	F08A8.4
+R07H5.2	F08A8.4
+R08F11.3	F08A8.4
+R09B5.6	F08A8.4
+R09E10.3	F08A8.4
+R09E10.4	F08A8.4
+T02G5.4	F08A8.4
+T02G5.7	F08A8.4
+T02G5.8	F08A8.4
+T05G5.6	F08A8.4
+T05H4.13	F08A8.4
+T08B1.6	F08A8.4
+T08B2.7	F08A8.4
+T08G2.3	F08A8.4
+T25G12.5	F08A8.4
+Y46G5A.17	F08A8.4
+Y49C4A.9	F08A8.4
+Y65B4BL.5	F08A8.4
+Y69F12A.2	F08A8.4
+Y76A2B.3	F08A8.4
+F37C12.7	F28F8.2
+F42A9.5	F28F8.2
+F47G6.2	F28F8.2
+F53A2.7	F28F8.2
+F54C8.1	F28F8.2
+F54D5.7	F28F8.2
+F54D8.3	F28F8.2
+F58F9.7	F28F8.2
+F59F4.1	F28F8.2
+H24K24.3	F28F8.2
+K04F1.15	F28F8.2
+K05F1.3	F28F8.2
+K06A5.6	F28F8.2
+K09H11.1	F28F8.2
+K12G11.3	F28F8.2
+K12G11.4	F28F8.2
+R06F6.9	F28F8.2
+R07C3.4	F28F8.2
+R07H5.2	F28F8.2
+R08F11.3	F28F8.2
+R09B5.6	F28F8.2
+R09E10.3	F28F8.2
+R09E10.4	F28F8.2
+T02G5.4	F28F8.2
+T02G5.7	F28F8.2
+T02G5.8	F28F8.2
+T05G5.6	F28F8.2
+T05H4.13	F28F8.2
+T08B1.6	F28F8.2
+T08B2.7	F28F8.2
+T08G2.3	F28F8.2
+T25G12.5	F28F8.2
+Y46G5A.17	F28F8.2
+Y49C4A.9	F28F8.2
+Y65B4BL.5	F28F8.2
+Y69F12A.2	F28F8.2
+Y76A2B.3	F28F8.2
+F42A9.5	F37C12.7
+F47G6.2	F37C12.7
+F53A2.7	F37C12.7
+F54C8.1	F37C12.7
+F54D5.7	F37C12.7
+F54D8.3	F37C12.7
+F58F9.7	F37C12.7
+F59F4.1	F37C12.7
+H24K24.3	F37C12.7
+K04F1.15	F37C12.7
+K05F1.3	F37C12.7
+K06A5.6	F37C12.7
+K09H11.1	F37C12.7
+K12G11.3	F37C12.7
+K12G11.4	F37C12.7
+R06F6.9	F37C12.7
+R07C3.4	F37C12.7
+R07H5.2	F37C12.7
+R08F11.3	F37C12.7
+R09B5.6	F37C12.7
+R09E10.3	F37C12.7
+R09E10.4	F37C12.7
+T02G5.4	F37C12.7
+T02G5.7	F37C12.7
+T02G5.8	F37C12.7
+T05G5.6	F37C12.7
+T05H4.13	F37C12.7
+T08B1.6	F37C12.7
+T08B2.7	F37C12.7
+T08G2.3	F37C12.7
+T25G12.5	F37C12.7
+Y46G5A.17	F37C12.7
+Y49C4A.9	F37C12.7
+Y65B4BL.5	F37C12.7
+Y69F12A.2	F37C12.7
+Y76A2B.3	F37C12.7
+F47G6.2	F42A9.5
+F53A2.7	F42A9.5
+F54C8.1	F42A9.5
+F54D5.7	F42A9.5
+F54D8.3	F42A9.5
+F58F9.7	F42A9.5
+F59F4.1	F42A9.5
+H24K24.3	F42A9.5
+K04F1.15	F42A9.5
+K05F1.3	F42A9.5
+K06A5.6	F42A9.5
+K09H11.1	F42A9.5
+K12G11.3	F42A9.5
+K12G11.4	F42A9.5
+R06F6.9	F42A9.5
+R07C3.4	F42A9.5
+R07H5.2	F42A9.5
+R08F11.3	F42A9.5
+R09B5.6	F42A9.5
+R09E10.3	F42A9.5
+R09E10.4	F42A9.5
+T02G5.4	F42A9.5
+T02G5.7	F42A9.5
+T02G5.8	F42A9.5
+T05G5.6	F42A9.5
+T05H4.13	F42A9.5
+T08B1.6	F42A9.5
+T08B2.7	F42A9.5
+T08G2.3	F42A9.5
+T25G12.5	F42A9.5
+Y46G5A.17	F42A9.5
+Y49C4A.9	F42A9.5
+Y65B4BL.5	F42A9.5
+Y69F12A.2	F42A9.5
+Y76A2B.3	F42A9.5
+F53A2.7	F47G6.2
+F54C8.1	F47G6.2
+F54D5.7	F47G6.2
+F54D8.3	F47G6.2
+F58F9.7	F47G6.2
+F59F4.1	F47G6.2
+H24K24.3	F47G6.2
+K04F1.15	F47G6.2
+K05F1.3	F47G6.2
+K06A5.6	F47G6.2
+K09H11.1	F47G6.2
+K12G11.3	F47G6.2
+K12G11.4	F47G6.2
+R06F6.9	F47G6.2
+R07C3.4	F47G6.2
+R07H5.2	F47G6.2
+R08F11.3	F47G6.2
+R09B5.6	F47G6.2
+R09E10.3	F47G6.2
+R09E10.4	F47G6.2
+T02G5.4	F47G6.2
+T02G5.7	F47G6.2
+T02G5.8	F47G6.2
+T05G5.6	F47G6.2
+T05H4.13	F47G6.2
+T08B1.6	F47G6.2
+T08B2.7	F47G6.2
+T08G2.3	F47G6.2
+T25G12.5	F47G6.2
+Y46G5A.17	F47G6.2
+Y49C4A.9	F47G6.2
+Y65B4BL.5	F47G6.2
+Y69F12A.2	F47G6.2
+Y76A2B.3	F47G6.2
+F54D5.7	F53A2.7
+F54D8.3	F53A2.7
+F58F9.7	F53A2.7
+F59F4.1	F53A2.7
+H24K24.3	F53A2.7
+K04F1.15	F53A2.7
+K05F1.3	F53A2.7
+K06A5.6	F53A2.7
+K09H11.1	F53A2.7
+K12G11.3	F53A2.7
+K12G11.4	F53A2.7
+R06F6.9	F53A2.7
+R07C3.4	F53A2.7
+R07H5.2	F53A2.7
+R08F11.3	F53A2.7
+R09E10.3	F53A2.7
+R09E10.4	F53A2.7
+T02G5.4	F53A2.7
+T02G5.7	F53A2.7
+T02G5.8	F53A2.7
+T05H4.13	F53A2.7
+T08B1.6	F53A2.7
+T08G2.3	F53A2.7
+T25G12.5	F53A2.7
+Y46G5A.17	F53A2.7
+Y49C4A.9	F53A2.7
+Y65B4BL.5	F53A2.7
+Y69F12A.2	F53A2.7
+Y76A2B.3	F53A2.7
+F54D5.7	F54C8.1
+F54D8.3	F54C8.1
+F58F9.7	F54C8.1
+F59F4.1	F54C8.1
+H24K24.3	F54C8.1
+K04F1.15	F54C8.1
+K05F1.3	F54C8.1
+K06A5.6	F54C8.1
+K09H11.1	F54C8.1
+K12G11.3	F54C8.1
+K12G11.4	F54C8.1
+R06F6.9	F54C8.1
+R07C3.4	F54C8.1
+R07H5.2	F54C8.1
+R08F11.3	F54C8.1
+R09E10.3	F54C8.1
+R09E10.4	F54C8.1
+T02G5.4	F54C8.1
+T02G5.7	F54C8.1
+T02G5.8	F54C8.1
+T05H4.13	F54C8.1
+T08B1.6	F54C8.1
+T08G2.3	F54C8.1
+T25G12.5	F54C8.1
+Y46G5A.17	F54C8.1
+Y49C4A.9	F54C8.1
+Y65B4BL.5	F54C8.1
+Y69F12A.2	F54C8.1
+Y76A2B.3	F54C8.1
+F54D8.3	F54D5.7
+F58F9.7	F54D5.7
+F59F4.1	F54D5.7
+H24K24.3	F54D5.7
+K04F1.15	F54D5.7
+K05F1.3	F54D5.7
+K06A5.6	F54D5.7
+K09H11.1	F54D5.7
+K12G11.3	F54D5.7
+K12G11.4	F54D5.7
+R06F6.9	F54D5.7
+R07C3.4	F54D5.7
+R07H5.2	F54D5.7
+R08F11.3	F54D5.7
+R09B5.6	F54D5.7
+R09E10.3	F54D5.7
+R09E10.4	F54D5.7
+T02G5.4	F54D5.7
+T02G5.7	F54D5.7
+T02G5.8	F54D5.7
+T05G5.6	F54D5.7
+T05H4.13	F54D5.7
+T08B1.6	F54D5.7
+T08B2.7	F54D5.7
+T08G2.3	F54D5.7
+T25G12.5	F54D5.7
+Y46G5A.17	F54D5.7
+Y49C4A.9	F54D5.7
+Y65B4BL.5	F54D5.7
+Y69F12A.2	F54D5.7
+Y76A2B.3	F54D5.7
+F58F9.7	F54D8.3
+F59F4.1	F54D8.3
+K05F1.3	F54D8.3
+K06A5.6	F54D8.3
+K09H11.1	F54D8.3
+R06F6.9	F54D8.3
+R07C3.4	F54D8.3
+R07H5.2	F54D8.3
+R08F11.3	F54D8.3
+R09B5.6	F54D8.3
+R09E10.3	F54D8.3
+R09E10.4	F54D8.3
+T02G5.4	F54D8.3
+T02G5.7	F54D8.3
+T02G5.8	F54D8.3
+T05G5.6	F54D8.3
+T08B1.6	F54D8.3
+T08B2.7	F54D8.3
+T08G2.3	F54D8.3
+T25G12.5	F54D8.3
+Y46G5A.17	F54D8.3
+Y49C4A.9	F54D8.3
+Y65B4BL.5	F54D8.3
+Y76A2B.3	F54D8.3
+F59F4.1	F58F9.7
+H24K24.3	F58F9.7
+K04F1.15	F58F9.7
+K05F1.3	F58F9.7
+K06A5.6	F58F9.7
+K09H11.1	F58F9.7
+K12G11.3	F58F9.7
+K12G11.4	F58F9.7
+R06F6.9	F58F9.7
+R07C3.4	F58F9.7
+R07H5.2	F58F9.7
+R08F11.3	F58F9.7
+R09B5.6	F58F9.7
+R09E10.3	F58F9.7
+R09E10.4	F58F9.7
+T02G5.4	F58F9.7
+T02G5.7	F58F9.7
+T02G5.8	F58F9.7
+T05G5.6	F58F9.7
+T05H4.13	F58F9.7
+T08B1.6	F58F9.7
+T08B2.7	F58F9.7
+T08G2.3	F58F9.7
+T25G12.5	F58F9.7
+Y46G5A.17	F58F9.7
+Y49C4A.9	F58F9.7
+Y65B4BL.5	F58F9.7
+Y69F12A.2	F58F9.7
+Y76A2B.3	F58F9.7
+H24K24.3	F59F4.1
+K04F1.15	F59F4.1
+K05F1.3	F59F4.1
+K06A5.6	F59F4.1
+K09H11.1	F59F4.1
+K12G11.3	F59F4.1
+K12G11.4	F59F4.1
+R06F6.9	F59F4.1
+R07C3.4	F59F4.1
+R07H5.2	F59F4.1
+R08F11.3	F59F4.1
+R09B5.6	F59F4.1
+R09E10.3	F59F4.1
+R09E10.4	F59F4.1
+T02G5.4	F59F4.1
+T02G5.7	F59F4.1
+T02G5.8	F59F4.1
+T05G5.6	F59F4.1
+T05H4.13	F59F4.1
+T08B1.6	F59F4.1
+T08B2.7	F59F4.1
+T08G2.3	F59F4.1
+T25G12.5	F59F4.1
+Y46G5A.17	F59F4.1
+Y49C4A.9	F59F4.1
+Y65B4BL.5	F59F4.1
+Y69F12A.2	F59F4.1
+Y76A2B.3	F59F4.1
+K05F1.3	H24K24.3
+K06A5.6	H24K24.3
+K09H11.1	H24K24.3
+R06F6.9	H24K24.3
+R07C3.4	H24K24.3
+R07H5.2	H24K24.3
+R08F11.3	H24K24.3
+R09B5.6	H24K24.3
+R09E10.3	H24K24.3
+R09E10.4	H24K24.3
+T02G5.4	H24K24.3
+T02G5.7	H24K24.3
+T02G5.8	H24K24.3
+T05G5.6	H24K24.3
+T08B1.6	H24K24.3
+T08B2.7	H24K24.3
+T08G2.3	H24K24.3
+T25G12.5	H24K24.3
+Y46G5A.17	H24K24.3
+Y49C4A.9	H24K24.3
+Y65B4BL.5	H24K24.3
+Y76A2B.3	H24K24.3
+K05F1.3	K04F1.15
+K06A5.6	K04F1.15
+K09H11.1	K04F1.15
+R06F6.9	K04F1.15
+R07C3.4	K04F1.15
+R07H5.2	K04F1.15
+R08F11.3	K04F1.15
+R09B5.6	K04F1.15
+R09E10.3	K04F1.15
+R09E10.4	K04F1.15
+T02G5.4	K04F1.15
+T02G5.7	K04F1.15
+T02G5.8	K04F1.15
+T05G5.6	K04F1.15
+T08B1.6	K04F1.15
+T08B2.7	K04F1.15
+T08G2.3	K04F1.15
+T25G12.5	K04F1.15
+Y46G5A.17	K04F1.15
+Y49C4A.9	K04F1.15
+Y65B4BL.5	K04F1.15
+Y76A2B.3	K04F1.15
+K06A5.6	K05F1.3
+K09H11.1	K05F1.3
+K12G11.3	K05F1.3
+K12G11.4	K05F1.3
+R06F6.9	K05F1.3
+R07C3.4	K05F1.3
+R07H5.2	K05F1.3
+R08F11.3	K05F1.3
+R09B5.6	K05F1.3
+R09E10.3	K05F1.3
+R09E10.4	K05F1.3
+T02G5.4	K05F1.3
+T02G5.7	K05F1.3
+T02G5.8	K05F1.3
+T05G5.6	K05F1.3
+T05H4.13	K05F1.3
+T08B1.6	K05F1.3
+T08B2.7	K05F1.3
+T08G2.3	K05F1.3
+T25G12.5	K05F1.3
+Y46G5A.17	K05F1.3
+Y49C4A.9	K05F1.3
+Y65B4BL.5	K05F1.3
+Y69F12A.2	K05F1.3
+Y76A2B.3	K05F1.3
+K09H11.1	K06A5.6
+K12G11.3	K06A5.6
+K12G11.4	K06A5.6
+R06F6.9	K06A5.6
+R07C3.4	K06A5.6
+R07H5.2	K06A5.6
+R08F11.3	K06A5.6
+R09B5.6	K06A5.6
+R09E10.3	K06A5.6
+R09E10.4	K06A5.6
+T02G5.4	K06A5.6
+T02G5.7	K06A5.6
+T02G5.8	K06A5.6
+T05G5.6	K06A5.6
+T05H4.13	K06A5.6
+T08B1.6	K06A5.6
+T08B2.7	K06A5.6
+T08G2.3	K06A5.6
+T25G12.5	K06A5.6
+Y46G5A.17	K06A5.6
+Y49C4A.9	K06A5.6
+Y65B4BL.5	K06A5.6
+Y69F12A.2	K06A5.6
+Y76A2B.3	K06A5.6
+K12G11.3	K09H11.1
+K12G11.4	K09H11.1
+R06F6.9	K09H11.1
+R07C3.4	K09H11.1
+R07H5.2	K09H11.1
+R08F11.3	K09H11.1
+R09B5.6	K09H11.1
+R09E10.3	K09H11.1
+R09E10.4	K09H11.1
+T02G5.4	K09H11.1
+T02G5.7	K09H11.1
+T02G5.8	K09H11.1
+T05G5.6	K09H11.1
+T05H4.13	K09H11.1
+T08B1.6	K09H11.1
+T08B2.7	K09H11.1
+T08G2.3	K09H11.1
+T25G12.5	K09H11.1
+Y46G5A.17	K09H11.1
+Y49C4A.9	K09H11.1
+Y65B4BL.5	K09H11.1
+Y69F12A.2	K09H11.1
+Y76A2B.3	K09H11.1
+R06F6.9	K12G11.3
+R07C3.4	K12G11.3
+R07H5.2	K12G11.3
+R08F11.3	K12G11.3
+R09B5.6	K12G11.3
+R09E10.3	K12G11.3
+R09E10.4	K12G11.3
+T02G5.4	K12G11.3
+T02G5.7	K12G11.3
+T02G5.8	K12G11.3
+T05G5.6	K12G11.3
+T08B1.6	K12G11.3
+T08B2.7	K12G11.3
+T08G2.3	K12G11.3
+T25G12.5	K12G11.3
+Y46G5A.17	K12G11.3
+Y49C4A.9	K12G11.3
+Y65B4BL.5	K12G11.3
+Y76A2B.3	K12G11.3
+R06F6.9	K12G11.4
+R07C3.4	K12G11.4
+R07H5.2	K12G11.4
+R08F11.3	K12G11.4
+R09B5.6	K12G11.4
+R09E10.3	K12G11.4
+R09E10.4	K12G11.4
+T02G5.4	K12G11.4
+T02G5.7	K12G11.4
+T02G5.8	K12G11.4
+T05G5.6	K12G11.4
+T08B1.6	K12G11.4
+T08B2.7	K12G11.4
+T08G2.3	K12G11.4
+T25G12.5	K12G11.4
+Y46G5A.17	K12G11.4
+Y49C4A.9	K12G11.4
+Y65B4BL.5	K12G11.4
+Y76A2B.3	K12G11.4
+R07C3.4	R06F6.9
+R07H5.2	R06F6.9
+R08F11.3	R06F6.9
+R09B5.6	R06F6.9
+R09E10.3	R06F6.9
+R09E10.4	R06F6.9
+T02G5.4	R06F6.9
+T02G5.7	R06F6.9
+T02G5.8	R06F6.9
+T05G5.6	R06F6.9
+T05H4.13	R06F6.9
+T08B1.6	R06F6.9
+T08B2.7	R06F6.9
+T08G2.3	R06F6.9
+T25G12.5	R06F6.9
+Y46G5A.17	R06F6.9
+Y49C4A.9	R06F6.9
+Y65B4BL.5	R06F6.9
+Y69F12A.2	R06F6.9
+Y76A2B.3	R06F6.9
+R07H5.2	R07C3.4
+R08F11.3	R07C3.4
+R09B5.6	R07C3.4
+R09E10.3	R07C3.4
+R09E10.4	R07C3.4
+T02G5.4	R07C3.4
+T02G5.7	R07C3.4
+T02G5.8	R07C3.4
+T05G5.6	R07C3.4
+T05H4.13	R07C3.4
+T08B1.6	R07C3.4
+T08B2.7	R07C3.4
+T08G2.3	R07C3.4
+T25G12.5	R07C3.4
+Y46G5A.17	R07C3.4
+Y49C4A.9	R07C3.4
+Y65B4BL.5	R07C3.4
+Y69F12A.2	R07C3.4
+Y76A2B.3	R07C3.4
+R08F11.3	R07H5.2
+R09B5.6	R07H5.2
+R09E10.3	R07H5.2
+R09E10.4	R07H5.2
+T02G5.4	R07H5.2
+T02G5.7	R07H5.2
+T02G5.8	R07H5.2
+T05G5.6	R07H5.2
+T05H4.13	R07H5.2
+T08B1.6	R07H5.2
+T08B2.7	R07H5.2
+T08G2.3	R07H5.2
+T25G12.5	R07H5.2
+Y46G5A.17	R07H5.2
+Y49C4A.9	R07H5.2
+Y65B4BL.5	R07H5.2
+Y69F12A.2	R07H5.2
+Y76A2B.3	R07H5.2
+R09B5.6	R08F11.3
+R09E10.3	R08F11.3
+R09E10.4	R08F11.3
+T02G5.4	R08F11.3
+T02G5.7	R08F11.3
+T02G5.8	R08F11.3
+T05G5.6	R08F11.3
+T05H4.13	R08F11.3
+T08B1.6	R08F11.3
+T08B2.7	R08F11.3
+T08G2.3	R08F11.3
+T25G12.5	R08F11.3
+Y46G5A.17	R08F11.3
+Y49C4A.9	R08F11.3
+Y65B4BL.5	R08F11.3
+Y69F12A.2	R08F11.3
+Y76A2B.3	R08F11.3
+R09E10.3	R09B5.6
+R09E10.4	R09B5.6
+T02G5.4	R09B5.6
+T02G5.7	R09B5.6
+T02G5.8	R09B5.6
+T05H4.13	R09B5.6
+T08B1.6	R09B5.6
+T08G2.3	R09B5.6
+T25G12.5	R09B5.6
+Y46G5A.17	R09B5.6
+Y49C4A.9	R09B5.6
+Y65B4BL.5	R09B5.6
+Y69F12A.2	R09B5.6
+Y76A2B.3	R09B5.6
+R09E10.4	R09E10.3
+T02G5.4	R09E10.3
+T02G5.7	R09E10.3
+T02G5.8	R09E10.3
+T05G5.6	R09E10.3
+T05H4.13	R09E10.3
+T08B1.6	R09E10.3
+T08B2.7	R09E10.3
+T08G2.3	R09E10.3
+T25G12.5	R09E10.3
+Y46G5A.17	R09E10.3
+Y49C4A.9	R09E10.3
+Y65B4BL.5	R09E10.3
+Y69F12A.2	R09E10.3
+Y76A2B.3	R09E10.3
+T02G5.4	R09E10.4
+T02G5.7	R09E10.4
+T02G5.8	R09E10.4
+T05G5.6	R09E10.4
+T05H4.13	R09E10.4
+T08B1.6	R09E10.4
+T08B2.7	R09E10.4
+T08G2.3	R09E10.4
+T25G12.5	R09E10.4
+Y46G5A.17	R09E10.4
+Y49C4A.9	R09E10.4
+Y65B4BL.5	R09E10.4
+Y69F12A.2	R09E10.4
+Y76A2B.3	R09E10.4
+T02G5.7	T02G5.4
+T02G5.8	T02G5.4
+T05G5.6	T02G5.4
+T05H4.13	T02G5.4
+T08B1.6	T02G5.4
+T08B2.7	T02G5.4
+T08G2.3	T02G5.4
+T25G12.5	T02G5.4
+Y46G5A.17	T02G5.4
+Y49C4A.9	T02G5.4
+Y65B4BL.5	T02G5.4
+Y69F12A.2	T02G5.4
+Y76A2B.3	T02G5.4
+T02G5.8	T02G5.7
+T05G5.6	T02G5.7
+T05H4.13	T02G5.7
+T08B1.6	T02G5.7
+T08B2.7	T02G5.7
+T08G2.3	T02G5.7
+T25G12.5	T02G5.7
+Y46G5A.17	T02G5.7
+Y49C4A.9	T02G5.7
+Y65B4BL.5	T02G5.7
+Y69F12A.2	T02G5.7
+Y76A2B.3	T02G5.7
+T05G5.6	T02G5.8
+T05H4.13	T02G5.8
+T08B1.6	T02G5.8
+T08B2.7	T02G5.8
+T08G2.3	T02G5.8
+T25G12.5	T02G5.8
+Y46G5A.17	T02G5.8
+Y49C4A.9	T02G5.8
+Y65B4BL.5	T02G5.8
+Y69F12A.2	T02G5.8
+Y76A2B.3	T02G5.8
+T05H4.13	T05G5.6
+T08B1.6	T05G5.6
+T08G2.3	T05G5.6
+T25G12.5	T05G5.6
+Y46G5A.17	T05G5.6
+Y49C4A.9	T05G5.6
+Y65B4BL.5	T05G5.6
+Y69F12A.2	T05G5.6
+Y76A2B.3	T05G5.6
+T08B1.6	T05H4.13
+T08B2.7	T05H4.13
+T08G2.3	T05H4.13
+T25G12.5	T05H4.13
+Y46G5A.17	T05H4.13
+Y49C4A.9	T05H4.13
+Y65B4BL.5	T05H4.13
+Y76A2B.3	T05H4.13
+T08B2.7	T08B1.6
+T08G2.3	T08B1.6
+T25G12.5	T08B1.6
+Y46G5A.17	T08B1.6
+Y49C4A.9	T08B1.6
+Y65B4BL.5	T08B1.6
+Y69F12A.2	T08B1.6
+Y76A2B.3	T08B1.6
+T08G2.3	T08B2.7
+T25G12.5	T08B2.7
+Y46G5A.17	T08B2.7
+Y49C4A.9	T08B2.7
+Y65B4BL.5	T08B2.7
+Y69F12A.2	T08B2.7
+Y76A2B.3	T08B2.7
+T25G12.5	T08G2.3
+Y46G5A.17	T08G2.3
+Y49C4A.9	T08G2.3
+Y65B4BL.5	T08G2.3
+Y69F12A.2	T08G2.3
+Y76A2B.3	T08G2.3
+Y46G5A.17	T25G12.5
+Y49C4A.9	T25G12.5
+Y65B4BL.5	T25G12.5
+Y69F12A.2	T25G12.5
+Y76A2B.3	T25G12.5
+Y49C4A.9	Y46G5A.17
+Y65B4BL.5	Y46G5A.17
+Y69F12A.2	Y46G5A.17
+Y76A2B.3	Y46G5A.17
+Y65B4BL.5	Y49C4A.9
+Y69F12A.2	Y49C4A.9
+Y76A2B.3	Y49C4A.9
+Y69F12A.2	Y65B4BL.5
+Y76A2B.3	Y65B4BL.5
+Y76A2B.3	Y69F12A.2
+F25B4.6	C05C10.3
+T02G5.4	C05C10.3
+T02G5.7	C05C10.3
+T02G5.8	C05C10.3
+Y71G12B.10	C05C10.3
+T02G5.4	F25B4.6
+T02G5.7	F25B4.6
+T02G5.8	F25B4.6
+Y71G12B.10	F25B4.6
+Y71G12B.10	T02G5.4
+Y71G12B.10	T02G5.7
+Y71G12B.10	T02G5.8
+F49E12.9	B0395.2
+F52H2.6	B0395.2
+F52H2.6	F49E12.9
+F57B9.4	F42D1.2
+K07B1.2	F42D1.2
+T21C12.2	F42D1.2
+Y57G11C.11	F42D1.2
+ZC395.2	F42D1.2
+ZK1127.2	F42D1.2
+ZK652.9	F42D1.2
+K07B1.2	F57B9.4
+T21C12.2	F57B9.4
+Y57G11C.11	F57B9.4
+ZC395.2	F57B9.4
+ZK1127.2	F57B9.4
+ZK652.9	F57B9.4
+T21C12.2	K07B1.2
+Y57G11C.11	K07B1.2
+ZC395.2	K07B1.2
+ZK1127.2	K07B1.2
+ZK652.9	K07B1.2
+Y57G11C.11	T21C12.2
+ZC395.2	T21C12.2
+ZK1127.2	T21C12.2
+ZK652.9	T21C12.2
+ZC395.2	Y57G11C.11
+ZK1127.2	Y57G11C.11
+ZK652.9	Y57G11C.11
+ZK1127.2	ZC395.2
+ZK652.9	ZC395.2
+ZK652.9	ZK1127.2
+C06H2.1	C03G5.1
+C09H10.3	C03G5.1
+C13C4.4	C03G5.1
+C16A3.5	C03G5.1
+C17H12.14	C03G5.1
+C18E9.4	C03G5.1
+C25A1.13	C03G5.1
+C25H3.9	C03G5.1
+C26H9A.1	C03G5.1
+C30F8.2	C03G5.1
+C33A12.1	C03G5.1
+C34B2.8	C03G5.1
+C34E10.6	C03G5.1
+C47E12.4	C03G5.1
+C53B7.4	C03G5.1
+C54G4.8	C03G5.1
+D2030.4	C03G5.1
+F02E8.1	C03G5.1
+F16B4.6	C03G5.1
+F20B6.2	C03G5.1
+F22D6.4	C03G5.1
+F26E4.6	C03G5.1
+F26E4.9	C03G5.1
+F27C1.7	C03G5.1
+F29C4.2	C03G5.1
+F31D4.9	C03G5.1
+F32D1.2	C03G5.1
+F35G12.10	C03G5.1
+F35H10.4	C03G5.1
+F37C12.3	C03G5.1
+F40G9.2	C03G5.1
+F42G8.10	C03G5.1
+F42G8.12	C03G5.1
+F44G4.2	C03G5.1
+F45H10.2	C03G5.1
+F45H10.3	C03G5.1
+F46F11.5	C03G5.1
+F49C12.13	C03G5.1
+F52E1.10	C03G5.1
+F53F4.10	C03G5.1
+F54D8.2	C03G5.1
+F55H2.2	C03G5.1
+F57B10.14	C03G5.1
+F58F12.1	C03G5.1
+F59C6.5	C03G5.1
+H28O16.1	C03G5.1
+JC8.5	C03G5.1
+K04G7.4	C03G5.1
+K07A12.3	C03G5.1
+K09A9.5	C03G5.1
+R04F11.2	C03G5.1
+R05D3.6	C03G5.1
+R07E4.3	C03G5.1
+R10E11.2	C03G5.1
+R10E11.8	C03G5.1
+R53.4	C03G5.1
+T01H3.1	C03G5.1
+T02H6.11	C03G5.1
+T06D8.5	C03G5.1
+T10B10.2	C03G5.1
+T10E9.7	C03G5.1
+T14F9.1	C03G5.1
+T20H4.5	C03G5.1
+T24C4.1	C03G5.1
+T26A5.3	C03G5.1
+T26E3.7	C03G5.1
+T27E9.2	C03G5.1
+VW02B12L.1	C03G5.1
+VW06B3R.1	C03G5.1
+W01A8.4	C03G5.1
+W09C5.8	C03G5.1
+W10D5.2	C03G5.1
+Y110A7A.12	C03G5.1
+Y37D8A.14	C03G5.1
+Y38F2AL.3	C03G5.1
+Y38F2AL.4	C03G5.1
+Y45G12B.1	C03G5.1
+Y46G5A.2	C03G5.1
+Y49A3A.2	C03G5.1
+Y51H1A.3	C03G5.1
+Y53G8AL.2	C03G5.1
+Y54E10BL.5	C03G5.1
+Y54F10AM.5	C03G5.1
+Y55H10A.1	C03G5.1
+Y56A3A.19	C03G5.1
+Y57G11C.12	C03G5.1
+Y63D3A.7	C03G5.1
+Y69A2AR.18	C03G5.1
+Y71H2AM.4	C03G5.1
+Y71H2AM.5	C03G5.1
+Y94H6A.8	C03G5.1
+ZC262.5	C03G5.1
+ZK637.8	C03G5.1
+ZK809.3	C03G5.1
+ZK970.4	C03G5.1
+ZK973.10	C03G5.1
+C09H10.3	C06H2.1
+C13C4.4	C06H2.1
+C16A3.5	C06H2.1
+C17H12.14	C06H2.1
+C18E9.4	C06H2.1
+C25A1.13	C06H2.1
+C25H3.9	C06H2.1
+C26H9A.1	C06H2.1
+C30F8.2	C06H2.1
+C33A12.1	C06H2.1
+C34B2.7	C06H2.1
+C34B2.8	C06H2.1
+C34E10.6	C06H2.1
+C47E12.4	C06H2.1
+C53B7.4	C06H2.1
+C54G4.8	C06H2.1
+D2030.4	C06H2.1
+F02E8.1	C06H2.1
+F16B4.6	C06H2.1
+F20B6.2	C06H2.1
+F22D6.4	C06H2.1
+F26E4.6	C06H2.1
+F26E4.9	C06H2.1
+F27C1.7	C06H2.1
+F29C4.2	C06H2.1
+F31D4.9	C06H2.1
+F32D1.2	C06H2.1
+F33A8.5	C06H2.1
+F35G12.10	C06H2.1
+F35H10.4	C06H2.1
+F37C12.3	C06H2.1
+F40G9.2	C06H2.1
+F42A8.2	C06H2.1
+F42G8.10	C06H2.1
+F42G8.12	C06H2.1
+F44G4.2	C06H2.1
+F45H10.2	C06H2.1
+F45H10.3	C06H2.1
+F46F11.5	C06H2.1
+F49C12.13	C06H2.1
+F52E1.10	C06H2.1
+F53F4.10	C06H2.1
+F54D8.2	C06H2.1
+F55H2.2	C06H2.1
+F57B10.14	C06H2.1
+F58F12.1	C06H2.1
+F59C6.5	C06H2.1
+H28O16.1	C06H2.1
+JC8.5	C06H2.1
+K04G7.4	C06H2.1
+K07A12.3	C06H2.1
+K09A9.5	C06H2.1
+R04F11.2	C06H2.1
+R05D3.6	C06H2.1
+R07E4.3	C06H2.1
+R10E11.2	C06H2.1
+R10E11.8	C06H2.1
+R53.4	C06H2.1
+T01H3.1	C06H2.1
+T02H6.11	C06H2.1
+T06D8.5	C06H2.1
+T07C4.7	C06H2.1
+T10B10.2	C06H2.1
+T10E9.7	C06H2.1
+T14F9.1	C06H2.1
+T20H4.5	C06H2.1
+T24C4.1	C06H2.1
+T26A5.3	C06H2.1
+T26E3.7	C06H2.1
+T27E9.2	C06H2.1
+VW02B12L.1	C06H2.1
+VW06B3R.1	C06H2.1
+W01A8.4	C06H2.1
+W09C5.8	C06H2.1
+W10D5.2	C06H2.1
+Y110A7A.12	C06H2.1
+Y37D8A.14	C06H2.1
+Y38F2AL.3	C06H2.1
+Y38F2AL.4	C06H2.1
+Y45G12B.1	C06H2.1
+Y46G5A.2	C06H2.1
+Y49A3A.2	C06H2.1
+Y51H1A.3	C06H2.1
+Y53G8AL.2	C06H2.1
+Y54E10BL.5	C06H2.1
+Y54F10AM.5	C06H2.1
+Y55H10A.1	C06H2.1
+Y56A3A.19	C06H2.1
+Y57G11C.12	C06H2.1
+Y63D3A.7	C06H2.1
+Y69A2AR.18	C06H2.1
+Y71H2AM.4	C06H2.1
+Y71H2AM.5	C06H2.1
+Y94H6A.8	C06H2.1
+ZC262.5	C06H2.1
+ZK637.8	C06H2.1
+ZK809.3	C06H2.1
+ZK970.4	C06H2.1
+ZK973.10	C06H2.1
+C13C4.4	C09H10.3
+C16A3.5	C09H10.3
+C17H12.14	C09H10.3
+C18E9.4	C09H10.3
+C25A1.13	C09H10.3
+C25H3.9	C09H10.3
+C26H9A.1	C09H10.3
+C30F8.2	C09H10.3
+C33A12.1	C09H10.3
+C34B2.7	C09H10.3
+C34B2.8	C09H10.3
+C34E10.6	C09H10.3
+C47E12.4	C09H10.3
+C53B7.4	C09H10.3
+C54G4.8	C09H10.3
+D2030.4	C09H10.3
+F02E8.1	C09H10.3
+F16B4.6	C09H10.3
+F20B6.2	C09H10.3
+F22D6.4	C09H10.3
+F26E4.6	C09H10.3
+F26E4.9	C09H10.3
+F27C1.7	C09H10.3
+F29C4.2	C09H10.3
+F31D4.9	C09H10.3
+F32D1.2	C09H10.3
+F33A8.5	C09H10.3
+F35G12.10	C09H10.3
+F35H10.4	C09H10.3
+F37C12.3	C09H10.3
+F40G9.2	C09H10.3
+F42A8.2	C09H10.3
+F42G8.10	C09H10.3
+F42G8.12	C09H10.3
+F44G4.2	C09H10.3
+F45H10.2	C09H10.3
+F45H10.3	C09H10.3
+F46F11.5	C09H10.3
+F49C12.13	C09H10.3
+F52E1.10	C09H10.3
+F53F4.10	C09H10.3
+F54D8.2	C09H10.3
+F55H2.2	C09H10.3
+F57B10.14	C09H10.3
+F58F12.1	C09H10.3
+F59C6.5	C09H10.3
+H28O16.1	C09H10.3
+JC8.5	C09H10.3
+K04G7.4	C09H10.3
+K07A12.3	C09H10.3
+K09A9.5	C09H10.3
+R04F11.2	C09H10.3
+R05D3.6	C09H10.3
+R07E4.3	C09H10.3
+R10E11.2	C09H10.3
+R10E11.8	C09H10.3
+R53.4	C09H10.3
+T01H3.1	C09H10.3
+T02H6.11	C09H10.3
+T06D8.5	C09H10.3
+T07C4.7	C09H10.3
+T10B10.2	C09H10.3
+T10E9.7	C09H10.3
+T14F9.1	C09H10.3
+T20H4.5	C09H10.3
+T24C4.1	C09H10.3
+T26A5.3	C09H10.3
+T26E3.7	C09H10.3
+T27E9.2	C09H10.3
+VW02B12L.1	C09H10.3
+VW06B3R.1	C09H10.3
+W01A8.4	C09H10.3
+W09C5.8	C09H10.3
+W10D5.2	C09H10.3
+Y110A7A.12	C09H10.3
+Y37D8A.14	C09H10.3
+Y38F2AL.3	C09H10.3
+Y38F2AL.4	C09H10.3
+Y45G12B.1	C09H10.3
+Y46G5A.2	C09H10.3
+Y49A3A.2	C09H10.3
+Y51H1A.3	C09H10.3
+Y53G8AL.2	C09H10.3
+Y54E10BL.5	C09H10.3
+Y54F10AM.5	C09H10.3
+Y55H10A.1	C09H10.3
+Y56A3A.19	C09H10.3
+Y57G11C.12	C09H10.3
+Y63D3A.7	C09H10.3
+Y69A2AR.18	C09H10.3
+Y71H2AM.4	C09H10.3
+Y71H2AM.5	C09H10.3
+Y94H6A.8	C09H10.3
+ZC262.5	C09H10.3
+ZK637.8	C09H10.3
+ZK809.3	C09H10.3
+ZK970.4	C09H10.3
+ZK973.10	C09H10.3
+C16A3.5	C13C4.4
+C17H12.14	C13C4.4
+C18E9.4	C13C4.4
+C25A1.13	C13C4.4
+C25H3.9	C13C4.4
+C26H9A.1	C13C4.4
+C30F8.2	C13C4.4
+C33A12.1	C13C4.4
+C34B2.7	C13C4.4
+C34B2.8	C13C4.4
+C34E10.6	C13C4.4
+C47E12.4	C13C4.4
+C53B7.4	C13C4.4
+C54G4.8	C13C4.4
+D2030.4	C13C4.4
+F02E8.1	C13C4.4
+F16B4.6	C13C4.4
+F20B6.2	C13C4.4
+F22D6.4	C13C4.4
+F26E4.6	C13C4.4
+F26E4.9	C13C4.4
+F27C1.7	C13C4.4
+F29C4.2	C13C4.4
+F31D4.9	C13C4.4
+F32D1.2	C13C4.4
+F33A8.5	C13C4.4
+F35G12.10	C13C4.4
+F35H10.4	C13C4.4
+F37C12.3	C13C4.4
+F40G9.2	C13C4.4
+F42A8.2	C13C4.4
+F42G8.10	C13C4.4
+F42G8.12	C13C4.4
+F44G4.2	C13C4.4
+F45H10.2	C13C4.4
+F45H10.3	C13C4.4
+F46F11.5	C13C4.4
+F49C12.13	C13C4.4
+F52E1.10	C13C4.4
+F53F4.10	C13C4.4
+F54D8.2	C13C4.4
+F55H2.2	C13C4.4
+F57B10.14	C13C4.4
+F58F12.1	C13C4.4
+F59C6.5	C13C4.4
+H28O16.1	C13C4.4
+JC8.5	C13C4.4
+K04G7.4	C13C4.4
+K07A12.3	C13C4.4
+K09A9.5	C13C4.4
+R04F11.2	C13C4.4
+R05D3.6	C13C4.4
+R07E4.3	C13C4.4
+R10E11.2	C13C4.4
+R10E11.8	C13C4.4
+R53.4	C13C4.4
+T01H3.1	C13C4.4
+T02H6.11	C13C4.4
+T06D8.5	C13C4.4
+T07C4.7	C13C4.4
+T10B10.2	C13C4.4
+T10E9.7	C13C4.4
+T14F9.1	C13C4.4
+T20H4.5	C13C4.4
+T24C4.1	C13C4.4
+T26A5.3	C13C4.4
+T26E3.7	C13C4.4
+T27E9.2	C13C4.4
+VW02B12L.1	C13C4.4
+VW06B3R.1	C13C4.4
+W01A8.4	C13C4.4
+W09C5.8	C13C4.4
+W10D5.2	C13C4.4
+Y110A7A.12	C13C4.4
+Y37D8A.14	C13C4.4
+Y38F2AL.3	C13C4.4
+Y38F2AL.4	C13C4.4
+Y45G12B.1	C13C4.4
+Y46G5A.2	C13C4.4
+Y49A3A.2	C13C4.4
+Y51H1A.3	C13C4.4
+Y53G8AL.2	C13C4.4
+Y54E10BL.5	C13C4.4
+Y54F10AM.5	C13C4.4
+Y55H10A.1	C13C4.4
+Y56A3A.19	C13C4.4
+Y57G11C.12	C13C4.4
+Y63D3A.7	C13C4.4
+Y69A2AR.18	C13C4.4
+Y71H2AM.4	C13C4.4
+Y71H2AM.5	C13C4.4
+Y94H6A.8	C13C4.4
+ZC262.5	C13C4.4
+ZK637.8	C13C4.4
+ZK809.3	C13C4.4
+ZK970.4	C13C4.4
+ZK973.10	C13C4.4
+C17H12.14	C16A3.5
+C18E9.4	C16A3.5
+C25A1.13	C16A3.5
+C25H3.9	C16A3.5
+C26H9A.1	C16A3.5
+C30F8.2	C16A3.5
+C33A12.1	C16A3.5
+C34B2.7	C16A3.5
+C34B2.8	C16A3.5
+C34E10.6	C16A3.5
+C47E12.4	C16A3.5
+C53B7.4	C16A3.5
+C54G4.8	C16A3.5
+D2030.4	C16A3.5
+F02E8.1	C16A3.5
+F16B4.6	C16A3.5
+F20B6.2	C16A3.5
+F22D6.4	C16A3.5
+F26E4.6	C16A3.5
+F26E4.9	C16A3.5
+F27C1.7	C16A3.5
+F29C4.2	C16A3.5
+F31D4.9	C16A3.5
+F32D1.2	C16A3.5
+F33A8.5	C16A3.5
+F35G12.10	C16A3.5
+F35H10.4	C16A3.5
+F37C12.3	C16A3.5
+F40G9.2	C16A3.5
+F42A8.2	C16A3.5
+F42G8.10	C16A3.5
+F42G8.12	C16A3.5
+F44G4.2	C16A3.5
+F45H10.2	C16A3.5
+F45H10.3	C16A3.5
+F46F11.5	C16A3.5
+F49C12.13	C16A3.5
+F52E1.10	C16A3.5
+F53F4.10	C16A3.5
+F54D8.2	C16A3.5
+F55H2.2	C16A3.5
+F57B10.14	C16A3.5
+F58F12.1	C16A3.5
+F59C6.5	C16A3.5
+H28O16.1	C16A3.5
+JC8.5	C16A3.5
+K04G7.4	C16A3.5
+K07A12.3	C16A3.5
+K09A9.5	C16A3.5
+R04F11.2	C16A3.5
+R05D3.6	C16A3.5
+R07E4.3	C16A3.5
+R10E11.2	C16A3.5
+R10E11.8	C16A3.5
+R53.4	C16A3.5
+T01H3.1	C16A3.5
+T02H6.11	C16A3.5
+T06D8.5	C16A3.5
+T07C4.7	C16A3.5
+T10B10.2	C16A3.5
+T10E9.7	C16A3.5
+T14F9.1	C16A3.5
+T20H4.5	C16A3.5
+T24C4.1	C16A3.5
+T26A5.3	C16A3.5
+T26E3.7	C16A3.5
+T27E9.2	C16A3.5
+VW02B12L.1	C16A3.5
+VW06B3R.1	C16A3.5
+W01A8.4	C16A3.5
+W09C5.8	C16A3.5
+W10D5.2	C16A3.5
+Y110A7A.12	C16A3.5
+Y37D8A.14	C16A3.5
+Y38F2AL.3	C16A3.5
+Y38F2AL.4	C16A3.5
+Y45G12B.1	C16A3.5
+Y46G5A.2	C16A3.5
+Y49A3A.2	C16A3.5
+Y51H1A.3	C16A3.5
+Y53G8AL.2	C16A3.5
+Y54E10BL.5	C16A3.5
+Y54F10AM.5	C16A3.5
+Y55H10A.1	C16A3.5
+Y56A3A.19	C16A3.5
+Y57G11C.12	C16A3.5
+Y63D3A.7	C16A3.5
+Y69A2AR.18	C16A3.5
+Y71H2AM.4	C16A3.5
+Y71H2AM.5	C16A3.5
+Y94H6A.8	C16A3.5
+ZC262.5	C16A3.5
+ZK637.8	C16A3.5
+ZK809.3	C16A3.5
+ZK970.4	C16A3.5
+ZK973.10	C16A3.5
+C18E9.4	C17H12.14
+C25A1.13	C17H12.14
+C25H3.9	C17H12.14
+C26H9A.1	C17H12.14
+C30F8.2	C17H12.14
+C33A12.1	C17H12.14
+C34B2.7	C17H12.14
+C34B2.8	C17H12.14
+C34E10.6	C17H12.14
+C47E12.4	C17H12.14
+C53B7.4	C17H12.14
+C54G4.8	C17H12.14
+D2030.4	C17H12.14
+F02E8.1	C17H12.14
+F16B4.6	C17H12.14
+F20B6.2	C17H12.14
+F22D6.4	C17H12.14
+F26E4.6	C17H12.14
+F26E4.9	C17H12.14
+F27C1.7	C17H12.14
+F29C4.2	C17H12.14
+F31D4.9	C17H12.14
+F32D1.2	C17H12.14
+F33A8.5	C17H12.14
+F35G12.10	C17H12.14
+F35H10.4	C17H12.14
+F37C12.3	C17H12.14
+F40G9.2	C17H12.14
+F42A8.2	C17H12.14
+F42G8.10	C17H12.14
+F42G8.12	C17H12.14
+F44G4.2	C17H12.14
+F45H10.2	C17H12.14
+F45H10.3	C17H12.14
+F46F11.5	C17H12.14
+F49C12.13	C17H12.14
+F52E1.10	C17H12.14
+F53F4.10	C17H12.14
+F54D8.2	C17H12.14
+F55H2.2	C17H12.14
+F57B10.14	C17H12.14
+F58F12.1	C17H12.14
+F59C6.5	C17H12.14
+H28O16.1	C17H12.14
+JC8.5	C17H12.14
+K04G7.4	C17H12.14
+K07A12.3	C17H12.14
+K09A9.5	C17H12.14
+R04F11.2	C17H12.14
+R05D3.6	C17H12.14
+R07E4.3	C17H12.14
+R10E11.2	C17H12.14
+R10E11.8	C17H12.14
+R53.4	C17H12.14
+T01H3.1	C17H12.14
+T02H6.11	C17H12.14
+T06D8.5	C17H12.14
+T07C4.7	C17H12.14
+T10B10.2	C17H12.14
+T10E9.7	C17H12.14
+T14F9.1	C17H12.14
+T20H4.5	C17H12.14
+T24C4.1	C17H12.14
+T26A5.3	C17H12.14
+T26E3.7	C17H12.14
+T27E9.2	C17H12.14
+VW02B12L.1	C17H12.14
+VW06B3R.1	C17H12.14
+W01A8.4	C17H12.14
+W09C5.8	C17H12.14
+W10D5.2	C17H12.14
+Y110A7A.12	C17H12.14
+Y37D8A.14	C17H12.14
+Y38F2AL.3	C17H12.14
+Y38F2AL.4	C17H12.14
+Y45G12B.1	C17H12.14
+Y46G5A.2	C17H12.14
+Y49A3A.2	C17H12.14
+Y51H1A.3	C17H12.14
+Y53G8AL.2	C17H12.14
+Y54E10BL.5	C17H12.14
+Y54F10AM.5	C17H12.14
+Y55H10A.1	C17H12.14
+Y56A3A.19	C17H12.14
+Y57G11C.12	C17H12.14
+Y63D3A.7	C17H12.14
+Y69A2AR.18	C17H12.14
+Y71H2AM.4	C17H12.14
+Y71H2AM.5	C17H12.14
+Y94H6A.8	C17H12.14
+ZC262.5	C17H12.14
+ZK637.8	C17H12.14
+ZK809.3	C17H12.14
+ZK970.4	C17H12.14
+ZK973.10	C17H12.14
+C25A1.13	C18E9.4
+C25H3.9	C18E9.4
+C26H9A.1	C18E9.4
+C30F8.2	C18E9.4
+C33A12.1	C18E9.4
+C34B2.7	C18E9.4
+C34B2.8	C18E9.4
+C34E10.6	C18E9.4
+C47E12.4	C18E9.4
+C53B7.4	C18E9.4
+C54G4.8	C18E9.4
+D2030.4	C18E9.4
+F02E8.1	C18E9.4
+F16B4.6	C18E9.4
+F20B6.2	C18E9.4
+F22D6.4	C18E9.4
+F26E4.6	C18E9.4
+F26E4.9	C18E9.4
+F27C1.7	C18E9.4
+F29C4.2	C18E9.4
+F31D4.9	C18E9.4
+F32D1.2	C18E9.4
+F33A8.5	C18E9.4
+F35G12.10	C18E9.4
+F35H10.4	C18E9.4
+F37C12.3	C18E9.4
+F40G9.2	C18E9.4
+F42A8.2	C18E9.4
+F42G8.10	C18E9.4
+F42G8.12	C18E9.4
+F44G4.2	C18E9.4
+F45H10.2	C18E9.4
+F45H10.3	C18E9.4
+F46F11.5	C18E9.4
+F49C12.13	C18E9.4
+F52E1.10	C18E9.4
+F53F4.10	C18E9.4
+F54D8.2	C18E9.4
+F55H2.2	C18E9.4
+F57B10.14	C18E9.4
+F58F12.1	C18E9.4
+F59C6.5	C18E9.4
+H28O16.1	C18E9.4
+JC8.5	C18E9.4
+K04G7.4	C18E9.4
+K07A12.3	C18E9.4
+K09A9.5	C18E9.4
+R04F11.2	C18E9.4
+R05D3.6	C18E9.4
+R07E4.3	C18E9.4
+R10E11.2	C18E9.4
+R10E11.8	C18E9.4
+R53.4	C18E9.4
+T01H3.1	C18E9.4
+T02H6.11	C18E9.4
+T06D8.5	C18E9.4
+T07C4.7	C18E9.4
+T10B10.2	C18E9.4
+T10E9.7	C18E9.4
+T14F9.1	C18E9.4
+T20H4.5	C18E9.4
+T24C4.1	C18E9.4
+T26A5.3	C18E9.4
+T26E3.7	C18E9.4
+T27E9.2	C18E9.4
+VW02B12L.1	C18E9.4
+VW06B3R.1	C18E9.4
+W01A8.4	C18E9.4
+W09C5.8	C18E9.4
+W10D5.2	C18E9.4
+Y110A7A.12	C18E9.4
+Y37D8A.14	C18E9.4
+Y38F2AL.3	C18E9.4
+Y38F2AL.4	C18E9.4
+Y45G12B.1	C18E9.4
+Y46G5A.2	C18E9.4
+Y49A3A.2	C18E9.4
+Y51H1A.3	C18E9.4
+Y53G8AL.2	C18E9.4
+Y54E10BL.5	C18E9.4
+Y54F10AM.5	C18E9.4
+Y55H10A.1	C18E9.4
+Y56A3A.19	C18E9.4
+Y57G11C.12	C18E9.4
+Y63D3A.7	C18E9.4
+Y69A2AR.18	C18E9.4
+Y71H2AM.4	C18E9.4
+Y71H2AM.5	C18E9.4
+Y94H6A.8	C18E9.4
+ZC262.5	C18E9.4
+ZK637.8	C18E9.4
+ZK809.3	C18E9.4
+ZK970.4	C18E9.4
+ZK973.10	C18E9.4
+C25H3.9	C25A1.13
+C26H9A.1	C25A1.13
+C30F8.2	C25A1.13
+C33A12.1	C25A1.13
+C34B2.7	C25A1.13
+C34B2.8	C25A1.13
+C34E10.6	C25A1.13
+C47E12.4	C25A1.13
+C53B7.4	C25A1.13
+C54G4.8	C25A1.13
+D2030.4	C25A1.13
+F02E8.1	C25A1.13
+F16B4.6	C25A1.13
+F20B6.2	C25A1.13
+F22D6.4	C25A1.13
+F26E4.6	C25A1.13
+F26E4.9	C25A1.13
+F27C1.7	C25A1.13
+F29C4.2	C25A1.13
+F31D4.9	C25A1.13
+F32D1.2	C25A1.13
+F33A8.5	C25A1.13
+F35G12.10	C25A1.13
+F35H10.4	C25A1.13
+F37C12.3	C25A1.13
+F40G9.2	C25A1.13
+F42A8.2	C25A1.13
+F42G8.10	C25A1.13
+F42G8.12	C25A1.13
+F44G4.2	C25A1.13
+F45H10.2	C25A1.13
+F45H10.3	C25A1.13
+F46F11.5	C25A1.13
+F49C12.13	C25A1.13
+F52E1.10	C25A1.13
+F53F4.10	C25A1.13
+F54D8.2	C25A1.13
+F55H2.2	C25A1.13
+F57B10.14	C25A1.13
+F58F12.1	C25A1.13
+F59C6.5	C25A1.13
+H28O16.1	C25A1.13
+JC8.5	C25A1.13
+K04G7.4	C25A1.13
+K07A12.3	C25A1.13
+K09A9.5	C25A1.13
+R04F11.2	C25A1.13
+R05D3.6	C25A1.13
+R07E4.3	C25A1.13
+R10E11.2	C25A1.13
+R10E11.8	C25A1.13
+R53.4	C25A1.13
+T01H3.1	C25A1.13
+T02H6.11	C25A1.13
+T06D8.5	C25A1.13
+T07C4.7	C25A1.13
+T10B10.2	C25A1.13
+T10E9.7	C25A1.13
+T14F9.1	C25A1.13
+T20H4.5	C25A1.13
+T24C4.1	C25A1.13
+T26A5.3	C25A1.13
+T26E3.7	C25A1.13
+T27E9.2	C25A1.13
+VW02B12L.1	C25A1.13
+VW06B3R.1	C25A1.13
+W01A8.4	C25A1.13
+W09C5.8	C25A1.13
+W10D5.2	C25A1.13
+Y110A7A.12	C25A1.13
+Y37D8A.14	C25A1.13
+Y38F2AL.3	C25A1.13
+Y38F2AL.4	C25A1.13
+Y45G12B.1	C25A1.13
+Y46G5A.2	C25A1.13
+Y49A3A.2	C25A1.13
+Y51H1A.3	C25A1.13
+Y53G8AL.2	C25A1.13
+Y54E10BL.5	C25A1.13
+Y54F10AM.5	C25A1.13
+Y55H10A.1	C25A1.13
+Y56A3A.19	C25A1.13
+Y57G11C.12	C25A1.13
+Y63D3A.7	C25A1.13
+Y69A2AR.18	C25A1.13
+Y71H2AM.4	C25A1.13
+Y71H2AM.5	C25A1.13
+Y94H6A.8	C25A1.13
+ZC262.5	C25A1.13
+ZK637.8	C25A1.13
+ZK809.3	C25A1.13
+ZK970.4	C25A1.13
+ZK973.10	C25A1.13
+C26H9A.1	C25H3.9
+C30F8.2	C25H3.9
+C33A12.1	C25H3.9
+C34B2.7	C25H3.9
+C34B2.8	C25H3.9
+C34E10.6	C25H3.9
+C47E12.4	C25H3.9
+C53B7.4	C25H3.9
+C54G4.8	C25H3.9
+D2030.4	C25H3.9
+F02E8.1	C25H3.9
+F16B4.6	C25H3.9
+F20B6.2	C25H3.9
+F22D6.4	C25H3.9
+F26E4.6	C25H3.9
+F26E4.9	C25H3.9
+F27C1.7	C25H3.9
+F29C4.2	C25H3.9
+F31D4.9	C25H3.9
+F32D1.2	C25H3.9
+F33A8.5	C25H3.9
+F35G12.10	C25H3.9
+F35H10.4	C25H3.9
+F37C12.3	C25H3.9
+F40G9.2	C25H3.9
+F42A8.2	C25H3.9
+F42G8.10	C25H3.9
+F42G8.12	C25H3.9
+F44G4.2	C25H3.9
+F45H10.2	C25H3.9
+F45H10.3	C25H3.9
+F46F11.5	C25H3.9
+F49C12.13	C25H3.9
+F52E1.10	C25H3.9
+F53F4.10	C25H3.9
+F54D8.2	C25H3.9
+F55H2.2	C25H3.9
+F57B10.14	C25H3.9
+F58F12.1	C25H3.9
+F59C6.5	C25H3.9
+H28O16.1	C25H3.9
+JC8.5	C25H3.9
+K04G7.4	C25H3.9
+K07A12.3	C25H3.9
+K09A9.5	C25H3.9
+R04F11.2	C25H3.9
+R05D3.6	C25H3.9
+R07E4.3	C25H3.9
+R10E11.2	C25H3.9
+R10E11.8	C25H3.9
+R53.4	C25H3.9
+T01H3.1	C25H3.9
+T02H6.11	C25H3.9
+T06D8.5	C25H3.9
+T07C4.7	C25H3.9
+T10B10.2	C25H3.9
+T10E9.7	C25H3.9
+T14F9.1	C25H3.9
+T20H4.5	C25H3.9
+T24C4.1	C25H3.9
+T26A5.3	C25H3.9
+T26E3.7	C25H3.9
+T27E9.2	C25H3.9
+VW02B12L.1	C25H3.9
+VW06B3R.1	C25H3.9
+W01A8.4	C25H3.9
+W09C5.8	C25H3.9
+W10D5.2	C25H3.9
+Y110A7A.12	C25H3.9
+Y37D8A.14	C25H3.9
+Y38F2AL.3	C25H3.9
+Y38F2AL.4	C25H3.9
+Y45G12B.1	C25H3.9
+Y46G5A.2	C25H3.9
+Y49A3A.2	C25H3.9
+Y51H1A.3	C25H3.9
+Y53G8AL.2	C25H3.9
+Y54E10BL.5	C25H3.9
+Y54F10AM.5	C25H3.9
+Y55H10A.1	C25H3.9
+Y56A3A.19	C25H3.9
+Y57G11C.12	C25H3.9
+Y63D3A.7	C25H3.9
+Y69A2AR.18	C25H3.9
+Y71H2AM.4	C25H3.9
+Y71H2AM.5	C25H3.9
+Y94H6A.8	C25H3.9
+ZC262.5	C25H3.9
+ZK637.8	C25H3.9
+ZK809.3	C25H3.9
+ZK970.4	C25H3.9
+ZK973.10	C25H3.9
+C30F8.2	C26H9A.1
+C33A12.1	C26H9A.1
+C34B2.7	C26H9A.1
+C34B2.8	C26H9A.1
+C34E10.6	C26H9A.1
+C47E12.4	C26H9A.1
+C53B7.4	C26H9A.1
+C54G4.8	C26H9A.1
+D2030.4	C26H9A.1
+F02E8.1	C26H9A.1
+F16B4.6	C26H9A.1
+F20B6.2	C26H9A.1
+F22D6.4	C26H9A.1
+F26E4.6	C26H9A.1
+F26E4.9	C26H9A.1
+F27C1.7	C26H9A.1
+F29C4.2	C26H9A.1
+F31D4.9	C26H9A.1
+F32D1.2	C26H9A.1
+F33A8.5	C26H9A.1
+F35G12.10	C26H9A.1
+F35H10.4	C26H9A.1
+F37C12.3	C26H9A.1
+F40G9.2	C26H9A.1
+F42A8.2	C26H9A.1
+F42G8.10	C26H9A.1
+F42G8.12	C26H9A.1
+F44G4.2	C26H9A.1
+F45H10.2	C26H9A.1
+F45H10.3	C26H9A.1
+F46F11.5	C26H9A.1
+F49C12.13	C26H9A.1
+F52E1.10	C26H9A.1
+F53F4.10	C26H9A.1
+F54D8.2	C26H9A.1
+F55H2.2	C26H9A.1
+F57B10.14	C26H9A.1
+F58F12.1	C26H9A.1
+F59C6.5	C26H9A.1
+H28O16.1	C26H9A.1
+JC8.5	C26H9A.1
+K04G7.4	C26H9A.1
+K07A12.3	C26H9A.1
+K09A9.5	C26H9A.1
+R04F11.2	C26H9A.1
+R05D3.6	C26H9A.1
+R07E4.3	C26H9A.1
+R10E11.2	C26H9A.1
+R10E11.8	C26H9A.1
+R53.4	C26H9A.1
+T01H3.1	C26H9A.1
+T02H6.11	C26H9A.1
+T06D8.5	C26H9A.1
+T07C4.7	C26H9A.1
+T10B10.2	C26H9A.1
+T10E9.7	C26H9A.1
+T14F9.1	C26H9A.1
+T20H4.5	C26H9A.1
+T24C4.1	C26H9A.1
+T26A5.3	C26H9A.1
+T26E3.7	C26H9A.1
+T27E9.2	C26H9A.1
+VW02B12L.1	C26H9A.1
+VW06B3R.1	C26H9A.1
+W01A8.4	C26H9A.1
+W09C5.8	C26H9A.1
+W10D5.2	C26H9A.1
+Y110A7A.12	C26H9A.1
+Y37D8A.14	C26H9A.1
+Y38F2AL.3	C26H9A.1
+Y38F2AL.4	C26H9A.1
+Y45G12B.1	C26H9A.1
+Y46G5A.2	C26H9A.1
+Y49A3A.2	C26H9A.1
+Y51H1A.3	C26H9A.1
+Y53G8AL.2	C26H9A.1
+Y54E10BL.5	C26H9A.1
+Y54F10AM.5	C26H9A.1
+Y55H10A.1	C26H9A.1
+Y56A3A.19	C26H9A.1
+Y57G11C.12	C26H9A.1
+Y63D3A.7	C26H9A.1
+Y69A2AR.18	C26H9A.1
+Y71H2AM.4	C26H9A.1
+Y71H2AM.5	C26H9A.1
+Y94H6A.8	C26H9A.1
+ZC262.5	C26H9A.1
+ZK637.8	C26H9A.1
+ZK809.3	C26H9A.1
+ZK970.4	C26H9A.1
+ZK973.10	C26H9A.1
+C33A12.1	C30F8.2
+C34B2.7	C30F8.2
+C34B2.8	C30F8.2
+C34E10.6	C30F8.2
+C47E12.4	C30F8.2
+C53B7.4	C30F8.2
+C54G4.8	C30F8.2
+D2030.4	C30F8.2
+F02E8.1	C30F8.2
+F16B4.6	C30F8.2
+F20B6.2	C30F8.2
+F22D6.4	C30F8.2
+F26E4.6	C30F8.2
+F26E4.9	C30F8.2
+F27C1.7	C30F8.2
+F29C4.2	C30F8.2
+F31D4.9	C30F8.2
+F32D1.2	C30F8.2
+F33A8.5	C30F8.2
+F35G12.10	C30F8.2
+F35H10.4	C30F8.2
+F37C12.3	C30F8.2
+F40G9.2	C30F8.2
+F42A8.2	C30F8.2
+F42G8.10	C30F8.2
+F42G8.12	C30F8.2
+F44G4.2	C30F8.2
+F45H10.2	C30F8.2
+F45H10.3	C30F8.2
+F46F11.5	C30F8.2
+F49C12.13	C30F8.2
+F52E1.10	C30F8.2
+F53F4.10	C30F8.2
+F54D8.2	C30F8.2
+F55H2.2	C30F8.2
+F57B10.14	C30F8.2
+F58F12.1	C30F8.2
+F59C6.5	C30F8.2
+H28O16.1	C30F8.2
+JC8.5	C30F8.2
+K04G7.4	C30F8.2
+K07A12.3	C30F8.2
+K09A9.5	C30F8.2
+R04F11.2	C30F8.2
+R05D3.6	C30F8.2
+R07E4.3	C30F8.2
+R10E11.2	C30F8.2
+R10E11.8	C30F8.2
+R53.4	C30F8.2
+T01H3.1	C30F8.2
+T02H6.11	C30F8.2
+T06D8.5	C30F8.2
+T07C4.7	C30F8.2
+T10B10.2	C30F8.2
+T10E9.7	C30F8.2
+T14F9.1	C30F8.2
+T20H4.5	C30F8.2
+T24C4.1	C30F8.2
+T26A5.3	C30F8.2
+T26E3.7	C30F8.2
+T27E9.2	C30F8.2
+VW02B12L.1	C30F8.2
+VW06B3R.1	C30F8.2
+W01A8.4	C30F8.2
+W09C5.8	C30F8.2
+W10D5.2	C30F8.2
+Y110A7A.12	C30F8.2
+Y37D8A.14	C30F8.2
+Y38F2AL.3	C30F8.2
+Y38F2AL.4	C30F8.2
+Y45G12B.1	C30F8.2
+Y46G5A.2	C30F8.2
+Y49A3A.2	C30F8.2
+Y51H1A.3	C30F8.2
+Y53G8AL.2	C30F8.2
+Y54E10BL.5	C30F8.2
+Y54F10AM.5	C30F8.2
+Y55H10A.1	C30F8.2
+Y56A3A.19	C30F8.2
+Y57G11C.12	C30F8.2
+Y63D3A.7	C30F8.2
+Y69A2AR.18	C30F8.2
+Y71H2AM.4	C30F8.2
+Y71H2AM.5	C30F8.2
+Y94H6A.8	C30F8.2
+ZC262.5	C30F8.2
+ZK637.8	C30F8.2
+ZK809.3	C30F8.2
+ZK970.4	C30F8.2
+ZK973.10	C30F8.2
+C34B2.7	C33A12.1
+C34B2.8	C33A12.1
+C34E10.6	C33A12.1
+C47E12.4	C33A12.1
+C53B7.4	C33A12.1
+C54G4.8	C33A12.1
+D2030.4	C33A12.1
+F02E8.1	C33A12.1
+F16B4.6	C33A12.1
+F20B6.2	C33A12.1
+F22D6.4	C33A12.1
+F26E4.6	C33A12.1
+F26E4.9	C33A12.1
+F27C1.7	C33A12.1
+F29C4.2	C33A12.1
+F31D4.9	C33A12.1
+F32D1.2	C33A12.1
+F33A8.5	C33A12.1
+F35G12.10	C33A12.1
+F35H10.4	C33A12.1
+F37C12.3	C33A12.1
+F40G9.2	C33A12.1
+F42A8.2	C33A12.1
+F42G8.10	C33A12.1
+F42G8.12	C33A12.1
+F44G4.2	C33A12.1
+F45H10.2	C33A12.1
+F45H10.3	C33A12.1
+F46F11.5	C33A12.1
+F49C12.13	C33A12.1
+F52E1.10	C33A12.1
+F53F4.10	C33A12.1
+F54D8.2	C33A12.1
+F55H2.2	C33A12.1
+F57B10.14	C33A12.1
+F58F12.1	C33A12.1
+F59C6.5	C33A12.1
+H28O16.1	C33A12.1
+JC8.5	C33A12.1
+K04G7.4	C33A12.1
+K07A12.3	C33A12.1
+K09A9.5	C33A12.1
+R04F11.2	C33A12.1
+R05D3.6	C33A12.1
+R07E4.3	C33A12.1
+R10E11.2	C33A12.1
+R10E11.8	C33A12.1
+R53.4	C33A12.1
+T01H3.1	C33A12.1
+T02H6.11	C33A12.1
+T06D8.5	C33A12.1
+T07C4.7	C33A12.1
+T10B10.2	C33A12.1
+T10E9.7	C33A12.1
+T14F9.1	C33A12.1
+T20H4.5	C33A12.1
+T24C4.1	C33A12.1
+T26A5.3	C33A12.1
+T26E3.7	C33A12.1
+T27E9.2	C33A12.1
+VW02B12L.1	C33A12.1
+VW06B3R.1	C33A12.1
+W01A8.4	C33A12.1
+W09C5.8	C33A12.1
+W10D5.2	C33A12.1
+Y110A7A.12	C33A12.1
+Y37D8A.14	C33A12.1
+Y38F2AL.3	C33A12.1
+Y38F2AL.4	C33A12.1
+Y45G12B.1	C33A12.1
+Y46G5A.2	C33A12.1
+Y49A3A.2	C33A12.1
+Y51H1A.3	C33A12.1
+Y53G8AL.2	C33A12.1
+Y54E10BL.5	C33A12.1
+Y54F10AM.5	C33A12.1
+Y55H10A.1	C33A12.1
+Y56A3A.19	C33A12.1
+Y57G11C.12	C33A12.1
+Y63D3A.7	C33A12.1
+Y69A2AR.18	C33A12.1
+Y71H2AM.4	C33A12.1
+Y71H2AM.5	C33A12.1
+Y94H6A.8	C33A12.1
+ZC262.5	C33A12.1
+ZK637.8	C33A12.1
+ZK809.3	C33A12.1
+ZK970.4	C33A12.1
+ZK973.10	C33A12.1
+C34B2.8	C34B2.7
+C34E10.6	C34B2.7
+C47E12.4	C34B2.7
+C53B7.4	C34B2.7
+C54G4.8	C34B2.7
+D2030.4	C34B2.7
+F02E8.1	C34B2.7
+F16B4.6	C34B2.7
+F20B6.2	C34B2.7
+F22D6.4	C34B2.7
+F26E4.6	C34B2.7
+F26E4.9	C34B2.7
+F27C1.7	C34B2.7
+F29C4.2	C34B2.7
+F31D4.9	C34B2.7
+F32D1.2	C34B2.7
+F35G12.10	C34B2.7
+F35H10.4	C34B2.7
+F37C12.3	C34B2.7
+F40G9.2	C34B2.7
+F42G8.10	C34B2.7
+F42G8.12	C34B2.7
+F44G4.2	C34B2.7
+F45H10.2	C34B2.7
+F45H10.3	C34B2.7
+F46F11.5	C34B2.7
+F49C12.13	C34B2.7
+F52E1.10	C34B2.7
+F53F4.10	C34B2.7
+F54D8.2	C34B2.7
+F55H2.2	C34B2.7
+F57B10.14	C34B2.7
+F58F12.1	C34B2.7
+F59C6.5	C34B2.7
+H28O16.1	C34B2.7
+JC8.5	C34B2.7
+K04G7.4	C34B2.7
+K07A12.3	C34B2.7
+K09A9.5	C34B2.7
+R04F11.2	C34B2.7
+R05D3.6	C34B2.7
+R07E4.3	C34B2.7
+R10E11.2	C34B2.7
+R10E11.8	C34B2.7
+R53.4	C34B2.7
+T01H3.1	C34B2.7
+T02H6.11	C34B2.7
+T06D8.5	C34B2.7
+T10B10.2	C34B2.7
+T10E9.7	C34B2.7
+T14F9.1	C34B2.7
+T20H4.5	C34B2.7
+T24C4.1	C34B2.7
+T26A5.3	C34B2.7
+T26E3.7	C34B2.7
+T27E9.2	C34B2.7
+VW02B12L.1	C34B2.7
+VW06B3R.1	C34B2.7
+W01A8.4	C34B2.7
+W09C5.8	C34B2.7
+W10D5.2	C34B2.7
+Y110A7A.12	C34B2.7
+Y37D8A.14	C34B2.7
+Y38F2AL.3	C34B2.7
+Y38F2AL.4	C34B2.7
+Y45G12B.1	C34B2.7
+Y46G5A.2	C34B2.7
+Y49A3A.2	C34B2.7
+Y51H1A.3	C34B2.7
+Y53G8AL.2	C34B2.7
+Y54E10BL.5	C34B2.7
+Y54F10AM.5	C34B2.7
+Y55H10A.1	C34B2.7
+Y56A3A.19	C34B2.7
+Y57G11C.12	C34B2.7
+Y63D3A.7	C34B2.7
+Y69A2AR.18	C34B2.7
+Y71H2AM.4	C34B2.7
+Y71H2AM.5	C34B2.7
+Y94H6A.8	C34B2.7
+ZC262.5	C34B2.7
+ZK637.8	C34B2.7
+ZK809.3	C34B2.7
+ZK970.4	C34B2.7
+ZK973.10	C34B2.7
+C34E10.6	C34B2.8
+C47E12.4	C34B2.8
+C53B7.4	C34B2.8
+C54G4.8	C34B2.8
+D2030.4	C34B2.8
+F02E8.1	C34B2.8
+F16B4.6	C34B2.8
+F20B6.2	C34B2.8
+F22D6.4	C34B2.8
+F26E4.6	C34B2.8
+F26E4.9	C34B2.8
+F27C1.7	C34B2.8
+F29C4.2	C34B2.8
+F31D4.9	C34B2.8
+F32D1.2	C34B2.8
+F33A8.5	C34B2.8
+F35G12.10	C34B2.8
+F35H10.4	C34B2.8
+F37C12.3	C34B2.8
+F40G9.2	C34B2.8
+F42A8.2	C34B2.8
+F42G8.10	C34B2.8
+F42G8.12	C34B2.8
+F44G4.2	C34B2.8
+F45H10.2	C34B2.8
+F45H10.3	C34B2.8
+F46F11.5	C34B2.8
+F49C12.13	C34B2.8
+F52E1.10	C34B2.8
+F53F4.10	C34B2.8
+F54D8.2	C34B2.8
+F55H2.2	C34B2.8
+F57B10.14	C34B2.8
+F58F12.1	C34B2.8
+F59C6.5	C34B2.8
+H28O16.1	C34B2.8
+JC8.5	C34B2.8
+K04G7.4	C34B2.8
+K07A12.3	C34B2.8
+K09A9.5	C34B2.8
+R04F11.2	C34B2.8
+R05D3.6	C34B2.8
+R07E4.3	C34B2.8
+R10E11.2	C34B2.8
+R10E11.8	C34B2.8
+R53.4	C34B2.8
+T01H3.1	C34B2.8
+T02H6.11	C34B2.8
+T06D8.5	C34B2.8
+T07C4.7	C34B2.8
+T10B10.2	C34B2.8
+T10E9.7	C34B2.8
+T14F9.1	C34B2.8
+T20H4.5	C34B2.8
+T24C4.1	C34B2.8
+T26A5.3	C34B2.8
+T26E3.7	C34B2.8
+T27E9.2	C34B2.8
+VW02B12L.1	C34B2.8
+VW06B3R.1	C34B2.8
+W01A8.4	C34B2.8
+W09C5.8	C34B2.8
+W10D5.2	C34B2.8
+Y110A7A.12	C34B2.8
+Y37D8A.14	C34B2.8
+Y38F2AL.3	C34B2.8
+Y38F2AL.4	C34B2.8
+Y45G12B.1	C34B2.8
+Y46G5A.2	C34B2.8
+Y49A3A.2	C34B2.8
+Y51H1A.3	C34B2.8
+Y53G8AL.2	C34B2.8
+Y54E10BL.5	C34B2.8
+Y54F10AM.5	C34B2.8
+Y55H10A.1	C34B2.8
+Y56A3A.19	C34B2.8
+Y57G11C.12	C34B2.8
+Y63D3A.7	C34B2.8
+Y69A2AR.18	C34B2.8
+Y71H2AM.4	C34B2.8
+Y71H2AM.5	C34B2.8
+Y94H6A.8	C34B2.8
+ZC262.5	C34B2.8
+ZK637.8	C34B2.8
+ZK809.3	C34B2.8
+ZK970.4	C34B2.8
+ZK973.10	C34B2.8
+C47E12.4	C34E10.6
+C53B7.4	C34E10.6
+C54G4.8	C34E10.6
+D2030.4	C34E10.6
+F02E8.1	C34E10.6
+F16B4.6	C34E10.6
+F20B6.2	C34E10.6
+F22D6.4	C34E10.6
+F26E4.6	C34E10.6
+F26E4.9	C34E10.6
+F27C1.7	C34E10.6
+F29C4.2	C34E10.6
+F31D4.9	C34E10.6
+F32D1.2	C34E10.6
+F33A8.5	C34E10.6
+F35G12.10	C34E10.6
+F35H10.4	C34E10.6
+F37C12.3	C34E10.6
+F40G9.2	C34E10.6
+F42A8.2	C34E10.6
+F42G8.10	C34E10.6
+F42G8.12	C34E10.6
+F44G4.2	C34E10.6
+F45H10.2	C34E10.6
+F45H10.3	C34E10.6
+F46F11.5	C34E10.6
+F49C12.13	C34E10.6
+F52E1.10	C34E10.6
+F53F4.10	C34E10.6
+F54D8.2	C34E10.6
+F55H2.2	C34E10.6
+F57B10.14	C34E10.6
+F58F12.1	C34E10.6
+F59C6.5	C34E10.6
+H28O16.1	C34E10.6
+JC8.5	C34E10.6
+K04G7.4	C34E10.6
+K07A12.3	C34E10.6
+K09A9.5	C34E10.6
+R04F11.2	C34E10.6
+R05D3.6	C34E10.6
+R07E4.3	C34E10.6
+R10E11.2	C34E10.6
+R10E11.8	C34E10.6
+R53.4	C34E10.6
+T01H3.1	C34E10.6
+T02H6.11	C34E10.6
+T06D8.5	C34E10.6
+T07C4.7	C34E10.6
+T10B10.2	C34E10.6
+T10E9.7	C34E10.6
+T14F9.1	C34E10.6
+T20H4.5	C34E10.6
+T24C4.1	C34E10.6
+T26A5.3	C34E10.6
+T26E3.7	C34E10.6
+T27E9.2	C34E10.6
+VW02B12L.1	C34E10.6
+VW06B3R.1	C34E10.6
+W01A8.4	C34E10.6
+W09C5.8	C34E10.6
+W10D5.2	C34E10.6
+Y110A7A.12	C34E10.6
+Y37D8A.14	C34E10.6
+Y38F2AL.3	C34E10.6
+Y38F2AL.4	C34E10.6
+Y45G12B.1	C34E10.6
+Y46G5A.2	C34E10.6
+Y49A3A.2	C34E10.6
+Y51H1A.3	C34E10.6
+Y53G8AL.2	C34E10.6
+Y54E10BL.5	C34E10.6
+Y54F10AM.5	C34E10.6
+Y55H10A.1	C34E10.6
+Y56A3A.19	C34E10.6
+Y57G11C.12	C34E10.6
+Y63D3A.7	C34E10.6
+Y69A2AR.18	C34E10.6
+Y71H2AM.4	C34E10.6
+Y71H2AM.5	C34E10.6
+Y94H6A.8	C34E10.6
+ZC262.5	C34E10.6
+ZK637.8	C34E10.6
+ZK809.3	C34E10.6
+ZK970.4	C34E10.6
+ZK973.10	C34E10.6
+C53B7.4	C47E12.4
+C54G4.8	C47E12.4
+D2030.4	C47E12.4
+F02E8.1	C47E12.4
+F16B4.6	C47E12.4
+F20B6.2	C47E12.4
+F22D6.4	C47E12.4
+F26E4.6	C47E12.4
+F26E4.9	C47E12.4
+F27C1.7	C47E12.4
+F29C4.2	C47E12.4
+F31D4.9	C47E12.4
+F32D1.2	C47E12.4
+F33A8.5	C47E12.4
+F35G12.10	C47E12.4
+F35H10.4	C47E12.4
+F37C12.3	C47E12.4
+F40G9.2	C47E12.4
+F42A8.2	C47E12.4
+F42G8.10	C47E12.4
+F42G8.12	C47E12.4
+F44G4.2	C47E12.4
+F45H10.2	C47E12.4
+F45H10.3	C47E12.4
+F46F11.5	C47E12.4
+F49C12.13	C47E12.4
+F52E1.10	C47E12.4
+F53F4.10	C47E12.4
+F54D8.2	C47E12.4
+F55H2.2	C47E12.4
+F57B10.14	C47E12.4
+F58F12.1	C47E12.4
+F59C6.5	C47E12.4
+H28O16.1	C47E12.4
+JC8.5	C47E12.4
+K04G7.4	C47E12.4
+K07A12.3	C47E12.4
+K09A9.5	C47E12.4
+R04F11.2	C47E12.4
+R05D3.6	C47E12.4
+R07E4.3	C47E12.4
+R10E11.2	C47E12.4
+R10E11.8	C47E12.4
+R53.4	C47E12.4
+T01H3.1	C47E12.4
+T02H6.11	C47E12.4
+T06D8.5	C47E12.4
+T07C4.7	C47E12.4
+T10B10.2	C47E12.4
+T10E9.7	C47E12.4
+T14F9.1	C47E12.4
+T20H4.5	C47E12.4
+T24C4.1	C47E12.4
+T26A5.3	C47E12.4
+T26E3.7	C47E12.4
+T27E9.2	C47E12.4
+VW02B12L.1	C47E12.4
+VW06B3R.1	C47E12.4
+W01A8.4	C47E12.4
+W09C5.8	C47E12.4
+W10D5.2	C47E12.4
+Y110A7A.12	C47E12.4
+Y37D8A.14	C47E12.4
+Y38F2AL.3	C47E12.4
+Y38F2AL.4	C47E12.4
+Y45G12B.1	C47E12.4
+Y46G5A.2	C47E12.4
+Y49A3A.2	C47E12.4
+Y51H1A.3	C47E12.4
+Y53G8AL.2	C47E12.4
+Y54E10BL.5	C47E12.4
+Y54F10AM.5	C47E12.4
+Y55H10A.1	C47E12.4
+Y56A3A.19	C47E12.4
+Y57G11C.12	C47E12.4
+Y63D3A.7	C47E12.4
+Y69A2AR.18	C47E12.4
+Y71H2AM.4	C47E12.4
+Y71H2AM.5	C47E12.4
+Y94H6A.8	C47E12.4
+ZC262.5	C47E12.4
+ZK637.8	C47E12.4
+ZK809.3	C47E12.4
+ZK970.4	C47E12.4
+ZK973.10	C47E12.4
+C54G4.8	C53B7.4
+D2030.4	C53B7.4
+F02E8.1	C53B7.4
+F16B4.6	C53B7.4
+F20B6.2	C53B7.4
+F22D6.4	C53B7.4
+F26E4.6	C53B7.4
+F26E4.9	C53B7.4
+F27C1.7	C53B7.4
+F29C4.2	C53B7.4
+F31D4.9	C53B7.4
+F32D1.2	C53B7.4
+F33A8.5	C53B7.4
+F35G12.10	C53B7.4
+F35H10.4	C53B7.4
+F37C12.3	C53B7.4
+F40G9.2	C53B7.4
+F42A8.2	C53B7.4
+F42G8.10	C53B7.4
+F42G8.12	C53B7.4
+F44G4.2	C53B7.4
+F45H10.2	C53B7.4
+F45H10.3	C53B7.4
+F46F11.5	C53B7.4
+F49C12.13	C53B7.4
+F52E1.10	C53B7.4
+F53F4.10	C53B7.4
+F54D8.2	C53B7.4
+F55H2.2	C53B7.4
+F57B10.14	C53B7.4
+F58F12.1	C53B7.4
+F59C6.5	C53B7.4
+H28O16.1	C53B7.4
+JC8.5	C53B7.4
+K04G7.4	C53B7.4
+K07A12.3	C53B7.4
+K09A9.5	C53B7.4
+R04F11.2	C53B7.4
+R05D3.6	C53B7.4
+R07E4.3	C53B7.4
+R10E11.2	C53B7.4
+R10E11.8	C53B7.4
+R53.4	C53B7.4
+T01H3.1	C53B7.4
+T02H6.11	C53B7.4
+T06D8.5	C53B7.4
+T07C4.7	C53B7.4
+T10B10.2	C53B7.4
+T10E9.7	C53B7.4
+T14F9.1	C53B7.4
+T20H4.5	C53B7.4
+T24C4.1	C53B7.4
+T26A5.3	C53B7.4
+T26E3.7	C53B7.4
+T27E9.2	C53B7.4
+VW02B12L.1	C53B7.4
+VW06B3R.1	C53B7.4
+W01A8.4	C53B7.4
+W09C5.8	C53B7.4
+W10D5.2	C53B7.4
+Y110A7A.12	C53B7.4
+Y37D8A.14	C53B7.4
+Y38F2AL.3	C53B7.4
+Y38F2AL.4	C53B7.4
+Y45G12B.1	C53B7.4
+Y46G5A.2	C53B7.4
+Y49A3A.2	C53B7.4
+Y51H1A.3	C53B7.4
+Y53G8AL.2	C53B7.4
+Y54E10BL.5	C53B7.4
+Y54F10AM.5	C53B7.4
+Y55H10A.1	C53B7.4
+Y56A3A.19	C53B7.4
+Y57G11C.12	C53B7.4
+Y63D3A.7	C53B7.4
+Y69A2AR.18	C53B7.4
+Y71H2AM.4	C53B7.4
+Y71H2AM.5	C53B7.4
+Y94H6A.8	C53B7.4
+ZC262.5	C53B7.4
+ZK637.8	C53B7.4
+ZK809.3	C53B7.4
+ZK970.4	C53B7.4
+ZK973.10	C53B7.4
+D2030.4	C54G4.8
+F02E8.1	C54G4.8
+F16B4.6	C54G4.8
+F20B6.2	C54G4.8
+F22D6.4	C54G4.8
+F26E4.6	C54G4.8
+F26E4.9	C54G4.8
+F27C1.7	C54G4.8
+F29C4.2	C54G4.8
+F31D4.9	C54G4.8
+F32D1.2	C54G4.8
+F33A8.5	C54G4.8
+F35G12.10	C54G4.8
+F35H10.4	C54G4.8
+F37C12.3	C54G4.8
+F40G9.2	C54G4.8
+F42A8.2	C54G4.8
+F42G8.10	C54G4.8
+F42G8.12	C54G4.8
+F44G4.2	C54G4.8
+F45H10.2	C54G4.8
+F45H10.3	C54G4.8
+F46F11.5	C54G4.8
+F49C12.13	C54G4.8
+F52E1.10	C54G4.8
+F53F4.10	C54G4.8
+F54D8.2	C54G4.8
+F55H2.2	C54G4.8
+F57B10.14	C54G4.8
+F58F12.1	C54G4.8
+F59C6.5	C54G4.8
+H28O16.1	C54G4.8
+JC8.5	C54G4.8
+K04G7.4	C54G4.8
+K07A12.3	C54G4.8
+K09A9.5	C54G4.8
+R04F11.2	C54G4.8
+R05D3.6	C54G4.8
+R07E4.3	C54G4.8
+R10E11.2	C54G4.8
+R10E11.8	C54G4.8
+R53.4	C54G4.8
+T01H3.1	C54G4.8
+T02H6.11	C54G4.8
+T06D8.5	C54G4.8
+T07C4.7	C54G4.8
+T10B10.2	C54G4.8
+T10E9.7	C54G4.8
+T14F9.1	C54G4.8
+T20H4.5	C54G4.8
+T24C4.1	C54G4.8
+T26A5.3	C54G4.8
+T26E3.7	C54G4.8
+T27E9.2	C54G4.8
+VW02B12L.1	C54G4.8
+VW06B3R.1	C54G4.8
+W01A8.4	C54G4.8
+W09C5.8	C54G4.8
+W10D5.2	C54G4.8
+Y110A7A.12	C54G4.8
+Y37D8A.14	C54G4.8
+Y38F2AL.3	C54G4.8
+Y38F2AL.4	C54G4.8
+Y45G12B.1	C54G4.8
+Y46G5A.2	C54G4.8
+Y49A3A.2	C54G4.8
+Y51H1A.3	C54G4.8
+Y53G8AL.2	C54G4.8
+Y54E10BL.5	C54G4.8
+Y54F10AM.5	C54G4.8
+Y55H10A.1	C54G4.8
+Y56A3A.19	C54G4.8
+Y57G11C.12	C54G4.8
+Y63D3A.7	C54G4.8
+Y69A2AR.18	C54G4.8
+Y71H2AM.4	C54G4.8
+Y71H2AM.5	C54G4.8
+Y94H6A.8	C54G4.8
+ZC262.5	C54G4.8
+ZK637.8	C54G4.8
+ZK809.3	C54G4.8
+ZK970.4	C54G4.8
+ZK973.10	C54G4.8
+F02E8.1	D2030.4
+F16B4.6	D2030.4
+F20B6.2	D2030.4
+F22D6.4	D2030.4
+F26E4.6	D2030.4
+F26E4.9	D2030.4
+F27C1.7	D2030.4
+F29C4.2	D2030.4
+F31D4.9	D2030.4
+F32D1.2	D2030.4
+F33A8.5	D2030.4
+F35G12.10	D2030.4
+F35H10.4	D2030.4
+F37C12.3	D2030.4
+F40G9.2	D2030.4
+F42A8.2	D2030.4
+F42G8.10	D2030.4
+F42G8.12	D2030.4
+F44G4.2	D2030.4
+F45H10.2	D2030.4
+F45H10.3	D2030.4
+F46F11.5	D2030.4
+F49C12.13	D2030.4
+F52E1.10	D2030.4
+F53F4.10	D2030.4
+F54D8.2	D2030.4
+F55H2.2	D2030.4
+F57B10.14	D2030.4
+F58F12.1	D2030.4
+F59C6.5	D2030.4
+H28O16.1	D2030.4
+JC8.5	D2030.4
+K04G7.4	D2030.4
+K07A12.3	D2030.4
+K09A9.5	D2030.4
+R04F11.2	D2030.4
+R05D3.6	D2030.4
+R07E4.3	D2030.4
+R10E11.2	D2030.4
+R10E11.8	D2030.4
+R53.4	D2030.4
+T01H3.1	D2030.4
+T02H6.11	D2030.4
+T06D8.5	D2030.4
+T07C4.7	D2030.4
+T10B10.2	D2030.4
+T10E9.7	D2030.4
+T14F9.1	D2030.4
+T20H4.5	D2030.4
+T24C4.1	D2030.4
+T26A5.3	D2030.4
+T26E3.7	D2030.4
+T27E9.2	D2030.4
+VW02B12L.1	D2030.4
+VW06B3R.1	D2030.4
+W01A8.4	D2030.4
+W09C5.8	D2030.4
+W10D5.2	D2030.4
+Y110A7A.12	D2030.4
+Y37D8A.14	D2030.4
+Y38F2AL.3	D2030.4
+Y38F2AL.4	D2030.4
+Y45G12B.1	D2030.4
+Y46G5A.2	D2030.4
+Y49A3A.2	D2030.4
+Y51H1A.3	D2030.4
+Y53G8AL.2	D2030.4
+Y54E10BL.5	D2030.4
+Y54F10AM.5	D2030.4
+Y55H10A.1	D2030.4
+Y56A3A.19	D2030.4
+Y57G11C.12	D2030.4
+Y63D3A.7	D2030.4
+Y69A2AR.18	D2030.4
+Y71H2AM.4	D2030.4
+Y71H2AM.5	D2030.4
+Y94H6A.8	D2030.4
+ZC262.5	D2030.4
+ZK637.8	D2030.4
+ZK809.3	D2030.4
+ZK970.4	D2030.4
+ZK973.10	D2030.4
+F16B4.6	F02E8.1
+F20B6.2	F02E8.1
+F22D6.4	F02E8.1
+F26E4.6	F02E8.1
+F26E4.9	F02E8.1
+F27C1.7	F02E8.1
+F29C4.2	F02E8.1
+F31D4.9	F02E8.1
+F32D1.2	F02E8.1
+F33A8.5	F02E8.1
+F35H10.4	F02E8.1
+F37C12.3	F02E8.1
+F40G9.2	F02E8.1
+F42A8.2	F02E8.1
+F42G8.10	F02E8.1
+F42G8.12	F02E8.1
+F44G4.2	F02E8.1
+F45H10.2	F02E8.1
+F45H10.3	F02E8.1
+F46F11.5	F02E8.1
+F49C12.13	F02E8.1
+F52E1.10	F02E8.1
+F53F4.10	F02E8.1
+F54D8.2	F02E8.1
+F55H2.2	F02E8.1
+F57B10.14	F02E8.1
+F58F12.1	F02E8.1
+F59C6.5	F02E8.1
+H28O16.1	F02E8.1
+JC8.5	F02E8.1
+K04G7.4	F02E8.1
+K07A12.3	F02E8.1
+K09A9.5	F02E8.1
+R04F11.2	F02E8.1
+R05D3.6	F02E8.1
+R07E4.3	F02E8.1
+R10E11.2	F02E8.1
+R10E11.8	F02E8.1
+R53.4	F02E8.1
+T01H3.1	F02E8.1
+T02H6.11	F02E8.1
+T06D8.5	F02E8.1
+T07C4.7	F02E8.1
+T10B10.2	F02E8.1
+T10E9.7	F02E8.1
+T14F9.1	F02E8.1
+T20H4.5	F02E8.1
+T24C4.1	F02E8.1
+T26A5.3	F02E8.1
+T26E3.7	F02E8.1
+T27E9.2	F02E8.1
+VW02B12L.1	F02E8.1
+VW06B3R.1	F02E8.1
+W01A8.4	F02E8.1
+W09C5.8	F02E8.1
+W10D5.2	F02E8.1
+Y110A7A.12	F02E8.1
+Y37D8A.14	F02E8.1
+Y38F2AL.3	F02E8.1
+Y38F2AL.4	F02E8.1
+Y45G12B.1	F02E8.1
+Y46G5A.2	F02E8.1
+Y49A3A.2	F02E8.1
+Y51H1A.3	F02E8.1
+Y53G8AL.2	F02E8.1
+Y54E10BL.5	F02E8.1
+Y54F10AM.5	F02E8.1
+Y55H10A.1	F02E8.1
+Y56A3A.19	F02E8.1
+Y57G11C.12	F02E8.1
+Y63D3A.7	F02E8.1
+Y69A2AR.18	F02E8.1
+Y71H2AM.4	F02E8.1
+Y71H2AM.5	F02E8.1
+Y94H6A.8	F02E8.1
+ZC262.5	F02E8.1
+ZK637.8	F02E8.1
+ZK809.3	F02E8.1
+ZK970.4	F02E8.1
+ZK973.10	F02E8.1
+F20B6.2	F16B4.6
+F22D6.4	F16B4.6
+F26E4.6	F16B4.6
+F26E4.9	F16B4.6
+F27C1.7	F16B4.6
+F29C4.2	F16B4.6
+F31D4.9	F16B4.6
+F32D1.2	F16B4.6
+F33A8.5	F16B4.6
+F35G12.10	F16B4.6
+F35H10.4	F16B4.6
+F37C12.3	F16B4.6
+F40G9.2	F16B4.6
+F42A8.2	F16B4.6
+F42G8.10	F16B4.6
+F42G8.12	F16B4.6
+F44G4.2	F16B4.6
+F45H10.2	F16B4.6
+F45H10.3	F16B4.6
+F46F11.5	F16B4.6
+F49C12.13	F16B4.6
+F52E1.10	F16B4.6
+F53F4.10	F16B4.6
+F54D8.2	F16B4.6
+F55H2.2	F16B4.6
+F57B10.14	F16B4.6
+F58F12.1	F16B4.6
+F59C6.5	F16B4.6
+H28O16.1	F16B4.6
+JC8.5	F16B4.6
+K04G7.4	F16B4.6
+K07A12.3	F16B4.6
+K09A9.5	F16B4.6
+R04F11.2	F16B4.6
+R05D3.6	F16B4.6
+R07E4.3	F16B4.6
+R10E11.2	F16B4.6
+R10E11.8	F16B4.6
+R53.4	F16B4.6
+T01H3.1	F16B4.6
+T02H6.11	F16B4.6
+T06D8.5	F16B4.6
+T07C4.7	F16B4.6
+T10B10.2	F16B4.6
+T10E9.7	F16B4.6
+T14F9.1	F16B4.6
+T20H4.5	F16B4.6
+T24C4.1	F16B4.6
+T26A5.3	F16B4.6
+T26E3.7	F16B4.6
+T27E9.2	F16B4.6
+VW02B12L.1	F16B4.6
+VW06B3R.1	F16B4.6
+W01A8.4	F16B4.6
+W09C5.8	F16B4.6
+W10D5.2	F16B4.6
+Y110A7A.12	F16B4.6
+Y37D8A.14	F16B4.6
+Y38F2AL.3	F16B4.6
+Y38F2AL.4	F16B4.6
+Y45G12B.1	F16B4.6
+Y46G5A.2	F16B4.6
+Y49A3A.2	F16B4.6
+Y51H1A.3	F16B4.6
+Y53G8AL.2	F16B4.6
+Y54E10BL.5	F16B4.6
+Y54F10AM.5	F16B4.6
+Y55H10A.1	F16B4.6
+Y56A3A.19	F16B4.6
+Y57G11C.12	F16B4.6
+Y63D3A.7	F16B4.6
+Y69A2AR.18	F16B4.6
+Y71H2AM.4	F16B4.6
+Y71H2AM.5	F16B4.6
+Y94H6A.8	F16B4.6
+ZC262.5	F16B4.6
+ZK637.8	F16B4.6
+ZK809.3	F16B4.6
+ZK970.4	F16B4.6
+ZK973.10	F16B4.6
+F22D6.4	F20B6.2
+F26E4.6	F20B6.2
+F26E4.9	F20B6.2
+F27C1.7	F20B6.2
+F29C4.2	F20B6.2
+F31D4.9	F20B6.2
+F32D1.2	F20B6.2
+F33A8.5	F20B6.2
+F35G12.10	F20B6.2
+F35H10.4	F20B6.2
+F37C12.3	F20B6.2
+F40G9.2	F20B6.2
+F42A8.2	F20B6.2
+F42G8.10	F20B6.2
+F42G8.12	F20B6.2
+F44G4.2	F20B6.2
+F45H10.2	F20B6.2
+F45H10.3	F20B6.2
+F46F11.5	F20B6.2
+F49C12.13	F20B6.2
+F52E1.10	F20B6.2
+F53F4.10	F20B6.2
+F54D8.2	F20B6.2
+F55H2.2	F20B6.2
+F57B10.14	F20B6.2
+F58F12.1	F20B6.2
+F59C6.5	F20B6.2
+H28O16.1	F20B6.2
+JC8.5	F20B6.2
+K04G7.4	F20B6.2
+K07A12.3	F20B6.2
+K09A9.5	F20B6.2
+R04F11.2	F20B6.2
+R05D3.6	F20B6.2
+R07E4.3	F20B6.2
+R10E11.2	F20B6.2
+R10E11.8	F20B6.2
+R53.4	F20B6.2
+T01H3.1	F20B6.2
+T02H6.11	F20B6.2
+T06D8.5	F20B6.2
+T07C4.7	F20B6.2
+T10B10.2	F20B6.2
+T10E9.7	F20B6.2
+T14F9.1	F20B6.2
+T20H4.5	F20B6.2
+T24C4.1	F20B6.2
+T26A5.3	F20B6.2
+T26E3.7	F20B6.2
+T27E9.2	F20B6.2
+VW02B12L.1	F20B6.2
+VW06B3R.1	F20B6.2
+W01A8.4	F20B6.2
+W09C5.8	F20B6.2
+W10D5.2	F20B6.2
+Y110A7A.12	F20B6.2
+Y37D8A.14	F20B6.2
+Y38F2AL.3	F20B6.2
+Y38F2AL.4	F20B6.2
+Y45G12B.1	F20B6.2
+Y46G5A.2	F20B6.2
+Y49A3A.2	F20B6.2
+Y51H1A.3	F20B6.2
+Y53G8AL.2	F20B6.2
+Y54E10BL.5	F20B6.2
+Y54F10AM.5	F20B6.2
+Y55H10A.1	F20B6.2
+Y56A3A.19	F20B6.2
+Y57G11C.12	F20B6.2
+Y63D3A.7	F20B6.2
+Y69A2AR.18	F20B6.2
+Y71H2AM.4	F20B6.2
+Y71H2AM.5	F20B6.2
+Y94H6A.8	F20B6.2
+ZC262.5	F20B6.2
+ZK637.8	F20B6.2
+ZK809.3	F20B6.2
+ZK970.4	F20B6.2
+ZK973.10	F20B6.2
+F26E4.6	F22D6.4
+F26E4.9	F22D6.4
+F27C1.7	F22D6.4
+F29C4.2	F22D6.4
+F31D4.9	F22D6.4
+F32D1.2	F22D6.4
+F33A8.5	F22D6.4
+F35G12.10	F22D6.4
+F35H10.4	F22D6.4
+F37C12.3	F22D6.4
+F40G9.2	F22D6.4
+F42A8.2	F22D6.4
+F42G8.10	F22D6.4
+F42G8.12	F22D6.4
+F44G4.2	F22D6.4
+F45H10.2	F22D6.4
+F45H10.3	F22D6.4
+F46F11.5	F22D6.4
+F49C12.13	F22D6.4
+F52E1.10	F22D6.4
+F53F4.10	F22D6.4
+F54D8.2	F22D6.4
+F55H2.2	F22D6.4
+F57B10.14	F22D6.4
+F58F12.1	F22D6.4
+F59C6.5	F22D6.4
+H28O16.1	F22D6.4
+JC8.5	F22D6.4
+K04G7.4	F22D6.4
+K07A12.3	F22D6.4
+K09A9.5	F22D6.4
+R04F11.2	F22D6.4
+R05D3.6	F22D6.4
+R07E4.3	F22D6.4
+R10E11.2	F22D6.4
+R10E11.8	F22D6.4
+R53.4	F22D6.4
+T01H3.1	F22D6.4
+T02H6.11	F22D6.4
+T06D8.5	F22D6.4
+T07C4.7	F22D6.4
+T10B10.2	F22D6.4
+T10E9.7	F22D6.4
+T14F9.1	F22D6.4
+T20H4.5	F22D6.4
+T24C4.1	F22D6.4
+T26A5.3	F22D6.4
+T26E3.7	F22D6.4
+T27E9.2	F22D6.4
+VW02B12L.1	F22D6.4
+VW06B3R.1	F22D6.4
+W01A8.4	F22D6.4
+W09C5.8	F22D6.4
+W10D5.2	F22D6.4
+Y110A7A.12	F22D6.4
+Y37D8A.14	F22D6.4
+Y38F2AL.3	F22D6.4
+Y38F2AL.4	F22D6.4
+Y45G12B.1	F22D6.4
+Y46G5A.2	F22D6.4
+Y49A3A.2	F22D6.4
+Y51H1A.3	F22D6.4
+Y53G8AL.2	F22D6.4
+Y54E10BL.5	F22D6.4
+Y54F10AM.5	F22D6.4
+Y55H10A.1	F22D6.4
+Y56A3A.19	F22D6.4
+Y57G11C.12	F22D6.4
+Y63D3A.7	F22D6.4
+Y69A2AR.18	F22D6.4
+Y71H2AM.4	F22D6.4
+Y71H2AM.5	F22D6.4
+Y94H6A.8	F22D6.4
+ZC262.5	F22D6.4
+ZK637.8	F22D6.4
+ZK809.3	F22D6.4
+ZK970.4	F22D6.4
+ZK973.10	F22D6.4
+F26E4.9	F26E4.6
+F27C1.7	F26E4.6
+F29C4.2	F26E4.6
+F31D4.9	F26E4.6
+F32D1.2	F26E4.6
+F33A8.5	F26E4.6
+F35G12.10	F26E4.6
+F35H10.4	F26E4.6
+F37C12.3	F26E4.6
+F40G9.2	F26E4.6
+F42A8.2	F26E4.6
+F42G8.10	F26E4.6
+F42G8.12	F26E4.6
+F44G4.2	F26E4.6
+F45H10.2	F26E4.6
+F45H10.3	F26E4.6
+F46F11.5	F26E4.6
+F49C12.13	F26E4.6
+F52E1.10	F26E4.6
+F53F4.10	F26E4.6
+F54D8.2	F26E4.6
+F55H2.2	F26E4.6
+F57B10.14	F26E4.6
+F58F12.1	F26E4.6
+F59C6.5	F26E4.6
+H28O16.1	F26E4.6
+JC8.5	F26E4.6
+K04G7.4	F26E4.6
+K07A12.3	F26E4.6
+K09A9.5	F26E4.6
+R04F11.2	F26E4.6
+R05D3.6	F26E4.6
+R07E4.3	F26E4.6
+R10E11.2	F26E4.6
+R10E11.8	F26E4.6
+R53.4	F26E4.6
+T01H3.1	F26E4.6
+T02H6.11	F26E4.6
+T06D8.5	F26E4.6
+T07C4.7	F26E4.6
+T10B10.2	F26E4.6
+T10E9.7	F26E4.6
+T14F9.1	F26E4.6
+T20H4.5	F26E4.6
+T24C4.1	F26E4.6
+T26A5.3	F26E4.6
+T26E3.7	F26E4.6
+T27E9.2	F26E4.6
+VW02B12L.1	F26E4.6
+VW06B3R.1	F26E4.6
+W01A8.4	F26E4.6
+W09C5.8	F26E4.6
+W10D5.2	F26E4.6
+Y110A7A.12	F26E4.6
+Y37D8A.14	F26E4.6
+Y38F2AL.3	F26E4.6
+Y38F2AL.4	F26E4.6
+Y45G12B.1	F26E4.6
+Y46G5A.2	F26E4.6
+Y49A3A.2	F26E4.6
+Y51H1A.3	F26E4.6
+Y53G8AL.2	F26E4.6
+Y54E10BL.5	F26E4.6
+Y54F10AM.5	F26E4.6
+Y55H10A.1	F26E4.6
+Y56A3A.19	F26E4.6
+Y57G11C.12	F26E4.6
+Y63D3A.7	F26E4.6
+Y69A2AR.18	F26E4.6
+Y71H2AM.4	F26E4.6
+Y71H2AM.5	F26E4.6
+Y94H6A.8	F26E4.6
+ZC262.5	F26E4.6
+ZK637.8	F26E4.6
+ZK809.3	F26E4.6
+ZK970.4	F26E4.6
+ZK973.10	F26E4.6
+F27C1.7	F26E4.9
+F29C4.2	F26E4.9
+F31D4.9	F26E4.9
+F32D1.2	F26E4.9
+F33A8.5	F26E4.9
+F35G12.10	F26E4.9
+F35H10.4	F26E4.9
+F37C12.3	F26E4.9
+F40G9.2	F26E4.9
+F42A8.2	F26E4.9
+F42G8.10	F26E4.9
+F42G8.12	F26E4.9
+F44G4.2	F26E4.9
+F45H10.2	F26E4.9
+F45H10.3	F26E4.9
+F46F11.5	F26E4.9
+F49C12.13	F26E4.9
+F52E1.10	F26E4.9
+F53F4.10	F26E4.9
+F54D8.2	F26E4.9
+F55H2.2	F26E4.9
+F57B10.14	F26E4.9
+F58F12.1	F26E4.9
+F59C6.5	F26E4.9
+H28O16.1	F26E4.9
+JC8.5	F26E4.9
+K04G7.4	F26E4.9
+K07A12.3	F26E4.9
+K09A9.5	F26E4.9
+R04F11.2	F26E4.9
+R05D3.6	F26E4.9
+R07E4.3	F26E4.9
+R10E11.2	F26E4.9
+R10E11.8	F26E4.9
+R53.4	F26E4.9
+T01H3.1	F26E4.9
+T02H6.11	F26E4.9
+T06D8.5	F26E4.9
+T07C4.7	F26E4.9
+T10B10.2	F26E4.9
+T10E9.7	F26E4.9
+T14F9.1	F26E4.9
+T20H4.5	F26E4.9
+T24C4.1	F26E4.9
+T26A5.3	F26E4.9
+T26E3.7	F26E4.9
+T27E9.2	F26E4.9
+VW02B12L.1	F26E4.9
+VW06B3R.1	F26E4.9
+W01A8.4	F26E4.9
+W09C5.8	F26E4.9
+W10D5.2	F26E4.9
+Y110A7A.12	F26E4.9
+Y37D8A.14	F26E4.9
+Y38F2AL.3	F26E4.9
+Y38F2AL.4	F26E4.9
+Y45G12B.1	F26E4.9
+Y46G5A.2	F26E4.9
+Y49A3A.2	F26E4.9
+Y51H1A.3	F26E4.9
+Y53G8AL.2	F26E4.9
+Y54E10BL.5	F26E4.9
+Y54F10AM.5	F26E4.9
+Y55H10A.1	F26E4.9
+Y56A3A.19	F26E4.9
+Y57G11C.12	F26E4.9
+Y63D3A.7	F26E4.9
+Y69A2AR.18	F26E4.9
+Y71H2AM.4	F26E4.9
+Y71H2AM.5	F26E4.9
+Y94H6A.8	F26E4.9
+ZC262.5	F26E4.9
+ZK637.8	F26E4.9
+ZK809.3	F26E4.9
+ZK970.4	F26E4.9
+ZK973.10	F26E4.9
+F29C4.2	F27C1.7
+F31D4.9	F27C1.7
+F32D1.2	F27C1.7
+F33A8.5	F27C1.7
+F35G12.10	F27C1.7
+F35H10.4	F27C1.7
+F37C12.3	F27C1.7
+F40G9.2	F27C1.7
+F42A8.2	F27C1.7
+F42G8.10	F27C1.7
+F42G8.12	F27C1.7
+F44G4.2	F27C1.7
+F45H10.2	F27C1.7
+F45H10.3	F27C1.7
+F46F11.5	F27C1.7
+F49C12.13	F27C1.7
+F52E1.10	F27C1.7
+F53F4.10	F27C1.7
+F54D8.2	F27C1.7
+F55H2.2	F27C1.7
+F57B10.14	F27C1.7
+F58F12.1	F27C1.7
+F59C6.5	F27C1.7
+H28O16.1	F27C1.7
+JC8.5	F27C1.7
+K04G7.4	F27C1.7
+K07A12.3	F27C1.7
+K09A9.5	F27C1.7
+R04F11.2	F27C1.7
+R05D3.6	F27C1.7
+R07E4.3	F27C1.7
+R10E11.2	F27C1.7
+R10E11.8	F27C1.7
+R53.4	F27C1.7
+T01H3.1	F27C1.7
+T02H6.11	F27C1.7
+T06D8.5	F27C1.7
+T07C4.7	F27C1.7
+T10B10.2	F27C1.7
+T10E9.7	F27C1.7
+T14F9.1	F27C1.7
+T20H4.5	F27C1.7
+T24C4.1	F27C1.7
+T26A5.3	F27C1.7
+T26E3.7	F27C1.7
+T27E9.2	F27C1.7
+VW02B12L.1	F27C1.7
+VW06B3R.1	F27C1.7
+W01A8.4	F27C1.7
+W09C5.8	F27C1.7
+W10D5.2	F27C1.7
+Y110A7A.12	F27C1.7
+Y37D8A.14	F27C1.7
+Y38F2AL.3	F27C1.7
+Y38F2AL.4	F27C1.7
+Y45G12B.1	F27C1.7
+Y46G5A.2	F27C1.7
+Y49A3A.2	F27C1.7
+Y51H1A.3	F27C1.7
+Y53G8AL.2	F27C1.7
+Y54E10BL.5	F27C1.7
+Y54F10AM.5	F27C1.7
+Y55H10A.1	F27C1.7
+Y56A3A.19	F27C1.7
+Y57G11C.12	F27C1.7
+Y63D3A.7	F27C1.7
+Y69A2AR.18	F27C1.7
+Y71H2AM.4	F27C1.7
+Y71H2AM.5	F27C1.7
+Y94H6A.8	F27C1.7
+ZC262.5	F27C1.7
+ZK637.8	F27C1.7
+ZK809.3	F27C1.7
+ZK970.4	F27C1.7
+ZK973.10	F27C1.7
+F31D4.9	F29C4.2
+F32D1.2	F29C4.2
+F33A8.5	F29C4.2
+F35G12.10	F29C4.2
+F35H10.4	F29C4.2
+F37C12.3	F29C4.2
+F40G9.2	F29C4.2
+F42A8.2	F29C4.2
+F42G8.10	F29C4.2
+F42G8.12	F29C4.2
+F44G4.2	F29C4.2
+F45H10.2	F29C4.2
+F45H10.3	F29C4.2
+F46F11.5	F29C4.2
+F49C12.13	F29C4.2
+F52E1.10	F29C4.2
+F53F4.10	F29C4.2
+F54D8.2	F29C4.2
+F55H2.2	F29C4.2
+F57B10.14	F29C4.2
+F58F12.1	F29C4.2
+F59C6.5	F29C4.2
+H28O16.1	F29C4.2
+JC8.5	F29C4.2
+K04G7.4	F29C4.2
+K07A12.3	F29C4.2
+K09A9.5	F29C4.2
+R04F11.2	F29C4.2
+R05D3.6	F29C4.2
+R07E4.3	F29C4.2
+R10E11.2	F29C4.2
+R10E11.8	F29C4.2
+R53.4	F29C4.2
+T01H3.1	F29C4.2
+T02H6.11	F29C4.2
+T06D8.5	F29C4.2
+T07C4.7	F29C4.2
+T10B10.2	F29C4.2
+T10E9.7	F29C4.2
+T14F9.1	F29C4.2
+T20H4.5	F29C4.2
+T24C4.1	F29C4.2
+T26A5.3	F29C4.2
+T26E3.7	F29C4.2
+T27E9.2	F29C4.2
+VW02B12L.1	F29C4.2
+VW06B3R.1	F29C4.2
+W01A8.4	F29C4.2
+W09C5.8	F29C4.2
+W10D5.2	F29C4.2
+Y110A7A.12	F29C4.2
+Y37D8A.14	F29C4.2
+Y38F2AL.3	F29C4.2
+Y38F2AL.4	F29C4.2
+Y45G12B.1	F29C4.2
+Y46G5A.2	F29C4.2
+Y49A3A.2	F29C4.2
+Y51H1A.3	F29C4.2
+Y53G8AL.2	F29C4.2
+Y54E10BL.5	F29C4.2
+Y54F10AM.5	F29C4.2
+Y55H10A.1	F29C4.2
+Y56A3A.19	F29C4.2
+Y57G11C.12	F29C4.2
+Y63D3A.7	F29C4.2
+Y69A2AR.18	F29C4.2
+Y71H2AM.4	F29C4.2
+Y71H2AM.5	F29C4.2
+Y94H6A.8	F29C4.2
+ZC262.5	F29C4.2
+ZK637.8	F29C4.2
+ZK809.3	F29C4.2
+ZK970.4	F29C4.2
+ZK973.10	F29C4.2
+F32D1.2	F31D4.9
+F33A8.5	F31D4.9
+F35G12.10	F31D4.9
+F35H10.4	F31D4.9
+F37C12.3	F31D4.9
+F40G9.2	F31D4.9
+F42A8.2	F31D4.9
+F42G8.10	F31D4.9
+F42G8.12	F31D4.9
+F44G4.2	F31D4.9
+F45H10.2	F31D4.9
+F45H10.3	F31D4.9
+F46F11.5	F31D4.9
+F49C12.13	F31D4.9
+F52E1.10	F31D4.9
+F53F4.10	F31D4.9
+F54D8.2	F31D4.9
+F55H2.2	F31D4.9
+F57B10.14	F31D4.9
+F58F12.1	F31D4.9
+F59C6.5	F31D4.9
+H28O16.1	F31D4.9
+JC8.5	F31D4.9
+K04G7.4	F31D4.9
+K07A12.3	F31D4.9
+K09A9.5	F31D4.9
+R04F11.2	F31D4.9
+R05D3.6	F31D4.9
+R07E4.3	F31D4.9
+R10E11.2	F31D4.9
+R10E11.8	F31D4.9
+R53.4	F31D4.9
+T01H3.1	F31D4.9
+T02H6.11	F31D4.9
+T06D8.5	F31D4.9
+T07C4.7	F31D4.9
+T10B10.2	F31D4.9
+T10E9.7	F31D4.9
+T14F9.1	F31D4.9
+T20H4.5	F31D4.9
+T24C4.1	F31D4.9
+T26A5.3	F31D4.9
+T26E3.7	F31D4.9
+T27E9.2	F31D4.9
+VW02B12L.1	F31D4.9
+VW06B3R.1	F31D4.9
+W01A8.4	F31D4.9
+W09C5.8	F31D4.9
+W10D5.2	F31D4.9
+Y110A7A.12	F31D4.9
+Y37D8A.14	F31D4.9
+Y38F2AL.3	F31D4.9
+Y38F2AL.4	F31D4.9
+Y45G12B.1	F31D4.9
+Y46G5A.2	F31D4.9
+Y49A3A.2	F31D4.9
+Y51H1A.3	F31D4.9
+Y53G8AL.2	F31D4.9
+Y54E10BL.5	F31D4.9
+Y54F10AM.5	F31D4.9
+Y55H10A.1	F31D4.9
+Y56A3A.19	F31D4.9
+Y57G11C.12	F31D4.9
+Y63D3A.7	F31D4.9
+Y69A2AR.18	F31D4.9
+Y71H2AM.4	F31D4.9
+Y71H2AM.5	F31D4.9
+Y94H6A.8	F31D4.9
+ZC262.5	F31D4.9
+ZK637.8	F31D4.9
+ZK809.3	F31D4.9
+ZK970.4	F31D4.9
+ZK973.10	F31D4.9
+F33A8.5	F32D1.2
+F35G12.10	F32D1.2
+F35H10.4	F32D1.2
+F37C12.3	F32D1.2
+F40G9.2	F32D1.2
+F42A8.2	F32D1.2
+F42G8.10	F32D1.2
+F42G8.12	F32D1.2
+F44G4.2	F32D1.2
+F45H10.2	F32D1.2
+F45H10.3	F32D1.2
+F46F11.5	F32D1.2
+F49C12.13	F32D1.2
+F52E1.10	F32D1.2
+F53F4.10	F32D1.2
+F54D8.2	F32D1.2
+F55H2.2	F32D1.2
+F57B10.14	F32D1.2
+F58F12.1	F32D1.2
+F59C6.5	F32D1.2
+H28O16.1	F32D1.2
+JC8.5	F32D1.2
+K04G7.4	F32D1.2
+K07A12.3	F32D1.2
+K09A9.5	F32D1.2
+R04F11.2	F32D1.2
+R05D3.6	F32D1.2
+R07E4.3	F32D1.2
+R10E11.2	F32D1.2
+R10E11.8	F32D1.2
+R53.4	F32D1.2
+T01H3.1	F32D1.2
+T02H6.11	F32D1.2
+T06D8.5	F32D1.2
+T07C4.7	F32D1.2
+T10B10.2	F32D1.2
+T10E9.7	F32D1.2
+T14F9.1	F32D1.2
+T20H4.5	F32D1.2
+T24C4.1	F32D1.2
+T26A5.3	F32D1.2
+T26E3.7	F32D1.2
+T27E9.2	F32D1.2
+VW02B12L.1	F32D1.2
+VW06B3R.1	F32D1.2
+W01A8.4	F32D1.2
+W09C5.8	F32D1.2
+W10D5.2	F32D1.2
+Y110A7A.12	F32D1.2
+Y37D8A.14	F32D1.2
+Y38F2AL.3	F32D1.2
+Y38F2AL.4	F32D1.2
+Y45G12B.1	F32D1.2
+Y46G5A.2	F32D1.2
+Y49A3A.2	F32D1.2
+Y51H1A.3	F32D1.2
+Y53G8AL.2	F32D1.2
+Y54E10BL.5	F32D1.2
+Y54F10AM.5	F32D1.2
+Y55H10A.1	F32D1.2
+Y56A3A.19	F32D1.2
+Y57G11C.12	F32D1.2
+Y63D3A.7	F32D1.2
+Y69A2AR.18	F32D1.2
+Y71H2AM.4	F32D1.2
+Y71H2AM.5	F32D1.2
+Y94H6A.8	F32D1.2
+ZC262.5	F32D1.2
+ZK637.8	F32D1.2
+ZK809.3	F32D1.2
+ZK970.4	F32D1.2
+ZK973.10	F32D1.2
+F35G12.10	F33A8.5
+F35H10.4	F33A8.5
+F37C12.3	F33A8.5
+F40G9.2	F33A8.5
+F42G8.10	F33A8.5
+F42G8.12	F33A8.5
+F44G4.2	F33A8.5
+F45H10.2	F33A8.5
+F45H10.3	F33A8.5
+F46F11.5	F33A8.5
+F49C12.13	F33A8.5
+F52E1.10	F33A8.5
+F53F4.10	F33A8.5
+F54D8.2	F33A8.5
+F55H2.2	F33A8.5
+F57B10.14	F33A8.5
+F58F12.1	F33A8.5
+F59C6.5	F33A8.5
+H28O16.1	F33A8.5
+JC8.5	F33A8.5
+K04G7.4	F33A8.5
+K07A12.3	F33A8.5
+K09A9.5	F33A8.5
+R04F11.2	F33A8.5
+R05D3.6	F33A8.5
+R07E4.3	F33A8.5
+R10E11.2	F33A8.5
+R10E11.8	F33A8.5
+R53.4	F33A8.5
+T01H3.1	F33A8.5
+T02H6.11	F33A8.5
+T06D8.5	F33A8.5
+T10B10.2	F33A8.5
+T10E9.7	F33A8.5
+T14F9.1	F33A8.5
+T20H4.5	F33A8.5
+T24C4.1	F33A8.5
+T26A5.3	F33A8.5
+T26E3.7	F33A8.5
+T27E9.2	F33A8.5
+VW02B12L.1	F33A8.5
+VW06B3R.1	F33A8.5
+W01A8.4	F33A8.5
+W09C5.8	F33A8.5
+W10D5.2	F33A8.5
+Y110A7A.12	F33A8.5
+Y37D8A.14	F33A8.5
+Y38F2AL.3	F33A8.5
+Y38F2AL.4	F33A8.5
+Y45G12B.1	F33A8.5
+Y46G5A.2	F33A8.5
+Y49A3A.2	F33A8.5
+Y51H1A.3	F33A8.5
+Y53G8AL.2	F33A8.5
+Y54E10BL.5	F33A8.5
+Y54F10AM.5	F33A8.5
+Y55H10A.1	F33A8.5
+Y56A3A.19	F33A8.5
+Y57G11C.12	F33A8.5
+Y63D3A.7	F33A8.5
+Y69A2AR.18	F33A8.5
+Y71H2AM.4	F33A8.5
+Y71H2AM.5	F33A8.5
+Y94H6A.8	F33A8.5
+ZC262.5	F33A8.5
+ZK637.8	F33A8.5
+ZK809.3	F33A8.5
+ZK970.4	F33A8.5
+ZK973.10	F33A8.5
+F35H10.4	F35G12.10
+F37C12.3	F35G12.10
+F40G9.2	F35G12.10
+F42A8.2	F35G12.10
+F42G8.10	F35G12.10
+F42G8.12	F35G12.10
+F44G4.2	F35G12.10
+F45H10.2	F35G12.10
+F45H10.3	F35G12.10
+F46F11.5	F35G12.10
+F49C12.13	F35G12.10
+F52E1.10	F35G12.10
+F53F4.10	F35G12.10
+F54D8.2	F35G12.10
+F55H2.2	F35G12.10
+F57B10.14	F35G12.10
+F58F12.1	F35G12.10
+F59C6.5	F35G12.10
+H28O16.1	F35G12.10
+JC8.5	F35G12.10
+K04G7.4	F35G12.10
+K07A12.3	F35G12.10
+K09A9.5	F35G12.10
+R04F11.2	F35G12.10
+R05D3.6	F35G12.10
+R07E4.3	F35G12.10
+R10E11.2	F35G12.10
+R10E11.8	F35G12.10
+R53.4	F35G12.10
+T01H3.1	F35G12.10
+T02H6.11	F35G12.10
+T06D8.5	F35G12.10
+T07C4.7	F35G12.10
+T10B10.2	F35G12.10
+T10E9.7	F35G12.10
+T14F9.1	F35G12.10
+T20H4.5	F35G12.10
+T24C4.1	F35G12.10
+T26A5.3	F35G12.10
+T26E3.7	F35G12.10
+T27E9.2	F35G12.10
+VW02B12L.1	F35G12.10
+VW06B3R.1	F35G12.10
+W01A8.4	F35G12.10
+W09C5.8	F35G12.10
+W10D5.2	F35G12.10
+Y110A7A.12	F35G12.10
+Y37D8A.14	F35G12.10
+Y38F2AL.3	F35G12.10
+Y38F2AL.4	F35G12.10
+Y45G12B.1	F35G12.10
+Y46G5A.2	F35G12.10
+Y49A3A.2	F35G12.10
+Y51H1A.3	F35G12.10
+Y53G8AL.2	F35G12.10
+Y54E10BL.5	F35G12.10
+Y54F10AM.5	F35G12.10
+Y55H10A.1	F35G12.10
+Y56A3A.19	F35G12.10
+Y57G11C.12	F35G12.10
+Y63D3A.7	F35G12.10
+Y69A2AR.18	F35G12.10
+Y71H2AM.4	F35G12.10
+Y71H2AM.5	F35G12.10
+Y94H6A.8	F35G12.10
+ZC262.5	F35G12.10
+ZK637.8	F35G12.10
+ZK809.3	F35G12.10
+ZK970.4	F35G12.10
+ZK973.10	F35G12.10
+F37C12.3	F35H10.4
+F40G9.2	F35H10.4
+F42A8.2	F35H10.4
+F42G8.10	F35H10.4
+F42G8.12	F35H10.4
+F44G4.2	F35H10.4
+F45H10.2	F35H10.4
+F45H10.3	F35H10.4
+F46F11.5	F35H10.4
+F49C12.13	F35H10.4
+F52E1.10	F35H10.4
+F53F4.10	F35H10.4
+F54D8.2	F35H10.4
+F55H2.2	F35H10.4
+F57B10.14	F35H10.4
+F58F12.1	F35H10.4
+F59C6.5	F35H10.4
+H28O16.1	F35H10.4
+JC8.5	F35H10.4
+K04G7.4	F35H10.4
+K07A12.3	F35H10.4
+K09A9.5	F35H10.4
+R04F11.2	F35H10.4
+R05D3.6	F35H10.4
+R07E4.3	F35H10.4
+R10E11.2	F35H10.4
+R10E11.8	F35H10.4
+R53.4	F35H10.4
+T01H3.1	F35H10.4
+T02H6.11	F35H10.4
+T06D8.5	F35H10.4
+T07C4.7	F35H10.4
+T10B10.2	F35H10.4
+T10E9.7	F35H10.4
+T14F9.1	F35H10.4
+T20H4.5	F35H10.4
+T24C4.1	F35H10.4
+T26A5.3	F35H10.4
+T26E3.7	F35H10.4
+T27E9.2	F35H10.4
+VW02B12L.1	F35H10.4
+VW06B3R.1	F35H10.4
+W01A8.4	F35H10.4
+W09C5.8	F35H10.4
+W10D5.2	F35H10.4
+Y110A7A.12	F35H10.4
+Y37D8A.14	F35H10.4
+Y38F2AL.3	F35H10.4
+Y38F2AL.4	F35H10.4
+Y45G12B.1	F35H10.4
+Y46G5A.2	F35H10.4
+Y49A3A.2	F35H10.4
+Y51H1A.3	F35H10.4
+Y53G8AL.2	F35H10.4
+Y54E10BL.5	F35H10.4
+Y54F10AM.5	F35H10.4
+Y55H10A.1	F35H10.4
+Y56A3A.19	F35H10.4
+Y57G11C.12	F35H10.4
+Y63D3A.7	F35H10.4
+Y69A2AR.18	F35H10.4
+Y71H2AM.4	F35H10.4
+Y71H2AM.5	F35H10.4
+Y94H6A.8	F35H10.4
+ZC262.5	F35H10.4
+ZK637.8	F35H10.4
+ZK809.3	F35H10.4
+ZK970.4	F35H10.4
+ZK973.10	F35H10.4
+F40G9.2	F37C12.3
+F42A8.2	F37C12.3
+F42G8.10	F37C12.3
+F42G8.12	F37C12.3
+F44G4.2	F37C12.3
+F45H10.2	F37C12.3
+F45H10.3	F37C12.3
+F46F11.5	F37C12.3
+F49C12.13	F37C12.3
+F52E1.10	F37C12.3
+F53F4.10	F37C12.3
+F54D8.2	F37C12.3
+F55H2.2	F37C12.3
+F57B10.14	F37C12.3
+F58F12.1	F37C12.3
+F59C6.5	F37C12.3
+H28O16.1	F37C12.3
+JC8.5	F37C12.3
+K04G7.4	F37C12.3
+K07A12.3	F37C12.3
+K09A9.5	F37C12.3
+R04F11.2	F37C12.3
+R05D3.6	F37C12.3
+R07E4.3	F37C12.3
+R10E11.2	F37C12.3
+R10E11.8	F37C12.3
+R53.4	F37C12.3
+T01H3.1	F37C12.3
+T02H6.11	F37C12.3
+T06D8.5	F37C12.3
+T07C4.7	F37C12.3
+T10B10.2	F37C12.3
+T10E9.7	F37C12.3
+T14F9.1	F37C12.3
+T20H4.5	F37C12.3
+T24C4.1	F37C12.3
+T26A5.3	F37C12.3
+T26E3.7	F37C12.3
+T27E9.2	F37C12.3
+VW02B12L.1	F37C12.3
+VW06B3R.1	F37C12.3
+W01A8.4	F37C12.3
+W09C5.8	F37C12.3
+W10D5.2	F37C12.3
+Y110A7A.12	F37C12.3
+Y37D8A.14	F37C12.3
+Y38F2AL.3	F37C12.3
+Y38F2AL.4	F37C12.3
+Y45G12B.1	F37C12.3
+Y46G5A.2	F37C12.3
+Y49A3A.2	F37C12.3
+Y51H1A.3	F37C12.3
+Y53G8AL.2	F37C12.3
+Y54E10BL.5	F37C12.3
+Y54F10AM.5	F37C12.3
+Y55H10A.1	F37C12.3
+Y56A3A.19	F37C12.3
+Y57G11C.12	F37C12.3
+Y63D3A.7	F37C12.3
+Y69A2AR.18	F37C12.3
+Y71H2AM.4	F37C12.3
+Y71H2AM.5	F37C12.3
+Y94H6A.8	F37C12.3
+ZC262.5	F37C12.3
+ZK637.8	F37C12.3
+ZK809.3	F37C12.3
+ZK970.4	F37C12.3
+ZK973.10	F37C12.3
+F42A8.2	F40G9.2
+F42G8.10	F40G9.2
+F42G8.12	F40G9.2
+F44G4.2	F40G9.2
+F45H10.2	F40G9.2
+F45H10.3	F40G9.2
+F46F11.5	F40G9.2
+F49C12.13	F40G9.2
+F52E1.10	F40G9.2
+F53F4.10	F40G9.2
+F54D8.2	F40G9.2
+F55H2.2	F40G9.2
+F57B10.14	F40G9.2
+F58F12.1	F40G9.2
+F59C6.5	F40G9.2
+H28O16.1	F40G9.2
+JC8.5	F40G9.2
+K04G7.4	F40G9.2
+K07A12.3	F40G9.2
+K09A9.5	F40G9.2
+R04F11.2	F40G9.2
+R05D3.6	F40G9.2
+R07E4.3	F40G9.2
+R10E11.2	F40G9.2
+R10E11.8	F40G9.2
+R53.4	F40G9.2
+T01H3.1	F40G9.2
+T02H6.11	F40G9.2
+T06D8.5	F40G9.2
+T07C4.7	F40G9.2
+T10B10.2	F40G9.2
+T10E9.7	F40G9.2
+T14F9.1	F40G9.2
+T20H4.5	F40G9.2
+T24C4.1	F40G9.2
+T26A5.3	F40G9.2
+T26E3.7	F40G9.2
+T27E9.2	F40G9.2
+VW02B12L.1	F40G9.2
+VW06B3R.1	F40G9.2
+W01A8.4	F40G9.2
+W09C5.8	F40G9.2
+W10D5.2	F40G9.2
+Y110A7A.12	F40G9.2
+Y37D8A.14	F40G9.2
+Y38F2AL.3	F40G9.2
+Y38F2AL.4	F40G9.2
+Y45G12B.1	F40G9.2
+Y46G5A.2	F40G9.2
+Y49A3A.2	F40G9.2
+Y51H1A.3	F40G9.2
+Y53G8AL.2	F40G9.2
+Y54E10BL.5	F40G9.2
+Y54F10AM.5	F40G9.2
+Y55H10A.1	F40G9.2
+Y56A3A.19	F40G9.2
+Y57G11C.12	F40G9.2
+Y63D3A.7	F40G9.2
+Y69A2AR.18	F40G9.2
+Y71H2AM.4	F40G9.2
+Y71H2AM.5	F40G9.2
+Y94H6A.8	F40G9.2
+ZC262.5	F40G9.2
+ZK637.8	F40G9.2
+ZK809.3	F40G9.2
+ZK970.4	F40G9.2
+ZK973.10	F40G9.2
+F42G8.10	F42A8.2
+F42G8.12	F42A8.2
+F44G4.2	F42A8.2
+F45H10.2	F42A8.2
+F45H10.3	F42A8.2
+F46F11.5	F42A8.2
+F49C12.13	F42A8.2
+F52E1.10	F42A8.2
+F53F4.10	F42A8.2
+F54D8.2	F42A8.2
+F55H2.2	F42A8.2
+F57B10.14	F42A8.2
+F58F12.1	F42A8.2
+F59C6.5	F42A8.2
+H28O16.1	F42A8.2
+JC8.5	F42A8.2
+K04G7.4	F42A8.2
+K07A12.3	F42A8.2
+K09A9.5	F42A8.2
+R04F11.2	F42A8.2
+R05D3.6	F42A8.2
+R07E4.3	F42A8.2
+R10E11.2	F42A8.2
+R10E11.8	F42A8.2
+R53.4	F42A8.2
+T01H3.1	F42A8.2
+T02H6.11	F42A8.2
+T06D8.5	F42A8.2
+T10B10.2	F42A8.2
+T10E9.7	F42A8.2
+T14F9.1	F42A8.2
+T20H4.5	F42A8.2
+T24C4.1	F42A8.2
+T26A5.3	F42A8.2
+T26E3.7	F42A8.2
+T27E9.2	F42A8.2
+VW02B12L.1	F42A8.2
+VW06B3R.1	F42A8.2
+W01A8.4	F42A8.2
+W09C5.8	F42A8.2
+W10D5.2	F42A8.2
+Y110A7A.12	F42A8.2
+Y37D8A.14	F42A8.2
+Y38F2AL.3	F42A8.2
+Y38F2AL.4	F42A8.2
+Y45G12B.1	F42A8.2
+Y46G5A.2	F42A8.2
+Y49A3A.2	F42A8.2
+Y51H1A.3	F42A8.2
+Y53G8AL.2	F42A8.2
+Y54E10BL.5	F42A8.2
+Y54F10AM.5	F42A8.2
+Y55H10A.1	F42A8.2
+Y56A3A.19	F42A8.2
+Y57G11C.12	F42A8.2
+Y63D3A.7	F42A8.2
+Y69A2AR.18	F42A8.2
+Y71H2AM.4	F42A8.2
+Y71H2AM.5	F42A8.2
+Y94H6A.8	F42A8.2
+ZC262.5	F42A8.2
+ZK637.8	F42A8.2
+ZK809.3	F42A8.2
+ZK970.4	F42A8.2
+ZK973.10	F42A8.2
+F42G8.12	F42G8.10
+F44G4.2	F42G8.10
+F45H10.2	F42G8.10
+F45H10.3	F42G8.10
+F46F11.5	F42G8.10
+F49C12.13	F42G8.10
+F52E1.10	F42G8.10
+F53F4.10	F42G8.10
+F54D8.2	F42G8.10
+F55H2.2	F42G8.10
+F57B10.14	F42G8.10
+F58F12.1	F42G8.10
+F59C6.5	F42G8.10
+H28O16.1	F42G8.10
+JC8.5	F42G8.10
+K04G7.4	F42G8.10
+K07A12.3	F42G8.10
+K09A9.5	F42G8.10
+R04F11.2	F42G8.10
+R05D3.6	F42G8.10
+R07E4.3	F42G8.10
+R10E11.2	F42G8.10
+R10E11.8	F42G8.10
+R53.4	F42G8.10
+T01H3.1	F42G8.10
+T02H6.11	F42G8.10
+T06D8.5	F42G8.10
+T07C4.7	F42G8.10
+T10B10.2	F42G8.10
+T10E9.7	F42G8.10
+T14F9.1	F42G8.10
+T20H4.5	F42G8.10
+T24C4.1	F42G8.10
+T26A5.3	F42G8.10
+T26E3.7	F42G8.10
+T27E9.2	F42G8.10
+VW02B12L.1	F42G8.10
+VW06B3R.1	F42G8.10
+W01A8.4	F42G8.10
+W09C5.8	F42G8.10
+W10D5.2	F42G8.10
+Y110A7A.12	F42G8.10
+Y37D8A.14	F42G8.10
+Y38F2AL.3	F42G8.10
+Y38F2AL.4	F42G8.10
+Y45G12B.1	F42G8.10
+Y46G5A.2	F42G8.10
+Y49A3A.2	F42G8.10
+Y51H1A.3	F42G8.10
+Y53G8AL.2	F42G8.10
+Y54E10BL.5	F42G8.10
+Y54F10AM.5	F42G8.10
+Y55H10A.1	F42G8.10
+Y56A3A.19	F42G8.10
+Y57G11C.12	F42G8.10
+Y63D3A.7	F42G8.10
+Y69A2AR.18	F42G8.10
+Y71H2AM.4	F42G8.10
+Y71H2AM.5	F42G8.10
+Y94H6A.8	F42G8.10
+ZC262.5	F42G8.10
+ZK637.8	F42G8.10
+ZK809.3	F42G8.10
+ZK970.4	F42G8.10
+ZK973.10	F42G8.10
+F44G4.2	F42G8.12
+F45H10.2	F42G8.12
+F45H10.3	F42G8.12
+F46F11.5	F42G8.12
+F49C12.13	F42G8.12
+F52E1.10	F42G8.12
+F53F4.10	F42G8.12
+F54D8.2	F42G8.12
+F55H2.2	F42G8.12
+F57B10.14	F42G8.12
+F58F12.1	F42G8.12
+F59C6.5	F42G8.12
+H28O16.1	F42G8.12
+JC8.5	F42G8.12
+K04G7.4	F42G8.12
+K07A12.3	F42G8.12
+K09A9.5	F42G8.12
+R04F11.2	F42G8.12
+R05D3.6	F42G8.12
+R07E4.3	F42G8.12
+R10E11.2	F42G8.12
+R10E11.8	F42G8.12
+R53.4	F42G8.12
+T01H3.1	F42G8.12
+T02H6.11	F42G8.12
+T06D8.5	F42G8.12
+T07C4.7	F42G8.12
+T10B10.2	F42G8.12
+T10E9.7	F42G8.12
+T14F9.1	F42G8.12
+T20H4.5	F42G8.12
+T24C4.1	F42G8.12
+T26A5.3	F42G8.12
+T26E3.7	F42G8.12
+T27E9.2	F42G8.12
+VW02B12L.1	F42G8.12
+VW06B3R.1	F42G8.12
+W01A8.4	F42G8.12
+W09C5.8	F42G8.12
+W10D5.2	F42G8.12
+Y110A7A.12	F42G8.12
+Y37D8A.14	F42G8.12
+Y38F2AL.3	F42G8.12
+Y38F2AL.4	F42G8.12
+Y45G12B.1	F42G8.12
+Y46G5A.2	F42G8.12
+Y49A3A.2	F42G8.12
+Y51H1A.3	F42G8.12
+Y53G8AL.2	F42G8.12
+Y54E10BL.5	F42G8.12
+Y54F10AM.5	F42G8.12
+Y55H10A.1	F42G8.12
+Y56A3A.19	F42G8.12
+Y57G11C.12	F42G8.12
+Y63D3A.7	F42G8.12
+Y69A2AR.18	F42G8.12
+Y71H2AM.4	F42G8.12
+Y71H2AM.5	F42G8.12
+Y94H6A.8	F42G8.12
+ZC262.5	F42G8.12
+ZK637.8	F42G8.12
+ZK809.3	F42G8.12
+ZK970.4	F42G8.12
+ZK973.10	F42G8.12
+F45H10.2	F44G4.2
+F45H10.3	F44G4.2
+F46F11.5	F44G4.2
+F49C12.13	F44G4.2
+F52E1.10	F44G4.2
+F53F4.10	F44G4.2
+F54D8.2	F44G4.2
+F55H2.2	F44G4.2
+F57B10.14	F44G4.2
+F58F12.1	F44G4.2
+F59C6.5	F44G4.2
+H28O16.1	F44G4.2
+JC8.5	F44G4.2
+K04G7.4	F44G4.2
+K07A12.3	F44G4.2
+K09A9.5	F44G4.2
+R04F11.2	F44G4.2
+R05D3.6	F44G4.2
+R07E4.3	F44G4.2
+R10E11.2	F44G4.2
+R10E11.8	F44G4.2
+R53.4	F44G4.2
+T01H3.1	F44G4.2
+T02H6.11	F44G4.2
+T06D8.5	F44G4.2
+T07C4.7	F44G4.2
+T10B10.2	F44G4.2
+T10E9.7	F44G4.2
+T14F9.1	F44G4.2
+T20H4.5	F44G4.2
+T24C4.1	F44G4.2
+T26A5.3	F44G4.2
+T26E3.7	F44G4.2
+T27E9.2	F44G4.2
+VW02B12L.1	F44G4.2
+VW06B3R.1	F44G4.2
+W01A8.4	F44G4.2
+W09C5.8	F44G4.2
+W10D5.2	F44G4.2
+Y110A7A.12	F44G4.2
+Y37D8A.14	F44G4.2
+Y38F2AL.3	F44G4.2
+Y38F2AL.4	F44G4.2
+Y45G12B.1	F44G4.2
+Y46G5A.2	F44G4.2
+Y49A3A.2	F44G4.2
+Y51H1A.3	F44G4.2
+Y53G8AL.2	F44G4.2
+Y54E10BL.5	F44G4.2
+Y54F10AM.5	F44G4.2
+Y55H10A.1	F44G4.2
+Y56A3A.19	F44G4.2
+Y57G11C.12	F44G4.2
+Y63D3A.7	F44G4.2
+Y69A2AR.18	F44G4.2
+Y71H2AM.4	F44G4.2
+Y71H2AM.5	F44G4.2
+Y94H6A.8	F44G4.2
+ZC262.5	F44G4.2
+ZK637.8	F44G4.2
+ZK809.3	F44G4.2
+ZK970.4	F44G4.2
+ZK973.10	F44G4.2
+F45H10.3	F45H10.2
+F46F11.5	F45H10.2
+F49C12.13	F45H10.2
+F52E1.10	F45H10.2
+F53F4.10	F45H10.2
+F54D8.2	F45H10.2
+F55H2.2	F45H10.2
+F57B10.14	F45H10.2
+F58F12.1	F45H10.2
+F59C6.5	F45H10.2
+H28O16.1	F45H10.2
+JC8.5	F45H10.2
+K04G7.4	F45H10.2
+K07A12.3	F45H10.2
+K09A9.5	F45H10.2
+R04F11.2	F45H10.2
+R05D3.6	F45H10.2
+R07E4.3	F45H10.2
+R10E11.2	F45H10.2
+R10E11.8	F45H10.2
+R53.4	F45H10.2
+T01H3.1	F45H10.2
+T02H6.11	F45H10.2
+T06D8.5	F45H10.2
+T07C4.7	F45H10.2
+T10B10.2	F45H10.2
+T10E9.7	F45H10.2
+T14F9.1	F45H10.2
+T20H4.5	F45H10.2
+T24C4.1	F45H10.2
+T26A5.3	F45H10.2
+T26E3.7	F45H10.2
+T27E9.2	F45H10.2
+VW02B12L.1	F45H10.2
+VW06B3R.1	F45H10.2
+W01A8.4	F45H10.2
+W09C5.8	F45H10.2
+W10D5.2	F45H10.2
+Y110A7A.12	F45H10.2
+Y37D8A.14	F45H10.2
+Y38F2AL.3	F45H10.2
+Y38F2AL.4	F45H10.2
+Y45G12B.1	F45H10.2
+Y46G5A.2	F45H10.2
+Y49A3A.2	F45H10.2
+Y51H1A.3	F45H10.2
+Y53G8AL.2	F45H10.2
+Y54E10BL.5	F45H10.2
+Y54F10AM.5	F45H10.2
+Y55H10A.1	F45H10.2
+Y56A3A.19	F45H10.2
+Y57G11C.12	F45H10.2
+Y63D3A.7	F45H10.2
+Y69A2AR.18	F45H10.2
+Y71H2AM.4	F45H10.2
+Y71H2AM.5	F45H10.2
+Y94H6A.8	F45H10.2
+ZC262.5	F45H10.2
+ZK637.8	F45H10.2
+ZK809.3	F45H10.2
+ZK970.4	F45H10.2
+ZK973.10	F45H10.2
+F46F11.5	F45H10.3
+F49C12.13	F45H10.3
+F52E1.10	F45H10.3
+F53F4.10	F45H10.3
+F54D8.2	F45H10.3
+F55H2.2	F45H10.3
+F57B10.14	F45H10.3
+F58F12.1	F45H10.3
+F59C6.5	F45H10.3
+H28O16.1	F45H10.3
+JC8.5	F45H10.3
+K04G7.4	F45H10.3
+K07A12.3	F45H10.3
+K09A9.5	F45H10.3
+R04F11.2	F45H10.3
+R05D3.6	F45H10.3
+R07E4.3	F45H10.3
+R10E11.2	F45H10.3
+R10E11.8	F45H10.3
+R53.4	F45H10.3
+T01H3.1	F45H10.3
+T02H6.11	F45H10.3
+T06D8.5	F45H10.3
+T07C4.7	F45H10.3
+T10B10.2	F45H10.3
+T10E9.7	F45H10.3
+T14F9.1	F45H10.3
+T20H4.5	F45H10.3
+T24C4.1	F45H10.3
+T26A5.3	F45H10.3
+T26E3.7	F45H10.3
+T27E9.2	F45H10.3
+VW02B12L.1	F45H10.3
+VW06B3R.1	F45H10.3
+W01A8.4	F45H10.3
+W09C5.8	F45H10.3
+W10D5.2	F45H10.3
+Y110A7A.12	F45H10.3
+Y37D8A.14	F45H10.3
+Y38F2AL.3	F45H10.3
+Y38F2AL.4	F45H10.3
+Y45G12B.1	F45H10.3
+Y46G5A.2	F45H10.3
+Y49A3A.2	F45H10.3
+Y51H1A.3	F45H10.3
+Y53G8AL.2	F45H10.3
+Y54E10BL.5	F45H10.3
+Y54F10AM.5	F45H10.3
+Y55H10A.1	F45H10.3
+Y56A3A.19	F45H10.3
+Y57G11C.12	F45H10.3
+Y63D3A.7	F45H10.3
+Y69A2AR.18	F45H10.3
+Y71H2AM.4	F45H10.3
+Y71H2AM.5	F45H10.3
+Y94H6A.8	F45H10.3
+ZC262.5	F45H10.3
+ZK637.8	F45H10.3
+ZK809.3	F45H10.3
+ZK970.4	F45H10.3
+ZK973.10	F45H10.3
+F49C12.13	F46F11.5
+F52E1.10	F46F11.5
+F53F4.10	F46F11.5
+F54D8.2	F46F11.5
+F55H2.2	F46F11.5
+F57B10.14	F46F11.5
+F58F12.1	F46F11.5
+F59C6.5	F46F11.5
+H28O16.1	F46F11.5
+JC8.5	F46F11.5
+K04G7.4	F46F11.5
+K07A12.3	F46F11.5
+K09A9.5	F46F11.5
+R04F11.2	F46F11.5
+R05D3.6	F46F11.5
+R07E4.3	F46F11.5
+R10E11.2	F46F11.5
+R10E11.8	F46F11.5
+R53.4	F46F11.5
+T01H3.1	F46F11.5
+T02H6.11	F46F11.5
+T06D8.5	F46F11.5
+T07C4.7	F46F11.5
+T10B10.2	F46F11.5
+T10E9.7	F46F11.5
+T14F9.1	F46F11.5
+T20H4.5	F46F11.5
+T24C4.1	F46F11.5
+T26A5.3	F46F11.5
+T26E3.7	F46F11.5
+T27E9.2	F46F11.5
+VW02B12L.1	F46F11.5
+VW06B3R.1	F46F11.5
+W01A8.4	F46F11.5
+W09C5.8	F46F11.5
+W10D5.2	F46F11.5
+Y110A7A.12	F46F11.5
+Y37D8A.14	F46F11.5
+Y38F2AL.3	F46F11.5
+Y38F2AL.4	F46F11.5
+Y45G12B.1	F46F11.5
+Y46G5A.2	F46F11.5
+Y49A3A.2	F46F11.5
+Y51H1A.3	F46F11.5
+Y53G8AL.2	F46F11.5
+Y54E10BL.5	F46F11.5
+Y54F10AM.5	F46F11.5
+Y55H10A.1	F46F11.5
+Y56A3A.19	F46F11.5
+Y57G11C.12	F46F11.5
+Y63D3A.7	F46F11.5
+Y69A2AR.18	F46F11.5
+Y71H2AM.4	F46F11.5
+Y71H2AM.5	F46F11.5
+Y94H6A.8	F46F11.5
+ZC262.5	F46F11.5
+ZK637.8	F46F11.5
+ZK809.3	F46F11.5
+ZK970.4	F46F11.5
+ZK973.10	F46F11.5
+F52E1.10	F49C12.13
+F53F4.10	F49C12.13
+F54D8.2	F49C12.13
+F55H2.2	F49C12.13
+F57B10.14	F49C12.13
+F58F12.1	F49C12.13
+F59C6.5	F49C12.13
+H28O16.1	F49C12.13
+JC8.5	F49C12.13
+K04G7.4	F49C12.13
+K07A12.3	F49C12.13
+K09A9.5	F49C12.13
+R04F11.2	F49C12.13
+R05D3.6	F49C12.13
+R07E4.3	F49C12.13
+R10E11.2	F49C12.13
+R10E11.8	F49C12.13
+R53.4	F49C12.13
+T01H3.1	F49C12.13
+T02H6.11	F49C12.13
+T06D8.5	F49C12.13
+T07C4.7	F49C12.13
+T10B10.2	F49C12.13
+T10E9.7	F49C12.13
+T14F9.1	F49C12.13
+T20H4.5	F49C12.13
+T24C4.1	F49C12.13
+T26A5.3	F49C12.13
+T26E3.7	F49C12.13
+T27E9.2	F49C12.13
+VW02B12L.1	F49C12.13
+VW06B3R.1	F49C12.13
+W01A8.4	F49C12.13
+W09C5.8	F49C12.13
+W10D5.2	F49C12.13
+Y110A7A.12	F49C12.13
+Y37D8A.14	F49C12.13
+Y38F2AL.3	F49C12.13
+Y38F2AL.4	F49C12.13
+Y45G12B.1	F49C12.13
+Y46G5A.2	F49C12.13
+Y49A3A.2	F49C12.13
+Y51H1A.3	F49C12.13
+Y53G8AL.2	F49C12.13
+Y54E10BL.5	F49C12.13
+Y54F10AM.5	F49C12.13
+Y55H10A.1	F49C12.13
+Y56A3A.19	F49C12.13
+Y57G11C.12	F49C12.13
+Y63D3A.7	F49C12.13
+Y69A2AR.18	F49C12.13
+Y71H2AM.4	F49C12.13
+Y71H2AM.5	F49C12.13
+Y94H6A.8	F49C12.13
+ZC262.5	F49C12.13
+ZK637.8	F49C12.13
+ZK809.3	F49C12.13
+ZK970.4	F49C12.13
+ZK973.10	F49C12.13
+F53F4.10	F52E1.10
+F54D8.2	F52E1.10
+F55H2.2	F52E1.10
+F57B10.14	F52E1.10
+F58F12.1	F52E1.10
+F59C6.5	F52E1.10
+H28O16.1	F52E1.10
+JC8.5	F52E1.10
+K04G7.4	F52E1.10
+K07A12.3	F52E1.10
+K09A9.5	F52E1.10
+R04F11.2	F52E1.10
+R05D3.6	F52E1.10
+R07E4.3	F52E1.10
+R10E11.2	F52E1.10
+R10E11.8	F52E1.10
+R53.4	F52E1.10
+T01H3.1	F52E1.10
+T02H6.11	F52E1.10
+T06D8.5	F52E1.10
+T07C4.7	F52E1.10
+T10B10.2	F52E1.10
+T10E9.7	F52E1.10
+T14F9.1	F52E1.10
+T20H4.5	F52E1.10
+T24C4.1	F52E1.10
+T26A5.3	F52E1.10
+T26E3.7	F52E1.10
+T27E9.2	F52E1.10
+VW02B12L.1	F52E1.10
+VW06B3R.1	F52E1.10
+W01A8.4	F52E1.10
+W09C5.8	F52E1.10
+W10D5.2	F52E1.10
+Y110A7A.12	F52E1.10
+Y37D8A.14	F52E1.10
+Y38F2AL.3	F52E1.10
+Y38F2AL.4	F52E1.10
+Y45G12B.1	F52E1.10
+Y46G5A.2	F52E1.10
+Y49A3A.2	F52E1.10
+Y51H1A.3	F52E1.10
+Y53G8AL.2	F52E1.10
+Y54E10BL.5	F52E1.10
+Y54F10AM.5	F52E1.10
+Y55H10A.1	F52E1.10
+Y56A3A.19	F52E1.10
+Y57G11C.12	F52E1.10
+Y63D3A.7	F52E1.10
+Y69A2AR.18	F52E1.10
+Y71H2AM.4	F52E1.10
+Y71H2AM.5	F52E1.10
+Y94H6A.8	F52E1.10
+ZC262.5	F52E1.10
+ZK637.8	F52E1.10
+ZK809.3	F52E1.10
+ZK970.4	F52E1.10
+ZK973.10	F52E1.10
+F54D8.2	F53F4.10
+F55H2.2	F53F4.10
+F57B10.14	F53F4.10
+F58F12.1	F53F4.10
+F59C6.5	F53F4.10
+H28O16.1	F53F4.10
+JC8.5	F53F4.10
+K04G7.4	F53F4.10
+K07A12.3	F53F4.10
+K09A9.5	F53F4.10
+R04F11.2	F53F4.10
+R05D3.6	F53F4.10
+R07E4.3	F53F4.10
+R10E11.2	F53F4.10
+R10E11.8	F53F4.10
+R53.4	F53F4.10
+T01H3.1	F53F4.10
+T02H6.11	F53F4.10
+T06D8.5	F53F4.10
+T07C4.7	F53F4.10
+T10B10.2	F53F4.10
+T10E9.7	F53F4.10
+T14F9.1	F53F4.10
+T20H4.5	F53F4.10
+T24C4.1	F53F4.10
+T26A5.3	F53F4.10
+T26E3.7	F53F4.10
+T27E9.2	F53F4.10
+VW02B12L.1	F53F4.10
+VW06B3R.1	F53F4.10
+W01A8.4	F53F4.10
+W09C5.8	F53F4.10
+W10D5.2	F53F4.10
+Y110A7A.12	F53F4.10
+Y37D8A.14	F53F4.10
+Y38F2AL.3	F53F4.10
+Y38F2AL.4	F53F4.10
+Y45G12B.1	F53F4.10
+Y46G5A.2	F53F4.10
+Y49A3A.2	F53F4.10
+Y51H1A.3	F53F4.10
+Y53G8AL.2	F53F4.10
+Y54E10BL.5	F53F4.10
+Y54F10AM.5	F53F4.10
+Y55H10A.1	F53F4.10
+Y56A3A.19	F53F4.10
+Y57G11C.12	F53F4.10
+Y63D3A.7	F53F4.10
+Y69A2AR.18	F53F4.10
+Y71H2AM.4	F53F4.10
+Y71H2AM.5	F53F4.10
+Y94H6A.8	F53F4.10
+ZC262.5	F53F4.10
+ZK637.8	F53F4.10
+ZK809.3	F53F4.10
+ZK970.4	F53F4.10
+ZK973.10	F53F4.10
+F55H2.2	F54D8.2
+F57B10.14	F54D8.2
+F58F12.1	F54D8.2
+F59C6.5	F54D8.2
+H28O16.1	F54D8.2
+JC8.5	F54D8.2
+K04G7.4	F54D8.2
+K07A12.3	F54D8.2
+K09A9.5	F54D8.2
+R04F11.2	F54D8.2
+R05D3.6	F54D8.2
+R07E4.3	F54D8.2
+R10E11.2	F54D8.2
+R10E11.8	F54D8.2
+R53.4	F54D8.2
+T01H3.1	F54D8.2
+T02H6.11	F54D8.2
+T06D8.5	F54D8.2
+T07C4.7	F54D8.2
+T10B10.2	F54D8.2
+T10E9.7	F54D8.2
+T14F9.1	F54D8.2
+T20H4.5	F54D8.2
+T24C4.1	F54D8.2
+T26A5.3	F54D8.2
+T26E3.7	F54D8.2
+T27E9.2	F54D8.2
+VW02B12L.1	F54D8.2
+VW06B3R.1	F54D8.2
+W01A8.4	F54D8.2
+W09C5.8	F54D8.2
+W10D5.2	F54D8.2
+Y110A7A.12	F54D8.2
+Y37D8A.14	F54D8.2
+Y38F2AL.3	F54D8.2
+Y38F2AL.4	F54D8.2
+Y45G12B.1	F54D8.2
+Y46G5A.2	F54D8.2
+Y49A3A.2	F54D8.2
+Y51H1A.3	F54D8.2
+Y53G8AL.2	F54D8.2
+Y54E10BL.5	F54D8.2
+Y54F10AM.5	F54D8.2
+Y55H10A.1	F54D8.2
+Y56A3A.19	F54D8.2
+Y57G11C.12	F54D8.2
+Y63D3A.7	F54D8.2
+Y69A2AR.18	F54D8.2
+Y71H2AM.4	F54D8.2
+Y71H2AM.5	F54D8.2
+Y94H6A.8	F54D8.2
+ZC262.5	F54D8.2
+ZK637.8	F54D8.2
+ZK809.3	F54D8.2
+ZK970.4	F54D8.2
+ZK973.10	F54D8.2
+F57B10.14	F55H2.2
+F58F12.1	F55H2.2
+F59C6.5	F55H2.2
+H28O16.1	F55H2.2
+JC8.5	F55H2.2
+K04G7.4	F55H2.2
+K07A12.3	F55H2.2
+K09A9.5	F55H2.2
+R04F11.2	F55H2.2
+R05D3.6	F55H2.2
+R07E4.3	F55H2.2
+R10E11.2	F55H2.2
+R10E11.8	F55H2.2
+R53.4	F55H2.2
+T01H3.1	F55H2.2
+T02H6.11	F55H2.2
+T06D8.5	F55H2.2
+T07C4.7	F55H2.2
+T10B10.2	F55H2.2
+T10E9.7	F55H2.2
+T14F9.1	F55H2.2
+T20H4.5	F55H2.2
+T24C4.1	F55H2.2
+T26A5.3	F55H2.2
+T26E3.7	F55H2.2
+T27E9.2	F55H2.2
+VW02B12L.1	F55H2.2
+VW06B3R.1	F55H2.2
+W01A8.4	F55H2.2
+W09C5.8	F55H2.2
+W10D5.2	F55H2.2
+Y110A7A.12	F55H2.2
+Y37D8A.14	F55H2.2
+Y38F2AL.3	F55H2.2
+Y38F2AL.4	F55H2.2
+Y45G12B.1	F55H2.2
+Y46G5A.2	F55H2.2
+Y49A3A.2	F55H2.2
+Y51H1A.3	F55H2.2
+Y53G8AL.2	F55H2.2
+Y54E10BL.5	F55H2.2
+Y54F10AM.5	F55H2.2
+Y55H10A.1	F55H2.2
+Y56A3A.19	F55H2.2
+Y57G11C.12	F55H2.2
+Y63D3A.7	F55H2.2
+Y69A2AR.18	F55H2.2
+Y71H2AM.4	F55H2.2
+Y71H2AM.5	F55H2.2
+Y94H6A.8	F55H2.2
+ZC262.5	F55H2.2
+ZK637.8	F55H2.2
+ZK809.3	F55H2.2
+ZK970.4	F55H2.2
+ZK973.10	F55H2.2
+F58F12.1	F57B10.14
+F59C6.5	F57B10.14
+H28O16.1	F57B10.14
+JC8.5	F57B10.14
+K04G7.4	F57B10.14
+K07A12.3	F57B10.14
+K09A9.5	F57B10.14
+R04F11.2	F57B10.14
+R05D3.6	F57B10.14
+R07E4.3	F57B10.14
+R10E11.2	F57B10.14
+R10E11.8	F57B10.14
+R53.4	F57B10.14
+T01H3.1	F57B10.14
+T02H6.11	F57B10.14
+T06D8.5	F57B10.14
+T07C4.7	F57B10.14
+T10B10.2	F57B10.14
+T10E9.7	F57B10.14
+T14F9.1	F57B10.14
+T20H4.5	F57B10.14
+T24C4.1	F57B10.14
+T26A5.3	F57B10.14
+T26E3.7	F57B10.14
+T27E9.2	F57B10.14
+VW02B12L.1	F57B10.14
+VW06B3R.1	F57B10.14
+W01A8.4	F57B10.14
+W09C5.8	F57B10.14
+W10D5.2	F57B10.14
+Y110A7A.12	F57B10.14
+Y37D8A.14	F57B10.14
+Y38F2AL.3	F57B10.14
+Y38F2AL.4	F57B10.14
+Y45G12B.1	F57B10.14
+Y46G5A.2	F57B10.14
+Y49A3A.2	F57B10.14
+Y51H1A.3	F57B10.14
+Y53G8AL.2	F57B10.14
+Y54E10BL.5	F57B10.14
+Y54F10AM.5	F57B10.14
+Y55H10A.1	F57B10.14
+Y56A3A.19	F57B10.14
+Y57G11C.12	F57B10.14
+Y63D3A.7	F57B10.14
+Y69A2AR.18	F57B10.14
+Y71H2AM.4	F57B10.14
+Y71H2AM.5	F57B10.14
+Y94H6A.8	F57B10.14
+ZC262.5	F57B10.14
+ZK637.8	F57B10.14
+ZK809.3	F57B10.14
+ZK970.4	F57B10.14
+ZK973.10	F57B10.14
+F59C6.5	F58F12.1
+H28O16.1	F58F12.1
+JC8.5	F58F12.1
+K04G7.4	F58F12.1
+K07A12.3	F58F12.1
+K09A9.5	F58F12.1
+R04F11.2	F58F12.1
+R05D3.6	F58F12.1
+R07E4.3	F58F12.1
+R10E11.2	F58F12.1
+R10E11.8	F58F12.1
+R53.4	F58F12.1
+T01H3.1	F58F12.1
+T02H6.11	F58F12.1
+T06D8.5	F58F12.1
+T07C4.7	F58F12.1
+T10B10.2	F58F12.1
+T10E9.7	F58F12.1
+T14F9.1	F58F12.1
+T20H4.5	F58F12.1
+T24C4.1	F58F12.1
+T26A5.3	F58F12.1
+T26E3.7	F58F12.1
+T27E9.2	F58F12.1
+VW02B12L.1	F58F12.1
+VW06B3R.1	F58F12.1
+W01A8.4	F58F12.1
+W09C5.8	F58F12.1
+W10D5.2	F58F12.1
+Y110A7A.12	F58F12.1
+Y37D8A.14	F58F12.1
+Y38F2AL.3	F58F12.1
+Y38F2AL.4	F58F12.1
+Y45G12B.1	F58F12.1
+Y46G5A.2	F58F12.1
+Y49A3A.2	F58F12.1
+Y51H1A.3	F58F12.1
+Y53G8AL.2	F58F12.1
+Y54E10BL.5	F58F12.1
+Y54F10AM.5	F58F12.1
+Y55H10A.1	F58F12.1
+Y56A3A.19	F58F12.1
+Y57G11C.12	F58F12.1
+Y63D3A.7	F58F12.1
+Y69A2AR.18	F58F12.1
+Y71H2AM.4	F58F12.1
+Y71H2AM.5	F58F12.1
+Y94H6A.8	F58F12.1
+ZC262.5	F58F12.1
+ZK637.8	F58F12.1
+ZK809.3	F58F12.1
+ZK970.4	F58F12.1
+ZK973.10	F58F12.1
+H28O16.1	F59C6.5
+JC8.5	F59C6.5
+K04G7.4	F59C6.5
+K07A12.3	F59C6.5
+K09A9.5	F59C6.5
+R04F11.2	F59C6.5
+R05D3.6	F59C6.5
+R07E4.3	F59C6.5
+R10E11.2	F59C6.5
+R10E11.8	F59C6.5
+R53.4	F59C6.5
+T01H3.1	F59C6.5
+T02H6.11	F59C6.5
+T06D8.5	F59C6.5
+T07C4.7	F59C6.5
+T10B10.2	F59C6.5
+T10E9.7	F59C6.5
+T14F9.1	F59C6.5
+T20H4.5	F59C6.5
+T24C4.1	F59C6.5
+T26A5.3	F59C6.5
+T26E3.7	F59C6.5
+T27E9.2	F59C6.5
+VW02B12L.1	F59C6.5
+VW06B3R.1	F59C6.5
+W01A8.4	F59C6.5
+W09C5.8	F59C6.5
+W10D5.2	F59C6.5
+Y110A7A.12	F59C6.5
+Y37D8A.14	F59C6.5
+Y38F2AL.3	F59C6.5
+Y38F2AL.4	F59C6.5
+Y45G12B.1	F59C6.5
+Y46G5A.2	F59C6.5
+Y49A3A.2	F59C6.5
+Y51H1A.3	F59C6.5
+Y53G8AL.2	F59C6.5
+Y54E10BL.5	F59C6.5
+Y54F10AM.5	F59C6.5
+Y55H10A.1	F59C6.5
+Y56A3A.19	F59C6.5
+Y57G11C.12	F59C6.5
+Y63D3A.7	F59C6.5
+Y69A2AR.18	F59C6.5
+Y71H2AM.4	F59C6.5
+Y71H2AM.5	F59C6.5
+Y94H6A.8	F59C6.5
+ZC262.5	F59C6.5
+ZK637.8	F59C6.5
+ZK809.3	F59C6.5
+ZK970.4	F59C6.5
+ZK973.10	F59C6.5
+JC8.5	H28O16.1
+K04G7.4	H28O16.1
+K07A12.3	H28O16.1
+K09A9.5	H28O16.1
+R04F11.2	H28O16.1
+R05D3.6	H28O16.1
+R07E4.3	H28O16.1
+R10E11.2	H28O16.1
+R10E11.8	H28O16.1
+R53.4	H28O16.1
+T01H3.1	H28O16.1
+T02H6.11	H28O16.1
+T06D8.5	H28O16.1
+T07C4.7	H28O16.1
+T10B10.2	H28O16.1
+T10E9.7	H28O16.1
+T14F9.1	H28O16.1
+T20H4.5	H28O16.1
+T24C4.1	H28O16.1
+T26A5.3	H28O16.1
+T26E3.7	H28O16.1
+T27E9.2	H28O16.1
+VW02B12L.1	H28O16.1
+VW06B3R.1	H28O16.1
+W01A8.4	H28O16.1
+W09C5.8	H28O16.1
+W10D5.2	H28O16.1
+Y110A7A.12	H28O16.1
+Y37D8A.14	H28O16.1
+Y38F2AL.3	H28O16.1
+Y38F2AL.4	H28O16.1
+Y45G12B.1	H28O16.1
+Y46G5A.2	H28O16.1
+Y49A3A.2	H28O16.1
+Y51H1A.3	H28O16.1
+Y53G8AL.2	H28O16.1
+Y54E10BL.5	H28O16.1
+Y54F10AM.5	H28O16.1
+Y55H10A.1	H28O16.1
+Y56A3A.19	H28O16.1
+Y57G11C.12	H28O16.1
+Y63D3A.7	H28O16.1
+Y69A2AR.18	H28O16.1
+Y71H2AM.4	H28O16.1
+Y71H2AM.5	H28O16.1
+Y94H6A.8	H28O16.1
+ZC262.5	H28O16.1
+ZK637.8	H28O16.1
+ZK809.3	H28O16.1
+ZK970.4	H28O16.1
+ZK973.10	H28O16.1
+K04G7.4	JC8.5
+K07A12.3	JC8.5
+K09A9.5	JC8.5
+R04F11.2	JC8.5
+R05D3.6	JC8.5
+R07E4.3	JC8.5
+R10E11.2	JC8.5
+R10E11.8	JC8.5
+R53.4	JC8.5
+T01H3.1	JC8.5
+T02H6.11	JC8.5
+T06D8.5	JC8.5
+T07C4.7	JC8.5
+T10B10.2	JC8.5
+T10E9.7	JC8.5
+T14F9.1	JC8.5
+T20H4.5	JC8.5
+T24C4.1	JC8.5
+T26A5.3	JC8.5
+T26E3.7	JC8.5
+T27E9.2	JC8.5
+VW02B12L.1	JC8.5
+VW06B3R.1	JC8.5
+W01A8.4	JC8.5
+W09C5.8	JC8.5
+W10D5.2	JC8.5
+Y110A7A.12	JC8.5
+Y37D8A.14	JC8.5
+Y38F2AL.3	JC8.5
+Y38F2AL.4	JC8.5
+Y45G12B.1	JC8.5
+Y46G5A.2	JC8.5
+Y49A3A.2	JC8.5
+Y51H1A.3	JC8.5
+Y53G8AL.2	JC8.5
+Y54E10BL.5	JC8.5
+Y54F10AM.5	JC8.5
+Y55H10A.1	JC8.5
+Y56A3A.19	JC8.5
+Y57G11C.12	JC8.5
+Y63D3A.7	JC8.5
+Y69A2AR.18	JC8.5
+Y71H2AM.4	JC8.5
+Y71H2AM.5	JC8.5
+Y94H6A.8	JC8.5
+ZC262.5	JC8.5
+ZK637.8	JC8.5
+ZK809.3	JC8.5
+ZK970.4	JC8.5
+ZK973.10	JC8.5
+K07A12.3	K04G7.4
+K09A9.5	K04G7.4
+R04F11.2	K04G7.4
+R05D3.6	K04G7.4
+R07E4.3	K04G7.4
+R10E11.2	K04G7.4
+R10E11.8	K04G7.4
+R53.4	K04G7.4
+T01H3.1	K04G7.4
+T02H6.11	K04G7.4
+T06D8.5	K04G7.4
+T07C4.7	K04G7.4
+T10B10.2	K04G7.4
+T10E9.7	K04G7.4
+T14F9.1	K04G7.4
+T20H4.5	K04G7.4
+T24C4.1	K04G7.4
+T26A5.3	K04G7.4
+T26E3.7	K04G7.4
+T27E9.2	K04G7.4
+VW02B12L.1	K04G7.4
+VW06B3R.1	K04G7.4
+W01A8.4	K04G7.4
+W09C5.8	K04G7.4
+W10D5.2	K04G7.4
+Y110A7A.12	K04G7.4
+Y37D8A.14	K04G7.4
+Y38F2AL.3	K04G7.4
+Y38F2AL.4	K04G7.4
+Y45G12B.1	K04G7.4
+Y46G5A.2	K04G7.4
+Y49A3A.2	K04G7.4
+Y51H1A.3	K04G7.4
+Y53G8AL.2	K04G7.4
+Y54E10BL.5	K04G7.4
+Y54F10AM.5	K04G7.4
+Y55H10A.1	K04G7.4
+Y56A3A.19	K04G7.4
+Y57G11C.12	K04G7.4
+Y63D3A.7	K04G7.4
+Y69A2AR.18	K04G7.4
+Y71H2AM.4	K04G7.4
+Y71H2AM.5	K04G7.4
+Y94H6A.8	K04G7.4
+ZC262.5	K04G7.4
+ZK637.8	K04G7.4
+ZK809.3	K04G7.4
+ZK970.4	K04G7.4
+ZK973.10	K04G7.4
+K09A9.5	K07A12.3
+R04F11.2	K07A12.3
+R05D3.6	K07A12.3
+R07E4.3	K07A12.3
+R10E11.2	K07A12.3
+R10E11.8	K07A12.3
+R53.4	K07A12.3
+T01H3.1	K07A12.3
+T02H6.11	K07A12.3
+T06D8.5	K07A12.3
+T07C4.7	K07A12.3
+T10B10.2	K07A12.3
+T10E9.7	K07A12.3
+T14F9.1	K07A12.3
+T20H4.5	K07A12.3
+T24C4.1	K07A12.3
+T26A5.3	K07A12.3
+T26E3.7	K07A12.3
+T27E9.2	K07A12.3
+VW02B12L.1	K07A12.3
+VW06B3R.1	K07A12.3
+W01A8.4	K07A12.3
+W09C5.8	K07A12.3
+W10D5.2	K07A12.3
+Y110A7A.12	K07A12.3
+Y37D8A.14	K07A12.3
+Y38F2AL.3	K07A12.3
+Y38F2AL.4	K07A12.3
+Y45G12B.1	K07A12.3
+Y46G5A.2	K07A12.3
+Y49A3A.2	K07A12.3
+Y51H1A.3	K07A12.3
+Y53G8AL.2	K07A12.3
+Y54E10BL.5	K07A12.3
+Y54F10AM.5	K07A12.3
+Y55H10A.1	K07A12.3
+Y56A3A.19	K07A12.3
+Y57G11C.12	K07A12.3
+Y63D3A.7	K07A12.3
+Y69A2AR.18	K07A12.3
+Y71H2AM.4	K07A12.3
+Y71H2AM.5	K07A12.3
+Y94H6A.8	K07A12.3
+ZC262.5	K07A12.3
+ZK637.8	K07A12.3
+ZK809.3	K07A12.3
+ZK970.4	K07A12.3
+ZK973.10	K07A12.3
+R04F11.2	K09A9.5
+R05D3.6	K09A9.5
+R07E4.3	K09A9.5
+R10E11.2	K09A9.5
+R10E11.8	K09A9.5
+R53.4	K09A9.5
+T01H3.1	K09A9.5
+T02H6.11	K09A9.5
+T06D8.5	K09A9.5
+T07C4.7	K09A9.5
+T10B10.2	K09A9.5
+T10E9.7	K09A9.5
+T14F9.1	K09A9.5
+T20H4.5	K09A9.5
+T24C4.1	K09A9.5
+T26A5.3	K09A9.5
+T26E3.7	K09A9.5
+T27E9.2	K09A9.5
+VW02B12L.1	K09A9.5
+VW06B3R.1	K09A9.5
+W01A8.4	K09A9.5
+W09C5.8	K09A9.5
+W10D5.2	K09A9.5
+Y110A7A.12	K09A9.5
+Y37D8A.14	K09A9.5
+Y38F2AL.3	K09A9.5
+Y38F2AL.4	K09A9.5
+Y45G12B.1	K09A9.5
+Y46G5A.2	K09A9.5
+Y49A3A.2	K09A9.5
+Y51H1A.3	K09A9.5
+Y53G8AL.2	K09A9.5
+Y54E10BL.5	K09A9.5
+Y54F10AM.5	K09A9.5
+Y55H10A.1	K09A9.5
+Y56A3A.19	K09A9.5
+Y57G11C.12	K09A9.5
+Y63D3A.7	K09A9.5
+Y69A2AR.18	K09A9.5
+Y71H2AM.4	K09A9.5
+Y71H2AM.5	K09A9.5
+Y94H6A.8	K09A9.5
+ZC262.5	K09A9.5
+ZK637.8	K09A9.5
+ZK809.3	K09A9.5
+ZK970.4	K09A9.5
+ZK973.10	K09A9.5
+R05D3.6	R04F11.2
+R07E4.3	R04F11.2
+R10E11.2	R04F11.2
+R10E11.8	R04F11.2
+R53.4	R04F11.2
+T01H3.1	R04F11.2
+T02H6.11	R04F11.2
+T06D8.5	R04F11.2
+T07C4.7	R04F11.2
+T10B10.2	R04F11.2
+T10E9.7	R04F11.2
+T14F9.1	R04F11.2
+T20H4.5	R04F11.2
+T24C4.1	R04F11.2
+T26A5.3	R04F11.2
+T26E3.7	R04F11.2
+T27E9.2	R04F11.2
+VW02B12L.1	R04F11.2
+VW06B3R.1	R04F11.2
+W01A8.4	R04F11.2
+W09C5.8	R04F11.2
+W10D5.2	R04F11.2
+Y110A7A.12	R04F11.2
+Y37D8A.14	R04F11.2
+Y38F2AL.3	R04F11.2
+Y38F2AL.4	R04F11.2
+Y45G12B.1	R04F11.2
+Y46G5A.2	R04F11.2
+Y49A3A.2	R04F11.2
+Y51H1A.3	R04F11.2
+Y53G8AL.2	R04F11.2
+Y54E10BL.5	R04F11.2
+Y54F10AM.5	R04F11.2
+Y55H10A.1	R04F11.2
+Y56A3A.19	R04F11.2
+Y57G11C.12	R04F11.2
+Y63D3A.7	R04F11.2
+Y69A2AR.18	R04F11.2
+Y71H2AM.4	R04F11.2
+Y71H2AM.5	R04F11.2
+Y94H6A.8	R04F11.2
+ZC262.5	R04F11.2
+ZK637.8	R04F11.2
+ZK809.3	R04F11.2
+ZK970.4	R04F11.2
+ZK973.10	R04F11.2
+R07E4.3	R05D3.6
+R10E11.2	R05D3.6
+R10E11.8	R05D3.6
+R53.4	R05D3.6
+T01H3.1	R05D3.6
+T02H6.11	R05D3.6
+T06D8.5	R05D3.6
+T07C4.7	R05D3.6
+T10B10.2	R05D3.6
+T10E9.7	R05D3.6
+T14F9.1	R05D3.6
+T20H4.5	R05D3.6
+T24C4.1	R05D3.6
+T26A5.3	R05D3.6
+T26E3.7	R05D3.6
+T27E9.2	R05D3.6
+VW02B12L.1	R05D3.6
+VW06B3R.1	R05D3.6
+W01A8.4	R05D3.6
+W09C5.8	R05D3.6
+W10D5.2	R05D3.6
+Y110A7A.12	R05D3.6
+Y37D8A.14	R05D3.6
+Y38F2AL.3	R05D3.6
+Y38F2AL.4	R05D3.6
+Y45G12B.1	R05D3.6
+Y46G5A.2	R05D3.6
+Y49A3A.2	R05D3.6
+Y51H1A.3	R05D3.6
+Y53G8AL.2	R05D3.6
+Y54E10BL.5	R05D3.6
+Y54F10AM.5	R05D3.6
+Y55H10A.1	R05D3.6
+Y56A3A.19	R05D3.6
+Y57G11C.12	R05D3.6
+Y63D3A.7	R05D3.6
+Y69A2AR.18	R05D3.6
+Y71H2AM.4	R05D3.6
+Y71H2AM.5	R05D3.6
+Y94H6A.8	R05D3.6
+ZC262.5	R05D3.6
+ZK637.8	R05D3.6
+ZK809.3	R05D3.6
+ZK970.4	R05D3.6
+ZK973.10	R05D3.6
+R10E11.2	R07E4.3
+R10E11.8	R07E4.3
+R53.4	R07E4.3
+T01H3.1	R07E4.3
+T02H6.11	R07E4.3
+T06D8.5	R07E4.3
+T07C4.7	R07E4.3
+T10B10.2	R07E4.3
+T10E9.7	R07E4.3
+T14F9.1	R07E4.3
+T20H4.5	R07E4.3
+T24C4.1	R07E4.3
+T26A5.3	R07E4.3
+T26E3.7	R07E4.3
+T27E9.2	R07E4.3
+VW02B12L.1	R07E4.3
+VW06B3R.1	R07E4.3
+W01A8.4	R07E4.3
+W09C5.8	R07E4.3
+W10D5.2	R07E4.3
+Y110A7A.12	R07E4.3
+Y37D8A.14	R07E4.3
+Y38F2AL.3	R07E4.3
+Y38F2AL.4	R07E4.3
+Y45G12B.1	R07E4.3
+Y46G5A.2	R07E4.3
+Y49A3A.2	R07E4.3
+Y51H1A.3	R07E4.3
+Y53G8AL.2	R07E4.3
+Y54E10BL.5	R07E4.3
+Y54F10AM.5	R07E4.3
+Y55H10A.1	R07E4.3
+Y56A3A.19	R07E4.3
+Y57G11C.12	R07E4.3
+Y63D3A.7	R07E4.3
+Y69A2AR.18	R07E4.3
+Y71H2AM.4	R07E4.3
+Y71H2AM.5	R07E4.3
+Y94H6A.8	R07E4.3
+ZC262.5	R07E4.3
+ZK637.8	R07E4.3
+ZK809.3	R07E4.3
+ZK970.4	R07E4.3
+ZK973.10	R07E4.3
+R10E11.8	R10E11.2
+R53.4	R10E11.2
+T01H3.1	R10E11.2
+T02H6.11	R10E11.2
+T06D8.5	R10E11.2
+T07C4.7	R10E11.2
+T10B10.2	R10E11.2
+T10E9.7	R10E11.2
+T14F9.1	R10E11.2
+T20H4.5	R10E11.2
+T24C4.1	R10E11.2
+T26A5.3	R10E11.2
+T26E3.7	R10E11.2
+T27E9.2	R10E11.2
+VW02B12L.1	R10E11.2
+VW06B3R.1	R10E11.2
+W01A8.4	R10E11.2
+W09C5.8	R10E11.2
+W10D5.2	R10E11.2
+Y110A7A.12	R10E11.2
+Y37D8A.14	R10E11.2
+Y38F2AL.3	R10E11.2
+Y38F2AL.4	R10E11.2
+Y45G12B.1	R10E11.2
+Y46G5A.2	R10E11.2
+Y49A3A.2	R10E11.2
+Y51H1A.3	R10E11.2
+Y53G8AL.2	R10E11.2
+Y54E10BL.5	R10E11.2
+Y54F10AM.5	R10E11.2
+Y55H10A.1	R10E11.2
+Y56A3A.19	R10E11.2
+Y57G11C.12	R10E11.2
+Y63D3A.7	R10E11.2
+Y69A2AR.18	R10E11.2
+Y71H2AM.4	R10E11.2
+Y71H2AM.5	R10E11.2
+Y94H6A.8	R10E11.2
+ZC262.5	R10E11.2
+ZK637.8	R10E11.2
+ZK809.3	R10E11.2
+ZK970.4	R10E11.2
+ZK973.10	R10E11.2
+R53.4	R10E11.8
+T01H3.1	R10E11.8
+T02H6.11	R10E11.8
+T06D8.5	R10E11.8
+T07C4.7	R10E11.8
+T10B10.2	R10E11.8
+T10E9.7	R10E11.8
+T14F9.1	R10E11.8
+T20H4.5	R10E11.8
+T24C4.1	R10E11.8
+T26A5.3	R10E11.8
+T26E3.7	R10E11.8
+T27E9.2	R10E11.8
+VW02B12L.1	R10E11.8
+VW06B3R.1	R10E11.8
+W01A8.4	R10E11.8
+W09C5.8	R10E11.8
+W10D5.2	R10E11.8
+Y110A7A.12	R10E11.8
+Y37D8A.14	R10E11.8
+Y38F2AL.3	R10E11.8
+Y38F2AL.4	R10E11.8
+Y45G12B.1	R10E11.8
+Y46G5A.2	R10E11.8
+Y49A3A.2	R10E11.8
+Y51H1A.3	R10E11.8
+Y53G8AL.2	R10E11.8
+Y54E10BL.5	R10E11.8
+Y54F10AM.5	R10E11.8
+Y55H10A.1	R10E11.8
+Y56A3A.19	R10E11.8
+Y57G11C.12	R10E11.8
+Y63D3A.7	R10E11.8
+Y69A2AR.18	R10E11.8
+Y71H2AM.4	R10E11.8
+Y71H2AM.5	R10E11.8
+Y94H6A.8	R10E11.8
+ZC262.5	R10E11.8
+ZK637.8	R10E11.8
+ZK809.3	R10E11.8
+ZK970.4	R10E11.8
+ZK973.10	R10E11.8
+T01H3.1	R53.4
+T02H6.11	R53.4
+T06D8.5	R53.4
+T07C4.7	R53.4
+T10B10.2	R53.4
+T10E9.7	R53.4
+T14F9.1	R53.4
+T20H4.5	R53.4
+T24C4.1	R53.4
+T26A5.3	R53.4
+T26E3.7	R53.4
+T27E9.2	R53.4
+VW02B12L.1	R53.4
+VW06B3R.1	R53.4
+W01A8.4	R53.4
+W09C5.8	R53.4
+W10D5.2	R53.4
+Y110A7A.12	R53.4
+Y37D8A.14	R53.4
+Y38F2AL.3	R53.4
+Y38F2AL.4	R53.4
+Y45G12B.1	R53.4
+Y46G5A.2	R53.4
+Y49A3A.2	R53.4
+Y51H1A.3	R53.4
+Y53G8AL.2	R53.4
+Y54E10BL.5	R53.4
+Y54F10AM.5	R53.4
+Y55H10A.1	R53.4
+Y56A3A.19	R53.4
+Y57G11C.12	R53.4
+Y63D3A.7	R53.4
+Y69A2AR.18	R53.4
+Y71H2AM.4	R53.4
+Y71H2AM.5	R53.4
+Y94H6A.8	R53.4
+ZC262.5	R53.4
+ZK637.8	R53.4
+ZK809.3	R53.4
+ZK970.4	R53.4
+ZK973.10	R53.4
+T02H6.11	T01H3.1
+T06D8.5	T01H3.1
+T07C4.7	T01H3.1
+T10B10.2	T01H3.1
+T10E9.7	T01H3.1
+T14F9.1	T01H3.1
+T20H4.5	T01H3.1
+T24C4.1	T01H3.1
+T26A5.3	T01H3.1
+T26E3.7	T01H3.1
+T27E9.2	T01H3.1
+VW02B12L.1	T01H3.1
+VW06B3R.1	T01H3.1
+W01A8.4	T01H3.1
+W09C5.8	T01H3.1
+W10D5.2	T01H3.1
+Y110A7A.12	T01H3.1
+Y37D8A.14	T01H3.1
+Y38F2AL.3	T01H3.1
+Y38F2AL.4	T01H3.1
+Y45G12B.1	T01H3.1
+Y46G5A.2	T01H3.1
+Y49A3A.2	T01H3.1
+Y51H1A.3	T01H3.1
+Y53G8AL.2	T01H3.1
+Y54E10BL.5	T01H3.1
+Y54F10AM.5	T01H3.1
+Y55H10A.1	T01H3.1
+Y56A3A.19	T01H3.1
+Y57G11C.12	T01H3.1
+Y63D3A.7	T01H3.1
+Y69A2AR.18	T01H3.1
+Y71H2AM.4	T01H3.1
+Y71H2AM.5	T01H3.1
+Y94H6A.8	T01H3.1
+ZC262.5	T01H3.1
+ZK637.8	T01H3.1
+ZK809.3	T01H3.1
+ZK970.4	T01H3.1
+ZK973.10	T01H3.1
+T06D8.5	T02H6.11
+T07C4.7	T02H6.11
+T10B10.2	T02H6.11
+T10E9.7	T02H6.11
+T14F9.1	T02H6.11
+T20H4.5	T02H6.11
+T24C4.1	T02H6.11
+T26A5.3	T02H6.11
+T26E3.7	T02H6.11
+T27E9.2	T02H6.11
+VW02B12L.1	T02H6.11
+VW06B3R.1	T02H6.11
+W01A8.4	T02H6.11
+W09C5.8	T02H6.11
+W10D5.2	T02H6.11
+Y110A7A.12	T02H6.11
+Y37D8A.14	T02H6.11
+Y38F2AL.3	T02H6.11
+Y38F2AL.4	T02H6.11
+Y45G12B.1	T02H6.11
+Y46G5A.2	T02H6.11
+Y49A3A.2	T02H6.11
+Y51H1A.3	T02H6.11
+Y53G8AL.2	T02H6.11
+Y54E10BL.5	T02H6.11
+Y54F10AM.5	T02H6.11
+Y55H10A.1	T02H6.11
+Y56A3A.19	T02H6.11
+Y57G11C.12	T02H6.11
+Y63D3A.7	T02H6.11
+Y69A2AR.18	T02H6.11
+Y71H2AM.4	T02H6.11
+Y71H2AM.5	T02H6.11
+Y94H6A.8	T02H6.11
+ZC262.5	T02H6.11
+ZK637.8	T02H6.11
+ZK809.3	T02H6.11
+ZK970.4	T02H6.11
+ZK973.10	T02H6.11
+T07C4.7	T06D8.5
+T10B10.2	T06D8.5
+T10E9.7	T06D8.5
+T14F9.1	T06D8.5
+T20H4.5	T06D8.5
+T24C4.1	T06D8.5
+T26A5.3	T06D8.5
+T26E3.7	T06D8.5
+T27E9.2	T06D8.5
+VW02B12L.1	T06D8.5
+VW06B3R.1	T06D8.5
+W01A8.4	T06D8.5
+W09C5.8	T06D8.5
+W10D5.2	T06D8.5
+Y110A7A.12	T06D8.5
+Y37D8A.14	T06D8.5
+Y38F2AL.3	T06D8.5
+Y38F2AL.4	T06D8.5
+Y45G12B.1	T06D8.5
+Y46G5A.2	T06D8.5
+Y49A3A.2	T06D8.5
+Y51H1A.3	T06D8.5
+Y53G8AL.2	T06D8.5
+Y54E10BL.5	T06D8.5
+Y54F10AM.5	T06D8.5
+Y55H10A.1	T06D8.5
+Y56A3A.19	T06D8.5
+Y57G11C.12	T06D8.5
+Y63D3A.7	T06D8.5
+Y69A2AR.18	T06D8.5
+Y71H2AM.4	T06D8.5
+Y71H2AM.5	T06D8.5
+Y94H6A.8	T06D8.5
+ZC262.5	T06D8.5
+ZK637.8	T06D8.5
+ZK809.3	T06D8.5
+ZK970.4	T06D8.5
+ZK973.10	T06D8.5
+T10B10.2	T07C4.7
+T10E9.7	T07C4.7
+T14F9.1	T07C4.7
+T20H4.5	T07C4.7
+T24C4.1	T07C4.7
+T26A5.3	T07C4.7
+T26E3.7	T07C4.7
+T27E9.2	T07C4.7
+VW02B12L.1	T07C4.7
+VW06B3R.1	T07C4.7
+W01A8.4	T07C4.7
+W09C5.8	T07C4.7
+W10D5.2	T07C4.7
+Y110A7A.12	T07C4.7
+Y37D8A.14	T07C4.7
+Y38F2AL.3	T07C4.7
+Y38F2AL.4	T07C4.7
+Y45G12B.1	T07C4.7
+Y46G5A.2	T07C4.7
+Y49A3A.2	T07C4.7
+Y51H1A.3	T07C4.7
+Y53G8AL.2	T07C4.7
+Y54E10BL.5	T07C4.7
+Y54F10AM.5	T07C4.7
+Y55H10A.1	T07C4.7
+Y56A3A.19	T07C4.7
+Y57G11C.12	T07C4.7
+Y63D3A.7	T07C4.7
+Y69A2AR.18	T07C4.7
+Y71H2AM.4	T07C4.7
+Y71H2AM.5	T07C4.7
+Y94H6A.8	T07C4.7
+ZC262.5	T07C4.7
+ZK637.8	T07C4.7
+ZK809.3	T07C4.7
+ZK970.4	T07C4.7
+ZK973.10	T07C4.7
+T10E9.7	T10B10.2
+T14F9.1	T10B10.2
+T20H4.5	T10B10.2
+T24C4.1	T10B10.2
+T26A5.3	T10B10.2
+T26E3.7	T10B10.2
+T27E9.2	T10B10.2
+VW02B12L.1	T10B10.2
+VW06B3R.1	T10B10.2
+W01A8.4	T10B10.2
+W09C5.8	T10B10.2
+W10D5.2	T10B10.2
+Y110A7A.12	T10B10.2
+Y37D8A.14	T10B10.2
+Y38F2AL.3	T10B10.2
+Y38F2AL.4	T10B10.2
+Y45G12B.1	T10B10.2
+Y46G5A.2	T10B10.2
+Y49A3A.2	T10B10.2
+Y51H1A.3	T10B10.2
+Y53G8AL.2	T10B10.2
+Y54E10BL.5	T10B10.2
+Y54F10AM.5	T10B10.2
+Y55H10A.1	T10B10.2
+Y56A3A.19	T10B10.2
+Y57G11C.12	T10B10.2
+Y63D3A.7	T10B10.2
+Y69A2AR.18	T10B10.2
+Y71H2AM.4	T10B10.2
+Y71H2AM.5	T10B10.2
+Y94H6A.8	T10B10.2
+ZC262.5	T10B10.2
+ZK637.8	T10B10.2
+ZK809.3	T10B10.2
+ZK970.4	T10B10.2
+ZK973.10	T10B10.2
+T14F9.1	T10E9.7
+T20H4.5	T10E9.7
+T24C4.1	T10E9.7
+T26A5.3	T10E9.7
+T26E3.7	T10E9.7
+T27E9.2	T10E9.7
+VW02B12L.1	T10E9.7
+VW06B3R.1	T10E9.7
+W01A8.4	T10E9.7
+W09C5.8	T10E9.7
+W10D5.2	T10E9.7
+Y110A7A.12	T10E9.7
+Y37D8A.14	T10E9.7
+Y38F2AL.3	T10E9.7
+Y38F2AL.4	T10E9.7
+Y45G12B.1	T10E9.7
+Y46G5A.2	T10E9.7
+Y49A3A.2	T10E9.7
+Y51H1A.3	T10E9.7
+Y53G8AL.2	T10E9.7
+Y54E10BL.5	T10E9.7
+Y54F10AM.5	T10E9.7
+Y55H10A.1	T10E9.7
+Y56A3A.19	T10E9.7
+Y57G11C.12	T10E9.7
+Y63D3A.7	T10E9.7
+Y69A2AR.18	T10E9.7
+Y71H2AM.4	T10E9.7
+Y71H2AM.5	T10E9.7
+Y94H6A.8	T10E9.7
+ZC262.5	T10E9.7
+ZK637.8	T10E9.7
+ZK809.3	T10E9.7
+ZK970.4	T10E9.7
+ZK973.10	T10E9.7
+T20H4.5	T14F9.1
+T24C4.1	T14F9.1
+T26A5.3	T14F9.1
+T26E3.7	T14F9.1
+T27E9.2	T14F9.1
+VW02B12L.1	T14F9.1
+VW06B3R.1	T14F9.1
+W01A8.4	T14F9.1
+W09C5.8	T14F9.1
+W10D5.2	T14F9.1
+Y110A7A.12	T14F9.1
+Y37D8A.14	T14F9.1
+Y38F2AL.3	T14F9.1
+Y38F2AL.4	T14F9.1
+Y45G12B.1	T14F9.1
+Y46G5A.2	T14F9.1
+Y49A3A.2	T14F9.1
+Y51H1A.3	T14F9.1
+Y53G8AL.2	T14F9.1
+Y54E10BL.5	T14F9.1
+Y54F10AM.5	T14F9.1
+Y55H10A.1	T14F9.1
+Y56A3A.19	T14F9.1
+Y57G11C.12	T14F9.1
+Y63D3A.7	T14F9.1
+Y69A2AR.18	T14F9.1
+Y71H2AM.4	T14F9.1
+Y71H2AM.5	T14F9.1
+Y94H6A.8	T14F9.1
+ZC262.5	T14F9.1
+ZK637.8	T14F9.1
+ZK809.3	T14F9.1
+ZK970.4	T14F9.1
+ZK973.10	T14F9.1
+T24C4.1	T20H4.5
+T26A5.3	T20H4.5
+T26E3.7	T20H4.5
+T27E9.2	T20H4.5
+VW02B12L.1	T20H4.5
+VW06B3R.1	T20H4.5
+W01A8.4	T20H4.5
+W09C5.8	T20H4.5
+W10D5.2	T20H4.5
+Y110A7A.12	T20H4.5
+Y37D8A.14	T20H4.5
+Y38F2AL.3	T20H4.5
+Y38F2AL.4	T20H4.5
+Y45G12B.1	T20H4.5
+Y46G5A.2	T20H4.5
+Y49A3A.2	T20H4.5
+Y51H1A.3	T20H4.5
+Y53G8AL.2	T20H4.5
+Y54E10BL.5	T20H4.5
+Y54F10AM.5	T20H4.5
+Y55H10A.1	T20H4.5
+Y56A3A.19	T20H4.5
+Y57G11C.12	T20H4.5
+Y63D3A.7	T20H4.5
+Y69A2AR.18	T20H4.5
+Y71H2AM.4	T20H4.5
+Y71H2AM.5	T20H4.5
+Y94H6A.8	T20H4.5
+ZC262.5	T20H4.5
+ZK637.8	T20H4.5
+ZK809.3	T20H4.5
+ZK970.4	T20H4.5
+ZK973.10	T20H4.5
+T26A5.3	T24C4.1
+T26E3.7	T24C4.1
+T27E9.2	T24C4.1
+VW02B12L.1	T24C4.1
+VW06B3R.1	T24C4.1
+W01A8.4	T24C4.1
+W09C5.8	T24C4.1
+W10D5.2	T24C4.1
+Y110A7A.12	T24C4.1
+Y37D8A.14	T24C4.1
+Y38F2AL.3	T24C4.1
+Y38F2AL.4	T24C4.1
+Y45G12B.1	T24C4.1
+Y46G5A.2	T24C4.1
+Y49A3A.2	T24C4.1
+Y51H1A.3	T24C4.1
+Y53G8AL.2	T24C4.1
+Y54E10BL.5	T24C4.1
+Y54F10AM.5	T24C4.1
+Y55H10A.1	T24C4.1
+Y56A3A.19	T24C4.1
+Y57G11C.12	T24C4.1
+Y63D3A.7	T24C4.1
+Y69A2AR.18	T24C4.1
+Y71H2AM.4	T24C4.1
+Y71H2AM.5	T24C4.1
+Y94H6A.8	T24C4.1
+ZC262.5	T24C4.1
+ZK637.8	T24C4.1
+ZK809.3	T24C4.1
+ZK970.4	T24C4.1
+ZK973.10	T24C4.1
+T26E3.7	T26A5.3
+T27E9.2	T26A5.3
+VW02B12L.1	T26A5.3
+VW06B3R.1	T26A5.3
+W01A8.4	T26A5.3
+W09C5.8	T26A5.3
+W10D5.2	T26A5.3
+Y110A7A.12	T26A5.3
+Y37D8A.14	T26A5.3
+Y38F2AL.3	T26A5.3
+Y38F2AL.4	T26A5.3
+Y45G12B.1	T26A5.3
+Y46G5A.2	T26A5.3
+Y49A3A.2	T26A5.3
+Y51H1A.3	T26A5.3
+Y53G8AL.2	T26A5.3
+Y54E10BL.5	T26A5.3
+Y54F10AM.5	T26A5.3
+Y55H10A.1	T26A5.3
+Y56A3A.19	T26A5.3
+Y57G11C.12	T26A5.3
+Y63D3A.7	T26A5.3
+Y69A2AR.18	T26A5.3
+Y71H2AM.4	T26A5.3
+Y71H2AM.5	T26A5.3
+Y94H6A.8	T26A5.3
+ZC262.5	T26A5.3
+ZK637.8	T26A5.3
+ZK809.3	T26A5.3
+ZK970.4	T26A5.3
+ZK973.10	T26A5.3
+T27E9.2	T26E3.7
+VW02B12L.1	T26E3.7
+VW06B3R.1	T26E3.7
+W01A8.4	T26E3.7
+W09C5.8	T26E3.7
+W10D5.2	T26E3.7
+Y110A7A.12	T26E3.7
+Y37D8A.14	T26E3.7
+Y38F2AL.3	T26E3.7
+Y38F2AL.4	T26E3.7
+Y45G12B.1	T26E3.7
+Y46G5A.2	T26E3.7
+Y49A3A.2	T26E3.7
+Y51H1A.3	T26E3.7
+Y53G8AL.2	T26E3.7
+Y54E10BL.5	T26E3.7
+Y54F10AM.5	T26E3.7
+Y55H10A.1	T26E3.7
+Y56A3A.19	T26E3.7
+Y57G11C.12	T26E3.7
+Y63D3A.7	T26E3.7
+Y69A2AR.18	T26E3.7
+Y71H2AM.4	T26E3.7
+Y71H2AM.5	T26E3.7
+Y94H6A.8	T26E3.7
+ZC262.5	T26E3.7
+ZK637.8	T26E3.7
+ZK809.3	T26E3.7
+ZK970.4	T26E3.7
+ZK973.10	T26E3.7
+VW02B12L.1	T27E9.2
+VW06B3R.1	T27E9.2
+W01A8.4	T27E9.2
+W09C5.8	T27E9.2
+W10D5.2	T27E9.2
+Y110A7A.12	T27E9.2
+Y37D8A.14	T27E9.2
+Y38F2AL.3	T27E9.2
+Y38F2AL.4	T27E9.2
+Y45G12B.1	T27E9.2
+Y46G5A.2	T27E9.2
+Y49A3A.2	T27E9.2
+Y51H1A.3	T27E9.2
+Y53G8AL.2	T27E9.2
+Y54E10BL.5	T27E9.2
+Y54F10AM.5	T27E9.2
+Y55H10A.1	T27E9.2
+Y56A3A.19	T27E9.2
+Y57G11C.12	T27E9.2
+Y63D3A.7	T27E9.2
+Y69A2AR.18	T27E9.2
+Y71H2AM.4	T27E9.2
+Y71H2AM.5	T27E9.2
+Y94H6A.8	T27E9.2
+ZC262.5	T27E9.2
+ZK637.8	T27E9.2
+ZK809.3	T27E9.2
+ZK970.4	T27E9.2
+ZK973.10	T27E9.2
+VW06B3R.1	VW02B12L.1
+W01A8.4	VW02B12L.1
+W09C5.8	VW02B12L.1
+W10D5.2	VW02B12L.1
+Y110A7A.12	VW02B12L.1
+Y37D8A.14	VW02B12L.1
+Y38F2AL.3	VW02B12L.1
+Y38F2AL.4	VW02B12L.1
+Y45G12B.1	VW02B12L.1
+Y46G5A.2	VW02B12L.1
+Y49A3A.2	VW02B12L.1
+Y51H1A.3	VW02B12L.1
+Y53G8AL.2	VW02B12L.1
+Y54E10BL.5	VW02B12L.1
+Y54F10AM.5	VW02B12L.1
+Y55H10A.1	VW02B12L.1
+Y56A3A.19	VW02B12L.1
+Y57G11C.12	VW02B12L.1
+Y63D3A.7	VW02B12L.1
+Y69A2AR.18	VW02B12L.1
+Y71H2AM.4	VW02B12L.1
+Y71H2AM.5	VW02B12L.1
+Y94H6A.8	VW02B12L.1
+ZC262.5	VW02B12L.1
+ZK637.8	VW02B12L.1
+ZK809.3	VW02B12L.1
+ZK970.4	VW02B12L.1
+ZK973.10	VW02B12L.1
+W01A8.4	VW06B3R.1
+W09C5.8	VW06B3R.1
+W10D5.2	VW06B3R.1
+Y110A7A.12	VW06B3R.1
+Y37D8A.14	VW06B3R.1
+Y38F2AL.3	VW06B3R.1
+Y38F2AL.4	VW06B3R.1
+Y45G12B.1	VW06B3R.1
+Y46G5A.2	VW06B3R.1
+Y49A3A.2	VW06B3R.1
+Y51H1A.3	VW06B3R.1
+Y53G8AL.2	VW06B3R.1
+Y54E10BL.5	VW06B3R.1
+Y54F10AM.5	VW06B3R.1
+Y55H10A.1	VW06B3R.1
+Y56A3A.19	VW06B3R.1
+Y57G11C.12	VW06B3R.1
+Y63D3A.7	VW06B3R.1
+Y69A2AR.18	VW06B3R.1
+Y71H2AM.4	VW06B3R.1
+Y71H2AM.5	VW06B3R.1
+Y94H6A.8	VW06B3R.1
+ZC262.5	VW06B3R.1
+ZK637.8	VW06B3R.1
+ZK809.3	VW06B3R.1
+ZK970.4	VW06B3R.1
+ZK973.10	VW06B3R.1
+W09C5.8	W01A8.4
+W10D5.2	W01A8.4
+Y110A7A.12	W01A8.4
+Y37D8A.14	W01A8.4
+Y38F2AL.3	W01A8.4
+Y38F2AL.4	W01A8.4
+Y45G12B.1	W01A8.4
+Y46G5A.2	W01A8.4
+Y49A3A.2	W01A8.4
+Y51H1A.3	W01A8.4
+Y53G8AL.2	W01A8.4
+Y54E10BL.5	W01A8.4
+Y54F10AM.5	W01A8.4
+Y55H10A.1	W01A8.4
+Y56A3A.19	W01A8.4
+Y57G11C.12	W01A8.4
+Y63D3A.7	W01A8.4
+Y69A2AR.18	W01A8.4
+Y71H2AM.4	W01A8.4
+Y71H2AM.5	W01A8.4
+Y94H6A.8	W01A8.4
+ZC262.5	W01A8.4
+ZK637.8	W01A8.4
+ZK809.3	W01A8.4
+ZK970.4	W01A8.4
+ZK973.10	W01A8.4
+W10D5.2	W09C5.8
+Y110A7A.12	W09C5.8
+Y37D8A.14	W09C5.8
+Y38F2AL.3	W09C5.8
+Y38F2AL.4	W09C5.8
+Y45G12B.1	W09C5.8
+Y46G5A.2	W09C5.8
+Y49A3A.2	W09C5.8
+Y51H1A.3	W09C5.8
+Y53G8AL.2	W09C5.8
+Y54E10BL.5	W09C5.8
+Y54F10AM.5	W09C5.8
+Y55H10A.1	W09C5.8
+Y56A3A.19	W09C5.8
+Y57G11C.12	W09C5.8
+Y63D3A.7	W09C5.8
+Y69A2AR.18	W09C5.8
+Y71H2AM.4	W09C5.8
+Y71H2AM.5	W09C5.8
+Y94H6A.8	W09C5.8
+ZC262.5	W09C5.8
+ZK637.8	W09C5.8
+ZK809.3	W09C5.8
+ZK970.4	W09C5.8
+ZK973.10	W09C5.8
+Y110A7A.12	W10D5.2
+Y37D8A.14	W10D5.2
+Y38F2AL.3	W10D5.2
+Y38F2AL.4	W10D5.2
+Y45G12B.1	W10D5.2
+Y46G5A.2	W10D5.2
+Y49A3A.2	W10D5.2
+Y51H1A.3	W10D5.2
+Y53G8AL.2	W10D5.2
+Y54E10BL.5	W10D5.2
+Y54F10AM.5	W10D5.2
+Y55H10A.1	W10D5.2
+Y56A3A.19	W10D5.2
+Y57G11C.12	W10D5.2
+Y63D3A.7	W10D5.2
+Y69A2AR.18	W10D5.2
+Y71H2AM.4	W10D5.2
+Y71H2AM.5	W10D5.2
+Y94H6A.8	W10D5.2
+ZC262.5	W10D5.2
+ZK637.8	W10D5.2
+ZK809.3	W10D5.2
+ZK970.4	W10D5.2
+ZK973.10	W10D5.2
+Y37D8A.14	Y110A7A.12
+Y38F2AL.3	Y110A7A.12
+Y38F2AL.4	Y110A7A.12
+Y45G12B.1	Y110A7A.12
+Y46G5A.2	Y110A7A.12
+Y49A3A.2	Y110A7A.12
+Y51H1A.3	Y110A7A.12
+Y53G8AL.2	Y110A7A.12
+Y54E10BL.5	Y110A7A.12
+Y54F10AM.5	Y110A7A.12
+Y55H10A.1	Y110A7A.12
+Y56A3A.19	Y110A7A.12
+Y57G11C.12	Y110A7A.12
+Y63D3A.7	Y110A7A.12
+Y69A2AR.18	Y110A7A.12
+Y71H2AM.4	Y110A7A.12
+Y71H2AM.5	Y110A7A.12
+Y94H6A.8	Y110A7A.12
+ZC262.5	Y110A7A.12
+ZK637.8	Y110A7A.12
+ZK809.3	Y110A7A.12
+ZK970.4	Y110A7A.12
+ZK973.10	Y110A7A.12
+Y38F2AL.3	Y37D8A.14
+Y38F2AL.4	Y37D8A.14
+Y45G12B.1	Y37D8A.14
+Y46G5A.2	Y37D8A.14
+Y49A3A.2	Y37D8A.14
+Y51H1A.3	Y37D8A.14
+Y53G8AL.2	Y37D8A.14
+Y54E10BL.5	Y37D8A.14
+Y54F10AM.5	Y37D8A.14
+Y55H10A.1	Y37D8A.14
+Y56A3A.19	Y37D8A.14
+Y57G11C.12	Y37D8A.14
+Y63D3A.7	Y37D8A.14
+Y69A2AR.18	Y37D8A.14
+Y71H2AM.4	Y37D8A.14
+Y71H2AM.5	Y37D8A.14
+Y94H6A.8	Y37D8A.14
+ZC262.5	Y37D8A.14
+ZK637.8	Y37D8A.14
+ZK809.3	Y37D8A.14
+ZK970.4	Y37D8A.14
+ZK973.10	Y37D8A.14
+Y38F2AL.4	Y38F2AL.3
+Y45G12B.1	Y38F2AL.3
+Y46G5A.2	Y38F2AL.3
+Y49A3A.2	Y38F2AL.3
+Y51H1A.3	Y38F2AL.3
+Y53G8AL.2	Y38F2AL.3
+Y54E10BL.5	Y38F2AL.3
+Y54F10AM.5	Y38F2AL.3
+Y55H10A.1	Y38F2AL.3
+Y56A3A.19	Y38F2AL.3
+Y57G11C.12	Y38F2AL.3
+Y63D3A.7	Y38F2AL.3
+Y69A2AR.18	Y38F2AL.3
+Y71H2AM.4	Y38F2AL.3
+Y71H2AM.5	Y38F2AL.3
+Y94H6A.8	Y38F2AL.3
+ZC262.5	Y38F2AL.3
+ZK637.8	Y38F2AL.3
+ZK809.3	Y38F2AL.3
+ZK970.4	Y38F2AL.3
+ZK973.10	Y38F2AL.3
+Y45G12B.1	Y38F2AL.4
+Y46G5A.2	Y38F2AL.4
+Y49A3A.2	Y38F2AL.4
+Y51H1A.3	Y38F2AL.4
+Y53G8AL.2	Y38F2AL.4
+Y54E10BL.5	Y38F2AL.4
+Y54F10AM.5	Y38F2AL.4
+Y55H10A.1	Y38F2AL.4
+Y56A3A.19	Y38F2AL.4
+Y57G11C.12	Y38F2AL.4
+Y63D3A.7	Y38F2AL.4
+Y69A2AR.18	Y38F2AL.4
+Y71H2AM.4	Y38F2AL.4
+Y71H2AM.5	Y38F2AL.4
+Y94H6A.8	Y38F2AL.4
+ZC262.5	Y38F2AL.4
+ZK637.8	Y38F2AL.4
+ZK809.3	Y38F2AL.4
+ZK970.4	Y38F2AL.4
+ZK973.10	Y38F2AL.4
+Y46G5A.2	Y45G12B.1
+Y49A3A.2	Y45G12B.1
+Y51H1A.3	Y45G12B.1
+Y53G8AL.2	Y45G12B.1
+Y54E10BL.5	Y45G12B.1
+Y54F10AM.5	Y45G12B.1
+Y55H10A.1	Y45G12B.1
+Y56A3A.19	Y45G12B.1
+Y57G11C.12	Y45G12B.1
+Y63D3A.7	Y45G12B.1
+Y69A2AR.18	Y45G12B.1
+Y71H2AM.4	Y45G12B.1
+Y71H2AM.5	Y45G12B.1
+Y94H6A.8	Y45G12B.1
+ZC262.5	Y45G12B.1
+ZK637.8	Y45G12B.1
+ZK809.3	Y45G12B.1
+ZK970.4	Y45G12B.1
+ZK973.10	Y45G12B.1
+Y49A3A.2	Y46G5A.2
+Y51H1A.3	Y46G5A.2
+Y53G8AL.2	Y46G5A.2
+Y54E10BL.5	Y46G5A.2
+Y54F10AM.5	Y46G5A.2
+Y55H10A.1	Y46G5A.2
+Y56A3A.19	Y46G5A.2
+Y57G11C.12	Y46G5A.2
+Y63D3A.7	Y46G5A.2
+Y69A2AR.18	Y46G5A.2
+Y71H2AM.4	Y46G5A.2
+Y71H2AM.5	Y46G5A.2
+Y94H6A.8	Y46G5A.2
+ZC262.5	Y46G5A.2
+ZK637.8	Y46G5A.2
+ZK809.3	Y46G5A.2
+ZK970.4	Y46G5A.2
+ZK973.10	Y46G5A.2
+Y51H1A.3	Y49A3A.2
+Y53G8AL.2	Y49A3A.2
+Y54E10BL.5	Y49A3A.2
+Y54F10AM.5	Y49A3A.2
+Y55H10A.1	Y49A3A.2
+Y56A3A.19	Y49A3A.2
+Y57G11C.12	Y49A3A.2
+Y63D3A.7	Y49A3A.2
+Y69A2AR.18	Y49A3A.2
+Y71H2AM.4	Y49A3A.2
+Y71H2AM.5	Y49A3A.2
+Y94H6A.8	Y49A3A.2
+ZC262.5	Y49A3A.2
+ZK637.8	Y49A3A.2
+ZK809.3	Y49A3A.2
+ZK970.4	Y49A3A.2
+ZK973.10	Y49A3A.2
+Y53G8AL.2	Y51H1A.3
+Y54E10BL.5	Y51H1A.3
+Y54F10AM.5	Y51H1A.3
+Y55H10A.1	Y51H1A.3
+Y56A3A.19	Y51H1A.3
+Y57G11C.12	Y51H1A.3
+Y63D3A.7	Y51H1A.3
+Y69A2AR.18	Y51H1A.3
+Y71H2AM.4	Y51H1A.3
+Y71H2AM.5	Y51H1A.3
+Y94H6A.8	Y51H1A.3
+ZC262.5	Y51H1A.3
+ZK637.8	Y51H1A.3
+ZK809.3	Y51H1A.3
+ZK970.4	Y51H1A.3
+ZK973.10	Y51H1A.3
+Y54E10BL.5	Y53G8AL.2
+Y54F10AM.5	Y53G8AL.2
+Y55H10A.1	Y53G8AL.2
+Y56A3A.19	Y53G8AL.2
+Y57G11C.12	Y53G8AL.2
+Y63D3A.7	Y53G8AL.2
+Y69A2AR.18	Y53G8AL.2
+Y71H2AM.4	Y53G8AL.2
+Y71H2AM.5	Y53G8AL.2
+Y94H6A.8	Y53G8AL.2
+ZC262.5	Y53G8AL.2
+ZK637.8	Y53G8AL.2
+ZK809.3	Y53G8AL.2
+ZK970.4	Y53G8AL.2
+ZK973.10	Y53G8AL.2
+Y54F10AM.5	Y54E10BL.5
+Y55H10A.1	Y54E10BL.5
+Y56A3A.19	Y54E10BL.5
+Y57G11C.12	Y54E10BL.5
+Y63D3A.7	Y54E10BL.5
+Y69A2AR.18	Y54E10BL.5
+Y71H2AM.4	Y54E10BL.5
+Y71H2AM.5	Y54E10BL.5
+Y94H6A.8	Y54E10BL.5
+ZC262.5	Y54E10BL.5
+ZK637.8	Y54E10BL.5
+ZK809.3	Y54E10BL.5
+ZK970.4	Y54E10BL.5
+ZK973.10	Y54E10BL.5
+Y55H10A.1	Y54F10AM.5
+Y56A3A.19	Y54F10AM.5
+Y57G11C.12	Y54F10AM.5
+Y63D3A.7	Y54F10AM.5
+Y69A2AR.18	Y54F10AM.5
+Y71H2AM.4	Y54F10AM.5
+Y71H2AM.5	Y54F10AM.5
+Y94H6A.8	Y54F10AM.5
+ZC262.5	Y54F10AM.5
+ZK637.8	Y54F10AM.5
+ZK809.3	Y54F10AM.5
+ZK970.4	Y54F10AM.5
+ZK973.10	Y54F10AM.5
+Y56A3A.19	Y55H10A.1
+Y57G11C.12	Y55H10A.1
+Y63D3A.7	Y55H10A.1
+Y69A2AR.18	Y55H10A.1
+Y71H2AM.4	Y55H10A.1
+Y71H2AM.5	Y55H10A.1
+Y94H6A.8	Y55H10A.1
+ZC262.5	Y55H10A.1
+ZK637.8	Y55H10A.1
+ZK809.3	Y55H10A.1
+ZK970.4	Y55H10A.1
+ZK973.10	Y55H10A.1
+Y57G11C.12	Y56A3A.19
+Y63D3A.7	Y56A3A.19
+Y69A2AR.18	Y56A3A.19
+Y71H2AM.4	Y56A3A.19
+Y71H2AM.5	Y56A3A.19
+Y94H6A.8	Y56A3A.19
+ZC262.5	Y56A3A.19
+ZK637.8	Y56A3A.19
+ZK809.3	Y56A3A.19
+ZK970.4	Y56A3A.19
+ZK973.10	Y56A3A.19
+Y63D3A.7	Y57G11C.12
+Y69A2AR.18	Y57G11C.12
+Y71H2AM.4	Y57G11C.12
+Y71H2AM.5	Y57G11C.12
+Y94H6A.8	Y57G11C.12
+ZC262.5	Y57G11C.12
+ZK637.8	Y57G11C.12
+ZK809.3	Y57G11C.12
+ZK970.4	Y57G11C.12
+ZK973.10	Y57G11C.12
+Y69A2AR.18	Y63D3A.7
+Y71H2AM.4	Y63D3A.7
+Y71H2AM.5	Y63D3A.7
+Y94H6A.8	Y63D3A.7
+ZC262.5	Y63D3A.7
+ZK637.8	Y63D3A.7
+ZK809.3	Y63D3A.7
+ZK970.4	Y63D3A.7
+ZK973.10	Y63D3A.7
+Y71H2AM.4	Y69A2AR.18
+Y71H2AM.5	Y69A2AR.18
+Y94H6A.8	Y69A2AR.18
+ZC262.5	Y69A2AR.18
+ZK637.8	Y69A2AR.18
+ZK809.3	Y69A2AR.18
+ZK970.4	Y69A2AR.18
+ZK973.10	Y69A2AR.18
+Y71H2AM.5	Y71H2AM.4
+Y94H6A.8	Y71H2AM.4
+ZC262.5	Y71H2AM.4
+ZK637.8	Y71H2AM.4
+ZK809.3	Y71H2AM.4
+ZK970.4	Y71H2AM.4
+ZK973.10	Y71H2AM.4
+Y94H6A.8	Y71H2AM.5
+ZC262.5	Y71H2AM.5
+ZK637.8	Y71H2AM.5
+ZK809.3	Y71H2AM.5
+ZK970.4	Y71H2AM.5
+ZK973.10	Y71H2AM.5
+ZC262.5	Y94H6A.8
+ZK637.8	Y94H6A.8
+ZK809.3	Y94H6A.8
+ZK970.4	Y94H6A.8
+ZK973.10	Y94H6A.8
+ZK637.8	ZC262.5
+ZK809.3	ZC262.5
+ZK970.4	ZC262.5
+ZK973.10	ZC262.5
+ZK809.3	ZK637.8
+ZK970.4	ZK637.8
+ZK973.10	ZK637.8
+ZK970.4	ZK809.3
+ZK973.10	ZK809.3
+ZK973.10	ZK970.4
+B0024.6	AH6.1
+B0286.3	AH6.1
+BE0003N10.1	AH6.1
+C03C10.3	AH6.1
+C06A1.5	AH6.1
+C06A12.4	AH6.1
+C06B3.8	AH6.1
+C15H11.8	AH6.1
+C17F4.6	AH6.1
+C26E6.4	AH6.1
+C27H5.1	AH6.1
+C29E4.8	AH6.1
+C30G4.3	AH6.1
+C32E12.2	AH6.1
+C36B1.3	AH6.1
+C37H5.6	AH6.1
+C42D4.8	AH6.1
+C46E1.2	AH6.1
+C48E7.2	AH6.1
+C49H3.1	AH6.1
+C55F2.1	AH6.1
+E01F3.1	AH6.1
+EEED8.8	AH6.1
+F08B1.2	AH6.1
+F08B4.5	AH6.1
+F08C6.6	AH6.1
+F09F7.3	AH6.1
+F10C2.4	AH6.1
+F10F2.2	AH6.1
+F12F6.7	AH6.1
+F14B4.3	AH6.1
+F15E6.6	AH6.1
+F17C8.1	AH6.1
+F19G12.2	AH6.1
+F21H7.9	AH6.1
+F22E5.3	AH6.1
+F23B2.13	AH6.1
+F23H12.6	AH6.1
+F25H2.5	AH6.1
+F25H5.3	AH6.1
+F26F4.11	AH6.1
+F32D1.5	AH6.1
+F33H2.5	AH6.1
+F36A4.7	AH6.1
+F38B2.4	AH6.1
+F38B6.4	AH6.1
+F43E2.2	AH6.1
+F55B11.1	AH6.1
+F58A4.4	AH6.1
+F58A4.9	AH6.1
+H27M09.2	AH6.1
+H43I07.2	AH6.1
+K02D7.1	AH6.1
+K08H10.4	AH6.1
+M04G12.3	AH6.1
+M106.4	AH6.1
+R01H10.1	AH6.1
+R04F11.3	AH6.1
+R05F9.6	AH6.1
+R06C7.5	AH6.1
+R07E4.4	AH6.1
+R07H5.8	AH6.1
+R134.1	AH6.1
+R134.2	AH6.1
+R151.2	AH6.1
+R153.1	AH6.1
+T01A4.1	AH6.1
+T03D8.5	AH6.1
+T03F1.8	AH6.1
+T04A8.5	AH6.1
+T04D3.3	AH6.1
+T04D3.4	AH6.1
+T14G10.1	AH6.1
+T19B4.3	AH6.1
+T22D1.3	AH6.1
+T23G5.1	AH6.1
+T24C4.5	AH6.1
+T26C12.4	AH6.1
+W01G7.3	AH6.1
+W02D9.1	AH6.1
+W03F11.2	AH6.1
+W06E11.1	AH6.1
+W09C3.4	AH6.1
+Y105C5B.2	AH6.1
+Y105E8B.5	AH6.1
+Y10G11A.1	AH6.1
+Y37E3.3	AH6.1
+Y37H9A.6	AH6.1
+Y43F4B.5	AH6.1
+Y47D3A.29	AH6.1
+Y48E1A.1	AH6.1
+Y53F4B.3	AH6.1
+Y54E10BR.6	AH6.1
+Y56A3A.13	AH6.1
+Y71H10B.1	AH6.1
+Y77E11A.6	AH6.1
+Y95B8A.10	AH6.1
+Y97E10AR.5	AH6.1
+ZC239.7	AH6.1
+ZC395.7	AH6.1
+ZC412.2	AH6.1
+ZK455.2	AH6.1
+ZK563.7	AH6.1
+ZK593.1	AH6.1
+ZK673.2	AH6.1
+ZK856.10	AH6.1
+ZK896.8	AH6.1
+ZK909.3	AH6.1
+ZK970.5	AH6.1
+ZK970.6	AH6.1
+B0286.3	B0024.6
+BE0003N10.1	B0024.6
+C03C10.3	B0024.6
+C06A1.5	B0024.6
+C06A12.4	B0024.6
+C06B3.8	B0024.6
+C15H11.8	B0024.6
+C17F4.6	B0024.6
+C26E6.4	B0024.6
+C27H5.1	B0024.6
+C29E4.8	B0024.6
+C30G4.3	B0024.6
+C32E12.2	B0024.6
+C36B1.3	B0024.6
+C37H5.6	B0024.6
+C42D4.8	B0024.6
+C46E1.2	B0024.6
+C48E7.2	B0024.6
+C49H3.1	B0024.6
+C55F2.1	B0024.6
+E01F3.1	B0024.6
+EEED8.8	B0024.6
+F08B1.2	B0024.6
+F08B4.5	B0024.6
+F08C6.6	B0024.6
+F09F7.3	B0024.6
+F10C2.4	B0024.6
+F10F2.2	B0024.6
+F12F6.7	B0024.6
+F14B4.3	B0024.6
+F15E6.6	B0024.6
+F17C8.1	B0024.6
+F19G12.2	B0024.6
+F21H7.9	B0024.6
+F22E5.3	B0024.6
+F23B2.13	B0024.6
+F23H12.6	B0024.6
+F25H2.5	B0024.6
+F25H5.3	B0024.6
+F26F4.11	B0024.6
+F32D1.5	B0024.6
+F33H2.5	B0024.6
+F36A4.7	B0024.6
+F38B2.4	B0024.6
+F38B6.4	B0024.6
+F43E2.2	B0024.6
+F55B11.1	B0024.6
+F58A4.4	B0024.6
+F58A4.9	B0024.6
+H27M09.2	B0024.6
+H43I07.2	B0024.6
+K02D7.1	B0024.6
+K08H10.4	B0024.6
+M04G12.3	B0024.6
+M106.4	B0024.6
+R01H10.1	B0024.6
+R04F11.3	B0024.6
+R05F9.6	B0024.6
+R06C7.5	B0024.6
+R07E4.4	B0024.6
+R07H5.8	B0024.6
+R134.1	B0024.6
+R134.2	B0024.6
+R151.2	B0024.6
+R153.1	B0024.6
+T01A4.1	B0024.6
+T03D8.5	B0024.6
+T03F1.8	B0024.6
+T04A8.5	B0024.6
+T04D3.3	B0024.6
+T04D3.4	B0024.6
+T14G10.1	B0024.6
+T19B4.3	B0024.6
+T22D1.3	B0024.6
+T23G5.1	B0024.6
+T24C4.5	B0024.6
+T26C12.4	B0024.6
+W01G7.3	B0024.6
+W02D9.1	B0024.6
+W03F11.2	B0024.6
+W06E11.1	B0024.6
+W09C3.4	B0024.6
+Y105C5B.2	B0024.6
+Y105E8B.5	B0024.6
+Y10G11A.1	B0024.6
+Y37E3.3	B0024.6
+Y37H9A.6	B0024.6
+Y43F4B.5	B0024.6
+Y47D3A.29	B0024.6
+Y48E1A.1	B0024.6
+Y53F4B.3	B0024.6
+Y54E10BR.6	B0024.6
+Y56A3A.13	B0024.6
+Y71H10B.1	B0024.6
+Y77E11A.6	B0024.6
+Y95B8A.10	B0024.6
+Y97E10AR.5	B0024.6
+ZC239.7	B0024.6
+ZC395.7	B0024.6
+ZC412.2	B0024.6
+ZK455.2	B0024.6
+ZK563.7	B0024.6
+ZK593.1	B0024.6
+ZK673.2	B0024.6
+ZK856.10	B0024.6
+ZK896.8	B0024.6
+ZK909.3	B0024.6
+ZK970.5	B0024.6
+ZK970.6	B0024.6
+BE0003N10.1	B0286.3
+C03C10.3	B0286.3
+C06A1.5	B0286.3
+C06A12.4	B0286.3
+C06B3.8	B0286.3
+C15H11.8	B0286.3
+C17F4.6	B0286.3
+C26E6.4	B0286.3
+C27H5.1	B0286.3
+C29E4.8	B0286.3
+C30G4.3	B0286.3
+C32E12.2	B0286.3
+C36B1.3	B0286.3
+C37H5.6	B0286.3
+C42D4.8	B0286.3
+C46E1.2	B0286.3
+C48E7.2	B0286.3
+C49H3.1	B0286.3
+C55F2.1	B0286.3
+E01F3.1	B0286.3
+EEED8.8	B0286.3
+F08B1.2	B0286.3
+F08B4.5	B0286.3
+F08C6.6	B0286.3
+F09F7.3	B0286.3
+F10C2.4	B0286.3
+F10F2.2	B0286.3
+F12F6.7	B0286.3
+F14B4.3	B0286.3
+F15E6.6	B0286.3
+F17C8.1	B0286.3
+F19G12.2	B0286.3
+F21H7.9	B0286.3
+F22E5.3	B0286.3
+F23B2.13	B0286.3
+F23H12.6	B0286.3
+F25H2.5	B0286.3
+F25H5.3	B0286.3
+F26F4.11	B0286.3
+F32D1.5	B0286.3
+F33H2.5	B0286.3
+F36A4.7	B0286.3
+F38B2.4	B0286.3
+F38B6.4	B0286.3
+F43E2.2	B0286.3
+F55B11.1	B0286.3
+F58A4.4	B0286.3
+F58A4.9	B0286.3
+H27M09.2	B0286.3
+H43I07.2	B0286.3
+K02D7.1	B0286.3
+K08H10.4	B0286.3
+M04G12.3	B0286.3
+M106.4	B0286.3
+R01H10.1	B0286.3
+R04F11.3	B0286.3
+R05F9.6	B0286.3
+R06C7.5	B0286.3
+R07E4.4	B0286.3
+R07H5.8	B0286.3
+R134.1	B0286.3
+R134.2	B0286.3
+R151.2	B0286.3
+R153.1	B0286.3
+T01A4.1	B0286.3
+T03D8.5	B0286.3
+T03F1.8	B0286.3
+T04A8.5	B0286.3
+T04D3.3	B0286.3
+T04D3.4	B0286.3
+T14G10.1	B0286.3
+T19B4.3	B0286.3
+T22D1.3	B0286.3
+T23G5.1	B0286.3
+T24C4.5	B0286.3
+T26C12.4	B0286.3
+W01G7.3	B0286.3
+W02D9.1	B0286.3
+W03F11.2	B0286.3
+W06E11.1	B0286.3
+W09C3.4	B0286.3
+Y105C5B.2	B0286.3
+Y105E8B.5	B0286.3
+Y10G11A.1	B0286.3
+Y37E3.3	B0286.3
+Y37H9A.6	B0286.3
+Y43F4B.5	B0286.3
+Y47D3A.29	B0286.3
+Y48E1A.1	B0286.3
+Y53F4B.3	B0286.3
+Y54E10BR.6	B0286.3
+Y56A3A.13	B0286.3
+Y71H10B.1	B0286.3
+Y77E11A.6	B0286.3
+Y95B8A.10	B0286.3
+Y97E10AR.5	B0286.3
+ZC239.7	B0286.3
+ZC395.7	B0286.3
+ZC412.2	B0286.3
+ZK455.2	B0286.3
+ZK563.7	B0286.3
+ZK593.1	B0286.3
+ZK673.2	B0286.3
+ZK856.10	B0286.3
+ZK896.8	B0286.3
+ZK909.3	B0286.3
+ZK970.5	B0286.3
+ZK970.6	B0286.3
+C03C10.3	BE0003N10.1
+C06A1.5	BE0003N10.1
+C06A12.4	BE0003N10.1
+C06B3.8	BE0003N10.1
+C15H11.8	BE0003N10.1
+C17F4.6	BE0003N10.1
+C26E6.4	BE0003N10.1
+C27H5.1	BE0003N10.1
+C29E4.8	BE0003N10.1
+C30G4.3	BE0003N10.1
+C32E12.2	BE0003N10.1
+C36B1.3	BE0003N10.1
+C37H5.6	BE0003N10.1
+C42D4.8	BE0003N10.1
+C46E1.2	BE0003N10.1
+C48E7.2	BE0003N10.1
+C49H3.1	BE0003N10.1
+C55F2.1	BE0003N10.1
+E01F3.1	BE0003N10.1
+EEED8.8	BE0003N10.1
+F08B1.2	BE0003N10.1
+F08B4.5	BE0003N10.1
+F08C6.6	BE0003N10.1
+F09F7.3	BE0003N10.1
+F10C2.4	BE0003N10.1
+F10F2.2	BE0003N10.1
+F12F6.7	BE0003N10.1
+F14B4.3	BE0003N10.1
+F15E6.6	BE0003N10.1
+F17C8.1	BE0003N10.1
+F19G12.2	BE0003N10.1
+F21H7.9	BE0003N10.1
+F22E5.3	BE0003N10.1
+F23B2.13	BE0003N10.1
+F23H12.6	BE0003N10.1
+F25H2.5	BE0003N10.1
+F25H5.3	BE0003N10.1
+F26F4.11	BE0003N10.1
+F32D1.5	BE0003N10.1
+F33H2.5	BE0003N10.1
+F36A4.7	BE0003N10.1
+F38B2.4	BE0003N10.1
+F38B6.4	BE0003N10.1
+F43E2.2	BE0003N10.1
+F55B11.1	BE0003N10.1
+F58A4.4	BE0003N10.1
+F58A4.9	BE0003N10.1
+H27M09.2	BE0003N10.1
+H43I07.2	BE0003N10.1
+K02D7.1	BE0003N10.1
+K08H10.4	BE0003N10.1
+M04G12.3	BE0003N10.1
+M106.4	BE0003N10.1
+R01H10.1	BE0003N10.1
+R04F11.3	BE0003N10.1
+R05F9.6	BE0003N10.1
+R06C7.5	BE0003N10.1
+R07E4.4	BE0003N10.1
+R07H5.8	BE0003N10.1
+R134.1	BE0003N10.1
+R134.2	BE0003N10.1
+R151.2	BE0003N10.1
+R153.1	BE0003N10.1
+T01A4.1	BE0003N10.1
+T03D8.5	BE0003N10.1
+T03F1.8	BE0003N10.1
+T04A8.5	BE0003N10.1
+T04D3.3	BE0003N10.1
+T04D3.4	BE0003N10.1
+T14G10.1	BE0003N10.1
+T19B4.3	BE0003N10.1
+T22D1.3	BE0003N10.1
+T23G5.1	BE0003N10.1
+T24C4.5	BE0003N10.1
+T26C12.4	BE0003N10.1
+W01G7.3	BE0003N10.1
+W02D9.1	BE0003N10.1
+W03F11.2	BE0003N10.1
+W06E11.1	BE0003N10.1
+W09C3.4	BE0003N10.1
+Y105C5B.2	BE0003N10.1
+Y105E8B.5	BE0003N10.1
+Y10G11A.1	BE0003N10.1
+Y37E3.3	BE0003N10.1
+Y37H9A.6	BE0003N10.1
+Y43F4B.5	BE0003N10.1
+Y47D3A.29	BE0003N10.1
+Y48E1A.1	BE0003N10.1
+Y53F4B.3	BE0003N10.1
+Y54E10BR.6	BE0003N10.1
+Y56A3A.13	BE0003N10.1
+Y71H10B.1	BE0003N10.1
+Y77E11A.6	BE0003N10.1
+Y95B8A.10	BE0003N10.1
+Y97E10AR.5	BE0003N10.1
+ZC239.7	BE0003N10.1
+ZC395.7	BE0003N10.1
+ZC412.2	BE0003N10.1
+ZK455.2	BE0003N10.1
+ZK563.7	BE0003N10.1
+ZK593.1	BE0003N10.1
+ZK673.2	BE0003N10.1
+ZK856.10	BE0003N10.1
+ZK896.8	BE0003N10.1
+ZK909.3	BE0003N10.1
+ZK970.5	BE0003N10.1
+ZK970.6	BE0003N10.1
+C06A1.5	C03C10.3
+C06A12.4	C03C10.3
+C06B3.8	C03C10.3
+C15H11.8	C03C10.3
+C17F4.6	C03C10.3
+C26E6.4	C03C10.3
+C27H5.1	C03C10.3
+C29E4.8	C03C10.3
+C30G4.3	C03C10.3
+C32E12.2	C03C10.3
+C36B1.3	C03C10.3
+C37H5.6	C03C10.3
+C42D4.8	C03C10.3
+C46E1.2	C03C10.3
+C48E7.2	C03C10.3
+C49H3.1	C03C10.3
+C55F2.1	C03C10.3
+E01F3.1	C03C10.3
+EEED8.8	C03C10.3
+F08B1.2	C03C10.3
+F08B4.5	C03C10.3
+F08C6.6	C03C10.3
+F09F7.3	C03C10.3
+F10C2.4	C03C10.3
+F10F2.2	C03C10.3
+F12F6.7	C03C10.3
+F14B4.3	C03C10.3
+F15E6.6	C03C10.3
+F17C8.1	C03C10.3
+F19G12.2	C03C10.3
+F21H7.9	C03C10.3
+F22E5.3	C03C10.3
+F23B2.13	C03C10.3
+F23H12.6	C03C10.3
+F25H2.5	C03C10.3
+F25H5.3	C03C10.3
+F26F4.11	C03C10.3
+F32D1.5	C03C10.3
+F33H2.5	C03C10.3
+F36A4.7	C03C10.3
+F38B2.4	C03C10.3
+F38B6.4	C03C10.3
+F43E2.2	C03C10.3
+F55B11.1	C03C10.3
+F58A4.4	C03C10.3
+F58A4.9	C03C10.3
+H27M09.2	C03C10.3
+H43I07.2	C03C10.3
+K02D7.1	C03C10.3
+K08H10.4	C03C10.3
+M04G12.3	C03C10.3
+M106.4	C03C10.3
+R01H10.1	C03C10.3
+R04F11.3	C03C10.3
+R05F9.6	C03C10.3
+R06C7.5	C03C10.3
+R07E4.4	C03C10.3
+R07H5.8	C03C10.3
+R134.1	C03C10.3
+R134.2	C03C10.3
+R151.2	C03C10.3
+R153.1	C03C10.3
+T01A4.1	C03C10.3
+T03D8.5	C03C10.3
+T03F1.8	C03C10.3
+T04A8.5	C03C10.3
+T04D3.3	C03C10.3
+T04D3.4	C03C10.3
+T14G10.1	C03C10.3
+T19B4.3	C03C10.3
+T22D1.3	C03C10.3
+T23G5.1	C03C10.3
+T24C4.5	C03C10.3
+T26C12.4	C03C10.3
+W01G7.3	C03C10.3
+W02D9.1	C03C10.3
+W03F11.2	C03C10.3
+W06E11.1	C03C10.3
+W09C3.4	C03C10.3
+Y105C5B.2	C03C10.3
+Y105E8B.5	C03C10.3
+Y10G11A.1	C03C10.3
+Y37E3.3	C03C10.3
+Y37H9A.6	C03C10.3
+Y43F4B.5	C03C10.3
+Y47D3A.29	C03C10.3
+Y48E1A.1	C03C10.3
+Y53F4B.3	C03C10.3
+Y54E10BR.6	C03C10.3
+Y56A3A.13	C03C10.3
+Y71H10B.1	C03C10.3
+Y77E11A.6	C03C10.3
+Y95B8A.10	C03C10.3
+Y97E10AR.5	C03C10.3
+ZC239.7	C03C10.3
+ZC395.7	C03C10.3
+ZC412.2	C03C10.3
+ZK455.2	C03C10.3
+ZK563.7	C03C10.3
+ZK593.1	C03C10.3
+ZK673.2	C03C10.3
+ZK856.10	C03C10.3
+ZK896.8	C03C10.3
+ZK909.3	C03C10.3
+ZK970.5	C03C10.3
+ZK970.6	C03C10.3
+C06A12.4	C06A1.5
+C06B3.8	C06A1.5
+C15H11.8	C06A1.5
+C17F4.6	C06A1.5
+C26E6.4	C06A1.5
+C27H5.1	C06A1.5
+C29E4.8	C06A1.5
+C30G4.3	C06A1.5
+C32E12.2	C06A1.5
+C36B1.3	C06A1.5
+C37H5.6	C06A1.5
+C42D4.8	C06A1.5
+C46E1.2	C06A1.5
+C48E7.2	C06A1.5
+C49H3.1	C06A1.5
+C55F2.1	C06A1.5
+E01F3.1	C06A1.5
+EEED8.8	C06A1.5
+F08B1.2	C06A1.5
+F08B4.5	C06A1.5
+F08C6.6	C06A1.5
+F09F7.3	C06A1.5
+F10C2.4	C06A1.5
+F10F2.2	C06A1.5
+F12F6.7	C06A1.5
+F14B4.3	C06A1.5
+F15E6.6	C06A1.5
+F17C8.1	C06A1.5
+F19G12.2	C06A1.5
+F21H7.9	C06A1.5
+F22E5.3	C06A1.5
+F23B2.13	C06A1.5
+F23H12.6	C06A1.5
+F25H2.5	C06A1.5
+F25H5.3	C06A1.5
+F26F4.11	C06A1.5
+F32D1.5	C06A1.5
+F33H2.5	C06A1.5
+F36A4.7	C06A1.5
+F38B2.4	C06A1.5
+F38B6.4	C06A1.5
+F43E2.2	C06A1.5
+F55B11.1	C06A1.5
+F58A4.4	C06A1.5
+F58A4.9	C06A1.5
+H27M09.2	C06A1.5
+H43I07.2	C06A1.5
+K02D7.1	C06A1.5
+K08H10.4	C06A1.5
+M04G12.3	C06A1.5
+M106.4	C06A1.5
+R01H10.1	C06A1.5
+R04F11.3	C06A1.5
+R05F9.6	C06A1.5
+R06C7.5	C06A1.5
+R07E4.4	C06A1.5
+R07H5.8	C06A1.5
+R134.1	C06A1.5
+R134.2	C06A1.5
+R151.2	C06A1.5
+R153.1	C06A1.5
+T01A4.1	C06A1.5
+T03D8.5	C06A1.5
+T03F1.8	C06A1.5
+T04A8.5	C06A1.5
+T04D3.3	C06A1.5
+T04D3.4	C06A1.5
+T14G10.1	C06A1.5
+T19B4.3	C06A1.5
+T22D1.3	C06A1.5
+T23G5.1	C06A1.5
+T24C4.5	C06A1.5
+T26C12.4	C06A1.5
+W01G7.3	C06A1.5
+W02D9.1	C06A1.5
+W03F11.2	C06A1.5
+W06E11.1	C06A1.5
+W09C3.4	C06A1.5
+Y105C5B.2	C06A1.5
+Y105E8B.5	C06A1.5
+Y10G11A.1	C06A1.5
+Y37E3.3	C06A1.5
+Y37H9A.6	C06A1.5
+Y43F4B.5	C06A1.5
+Y47D3A.29	C06A1.5
+Y48E1A.1	C06A1.5
+Y53F4B.3	C06A1.5
+Y54E10BR.6	C06A1.5
+Y56A3A.13	C06A1.5
+Y71H10B.1	C06A1.5
+Y77E11A.6	C06A1.5
+Y95B8A.10	C06A1.5
+Y97E10AR.5	C06A1.5
+ZC239.7	C06A1.5
+ZC395.7	C06A1.5
+ZC412.2	C06A1.5
+ZK455.2	C06A1.5
+ZK563.7	C06A1.5
+ZK593.1	C06A1.5
+ZK673.2	C06A1.5
+ZK856.10	C06A1.5
+ZK896.8	C06A1.5
+ZK909.3	C06A1.5
+ZK970.5	C06A1.5
+ZK970.6	C06A1.5
+C06B3.8	C06A12.4
+C15H11.8	C06A12.4
+C17F4.6	C06A12.4
+C26E6.4	C06A12.4
+C27H5.1	C06A12.4
+C29E4.8	C06A12.4
+C30G4.3	C06A12.4
+C32E12.2	C06A12.4
+C36B1.3	C06A12.4
+C37H5.6	C06A12.4
+C42D4.8	C06A12.4
+C46E1.2	C06A12.4
+C48E7.2	C06A12.4
+C49H3.1	C06A12.4
+C55F2.1	C06A12.4
+E01F3.1	C06A12.4
+EEED8.8	C06A12.4
+F08B1.2	C06A12.4
+F08B4.5	C06A12.4
+F08C6.6	C06A12.4
+F09F7.3	C06A12.4
+F10C2.4	C06A12.4
+F10F2.2	C06A12.4
+F12F6.7	C06A12.4
+F14B4.3	C06A12.4
+F15E6.6	C06A12.4
+F17C8.1	C06A12.4
+F19G12.2	C06A12.4
+F21H7.9	C06A12.4
+F22E5.3	C06A12.4
+F23B2.13	C06A12.4
+F23H12.6	C06A12.4
+F25H2.5	C06A12.4
+F25H5.3	C06A12.4
+F26F4.11	C06A12.4
+F32D1.5	C06A12.4
+F33H2.5	C06A12.4
+F36A4.7	C06A12.4
+F38B2.4	C06A12.4
+F38B6.4	C06A12.4
+F43E2.2	C06A12.4
+F55B11.1	C06A12.4
+F58A4.4	C06A12.4
+F58A4.9	C06A12.4
+H27M09.2	C06A12.4
+H43I07.2	C06A12.4
+K02D7.1	C06A12.4
+K08H10.4	C06A12.4
+M04G12.3	C06A12.4
+M106.4	C06A12.4
+R01H10.1	C06A12.4
+R04F11.3	C06A12.4
+R05F9.6	C06A12.4
+R06C7.5	C06A12.4
+R07E4.4	C06A12.4
+R07H5.8	C06A12.4
+R134.1	C06A12.4
+R134.2	C06A12.4
+R151.2	C06A12.4
+R153.1	C06A12.4
+T01A4.1	C06A12.4
+T03D8.5	C06A12.4
+T03F1.8	C06A12.4
+T04A8.5	C06A12.4
+T04D3.3	C06A12.4
+T04D3.4	C06A12.4
+T14G10.1	C06A12.4
+T19B4.3	C06A12.4
+T22D1.3	C06A12.4
+T23G5.1	C06A12.4
+T24C4.5	C06A12.4
+T26C12.4	C06A12.4
+W01G7.3	C06A12.4
+W02D9.1	C06A12.4
+W03F11.2	C06A12.4
+W06E11.1	C06A12.4
+W09C3.4	C06A12.4
+Y105C5B.2	C06A12.4
+Y105E8B.5	C06A12.4
+Y10G11A.1	C06A12.4
+Y37E3.3	C06A12.4
+Y37H9A.6	C06A12.4
+Y43F4B.5	C06A12.4
+Y47D3A.29	C06A12.4
+Y48E1A.1	C06A12.4
+Y53F4B.3	C06A12.4
+Y54E10BR.6	C06A12.4
+Y56A3A.13	C06A12.4
+Y71H10B.1	C06A12.4
+Y77E11A.6	C06A12.4
+Y95B8A.10	C06A12.4
+Y97E10AR.5	C06A12.4
+ZC239.7	C06A12.4
+ZC395.7	C06A12.4
+ZC412.2	C06A12.4
+ZK455.2	C06A12.4
+ZK563.7	C06A12.4
+ZK593.1	C06A12.4
+ZK673.2	C06A12.4
+ZK856.10	C06A12.4
+ZK896.8	C06A12.4
+ZK909.3	C06A12.4
+ZK970.5	C06A12.4
+ZK970.6	C06A12.4
+C15H11.8	C06B3.8
+C17F4.6	C06B3.8
+C26E6.4	C06B3.8
+C27H5.1	C06B3.8
+C29E4.8	C06B3.8
+C30G4.3	C06B3.8
+C32E12.2	C06B3.8
+C36B1.3	C06B3.8
+C37H5.6	C06B3.8
+C42D4.8	C06B3.8
+C46E1.2	C06B3.8
+C48E7.2	C06B3.8
+C49H3.1	C06B3.8
+C55F2.1	C06B3.8
+E01F3.1	C06B3.8
+EEED8.8	C06B3.8
+F08B1.2	C06B3.8
+F08B4.5	C06B3.8
+F08C6.6	C06B3.8
+F09F7.3	C06B3.8
+F10C2.4	C06B3.8
+F10F2.2	C06B3.8
+F12F6.7	C06B3.8
+F14B4.3	C06B3.8
+F15E6.6	C06B3.8
+F17C8.1	C06B3.8
+F19G12.2	C06B3.8
+F21H7.9	C06B3.8
+F22E5.3	C06B3.8
+F23B2.13	C06B3.8
+F23H12.6	C06B3.8
+F25H2.5	C06B3.8
+F25H5.3	C06B3.8
+F26F4.11	C06B3.8
+F32D1.5	C06B3.8
+F33H2.5	C06B3.8
+F36A4.7	C06B3.8
+F38B2.4	C06B3.8
+F38B6.4	C06B3.8
+F43E2.2	C06B3.8
+F55B11.1	C06B3.8
+F58A4.4	C06B3.8
+F58A4.9	C06B3.8
+H27M09.2	C06B3.8
+H43I07.2	C06B3.8
+K02D7.1	C06B3.8
+K08H10.4	C06B3.8
+M04G12.3	C06B3.8
+M106.4	C06B3.8
+R01H10.1	C06B3.8
+R04F11.3	C06B3.8
+R05F9.6	C06B3.8
+R06C7.5	C06B3.8
+R07E4.4	C06B3.8
+R07H5.8	C06B3.8
+R134.1	C06B3.8
+R134.2	C06B3.8
+R151.2	C06B3.8
+R153.1	C06B3.8
+T01A4.1	C06B3.8
+T03D8.5	C06B3.8
+T03F1.8	C06B3.8
+T04A8.5	C06B3.8
+T04D3.3	C06B3.8
+T04D3.4	C06B3.8
+T14G10.1	C06B3.8
+T19B4.3	C06B3.8
+T22D1.3	C06B3.8
+T23G5.1	C06B3.8
+T24C4.5	C06B3.8
+T26C12.4	C06B3.8
+W01G7.3	C06B3.8
+W02D9.1	C06B3.8
+W03F11.2	C06B3.8
+W06E11.1	C06B3.8
+W09C3.4	C06B3.8
+Y105C5B.2	C06B3.8
+Y105E8B.5	C06B3.8
+Y10G11A.1	C06B3.8
+Y37E3.3	C06B3.8
+Y37H9A.6	C06B3.8
+Y43F4B.5	C06B3.8
+Y47D3A.29	C06B3.8
+Y48E1A.1	C06B3.8
+Y53F4B.3	C06B3.8
+Y54E10BR.6	C06B3.8
+Y56A3A.13	C06B3.8
+Y71H10B.1	C06B3.8
+Y77E11A.6	C06B3.8
+Y95B8A.10	C06B3.8
+Y97E10AR.5	C06B3.8
+ZC239.7	C06B3.8
+ZC395.7	C06B3.8
+ZC412.2	C06B3.8
+ZK455.2	C06B3.8
+ZK563.7	C06B3.8
+ZK593.1	C06B3.8
+ZK673.2	C06B3.8
+ZK856.10	C06B3.8
+ZK896.8	C06B3.8
+ZK909.3	C06B3.8
+ZK970.5	C06B3.8
+ZK970.6	C06B3.8
+C17F4.6	C15H11.8
+C26E6.4	C15H11.8
+C27H5.1	C15H11.8
+C29E4.8	C15H11.8
+C30G4.3	C15H11.8
+C32E12.2	C15H11.8
+C36B1.3	C15H11.8
+C37H5.6	C15H11.8
+C42D4.8	C15H11.8
+C46E1.2	C15H11.8
+C48E7.2	C15H11.8
+C49H3.1	C15H11.8
+C55F2.1	C15H11.8
+E01F3.1	C15H11.8
+EEED8.8	C15H11.8
+F08B1.2	C15H11.8
+F08B4.5	C15H11.8
+F08C6.6	C15H11.8
+F09F7.3	C15H11.8
+F10C2.4	C15H11.8
+F10F2.2	C15H11.8
+F12F6.7	C15H11.8
+F14B4.3	C15H11.8
+F15E6.6	C15H11.8
+F17C8.1	C15H11.8
+F19G12.2	C15H11.8
+F21H7.9	C15H11.8
+F22E5.3	C15H11.8
+F23B2.13	C15H11.8
+F23H12.6	C15H11.8
+F25H2.5	C15H11.8
+F25H5.3	C15H11.8
+F26F4.11	C15H11.8
+F32D1.5	C15H11.8
+F33H2.5	C15H11.8
+F36A4.7	C15H11.8
+F38B2.4	C15H11.8
+F38B6.4	C15H11.8
+F43E2.2	C15H11.8
+F55B11.1	C15H11.8
+F58A4.4	C15H11.8
+F58A4.9	C15H11.8
+H27M09.2	C15H11.8
+H43I07.2	C15H11.8
+K02D7.1	C15H11.8
+K08H10.4	C15H11.8
+M04G12.3	C15H11.8
+M106.4	C15H11.8
+R01H10.1	C15H11.8
+R04F11.3	C15H11.8
+R05F9.6	C15H11.8
+R06C7.5	C15H11.8
+R07E4.4	C15H11.8
+R07H5.8	C15H11.8
+R134.1	C15H11.8
+R134.2	C15H11.8
+R151.2	C15H11.8
+R153.1	C15H11.8
+T01A4.1	C15H11.8
+T03D8.5	C15H11.8
+T03F1.8	C15H11.8
+T04A8.5	C15H11.8
+T04D3.3	C15H11.8
+T04D3.4	C15H11.8
+T14G10.1	C15H11.8
+T19B4.3	C15H11.8
+T22D1.3	C15H11.8
+T23G5.1	C15H11.8
+T24C4.5	C15H11.8
+T26C12.4	C15H11.8
+W01G7.3	C15H11.8
+W02D9.1	C15H11.8
+W03F11.2	C15H11.8
+W06E11.1	C15H11.8
+W09C3.4	C15H11.8
+Y105C5B.2	C15H11.8
+Y105E8B.5	C15H11.8
+Y10G11A.1	C15H11.8
+Y37E3.3	C15H11.8
+Y37H9A.6	C15H11.8
+Y43F4B.5	C15H11.8
+Y47D3A.29	C15H11.8
+Y48E1A.1	C15H11.8
+Y53F4B.3	C15H11.8
+Y54E10BR.6	C15H11.8
+Y56A3A.13	C15H11.8
+Y71H10B.1	C15H11.8
+Y77E11A.6	C15H11.8
+Y95B8A.10	C15H11.8
+Y97E10AR.5	C15H11.8
+ZC239.7	C15H11.8
+ZC395.7	C15H11.8
+ZC412.2	C15H11.8
+ZK455.2	C15H11.8
+ZK563.7	C15H11.8
+ZK593.1	C15H11.8
+ZK673.2	C15H11.8
+ZK856.10	C15H11.8
+ZK896.8	C15H11.8
+ZK909.3	C15H11.8
+ZK970.5	C15H11.8
+ZK970.6	C15H11.8
+C26E6.4	C17F4.6
+C27H5.1	C17F4.6
+C29E4.8	C17F4.6
+C30G4.3	C17F4.6
+C32E12.2	C17F4.6
+C36B1.3	C17F4.6
+C37H5.6	C17F4.6
+C42D4.8	C17F4.6
+C46E1.2	C17F4.6
+C48E7.2	C17F4.6
+C49H3.1	C17F4.6
+C55F2.1	C17F4.6
+E01F3.1	C17F4.6
+EEED8.8	C17F4.6
+F08B1.2	C17F4.6
+F08B4.5	C17F4.6
+F08C6.6	C17F4.6
+F09F7.3	C17F4.6
+F10C2.4	C17F4.6
+F10F2.2	C17F4.6
+F12F6.7	C17F4.6
+F14B4.3	C17F4.6
+F15E6.6	C17F4.6
+F17C8.1	C17F4.6
+F19G12.2	C17F4.6
+F21H7.9	C17F4.6
+F22E5.3	C17F4.6
+F23B2.13	C17F4.6
+F23H12.6	C17F4.6
+F25H2.5	C17F4.6
+F25H5.3	C17F4.6
+F26F4.11	C17F4.6
+F32D1.5	C17F4.6
+F33H2.5	C17F4.6
+F36A4.7	C17F4.6
+F38B2.4	C17F4.6
+F38B6.4	C17F4.6
+F43E2.2	C17F4.6
+F55B11.1	C17F4.6
+F58A4.4	C17F4.6
+F58A4.9	C17F4.6
+H27M09.2	C17F4.6
+H43I07.2	C17F4.6
+K02D7.1	C17F4.6
+K08H10.4	C17F4.6
+M04G12.3	C17F4.6
+M106.4	C17F4.6
+R01H10.1	C17F4.6
+R04F11.3	C17F4.6
+R05F9.6	C17F4.6
+R06C7.5	C17F4.6
+R07E4.4	C17F4.6
+R07H5.8	C17F4.6
+R134.1	C17F4.6
+R134.2	C17F4.6
+R151.2	C17F4.6
+R153.1	C17F4.6
+T01A4.1	C17F4.6
+T03D8.5	C17F4.6
+T03F1.8	C17F4.6
+T04A8.5	C17F4.6
+T04D3.3	C17F4.6
+T04D3.4	C17F4.6
+T14G10.1	C17F4.6
+T19B4.3	C17F4.6
+T22D1.3	C17F4.6
+T23G5.1	C17F4.6
+T24C4.5	C17F4.6
+T26C12.4	C17F4.6
+W01G7.3	C17F4.6
+W02D9.1	C17F4.6
+W03F11.2	C17F4.6
+W06E11.1	C17F4.6
+W09C3.4	C17F4.6
+Y105C5B.2	C17F4.6
+Y105E8B.5	C17F4.6
+Y10G11A.1	C17F4.6
+Y37E3.3	C17F4.6
+Y37H9A.6	C17F4.6
+Y43F4B.5	C17F4.6
+Y47D3A.29	C17F4.6
+Y48E1A.1	C17F4.6
+Y53F4B.3	C17F4.6
+Y54E10BR.6	C17F4.6
+Y56A3A.13	C17F4.6
+Y71H10B.1	C17F4.6
+Y77E11A.6	C17F4.6
+Y95B8A.10	C17F4.6
+Y97E10AR.5	C17F4.6
+ZC239.7	C17F4.6
+ZC395.7	C17F4.6
+ZC412.2	C17F4.6
+ZK455.2	C17F4.6
+ZK563.7	C17F4.6
+ZK593.1	C17F4.6
+ZK673.2	C17F4.6
+ZK856.10	C17F4.6
+ZK896.8	C17F4.6
+ZK909.3	C17F4.6
+ZK970.5	C17F4.6
+ZK970.6	C17F4.6
+C27H5.1	C26E6.4
+C29E4.8	C26E6.4
+C30G4.3	C26E6.4
+C32E12.2	C26E6.4
+C36B1.3	C26E6.4
+C37H5.6	C26E6.4
+C42D4.8	C26E6.4
+C46E1.2	C26E6.4
+C48E7.2	C26E6.4
+C49H3.1	C26E6.4
+C55F2.1	C26E6.4
+E01F3.1	C26E6.4
+EEED8.8	C26E6.4
+F08B1.2	C26E6.4
+F08B4.5	C26E6.4
+F08C6.6	C26E6.4
+F09F7.3	C26E6.4
+F10C2.4	C26E6.4
+F10F2.2	C26E6.4
+F12F6.7	C26E6.4
+F14B4.3	C26E6.4
+F15E6.6	C26E6.4
+F17C8.1	C26E6.4
+F19G12.2	C26E6.4
+F21H7.9	C26E6.4
+F22E5.3	C26E6.4
+F23B2.13	C26E6.4
+F23H12.6	C26E6.4
+F25H2.5	C26E6.4
+F25H5.3	C26E6.4
+F26F4.11	C26E6.4
+F32D1.5	C26E6.4
+F33H2.5	C26E6.4
+F36A4.7	C26E6.4
+F38B2.4	C26E6.4
+F38B6.4	C26E6.4
+F43E2.2	C26E6.4
+F55B11.1	C26E6.4
+F58A4.4	C26E6.4
+F58A4.9	C26E6.4
+H27M09.2	C26E6.4
+H43I07.2	C26E6.4
+K02D7.1	C26E6.4
+K08H10.4	C26E6.4
+M04G12.3	C26E6.4
+M106.4	C26E6.4
+R01H10.1	C26E6.4
+R04F11.3	C26E6.4
+R05F9.6	C26E6.4
+R06C7.5	C26E6.4
+R07E4.4	C26E6.4
+R07H5.8	C26E6.4
+R134.1	C26E6.4
+R134.2	C26E6.4
+R151.2	C26E6.4
+R153.1	C26E6.4
+T01A4.1	C26E6.4
+T03D8.5	C26E6.4
+T03F1.8	C26E6.4
+T04A8.5	C26E6.4
+T04D3.3	C26E6.4
+T04D3.4	C26E6.4
+T14G10.1	C26E6.4
+T19B4.3	C26E6.4
+T22D1.3	C26E6.4
+T23G5.1	C26E6.4
+T24C4.5	C26E6.4
+T26C12.4	C26E6.4
+W01G7.3	C26E6.4
+W02D9.1	C26E6.4
+W03F11.2	C26E6.4
+W06E11.1	C26E6.4
+W09C3.4	C26E6.4
+Y105C5B.2	C26E6.4
+Y105E8B.5	C26E6.4
+Y10G11A.1	C26E6.4
+Y37E3.3	C26E6.4
+Y37H9A.6	C26E6.4
+Y43F4B.5	C26E6.4
+Y47D3A.29	C26E6.4
+Y48E1A.1	C26E6.4
+Y53F4B.3	C26E6.4
+Y54E10BR.6	C26E6.4
+Y56A3A.13	C26E6.4
+Y71H10B.1	C26E6.4
+Y77E11A.6	C26E6.4
+Y95B8A.10	C26E6.4
+Y97E10AR.5	C26E6.4
+ZC239.7	C26E6.4
+ZC395.7	C26E6.4
+ZC412.2	C26E6.4
+ZK455.2	C26E6.4
+ZK563.7	C26E6.4
+ZK593.1	C26E6.4
+ZK673.2	C26E6.4
+ZK856.10	C26E6.4
+ZK896.8	C26E6.4
+ZK909.3	C26E6.4
+ZK970.5	C26E6.4
+ZK970.6	C26E6.4
+C29E4.8	C27H5.1
+C30G4.3	C27H5.1
+C32E12.2	C27H5.1
+C36B1.3	C27H5.1
+C37H5.6	C27H5.1
+C42D4.8	C27H5.1
+C46E1.2	C27H5.1
+C48E7.2	C27H5.1
+C49H3.1	C27H5.1
+C55F2.1	C27H5.1
+E01F3.1	C27H5.1
+EEED8.8	C27H5.1
+F08B1.2	C27H5.1
+F08B4.5	C27H5.1
+F08C6.6	C27H5.1
+F09F7.3	C27H5.1
+F10C2.4	C27H5.1
+F10F2.2	C27H5.1
+F12F6.7	C27H5.1
+F14B4.3	C27H5.1
+F15E6.6	C27H5.1
+F17C8.1	C27H5.1
+F19G12.2	C27H5.1
+F21H7.9	C27H5.1
+F22E5.3	C27H5.1
+F23B2.13	C27H5.1
+F23H12.6	C27H5.1
+F25H2.5	C27H5.1
+F25H5.3	C27H5.1
+F26F4.11	C27H5.1
+F32D1.5	C27H5.1
+F33H2.5	C27H5.1
+F36A4.7	C27H5.1
+F38B2.4	C27H5.1
+F38B6.4	C27H5.1
+F43E2.2	C27H5.1
+F55B11.1	C27H5.1
+F58A4.4	C27H5.1
+F58A4.9	C27H5.1
+H27M09.2	C27H5.1
+H43I07.2	C27H5.1
+K02D7.1	C27H5.1
+K08H10.4	C27H5.1
+M04G12.3	C27H5.1
+M106.4	C27H5.1
+R01H10.1	C27H5.1
+R04F11.3	C27H5.1
+R05F9.6	C27H5.1
+R06C7.5	C27H5.1
+R07E4.4	C27H5.1
+R07H5.8	C27H5.1
+R134.1	C27H5.1
+R134.2	C27H5.1
+R151.2	C27H5.1
+R153.1	C27H5.1
+T01A4.1	C27H5.1
+T03D8.5	C27H5.1
+T03F1.8	C27H5.1
+T04A8.5	C27H5.1
+T04D3.3	C27H5.1
+T04D3.4	C27H5.1
+T14G10.1	C27H5.1
+T19B4.3	C27H5.1
+T22D1.3	C27H5.1
+T23G5.1	C27H5.1
+T24C4.5	C27H5.1
+T26C12.4	C27H5.1
+W01G7.3	C27H5.1
+W02D9.1	C27H5.1
+W03F11.2	C27H5.1
+W06E11.1	C27H5.1
+W09C3.4	C27H5.1
+Y105C5B.2	C27H5.1
+Y105E8B.5	C27H5.1
+Y10G11A.1	C27H5.1
+Y37E3.3	C27H5.1
+Y37H9A.6	C27H5.1
+Y43F4B.5	C27H5.1
+Y47D3A.29	C27H5.1
+Y48E1A.1	C27H5.1
+Y53F4B.3	C27H5.1
+Y54E10BR.6	C27H5.1
+Y56A3A.13	C27H5.1
+Y71H10B.1	C27H5.1
+Y77E11A.6	C27H5.1
+Y95B8A.10	C27H5.1
+Y97E10AR.5	C27H5.1
+ZC239.7	C27H5.1
+ZC395.7	C27H5.1
+ZC412.2	C27H5.1
+ZK455.2	C27H5.1
+ZK563.7	C27H5.1
+ZK593.1	C27H5.1
+ZK673.2	C27H5.1
+ZK856.10	C27H5.1
+ZK896.8	C27H5.1
+ZK909.3	C27H5.1
+ZK970.5	C27H5.1
+ZK970.6	C27H5.1
+C30G4.3	C29E4.8
+C32E12.2	C29E4.8
+C36B1.3	C29E4.8
+C37H5.6	C29E4.8
+C42D4.8	C29E4.8
+C46E1.2	C29E4.8
+C48E7.2	C29E4.8
+C49H3.1	C29E4.8
+C55F2.1	C29E4.8
+E01F3.1	C29E4.8
+EEED8.8	C29E4.8
+F08B1.2	C29E4.8
+F08B4.5	C29E4.8
+F08C6.6	C29E4.8
+F09F7.3	C29E4.8
+F10C2.4	C29E4.8
+F10F2.2	C29E4.8
+F12F6.7	C29E4.8
+F14B4.3	C29E4.8
+F15E6.6	C29E4.8
+F17C8.1	C29E4.8
+F19G12.2	C29E4.8
+F21H7.9	C29E4.8
+F22E5.3	C29E4.8
+F23B2.13	C29E4.8
+F23H12.6	C29E4.8
+F25H2.5	C29E4.8
+F25H5.3	C29E4.8
+F26F4.11	C29E4.8
+F32D1.5	C29E4.8
+F33H2.5	C29E4.8
+F36A4.7	C29E4.8
+F38B2.4	C29E4.8
+F38B6.4	C29E4.8
+F43E2.2	C29E4.8
+F55B11.1	C29E4.8
+F58A4.4	C29E4.8
+F58A4.9	C29E4.8
+H27M09.2	C29E4.8
+H43I07.2	C29E4.8
+K02D7.1	C29E4.8
+K08H10.4	C29E4.8
+M04G12.3	C29E4.8
+M106.4	C29E4.8
+R01H10.1	C29E4.8
+R04F11.3	C29E4.8
+R05F9.6	C29E4.8
+R06C7.5	C29E4.8
+R07E4.4	C29E4.8
+R07H5.8	C29E4.8
+R134.1	C29E4.8
+R134.2	C29E4.8
+R151.2	C29E4.8
+R153.1	C29E4.8
+T01A4.1	C29E4.8
+T03D8.5	C29E4.8
+T03F1.8	C29E4.8
+T04A8.5	C29E4.8
+T04D3.3	C29E4.8
+T04D3.4	C29E4.8
+T14G10.1	C29E4.8
+T19B4.3	C29E4.8
+T22D1.3	C29E4.8
+T23G5.1	C29E4.8
+T24C4.5	C29E4.8
+T26C12.4	C29E4.8
+W01G7.3	C29E4.8
+W02D9.1	C29E4.8
+W03F11.2	C29E4.8
+W06E11.1	C29E4.8
+W09C3.4	C29E4.8
+Y105C5B.2	C29E4.8
+Y105E8B.5	C29E4.8
+Y10G11A.1	C29E4.8
+Y37E3.3	C29E4.8
+Y37H9A.6	C29E4.8
+Y43F4B.5	C29E4.8
+Y47D3A.29	C29E4.8
+Y48E1A.1	C29E4.8
+Y53F4B.3	C29E4.8
+Y54E10BR.6	C29E4.8
+Y56A3A.13	C29E4.8
+Y71H10B.1	C29E4.8
+Y77E11A.6	C29E4.8
+Y95B8A.10	C29E4.8
+Y97E10AR.5	C29E4.8
+ZC239.7	C29E4.8
+ZC395.7	C29E4.8
+ZC412.2	C29E4.8
+ZK455.2	C29E4.8
+ZK563.7	C29E4.8
+ZK593.1	C29E4.8
+ZK673.2	C29E4.8
+ZK856.10	C29E4.8
+ZK896.8	C29E4.8
+ZK909.3	C29E4.8
+ZK970.5	C29E4.8
+ZK970.6	C29E4.8
+C32E12.2	C30G4.3
+C36B1.3	C30G4.3
+C37H5.6	C30G4.3
+C42D4.8	C30G4.3
+C46E1.2	C30G4.3
+C48E7.2	C30G4.3
+C49H3.1	C30G4.3
+C55F2.1	C30G4.3
+E01F3.1	C30G4.3
+EEED8.8	C30G4.3
+F08B1.2	C30G4.3
+F08B4.5	C30G4.3
+F08C6.6	C30G4.3
+F09F7.3	C30G4.3
+F10C2.4	C30G4.3
+F10F2.2	C30G4.3
+F12F6.7	C30G4.3
+F14B4.3	C30G4.3
+F15E6.6	C30G4.3
+F17C8.1	C30G4.3
+F19G12.2	C30G4.3
+F21H7.9	C30G4.3
+F22E5.3	C30G4.3
+F23B2.13	C30G4.3
+F23H12.6	C30G4.3
+F25H2.5	C30G4.3
+F25H5.3	C30G4.3
+F26F4.11	C30G4.3
+F32D1.5	C30G4.3
+F33H2.5	C30G4.3
+F36A4.7	C30G4.3
+F38B2.4	C30G4.3
+F38B6.4	C30G4.3
+F43E2.2	C30G4.3
+F55B11.1	C30G4.3
+F58A4.4	C30G4.3
+F58A4.9	C30G4.3
+H27M09.2	C30G4.3
+H43I07.2	C30G4.3
+K02D7.1	C30G4.3
+K08H10.4	C30G4.3
+M04G12.3	C30G4.3
+M106.4	C30G4.3
+R01H10.1	C30G4.3
+R04F11.3	C30G4.3
+R05F9.6	C30G4.3
+R06C7.5	C30G4.3
+R07E4.4	C30G4.3
+R07H5.8	C30G4.3
+R134.1	C30G4.3
+R134.2	C30G4.3
+R151.2	C30G4.3
+R153.1	C30G4.3
+T01A4.1	C30G4.3
+T03D8.5	C30G4.3
+T03F1.8	C30G4.3
+T04A8.5	C30G4.3
+T04D3.3	C30G4.3
+T04D3.4	C30G4.3
+T14G10.1	C30G4.3
+T19B4.3	C30G4.3
+T22D1.3	C30G4.3
+T23G5.1	C30G4.3
+T24C4.5	C30G4.3
+T26C12.4	C30G4.3
+W01G7.3	C30G4.3
+W02D9.1	C30G4.3
+W03F11.2	C30G4.3
+W06E11.1	C30G4.3
+W09C3.4	C30G4.3
+Y105C5B.2	C30G4.3
+Y105E8B.5	C30G4.3
+Y10G11A.1	C30G4.3
+Y37E3.3	C30G4.3
+Y37H9A.6	C30G4.3
+Y43F4B.5	C30G4.3
+Y47D3A.29	C30G4.3
+Y48E1A.1	C30G4.3
+Y53F4B.3	C30G4.3
+Y54E10BR.6	C30G4.3
+Y56A3A.13	C30G4.3
+Y71H10B.1	C30G4.3
+Y77E11A.6	C30G4.3
+Y95B8A.10	C30G4.3
+Y97E10AR.5	C30G4.3
+ZC239.7	C30G4.3
+ZC395.7	C30G4.3
+ZC412.2	C30G4.3
+ZK455.2	C30G4.3
+ZK563.7	C30G4.3
+ZK593.1	C30G4.3
+ZK673.2	C30G4.3
+ZK856.10	C30G4.3
+ZK896.8	C30G4.3
+ZK909.3	C30G4.3
+ZK970.5	C30G4.3
+ZK970.6	C30G4.3
+C36B1.3	C32E12.2
+C37H5.6	C32E12.2
+C42D4.8	C32E12.2
+C46E1.2	C32E12.2
+C48E7.2	C32E12.2
+C49H3.1	C32E12.2
+C55F2.1	C32E12.2
+E01F3.1	C32E12.2
+EEED8.8	C32E12.2
+F08B1.2	C32E12.2
+F08B4.5	C32E12.2
+F08C6.6	C32E12.2
+F09F7.3	C32E12.2
+F10C2.4	C32E12.2
+F10F2.2	C32E12.2
+F12F6.7	C32E12.2
+F14B4.3	C32E12.2
+F15E6.6	C32E12.2
+F17C8.1	C32E12.2
+F19G12.2	C32E12.2
+F21H7.9	C32E12.2
+F22E5.3	C32E12.2
+F23B2.13	C32E12.2
+F23H12.6	C32E12.2
+F25H2.5	C32E12.2
+F25H5.3	C32E12.2
+F26F4.11	C32E12.2
+F32D1.5	C32E12.2
+F33H2.5	C32E12.2
+F36A4.7	C32E12.2
+F38B2.4	C32E12.2
+F38B6.4	C32E12.2
+F43E2.2	C32E12.2
+F55B11.1	C32E12.2
+F58A4.4	C32E12.2
+F58A4.9	C32E12.2
+H27M09.2	C32E12.2
+H43I07.2	C32E12.2
+K02D7.1	C32E12.2
+K08H10.4	C32E12.2
+M04G12.3	C32E12.2
+M106.4	C32E12.2
+R01H10.1	C32E12.2
+R04F11.3	C32E12.2
+R05F9.6	C32E12.2
+R06C7.5	C32E12.2
+R07E4.4	C32E12.2
+R07H5.8	C32E12.2
+R134.1	C32E12.2
+R134.2	C32E12.2
+R151.2	C32E12.2
+R153.1	C32E12.2
+T01A4.1	C32E12.2
+T03D8.5	C32E12.2
+T03F1.8	C32E12.2
+T04A8.5	C32E12.2
+T04D3.3	C32E12.2
+T04D3.4	C32E12.2
+T14G10.1	C32E12.2
+T19B4.3	C32E12.2
+T22D1.3	C32E12.2
+T23G5.1	C32E12.2
+T24C4.5	C32E12.2
+T26C12.4	C32E12.2
+W01G7.3	C32E12.2
+W02D9.1	C32E12.2
+W03F11.2	C32E12.2
+W06E11.1	C32E12.2
+W09C3.4	C32E12.2
+Y105C5B.2	C32E12.2
+Y105E8B.5	C32E12.2
+Y10G11A.1	C32E12.2
+Y37E3.3	C32E12.2
+Y37H9A.6	C32E12.2
+Y43F4B.5	C32E12.2
+Y47D3A.29	C32E12.2
+Y48E1A.1	C32E12.2
+Y53F4B.3	C32E12.2
+Y54E10BR.6	C32E12.2
+Y56A3A.13	C32E12.2
+Y71H10B.1	C32E12.2
+Y77E11A.6	C32E12.2
+Y95B8A.10	C32E12.2
+Y97E10AR.5	C32E12.2
+ZC239.7	C32E12.2
+ZC395.7	C32E12.2
+ZC412.2	C32E12.2
+ZK455.2	C32E12.2
+ZK563.7	C32E12.2
+ZK593.1	C32E12.2
+ZK673.2	C32E12.2
+ZK856.10	C32E12.2
+ZK896.8	C32E12.2
+ZK909.3	C32E12.2
+ZK970.5	C32E12.2
+ZK970.6	C32E12.2
+C37H5.6	C36B1.3
+C42D4.8	C36B1.3
+C46E1.2	C36B1.3
+C48E7.2	C36B1.3
+C49H3.1	C36B1.3
+C55F2.1	C36B1.3
+E01F3.1	C36B1.3
+EEED8.8	C36B1.3
+F08B1.2	C36B1.3
+F08B4.5	C36B1.3
+F08C6.6	C36B1.3
+F09F7.3	C36B1.3
+F10C2.4	C36B1.3
+F10F2.2	C36B1.3
+F12F6.7	C36B1.3
+F14B4.3	C36B1.3
+F15E6.6	C36B1.3
+F17C8.1	C36B1.3
+F19G12.2	C36B1.3
+F21H7.9	C36B1.3
+F22E5.3	C36B1.3
+F23B2.13	C36B1.3
+F23H12.6	C36B1.3
+F25H2.5	C36B1.3
+F25H5.3	C36B1.3
+F26F4.11	C36B1.3
+F32D1.5	C36B1.3
+F33H2.5	C36B1.3
+F36A4.7	C36B1.3
+F38B2.4	C36B1.3
+F38B6.4	C36B1.3
+F43E2.2	C36B1.3
+F55B11.1	C36B1.3
+F58A4.4	C36B1.3
+F58A4.9	C36B1.3
+H27M09.2	C36B1.3
+H43I07.2	C36B1.3
+K02D7.1	C36B1.3
+K08H10.4	C36B1.3
+M04G12.3	C36B1.3
+M106.4	C36B1.3
+R01H10.1	C36B1.3
+R04F11.3	C36B1.3
+R05F9.6	C36B1.3
+R06C7.5	C36B1.3
+R07E4.4	C36B1.3
+R07H5.8	C36B1.3
+R134.1	C36B1.3
+R134.2	C36B1.3
+R151.2	C36B1.3
+R153.1	C36B1.3
+T01A4.1	C36B1.3
+T03D8.5	C36B1.3
+T03F1.8	C36B1.3
+T04A8.5	C36B1.3
+T04D3.3	C36B1.3
+T04D3.4	C36B1.3
+T14G10.1	C36B1.3
+T19B4.3	C36B1.3
+T22D1.3	C36B1.3
+T23G5.1	C36B1.3
+T24C4.5	C36B1.3
+T26C12.4	C36B1.3
+W01G7.3	C36B1.3
+W02D9.1	C36B1.3
+W03F11.2	C36B1.3
+W06E11.1	C36B1.3
+W09C3.4	C36B1.3
+Y105C5B.2	C36B1.3
+Y105E8B.5	C36B1.3
+Y10G11A.1	C36B1.3
+Y37E3.3	C36B1.3
+Y37H9A.6	C36B1.3
+Y43F4B.5	C36B1.3
+Y47D3A.29	C36B1.3
+Y48E1A.1	C36B1.3
+Y53F4B.3	C36B1.3
+Y54E10BR.6	C36B1.3
+Y56A3A.13	C36B1.3
+Y71H10B.1	C36B1.3
+Y77E11A.6	C36B1.3
+Y95B8A.10	C36B1.3
+Y97E10AR.5	C36B1.3
+ZC239.7	C36B1.3
+ZC395.7	C36B1.3
+ZC412.2	C36B1.3
+ZK455.2	C36B1.3
+ZK563.7	C36B1.3
+ZK593.1	C36B1.3
+ZK673.2	C36B1.3
+ZK856.10	C36B1.3
+ZK896.8	C36B1.3
+ZK909.3	C36B1.3
+ZK970.5	C36B1.3
+ZK970.6	C36B1.3
+C42D4.8	C37H5.6
+C46E1.2	C37H5.6
+C48E7.2	C37H5.6
+C49H3.1	C37H5.6
+C55F2.1	C37H5.6
+E01F3.1	C37H5.6
+EEED8.8	C37H5.6
+F08B1.2	C37H5.6
+F08B4.5	C37H5.6
+F08C6.6	C37H5.6
+F09F7.3	C37H5.6
+F10C2.4	C37H5.6
+F10F2.2	C37H5.6
+F12F6.7	C37H5.6
+F14B4.3	C37H5.6
+F15E6.6	C37H5.6
+F17C8.1	C37H5.6
+F19G12.2	C37H5.6
+F21H7.9	C37H5.6
+F22E5.3	C37H5.6
+F23B2.13	C37H5.6
+F23H12.6	C37H5.6
+F25H2.5	C37H5.6
+F25H5.3	C37H5.6
+F26F4.11	C37H5.6
+F32D1.5	C37H5.6
+F33H2.5	C37H5.6
+F36A4.7	C37H5.6
+F38B2.4	C37H5.6
+F38B6.4	C37H5.6
+F43E2.2	C37H5.6
+F55B11.1	C37H5.6
+F58A4.4	C37H5.6
+F58A4.9	C37H5.6
+H27M09.2	C37H5.6
+H43I07.2	C37H5.6
+K02D7.1	C37H5.6
+K08H10.4	C37H5.6
+M04G12.3	C37H5.6
+M106.4	C37H5.6
+R01H10.1	C37H5.6
+R04F11.3	C37H5.6
+R05F9.6	C37H5.6
+R06C7.5	C37H5.6
+R07E4.4	C37H5.6
+R07H5.8	C37H5.6
+R134.1	C37H5.6
+R134.2	C37H5.6
+R151.2	C37H5.6
+R153.1	C37H5.6
+T01A4.1	C37H5.6
+T03D8.5	C37H5.6
+T03F1.8	C37H5.6
+T04A8.5	C37H5.6
+T04D3.3	C37H5.6
+T04D3.4	C37H5.6
+T14G10.1	C37H5.6
+T19B4.3	C37H5.6
+T22D1.3	C37H5.6
+T23G5.1	C37H5.6
+T24C4.5	C37H5.6
+T26C12.4	C37H5.6
+W01G7.3	C37H5.6
+W02D9.1	C37H5.6
+W03F11.2	C37H5.6
+W06E11.1	C37H5.6
+W09C3.4	C37H5.6
+Y105C5B.2	C37H5.6
+Y105E8B.5	C37H5.6
+Y10G11A.1	C37H5.6
+Y37E3.3	C37H5.6
+Y37H9A.6	C37H5.6
+Y43F4B.5	C37H5.6
+Y47D3A.29	C37H5.6
+Y48E1A.1	C37H5.6
+Y53F4B.3	C37H5.6
+Y54E10BR.6	C37H5.6
+Y56A3A.13	C37H5.6
+Y71H10B.1	C37H5.6
+Y77E11A.6	C37H5.6
+Y95B8A.10	C37H5.6
+Y97E10AR.5	C37H5.6
+ZC239.7	C37H5.6
+ZC395.7	C37H5.6
+ZC412.2	C37H5.6
+ZK455.2	C37H5.6
+ZK563.7	C37H5.6
+ZK593.1	C37H5.6
+ZK673.2	C37H5.6
+ZK856.10	C37H5.6
+ZK896.8	C37H5.6
+ZK909.3	C37H5.6
+ZK970.5	C37H5.6
+ZK970.6	C37H5.6
+C46E1.2	C42D4.8
+C48E7.2	C42D4.8
+C49H3.1	C42D4.8
+C55F2.1	C42D4.8
+E01F3.1	C42D4.8
+EEED8.8	C42D4.8
+F08B1.2	C42D4.8
+F08B4.5	C42D4.8
+F08C6.6	C42D4.8
+F09F7.3	C42D4.8
+F10C2.4	C42D4.8
+F10F2.2	C42D4.8
+F12F6.7	C42D4.8
+F14B4.3	C42D4.8
+F15E6.6	C42D4.8
+F17C8.1	C42D4.8
+F19G12.2	C42D4.8
+F21H7.9	C42D4.8
+F22E5.3	C42D4.8
+F23B2.13	C42D4.8
+F23H12.6	C42D4.8
+F25H2.5	C42D4.8
+F25H5.3	C42D4.8
+F26F4.11	C42D4.8
+F32D1.5	C42D4.8
+F33H2.5	C42D4.8
+F36A4.7	C42D4.8
+F38B2.4	C42D4.8
+F38B6.4	C42D4.8
+F43E2.2	C42D4.8
+F55B11.1	C42D4.8
+F58A4.4	C42D4.8
+F58A4.9	C42D4.8
+H27M09.2	C42D4.8
+H43I07.2	C42D4.8
+K02D7.1	C42D4.8
+K08H10.4	C42D4.8
+M04G12.3	C42D4.8
+M106.4	C42D4.8
+R01H10.1	C42D4.8
+R04F11.3	C42D4.8
+R05F9.6	C42D4.8
+R06C7.5	C42D4.8
+R07E4.4	C42D4.8
+R07H5.8	C42D4.8
+R134.1	C42D4.8
+R134.2	C42D4.8
+R151.2	C42D4.8
+R153.1	C42D4.8
+T01A4.1	C42D4.8
+T03D8.5	C42D4.8
+T03F1.8	C42D4.8
+T04A8.5	C42D4.8
+T04D3.3	C42D4.8
+T04D3.4	C42D4.8
+T14G10.1	C42D4.8
+T19B4.3	C42D4.8
+T22D1.3	C42D4.8
+T23G5.1	C42D4.8
+T24C4.5	C42D4.8
+T26C12.4	C42D4.8
+W01G7.3	C42D4.8
+W02D9.1	C42D4.8
+W03F11.2	C42D4.8
+W06E11.1	C42D4.8
+W09C3.4	C42D4.8
+Y105C5B.2	C42D4.8
+Y105E8B.5	C42D4.8
+Y10G11A.1	C42D4.8
+Y37E3.3	C42D4.8
+Y37H9A.6	C42D4.8
+Y43F4B.5	C42D4.8
+Y47D3A.29	C42D4.8
+Y48E1A.1	C42D4.8
+Y53F4B.3	C42D4.8
+Y54E10BR.6	C42D4.8
+Y56A3A.13	C42D4.8
+Y71H10B.1	C42D4.8
+Y77E11A.6	C42D4.8
+Y95B8A.10	C42D4.8
+Y97E10AR.5	C42D4.8
+ZC239.7	C42D4.8
+ZC395.7	C42D4.8
+ZC412.2	C42D4.8
+ZK455.2	C42D4.8
+ZK563.7	C42D4.8
+ZK593.1	C42D4.8
+ZK673.2	C42D4.8
+ZK856.10	C42D4.8
+ZK896.8	C42D4.8
+ZK909.3	C42D4.8
+ZK970.5	C42D4.8
+ZK970.6	C42D4.8
+C48E7.2	C46E1.2
+C49H3.1	C46E1.2
+C55F2.1	C46E1.2
+E01F3.1	C46E1.2
+EEED8.8	C46E1.2
+F08B1.2	C46E1.2
+F08B4.5	C46E1.2
+F08C6.6	C46E1.2
+F09F7.3	C46E1.2
+F10C2.4	C46E1.2
+F10F2.2	C46E1.2
+F12F6.7	C46E1.2
+F14B4.3	C46E1.2
+F15E6.6	C46E1.2
+F17C8.1	C46E1.2
+F19G12.2	C46E1.2
+F21H7.9	C46E1.2
+F22E5.3	C46E1.2
+F23B2.13	C46E1.2
+F23H12.6	C46E1.2
+F25H2.5	C46E1.2
+F25H5.3	C46E1.2
+F26F4.11	C46E1.2
+F32D1.5	C46E1.2
+F33H2.5	C46E1.2
+F36A4.7	C46E1.2
+F38B2.4	C46E1.2
+F38B6.4	C46E1.2
+F43E2.2	C46E1.2
+F55B11.1	C46E1.2
+F58A4.4	C46E1.2
+F58A4.9	C46E1.2
+H27M09.2	C46E1.2
+H43I07.2	C46E1.2
+K02D7.1	C46E1.2
+K08H10.4	C46E1.2
+M04G12.3	C46E1.2
+M106.4	C46E1.2
+R01H10.1	C46E1.2
+R04F11.3	C46E1.2
+R05F9.6	C46E1.2
+R06C7.5	C46E1.2
+R07E4.4	C46E1.2
+R07H5.8	C46E1.2
+R134.1	C46E1.2
+R134.2	C46E1.2
+R151.2	C46E1.2
+R153.1	C46E1.2
+T01A4.1	C46E1.2
+T03D8.5	C46E1.2
+T03F1.8	C46E1.2
+T04A8.5	C46E1.2
+T04D3.3	C46E1.2
+T04D3.4	C46E1.2
+T14G10.1	C46E1.2
+T19B4.3	C46E1.2
+T22D1.3	C46E1.2
+T23G5.1	C46E1.2
+T24C4.5	C46E1.2
+T26C12.4	C46E1.2
+W01G7.3	C46E1.2
+W02D9.1	C46E1.2
+W03F11.2	C46E1.2
+W06E11.1	C46E1.2
+W09C3.4	C46E1.2
+Y105C5B.2	C46E1.2
+Y105E8B.5	C46E1.2
+Y10G11A.1	C46E1.2
+Y37E3.3	C46E1.2
+Y37H9A.6	C46E1.2
+Y43F4B.5	C46E1.2
+Y47D3A.29	C46E1.2
+Y48E1A.1	C46E1.2
+Y53F4B.3	C46E1.2
+Y54E10BR.6	C46E1.2
+Y56A3A.13	C46E1.2
+Y71H10B.1	C46E1.2
+Y77E11A.6	C46E1.2
+Y95B8A.10	C46E1.2
+Y97E10AR.5	C46E1.2
+ZC239.7	C46E1.2
+ZC395.7	C46E1.2
+ZC412.2	C46E1.2
+ZK455.2	C46E1.2
+ZK563.7	C46E1.2
+ZK593.1	C46E1.2
+ZK673.2	C46E1.2
+ZK856.10	C46E1.2
+ZK896.8	C46E1.2
+ZK909.3	C46E1.2
+ZK970.5	C46E1.2
+ZK970.6	C46E1.2
+C49H3.1	C48E7.2
+C55F2.1	C48E7.2
+E01F3.1	C48E7.2
+EEED8.8	C48E7.2
+F08B1.2	C48E7.2
+F08B4.5	C48E7.2
+F08C6.6	C48E7.2
+F09F7.3	C48E7.2
+F10C2.4	C48E7.2
+F10F2.2	C48E7.2
+F12F6.7	C48E7.2
+F14B4.3	C48E7.2
+F15E6.6	C48E7.2
+F17C8.1	C48E7.2
+F19G12.2	C48E7.2
+F21H7.9	C48E7.2
+F22E5.3	C48E7.2
+F23B2.13	C48E7.2
+F23H12.6	C48E7.2
+F25H2.5	C48E7.2
+F25H5.3	C48E7.2
+F26F4.11	C48E7.2
+F32D1.5	C48E7.2
+F33H2.5	C48E7.2
+F36A4.7	C48E7.2
+F38B2.4	C48E7.2
+F38B6.4	C48E7.2
+F43E2.2	C48E7.2
+F55B11.1	C48E7.2
+F58A4.4	C48E7.2
+F58A4.9	C48E7.2
+H27M09.2	C48E7.2
+H43I07.2	C48E7.2
+K02D7.1	C48E7.2
+K08H10.4	C48E7.2
+M04G12.3	C48E7.2
+M106.4	C48E7.2
+R01H10.1	C48E7.2
+R04F11.3	C48E7.2
+R05F9.6	C48E7.2
+R06C7.5	C48E7.2
+R07E4.4	C48E7.2
+R07H5.8	C48E7.2
+R134.1	C48E7.2
+R134.2	C48E7.2
+R151.2	C48E7.2
+R153.1	C48E7.2
+T01A4.1	C48E7.2
+T03D8.5	C48E7.2
+T03F1.8	C48E7.2
+T04A8.5	C48E7.2
+T04D3.3	C48E7.2
+T04D3.4	C48E7.2
+T14G10.1	C48E7.2
+T19B4.3	C48E7.2
+T22D1.3	C48E7.2
+T23G5.1	C48E7.2
+T24C4.5	C48E7.2
+T26C12.4	C48E7.2
+W01G7.3	C48E7.2
+W02D9.1	C48E7.2
+W03F11.2	C48E7.2
+W06E11.1	C48E7.2
+W09C3.4	C48E7.2
+Y105C5B.2	C48E7.2
+Y105E8B.5	C48E7.2
+Y10G11A.1	C48E7.2
+Y37E3.3	C48E7.2
+Y37H9A.6	C48E7.2
+Y43F4B.5	C48E7.2
+Y47D3A.29	C48E7.2
+Y48E1A.1	C48E7.2
+Y53F4B.3	C48E7.2
+Y54E10BR.6	C48E7.2
+Y56A3A.13	C48E7.2
+Y71H10B.1	C48E7.2
+Y77E11A.6	C48E7.2
+Y95B8A.10	C48E7.2
+Y97E10AR.5	C48E7.2
+ZC239.7	C48E7.2
+ZC395.7	C48E7.2
+ZC412.2	C48E7.2
+ZK455.2	C48E7.2
+ZK563.7	C48E7.2
+ZK593.1	C48E7.2
+ZK673.2	C48E7.2
+ZK856.10	C48E7.2
+ZK896.8	C48E7.2
+ZK909.3	C48E7.2
+ZK970.5	C48E7.2
+ZK970.6	C48E7.2
+C55F2.1	C49H3.1
+E01F3.1	C49H3.1
+EEED8.8	C49H3.1
+F08B1.2	C49H3.1
+F08B4.5	C49H3.1
+F08C6.6	C49H3.1
+F09F7.3	C49H3.1
+F10C2.4	C49H3.1
+F10F2.2	C49H3.1
+F12F6.7	C49H3.1
+F14B4.3	C49H3.1
+F15E6.6	C49H3.1
+F17C8.1	C49H3.1
+F19G12.2	C49H3.1
+F21H7.9	C49H3.1
+F22E5.3	C49H3.1
+F23B2.13	C49H3.1
+F23H12.6	C49H3.1
+F25H2.5	C49H3.1
+F25H5.3	C49H3.1
+F26F4.11	C49H3.1
+F32D1.5	C49H3.1
+F33H2.5	C49H3.1
+F36A4.7	C49H3.1
+F38B2.4	C49H3.1
+F38B6.4	C49H3.1
+F43E2.2	C49H3.1
+F55B11.1	C49H3.1
+F58A4.4	C49H3.1
+F58A4.9	C49H3.1
+H27M09.2	C49H3.1
+H43I07.2	C49H3.1
+K02D7.1	C49H3.1
+K08H10.4	C49H3.1
+M04G12.3	C49H3.1
+M106.4	C49H3.1
+R01H10.1	C49H3.1
+R04F11.3	C49H3.1
+R05F9.6	C49H3.1
+R06C7.5	C49H3.1
+R07E4.4	C49H3.1
+R07H5.8	C49H3.1
+R134.1	C49H3.1
+R134.2	C49H3.1
+R151.2	C49H3.1
+R153.1	C49H3.1
+T01A4.1	C49H3.1
+T03D8.5	C49H3.1
+T03F1.8	C49H3.1
+T04A8.5	C49H3.1
+T04D3.3	C49H3.1
+T04D3.4	C49H3.1
+T14G10.1	C49H3.1
+T19B4.3	C49H3.1
+T22D1.3	C49H3.1
+T23G5.1	C49H3.1
+T24C4.5	C49H3.1
+W01G7.3	C49H3.1
+W02D9.1	C49H3.1
+W03F11.2	C49H3.1
+W06E11.1	C49H3.1
+W09C3.4	C49H3.1
+Y105C5B.2	C49H3.1
+Y105E8B.5	C49H3.1
+Y10G11A.1	C49H3.1
+Y37E3.3	C49H3.1
+Y37H9A.6	C49H3.1
+Y43F4B.5	C49H3.1
+Y47D3A.29	C49H3.1
+Y48E1A.1	C49H3.1
+Y53F4B.3	C49H3.1
+Y54E10BR.6	C49H3.1
+Y56A3A.13	C49H3.1
+Y71H10B.1	C49H3.1
+Y77E11A.6	C49H3.1
+Y95B8A.10	C49H3.1
+Y97E10AR.5	C49H3.1
+ZC239.7	C49H3.1
+ZC395.7	C49H3.1
+ZC412.2	C49H3.1
+ZK455.2	C49H3.1
+ZK563.7	C49H3.1
+ZK593.1	C49H3.1
+ZK673.2	C49H3.1
+ZK856.10	C49H3.1
+ZK909.3	C49H3.1
+ZK970.5	C49H3.1
+ZK970.6	C49H3.1
+E01F3.1	C55F2.1
+EEED8.8	C55F2.1
+F08B1.2	C55F2.1
+F08B4.5	C55F2.1
+F08C6.6	C55F2.1
+F09F7.3	C55F2.1
+F10C2.4	C55F2.1
+F10F2.2	C55F2.1
+F12F6.7	C55F2.1
+F14B4.3	C55F2.1
+F15E6.6	C55F2.1
+F17C8.1	C55F2.1
+F19G12.2	C55F2.1
+F21H7.9	C55F2.1
+F22E5.3	C55F2.1
+F23B2.13	C55F2.1
+F23H12.6	C55F2.1
+F25H2.5	C55F2.1
+F25H5.3	C55F2.1
+F26F4.11	C55F2.1
+F32D1.5	C55F2.1
+F33H2.5	C55F2.1
+F36A4.7	C55F2.1
+F38B2.4	C55F2.1
+F38B6.4	C55F2.1
+F43E2.2	C55F2.1
+F55B11.1	C55F2.1
+F58A4.4	C55F2.1
+F58A4.9	C55F2.1
+H27M09.2	C55F2.1
+H43I07.2	C55F2.1
+K02D7.1	C55F2.1
+K08H10.4	C55F2.1
+M04G12.3	C55F2.1
+M106.4	C55F2.1
+R01H10.1	C55F2.1
+R04F11.3	C55F2.1
+R05F9.6	C55F2.1
+R06C7.5	C55F2.1
+R07E4.4	C55F2.1
+R07H5.8	C55F2.1
+R134.1	C55F2.1
+R134.2	C55F2.1
+R151.2	C55F2.1
+R153.1	C55F2.1
+T01A4.1	C55F2.1
+T03D8.5	C55F2.1
+T03F1.8	C55F2.1
+T04A8.5	C55F2.1
+T04D3.3	C55F2.1
+T04D3.4	C55F2.1
+T14G10.1	C55F2.1
+T19B4.3	C55F2.1
+T22D1.3	C55F2.1
+T23G5.1	C55F2.1
+T24C4.5	C55F2.1
+T26C12.4	C55F2.1
+W01G7.3	C55F2.1
+W02D9.1	C55F2.1
+W03F11.2	C55F2.1
+W06E11.1	C55F2.1
+W09C3.4	C55F2.1
+Y105C5B.2	C55F2.1
+Y105E8B.5	C55F2.1
+Y10G11A.1	C55F2.1
+Y37E3.3	C55F2.1
+Y37H9A.6	C55F2.1
+Y43F4B.5	C55F2.1
+Y47D3A.29	C55F2.1
+Y48E1A.1	C55F2.1
+Y53F4B.3	C55F2.1
+Y54E10BR.6	C55F2.1
+Y56A3A.13	C55F2.1
+Y71H10B.1	C55F2.1
+Y77E11A.6	C55F2.1
+Y95B8A.10	C55F2.1
+Y97E10AR.5	C55F2.1
+ZC239.7	C55F2.1
+ZC395.7	C55F2.1
+ZC412.2	C55F2.1
+ZK455.2	C55F2.1
+ZK563.7	C55F2.1
+ZK593.1	C55F2.1
+ZK673.2	C55F2.1
+ZK856.10	C55F2.1
+ZK896.8	C55F2.1
+ZK909.3	C55F2.1
+ZK970.5	C55F2.1
+ZK970.6	C55F2.1
+EEED8.8	E01F3.1
+F08B1.2	E01F3.1
+F08B4.5	E01F3.1
+F08C6.6	E01F3.1
+F09F7.3	E01F3.1
+F10C2.4	E01F3.1
+F10F2.2	E01F3.1
+F12F6.7	E01F3.1
+F14B4.3	E01F3.1
+F15E6.6	E01F3.1
+F17C8.1	E01F3.1
+F19G12.2	E01F3.1
+F21H7.9	E01F3.1
+F22E5.3	E01F3.1
+F23B2.13	E01F3.1
+F23H12.6	E01F3.1
+F25H2.5	E01F3.1
+F25H5.3	E01F3.1
+F26F4.11	E01F3.1
+F32D1.5	E01F3.1
+F33H2.5	E01F3.1
+F36A4.7	E01F3.1
+F38B2.4	E01F3.1
+F38B6.4	E01F3.1
+F43E2.2	E01F3.1
+F55B11.1	E01F3.1
+F58A4.4	E01F3.1
+F58A4.9	E01F3.1
+H27M09.2	E01F3.1
+H43I07.2	E01F3.1
+K02D7.1	E01F3.1
+K08H10.4	E01F3.1
+M04G12.3	E01F3.1
+M106.4	E01F3.1
+R01H10.1	E01F3.1
+R04F11.3	E01F3.1
+R05F9.6	E01F3.1
+R06C7.5	E01F3.1
+R07E4.4	E01F3.1
+R07H5.8	E01F3.1
+R134.1	E01F3.1
+R134.2	E01F3.1
+R151.2	E01F3.1
+R153.1	E01F3.1
+T01A4.1	E01F3.1
+T03D8.5	E01F3.1
+T03F1.8	E01F3.1
+T04A8.5	E01F3.1
+T04D3.3	E01F3.1
+T04D3.4	E01F3.1
+T14G10.1	E01F3.1
+T19B4.3	E01F3.1
+T22D1.3	E01F3.1
+T23G5.1	E01F3.1
+T24C4.5	E01F3.1
+T26C12.4	E01F3.1
+W01G7.3	E01F3.1
+W02D9.1	E01F3.1
+W03F11.2	E01F3.1
+W06E11.1	E01F3.1
+W09C3.4	E01F3.1
+Y105C5B.2	E01F3.1
+Y105E8B.5	E01F3.1
+Y10G11A.1	E01F3.1
+Y37E3.3	E01F3.1
+Y37H9A.6	E01F3.1
+Y43F4B.5	E01F3.1
+Y47D3A.29	E01F3.1
+Y48E1A.1	E01F3.1
+Y53F4B.3	E01F3.1
+Y54E10BR.6	E01F3.1
+Y56A3A.13	E01F3.1
+Y71H10B.1	E01F3.1
+Y77E11A.6	E01F3.1
+Y95B8A.10	E01F3.1
+Y97E10AR.5	E01F3.1
+ZC239.7	E01F3.1
+ZC395.7	E01F3.1
+ZC412.2	E01F3.1
+ZK455.2	E01F3.1
+ZK563.7	E01F3.1
+ZK593.1	E01F3.1
+ZK673.2	E01F3.1
+ZK856.10	E01F3.1
+ZK896.8	E01F3.1
+ZK909.3	E01F3.1
+ZK970.5	E01F3.1
+ZK970.6	E01F3.1
+F08B1.2	EEED8.8
+F08B4.5	EEED8.8
+F08C6.6	EEED8.8
+F09F7.3	EEED8.8
+F10C2.4	EEED8.8
+F10F2.2	EEED8.8
+F12F6.7	EEED8.8
+F14B4.3	EEED8.8
+F15E6.6	EEED8.8
+F17C8.1	EEED8.8
+F19G12.2	EEED8.8
+F21H7.9	EEED8.8
+F22E5.3	EEED8.8
+F23B2.13	EEED8.8
+F23H12.6	EEED8.8
+F25H2.5	EEED8.8
+F25H5.3	EEED8.8
+F26F4.11	EEED8.8
+F32D1.5	EEED8.8
+F33H2.5	EEED8.8
+F36A4.7	EEED8.8
+F38B2.4	EEED8.8
+F38B6.4	EEED8.8
+F43E2.2	EEED8.8
+F55B11.1	EEED8.8
+F58A4.4	EEED8.8
+F58A4.9	EEED8.8
+H27M09.2	EEED8.8
+H43I07.2	EEED8.8
+K02D7.1	EEED8.8
+K08H10.4	EEED8.8
+M04G12.3	EEED8.8
+M106.4	EEED8.8
+R01H10.1	EEED8.8
+R04F11.3	EEED8.8
+R05F9.6	EEED8.8
+R06C7.5	EEED8.8
+R07E4.4	EEED8.8
+R07H5.8	EEED8.8
+R134.1	EEED8.8
+R134.2	EEED8.8
+R151.2	EEED8.8
+R153.1	EEED8.8
+T01A4.1	EEED8.8
+T03D8.5	EEED8.8
+T03F1.8	EEED8.8
+T04A8.5	EEED8.8
+T04D3.3	EEED8.8
+T04D3.4	EEED8.8
+T14G10.1	EEED8.8
+T19B4.3	EEED8.8
+T22D1.3	EEED8.8
+T23G5.1	EEED8.8
+T24C4.5	EEED8.8
+T26C12.4	EEED8.8
+W01G7.3	EEED8.8
+W02D9.1	EEED8.8
+W03F11.2	EEED8.8
+W06E11.1	EEED8.8
+W09C3.4	EEED8.8
+Y105C5B.2	EEED8.8
+Y105E8B.5	EEED8.8
+Y10G11A.1	EEED8.8
+Y37E3.3	EEED8.8
+Y37H9A.6	EEED8.8
+Y43F4B.5	EEED8.8
+Y47D3A.29	EEED8.8
+Y48E1A.1	EEED8.8
+Y53F4B.3	EEED8.8
+Y54E10BR.6	EEED8.8
+Y56A3A.13	EEED8.8
+Y71H10B.1	EEED8.8
+Y77E11A.6	EEED8.8
+Y95B8A.10	EEED8.8
+Y97E10AR.5	EEED8.8
+ZC239.7	EEED8.8
+ZC395.7	EEED8.8
+ZC412.2	EEED8.8
+ZK455.2	EEED8.8
+ZK563.7	EEED8.8
+ZK593.1	EEED8.8
+ZK673.2	EEED8.8
+ZK856.10	EEED8.8
+ZK896.8	EEED8.8
+ZK909.3	EEED8.8
+ZK970.5	EEED8.8
+ZK970.6	EEED8.8
+F08B4.5	F08B1.2
+F08C6.6	F08B1.2
+F09F7.3	F08B1.2
+F10C2.4	F08B1.2
+F10F2.2	F08B1.2
+F12F6.7	F08B1.2
+F14B4.3	F08B1.2
+F15E6.6	F08B1.2
+F17C8.1	F08B1.2
+F19G12.2	F08B1.2
+F21H7.9	F08B1.2
+F22E5.3	F08B1.2
+F23B2.13	F08B1.2
+F23H12.6	F08B1.2
+F25H2.5	F08B1.2
+F25H5.3	F08B1.2
+F26F4.11	F08B1.2
+F32D1.5	F08B1.2
+F33H2.5	F08B1.2
+F36A4.7	F08B1.2
+F38B2.4	F08B1.2
+F38B6.4	F08B1.2
+F43E2.2	F08B1.2
+F55B11.1	F08B1.2
+F58A4.4	F08B1.2
+F58A4.9	F08B1.2
+H27M09.2	F08B1.2
+H43I07.2	F08B1.2
+K02D7.1	F08B1.2
+K08H10.4	F08B1.2
+M04G12.3	F08B1.2
+M106.4	F08B1.2
+R01H10.1	F08B1.2
+R04F11.3	F08B1.2
+R05F9.6	F08B1.2
+R06C7.5	F08B1.2
+R07E4.4	F08B1.2
+R07H5.8	F08B1.2
+R134.1	F08B1.2
+R134.2	F08B1.2
+R151.2	F08B1.2
+R153.1	F08B1.2
+T03D8.5	F08B1.2
+T03F1.8	F08B1.2
+T04A8.5	F08B1.2
+T04D3.3	F08B1.2
+T04D3.4	F08B1.2
+T14G10.1	F08B1.2
+T19B4.3	F08B1.2
+T22D1.3	F08B1.2
+T23G5.1	F08B1.2
+T24C4.5	F08B1.2
+T26C12.4	F08B1.2
+W01G7.3	F08B1.2
+W02D9.1	F08B1.2
+W03F11.2	F08B1.2
+W06E11.1	F08B1.2
+W09C3.4	F08B1.2
+Y105C5B.2	F08B1.2
+Y105E8B.5	F08B1.2
+Y10G11A.1	F08B1.2
+Y37E3.3	F08B1.2
+Y37H9A.6	F08B1.2
+Y43F4B.5	F08B1.2
+Y47D3A.29	F08B1.2
+Y48E1A.1	F08B1.2
+Y53F4B.3	F08B1.2
+Y54E10BR.6	F08B1.2
+Y56A3A.13	F08B1.2
+Y71H10B.1	F08B1.2
+Y77E11A.6	F08B1.2
+Y95B8A.10	F08B1.2
+Y97E10AR.5	F08B1.2
+ZC239.7	F08B1.2
+ZC395.7	F08B1.2
+ZC412.2	F08B1.2
+ZK455.2	F08B1.2
+ZK563.7	F08B1.2
+ZK593.1	F08B1.2
+ZK673.2	F08B1.2
+ZK856.10	F08B1.2
+ZK896.8	F08B1.2
+ZK909.3	F08B1.2
+ZK970.5	F08B1.2
+ZK970.6	F08B1.2
+F08C6.6	F08B4.5
+F09F7.3	F08B4.5
+F10C2.4	F08B4.5
+F10F2.2	F08B4.5
+F12F6.7	F08B4.5
+F14B4.3	F08B4.5
+F15E6.6	F08B4.5
+F17C8.1	F08B4.5
+F19G12.2	F08B4.5
+F21H7.9	F08B4.5
+F22E5.3	F08B4.5
+F23B2.13	F08B4.5
+F23H12.6	F08B4.5
+F25H2.5	F08B4.5
+F25H5.3	F08B4.5
+F26F4.11	F08B4.5
+F32D1.5	F08B4.5
+F33H2.5	F08B4.5
+F36A4.7	F08B4.5
+F38B2.4	F08B4.5
+F38B6.4	F08B4.5
+F43E2.2	F08B4.5
+F55B11.1	F08B4.5
+F58A4.4	F08B4.5
+F58A4.9	F08B4.5
+H27M09.2	F08B4.5
+H43I07.2	F08B4.5
+K02D7.1	F08B4.5
+K08H10.4	F08B4.5
+M04G12.3	F08B4.5
+M106.4	F08B4.5
+R01H10.1	F08B4.5
+R04F11.3	F08B4.5
+R05F9.6	F08B4.5
+R06C7.5	F08B4.5
+R07E4.4	F08B4.5
+R07H5.8	F08B4.5
+R134.1	F08B4.5
+R134.2	F08B4.5
+R151.2	F08B4.5
+R153.1	F08B4.5
+T01A4.1	F08B4.5
+T03D8.5	F08B4.5
+T03F1.8	F08B4.5
+T04A8.5	F08B4.5
+T04D3.3	F08B4.5
+T04D3.4	F08B4.5
+T14G10.1	F08B4.5
+T19B4.3	F08B4.5
+T22D1.3	F08B4.5
+T23G5.1	F08B4.5
+T24C4.5	F08B4.5
+T26C12.4	F08B4.5
+W01G7.3	F08B4.5
+W02D9.1	F08B4.5
+W03F11.2	F08B4.5
+W06E11.1	F08B4.5
+W09C3.4	F08B4.5
+Y105C5B.2	F08B4.5
+Y105E8B.5	F08B4.5
+Y10G11A.1	F08B4.5
+Y37E3.3	F08B4.5
+Y37H9A.6	F08B4.5
+Y43F4B.5	F08B4.5
+Y47D3A.29	F08B4.5
+Y48E1A.1	F08B4.5
+Y53F4B.3	F08B4.5
+Y54E10BR.6	F08B4.5
+Y56A3A.13	F08B4.5
+Y71H10B.1	F08B4.5
+Y77E11A.6	F08B4.5
+Y95B8A.10	F08B4.5
+Y97E10AR.5	F08B4.5
+ZC239.7	F08B4.5
+ZC395.7	F08B4.5
+ZC412.2	F08B4.5
+ZK455.2	F08B4.5
+ZK563.7	F08B4.5
+ZK593.1	F08B4.5
+ZK673.2	F08B4.5
+ZK856.10	F08B4.5
+ZK896.8	F08B4.5
+ZK909.3	F08B4.5
+ZK970.5	F08B4.5
+ZK970.6	F08B4.5
+F09F7.3	F08C6.6
+F10C2.4	F08C6.6
+F10F2.2	F08C6.6
+F12F6.7	F08C6.6
+F14B4.3	F08C6.6
+F15E6.6	F08C6.6
+F17C8.1	F08C6.6
+F19G12.2	F08C6.6
+F21H7.9	F08C6.6
+F22E5.3	F08C6.6
+F23B2.13	F08C6.6
+F23H12.6	F08C6.6
+F25H2.5	F08C6.6
+F25H5.3	F08C6.6
+F26F4.11	F08C6.6
+F32D1.5	F08C6.6
+F33H2.5	F08C6.6
+F36A4.7	F08C6.6
+F38B2.4	F08C6.6
+F38B6.4	F08C6.6
+F43E2.2	F08C6.6
+F55B11.1	F08C6.6
+F58A4.4	F08C6.6
+F58A4.9	F08C6.6
+H27M09.2	F08C6.6
+H43I07.2	F08C6.6
+K02D7.1	F08C6.6
+K08H10.4	F08C6.6
+M04G12.3	F08C6.6
+M106.4	F08C6.6
+R01H10.1	F08C6.6
+R04F11.3	F08C6.6
+R05F9.6	F08C6.6
+R06C7.5	F08C6.6
+R07E4.4	F08C6.6
+R07H5.8	F08C6.6
+R134.1	F08C6.6
+R134.2	F08C6.6
+R151.2	F08C6.6
+R153.1	F08C6.6
+T01A4.1	F08C6.6
+T03D8.5	F08C6.6
+T03F1.8	F08C6.6
+T04A8.5	F08C6.6
+T04D3.3	F08C6.6
+T04D3.4	F08C6.6
+T14G10.1	F08C6.6
+T19B4.3	F08C6.6
+T22D1.3	F08C6.6
+T23G5.1	F08C6.6
+T24C4.5	F08C6.6
+T26C12.4	F08C6.6
+W01G7.3	F08C6.6
+W02D9.1	F08C6.6
+W03F11.2	F08C6.6
+W06E11.1	F08C6.6
+W09C3.4	F08C6.6
+Y105C5B.2	F08C6.6
+Y105E8B.5	F08C6.6
+Y10G11A.1	F08C6.6
+Y37E3.3	F08C6.6
+Y37H9A.6	F08C6.6
+Y43F4B.5	F08C6.6
+Y47D3A.29	F08C6.6
+Y48E1A.1	F08C6.6
+Y53F4B.3	F08C6.6
+Y54E10BR.6	F08C6.6
+Y56A3A.13	F08C6.6
+Y71H10B.1	F08C6.6
+Y77E11A.6	F08C6.6
+Y95B8A.10	F08C6.6
+Y97E10AR.5	F08C6.6
+ZC239.7	F08C6.6
+ZC395.7	F08C6.6
+ZC412.2	F08C6.6
+ZK455.2	F08C6.6
+ZK563.7	F08C6.6
+ZK593.1	F08C6.6
+ZK673.2	F08C6.6
+ZK856.10	F08C6.6
+ZK896.8	F08C6.6
+ZK909.3	F08C6.6
+ZK970.5	F08C6.6
+ZK970.6	F08C6.6
+F10C2.4	F09F7.3
+F10F2.2	F09F7.3
+F12F6.7	F09F7.3
+F14B4.3	F09F7.3
+F15E6.6	F09F7.3
+F17C8.1	F09F7.3
+F19G12.2	F09F7.3
+F21H7.9	F09F7.3
+F22E5.3	F09F7.3
+F23B2.13	F09F7.3
+F23H12.6	F09F7.3
+F25H2.5	F09F7.3
+F25H5.3	F09F7.3
+F26F4.11	F09F7.3
+F32D1.5	F09F7.3
+F33H2.5	F09F7.3
+F36A4.7	F09F7.3
+F38B2.4	F09F7.3
+F38B6.4	F09F7.3
+F43E2.2	F09F7.3
+F55B11.1	F09F7.3
+F58A4.4	F09F7.3
+F58A4.9	F09F7.3
+H27M09.2	F09F7.3
+H43I07.2	F09F7.3
+K02D7.1	F09F7.3
+K08H10.4	F09F7.3
+M04G12.3	F09F7.3
+M106.4	F09F7.3
+R01H10.1	F09F7.3
+R04F11.3	F09F7.3
+R05F9.6	F09F7.3
+R06C7.5	F09F7.3
+R07E4.4	F09F7.3
+R07H5.8	F09F7.3
+R134.1	F09F7.3
+R134.2	F09F7.3
+R151.2	F09F7.3
+R153.1	F09F7.3
+T01A4.1	F09F7.3
+T03D8.5	F09F7.3
+T03F1.8	F09F7.3
+T04A8.5	F09F7.3
+T04D3.3	F09F7.3
+T04D3.4	F09F7.3
+T14G10.1	F09F7.3
+T19B4.3	F09F7.3
+T22D1.3	F09F7.3
+T23G5.1	F09F7.3
+T24C4.5	F09F7.3
+T26C12.4	F09F7.3
+W01G7.3	F09F7.3
+W02D9.1	F09F7.3
+W03F11.2	F09F7.3
+W06E11.1	F09F7.3
+W09C3.4	F09F7.3
+Y105C5B.2	F09F7.3
+Y105E8B.5	F09F7.3
+Y10G11A.1	F09F7.3
+Y37E3.3	F09F7.3
+Y37H9A.6	F09F7.3
+Y43F4B.5	F09F7.3
+Y47D3A.29	F09F7.3
+Y48E1A.1	F09F7.3
+Y53F4B.3	F09F7.3
+Y54E10BR.6	F09F7.3
+Y56A3A.13	F09F7.3
+Y71H10B.1	F09F7.3
+Y77E11A.6	F09F7.3
+Y95B8A.10	F09F7.3
+Y97E10AR.5	F09F7.3
+ZC239.7	F09F7.3
+ZC395.7	F09F7.3
+ZC412.2	F09F7.3
+ZK455.2	F09F7.3
+ZK563.7	F09F7.3
+ZK593.1	F09F7.3
+ZK673.2	F09F7.3
+ZK856.10	F09F7.3
+ZK896.8	F09F7.3
+ZK909.3	F09F7.3
+ZK970.5	F09F7.3
+ZK970.6	F09F7.3
+F10F2.2	F10C2.4
+F12F6.7	F10C2.4
+F14B4.3	F10C2.4
+F15E6.6	F10C2.4
+F17C8.1	F10C2.4
+F19G12.2	F10C2.4
+F21H7.9	F10C2.4
+F22E5.3	F10C2.4
+F23B2.13	F10C2.4
+F23H12.6	F10C2.4
+F25H2.5	F10C2.4
+F25H5.3	F10C2.4
+F26F4.11	F10C2.4
+F32D1.5	F10C2.4
+F33H2.5	F10C2.4
+F36A4.7	F10C2.4
+F38B2.4	F10C2.4
+F38B6.4	F10C2.4
+F43E2.2	F10C2.4
+F55B11.1	F10C2.4
+F58A4.4	F10C2.4
+F58A4.9	F10C2.4
+H27M09.2	F10C2.4
+H43I07.2	F10C2.4
+K02D7.1	F10C2.4
+K08H10.4	F10C2.4
+M04G12.3	F10C2.4
+M106.4	F10C2.4
+R01H10.1	F10C2.4
+R04F11.3	F10C2.4
+R05F9.6	F10C2.4
+R06C7.5	F10C2.4
+R07E4.4	F10C2.4
+R07H5.8	F10C2.4
+R134.1	F10C2.4
+R134.2	F10C2.4
+R151.2	F10C2.4
+R153.1	F10C2.4
+T01A4.1	F10C2.4
+T03D8.5	F10C2.4
+T03F1.8	F10C2.4
+T04A8.5	F10C2.4
+T04D3.3	F10C2.4
+T04D3.4	F10C2.4
+T14G10.1	F10C2.4
+T19B4.3	F10C2.4
+T22D1.3	F10C2.4
+T23G5.1	F10C2.4
+T24C4.5	F10C2.4
+T26C12.4	F10C2.4
+W01G7.3	F10C2.4
+W02D9.1	F10C2.4
+W03F11.2	F10C2.4
+W06E11.1	F10C2.4
+W09C3.4	F10C2.4
+Y105C5B.2	F10C2.4
+Y105E8B.5	F10C2.4
+Y10G11A.1	F10C2.4
+Y37E3.3	F10C2.4
+Y37H9A.6	F10C2.4
+Y43F4B.5	F10C2.4
+Y48E1A.1	F10C2.4
+Y53F4B.3	F10C2.4
+Y54E10BR.6	F10C2.4
+Y56A3A.13	F10C2.4
+Y71H10B.1	F10C2.4
+Y77E11A.6	F10C2.4
+Y95B8A.10	F10C2.4
+Y97E10AR.5	F10C2.4
+ZC239.7	F10C2.4
+ZC395.7	F10C2.4
+ZC412.2	F10C2.4
+ZK455.2	F10C2.4
+ZK563.7	F10C2.4
+ZK593.1	F10C2.4
+ZK673.2	F10C2.4
+ZK856.10	F10C2.4
+ZK896.8	F10C2.4
+ZK909.3	F10C2.4
+ZK970.5	F10C2.4
+ZK970.6	F10C2.4
+F12F6.7	F10F2.2
+F14B4.3	F10F2.2
+F15E6.6	F10F2.2
+F17C8.1	F10F2.2
+F19G12.2	F10F2.2
+F21H7.9	F10F2.2
+F22E5.3	F10F2.2
+F23B2.13	F10F2.2
+F23H12.6	F10F2.2
+F25H2.5	F10F2.2
+F25H5.3	F10F2.2
+F26F4.11	F10F2.2
+F32D1.5	F10F2.2
+F33H2.5	F10F2.2
+F36A4.7	F10F2.2
+F38B2.4	F10F2.2
+F38B6.4	F10F2.2
+F43E2.2	F10F2.2
+F55B11.1	F10F2.2
+F58A4.4	F10F2.2
+F58A4.9	F10F2.2
+H27M09.2	F10F2.2
+H43I07.2	F10F2.2
+K02D7.1	F10F2.2
+K08H10.4	F10F2.2
+M04G12.3	F10F2.2
+M106.4	F10F2.2
+R01H10.1	F10F2.2
+R04F11.3	F10F2.2
+R05F9.6	F10F2.2
+R06C7.5	F10F2.2
+R07E4.4	F10F2.2
+R07H5.8	F10F2.2
+R134.1	F10F2.2
+R134.2	F10F2.2
+R151.2	F10F2.2
+R153.1	F10F2.2
+T01A4.1	F10F2.2
+T03D8.5	F10F2.2
+T03F1.8	F10F2.2
+T04A8.5	F10F2.2
+T04D3.3	F10F2.2
+T04D3.4	F10F2.2
+T14G10.1	F10F2.2
+T19B4.3	F10F2.2
+T22D1.3	F10F2.2
+T23G5.1	F10F2.2
+T24C4.5	F10F2.2
+T26C12.4	F10F2.2
+W01G7.3	F10F2.2
+W02D9.1	F10F2.2
+W03F11.2	F10F2.2
+W06E11.1	F10F2.2
+W09C3.4	F10F2.2
+Y105C5B.2	F10F2.2
+Y105E8B.5	F10F2.2
+Y10G11A.1	F10F2.2
+Y37E3.3	F10F2.2
+Y37H9A.6	F10F2.2
+Y43F4B.5	F10F2.2
+Y47D3A.29	F10F2.2
+Y48E1A.1	F10F2.2
+Y53F4B.3	F10F2.2
+Y54E10BR.6	F10F2.2
+Y56A3A.13	F10F2.2
+Y71H10B.1	F10F2.2
+Y77E11A.6	F10F2.2
+Y95B8A.10	F10F2.2
+Y97E10AR.5	F10F2.2
+ZC239.7	F10F2.2
+ZC395.7	F10F2.2
+ZC412.2	F10F2.2
+ZK455.2	F10F2.2
+ZK563.7	F10F2.2
+ZK593.1	F10F2.2
+ZK673.2	F10F2.2
+ZK856.10	F10F2.2
+ZK896.8	F10F2.2
+ZK909.3	F10F2.2
+ZK970.5	F10F2.2
+ZK970.6	F10F2.2
+F14B4.3	F12F6.7
+F15E6.6	F12F6.7
+F17C8.1	F12F6.7
+F19G12.2	F12F6.7
+F21H7.9	F12F6.7
+F22E5.3	F12F6.7
+F23B2.13	F12F6.7
+F23H12.6	F12F6.7
+F25H2.5	F12F6.7
+F25H5.3	F12F6.7
+F26F4.11	F12F6.7
+F32D1.5	F12F6.7
+F33H2.5	F12F6.7
+F36A4.7	F12F6.7
+F38B2.4	F12F6.7
+F38B6.4	F12F6.7
+F43E2.2	F12F6.7
+F55B11.1	F12F6.7
+F58A4.4	F12F6.7
+F58A4.9	F12F6.7
+H27M09.2	F12F6.7
+H43I07.2	F12F6.7
+K02D7.1	F12F6.7
+K08H10.4	F12F6.7
+M04G12.3	F12F6.7
+M106.4	F12F6.7
+R01H10.1	F12F6.7
+R04F11.3	F12F6.7
+R05F9.6	F12F6.7
+R06C7.5	F12F6.7
+R07E4.4	F12F6.7
+R07H5.8	F12F6.7
+R134.1	F12F6.7
+R134.2	F12F6.7
+R151.2	F12F6.7
+R153.1	F12F6.7
+T01A4.1	F12F6.7
+T03D8.5	F12F6.7
+T03F1.8	F12F6.7
+T04A8.5	F12F6.7
+T04D3.3	F12F6.7
+T04D3.4	F12F6.7
+T14G10.1	F12F6.7
+T19B4.3	F12F6.7
+T22D1.3	F12F6.7
+T23G5.1	F12F6.7
+T24C4.5	F12F6.7
+T26C12.4	F12F6.7
+W01G7.3	F12F6.7
+W02D9.1	F12F6.7
+W03F11.2	F12F6.7
+W06E11.1	F12F6.7
+W09C3.4	F12F6.7
+Y105C5B.2	F12F6.7
+Y105E8B.5	F12F6.7
+Y10G11A.1	F12F6.7
+Y37E3.3	F12F6.7
+Y37H9A.6	F12F6.7
+Y43F4B.5	F12F6.7
+Y47D3A.29	F12F6.7
+Y48E1A.1	F12F6.7
+Y53F4B.3	F12F6.7
+Y54E10BR.6	F12F6.7
+Y56A3A.13	F12F6.7
+Y71H10B.1	F12F6.7
+Y77E11A.6	F12F6.7
+Y95B8A.10	F12F6.7
+Y97E10AR.5	F12F6.7
+ZC239.7	F12F6.7
+ZC395.7	F12F6.7
+ZC412.2	F12F6.7
+ZK455.2	F12F6.7
+ZK563.7	F12F6.7
+ZK593.1	F12F6.7
+ZK673.2	F12F6.7
+ZK856.10	F12F6.7
+ZK896.8	F12F6.7
+ZK909.3	F12F6.7
+ZK970.5	F12F6.7
+ZK970.6	F12F6.7
+F15E6.6	F14B4.3
+F17C8.1	F14B4.3
+F19G12.2	F14B4.3
+F21H7.9	F14B4.3
+F22E5.3	F14B4.3
+F23B2.13	F14B4.3
+F23H12.6	F14B4.3
+F25H2.5	F14B4.3
+F25H5.3	F14B4.3
+F26F4.11	F14B4.3
+F32D1.5	F14B4.3
+F33H2.5	F14B4.3
+F36A4.7	F14B4.3
+F38B2.4	F14B4.3
+F38B6.4	F14B4.3
+F43E2.2	F14B4.3
+F55B11.1	F14B4.3
+F58A4.4	F14B4.3
+F58A4.9	F14B4.3
+H27M09.2	F14B4.3
+H43I07.2	F14B4.3
+K02D7.1	F14B4.3
+K08H10.4	F14B4.3
+M04G12.3	F14B4.3
+M106.4	F14B4.3
+R01H10.1	F14B4.3
+R04F11.3	F14B4.3
+R05F9.6	F14B4.3
+R06C7.5	F14B4.3
+R07E4.4	F14B4.3
+R07H5.8	F14B4.3
+R134.1	F14B4.3
+R134.2	F14B4.3
+R151.2	F14B4.3
+R153.1	F14B4.3
+T01A4.1	F14B4.3
+T03D8.5	F14B4.3
+T03F1.8	F14B4.3
+T04A8.5	F14B4.3
+T04D3.3	F14B4.3
+T04D3.4	F14B4.3
+T14G10.1	F14B4.3
+T19B4.3	F14B4.3
+T22D1.3	F14B4.3
+T23G5.1	F14B4.3
+T24C4.5	F14B4.3
+T26C12.4	F14B4.3
+W01G7.3	F14B4.3
+W02D9.1	F14B4.3
+W03F11.2	F14B4.3
+W06E11.1	F14B4.3
+W09C3.4	F14B4.3
+Y105C5B.2	F14B4.3
+Y105E8B.5	F14B4.3
+Y10G11A.1	F14B4.3
+Y37E3.3	F14B4.3
+Y37H9A.6	F14B4.3
+Y43F4B.5	F14B4.3
+Y47D3A.29	F14B4.3
+Y48E1A.1	F14B4.3
+Y53F4B.3	F14B4.3
+Y54E10BR.6	F14B4.3
+Y56A3A.13	F14B4.3
+Y71H10B.1	F14B4.3
+Y77E11A.6	F14B4.3
+Y95B8A.10	F14B4.3
+Y97E10AR.5	F14B4.3
+ZC239.7	F14B4.3
+ZC395.7	F14B4.3
+ZC412.2	F14B4.3
+ZK455.2	F14B4.3
+ZK563.7	F14B4.3
+ZK593.1	F14B4.3
+ZK673.2	F14B4.3
+ZK856.10	F14B4.3
+ZK896.8	F14B4.3
+ZK909.3	F14B4.3
+ZK970.5	F14B4.3
+ZK970.6	F14B4.3
+F17C8.1	F15E6.6
+F19G12.2	F15E6.6
+F21H7.9	F15E6.6
+F22E5.3	F15E6.6
+F23B2.13	F15E6.6
+F23H12.6	F15E6.6
+F25H2.5	F15E6.6
+F25H5.3	F15E6.6
+F26F4.11	F15E6.6
+F32D1.5	F15E6.6
+F33H2.5	F15E6.6
+F36A4.7	F15E6.6
+F38B2.4	F15E6.6
+F38B6.4	F15E6.6
+F43E2.2	F15E6.6
+F55B11.1	F15E6.6
+F58A4.4	F15E6.6
+F58A4.9	F15E6.6
+H27M09.2	F15E6.6
+H43I07.2	F15E6.6
+K02D7.1	F15E6.6
+K08H10.4	F15E6.6
+M04G12.3	F15E6.6
+M106.4	F15E6.6
+R01H10.1	F15E6.6
+R04F11.3	F15E6.6
+R05F9.6	F15E6.6
+R06C7.5	F15E6.6
+R07E4.4	F15E6.6
+R07H5.8	F15E6.6
+R134.1	F15E6.6
+R134.2	F15E6.6
+R151.2	F15E6.6
+R153.1	F15E6.6
+T01A4.1	F15E6.6
+T03D8.5	F15E6.6
+T03F1.8	F15E6.6
+T04A8.5	F15E6.6
+T04D3.3	F15E6.6
+T04D3.4	F15E6.6
+T14G10.1	F15E6.6
+T19B4.3	F15E6.6
+T22D1.3	F15E6.6
+T23G5.1	F15E6.6
+T24C4.5	F15E6.6
+T26C12.4	F15E6.6
+W01G7.3	F15E6.6
+W02D9.1	F15E6.6
+W03F11.2	F15E6.6
+W06E11.1	F15E6.6
+W09C3.4	F15E6.6
+Y105C5B.2	F15E6.6
+Y105E8B.5	F15E6.6
+Y10G11A.1	F15E6.6
+Y37E3.3	F15E6.6
+Y37H9A.6	F15E6.6
+Y43F4B.5	F15E6.6
+Y47D3A.29	F15E6.6
+Y48E1A.1	F15E6.6
+Y53F4B.3	F15E6.6
+Y54E10BR.6	F15E6.6
+Y56A3A.13	F15E6.6
+Y71H10B.1	F15E6.6
+Y77E11A.6	F15E6.6
+Y95B8A.10	F15E6.6
+Y97E10AR.5	F15E6.6
+ZC239.7	F15E6.6
+ZC395.7	F15E6.6
+ZC412.2	F15E6.6
+ZK455.2	F15E6.6
+ZK563.7	F15E6.6
+ZK593.1	F15E6.6
+ZK673.2	F15E6.6
+ZK856.10	F15E6.6
+ZK896.8	F15E6.6
+ZK909.3	F15E6.6
+ZK970.5	F15E6.6
+ZK970.6	F15E6.6
+F19G12.2	F17C8.1
+F21H7.9	F17C8.1
+F22E5.3	F17C8.1
+F23B2.13	F17C8.1
+F23H12.6	F17C8.1
+F25H2.5	F17C8.1
+F25H5.3	F17C8.1
+F26F4.11	F17C8.1
+F32D1.5	F17C8.1
+F33H2.5	F17C8.1
+F36A4.7	F17C8.1
+F38B2.4	F17C8.1
+F38B6.4	F17C8.1
+F43E2.2	F17C8.1
+F55B11.1	F17C8.1
+F58A4.4	F17C8.1
+F58A4.9	F17C8.1
+H27M09.2	F17C8.1
+H43I07.2	F17C8.1
+K02D7.1	F17C8.1
+K08H10.4	F17C8.1
+M04G12.3	F17C8.1
+M106.4	F17C8.1
+R01H10.1	F17C8.1
+R04F11.3	F17C8.1
+R05F9.6	F17C8.1
+R06C7.5	F17C8.1
+R07E4.4	F17C8.1
+R07H5.8	F17C8.1
+R134.1	F17C8.1
+R134.2	F17C8.1
+R151.2	F17C8.1
+R153.1	F17C8.1
+T01A4.1	F17C8.1
+T03D8.5	F17C8.1
+T03F1.8	F17C8.1
+T04A8.5	F17C8.1
+T04D3.3	F17C8.1
+T04D3.4	F17C8.1
+T14G10.1	F17C8.1
+T19B4.3	F17C8.1
+T22D1.3	F17C8.1
+T23G5.1	F17C8.1
+T24C4.5	F17C8.1
+T26C12.4	F17C8.1
+W01G7.3	F17C8.1
+W02D9.1	F17C8.1
+W03F11.2	F17C8.1
+W06E11.1	F17C8.1
+W09C3.4	F17C8.1
+Y105C5B.2	F17C8.1
+Y105E8B.5	F17C8.1
+Y10G11A.1	F17C8.1
+Y37E3.3	F17C8.1
+Y37H9A.6	F17C8.1
+Y43F4B.5	F17C8.1
+Y47D3A.29	F17C8.1
+Y48E1A.1	F17C8.1
+Y53F4B.3	F17C8.1
+Y54E10BR.6	F17C8.1
+Y56A3A.13	F17C8.1
+Y71H10B.1	F17C8.1
+Y77E11A.6	F17C8.1
+Y95B8A.10	F17C8.1
+Y97E10AR.5	F17C8.1
+ZC239.7	F17C8.1
+ZC395.7	F17C8.1
+ZC412.2	F17C8.1
+ZK455.2	F17C8.1
+ZK563.7	F17C8.1
+ZK593.1	F17C8.1
+ZK673.2	F17C8.1
+ZK856.10	F17C8.1
+ZK896.8	F17C8.1
+ZK909.3	F17C8.1
+ZK970.5	F17C8.1
+ZK970.6	F17C8.1
+F21H7.9	F19G12.2
+F22E5.3	F19G12.2
+F23B2.13	F19G12.2
+F23H12.6	F19G12.2
+F25H2.5	F19G12.2
+F25H5.3	F19G12.2
+F26F4.11	F19G12.2
+F32D1.5	F19G12.2
+F33H2.5	F19G12.2
+F36A4.7	F19G12.2
+F38B2.4	F19G12.2
+F38B6.4	F19G12.2
+F43E2.2	F19G12.2
+F55B11.1	F19G12.2
+F58A4.4	F19G12.2
+F58A4.9	F19G12.2
+H27M09.2	F19G12.2
+H43I07.2	F19G12.2
+K02D7.1	F19G12.2
+K08H10.4	F19G12.2
+M04G12.3	F19G12.2
+M106.4	F19G12.2
+R01H10.1	F19G12.2
+R04F11.3	F19G12.2
+R05F9.6	F19G12.2
+R06C7.5	F19G12.2
+R07E4.4	F19G12.2
+R07H5.8	F19G12.2
+R134.1	F19G12.2
+R134.2	F19G12.2
+R151.2	F19G12.2
+R153.1	F19G12.2
+T01A4.1	F19G12.2
+T03D8.5	F19G12.2
+T03F1.8	F19G12.2
+T04A8.5	F19G12.2
+T04D3.3	F19G12.2
+T04D3.4	F19G12.2
+T14G10.1	F19G12.2
+T19B4.3	F19G12.2
+T22D1.3	F19G12.2
+T23G5.1	F19G12.2
+T24C4.5	F19G12.2
+T26C12.4	F19G12.2
+W01G7.3	F19G12.2
+W02D9.1	F19G12.2
+W03F11.2	F19G12.2
+W06E11.1	F19G12.2
+W09C3.4	F19G12.2
+Y105C5B.2	F19G12.2
+Y105E8B.5	F19G12.2
+Y10G11A.1	F19G12.2
+Y37E3.3	F19G12.2
+Y37H9A.6	F19G12.2
+Y43F4B.5	F19G12.2
+Y47D3A.29	F19G12.2
+Y48E1A.1	F19G12.2
+Y53F4B.3	F19G12.2
+Y54E10BR.6	F19G12.2
+Y56A3A.13	F19G12.2
+Y71H10B.1	F19G12.2
+Y77E11A.6	F19G12.2
+Y95B8A.10	F19G12.2
+Y97E10AR.5	F19G12.2
+ZC239.7	F19G12.2
+ZC395.7	F19G12.2
+ZC412.2	F19G12.2
+ZK455.2	F19G12.2
+ZK563.7	F19G12.2
+ZK593.1	F19G12.2
+ZK673.2	F19G12.2
+ZK856.10	F19G12.2
+ZK896.8	F19G12.2
+ZK909.3	F19G12.2
+ZK970.5	F19G12.2
+ZK970.6	F19G12.2
+F22E5.3	F21H7.9
+F23B2.13	F21H7.9
+F23H12.6	F21H7.9
+F25H2.5	F21H7.9
+F25H5.3	F21H7.9
+F26F4.11	F21H7.9
+F32D1.5	F21H7.9
+F33H2.5	F21H7.9
+F36A4.7	F21H7.9
+F38B2.4	F21H7.9
+F38B6.4	F21H7.9
+F43E2.2	F21H7.9
+F55B11.1	F21H7.9
+F58A4.4	F21H7.9
+F58A4.9	F21H7.9
+H27M09.2	F21H7.9
+H43I07.2	F21H7.9
+K02D7.1	F21H7.9
+K08H10.4	F21H7.9
+M04G12.3	F21H7.9
+M106.4	F21H7.9
+R01H10.1	F21H7.9
+R04F11.3	F21H7.9
+R05F9.6	F21H7.9
+R06C7.5	F21H7.9
+R07E4.4	F21H7.9
+R07H5.8	F21H7.9
+R134.1	F21H7.9
+R134.2	F21H7.9
+R151.2	F21H7.9
+R153.1	F21H7.9
+T01A4.1	F21H7.9
+T03D8.5	F21H7.9
+T03F1.8	F21H7.9
+T04A8.5	F21H7.9
+T04D3.3	F21H7.9
+T04D3.4	F21H7.9
+T14G10.1	F21H7.9
+T19B4.3	F21H7.9
+T22D1.3	F21H7.9
+T23G5.1	F21H7.9
+T24C4.5	F21H7.9
+T26C12.4	F21H7.9
+W01G7.3	F21H7.9
+W02D9.1	F21H7.9
+W03F11.2	F21H7.9
+W06E11.1	F21H7.9
+W09C3.4	F21H7.9
+Y105C5B.2	F21H7.9
+Y105E8B.5	F21H7.9
+Y10G11A.1	F21H7.9
+Y37E3.3	F21H7.9
+Y37H9A.6	F21H7.9
+Y43F4B.5	F21H7.9
+Y47D3A.29	F21H7.9
+Y48E1A.1	F21H7.9
+Y53F4B.3	F21H7.9
+Y54E10BR.6	F21H7.9
+Y56A3A.13	F21H7.9
+Y71H10B.1	F21H7.9
+Y77E11A.6	F21H7.9
+Y95B8A.10	F21H7.9
+Y97E10AR.5	F21H7.9
+ZC239.7	F21H7.9
+ZC395.7	F21H7.9
+ZC412.2	F21H7.9
+ZK455.2	F21H7.9
+ZK563.7	F21H7.9
+ZK593.1	F21H7.9
+ZK673.2	F21H7.9
+ZK856.10	F21H7.9
+ZK896.8	F21H7.9
+ZK909.3	F21H7.9
+ZK970.5	F21H7.9
+ZK970.6	F21H7.9
+F23B2.13	F22E5.3
+F23H12.6	F22E5.3
+F25H2.5	F22E5.3
+F25H5.3	F22E5.3
+F26F4.11	F22E5.3
+F32D1.5	F22E5.3
+F33H2.5	F22E5.3
+F36A4.7	F22E5.3
+F38B2.4	F22E5.3
+F38B6.4	F22E5.3
+F43E2.2	F22E5.3
+F55B11.1	F22E5.3
+F58A4.4	F22E5.3
+F58A4.9	F22E5.3
+H27M09.2	F22E5.3
+H43I07.2	F22E5.3
+K02D7.1	F22E5.3
+K08H10.4	F22E5.3
+M04G12.3	F22E5.3
+M106.4	F22E5.3
+R01H10.1	F22E5.3
+R04F11.3	F22E5.3
+R05F9.6	F22E5.3
+R06C7.5	F22E5.3
+R07E4.4	F22E5.3
+R07H5.8	F22E5.3
+R134.1	F22E5.3
+R134.2	F22E5.3
+R151.2	F22E5.3
+R153.1	F22E5.3
+T01A4.1	F22E5.3
+T03D8.5	F22E5.3
+T03F1.8	F22E5.3
+T04A8.5	F22E5.3
+T04D3.3	F22E5.3
+T04D3.4	F22E5.3
+T14G10.1	F22E5.3
+T19B4.3	F22E5.3
+T22D1.3	F22E5.3
+T23G5.1	F22E5.3
+T24C4.5	F22E5.3
+T26C12.4	F22E5.3
+W01G7.3	F22E5.3
+W02D9.1	F22E5.3
+W03F11.2	F22E5.3
+W06E11.1	F22E5.3
+W09C3.4	F22E5.3
+Y105C5B.2	F22E5.3
+Y105E8B.5	F22E5.3
+Y10G11A.1	F22E5.3
+Y37E3.3	F22E5.3
+Y37H9A.6	F22E5.3
+Y43F4B.5	F22E5.3
+Y47D3A.29	F22E5.3
+Y48E1A.1	F22E5.3
+Y53F4B.3	F22E5.3
+Y54E10BR.6	F22E5.3
+Y56A3A.13	F22E5.3
+Y71H10B.1	F22E5.3
+Y77E11A.6	F22E5.3
+Y95B8A.10	F22E5.3
+Y97E10AR.5	F22E5.3
+ZC239.7	F22E5.3
+ZC395.7	F22E5.3
+ZC412.2	F22E5.3
+ZK455.2	F22E5.3
+ZK563.7	F22E5.3
+ZK593.1	F22E5.3
+ZK673.2	F22E5.3
+ZK856.10	F22E5.3
+ZK896.8	F22E5.3
+ZK909.3	F22E5.3
+ZK970.5	F22E5.3
+ZK970.6	F22E5.3
+F23H12.6	F23B2.13
+F25H2.5	F23B2.13
+F25H5.3	F23B2.13
+F26F4.11	F23B2.13
+F32D1.5	F23B2.13
+F33H2.5	F23B2.13
+F36A4.7	F23B2.13
+F38B2.4	F23B2.13
+F38B6.4	F23B2.13
+F43E2.2	F23B2.13
+F55B11.1	F23B2.13
+F58A4.4	F23B2.13
+F58A4.9	F23B2.13
+H27M09.2	F23B2.13
+H43I07.2	F23B2.13
+K02D7.1	F23B2.13
+K08H10.4	F23B2.13
+M04G12.3	F23B2.13
+M106.4	F23B2.13
+R01H10.1	F23B2.13
+R04F11.3	F23B2.13
+R05F9.6	F23B2.13
+R06C7.5	F23B2.13
+R07E4.4	F23B2.13
+R07H5.8	F23B2.13
+R134.1	F23B2.13
+R134.2	F23B2.13
+R151.2	F23B2.13
+R153.1	F23B2.13
+T01A4.1	F23B2.13
+T03D8.5	F23B2.13
+T03F1.8	F23B2.13
+T04A8.5	F23B2.13
+T04D3.3	F23B2.13
+T04D3.4	F23B2.13
+T14G10.1	F23B2.13
+T19B4.3	F23B2.13
+T22D1.3	F23B2.13
+T23G5.1	F23B2.13
+T24C4.5	F23B2.13
+T26C12.4	F23B2.13
+W01G7.3	F23B2.13
+W02D9.1	F23B2.13
+W03F11.2	F23B2.13
+W06E11.1	F23B2.13
+W09C3.4	F23B2.13
+Y105C5B.2	F23B2.13
+Y105E8B.5	F23B2.13
+Y10G11A.1	F23B2.13
+Y37E3.3	F23B2.13
+Y37H9A.6	F23B2.13
+Y43F4B.5	F23B2.13
+Y47D3A.29	F23B2.13
+Y48E1A.1	F23B2.13
+Y53F4B.3	F23B2.13
+Y54E10BR.6	F23B2.13
+Y56A3A.13	F23B2.13
+Y71H10B.1	F23B2.13
+Y77E11A.6	F23B2.13
+Y95B8A.10	F23B2.13
+Y97E10AR.5	F23B2.13
+ZC239.7	F23B2.13
+ZC395.7	F23B2.13
+ZC412.2	F23B2.13
+ZK455.2	F23B2.13
+ZK563.7	F23B2.13
+ZK593.1	F23B2.13
+ZK673.2	F23B2.13
+ZK856.10	F23B2.13
+ZK896.8	F23B2.13
+ZK909.3	F23B2.13
+ZK970.5	F23B2.13
+ZK970.6	F23B2.13
+F25H2.5	F23H12.6
+F25H5.3	F23H12.6
+F26F4.11	F23H12.6
+F32D1.5	F23H12.6
+F33H2.5	F23H12.6
+F36A4.7	F23H12.6
+F38B2.4	F23H12.6
+F38B6.4	F23H12.6
+F43E2.2	F23H12.6
+F55B11.1	F23H12.6
+F58A4.4	F23H12.6
+F58A4.9	F23H12.6
+H27M09.2	F23H12.6
+H43I07.2	F23H12.6
+K02D7.1	F23H12.6
+K08H10.4	F23H12.6
+M04G12.3	F23H12.6
+M106.4	F23H12.6
+R01H10.1	F23H12.6
+R04F11.3	F23H12.6
+R05F9.6	F23H12.6
+R06C7.5	F23H12.6
+R07E4.4	F23H12.6
+R07H5.8	F23H12.6
+R134.1	F23H12.6
+R134.2	F23H12.6
+R151.2	F23H12.6
+R153.1	F23H12.6
+T01A4.1	F23H12.6
+T03D8.5	F23H12.6
+T03F1.8	F23H12.6
+T04A8.5	F23H12.6
+T04D3.3	F23H12.6
+T04D3.4	F23H12.6
+T14G10.1	F23H12.6
+T19B4.3	F23H12.6
+T22D1.3	F23H12.6
+T23G5.1	F23H12.6
+T24C4.5	F23H12.6
+T26C12.4	F23H12.6
+W01G7.3	F23H12.6
+W02D9.1	F23H12.6
+W03F11.2	F23H12.6
+W06E11.1	F23H12.6
+W09C3.4	F23H12.6
+Y105C5B.2	F23H12.6
+Y105E8B.5	F23H12.6
+Y10G11A.1	F23H12.6
+Y37E3.3	F23H12.6
+Y37H9A.6	F23H12.6
+Y43F4B.5	F23H12.6
+Y47D3A.29	F23H12.6
+Y48E1A.1	F23H12.6
+Y53F4B.3	F23H12.6
+Y54E10BR.6	F23H12.6
+Y56A3A.13	F23H12.6
+Y71H10B.1	F23H12.6
+Y77E11A.6	F23H12.6
+Y95B8A.10	F23H12.6
+Y97E10AR.5	F23H12.6
+ZC239.7	F23H12.6
+ZC395.7	F23H12.6
+ZC412.2	F23H12.6
+ZK455.2	F23H12.6
+ZK563.7	F23H12.6
+ZK593.1	F23H12.6
+ZK673.2	F23H12.6
+ZK856.10	F23H12.6
+ZK896.8	F23H12.6
+ZK909.3	F23H12.6
+ZK970.5	F23H12.6
+ZK970.6	F23H12.6
+F25H5.3	F25H2.5
+F26F4.11	F25H2.5
+F32D1.5	F25H2.5
+F33H2.5	F25H2.5
+F36A4.7	F25H2.5
+F38B2.4	F25H2.5
+F38B6.4	F25H2.5
+F43E2.2	F25H2.5
+F55B11.1	F25H2.5
+F58A4.4	F25H2.5
+F58A4.9	F25H2.5
+H27M09.2	F25H2.5
+H43I07.2	F25H2.5
+K02D7.1	F25H2.5
+K08H10.4	F25H2.5
+M04G12.3	F25H2.5
+M106.4	F25H2.5
+R01H10.1	F25H2.5
+R04F11.3	F25H2.5
+R05F9.6	F25H2.5
+R06C7.5	F25H2.5
+R07E4.4	F25H2.5
+R07H5.8	F25H2.5
+R134.1	F25H2.5
+R134.2	F25H2.5
+R151.2	F25H2.5
+R153.1	F25H2.5
+T01A4.1	F25H2.5
+T03D8.5	F25H2.5
+T03F1.8	F25H2.5
+T04A8.5	F25H2.5
+T04D3.3	F25H2.5
+T04D3.4	F25H2.5
+T14G10.1	F25H2.5
+T19B4.3	F25H2.5
+T22D1.3	F25H2.5
+T23G5.1	F25H2.5
+T24C4.5	F25H2.5
+T26C12.4	F25H2.5
+W01G7.3	F25H2.5
+W02D9.1	F25H2.5
+W03F11.2	F25H2.5
+W06E11.1	F25H2.5
+W09C3.4	F25H2.5
+Y105C5B.2	F25H2.5
+Y105E8B.5	F25H2.5
+Y10G11A.1	F25H2.5
+Y37E3.3	F25H2.5
+Y37H9A.6	F25H2.5
+Y43F4B.5	F25H2.5
+Y47D3A.29	F25H2.5
+Y48E1A.1	F25H2.5
+Y53F4B.3	F25H2.5
+Y54E10BR.6	F25H2.5
+Y56A3A.13	F25H2.5
+Y71H10B.1	F25H2.5
+Y77E11A.6	F25H2.5
+Y95B8A.10	F25H2.5
+Y97E10AR.5	F25H2.5
+ZC239.7	F25H2.5
+ZC395.7	F25H2.5
+ZC412.2	F25H2.5
+ZK455.2	F25H2.5
+ZK563.7	F25H2.5
+ZK593.1	F25H2.5
+ZK673.2	F25H2.5
+ZK856.10	F25H2.5
+ZK896.8	F25H2.5
+ZK909.3	F25H2.5
+ZK970.5	F25H2.5
+ZK970.6	F25H2.5
+F26F4.11	F25H5.3
+F32D1.5	F25H5.3
+F33H2.5	F25H5.3
+F36A4.7	F25H5.3
+F38B2.4	F25H5.3
+F38B6.4	F25H5.3
+F43E2.2	F25H5.3
+F55B11.1	F25H5.3
+F58A4.4	F25H5.3
+F58A4.9	F25H5.3
+H27M09.2	F25H5.3
+H43I07.2	F25H5.3
+K02D7.1	F25H5.3
+K08H10.4	F25H5.3
+M04G12.3	F25H5.3
+M106.4	F25H5.3
+R01H10.1	F25H5.3
+R04F11.3	F25H5.3
+R06C7.5	F25H5.3
+R07E4.4	F25H5.3
+R07H5.8	F25H5.3
+R134.1	F25H5.3
+R134.2	F25H5.3
+R151.2	F25H5.3
+R153.1	F25H5.3
+T01A4.1	F25H5.3
+T03D8.5	F25H5.3
+T03F1.8	F25H5.3
+T04A8.5	F25H5.3
+T04D3.3	F25H5.3
+T04D3.4	F25H5.3
+T14G10.1	F25H5.3
+T19B4.3	F25H5.3
+T22D1.3	F25H5.3
+T23G5.1	F25H5.3
+T24C4.5	F25H5.3
+T26C12.4	F25H5.3
+W01G7.3	F25H5.3
+W02D9.1	F25H5.3
+W03F11.2	F25H5.3
+W06E11.1	F25H5.3
+W09C3.4	F25H5.3
+Y105C5B.2	F25H5.3
+Y105E8B.5	F25H5.3
+Y10G11A.1	F25H5.3
+Y37E3.3	F25H5.3
+Y37H9A.6	F25H5.3
+Y47D3A.29	F25H5.3
+Y48E1A.1	F25H5.3
+Y53F4B.3	F25H5.3
+Y54E10BR.6	F25H5.3
+Y56A3A.13	F25H5.3
+Y71H10B.1	F25H5.3
+Y77E11A.6	F25H5.3
+Y95B8A.10	F25H5.3
+Y97E10AR.5	F25H5.3
+ZC239.7	F25H5.3
+ZC395.7	F25H5.3
+ZC412.2	F25H5.3
+ZK455.2	F25H5.3
+ZK563.7	F25H5.3
+ZK673.2	F25H5.3
+ZK856.10	F25H5.3
+ZK896.8	F25H5.3
+ZK909.3	F25H5.3
+ZK970.5	F25H5.3
+ZK970.6	F25H5.3
+F32D1.5	F26F4.11
+F33H2.5	F26F4.11
+F36A4.7	F26F4.11
+F38B2.4	F26F4.11
+F38B6.4	F26F4.11
+F43E2.2	F26F4.11
+F55B11.1	F26F4.11
+F58A4.4	F26F4.11
+F58A4.9	F26F4.11
+H27M09.2	F26F4.11
+H43I07.2	F26F4.11
+K02D7.1	F26F4.11
+K08H10.4	F26F4.11
+M04G12.3	F26F4.11
+M106.4	F26F4.11
+R01H10.1	F26F4.11
+R04F11.3	F26F4.11
+R05F9.6	F26F4.11
+R06C7.5	F26F4.11
+R07E4.4	F26F4.11
+R07H5.8	F26F4.11
+R134.1	F26F4.11
+R134.2	F26F4.11
+R151.2	F26F4.11
+R153.1	F26F4.11
+T01A4.1	F26F4.11
+T03D8.5	F26F4.11
+T03F1.8	F26F4.11
+T04A8.5	F26F4.11
+T04D3.3	F26F4.11
+T04D3.4	F26F4.11
+T14G10.1	F26F4.11
+T19B4.3	F26F4.11
+T22D1.3	F26F4.11
+T23G5.1	F26F4.11
+T24C4.5	F26F4.11
+T26C12.4	F26F4.11
+W01G7.3	F26F4.11
+W02D9.1	F26F4.11
+W03F11.2	F26F4.11
+W06E11.1	F26F4.11
+W09C3.4	F26F4.11
+Y105C5B.2	F26F4.11
+Y105E8B.5	F26F4.11
+Y10G11A.1	F26F4.11
+Y37E3.3	F26F4.11
+Y37H9A.6	F26F4.11
+Y43F4B.5	F26F4.11
+Y47D3A.29	F26F4.11
+Y48E1A.1	F26F4.11
+Y53F4B.3	F26F4.11
+Y54E10BR.6	F26F4.11
+Y56A3A.13	F26F4.11
+Y71H10B.1	F26F4.11
+Y77E11A.6	F26F4.11
+Y95B8A.10	F26F4.11
+Y97E10AR.5	F26F4.11
+ZC239.7	F26F4.11
+ZC395.7	F26F4.11
+ZC412.2	F26F4.11
+ZK455.2	F26F4.11
+ZK563.7	F26F4.11
+ZK593.1	F26F4.11
+ZK673.2	F26F4.11
+ZK856.10	F26F4.11
+ZK896.8	F26F4.11
+ZK909.3	F26F4.11
+ZK970.5	F26F4.11
+ZK970.6	F26F4.11
+F33H2.5	F32D1.5
+F36A4.7	F32D1.5
+F38B2.4	F32D1.5
+F38B6.4	F32D1.5
+F43E2.2	F32D1.5
+F55B11.1	F32D1.5
+F58A4.4	F32D1.5
+F58A4.9	F32D1.5
+H27M09.2	F32D1.5
+H43I07.2	F32D1.5
+K02D7.1	F32D1.5
+K08H10.4	F32D1.5
+M04G12.3	F32D1.5
+M106.4	F32D1.5
+R01H10.1	F32D1.5
+R04F11.3	F32D1.5
+R05F9.6	F32D1.5
+R06C7.5	F32D1.5
+R07E4.4	F32D1.5
+R07H5.8	F32D1.5
+R134.1	F32D1.5
+R134.2	F32D1.5
+R151.2	F32D1.5
+R153.1	F32D1.5
+T01A4.1	F32D1.5
+T03D8.5	F32D1.5
+T03F1.8	F32D1.5
+T04A8.5	F32D1.5
+T04D3.3	F32D1.5
+T04D3.4	F32D1.5
+T14G10.1	F32D1.5
+T19B4.3	F32D1.5
+T22D1.3	F32D1.5
+T23G5.1	F32D1.5
+T24C4.5	F32D1.5
+T26C12.4	F32D1.5
+W01G7.3	F32D1.5
+W02D9.1	F32D1.5
+W03F11.2	F32D1.5
+W06E11.1	F32D1.5
+W09C3.4	F32D1.5
+Y105C5B.2	F32D1.5
+Y105E8B.5	F32D1.5
+Y10G11A.1	F32D1.5
+Y37E3.3	F32D1.5
+Y37H9A.6	F32D1.5
+Y43F4B.5	F32D1.5
+Y47D3A.29	F32D1.5
+Y48E1A.1	F32D1.5
+Y53F4B.3	F32D1.5
+Y54E10BR.6	F32D1.5
+Y56A3A.13	F32D1.5
+Y71H10B.1	F32D1.5
+Y77E11A.6	F32D1.5
+Y95B8A.10	F32D1.5
+Y97E10AR.5	F32D1.5
+ZC239.7	F32D1.5
+ZC395.7	F32D1.5
+ZC412.2	F32D1.5
+ZK455.2	F32D1.5
+ZK563.7	F32D1.5
+ZK593.1	F32D1.5
+ZK673.2	F32D1.5
+ZK856.10	F32D1.5
+ZK896.8	F32D1.5
+ZK909.3	F32D1.5
+ZK970.5	F32D1.5
+ZK970.6	F32D1.5
+F36A4.7	F33H2.5
+F38B2.4	F33H2.5
+F38B6.4	F33H2.5
+F43E2.2	F33H2.5
+F55B11.1	F33H2.5
+F58A4.4	F33H2.5
+F58A4.9	F33H2.5
+H27M09.2	F33H2.5
+H43I07.2	F33H2.5
+K02D7.1	F33H2.5
+K08H10.4	F33H2.5
+M04G12.3	F33H2.5
+M106.4	F33H2.5
+R01H10.1	F33H2.5
+R04F11.3	F33H2.5
+R05F9.6	F33H2.5
+R06C7.5	F33H2.5
+R07E4.4	F33H2.5
+R07H5.8	F33H2.5
+R134.1	F33H2.5
+R134.2	F33H2.5
+R151.2	F33H2.5
+R153.1	F33H2.5
+T01A4.1	F33H2.5
+T03D8.5	F33H2.5
+T03F1.8	F33H2.5
+T04A8.5	F33H2.5
+T04D3.3	F33H2.5
+T04D3.4	F33H2.5
+T14G10.1	F33H2.5
+T19B4.3	F33H2.5
+T22D1.3	F33H2.5
+T23G5.1	F33H2.5
+T24C4.5	F33H2.5
+T26C12.4	F33H2.5
+W01G7.3	F33H2.5
+W02D9.1	F33H2.5
+W03F11.2	F33H2.5
+W06E11.1	F33H2.5
+W09C3.4	F33H2.5
+Y105C5B.2	F33H2.5
+Y105E8B.5	F33H2.5
+Y10G11A.1	F33H2.5
+Y37E3.3	F33H2.5
+Y37H9A.6	F33H2.5
+Y43F4B.5	F33H2.5
+Y47D3A.29	F33H2.5
+Y48E1A.1	F33H2.5
+Y53F4B.3	F33H2.5
+Y54E10BR.6	F33H2.5
+Y56A3A.13	F33H2.5
+Y71H10B.1	F33H2.5
+Y77E11A.6	F33H2.5
+Y95B8A.10	F33H2.5
+Y97E10AR.5	F33H2.5
+ZC239.7	F33H2.5
+ZC395.7	F33H2.5
+ZC412.2	F33H2.5
+ZK455.2	F33H2.5
+ZK563.7	F33H2.5
+ZK593.1	F33H2.5
+ZK673.2	F33H2.5
+ZK856.10	F33H2.5
+ZK896.8	F33H2.5
+ZK909.3	F33H2.5
+ZK970.5	F33H2.5
+ZK970.6	F33H2.5
+F38B2.4	F36A4.7
+F38B6.4	F36A4.7
+F43E2.2	F36A4.7
+F55B11.1	F36A4.7
+F58A4.4	F36A4.7
+F58A4.9	F36A4.7
+H27M09.2	F36A4.7
+H43I07.2	F36A4.7
+K02D7.1	F36A4.7
+K08H10.4	F36A4.7
+M04G12.3	F36A4.7
+M106.4	F36A4.7
+R01H10.1	F36A4.7
+R04F11.3	F36A4.7
+R05F9.6	F36A4.7
+R06C7.5	F36A4.7
+R07E4.4	F36A4.7
+R07H5.8	F36A4.7
+R134.1	F36A4.7
+R134.2	F36A4.7
+R151.2	F36A4.7
+R153.1	F36A4.7
+T01A4.1	F36A4.7
+T03D8.5	F36A4.7
+T03F1.8	F36A4.7
+T04A8.5	F36A4.7
+T04D3.3	F36A4.7
+T04D3.4	F36A4.7
+T14G10.1	F36A4.7
+T19B4.3	F36A4.7
+T22D1.3	F36A4.7
+T23G5.1	F36A4.7
+T24C4.5	F36A4.7
+T26C12.4	F36A4.7
+W01G7.3	F36A4.7
+W02D9.1	F36A4.7
+W03F11.2	F36A4.7
+W06E11.1	F36A4.7
+W09C3.4	F36A4.7
+Y105C5B.2	F36A4.7
+Y105E8B.5	F36A4.7
+Y10G11A.1	F36A4.7
+Y37E3.3	F36A4.7
+Y37H9A.6	F36A4.7
+Y43F4B.5	F36A4.7
+Y47D3A.29	F36A4.7
+Y48E1A.1	F36A4.7
+Y53F4B.3	F36A4.7
+Y54E10BR.6	F36A4.7
+Y56A3A.13	F36A4.7
+Y71H10B.1	F36A4.7
+Y77E11A.6	F36A4.7
+Y95B8A.10	F36A4.7
+Y97E10AR.5	F36A4.7
+ZC239.7	F36A4.7
+ZC395.7	F36A4.7
+ZC412.2	F36A4.7
+ZK455.2	F36A4.7
+ZK563.7	F36A4.7
+ZK593.1	F36A4.7
+ZK673.2	F36A4.7
+ZK856.10	F36A4.7
+ZK896.8	F36A4.7
+ZK909.3	F36A4.7
+ZK970.5	F36A4.7
+ZK970.6	F36A4.7
+F38B6.4	F38B2.4
+F43E2.2	F38B2.4
+F55B11.1	F38B2.4
+F58A4.4	F38B2.4
+F58A4.9	F38B2.4
+H27M09.2	F38B2.4
+H43I07.2	F38B2.4
+K02D7.1	F38B2.4
+K08H10.4	F38B2.4
+M04G12.3	F38B2.4
+M106.4	F38B2.4
+R01H10.1	F38B2.4
+R04F11.3	F38B2.4
+R05F9.6	F38B2.4
+R06C7.5	F38B2.4
+R07E4.4	F38B2.4
+R07H5.8	F38B2.4
+R134.1	F38B2.4
+R134.2	F38B2.4
+R151.2	F38B2.4
+R153.1	F38B2.4
+T01A4.1	F38B2.4
+T03D8.5	F38B2.4
+T03F1.8	F38B2.4
+T04A8.5	F38B2.4
+T04D3.3	F38B2.4
+T04D3.4	F38B2.4
+T14G10.1	F38B2.4
+T19B4.3	F38B2.4
+T22D1.3	F38B2.4
+T23G5.1	F38B2.4
+T24C4.5	F38B2.4
+T26C12.4	F38B2.4
+W01G7.3	F38B2.4
+W02D9.1	F38B2.4
+W03F11.2	F38B2.4
+W06E11.1	F38B2.4
+W09C3.4	F38B2.4
+Y105C5B.2	F38B2.4
+Y105E8B.5	F38B2.4
+Y10G11A.1	F38B2.4
+Y37E3.3	F38B2.4
+Y37H9A.6	F38B2.4
+Y43F4B.5	F38B2.4
+Y47D3A.29	F38B2.4
+Y48E1A.1	F38B2.4
+Y53F4B.3	F38B2.4
+Y54E10BR.6	F38B2.4
+Y56A3A.13	F38B2.4
+Y71H10B.1	F38B2.4
+Y77E11A.6	F38B2.4
+Y95B8A.10	F38B2.4
+Y97E10AR.5	F38B2.4
+ZC239.7	F38B2.4
+ZC395.7	F38B2.4
+ZC412.2	F38B2.4
+ZK455.2	F38B2.4
+ZK563.7	F38B2.4
+ZK593.1	F38B2.4
+ZK673.2	F38B2.4
+ZK856.10	F38B2.4
+ZK896.8	F38B2.4
+ZK909.3	F38B2.4
+ZK970.5	F38B2.4
+ZK970.6	F38B2.4
+F43E2.2	F38B6.4
+F55B11.1	F38B6.4
+F58A4.4	F38B6.4
+F58A4.9	F38B6.4
+H27M09.2	F38B6.4
+H43I07.2	F38B6.4
+K02D7.1	F38B6.4
+K08H10.4	F38B6.4
+M04G12.3	F38B6.4
+M106.4	F38B6.4
+R01H10.1	F38B6.4
+R04F11.3	F38B6.4
+R05F9.6	F38B6.4
+R06C7.5	F38B6.4
+R07E4.4	F38B6.4
+R07H5.8	F38B6.4
+R134.1	F38B6.4
+R134.2	F38B6.4
+R151.2	F38B6.4
+R153.1	F38B6.4
+T01A4.1	F38B6.4
+T03D8.5	F38B6.4
+T03F1.8	F38B6.4
+T04A8.5	F38B6.4
+T04D3.3	F38B6.4
+T04D3.4	F38B6.4
+T14G10.1	F38B6.4
+T19B4.3	F38B6.4
+T22D1.3	F38B6.4
+T23G5.1	F38B6.4
+T24C4.5	F38B6.4
+T26C12.4	F38B6.4
+W01G7.3	F38B6.4
+W02D9.1	F38B6.4
+W03F11.2	F38B6.4
+W06E11.1	F38B6.4
+W09C3.4	F38B6.4
+Y105C5B.2	F38B6.4
+Y105E8B.5	F38B6.4
+Y10G11A.1	F38B6.4
+Y37E3.3	F38B6.4
+Y37H9A.6	F38B6.4
+Y43F4B.5	F38B6.4
+Y47D3A.29	F38B6.4
+Y48E1A.1	F38B6.4
+Y53F4B.3	F38B6.4
+Y54E10BR.6	F38B6.4
+Y56A3A.13	F38B6.4
+Y71H10B.1	F38B6.4
+Y77E11A.6	F38B6.4
+Y95B8A.10	F38B6.4
+Y97E10AR.5	F38B6.4
+ZC239.7	F38B6.4
+ZC395.7	F38B6.4
+ZC412.2	F38B6.4
+ZK455.2	F38B6.4
+ZK563.7	F38B6.4
+ZK593.1	F38B6.4
+ZK673.2	F38B6.4
+ZK856.10	F38B6.4
+ZK896.8	F38B6.4
+ZK909.3	F38B6.4
+ZK970.5	F38B6.4
+ZK970.6	F38B6.4
+F55B11.1	F43E2.2
+F58A4.4	F43E2.2
+F58A4.9	F43E2.2
+H27M09.2	F43E2.2
+H43I07.2	F43E2.2
+K02D7.1	F43E2.2
+K08H10.4	F43E2.2
+M04G12.3	F43E2.2
+M106.4	F43E2.2
+R01H10.1	F43E2.2
+R04F11.3	F43E2.2
+R05F9.6	F43E2.2
+R06C7.5	F43E2.2
+R07E4.4	F43E2.2
+R07H5.8	F43E2.2
+R134.1	F43E2.2
+R134.2	F43E2.2
+R151.2	F43E2.2
+R153.1	F43E2.2
+T01A4.1	F43E2.2
+T03D8.5	F43E2.2
+T03F1.8	F43E2.2
+T04A8.5	F43E2.2
+T04D3.3	F43E2.2
+T04D3.4	F43E2.2
+T14G10.1	F43E2.2
+T19B4.3	F43E2.2
+T22D1.3	F43E2.2
+T23G5.1	F43E2.2
+T24C4.5	F43E2.2
+T26C12.4	F43E2.2
+W01G7.3	F43E2.2
+W02D9.1	F43E2.2
+W03F11.2	F43E2.2
+W06E11.1	F43E2.2
+W09C3.4	F43E2.2
+Y105C5B.2	F43E2.2
+Y105E8B.5	F43E2.2
+Y10G11A.1	F43E2.2
+Y37E3.3	F43E2.2
+Y37H9A.6	F43E2.2
+Y43F4B.5	F43E2.2
+Y47D3A.29	F43E2.2
+Y48E1A.1	F43E2.2
+Y53F4B.3	F43E2.2
+Y54E10BR.6	F43E2.2
+Y56A3A.13	F43E2.2
+Y71H10B.1	F43E2.2
+Y77E11A.6	F43E2.2
+Y95B8A.10	F43E2.2
+Y97E10AR.5	F43E2.2
+ZC239.7	F43E2.2
+ZC395.7	F43E2.2
+ZC412.2	F43E2.2
+ZK455.2	F43E2.2
+ZK563.7	F43E2.2
+ZK593.1	F43E2.2
+ZK673.2	F43E2.2
+ZK856.10	F43E2.2
+ZK896.8	F43E2.2
+ZK909.3	F43E2.2
+ZK970.5	F43E2.2
+ZK970.6	F43E2.2
+F58A4.4	F55B11.1
+F58A4.9	F55B11.1
+H27M09.2	F55B11.1
+H43I07.2	F55B11.1
+K02D7.1	F55B11.1
+K08H10.4	F55B11.1
+M04G12.3	F55B11.1
+M106.4	F55B11.1
+R01H10.1	F55B11.1
+R04F11.3	F55B11.1
+R05F9.6	F55B11.1
+R06C7.5	F55B11.1
+R07E4.4	F55B11.1
+R07H5.8	F55B11.1
+R134.1	F55B11.1
+R134.2	F55B11.1
+R151.2	F55B11.1
+R153.1	F55B11.1
+T01A4.1	F55B11.1
+T03D8.5	F55B11.1
+T03F1.8	F55B11.1
+T04A8.5	F55B11.1
+T04D3.3	F55B11.1
+T04D3.4	F55B11.1
+T14G10.1	F55B11.1
+T19B4.3	F55B11.1
+T22D1.3	F55B11.1
+T23G5.1	F55B11.1
+T24C4.5	F55B11.1
+T26C12.4	F55B11.1
+W01G7.3	F55B11.1
+W02D9.1	F55B11.1
+W03F11.2	F55B11.1
+W06E11.1	F55B11.1
+W09C3.4	F55B11.1
+Y105C5B.2	F55B11.1
+Y105E8B.5	F55B11.1
+Y10G11A.1	F55B11.1
+Y37E3.3	F55B11.1
+Y37H9A.6	F55B11.1
+Y43F4B.5	F55B11.1
+Y47D3A.29	F55B11.1
+Y48E1A.1	F55B11.1
+Y53F4B.3	F55B11.1
+Y54E10BR.6	F55B11.1
+Y56A3A.13	F55B11.1
+Y71H10B.1	F55B11.1
+Y77E11A.6	F55B11.1
+Y95B8A.10	F55B11.1
+Y97E10AR.5	F55B11.1
+ZC239.7	F55B11.1
+ZC395.7	F55B11.1
+ZC412.2	F55B11.1
+ZK455.2	F55B11.1
+ZK563.7	F55B11.1
+ZK593.1	F55B11.1
+ZK673.2	F55B11.1
+ZK856.10	F55B11.1
+ZK896.8	F55B11.1
+ZK909.3	F55B11.1
+ZK970.5	F55B11.1
+ZK970.6	F55B11.1
+F58A4.9	F58A4.4
+H27M09.2	F58A4.4
+H43I07.2	F58A4.4
+K02D7.1	F58A4.4
+K08H10.4	F58A4.4
+M04G12.3	F58A4.4
+M106.4	F58A4.4
+R01H10.1	F58A4.4
+R04F11.3	F58A4.4
+R05F9.6	F58A4.4
+R06C7.5	F58A4.4
+R07E4.4	F58A4.4
+R07H5.8	F58A4.4
+R134.1	F58A4.4
+R134.2	F58A4.4
+R151.2	F58A4.4
+R153.1	F58A4.4
+T01A4.1	F58A4.4
+T03D8.5	F58A4.4
+T03F1.8	F58A4.4
+T04A8.5	F58A4.4
+T04D3.3	F58A4.4
+T04D3.4	F58A4.4
+T14G10.1	F58A4.4
+T19B4.3	F58A4.4
+T22D1.3	F58A4.4
+T23G5.1	F58A4.4
+T24C4.5	F58A4.4
+T26C12.4	F58A4.4
+W01G7.3	F58A4.4
+W02D9.1	F58A4.4
+W03F11.2	F58A4.4
+W06E11.1	F58A4.4
+W09C3.4	F58A4.4
+Y105C5B.2	F58A4.4
+Y105E8B.5	F58A4.4
+Y10G11A.1	F58A4.4
+Y37E3.3	F58A4.4
+Y37H9A.6	F58A4.4
+Y43F4B.5	F58A4.4
+Y47D3A.29	F58A4.4
+Y48E1A.1	F58A4.4
+Y53F4B.3	F58A4.4
+Y54E10BR.6	F58A4.4
+Y56A3A.13	F58A4.4
+Y71H10B.1	F58A4.4
+Y77E11A.6	F58A4.4
+Y95B8A.10	F58A4.4
+Y97E10AR.5	F58A4.4
+ZC239.7	F58A4.4
+ZC395.7	F58A4.4
+ZC412.2	F58A4.4
+ZK455.2	F58A4.4
+ZK563.7	F58A4.4
+ZK593.1	F58A4.4
+ZK673.2	F58A4.4
+ZK856.10	F58A4.4
+ZK896.8	F58A4.4
+ZK909.3	F58A4.4
+ZK970.5	F58A4.4
+ZK970.6	F58A4.4
+H27M09.2	F58A4.9
+H43I07.2	F58A4.9
+K02D7.1	F58A4.9
+K08H10.4	F58A4.9
+M04G12.3	F58A4.9
+M106.4	F58A4.9
+R01H10.1	F58A4.9
+R04F11.3	F58A4.9
+R05F9.6	F58A4.9
+R06C7.5	F58A4.9
+R07E4.4	F58A4.9
+R07H5.8	F58A4.9
+R134.1	F58A4.9
+R134.2	F58A4.9
+R151.2	F58A4.9
+R153.1	F58A4.9
+T01A4.1	F58A4.9
+T03D8.5	F58A4.9
+T03F1.8	F58A4.9
+T04A8.5	F58A4.9
+T04D3.3	F58A4.9
+T04D3.4	F58A4.9
+T14G10.1	F58A4.9
+T19B4.3	F58A4.9
+T22D1.3	F58A4.9
+T23G5.1	F58A4.9
+T24C4.5	F58A4.9
+T26C12.4	F58A4.9
+W01G7.3	F58A4.9
+W02D9.1	F58A4.9
+W03F11.2	F58A4.9
+W06E11.1	F58A4.9
+W09C3.4	F58A4.9
+Y105C5B.2	F58A4.9
+Y105E8B.5	F58A4.9
+Y10G11A.1	F58A4.9
+Y37E3.3	F58A4.9
+Y37H9A.6	F58A4.9
+Y43F4B.5	F58A4.9
+Y47D3A.29	F58A4.9
+Y48E1A.1	F58A4.9
+Y53F4B.3	F58A4.9
+Y54E10BR.6	F58A4.9
+Y56A3A.13	F58A4.9
+Y71H10B.1	F58A4.9
+Y77E11A.6	F58A4.9
+Y95B8A.10	F58A4.9
+Y97E10AR.5	F58A4.9
+ZC239.7	F58A4.9
+ZC395.7	F58A4.9
+ZC412.2	F58A4.9
+ZK455.2	F58A4.9
+ZK563.7	F58A4.9
+ZK593.1	F58A4.9
+ZK673.2	F58A4.9
+ZK856.10	F58A4.9
+ZK896.8	F58A4.9
+ZK909.3	F58A4.9
+ZK970.5	F58A4.9
+ZK970.6	F58A4.9
+H43I07.2	H27M09.2
+K02D7.1	H27M09.2
+K08H10.4	H27M09.2
+M04G12.3	H27M09.2
+M106.4	H27M09.2
+R01H10.1	H27M09.2
+R04F11.3	H27M09.2
+R05F9.6	H27M09.2
+R06C7.5	H27M09.2
+R07E4.4	H27M09.2
+R07H5.8	H27M09.2
+R134.1	H27M09.2
+R134.2	H27M09.2
+R151.2	H27M09.2
+R153.1	H27M09.2
+T01A4.1	H27M09.2
+T03D8.5	H27M09.2
+T03F1.8	H27M09.2
+T04A8.5	H27M09.2
+T04D3.3	H27M09.2
+T04D3.4	H27M09.2
+T14G10.1	H27M09.2
+T19B4.3	H27M09.2
+T22D1.3	H27M09.2
+T23G5.1	H27M09.2
+T24C4.5	H27M09.2
+T26C12.4	H27M09.2
+W01G7.3	H27M09.2
+W02D9.1	H27M09.2
+W03F11.2	H27M09.2
+W06E11.1	H27M09.2
+W09C3.4	H27M09.2
+Y105C5B.2	H27M09.2
+Y105E8B.5	H27M09.2
+Y10G11A.1	H27M09.2
+Y37E3.3	H27M09.2
+Y37H9A.6	H27M09.2
+Y43F4B.5	H27M09.2
+Y47D3A.29	H27M09.2
+Y48E1A.1	H27M09.2
+Y53F4B.3	H27M09.2
+Y54E10BR.6	H27M09.2
+Y56A3A.13	H27M09.2
+Y71H10B.1	H27M09.2
+Y77E11A.6	H27M09.2
+Y95B8A.10	H27M09.2
+Y97E10AR.5	H27M09.2
+ZC239.7	H27M09.2
+ZC395.7	H27M09.2
+ZC412.2	H27M09.2
+ZK455.2	H27M09.2
+ZK563.7	H27M09.2
+ZK593.1	H27M09.2
+ZK673.2	H27M09.2
+ZK856.10	H27M09.2
+ZK896.8	H27M09.2
+ZK909.3	H27M09.2
+ZK970.5	H27M09.2
+ZK970.6	H27M09.2
+K02D7.1	H43I07.2
+K08H10.4	H43I07.2
+M04G12.3	H43I07.2
+M106.4	H43I07.2
+R01H10.1	H43I07.2
+R04F11.3	H43I07.2
+R05F9.6	H43I07.2
+R06C7.5	H43I07.2
+R07E4.4	H43I07.2
+R07H5.8	H43I07.2
+R134.1	H43I07.2
+R134.2	H43I07.2
+R151.2	H43I07.2
+R153.1	H43I07.2
+T01A4.1	H43I07.2
+T03D8.5	H43I07.2
+T03F1.8	H43I07.2
+T04A8.5	H43I07.2
+T04D3.3	H43I07.2
+T04D3.4	H43I07.2
+T14G10.1	H43I07.2
+T19B4.3	H43I07.2
+T22D1.3	H43I07.2
+T23G5.1	H43I07.2
+T24C4.5	H43I07.2
+T26C12.4	H43I07.2
+W01G7.3	H43I07.2
+W02D9.1	H43I07.2
+W03F11.2	H43I07.2
+W06E11.1	H43I07.2
+W09C3.4	H43I07.2
+Y105C5B.2	H43I07.2
+Y105E8B.5	H43I07.2
+Y10G11A.1	H43I07.2
+Y37E3.3	H43I07.2
+Y37H9A.6	H43I07.2
+Y43F4B.5	H43I07.2
+Y47D3A.29	H43I07.2
+Y48E1A.1	H43I07.2
+Y53F4B.3	H43I07.2
+Y54E10BR.6	H43I07.2
+Y56A3A.13	H43I07.2
+Y71H10B.1	H43I07.2
+Y77E11A.6	H43I07.2
+Y95B8A.10	H43I07.2
+Y97E10AR.5	H43I07.2
+ZC239.7	H43I07.2
+ZC395.7	H43I07.2
+ZC412.2	H43I07.2
+ZK455.2	H43I07.2
+ZK563.7	H43I07.2
+ZK593.1	H43I07.2
+ZK673.2	H43I07.2
+ZK856.10	H43I07.2
+ZK896.8	H43I07.2
+ZK909.3	H43I07.2
+ZK970.5	H43I07.2
+ZK970.6	H43I07.2
+K08H10.4	K02D7.1
+M04G12.3	K02D7.1
+M106.4	K02D7.1
+R01H10.1	K02D7.1
+R04F11.3	K02D7.1
+R05F9.6	K02D7.1
+R06C7.5	K02D7.1
+R07E4.4	K02D7.1
+R07H5.8	K02D7.1
+R134.1	K02D7.1
+R134.2	K02D7.1
+R151.2	K02D7.1
+R153.1	K02D7.1
+T01A4.1	K02D7.1
+T03D8.5	K02D7.1
+T03F1.8	K02D7.1
+T04A8.5	K02D7.1
+T04D3.3	K02D7.1
+T04D3.4	K02D7.1
+T14G10.1	K02D7.1
+T19B4.3	K02D7.1
+T22D1.3	K02D7.1
+T23G5.1	K02D7.1
+T24C4.5	K02D7.1
+T26C12.4	K02D7.1
+W01G7.3	K02D7.1
+W02D9.1	K02D7.1
+W03F11.2	K02D7.1
+W06E11.1	K02D7.1
+W09C3.4	K02D7.1
+Y105C5B.2	K02D7.1
+Y105E8B.5	K02D7.1
+Y10G11A.1	K02D7.1
+Y37E3.3	K02D7.1
+Y37H9A.6	K02D7.1
+Y43F4B.5	K02D7.1
+Y47D3A.29	K02D7.1
+Y48E1A.1	K02D7.1
+Y53F4B.3	K02D7.1
+Y54E10BR.6	K02D7.1
+Y56A3A.13	K02D7.1
+Y71H10B.1	K02D7.1
+Y77E11A.6	K02D7.1
+Y95B8A.10	K02D7.1
+Y97E10AR.5	K02D7.1
+ZC239.7	K02D7.1
+ZC395.7	K02D7.1
+ZC412.2	K02D7.1
+ZK455.2	K02D7.1
+ZK563.7	K02D7.1
+ZK593.1	K02D7.1
+ZK673.2	K02D7.1
+ZK856.10	K02D7.1
+ZK896.8	K02D7.1
+ZK909.3	K02D7.1
+ZK970.5	K02D7.1
+ZK970.6	K02D7.1
+M04G12.3	K08H10.4
+M106.4	K08H10.4
+R01H10.1	K08H10.4
+R04F11.3	K08H10.4
+R05F9.6	K08H10.4
+R06C7.5	K08H10.4
+R07E4.4	K08H10.4
+R07H5.8	K08H10.4
+R134.1	K08H10.4
+R134.2	K08H10.4
+R151.2	K08H10.4
+R153.1	K08H10.4
+T01A4.1	K08H10.4
+T03D8.5	K08H10.4
+T03F1.8	K08H10.4
+T04A8.5	K08H10.4
+T04D3.3	K08H10.4
+T04D3.4	K08H10.4
+T14G10.1	K08H10.4
+T19B4.3	K08H10.4
+T22D1.3	K08H10.4
+T23G5.1	K08H10.4
+T24C4.5	K08H10.4
+T26C12.4	K08H10.4
+W01G7.3	K08H10.4
+W02D9.1	K08H10.4
+W03F11.2	K08H10.4
+W06E11.1	K08H10.4
+W09C3.4	K08H10.4
+Y105C5B.2	K08H10.4
+Y105E8B.5	K08H10.4
+Y10G11A.1	K08H10.4
+Y37E3.3	K08H10.4
+Y37H9A.6	K08H10.4
+Y43F4B.5	K08H10.4
+Y47D3A.29	K08H10.4
+Y48E1A.1	K08H10.4
+Y53F4B.3	K08H10.4
+Y54E10BR.6	K08H10.4
+Y56A3A.13	K08H10.4
+Y71H10B.1	K08H10.4
+Y77E11A.6	K08H10.4
+Y95B8A.10	K08H10.4
+Y97E10AR.5	K08H10.4
+ZC239.7	K08H10.4
+ZC395.7	K08H10.4
+ZC412.2	K08H10.4
+ZK455.2	K08H10.4
+ZK563.7	K08H10.4
+ZK593.1	K08H10.4
+ZK673.2	K08H10.4
+ZK856.10	K08H10.4
+ZK896.8	K08H10.4
+ZK909.3	K08H10.4
+ZK970.5	K08H10.4
+ZK970.6	K08H10.4
+M106.4	M04G12.3
+R01H10.1	M04G12.3
+R04F11.3	M04G12.3
+R05F9.6	M04G12.3
+R06C7.5	M04G12.3
+R07E4.4	M04G12.3
+R07H5.8	M04G12.3
+R134.1	M04G12.3
+R134.2	M04G12.3
+R151.2	M04G12.3
+R153.1	M04G12.3
+T01A4.1	M04G12.3
+T03D8.5	M04G12.3
+T03F1.8	M04G12.3
+T04A8.5	M04G12.3
+T04D3.3	M04G12.3
+T04D3.4	M04G12.3
+T14G10.1	M04G12.3
+T19B4.3	M04G12.3
+T22D1.3	M04G12.3
+T23G5.1	M04G12.3
+T24C4.5	M04G12.3
+T26C12.4	M04G12.3
+W01G7.3	M04G12.3
+W02D9.1	M04G12.3
+W03F11.2	M04G12.3
+W06E11.1	M04G12.3
+W09C3.4	M04G12.3
+Y105C5B.2	M04G12.3
+Y105E8B.5	M04G12.3
+Y10G11A.1	M04G12.3
+Y37E3.3	M04G12.3
+Y37H9A.6	M04G12.3
+Y43F4B.5	M04G12.3
+Y47D3A.29	M04G12.3
+Y48E1A.1	M04G12.3
+Y53F4B.3	M04G12.3
+Y54E10BR.6	M04G12.3
+Y56A3A.13	M04G12.3
+Y71H10B.1	M04G12.3
+Y77E11A.6	M04G12.3
+Y95B8A.10	M04G12.3
+Y97E10AR.5	M04G12.3
+ZC239.7	M04G12.3
+ZC395.7	M04G12.3
+ZC412.2	M04G12.3
+ZK455.2	M04G12.3
+ZK563.7	M04G12.3
+ZK593.1	M04G12.3
+ZK673.2	M04G12.3
+ZK856.10	M04G12.3
+ZK896.8	M04G12.3
+ZK909.3	M04G12.3
+ZK970.5	M04G12.3
+ZK970.6	M04G12.3
+R01H10.1	M106.4
+R04F11.3	M106.4
+R05F9.6	M106.4
+R06C7.5	M106.4
+R07E4.4	M106.4
+R07H5.8	M106.4
+R134.1	M106.4
+R134.2	M106.4
+R151.2	M106.4
+R153.1	M106.4
+T01A4.1	M106.4
+T03D8.5	M106.4
+T03F1.8	M106.4
+T04A8.5	M106.4
+T04D3.3	M106.4
+T04D3.4	M106.4
+T14G10.1	M106.4
+T19B4.3	M106.4
+T22D1.3	M106.4
+T23G5.1	M106.4
+T24C4.5	M106.4
+T26C12.4	M106.4
+W01G7.3	M106.4
+W02D9.1	M106.4
+W03F11.2	M106.4
+W06E11.1	M106.4
+W09C3.4	M106.4
+Y105C5B.2	M106.4
+Y105E8B.5	M106.4
+Y10G11A.1	M106.4
+Y37E3.3	M106.4
+Y37H9A.6	M106.4
+Y43F4B.5	M106.4
+Y47D3A.29	M106.4
+Y48E1A.1	M106.4
+Y53F4B.3	M106.4
+Y54E10BR.6	M106.4
+Y56A3A.13	M106.4
+Y71H10B.1	M106.4
+Y77E11A.6	M106.4
+Y95B8A.10	M106.4
+Y97E10AR.5	M106.4
+ZC239.7	M106.4
+ZC395.7	M106.4
+ZC412.2	M106.4
+ZK455.2	M106.4
+ZK563.7	M106.4
+ZK593.1	M106.4
+ZK673.2	M106.4
+ZK856.10	M106.4
+ZK896.8	M106.4
+ZK909.3	M106.4
+ZK970.5	M106.4
+ZK970.6	M106.4
+R04F11.3	R01H10.1
+R05F9.6	R01H10.1
+R06C7.5	R01H10.1
+R07E4.4	R01H10.1
+R07H5.8	R01H10.1
+R134.1	R01H10.1
+R134.2	R01H10.1
+R151.2	R01H10.1
+R153.1	R01H10.1
+T01A4.1	R01H10.1
+T03D8.5	R01H10.1
+T03F1.8	R01H10.1
+T04A8.5	R01H10.1
+T04D3.3	R01H10.1
+T04D3.4	R01H10.1
+T14G10.1	R01H10.1
+T19B4.3	R01H10.1
+T22D1.3	R01H10.1
+T23G5.1	R01H10.1
+T24C4.5	R01H10.1
+T26C12.4	R01H10.1
+W01G7.3	R01H10.1
+W02D9.1	R01H10.1
+W03F11.2	R01H10.1
+W06E11.1	R01H10.1
+W09C3.4	R01H10.1
+Y105C5B.2	R01H10.1
+Y105E8B.5	R01H10.1
+Y10G11A.1	R01H10.1
+Y37E3.3	R01H10.1
+Y37H9A.6	R01H10.1
+Y43F4B.5	R01H10.1
+Y47D3A.29	R01H10.1
+Y48E1A.1	R01H10.1
+Y53F4B.3	R01H10.1
+Y54E10BR.6	R01H10.1
+Y56A3A.13	R01H10.1
+Y71H10B.1	R01H10.1
+Y77E11A.6	R01H10.1
+Y95B8A.10	R01H10.1
+Y97E10AR.5	R01H10.1
+ZC239.7	R01H10.1
+ZC395.7	R01H10.1
+ZC412.2	R01H10.1
+ZK455.2	R01H10.1
+ZK563.7	R01H10.1
+ZK593.1	R01H10.1
+ZK673.2	R01H10.1
+ZK856.10	R01H10.1
+ZK896.8	R01H10.1
+ZK909.3	R01H10.1
+ZK970.5	R01H10.1
+ZK970.6	R01H10.1
+R05F9.6	R04F11.3
+R06C7.5	R04F11.3
+R07E4.4	R04F11.3
+R07H5.8	R04F11.3
+R134.1	R04F11.3
+R134.2	R04F11.3
+R151.2	R04F11.3
+R153.1	R04F11.3
+T01A4.1	R04F11.3
+T03D8.5	R04F11.3
+T03F1.8	R04F11.3
+T04A8.5	R04F11.3
+T04D3.3	R04F11.3
+T04D3.4	R04F11.3
+T14G10.1	R04F11.3
+T19B4.3	R04F11.3
+T22D1.3	R04F11.3
+T23G5.1	R04F11.3
+T24C4.5	R04F11.3
+T26C12.4	R04F11.3
+W01G7.3	R04F11.3
+W02D9.1	R04F11.3
+W03F11.2	R04F11.3
+W06E11.1	R04F11.3
+W09C3.4	R04F11.3
+Y105C5B.2	R04F11.3
+Y105E8B.5	R04F11.3
+Y10G11A.1	R04F11.3
+Y37E3.3	R04F11.3
+Y37H9A.6	R04F11.3
+Y43F4B.5	R04F11.3
+Y47D3A.29	R04F11.3
+Y48E1A.1	R04F11.3
+Y53F4B.3	R04F11.3
+Y54E10BR.6	R04F11.3
+Y56A3A.13	R04F11.3
+Y71H10B.1	R04F11.3
+Y77E11A.6	R04F11.3
+Y95B8A.10	R04F11.3
+Y97E10AR.5	R04F11.3
+ZC239.7	R04F11.3
+ZC395.7	R04F11.3
+ZC412.2	R04F11.3
+ZK455.2	R04F11.3
+ZK563.7	R04F11.3
+ZK593.1	R04F11.3
+ZK673.2	R04F11.3
+ZK856.10	R04F11.3
+ZK896.8	R04F11.3
+ZK909.3	R04F11.3
+ZK970.5	R04F11.3
+ZK970.6	R04F11.3
+R06C7.5	R05F9.6
+R07E4.4	R05F9.6
+R07H5.8	R05F9.6
+R134.1	R05F9.6
+R134.2	R05F9.6
+R153.1	R05F9.6
+T01A4.1	R05F9.6
+T03D8.5	R05F9.6
+T03F1.8	R05F9.6
+T04A8.5	R05F9.6
+T04D3.3	R05F9.6
+T04D3.4	R05F9.6
+T14G10.1	R05F9.6
+T19B4.3	R05F9.6
+T22D1.3	R05F9.6
+T23G5.1	R05F9.6
+T24C4.5	R05F9.6
+T26C12.4	R05F9.6
+W01G7.3	R05F9.6
+W02D9.1	R05F9.6
+W03F11.2	R05F9.6
+W06E11.1	R05F9.6
+W09C3.4	R05F9.6
+Y105C5B.2	R05F9.6
+Y105E8B.5	R05F9.6
+Y10G11A.1	R05F9.6
+Y37E3.3	R05F9.6
+Y37H9A.6	R05F9.6
+Y47D3A.29	R05F9.6
+Y48E1A.1	R05F9.6
+Y53F4B.3	R05F9.6
+Y54E10BR.6	R05F9.6
+Y56A3A.13	R05F9.6
+Y71H10B.1	R05F9.6
+Y77E11A.6	R05F9.6
+Y95B8A.10	R05F9.6
+Y97E10AR.5	R05F9.6
+ZC239.7	R05F9.6
+ZC395.7	R05F9.6
+ZC412.2	R05F9.6
+ZK455.2	R05F9.6
+ZK563.7	R05F9.6
+ZK673.2	R05F9.6
+ZK856.10	R05F9.6
+ZK896.8	R05F9.6
+ZK909.3	R05F9.6
+ZK970.5	R05F9.6
+ZK970.6	R05F9.6
+R07E4.4	R06C7.5
+R07H5.8	R06C7.5
+R134.1	R06C7.5
+R134.2	R06C7.5
+R151.2	R06C7.5
+R153.1	R06C7.5
+T01A4.1	R06C7.5
+T03D8.5	R06C7.5
+T03F1.8	R06C7.5
+T04A8.5	R06C7.5
+T04D3.3	R06C7.5
+T04D3.4	R06C7.5
+T14G10.1	R06C7.5
+T19B4.3	R06C7.5
+T22D1.3	R06C7.5
+T23G5.1	R06C7.5
+T24C4.5	R06C7.5
+T26C12.4	R06C7.5
+W01G7.3	R06C7.5
+W02D9.1	R06C7.5
+W03F11.2	R06C7.5
+W06E11.1	R06C7.5
+W09C3.4	R06C7.5
+Y105C5B.2	R06C7.5
+Y105E8B.5	R06C7.5
+Y10G11A.1	R06C7.5
+Y37E3.3	R06C7.5
+Y37H9A.6	R06C7.5
+Y43F4B.5	R06C7.5
+Y47D3A.29	R06C7.5
+Y48E1A.1	R06C7.5
+Y53F4B.3	R06C7.5
+Y54E10BR.6	R06C7.5
+Y56A3A.13	R06C7.5
+Y71H10B.1	R06C7.5
+Y77E11A.6	R06C7.5
+Y95B8A.10	R06C7.5
+Y97E10AR.5	R06C7.5
+ZC239.7	R06C7.5
+ZC395.7	R06C7.5
+ZC412.2	R06C7.5
+ZK455.2	R06C7.5
+ZK563.7	R06C7.5
+ZK593.1	R06C7.5
+ZK673.2	R06C7.5
+ZK856.10	R06C7.5
+ZK896.8	R06C7.5
+ZK909.3	R06C7.5
+ZK970.5	R06C7.5
+ZK970.6	R06C7.5
+R07H5.8	R07E4.4
+R134.1	R07E4.4
+R134.2	R07E4.4
+R151.2	R07E4.4
+R153.1	R07E4.4
+T01A4.1	R07E4.4
+T03D8.5	R07E4.4
+T03F1.8	R07E4.4
+T04A8.5	R07E4.4
+T04D3.3	R07E4.4
+T04D3.4	R07E4.4
+T14G10.1	R07E4.4
+T19B4.3	R07E4.4
+T22D1.3	R07E4.4
+T23G5.1	R07E4.4
+T24C4.5	R07E4.4
+T26C12.4	R07E4.4
+W01G7.3	R07E4.4
+W02D9.1	R07E4.4
+W03F11.2	R07E4.4
+W06E11.1	R07E4.4
+W09C3.4	R07E4.4
+Y105C5B.2	R07E4.4
+Y105E8B.5	R07E4.4
+Y10G11A.1	R07E4.4
+Y37E3.3	R07E4.4
+Y37H9A.6	R07E4.4
+Y43F4B.5	R07E4.4
+Y47D3A.29	R07E4.4
+Y48E1A.1	R07E4.4
+Y53F4B.3	R07E4.4
+Y54E10BR.6	R07E4.4
+Y56A3A.13	R07E4.4
+Y71H10B.1	R07E4.4
+Y77E11A.6	R07E4.4
+Y95B8A.10	R07E4.4
+Y97E10AR.5	R07E4.4
+ZC239.7	R07E4.4
+ZC395.7	R07E4.4
+ZC412.2	R07E4.4
+ZK455.2	R07E4.4
+ZK563.7	R07E4.4
+ZK593.1	R07E4.4
+ZK673.2	R07E4.4
+ZK856.10	R07E4.4
+ZK896.8	R07E4.4
+ZK909.3	R07E4.4
+ZK970.5	R07E4.4
+ZK970.6	R07E4.4
+R134.1	R07H5.8
+R134.2	R07H5.8
+R151.2	R07H5.8
+R153.1	R07H5.8
+T01A4.1	R07H5.8
+T03D8.5	R07H5.8
+T03F1.8	R07H5.8
+T04A8.5	R07H5.8
+T04D3.3	R07H5.8
+T04D3.4	R07H5.8
+T14G10.1	R07H5.8
+T19B4.3	R07H5.8
+T22D1.3	R07H5.8
+T23G5.1	R07H5.8
+T24C4.5	R07H5.8
+T26C12.4	R07H5.8
+W01G7.3	R07H5.8
+W02D9.1	R07H5.8
+W03F11.2	R07H5.8
+W06E11.1	R07H5.8
+W09C3.4	R07H5.8
+Y105C5B.2	R07H5.8
+Y105E8B.5	R07H5.8
+Y10G11A.1	R07H5.8
+Y37E3.3	R07H5.8
+Y37H9A.6	R07H5.8
+Y43F4B.5	R07H5.8
+Y47D3A.29	R07H5.8
+Y48E1A.1	R07H5.8
+Y53F4B.3	R07H5.8
+Y54E10BR.6	R07H5.8
+Y56A3A.13	R07H5.8
+Y71H10B.1	R07H5.8
+Y77E11A.6	R07H5.8
+Y95B8A.10	R07H5.8
+Y97E10AR.5	R07H5.8
+ZC239.7	R07H5.8
+ZC395.7	R07H5.8
+ZC412.2	R07H5.8
+ZK455.2	R07H5.8
+ZK563.7	R07H5.8
+ZK593.1	R07H5.8
+ZK673.2	R07H5.8
+ZK856.10	R07H5.8
+ZK896.8	R07H5.8
+ZK909.3	R07H5.8
+ZK970.5	R07H5.8
+ZK970.6	R07H5.8
+R134.2	R134.1
+R151.2	R134.1
+R153.1	R134.1
+T01A4.1	R134.1
+T03D8.5	R134.1
+T03F1.8	R134.1
+T04A8.5	R134.1
+T04D3.3	R134.1
+T04D3.4	R134.1
+T14G10.1	R134.1
+T19B4.3	R134.1
+T22D1.3	R134.1
+T23G5.1	R134.1
+T24C4.5	R134.1
+T26C12.4	R134.1
+W01G7.3	R134.1
+W02D9.1	R134.1
+W03F11.2	R134.1
+W06E11.1	R134.1
+W09C3.4	R134.1
+Y105C5B.2	R134.1
+Y105E8B.5	R134.1
+Y10G11A.1	R134.1
+Y37E3.3	R134.1
+Y37H9A.6	R134.1
+Y43F4B.5	R134.1
+Y47D3A.29	R134.1
+Y48E1A.1	R134.1
+Y53F4B.3	R134.1
+Y54E10BR.6	R134.1
+Y56A3A.13	R134.1
+Y71H10B.1	R134.1
+Y77E11A.6	R134.1
+Y95B8A.10	R134.1
+Y97E10AR.5	R134.1
+ZC239.7	R134.1
+ZC395.7	R134.1
+ZC412.2	R134.1
+ZK455.2	R134.1
+ZK563.7	R134.1
+ZK593.1	R134.1
+ZK673.2	R134.1
+ZK856.10	R134.1
+ZK896.8	R134.1
+ZK909.3	R134.1
+ZK970.5	R134.1
+ZK970.6	R134.1
+R151.2	R134.2
+R153.1	R134.2
+T01A4.1	R134.2
+T03D8.5	R134.2
+T03F1.8	R134.2
+T04A8.5	R134.2
+T04D3.3	R134.2
+T04D3.4	R134.2
+T14G10.1	R134.2
+T19B4.3	R134.2
+T22D1.3	R134.2
+T23G5.1	R134.2
+T24C4.5	R134.2
+T26C12.4	R134.2
+W01G7.3	R134.2
+W02D9.1	R134.2
+W03F11.2	R134.2
+W06E11.1	R134.2
+W09C3.4	R134.2
+Y105C5B.2	R134.2
+Y105E8B.5	R134.2
+Y10G11A.1	R134.2
+Y37E3.3	R134.2
+Y37H9A.6	R134.2
+Y43F4B.5	R134.2
+Y47D3A.29	R134.2
+Y48E1A.1	R134.2
+Y53F4B.3	R134.2
+Y54E10BR.6	R134.2
+Y56A3A.13	R134.2
+Y71H10B.1	R134.2
+Y77E11A.6	R134.2
+Y95B8A.10	R134.2
+Y97E10AR.5	R134.2
+ZC239.7	R134.2
+ZC395.7	R134.2
+ZC412.2	R134.2
+ZK455.2	R134.2
+ZK563.7	R134.2
+ZK593.1	R134.2
+ZK673.2	R134.2
+ZK856.10	R134.2
+ZK896.8	R134.2
+ZK909.3	R134.2
+ZK970.5	R134.2
+ZK970.6	R134.2
+R153.1	R151.2
+T01A4.1	R151.2
+T03D8.5	R151.2
+T03F1.8	R151.2
+T04A8.5	R151.2
+T04D3.3	R151.2
+T04D3.4	R151.2
+T14G10.1	R151.2
+T19B4.3	R151.2
+T22D1.3	R151.2
+T23G5.1	R151.2
+T24C4.5	R151.2
+T26C12.4	R151.2
+W01G7.3	R151.2
+W02D9.1	R151.2
+W03F11.2	R151.2
+W06E11.1	R151.2
+W09C3.4	R151.2
+Y105C5B.2	R151.2
+Y105E8B.5	R151.2
+Y10G11A.1	R151.2
+Y37E3.3	R151.2
+Y37H9A.6	R151.2
+Y47D3A.29	R151.2
+Y48E1A.1	R151.2
+Y53F4B.3	R151.2
+Y54E10BR.6	R151.2
+Y56A3A.13	R151.2
+Y71H10B.1	R151.2
+Y77E11A.6	R151.2
+Y95B8A.10	R151.2
+Y97E10AR.5	R151.2
+ZC239.7	R151.2
+ZC395.7	R151.2
+ZC412.2	R151.2
+ZK455.2	R151.2
+ZK563.7	R151.2
+ZK593.1	R151.2
+ZK673.2	R151.2
+ZK856.10	R151.2
+ZK896.8	R151.2
+ZK909.3	R151.2
+ZK970.5	R151.2
+ZK970.6	R151.2
+T01A4.1	R153.1
+T03D8.5	R153.1
+T03F1.8	R153.1
+T04A8.5	R153.1
+T04D3.3	R153.1
+T04D3.4	R153.1
+T14G10.1	R153.1
+T19B4.3	R153.1
+T22D1.3	R153.1
+T23G5.1	R153.1
+T24C4.5	R153.1
+T26C12.4	R153.1
+W01G7.3	R153.1
+W02D9.1	R153.1
+W03F11.2	R153.1
+W06E11.1	R153.1
+W09C3.4	R153.1
+Y105C5B.2	R153.1
+Y105E8B.5	R153.1
+Y10G11A.1	R153.1
+Y37E3.3	R153.1
+Y37H9A.6	R153.1
+Y43F4B.5	R153.1
+Y47D3A.29	R153.1
+Y48E1A.1	R153.1
+Y53F4B.3	R153.1
+Y54E10BR.6	R153.1
+Y56A3A.13	R153.1
+Y71H10B.1	R153.1
+Y77E11A.6	R153.1
+Y95B8A.10	R153.1
+Y97E10AR.5	R153.1
+ZC239.7	R153.1
+ZC395.7	R153.1
+ZC412.2	R153.1
+ZK455.2	R153.1
+ZK563.7	R153.1
+ZK593.1	R153.1
+ZK673.2	R153.1
+ZK856.10	R153.1
+ZK896.8	R153.1
+ZK909.3	R153.1
+ZK970.5	R153.1
+ZK970.6	R153.1
+T03D8.5	T01A4.1
+T03F1.8	T01A4.1
+T04A8.5	T01A4.1
+T04D3.3	T01A4.1
+T04D3.4	T01A4.1
+T14G10.1	T01A4.1
+T19B4.3	T01A4.1
+T22D1.3	T01A4.1
+T23G5.1	T01A4.1
+T24C4.5	T01A4.1
+T26C12.4	T01A4.1
+W01G7.3	T01A4.1
+W02D9.1	T01A4.1
+W03F11.2	T01A4.1
+W06E11.1	T01A4.1
+W09C3.4	T01A4.1
+Y105C5B.2	T01A4.1
+Y105E8B.5	T01A4.1
+Y10G11A.1	T01A4.1
+Y37E3.3	T01A4.1
+Y37H9A.6	T01A4.1
+Y43F4B.5	T01A4.1
+Y47D3A.29	T01A4.1
+Y48E1A.1	T01A4.1
+Y53F4B.3	T01A4.1
+Y54E10BR.6	T01A4.1
+Y56A3A.13	T01A4.1
+Y71H10B.1	T01A4.1
+Y77E11A.6	T01A4.1
+Y95B8A.10	T01A4.1
+Y97E10AR.5	T01A4.1
+ZC239.7	T01A4.1
+ZC395.7	T01A4.1
+ZC412.2	T01A4.1
+ZK455.2	T01A4.1
+ZK563.7	T01A4.1
+ZK593.1	T01A4.1
+ZK673.2	T01A4.1
+ZK856.10	T01A4.1
+ZK896.8	T01A4.1
+ZK909.3	T01A4.1
+ZK970.5	T01A4.1
+ZK970.6	T01A4.1
+T03F1.8	T03D8.5
+T04A8.5	T03D8.5
+T04D3.3	T03D8.5
+T04D3.4	T03D8.5
+T14G10.1	T03D8.5
+T19B4.3	T03D8.5
+T22D1.3	T03D8.5
+T23G5.1	T03D8.5
+T24C4.5	T03D8.5
+T26C12.4	T03D8.5
+W01G7.3	T03D8.5
+W02D9.1	T03D8.5
+W03F11.2	T03D8.5
+W06E11.1	T03D8.5
+W09C3.4	T03D8.5
+Y105C5B.2	T03D8.5
+Y105E8B.5	T03D8.5
+Y10G11A.1	T03D8.5
+Y37E3.3	T03D8.5
+Y37H9A.6	T03D8.5
+Y43F4B.5	T03D8.5
+Y47D3A.29	T03D8.5
+Y48E1A.1	T03D8.5
+Y53F4B.3	T03D8.5
+Y54E10BR.6	T03D8.5
+Y56A3A.13	T03D8.5
+Y71H10B.1	T03D8.5
+Y77E11A.6	T03D8.5
+Y95B8A.10	T03D8.5
+Y97E10AR.5	T03D8.5
+ZC239.7	T03D8.5
+ZC395.7	T03D8.5
+ZC412.2	T03D8.5
+ZK455.2	T03D8.5
+ZK563.7	T03D8.5
+ZK593.1	T03D8.5
+ZK673.2	T03D8.5
+ZK856.10	T03D8.5
+ZK896.8	T03D8.5
+ZK909.3	T03D8.5
+ZK970.5	T03D8.5
+ZK970.6	T03D8.5
+T04A8.5	T03F1.8
+T04D3.3	T03F1.8
+T04D3.4	T03F1.8
+T14G10.1	T03F1.8
+T19B4.3	T03F1.8
+T22D1.3	T03F1.8
+T23G5.1	T03F1.8
+T24C4.5	T03F1.8
+T26C12.4	T03F1.8
+W01G7.3	T03F1.8
+W02D9.1	T03F1.8
+W03F11.2	T03F1.8
+W06E11.1	T03F1.8
+W09C3.4	T03F1.8
+Y105C5B.2	T03F1.8
+Y105E8B.5	T03F1.8
+Y10G11A.1	T03F1.8
+Y37E3.3	T03F1.8
+Y37H9A.6	T03F1.8
+Y43F4B.5	T03F1.8
+Y47D3A.29	T03F1.8
+Y48E1A.1	T03F1.8
+Y53F4B.3	T03F1.8
+Y54E10BR.6	T03F1.8
+Y56A3A.13	T03F1.8
+Y71H10B.1	T03F1.8
+Y77E11A.6	T03F1.8
+Y95B8A.10	T03F1.8
+Y97E10AR.5	T03F1.8
+ZC239.7	T03F1.8
+ZC395.7	T03F1.8
+ZC412.2	T03F1.8
+ZK455.2	T03F1.8
+ZK563.7	T03F1.8
+ZK593.1	T03F1.8
+ZK673.2	T03F1.8
+ZK856.10	T03F1.8
+ZK896.8	T03F1.8
+ZK909.3	T03F1.8
+ZK970.5	T03F1.8
+ZK970.6	T03F1.8
+T04D3.3	T04A8.5
+T04D3.4	T04A8.5
+T14G10.1	T04A8.5
+T19B4.3	T04A8.5
+T22D1.3	T04A8.5
+T23G5.1	T04A8.5
+T24C4.5	T04A8.5
+T26C12.4	T04A8.5
+W01G7.3	T04A8.5
+W02D9.1	T04A8.5
+W03F11.2	T04A8.5
+W06E11.1	T04A8.5
+W09C3.4	T04A8.5
+Y105C5B.2	T04A8.5
+Y105E8B.5	T04A8.5
+Y10G11A.1	T04A8.5
+Y37E3.3	T04A8.5
+Y37H9A.6	T04A8.5
+Y43F4B.5	T04A8.5
+Y47D3A.29	T04A8.5
+Y48E1A.1	T04A8.5
+Y53F4B.3	T04A8.5
+Y54E10BR.6	T04A8.5
+Y56A3A.13	T04A8.5
+Y71H10B.1	T04A8.5
+Y77E11A.6	T04A8.5
+Y95B8A.10	T04A8.5
+Y97E10AR.5	T04A8.5
+ZC239.7	T04A8.5
+ZC395.7	T04A8.5
+ZC412.2	T04A8.5
+ZK455.2	T04A8.5
+ZK563.7	T04A8.5
+ZK593.1	T04A8.5
+ZK673.2	T04A8.5
+ZK856.10	T04A8.5
+ZK896.8	T04A8.5
+ZK909.3	T04A8.5
+ZK970.5	T04A8.5
+ZK970.6	T04A8.5
+T04D3.4	T04D3.3
+T14G10.1	T04D3.3
+T19B4.3	T04D3.3
+T22D1.3	T04D3.3
+T23G5.1	T04D3.3
+T24C4.5	T04D3.3
+T26C12.4	T04D3.3
+W01G7.3	T04D3.3
+W02D9.1	T04D3.3
+W03F11.2	T04D3.3
+W06E11.1	T04D3.3
+W09C3.4	T04D3.3
+Y105C5B.2	T04D3.3
+Y105E8B.5	T04D3.3
+Y10G11A.1	T04D3.3
+Y37E3.3	T04D3.3
+Y37H9A.6	T04D3.3
+Y43F4B.5	T04D3.3
+Y47D3A.29	T04D3.3
+Y48E1A.1	T04D3.3
+Y53F4B.3	T04D3.3
+Y54E10BR.6	T04D3.3
+Y56A3A.13	T04D3.3
+Y71H10B.1	T04D3.3
+Y77E11A.6	T04D3.3
+Y95B8A.10	T04D3.3
+Y97E10AR.5	T04D3.3
+ZC239.7	T04D3.3
+ZC395.7	T04D3.3
+ZC412.2	T04D3.3
+ZK455.2	T04D3.3
+ZK563.7	T04D3.3
+ZK593.1	T04D3.3
+ZK673.2	T04D3.3
+ZK856.10	T04D3.3
+ZK896.8	T04D3.3
+ZK909.3	T04D3.3
+ZK970.5	T04D3.3
+ZK970.6	T04D3.3
+T14G10.1	T04D3.4
+T19B4.3	T04D3.4
+T22D1.3	T04D3.4
+T23G5.1	T04D3.4
+T24C4.5	T04D3.4
+T26C12.4	T04D3.4
+W01G7.3	T04D3.4
+W02D9.1	T04D3.4
+W03F11.2	T04D3.4
+W06E11.1	T04D3.4
+W09C3.4	T04D3.4
+Y105C5B.2	T04D3.4
+Y105E8B.5	T04D3.4
+Y10G11A.1	T04D3.4
+Y37E3.3	T04D3.4
+Y37H9A.6	T04D3.4
+Y43F4B.5	T04D3.4
+Y47D3A.29	T04D3.4
+Y48E1A.1	T04D3.4
+Y53F4B.3	T04D3.4
+Y54E10BR.6	T04D3.4
+Y56A3A.13	T04D3.4
+Y71H10B.1	T04D3.4
+Y77E11A.6	T04D3.4
+Y95B8A.10	T04D3.4
+Y97E10AR.5	T04D3.4
+ZC239.7	T04D3.4
+ZC395.7	T04D3.4
+ZC412.2	T04D3.4
+ZK455.2	T04D3.4
+ZK563.7	T04D3.4
+ZK593.1	T04D3.4
+ZK673.2	T04D3.4
+ZK856.10	T04D3.4
+ZK896.8	T04D3.4
+ZK909.3	T04D3.4
+ZK970.5	T04D3.4
+ZK970.6	T04D3.4
+T19B4.3	T14G10.1
+T22D1.3	T14G10.1
+T23G5.1	T14G10.1
+T24C4.5	T14G10.1
+T26C12.4	T14G10.1
+W01G7.3	T14G10.1
+W02D9.1	T14G10.1
+W03F11.2	T14G10.1
+W06E11.1	T14G10.1
+W09C3.4	T14G10.1
+Y105C5B.2	T14G10.1
+Y105E8B.5	T14G10.1
+Y10G11A.1	T14G10.1
+Y37E3.3	T14G10.1
+Y37H9A.6	T14G10.1
+Y43F4B.5	T14G10.1
+Y47D3A.29	T14G10.1
+Y48E1A.1	T14G10.1
+Y53F4B.3	T14G10.1
+Y54E10BR.6	T14G10.1
+Y56A3A.13	T14G10.1
+Y71H10B.1	T14G10.1
+Y77E11A.6	T14G10.1
+Y95B8A.10	T14G10.1
+Y97E10AR.5	T14G10.1
+ZC239.7	T14G10.1
+ZC395.7	T14G10.1
+ZC412.2	T14G10.1
+ZK455.2	T14G10.1
+ZK563.7	T14G10.1
+ZK593.1	T14G10.1
+ZK673.2	T14G10.1
+ZK856.10	T14G10.1
+ZK896.8	T14G10.1
+ZK909.3	T14G10.1
+ZK970.5	T14G10.1
+ZK970.6	T14G10.1
+T22D1.3	T19B4.3
+T23G5.1	T19B4.3
+T24C4.5	T19B4.3
+T26C12.4	T19B4.3
+W01G7.3	T19B4.3
+W02D9.1	T19B4.3
+W03F11.2	T19B4.3
+W06E11.1	T19B4.3
+W09C3.4	T19B4.3
+Y105C5B.2	T19B4.3
+Y105E8B.5	T19B4.3
+Y10G11A.1	T19B4.3
+Y37E3.3	T19B4.3
+Y37H9A.6	T19B4.3
+Y43F4B.5	T19B4.3
+Y47D3A.29	T19B4.3
+Y48E1A.1	T19B4.3
+Y53F4B.3	T19B4.3
+Y54E10BR.6	T19B4.3
+Y56A3A.13	T19B4.3
+Y71H10B.1	T19B4.3
+Y77E11A.6	T19B4.3
+Y95B8A.10	T19B4.3
+Y97E10AR.5	T19B4.3
+ZC239.7	T19B4.3
+ZC395.7	T19B4.3
+ZC412.2	T19B4.3
+ZK455.2	T19B4.3
+ZK563.7	T19B4.3
+ZK593.1	T19B4.3
+ZK673.2	T19B4.3
+ZK856.10	T19B4.3
+ZK896.8	T19B4.3
+ZK909.3	T19B4.3
+ZK970.5	T19B4.3
+ZK970.6	T19B4.3
+T23G5.1	T22D1.3
+T24C4.5	T22D1.3
+T26C12.4	T22D1.3
+W01G7.3	T22D1.3
+W02D9.1	T22D1.3
+W03F11.2	T22D1.3
+W06E11.1	T22D1.3
+W09C3.4	T22D1.3
+Y105C5B.2	T22D1.3
+Y105E8B.5	T22D1.3
+Y10G11A.1	T22D1.3
+Y37E3.3	T22D1.3
+Y37H9A.6	T22D1.3
+Y43F4B.5	T22D1.3
+Y47D3A.29	T22D1.3
+Y48E1A.1	T22D1.3
+Y53F4B.3	T22D1.3
+Y54E10BR.6	T22D1.3
+Y56A3A.13	T22D1.3
+Y71H10B.1	T22D1.3
+Y77E11A.6	T22D1.3
+Y95B8A.10	T22D1.3
+Y97E10AR.5	T22D1.3
+ZC239.7	T22D1.3
+ZC395.7	T22D1.3
+ZC412.2	T22D1.3
+ZK455.2	T22D1.3
+ZK563.7	T22D1.3
+ZK593.1	T22D1.3
+ZK673.2	T22D1.3
+ZK856.10	T22D1.3
+ZK896.8	T22D1.3
+ZK909.3	T22D1.3
+ZK970.5	T22D1.3
+ZK970.6	T22D1.3
+T24C4.5	T23G5.1
+T26C12.4	T23G5.1
+W01G7.3	T23G5.1
+W02D9.1	T23G5.1
+W03F11.2	T23G5.1
+W06E11.1	T23G5.1
+W09C3.4	T23G5.1
+Y105C5B.2	T23G5.1
+Y105E8B.5	T23G5.1
+Y10G11A.1	T23G5.1
+Y37E3.3	T23G5.1
+Y37H9A.6	T23G5.1
+Y43F4B.5	T23G5.1
+Y47D3A.29	T23G5.1
+Y48E1A.1	T23G5.1
+Y53F4B.3	T23G5.1
+Y54E10BR.6	T23G5.1
+Y56A3A.13	T23G5.1
+Y71H10B.1	T23G5.1
+Y77E11A.6	T23G5.1
+Y95B8A.10	T23G5.1
+Y97E10AR.5	T23G5.1
+ZC239.7	T23G5.1
+ZC395.7	T23G5.1
+ZC412.2	T23G5.1
+ZK455.2	T23G5.1
+ZK563.7	T23G5.1
+ZK593.1	T23G5.1
+ZK673.2	T23G5.1
+ZK856.10	T23G5.1
+ZK896.8	T23G5.1
+ZK909.3	T23G5.1
+ZK970.5	T23G5.1
+ZK970.6	T23G5.1
+T26C12.4	T24C4.5
+W01G7.3	T24C4.5
+W02D9.1	T24C4.5
+W03F11.2	T24C4.5
+W06E11.1	T24C4.5
+W09C3.4	T24C4.5
+Y105C5B.2	T24C4.5
+Y105E8B.5	T24C4.5
+Y10G11A.1	T24C4.5
+Y37E3.3	T24C4.5
+Y37H9A.6	T24C4.5
+Y43F4B.5	T24C4.5
+Y47D3A.29	T24C4.5
+Y48E1A.1	T24C4.5
+Y53F4B.3	T24C4.5
+Y54E10BR.6	T24C4.5
+Y56A3A.13	T24C4.5
+Y71H10B.1	T24C4.5
+Y77E11A.6	T24C4.5
+Y95B8A.10	T24C4.5
+Y97E10AR.5	T24C4.5
+ZC239.7	T24C4.5
+ZC395.7	T24C4.5
+ZC412.2	T24C4.5
+ZK455.2	T24C4.5
+ZK563.7	T24C4.5
+ZK593.1	T24C4.5
+ZK673.2	T24C4.5
+ZK856.10	T24C4.5
+ZK896.8	T24C4.5
+ZK909.3	T24C4.5
+ZK970.5	T24C4.5
+ZK970.6	T24C4.5
+W01G7.3	T26C12.4
+W02D9.1	T26C12.4
+W03F11.2	T26C12.4
+W06E11.1	T26C12.4
+W09C3.4	T26C12.4
+Y105C5B.2	T26C12.4
+Y105E8B.5	T26C12.4
+Y10G11A.1	T26C12.4
+Y37E3.3	T26C12.4
+Y37H9A.6	T26C12.4
+Y43F4B.5	T26C12.4
+Y47D3A.29	T26C12.4
+Y48E1A.1	T26C12.4
+Y53F4B.3	T26C12.4
+Y54E10BR.6	T26C12.4
+Y56A3A.13	T26C12.4
+Y71H10B.1	T26C12.4
+Y77E11A.6	T26C12.4
+Y95B8A.10	T26C12.4
+Y97E10AR.5	T26C12.4
+ZC239.7	T26C12.4
+ZC395.7	T26C12.4
+ZC412.2	T26C12.4
+ZK455.2	T26C12.4
+ZK563.7	T26C12.4
+ZK593.1	T26C12.4
+ZK673.2	T26C12.4
+ZK856.10	T26C12.4
+ZK909.3	T26C12.4
+ZK970.5	T26C12.4
+ZK970.6	T26C12.4
+W02D9.1	W01G7.3
+W03F11.2	W01G7.3
+W06E11.1	W01G7.3
+W09C3.4	W01G7.3
+Y105C5B.2	W01G7.3
+Y105E8B.5	W01G7.3
+Y10G11A.1	W01G7.3
+Y37E3.3	W01G7.3
+Y37H9A.6	W01G7.3
+Y43F4B.5	W01G7.3
+Y47D3A.29	W01G7.3
+Y48E1A.1	W01G7.3
+Y53F4B.3	W01G7.3
+Y54E10BR.6	W01G7.3
+Y56A3A.13	W01G7.3
+Y71H10B.1	W01G7.3
+Y77E11A.6	W01G7.3
+Y95B8A.10	W01G7.3
+Y97E10AR.5	W01G7.3
+ZC239.7	W01G7.3
+ZC395.7	W01G7.3
+ZC412.2	W01G7.3
+ZK455.2	W01G7.3
+ZK563.7	W01G7.3
+ZK593.1	W01G7.3
+ZK673.2	W01G7.3
+ZK856.10	W01G7.3
+ZK896.8	W01G7.3
+ZK909.3	W01G7.3
+ZK970.5	W01G7.3
+ZK970.6	W01G7.3
+W03F11.2	W02D9.1
+W06E11.1	W02D9.1
+W09C3.4	W02D9.1
+Y105C5B.2	W02D9.1
+Y105E8B.5	W02D9.1
+Y10G11A.1	W02D9.1
+Y37E3.3	W02D9.1
+Y37H9A.6	W02D9.1
+Y43F4B.5	W02D9.1
+Y47D3A.29	W02D9.1
+Y48E1A.1	W02D9.1
+Y53F4B.3	W02D9.1
+Y54E10BR.6	W02D9.1
+Y56A3A.13	W02D9.1
+Y71H10B.1	W02D9.1
+Y77E11A.6	W02D9.1
+Y95B8A.10	W02D9.1
+Y97E10AR.5	W02D9.1
+ZC239.7	W02D9.1
+ZC395.7	W02D9.1
+ZC412.2	W02D9.1
+ZK455.2	W02D9.1
+ZK563.7	W02D9.1
+ZK593.1	W02D9.1
+ZK673.2	W02D9.1
+ZK856.10	W02D9.1
+ZK896.8	W02D9.1
+ZK909.3	W02D9.1
+ZK970.5	W02D9.1
+ZK970.6	W02D9.1
+W06E11.1	W03F11.2
+W09C3.4	W03F11.2
+Y105C5B.2	W03F11.2
+Y105E8B.5	W03F11.2
+Y10G11A.1	W03F11.2
+Y37E3.3	W03F11.2
+Y37H9A.6	W03F11.2
+Y43F4B.5	W03F11.2
+Y47D3A.29	W03F11.2
+Y48E1A.1	W03F11.2
+Y53F4B.3	W03F11.2
+Y54E10BR.6	W03F11.2
+Y56A3A.13	W03F11.2
+Y71H10B.1	W03F11.2
+Y77E11A.6	W03F11.2
+Y95B8A.10	W03F11.2
+Y97E10AR.5	W03F11.2
+ZC239.7	W03F11.2
+ZC395.7	W03F11.2
+ZC412.2	W03F11.2
+ZK455.2	W03F11.2
+ZK563.7	W03F11.2
+ZK593.1	W03F11.2
+ZK673.2	W03F11.2
+ZK856.10	W03F11.2
+ZK896.8	W03F11.2
+ZK909.3	W03F11.2
+ZK970.5	W03F11.2
+ZK970.6	W03F11.2
+W09C3.4	W06E11.1
+Y105C5B.2	W06E11.1
+Y105E8B.5	W06E11.1
+Y10G11A.1	W06E11.1
+Y37E3.3	W06E11.1
+Y37H9A.6	W06E11.1
+Y43F4B.5	W06E11.1
+Y47D3A.29	W06E11.1
+Y48E1A.1	W06E11.1
+Y53F4B.3	W06E11.1
+Y54E10BR.6	W06E11.1
+Y56A3A.13	W06E11.1
+Y71H10B.1	W06E11.1
+Y77E11A.6	W06E11.1
+Y95B8A.10	W06E11.1
+Y97E10AR.5	W06E11.1
+ZC239.7	W06E11.1
+ZC395.7	W06E11.1
+ZC412.2	W06E11.1
+ZK455.2	W06E11.1
+ZK563.7	W06E11.1
+ZK593.1	W06E11.1
+ZK673.2	W06E11.1
+ZK856.10	W06E11.1
+ZK896.8	W06E11.1
+ZK909.3	W06E11.1
+ZK970.5	W06E11.1
+ZK970.6	W06E11.1
+Y105C5B.2	W09C3.4
+Y105E8B.5	W09C3.4
+Y10G11A.1	W09C3.4
+Y37E3.3	W09C3.4
+Y37H9A.6	W09C3.4
+Y43F4B.5	W09C3.4
+Y47D3A.29	W09C3.4
+Y48E1A.1	W09C3.4
+Y53F4B.3	W09C3.4
+Y54E10BR.6	W09C3.4
+Y56A3A.13	W09C3.4
+Y71H10B.1	W09C3.4
+Y77E11A.6	W09C3.4
+Y95B8A.10	W09C3.4
+Y97E10AR.5	W09C3.4
+ZC239.7	W09C3.4
+ZC395.7	W09C3.4
+ZC412.2	W09C3.4
+ZK455.2	W09C3.4
+ZK563.7	W09C3.4
+ZK593.1	W09C3.4
+ZK673.2	W09C3.4
+ZK856.10	W09C3.4
+ZK896.8	W09C3.4
+ZK909.3	W09C3.4
+ZK970.5	W09C3.4
+ZK970.6	W09C3.4
+Y105E8B.5	Y105C5B.2
+Y10G11A.1	Y105C5B.2
+Y37E3.3	Y105C5B.2
+Y37H9A.6	Y105C5B.2
+Y43F4B.5	Y105C5B.2
+Y47D3A.29	Y105C5B.2
+Y48E1A.1	Y105C5B.2
+Y53F4B.3	Y105C5B.2
+Y54E10BR.6	Y105C5B.2
+Y56A3A.13	Y105C5B.2
+Y71H10B.1	Y105C5B.2
+Y77E11A.6	Y105C5B.2
+Y95B8A.10	Y105C5B.2
+Y97E10AR.5	Y105C5B.2
+ZC239.7	Y105C5B.2
+ZC395.7	Y105C5B.2
+ZC412.2	Y105C5B.2
+ZK455.2	Y105C5B.2
+ZK563.7	Y105C5B.2
+ZK593.1	Y105C5B.2
+ZK673.2	Y105C5B.2
+ZK856.10	Y105C5B.2
+ZK896.8	Y105C5B.2
+ZK909.3	Y105C5B.2
+ZK970.5	Y105C5B.2
+ZK970.6	Y105C5B.2
+Y10G11A.1	Y105E8B.5
+Y37E3.3	Y105E8B.5
+Y37H9A.6	Y105E8B.5
+Y43F4B.5	Y105E8B.5
+Y47D3A.29	Y105E8B.5
+Y48E1A.1	Y105E8B.5
+Y53F4B.3	Y105E8B.5
+Y54E10BR.6	Y105E8B.5
+Y56A3A.13	Y105E8B.5
+Y71H10B.1	Y105E8B.5
+Y77E11A.6	Y105E8B.5
+Y95B8A.10	Y105E8B.5
+Y97E10AR.5	Y105E8B.5
+ZC239.7	Y105E8B.5
+ZC395.7	Y105E8B.5
+ZC412.2	Y105E8B.5
+ZK455.2	Y105E8B.5
+ZK563.7	Y105E8B.5
+ZK593.1	Y105E8B.5
+ZK673.2	Y105E8B.5
+ZK856.10	Y105E8B.5
+ZK896.8	Y105E8B.5
+ZK909.3	Y105E8B.5
+ZK970.5	Y105E8B.5
+ZK970.6	Y105E8B.5
+Y37E3.3	Y10G11A.1
+Y37H9A.6	Y10G11A.1
+Y43F4B.5	Y10G11A.1
+Y47D3A.29	Y10G11A.1
+Y48E1A.1	Y10G11A.1
+Y53F4B.3	Y10G11A.1
+Y54E10BR.6	Y10G11A.1
+Y56A3A.13	Y10G11A.1
+Y71H10B.1	Y10G11A.1
+Y77E11A.6	Y10G11A.1
+Y95B8A.10	Y10G11A.1
+Y97E10AR.5	Y10G11A.1
+ZC239.7	Y10G11A.1
+ZC395.7	Y10G11A.1
+ZC412.2	Y10G11A.1
+ZK455.2	Y10G11A.1
+ZK563.7	Y10G11A.1
+ZK593.1	Y10G11A.1
+ZK673.2	Y10G11A.1
+ZK856.10	Y10G11A.1
+ZK896.8	Y10G11A.1
+ZK909.3	Y10G11A.1
+ZK970.5	Y10G11A.1
+ZK970.6	Y10G11A.1
+Y37H9A.6	Y37E3.3
+Y43F4B.5	Y37E3.3
+Y47D3A.29	Y37E3.3
+Y48E1A.1	Y37E3.3
+Y53F4B.3	Y37E3.3
+Y54E10BR.6	Y37E3.3
+Y56A3A.13	Y37E3.3
+Y71H10B.1	Y37E3.3
+Y77E11A.6	Y37E3.3
+Y95B8A.10	Y37E3.3
+Y97E10AR.5	Y37E3.3
+ZC239.7	Y37E3.3
+ZC395.7	Y37E3.3
+ZC412.2	Y37E3.3
+ZK455.2	Y37E3.3
+ZK563.7	Y37E3.3
+ZK593.1	Y37E3.3
+ZK673.2	Y37E3.3
+ZK856.10	Y37E3.3
+ZK896.8	Y37E3.3
+ZK909.3	Y37E3.3
+ZK970.5	Y37E3.3
+ZK970.6	Y37E3.3
+Y43F4B.5	Y37H9A.6
+Y47D3A.29	Y37H9A.6
+Y48E1A.1	Y37H9A.6
+Y53F4B.3	Y37H9A.6
+Y54E10BR.6	Y37H9A.6
+Y56A3A.13	Y37H9A.6
+Y71H10B.1	Y37H9A.6
+Y77E11A.6	Y37H9A.6
+Y95B8A.10	Y37H9A.6
+Y97E10AR.5	Y37H9A.6
+ZC239.7	Y37H9A.6
+ZC395.7	Y37H9A.6
+ZC412.2	Y37H9A.6
+ZK455.2	Y37H9A.6
+ZK563.7	Y37H9A.6
+ZK593.1	Y37H9A.6
+ZK673.2	Y37H9A.6
+ZK856.10	Y37H9A.6
+ZK896.8	Y37H9A.6
+ZK909.3	Y37H9A.6
+ZK970.5	Y37H9A.6
+ZK970.6	Y37H9A.6
+Y47D3A.29	Y43F4B.5
+Y48E1A.1	Y43F4B.5
+Y53F4B.3	Y43F4B.5
+Y54E10BR.6	Y43F4B.5
+Y56A3A.13	Y43F4B.5
+Y71H10B.1	Y43F4B.5
+Y77E11A.6	Y43F4B.5
+Y95B8A.10	Y43F4B.5
+Y97E10AR.5	Y43F4B.5
+ZC239.7	Y43F4B.5
+ZC395.7	Y43F4B.5
+ZC412.2	Y43F4B.5
+ZK455.2	Y43F4B.5
+ZK563.7	Y43F4B.5
+ZK673.2	Y43F4B.5
+ZK856.10	Y43F4B.5
+ZK896.8	Y43F4B.5
+ZK909.3	Y43F4B.5
+ZK970.5	Y43F4B.5
+ZK970.6	Y43F4B.5
+Y48E1A.1	Y47D3A.29
+Y53F4B.3	Y47D3A.29
+Y54E10BR.6	Y47D3A.29
+Y56A3A.13	Y47D3A.29
+Y71H10B.1	Y47D3A.29
+Y77E11A.6	Y47D3A.29
+Y95B8A.10	Y47D3A.29
+Y97E10AR.5	Y47D3A.29
+ZC239.7	Y47D3A.29
+ZC395.7	Y47D3A.29
+ZC412.2	Y47D3A.29
+ZK455.2	Y47D3A.29
+ZK563.7	Y47D3A.29
+ZK593.1	Y47D3A.29
+ZK673.2	Y47D3A.29
+ZK856.10	Y47D3A.29
+ZK896.8	Y47D3A.29
+ZK909.3	Y47D3A.29
+ZK970.5	Y47D3A.29
+ZK970.6	Y47D3A.29
+Y53F4B.3	Y48E1A.1
+Y54E10BR.6	Y48E1A.1
+Y56A3A.13	Y48E1A.1
+Y71H10B.1	Y48E1A.1
+Y77E11A.6	Y48E1A.1
+Y95B8A.10	Y48E1A.1
+Y97E10AR.5	Y48E1A.1
+ZC239.7	Y48E1A.1
+ZC395.7	Y48E1A.1
+ZC412.2	Y48E1A.1
+ZK455.2	Y48E1A.1
+ZK563.7	Y48E1A.1
+ZK593.1	Y48E1A.1
+ZK673.2	Y48E1A.1
+ZK856.10	Y48E1A.1
+ZK896.8	Y48E1A.1
+ZK909.3	Y48E1A.1
+ZK970.5	Y48E1A.1
+ZK970.6	Y48E1A.1
+Y54E10BR.6	Y53F4B.3
+Y56A3A.13	Y53F4B.3
+Y71H10B.1	Y53F4B.3
+Y77E11A.6	Y53F4B.3
+Y95B8A.10	Y53F4B.3
+Y97E10AR.5	Y53F4B.3
+ZC239.7	Y53F4B.3
+ZC395.7	Y53F4B.3
+ZC412.2	Y53F4B.3
+ZK455.2	Y53F4B.3
+ZK563.7	Y53F4B.3
+ZK593.1	Y53F4B.3
+ZK673.2	Y53F4B.3
+ZK856.10	Y53F4B.3
+ZK896.8	Y53F4B.3
+ZK909.3	Y53F4B.3
+ZK970.5	Y53F4B.3
+ZK970.6	Y53F4B.3
+Y56A3A.13	Y54E10BR.6
+Y71H10B.1	Y54E10BR.6
+Y77E11A.6	Y54E10BR.6
+Y95B8A.10	Y54E10BR.6
+Y97E10AR.5	Y54E10BR.6
+ZC239.7	Y54E10BR.6
+ZC395.7	Y54E10BR.6
+ZC412.2	Y54E10BR.6
+ZK455.2	Y54E10BR.6
+ZK563.7	Y54E10BR.6
+ZK593.1	Y54E10BR.6
+ZK673.2	Y54E10BR.6
+ZK856.10	Y54E10BR.6
+ZK896.8	Y54E10BR.6
+ZK909.3	Y54E10BR.6
+ZK970.5	Y54E10BR.6
+ZK970.6	Y54E10BR.6
+Y71H10B.1	Y56A3A.13
+Y77E11A.6	Y56A3A.13
+Y95B8A.10	Y56A3A.13
+Y97E10AR.5	Y56A3A.13
+ZC239.7	Y56A3A.13
+ZC395.7	Y56A3A.13
+ZC412.2	Y56A3A.13
+ZK455.2	Y56A3A.13
+ZK563.7	Y56A3A.13
+ZK593.1	Y56A3A.13
+ZK673.2	Y56A3A.13
+ZK856.10	Y56A3A.13
+ZK896.8	Y56A3A.13
+ZK909.3	Y56A3A.13
+ZK970.5	Y56A3A.13
+ZK970.6	Y56A3A.13
+Y77E11A.6	Y71H10B.1
+Y95B8A.10	Y71H10B.1
+Y97E10AR.5	Y71H10B.1
+ZC239.7	Y71H10B.1
+ZC395.7	Y71H10B.1
+ZC412.2	Y71H10B.1
+ZK455.2	Y71H10B.1
+ZK563.7	Y71H10B.1
+ZK593.1	Y71H10B.1
+ZK673.2	Y71H10B.1
+ZK856.10	Y71H10B.1
+ZK896.8	Y71H10B.1
+ZK909.3	Y71H10B.1
+ZK970.5	Y71H10B.1
+ZK970.6	Y71H10B.1
+Y95B8A.10	Y77E11A.6
+Y97E10AR.5	Y77E11A.6
+ZC239.7	Y77E11A.6
+ZC395.7	Y77E11A.6
+ZC412.2	Y77E11A.6
+ZK455.2	Y77E11A.6
+ZK563.7	Y77E11A.6
+ZK593.1	Y77E11A.6
+ZK673.2	Y77E11A.6
+ZK856.10	Y77E11A.6
+ZK896.8	Y77E11A.6
+ZK909.3	Y77E11A.6
+ZK970.5	Y77E11A.6
+ZK970.6	Y77E11A.6
+Y97E10AR.5	Y95B8A.10
+ZC239.7	Y95B8A.10
+ZC395.7	Y95B8A.10
+ZC412.2	Y95B8A.10
+ZK455.2	Y95B8A.10
+ZK563.7	Y95B8A.10
+ZK593.1	Y95B8A.10
+ZK673.2	Y95B8A.10
+ZK856.10	Y95B8A.10
+ZK896.8	Y95B8A.10
+ZK909.3	Y95B8A.10
+ZK970.5	Y95B8A.10
+ZK970.6	Y95B8A.10
+ZC239.7	Y97E10AR.5
+ZC395.7	Y97E10AR.5
+ZC412.2	Y97E10AR.5
+ZK455.2	Y97E10AR.5
+ZK563.7	Y97E10AR.5
+ZK593.1	Y97E10AR.5
+ZK673.2	Y97E10AR.5
+ZK856.10	Y97E10AR.5
+ZK896.8	Y97E10AR.5
+ZK909.3	Y97E10AR.5
+ZK970.5	Y97E10AR.5
+ZK970.6	Y97E10AR.5
+ZC395.7	ZC239.7
+ZC412.2	ZC239.7
+ZK455.2	ZC239.7
+ZK563.7	ZC239.7
+ZK593.1	ZC239.7
+ZK673.2	ZC239.7
+ZK856.10	ZC239.7
+ZK896.8	ZC239.7
+ZK909.3	ZC239.7
+ZK970.5	ZC239.7
+ZK970.6	ZC239.7
+ZC412.2	ZC395.7
+ZK455.2	ZC395.7
+ZK563.7	ZC395.7
+ZK593.1	ZC395.7
+ZK673.2	ZC395.7
+ZK856.10	ZC395.7
+ZK896.8	ZC395.7
+ZK909.3	ZC395.7
+ZK970.5	ZC395.7
+ZK970.6	ZC395.7
+ZK455.2	ZC412.2
+ZK563.7	ZC412.2
+ZK593.1	ZC412.2
+ZK673.2	ZC412.2
+ZK856.10	ZC412.2
+ZK896.8	ZC412.2
+ZK909.3	ZC412.2
+ZK970.5	ZC412.2
+ZK970.6	ZC412.2
+ZK563.7	ZK455.2
+ZK593.1	ZK455.2
+ZK673.2	ZK455.2
+ZK856.10	ZK455.2
+ZK896.8	ZK455.2
+ZK909.3	ZK455.2
+ZK970.5	ZK455.2
+ZK970.6	ZK455.2
+ZK593.1	ZK563.7
+ZK673.2	ZK563.7
+ZK856.10	ZK563.7
+ZK896.8	ZK563.7
+ZK909.3	ZK563.7
+ZK970.5	ZK563.7
+ZK970.6	ZK563.7
+ZK673.2	ZK593.1
+ZK856.10	ZK593.1
+ZK896.8	ZK593.1
+ZK909.3	ZK593.1
+ZK970.5	ZK593.1
+ZK970.6	ZK593.1
+ZK856.10	ZK673.2
+ZK896.8	ZK673.2
+ZK909.3	ZK673.2
+ZK970.5	ZK673.2
+ZK970.6	ZK673.2
+ZK896.8	ZK856.10
+ZK909.3	ZK856.10
+ZK970.5	ZK856.10
+ZK970.6	ZK856.10
+ZK909.3	ZK896.8
+ZK970.5	ZK896.8
+ZK970.6	ZK896.8
+ZK970.5	ZK909.3
+ZK970.6	ZK909.3
+ZK970.6	ZK970.5
+BE0003N10.1	B0001.4
+C03C10.3	B0001.4
+C06A1.5	B0001.4
+C06G3.7	B0001.4
+C15H11.8	B0001.4
+C25F6.3	B0001.4
+C26E6.4	B0001.4
+C29F7.3	B0001.4
+C36B1.3	B0001.4
+C42D4.8	B0001.4
+C47D2.2	B0001.4
+C47E12.8	B0001.4
+C48E7.2	B0001.4
+D2085.1	B0001.4
+F08B4.5	B0001.4
+F08C6.6	B0001.4
+F09F7.3	B0001.4
+F10C2.4	B0001.4
+F12F6.7	B0001.4
+F13H8.7	B0001.4
+F14B4.3	B0001.4
+F19G12.2	B0001.4
+F23B2.13	B0001.4
+F25H2.5	B0001.4
+F26F4.11	B0001.4
+F33H2.5	B0001.4
+F36A4.7	B0001.4
+F40F8.1	B0001.4
+F43E2.2	B0001.4
+F49E8.4	B0001.4
+F58A4.4	B0001.4
+F58A4.9	B0001.4
+H27M09.2	B0001.4
+H43I07.2	B0001.4
+K02D7.1	B0001.4
+K07A1.2	B0001.4
+K08H10.4	B0001.4
+R01H10.1	B0001.4
+R04F11.3	B0001.4
+R07E4.4	B0001.4
+R53.2	B0001.4
+T07C4.1	B0001.4
+T23G5.1	B0001.4
+T24C4.5	B0001.4
+W01G7.3	B0001.4
+W02D3.2	B0001.4
+W02D9.1	B0001.4
+W06E11.1	B0001.4
+W06H3.3	B0001.4
+W09C3.4	B0001.4
+Y10G11A.1	B0001.4
+Y110A7A.4	B0001.4
+Y37E3.3	B0001.4
+Y37H9A.6	B0001.4
+Y43C5A.5	B0001.4
+Y47D3A.29	B0001.4
+Y48E1A.1	B0001.4
+Y53F4B.3	B0001.4
+Y54E10BR.6	B0001.4
+Y71H10B.1	B0001.4
+Y77E11A.6	B0001.4
+Y97E10AR.5	B0001.4
+ZC395.7	B0001.4
+ZK563.7	B0001.4
+ZK643.2	B0001.4
+ZK783.2	B0001.4
+ZK856.10	B0001.4
+C06G3.7	BE0003N10.1
+C25F6.3	BE0003N10.1
+C29F7.3	BE0003N10.1
+C47D2.2	BE0003N10.1
+C47E12.8	BE0003N10.1
+D2085.1	BE0003N10.1
+F13H8.7	BE0003N10.1
+F40F8.1	BE0003N10.1
+F49E8.4	BE0003N10.1
+K07A1.2	BE0003N10.1
+R53.2	BE0003N10.1
+T07C4.1	BE0003N10.1
+W02D3.2	BE0003N10.1
+W06H3.3	BE0003N10.1
+Y110A7A.4	BE0003N10.1
+Y43C5A.5	BE0003N10.1
+ZK643.2	BE0003N10.1
+ZK783.2	BE0003N10.1
+C06G3.7	C03C10.3
+C25F6.3	C03C10.3
+C29F7.3	C03C10.3
+C47D2.2	C03C10.3
+C47E12.8	C03C10.3
+D2085.1	C03C10.3
+F13H8.7	C03C10.3
+F40F8.1	C03C10.3
+F49E8.4	C03C10.3
+K07A1.2	C03C10.3
+R53.2	C03C10.3
+T07C4.1	C03C10.3
+W02D3.2	C03C10.3
+W06H3.3	C03C10.3
+Y110A7A.4	C03C10.3
+Y43C5A.5	C03C10.3
+ZK643.2	C03C10.3
+ZK783.2	C03C10.3
+C06G3.7	C06A1.5
+C25F6.3	C06A1.5
+C29F7.3	C06A1.5
+C47D2.2	C06A1.5
+C47E12.8	C06A1.5
+D2085.1	C06A1.5
+F13H8.7	C06A1.5
+F40F8.1	C06A1.5
+F49E8.4	C06A1.5
+K07A1.2	C06A1.5
+R53.2	C06A1.5
+T07C4.1	C06A1.5
+W02D3.2	C06A1.5
+W06H3.3	C06A1.5
+Y110A7A.4	C06A1.5
+Y43C5A.5	C06A1.5
+ZK643.2	C06A1.5
+ZK783.2	C06A1.5
+C15H11.8	C06G3.7
+C25F6.3	C06G3.7
+C26E6.4	C06G3.7
+C29F7.3	C06G3.7
+C36B1.3	C06G3.7
+C42D4.8	C06G3.7
+C47D2.2	C06G3.7
+C47E12.8	C06G3.7
+C48E7.2	C06G3.7
+D2085.1	C06G3.7
+F08B4.5	C06G3.7
+F08C6.6	C06G3.7
+F09F7.3	C06G3.7
+F10C2.4	C06G3.7
+F12F6.7	C06G3.7
+F13H8.7	C06G3.7
+F14B4.3	C06G3.7
+F19G12.2	C06G3.7
+F23B2.13	C06G3.7
+F25H2.5	C06G3.7
+F26F4.11	C06G3.7
+F33H2.5	C06G3.7
+F36A4.7	C06G3.7
+F40F8.1	C06G3.7
+F43E2.2	C06G3.7
+F49E8.4	C06G3.7
+F58A4.4	C06G3.7
+F58A4.9	C06G3.7
+H27M09.2	C06G3.7
+H43I07.2	C06G3.7
+K02D7.1	C06G3.7
+K07A1.2	C06G3.7
+K08H10.4	C06G3.7
+R01H10.1	C06G3.7
+R04F11.3	C06G3.7
+R07E4.4	C06G3.7
+R53.2	C06G3.7
+T07C4.1	C06G3.7
+T23G5.1	C06G3.7
+T24C4.5	C06G3.7
+W01G7.3	C06G3.7
+W02D3.2	C06G3.7
+W02D9.1	C06G3.7
+W06E11.1	C06G3.7
+W06H3.3	C06G3.7
+W09C3.4	C06G3.7
+Y10G11A.1	C06G3.7
+Y110A7A.4	C06G3.7
+Y37E3.3	C06G3.7
+Y37H9A.6	C06G3.7
+Y43C5A.5	C06G3.7
+Y47D3A.29	C06G3.7
+Y48E1A.1	C06G3.7
+Y53F4B.3	C06G3.7
+Y54E10BR.6	C06G3.7
+Y71H10B.1	C06G3.7
+Y77E11A.6	C06G3.7
+Y97E10AR.5	C06G3.7
+ZC395.7	C06G3.7
+ZK563.7	C06G3.7
+ZK643.2	C06G3.7
+ZK783.2	C06G3.7
+ZK856.10	C06G3.7
+C25F6.3	C15H11.8
+C29F7.3	C15H11.8
+C47D2.2	C15H11.8
+C47E12.8	C15H11.8
+D2085.1	C15H11.8
+F13H8.7	C15H11.8
+F40F8.1	C15H11.8
+F49E8.4	C15H11.8
+K07A1.2	C15H11.8
+R53.2	C15H11.8
+T07C4.1	C15H11.8
+W02D3.2	C15H11.8
+W06H3.3	C15H11.8
+Y110A7A.4	C15H11.8
+Y43C5A.5	C15H11.8
+ZK643.2	C15H11.8
+ZK783.2	C15H11.8
+C26E6.4	C25F6.3
+C29F7.3	C25F6.3
+C36B1.3	C25F6.3
+C42D4.8	C25F6.3
+C47D2.2	C25F6.3
+C47E12.8	C25F6.3
+C48E7.2	C25F6.3
+D2085.1	C25F6.3
+F08B4.5	C25F6.3
+F08C6.6	C25F6.3
+F09F7.3	C25F6.3
+F10C2.4	C25F6.3
+F12F6.7	C25F6.3
+F14B4.3	C25F6.3
+F19G12.2	C25F6.3
+F23B2.13	C25F6.3
+F25H2.5	C25F6.3
+F26F4.11	C25F6.3
+F33H2.5	C25F6.3
+F36A4.7	C25F6.3
+F40F8.1	C25F6.3
+F43E2.2	C25F6.3
+F49E8.4	C25F6.3
+F58A4.4	C25F6.3
+F58A4.9	C25F6.3
+H27M09.2	C25F6.3
+H43I07.2	C25F6.3
+K02D7.1	C25F6.3
+K07A1.2	C25F6.3
+K08H10.4	C25F6.3
+R01H10.1	C25F6.3
+R04F11.3	C25F6.3
+R07E4.4	C25F6.3
+R53.2	C25F6.3
+T07C4.1	C25F6.3
+T23G5.1	C25F6.3
+T24C4.5	C25F6.3
+W01G7.3	C25F6.3
+W02D3.2	C25F6.3
+W02D9.1	C25F6.3
+W06E11.1	C25F6.3
+W06H3.3	C25F6.3
+W09C3.4	C25F6.3
+Y10G11A.1	C25F6.3
+Y110A7A.4	C25F6.3
+Y37E3.3	C25F6.3
+Y37H9A.6	C25F6.3
+Y43C5A.5	C25F6.3
+Y47D3A.29	C25F6.3
+Y48E1A.1	C25F6.3
+Y53F4B.3	C25F6.3
+Y54E10BR.6	C25F6.3
+Y71H10B.1	C25F6.3
+Y77E11A.6	C25F6.3
+Y97E10AR.5	C25F6.3
+ZC395.7	C25F6.3
+ZK563.7	C25F6.3
+ZK643.2	C25F6.3
+ZK856.10	C25F6.3
+C29F7.3	C26E6.4
+C47D2.2	C26E6.4
+C47E12.8	C26E6.4
+D2085.1	C26E6.4
+F13H8.7	C26E6.4
+F40F8.1	C26E6.4
+F49E8.4	C26E6.4
+K07A1.2	C26E6.4
+R53.2	C26E6.4
+T07C4.1	C26E6.4
+W02D3.2	C26E6.4
+W06H3.3	C26E6.4
+Y110A7A.4	C26E6.4
+Y43C5A.5	C26E6.4
+ZK643.2	C26E6.4
+ZK783.2	C26E6.4
+C36B1.3	C29F7.3
+C42D4.8	C29F7.3
+C47D2.2	C29F7.3
+C47E12.8	C29F7.3
+C48E7.2	C29F7.3
+D2085.1	C29F7.3
+F08B4.5	C29F7.3
+F08C6.6	C29F7.3
+F09F7.3	C29F7.3
+F10C2.4	C29F7.3
+F12F6.7	C29F7.3
+F13H8.7	C29F7.3
+F14B4.3	C29F7.3
+F19G12.2	C29F7.3
+F23B2.13	C29F7.3
+F25H2.5	C29F7.3
+F26F4.11	C29F7.3
+F33H2.5	C29F7.3
+F36A4.7	C29F7.3
+F40F8.1	C29F7.3
+F43E2.2	C29F7.3
+F49E8.4	C29F7.3
+F58A4.4	C29F7.3
+F58A4.9	C29F7.3
+H27M09.2	C29F7.3
+H43I07.2	C29F7.3
+K02D7.1	C29F7.3
+K07A1.2	C29F7.3
+K08H10.4	C29F7.3
+R01H10.1	C29F7.3
+R04F11.3	C29F7.3
+R07E4.4	C29F7.3
+R53.2	C29F7.3
+T07C4.1	C29F7.3
+T23G5.1	C29F7.3
+T24C4.5	C29F7.3
+W01G7.3	C29F7.3
+W02D3.2	C29F7.3
+W02D9.1	C29F7.3
+W06E11.1	C29F7.3
+W06H3.3	C29F7.3
+W09C3.4	C29F7.3
+Y10G11A.1	C29F7.3
+Y110A7A.4	C29F7.3
+Y37E3.3	C29F7.3
+Y37H9A.6	C29F7.3
+Y43C5A.5	C29F7.3
+Y47D3A.29	C29F7.3
+Y48E1A.1	C29F7.3
+Y53F4B.3	C29F7.3
+Y54E10BR.6	C29F7.3
+Y71H10B.1	C29F7.3
+Y77E11A.6	C29F7.3
+Y97E10AR.5	C29F7.3
+ZC395.7	C29F7.3
+ZK563.7	C29F7.3
+ZK643.2	C29F7.3
+ZK783.2	C29F7.3
+ZK856.10	C29F7.3
+C47D2.2	C36B1.3
+C47E12.8	C36B1.3
+D2085.1	C36B1.3
+F13H8.7	C36B1.3
+F40F8.1	C36B1.3
+F49E8.4	C36B1.3
+K07A1.2	C36B1.3
+R53.2	C36B1.3
+T07C4.1	C36B1.3
+W02D3.2	C36B1.3
+W06H3.3	C36B1.3
+Y110A7A.4	C36B1.3
+Y43C5A.5	C36B1.3
+ZK643.2	C36B1.3
+ZK783.2	C36B1.3
+C47D2.2	C42D4.8
+C47E12.8	C42D4.8
+D2085.1	C42D4.8
+F13H8.7	C42D4.8
+F40F8.1	C42D4.8
+F49E8.4	C42D4.8
+K07A1.2	C42D4.8
+R53.2	C42D4.8
+T07C4.1	C42D4.8
+W02D3.2	C42D4.8
+W06H3.3	C42D4.8
+Y110A7A.4	C42D4.8
+Y43C5A.5	C42D4.8
+ZK643.2	C42D4.8
+ZK783.2	C42D4.8
+C47E12.8	C47D2.2
+C48E7.2	C47D2.2
+D2085.1	C47D2.2
+F08B4.5	C47D2.2
+F08C6.6	C47D2.2
+F09F7.3	C47D2.2
+F10C2.4	C47D2.2
+F12F6.7	C47D2.2
+F13H8.7	C47D2.2
+F14B4.3	C47D2.2
+F19G12.2	C47D2.2
+F23B2.13	C47D2.2
+F25H2.5	C47D2.2
+F26F4.11	C47D2.2
+F33H2.5	C47D2.2
+F36A4.7	C47D2.2
+F40F8.1	C47D2.2
+F43E2.2	C47D2.2
+F58A4.4	C47D2.2
+F58A4.9	C47D2.2
+H27M09.2	C47D2.2
+H43I07.2	C47D2.2
+K02D7.1	C47D2.2
+K07A1.2	C47D2.2
+K08H10.4	C47D2.2
+R01H10.1	C47D2.2
+R04F11.3	C47D2.2
+R07E4.4	C47D2.2
+R53.2	C47D2.2
+T07C4.1	C47D2.2
+T23G5.1	C47D2.2
+T24C4.5	C47D2.2
+W01G7.3	C47D2.2
+W02D3.2	C47D2.2
+W02D9.1	C47D2.2
+W06E11.1	C47D2.2
+W06H3.3	C47D2.2
+W09C3.4	C47D2.2
+Y10G11A.1	C47D2.2
+Y110A7A.4	C47D2.2
+Y37E3.3	C47D2.2
+Y37H9A.6	C47D2.2
+Y43C5A.5	C47D2.2
+Y47D3A.29	C47D2.2
+Y48E1A.1	C47D2.2
+Y53F4B.3	C47D2.2
+Y54E10BR.6	C47D2.2
+Y71H10B.1	C47D2.2
+Y77E11A.6	C47D2.2
+Y97E10AR.5	C47D2.2
+ZC395.7	C47D2.2
+ZK563.7	C47D2.2
+ZK643.2	C47D2.2
+ZK783.2	C47D2.2
+ZK856.10	C47D2.2
+C48E7.2	C47E12.8
+D2085.1	C47E12.8
+F08B4.5	C47E12.8
+F08C6.6	C47E12.8
+F09F7.3	C47E12.8
+F10C2.4	C47E12.8
+F12F6.7	C47E12.8
+F13H8.7	C47E12.8
+F14B4.3	C47E12.8
+F19G12.2	C47E12.8
+F23B2.13	C47E12.8
+F25H2.5	C47E12.8
+F26F4.11	C47E12.8
+F33H2.5	C47E12.8
+F36A4.7	C47E12.8
+F40F8.1	C47E12.8
+F43E2.2	C47E12.8
+F49E8.4	C47E12.8
+F58A4.4	C47E12.8
+F58A4.9	C47E12.8
+H27M09.2	C47E12.8
+H43I07.2	C47E12.8
+K02D7.1	C47E12.8
+K07A1.2	C47E12.8
+K08H10.4	C47E12.8
+R01H10.1	C47E12.8
+R04F11.3	C47E12.8
+R07E4.4	C47E12.8
+R53.2	C47E12.8
+T07C4.1	C47E12.8
+T23G5.1	C47E12.8
+T24C4.5	C47E12.8
+W01G7.3	C47E12.8
+W02D3.2	C47E12.8
+W02D9.1	C47E12.8
+W06E11.1	C47E12.8
+W06H3.3	C47E12.8
+W09C3.4	C47E12.8
+Y10G11A.1	C47E12.8
+Y110A7A.4	C47E12.8
+Y37E3.3	C47E12.8
+Y37H9A.6	C47E12.8
+Y43C5A.5	C47E12.8
+Y47D3A.29	C47E12.8
+Y48E1A.1	C47E12.8
+Y53F4B.3	C47E12.8
+Y54E10BR.6	C47E12.8
+Y71H10B.1	C47E12.8
+Y77E11A.6	C47E12.8
+Y97E10AR.5	C47E12.8
+ZC395.7	C47E12.8
+ZK563.7	C47E12.8
+ZK643.2	C47E12.8
+ZK783.2	C47E12.8
+ZK856.10	C47E12.8
+D2085.1	C48E7.2
+F13H8.7	C48E7.2
+F40F8.1	C48E7.2
+F49E8.4	C48E7.2
+K07A1.2	C48E7.2
+R53.2	C48E7.2
+T07C4.1	C48E7.2
+W02D3.2	C48E7.2
+W06H3.3	C48E7.2
+Y110A7A.4	C48E7.2
+Y43C5A.5	C48E7.2
+ZK643.2	C48E7.2
+ZK783.2	C48E7.2
+F08B4.5	D2085.1
+F08C6.6	D2085.1
+F09F7.3	D2085.1
+F10C2.4	D2085.1
+F12F6.7	D2085.1
+F13H8.7	D2085.1
+F14B4.3	D2085.1
+F19G12.2	D2085.1
+F23B2.13	D2085.1
+F25H2.5	D2085.1
+F26F4.11	D2085.1
+F33H2.5	D2085.1
+F36A4.7	D2085.1
+F40F8.1	D2085.1
+F43E2.2	D2085.1
+F49E8.4	D2085.1
+F58A4.4	D2085.1
+F58A4.9	D2085.1
+H27M09.2	D2085.1
+H43I07.2	D2085.1
+K02D7.1	D2085.1
+K07A1.2	D2085.1
+K08H10.4	D2085.1
+R01H10.1	D2085.1
+R04F11.3	D2085.1
+R07E4.4	D2085.1
+R53.2	D2085.1
+T07C4.1	D2085.1
+T23G5.1	D2085.1
+T24C4.5	D2085.1
+W01G7.3	D2085.1
+W02D3.2	D2085.1
+W02D9.1	D2085.1
+W06E11.1	D2085.1
+W06H3.3	D2085.1
+W09C3.4	D2085.1
+Y10G11A.1	D2085.1
+Y110A7A.4	D2085.1
+Y37E3.3	D2085.1
+Y37H9A.6	D2085.1
+Y43C5A.5	D2085.1
+Y47D3A.29	D2085.1
+Y48E1A.1	D2085.1
+Y53F4B.3	D2085.1
+Y54E10BR.6	D2085.1
+Y71H10B.1	D2085.1
+Y77E11A.6	D2085.1
+Y97E10AR.5	D2085.1
+ZC395.7	D2085.1
+ZK563.7	D2085.1
+ZK643.2	D2085.1
+ZK783.2	D2085.1
+ZK856.10	D2085.1
+F13H8.7	F08B4.5
+F40F8.1	F08B4.5
+F49E8.4	F08B4.5
+K07A1.2	F08B4.5
+R53.2	F08B4.5
+T07C4.1	F08B4.5
+W02D3.2	F08B4.5
+W06H3.3	F08B4.5
+Y110A7A.4	F08B4.5
+Y43C5A.5	F08B4.5
+ZK643.2	F08B4.5
+ZK783.2	F08B4.5
+F13H8.7	F08C6.6
+F40F8.1	F08C6.6
+F49E8.4	F08C6.6
+K07A1.2	F08C6.6
+R53.2	F08C6.6
+T07C4.1	F08C6.6
+W02D3.2	F08C6.6
+W06H3.3	F08C6.6
+Y110A7A.4	F08C6.6
+Y43C5A.5	F08C6.6
+ZK643.2	F08C6.6
+ZK783.2	F08C6.6
+F13H8.7	F09F7.3
+F40F8.1	F09F7.3
+F49E8.4	F09F7.3
+K07A1.2	F09F7.3
+R53.2	F09F7.3
+T07C4.1	F09F7.3
+W02D3.2	F09F7.3
+W06H3.3	F09F7.3
+Y110A7A.4	F09F7.3
+Y43C5A.5	F09F7.3
+ZK643.2	F09F7.3
+ZK783.2	F09F7.3
+F13H8.7	F10C2.4
+F40F8.1	F10C2.4
+F49E8.4	F10C2.4
+K07A1.2	F10C2.4
+R53.2	F10C2.4
+T07C4.1	F10C2.4
+W02D3.2	F10C2.4
+W06H3.3	F10C2.4
+Y110A7A.4	F10C2.4
+Y43C5A.5	F10C2.4
+ZK643.2	F10C2.4
+ZK783.2	F10C2.4
+F13H8.7	F12F6.7
+F40F8.1	F12F6.7
+F49E8.4	F12F6.7
+K07A1.2	F12F6.7
+R53.2	F12F6.7
+T07C4.1	F12F6.7
+W02D3.2	F12F6.7
+W06H3.3	F12F6.7
+Y110A7A.4	F12F6.7
+Y43C5A.5	F12F6.7
+ZK643.2	F12F6.7
+ZK783.2	F12F6.7
+F14B4.3	F13H8.7
+F19G12.2	F13H8.7
+F23B2.13	F13H8.7
+F25H2.5	F13H8.7
+F26F4.11	F13H8.7
+F33H2.5	F13H8.7
+F36A4.7	F13H8.7
+F40F8.1	F13H8.7
+F43E2.2	F13H8.7
+F49E8.4	F13H8.7
+F58A4.4	F13H8.7
+F58A4.9	F13H8.7
+H27M09.2	F13H8.7
+H43I07.2	F13H8.7
+K02D7.1	F13H8.7
+K07A1.2	F13H8.7
+K08H10.4	F13H8.7
+R01H10.1	F13H8.7
+R04F11.3	F13H8.7
+R07E4.4	F13H8.7
+R53.2	F13H8.7
+T07C4.1	F13H8.7
+T23G5.1	F13H8.7
+T24C4.5	F13H8.7
+W01G7.3	F13H8.7
+W02D3.2	F13H8.7
+W02D9.1	F13H8.7
+W06E11.1	F13H8.7
+W06H3.3	F13H8.7
+W09C3.4	F13H8.7
+Y10G11A.1	F13H8.7
+Y110A7A.4	F13H8.7
+Y37E3.3	F13H8.7
+Y37H9A.6	F13H8.7
+Y43C5A.5	F13H8.7
+Y47D3A.29	F13H8.7
+Y48E1A.1	F13H8.7
+Y53F4B.3	F13H8.7
+Y54E10BR.6	F13H8.7
+Y71H10B.1	F13H8.7
+Y77E11A.6	F13H8.7
+Y97E10AR.5	F13H8.7
+ZC395.7	F13H8.7
+ZK563.7	F13H8.7
+ZK643.2	F13H8.7
+ZK783.2	F13H8.7
+ZK856.10	F13H8.7
+F40F8.1	F14B4.3
+F49E8.4	F14B4.3
+K07A1.2	F14B4.3
+R53.2	F14B4.3
+T07C4.1	F14B4.3
+W02D3.2	F14B4.3
+W06H3.3	F14B4.3
+Y110A7A.4	F14B4.3
+Y43C5A.5	F14B4.3
+ZK643.2	F14B4.3
+ZK783.2	F14B4.3
+F40F8.1	F19G12.2
+F49E8.4	F19G12.2
+K07A1.2	F19G12.2
+R53.2	F19G12.2
+T07C4.1	F19G12.2
+W02D3.2	F19G12.2
+W06H3.3	F19G12.2
+Y110A7A.4	F19G12.2
+Y43C5A.5	F19G12.2
+ZK643.2	F19G12.2
+ZK783.2	F19G12.2
+F40F8.1	F23B2.13
+F49E8.4	F23B2.13
+K07A1.2	F23B2.13
+R53.2	F23B2.13
+T07C4.1	F23B2.13
+W02D3.2	F23B2.13
+W06H3.3	F23B2.13
+Y110A7A.4	F23B2.13
+Y43C5A.5	F23B2.13
+ZK643.2	F23B2.13
+ZK783.2	F23B2.13
+F40F8.1	F25H2.5
+F49E8.4	F25H2.5
+K07A1.2	F25H2.5
+R53.2	F25H2.5
+T07C4.1	F25H2.5
+W02D3.2	F25H2.5
+W06H3.3	F25H2.5
+Y110A7A.4	F25H2.5
+Y43C5A.5	F25H2.5
+ZK643.2	F25H2.5
+ZK783.2	F25H2.5
+F40F8.1	F26F4.11
+F49E8.4	F26F4.11
+K07A1.2	F26F4.11
+R53.2	F26F4.11
+T07C4.1	F26F4.11
+W02D3.2	F26F4.11
+W06H3.3	F26F4.11
+Y110A7A.4	F26F4.11
+Y43C5A.5	F26F4.11
+ZK643.2	F26F4.11
+ZK783.2	F26F4.11
+F40F8.1	F33H2.5
+F49E8.4	F33H2.5
+K07A1.2	F33H2.5
+R53.2	F33H2.5
+T07C4.1	F33H2.5
+W02D3.2	F33H2.5
+W06H3.3	F33H2.5
+Y110A7A.4	F33H2.5
+Y43C5A.5	F33H2.5
+ZK643.2	F33H2.5
+ZK783.2	F33H2.5
+F40F8.1	F36A4.7
+F49E8.4	F36A4.7
+K07A1.2	F36A4.7
+R53.2	F36A4.7
+T07C4.1	F36A4.7
+W02D3.2	F36A4.7
+W06H3.3	F36A4.7
+Y110A7A.4	F36A4.7
+Y43C5A.5	F36A4.7
+ZK643.2	F36A4.7
+ZK783.2	F36A4.7
+F43E2.2	F40F8.1
+F49E8.4	F40F8.1
+F58A4.4	F40F8.1
+F58A4.9	F40F8.1
+H27M09.2	F40F8.1
+H43I07.2	F40F8.1
+K02D7.1	F40F8.1
+K07A1.2	F40F8.1
+K08H10.4	F40F8.1
+R01H10.1	F40F8.1
+R04F11.3	F40F8.1
+R07E4.4	F40F8.1
+R53.2	F40F8.1
+T07C4.1	F40F8.1
+T23G5.1	F40F8.1
+T24C4.5	F40F8.1
+W01G7.3	F40F8.1
+W02D3.2	F40F8.1
+W02D9.1	F40F8.1
+W06E11.1	F40F8.1
+W06H3.3	F40F8.1
+W09C3.4	F40F8.1
+Y10G11A.1	F40F8.1
+Y110A7A.4	F40F8.1
+Y37E3.3	F40F8.1
+Y37H9A.6	F40F8.1
+Y43C5A.5	F40F8.1
+Y47D3A.29	F40F8.1
+Y48E1A.1	F40F8.1
+Y53F4B.3	F40F8.1
+Y54E10BR.6	F40F8.1
+Y71H10B.1	F40F8.1
+Y77E11A.6	F40F8.1
+Y97E10AR.5	F40F8.1
+ZC395.7	F40F8.1
+ZK563.7	F40F8.1
+ZK643.2	F40F8.1
+ZK783.2	F40F8.1
+ZK856.10	F40F8.1
+F49E8.4	F43E2.2
+K07A1.2	F43E2.2
+R53.2	F43E2.2
+T07C4.1	F43E2.2
+W02D3.2	F43E2.2
+W06H3.3	F43E2.2
+Y110A7A.4	F43E2.2
+Y43C5A.5	F43E2.2
+ZK643.2	F43E2.2
+ZK783.2	F43E2.2
+F58A4.4	F49E8.4
+F58A4.9	F49E8.4
+H27M09.2	F49E8.4
+H43I07.2	F49E8.4
+K02D7.1	F49E8.4
+K07A1.2	F49E8.4
+K08H10.4	F49E8.4
+R01H10.1	F49E8.4
+R04F11.3	F49E8.4
+R07E4.4	F49E8.4
+R53.2	F49E8.4
+T07C4.1	F49E8.4
+T23G5.1	F49E8.4
+T24C4.5	F49E8.4
+W01G7.3	F49E8.4
+W02D3.2	F49E8.4
+W02D9.1	F49E8.4
+W06E11.1	F49E8.4
+W06H3.3	F49E8.4
+W09C3.4	F49E8.4
+Y10G11A.1	F49E8.4
+Y110A7A.4	F49E8.4
+Y37E3.3	F49E8.4
+Y37H9A.6	F49E8.4
+Y43C5A.5	F49E8.4
+Y47D3A.29	F49E8.4
+Y48E1A.1	F49E8.4
+Y53F4B.3	F49E8.4
+Y54E10BR.6	F49E8.4
+Y71H10B.1	F49E8.4
+Y77E11A.6	F49E8.4
+Y97E10AR.5	F49E8.4
+ZC395.7	F49E8.4
+ZK563.7	F49E8.4
+ZK643.2	F49E8.4
+ZK783.2	F49E8.4
+ZK856.10	F49E8.4
+K07A1.2	F58A4.4
+R53.2	F58A4.4
+T07C4.1	F58A4.4
+W02D3.2	F58A4.4
+W06H3.3	F58A4.4
+Y110A7A.4	F58A4.4
+Y43C5A.5	F58A4.4
+ZK643.2	F58A4.4
+ZK783.2	F58A4.4
+K07A1.2	F58A4.9
+R53.2	F58A4.9
+T07C4.1	F58A4.9
+W02D3.2	F58A4.9
+W06H3.3	F58A4.9
+Y110A7A.4	F58A4.9
+Y43C5A.5	F58A4.9
+ZK643.2	F58A4.9
+ZK783.2	F58A4.9
+K07A1.2	H27M09.2
+R53.2	H27M09.2
+T07C4.1	H27M09.2
+W02D3.2	H27M09.2
+W06H3.3	H27M09.2
+Y110A7A.4	H27M09.2
+Y43C5A.5	H27M09.2
+ZK643.2	H27M09.2
+ZK783.2	H27M09.2
+K07A1.2	H43I07.2
+R53.2	H43I07.2
+T07C4.1	H43I07.2
+W02D3.2	H43I07.2
+W06H3.3	H43I07.2
+Y110A7A.4	H43I07.2
+Y43C5A.5	H43I07.2
+ZK643.2	H43I07.2
+ZK783.2	H43I07.2
+K07A1.2	K02D7.1
+R53.2	K02D7.1
+T07C4.1	K02D7.1
+W02D3.2	K02D7.1
+W06H3.3	K02D7.1
+Y110A7A.4	K02D7.1
+Y43C5A.5	K02D7.1
+ZK643.2	K02D7.1
+ZK783.2	K02D7.1
+K08H10.4	K07A1.2
+R01H10.1	K07A1.2
+R04F11.3	K07A1.2
+R07E4.4	K07A1.2
+R53.2	K07A1.2
+T07C4.1	K07A1.2
+T23G5.1	K07A1.2
+T24C4.5	K07A1.2
+W01G7.3	K07A1.2
+W02D3.2	K07A1.2
+W02D9.1	K07A1.2
+W06E11.1	K07A1.2
+W06H3.3	K07A1.2
+W09C3.4	K07A1.2
+Y10G11A.1	K07A1.2
+Y110A7A.4	K07A1.2
+Y37E3.3	K07A1.2
+Y37H9A.6	K07A1.2
+Y43C5A.5	K07A1.2
+Y47D3A.29	K07A1.2
+Y48E1A.1	K07A1.2
+Y53F4B.3	K07A1.2
+Y54E10BR.6	K07A1.2
+Y71H10B.1	K07A1.2
+Y77E11A.6	K07A1.2
+Y97E10AR.5	K07A1.2
+ZC395.7	K07A1.2
+ZK563.7	K07A1.2
+ZK643.2	K07A1.2
+ZK783.2	K07A1.2
+ZK856.10	K07A1.2
+R53.2	K08H10.4
+T07C4.1	K08H10.4
+W02D3.2	K08H10.4
+W06H3.3	K08H10.4
+Y110A7A.4	K08H10.4
+Y43C5A.5	K08H10.4
+ZK643.2	K08H10.4
+ZK783.2	K08H10.4
+R53.2	R01H10.1
+T07C4.1	R01H10.1
+W02D3.2	R01H10.1
+W06H3.3	R01H10.1
+Y110A7A.4	R01H10.1
+Y43C5A.5	R01H10.1
+ZK643.2	R01H10.1
+ZK783.2	R01H10.1
+R53.2	R04F11.3
+T07C4.1	R04F11.3
+W02D3.2	R04F11.3
+W06H3.3	R04F11.3
+Y110A7A.4	R04F11.3
+Y43C5A.5	R04F11.3
+ZK643.2	R04F11.3
+ZK783.2	R04F11.3
+R53.2	R07E4.4
+T07C4.1	R07E4.4
+W02D3.2	R07E4.4
+W06H3.3	R07E4.4
+Y110A7A.4	R07E4.4
+Y43C5A.5	R07E4.4
+ZK643.2	R07E4.4
+ZK783.2	R07E4.4
+T07C4.1	R53.2
+T23G5.1	R53.2
+T24C4.5	R53.2
+W01G7.3	R53.2
+W02D3.2	R53.2
+W02D9.1	R53.2
+W06E11.1	R53.2
+W06H3.3	R53.2
+W09C3.4	R53.2
+Y10G11A.1	R53.2
+Y110A7A.4	R53.2
+Y37E3.3	R53.2
+Y37H9A.6	R53.2
+Y43C5A.5	R53.2
+Y47D3A.29	R53.2
+Y48E1A.1	R53.2
+Y53F4B.3	R53.2
+Y54E10BR.6	R53.2
+Y71H10B.1	R53.2
+Y77E11A.6	R53.2
+Y97E10AR.5	R53.2
+ZC395.7	R53.2
+ZK563.7	R53.2
+ZK643.2	R53.2
+ZK783.2	R53.2
+ZK856.10	R53.2
+T23G5.1	T07C4.1
+T24C4.5	T07C4.1
+W01G7.3	T07C4.1
+W02D3.2	T07C4.1
+W02D9.1	T07C4.1
+W06E11.1	T07C4.1
+W06H3.3	T07C4.1
+W09C3.4	T07C4.1
+Y10G11A.1	T07C4.1
+Y110A7A.4	T07C4.1
+Y37E3.3	T07C4.1
+Y37H9A.6	T07C4.1
+Y43C5A.5	T07C4.1
+Y47D3A.29	T07C4.1
+Y48E1A.1	T07C4.1
+Y53F4B.3	T07C4.1
+Y54E10BR.6	T07C4.1
+Y71H10B.1	T07C4.1
+Y77E11A.6	T07C4.1
+Y97E10AR.5	T07C4.1
+ZC395.7	T07C4.1
+ZK563.7	T07C4.1
+ZK643.2	T07C4.1
+ZK783.2	T07C4.1
+ZK856.10	T07C4.1
+W02D3.2	T23G5.1
+W06H3.3	T23G5.1
+Y110A7A.4	T23G5.1
+Y43C5A.5	T23G5.1
+ZK643.2	T23G5.1
+ZK783.2	T23G5.1
+W02D3.2	T24C4.5
+W06H3.3	T24C4.5
+Y110A7A.4	T24C4.5
+Y43C5A.5	T24C4.5
+ZK643.2	T24C4.5
+ZK783.2	T24C4.5
+W02D3.2	W01G7.3
+W06H3.3	W01G7.3
+Y110A7A.4	W01G7.3
+Y43C5A.5	W01G7.3
+ZK643.2	W01G7.3
+ZK783.2	W01G7.3
+W02D9.1	W02D3.2
+W06E11.1	W02D3.2
+W06H3.3	W02D3.2
+W09C3.4	W02D3.2
+Y10G11A.1	W02D3.2
+Y110A7A.4	W02D3.2
+Y37E3.3	W02D3.2
+Y37H9A.6	W02D3.2
+Y43C5A.5	W02D3.2
+Y47D3A.29	W02D3.2
+Y48E1A.1	W02D3.2
+Y53F4B.3	W02D3.2
+Y54E10BR.6	W02D3.2
+Y71H10B.1	W02D3.2
+Y77E11A.6	W02D3.2
+Y97E10AR.5	W02D3.2
+ZC395.7	W02D3.2
+ZK563.7	W02D3.2
+ZK643.2	W02D3.2
+ZK783.2	W02D3.2
+ZK856.10	W02D3.2
+W06H3.3	W02D9.1
+Y110A7A.4	W02D9.1
+Y43C5A.5	W02D9.1
+ZK643.2	W02D9.1
+ZK783.2	W02D9.1
+W06H3.3	W06E11.1
+Y110A7A.4	W06E11.1
+Y43C5A.5	W06E11.1
+ZK643.2	W06E11.1
+ZK783.2	W06E11.1
+W09C3.4	W06H3.3
+Y10G11A.1	W06H3.3
+Y110A7A.4	W06H3.3
+Y37E3.3	W06H3.3
+Y37H9A.6	W06H3.3
+Y43C5A.5	W06H3.3
+Y47D3A.29	W06H3.3
+Y48E1A.1	W06H3.3
+Y53F4B.3	W06H3.3
+Y54E10BR.6	W06H3.3
+Y71H10B.1	W06H3.3
+Y77E11A.6	W06H3.3
+Y97E10AR.5	W06H3.3
+ZC395.7	W06H3.3
+ZK563.7	W06H3.3
+ZK643.2	W06H3.3
+ZK783.2	W06H3.3
+ZK856.10	W06H3.3
+Y110A7A.4	W09C3.4
+Y43C5A.5	W09C3.4
+ZK643.2	W09C3.4
+ZK783.2	W09C3.4
+Y110A7A.4	Y10G11A.1
+Y43C5A.5	Y10G11A.1
+ZK643.2	Y10G11A.1
+ZK783.2	Y10G11A.1
+Y37E3.3	Y110A7A.4
+Y37H9A.6	Y110A7A.4
+Y43C5A.5	Y110A7A.4
+Y47D3A.29	Y110A7A.4
+Y48E1A.1	Y110A7A.4
+Y53F4B.3	Y110A7A.4
+Y54E10BR.6	Y110A7A.4
+Y71H10B.1	Y110A7A.4
+Y77E11A.6	Y110A7A.4
+Y97E10AR.5	Y110A7A.4
+ZC395.7	Y110A7A.4
+ZK563.7	Y110A7A.4
+ZK643.2	Y110A7A.4
+ZK783.2	Y110A7A.4
+ZK856.10	Y110A7A.4
+Y43C5A.5	Y37E3.3
+ZK643.2	Y37E3.3
+ZK783.2	Y37E3.3
+Y43C5A.5	Y37H9A.6
+ZK643.2	Y37H9A.6
+ZK783.2	Y37H9A.6
+Y47D3A.29	Y43C5A.5
+Y48E1A.1	Y43C5A.5
+Y53F4B.3	Y43C5A.5
+Y54E10BR.6	Y43C5A.5
+Y71H10B.1	Y43C5A.5
+Y77E11A.6	Y43C5A.5
+Y97E10AR.5	Y43C5A.5
+ZC395.7	Y43C5A.5
+ZK563.7	Y43C5A.5
+ZK643.2	Y43C5A.5
+ZK783.2	Y43C5A.5
+ZK856.10	Y43C5A.5
+ZK643.2	Y47D3A.29
+ZK783.2	Y47D3A.29
+ZK643.2	Y48E1A.1
+ZK783.2	Y48E1A.1
+ZK643.2	Y53F4B.3
+ZK783.2	Y53F4B.3
+ZK643.2	Y54E10BR.6
+ZK783.2	Y54E10BR.6
+ZK643.2	Y71H10B.1
+ZK783.2	Y71H10B.1
+ZK643.2	Y77E11A.6
+ZK783.2	Y77E11A.6
+ZK643.2	Y97E10AR.5
+ZK783.2	Y97E10AR.5
+ZK643.2	ZC395.7
+ZK783.2	ZC395.7
+ZK643.2	ZK563.7
+ZK783.2	ZK563.7
+ZK783.2	ZK643.2
+ZK856.10	ZK643.2
+ZK856.10	ZK783.2
+C14E2.2	C09F9.3
+C14F11.1	C09F9.3
+C28D4.3	C09F9.3
+C32F10.8	C09F9.3
+C37H5.6	C09F9.3
+C44E4.3	C09F9.3
+C45B2.5	C09F9.3
+C47A10.5	C09F9.3
+D2085.1	C09F9.3
+DH11.1	C09F9.3
+F07A11.2	C09F9.3
+F18E3.7	C09F9.3
+F22B3.4	C09F9.3
+F25G6.6	C09F9.3
+F26D10.10	C09F9.3
+F30F8.2	C09F9.3
+F45H10.1	C09F9.3
+F56D12.1	C09F9.3
+K03H1.1	C09F9.3
+K04D7.3	C09F9.3
+M02D8.4	C09F9.3
+R06C7.5	C09F9.3
+T01C8.5	C09F9.3
+T04A8.5	C09F9.3
+T09B4.8	C09F9.3
+T14D7.1	C09F9.3
+W07E11.1	C09F9.3
+Y105C5B.28	C09F9.3
+Y37D8A.23	C09F9.3
+ZK829.4	C09F9.3
+C14F11.1	C14E2.2
+C28D4.3	C14E2.2
+C32F10.8	C14E2.2
+C37H5.6	C14E2.2
+C44E4.3	C14E2.2
+C45B2.5	C14E2.2
+C47A10.5	C14E2.2
+D2085.1	C14E2.2
+DH11.1	C14E2.2
+F07A11.2	C14E2.2
+F18E3.7	C14E2.2
+F22B3.4	C14E2.2
+F25G6.6	C14E2.2
+F26D10.10	C14E2.2
+F30F8.2	C14E2.2
+F45H10.1	C14E2.2
+F56D12.1	C14E2.2
+K03H1.1	C14E2.2
+K04D7.3	C14E2.2
+M02D8.4	C14E2.2
+R06C7.5	C14E2.2
+T01C8.5	C14E2.2
+T04A8.5	C14E2.2
+T09B4.8	C14E2.2
+T14D7.1	C14E2.2
+W07E11.1	C14E2.2
+Y105C5B.28	C14E2.2
+Y37D8A.23	C14E2.2
+ZK829.4	C14E2.2
+C28D4.3	C14F11.1
+C32F10.8	C14F11.1
+C37H5.6	C14F11.1
+C44E4.3	C14F11.1
+C45B2.5	C14F11.1
+C47A10.5	C14F11.1
+D2085.1	C14F11.1
+DH11.1	C14F11.1
+F07A11.2	C14F11.1
+F18E3.7	C14F11.1
+F22B3.4	C14F11.1
+F25G6.6	C14F11.1
+F26D10.10	C14F11.1
+F30F8.2	C14F11.1
+F45H10.1	C14F11.1
+F56D12.1	C14F11.1
+K03H1.1	C14F11.1
+K04D7.3	C14F11.1
+M02D8.4	C14F11.1
+R06C7.5	C14F11.1
+T01C8.5	C14F11.1
+T04A8.5	C14F11.1
+T09B4.8	C14F11.1
+T14D7.1	C14F11.1
+W07E11.1	C14F11.1
+Y105C5B.28	C14F11.1
+Y37D8A.23	C14F11.1
+ZK829.4	C14F11.1
+C32F10.8	C28D4.3
+C37H5.6	C28D4.3
+C44E4.3	C28D4.3
+C45B2.5	C28D4.3
+C47A10.5	C28D4.3
+D2085.1	C28D4.3
+DH11.1	C28D4.3
+F07A11.2	C28D4.3
+F18E3.7	C28D4.3
+F22B3.4	C28D4.3
+F25G6.6	C28D4.3
+F26D10.10	C28D4.3
+F30F8.2	C28D4.3
+F45H10.1	C28D4.3
+F56D12.1	C28D4.3
+K03H1.1	C28D4.3
+K04D7.3	C28D4.3
+M02D8.4	C28D4.3
+R06C7.5	C28D4.3
+T01C8.5	C28D4.3
+T04A8.5	C28D4.3
+T09B4.8	C28D4.3
+T14D7.1	C28D4.3
+W07E11.1	C28D4.3
+Y105C5B.28	C28D4.3
+Y37D8A.23	C28D4.3
+ZK829.4	C28D4.3
+C37H5.6	C32F10.8
+C44E4.3	C32F10.8
+C45B2.5	C32F10.8
+C47A10.5	C32F10.8
+D2085.1	C32F10.8
+DH11.1	C32F10.8
+F07A11.2	C32F10.8
+F18E3.7	C32F10.8
+F22B3.4	C32F10.8
+F25G6.6	C32F10.8
+F26D10.10	C32F10.8
+F30F8.2	C32F10.8
+F45H10.1	C32F10.8
+F56D12.1	C32F10.8
+K03H1.1	C32F10.8
+K04D7.3	C32F10.8
+M02D8.4	C32F10.8
+R06C7.5	C32F10.8
+T01C8.5	C32F10.8
+T04A8.5	C32F10.8
+T09B4.8	C32F10.8
+T14D7.1	C32F10.8
+W07E11.1	C32F10.8
+Y105C5B.28	C32F10.8
+Y37D8A.23	C32F10.8
+ZK829.4	C32F10.8
+C44E4.3	C37H5.6
+C45B2.5	C37H5.6
+C47A10.5	C37H5.6
+D2085.1	C37H5.6
+DH11.1	C37H5.6
+F07A11.2	C37H5.6
+F18E3.7	C37H5.6
+F22B3.4	C37H5.6
+F25G6.6	C37H5.6
+F26D10.10	C37H5.6
+F30F8.2	C37H5.6
+F45H10.1	C37H5.6
+F56D12.1	C37H5.6
+K03H1.1	C37H5.6
+K04D7.3	C37H5.6
+M02D8.4	C37H5.6
+T01C8.5	C37H5.6
+T09B4.8	C37H5.6
+T14D7.1	C37H5.6
+W07E11.1	C37H5.6
+Y105C5B.28	C37H5.6
+Y37D8A.23	C37H5.6
+ZK829.4	C37H5.6
+C45B2.5	C44E4.3
+C47A10.5	C44E4.3
+D2085.1	C44E4.3
+DH11.1	C44E4.3
+F07A11.2	C44E4.3
+F18E3.7	C44E4.3
+F22B3.4	C44E4.3
+F25G6.6	C44E4.3
+F26D10.10	C44E4.3
+F30F8.2	C44E4.3
+F45H10.1	C44E4.3
+F56D12.1	C44E4.3
+K03H1.1	C44E4.3
+K04D7.3	C44E4.3
+M02D8.4	C44E4.3
+R06C7.5	C44E4.3
+T01C8.5	C44E4.3
+T04A8.5	C44E4.3
+T09B4.8	C44E4.3
+T14D7.1	C44E4.3
+W07E11.1	C44E4.3
+Y105C5B.28	C44E4.3
+Y37D8A.23	C44E4.3
+ZK829.4	C44E4.3
+C47A10.5	C45B2.5
+D2085.1	C45B2.5
+DH11.1	C45B2.5
+F07A11.2	C45B2.5
+F18E3.7	C45B2.5
+F22B3.4	C45B2.5
+F25G6.6	C45B2.5
+F26D10.10	C45B2.5
+F30F8.2	C45B2.5
+F45H10.1	C45B2.5
+F56D12.1	C45B2.5
+K03H1.1	C45B2.5
+K04D7.3	C45B2.5
+M02D8.4	C45B2.5
+R06C7.5	C45B2.5
+T01C8.5	C45B2.5
+T04A8.5	C45B2.5
+T09B4.8	C45B2.5
+T14D7.1	C45B2.5
+W07E11.1	C45B2.5
+Y105C5B.28	C45B2.5
+Y37D8A.23	C45B2.5
+ZK829.4	C45B2.5
+D2085.1	C47A10.5
+DH11.1	C47A10.5
+F07A11.2	C47A10.5
+F18E3.7	C47A10.5
+F22B3.4	C47A10.5
+F25G6.6	C47A10.5
+F26D10.10	C47A10.5
+F30F8.2	C47A10.5
+F45H10.1	C47A10.5
+F56D12.1	C47A10.5
+K03H1.1	C47A10.5
+K04D7.3	C47A10.5
+M02D8.4	C47A10.5
+R06C7.5	C47A10.5
+T01C8.5	C47A10.5
+T04A8.5	C47A10.5
+T09B4.8	C47A10.5
+T14D7.1	C47A10.5
+W07E11.1	C47A10.5
+Y105C5B.28	C47A10.5
+Y37D8A.23	C47A10.5
+ZK829.4	C47A10.5
+DH11.1	D2085.1
+F07A11.2	D2085.1
+F18E3.7	D2085.1
+F22B3.4	D2085.1
+F25G6.6	D2085.1
+F26D10.10	D2085.1
+F30F8.2	D2085.1
+F45H10.1	D2085.1
+F56D12.1	D2085.1
+K03H1.1	D2085.1
+K04D7.3	D2085.1
+M02D8.4	D2085.1
+R06C7.5	D2085.1
+T01C8.5	D2085.1
+T04A8.5	D2085.1
+T09B4.8	D2085.1
+T14D7.1	D2085.1
+W07E11.1	D2085.1
+Y105C5B.28	D2085.1
+Y37D8A.23	D2085.1
+ZK829.4	D2085.1
+F07A11.2	DH11.1
+F18E3.7	DH11.1
+F22B3.4	DH11.1
+F25G6.6	DH11.1
+F26D10.10	DH11.1
+F30F8.2	DH11.1
+F45H10.1	DH11.1
+F56D12.1	DH11.1
+K03H1.1	DH11.1
+K04D7.3	DH11.1
+M02D8.4	DH11.1
+R06C7.5	DH11.1
+T01C8.5	DH11.1
+T04A8.5	DH11.1
+T09B4.8	DH11.1
+T14D7.1	DH11.1
+W07E11.1	DH11.1
+Y105C5B.28	DH11.1
+Y37D8A.23	DH11.1
+ZK829.4	DH11.1
+F18E3.7	F07A11.2
+F22B3.4	F07A11.2
+F25G6.6	F07A11.2
+F26D10.10	F07A11.2
+F30F8.2	F07A11.2
+F45H10.1	F07A11.2
+F56D12.1	F07A11.2
+K03H1.1	F07A11.2
+K04D7.3	F07A11.2
+M02D8.4	F07A11.2
+R06C7.5	F07A11.2
+T01C8.5	F07A11.2
+T04A8.5	F07A11.2
+T09B4.8	F07A11.2
+T14D7.1	F07A11.2
+W07E11.1	F07A11.2
+Y105C5B.28	F07A11.2
+Y37D8A.23	F07A11.2
+ZK829.4	F07A11.2
+F22B3.4	F18E3.7
+F25G6.6	F18E3.7
+F26D10.10	F18E3.7
+F30F8.2	F18E3.7
+F45H10.1	F18E3.7
+F56D12.1	F18E3.7
+K03H1.1	F18E3.7
+K04D7.3	F18E3.7
+M02D8.4	F18E3.7
+R06C7.5	F18E3.7
+T01C8.5	F18E3.7
+T04A8.5	F18E3.7
+T09B4.8	F18E3.7
+T14D7.1	F18E3.7
+W07E11.1	F18E3.7
+Y105C5B.28	F18E3.7
+Y37D8A.23	F18E3.7
+ZK829.4	F18E3.7
+F25G6.6	F22B3.4
+F26D10.10	F22B3.4
+F30F8.2	F22B3.4
+F45H10.1	F22B3.4
+F56D12.1	F22B3.4
+K03H1.1	F22B3.4
+K04D7.3	F22B3.4
+M02D8.4	F22B3.4
+R06C7.5	F22B3.4
+T01C8.5	F22B3.4
+T04A8.5	F22B3.4
+T09B4.8	F22B3.4
+T14D7.1	F22B3.4
+W07E11.1	F22B3.4
+Y105C5B.28	F22B3.4
+Y37D8A.23	F22B3.4
+ZK829.4	F22B3.4
+F26D10.10	F25G6.6
+F30F8.2	F25G6.6
+F45H10.1	F25G6.6
+F56D12.1	F25G6.6
+K03H1.1	F25G6.6
+K04D7.3	F25G6.6
+M02D8.4	F25G6.6
+R06C7.5	F25G6.6
+T01C8.5	F25G6.6
+T04A8.5	F25G6.6
+T09B4.8	F25G6.6
+T14D7.1	F25G6.6
+W07E11.1	F25G6.6
+Y105C5B.28	F25G6.6
+Y37D8A.23	F25G6.6
+ZK829.4	F25G6.6
+F30F8.2	F26D10.10
+F45H10.1	F26D10.10
+F56D12.1	F26D10.10
+K03H1.1	F26D10.10
+K04D7.3	F26D10.10
+M02D8.4	F26D10.10
+R06C7.5	F26D10.10
+T01C8.5	F26D10.10
+T04A8.5	F26D10.10
+T09B4.8	F26D10.10
+T14D7.1	F26D10.10
+W07E11.1	F26D10.10
+Y105C5B.28	F26D10.10
+Y37D8A.23	F26D10.10
+ZK829.4	F26D10.10
+F45H10.1	F30F8.2
+F56D12.1	F30F8.2
+K03H1.1	F30F8.2
+K04D7.3	F30F8.2
+M02D8.4	F30F8.2
+R06C7.5	F30F8.2
+T01C8.5	F30F8.2
+T04A8.5	F30F8.2
+T09B4.8	F30F8.2
+T14D7.1	F30F8.2
+W07E11.1	F30F8.2
+Y105C5B.28	F30F8.2
+Y37D8A.23	F30F8.2
+ZK829.4	F30F8.2
+F56D12.1	F45H10.1
+K03H1.1	F45H10.1
+K04D7.3	F45H10.1
+M02D8.4	F45H10.1
+R06C7.5	F45H10.1
+T01C8.5	F45H10.1
+T04A8.5	F45H10.1
+T09B4.8	F45H10.1
+T14D7.1	F45H10.1
+W07E11.1	F45H10.1
+Y105C5B.28	F45H10.1
+Y37D8A.23	F45H10.1
+ZK829.4	F45H10.1
+K03H1.1	F56D12.1
+K04D7.3	F56D12.1
+M02D8.4	F56D12.1
+R06C7.5	F56D12.1
+T01C8.5	F56D12.1
+T04A8.5	F56D12.1
+T09B4.8	F56D12.1
+T14D7.1	F56D12.1
+W07E11.1	F56D12.1
+Y105C5B.28	F56D12.1
+Y37D8A.23	F56D12.1
+ZK829.4	F56D12.1
+K04D7.3	K03H1.1
+M02D8.4	K03H1.1
+R06C7.5	K03H1.1
+T01C8.5	K03H1.1
+T04A8.5	K03H1.1
+T09B4.8	K03H1.1
+T14D7.1	K03H1.1
+W07E11.1	K03H1.1
+Y105C5B.28	K03H1.1
+Y37D8A.23	K03H1.1
+ZK829.4	K03H1.1
+M02D8.4	K04D7.3
+R06C7.5	K04D7.3
+T01C8.5	K04D7.3
+T04A8.5	K04D7.3
+T09B4.8	K04D7.3
+T14D7.1	K04D7.3
+W07E11.1	K04D7.3
+Y105C5B.28	K04D7.3
+Y37D8A.23	K04D7.3
+ZK829.4	K04D7.3
+R06C7.5	M02D8.4
+T01C8.5	M02D8.4
+T04A8.5	M02D8.4
+T09B4.8	M02D8.4
+T14D7.1	M02D8.4
+W07E11.1	M02D8.4
+Y105C5B.28	M02D8.4
+Y37D8A.23	M02D8.4
+ZK829.4	M02D8.4
+T01C8.5	R06C7.5
+T09B4.8	R06C7.5
+T14D7.1	R06C7.5
+W07E11.1	R06C7.5
+Y105C5B.28	R06C7.5
+Y37D8A.23	R06C7.5
+ZK829.4	R06C7.5
+T04A8.5	T01C8.5
+T09B4.8	T01C8.5
+T14D7.1	T01C8.5
+W07E11.1	T01C8.5
+Y105C5B.28	T01C8.5
+Y37D8A.23	T01C8.5
+ZK829.4	T01C8.5
+T09B4.8	T04A8.5
+T14D7.1	T04A8.5
+W07E11.1	T04A8.5
+Y105C5B.28	T04A8.5
+Y37D8A.23	T04A8.5
+ZK829.4	T04A8.5
+T14D7.1	T09B4.8
+W07E11.1	T09B4.8
+Y105C5B.28	T09B4.8
+Y37D8A.23	T09B4.8
+ZK829.4	T09B4.8
+W07E11.1	T14D7.1
+Y105C5B.28	T14D7.1
+Y37D8A.23	T14D7.1
+ZK829.4	T14D7.1
+Y105C5B.28	W07E11.1
+Y37D8A.23	W07E11.1
+ZK829.4	W07E11.1
+Y37D8A.23	Y105C5B.28
+ZK829.4	Y105C5B.28
+ZK829.4	Y37D8A.23
+C12C8.2	C05D11.11
+C13B9.2	C05D11.11
+C31C9.2	C05D11.11
+C34C6.4	C05D11.11
+F01F1.6	C05D11.11
+F08F3.4	C05D11.11
+F22B8.6	C05D11.11
+F25B4.1	C05D11.11
+F26H9.5	C05D11.11
+F54A3.4	C05D11.11
+F57B10.3	C05D11.11
+K01C8.1	C05D11.11
+LLC1.3	C05D11.11
+R102.4	C05D11.11
+R12C12.1	C05D11.11
+T09B4.8	C05D11.11
+T14D7.1	C05D11.11
+T25B9.1	C05D11.11
+Y51H7C.9	C05D11.11
+Y62E10A.13	C05D11.11
+Y69A2AR.5	C05D11.11
+ZC373.1	C05D11.11
+ZK1127.10	C05D11.11
+C13B9.2	C12C8.2
+C31C9.2	C12C8.2
+C34C6.4	C12C8.2
+F01F1.6	C12C8.2
+F08F3.4	C12C8.2
+F22B8.6	C12C8.2
+F25B4.1	C12C8.2
+F26H9.5	C12C8.2
+F54A3.4	C12C8.2
+F57B10.3	C12C8.2
+K01C8.1	C12C8.2
+LLC1.3	C12C8.2
+R102.4	C12C8.2
+R12C12.1	C12C8.2
+T09B4.8	C12C8.2
+T14D7.1	C12C8.2
+T25B9.1	C12C8.2
+Y51H7C.9	C12C8.2
+Y62E10A.13	C12C8.2
+Y69A2AR.5	C12C8.2
+ZC373.1	C12C8.2
+ZK1127.10	C12C8.2
+C31C9.2	C13B9.2
+C34C6.4	C13B9.2
+F01F1.6	C13B9.2
+F08F3.4	C13B9.2
+F22B8.6	C13B9.2
+F25B4.1	C13B9.2
+F26H9.5	C13B9.2
+F54A3.4	C13B9.2
+F57B10.3	C13B9.2
+K01C8.1	C13B9.2
+LLC1.3	C13B9.2
+R102.4	C13B9.2
+R12C12.1	C13B9.2
+T09B4.8	C13B9.2
+T14D7.1	C13B9.2
+T25B9.1	C13B9.2
+Y51H7C.9	C13B9.2
+Y62E10A.13	C13B9.2
+Y69A2AR.5	C13B9.2
+ZC373.1	C13B9.2
+ZK1127.10	C13B9.2
+C34C6.4	C31C9.2
+F01F1.6	C31C9.2
+F08F3.4	C31C9.2
+F22B8.6	C31C9.2
+F25B4.1	C31C9.2
+F26H9.5	C31C9.2
+F54A3.4	C31C9.2
+F57B10.3	C31C9.2
+K01C8.1	C31C9.2
+LLC1.3	C31C9.2
+R102.4	C31C9.2
+R12C12.1	C31C9.2
+T09B4.8	C31C9.2
+T14D7.1	C31C9.2
+T25B9.1	C31C9.2
+Y51H7C.9	C31C9.2
+Y62E10A.13	C31C9.2
+Y69A2AR.5	C31C9.2
+ZC373.1	C31C9.2
+ZK1127.10	C31C9.2
+F01F1.6	C34C6.4
+F08F3.4	C34C6.4
+F22B8.6	C34C6.4
+F25B4.1	C34C6.4
+F26H9.5	C34C6.4
+F54A3.4	C34C6.4
+F57B10.3	C34C6.4
+K01C8.1	C34C6.4
+LLC1.3	C34C6.4
+R102.4	C34C6.4
+R12C12.1	C34C6.4
+T09B4.8	C34C6.4
+T14D7.1	C34C6.4
+T25B9.1	C34C6.4
+Y51H7C.9	C34C6.4
+Y62E10A.13	C34C6.4
+Y69A2AR.5	C34C6.4
+ZC373.1	C34C6.4
+ZK1127.10	C34C6.4
+F08F3.4	F01F1.6
+F22B8.6	F01F1.6
+F25B4.1	F01F1.6
+F26H9.5	F01F1.6
+F54A3.4	F01F1.6
+K01C8.1	F01F1.6
+R102.4	F01F1.6
+R12C12.1	F01F1.6
+T09B4.8	F01F1.6
+T14D7.1	F01F1.6
+T25B9.1	F01F1.6
+Y51H7C.9	F01F1.6
+Y62E10A.13	F01F1.6
+Y69A2AR.5	F01F1.6
+ZC373.1	F01F1.6
+ZK1127.10	F01F1.6
+F22B8.6	F08F3.4
+F25B4.1	F08F3.4
+F26H9.5	F08F3.4
+F54A3.4	F08F3.4
+F57B10.3	F08F3.4
+K01C8.1	F08F3.4
+LLC1.3	F08F3.4
+R102.4	F08F3.4
+R12C12.1	F08F3.4
+T09B4.8	F08F3.4
+T14D7.1	F08F3.4
+T25B9.1	F08F3.4
+Y51H7C.9	F08F3.4
+Y62E10A.13	F08F3.4
+Y69A2AR.5	F08F3.4
+ZC373.1	F08F3.4
+ZK1127.10	F08F3.4
+F25B4.1	F22B8.6
+F26H9.5	F22B8.6
+F54A3.4	F22B8.6
+F57B10.3	F22B8.6
+K01C8.1	F22B8.6
+LLC1.3	F22B8.6
+R102.4	F22B8.6
+R12C12.1	F22B8.6
+T09B4.8	F22B8.6
+T14D7.1	F22B8.6
+T25B9.1	F22B8.6
+Y51H7C.9	F22B8.6
+Y62E10A.13	F22B8.6
+Y69A2AR.5	F22B8.6
+ZC373.1	F22B8.6
+ZK1127.10	F22B8.6
+F26H9.5	F25B4.1
+F54A3.4	F25B4.1
+F57B10.3	F25B4.1
+K01C8.1	F25B4.1
+LLC1.3	F25B4.1
+R102.4	F25B4.1
+R12C12.1	F25B4.1
+T09B4.8	F25B4.1
+T14D7.1	F25B4.1
+T25B9.1	F25B4.1
+Y51H7C.9	F25B4.1
+Y62E10A.13	F25B4.1
+Y69A2AR.5	F25B4.1
+ZC373.1	F25B4.1
+ZK1127.10	F25B4.1
+F54A3.4	F26H9.5
+F57B10.3	F26H9.5
+K01C8.1	F26H9.5
+LLC1.3	F26H9.5
+R102.4	F26H9.5
+R12C12.1	F26H9.5
+T09B4.8	F26H9.5
+T14D7.1	F26H9.5
+T25B9.1	F26H9.5
+Y51H7C.9	F26H9.5
+Y62E10A.13	F26H9.5
+Y69A2AR.5	F26H9.5
+ZC373.1	F26H9.5
+ZK1127.10	F26H9.5
+F57B10.3	F54A3.4
+K01C8.1	F54A3.4
+LLC1.3	F54A3.4
+R102.4	F54A3.4
+R12C12.1	F54A3.4
+T09B4.8	F54A3.4
+T14D7.1	F54A3.4
+T25B9.1	F54A3.4
+Y51H7C.9	F54A3.4
+Y62E10A.13	F54A3.4
+Y69A2AR.5	F54A3.4
+ZC373.1	F54A3.4
+ZK1127.10	F54A3.4
+K01C8.1	F57B10.3
+R102.4	F57B10.3
+R12C12.1	F57B10.3
+T09B4.8	F57B10.3
+T14D7.1	F57B10.3
+T25B9.1	F57B10.3
+Y51H7C.9	F57B10.3
+Y62E10A.13	F57B10.3
+Y69A2AR.5	F57B10.3
+ZC373.1	F57B10.3
+ZK1127.10	F57B10.3
+LLC1.3	K01C8.1
+R102.4	K01C8.1
+R12C12.1	K01C8.1
+T09B4.8	K01C8.1
+T14D7.1	K01C8.1
+T25B9.1	K01C8.1
+Y51H7C.9	K01C8.1
+Y62E10A.13	K01C8.1
+Y69A2AR.5	K01C8.1
+ZC373.1	K01C8.1
+ZK1127.10	K01C8.1
+R102.4	LLC1.3
+R12C12.1	LLC1.3
+T09B4.8	LLC1.3
+T14D7.1	LLC1.3
+T25B9.1	LLC1.3
+Y51H7C.9	LLC1.3
+Y62E10A.13	LLC1.3
+Y69A2AR.5	LLC1.3
+ZC373.1	LLC1.3
+ZK1127.10	LLC1.3
+R12C12.1	R102.4
+T09B4.8	R102.4
+T14D7.1	R102.4
+T25B9.1	R102.4
+Y51H7C.9	R102.4
+Y62E10A.13	R102.4
+Y69A2AR.5	R102.4
+ZC373.1	R102.4
+ZK1127.10	R102.4
+T09B4.8	R12C12.1
+T14D7.1	R12C12.1
+T25B9.1	R12C12.1
+Y51H7C.9	R12C12.1
+Y62E10A.13	R12C12.1
+Y69A2AR.5	R12C12.1
+ZC373.1	R12C12.1
+ZK1127.10	R12C12.1
+T25B9.1	T09B4.8
+Y51H7C.9	T09B4.8
+Y62E10A.13	T09B4.8
+Y69A2AR.5	T09B4.8
+ZC373.1	T09B4.8
+ZK1127.10	T09B4.8
+T25B9.1	T14D7.1
+Y51H7C.9	T14D7.1
+Y62E10A.13	T14D7.1
+Y69A2AR.5	T14D7.1
+ZC373.1	T14D7.1
+ZK1127.10	T14D7.1
+Y51H7C.9	T25B9.1
+Y62E10A.13	T25B9.1
+Y69A2AR.5	T25B9.1
+ZC373.1	T25B9.1
+ZK1127.10	T25B9.1
+Y62E10A.13	Y51H7C.9
+Y69A2AR.5	Y51H7C.9
+ZC373.1	Y51H7C.9
+ZK1127.10	Y51H7C.9
+Y69A2AR.5	Y62E10A.13
+ZC373.1	Y62E10A.13
+ZK1127.10	Y62E10A.13
+ZC373.1	Y69A2AR.5
+ZK1127.10	Y69A2AR.5
+ZK1127.10	ZC373.1
+C06E7.1	B0228.7
+C06E7.3	B0228.7
+C12C8.2	B0228.7
+C14E2.2	B0228.7
+C14F11.1	B0228.7
+C17G1.7	B0228.7
+C44E4.3	B0228.7
+C49F5.1	B0228.7
+D2023.5	B0228.7
+F11G11.9	B0228.7
+F13D12.2	B0228.7
+F22B8.6	B0228.7
+F42D1.2	B0228.7
+F42F12.4	B0228.7
+F47G4.7	B0228.7
+F54A3.4	B0228.7
+F56F10.3	B0228.7
+F58H1.3	B0228.7
+F59A7.9	B0228.7
+H12D21.4	B0228.7
+K02F2.2	B0228.7
+K10H10.2	B0228.7
+R03D7.1	B0228.7
+T01C8.5	B0228.7
+T13A10.11	B0228.7
+Y46G5A.19	B0228.7
+ZC373.1	B0228.7
+ZC373.5	B0228.7
+ZK1127.10	B0228.7
+C06E7.3	C06E7.1
+C12C8.2	C06E7.1
+C14E2.2	C06E7.1
+C14F11.1	C06E7.1
+C17G1.7	C06E7.1
+C44E4.3	C06E7.1
+C49F5.1	C06E7.1
+D2023.5	C06E7.1
+F11G11.9	C06E7.1
+F13D12.2	C06E7.1
+F22B8.6	C06E7.1
+F42D1.2	C06E7.1
+F42F12.4	C06E7.1
+F47G4.7	C06E7.1
+F54A3.4	C06E7.1
+F56F10.3	C06E7.1
+F58H1.3	C06E7.1
+F59A7.9	C06E7.1
+H12D21.4	C06E7.1
+K02F2.2	C06E7.1
+K10H10.2	C06E7.1
+R03D7.1	C06E7.1
+T01C8.5	C06E7.1
+T13A10.11	C06E7.1
+Y46G5A.19	C06E7.1
+ZC373.1	C06E7.1
+ZC373.5	C06E7.1
+ZK1127.10	C06E7.1
+C12C8.2	C06E7.3
+C14E2.2	C06E7.3
+C14F11.1	C06E7.3
+C17G1.7	C06E7.3
+C44E4.3	C06E7.3
+C49F5.1	C06E7.3
+D2023.5	C06E7.3
+F11G11.9	C06E7.3
+F13D12.2	C06E7.3
+F22B8.6	C06E7.3
+F42D1.2	C06E7.3
+F42F12.4	C06E7.3
+F47G4.7	C06E7.3
+F54A3.4	C06E7.3
+F56F10.3	C06E7.3
+F58H1.3	C06E7.3
+F59A7.9	C06E7.3
+H12D21.4	C06E7.3
+K02F2.2	C06E7.3
+K10H10.2	C06E7.3
+R03D7.1	C06E7.3
+T01C8.5	C06E7.3
+T13A10.11	C06E7.3
+Y46G5A.19	C06E7.3
+ZC373.1	C06E7.3
+ZC373.5	C06E7.3
+ZK1127.10	C06E7.3
+C14E2.2	C12C8.2
+C14F11.1	C12C8.2
+C17G1.7	C12C8.2
+C44E4.3	C12C8.2
+C49F5.1	C12C8.2
+D2023.5	C12C8.2
+F11G11.9	C12C8.2
+F13D12.2	C12C8.2
+F42D1.2	C12C8.2
+F42F12.4	C12C8.2
+F47G4.7	C12C8.2
+F56F10.3	C12C8.2
+F58H1.3	C12C8.2
+F59A7.9	C12C8.2
+H12D21.4	C12C8.2
+K02F2.2	C12C8.2
+K10H10.2	C12C8.2
+R03D7.1	C12C8.2
+T01C8.5	C12C8.2
+T13A10.11	C12C8.2
+Y46G5A.19	C12C8.2
+ZC373.5	C12C8.2
+C17G1.7	C14E2.2
+C49F5.1	C14E2.2
+D2023.5	C14E2.2
+F11G11.9	C14E2.2
+F13D12.2	C14E2.2
+F22B8.6	C14E2.2
+F42D1.2	C14E2.2
+F42F12.4	C14E2.2
+F47G4.7	C14E2.2
+F54A3.4	C14E2.2
+F56F10.3	C14E2.2
+F58H1.3	C14E2.2
+F59A7.9	C14E2.2
+H12D21.4	C14E2.2
+K02F2.2	C14E2.2
+K10H10.2	C14E2.2
+R03D7.1	C14E2.2
+T13A10.11	C14E2.2
+Y46G5A.19	C14E2.2
+ZC373.1	C14E2.2
+ZC373.5	C14E2.2
+ZK1127.10	C14E2.2
+C17G1.7	C14F11.1
+C49F5.1	C14F11.1
+D2023.5	C14F11.1
+F11G11.9	C14F11.1
+F13D12.2	C14F11.1
+F22B8.6	C14F11.1
+F42D1.2	C14F11.1
+F42F12.4	C14F11.1
+F47G4.7	C14F11.1
+F54A3.4	C14F11.1
+F56F10.3	C14F11.1
+F58H1.3	C14F11.1
+F59A7.9	C14F11.1
+H12D21.4	C14F11.1
+K02F2.2	C14F11.1
+K10H10.2	C14F11.1
+R03D7.1	C14F11.1
+T13A10.11	C14F11.1
+Y46G5A.19	C14F11.1
+ZC373.1	C14F11.1
+ZC373.5	C14F11.1
+ZK1127.10	C14F11.1
+C44E4.3	C17G1.7
+C49F5.1	C17G1.7
+D2023.5	C17G1.7
+F11G11.9	C17G1.7
+F13D12.2	C17G1.7
+F22B8.6	C17G1.7
+F42D1.2	C17G1.7
+F42F12.4	C17G1.7
+F47G4.7	C17G1.7
+F54A3.4	C17G1.7
+F56F10.3	C17G1.7
+F58H1.3	C17G1.7
+F59A7.9	C17G1.7
+H12D21.4	C17G1.7
+K02F2.2	C17G1.7
+K10H10.2	C17G1.7
+R03D7.1	C17G1.7
+T01C8.5	C17G1.7
+T13A10.11	C17G1.7
+Y46G5A.19	C17G1.7
+ZC373.1	C17G1.7
+ZC373.5	C17G1.7
+ZK1127.10	C17G1.7
+C49F5.1	C44E4.3
+D2023.5	C44E4.3
+F11G11.9	C44E4.3
+F13D12.2	C44E4.3
+F22B8.6	C44E4.3
+F42D1.2	C44E4.3
+F42F12.4	C44E4.3
+F47G4.7	C44E4.3
+F54A3.4	C44E4.3
+F56F10.3	C44E4.3
+F58H1.3	C44E4.3
+F59A7.9	C44E4.3
+H12D21.4	C44E4.3
+K02F2.2	C44E4.3
+K10H10.2	C44E4.3
+R03D7.1	C44E4.3
+T13A10.11	C44E4.3
+Y46G5A.19	C44E4.3
+ZC373.1	C44E4.3
+ZC373.5	C44E4.3
+ZK1127.10	C44E4.3
+D2023.5	C49F5.1
+F11G11.9	C49F5.1
+F13D12.2	C49F5.1
+F22B8.6	C49F5.1
+F42D1.2	C49F5.1
+F42F12.4	C49F5.1
+F47G4.7	C49F5.1
+F54A3.4	C49F5.1
+F56F10.3	C49F5.1
+F58H1.3	C49F5.1
+F59A7.9	C49F5.1
+H12D21.4	C49F5.1
+K02F2.2	C49F5.1
+K10H10.2	C49F5.1
+R03D7.1	C49F5.1
+T01C8.5	C49F5.1
+T13A10.11	C49F5.1
+Y46G5A.19	C49F5.1
+ZC373.1	C49F5.1
+ZC373.5	C49F5.1
+ZK1127.10	C49F5.1
+F11G11.9	D2023.5
+F13D12.2	D2023.5
+F22B8.6	D2023.5
+F42D1.2	D2023.5
+F42F12.4	D2023.5
+F47G4.7	D2023.5
+F54A3.4	D2023.5
+F56F10.3	D2023.5
+F58H1.3	D2023.5
+F59A7.9	D2023.5
+H12D21.4	D2023.5
+K02F2.2	D2023.5
+K10H10.2	D2023.5
+R03D7.1	D2023.5
+T01C8.5	D2023.5
+T13A10.11	D2023.5
+Y46G5A.19	D2023.5
+ZC373.1	D2023.5
+ZC373.5	D2023.5
+ZK1127.10	D2023.5
+F13D12.2	F11G11.9
+F22B8.6	F11G11.9
+F42D1.2	F11G11.9
+F42F12.4	F11G11.9
+F47G4.7	F11G11.9
+F54A3.4	F11G11.9
+F56F10.3	F11G11.9
+F58H1.3	F11G11.9
+F59A7.9	F11G11.9
+H12D21.4	F11G11.9
+K02F2.2	F11G11.9
+K10H10.2	F11G11.9
+R03D7.1	F11G11.9
+T01C8.5	F11G11.9
+T13A10.11	F11G11.9
+Y46G5A.19	F11G11.9
+ZC373.1	F11G11.9
+ZC373.5	F11G11.9
+ZK1127.10	F11G11.9
+F22B8.6	F13D12.2
+F42D1.2	F13D12.2
+F42F12.4	F13D12.2
+F47G4.7	F13D12.2
+F54A3.4	F13D12.2
+F56F10.3	F13D12.2
+F58H1.3	F13D12.2
+F59A7.9	F13D12.2
+H12D21.4	F13D12.2
+K02F2.2	F13D12.2
+K10H10.2	F13D12.2
+R03D7.1	F13D12.2
+T01C8.5	F13D12.2
+T13A10.11	F13D12.2
+Y46G5A.19	F13D12.2
+ZC373.1	F13D12.2
+ZC373.5	F13D12.2
+ZK1127.10	F13D12.2
+F42D1.2	F22B8.6
+F42F12.4	F22B8.6
+F47G4.7	F22B8.6
+F56F10.3	F22B8.6
+F58H1.3	F22B8.6
+F59A7.9	F22B8.6
+H12D21.4	F22B8.6
+K02F2.2	F22B8.6
+K10H10.2	F22B8.6
+R03D7.1	F22B8.6
+T01C8.5	F22B8.6
+T13A10.11	F22B8.6
+Y46G5A.19	F22B8.6
+ZC373.5	F22B8.6
+F42F12.4	F42D1.2
+F47G4.7	F42D1.2
+F54A3.4	F42D1.2
+F56F10.3	F42D1.2
+F58H1.3	F42D1.2
+F59A7.9	F42D1.2
+H12D21.4	F42D1.2
+K02F2.2	F42D1.2
+K10H10.2	F42D1.2
+R03D7.1	F42D1.2
+T01C8.5	F42D1.2
+T13A10.11	F42D1.2
+Y46G5A.19	F42D1.2
+ZC373.1	F42D1.2
+ZC373.5	F42D1.2
+ZK1127.10	F42D1.2
+F47G4.7	F42F12.4
+F54A3.4	F42F12.4
+F56F10.3	F42F12.4
+F58H1.3	F42F12.4
+F59A7.9	F42F12.4
+H12D21.4	F42F12.4
+K02F2.2	F42F12.4
+K10H10.2	F42F12.4
+R03D7.1	F42F12.4
+T01C8.5	F42F12.4
+T13A10.11	F42F12.4
+Y46G5A.19	F42F12.4
+ZC373.1	F42F12.4
+ZC373.5	F42F12.4
+ZK1127.10	F42F12.4
+F54A3.4	F47G4.7
+F56F10.3	F47G4.7
+F58H1.3	F47G4.7
+F59A7.9	F47G4.7
+H12D21.4	F47G4.7
+K02F2.2	F47G4.7
+K10H10.2	F47G4.7
+R03D7.1	F47G4.7
+T01C8.5	F47G4.7
+T13A10.11	F47G4.7
+Y46G5A.19	F47G4.7
+ZC373.1	F47G4.7
+ZC373.5	F47G4.7
+ZK1127.10	F47G4.7
+F56F10.3	F54A3.4
+F58H1.3	F54A3.4
+F59A7.9	F54A3.4
+H12D21.4	F54A3.4
+K02F2.2	F54A3.4
+K10H10.2	F54A3.4
+R03D7.1	F54A3.4
+T01C8.5	F54A3.4
+T13A10.11	F54A3.4
+Y46G5A.19	F54A3.4
+ZC373.5	F54A3.4
+F58H1.3	F56F10.3
+F59A7.9	F56F10.3
+H12D21.4	F56F10.3
+K02F2.2	F56F10.3
+K10H10.2	F56F10.3
+R03D7.1	F56F10.3
+T01C8.5	F56F10.3
+T13A10.11	F56F10.3
+Y46G5A.19	F56F10.3
+ZC373.1	F56F10.3
+ZC373.5	F56F10.3
+ZK1127.10	F56F10.3
+F59A7.9	F58H1.3
+H12D21.4	F58H1.3
+K02F2.2	F58H1.3
+K10H10.2	F58H1.3
+R03D7.1	F58H1.3
+T01C8.5	F58H1.3
+T13A10.11	F58H1.3
+Y46G5A.19	F58H1.3
+ZC373.1	F58H1.3
+ZC373.5	F58H1.3
+ZK1127.10	F58H1.3
+H12D21.4	F59A7.9
+K02F2.2	F59A7.9
+K10H10.2	F59A7.9
+R03D7.1	F59A7.9
+T01C8.5	F59A7.9
+T13A10.11	F59A7.9
+Y46G5A.19	F59A7.9
+ZC373.1	F59A7.9
+ZC373.5	F59A7.9
+ZK1127.10	F59A7.9
+K02F2.2	H12D21.4
+K10H10.2	H12D21.4
+R03D7.1	H12D21.4
+T01C8.5	H12D21.4
+T13A10.11	H12D21.4
+Y46G5A.19	H12D21.4
+ZC373.1	H12D21.4
+ZC373.5	H12D21.4
+ZK1127.10	H12D21.4
+K10H10.2	K02F2.2
+R03D7.1	K02F2.2
+T01C8.5	K02F2.2
+T13A10.11	K02F2.2
+Y46G5A.19	K02F2.2
+ZC373.1	K02F2.2
+ZC373.5	K02F2.2
+ZK1127.10	K02F2.2
+R03D7.1	K10H10.2
+T01C8.5	K10H10.2
+T13A10.11	K10H10.2
+Y46G5A.19	K10H10.2
+ZC373.1	K10H10.2
+ZC373.5	K10H10.2
+ZK1127.10	K10H10.2
+T01C8.5	R03D7.1
+T13A10.11	R03D7.1
+Y46G5A.19	R03D7.1
+ZC373.1	R03D7.1
+ZC373.5	R03D7.1
+ZK1127.10	R03D7.1
+T13A10.11	T01C8.5
+Y46G5A.19	T01C8.5
+ZC373.1	T01C8.5
+ZC373.5	T01C8.5
+ZK1127.10	T01C8.5
+Y46G5A.19	T13A10.11
+ZC373.1	T13A10.11
+ZC373.5	T13A10.11
+ZK1127.10	T13A10.11
+ZC373.1	Y46G5A.19
+ZC373.5	Y46G5A.19
+ZK1127.10	Y46G5A.19
+ZC373.5	ZC373.1
+ZK1127.10	ZC373.5
+B0272.3	B0250.5
+B0303.3	B0250.5
+C02B10.1	B0250.5
+C05C10.3	B0250.5
+C29F3.1	B0250.5
+D2030.5	B0250.5
+F01F1.6	B0250.5
+F01G10.2	B0250.5
+F01G10.3	B0250.5
+F01G4.2	B0250.5
+F09F7.4	B0250.5
+F13D12.4	B0250.5
+F25B4.6	B0250.5
+F27D4.5	B0250.5
+F27D9.5	B0250.5
+F28A10.6	B0250.5
+F32B6.2	B0250.5
+F52E4.1	B0250.5
+F53A2.7	B0250.5
+F54C8.1	B0250.5
+F54D8.3	B0250.5
+K02A4.1	B0250.5
+K04D7.3	B0250.5
+K04F1.15	B0250.5
+K05F1.3	B0250.5
+K06A5.6	B0250.5
+K09H11.1	B0250.5
+LLC1.3	B0250.5
+R09B5.6	B0250.5
+T02G5.4	B0250.5
+T02G5.7	B0250.5
+T02G5.8	B0250.5
+T05G5.6	B0250.5
+T05H4.13	B0250.5
+T08B2.7	B0250.5
+T08G2.3	B0250.5
+T25G12.5	B0250.5
+Y39E4A.3	B0250.5
+Y44A6D.5	B0250.5
+Y69F12A.2	B0250.5
+Y71G12B.10	B0250.5
+ZK1058.1	B0250.5
+ZK669.4	B0250.5
+C02B10.1	B0272.3
+C05C10.3	B0272.3
+D2030.5	B0272.3
+F01G4.2	B0272.3
+F09F7.4	B0272.3
+F13D12.4	B0272.3
+F25B4.6	B0272.3
+F27D4.5	B0272.3
+F27D9.5	B0272.3
+F28A10.6	B0272.3
+F32B6.2	B0272.3
+F52E4.1	B0272.3
+K02A4.1	B0272.3
+K04D7.3	B0272.3
+LLC1.3	B0272.3
+Y39E4A.3	B0272.3
+Y44A6D.5	B0272.3
+Y71G12B.10	B0272.3
+ZK1058.1	B0272.3
+ZK669.4	B0272.3
+C02B10.1	B0303.3
+C05C10.3	B0303.3
+D2030.5	B0303.3
+F01G4.2	B0303.3
+F09F7.4	B0303.3
+F13D12.4	B0303.3
+F25B4.6	B0303.3
+F27D4.5	B0303.3
+F27D9.5	B0303.3
+F28A10.6	B0303.3
+F32B6.2	B0303.3
+F52E4.1	B0303.3
+K02A4.1	B0303.3
+K04D7.3	B0303.3
+LLC1.3	B0303.3
+Y39E4A.3	B0303.3
+Y44A6D.5	B0303.3
+Y71G12B.10	B0303.3
+ZK1058.1	B0303.3
+ZK669.4	B0303.3
+C05C10.3	C02B10.1
+C29F3.1	C02B10.1
+D2030.5	C02B10.1
+F01F1.6	C02B10.1
+F01G10.2	C02B10.1
+F01G10.3	C02B10.1
+F01G4.2	C02B10.1
+F09F7.4	C02B10.1
+F13D12.4	C02B10.1
+F25B4.6	C02B10.1
+F27D4.5	C02B10.1
+F27D9.5	C02B10.1
+F28A10.6	C02B10.1
+F32B6.2	C02B10.1
+F52E4.1	C02B10.1
+F53A2.7	C02B10.1
+F54C8.1	C02B10.1
+F54D8.3	C02B10.1
+K02A4.1	C02B10.1
+K04D7.3	C02B10.1
+K04F1.15	C02B10.1
+K05F1.3	C02B10.1
+K06A5.6	C02B10.1
+K09H11.1	C02B10.1
+LLC1.3	C02B10.1
+R09B5.6	C02B10.1
+T02G5.4	C02B10.1
+T02G5.7	C02B10.1
+T02G5.8	C02B10.1
+T05G5.6	C02B10.1
+T05H4.13	C02B10.1
+T08B2.7	C02B10.1
+T08G2.3	C02B10.1
+T25G12.5	C02B10.1
+Y39E4A.3	C02B10.1
+Y44A6D.5	C02B10.1
+Y69F12A.2	C02B10.1
+Y71G12B.10	C02B10.1
+ZK1058.1	C02B10.1
+ZK669.4	C02B10.1
+C29F3.1	C05C10.3
+D2030.5	C05C10.3
+F01F1.6	C05C10.3
+F01G10.2	C05C10.3
+F01G10.3	C05C10.3
+F01G4.2	C05C10.3
+F09F7.4	C05C10.3
+F13D12.4	C05C10.3
+F27D4.5	C05C10.3
+F27D9.5	C05C10.3
+F28A10.6	C05C10.3
+F32B6.2	C05C10.3
+F52E4.1	C05C10.3
+F53A2.7	C05C10.3
+F54C8.1	C05C10.3
+F54D8.3	C05C10.3
+K02A4.1	C05C10.3
+K04D7.3	C05C10.3
+K04F1.15	C05C10.3
+K05F1.3	C05C10.3
+K06A5.6	C05C10.3
+K09H11.1	C05C10.3
+LLC1.3	C05C10.3
+R09B5.6	C05C10.3
+T05G5.6	C05C10.3
+T05H4.13	C05C10.3
+T08B2.7	C05C10.3
+T08G2.3	C05C10.3
+T25G12.5	C05C10.3
+Y39E4A.3	C05C10.3
+Y44A6D.5	C05C10.3
+Y69F12A.2	C05C10.3
+ZK1058.1	C05C10.3
+ZK669.4	C05C10.3
+D2030.5	C29F3.1
+F01G4.2	C29F3.1
+F09F7.4	C29F3.1
+F13D12.4	C29F3.1
+F25B4.6	C29F3.1
+F27D4.5	C29F3.1
+F27D9.5	C29F3.1
+F28A10.6	C29F3.1
+F32B6.2	C29F3.1
+F52E4.1	C29F3.1
+K02A4.1	C29F3.1
+K04D7.3	C29F3.1
+LLC1.3	C29F3.1
+Y39E4A.3	C29F3.1
+Y44A6D.5	C29F3.1
+Y71G12B.10	C29F3.1
+ZK1058.1	C29F3.1
+ZK669.4	C29F3.1
+F01F1.6	D2030.5
+F01G10.2	D2030.5
+F01G10.3	D2030.5
+F01G4.2	D2030.5
+F09F7.4	D2030.5
+F13D12.4	D2030.5
+F25B4.6	D2030.5
+F27D4.5	D2030.5
+F27D9.5	D2030.5
+F28A10.6	D2030.5
+F32B6.2	D2030.5
+F52E4.1	D2030.5
+F53A2.7	D2030.5
+F54C8.1	D2030.5
+F54D8.3	D2030.5
+K02A4.1	D2030.5
+K04D7.3	D2030.5
+K04F1.15	D2030.5
+K05F1.3	D2030.5
+K06A5.6	D2030.5
+K09H11.1	D2030.5
+LLC1.3	D2030.5
+R09B5.6	D2030.5
+T02G5.4	D2030.5
+T02G5.7	D2030.5
+T02G5.8	D2030.5
+T05G5.6	D2030.5
+T05H4.13	D2030.5
+T08B2.7	D2030.5
+T08G2.3	D2030.5
+T25G12.5	D2030.5
+Y39E4A.3	D2030.5
+Y44A6D.5	D2030.5
+Y69F12A.2	D2030.5
+Y71G12B.10	D2030.5
+ZK1058.1	D2030.5
+ZK669.4	D2030.5
+F01G4.2	F01F1.6
+F09F7.4	F01F1.6
+F13D12.4	F01F1.6
+F25B4.6	F01F1.6
+F27D4.5	F01F1.6
+F27D9.5	F01F1.6
+F28A10.6	F01F1.6
+F32B6.2	F01F1.6
+F52E4.1	F01F1.6
+K02A4.1	F01F1.6
+K04D7.3	F01F1.6
+Y39E4A.3	F01F1.6
+Y44A6D.5	F01F1.6
+Y71G12B.10	F01F1.6
+ZK1058.1	F01F1.6
+ZK669.4	F01F1.6
+F01G4.2	F01G10.2
+F09F7.4	F01G10.2
+F13D12.4	F01G10.2
+F25B4.6	F01G10.2
+F27D4.5	F01G10.2
+F27D9.5	F01G10.2
+F28A10.6	F01G10.2
+F32B6.2	F01G10.2
+F52E4.1	F01G10.2
+K02A4.1	F01G10.2
+K04D7.3	F01G10.2
+LLC1.3	F01G10.2
+Y39E4A.3	F01G10.2
+Y44A6D.5	F01G10.2
+Y71G12B.10	F01G10.2
+ZK1058.1	F01G10.2
+ZK669.4	F01G10.2
+F01G4.2	F01G10.3
+F09F7.4	F01G10.3
+F13D12.4	F01G10.3
+F25B4.6	F01G10.3
+F27D4.5	F01G10.3
+F27D9.5	F01G10.3
+F28A10.6	F01G10.3
+F32B6.2	F01G10.3
+F52E4.1	F01G10.3
+K02A4.1	F01G10.3
+K04D7.3	F01G10.3
+LLC1.3	F01G10.3
+Y39E4A.3	F01G10.3
+Y44A6D.5	F01G10.3
+Y71G12B.10	F01G10.3
+ZK1058.1	F01G10.3
+ZK669.4	F01G10.3
+F09F7.4	F01G4.2
+F13D12.4	F01G4.2
+F25B4.6	F01G4.2
+F27D4.5	F01G4.2
+F27D9.5	F01G4.2
+F28A10.6	F01G4.2
+F32B6.2	F01G4.2
+F52E4.1	F01G4.2
+F53A2.7	F01G4.2
+F54C8.1	F01G4.2
+F54D8.3	F01G4.2
+K02A4.1	F01G4.2
+K04D7.3	F01G4.2
+K04F1.15	F01G4.2
+K05F1.3	F01G4.2
+K06A5.6	F01G4.2
+K09H11.1	F01G4.2
+LLC1.3	F01G4.2
+R09B5.6	F01G4.2
+T02G5.4	F01G4.2
+T02G5.7	F01G4.2
+T02G5.8	F01G4.2
+T05G5.6	F01G4.2
+T05H4.13	F01G4.2
+T08B2.7	F01G4.2
+T08G2.3	F01G4.2
+T25G12.5	F01G4.2
+Y39E4A.3	F01G4.2
+Y44A6D.5	F01G4.2
+Y69F12A.2	F01G4.2
+Y71G12B.10	F01G4.2
+ZK1058.1	F01G4.2
+ZK669.4	F01G4.2
+F13D12.4	F09F7.4
+F25B4.6	F09F7.4
+F27D4.5	F09F7.4
+F27D9.5	F09F7.4
+F28A10.6	F09F7.4
+F32B6.2	F09F7.4
+F52E4.1	F09F7.4
+F53A2.7	F09F7.4
+F54C8.1	F09F7.4
+F54D8.3	F09F7.4
+K02A4.1	F09F7.4
+K04D7.3	F09F7.4
+K04F1.15	F09F7.4
+K05F1.3	F09F7.4
+K06A5.6	F09F7.4
+K09H11.1	F09F7.4
+LLC1.3	F09F7.4
+R09B5.6	F09F7.4
+T02G5.4	F09F7.4
+T02G5.7	F09F7.4
+T02G5.8	F09F7.4
+T05G5.6	F09F7.4
+T05H4.13	F09F7.4
+T08B2.7	F09F7.4
+T08G2.3	F09F7.4
+T25G12.5	F09F7.4
+Y39E4A.3	F09F7.4
+Y44A6D.5	F09F7.4
+Y69F12A.2	F09F7.4
+Y71G12B.10	F09F7.4
+ZK1058.1	F09F7.4
+ZK669.4	F09F7.4
+F25B4.6	F13D12.4
+F27D4.5	F13D12.4
+F27D9.5	F13D12.4
+F28A10.6	F13D12.4
+F32B6.2	F13D12.4
+F52E4.1	F13D12.4
+F53A2.7	F13D12.4
+F54C8.1	F13D12.4
+F54D8.3	F13D12.4
+K02A4.1	F13D12.4
+K04D7.3	F13D12.4
+K04F1.15	F13D12.4
+K05F1.3	F13D12.4
+K06A5.6	F13D12.4
+K09H11.1	F13D12.4
+LLC1.3	F13D12.4
+R09B5.6	F13D12.4
+T02G5.4	F13D12.4
+T02G5.7	F13D12.4
+T02G5.8	F13D12.4
+T05G5.6	F13D12.4
+T05H4.13	F13D12.4
+T08B2.7	F13D12.4
+T08G2.3	F13D12.4
+T25G12.5	F13D12.4
+Y39E4A.3	F13D12.4
+Y44A6D.5	F13D12.4
+Y69F12A.2	F13D12.4
+Y71G12B.10	F13D12.4
+ZK1058.1	F13D12.4
+ZK669.4	F13D12.4
+F27D4.5	F25B4.6
+F27D9.5	F25B4.6
+F28A10.6	F25B4.6
+F32B6.2	F25B4.6
+F52E4.1	F25B4.6
+F53A2.7	F25B4.6
+F54C8.1	F25B4.6
+F54D8.3	F25B4.6
+K02A4.1	F25B4.6
+K04D7.3	F25B4.6
+K04F1.15	F25B4.6
+K05F1.3	F25B4.6
+K06A5.6	F25B4.6
+K09H11.1	F25B4.6
+LLC1.3	F25B4.6
+R09B5.6	F25B4.6
+T05G5.6	F25B4.6
+T05H4.13	F25B4.6
+T08B2.7	F25B4.6
+T08G2.3	F25B4.6
+T25G12.5	F25B4.6
+Y39E4A.3	F25B4.6
+Y44A6D.5	F25B4.6
+Y69F12A.2	F25B4.6
+ZK1058.1	F25B4.6
+ZK669.4	F25B4.6
+F27D9.5	F27D4.5
+F28A10.6	F27D4.5
+F32B6.2	F27D4.5
+F52E4.1	F27D4.5
+F53A2.7	F27D4.5
+F54C8.1	F27D4.5
+F54D8.3	F27D4.5
+K02A4.1	F27D4.5
+K04D7.3	F27D4.5
+K04F1.15	F27D4.5
+K05F1.3	F27D4.5
+K06A5.6	F27D4.5
+K09H11.1	F27D4.5
+LLC1.3	F27D4.5
+R09B5.6	F27D4.5
+T02G5.4	F27D4.5
+T02G5.7	F27D4.5
+T02G5.8	F27D4.5
+T05G5.6	F27D4.5
+T05H4.13	F27D4.5
+T08B2.7	F27D4.5
+T08G2.3	F27D4.5
+T25G12.5	F27D4.5
+Y39E4A.3	F27D4.5
+Y44A6D.5	F27D4.5
+Y69F12A.2	F27D4.5
+Y71G12B.10	F27D4.5
+ZK1058.1	F27D4.5
+ZK669.4	F27D4.5
+F28A10.6	F27D9.5
+F32B6.2	F27D9.5
+F52E4.1	F27D9.5
+F53A2.7	F27D9.5
+F54C8.1	F27D9.5
+F54D8.3	F27D9.5
+K02A4.1	F27D9.5
+K04D7.3	F27D9.5
+K04F1.15	F27D9.5
+K05F1.3	F27D9.5
+K06A5.6	F27D9.5
+K09H11.1	F27D9.5
+LLC1.3	F27D9.5
+R09B5.6	F27D9.5
+T02G5.4	F27D9.5
+T02G5.7	F27D9.5
+T02G5.8	F27D9.5
+T05G5.6	F27D9.5
+T05H4.13	F27D9.5
+T08B2.7	F27D9.5
+T08G2.3	F27D9.5
+T25G12.5	F27D9.5
+Y39E4A.3	F27D9.5
+Y44A6D.5	F27D9.5
+Y69F12A.2	F27D9.5
+Y71G12B.10	F27D9.5
+ZK1058.1	F27D9.5
+ZK669.4	F27D9.5
+F32B6.2	F28A10.6
+F52E4.1	F28A10.6
+F53A2.7	F28A10.6
+F54C8.1	F28A10.6
+F54D8.3	F28A10.6
+K02A4.1	F28A10.6
+K04D7.3	F28A10.6
+K04F1.15	F28A10.6
+K05F1.3	F28A10.6
+K06A5.6	F28A10.6
+K09H11.1	F28A10.6
+LLC1.3	F28A10.6
+R09B5.6	F28A10.6
+T02G5.4	F28A10.6
+T02G5.7	F28A10.6
+T02G5.8	F28A10.6
+T05G5.6	F28A10.6
+T05H4.13	F28A10.6
+T08B2.7	F28A10.6
+T08G2.3	F28A10.6
+T25G12.5	F28A10.6
+Y39E4A.3	F28A10.6
+Y44A6D.5	F28A10.6
+Y69F12A.2	F28A10.6
+Y71G12B.10	F28A10.6
+ZK1058.1	F28A10.6
+ZK669.4	F28A10.6
+F52E4.1	F32B6.2
+F53A2.7	F32B6.2
+F54C8.1	F32B6.2
+F54D8.3	F32B6.2
+K02A4.1	F32B6.2
+K04D7.3	F32B6.2
+K04F1.15	F32B6.2
+K05F1.3	F32B6.2
+K06A5.6	F32B6.2
+K09H11.1	F32B6.2
+LLC1.3	F32B6.2
+R09B5.6	F32B6.2
+T02G5.4	F32B6.2
+T02G5.7	F32B6.2
+T02G5.8	F32B6.2
+T05G5.6	F32B6.2
+T05H4.13	F32B6.2
+T08B2.7	F32B6.2
+T08G2.3	F32B6.2
+T25G12.5	F32B6.2
+Y39E4A.3	F32B6.2
+Y44A6D.5	F32B6.2
+Y69F12A.2	F32B6.2
+Y71G12B.10	F32B6.2
+ZK1058.1	F32B6.2
+ZK669.4	F32B6.2
+F53A2.7	F52E4.1
+F54C8.1	F52E4.1
+F54D8.3	F52E4.1
+K02A4.1	F52E4.1
+K04D7.3	F52E4.1
+K04F1.15	F52E4.1
+K05F1.3	F52E4.1
+K06A5.6	F52E4.1
+K09H11.1	F52E4.1
+LLC1.3	F52E4.1
+R09B5.6	F52E4.1
+T02G5.4	F52E4.1
+T02G5.7	F52E4.1
+T02G5.8	F52E4.1
+T05G5.6	F52E4.1
+T05H4.13	F52E4.1
+T08B2.7	F52E4.1
+T08G2.3	F52E4.1
+T25G12.5	F52E4.1
+Y39E4A.3	F52E4.1
+Y44A6D.5	F52E4.1
+Y69F12A.2	F52E4.1
+Y71G12B.10	F52E4.1
+ZK1058.1	F52E4.1
+ZK669.4	F52E4.1
+K02A4.1	F53A2.7
+K04D7.3	F53A2.7
+LLC1.3	F53A2.7
+Y39E4A.3	F53A2.7
+Y44A6D.5	F53A2.7
+Y71G12B.10	F53A2.7
+ZK1058.1	F53A2.7
+ZK669.4	F53A2.7
+K02A4.1	F54C8.1
+K04D7.3	F54C8.1
+LLC1.3	F54C8.1
+Y39E4A.3	F54C8.1
+Y44A6D.5	F54C8.1
+Y71G12B.10	F54C8.1
+ZK1058.1	F54C8.1
+ZK669.4	F54C8.1
+K02A4.1	F54D8.3
+K04D7.3	F54D8.3
+Y39E4A.3	F54D8.3
+Y44A6D.5	F54D8.3
+Y71G12B.10	F54D8.3
+ZK1058.1	F54D8.3
+ZK669.4	F54D8.3
+K04D7.3	K02A4.1
+K04F1.15	K02A4.1
+K05F1.3	K02A4.1
+K06A5.6	K02A4.1
+K09H11.1	K02A4.1
+LLC1.3	K02A4.1
+R09B5.6	K02A4.1
+T02G5.4	K02A4.1
+T02G5.7	K02A4.1
+T02G5.8	K02A4.1
+T05G5.6	K02A4.1
+T05H4.13	K02A4.1
+T08B2.7	K02A4.1
+T08G2.3	K02A4.1
+T25G12.5	K02A4.1
+Y39E4A.3	K02A4.1
+Y44A6D.5	K02A4.1
+Y69F12A.2	K02A4.1
+Y71G12B.10	K02A4.1
+ZK1058.1	K02A4.1
+ZK669.4	K02A4.1
+K04F1.15	K04D7.3
+K05F1.3	K04D7.3
+K06A5.6	K04D7.3
+K09H11.1	K04D7.3
+LLC1.3	K04D7.3
+R09B5.6	K04D7.3
+T02G5.4	K04D7.3
+T02G5.7	K04D7.3
+T02G5.8	K04D7.3
+T05G5.6	K04D7.3
+T05H4.13	K04D7.3
+T08B2.7	K04D7.3
+T08G2.3	K04D7.3
+T25G12.5	K04D7.3
+Y39E4A.3	K04D7.3
+Y44A6D.5	K04D7.3
+Y69F12A.2	K04D7.3
+Y71G12B.10	K04D7.3
+ZK1058.1	K04D7.3
+ZK669.4	K04D7.3
+Y39E4A.3	K04F1.15
+Y44A6D.5	K04F1.15
+Y71G12B.10	K04F1.15
+ZK1058.1	K04F1.15
+ZK669.4	K04F1.15
+LLC1.3	K05F1.3
+Y39E4A.3	K05F1.3
+Y44A6D.5	K05F1.3
+Y71G12B.10	K05F1.3
+ZK1058.1	K05F1.3
+ZK669.4	K05F1.3
+LLC1.3	K06A5.6
+Y39E4A.3	K06A5.6
+Y44A6D.5	K06A5.6
+Y71G12B.10	K06A5.6
+ZK1058.1	K06A5.6
+ZK669.4	K06A5.6
+LLC1.3	K09H11.1
+Y39E4A.3	K09H11.1
+Y44A6D.5	K09H11.1
+Y71G12B.10	K09H11.1
+ZK1058.1	K09H11.1
+ZK669.4	K09H11.1
+R09B5.6	LLC1.3
+T02G5.4	LLC1.3
+T02G5.7	LLC1.3
+T02G5.8	LLC1.3
+T05G5.6	LLC1.3
+T08B2.7	LLC1.3
+T08G2.3	LLC1.3
+T25G12.5	LLC1.3
+Y39E4A.3	LLC1.3
+Y44A6D.5	LLC1.3
+Y71G12B.10	LLC1.3
+ZK1058.1	LLC1.3
+ZK669.4	LLC1.3
+Y39E4A.3	R09B5.6
+Y44A6D.5	R09B5.6
+Y71G12B.10	R09B5.6
+ZK1058.1	R09B5.6
+ZK669.4	R09B5.6
+Y39E4A.3	T02G5.4
+Y44A6D.5	T02G5.4
+ZK1058.1	T02G5.4
+ZK669.4	T02G5.4
+Y39E4A.3	T02G5.7
+Y44A6D.5	T02G5.7
+ZK1058.1	T02G5.7
+ZK669.4	T02G5.7
+Y39E4A.3	T02G5.8
+Y44A6D.5	T02G5.8
+ZK1058.1	T02G5.8
+ZK669.4	T02G5.8
+Y39E4A.3	T05G5.6
+Y44A6D.5	T05G5.6
+Y71G12B.10	T05G5.6
+ZK1058.1	T05G5.6
+ZK669.4	T05G5.6
+Y39E4A.3	T05H4.13
+Y44A6D.5	T05H4.13
+Y71G12B.10	T05H4.13
+ZK1058.1	T05H4.13
+ZK669.4	T05H4.13
+Y39E4A.3	T08B2.7
+Y44A6D.5	T08B2.7
+Y71G12B.10	T08B2.7
+ZK1058.1	T08B2.7
+ZK669.4	T08B2.7
+Y39E4A.3	T08G2.3
+Y44A6D.5	T08G2.3
+Y71G12B.10	T08G2.3
+ZK1058.1	T08G2.3
+ZK669.4	T08G2.3
+Y39E4A.3	T25G12.5
+Y44A6D.5	T25G12.5
+Y71G12B.10	T25G12.5
+ZK1058.1	T25G12.5
+ZK669.4	T25G12.5
+Y44A6D.5	Y39E4A.3
+Y69F12A.2	Y39E4A.3
+Y71G12B.10	Y39E4A.3
+ZK1058.1	Y39E4A.3
+ZK669.4	Y39E4A.3
+Y69F12A.2	Y44A6D.5
+Y71G12B.10	Y44A6D.5
+ZK1058.1	Y44A6D.5
+ZK669.4	Y44A6D.5
+Y71G12B.10	Y69F12A.2
+ZK1058.1	Y69F12A.2
+ZK669.4	Y69F12A.2
+ZK1058.1	Y71G12B.10
+ZK669.4	Y71G12B.10
+ZK669.4	ZK1058.1
+K01C8.1	C04C3.3
+K02A4.1	C04C3.3
+Y44A6D.5	C04C3.3
+Y51H7C.9	C04C3.3
+K02A4.1	K01C8.1
+T05H10.6	K01C8.1
+Y44A6D.5	K01C8.1
+T05H10.6	K02A4.1
+Y51H7C.9	K02A4.1
+Y44A6D.5	T05H10.6
+Y51H7C.9	T05H10.6
+Y51H7C.9	Y44A6D.5
+C26E6.9	B0272.3
+C32D5.5	B0272.3
+D2089.5	B0272.3
+F52H3.1	B0272.3
+F54F7.7	B0272.3
+F55G7.2	B0272.3
+M05D6.7	B0272.3
+R02D3.1	B0272.3
+R05D3.11	B0272.3
+T12D8.1	B0272.3
+T12F5.4	B0272.3
+T22B11.5	B0272.3
+T26A5.7	B0272.3
+W02F12.5	B0272.3
+W06D11.4	B0272.3
+Y39G10AR.18	B0272.3
+Y41D4B.12	B0272.3
+C29F3.1	C26E6.9
+C32D5.5	C26E6.9
+D2089.5	C26E6.9
+F01F1.6	C26E6.9
+F01G10.2	C26E6.9
+F01G10.3	C26E6.9
+F52H3.1	C26E6.9
+F54C8.1	C26E6.9
+F54D5.7	C26E6.9
+F54D8.3	C26E6.9
+F54F7.7	C26E6.9
+F55G7.2	C26E6.9
+K04F1.15	C26E6.9
+M05D6.7	C26E6.9
+R02D3.1	C26E6.9
+R05D3.11	C26E6.9
+R09B5.6	C26E6.9
+T02G5.4	C26E6.9
+T02G5.7	C26E6.9
+T02G5.8	C26E6.9
+T05G5.6	C26E6.9
+T05H4.13	C26E6.9
+T08B2.7	C26E6.9
+T12F5.4	C26E6.9
+T22B11.5	C26E6.9
+T26A5.7	C26E6.9
+W02F12.5	C26E6.9
+W06D11.4	C26E6.9
+Y39G10AR.18	C26E6.9
+Y41D4B.12	C26E6.9
+Y69F12A.2	C26E6.9
+C32D5.5	C29F3.1
+D2089.5	C29F3.1
+F52H3.1	C29F3.1
+F54F7.7	C29F3.1
+F55G7.2	C29F3.1
+M05D6.7	C29F3.1
+R02D3.1	C29F3.1
+R05D3.11	C29F3.1
+T12D8.1	C29F3.1
+T12F5.4	C29F3.1
+T22B11.5	C29F3.1
+T26A5.7	C29F3.1
+W02F12.5	C29F3.1
+W06D11.4	C29F3.1
+Y39G10AR.18	C29F3.1
+Y41D4B.12	C29F3.1
+D2089.5	C32D5.5
+F01F1.6	C32D5.5
+F01G10.2	C32D5.5
+F01G10.3	C32D5.5
+F52H3.1	C32D5.5
+F54C8.1	C32D5.5
+F54D5.7	C32D5.5
+F54D8.3	C32D5.5
+F54F7.7	C32D5.5
+F55G7.2	C32D5.5
+K04F1.15	C32D5.5
+M05D6.7	C32D5.5
+R02D3.1	C32D5.5
+R05D3.11	C32D5.5
+R09B5.6	C32D5.5
+T02G5.4	C32D5.5
+T02G5.7	C32D5.5
+T02G5.8	C32D5.5
+T05G5.6	C32D5.5
+T05H4.13	C32D5.5
+T08B2.7	C32D5.5
+T12D8.1	C32D5.5
+T12F5.4	C32D5.5
+T22B11.5	C32D5.5
+T26A5.7	C32D5.5
+W02F12.5	C32D5.5
+W06D11.4	C32D5.5
+Y39G10AR.18	C32D5.5
+Y41D4B.12	C32D5.5
+Y69F12A.2	C32D5.5
+F01F1.6	D2089.5
+F01G10.2	D2089.5
+F01G10.3	D2089.5
+F52H3.1	D2089.5
+F54C8.1	D2089.5
+F54D5.7	D2089.5
+F54D8.3	D2089.5
+F54F7.7	D2089.5
+F55G7.2	D2089.5
+K04F1.15	D2089.5
+M05D6.7	D2089.5
+R02D3.1	D2089.5
+R05D3.11	D2089.5
+R09B5.6	D2089.5
+T02G5.4	D2089.5
+T02G5.7	D2089.5
+T02G5.8	D2089.5
+T05G5.6	D2089.5
+T05H4.13	D2089.5
+T08B2.7	D2089.5
+T12D8.1	D2089.5
+T12F5.4	D2089.5
+T22B11.5	D2089.5
+T26A5.7	D2089.5
+W02F12.5	D2089.5
+W06D11.4	D2089.5
+Y39G10AR.18	D2089.5
+Y41D4B.12	D2089.5
+Y69F12A.2	D2089.5
+F52H3.1	F01F1.6
+F54F7.7	F01F1.6
+F55G7.2	F01F1.6
+M05D6.7	F01F1.6
+R02D3.1	F01F1.6
+R05D3.11	F01F1.6
+T12D8.1	F01F1.6
+T12F5.4	F01F1.6
+T22B11.5	F01F1.6
+T26A5.7	F01F1.6
+W02F12.5	F01F1.6
+W06D11.4	F01F1.6
+Y39G10AR.18	F01F1.6
+Y41D4B.12	F01F1.6
+F52H3.1	F01G10.2
+F54F7.7	F01G10.2
+F55G7.2	F01G10.2
+M05D6.7	F01G10.2
+R02D3.1	F01G10.2
+R05D3.11	F01G10.2
+T12D8.1	F01G10.2
+T12F5.4	F01G10.2
+T22B11.5	F01G10.2
+T26A5.7	F01G10.2
+W02F12.5	F01G10.2
+W06D11.4	F01G10.2
+Y39G10AR.18	F01G10.2
+Y41D4B.12	F01G10.2
+F52H3.1	F01G10.3
+F54F7.7	F01G10.3
+F55G7.2	F01G10.3
+M05D6.7	F01G10.3
+R02D3.1	F01G10.3
+R05D3.11	F01G10.3
+T12D8.1	F01G10.3
+T12F5.4	F01G10.3
+T22B11.5	F01G10.3
+T26A5.7	F01G10.3
+W02F12.5	F01G10.3
+W06D11.4	F01G10.3
+Y39G10AR.18	F01G10.3
+Y41D4B.12	F01G10.3
+F54C8.1	F52H3.1
+F54D5.7	F52H3.1
+F54D8.3	F52H3.1
+F54F7.7	F52H3.1
+F55G7.2	F52H3.1
+K04F1.15	F52H3.1
+M05D6.7	F52H3.1
+R02D3.1	F52H3.1
+R05D3.11	F52H3.1
+R09B5.6	F52H3.1
+T02G5.4	F52H3.1
+T02G5.7	F52H3.1
+T02G5.8	F52H3.1
+T05G5.6	F52H3.1
+T05H4.13	F52H3.1
+T08B2.7	F52H3.1
+T12D8.1	F52H3.1
+T12F5.4	F52H3.1
+T22B11.5	F52H3.1
+T26A5.7	F52H3.1
+W02F12.5	F52H3.1
+W06D11.4	F52H3.1
+Y39G10AR.18	F52H3.1
+Y41D4B.12	F52H3.1
+Y69F12A.2	F52H3.1
+F54F7.7	F54C8.1
+F55G7.2	F54C8.1
+M05D6.7	F54C8.1
+R02D3.1	F54C8.1
+R05D3.11	F54C8.1
+T12D8.1	F54C8.1
+T12F5.4	F54C8.1
+T22B11.5	F54C8.1
+T26A5.7	F54C8.1
+W02F12.5	F54C8.1
+W06D11.4	F54C8.1
+Y39G10AR.18	F54C8.1
+Y41D4B.12	F54C8.1
+F54F7.7	F54D5.7
+F55G7.2	F54D5.7
+M05D6.7	F54D5.7
+R02D3.1	F54D5.7
+R05D3.11	F54D5.7
+T12D8.1	F54D5.7
+T12F5.4	F54D5.7
+T22B11.5	F54D5.7
+T26A5.7	F54D5.7
+W02F12.5	F54D5.7
+W06D11.4	F54D5.7
+Y39G10AR.18	F54D5.7
+Y41D4B.12	F54D5.7
+F54F7.7	F54D8.3
+F55G7.2	F54D8.3
+M05D6.7	F54D8.3
+R02D3.1	F54D8.3
+R05D3.11	F54D8.3
+T12D8.1	F54D8.3
+T12F5.4	F54D8.3
+T22B11.5	F54D8.3
+T26A5.7	F54D8.3
+W02F12.5	F54D8.3
+W06D11.4	F54D8.3
+Y39G10AR.18	F54D8.3
+Y41D4B.12	F54D8.3
+F55G7.2	F54F7.7
+K04F1.15	F54F7.7
+M05D6.7	F54F7.7
+R02D3.1	F54F7.7
+R05D3.11	F54F7.7
+R09B5.6	F54F7.7
+T02G5.4	F54F7.7
+T02G5.7	F54F7.7
+T02G5.8	F54F7.7
+T05G5.6	F54F7.7
+T05H4.13	F54F7.7
+T08B2.7	F54F7.7
+T12D8.1	F54F7.7
+T12F5.4	F54F7.7
+T22B11.5	F54F7.7
+T26A5.7	F54F7.7
+W02F12.5	F54F7.7
+W06D11.4	F54F7.7
+Y39G10AR.18	F54F7.7
+Y41D4B.12	F54F7.7
+Y69F12A.2	F54F7.7
+K04F1.15	F55G7.2
+M05D6.7	F55G7.2
+R02D3.1	F55G7.2
+R05D3.11	F55G7.2
+R09B5.6	F55G7.2
+T02G5.4	F55G7.2
+T02G5.7	F55G7.2
+T02G5.8	F55G7.2
+T05G5.6	F55G7.2
+T05H4.13	F55G7.2
+T08B2.7	F55G7.2
+T12D8.1	F55G7.2
+T12F5.4	F55G7.2
+T22B11.5	F55G7.2
+T26A5.7	F55G7.2
+W02F12.5	F55G7.2
+W06D11.4	F55G7.2
+Y39G10AR.18	F55G7.2
+Y41D4B.12	F55G7.2
+Y69F12A.2	F55G7.2
+M05D6.7	K04F1.15
+R02D3.1	K04F1.15
+R05D3.11	K04F1.15
+T12D8.1	K04F1.15
+T12F5.4	K04F1.15
+T22B11.5	K04F1.15
+T26A5.7	K04F1.15
+W02F12.5	K04F1.15
+W06D11.4	K04F1.15
+Y39G10AR.18	K04F1.15
+Y41D4B.12	K04F1.15
+R02D3.1	M05D6.7
+R05D3.11	M05D6.7
+R09B5.6	M05D6.7
+T02G5.4	M05D6.7
+T02G5.7	M05D6.7
+T02G5.8	M05D6.7
+T05G5.6	M05D6.7
+T05H4.13	M05D6.7
+T08B2.7	M05D6.7
+T12D8.1	M05D6.7
+T12F5.4	M05D6.7
+T22B11.5	M05D6.7
+T26A5.7	M05D6.7
+W02F12.5	M05D6.7
+W06D11.4	M05D6.7
+Y39G10AR.18	M05D6.7
+Y41D4B.12	M05D6.7
+Y69F12A.2	M05D6.7
+R05D3.11	R02D3.1
+R09B5.6	R02D3.1
+T02G5.4	R02D3.1
+T02G5.7	R02D3.1
+T02G5.8	R02D3.1
+T05G5.6	R02D3.1
+T05H4.13	R02D3.1
+T08B2.7	R02D3.1
+T12D8.1	R02D3.1
+T12F5.4	R02D3.1
+T22B11.5	R02D3.1
+T26A5.7	R02D3.1
+W02F12.5	R02D3.1
+W06D11.4	R02D3.1
+Y39G10AR.18	R02D3.1
+Y41D4B.12	R02D3.1
+Y69F12A.2	R02D3.1
+R09B5.6	R05D3.11
+T02G5.4	R05D3.11
+T02G5.7	R05D3.11
+T02G5.8	R05D3.11
+T05G5.6	R05D3.11
+T05H4.13	R05D3.11
+T08B2.7	R05D3.11
+T12D8.1	R05D3.11
+T12F5.4	R05D3.11
+T22B11.5	R05D3.11
+T26A5.7	R05D3.11
+W02F12.5	R05D3.11
+W06D11.4	R05D3.11
+Y39G10AR.18	R05D3.11
+Y41D4B.12	R05D3.11
+Y69F12A.2	R05D3.11
+T12D8.1	R09B5.6
+T12F5.4	R09B5.6
+T22B11.5	R09B5.6
+T26A5.7	R09B5.6
+W02F12.5	R09B5.6
+W06D11.4	R09B5.6
+Y39G10AR.18	R09B5.6
+Y41D4B.12	R09B5.6
+T12D8.1	T02G5.4
+T12F5.4	T02G5.4
+T22B11.5	T02G5.4
+T26A5.7	T02G5.4
+W02F12.5	T02G5.4
+W06D11.4	T02G5.4
+Y39G10AR.18	T02G5.4
+Y41D4B.12	T02G5.4
+T12D8.1	T02G5.7
+T12F5.4	T02G5.7
+T22B11.5	T02G5.7
+T26A5.7	T02G5.7
+W02F12.5	T02G5.7
+W06D11.4	T02G5.7
+Y39G10AR.18	T02G5.7
+Y41D4B.12	T02G5.7
+T12D8.1	T02G5.8
+T12F5.4	T02G5.8
+T22B11.5	T02G5.8
+T26A5.7	T02G5.8
+W02F12.5	T02G5.8
+W06D11.4	T02G5.8
+Y39G10AR.18	T02G5.8
+Y41D4B.12	T02G5.8
+T12D8.1	T05G5.6
+T12F5.4	T05G5.6
+T22B11.5	T05G5.6
+T26A5.7	T05G5.6
+W02F12.5	T05G5.6
+W06D11.4	T05G5.6
+Y39G10AR.18	T05G5.6
+Y41D4B.12	T05G5.6
+T12D8.1	T05H4.13
+T12F5.4	T05H4.13
+T22B11.5	T05H4.13
+T26A5.7	T05H4.13
+W02F12.5	T05H4.13
+W06D11.4	T05H4.13
+Y39G10AR.18	T05H4.13
+Y41D4B.12	T05H4.13
+T12D8.1	T08B2.7
+T12F5.4	T08B2.7
+T22B11.5	T08B2.7
+T26A5.7	T08B2.7
+W02F12.5	T08B2.7
+W06D11.4	T08B2.7
+Y39G10AR.18	T08B2.7
+Y41D4B.12	T08B2.7
+T12F5.4	T12D8.1
+T22B11.5	T12D8.1
+T26A5.7	T12D8.1
+W02F12.5	T12D8.1
+W06D11.4	T12D8.1
+Y39G10AR.18	T12D8.1
+Y41D4B.12	T12D8.1
+Y69F12A.2	T12D8.1
+T22B11.5	T12F5.4
+T26A5.7	T12F5.4
+W02F12.5	T12F5.4
+W06D11.4	T12F5.4
+Y39G10AR.18	T12F5.4
+Y41D4B.12	T12F5.4
+Y69F12A.2	T12F5.4
+T26A5.7	T22B11.5
+W06D11.4	T22B11.5
+Y39G10AR.18	T22B11.5
+Y41D4B.12	T22B11.5
+Y69F12A.2	T22B11.5
+W02F12.5	T26A5.7
+W06D11.4	T26A5.7
+Y39G10AR.18	T26A5.7
+Y41D4B.12	T26A5.7
+Y69F12A.2	T26A5.7
+W06D11.4	W02F12.5
+Y39G10AR.18	W02F12.5
+Y41D4B.12	W02F12.5
+Y69F12A.2	W02F12.5
+Y39G10AR.18	W06D11.4
+Y41D4B.12	W06D11.4
+Y69F12A.2	W06D11.4
+Y41D4B.12	Y39G10AR.18
+Y69F12A.2	Y39G10AR.18
+Y69F12A.2	Y41D4B.12
+C09F9.3	B0513.5
+C10C5.5	B0513.5
+C14E2.2	B0513.5
+C14F11.1	B0513.5
+C16A3.10	B0513.5
+C28D4.3	B0513.5
+C44E4.3	B0513.5
+C45B2.5	B0513.5
+DH11.1	B0513.5
+F01F1.6	B0513.5
+F26D10.10	B0513.5
+F30F8.2	B0513.5
+F35G2.4	B0513.5
+F44G3.2	B0513.5
+F46H5.3	B0513.5
+F47G4.7	B0513.5
+F54D8.3	B0513.5
+F55G1.9	B0513.5
+F56D12.1	B0513.5
+K03H1.1	B0513.5
+K04F1.15	B0513.5
+K11C4.4	B0513.5
+M153.1	B0513.5
+T01C8.5	B0513.5
+T05H4.13	B0513.5
+T22H6.2	B0513.5
+W10C8.5	B0513.5
+Y105C5B.28	B0513.5
+Y46G5A.19	B0513.5
+Y47D3B.10	B0513.5
+Y69A2AR.5	B0513.5
+Y69F12A.2	B0513.5
+ZC434.8	B0513.5
+ZK829.4	B0513.5
+C10C5.5	C09F9.3
+C16A3.10	C09F9.3
+F01F1.6	C09F9.3
+F35G2.4	C09F9.3
+F44G3.2	C09F9.3
+F46H5.3	C09F9.3
+F47G4.7	C09F9.3
+F54D8.3	C09F9.3
+F55G1.9	C09F9.3
+K04F1.15	C09F9.3
+K11C4.4	C09F9.3
+M153.1	C09F9.3
+T05H4.13	C09F9.3
+T22H6.2	C09F9.3
+W10C8.5	C09F9.3
+Y46G5A.19	C09F9.3
+Y47D3B.10	C09F9.3
+Y69A2AR.5	C09F9.3
+Y69F12A.2	C09F9.3
+ZC434.8	C09F9.3
+C14E2.2	C10C5.5
+C14F11.1	C10C5.5
+C16A3.10	C10C5.5
+C28D4.3	C10C5.5
+C44E4.3	C10C5.5
+C45B2.5	C10C5.5
+DH11.1	C10C5.5
+F01F1.6	C10C5.5
+F26D10.10	C10C5.5
+F30F8.2	C10C5.5
+F35G2.4	C10C5.5
+F44G3.2	C10C5.5
+F46H5.3	C10C5.5
+F47G4.7	C10C5.5
+F54D8.3	C10C5.5
+F55G1.9	C10C5.5
+F56D12.1	C10C5.5
+K03H1.1	C10C5.5
+K04F1.15	C10C5.5
+K11C4.4	C10C5.5
+M153.1	C10C5.5
+T01C8.5	C10C5.5
+T05H4.13	C10C5.5
+T22H6.2	C10C5.5
+W10C8.5	C10C5.5
+Y105C5B.28	C10C5.5
+Y46G5A.19	C10C5.5
+Y47D3B.10	C10C5.5
+Y69A2AR.5	C10C5.5
+Y69F12A.2	C10C5.5
+ZC434.8	C10C5.5
+ZK829.4	C10C5.5
+C16A3.10	C14E2.2
+F01F1.6	C14E2.2
+F35G2.4	C14E2.2
+F44G3.2	C14E2.2
+F46H5.3	C14E2.2
+F54D8.3	C14E2.2
+F55G1.9	C14E2.2
+K04F1.15	C14E2.2
+K11C4.4	C14E2.2
+M153.1	C14E2.2
+T05H4.13	C14E2.2
+T22H6.2	C14E2.2
+W10C8.5	C14E2.2
+Y47D3B.10	C14E2.2
+Y69A2AR.5	C14E2.2
+Y69F12A.2	C14E2.2
+ZC434.8	C14E2.2
+C16A3.10	C14F11.1
+F01F1.6	C14F11.1
+F35G2.4	C14F11.1
+F44G3.2	C14F11.1
+F46H5.3	C14F11.1
+F54D8.3	C14F11.1
+F55G1.9	C14F11.1
+K04F1.15	C14F11.1
+K11C4.4	C14F11.1
+M153.1	C14F11.1
+T05H4.13	C14F11.1
+T22H6.2	C14F11.1
+W10C8.5	C14F11.1
+Y47D3B.10	C14F11.1
+Y69A2AR.5	C14F11.1
+Y69F12A.2	C14F11.1
+ZC434.8	C14F11.1
+C28D4.3	C16A3.10
+C44E4.3	C16A3.10
+C45B2.5	C16A3.10
+DH11.1	C16A3.10
+F01F1.6	C16A3.10
+F26D10.10	C16A3.10
+F30F8.2	C16A3.10
+F35G2.4	C16A3.10
+F44G3.2	C16A3.10
+F46H5.3	C16A3.10
+F47G4.7	C16A3.10
+F54D8.3	C16A3.10
+F55G1.9	C16A3.10
+F56D12.1	C16A3.10
+K03H1.1	C16A3.10
+K04F1.15	C16A3.10
+K11C4.4	C16A3.10
+M153.1	C16A3.10
+T01C8.5	C16A3.10
+T05H4.13	C16A3.10
+T22H6.2	C16A3.10
+W10C8.5	C16A3.10
+Y105C5B.28	C16A3.10
+Y46G5A.19	C16A3.10
+Y47D3B.10	C16A3.10
+Y69A2AR.5	C16A3.10
+Y69F12A.2	C16A3.10
+ZC434.8	C16A3.10
+ZK829.4	C16A3.10
+F01F1.6	C28D4.3
+F35G2.4	C28D4.3
+F44G3.2	C28D4.3
+F46H5.3	C28D4.3
+F47G4.7	C28D4.3
+F54D8.3	C28D4.3
+F55G1.9	C28D4.3
+K04F1.15	C28D4.3
+K11C4.4	C28D4.3
+M153.1	C28D4.3
+T05H4.13	C28D4.3
+T22H6.2	C28D4.3
+W10C8.5	C28D4.3
+Y46G5A.19	C28D4.3
+Y47D3B.10	C28D4.3
+Y69A2AR.5	C28D4.3
+Y69F12A.2	C28D4.3
+ZC434.8	C28D4.3
+F01F1.6	C44E4.3
+F35G2.4	C44E4.3
+F44G3.2	C44E4.3
+F46H5.3	C44E4.3
+F54D8.3	C44E4.3
+F55G1.9	C44E4.3
+K04F1.15	C44E4.3
+K11C4.4	C44E4.3
+M153.1	C44E4.3
+T05H4.13	C44E4.3
+T22H6.2	C44E4.3
+W10C8.5	C44E4.3
+Y47D3B.10	C44E4.3
+Y69A2AR.5	C44E4.3
+Y69F12A.2	C44E4.3
+ZC434.8	C44E4.3
+F01F1.6	C45B2.5
+F35G2.4	C45B2.5
+F44G3.2	C45B2.5
+F46H5.3	C45B2.5
+F47G4.7	C45B2.5
+F54D8.3	C45B2.5
+F55G1.9	C45B2.5
+K04F1.15	C45B2.5
+K11C4.4	C45B2.5
+M153.1	C45B2.5
+T05H4.13	C45B2.5
+T22H6.2	C45B2.5
+W10C8.5	C45B2.5
+Y46G5A.19	C45B2.5
+Y47D3B.10	C45B2.5
+Y69A2AR.5	C45B2.5
+Y69F12A.2	C45B2.5
+ZC434.8	C45B2.5
+F01F1.6	DH11.1
+F35G2.4	DH11.1
+F44G3.2	DH11.1
+F46H5.3	DH11.1
+F47G4.7	DH11.1
+F54D8.3	DH11.1
+F55G1.9	DH11.1
+K04F1.15	DH11.1
+K11C4.4	DH11.1
+M153.1	DH11.1
+T05H4.13	DH11.1
+T22H6.2	DH11.1
+W10C8.5	DH11.1
+Y46G5A.19	DH11.1
+Y47D3B.10	DH11.1
+Y69A2AR.5	DH11.1
+Y69F12A.2	DH11.1
+ZC434.8	DH11.1
+F26D10.10	F01F1.6
+F30F8.2	F01F1.6
+F35G2.4	F01F1.6
+F44G3.2	F01F1.6
+F46H5.3	F01F1.6
+F47G4.7	F01F1.6
+F55G1.9	F01F1.6
+F56D12.1	F01F1.6
+K03H1.1	F01F1.6
+K11C4.4	F01F1.6
+M153.1	F01F1.6
+T01C8.5	F01F1.6
+T22H6.2	F01F1.6
+W10C8.5	F01F1.6
+Y105C5B.28	F01F1.6
+Y46G5A.19	F01F1.6
+Y47D3B.10	F01F1.6
+ZC434.8	F01F1.6
+ZK829.4	F01F1.6
+F35G2.4	F26D10.10
+F44G3.2	F26D10.10
+F46H5.3	F26D10.10
+F47G4.7	F26D10.10
+F54D8.3	F26D10.10
+F55G1.9	F26D10.10
+K04F1.15	F26D10.10
+K11C4.4	F26D10.10
+M153.1	F26D10.10
+T05H4.13	F26D10.10
+T22H6.2	F26D10.10
+W10C8.5	F26D10.10
+Y46G5A.19	F26D10.10
+Y47D3B.10	F26D10.10
+Y69A2AR.5	F26D10.10
+Y69F12A.2	F26D10.10
+ZC434.8	F26D10.10
+F35G2.4	F30F8.2
+F44G3.2	F30F8.2
+F46H5.3	F30F8.2
+F47G4.7	F30F8.2
+F54D8.3	F30F8.2
+F55G1.9	F30F8.2
+K04F1.15	F30F8.2
+K11C4.4	F30F8.2
+M153.1	F30F8.2
+T05H4.13	F30F8.2
+T22H6.2	F30F8.2
+W10C8.5	F30F8.2
+Y46G5A.19	F30F8.2
+Y47D3B.10	F30F8.2
+Y69A2AR.5	F30F8.2
+Y69F12A.2	F30F8.2
+ZC434.8	F30F8.2
+F44G3.2	F35G2.4
+F46H5.3	F35G2.4
+F47G4.7	F35G2.4
+F54D8.3	F35G2.4
+F55G1.9	F35G2.4
+F56D12.1	F35G2.4
+K03H1.1	F35G2.4
+K04F1.15	F35G2.4
+K11C4.4	F35G2.4
+M153.1	F35G2.4
+T01C8.5	F35G2.4
+T05H4.13	F35G2.4
+T22H6.2	F35G2.4
+W10C8.5	F35G2.4
+Y105C5B.28	F35G2.4
+Y46G5A.19	F35G2.4
+Y47D3B.10	F35G2.4
+Y69A2AR.5	F35G2.4
+Y69F12A.2	F35G2.4
+ZC434.8	F35G2.4
+ZK829.4	F35G2.4
+F46H5.3	F44G3.2
+F47G4.7	F44G3.2
+F54D8.3	F44G3.2
+F55G1.9	F44G3.2
+F56D12.1	F44G3.2
+K03H1.1	F44G3.2
+K04F1.15	F44G3.2
+K11C4.4	F44G3.2
+M153.1	F44G3.2
+T01C8.5	F44G3.2
+T05H4.13	F44G3.2
+T22H6.2	F44G3.2
+W10C8.5	F44G3.2
+Y105C5B.28	F44G3.2
+Y46G5A.19	F44G3.2
+Y47D3B.10	F44G3.2
+Y69A2AR.5	F44G3.2
+Y69F12A.2	F44G3.2
+ZC434.8	F44G3.2
+ZK829.4	F44G3.2
+F47G4.7	F46H5.3
+F54D8.3	F46H5.3
+F55G1.9	F46H5.3
+F56D12.1	F46H5.3
+K03H1.1	F46H5.3
+K04F1.15	F46H5.3
+K11C4.4	F46H5.3
+M153.1	F46H5.3
+T01C8.5	F46H5.3
+T05H4.13	F46H5.3
+T22H6.2	F46H5.3
+W10C8.5	F46H5.3
+Y105C5B.28	F46H5.3
+Y46G5A.19	F46H5.3
+Y47D3B.10	F46H5.3
+Y69A2AR.5	F46H5.3
+Y69F12A.2	F46H5.3
+ZC434.8	F46H5.3
+ZK829.4	F46H5.3
+F54D8.3	F47G4.7
+F55G1.9	F47G4.7
+F56D12.1	F47G4.7
+K03H1.1	F47G4.7
+K04F1.15	F47G4.7
+K11C4.4	F47G4.7
+M153.1	F47G4.7
+T05H4.13	F47G4.7
+T22H6.2	F47G4.7
+W10C8.5	F47G4.7
+Y105C5B.28	F47G4.7
+Y47D3B.10	F47G4.7
+Y69A2AR.5	F47G4.7
+Y69F12A.2	F47G4.7
+ZC434.8	F47G4.7
+ZK829.4	F47G4.7
+F55G1.9	F54D8.3
+F56D12.1	F54D8.3
+K03H1.1	F54D8.3
+K11C4.4	F54D8.3
+M153.1	F54D8.3
+T01C8.5	F54D8.3
+T22H6.2	F54D8.3
+W10C8.5	F54D8.3
+Y105C5B.28	F54D8.3
+Y46G5A.19	F54D8.3
+Y47D3B.10	F54D8.3
+Y69A2AR.5	F54D8.3
+ZC434.8	F54D8.3
+ZK829.4	F54D8.3
+F56D12.1	F55G1.9
+K03H1.1	F55G1.9
+K04F1.15	F55G1.9
+K11C4.4	F55G1.9
+M153.1	F55G1.9
+T01C8.5	F55G1.9
+T05H4.13	F55G1.9
+T22H6.2	F55G1.9
+W10C8.5	F55G1.9
+Y105C5B.28	F55G1.9
+Y46G5A.19	F55G1.9
+Y47D3B.10	F55G1.9
+Y69A2AR.5	F55G1.9
+Y69F12A.2	F55G1.9
+ZC434.8	F55G1.9
+ZK829.4	F55G1.9
+K04F1.15	F56D12.1
+K11C4.4	F56D12.1
+M153.1	F56D12.1
+T05H4.13	F56D12.1
+T22H6.2	F56D12.1
+W10C8.5	F56D12.1
+Y46G5A.19	F56D12.1
+Y47D3B.10	F56D12.1
+Y69A2AR.5	F56D12.1
+Y69F12A.2	F56D12.1
+ZC434.8	F56D12.1
+K04F1.15	K03H1.1
+K11C4.4	K03H1.1
+M153.1	K03H1.1
+T05H4.13	K03H1.1
+T22H6.2	K03H1.1
+W10C8.5	K03H1.1
+Y46G5A.19	K03H1.1
+Y47D3B.10	K03H1.1
+Y69A2AR.5	K03H1.1
+Y69F12A.2	K03H1.1
+ZC434.8	K03H1.1
+K11C4.4	K04F1.15
+M153.1	K04F1.15
+T01C8.5	K04F1.15
+T22H6.2	K04F1.15
+W10C8.5	K04F1.15
+Y105C5B.28	K04F1.15
+Y46G5A.19	K04F1.15
+Y47D3B.10	K04F1.15
+Y69A2AR.5	K04F1.15
+ZC434.8	K04F1.15
+ZK829.4	K04F1.15
+M153.1	K11C4.4
+T01C8.5	K11C4.4
+T05H4.13	K11C4.4
+T22H6.2	K11C4.4
+W10C8.5	K11C4.4
+Y105C5B.28	K11C4.4
+Y46G5A.19	K11C4.4
+Y47D3B.10	K11C4.4
+Y69A2AR.5	K11C4.4
+Y69F12A.2	K11C4.4
+ZC434.8	K11C4.4
+ZK829.4	K11C4.4
+T01C8.5	M153.1
+T05H4.13	M153.1
+T22H6.2	M153.1
+W10C8.5	M153.1
+Y105C5B.28	M153.1
+Y46G5A.19	M153.1
+Y47D3B.10	M153.1
+Y69A2AR.5	M153.1
+Y69F12A.2	M153.1
+ZC434.8	M153.1
+ZK829.4	M153.1
+T05H4.13	T01C8.5
+T22H6.2	T01C8.5
+W10C8.5	T01C8.5
+Y47D3B.10	T01C8.5
+Y69A2AR.5	T01C8.5
+Y69F12A.2	T01C8.5
+ZC434.8	T01C8.5
+T22H6.2	T05H4.13
+W10C8.5	T05H4.13
+Y105C5B.28	T05H4.13
+Y46G5A.19	T05H4.13
+Y47D3B.10	T05H4.13
+Y69A2AR.5	T05H4.13
+ZC434.8	T05H4.13
+ZK829.4	T05H4.13
+W10C8.5	T22H6.2
+Y105C5B.28	T22H6.2
+Y46G5A.19	T22H6.2
+Y47D3B.10	T22H6.2
+Y69A2AR.5	T22H6.2
+Y69F12A.2	T22H6.2
+ZC434.8	T22H6.2
+ZK829.4	T22H6.2
+Y105C5B.28	W10C8.5
+Y46G5A.19	W10C8.5
+Y47D3B.10	W10C8.5
+Y69A2AR.5	W10C8.5
+Y69F12A.2	W10C8.5
+ZC434.8	W10C8.5
+ZK829.4	W10C8.5
+Y46G5A.19	Y105C5B.28
+Y47D3B.10	Y105C5B.28
+Y69A2AR.5	Y105C5B.28
+Y69F12A.2	Y105C5B.28
+ZC434.8	Y105C5B.28
+Y47D3B.10	Y46G5A.19
+Y69A2AR.5	Y46G5A.19
+Y69F12A.2	Y46G5A.19
+ZC434.8	Y46G5A.19
+ZK829.4	Y46G5A.19
+Y69A2AR.5	Y47D3B.10
+Y69F12A.2	Y47D3B.10
+ZC434.8	Y47D3B.10
+ZK829.4	Y47D3B.10
+Y69F12A.2	Y69A2AR.5
+ZC434.8	Y69A2AR.5
+ZK829.4	Y69A2AR.5
+ZC434.8	Y69F12A.2
+ZK829.4	Y69F12A.2
+ZK829.4	ZC434.8
+F01F1.6	C05D2.3
+F47B10.2	C05D2.3
+F54D8.3	C05D2.3
+K01C8.3	C05D2.3
+K04F1.15	C05D2.3
+T05H4.13	C05D2.3
+T08B1.3	C05D2.3
+Y51H4A.7	C05D2.3
+Y69F12A.2	C05D2.3
+ZK1058.5	C05D2.3
+ZK829.2	C05D2.3
+F47B10.2	F01F1.6
+K01C8.3	F01F1.6
+Y51H4A.7	F01F1.6
+ZK1058.5	F01F1.6
+ZK829.2	F01F1.6
+F54D8.3	F47B10.2
+K01C8.3	F47B10.2
+K04F1.15	F47B10.2
+T05H4.13	F47B10.2
+T08B1.3	F47B10.2
+Y51H4A.7	F47B10.2
+Y69F12A.2	F47B10.2
+ZK1058.5	F47B10.2
+ZK829.2	F47B10.2
+K01C8.3	F54D8.3
+Y51H4A.7	F54D8.3
+ZK1058.5	F54D8.3
+ZK829.2	F54D8.3
+K04F1.15	K01C8.3
+T05H4.13	K01C8.3
+T08B1.3	K01C8.3
+Y51H4A.7	K01C8.3
+Y69F12A.2	K01C8.3
+ZK1058.5	K01C8.3
+ZK829.2	K01C8.3
+Y51H4A.7	K04F1.15
+ZK1058.5	K04F1.15
+ZK829.2	K04F1.15
+Y51H4A.7	T05H4.13
+ZK1058.5	T05H4.13
+ZK829.2	T05H4.13
+Y51H4A.7	T08B1.3
+ZK1058.5	T08B1.3
+ZK829.2	T08B1.3
+Y69F12A.2	Y51H4A.7
+ZK1058.5	Y51H4A.7
+ZK829.2	Y51H4A.7
+ZK1058.5	Y69F12A.2
+ZK829.2	Y69F12A.2
+ZK829.2	ZK1058.5
+C14E2.2	C05D2.3
+C14F11.1	C05D2.3
+C34G6.2	C05D2.3
+C44E4.3	C05D2.3
+D1053.1	C05D2.3
+D2063.1	C05D2.3
+F42D1.2	C05D2.3
+H13N06.6	C05D2.3
+H24K24.3	C05D2.3
+K10C2.4	C05D2.3
+K12G11.3	C05D2.3
+K12G11.4	C05D2.3
+T01C8.5	C05D2.3
+T21C12.2	C05D2.3
+W06D4.1	C05D2.3
+Y53G8B.1	C05D2.3
+Y56A3A.3	C05D2.3
+C34G6.2	C14E2.2
+D1053.1	C14E2.2
+D2063.1	C14E2.2
+H13N06.6	C14E2.2
+H24K24.3	C14E2.2
+K01C8.3	C14E2.2
+K10C2.4	C14E2.2
+K12G11.3	C14E2.2
+K12G11.4	C14E2.2
+T08B1.3	C14E2.2
+T21C12.2	C14E2.2
+W06D4.1	C14E2.2
+Y53G8B.1	C14E2.2
+Y56A3A.3	C14E2.2
+ZK1058.5	C14E2.2
+ZK829.2	C14E2.2
+C34G6.2	C14F11.1
+D1053.1	C14F11.1
+D2063.1	C14F11.1
+H13N06.6	C14F11.1
+H24K24.3	C14F11.1
+K01C8.3	C14F11.1
+K10C2.4	C14F11.1
+K12G11.3	C14F11.1
+K12G11.4	C14F11.1
+T08B1.3	C14F11.1
+T21C12.2	C14F11.1
+W06D4.1	C14F11.1
+Y53G8B.1	C14F11.1
+Y56A3A.3	C14F11.1
+ZK1058.5	C14F11.1
+ZK829.2	C14F11.1
+C44E4.3	C34G6.2
+D1053.1	C34G6.2
+D2063.1	C34G6.2
+F42D1.2	C34G6.2
+H13N06.6	C34G6.2
+H24K24.3	C34G6.2
+K01C8.3	C34G6.2
+K10C2.4	C34G6.2
+K12G11.3	C34G6.2
+K12G11.4	C34G6.2
+T01C8.5	C34G6.2
+T08B1.3	C34G6.2
+T21C12.2	C34G6.2
+W06D4.1	C34G6.2
+Y53G8B.1	C34G6.2
+Y56A3A.3	C34G6.2
+ZK1058.5	C34G6.2
+ZK829.2	C34G6.2
+D1053.1	C44E4.3
+D2063.1	C44E4.3
+H13N06.6	C44E4.3
+H24K24.3	C44E4.3
+K01C8.3	C44E4.3
+K10C2.4	C44E4.3
+K12G11.3	C44E4.3
+K12G11.4	C44E4.3
+T08B1.3	C44E4.3
+T21C12.2	C44E4.3
+W06D4.1	C44E4.3
+Y53G8B.1	C44E4.3
+Y56A3A.3	C44E4.3
+ZK1058.5	C44E4.3
+ZK829.2	C44E4.3
+D2063.1	D1053.1
+F42D1.2	D1053.1
+H13N06.6	D1053.1
+H24K24.3	D1053.1
+K01C8.3	D1053.1
+K10C2.4	D1053.1
+K12G11.3	D1053.1
+K12G11.4	D1053.1
+T01C8.5	D1053.1
+T08B1.3	D1053.1
+T21C12.2	D1053.1
+W06D4.1	D1053.1
+Y53G8B.1	D1053.1
+Y56A3A.3	D1053.1
+ZK1058.5	D1053.1
+ZK829.2	D1053.1
+F42D1.2	D2063.1
+H13N06.6	D2063.1
+K01C8.3	D2063.1
+K10C2.4	D2063.1
+T01C8.5	D2063.1
+T21C12.2	D2063.1
+W06D4.1	D2063.1
+Y53G8B.1	D2063.1
+Y56A3A.3	D2063.1
+ZK1058.5	D2063.1
+ZK829.2	D2063.1
+H13N06.6	F42D1.2
+H24K24.3	F42D1.2
+K01C8.3	F42D1.2
+K10C2.4	F42D1.2
+K12G11.3	F42D1.2
+K12G11.4	F42D1.2
+T08B1.3	F42D1.2
+W06D4.1	F42D1.2
+Y53G8B.1	F42D1.2
+Y56A3A.3	F42D1.2
+ZK1058.5	F42D1.2
+ZK829.2	F42D1.2
+H24K24.3	H13N06.6
+K01C8.3	H13N06.6
+K10C2.4	H13N06.6
+K12G11.3	H13N06.6
+K12G11.4	H13N06.6
+T01C8.5	H13N06.6
+T08B1.3	H13N06.6
+T21C12.2	H13N06.6
+W06D4.1	H13N06.6
+Y53G8B.1	H13N06.6
+Y56A3A.3	H13N06.6
+ZK1058.5	H13N06.6
+ZK829.2	H13N06.6
+K01C8.3	H24K24.3
+K10C2.4	H24K24.3
+T01C8.5	H24K24.3
+T21C12.2	H24K24.3
+W06D4.1	H24K24.3
+Y53G8B.1	H24K24.3
+Y56A3A.3	H24K24.3
+ZK1058.5	H24K24.3
+ZK829.2	H24K24.3
+K10C2.4	K01C8.3
+K12G11.3	K01C8.3
+K12G11.4	K01C8.3
+T01C8.5	K01C8.3
+T21C12.2	K01C8.3
+W06D4.1	K01C8.3
+Y53G8B.1	K01C8.3
+Y56A3A.3	K01C8.3
+K12G11.3	K10C2.4
+K12G11.4	K10C2.4
+T01C8.5	K10C2.4
+T08B1.3	K10C2.4
+T21C12.2	K10C2.4
+W06D4.1	K10C2.4
+Y53G8B.1	K10C2.4
+Y56A3A.3	K10C2.4
+ZK1058.5	K10C2.4
+ZK829.2	K10C2.4
+T01C8.5	K12G11.3
+T21C12.2	K12G11.3
+W06D4.1	K12G11.3
+Y53G8B.1	K12G11.3
+Y56A3A.3	K12G11.3
+ZK1058.5	K12G11.3
+ZK829.2	K12G11.3
+T01C8.5	K12G11.4
+T21C12.2	K12G11.4
+W06D4.1	K12G11.4
+Y53G8B.1	K12G11.4
+Y56A3A.3	K12G11.4
+ZK1058.5	K12G11.4
+ZK829.2	K12G11.4
+T08B1.3	T01C8.5
+T21C12.2	T01C8.5
+W06D4.1	T01C8.5
+Y53G8B.1	T01C8.5
+Y56A3A.3	T01C8.5
+ZK1058.5	T01C8.5
+ZK829.2	T01C8.5
+T21C12.2	T08B1.3
+W06D4.1	T08B1.3
+Y53G8B.1	T08B1.3
+Y56A3A.3	T08B1.3
+W06D4.1	T21C12.2
+Y53G8B.1	T21C12.2
+Y56A3A.3	T21C12.2
+ZK1058.5	T21C12.2
+ZK829.2	T21C12.2
+Y53G8B.1	W06D4.1
+Y56A3A.3	W06D4.1
+ZK1058.5	W06D4.1
+ZK829.2	W06D4.1
+Y56A3A.3	Y53G8B.1
+ZK1058.5	Y53G8B.1
+ZK829.2	Y53G8B.1
+ZK1058.5	Y56A3A.3
+ZK829.2	Y56A3A.3
+F09F3.5	C05D2.3
+K08F8.4	C05D2.3
+ZK1127.2	C05D2.3
+F09F3.5	C14E2.2
+K08F8.4	C14E2.2
+ZK1127.2	C14E2.2
+F09F3.5	C14F11.1
+K08F8.4	C14F11.1
+ZK1127.2	C14F11.1
+F09F3.5	C44E4.3
+K08F8.4	C44E4.3
+ZK1127.2	C44E4.3
+F42D1.2	F09F3.5
+K01C8.3	F09F3.5
+K08F8.4	F09F3.5
+T01C8.5	F09F3.5
+T08B1.3	F09F3.5
+T21C12.2	F09F3.5
+Y56A3A.3	F09F3.5
+ZK1127.2	F09F3.5
+ZK829.2	F09F3.5
+K08F8.4	F42D1.2
+K08F8.4	K01C8.3
+ZK1127.2	K01C8.3
+T01C8.5	K08F8.4
+T08B1.3	K08F8.4
+T21C12.2	K08F8.4
+Y56A3A.3	K08F8.4
+ZK1127.2	K08F8.4
+ZK829.2	K08F8.4
+ZK1127.2	T01C8.5
+ZK1127.2	T08B1.3
+ZK1127.2	Y56A3A.3
+ZK829.2	ZK1127.2
+C05D2.3	B0272.3
+C15H9.7	B0272.3
+C28H8.11	B0272.3
+K01C8.3	B0272.3
+K06A4.5	B0272.3
+R03A10.4	B0272.3
+R07B7.5	B0272.3
+Y54G11A.13	B0272.3
+Y54G11A.5	B0272.3
+Y54G11A.6	B0272.3
+Y71D11A.3	B0272.3
+ZK1058.6	B0272.3
+ZK829.2	B0272.3
+C15H9.7	C05D2.3
+C28H8.11	C05D2.3
+C29F3.1	C05D2.3
+C49C8.4	C05D2.3
+F01G10.2	C05D2.3
+F01G10.3	C05D2.3
+F42A9.5	C05D2.3
+F54C8.1	C05D2.3
+F54D5.7	C05D2.3
+K06A4.5	C05D2.3
+R03A10.4	C05D2.3
+R07B7.5	C05D2.3
+R08F11.3	C05D2.3
+R09B5.6	C05D2.3
+T02G5.4	C05D2.3
+T02G5.7	C05D2.3
+T02G5.8	C05D2.3
+T05G5.6	C05D2.3
+T08B2.7	C05D2.3
+T22B11.5	C05D2.3
+Y49C4A.9	C05D2.3
+Y54G11A.13	C05D2.3
+Y54G11A.5	C05D2.3
+Y54G11A.6	C05D2.3
+Y71D11A.3	C05D2.3
+ZK1058.6	C05D2.3
+C28H8.11	C15H9.7
+C29F3.1	C15H9.7
+C49C8.4	C15H9.7
+F01F1.6	C15H9.7
+F01G10.2	C15H9.7
+F01G10.3	C15H9.7
+F42A9.5	C15H9.7
+F54C8.1	C15H9.7
+F54D5.7	C15H9.7
+F54D8.3	C15H9.7
+K01C8.3	C15H9.7
+K04F1.15	C15H9.7
+K06A4.5	C15H9.7
+R03A10.4	C15H9.7
+R07B7.5	C15H9.7
+R08F11.3	C15H9.7
+R09B5.6	C15H9.7
+T02G5.4	C15H9.7
+T02G5.7	C15H9.7
+T02G5.8	C15H9.7
+T05G5.6	C15H9.7
+T05H4.13	C15H9.7
+T08B2.7	C15H9.7
+T22B11.5	C15H9.7
+Y49C4A.9	C15H9.7
+Y54G11A.13	C15H9.7
+Y54G11A.5	C15H9.7
+Y54G11A.6	C15H9.7
+Y69F12A.2	C15H9.7
+Y71D11A.3	C15H9.7
+ZK1058.6	C15H9.7
+ZK829.2	C15H9.7
+C29F3.1	C28H8.11
+C49C8.4	C28H8.11
+F01F1.6	C28H8.11
+F01G10.2	C28H8.11
+F01G10.3	C28H8.11
+F42A9.5	C28H8.11
+F54C8.1	C28H8.11
+F54D5.7	C28H8.11
+F54D8.3	C28H8.11
+K01C8.3	C28H8.11
+K04F1.15	C28H8.11
+K06A4.5	C28H8.11
+R03A10.4	C28H8.11
+R07B7.5	C28H8.11
+R08F11.3	C28H8.11
+R09B5.6	C28H8.11
+T02G5.4	C28H8.11
+T02G5.7	C28H8.11
+T02G5.8	C28H8.11
+T05G5.6	C28H8.11
+T05H4.13	C28H8.11
+T08B2.7	C28H8.11
+T22B11.5	C28H8.11
+Y49C4A.9	C28H8.11
+Y54G11A.13	C28H8.11
+Y54G11A.5	C28H8.11
+Y54G11A.6	C28H8.11
+Y69F12A.2	C28H8.11
+Y71D11A.3	C28H8.11
+ZK1058.6	C28H8.11
+ZK829.2	C28H8.11
+K01C8.3	C29F3.1
+K06A4.5	C29F3.1
+R03A10.4	C29F3.1
+R07B7.5	C29F3.1
+Y54G11A.13	C29F3.1
+Y54G11A.5	C29F3.1
+Y54G11A.6	C29F3.1
+Y71D11A.3	C29F3.1
+ZK1058.6	C29F3.1
+ZK829.2	C29F3.1
+K01C8.3	C49C8.4
+K06A4.5	C49C8.4
+R03A10.4	C49C8.4
+R07B7.5	C49C8.4
+T22B11.5	C49C8.4
+Y54G11A.13	C49C8.4
+Y54G11A.5	C49C8.4
+Y54G11A.6	C49C8.4
+Y71D11A.3	C49C8.4
+ZK1058.6	C49C8.4
+ZK829.2	C49C8.4
+K06A4.5	F01F1.6
+R03A10.4	F01F1.6
+R07B7.5	F01F1.6
+Y54G11A.13	F01F1.6
+Y54G11A.5	F01F1.6
+Y54G11A.6	F01F1.6
+Y71D11A.3	F01F1.6
+ZK1058.6	F01F1.6
+K01C8.3	F01G10.2
+K06A4.5	F01G10.2
+R03A10.4	F01G10.2
+R07B7.5	F01G10.2
+Y54G11A.13	F01G10.2
+Y54G11A.5	F01G10.2
+Y54G11A.6	F01G10.2
+Y71D11A.3	F01G10.2
+ZK1058.6	F01G10.2
+ZK829.2	F01G10.2
+K01C8.3	F01G10.3
+K06A4.5	F01G10.3
+R03A10.4	F01G10.3
+R07B7.5	F01G10.3
+Y54G11A.13	F01G10.3
+Y54G11A.5	F01G10.3
+Y54G11A.6	F01G10.3
+Y71D11A.3	F01G10.3
+ZK1058.6	F01G10.3
+ZK829.2	F01G10.3
+K01C8.3	F42A9.5
+K06A4.5	F42A9.5
+R03A10.4	F42A9.5
+R07B7.5	F42A9.5
+T22B11.5	F42A9.5
+Y54G11A.13	F42A9.5
+Y54G11A.5	F42A9.5
+Y54G11A.6	F42A9.5
+Y71D11A.3	F42A9.5
+ZK1058.6	F42A9.5
+ZK829.2	F42A9.5
+K01C8.3	F54C8.1
+K06A4.5	F54C8.1
+R03A10.4	F54C8.1
+R07B7.5	F54C8.1
+Y54G11A.13	F54C8.1
+Y54G11A.5	F54C8.1
+Y54G11A.6	F54C8.1
+Y71D11A.3	F54C8.1
+ZK1058.6	F54C8.1
+ZK829.2	F54C8.1
+K01C8.3	F54D5.7
+K06A4.5	F54D5.7
+R03A10.4	F54D5.7
+R07B7.5	F54D5.7
+Y54G11A.13	F54D5.7
+Y54G11A.5	F54D5.7
+Y54G11A.6	F54D5.7
+Y71D11A.3	F54D5.7
+ZK1058.6	F54D5.7
+ZK829.2	F54D5.7
+K06A4.5	F54D8.3
+R03A10.4	F54D8.3
+R07B7.5	F54D8.3
+Y54G11A.13	F54D8.3
+Y54G11A.5	F54D8.3
+Y54G11A.6	F54D8.3
+Y71D11A.3	F54D8.3
+ZK1058.6	F54D8.3
+K06A4.5	K01C8.3
+R03A10.4	K01C8.3
+R07B7.5	K01C8.3
+R08F11.3	K01C8.3
+R09B5.6	K01C8.3
+T02G5.4	K01C8.3
+T02G5.7	K01C8.3
+T02G5.8	K01C8.3
+T05G5.6	K01C8.3
+T08B2.7	K01C8.3
+T22B11.5	K01C8.3
+Y49C4A.9	K01C8.3
+Y54G11A.13	K01C8.3
+Y54G11A.5	K01C8.3
+Y54G11A.6	K01C8.3
+Y71D11A.3	K01C8.3
+ZK1058.6	K01C8.3
+K06A4.5	K04F1.15
+R03A10.4	K04F1.15
+R07B7.5	K04F1.15
+Y54G11A.13	K04F1.15
+Y54G11A.5	K04F1.15
+Y54G11A.6	K04F1.15
+Y71D11A.3	K04F1.15
+ZK1058.6	K04F1.15
+R03A10.4	K06A4.5
+R07B7.5	K06A4.5
+R08F11.3	K06A4.5
+R09B5.6	K06A4.5
+T02G5.4	K06A4.5
+T02G5.7	K06A4.5
+T02G5.8	K06A4.5
+T05G5.6	K06A4.5
+T05H4.13	K06A4.5
+T08B2.7	K06A4.5
+T22B11.5	K06A4.5
+Y49C4A.9	K06A4.5
+Y54G11A.13	K06A4.5
+Y54G11A.5	K06A4.5
+Y54G11A.6	K06A4.5
+Y69F12A.2	K06A4.5
+Y71D11A.3	K06A4.5
+ZK1058.6	K06A4.5
+ZK829.2	K06A4.5
+R07B7.5	R03A10.4
+R08F11.3	R03A10.4
+R09B5.6	R03A10.4
+T02G5.4	R03A10.4
+T02G5.7	R03A10.4
+T02G5.8	R03A10.4
+T05G5.6	R03A10.4
+T05H4.13	R03A10.4
+T08B2.7	R03A10.4
+T22B11.5	R03A10.4
+Y49C4A.9	R03A10.4
+Y54G11A.13	R03A10.4
+Y54G11A.5	R03A10.4
+Y54G11A.6	R03A10.4
+Y69F12A.2	R03A10.4
+Y71D11A.3	R03A10.4
+ZK1058.6	R03A10.4
+ZK829.2	R03A10.4
+R08F11.3	R07B7.5
+R09B5.6	R07B7.5
+T02G5.4	R07B7.5
+T02G5.7	R07B7.5
+T02G5.8	R07B7.5
+T05G5.6	R07B7.5
+T05H4.13	R07B7.5
+T08B2.7	R07B7.5
+T22B11.5	R07B7.5
+Y49C4A.9	R07B7.5
+Y54G11A.13	R07B7.5
+Y54G11A.5	R07B7.5
+Y54G11A.6	R07B7.5
+Y69F12A.2	R07B7.5
+Y71D11A.3	R07B7.5
+ZK1058.6	R07B7.5
+ZK829.2	R07B7.5
+T22B11.5	R08F11.3
+Y54G11A.13	R08F11.3
+Y54G11A.5	R08F11.3
+Y54G11A.6	R08F11.3
+Y71D11A.3	R08F11.3
+ZK1058.6	R08F11.3
+ZK829.2	R08F11.3
+Y54G11A.13	R09B5.6
+Y54G11A.5	R09B5.6
+Y54G11A.6	R09B5.6
+Y71D11A.3	R09B5.6
+ZK1058.6	R09B5.6
+ZK829.2	R09B5.6
+Y54G11A.13	T02G5.4
+Y54G11A.5	T02G5.4
+Y54G11A.6	T02G5.4
+Y71D11A.3	T02G5.4
+ZK1058.6	T02G5.4
+ZK829.2	T02G5.4
+Y54G11A.13	T02G5.7
+Y54G11A.5	T02G5.7
+Y54G11A.6	T02G5.7
+Y71D11A.3	T02G5.7
+ZK1058.6	T02G5.7
+ZK829.2	T02G5.7
+Y54G11A.13	T02G5.8
+Y54G11A.5	T02G5.8
+Y54G11A.6	T02G5.8
+Y71D11A.3	T02G5.8
+ZK1058.6	T02G5.8
+ZK829.2	T02G5.8
+Y54G11A.13	T05G5.6
+Y54G11A.5	T05G5.6
+Y54G11A.6	T05G5.6
+Y71D11A.3	T05G5.6
+ZK1058.6	T05G5.6
+ZK829.2	T05G5.6
+Y54G11A.13	T05H4.13
+Y54G11A.5	T05H4.13
+Y54G11A.6	T05H4.13
+Y71D11A.3	T05H4.13
+ZK1058.6	T05H4.13
+Y54G11A.13	T08B2.7
+Y54G11A.5	T08B2.7
+Y54G11A.6	T08B2.7
+Y71D11A.3	T08B2.7
+ZK1058.6	T08B2.7
+ZK829.2	T08B2.7
+Y49C4A.9	T22B11.5
+Y54G11A.13	T22B11.5
+Y54G11A.5	T22B11.5
+Y54G11A.6	T22B11.5
+Y71D11A.3	T22B11.5
+ZK1058.6	T22B11.5
+ZK829.2	T22B11.5
+Y54G11A.13	Y49C4A.9
+Y54G11A.5	Y49C4A.9
+Y54G11A.6	Y49C4A.9
+Y71D11A.3	Y49C4A.9
+ZK1058.6	Y49C4A.9
+ZK829.2	Y49C4A.9
+Y54G11A.5	Y54G11A.13
+Y54G11A.6	Y54G11A.13
+Y69F12A.2	Y54G11A.13
+Y71D11A.3	Y54G11A.13
+ZK1058.6	Y54G11A.13
+ZK829.2	Y54G11A.13
+Y54G11A.6	Y54G11A.5
+Y69F12A.2	Y54G11A.5
+Y71D11A.3	Y54G11A.5
+ZK1058.6	Y54G11A.5
+ZK829.2	Y54G11A.5
+Y69F12A.2	Y54G11A.6
+Y71D11A.3	Y54G11A.6
+ZK1058.6	Y54G11A.6
+ZK829.2	Y54G11A.6
+Y71D11A.3	Y69F12A.2
+ZK1058.6	Y69F12A.2
+ZK1058.6	Y71D11A.3
+ZK829.2	Y71D11A.3
+ZK829.2	ZK1058.6
+C29F3.1	C25F6.3
+F01F1.6	C25F6.3
+F09F7.4	C25F6.3
+F13D12.4	C25F6.3
+F54D8.3	C25F6.3
+K04D7.3	C25F6.3
+K04F1.15	C25F6.3
+K05F1.3	C25F6.3
+K09H11.1	C25F6.3
+T05G5.6	C25F6.3
+T05H4.13	C25F6.3
+T08B1.3	C25F6.3
+T08B2.7	C25F6.3
+T08G2.3	C25F6.3
+T25G12.5	C25F6.3
+Y37D8A.23	C25F6.3
+Y46G5A.19	C25F6.3
+Y69F12A.2	C25F6.3
+C47E12.8	C29F3.1
+F13H8.7	C29F3.1
+T08B1.3	C29F3.1
+Y37D8A.23	C29F3.1
+Y46G5A.19	C29F3.1
+F01F1.6	C47E12.8
+F09F7.4	C47E12.8
+F13D12.4	C47E12.8
+F54D8.3	C47E12.8
+K04D7.3	C47E12.8
+K04F1.15	C47E12.8
+K05F1.3	C47E12.8
+K09H11.1	C47E12.8
+T05G5.6	C47E12.8
+T05H4.13	C47E12.8
+T08B1.3	C47E12.8
+T08B2.7	C47E12.8
+T08G2.3	C47E12.8
+T25G12.5	C47E12.8
+Y37D8A.23	C47E12.8
+Y46G5A.19	C47E12.8
+Y69F12A.2	C47E12.8
+F13H8.7	F01F1.6
+Y37D8A.23	F01F1.6
+F13H8.7	F09F7.4
+T08B1.3	F09F7.4
+Y37D8A.23	F09F7.4
+Y46G5A.19	F09F7.4
+F13H8.7	F13D12.4
+T08B1.3	F13D12.4
+Y37D8A.23	F13D12.4
+Y46G5A.19	F13D12.4
+F54D8.3	F13H8.7
+K04D7.3	F13H8.7
+K04F1.15	F13H8.7
+K05F1.3	F13H8.7
+K09H11.1	F13H8.7
+T05G5.6	F13H8.7
+T05H4.13	F13H8.7
+T08B1.3	F13H8.7
+T08B2.7	F13H8.7
+T08G2.3	F13H8.7
+T25G12.5	F13H8.7
+Y37D8A.23	F13H8.7
+Y46G5A.19	F13H8.7
+Y69F12A.2	F13H8.7
+Y37D8A.23	F54D8.3
+T08B1.3	K04D7.3
+Y46G5A.19	K04D7.3
+Y37D8A.23	K04F1.15
+T08B1.3	K05F1.3
+Y37D8A.23	K05F1.3
+Y46G5A.19	K05F1.3
+T08B1.3	K09H11.1
+Y37D8A.23	K09H11.1
+Y46G5A.19	K09H11.1
+T08B1.3	T05G5.6
+Y37D8A.23	T05G5.6
+Y46G5A.19	T05G5.6
+Y37D8A.23	T05H4.13
+T08B2.7	T08B1.3
+T08G2.3	T08B1.3
+T25G12.5	T08B1.3
+Y37D8A.23	T08B1.3
+Y46G5A.19	T08B1.3
+Y37D8A.23	T08B2.7
+Y46G5A.19	T08B2.7
+Y37D8A.23	T08G2.3
+Y46G5A.19	T08G2.3
+Y37D8A.23	T25G12.5
+Y46G5A.19	T25G12.5
+Y46G5A.19	Y37D8A.23
+Y69F12A.2	Y37D8A.23
+F56F10.3	C53D5.5
+T03D8.6	C53D5.5
+Y37D8A.23	C53D5.5
+Y7A9A.1	C53D5.5
+T03D8.6	F56F10.3
+Y37D8A.23	F56F10.3
+Y7A9A.1	F56F10.3
+Y37D8A.23	T03D8.6
+Y7A9A.1	T03D8.6
+Y7A9A.1	Y37D8A.23
+C12C8.2	C06G3.7
+D1054.13	C06G3.7
+F13H8.9	C06G3.7
+F22B8.6	C06G3.7
+F58B3.5	C06G3.7
+R03A10.4	C06G3.7
+R03D7.1	C06G3.7
+T14G10.1	C06G3.7
+Y105E8A.20	C06G3.7
+Y45F10A.4	C06G3.7
+ZK1127.10	C06G3.7
+D1054.13	C12C8.2
+F13H8.9	C12C8.2
+F58B3.5	C12C8.2
+R03A10.4	C12C8.2
+T14G10.1	C12C8.2
+Y105E8A.20	C12C8.2
+Y45F10A.4	C12C8.2
+F13H8.9	D1054.13
+F22B8.6	D1054.13
+F58B3.5	D1054.13
+R03A10.4	D1054.13
+R03D7.1	D1054.13
+T14G10.1	D1054.13
+Y105E8A.20	D1054.13
+Y45F10A.4	D1054.13
+ZK1127.10	D1054.13
+F22B8.6	F13H8.9
+F58B3.5	F13H8.9
+R03A10.4	F13H8.9
+R03D7.1	F13H8.9
+T14G10.1	F13H8.9
+Y105E8A.20	F13H8.9
+Y45F10A.4	F13H8.9
+ZK1127.10	F13H8.9
+F58B3.5	F22B8.6
+R03A10.4	F22B8.6
+T14G10.1	F22B8.6
+Y105E8A.20	F22B8.6
+Y45F10A.4	F22B8.6
+R03A10.4	F58B3.5
+R03D7.1	F58B3.5
+T14G10.1	F58B3.5
+Y105E8A.20	F58B3.5
+Y45F10A.4	F58B3.5
+ZK1127.10	F58B3.5
+R03D7.1	R03A10.4
+T14G10.1	R03A10.4
+Y105E8A.20	R03A10.4
+Y45F10A.4	R03A10.4
+ZK1127.10	R03A10.4
+T14G10.1	R03D7.1
+Y105E8A.20	R03D7.1
+Y45F10A.4	R03D7.1
+Y105E8A.20	T14G10.1
+Y45F10A.4	T14G10.1
+ZK1127.10	T14G10.1
+Y45F10A.4	Y105E8A.20
+ZK1127.10	Y105E8A.20
+ZK1127.10	Y45F10A.4
+C50F7.10	C05D11.11
+C53D5.5	C05D11.11
+T03D8.6	C05D11.11
+Y7A9A.1	C05D11.11
+ZK1058.6	C05D11.11
+C53D5.5	C50F7.10
+T03D8.6	C50F7.10
+Y7A9A.1	C50F7.10
+ZK1058.6	C50F7.10
+ZK1058.6	C53D5.5
+ZK1058.6	T03D8.6
+ZK1058.6	Y7A9A.1
+C03C10.3	B0035.5
+C11E4.1	B0035.5
+C11E4.2	B0035.5
+C29E4.7	B0035.5
+C34F6.8	B0035.5
+C44B7.7	B0035.5
+C53D5.5	B0035.5
+E01A2.1	B0035.5
+F11G11.1	B0035.5
+F11G11.2	B0035.5
+F11G11.3	B0035.5
+F26E4.12	B0035.5
+F35E8.8	B0035.5
+F37B12.2	B0035.5
+F59B8.2	B0035.5
+K08F4.11	B0035.5
+K08F4.6	B0035.5
+K08F4.7	B0035.5
+K11C4.4	B0035.5
+M176.2	B0035.5
+R03D7.6	B0035.5
+R03G5.5	B0035.5
+R05H10.5	B0035.5
+R07B1.4	B0035.5
+R107.7	B0035.5
+T03D8.6	B0035.5
+T23G5.1	B0035.5
+W07G4.4	B0035.5
+Y38F2AR.12	B0035.5
+Y45G12C.2	B0035.5
+Y46G5A.19	B0035.5
+Y7A9A.1	B0035.5
+ZK1320.1	B0035.5
+ZK353.6	B0035.5
+ZK546.11	B0035.5
+ZK637.10	B0035.5
+C11E4.1	C03C10.3
+C11E4.2	C03C10.3
+C29E4.7	C03C10.3
+C34F6.8	C03C10.3
+C44B7.7	C03C10.3
+C53D5.5	C03C10.3
+E01A2.1	C03C10.3
+F11G11.1	C03C10.3
+F11G11.2	C03C10.3
+F11G11.3	C03C10.3
+F26E4.12	C03C10.3
+F35E8.8	C03C10.3
+F37B12.2	C03C10.3
+F59B8.2	C03C10.3
+K08F4.11	C03C10.3
+K08F4.6	C03C10.3
+K08F4.7	C03C10.3
+K11C4.4	C03C10.3
+M176.2	C03C10.3
+R03D7.6	C03C10.3
+R03G5.5	C03C10.3
+R05H10.5	C03C10.3
+R07B1.4	C03C10.3
+R107.7	C03C10.3
+T03D8.6	C03C10.3
+T25B9.9	C03C10.3
+W07G4.4	C03C10.3
+Y38F2AR.12	C03C10.3
+Y45G12C.2	C03C10.3
+Y46G5A.19	C03C10.3
+Y7A9A.1	C03C10.3
+ZK1320.1	C03C10.3
+ZK353.6	C03C10.3
+ZK546.11	C03C10.3
+ZK637.10	C03C10.3
+C11E4.2	C11E4.1
+C29E4.7	C11E4.1
+C34F6.8	C11E4.1
+C44B7.7	C11E4.1
+C53D5.5	C11E4.1
+E01A2.1	C11E4.1
+F11G11.1	C11E4.1
+F11G11.2	C11E4.1
+F11G11.3	C11E4.1
+F26E4.12	C11E4.1
+F35E8.8	C11E4.1
+F37B12.2	C11E4.1
+F59B8.2	C11E4.1
+K08F4.11	C11E4.1
+K08F4.6	C11E4.1
+K08F4.7	C11E4.1
+K11C4.4	C11E4.1
+M176.2	C11E4.1
+R03D7.6	C11E4.1
+R03G5.5	C11E4.1
+R05H10.5	C11E4.1
+R07B1.4	C11E4.1
+R107.7	C11E4.1
+T03D8.6	C11E4.1
+T23G5.1	C11E4.1
+T25B9.9	C11E4.1
+W07G4.4	C11E4.1
+Y38F2AR.12	C11E4.1
+Y45G12C.2	C11E4.1
+Y46G5A.19	C11E4.1
+Y7A9A.1	C11E4.1
+ZK1320.1	C11E4.1
+ZK353.6	C11E4.1
+ZK546.11	C11E4.1
+ZK637.10	C11E4.1
+C29E4.7	C11E4.2
+C34F6.8	C11E4.2
+C44B7.7	C11E4.2
+C53D5.5	C11E4.2
+E01A2.1	C11E4.2
+F11G11.1	C11E4.2
+F11G11.2	C11E4.2
+F11G11.3	C11E4.2
+F26E4.12	C11E4.2
+F35E8.8	C11E4.2
+F37B12.2	C11E4.2
+F59B8.2	C11E4.2
+K08F4.11	C11E4.2
+K08F4.6	C11E4.2
+K08F4.7	C11E4.2
+K11C4.4	C11E4.2
+M176.2	C11E4.2
+R03D7.6	C11E4.2
+R03G5.5	C11E4.2
+R05H10.5	C11E4.2
+R07B1.4	C11E4.2
+R107.7	C11E4.2
+T03D8.6	C11E4.2
+T23G5.1	C11E4.2
+T25B9.9	C11E4.2
+W07G4.4	C11E4.2
+Y38F2AR.12	C11E4.2
+Y45G12C.2	C11E4.2
+Y46G5A.19	C11E4.2
+Y7A9A.1	C11E4.2
+ZK1320.1	C11E4.2
+ZK353.6	C11E4.2
+ZK546.11	C11E4.2
+ZK637.10	C11E4.2
+C34F6.8	C29E4.7
+C44B7.7	C29E4.7
+C53D5.5	C29E4.7
+E01A2.1	C29E4.7
+F11G11.1	C29E4.7
+F11G11.2	C29E4.7
+F11G11.3	C29E4.7
+F26E4.12	C29E4.7
+F35E8.8	C29E4.7
+F37B12.2	C29E4.7
+F59B8.2	C29E4.7
+K08F4.11	C29E4.7
+K08F4.6	C29E4.7
+K08F4.7	C29E4.7
+K11C4.4	C29E4.7
+M176.2	C29E4.7
+R03D7.6	C29E4.7
+R03G5.5	C29E4.7
+R05H10.5	C29E4.7
+R07B1.4	C29E4.7
+R107.7	C29E4.7
+T03D8.6	C29E4.7
+T23G5.1	C29E4.7
+T25B9.9	C29E4.7
+W07G4.4	C29E4.7
+Y38F2AR.12	C29E4.7
+Y45G12C.2	C29E4.7
+Y46G5A.19	C29E4.7
+Y7A9A.1	C29E4.7
+ZK1320.1	C29E4.7
+ZK353.6	C29E4.7
+ZK546.11	C29E4.7
+ZK637.10	C29E4.7
+C44B7.7	C34F6.8
+C53D5.5	C34F6.8
+E01A2.1	C34F6.8
+F11G11.1	C34F6.8
+F11G11.2	C34F6.8
+F11G11.3	C34F6.8
+F26E4.12	C34F6.8
+F35E8.8	C34F6.8
+F37B12.2	C34F6.8
+K08F4.11	C34F6.8
+K08F4.6	C34F6.8
+K08F4.7	C34F6.8
+K11C4.4	C34F6.8
+M176.2	C34F6.8
+R03D7.6	C34F6.8
+R03G5.5	C34F6.8
+R05H10.5	C34F6.8
+R07B1.4	C34F6.8
+R107.7	C34F6.8
+T03D8.6	C34F6.8
+T23G5.1	C34F6.8
+T25B9.9	C34F6.8
+W07G4.4	C34F6.8
+Y38F2AR.12	C34F6.8
+Y45G12C.2	C34F6.8
+Y46G5A.19	C34F6.8
+Y7A9A.1	C34F6.8
+ZK1320.1	C34F6.8
+ZK353.6	C34F6.8
+ZK546.11	C34F6.8
+ZK637.10	C34F6.8
+C53D5.5	C44B7.7
+E01A2.1	C44B7.7
+F11G11.1	C44B7.7
+F11G11.2	C44B7.7
+F11G11.3	C44B7.7
+F26E4.12	C44B7.7
+F35E8.8	C44B7.7
+F37B12.2	C44B7.7
+F59B8.2	C44B7.7
+K08F4.11	C44B7.7
+K08F4.6	C44B7.7
+K08F4.7	C44B7.7
+K11C4.4	C44B7.7
+M176.2	C44B7.7
+R03D7.6	C44B7.7
+R03G5.5	C44B7.7
+R05H10.5	C44B7.7
+R07B1.4	C44B7.7
+R107.7	C44B7.7
+T03D8.6	C44B7.7
+T23G5.1	C44B7.7
+T25B9.9	C44B7.7
+W07G4.4	C44B7.7
+Y38F2AR.12	C44B7.7
+Y45G12C.2	C44B7.7
+Y46G5A.19	C44B7.7
+Y7A9A.1	C44B7.7
+ZK1320.1	C44B7.7
+ZK353.6	C44B7.7
+ZK546.11	C44B7.7
+ZK637.10	C44B7.7
+E01A2.1	C53D5.5
+F11G11.1	C53D5.5
+F11G11.2	C53D5.5
+F11G11.3	C53D5.5
+F26E4.12	C53D5.5
+F35E8.8	C53D5.5
+F37B12.2	C53D5.5
+F59B8.2	C53D5.5
+K08F4.11	C53D5.5
+K08F4.6	C53D5.5
+K08F4.7	C53D5.5
+K11C4.4	C53D5.5
+M176.2	C53D5.5
+R03D7.6	C53D5.5
+R03G5.5	C53D5.5
+R05H10.5	C53D5.5
+R07B1.4	C53D5.5
+R107.7	C53D5.5
+T23G5.1	C53D5.5
+T25B9.9	C53D5.5
+W07G4.4	C53D5.5
+Y38F2AR.12	C53D5.5
+Y45G12C.2	C53D5.5
+Y46G5A.19	C53D5.5
+ZK1320.1	C53D5.5
+ZK353.6	C53D5.5
+ZK546.11	C53D5.5
+ZK637.10	C53D5.5
+F11G11.1	E01A2.1
+F11G11.2	E01A2.1
+F11G11.3	E01A2.1
+F26E4.12	E01A2.1
+F35E8.8	E01A2.1
+F37B12.2	E01A2.1
+F59B8.2	E01A2.1
+K08F4.11	E01A2.1
+K08F4.6	E01A2.1
+K08F4.7	E01A2.1
+K11C4.4	E01A2.1
+M176.2	E01A2.1
+R03D7.6	E01A2.1
+R03G5.5	E01A2.1
+R05H10.5	E01A2.1
+R07B1.4	E01A2.1
+R107.7	E01A2.1
+T03D8.6	E01A2.1
+T23G5.1	E01A2.1
+T25B9.9	E01A2.1
+W07G4.4	E01A2.1
+Y38F2AR.12	E01A2.1
+Y45G12C.2	E01A2.1
+Y46G5A.19	E01A2.1
+Y7A9A.1	E01A2.1
+ZK1320.1	E01A2.1
+ZK353.6	E01A2.1
+ZK546.11	E01A2.1
+ZK637.10	E01A2.1
+F11G11.2	F11G11.1
+F11G11.3	F11G11.1
+F26E4.12	F11G11.1
+F35E8.8	F11G11.1
+F37B12.2	F11G11.1
+F59B8.2	F11G11.1
+K08F4.11	F11G11.1
+K08F4.6	F11G11.1
+K08F4.7	F11G11.1
+K11C4.4	F11G11.1
+M176.2	F11G11.1
+R03D7.6	F11G11.1
+R03G5.5	F11G11.1
+R05H10.5	F11G11.1
+R07B1.4	F11G11.1
+R107.7	F11G11.1
+T03D8.6	F11G11.1
+T23G5.1	F11G11.1
+T25B9.9	F11G11.1
+W07G4.4	F11G11.1
+Y38F2AR.12	F11G11.1
+Y45G12C.2	F11G11.1
+Y46G5A.19	F11G11.1
+Y7A9A.1	F11G11.1
+ZK1320.1	F11G11.1
+ZK353.6	F11G11.1
+ZK546.11	F11G11.1
+ZK637.10	F11G11.1
+F11G11.3	F11G11.2
+F26E4.12	F11G11.2
+F35E8.8	F11G11.2
+F37B12.2	F11G11.2
+F59B8.2	F11G11.2
+K08F4.11	F11G11.2
+K08F4.6	F11G11.2
+K08F4.7	F11G11.2
+K11C4.4	F11G11.2
+M176.2	F11G11.2
+R03D7.6	F11G11.2
+R03G5.5	F11G11.2
+R05H10.5	F11G11.2
+R07B1.4	F11G11.2
+R107.7	F11G11.2
+T03D8.6	F11G11.2
+T23G5.1	F11G11.2
+T25B9.9	F11G11.2
+W07G4.4	F11G11.2
+Y38F2AR.12	F11G11.2
+Y45G12C.2	F11G11.2
+Y46G5A.19	F11G11.2
+Y7A9A.1	F11G11.2
+ZK1320.1	F11G11.2
+ZK353.6	F11G11.2
+ZK546.11	F11G11.2
+ZK637.10	F11G11.2
+F26E4.12	F11G11.3
+F35E8.8	F11G11.3
+F37B12.2	F11G11.3
+F59B8.2	F11G11.3
+K08F4.11	F11G11.3
+K08F4.6	F11G11.3
+K08F4.7	F11G11.3
+K11C4.4	F11G11.3
+M176.2	F11G11.3
+R03D7.6	F11G11.3
+R03G5.5	F11G11.3
+R05H10.5	F11G11.3
+R07B1.4	F11G11.3
+R107.7	F11G11.3
+T03D8.6	F11G11.3
+T23G5.1	F11G11.3
+T25B9.9	F11G11.3
+W07G4.4	F11G11.3
+Y38F2AR.12	F11G11.3
+Y45G12C.2	F11G11.3
+Y46G5A.19	F11G11.3
+Y7A9A.1	F11G11.3
+ZK1320.1	F11G11.3
+ZK353.6	F11G11.3
+ZK546.11	F11G11.3
+ZK637.10	F11G11.3
+F35E8.8	F26E4.12
+F37B12.2	F26E4.12
+F59B8.2	F26E4.12
+K08F4.11	F26E4.12
+K08F4.6	F26E4.12
+K08F4.7	F26E4.12
+K11C4.4	F26E4.12
+M176.2	F26E4.12
+R03D7.6	F26E4.12
+R03G5.5	F26E4.12
+R05H10.5	F26E4.12
+R07B1.4	F26E4.12
+R107.7	F26E4.12
+T03D8.6	F26E4.12
+T23G5.1	F26E4.12
+T25B9.9	F26E4.12
+W07G4.4	F26E4.12
+Y38F2AR.12	F26E4.12
+Y45G12C.2	F26E4.12
+Y46G5A.19	F26E4.12
+Y7A9A.1	F26E4.12
+ZK1320.1	F26E4.12
+ZK353.6	F26E4.12
+ZK546.11	F26E4.12
+ZK637.10	F26E4.12
+F37B12.2	F35E8.8
+F59B8.2	F35E8.8
+K08F4.11	F35E8.8
+K08F4.6	F35E8.8
+K08F4.7	F35E8.8
+K11C4.4	F35E8.8
+M176.2	F35E8.8
+R03D7.6	F35E8.8
+R03G5.5	F35E8.8
+R05H10.5	F35E8.8
+R07B1.4	F35E8.8
+R107.7	F35E8.8
+T03D8.6	F35E8.8
+T23G5.1	F35E8.8
+T25B9.9	F35E8.8
+W07G4.4	F35E8.8
+Y38F2AR.12	F35E8.8
+Y45G12C.2	F35E8.8
+Y46G5A.19	F35E8.8
+Y7A9A.1	F35E8.8
+ZK1320.1	F35E8.8
+ZK353.6	F35E8.8
+ZK546.11	F35E8.8
+ZK637.10	F35E8.8
+F59B8.2	F37B12.2
+K08F4.11	F37B12.2
+K08F4.6	F37B12.2
+K08F4.7	F37B12.2
+K11C4.4	F37B12.2
+M176.2	F37B12.2
+R03D7.6	F37B12.2
+R03G5.5	F37B12.2
+R05H10.5	F37B12.2
+R07B1.4	F37B12.2
+R107.7	F37B12.2
+T03D8.6	F37B12.2
+T23G5.1	F37B12.2
+T25B9.9	F37B12.2
+W07G4.4	F37B12.2
+Y38F2AR.12	F37B12.2
+Y45G12C.2	F37B12.2
+Y46G5A.19	F37B12.2
+Y7A9A.1	F37B12.2
+ZK1320.1	F37B12.2
+ZK353.6	F37B12.2
+ZK546.11	F37B12.2
+ZK637.10	F37B12.2
+K08F4.11	F59B8.2
+K08F4.6	F59B8.2
+K08F4.7	F59B8.2
+K11C4.4	F59B8.2
+M176.2	F59B8.2
+R03D7.6	F59B8.2
+R03G5.5	F59B8.2
+R05H10.5	F59B8.2
+R07B1.4	F59B8.2
+R107.7	F59B8.2
+T03D8.6	F59B8.2
+T23G5.1	F59B8.2
+T25B9.9	F59B8.2
+W07G4.4	F59B8.2
+Y38F2AR.12	F59B8.2
+Y45G12C.2	F59B8.2
+Y46G5A.19	F59B8.2
+Y7A9A.1	F59B8.2
+ZK1320.1	F59B8.2
+ZK353.6	F59B8.2
+ZK546.11	F59B8.2
+ZK637.10	F59B8.2
+K08F4.6	K08F4.11
+K08F4.7	K08F4.11
+K11C4.4	K08F4.11
+M176.2	K08F4.11
+R03D7.6	K08F4.11
+R03G5.5	K08F4.11
+R05H10.5	K08F4.11
+R07B1.4	K08F4.11
+R107.7	K08F4.11
+T03D8.6	K08F4.11
+T23G5.1	K08F4.11
+T25B9.9	K08F4.11
+W07G4.4	K08F4.11
+Y38F2AR.12	K08F4.11
+Y45G12C.2	K08F4.11
+Y46G5A.19	K08F4.11
+Y7A9A.1	K08F4.11
+ZK1320.1	K08F4.11
+ZK353.6	K08F4.11
+ZK546.11	K08F4.11
+ZK637.10	K08F4.11
+K08F4.7	K08F4.6
+K11C4.4	K08F4.6
+M176.2	K08F4.6
+R03D7.6	K08F4.6
+R03G5.5	K08F4.6
+R05H10.5	K08F4.6
+R07B1.4	K08F4.6
+R107.7	K08F4.6
+T03D8.6	K08F4.6
+T23G5.1	K08F4.6
+T25B9.9	K08F4.6
+W07G4.4	K08F4.6
+Y38F2AR.12	K08F4.6
+Y45G12C.2	K08F4.6
+Y46G5A.19	K08F4.6
+Y7A9A.1	K08F4.6
+ZK1320.1	K08F4.6
+ZK353.6	K08F4.6
+ZK546.11	K08F4.6
+ZK637.10	K08F4.6
+K11C4.4	K08F4.7
+M176.2	K08F4.7
+R03D7.6	K08F4.7
+R03G5.5	K08F4.7
+R05H10.5	K08F4.7
+R07B1.4	K08F4.7
+R107.7	K08F4.7
+T03D8.6	K08F4.7
+T23G5.1	K08F4.7
+T25B9.9	K08F4.7
+W07G4.4	K08F4.7
+Y38F2AR.12	K08F4.7
+Y45G12C.2	K08F4.7
+Y46G5A.19	K08F4.7
+Y7A9A.1	K08F4.7
+ZK1320.1	K08F4.7
+ZK353.6	K08F4.7
+ZK546.11	K08F4.7
+ZK637.10	K08F4.7
+M176.2	K11C4.4
+R03D7.6	K11C4.4
+R03G5.5	K11C4.4
+R05H10.5	K11C4.4
+R07B1.4	K11C4.4
+R107.7	K11C4.4
+T03D8.6	K11C4.4
+T23G5.1	K11C4.4
+T25B9.9	K11C4.4
+W07G4.4	K11C4.4
+Y38F2AR.12	K11C4.4
+Y45G12C.2	K11C4.4
+Y7A9A.1	K11C4.4
+ZK1320.1	K11C4.4
+ZK353.6	K11C4.4
+ZK546.11	K11C4.4
+ZK637.10	K11C4.4
+R03D7.6	M176.2
+R03G5.5	M176.2
+R05H10.5	M176.2
+R07B1.4	M176.2
+R107.7	M176.2
+T03D8.6	M176.2
+T23G5.1	M176.2
+T25B9.9	M176.2
+W07G4.4	M176.2
+Y38F2AR.12	M176.2
+Y45G12C.2	M176.2
+Y46G5A.19	M176.2
+Y7A9A.1	M176.2
+ZK1320.1	M176.2
+ZK353.6	M176.2
+ZK546.11	M176.2
+ZK637.10	M176.2
+R03G5.5	R03D7.6
+R05H10.5	R03D7.6
+R07B1.4	R03D7.6
+R107.7	R03D7.6
+T03D8.6	R03D7.6
+T23G5.1	R03D7.6
+T25B9.9	R03D7.6
+W07G4.4	R03D7.6
+Y38F2AR.12	R03D7.6
+Y45G12C.2	R03D7.6
+Y46G5A.19	R03D7.6
+Y7A9A.1	R03D7.6
+ZK1320.1	R03D7.6
+ZK353.6	R03D7.6
+ZK546.11	R03D7.6
+ZK637.10	R03D7.6
+R05H10.5	R03G5.5
+R07B1.4	R03G5.5
+R107.7	R03G5.5
+T03D8.6	R03G5.5
+T23G5.1	R03G5.5
+T25B9.9	R03G5.5
+W07G4.4	R03G5.5
+Y38F2AR.12	R03G5.5
+Y45G12C.2	R03G5.5
+Y46G5A.19	R03G5.5
+Y7A9A.1	R03G5.5
+ZK1320.1	R03G5.5
+ZK353.6	R03G5.5
+ZK546.11	R03G5.5
+ZK637.10	R03G5.5
+R07B1.4	R05H10.5
+R107.7	R05H10.5
+T03D8.6	R05H10.5
+T23G5.1	R05H10.5
+T25B9.9	R05H10.5
+W07G4.4	R05H10.5
+Y38F2AR.12	R05H10.5
+Y45G12C.2	R05H10.5
+Y46G5A.19	R05H10.5
+Y7A9A.1	R05H10.5
+ZK1320.1	R05H10.5
+ZK353.6	R05H10.5
+ZK546.11	R05H10.5
+ZK637.10	R05H10.5
+R107.7	R07B1.4
+T03D8.6	R07B1.4
+T23G5.1	R07B1.4
+T25B9.9	R07B1.4
+W07G4.4	R07B1.4
+Y38F2AR.12	R07B1.4
+Y45G12C.2	R07B1.4
+Y46G5A.19	R07B1.4
+Y7A9A.1	R07B1.4
+ZK1320.1	R07B1.4
+ZK353.6	R07B1.4
+ZK546.11	R07B1.4
+ZK637.10	R07B1.4
+T03D8.6	R107.7
+T23G5.1	R107.7
+T25B9.9	R107.7
+W07G4.4	R107.7
+Y38F2AR.12	R107.7
+Y45G12C.2	R107.7
+Y46G5A.19	R107.7
+Y7A9A.1	R107.7
+ZK1320.1	R107.7
+ZK353.6	R107.7
+ZK546.11	R107.7
+ZK637.10	R107.7
+T23G5.1	T03D8.6
+T25B9.9	T03D8.6
+W07G4.4	T03D8.6
+Y38F2AR.12	T03D8.6
+Y45G12C.2	T03D8.6
+Y46G5A.19	T03D8.6
+ZK1320.1	T03D8.6
+ZK353.6	T03D8.6
+ZK546.11	T03D8.6
+ZK637.10	T03D8.6
+T25B9.9	T23G5.1
+W07G4.4	T23G5.1
+Y38F2AR.12	T23G5.1
+Y45G12C.2	T23G5.1
+Y46G5A.19	T23G5.1
+Y7A9A.1	T23G5.1
+ZK1320.1	T23G5.1
+ZK353.6	T23G5.1
+ZK546.11	T23G5.1
+ZK637.10	T23G5.1
+W07G4.4	T25B9.9
+Y38F2AR.12	T25B9.9
+Y45G12C.2	T25B9.9
+Y46G5A.19	T25B9.9
+Y7A9A.1	T25B9.9
+ZK1320.1	T25B9.9
+ZK353.6	T25B9.9
+ZK546.11	T25B9.9
+ZK637.10	T25B9.9
+Y38F2AR.12	W07G4.4
+Y45G12C.2	W07G4.4
+Y46G5A.19	W07G4.4
+Y7A9A.1	W07G4.4
+ZK1320.1	W07G4.4
+ZK353.6	W07G4.4
+ZK546.11	W07G4.4
+ZK637.10	W07G4.4
+Y45G12C.2	Y38F2AR.12
+Y46G5A.19	Y38F2AR.12
+Y7A9A.1	Y38F2AR.12
+ZK1320.1	Y38F2AR.12
+ZK353.6	Y38F2AR.12
+ZK546.11	Y38F2AR.12
+ZK637.10	Y38F2AR.12
+Y46G5A.19	Y45G12C.2
+Y7A9A.1	Y45G12C.2
+ZK1320.1	Y45G12C.2
+ZK353.6	Y45G12C.2
+ZK546.11	Y45G12C.2
+ZK637.10	Y45G12C.2
+Y7A9A.1	Y46G5A.19
+ZK1320.1	Y46G5A.19
+ZK353.6	Y46G5A.19
+ZK546.11	Y46G5A.19
+ZK637.10	Y46G5A.19
+ZK1320.1	Y7A9A.1
+ZK353.6	Y7A9A.1
+ZK546.11	Y7A9A.1
+ZK637.10	Y7A9A.1
+ZK353.6	ZK1320.1
+ZK546.11	ZK1320.1
+ZK637.10	ZK1320.1
+ZK546.11	ZK353.6
+ZK637.10	ZK353.6
+ZK637.10	ZK546.11
+C23H3.7	B0310.5
+C50F7.10	B0310.5
+D2096.3	B0310.5
+D2096.4	B0310.5
+F14B4.2	B0310.5
+F57B10.7	B0310.5
+R05F9.6	B0310.5
+R06A4.8	B0310.5
+T04A8.7	B0310.5
+T05A12.2	B0310.5
+T22F3.3	B0310.5
+W05E10.4	B0310.5
+Y43F4B.5	B0310.5
+Y46G5A.31	B0310.5
+Y87G2A.8	B0310.5
+C23H3.7	C17G1.3
+C50F7.10	C17G1.3
+D2096.3	C17G1.3
+D2096.4	C17G1.3
+F14B4.2	C17G1.3
+F57B10.7	C17G1.3
+R05F9.6	C17G1.3
+R06A4.8	C17G1.3
+T04A8.7	C17G1.3
+T05A12.2	C17G1.3
+T22F3.3	C17G1.3
+W05E10.4	C17G1.3
+Y43F4B.5	C17G1.3
+Y46G5A.31	C17G1.3
+Y87G2A.8	C17G1.3
+C23H3.7	C18C4.3
+C50F7.10	C18C4.3
+D2096.3	C18C4.3
+D2096.4	C18C4.3
+F14B4.2	C18C4.3
+F57B10.7	C18C4.3
+R05F9.6	C18C4.3
+R06A4.8	C18C4.3
+T04A8.7	C18C4.3
+T05A12.2	C18C4.3
+T22F3.3	C18C4.3
+W05E10.4	C18C4.3
+Y43F4B.5	C18C4.3
+Y46G5A.31	C18C4.3
+Y87G2A.8	C18C4.3
+C50F7.10	C23H3.7
+D2096.3	C23H3.7
+D2096.4	C23H3.7
+F14B4.2	C23H3.7
+F29F11.1	C23H3.7
+F35H8.6	C23H3.7
+F39G3.1	C23H3.7
+F57B10.7	C23H3.7
+K08E3.5	C23H3.7
+M88.1	C23H3.7
+R05F9.6	C23H3.7
+R06A4.8	C23H3.7
+T04A8.7	C23H3.7
+T04H1.7	C23H3.7
+T04H1.8	C23H3.7
+T05A12.2	C23H3.7
+T07C5.1	C23H3.7
+T22F3.3	C23H3.7
+W05E10.4	C23H3.7
+Y105E8B.9	C23H3.7
+Y43F4B.5	C23H3.7
+Y46G5A.31	C23H3.7
+Y87G2A.8	C23H3.7
+D2096.3	C50F7.10
+D2096.4	C50F7.10
+F14B4.2	C50F7.10
+F29F11.1	C50F7.10
+F35H8.6	C50F7.10
+F39G3.1	C50F7.10
+F57B10.7	C50F7.10
+K08E3.5	C50F7.10
+M88.1	C50F7.10
+R05F9.6	C50F7.10
+R06A4.8	C50F7.10
+T04A8.7	C50F7.10
+T04H1.7	C50F7.10
+T04H1.8	C50F7.10
+T05A12.2	C50F7.10
+T07C5.1	C50F7.10
+T22F3.3	C50F7.10
+W05E10.4	C50F7.10
+Y105E8B.9	C50F7.10
+Y43F4B.5	C50F7.10
+Y46G5A.31	C50F7.10
+Y87G2A.8	C50F7.10
+D2096.4	D2096.3
+F29F11.1	D2096.3
+F35H8.6	D2096.3
+F39G3.1	D2096.3
+F57B10.7	D2096.3
+M88.1	D2096.3
+R06A4.8	D2096.3
+T04A8.7	D2096.3
+T04H1.7	D2096.3
+T04H1.8	D2096.3
+T05A12.2	D2096.3
+T07C5.1	D2096.3
+T22F3.3	D2096.3
+W05E10.4	D2096.3
+Y105E8B.9	D2096.3
+Y46G5A.31	D2096.3
+Y87G2A.8	D2096.3
+F14B4.2	D2096.4
+F29F11.1	D2096.4
+F35H8.6	D2096.4
+F39G3.1	D2096.4
+F57B10.7	D2096.4
+K08E3.5	D2096.4
+M88.1	D2096.4
+R05F9.6	D2096.4
+R06A4.8	D2096.4
+T04A8.7	D2096.4
+T04H1.7	D2096.4
+T04H1.8	D2096.4
+T05A12.2	D2096.4
+T07C5.1	D2096.4
+T22F3.3	D2096.4
+W05E10.4	D2096.4
+Y105E8B.9	D2096.4
+Y43F4B.5	D2096.4
+Y46G5A.31	D2096.4
+Y87G2A.8	D2096.4
+F29F11.1	F14B4.2
+F35H8.6	F14B4.2
+F39G3.1	F14B4.2
+F57B10.7	F14B4.2
+M88.1	F14B4.2
+R06A4.8	F14B4.2
+T04A8.7	F14B4.2
+T04H1.7	F14B4.2
+T04H1.8	F14B4.2
+T05A12.2	F14B4.2
+T07C5.1	F14B4.2
+T22F3.3	F14B4.2
+W05E10.4	F14B4.2
+Y105E8B.9	F14B4.2
+Y46G5A.31	F14B4.2
+F57B10.7	F29F11.1
+R05F9.6	F29F11.1
+R06A4.8	F29F11.1
+T04A8.7	F29F11.1
+T05A12.2	F29F11.1
+T22F3.3	F29F11.1
+W05E10.4	F29F11.1
+Y43F4B.5	F29F11.1
+Y46G5A.31	F29F11.1
+Y87G2A.8	F29F11.1
+F57B10.7	F35H8.6
+R05F9.6	F35H8.6
+R06A4.8	F35H8.6
+T04A8.7	F35H8.6
+T05A12.2	F35H8.6
+T22F3.3	F35H8.6
+W05E10.4	F35H8.6
+Y43F4B.5	F35H8.6
+Y46G5A.31	F35H8.6
+Y87G2A.8	F35H8.6
+F57B10.7	F39G3.1
+R05F9.6	F39G3.1
+R06A4.8	F39G3.1
+T04A8.7	F39G3.1
+T05A12.2	F39G3.1
+T22F3.3	F39G3.1
+W05E10.4	F39G3.1
+Y43F4B.5	F39G3.1
+Y46G5A.31	F39G3.1
+Y87G2A.8	F39G3.1
+K08E3.5	F57B10.7
+M88.1	F57B10.7
+R05F9.6	F57B10.7
+R06A4.8	F57B10.7
+T04A8.7	F57B10.7
+T04H1.7	F57B10.7
+T04H1.8	F57B10.7
+T05A12.2	F57B10.7
+T07C5.1	F57B10.7
+T22F3.3	F57B10.7
+W05E10.4	F57B10.7
+Y105E8B.9	F57B10.7
+Y43F4B.5	F57B10.7
+Y46G5A.31	F57B10.7
+Y87G2A.8	F57B10.7
+R06A4.8	K08E3.5
+T04A8.7	K08E3.5
+T05A12.2	K08E3.5
+T22F3.3	K08E3.5
+W05E10.4	K08E3.5
+Y46G5A.31	K08E3.5
+Y87G2A.8	K08E3.5
+R05F9.6	M88.1
+R06A4.8	M88.1
+T04A8.7	M88.1
+T05A12.2	M88.1
+T22F3.3	M88.1
+W05E10.4	M88.1
+Y43F4B.5	M88.1
+Y46G5A.31	M88.1
+Y87G2A.8	M88.1
+R06A4.8	R05F9.6
+T04A8.7	R05F9.6
+T04H1.7	R05F9.6
+T04H1.8	R05F9.6
+T05A12.2	R05F9.6
+T07C5.1	R05F9.6
+T22F3.3	R05F9.6
+W05E10.4	R05F9.6
+Y105E8B.9	R05F9.6
+Y46G5A.31	R05F9.6
+T04A8.7	R06A4.8
+T04H1.7	R06A4.8
+T04H1.8	R06A4.8
+T05A12.2	R06A4.8
+T07C5.1	R06A4.8
+T22F3.3	R06A4.8
+W05E10.4	R06A4.8
+Y105E8B.9	R06A4.8
+Y43F4B.5	R06A4.8
+Y46G5A.31	R06A4.8
+Y87G2A.8	R06A4.8
+T04H1.7	T04A8.7
+T04H1.8	T04A8.7
+T05A12.2	T04A8.7
+T07C5.1	T04A8.7
+T22F3.3	T04A8.7
+W05E10.4	T04A8.7
+Y105E8B.9	T04A8.7
+Y43F4B.5	T04A8.7
+Y46G5A.31	T04A8.7
+Y87G2A.8	T04A8.7
+T05A12.2	T04H1.7
+T22F3.3	T04H1.7
+W05E10.4	T04H1.7
+Y43F4B.5	T04H1.7
+Y46G5A.31	T04H1.7
+Y87G2A.8	T04H1.7
+T05A12.2	T04H1.8
+T22F3.3	T04H1.8
+W05E10.4	T04H1.8
+Y43F4B.5	T04H1.8
+Y46G5A.31	T04H1.8
+Y87G2A.8	T04H1.8
+T07C5.1	T05A12.2
+T22F3.3	T05A12.2
+W05E10.4	T05A12.2
+Y105E8B.9	T05A12.2
+Y43F4B.5	T05A12.2
+Y46G5A.31	T05A12.2
+Y87G2A.8	T05A12.2
+T22F3.3	T07C5.1
+W05E10.4	T07C5.1
+Y43F4B.5	T07C5.1
+Y46G5A.31	T07C5.1
+Y87G2A.8	T07C5.1
+W05E10.4	T22F3.3
+Y105E8B.9	T22F3.3
+Y43F4B.5	T22F3.3
+Y46G5A.31	T22F3.3
+Y87G2A.8	T22F3.3
+Y105E8B.9	W05E10.4
+Y43F4B.5	W05E10.4
+Y46G5A.31	W05E10.4
+Y87G2A.8	W05E10.4
+Y43F4B.5	Y105E8B.9
+Y46G5A.31	Y105E8B.9
+Y87G2A.8	Y105E8B.9
+Y46G5A.31	Y43F4B.5
+Y87G2A.8	Y46G5A.31
+B0416.6	B0361.8
+C03E10.4	B0361.8
+C08B11.8	B0361.8
+C08H9.3	B0361.8
+C10F3.6	B0361.8
+C14A4.3	B0361.8
+C52E4.5	B0361.8
+C55B7.2	B0361.8
+D2030.1	B0361.8
+F09E5.2	B0361.8
+F13H10.4	B0361.8
+F28D1.11	B0361.8
+F40F9.6	B0361.8
+F48E3.1	B0361.8
+F52D1.1	B0361.8
+F57B10.10	B0361.8
+F58H1.1	B0361.8
+H43I07.3	B0361.8
+K09E4.2	B0361.8
+M01F1.1	B0361.8
+M02B7.4	B0361.8
+R10D12.12	B0361.8
+T03G11.4	B0361.8
+T09A5.11	B0361.8
+T12A2.2	B0361.8
+T22D1.4	B0361.8
+T24D1.4	B0361.8
+T26A5.4	B0361.8
+Y60A3A.14	B0361.8
+Y66H1A.2	B0361.8
+Y73E7A.7	B0361.8
+ZC410.3	B0361.8
+ZC513.5	B0361.8
+ZK180.3	B0361.8
+ZK686.3	B0361.8
+C03E10.4	B0416.6
+C08B11.8	B0416.6
+C08H9.3	B0416.6
+C10F3.6	B0416.6
+C14A4.3	B0416.6
+C52E4.5	B0416.6
+C55B7.2	B0416.6
+D2030.1	B0416.6
+F09E5.2	B0416.6
+F13H10.4	B0416.6
+F28D1.11	B0416.6
+F40F9.6	B0416.6
+F48E3.1	B0416.6
+F52D1.1	B0416.6
+F57B10.10	B0416.6
+F58H1.1	B0416.6
+H43I07.3	B0416.6
+K09E4.2	B0416.6
+M01F1.1	B0416.6
+M02B7.4	B0416.6
+R10D12.12	B0416.6
+T03G11.4	B0416.6
+T09A5.11	B0416.6
+T12A2.2	B0416.6
+T22D1.4	B0416.6
+T24D1.4	B0416.6
+T26A5.4	B0416.6
+Y60A3A.14	B0416.6
+Y66H1A.2	B0416.6
+Y73E7A.7	B0416.6
+ZC410.3	B0416.6
+ZC513.5	B0416.6
+ZK180.3	B0416.6
+ZK686.3	B0416.6
+C08B11.8	C03E10.4
+C08H9.3	C03E10.4
+C10F3.6	C03E10.4
+C14A4.3	C03E10.4
+C52E4.5	C03E10.4
+C55B7.2	C03E10.4
+D2030.1	C03E10.4
+F09E5.2	C03E10.4
+F13H10.4	C03E10.4
+F28D1.11	C03E10.4
+F40F9.6	C03E10.4
+F48E3.1	C03E10.4
+F52D1.1	C03E10.4
+F57B10.10	C03E10.4
+F58H1.1	C03E10.4
+H43I07.3	C03E10.4
+K09E4.2	C03E10.4
+M01F1.1	C03E10.4
+M02B7.4	C03E10.4
+R10D12.12	C03E10.4
+T03G11.4	C03E10.4
+T09A5.11	C03E10.4
+T12A2.2	C03E10.4
+T22D1.4	C03E10.4
+T24D1.4	C03E10.4
+T26A5.4	C03E10.4
+Y60A3A.14	C03E10.4
+Y66H1A.2	C03E10.4
+Y73E7A.7	C03E10.4
+ZC410.3	C03E10.4
+ZC513.5	C03E10.4
+ZK180.3	C03E10.4
+ZK686.3	C03E10.4
+C08H9.3	C08B11.8
+C10F3.6	C08B11.8
+C14A4.3	C08B11.8
+C52E4.5	C08B11.8
+C55B7.2	C08B11.8
+D2030.1	C08B11.8
+F09E5.2	C08B11.8
+F13H10.4	C08B11.8
+F28D1.11	C08B11.8
+F40F9.6	C08B11.8
+F48E3.1	C08B11.8
+F52D1.1	C08B11.8
+F57B10.10	C08B11.8
+F58H1.1	C08B11.8
+H43I07.3	C08B11.8
+K09E4.2	C08B11.8
+M01F1.1	C08B11.8
+M02B7.4	C08B11.8
+R10D12.12	C08B11.8
+T03G11.4	C08B11.8
+T09A5.11	C08B11.8
+T12A2.2	C08B11.8
+T22D1.4	C08B11.8
+T24D1.4	C08B11.8
+T26A5.4	C08B11.8
+Y60A3A.14	C08B11.8
+Y66H1A.2	C08B11.8
+Y73E7A.7	C08B11.8
+ZC410.3	C08B11.8
+ZC513.5	C08B11.8
+ZK180.3	C08B11.8
+ZK686.3	C08B11.8
+C10F3.6	C08H9.3
+C14A4.3	C08H9.3
+C52E4.5	C08H9.3
+C55B7.2	C08H9.3
+D2030.1	C08H9.3
+F09E5.2	C08H9.3
+F13H10.4	C08H9.3
+F28D1.11	C08H9.3
+F40F9.6	C08H9.3
+F48E3.1	C08H9.3
+F52D1.1	C08H9.3
+F57B10.10	C08H9.3
+F58H1.1	C08H9.3
+H43I07.3	C08H9.3
+K09E4.2	C08H9.3
+M01F1.1	C08H9.3
+M02B7.4	C08H9.3
+R10D12.12	C08H9.3
+T03G11.4	C08H9.3
+T09A5.11	C08H9.3
+T12A2.2	C08H9.3
+T22D1.4	C08H9.3
+T24D1.4	C08H9.3
+T26A5.4	C08H9.3
+Y60A3A.14	C08H9.3
+Y66H1A.2	C08H9.3
+Y73E7A.7	C08H9.3
+ZC410.3	C08H9.3
+ZC513.5	C08H9.3
+ZK180.3	C08H9.3
+ZK686.3	C08H9.3
+C14A4.3	C10F3.6
+C52E4.5	C10F3.6
+C55B7.2	C10F3.6
+D2030.1	C10F3.6
+F09E5.2	C10F3.6
+F13H10.4	C10F3.6
+F28D1.11	C10F3.6
+F40F9.6	C10F3.6
+F48E3.1	C10F3.6
+F52D1.1	C10F3.6
+F57B10.10	C10F3.6
+F58H1.1	C10F3.6
+H43I07.3	C10F3.6
+K09E4.2	C10F3.6
+M01F1.1	C10F3.6
+M02B7.4	C10F3.6
+R10D12.12	C10F3.6
+T03G11.4	C10F3.6
+T09A5.11	C10F3.6
+T12A2.2	C10F3.6
+T22D1.4	C10F3.6
+T24D1.4	C10F3.6
+T26A5.4	C10F3.6
+Y60A3A.14	C10F3.6
+Y66H1A.2	C10F3.6
+Y73E7A.7	C10F3.6
+ZC410.3	C10F3.6
+ZC513.5	C10F3.6
+ZK180.3	C10F3.6
+ZK686.3	C10F3.6
+C52E4.5	C14A4.3
+C55B7.2	C14A4.3
+D2030.1	C14A4.3
+F09E5.2	C14A4.3
+F13H10.4	C14A4.3
+F28D1.11	C14A4.3
+F40F9.6	C14A4.3
+F48E3.1	C14A4.3
+F52D1.1	C14A4.3
+F57B10.10	C14A4.3
+F58H1.1	C14A4.3
+H43I07.3	C14A4.3
+K09E4.2	C14A4.3
+M01F1.1	C14A4.3
+M02B7.4	C14A4.3
+R10D12.12	C14A4.3
+T03G11.4	C14A4.3
+T09A5.11	C14A4.3
+T12A2.2	C14A4.3
+T22D1.4	C14A4.3
+T24D1.4	C14A4.3
+T26A5.4	C14A4.3
+Y60A3A.14	C14A4.3
+Y66H1A.2	C14A4.3
+Y73E7A.7	C14A4.3
+ZC410.3	C14A4.3
+ZC513.5	C14A4.3
+ZK180.3	C14A4.3
+ZK686.3	C14A4.3
+C55B7.2	C52E4.5
+D2030.1	C52E4.5
+F09E5.2	C52E4.5
+F13H10.4	C52E4.5
+F28D1.11	C52E4.5
+F40F9.6	C52E4.5
+F48E3.1	C52E4.5
+F52D1.1	C52E4.5
+F57B10.10	C52E4.5
+F58H1.1	C52E4.5
+H43I07.3	C52E4.5
+K09E4.2	C52E4.5
+M01F1.1	C52E4.5
+M02B7.4	C52E4.5
+R10D12.12	C52E4.5
+T03G11.4	C52E4.5
+T09A5.11	C52E4.5
+T12A2.2	C52E4.5
+T22D1.4	C52E4.5
+T24D1.4	C52E4.5
+T26A5.4	C52E4.5
+Y60A3A.14	C52E4.5
+Y66H1A.2	C52E4.5
+Y73E7A.7	C52E4.5
+ZC410.3	C52E4.5
+ZC513.5	C52E4.5
+ZK180.3	C52E4.5
+ZK686.3	C52E4.5
+D2030.1	C55B7.2
+F09E5.2	C55B7.2
+F13H10.4	C55B7.2
+F28D1.11	C55B7.2
+F40F9.6	C55B7.2
+F48E3.1	C55B7.2
+F52D1.1	C55B7.2
+F57B10.10	C55B7.2
+F58H1.1	C55B7.2
+H43I07.3	C55B7.2
+K09E4.2	C55B7.2
+M01F1.1	C55B7.2
+M02B7.4	C55B7.2
+R10D12.12	C55B7.2
+T03G11.4	C55B7.2
+T09A5.11	C55B7.2
+T12A2.2	C55B7.2
+T22D1.4	C55B7.2
+T24D1.4	C55B7.2
+T26A5.4	C55B7.2
+Y60A3A.14	C55B7.2
+Y66H1A.2	C55B7.2
+Y73E7A.7	C55B7.2
+ZC410.3	C55B7.2
+ZC513.5	C55B7.2
+ZK180.3	C55B7.2
+ZK686.3	C55B7.2
+F09E5.2	D2030.1
+F13H10.4	D2030.1
+F28D1.11	D2030.1
+F40F9.6	D2030.1
+F48E3.1	D2030.1
+F52D1.1	D2030.1
+F57B10.10	D2030.1
+F58H1.1	D2030.1
+H43I07.3	D2030.1
+K09E4.2	D2030.1
+M01F1.1	D2030.1
+M02B7.4	D2030.1
+R10D12.12	D2030.1
+T03G11.4	D2030.1
+T09A5.11	D2030.1
+T12A2.2	D2030.1
+T22D1.4	D2030.1
+T24D1.4	D2030.1
+T26A5.4	D2030.1
+Y60A3A.14	D2030.1
+Y66H1A.2	D2030.1
+Y73E7A.7	D2030.1
+ZC410.3	D2030.1
+ZC513.5	D2030.1
+ZK180.3	D2030.1
+ZK686.3	D2030.1
+F13H10.4	F09E5.2
+F28D1.11	F09E5.2
+F40F9.6	F09E5.2
+F48E3.1	F09E5.2
+F52D1.1	F09E5.2
+F57B10.10	F09E5.2
+F58H1.1	F09E5.2
+H43I07.3	F09E5.2
+K09E4.2	F09E5.2
+M01F1.1	F09E5.2
+M02B7.4	F09E5.2
+R10D12.12	F09E5.2
+T03G11.4	F09E5.2
+T09A5.11	F09E5.2
+T12A2.2	F09E5.2
+T22D1.4	F09E5.2
+T24D1.4	F09E5.2
+T26A5.4	F09E5.2
+Y60A3A.14	F09E5.2
+Y66H1A.2	F09E5.2
+Y73E7A.7	F09E5.2
+ZC410.3	F09E5.2
+ZC513.5	F09E5.2
+ZK180.3	F09E5.2
+ZK686.3	F09E5.2
+F28D1.11	F13H10.4
+F40F9.6	F13H10.4
+F48E3.1	F13H10.4
+F52D1.1	F13H10.4
+F57B10.10	F13H10.4
+F58H1.1	F13H10.4
+H43I07.3	F13H10.4
+K09E4.2	F13H10.4
+M01F1.1	F13H10.4
+M02B7.4	F13H10.4
+R10D12.12	F13H10.4
+T03G11.4	F13H10.4
+T09A5.11	F13H10.4
+T12A2.2	F13H10.4
+T22D1.4	F13H10.4
+T24D1.4	F13H10.4
+T26A5.4	F13H10.4
+Y60A3A.14	F13H10.4
+Y66H1A.2	F13H10.4
+Y73E7A.7	F13H10.4
+ZC410.3	F13H10.4
+ZC513.5	F13H10.4
+ZK180.3	F13H10.4
+ZK686.3	F13H10.4
+F40F9.6	F28D1.11
+F48E3.1	F28D1.11
+F52D1.1	F28D1.11
+F57B10.10	F28D1.11
+F58H1.1	F28D1.11
+H43I07.3	F28D1.11
+K09E4.2	F28D1.11
+M01F1.1	F28D1.11
+M02B7.4	F28D1.11
+R10D12.12	F28D1.11
+T03G11.4	F28D1.11
+T09A5.11	F28D1.11
+T12A2.2	F28D1.11
+T22D1.4	F28D1.11
+T24D1.4	F28D1.11
+T26A5.4	F28D1.11
+Y60A3A.14	F28D1.11
+Y66H1A.2	F28D1.11
+Y73E7A.7	F28D1.11
+ZC410.3	F28D1.11
+ZC513.5	F28D1.11
+ZK180.3	F28D1.11
+ZK686.3	F28D1.11
+F48E3.1	F40F9.6
+F52D1.1	F40F9.6
+F57B10.10	F40F9.6
+F58H1.1	F40F9.6
+H43I07.3	F40F9.6
+K09E4.2	F40F9.6
+M01F1.1	F40F9.6
+M02B7.4	F40F9.6
+R10D12.12	F40F9.6
+T03G11.4	F40F9.6
+T09A5.11	F40F9.6
+T12A2.2	F40F9.6
+T22D1.4	F40F9.6
+T24D1.4	F40F9.6
+T26A5.4	F40F9.6
+Y60A3A.14	F40F9.6
+Y66H1A.2	F40F9.6
+Y73E7A.7	F40F9.6
+ZC410.3	F40F9.6
+ZC513.5	F40F9.6
+ZK180.3	F40F9.6
+ZK686.3	F40F9.6
+F52D1.1	F48E3.1
+F57B10.10	F48E3.1
+F58H1.1	F48E3.1
+H43I07.3	F48E3.1
+K09E4.2	F48E3.1
+M01F1.1	F48E3.1
+M02B7.4	F48E3.1
+R10D12.12	F48E3.1
+T03G11.4	F48E3.1
+T09A5.11	F48E3.1
+T12A2.2	F48E3.1
+T22D1.4	F48E3.1
+T24D1.4	F48E3.1
+T26A5.4	F48E3.1
+Y60A3A.14	F48E3.1
+Y66H1A.2	F48E3.1
+Y73E7A.7	F48E3.1
+ZC410.3	F48E3.1
+ZC513.5	F48E3.1
+ZK180.3	F48E3.1
+ZK686.3	F48E3.1
+F57B10.10	F52D1.1
+F58H1.1	F52D1.1
+H43I07.3	F52D1.1
+K09E4.2	F52D1.1
+M01F1.1	F52D1.1
+M02B7.4	F52D1.1
+R10D12.12	F52D1.1
+T03G11.4	F52D1.1
+T09A5.11	F52D1.1
+T12A2.2	F52D1.1
+T22D1.4	F52D1.1
+T24D1.4	F52D1.1
+T26A5.4	F52D1.1
+Y60A3A.14	F52D1.1
+Y66H1A.2	F52D1.1
+Y73E7A.7	F52D1.1
+ZC410.3	F52D1.1
+ZC513.5	F52D1.1
+ZK180.3	F52D1.1
+ZK686.3	F52D1.1
+F58H1.1	F57B10.10
+H43I07.3	F57B10.10
+K09E4.2	F57B10.10
+M01F1.1	F57B10.10
+M02B7.4	F57B10.10
+R10D12.12	F57B10.10
+T03G11.4	F57B10.10
+T09A5.11	F57B10.10
+T12A2.2	F57B10.10
+T22D1.4	F57B10.10
+T24D1.4	F57B10.10
+T26A5.4	F57B10.10
+Y60A3A.14	F57B10.10
+Y66H1A.2	F57B10.10
+Y73E7A.7	F57B10.10
+ZC410.3	F57B10.10
+ZC513.5	F57B10.10
+ZK180.3	F57B10.10
+ZK686.3	F57B10.10
+H43I07.3	F58H1.1
+K09E4.2	F58H1.1
+M01F1.1	F58H1.1
+M02B7.4	F58H1.1
+R10D12.12	F58H1.1
+T03G11.4	F58H1.1
+T09A5.11	F58H1.1
+T12A2.2	F58H1.1
+T22D1.4	F58H1.1
+T24D1.4	F58H1.1
+T26A5.4	F58H1.1
+Y60A3A.14	F58H1.1
+Y66H1A.2	F58H1.1
+Y73E7A.7	F58H1.1
+ZC410.3	F58H1.1
+ZC513.5	F58H1.1
+ZK180.3	F58H1.1
+ZK686.3	F58H1.1
+K09E4.2	H43I07.3
+M01F1.1	H43I07.3
+M02B7.4	H43I07.3
+R10D12.12	H43I07.3
+T03G11.4	H43I07.3
+T09A5.11	H43I07.3
+T12A2.2	H43I07.3
+T22D1.4	H43I07.3
+T24D1.4	H43I07.3
+T26A5.4	H43I07.3
+Y60A3A.14	H43I07.3
+Y66H1A.2	H43I07.3
+Y73E7A.7	H43I07.3
+ZC410.3	H43I07.3
+ZC513.5	H43I07.3
+ZK180.3	H43I07.3
+ZK686.3	H43I07.3
+M01F1.1	K09E4.2
+M02B7.4	K09E4.2
+R10D12.12	K09E4.2
+T03G11.4	K09E4.2
+T09A5.11	K09E4.2
+T12A2.2	K09E4.2
+T22D1.4	K09E4.2
+T24D1.4	K09E4.2
+T26A5.4	K09E4.2
+Y60A3A.14	K09E4.2
+Y66H1A.2	K09E4.2
+Y73E7A.7	K09E4.2
+ZC410.3	K09E4.2
+ZC513.5	K09E4.2
+ZK180.3	K09E4.2
+ZK686.3	K09E4.2
+M02B7.4	M01F1.1
+R10D12.12	M01F1.1
+T03G11.4	M01F1.1
+T09A5.11	M01F1.1
+T12A2.2	M01F1.1
+T22D1.4	M01F1.1
+T24D1.4	M01F1.1
+T26A5.4	M01F1.1
+Y60A3A.14	M01F1.1
+Y66H1A.2	M01F1.1
+Y73E7A.7	M01F1.1
+ZC410.3	M01F1.1
+ZC513.5	M01F1.1
+ZK180.3	M01F1.1
+ZK686.3	M01F1.1
+R10D12.12	M02B7.4
+T03G11.4	M02B7.4
+T09A5.11	M02B7.4
+T12A2.2	M02B7.4
+T22D1.4	M02B7.4
+T24D1.4	M02B7.4
+T26A5.4	M02B7.4
+Y60A3A.14	M02B7.4
+Y66H1A.2	M02B7.4
+Y73E7A.7	M02B7.4
+ZC410.3	M02B7.4
+ZC513.5	M02B7.4
+ZK180.3	M02B7.4
+ZK686.3	M02B7.4
+T03G11.4	R10D12.12
+T09A5.11	R10D12.12
+T12A2.2	R10D12.12
+T22D1.4	R10D12.12
+T24D1.4	R10D12.12
+T26A5.4	R10D12.12
+Y60A3A.14	R10D12.12
+Y66H1A.2	R10D12.12
+Y73E7A.7	R10D12.12
+ZC410.3	R10D12.12
+ZC513.5	R10D12.12
+ZK180.3	R10D12.12
+ZK686.3	R10D12.12
+T09A5.11	T03G11.4
+T12A2.2	T03G11.4
+T22D1.4	T03G11.4
+T24D1.4	T03G11.4
+T26A5.4	T03G11.4
+Y60A3A.14	T03G11.4
+Y66H1A.2	T03G11.4
+Y73E7A.7	T03G11.4
+ZC410.3	T03G11.4
+ZC513.5	T03G11.4
+ZK180.3	T03G11.4
+ZK686.3	T03G11.4
+T12A2.2	T09A5.11
+T22D1.4	T09A5.11
+T24D1.4	T09A5.11
+T26A5.4	T09A5.11
+Y60A3A.14	T09A5.11
+Y66H1A.2	T09A5.11
+Y73E7A.7	T09A5.11
+ZC410.3	T09A5.11
+ZC513.5	T09A5.11
+ZK180.3	T09A5.11
+ZK686.3	T09A5.11
+T22D1.4	T12A2.2
+T24D1.4	T12A2.2
+T26A5.4	T12A2.2
+Y60A3A.14	T12A2.2
+Y66H1A.2	T12A2.2
+Y73E7A.7	T12A2.2
+ZC410.3	T12A2.2
+ZC513.5	T12A2.2
+ZK180.3	T12A2.2
+ZK686.3	T12A2.2
+T24D1.4	T22D1.4
+T26A5.4	T22D1.4
+Y60A3A.14	T22D1.4
+Y66H1A.2	T22D1.4
+Y73E7A.7	T22D1.4
+ZC410.3	T22D1.4
+ZC513.5	T22D1.4
+ZK180.3	T22D1.4
+ZK686.3	T22D1.4
+T26A5.4	T24D1.4
+Y60A3A.14	T24D1.4
+Y66H1A.2	T24D1.4
+Y73E7A.7	T24D1.4
+ZC410.3	T24D1.4
+ZC513.5	T24D1.4
+ZK180.3	T24D1.4
+ZK686.3	T24D1.4
+Y60A3A.14	T26A5.4
+Y66H1A.2	T26A5.4
+Y73E7A.7	T26A5.4
+ZC410.3	T26A5.4
+ZC513.5	T26A5.4
+ZK180.3	T26A5.4
+ZK686.3	T26A5.4
+Y66H1A.2	Y60A3A.14
+Y73E7A.7	Y60A3A.14
+ZC410.3	Y60A3A.14
+ZC513.5	Y60A3A.14
+ZK180.3	Y60A3A.14
+ZK686.3	Y60A3A.14
+Y73E7A.7	Y66H1A.2
+ZC410.3	Y66H1A.2
+ZC513.5	Y66H1A.2
+ZK180.3	Y66H1A.2
+ZK686.3	Y66H1A.2
+ZC410.3	Y73E7A.7
+ZC513.5	Y73E7A.7
+ZK180.3	Y73E7A.7
+ZK686.3	Y73E7A.7
+ZC513.5	ZC410.3
+ZK180.3	ZC410.3
+ZK686.3	ZC410.3
+ZK180.3	ZC513.5
+ZK686.3	ZC513.5
+ZK686.3	ZK180.3
+C33C12.3	C14C11.3
+C33C12.8	C14C11.3
+C33G3.4	C14C11.3
+F01F1.10	C14C11.3
+F11E6.1	C14C11.3
+F55D10.1	C14C11.3
+R04B3.2	C14C11.3
+T19B10.3	C14C11.3
+W03G11.3	C14C11.3
+Y4C6B.6	C14C11.3
+C33C12.8	C33C12.3
+C33G3.4	C33C12.3
+F01F1.10	C33C12.3
+F11E6.1	C33C12.3
+F55D10.1	C33C12.3
+R04B3.2	C33C12.3
+T14F9.3	C33C12.3
+T19B10.3	C33C12.3
+W03G11.3	C33C12.3
+Y39A1C.4	C33C12.3
+Y4C6B.6	C33C12.3
+Y51F10.5	C33C12.3
+Y70D2A.2	C33C12.3
+C33G3.4	C33C12.8
+F01F1.10	C33C12.8
+F11E6.1	C33C12.8
+F55D10.1	C33C12.8
+R04B3.2	C33C12.8
+T14F9.3	C33C12.8
+T19B10.3	C33C12.8
+W03G11.3	C33C12.8
+Y39A1C.4	C33C12.8
+Y4C6B.6	C33C12.8
+Y51F10.5	C33C12.8
+Y70D2A.2	C33C12.8
+F01F1.10	C33G3.4
+F11E6.1	C33G3.4
+F55D10.1	C33G3.4
+R04B3.2	C33G3.4
+T14F9.3	C33G3.4
+T19B10.3	C33G3.4
+W03G11.3	C33G3.4
+Y39A1C.4	C33G3.4
+Y4C6B.6	C33G3.4
+Y51F10.5	C33G3.4
+Y70D2A.2	C33G3.4
+F11E6.1	F01F1.10
+F55D10.1	F01F1.10
+R04B3.2	F01F1.10
+T14F9.3	F01F1.10
+T19B10.3	F01F1.10
+W03G11.3	F01F1.10
+Y39A1C.4	F01F1.10
+Y4C6B.6	F01F1.10
+Y51F10.5	F01F1.10
+Y70D2A.2	F01F1.10
+F55D10.1	F11E6.1
+R04B3.2	F11E6.1
+T14F9.3	F11E6.1
+T19B10.3	F11E6.1
+W03G11.3	F11E6.1
+Y39A1C.4	F11E6.1
+Y4C6B.6	F11E6.1
+Y51F10.5	F11E6.1
+Y70D2A.2	F11E6.1
+R04B3.2	F55D10.1
+T14F9.3	F55D10.1
+T19B10.3	F55D10.1
+W03G11.3	F55D10.1
+Y39A1C.4	F55D10.1
+Y4C6B.6	F55D10.1
+Y51F10.5	F55D10.1
+Y70D2A.2	F55D10.1
+T14F9.3	R04B3.2
+T19B10.3	R04B3.2
+W03G11.3	R04B3.2
+Y39A1C.4	R04B3.2
+Y4C6B.6	R04B3.2
+Y51F10.5	R04B3.2
+Y70D2A.2	R04B3.2
+T19B10.3	T14F9.3
+W03G11.3	T14F9.3
+Y4C6B.6	T14F9.3
+W03G11.3	T19B10.3
+Y39A1C.4	T19B10.3
+Y4C6B.6	T19B10.3
+Y51F10.5	T19B10.3
+Y70D2A.2	T19B10.3
+Y39A1C.4	W03G11.3
+Y4C6B.6	W03G11.3
+Y51F10.5	W03G11.3
+Y70D2A.2	W03G11.3
+Y4C6B.6	Y39A1C.4
+Y51F10.5	Y4C6B.6
+Y70D2A.2	Y4C6B.6
+T15D6.2	C38H2.2
+Y116F11B.12	C38H2.2
+Y39E4B.12	C38H2.2
+Y45F10D.3	C38H2.2
+Y46H3A.6	C38H2.2
+ZK688.8	C38H2.2
+Y116F11B.12	T15D6.2
+Y39E4B.12	T15D6.2
+Y45F10D.3	T15D6.2
+Y46H3A.6	T15D6.2
+ZK688.8	T15D6.2
+Y39E4B.12	Y116F11B.12
+Y45F10D.3	Y116F11B.12
+Y46H3A.6	Y116F11B.12
+ZK688.8	Y116F11B.12
+Y45F10D.3	Y39E4B.12
+Y46H3A.6	Y39E4B.12
+ZK688.8	Y39E4B.12
+Y46H3A.6	Y45F10D.3
+ZK688.8	Y45F10D.3
+ZK688.8	Y46H3A.6
+C15C7.7	B0310.5
+K04G7.3	B0310.5
+K10G9.3	B0310.5
+M70.4	B0310.5
+Y73E7A.7	B0310.5
+ZC250.2	B0310.5
+C17G1.3	C15C7.7
+C18C4.3	C15C7.7
+F35H8.6	C15C7.7
+F39G3.1	C15C7.7
+K04G7.3	C15C7.7
+K10G9.3	C15C7.7
+M70.4	C15C7.7
+M88.1	C15C7.7
+T04H1.7	C15C7.7
+T04H1.8	C15C7.7
+T07C5.1	C15C7.7
+Y73E7A.7	C15C7.7
+ZC250.2	C15C7.7
+K04G7.3	C17G1.3
+K10G9.3	C17G1.3
+M70.4	C17G1.3
+Y73E7A.7	C17G1.3
+ZC250.2	C17G1.3
+K04G7.3	C18C4.3
+K10G9.3	C18C4.3
+M70.4	C18C4.3
+Y73E7A.7	C18C4.3
+ZC250.2	C18C4.3
+K04G7.3	F35H8.6
+K10G9.3	F35H8.6
+M70.4	F35H8.6
+Y73E7A.7	F35H8.6
+ZC250.2	F35H8.6
+K04G7.3	F39G3.1
+K10G9.3	F39G3.1
+M70.4	F39G3.1
+Y73E7A.7	F39G3.1
+ZC250.2	F39G3.1
+K10G9.3	K04G7.3
+M70.4	K04G7.3
+M88.1	K04G7.3
+T04H1.7	K04G7.3
+T04H1.8	K04G7.3
+T07C5.1	K04G7.3
+Y73E7A.7	K04G7.3
+ZC250.2	K04G7.3
+M70.4	K10G9.3
+M88.1	K10G9.3
+T04H1.7	K10G9.3
+T04H1.8	K10G9.3
+T07C5.1	K10G9.3
+Y73E7A.7	K10G9.3
+ZC250.2	K10G9.3
+M88.1	M70.4
+T04H1.7	M70.4
+T04H1.8	M70.4
+T07C5.1	M70.4
+Y73E7A.7	M70.4
+ZC250.2	M70.4
+Y73E7A.7	M88.1
+ZC250.2	M88.1
+Y73E7A.7	T04H1.7
+ZC250.2	T04H1.7
+Y73E7A.7	T04H1.8
+ZC250.2	T04H1.8
+Y73E7A.7	T07C5.1
+ZC250.2	T07C5.1
+ZC250.2	Y73E7A.7
+C01F1.3	B0024.12
+C04F6.3	B0024.12
+C05C8.7	B0024.12
+C36A4.4	B0024.12
+C42C1.5	B0024.12
+C47B2.6	B0024.12
+C53B4.7	B0024.12
+D2096.4	B0024.12
+F07A11.2	B0024.12
+F14B4.2	B0024.12
+F21D5.1	B0024.12
+F22B3.4	B0024.12
+F29F11.1	B0024.12
+F48A11.1	B0024.12
+F52B11.2	B0024.12
+F56H6.5	B0024.12
+F59B2.3	B0024.12
+K03H1.13	B0024.12
+K08E3.5	B0024.12
+M01D7.4	B0024.12
+R01H2.5	B0024.12
+R05F9.6	B0024.12
+T03F6.3	B0024.12
+T05H4.4	B0024.12
+T05H4.5	B0024.12
+T14F9.3	B0024.12
+T25G3.2	B0024.12
+W06B4.2	B0024.12
+Y43F4B.5	B0024.12
+Y47D9A.1	B0024.12
+Y87G2A.8	B0024.12
+ZK1058.3	B0024.12
+ZK632.4	B0024.12
+C04F6.3	C01F1.3
+C05C8.7	C01F1.3
+C36A4.4	C01F1.3
+C42C1.5	C01F1.3
+C47B2.6	C01F1.3
+C53B4.7	C01F1.3
+D2096.4	C01F1.3
+F07A11.2	C01F1.3
+F14B4.2	C01F1.3
+F21D5.1	C01F1.3
+F22B3.4	C01F1.3
+F29F11.1	C01F1.3
+F48A11.1	C01F1.3
+F52B11.2	C01F1.3
+F56H6.5	C01F1.3
+F59B2.3	C01F1.3
+K03H1.13	C01F1.3
+K08E3.5	C01F1.3
+M01D7.4	C01F1.3
+R01H2.5	C01F1.3
+R05F9.6	C01F1.3
+T03F6.3	C01F1.3
+T05H4.4	C01F1.3
+T05H4.5	C01F1.3
+T14F9.3	C01F1.3
+T25G3.2	C01F1.3
+W06B4.2	C01F1.3
+Y43F4B.5	C01F1.3
+Y47D9A.1	C01F1.3
+Y87G2A.8	C01F1.3
+ZK1058.3	C01F1.3
+ZK632.4	C01F1.3
+C05C8.7	C04F6.3
+C36A4.4	C04F6.3
+C42C1.5	C04F6.3
+C47B2.6	C04F6.3
+C53B4.7	C04F6.3
+D2096.4	C04F6.3
+F07A11.2	C04F6.3
+F14B4.2	C04F6.3
+F21D5.1	C04F6.3
+F22B3.4	C04F6.3
+F29F11.1	C04F6.3
+F48A11.1	C04F6.3
+F52B11.2	C04F6.3
+F56H6.5	C04F6.3
+F59B2.3	C04F6.3
+K03H1.13	C04F6.3
+K08E3.5	C04F6.3
+M01D7.4	C04F6.3
+R01H2.5	C04F6.3
+R05F9.6	C04F6.3
+T03F6.3	C04F6.3
+T05H4.4	C04F6.3
+T05H4.5	C04F6.3
+T14F9.3	C04F6.3
+T25G3.2	C04F6.3
+W06B4.2	C04F6.3
+Y43F4B.5	C04F6.3
+Y47D9A.1	C04F6.3
+Y87G2A.8	C04F6.3
+ZK1058.3	C04F6.3
+ZK632.4	C04F6.3
+C36A4.4	C05C8.7
+C47B2.6	C05C8.7
+D2096.4	C05C8.7
+F07A11.2	C05C8.7
+F21D5.1	C05C8.7
+F22B3.4	C05C8.7
+F29F11.1	C05C8.7
+F48A11.1	C05C8.7
+F59B2.3	C05C8.7
+K08E3.5	C05C8.7
+M01D7.4	C05C8.7
+R05F9.6	C05C8.7
+T03F6.3	C05C8.7
+T05H4.4	C05C8.7
+T05H4.5	C05C8.7
+T14F9.3	C05C8.7
+T25G3.2	C05C8.7
+W06B4.2	C05C8.7
+Y43F4B.5	C05C8.7
+Y87G2A.8	C05C8.7
+ZK1058.3	C05C8.7
+C42C1.5	C36A4.4
+C47B2.6	C36A4.4
+C53B4.7	C36A4.4
+D2096.4	C36A4.4
+F07A11.2	C36A4.4
+F14B4.2	C36A4.4
+F21D5.1	C36A4.4
+F22B3.4	C36A4.4
+F29F11.1	C36A4.4
+F48A11.1	C36A4.4
+F52B11.2	C36A4.4
+F56H6.5	C36A4.4
+F59B2.3	C36A4.4
+K03H1.13	C36A4.4
+K08E3.5	C36A4.4
+M01D7.4	C36A4.4
+R01H2.5	C36A4.4
+R05F9.6	C36A4.4
+T03F6.3	C36A4.4
+T05H4.4	C36A4.4
+T05H4.5	C36A4.4
+T14F9.3	C36A4.4
+T25G3.2	C36A4.4
+W06B4.2	C36A4.4
+Y43F4B.5	C36A4.4
+Y47D9A.1	C36A4.4
+Y87G2A.8	C36A4.4
+ZK1058.3	C36A4.4
+ZK632.4	C36A4.4
+C47B2.6	C42C1.5
+D2096.4	C42C1.5
+F07A11.2	C42C1.5
+F21D5.1	C42C1.5
+F22B3.4	C42C1.5
+F29F11.1	C42C1.5
+F48A11.1	C42C1.5
+F59B2.3	C42C1.5
+K08E3.5	C42C1.5
+M01D7.4	C42C1.5
+R05F9.6	C42C1.5
+T03F6.3	C42C1.5
+T05H4.4	C42C1.5
+T05H4.5	C42C1.5
+T14F9.3	C42C1.5
+T25G3.2	C42C1.5
+W06B4.2	C42C1.5
+Y43F4B.5	C42C1.5
+Y87G2A.8	C42C1.5
+ZK1058.3	C42C1.5
+C53B4.7	C47B2.6
+D2096.4	C47B2.6
+F07A11.2	C47B2.6
+F21D5.1	C47B2.6
+F22B3.4	C47B2.6
+F29F11.1	C47B2.6
+F48A11.1	C47B2.6
+F52B11.2	C47B2.6
+F56H6.5	C47B2.6
+F59B2.3	C47B2.6
+K03H1.13	C47B2.6
+R01H2.5	C47B2.6
+T03F6.3	C47B2.6
+T05H4.4	C47B2.6
+T05H4.5	C47B2.6
+T14F9.3	C47B2.6
+T25G3.2	C47B2.6
+W06B4.2	C47B2.6
+Y47D9A.1	C47B2.6
+Y87G2A.8	C47B2.6
+ZK632.4	C47B2.6
+D2096.4	C53B4.7
+F07A11.2	C53B4.7
+F21D5.1	C53B4.7
+F22B3.4	C53B4.7
+F29F11.1	C53B4.7
+F48A11.1	C53B4.7
+F59B2.3	C53B4.7
+K08E3.5	C53B4.7
+M01D7.4	C53B4.7
+R05F9.6	C53B4.7
+T03F6.3	C53B4.7
+T05H4.4	C53B4.7
+T05H4.5	C53B4.7
+T14F9.3	C53B4.7
+T25G3.2	C53B4.7
+W06B4.2	C53B4.7
+Y43F4B.5	C53B4.7
+Y87G2A.8	C53B4.7
+ZK1058.3	C53B4.7
+F07A11.2	D2096.4
+F21D5.1	D2096.4
+F22B3.4	D2096.4
+F48A11.1	D2096.4
+F52B11.2	D2096.4
+F56H6.5	D2096.4
+F59B2.3	D2096.4
+K03H1.13	D2096.4
+M01D7.4	D2096.4
+R01H2.5	D2096.4
+T03F6.3	D2096.4
+T05H4.4	D2096.4
+T05H4.5	D2096.4
+T14F9.3	D2096.4
+T25G3.2	D2096.4
+W06B4.2	D2096.4
+Y47D9A.1	D2096.4
+ZK1058.3	D2096.4
+ZK632.4	D2096.4
+F14B4.2	F07A11.2
+F21D5.1	F07A11.2
+F29F11.1	F07A11.2
+F48A11.1	F07A11.2
+F52B11.2	F07A11.2
+F56H6.5	F07A11.2
+F59B2.3	F07A11.2
+K03H1.13	F07A11.2
+K08E3.5	F07A11.2
+M01D7.4	F07A11.2
+R01H2.5	F07A11.2
+R05F9.6	F07A11.2
+T03F6.3	F07A11.2
+T05H4.4	F07A11.2
+T05H4.5	F07A11.2
+T14F9.3	F07A11.2
+T25G3.2	F07A11.2
+W06B4.2	F07A11.2
+Y43F4B.5	F07A11.2
+Y47D9A.1	F07A11.2
+Y87G2A.8	F07A11.2
+ZK1058.3	F07A11.2
+ZK632.4	F07A11.2
+F21D5.1	F14B4.2
+F22B3.4	F14B4.2
+F48A11.1	F14B4.2
+F59B2.3	F14B4.2
+T03F6.3	F14B4.2
+T05H4.4	F14B4.2
+T05H4.5	F14B4.2
+T14F9.3	F14B4.2
+T25G3.2	F14B4.2
+W06B4.2	F14B4.2
+F22B3.4	F21D5.1
+F29F11.1	F21D5.1
+F48A11.1	F21D5.1
+F52B11.2	F21D5.1
+F56H6.5	F21D5.1
+F59B2.3	F21D5.1
+K03H1.13	F21D5.1
+K08E3.5	F21D5.1
+M01D7.4	F21D5.1
+R01H2.5	F21D5.1
+T03F6.3	F21D5.1
+T05H4.4	F21D5.1
+T05H4.5	F21D5.1
+T14F9.3	F21D5.1
+T25G3.2	F21D5.1
+W06B4.2	F21D5.1
+Y47D9A.1	F21D5.1
+Y87G2A.8	F21D5.1
+ZK1058.3	F21D5.1
+ZK632.4	F21D5.1
+F29F11.1	F22B3.4
+F48A11.1	F22B3.4
+F52B11.2	F22B3.4
+F56H6.5	F22B3.4
+F59B2.3	F22B3.4
+K03H1.13	F22B3.4
+K08E3.5	F22B3.4
+M01D7.4	F22B3.4
+R01H2.5	F22B3.4
+R05F9.6	F22B3.4
+T03F6.3	F22B3.4
+T05H4.4	F22B3.4
+T05H4.5	F22B3.4
+T14F9.3	F22B3.4
+T25G3.2	F22B3.4
+W06B4.2	F22B3.4
+Y43F4B.5	F22B3.4
+Y47D9A.1	F22B3.4
+Y87G2A.8	F22B3.4
+ZK1058.3	F22B3.4
+ZK632.4	F22B3.4
+F48A11.1	F29F11.1
+F52B11.2	F29F11.1
+F56H6.5	F29F11.1
+F59B2.3	F29F11.1
+K03H1.13	F29F11.1
+M01D7.4	F29F11.1
+R01H2.5	F29F11.1
+T03F6.3	F29F11.1
+T05H4.4	F29F11.1
+T05H4.5	F29F11.1
+T14F9.3	F29F11.1
+T25G3.2	F29F11.1
+W06B4.2	F29F11.1
+Y47D9A.1	F29F11.1
+ZK1058.3	F29F11.1
+ZK632.4	F29F11.1
+F52B11.2	F48A11.1
+F56H6.5	F48A11.1
+F59B2.3	F48A11.1
+K03H1.13	F48A11.1
+K08E3.5	F48A11.1
+M01D7.4	F48A11.1
+R01H2.5	F48A11.1
+R05F9.6	F48A11.1
+T03F6.3	F48A11.1
+T05H4.4	F48A11.1
+T05H4.5	F48A11.1
+T14F9.3	F48A11.1
+T25G3.2	F48A11.1
+W06B4.2	F48A11.1
+Y43F4B.5	F48A11.1
+Y47D9A.1	F48A11.1
+Y87G2A.8	F48A11.1
+ZK1058.3	F48A11.1
+ZK632.4	F48A11.1
+F59B2.3	F52B11.2
+K08E3.5	F52B11.2
+M01D7.4	F52B11.2
+R05F9.6	F52B11.2
+T03F6.3	F52B11.2
+T05H4.4	F52B11.2
+T05H4.5	F52B11.2
+T14F9.3	F52B11.2
+T25G3.2	F52B11.2
+W06B4.2	F52B11.2
+Y43F4B.5	F52B11.2
+Y87G2A.8	F52B11.2
+ZK1058.3	F52B11.2
+F59B2.3	F56H6.5
+K08E3.5	F56H6.5
+M01D7.4	F56H6.5
+R05F9.6	F56H6.5
+T03F6.3	F56H6.5
+T05H4.4	F56H6.5
+T05H4.5	F56H6.5
+T14F9.3	F56H6.5
+T25G3.2	F56H6.5
+W06B4.2	F56H6.5
+Y43F4B.5	F56H6.5
+Y87G2A.8	F56H6.5
+ZK1058.3	F56H6.5
+K03H1.13	F59B2.3
+K08E3.5	F59B2.3
+M01D7.4	F59B2.3
+R01H2.5	F59B2.3
+R05F9.6	F59B2.3
+T03F6.3	F59B2.3
+T05H4.4	F59B2.3
+T05H4.5	F59B2.3
+T14F9.3	F59B2.3
+T25G3.2	F59B2.3
+W06B4.2	F59B2.3
+Y43F4B.5	F59B2.3
+Y47D9A.1	F59B2.3
+Y87G2A.8	F59B2.3
+ZK1058.3	F59B2.3
+ZK632.4	F59B2.3
+K08E3.5	K03H1.13
+M01D7.4	K03H1.13
+R05F9.6	K03H1.13
+T03F6.3	K03H1.13
+T05H4.4	K03H1.13
+T05H4.5	K03H1.13
+T14F9.3	K03H1.13
+T25G3.2	K03H1.13
+W06B4.2	K03H1.13
+Y43F4B.5	K03H1.13
+Y87G2A.8	K03H1.13
+ZK1058.3	K03H1.13
+R01H2.5	K08E3.5
+T03F6.3	K08E3.5
+T05H4.4	K08E3.5
+T05H4.5	K08E3.5
+T14F9.3	K08E3.5
+T25G3.2	K08E3.5
+W06B4.2	K08E3.5
+Y47D9A.1	K08E3.5
+ZK632.4	K08E3.5
+R01H2.5	M01D7.4
+T03F6.3	M01D7.4
+T05H4.4	M01D7.4
+T05H4.5	M01D7.4
+T14F9.3	M01D7.4
+T25G3.2	M01D7.4
+W06B4.2	M01D7.4
+Y47D9A.1	M01D7.4
+Y87G2A.8	M01D7.4
+ZK632.4	M01D7.4
+R05F9.6	R01H2.5
+T03F6.3	R01H2.5
+T05H4.4	R01H2.5
+T05H4.5	R01H2.5
+T14F9.3	R01H2.5
+T25G3.2	R01H2.5
+W06B4.2	R01H2.5
+Y43F4B.5	R01H2.5
+Y87G2A.8	R01H2.5
+ZK1058.3	R01H2.5
+T03F6.3	R05F9.6
+T05H4.4	R05F9.6
+T05H4.5	R05F9.6
+T14F9.3	R05F9.6
+T25G3.2	R05F9.6
+W06B4.2	R05F9.6
+Y47D9A.1	R05F9.6
+ZK632.4	R05F9.6
+T05H4.4	T03F6.3
+T05H4.5	T03F6.3
+T14F9.3	T03F6.3
+T25G3.2	T03F6.3
+W06B4.2	T03F6.3
+Y43F4B.5	T03F6.3
+Y47D9A.1	T03F6.3
+Y87G2A.8	T03F6.3
+ZK1058.3	T03F6.3
+ZK632.4	T03F6.3
+T05H4.5	T05H4.4
+T14F9.3	T05H4.4
+T25G3.2	T05H4.4
+W06B4.2	T05H4.4
+Y43F4B.5	T05H4.4
+Y47D9A.1	T05H4.4
+Y87G2A.8	T05H4.4
+ZK1058.3	T05H4.4
+ZK632.4	T05H4.4
+T14F9.3	T05H4.5
+T25G3.2	T05H4.5
+W06B4.2	T05H4.5
+Y43F4B.5	T05H4.5
+Y47D9A.1	T05H4.5
+Y87G2A.8	T05H4.5
+ZK1058.3	T05H4.5
+ZK632.4	T05H4.5
+T25G3.2	T14F9.3
+W06B4.2	T14F9.3
+Y43F4B.5	T14F9.3
+Y47D9A.1	T14F9.3
+Y87G2A.8	T14F9.3
+ZK1058.3	T14F9.3
+ZK632.4	T14F9.3
+W06B4.2	T25G3.2
+Y43F4B.5	T25G3.2
+Y47D9A.1	T25G3.2
+Y87G2A.8	T25G3.2
+ZK1058.3	T25G3.2
+ZK632.4	T25G3.2
+Y43F4B.5	W06B4.2
+Y47D9A.1	W06B4.2
+Y87G2A.8	W06B4.2
+ZK1058.3	W06B4.2
+ZK632.4	W06B4.2
+Y47D9A.1	Y43F4B.5
+ZK632.4	Y43F4B.5
+Y87G2A.8	Y47D9A.1
+ZK1058.3	Y47D9A.1
+ZK1058.3	Y87G2A.8
+ZK632.4	Y87G2A.8
+ZK632.4	ZK1058.3
+F53B1.4	C14F11.6
+T14F9.3	K09E4.4
+T19B10.3	K09E4.4
+Y105E8B.9	K09E4.4
+Y105E8B.9	T14F9.3
+Y105E8B.9	T19B10.3
+R10E11.4	PAR2.4
+T24D1.1	PAR2.4
+Y110A2AL.14	PAR2.4
+Y50D4C.4	PAR2.4
+ZK1307.5	PAR2.4
+T24D1.1	R10E11.4
+Y110A2AL.14	R10E11.4
+Y50D4C.4	R10E11.4
+ZK1307.5	R10E11.4
+Y110A2AL.14	T24D1.1
+Y50D4C.4	T24D1.1
+ZK1307.5	T24D1.1
+Y50D4C.4	Y110A2AL.14
+ZK1307.5	Y110A2AL.14
+ZK1307.5	Y50D4C.4
+F22F7.6	C10F3.6
+Y73E7A.7	F22F7.6
+C34F6.4	B0285.5
+F12F6.3	B0285.5
+F52B10.2	B0285.5
+K01G5.6	B0285.5
+R10E11.4	B0285.5
+Y110A2AL.14	B0285.5
+Y50D4C.4	B0285.5
+ZK1307.5	B0285.5
+F12F6.3	C34F6.4
+F52B10.2	C34F6.4
+K01G5.6	C34F6.4
+R10E11.4	C34F6.4
+Y110A2AL.14	C34F6.4
+Y50D4C.4	C34F6.4
+ZK1307.5	C34F6.4
+F52B10.2	F12F6.3
+R10E11.4	F12F6.3
+Y110A2AL.14	F12F6.3
+Y50D4C.4	F12F6.3
+ZK1307.5	F12F6.3
+K01G5.6	F52B10.2
+R10E11.4	F52B10.2
+Y110A2AL.14	F52B10.2
+Y50D4C.4	F52B10.2
+ZK1307.5	F52B10.2
+R10E11.4	K01G5.6
+Y110A2AL.14	K01G5.6
+Y50D4C.4	K01G5.6
+ZK1307.5	K01G5.6
+C13B9.2	C09E10.2
+C54G7.2	C09E10.2
+F01F1.6	C09E10.2
+F08F3.2	C09E10.2
+F42A9.1	C09E10.2
+F49H12.6	C09E10.2
+F52C9.3	C09E10.2
+F54D8.3	C09E10.2
+F54G8.2	C09E10.2
+F59F4.4	C09E10.2
+H19N07.4	C09E10.2
+H37A05.1	C09E10.2
+K04F1.15	C09E10.2
+K06A1.6	C09E10.2
+R07E3.5	C09E10.2
+R11F4.1	C09E10.2
+T05H4.1	C09E10.2
+T05H4.13	C09E10.2
+T06E8.1	C09E10.2
+W02H5.8	C09E10.2
+Y39G8B.1	C09E10.2
+Y69F12A.2	C09E10.2
+ZK40.1	C09E10.2
+C54G7.2	C13B9.2
+F08F3.2	C13B9.2
+F42A9.1	C13B9.2
+F49H12.6	C13B9.2
+F52C9.3	C13B9.2
+F54D8.3	C13B9.2
+F54G8.2	C13B9.2
+F59F4.4	C13B9.2
+H19N07.4	C13B9.2
+H37A05.1	C13B9.2
+K04F1.15	C13B9.2
+K06A1.6	C13B9.2
+R07E3.5	C13B9.2
+R11F4.1	C13B9.2
+T05H4.1	C13B9.2
+T05H4.13	C13B9.2
+T06E8.1	C13B9.2
+W02H5.8	C13B9.2
+Y39G8B.1	C13B9.2
+Y69F12A.2	C13B9.2
+ZK40.1	C13B9.2
+F01F1.6	C54G7.2
+F08F3.2	C54G7.2
+F42A9.1	C54G7.2
+F49H12.6	C54G7.2
+F52C9.3	C54G7.2
+F54D8.3	C54G7.2
+F54G8.2	C54G7.2
+F59F4.4	C54G7.2
+H19N07.4	C54G7.2
+H37A05.1	C54G7.2
+K04F1.15	C54G7.2
+K06A1.6	C54G7.2
+R07E3.5	C54G7.2
+R11F4.1	C54G7.2
+T05H4.1	C54G7.2
+T05H4.13	C54G7.2
+T06E8.1	C54G7.2
+W02H5.8	C54G7.2
+Y39G8B.1	C54G7.2
+Y69F12A.2	C54G7.2
+ZK40.1	C54G7.2
+F08F3.2	F01F1.6
+F42A9.1	F01F1.6
+F49H12.6	F01F1.6
+F52C9.3	F01F1.6
+F54G8.2	F01F1.6
+F59F4.4	F01F1.6
+H19N07.4	F01F1.6
+H37A05.1	F01F1.6
+K06A1.6	F01F1.6
+R07E3.5	F01F1.6
+R11F4.1	F01F1.6
+T05H4.1	F01F1.6
+T06E8.1	F01F1.6
+W02H5.8	F01F1.6
+Y39G8B.1	F01F1.6
+ZK40.1	F01F1.6
+F42A9.1	F08F3.2
+F49H12.6	F08F3.2
+F52C9.3	F08F3.2
+F54D8.3	F08F3.2
+F54G8.2	F08F3.2
+F59F4.4	F08F3.2
+H19N07.4	F08F3.2
+H37A05.1	F08F3.2
+K04F1.15	F08F3.2
+K06A1.6	F08F3.2
+R07E3.5	F08F3.2
+R11F4.1	F08F3.2
+T05H4.1	F08F3.2
+T05H4.13	F08F3.2
+T06E8.1	F08F3.2
+W02H5.8	F08F3.2
+Y39G8B.1	F08F3.2
+Y69F12A.2	F08F3.2
+ZK40.1	F08F3.2
+F49H12.6	F42A9.1
+F52C9.3	F42A9.1
+F54D8.3	F42A9.1
+F54G8.2	F42A9.1
+F59F4.4	F42A9.1
+H19N07.4	F42A9.1
+H37A05.1	F42A9.1
+K04F1.15	F42A9.1
+K06A1.6	F42A9.1
+R07E3.5	F42A9.1
+R11F4.1	F42A9.1
+T05H4.1	F42A9.1
+T05H4.13	F42A9.1
+T06E8.1	F42A9.1
+W02H5.8	F42A9.1
+Y39G8B.1	F42A9.1
+Y69F12A.2	F42A9.1
+ZK40.1	F42A9.1
+F52C9.3	F49H12.6
+F54D8.3	F49H12.6
+F54G8.2	F49H12.6
+F59F4.4	F49H12.6
+H19N07.4	F49H12.6
+H37A05.1	F49H12.6
+K04F1.15	F49H12.6
+K06A1.6	F49H12.6
+R07E3.5	F49H12.6
+R11F4.1	F49H12.6
+T05H4.1	F49H12.6
+T05H4.13	F49H12.6
+T06E8.1	F49H12.6
+W02H5.8	F49H12.6
+Y39G8B.1	F49H12.6
+Y69F12A.2	F49H12.6
+ZK40.1	F49H12.6
+F54D8.3	F52C9.3
+F54G8.2	F52C9.3
+F59F4.4	F52C9.3
+H19N07.4	F52C9.3
+H37A05.1	F52C9.3
+K04F1.15	F52C9.3
+K06A1.6	F52C9.3
+R07E3.5	F52C9.3
+R11F4.1	F52C9.3
+T05H4.1	F52C9.3
+T05H4.13	F52C9.3
+T06E8.1	F52C9.3
+W02H5.8	F52C9.3
+Y39G8B.1	F52C9.3
+Y69F12A.2	F52C9.3
+ZK40.1	F52C9.3
+F54G8.2	F54D8.3
+F59F4.4	F54D8.3
+H19N07.4	F54D8.3
+H37A05.1	F54D8.3
+K06A1.6	F54D8.3
+R07E3.5	F54D8.3
+R11F4.1	F54D8.3
+T05H4.1	F54D8.3
+T06E8.1	F54D8.3
+W02H5.8	F54D8.3
+ZK40.1	F54D8.3
+F59F4.4	F54G8.2
+H19N07.4	F54G8.2
+H37A05.1	F54G8.2
+K04F1.15	F54G8.2
+K06A1.6	F54G8.2
+R07E3.5	F54G8.2
+R11F4.1	F54G8.2
+T05H4.1	F54G8.2
+T05H4.13	F54G8.2
+T06E8.1	F54G8.2
+W02H5.8	F54G8.2
+Y39G8B.1	F54G8.2
+Y69F12A.2	F54G8.2
+ZK40.1	F54G8.2
+H19N07.4	F59F4.4
+H37A05.1	F59F4.4
+K04F1.15	F59F4.4
+K06A1.6	F59F4.4
+R07E3.5	F59F4.4
+R11F4.1	F59F4.4
+T05H4.1	F59F4.4
+T05H4.13	F59F4.4
+T06E8.1	F59F4.4
+W02H5.8	F59F4.4
+Y39G8B.1	F59F4.4
+Y69F12A.2	F59F4.4
+ZK40.1	F59F4.4
+H37A05.1	H19N07.4
+K04F1.15	H19N07.4
+K06A1.6	H19N07.4
+R07E3.5	H19N07.4
+R11F4.1	H19N07.4
+T05H4.1	H19N07.4
+T05H4.13	H19N07.4
+T06E8.1	H19N07.4
+W02H5.8	H19N07.4
+Y39G8B.1	H19N07.4
+Y69F12A.2	H19N07.4
+ZK40.1	H19N07.4
+K04F1.15	H37A05.1
+K06A1.6	H37A05.1
+R07E3.5	H37A05.1
+R11F4.1	H37A05.1
+T05H4.1	H37A05.1
+T05H4.13	H37A05.1
+T06E8.1	H37A05.1
+W02H5.8	H37A05.1
+Y39G8B.1	H37A05.1
+Y69F12A.2	H37A05.1
+ZK40.1	H37A05.1
+K06A1.6	K04F1.15
+R07E3.5	K04F1.15
+R11F4.1	K04F1.15
+T05H4.1	K04F1.15
+T06E8.1	K04F1.15
+W02H5.8	K04F1.15
+ZK40.1	K04F1.15
+R07E3.5	K06A1.6
+R11F4.1	K06A1.6
+T05H4.1	K06A1.6
+T05H4.13	K06A1.6
+T06E8.1	K06A1.6
+W02H5.8	K06A1.6
+Y39G8B.1	K06A1.6
+Y69F12A.2	K06A1.6
+ZK40.1	K06A1.6
+R11F4.1	R07E3.5
+T05H4.1	R07E3.5
+T05H4.13	R07E3.5
+T06E8.1	R07E3.5
+W02H5.8	R07E3.5
+Y39G8B.1	R07E3.5
+Y69F12A.2	R07E3.5
+ZK40.1	R07E3.5
+T05H4.1	R11F4.1
+T05H4.13	R11F4.1
+T06E8.1	R11F4.1
+W02H5.8	R11F4.1
+Y39G8B.1	R11F4.1
+Y69F12A.2	R11F4.1
+ZK40.1	R11F4.1
+T05H4.13	T05H4.1
+T06E8.1	T05H4.1
+W02H5.8	T05H4.1
+Y39G8B.1	T05H4.1
+Y69F12A.2	T05H4.1
+ZK40.1	T05H4.1
+T06E8.1	T05H4.13
+W02H5.8	T05H4.13
+ZK40.1	T05H4.13
+W02H5.8	T06E8.1
+Y39G8B.1	T06E8.1
+Y69F12A.2	T06E8.1
+ZK40.1	T06E8.1
+Y39G8B.1	W02H5.8
+Y69F12A.2	W02H5.8
+ZK40.1	W02H5.8
+Y69F12A.2	Y39G8B.1
+ZK40.1	Y39G8B.1
+ZK40.1	Y69F12A.2
+B0334.8	B0025.1
+B0348.4	B0025.1
+C09B8.1	B0025.1
+C54E4.5	B0025.1
+F13D12.4	B0025.1
+F13G3.5	B0025.1
+F31B12.1	B0025.1
+F35H12.4	B0025.1
+F39B1.1	B0025.1
+F55A12.3	B0025.1
+JC8.10	B0025.1
+R05G6.8	B0025.1
+T01E8.3	B0025.1
+VF11C1L.1	B0025.1
+VF13D12L.1	B0025.1
+Y17G7B.7	B0025.1
+Y46G5A.5	B0025.1
+Y48G9A.8	B0025.1
+Y6B3B.5	B0025.1
+Y75B8A.24	B0025.1
+B0348.4	B0334.8
+C09B8.1	B0334.8
+C54E4.5	B0334.8
+F13D12.4	B0334.8
+F13G3.5	B0334.8
+F31B12.1	B0334.8
+F35H12.4	B0334.8
+F39B1.1	B0334.8
+F55A12.3	B0334.8
+JC8.10	B0334.8
+R05G6.8	B0334.8
+T01E8.3	B0334.8
+VF11C1L.1	B0334.8
+VF13D12L.1	B0334.8
+Y17G7B.7	B0334.8
+Y46G5A.5	B0334.8
+Y48G9A.8	B0334.8
+Y6B3B.5	B0334.8
+Y75B8A.24	B0334.8
+C09B8.1	B0348.4
+C54E4.5	B0348.4
+F13D12.4	B0348.4
+F13G3.5	B0348.4
+F31B12.1	B0348.4
+F35H12.4	B0348.4
+F39B1.1	B0348.4
+F55A12.3	B0348.4
+JC8.10	B0348.4
+R05G6.8	B0348.4
+T01E8.3	B0348.4
+VF11C1L.1	B0348.4
+VF13D12L.1	B0348.4
+Y17G7B.7	B0348.4
+Y46G5A.5	B0348.4
+Y48G9A.8	B0348.4
+Y6B3B.5	B0348.4
+Y75B8A.24	B0348.4
+C54E4.5	C09B8.1
+F13D12.4	C09B8.1
+F13G3.5	C09B8.1
+F31B12.1	C09B8.1
+F35H12.4	C09B8.1
+F39B1.1	C09B8.1
+F55A12.3	C09B8.1
+JC8.10	C09B8.1
+R05G6.8	C09B8.1
+T01E8.3	C09B8.1
+VF11C1L.1	C09B8.1
+VF13D12L.1	C09B8.1
+Y17G7B.7	C09B8.1
+Y46G5A.5	C09B8.1
+Y48G9A.8	C09B8.1
+Y6B3B.5	C09B8.1
+Y75B8A.24	C09B8.1
+F13D12.4	C54E4.5
+F13G3.5	C54E4.5
+F31B12.1	C54E4.5
+F35H12.4	C54E4.5
+F39B1.1	C54E4.5
+F55A12.3	C54E4.5
+JC8.10	C54E4.5
+R05G6.8	C54E4.5
+T01E8.3	C54E4.5
+VF11C1L.1	C54E4.5
+VF13D12L.1	C54E4.5
+Y17G7B.7	C54E4.5
+Y46G5A.5	C54E4.5
+Y48G9A.8	C54E4.5
+Y6B3B.5	C54E4.5
+Y75B8A.24	C54E4.5
+F13G3.5	F13D12.4
+F31B12.1	F13D12.4
+F35H12.4	F13D12.4
+F39B1.1	F13D12.4
+F55A12.3	F13D12.4
+JC8.10	F13D12.4
+R05G6.8	F13D12.4
+T01E8.3	F13D12.4
+VF11C1L.1	F13D12.4
+VF13D12L.1	F13D12.4
+Y17G7B.7	F13D12.4
+Y46G5A.5	F13D12.4
+Y48G9A.8	F13D12.4
+Y6B3B.5	F13D12.4
+Y75B8A.24	F13D12.4
+F31B12.1	F13G3.5
+F35H12.4	F13G3.5
+F39B1.1	F13G3.5
+F55A12.3	F13G3.5
+JC8.10	F13G3.5
+R05G6.8	F13G3.5
+T01E8.3	F13G3.5
+VF11C1L.1	F13G3.5
+VF13D12L.1	F13G3.5
+Y17G7B.7	F13G3.5
+Y46G5A.5	F13G3.5
+Y48G9A.8	F13G3.5
+Y6B3B.5	F13G3.5
+Y75B8A.24	F13G3.5
+F35H12.4	F31B12.1
+F39B1.1	F31B12.1
+F55A12.3	F31B12.1
+JC8.10	F31B12.1
+R05G6.8	F31B12.1
+T01E8.3	F31B12.1
+VF11C1L.1	F31B12.1
+VF13D12L.1	F31B12.1
+Y17G7B.7	F31B12.1
+Y46G5A.5	F31B12.1
+Y48G9A.8	F31B12.1
+Y6B3B.5	F31B12.1
+Y75B8A.24	F31B12.1
+F39B1.1	F35H12.4
+F55A12.3	F35H12.4
+JC8.10	F35H12.4
+R05G6.8	F35H12.4
+T01E8.3	F35H12.4
+VF11C1L.1	F35H12.4
+VF13D12L.1	F35H12.4
+Y17G7B.7	F35H12.4
+Y46G5A.5	F35H12.4
+Y48G9A.8	F35H12.4
+Y6B3B.5	F35H12.4
+Y75B8A.24	F35H12.4
+F55A12.3	F39B1.1
+JC8.10	F39B1.1
+R05G6.8	F39B1.1
+T01E8.3	F39B1.1
+VF11C1L.1	F39B1.1
+VF13D12L.1	F39B1.1
+Y17G7B.7	F39B1.1
+Y46G5A.5	F39B1.1
+Y48G9A.8	F39B1.1
+Y6B3B.5	F39B1.1
+Y75B8A.24	F39B1.1
+JC8.10	F55A12.3
+R05G6.8	F55A12.3
+T01E8.3	F55A12.3
+VF11C1L.1	F55A12.3
+VF13D12L.1	F55A12.3
+Y17G7B.7	F55A12.3
+Y46G5A.5	F55A12.3
+Y48G9A.8	F55A12.3
+Y6B3B.5	F55A12.3
+Y75B8A.24	F55A12.3
+R05G6.8	JC8.10
+T01E8.3	JC8.10
+VF11C1L.1	JC8.10
+VF13D12L.1	JC8.10
+Y17G7B.7	JC8.10
+Y46G5A.5	JC8.10
+Y48G9A.8	JC8.10
+Y6B3B.5	JC8.10
+Y75B8A.24	JC8.10
+T01E8.3	R05G6.8
+VF11C1L.1	R05G6.8
+VF13D12L.1	R05G6.8
+Y17G7B.7	R05G6.8
+Y46G5A.5	R05G6.8
+Y48G9A.8	R05G6.8
+Y6B3B.5	R05G6.8
+Y75B8A.24	R05G6.8
+VF11C1L.1	T01E8.3
+VF13D12L.1	T01E8.3
+Y17G7B.7	T01E8.3
+Y46G5A.5	T01E8.3
+Y48G9A.8	T01E8.3
+Y6B3B.5	T01E8.3
+Y75B8A.24	T01E8.3
+VF13D12L.1	VF11C1L.1
+Y17G7B.7	VF11C1L.1
+Y46G5A.5	VF11C1L.1
+Y48G9A.8	VF11C1L.1
+Y6B3B.5	VF11C1L.1
+Y75B8A.24	VF11C1L.1
+Y17G7B.7	VF13D12L.1
+Y46G5A.5	VF13D12L.1
+Y48G9A.8	VF13D12L.1
+Y6B3B.5	VF13D12L.1
+Y75B8A.24	VF13D12L.1
+Y46G5A.5	Y17G7B.7
+Y48G9A.8	Y17G7B.7
+Y6B3B.5	Y17G7B.7
+Y75B8A.24	Y17G7B.7
+Y48G9A.8	Y46G5A.5
+Y6B3B.5	Y46G5A.5
+Y75B8A.24	Y46G5A.5
+Y6B3B.5	Y48G9A.8
+Y75B8A.24	Y48G9A.8
+Y75B8A.24	Y6B3B.5
+C27A12.9	B0491.1
+D2085.6	B0491.1
+F01G4.5	B0491.1
+F17C11.7	B0491.1
+F33D11.9	B0491.1
+T05E11.6	B0491.1
+T20D3.8	B0491.1
+T22C1.3	B0491.1
+Y54E10BR.1	B0491.1
+D2085.6	C27A12.9
+F01G4.5	C27A12.9
+F17C11.7	C27A12.9
+F33D11.9	C27A12.9
+T05E11.6	C27A12.9
+T20D3.8	C27A12.9
+T22C1.3	C27A12.9
+Y54E10BR.1	C27A12.9
+F01G4.5	D2085.6
+F17C11.7	D2085.6
+F33D11.9	D2085.6
+T05E11.6	D2085.6
+T20D3.8	D2085.6
+T22C1.3	D2085.6
+Y54E10BR.1	D2085.6
+F17C11.7	F01G4.5
+F33D11.9	F01G4.5
+T05E11.6	F01G4.5
+T20D3.8	F01G4.5
+T22C1.3	F01G4.5
+Y54E10BR.1	F01G4.5
+F33D11.9	F17C11.7
+T05E11.6	F17C11.7
+T20D3.8	F17C11.7
+T22C1.3	F17C11.7
+Y54E10BR.1	F17C11.7
+T05E11.6	F33D11.9
+T20D3.8	F33D11.9
+T22C1.3	F33D11.9
+Y54E10BR.1	F33D11.9
+T20D3.8	T05E11.6
+T22C1.3	T05E11.6
+Y54E10BR.1	T05E11.6
+T22C1.3	T20D3.8
+Y54E10BR.1	T20D3.8
+Y54E10BR.1	T22C1.3
+C03H5.4	B0361.5
+C04G6.3	B0361.5
+C07E3.9	B0361.5
+C09E10.2	B0361.5
+C33H5.18	B0361.5
+C39D10.3	B0361.5
+C52B9.1	B0361.5
+C54G7.2	B0361.5
+F08C6.2	B0361.5
+F08F3.2	B0361.5
+F14F3.3	B0361.5
+F22E10.5	B0361.5
+F23H11.9	B0361.5
+F42A9.1	B0361.5
+F47G4.3	B0361.5
+F49H12.6	B0361.5
+F54D7.2	B0361.5
+F54G8.2	B0361.5
+F55C5.2	B0361.5
+F59F4.4	B0361.5
+H37A05.1	B0361.5
+K04G2.5	B0361.5
+K06A1.6	B0361.5
+K07B1.5	B0361.5
+K11H3.1	B0361.5
+M05B5.4	B0361.5
+M110.7	B0361.5
+R07E3.5	B0361.5
+R155.1	B0361.5
+T05H4.1	B0361.5
+T06E8.1	B0361.5
+T12B3.3	B0361.5
+T25G3.4	B0361.5
+T27A10.3	B0361.5
+W07A8.2	B0361.5
+W09B12.1	B0361.5
+Y37E3.11	B0361.5
+Y44E3A.2	B0361.5
+Y46G5A.21	B0361.5
+Y46G5A.5	B0361.5
+Y48B6A.7	B0361.5
+Y48G1C.4	B0361.5
+ZC416.8	B0361.5
+ZC506.3	B0361.5
+ZK370.4	B0361.5
+ZK40.1	B0361.5
+ZK809.2	B0361.5
+C04G6.3	C03H5.4
+C07E3.9	C03H5.4
+C09E10.2	C03H5.4
+C33H5.18	C03H5.4
+C39D10.3	C03H5.4
+C52B9.1	C03H5.4
+C54G7.2	C03H5.4
+F08C6.2	C03H5.4
+F08F3.2	C03H5.4
+F14F3.3	C03H5.4
+F22E10.5	C03H5.4
+F23H11.9	C03H5.4
+F42A9.1	C03H5.4
+F47G4.3	C03H5.4
+F49H12.6	C03H5.4
+F54D7.2	C03H5.4
+F54G8.2	C03H5.4
+F55C5.2	C03H5.4
+F59F4.4	C03H5.4
+H37A05.1	C03H5.4
+K04G2.5	C03H5.4
+K06A1.6	C03H5.4
+K07B1.5	C03H5.4
+K11H3.1	C03H5.4
+M05B5.4	C03H5.4
+M110.7	C03H5.4
+R07E3.5	C03H5.4
+R155.1	C03H5.4
+T05H4.1	C03H5.4
+T06E8.1	C03H5.4
+T12B3.3	C03H5.4
+T25G3.4	C03H5.4
+T27A10.3	C03H5.4
+W07A8.2	C03H5.4
+W09B12.1	C03H5.4
+Y37E3.11	C03H5.4
+Y44E3A.2	C03H5.4
+Y46G5A.21	C03H5.4
+Y46G5A.5	C03H5.4
+Y48B6A.7	C03H5.4
+Y48G1C.4	C03H5.4
+ZC416.8	C03H5.4
+ZC506.3	C03H5.4
+ZK370.4	C03H5.4
+ZK40.1	C03H5.4
+ZK809.2	C03H5.4
+C07E3.9	C04G6.3
+C09E10.2	C04G6.3
+C33H5.18	C04G6.3
+C39D10.3	C04G6.3
+C52B9.1	C04G6.3
+C54G7.2	C04G6.3
+F08C6.2	C04G6.3
+F08F3.2	C04G6.3
+F14F3.3	C04G6.3
+F22E10.5	C04G6.3
+F23H11.9	C04G6.3
+F42A9.1	C04G6.3
+F47G4.3	C04G6.3
+F49H12.6	C04G6.3
+F54D7.2	C04G6.3
+F54G8.2	C04G6.3
+F55C5.2	C04G6.3
+F59F4.4	C04G6.3
+H37A05.1	C04G6.3
+K04G2.5	C04G6.3
+K06A1.6	C04G6.3
+K07B1.5	C04G6.3
+K11H3.1	C04G6.3
+M05B5.4	C04G6.3
+M110.7	C04G6.3
+R07E3.5	C04G6.3
+R155.1	C04G6.3
+T05H4.1	C04G6.3
+T06E8.1	C04G6.3
+T12B3.3	C04G6.3
+T25G3.4	C04G6.3
+T27A10.3	C04G6.3
+W07A8.2	C04G6.3
+W09B12.1	C04G6.3
+Y37E3.11	C04G6.3
+Y44E3A.2	C04G6.3
+Y46G5A.21	C04G6.3
+Y46G5A.5	C04G6.3
+Y48B6A.7	C04G6.3
+Y48G1C.4	C04G6.3
+ZC416.8	C04G6.3
+ZC506.3	C04G6.3
+ZK370.4	C04G6.3
+ZK40.1	C04G6.3
+ZK809.2	C04G6.3
+C09E10.2	C07E3.9
+C33H5.18	C07E3.9
+C39D10.3	C07E3.9
+C52B9.1	C07E3.9
+C54G7.2	C07E3.9
+F08C6.2	C07E3.9
+F08F3.2	C07E3.9
+F14F3.3	C07E3.9
+F22E10.5	C07E3.9
+F23H11.9	C07E3.9
+F42A9.1	C07E3.9
+F47G4.3	C07E3.9
+F49H12.6	C07E3.9
+F54D7.2	C07E3.9
+F54G8.2	C07E3.9
+F55C5.2	C07E3.9
+F59F4.4	C07E3.9
+H37A05.1	C07E3.9
+K04G2.5	C07E3.9
+K06A1.6	C07E3.9
+K07B1.5	C07E3.9
+K11H3.1	C07E3.9
+M05B5.4	C07E3.9
+M110.7	C07E3.9
+R07E3.5	C07E3.9
+R155.1	C07E3.9
+T05H4.1	C07E3.9
+T06E8.1	C07E3.9
+T12B3.3	C07E3.9
+T25G3.4	C07E3.9
+T27A10.3	C07E3.9
+W07A8.2	C07E3.9
+W09B12.1	C07E3.9
+Y37E3.11	C07E3.9
+Y44E3A.2	C07E3.9
+Y46G5A.21	C07E3.9
+Y46G5A.5	C07E3.9
+Y48B6A.7	C07E3.9
+Y48G1C.4	C07E3.9
+ZC416.8	C07E3.9
+ZC506.3	C07E3.9
+ZK370.4	C07E3.9
+ZK40.1	C07E3.9
+ZK809.2	C07E3.9
+C33H5.18	C09E10.2
+C39D10.3	C09E10.2
+C52B9.1	C09E10.2
+F08C6.2	C09E10.2
+F14F3.3	C09E10.2
+F22E10.5	C09E10.2
+F23H11.9	C09E10.2
+F47G4.3	C09E10.2
+F54D7.2	C09E10.2
+F55C5.2	C09E10.2
+K04G2.5	C09E10.2
+K07B1.5	C09E10.2
+K11H3.1	C09E10.2
+M05B5.4	C09E10.2
+M110.7	C09E10.2
+R155.1	C09E10.2
+T12B3.3	C09E10.2
+T25G3.4	C09E10.2
+T27A10.3	C09E10.2
+W07A8.2	C09E10.2
+W09B12.1	C09E10.2
+Y37E3.11	C09E10.2
+Y44E3A.2	C09E10.2
+Y46G5A.21	C09E10.2
+Y46G5A.5	C09E10.2
+Y48B6A.7	C09E10.2
+Y48G1C.4	C09E10.2
+ZC416.8	C09E10.2
+ZC506.3	C09E10.2
+ZK370.4	C09E10.2
+ZK809.2	C09E10.2
+C39D10.3	C33H5.18
+C52B9.1	C33H5.18
+C54G7.2	C33H5.18
+F08C6.2	C33H5.18
+F08F3.2	C33H5.18
+F14F3.3	C33H5.18
+F22E10.5	C33H5.18
+F23H11.9	C33H5.18
+F42A9.1	C33H5.18
+F47G4.3	C33H5.18
+F49H12.6	C33H5.18
+F54D7.2	C33H5.18
+F54G8.2	C33H5.18
+F55C5.2	C33H5.18
+F59F4.4	C33H5.18
+H37A05.1	C33H5.18
+K04G2.5	C33H5.18
+K06A1.6	C33H5.18
+K07B1.5	C33H5.18
+K11H3.1	C33H5.18
+M05B5.4	C33H5.18
+M110.7	C33H5.18
+R07E3.5	C33H5.18
+R155.1	C33H5.18
+T05H4.1	C33H5.18
+T06E8.1	C33H5.18
+T12B3.3	C33H5.18
+T25G3.4	C33H5.18
+T27A10.3	C33H5.18
+W07A8.2	C33H5.18
+W09B12.1	C33H5.18
+Y37E3.11	C33H5.18
+Y44E3A.2	C33H5.18
+Y46G5A.21	C33H5.18
+Y46G5A.5	C33H5.18
+Y48B6A.7	C33H5.18
+Y48G1C.4	C33H5.18
+ZC416.8	C33H5.18
+ZC506.3	C33H5.18
+ZK370.4	C33H5.18
+ZK40.1	C33H5.18
+ZK809.2	C33H5.18
+C52B9.1	C39D10.3
+C54G7.2	C39D10.3
+F08C6.2	C39D10.3
+F08F3.2	C39D10.3
+F14F3.3	C39D10.3
+F22E10.5	C39D10.3
+F23H11.9	C39D10.3
+F42A9.1	C39D10.3
+F47G4.3	C39D10.3
+F49H12.6	C39D10.3
+F54D7.2	C39D10.3
+F54G8.2	C39D10.3
+F55C5.2	C39D10.3
+F59F4.4	C39D10.3
+H37A05.1	C39D10.3
+K04G2.5	C39D10.3
+K06A1.6	C39D10.3
+K07B1.5	C39D10.3
+K11H3.1	C39D10.3
+M05B5.4	C39D10.3
+M110.7	C39D10.3
+R07E3.5	C39D10.3
+R155.1	C39D10.3
+T05H4.1	C39D10.3
+T06E8.1	C39D10.3
+T12B3.3	C39D10.3
+T25G3.4	C39D10.3
+T27A10.3	C39D10.3
+W07A8.2	C39D10.3
+W09B12.1	C39D10.3
+Y37E3.11	C39D10.3
+Y44E3A.2	C39D10.3
+Y46G5A.21	C39D10.3
+Y46G5A.5	C39D10.3
+Y48B6A.7	C39D10.3
+Y48G1C.4	C39D10.3
+ZC416.8	C39D10.3
+ZC506.3	C39D10.3
+ZK370.4	C39D10.3
+ZK40.1	C39D10.3
+ZK809.2	C39D10.3
+C54G7.2	C52B9.1
+F08C6.2	C52B9.1
+F08F3.2	C52B9.1
+F14F3.3	C52B9.1
+F22E10.5	C52B9.1
+F23H11.9	C52B9.1
+F42A9.1	C52B9.1
+F47G4.3	C52B9.1
+F49H12.6	C52B9.1
+F54D7.2	C52B9.1
+F54G8.2	C52B9.1
+F55C5.2	C52B9.1
+F59F4.4	C52B9.1
+H37A05.1	C52B9.1
+K04G2.5	C52B9.1
+K06A1.6	C52B9.1
+K07B1.5	C52B9.1
+K11H3.1	C52B9.1
+M05B5.4	C52B9.1
+M110.7	C52B9.1
+R07E3.5	C52B9.1
+R155.1	C52B9.1
+T05H4.1	C52B9.1
+T06E8.1	C52B9.1
+T12B3.3	C52B9.1
+T25G3.4	C52B9.1
+T27A10.3	C52B9.1
+W07A8.2	C52B9.1
+W09B12.1	C52B9.1
+Y37E3.11	C52B9.1
+Y44E3A.2	C52B9.1
+Y46G5A.21	C52B9.1
+Y46G5A.5	C52B9.1
+Y48B6A.7	C52B9.1
+Y48G1C.4	C52B9.1
+ZC416.8	C52B9.1
+ZC506.3	C52B9.1
+ZK370.4	C52B9.1
+ZK40.1	C52B9.1
+ZK809.2	C52B9.1
+F08C6.2	C54G7.2
+F14F3.3	C54G7.2
+F22E10.5	C54G7.2
+F23H11.9	C54G7.2
+F47G4.3	C54G7.2
+F54D7.2	C54G7.2
+F55C5.2	C54G7.2
+K04G2.5	C54G7.2
+K07B1.5	C54G7.2
+K11H3.1	C54G7.2
+M05B5.4	C54G7.2
+M110.7	C54G7.2
+R155.1	C54G7.2
+T12B3.3	C54G7.2
+T25G3.4	C54G7.2
+T27A10.3	C54G7.2
+W07A8.2	C54G7.2
+W09B12.1	C54G7.2
+Y37E3.11	C54G7.2
+Y44E3A.2	C54G7.2
+Y46G5A.21	C54G7.2
+Y46G5A.5	C54G7.2
+Y48B6A.7	C54G7.2
+Y48G1C.4	C54G7.2
+ZC416.8	C54G7.2
+ZC506.3	C54G7.2
+ZK370.4	C54G7.2
+ZK809.2	C54G7.2
+F08F3.2	F08C6.2
+F14F3.3	F08C6.2
+F22E10.5	F08C6.2
+F23H11.9	F08C6.2
+F42A9.1	F08C6.2
+F47G4.3	F08C6.2
+F49H12.6	F08C6.2
+F54D7.2	F08C6.2
+F54G8.2	F08C6.2
+F55C5.2	F08C6.2
+F59F4.4	F08C6.2
+H37A05.1	F08C6.2
+K04G2.5	F08C6.2
+K06A1.6	F08C6.2
+K07B1.5	F08C6.2
+K11H3.1	F08C6.2
+M05B5.4	F08C6.2
+M110.7	F08C6.2
+R07E3.5	F08C6.2
+R155.1	F08C6.2
+T05H4.1	F08C6.2
+T06E8.1	F08C6.2
+T12B3.3	F08C6.2
+T25G3.4	F08C6.2
+T27A10.3	F08C6.2
+W07A8.2	F08C6.2
+W09B12.1	F08C6.2
+Y37E3.11	F08C6.2
+Y44E3A.2	F08C6.2
+Y46G5A.21	F08C6.2
+Y46G5A.5	F08C6.2
+Y48B6A.7	F08C6.2
+Y48G1C.4	F08C6.2
+ZC416.8	F08C6.2
+ZC506.3	F08C6.2
+ZK370.4	F08C6.2
+ZK40.1	F08C6.2
+ZK809.2	F08C6.2
+F14F3.3	F08F3.2
+F22E10.5	F08F3.2
+F23H11.9	F08F3.2
+F47G4.3	F08F3.2
+F54D7.2	F08F3.2
+F55C5.2	F08F3.2
+K04G2.5	F08F3.2
+K07B1.5	F08F3.2
+K11H3.1	F08F3.2
+M05B5.4	F08F3.2
+M110.7	F08F3.2
+R155.1	F08F3.2
+T12B3.3	F08F3.2
+T25G3.4	F08F3.2
+T27A10.3	F08F3.2
+W07A8.2	F08F3.2
+W09B12.1	F08F3.2
+Y37E3.11	F08F3.2
+Y44E3A.2	F08F3.2
+Y46G5A.21	F08F3.2
+Y46G5A.5	F08F3.2
+Y48B6A.7	F08F3.2
+Y48G1C.4	F08F3.2
+ZC416.8	F08F3.2
+ZC506.3	F08F3.2
+ZK370.4	F08F3.2
+ZK809.2	F08F3.2
+F22E10.5	F14F3.3
+F23H11.9	F14F3.3
+F42A9.1	F14F3.3
+F47G4.3	F14F3.3
+F49H12.6	F14F3.3
+F54D7.2	F14F3.3
+F54G8.2	F14F3.3
+F55C5.2	F14F3.3
+F59F4.4	F14F3.3
+H37A05.1	F14F3.3
+K04G2.5	F14F3.3
+K06A1.6	F14F3.3
+K07B1.5	F14F3.3
+K11H3.1	F14F3.3
+M05B5.4	F14F3.3
+M110.7	F14F3.3
+R07E3.5	F14F3.3
+R155.1	F14F3.3
+T05H4.1	F14F3.3
+T06E8.1	F14F3.3
+T12B3.3	F14F3.3
+T25G3.4	F14F3.3
+T27A10.3	F14F3.3
+W07A8.2	F14F3.3
+W09B12.1	F14F3.3
+Y37E3.11	F14F3.3
+Y44E3A.2	F14F3.3
+Y46G5A.21	F14F3.3
+Y46G5A.5	F14F3.3
+Y48B6A.7	F14F3.3
+Y48G1C.4	F14F3.3
+ZC416.8	F14F3.3
+ZC506.3	F14F3.3
+ZK370.4	F14F3.3
+ZK40.1	F14F3.3
+ZK809.2	F14F3.3
+F23H11.9	F22E10.5
+F42A9.1	F22E10.5
+F47G4.3	F22E10.5
+F49H12.6	F22E10.5
+F54D7.2	F22E10.5
+F54G8.2	F22E10.5
+F55C5.2	F22E10.5
+F59F4.4	F22E10.5
+H37A05.1	F22E10.5
+K04G2.5	F22E10.5
+K06A1.6	F22E10.5
+K07B1.5	F22E10.5
+K11H3.1	F22E10.5
+M05B5.4	F22E10.5
+M110.7	F22E10.5
+R07E3.5	F22E10.5
+R155.1	F22E10.5
+T05H4.1	F22E10.5
+T06E8.1	F22E10.5
+T12B3.3	F22E10.5
+T25G3.4	F22E10.5
+T27A10.3	F22E10.5
+W07A8.2	F22E10.5
+W09B12.1	F22E10.5
+Y37E3.11	F22E10.5
+Y44E3A.2	F22E10.5
+Y46G5A.21	F22E10.5
+Y46G5A.5	F22E10.5
+Y48B6A.7	F22E10.5
+Y48G1C.4	F22E10.5
+ZC416.8	F22E10.5
+ZC506.3	F22E10.5
+ZK370.4	F22E10.5
+ZK40.1	F22E10.5
+ZK809.2	F22E10.5
+F42A9.1	F23H11.9
+F47G4.3	F23H11.9
+F49H12.6	F23H11.9
+F54D7.2	F23H11.9
+F54G8.2	F23H11.9
+F55C5.2	F23H11.9
+F59F4.4	F23H11.9
+H37A05.1	F23H11.9
+K04G2.5	F23H11.9
+K06A1.6	F23H11.9
+K07B1.5	F23H11.9
+K11H3.1	F23H11.9
+M05B5.4	F23H11.9
+M110.7	F23H11.9
+R07E3.5	F23H11.9
+R155.1	F23H11.9
+T05H4.1	F23H11.9
+T06E8.1	F23H11.9
+T12B3.3	F23H11.9
+T25G3.4	F23H11.9
+T27A10.3	F23H11.9
+W07A8.2	F23H11.9
+W09B12.1	F23H11.9
+Y37E3.11	F23H11.9
+Y44E3A.2	F23H11.9
+Y46G5A.21	F23H11.9
+Y46G5A.5	F23H11.9
+Y48B6A.7	F23H11.9
+Y48G1C.4	F23H11.9
+ZC416.8	F23H11.9
+ZC506.3	F23H11.9
+ZK370.4	F23H11.9
+ZK40.1	F23H11.9
+ZK809.2	F23H11.9
+F47G4.3	F42A9.1
+F54D7.2	F42A9.1
+F55C5.2	F42A9.1
+K04G2.5	F42A9.1
+K07B1.5	F42A9.1
+K11H3.1	F42A9.1
+M05B5.4	F42A9.1
+M110.7	F42A9.1
+R155.1	F42A9.1
+T12B3.3	F42A9.1
+T25G3.4	F42A9.1
+T27A10.3	F42A9.1
+W07A8.2	F42A9.1
+W09B12.1	F42A9.1
+Y37E3.11	F42A9.1
+Y44E3A.2	F42A9.1
+Y46G5A.21	F42A9.1
+Y46G5A.5	F42A9.1
+Y48B6A.7	F42A9.1
+Y48G1C.4	F42A9.1
+ZC416.8	F42A9.1
+ZC506.3	F42A9.1
+ZK370.4	F42A9.1
+ZK809.2	F42A9.1
+F49H12.6	F47G4.3
+F54D7.2	F47G4.3
+F54G8.2	F47G4.3
+F55C5.2	F47G4.3
+F59F4.4	F47G4.3
+H37A05.1	F47G4.3
+K04G2.5	F47G4.3
+K06A1.6	F47G4.3
+K07B1.5	F47G4.3
+K11H3.1	F47G4.3
+M05B5.4	F47G4.3
+M110.7	F47G4.3
+R07E3.5	F47G4.3
+R155.1	F47G4.3
+T05H4.1	F47G4.3
+T06E8.1	F47G4.3
+T12B3.3	F47G4.3
+T25G3.4	F47G4.3
+T27A10.3	F47G4.3
+W07A8.2	F47G4.3
+W09B12.1	F47G4.3
+Y37E3.11	F47G4.3
+Y44E3A.2	F47G4.3
+Y46G5A.21	F47G4.3
+Y46G5A.5	F47G4.3
+Y48B6A.7	F47G4.3
+Y48G1C.4	F47G4.3
+ZC416.8	F47G4.3
+ZC506.3	F47G4.3
+ZK370.4	F47G4.3
+ZK40.1	F47G4.3
+ZK809.2	F47G4.3
+F54D7.2	F49H12.6
+F55C5.2	F49H12.6
+K04G2.5	F49H12.6
+K07B1.5	F49H12.6
+K11H3.1	F49H12.6
+M05B5.4	F49H12.6
+M110.7	F49H12.6
+R155.1	F49H12.6
+T12B3.3	F49H12.6
+T25G3.4	F49H12.6
+T27A10.3	F49H12.6
+W07A8.2	F49H12.6
+W09B12.1	F49H12.6
+Y37E3.11	F49H12.6
+Y44E3A.2	F49H12.6
+Y46G5A.21	F49H12.6
+Y46G5A.5	F49H12.6
+Y48B6A.7	F49H12.6
+Y48G1C.4	F49H12.6
+ZC416.8	F49H12.6
+ZC506.3	F49H12.6
+ZK370.4	F49H12.6
+ZK809.2	F49H12.6
+F54G8.2	F54D7.2
+F55C5.2	F54D7.2
+F59F4.4	F54D7.2
+H37A05.1	F54D7.2
+K04G2.5	F54D7.2
+K06A1.6	F54D7.2
+K07B1.5	F54D7.2
+K11H3.1	F54D7.2
+M05B5.4	F54D7.2
+M110.7	F54D7.2
+R07E3.5	F54D7.2
+R155.1	F54D7.2
+T05H4.1	F54D7.2
+T06E8.1	F54D7.2
+T12B3.3	F54D7.2
+T25G3.4	F54D7.2
+T27A10.3	F54D7.2
+W07A8.2	F54D7.2
+W09B12.1	F54D7.2
+Y37E3.11	F54D7.2
+Y44E3A.2	F54D7.2
+Y46G5A.21	F54D7.2
+Y46G5A.5	F54D7.2
+Y48B6A.7	F54D7.2
+Y48G1C.4	F54D7.2
+ZC416.8	F54D7.2
+ZC506.3	F54D7.2
+ZK370.4	F54D7.2
+ZK40.1	F54D7.2
+ZK809.2	F54D7.2
+F55C5.2	F54G8.2
+K04G2.5	F54G8.2
+K07B1.5	F54G8.2
+K11H3.1	F54G8.2
+M05B5.4	F54G8.2
+M110.7	F54G8.2
+R155.1	F54G8.2
+T12B3.3	F54G8.2
+T25G3.4	F54G8.2
+T27A10.3	F54G8.2
+W07A8.2	F54G8.2
+W09B12.1	F54G8.2
+Y37E3.11	F54G8.2
+Y44E3A.2	F54G8.2
+Y46G5A.21	F54G8.2
+Y46G5A.5	F54G8.2
+Y48B6A.7	F54G8.2
+Y48G1C.4	F54G8.2
+ZC416.8	F54G8.2
+ZC506.3	F54G8.2
+ZK370.4	F54G8.2
+ZK809.2	F54G8.2
+F59F4.4	F55C5.2
+H37A05.1	F55C5.2
+K04G2.5	F55C5.2
+K06A1.6	F55C5.2
+K07B1.5	F55C5.2
+K11H3.1	F55C5.2
+M05B5.4	F55C5.2
+M110.7	F55C5.2
+R07E3.5	F55C5.2
+R155.1	F55C5.2
+T05H4.1	F55C5.2
+T06E8.1	F55C5.2
+T12B3.3	F55C5.2
+T25G3.4	F55C5.2
+T27A10.3	F55C5.2
+W07A8.2	F55C5.2
+W09B12.1	F55C5.2
+Y37E3.11	F55C5.2
+Y44E3A.2	F55C5.2
+Y46G5A.21	F55C5.2
+Y46G5A.5	F55C5.2
+Y48B6A.7	F55C5.2
+Y48G1C.4	F55C5.2
+ZC416.8	F55C5.2
+ZC506.3	F55C5.2
+ZK370.4	F55C5.2
+ZK40.1	F55C5.2
+ZK809.2	F55C5.2
+K04G2.5	F59F4.4
+K07B1.5	F59F4.4
+K11H3.1	F59F4.4
+M05B5.4	F59F4.4
+M110.7	F59F4.4
+R155.1	F59F4.4
+T12B3.3	F59F4.4
+T25G3.4	F59F4.4
+T27A10.3	F59F4.4
+W07A8.2	F59F4.4
+W09B12.1	F59F4.4
+Y37E3.11	F59F4.4
+Y44E3A.2	F59F4.4
+Y46G5A.21	F59F4.4
+Y46G5A.5	F59F4.4
+Y48B6A.7	F59F4.4
+Y48G1C.4	F59F4.4
+ZC416.8	F59F4.4
+ZC506.3	F59F4.4
+ZK370.4	F59F4.4
+ZK809.2	F59F4.4
+K04G2.5	H37A05.1
+K07B1.5	H37A05.1
+K11H3.1	H37A05.1
+M05B5.4	H37A05.1
+M110.7	H37A05.1
+R155.1	H37A05.1
+T12B3.3	H37A05.1
+T25G3.4	H37A05.1
+T27A10.3	H37A05.1
+W07A8.2	H37A05.1
+W09B12.1	H37A05.1
+Y37E3.11	H37A05.1
+Y44E3A.2	H37A05.1
+Y46G5A.21	H37A05.1
+Y46G5A.5	H37A05.1
+Y48B6A.7	H37A05.1
+Y48G1C.4	H37A05.1
+ZC416.8	H37A05.1
+ZC506.3	H37A05.1
+ZK370.4	H37A05.1
+ZK809.2	H37A05.1
+K06A1.6	K04G2.5
+K07B1.5	K04G2.5
+K11H3.1	K04G2.5
+M05B5.4	K04G2.5
+M110.7	K04G2.5
+R07E3.5	K04G2.5
+R155.1	K04G2.5
+T05H4.1	K04G2.5
+T06E8.1	K04G2.5
+T12B3.3	K04G2.5
+T25G3.4	K04G2.5
+T27A10.3	K04G2.5
+W07A8.2	K04G2.5
+W09B12.1	K04G2.5
+Y37E3.11	K04G2.5
+Y44E3A.2	K04G2.5
+Y46G5A.21	K04G2.5
+Y46G5A.5	K04G2.5
+Y48B6A.7	K04G2.5
+Y48G1C.4	K04G2.5
+ZC416.8	K04G2.5
+ZC506.3	K04G2.5
+ZK370.4	K04G2.5
+ZK40.1	K04G2.5
+ZK809.2	K04G2.5
+K07B1.5	K06A1.6
+K11H3.1	K06A1.6
+M05B5.4	K06A1.6
+M110.7	K06A1.6
+R155.1	K06A1.6
+T12B3.3	K06A1.6
+T25G3.4	K06A1.6
+T27A10.3	K06A1.6
+W07A8.2	K06A1.6
+W09B12.1	K06A1.6
+Y37E3.11	K06A1.6
+Y44E3A.2	K06A1.6
+Y46G5A.21	K06A1.6
+Y46G5A.5	K06A1.6
+Y48B6A.7	K06A1.6
+Y48G1C.4	K06A1.6
+ZC416.8	K06A1.6
+ZC506.3	K06A1.6
+ZK370.4	K06A1.6
+ZK809.2	K06A1.6
+K11H3.1	K07B1.5
+M05B5.4	K07B1.5
+M110.7	K07B1.5
+R07E3.5	K07B1.5
+R155.1	K07B1.5
+T05H4.1	K07B1.5
+T06E8.1	K07B1.5
+T12B3.3	K07B1.5
+T25G3.4	K07B1.5
+T27A10.3	K07B1.5
+W07A8.2	K07B1.5
+W09B12.1	K07B1.5
+Y37E3.11	K07B1.5
+Y44E3A.2	K07B1.5
+Y46G5A.21	K07B1.5
+Y46G5A.5	K07B1.5
+Y48B6A.7	K07B1.5
+Y48G1C.4	K07B1.5
+ZC416.8	K07B1.5
+ZC506.3	K07B1.5
+ZK370.4	K07B1.5
+ZK40.1	K07B1.5
+ZK809.2	K07B1.5
+M05B5.4	K11H3.1
+M110.7	K11H3.1
+R07E3.5	K11H3.1
+R155.1	K11H3.1
+T05H4.1	K11H3.1
+T06E8.1	K11H3.1
+T12B3.3	K11H3.1
+T25G3.4	K11H3.1
+T27A10.3	K11H3.1
+W07A8.2	K11H3.1
+W09B12.1	K11H3.1
+Y37E3.11	K11H3.1
+Y44E3A.2	K11H3.1
+Y46G5A.21	K11H3.1
+Y46G5A.5	K11H3.1
+Y48B6A.7	K11H3.1
+Y48G1C.4	K11H3.1
+ZC416.8	K11H3.1
+ZC506.3	K11H3.1
+ZK370.4	K11H3.1
+ZK40.1	K11H3.1
+ZK809.2	K11H3.1
+M110.7	M05B5.4
+R07E3.5	M05B5.4
+R155.1	M05B5.4
+T05H4.1	M05B5.4
+T06E8.1	M05B5.4
+T12B3.3	M05B5.4
+T25G3.4	M05B5.4
+T27A10.3	M05B5.4
+W07A8.2	M05B5.4
+W09B12.1	M05B5.4
+Y37E3.11	M05B5.4
+Y44E3A.2	M05B5.4
+Y46G5A.21	M05B5.4
+Y46G5A.5	M05B5.4
+Y48B6A.7	M05B5.4
+Y48G1C.4	M05B5.4
+ZC416.8	M05B5.4
+ZC506.3	M05B5.4
+ZK370.4	M05B5.4
+ZK40.1	M05B5.4
+ZK809.2	M05B5.4
+R07E3.5	M110.7
+R155.1	M110.7
+T05H4.1	M110.7
+T06E8.1	M110.7
+T12B3.3	M110.7
+T25G3.4	M110.7
+T27A10.3	M110.7
+W07A8.2	M110.7
+W09B12.1	M110.7
+Y37E3.11	M110.7
+Y44E3A.2	M110.7
+Y46G5A.21	M110.7
+Y46G5A.5	M110.7
+Y48B6A.7	M110.7
+Y48G1C.4	M110.7
+ZC416.8	M110.7
+ZC506.3	M110.7
+ZK370.4	M110.7
+ZK40.1	M110.7
+ZK809.2	M110.7
+R155.1	R07E3.5
+T12B3.3	R07E3.5
+T25G3.4	R07E3.5
+T27A10.3	R07E3.5
+W07A8.2	R07E3.5
+W09B12.1	R07E3.5
+Y37E3.11	R07E3.5
+Y44E3A.2	R07E3.5
+Y46G5A.21	R07E3.5
+Y46G5A.5	R07E3.5
+Y48B6A.7	R07E3.5
+Y48G1C.4	R07E3.5
+ZC416.8	R07E3.5
+ZC506.3	R07E3.5
+ZK370.4	R07E3.5
+ZK809.2	R07E3.5
+T05H4.1	R155.1
+T06E8.1	R155.1
+T12B3.3	R155.1
+T25G3.4	R155.1
+T27A10.3	R155.1
+W07A8.2	R155.1
+W09B12.1	R155.1
+Y37E3.11	R155.1
+Y44E3A.2	R155.1
+Y46G5A.21	R155.1
+Y46G5A.5	R155.1
+Y48B6A.7	R155.1
+Y48G1C.4	R155.1
+ZC416.8	R155.1
+ZC506.3	R155.1
+ZK370.4	R155.1
+ZK40.1	R155.1
+ZK809.2	R155.1
+T12B3.3	T05H4.1
+T25G3.4	T05H4.1
+T27A10.3	T05H4.1
+W07A8.2	T05H4.1
+W09B12.1	T05H4.1
+Y37E3.11	T05H4.1
+Y44E3A.2	T05H4.1
+Y46G5A.21	T05H4.1
+Y46G5A.5	T05H4.1
+Y48B6A.7	T05H4.1
+Y48G1C.4	T05H4.1
+ZC416.8	T05H4.1
+ZC506.3	T05H4.1
+ZK370.4	T05H4.1
+ZK809.2	T05H4.1
+T12B3.3	T06E8.1
+T25G3.4	T06E8.1
+T27A10.3	T06E8.1
+W07A8.2	T06E8.1
+W09B12.1	T06E8.1
+Y37E3.11	T06E8.1
+Y44E3A.2	T06E8.1
+Y46G5A.21	T06E8.1
+Y46G5A.5	T06E8.1
+Y48B6A.7	T06E8.1
+Y48G1C.4	T06E8.1
+ZC416.8	T06E8.1
+ZC506.3	T06E8.1
+ZK370.4	T06E8.1
+ZK809.2	T06E8.1
+T25G3.4	T12B3.3
+T27A10.3	T12B3.3
+W07A8.2	T12B3.3
+W09B12.1	T12B3.3
+Y37E3.11	T12B3.3
+Y44E3A.2	T12B3.3
+Y46G5A.21	T12B3.3
+Y46G5A.5	T12B3.3
+Y48B6A.7	T12B3.3
+Y48G1C.4	T12B3.3
+ZC416.8	T12B3.3
+ZC506.3	T12B3.3
+ZK370.4	T12B3.3
+ZK40.1	T12B3.3
+ZK809.2	T12B3.3
+T27A10.3	T25G3.4
+W07A8.2	T25G3.4
+W09B12.1	T25G3.4
+Y37E3.11	T25G3.4
+Y44E3A.2	T25G3.4
+Y46G5A.21	T25G3.4
+Y46G5A.5	T25G3.4
+Y48B6A.7	T25G3.4
+Y48G1C.4	T25G3.4
+ZC416.8	T25G3.4
+ZC506.3	T25G3.4
+ZK370.4	T25G3.4
+ZK40.1	T25G3.4
+ZK809.2	T25G3.4
+W07A8.2	T27A10.3
+W09B12.1	T27A10.3
+Y37E3.11	T27A10.3
+Y44E3A.2	T27A10.3
+Y46G5A.21	T27A10.3
+Y46G5A.5	T27A10.3
+Y48B6A.7	T27A10.3
+Y48G1C.4	T27A10.3
+ZC416.8	T27A10.3
+ZC506.3	T27A10.3
+ZK370.4	T27A10.3
+ZK40.1	T27A10.3
+ZK809.2	T27A10.3
+W09B12.1	W07A8.2
+Y37E3.11	W07A8.2
+Y44E3A.2	W07A8.2
+Y46G5A.21	W07A8.2
+Y46G5A.5	W07A8.2
+Y48B6A.7	W07A8.2
+Y48G1C.4	W07A8.2
+ZC416.8	W07A8.2
+ZC506.3	W07A8.2
+ZK370.4	W07A8.2
+ZK40.1	W07A8.2
+ZK809.2	W07A8.2
+Y37E3.11	W09B12.1
+Y46G5A.21	W09B12.1
+Y46G5A.5	W09B12.1
+Y48G1C.4	W09B12.1
+ZC416.8	W09B12.1
+ZC506.3	W09B12.1
+ZK370.4	W09B12.1
+ZK40.1	W09B12.1
+ZK809.2	W09B12.1
+Y44E3A.2	Y37E3.11
+Y46G5A.21	Y37E3.11
+Y46G5A.5	Y37E3.11
+Y48B6A.7	Y37E3.11
+Y48G1C.4	Y37E3.11
+ZC416.8	Y37E3.11
+ZC506.3	Y37E3.11
+ZK370.4	Y37E3.11
+ZK40.1	Y37E3.11
+ZK809.2	Y37E3.11
+Y46G5A.21	Y44E3A.2
+Y46G5A.5	Y44E3A.2
+Y48G1C.4	Y44E3A.2
+ZC416.8	Y44E3A.2
+ZC506.3	Y44E3A.2
+ZK370.4	Y44E3A.2
+ZK40.1	Y44E3A.2
+ZK809.2	Y44E3A.2
+Y46G5A.5	Y46G5A.21
+Y48B6A.7	Y46G5A.21
+Y48G1C.4	Y46G5A.21
+ZC416.8	Y46G5A.21
+ZC506.3	Y46G5A.21
+ZK370.4	Y46G5A.21
+ZK40.1	Y46G5A.21
+ZK809.2	Y46G5A.21
+Y48B6A.7	Y46G5A.5
+Y48G1C.4	Y46G5A.5
+ZC416.8	Y46G5A.5
+ZC506.3	Y46G5A.5
+ZK370.4	Y46G5A.5
+ZK40.1	Y46G5A.5
+ZK809.2	Y46G5A.5
+Y48G1C.4	Y48B6A.7
+ZC416.8	Y48B6A.7
+ZC506.3	Y48B6A.7
+ZK370.4	Y48B6A.7
+ZK40.1	Y48B6A.7
+ZK809.2	Y48B6A.7
+ZC416.8	Y48G1C.4
+ZC506.3	Y48G1C.4
+ZK370.4	Y48G1C.4
+ZK40.1	Y48G1C.4
+ZK809.2	Y48G1C.4
+ZC506.3	ZC416.8
+ZK370.4	ZC416.8
+ZK40.1	ZC416.8
+ZK809.2	ZC416.8
+ZK370.4	ZC506.3
+ZK40.1	ZC506.3
+ZK809.2	ZC506.3
+ZK40.1	ZK370.4
+ZK809.2	ZK370.4
+ZK809.2	ZK40.1
+C52B9.7	C03H5.4
+T03F6.5	C03H5.4
+T03G6.3	C03H5.4
+Y50D7A.7	C03H5.4
+C52B9.7	C04G6.3
+T03F6.5	C04G6.3
+T03G6.3	C04G6.3
+Y50D7A.7	C04G6.3
+C52B9.7	C07E3.9
+T03F6.5	C07E3.9
+T03G6.3	C07E3.9
+Y50D7A.7	C07E3.9
+F22E10.5	C52B9.7
+F54D7.2	C52B9.7
+T03F6.5	C52B9.7
+T03G6.3	C52B9.7
+W07A8.2	C52B9.7
+Y50D7A.7	C52B9.7
+T03F6.5	F22E10.5
+T03G6.3	F22E10.5
+Y50D7A.7	F22E10.5
+T03F6.5	F54D7.2
+T03G6.3	F54D7.2
+Y50D7A.7	F54D7.2
+T03G6.3	T03F6.5
+W07A8.2	T03F6.5
+Y50D7A.7	T03F6.5
+W07A8.2	T03G6.3
+Y50D7A.7	T03G6.3
+Y50D7A.7	W07A8.2
+C11E4.1	C03H5.4
+C11E4.2	C03H5.4
+C53D5.5	C03H5.4
+F26E4.12	C03H5.4
+R03G5.5	C03H5.4
+R05H10.5	C03H5.4
+R11A8.5	C03H5.4
+T03D8.6	C03H5.4
+Y7A9A.1	C03H5.4
+ZC395.10	C03H5.4
+ZC416.6	C03H5.4
+C11E4.1	C07E3.9
+C11E4.2	C07E3.9
+C53D5.5	C07E3.9
+F26E4.12	C07E3.9
+R03G5.5	C07E3.9
+R05H10.5	C07E3.9
+R11A8.5	C07E3.9
+T03D8.6	C07E3.9
+Y7A9A.1	C07E3.9
+ZC395.10	C07E3.9
+ZC416.6	C07E3.9
+R11A8.5	C11E4.1
+W07A8.2	C11E4.1
+ZC395.10	C11E4.1
+ZC416.6	C11E4.1
+R11A8.5	C11E4.2
+W07A8.2	C11E4.2
+ZC395.10	C11E4.2
+ZC416.6	C11E4.2
+R11A8.5	C53D5.5
+W07A8.2	C53D5.5
+ZC395.10	C53D5.5
+ZC416.6	C53D5.5
+R11A8.5	F26E4.12
+W07A8.2	F26E4.12
+ZC395.10	F26E4.12
+ZC416.6	F26E4.12
+R11A8.5	R03G5.5
+W07A8.2	R03G5.5
+ZC395.10	R03G5.5
+ZC416.6	R03G5.5
+R11A8.5	R05H10.5
+W07A8.2	R05H10.5
+ZC395.10	R05H10.5
+ZC416.6	R05H10.5
+T03D8.6	R11A8.5
+W07A8.2	R11A8.5
+Y7A9A.1	R11A8.5
+ZC395.10	R11A8.5
+ZC416.6	R11A8.5
+W07A8.2	T03D8.6
+ZC395.10	T03D8.6
+ZC416.6	T03D8.6
+Y7A9A.1	W07A8.2
+ZC395.10	W07A8.2
+ZC416.6	W07A8.2
+ZC395.10	Y7A9A.1
+ZC416.6	Y7A9A.1
+ZC416.6	ZC395.10
+C06B3.4	C03H5.4
+C06B3.5	C03H5.4
+C56G2.6	C03H5.4
+F11A5.12	C03H5.4
+F25G6.5	C03H5.4
+C07E3.9	C06B3.4
+W07A8.2	C06B3.4
+C07E3.9	C06B3.5
+W07A8.2	C06B3.5
+C56G2.6	C07E3.9
+F11A5.12	C07E3.9
+F25G6.5	C07E3.9
+W07A8.2	C56G2.6
+W07A8.2	F11A5.12
+W07A8.2	F25G6.5
+C48B4.1	C03H5.4
+F08A8.1	C03H5.4
+F08A8.2	C03H5.4
+F08A8.3	C03H5.4
+F08A8.4	C03H5.4
+F58F9.7	C03H5.4
+F59F4.1	C03H5.4
+C48B4.1	C07E3.9
+F08A8.1	C07E3.9
+F08A8.2	C07E3.9
+F08A8.3	C07E3.9
+F08A8.4	C07E3.9
+F58F9.7	C07E3.9
+F59F4.1	C07E3.9
+W07A8.2	C48B4.1
+W07A8.2	F08A8.1
+W07A8.2	F08A8.2
+W07A8.2	F08A8.3
+W07A8.2	F08A8.4
+W07A8.2	F58F9.7
+W07A8.2	F59F4.1
+C29E4.10	B0252.2
+C33C12.3	B0252.2
+C33C12.8	B0252.2
+F11E6.1	B0252.2
+F33D4.4	B0252.2
+F43H9.2	B0252.2
+F53H8.4	B0252.2
+F59G1.1	B0252.2
+H21P03.3	B0252.2
+K02G10.6	B0252.2
+K11D2.2	B0252.2
+T10B11.2	B0252.2
+T19B10.3	B0252.2
+T22G5.5	B0252.2
+T27F6.6	B0252.2
+Y22D7AL.8	B0252.2
+Y4C6B.6	B0252.2
+Y54E5A.1	B0252.2
+Y66H1B.4	B0252.2
+Y6B3B.10	B0252.2
+C29E4.10	C09G4.1
+C33C12.3	C09G4.1
+C33C12.8	C09G4.1
+F11E6.1	C09G4.1
+F33D4.4	C09G4.1
+F43H9.2	C09G4.1
+F53H8.4	C09G4.1
+F59G1.1	C09G4.1
+H21P03.3	C09G4.1
+K02G10.6	C09G4.1
+K11D2.2	C09G4.1
+R05D11.9	C09G4.1
+T10B11.2	C09G4.1
+T19B10.3	C09G4.1
+T22G5.5	C09G4.1
+T27F6.6	C09G4.1
+Y22D7AL.8	C09G4.1
+Y4C6B.6	C09G4.1
+Y54E5A.1	C09G4.1
+Y66H1B.4	C09G4.1
+Y6B3B.10	C09G4.1
+C33C12.3	C29E4.10
+C33C12.8	C29E4.10
+F11E6.1	C29E4.10
+F33D4.4	C29E4.10
+F43H9.2	C29E4.10
+F53H8.4	C29E4.10
+F59G1.1	C29E4.10
+H21P03.3	C29E4.10
+K02G10.6	C29E4.10
+K11D2.2	C29E4.10
+R05D11.9	C29E4.10
+T10B11.2	C29E4.10
+T19B10.3	C29E4.10
+T22G5.5	C29E4.10
+T27F6.6	C29E4.10
+W03G1.7	C29E4.10
+Y22D7AL.8	C29E4.10
+Y4C6B.6	C29E4.10
+Y54E5A.1	C29E4.10
+Y66H1B.4	C29E4.10
+Y6B3B.10	C29E4.10
+ZK455.4	C29E4.10
+F33D4.4	C33C12.3
+F43H9.2	C33C12.3
+F53H8.4	C33C12.3
+F59G1.1	C33C12.3
+H21P03.3	C33C12.3
+K02G10.6	C33C12.3
+K11D2.2	C33C12.3
+R05D11.9	C33C12.3
+T10B11.2	C33C12.3
+T22G5.5	C33C12.3
+T27F6.6	C33C12.3
+W03G1.7	C33C12.3
+Y22D7AL.8	C33C12.3
+Y54E5A.1	C33C12.3
+Y66H1B.4	C33C12.3
+Y6B3B.10	C33C12.3
+ZK455.4	C33C12.3
+F33D4.4	C33C12.8
+F43H9.2	C33C12.8
+F53H8.4	C33C12.8
+F59G1.1	C33C12.8
+H21P03.3	C33C12.8
+K02G10.6	C33C12.8
+K11D2.2	C33C12.8
+R05D11.9	C33C12.8
+T10B11.2	C33C12.8
+T22G5.5	C33C12.8
+T27F6.6	C33C12.8
+W03G1.7	C33C12.8
+Y22D7AL.8	C33C12.8
+Y54E5A.1	C33C12.8
+Y66H1B.4	C33C12.8
+Y6B3B.10	C33C12.8
+ZK455.4	C33C12.8
+F33D4.4	F11E6.1
+F43H9.2	F11E6.1
+F53H8.4	F11E6.1
+F59G1.1	F11E6.1
+H21P03.3	F11E6.1
+K02G10.6	F11E6.1
+K11D2.2	F11E6.1
+R05D11.9	F11E6.1
+T10B11.2	F11E6.1
+T22G5.5	F11E6.1
+T27F6.6	F11E6.1
+W03G1.7	F11E6.1
+Y22D7AL.8	F11E6.1
+Y54E5A.1	F11E6.1
+Y66H1B.4	F11E6.1
+Y6B3B.10	F11E6.1
+ZK455.4	F11E6.1
+F43H9.2	F33D4.4
+F53H8.4	F33D4.4
+F59G1.1	F33D4.4
+H21P03.3	F33D4.4
+K02G10.6	F33D4.4
+K11D2.2	F33D4.4
+R05D11.9	F33D4.4
+T10B11.2	F33D4.4
+T19B10.3	F33D4.4
+T22G5.5	F33D4.4
+T27F6.6	F33D4.4
+W03G1.7	F33D4.4
+Y22D7AL.8	F33D4.4
+Y4C6B.6	F33D4.4
+Y54E5A.1	F33D4.4
+Y66H1B.4	F33D4.4
+Y6B3B.10	F33D4.4
+ZK455.4	F33D4.4
+F53H8.4	F43H9.2
+F59G1.1	F43H9.2
+H21P03.3	F43H9.2
+K02G10.6	F43H9.2
+K11D2.2	F43H9.2
+R05D11.9	F43H9.2
+T10B11.2	F43H9.2
+T19B10.3	F43H9.2
+T22G5.5	F43H9.2
+T27F6.6	F43H9.2
+W03G1.7	F43H9.2
+Y22D7AL.8	F43H9.2
+Y4C6B.6	F43H9.2
+Y54E5A.1	F43H9.2
+Y66H1B.4	F43H9.2
+Y6B3B.10	F43H9.2
+ZK455.4	F43H9.2
+F59G1.1	F53H8.4
+K02G10.6	F53H8.4
+K11D2.2	F53H8.4
+R05D11.9	F53H8.4
+T10B11.2	F53H8.4
+T19B10.3	F53H8.4
+T22G5.5	F53H8.4
+T27F6.6	F53H8.4
+W03G1.7	F53H8.4
+Y4C6B.6	F53H8.4
+Y54E5A.1	F53H8.4
+Y66H1B.4	F53H8.4
+Y6B3B.10	F53H8.4
+ZK455.4	F53H8.4
+H21P03.3	F59G1.1
+K02G10.6	F59G1.1
+K11D2.2	F59G1.1
+R05D11.9	F59G1.1
+T10B11.2	F59G1.1
+T19B10.3	F59G1.1
+T22G5.5	F59G1.1
+T27F6.6	F59G1.1
+W03G1.7	F59G1.1
+Y22D7AL.8	F59G1.1
+Y4C6B.6	F59G1.1
+Y54E5A.1	F59G1.1
+Y66H1B.4	F59G1.1
+Y6B3B.10	F59G1.1
+ZK455.4	F59G1.1
+K02G10.6	H21P03.3
+K11D2.2	H21P03.3
+R05D11.9	H21P03.3
+T10B11.2	H21P03.3
+T19B10.3	H21P03.3
+T22G5.5	H21P03.3
+T27F6.6	H21P03.3
+W03G1.7	H21P03.3
+Y4C6B.6	H21P03.3
+Y54E5A.1	H21P03.3
+Y66H1B.4	H21P03.3
+Y6B3B.10	H21P03.3
+ZK455.4	H21P03.3
+K11D2.2	K02G10.6
+R05D11.9	K02G10.6
+T10B11.2	K02G10.6
+T19B10.3	K02G10.6
+T22G5.5	K02G10.6
+T27F6.6	K02G10.6
+W03G1.7	K02G10.6
+Y22D7AL.8	K02G10.6
+Y4C6B.6	K02G10.6
+Y54E5A.1	K02G10.6
+Y66H1B.4	K02G10.6
+Y6B3B.10	K02G10.6
+ZK455.4	K02G10.6
+R05D11.9	K11D2.2
+T10B11.2	K11D2.2
+T19B10.3	K11D2.2
+T22G5.5	K11D2.2
+T27F6.6	K11D2.2
+W03G1.7	K11D2.2
+Y22D7AL.8	K11D2.2
+Y4C6B.6	K11D2.2
+Y54E5A.1	K11D2.2
+Y66H1B.4	K11D2.2
+Y6B3B.10	K11D2.2
+ZK455.4	K11D2.2
+T10B11.2	R05D11.9
+T19B10.3	R05D11.9
+T22G5.5	R05D11.9
+T27F6.6	R05D11.9
+Y22D7AL.8	R05D11.9
+Y4C6B.6	R05D11.9
+Y54E5A.1	R05D11.9
+Y66H1B.4	R05D11.9
+Y6B3B.10	R05D11.9
+T19B10.3	T10B11.2
+T22G5.5	T10B11.2
+T27F6.6	T10B11.2
+W03G1.7	T10B11.2
+Y22D7AL.8	T10B11.2
+Y4C6B.6	T10B11.2
+Y54E5A.1	T10B11.2
+Y66H1B.4	T10B11.2
+Y6B3B.10	T10B11.2
+ZK455.4	T10B11.2
+T22G5.5	T19B10.3
+T27F6.6	T19B10.3
+W03G1.7	T19B10.3
+Y22D7AL.8	T19B10.3
+Y54E5A.1	T19B10.3
+Y66H1B.4	T19B10.3
+Y6B3B.10	T19B10.3
+ZK455.4	T19B10.3
+T27F6.6	T22G5.5
+W03G1.7	T22G5.5
+Y22D7AL.8	T22G5.5
+Y4C6B.6	T22G5.5
+Y54E5A.1	T22G5.5
+Y66H1B.4	T22G5.5
+Y6B3B.10	T22G5.5
+ZK455.4	T22G5.5
+W03G1.7	T27F6.6
+Y22D7AL.8	T27F6.6
+Y4C6B.6	T27F6.6
+Y54E5A.1	T27F6.6
+Y66H1B.4	T27F6.6
+Y6B3B.10	T27F6.6
+ZK455.4	T27F6.6
+Y22D7AL.8	W03G1.7
+Y4C6B.6	W03G1.7
+Y54E5A.1	W03G1.7
+Y66H1B.4	W03G1.7
+Y6B3B.10	W03G1.7
+Y4C6B.6	Y22D7AL.8
+Y54E5A.1	Y22D7AL.8
+Y66H1B.4	Y22D7AL.8
+Y6B3B.10	Y22D7AL.8
+ZK455.4	Y22D7AL.8
+Y54E5A.1	Y4C6B.6
+Y66H1B.4	Y4C6B.6
+Y6B3B.10	Y4C6B.6
+ZK455.4	Y4C6B.6
+Y66H1B.4	Y54E5A.1
+Y6B3B.10	Y54E5A.1
+ZK455.4	Y54E5A.1
+Y6B3B.10	Y66H1B.4
+ZK455.4	Y66H1B.4
+ZK455.4	Y6B3B.10
+T26C5.3	T14F9.3
+T26C5.3	T19B10.3
+F32D8.12	C04C3.3
+T02G5.4	C04C3.3
+T02G5.7	C04C3.3
+T02G5.8	C04C3.3
+T21C9.6	C04C3.3
+W09B6.1	C04C3.3
+Y17G7B.3	C04C3.3
+Y39G8B.1	C04C3.3
+Y48B6A.12	C04C3.3
+F32D8.12	C30H6.7
+T02G5.4	C30H6.7
+T02G5.7	C30H6.7
+T02G5.8	C30H6.7
+T21C9.6	C30H6.7
+W09B6.1	C30H6.7
+Y17G7B.3	C30H6.7
+Y39G8B.1	C30H6.7
+Y48B6A.12	C30H6.7
+D2023.2	C36A4.9
+F20H11.3	C36A4.9
+F32D8.12	C36A4.9
+F46E10.10	C36A4.9
+T02G5.4	C36A4.9
+T02G5.7	C36A4.9
+T02G5.8	C36A4.9
+T21C9.6	C36A4.9
+W09B6.1	C36A4.9
+Y17G7B.3	C36A4.9
+Y39G8B.1	C36A4.9
+Y48B6A.12	C36A4.9
+F01F1.6	D2023.2
+F13D12.2	D2023.2
+F25H5.3	D2023.2
+F32D8.12	D2023.2
+F54D8.3	D2023.2
+K04F1.15	D2023.2
+T02G5.4	D2023.2
+T02G5.7	D2023.2
+T02G5.8	D2023.2
+T05H4.13	D2023.2
+T21C9.6	D2023.2
+W09B6.1	D2023.2
+Y17G7B.3	D2023.2
+Y39G8B.1	D2023.2
+Y48B6A.12	D2023.2
+Y69F12A.2	D2023.2
+ZK593.1	D2023.2
+F20H11.3	F01F1.6
+F32D8.12	F01F1.6
+F46E10.10	F01F1.6
+T21C9.6	F01F1.6
+W09B6.1	F01F1.6
+Y17G7B.3	F01F1.6
+Y48B6A.12	F01F1.6
+F20H11.3	F13D12.2
+F32D8.12	F13D12.2
+F46E10.10	F13D12.2
+T02G5.4	F13D12.2
+T02G5.7	F13D12.2
+T02G5.8	F13D12.2
+T21C9.6	F13D12.2
+W09B6.1	F13D12.2
+Y17G7B.3	F13D12.2
+Y39G8B.1	F13D12.2
+Y48B6A.12	F13D12.2
+F25H5.3	F20H11.3
+F32D8.12	F20H11.3
+F54D8.3	F20H11.3
+K04F1.15	F20H11.3
+T02G5.4	F20H11.3
+T02G5.7	F20H11.3
+T02G5.8	F20H11.3
+T05H4.13	F20H11.3
+T21C9.6	F20H11.3
+W09B6.1	F20H11.3
+Y17G7B.3	F20H11.3
+Y39G8B.1	F20H11.3
+Y48B6A.12	F20H11.3
+Y69F12A.2	F20H11.3
+ZK593.1	F20H11.3
+F32D8.12	F23B12.5
+T02G5.4	F23B12.5
+T02G5.7	F23B12.5
+T02G5.8	F23B12.5
+T21C9.6	F23B12.5
+W09B6.1	F23B12.5
+Y17G7B.3	F23B12.5
+Y39G8B.1	F23B12.5
+Y48B6A.12	F23B12.5
+F32D8.12	F25H5.3
+F46E10.10	F25H5.3
+T02G5.4	F25H5.3
+T02G5.7	F25H5.3
+T02G5.8	F25H5.3
+T21C9.6	F25H5.3
+W09B6.1	F25H5.3
+Y17G7B.3	F25H5.3
+Y39G8B.1	F25H5.3
+Y48B6A.12	F25H5.3
+F46E10.10	F32D8.12
+F54D8.3	F32D8.12
+K04F1.15	F32D8.12
+LLC1.3	F32D8.12
+R11A5.4	F32D8.12
+T02G5.4	F32D8.12
+T02G5.7	F32D8.12
+T02G5.8	F32D8.12
+T05H10.6	F32D8.12
+T05H4.13	F32D8.12
+T21C9.6	F32D8.12
+W05G11.6	F32D8.12
+W09B6.1	F32D8.12
+Y17G7B.3	F32D8.12
+Y39G8B.1	F32D8.12
+Y48B6A.12	F32D8.12
+Y69F12A.2	F32D8.12
+ZK593.1	F32D8.12
+F54D8.3	F46E10.10
+K04F1.15	F46E10.10
+T02G5.4	F46E10.10
+T02G5.7	F46E10.10
+T02G5.8	F46E10.10
+T05H4.13	F46E10.10
+T21C9.6	F46E10.10
+W09B6.1	F46E10.10
+Y17G7B.3	F46E10.10
+Y39G8B.1	F46E10.10
+Y48B6A.12	F46E10.10
+Y69F12A.2	F46E10.10
+ZK593.1	F46E10.10
+T21C9.6	F54D8.3
+W09B6.1	F54D8.3
+Y17G7B.3	F54D8.3
+Y48B6A.12	F54D8.3
+T21C9.6	K04F1.15
+W09B6.1	K04F1.15
+Y17G7B.3	K04F1.15
+Y48B6A.12	K04F1.15
+T21C9.6	LLC1.3
+W09B6.1	LLC1.3
+Y17G7B.3	LLC1.3
+Y39G8B.1	LLC1.3
+Y48B6A.12	LLC1.3
+T02G5.4	R11A5.4
+T02G5.7	R11A5.4
+T02G5.8	R11A5.4
+T21C9.6	R11A5.4
+W09B6.1	R11A5.4
+Y17G7B.3	R11A5.4
+Y39G8B.1	R11A5.4
+Y48B6A.12	R11A5.4
+T05H10.6	T02G5.4
+T21C9.6	T02G5.4
+W05G11.6	T02G5.4
+W09B6.1	T02G5.4
+Y17G7B.3	T02G5.4
+Y39G8B.1	T02G5.4
+Y48B6A.12	T02G5.4
+ZK593.1	T02G5.4
+T05H10.6	T02G5.7
+T21C9.6	T02G5.7
+W05G11.6	T02G5.7
+W09B6.1	T02G5.7
+Y17G7B.3	T02G5.7
+Y39G8B.1	T02G5.7
+Y48B6A.12	T02G5.7
+ZK593.1	T02G5.7
+T05H10.6	T02G5.8
+T21C9.6	T02G5.8
+W05G11.6	T02G5.8
+W09B6.1	T02G5.8
+Y17G7B.3	T02G5.8
+Y39G8B.1	T02G5.8
+Y48B6A.12	T02G5.8
+ZK593.1	T02G5.8
+T21C9.6	T05H10.6
+W09B6.1	T05H10.6
+Y17G7B.3	T05H10.6
+Y39G8B.1	T05H10.6
+Y48B6A.12	T05H10.6
+T21C9.6	T05H4.13
+W09B6.1	T05H4.13
+Y17G7B.3	T05H4.13
+Y48B6A.12	T05H4.13
+W05G11.6	T21C9.6
+W09B6.1	T21C9.6
+Y17G7B.3	T21C9.6
+Y39G8B.1	T21C9.6
+Y48B6A.12	T21C9.6
+Y69F12A.2	T21C9.6
+ZK593.1	T21C9.6
+W09B6.1	W05G11.6
+Y17G7B.3	W05G11.6
+Y39G8B.1	W05G11.6
+Y48B6A.12	W05G11.6
+Y17G7B.3	W09B6.1
+Y39G8B.1	W09B6.1
+Y48B6A.12	W09B6.1
+Y69F12A.2	W09B6.1
+ZK593.1	W09B6.1
+Y39G8B.1	Y17G7B.3
+Y48B6A.12	Y17G7B.3
+Y69F12A.2	Y17G7B.3
+ZK593.1	Y17G7B.3
+Y48B6A.12	Y39G8B.1
+ZK593.1	Y39G8B.1
+Y69F12A.2	Y48B6A.12
+ZK593.1	Y48B6A.12
+D2030.5	C13B9.2
+F20H11.3	C13B9.2
+F27D9.5	C13B9.2
+F41E6.5	C13B9.2
+F46E10.10	C13B9.2
+F52E4.1	C13B9.2
+F54H12.1	C13B9.2
+T02G5.4	C13B9.2
+T02G5.7	C13B9.2
+T02G5.8	C13B9.2
+T20G5.2	C13B9.2
+ZK1058.1	C13B9.2
+ZK455.1	C13B9.2
+F20H11.3	D2030.5
+F41E6.5	D2030.5
+F46E10.10	D2030.5
+F54H12.1	D2030.5
+T20G5.2	D2030.5
+ZK455.1	D2030.5
+F27D9.5	F20H11.3
+F41E6.5	F20H11.3
+F52E4.1	F20H11.3
+ZK1058.1	F20H11.3
+F41E6.5	F27D9.5
+F46E10.10	F27D9.5
+F54H12.1	F27D9.5
+T20G5.2	F27D9.5
+ZK455.1	F27D9.5
+F46E10.10	F41E6.5
+F52E4.1	F41E6.5
+F54H12.1	F41E6.5
+T02G5.4	F41E6.5
+T02G5.7	F41E6.5
+T02G5.8	F41E6.5
+T20G5.2	F41E6.5
+ZK1058.1	F41E6.5
+ZK455.1	F41E6.5
+F52E4.1	F46E10.10
+ZK1058.1	F46E10.10
+F54H12.1	F52E4.1
+T20G5.2	F52E4.1
+ZK455.1	F52E4.1
+T02G5.4	F54H12.1
+T02G5.7	F54H12.1
+T02G5.8	F54H12.1
+ZK1058.1	F54H12.1
+T20G5.2	T02G5.4
+ZK455.1	T02G5.4
+T20G5.2	T02G5.7
+ZK455.1	T02G5.7
+T20G5.2	T02G5.8
+ZK455.1	T02G5.8
+ZK1058.1	T20G5.2
+ZK455.1	ZK1058.1
+C29F3.1	C05G5.4
+C36A4.9	C05G5.4
+D2030.5	C05G5.4
+F01F1.6	C05G5.4
+F09F7.4	C05G5.4
+F13D12.2	C05G5.4
+F13D12.4	C05G5.4
+F27D9.5	C05G5.4
+F52E4.1	C05G5.4
+F54D8.3	C05G5.4
+K04D7.3	C05G5.4
+K04F1.15	C05G5.4
+K05F1.3	C05G5.4
+K09H11.1	C05G5.4
+T02G5.4	C05G5.4
+T02G5.7	C05G5.4
+T02G5.8	C05G5.4
+T05G5.6	C05G5.4
+T05H4.13	C05G5.4
+T08B2.7	C05G5.4
+T08G2.3	C05G5.4
+T25G12.5	C05G5.4
+W09B6.1	C05G5.4
+Y69F12A.2	C05G5.4
+ZK1058.1	C05G5.4
+C36A4.9	C29F3.1
+C50F7.4	C29F3.1
+F13D12.2	C29F3.1
+F23H11.3	C29F3.1
+F47B10.1	C29F3.1
+W09B6.1	C29F3.1
+C50F7.4	C36A4.9
+D2030.5	C36A4.9
+F09F7.4	C36A4.9
+F13D12.4	C36A4.9
+F23H11.3	C36A4.9
+F27D9.5	C36A4.9
+F47B10.1	C36A4.9
+F52E4.1	C36A4.9
+K04D7.3	C36A4.9
+K05F1.3	C36A4.9
+K09H11.1	C36A4.9
+T05G5.6	C36A4.9
+T08B2.7	C36A4.9
+T08G2.3	C36A4.9
+T25G12.5	C36A4.9
+ZK1058.1	C36A4.9
+D2030.5	C50F7.4
+F01F1.6	C50F7.4
+F09F7.4	C50F7.4
+F13D12.2	C50F7.4
+F13D12.4	C50F7.4
+F27D9.5	C50F7.4
+F52E4.1	C50F7.4
+F54D8.3	C50F7.4
+K04D7.3	C50F7.4
+K04F1.15	C50F7.4
+K05F1.3	C50F7.4
+K09H11.1	C50F7.4
+T02G5.4	C50F7.4
+T02G5.7	C50F7.4
+T02G5.8	C50F7.4
+T05G5.6	C50F7.4
+T05H4.13	C50F7.4
+T08B2.7	C50F7.4
+T08G2.3	C50F7.4
+T25G12.5	C50F7.4
+W09B6.1	C50F7.4
+Y69F12A.2	C50F7.4
+ZK1058.1	C50F7.4
+F13D12.2	D2030.5
+F23H11.3	D2030.5
+F47B10.1	D2030.5
+W09B6.1	D2030.5
+F23H11.3	F01F1.6
+F47B10.1	F01F1.6
+F13D12.2	F09F7.4
+F23H11.3	F09F7.4
+F47B10.1	F09F7.4
+W09B6.1	F09F7.4
+F13D12.4	F13D12.2
+F23H11.3	F13D12.2
+F27D9.5	F13D12.2
+F47B10.1	F13D12.2
+F52E4.1	F13D12.2
+K04D7.3	F13D12.2
+K05F1.3	F13D12.2
+K09H11.1	F13D12.2
+T05G5.6	F13D12.2
+T08B2.7	F13D12.2
+T08G2.3	F13D12.2
+T25G12.5	F13D12.2
+ZK1058.1	F13D12.2
+F23H11.3	F13D12.4
+F47B10.1	F13D12.4
+W09B6.1	F13D12.4
+F27D9.5	F23H11.3
+F52E4.1	F23H11.3
+F54D8.3	F23H11.3
+K04D7.3	F23H11.3
+K04F1.15	F23H11.3
+K05F1.3	F23H11.3
+K09H11.1	F23H11.3
+T02G5.4	F23H11.3
+T02G5.7	F23H11.3
+T02G5.8	F23H11.3
+T05G5.6	F23H11.3
+T05H4.13	F23H11.3
+T08B2.7	F23H11.3
+T08G2.3	F23H11.3
+T25G12.5	F23H11.3
+W09B6.1	F23H11.3
+Y69F12A.2	F23H11.3
+ZK1058.1	F23H11.3
+F47B10.1	F27D9.5
+W09B6.1	F27D9.5
+F52E4.1	F47B10.1
+F54D8.3	F47B10.1
+K04D7.3	F47B10.1
+K04F1.15	F47B10.1
+K05F1.3	F47B10.1
+K09H11.1	F47B10.1
+T02G5.4	F47B10.1
+T02G5.7	F47B10.1
+T02G5.8	F47B10.1
+T05G5.6	F47B10.1
+T05H4.13	F47B10.1
+T08B2.7	F47B10.1
+T08G2.3	F47B10.1
+T25G12.5	F47B10.1
+W09B6.1	F47B10.1
+Y69F12A.2	F47B10.1
+ZK1058.1	F47B10.1
+W09B6.1	F52E4.1
+W09B6.1	K04D7.3
+W09B6.1	K05F1.3
+W09B6.1	K09H11.1
+W09B6.1	T05G5.6
+W09B6.1	T08B2.7
+W09B6.1	T08G2.3
+W09B6.1	T25G12.5
+ZK1058.1	W09B6.1
+C04C3.3	B0272.3
+C06B3.4	B0272.3
+C06B3.5	B0272.3
+C56G2.6	B0272.3
+F11A5.12	B0272.3
+F25G6.5	B0272.3
+F45H10.1	B0272.3
+K03A1.5	B0272.3
+T05H10.6	B0272.3
+Y37D8A.23	B0272.3
+Y45G12B.3	B0272.3
+C05C10.3	C04C3.3
+C06B3.4	C04C3.3
+C06B3.5	C04C3.3
+C29F3.1	C04C3.3
+C56G2.6	C04C3.3
+F01G10.2	C04C3.3
+F01G10.3	C04C3.3
+F11A5.12	C04C3.3
+F25B4.6	C04C3.3
+F25G6.5	C04C3.3
+F45H10.1	C04C3.3
+F54C8.1	C04C3.3
+K03A1.5	C04C3.3
+K04D7.3	C04C3.3
+R09B5.6	C04C3.3
+T05G5.6	C04C3.3
+T08B2.7	C04C3.3
+Y37D8A.23	C04C3.3
+Y45G12B.3	C04C3.3
+Y71G12B.10	C04C3.3
+C06B3.4	C05C10.3
+C06B3.5	C05C10.3
+C56G2.6	C05C10.3
+F11A5.12	C05C10.3
+F25G6.5	C05C10.3
+F45H10.1	C05C10.3
+K03A1.5	C05C10.3
+T05H10.6	C05C10.3
+Y37D8A.23	C05C10.3
+Y45G12B.3	C05C10.3
+C29F3.1	C06B3.4
+F01G10.2	C06B3.4
+F01G10.3	C06B3.4
+F25B4.6	C06B3.4
+F45H10.1	C06B3.4
+F54C8.1	C06B3.4
+K03A1.5	C06B3.4
+K04D7.3	C06B3.4
+R09B5.6	C06B3.4
+T02G5.4	C06B3.4
+T02G5.7	C06B3.4
+T02G5.8	C06B3.4
+T05G5.6	C06B3.4
+T05H10.6	C06B3.4
+T08B2.7	C06B3.4
+Y37D8A.23	C06B3.4
+Y45G12B.3	C06B3.4
+Y71G12B.10	C06B3.4
+C29F3.1	C06B3.5
+F01G10.2	C06B3.5
+F01G10.3	C06B3.5
+F25B4.6	C06B3.5
+F45H10.1	C06B3.5
+F54C8.1	C06B3.5
+K03A1.5	C06B3.5
+K04D7.3	C06B3.5
+R09B5.6	C06B3.5
+T02G5.4	C06B3.5
+T02G5.7	C06B3.5
+T02G5.8	C06B3.5
+T05G5.6	C06B3.5
+T05H10.6	C06B3.5
+T08B2.7	C06B3.5
+Y37D8A.23	C06B3.5
+Y45G12B.3	C06B3.5
+Y71G12B.10	C06B3.5
+C56G2.6	C29F3.1
+F11A5.12	C29F3.1
+F25G6.5	C29F3.1
+F45H10.1	C29F3.1
+K03A1.5	C29F3.1
+T05H10.6	C29F3.1
+Y45G12B.3	C29F3.1
+F01G10.2	C56G2.6
+F01G10.3	C56G2.6
+F25B4.6	C56G2.6
+F45H10.1	C56G2.6
+F54C8.1	C56G2.6
+K03A1.5	C56G2.6
+K04D7.3	C56G2.6
+R09B5.6	C56G2.6
+T02G5.4	C56G2.6
+T02G5.7	C56G2.6
+T02G5.8	C56G2.6
+T05G5.6	C56G2.6
+T05H10.6	C56G2.6
+T08B2.7	C56G2.6
+Y37D8A.23	C56G2.6
+Y45G12B.3	C56G2.6
+Y71G12B.10	C56G2.6
+F11A5.12	F01G10.2
+F25G6.5	F01G10.2
+F45H10.1	F01G10.2
+K03A1.5	F01G10.2
+T05H10.6	F01G10.2
+Y37D8A.23	F01G10.2
+Y45G12B.3	F01G10.2
+F11A5.12	F01G10.3
+F25G6.5	F01G10.3
+F45H10.1	F01G10.3
+K03A1.5	F01G10.3
+T05H10.6	F01G10.3
+Y37D8A.23	F01G10.3
+Y45G12B.3	F01G10.3
+F25B4.6	F11A5.12
+F45H10.1	F11A5.12
+F54C8.1	F11A5.12
+K03A1.5	F11A5.12
+K04D7.3	F11A5.12
+R09B5.6	F11A5.12
+T02G5.4	F11A5.12
+T02G5.7	F11A5.12
+T02G5.8	F11A5.12
+T05G5.6	F11A5.12
+T05H10.6	F11A5.12
+T08B2.7	F11A5.12
+Y37D8A.23	F11A5.12
+Y45G12B.3	F11A5.12
+Y71G12B.10	F11A5.12
+F25G6.5	F25B4.6
+F45H10.1	F25B4.6
+K03A1.5	F25B4.6
+T05H10.6	F25B4.6
+Y37D8A.23	F25B4.6
+Y45G12B.3	F25B4.6
+F45H10.1	F25G6.5
+F54C8.1	F25G6.5
+K03A1.5	F25G6.5
+K04D7.3	F25G6.5
+R09B5.6	F25G6.5
+T02G5.4	F25G6.5
+T02G5.7	F25G6.5
+T02G5.8	F25G6.5
+T05G5.6	F25G6.5
+T05H10.6	F25G6.5
+T08B2.7	F25G6.5
+Y37D8A.23	F25G6.5
+Y45G12B.3	F25G6.5
+Y71G12B.10	F25G6.5
+F54C8.1	F45H10.1
+K03A1.5	F45H10.1
+R09B5.6	F45H10.1
+T02G5.4	F45H10.1
+T02G5.7	F45H10.1
+T02G5.8	F45H10.1
+T05G5.6	F45H10.1
+T05H10.6	F45H10.1
+T08B2.7	F45H10.1
+Y45G12B.3	F45H10.1
+Y71G12B.10	F45H10.1
+K03A1.5	F54C8.1
+T05H10.6	F54C8.1
+Y37D8A.23	F54C8.1
+Y45G12B.3	F54C8.1
+K04D7.3	K03A1.5
+R09B5.6	K03A1.5
+T02G5.4	K03A1.5
+T02G5.7	K03A1.5
+T02G5.8	K03A1.5
+T05G5.6	K03A1.5
+T05H10.6	K03A1.5
+T08B2.7	K03A1.5
+Y37D8A.23	K03A1.5
+Y45G12B.3	K03A1.5
+Y71G12B.10	K03A1.5
+T05H10.6	K04D7.3
+Y45G12B.3	K04D7.3
+T05H10.6	R09B5.6
+Y37D8A.23	R09B5.6
+Y45G12B.3	R09B5.6
+Y37D8A.23	T02G5.4
+Y45G12B.3	T02G5.4
+Y37D8A.23	T02G5.7
+Y45G12B.3	T02G5.7
+Y37D8A.23	T02G5.8
+Y45G12B.3	T02G5.8
+T05H10.6	T05G5.6
+Y45G12B.3	T05G5.6
+T08B2.7	T05H10.6
+Y37D8A.23	T05H10.6
+Y45G12B.3	T05H10.6
+Y71G12B.10	T05H10.6
+Y45G12B.3	T08B2.7
+Y45G12B.3	Y37D8A.23
+Y71G12B.10	Y37D8A.23
+Y71G12B.10	Y45G12B.3
+C06A8.1	C05D11.11
+C36B1.7	C05D11.11
+C55F2.1	C05D11.11
+F36H1.6	C05D11.11
+F38B6.4	C05D11.11
+K07E3.3	C05D11.11
+K07E3.4	C05D11.11
+R03D7.1	C05D11.11
+Y106G6E.4	C05D11.11
+Y110A7A.4	C05D11.11
+C36B1.7	C06A8.1
+C55F2.1	C06A8.1
+F25B4.1	C06A8.1
+F36H1.6	C06A8.1
+F38B6.4	C06A8.1
+K07E3.3	C06A8.1
+K07E3.4	C06A8.1
+R03D7.1	C06A8.1
+Y106G6E.4	C06A8.1
+Y110A7A.4	C06A8.1
+C55F2.1	C36B1.7
+F25B4.1	C36B1.7
+F36H1.6	C36B1.7
+F38B6.4	C36B1.7
+K07E3.3	C36B1.7
+K07E3.4	C36B1.7
+R03D7.1	C36B1.7
+Y106G6E.4	C36B1.7
+Y110A7A.4	C36B1.7
+F25B4.1	C55F2.1
+F36H1.6	C55F2.1
+K07E3.3	C55F2.1
+K07E3.4	C55F2.1
+R03D7.1	C55F2.1
+Y106G6E.4	C55F2.1
+Y110A7A.4	C55F2.1
+F36H1.6	F25B4.1
+F38B6.4	F25B4.1
+K07E3.3	F25B4.1
+K07E3.4	F25B4.1
+R03D7.1	F25B4.1
+Y106G6E.4	F25B4.1
+Y110A7A.4	F25B4.1
+F38B6.4	F36H1.6
+K07E3.3	F36H1.6
+K07E3.4	F36H1.6
+R03D7.1	F36H1.6
+Y106G6E.4	F36H1.6
+Y110A7A.4	F36H1.6
+K07E3.3	F38B6.4
+K07E3.4	F38B6.4
+R03D7.1	F38B6.4
+Y106G6E.4	F38B6.4
+Y110A7A.4	F38B6.4
+K07E3.4	K07E3.3
+R03D7.1	K07E3.3
+Y106G6E.4	K07E3.3
+Y110A7A.4	K07E3.3
+R03D7.1	K07E3.4
+Y106G6E.4	K07E3.4
+Y110A7A.4	K07E3.4
+Y106G6E.4	R03D7.1
+Y110A7A.4	R03D7.1
+Y110A7A.4	Y106G6E.4
+ZK637.9	B0205.6
+C05C10.1	B0361.7
+C05C10.4	B0361.7
+C34G6.2	B0361.7
+F02E9.7	B0361.7
+F26C11.1	B0361.7
+R53.1	B0361.7
+T13B5.3	B0361.7
+C05C10.4	C05C10.1
+C34G6.2	C05C10.1
+F02E9.7	C05C10.1
+F26C11.1	C05C10.1
+R53.1	C05C10.1
+T13B5.3	C05C10.1
+C34G6.2	C05C10.4
+F02E9.7	C05C10.4
+F26C11.1	C05C10.4
+R53.1	C05C10.4
+T13B5.3	C05C10.4
+F02E9.7	C34G6.2
+F26C11.1	C34G6.2
+R53.1	C34G6.2
+T13B5.3	C34G6.2
+F26C11.1	F02E9.7
+R53.1	F02E9.7
+T13B5.3	F02E9.7
+R53.1	F26C11.1
+T13B5.3	F26C11.1
+T13B5.3	R53.1
+F57B9.1	F26H9.5
+F57C9.1	F26H9.5
+F57C9.1	F57B9.1
+C24F3.4	C15H9.1
+F26H9.4	C15H9.1
+K02D7.1	C15H9.1
+W06B3.1	C15H9.1
+Y10G11A.1	C15H9.1
+Y54G2A.17	C15H9.1
+Y71H10B.1	C15H9.1
+F26H9.4	C24F3.4
+K02D7.1	C24F3.4
+W06B3.1	C24F3.4
+Y10G11A.1	C24F3.4
+Y54G2A.17	C24F3.4
+Y71H10B.1	C24F3.4
+K02D7.1	F26H9.4
+W06B3.1	F26H9.4
+Y10G11A.1	F26H9.4
+Y54G2A.17	F26H9.4
+Y71H10B.1	F26H9.4
+W06B3.1	K02D7.1
+Y54G2A.17	K02D7.1
+Y10G11A.1	W06B3.1
+Y54G2A.17	W06B3.1
+Y71H10B.1	W06B3.1
+Y54G2A.17	Y10G11A.1
+Y71H10B.1	Y54G2A.17
+C42D8.3	C25F6.3
+F25H9.6	C25F6.3
+K02A4.1	C25F6.3
+T04G9.4	C25F6.3
+T05G5.5	C25F6.3
+T28H10.1	C25F6.3
+Y44A6D.5	C25F6.3
+Y65B4A.8	C25F6.3
+Y71H2AM.6	C25F6.3
+C47E12.8	C42D8.3
+F13H8.7	C42D8.3
+F25H9.6	C42D8.3
+K02A4.1	C42D8.3
+T04G9.4	C42D8.3
+T05G5.5	C42D8.3
+T28H10.1	C42D8.3
+Y44A6D.5	C42D8.3
+Y65B4A.8	C42D8.3
+Y71H2AM.6	C42D8.3
+F25H9.6	C47E12.8
+K02A4.1	C47E12.8
+T04G9.4	C47E12.8
+T05G5.5	C47E12.8
+T28H10.1	C47E12.8
+Y44A6D.5	C47E12.8
+Y65B4A.8	C47E12.8
+Y71H2AM.6	C47E12.8
+F25H9.6	F13H8.7
+K02A4.1	F13H8.7
+T04G9.4	F13H8.7
+T05G5.5	F13H8.7
+T28H10.1	F13H8.7
+Y44A6D.5	F13H8.7
+Y65B4A.8	F13H8.7
+Y71H2AM.6	F13H8.7
+K02A4.1	F25H9.6
+T04G9.4	F25H9.6
+T05G5.5	F25H9.6
+T28H10.1	F25H9.6
+Y44A6D.5	F25H9.6
+Y65B4A.8	F25H9.6
+Y71H2AM.6	F25H9.6
+T04G9.4	K02A4.1
+T05G5.5	K02A4.1
+T28H10.1	K02A4.1
+Y65B4A.8	K02A4.1
+Y71H2AM.6	K02A4.1
+T05G5.5	T04G9.4
+T28H10.1	T04G9.4
+Y44A6D.5	T04G9.4
+Y65B4A.8	T04G9.4
+Y71H2AM.6	T04G9.4
+T28H10.1	T05G5.5
+Y44A6D.5	T05G5.5
+Y65B4A.8	T05G5.5
+Y71H2AM.6	T05G5.5
+Y44A6D.5	T28H10.1
+Y65B4A.8	T28H10.1
+Y71H2AM.6	T28H10.1
+Y65B4A.8	Y44A6D.5
+Y71H2AM.6	Y44A6D.5
+Y71H2AM.6	Y65B4A.8
+M01F1.3	C45G3.3
+C36B1.7	B0041.6
+F25B5.6	B0041.6
+F32G8.6	B0041.6
+F49H6.5	B0041.6
+K10D2.7	B0041.6
+T03F6.1	B0041.6
+T27A3.6	B0041.6
+Y105C5B.3	B0041.6
+F25B5.6	C36B1.7
+F32G8.6	C36B1.7
+F49H6.5	C36B1.7
+K10D2.7	C36B1.7
+T03F6.1	C36B1.7
+T27A3.6	C36B1.7
+Y105C5B.3	C36B1.7
+F32G8.6	F25B5.6
+F49H6.5	F25B5.6
+K10D2.7	F25B5.6
+T03F6.1	F25B5.6
+T27A3.6	F25B5.6
+Y105C5B.3	F25B5.6
+F49H6.5	F32G8.6
+K10D2.7	F32G8.6
+T03F6.1	F32G8.6
+T27A3.6	F32G8.6
+Y105C5B.3	F32G8.6
+K10D2.7	F49H6.5
+T03F6.1	F49H6.5
+T27A3.6	F49H6.5
+Y105C5B.3	F49H6.5
+T03F6.1	K10D2.7
+T27A3.6	K10D2.7
+Y105C5B.3	K10D2.7
+T27A3.6	T03F6.1
+Y105C5B.3	T03F6.1
+Y105C5B.3	T27A3.6
+D2063.1	B0310.5
+F36H9.3	B0310.5
+H19N07.4	B0310.5
+H24K24.3	B0310.5
+K12G11.3	B0310.5
+K12G11.4	B0310.5
+T02E1.5	B0310.5
+T11F9.11	B0310.5
+D2063.1	C17G1.3
+F36H9.3	C17G1.3
+H19N07.4	C17G1.3
+H24K24.3	C17G1.3
+K12G11.3	C17G1.3
+K12G11.4	C17G1.3
+T02E1.5	C17G1.3
+T11F9.11	C17G1.3
+D2063.1	C18C4.3
+F36H9.3	C18C4.3
+H19N07.4	C18C4.3
+H24K24.3	C18C4.3
+K12G11.3	C18C4.3
+K12G11.4	C18C4.3
+T02E1.5	C18C4.3
+T11F9.11	C18C4.3
+F35H8.6	D2063.1
+F36H9.3	D2063.1
+F39G3.1	D2063.1
+H19N07.4	D2063.1
+M88.1	D2063.1
+T02E1.5	D2063.1
+T04H1.7	D2063.1
+T04H1.8	D2063.1
+T07C5.1	D2063.1
+T11F9.11	D2063.1
+F36H9.3	F35H8.6
+H19N07.4	F35H8.6
+H24K24.3	F35H8.6
+K12G11.3	F35H8.6
+K12G11.4	F35H8.6
+T02E1.5	F35H8.6
+T11F9.11	F35H8.6
+F39G3.1	F36H9.3
+H19N07.4	F36H9.3
+H24K24.3	F36H9.3
+K12G11.3	F36H9.3
+K12G11.4	F36H9.3
+M88.1	F36H9.3
+T02E1.5	F36H9.3
+T04H1.7	F36H9.3
+T04H1.8	F36H9.3
+T07C5.1	F36H9.3
+T11F9.11	F36H9.3
+H19N07.4	F39G3.1
+H24K24.3	F39G3.1
+K12G11.3	F39G3.1
+K12G11.4	F39G3.1
+T02E1.5	F39G3.1
+T11F9.11	F39G3.1
+H24K24.3	H19N07.4
+K12G11.3	H19N07.4
+K12G11.4	H19N07.4
+M88.1	H19N07.4
+T02E1.5	H19N07.4
+T04H1.7	H19N07.4
+T04H1.8	H19N07.4
+T07C5.1	H19N07.4
+T11F9.11	H19N07.4
+M88.1	H24K24.3
+T02E1.5	H24K24.3
+T04H1.7	H24K24.3
+T04H1.8	H24K24.3
+T07C5.1	H24K24.3
+T11F9.11	H24K24.3
+M88.1	K12G11.3
+T02E1.5	K12G11.3
+T04H1.7	K12G11.3
+T04H1.8	K12G11.3
+T07C5.1	K12G11.3
+T11F9.11	K12G11.3
+M88.1	K12G11.4
+T02E1.5	K12G11.4
+T04H1.7	K12G11.4
+T04H1.8	K12G11.4
+T07C5.1	K12G11.4
+T11F9.11	K12G11.4
+T02E1.5	M88.1
+T11F9.11	M88.1
+T04H1.7	T02E1.5
+T04H1.8	T02E1.5
+T07C5.1	T02E1.5
+T11F9.11	T02E1.5
+T11F9.11	T04H1.7
+T11F9.11	T04H1.8
+T11F9.11	T07C5.1
+C26E6.11	B0310.5
+D1037.3	B0310.5
+T06D8.5	B0310.5
+T06D8.6	B0310.5
+T07A9.2	B0310.5
+Y46G5A.2	B0310.5
+ZC434.5	B0310.5
+C26E6.11	C17G1.3
+D1037.3	C17G1.3
+T06D8.5	C17G1.3
+T06D8.6	C17G1.3
+T07A9.2	C17G1.3
+Y46G5A.2	C17G1.3
+ZC434.5	C17G1.3
+C26E6.11	C18C4.3
+D1037.3	C18C4.3
+T06D8.5	C18C4.3
+T06D8.6	C18C4.3
+T07A9.2	C18C4.3
+Y46G5A.2	C18C4.3
+ZC434.5	C18C4.3
+D1037.3	C26E6.11
+F35H8.6	C26E6.11
+F39G3.1	C26E6.11
+M88.1	C26E6.11
+T04H1.7	C26E6.11
+T04H1.8	C26E6.11
+T06D8.5	C26E6.11
+T06D8.6	C26E6.11
+T07A9.2	C26E6.11
+T07C5.1	C26E6.11
+Y105E8B.9	C26E6.11
+Y46G5A.2	C26E6.11
+ZC434.5	C26E6.11
+F35H8.6	D1037.3
+F39G3.1	D1037.3
+M88.1	D1037.3
+T04H1.7	D1037.3
+T04H1.8	D1037.3
+T06D8.5	D1037.3
+T06D8.6	D1037.3
+T07A9.2	D1037.3
+T07C5.1	D1037.3
+Y105E8B.9	D1037.3
+Y46G5A.2	D1037.3
+ZC434.5	D1037.3
+T06D8.5	F35H8.6
+T06D8.6	F35H8.6
+T07A9.2	F35H8.6
+Y46G5A.2	F35H8.6
+ZC434.5	F35H8.6
+T06D8.5	F39G3.1
+T06D8.6	F39G3.1
+T07A9.2	F39G3.1
+Y46G5A.2	F39G3.1
+ZC434.5	F39G3.1
+T06D8.5	M88.1
+T06D8.6	M88.1
+T07A9.2	M88.1
+Y46G5A.2	M88.1
+ZC434.5	M88.1
+T06D8.5	T04H1.7
+T06D8.6	T04H1.7
+T07A9.2	T04H1.7
+Y46G5A.2	T04H1.7
+ZC434.5	T04H1.7
+T06D8.5	T04H1.8
+T06D8.6	T04H1.8
+T07A9.2	T04H1.8
+Y46G5A.2	T04H1.8
+ZC434.5	T04H1.8
+T06D8.6	T06D8.5
+T07A9.2	T06D8.5
+T07C5.1	T06D8.5
+Y105E8B.9	T06D8.5
+ZC434.5	T06D8.5
+T07A9.2	T06D8.6
+T07C5.1	T06D8.6
+Y105E8B.9	T06D8.6
+Y46G5A.2	T06D8.6
+ZC434.5	T06D8.6
+T07C5.1	T07A9.2
+Y105E8B.9	T07A9.2
+Y46G5A.2	T07A9.2
+ZC434.5	T07A9.2
+Y46G5A.2	T07C5.1
+ZC434.5	T07C5.1
+Y46G5A.2	Y105E8B.9
+ZC434.5	Y105E8B.9
+ZC434.5	Y46G5A.2
+C24A11.9	C04F12.10
+F08F8.2	C04F12.10
+F21F3.3	C04F12.10
+F23B12.6	C04F12.10
+F25B4.6	C04F12.10
+F32D8.13	C04F12.10
+F48F5.5	C04F12.10
+K06H7.9	C04F12.10
+M01E11.1	C04F12.10
+R02D3.5	C04F12.10
+R06C1.2	C04F12.10
+T01G1.4	C04F12.10
+T02G5.4	C04F12.10
+T02G5.7	C04F12.10
+T02G5.8	C04F12.10
+Y42G9A.4	C04F12.10
+F08F8.2	C24A11.9
+F21F3.3	C24A11.9
+F23B12.6	C24A11.9
+F25B4.6	C24A11.9
+F32D8.13	C24A11.9
+F48F5.5	C24A11.9
+K06H7.9	C24A11.9
+M01E11.1	C24A11.9
+R02D3.5	C24A11.9
+R06C1.2	C24A11.9
+T01G1.4	C24A11.9
+T02G5.4	C24A11.9
+T02G5.7	C24A11.9
+T02G5.8	C24A11.9
+Y42G9A.4	C24A11.9
+F21F3.3	F08F8.2
+F23B12.6	F08F8.2
+F25B4.6	F08F8.2
+F32D8.13	F08F8.2
+F48F5.5	F08F8.2
+K06H7.9	F08F8.2
+M01E11.1	F08F8.2
+R02D3.5	F08F8.2
+R06C1.2	F08F8.2
+T01G1.4	F08F8.2
+T02G5.4	F08F8.2
+T02G5.7	F08F8.2
+T02G5.8	F08F8.2
+Y42G9A.4	F08F8.2
+F23B12.6	F21F3.3
+F25B4.6	F21F3.3
+F32D8.13	F21F3.3
+F48F5.5	F21F3.3
+K06H7.9	F21F3.3
+M01E11.1	F21F3.3
+R02D3.5	F21F3.3
+R06C1.2	F21F3.3
+T01G1.4	F21F3.3
+T02G5.4	F21F3.3
+T02G5.7	F21F3.3
+T02G5.8	F21F3.3
+Y42G9A.4	F21F3.3
+F25B4.6	F23B12.6
+F32D8.13	F23B12.6
+F48F5.5	F23B12.6
+K06H7.9	F23B12.6
+M01E11.1	F23B12.6
+R02D3.5	F23B12.6
+R06C1.2	F23B12.6
+T01G1.4	F23B12.6
+T02G5.4	F23B12.6
+T02G5.7	F23B12.6
+T02G5.8	F23B12.6
+Y42G9A.4	F23B12.6
+F32D8.13	F25B4.6
+F48F5.5	F25B4.6
+K06H7.9	F25B4.6
+M01E11.1	F25B4.6
+R02D3.5	F25B4.6
+R06C1.2	F25B4.6
+T01G1.4	F25B4.6
+Y42G9A.4	F25B4.6
+F48F5.5	F32D8.13
+K06H7.9	F32D8.13
+M01E11.1	F32D8.13
+R02D3.5	F32D8.13
+R06C1.2	F32D8.13
+T01G1.4	F32D8.13
+T02G5.4	F32D8.13
+T02G5.7	F32D8.13
+T02G5.8	F32D8.13
+Y42G9A.4	F32D8.13
+K06H7.9	F48F5.5
+M01E11.1	F48F5.5
+R02D3.5	F48F5.5
+R06C1.2	F48F5.5
+T01G1.4	F48F5.5
+T02G5.4	F48F5.5
+T02G5.7	F48F5.5
+T02G5.8	F48F5.5
+Y42G9A.4	F48F5.5
+M01E11.1	K06H7.9
+R02D3.5	K06H7.9
+R06C1.2	K06H7.9
+T01G1.4	K06H7.9
+T02G5.4	K06H7.9
+T02G5.7	K06H7.9
+T02G5.8	K06H7.9
+Y42G9A.4	K06H7.9
+R02D3.5	M01E11.1
+R06C1.2	M01E11.1
+T01G1.4	M01E11.1
+T02G5.4	M01E11.1
+T02G5.7	M01E11.1
+T02G5.8	M01E11.1
+Y42G9A.4	M01E11.1
+R06C1.2	R02D3.5
+T01G1.4	R02D3.5
+T02G5.4	R02D3.5
+T02G5.7	R02D3.5
+T02G5.8	R02D3.5
+Y42G9A.4	R02D3.5
+T01G1.4	R06C1.2
+T02G5.4	R06C1.2
+T02G5.7	R06C1.2
+T02G5.8	R06C1.2
+Y42G9A.4	R06C1.2
+T02G5.4	T01G1.4
+T02G5.7	T01G1.4
+T02G5.8	T01G1.4
+Y42G9A.4	T01G1.4
+Y42G9A.4	T02G5.4
+Y42G9A.4	T02G5.7
+Y42G9A.4	T02G5.8
+H13N06.4	C17G1.7
+T14G10.1	C17G1.7
+Y6B3B.5	C17G1.7
+ZK430.2	C17G1.7
+H13N06.4	F59A7.9
+T14G10.1	F59A7.9
+Y6B3B.5	F59A7.9
+ZK430.2	F59A7.9
+K10H10.2	H13N06.4
+T14G10.1	H13N06.4
+Y6B3B.5	H13N06.4
+ZK430.2	H13N06.4
+T14G10.1	K10H10.2
+Y6B3B.5	K10H10.2
+ZK430.2	K10H10.2
+Y6B3B.5	T14G10.1
+ZK430.2	T14G10.1
+ZK430.2	Y6B3B.5
+C25A1.7	B0464.1
+C29H12.1	B0464.1
+C47D12.6	B0464.1
+C47E12.1	B0464.1
+D1054.13	B0464.1
+F10C2.6	B0464.1
+F22B5.9	B0464.1
+F22D6.3	B0464.1
+F26F4.10	B0464.1
+F28H1.3	B0464.1
+F58B3.5	B0464.1
+R11A8.6	B0464.1
+R74.1	B0464.1
+T02G5.9	B0464.1
+T07A9.2	B0464.1
+T08B2.9	B0464.1
+T10F2.1	B0464.1
+T11G6.1	B0464.1
+T20H4.3	B0464.1
+T27F6.5	B0464.1
+W02B12.6	B0464.1
+W03B1.4	B0464.1
+Y105E8A.19	B0464.1
+Y105E8A.20	B0464.1
+Y23H5A.7	B0464.1
+Y41D4A.6	B0464.1
+Y41E3.4	B0464.1
+Y60A3A.13	B0464.1
+Y66D12A.23	B0464.1
+Y80D3A.1	B0464.1
+Y87G2A.5	B0464.1
+ZC434.5	B0464.1
+ZC513.4	B0464.1
+ZK524.3	B0464.1
+C29H12.1	C25A1.7
+C47D12.6	C25A1.7
+C47E12.1	C25A1.7
+D1054.13	C25A1.7
+F10C2.6	C25A1.7
+F22B5.9	C25A1.7
+F22D6.3	C25A1.7
+F26F4.10	C25A1.7
+F28H1.3	C25A1.7
+F58B3.5	C25A1.7
+R11A8.6	C25A1.7
+R74.1	C25A1.7
+T02G5.9	C25A1.7
+T07A9.2	C25A1.7
+T08B2.9	C25A1.7
+T10F2.1	C25A1.7
+T11G6.1	C25A1.7
+T20H4.3	C25A1.7
+T27F6.5	C25A1.7
+W02B12.6	C25A1.7
+W03B1.4	C25A1.7
+Y105E8A.19	C25A1.7
+Y105E8A.20	C25A1.7
+Y23H5A.7	C25A1.7
+Y41D4A.6	C25A1.7
+Y41E3.4	C25A1.7
+Y60A3A.13	C25A1.7
+Y66D12A.23	C25A1.7
+Y80D3A.1	C25A1.7
+Y87G2A.5	C25A1.7
+ZC434.5	C25A1.7
+ZC513.4	C25A1.7
+ZK524.3	C25A1.7
+C47D12.6	C29H12.1
+C47E12.1	C29H12.1
+D1054.13	C29H12.1
+F10C2.6	C29H12.1
+F22B5.9	C29H12.1
+F22D6.3	C29H12.1
+F26F4.10	C29H12.1
+F28H1.3	C29H12.1
+F58B3.5	C29H12.1
+R11A8.6	C29H12.1
+R74.1	C29H12.1
+T02G5.9	C29H12.1
+T07A9.2	C29H12.1
+T08B2.9	C29H12.1
+T10F2.1	C29H12.1
+T11G6.1	C29H12.1
+T20H4.3	C29H12.1
+T27F6.5	C29H12.1
+W02B12.6	C29H12.1
+W03B1.4	C29H12.1
+Y105E8A.19	C29H12.1
+Y105E8A.20	C29H12.1
+Y23H5A.7	C29H12.1
+Y41D4A.6	C29H12.1
+Y41E3.4	C29H12.1
+Y60A3A.13	C29H12.1
+Y66D12A.23	C29H12.1
+Y80D3A.1	C29H12.1
+Y87G2A.5	C29H12.1
+ZC434.5	C29H12.1
+ZC513.4	C29H12.1
+ZK524.3	C29H12.1
+C47E12.1	C47D12.6
+D1054.13	C47D12.6
+F10C2.6	C47D12.6
+F22B5.9	C47D12.6
+F22D6.3	C47D12.6
+F26F4.10	C47D12.6
+F28H1.3	C47D12.6
+F58B3.5	C47D12.6
+R11A8.6	C47D12.6
+R74.1	C47D12.6
+T02G5.9	C47D12.6
+T07A9.2	C47D12.6
+T08B2.9	C47D12.6
+T10F2.1	C47D12.6
+T11G6.1	C47D12.6
+T20H4.3	C47D12.6
+T27F6.5	C47D12.6
+W02B12.6	C47D12.6
+W03B1.4	C47D12.6
+Y105E8A.19	C47D12.6
+Y105E8A.20	C47D12.6
+Y23H5A.7	C47D12.6
+Y41D4A.6	C47D12.6
+Y41E3.4	C47D12.6
+Y60A3A.13	C47D12.6
+Y66D12A.23	C47D12.6
+Y80D3A.1	C47D12.6
+Y87G2A.5	C47D12.6
+ZC434.5	C47D12.6
+ZC513.4	C47D12.6
+ZK524.3	C47D12.6
+D1054.13	C47E12.1
+F10C2.6	C47E12.1
+F22B5.9	C47E12.1
+F22D6.3	C47E12.1
+F26F4.10	C47E12.1
+F28H1.3	C47E12.1
+F58B3.5	C47E12.1
+R11A8.6	C47E12.1
+R74.1	C47E12.1
+T02G5.9	C47E12.1
+T07A9.2	C47E12.1
+T08B2.9	C47E12.1
+T10F2.1	C47E12.1
+T11G6.1	C47E12.1
+T20H4.3	C47E12.1
+T27F6.5	C47E12.1
+W02B12.6	C47E12.1
+W03B1.4	C47E12.1
+Y105E8A.19	C47E12.1
+Y105E8A.20	C47E12.1
+Y23H5A.7	C47E12.1
+Y41D4A.6	C47E12.1
+Y41E3.4	C47E12.1
+Y60A3A.13	C47E12.1
+Y66D12A.23	C47E12.1
+Y80D3A.1	C47E12.1
+Y87G2A.5	C47E12.1
+ZC434.5	C47E12.1
+ZC513.4	C47E12.1
+ZK524.3	C47E12.1
+F10C2.6	D1054.13
+F22B5.9	D1054.13
+F22D6.3	D1054.13
+F26F4.10	D1054.13
+F28H1.3	D1054.13
+R11A8.6	D1054.13
+R74.1	D1054.13
+T02G5.9	D1054.13
+T07A9.2	D1054.13
+T08B2.9	D1054.13
+T10F2.1	D1054.13
+T11G6.1	D1054.13
+T20H4.3	D1054.13
+T27F6.5	D1054.13
+W02B12.6	D1054.13
+W03B1.4	D1054.13
+Y105E8A.19	D1054.13
+Y23H5A.7	D1054.13
+Y41D4A.6	D1054.13
+Y41E3.4	D1054.13
+Y60A3A.13	D1054.13
+Y66D12A.23	D1054.13
+Y80D3A.1	D1054.13
+Y87G2A.5	D1054.13
+ZC434.5	D1054.13
+ZC513.4	D1054.13
+ZK524.3	D1054.13
+F22B5.9	F10C2.6
+F22D6.3	F10C2.6
+F26F4.10	F10C2.6
+F28H1.3	F10C2.6
+F58B3.5	F10C2.6
+R11A8.6	F10C2.6
+R74.1	F10C2.6
+T02G5.9	F10C2.6
+T07A9.2	F10C2.6
+T08B2.9	F10C2.6
+T10F2.1	F10C2.6
+T11G6.1	F10C2.6
+T20H4.3	F10C2.6
+T27F6.5	F10C2.6
+W02B12.6	F10C2.6
+W03B1.4	F10C2.6
+Y105E8A.19	F10C2.6
+Y105E8A.20	F10C2.6
+Y23H5A.7	F10C2.6
+Y41D4A.6	F10C2.6
+Y41E3.4	F10C2.6
+Y60A3A.13	F10C2.6
+Y66D12A.23	F10C2.6
+Y80D3A.1	F10C2.6
+Y87G2A.5	F10C2.6
+ZC434.5	F10C2.6
+ZC513.4	F10C2.6
+ZK524.3	F10C2.6
+F22D6.3	F22B5.9
+F26F4.10	F22B5.9
+F28H1.3	F22B5.9
+F58B3.5	F22B5.9
+R11A8.6	F22B5.9
+R74.1	F22B5.9
+T02G5.9	F22B5.9
+T07A9.2	F22B5.9
+T08B2.9	F22B5.9
+T10F2.1	F22B5.9
+T11G6.1	F22B5.9
+T20H4.3	F22B5.9
+T27F6.5	F22B5.9
+W02B12.6	F22B5.9
+W03B1.4	F22B5.9
+Y105E8A.19	F22B5.9
+Y105E8A.20	F22B5.9
+Y23H5A.7	F22B5.9
+Y41D4A.6	F22B5.9
+Y41E3.4	F22B5.9
+Y60A3A.13	F22B5.9
+Y66D12A.23	F22B5.9
+Y80D3A.1	F22B5.9
+Y87G2A.5	F22B5.9
+ZC434.5	F22B5.9
+ZC513.4	F22B5.9
+ZK524.3	F22B5.9
+F26F4.10	F22D6.3
+F28H1.3	F22D6.3
+F58B3.5	F22D6.3
+R11A8.6	F22D6.3
+R74.1	F22D6.3
+T02G5.9	F22D6.3
+T07A9.2	F22D6.3
+T08B2.9	F22D6.3
+T10F2.1	F22D6.3
+T11G6.1	F22D6.3
+T20H4.3	F22D6.3
+T27F6.5	F22D6.3
+W02B12.6	F22D6.3
+W03B1.4	F22D6.3
+Y105E8A.19	F22D6.3
+Y105E8A.20	F22D6.3
+Y23H5A.7	F22D6.3
+Y41D4A.6	F22D6.3
+Y41E3.4	F22D6.3
+Y60A3A.13	F22D6.3
+Y66D12A.23	F22D6.3
+Y80D3A.1	F22D6.3
+Y87G2A.5	F22D6.3
+ZC434.5	F22D6.3
+ZC513.4	F22D6.3
+ZK524.3	F22D6.3
+F28H1.3	F26F4.10
+F58B3.5	F26F4.10
+R11A8.6	F26F4.10
+R74.1	F26F4.10
+T02G5.9	F26F4.10
+T07A9.2	F26F4.10
+T08B2.9	F26F4.10
+T10F2.1	F26F4.10
+T11G6.1	F26F4.10
+T20H4.3	F26F4.10
+T27F6.5	F26F4.10
+W02B12.6	F26F4.10
+W03B1.4	F26F4.10
+Y105E8A.19	F26F4.10
+Y105E8A.20	F26F4.10
+Y23H5A.7	F26F4.10
+Y41D4A.6	F26F4.10
+Y41E3.4	F26F4.10
+Y60A3A.13	F26F4.10
+Y66D12A.23	F26F4.10
+Y80D3A.1	F26F4.10
+Y87G2A.5	F26F4.10
+ZC434.5	F26F4.10
+ZC513.4	F26F4.10
+ZK524.3	F26F4.10
+F58B3.5	F28H1.3
+R11A8.6	F28H1.3
+R74.1	F28H1.3
+T02G5.9	F28H1.3
+T07A9.2	F28H1.3
+T08B2.9	F28H1.3
+T10F2.1	F28H1.3
+T11G6.1	F28H1.3
+T20H4.3	F28H1.3
+T27F6.5	F28H1.3
+W02B12.6	F28H1.3
+W03B1.4	F28H1.3
+Y105E8A.19	F28H1.3
+Y105E8A.20	F28H1.3
+Y23H5A.7	F28H1.3
+Y41D4A.6	F28H1.3
+Y41E3.4	F28H1.3
+Y60A3A.13	F28H1.3
+Y66D12A.23	F28H1.3
+Y80D3A.1	F28H1.3
+Y87G2A.5	F28H1.3
+ZC434.5	F28H1.3
+ZC513.4	F28H1.3
+ZK524.3	F28H1.3
+R11A8.6	F58B3.5
+R74.1	F58B3.5
+T02G5.9	F58B3.5
+T07A9.2	F58B3.5
+T08B2.9	F58B3.5
+T10F2.1	F58B3.5
+T11G6.1	F58B3.5
+T20H4.3	F58B3.5
+T27F6.5	F58B3.5
+W02B12.6	F58B3.5
+W03B1.4	F58B3.5
+Y105E8A.19	F58B3.5
+Y23H5A.7	F58B3.5
+Y41D4A.6	F58B3.5
+Y41E3.4	F58B3.5
+Y60A3A.13	F58B3.5
+Y66D12A.23	F58B3.5
+Y80D3A.1	F58B3.5
+Y87G2A.5	F58B3.5
+ZC434.5	F58B3.5
+ZC513.4	F58B3.5
+ZK524.3	F58B3.5
+R74.1	R11A8.6
+T02G5.9	R11A8.6
+T07A9.2	R11A8.6
+T08B2.9	R11A8.6
+T10F2.1	R11A8.6
+T11G6.1	R11A8.6
+T20H4.3	R11A8.6
+T27F6.5	R11A8.6
+W02B12.6	R11A8.6
+W03B1.4	R11A8.6
+Y105E8A.19	R11A8.6
+Y105E8A.20	R11A8.6
+Y23H5A.7	R11A8.6
+Y41D4A.6	R11A8.6
+Y41E3.4	R11A8.6
+Y60A3A.13	R11A8.6
+Y66D12A.23	R11A8.6
+Y80D3A.1	R11A8.6
+Y87G2A.5	R11A8.6
+ZC434.5	R11A8.6
+ZC513.4	R11A8.6
+ZK524.3	R11A8.6
+T02G5.9	R74.1
+T07A9.2	R74.1
+T08B2.9	R74.1
+T10F2.1	R74.1
+T11G6.1	R74.1
+T20H4.3	R74.1
+T27F6.5	R74.1
+W02B12.6	R74.1
+W03B1.4	R74.1
+Y105E8A.19	R74.1
+Y105E8A.20	R74.1
+Y23H5A.7	R74.1
+Y41D4A.6	R74.1
+Y41E3.4	R74.1
+Y60A3A.13	R74.1
+Y66D12A.23	R74.1
+Y80D3A.1	R74.1
+Y87G2A.5	R74.1
+ZC434.5	R74.1
+ZC513.4	R74.1
+ZK524.3	R74.1
+T07A9.2	T02G5.9
+T08B2.9	T02G5.9
+T10F2.1	T02G5.9
+T11G6.1	T02G5.9
+T20H4.3	T02G5.9
+T27F6.5	T02G5.9
+W02B12.6	T02G5.9
+W03B1.4	T02G5.9
+Y105E8A.19	T02G5.9
+Y105E8A.20	T02G5.9
+Y23H5A.7	T02G5.9
+Y41D4A.6	T02G5.9
+Y41E3.4	T02G5.9
+Y60A3A.13	T02G5.9
+Y66D12A.23	T02G5.9
+Y80D3A.1	T02G5.9
+Y87G2A.5	T02G5.9
+ZC434.5	T02G5.9
+ZC513.4	T02G5.9
+ZK524.3	T02G5.9
+T08B2.9	T07A9.2
+T10F2.1	T07A9.2
+T11G6.1	T07A9.2
+T20H4.3	T07A9.2
+T27F6.5	T07A9.2
+W02B12.6	T07A9.2
+W03B1.4	T07A9.2
+Y105E8A.19	T07A9.2
+Y105E8A.20	T07A9.2
+Y23H5A.7	T07A9.2
+Y41D4A.6	T07A9.2
+Y41E3.4	T07A9.2
+Y60A3A.13	T07A9.2
+Y66D12A.23	T07A9.2
+Y80D3A.1	T07A9.2
+Y87G2A.5	T07A9.2
+ZC513.4	T07A9.2
+ZK524.3	T07A9.2
+T10F2.1	T08B2.9
+T11G6.1	T08B2.9
+T20H4.3	T08B2.9
+T27F6.5	T08B2.9
+W02B12.6	T08B2.9
+W03B1.4	T08B2.9
+Y105E8A.19	T08B2.9
+Y105E8A.20	T08B2.9
+Y23H5A.7	T08B2.9
+Y41D4A.6	T08B2.9
+Y41E3.4	T08B2.9
+Y60A3A.13	T08B2.9
+Y66D12A.23	T08B2.9
+Y80D3A.1	T08B2.9
+Y87G2A.5	T08B2.9
+ZC434.5	T08B2.9
+ZC513.4	T08B2.9
+ZK524.3	T08B2.9
+T11G6.1	T10F2.1
+T20H4.3	T10F2.1
+T27F6.5	T10F2.1
+W02B12.6	T10F2.1
+W03B1.4	T10F2.1
+Y105E8A.19	T10F2.1
+Y105E8A.20	T10F2.1
+Y23H5A.7	T10F2.1
+Y41D4A.6	T10F2.1
+Y41E3.4	T10F2.1
+Y60A3A.13	T10F2.1
+Y66D12A.23	T10F2.1
+Y80D3A.1	T10F2.1
+Y87G2A.5	T10F2.1
+ZC434.5	T10F2.1
+ZC513.4	T10F2.1
+ZK524.3	T10F2.1
+T20H4.3	T11G6.1
+T27F6.5	T11G6.1
+W02B12.6	T11G6.1
+W03B1.4	T11G6.1
+Y105E8A.19	T11G6.1
+Y105E8A.20	T11G6.1
+Y23H5A.7	T11G6.1
+Y41D4A.6	T11G6.1
+Y41E3.4	T11G6.1
+Y60A3A.13	T11G6.1
+Y66D12A.23	T11G6.1
+Y80D3A.1	T11G6.1
+Y87G2A.5	T11G6.1
+ZC434.5	T11G6.1
+ZC513.4	T11G6.1
+ZK524.3	T11G6.1
+T27F6.5	T20H4.3
+W02B12.6	T20H4.3
+W03B1.4	T20H4.3
+Y105E8A.19	T20H4.3
+Y105E8A.20	T20H4.3
+Y23H5A.7	T20H4.3
+Y41D4A.6	T20H4.3
+Y41E3.4	T20H4.3
+Y60A3A.13	T20H4.3
+Y66D12A.23	T20H4.3
+Y80D3A.1	T20H4.3
+Y87G2A.5	T20H4.3
+ZC434.5	T20H4.3
+ZC513.4	T20H4.3
+ZK524.3	T20H4.3
+W02B12.6	T27F6.5
+W03B1.4	T27F6.5
+Y105E8A.19	T27F6.5
+Y105E8A.20	T27F6.5
+Y23H5A.7	T27F6.5
+Y41D4A.6	T27F6.5
+Y41E3.4	T27F6.5
+Y60A3A.13	T27F6.5
+Y66D12A.23	T27F6.5
+Y80D3A.1	T27F6.5
+Y87G2A.5	T27F6.5
+ZC434.5	T27F6.5
+ZC513.4	T27F6.5
+ZK524.3	T27F6.5
+W03B1.4	W02B12.6
+Y105E8A.19	W02B12.6
+Y105E8A.20	W02B12.6
+Y23H5A.7	W02B12.6
+Y41D4A.6	W02B12.6
+Y41E3.4	W02B12.6
+Y60A3A.13	W02B12.6
+Y66D12A.23	W02B12.6
+Y80D3A.1	W02B12.6
+Y87G2A.5	W02B12.6
+ZC434.5	W02B12.6
+ZC513.4	W02B12.6
+ZK524.3	W02B12.6
+Y105E8A.19	W03B1.4
+Y105E8A.20	W03B1.4
+Y23H5A.7	W03B1.4
+Y41D4A.6	W03B1.4
+Y41E3.4	W03B1.4
+Y60A3A.13	W03B1.4
+Y66D12A.23	W03B1.4
+Y80D3A.1	W03B1.4
+Y87G2A.5	W03B1.4
+ZC434.5	W03B1.4
+ZC513.4	W03B1.4
+ZK524.3	W03B1.4
+Y105E8A.20	Y105E8A.19
+Y23H5A.7	Y105E8A.19
+Y41D4A.6	Y105E8A.19
+Y41E3.4	Y105E8A.19
+Y60A3A.13	Y105E8A.19
+Y66D12A.23	Y105E8A.19
+Y80D3A.1	Y105E8A.19
+Y87G2A.5	Y105E8A.19
+ZC434.5	Y105E8A.19
+ZC513.4	Y105E8A.19
+ZK524.3	Y105E8A.19
+Y23H5A.7	Y105E8A.20
+Y41D4A.6	Y105E8A.20
+Y41E3.4	Y105E8A.20
+Y60A3A.13	Y105E8A.20
+Y66D12A.23	Y105E8A.20
+Y80D3A.1	Y105E8A.20
+Y87G2A.5	Y105E8A.20
+ZC434.5	Y105E8A.20
+ZC513.4	Y105E8A.20
+ZK524.3	Y105E8A.20
+Y41D4A.6	Y23H5A.7
+Y41E3.4	Y23H5A.7
+Y60A3A.13	Y23H5A.7
+Y66D12A.23	Y23H5A.7
+Y80D3A.1	Y23H5A.7
+Y87G2A.5	Y23H5A.7
+ZC434.5	Y23H5A.7
+ZC513.4	Y23H5A.7
+ZK524.3	Y23H5A.7
+Y41E3.4	Y41D4A.6
+Y60A3A.13	Y41D4A.6
+Y66D12A.23	Y41D4A.6
+Y80D3A.1	Y41D4A.6
+Y87G2A.5	Y41D4A.6
+ZC434.5	Y41D4A.6
+ZC513.4	Y41D4A.6
+ZK524.3	Y41D4A.6
+Y60A3A.13	Y41E3.4
+Y66D12A.23	Y41E3.4
+Y80D3A.1	Y41E3.4
+Y87G2A.5	Y41E3.4
+ZC434.5	Y41E3.4
+ZC513.4	Y41E3.4
+ZK524.3	Y41E3.4
+Y66D12A.23	Y60A3A.13
+Y80D3A.1	Y60A3A.13
+Y87G2A.5	Y60A3A.13
+ZC434.5	Y60A3A.13
+ZC513.4	Y60A3A.13
+ZK524.3	Y60A3A.13
+Y80D3A.1	Y66D12A.23
+Y87G2A.5	Y66D12A.23
+ZC434.5	Y66D12A.23
+ZC513.4	Y66D12A.23
+ZK524.3	Y66D12A.23
+Y87G2A.5	Y80D3A.1
+ZC434.5	Y80D3A.1
+ZC513.4	Y80D3A.1
+ZK524.3	Y80D3A.1
+ZC434.5	Y87G2A.5
+ZC513.4	Y87G2A.5
+ZK524.3	Y87G2A.5
+ZC513.4	ZC434.5
+ZK524.3	ZC434.5
+ZK524.3	ZC513.4
+C29E4.7	B0310.5
+F11G11.1	B0310.5
+F11G11.2	B0310.5
+F11G11.3	B0310.5
+F35E8.8	B0310.5
+K08F4.11	B0310.5
+K08F4.6	B0310.5
+K08F4.7	B0310.5
+R03D7.6	B0310.5
+R07B1.4	B0310.5
+R107.7	B0310.5
+T08B1.3	B0310.5
+W01A11.1	B0310.5
+Y45G12C.2	B0310.5
+ZK1320.1	B0310.5
+ZK546.11	B0310.5
+C29E4.7	C17G1.3
+F11G11.1	C17G1.3
+F11G11.2	C17G1.3
+F11G11.3	C17G1.3
+F35E8.8	C17G1.3
+K08F4.11	C17G1.3
+K08F4.6	C17G1.3
+K08F4.7	C17G1.3
+R03D7.6	C17G1.3
+R07B1.4	C17G1.3
+R107.7	C17G1.3
+T08B1.3	C17G1.3
+W01A11.1	C17G1.3
+Y45G12C.2	C17G1.3
+ZK1320.1	C17G1.3
+ZK546.11	C17G1.3
+C29E4.7	C18C4.3
+F11G11.1	C18C4.3
+F11G11.2	C18C4.3
+F11G11.3	C18C4.3
+F35E8.8	C18C4.3
+K08F4.11	C18C4.3
+K08F4.6	C18C4.3
+K08F4.7	C18C4.3
+R03D7.6	C18C4.3
+R07B1.4	C18C4.3
+R107.7	C18C4.3
+T08B1.3	C18C4.3
+W01A11.1	C18C4.3
+Y45G12C.2	C18C4.3
+ZK1320.1	C18C4.3
+ZK546.11	C18C4.3
+D2063.1	C29E4.7
+F35H8.6	C29E4.7
+F39G3.1	C29E4.7
+H24K24.3	C29E4.7
+K12G11.3	C29E4.7
+K12G11.4	C29E4.7
+M88.1	C29E4.7
+T04H1.7	C29E4.7
+T04H1.8	C29E4.7
+T07C5.1	C29E4.7
+T08B1.3	C29E4.7
+W01A11.1	C29E4.7
+F11G11.1	D2063.1
+F11G11.2	D2063.1
+F11G11.3	D2063.1
+F35E8.8	D2063.1
+K08F4.11	D2063.1
+K08F4.6	D2063.1
+K08F4.7	D2063.1
+R03D7.6	D2063.1
+R07B1.4	D2063.1
+R107.7	D2063.1
+W01A11.1	D2063.1
+Y45G12C.2	D2063.1
+ZK1320.1	D2063.1
+ZK546.11	D2063.1
+F35H8.6	F11G11.1
+F39G3.1	F11G11.1
+H24K24.3	F11G11.1
+K12G11.3	F11G11.1
+K12G11.4	F11G11.1
+M88.1	F11G11.1
+T04H1.7	F11G11.1
+T04H1.8	F11G11.1
+T07C5.1	F11G11.1
+T08B1.3	F11G11.1
+W01A11.1	F11G11.1
+F35H8.6	F11G11.2
+F39G3.1	F11G11.2
+H24K24.3	F11G11.2
+K12G11.3	F11G11.2
+K12G11.4	F11G11.2
+M88.1	F11G11.2
+T04H1.7	F11G11.2
+T04H1.8	F11G11.2
+T07C5.1	F11G11.2
+T08B1.3	F11G11.2
+W01A11.1	F11G11.2
+F35H8.6	F11G11.3
+F39G3.1	F11G11.3
+H24K24.3	F11G11.3
+K12G11.3	F11G11.3
+K12G11.4	F11G11.3
+M88.1	F11G11.3
+T04H1.7	F11G11.3
+T04H1.8	F11G11.3
+T07C5.1	F11G11.3
+T08B1.3	F11G11.3
+W01A11.1	F11G11.3
+F35H8.6	F35E8.8
+F39G3.1	F35E8.8
+H24K24.3	F35E8.8
+K12G11.3	F35E8.8
+K12G11.4	F35E8.8
+M88.1	F35E8.8
+T04H1.7	F35E8.8
+T04H1.8	F35E8.8
+T07C5.1	F35E8.8
+T08B1.3	F35E8.8
+W01A11.1	F35E8.8
+K08F4.11	F35H8.6
+K08F4.6	F35H8.6
+K08F4.7	F35H8.6
+R03D7.6	F35H8.6
+R07B1.4	F35H8.6
+R107.7	F35H8.6
+T08B1.3	F35H8.6
+W01A11.1	F35H8.6
+Y45G12C.2	F35H8.6
+ZK1320.1	F35H8.6
+ZK546.11	F35H8.6
+K08F4.11	F39G3.1
+K08F4.6	F39G3.1
+K08F4.7	F39G3.1
+R03D7.6	F39G3.1
+R07B1.4	F39G3.1
+R107.7	F39G3.1
+T08B1.3	F39G3.1
+W01A11.1	F39G3.1
+Y45G12C.2	F39G3.1
+ZK1320.1	F39G3.1
+ZK546.11	F39G3.1
+K08F4.11	H24K24.3
+K08F4.6	H24K24.3
+K08F4.7	H24K24.3
+R03D7.6	H24K24.3
+R07B1.4	H24K24.3
+R107.7	H24K24.3
+W01A11.1	H24K24.3
+Y45G12C.2	H24K24.3
+ZK1320.1	H24K24.3
+ZK546.11	H24K24.3
+K12G11.3	K08F4.11
+K12G11.4	K08F4.11
+M88.1	K08F4.11
+T04H1.7	K08F4.11
+T04H1.8	K08F4.11
+T07C5.1	K08F4.11
+T08B1.3	K08F4.11
+W01A11.1	K08F4.11
+K12G11.3	K08F4.6
+K12G11.4	K08F4.6
+M88.1	K08F4.6
+T04H1.7	K08F4.6
+T04H1.8	K08F4.6
+T07C5.1	K08F4.6
+T08B1.3	K08F4.6
+W01A11.1	K08F4.6
+K12G11.3	K08F4.7
+K12G11.4	K08F4.7
+M88.1	K08F4.7
+T04H1.7	K08F4.7
+T04H1.8	K08F4.7
+T07C5.1	K08F4.7
+T08B1.3	K08F4.7
+W01A11.1	K08F4.7
+R03D7.6	K12G11.3
+R07B1.4	K12G11.3
+R107.7	K12G11.3
+W01A11.1	K12G11.3
+Y45G12C.2	K12G11.3
+ZK1320.1	K12G11.3
+ZK546.11	K12G11.3
+R03D7.6	K12G11.4
+R07B1.4	K12G11.4
+R107.7	K12G11.4
+W01A11.1	K12G11.4
+Y45G12C.2	K12G11.4
+ZK1320.1	K12G11.4
+ZK546.11	K12G11.4
+R03D7.6	M88.1
+R07B1.4	M88.1
+R107.7	M88.1
+T08B1.3	M88.1
+W01A11.1	M88.1
+Y45G12C.2	M88.1
+ZK1320.1	M88.1
+ZK546.11	M88.1
+T04H1.7	R03D7.6
+T04H1.8	R03D7.6
+T07C5.1	R03D7.6
+T08B1.3	R03D7.6
+W01A11.1	R03D7.6
+T04H1.7	R07B1.4
+T04H1.8	R07B1.4
+T07C5.1	R07B1.4
+T08B1.3	R07B1.4
+W01A11.1	R07B1.4
+T04H1.7	R107.7
+T04H1.8	R107.7
+T07C5.1	R107.7
+T08B1.3	R107.7
+W01A11.1	R107.7
+T08B1.3	T04H1.7
+W01A11.1	T04H1.7
+Y45G12C.2	T04H1.7
+ZK1320.1	T04H1.7
+ZK546.11	T04H1.7
+T08B1.3	T04H1.8
+W01A11.1	T04H1.8
+Y45G12C.2	T04H1.8
+ZK1320.1	T04H1.8
+ZK546.11	T04H1.8
+T08B1.3	T07C5.1
+W01A11.1	T07C5.1
+Y45G12C.2	T07C5.1
+ZK1320.1	T07C5.1
+ZK546.11	T07C5.1
+W01A11.1	T08B1.3
+Y45G12C.2	T08B1.3
+ZK1320.1	T08B1.3
+ZK546.11	T08B1.3
+Y45G12C.2	W01A11.1
+ZK1320.1	W01A11.1
+ZK546.11	W01A11.1
+H24K24.5	B0310.5
+K08C7.2	B0310.5
+K08C7.5	B0310.5
+Y39A1A.19	B0310.5
+H24K24.5	C17G1.3
+K08C7.2	C17G1.3
+K08C7.5	C17G1.3
+Y39A1A.19	C17G1.3
+H24K24.5	C18C4.3
+K08C7.2	C18C4.3
+K08C7.5	C18C4.3
+Y39A1A.19	C18C4.3
+H24K24.5	C29E4.7
+K08C7.2	C29E4.7
+K08C7.5	C29E4.7
+Y39A1A.19	C29E4.7
+H24K24.5	D2063.1
+K08C7.2	D2063.1
+K08C7.5	D2063.1
+Y39A1A.19	D2063.1
+H24K24.5	F11G11.1
+K08C7.2	F11G11.1
+K08C7.5	F11G11.1
+Y39A1A.19	F11G11.1
+H24K24.5	F11G11.2
+K08C7.2	F11G11.2
+K08C7.5	F11G11.2
+Y39A1A.19	F11G11.2
+H24K24.5	F11G11.3
+K08C7.2	F11G11.3
+K08C7.5	F11G11.3
+Y39A1A.19	F11G11.3
+H24K24.5	F35E8.8
+K08C7.2	F35E8.8
+K08C7.5	F35E8.8
+Y39A1A.19	F35E8.8
+H24K24.5	F35H8.6
+K08C7.2	F35H8.6
+K08C7.5	F35H8.6
+Y39A1A.19	F35H8.6
+H24K24.5	F39G3.1
+K08C7.2	F39G3.1
+K08C7.5	F39G3.1
+Y39A1A.19	F39G3.1
+H24K24.5	H24K24.3
+K08C7.2	H24K24.3
+K08C7.5	H24K24.3
+Y39A1A.19	H24K24.3
+K08C7.2	H24K24.5
+K08C7.5	H24K24.5
+K08F4.11	H24K24.5
+K08F4.6	H24K24.5
+K08F4.7	H24K24.5
+K12G11.3	H24K24.5
+K12G11.4	H24K24.5
+M88.1	H24K24.5
+R03D7.6	H24K24.5
+R07B1.4	H24K24.5
+R107.7	H24K24.5
+T04H1.7	H24K24.5
+T04H1.8	H24K24.5
+T07C5.1	H24K24.5
+T08B1.3	H24K24.5
+Y39A1A.19	H24K24.5
+Y45G12C.2	H24K24.5
+ZK1320.1	H24K24.5
+ZK546.11	H24K24.5
+K08C7.5	K08C7.2
+K08F4.11	K08C7.2
+K08F4.6	K08C7.2
+K08F4.7	K08C7.2
+K12G11.3	K08C7.2
+K12G11.4	K08C7.2
+M88.1	K08C7.2
+R03D7.6	K08C7.2
+R07B1.4	K08C7.2
+R107.7	K08C7.2
+T04H1.7	K08C7.2
+T04H1.8	K08C7.2
+T07C5.1	K08C7.2
+T08B1.3	K08C7.2
+Y39A1A.19	K08C7.2
+Y45G12C.2	K08C7.2
+ZK1320.1	K08C7.2
+ZK546.11	K08C7.2
+K08F4.11	K08C7.5
+K08F4.6	K08C7.5
+K08F4.7	K08C7.5
+K12G11.3	K08C7.5
+K12G11.4	K08C7.5
+M88.1	K08C7.5
+R03D7.6	K08C7.5
+R07B1.4	K08C7.5
+R107.7	K08C7.5
+T04H1.7	K08C7.5
+T04H1.8	K08C7.5
+T07C5.1	K08C7.5
+T08B1.3	K08C7.5
+Y39A1A.19	K08C7.5
+Y45G12C.2	K08C7.5
+ZK1320.1	K08C7.5
+ZK546.11	K08C7.5
+Y39A1A.19	K08F4.11
+Y39A1A.19	K08F4.6
+Y39A1A.19	K08F4.7
+Y39A1A.19	K12G11.3
+Y39A1A.19	K12G11.4
+Y39A1A.19	M88.1
+Y39A1A.19	R03D7.6
+Y39A1A.19	R07B1.4
+Y39A1A.19	R107.7
+Y39A1A.19	T04H1.7
+Y39A1A.19	T04H1.8
+Y39A1A.19	T07C5.1
+Y39A1A.19	T08B1.3
+Y45G12C.2	Y39A1A.19
+ZK1320.1	Y39A1A.19
+ZK546.11	Y39A1A.19
+B0310.5	B0001.4
+C17G1.3	B0001.4
+C18C4.3	B0001.4
+C52A10.2	B0001.4
+F13H6.3	B0001.4
+F13H6.4	B0001.4
+F15E6.6	B0001.4
+F35H8.6	B0001.4
+F39G3.1	B0001.4
+F55B11.1	B0001.4
+M106.4	B0001.4
+M88.1	B0001.4
+R12A1.4	B0001.4
+T04H1.7	B0001.4
+T04H1.8	B0001.4
+T07C5.1	B0001.4
+T22D1.3	B0001.4
+Y105E8B.5	B0001.4
+Y105E8B.9	B0001.4
+C25F6.3	B0310.5
+C47D2.2	B0310.5
+C47E12.8	B0310.5
+C52A10.2	B0310.5
+F13H6.3	B0310.5
+F13H6.4	B0310.5
+F13H8.7	B0310.5
+F15E6.6	B0310.5
+F49E8.4	B0310.5
+F55B11.1	B0310.5
+M106.4	B0310.5
+R12A1.4	B0310.5
+T07C4.1	B0310.5
+T22D1.3	B0310.5
+Y105E8B.5	B0310.5
+Y43C5A.5	B0310.5
+ZC395.7	B0310.5
+ZK783.2	B0310.5
+C25F6.3	C17G1.3
+C47D2.2	C17G1.3
+C47E12.8	C17G1.3
+C52A10.2	C17G1.3
+F13H6.3	C17G1.3
+F13H6.4	C17G1.3
+F13H8.7	C17G1.3
+F15E6.6	C17G1.3
+F49E8.4	C17G1.3
+F55B11.1	C17G1.3
+M106.4	C17G1.3
+R12A1.4	C17G1.3
+T07C4.1	C17G1.3
+T22D1.3	C17G1.3
+Y105E8B.5	C17G1.3
+Y43C5A.5	C17G1.3
+ZC395.7	C17G1.3
+ZK783.2	C17G1.3
+C25F6.3	C18C4.3
+C47D2.2	C18C4.3
+C47E12.8	C18C4.3
+C52A10.2	C18C4.3
+F13H6.3	C18C4.3
+F13H6.4	C18C4.3
+F13H8.7	C18C4.3
+F15E6.6	C18C4.3
+F49E8.4	C18C4.3
+F55B11.1	C18C4.3
+M106.4	C18C4.3
+R12A1.4	C18C4.3
+T07C4.1	C18C4.3
+T22D1.3	C18C4.3
+Y105E8B.5	C18C4.3
+Y43C5A.5	C18C4.3
+ZC395.7	C18C4.3
+ZK783.2	C18C4.3
+C52A10.2	C25F6.3
+F13H6.3	C25F6.3
+F13H6.4	C25F6.3
+F15E6.6	C25F6.3
+F35H8.6	C25F6.3
+F39G3.1	C25F6.3
+F55B11.1	C25F6.3
+M106.4	C25F6.3
+M88.1	C25F6.3
+R12A1.4	C25F6.3
+T04H1.7	C25F6.3
+T04H1.8	C25F6.3
+T07C5.1	C25F6.3
+T22D1.3	C25F6.3
+Y105E8B.5	C25F6.3
+Y105E8B.9	C25F6.3
+C52A10.2	C47D2.2
+F13H6.3	C47D2.2
+F13H6.4	C47D2.2
+F15E6.6	C47D2.2
+F35H8.6	C47D2.2
+F39G3.1	C47D2.2
+F55B11.1	C47D2.2
+M106.4	C47D2.2
+M88.1	C47D2.2
+R12A1.4	C47D2.2
+T04H1.7	C47D2.2
+T04H1.8	C47D2.2
+T07C5.1	C47D2.2
+T22D1.3	C47D2.2
+Y105E8B.5	C47D2.2
+Y105E8B.9	C47D2.2
+C52A10.2	C47E12.8
+F13H6.3	C47E12.8
+F13H6.4	C47E12.8
+F15E6.6	C47E12.8
+F35H8.6	C47E12.8
+F39G3.1	C47E12.8
+F55B11.1	C47E12.8
+M106.4	C47E12.8
+M88.1	C47E12.8
+R12A1.4	C47E12.8
+T04H1.7	C47E12.8
+T04H1.8	C47E12.8
+T07C5.1	C47E12.8
+T22D1.3	C47E12.8
+Y105E8B.5	C47E12.8
+Y105E8B.9	C47E12.8
+F13H8.7	C52A10.2
+F15E6.6	C52A10.2
+F35H8.6	C52A10.2
+F39G3.1	C52A10.2
+F49E8.4	C52A10.2
+F55B11.1	C52A10.2
+M106.4	C52A10.2
+M88.1	C52A10.2
+T04H1.7	C52A10.2
+T04H1.8	C52A10.2
+T07C4.1	C52A10.2
+T07C5.1	C52A10.2
+T22D1.3	C52A10.2
+Y105E8B.5	C52A10.2
+Y105E8B.9	C52A10.2
+Y43C5A.5	C52A10.2
+ZC395.7	C52A10.2
+ZK783.2	C52A10.2
+F13H8.7	F13H6.3
+F15E6.6	F13H6.3
+F35H8.6	F13H6.3
+F39G3.1	F13H6.3
+F49E8.4	F13H6.3
+F55B11.1	F13H6.3
+M106.4	F13H6.3
+M88.1	F13H6.3
+T04H1.7	F13H6.3
+T04H1.8	F13H6.3
+T07C4.1	F13H6.3
+T07C5.1	F13H6.3
+T22D1.3	F13H6.3
+Y105E8B.5	F13H6.3
+Y105E8B.9	F13H6.3
+Y43C5A.5	F13H6.3
+ZC395.7	F13H6.3
+ZK783.2	F13H6.3
+F13H8.7	F13H6.4
+F15E6.6	F13H6.4
+F35H8.6	F13H6.4
+F39G3.1	F13H6.4
+F49E8.4	F13H6.4
+F55B11.1	F13H6.4
+M106.4	F13H6.4
+M88.1	F13H6.4
+T04H1.7	F13H6.4
+T04H1.8	F13H6.4
+T07C4.1	F13H6.4
+T07C5.1	F13H6.4
+T22D1.3	F13H6.4
+Y105E8B.5	F13H6.4
+Y105E8B.9	F13H6.4
+Y43C5A.5	F13H6.4
+ZC395.7	F13H6.4
+ZK783.2	F13H6.4
+F15E6.6	F13H8.7
+F35H8.6	F13H8.7
+F39G3.1	F13H8.7
+F55B11.1	F13H8.7
+M106.4	F13H8.7
+M88.1	F13H8.7
+R12A1.4	F13H8.7
+T04H1.7	F13H8.7
+T04H1.8	F13H8.7
+T07C5.1	F13H8.7
+T22D1.3	F13H8.7
+Y105E8B.5	F13H8.7
+Y105E8B.9	F13H8.7
+F35H8.6	F15E6.6
+F39G3.1	F15E6.6
+F49E8.4	F15E6.6
+M88.1	F15E6.6
+R12A1.4	F15E6.6
+T04H1.7	F15E6.6
+T04H1.8	F15E6.6
+T07C4.1	F15E6.6
+T07C5.1	F15E6.6
+Y105E8B.9	F15E6.6
+Y43C5A.5	F15E6.6
+ZK783.2	F15E6.6
+F49E8.4	F35H8.6
+F55B11.1	F35H8.6
+M106.4	F35H8.6
+R12A1.4	F35H8.6
+T07C4.1	F35H8.6
+T22D1.3	F35H8.6
+Y105E8B.5	F35H8.6
+Y43C5A.5	F35H8.6
+ZC395.7	F35H8.6
+ZK783.2	F35H8.6
+F49E8.4	F39G3.1
+F55B11.1	F39G3.1
+M106.4	F39G3.1
+R12A1.4	F39G3.1
+T07C4.1	F39G3.1
+T22D1.3	F39G3.1
+Y105E8B.5	F39G3.1
+Y43C5A.5	F39G3.1
+ZC395.7	F39G3.1
+ZK783.2	F39G3.1
+F55B11.1	F49E8.4
+M106.4	F49E8.4
+M88.1	F49E8.4
+R12A1.4	F49E8.4
+T04H1.7	F49E8.4
+T04H1.8	F49E8.4
+T07C5.1	F49E8.4
+T22D1.3	F49E8.4
+Y105E8B.5	F49E8.4
+Y105E8B.9	F49E8.4
+M88.1	F55B11.1
+R12A1.4	F55B11.1
+T04H1.7	F55B11.1
+T04H1.8	F55B11.1
+T07C4.1	F55B11.1
+T07C5.1	F55B11.1
+Y105E8B.9	F55B11.1
+Y43C5A.5	F55B11.1
+ZK783.2	F55B11.1
+M88.1	M106.4
+R12A1.4	M106.4
+T04H1.7	M106.4
+T04H1.8	M106.4
+T07C4.1	M106.4
+T07C5.1	M106.4
+Y105E8B.9	M106.4
+Y43C5A.5	M106.4
+ZK783.2	M106.4
+R12A1.4	M88.1
+T07C4.1	M88.1
+T22D1.3	M88.1
+Y105E8B.5	M88.1
+Y43C5A.5	M88.1
+ZC395.7	M88.1
+ZK783.2	M88.1
+T04H1.7	R12A1.4
+T04H1.8	R12A1.4
+T07C4.1	R12A1.4
+T07C5.1	R12A1.4
+T22D1.3	R12A1.4
+Y105E8B.5	R12A1.4
+Y105E8B.9	R12A1.4
+Y43C5A.5	R12A1.4
+ZC395.7	R12A1.4
+ZK783.2	R12A1.4
+T07C4.1	T04H1.7
+T22D1.3	T04H1.7
+Y105E8B.5	T04H1.7
+Y43C5A.5	T04H1.7
+ZC395.7	T04H1.7
+ZK783.2	T04H1.7
+T07C4.1	T04H1.8
+T22D1.3	T04H1.8
+Y105E8B.5	T04H1.8
+Y43C5A.5	T04H1.8
+ZC395.7	T04H1.8
+ZK783.2	T04H1.8
+T07C5.1	T07C4.1
+T22D1.3	T07C4.1
+Y105E8B.5	T07C4.1
+Y105E8B.9	T07C4.1
+T22D1.3	T07C5.1
+Y105E8B.5	T07C5.1
+Y43C5A.5	T07C5.1
+ZC395.7	T07C5.1
+ZK783.2	T07C5.1
+Y105E8B.9	T22D1.3
+Y43C5A.5	T22D1.3
+ZK783.2	T22D1.3
+Y105E8B.9	Y105E8B.5
+Y43C5A.5	Y105E8B.5
+ZK783.2	Y105E8B.5
+Y43C5A.5	Y105E8B.9
+ZC395.7	Y105E8B.9
+ZK783.2	Y105E8B.9
+C48B4.1	C15F1.6
+F08A8.1	C15F1.6
+F08A8.2	C15F1.6
+F08A8.3	C15F1.6
+F08A8.4	C15F1.6
+F10D2.9	C15F1.6
+F58F9.7	C15F1.6
+F59F4.1	C15F1.6
+VZK822L.1	C15F1.6
+W06D12.3	C15F1.6
+Y67H2A.8	C15F1.6
+F10D2.9	C29F3.1
+VZK822L.1	C29F3.1
+W06D12.3	C29F3.1
+Y67H2A.8	C29F3.1
+F10D2.9	C48B4.1
+T15B7.2	C48B4.1
+VZK822L.1	C48B4.1
+W06D12.3	C48B4.1
+Y67H2A.8	C48B4.1
+F10D2.9	F08A8.1
+T15B7.2	F08A8.1
+VZK822L.1	F08A8.1
+W06D12.3	F08A8.1
+Y67H2A.8	F08A8.1
+F10D2.9	F08A8.2
+T15B7.2	F08A8.2
+VZK822L.1	F08A8.2
+W06D12.3	F08A8.2
+Y67H2A.8	F08A8.2
+F10D2.9	F08A8.3
+T15B7.2	F08A8.3
+VZK822L.1	F08A8.3
+W06D12.3	F08A8.3
+Y67H2A.8	F08A8.3
+F10D2.9	F08A8.4
+T15B7.2	F08A8.4
+VZK822L.1	F08A8.4
+W06D12.3	F08A8.4
+Y67H2A.8	F08A8.4
+F58F9.7	F10D2.9
+F59F4.1	F10D2.9
+T08B2.7	F10D2.9
+T15B7.2	F10D2.9
+VZK822L.1	F10D2.9
+W06D12.3	F10D2.9
+Y67H2A.8	F10D2.9
+T15B7.2	F58F9.7
+VZK822L.1	F58F9.7
+W06D12.3	F58F9.7
+Y67H2A.8	F58F9.7
+T15B7.2	F59F4.1
+VZK822L.1	F59F4.1
+W06D12.3	F59F4.1
+Y67H2A.8	F59F4.1
+VZK822L.1	T08B2.7
+W06D12.3	T08B2.7
+Y67H2A.8	T08B2.7
+VZK822L.1	T15B7.2
+W06D12.3	T15B7.2
+Y67H2A.8	T15B7.2
+W06D12.3	VZK822L.1
+Y67H2A.8	VZK822L.1
+Y67H2A.8	W06D12.3
+C34G6.4	C05A9.1
+C44B7.9	C05A9.1
+C47A10.1	C05A9.1
+C54G10.3	C05A9.1
+DH11.3	C05A9.1
+F14F4.3	C05A9.1
+F22E10.1	C05A9.1
+F22E10.2	C05A9.1
+F22E10.3	C05A9.1
+F42E11.1	C05A9.1
+T02D1.5	C05A9.1
+Y48G8AL.11	C05A9.1
+Y50E8A.16	C05A9.1
+Y74C10AR.3	C05A9.1
+ZK455.7	C05A9.1
+ZK484.2	C05A9.1
+C44B7.9	C34G6.4
+C47A10.1	C34G6.4
+C54G10.3	C34G6.4
+DH11.3	C34G6.4
+F14F4.3	C34G6.4
+F22E10.1	C34G6.4
+F22E10.2	C34G6.4
+F22E10.3	C34G6.4
+F42E11.1	C34G6.4
+T02D1.5	C34G6.4
+Y48G8AL.11	C34G6.4
+Y50E8A.16	C34G6.4
+Y74C10AR.3	C34G6.4
+ZK455.7	C34G6.4
+ZK484.2	C34G6.4
+C47A10.1	C44B7.9
+C54G10.3	C44B7.9
+DH11.3	C44B7.9
+F14F4.3	C44B7.9
+F22E10.1	C44B7.9
+F22E10.2	C44B7.9
+F22E10.3	C44B7.9
+F42E11.1	C44B7.9
+T02D1.5	C44B7.9
+Y48G8AL.11	C44B7.9
+Y50E8A.16	C44B7.9
+Y74C10AR.3	C44B7.9
+ZK455.7	C44B7.9
+ZK484.2	C44B7.9
+C54G10.3	C47A10.1
+DH11.3	C47A10.1
+F14F4.3	C47A10.1
+F22E10.1	C47A10.1
+F22E10.2	C47A10.1
+F22E10.3	C47A10.1
+F42E11.1	C47A10.1
+T02D1.5	C47A10.1
+Y48G8AL.11	C47A10.1
+Y50E8A.16	C47A10.1
+Y74C10AR.3	C47A10.1
+ZK455.7	C47A10.1
+ZK484.2	C47A10.1
+DH11.3	C54G10.3
+F14F4.3	C54G10.3
+F22E10.1	C54G10.3
+F22E10.2	C54G10.3
+F22E10.3	C54G10.3
+F42E11.1	C54G10.3
+T02D1.5	C54G10.3
+Y48G8AL.11	C54G10.3
+Y50E8A.16	C54G10.3
+Y74C10AR.3	C54G10.3
+ZK455.7	C54G10.3
+ZK484.2	C54G10.3
+F14F4.3	DH11.3
+F22E10.1	DH11.3
+F22E10.2	DH11.3
+F22E10.3	DH11.3
+F42E11.1	DH11.3
+T02D1.5	DH11.3
+Y48G8AL.11	DH11.3
+Y50E8A.16	DH11.3
+Y74C10AR.3	DH11.3
+ZK455.7	DH11.3
+ZK484.2	DH11.3
+F22E10.1	F14F4.3
+F22E10.2	F14F4.3
+F22E10.3	F14F4.3
+F42E11.1	F14F4.3
+T02D1.5	F14F4.3
+Y48G8AL.11	F14F4.3
+Y50E8A.16	F14F4.3
+Y74C10AR.3	F14F4.3
+ZK455.7	F14F4.3
+ZK484.2	F14F4.3
+F22E10.2	F22E10.1
+F22E10.3	F22E10.1
+F42E11.1	F22E10.1
+T02D1.5	F22E10.1
+Y48G8AL.11	F22E10.1
+Y50E8A.16	F22E10.1
+Y74C10AR.3	F22E10.1
+ZK455.7	F22E10.1
+ZK484.2	F22E10.1
+F22E10.3	F22E10.2
+F42E11.1	F22E10.2
+T02D1.5	F22E10.2
+Y48G8AL.11	F22E10.2
+Y50E8A.16	F22E10.2
+Y74C10AR.3	F22E10.2
+ZK455.7	F22E10.2
+ZK484.2	F22E10.2
+F42E11.1	F22E10.3
+T02D1.5	F22E10.3
+Y48G8AL.11	F22E10.3
+Y50E8A.16	F22E10.3
+Y74C10AR.3	F22E10.3
+ZK455.7	F22E10.3
+ZK484.2	F22E10.3
+T02D1.5	F42E11.1
+Y48G8AL.11	F42E11.1
+Y50E8A.16	F42E11.1
+Y74C10AR.3	F42E11.1
+ZK455.7	F42E11.1
+ZK484.2	F42E11.1
+Y48G8AL.11	T02D1.5
+Y50E8A.16	T02D1.5
+Y74C10AR.3	T02D1.5
+ZK455.7	T02D1.5
+ZK484.2	T02D1.5
+Y50E8A.16	Y48G8AL.11
+Y74C10AR.3	Y48G8AL.11
+ZK455.7	Y48G8AL.11
+ZK484.2	Y48G8AL.11
+Y74C10AR.3	Y50E8A.16
+ZK455.7	Y50E8A.16
+ZK484.2	Y50E8A.16
+ZK455.7	Y74C10AR.3
+ZK484.2	Y74C10AR.3
+ZK484.2	ZK455.7
+B0280.9	B0205.7
+C05C8.5	B0205.7
+C05D11.9	B0205.7
+C08B6.8	B0205.7
+C15C6.4	B0205.7
+C15H11.3	B0205.7
+C15H11.6	B0205.7
+C25A1.16	B0205.7
+C47B2.5	B0205.7
+C48B6.2	B0205.7
+C53H9.2	B0205.7
+E02H1.6	B0205.7
+F13H8.2	B0205.7
+F26E4.10	B0205.7
+F27C1.6	B0205.7
+F30A10.9	B0205.7
+F52C9.8	B0205.7
+F55A12.8	B0205.7
+F55F10.1	B0205.7
+F55F8.3	B0205.7
+H35B03.2	B0205.7
+K01C8.9	B0205.7
+K01G5.4	B0205.7
+K01G5.5	B0205.7
+K07C5.4	B0205.7
+K10C3.5	B0205.7
+M01B12.5	B0205.7
+M28.5	B0205.7
+R05H10.2	B0205.7
+T01C3.7	B0205.7
+T01G9.6	B0205.7
+T07A9.9	B0205.7
+T10B5.3	B0205.7
+T19A6.2	B0205.7
+T25G3.3	B0205.7
+W01B11.3	B0205.7
+W06E11.4	B0205.7
+Y105E8B.3	B0205.7
+Y23H5B.5	B0205.7
+Y39A1A.14	B0205.7
+Y39G8C.1	B0205.7
+Y45F10D.7	B0205.7
+Y48A6B.3	B0205.7
+Y48B6A.3	B0205.7
+Y48C3A.7	B0205.7
+Y51H7C.11	B0205.7
+Y53C12B.1	B0205.7
+Y54E10BR.4	B0205.7
+Y56A3A.33	B0205.7
+Y61A9LA.10	B0205.7
+Y62E10A.2	B0205.7
+Y66A7A.2	B0205.7
+Y66H1A.4	B0205.7
+Y71F9AM.5	B0205.7
+Y75B8A.7	B0205.7
+ZC434.4	B0205.7
+ZK1127.5	B0205.7
+ZK430.1	B0205.7
+ZK632.14	B0205.7
+ZK742.1	B0205.7
+ZK795.3	B0205.7
+C05C8.5	B0280.9
+C05D11.9	B0280.9
+C08B6.8	B0280.9
+C15C6.4	B0280.9
+C15H11.3	B0280.9
+C15H11.6	B0280.9
+C25A1.16	B0280.9
+C47B2.5	B0280.9
+C48B6.2	B0280.9
+C53H9.2	B0280.9
+E02H1.6	B0280.9
+F13H8.2	B0280.9
+F26E4.10	B0280.9
+F27C1.6	B0280.9
+F30A10.9	B0280.9
+F52C9.8	B0280.9
+F55A12.8	B0280.9
+F55F10.1	B0280.9
+F55F8.3	B0280.9
+H35B03.2	B0280.9
+K01C8.9	B0280.9
+K01G5.4	B0280.9
+K01G5.5	B0280.9
+K07C5.4	B0280.9
+K10C3.5	B0280.9
+M01B12.5	B0280.9
+M28.5	B0280.9
+R05H10.2	B0280.9
+T01C3.7	B0280.9
+T01G9.6	B0280.9
+T07A9.9	B0280.9
+T10B5.3	B0280.9
+T19A6.2	B0280.9
+T25G3.3	B0280.9
+W01B11.3	B0280.9
+W06E11.4	B0280.9
+Y105E8B.3	B0280.9
+Y23H5B.5	B0280.9
+Y39A1A.14	B0280.9
+Y39G8C.1	B0280.9
+Y45F10D.7	B0280.9
+Y48A6B.3	B0280.9
+Y48B6A.3	B0280.9
+Y48C3A.7	B0280.9
+Y51H7C.11	B0280.9
+Y53C12B.1	B0280.9
+Y54E10BR.4	B0280.9
+Y56A3A.33	B0280.9
+Y61A9LA.10	B0280.9
+Y62E10A.2	B0280.9
+Y66A7A.2	B0280.9
+Y66H1A.4	B0280.9
+Y71F9AM.5	B0280.9
+Y75B8A.7	B0280.9
+ZC434.4	B0280.9
+ZK1127.5	B0280.9
+ZK430.1	B0280.9
+ZK632.14	B0280.9
+ZK742.1	B0280.9
+ZK795.3	B0280.9
+C05D11.9	C05C8.5
+C08B6.8	C05C8.5
+C15C6.4	C05C8.5
+C15H11.3	C05C8.5
+C15H11.6	C05C8.5
+C25A1.16	C05C8.5
+C47B2.5	C05C8.5
+C48B6.2	C05C8.5
+C53H9.2	C05C8.5
+E02H1.6	C05C8.5
+F13H8.2	C05C8.5
+F26E4.10	C05C8.5
+F27C1.6	C05C8.5
+F30A10.9	C05C8.5
+F52C9.8	C05C8.5
+F55A12.8	C05C8.5
+F55F10.1	C05C8.5
+F55F8.3	C05C8.5
+H35B03.2	C05C8.5
+K01C8.9	C05C8.5
+K01G5.4	C05C8.5
+K01G5.5	C05C8.5
+K07C5.4	C05C8.5
+K10C3.5	C05C8.5
+M01B12.5	C05C8.5
+M28.5	C05C8.5
+R05H10.2	C05C8.5
+T01C3.7	C05C8.5
+T01G9.6	C05C8.5
+T07A9.9	C05C8.5
+T10B5.3	C05C8.5
+T19A6.2	C05C8.5
+T25G3.3	C05C8.5
+W01B11.3	C05C8.5
+W06E11.4	C05C8.5
+Y105E8B.3	C05C8.5
+Y23H5B.5	C05C8.5
+Y39A1A.14	C05C8.5
+Y39G8C.1	C05C8.5
+Y45F10D.7	C05C8.5
+Y48A6B.3	C05C8.5
+Y48B6A.3	C05C8.5
+Y48C3A.7	C05C8.5
+Y51H7C.11	C05C8.5
+Y53C12B.1	C05C8.5
+Y54E10BR.4	C05C8.5
+Y56A3A.33	C05C8.5
+Y61A9LA.10	C05C8.5
+Y62E10A.2	C05C8.5
+Y66A7A.2	C05C8.5
+Y66H1A.4	C05C8.5
+Y71F9AM.5	C05C8.5
+Y75B8A.7	C05C8.5
+ZC434.4	C05C8.5
+ZK1127.5	C05C8.5
+ZK430.1	C05C8.5
+ZK632.14	C05C8.5
+ZK742.1	C05C8.5
+ZK795.3	C05C8.5
+C08B6.8	C05D11.9
+C15C6.4	C05D11.9
+C15H11.3	C05D11.9
+C15H11.6	C05D11.9
+C25A1.16	C05D11.9
+C47B2.5	C05D11.9
+C48B6.2	C05D11.9
+C53H9.2	C05D11.9
+E02H1.6	C05D11.9
+F13H8.2	C05D11.9
+F26E4.10	C05D11.9
+F27C1.6	C05D11.9
+F30A10.9	C05D11.9
+F52C9.8	C05D11.9
+F55A12.8	C05D11.9
+F55F10.1	C05D11.9
+F55F8.3	C05D11.9
+H35B03.2	C05D11.9
+K01C8.9	C05D11.9
+K01G5.4	C05D11.9
+K01G5.5	C05D11.9
+K07C5.4	C05D11.9
+K10C3.5	C05D11.9
+M01B12.5	C05D11.9
+M28.5	C05D11.9
+R05H10.2	C05D11.9
+T01C3.7	C05D11.9
+T01G9.6	C05D11.9
+T07A9.9	C05D11.9
+T10B5.3	C05D11.9
+T19A6.2	C05D11.9
+T25G3.3	C05D11.9
+W01B11.3	C05D11.9
+W06E11.4	C05D11.9
+Y105E8B.3	C05D11.9
+Y23H5B.5	C05D11.9
+Y39A1A.14	C05D11.9
+Y39G8C.1	C05D11.9
+Y45F10D.7	C05D11.9
+Y48A6B.3	C05D11.9
+Y48B6A.3	C05D11.9
+Y48C3A.7	C05D11.9
+Y51H7C.11	C05D11.9
+Y53C12B.1	C05D11.9
+Y54E10BR.4	C05D11.9
+Y56A3A.33	C05D11.9
+Y61A9LA.10	C05D11.9
+Y62E10A.2	C05D11.9
+Y66A7A.2	C05D11.9
+Y66H1A.4	C05D11.9
+Y71F9AM.5	C05D11.9
+Y75B8A.7	C05D11.9
+ZC434.4	C05D11.9
+ZK1127.5	C05D11.9
+ZK430.1	C05D11.9
+ZK632.14	C05D11.9
+ZK742.1	C05D11.9
+ZK795.3	C05D11.9
+C15C6.4	C08B6.8
+C15H11.3	C08B6.8
+C15H11.6	C08B6.8
+C25A1.16	C08B6.8
+C47B2.5	C08B6.8
+C48B6.2	C08B6.8
+C53H9.2	C08B6.8
+E02H1.6	C08B6.8
+F13H8.2	C08B6.8
+F26E4.10	C08B6.8
+F27C1.6	C08B6.8
+F30A10.9	C08B6.8
+F52C9.8	C08B6.8
+F55A12.8	C08B6.8
+F55F10.1	C08B6.8
+F55F8.3	C08B6.8
+H35B03.2	C08B6.8
+K01C8.9	C08B6.8
+K01G5.4	C08B6.8
+K01G5.5	C08B6.8
+K07C5.4	C08B6.8
+K10C3.5	C08B6.8
+M01B12.5	C08B6.8
+M28.5	C08B6.8
+R05H10.2	C08B6.8
+T01C3.7	C08B6.8
+T01G9.6	C08B6.8
+T07A9.9	C08B6.8
+T10B5.3	C08B6.8
+T19A6.2	C08B6.8
+T25G3.3	C08B6.8
+W01B11.3	C08B6.8
+W06E11.4	C08B6.8
+Y105E8B.3	C08B6.8
+Y23H5B.5	C08B6.8
+Y39A1A.14	C08B6.8
+Y39G8C.1	C08B6.8
+Y45F10D.7	C08B6.8
+Y48A6B.3	C08B6.8
+Y48B6A.3	C08B6.8
+Y48C3A.7	C08B6.8
+Y51H7C.11	C08B6.8
+Y53C12B.1	C08B6.8
+Y54E10BR.4	C08B6.8
+Y56A3A.33	C08B6.8
+Y61A9LA.10	C08B6.8
+Y62E10A.2	C08B6.8
+Y66A7A.2	C08B6.8
+Y66H1A.4	C08B6.8
+Y71F9AM.5	C08B6.8
+Y75B8A.7	C08B6.8
+ZC434.4	C08B6.8
+ZK1127.5	C08B6.8
+ZK430.1	C08B6.8
+ZK632.14	C08B6.8
+ZK742.1	C08B6.8
+ZK795.3	C08B6.8
+C15H11.3	C15C6.4
+C15H11.6	C15C6.4
+C25A1.16	C15C6.4
+C47B2.5	C15C6.4
+C48B6.2	C15C6.4
+C53H9.2	C15C6.4
+E02H1.6	C15C6.4
+F13H8.2	C15C6.4
+F26E4.10	C15C6.4
+F27C1.6	C15C6.4
+F30A10.9	C15C6.4
+F52C9.8	C15C6.4
+F55A12.8	C15C6.4
+F55F10.1	C15C6.4
+F55F8.3	C15C6.4
+H35B03.2	C15C6.4
+K01C8.9	C15C6.4
+K01G5.4	C15C6.4
+K01G5.5	C15C6.4
+K07C5.4	C15C6.4
+K10C3.5	C15C6.4
+M01B12.5	C15C6.4
+M28.5	C15C6.4
+R05H10.2	C15C6.4
+T01C3.7	C15C6.4
+T01G9.6	C15C6.4
+T07A9.9	C15C6.4
+T10B5.3	C15C6.4
+T19A6.2	C15C6.4
+T25G3.3	C15C6.4
+W01B11.3	C15C6.4
+W06E11.4	C15C6.4
+Y105E8B.3	C15C6.4
+Y23H5B.5	C15C6.4
+Y39A1A.14	C15C6.4
+Y39G8C.1	C15C6.4
+Y45F10D.7	C15C6.4
+Y48A6B.3	C15C6.4
+Y48B6A.3	C15C6.4
+Y48C3A.7	C15C6.4
+Y51H7C.11	C15C6.4
+Y53C12B.1	C15C6.4
+Y54E10BR.4	C15C6.4
+Y56A3A.33	C15C6.4
+Y61A9LA.10	C15C6.4
+Y62E10A.2	C15C6.4
+Y66A7A.2	C15C6.4
+Y66H1A.4	C15C6.4
+Y71F9AM.5	C15C6.4
+Y75B8A.7	C15C6.4
+ZC434.4	C15C6.4
+ZK1127.5	C15C6.4
+ZK430.1	C15C6.4
+ZK632.14	C15C6.4
+ZK742.1	C15C6.4
+ZK795.3	C15C6.4
+C15H11.6	C15H11.3
+C25A1.16	C15H11.3
+C47B2.5	C15H11.3
+C48B6.2	C15H11.3
+C53H9.2	C15H11.3
+E02H1.6	C15H11.3
+F13H8.2	C15H11.3
+F26E4.10	C15H11.3
+F27C1.6	C15H11.3
+F30A10.9	C15H11.3
+F52C9.8	C15H11.3
+F55A12.8	C15H11.3
+F55F10.1	C15H11.3
+F55F8.3	C15H11.3
+H35B03.2	C15H11.3
+K01C8.9	C15H11.3
+K01G5.4	C15H11.3
+K01G5.5	C15H11.3
+K07C5.4	C15H11.3
+K10C3.5	C15H11.3
+M01B12.5	C15H11.3
+M28.5	C15H11.3
+R05H10.2	C15H11.3
+T01C3.7	C15H11.3
+T01G9.6	C15H11.3
+T07A9.9	C15H11.3
+T10B5.3	C15H11.3
+T19A6.2	C15H11.3
+T25G3.3	C15H11.3
+W01B11.3	C15H11.3
+W06E11.4	C15H11.3
+Y105E8B.3	C15H11.3
+Y23H5B.5	C15H11.3
+Y39A1A.14	C15H11.3
+Y39G8C.1	C15H11.3
+Y45F10D.7	C15H11.3
+Y48A6B.3	C15H11.3
+Y48B6A.3	C15H11.3
+Y48C3A.7	C15H11.3
+Y51H7C.11	C15H11.3
+Y53C12B.1	C15H11.3
+Y54E10BR.4	C15H11.3
+Y56A3A.33	C15H11.3
+Y61A9LA.10	C15H11.3
+Y62E10A.2	C15H11.3
+Y66A7A.2	C15H11.3
+Y66H1A.4	C15H11.3
+Y71F9AM.5	C15H11.3
+Y75B8A.7	C15H11.3
+ZC434.4	C15H11.3
+ZK1127.5	C15H11.3
+ZK430.1	C15H11.3
+ZK632.14	C15H11.3
+ZK742.1	C15H11.3
+ZK795.3	C15H11.3
+C25A1.16	C15H11.6
+C47B2.5	C15H11.6
+C48B6.2	C15H11.6
+C53H9.2	C15H11.6
+E02H1.6	C15H11.6
+F13H8.2	C15H11.6
+F26E4.10	C15H11.6
+F27C1.6	C15H11.6
+F30A10.9	C15H11.6
+F52C9.8	C15H11.6
+F55A12.8	C15H11.6
+F55F10.1	C15H11.6
+F55F8.3	C15H11.6
+H35B03.2	C15H11.6
+K01C8.9	C15H11.6
+K01G5.4	C15H11.6
+K01G5.5	C15H11.6
+K07C5.4	C15H11.6
+K10C3.5	C15H11.6
+M01B12.5	C15H11.6
+M28.5	C15H11.6
+R05H10.2	C15H11.6
+T01C3.7	C15H11.6
+T01G9.6	C15H11.6
+T07A9.9	C15H11.6
+T10B5.3	C15H11.6
+T19A6.2	C15H11.6
+T25G3.3	C15H11.6
+W01B11.3	C15H11.6
+W06E11.4	C15H11.6
+Y105E8B.3	C15H11.6
+Y23H5B.5	C15H11.6
+Y39A1A.14	C15H11.6
+Y39G8C.1	C15H11.6
+Y45F10D.7	C15H11.6
+Y48A6B.3	C15H11.6
+Y48B6A.3	C15H11.6
+Y48C3A.7	C15H11.6
+Y51H7C.11	C15H11.6
+Y53C12B.1	C15H11.6
+Y54E10BR.4	C15H11.6
+Y56A3A.33	C15H11.6
+Y61A9LA.10	C15H11.6
+Y62E10A.2	C15H11.6
+Y66A7A.2	C15H11.6
+Y66H1A.4	C15H11.6
+Y71F9AM.5	C15H11.6
+Y75B8A.7	C15H11.6
+ZC434.4	C15H11.6
+ZK1127.5	C15H11.6
+ZK430.1	C15H11.6
+ZK632.14	C15H11.6
+ZK742.1	C15H11.6
+ZK795.3	C15H11.6
+C47B2.5	C25A1.16
+C48B6.2	C25A1.16
+C53H9.2	C25A1.16
+E02H1.6	C25A1.16
+F13H8.2	C25A1.16
+F26E4.10	C25A1.16
+F27C1.6	C25A1.16
+F30A10.9	C25A1.16
+F52C9.8	C25A1.16
+F55A12.8	C25A1.16
+F55F10.1	C25A1.16
+F55F8.3	C25A1.16
+H35B03.2	C25A1.16
+K01C8.9	C25A1.16
+K01G5.4	C25A1.16
+K01G5.5	C25A1.16
+K07C5.4	C25A1.16
+K10C3.5	C25A1.16
+M01B12.5	C25A1.16
+M28.5	C25A1.16
+R05H10.2	C25A1.16
+T01C3.7	C25A1.16
+T01G9.6	C25A1.16
+T07A9.9	C25A1.16
+T10B5.3	C25A1.16
+T19A6.2	C25A1.16
+T25G3.3	C25A1.16
+W01B11.3	C25A1.16
+W06E11.4	C25A1.16
+Y105E8B.3	C25A1.16
+Y23H5B.5	C25A1.16
+Y39A1A.14	C25A1.16
+Y39G8C.1	C25A1.16
+Y45F10D.7	C25A1.16
+Y48A6B.3	C25A1.16
+Y48B6A.3	C25A1.16
+Y48C3A.7	C25A1.16
+Y51H7C.11	C25A1.16
+Y53C12B.1	C25A1.16
+Y54E10BR.4	C25A1.16
+Y56A3A.33	C25A1.16
+Y61A9LA.10	C25A1.16
+Y62E10A.2	C25A1.16
+Y66A7A.2	C25A1.16
+Y66H1A.4	C25A1.16
+Y71F9AM.5	C25A1.16
+Y75B8A.7	C25A1.16
+ZC434.4	C25A1.16
+ZK1127.5	C25A1.16
+ZK430.1	C25A1.16
+ZK632.14	C25A1.16
+ZK742.1	C25A1.16
+ZK795.3	C25A1.16
+C48B6.2	C47B2.5
+C53H9.2	C47B2.5
+E02H1.6	C47B2.5
+F13H8.2	C47B2.5
+F26E4.10	C47B2.5
+F27C1.6	C47B2.5
+F30A10.9	C47B2.5
+F52C9.8	C47B2.5
+F55A12.8	C47B2.5
+F55F10.1	C47B2.5
+F55F8.3	C47B2.5
+H35B03.2	C47B2.5
+K01C8.9	C47B2.5
+K01G5.4	C47B2.5
+K01G5.5	C47B2.5
+K07C5.4	C47B2.5
+K10C3.5	C47B2.5
+M01B12.5	C47B2.5
+M28.5	C47B2.5
+R05H10.2	C47B2.5
+T01C3.7	C47B2.5
+T01G9.6	C47B2.5
+T07A9.9	C47B2.5
+T10B5.3	C47B2.5
+T19A6.2	C47B2.5
+T25G3.3	C47B2.5
+W01B11.3	C47B2.5
+W06E11.4	C47B2.5
+Y105E8B.3	C47B2.5
+Y23H5B.5	C47B2.5
+Y39A1A.14	C47B2.5
+Y39G8C.1	C47B2.5
+Y45F10D.7	C47B2.5
+Y48A6B.3	C47B2.5
+Y48B6A.3	C47B2.5
+Y48C3A.7	C47B2.5
+Y51H7C.11	C47B2.5
+Y53C12B.1	C47B2.5
+Y54E10BR.4	C47B2.5
+Y56A3A.33	C47B2.5
+Y61A9LA.10	C47B2.5
+Y62E10A.2	C47B2.5
+Y66A7A.2	C47B2.5
+Y66H1A.4	C47B2.5
+Y71F9AM.5	C47B2.5
+Y75B8A.7	C47B2.5
+ZC434.4	C47B2.5
+ZK1127.5	C47B2.5
+ZK430.1	C47B2.5
+ZK632.14	C47B2.5
+ZK742.1	C47B2.5
+ZK795.3	C47B2.5
+C53H9.2	C48B6.2
+E02H1.6	C48B6.2
+F13H8.2	C48B6.2
+F26E4.10	C48B6.2
+F27C1.6	C48B6.2
+F30A10.9	C48B6.2
+F52C9.8	C48B6.2
+F55A12.8	C48B6.2
+F55F10.1	C48B6.2
+F55F8.3	C48B6.2
+H35B03.2	C48B6.2
+K01C8.9	C48B6.2
+K01G5.4	C48B6.2
+K01G5.5	C48B6.2
+K07C5.4	C48B6.2
+K10C3.5	C48B6.2
+M01B12.5	C48B6.2
+M28.5	C48B6.2
+R05H10.2	C48B6.2
+T01C3.7	C48B6.2
+T01G9.6	C48B6.2
+T07A9.9	C48B6.2
+T10B5.3	C48B6.2
+T19A6.2	C48B6.2
+T25G3.3	C48B6.2
+W01B11.3	C48B6.2
+W06E11.4	C48B6.2
+Y105E8B.3	C48B6.2
+Y23H5B.5	C48B6.2
+Y39A1A.14	C48B6.2
+Y39G8C.1	C48B6.2
+Y45F10D.7	C48B6.2
+Y48A6B.3	C48B6.2
+Y48B6A.3	C48B6.2
+Y48C3A.7	C48B6.2
+Y51H7C.11	C48B6.2
+Y53C12B.1	C48B6.2
+Y54E10BR.4	C48B6.2
+Y56A3A.33	C48B6.2
+Y61A9LA.10	C48B6.2
+Y62E10A.2	C48B6.2
+Y66A7A.2	C48B6.2
+Y66H1A.4	C48B6.2
+Y71F9AM.5	C48B6.2
+Y75B8A.7	C48B6.2
+ZC434.4	C48B6.2
+ZK1127.5	C48B6.2
+ZK430.1	C48B6.2
+ZK632.14	C48B6.2
+ZK742.1	C48B6.2
+ZK795.3	C48B6.2
+E02H1.6	C53H9.2
+F13H8.2	C53H9.2
+F26E4.10	C53H9.2
+F27C1.6	C53H9.2
+F30A10.9	C53H9.2
+F52C9.8	C53H9.2
+F55A12.8	C53H9.2
+F55F10.1	C53H9.2
+F55F8.3	C53H9.2
+H35B03.2	C53H9.2
+K01C8.9	C53H9.2
+K01G5.4	C53H9.2
+K01G5.5	C53H9.2
+K07C5.4	C53H9.2
+K10C3.5	C53H9.2
+M01B12.5	C53H9.2
+M28.5	C53H9.2
+R05H10.2	C53H9.2
+T01C3.7	C53H9.2
+T01G9.6	C53H9.2
+T07A9.9	C53H9.2
+T10B5.3	C53H9.2
+T19A6.2	C53H9.2
+T25G3.3	C53H9.2
+W01B11.3	C53H9.2
+W06E11.4	C53H9.2
+Y105E8B.3	C53H9.2
+Y23H5B.5	C53H9.2
+Y39A1A.14	C53H9.2
+Y39G8C.1	C53H9.2
+Y45F10D.7	C53H9.2
+Y48A6B.3	C53H9.2
+Y48B6A.3	C53H9.2
+Y48C3A.7	C53H9.2
+Y51H7C.11	C53H9.2
+Y53C12B.1	C53H9.2
+Y54E10BR.4	C53H9.2
+Y56A3A.33	C53H9.2
+Y61A9LA.10	C53H9.2
+Y62E10A.2	C53H9.2
+Y66A7A.2	C53H9.2
+Y66H1A.4	C53H9.2
+Y71F9AM.5	C53H9.2
+Y75B8A.7	C53H9.2
+ZC434.4	C53H9.2
+ZK1127.5	C53H9.2
+ZK430.1	C53H9.2
+ZK632.14	C53H9.2
+ZK742.1	C53H9.2
+ZK795.3	C53H9.2
+F13H8.2	E02H1.6
+F26E4.10	E02H1.6
+F27C1.6	E02H1.6
+F30A10.9	E02H1.6
+F52C9.8	E02H1.6
+F55A12.8	E02H1.6
+F55F10.1	E02H1.6
+F55F8.3	E02H1.6
+H35B03.2	E02H1.6
+K01C8.9	E02H1.6
+K01G5.4	E02H1.6
+K01G5.5	E02H1.6
+K07C5.4	E02H1.6
+K10C3.5	E02H1.6
+M01B12.5	E02H1.6
+M28.5	E02H1.6
+R05H10.2	E02H1.6
+T01C3.7	E02H1.6
+T01G9.6	E02H1.6
+T07A9.9	E02H1.6
+T10B5.3	E02H1.6
+T19A6.2	E02H1.6
+T25G3.3	E02H1.6
+W01B11.3	E02H1.6
+W06E11.4	E02H1.6
+Y105E8B.3	E02H1.6
+Y23H5B.5	E02H1.6
+Y39A1A.14	E02H1.6
+Y39G8C.1	E02H1.6
+Y45F10D.7	E02H1.6
+Y48A6B.3	E02H1.6
+Y48B6A.3	E02H1.6
+Y48C3A.7	E02H1.6
+Y51H7C.11	E02H1.6
+Y53C12B.1	E02H1.6
+Y54E10BR.4	E02H1.6
+Y56A3A.33	E02H1.6
+Y61A9LA.10	E02H1.6
+Y62E10A.2	E02H1.6
+Y66A7A.2	E02H1.6
+Y66H1A.4	E02H1.6
+Y71F9AM.5	E02H1.6
+Y75B8A.7	E02H1.6
+ZC434.4	E02H1.6
+ZK1127.5	E02H1.6
+ZK430.1	E02H1.6
+ZK632.14	E02H1.6
+ZK742.1	E02H1.6
+ZK795.3	E02H1.6
+F26E4.10	F13H8.2
+F27C1.6	F13H8.2
+F30A10.9	F13H8.2
+F52C9.8	F13H8.2
+F55A12.8	F13H8.2
+F55F10.1	F13H8.2
+F55F8.3	F13H8.2
+H35B03.2	F13H8.2
+K01C8.9	F13H8.2
+K01G5.4	F13H8.2
+K01G5.5	F13H8.2
+K07C5.4	F13H8.2
+K10C3.5	F13H8.2
+M01B12.5	F13H8.2
+M28.5	F13H8.2
+R05H10.2	F13H8.2
+T01C3.7	F13H8.2
+T01G9.6	F13H8.2
+T07A9.9	F13H8.2
+T10B5.3	F13H8.2
+T19A6.2	F13H8.2
+T25G3.3	F13H8.2
+W01B11.3	F13H8.2
+W06E11.4	F13H8.2
+Y105E8B.3	F13H8.2
+Y23H5B.5	F13H8.2
+Y39A1A.14	F13H8.2
+Y39G8C.1	F13H8.2
+Y45F10D.7	F13H8.2
+Y48A6B.3	F13H8.2
+Y48B6A.3	F13H8.2
+Y48C3A.7	F13H8.2
+Y51H7C.11	F13H8.2
+Y53C12B.1	F13H8.2
+Y54E10BR.4	F13H8.2
+Y56A3A.33	F13H8.2
+Y61A9LA.10	F13H8.2
+Y62E10A.2	F13H8.2
+Y66A7A.2	F13H8.2
+Y66H1A.4	F13H8.2
+Y71F9AM.5	F13H8.2
+Y75B8A.7	F13H8.2
+ZC434.4	F13H8.2
+ZK1127.5	F13H8.2
+ZK430.1	F13H8.2
+ZK632.14	F13H8.2
+ZK742.1	F13H8.2
+ZK795.3	F13H8.2
+F27C1.6	F26E4.10
+F30A10.9	F26E4.10
+F52C9.8	F26E4.10
+F55A12.8	F26E4.10
+F55F10.1	F26E4.10
+F55F8.3	F26E4.10
+H35B03.2	F26E4.10
+K01C8.9	F26E4.10
+K01G5.4	F26E4.10
+K01G5.5	F26E4.10
+K07C5.4	F26E4.10
+K10C3.5	F26E4.10
+M01B12.5	F26E4.10
+M28.5	F26E4.10
+R05H10.2	F26E4.10
+T01C3.7	F26E4.10
+T01G9.6	F26E4.10
+T07A9.9	F26E4.10
+T10B5.3	F26E4.10
+T19A6.2	F26E4.10
+T25G3.3	F26E4.10
+W01B11.3	F26E4.10
+W06E11.4	F26E4.10
+Y105E8B.3	F26E4.10
+Y23H5B.5	F26E4.10
+Y39A1A.14	F26E4.10
+Y39G8C.1	F26E4.10
+Y45F10D.7	F26E4.10
+Y48A6B.3	F26E4.10
+Y48B6A.3	F26E4.10
+Y48C3A.7	F26E4.10
+Y51H7C.11	F26E4.10
+Y53C12B.1	F26E4.10
+Y54E10BR.4	F26E4.10
+Y56A3A.33	F26E4.10
+Y61A9LA.10	F26E4.10
+Y62E10A.2	F26E4.10
+Y66A7A.2	F26E4.10
+Y66H1A.4	F26E4.10
+Y71F9AM.5	F26E4.10
+Y75B8A.7	F26E4.10
+ZC434.4	F26E4.10
+ZK1127.5	F26E4.10
+ZK430.1	F26E4.10
+ZK632.14	F26E4.10
+ZK742.1	F26E4.10
+ZK795.3	F26E4.10
+F30A10.9	F27C1.6
+F52C9.8	F27C1.6
+F55A12.8	F27C1.6
+F55F10.1	F27C1.6
+F55F8.3	F27C1.6
+H35B03.2	F27C1.6
+K01C8.9	F27C1.6
+K01G5.4	F27C1.6
+K01G5.5	F27C1.6
+K07C5.4	F27C1.6
+K10C3.5	F27C1.6
+M01B12.5	F27C1.6
+M28.5	F27C1.6
+R05H10.2	F27C1.6
+T01C3.7	F27C1.6
+T01G9.6	F27C1.6
+T07A9.9	F27C1.6
+T10B5.3	F27C1.6
+T19A6.2	F27C1.6
+T25G3.3	F27C1.6
+W01B11.3	F27C1.6
+W06E11.4	F27C1.6
+Y105E8B.3	F27C1.6
+Y23H5B.5	F27C1.6
+Y39A1A.14	F27C1.6
+Y39G8C.1	F27C1.6
+Y45F10D.7	F27C1.6
+Y48A6B.3	F27C1.6
+Y48B6A.3	F27C1.6
+Y48C3A.7	F27C1.6
+Y51H7C.11	F27C1.6
+Y53C12B.1	F27C1.6
+Y54E10BR.4	F27C1.6
+Y56A3A.33	F27C1.6
+Y61A9LA.10	F27C1.6
+Y62E10A.2	F27C1.6
+Y66A7A.2	F27C1.6
+Y66H1A.4	F27C1.6
+Y71F9AM.5	F27C1.6
+Y75B8A.7	F27C1.6
+ZC434.4	F27C1.6
+ZK1127.5	F27C1.6
+ZK430.1	F27C1.6
+ZK632.14	F27C1.6
+ZK742.1	F27C1.6
+ZK795.3	F27C1.6
+F52C9.8	F30A10.9
+F55A12.8	F30A10.9
+F55F10.1	F30A10.9
+F55F8.3	F30A10.9
+H35B03.2	F30A10.9
+K01C8.9	F30A10.9
+K01G5.4	F30A10.9
+K01G5.5	F30A10.9
+K07C5.4	F30A10.9
+K10C3.5	F30A10.9
+M01B12.5	F30A10.9
+M28.5	F30A10.9
+R05H10.2	F30A10.9
+T01C3.7	F30A10.9
+T01G9.6	F30A10.9
+T07A9.9	F30A10.9
+T10B5.3	F30A10.9
+T19A6.2	F30A10.9
+T25G3.3	F30A10.9
+W01B11.3	F30A10.9
+W06E11.4	F30A10.9
+Y105E8B.3	F30A10.9
+Y23H5B.5	F30A10.9
+Y39A1A.14	F30A10.9
+Y39G8C.1	F30A10.9
+Y45F10D.7	F30A10.9
+Y48A6B.3	F30A10.9
+Y48B6A.3	F30A10.9
+Y48C3A.7	F30A10.9
+Y51H7C.11	F30A10.9
+Y53C12B.1	F30A10.9
+Y54E10BR.4	F30A10.9
+Y56A3A.33	F30A10.9
+Y61A9LA.10	F30A10.9
+Y62E10A.2	F30A10.9
+Y66A7A.2	F30A10.9
+Y66H1A.4	F30A10.9
+Y71F9AM.5	F30A10.9
+Y75B8A.7	F30A10.9
+ZC434.4	F30A10.9
+ZK1127.5	F30A10.9
+ZK430.1	F30A10.9
+ZK632.14	F30A10.9
+ZK742.1	F30A10.9
+ZK795.3	F30A10.9
+F55A12.8	F52C9.8
+F55F10.1	F52C9.8
+F55F8.3	F52C9.8
+H35B03.2	F52C9.8
+K01C8.9	F52C9.8
+K01G5.4	F52C9.8
+K01G5.5	F52C9.8
+K07C5.4	F52C9.8
+K10C3.5	F52C9.8
+M01B12.5	F52C9.8
+M28.5	F52C9.8
+R05H10.2	F52C9.8
+T01C3.7	F52C9.8
+T01G9.6	F52C9.8
+T07A9.9	F52C9.8
+T10B5.3	F52C9.8
+T19A6.2	F52C9.8
+T25G3.3	F52C9.8
+W01B11.3	F52C9.8
+W06E11.4	F52C9.8
+Y105E8B.3	F52C9.8
+Y23H5B.5	F52C9.8
+Y39A1A.14	F52C9.8
+Y39G8C.1	F52C9.8
+Y45F10D.7	F52C9.8
+Y48A6B.3	F52C9.8
+Y48B6A.3	F52C9.8
+Y48C3A.7	F52C9.8
+Y51H7C.11	F52C9.8
+Y53C12B.1	F52C9.8
+Y54E10BR.4	F52C9.8
+Y56A3A.33	F52C9.8
+Y61A9LA.10	F52C9.8
+Y62E10A.2	F52C9.8
+Y66A7A.2	F52C9.8
+Y66H1A.4	F52C9.8
+Y71F9AM.5	F52C9.8
+Y75B8A.7	F52C9.8
+ZC434.4	F52C9.8
+ZK1127.5	F52C9.8
+ZK430.1	F52C9.8
+ZK632.14	F52C9.8
+ZK742.1	F52C9.8
+ZK795.3	F52C9.8
+F55F10.1	F55A12.8
+F55F8.3	F55A12.8
+H35B03.2	F55A12.8
+K01C8.9	F55A12.8
+K01G5.4	F55A12.8
+K01G5.5	F55A12.8
+K07C5.4	F55A12.8
+K10C3.5	F55A12.8
+M01B12.5	F55A12.8
+M28.5	F55A12.8
+R05H10.2	F55A12.8
+T01C3.7	F55A12.8
+T01G9.6	F55A12.8
+T07A9.9	F55A12.8
+T10B5.3	F55A12.8
+T19A6.2	F55A12.8
+T25G3.3	F55A12.8
+W01B11.3	F55A12.8
+W06E11.4	F55A12.8
+Y105E8B.3	F55A12.8
+Y23H5B.5	F55A12.8
+Y39A1A.14	F55A12.8
+Y39G8C.1	F55A12.8
+Y45F10D.7	F55A12.8
+Y48A6B.3	F55A12.8
+Y48B6A.3	F55A12.8
+Y48C3A.7	F55A12.8
+Y51H7C.11	F55A12.8
+Y53C12B.1	F55A12.8
+Y54E10BR.4	F55A12.8
+Y56A3A.33	F55A12.8
+Y61A9LA.10	F55A12.8
+Y62E10A.2	F55A12.8
+Y66A7A.2	F55A12.8
+Y66H1A.4	F55A12.8
+Y71F9AM.5	F55A12.8
+Y75B8A.7	F55A12.8
+ZC434.4	F55A12.8
+ZK1127.5	F55A12.8
+ZK430.1	F55A12.8
+ZK632.14	F55A12.8
+ZK742.1	F55A12.8
+ZK795.3	F55A12.8
+F55F8.3	F55F10.1
+H35B03.2	F55F10.1
+K01C8.9	F55F10.1
+K01G5.4	F55F10.1
+K01G5.5	F55F10.1
+K07C5.4	F55F10.1
+K10C3.5	F55F10.1
+M01B12.5	F55F10.1
+M28.5	F55F10.1
+R05H10.2	F55F10.1
+T01C3.7	F55F10.1
+T01G9.6	F55F10.1
+T07A9.9	F55F10.1
+T10B5.3	F55F10.1
+T19A6.2	F55F10.1
+T25G3.3	F55F10.1
+W01B11.3	F55F10.1
+W06E11.4	F55F10.1
+Y105E8B.3	F55F10.1
+Y23H5B.5	F55F10.1
+Y39A1A.14	F55F10.1
+Y39G8C.1	F55F10.1
+Y45F10D.7	F55F10.1
+Y48A6B.3	F55F10.1
+Y48B6A.3	F55F10.1
+Y48C3A.7	F55F10.1
+Y51H7C.11	F55F10.1
+Y53C12B.1	F55F10.1
+Y54E10BR.4	F55F10.1
+Y56A3A.33	F55F10.1
+Y61A9LA.10	F55F10.1
+Y62E10A.2	F55F10.1
+Y66A7A.2	F55F10.1
+Y66H1A.4	F55F10.1
+Y71F9AM.5	F55F10.1
+Y75B8A.7	F55F10.1
+ZC434.4	F55F10.1
+ZK1127.5	F55F10.1
+ZK430.1	F55F10.1
+ZK632.14	F55F10.1
+ZK742.1	F55F10.1
+ZK795.3	F55F10.1
+H35B03.2	F55F8.3
+K01C8.9	F55F8.3
+K01G5.4	F55F8.3
+K01G5.5	F55F8.3
+K07C5.4	F55F8.3
+K10C3.5	F55F8.3
+M01B12.5	F55F8.3
+M28.5	F55F8.3
+R05H10.2	F55F8.3
+T01C3.7	F55F8.3
+T01G9.6	F55F8.3
+T07A9.9	F55F8.3
+T10B5.3	F55F8.3
+T19A6.2	F55F8.3
+T25G3.3	F55F8.3
+W01B11.3	F55F8.3
+W06E11.4	F55F8.3
+Y105E8B.3	F55F8.3
+Y23H5B.5	F55F8.3
+Y39A1A.14	F55F8.3
+Y39G8C.1	F55F8.3
+Y45F10D.7	F55F8.3
+Y48A6B.3	F55F8.3
+Y48B6A.3	F55F8.3
+Y48C3A.7	F55F8.3
+Y51H7C.11	F55F8.3
+Y53C12B.1	F55F8.3
+Y54E10BR.4	F55F8.3
+Y56A3A.33	F55F8.3
+Y61A9LA.10	F55F8.3
+Y62E10A.2	F55F8.3
+Y66A7A.2	F55F8.3
+Y66H1A.4	F55F8.3
+Y71F9AM.5	F55F8.3
+Y75B8A.7	F55F8.3
+ZC434.4	F55F8.3
+ZK1127.5	F55F8.3
+ZK430.1	F55F8.3
+ZK632.14	F55F8.3
+ZK742.1	F55F8.3
+ZK795.3	F55F8.3
+K01C8.9	H35B03.2
+K01G5.4	H35B03.2
+K01G5.5	H35B03.2
+K07C5.4	H35B03.2
+K10C3.5	H35B03.2
+M01B12.5	H35B03.2
+M28.5	H35B03.2
+R05H10.2	H35B03.2
+T01C3.7	H35B03.2
+T01G9.6	H35B03.2
+T07A9.9	H35B03.2
+T10B5.3	H35B03.2
+T19A6.2	H35B03.2
+T25G3.3	H35B03.2
+W01B11.3	H35B03.2
+W06E11.4	H35B03.2
+Y105E8B.3	H35B03.2
+Y23H5B.5	H35B03.2
+Y39A1A.14	H35B03.2
+Y39G8C.1	H35B03.2
+Y45F10D.7	H35B03.2
+Y48A6B.3	H35B03.2
+Y48B6A.3	H35B03.2
+Y48C3A.7	H35B03.2
+Y51H7C.11	H35B03.2
+Y53C12B.1	H35B03.2
+Y54E10BR.4	H35B03.2
+Y56A3A.33	H35B03.2
+Y61A9LA.10	H35B03.2
+Y62E10A.2	H35B03.2
+Y66A7A.2	H35B03.2
+Y66H1A.4	H35B03.2
+Y71F9AM.5	H35B03.2
+Y75B8A.7	H35B03.2
+ZC434.4	H35B03.2
+ZK1127.5	H35B03.2
+ZK430.1	H35B03.2
+ZK632.14	H35B03.2
+ZK742.1	H35B03.2
+ZK795.3	H35B03.2
+K01G5.4	K01C8.9
+K01G5.5	K01C8.9
+K07C5.4	K01C8.9
+K10C3.5	K01C8.9
+M01B12.5	K01C8.9
+M28.5	K01C8.9
+R05H10.2	K01C8.9
+T01C3.7	K01C8.9
+T01G9.6	K01C8.9
+T07A9.9	K01C8.9
+T10B5.3	K01C8.9
+T19A6.2	K01C8.9
+T25G3.3	K01C8.9
+W01B11.3	K01C8.9
+W06E11.4	K01C8.9
+Y105E8B.3	K01C8.9
+Y23H5B.5	K01C8.9
+Y39A1A.14	K01C8.9
+Y39G8C.1	K01C8.9
+Y45F10D.7	K01C8.9
+Y48A6B.3	K01C8.9
+Y48B6A.3	K01C8.9
+Y48C3A.7	K01C8.9
+Y51H7C.11	K01C8.9
+Y53C12B.1	K01C8.9
+Y54E10BR.4	K01C8.9
+Y56A3A.33	K01C8.9
+Y61A9LA.10	K01C8.9
+Y62E10A.2	K01C8.9
+Y66A7A.2	K01C8.9
+Y66H1A.4	K01C8.9
+Y71F9AM.5	K01C8.9
+Y75B8A.7	K01C8.9
+ZC434.4	K01C8.9
+ZK1127.5	K01C8.9
+ZK430.1	K01C8.9
+ZK632.14	K01C8.9
+ZK742.1	K01C8.9
+ZK795.3	K01C8.9
+K01G5.5	K01G5.4
+K07C5.4	K01G5.4
+K10C3.5	K01G5.4
+M01B12.5	K01G5.4
+M28.5	K01G5.4
+R05H10.2	K01G5.4
+T01C3.7	K01G5.4
+T01G9.6	K01G5.4
+T07A9.9	K01G5.4
+T10B5.3	K01G5.4
+T19A6.2	K01G5.4
+T25G3.3	K01G5.4
+W01B11.3	K01G5.4
+W06E11.4	K01G5.4
+Y105E8B.3	K01G5.4
+Y23H5B.5	K01G5.4
+Y39A1A.14	K01G5.4
+Y39G8C.1	K01G5.4
+Y45F10D.7	K01G5.4
+Y48A6B.3	K01G5.4
+Y48B6A.3	K01G5.4
+Y48C3A.7	K01G5.4
+Y51H7C.11	K01G5.4
+Y53C12B.1	K01G5.4
+Y54E10BR.4	K01G5.4
+Y56A3A.33	K01G5.4
+Y61A9LA.10	K01G5.4
+Y62E10A.2	K01G5.4
+Y66A7A.2	K01G5.4
+Y66H1A.4	K01G5.4
+Y71F9AM.5	K01G5.4
+Y75B8A.7	K01G5.4
+ZC434.4	K01G5.4
+ZK1127.5	K01G5.4
+ZK430.1	K01G5.4
+ZK632.14	K01G5.4
+ZK742.1	K01G5.4
+ZK795.3	K01G5.4
+K07C5.4	K01G5.5
+K10C3.5	K01G5.5
+M01B12.5	K01G5.5
+M28.5	K01G5.5
+R05H10.2	K01G5.5
+T01C3.7	K01G5.5
+T01G9.6	K01G5.5
+T07A9.9	K01G5.5
+T10B5.3	K01G5.5
+T19A6.2	K01G5.5
+T25G3.3	K01G5.5
+W01B11.3	K01G5.5
+W06E11.4	K01G5.5
+Y105E8B.3	K01G5.5
+Y23H5B.5	K01G5.5
+Y39A1A.14	K01G5.5
+Y39G8C.1	K01G5.5
+Y45F10D.7	K01G5.5
+Y48A6B.3	K01G5.5
+Y48B6A.3	K01G5.5
+Y48C3A.7	K01G5.5
+Y51H7C.11	K01G5.5
+Y53C12B.1	K01G5.5
+Y54E10BR.4	K01G5.5
+Y56A3A.33	K01G5.5
+Y61A9LA.10	K01G5.5
+Y62E10A.2	K01G5.5
+Y66A7A.2	K01G5.5
+Y66H1A.4	K01G5.5
+Y71F9AM.5	K01G5.5
+Y75B8A.7	K01G5.5
+ZC434.4	K01G5.5
+ZK1127.5	K01G5.5
+ZK430.1	K01G5.5
+ZK632.14	K01G5.5
+ZK742.1	K01G5.5
+ZK795.3	K01G5.5
+K10C3.5	K07C5.4
+M01B12.5	K07C5.4
+M28.5	K07C5.4
+R05H10.2	K07C5.4
+T01C3.7	K07C5.4
+T01G9.6	K07C5.4
+T07A9.9	K07C5.4
+T10B5.3	K07C5.4
+T19A6.2	K07C5.4
+T25G3.3	K07C5.4
+W01B11.3	K07C5.4
+W06E11.4	K07C5.4
+Y105E8B.3	K07C5.4
+Y23H5B.5	K07C5.4
+Y39A1A.14	K07C5.4
+Y39G8C.1	K07C5.4
+Y45F10D.7	K07C5.4
+Y48A6B.3	K07C5.4
+Y48B6A.3	K07C5.4
+Y48C3A.7	K07C5.4
+Y51H7C.11	K07C5.4
+Y53C12B.1	K07C5.4
+Y54E10BR.4	K07C5.4
+Y56A3A.33	K07C5.4
+Y61A9LA.10	K07C5.4
+Y62E10A.2	K07C5.4
+Y66A7A.2	K07C5.4
+Y66H1A.4	K07C5.4
+Y71F9AM.5	K07C5.4
+Y75B8A.7	K07C5.4
+ZC434.4	K07C5.4
+ZK1127.5	K07C5.4
+ZK430.1	K07C5.4
+ZK632.14	K07C5.4
+ZK742.1	K07C5.4
+ZK795.3	K07C5.4
+M01B12.5	K10C3.5
+M28.5	K10C3.5
+R05H10.2	K10C3.5
+T01C3.7	K10C3.5
+T01G9.6	K10C3.5
+T07A9.9	K10C3.5
+T10B5.3	K10C3.5
+T19A6.2	K10C3.5
+T25G3.3	K10C3.5
+W01B11.3	K10C3.5
+W06E11.4	K10C3.5
+Y105E8B.3	K10C3.5
+Y23H5B.5	K10C3.5
+Y39A1A.14	K10C3.5
+Y39G8C.1	K10C3.5
+Y45F10D.7	K10C3.5
+Y48A6B.3	K10C3.5
+Y48B6A.3	K10C3.5
+Y48C3A.7	K10C3.5
+Y51H7C.11	K10C3.5
+Y53C12B.1	K10C3.5
+Y54E10BR.4	K10C3.5
+Y56A3A.33	K10C3.5
+Y61A9LA.10	K10C3.5
+Y62E10A.2	K10C3.5
+Y66A7A.2	K10C3.5
+Y66H1A.4	K10C3.5
+Y71F9AM.5	K10C3.5
+Y75B8A.7	K10C3.5
+ZC434.4	K10C3.5
+ZK1127.5	K10C3.5
+ZK430.1	K10C3.5
+ZK632.14	K10C3.5
+ZK742.1	K10C3.5
+ZK795.3	K10C3.5
+M28.5	M01B12.5
+R05H10.2	M01B12.5
+T01C3.7	M01B12.5
+T01G9.6	M01B12.5
+T07A9.9	M01B12.5
+T10B5.3	M01B12.5
+T19A6.2	M01B12.5
+T25G3.3	M01B12.5
+W01B11.3	M01B12.5
+W06E11.4	M01B12.5
+Y105E8B.3	M01B12.5
+Y23H5B.5	M01B12.5
+Y39A1A.14	M01B12.5
+Y39G8C.1	M01B12.5
+Y45F10D.7	M01B12.5
+Y48A6B.3	M01B12.5
+Y48B6A.3	M01B12.5
+Y48C3A.7	M01B12.5
+Y51H7C.11	M01B12.5
+Y53C12B.1	M01B12.5
+Y54E10BR.4	M01B12.5
+Y56A3A.33	M01B12.5
+Y61A9LA.10	M01B12.5
+Y62E10A.2	M01B12.5
+Y66A7A.2	M01B12.5
+Y66H1A.4	M01B12.5
+Y71F9AM.5	M01B12.5
+Y75B8A.7	M01B12.5
+ZC434.4	M01B12.5
+ZK1127.5	M01B12.5
+ZK430.1	M01B12.5
+ZK632.14	M01B12.5
+ZK742.1	M01B12.5
+ZK795.3	M01B12.5
+R05H10.2	M28.5
+T01C3.7	M28.5
+T01G9.6	M28.5
+T07A9.9	M28.5
+T10B5.3	M28.5
+T19A6.2	M28.5
+T25G3.3	M28.5
+W01B11.3	M28.5
+W06E11.4	M28.5
+Y105E8B.3	M28.5
+Y23H5B.5	M28.5
+Y39A1A.14	M28.5
+Y39G8C.1	M28.5
+Y45F10D.7	M28.5
+Y48A6B.3	M28.5
+Y48B6A.3	M28.5
+Y48C3A.7	M28.5
+Y51H7C.11	M28.5
+Y53C12B.1	M28.5
+Y54E10BR.4	M28.5
+Y56A3A.33	M28.5
+Y61A9LA.10	M28.5
+Y62E10A.2	M28.5
+Y66A7A.2	M28.5
+Y66H1A.4	M28.5
+Y71F9AM.5	M28.5
+Y75B8A.7	M28.5
+ZC434.4	M28.5
+ZK1127.5	M28.5
+ZK430.1	M28.5
+ZK632.14	M28.5
+ZK742.1	M28.5
+ZK795.3	M28.5
+T01C3.7	R05H10.2
+T01G9.6	R05H10.2
+T07A9.9	R05H10.2
+T10B5.3	R05H10.2
+T19A6.2	R05H10.2
+T25G3.3	R05H10.2
+W01B11.3	R05H10.2
+W06E11.4	R05H10.2
+Y105E8B.3	R05H10.2
+Y23H5B.5	R05H10.2
+Y39A1A.14	R05H10.2
+Y39G8C.1	R05H10.2
+Y45F10D.7	R05H10.2
+Y48A6B.3	R05H10.2
+Y48B6A.3	R05H10.2
+Y48C3A.7	R05H10.2
+Y51H7C.11	R05H10.2
+Y53C12B.1	R05H10.2
+Y54E10BR.4	R05H10.2
+Y56A3A.33	R05H10.2
+Y61A9LA.10	R05H10.2
+Y62E10A.2	R05H10.2
+Y66A7A.2	R05H10.2
+Y66H1A.4	R05H10.2
+Y71F9AM.5	R05H10.2
+Y75B8A.7	R05H10.2
+ZC434.4	R05H10.2
+ZK1127.5	R05H10.2
+ZK430.1	R05H10.2
+ZK632.14	R05H10.2
+ZK742.1	R05H10.2
+ZK795.3	R05H10.2
+T01G9.6	T01C3.7
+T07A9.9	T01C3.7
+T10B5.3	T01C3.7
+T19A6.2	T01C3.7
+T25G3.3	T01C3.7
+W01B11.3	T01C3.7
+W06E11.4	T01C3.7
+Y105E8B.3	T01C3.7
+Y23H5B.5	T01C3.7
+Y39A1A.14	T01C3.7
+Y39G8C.1	T01C3.7
+Y45F10D.7	T01C3.7
+Y48A6B.3	T01C3.7
+Y48B6A.3	T01C3.7
+Y48C3A.7	T01C3.7
+Y51H7C.11	T01C3.7
+Y53C12B.1	T01C3.7
+Y54E10BR.4	T01C3.7
+Y56A3A.33	T01C3.7
+Y61A9LA.10	T01C3.7
+Y62E10A.2	T01C3.7
+Y66A7A.2	T01C3.7
+Y66H1A.4	T01C3.7
+Y71F9AM.5	T01C3.7
+Y75B8A.7	T01C3.7
+ZC434.4	T01C3.7
+ZK1127.5	T01C3.7
+ZK430.1	T01C3.7
+ZK632.14	T01C3.7
+ZK742.1	T01C3.7
+ZK795.3	T01C3.7
+T07A9.9	T01G9.6
+T10B5.3	T01G9.6
+T19A6.2	T01G9.6
+T25G3.3	T01G9.6
+W01B11.3	T01G9.6
+W06E11.4	T01G9.6
+Y105E8B.3	T01G9.6
+Y23H5B.5	T01G9.6
+Y39A1A.14	T01G9.6
+Y39G8C.1	T01G9.6
+Y45F10D.7	T01G9.6
+Y48A6B.3	T01G9.6
+Y48B6A.3	T01G9.6
+Y48C3A.7	T01G9.6
+Y51H7C.11	T01G9.6
+Y53C12B.1	T01G9.6
+Y54E10BR.4	T01G9.6
+Y56A3A.33	T01G9.6
+Y61A9LA.10	T01G9.6
+Y62E10A.2	T01G9.6
+Y66A7A.2	T01G9.6
+Y66H1A.4	T01G9.6
+Y71F9AM.5	T01G9.6
+Y75B8A.7	T01G9.6
+ZC434.4	T01G9.6
+ZK1127.5	T01G9.6
+ZK430.1	T01G9.6
+ZK632.14	T01G9.6
+ZK742.1	T01G9.6
+ZK795.3	T01G9.6
+T10B5.3	T07A9.9
+T19A6.2	T07A9.9
+T25G3.3	T07A9.9
+W01B11.3	T07A9.9
+W06E11.4	T07A9.9
+Y105E8B.3	T07A9.9
+Y23H5B.5	T07A9.9
+Y39A1A.14	T07A9.9
+Y39G8C.1	T07A9.9
+Y45F10D.7	T07A9.9
+Y48A6B.3	T07A9.9
+Y48B6A.3	T07A9.9
+Y48C3A.7	T07A9.9
+Y51H7C.11	T07A9.9
+Y53C12B.1	T07A9.9
+Y54E10BR.4	T07A9.9
+Y56A3A.33	T07A9.9
+Y61A9LA.10	T07A9.9
+Y62E10A.2	T07A9.9
+Y66A7A.2	T07A9.9
+Y66H1A.4	T07A9.9
+Y71F9AM.5	T07A9.9
+Y75B8A.7	T07A9.9
+ZC434.4	T07A9.9
+ZK1127.5	T07A9.9
+ZK430.1	T07A9.9
+ZK632.14	T07A9.9
+ZK742.1	T07A9.9
+ZK795.3	T07A9.9
+T19A6.2	T10B5.3
+T25G3.3	T10B5.3
+W01B11.3	T10B5.3
+W06E11.4	T10B5.3
+Y105E8B.3	T10B5.3
+Y23H5B.5	T10B5.3
+Y39A1A.14	T10B5.3
+Y39G8C.1	T10B5.3
+Y45F10D.7	T10B5.3
+Y48A6B.3	T10B5.3
+Y48B6A.3	T10B5.3
+Y48C3A.7	T10B5.3
+Y51H7C.11	T10B5.3
+Y53C12B.1	T10B5.3
+Y54E10BR.4	T10B5.3
+Y56A3A.33	T10B5.3
+Y61A9LA.10	T10B5.3
+Y62E10A.2	T10B5.3
+Y66A7A.2	T10B5.3
+Y66H1A.4	T10B5.3
+Y71F9AM.5	T10B5.3
+Y75B8A.7	T10B5.3
+ZC434.4	T10B5.3
+ZK1127.5	T10B5.3
+ZK430.1	T10B5.3
+ZK632.14	T10B5.3
+ZK742.1	T10B5.3
+ZK795.3	T10B5.3
+T25G3.3	T19A6.2
+W01B11.3	T19A6.2
+W06E11.4	T19A6.2
+Y105E8B.3	T19A6.2
+Y23H5B.5	T19A6.2
+Y39A1A.14	T19A6.2
+Y39G8C.1	T19A6.2
+Y45F10D.7	T19A6.2
+Y48A6B.3	T19A6.2
+Y48B6A.3	T19A6.2
+Y48C3A.7	T19A6.2
+Y51H7C.11	T19A6.2
+Y53C12B.1	T19A6.2
+Y54E10BR.4	T19A6.2
+Y56A3A.33	T19A6.2
+Y61A9LA.10	T19A6.2
+Y62E10A.2	T19A6.2
+Y66A7A.2	T19A6.2
+Y66H1A.4	T19A6.2
+Y71F9AM.5	T19A6.2
+Y75B8A.7	T19A6.2
+ZC434.4	T19A6.2
+ZK1127.5	T19A6.2
+ZK430.1	T19A6.2
+ZK632.14	T19A6.2
+ZK742.1	T19A6.2
+ZK795.3	T19A6.2
+W01B11.3	T25G3.3
+W06E11.4	T25G3.3
+Y105E8B.3	T25G3.3
+Y23H5B.5	T25G3.3
+Y39A1A.14	T25G3.3
+Y39G8C.1	T25G3.3
+Y45F10D.7	T25G3.3
+Y48A6B.3	T25G3.3
+Y48B6A.3	T25G3.3
+Y48C3A.7	T25G3.3
+Y51H7C.11	T25G3.3
+Y53C12B.1	T25G3.3
+Y54E10BR.4	T25G3.3
+Y56A3A.33	T25G3.3
+Y61A9LA.10	T25G3.3
+Y62E10A.2	T25G3.3
+Y66A7A.2	T25G3.3
+Y66H1A.4	T25G3.3
+Y71F9AM.5	T25G3.3
+Y75B8A.7	T25G3.3
+ZC434.4	T25G3.3
+ZK1127.5	T25G3.3
+ZK430.1	T25G3.3
+ZK632.14	T25G3.3
+ZK742.1	T25G3.3
+ZK795.3	T25G3.3
+W06E11.4	W01B11.3
+Y105E8B.3	W01B11.3
+Y23H5B.5	W01B11.3
+Y39A1A.14	W01B11.3
+Y39G8C.1	W01B11.3
+Y45F10D.7	W01B11.3
+Y48A6B.3	W01B11.3
+Y48B6A.3	W01B11.3
+Y48C3A.7	W01B11.3
+Y51H7C.11	W01B11.3
+Y53C12B.1	W01B11.3
+Y54E10BR.4	W01B11.3
+Y56A3A.33	W01B11.3
+Y61A9LA.10	W01B11.3
+Y62E10A.2	W01B11.3
+Y66A7A.2	W01B11.3
+Y66H1A.4	W01B11.3
+Y71F9AM.5	W01B11.3
+Y75B8A.7	W01B11.3
+ZC434.4	W01B11.3
+ZK1127.5	W01B11.3
+ZK430.1	W01B11.3
+ZK632.14	W01B11.3
+ZK742.1	W01B11.3
+ZK795.3	W01B11.3
+Y105E8B.3	W06E11.4
+Y23H5B.5	W06E11.4
+Y39A1A.14	W06E11.4
+Y39G8C.1	W06E11.4
+Y45F10D.7	W06E11.4
+Y48A6B.3	W06E11.4
+Y48B6A.3	W06E11.4
+Y48C3A.7	W06E11.4
+Y53C12B.1	W06E11.4
+Y54E10BR.4	W06E11.4
+Y56A3A.33	W06E11.4
+Y61A9LA.10	W06E11.4
+Y62E10A.2	W06E11.4
+Y66A7A.2	W06E11.4
+Y66H1A.4	W06E11.4
+Y71F9AM.5	W06E11.4
+Y75B8A.7	W06E11.4
+ZC434.4	W06E11.4
+ZK1127.5	W06E11.4
+ZK430.1	W06E11.4
+ZK632.14	W06E11.4
+ZK742.1	W06E11.4
+ZK795.3	W06E11.4
+Y23H5B.5	Y105E8B.3
+Y39A1A.14	Y105E8B.3
+Y39G8C.1	Y105E8B.3
+Y45F10D.7	Y105E8B.3
+Y48A6B.3	Y105E8B.3
+Y48B6A.3	Y105E8B.3
+Y48C3A.7	Y105E8B.3
+Y51H7C.11	Y105E8B.3
+Y53C12B.1	Y105E8B.3
+Y54E10BR.4	Y105E8B.3
+Y56A3A.33	Y105E8B.3
+Y61A9LA.10	Y105E8B.3
+Y62E10A.2	Y105E8B.3
+Y66A7A.2	Y105E8B.3
+Y66H1A.4	Y105E8B.3
+Y71F9AM.5	Y105E8B.3
+Y75B8A.7	Y105E8B.3
+ZC434.4	Y105E8B.3
+ZK1127.5	Y105E8B.3
+ZK430.1	Y105E8B.3
+ZK632.14	Y105E8B.3
+ZK742.1	Y105E8B.3
+ZK795.3	Y105E8B.3
+Y39A1A.14	Y23H5B.5
+Y39G8C.1	Y23H5B.5
+Y45F10D.7	Y23H5B.5
+Y48A6B.3	Y23H5B.5
+Y48B6A.3	Y23H5B.5
+Y48C3A.7	Y23H5B.5
+Y51H7C.11	Y23H5B.5
+Y53C12B.1	Y23H5B.5
+Y54E10BR.4	Y23H5B.5
+Y56A3A.33	Y23H5B.5
+Y61A9LA.10	Y23H5B.5
+Y62E10A.2	Y23H5B.5
+Y66A7A.2	Y23H5B.5
+Y66H1A.4	Y23H5B.5
+Y71F9AM.5	Y23H5B.5
+Y75B8A.7	Y23H5B.5
+ZC434.4	Y23H5B.5
+ZK1127.5	Y23H5B.5
+ZK430.1	Y23H5B.5
+ZK632.14	Y23H5B.5
+ZK742.1	Y23H5B.5
+ZK795.3	Y23H5B.5
+Y39G8C.1	Y39A1A.14
+Y45F10D.7	Y39A1A.14
+Y48A6B.3	Y39A1A.14
+Y48B6A.3	Y39A1A.14
+Y48C3A.7	Y39A1A.14
+Y51H7C.11	Y39A1A.14
+Y53C12B.1	Y39A1A.14
+Y54E10BR.4	Y39A1A.14
+Y56A3A.33	Y39A1A.14
+Y61A9LA.10	Y39A1A.14
+Y62E10A.2	Y39A1A.14
+Y66A7A.2	Y39A1A.14
+Y66H1A.4	Y39A1A.14
+Y71F9AM.5	Y39A1A.14
+Y75B8A.7	Y39A1A.14
+ZC434.4	Y39A1A.14
+ZK1127.5	Y39A1A.14
+ZK430.1	Y39A1A.14
+ZK632.14	Y39A1A.14
+ZK742.1	Y39A1A.14
+ZK795.3	Y39A1A.14
+Y45F10D.7	Y39G8C.1
+Y48A6B.3	Y39G8C.1
+Y48B6A.3	Y39G8C.1
+Y48C3A.7	Y39G8C.1
+Y51H7C.11	Y39G8C.1
+Y53C12B.1	Y39G8C.1
+Y54E10BR.4	Y39G8C.1
+Y56A3A.33	Y39G8C.1
+Y61A9LA.10	Y39G8C.1
+Y62E10A.2	Y39G8C.1
+Y66A7A.2	Y39G8C.1
+Y66H1A.4	Y39G8C.1
+Y71F9AM.5	Y39G8C.1
+Y75B8A.7	Y39G8C.1
+ZC434.4	Y39G8C.1
+ZK1127.5	Y39G8C.1
+ZK430.1	Y39G8C.1
+ZK632.14	Y39G8C.1
+ZK742.1	Y39G8C.1
+ZK795.3	Y39G8C.1
+Y48A6B.3	Y45F10D.7
+Y48B6A.3	Y45F10D.7
+Y48C3A.7	Y45F10D.7
+Y51H7C.11	Y45F10D.7
+Y53C12B.1	Y45F10D.7
+Y54E10BR.4	Y45F10D.7
+Y56A3A.33	Y45F10D.7
+Y61A9LA.10	Y45F10D.7
+Y62E10A.2	Y45F10D.7
+Y66A7A.2	Y45F10D.7
+Y66H1A.4	Y45F10D.7
+Y71F9AM.5	Y45F10D.7
+Y75B8A.7	Y45F10D.7
+ZC434.4	Y45F10D.7
+ZK1127.5	Y45F10D.7
+ZK430.1	Y45F10D.7
+ZK632.14	Y45F10D.7
+ZK742.1	Y45F10D.7
+ZK795.3	Y45F10D.7
+Y48B6A.3	Y48A6B.3
+Y48C3A.7	Y48A6B.3
+Y51H7C.11	Y48A6B.3
+Y53C12B.1	Y48A6B.3
+Y54E10BR.4	Y48A6B.3
+Y56A3A.33	Y48A6B.3
+Y61A9LA.10	Y48A6B.3
+Y62E10A.2	Y48A6B.3
+Y66A7A.2	Y48A6B.3
+Y66H1A.4	Y48A6B.3
+Y71F9AM.5	Y48A6B.3
+Y75B8A.7	Y48A6B.3
+ZC434.4	Y48A6B.3
+ZK1127.5	Y48A6B.3
+ZK430.1	Y48A6B.3
+ZK632.14	Y48A6B.3
+ZK742.1	Y48A6B.3
+ZK795.3	Y48A6B.3
+Y48C3A.7	Y48B6A.3
+Y51H7C.11	Y48B6A.3
+Y53C12B.1	Y48B6A.3
+Y54E10BR.4	Y48B6A.3
+Y56A3A.33	Y48B6A.3
+Y61A9LA.10	Y48B6A.3
+Y62E10A.2	Y48B6A.3
+Y66A7A.2	Y48B6A.3
+Y66H1A.4	Y48B6A.3
+Y71F9AM.5	Y48B6A.3
+Y75B8A.7	Y48B6A.3
+ZC434.4	Y48B6A.3
+ZK1127.5	Y48B6A.3
+ZK430.1	Y48B6A.3
+ZK632.14	Y48B6A.3
+ZK742.1	Y48B6A.3
+ZK795.3	Y48B6A.3
+Y51H7C.11	Y48C3A.7
+Y53C12B.1	Y48C3A.7
+Y54E10BR.4	Y48C3A.7
+Y56A3A.33	Y48C3A.7
+Y61A9LA.10	Y48C3A.7
+Y62E10A.2	Y48C3A.7
+Y66A7A.2	Y48C3A.7
+Y66H1A.4	Y48C3A.7
+Y71F9AM.5	Y48C3A.7
+Y75B8A.7	Y48C3A.7
+ZC434.4	Y48C3A.7
+ZK1127.5	Y48C3A.7
+ZK430.1	Y48C3A.7
+ZK632.14	Y48C3A.7
+ZK742.1	Y48C3A.7
+ZK795.3	Y48C3A.7
+Y53C12B.1	Y51H7C.11
+Y54E10BR.4	Y51H7C.11
+Y56A3A.33	Y51H7C.11
+Y61A9LA.10	Y51H7C.11
+Y62E10A.2	Y51H7C.11
+Y66A7A.2	Y51H7C.11
+Y66H1A.4	Y51H7C.11
+Y71F9AM.5	Y51H7C.11
+Y75B8A.7	Y51H7C.11
+ZC434.4	Y51H7C.11
+ZK1127.5	Y51H7C.11
+ZK430.1	Y51H7C.11
+ZK632.14	Y51H7C.11
+ZK742.1	Y51H7C.11
+ZK795.3	Y51H7C.11
+Y54E10BR.4	Y53C12B.1
+Y56A3A.33	Y53C12B.1
+Y61A9LA.10	Y53C12B.1
+Y62E10A.2	Y53C12B.1
+Y66A7A.2	Y53C12B.1
+Y66H1A.4	Y53C12B.1
+Y71F9AM.5	Y53C12B.1
+Y75B8A.7	Y53C12B.1
+ZC434.4	Y53C12B.1
+ZK1127.5	Y53C12B.1
+ZK430.1	Y53C12B.1
+ZK632.14	Y53C12B.1
+ZK742.1	Y53C12B.1
+ZK795.3	Y53C12B.1
+Y56A3A.33	Y54E10BR.4
+Y61A9LA.10	Y54E10BR.4
+Y62E10A.2	Y54E10BR.4
+Y66A7A.2	Y54E10BR.4
+Y66H1A.4	Y54E10BR.4
+Y71F9AM.5	Y54E10BR.4
+Y75B8A.7	Y54E10BR.4
+ZC434.4	Y54E10BR.4
+ZK1127.5	Y54E10BR.4
+ZK430.1	Y54E10BR.4
+ZK632.14	Y54E10BR.4
+ZK742.1	Y54E10BR.4
+ZK795.3	Y54E10BR.4
+Y61A9LA.10	Y56A3A.33
+Y62E10A.2	Y56A3A.33
+Y66A7A.2	Y56A3A.33
+Y66H1A.4	Y56A3A.33
+Y71F9AM.5	Y56A3A.33
+Y75B8A.7	Y56A3A.33
+ZC434.4	Y56A3A.33
+ZK1127.5	Y56A3A.33
+ZK430.1	Y56A3A.33
+ZK632.14	Y56A3A.33
+ZK742.1	Y56A3A.33
+ZK795.3	Y56A3A.33
+Y62E10A.2	Y61A9LA.10
+Y66A7A.2	Y61A9LA.10
+Y66H1A.4	Y61A9LA.10
+Y71F9AM.5	Y61A9LA.10
+Y75B8A.7	Y61A9LA.10
+ZC434.4	Y61A9LA.10
+ZK1127.5	Y61A9LA.10
+ZK430.1	Y61A9LA.10
+ZK632.14	Y61A9LA.10
+ZK742.1	Y61A9LA.10
+ZK795.3	Y61A9LA.10
+Y66A7A.2	Y62E10A.2
+Y66H1A.4	Y62E10A.2
+Y71F9AM.5	Y62E10A.2
+Y75B8A.7	Y62E10A.2
+ZC434.4	Y62E10A.2
+ZK1127.5	Y62E10A.2
+ZK430.1	Y62E10A.2
+ZK632.14	Y62E10A.2
+ZK742.1	Y62E10A.2
+ZK795.3	Y62E10A.2
+Y66H1A.4	Y66A7A.2
+Y71F9AM.5	Y66A7A.2
+Y75B8A.7	Y66A7A.2
+ZC434.4	Y66A7A.2
+ZK1127.5	Y66A7A.2
+ZK430.1	Y66A7A.2
+ZK632.14	Y66A7A.2
+ZK742.1	Y66A7A.2
+ZK795.3	Y66A7A.2
+Y71F9AM.5	Y66H1A.4
+Y75B8A.7	Y66H1A.4
+ZC434.4	Y66H1A.4
+ZK1127.5	Y66H1A.4
+ZK430.1	Y66H1A.4
+ZK632.14	Y66H1A.4
+ZK742.1	Y66H1A.4
+ZK795.3	Y66H1A.4
+Y75B8A.7	Y71F9AM.5
+ZC434.4	Y71F9AM.5
+ZK1127.5	Y71F9AM.5
+ZK430.1	Y71F9AM.5
+ZK632.14	Y71F9AM.5
+ZK742.1	Y71F9AM.5
+ZK795.3	Y71F9AM.5
+ZC434.4	Y75B8A.7
+ZK1127.5	Y75B8A.7
+ZK430.1	Y75B8A.7
+ZK632.14	Y75B8A.7
+ZK742.1	Y75B8A.7
+ZK795.3	Y75B8A.7
+ZK1127.5	ZC434.4
+ZK430.1	ZC434.4
+ZK632.14	ZC434.4
+ZK742.1	ZC434.4
+ZK795.3	ZC434.4
+ZK430.1	ZK1127.5
+ZK632.14	ZK1127.5
+ZK742.1	ZK1127.5
+ZK795.3	ZK1127.5
+ZK632.14	ZK430.1
+ZK742.1	ZK430.1
+ZK795.3	ZK430.1
+ZK742.1	ZK632.14
+ZK795.3	ZK632.14
+ZK795.3	ZK742.1
+B0250.1	B0041.4
+B0336.10	B0041.4
+B0393.1	B0041.4
+B0412.4	B0041.4
+B0513.3	B0041.4
+C03D6.8	B0041.4
+C04F12.4	B0041.4
+C06B8.8	B0041.4
+C09D4.5	B0041.4
+C09H10.2	B0041.4
+C14B9.7	B0041.4
+C16A3.9	B0041.4
+C23G10.3	B0041.4
+C26F1.4	B0041.4
+C26F1.9	B0041.4
+C27A2.2	B0041.4
+C32E8.2	B0041.4
+C37A2.7	B0041.4
+C42C1.14	B0041.4
+C49H3.11	B0041.4
+C53H9.1	B0041.4
+C54C6.1	B0041.4
+D1007.12	B0041.4
+D1007.6	B0041.4
+E04A4.8	B0041.4
+F07D10.1	B0041.4
+F10B5.1	B0041.4
+F10E7.7	B0041.4
+F13B10.2	B0041.4
+F13G3.11	B0041.4
+F25H2.10	B0041.4
+F28C6.7	B0041.4
+F28D1.7	B0041.4
+F34H10.1	B0041.4
+F36A2.6	B0041.4
+F37C12.11	B0041.4
+F37C12.4	B0041.4
+F37C12.9	B0041.4
+F39B2.6	B0041.4
+F40F11.1	B0041.4
+F40F8.10	B0041.4
+F42C5.8	B0041.4
+F52B5.6	B0041.4
+F53A3.3	B0041.4
+F53G12.10	B0041.4
+F54C9.5	B0041.4
+F54E7.2	B0041.4
+F55D10.2	B0041.4
+F56E10.4	B0041.4
+F56F3.5	B0041.4
+H06I04.4	B0041.4
+K02B2.5	B0041.4
+K08C9.7	B0041.4
+K11H12.2	B0041.4
+M01F1.2	B0041.4
+R11D1.8	B0041.4
+R13A5.8	B0041.4
+R151.3	B0041.4
+T01C3.6	B0041.4
+T05E11.1	B0041.4
+T05F1.3	B0041.4
+T07A9.11	B0041.4
+T08B2.10	B0041.4
+T22F3.4	B0041.4
+T24B8.1	B0041.4
+W01D2.1	B0041.4
+W09C5.6	B0041.4
+Y105E8A.16	B0041.4
+Y106G6H.3	B0041.4
+Y24D9A.4	B0041.4
+Y37E3.7	B0041.4
+Y37E3.8	B0041.4
+Y41D4B.5	B0041.4
+Y43B11AR.4	B0041.4
+Y45F10D.12	B0041.4
+Y48B6A.2	B0041.4
+Y48G8AL.8	B0041.4
+Y57G11C.16	B0041.4
+Y62E10A.1	B0041.4
+Y71A12B.1	B0041.4
+Y71F9AL.13	B0041.4
+Y73B3A.18	B0041.4
+ZC434.2	B0041.4
+ZK1010.1	B0041.4
+ZK652.4	B0041.4
+B0336.10	B0250.1
+B0393.1	B0250.1
+B0412.4	B0250.1
+B0513.3	B0250.1
+C03D6.8	B0250.1
+C04F12.4	B0250.1
+C06B8.8	B0250.1
+C09D4.5	B0250.1
+C09H10.2	B0250.1
+C14B9.7	B0250.1
+C16A3.9	B0250.1
+C23G10.3	B0250.1
+C26F1.4	B0250.1
+C26F1.9	B0250.1
+C27A2.2	B0250.1
+C32E8.2	B0250.1
+C37A2.7	B0250.1
+C42C1.14	B0250.1
+C49H3.11	B0250.1
+C53H9.1	B0250.1
+C54C6.1	B0250.1
+D1007.12	B0250.1
+D1007.6	B0250.1
+E04A4.8	B0250.1
+F07D10.1	B0250.1
+F10B5.1	B0250.1
+F10E7.7	B0250.1
+F13B10.2	B0250.1
+F13G3.11	B0250.1
+F25H2.10	B0250.1
+F28C6.7	B0250.1
+F28D1.7	B0250.1
+F34H10.1	B0250.1
+F36A2.6	B0250.1
+F37C12.11	B0250.1
+F37C12.4	B0250.1
+F37C12.9	B0250.1
+F39B2.6	B0250.1
+F40F11.1	B0250.1
+F40F8.10	B0250.1
+F42C5.8	B0250.1
+F52B5.6	B0250.1
+F53A3.3	B0250.1
+F53G12.10	B0250.1
+F54C9.5	B0250.1
+F54E7.2	B0250.1
+F55D10.2	B0250.1
+F56E10.4	B0250.1
+F56F3.5	B0250.1
+H06I04.4	B0250.1
+K02B2.5	B0250.1
+K08C9.7	B0250.1
+K11H12.2	B0250.1
+M01F1.2	B0250.1
+R11D1.8	B0250.1
+R13A5.8	B0250.1
+R151.3	B0250.1
+T01C3.6	B0250.1
+T05E11.1	B0250.1
+T05F1.3	B0250.1
+T07A9.11	B0250.1
+T08B2.10	B0250.1
+T22F3.4	B0250.1
+T24B8.1	B0250.1
+W01D2.1	B0250.1
+W09C5.6	B0250.1
+Y105E8A.16	B0250.1
+Y106G6H.3	B0250.1
+Y24D9A.4	B0250.1
+Y37E3.7	B0250.1
+Y37E3.8	B0250.1
+Y41D4B.5	B0250.1
+Y43B11AR.4	B0250.1
+Y45F10D.12	B0250.1
+Y48B6A.2	B0250.1
+Y48G8AL.8	B0250.1
+Y57G11C.16	B0250.1
+Y62E10A.1	B0250.1
+Y71A12B.1	B0250.1
+Y71F9AL.13	B0250.1
+Y73B3A.18	B0250.1
+ZC434.2	B0250.1
+ZK1010.1	B0250.1
+ZK652.4	B0250.1
+B0393.1	B0336.10
+B0412.4	B0336.10
+B0513.3	B0336.10
+C03D6.8	B0336.10
+C04F12.4	B0336.10
+C06B8.8	B0336.10
+C09D4.5	B0336.10
+C09H10.2	B0336.10
+C14B9.7	B0336.10
+C16A3.9	B0336.10
+C23G10.3	B0336.10
+C26F1.4	B0336.10
+C26F1.9	B0336.10
+C27A2.2	B0336.10
+C32E8.2	B0336.10
+C37A2.7	B0336.10
+C42C1.14	B0336.10
+C49H3.11	B0336.10
+C53H9.1	B0336.10
+C54C6.1	B0336.10
+D1007.12	B0336.10
+D1007.6	B0336.10
+E04A4.8	B0336.10
+F07D10.1	B0336.10
+F10B5.1	B0336.10
+F10E7.7	B0336.10
+F13B10.2	B0336.10
+F13G3.11	B0336.10
+F25H2.10	B0336.10
+F28C6.7	B0336.10
+F28D1.7	B0336.10
+F34H10.1	B0336.10
+F36A2.6	B0336.10
+F37C12.11	B0336.10
+F37C12.4	B0336.10
+F37C12.9	B0336.10
+F39B2.6	B0336.10
+F40F11.1	B0336.10
+F40F8.10	B0336.10
+F42C5.8	B0336.10
+F52B5.6	B0336.10
+F53A3.3	B0336.10
+F53G12.10	B0336.10
+F54C9.5	B0336.10
+F54E7.2	B0336.10
+F55D10.2	B0336.10
+F56E10.4	B0336.10
+F56F3.5	B0336.10
+H06I04.4	B0336.10
+K02B2.5	B0336.10
+K08C9.7	B0336.10
+K11H12.2	B0336.10
+M01F1.2	B0336.10
+R11D1.8	B0336.10
+R13A5.8	B0336.10
+R151.3	B0336.10
+T01C3.6	B0336.10
+T05E11.1	B0336.10
+T05F1.3	B0336.10
+T07A9.11	B0336.10
+T08B2.10	B0336.10
+T22F3.4	B0336.10
+T24B8.1	B0336.10
+W01D2.1	B0336.10
+W09C5.6	B0336.10
+Y105E8A.16	B0336.10
+Y106G6H.3	B0336.10
+Y24D9A.4	B0336.10
+Y37E3.7	B0336.10
+Y37E3.8	B0336.10
+Y41D4B.5	B0336.10
+Y43B11AR.4	B0336.10
+Y45F10D.12	B0336.10
+Y48B6A.2	B0336.10
+Y48G8AL.8	B0336.10
+Y57G11C.16	B0336.10
+Y62E10A.1	B0336.10
+Y71A12B.1	B0336.10
+Y71F9AL.13	B0336.10
+Y73B3A.18	B0336.10
+ZC434.2	B0336.10
+ZK1010.1	B0336.10
+ZK652.4	B0336.10
+B0412.4	B0393.1
+B0513.3	B0393.1
+C03D6.8	B0393.1
+C04F12.4	B0393.1
+C06B8.8	B0393.1
+C09D4.5	B0393.1
+C09H10.2	B0393.1
+C14B9.7	B0393.1
+C16A3.9	B0393.1
+C23G10.3	B0393.1
+C26F1.4	B0393.1
+C26F1.9	B0393.1
+C27A2.2	B0393.1
+C32E8.2	B0393.1
+C37A2.7	B0393.1
+C42C1.14	B0393.1
+C49H3.11	B0393.1
+C53H9.1	B0393.1
+C54C6.1	B0393.1
+D1007.12	B0393.1
+D1007.6	B0393.1
+E04A4.8	B0393.1
+F07D10.1	B0393.1
+F10B5.1	B0393.1
+F10E7.7	B0393.1
+F13B10.2	B0393.1
+F13G3.11	B0393.1
+F25H2.10	B0393.1
+F28C6.7	B0393.1
+F28D1.7	B0393.1
+F34H10.1	B0393.1
+F36A2.6	B0393.1
+F37C12.4	B0393.1
+F37C12.9	B0393.1
+F39B2.6	B0393.1
+F40F11.1	B0393.1
+F40F8.10	B0393.1
+F42C5.8	B0393.1
+F52B5.6	B0393.1
+F53A3.3	B0393.1
+F53G12.10	B0393.1
+F54C9.5	B0393.1
+F54E7.2	B0393.1
+F55D10.2	B0393.1
+F56E10.4	B0393.1
+F56F3.5	B0393.1
+H06I04.4	B0393.1
+K02B2.5	B0393.1
+K08C9.7	B0393.1
+K11H12.2	B0393.1
+M01F1.2	B0393.1
+R11D1.8	B0393.1
+R13A5.8	B0393.1
+R151.3	B0393.1
+T01C3.6	B0393.1
+T05E11.1	B0393.1
+T05F1.3	B0393.1
+T07A9.11	B0393.1
+T22F3.4	B0393.1
+T24B8.1	B0393.1
+W01D2.1	B0393.1
+W09C5.6	B0393.1
+Y106G6H.3	B0393.1
+Y24D9A.4	B0393.1
+Y37E3.7	B0393.1
+Y37E3.8	B0393.1
+Y43B11AR.4	B0393.1
+Y45F10D.12	B0393.1
+Y48B6A.2	B0393.1
+Y48G8AL.8	B0393.1
+Y57G11C.16	B0393.1
+Y62E10A.1	B0393.1
+Y71A12B.1	B0393.1
+Y71F9AL.13	B0393.1
+Y73B3A.18	B0393.1
+ZC434.2	B0393.1
+ZK1010.1	B0393.1
+ZK652.4	B0393.1
+B0513.3	B0412.4
+C03D6.8	B0412.4
+C04F12.4	B0412.4
+C06B8.8	B0412.4
+C09D4.5	B0412.4
+C09H10.2	B0412.4
+C14B9.7	B0412.4
+C16A3.9	B0412.4
+C23G10.3	B0412.4
+C26F1.4	B0412.4
+C26F1.9	B0412.4
+C27A2.2	B0412.4
+C32E8.2	B0412.4
+C37A2.7	B0412.4
+C42C1.14	B0412.4
+C49H3.11	B0412.4
+C53H9.1	B0412.4
+C54C6.1	B0412.4
+D1007.12	B0412.4
+D1007.6	B0412.4
+E04A4.8	B0412.4
+F07D10.1	B0412.4
+F10B5.1	B0412.4
+F10E7.7	B0412.4
+F13B10.2	B0412.4
+F13G3.11	B0412.4
+F25H2.10	B0412.4
+F28C6.7	B0412.4
+F28D1.7	B0412.4
+F34H10.1	B0412.4
+F36A2.6	B0412.4
+F37C12.11	B0412.4
+F37C12.4	B0412.4
+F37C12.9	B0412.4
+F39B2.6	B0412.4
+F40F11.1	B0412.4
+F40F8.10	B0412.4
+F42C5.8	B0412.4
+F52B5.6	B0412.4
+F53A3.3	B0412.4
+F53G12.10	B0412.4
+F54C9.5	B0412.4
+F54E7.2	B0412.4
+F55D10.2	B0412.4
+F56E10.4	B0412.4
+F56F3.5	B0412.4
+H06I04.4	B0412.4
+K02B2.5	B0412.4
+K08C9.7	B0412.4
+K11H12.2	B0412.4
+M01F1.2	B0412.4
+R11D1.8	B0412.4
+R13A5.8	B0412.4
+R151.3	B0412.4
+T01C3.6	B0412.4
+T05E11.1	B0412.4
+T05F1.3	B0412.4
+T07A9.11	B0412.4
+T08B2.10	B0412.4
+T22F3.4	B0412.4
+T24B8.1	B0412.4
+W01D2.1	B0412.4
+W09C5.6	B0412.4
+Y105E8A.16	B0412.4
+Y106G6H.3	B0412.4
+Y24D9A.4	B0412.4
+Y37E3.7	B0412.4
+Y37E3.8	B0412.4
+Y41D4B.5	B0412.4
+Y43B11AR.4	B0412.4
+Y45F10D.12	B0412.4
+Y48B6A.2	B0412.4
+Y48G8AL.8	B0412.4
+Y57G11C.16	B0412.4
+Y62E10A.1	B0412.4
+Y71A12B.1	B0412.4
+Y71F9AL.13	B0412.4
+Y73B3A.18	B0412.4
+ZC434.2	B0412.4
+ZK1010.1	B0412.4
+ZK652.4	B0412.4
+C03D6.8	B0513.3
+C04F12.4	B0513.3
+C06B8.8	B0513.3
+C09D4.5	B0513.3
+C09H10.2	B0513.3
+C14B9.7	B0513.3
+C16A3.9	B0513.3
+C23G10.3	B0513.3
+C26F1.4	B0513.3
+C26F1.9	B0513.3
+C27A2.2	B0513.3
+C32E8.2	B0513.3
+C37A2.7	B0513.3
+C42C1.14	B0513.3
+C49H3.11	B0513.3
+C53H9.1	B0513.3
+C54C6.1	B0513.3
+D1007.12	B0513.3
+D1007.6	B0513.3
+E04A4.8	B0513.3
+F07D10.1	B0513.3
+F10B5.1	B0513.3
+F10E7.7	B0513.3
+F13B10.2	B0513.3
+F13G3.11	B0513.3
+F25H2.10	B0513.3
+F28C6.7	B0513.3
+F28D1.7	B0513.3
+F34H10.1	B0513.3
+F36A2.6	B0513.3
+F37C12.11	B0513.3
+F37C12.4	B0513.3
+F37C12.9	B0513.3
+F39B2.6	B0513.3
+F40F11.1	B0513.3
+F40F8.10	B0513.3
+F42C5.8	B0513.3
+F52B5.6	B0513.3
+F53A3.3	B0513.3
+F53G12.10	B0513.3
+F54C9.5	B0513.3
+F54E7.2	B0513.3
+F55D10.2	B0513.3
+F56E10.4	B0513.3
+F56F3.5	B0513.3
+H06I04.4	B0513.3
+K02B2.5	B0513.3
+K08C9.7	B0513.3
+K11H12.2	B0513.3
+M01F1.2	B0513.3
+R11D1.8	B0513.3
+R13A5.8	B0513.3
+R151.3	B0513.3
+T01C3.6	B0513.3
+T05E11.1	B0513.3
+T05F1.3	B0513.3
+T07A9.11	B0513.3
+T08B2.10	B0513.3
+T22F3.4	B0513.3
+T24B8.1	B0513.3
+W01D2.1	B0513.3
+W09C5.6	B0513.3
+Y105E8A.16	B0513.3
+Y106G6H.3	B0513.3
+Y24D9A.4	B0513.3
+Y37E3.7	B0513.3
+Y37E3.8	B0513.3
+Y41D4B.5	B0513.3
+Y43B11AR.4	B0513.3
+Y45F10D.12	B0513.3
+Y48B6A.2	B0513.3
+Y48G8AL.8	B0513.3
+Y57G11C.16	B0513.3
+Y62E10A.1	B0513.3
+Y71A12B.1	B0513.3
+Y71F9AL.13	B0513.3
+Y73B3A.18	B0513.3
+ZC434.2	B0513.3
+ZK1010.1	B0513.3
+ZK652.4	B0513.3
+C04F12.4	C03D6.8
+C06B8.8	C03D6.8
+C09D4.5	C03D6.8
+C09H10.2	C03D6.8
+C14B9.7	C03D6.8
+C16A3.9	C03D6.8
+C23G10.3	C03D6.8
+C26F1.4	C03D6.8
+C26F1.9	C03D6.8
+C27A2.2	C03D6.8
+C32E8.2	C03D6.8
+C37A2.7	C03D6.8
+C42C1.14	C03D6.8
+C49H3.11	C03D6.8
+C53H9.1	C03D6.8
+C54C6.1	C03D6.8
+D1007.12	C03D6.8
+D1007.6	C03D6.8
+E04A4.8	C03D6.8
+F07D10.1	C03D6.8
+F10B5.1	C03D6.8
+F10E7.7	C03D6.8
+F13B10.2	C03D6.8
+F13G3.11	C03D6.8
+F25H2.10	C03D6.8
+F28C6.7	C03D6.8
+F28D1.7	C03D6.8
+F34H10.1	C03D6.8
+F36A2.6	C03D6.8
+F37C12.11	C03D6.8
+F37C12.4	C03D6.8
+F37C12.9	C03D6.8
+F39B2.6	C03D6.8
+F40F11.1	C03D6.8
+F40F8.10	C03D6.8
+F42C5.8	C03D6.8
+F52B5.6	C03D6.8
+F53A3.3	C03D6.8
+F53G12.10	C03D6.8
+F54C9.5	C03D6.8
+F54E7.2	C03D6.8
+F55D10.2	C03D6.8
+F56E10.4	C03D6.8
+F56F3.5	C03D6.8
+H06I04.4	C03D6.8
+K02B2.5	C03D6.8
+K08C9.7	C03D6.8
+K11H12.2	C03D6.8
+M01F1.2	C03D6.8
+R11D1.8	C03D6.8
+R13A5.8	C03D6.8
+R151.3	C03D6.8
+T01C3.6	C03D6.8
+T05E11.1	C03D6.8
+T05F1.3	C03D6.8
+T07A9.11	C03D6.8
+T08B2.10	C03D6.8
+T22F3.4	C03D6.8
+T24B8.1	C03D6.8
+W01D2.1	C03D6.8
+W09C5.6	C03D6.8
+Y105E8A.16	C03D6.8
+Y106G6H.3	C03D6.8
+Y24D9A.4	C03D6.8
+Y37E3.7	C03D6.8
+Y37E3.8	C03D6.8
+Y41D4B.5	C03D6.8
+Y43B11AR.4	C03D6.8
+Y45F10D.12	C03D6.8
+Y48B6A.2	C03D6.8
+Y48G8AL.8	C03D6.8
+Y57G11C.16	C03D6.8
+Y62E10A.1	C03D6.8
+Y71A12B.1	C03D6.8
+Y71F9AL.13	C03D6.8
+Y73B3A.18	C03D6.8
+ZC434.2	C03D6.8
+ZK1010.1	C03D6.8
+ZK652.4	C03D6.8
+C06B8.8	C04F12.4
+C09D4.5	C04F12.4
+C09H10.2	C04F12.4
+C14B9.7	C04F12.4
+C16A3.9	C04F12.4
+C23G10.3	C04F12.4
+C26F1.4	C04F12.4
+C26F1.9	C04F12.4
+C27A2.2	C04F12.4
+C32E8.2	C04F12.4
+C37A2.7	C04F12.4
+C42C1.14	C04F12.4
+C49H3.11	C04F12.4
+C53H9.1	C04F12.4
+C54C6.1	C04F12.4
+D1007.12	C04F12.4
+D1007.6	C04F12.4
+E04A4.8	C04F12.4
+F07D10.1	C04F12.4
+F10B5.1	C04F12.4
+F10E7.7	C04F12.4
+F13B10.2	C04F12.4
+F13G3.11	C04F12.4
+F25H2.10	C04F12.4
+F28C6.7	C04F12.4
+F28D1.7	C04F12.4
+F34H10.1	C04F12.4
+F36A2.6	C04F12.4
+F37C12.11	C04F12.4
+F37C12.4	C04F12.4
+F37C12.9	C04F12.4
+F39B2.6	C04F12.4
+F40F11.1	C04F12.4
+F40F8.10	C04F12.4
+F42C5.8	C04F12.4
+F52B5.6	C04F12.4
+F53A3.3	C04F12.4
+F53G12.10	C04F12.4
+F54C9.5	C04F12.4
+F54E7.2	C04F12.4
+F55D10.2	C04F12.4
+F56E10.4	C04F12.4
+F56F3.5	C04F12.4
+H06I04.4	C04F12.4
+K02B2.5	C04F12.4
+K08C9.7	C04F12.4
+K11H12.2	C04F12.4
+M01F1.2	C04F12.4
+R11D1.8	C04F12.4
+R13A5.8	C04F12.4
+R151.3	C04F12.4
+T01C3.6	C04F12.4
+T05E11.1	C04F12.4
+T05F1.3	C04F12.4
+T07A9.11	C04F12.4
+T08B2.10	C04F12.4
+T22F3.4	C04F12.4
+T24B8.1	C04F12.4
+W01D2.1	C04F12.4
+W09C5.6	C04F12.4
+Y105E8A.16	C04F12.4
+Y106G6H.3	C04F12.4
+Y24D9A.4	C04F12.4
+Y37E3.7	C04F12.4
+Y37E3.8	C04F12.4
+Y41D4B.5	C04F12.4
+Y43B11AR.4	C04F12.4
+Y45F10D.12	C04F12.4
+Y48B6A.2	C04F12.4
+Y48G8AL.8	C04F12.4
+Y57G11C.16	C04F12.4
+Y62E10A.1	C04F12.4
+Y71A12B.1	C04F12.4
+Y71F9AL.13	C04F12.4
+Y73B3A.18	C04F12.4
+ZC434.2	C04F12.4
+ZK1010.1	C04F12.4
+ZK652.4	C04F12.4
+C09D4.5	C06B8.8
+C09H10.2	C06B8.8
+C14B9.7	C06B8.8
+C16A3.9	C06B8.8
+C23G10.3	C06B8.8
+C26F1.4	C06B8.8
+C26F1.9	C06B8.8
+C27A2.2	C06B8.8
+C32E8.2	C06B8.8
+C37A2.7	C06B8.8
+C42C1.14	C06B8.8
+C49H3.11	C06B8.8
+C53H9.1	C06B8.8
+C54C6.1	C06B8.8
+D1007.12	C06B8.8
+D1007.6	C06B8.8
+E04A4.8	C06B8.8
+F07D10.1	C06B8.8
+F10B5.1	C06B8.8
+F10E7.7	C06B8.8
+F13B10.2	C06B8.8
+F13G3.11	C06B8.8
+F25H2.10	C06B8.8
+F28C6.7	C06B8.8
+F28D1.7	C06B8.8
+F34H10.1	C06B8.8
+F36A2.6	C06B8.8
+F37C12.11	C06B8.8
+F37C12.4	C06B8.8
+F37C12.9	C06B8.8
+F39B2.6	C06B8.8
+F40F11.1	C06B8.8
+F40F8.10	C06B8.8
+F42C5.8	C06B8.8
+F52B5.6	C06B8.8
+F53A3.3	C06B8.8
+F53G12.10	C06B8.8
+F54C9.5	C06B8.8
+F54E7.2	C06B8.8
+F55D10.2	C06B8.8
+F56E10.4	C06B8.8
+F56F3.5	C06B8.8
+H06I04.4	C06B8.8
+K02B2.5	C06B8.8
+K08C9.7	C06B8.8
+K11H12.2	C06B8.8
+M01F1.2	C06B8.8
+R11D1.8	C06B8.8
+R13A5.8	C06B8.8
+R151.3	C06B8.8
+T01C3.6	C06B8.8
+T05E11.1	C06B8.8
+T05F1.3	C06B8.8
+T07A9.11	C06B8.8
+T08B2.10	C06B8.8
+T22F3.4	C06B8.8
+T24B8.1	C06B8.8
+W01D2.1	C06B8.8
+W09C5.6	C06B8.8
+Y105E8A.16	C06B8.8
+Y106G6H.3	C06B8.8
+Y24D9A.4	C06B8.8
+Y37E3.7	C06B8.8
+Y37E3.8	C06B8.8
+Y41D4B.5	C06B8.8
+Y43B11AR.4	C06B8.8
+Y45F10D.12	C06B8.8
+Y48B6A.2	C06B8.8
+Y48G8AL.8	C06B8.8
+Y57G11C.16	C06B8.8
+Y62E10A.1	C06B8.8
+Y71A12B.1	C06B8.8
+Y71F9AL.13	C06B8.8
+Y73B3A.18	C06B8.8
+ZC434.2	C06B8.8
+ZK1010.1	C06B8.8
+ZK652.4	C06B8.8
+C09H10.2	C09D4.5
+C14B9.7	C09D4.5
+C16A3.9	C09D4.5
+C23G10.3	C09D4.5
+C26F1.4	C09D4.5
+C26F1.9	C09D4.5
+C27A2.2	C09D4.5
+C32E8.2	C09D4.5
+C37A2.7	C09D4.5
+C42C1.14	C09D4.5
+C49H3.11	C09D4.5
+C53H9.1	C09D4.5
+C54C6.1	C09D4.5
+D1007.12	C09D4.5
+D1007.6	C09D4.5
+E04A4.8	C09D4.5
+F07D10.1	C09D4.5
+F10B5.1	C09D4.5
+F10E7.7	C09D4.5
+F13B10.2	C09D4.5
+F13G3.11	C09D4.5
+F25H2.10	C09D4.5
+F28C6.7	C09D4.5
+F28D1.7	C09D4.5
+F34H10.1	C09D4.5
+F36A2.6	C09D4.5
+F37C12.11	C09D4.5
+F37C12.4	C09D4.5
+F37C12.9	C09D4.5
+F39B2.6	C09D4.5
+F40F11.1	C09D4.5
+F40F8.10	C09D4.5
+F42C5.8	C09D4.5
+F52B5.6	C09D4.5
+F53A3.3	C09D4.5
+F53G12.10	C09D4.5
+F54C9.5	C09D4.5
+F54E7.2	C09D4.5
+F55D10.2	C09D4.5
+F56E10.4	C09D4.5
+F56F3.5	C09D4.5
+H06I04.4	C09D4.5
+K02B2.5	C09D4.5
+K08C9.7	C09D4.5
+K11H12.2	C09D4.5
+M01F1.2	C09D4.5
+R11D1.8	C09D4.5
+R13A5.8	C09D4.5
+R151.3	C09D4.5
+T01C3.6	C09D4.5
+T05E11.1	C09D4.5
+T05F1.3	C09D4.5
+T07A9.11	C09D4.5
+T08B2.10	C09D4.5
+T22F3.4	C09D4.5
+T24B8.1	C09D4.5
+W01D2.1	C09D4.5
+W09C5.6	C09D4.5
+Y105E8A.16	C09D4.5
+Y106G6H.3	C09D4.5
+Y24D9A.4	C09D4.5
+Y37E3.7	C09D4.5
+Y37E3.8	C09D4.5
+Y41D4B.5	C09D4.5
+Y43B11AR.4	C09D4.5
+Y45F10D.12	C09D4.5
+Y48B6A.2	C09D4.5
+Y48G8AL.8	C09D4.5
+Y57G11C.16	C09D4.5
+Y62E10A.1	C09D4.5
+Y71A12B.1	C09D4.5
+Y71F9AL.13	C09D4.5
+Y73B3A.18	C09D4.5
+ZC434.2	C09D4.5
+ZK1010.1	C09D4.5
+ZK652.4	C09D4.5
+C14B9.7	C09H10.2
+C16A3.9	C09H10.2
+C23G10.3	C09H10.2
+C26F1.4	C09H10.2
+C26F1.9	C09H10.2
+C27A2.2	C09H10.2
+C32E8.2	C09H10.2
+C37A2.7	C09H10.2
+C42C1.14	C09H10.2
+C49H3.11	C09H10.2
+C53H9.1	C09H10.2
+C54C6.1	C09H10.2
+D1007.12	C09H10.2
+D1007.6	C09H10.2
+E04A4.8	C09H10.2
+F07D10.1	C09H10.2
+F10B5.1	C09H10.2
+F10E7.7	C09H10.2
+F13B10.2	C09H10.2
+F13G3.11	C09H10.2
+F25H2.10	C09H10.2
+F28C6.7	C09H10.2
+F28D1.7	C09H10.2
+F34H10.1	C09H10.2
+F36A2.6	C09H10.2
+F37C12.11	C09H10.2
+F37C12.4	C09H10.2
+F37C12.9	C09H10.2
+F39B2.6	C09H10.2
+F40F11.1	C09H10.2
+F40F8.10	C09H10.2
+F42C5.8	C09H10.2
+F52B5.6	C09H10.2
+F53A3.3	C09H10.2
+F53G12.10	C09H10.2
+F54C9.5	C09H10.2
+F54E7.2	C09H10.2
+F55D10.2	C09H10.2
+F56E10.4	C09H10.2
+F56F3.5	C09H10.2
+H06I04.4	C09H10.2
+K02B2.5	C09H10.2
+K08C9.7	C09H10.2
+K11H12.2	C09H10.2
+M01F1.2	C09H10.2
+R11D1.8	C09H10.2
+R13A5.8	C09H10.2
+R151.3	C09H10.2
+T01C3.6	C09H10.2
+T05E11.1	C09H10.2
+T05F1.3	C09H10.2
+T07A9.11	C09H10.2
+T08B2.10	C09H10.2
+T22F3.4	C09H10.2
+T24B8.1	C09H10.2
+W01D2.1	C09H10.2
+W09C5.6	C09H10.2
+Y105E8A.16	C09H10.2
+Y106G6H.3	C09H10.2
+Y24D9A.4	C09H10.2
+Y37E3.7	C09H10.2
+Y37E3.8	C09H10.2
+Y41D4B.5	C09H10.2
+Y43B11AR.4	C09H10.2
+Y45F10D.12	C09H10.2
+Y48B6A.2	C09H10.2
+Y48G8AL.8	C09H10.2
+Y57G11C.16	C09H10.2
+Y62E10A.1	C09H10.2
+Y71A12B.1	C09H10.2
+Y71F9AL.13	C09H10.2
+Y73B3A.18	C09H10.2
+ZC434.2	C09H10.2
+ZK1010.1	C09H10.2
+ZK652.4	C09H10.2
+C16A3.9	C14B9.7
+C23G10.3	C14B9.7
+C26F1.4	C14B9.7
+C26F1.9	C14B9.7
+C27A2.2	C14B9.7
+C32E8.2	C14B9.7
+C37A2.7	C14B9.7
+C42C1.14	C14B9.7
+C49H3.11	C14B9.7
+C53H9.1	C14B9.7
+C54C6.1	C14B9.7
+D1007.12	C14B9.7
+D1007.6	C14B9.7
+E04A4.8	C14B9.7
+F07D10.1	C14B9.7
+F10B5.1	C14B9.7
+F10E7.7	C14B9.7
+F13B10.2	C14B9.7
+F13G3.11	C14B9.7
+F25H2.10	C14B9.7
+F28C6.7	C14B9.7
+F28D1.7	C14B9.7
+F34H10.1	C14B9.7
+F36A2.6	C14B9.7
+F37C12.11	C14B9.7
+F37C12.4	C14B9.7
+F37C12.9	C14B9.7
+F39B2.6	C14B9.7
+F40F11.1	C14B9.7
+F40F8.10	C14B9.7
+F42C5.8	C14B9.7
+F52B5.6	C14B9.7
+F53A3.3	C14B9.7
+F53G12.10	C14B9.7
+F54C9.5	C14B9.7
+F54E7.2	C14B9.7
+F55D10.2	C14B9.7
+F56E10.4	C14B9.7
+F56F3.5	C14B9.7
+H06I04.4	C14B9.7
+K02B2.5	C14B9.7
+K08C9.7	C14B9.7
+K11H12.2	C14B9.7
+M01F1.2	C14B9.7
+R11D1.8	C14B9.7
+R13A5.8	C14B9.7
+R151.3	C14B9.7
+T01C3.6	C14B9.7
+T05E11.1	C14B9.7
+T05F1.3	C14B9.7
+T07A9.11	C14B9.7
+T08B2.10	C14B9.7
+T22F3.4	C14B9.7
+T24B8.1	C14B9.7
+W01D2.1	C14B9.7
+W09C5.6	C14B9.7
+Y105E8A.16	C14B9.7
+Y106G6H.3	C14B9.7
+Y24D9A.4	C14B9.7
+Y37E3.7	C14B9.7
+Y37E3.8	C14B9.7
+Y41D4B.5	C14B9.7
+Y43B11AR.4	C14B9.7
+Y45F10D.12	C14B9.7
+Y48B6A.2	C14B9.7
+Y48G8AL.8	C14B9.7
+Y57G11C.16	C14B9.7
+Y62E10A.1	C14B9.7
+Y71A12B.1	C14B9.7
+Y71F9AL.13	C14B9.7
+Y73B3A.18	C14B9.7
+ZC434.2	C14B9.7
+ZK1010.1	C14B9.7
+ZK652.4	C14B9.7
+C23G10.3	C16A3.9
+C26F1.4	C16A3.9
+C26F1.9	C16A3.9
+C27A2.2	C16A3.9
+C32E8.2	C16A3.9
+C37A2.7	C16A3.9
+C42C1.14	C16A3.9
+C49H3.11	C16A3.9
+C53H9.1	C16A3.9
+C54C6.1	C16A3.9
+D1007.12	C16A3.9
+D1007.6	C16A3.9
+E04A4.8	C16A3.9
+F07D10.1	C16A3.9
+F10B5.1	C16A3.9
+F10E7.7	C16A3.9
+F13B10.2	C16A3.9
+F13G3.11	C16A3.9
+F25H2.10	C16A3.9
+F28C6.7	C16A3.9
+F28D1.7	C16A3.9
+F34H10.1	C16A3.9
+F36A2.6	C16A3.9
+F37C12.11	C16A3.9
+F37C12.4	C16A3.9
+F37C12.9	C16A3.9
+F39B2.6	C16A3.9
+F40F11.1	C16A3.9
+F40F8.10	C16A3.9
+F42C5.8	C16A3.9
+F52B5.6	C16A3.9
+F53A3.3	C16A3.9
+F53G12.10	C16A3.9
+F54C9.5	C16A3.9
+F54E7.2	C16A3.9
+F55D10.2	C16A3.9
+F56E10.4	C16A3.9
+F56F3.5	C16A3.9
+H06I04.4	C16A3.9
+K02B2.5	C16A3.9
+K08C9.7	C16A3.9
+K11H12.2	C16A3.9
+M01F1.2	C16A3.9
+R11D1.8	C16A3.9
+R13A5.8	C16A3.9
+R151.3	C16A3.9
+T01C3.6	C16A3.9
+T05E11.1	C16A3.9
+T05F1.3	C16A3.9
+T07A9.11	C16A3.9
+T08B2.10	C16A3.9
+T22F3.4	C16A3.9
+T24B8.1	C16A3.9
+W01D2.1	C16A3.9
+W09C5.6	C16A3.9
+Y105E8A.16	C16A3.9
+Y106G6H.3	C16A3.9
+Y24D9A.4	C16A3.9
+Y37E3.7	C16A3.9
+Y37E3.8	C16A3.9
+Y41D4B.5	C16A3.9
+Y43B11AR.4	C16A3.9
+Y45F10D.12	C16A3.9
+Y48B6A.2	C16A3.9
+Y48G8AL.8	C16A3.9
+Y57G11C.16	C16A3.9
+Y62E10A.1	C16A3.9
+Y71A12B.1	C16A3.9
+Y71F9AL.13	C16A3.9
+Y73B3A.18	C16A3.9
+ZC434.2	C16A3.9
+ZK1010.1	C16A3.9
+ZK652.4	C16A3.9
+C26F1.4	C23G10.3
+C26F1.9	C23G10.3
+C27A2.2	C23G10.3
+C32E8.2	C23G10.3
+C37A2.7	C23G10.3
+C42C1.14	C23G10.3
+C49H3.11	C23G10.3
+C53H9.1	C23G10.3
+C54C6.1	C23G10.3
+D1007.12	C23G10.3
+D1007.6	C23G10.3
+E04A4.8	C23G10.3
+F07D10.1	C23G10.3
+F10B5.1	C23G10.3
+F10E7.7	C23G10.3
+F13B10.2	C23G10.3
+F13G3.11	C23G10.3
+F25H2.10	C23G10.3
+F28C6.7	C23G10.3
+F28D1.7	C23G10.3
+F34H10.1	C23G10.3
+F36A2.6	C23G10.3
+F37C12.11	C23G10.3
+F37C12.4	C23G10.3
+F37C12.9	C23G10.3
+F39B2.6	C23G10.3
+F40F11.1	C23G10.3
+F40F8.10	C23G10.3
+F42C5.8	C23G10.3
+F52B5.6	C23G10.3
+F53A3.3	C23G10.3
+F53G12.10	C23G10.3
+F54C9.5	C23G10.3
+F54E7.2	C23G10.3
+F55D10.2	C23G10.3
+F56E10.4	C23G10.3
+F56F3.5	C23G10.3
+H06I04.4	C23G10.3
+K02B2.5	C23G10.3
+K08C9.7	C23G10.3
+K11H12.2	C23G10.3
+M01F1.2	C23G10.3
+R11D1.8	C23G10.3
+R13A5.8	C23G10.3
+R151.3	C23G10.3
+T01C3.6	C23G10.3
+T05E11.1	C23G10.3
+T05F1.3	C23G10.3
+T07A9.11	C23G10.3
+T08B2.10	C23G10.3
+T22F3.4	C23G10.3
+T24B8.1	C23G10.3
+W01D2.1	C23G10.3
+W09C5.6	C23G10.3
+Y105E8A.16	C23G10.3
+Y106G6H.3	C23G10.3
+Y24D9A.4	C23G10.3
+Y37E3.7	C23G10.3
+Y37E3.8	C23G10.3
+Y41D4B.5	C23G10.3
+Y43B11AR.4	C23G10.3
+Y45F10D.12	C23G10.3
+Y48B6A.2	C23G10.3
+Y48G8AL.8	C23G10.3
+Y57G11C.16	C23G10.3
+Y62E10A.1	C23G10.3
+Y71A12B.1	C23G10.3
+Y71F9AL.13	C23G10.3
+Y73B3A.18	C23G10.3
+ZC434.2	C23G10.3
+ZK1010.1	C23G10.3
+ZK652.4	C23G10.3
+C26F1.9	C26F1.4
+C27A2.2	C26F1.4
+C32E8.2	C26F1.4
+C37A2.7	C26F1.4
+C42C1.14	C26F1.4
+C49H3.11	C26F1.4
+C53H9.1	C26F1.4
+C54C6.1	C26F1.4
+D1007.12	C26F1.4
+D1007.6	C26F1.4
+E04A4.8	C26F1.4
+F07D10.1	C26F1.4
+F10B5.1	C26F1.4
+F10E7.7	C26F1.4
+F13B10.2	C26F1.4
+F13G3.11	C26F1.4
+F25H2.10	C26F1.4
+F28C6.7	C26F1.4
+F28D1.7	C26F1.4
+F34H10.1	C26F1.4
+F36A2.6	C26F1.4
+F37C12.11	C26F1.4
+F37C12.4	C26F1.4
+F37C12.9	C26F1.4
+F39B2.6	C26F1.4
+F40F11.1	C26F1.4
+F40F8.10	C26F1.4
+F42C5.8	C26F1.4
+F52B5.6	C26F1.4
+F53A3.3	C26F1.4
+F53G12.10	C26F1.4
+F54C9.5	C26F1.4
+F54E7.2	C26F1.4
+F55D10.2	C26F1.4
+F56E10.4	C26F1.4
+F56F3.5	C26F1.4
+H06I04.4	C26F1.4
+K02B2.5	C26F1.4
+K08C9.7	C26F1.4
+K11H12.2	C26F1.4
+M01F1.2	C26F1.4
+R11D1.8	C26F1.4
+R13A5.8	C26F1.4
+R151.3	C26F1.4
+T01C3.6	C26F1.4
+T05E11.1	C26F1.4
+T05F1.3	C26F1.4
+T07A9.11	C26F1.4
+T08B2.10	C26F1.4
+T22F3.4	C26F1.4
+T24B8.1	C26F1.4
+W01D2.1	C26F1.4
+W09C5.6	C26F1.4
+Y105E8A.16	C26F1.4
+Y106G6H.3	C26F1.4
+Y24D9A.4	C26F1.4
+Y37E3.7	C26F1.4
+Y37E3.8	C26F1.4
+Y41D4B.5	C26F1.4
+Y43B11AR.4	C26F1.4
+Y45F10D.12	C26F1.4
+Y48B6A.2	C26F1.4
+Y48G8AL.8	C26F1.4
+Y57G11C.16	C26F1.4
+Y62E10A.1	C26F1.4
+Y71A12B.1	C26F1.4
+Y71F9AL.13	C26F1.4
+Y73B3A.18	C26F1.4
+ZC434.2	C26F1.4
+ZK1010.1	C26F1.4
+ZK652.4	C26F1.4
+C27A2.2	C26F1.9
+C32E8.2	C26F1.9
+C37A2.7	C26F1.9
+C42C1.14	C26F1.9
+C49H3.11	C26F1.9
+C53H9.1	C26F1.9
+C54C6.1	C26F1.9
+D1007.12	C26F1.9
+D1007.6	C26F1.9
+E04A4.8	C26F1.9
+F07D10.1	C26F1.9
+F10B5.1	C26F1.9
+F10E7.7	C26F1.9
+F13B10.2	C26F1.9
+F13G3.11	C26F1.9
+F25H2.10	C26F1.9
+F28C6.7	C26F1.9
+F28D1.7	C26F1.9
+F34H10.1	C26F1.9
+F36A2.6	C26F1.9
+F37C12.11	C26F1.9
+F37C12.4	C26F1.9
+F37C12.9	C26F1.9
+F39B2.6	C26F1.9
+F40F11.1	C26F1.9
+F40F8.10	C26F1.9
+F42C5.8	C26F1.9
+F52B5.6	C26F1.9
+F53A3.3	C26F1.9
+F53G12.10	C26F1.9
+F54C9.5	C26F1.9
+F54E7.2	C26F1.9
+F55D10.2	C26F1.9
+F56E10.4	C26F1.9
+F56F3.5	C26F1.9
+H06I04.4	C26F1.9
+K02B2.5	C26F1.9
+K08C9.7	C26F1.9
+K11H12.2	C26F1.9
+M01F1.2	C26F1.9
+R11D1.8	C26F1.9
+R13A5.8	C26F1.9
+R151.3	C26F1.9
+T01C3.6	C26F1.9
+T05E11.1	C26F1.9
+T05F1.3	C26F1.9
+T07A9.11	C26F1.9
+T08B2.10	C26F1.9
+T22F3.4	C26F1.9
+T24B8.1	C26F1.9
+W01D2.1	C26F1.9
+W09C5.6	C26F1.9
+Y105E8A.16	C26F1.9
+Y106G6H.3	C26F1.9
+Y24D9A.4	C26F1.9
+Y37E3.7	C26F1.9
+Y37E3.8	C26F1.9
+Y41D4B.5	C26F1.9
+Y43B11AR.4	C26F1.9
+Y45F10D.12	C26F1.9
+Y48B6A.2	C26F1.9
+Y48G8AL.8	C26F1.9
+Y57G11C.16	C26F1.9
+Y62E10A.1	C26F1.9
+Y71A12B.1	C26F1.9
+Y71F9AL.13	C26F1.9
+Y73B3A.18	C26F1.9
+ZC434.2	C26F1.9
+ZK1010.1	C26F1.9
+ZK652.4	C26F1.9
+C32E8.2	C27A2.2
+C37A2.7	C27A2.2
+C42C1.14	C27A2.2
+C49H3.11	C27A2.2
+C53H9.1	C27A2.2
+C54C6.1	C27A2.2
+D1007.12	C27A2.2
+D1007.6	C27A2.2
+E04A4.8	C27A2.2
+F07D10.1	C27A2.2
+F10B5.1	C27A2.2
+F10E7.7	C27A2.2
+F13B10.2	C27A2.2
+F13G3.11	C27A2.2
+F25H2.10	C27A2.2
+F28C6.7	C27A2.2
+F28D1.7	C27A2.2
+F34H10.1	C27A2.2
+F36A2.6	C27A2.2
+F37C12.11	C27A2.2
+F37C12.4	C27A2.2
+F37C12.9	C27A2.2
+F39B2.6	C27A2.2
+F40F11.1	C27A2.2
+F40F8.10	C27A2.2
+F42C5.8	C27A2.2
+F52B5.6	C27A2.2
+F53A3.3	C27A2.2
+F53G12.10	C27A2.2
+F54C9.5	C27A2.2
+F54E7.2	C27A2.2
+F55D10.2	C27A2.2
+F56E10.4	C27A2.2
+F56F3.5	C27A2.2
+H06I04.4	C27A2.2
+K02B2.5	C27A2.2
+K08C9.7	C27A2.2
+K11H12.2	C27A2.2
+M01F1.2	C27A2.2
+R11D1.8	C27A2.2
+R13A5.8	C27A2.2
+R151.3	C27A2.2
+T01C3.6	C27A2.2
+T05E11.1	C27A2.2
+T05F1.3	C27A2.2
+T07A9.11	C27A2.2
+T08B2.10	C27A2.2
+T22F3.4	C27A2.2
+T24B8.1	C27A2.2
+W01D2.1	C27A2.2
+W09C5.6	C27A2.2
+Y105E8A.16	C27A2.2
+Y106G6H.3	C27A2.2
+Y24D9A.4	C27A2.2
+Y37E3.7	C27A2.2
+Y37E3.8	C27A2.2
+Y41D4B.5	C27A2.2
+Y43B11AR.4	C27A2.2
+Y45F10D.12	C27A2.2
+Y48B6A.2	C27A2.2
+Y48G8AL.8	C27A2.2
+Y57G11C.16	C27A2.2
+Y62E10A.1	C27A2.2
+Y71A12B.1	C27A2.2
+Y71F9AL.13	C27A2.2
+Y73B3A.18	C27A2.2
+ZC434.2	C27A2.2
+ZK1010.1	C27A2.2
+ZK652.4	C27A2.2
+C37A2.7	C32E8.2
+C42C1.14	C32E8.2
+C49H3.11	C32E8.2
+C53H9.1	C32E8.2
+C54C6.1	C32E8.2
+D1007.12	C32E8.2
+D1007.6	C32E8.2
+E04A4.8	C32E8.2
+F07D10.1	C32E8.2
+F10B5.1	C32E8.2
+F10E7.7	C32E8.2
+F13B10.2	C32E8.2
+F13G3.11	C32E8.2
+F25H2.10	C32E8.2
+F28C6.7	C32E8.2
+F28D1.7	C32E8.2
+F34H10.1	C32E8.2
+F36A2.6	C32E8.2
+F37C12.11	C32E8.2
+F37C12.4	C32E8.2
+F37C12.9	C32E8.2
+F39B2.6	C32E8.2
+F40F11.1	C32E8.2
+F40F8.10	C32E8.2
+F42C5.8	C32E8.2
+F52B5.6	C32E8.2
+F53A3.3	C32E8.2
+F53G12.10	C32E8.2
+F54C9.5	C32E8.2
+F54E7.2	C32E8.2
+F55D10.2	C32E8.2
+F56E10.4	C32E8.2
+F56F3.5	C32E8.2
+H06I04.4	C32E8.2
+K02B2.5	C32E8.2
+K08C9.7	C32E8.2
+K11H12.2	C32E8.2
+M01F1.2	C32E8.2
+R11D1.8	C32E8.2
+R13A5.8	C32E8.2
+R151.3	C32E8.2
+T01C3.6	C32E8.2
+T05E11.1	C32E8.2
+T05F1.3	C32E8.2
+T07A9.11	C32E8.2
+T08B2.10	C32E8.2
+T22F3.4	C32E8.2
+T24B8.1	C32E8.2
+W01D2.1	C32E8.2
+W09C5.6	C32E8.2
+Y105E8A.16	C32E8.2
+Y106G6H.3	C32E8.2
+Y24D9A.4	C32E8.2
+Y37E3.7	C32E8.2
+Y37E3.8	C32E8.2
+Y41D4B.5	C32E8.2
+Y43B11AR.4	C32E8.2
+Y45F10D.12	C32E8.2
+Y48B6A.2	C32E8.2
+Y48G8AL.8	C32E8.2
+Y57G11C.16	C32E8.2
+Y62E10A.1	C32E8.2
+Y71A12B.1	C32E8.2
+Y71F9AL.13	C32E8.2
+Y73B3A.18	C32E8.2
+ZC434.2	C32E8.2
+ZK1010.1	C32E8.2
+ZK652.4	C32E8.2
+C42C1.14	C37A2.7
+C49H3.11	C37A2.7
+C53H9.1	C37A2.7
+C54C6.1	C37A2.7
+D1007.12	C37A2.7
+D1007.6	C37A2.7
+E04A4.8	C37A2.7
+F07D10.1	C37A2.7
+F10B5.1	C37A2.7
+F10E7.7	C37A2.7
+F13B10.2	C37A2.7
+F13G3.11	C37A2.7
+F25H2.10	C37A2.7
+F28C6.7	C37A2.7
+F28D1.7	C37A2.7
+F34H10.1	C37A2.7
+F36A2.6	C37A2.7
+F37C12.11	C37A2.7
+F37C12.4	C37A2.7
+F37C12.9	C37A2.7
+F39B2.6	C37A2.7
+F40F11.1	C37A2.7
+F40F8.10	C37A2.7
+F42C5.8	C37A2.7
+F52B5.6	C37A2.7
+F53A3.3	C37A2.7
+F53G12.10	C37A2.7
+F54C9.5	C37A2.7
+F54E7.2	C37A2.7
+F55D10.2	C37A2.7
+F56E10.4	C37A2.7
+F56F3.5	C37A2.7
+H06I04.4	C37A2.7
+K02B2.5	C37A2.7
+K08C9.7	C37A2.7
+K11H12.2	C37A2.7
+M01F1.2	C37A2.7
+R11D1.8	C37A2.7
+R13A5.8	C37A2.7
+R151.3	C37A2.7
+T01C3.6	C37A2.7
+T05E11.1	C37A2.7
+T05F1.3	C37A2.7
+T07A9.11	C37A2.7
+T08B2.10	C37A2.7
+T22F3.4	C37A2.7
+T24B8.1	C37A2.7
+W01D2.1	C37A2.7
+W09C5.6	C37A2.7
+Y105E8A.16	C37A2.7
+Y106G6H.3	C37A2.7
+Y24D9A.4	C37A2.7
+Y37E3.7	C37A2.7
+Y37E3.8	C37A2.7
+Y41D4B.5	C37A2.7
+Y43B11AR.4	C37A2.7
+Y45F10D.12	C37A2.7
+Y48B6A.2	C37A2.7
+Y48G8AL.8	C37A2.7
+Y57G11C.16	C37A2.7
+Y62E10A.1	C37A2.7
+Y71A12B.1	C37A2.7
+Y71F9AL.13	C37A2.7
+Y73B3A.18	C37A2.7
+ZC434.2	C37A2.7
+ZK1010.1	C37A2.7
+ZK652.4	C37A2.7
+C49H3.11	C42C1.14
+C53H9.1	C42C1.14
+C54C6.1	C42C1.14
+D1007.12	C42C1.14
+D1007.6	C42C1.14
+E04A4.8	C42C1.14
+F07D10.1	C42C1.14
+F10B5.1	C42C1.14
+F10E7.7	C42C1.14
+F13B10.2	C42C1.14
+F13G3.11	C42C1.14
+F25H2.10	C42C1.14
+F28C6.7	C42C1.14
+F28D1.7	C42C1.14
+F34H10.1	C42C1.14
+F36A2.6	C42C1.14
+F37C12.11	C42C1.14
+F37C12.4	C42C1.14
+F37C12.9	C42C1.14
+F39B2.6	C42C1.14
+F40F11.1	C42C1.14
+F40F8.10	C42C1.14
+F42C5.8	C42C1.14
+F52B5.6	C42C1.14
+F53A3.3	C42C1.14
+F53G12.10	C42C1.14
+F54C9.5	C42C1.14
+F54E7.2	C42C1.14
+F55D10.2	C42C1.14
+F56E10.4	C42C1.14
+F56F3.5	C42C1.14
+H06I04.4	C42C1.14
+K02B2.5	C42C1.14
+K08C9.7	C42C1.14
+K11H12.2	C42C1.14
+M01F1.2	C42C1.14
+R11D1.8	C42C1.14
+R13A5.8	C42C1.14
+R151.3	C42C1.14
+T01C3.6	C42C1.14
+T05E11.1	C42C1.14
+T05F1.3	C42C1.14
+T07A9.11	C42C1.14
+T08B2.10	C42C1.14
+T22F3.4	C42C1.14
+T24B8.1	C42C1.14
+W01D2.1	C42C1.14
+W09C5.6	C42C1.14
+Y105E8A.16	C42C1.14
+Y106G6H.3	C42C1.14
+Y24D9A.4	C42C1.14
+Y37E3.7	C42C1.14
+Y37E3.8	C42C1.14
+Y41D4B.5	C42C1.14
+Y43B11AR.4	C42C1.14
+Y45F10D.12	C42C1.14
+Y48B6A.2	C42C1.14
+Y48G8AL.8	C42C1.14
+Y57G11C.16	C42C1.14
+Y62E10A.1	C42C1.14
+Y71A12B.1	C42C1.14
+Y71F9AL.13	C42C1.14
+Y73B3A.18	C42C1.14
+ZC434.2	C42C1.14
+ZK1010.1	C42C1.14
+ZK652.4	C42C1.14
+C53H9.1	C49H3.11
+C54C6.1	C49H3.11
+D1007.12	C49H3.11
+D1007.6	C49H3.11
+E04A4.8	C49H3.11
+F07D10.1	C49H3.11
+F10B5.1	C49H3.11
+F10E7.7	C49H3.11
+F13B10.2	C49H3.11
+F13G3.11	C49H3.11
+F25H2.10	C49H3.11
+F28C6.7	C49H3.11
+F28D1.7	C49H3.11
+F34H10.1	C49H3.11
+F36A2.6	C49H3.11
+F37C12.11	C49H3.11
+F37C12.4	C49H3.11
+F37C12.9	C49H3.11
+F39B2.6	C49H3.11
+F40F11.1	C49H3.11
+F40F8.10	C49H3.11
+F42C5.8	C49H3.11
+F52B5.6	C49H3.11
+F53A3.3	C49H3.11
+F53G12.10	C49H3.11
+F54C9.5	C49H3.11
+F54E7.2	C49H3.11
+F55D10.2	C49H3.11
+F56E10.4	C49H3.11
+F56F3.5	C49H3.11
+H06I04.4	C49H3.11
+K02B2.5	C49H3.11
+K08C9.7	C49H3.11
+K11H12.2	C49H3.11
+M01F1.2	C49H3.11
+R11D1.8	C49H3.11
+R13A5.8	C49H3.11
+R151.3	C49H3.11
+T01C3.6	C49H3.11
+T05E11.1	C49H3.11
+T05F1.3	C49H3.11
+T07A9.11	C49H3.11
+T08B2.10	C49H3.11
+T22F3.4	C49H3.11
+T24B8.1	C49H3.11
+W01D2.1	C49H3.11
+W09C5.6	C49H3.11
+Y105E8A.16	C49H3.11
+Y106G6H.3	C49H3.11
+Y24D9A.4	C49H3.11
+Y37E3.7	C49H3.11
+Y37E3.8	C49H3.11
+Y41D4B.5	C49H3.11
+Y43B11AR.4	C49H3.11
+Y45F10D.12	C49H3.11
+Y48B6A.2	C49H3.11
+Y48G8AL.8	C49H3.11
+Y57G11C.16	C49H3.11
+Y62E10A.1	C49H3.11
+Y71A12B.1	C49H3.11
+Y71F9AL.13	C49H3.11
+Y73B3A.18	C49H3.11
+ZC434.2	C49H3.11
+ZK1010.1	C49H3.11
+ZK652.4	C49H3.11
+C54C6.1	C53H9.1
+D1007.12	C53H9.1
+D1007.6	C53H9.1
+E04A4.8	C53H9.1
+F07D10.1	C53H9.1
+F10B5.1	C53H9.1
+F10E7.7	C53H9.1
+F13B10.2	C53H9.1
+F13G3.11	C53H9.1
+F25H2.10	C53H9.1
+F28C6.7	C53H9.1
+F28D1.7	C53H9.1
+F34H10.1	C53H9.1
+F36A2.6	C53H9.1
+F37C12.11	C53H9.1
+F37C12.4	C53H9.1
+F37C12.9	C53H9.1
+F39B2.6	C53H9.1
+F40F11.1	C53H9.1
+F40F8.10	C53H9.1
+F42C5.8	C53H9.1
+F52B5.6	C53H9.1
+F53A3.3	C53H9.1
+F53G12.10	C53H9.1
+F54C9.5	C53H9.1
+F54E7.2	C53H9.1
+F55D10.2	C53H9.1
+F56E10.4	C53H9.1
+F56F3.5	C53H9.1
+H06I04.4	C53H9.1
+K02B2.5	C53H9.1
+K08C9.7	C53H9.1
+K11H12.2	C53H9.1
+M01F1.2	C53H9.1
+R11D1.8	C53H9.1
+R13A5.8	C53H9.1
+R151.3	C53H9.1
+T01C3.6	C53H9.1
+T05E11.1	C53H9.1
+T05F1.3	C53H9.1
+T07A9.11	C53H9.1
+T08B2.10	C53H9.1
+T22F3.4	C53H9.1
+T24B8.1	C53H9.1
+W01D2.1	C53H9.1
+W09C5.6	C53H9.1
+Y105E8A.16	C53H9.1
+Y106G6H.3	C53H9.1
+Y24D9A.4	C53H9.1
+Y37E3.7	C53H9.1
+Y37E3.8	C53H9.1
+Y41D4B.5	C53H9.1
+Y43B11AR.4	C53H9.1
+Y45F10D.12	C53H9.1
+Y48B6A.2	C53H9.1
+Y48G8AL.8	C53H9.1
+Y57G11C.16	C53H9.1
+Y62E10A.1	C53H9.1
+Y71A12B.1	C53H9.1
+Y71F9AL.13	C53H9.1
+Y73B3A.18	C53H9.1
+ZC434.2	C53H9.1
+ZK1010.1	C53H9.1
+ZK652.4	C53H9.1
+D1007.12	C54C6.1
+D1007.6	C54C6.1
+E04A4.8	C54C6.1
+F07D10.1	C54C6.1
+F10B5.1	C54C6.1
+F10E7.7	C54C6.1
+F13B10.2	C54C6.1
+F13G3.11	C54C6.1
+F25H2.10	C54C6.1
+F28C6.7	C54C6.1
+F28D1.7	C54C6.1
+F34H10.1	C54C6.1
+F36A2.6	C54C6.1
+F37C12.11	C54C6.1
+F37C12.4	C54C6.1
+F37C12.9	C54C6.1
+F39B2.6	C54C6.1
+F40F11.1	C54C6.1
+F40F8.10	C54C6.1
+F42C5.8	C54C6.1
+F52B5.6	C54C6.1
+F53A3.3	C54C6.1
+F53G12.10	C54C6.1
+F54C9.5	C54C6.1
+F54E7.2	C54C6.1
+F55D10.2	C54C6.1
+F56E10.4	C54C6.1
+F56F3.5	C54C6.1
+H06I04.4	C54C6.1
+K02B2.5	C54C6.1
+K08C9.7	C54C6.1
+K11H12.2	C54C6.1
+M01F1.2	C54C6.1
+R11D1.8	C54C6.1
+R13A5.8	C54C6.1
+R151.3	C54C6.1
+T01C3.6	C54C6.1
+T05E11.1	C54C6.1
+T05F1.3	C54C6.1
+T07A9.11	C54C6.1
+T08B2.10	C54C6.1
+T22F3.4	C54C6.1
+T24B8.1	C54C6.1
+W01D2.1	C54C6.1
+W09C5.6	C54C6.1
+Y105E8A.16	C54C6.1
+Y106G6H.3	C54C6.1
+Y24D9A.4	C54C6.1
+Y37E3.7	C54C6.1
+Y37E3.8	C54C6.1
+Y41D4B.5	C54C6.1
+Y43B11AR.4	C54C6.1
+Y45F10D.12	C54C6.1
+Y48B6A.2	C54C6.1
+Y48G8AL.8	C54C6.1
+Y57G11C.16	C54C6.1
+Y62E10A.1	C54C6.1
+Y71A12B.1	C54C6.1
+Y71F9AL.13	C54C6.1
+Y73B3A.18	C54C6.1
+ZC434.2	C54C6.1
+ZK1010.1	C54C6.1
+ZK652.4	C54C6.1
+D1007.6	D1007.12
+E04A4.8	D1007.12
+F07D10.1	D1007.12
+F10B5.1	D1007.12
+F10E7.7	D1007.12
+F13B10.2	D1007.12
+F13G3.11	D1007.12
+F25H2.10	D1007.12
+F28C6.7	D1007.12
+F28D1.7	D1007.12
+F34H10.1	D1007.12
+F36A2.6	D1007.12
+F37C12.11	D1007.12
+F37C12.4	D1007.12
+F37C12.9	D1007.12
+F39B2.6	D1007.12
+F40F11.1	D1007.12
+F40F8.10	D1007.12
+F42C5.8	D1007.12
+F52B5.6	D1007.12
+F53A3.3	D1007.12
+F53G12.10	D1007.12
+F54C9.5	D1007.12
+F54E7.2	D1007.12
+F55D10.2	D1007.12
+F56E10.4	D1007.12
+F56F3.5	D1007.12
+H06I04.4	D1007.12
+K02B2.5	D1007.12
+K08C9.7	D1007.12
+K11H12.2	D1007.12
+M01F1.2	D1007.12
+R11D1.8	D1007.12
+R13A5.8	D1007.12
+R151.3	D1007.12
+T01C3.6	D1007.12
+T05E11.1	D1007.12
+T05F1.3	D1007.12
+T07A9.11	D1007.12
+T08B2.10	D1007.12
+T22F3.4	D1007.12
+T24B8.1	D1007.12
+W01D2.1	D1007.12
+W09C5.6	D1007.12
+Y105E8A.16	D1007.12
+Y106G6H.3	D1007.12
+Y24D9A.4	D1007.12
+Y37E3.7	D1007.12
+Y37E3.8	D1007.12
+Y41D4B.5	D1007.12
+Y43B11AR.4	D1007.12
+Y45F10D.12	D1007.12
+Y48B6A.2	D1007.12
+Y48G8AL.8	D1007.12
+Y57G11C.16	D1007.12
+Y62E10A.1	D1007.12
+Y71A12B.1	D1007.12
+Y71F9AL.13	D1007.12
+Y73B3A.18	D1007.12
+ZC434.2	D1007.12
+ZK1010.1	D1007.12
+ZK652.4	D1007.12
+E04A4.8	D1007.6
+F07D10.1	D1007.6
+F10B5.1	D1007.6
+F10E7.7	D1007.6
+F13B10.2	D1007.6
+F13G3.11	D1007.6
+F25H2.10	D1007.6
+F28C6.7	D1007.6
+F28D1.7	D1007.6
+F34H10.1	D1007.6
+F36A2.6	D1007.6
+F37C12.11	D1007.6
+F37C12.4	D1007.6
+F37C12.9	D1007.6
+F39B2.6	D1007.6
+F40F11.1	D1007.6
+F40F8.10	D1007.6
+F42C5.8	D1007.6
+F52B5.6	D1007.6
+F53A3.3	D1007.6
+F53G12.10	D1007.6
+F54C9.5	D1007.6
+F54E7.2	D1007.6
+F55D10.2	D1007.6
+F56E10.4	D1007.6
+F56F3.5	D1007.6
+H06I04.4	D1007.6
+K02B2.5	D1007.6
+K08C9.7	D1007.6
+K11H12.2	D1007.6
+M01F1.2	D1007.6
+R11D1.8	D1007.6
+R13A5.8	D1007.6
+R151.3	D1007.6
+T01C3.6	D1007.6
+T05E11.1	D1007.6
+T05F1.3	D1007.6
+T07A9.11	D1007.6
+T08B2.10	D1007.6
+T22F3.4	D1007.6
+T24B8.1	D1007.6
+W01D2.1	D1007.6
+W09C5.6	D1007.6
+Y105E8A.16	D1007.6
+Y106G6H.3	D1007.6
+Y24D9A.4	D1007.6
+Y37E3.7	D1007.6
+Y37E3.8	D1007.6
+Y41D4B.5	D1007.6
+Y43B11AR.4	D1007.6
+Y45F10D.12	D1007.6
+Y48B6A.2	D1007.6
+Y48G8AL.8	D1007.6
+Y57G11C.16	D1007.6
+Y62E10A.1	D1007.6
+Y71A12B.1	D1007.6
+Y71F9AL.13	D1007.6
+Y73B3A.18	D1007.6
+ZC434.2	D1007.6
+ZK1010.1	D1007.6
+ZK652.4	D1007.6
+F07D10.1	E04A4.8
+F10B5.1	E04A4.8
+F10E7.7	E04A4.8
+F13B10.2	E04A4.8
+F13G3.11	E04A4.8
+F25H2.10	E04A4.8
+F28C6.7	E04A4.8
+F28D1.7	E04A4.8
+F34H10.1	E04A4.8
+F36A2.6	E04A4.8
+F37C12.11	E04A4.8
+F37C12.4	E04A4.8
+F37C12.9	E04A4.8
+F39B2.6	E04A4.8
+F40F11.1	E04A4.8
+F40F8.10	E04A4.8
+F42C5.8	E04A4.8
+F52B5.6	E04A4.8
+F53A3.3	E04A4.8
+F53G12.10	E04A4.8
+F54C9.5	E04A4.8
+F54E7.2	E04A4.8
+F55D10.2	E04A4.8
+F56E10.4	E04A4.8
+F56F3.5	E04A4.8
+H06I04.4	E04A4.8
+K02B2.5	E04A4.8
+K08C9.7	E04A4.8
+K11H12.2	E04A4.8
+M01F1.2	E04A4.8
+R11D1.8	E04A4.8
+R13A5.8	E04A4.8
+R151.3	E04A4.8
+T01C3.6	E04A4.8
+T05E11.1	E04A4.8
+T05F1.3	E04A4.8
+T07A9.11	E04A4.8
+T08B2.10	E04A4.8
+T22F3.4	E04A4.8
+T24B8.1	E04A4.8
+W01D2.1	E04A4.8
+W09C5.6	E04A4.8
+Y105E8A.16	E04A4.8
+Y106G6H.3	E04A4.8
+Y24D9A.4	E04A4.8
+Y37E3.7	E04A4.8
+Y37E3.8	E04A4.8
+Y41D4B.5	E04A4.8
+Y43B11AR.4	E04A4.8
+Y45F10D.12	E04A4.8
+Y48B6A.2	E04A4.8
+Y48G8AL.8	E04A4.8
+Y57G11C.16	E04A4.8
+Y62E10A.1	E04A4.8
+Y71A12B.1	E04A4.8
+Y71F9AL.13	E04A4.8
+Y73B3A.18	E04A4.8
+ZC434.2	E04A4.8
+ZK1010.1	E04A4.8
+ZK652.4	E04A4.8
+F10B5.1	F07D10.1
+F10E7.7	F07D10.1
+F13B10.2	F07D10.1
+F13G3.11	F07D10.1
+F25H2.10	F07D10.1
+F28C6.7	F07D10.1
+F28D1.7	F07D10.1
+F34H10.1	F07D10.1
+F36A2.6	F07D10.1
+F37C12.11	F07D10.1
+F37C12.4	F07D10.1
+F37C12.9	F07D10.1
+F39B2.6	F07D10.1
+F40F11.1	F07D10.1
+F40F8.10	F07D10.1
+F42C5.8	F07D10.1
+F52B5.6	F07D10.1
+F53A3.3	F07D10.1
+F53G12.10	F07D10.1
+F54C9.5	F07D10.1
+F54E7.2	F07D10.1
+F55D10.2	F07D10.1
+F56E10.4	F07D10.1
+F56F3.5	F07D10.1
+H06I04.4	F07D10.1
+K02B2.5	F07D10.1
+K08C9.7	F07D10.1
+K11H12.2	F07D10.1
+M01F1.2	F07D10.1
+R11D1.8	F07D10.1
+R13A5.8	F07D10.1
+R151.3	F07D10.1
+T01C3.6	F07D10.1
+T05E11.1	F07D10.1
+T05F1.3	F07D10.1
+T07A9.11	F07D10.1
+T08B2.10	F07D10.1
+T22F3.4	F07D10.1
+T24B8.1	F07D10.1
+W01D2.1	F07D10.1
+W09C5.6	F07D10.1
+Y105E8A.16	F07D10.1
+Y106G6H.3	F07D10.1
+Y24D9A.4	F07D10.1
+Y37E3.7	F07D10.1
+Y37E3.8	F07D10.1
+Y41D4B.5	F07D10.1
+Y43B11AR.4	F07D10.1
+Y45F10D.12	F07D10.1
+Y48B6A.2	F07D10.1
+Y48G8AL.8	F07D10.1
+Y57G11C.16	F07D10.1
+Y62E10A.1	F07D10.1
+Y71A12B.1	F07D10.1
+Y71F9AL.13	F07D10.1
+Y73B3A.18	F07D10.1
+ZC434.2	F07D10.1
+ZK1010.1	F07D10.1
+ZK652.4	F07D10.1
+F10E7.7	F10B5.1
+F13B10.2	F10B5.1
+F13G3.11	F10B5.1
+F25H2.10	F10B5.1
+F28C6.7	F10B5.1
+F28D1.7	F10B5.1
+F34H10.1	F10B5.1
+F36A2.6	F10B5.1
+F37C12.11	F10B5.1
+F37C12.4	F10B5.1
+F37C12.9	F10B5.1
+F39B2.6	F10B5.1
+F40F11.1	F10B5.1
+F40F8.10	F10B5.1
+F42C5.8	F10B5.1
+F52B5.6	F10B5.1
+F53A3.3	F10B5.1
+F53G12.10	F10B5.1
+F54C9.5	F10B5.1
+F54E7.2	F10B5.1
+F55D10.2	F10B5.1
+F56E10.4	F10B5.1
+F56F3.5	F10B5.1
+H06I04.4	F10B5.1
+K02B2.5	F10B5.1
+K08C9.7	F10B5.1
+K11H12.2	F10B5.1
+M01F1.2	F10B5.1
+R11D1.8	F10B5.1
+R13A5.8	F10B5.1
+R151.3	F10B5.1
+T01C3.6	F10B5.1
+T05E11.1	F10B5.1
+T05F1.3	F10B5.1
+T07A9.11	F10B5.1
+T08B2.10	F10B5.1
+T22F3.4	F10B5.1
+T24B8.1	F10B5.1
+W01D2.1	F10B5.1
+W09C5.6	F10B5.1
+Y105E8A.16	F10B5.1
+Y106G6H.3	F10B5.1
+Y24D9A.4	F10B5.1
+Y37E3.7	F10B5.1
+Y37E3.8	F10B5.1
+Y41D4B.5	F10B5.1
+Y43B11AR.4	F10B5.1
+Y45F10D.12	F10B5.1
+Y48B6A.2	F10B5.1
+Y48G8AL.8	F10B5.1
+Y57G11C.16	F10B5.1
+Y62E10A.1	F10B5.1
+Y71A12B.1	F10B5.1
+Y71F9AL.13	F10B5.1
+Y73B3A.18	F10B5.1
+ZC434.2	F10B5.1
+ZK1010.1	F10B5.1
+ZK652.4	F10B5.1
+F13B10.2	F10E7.7
+F13G3.11	F10E7.7
+F25H2.10	F10E7.7
+F28C6.7	F10E7.7
+F28D1.7	F10E7.7
+F34H10.1	F10E7.7
+F36A2.6	F10E7.7
+F37C12.11	F10E7.7
+F37C12.4	F10E7.7
+F37C12.9	F10E7.7
+F39B2.6	F10E7.7
+F40F11.1	F10E7.7
+F40F8.10	F10E7.7
+F42C5.8	F10E7.7
+F52B5.6	F10E7.7
+F53A3.3	F10E7.7
+F53G12.10	F10E7.7
+F54C9.5	F10E7.7
+F54E7.2	F10E7.7
+F55D10.2	F10E7.7
+F56E10.4	F10E7.7
+F56F3.5	F10E7.7
+H06I04.4	F10E7.7
+K02B2.5	F10E7.7
+K08C9.7	F10E7.7
+K11H12.2	F10E7.7
+M01F1.2	F10E7.7
+R11D1.8	F10E7.7
+R13A5.8	F10E7.7
+R151.3	F10E7.7
+T01C3.6	F10E7.7
+T05E11.1	F10E7.7
+T05F1.3	F10E7.7
+T07A9.11	F10E7.7
+T08B2.10	F10E7.7
+T22F3.4	F10E7.7
+T24B8.1	F10E7.7
+W01D2.1	F10E7.7
+W09C5.6	F10E7.7
+Y105E8A.16	F10E7.7
+Y106G6H.3	F10E7.7
+Y24D9A.4	F10E7.7
+Y37E3.7	F10E7.7
+Y37E3.8	F10E7.7
+Y41D4B.5	F10E7.7
+Y43B11AR.4	F10E7.7
+Y45F10D.12	F10E7.7
+Y48B6A.2	F10E7.7
+Y48G8AL.8	F10E7.7
+Y57G11C.16	F10E7.7
+Y62E10A.1	F10E7.7
+Y71A12B.1	F10E7.7
+Y71F9AL.13	F10E7.7
+Y73B3A.18	F10E7.7
+ZC434.2	F10E7.7
+ZK1010.1	F10E7.7
+ZK652.4	F10E7.7
+F13G3.11	F13B10.2
+F25H2.10	F13B10.2
+F28C6.7	F13B10.2
+F28D1.7	F13B10.2
+F34H10.1	F13B10.2
+F36A2.6	F13B10.2
+F37C12.11	F13B10.2
+F37C12.4	F13B10.2
+F37C12.9	F13B10.2
+F39B2.6	F13B10.2
+F40F11.1	F13B10.2
+F40F8.10	F13B10.2
+F42C5.8	F13B10.2
+F52B5.6	F13B10.2
+F53A3.3	F13B10.2
+F53G12.10	F13B10.2
+F54C9.5	F13B10.2
+F54E7.2	F13B10.2
+F55D10.2	F13B10.2
+F56E10.4	F13B10.2
+F56F3.5	F13B10.2
+H06I04.4	F13B10.2
+K02B2.5	F13B10.2
+K08C9.7	F13B10.2
+K11H12.2	F13B10.2
+M01F1.2	F13B10.2
+R11D1.8	F13B10.2
+R13A5.8	F13B10.2
+R151.3	F13B10.2
+T01C3.6	F13B10.2
+T05E11.1	F13B10.2
+T05F1.3	F13B10.2
+T07A9.11	F13B10.2
+T08B2.10	F13B10.2
+T22F3.4	F13B10.2
+T24B8.1	F13B10.2
+W01D2.1	F13B10.2
+W09C5.6	F13B10.2
+Y105E8A.16	F13B10.2
+Y106G6H.3	F13B10.2
+Y24D9A.4	F13B10.2
+Y37E3.7	F13B10.2
+Y37E3.8	F13B10.2
+Y41D4B.5	F13B10.2
+Y43B11AR.4	F13B10.2
+Y45F10D.12	F13B10.2
+Y48B6A.2	F13B10.2
+Y48G8AL.8	F13B10.2
+Y57G11C.16	F13B10.2
+Y62E10A.1	F13B10.2
+Y71A12B.1	F13B10.2
+Y71F9AL.13	F13B10.2
+Y73B3A.18	F13B10.2
+ZC434.2	F13B10.2
+ZK1010.1	F13B10.2
+ZK652.4	F13B10.2
+F25H2.10	F13G3.11
+F28C6.7	F13G3.11
+F28D1.7	F13G3.11
+F34H10.1	F13G3.11
+F36A2.6	F13G3.11
+F37C12.11	F13G3.11
+F37C12.4	F13G3.11
+F37C12.9	F13G3.11
+F39B2.6	F13G3.11
+F40F11.1	F13G3.11
+F40F8.10	F13G3.11
+F42C5.8	F13G3.11
+F52B5.6	F13G3.11
+F53A3.3	F13G3.11
+F53G12.10	F13G3.11
+F54C9.5	F13G3.11
+F54E7.2	F13G3.11
+F55D10.2	F13G3.11
+F56E10.4	F13G3.11
+F56F3.5	F13G3.11
+H06I04.4	F13G3.11
+K02B2.5	F13G3.11
+K08C9.7	F13G3.11
+K11H12.2	F13G3.11
+M01F1.2	F13G3.11
+R11D1.8	F13G3.11
+R13A5.8	F13G3.11
+R151.3	F13G3.11
+T01C3.6	F13G3.11
+T05E11.1	F13G3.11
+T05F1.3	F13G3.11
+T07A9.11	F13G3.11
+T08B2.10	F13G3.11
+T22F3.4	F13G3.11
+T24B8.1	F13G3.11
+W01D2.1	F13G3.11
+W09C5.6	F13G3.11
+Y105E8A.16	F13G3.11
+Y106G6H.3	F13G3.11
+Y24D9A.4	F13G3.11
+Y37E3.7	F13G3.11
+Y37E3.8	F13G3.11
+Y41D4B.5	F13G3.11
+Y43B11AR.4	F13G3.11
+Y45F10D.12	F13G3.11
+Y48B6A.2	F13G3.11
+Y48G8AL.8	F13G3.11
+Y57G11C.16	F13G3.11
+Y62E10A.1	F13G3.11
+Y71A12B.1	F13G3.11
+Y71F9AL.13	F13G3.11
+Y73B3A.18	F13G3.11
+ZC434.2	F13G3.11
+ZK1010.1	F13G3.11
+ZK652.4	F13G3.11
+F28C6.7	F25H2.10
+F28D1.7	F25H2.10
+F34H10.1	F25H2.10
+F36A2.6	F25H2.10
+F37C12.11	F25H2.10
+F37C12.4	F25H2.10
+F37C12.9	F25H2.10
+F39B2.6	F25H2.10
+F40F11.1	F25H2.10
+F40F8.10	F25H2.10
+F42C5.8	F25H2.10
+F52B5.6	F25H2.10
+F53A3.3	F25H2.10
+F53G12.10	F25H2.10
+F54C9.5	F25H2.10
+F54E7.2	F25H2.10
+F55D10.2	F25H2.10
+F56E10.4	F25H2.10
+F56F3.5	F25H2.10
+H06I04.4	F25H2.10
+K02B2.5	F25H2.10
+K08C9.7	F25H2.10
+K11H12.2	F25H2.10
+M01F1.2	F25H2.10
+R11D1.8	F25H2.10
+R13A5.8	F25H2.10
+R151.3	F25H2.10
+T01C3.6	F25H2.10
+T05E11.1	F25H2.10
+T05F1.3	F25H2.10
+T07A9.11	F25H2.10
+T08B2.10	F25H2.10
+T22F3.4	F25H2.10
+T24B8.1	F25H2.10
+W01D2.1	F25H2.10
+W09C5.6	F25H2.10
+Y105E8A.16	F25H2.10
+Y106G6H.3	F25H2.10
+Y24D9A.4	F25H2.10
+Y37E3.7	F25H2.10
+Y37E3.8	F25H2.10
+Y41D4B.5	F25H2.10
+Y43B11AR.4	F25H2.10
+Y45F10D.12	F25H2.10
+Y48B6A.2	F25H2.10
+Y48G8AL.8	F25H2.10
+Y57G11C.16	F25H2.10
+Y62E10A.1	F25H2.10
+Y71A12B.1	F25H2.10
+Y71F9AL.13	F25H2.10
+Y73B3A.18	F25H2.10
+ZC434.2	F25H2.10
+ZK1010.1	F25H2.10
+ZK652.4	F25H2.10
+F28D1.7	F28C6.7
+F34H10.1	F28C6.7
+F36A2.6	F28C6.7
+F37C12.11	F28C6.7
+F37C12.4	F28C6.7
+F37C12.9	F28C6.7
+F39B2.6	F28C6.7
+F40F11.1	F28C6.7
+F40F8.10	F28C6.7
+F42C5.8	F28C6.7
+F52B5.6	F28C6.7
+F53A3.3	F28C6.7
+F53G12.10	F28C6.7
+F54C9.5	F28C6.7
+F54E7.2	F28C6.7
+F55D10.2	F28C6.7
+F56E10.4	F28C6.7
+F56F3.5	F28C6.7
+H06I04.4	F28C6.7
+K02B2.5	F28C6.7
+K08C9.7	F28C6.7
+K11H12.2	F28C6.7
+M01F1.2	F28C6.7
+R11D1.8	F28C6.7
+R13A5.8	F28C6.7
+R151.3	F28C6.7
+T01C3.6	F28C6.7
+T05E11.1	F28C6.7
+T05F1.3	F28C6.7
+T07A9.11	F28C6.7
+T08B2.10	F28C6.7
+T22F3.4	F28C6.7
+T24B8.1	F28C6.7
+W01D2.1	F28C6.7
+W09C5.6	F28C6.7
+Y105E8A.16	F28C6.7
+Y106G6H.3	F28C6.7
+Y24D9A.4	F28C6.7
+Y37E3.7	F28C6.7
+Y37E3.8	F28C6.7
+Y41D4B.5	F28C6.7
+Y43B11AR.4	F28C6.7
+Y45F10D.12	F28C6.7
+Y48B6A.2	F28C6.7
+Y48G8AL.8	F28C6.7
+Y57G11C.16	F28C6.7
+Y62E10A.1	F28C6.7
+Y71A12B.1	F28C6.7
+Y71F9AL.13	F28C6.7
+Y73B3A.18	F28C6.7
+ZC434.2	F28C6.7
+ZK1010.1	F28C6.7
+ZK652.4	F28C6.7
+F34H10.1	F28D1.7
+F36A2.6	F28D1.7
+F37C12.11	F28D1.7
+F37C12.4	F28D1.7
+F37C12.9	F28D1.7
+F39B2.6	F28D1.7
+F40F11.1	F28D1.7
+F40F8.10	F28D1.7
+F42C5.8	F28D1.7
+F52B5.6	F28D1.7
+F53A3.3	F28D1.7
+F53G12.10	F28D1.7
+F54C9.5	F28D1.7
+F54E7.2	F28D1.7
+F55D10.2	F28D1.7
+F56E10.4	F28D1.7
+F56F3.5	F28D1.7
+H06I04.4	F28D1.7
+K02B2.5	F28D1.7
+K08C9.7	F28D1.7
+K11H12.2	F28D1.7
+M01F1.2	F28D1.7
+R11D1.8	F28D1.7
+R13A5.8	F28D1.7
+R151.3	F28D1.7
+T01C3.6	F28D1.7
+T05E11.1	F28D1.7
+T05F1.3	F28D1.7
+T07A9.11	F28D1.7
+T08B2.10	F28D1.7
+T22F3.4	F28D1.7
+T24B8.1	F28D1.7
+W01D2.1	F28D1.7
+W09C5.6	F28D1.7
+Y105E8A.16	F28D1.7
+Y106G6H.3	F28D1.7
+Y24D9A.4	F28D1.7
+Y37E3.7	F28D1.7
+Y37E3.8	F28D1.7
+Y41D4B.5	F28D1.7
+Y43B11AR.4	F28D1.7
+Y45F10D.12	F28D1.7
+Y48B6A.2	F28D1.7
+Y48G8AL.8	F28D1.7
+Y57G11C.16	F28D1.7
+Y62E10A.1	F28D1.7
+Y71A12B.1	F28D1.7
+Y71F9AL.13	F28D1.7
+Y73B3A.18	F28D1.7
+ZC434.2	F28D1.7
+ZK1010.1	F28D1.7
+ZK652.4	F28D1.7
+F36A2.6	F34H10.1
+F37C12.11	F34H10.1
+F37C12.4	F34H10.1
+F37C12.9	F34H10.1
+F39B2.6	F34H10.1
+F40F11.1	F34H10.1
+F40F8.10	F34H10.1
+F42C5.8	F34H10.1
+F52B5.6	F34H10.1
+F53A3.3	F34H10.1
+F53G12.10	F34H10.1
+F54C9.5	F34H10.1
+F54E7.2	F34H10.1
+F55D10.2	F34H10.1
+F56E10.4	F34H10.1
+F56F3.5	F34H10.1
+H06I04.4	F34H10.1
+K02B2.5	F34H10.1
+K08C9.7	F34H10.1
+K11H12.2	F34H10.1
+M01F1.2	F34H10.1
+R11D1.8	F34H10.1
+R13A5.8	F34H10.1
+R151.3	F34H10.1
+T01C3.6	F34H10.1
+T05E11.1	F34H10.1
+T05F1.3	F34H10.1
+T07A9.11	F34H10.1
+T08B2.10	F34H10.1
+T22F3.4	F34H10.1
+T24B8.1	F34H10.1
+W01D2.1	F34H10.1
+W09C5.6	F34H10.1
+Y105E8A.16	F34H10.1
+Y106G6H.3	F34H10.1
+Y24D9A.4	F34H10.1
+Y37E3.7	F34H10.1
+Y37E3.8	F34H10.1
+Y41D4B.5	F34H10.1
+Y43B11AR.4	F34H10.1
+Y45F10D.12	F34H10.1
+Y48B6A.2	F34H10.1
+Y48G8AL.8	F34H10.1
+Y57G11C.16	F34H10.1
+Y62E10A.1	F34H10.1
+Y71A12B.1	F34H10.1
+Y71F9AL.13	F34H10.1
+Y73B3A.18	F34H10.1
+ZC434.2	F34H10.1
+ZK1010.1	F34H10.1
+ZK652.4	F34H10.1
+F37C12.11	F36A2.6
+F37C12.4	F36A2.6
+F37C12.9	F36A2.6
+F39B2.6	F36A2.6
+F40F11.1	F36A2.6
+F40F8.10	F36A2.6
+F42C5.8	F36A2.6
+F52B5.6	F36A2.6
+F53A3.3	F36A2.6
+F53G12.10	F36A2.6
+F54C9.5	F36A2.6
+F54E7.2	F36A2.6
+F55D10.2	F36A2.6
+F56E10.4	F36A2.6
+F56F3.5	F36A2.6
+H06I04.4	F36A2.6
+K02B2.5	F36A2.6
+K08C9.7	F36A2.6
+K11H12.2	F36A2.6
+M01F1.2	F36A2.6
+R11D1.8	F36A2.6
+R13A5.8	F36A2.6
+R151.3	F36A2.6
+T01C3.6	F36A2.6
+T05E11.1	F36A2.6
+T05F1.3	F36A2.6
+T07A9.11	F36A2.6
+T08B2.10	F36A2.6
+T22F3.4	F36A2.6
+T24B8.1	F36A2.6
+W01D2.1	F36A2.6
+W09C5.6	F36A2.6
+Y105E8A.16	F36A2.6
+Y106G6H.3	F36A2.6
+Y24D9A.4	F36A2.6
+Y37E3.7	F36A2.6
+Y37E3.8	F36A2.6
+Y41D4B.5	F36A2.6
+Y43B11AR.4	F36A2.6
+Y45F10D.12	F36A2.6
+Y48B6A.2	F36A2.6
+Y48G8AL.8	F36A2.6
+Y57G11C.16	F36A2.6
+Y62E10A.1	F36A2.6
+Y71A12B.1	F36A2.6
+Y71F9AL.13	F36A2.6
+Y73B3A.18	F36A2.6
+ZC434.2	F36A2.6
+ZK1010.1	F36A2.6
+ZK652.4	F36A2.6
+F37C12.4	F37C12.11
+F37C12.9	F37C12.11
+F39B2.6	F37C12.11
+F40F11.1	F37C12.11
+F40F8.10	F37C12.11
+F52B5.6	F37C12.11
+F53A3.3	F37C12.11
+F53G12.10	F37C12.11
+F54C9.5	F37C12.11
+F54E7.2	F37C12.11
+F55D10.2	F37C12.11
+F56E10.4	F37C12.11
+F56F3.5	F37C12.11
+H06I04.4	F37C12.11
+K02B2.5	F37C12.11
+K08C9.7	F37C12.11
+K11H12.2	F37C12.11
+M01F1.2	F37C12.11
+R11D1.8	F37C12.11
+R13A5.8	F37C12.11
+R151.3	F37C12.11
+T01C3.6	F37C12.11
+T05E11.1	F37C12.11
+T05F1.3	F37C12.11
+T22F3.4	F37C12.11
+T24B8.1	F37C12.11
+W01D2.1	F37C12.11
+W09C5.6	F37C12.11
+Y105E8A.16	F37C12.11
+Y106G6H.3	F37C12.11
+Y24D9A.4	F37C12.11
+Y37E3.7	F37C12.11
+Y37E3.8	F37C12.11
+Y41D4B.5	F37C12.11
+Y43B11AR.4	F37C12.11
+Y45F10D.12	F37C12.11
+Y48B6A.2	F37C12.11
+Y48G8AL.8	F37C12.11
+Y57G11C.16	F37C12.11
+Y62E10A.1	F37C12.11
+Y71F9AL.13	F37C12.11
+Y73B3A.18	F37C12.11
+ZK1010.1	F37C12.11
+ZK652.4	F37C12.11
+F37C12.9	F37C12.4
+F39B2.6	F37C12.4
+F40F11.1	F37C12.4
+F40F8.10	F37C12.4
+F42C5.8	F37C12.4
+F52B5.6	F37C12.4
+F53A3.3	F37C12.4
+F53G12.10	F37C12.4
+F54C9.5	F37C12.4
+F54E7.2	F37C12.4
+F55D10.2	F37C12.4
+F56E10.4	F37C12.4
+F56F3.5	F37C12.4
+H06I04.4	F37C12.4
+K02B2.5	F37C12.4
+K08C9.7	F37C12.4
+K11H12.2	F37C12.4
+M01F1.2	F37C12.4
+R11D1.8	F37C12.4
+R13A5.8	F37C12.4
+R151.3	F37C12.4
+T01C3.6	F37C12.4
+T05E11.1	F37C12.4
+T05F1.3	F37C12.4
+T07A9.11	F37C12.4
+T08B2.10	F37C12.4
+T22F3.4	F37C12.4
+T24B8.1	F37C12.4
+W01D2.1	F37C12.4
+W09C5.6	F37C12.4
+Y105E8A.16	F37C12.4
+Y106G6H.3	F37C12.4
+Y24D9A.4	F37C12.4
+Y37E3.7	F37C12.4
+Y37E3.8	F37C12.4
+Y41D4B.5	F37C12.4
+Y43B11AR.4	F37C12.4
+Y45F10D.12	F37C12.4
+Y48B6A.2	F37C12.4
+Y48G8AL.8	F37C12.4
+Y57G11C.16	F37C12.4
+Y62E10A.1	F37C12.4
+Y71A12B.1	F37C12.4
+Y71F9AL.13	F37C12.4
+Y73B3A.18	F37C12.4
+ZC434.2	F37C12.4
+ZK1010.1	F37C12.4
+ZK652.4	F37C12.4
+F39B2.6	F37C12.9
+F40F11.1	F37C12.9
+F40F8.10	F37C12.9
+F42C5.8	F37C12.9
+F52B5.6	F37C12.9
+F53A3.3	F37C12.9
+F53G12.10	F37C12.9
+F54C9.5	F37C12.9
+F54E7.2	F37C12.9
+F55D10.2	F37C12.9
+F56E10.4	F37C12.9
+F56F3.5	F37C12.9
+H06I04.4	F37C12.9
+K02B2.5	F37C12.9
+K08C9.7	F37C12.9
+K11H12.2	F37C12.9
+M01F1.2	F37C12.9
+R11D1.8	F37C12.9
+R13A5.8	F37C12.9
+R151.3	F37C12.9
+T01C3.6	F37C12.9
+T05E11.1	F37C12.9
+T05F1.3	F37C12.9
+T07A9.11	F37C12.9
+T08B2.10	F37C12.9
+T22F3.4	F37C12.9
+T24B8.1	F37C12.9
+W01D2.1	F37C12.9
+W09C5.6	F37C12.9
+Y105E8A.16	F37C12.9
+Y106G6H.3	F37C12.9
+Y24D9A.4	F37C12.9
+Y37E3.7	F37C12.9
+Y37E3.8	F37C12.9
+Y41D4B.5	F37C12.9
+Y43B11AR.4	F37C12.9
+Y45F10D.12	F37C12.9
+Y48B6A.2	F37C12.9
+Y48G8AL.8	F37C12.9
+Y57G11C.16	F37C12.9
+Y62E10A.1	F37C12.9
+Y71A12B.1	F37C12.9
+Y71F9AL.13	F37C12.9
+Y73B3A.18	F37C12.9
+ZC434.2	F37C12.9
+ZK1010.1	F37C12.9
+ZK652.4	F37C12.9
+F40F11.1	F39B2.6
+F40F8.10	F39B2.6
+F42C5.8	F39B2.6
+F52B5.6	F39B2.6
+F53A3.3	F39B2.6
+F53G12.10	F39B2.6
+F54C9.5	F39B2.6
+F54E7.2	F39B2.6
+F55D10.2	F39B2.6
+F56E10.4	F39B2.6
+F56F3.5	F39B2.6
+H06I04.4	F39B2.6
+K02B2.5	F39B2.6
+K08C9.7	F39B2.6
+K11H12.2	F39B2.6
+M01F1.2	F39B2.6
+R11D1.8	F39B2.6
+R13A5.8	F39B2.6
+R151.3	F39B2.6
+T01C3.6	F39B2.6
+T05E11.1	F39B2.6
+T05F1.3	F39B2.6
+T07A9.11	F39B2.6
+T08B2.10	F39B2.6
+T22F3.4	F39B2.6
+T24B8.1	F39B2.6
+W01D2.1	F39B2.6
+W09C5.6	F39B2.6
+Y105E8A.16	F39B2.6
+Y106G6H.3	F39B2.6
+Y24D9A.4	F39B2.6
+Y37E3.7	F39B2.6
+Y37E3.8	F39B2.6
+Y41D4B.5	F39B2.6
+Y43B11AR.4	F39B2.6
+Y45F10D.12	F39B2.6
+Y48B6A.2	F39B2.6
+Y48G8AL.8	F39B2.6
+Y57G11C.16	F39B2.6
+Y62E10A.1	F39B2.6
+Y71A12B.1	F39B2.6
+Y71F9AL.13	F39B2.6
+Y73B3A.18	F39B2.6
+ZC434.2	F39B2.6
+ZK1010.1	F39B2.6
+ZK652.4	F39B2.6
+F40F8.10	F40F11.1
+F42C5.8	F40F11.1
+F52B5.6	F40F11.1
+F53A3.3	F40F11.1
+F53G12.10	F40F11.1
+F54C9.5	F40F11.1
+F54E7.2	F40F11.1
+F55D10.2	F40F11.1
+F56E10.4	F40F11.1
+F56F3.5	F40F11.1
+H06I04.4	F40F11.1
+K02B2.5	F40F11.1
+K08C9.7	F40F11.1
+K11H12.2	F40F11.1
+M01F1.2	F40F11.1
+R11D1.8	F40F11.1
+R13A5.8	F40F11.1
+R151.3	F40F11.1
+T01C3.6	F40F11.1
+T05E11.1	F40F11.1
+T05F1.3	F40F11.1
+T07A9.11	F40F11.1
+T08B2.10	F40F11.1
+T22F3.4	F40F11.1
+T24B8.1	F40F11.1
+W01D2.1	F40F11.1
+W09C5.6	F40F11.1
+Y105E8A.16	F40F11.1
+Y106G6H.3	F40F11.1
+Y24D9A.4	F40F11.1
+Y37E3.7	F40F11.1
+Y37E3.8	F40F11.1
+Y41D4B.5	F40F11.1
+Y43B11AR.4	F40F11.1
+Y45F10D.12	F40F11.1
+Y48B6A.2	F40F11.1
+Y48G8AL.8	F40F11.1
+Y57G11C.16	F40F11.1
+Y62E10A.1	F40F11.1
+Y71A12B.1	F40F11.1
+Y71F9AL.13	F40F11.1
+Y73B3A.18	F40F11.1
+ZC434.2	F40F11.1
+ZK1010.1	F40F11.1
+ZK652.4	F40F11.1
+F42C5.8	F40F8.10
+F52B5.6	F40F8.10
+F53A3.3	F40F8.10
+F53G12.10	F40F8.10
+F54C9.5	F40F8.10
+F54E7.2	F40F8.10
+F55D10.2	F40F8.10
+F56E10.4	F40F8.10
+F56F3.5	F40F8.10
+H06I04.4	F40F8.10
+K02B2.5	F40F8.10
+K08C9.7	F40F8.10
+K11H12.2	F40F8.10
+M01F1.2	F40F8.10
+R11D1.8	F40F8.10
+R13A5.8	F40F8.10
+R151.3	F40F8.10
+T01C3.6	F40F8.10
+T05E11.1	F40F8.10
+T05F1.3	F40F8.10
+T07A9.11	F40F8.10
+T08B2.10	F40F8.10
+T22F3.4	F40F8.10
+T24B8.1	F40F8.10
+W01D2.1	F40F8.10
+W09C5.6	F40F8.10
+Y105E8A.16	F40F8.10
+Y106G6H.3	F40F8.10
+Y24D9A.4	F40F8.10
+Y37E3.7	F40F8.10
+Y37E3.8	F40F8.10
+Y41D4B.5	F40F8.10
+Y43B11AR.4	F40F8.10
+Y45F10D.12	F40F8.10
+Y48B6A.2	F40F8.10
+Y48G8AL.8	F40F8.10
+Y57G11C.16	F40F8.10
+Y62E10A.1	F40F8.10
+Y71A12B.1	F40F8.10
+Y71F9AL.13	F40F8.10
+Y73B3A.18	F40F8.10
+ZC434.2	F40F8.10
+ZK1010.1	F40F8.10
+ZK652.4	F40F8.10
+F52B5.6	F42C5.8
+F53A3.3	F42C5.8
+F53G12.10	F42C5.8
+F54C9.5	F42C5.8
+F54E7.2	F42C5.8
+F55D10.2	F42C5.8
+F56E10.4	F42C5.8
+F56F3.5	F42C5.8
+H06I04.4	F42C5.8
+K02B2.5	F42C5.8
+K08C9.7	F42C5.8
+K11H12.2	F42C5.8
+M01F1.2	F42C5.8
+R11D1.8	F42C5.8
+R13A5.8	F42C5.8
+R151.3	F42C5.8
+T01C3.6	F42C5.8
+T05E11.1	F42C5.8
+T05F1.3	F42C5.8
+T22F3.4	F42C5.8
+T24B8.1	F42C5.8
+W01D2.1	F42C5.8
+W09C5.6	F42C5.8
+Y105E8A.16	F42C5.8
+Y106G6H.3	F42C5.8
+Y24D9A.4	F42C5.8
+Y37E3.7	F42C5.8
+Y37E3.8	F42C5.8
+Y41D4B.5	F42C5.8
+Y43B11AR.4	F42C5.8
+Y45F10D.12	F42C5.8
+Y48B6A.2	F42C5.8
+Y48G8AL.8	F42C5.8
+Y57G11C.16	F42C5.8
+Y62E10A.1	F42C5.8
+Y71A12B.1	F42C5.8
+Y71F9AL.13	F42C5.8
+Y73B3A.18	F42C5.8
+ZC434.2	F42C5.8
+ZK1010.1	F42C5.8
+ZK652.4	F42C5.8
+F53A3.3	F52B5.6
+F53G12.10	F52B5.6
+F54C9.5	F52B5.6
+F54E7.2	F52B5.6
+F55D10.2	F52B5.6
+F56E10.4	F52B5.6
+F56F3.5	F52B5.6
+H06I04.4	F52B5.6
+K02B2.5	F52B5.6
+K08C9.7	F52B5.6
+K11H12.2	F52B5.6
+M01F1.2	F52B5.6
+R11D1.8	F52B5.6
+R13A5.8	F52B5.6
+R151.3	F52B5.6
+T01C3.6	F52B5.6
+T05E11.1	F52B5.6
+T05F1.3	F52B5.6
+T07A9.11	F52B5.6
+T08B2.10	F52B5.6
+T22F3.4	F52B5.6
+T24B8.1	F52B5.6
+W01D2.1	F52B5.6
+W09C5.6	F52B5.6
+Y105E8A.16	F52B5.6
+Y106G6H.3	F52B5.6
+Y24D9A.4	F52B5.6
+Y37E3.7	F52B5.6
+Y37E3.8	F52B5.6
+Y41D4B.5	F52B5.6
+Y43B11AR.4	F52B5.6
+Y45F10D.12	F52B5.6
+Y48B6A.2	F52B5.6
+Y48G8AL.8	F52B5.6
+Y57G11C.16	F52B5.6
+Y62E10A.1	F52B5.6
+Y71A12B.1	F52B5.6
+Y71F9AL.13	F52B5.6
+Y73B3A.18	F52B5.6
+ZC434.2	F52B5.6
+ZK1010.1	F52B5.6
+ZK652.4	F52B5.6
+F53G12.10	F53A3.3
+F54C9.5	F53A3.3
+F54E7.2	F53A3.3
+F55D10.2	F53A3.3
+F56E10.4	F53A3.3
+F56F3.5	F53A3.3
+H06I04.4	F53A3.3
+K02B2.5	F53A3.3
+K08C9.7	F53A3.3
+K11H12.2	F53A3.3
+M01F1.2	F53A3.3
+R11D1.8	F53A3.3
+R13A5.8	F53A3.3
+R151.3	F53A3.3
+T01C3.6	F53A3.3
+T05E11.1	F53A3.3
+T05F1.3	F53A3.3
+T07A9.11	F53A3.3
+T08B2.10	F53A3.3
+T22F3.4	F53A3.3
+T24B8.1	F53A3.3
+W01D2.1	F53A3.3
+W09C5.6	F53A3.3
+Y105E8A.16	F53A3.3
+Y106G6H.3	F53A3.3
+Y24D9A.4	F53A3.3
+Y37E3.7	F53A3.3
+Y37E3.8	F53A3.3
+Y41D4B.5	F53A3.3
+Y43B11AR.4	F53A3.3
+Y45F10D.12	F53A3.3
+Y48B6A.2	F53A3.3
+Y48G8AL.8	F53A3.3
+Y57G11C.16	F53A3.3
+Y62E10A.1	F53A3.3
+Y71A12B.1	F53A3.3
+Y71F9AL.13	F53A3.3
+Y73B3A.18	F53A3.3
+ZC434.2	F53A3.3
+ZK1010.1	F53A3.3
+ZK652.4	F53A3.3
+F54C9.5	F53G12.10
+F54E7.2	F53G12.10
+F55D10.2	F53G12.10
+F56E10.4	F53G12.10
+F56F3.5	F53G12.10
+H06I04.4	F53G12.10
+K02B2.5	F53G12.10
+K08C9.7	F53G12.10
+K11H12.2	F53G12.10
+M01F1.2	F53G12.10
+R11D1.8	F53G12.10
+R13A5.8	F53G12.10
+R151.3	F53G12.10
+T01C3.6	F53G12.10
+T05E11.1	F53G12.10
+T05F1.3	F53G12.10
+T07A9.11	F53G12.10
+T08B2.10	F53G12.10
+T22F3.4	F53G12.10
+T24B8.1	F53G12.10
+W01D2.1	F53G12.10
+W09C5.6	F53G12.10
+Y105E8A.16	F53G12.10
+Y106G6H.3	F53G12.10
+Y24D9A.4	F53G12.10
+Y37E3.7	F53G12.10
+Y37E3.8	F53G12.10
+Y41D4B.5	F53G12.10
+Y43B11AR.4	F53G12.10
+Y45F10D.12	F53G12.10
+Y48B6A.2	F53G12.10
+Y48G8AL.8	F53G12.10
+Y57G11C.16	F53G12.10
+Y62E10A.1	F53G12.10
+Y71A12B.1	F53G12.10
+Y71F9AL.13	F53G12.10
+Y73B3A.18	F53G12.10
+ZC434.2	F53G12.10
+ZK1010.1	F53G12.10
+ZK652.4	F53G12.10
+F54E7.2	F54C9.5
+F55D10.2	F54C9.5
+F56E10.4	F54C9.5
+F56F3.5	F54C9.5
+H06I04.4	F54C9.5
+K02B2.5	F54C9.5
+K08C9.7	F54C9.5
+K11H12.2	F54C9.5
+M01F1.2	F54C9.5
+R11D1.8	F54C9.5
+R13A5.8	F54C9.5
+R151.3	F54C9.5
+T01C3.6	F54C9.5
+T05E11.1	F54C9.5
+T05F1.3	F54C9.5
+T07A9.11	F54C9.5
+T08B2.10	F54C9.5
+T22F3.4	F54C9.5
+T24B8.1	F54C9.5
+W01D2.1	F54C9.5
+W09C5.6	F54C9.5
+Y105E8A.16	F54C9.5
+Y106G6H.3	F54C9.5
+Y24D9A.4	F54C9.5
+Y37E3.7	F54C9.5
+Y37E3.8	F54C9.5
+Y41D4B.5	F54C9.5
+Y43B11AR.4	F54C9.5
+Y45F10D.12	F54C9.5
+Y48B6A.2	F54C9.5
+Y48G8AL.8	F54C9.5
+Y57G11C.16	F54C9.5
+Y62E10A.1	F54C9.5
+Y71A12B.1	F54C9.5
+Y71F9AL.13	F54C9.5
+Y73B3A.18	F54C9.5
+ZC434.2	F54C9.5
+ZK1010.1	F54C9.5
+ZK652.4	F54C9.5
+F55D10.2	F54E7.2
+F56E10.4	F54E7.2
+F56F3.5	F54E7.2
+H06I04.4	F54E7.2
+K02B2.5	F54E7.2
+K08C9.7	F54E7.2
+K11H12.2	F54E7.2
+M01F1.2	F54E7.2
+R11D1.8	F54E7.2
+R13A5.8	F54E7.2
+R151.3	F54E7.2
+T01C3.6	F54E7.2
+T05E11.1	F54E7.2
+T05F1.3	F54E7.2
+T07A9.11	F54E7.2
+T08B2.10	F54E7.2
+T22F3.4	F54E7.2
+T24B8.1	F54E7.2
+W01D2.1	F54E7.2
+W09C5.6	F54E7.2
+Y105E8A.16	F54E7.2
+Y106G6H.3	F54E7.2
+Y24D9A.4	F54E7.2
+Y37E3.7	F54E7.2
+Y37E3.8	F54E7.2
+Y41D4B.5	F54E7.2
+Y43B11AR.4	F54E7.2
+Y45F10D.12	F54E7.2
+Y48B6A.2	F54E7.2
+Y48G8AL.8	F54E7.2
+Y57G11C.16	F54E7.2
+Y62E10A.1	F54E7.2
+Y71A12B.1	F54E7.2
+Y71F9AL.13	F54E7.2
+Y73B3A.18	F54E7.2
+ZC434.2	F54E7.2
+ZK1010.1	F54E7.2
+ZK652.4	F54E7.2
+F56E10.4	F55D10.2
+F56F3.5	F55D10.2
+H06I04.4	F55D10.2
+K02B2.5	F55D10.2
+K08C9.7	F55D10.2
+K11H12.2	F55D10.2
+M01F1.2	F55D10.2
+R11D1.8	F55D10.2
+R13A5.8	F55D10.2
+R151.3	F55D10.2
+T01C3.6	F55D10.2
+T05E11.1	F55D10.2
+T05F1.3	F55D10.2
+T07A9.11	F55D10.2
+T08B2.10	F55D10.2
+T22F3.4	F55D10.2
+T24B8.1	F55D10.2
+W01D2.1	F55D10.2
+W09C5.6	F55D10.2
+Y105E8A.16	F55D10.2
+Y106G6H.3	F55D10.2
+Y24D9A.4	F55D10.2
+Y37E3.7	F55D10.2
+Y37E3.8	F55D10.2
+Y41D4B.5	F55D10.2
+Y43B11AR.4	F55D10.2
+Y45F10D.12	F55D10.2
+Y48B6A.2	F55D10.2
+Y48G8AL.8	F55D10.2
+Y57G11C.16	F55D10.2
+Y62E10A.1	F55D10.2
+Y71A12B.1	F55D10.2
+Y71F9AL.13	F55D10.2
+Y73B3A.18	F55D10.2
+ZC434.2	F55D10.2
+ZK1010.1	F55D10.2
+ZK652.4	F55D10.2
+F56F3.5	F56E10.4
+H06I04.4	F56E10.4
+K02B2.5	F56E10.4
+K08C9.7	F56E10.4
+K11H12.2	F56E10.4
+M01F1.2	F56E10.4
+R11D1.8	F56E10.4
+R13A5.8	F56E10.4
+R151.3	F56E10.4
+T01C3.6	F56E10.4
+T05E11.1	F56E10.4
+T05F1.3	F56E10.4
+T07A9.11	F56E10.4
+T08B2.10	F56E10.4
+T22F3.4	F56E10.4
+T24B8.1	F56E10.4
+W01D2.1	F56E10.4
+W09C5.6	F56E10.4
+Y105E8A.16	F56E10.4
+Y106G6H.3	F56E10.4
+Y24D9A.4	F56E10.4
+Y37E3.7	F56E10.4
+Y37E3.8	F56E10.4
+Y41D4B.5	F56E10.4
+Y43B11AR.4	F56E10.4
+Y45F10D.12	F56E10.4
+Y48B6A.2	F56E10.4
+Y48G8AL.8	F56E10.4
+Y57G11C.16	F56E10.4
+Y62E10A.1	F56E10.4
+Y71A12B.1	F56E10.4
+Y71F9AL.13	F56E10.4
+Y73B3A.18	F56E10.4
+ZC434.2	F56E10.4
+ZK1010.1	F56E10.4
+ZK652.4	F56E10.4
+H06I04.4	F56F3.5
+K02B2.5	F56F3.5
+K08C9.7	F56F3.5
+K11H12.2	F56F3.5
+M01F1.2	F56F3.5
+R11D1.8	F56F3.5
+R13A5.8	F56F3.5
+R151.3	F56F3.5
+T01C3.6	F56F3.5
+T05E11.1	F56F3.5
+T05F1.3	F56F3.5
+T07A9.11	F56F3.5
+T08B2.10	F56F3.5
+T22F3.4	F56F3.5
+T24B8.1	F56F3.5
+W01D2.1	F56F3.5
+W09C5.6	F56F3.5
+Y105E8A.16	F56F3.5
+Y106G6H.3	F56F3.5
+Y24D9A.4	F56F3.5
+Y37E3.7	F56F3.5
+Y37E3.8	F56F3.5
+Y41D4B.5	F56F3.5
+Y43B11AR.4	F56F3.5
+Y45F10D.12	F56F3.5
+Y48B6A.2	F56F3.5
+Y48G8AL.8	F56F3.5
+Y57G11C.16	F56F3.5
+Y62E10A.1	F56F3.5
+Y71A12B.1	F56F3.5
+Y71F9AL.13	F56F3.5
+Y73B3A.18	F56F3.5
+ZC434.2	F56F3.5
+ZK1010.1	F56F3.5
+ZK652.4	F56F3.5
+K02B2.5	H06I04.4
+K08C9.7	H06I04.4
+K11H12.2	H06I04.4
+M01F1.2	H06I04.4
+R11D1.8	H06I04.4
+R13A5.8	H06I04.4
+R151.3	H06I04.4
+T01C3.6	H06I04.4
+T05E11.1	H06I04.4
+T05F1.3	H06I04.4
+T07A9.11	H06I04.4
+T08B2.10	H06I04.4
+T22F3.4	H06I04.4
+T24B8.1	H06I04.4
+W01D2.1	H06I04.4
+W09C5.6	H06I04.4
+Y105E8A.16	H06I04.4
+Y106G6H.3	H06I04.4
+Y24D9A.4	H06I04.4
+Y37E3.7	H06I04.4
+Y37E3.8	H06I04.4
+Y41D4B.5	H06I04.4
+Y43B11AR.4	H06I04.4
+Y45F10D.12	H06I04.4
+Y48B6A.2	H06I04.4
+Y48G8AL.8	H06I04.4
+Y57G11C.16	H06I04.4
+Y62E10A.1	H06I04.4
+Y71A12B.1	H06I04.4
+Y71F9AL.13	H06I04.4
+Y73B3A.18	H06I04.4
+ZC434.2	H06I04.4
+ZK1010.1	H06I04.4
+ZK652.4	H06I04.4
+K08C9.7	K02B2.5
+K11H12.2	K02B2.5
+M01F1.2	K02B2.5
+R11D1.8	K02B2.5
+R13A5.8	K02B2.5
+R151.3	K02B2.5
+T01C3.6	K02B2.5
+T05E11.1	K02B2.5
+T05F1.3	K02B2.5
+T07A9.11	K02B2.5
+T08B2.10	K02B2.5
+T22F3.4	K02B2.5
+T24B8.1	K02B2.5
+W01D2.1	K02B2.5
+W09C5.6	K02B2.5
+Y105E8A.16	K02B2.5
+Y106G6H.3	K02B2.5
+Y24D9A.4	K02B2.5
+Y37E3.7	K02B2.5
+Y37E3.8	K02B2.5
+Y41D4B.5	K02B2.5
+Y43B11AR.4	K02B2.5
+Y45F10D.12	K02B2.5
+Y48B6A.2	K02B2.5
+Y48G8AL.8	K02B2.5
+Y57G11C.16	K02B2.5
+Y62E10A.1	K02B2.5
+Y71A12B.1	K02B2.5
+Y71F9AL.13	K02B2.5
+Y73B3A.18	K02B2.5
+ZC434.2	K02B2.5
+ZK1010.1	K02B2.5
+ZK652.4	K02B2.5
+K11H12.2	K08C9.7
+M01F1.2	K08C9.7
+R11D1.8	K08C9.7
+R13A5.8	K08C9.7
+R151.3	K08C9.7
+T01C3.6	K08C9.7
+T05E11.1	K08C9.7
+T05F1.3	K08C9.7
+T07A9.11	K08C9.7
+T08B2.10	K08C9.7
+T22F3.4	K08C9.7
+T24B8.1	K08C9.7
+W01D2.1	K08C9.7
+W09C5.6	K08C9.7
+Y105E8A.16	K08C9.7
+Y106G6H.3	K08C9.7
+Y24D9A.4	K08C9.7
+Y37E3.7	K08C9.7
+Y37E3.8	K08C9.7
+Y41D4B.5	K08C9.7
+Y43B11AR.4	K08C9.7
+Y45F10D.12	K08C9.7
+Y48B6A.2	K08C9.7
+Y48G8AL.8	K08C9.7
+Y57G11C.16	K08C9.7
+Y62E10A.1	K08C9.7
+Y71A12B.1	K08C9.7
+Y71F9AL.13	K08C9.7
+Y73B3A.18	K08C9.7
+ZC434.2	K08C9.7
+ZK1010.1	K08C9.7
+ZK652.4	K08C9.7
+M01F1.2	K11H12.2
+R11D1.8	K11H12.2
+R13A5.8	K11H12.2
+R151.3	K11H12.2
+T01C3.6	K11H12.2
+T05E11.1	K11H12.2
+T05F1.3	K11H12.2
+T07A9.11	K11H12.2
+T08B2.10	K11H12.2
+T22F3.4	K11H12.2
+T24B8.1	K11H12.2
+W01D2.1	K11H12.2
+W09C5.6	K11H12.2
+Y105E8A.16	K11H12.2
+Y106G6H.3	K11H12.2
+Y24D9A.4	K11H12.2
+Y37E3.7	K11H12.2
+Y37E3.8	K11H12.2
+Y41D4B.5	K11H12.2
+Y43B11AR.4	K11H12.2
+Y45F10D.12	K11H12.2
+Y48B6A.2	K11H12.2
+Y48G8AL.8	K11H12.2
+Y57G11C.16	K11H12.2
+Y62E10A.1	K11H12.2
+Y71A12B.1	K11H12.2
+Y71F9AL.13	K11H12.2
+Y73B3A.18	K11H12.2
+ZC434.2	K11H12.2
+ZK1010.1	K11H12.2
+ZK652.4	K11H12.2
+R11D1.8	M01F1.2
+R13A5.8	M01F1.2
+R151.3	M01F1.2
+T01C3.6	M01F1.2
+T05E11.1	M01F1.2
+T05F1.3	M01F1.2
+T07A9.11	M01F1.2
+T08B2.10	M01F1.2
+T22F3.4	M01F1.2
+T24B8.1	M01F1.2
+W01D2.1	M01F1.2
+W09C5.6	M01F1.2
+Y105E8A.16	M01F1.2
+Y106G6H.3	M01F1.2
+Y24D9A.4	M01F1.2
+Y37E3.7	M01F1.2
+Y37E3.8	M01F1.2
+Y41D4B.5	M01F1.2
+Y43B11AR.4	M01F1.2
+Y45F10D.12	M01F1.2
+Y48B6A.2	M01F1.2
+Y48G8AL.8	M01F1.2
+Y57G11C.16	M01F1.2
+Y62E10A.1	M01F1.2
+Y71A12B.1	M01F1.2
+Y71F9AL.13	M01F1.2
+Y73B3A.18	M01F1.2
+ZC434.2	M01F1.2
+ZK1010.1	M01F1.2
+ZK652.4	M01F1.2
+R13A5.8	R11D1.8
+R151.3	R11D1.8
+T01C3.6	R11D1.8
+T05E11.1	R11D1.8
+T05F1.3	R11D1.8
+T07A9.11	R11D1.8
+T08B2.10	R11D1.8
+T22F3.4	R11D1.8
+T24B8.1	R11D1.8
+W01D2.1	R11D1.8
+W09C5.6	R11D1.8
+Y105E8A.16	R11D1.8
+Y106G6H.3	R11D1.8
+Y24D9A.4	R11D1.8
+Y37E3.7	R11D1.8
+Y37E3.8	R11D1.8
+Y41D4B.5	R11D1.8
+Y43B11AR.4	R11D1.8
+Y45F10D.12	R11D1.8
+Y48B6A.2	R11D1.8
+Y48G8AL.8	R11D1.8
+Y57G11C.16	R11D1.8
+Y62E10A.1	R11D1.8
+Y71A12B.1	R11D1.8
+Y71F9AL.13	R11D1.8
+Y73B3A.18	R11D1.8
+ZC434.2	R11D1.8
+ZK1010.1	R11D1.8
+ZK652.4	R11D1.8
+R151.3	R13A5.8
+T01C3.6	R13A5.8
+T05E11.1	R13A5.8
+T05F1.3	R13A5.8
+T07A9.11	R13A5.8
+T08B2.10	R13A5.8
+T22F3.4	R13A5.8
+T24B8.1	R13A5.8
+W01D2.1	R13A5.8
+W09C5.6	R13A5.8
+Y105E8A.16	R13A5.8
+Y106G6H.3	R13A5.8
+Y24D9A.4	R13A5.8
+Y37E3.7	R13A5.8
+Y37E3.8	R13A5.8
+Y41D4B.5	R13A5.8
+Y43B11AR.4	R13A5.8
+Y45F10D.12	R13A5.8
+Y48B6A.2	R13A5.8
+Y48G8AL.8	R13A5.8
+Y57G11C.16	R13A5.8
+Y62E10A.1	R13A5.8
+Y71A12B.1	R13A5.8
+Y71F9AL.13	R13A5.8
+Y73B3A.18	R13A5.8
+ZC434.2	R13A5.8
+ZK1010.1	R13A5.8
+ZK652.4	R13A5.8
+T01C3.6	R151.3
+T05E11.1	R151.3
+T05F1.3	R151.3
+T07A9.11	R151.3
+T08B2.10	R151.3
+T22F3.4	R151.3
+T24B8.1	R151.3
+W01D2.1	R151.3
+W09C5.6	R151.3
+Y105E8A.16	R151.3
+Y106G6H.3	R151.3
+Y24D9A.4	R151.3
+Y37E3.7	R151.3
+Y37E3.8	R151.3
+Y41D4B.5	R151.3
+Y43B11AR.4	R151.3
+Y45F10D.12	R151.3
+Y48B6A.2	R151.3
+Y48G8AL.8	R151.3
+Y57G11C.16	R151.3
+Y62E10A.1	R151.3
+Y71A12B.1	R151.3
+Y71F9AL.13	R151.3
+Y73B3A.18	R151.3
+ZC434.2	R151.3
+ZK1010.1	R151.3
+ZK652.4	R151.3
+T05E11.1	T01C3.6
+T05F1.3	T01C3.6
+T07A9.11	T01C3.6
+T08B2.10	T01C3.6
+T22F3.4	T01C3.6
+T24B8.1	T01C3.6
+W01D2.1	T01C3.6
+W09C5.6	T01C3.6
+Y105E8A.16	T01C3.6
+Y106G6H.3	T01C3.6
+Y24D9A.4	T01C3.6
+Y37E3.7	T01C3.6
+Y37E3.8	T01C3.6
+Y41D4B.5	T01C3.6
+Y43B11AR.4	T01C3.6
+Y45F10D.12	T01C3.6
+Y48B6A.2	T01C3.6
+Y48G8AL.8	T01C3.6
+Y57G11C.16	T01C3.6
+Y62E10A.1	T01C3.6
+Y71A12B.1	T01C3.6
+Y71F9AL.13	T01C3.6
+Y73B3A.18	T01C3.6
+ZC434.2	T01C3.6
+ZK1010.1	T01C3.6
+ZK652.4	T01C3.6
+T05F1.3	T05E11.1
+T07A9.11	T05E11.1
+T08B2.10	T05E11.1
+T22F3.4	T05E11.1
+T24B8.1	T05E11.1
+W01D2.1	T05E11.1
+W09C5.6	T05E11.1
+Y105E8A.16	T05E11.1
+Y106G6H.3	T05E11.1
+Y24D9A.4	T05E11.1
+Y37E3.7	T05E11.1
+Y37E3.8	T05E11.1
+Y41D4B.5	T05E11.1
+Y43B11AR.4	T05E11.1
+Y45F10D.12	T05E11.1
+Y48B6A.2	T05E11.1
+Y48G8AL.8	T05E11.1
+Y57G11C.16	T05E11.1
+Y62E10A.1	T05E11.1
+Y71A12B.1	T05E11.1
+Y71F9AL.13	T05E11.1
+Y73B3A.18	T05E11.1
+ZC434.2	T05E11.1
+ZK1010.1	T05E11.1
+ZK652.4	T05E11.1
+T07A9.11	T05F1.3
+T08B2.10	T05F1.3
+T22F3.4	T05F1.3
+T24B8.1	T05F1.3
+W01D2.1	T05F1.3
+W09C5.6	T05F1.3
+Y105E8A.16	T05F1.3
+Y106G6H.3	T05F1.3
+Y24D9A.4	T05F1.3
+Y37E3.7	T05F1.3
+Y37E3.8	T05F1.3
+Y41D4B.5	T05F1.3
+Y43B11AR.4	T05F1.3
+Y45F10D.12	T05F1.3
+Y48B6A.2	T05F1.3
+Y48G8AL.8	T05F1.3
+Y57G11C.16	T05F1.3
+Y62E10A.1	T05F1.3
+Y71A12B.1	T05F1.3
+Y71F9AL.13	T05F1.3
+Y73B3A.18	T05F1.3
+ZC434.2	T05F1.3
+ZK1010.1	T05F1.3
+ZK652.4	T05F1.3
+T22F3.4	T07A9.11
+T24B8.1	T07A9.11
+W01D2.1	T07A9.11
+W09C5.6	T07A9.11
+Y105E8A.16	T07A9.11
+Y106G6H.3	T07A9.11
+Y24D9A.4	T07A9.11
+Y37E3.7	T07A9.11
+Y37E3.8	T07A9.11
+Y41D4B.5	T07A9.11
+Y43B11AR.4	T07A9.11
+Y45F10D.12	T07A9.11
+Y48B6A.2	T07A9.11
+Y48G8AL.8	T07A9.11
+Y57G11C.16	T07A9.11
+Y62E10A.1	T07A9.11
+Y71A12B.1	T07A9.11
+Y71F9AL.13	T07A9.11
+Y73B3A.18	T07A9.11
+ZC434.2	T07A9.11
+ZK1010.1	T07A9.11
+ZK652.4	T07A9.11
+T22F3.4	T08B2.10
+T24B8.1	T08B2.10
+W01D2.1	T08B2.10
+W09C5.6	T08B2.10
+Y105E8A.16	T08B2.10
+Y106G6H.3	T08B2.10
+Y24D9A.4	T08B2.10
+Y37E3.7	T08B2.10
+Y37E3.8	T08B2.10
+Y41D4B.5	T08B2.10
+Y43B11AR.4	T08B2.10
+Y45F10D.12	T08B2.10
+Y48B6A.2	T08B2.10
+Y48G8AL.8	T08B2.10
+Y57G11C.16	T08B2.10
+Y62E10A.1	T08B2.10
+Y71A12B.1	T08B2.10
+Y71F9AL.13	T08B2.10
+Y73B3A.18	T08B2.10
+ZC434.2	T08B2.10
+ZK1010.1	T08B2.10
+ZK652.4	T08B2.10
+T24B8.1	T22F3.4
+W01D2.1	T22F3.4
+W09C5.6	T22F3.4
+Y105E8A.16	T22F3.4
+Y106G6H.3	T22F3.4
+Y24D9A.4	T22F3.4
+Y37E3.7	T22F3.4
+Y37E3.8	T22F3.4
+Y41D4B.5	T22F3.4
+Y43B11AR.4	T22F3.4
+Y45F10D.12	T22F3.4
+Y48B6A.2	T22F3.4
+Y48G8AL.8	T22F3.4
+Y57G11C.16	T22F3.4
+Y62E10A.1	T22F3.4
+Y71A12B.1	T22F3.4
+Y71F9AL.13	T22F3.4
+Y73B3A.18	T22F3.4
+ZC434.2	T22F3.4
+ZK1010.1	T22F3.4
+ZK652.4	T22F3.4
+W01D2.1	T24B8.1
+W09C5.6	T24B8.1
+Y105E8A.16	T24B8.1
+Y106G6H.3	T24B8.1
+Y24D9A.4	T24B8.1
+Y37E3.7	T24B8.1
+Y37E3.8	T24B8.1
+Y41D4B.5	T24B8.1
+Y43B11AR.4	T24B8.1
+Y45F10D.12	T24B8.1
+Y48B6A.2	T24B8.1
+Y48G8AL.8	T24B8.1
+Y57G11C.16	T24B8.1
+Y62E10A.1	T24B8.1
+Y71A12B.1	T24B8.1
+Y71F9AL.13	T24B8.1
+Y73B3A.18	T24B8.1
+ZC434.2	T24B8.1
+ZK1010.1	T24B8.1
+ZK652.4	T24B8.1
+W09C5.6	W01D2.1
+Y105E8A.16	W01D2.1
+Y106G6H.3	W01D2.1
+Y24D9A.4	W01D2.1
+Y37E3.7	W01D2.1
+Y37E3.8	W01D2.1
+Y41D4B.5	W01D2.1
+Y43B11AR.4	W01D2.1
+Y45F10D.12	W01D2.1
+Y48B6A.2	W01D2.1
+Y48G8AL.8	W01D2.1
+Y57G11C.16	W01D2.1
+Y62E10A.1	W01D2.1
+Y71A12B.1	W01D2.1
+Y71F9AL.13	W01D2.1
+Y73B3A.18	W01D2.1
+ZC434.2	W01D2.1
+ZK1010.1	W01D2.1
+ZK652.4	W01D2.1
+Y105E8A.16	W09C5.6
+Y106G6H.3	W09C5.6
+Y24D9A.4	W09C5.6
+Y37E3.7	W09C5.6
+Y37E3.8	W09C5.6
+Y41D4B.5	W09C5.6
+Y43B11AR.4	W09C5.6
+Y45F10D.12	W09C5.6
+Y48B6A.2	W09C5.6
+Y48G8AL.8	W09C5.6
+Y57G11C.16	W09C5.6
+Y62E10A.1	W09C5.6
+Y71A12B.1	W09C5.6
+Y71F9AL.13	W09C5.6
+Y73B3A.18	W09C5.6
+ZC434.2	W09C5.6
+ZK1010.1	W09C5.6
+ZK652.4	W09C5.6
+Y106G6H.3	Y105E8A.16
+Y24D9A.4	Y105E8A.16
+Y37E3.7	Y105E8A.16
+Y37E3.8	Y105E8A.16
+Y41D4B.5	Y105E8A.16
+Y43B11AR.4	Y105E8A.16
+Y45F10D.12	Y105E8A.16
+Y48B6A.2	Y105E8A.16
+Y48G8AL.8	Y105E8A.16
+Y57G11C.16	Y105E8A.16
+Y62E10A.1	Y105E8A.16
+Y71A12B.1	Y105E8A.16
+Y71F9AL.13	Y105E8A.16
+Y73B3A.18	Y105E8A.16
+ZC434.2	Y105E8A.16
+ZK1010.1	Y105E8A.16
+ZK652.4	Y105E8A.16
+Y24D9A.4	Y106G6H.3
+Y37E3.7	Y106G6H.3
+Y37E3.8	Y106G6H.3
+Y41D4B.5	Y106G6H.3
+Y43B11AR.4	Y106G6H.3
+Y45F10D.12	Y106G6H.3
+Y48B6A.2	Y106G6H.3
+Y48G8AL.8	Y106G6H.3
+Y57G11C.16	Y106G6H.3
+Y62E10A.1	Y106G6H.3
+Y71A12B.1	Y106G6H.3
+Y71F9AL.13	Y106G6H.3
+Y73B3A.18	Y106G6H.3
+ZC434.2	Y106G6H.3
+ZK1010.1	Y106G6H.3
+ZK652.4	Y106G6H.3
+Y37E3.7	Y24D9A.4
+Y37E3.8	Y24D9A.4
+Y41D4B.5	Y24D9A.4
+Y43B11AR.4	Y24D9A.4
+Y45F10D.12	Y24D9A.4
+Y48B6A.2	Y24D9A.4
+Y48G8AL.8	Y24D9A.4
+Y57G11C.16	Y24D9A.4
+Y62E10A.1	Y24D9A.4
+Y71A12B.1	Y24D9A.4
+Y71F9AL.13	Y24D9A.4
+Y73B3A.18	Y24D9A.4
+ZC434.2	Y24D9A.4
+ZK1010.1	Y24D9A.4
+ZK652.4	Y24D9A.4
+Y37E3.8	Y37E3.7
+Y41D4B.5	Y37E3.7
+Y43B11AR.4	Y37E3.7
+Y45F10D.12	Y37E3.7
+Y48B6A.2	Y37E3.7
+Y48G8AL.8	Y37E3.7
+Y57G11C.16	Y37E3.7
+Y62E10A.1	Y37E3.7
+Y71A12B.1	Y37E3.7
+Y71F9AL.13	Y37E3.7
+Y73B3A.18	Y37E3.7
+ZC434.2	Y37E3.7
+ZK1010.1	Y37E3.7
+ZK652.4	Y37E3.7
+Y41D4B.5	Y37E3.8
+Y43B11AR.4	Y37E3.8
+Y45F10D.12	Y37E3.8
+Y48B6A.2	Y37E3.8
+Y48G8AL.8	Y37E3.8
+Y57G11C.16	Y37E3.8
+Y62E10A.1	Y37E3.8
+Y71A12B.1	Y37E3.8
+Y71F9AL.13	Y37E3.8
+Y73B3A.18	Y37E3.8
+ZC434.2	Y37E3.8
+ZK1010.1	Y37E3.8
+ZK652.4	Y37E3.8
+Y43B11AR.4	Y41D4B.5
+Y45F10D.12	Y41D4B.5
+Y48B6A.2	Y41D4B.5
+Y48G8AL.8	Y41D4B.5
+Y57G11C.16	Y41D4B.5
+Y62E10A.1	Y41D4B.5
+Y71A12B.1	Y41D4B.5
+Y71F9AL.13	Y41D4B.5
+Y73B3A.18	Y41D4B.5
+ZC434.2	Y41D4B.5
+ZK1010.1	Y41D4B.5
+ZK652.4	Y41D4B.5
+Y45F10D.12	Y43B11AR.4
+Y48B6A.2	Y43B11AR.4
+Y48G8AL.8	Y43B11AR.4
+Y57G11C.16	Y43B11AR.4
+Y62E10A.1	Y43B11AR.4
+Y71A12B.1	Y43B11AR.4
+Y71F9AL.13	Y43B11AR.4
+Y73B3A.18	Y43B11AR.4
+ZC434.2	Y43B11AR.4
+ZK1010.1	Y43B11AR.4
+ZK652.4	Y43B11AR.4
+Y48B6A.2	Y45F10D.12
+Y48G8AL.8	Y45F10D.12
+Y57G11C.16	Y45F10D.12
+Y62E10A.1	Y45F10D.12
+Y71A12B.1	Y45F10D.12
+Y71F9AL.13	Y45F10D.12
+Y73B3A.18	Y45F10D.12
+ZC434.2	Y45F10D.12
+ZK1010.1	Y45F10D.12
+ZK652.4	Y45F10D.12
+Y48G8AL.8	Y48B6A.2
+Y57G11C.16	Y48B6A.2
+Y62E10A.1	Y48B6A.2
+Y71A12B.1	Y48B6A.2
+Y71F9AL.13	Y48B6A.2
+Y73B3A.18	Y48B6A.2
+ZC434.2	Y48B6A.2
+ZK1010.1	Y48B6A.2
+ZK652.4	Y48B6A.2
+Y57G11C.16	Y48G8AL.8
+Y62E10A.1	Y48G8AL.8
+Y71A12B.1	Y48G8AL.8
+Y71F9AL.13	Y48G8AL.8
+Y73B3A.18	Y48G8AL.8
+ZC434.2	Y48G8AL.8
+ZK1010.1	Y48G8AL.8
+ZK652.4	Y48G8AL.8
+Y62E10A.1	Y57G11C.16
+Y71A12B.1	Y57G11C.16
+Y71F9AL.13	Y57G11C.16
+Y73B3A.18	Y57G11C.16
+ZC434.2	Y57G11C.16
+ZK1010.1	Y57G11C.16
+ZK652.4	Y57G11C.16
+Y71A12B.1	Y62E10A.1
+Y71F9AL.13	Y62E10A.1
+Y73B3A.18	Y62E10A.1
+ZC434.2	Y62E10A.1
+ZK1010.1	Y62E10A.1
+ZK652.4	Y62E10A.1
+Y71F9AL.13	Y71A12B.1
+Y73B3A.18	Y71A12B.1
+ZK1010.1	Y71A12B.1
+ZK652.4	Y71A12B.1
+Y73B3A.18	Y71F9AL.13
+ZC434.2	Y71F9AL.13
+ZK1010.1	Y71F9AL.13
+ZK652.4	Y71F9AL.13
+ZC434.2	Y73B3A.18
+ZK1010.1	Y73B3A.18
+ZK652.4	Y73B3A.18
+ZK1010.1	ZC434.2
+ZK652.4	ZC434.2
+ZK652.4	ZK1010.1
+B0348.6	B0240.4
+B0511.10	B0240.4
+B0513.2	B0240.4
+C01F6.5	B0240.4
+C01F6.8	B0240.4
+C02B10.4	B0240.4
+C03D6.4	B0240.4
+C05C10.2	B0240.4
+C05D11.9	B0240.4
+C05D9.5	B0240.4
+C15C6.4	B0240.4
+C15F1.4	B0240.4
+C15H11.3	B0240.4
+C15H11.6	B0240.4
+C16A3.8	B0240.4
+C16C10.4	B0240.4
+C24H11.5	B0240.4
+C27D11.1	B0240.4
+C29E4.3	B0240.4
+C29E4.4	B0240.4
+C34E10.5	B0240.4
+C37C3.2	B0240.4
+C41D11.2	B0240.4
+C41G7.1	B0240.4
+C43E11.1	B0240.4
+C44H9.4	B0240.4
+C49H3.10	B0240.4
+D1007.4	B0240.4
+D2013.7	B0240.4
+D2085.3	B0240.4
+E01G4.4	B0240.4
+E04A4.4	B0240.4
+F07A11.3	B0240.4
+F10E9.5	B0240.4
+F10G8.3	B0240.4
+F11A3.2	B0240.4
+F18H3.3	B0240.4
+F22B5.2	B0240.4
+F23B2.6	B0240.4
+F23F1.5	B0240.4
+F26A3.2	B0240.4
+F28B3.8	B0240.4
+F28D9.1	B0240.4
+F29B9.6	B0240.4
+F31E3.5	B0240.4
+F32H2.4	B0240.4
+F33D11.10	B0240.4
+F37E3.1	B0240.4
+F46B6.3	B0240.4
+F53A2.6	B0240.4
+F53F10.5	B0240.4
+F55B12.4	B0240.4
+F56A11.1	B0240.4
+F56A3.3	B0240.4
+F56D2.4	B0240.4
+F57B9.3	B0240.4
+F57B9.6	B0240.4
+F59A2.1	B0240.4
+H06H21.3	B0240.4
+H35B03.2	B0240.4
+K01G5.4	B0240.4
+K02F3.11	B0240.4
+K04G2.1	B0240.4
+K07F5.13	B0240.4
+K12C11.2	B0240.4
+K12D12.2	B0240.4
+M110.4	B0240.4
+M18.7	B0240.4
+R03G5.1	B0240.4
+R04A9.4	B0240.4
+R06F6.5	B0240.4
+R07E5.14	B0240.4
+R07G3.3	B0240.4
+R08D7.3	B0240.4
+R09B3.5	B0240.4
+R186.7	B0240.4
+T01G9.4	B0240.4
+T02H6.2	B0240.4
+T06A10.1	B0240.4
+T08G11.4	B0240.4
+T20G5.9	B0240.4
+T23D8.4	B0240.4
+T23H2.1	B0240.4
+T25G3.3	B0240.4
+T27F7.3	B0240.4
+W08E3.2	B0240.4
+Y106G6H.2	B0240.4
+Y32H12A.2	B0240.4
+Y37E3.10	B0240.4
+Y37E3.15	B0240.4
+Y39A3CR.1	B0240.4
+Y39G10AR.8	B0240.4
+Y40B1B.5	B0240.4
+Y41D4B.19	B0240.4
+Y43F4B.4	B0240.4
+Y47H9C.7	B0240.4
+Y48G8AL.6	B0240.4
+Y54E2A.11	B0240.4
+Y54F10BM.2	B0240.4
+Y57A10A.30	B0240.4
+Y62E10A.2	B0240.4
+Y65B4A.6	B0240.4
+Y66A7A.2	B0240.4
+Y71F9AM.5	B0240.4
+Y71H2B.2	B0240.4
+Y73B6BL.18	B0240.4
+Y74C10AR.1	B0240.4
+Y77E11A.13	B0240.4
+ZK1098.4	B0240.4
+ZK632.14	B0240.4
+ZK742.1	B0240.4
+B0511.10	B0348.6
+B0513.2	B0348.6
+C01F6.5	B0348.6
+C01F6.8	B0348.6
+C02B10.4	B0348.6
+C03D6.4	B0348.6
+C05C10.2	B0348.6
+C05D11.9	B0348.6
+C05D9.5	B0348.6
+C15C6.4	B0348.6
+C15F1.4	B0348.6
+C15H11.3	B0348.6
+C15H11.6	B0348.6
+C16A3.8	B0348.6
+C16C10.4	B0348.6
+C24H11.5	B0348.6
+C27D11.1	B0348.6
+C29E4.3	B0348.6
+C29E4.4	B0348.6
+C34E10.5	B0348.6
+C37C3.2	B0348.6
+C41D11.2	B0348.6
+C41G7.1	B0348.6
+C43E11.1	B0348.6
+C44H9.4	B0348.6
+C49H3.10	B0348.6
+D1007.4	B0348.6
+D2013.7	B0348.6
+D2085.3	B0348.6
+E01G4.4	B0348.6
+E04A4.4	B0348.6
+F07A11.3	B0348.6
+F10E9.5	B0348.6
+F10G8.3	B0348.6
+F11A3.2	B0348.6
+F18H3.3	B0348.6
+F22B5.2	B0348.6
+F23B2.6	B0348.6
+F23F1.5	B0348.6
+F26A3.2	B0348.6
+F28B3.8	B0348.6
+F28D9.1	B0348.6
+F29B9.6	B0348.6
+F31E3.5	B0348.6
+F32H2.4	B0348.6
+F33D11.10	B0348.6
+F37E3.1	B0348.6
+F46B6.3	B0348.6
+F53A2.6	B0348.6
+F53F10.5	B0348.6
+F55B12.4	B0348.6
+F56A11.1	B0348.6
+F56A3.3	B0348.6
+F56D2.4	B0348.6
+F57B9.3	B0348.6
+F57B9.6	B0348.6
+F59A2.1	B0348.6
+H06H21.3	B0348.6
+H35B03.2	B0348.6
+K01G5.4	B0348.6
+K02F3.11	B0348.6
+K04G2.1	B0348.6
+K07F5.13	B0348.6
+K12C11.2	B0348.6
+K12D12.2	B0348.6
+M110.4	B0348.6
+M18.7	B0348.6
+R03G5.1	B0348.6
+R04A9.4	B0348.6
+R06F6.5	B0348.6
+R07E5.14	B0348.6
+R07G3.3	B0348.6
+R08D7.3	B0348.6
+R09B3.5	B0348.6
+R186.7	B0348.6
+T01G9.4	B0348.6
+T02H6.2	B0348.6
+T06A10.1	B0348.6
+T08G11.4	B0348.6
+T20G5.9	B0348.6
+T23D8.4	B0348.6
+T23H2.1	B0348.6
+T25G3.3	B0348.6
+T27F7.3	B0348.6
+W08E3.2	B0348.6
+Y106G6H.2	B0348.6
+Y32H12A.2	B0348.6
+Y37E3.10	B0348.6
+Y37E3.15	B0348.6
+Y39A3CR.1	B0348.6
+Y39G10AR.8	B0348.6
+Y40B1B.5	B0348.6
+Y41D4B.19	B0348.6
+Y43F4B.4	B0348.6
+Y47H9C.7	B0348.6
+Y48G8AL.6	B0348.6
+Y54E2A.11	B0348.6
+Y54F10BM.2	B0348.6
+Y57A10A.30	B0348.6
+Y62E10A.2	B0348.6
+Y65B4A.6	B0348.6
+Y66A7A.2	B0348.6
+Y71F9AM.5	B0348.6
+Y71H2B.2	B0348.6
+Y73B6BL.18	B0348.6
+Y74C10AR.1	B0348.6
+Y77E11A.13	B0348.6
+ZK1098.4	B0348.6
+ZK632.14	B0348.6
+ZK742.1	B0348.6
+B0513.2	B0511.10
+C01F6.5	B0511.10
+C01F6.8	B0511.10
+C02B10.4	B0511.10
+C03D6.4	B0511.10
+C05C10.2	B0511.10
+C05D11.9	B0511.10
+C05D9.5	B0511.10
+C15C6.4	B0511.10
+C15F1.4	B0511.10
+C15H11.3	B0511.10
+C15H11.6	B0511.10
+C16A3.8	B0511.10
+C16C10.4	B0511.10
+C24H11.5	B0511.10
+C27D11.1	B0511.10
+C29E4.3	B0511.10
+C29E4.4	B0511.10
+C34E10.5	B0511.10
+C37C3.2	B0511.10
+C41D11.2	B0511.10
+C41G7.1	B0511.10
+C43E11.1	B0511.10
+C44H9.4	B0511.10
+C49H3.10	B0511.10
+D1007.4	B0511.10
+D2013.7	B0511.10
+D2085.3	B0511.10
+E01G4.4	B0511.10
+E04A4.4	B0511.10
+F07A11.3	B0511.10
+F10E9.5	B0511.10
+F10G8.3	B0511.10
+F11A3.2	B0511.10
+F18H3.3	B0511.10
+F22B5.2	B0511.10
+F23B2.6	B0511.10
+F23F1.5	B0511.10
+F26A3.2	B0511.10
+F28B3.8	B0511.10
+F28D9.1	B0511.10
+F29B9.6	B0511.10
+F31E3.5	B0511.10
+F32H2.4	B0511.10
+F33D11.10	B0511.10
+F37E3.1	B0511.10
+F46B6.3	B0511.10
+F53A2.6	B0511.10
+F53F10.5	B0511.10
+F55B12.4	B0511.10
+F56A11.1	B0511.10
+F56A3.3	B0511.10
+F56D2.4	B0511.10
+F57B9.3	B0511.10
+F57B9.6	B0511.10
+F59A2.1	B0511.10
+H06H21.3	B0511.10
+H35B03.2	B0511.10
+K01G5.4	B0511.10
+K02F3.11	B0511.10
+K04G2.1	B0511.10
+K07F5.13	B0511.10
+K12C11.2	B0511.10
+K12D12.2	B0511.10
+M110.4	B0511.10
+M18.7	B0511.10
+R03G5.1	B0511.10
+R04A9.4	B0511.10
+R06F6.5	B0511.10
+R07E5.14	B0511.10
+R07G3.3	B0511.10
+R08D7.3	B0511.10
+R09B3.5	B0511.10
+R186.7	B0511.10
+T01G9.4	B0511.10
+T02H6.2	B0511.10
+T06A10.1	B0511.10
+T08G11.4	B0511.10
+T20G5.9	B0511.10
+T23D8.4	B0511.10
+T23H2.1	B0511.10
+T25G3.3	B0511.10
+T27F7.3	B0511.10
+W08E3.2	B0511.10
+Y106G6H.2	B0511.10
+Y32H12A.2	B0511.10
+Y37E3.10	B0511.10
+Y37E3.15	B0511.10
+Y39A3CR.1	B0511.10
+Y39G10AR.8	B0511.10
+Y40B1B.5	B0511.10
+Y41D4B.19	B0511.10
+Y43F4B.4	B0511.10
+Y47H9C.7	B0511.10
+Y48G8AL.6	B0511.10
+Y54E2A.11	B0511.10
+Y54F10BM.2	B0511.10
+Y57A10A.30	B0511.10
+Y62E10A.2	B0511.10
+Y65B4A.6	B0511.10
+Y66A7A.2	B0511.10
+Y71F9AM.5	B0511.10
+Y71H2B.2	B0511.10
+Y73B6BL.18	B0511.10
+Y74C10AR.1	B0511.10
+Y77E11A.13	B0511.10
+ZK1098.4	B0511.10
+ZK632.14	B0511.10
+ZK742.1	B0511.10
+C01F6.5	B0513.2
+C01F6.8	B0513.2
+C02B10.4	B0513.2
+C03D6.4	B0513.2
+C05C10.2	B0513.2
+C05D11.9	B0513.2
+C05D9.5	B0513.2
+C15C6.4	B0513.2
+C15F1.4	B0513.2
+C15H11.3	B0513.2
+C15H11.6	B0513.2
+C16A3.8	B0513.2
+C16C10.4	B0513.2
+C24H11.5	B0513.2
+C27D11.1	B0513.2
+C29E4.3	B0513.2
+C29E4.4	B0513.2
+C34E10.5	B0513.2
+C37C3.2	B0513.2
+C41D11.2	B0513.2
+C41G7.1	B0513.2
+C43E11.1	B0513.2
+C44H9.4	B0513.2
+C49H3.10	B0513.2
+D1007.4	B0513.2
+D2013.7	B0513.2
+D2085.3	B0513.2
+E01G4.4	B0513.2
+E04A4.4	B0513.2
+F07A11.3	B0513.2
+F10E9.5	B0513.2
+F10G8.3	B0513.2
+F11A3.2	B0513.2
+F18H3.3	B0513.2
+F22B5.2	B0513.2
+F23B2.6	B0513.2
+F23F1.5	B0513.2
+F26A3.2	B0513.2
+F28B3.8	B0513.2
+F28D9.1	B0513.2
+F29B9.6	B0513.2
+F31E3.5	B0513.2
+F32H2.4	B0513.2
+F33D11.10	B0513.2
+F37E3.1	B0513.2
+F46B6.3	B0513.2
+F53A2.6	B0513.2
+F53F10.5	B0513.2
+F55B12.4	B0513.2
+F56A11.1	B0513.2
+F56A3.3	B0513.2
+F56D2.4	B0513.2
+F57B9.3	B0513.2
+F57B9.6	B0513.2
+F59A2.1	B0513.2
+H06H21.3	B0513.2
+H35B03.2	B0513.2
+K01G5.4	B0513.2
+K02F3.11	B0513.2
+K04G2.1	B0513.2
+K07F5.13	B0513.2
+K12C11.2	B0513.2
+K12D12.2	B0513.2
+M110.4	B0513.2
+M18.7	B0513.2
+R03G5.1	B0513.2
+R04A9.4	B0513.2
+R06F6.5	B0513.2
+R07E5.14	B0513.2
+R07G3.3	B0513.2
+R08D7.3	B0513.2
+R09B3.5	B0513.2
+R186.7	B0513.2
+T01G9.4	B0513.2
+T02H6.2	B0513.2
+T06A10.1	B0513.2
+T08G11.4	B0513.2
+T20G5.9	B0513.2
+T23D8.4	B0513.2
+T23H2.1	B0513.2
+T25G3.3	B0513.2
+T27F7.3	B0513.2
+W08E3.2	B0513.2
+Y106G6H.2	B0513.2
+Y32H12A.2	B0513.2
+Y37E3.10	B0513.2
+Y37E3.15	B0513.2
+Y39A3CR.1	B0513.2
+Y39G10AR.8	B0513.2
+Y40B1B.5	B0513.2
+Y41D4B.19	B0513.2
+Y43F4B.4	B0513.2
+Y47H9C.7	B0513.2
+Y48G8AL.6	B0513.2
+Y54E2A.11	B0513.2
+Y54F10BM.2	B0513.2
+Y57A10A.30	B0513.2
+Y62E10A.2	B0513.2
+Y65B4A.6	B0513.2
+Y66A7A.2	B0513.2
+Y71F9AM.5	B0513.2
+Y71H2B.2	B0513.2
+Y73B6BL.18	B0513.2
+Y74C10AR.1	B0513.2
+Y77E11A.13	B0513.2
+ZK1098.4	B0513.2
+ZK632.14	B0513.2
+ZK742.1	B0513.2
+C01F6.8	C01F6.5
+C02B10.4	C01F6.5
+C03D6.4	C01F6.5
+C05C10.2	C01F6.5
+C05D11.9	C01F6.5
+C05D9.5	C01F6.5
+C15C6.4	C01F6.5
+C15F1.4	C01F6.5
+C15H11.3	C01F6.5
+C15H11.6	C01F6.5
+C16A3.8	C01F6.5
+C16C10.4	C01F6.5
+C24H11.5	C01F6.5
+C27D11.1	C01F6.5
+C29E4.3	C01F6.5
+C29E4.4	C01F6.5
+C34E10.5	C01F6.5
+C37C3.2	C01F6.5
+C41D11.2	C01F6.5
+C41G7.1	C01F6.5
+C43E11.1	C01F6.5
+C44H9.4	C01F6.5
+C49H3.10	C01F6.5
+D1007.4	C01F6.5
+D2013.7	C01F6.5
+D2085.3	C01F6.5
+E01G4.4	C01F6.5
+E04A4.4	C01F6.5
+F07A11.3	C01F6.5
+F10E9.5	C01F6.5
+F10G8.3	C01F6.5
+F11A3.2	C01F6.5
+F18H3.3	C01F6.5
+F22B5.2	C01F6.5
+F23B2.6	C01F6.5
+F23F1.5	C01F6.5
+F26A3.2	C01F6.5
+F28B3.8	C01F6.5
+F28D9.1	C01F6.5
+F29B9.6	C01F6.5
+F31E3.5	C01F6.5
+F32H2.4	C01F6.5
+F33D11.10	C01F6.5
+F37E3.1	C01F6.5
+F46B6.3	C01F6.5
+F53A2.6	C01F6.5
+F53F10.5	C01F6.5
+F55B12.4	C01F6.5
+F56A11.1	C01F6.5
+F56A3.3	C01F6.5
+F56D2.4	C01F6.5
+F57B9.3	C01F6.5
+F57B9.6	C01F6.5
+F59A2.1	C01F6.5
+H06H21.3	C01F6.5
+H35B03.2	C01F6.5
+K01G5.4	C01F6.5
+K02F3.11	C01F6.5
+K04G2.1	C01F6.5
+K07F5.13	C01F6.5
+K12C11.2	C01F6.5
+K12D12.2	C01F6.5
+M110.4	C01F6.5
+M18.7	C01F6.5
+R03G5.1	C01F6.5
+R04A9.4	C01F6.5
+R06F6.5	C01F6.5
+R07E5.14	C01F6.5
+R07G3.3	C01F6.5
+R08D7.3	C01F6.5
+R09B3.5	C01F6.5
+R186.7	C01F6.5
+T01G9.4	C01F6.5
+T02H6.2	C01F6.5
+T06A10.1	C01F6.5
+T08G11.4	C01F6.5
+T20G5.9	C01F6.5
+T23D8.4	C01F6.5
+T23H2.1	C01F6.5
+T25G3.3	C01F6.5
+T27F7.3	C01F6.5
+W08E3.2	C01F6.5
+Y106G6H.2	C01F6.5
+Y32H12A.2	C01F6.5
+Y37E3.10	C01F6.5
+Y37E3.15	C01F6.5
+Y39A3CR.1	C01F6.5
+Y39G10AR.8	C01F6.5
+Y40B1B.5	C01F6.5
+Y41D4B.19	C01F6.5
+Y43F4B.4	C01F6.5
+Y47H9C.7	C01F6.5
+Y48G8AL.6	C01F6.5
+Y54E2A.11	C01F6.5
+Y54F10BM.2	C01F6.5
+Y57A10A.30	C01F6.5
+Y62E10A.2	C01F6.5
+Y65B4A.6	C01F6.5
+Y66A7A.2	C01F6.5
+Y71F9AM.5	C01F6.5
+Y71H2B.2	C01F6.5
+Y73B6BL.18	C01F6.5
+Y74C10AR.1	C01F6.5
+Y77E11A.13	C01F6.5
+ZK1098.4	C01F6.5
+ZK632.14	C01F6.5
+ZK742.1	C01F6.5
+C02B10.4	C01F6.8
+C03D6.4	C01F6.8
+C05C10.2	C01F6.8
+C05D11.9	C01F6.8
+C05D9.5	C01F6.8
+C15C6.4	C01F6.8
+C15F1.4	C01F6.8
+C15H11.3	C01F6.8
+C15H11.6	C01F6.8
+C16A3.8	C01F6.8
+C16C10.4	C01F6.8
+C24H11.5	C01F6.8
+C27D11.1	C01F6.8
+C29E4.3	C01F6.8
+C29E4.4	C01F6.8
+C34E10.5	C01F6.8
+C37C3.2	C01F6.8
+C41D11.2	C01F6.8
+C41G7.1	C01F6.8
+C43E11.1	C01F6.8
+C44H9.4	C01F6.8
+C49H3.10	C01F6.8
+D1007.4	C01F6.8
+D2013.7	C01F6.8
+D2085.3	C01F6.8
+E01G4.4	C01F6.8
+E04A4.4	C01F6.8
+F07A11.3	C01F6.8
+F10E9.5	C01F6.8
+F10G8.3	C01F6.8
+F11A3.2	C01F6.8
+F18H3.3	C01F6.8
+F22B5.2	C01F6.8
+F23B2.6	C01F6.8
+F23F1.5	C01F6.8
+F26A3.2	C01F6.8
+F28B3.8	C01F6.8
+F28D9.1	C01F6.8
+F29B9.6	C01F6.8
+F31E3.5	C01F6.8
+F32H2.4	C01F6.8
+F33D11.10	C01F6.8
+F37E3.1	C01F6.8
+F46B6.3	C01F6.8
+F53A2.6	C01F6.8
+F53F10.5	C01F6.8
+F55B12.4	C01F6.8
+F56A11.1	C01F6.8
+F56A3.3	C01F6.8
+F56D2.4	C01F6.8
+F57B9.3	C01F6.8
+F57B9.6	C01F6.8
+F59A2.1	C01F6.8
+H06H21.3	C01F6.8
+H35B03.2	C01F6.8
+K01G5.4	C01F6.8
+K02F3.11	C01F6.8
+K04G2.1	C01F6.8
+K07F5.13	C01F6.8
+K12C11.2	C01F6.8
+K12D12.2	C01F6.8
+M110.4	C01F6.8
+M18.7	C01F6.8
+R03G5.1	C01F6.8
+R04A9.4	C01F6.8
+R06F6.5	C01F6.8
+R07E5.14	C01F6.8
+R07G3.3	C01F6.8
+R08D7.3	C01F6.8
+R09B3.5	C01F6.8
+R186.7	C01F6.8
+T01G9.4	C01F6.8
+T02H6.2	C01F6.8
+T06A10.1	C01F6.8
+T08G11.4	C01F6.8
+T20G5.9	C01F6.8
+T23D8.4	C01F6.8
+T23H2.1	C01F6.8
+T25G3.3	C01F6.8
+T27F7.3	C01F6.8
+W08E3.2	C01F6.8
+Y106G6H.2	C01F6.8
+Y32H12A.2	C01F6.8
+Y37E3.10	C01F6.8
+Y37E3.15	C01F6.8
+Y39A3CR.1	C01F6.8
+Y39G10AR.8	C01F6.8
+Y40B1B.5	C01F6.8
+Y41D4B.19	C01F6.8
+Y43F4B.4	C01F6.8
+Y47H9C.7	C01F6.8
+Y48G8AL.6	C01F6.8
+Y54E2A.11	C01F6.8
+Y54F10BM.2	C01F6.8
+Y57A10A.30	C01F6.8
+Y62E10A.2	C01F6.8
+Y65B4A.6	C01F6.8
+Y66A7A.2	C01F6.8
+Y71F9AM.5	C01F6.8
+Y71H2B.2	C01F6.8
+Y73B6BL.18	C01F6.8
+Y74C10AR.1	C01F6.8
+Y77E11A.13	C01F6.8
+ZK1098.4	C01F6.8
+ZK632.14	C01F6.8
+ZK742.1	C01F6.8
+C03D6.4	C02B10.4
+C05C10.2	C02B10.4
+C05D11.9	C02B10.4
+C05D9.5	C02B10.4
+C15C6.4	C02B10.4
+C15F1.4	C02B10.4
+C15H11.3	C02B10.4
+C15H11.6	C02B10.4
+C16A3.8	C02B10.4
+C16C10.4	C02B10.4
+C24H11.5	C02B10.4
+C27D11.1	C02B10.4
+C29E4.3	C02B10.4
+C29E4.4	C02B10.4
+C34E10.5	C02B10.4
+C37C3.2	C02B10.4
+C41D11.2	C02B10.4
+C41G7.1	C02B10.4
+C43E11.1	C02B10.4
+C44H9.4	C02B10.4
+C49H3.10	C02B10.4
+D1007.4	C02B10.4
+D2013.7	C02B10.4
+D2085.3	C02B10.4
+E01G4.4	C02B10.4
+E04A4.4	C02B10.4
+F07A11.3	C02B10.4
+F10E9.5	C02B10.4
+F10G8.3	C02B10.4
+F11A3.2	C02B10.4
+F18H3.3	C02B10.4
+F22B5.2	C02B10.4
+F23B2.6	C02B10.4
+F23F1.5	C02B10.4
+F26A3.2	C02B10.4
+F28B3.8	C02B10.4
+F28D9.1	C02B10.4
+F29B9.6	C02B10.4
+F31E3.5	C02B10.4
+F32H2.4	C02B10.4
+F33D11.10	C02B10.4
+F37E3.1	C02B10.4
+F46B6.3	C02B10.4
+F53A2.6	C02B10.4
+F53F10.5	C02B10.4
+F55B12.4	C02B10.4
+F56A11.1	C02B10.4
+F56A3.3	C02B10.4
+F56D2.4	C02B10.4
+F57B9.3	C02B10.4
+F57B9.6	C02B10.4
+F59A2.1	C02B10.4
+H06H21.3	C02B10.4
+H35B03.2	C02B10.4
+K01G5.4	C02B10.4
+K02F3.11	C02B10.4
+K04G2.1	C02B10.4
+K07F5.13	C02B10.4
+K12C11.2	C02B10.4
+K12D12.2	C02B10.4
+M110.4	C02B10.4
+M18.7	C02B10.4
+R03G5.1	C02B10.4
+R04A9.4	C02B10.4
+R06F6.5	C02B10.4
+R07E5.14	C02B10.4
+R07G3.3	C02B10.4
+R08D7.3	C02B10.4
+R09B3.5	C02B10.4
+R186.7	C02B10.4
+T01G9.4	C02B10.4
+T02H6.2	C02B10.4
+T06A10.1	C02B10.4
+T08G11.4	C02B10.4
+T20G5.9	C02B10.4
+T23D8.4	C02B10.4
+T23H2.1	C02B10.4
+T25G3.3	C02B10.4
+T27F7.3	C02B10.4
+W08E3.2	C02B10.4
+Y106G6H.2	C02B10.4
+Y32H12A.2	C02B10.4
+Y37E3.10	C02B10.4
+Y37E3.15	C02B10.4
+Y39A3CR.1	C02B10.4
+Y39G10AR.8	C02B10.4
+Y40B1B.5	C02B10.4
+Y41D4B.19	C02B10.4
+Y43F4B.4	C02B10.4
+Y47H9C.7	C02B10.4
+Y48G8AL.6	C02B10.4
+Y54E2A.11	C02B10.4
+Y54F10BM.2	C02B10.4
+Y57A10A.30	C02B10.4
+Y62E10A.2	C02B10.4
+Y65B4A.6	C02B10.4
+Y66A7A.2	C02B10.4
+Y71F9AM.5	C02B10.4
+Y71H2B.2	C02B10.4
+Y73B6BL.18	C02B10.4
+Y74C10AR.1	C02B10.4
+Y77E11A.13	C02B10.4
+ZK1098.4	C02B10.4
+ZK632.14	C02B10.4
+ZK742.1	C02B10.4
+C05C10.2	C03D6.4
+C05D11.9	C03D6.4
+C05D9.5	C03D6.4
+C15C6.4	C03D6.4
+C15F1.4	C03D6.4
+C15H11.3	C03D6.4
+C15H11.6	C03D6.4
+C16A3.8	C03D6.4
+C16C10.4	C03D6.4
+C24H11.5	C03D6.4
+C27D11.1	C03D6.4
+C29E4.3	C03D6.4
+C29E4.4	C03D6.4
+C34E10.5	C03D6.4
+C37C3.2	C03D6.4
+C41D11.2	C03D6.4
+C41G7.1	C03D6.4
+C43E11.1	C03D6.4
+C44H9.4	C03D6.4
+C49H3.10	C03D6.4
+D1007.4	C03D6.4
+D2013.7	C03D6.4
+D2085.3	C03D6.4
+E01G4.4	C03D6.4
+E04A4.4	C03D6.4
+F07A11.3	C03D6.4
+F10E9.5	C03D6.4
+F10G8.3	C03D6.4
+F11A3.2	C03D6.4
+F18H3.3	C03D6.4
+F22B5.2	C03D6.4
+F23B2.6	C03D6.4
+F23F1.5	C03D6.4
+F26A3.2	C03D6.4
+F28B3.8	C03D6.4
+F28D9.1	C03D6.4
+F29B9.6	C03D6.4
+F31E3.5	C03D6.4
+F32H2.4	C03D6.4
+F33D11.10	C03D6.4
+F37E3.1	C03D6.4
+F46B6.3	C03D6.4
+F53A2.6	C03D6.4
+F53F10.5	C03D6.4
+F55B12.4	C03D6.4
+F56A11.1	C03D6.4
+F56A3.3	C03D6.4
+F56D2.4	C03D6.4
+F57B9.3	C03D6.4
+F57B9.6	C03D6.4
+F59A2.1	C03D6.4
+H06H21.3	C03D6.4
+H35B03.2	C03D6.4
+K01G5.4	C03D6.4
+K02F3.11	C03D6.4
+K04G2.1	C03D6.4
+K07F5.13	C03D6.4
+K12C11.2	C03D6.4
+K12D12.2	C03D6.4
+M110.4	C03D6.4
+M18.7	C03D6.4
+R03G5.1	C03D6.4
+R04A9.4	C03D6.4
+R06F6.5	C03D6.4
+R07E5.14	C03D6.4
+R07G3.3	C03D6.4
+R08D7.3	C03D6.4
+R09B3.5	C03D6.4
+R186.7	C03D6.4
+T01G9.4	C03D6.4
+T02H6.2	C03D6.4
+T06A10.1	C03D6.4
+T08G11.4	C03D6.4
+T20G5.9	C03D6.4
+T23D8.4	C03D6.4
+T23H2.1	C03D6.4
+T25G3.3	C03D6.4
+T27F7.3	C03D6.4
+W08E3.2	C03D6.4
+Y106G6H.2	C03D6.4
+Y32H12A.2	C03D6.4
+Y37E3.10	C03D6.4
+Y37E3.15	C03D6.4
+Y39A3CR.1	C03D6.4
+Y39G10AR.8	C03D6.4
+Y40B1B.5	C03D6.4
+Y41D4B.19	C03D6.4
+Y43F4B.4	C03D6.4
+Y47H9C.7	C03D6.4
+Y48G8AL.6	C03D6.4
+Y54E2A.11	C03D6.4
+Y54F10BM.2	C03D6.4
+Y57A10A.30	C03D6.4
+Y62E10A.2	C03D6.4
+Y65B4A.6	C03D6.4
+Y66A7A.2	C03D6.4
+Y71F9AM.5	C03D6.4
+Y71H2B.2	C03D6.4
+Y73B6BL.18	C03D6.4
+Y74C10AR.1	C03D6.4
+Y77E11A.13	C03D6.4
+ZK1098.4	C03D6.4
+ZK632.14	C03D6.4
+ZK742.1	C03D6.4
+C05D11.9	C05C10.2
+C05D9.5	C05C10.2
+C15C6.4	C05C10.2
+C15F1.4	C05C10.2
+C15H11.3	C05C10.2
+C15H11.6	C05C10.2
+C16A3.8	C05C10.2
+C16C10.4	C05C10.2
+C24H11.5	C05C10.2
+C27D11.1	C05C10.2
+C29E4.3	C05C10.2
+C29E4.4	C05C10.2
+C34E10.5	C05C10.2
+C37C3.2	C05C10.2
+C41D11.2	C05C10.2
+C41G7.1	C05C10.2
+C43E11.1	C05C10.2
+C44H9.4	C05C10.2
+C49H3.10	C05C10.2
+D1007.4	C05C10.2
+D2013.7	C05C10.2
+D2085.3	C05C10.2
+E01G4.4	C05C10.2
+E04A4.4	C05C10.2
+F07A11.3	C05C10.2
+F10E9.5	C05C10.2
+F10G8.3	C05C10.2
+F11A3.2	C05C10.2
+F18H3.3	C05C10.2
+F22B5.2	C05C10.2
+F23B2.6	C05C10.2
+F23F1.5	C05C10.2
+F26A3.2	C05C10.2
+F28B3.8	C05C10.2
+F28D9.1	C05C10.2
+F29B9.6	C05C10.2
+F31E3.5	C05C10.2
+F32H2.4	C05C10.2
+F33D11.10	C05C10.2
+F37E3.1	C05C10.2
+F46B6.3	C05C10.2
+F53A2.6	C05C10.2
+F53F10.5	C05C10.2
+F55B12.4	C05C10.2
+F56A11.1	C05C10.2
+F56A3.3	C05C10.2
+F56D2.4	C05C10.2
+F57B9.3	C05C10.2
+F57B9.6	C05C10.2
+F59A2.1	C05C10.2
+H06H21.3	C05C10.2
+H35B03.2	C05C10.2
+K01G5.4	C05C10.2
+K02F3.11	C05C10.2
+K04G2.1	C05C10.2
+K07F5.13	C05C10.2
+K12C11.2	C05C10.2
+K12D12.2	C05C10.2
+M110.4	C05C10.2
+M18.7	C05C10.2
+R03G5.1	C05C10.2
+R04A9.4	C05C10.2
+R06F6.5	C05C10.2
+R07E5.14	C05C10.2
+R07G3.3	C05C10.2
+R08D7.3	C05C10.2
+R09B3.5	C05C10.2
+R186.7	C05C10.2
+T01G9.4	C05C10.2
+T02H6.2	C05C10.2
+T06A10.1	C05C10.2
+T08G11.4	C05C10.2
+T20G5.9	C05C10.2
+T23D8.4	C05C10.2
+T23H2.1	C05C10.2
+T25G3.3	C05C10.2
+T27F7.3	C05C10.2
+W08E3.2	C05C10.2
+Y106G6H.2	C05C10.2
+Y32H12A.2	C05C10.2
+Y37E3.10	C05C10.2
+Y37E3.15	C05C10.2
+Y39A3CR.1	C05C10.2
+Y39G10AR.8	C05C10.2
+Y40B1B.5	C05C10.2
+Y41D4B.19	C05C10.2
+Y43F4B.4	C05C10.2
+Y47H9C.7	C05C10.2
+Y48G8AL.6	C05C10.2
+Y54E2A.11	C05C10.2
+Y54F10BM.2	C05C10.2
+Y57A10A.30	C05C10.2
+Y62E10A.2	C05C10.2
+Y65B4A.6	C05C10.2
+Y66A7A.2	C05C10.2
+Y71F9AM.5	C05C10.2
+Y71H2B.2	C05C10.2
+Y73B6BL.18	C05C10.2
+Y74C10AR.1	C05C10.2
+Y77E11A.13	C05C10.2
+ZK1098.4	C05C10.2
+ZK632.14	C05C10.2
+ZK742.1	C05C10.2
+C05D9.5	C05D11.9
+C15F1.4	C05D11.9
+C16A3.8	C05D11.9
+C16C10.4	C05D11.9
+C24H11.5	C05D11.9
+C27D11.1	C05D11.9
+C29E4.3	C05D11.9
+C29E4.4	C05D11.9
+C34E10.5	C05D11.9
+C37C3.2	C05D11.9
+C41D11.2	C05D11.9
+C41G7.1	C05D11.9
+C43E11.1	C05D11.9
+C44H9.4	C05D11.9
+C49H3.10	C05D11.9
+D1007.4	C05D11.9
+D2013.7	C05D11.9
+D2085.3	C05D11.9
+E01G4.4	C05D11.9
+E04A4.4	C05D11.9
+F07A11.3	C05D11.9
+F10E9.5	C05D11.9
+F10G8.3	C05D11.9
+F11A3.2	C05D11.9
+F18H3.3	C05D11.9
+F22B5.2	C05D11.9
+F23B2.6	C05D11.9
+F23F1.5	C05D11.9
+F26A3.2	C05D11.9
+F28B3.8	C05D11.9
+F28D9.1	C05D11.9
+F29B9.6	C05D11.9
+F31E3.5	C05D11.9
+F32H2.4	C05D11.9
+F33D11.10	C05D11.9
+F37E3.1	C05D11.9
+F46B6.3	C05D11.9
+F53A2.6	C05D11.9
+F53F10.5	C05D11.9
+F55B12.4	C05D11.9
+F56A11.1	C05D11.9
+F56A3.3	C05D11.9
+F56D2.4	C05D11.9
+F57B9.3	C05D11.9
+F57B9.6	C05D11.9
+F59A2.1	C05D11.9
+H06H21.3	C05D11.9
+K02F3.11	C05D11.9
+K04G2.1	C05D11.9
+K07F5.13	C05D11.9
+K12C11.2	C05D11.9
+K12D12.2	C05D11.9
+M110.4	C05D11.9
+M18.7	C05D11.9
+R03G5.1	C05D11.9
+R04A9.4	C05D11.9
+R06F6.5	C05D11.9
+R07E5.14	C05D11.9
+R07G3.3	C05D11.9
+R08D7.3	C05D11.9
+R09B3.5	C05D11.9
+R186.7	C05D11.9
+T01G9.4	C05D11.9
+T02H6.2	C05D11.9
+T06A10.1	C05D11.9
+T08G11.4	C05D11.9
+T20G5.9	C05D11.9
+T23D8.4	C05D11.9
+T23H2.1	C05D11.9
+T27F7.3	C05D11.9
+W08E3.2	C05D11.9
+Y106G6H.2	C05D11.9
+Y32H12A.2	C05D11.9
+Y37E3.10	C05D11.9
+Y37E3.15	C05D11.9
+Y39A3CR.1	C05D11.9
+Y39G10AR.8	C05D11.9
+Y40B1B.5	C05D11.9
+Y41D4B.19	C05D11.9
+Y43F4B.4	C05D11.9
+Y47H9C.7	C05D11.9
+Y48G8AL.6	C05D11.9
+Y54E2A.11	C05D11.9
+Y54F10BM.2	C05D11.9
+Y57A10A.30	C05D11.9
+Y65B4A.6	C05D11.9
+Y71H2B.2	C05D11.9
+Y73B6BL.18	C05D11.9
+Y74C10AR.1	C05D11.9
+Y77E11A.13	C05D11.9
+ZK1098.4	C05D11.9
+C15C6.4	C05D9.5
+C15F1.4	C05D9.5
+C15H11.3	C05D9.5
+C15H11.6	C05D9.5
+C16A3.8	C05D9.5
+C16C10.4	C05D9.5
+C24H11.5	C05D9.5
+C27D11.1	C05D9.5
+C29E4.3	C05D9.5
+C29E4.4	C05D9.5
+C34E10.5	C05D9.5
+C37C3.2	C05D9.5
+C41D11.2	C05D9.5
+C41G7.1	C05D9.5
+C43E11.1	C05D9.5
+C44H9.4	C05D9.5
+C49H3.10	C05D9.5
+D1007.4	C05D9.5
+D2013.7	C05D9.5
+D2085.3	C05D9.5
+E01G4.4	C05D9.5
+E04A4.4	C05D9.5
+F07A11.3	C05D9.5
+F10E9.5	C05D9.5
+F10G8.3	C05D9.5
+F11A3.2	C05D9.5
+F18H3.3	C05D9.5
+F22B5.2	C05D9.5
+F23B2.6	C05D9.5
+F23F1.5	C05D9.5
+F26A3.2	C05D9.5
+F28B3.8	C05D9.5
+F28D9.1	C05D9.5
+F29B9.6	C05D9.5
+F31E3.5	C05D9.5
+F32H2.4	C05D9.5
+F33D11.10	C05D9.5
+F37E3.1	C05D9.5
+F46B6.3	C05D9.5
+F53A2.6	C05D9.5
+F53F10.5	C05D9.5
+F55B12.4	C05D9.5
+F56A11.1	C05D9.5
+F56A3.3	C05D9.5
+F56D2.4	C05D9.5
+F57B9.3	C05D9.5
+F57B9.6	C05D9.5
+F59A2.1	C05D9.5
+H06H21.3	C05D9.5
+H35B03.2	C05D9.5
+K01G5.4	C05D9.5
+K02F3.11	C05D9.5
+K04G2.1	C05D9.5
+K07F5.13	C05D9.5
+K12C11.2	C05D9.5
+K12D12.2	C05D9.5
+M110.4	C05D9.5
+M18.7	C05D9.5
+R03G5.1	C05D9.5
+R04A9.4	C05D9.5
+R06F6.5	C05D9.5
+R07E5.14	C05D9.5
+R07G3.3	C05D9.5
+R08D7.3	C05D9.5
+R09B3.5	C05D9.5
+R186.7	C05D9.5
+T01G9.4	C05D9.5
+T02H6.2	C05D9.5
+T06A10.1	C05D9.5
+T08G11.4	C05D9.5
+T20G5.9	C05D9.5
+T23D8.4	C05D9.5
+T23H2.1	C05D9.5
+T25G3.3	C05D9.5
+T27F7.3	C05D9.5
+W08E3.2	C05D9.5
+Y106G6H.2	C05D9.5
+Y32H12A.2	C05D9.5
+Y37E3.10	C05D9.5
+Y37E3.15	C05D9.5
+Y39A3CR.1	C05D9.5
+Y39G10AR.8	C05D9.5
+Y40B1B.5	C05D9.5
+Y41D4B.19	C05D9.5
+Y43F4B.4	C05D9.5
+Y47H9C.7	C05D9.5
+Y48G8AL.6	C05D9.5
+Y54E2A.11	C05D9.5
+Y54F10BM.2	C05D9.5
+Y57A10A.30	C05D9.5
+Y62E10A.2	C05D9.5
+Y65B4A.6	C05D9.5
+Y66A7A.2	C05D9.5
+Y71F9AM.5	C05D9.5
+Y71H2B.2	C05D9.5
+Y73B6BL.18	C05D9.5
+Y74C10AR.1	C05D9.5
+Y77E11A.13	C05D9.5
+ZK1098.4	C05D9.5
+ZK632.14	C05D9.5
+ZK742.1	C05D9.5
+C15F1.4	C15C6.4
+C16A3.8	C15C6.4
+C16C10.4	C15C6.4
+C24H11.5	C15C6.4
+C27D11.1	C15C6.4
+C29E4.3	C15C6.4
+C29E4.4	C15C6.4
+C34E10.5	C15C6.4
+C37C3.2	C15C6.4
+C41D11.2	C15C6.4
+C41G7.1	C15C6.4
+C43E11.1	C15C6.4
+C44H9.4	C15C6.4
+C49H3.10	C15C6.4
+D1007.4	C15C6.4
+D2013.7	C15C6.4
+D2085.3	C15C6.4
+E01G4.4	C15C6.4
+E04A4.4	C15C6.4
+F07A11.3	C15C6.4
+F10E9.5	C15C6.4
+F10G8.3	C15C6.4
+F11A3.2	C15C6.4
+F18H3.3	C15C6.4
+F22B5.2	C15C6.4
+F23B2.6	C15C6.4
+F23F1.5	C15C6.4
+F26A3.2	C15C6.4
+F28B3.8	C15C6.4
+F28D9.1	C15C6.4
+F29B9.6	C15C6.4
+F31E3.5	C15C6.4
+F32H2.4	C15C6.4
+F33D11.10	C15C6.4
+F37E3.1	C15C6.4
+F46B6.3	C15C6.4
+F53A2.6	C15C6.4
+F53F10.5	C15C6.4
+F55B12.4	C15C6.4
+F56A11.1	C15C6.4
+F56A3.3	C15C6.4
+F56D2.4	C15C6.4
+F57B9.3	C15C6.4
+F57B9.6	C15C6.4
+F59A2.1	C15C6.4
+H06H21.3	C15C6.4
+K02F3.11	C15C6.4
+K04G2.1	C15C6.4
+K07F5.13	C15C6.4
+K12C11.2	C15C6.4
+K12D12.2	C15C6.4
+M110.4	C15C6.4
+M18.7	C15C6.4
+R03G5.1	C15C6.4
+R04A9.4	C15C6.4
+R06F6.5	C15C6.4
+R07E5.14	C15C6.4
+R07G3.3	C15C6.4
+R08D7.3	C15C6.4
+R09B3.5	C15C6.4
+R186.7	C15C6.4
+T01G9.4	C15C6.4
+T02H6.2	C15C6.4
+T06A10.1	C15C6.4
+T08G11.4	C15C6.4
+T20G5.9	C15C6.4
+T23D8.4	C15C6.4
+T23H2.1	C15C6.4
+T27F7.3	C15C6.4
+W08E3.2	C15C6.4
+Y106G6H.2	C15C6.4
+Y32H12A.2	C15C6.4
+Y37E3.10	C15C6.4
+Y37E3.15	C15C6.4
+Y39A3CR.1	C15C6.4
+Y39G10AR.8	C15C6.4
+Y40B1B.5	C15C6.4
+Y41D4B.19	C15C6.4
+Y43F4B.4	C15C6.4
+Y47H9C.7	C15C6.4
+Y48G8AL.6	C15C6.4
+Y54E2A.11	C15C6.4
+Y54F10BM.2	C15C6.4
+Y57A10A.30	C15C6.4
+Y65B4A.6	C15C6.4
+Y71H2B.2	C15C6.4
+Y73B6BL.18	C15C6.4
+Y74C10AR.1	C15C6.4
+Y77E11A.13	C15C6.4
+ZK1098.4	C15C6.4
+C15H11.3	C15F1.4
+C15H11.6	C15F1.4
+C16A3.8	C15F1.4
+C16C10.4	C15F1.4
+C24H11.5	C15F1.4
+C27D11.1	C15F1.4
+C29E4.3	C15F1.4
+C29E4.4	C15F1.4
+C34E10.5	C15F1.4
+C37C3.2	C15F1.4
+C41D11.2	C15F1.4
+C41G7.1	C15F1.4
+C43E11.1	C15F1.4
+C44H9.4	C15F1.4
+C49H3.10	C15F1.4
+D1007.4	C15F1.4
+D2013.7	C15F1.4
+D2085.3	C15F1.4
+E01G4.4	C15F1.4
+E04A4.4	C15F1.4
+F07A11.3	C15F1.4
+F10E9.5	C15F1.4
+F10G8.3	C15F1.4
+F11A3.2	C15F1.4
+F18H3.3	C15F1.4
+F22B5.2	C15F1.4
+F23B2.6	C15F1.4
+F23F1.5	C15F1.4
+F26A3.2	C15F1.4
+F28B3.8	C15F1.4
+F28D9.1	C15F1.4
+F29B9.6	C15F1.4
+F31E3.5	C15F1.4
+F32H2.4	C15F1.4
+F33D11.10	C15F1.4
+F37E3.1	C15F1.4
+F46B6.3	C15F1.4
+F53A2.6	C15F1.4
+F53F10.5	C15F1.4
+F55B12.4	C15F1.4
+F56A11.1	C15F1.4
+F56A3.3	C15F1.4
+F56D2.4	C15F1.4
+F57B9.3	C15F1.4
+F57B9.6	C15F1.4
+F59A2.1	C15F1.4
+H06H21.3	C15F1.4
+H35B03.2	C15F1.4
+K01G5.4	C15F1.4
+K02F3.11	C15F1.4
+K04G2.1	C15F1.4
+K07F5.13	C15F1.4
+K12C11.2	C15F1.4
+K12D12.2	C15F1.4
+M110.4	C15F1.4
+M18.7	C15F1.4
+R03G5.1	C15F1.4
+R04A9.4	C15F1.4
+R06F6.5	C15F1.4
+R07E5.14	C15F1.4
+R07G3.3	C15F1.4
+R08D7.3	C15F1.4
+R09B3.5	C15F1.4
+R186.7	C15F1.4
+T01G9.4	C15F1.4
+T02H6.2	C15F1.4
+T06A10.1	C15F1.4
+T08G11.4	C15F1.4
+T20G5.9	C15F1.4
+T23D8.4	C15F1.4
+T23H2.1	C15F1.4
+T25G3.3	C15F1.4
+T27F7.3	C15F1.4
+W08E3.2	C15F1.4
+Y106G6H.2	C15F1.4
+Y32H12A.2	C15F1.4
+Y37E3.10	C15F1.4
+Y37E3.15	C15F1.4
+Y39A3CR.1	C15F1.4
+Y39G10AR.8	C15F1.4
+Y40B1B.5	C15F1.4
+Y41D4B.19	C15F1.4
+Y43F4B.4	C15F1.4
+Y47H9C.7	C15F1.4
+Y48G8AL.6	C15F1.4
+Y54E2A.11	C15F1.4
+Y54F10BM.2	C15F1.4
+Y57A10A.30	C15F1.4
+Y62E10A.2	C15F1.4
+Y65B4A.6	C15F1.4
+Y66A7A.2	C15F1.4
+Y71F9AM.5	C15F1.4
+Y71H2B.2	C15F1.4
+Y73B6BL.18	C15F1.4
+Y74C10AR.1	C15F1.4
+Y77E11A.13	C15F1.4
+ZK1098.4	C15F1.4
+ZK632.14	C15F1.4
+ZK742.1	C15F1.4
+C16A3.8	C15H11.3
+C16C10.4	C15H11.3
+C24H11.5	C15H11.3
+C27D11.1	C15H11.3
+C29E4.3	C15H11.3
+C29E4.4	C15H11.3
+C34E10.5	C15H11.3
+C37C3.2	C15H11.3
+C41D11.2	C15H11.3
+C41G7.1	C15H11.3
+C43E11.1	C15H11.3
+C44H9.4	C15H11.3
+C49H3.10	C15H11.3
+D1007.4	C15H11.3
+D2013.7	C15H11.3
+D2085.3	C15H11.3
+E01G4.4	C15H11.3
+E04A4.4	C15H11.3
+F07A11.3	C15H11.3
+F10E9.5	C15H11.3
+F10G8.3	C15H11.3
+F11A3.2	C15H11.3
+F18H3.3	C15H11.3
+F22B5.2	C15H11.3
+F23B2.6	C15H11.3
+F23F1.5	C15H11.3
+F26A3.2	C15H11.3
+F28B3.8	C15H11.3
+F28D9.1	C15H11.3
+F29B9.6	C15H11.3
+F31E3.5	C15H11.3
+F32H2.4	C15H11.3
+F33D11.10	C15H11.3
+F37E3.1	C15H11.3
+F46B6.3	C15H11.3
+F53A2.6	C15H11.3
+F53F10.5	C15H11.3
+F55B12.4	C15H11.3
+F56A11.1	C15H11.3
+F56A3.3	C15H11.3
+F56D2.4	C15H11.3
+F57B9.3	C15H11.3
+F57B9.6	C15H11.3
+F59A2.1	C15H11.3
+H06H21.3	C15H11.3
+K02F3.11	C15H11.3
+K04G2.1	C15H11.3
+K07F5.13	C15H11.3
+K12C11.2	C15H11.3
+K12D12.2	C15H11.3
+M110.4	C15H11.3
+M18.7	C15H11.3
+R03G5.1	C15H11.3
+R04A9.4	C15H11.3
+R06F6.5	C15H11.3
+R07E5.14	C15H11.3
+R07G3.3	C15H11.3
+R08D7.3	C15H11.3
+R09B3.5	C15H11.3
+R186.7	C15H11.3
+T01G9.4	C15H11.3
+T02H6.2	C15H11.3
+T06A10.1	C15H11.3
+T08G11.4	C15H11.3
+T20G5.9	C15H11.3
+T23D8.4	C15H11.3
+T23H2.1	C15H11.3
+T27F7.3	C15H11.3
+W08E3.2	C15H11.3
+Y106G6H.2	C15H11.3
+Y32H12A.2	C15H11.3
+Y37E3.10	C15H11.3
+Y37E3.15	C15H11.3
+Y39A3CR.1	C15H11.3
+Y39G10AR.8	C15H11.3
+Y40B1B.5	C15H11.3
+Y41D4B.19	C15H11.3
+Y43F4B.4	C15H11.3
+Y47H9C.7	C15H11.3
+Y48G8AL.6	C15H11.3
+Y54E2A.11	C15H11.3
+Y54F10BM.2	C15H11.3
+Y57A10A.30	C15H11.3
+Y65B4A.6	C15H11.3
+Y71H2B.2	C15H11.3
+Y73B6BL.18	C15H11.3
+Y74C10AR.1	C15H11.3
+Y77E11A.13	C15H11.3
+ZK1098.4	C15H11.3
+C16A3.8	C15H11.6
+C16C10.4	C15H11.6
+C24H11.5	C15H11.6
+C27D11.1	C15H11.6
+C29E4.3	C15H11.6
+C29E4.4	C15H11.6
+C34E10.5	C15H11.6
+C37C3.2	C15H11.6
+C41D11.2	C15H11.6
+C41G7.1	C15H11.6
+C43E11.1	C15H11.6
+C44H9.4	C15H11.6
+C49H3.10	C15H11.6
+D1007.4	C15H11.6
+D2013.7	C15H11.6
+D2085.3	C15H11.6
+E01G4.4	C15H11.6
+E04A4.4	C15H11.6
+F07A11.3	C15H11.6
+F10E9.5	C15H11.6
+F10G8.3	C15H11.6
+F11A3.2	C15H11.6
+F18H3.3	C15H11.6
+F22B5.2	C15H11.6
+F23B2.6	C15H11.6
+F23F1.5	C15H11.6
+F26A3.2	C15H11.6
+F28B3.8	C15H11.6
+F28D9.1	C15H11.6
+F29B9.6	C15H11.6
+F31E3.5	C15H11.6
+F32H2.4	C15H11.6
+F33D11.10	C15H11.6
+F37E3.1	C15H11.6
+F46B6.3	C15H11.6
+F53A2.6	C15H11.6
+F53F10.5	C15H11.6
+F55B12.4	C15H11.6
+F56A11.1	C15H11.6
+F56A3.3	C15H11.6
+F56D2.4	C15H11.6
+F57B9.3	C15H11.6
+F57B9.6	C15H11.6
+F59A2.1	C15H11.6
+H06H21.3	C15H11.6
+K02F3.11	C15H11.6
+K04G2.1	C15H11.6
+K07F5.13	C15H11.6
+K12C11.2	C15H11.6
+K12D12.2	C15H11.6
+M110.4	C15H11.6
+M18.7	C15H11.6
+R03G5.1	C15H11.6
+R04A9.4	C15H11.6
+R06F6.5	C15H11.6
+R07E5.14	C15H11.6
+R07G3.3	C15H11.6
+R08D7.3	C15H11.6
+R09B3.5	C15H11.6
+R186.7	C15H11.6
+T01G9.4	C15H11.6
+T02H6.2	C15H11.6
+T06A10.1	C15H11.6
+T08G11.4	C15H11.6
+T20G5.9	C15H11.6
+T23D8.4	C15H11.6
+T23H2.1	C15H11.6
+T27F7.3	C15H11.6
+W08E3.2	C15H11.6
+Y106G6H.2	C15H11.6
+Y32H12A.2	C15H11.6
+Y37E3.10	C15H11.6
+Y37E3.15	C15H11.6
+Y39A3CR.1	C15H11.6
+Y39G10AR.8	C15H11.6
+Y40B1B.5	C15H11.6
+Y41D4B.19	C15H11.6
+Y43F4B.4	C15H11.6
+Y47H9C.7	C15H11.6
+Y48G8AL.6	C15H11.6
+Y54E2A.11	C15H11.6
+Y54F10BM.2	C15H11.6
+Y57A10A.30	C15H11.6
+Y65B4A.6	C15H11.6
+Y71H2B.2	C15H11.6
+Y73B6BL.18	C15H11.6
+Y74C10AR.1	C15H11.6
+Y77E11A.13	C15H11.6
+ZK1098.4	C15H11.6
+C16C10.4	C16A3.8
+C24H11.5	C16A3.8
+C27D11.1	C16A3.8
+C29E4.3	C16A3.8
+C29E4.4	C16A3.8
+C34E10.5	C16A3.8
+C37C3.2	C16A3.8
+C41D11.2	C16A3.8
+C41G7.1	C16A3.8
+C43E11.1	C16A3.8
+C44H9.4	C16A3.8
+C49H3.10	C16A3.8
+D1007.4	C16A3.8
+D2013.7	C16A3.8
+D2085.3	C16A3.8
+E01G4.4	C16A3.8
+E04A4.4	C16A3.8
+F07A11.3	C16A3.8
+F10E9.5	C16A3.8
+F10G8.3	C16A3.8
+F11A3.2	C16A3.8
+F18H3.3	C16A3.8
+F22B5.2	C16A3.8
+F23B2.6	C16A3.8
+F23F1.5	C16A3.8
+F26A3.2	C16A3.8
+F28B3.8	C16A3.8
+F28D9.1	C16A3.8
+F29B9.6	C16A3.8
+F31E3.5	C16A3.8
+F32H2.4	C16A3.8
+F33D11.10	C16A3.8
+F37E3.1	C16A3.8
+F46B6.3	C16A3.8
+F53A2.6	C16A3.8
+F53F10.5	C16A3.8
+F55B12.4	C16A3.8
+F56A11.1	C16A3.8
+F56A3.3	C16A3.8
+F56D2.4	C16A3.8
+F57B9.3	C16A3.8
+F57B9.6	C16A3.8
+F59A2.1	C16A3.8
+H06H21.3	C16A3.8
+H35B03.2	C16A3.8
+K01G5.4	C16A3.8
+K02F3.11	C16A3.8
+K04G2.1	C16A3.8
+K07F5.13	C16A3.8
+K12C11.2	C16A3.8
+K12D12.2	C16A3.8
+M110.4	C16A3.8
+M18.7	C16A3.8
+R03G5.1	C16A3.8
+R04A9.4	C16A3.8
+R06F6.5	C16A3.8
+R07E5.14	C16A3.8
+R07G3.3	C16A3.8
+R08D7.3	C16A3.8
+R09B3.5	C16A3.8
+R186.7	C16A3.8
+T01G9.4	C16A3.8
+T02H6.2	C16A3.8
+T06A10.1	C16A3.8
+T08G11.4	C16A3.8
+T20G5.9	C16A3.8
+T23D8.4	C16A3.8
+T23H2.1	C16A3.8
+T25G3.3	C16A3.8
+T27F7.3	C16A3.8
+W08E3.2	C16A3.8
+Y106G6H.2	C16A3.8
+Y32H12A.2	C16A3.8
+Y37E3.10	C16A3.8
+Y37E3.15	C16A3.8
+Y39A3CR.1	C16A3.8
+Y39G10AR.8	C16A3.8
+Y40B1B.5	C16A3.8
+Y41D4B.19	C16A3.8
+Y43F4B.4	C16A3.8
+Y47H9C.7	C16A3.8
+Y48G8AL.6	C16A3.8
+Y54E2A.11	C16A3.8
+Y54F10BM.2	C16A3.8
+Y57A10A.30	C16A3.8
+Y62E10A.2	C16A3.8
+Y65B4A.6	C16A3.8
+Y66A7A.2	C16A3.8
+Y71F9AM.5	C16A3.8
+Y71H2B.2	C16A3.8
+Y73B6BL.18	C16A3.8
+Y74C10AR.1	C16A3.8
+Y77E11A.13	C16A3.8
+ZK1098.4	C16A3.8
+ZK632.14	C16A3.8
+ZK742.1	C16A3.8
+C24H11.5	C16C10.4
+C27D11.1	C16C10.4
+C29E4.3	C16C10.4
+C29E4.4	C16C10.4
+C34E10.5	C16C10.4
+C37C3.2	C16C10.4
+C41D11.2	C16C10.4
+C41G7.1	C16C10.4
+C43E11.1	C16C10.4
+C44H9.4	C16C10.4
+C49H3.10	C16C10.4
+D1007.4	C16C10.4
+D2013.7	C16C10.4
+D2085.3	C16C10.4
+E01G4.4	C16C10.4
+E04A4.4	C16C10.4
+F07A11.3	C16C10.4
+F10E9.5	C16C10.4
+F10G8.3	C16C10.4
+F11A3.2	C16C10.4
+F18H3.3	C16C10.4
+F22B5.2	C16C10.4
+F23B2.6	C16C10.4
+F23F1.5	C16C10.4
+F26A3.2	C16C10.4
+F28B3.8	C16C10.4
+F28D9.1	C16C10.4
+F29B9.6	C16C10.4
+F31E3.5	C16C10.4
+F32H2.4	C16C10.4
+F33D11.10	C16C10.4
+F37E3.1	C16C10.4
+F46B6.3	C16C10.4
+F53A2.6	C16C10.4
+F53F10.5	C16C10.4
+F55B12.4	C16C10.4
+F56A11.1	C16C10.4
+F56A3.3	C16C10.4
+F56D2.4	C16C10.4
+F57B9.3	C16C10.4
+F57B9.6	C16C10.4
+F59A2.1	C16C10.4
+H06H21.3	C16C10.4
+H35B03.2	C16C10.4
+K01G5.4	C16C10.4
+K02F3.11	C16C10.4
+K04G2.1	C16C10.4
+K07F5.13	C16C10.4
+K12C11.2	C16C10.4
+K12D12.2	C16C10.4
+M110.4	C16C10.4
+M18.7	C16C10.4
+R03G5.1	C16C10.4
+R04A9.4	C16C10.4
+R06F6.5	C16C10.4
+R07E5.14	C16C10.4
+R07G3.3	C16C10.4
+R08D7.3	C16C10.4
+R09B3.5	C16C10.4
+R186.7	C16C10.4
+T01G9.4	C16C10.4
+T02H6.2	C16C10.4
+T06A10.1	C16C10.4
+T08G11.4	C16C10.4
+T20G5.9	C16C10.4
+T23D8.4	C16C10.4
+T23H2.1	C16C10.4
+T25G3.3	C16C10.4
+T27F7.3	C16C10.4
+W08E3.2	C16C10.4
+Y106G6H.2	C16C10.4
+Y32H12A.2	C16C10.4
+Y37E3.10	C16C10.4
+Y37E3.15	C16C10.4
+Y39A3CR.1	C16C10.4
+Y39G10AR.8	C16C10.4
+Y40B1B.5	C16C10.4
+Y41D4B.19	C16C10.4
+Y43F4B.4	C16C10.4
+Y47H9C.7	C16C10.4
+Y48G8AL.6	C16C10.4
+Y54E2A.11	C16C10.4
+Y54F10BM.2	C16C10.4
+Y57A10A.30	C16C10.4
+Y62E10A.2	C16C10.4
+Y65B4A.6	C16C10.4
+Y66A7A.2	C16C10.4
+Y71F9AM.5	C16C10.4
+Y71H2B.2	C16C10.4
+Y73B6BL.18	C16C10.4
+Y74C10AR.1	C16C10.4
+Y77E11A.13	C16C10.4
+ZK1098.4	C16C10.4
+ZK632.14	C16C10.4
+ZK742.1	C16C10.4
+C27D11.1	C24H11.5
+C29E4.3	C24H11.5
+C29E4.4	C24H11.5
+C34E10.5	C24H11.5
+C37C3.2	C24H11.5
+C41D11.2	C24H11.5
+C41G7.1	C24H11.5
+C43E11.1	C24H11.5
+C44H9.4	C24H11.5
+C49H3.10	C24H11.5
+D1007.4	C24H11.5
+D2013.7	C24H11.5
+D2085.3	C24H11.5
+E01G4.4	C24H11.5
+E04A4.4	C24H11.5
+F07A11.3	C24H11.5
+F10E9.5	C24H11.5
+F10G8.3	C24H11.5
+F11A3.2	C24H11.5
+F18H3.3	C24H11.5
+F22B5.2	C24H11.5
+F23B2.6	C24H11.5
+F23F1.5	C24H11.5
+F26A3.2	C24H11.5
+F28B3.8	C24H11.5
+F28D9.1	C24H11.5
+F29B9.6	C24H11.5
+F31E3.5	C24H11.5
+F32H2.4	C24H11.5
+F33D11.10	C24H11.5
+F37E3.1	C24H11.5
+F46B6.3	C24H11.5
+F53A2.6	C24H11.5
+F53F10.5	C24H11.5
+F55B12.4	C24H11.5
+F56A11.1	C24H11.5
+F56A3.3	C24H11.5
+F56D2.4	C24H11.5
+F57B9.3	C24H11.5
+F57B9.6	C24H11.5
+F59A2.1	C24H11.5
+H06H21.3	C24H11.5
+H35B03.2	C24H11.5
+K01G5.4	C24H11.5
+K02F3.11	C24H11.5
+K04G2.1	C24H11.5
+K07F5.13	C24H11.5
+K12C11.2	C24H11.5
+K12D12.2	C24H11.5
+M110.4	C24H11.5
+M18.7	C24H11.5
+R03G5.1	C24H11.5
+R04A9.4	C24H11.5
+R06F6.5	C24H11.5
+R07E5.14	C24H11.5
+R07G3.3	C24H11.5
+R08D7.3	C24H11.5
+R09B3.5	C24H11.5
+R186.7	C24H11.5
+T01G9.4	C24H11.5
+T02H6.2	C24H11.5
+T06A10.1	C24H11.5
+T08G11.4	C24H11.5
+T20G5.9	C24H11.5
+T23D8.4	C24H11.5
+T23H2.1	C24H11.5
+T25G3.3	C24H11.5
+T27F7.3	C24H11.5
+W08E3.2	C24H11.5
+Y106G6H.2	C24H11.5
+Y32H12A.2	C24H11.5
+Y37E3.10	C24H11.5
+Y37E3.15	C24H11.5
+Y39A3CR.1	C24H11.5
+Y39G10AR.8	C24H11.5
+Y40B1B.5	C24H11.5
+Y41D4B.19	C24H11.5
+Y43F4B.4	C24H11.5
+Y47H9C.7	C24H11.5
+Y48G8AL.6	C24H11.5
+Y54E2A.11	C24H11.5
+Y54F10BM.2	C24H11.5
+Y57A10A.30	C24H11.5
+Y62E10A.2	C24H11.5
+Y65B4A.6	C24H11.5
+Y66A7A.2	C24H11.5
+Y71F9AM.5	C24H11.5
+Y71H2B.2	C24H11.5
+Y73B6BL.18	C24H11.5
+Y74C10AR.1	C24H11.5
+Y77E11A.13	C24H11.5
+ZK1098.4	C24H11.5
+ZK632.14	C24H11.5
+ZK742.1	C24H11.5
+C29E4.3	C27D11.1
+C29E4.4	C27D11.1
+C34E10.5	C27D11.1
+C37C3.2	C27D11.1
+C41D11.2	C27D11.1
+C41G7.1	C27D11.1
+C43E11.1	C27D11.1
+C44H9.4	C27D11.1
+C49H3.10	C27D11.1
+D1007.4	C27D11.1
+D2013.7	C27D11.1
+D2085.3	C27D11.1
+E01G4.4	C27D11.1
+E04A4.4	C27D11.1
+F07A11.3	C27D11.1
+F10E9.5	C27D11.1
+F10G8.3	C27D11.1
+F11A3.2	C27D11.1
+F18H3.3	C27D11.1
+F22B5.2	C27D11.1
+F23B2.6	C27D11.1
+F23F1.5	C27D11.1
+F26A3.2	C27D11.1
+F28B3.8	C27D11.1
+F28D9.1	C27D11.1
+F29B9.6	C27D11.1
+F31E3.5	C27D11.1
+F32H2.4	C27D11.1
+F33D11.10	C27D11.1
+F37E3.1	C27D11.1
+F46B6.3	C27D11.1
+F53A2.6	C27D11.1
+F53F10.5	C27D11.1
+F55B12.4	C27D11.1
+F56A11.1	C27D11.1
+F56A3.3	C27D11.1
+F56D2.4	C27D11.1
+F57B9.3	C27D11.1
+F57B9.6	C27D11.1
+F59A2.1	C27D11.1
+H06H21.3	C27D11.1
+H35B03.2	C27D11.1
+K01G5.4	C27D11.1
+K02F3.11	C27D11.1
+K04G2.1	C27D11.1
+K07F5.13	C27D11.1
+K12C11.2	C27D11.1
+K12D12.2	C27D11.1
+M110.4	C27D11.1
+M18.7	C27D11.1
+R03G5.1	C27D11.1
+R04A9.4	C27D11.1
+R06F6.5	C27D11.1
+R07E5.14	C27D11.1
+R07G3.3	C27D11.1
+R08D7.3	C27D11.1
+R09B3.5	C27D11.1
+R186.7	C27D11.1
+T01G9.4	C27D11.1
+T02H6.2	C27D11.1
+T06A10.1	C27D11.1
+T08G11.4	C27D11.1
+T20G5.9	C27D11.1
+T23D8.4	C27D11.1
+T23H2.1	C27D11.1
+T25G3.3	C27D11.1
+T27F7.3	C27D11.1
+W08E3.2	C27D11.1
+Y106G6H.2	C27D11.1
+Y32H12A.2	C27D11.1
+Y37E3.10	C27D11.1
+Y37E3.15	C27D11.1
+Y39A3CR.1	C27D11.1
+Y39G10AR.8	C27D11.1
+Y40B1B.5	C27D11.1
+Y41D4B.19	C27D11.1
+Y43F4B.4	C27D11.1
+Y47H9C.7	C27D11.1
+Y48G8AL.6	C27D11.1
+Y54E2A.11	C27D11.1
+Y54F10BM.2	C27D11.1
+Y57A10A.30	C27D11.1
+Y62E10A.2	C27D11.1
+Y65B4A.6	C27D11.1
+Y66A7A.2	C27D11.1
+Y71F9AM.5	C27D11.1
+Y71H2B.2	C27D11.1
+Y73B6BL.18	C27D11.1
+Y74C10AR.1	C27D11.1
+Y77E11A.13	C27D11.1
+ZK1098.4	C27D11.1
+ZK632.14	C27D11.1
+ZK742.1	C27D11.1
+C29E4.4	C29E4.3
+C34E10.5	C29E4.3
+C37C3.2	C29E4.3
+C41D11.2	C29E4.3
+C41G7.1	C29E4.3
+C43E11.1	C29E4.3
+C44H9.4	C29E4.3
+C49H3.10	C29E4.3
+D1007.4	C29E4.3
+D2013.7	C29E4.3
+D2085.3	C29E4.3
+E01G4.4	C29E4.3
+E04A4.4	C29E4.3
+F07A11.3	C29E4.3
+F10E9.5	C29E4.3
+F10G8.3	C29E4.3
+F11A3.2	C29E4.3
+F18H3.3	C29E4.3
+F22B5.2	C29E4.3
+F23B2.6	C29E4.3
+F23F1.5	C29E4.3
+F26A3.2	C29E4.3
+F28B3.8	C29E4.3
+F28D9.1	C29E4.3
+F29B9.6	C29E4.3
+F31E3.5	C29E4.3
+F32H2.4	C29E4.3
+F33D11.10	C29E4.3
+F37E3.1	C29E4.3
+F46B6.3	C29E4.3
+F53A2.6	C29E4.3
+F53F10.5	C29E4.3
+F55B12.4	C29E4.3
+F56A11.1	C29E4.3
+F56A3.3	C29E4.3
+F56D2.4	C29E4.3
+F57B9.3	C29E4.3
+F57B9.6	C29E4.3
+F59A2.1	C29E4.3
+H06H21.3	C29E4.3
+H35B03.2	C29E4.3
+K01G5.4	C29E4.3
+K02F3.11	C29E4.3
+K04G2.1	C29E4.3
+K07F5.13	C29E4.3
+K12C11.2	C29E4.3
+K12D12.2	C29E4.3
+M110.4	C29E4.3
+M18.7	C29E4.3
+R03G5.1	C29E4.3
+R04A9.4	C29E4.3
+R06F6.5	C29E4.3
+R07E5.14	C29E4.3
+R07G3.3	C29E4.3
+R08D7.3	C29E4.3
+R09B3.5	C29E4.3
+R186.7	C29E4.3
+T01G9.4	C29E4.3
+T02H6.2	C29E4.3
+T06A10.1	C29E4.3
+T08G11.4	C29E4.3
+T20G5.9	C29E4.3
+T23D8.4	C29E4.3
+T23H2.1	C29E4.3
+T25G3.3	C29E4.3
+T27F7.3	C29E4.3
+W08E3.2	C29E4.3
+Y106G6H.2	C29E4.3
+Y32H12A.2	C29E4.3
+Y37E3.10	C29E4.3
+Y37E3.15	C29E4.3
+Y39A3CR.1	C29E4.3
+Y39G10AR.8	C29E4.3
+Y40B1B.5	C29E4.3
+Y41D4B.19	C29E4.3
+Y43F4B.4	C29E4.3
+Y47H9C.7	C29E4.3
+Y48G8AL.6	C29E4.3
+Y54E2A.11	C29E4.3
+Y54F10BM.2	C29E4.3
+Y57A10A.30	C29E4.3
+Y62E10A.2	C29E4.3
+Y65B4A.6	C29E4.3
+Y66A7A.2	C29E4.3
+Y71F9AM.5	C29E4.3
+Y71H2B.2	C29E4.3
+Y73B6BL.18	C29E4.3
+Y74C10AR.1	C29E4.3
+Y77E11A.13	C29E4.3
+ZK1098.4	C29E4.3
+ZK632.14	C29E4.3
+ZK742.1	C29E4.3
+C34E10.5	C29E4.4
+C37C3.2	C29E4.4
+C41D11.2	C29E4.4
+C41G7.1	C29E4.4
+C43E11.1	C29E4.4
+C44H9.4	C29E4.4
+C49H3.10	C29E4.4
+D1007.4	C29E4.4
+D2013.7	C29E4.4
+D2085.3	C29E4.4
+E01G4.4	C29E4.4
+E04A4.4	C29E4.4
+F07A11.3	C29E4.4
+F10E9.5	C29E4.4
+F10G8.3	C29E4.4
+F11A3.2	C29E4.4
+F18H3.3	C29E4.4
+F22B5.2	C29E4.4
+F23B2.6	C29E4.4
+F23F1.5	C29E4.4
+F26A3.2	C29E4.4
+F28B3.8	C29E4.4
+F28D9.1	C29E4.4
+F29B9.6	C29E4.4
+F31E3.5	C29E4.4
+F32H2.4	C29E4.4
+F33D11.10	C29E4.4
+F37E3.1	C29E4.4
+F46B6.3	C29E4.4
+F53A2.6	C29E4.4
+F53F10.5	C29E4.4
+F55B12.4	C29E4.4
+F56A11.1	C29E4.4
+F56A3.3	C29E4.4
+F56D2.4	C29E4.4
+F57B9.3	C29E4.4
+F57B9.6	C29E4.4
+F59A2.1	C29E4.4
+H06H21.3	C29E4.4
+H35B03.2	C29E4.4
+K01G5.4	C29E4.4
+K02F3.11	C29E4.4
+K04G2.1	C29E4.4
+K07F5.13	C29E4.4
+K12C11.2	C29E4.4
+K12D12.2	C29E4.4
+M110.4	C29E4.4
+M18.7	C29E4.4
+R03G5.1	C29E4.4
+R04A9.4	C29E4.4
+R06F6.5	C29E4.4
+R07E5.14	C29E4.4
+R07G3.3	C29E4.4
+R08D7.3	C29E4.4
+R09B3.5	C29E4.4
+R186.7	C29E4.4
+T01G9.4	C29E4.4
+T02H6.2	C29E4.4
+T06A10.1	C29E4.4
+T08G11.4	C29E4.4
+T20G5.9	C29E4.4
+T23D8.4	C29E4.4
+T23H2.1	C29E4.4
+T25G3.3	C29E4.4
+T27F7.3	C29E4.4
+W08E3.2	C29E4.4
+Y106G6H.2	C29E4.4
+Y32H12A.2	C29E4.4
+Y37E3.10	C29E4.4
+Y37E3.15	C29E4.4
+Y39A3CR.1	C29E4.4
+Y39G10AR.8	C29E4.4
+Y40B1B.5	C29E4.4
+Y41D4B.19	C29E4.4
+Y43F4B.4	C29E4.4
+Y47H9C.7	C29E4.4
+Y48G8AL.6	C29E4.4
+Y54E2A.11	C29E4.4
+Y54F10BM.2	C29E4.4
+Y57A10A.30	C29E4.4
+Y62E10A.2	C29E4.4
+Y65B4A.6	C29E4.4
+Y66A7A.2	C29E4.4
+Y71F9AM.5	C29E4.4
+Y71H2B.2	C29E4.4
+Y73B6BL.18	C29E4.4
+Y74C10AR.1	C29E4.4
+Y77E11A.13	C29E4.4
+ZK1098.4	C29E4.4
+ZK632.14	C29E4.4
+ZK742.1	C29E4.4
+C37C3.2	C34E10.5
+C41D11.2	C34E10.5
+C41G7.1	C34E10.5
+C43E11.1	C34E10.5
+C44H9.4	C34E10.5
+C49H3.10	C34E10.5
+D1007.4	C34E10.5
+D2013.7	C34E10.5
+D2085.3	C34E10.5
+E01G4.4	C34E10.5
+E04A4.4	C34E10.5
+F07A11.3	C34E10.5
+F10E9.5	C34E10.5
+F10G8.3	C34E10.5
+F11A3.2	C34E10.5
+F18H3.3	C34E10.5
+F22B5.2	C34E10.5
+F23B2.6	C34E10.5
+F23F1.5	C34E10.5
+F26A3.2	C34E10.5
+F28B3.8	C34E10.5
+F28D9.1	C34E10.5
+F29B9.6	C34E10.5
+F31E3.5	C34E10.5
+F32H2.4	C34E10.5
+F33D11.10	C34E10.5
+F37E3.1	C34E10.5
+F46B6.3	C34E10.5
+F53A2.6	C34E10.5
+F53F10.5	C34E10.5
+F55B12.4	C34E10.5
+F56A11.1	C34E10.5
+F56A3.3	C34E10.5
+F56D2.4	C34E10.5
+F57B9.3	C34E10.5
+F57B9.6	C34E10.5
+F59A2.1	C34E10.5
+H06H21.3	C34E10.5
+H35B03.2	C34E10.5
+K01G5.4	C34E10.5
+K02F3.11	C34E10.5
+K04G2.1	C34E10.5
+K07F5.13	C34E10.5
+K12C11.2	C34E10.5
+K12D12.2	C34E10.5
+M110.4	C34E10.5
+M18.7	C34E10.5
+R03G5.1	C34E10.5
+R04A9.4	C34E10.5
+R06F6.5	C34E10.5
+R07E5.14	C34E10.5
+R07G3.3	C34E10.5
+R08D7.3	C34E10.5
+R09B3.5	C34E10.5
+R186.7	C34E10.5
+T01G9.4	C34E10.5
+T02H6.2	C34E10.5
+T06A10.1	C34E10.5
+T08G11.4	C34E10.5
+T20G5.9	C34E10.5
+T23D8.4	C34E10.5
+T23H2.1	C34E10.5
+T25G3.3	C34E10.5
+T27F7.3	C34E10.5
+W08E3.2	C34E10.5
+Y106G6H.2	C34E10.5
+Y32H12A.2	C34E10.5
+Y37E3.10	C34E10.5
+Y37E3.15	C34E10.5
+Y39A3CR.1	C34E10.5
+Y39G10AR.8	C34E10.5
+Y40B1B.5	C34E10.5
+Y41D4B.19	C34E10.5
+Y43F4B.4	C34E10.5
+Y47H9C.7	C34E10.5
+Y48G8AL.6	C34E10.5
+Y54E2A.11	C34E10.5
+Y54F10BM.2	C34E10.5
+Y57A10A.30	C34E10.5
+Y62E10A.2	C34E10.5
+Y65B4A.6	C34E10.5
+Y66A7A.2	C34E10.5
+Y71F9AM.5	C34E10.5
+Y71H2B.2	C34E10.5
+Y73B6BL.18	C34E10.5
+Y74C10AR.1	C34E10.5
+Y77E11A.13	C34E10.5
+ZK1098.4	C34E10.5
+ZK632.14	C34E10.5
+ZK742.1	C34E10.5
+C41D11.2	C37C3.2
+C41G7.1	C37C3.2
+C43E11.1	C37C3.2
+C44H9.4	C37C3.2
+C49H3.10	C37C3.2
+D1007.4	C37C3.2
+D2013.7	C37C3.2
+D2085.3	C37C3.2
+E01G4.4	C37C3.2
+E04A4.4	C37C3.2
+F07A11.3	C37C3.2
+F10E9.5	C37C3.2
+F10G8.3	C37C3.2
+F11A3.2	C37C3.2
+F18H3.3	C37C3.2
+F22B5.2	C37C3.2
+F23B2.6	C37C3.2
+F23F1.5	C37C3.2
+F26A3.2	C37C3.2
+F28B3.8	C37C3.2
+F28D9.1	C37C3.2
+F29B9.6	C37C3.2
+F31E3.5	C37C3.2
+F32H2.4	C37C3.2
+F33D11.10	C37C3.2
+F37E3.1	C37C3.2
+F46B6.3	C37C3.2
+F53A2.6	C37C3.2
+F53F10.5	C37C3.2
+F55B12.4	C37C3.2
+F56A11.1	C37C3.2
+F56A3.3	C37C3.2
+F56D2.4	C37C3.2
+F57B9.3	C37C3.2
+F57B9.6	C37C3.2
+F59A2.1	C37C3.2
+H06H21.3	C37C3.2
+H35B03.2	C37C3.2
+K01G5.4	C37C3.2
+K02F3.11	C37C3.2
+K04G2.1	C37C3.2
+K07F5.13	C37C3.2
+K12C11.2	C37C3.2
+K12D12.2	C37C3.2
+M110.4	C37C3.2
+M18.7	C37C3.2
+R03G5.1	C37C3.2
+R04A9.4	C37C3.2
+R06F6.5	C37C3.2
+R07E5.14	C37C3.2
+R07G3.3	C37C3.2
+R08D7.3	C37C3.2
+R09B3.5	C37C3.2
+R186.7	C37C3.2
+T01G9.4	C37C3.2
+T02H6.2	C37C3.2
+T06A10.1	C37C3.2
+T08G11.4	C37C3.2
+T20G5.9	C37C3.2
+T23D8.4	C37C3.2
+T23H2.1	C37C3.2
+T25G3.3	C37C3.2
+T27F7.3	C37C3.2
+W08E3.2	C37C3.2
+Y106G6H.2	C37C3.2
+Y32H12A.2	C37C3.2
+Y37E3.10	C37C3.2
+Y37E3.15	C37C3.2
+Y39A3CR.1	C37C3.2
+Y39G10AR.8	C37C3.2
+Y40B1B.5	C37C3.2
+Y41D4B.19	C37C3.2
+Y43F4B.4	C37C3.2
+Y47H9C.7	C37C3.2
+Y48G8AL.6	C37C3.2
+Y54E2A.11	C37C3.2
+Y54F10BM.2	C37C3.2
+Y57A10A.30	C37C3.2
+Y62E10A.2	C37C3.2
+Y65B4A.6	C37C3.2
+Y66A7A.2	C37C3.2
+Y71F9AM.5	C37C3.2
+Y71H2B.2	C37C3.2
+Y73B6BL.18	C37C3.2
+Y74C10AR.1	C37C3.2
+Y77E11A.13	C37C3.2
+ZK1098.4	C37C3.2
+ZK632.14	C37C3.2
+ZK742.1	C37C3.2
+C41G7.1	C41D11.2
+C43E11.1	C41D11.2
+C44H9.4	C41D11.2
+C49H3.10	C41D11.2
+D1007.4	C41D11.2
+D2013.7	C41D11.2
+D2085.3	C41D11.2
+E01G4.4	C41D11.2
+E04A4.4	C41D11.2
+F07A11.3	C41D11.2
+F10E9.5	C41D11.2
+F10G8.3	C41D11.2
+F11A3.2	C41D11.2
+F18H3.3	C41D11.2
+F22B5.2	C41D11.2
+F23B2.6	C41D11.2
+F23F1.5	C41D11.2
+F26A3.2	C41D11.2
+F28B3.8	C41D11.2
+F28D9.1	C41D11.2
+F29B9.6	C41D11.2
+F31E3.5	C41D11.2
+F32H2.4	C41D11.2
+F33D11.10	C41D11.2
+F37E3.1	C41D11.2
+F46B6.3	C41D11.2
+F53A2.6	C41D11.2
+F53F10.5	C41D11.2
+F55B12.4	C41D11.2
+F56A11.1	C41D11.2
+F56A3.3	C41D11.2
+F56D2.4	C41D11.2
+F57B9.3	C41D11.2
+F57B9.6	C41D11.2
+F59A2.1	C41D11.2
+H06H21.3	C41D11.2
+H35B03.2	C41D11.2
+K01G5.4	C41D11.2
+K02F3.11	C41D11.2
+K04G2.1	C41D11.2
+K07F5.13	C41D11.2
+K12C11.2	C41D11.2
+K12D12.2	C41D11.2
+M110.4	C41D11.2
+M18.7	C41D11.2
+R03G5.1	C41D11.2
+R04A9.4	C41D11.2
+R06F6.5	C41D11.2
+R07E5.14	C41D11.2
+R07G3.3	C41D11.2
+R08D7.3	C41D11.2
+R09B3.5	C41D11.2
+R186.7	C41D11.2
+T01G9.4	C41D11.2
+T02H6.2	C41D11.2
+T06A10.1	C41D11.2
+T08G11.4	C41D11.2
+T20G5.9	C41D11.2
+T23D8.4	C41D11.2
+T23H2.1	C41D11.2
+T25G3.3	C41D11.2
+T27F7.3	C41D11.2
+W08E3.2	C41D11.2
+Y106G6H.2	C41D11.2
+Y32H12A.2	C41D11.2
+Y37E3.10	C41D11.2
+Y37E3.15	C41D11.2
+Y39A3CR.1	C41D11.2
+Y39G10AR.8	C41D11.2
+Y40B1B.5	C41D11.2
+Y41D4B.19	C41D11.2
+Y43F4B.4	C41D11.2
+Y47H9C.7	C41D11.2
+Y48G8AL.6	C41D11.2
+Y54E2A.11	C41D11.2
+Y54F10BM.2	C41D11.2
+Y57A10A.30	C41D11.2
+Y62E10A.2	C41D11.2
+Y65B4A.6	C41D11.2
+Y66A7A.2	C41D11.2
+Y71F9AM.5	C41D11.2
+Y71H2B.2	C41D11.2
+Y73B6BL.18	C41D11.2
+Y74C10AR.1	C41D11.2
+Y77E11A.13	C41D11.2
+ZK1098.4	C41D11.2
+ZK632.14	C41D11.2
+ZK742.1	C41D11.2
+C43E11.1	C41G7.1
+C44H9.4	C41G7.1
+C49H3.10	C41G7.1
+D1007.4	C41G7.1
+D2013.7	C41G7.1
+D2085.3	C41G7.1
+E01G4.4	C41G7.1
+E04A4.4	C41G7.1
+F07A11.3	C41G7.1
+F10E9.5	C41G7.1
+F10G8.3	C41G7.1
+F11A3.2	C41G7.1
+F18H3.3	C41G7.1
+F22B5.2	C41G7.1
+F23B2.6	C41G7.1
+F23F1.5	C41G7.1
+F26A3.2	C41G7.1
+F28B3.8	C41G7.1
+F28D9.1	C41G7.1
+F29B9.6	C41G7.1
+F31E3.5	C41G7.1
+F32H2.4	C41G7.1
+F33D11.10	C41G7.1
+F37E3.1	C41G7.1
+F46B6.3	C41G7.1
+F53A2.6	C41G7.1
+F53F10.5	C41G7.1
+F55B12.4	C41G7.1
+F56A11.1	C41G7.1
+F56A3.3	C41G7.1
+F56D2.4	C41G7.1
+F57B9.3	C41G7.1
+F57B9.6	C41G7.1
+F59A2.1	C41G7.1
+H06H21.3	C41G7.1
+H35B03.2	C41G7.1
+K01G5.4	C41G7.1
+K02F3.11	C41G7.1
+K04G2.1	C41G7.1
+K07F5.13	C41G7.1
+K12C11.2	C41G7.1
+K12D12.2	C41G7.1
+M110.4	C41G7.1
+M18.7	C41G7.1
+R03G5.1	C41G7.1
+R04A9.4	C41G7.1
+R06F6.5	C41G7.1
+R07E5.14	C41G7.1
+R07G3.3	C41G7.1
+R08D7.3	C41G7.1
+R09B3.5	C41G7.1
+R186.7	C41G7.1
+T01G9.4	C41G7.1
+T02H6.2	C41G7.1
+T06A10.1	C41G7.1
+T08G11.4	C41G7.1
+T20G5.9	C41G7.1
+T23D8.4	C41G7.1
+T23H2.1	C41G7.1
+T25G3.3	C41G7.1
+T27F7.3	C41G7.1
+W08E3.2	C41G7.1
+Y106G6H.2	C41G7.1
+Y32H12A.2	C41G7.1
+Y37E3.10	C41G7.1
+Y37E3.15	C41G7.1
+Y39A3CR.1	C41G7.1
+Y39G10AR.8	C41G7.1
+Y40B1B.5	C41G7.1
+Y41D4B.19	C41G7.1
+Y43F4B.4	C41G7.1
+Y47H9C.7	C41G7.1
+Y48G8AL.6	C41G7.1
+Y54E2A.11	C41G7.1
+Y54F10BM.2	C41G7.1
+Y57A10A.30	C41G7.1
+Y62E10A.2	C41G7.1
+Y65B4A.6	C41G7.1
+Y66A7A.2	C41G7.1
+Y71F9AM.5	C41G7.1
+Y71H2B.2	C41G7.1
+Y73B6BL.18	C41G7.1
+Y74C10AR.1	C41G7.1
+Y77E11A.13	C41G7.1
+ZK1098.4	C41G7.1
+ZK632.14	C41G7.1
+ZK742.1	C41G7.1
+C44H9.4	C43E11.1
+C49H3.10	C43E11.1
+D1007.4	C43E11.1
+D2013.7	C43E11.1
+D2085.3	C43E11.1
+E01G4.4	C43E11.1
+E04A4.4	C43E11.1
+F07A11.3	C43E11.1
+F10E9.5	C43E11.1
+F10G8.3	C43E11.1
+F11A3.2	C43E11.1
+F18H3.3	C43E11.1
+F22B5.2	C43E11.1
+F23B2.6	C43E11.1
+F23F1.5	C43E11.1
+F26A3.2	C43E11.1
+F28B3.8	C43E11.1
+F28D9.1	C43E11.1
+F29B9.6	C43E11.1
+F31E3.5	C43E11.1
+F32H2.4	C43E11.1
+F33D11.10	C43E11.1
+F37E3.1	C43E11.1
+F46B6.3	C43E11.1
+F53A2.6	C43E11.1
+F53F10.5	C43E11.1
+F55B12.4	C43E11.1
+F56A11.1	C43E11.1
+F56A3.3	C43E11.1
+F56D2.4	C43E11.1
+F57B9.3	C43E11.1
+F57B9.6	C43E11.1
+F59A2.1	C43E11.1
+H06H21.3	C43E11.1
+H35B03.2	C43E11.1
+K01G5.4	C43E11.1
+K02F3.11	C43E11.1
+K04G2.1	C43E11.1
+K07F5.13	C43E11.1
+K12C11.2	C43E11.1
+K12D12.2	C43E11.1
+M110.4	C43E11.1
+M18.7	C43E11.1
+R03G5.1	C43E11.1
+R04A9.4	C43E11.1
+R06F6.5	C43E11.1
+R07E5.14	C43E11.1
+R07G3.3	C43E11.1
+R08D7.3	C43E11.1
+R09B3.5	C43E11.1
+R186.7	C43E11.1
+T01G9.4	C43E11.1
+T02H6.2	C43E11.1
+T06A10.1	C43E11.1
+T08G11.4	C43E11.1
+T20G5.9	C43E11.1
+T23D8.4	C43E11.1
+T23H2.1	C43E11.1
+T25G3.3	C43E11.1
+T27F7.3	C43E11.1
+W08E3.2	C43E11.1
+Y106G6H.2	C43E11.1
+Y32H12A.2	C43E11.1
+Y37E3.10	C43E11.1
+Y37E3.15	C43E11.1
+Y39A3CR.1	C43E11.1
+Y39G10AR.8	C43E11.1
+Y40B1B.5	C43E11.1
+Y41D4B.19	C43E11.1
+Y43F4B.4	C43E11.1
+Y47H9C.7	C43E11.1
+Y48G8AL.6	C43E11.1
+Y54E2A.11	C43E11.1
+Y54F10BM.2	C43E11.1
+Y57A10A.30	C43E11.1
+Y62E10A.2	C43E11.1
+Y65B4A.6	C43E11.1
+Y66A7A.2	C43E11.1
+Y71F9AM.5	C43E11.1
+Y71H2B.2	C43E11.1
+Y73B6BL.18	C43E11.1
+Y74C10AR.1	C43E11.1
+Y77E11A.13	C43E11.1
+ZK1098.4	C43E11.1
+ZK632.14	C43E11.1
+ZK742.1	C43E11.1
+C49H3.10	C44H9.4
+D1007.4	C44H9.4
+D2013.7	C44H9.4
+D2085.3	C44H9.4
+E01G4.4	C44H9.4
+E04A4.4	C44H9.4
+F07A11.3	C44H9.4
+F10E9.5	C44H9.4
+F10G8.3	C44H9.4
+F11A3.2	C44H9.4
+F18H3.3	C44H9.4
+F22B5.2	C44H9.4
+F23B2.6	C44H9.4
+F23F1.5	C44H9.4
+F26A3.2	C44H9.4
+F28B3.8	C44H9.4
+F28D9.1	C44H9.4
+F29B9.6	C44H9.4
+F31E3.5	C44H9.4
+F32H2.4	C44H9.4
+F33D11.10	C44H9.4
+F37E3.1	C44H9.4
+F46B6.3	C44H9.4
+F53A2.6	C44H9.4
+F53F10.5	C44H9.4
+F55B12.4	C44H9.4
+F56A11.1	C44H9.4
+F56A3.3	C44H9.4
+F56D2.4	C44H9.4
+F57B9.3	C44H9.4
+F57B9.6	C44H9.4
+F59A2.1	C44H9.4
+H06H21.3	C44H9.4
+H35B03.2	C44H9.4
+K01G5.4	C44H9.4
+K02F3.11	C44H9.4
+K04G2.1	C44H9.4
+K07F5.13	C44H9.4
+K12C11.2	C44H9.4
+K12D12.2	C44H9.4
+M110.4	C44H9.4
+M18.7	C44H9.4
+R03G5.1	C44H9.4
+R04A9.4	C44H9.4
+R06F6.5	C44H9.4
+R07E5.14	C44H9.4
+R07G3.3	C44H9.4
+R08D7.3	C44H9.4
+R09B3.5	C44H9.4
+R186.7	C44H9.4
+T01G9.4	C44H9.4
+T02H6.2	C44H9.4
+T06A10.1	C44H9.4
+T08G11.4	C44H9.4
+T20G5.9	C44H9.4
+T23D8.4	C44H9.4
+T23H2.1	C44H9.4
+T25G3.3	C44H9.4
+T27F7.3	C44H9.4
+W08E3.2	C44H9.4
+Y106G6H.2	C44H9.4
+Y32H12A.2	C44H9.4
+Y37E3.10	C44H9.4
+Y37E3.15	C44H9.4
+Y39A3CR.1	C44H9.4
+Y39G10AR.8	C44H9.4
+Y40B1B.5	C44H9.4
+Y41D4B.19	C44H9.4
+Y43F4B.4	C44H9.4
+Y47H9C.7	C44H9.4
+Y48G8AL.6	C44H9.4
+Y54E2A.11	C44H9.4
+Y54F10BM.2	C44H9.4
+Y57A10A.30	C44H9.4
+Y62E10A.2	C44H9.4
+Y65B4A.6	C44H9.4
+Y66A7A.2	C44H9.4
+Y71F9AM.5	C44H9.4
+Y71H2B.2	C44H9.4
+Y73B6BL.18	C44H9.4
+Y74C10AR.1	C44H9.4
+Y77E11A.13	C44H9.4
+ZK1098.4	C44H9.4
+ZK632.14	C44H9.4
+ZK742.1	C44H9.4
+D1007.4	C49H3.10
+D2013.7	C49H3.10
+D2085.3	C49H3.10
+E01G4.4	C49H3.10
+E04A4.4	C49H3.10
+F07A11.3	C49H3.10
+F10E9.5	C49H3.10
+F10G8.3	C49H3.10
+F11A3.2	C49H3.10
+F18H3.3	C49H3.10
+F22B5.2	C49H3.10
+F23B2.6	C49H3.10
+F23F1.5	C49H3.10
+F26A3.2	C49H3.10
+F28B3.8	C49H3.10
+F28D9.1	C49H3.10
+F29B9.6	C49H3.10
+F31E3.5	C49H3.10
+F32H2.4	C49H3.10
+F33D11.10	C49H3.10
+F37E3.1	C49H3.10
+F46B6.3	C49H3.10
+F53A2.6	C49H3.10
+F53F10.5	C49H3.10
+F55B12.4	C49H3.10
+F56A11.1	C49H3.10
+F56A3.3	C49H3.10
+F56D2.4	C49H3.10
+F57B9.3	C49H3.10
+F57B9.6	C49H3.10
+F59A2.1	C49H3.10
+H06H21.3	C49H3.10
+H35B03.2	C49H3.10
+K01G5.4	C49H3.10
+K02F3.11	C49H3.10
+K04G2.1	C49H3.10
+K07F5.13	C49H3.10
+K12C11.2	C49H3.10
+K12D12.2	C49H3.10
+M110.4	C49H3.10
+M18.7	C49H3.10
+R03G5.1	C49H3.10
+R04A9.4	C49H3.10
+R06F6.5	C49H3.10
+R07E5.14	C49H3.10
+R07G3.3	C49H3.10
+R08D7.3	C49H3.10
+R09B3.5	C49H3.10
+R186.7	C49H3.10
+T01G9.4	C49H3.10
+T02H6.2	C49H3.10
+T06A10.1	C49H3.10
+T08G11.4	C49H3.10
+T20G5.9	C49H3.10
+T23D8.4	C49H3.10
+T23H2.1	C49H3.10
+T25G3.3	C49H3.10
+T27F7.3	C49H3.10
+W08E3.2	C49H3.10
+Y106G6H.2	C49H3.10
+Y32H12A.2	C49H3.10
+Y37E3.10	C49H3.10
+Y37E3.15	C49H3.10
+Y39A3CR.1	C49H3.10
+Y39G10AR.8	C49H3.10
+Y40B1B.5	C49H3.10
+Y41D4B.19	C49H3.10
+Y43F4B.4	C49H3.10
+Y47H9C.7	C49H3.10
+Y48G8AL.6	C49H3.10
+Y54E2A.11	C49H3.10
+Y54F10BM.2	C49H3.10
+Y57A10A.30	C49H3.10
+Y62E10A.2	C49H3.10
+Y65B4A.6	C49H3.10
+Y66A7A.2	C49H3.10
+Y71F9AM.5	C49H3.10
+Y71H2B.2	C49H3.10
+Y73B6BL.18	C49H3.10
+Y74C10AR.1	C49H3.10
+Y77E11A.13	C49H3.10
+ZK1098.4	C49H3.10
+ZK632.14	C49H3.10
+ZK742.1	C49H3.10
+D2013.7	D1007.4
+D2085.3	D1007.4
+E01G4.4	D1007.4
+E04A4.4	D1007.4
+F07A11.3	D1007.4
+F10E9.5	D1007.4
+F10G8.3	D1007.4
+F11A3.2	D1007.4
+F18H3.3	D1007.4
+F22B5.2	D1007.4
+F23B2.6	D1007.4
+F23F1.5	D1007.4
+F26A3.2	D1007.4
+F28B3.8	D1007.4
+F28D9.1	D1007.4
+F29B9.6	D1007.4
+F31E3.5	D1007.4
+F32H2.4	D1007.4
+F33D11.10	D1007.4
+F37E3.1	D1007.4
+F46B6.3	D1007.4
+F53A2.6	D1007.4
+F53F10.5	D1007.4
+F55B12.4	D1007.4
+F56A11.1	D1007.4
+F56A3.3	D1007.4
+F56D2.4	D1007.4
+F57B9.3	D1007.4
+F57B9.6	D1007.4
+F59A2.1	D1007.4
+H06H21.3	D1007.4
+H35B03.2	D1007.4
+K01G5.4	D1007.4
+K02F3.11	D1007.4
+K04G2.1	D1007.4
+K07F5.13	D1007.4
+K12C11.2	D1007.4
+K12D12.2	D1007.4
+M110.4	D1007.4
+M18.7	D1007.4
+R03G5.1	D1007.4
+R04A9.4	D1007.4
+R06F6.5	D1007.4
+R07E5.14	D1007.4
+R07G3.3	D1007.4
+R08D7.3	D1007.4
+R09B3.5	D1007.4
+R186.7	D1007.4
+T01G9.4	D1007.4
+T02H6.2	D1007.4
+T06A10.1	D1007.4
+T08G11.4	D1007.4
+T20G5.9	D1007.4
+T23D8.4	D1007.4
+T23H2.1	D1007.4
+T25G3.3	D1007.4
+T27F7.3	D1007.4
+W08E3.2	D1007.4
+Y106G6H.2	D1007.4
+Y32H12A.2	D1007.4
+Y37E3.10	D1007.4
+Y37E3.15	D1007.4
+Y39A3CR.1	D1007.4
+Y39G10AR.8	D1007.4
+Y40B1B.5	D1007.4
+Y41D4B.19	D1007.4
+Y43F4B.4	D1007.4
+Y47H9C.7	D1007.4
+Y48G8AL.6	D1007.4
+Y54E2A.11	D1007.4
+Y54F10BM.2	D1007.4
+Y57A10A.30	D1007.4
+Y62E10A.2	D1007.4
+Y65B4A.6	D1007.4
+Y66A7A.2	D1007.4
+Y71F9AM.5	D1007.4
+Y71H2B.2	D1007.4
+Y73B6BL.18	D1007.4
+Y74C10AR.1	D1007.4
+Y77E11A.13	D1007.4
+ZK1098.4	D1007.4
+ZK632.14	D1007.4
+ZK742.1	D1007.4
+D2085.3	D2013.7
+E01G4.4	D2013.7
+E04A4.4	D2013.7
+F07A11.3	D2013.7
+F10E9.5	D2013.7
+F10G8.3	D2013.7
+F11A3.2	D2013.7
+F18H3.3	D2013.7
+F22B5.2	D2013.7
+F23B2.6	D2013.7
+F23F1.5	D2013.7
+F26A3.2	D2013.7
+F28B3.8	D2013.7
+F28D9.1	D2013.7
+F29B9.6	D2013.7
+F31E3.5	D2013.7
+F32H2.4	D2013.7
+F33D11.10	D2013.7
+F37E3.1	D2013.7
+F46B6.3	D2013.7
+F53A2.6	D2013.7
+F53F10.5	D2013.7
+F55B12.4	D2013.7
+F56A11.1	D2013.7
+F56A3.3	D2013.7
+F56D2.4	D2013.7
+F57B9.3	D2013.7
+F57B9.6	D2013.7
+F59A2.1	D2013.7
+H06H21.3	D2013.7
+H35B03.2	D2013.7
+K01G5.4	D2013.7
+K02F3.11	D2013.7
+K04G2.1	D2013.7
+K07F5.13	D2013.7
+K12C11.2	D2013.7
+K12D12.2	D2013.7
+M110.4	D2013.7
+M18.7	D2013.7
+R03G5.1	D2013.7
+R04A9.4	D2013.7
+R06F6.5	D2013.7
+R07E5.14	D2013.7
+R07G3.3	D2013.7
+R08D7.3	D2013.7
+R09B3.5	D2013.7
+R186.7	D2013.7
+T01G9.4	D2013.7
+T02H6.2	D2013.7
+T06A10.1	D2013.7
+T08G11.4	D2013.7
+T20G5.9	D2013.7
+T23D8.4	D2013.7
+T23H2.1	D2013.7
+T25G3.3	D2013.7
+T27F7.3	D2013.7
+W08E3.2	D2013.7
+Y106G6H.2	D2013.7
+Y32H12A.2	D2013.7
+Y37E3.10	D2013.7
+Y37E3.15	D2013.7
+Y39A3CR.1	D2013.7
+Y39G10AR.8	D2013.7
+Y40B1B.5	D2013.7
+Y41D4B.19	D2013.7
+Y43F4B.4	D2013.7
+Y47H9C.7	D2013.7
+Y48G8AL.6	D2013.7
+Y54E2A.11	D2013.7
+Y54F10BM.2	D2013.7
+Y57A10A.30	D2013.7
+Y62E10A.2	D2013.7
+Y65B4A.6	D2013.7
+Y66A7A.2	D2013.7
+Y71F9AM.5	D2013.7
+Y71H2B.2	D2013.7
+Y73B6BL.18	D2013.7
+Y74C10AR.1	D2013.7
+Y77E11A.13	D2013.7
+ZK1098.4	D2013.7
+ZK632.14	D2013.7
+ZK742.1	D2013.7
+E01G4.4	D2085.3
+E04A4.4	D2085.3
+F07A11.3	D2085.3
+F10E9.5	D2085.3
+F10G8.3	D2085.3
+F11A3.2	D2085.3
+F18H3.3	D2085.3
+F22B5.2	D2085.3
+F23B2.6	D2085.3
+F23F1.5	D2085.3
+F26A3.2	D2085.3
+F28B3.8	D2085.3
+F28D9.1	D2085.3
+F29B9.6	D2085.3
+F31E3.5	D2085.3
+F32H2.4	D2085.3
+F33D11.10	D2085.3
+F37E3.1	D2085.3
+F46B6.3	D2085.3
+F53A2.6	D2085.3
+F53F10.5	D2085.3
+F55B12.4	D2085.3
+F56A11.1	D2085.3
+F56A3.3	D2085.3
+F56D2.4	D2085.3
+F57B9.3	D2085.3
+F57B9.6	D2085.3
+F59A2.1	D2085.3
+H06H21.3	D2085.3
+H35B03.2	D2085.3
+K01G5.4	D2085.3
+K02F3.11	D2085.3
+K04G2.1	D2085.3
+K07F5.13	D2085.3
+K12C11.2	D2085.3
+K12D12.2	D2085.3
+M110.4	D2085.3
+M18.7	D2085.3
+R03G5.1	D2085.3
+R04A9.4	D2085.3
+R06F6.5	D2085.3
+R07E5.14	D2085.3
+R07G3.3	D2085.3
+R08D7.3	D2085.3
+R09B3.5	D2085.3
+R186.7	D2085.3
+T01G9.4	D2085.3
+T02H6.2	D2085.3
+T06A10.1	D2085.3
+T08G11.4	D2085.3
+T20G5.9	D2085.3
+T23D8.4	D2085.3
+T23H2.1	D2085.3
+T25G3.3	D2085.3
+T27F7.3	D2085.3
+W08E3.2	D2085.3
+Y106G6H.2	D2085.3
+Y32H12A.2	D2085.3
+Y37E3.10	D2085.3
+Y37E3.15	D2085.3
+Y39A3CR.1	D2085.3
+Y39G10AR.8	D2085.3
+Y40B1B.5	D2085.3
+Y41D4B.19	D2085.3
+Y43F4B.4	D2085.3
+Y47H9C.7	D2085.3
+Y48G8AL.6	D2085.3
+Y54E2A.11	D2085.3
+Y54F10BM.2	D2085.3
+Y57A10A.30	D2085.3
+Y62E10A.2	D2085.3
+Y65B4A.6	D2085.3
+Y66A7A.2	D2085.3
+Y71F9AM.5	D2085.3
+Y71H2B.2	D2085.3
+Y73B6BL.18	D2085.3
+Y74C10AR.1	D2085.3
+Y77E11A.13	D2085.3
+ZK1098.4	D2085.3
+ZK632.14	D2085.3
+ZK742.1	D2085.3
+E04A4.4	E01G4.4
+F07A11.3	E01G4.4
+F10E9.5	E01G4.4
+F10G8.3	E01G4.4
+F11A3.2	E01G4.4
+F18H3.3	E01G4.4
+F22B5.2	E01G4.4
+F23B2.6	E01G4.4
+F23F1.5	E01G4.4
+F26A3.2	E01G4.4
+F28B3.8	E01G4.4
+F28D9.1	E01G4.4
+F29B9.6	E01G4.4
+F31E3.5	E01G4.4
+F32H2.4	E01G4.4
+F33D11.10	E01G4.4
+F37E3.1	E01G4.4
+F46B6.3	E01G4.4
+F53A2.6	E01G4.4
+F53F10.5	E01G4.4
+F55B12.4	E01G4.4
+F56A11.1	E01G4.4
+F56A3.3	E01G4.4
+F56D2.4	E01G4.4
+F57B9.3	E01G4.4
+F57B9.6	E01G4.4
+F59A2.1	E01G4.4
+H06H21.3	E01G4.4
+H35B03.2	E01G4.4
+K01G5.4	E01G4.4
+K02F3.11	E01G4.4
+K04G2.1	E01G4.4
+K07F5.13	E01G4.4
+K12C11.2	E01G4.4
+K12D12.2	E01G4.4
+M110.4	E01G4.4
+M18.7	E01G4.4
+R03G5.1	E01G4.4
+R04A9.4	E01G4.4
+R06F6.5	E01G4.4
+R07E5.14	E01G4.4
+R07G3.3	E01G4.4
+R08D7.3	E01G4.4
+R09B3.5	E01G4.4
+R186.7	E01G4.4
+T01G9.4	E01G4.4
+T02H6.2	E01G4.4
+T06A10.1	E01G4.4
+T08G11.4	E01G4.4
+T20G5.9	E01G4.4
+T23D8.4	E01G4.4
+T23H2.1	E01G4.4
+T25G3.3	E01G4.4
+T27F7.3	E01G4.4
+W08E3.2	E01G4.4
+Y106G6H.2	E01G4.4
+Y32H12A.2	E01G4.4
+Y37E3.10	E01G4.4
+Y37E3.15	E01G4.4
+Y39A3CR.1	E01G4.4
+Y39G10AR.8	E01G4.4
+Y40B1B.5	E01G4.4
+Y41D4B.19	E01G4.4
+Y43F4B.4	E01G4.4
+Y47H9C.7	E01G4.4
+Y48G8AL.6	E01G4.4
+Y54E2A.11	E01G4.4
+Y54F10BM.2	E01G4.4
+Y57A10A.30	E01G4.4
+Y62E10A.2	E01G4.4
+Y65B4A.6	E01G4.4
+Y66A7A.2	E01G4.4
+Y71F9AM.5	E01G4.4
+Y71H2B.2	E01G4.4
+Y73B6BL.18	E01G4.4
+Y74C10AR.1	E01G4.4
+Y77E11A.13	E01G4.4
+ZK1098.4	E01G4.4
+ZK632.14	E01G4.4
+ZK742.1	E01G4.4
+F07A11.3	E04A4.4
+F10E9.5	E04A4.4
+F10G8.3	E04A4.4
+F11A3.2	E04A4.4
+F18H3.3	E04A4.4
+F22B5.2	E04A4.4
+F23B2.6	E04A4.4
+F23F1.5	E04A4.4
+F26A3.2	E04A4.4
+F28B3.8	E04A4.4
+F28D9.1	E04A4.4
+F29B9.6	E04A4.4
+F31E3.5	E04A4.4
+F32H2.4	E04A4.4
+F33D11.10	E04A4.4
+F37E3.1	E04A4.4
+F46B6.3	E04A4.4
+F53A2.6	E04A4.4
+F53F10.5	E04A4.4
+F55B12.4	E04A4.4
+F56A11.1	E04A4.4
+F56A3.3	E04A4.4
+F56D2.4	E04A4.4
+F57B9.3	E04A4.4
+F57B9.6	E04A4.4
+F59A2.1	E04A4.4
+H06H21.3	E04A4.4
+H35B03.2	E04A4.4
+K01G5.4	E04A4.4
+K02F3.11	E04A4.4
+K04G2.1	E04A4.4
+K07F5.13	E04A4.4
+K12C11.2	E04A4.4
+K12D12.2	E04A4.4
+M110.4	E04A4.4
+M18.7	E04A4.4
+R03G5.1	E04A4.4
+R04A9.4	E04A4.4
+R06F6.5	E04A4.4
+R07E5.14	E04A4.4
+R07G3.3	E04A4.4
+R08D7.3	E04A4.4
+R09B3.5	E04A4.4
+R186.7	E04A4.4
+T01G9.4	E04A4.4
+T02H6.2	E04A4.4
+T06A10.1	E04A4.4
+T08G11.4	E04A4.4
+T20G5.9	E04A4.4
+T23D8.4	E04A4.4
+T23H2.1	E04A4.4
+T25G3.3	E04A4.4
+T27F7.3	E04A4.4
+W08E3.2	E04A4.4
+Y106G6H.2	E04A4.4
+Y32H12A.2	E04A4.4
+Y37E3.10	E04A4.4
+Y37E3.15	E04A4.4
+Y39A3CR.1	E04A4.4
+Y39G10AR.8	E04A4.4
+Y40B1B.5	E04A4.4
+Y41D4B.19	E04A4.4
+Y43F4B.4	E04A4.4
+Y47H9C.7	E04A4.4
+Y48G8AL.6	E04A4.4
+Y54E2A.11	E04A4.4
+Y54F10BM.2	E04A4.4
+Y57A10A.30	E04A4.4
+Y62E10A.2	E04A4.4
+Y65B4A.6	E04A4.4
+Y66A7A.2	E04A4.4
+Y71F9AM.5	E04A4.4
+Y71H2B.2	E04A4.4
+Y73B6BL.18	E04A4.4
+Y74C10AR.1	E04A4.4
+Y77E11A.13	E04A4.4
+ZK1098.4	E04A4.4
+ZK632.14	E04A4.4
+ZK742.1	E04A4.4
+F10E9.5	F07A11.3
+F10G8.3	F07A11.3
+F11A3.2	F07A11.3
+F18H3.3	F07A11.3
+F22B5.2	F07A11.3
+F23B2.6	F07A11.3
+F23F1.5	F07A11.3
+F26A3.2	F07A11.3
+F28B3.8	F07A11.3
+F28D9.1	F07A11.3
+F29B9.6	F07A11.3
+F31E3.5	F07A11.3
+F32H2.4	F07A11.3
+F33D11.10	F07A11.3
+F37E3.1	F07A11.3
+F46B6.3	F07A11.3
+F53A2.6	F07A11.3
+F53F10.5	F07A11.3
+F55B12.4	F07A11.3
+F56A11.1	F07A11.3
+F56A3.3	F07A11.3
+F56D2.4	F07A11.3
+F57B9.3	F07A11.3
+F57B9.6	F07A11.3
+F59A2.1	F07A11.3
+H06H21.3	F07A11.3
+H35B03.2	F07A11.3
+K01G5.4	F07A11.3
+K02F3.11	F07A11.3
+K04G2.1	F07A11.3
+K07F5.13	F07A11.3
+K12C11.2	F07A11.3
+K12D12.2	F07A11.3
+M110.4	F07A11.3
+M18.7	F07A11.3
+R03G5.1	F07A11.3
+R04A9.4	F07A11.3
+R06F6.5	F07A11.3
+R07E5.14	F07A11.3
+R07G3.3	F07A11.3
+R08D7.3	F07A11.3
+R09B3.5	F07A11.3
+R186.7	F07A11.3
+T01G9.4	F07A11.3
+T02H6.2	F07A11.3
+T06A10.1	F07A11.3
+T08G11.4	F07A11.3
+T20G5.9	F07A11.3
+T23D8.4	F07A11.3
+T23H2.1	F07A11.3
+T25G3.3	F07A11.3
+T27F7.3	F07A11.3
+W08E3.2	F07A11.3
+Y106G6H.2	F07A11.3
+Y32H12A.2	F07A11.3
+Y37E3.10	F07A11.3
+Y37E3.15	F07A11.3
+Y39A3CR.1	F07A11.3
+Y39G10AR.8	F07A11.3
+Y40B1B.5	F07A11.3
+Y41D4B.19	F07A11.3
+Y43F4B.4	F07A11.3
+Y47H9C.7	F07A11.3
+Y48G8AL.6	F07A11.3
+Y54E2A.11	F07A11.3
+Y54F10BM.2	F07A11.3
+Y57A10A.30	F07A11.3
+Y62E10A.2	F07A11.3
+Y65B4A.6	F07A11.3
+Y66A7A.2	F07A11.3
+Y71F9AM.5	F07A11.3
+Y71H2B.2	F07A11.3
+Y73B6BL.18	F07A11.3
+Y74C10AR.1	F07A11.3
+Y77E11A.13	F07A11.3
+ZK1098.4	F07A11.3
+ZK632.14	F07A11.3
+ZK742.1	F07A11.3
+F10G8.3	F10E9.5
+F11A3.2	F10E9.5
+F18H3.3	F10E9.5
+F22B5.2	F10E9.5
+F23B2.6	F10E9.5
+F23F1.5	F10E9.5
+F26A3.2	F10E9.5
+F28B3.8	F10E9.5
+F28D9.1	F10E9.5
+F29B9.6	F10E9.5
+F31E3.5	F10E9.5
+F32H2.4	F10E9.5
+F33D11.10	F10E9.5
+F37E3.1	F10E9.5
+F46B6.3	F10E9.5
+F53A2.6	F10E9.5
+F53F10.5	F10E9.5
+F55B12.4	F10E9.5
+F56A11.1	F10E9.5
+F56A3.3	F10E9.5
+F56D2.4	F10E9.5
+F57B9.3	F10E9.5
+F57B9.6	F10E9.5
+F59A2.1	F10E9.5
+H06H21.3	F10E9.5
+H35B03.2	F10E9.5
+K01G5.4	F10E9.5
+K02F3.11	F10E9.5
+K04G2.1	F10E9.5
+K07F5.13	F10E9.5
+K12C11.2	F10E9.5
+K12D12.2	F10E9.5
+M110.4	F10E9.5
+M18.7	F10E9.5
+R03G5.1	F10E9.5
+R04A9.4	F10E9.5
+R06F6.5	F10E9.5
+R07E5.14	F10E9.5
+R07G3.3	F10E9.5
+R08D7.3	F10E9.5
+R09B3.5	F10E9.5
+R186.7	F10E9.5
+T01G9.4	F10E9.5
+T02H6.2	F10E9.5
+T06A10.1	F10E9.5
+T08G11.4	F10E9.5
+T20G5.9	F10E9.5
+T23D8.4	F10E9.5
+T23H2.1	F10E9.5
+T25G3.3	F10E9.5
+T27F7.3	F10E9.5
+W08E3.2	F10E9.5
+Y106G6H.2	F10E9.5
+Y32H12A.2	F10E9.5
+Y37E3.10	F10E9.5
+Y37E3.15	F10E9.5
+Y39A3CR.1	F10E9.5
+Y39G10AR.8	F10E9.5
+Y40B1B.5	F10E9.5
+Y41D4B.19	F10E9.5
+Y43F4B.4	F10E9.5
+Y47H9C.7	F10E9.5
+Y48G8AL.6	F10E9.5
+Y54E2A.11	F10E9.5
+Y54F10BM.2	F10E9.5
+Y57A10A.30	F10E9.5
+Y62E10A.2	F10E9.5
+Y65B4A.6	F10E9.5
+Y66A7A.2	F10E9.5
+Y71F9AM.5	F10E9.5
+Y71H2B.2	F10E9.5
+Y73B6BL.18	F10E9.5
+Y74C10AR.1	F10E9.5
+Y77E11A.13	F10E9.5
+ZK1098.4	F10E9.5
+ZK632.14	F10E9.5
+ZK742.1	F10E9.5
+F11A3.2	F10G8.3
+F18H3.3	F10G8.3
+F22B5.2	F10G8.3
+F23B2.6	F10G8.3
+F23F1.5	F10G8.3
+F26A3.2	F10G8.3
+F28B3.8	F10G8.3
+F28D9.1	F10G8.3
+F29B9.6	F10G8.3
+F31E3.5	F10G8.3
+F32H2.4	F10G8.3
+F33D11.10	F10G8.3
+F37E3.1	F10G8.3
+F46B6.3	F10G8.3
+F53A2.6	F10G8.3
+F53F10.5	F10G8.3
+F55B12.4	F10G8.3
+F56A11.1	F10G8.3
+F56A3.3	F10G8.3
+F56D2.4	F10G8.3
+F57B9.3	F10G8.3
+F57B9.6	F10G8.3
+F59A2.1	F10G8.3
+H06H21.3	F10G8.3
+H35B03.2	F10G8.3
+K01G5.4	F10G8.3
+K02F3.11	F10G8.3
+K04G2.1	F10G8.3
+K07F5.13	F10G8.3
+K12C11.2	F10G8.3
+K12D12.2	F10G8.3
+M110.4	F10G8.3
+M18.7	F10G8.3
+R03G5.1	F10G8.3
+R04A9.4	F10G8.3
+R06F6.5	F10G8.3
+R07E5.14	F10G8.3
+R07G3.3	F10G8.3
+R08D7.3	F10G8.3
+R09B3.5	F10G8.3
+R186.7	F10G8.3
+T01G9.4	F10G8.3
+T02H6.2	F10G8.3
+T06A10.1	F10G8.3
+T08G11.4	F10G8.3
+T20G5.9	F10G8.3
+T23D8.4	F10G8.3
+T23H2.1	F10G8.3
+T25G3.3	F10G8.3
+T27F7.3	F10G8.3
+W08E3.2	F10G8.3
+Y106G6H.2	F10G8.3
+Y32H12A.2	F10G8.3
+Y37E3.10	F10G8.3
+Y37E3.15	F10G8.3
+Y39A3CR.1	F10G8.3
+Y39G10AR.8	F10G8.3
+Y40B1B.5	F10G8.3
+Y41D4B.19	F10G8.3
+Y43F4B.4	F10G8.3
+Y47H9C.7	F10G8.3
+Y48G8AL.6	F10G8.3
+Y54E2A.11	F10G8.3
+Y54F10BM.2	F10G8.3
+Y57A10A.30	F10G8.3
+Y62E10A.2	F10G8.3
+Y65B4A.6	F10G8.3
+Y66A7A.2	F10G8.3
+Y71F9AM.5	F10G8.3
+Y71H2B.2	F10G8.3
+Y73B6BL.18	F10G8.3
+Y74C10AR.1	F10G8.3
+Y77E11A.13	F10G8.3
+ZK1098.4	F10G8.3
+ZK632.14	F10G8.3
+ZK742.1	F10G8.3
+F18H3.3	F11A3.2
+F22B5.2	F11A3.2
+F23B2.6	F11A3.2
+F23F1.5	F11A3.2
+F26A3.2	F11A3.2
+F28B3.8	F11A3.2
+F28D9.1	F11A3.2
+F29B9.6	F11A3.2
+F31E3.5	F11A3.2
+F32H2.4	F11A3.2
+F33D11.10	F11A3.2
+F37E3.1	F11A3.2
+F46B6.3	F11A3.2
+F53A2.6	F11A3.2
+F53F10.5	F11A3.2
+F55B12.4	F11A3.2
+F56A11.1	F11A3.2
+F56A3.3	F11A3.2
+F56D2.4	F11A3.2
+F57B9.3	F11A3.2
+F57B9.6	F11A3.2
+F59A2.1	F11A3.2
+H06H21.3	F11A3.2
+H35B03.2	F11A3.2
+K01G5.4	F11A3.2
+K02F3.11	F11A3.2
+K04G2.1	F11A3.2
+K07F5.13	F11A3.2
+K12C11.2	F11A3.2
+K12D12.2	F11A3.2
+M110.4	F11A3.2
+M18.7	F11A3.2
+R03G5.1	F11A3.2
+R04A9.4	F11A3.2
+R06F6.5	F11A3.2
+R07E5.14	F11A3.2
+R07G3.3	F11A3.2
+R09B3.5	F11A3.2
+R186.7	F11A3.2
+T01G9.4	F11A3.2
+T02H6.2	F11A3.2
+T06A10.1	F11A3.2
+T08G11.4	F11A3.2
+T20G5.9	F11A3.2
+T23D8.4	F11A3.2
+T23H2.1	F11A3.2
+T25G3.3	F11A3.2
+T27F7.3	F11A3.2
+W08E3.2	F11A3.2
+Y106G6H.2	F11A3.2
+Y32H12A.2	F11A3.2
+Y37E3.10	F11A3.2
+Y37E3.15	F11A3.2
+Y39A3CR.1	F11A3.2
+Y39G10AR.8	F11A3.2
+Y40B1B.5	F11A3.2
+Y41D4B.19	F11A3.2
+Y43F4B.4	F11A3.2
+Y48G8AL.6	F11A3.2
+Y54F10BM.2	F11A3.2
+Y57A10A.30	F11A3.2
+Y62E10A.2	F11A3.2
+Y65B4A.6	F11A3.2
+Y66A7A.2	F11A3.2
+Y71F9AM.5	F11A3.2
+Y71H2B.2	F11A3.2
+Y73B6BL.18	F11A3.2
+Y74C10AR.1	F11A3.2
+Y77E11A.13	F11A3.2
+ZK632.14	F11A3.2
+ZK742.1	F11A3.2
+F22B5.2	F18H3.3
+F23B2.6	F18H3.3
+F23F1.5	F18H3.3
+F26A3.2	F18H3.3
+F28B3.8	F18H3.3
+F28D9.1	F18H3.3
+F29B9.6	F18H3.3
+F31E3.5	F18H3.3
+F32H2.4	F18H3.3
+F33D11.10	F18H3.3
+F37E3.1	F18H3.3
+F46B6.3	F18H3.3
+F53A2.6	F18H3.3
+F53F10.5	F18H3.3
+F55B12.4	F18H3.3
+F56A11.1	F18H3.3
+F56A3.3	F18H3.3
+F56D2.4	F18H3.3
+F57B9.3	F18H3.3
+F57B9.6	F18H3.3
+F59A2.1	F18H3.3
+H06H21.3	F18H3.3
+H35B03.2	F18H3.3
+K01G5.4	F18H3.3
+K02F3.11	F18H3.3
+K04G2.1	F18H3.3
+K07F5.13	F18H3.3
+K12C11.2	F18H3.3
+K12D12.2	F18H3.3
+M110.4	F18H3.3
+M18.7	F18H3.3
+R03G5.1	F18H3.3
+R04A9.4	F18H3.3
+R06F6.5	F18H3.3
+R07E5.14	F18H3.3
+R07G3.3	F18H3.3
+R08D7.3	F18H3.3
+R09B3.5	F18H3.3
+R186.7	F18H3.3
+T01G9.4	F18H3.3
+T02H6.2	F18H3.3
+T06A10.1	F18H3.3
+T08G11.4	F18H3.3
+T20G5.9	F18H3.3
+T23D8.4	F18H3.3
+T23H2.1	F18H3.3
+T25G3.3	F18H3.3
+T27F7.3	F18H3.3
+W08E3.2	F18H3.3
+Y106G6H.2	F18H3.3
+Y32H12A.2	F18H3.3
+Y37E3.10	F18H3.3
+Y37E3.15	F18H3.3
+Y39A3CR.1	F18H3.3
+Y39G10AR.8	F18H3.3
+Y40B1B.5	F18H3.3
+Y41D4B.19	F18H3.3
+Y43F4B.4	F18H3.3
+Y47H9C.7	F18H3.3
+Y48G8AL.6	F18H3.3
+Y54E2A.11	F18H3.3
+Y54F10BM.2	F18H3.3
+Y57A10A.30	F18H3.3
+Y62E10A.2	F18H3.3
+Y65B4A.6	F18H3.3
+Y66A7A.2	F18H3.3
+Y71F9AM.5	F18H3.3
+Y71H2B.2	F18H3.3
+Y73B6BL.18	F18H3.3
+Y74C10AR.1	F18H3.3
+Y77E11A.13	F18H3.3
+ZK1098.4	F18H3.3
+ZK632.14	F18H3.3
+ZK742.1	F18H3.3
+F23B2.6	F22B5.2
+F23F1.5	F22B5.2
+F26A3.2	F22B5.2
+F28B3.8	F22B5.2
+F28D9.1	F22B5.2
+F29B9.6	F22B5.2
+F31E3.5	F22B5.2
+F32H2.4	F22B5.2
+F33D11.10	F22B5.2
+F37E3.1	F22B5.2
+F46B6.3	F22B5.2
+F53A2.6	F22B5.2
+F53F10.5	F22B5.2
+F55B12.4	F22B5.2
+F56A11.1	F22B5.2
+F56A3.3	F22B5.2
+F56D2.4	F22B5.2
+F57B9.3	F22B5.2
+F57B9.6	F22B5.2
+F59A2.1	F22B5.2
+H06H21.3	F22B5.2
+H35B03.2	F22B5.2
+K01G5.4	F22B5.2
+K02F3.11	F22B5.2
+K04G2.1	F22B5.2
+K07F5.13	F22B5.2
+K12C11.2	F22B5.2
+K12D12.2	F22B5.2
+M110.4	F22B5.2
+M18.7	F22B5.2
+R03G5.1	F22B5.2
+R04A9.4	F22B5.2
+R06F6.5	F22B5.2
+R07E5.14	F22B5.2
+R07G3.3	F22B5.2
+R08D7.3	F22B5.2
+R09B3.5	F22B5.2
+R186.7	F22B5.2
+T01G9.4	F22B5.2
+T02H6.2	F22B5.2
+T06A10.1	F22B5.2
+T08G11.4	F22B5.2
+T20G5.9	F22B5.2
+T23D8.4	F22B5.2
+T23H2.1	F22B5.2
+T25G3.3	F22B5.2
+T27F7.3	F22B5.2
+W08E3.2	F22B5.2
+Y106G6H.2	F22B5.2
+Y32H12A.2	F22B5.2
+Y37E3.10	F22B5.2
+Y37E3.15	F22B5.2
+Y39A3CR.1	F22B5.2
+Y39G10AR.8	F22B5.2
+Y40B1B.5	F22B5.2
+Y41D4B.19	F22B5.2
+Y43F4B.4	F22B5.2
+Y47H9C.7	F22B5.2
+Y48G8AL.6	F22B5.2
+Y54E2A.11	F22B5.2
+Y54F10BM.2	F22B5.2
+Y57A10A.30	F22B5.2
+Y62E10A.2	F22B5.2
+Y65B4A.6	F22B5.2
+Y66A7A.2	F22B5.2
+Y71F9AM.5	F22B5.2
+Y71H2B.2	F22B5.2
+Y73B6BL.18	F22B5.2
+Y74C10AR.1	F22B5.2
+Y77E11A.13	F22B5.2
+ZK1098.4	F22B5.2
+ZK632.14	F22B5.2
+ZK742.1	F22B5.2
+F23F1.5	F23B2.6
+F26A3.2	F23B2.6
+F28B3.8	F23B2.6
+F28D9.1	F23B2.6
+F29B9.6	F23B2.6
+F31E3.5	F23B2.6
+F32H2.4	F23B2.6
+F33D11.10	F23B2.6
+F37E3.1	F23B2.6
+F46B6.3	F23B2.6
+F53A2.6	F23B2.6
+F53F10.5	F23B2.6
+F55B12.4	F23B2.6
+F56A11.1	F23B2.6
+F56A3.3	F23B2.6
+F56D2.4	F23B2.6
+F57B9.3	F23B2.6
+F57B9.6	F23B2.6
+F59A2.1	F23B2.6
+H06H21.3	F23B2.6
+H35B03.2	F23B2.6
+K01G5.4	F23B2.6
+K02F3.11	F23B2.6
+K04G2.1	F23B2.6
+K07F5.13	F23B2.6
+K12C11.2	F23B2.6
+K12D12.2	F23B2.6
+M110.4	F23B2.6
+M18.7	F23B2.6
+R03G5.1	F23B2.6
+R04A9.4	F23B2.6
+R06F6.5	F23B2.6
+R07E5.14	F23B2.6
+R07G3.3	F23B2.6
+R08D7.3	F23B2.6
+R09B3.5	F23B2.6
+R186.7	F23B2.6
+T01G9.4	F23B2.6
+T02H6.2	F23B2.6
+T06A10.1	F23B2.6
+T08G11.4	F23B2.6
+T20G5.9	F23B2.6
+T23D8.4	F23B2.6
+T23H2.1	F23B2.6
+T25G3.3	F23B2.6
+T27F7.3	F23B2.6
+W08E3.2	F23B2.6
+Y106G6H.2	F23B2.6
+Y32H12A.2	F23B2.6
+Y37E3.10	F23B2.6
+Y37E3.15	F23B2.6
+Y39A3CR.1	F23B2.6
+Y39G10AR.8	F23B2.6
+Y40B1B.5	F23B2.6
+Y41D4B.19	F23B2.6
+Y43F4B.4	F23B2.6
+Y47H9C.7	F23B2.6
+Y48G8AL.6	F23B2.6
+Y54E2A.11	F23B2.6
+Y54F10BM.2	F23B2.6
+Y57A10A.30	F23B2.6
+Y62E10A.2	F23B2.6
+Y65B4A.6	F23B2.6
+Y66A7A.2	F23B2.6
+Y71F9AM.5	F23B2.6
+Y71H2B.2	F23B2.6
+Y73B6BL.18	F23B2.6
+Y74C10AR.1	F23B2.6
+Y77E11A.13	F23B2.6
+ZK1098.4	F23B2.6
+ZK632.14	F23B2.6
+ZK742.1	F23B2.6
+F26A3.2	F23F1.5
+F28B3.8	F23F1.5
+F28D9.1	F23F1.5
+F29B9.6	F23F1.5
+F31E3.5	F23F1.5
+F32H2.4	F23F1.5
+F33D11.10	F23F1.5
+F37E3.1	F23F1.5
+F46B6.3	F23F1.5
+F53A2.6	F23F1.5
+F53F10.5	F23F1.5
+F55B12.4	F23F1.5
+F56A11.1	F23F1.5
+F56A3.3	F23F1.5
+F56D2.4	F23F1.5
+F57B9.3	F23F1.5
+F57B9.6	F23F1.5
+F59A2.1	F23F1.5
+H06H21.3	F23F1.5
+H35B03.2	F23F1.5
+K01G5.4	F23F1.5
+K02F3.11	F23F1.5
+K04G2.1	F23F1.5
+K07F5.13	F23F1.5
+K12C11.2	F23F1.5
+K12D12.2	F23F1.5
+M110.4	F23F1.5
+M18.7	F23F1.5
+R03G5.1	F23F1.5
+R04A9.4	F23F1.5
+R06F6.5	F23F1.5
+R07E5.14	F23F1.5
+R07G3.3	F23F1.5
+R08D7.3	F23F1.5
+R09B3.5	F23F1.5
+R186.7	F23F1.5
+T01G9.4	F23F1.5
+T02H6.2	F23F1.5
+T06A10.1	F23F1.5
+T08G11.4	F23F1.5
+T20G5.9	F23F1.5
+T23D8.4	F23F1.5
+T23H2.1	F23F1.5
+T25G3.3	F23F1.5
+T27F7.3	F23F1.5
+W08E3.2	F23F1.5
+Y106G6H.2	F23F1.5
+Y32H12A.2	F23F1.5
+Y37E3.10	F23F1.5
+Y37E3.15	F23F1.5
+Y39A3CR.1	F23F1.5
+Y39G10AR.8	F23F1.5
+Y40B1B.5	F23F1.5
+Y41D4B.19	F23F1.5
+Y43F4B.4	F23F1.5
+Y47H9C.7	F23F1.5
+Y48G8AL.6	F23F1.5
+Y54E2A.11	F23F1.5
+Y54F10BM.2	F23F1.5
+Y57A10A.30	F23F1.5
+Y62E10A.2	F23F1.5
+Y65B4A.6	F23F1.5
+Y66A7A.2	F23F1.5
+Y71F9AM.5	F23F1.5
+Y71H2B.2	F23F1.5
+Y73B6BL.18	F23F1.5
+Y74C10AR.1	F23F1.5
+Y77E11A.13	F23F1.5
+ZK1098.4	F23F1.5
+ZK632.14	F23F1.5
+ZK742.1	F23F1.5
+F28B3.8	F26A3.2
+F28D9.1	F26A3.2
+F29B9.6	F26A3.2
+F31E3.5	F26A3.2
+F32H2.4	F26A3.2
+F33D11.10	F26A3.2
+F37E3.1	F26A3.2
+F46B6.3	F26A3.2
+F53A2.6	F26A3.2
+F53F10.5	F26A3.2
+F55B12.4	F26A3.2
+F56A11.1	F26A3.2
+F56A3.3	F26A3.2
+F56D2.4	F26A3.2
+F57B9.3	F26A3.2
+F57B9.6	F26A3.2
+F59A2.1	F26A3.2
+H06H21.3	F26A3.2
+H35B03.2	F26A3.2
+K01G5.4	F26A3.2
+K02F3.11	F26A3.2
+K04G2.1	F26A3.2
+K07F5.13	F26A3.2
+K12C11.2	F26A3.2
+K12D12.2	F26A3.2
+M110.4	F26A3.2
+M18.7	F26A3.2
+R03G5.1	F26A3.2
+R04A9.4	F26A3.2
+R06F6.5	F26A3.2
+R07E5.14	F26A3.2
+R07G3.3	F26A3.2
+R08D7.3	F26A3.2
+R09B3.5	F26A3.2
+R186.7	F26A3.2
+T01G9.4	F26A3.2
+T02H6.2	F26A3.2
+T06A10.1	F26A3.2
+T08G11.4	F26A3.2
+T20G5.9	F26A3.2
+T23D8.4	F26A3.2
+T23H2.1	F26A3.2
+T25G3.3	F26A3.2
+T27F7.3	F26A3.2
+W08E3.2	F26A3.2
+Y106G6H.2	F26A3.2
+Y32H12A.2	F26A3.2
+Y37E3.10	F26A3.2
+Y37E3.15	F26A3.2
+Y39A3CR.1	F26A3.2
+Y39G10AR.8	F26A3.2
+Y40B1B.5	F26A3.2
+Y41D4B.19	F26A3.2
+Y43F4B.4	F26A3.2
+Y47H9C.7	F26A3.2
+Y48G8AL.6	F26A3.2
+Y54E2A.11	F26A3.2
+Y54F10BM.2	F26A3.2
+Y57A10A.30	F26A3.2
+Y62E10A.2	F26A3.2
+Y65B4A.6	F26A3.2
+Y66A7A.2	F26A3.2
+Y71F9AM.5	F26A3.2
+Y71H2B.2	F26A3.2
+Y73B6BL.18	F26A3.2
+Y74C10AR.1	F26A3.2
+Y77E11A.13	F26A3.2
+ZK1098.4	F26A3.2
+ZK632.14	F26A3.2
+ZK742.1	F26A3.2
+F28D9.1	F28B3.8
+F29B9.6	F28B3.8
+F31E3.5	F28B3.8
+F32H2.4	F28B3.8
+F33D11.10	F28B3.8
+F37E3.1	F28B3.8
+F46B6.3	F28B3.8
+F53A2.6	F28B3.8
+F53F10.5	F28B3.8
+F55B12.4	F28B3.8
+F56A11.1	F28B3.8
+F56A3.3	F28B3.8
+F56D2.4	F28B3.8
+F57B9.3	F28B3.8
+F57B9.6	F28B3.8
+F59A2.1	F28B3.8
+H06H21.3	F28B3.8
+H35B03.2	F28B3.8
+K01G5.4	F28B3.8
+K02F3.11	F28B3.8
+K04G2.1	F28B3.8
+K07F5.13	F28B3.8
+K12C11.2	F28B3.8
+K12D12.2	F28B3.8
+M110.4	F28B3.8
+M18.7	F28B3.8
+R03G5.1	F28B3.8
+R04A9.4	F28B3.8
+R06F6.5	F28B3.8
+R07E5.14	F28B3.8
+R07G3.3	F28B3.8
+R08D7.3	F28B3.8
+R09B3.5	F28B3.8
+R186.7	F28B3.8
+T01G9.4	F28B3.8
+T02H6.2	F28B3.8
+T06A10.1	F28B3.8
+T08G11.4	F28B3.8
+T20G5.9	F28B3.8
+T23D8.4	F28B3.8
+T23H2.1	F28B3.8
+T25G3.3	F28B3.8
+T27F7.3	F28B3.8
+W08E3.2	F28B3.8
+Y106G6H.2	F28B3.8
+Y32H12A.2	F28B3.8
+Y37E3.10	F28B3.8
+Y37E3.15	F28B3.8
+Y39A3CR.1	F28B3.8
+Y39G10AR.8	F28B3.8
+Y40B1B.5	F28B3.8
+Y41D4B.19	F28B3.8
+Y43F4B.4	F28B3.8
+Y47H9C.7	F28B3.8
+Y48G8AL.6	F28B3.8
+Y54E2A.11	F28B3.8
+Y54F10BM.2	F28B3.8
+Y57A10A.30	F28B3.8
+Y62E10A.2	F28B3.8
+Y65B4A.6	F28B3.8
+Y66A7A.2	F28B3.8
+Y71F9AM.5	F28B3.8
+Y71H2B.2	F28B3.8
+Y73B6BL.18	F28B3.8
+Y74C10AR.1	F28B3.8
+Y77E11A.13	F28B3.8
+ZK1098.4	F28B3.8
+ZK632.14	F28B3.8
+ZK742.1	F28B3.8
+F29B9.6	F28D9.1
+F31E3.5	F28D9.1
+F32H2.4	F28D9.1
+F33D11.10	F28D9.1
+F37E3.1	F28D9.1
+F46B6.3	F28D9.1
+F53A2.6	F28D9.1
+F53F10.5	F28D9.1
+F55B12.4	F28D9.1
+F56A11.1	F28D9.1
+F56A3.3	F28D9.1
+F56D2.4	F28D9.1
+F57B9.3	F28D9.1
+F57B9.6	F28D9.1
+F59A2.1	F28D9.1
+H06H21.3	F28D9.1
+H35B03.2	F28D9.1
+K01G5.4	F28D9.1
+K02F3.11	F28D9.1
+K04G2.1	F28D9.1
+K07F5.13	F28D9.1
+K12C11.2	F28D9.1
+K12D12.2	F28D9.1
+M110.4	F28D9.1
+M18.7	F28D9.1
+R03G5.1	F28D9.1
+R04A9.4	F28D9.1
+R06F6.5	F28D9.1
+R07E5.14	F28D9.1
+R07G3.3	F28D9.1
+R08D7.3	F28D9.1
+R09B3.5	F28D9.1
+R186.7	F28D9.1
+T01G9.4	F28D9.1
+T02H6.2	F28D9.1
+T06A10.1	F28D9.1
+T08G11.4	F28D9.1
+T20G5.9	F28D9.1
+T23D8.4	F28D9.1
+T23H2.1	F28D9.1
+T25G3.3	F28D9.1
+T27F7.3	F28D9.1
+W08E3.2	F28D9.1
+Y106G6H.2	F28D9.1
+Y32H12A.2	F28D9.1
+Y37E3.10	F28D9.1
+Y37E3.15	F28D9.1
+Y39A3CR.1	F28D9.1
+Y39G10AR.8	F28D9.1
+Y40B1B.5	F28D9.1
+Y41D4B.19	F28D9.1
+Y43F4B.4	F28D9.1
+Y47H9C.7	F28D9.1
+Y48G8AL.6	F28D9.1
+Y54E2A.11	F28D9.1
+Y54F10BM.2	F28D9.1
+Y57A10A.30	F28D9.1
+Y62E10A.2	F28D9.1
+Y65B4A.6	F28D9.1
+Y66A7A.2	F28D9.1
+Y71F9AM.5	F28D9.1
+Y71H2B.2	F28D9.1
+Y73B6BL.18	F28D9.1
+Y74C10AR.1	F28D9.1
+Y77E11A.13	F28D9.1
+ZK1098.4	F28D9.1
+ZK632.14	F28D9.1
+ZK742.1	F28D9.1
+F31E3.5	F29B9.6
+F32H2.4	F29B9.6
+F33D11.10	F29B9.6
+F37E3.1	F29B9.6
+F46B6.3	F29B9.6
+F53A2.6	F29B9.6
+F53F10.5	F29B9.6
+F55B12.4	F29B9.6
+F56A11.1	F29B9.6
+F56A3.3	F29B9.6
+F56D2.4	F29B9.6
+F57B9.3	F29B9.6
+F57B9.6	F29B9.6
+F59A2.1	F29B9.6
+H06H21.3	F29B9.6
+H35B03.2	F29B9.6
+K01G5.4	F29B9.6
+K02F3.11	F29B9.6
+K04G2.1	F29B9.6
+K07F5.13	F29B9.6
+K12C11.2	F29B9.6
+K12D12.2	F29B9.6
+M110.4	F29B9.6
+M18.7	F29B9.6
+R03G5.1	F29B9.6
+R04A9.4	F29B9.6
+R06F6.5	F29B9.6
+R07E5.14	F29B9.6
+R07G3.3	F29B9.6
+R08D7.3	F29B9.6
+R09B3.5	F29B9.6
+R186.7	F29B9.6
+T01G9.4	F29B9.6
+T02H6.2	F29B9.6
+T06A10.1	F29B9.6
+T08G11.4	F29B9.6
+T20G5.9	F29B9.6
+T23D8.4	F29B9.6
+T23H2.1	F29B9.6
+T25G3.3	F29B9.6
+T27F7.3	F29B9.6
+W08E3.2	F29B9.6
+Y106G6H.2	F29B9.6
+Y32H12A.2	F29B9.6
+Y37E3.10	F29B9.6
+Y37E3.15	F29B9.6
+Y39A3CR.1	F29B9.6
+Y39G10AR.8	F29B9.6
+Y40B1B.5	F29B9.6
+Y41D4B.19	F29B9.6
+Y43F4B.4	F29B9.6
+Y47H9C.7	F29B9.6
+Y48G8AL.6	F29B9.6
+Y54E2A.11	F29B9.6
+Y54F10BM.2	F29B9.6
+Y57A10A.30	F29B9.6
+Y62E10A.2	F29B9.6
+Y65B4A.6	F29B9.6
+Y66A7A.2	F29B9.6
+Y71F9AM.5	F29B9.6
+Y71H2B.2	F29B9.6
+Y73B6BL.18	F29B9.6
+Y74C10AR.1	F29B9.6
+Y77E11A.13	F29B9.6
+ZK1098.4	F29B9.6
+ZK632.14	F29B9.6
+ZK742.1	F29B9.6
+F32H2.4	F31E3.5
+F33D11.10	F31E3.5
+F37E3.1	F31E3.5
+F46B6.3	F31E3.5
+F53A2.6	F31E3.5
+F53F10.5	F31E3.5
+F55B12.4	F31E3.5
+F56A11.1	F31E3.5
+F56A3.3	F31E3.5
+F56D2.4	F31E3.5
+F57B9.3	F31E3.5
+F57B9.6	F31E3.5
+F59A2.1	F31E3.5
+H06H21.3	F31E3.5
+H35B03.2	F31E3.5
+K01G5.4	F31E3.5
+K02F3.11	F31E3.5
+K04G2.1	F31E3.5
+K07F5.13	F31E3.5
+K12C11.2	F31E3.5
+K12D12.2	F31E3.5
+M110.4	F31E3.5
+M18.7	F31E3.5
+R03G5.1	F31E3.5
+R04A9.4	F31E3.5
+R06F6.5	F31E3.5
+R07E5.14	F31E3.5
+R07G3.3	F31E3.5
+R08D7.3	F31E3.5
+R09B3.5	F31E3.5
+R186.7	F31E3.5
+T01G9.4	F31E3.5
+T02H6.2	F31E3.5
+T06A10.1	F31E3.5
+T08G11.4	F31E3.5
+T20G5.9	F31E3.5
+T23D8.4	F31E3.5
+T23H2.1	F31E3.5
+T25G3.3	F31E3.5
+T27F7.3	F31E3.5
+W08E3.2	F31E3.5
+Y106G6H.2	F31E3.5
+Y32H12A.2	F31E3.5
+Y37E3.10	F31E3.5
+Y37E3.15	F31E3.5
+Y39A3CR.1	F31E3.5
+Y39G10AR.8	F31E3.5
+Y40B1B.5	F31E3.5
+Y41D4B.19	F31E3.5
+Y43F4B.4	F31E3.5
+Y47H9C.7	F31E3.5
+Y48G8AL.6	F31E3.5
+Y54E2A.11	F31E3.5
+Y54F10BM.2	F31E3.5
+Y57A10A.30	F31E3.5
+Y62E10A.2	F31E3.5
+Y65B4A.6	F31E3.5
+Y66A7A.2	F31E3.5
+Y71F9AM.5	F31E3.5
+Y71H2B.2	F31E3.5
+Y73B6BL.18	F31E3.5
+Y74C10AR.1	F31E3.5
+Y77E11A.13	F31E3.5
+ZK1098.4	F31E3.5
+ZK632.14	F31E3.5
+ZK742.1	F31E3.5
+F33D11.10	F32H2.4
+F37E3.1	F32H2.4
+F46B6.3	F32H2.4
+F53A2.6	F32H2.4
+F53F10.5	F32H2.4
+F55B12.4	F32H2.4
+F56A11.1	F32H2.4
+F56A3.3	F32H2.4
+F56D2.4	F32H2.4
+F57B9.3	F32H2.4
+F57B9.6	F32H2.4
+F59A2.1	F32H2.4
+H06H21.3	F32H2.4
+H35B03.2	F32H2.4
+K01G5.4	F32H2.4
+K02F3.11	F32H2.4
+K04G2.1	F32H2.4
+K07F5.13	F32H2.4
+K12C11.2	F32H2.4
+K12D12.2	F32H2.4
+M110.4	F32H2.4
+M18.7	F32H2.4
+R03G5.1	F32H2.4
+R04A9.4	F32H2.4
+R06F6.5	F32H2.4
+R07E5.14	F32H2.4
+R07G3.3	F32H2.4
+R08D7.3	F32H2.4
+R09B3.5	F32H2.4
+R186.7	F32H2.4
+T01G9.4	F32H2.4
+T02H6.2	F32H2.4
+T06A10.1	F32H2.4
+T08G11.4	F32H2.4
+T20G5.9	F32H2.4
+T23D8.4	F32H2.4
+T23H2.1	F32H2.4
+T25G3.3	F32H2.4
+T27F7.3	F32H2.4
+W08E3.2	F32H2.4
+Y106G6H.2	F32H2.4
+Y32H12A.2	F32H2.4
+Y37E3.10	F32H2.4
+Y37E3.15	F32H2.4
+Y39A3CR.1	F32H2.4
+Y39G10AR.8	F32H2.4
+Y40B1B.5	F32H2.4
+Y41D4B.19	F32H2.4
+Y43F4B.4	F32H2.4
+Y47H9C.7	F32H2.4
+Y48G8AL.6	F32H2.4
+Y54E2A.11	F32H2.4
+Y54F10BM.2	F32H2.4
+Y57A10A.30	F32H2.4
+Y62E10A.2	F32H2.4
+Y65B4A.6	F32H2.4
+Y66A7A.2	F32H2.4
+Y71F9AM.5	F32H2.4
+Y71H2B.2	F32H2.4
+Y73B6BL.18	F32H2.4
+Y74C10AR.1	F32H2.4
+Y77E11A.13	F32H2.4
+ZK1098.4	F32H2.4
+ZK632.14	F32H2.4
+ZK742.1	F32H2.4
+F37E3.1	F33D11.10
+F46B6.3	F33D11.10
+F53A2.6	F33D11.10
+F53F10.5	F33D11.10
+F55B12.4	F33D11.10
+F56A11.1	F33D11.10
+F56A3.3	F33D11.10
+F56D2.4	F33D11.10
+F57B9.3	F33D11.10
+F57B9.6	F33D11.10
+F59A2.1	F33D11.10
+H06H21.3	F33D11.10
+H35B03.2	F33D11.10
+K01G5.4	F33D11.10
+K02F3.11	F33D11.10
+K04G2.1	F33D11.10
+K07F5.13	F33D11.10
+K12C11.2	F33D11.10
+K12D12.2	F33D11.10
+M110.4	F33D11.10
+M18.7	F33D11.10
+R03G5.1	F33D11.10
+R04A9.4	F33D11.10
+R06F6.5	F33D11.10
+R07E5.14	F33D11.10
+R07G3.3	F33D11.10
+R08D7.3	F33D11.10
+R09B3.5	F33D11.10
+R186.7	F33D11.10
+T01G9.4	F33D11.10
+T02H6.2	F33D11.10
+T06A10.1	F33D11.10
+T08G11.4	F33D11.10
+T20G5.9	F33D11.10
+T23D8.4	F33D11.10
+T23H2.1	F33D11.10
+T25G3.3	F33D11.10
+T27F7.3	F33D11.10
+W08E3.2	F33D11.10
+Y106G6H.2	F33D11.10
+Y32H12A.2	F33D11.10
+Y37E3.10	F33D11.10
+Y37E3.15	F33D11.10
+Y39A3CR.1	F33D11.10
+Y39G10AR.8	F33D11.10
+Y40B1B.5	F33D11.10
+Y41D4B.19	F33D11.10
+Y43F4B.4	F33D11.10
+Y47H9C.7	F33D11.10
+Y48G8AL.6	F33D11.10
+Y54E2A.11	F33D11.10
+Y54F10BM.2	F33D11.10
+Y57A10A.30	F33D11.10
+Y62E10A.2	F33D11.10
+Y65B4A.6	F33D11.10
+Y66A7A.2	F33D11.10
+Y71F9AM.5	F33D11.10
+Y71H2B.2	F33D11.10
+Y73B6BL.18	F33D11.10
+Y74C10AR.1	F33D11.10
+Y77E11A.13	F33D11.10
+ZK1098.4	F33D11.10
+ZK632.14	F33D11.10
+ZK742.1	F33D11.10
+F46B6.3	F37E3.1
+F53A2.6	F37E3.1
+F53F10.5	F37E3.1
+F55B12.4	F37E3.1
+F56A11.1	F37E3.1
+F56A3.3	F37E3.1
+F56D2.4	F37E3.1
+F57B9.3	F37E3.1
+F57B9.6	F37E3.1
+F59A2.1	F37E3.1
+H06H21.3	F37E3.1
+H35B03.2	F37E3.1
+K01G5.4	F37E3.1
+K02F3.11	F37E3.1
+K04G2.1	F37E3.1
+K07F5.13	F37E3.1
+K12C11.2	F37E3.1
+K12D12.2	F37E3.1
+M110.4	F37E3.1
+M18.7	F37E3.1
+R03G5.1	F37E3.1
+R04A9.4	F37E3.1
+R06F6.5	F37E3.1
+R07E5.14	F37E3.1
+R07G3.3	F37E3.1
+R08D7.3	F37E3.1
+R09B3.5	F37E3.1
+R186.7	F37E3.1
+T01G9.4	F37E3.1
+T02H6.2	F37E3.1
+T06A10.1	F37E3.1
+T08G11.4	F37E3.1
+T20G5.9	F37E3.1
+T23D8.4	F37E3.1
+T23H2.1	F37E3.1
+T25G3.3	F37E3.1
+T27F7.3	F37E3.1
+W08E3.2	F37E3.1
+Y106G6H.2	F37E3.1
+Y32H12A.2	F37E3.1
+Y37E3.10	F37E3.1
+Y37E3.15	F37E3.1
+Y39A3CR.1	F37E3.1
+Y39G10AR.8	F37E3.1
+Y40B1B.5	F37E3.1
+Y41D4B.19	F37E3.1
+Y43F4B.4	F37E3.1
+Y47H9C.7	F37E3.1
+Y48G8AL.6	F37E3.1
+Y54E2A.11	F37E3.1
+Y54F10BM.2	F37E3.1
+Y57A10A.30	F37E3.1
+Y62E10A.2	F37E3.1
+Y65B4A.6	F37E3.1
+Y66A7A.2	F37E3.1
+Y71F9AM.5	F37E3.1
+Y71H2B.2	F37E3.1
+Y73B6BL.18	F37E3.1
+Y74C10AR.1	F37E3.1
+Y77E11A.13	F37E3.1
+ZK1098.4	F37E3.1
+ZK632.14	F37E3.1
+ZK742.1	F37E3.1
+F53A2.6	F46B6.3
+F53F10.5	F46B6.3
+F55B12.4	F46B6.3
+F56A11.1	F46B6.3
+F56A3.3	F46B6.3
+F56D2.4	F46B6.3
+F57B9.3	F46B6.3
+F57B9.6	F46B6.3
+F59A2.1	F46B6.3
+H06H21.3	F46B6.3
+H35B03.2	F46B6.3
+K01G5.4	F46B6.3
+K02F3.11	F46B6.3
+K04G2.1	F46B6.3
+K07F5.13	F46B6.3
+K12C11.2	F46B6.3
+K12D12.2	F46B6.3
+M110.4	F46B6.3
+M18.7	F46B6.3
+R03G5.1	F46B6.3
+R04A9.4	F46B6.3
+R06F6.5	F46B6.3
+R07E5.14	F46B6.3
+R07G3.3	F46B6.3
+R08D7.3	F46B6.3
+R09B3.5	F46B6.3
+R186.7	F46B6.3
+T01G9.4	F46B6.3
+T02H6.2	F46B6.3
+T06A10.1	F46B6.3
+T08G11.4	F46B6.3
+T20G5.9	F46B6.3
+T23D8.4	F46B6.3
+T23H2.1	F46B6.3
+T25G3.3	F46B6.3
+T27F7.3	F46B6.3
+W08E3.2	F46B6.3
+Y106G6H.2	F46B6.3
+Y32H12A.2	F46B6.3
+Y37E3.10	F46B6.3
+Y37E3.15	F46B6.3
+Y39A3CR.1	F46B6.3
+Y39G10AR.8	F46B6.3
+Y40B1B.5	F46B6.3
+Y41D4B.19	F46B6.3
+Y43F4B.4	F46B6.3
+Y47H9C.7	F46B6.3
+Y48G8AL.6	F46B6.3
+Y54E2A.11	F46B6.3
+Y54F10BM.2	F46B6.3
+Y57A10A.30	F46B6.3
+Y62E10A.2	F46B6.3
+Y65B4A.6	F46B6.3
+Y66A7A.2	F46B6.3
+Y71F9AM.5	F46B6.3
+Y71H2B.2	F46B6.3
+Y73B6BL.18	F46B6.3
+Y74C10AR.1	F46B6.3
+Y77E11A.13	F46B6.3
+ZK1098.4	F46B6.3
+ZK632.14	F46B6.3
+ZK742.1	F46B6.3
+F53F10.5	F53A2.6
+F55B12.4	F53A2.6
+F56A11.1	F53A2.6
+F56A3.3	F53A2.6
+F56D2.4	F53A2.6
+F57B9.3	F53A2.6
+F57B9.6	F53A2.6
+F59A2.1	F53A2.6
+H06H21.3	F53A2.6
+H35B03.2	F53A2.6
+K01G5.4	F53A2.6
+K02F3.11	F53A2.6
+K04G2.1	F53A2.6
+K07F5.13	F53A2.6
+K12C11.2	F53A2.6
+K12D12.2	F53A2.6
+M110.4	F53A2.6
+M18.7	F53A2.6
+R03G5.1	F53A2.6
+R04A9.4	F53A2.6
+R06F6.5	F53A2.6
+R07E5.14	F53A2.6
+R07G3.3	F53A2.6
+R08D7.3	F53A2.6
+R09B3.5	F53A2.6
+R186.7	F53A2.6
+T01G9.4	F53A2.6
+T02H6.2	F53A2.6
+T06A10.1	F53A2.6
+T08G11.4	F53A2.6
+T20G5.9	F53A2.6
+T23D8.4	F53A2.6
+T23H2.1	F53A2.6
+T25G3.3	F53A2.6
+T27F7.3	F53A2.6
+W08E3.2	F53A2.6
+Y106G6H.2	F53A2.6
+Y32H12A.2	F53A2.6
+Y37E3.10	F53A2.6
+Y37E3.15	F53A2.6
+Y39A3CR.1	F53A2.6
+Y39G10AR.8	F53A2.6
+Y40B1B.5	F53A2.6
+Y41D4B.19	F53A2.6
+Y43F4B.4	F53A2.6
+Y47H9C.7	F53A2.6
+Y48G8AL.6	F53A2.6
+Y54E2A.11	F53A2.6
+Y54F10BM.2	F53A2.6
+Y57A10A.30	F53A2.6
+Y62E10A.2	F53A2.6
+Y65B4A.6	F53A2.6
+Y66A7A.2	F53A2.6
+Y71F9AM.5	F53A2.6
+Y71H2B.2	F53A2.6
+Y73B6BL.18	F53A2.6
+Y74C10AR.1	F53A2.6
+Y77E11A.13	F53A2.6
+ZK1098.4	F53A2.6
+ZK632.14	F53A2.6
+ZK742.1	F53A2.6
+F55B12.4	F53F10.5
+F56A11.1	F53F10.5
+F56A3.3	F53F10.5
+F56D2.4	F53F10.5
+F57B9.3	F53F10.5
+F57B9.6	F53F10.5
+F59A2.1	F53F10.5
+H06H21.3	F53F10.5
+H35B03.2	F53F10.5
+K01G5.4	F53F10.5
+K02F3.11	F53F10.5
+K04G2.1	F53F10.5
+K07F5.13	F53F10.5
+K12C11.2	F53F10.5
+K12D12.2	F53F10.5
+M110.4	F53F10.5
+M18.7	F53F10.5
+R03G5.1	F53F10.5
+R04A9.4	F53F10.5
+R06F6.5	F53F10.5
+R07E5.14	F53F10.5
+R07G3.3	F53F10.5
+R08D7.3	F53F10.5
+R09B3.5	F53F10.5
+R186.7	F53F10.5
+T01G9.4	F53F10.5
+T02H6.2	F53F10.5
+T06A10.1	F53F10.5
+T08G11.4	F53F10.5
+T20G5.9	F53F10.5
+T23D8.4	F53F10.5
+T23H2.1	F53F10.5
+T25G3.3	F53F10.5
+T27F7.3	F53F10.5
+W08E3.2	F53F10.5
+Y106G6H.2	F53F10.5
+Y32H12A.2	F53F10.5
+Y37E3.10	F53F10.5
+Y37E3.15	F53F10.5
+Y39A3CR.1	F53F10.5
+Y39G10AR.8	F53F10.5
+Y40B1B.5	F53F10.5
+Y41D4B.19	F53F10.5
+Y43F4B.4	F53F10.5
+Y47H9C.7	F53F10.5
+Y48G8AL.6	F53F10.5
+Y54E2A.11	F53F10.5
+Y54F10BM.2	F53F10.5
+Y57A10A.30	F53F10.5
+Y62E10A.2	F53F10.5
+Y65B4A.6	F53F10.5
+Y66A7A.2	F53F10.5
+Y71F9AM.5	F53F10.5
+Y71H2B.2	F53F10.5
+Y73B6BL.18	F53F10.5
+Y74C10AR.1	F53F10.5
+Y77E11A.13	F53F10.5
+ZK1098.4	F53F10.5
+ZK632.14	F53F10.5
+ZK742.1	F53F10.5
+F56A11.1	F55B12.4
+F56A3.3	F55B12.4
+F56D2.4	F55B12.4
+F57B9.3	F55B12.4
+F57B9.6	F55B12.4
+F59A2.1	F55B12.4
+H06H21.3	F55B12.4
+H35B03.2	F55B12.4
+K01G5.4	F55B12.4
+K02F3.11	F55B12.4
+K04G2.1	F55B12.4
+K07F5.13	F55B12.4
+K12C11.2	F55B12.4
+K12D12.2	F55B12.4
+M110.4	F55B12.4
+M18.7	F55B12.4
+R03G5.1	F55B12.4
+R04A9.4	F55B12.4
+R06F6.5	F55B12.4
+R07E5.14	F55B12.4
+R07G3.3	F55B12.4
+R08D7.3	F55B12.4
+R09B3.5	F55B12.4
+R186.7	F55B12.4
+T01G9.4	F55B12.4
+T02H6.2	F55B12.4
+T06A10.1	F55B12.4
+T08G11.4	F55B12.4
+T20G5.9	F55B12.4
+T23D8.4	F55B12.4
+T23H2.1	F55B12.4
+T25G3.3	F55B12.4
+T27F7.3	F55B12.4
+W08E3.2	F55B12.4
+Y106G6H.2	F55B12.4
+Y32H12A.2	F55B12.4
+Y37E3.10	F55B12.4
+Y37E3.15	F55B12.4
+Y39A3CR.1	F55B12.4
+Y39G10AR.8	F55B12.4
+Y40B1B.5	F55B12.4
+Y41D4B.19	F55B12.4
+Y43F4B.4	F55B12.4
+Y47H9C.7	F55B12.4
+Y48G8AL.6	F55B12.4
+Y54E2A.11	F55B12.4
+Y54F10BM.2	F55B12.4
+Y57A10A.30	F55B12.4
+Y62E10A.2	F55B12.4
+Y65B4A.6	F55B12.4
+Y66A7A.2	F55B12.4
+Y71F9AM.5	F55B12.4
+Y71H2B.2	F55B12.4
+Y73B6BL.18	F55B12.4
+Y74C10AR.1	F55B12.4
+Y77E11A.13	F55B12.4
+ZK1098.4	F55B12.4
+ZK632.14	F55B12.4
+ZK742.1	F55B12.4
+F56A3.3	F56A11.1
+F56D2.4	F56A11.1
+F57B9.3	F56A11.1
+F57B9.6	F56A11.1
+F59A2.1	F56A11.1
+H06H21.3	F56A11.1
+H35B03.2	F56A11.1
+K01G5.4	F56A11.1
+K02F3.11	F56A11.1
+K04G2.1	F56A11.1
+K07F5.13	F56A11.1
+K12C11.2	F56A11.1
+K12D12.2	F56A11.1
+M110.4	F56A11.1
+M18.7	F56A11.1
+R03G5.1	F56A11.1
+R04A9.4	F56A11.1
+R06F6.5	F56A11.1
+R07E5.14	F56A11.1
+R07G3.3	F56A11.1
+R08D7.3	F56A11.1
+R09B3.5	F56A11.1
+R186.7	F56A11.1
+T01G9.4	F56A11.1
+T02H6.2	F56A11.1
+T06A10.1	F56A11.1
+T08G11.4	F56A11.1
+T20G5.9	F56A11.1
+T23D8.4	F56A11.1
+T23H2.1	F56A11.1
+T25G3.3	F56A11.1
+T27F7.3	F56A11.1
+W08E3.2	F56A11.1
+Y106G6H.2	F56A11.1
+Y32H12A.2	F56A11.1
+Y37E3.10	F56A11.1
+Y37E3.15	F56A11.1
+Y39A3CR.1	F56A11.1
+Y39G10AR.8	F56A11.1
+Y40B1B.5	F56A11.1
+Y41D4B.19	F56A11.1
+Y43F4B.4	F56A11.1
+Y47H9C.7	F56A11.1
+Y48G8AL.6	F56A11.1
+Y54E2A.11	F56A11.1
+Y54F10BM.2	F56A11.1
+Y57A10A.30	F56A11.1
+Y62E10A.2	F56A11.1
+Y65B4A.6	F56A11.1
+Y66A7A.2	F56A11.1
+Y71F9AM.5	F56A11.1
+Y71H2B.2	F56A11.1
+Y73B6BL.18	F56A11.1
+Y74C10AR.1	F56A11.1
+Y77E11A.13	F56A11.1
+ZK1098.4	F56A11.1
+ZK632.14	F56A11.1
+ZK742.1	F56A11.1
+F56D2.4	F56A3.3
+F57B9.3	F56A3.3
+F57B9.6	F56A3.3
+F59A2.1	F56A3.3
+H06H21.3	F56A3.3
+H35B03.2	F56A3.3
+K01G5.4	F56A3.3
+K02F3.11	F56A3.3
+K04G2.1	F56A3.3
+K07F5.13	F56A3.3
+K12C11.2	F56A3.3
+K12D12.2	F56A3.3
+M110.4	F56A3.3
+M18.7	F56A3.3
+R03G5.1	F56A3.3
+R04A9.4	F56A3.3
+R06F6.5	F56A3.3
+R07E5.14	F56A3.3
+R07G3.3	F56A3.3
+R08D7.3	F56A3.3
+R09B3.5	F56A3.3
+R186.7	F56A3.3
+T01G9.4	F56A3.3
+T02H6.2	F56A3.3
+T06A10.1	F56A3.3
+T08G11.4	F56A3.3
+T20G5.9	F56A3.3
+T23D8.4	F56A3.3
+T23H2.1	F56A3.3
+T25G3.3	F56A3.3
+T27F7.3	F56A3.3
+W08E3.2	F56A3.3
+Y106G6H.2	F56A3.3
+Y32H12A.2	F56A3.3
+Y37E3.10	F56A3.3
+Y37E3.15	F56A3.3
+Y39A3CR.1	F56A3.3
+Y39G10AR.8	F56A3.3
+Y40B1B.5	F56A3.3
+Y41D4B.19	F56A3.3
+Y43F4B.4	F56A3.3
+Y47H9C.7	F56A3.3
+Y48G8AL.6	F56A3.3
+Y54E2A.11	F56A3.3
+Y54F10BM.2	F56A3.3
+Y57A10A.30	F56A3.3
+Y62E10A.2	F56A3.3
+Y65B4A.6	F56A3.3
+Y66A7A.2	F56A3.3
+Y71F9AM.5	F56A3.3
+Y71H2B.2	F56A3.3
+Y73B6BL.18	F56A3.3
+Y74C10AR.1	F56A3.3
+Y77E11A.13	F56A3.3
+ZK1098.4	F56A3.3
+ZK632.14	F56A3.3
+ZK742.1	F56A3.3
+F57B9.3	F56D2.4
+F57B9.6	F56D2.4
+F59A2.1	F56D2.4
+H06H21.3	F56D2.4
+H35B03.2	F56D2.4
+K01G5.4	F56D2.4
+K02F3.11	F56D2.4
+K04G2.1	F56D2.4
+K07F5.13	F56D2.4
+K12C11.2	F56D2.4
+K12D12.2	F56D2.4
+M110.4	F56D2.4
+M18.7	F56D2.4
+R03G5.1	F56D2.4
+R04A9.4	F56D2.4
+R06F6.5	F56D2.4
+R07E5.14	F56D2.4
+R07G3.3	F56D2.4
+R08D7.3	F56D2.4
+R09B3.5	F56D2.4
+R186.7	F56D2.4
+T01G9.4	F56D2.4
+T02H6.2	F56D2.4
+T06A10.1	F56D2.4
+T08G11.4	F56D2.4
+T20G5.9	F56D2.4
+T23D8.4	F56D2.4
+T23H2.1	F56D2.4
+T25G3.3	F56D2.4
+T27F7.3	F56D2.4
+W08E3.2	F56D2.4
+Y106G6H.2	F56D2.4
+Y32H12A.2	F56D2.4
+Y37E3.10	F56D2.4
+Y37E3.15	F56D2.4
+Y39A3CR.1	F56D2.4
+Y39G10AR.8	F56D2.4
+Y40B1B.5	F56D2.4
+Y41D4B.19	F56D2.4
+Y43F4B.4	F56D2.4
+Y47H9C.7	F56D2.4
+Y48G8AL.6	F56D2.4
+Y54E2A.11	F56D2.4
+Y54F10BM.2	F56D2.4
+Y57A10A.30	F56D2.4
+Y62E10A.2	F56D2.4
+Y65B4A.6	F56D2.4
+Y66A7A.2	F56D2.4
+Y71F9AM.5	F56D2.4
+Y71H2B.2	F56D2.4
+Y73B6BL.18	F56D2.4
+Y74C10AR.1	F56D2.4
+Y77E11A.13	F56D2.4
+ZK1098.4	F56D2.4
+ZK632.14	F56D2.4
+ZK742.1	F56D2.4
+F57B9.6	F57B9.3
+F59A2.1	F57B9.3
+H06H21.3	F57B9.3
+H35B03.2	F57B9.3
+K01G5.4	F57B9.3
+K02F3.11	F57B9.3
+K04G2.1	F57B9.3
+K07F5.13	F57B9.3
+K12C11.2	F57B9.3
+K12D12.2	F57B9.3
+M110.4	F57B9.3
+M18.7	F57B9.3
+R03G5.1	F57B9.3
+R04A9.4	F57B9.3
+R06F6.5	F57B9.3
+R07E5.14	F57B9.3
+R07G3.3	F57B9.3
+R08D7.3	F57B9.3
+R09B3.5	F57B9.3
+R186.7	F57B9.3
+T01G9.4	F57B9.3
+T02H6.2	F57B9.3
+T06A10.1	F57B9.3
+T08G11.4	F57B9.3
+T20G5.9	F57B9.3
+T23D8.4	F57B9.3
+T23H2.1	F57B9.3
+T25G3.3	F57B9.3
+T27F7.3	F57B9.3
+W08E3.2	F57B9.3
+Y106G6H.2	F57B9.3
+Y32H12A.2	F57B9.3
+Y37E3.10	F57B9.3
+Y37E3.15	F57B9.3
+Y39A3CR.1	F57B9.3
+Y39G10AR.8	F57B9.3
+Y40B1B.5	F57B9.3
+Y41D4B.19	F57B9.3
+Y43F4B.4	F57B9.3
+Y47H9C.7	F57B9.3
+Y48G8AL.6	F57B9.3
+Y54E2A.11	F57B9.3
+Y54F10BM.2	F57B9.3
+Y57A10A.30	F57B9.3
+Y62E10A.2	F57B9.3
+Y65B4A.6	F57B9.3
+Y66A7A.2	F57B9.3
+Y71F9AM.5	F57B9.3
+Y71H2B.2	F57B9.3
+Y73B6BL.18	F57B9.3
+Y74C10AR.1	F57B9.3
+Y77E11A.13	F57B9.3
+ZK1098.4	F57B9.3
+ZK632.14	F57B9.3
+ZK742.1	F57B9.3
+F59A2.1	F57B9.6
+H06H21.3	F57B9.6
+H35B03.2	F57B9.6
+K01G5.4	F57B9.6
+K02F3.11	F57B9.6
+K04G2.1	F57B9.6
+K07F5.13	F57B9.6
+K12C11.2	F57B9.6
+K12D12.2	F57B9.6
+M110.4	F57B9.6
+M18.7	F57B9.6
+R03G5.1	F57B9.6
+R04A9.4	F57B9.6
+R06F6.5	F57B9.6
+R07E5.14	F57B9.6
+R07G3.3	F57B9.6
+R08D7.3	F57B9.6
+R09B3.5	F57B9.6
+R186.7	F57B9.6
+T01G9.4	F57B9.6
+T02H6.2	F57B9.6
+T06A10.1	F57B9.6
+T08G11.4	F57B9.6
+T20G5.9	F57B9.6
+T23D8.4	F57B9.6
+T23H2.1	F57B9.6
+T25G3.3	F57B9.6
+T27F7.3	F57B9.6
+W08E3.2	F57B9.6
+Y106G6H.2	F57B9.6
+Y32H12A.2	F57B9.6
+Y37E3.10	F57B9.6
+Y37E3.15	F57B9.6
+Y39A3CR.1	F57B9.6
+Y39G10AR.8	F57B9.6
+Y40B1B.5	F57B9.6
+Y41D4B.19	F57B9.6
+Y43F4B.4	F57B9.6
+Y47H9C.7	F57B9.6
+Y48G8AL.6	F57B9.6
+Y54E2A.11	F57B9.6
+Y54F10BM.2	F57B9.6
+Y57A10A.30	F57B9.6
+Y62E10A.2	F57B9.6
+Y65B4A.6	F57B9.6
+Y66A7A.2	F57B9.6
+Y71F9AM.5	F57B9.6
+Y71H2B.2	F57B9.6
+Y73B6BL.18	F57B9.6
+Y74C10AR.1	F57B9.6
+Y77E11A.13	F57B9.6
+ZK1098.4	F57B9.6
+ZK632.14	F57B9.6
+ZK742.1	F57B9.6
+H06H21.3	F59A2.1
+H35B03.2	F59A2.1
+K01G5.4	F59A2.1
+K02F3.11	F59A2.1
+K04G2.1	F59A2.1
+K07F5.13	F59A2.1
+K12C11.2	F59A2.1
+K12D12.2	F59A2.1
+M110.4	F59A2.1
+M18.7	F59A2.1
+R03G5.1	F59A2.1
+R04A9.4	F59A2.1
+R06F6.5	F59A2.1
+R07E5.14	F59A2.1
+R07G3.3	F59A2.1
+R08D7.3	F59A2.1
+R09B3.5	F59A2.1
+R186.7	F59A2.1
+T01G9.4	F59A2.1
+T02H6.2	F59A2.1
+T06A10.1	F59A2.1
+T08G11.4	F59A2.1
+T20G5.9	F59A2.1
+T23D8.4	F59A2.1
+T23H2.1	F59A2.1
+T25G3.3	F59A2.1
+T27F7.3	F59A2.1
+W08E3.2	F59A2.1
+Y106G6H.2	F59A2.1
+Y32H12A.2	F59A2.1
+Y37E3.10	F59A2.1
+Y37E3.15	F59A2.1
+Y39A3CR.1	F59A2.1
+Y39G10AR.8	F59A2.1
+Y40B1B.5	F59A2.1
+Y41D4B.19	F59A2.1
+Y43F4B.4	F59A2.1
+Y47H9C.7	F59A2.1
+Y48G8AL.6	F59A2.1
+Y54E2A.11	F59A2.1
+Y54F10BM.2	F59A2.1
+Y57A10A.30	F59A2.1
+Y62E10A.2	F59A2.1
+Y65B4A.6	F59A2.1
+Y66A7A.2	F59A2.1
+Y71F9AM.5	F59A2.1
+Y71H2B.2	F59A2.1
+Y73B6BL.18	F59A2.1
+Y74C10AR.1	F59A2.1
+Y77E11A.13	F59A2.1
+ZK1098.4	F59A2.1
+ZK632.14	F59A2.1
+ZK742.1	F59A2.1
+H35B03.2	H06H21.3
+K01G5.4	H06H21.3
+K02F3.11	H06H21.3
+K04G2.1	H06H21.3
+K07F5.13	H06H21.3
+K12C11.2	H06H21.3
+K12D12.2	H06H21.3
+M110.4	H06H21.3
+M18.7	H06H21.3
+R03G5.1	H06H21.3
+R04A9.4	H06H21.3
+R06F6.5	H06H21.3
+R07E5.14	H06H21.3
+R07G3.3	H06H21.3
+R08D7.3	H06H21.3
+R09B3.5	H06H21.3
+R186.7	H06H21.3
+T01G9.4	H06H21.3
+T02H6.2	H06H21.3
+T06A10.1	H06H21.3
+T08G11.4	H06H21.3
+T20G5.9	H06H21.3
+T23D8.4	H06H21.3
+T23H2.1	H06H21.3
+T25G3.3	H06H21.3
+T27F7.3	H06H21.3
+W08E3.2	H06H21.3
+Y106G6H.2	H06H21.3
+Y32H12A.2	H06H21.3
+Y37E3.10	H06H21.3
+Y37E3.15	H06H21.3
+Y39A3CR.1	H06H21.3
+Y39G10AR.8	H06H21.3
+Y40B1B.5	H06H21.3
+Y41D4B.19	H06H21.3
+Y43F4B.4	H06H21.3
+Y47H9C.7	H06H21.3
+Y48G8AL.6	H06H21.3
+Y54E2A.11	H06H21.3
+Y54F10BM.2	H06H21.3
+Y57A10A.30	H06H21.3
+Y62E10A.2	H06H21.3
+Y65B4A.6	H06H21.3
+Y66A7A.2	H06H21.3
+Y71F9AM.5	H06H21.3
+Y71H2B.2	H06H21.3
+Y73B6BL.18	H06H21.3
+Y74C10AR.1	H06H21.3
+Y77E11A.13	H06H21.3
+ZK1098.4	H06H21.3
+ZK632.14	H06H21.3
+ZK742.1	H06H21.3
+K02F3.11	H35B03.2
+K04G2.1	H35B03.2
+K07F5.13	H35B03.2
+K12C11.2	H35B03.2
+K12D12.2	H35B03.2
+M110.4	H35B03.2
+M18.7	H35B03.2
+R03G5.1	H35B03.2
+R04A9.4	H35B03.2
+R06F6.5	H35B03.2
+R07E5.14	H35B03.2
+R07G3.3	H35B03.2
+R08D7.3	H35B03.2
+R09B3.5	H35B03.2
+R186.7	H35B03.2
+T01G9.4	H35B03.2
+T02H6.2	H35B03.2
+T06A10.1	H35B03.2
+T08G11.4	H35B03.2
+T20G5.9	H35B03.2
+T23D8.4	H35B03.2
+T23H2.1	H35B03.2
+T27F7.3	H35B03.2
+W08E3.2	H35B03.2
+Y106G6H.2	H35B03.2
+Y32H12A.2	H35B03.2
+Y37E3.10	H35B03.2
+Y37E3.15	H35B03.2
+Y39A3CR.1	H35B03.2
+Y39G10AR.8	H35B03.2
+Y40B1B.5	H35B03.2
+Y41D4B.19	H35B03.2
+Y43F4B.4	H35B03.2
+Y47H9C.7	H35B03.2
+Y48G8AL.6	H35B03.2
+Y54E2A.11	H35B03.2
+Y54F10BM.2	H35B03.2
+Y57A10A.30	H35B03.2
+Y65B4A.6	H35B03.2
+Y71H2B.2	H35B03.2
+Y73B6BL.18	H35B03.2
+Y74C10AR.1	H35B03.2
+Y77E11A.13	H35B03.2
+ZK1098.4	H35B03.2
+K02F3.11	K01G5.4
+K04G2.1	K01G5.4
+K07F5.13	K01G5.4
+K12C11.2	K01G5.4
+K12D12.2	K01G5.4
+M110.4	K01G5.4
+M18.7	K01G5.4
+R03G5.1	K01G5.4
+R04A9.4	K01G5.4
+R06F6.5	K01G5.4
+R07E5.14	K01G5.4
+R07G3.3	K01G5.4
+R08D7.3	K01G5.4
+R09B3.5	K01G5.4
+R186.7	K01G5.4
+T01G9.4	K01G5.4
+T02H6.2	K01G5.4
+T06A10.1	K01G5.4
+T08G11.4	K01G5.4
+T20G5.9	K01G5.4
+T23D8.4	K01G5.4
+T23H2.1	K01G5.4
+T27F7.3	K01G5.4
+W08E3.2	K01G5.4
+Y106G6H.2	K01G5.4
+Y32H12A.2	K01G5.4
+Y37E3.10	K01G5.4
+Y37E3.15	K01G5.4
+Y39A3CR.1	K01G5.4
+Y39G10AR.8	K01G5.4
+Y40B1B.5	K01G5.4
+Y41D4B.19	K01G5.4
+Y43F4B.4	K01G5.4
+Y47H9C.7	K01G5.4
+Y48G8AL.6	K01G5.4
+Y54E2A.11	K01G5.4
+Y54F10BM.2	K01G5.4
+Y57A10A.30	K01G5.4
+Y65B4A.6	K01G5.4
+Y71H2B.2	K01G5.4
+Y73B6BL.18	K01G5.4
+Y74C10AR.1	K01G5.4
+Y77E11A.13	K01G5.4
+ZK1098.4	K01G5.4
+K04G2.1	K02F3.11
+K07F5.13	K02F3.11
+K12C11.2	K02F3.11
+K12D12.2	K02F3.11
+M110.4	K02F3.11
+M18.7	K02F3.11
+R03G5.1	K02F3.11
+R04A9.4	K02F3.11
+R06F6.5	K02F3.11
+R07E5.14	K02F3.11
+R07G3.3	K02F3.11
+R08D7.3	K02F3.11
+R09B3.5	K02F3.11
+R186.7	K02F3.11
+T01G9.4	K02F3.11
+T02H6.2	K02F3.11
+T06A10.1	K02F3.11
+T08G11.4	K02F3.11
+T20G5.9	K02F3.11
+T23D8.4	K02F3.11
+T23H2.1	K02F3.11
+T25G3.3	K02F3.11
+T27F7.3	K02F3.11
+W08E3.2	K02F3.11
+Y106G6H.2	K02F3.11
+Y32H12A.2	K02F3.11
+Y37E3.10	K02F3.11
+Y37E3.15	K02F3.11
+Y39A3CR.1	K02F3.11
+Y39G10AR.8	K02F3.11
+Y40B1B.5	K02F3.11
+Y41D4B.19	K02F3.11
+Y43F4B.4	K02F3.11
+Y47H9C.7	K02F3.11
+Y48G8AL.6	K02F3.11
+Y54E2A.11	K02F3.11
+Y54F10BM.2	K02F3.11
+Y57A10A.30	K02F3.11
+Y62E10A.2	K02F3.11
+Y65B4A.6	K02F3.11
+Y66A7A.2	K02F3.11
+Y71F9AM.5	K02F3.11
+Y71H2B.2	K02F3.11
+Y73B6BL.18	K02F3.11
+Y74C10AR.1	K02F3.11
+Y77E11A.13	K02F3.11
+ZK1098.4	K02F3.11
+ZK632.14	K02F3.11
+ZK742.1	K02F3.11
+K07F5.13	K04G2.1
+K12C11.2	K04G2.1
+K12D12.2	K04G2.1
+M110.4	K04G2.1
+M18.7	K04G2.1
+R03G5.1	K04G2.1
+R04A9.4	K04G2.1
+R06F6.5	K04G2.1
+R07E5.14	K04G2.1
+R07G3.3	K04G2.1
+R08D7.3	K04G2.1
+R09B3.5	K04G2.1
+R186.7	K04G2.1
+T01G9.4	K04G2.1
+T02H6.2	K04G2.1
+T06A10.1	K04G2.1
+T08G11.4	K04G2.1
+T20G5.9	K04G2.1
+T23D8.4	K04G2.1
+T23H2.1	K04G2.1
+T25G3.3	K04G2.1
+T27F7.3	K04G2.1
+W08E3.2	K04G2.1
+Y106G6H.2	K04G2.1
+Y32H12A.2	K04G2.1
+Y37E3.10	K04G2.1
+Y37E3.15	K04G2.1
+Y39A3CR.1	K04G2.1
+Y39G10AR.8	K04G2.1
+Y40B1B.5	K04G2.1
+Y41D4B.19	K04G2.1
+Y43F4B.4	K04G2.1
+Y47H9C.7	K04G2.1
+Y48G8AL.6	K04G2.1
+Y54E2A.11	K04G2.1
+Y54F10BM.2	K04G2.1
+Y57A10A.30	K04G2.1
+Y62E10A.2	K04G2.1
+Y65B4A.6	K04G2.1
+Y66A7A.2	K04G2.1
+Y71F9AM.5	K04G2.1
+Y71H2B.2	K04G2.1
+Y73B6BL.18	K04G2.1
+Y74C10AR.1	K04G2.1
+Y77E11A.13	K04G2.1
+ZK1098.4	K04G2.1
+ZK632.14	K04G2.1
+ZK742.1	K04G2.1
+K12C11.2	K07F5.13
+K12D12.2	K07F5.13
+M110.4	K07F5.13
+M18.7	K07F5.13
+R03G5.1	K07F5.13
+R04A9.4	K07F5.13
+R06F6.5	K07F5.13
+R07E5.14	K07F5.13
+R07G3.3	K07F5.13
+R08D7.3	K07F5.13
+R09B3.5	K07F5.13
+R186.7	K07F5.13
+T01G9.4	K07F5.13
+T02H6.2	K07F5.13
+T06A10.1	K07F5.13
+T08G11.4	K07F5.13
+T20G5.9	K07F5.13
+T23D8.4	K07F5.13
+T23H2.1	K07F5.13
+T25G3.3	K07F5.13
+T27F7.3	K07F5.13
+W08E3.2	K07F5.13
+Y106G6H.2	K07F5.13
+Y32H12A.2	K07F5.13
+Y37E3.10	K07F5.13
+Y37E3.15	K07F5.13
+Y39A3CR.1	K07F5.13
+Y39G10AR.8	K07F5.13
+Y40B1B.5	K07F5.13
+Y41D4B.19	K07F5.13
+Y43F4B.4	K07F5.13
+Y47H9C.7	K07F5.13
+Y48G8AL.6	K07F5.13
+Y54E2A.11	K07F5.13
+Y54F10BM.2	K07F5.13
+Y57A10A.30	K07F5.13
+Y62E10A.2	K07F5.13
+Y65B4A.6	K07F5.13
+Y66A7A.2	K07F5.13
+Y71F9AM.5	K07F5.13
+Y71H2B.2	K07F5.13
+Y73B6BL.18	K07F5.13
+Y74C10AR.1	K07F5.13
+Y77E11A.13	K07F5.13
+ZK1098.4	K07F5.13
+ZK632.14	K07F5.13
+ZK742.1	K07F5.13
+K12D12.2	K12C11.2
+M110.4	K12C11.2
+M18.7	K12C11.2
+R03G5.1	K12C11.2
+R04A9.4	K12C11.2
+R06F6.5	K12C11.2
+R07E5.14	K12C11.2
+R07G3.3	K12C11.2
+R08D7.3	K12C11.2
+R09B3.5	K12C11.2
+R186.7	K12C11.2
+T01G9.4	K12C11.2
+T02H6.2	K12C11.2
+T06A10.1	K12C11.2
+T08G11.4	K12C11.2
+T20G5.9	K12C11.2
+T23D8.4	K12C11.2
+T23H2.1	K12C11.2
+T25G3.3	K12C11.2
+T27F7.3	K12C11.2
+W08E3.2	K12C11.2
+Y106G6H.2	K12C11.2
+Y32H12A.2	K12C11.2
+Y37E3.10	K12C11.2
+Y37E3.15	K12C11.2
+Y39A3CR.1	K12C11.2
+Y39G10AR.8	K12C11.2
+Y40B1B.5	K12C11.2
+Y41D4B.19	K12C11.2
+Y43F4B.4	K12C11.2
+Y47H9C.7	K12C11.2
+Y48G8AL.6	K12C11.2
+Y54E2A.11	K12C11.2
+Y54F10BM.2	K12C11.2
+Y57A10A.30	K12C11.2
+Y62E10A.2	K12C11.2
+Y65B4A.6	K12C11.2
+Y66A7A.2	K12C11.2
+Y71F9AM.5	K12C11.2
+Y71H2B.2	K12C11.2
+Y73B6BL.18	K12C11.2
+Y74C10AR.1	K12C11.2
+Y77E11A.13	K12C11.2
+ZK1098.4	K12C11.2
+ZK632.14	K12C11.2
+ZK742.1	K12C11.2
+M110.4	K12D12.2
+M18.7	K12D12.2
+R03G5.1	K12D12.2
+R04A9.4	K12D12.2
+R06F6.5	K12D12.2
+R07E5.14	K12D12.2
+R07G3.3	K12D12.2
+R08D7.3	K12D12.2
+R09B3.5	K12D12.2
+R186.7	K12D12.2
+T01G9.4	K12D12.2
+T02H6.2	K12D12.2
+T06A10.1	K12D12.2
+T08G11.4	K12D12.2
+T20G5.9	K12D12.2
+T23D8.4	K12D12.2
+T23H2.1	K12D12.2
+T25G3.3	K12D12.2
+T27F7.3	K12D12.2
+W08E3.2	K12D12.2
+Y106G6H.2	K12D12.2
+Y32H12A.2	K12D12.2
+Y37E3.10	K12D12.2
+Y37E3.15	K12D12.2
+Y39A3CR.1	K12D12.2
+Y39G10AR.8	K12D12.2
+Y40B1B.5	K12D12.2
+Y41D4B.19	K12D12.2
+Y43F4B.4	K12D12.2
+Y47H9C.7	K12D12.2
+Y48G8AL.6	K12D12.2
+Y54E2A.11	K12D12.2
+Y54F10BM.2	K12D12.2
+Y57A10A.30	K12D12.2
+Y62E10A.2	K12D12.2
+Y65B4A.6	K12D12.2
+Y66A7A.2	K12D12.2
+Y71F9AM.5	K12D12.2
+Y71H2B.2	K12D12.2
+Y73B6BL.18	K12D12.2
+Y74C10AR.1	K12D12.2
+Y77E11A.13	K12D12.2
+ZK1098.4	K12D12.2
+ZK632.14	K12D12.2
+ZK742.1	K12D12.2
+M18.7	M110.4
+R03G5.1	M110.4
+R04A9.4	M110.4
+R06F6.5	M110.4
+R07E5.14	M110.4
+R07G3.3	M110.4
+R08D7.3	M110.4
+R09B3.5	M110.4
+R186.7	M110.4
+T01G9.4	M110.4
+T02H6.2	M110.4
+T06A10.1	M110.4
+T08G11.4	M110.4
+T20G5.9	M110.4
+T23D8.4	M110.4
+T23H2.1	M110.4
+T25G3.3	M110.4
+T27F7.3	M110.4
+W08E3.2	M110.4
+Y106G6H.2	M110.4
+Y32H12A.2	M110.4
+Y37E3.10	M110.4
+Y37E3.15	M110.4
+Y39A3CR.1	M110.4
+Y39G10AR.8	M110.4
+Y40B1B.5	M110.4
+Y41D4B.19	M110.4
+Y43F4B.4	M110.4
+Y47H9C.7	M110.4
+Y48G8AL.6	M110.4
+Y54E2A.11	M110.4
+Y54F10BM.2	M110.4
+Y57A10A.30	M110.4
+Y62E10A.2	M110.4
+Y65B4A.6	M110.4
+Y66A7A.2	M110.4
+Y71F9AM.5	M110.4
+Y71H2B.2	M110.4
+Y73B6BL.18	M110.4
+Y74C10AR.1	M110.4
+Y77E11A.13	M110.4
+ZK1098.4	M110.4
+ZK632.14	M110.4
+ZK742.1	M110.4
+R03G5.1	M18.7
+R04A9.4	M18.7
+R06F6.5	M18.7
+R07E5.14	M18.7
+R07G3.3	M18.7
+R08D7.3	M18.7
+R09B3.5	M18.7
+R186.7	M18.7
+T01G9.4	M18.7
+T02H6.2	M18.7
+T06A10.1	M18.7
+T08G11.4	M18.7
+T20G5.9	M18.7
+T23D8.4	M18.7
+T23H2.1	M18.7
+T25G3.3	M18.7
+T27F7.3	M18.7
+W08E3.2	M18.7
+Y106G6H.2	M18.7
+Y32H12A.2	M18.7
+Y37E3.10	M18.7
+Y37E3.15	M18.7
+Y39A3CR.1	M18.7
+Y39G10AR.8	M18.7
+Y40B1B.5	M18.7
+Y41D4B.19	M18.7
+Y43F4B.4	M18.7
+Y47H9C.7	M18.7
+Y48G8AL.6	M18.7
+Y54E2A.11	M18.7
+Y54F10BM.2	M18.7
+Y57A10A.30	M18.7
+Y62E10A.2	M18.7
+Y65B4A.6	M18.7
+Y66A7A.2	M18.7
+Y71F9AM.5	M18.7
+Y71H2B.2	M18.7
+Y73B6BL.18	M18.7
+Y74C10AR.1	M18.7
+Y77E11A.13	M18.7
+ZK1098.4	M18.7
+ZK632.14	M18.7
+ZK742.1	M18.7
+R04A9.4	R03G5.1
+R06F6.5	R03G5.1
+R07E5.14	R03G5.1
+R07G3.3	R03G5.1
+R08D7.3	R03G5.1
+R09B3.5	R03G5.1
+R186.7	R03G5.1
+T01G9.4	R03G5.1
+T02H6.2	R03G5.1
+T06A10.1	R03G5.1
+T08G11.4	R03G5.1
+T20G5.9	R03G5.1
+T23D8.4	R03G5.1
+T23H2.1	R03G5.1
+T25G3.3	R03G5.1
+T27F7.3	R03G5.1
+W08E3.2	R03G5.1
+Y106G6H.2	R03G5.1
+Y32H12A.2	R03G5.1
+Y37E3.10	R03G5.1
+Y37E3.15	R03G5.1
+Y39A3CR.1	R03G5.1
+Y39G10AR.8	R03G5.1
+Y40B1B.5	R03G5.1
+Y41D4B.19	R03G5.1
+Y43F4B.4	R03G5.1
+Y47H9C.7	R03G5.1
+Y48G8AL.6	R03G5.1
+Y54E2A.11	R03G5.1
+Y54F10BM.2	R03G5.1
+Y57A10A.30	R03G5.1
+Y62E10A.2	R03G5.1
+Y65B4A.6	R03G5.1
+Y66A7A.2	R03G5.1
+Y71F9AM.5	R03G5.1
+Y71H2B.2	R03G5.1
+Y73B6BL.18	R03G5.1
+Y74C10AR.1	R03G5.1
+Y77E11A.13	R03G5.1
+ZK1098.4	R03G5.1
+ZK632.14	R03G5.1
+ZK742.1	R03G5.1
+R06F6.5	R04A9.4
+R07E5.14	R04A9.4
+R07G3.3	R04A9.4
+R08D7.3	R04A9.4
+R09B3.5	R04A9.4
+R186.7	R04A9.4
+T01G9.4	R04A9.4
+T02H6.2	R04A9.4
+T06A10.1	R04A9.4
+T08G11.4	R04A9.4
+T20G5.9	R04A9.4
+T23D8.4	R04A9.4
+T23H2.1	R04A9.4
+T25G3.3	R04A9.4
+T27F7.3	R04A9.4
+W08E3.2	R04A9.4
+Y106G6H.2	R04A9.4
+Y32H12A.2	R04A9.4
+Y37E3.10	R04A9.4
+Y37E3.15	R04A9.4
+Y39A3CR.1	R04A9.4
+Y39G10AR.8	R04A9.4
+Y40B1B.5	R04A9.4
+Y41D4B.19	R04A9.4
+Y43F4B.4	R04A9.4
+Y47H9C.7	R04A9.4
+Y48G8AL.6	R04A9.4
+Y54E2A.11	R04A9.4
+Y54F10BM.2	R04A9.4
+Y57A10A.30	R04A9.4
+Y62E10A.2	R04A9.4
+Y65B4A.6	R04A9.4
+Y66A7A.2	R04A9.4
+Y71F9AM.5	R04A9.4
+Y71H2B.2	R04A9.4
+Y73B6BL.18	R04A9.4
+Y74C10AR.1	R04A9.4
+Y77E11A.13	R04A9.4
+ZK1098.4	R04A9.4
+ZK632.14	R04A9.4
+ZK742.1	R04A9.4
+R07E5.14	R06F6.5
+R07G3.3	R06F6.5
+R08D7.3	R06F6.5
+R09B3.5	R06F6.5
+R186.7	R06F6.5
+T01G9.4	R06F6.5
+T02H6.2	R06F6.5
+T06A10.1	R06F6.5
+T08G11.4	R06F6.5
+T20G5.9	R06F6.5
+T23D8.4	R06F6.5
+T23H2.1	R06F6.5
+T25G3.3	R06F6.5
+T27F7.3	R06F6.5
+W08E3.2	R06F6.5
+Y106G6H.2	R06F6.5
+Y32H12A.2	R06F6.5
+Y37E3.10	R06F6.5
+Y37E3.15	R06F6.5
+Y39A3CR.1	R06F6.5
+Y39G10AR.8	R06F6.5
+Y40B1B.5	R06F6.5
+Y41D4B.19	R06F6.5
+Y43F4B.4	R06F6.5
+Y47H9C.7	R06F6.5
+Y48G8AL.6	R06F6.5
+Y54E2A.11	R06F6.5
+Y54F10BM.2	R06F6.5
+Y57A10A.30	R06F6.5
+Y62E10A.2	R06F6.5
+Y65B4A.6	R06F6.5
+Y66A7A.2	R06F6.5
+Y71F9AM.5	R06F6.5
+Y71H2B.2	R06F6.5
+Y73B6BL.18	R06F6.5
+Y74C10AR.1	R06F6.5
+Y77E11A.13	R06F6.5
+ZK1098.4	R06F6.5
+ZK632.14	R06F6.5
+ZK742.1	R06F6.5
+R07G3.3	R07E5.14
+R08D7.3	R07E5.14
+R09B3.5	R07E5.14
+R186.7	R07E5.14
+T01G9.4	R07E5.14
+T02H6.2	R07E5.14
+T06A10.1	R07E5.14
+T08G11.4	R07E5.14
+T20G5.9	R07E5.14
+T23D8.4	R07E5.14
+T23H2.1	R07E5.14
+T25G3.3	R07E5.14
+T27F7.3	R07E5.14
+W08E3.2	R07E5.14
+Y106G6H.2	R07E5.14
+Y32H12A.2	R07E5.14
+Y37E3.10	R07E5.14
+Y37E3.15	R07E5.14
+Y39A3CR.1	R07E5.14
+Y39G10AR.8	R07E5.14
+Y40B1B.5	R07E5.14
+Y41D4B.19	R07E5.14
+Y43F4B.4	R07E5.14
+Y47H9C.7	R07E5.14
+Y48G8AL.6	R07E5.14
+Y54E2A.11	R07E5.14
+Y54F10BM.2	R07E5.14
+Y57A10A.30	R07E5.14
+Y62E10A.2	R07E5.14
+Y65B4A.6	R07E5.14
+Y66A7A.2	R07E5.14
+Y71F9AM.5	R07E5.14
+Y71H2B.2	R07E5.14
+Y73B6BL.18	R07E5.14
+Y74C10AR.1	R07E5.14
+Y77E11A.13	R07E5.14
+ZK1098.4	R07E5.14
+ZK632.14	R07E5.14
+ZK742.1	R07E5.14
+R08D7.3	R07G3.3
+R09B3.5	R07G3.3
+R186.7	R07G3.3
+T01G9.4	R07G3.3
+T02H6.2	R07G3.3
+T06A10.1	R07G3.3
+T08G11.4	R07G3.3
+T20G5.9	R07G3.3
+T23D8.4	R07G3.3
+T23H2.1	R07G3.3
+T25G3.3	R07G3.3
+T27F7.3	R07G3.3
+W08E3.2	R07G3.3
+Y106G6H.2	R07G3.3
+Y32H12A.2	R07G3.3
+Y37E3.10	R07G3.3
+Y37E3.15	R07G3.3
+Y39A3CR.1	R07G3.3
+Y39G10AR.8	R07G3.3
+Y40B1B.5	R07G3.3
+Y41D4B.19	R07G3.3
+Y43F4B.4	R07G3.3
+Y47H9C.7	R07G3.3
+Y48G8AL.6	R07G3.3
+Y54E2A.11	R07G3.3
+Y54F10BM.2	R07G3.3
+Y57A10A.30	R07G3.3
+Y62E10A.2	R07G3.3
+Y65B4A.6	R07G3.3
+Y66A7A.2	R07G3.3
+Y71F9AM.5	R07G3.3
+Y71H2B.2	R07G3.3
+Y73B6BL.18	R07G3.3
+Y74C10AR.1	R07G3.3
+Y77E11A.13	R07G3.3
+ZK1098.4	R07G3.3
+ZK632.14	R07G3.3
+ZK742.1	R07G3.3
+R09B3.5	R08D7.3
+R186.7	R08D7.3
+T01G9.4	R08D7.3
+T02H6.2	R08D7.3
+T06A10.1	R08D7.3
+T08G11.4	R08D7.3
+T20G5.9	R08D7.3
+T23D8.4	R08D7.3
+T23H2.1	R08D7.3
+T25G3.3	R08D7.3
+T27F7.3	R08D7.3
+W08E3.2	R08D7.3
+Y106G6H.2	R08D7.3
+Y32H12A.2	R08D7.3
+Y37E3.10	R08D7.3
+Y37E3.15	R08D7.3
+Y39A3CR.1	R08D7.3
+Y39G10AR.8	R08D7.3
+Y40B1B.5	R08D7.3
+Y41D4B.19	R08D7.3
+Y43F4B.4	R08D7.3
+Y48G8AL.6	R08D7.3
+Y54F10BM.2	R08D7.3
+Y57A10A.30	R08D7.3
+Y62E10A.2	R08D7.3
+Y65B4A.6	R08D7.3
+Y66A7A.2	R08D7.3
+Y71F9AM.5	R08D7.3
+Y71H2B.2	R08D7.3
+Y73B6BL.18	R08D7.3
+Y74C10AR.1	R08D7.3
+Y77E11A.13	R08D7.3
+ZK632.14	R08D7.3
+ZK742.1	R08D7.3
+R186.7	R09B3.5
+T01G9.4	R09B3.5
+T02H6.2	R09B3.5
+T06A10.1	R09B3.5
+T08G11.4	R09B3.5
+T20G5.9	R09B3.5
+T23D8.4	R09B3.5
+T23H2.1	R09B3.5
+T25G3.3	R09B3.5
+T27F7.3	R09B3.5
+W08E3.2	R09B3.5
+Y106G6H.2	R09B3.5
+Y32H12A.2	R09B3.5
+Y37E3.10	R09B3.5
+Y37E3.15	R09B3.5
+Y39A3CR.1	R09B3.5
+Y39G10AR.8	R09B3.5
+Y40B1B.5	R09B3.5
+Y41D4B.19	R09B3.5
+Y43F4B.4	R09B3.5
+Y47H9C.7	R09B3.5
+Y48G8AL.6	R09B3.5
+Y54E2A.11	R09B3.5
+Y54F10BM.2	R09B3.5
+Y57A10A.30	R09B3.5
+Y62E10A.2	R09B3.5
+Y65B4A.6	R09B3.5
+Y66A7A.2	R09B3.5
+Y71F9AM.5	R09B3.5
+Y71H2B.2	R09B3.5
+Y73B6BL.18	R09B3.5
+Y74C10AR.1	R09B3.5
+Y77E11A.13	R09B3.5
+ZK1098.4	R09B3.5
+ZK632.14	R09B3.5
+ZK742.1	R09B3.5
+T01G9.4	R186.7
+T02H6.2	R186.7
+T06A10.1	R186.7
+T08G11.4	R186.7
+T20G5.9	R186.7
+T23D8.4	R186.7
+T23H2.1	R186.7
+T25G3.3	R186.7
+T27F7.3	R186.7
+W08E3.2	R186.7
+Y106G6H.2	R186.7
+Y32H12A.2	R186.7
+Y37E3.10	R186.7
+Y37E3.15	R186.7
+Y39A3CR.1	R186.7
+Y39G10AR.8	R186.7
+Y40B1B.5	R186.7
+Y41D4B.19	R186.7
+Y43F4B.4	R186.7
+Y47H9C.7	R186.7
+Y48G8AL.6	R186.7
+Y54E2A.11	R186.7
+Y54F10BM.2	R186.7
+Y57A10A.30	R186.7
+Y62E10A.2	R186.7
+Y65B4A.6	R186.7
+Y66A7A.2	R186.7
+Y71F9AM.5	R186.7
+Y71H2B.2	R186.7
+Y73B6BL.18	R186.7
+Y74C10AR.1	R186.7
+Y77E11A.13	R186.7
+ZK1098.4	R186.7
+ZK632.14	R186.7
+ZK742.1	R186.7
+T02H6.2	T01G9.4
+T06A10.1	T01G9.4
+T08G11.4	T01G9.4
+T20G5.9	T01G9.4
+T23D8.4	T01G9.4
+T23H2.1	T01G9.4
+T25G3.3	T01G9.4
+T27F7.3	T01G9.4
+W08E3.2	T01G9.4
+Y106G6H.2	T01G9.4
+Y32H12A.2	T01G9.4
+Y37E3.10	T01G9.4
+Y37E3.15	T01G9.4
+Y39A3CR.1	T01G9.4
+Y39G10AR.8	T01G9.4
+Y40B1B.5	T01G9.4
+Y41D4B.19	T01G9.4
+Y43F4B.4	T01G9.4
+Y47H9C.7	T01G9.4
+Y48G8AL.6	T01G9.4
+Y54E2A.11	T01G9.4
+Y54F10BM.2	T01G9.4
+Y57A10A.30	T01G9.4
+Y62E10A.2	T01G9.4
+Y65B4A.6	T01G9.4
+Y66A7A.2	T01G9.4
+Y71F9AM.5	T01G9.4
+Y71H2B.2	T01G9.4
+Y73B6BL.18	T01G9.4
+Y74C10AR.1	T01G9.4
+Y77E11A.13	T01G9.4
+ZK1098.4	T01G9.4
+ZK632.14	T01G9.4
+ZK742.1	T01G9.4
+T06A10.1	T02H6.2
+T08G11.4	T02H6.2
+T20G5.9	T02H6.2
+T23D8.4	T02H6.2
+T23H2.1	T02H6.2
+T25G3.3	T02H6.2
+T27F7.3	T02H6.2
+W08E3.2	T02H6.2
+Y106G6H.2	T02H6.2
+Y32H12A.2	T02H6.2
+Y37E3.10	T02H6.2
+Y37E3.15	T02H6.2
+Y39A3CR.1	T02H6.2
+Y39G10AR.8	T02H6.2
+Y40B1B.5	T02H6.2
+Y41D4B.19	T02H6.2
+Y43F4B.4	T02H6.2
+Y47H9C.7	T02H6.2
+Y48G8AL.6	T02H6.2
+Y54E2A.11	T02H6.2
+Y54F10BM.2	T02H6.2
+Y57A10A.30	T02H6.2
+Y62E10A.2	T02H6.2
+Y65B4A.6	T02H6.2
+Y66A7A.2	T02H6.2
+Y71F9AM.5	T02H6.2
+Y71H2B.2	T02H6.2
+Y73B6BL.18	T02H6.2
+Y74C10AR.1	T02H6.2
+Y77E11A.13	T02H6.2
+ZK1098.4	T02H6.2
+ZK632.14	T02H6.2
+ZK742.1	T02H6.2
+T08G11.4	T06A10.1
+T20G5.9	T06A10.1
+T23D8.4	T06A10.1
+T23H2.1	T06A10.1
+T25G3.3	T06A10.1
+T27F7.3	T06A10.1
+W08E3.2	T06A10.1
+Y106G6H.2	T06A10.1
+Y32H12A.2	T06A10.1
+Y37E3.10	T06A10.1
+Y37E3.15	T06A10.1
+Y39A3CR.1	T06A10.1
+Y39G10AR.8	T06A10.1
+Y40B1B.5	T06A10.1
+Y41D4B.19	T06A10.1
+Y43F4B.4	T06A10.1
+Y47H9C.7	T06A10.1
+Y48G8AL.6	T06A10.1
+Y54E2A.11	T06A10.1
+Y54F10BM.2	T06A10.1
+Y57A10A.30	T06A10.1
+Y62E10A.2	T06A10.1
+Y65B4A.6	T06A10.1
+Y66A7A.2	T06A10.1
+Y71F9AM.5	T06A10.1
+Y71H2B.2	T06A10.1
+Y73B6BL.18	T06A10.1
+Y74C10AR.1	T06A10.1
+Y77E11A.13	T06A10.1
+ZK1098.4	T06A10.1
+ZK632.14	T06A10.1
+ZK742.1	T06A10.1
+T20G5.9	T08G11.4
+T23D8.4	T08G11.4
+T23H2.1	T08G11.4
+T25G3.3	T08G11.4
+T27F7.3	T08G11.4
+W08E3.2	T08G11.4
+Y106G6H.2	T08G11.4
+Y32H12A.2	T08G11.4
+Y37E3.10	T08G11.4
+Y37E3.15	T08G11.4
+Y39A3CR.1	T08G11.4
+Y39G10AR.8	T08G11.4
+Y40B1B.5	T08G11.4
+Y41D4B.19	T08G11.4
+Y43F4B.4	T08G11.4
+Y47H9C.7	T08G11.4
+Y48G8AL.6	T08G11.4
+Y54E2A.11	T08G11.4
+Y54F10BM.2	T08G11.4
+Y57A10A.30	T08G11.4
+Y62E10A.2	T08G11.4
+Y65B4A.6	T08G11.4
+Y66A7A.2	T08G11.4
+Y71F9AM.5	T08G11.4
+Y71H2B.2	T08G11.4
+Y73B6BL.18	T08G11.4
+Y74C10AR.1	T08G11.4
+Y77E11A.13	T08G11.4
+ZK1098.4	T08G11.4
+ZK632.14	T08G11.4
+ZK742.1	T08G11.4
+T23D8.4	T20G5.9
+T23H2.1	T20G5.9
+T25G3.3	T20G5.9
+T27F7.3	T20G5.9
+W08E3.2	T20G5.9
+Y106G6H.2	T20G5.9
+Y32H12A.2	T20G5.9
+Y37E3.10	T20G5.9
+Y37E3.15	T20G5.9
+Y39A3CR.1	T20G5.9
+Y39G10AR.8	T20G5.9
+Y40B1B.5	T20G5.9
+Y41D4B.19	T20G5.9
+Y43F4B.4	T20G5.9
+Y47H9C.7	T20G5.9
+Y48G8AL.6	T20G5.9
+Y54E2A.11	T20G5.9
+Y54F10BM.2	T20G5.9
+Y57A10A.30	T20G5.9
+Y62E10A.2	T20G5.9
+Y65B4A.6	T20G5.9
+Y66A7A.2	T20G5.9
+Y71F9AM.5	T20G5.9
+Y71H2B.2	T20G5.9
+Y73B6BL.18	T20G5.9
+Y74C10AR.1	T20G5.9
+Y77E11A.13	T20G5.9
+ZK1098.4	T20G5.9
+ZK632.14	T20G5.9
+ZK742.1	T20G5.9
+T23H2.1	T23D8.4
+T25G3.3	T23D8.4
+T27F7.3	T23D8.4
+W08E3.2	T23D8.4
+Y106G6H.2	T23D8.4
+Y32H12A.2	T23D8.4
+Y37E3.10	T23D8.4
+Y37E3.15	T23D8.4
+Y39A3CR.1	T23D8.4
+Y39G10AR.8	T23D8.4
+Y40B1B.5	T23D8.4
+Y41D4B.19	T23D8.4
+Y43F4B.4	T23D8.4
+Y47H9C.7	T23D8.4
+Y48G8AL.6	T23D8.4
+Y54E2A.11	T23D8.4
+Y54F10BM.2	T23D8.4
+Y57A10A.30	T23D8.4
+Y62E10A.2	T23D8.4
+Y65B4A.6	T23D8.4
+Y66A7A.2	T23D8.4
+Y71F9AM.5	T23D8.4
+Y71H2B.2	T23D8.4
+Y73B6BL.18	T23D8.4
+Y74C10AR.1	T23D8.4
+Y77E11A.13	T23D8.4
+ZK1098.4	T23D8.4
+ZK632.14	T23D8.4
+ZK742.1	T23D8.4
+T25G3.3	T23H2.1
+T27F7.3	T23H2.1
+W08E3.2	T23H2.1
+Y106G6H.2	T23H2.1
+Y32H12A.2	T23H2.1
+Y37E3.10	T23H2.1
+Y37E3.15	T23H2.1
+Y39A3CR.1	T23H2.1
+Y39G10AR.8	T23H2.1
+Y40B1B.5	T23H2.1
+Y41D4B.19	T23H2.1
+Y43F4B.4	T23H2.1
+Y47H9C.7	T23H2.1
+Y48G8AL.6	T23H2.1
+Y54E2A.11	T23H2.1
+Y54F10BM.2	T23H2.1
+Y57A10A.30	T23H2.1
+Y62E10A.2	T23H2.1
+Y65B4A.6	T23H2.1
+Y66A7A.2	T23H2.1
+Y71F9AM.5	T23H2.1
+Y71H2B.2	T23H2.1
+Y73B6BL.18	T23H2.1
+Y74C10AR.1	T23H2.1
+Y77E11A.13	T23H2.1
+ZK1098.4	T23H2.1
+ZK632.14	T23H2.1
+ZK742.1	T23H2.1
+T27F7.3	T25G3.3
+W08E3.2	T25G3.3
+Y106G6H.2	T25G3.3
+Y32H12A.2	T25G3.3
+Y37E3.10	T25G3.3
+Y37E3.15	T25G3.3
+Y39A3CR.1	T25G3.3
+Y39G10AR.8	T25G3.3
+Y40B1B.5	T25G3.3
+Y41D4B.19	T25G3.3
+Y43F4B.4	T25G3.3
+Y47H9C.7	T25G3.3
+Y48G8AL.6	T25G3.3
+Y54E2A.11	T25G3.3
+Y54F10BM.2	T25G3.3
+Y57A10A.30	T25G3.3
+Y65B4A.6	T25G3.3
+Y71H2B.2	T25G3.3
+Y73B6BL.18	T25G3.3
+Y74C10AR.1	T25G3.3
+Y77E11A.13	T25G3.3
+ZK1098.4	T25G3.3
+W08E3.2	T27F7.3
+Y106G6H.2	T27F7.3
+Y32H12A.2	T27F7.3
+Y37E3.10	T27F7.3
+Y37E3.15	T27F7.3
+Y39A3CR.1	T27F7.3
+Y39G10AR.8	T27F7.3
+Y40B1B.5	T27F7.3
+Y41D4B.19	T27F7.3
+Y43F4B.4	T27F7.3
+Y47H9C.7	T27F7.3
+Y48G8AL.6	T27F7.3
+Y54E2A.11	T27F7.3
+Y54F10BM.2	T27F7.3
+Y57A10A.30	T27F7.3
+Y62E10A.2	T27F7.3
+Y65B4A.6	T27F7.3
+Y66A7A.2	T27F7.3
+Y71F9AM.5	T27F7.3
+Y71H2B.2	T27F7.3
+Y73B6BL.18	T27F7.3
+Y74C10AR.1	T27F7.3
+Y77E11A.13	T27F7.3
+ZK1098.4	T27F7.3
+ZK632.14	T27F7.3
+ZK742.1	T27F7.3
+Y106G6H.2	W08E3.2
+Y32H12A.2	W08E3.2
+Y37E3.10	W08E3.2
+Y37E3.15	W08E3.2
+Y39A3CR.1	W08E3.2
+Y39G10AR.8	W08E3.2
+Y40B1B.5	W08E3.2
+Y41D4B.19	W08E3.2
+Y43F4B.4	W08E3.2
+Y47H9C.7	W08E3.2
+Y48G8AL.6	W08E3.2
+Y54E2A.11	W08E3.2
+Y54F10BM.2	W08E3.2
+Y57A10A.30	W08E3.2
+Y62E10A.2	W08E3.2
+Y65B4A.6	W08E3.2
+Y66A7A.2	W08E3.2
+Y71F9AM.5	W08E3.2
+Y71H2B.2	W08E3.2
+Y73B6BL.18	W08E3.2
+Y74C10AR.1	W08E3.2
+Y77E11A.13	W08E3.2
+ZK1098.4	W08E3.2
+ZK632.14	W08E3.2
+ZK742.1	W08E3.2
+Y32H12A.2	Y106G6H.2
+Y37E3.10	Y106G6H.2
+Y37E3.15	Y106G6H.2
+Y39A3CR.1	Y106G6H.2
+Y39G10AR.8	Y106G6H.2
+Y40B1B.5	Y106G6H.2
+Y41D4B.19	Y106G6H.2
+Y43F4B.4	Y106G6H.2
+Y47H9C.7	Y106G6H.2
+Y48G8AL.6	Y106G6H.2
+Y54E2A.11	Y106G6H.2
+Y54F10BM.2	Y106G6H.2
+Y57A10A.30	Y106G6H.2
+Y62E10A.2	Y106G6H.2
+Y65B4A.6	Y106G6H.2
+Y66A7A.2	Y106G6H.2
+Y71F9AM.5	Y106G6H.2
+Y71H2B.2	Y106G6H.2
+Y73B6BL.18	Y106G6H.2
+Y74C10AR.1	Y106G6H.2
+Y77E11A.13	Y106G6H.2
+ZK1098.4	Y106G6H.2
+ZK632.14	Y106G6H.2
+ZK742.1	Y106G6H.2
+Y37E3.10	Y32H12A.2
+Y37E3.15	Y32H12A.2
+Y39A3CR.1	Y32H12A.2
+Y39G10AR.8	Y32H12A.2
+Y40B1B.5	Y32H12A.2
+Y41D4B.19	Y32H12A.2
+Y43F4B.4	Y32H12A.2
+Y47H9C.7	Y32H12A.2
+Y48G8AL.6	Y32H12A.2
+Y54E2A.11	Y32H12A.2
+Y54F10BM.2	Y32H12A.2
+Y57A10A.30	Y32H12A.2
+Y62E10A.2	Y32H12A.2
+Y65B4A.6	Y32H12A.2
+Y66A7A.2	Y32H12A.2
+Y71F9AM.5	Y32H12A.2
+Y71H2B.2	Y32H12A.2
+Y73B6BL.18	Y32H12A.2
+Y74C10AR.1	Y32H12A.2
+Y77E11A.13	Y32H12A.2
+ZK1098.4	Y32H12A.2
+ZK632.14	Y32H12A.2
+ZK742.1	Y32H12A.2
+Y37E3.15	Y37E3.10
+Y39A3CR.1	Y37E3.10
+Y39G10AR.8	Y37E3.10
+Y40B1B.5	Y37E3.10
+Y41D4B.19	Y37E3.10
+Y43F4B.4	Y37E3.10
+Y47H9C.7	Y37E3.10
+Y48G8AL.6	Y37E3.10
+Y54E2A.11	Y37E3.10
+Y54F10BM.2	Y37E3.10
+Y57A10A.30	Y37E3.10
+Y62E10A.2	Y37E3.10
+Y65B4A.6	Y37E3.10
+Y66A7A.2	Y37E3.10
+Y71F9AM.5	Y37E3.10
+Y71H2B.2	Y37E3.10
+Y73B6BL.18	Y37E3.10
+Y74C10AR.1	Y37E3.10
+Y77E11A.13	Y37E3.10
+ZK1098.4	Y37E3.10
+ZK632.14	Y37E3.10
+ZK742.1	Y37E3.10
+Y39A3CR.1	Y37E3.15
+Y39G10AR.8	Y37E3.15
+Y40B1B.5	Y37E3.15
+Y41D4B.19	Y37E3.15
+Y43F4B.4	Y37E3.15
+Y47H9C.7	Y37E3.15
+Y48G8AL.6	Y37E3.15
+Y54E2A.11	Y37E3.15
+Y54F10BM.2	Y37E3.15
+Y57A10A.30	Y37E3.15
+Y62E10A.2	Y37E3.15
+Y65B4A.6	Y37E3.15
+Y66A7A.2	Y37E3.15
+Y71F9AM.5	Y37E3.15
+Y71H2B.2	Y37E3.15
+Y73B6BL.18	Y37E3.15
+Y74C10AR.1	Y37E3.15
+Y77E11A.13	Y37E3.15
+ZK1098.4	Y37E3.15
+ZK632.14	Y37E3.15
+ZK742.1	Y37E3.15
+Y39G10AR.8	Y39A3CR.1
+Y40B1B.5	Y39A3CR.1
+Y41D4B.19	Y39A3CR.1
+Y43F4B.4	Y39A3CR.1
+Y47H9C.7	Y39A3CR.1
+Y48G8AL.6	Y39A3CR.1
+Y54E2A.11	Y39A3CR.1
+Y54F10BM.2	Y39A3CR.1
+Y57A10A.30	Y39A3CR.1
+Y62E10A.2	Y39A3CR.1
+Y65B4A.6	Y39A3CR.1
+Y66A7A.2	Y39A3CR.1
+Y71F9AM.5	Y39A3CR.1
+Y71H2B.2	Y39A3CR.1
+Y73B6BL.18	Y39A3CR.1
+Y74C10AR.1	Y39A3CR.1
+Y77E11A.13	Y39A3CR.1
+ZK1098.4	Y39A3CR.1
+ZK632.14	Y39A3CR.1
+ZK742.1	Y39A3CR.1
+Y40B1B.5	Y39G10AR.8
+Y41D4B.19	Y39G10AR.8
+Y43F4B.4	Y39G10AR.8
+Y47H9C.7	Y39G10AR.8
+Y48G8AL.6	Y39G10AR.8
+Y54E2A.11	Y39G10AR.8
+Y54F10BM.2	Y39G10AR.8
+Y57A10A.30	Y39G10AR.8
+Y62E10A.2	Y39G10AR.8
+Y65B4A.6	Y39G10AR.8
+Y66A7A.2	Y39G10AR.8
+Y71F9AM.5	Y39G10AR.8
+Y71H2B.2	Y39G10AR.8
+Y73B6BL.18	Y39G10AR.8
+Y74C10AR.1	Y39G10AR.8
+Y77E11A.13	Y39G10AR.8
+ZK1098.4	Y39G10AR.8
+ZK632.14	Y39G10AR.8
+ZK742.1	Y39G10AR.8
+Y41D4B.19	Y40B1B.5
+Y43F4B.4	Y40B1B.5
+Y47H9C.7	Y40B1B.5
+Y48G8AL.6	Y40B1B.5
+Y54E2A.11	Y40B1B.5
+Y54F10BM.2	Y40B1B.5
+Y57A10A.30	Y40B1B.5
+Y62E10A.2	Y40B1B.5
+Y65B4A.6	Y40B1B.5
+Y66A7A.2	Y40B1B.5
+Y71F9AM.5	Y40B1B.5
+Y71H2B.2	Y40B1B.5
+Y73B6BL.18	Y40B1B.5
+Y74C10AR.1	Y40B1B.5
+Y77E11A.13	Y40B1B.5
+ZK1098.4	Y40B1B.5
+ZK632.14	Y40B1B.5
+ZK742.1	Y40B1B.5
+Y43F4B.4	Y41D4B.19
+Y47H9C.7	Y41D4B.19
+Y48G8AL.6	Y41D4B.19
+Y54E2A.11	Y41D4B.19
+Y54F10BM.2	Y41D4B.19
+Y57A10A.30	Y41D4B.19
+Y62E10A.2	Y41D4B.19
+Y65B4A.6	Y41D4B.19
+Y66A7A.2	Y41D4B.19
+Y71F9AM.5	Y41D4B.19
+Y71H2B.2	Y41D4B.19
+Y73B6BL.18	Y41D4B.19
+Y74C10AR.1	Y41D4B.19
+Y77E11A.13	Y41D4B.19
+ZK1098.4	Y41D4B.19
+ZK632.14	Y41D4B.19
+ZK742.1	Y41D4B.19
+Y47H9C.7	Y43F4B.4
+Y48G8AL.6	Y43F4B.4
+Y54E2A.11	Y43F4B.4
+Y54F10BM.2	Y43F4B.4
+Y57A10A.30	Y43F4B.4
+Y62E10A.2	Y43F4B.4
+Y65B4A.6	Y43F4B.4
+Y66A7A.2	Y43F4B.4
+Y71F9AM.5	Y43F4B.4
+Y71H2B.2	Y43F4B.4
+Y73B6BL.18	Y43F4B.4
+Y74C10AR.1	Y43F4B.4
+Y77E11A.13	Y43F4B.4
+ZK1098.4	Y43F4B.4
+ZK632.14	Y43F4B.4
+ZK742.1	Y43F4B.4
+Y48G8AL.6	Y47H9C.7
+Y54F10BM.2	Y47H9C.7
+Y57A10A.30	Y47H9C.7
+Y62E10A.2	Y47H9C.7
+Y65B4A.6	Y47H9C.7
+Y66A7A.2	Y47H9C.7
+Y71F9AM.5	Y47H9C.7
+Y71H2B.2	Y47H9C.7
+Y73B6BL.18	Y47H9C.7
+Y74C10AR.1	Y47H9C.7
+Y77E11A.13	Y47H9C.7
+ZK632.14	Y47H9C.7
+ZK742.1	Y47H9C.7
+Y54E2A.11	Y48G8AL.6
+Y54F10BM.2	Y48G8AL.6
+Y57A10A.30	Y48G8AL.6
+Y62E10A.2	Y48G8AL.6
+Y65B4A.6	Y48G8AL.6
+Y66A7A.2	Y48G8AL.6
+Y71F9AM.5	Y48G8AL.6
+Y71H2B.2	Y48G8AL.6
+Y73B6BL.18	Y48G8AL.6
+Y74C10AR.1	Y48G8AL.6
+Y77E11A.13	Y48G8AL.6
+ZK1098.4	Y48G8AL.6
+ZK632.14	Y48G8AL.6
+ZK742.1	Y48G8AL.6
+Y54F10BM.2	Y54E2A.11
+Y57A10A.30	Y54E2A.11
+Y62E10A.2	Y54E2A.11
+Y65B4A.6	Y54E2A.11
+Y66A7A.2	Y54E2A.11
+Y71F9AM.5	Y54E2A.11
+Y71H2B.2	Y54E2A.11
+Y73B6BL.18	Y54E2A.11
+Y74C10AR.1	Y54E2A.11
+Y77E11A.13	Y54E2A.11
+ZK632.14	Y54E2A.11
+ZK742.1	Y54E2A.11
+Y57A10A.30	Y54F10BM.2
+Y62E10A.2	Y54F10BM.2
+Y65B4A.6	Y54F10BM.2
+Y66A7A.2	Y54F10BM.2
+Y71F9AM.5	Y54F10BM.2
+Y71H2B.2	Y54F10BM.2
+Y73B6BL.18	Y54F10BM.2
+Y74C10AR.1	Y54F10BM.2
+Y77E11A.13	Y54F10BM.2
+ZK1098.4	Y54F10BM.2
+ZK632.14	Y54F10BM.2
+ZK742.1	Y54F10BM.2
+Y62E10A.2	Y57A10A.30
+Y65B4A.6	Y57A10A.30
+Y66A7A.2	Y57A10A.30
+Y71F9AM.5	Y57A10A.30
+Y71H2B.2	Y57A10A.30
+Y73B6BL.18	Y57A10A.30
+Y74C10AR.1	Y57A10A.30
+Y77E11A.13	Y57A10A.30
+ZK1098.4	Y57A10A.30
+ZK632.14	Y57A10A.30
+ZK742.1	Y57A10A.30
+Y65B4A.6	Y62E10A.2
+Y71H2B.2	Y62E10A.2
+Y73B6BL.18	Y62E10A.2
+Y74C10AR.1	Y62E10A.2
+Y77E11A.13	Y62E10A.2
+ZK1098.4	Y62E10A.2
+Y66A7A.2	Y65B4A.6
+Y71F9AM.5	Y65B4A.6
+Y71H2B.2	Y65B4A.6
+Y73B6BL.18	Y65B4A.6
+Y74C10AR.1	Y65B4A.6
+Y77E11A.13	Y65B4A.6
+ZK1098.4	Y65B4A.6
+ZK632.14	Y65B4A.6
+ZK742.1	Y65B4A.6
+Y71H2B.2	Y66A7A.2
+Y73B6BL.18	Y66A7A.2
+Y74C10AR.1	Y66A7A.2
+Y77E11A.13	Y66A7A.2
+ZK1098.4	Y66A7A.2
+Y71H2B.2	Y71F9AM.5
+Y73B6BL.18	Y71F9AM.5
+Y74C10AR.1	Y71F9AM.5
+Y77E11A.13	Y71F9AM.5
+ZK1098.4	Y71F9AM.5
+Y73B6BL.18	Y71H2B.2
+Y74C10AR.1	Y71H2B.2
+Y77E11A.13	Y71H2B.2
+ZK1098.4	Y71H2B.2
+ZK632.14	Y71H2B.2
+ZK742.1	Y71H2B.2
+Y74C10AR.1	Y73B6BL.18
+Y77E11A.13	Y73B6BL.18
+ZK1098.4	Y73B6BL.18
+ZK632.14	Y73B6BL.18
+ZK742.1	Y73B6BL.18
+Y77E11A.13	Y74C10AR.1
+ZK1098.4	Y74C10AR.1
+ZK632.14	Y74C10AR.1
+ZK742.1	Y74C10AR.1
+ZK1098.4	Y77E11A.13
+ZK632.14	Y77E11A.13
+ZK742.1	Y77E11A.13
+ZK632.14	ZK1098.4
+ZK742.1	ZK1098.4
+C03D6.3	C01F6.5
+C06G1.5	C01F6.5
+C13G3.3	C01F6.5
+C17E4.5	C01F6.5
+C25A1.3	C01F6.5
+C25A1.9	C01F6.5
+C33H5.7	C01F6.5
+C48B6.6	C01F6.5
+D1046.1	C01F6.5
+F09G2.4	C01F6.5
+F11A10.8	C01F6.5
+F25G6.2	C01F6.5
+F26E4.1	C01F6.5
+F28C6.3	C01F6.5
+F28C6.6	C01F6.5
+F29F11.6	C01F6.5
+F32D1.9	C01F6.5
+F38H4.9	C01F6.5
+F43G6.5	C01F6.5
+F43G9.5	C01F6.5
+F48E8.5	C01F6.5
+F56A8.6	C01F6.5
+F56C9.1	C01F6.5
+F59A2.4	C01F6.5
+H19N07.1	C01F6.5
+K07A12.4	C01F6.5
+R06A4.9	C01F6.5
+R10E9.1	C01F6.5
+R144.2	C01F6.5
+R74.6	C01F6.5
+T05H4.6	C01F6.5
+T13C2.4	C01F6.5
+T15H9.6	C01F6.5
+W08G11.4	C01F6.5
+Y32F6A.3	C01F6.5
+Y54F10AL.2	C01F6.5
+Y67H2A.1	C01F6.5
+Y73B6A.4	C01F6.5
+Y76B12C.7	C01F6.5
+C03D6.3	C02B10.4
+C06G1.5	C02B10.4
+C13G3.3	C02B10.4
+C17E4.5	C02B10.4
+C25A1.3	C02B10.4
+C25A1.9	C02B10.4
+C33H5.7	C02B10.4
+C48B6.6	C02B10.4
+D1046.1	C02B10.4
+F09G2.4	C02B10.4
+F11A10.8	C02B10.4
+F25G6.2	C02B10.4
+F26E4.1	C02B10.4
+F28C6.3	C02B10.4
+F28C6.6	C02B10.4
+F29F11.6	C02B10.4
+F32D1.9	C02B10.4
+F38H4.9	C02B10.4
+F43G6.5	C02B10.4
+F43G9.5	C02B10.4
+F48E8.5	C02B10.4
+F56A8.6	C02B10.4
+F56C9.1	C02B10.4
+F59A2.4	C02B10.4
+H19N07.1	C02B10.4
+K07A12.4	C02B10.4
+R06A4.9	C02B10.4
+R10E9.1	C02B10.4
+R144.2	C02B10.4
+R74.6	C02B10.4
+T05H4.6	C02B10.4
+T13C2.4	C02B10.4
+T15H9.6	C02B10.4
+W08G11.4	C02B10.4
+Y32F6A.3	C02B10.4
+Y54F10AL.2	C02B10.4
+Y67H2A.1	C02B10.4
+Y73B6A.4	C02B10.4
+Y76B12C.7	C02B10.4
+C05C10.2	C03D6.3
+C06G1.5	C03D6.3
+C13G3.3	C03D6.3
+C15H11.3	C03D6.3
+C15H11.6	C03D6.3
+C16C10.4	C03D6.3
+C17E4.5	C03D6.3
+C25A1.9	C03D6.3
+C33H5.7	C03D6.3
+C43E11.1	C03D6.3
+C44H9.4	C03D6.3
+C48B6.6	C03D6.3
+D1046.1	C03D6.3
+F09G2.4	C03D6.3
+F11A10.8	C03D6.3
+F18H3.3	C03D6.3
+F23B2.6	C03D6.3
+F25G6.2	C03D6.3
+F26A3.2	C03D6.3
+F26E4.1	C03D6.3
+F28C6.3	C03D6.3
+F28C6.6	C03D6.3
+F28D9.1	C03D6.3
+F29F11.6	C03D6.3
+F32D1.9	C03D6.3
+F33D11.10	C03D6.3
+F37E3.1	C03D6.3
+F38H4.9	C03D6.3
+F43G6.5	C03D6.3
+F43G9.5	C03D6.3
+F46B6.3	C03D6.3
+F48E8.5	C03D6.3
+F56A8.6	C03D6.3
+F56C9.1	C03D6.3
+F59A2.4	C03D6.3
+H19N07.1	C03D6.3
+K02F3.11	C03D6.3
+K07A12.4	C03D6.3
+M18.7	C03D6.3
+R06A4.9	C03D6.3
+R07E5.14	C03D6.3
+R09B3.5	C03D6.3
+R10E9.1	C03D6.3
+R144.2	C03D6.3
+R186.7	C03D6.3
+R74.6	C03D6.3
+T05H4.6	C03D6.3
+T13C2.4	C03D6.3
+T15H9.6	C03D6.3
+T20G5.9	C03D6.3
+W08E3.2	C03D6.3
+W08G11.4	C03D6.3
+Y106G6H.2	C03D6.3
+Y32F6A.3	C03D6.3
+Y48G8AL.6	C03D6.3
+Y54F10AL.2	C03D6.3
+Y65B4A.6	C03D6.3
+Y67H2A.1	C03D6.3
+Y71F9AM.5	C03D6.3
+Y73B6A.4	C03D6.3
+Y73B6BL.18	C03D6.3
+Y76B12C.7	C03D6.3
+C06G1.5	C05C10.2
+C13G3.3	C05C10.2
+C17E4.5	C05C10.2
+C25A1.3	C05C10.2
+C25A1.9	C05C10.2
+C33H5.7	C05C10.2
+C48B6.6	C05C10.2
+D1046.1	C05C10.2
+F09G2.4	C05C10.2
+F11A10.8	C05C10.2
+F25G6.2	C05C10.2
+F26E4.1	C05C10.2
+F28C6.3	C05C10.2
+F28C6.6	C05C10.2
+F29F11.6	C05C10.2
+F32D1.9	C05C10.2
+F38H4.9	C05C10.2
+F43G6.5	C05C10.2
+F43G9.5	C05C10.2
+F48E8.5	C05C10.2
+F56A8.6	C05C10.2
+F56C9.1	C05C10.2
+F59A2.4	C05C10.2
+H19N07.1	C05C10.2
+K07A12.4	C05C10.2
+R06A4.9	C05C10.2
+R10E9.1	C05C10.2
+R144.2	C05C10.2
+R74.6	C05C10.2
+T05H4.6	C05C10.2
+T13C2.4	C05C10.2
+T15H9.6	C05C10.2
+W08G11.4	C05C10.2
+Y32F6A.3	C05C10.2
+Y54F10AL.2	C05C10.2
+Y67H2A.1	C05C10.2
+Y73B6A.4	C05C10.2
+Y76B12C.7	C05C10.2
+C13G3.3	C06G1.5
+C15H11.3	C06G1.5
+C15H11.6	C06G1.5
+C16C10.4	C06G1.5
+C17E4.5	C06G1.5
+C25A1.3	C06G1.5
+C25A1.9	C06G1.5
+C33H5.7	C06G1.5
+C43E11.1	C06G1.5
+C44H9.4	C06G1.5
+C48B6.6	C06G1.5
+D1046.1	C06G1.5
+F09G2.4	C06G1.5
+F11A10.8	C06G1.5
+F18H3.3	C06G1.5
+F23B2.6	C06G1.5
+F25G6.2	C06G1.5
+F26A3.2	C06G1.5
+F26E4.1	C06G1.5
+F28C6.3	C06G1.5
+F28C6.6	C06G1.5
+F28D9.1	C06G1.5
+F29F11.6	C06G1.5
+F32D1.9	C06G1.5
+F33D11.10	C06G1.5
+F37E3.1	C06G1.5
+F38H4.9	C06G1.5
+F43G6.5	C06G1.5
+F43G9.5	C06G1.5
+F46B6.3	C06G1.5
+F48E8.5	C06G1.5
+F56A8.6	C06G1.5
+F56C9.1	C06G1.5
+F59A2.4	C06G1.5
+H19N07.1	C06G1.5
+K02F3.11	C06G1.5
+K07A12.4	C06G1.5
+M18.7	C06G1.5
+R06A4.9	C06G1.5
+R07E5.14	C06G1.5
+R09B3.5	C06G1.5
+R10E9.1	C06G1.5
+R144.2	C06G1.5
+R186.7	C06G1.5
+R74.6	C06G1.5
+T05H4.6	C06G1.5
+T13C2.4	C06G1.5
+T15H9.6	C06G1.5
+T20G5.9	C06G1.5
+W08E3.2	C06G1.5
+W08G11.4	C06G1.5
+Y106G6H.2	C06G1.5
+Y32F6A.3	C06G1.5
+Y48G8AL.6	C06G1.5
+Y54F10AL.2	C06G1.5
+Y65B4A.6	C06G1.5
+Y67H2A.1	C06G1.5
+Y71F9AM.5	C06G1.5
+Y73B6A.4	C06G1.5
+Y73B6BL.18	C06G1.5
+Y76B12C.7	C06G1.5
+C15H11.3	C13G3.3
+C15H11.6	C13G3.3
+C16C10.4	C13G3.3
+C17E4.5	C13G3.3
+C25A1.3	C13G3.3
+C25A1.9	C13G3.3
+C33H5.7	C13G3.3
+C43E11.1	C13G3.3
+C44H9.4	C13G3.3
+C48B6.6	C13G3.3
+D1046.1	C13G3.3
+F09G2.4	C13G3.3
+F11A10.8	C13G3.3
+F18H3.3	C13G3.3
+F23B2.6	C13G3.3
+F25G6.2	C13G3.3
+F26A3.2	C13G3.3
+F26E4.1	C13G3.3
+F28C6.3	C13G3.3
+F28C6.6	C13G3.3
+F28D9.1	C13G3.3
+F29F11.6	C13G3.3
+F32D1.9	C13G3.3
+F33D11.10	C13G3.3
+F37E3.1	C13G3.3
+F38H4.9	C13G3.3
+F43G6.5	C13G3.3
+F43G9.5	C13G3.3
+F46B6.3	C13G3.3
+F48E8.5	C13G3.3
+F56A8.6	C13G3.3
+F56C9.1	C13G3.3
+F59A2.4	C13G3.3
+H19N07.1	C13G3.3
+K02F3.11	C13G3.3
+K07A12.4	C13G3.3
+M18.7	C13G3.3
+R06A4.9	C13G3.3
+R07E5.14	C13G3.3
+R09B3.5	C13G3.3
+R10E9.1	C13G3.3
+R144.2	C13G3.3
+R186.7	C13G3.3
+R74.6	C13G3.3
+T05H4.6	C13G3.3
+T13C2.4	C13G3.3
+T15H9.6	C13G3.3
+T20G5.9	C13G3.3
+W08E3.2	C13G3.3
+W08G11.4	C13G3.3
+Y106G6H.2	C13G3.3
+Y32F6A.3	C13G3.3
+Y48G8AL.6	C13G3.3
+Y54F10AL.2	C13G3.3
+Y65B4A.6	C13G3.3
+Y67H2A.1	C13G3.3
+Y71F9AM.5	C13G3.3
+Y73B6A.4	C13G3.3
+Y73B6BL.18	C13G3.3
+Y76B12C.7	C13G3.3
+C17E4.5	C15H11.3
+C25A1.3	C15H11.3
+C25A1.9	C15H11.3
+C33H5.7	C15H11.3
+C48B6.6	C15H11.3
+D1046.1	C15H11.3
+F09G2.4	C15H11.3
+F11A10.8	C15H11.3
+F25G6.2	C15H11.3
+F26E4.1	C15H11.3
+F28C6.3	C15H11.3
+F28C6.6	C15H11.3
+F29F11.6	C15H11.3
+F32D1.9	C15H11.3
+F38H4.9	C15H11.3
+F43G6.5	C15H11.3
+F43G9.5	C15H11.3
+F48E8.5	C15H11.3
+F56A8.6	C15H11.3
+F56C9.1	C15H11.3
+F59A2.4	C15H11.3
+H19N07.1	C15H11.3
+K07A12.4	C15H11.3
+R06A4.9	C15H11.3
+R10E9.1	C15H11.3
+R144.2	C15H11.3
+R74.6	C15H11.3
+T05H4.6	C15H11.3
+T13C2.4	C15H11.3
+T15H9.6	C15H11.3
+W08G11.4	C15H11.3
+Y32F6A.3	C15H11.3
+Y54F10AL.2	C15H11.3
+Y67H2A.1	C15H11.3
+Y73B6A.4	C15H11.3
+Y76B12C.7	C15H11.3
+C17E4.5	C15H11.6
+C25A1.3	C15H11.6
+C25A1.9	C15H11.6
+C33H5.7	C15H11.6
+C48B6.6	C15H11.6
+D1046.1	C15H11.6
+F09G2.4	C15H11.6
+F11A10.8	C15H11.6
+F25G6.2	C15H11.6
+F26E4.1	C15H11.6
+F28C6.3	C15H11.6
+F28C6.6	C15H11.6
+F29F11.6	C15H11.6
+F32D1.9	C15H11.6
+F38H4.9	C15H11.6
+F43G6.5	C15H11.6
+F43G9.5	C15H11.6
+F48E8.5	C15H11.6
+F56A8.6	C15H11.6
+F56C9.1	C15H11.6
+F59A2.4	C15H11.6
+H19N07.1	C15H11.6
+K07A12.4	C15H11.6
+R06A4.9	C15H11.6
+R10E9.1	C15H11.6
+R144.2	C15H11.6
+R74.6	C15H11.6
+T05H4.6	C15H11.6
+T13C2.4	C15H11.6
+T15H9.6	C15H11.6
+W08G11.4	C15H11.6
+Y32F6A.3	C15H11.6
+Y54F10AL.2	C15H11.6
+Y67H2A.1	C15H11.6
+Y73B6A.4	C15H11.6
+Y76B12C.7	C15H11.6
+C17E4.5	C16C10.4
+C25A1.3	C16C10.4
+C25A1.9	C16C10.4
+C33H5.7	C16C10.4
+C48B6.6	C16C10.4
+D1046.1	C16C10.4
+F09G2.4	C16C10.4
+F11A10.8	C16C10.4
+F25G6.2	C16C10.4
+F26E4.1	C16C10.4
+F28C6.3	C16C10.4
+F28C6.6	C16C10.4
+F29F11.6	C16C10.4
+F32D1.9	C16C10.4
+F38H4.9	C16C10.4
+F43G6.5	C16C10.4
+F43G9.5	C16C10.4
+F48E8.5	C16C10.4
+F56A8.6	C16C10.4
+F56C9.1	C16C10.4
+F59A2.4	C16C10.4
+H19N07.1	C16C10.4
+K07A12.4	C16C10.4
+R06A4.9	C16C10.4
+R10E9.1	C16C10.4
+R144.2	C16C10.4
+R74.6	C16C10.4
+T05H4.6	C16C10.4
+T13C2.4	C16C10.4
+T15H9.6	C16C10.4
+W08G11.4	C16C10.4
+Y32F6A.3	C16C10.4
+Y54F10AL.2	C16C10.4
+Y67H2A.1	C16C10.4
+Y73B6A.4	C16C10.4
+Y76B12C.7	C16C10.4
+C25A1.3	C17E4.5
+C25A1.9	C17E4.5
+C33H5.7	C17E4.5
+C43E11.1	C17E4.5
+C44H9.4	C17E4.5
+C48B6.6	C17E4.5
+D1046.1	C17E4.5
+F09G2.4	C17E4.5
+F11A10.8	C17E4.5
+F18H3.3	C17E4.5
+F23B2.6	C17E4.5
+F25G6.2	C17E4.5
+F26A3.2	C17E4.5
+F26E4.1	C17E4.5
+F28C6.3	C17E4.5
+F28C6.6	C17E4.5
+F28D9.1	C17E4.5
+F29F11.6	C17E4.5
+F32D1.9	C17E4.5
+F33D11.10	C17E4.5
+F37E3.1	C17E4.5
+F38H4.9	C17E4.5
+F43G6.5	C17E4.5
+F43G9.5	C17E4.5
+F46B6.3	C17E4.5
+F48E8.5	C17E4.5
+F56A8.6	C17E4.5
+F56C9.1	C17E4.5
+F59A2.4	C17E4.5
+H19N07.1	C17E4.5
+K02F3.11	C17E4.5
+K07A12.4	C17E4.5
+M18.7	C17E4.5
+R06A4.9	C17E4.5
+R07E5.14	C17E4.5
+R09B3.5	C17E4.5
+R10E9.1	C17E4.5
+R144.2	C17E4.5
+R186.7	C17E4.5
+R74.6	C17E4.5
+T05H4.6	C17E4.5
+T13C2.4	C17E4.5
+T15H9.6	C17E4.5
+T20G5.9	C17E4.5
+W08E3.2	C17E4.5
+W08G11.4	C17E4.5
+Y106G6H.2	C17E4.5
+Y32F6A.3	C17E4.5
+Y48G8AL.6	C17E4.5
+Y54F10AL.2	C17E4.5
+Y65B4A.6	C17E4.5
+Y67H2A.1	C17E4.5
+Y71F9AM.5	C17E4.5
+Y73B6A.4	C17E4.5
+Y73B6BL.18	C17E4.5
+Y76B12C.7	C17E4.5
+C25A1.9	C25A1.3
+C33H5.7	C25A1.3
+C43E11.1	C25A1.3
+C44H9.4	C25A1.3
+C48B6.6	C25A1.3
+D1046.1	C25A1.3
+F09G2.4	C25A1.3
+F11A10.8	C25A1.3
+F18H3.3	C25A1.3
+F23B2.6	C25A1.3
+F25G6.2	C25A1.3
+F26A3.2	C25A1.3
+F26E4.1	C25A1.3
+F28C6.3	C25A1.3
+F28C6.6	C25A1.3
+F28D9.1	C25A1.3
+F29F11.6	C25A1.3
+F32D1.9	C25A1.3
+F33D11.10	C25A1.3
+F37E3.1	C25A1.3
+F38H4.9	C25A1.3
+F43G6.5	C25A1.3
+F43G9.5	C25A1.3
+F46B6.3	C25A1.3
+F48E8.5	C25A1.3
+F56A8.6	C25A1.3
+F56C9.1	C25A1.3
+F59A2.4	C25A1.3
+H19N07.1	C25A1.3
+K02F3.11	C25A1.3
+K07A12.4	C25A1.3
+M18.7	C25A1.3
+R06A4.9	C25A1.3
+R07E5.14	C25A1.3
+R09B3.5	C25A1.3
+R10E9.1	C25A1.3
+R144.2	C25A1.3
+R186.7	C25A1.3
+R74.6	C25A1.3
+T05H4.6	C25A1.3
+T13C2.4	C25A1.3
+T15H9.6	C25A1.3
+T20G5.9	C25A1.3
+W08E3.2	C25A1.3
+W08G11.4	C25A1.3
+Y106G6H.2	C25A1.3
+Y32F6A.3	C25A1.3
+Y48G8AL.6	C25A1.3
+Y54F10AL.2	C25A1.3
+Y65B4A.6	C25A1.3
+Y67H2A.1	C25A1.3
+Y71F9AM.5	C25A1.3
+Y73B6A.4	C25A1.3
+Y73B6BL.18	C25A1.3
+Y76B12C.7	C25A1.3
+C33H5.7	C25A1.9
+C43E11.1	C25A1.9
+C44H9.4	C25A1.9
+C48B6.6	C25A1.9
+D1046.1	C25A1.9
+F09G2.4	C25A1.9
+F11A10.8	C25A1.9
+F18H3.3	C25A1.9
+F23B2.6	C25A1.9
+F25G6.2	C25A1.9
+F26A3.2	C25A1.9
+F26E4.1	C25A1.9
+F28C6.3	C25A1.9
+F28C6.6	C25A1.9
+F28D9.1	C25A1.9
+F29F11.6	C25A1.9
+F32D1.9	C25A1.9
+F33D11.10	C25A1.9
+F37E3.1	C25A1.9
+F38H4.9	C25A1.9
+F43G6.5	C25A1.9
+F43G9.5	C25A1.9
+F46B6.3	C25A1.9
+F48E8.5	C25A1.9
+F56A8.6	C25A1.9
+F56C9.1	C25A1.9
+F59A2.4	C25A1.9
+H19N07.1	C25A1.9
+K02F3.11	C25A1.9
+K07A12.4	C25A1.9
+M18.7	C25A1.9
+R06A4.9	C25A1.9
+R07E5.14	C25A1.9
+R09B3.5	C25A1.9
+R10E9.1	C25A1.9
+R144.2	C25A1.9
+R186.7	C25A1.9
+R74.6	C25A1.9
+T05H4.6	C25A1.9
+T13C2.4	C25A1.9
+T15H9.6	C25A1.9
+T20G5.9	C25A1.9
+W08E3.2	C25A1.9
+W08G11.4	C25A1.9
+Y106G6H.2	C25A1.9
+Y32F6A.3	C25A1.9
+Y48G8AL.6	C25A1.9
+Y54F10AL.2	C25A1.9
+Y65B4A.6	C25A1.9
+Y67H2A.1	C25A1.9
+Y71F9AM.5	C25A1.9
+Y73B6A.4	C25A1.9
+Y73B6BL.18	C25A1.9
+Y76B12C.7	C25A1.9
+C43E11.1	C33H5.7
+C44H9.4	C33H5.7
+C48B6.6	C33H5.7
+D1046.1	C33H5.7
+F09G2.4	C33H5.7
+F11A10.8	C33H5.7
+F18H3.3	C33H5.7
+F23B2.6	C33H5.7
+F25G6.2	C33H5.7
+F26A3.2	C33H5.7
+F26E4.1	C33H5.7
+F28C6.3	C33H5.7
+F28C6.6	C33H5.7
+F28D9.1	C33H5.7
+F29F11.6	C33H5.7
+F32D1.9	C33H5.7
+F33D11.10	C33H5.7
+F37E3.1	C33H5.7
+F38H4.9	C33H5.7
+F43G6.5	C33H5.7
+F43G9.5	C33H5.7
+F46B6.3	C33H5.7
+F48E8.5	C33H5.7
+F56A8.6	C33H5.7
+F56C9.1	C33H5.7
+F59A2.4	C33H5.7
+H19N07.1	C33H5.7
+K02F3.11	C33H5.7
+K07A12.4	C33H5.7
+M18.7	C33H5.7
+R06A4.9	C33H5.7
+R07E5.14	C33H5.7
+R09B3.5	C33H5.7
+R10E9.1	C33H5.7
+R144.2	C33H5.7
+R186.7	C33H5.7
+R74.6	C33H5.7
+T05H4.6	C33H5.7
+T13C2.4	C33H5.7
+T15H9.6	C33H5.7
+T20G5.9	C33H5.7
+W08E3.2	C33H5.7
+W08G11.4	C33H5.7
+Y106G6H.2	C33H5.7
+Y32F6A.3	C33H5.7
+Y48G8AL.6	C33H5.7
+Y54F10AL.2	C33H5.7
+Y65B4A.6	C33H5.7
+Y67H2A.1	C33H5.7
+Y71F9AM.5	C33H5.7
+Y73B6A.4	C33H5.7
+Y73B6BL.18	C33H5.7
+Y76B12C.7	C33H5.7
+C48B6.6	C43E11.1
+D1046.1	C43E11.1
+F09G2.4	C43E11.1
+F11A10.8	C43E11.1
+F25G6.2	C43E11.1
+F26E4.1	C43E11.1
+F28C6.3	C43E11.1
+F28C6.6	C43E11.1
+F29F11.6	C43E11.1
+F32D1.9	C43E11.1
+F38H4.9	C43E11.1
+F43G6.5	C43E11.1
+F43G9.5	C43E11.1
+F48E8.5	C43E11.1
+F56A8.6	C43E11.1
+F56C9.1	C43E11.1
+F59A2.4	C43E11.1
+H19N07.1	C43E11.1
+K07A12.4	C43E11.1
+R06A4.9	C43E11.1
+R10E9.1	C43E11.1
+R144.2	C43E11.1
+R74.6	C43E11.1
+T05H4.6	C43E11.1
+T13C2.4	C43E11.1
+T15H9.6	C43E11.1
+W08G11.4	C43E11.1
+Y32F6A.3	C43E11.1
+Y54F10AL.2	C43E11.1
+Y67H2A.1	C43E11.1
+Y73B6A.4	C43E11.1
+Y76B12C.7	C43E11.1
+C48B6.6	C44H9.4
+D1046.1	C44H9.4
+F09G2.4	C44H9.4
+F11A10.8	C44H9.4
+F25G6.2	C44H9.4
+F26E4.1	C44H9.4
+F28C6.3	C44H9.4
+F28C6.6	C44H9.4
+F29F11.6	C44H9.4
+F32D1.9	C44H9.4
+F38H4.9	C44H9.4
+F43G6.5	C44H9.4
+F43G9.5	C44H9.4
+F48E8.5	C44H9.4
+F56A8.6	C44H9.4
+F56C9.1	C44H9.4
+F59A2.4	C44H9.4
+H19N07.1	C44H9.4
+K07A12.4	C44H9.4
+R06A4.9	C44H9.4
+R10E9.1	C44H9.4
+R144.2	C44H9.4
+R74.6	C44H9.4
+T05H4.6	C44H9.4
+T13C2.4	C44H9.4
+T15H9.6	C44H9.4
+W08G11.4	C44H9.4
+Y32F6A.3	C44H9.4
+Y54F10AL.2	C44H9.4
+Y67H2A.1	C44H9.4
+Y73B6A.4	C44H9.4
+Y76B12C.7	C44H9.4
+D1046.1	C48B6.6
+F09G2.4	C48B6.6
+F11A10.8	C48B6.6
+F18H3.3	C48B6.6
+F23B2.6	C48B6.6
+F25G6.2	C48B6.6
+F26A3.2	C48B6.6
+F26E4.1	C48B6.6
+F28C6.3	C48B6.6
+F28C6.6	C48B6.6
+F28D9.1	C48B6.6
+F29F11.6	C48B6.6
+F32D1.9	C48B6.6
+F33D11.10	C48B6.6
+F37E3.1	C48B6.6
+F38H4.9	C48B6.6
+F43G6.5	C48B6.6
+F43G9.5	C48B6.6
+F46B6.3	C48B6.6
+F48E8.5	C48B6.6
+F56A8.6	C48B6.6
+F56C9.1	C48B6.6
+F59A2.4	C48B6.6
+H19N07.1	C48B6.6
+K02F3.11	C48B6.6
+K07A12.4	C48B6.6
+M18.7	C48B6.6
+R06A4.9	C48B6.6
+R07E5.14	C48B6.6
+R09B3.5	C48B6.6
+R10E9.1	C48B6.6
+R144.2	C48B6.6
+R186.7	C48B6.6
+R74.6	C48B6.6
+T05H4.6	C48B6.6
+T13C2.4	C48B6.6
+T15H9.6	C48B6.6
+T20G5.9	C48B6.6
+W08E3.2	C48B6.6
+W08G11.4	C48B6.6
+Y106G6H.2	C48B6.6
+Y32F6A.3	C48B6.6
+Y48G8AL.6	C48B6.6
+Y54F10AL.2	C48B6.6
+Y65B4A.6	C48B6.6
+Y67H2A.1	C48B6.6
+Y71F9AM.5	C48B6.6
+Y73B6A.4	C48B6.6
+Y73B6BL.18	C48B6.6
+Y76B12C.7	C48B6.6
+F09G2.4	D1046.1
+F11A10.8	D1046.1
+F18H3.3	D1046.1
+F23B2.6	D1046.1
+F25G6.2	D1046.1
+F26A3.2	D1046.1
+F26E4.1	D1046.1
+F28C6.3	D1046.1
+F28C6.6	D1046.1
+F28D9.1	D1046.1
+F29F11.6	D1046.1
+F32D1.9	D1046.1
+F33D11.10	D1046.1
+F37E3.1	D1046.1
+F38H4.9	D1046.1
+F43G6.5	D1046.1
+F43G9.5	D1046.1
+F46B6.3	D1046.1
+F48E8.5	D1046.1
+F56A8.6	D1046.1
+F56C9.1	D1046.1
+F59A2.4	D1046.1
+H19N07.1	D1046.1
+K02F3.11	D1046.1
+K07A12.4	D1046.1
+M18.7	D1046.1
+R06A4.9	D1046.1
+R07E5.14	D1046.1
+R09B3.5	D1046.1
+R10E9.1	D1046.1
+R144.2	D1046.1
+R186.7	D1046.1
+R74.6	D1046.1
+T05H4.6	D1046.1
+T13C2.4	D1046.1
+T15H9.6	D1046.1
+T20G5.9	D1046.1
+W08E3.2	D1046.1
+W08G11.4	D1046.1
+Y106G6H.2	D1046.1
+Y32F6A.3	D1046.1
+Y48G8AL.6	D1046.1
+Y54F10AL.2	D1046.1
+Y65B4A.6	D1046.1
+Y67H2A.1	D1046.1
+Y71F9AM.5	D1046.1
+Y73B6A.4	D1046.1
+Y73B6BL.18	D1046.1
+Y76B12C.7	D1046.1
+F11A10.8	F09G2.4
+F18H3.3	F09G2.4
+F23B2.6	F09G2.4
+F25G6.2	F09G2.4
+F26A3.2	F09G2.4
+F26E4.1	F09G2.4
+F28C6.3	F09G2.4
+F28C6.6	F09G2.4
+F28D9.1	F09G2.4
+F29F11.6	F09G2.4
+F32D1.9	F09G2.4
+F33D11.10	F09G2.4
+F37E3.1	F09G2.4
+F38H4.9	F09G2.4
+F43G6.5	F09G2.4
+F43G9.5	F09G2.4
+F46B6.3	F09G2.4
+F48E8.5	F09G2.4
+F56A8.6	F09G2.4
+F56C9.1	F09G2.4
+F59A2.4	F09G2.4
+H19N07.1	F09G2.4
+K02F3.11	F09G2.4
+K07A12.4	F09G2.4
+M18.7	F09G2.4
+R06A4.9	F09G2.4
+R07E5.14	F09G2.4
+R09B3.5	F09G2.4
+R10E9.1	F09G2.4
+R144.2	F09G2.4
+R186.7	F09G2.4
+R74.6	F09G2.4
+T05H4.6	F09G2.4
+T13C2.4	F09G2.4
+T15H9.6	F09G2.4
+T20G5.9	F09G2.4
+W08E3.2	F09G2.4
+W08G11.4	F09G2.4
+Y106G6H.2	F09G2.4
+Y32F6A.3	F09G2.4
+Y48G8AL.6	F09G2.4
+Y54F10AL.2	F09G2.4
+Y65B4A.6	F09G2.4
+Y67H2A.1	F09G2.4
+Y71F9AM.5	F09G2.4
+Y73B6A.4	F09G2.4
+Y73B6BL.18	F09G2.4
+Y76B12C.7	F09G2.4
+F18H3.3	F11A10.8
+F23B2.6	F11A10.8
+F25G6.2	F11A10.8
+F26A3.2	F11A10.8
+F26E4.1	F11A10.8
+F28C6.3	F11A10.8
+F28C6.6	F11A10.8
+F28D9.1	F11A10.8
+F29F11.6	F11A10.8
+F32D1.9	F11A10.8
+F33D11.10	F11A10.8
+F37E3.1	F11A10.8
+F38H4.9	F11A10.8
+F43G6.5	F11A10.8
+F43G9.5	F11A10.8
+F46B6.3	F11A10.8
+F48E8.5	F11A10.8
+F56A8.6	F11A10.8
+F56C9.1	F11A10.8
+F59A2.4	F11A10.8
+H19N07.1	F11A10.8
+K02F3.11	F11A10.8
+K07A12.4	F11A10.8
+M18.7	F11A10.8
+R06A4.9	F11A10.8
+R07E5.14	F11A10.8
+R09B3.5	F11A10.8
+R10E9.1	F11A10.8
+R144.2	F11A10.8
+R186.7	F11A10.8
+R74.6	F11A10.8
+T05H4.6	F11A10.8
+T13C2.4	F11A10.8
+T15H9.6	F11A10.8
+T20G5.9	F11A10.8
+W08E3.2	F11A10.8
+W08G11.4	F11A10.8
+Y106G6H.2	F11A10.8
+Y32F6A.3	F11A10.8
+Y48G8AL.6	F11A10.8
+Y54F10AL.2	F11A10.8
+Y65B4A.6	F11A10.8
+Y67H2A.1	F11A10.8
+Y71F9AM.5	F11A10.8
+Y73B6A.4	F11A10.8
+Y73B6BL.18	F11A10.8
+Y76B12C.7	F11A10.8
+F25G6.2	F18H3.3
+F26E4.1	F18H3.3
+F28C6.3	F18H3.3
+F28C6.6	F18H3.3
+F29F11.6	F18H3.3
+F32D1.9	F18H3.3
+F38H4.9	F18H3.3
+F43G6.5	F18H3.3
+F43G9.5	F18H3.3
+F48E8.5	F18H3.3
+F56A8.6	F18H3.3
+F56C9.1	F18H3.3
+F59A2.4	F18H3.3
+H19N07.1	F18H3.3
+K07A12.4	F18H3.3
+R06A4.9	F18H3.3
+R10E9.1	F18H3.3
+R144.2	F18H3.3
+R74.6	F18H3.3
+T05H4.6	F18H3.3
+T13C2.4	F18H3.3
+T15H9.6	F18H3.3
+W08G11.4	F18H3.3
+Y32F6A.3	F18H3.3
+Y54F10AL.2	F18H3.3
+Y67H2A.1	F18H3.3
+Y73B6A.4	F18H3.3
+Y76B12C.7	F18H3.3
+F25G6.2	F23B2.6
+F26E4.1	F23B2.6
+F28C6.3	F23B2.6
+F28C6.6	F23B2.6
+F29F11.6	F23B2.6
+F32D1.9	F23B2.6
+F38H4.9	F23B2.6
+F43G6.5	F23B2.6
+F43G9.5	F23B2.6
+F48E8.5	F23B2.6
+F56A8.6	F23B2.6
+F56C9.1	F23B2.6
+F59A2.4	F23B2.6
+H19N07.1	F23B2.6
+K07A12.4	F23B2.6
+R06A4.9	F23B2.6
+R10E9.1	F23B2.6
+R144.2	F23B2.6
+R74.6	F23B2.6
+T05H4.6	F23B2.6
+T13C2.4	F23B2.6
+T15H9.6	F23B2.6
+W08G11.4	F23B2.6
+Y32F6A.3	F23B2.6
+Y54F10AL.2	F23B2.6
+Y67H2A.1	F23B2.6
+Y73B6A.4	F23B2.6
+Y76B12C.7	F23B2.6
+F26A3.2	F25G6.2
+F26E4.1	F25G6.2
+F28C6.3	F25G6.2
+F28C6.6	F25G6.2
+F28D9.1	F25G6.2
+F29F11.6	F25G6.2
+F32D1.9	F25G6.2
+F33D11.10	F25G6.2
+F37E3.1	F25G6.2
+F38H4.9	F25G6.2
+F43G6.5	F25G6.2
+F43G9.5	F25G6.2
+F46B6.3	F25G6.2
+F48E8.5	F25G6.2
+F56A8.6	F25G6.2
+F56C9.1	F25G6.2
+F59A2.4	F25G6.2
+H19N07.1	F25G6.2
+K02F3.11	F25G6.2
+K07A12.4	F25G6.2
+M18.7	F25G6.2
+R06A4.9	F25G6.2
+R07E5.14	F25G6.2
+R09B3.5	F25G6.2
+R10E9.1	F25G6.2
+R144.2	F25G6.2
+R186.7	F25G6.2
+R74.6	F25G6.2
+T05H4.6	F25G6.2
+T13C2.4	F25G6.2
+T15H9.6	F25G6.2
+T20G5.9	F25G6.2
+W08E3.2	F25G6.2
+W08G11.4	F25G6.2
+Y106G6H.2	F25G6.2
+Y32F6A.3	F25G6.2
+Y48G8AL.6	F25G6.2
+Y54F10AL.2	F25G6.2
+Y65B4A.6	F25G6.2
+Y67H2A.1	F25G6.2
+Y71F9AM.5	F25G6.2
+Y73B6A.4	F25G6.2
+Y73B6BL.18	F25G6.2
+Y76B12C.7	F25G6.2
+F26E4.1	F26A3.2
+F28C6.3	F26A3.2
+F28C6.6	F26A3.2
+F29F11.6	F26A3.2
+F32D1.9	F26A3.2
+F38H4.9	F26A3.2
+F43G6.5	F26A3.2
+F43G9.5	F26A3.2
+F48E8.5	F26A3.2
+F56A8.6	F26A3.2
+F56C9.1	F26A3.2
+F59A2.4	F26A3.2
+H19N07.1	F26A3.2
+K07A12.4	F26A3.2
+R06A4.9	F26A3.2
+R10E9.1	F26A3.2
+R144.2	F26A3.2
+R74.6	F26A3.2
+T05H4.6	F26A3.2
+T13C2.4	F26A3.2
+T15H9.6	F26A3.2
+W08G11.4	F26A3.2
+Y32F6A.3	F26A3.2
+Y54F10AL.2	F26A3.2
+Y67H2A.1	F26A3.2
+Y73B6A.4	F26A3.2
+Y76B12C.7	F26A3.2
+F28C6.3	F26E4.1
+F28C6.6	F26E4.1
+F28D9.1	F26E4.1
+F29F11.6	F26E4.1
+F32D1.9	F26E4.1
+F33D11.10	F26E4.1
+F37E3.1	F26E4.1
+F38H4.9	F26E4.1
+F43G6.5	F26E4.1
+F43G9.5	F26E4.1
+F46B6.3	F26E4.1
+F48E8.5	F26E4.1
+F56A8.6	F26E4.1
+F56C9.1	F26E4.1
+F59A2.4	F26E4.1
+H19N07.1	F26E4.1
+K02F3.11	F26E4.1
+K07A12.4	F26E4.1
+M18.7	F26E4.1
+R06A4.9	F26E4.1
+R07E5.14	F26E4.1
+R09B3.5	F26E4.1
+R10E9.1	F26E4.1
+R144.2	F26E4.1
+R186.7	F26E4.1
+R74.6	F26E4.1
+T05H4.6	F26E4.1
+T13C2.4	F26E4.1
+T15H9.6	F26E4.1
+T20G5.9	F26E4.1
+W08E3.2	F26E4.1
+W08G11.4	F26E4.1
+Y106G6H.2	F26E4.1
+Y32F6A.3	F26E4.1
+Y48G8AL.6	F26E4.1
+Y54F10AL.2	F26E4.1
+Y65B4A.6	F26E4.1
+Y67H2A.1	F26E4.1
+Y71F9AM.5	F26E4.1
+Y73B6A.4	F26E4.1
+Y73B6BL.18	F26E4.1
+Y76B12C.7	F26E4.1
+F28C6.6	F28C6.3
+F28D9.1	F28C6.3
+F29F11.6	F28C6.3
+F32D1.9	F28C6.3
+F33D11.10	F28C6.3
+F37E3.1	F28C6.3
+F38H4.9	F28C6.3
+F43G6.5	F28C6.3
+F43G9.5	F28C6.3
+F46B6.3	F28C6.3
+F48E8.5	F28C6.3
+F56A8.6	F28C6.3
+F56C9.1	F28C6.3
+F59A2.4	F28C6.3
+H19N07.1	F28C6.3
+K02F3.11	F28C6.3
+K07A12.4	F28C6.3
+M18.7	F28C6.3
+R06A4.9	F28C6.3
+R07E5.14	F28C6.3
+R09B3.5	F28C6.3
+R10E9.1	F28C6.3
+R144.2	F28C6.3
+R186.7	F28C6.3
+R74.6	F28C6.3
+T05H4.6	F28C6.3
+T13C2.4	F28C6.3
+T15H9.6	F28C6.3
+T20G5.9	F28C6.3
+W08E3.2	F28C6.3
+W08G11.4	F28C6.3
+Y106G6H.2	F28C6.3
+Y32F6A.3	F28C6.3
+Y48G8AL.6	F28C6.3
+Y54F10AL.2	F28C6.3
+Y65B4A.6	F28C6.3
+Y67H2A.1	F28C6.3
+Y71F9AM.5	F28C6.3
+Y73B6A.4	F28C6.3
+Y73B6BL.18	F28C6.3
+Y76B12C.7	F28C6.3
+F28D9.1	F28C6.6
+F29F11.6	F28C6.6
+F32D1.9	F28C6.6
+F33D11.10	F28C6.6
+F37E3.1	F28C6.6
+F38H4.9	F28C6.6
+F43G6.5	F28C6.6
+F43G9.5	F28C6.6
+F46B6.3	F28C6.6
+F48E8.5	F28C6.6
+F56A8.6	F28C6.6
+F56C9.1	F28C6.6
+F59A2.4	F28C6.6
+H19N07.1	F28C6.6
+K02F3.11	F28C6.6
+K07A12.4	F28C6.6
+M18.7	F28C6.6
+R06A4.9	F28C6.6
+R07E5.14	F28C6.6
+R09B3.5	F28C6.6
+R10E9.1	F28C6.6
+R144.2	F28C6.6
+R186.7	F28C6.6
+R74.6	F28C6.6
+T05H4.6	F28C6.6
+T13C2.4	F28C6.6
+T15H9.6	F28C6.6
+T20G5.9	F28C6.6
+W08E3.2	F28C6.6
+W08G11.4	F28C6.6
+Y106G6H.2	F28C6.6
+Y32F6A.3	F28C6.6
+Y48G8AL.6	F28C6.6
+Y54F10AL.2	F28C6.6
+Y65B4A.6	F28C6.6
+Y67H2A.1	F28C6.6
+Y71F9AM.5	F28C6.6
+Y73B6A.4	F28C6.6
+Y73B6BL.18	F28C6.6
+Y76B12C.7	F28C6.6
+F29F11.6	F28D9.1
+F32D1.9	F28D9.1
+F38H4.9	F28D9.1
+F43G6.5	F28D9.1
+F43G9.5	F28D9.1
+F48E8.5	F28D9.1
+F56A8.6	F28D9.1
+F56C9.1	F28D9.1
+F59A2.4	F28D9.1
+H19N07.1	F28D9.1
+K07A12.4	F28D9.1
+R06A4.9	F28D9.1
+R10E9.1	F28D9.1
+R144.2	F28D9.1
+R74.6	F28D9.1
+T05H4.6	F28D9.1
+T13C2.4	F28D9.1
+T15H9.6	F28D9.1
+W08G11.4	F28D9.1
+Y32F6A.3	F28D9.1
+Y54F10AL.2	F28D9.1
+Y67H2A.1	F28D9.1
+Y73B6A.4	F28D9.1
+Y76B12C.7	F28D9.1
+F32D1.9	F29F11.6
+F33D11.10	F29F11.6
+F37E3.1	F29F11.6
+F38H4.9	F29F11.6
+F43G6.5	F29F11.6
+F43G9.5	F29F11.6
+F46B6.3	F29F11.6
+F48E8.5	F29F11.6
+F56A8.6	F29F11.6
+F56C9.1	F29F11.6
+F59A2.4	F29F11.6
+H19N07.1	F29F11.6
+K02F3.11	F29F11.6
+K07A12.4	F29F11.6
+M18.7	F29F11.6
+R06A4.9	F29F11.6
+R07E5.14	F29F11.6
+R09B3.5	F29F11.6
+R10E9.1	F29F11.6
+R144.2	F29F11.6
+R186.7	F29F11.6
+R74.6	F29F11.6
+T05H4.6	F29F11.6
+T13C2.4	F29F11.6
+T15H9.6	F29F11.6
+T20G5.9	F29F11.6
+W08E3.2	F29F11.6
+W08G11.4	F29F11.6
+Y106G6H.2	F29F11.6
+Y32F6A.3	F29F11.6
+Y48G8AL.6	F29F11.6
+Y54F10AL.2	F29F11.6
+Y65B4A.6	F29F11.6
+Y67H2A.1	F29F11.6
+Y71F9AM.5	F29F11.6
+Y73B6A.4	F29F11.6
+Y73B6BL.18	F29F11.6
+Y76B12C.7	F29F11.6
+F33D11.10	F32D1.9
+F37E3.1	F32D1.9
+F38H4.9	F32D1.9
+F43G6.5	F32D1.9
+F43G9.5	F32D1.9
+F46B6.3	F32D1.9
+F48E8.5	F32D1.9
+F56A8.6	F32D1.9
+F56C9.1	F32D1.9
+F59A2.4	F32D1.9
+H19N07.1	F32D1.9
+K02F3.11	F32D1.9
+K07A12.4	F32D1.9
+M18.7	F32D1.9
+R06A4.9	F32D1.9
+R07E5.14	F32D1.9
+R09B3.5	F32D1.9
+R10E9.1	F32D1.9
+R144.2	F32D1.9
+R186.7	F32D1.9
+R74.6	F32D1.9
+T05H4.6	F32D1.9
+T13C2.4	F32D1.9
+T15H9.6	F32D1.9
+T20G5.9	F32D1.9
+W08E3.2	F32D1.9
+W08G11.4	F32D1.9
+Y106G6H.2	F32D1.9
+Y32F6A.3	F32D1.9
+Y48G8AL.6	F32D1.9
+Y54F10AL.2	F32D1.9
+Y65B4A.6	F32D1.9
+Y67H2A.1	F32D1.9
+Y71F9AM.5	F32D1.9
+Y73B6A.4	F32D1.9
+Y73B6BL.18	F32D1.9
+Y76B12C.7	F32D1.9
+F38H4.9	F33D11.10
+F43G6.5	F33D11.10
+F43G9.5	F33D11.10
+F48E8.5	F33D11.10
+F56A8.6	F33D11.10
+F56C9.1	F33D11.10
+F59A2.4	F33D11.10
+H19N07.1	F33D11.10
+K07A12.4	F33D11.10
+R06A4.9	F33D11.10
+R10E9.1	F33D11.10
+R144.2	F33D11.10
+R74.6	F33D11.10
+T05H4.6	F33D11.10
+T13C2.4	F33D11.10
+T15H9.6	F33D11.10
+W08G11.4	F33D11.10
+Y32F6A.3	F33D11.10
+Y54F10AL.2	F33D11.10
+Y67H2A.1	F33D11.10
+Y73B6A.4	F33D11.10
+Y76B12C.7	F33D11.10
+F38H4.9	F37E3.1
+F43G6.5	F37E3.1
+F43G9.5	F37E3.1
+F48E8.5	F37E3.1
+F56A8.6	F37E3.1
+F56C9.1	F37E3.1
+F59A2.4	F37E3.1
+H19N07.1	F37E3.1
+K07A12.4	F37E3.1
+R06A4.9	F37E3.1
+R10E9.1	F37E3.1
+R144.2	F37E3.1
+R74.6	F37E3.1
+T05H4.6	F37E3.1
+T13C2.4	F37E3.1
+T15H9.6	F37E3.1
+W08G11.4	F37E3.1
+Y32F6A.3	F37E3.1
+Y54F10AL.2	F37E3.1
+Y67H2A.1	F37E3.1
+Y73B6A.4	F37E3.1
+Y76B12C.7	F37E3.1
+F43G6.5	F38H4.9
+F43G9.5	F38H4.9
+F46B6.3	F38H4.9
+F48E8.5	F38H4.9
+F56A8.6	F38H4.9
+F56C9.1	F38H4.9
+F59A2.4	F38H4.9
+H19N07.1	F38H4.9
+K02F3.11	F38H4.9
+K07A12.4	F38H4.9
+M18.7	F38H4.9
+R06A4.9	F38H4.9
+R07E5.14	F38H4.9
+R09B3.5	F38H4.9
+R10E9.1	F38H4.9
+R144.2	F38H4.9
+R186.7	F38H4.9
+R74.6	F38H4.9
+T05H4.6	F38H4.9
+T13C2.4	F38H4.9
+T15H9.6	F38H4.9
+T20G5.9	F38H4.9
+W08E3.2	F38H4.9
+W08G11.4	F38H4.9
+Y106G6H.2	F38H4.9
+Y32F6A.3	F38H4.9
+Y48G8AL.6	F38H4.9
+Y54F10AL.2	F38H4.9
+Y65B4A.6	F38H4.9
+Y67H2A.1	F38H4.9
+Y71F9AM.5	F38H4.9
+Y73B6A.4	F38H4.9
+Y73B6BL.18	F38H4.9
+Y76B12C.7	F38H4.9
+F43G9.5	F43G6.5
+F46B6.3	F43G6.5
+F48E8.5	F43G6.5
+F56A8.6	F43G6.5
+F56C9.1	F43G6.5
+F59A2.4	F43G6.5
+H19N07.1	F43G6.5
+K02F3.11	F43G6.5
+K07A12.4	F43G6.5
+M18.7	F43G6.5
+R06A4.9	F43G6.5
+R07E5.14	F43G6.5
+R09B3.5	F43G6.5
+R10E9.1	F43G6.5
+R144.2	F43G6.5
+R186.7	F43G6.5
+R74.6	F43G6.5
+T05H4.6	F43G6.5
+T13C2.4	F43G6.5
+T15H9.6	F43G6.5
+T20G5.9	F43G6.5
+W08E3.2	F43G6.5
+W08G11.4	F43G6.5
+Y106G6H.2	F43G6.5
+Y32F6A.3	F43G6.5
+Y48G8AL.6	F43G6.5
+Y54F10AL.2	F43G6.5
+Y65B4A.6	F43G6.5
+Y67H2A.1	F43G6.5
+Y71F9AM.5	F43G6.5
+Y73B6A.4	F43G6.5
+Y73B6BL.18	F43G6.5
+Y76B12C.7	F43G6.5
+F46B6.3	F43G9.5
+F48E8.5	F43G9.5
+F56A8.6	F43G9.5
+F56C9.1	F43G9.5
+F59A2.4	F43G9.5
+H19N07.1	F43G9.5
+K02F3.11	F43G9.5
+K07A12.4	F43G9.5
+M18.7	F43G9.5
+R06A4.9	F43G9.5
+R07E5.14	F43G9.5
+R09B3.5	F43G9.5
+R10E9.1	F43G9.5
+R144.2	F43G9.5
+R186.7	F43G9.5
+R74.6	F43G9.5
+T05H4.6	F43G9.5
+T13C2.4	F43G9.5
+T15H9.6	F43G9.5
+T20G5.9	F43G9.5
+W08E3.2	F43G9.5
+W08G11.4	F43G9.5
+Y106G6H.2	F43G9.5
+Y32F6A.3	F43G9.5
+Y48G8AL.6	F43G9.5
+Y54F10AL.2	F43G9.5
+Y65B4A.6	F43G9.5
+Y67H2A.1	F43G9.5
+Y71F9AM.5	F43G9.5
+Y73B6A.4	F43G9.5
+Y73B6BL.18	F43G9.5
+Y76B12C.7	F43G9.5
+F48E8.5	F46B6.3
+F56A8.6	F46B6.3
+F56C9.1	F46B6.3
+F59A2.4	F46B6.3
+H19N07.1	F46B6.3
+K07A12.4	F46B6.3
+R06A4.9	F46B6.3
+R10E9.1	F46B6.3
+R144.2	F46B6.3
+R74.6	F46B6.3
+T05H4.6	F46B6.3
+T13C2.4	F46B6.3
+T15H9.6	F46B6.3
+W08G11.4	F46B6.3
+Y32F6A.3	F46B6.3
+Y54F10AL.2	F46B6.3
+Y67H2A.1	F46B6.3
+Y73B6A.4	F46B6.3
+Y76B12C.7	F46B6.3
+F56A8.6	F48E8.5
+F56C9.1	F48E8.5
+F59A2.4	F48E8.5
+H19N07.1	F48E8.5
+K02F3.11	F48E8.5
+K07A12.4	F48E8.5
+M18.7	F48E8.5
+R06A4.9	F48E8.5
+R07E5.14	F48E8.5
+R09B3.5	F48E8.5
+R10E9.1	F48E8.5
+R144.2	F48E8.5
+R186.7	F48E8.5
+R74.6	F48E8.5
+T05H4.6	F48E8.5
+T13C2.4	F48E8.5
+T15H9.6	F48E8.5
+T20G5.9	F48E8.5
+W08E3.2	F48E8.5
+W08G11.4	F48E8.5
+Y106G6H.2	F48E8.5
+Y32F6A.3	F48E8.5
+Y48G8AL.6	F48E8.5
+Y54F10AL.2	F48E8.5
+Y65B4A.6	F48E8.5
+Y67H2A.1	F48E8.5
+Y71F9AM.5	F48E8.5
+Y73B6A.4	F48E8.5
+Y73B6BL.18	F48E8.5
+Y76B12C.7	F48E8.5
+F56C9.1	F56A8.6
+F59A2.4	F56A8.6
+H19N07.1	F56A8.6
+K02F3.11	F56A8.6
+K07A12.4	F56A8.6
+M18.7	F56A8.6
+R06A4.9	F56A8.6
+R07E5.14	F56A8.6
+R09B3.5	F56A8.6
+R10E9.1	F56A8.6
+R144.2	F56A8.6
+R186.7	F56A8.6
+R74.6	F56A8.6
+T05H4.6	F56A8.6
+T13C2.4	F56A8.6
+T15H9.6	F56A8.6
+T20G5.9	F56A8.6
+W08E3.2	F56A8.6
+W08G11.4	F56A8.6
+Y106G6H.2	F56A8.6
+Y32F6A.3	F56A8.6
+Y48G8AL.6	F56A8.6
+Y54F10AL.2	F56A8.6
+Y65B4A.6	F56A8.6
+Y67H2A.1	F56A8.6
+Y71F9AM.5	F56A8.6
+Y73B6A.4	F56A8.6
+Y73B6BL.18	F56A8.6
+Y76B12C.7	F56A8.6
+F59A2.4	F56C9.1
+H19N07.1	F56C9.1
+K02F3.11	F56C9.1
+K07A12.4	F56C9.1
+M18.7	F56C9.1
+R06A4.9	F56C9.1
+R07E5.14	F56C9.1
+R09B3.5	F56C9.1
+R10E9.1	F56C9.1
+R144.2	F56C9.1
+R186.7	F56C9.1
+R74.6	F56C9.1
+T05H4.6	F56C9.1
+T13C2.4	F56C9.1
+T15H9.6	F56C9.1
+T20G5.9	F56C9.1
+W08E3.2	F56C9.1
+W08G11.4	F56C9.1
+Y106G6H.2	F56C9.1
+Y32F6A.3	F56C9.1
+Y48G8AL.6	F56C9.1
+Y54F10AL.2	F56C9.1
+Y65B4A.6	F56C9.1
+Y67H2A.1	F56C9.1
+Y71F9AM.5	F56C9.1
+Y73B6A.4	F56C9.1
+Y73B6BL.18	F56C9.1
+Y76B12C.7	F56C9.1
+H19N07.1	F59A2.4
+K02F3.11	F59A2.4
+K07A12.4	F59A2.4
+M18.7	F59A2.4
+R06A4.9	F59A2.4
+R07E5.14	F59A2.4
+R09B3.5	F59A2.4
+R10E9.1	F59A2.4
+R144.2	F59A2.4
+R186.7	F59A2.4
+R74.6	F59A2.4
+T05H4.6	F59A2.4
+T13C2.4	F59A2.4
+T15H9.6	F59A2.4
+T20G5.9	F59A2.4
+W08E3.2	F59A2.4
+W08G11.4	F59A2.4
+Y106G6H.2	F59A2.4
+Y32F6A.3	F59A2.4
+Y48G8AL.6	F59A2.4
+Y54F10AL.2	F59A2.4
+Y65B4A.6	F59A2.4
+Y67H2A.1	F59A2.4
+Y71F9AM.5	F59A2.4
+Y73B6A.4	F59A2.4
+Y73B6BL.18	F59A2.4
+Y76B12C.7	F59A2.4
+K02F3.11	H19N07.1
+K07A12.4	H19N07.1
+M18.7	H19N07.1
+R06A4.9	H19N07.1
+R07E5.14	H19N07.1
+R09B3.5	H19N07.1
+R10E9.1	H19N07.1
+R144.2	H19N07.1
+R186.7	H19N07.1
+R74.6	H19N07.1
+T05H4.6	H19N07.1
+T13C2.4	H19N07.1
+T15H9.6	H19N07.1
+T20G5.9	H19N07.1
+W08E3.2	H19N07.1
+W08G11.4	H19N07.1
+Y106G6H.2	H19N07.1
+Y32F6A.3	H19N07.1
+Y48G8AL.6	H19N07.1
+Y54F10AL.2	H19N07.1
+Y65B4A.6	H19N07.1
+Y67H2A.1	H19N07.1
+Y71F9AM.5	H19N07.1
+Y73B6A.4	H19N07.1
+Y73B6BL.18	H19N07.1
+Y76B12C.7	H19N07.1
+K07A12.4	K02F3.11
+R06A4.9	K02F3.11
+R10E9.1	K02F3.11
+R144.2	K02F3.11
+R74.6	K02F3.11
+T05H4.6	K02F3.11
+T13C2.4	K02F3.11
+T15H9.6	K02F3.11
+W08G11.4	K02F3.11
+Y32F6A.3	K02F3.11
+Y54F10AL.2	K02F3.11
+Y67H2A.1	K02F3.11
+Y73B6A.4	K02F3.11
+Y76B12C.7	K02F3.11
+M18.7	K07A12.4
+R06A4.9	K07A12.4
+R07E5.14	K07A12.4
+R09B3.5	K07A12.4
+R10E9.1	K07A12.4
+R144.2	K07A12.4
+R186.7	K07A12.4
+R74.6	K07A12.4
+T05H4.6	K07A12.4
+T13C2.4	K07A12.4
+T15H9.6	K07A12.4
+T20G5.9	K07A12.4
+W08E3.2	K07A12.4
+W08G11.4	K07A12.4
+Y106G6H.2	K07A12.4
+Y32F6A.3	K07A12.4
+Y48G8AL.6	K07A12.4
+Y54F10AL.2	K07A12.4
+Y65B4A.6	K07A12.4
+Y67H2A.1	K07A12.4
+Y71F9AM.5	K07A12.4
+Y73B6A.4	K07A12.4
+Y73B6BL.18	K07A12.4
+Y76B12C.7	K07A12.4
+R06A4.9	M18.7
+R10E9.1	M18.7
+R144.2	M18.7
+R74.6	M18.7
+T05H4.6	M18.7
+T13C2.4	M18.7
+T15H9.6	M18.7
+W08G11.4	M18.7
+Y32F6A.3	M18.7
+Y54F10AL.2	M18.7
+Y67H2A.1	M18.7
+Y73B6A.4	M18.7
+Y76B12C.7	M18.7
+R07E5.14	R06A4.9
+R09B3.5	R06A4.9
+R10E9.1	R06A4.9
+R144.2	R06A4.9
+R186.7	R06A4.9
+R74.6	R06A4.9
+T05H4.6	R06A4.9
+T13C2.4	R06A4.9
+T15H9.6	R06A4.9
+T20G5.9	R06A4.9
+W08E3.2	R06A4.9
+W08G11.4	R06A4.9
+Y106G6H.2	R06A4.9
+Y32F6A.3	R06A4.9
+Y48G8AL.6	R06A4.9
+Y54F10AL.2	R06A4.9
+Y65B4A.6	R06A4.9
+Y67H2A.1	R06A4.9
+Y71F9AM.5	R06A4.9
+Y73B6A.4	R06A4.9
+Y73B6BL.18	R06A4.9
+Y76B12C.7	R06A4.9
+R10E9.1	R07E5.14
+R144.2	R07E5.14
+R74.6	R07E5.14
+T05H4.6	R07E5.14
+T13C2.4	R07E5.14
+T15H9.6	R07E5.14
+W08G11.4	R07E5.14
+Y32F6A.3	R07E5.14
+Y54F10AL.2	R07E5.14
+Y67H2A.1	R07E5.14
+Y73B6A.4	R07E5.14
+Y76B12C.7	R07E5.14
+R10E9.1	R09B3.5
+R144.2	R09B3.5
+R74.6	R09B3.5
+T05H4.6	R09B3.5
+T13C2.4	R09B3.5
+T15H9.6	R09B3.5
+W08G11.4	R09B3.5
+Y32F6A.3	R09B3.5
+Y54F10AL.2	R09B3.5
+Y67H2A.1	R09B3.5
+Y73B6A.4	R09B3.5
+Y76B12C.7	R09B3.5
+R144.2	R10E9.1
+R186.7	R10E9.1
+R74.6	R10E9.1
+T05H4.6	R10E9.1
+T13C2.4	R10E9.1
+T15H9.6	R10E9.1
+T20G5.9	R10E9.1
+W08E3.2	R10E9.1
+W08G11.4	R10E9.1
+Y106G6H.2	R10E9.1
+Y32F6A.3	R10E9.1
+Y48G8AL.6	R10E9.1
+Y54F10AL.2	R10E9.1
+Y65B4A.6	R10E9.1
+Y67H2A.1	R10E9.1
+Y71F9AM.5	R10E9.1
+Y73B6A.4	R10E9.1
+Y73B6BL.18	R10E9.1
+Y76B12C.7	R10E9.1
+R186.7	R144.2
+R74.6	R144.2
+T05H4.6	R144.2
+T13C2.4	R144.2
+T15H9.6	R144.2
+T20G5.9	R144.2
+W08E3.2	R144.2
+W08G11.4	R144.2
+Y106G6H.2	R144.2
+Y32F6A.3	R144.2
+Y48G8AL.6	R144.2
+Y54F10AL.2	R144.2
+Y65B4A.6	R144.2
+Y67H2A.1	R144.2
+Y71F9AM.5	R144.2
+Y73B6A.4	R144.2
+Y73B6BL.18	R144.2
+Y76B12C.7	R144.2
+R74.6	R186.7
+T05H4.6	R186.7
+T13C2.4	R186.7
+T15H9.6	R186.7
+W08G11.4	R186.7
+Y32F6A.3	R186.7
+Y54F10AL.2	R186.7
+Y67H2A.1	R186.7
+Y73B6A.4	R186.7
+Y76B12C.7	R186.7
+T05H4.6	R74.6
+T13C2.4	R74.6
+T15H9.6	R74.6
+T20G5.9	R74.6
+W08E3.2	R74.6
+W08G11.4	R74.6
+Y106G6H.2	R74.6
+Y32F6A.3	R74.6
+Y48G8AL.6	R74.6
+Y54F10AL.2	R74.6
+Y65B4A.6	R74.6
+Y67H2A.1	R74.6
+Y71F9AM.5	R74.6
+Y73B6A.4	R74.6
+Y73B6BL.18	R74.6
+Y76B12C.7	R74.6
+T13C2.4	T05H4.6
+T15H9.6	T05H4.6
+T20G5.9	T05H4.6
+W08E3.2	T05H4.6
+W08G11.4	T05H4.6
+Y106G6H.2	T05H4.6
+Y32F6A.3	T05H4.6
+Y48G8AL.6	T05H4.6
+Y54F10AL.2	T05H4.6
+Y65B4A.6	T05H4.6
+Y67H2A.1	T05H4.6
+Y71F9AM.5	T05H4.6
+Y73B6A.4	T05H4.6
+Y73B6BL.18	T05H4.6
+Y76B12C.7	T05H4.6
+T15H9.6	T13C2.4
+T20G5.9	T13C2.4
+W08E3.2	T13C2.4
+W08G11.4	T13C2.4
+Y106G6H.2	T13C2.4
+Y32F6A.3	T13C2.4
+Y48G8AL.6	T13C2.4
+Y54F10AL.2	T13C2.4
+Y65B4A.6	T13C2.4
+Y67H2A.1	T13C2.4
+Y71F9AM.5	T13C2.4
+Y73B6A.4	T13C2.4
+Y73B6BL.18	T13C2.4
+Y76B12C.7	T13C2.4
+T20G5.9	T15H9.6
+W08E3.2	T15H9.6
+W08G11.4	T15H9.6
+Y106G6H.2	T15H9.6
+Y32F6A.3	T15H9.6
+Y48G8AL.6	T15H9.6
+Y54F10AL.2	T15H9.6
+Y65B4A.6	T15H9.6
+Y67H2A.1	T15H9.6
+Y71F9AM.5	T15H9.6
+Y73B6A.4	T15H9.6
+Y73B6BL.18	T15H9.6
+Y76B12C.7	T15H9.6
+W08G11.4	T20G5.9
+Y32F6A.3	T20G5.9
+Y54F10AL.2	T20G5.9
+Y67H2A.1	T20G5.9
+Y73B6A.4	T20G5.9
+Y76B12C.7	T20G5.9
+W08G11.4	W08E3.2
+Y32F6A.3	W08E3.2
+Y54F10AL.2	W08E3.2
+Y67H2A.1	W08E3.2
+Y73B6A.4	W08E3.2
+Y76B12C.7	W08E3.2
+Y106G6H.2	W08G11.4
+Y32F6A.3	W08G11.4
+Y48G8AL.6	W08G11.4
+Y54F10AL.2	W08G11.4
+Y65B4A.6	W08G11.4
+Y67H2A.1	W08G11.4
+Y71F9AM.5	W08G11.4
+Y73B6A.4	W08G11.4
+Y73B6BL.18	W08G11.4
+Y76B12C.7	W08G11.4
+Y32F6A.3	Y106G6H.2
+Y54F10AL.2	Y106G6H.2
+Y67H2A.1	Y106G6H.2
+Y73B6A.4	Y106G6H.2
+Y76B12C.7	Y106G6H.2
+Y48G8AL.6	Y32F6A.3
+Y54F10AL.2	Y32F6A.3
+Y65B4A.6	Y32F6A.3
+Y67H2A.1	Y32F6A.3
+Y71F9AM.5	Y32F6A.3
+Y73B6A.4	Y32F6A.3
+Y73B6BL.18	Y32F6A.3
+Y76B12C.7	Y32F6A.3
+Y54F10AL.2	Y48G8AL.6
+Y67H2A.1	Y48G8AL.6
+Y73B6A.4	Y48G8AL.6
+Y76B12C.7	Y48G8AL.6
+Y65B4A.6	Y54F10AL.2
+Y67H2A.1	Y54F10AL.2
+Y71F9AM.5	Y54F10AL.2
+Y73B6A.4	Y54F10AL.2
+Y73B6BL.18	Y54F10AL.2
+Y76B12C.7	Y54F10AL.2
+Y67H2A.1	Y65B4A.6
+Y73B6A.4	Y65B4A.6
+Y76B12C.7	Y65B4A.6
+Y71F9AM.5	Y67H2A.1
+Y73B6A.4	Y67H2A.1
+Y73B6BL.18	Y67H2A.1
+Y76B12C.7	Y67H2A.1
+Y73B6A.4	Y71F9AM.5
+Y76B12C.7	Y71F9AM.5
+Y73B6BL.18	Y73B6A.4
+Y76B12C.7	Y73B6A.4
+Y76B12C.7	Y73B6BL.18
+B0564.1	B0286.4
+BE0003N10.1	B0286.4
+C04G2.6	B0286.4
+C07H6.5	B0286.4
+C14A4.4	B0286.4
+C14A4.5	B0286.4
+C26E6.3	B0286.4
+C37H5.8	B0286.4
+C49H3.5	B0286.4
+F01G4.3	B0286.4
+F18H3.3	B0286.4
+F28F8.3	B0286.4
+F29A7.6	B0286.4
+F31D4.1	B0286.4
+F31E3.4	B0286.4
+F32A5.7	B0286.4
+F37C12.13	B0286.4
+F40F8.9	B0286.4
+F43G6.9	B0286.4
+F52G2.1	B0286.4
+F57B9.2	B0286.4
+F59C6.4	B0286.4
+T10G3.6	B0286.4
+T21B10.2	B0286.4
+W08D2.7	B0286.4
+Y106G6H.2	B0286.4
+Y113G7A.9	B0286.4
+Y22D7AL.5	B0286.4
+Y39G8C.1	B0286.4
+Y48A6B.5	B0286.4
+Y48B6A.3	B0286.4
+Y51H7C.7	B0286.4
+Y56A3A.1	B0286.4
+Y56A3A.20	B0286.4
+Y62E10A.12	B0286.4
+Y71G12B.14	B0286.4
+Y73B6BL.3	B0286.4
+Y73B6BL.32	B0286.4
+ZC518.3	B0286.4
+ZK593.7	B0286.4
+ZK632.7	B0286.4
+ZK858.1	B0286.4
+BE0003N10.1	B0564.1
+C04G2.6	B0564.1
+C07H6.5	B0564.1
+C14A4.4	B0564.1
+C14A4.5	B0564.1
+C26E6.3	B0564.1
+C37H5.8	B0564.1
+C49H3.5	B0564.1
+F01G4.3	B0564.1
+F18H3.3	B0564.1
+F28F8.3	B0564.1
+F29A7.6	B0564.1
+F31D4.1	B0564.1
+F31E3.4	B0564.1
+F32A5.7	B0564.1
+F37C12.13	B0564.1
+F40F8.9	B0564.1
+F43G6.9	B0564.1
+F52G2.1	B0564.1
+F57B9.2	B0564.1
+F59C6.4	B0564.1
+T10G3.6	B0564.1
+T21B10.2	B0564.1
+W08D2.7	B0564.1
+Y106G6H.2	B0564.1
+Y113G7A.9	B0564.1
+Y22D7AL.5	B0564.1
+Y39G8C.1	B0564.1
+Y48A6B.5	B0564.1
+Y48B6A.3	B0564.1
+Y51H7C.7	B0564.1
+Y56A3A.1	B0564.1
+Y56A3A.20	B0564.1
+Y62E10A.12	B0564.1
+Y71G12B.14	B0564.1
+Y73B6BL.3	B0564.1
+Y73B6BL.32	B0564.1
+ZC518.3	B0564.1
+ZK593.7	B0564.1
+ZK632.7	B0564.1
+ZK858.1	B0564.1
+C04G2.6	BE0003N10.1
+C07H6.5	BE0003N10.1
+C14A4.4	BE0003N10.1
+C14A4.5	BE0003N10.1
+C26E6.3	BE0003N10.1
+C37H5.8	BE0003N10.1
+C49H3.5	BE0003N10.1
+F01G4.3	BE0003N10.1
+F18H3.3	BE0003N10.1
+F28F8.3	BE0003N10.1
+F29A7.6	BE0003N10.1
+F31D4.1	BE0003N10.1
+F31E3.4	BE0003N10.1
+F32A5.7	BE0003N10.1
+F37C12.13	BE0003N10.1
+F40F8.9	BE0003N10.1
+F43G6.9	BE0003N10.1
+F52G2.1	BE0003N10.1
+F57B9.2	BE0003N10.1
+F59C6.4	BE0003N10.1
+T10G3.6	BE0003N10.1
+T21B10.2	BE0003N10.1
+W08D2.7	BE0003N10.1
+Y106G6H.2	BE0003N10.1
+Y113G7A.9	BE0003N10.1
+Y22D7AL.5	BE0003N10.1
+Y39G8C.1	BE0003N10.1
+Y48A6B.5	BE0003N10.1
+Y48B6A.3	BE0003N10.1
+Y51H7C.7	BE0003N10.1
+Y56A3A.1	BE0003N10.1
+Y56A3A.20	BE0003N10.1
+Y62E10A.12	BE0003N10.1
+Y71G12B.14	BE0003N10.1
+Y73B6BL.3	BE0003N10.1
+Y73B6BL.32	BE0003N10.1
+ZC518.3	BE0003N10.1
+ZK593.7	BE0003N10.1
+ZK632.7	BE0003N10.1
+ZK858.1	BE0003N10.1
+C07H6.5	C04G2.6
+C14A4.4	C04G2.6
+C14A4.5	C04G2.6
+C26E6.3	C04G2.6
+C37H5.8	C04G2.6
+C49H3.5	C04G2.6
+F01G4.3	C04G2.6
+F18H3.3	C04G2.6
+F28F8.3	C04G2.6
+F29A7.6	C04G2.6
+F31D4.1	C04G2.6
+F31E3.4	C04G2.6
+F32A5.7	C04G2.6
+F37C12.13	C04G2.6
+F40F8.9	C04G2.6
+F43G6.9	C04G2.6
+F52G2.1	C04G2.6
+F57B9.2	C04G2.6
+F59C6.4	C04G2.6
+T10G3.6	C04G2.6
+T21B10.2	C04G2.6
+W08D2.7	C04G2.6
+Y106G6H.2	C04G2.6
+Y113G7A.9	C04G2.6
+Y22D7AL.5	C04G2.6
+Y39G8C.1	C04G2.6
+Y48A6B.5	C04G2.6
+Y48B6A.3	C04G2.6
+Y51H7C.7	C04G2.6
+Y56A3A.1	C04G2.6
+Y56A3A.20	C04G2.6
+Y62E10A.12	C04G2.6
+Y71G12B.14	C04G2.6
+Y73B6BL.3	C04G2.6
+Y73B6BL.32	C04G2.6
+ZC518.3	C04G2.6
+ZK593.7	C04G2.6
+ZK632.7	C04G2.6
+ZK858.1	C04G2.6
+C14A4.4	C07H6.5
+C14A4.5	C07H6.5
+C26E6.3	C07H6.5
+C37H5.8	C07H6.5
+C49H3.5	C07H6.5
+F01G4.3	C07H6.5
+F18H3.3	C07H6.5
+F28F8.3	C07H6.5
+F29A7.6	C07H6.5
+F31D4.1	C07H6.5
+F31E3.4	C07H6.5
+F32A5.7	C07H6.5
+F37C12.13	C07H6.5
+F40F8.9	C07H6.5
+F43G6.9	C07H6.5
+F52G2.1	C07H6.5
+F57B9.2	C07H6.5
+F59C6.4	C07H6.5
+T10G3.6	C07H6.5
+T21B10.2	C07H6.5
+W08D2.7	C07H6.5
+Y106G6H.2	C07H6.5
+Y113G7A.9	C07H6.5
+Y22D7AL.5	C07H6.5
+Y39G8C.1	C07H6.5
+Y48A6B.5	C07H6.5
+Y48B6A.3	C07H6.5
+Y51H7C.7	C07H6.5
+Y56A3A.1	C07H6.5
+Y56A3A.20	C07H6.5
+Y62E10A.12	C07H6.5
+Y71G12B.14	C07H6.5
+Y73B6BL.3	C07H6.5
+Y73B6BL.32	C07H6.5
+ZC518.3	C07H6.5
+ZK593.7	C07H6.5
+ZK632.7	C07H6.5
+ZK858.1	C07H6.5
+C14A4.5	C14A4.4
+C26E6.3	C14A4.4
+C37H5.8	C14A4.4
+C49H3.5	C14A4.4
+F01G4.3	C14A4.4
+F18H3.3	C14A4.4
+F28F8.3	C14A4.4
+F29A7.6	C14A4.4
+F31D4.1	C14A4.4
+F31E3.4	C14A4.4
+F32A5.7	C14A4.4
+F37C12.13	C14A4.4
+F40F8.9	C14A4.4
+F43G6.9	C14A4.4
+F52G2.1	C14A4.4
+F57B9.2	C14A4.4
+F59C6.4	C14A4.4
+T10G3.6	C14A4.4
+T21B10.2	C14A4.4
+W08D2.7	C14A4.4
+Y106G6H.2	C14A4.4
+Y113G7A.9	C14A4.4
+Y22D7AL.5	C14A4.4
+Y39G8C.1	C14A4.4
+Y48A6B.5	C14A4.4
+Y48B6A.3	C14A4.4
+Y51H7C.7	C14A4.4
+Y56A3A.1	C14A4.4
+Y56A3A.20	C14A4.4
+Y62E10A.12	C14A4.4
+Y71G12B.14	C14A4.4
+Y73B6BL.3	C14A4.4
+Y73B6BL.32	C14A4.4
+ZC518.3	C14A4.4
+ZK593.7	C14A4.4
+ZK632.7	C14A4.4
+ZK858.1	C14A4.4
+C26E6.3	C14A4.5
+C37H5.8	C14A4.5
+C49H3.5	C14A4.5
+F01G4.3	C14A4.5
+F18H3.3	C14A4.5
+F28F8.3	C14A4.5
+F29A7.6	C14A4.5
+F31D4.1	C14A4.5
+F31E3.4	C14A4.5
+F32A5.7	C14A4.5
+F37C12.13	C14A4.5
+F40F8.9	C14A4.5
+F43G6.9	C14A4.5
+F52G2.1	C14A4.5
+F57B9.2	C14A4.5
+F59C6.4	C14A4.5
+T10G3.6	C14A4.5
+T21B10.2	C14A4.5
+W08D2.7	C14A4.5
+Y106G6H.2	C14A4.5
+Y113G7A.9	C14A4.5
+Y22D7AL.5	C14A4.5
+Y39G8C.1	C14A4.5
+Y48A6B.5	C14A4.5
+Y48B6A.3	C14A4.5
+Y51H7C.7	C14A4.5
+Y56A3A.1	C14A4.5
+Y56A3A.20	C14A4.5
+Y62E10A.12	C14A4.5
+Y71G12B.14	C14A4.5
+Y73B6BL.3	C14A4.5
+Y73B6BL.32	C14A4.5
+ZC518.3	C14A4.5
+ZK593.7	C14A4.5
+ZK632.7	C14A4.5
+ZK858.1	C14A4.5
+C37H5.8	C26E6.3
+C49H3.5	C26E6.3
+F01G4.3	C26E6.3
+F18H3.3	C26E6.3
+F28F8.3	C26E6.3
+F29A7.6	C26E6.3
+F31D4.1	C26E6.3
+F31E3.4	C26E6.3
+F32A5.7	C26E6.3
+F37C12.13	C26E6.3
+F40F8.9	C26E6.3
+F43G6.9	C26E6.3
+F52G2.1	C26E6.3
+F57B9.2	C26E6.3
+F59C6.4	C26E6.3
+T10G3.6	C26E6.3
+T21B10.2	C26E6.3
+W08D2.7	C26E6.3
+Y106G6H.2	C26E6.3
+Y113G7A.9	C26E6.3
+Y22D7AL.5	C26E6.3
+Y39G8C.1	C26E6.3
+Y48A6B.5	C26E6.3
+Y48B6A.3	C26E6.3
+Y51H7C.7	C26E6.3
+Y56A3A.1	C26E6.3
+Y56A3A.20	C26E6.3
+Y62E10A.12	C26E6.3
+Y71G12B.14	C26E6.3
+Y73B6BL.3	C26E6.3
+Y73B6BL.32	C26E6.3
+ZC518.3	C26E6.3
+ZK593.7	C26E6.3
+ZK632.7	C26E6.3
+ZK858.1	C26E6.3
+C49H3.5	C37H5.8
+F01G4.3	C37H5.8
+F18H3.3	C37H5.8
+F28F8.3	C37H5.8
+F29A7.6	C37H5.8
+F31D4.1	C37H5.8
+F31E3.4	C37H5.8
+F32A5.7	C37H5.8
+F37C12.13	C37H5.8
+F40F8.9	C37H5.8
+F43G6.9	C37H5.8
+F52G2.1	C37H5.8
+F57B9.2	C37H5.8
+F59C6.4	C37H5.8
+T10G3.6	C37H5.8
+T21B10.2	C37H5.8
+W08D2.7	C37H5.8
+Y106G6H.2	C37H5.8
+Y113G7A.9	C37H5.8
+Y22D7AL.5	C37H5.8
+Y39G8C.1	C37H5.8
+Y48A6B.5	C37H5.8
+Y48B6A.3	C37H5.8
+Y51H7C.7	C37H5.8
+Y56A3A.1	C37H5.8
+Y56A3A.20	C37H5.8
+Y62E10A.12	C37H5.8
+Y71G12B.14	C37H5.8
+Y73B6BL.3	C37H5.8
+Y73B6BL.32	C37H5.8
+ZC518.3	C37H5.8
+ZK593.7	C37H5.8
+ZK632.7	C37H5.8
+ZK858.1	C37H5.8
+F01G4.3	C49H3.5
+F18H3.3	C49H3.5
+F28F8.3	C49H3.5
+F29A7.6	C49H3.5
+F31D4.1	C49H3.5
+F31E3.4	C49H3.5
+F32A5.7	C49H3.5
+F37C12.13	C49H3.5
+F40F8.9	C49H3.5
+F43G6.9	C49H3.5
+F52G2.1	C49H3.5
+F57B9.2	C49H3.5
+F59C6.4	C49H3.5
+T10G3.6	C49H3.5
+T21B10.2	C49H3.5
+W08D2.7	C49H3.5
+Y106G6H.2	C49H3.5
+Y113G7A.9	C49H3.5
+Y22D7AL.5	C49H3.5
+Y39G8C.1	C49H3.5
+Y48A6B.5	C49H3.5
+Y48B6A.3	C49H3.5
+Y51H7C.7	C49H3.5
+Y56A3A.1	C49H3.5
+Y56A3A.20	C49H3.5
+Y62E10A.12	C49H3.5
+Y71G12B.14	C49H3.5
+Y73B6BL.3	C49H3.5
+Y73B6BL.32	C49H3.5
+ZC518.3	C49H3.5
+ZK593.7	C49H3.5
+ZK632.7	C49H3.5
+ZK858.1	C49H3.5
+F18H3.3	F01G4.3
+F28F8.3	F01G4.3
+F29A7.6	F01G4.3
+F31D4.1	F01G4.3
+F31E3.4	F01G4.3
+F32A5.7	F01G4.3
+F37C12.13	F01G4.3
+F40F8.9	F01G4.3
+F43G6.9	F01G4.3
+F52G2.1	F01G4.3
+F57B9.2	F01G4.3
+F59C6.4	F01G4.3
+T10G3.6	F01G4.3
+T21B10.2	F01G4.3
+W08D2.7	F01G4.3
+Y106G6H.2	F01G4.3
+Y113G7A.9	F01G4.3
+Y22D7AL.5	F01G4.3
+Y39G8C.1	F01G4.3
+Y48A6B.5	F01G4.3
+Y48B6A.3	F01G4.3
+Y51H7C.7	F01G4.3
+Y56A3A.1	F01G4.3
+Y56A3A.20	F01G4.3
+Y62E10A.12	F01G4.3
+Y71G12B.14	F01G4.3
+Y73B6BL.3	F01G4.3
+Y73B6BL.32	F01G4.3
+ZC518.3	F01G4.3
+ZK593.7	F01G4.3
+ZK632.7	F01G4.3
+ZK858.1	F01G4.3
+F28F8.3	F18H3.3
+F29A7.6	F18H3.3
+F31D4.1	F18H3.3
+F31E3.4	F18H3.3
+F32A5.7	F18H3.3
+F37C12.13	F18H3.3
+F40F8.9	F18H3.3
+F43G6.9	F18H3.3
+F52G2.1	F18H3.3
+F57B9.2	F18H3.3
+F59C6.4	F18H3.3
+T10G3.6	F18H3.3
+T21B10.2	F18H3.3
+W08D2.7	F18H3.3
+Y113G7A.9	F18H3.3
+Y22D7AL.5	F18H3.3
+Y39G8C.1	F18H3.3
+Y48A6B.5	F18H3.3
+Y48B6A.3	F18H3.3
+Y51H7C.7	F18H3.3
+Y56A3A.1	F18H3.3
+Y56A3A.20	F18H3.3
+Y62E10A.12	F18H3.3
+Y71G12B.14	F18H3.3
+Y73B6BL.3	F18H3.3
+Y73B6BL.32	F18H3.3
+ZC518.3	F18H3.3
+ZK593.7	F18H3.3
+ZK632.7	F18H3.3
+ZK858.1	F18H3.3
+F29A7.6	F28F8.3
+F31D4.1	F28F8.3
+F31E3.4	F28F8.3
+F32A5.7	F28F8.3
+F37C12.13	F28F8.3
+F40F8.9	F28F8.3
+F43G6.9	F28F8.3
+F52G2.1	F28F8.3
+F57B9.2	F28F8.3
+F59C6.4	F28F8.3
+T10G3.6	F28F8.3
+T21B10.2	F28F8.3
+W08D2.7	F28F8.3
+Y106G6H.2	F28F8.3
+Y113G7A.9	F28F8.3
+Y22D7AL.5	F28F8.3
+Y39G8C.1	F28F8.3
+Y48A6B.5	F28F8.3
+Y48B6A.3	F28F8.3
+Y51H7C.7	F28F8.3
+Y56A3A.1	F28F8.3
+Y56A3A.20	F28F8.3
+Y62E10A.12	F28F8.3
+Y71G12B.14	F28F8.3
+Y73B6BL.3	F28F8.3
+Y73B6BL.32	F28F8.3
+ZC518.3	F28F8.3
+ZK593.7	F28F8.3
+ZK632.7	F28F8.3
+ZK858.1	F28F8.3
+F31D4.1	F29A7.6
+F31E3.4	F29A7.6
+F32A5.7	F29A7.6
+F37C12.13	F29A7.6
+F40F8.9	F29A7.6
+F43G6.9	F29A7.6
+F52G2.1	F29A7.6
+F57B9.2	F29A7.6
+F59C6.4	F29A7.6
+T10G3.6	F29A7.6
+T21B10.2	F29A7.6
+W08D2.7	F29A7.6
+Y106G6H.2	F29A7.6
+Y113G7A.9	F29A7.6
+Y22D7AL.5	F29A7.6
+Y39G8C.1	F29A7.6
+Y48A6B.5	F29A7.6
+Y48B6A.3	F29A7.6
+Y51H7C.7	F29A7.6
+Y56A3A.1	F29A7.6
+Y56A3A.20	F29A7.6
+Y62E10A.12	F29A7.6
+Y71G12B.14	F29A7.6
+Y73B6BL.3	F29A7.6
+Y73B6BL.32	F29A7.6
+ZC518.3	F29A7.6
+ZK593.7	F29A7.6
+ZK632.7	F29A7.6
+ZK858.1	F29A7.6
+F31E3.4	F31D4.1
+F32A5.7	F31D4.1
+F37C12.13	F31D4.1
+F40F8.9	F31D4.1
+F43G6.9	F31D4.1
+F52G2.1	F31D4.1
+F57B9.2	F31D4.1
+F59C6.4	F31D4.1
+T10G3.6	F31D4.1
+T21B10.2	F31D4.1
+W08D2.7	F31D4.1
+Y106G6H.2	F31D4.1
+Y113G7A.9	F31D4.1
+Y22D7AL.5	F31D4.1
+Y39G8C.1	F31D4.1
+Y48A6B.5	F31D4.1
+Y48B6A.3	F31D4.1
+Y51H7C.7	F31D4.1
+Y56A3A.1	F31D4.1
+Y56A3A.20	F31D4.1
+Y62E10A.12	F31D4.1
+Y71G12B.14	F31D4.1
+Y73B6BL.3	F31D4.1
+Y73B6BL.32	F31D4.1
+ZC518.3	F31D4.1
+ZK593.7	F31D4.1
+ZK632.7	F31D4.1
+ZK858.1	F31D4.1
+F32A5.7	F31E3.4
+F37C12.13	F31E3.4
+F40F8.9	F31E3.4
+F43G6.9	F31E3.4
+F52G2.1	F31E3.4
+F57B9.2	F31E3.4
+F59C6.4	F31E3.4
+T10G3.6	F31E3.4
+T21B10.2	F31E3.4
+W08D2.7	F31E3.4
+Y106G6H.2	F31E3.4
+Y113G7A.9	F31E3.4
+Y22D7AL.5	F31E3.4
+Y39G8C.1	F31E3.4
+Y48A6B.5	F31E3.4
+Y48B6A.3	F31E3.4
+Y51H7C.7	F31E3.4
+Y56A3A.1	F31E3.4
+Y56A3A.20	F31E3.4
+Y62E10A.12	F31E3.4
+Y71G12B.14	F31E3.4
+Y73B6BL.3	F31E3.4
+Y73B6BL.32	F31E3.4
+ZC518.3	F31E3.4
+ZK593.7	F31E3.4
+ZK632.7	F31E3.4
+ZK858.1	F31E3.4
+F37C12.13	F32A5.7
+F40F8.9	F32A5.7
+F43G6.9	F32A5.7
+F52G2.1	F32A5.7
+F57B9.2	F32A5.7
+F59C6.4	F32A5.7
+T10G3.6	F32A5.7
+T21B10.2	F32A5.7
+W08D2.7	F32A5.7
+Y106G6H.2	F32A5.7
+Y113G7A.9	F32A5.7
+Y22D7AL.5	F32A5.7
+Y39G8C.1	F32A5.7
+Y48A6B.5	F32A5.7
+Y48B6A.3	F32A5.7
+Y51H7C.7	F32A5.7
+Y56A3A.1	F32A5.7
+Y56A3A.20	F32A5.7
+Y62E10A.12	F32A5.7
+Y71G12B.14	F32A5.7
+Y73B6BL.3	F32A5.7
+Y73B6BL.32	F32A5.7
+ZC518.3	F32A5.7
+ZK593.7	F32A5.7
+ZK632.7	F32A5.7
+ZK858.1	F32A5.7
+F40F8.9	F37C12.13
+F43G6.9	F37C12.13
+F52G2.1	F37C12.13
+F57B9.2	F37C12.13
+F59C6.4	F37C12.13
+T10G3.6	F37C12.13
+T21B10.2	F37C12.13
+W08D2.7	F37C12.13
+Y106G6H.2	F37C12.13
+Y113G7A.9	F37C12.13
+Y22D7AL.5	F37C12.13
+Y39G8C.1	F37C12.13
+Y48A6B.5	F37C12.13
+Y48B6A.3	F37C12.13
+Y51H7C.7	F37C12.13
+Y56A3A.1	F37C12.13
+Y56A3A.20	F37C12.13
+Y62E10A.12	F37C12.13
+Y71G12B.14	F37C12.13
+Y73B6BL.3	F37C12.13
+Y73B6BL.32	F37C12.13
+ZC518.3	F37C12.13
+ZK593.7	F37C12.13
+ZK632.7	F37C12.13
+ZK858.1	F37C12.13
+F43G6.9	F40F8.9
+F52G2.1	F40F8.9
+F57B9.2	F40F8.9
+F59C6.4	F40F8.9
+T10G3.6	F40F8.9
+T21B10.2	F40F8.9
+W08D2.7	F40F8.9
+Y106G6H.2	F40F8.9
+Y113G7A.9	F40F8.9
+Y22D7AL.5	F40F8.9
+Y39G8C.1	F40F8.9
+Y48A6B.5	F40F8.9
+Y48B6A.3	F40F8.9
+Y51H7C.7	F40F8.9
+Y56A3A.1	F40F8.9
+Y56A3A.20	F40F8.9
+Y62E10A.12	F40F8.9
+Y71G12B.14	F40F8.9
+Y73B6BL.3	F40F8.9
+Y73B6BL.32	F40F8.9
+ZC518.3	F40F8.9
+ZK593.7	F40F8.9
+ZK632.7	F40F8.9
+ZK858.1	F40F8.9
+F52G2.1	F43G6.9
+F57B9.2	F43G6.9
+F59C6.4	F43G6.9
+T10G3.6	F43G6.9
+T21B10.2	F43G6.9
+W08D2.7	F43G6.9
+Y106G6H.2	F43G6.9
+Y113G7A.9	F43G6.9
+Y22D7AL.5	F43G6.9
+Y39G8C.1	F43G6.9
+Y48A6B.5	F43G6.9
+Y48B6A.3	F43G6.9
+Y51H7C.7	F43G6.9
+Y56A3A.1	F43G6.9
+Y56A3A.20	F43G6.9
+Y62E10A.12	F43G6.9
+Y71G12B.14	F43G6.9
+Y73B6BL.3	F43G6.9
+Y73B6BL.32	F43G6.9
+ZC518.3	F43G6.9
+ZK593.7	F43G6.9
+ZK632.7	F43G6.9
+ZK858.1	F43G6.9
+F57B9.2	F52G2.1
+F59C6.4	F52G2.1
+T10G3.6	F52G2.1
+T21B10.2	F52G2.1
+W08D2.7	F52G2.1
+Y106G6H.2	F52G2.1
+Y113G7A.9	F52G2.1
+Y22D7AL.5	F52G2.1
+Y39G8C.1	F52G2.1
+Y48A6B.5	F52G2.1
+Y48B6A.3	F52G2.1
+Y51H7C.7	F52G2.1
+Y56A3A.1	F52G2.1
+Y56A3A.20	F52G2.1
+Y62E10A.12	F52G2.1
+Y71G12B.14	F52G2.1
+Y73B6BL.3	F52G2.1
+Y73B6BL.32	F52G2.1
+ZC518.3	F52G2.1
+ZK593.7	F52G2.1
+ZK632.7	F52G2.1
+ZK858.1	F52G2.1
+F59C6.4	F57B9.2
+T10G3.6	F57B9.2
+T21B10.2	F57B9.2
+W08D2.7	F57B9.2
+Y106G6H.2	F57B9.2
+Y113G7A.9	F57B9.2
+Y22D7AL.5	F57B9.2
+Y39G8C.1	F57B9.2
+Y48A6B.5	F57B9.2
+Y48B6A.3	F57B9.2
+Y51H7C.7	F57B9.2
+Y56A3A.1	F57B9.2
+Y56A3A.20	F57B9.2
+Y62E10A.12	F57B9.2
+Y71G12B.14	F57B9.2
+Y73B6BL.3	F57B9.2
+Y73B6BL.32	F57B9.2
+ZC518.3	F57B9.2
+ZK593.7	F57B9.2
+ZK632.7	F57B9.2
+ZK858.1	F57B9.2
+T10G3.6	F59C6.4
+T21B10.2	F59C6.4
+W08D2.7	F59C6.4
+Y106G6H.2	F59C6.4
+Y113G7A.9	F59C6.4
+Y22D7AL.5	F59C6.4
+Y39G8C.1	F59C6.4
+Y48A6B.5	F59C6.4
+Y48B6A.3	F59C6.4
+Y51H7C.7	F59C6.4
+Y56A3A.1	F59C6.4
+Y56A3A.20	F59C6.4
+Y62E10A.12	F59C6.4
+Y71G12B.14	F59C6.4
+Y73B6BL.3	F59C6.4
+Y73B6BL.32	F59C6.4
+ZC518.3	F59C6.4
+ZK593.7	F59C6.4
+ZK632.7	F59C6.4
+ZK858.1	F59C6.4
+T21B10.2	T10G3.6
+W08D2.7	T10G3.6
+Y106G6H.2	T10G3.6
+Y113G7A.9	T10G3.6
+Y22D7AL.5	T10G3.6
+Y39G8C.1	T10G3.6
+Y48A6B.5	T10G3.6
+Y48B6A.3	T10G3.6
+Y51H7C.7	T10G3.6
+Y56A3A.1	T10G3.6
+Y56A3A.20	T10G3.6
+Y62E10A.12	T10G3.6
+Y71G12B.14	T10G3.6
+Y73B6BL.3	T10G3.6
+Y73B6BL.32	T10G3.6
+ZC518.3	T10G3.6
+ZK593.7	T10G3.6
+ZK632.7	T10G3.6
+ZK858.1	T10G3.6
+W08D2.7	T21B10.2
+Y106G6H.2	T21B10.2
+Y113G7A.9	T21B10.2
+Y22D7AL.5	T21B10.2
+Y39G8C.1	T21B10.2
+Y48A6B.5	T21B10.2
+Y48B6A.3	T21B10.2
+Y51H7C.7	T21B10.2
+Y56A3A.1	T21B10.2
+Y56A3A.20	T21B10.2
+Y62E10A.12	T21B10.2
+Y71G12B.14	T21B10.2
+Y73B6BL.3	T21B10.2
+Y73B6BL.32	T21B10.2
+ZC518.3	T21B10.2
+ZK593.7	T21B10.2
+ZK632.7	T21B10.2
+ZK858.1	T21B10.2
+Y106G6H.2	W08D2.7
+Y113G7A.9	W08D2.7
+Y22D7AL.5	W08D2.7
+Y39G8C.1	W08D2.7
+Y48A6B.5	W08D2.7
+Y48B6A.3	W08D2.7
+Y51H7C.7	W08D2.7
+Y56A3A.1	W08D2.7
+Y56A3A.20	W08D2.7
+Y62E10A.12	W08D2.7
+Y71G12B.14	W08D2.7
+Y73B6BL.3	W08D2.7
+Y73B6BL.32	W08D2.7
+ZC518.3	W08D2.7
+ZK593.7	W08D2.7
+ZK632.7	W08D2.7
+ZK858.1	W08D2.7
+Y113G7A.9	Y106G6H.2
+Y22D7AL.5	Y106G6H.2
+Y39G8C.1	Y106G6H.2
+Y48A6B.5	Y106G6H.2
+Y48B6A.3	Y106G6H.2
+Y51H7C.7	Y106G6H.2
+Y56A3A.1	Y106G6H.2
+Y56A3A.20	Y106G6H.2
+Y62E10A.12	Y106G6H.2
+Y71G12B.14	Y106G6H.2
+Y73B6BL.3	Y106G6H.2
+Y73B6BL.32	Y106G6H.2
+ZC518.3	Y106G6H.2
+ZK593.7	Y106G6H.2
+ZK632.7	Y106G6H.2
+ZK858.1	Y106G6H.2
+Y22D7AL.5	Y113G7A.9
+Y39G8C.1	Y113G7A.9
+Y48A6B.5	Y113G7A.9
+Y48B6A.3	Y113G7A.9
+Y51H7C.7	Y113G7A.9
+Y56A3A.1	Y113G7A.9
+Y56A3A.20	Y113G7A.9
+Y62E10A.12	Y113G7A.9
+Y71G12B.14	Y113G7A.9
+Y73B6BL.3	Y113G7A.9
+Y73B6BL.32	Y113G7A.9
+ZC518.3	Y113G7A.9
+ZK593.7	Y113G7A.9
+ZK632.7	Y113G7A.9
+ZK858.1	Y113G7A.9
+Y39G8C.1	Y22D7AL.5
+Y48A6B.5	Y22D7AL.5
+Y48B6A.3	Y22D7AL.5
+Y51H7C.7	Y22D7AL.5
+Y56A3A.1	Y22D7AL.5
+Y56A3A.20	Y22D7AL.5
+Y62E10A.12	Y22D7AL.5
+Y71G12B.14	Y22D7AL.5
+Y73B6BL.3	Y22D7AL.5
+Y73B6BL.32	Y22D7AL.5
+ZC518.3	Y22D7AL.5
+ZK593.7	Y22D7AL.5
+ZK632.7	Y22D7AL.5
+ZK858.1	Y22D7AL.5
+Y48A6B.5	Y39G8C.1
+Y51H7C.7	Y39G8C.1
+Y56A3A.1	Y39G8C.1
+Y56A3A.20	Y39G8C.1
+Y62E10A.12	Y39G8C.1
+Y71G12B.14	Y39G8C.1
+Y73B6BL.3	Y39G8C.1
+Y73B6BL.32	Y39G8C.1
+ZC518.3	Y39G8C.1
+ZK593.7	Y39G8C.1
+ZK632.7	Y39G8C.1
+ZK858.1	Y39G8C.1
+Y48B6A.3	Y48A6B.5
+Y51H7C.7	Y48A6B.5
+Y56A3A.1	Y48A6B.5
+Y56A3A.20	Y48A6B.5
+Y62E10A.12	Y48A6B.5
+Y71G12B.14	Y48A6B.5
+Y73B6BL.3	Y48A6B.5
+Y73B6BL.32	Y48A6B.5
+ZC518.3	Y48A6B.5
+ZK593.7	Y48A6B.5
+ZK632.7	Y48A6B.5
+ZK858.1	Y48A6B.5
+Y51H7C.7	Y48B6A.3
+Y56A3A.1	Y48B6A.3
+Y56A3A.20	Y48B6A.3
+Y62E10A.12	Y48B6A.3
+Y71G12B.14	Y48B6A.3
+Y73B6BL.3	Y48B6A.3
+Y73B6BL.32	Y48B6A.3
+ZC518.3	Y48B6A.3
+ZK593.7	Y48B6A.3
+ZK632.7	Y48B6A.3
+ZK858.1	Y48B6A.3
+Y56A3A.1	Y51H7C.7
+Y56A3A.20	Y51H7C.7
+Y62E10A.12	Y51H7C.7
+Y71G12B.14	Y51H7C.7
+Y73B6BL.3	Y51H7C.7
+Y73B6BL.32	Y51H7C.7
+ZC518.3	Y51H7C.7
+ZK593.7	Y51H7C.7
+ZK632.7	Y51H7C.7
+ZK858.1	Y51H7C.7
+Y56A3A.20	Y56A3A.1
+Y62E10A.12	Y56A3A.1
+Y71G12B.14	Y56A3A.1
+Y73B6BL.3	Y56A3A.1
+Y73B6BL.32	Y56A3A.1
+ZC518.3	Y56A3A.1
+ZK593.7	Y56A3A.1
+ZK632.7	Y56A3A.1
+ZK858.1	Y56A3A.1
+Y62E10A.12	Y56A3A.20
+Y71G12B.14	Y56A3A.20
+Y73B6BL.3	Y56A3A.20
+Y73B6BL.32	Y56A3A.20
+ZC518.3	Y56A3A.20
+ZK593.7	Y56A3A.20
+ZK632.7	Y56A3A.20
+ZK858.1	Y56A3A.20
+Y71G12B.14	Y62E10A.12
+Y73B6BL.3	Y62E10A.12
+Y73B6BL.32	Y62E10A.12
+ZC518.3	Y62E10A.12
+ZK593.7	Y62E10A.12
+ZK632.7	Y62E10A.12
+ZK858.1	Y62E10A.12
+Y73B6BL.3	Y71G12B.14
+Y73B6BL.32	Y71G12B.14
+ZC518.3	Y71G12B.14
+ZK593.7	Y71G12B.14
+ZK632.7	Y71G12B.14
+ZK858.1	Y71G12B.14
+Y73B6BL.32	Y73B6BL.3
+ZC518.3	Y73B6BL.3
+ZK593.7	Y73B6BL.3
+ZK632.7	Y73B6BL.3
+ZK858.1	Y73B6BL.3
+ZC518.3	Y73B6BL.32
+ZK593.7	Y73B6BL.32
+ZK632.7	Y73B6BL.32
+ZK858.1	Y73B6BL.32
+ZK593.7	ZC518.3
+ZK632.7	ZC518.3
+ZK858.1	ZC518.3
+ZK632.7	ZK593.7
+ZK858.1	ZK593.7
+ZK858.1	ZK632.7
+C01F1.1	B0336.13
+C14A4.10	B0336.13
+C27H5.3	B0336.13
+E02H1.6	B0336.13
+F30F8.8	B0336.13
+F39H11.2	B0336.13
+F43D9.5	B0336.13
+F48D6.1	B0336.13
+F53G2.7	B0336.13
+F54D5.11	B0336.13
+F54F7.1	B0336.13
+K03B4.3	B0336.13
+K10D3.3	B0336.13
+K11D12.2	B0336.13
+R02D3.3	B0336.13
+R119.6	B0336.13
+T12D8.7	B0336.13
+T16H12.4	B0336.13
+T20B12.2	B0336.13
+W03F9.5	B0336.13
+W04A8.7	B0336.13
+W09B6.2	B0336.13
+Y111B2A.13	B0336.13
+Y111B2A.16	B0336.13
+Y37E11B.4	B0336.13
+Y39B6A.36	B0336.13
+Y39G10AL.3	B0336.13
+Y49F6B.1	B0336.13
+Y50D7A.2	B0336.13
+Y55B1AL.2	B0336.13
+Y66D12A.15	B0336.13
+Y73F8A.24	B0336.13
+ZK1128.4	B0336.13
+ZK1320.12	B0336.13
+ZK550.4	B0336.13
+C14A4.10	C01F1.1
+C27H5.3	C01F1.1
+E02H1.6	C01F1.1
+F30F8.8	C01F1.1
+F39H11.2	C01F1.1
+F43D9.5	C01F1.1
+F48D6.1	C01F1.1
+F53G2.7	C01F1.1
+F54D5.11	C01F1.1
+F54F7.1	C01F1.1
+K03B4.3	C01F1.1
+K10D3.3	C01F1.1
+K11D12.2	C01F1.1
+R02D3.3	C01F1.1
+R119.6	C01F1.1
+T12D8.7	C01F1.1
+T16H12.4	C01F1.1
+T20B12.2	C01F1.1
+W03F9.5	C01F1.1
+W04A8.7	C01F1.1
+W09B6.2	C01F1.1
+Y111B2A.13	C01F1.1
+Y111B2A.16	C01F1.1
+Y37E11B.4	C01F1.1
+Y39B6A.36	C01F1.1
+Y39G10AL.3	C01F1.1
+Y49F6B.1	C01F1.1
+Y50D7A.2	C01F1.1
+Y55B1AL.2	C01F1.1
+Y66D12A.15	C01F1.1
+Y73F8A.24	C01F1.1
+ZK1128.4	C01F1.1
+ZK1320.12	C01F1.1
+ZK550.4	C01F1.1
+C27H5.3	C14A4.10
+E02H1.6	C14A4.10
+F30F8.8	C14A4.10
+F39H11.2	C14A4.10
+F43D9.5	C14A4.10
+F48D6.1	C14A4.10
+F53G2.7	C14A4.10
+F54D5.11	C14A4.10
+F54F7.1	C14A4.10
+K03B4.3	C14A4.10
+K10D3.3	C14A4.10
+K11D12.2	C14A4.10
+R02D3.3	C14A4.10
+R119.6	C14A4.10
+T12D8.7	C14A4.10
+T16H12.4	C14A4.10
+T20B12.2	C14A4.10
+W03F9.5	C14A4.10
+W04A8.7	C14A4.10
+W09B6.2	C14A4.10
+Y111B2A.13	C14A4.10
+Y111B2A.16	C14A4.10
+Y37E11B.4	C14A4.10
+Y39B6A.36	C14A4.10
+Y39G10AL.3	C14A4.10
+Y49F6B.1	C14A4.10
+Y50D7A.2	C14A4.10
+Y55B1AL.2	C14A4.10
+Y66D12A.15	C14A4.10
+Y73F8A.24	C14A4.10
+ZK1128.4	C14A4.10
+ZK1320.12	C14A4.10
+ZK550.4	C14A4.10
+E02H1.6	C27H5.3
+F30F8.8	C27H5.3
+F39H11.2	C27H5.3
+F43D9.5	C27H5.3
+F48D6.1	C27H5.3
+F53G2.7	C27H5.3
+F54D5.11	C27H5.3
+F54F7.1	C27H5.3
+K03B4.3	C27H5.3
+K10D3.3	C27H5.3
+K11D12.2	C27H5.3
+R02D3.3	C27H5.3
+R119.6	C27H5.3
+T12D8.7	C27H5.3
+T16H12.4	C27H5.3
+T20B12.2	C27H5.3
+W03F9.5	C27H5.3
+W04A8.7	C27H5.3
+W09B6.2	C27H5.3
+Y111B2A.13	C27H5.3
+Y111B2A.16	C27H5.3
+Y37E11B.4	C27H5.3
+Y39B6A.36	C27H5.3
+Y39G10AL.3	C27H5.3
+Y49F6B.1	C27H5.3
+Y50D7A.2	C27H5.3
+Y55B1AL.2	C27H5.3
+Y66D12A.15	C27H5.3
+Y73F8A.24	C27H5.3
+ZK1128.4	C27H5.3
+ZK1320.12	C27H5.3
+ZK550.4	C27H5.3
+F30F8.8	E02H1.6
+F39H11.2	E02H1.6
+F43D9.5	E02H1.6
+F48D6.1	E02H1.6
+F53G2.7	E02H1.6
+F54D5.11	E02H1.6
+F54F7.1	E02H1.6
+K03B4.3	E02H1.6
+K10D3.3	E02H1.6
+K11D12.2	E02H1.6
+R02D3.3	E02H1.6
+R119.6	E02H1.6
+T12D8.7	E02H1.6
+T16H12.4	E02H1.6
+T20B12.2	E02H1.6
+W03F9.5	E02H1.6
+W04A8.7	E02H1.6
+W09B6.2	E02H1.6
+Y111B2A.13	E02H1.6
+Y111B2A.16	E02H1.6
+Y37E11B.4	E02H1.6
+Y39B6A.36	E02H1.6
+Y39G10AL.3	E02H1.6
+Y49F6B.1	E02H1.6
+Y50D7A.2	E02H1.6
+Y55B1AL.2	E02H1.6
+Y66D12A.15	E02H1.6
+Y73F8A.24	E02H1.6
+ZK1128.4	E02H1.6
+ZK1320.12	E02H1.6
+ZK550.4	E02H1.6
+F39H11.2	F30F8.8
+F43D9.5	F30F8.8
+F48D6.1	F30F8.8
+F53G2.7	F30F8.8
+F54D5.11	F30F8.8
+F54F7.1	F30F8.8
+K03B4.3	F30F8.8
+K10D3.3	F30F8.8
+K11D12.2	F30F8.8
+R02D3.3	F30F8.8
+R119.6	F30F8.8
+T12D8.7	F30F8.8
+T16H12.4	F30F8.8
+T20B12.2	F30F8.8
+W03F9.5	F30F8.8
+W04A8.7	F30F8.8
+W09B6.2	F30F8.8
+Y111B2A.13	F30F8.8
+Y111B2A.16	F30F8.8
+Y37E11B.4	F30F8.8
+Y39B6A.36	F30F8.8
+Y39G10AL.3	F30F8.8
+Y49F6B.1	F30F8.8
+Y50D7A.2	F30F8.8
+Y55B1AL.2	F30F8.8
+Y66D12A.15	F30F8.8
+Y73F8A.24	F30F8.8
+ZK1128.4	F30F8.8
+ZK1320.12	F30F8.8
+ZK550.4	F30F8.8
+F43D9.5	F39H11.2
+F48D6.1	F39H11.2
+F53G2.7	F39H11.2
+F54D5.11	F39H11.2
+F54F7.1	F39H11.2
+K03B4.3	F39H11.2
+K10D3.3	F39H11.2
+K11D12.2	F39H11.2
+R02D3.3	F39H11.2
+R119.6	F39H11.2
+T12D8.7	F39H11.2
+T16H12.4	F39H11.2
+T20B12.2	F39H11.2
+W03F9.5	F39H11.2
+W04A8.7	F39H11.2
+W09B6.2	F39H11.2
+Y111B2A.13	F39H11.2
+Y111B2A.16	F39H11.2
+Y37E11B.4	F39H11.2
+Y39B6A.36	F39H11.2
+Y39G10AL.3	F39H11.2
+Y49F6B.1	F39H11.2
+Y50D7A.2	F39H11.2
+Y55B1AL.2	F39H11.2
+Y66D12A.15	F39H11.2
+Y73F8A.24	F39H11.2
+ZK1128.4	F39H11.2
+ZK1320.12	F39H11.2
+ZK550.4	F39H11.2
+F48D6.1	F43D9.5
+F53G2.7	F43D9.5
+F54D5.11	F43D9.5
+F54F7.1	F43D9.5
+K03B4.3	F43D9.5
+K10D3.3	F43D9.5
+K11D12.2	F43D9.5
+R02D3.3	F43D9.5
+R119.6	F43D9.5
+T12D8.7	F43D9.5
+T16H12.4	F43D9.5
+T20B12.2	F43D9.5
+W03F9.5	F43D9.5
+W04A8.7	F43D9.5
+W09B6.2	F43D9.5
+Y111B2A.13	F43D9.5
+Y111B2A.16	F43D9.5
+Y37E11B.4	F43D9.5
+Y39B6A.36	F43D9.5
+Y39G10AL.3	F43D9.5
+Y49F6B.1	F43D9.5
+Y50D7A.2	F43D9.5
+Y55B1AL.2	F43D9.5
+Y66D12A.15	F43D9.5
+Y73F8A.24	F43D9.5
+ZK1128.4	F43D9.5
+ZK1320.12	F43D9.5
+ZK550.4	F43D9.5
+F53G2.7	F48D6.1
+F54D5.11	F48D6.1
+F54F7.1	F48D6.1
+K03B4.3	F48D6.1
+K10D3.3	F48D6.1
+K11D12.2	F48D6.1
+R02D3.3	F48D6.1
+R119.6	F48D6.1
+T12D8.7	F48D6.1
+T16H12.4	F48D6.1
+T20B12.2	F48D6.1
+W03F9.5	F48D6.1
+W04A8.7	F48D6.1
+W09B6.2	F48D6.1
+Y111B2A.13	F48D6.1
+Y111B2A.16	F48D6.1
+Y37E11B.4	F48D6.1
+Y39B6A.36	F48D6.1
+Y39G10AL.3	F48D6.1
+Y49F6B.1	F48D6.1
+Y50D7A.2	F48D6.1
+Y55B1AL.2	F48D6.1
+Y66D12A.15	F48D6.1
+Y73F8A.24	F48D6.1
+ZK1128.4	F48D6.1
+ZK1320.12	F48D6.1
+ZK550.4	F48D6.1
+F54D5.11	F53G2.7
+F54F7.1	F53G2.7
+K03B4.3	F53G2.7
+K10D3.3	F53G2.7
+K11D12.2	F53G2.7
+R02D3.3	F53G2.7
+R119.6	F53G2.7
+T12D8.7	F53G2.7
+T16H12.4	F53G2.7
+T20B12.2	F53G2.7
+W03F9.5	F53G2.7
+W04A8.7	F53G2.7
+W09B6.2	F53G2.7
+Y111B2A.13	F53G2.7
+Y111B2A.16	F53G2.7
+Y37E11B.4	F53G2.7
+Y39B6A.36	F53G2.7
+Y39G10AL.3	F53G2.7
+Y49F6B.1	F53G2.7
+Y50D7A.2	F53G2.7
+Y55B1AL.2	F53G2.7
+Y66D12A.15	F53G2.7
+Y73F8A.24	F53G2.7
+ZK1128.4	F53G2.7
+ZK1320.12	F53G2.7
+ZK550.4	F53G2.7
+F54F7.1	F54D5.11
+K03B4.3	F54D5.11
+K10D3.3	F54D5.11
+K11D12.2	F54D5.11
+R02D3.3	F54D5.11
+R119.6	F54D5.11
+T12D8.7	F54D5.11
+T16H12.4	F54D5.11
+T20B12.2	F54D5.11
+W03F9.5	F54D5.11
+W04A8.7	F54D5.11
+W09B6.2	F54D5.11
+Y111B2A.13	F54D5.11
+Y111B2A.16	F54D5.11
+Y37E11B.4	F54D5.11
+Y39B6A.36	F54D5.11
+Y39G10AL.3	F54D5.11
+Y49F6B.1	F54D5.11
+Y50D7A.2	F54D5.11
+Y55B1AL.2	F54D5.11
+Y66D12A.15	F54D5.11
+Y73F8A.24	F54D5.11
+ZK1128.4	F54D5.11
+ZK1320.12	F54D5.11
+K03B4.3	F54F7.1
+K10D3.3	F54F7.1
+K11D12.2	F54F7.1
+R02D3.3	F54F7.1
+R119.6	F54F7.1
+T12D8.7	F54F7.1
+T16H12.4	F54F7.1
+T20B12.2	F54F7.1
+W03F9.5	F54F7.1
+W04A8.7	F54F7.1
+W09B6.2	F54F7.1
+Y111B2A.13	F54F7.1
+Y111B2A.16	F54F7.1
+Y37E11B.4	F54F7.1
+Y39B6A.36	F54F7.1
+Y39G10AL.3	F54F7.1
+Y49F6B.1	F54F7.1
+Y50D7A.2	F54F7.1
+Y55B1AL.2	F54F7.1
+Y66D12A.15	F54F7.1
+Y73F8A.24	F54F7.1
+ZK1128.4	F54F7.1
+ZK1320.12	F54F7.1
+ZK550.4	F54F7.1
+K10D3.3	K03B4.3
+K11D12.2	K03B4.3
+R02D3.3	K03B4.3
+R119.6	K03B4.3
+T12D8.7	K03B4.3
+T16H12.4	K03B4.3
+T20B12.2	K03B4.3
+W03F9.5	K03B4.3
+W04A8.7	K03B4.3
+W09B6.2	K03B4.3
+Y111B2A.13	K03B4.3
+Y111B2A.16	K03B4.3
+Y37E11B.4	K03B4.3
+Y39B6A.36	K03B4.3
+Y39G10AL.3	K03B4.3
+Y49F6B.1	K03B4.3
+Y50D7A.2	K03B4.3
+Y55B1AL.2	K03B4.3
+Y66D12A.15	K03B4.3
+Y73F8A.24	K03B4.3
+ZK1128.4	K03B4.3
+ZK1320.12	K03B4.3
+ZK550.4	K03B4.3
+K11D12.2	K10D3.3
+R02D3.3	K10D3.3
+R119.6	K10D3.3
+T12D8.7	K10D3.3
+T16H12.4	K10D3.3
+T20B12.2	K10D3.3
+W03F9.5	K10D3.3
+W04A8.7	K10D3.3
+W09B6.2	K10D3.3
+Y111B2A.13	K10D3.3
+Y111B2A.16	K10D3.3
+Y37E11B.4	K10D3.3
+Y39B6A.36	K10D3.3
+Y39G10AL.3	K10D3.3
+Y49F6B.1	K10D3.3
+Y50D7A.2	K10D3.3
+Y55B1AL.2	K10D3.3
+Y66D12A.15	K10D3.3
+Y73F8A.24	K10D3.3
+ZK1128.4	K10D3.3
+ZK1320.12	K10D3.3
+ZK550.4	K10D3.3
+R02D3.3	K11D12.2
+R119.6	K11D12.2
+T12D8.7	K11D12.2
+T16H12.4	K11D12.2
+T20B12.2	K11D12.2
+W03F9.5	K11D12.2
+W04A8.7	K11D12.2
+W09B6.2	K11D12.2
+Y111B2A.13	K11D12.2
+Y111B2A.16	K11D12.2
+Y37E11B.4	K11D12.2
+Y39B6A.36	K11D12.2
+Y39G10AL.3	K11D12.2
+Y49F6B.1	K11D12.2
+Y50D7A.2	K11D12.2
+Y55B1AL.2	K11D12.2
+Y66D12A.15	K11D12.2
+Y73F8A.24	K11D12.2
+ZK1128.4	K11D12.2
+ZK1320.12	K11D12.2
+ZK550.4	K11D12.2
+R119.6	R02D3.3
+T12D8.7	R02D3.3
+T16H12.4	R02D3.3
+T20B12.2	R02D3.3
+W03F9.5	R02D3.3
+W04A8.7	R02D3.3
+W09B6.2	R02D3.3
+Y111B2A.13	R02D3.3
+Y111B2A.16	R02D3.3
+Y37E11B.4	R02D3.3
+Y39B6A.36	R02D3.3
+Y39G10AL.3	R02D3.3
+Y49F6B.1	R02D3.3
+Y50D7A.2	R02D3.3
+Y55B1AL.2	R02D3.3
+Y66D12A.15	R02D3.3
+Y73F8A.24	R02D3.3
+ZK1128.4	R02D3.3
+ZK1320.12	R02D3.3
+ZK550.4	R02D3.3
+T12D8.7	R119.6
+T16H12.4	R119.6
+T20B12.2	R119.6
+W03F9.5	R119.6
+W04A8.7	R119.6
+W09B6.2	R119.6
+Y111B2A.13	R119.6
+Y111B2A.16	R119.6
+Y37E11B.4	R119.6
+Y39B6A.36	R119.6
+Y39G10AL.3	R119.6
+Y49F6B.1	R119.6
+Y50D7A.2	R119.6
+Y55B1AL.2	R119.6
+Y66D12A.15	R119.6
+Y73F8A.24	R119.6
+ZK1128.4	R119.6
+ZK1320.12	R119.6
+ZK550.4	R119.6
+T16H12.4	T12D8.7
+T20B12.2	T12D8.7
+W03F9.5	T12D8.7
+W04A8.7	T12D8.7
+W09B6.2	T12D8.7
+Y111B2A.13	T12D8.7
+Y111B2A.16	T12D8.7
+Y37E11B.4	T12D8.7
+Y39B6A.36	T12D8.7
+Y39G10AL.3	T12D8.7
+Y49F6B.1	T12D8.7
+Y50D7A.2	T12D8.7
+Y55B1AL.2	T12D8.7
+Y66D12A.15	T12D8.7
+Y73F8A.24	T12D8.7
+ZK1128.4	T12D8.7
+ZK1320.12	T12D8.7
+ZK550.4	T12D8.7
+T20B12.2	T16H12.4
+W03F9.5	T16H12.4
+W04A8.7	T16H12.4
+W09B6.2	T16H12.4
+Y111B2A.13	T16H12.4
+Y111B2A.16	T16H12.4
+Y37E11B.4	T16H12.4
+Y39B6A.36	T16H12.4
+Y39G10AL.3	T16H12.4
+Y49F6B.1	T16H12.4
+Y50D7A.2	T16H12.4
+Y55B1AL.2	T16H12.4
+Y66D12A.15	T16H12.4
+Y73F8A.24	T16H12.4
+ZK1128.4	T16H12.4
+ZK1320.12	T16H12.4
+ZK550.4	T16H12.4
+W03F9.5	T20B12.2
+W04A8.7	T20B12.2
+W09B6.2	T20B12.2
+Y111B2A.13	T20B12.2
+Y111B2A.16	T20B12.2
+Y37E11B.4	T20B12.2
+Y39B6A.36	T20B12.2
+Y39G10AL.3	T20B12.2
+Y49F6B.1	T20B12.2
+Y50D7A.2	T20B12.2
+Y55B1AL.2	T20B12.2
+Y66D12A.15	T20B12.2
+Y73F8A.24	T20B12.2
+ZK1128.4	T20B12.2
+ZK1320.12	T20B12.2
+ZK550.4	T20B12.2
+W04A8.7	W03F9.5
+W09B6.2	W03F9.5
+Y111B2A.13	W03F9.5
+Y111B2A.16	W03F9.5
+Y37E11B.4	W03F9.5
+Y39B6A.36	W03F9.5
+Y39G10AL.3	W03F9.5
+Y49F6B.1	W03F9.5
+Y50D7A.2	W03F9.5
+Y55B1AL.2	W03F9.5
+Y66D12A.15	W03F9.5
+Y73F8A.24	W03F9.5
+ZK1128.4	W03F9.5
+ZK1320.12	W03F9.5
+ZK550.4	W03F9.5
+W09B6.2	W04A8.7
+Y111B2A.13	W04A8.7
+Y111B2A.16	W04A8.7
+Y37E11B.4	W04A8.7
+Y39B6A.36	W04A8.7
+Y39G10AL.3	W04A8.7
+Y49F6B.1	W04A8.7
+Y50D7A.2	W04A8.7
+Y55B1AL.2	W04A8.7
+Y66D12A.15	W04A8.7
+Y73F8A.24	W04A8.7
+ZK1128.4	W04A8.7
+ZK1320.12	W04A8.7
+ZK550.4	W04A8.7
+Y111B2A.13	W09B6.2
+Y111B2A.16	W09B6.2
+Y37E11B.4	W09B6.2
+Y39B6A.36	W09B6.2
+Y39G10AL.3	W09B6.2
+Y49F6B.1	W09B6.2
+Y50D7A.2	W09B6.2
+Y55B1AL.2	W09B6.2
+Y66D12A.15	W09B6.2
+Y73F8A.24	W09B6.2
+ZK1128.4	W09B6.2
+ZK1320.12	W09B6.2
+ZK550.4	W09B6.2
+Y111B2A.16	Y111B2A.13
+Y37E11B.4	Y111B2A.13
+Y39B6A.36	Y111B2A.13
+Y39G10AL.3	Y111B2A.13
+Y49F6B.1	Y111B2A.13
+Y50D7A.2	Y111B2A.13
+Y55B1AL.2	Y111B2A.13
+Y66D12A.15	Y111B2A.13
+Y73F8A.24	Y111B2A.13
+ZK1128.4	Y111B2A.13
+ZK1320.12	Y111B2A.13
+ZK550.4	Y111B2A.13
+Y37E11B.4	Y111B2A.16
+Y39B6A.36	Y111B2A.16
+Y39G10AL.3	Y111B2A.16
+Y49F6B.1	Y111B2A.16
+Y50D7A.2	Y111B2A.16
+Y55B1AL.2	Y111B2A.16
+Y66D12A.15	Y111B2A.16
+Y73F8A.24	Y111B2A.16
+ZK1128.4	Y111B2A.16
+ZK1320.12	Y111B2A.16
+ZK550.4	Y111B2A.16
+Y39B6A.36	Y37E11B.4
+Y39G10AL.3	Y37E11B.4
+Y49F6B.1	Y37E11B.4
+Y50D7A.2	Y37E11B.4
+Y55B1AL.2	Y37E11B.4
+Y66D12A.15	Y37E11B.4
+Y73F8A.24	Y37E11B.4
+ZK1128.4	Y37E11B.4
+ZK1320.12	Y37E11B.4
+ZK550.4	Y37E11B.4
+Y39G10AL.3	Y39B6A.36
+Y49F6B.1	Y39B6A.36
+Y50D7A.2	Y39B6A.36
+Y55B1AL.2	Y39B6A.36
+Y66D12A.15	Y39B6A.36
+Y73F8A.24	Y39B6A.36
+ZK1128.4	Y39B6A.36
+ZK1320.12	Y39B6A.36
+ZK550.4	Y39B6A.36
+Y49F6B.1	Y39G10AL.3
+Y50D7A.2	Y39G10AL.3
+Y55B1AL.2	Y39G10AL.3
+Y66D12A.15	Y39G10AL.3
+Y73F8A.24	Y39G10AL.3
+ZK1128.4	Y39G10AL.3
+ZK1320.12	Y39G10AL.3
+ZK550.4	Y39G10AL.3
+Y50D7A.2	Y49F6B.1
+Y55B1AL.2	Y49F6B.1
+Y66D12A.15	Y49F6B.1
+Y73F8A.24	Y49F6B.1
+ZK1128.4	Y49F6B.1
+ZK1320.12	Y49F6B.1
+ZK550.4	Y49F6B.1
+Y55B1AL.2	Y50D7A.2
+Y66D12A.15	Y50D7A.2
+Y73F8A.24	Y50D7A.2
+ZK1128.4	Y50D7A.2
+ZK1320.12	Y50D7A.2
+ZK550.4	Y50D7A.2
+Y66D12A.15	Y55B1AL.2
+Y73F8A.24	Y55B1AL.2
+ZK1128.4	Y55B1AL.2
+ZK1320.12	Y55B1AL.2
+ZK550.4	Y55B1AL.2
+Y73F8A.24	Y66D12A.15
+ZK1128.4	Y66D12A.15
+ZK1320.12	Y66D12A.15
+ZK550.4	Y66D12A.15
+ZK1128.4	Y73F8A.24
+ZK1320.12	Y73F8A.24
+ZK550.4	Y73F8A.24
+ZK1320.12	ZK1128.4
+ZK550.4	ZK1128.4
+ZK550.4	ZK1320.12
+C25D7.6	C04F12.9
+C29A12.3	C04F12.9
+C39E9.13	C04F12.9
+C54G10.2	C04F12.9
+F08B4.5	C04F12.9
+F10C2.4	C04F12.9
+F12F6.7	C04F12.9
+F18A1.5	C04F12.9
+F21D5.6	C04F12.9
+F31E3.3	C04F12.9
+F32D1.10	C04F12.9
+F33H2.5	C04F12.9
+F43G6.1	C04F12.9
+F44B9.8	C04F12.9
+F58A4.4	C04F12.9
+F58F6.4	C04F12.9
+F59A3.6	C04F12.9
+F59A6.6	C04F12.9
+M04F3.1	C04F12.9
+R01H10.1	C04F12.9
+R04F11.3	C04F12.9
+R10E4.4	C04F12.9
+T13H5.7	C04F12.9
+T24C4.5	C04F12.9
+W02D9.1	C04F12.9
+W03D2.4	C04F12.9
+Y17G7B.5	C04F12.9
+Y39G10AR.14	C04F12.9
+Y47D3A.29	C04F12.9
+Y47G6A.8	C04F12.9
+Y53F4B.3	C04F12.9
+ZK632.1	C04F12.9
+C29A12.3	C25D7.6
+C39E9.13	C25D7.6
+C54G10.2	C25D7.6
+F08B4.5	C25D7.6
+F10C2.4	C25D7.6
+F12F6.7	C25D7.6
+F18A1.5	C25D7.6
+F21D5.6	C25D7.6
+F31E3.3	C25D7.6
+F32D1.10	C25D7.6
+F33H2.5	C25D7.6
+F43G6.1	C25D7.6
+F44B9.8	C25D7.6
+F58A4.4	C25D7.6
+F58F6.4	C25D7.6
+F59A3.6	C25D7.6
+F59A6.6	C25D7.6
+M04F3.1	C25D7.6
+R01H10.1	C25D7.6
+R04F11.3	C25D7.6
+R10E4.4	C25D7.6
+T13H5.7	C25D7.6
+T24C4.5	C25D7.6
+W02D9.1	C25D7.6
+W03D2.4	C25D7.6
+Y17G7B.5	C25D7.6
+Y39G10AR.14	C25D7.6
+Y47D3A.29	C25D7.6
+Y47G6A.8	C25D7.6
+Y53F4B.3	C25D7.6
+ZK632.1	C25D7.6
+C39E9.13	C29A12.3
+C54G10.2	C29A12.3
+F08B4.5	C29A12.3
+F10C2.4	C29A12.3
+F12F6.7	C29A12.3
+F18A1.5	C29A12.3
+F21D5.6	C29A12.3
+F31E3.3	C29A12.3
+F32D1.10	C29A12.3
+F33H2.5	C29A12.3
+F43G6.1	C29A12.3
+F44B9.8	C29A12.3
+F58A4.4	C29A12.3
+F58F6.4	C29A12.3
+F59A3.6	C29A12.3
+F59A6.6	C29A12.3
+M04F3.1	C29A12.3
+R01H10.1	C29A12.3
+R04F11.3	C29A12.3
+R10E4.4	C29A12.3
+T13H5.7	C29A12.3
+T24C4.5	C29A12.3
+W02D9.1	C29A12.3
+W03D2.4	C29A12.3
+Y17G7B.5	C29A12.3
+Y39G10AR.14	C29A12.3
+Y47D3A.29	C29A12.3
+Y47G6A.8	C29A12.3
+Y53F4B.3	C29A12.3
+ZK632.1	C29A12.3
+C54G10.2	C39E9.13
+F08B4.5	C39E9.13
+F10C2.4	C39E9.13
+F12F6.7	C39E9.13
+F18A1.5	C39E9.13
+F21D5.6	C39E9.13
+F31E3.3	C39E9.13
+F32D1.10	C39E9.13
+F33H2.5	C39E9.13
+F43G6.1	C39E9.13
+F44B9.8	C39E9.13
+F58A4.4	C39E9.13
+F58F6.4	C39E9.13
+F59A3.6	C39E9.13
+F59A6.6	C39E9.13
+M04F3.1	C39E9.13
+R01H10.1	C39E9.13
+R04F11.3	C39E9.13
+R10E4.4	C39E9.13
+T13H5.7	C39E9.13
+T24C4.5	C39E9.13
+W02D9.1	C39E9.13
+W03D2.4	C39E9.13
+Y17G7B.5	C39E9.13
+Y39G10AR.14	C39E9.13
+Y47D3A.29	C39E9.13
+Y47G6A.8	C39E9.13
+Y53F4B.3	C39E9.13
+ZK632.1	C39E9.13
+F08B4.5	C54G10.2
+F10C2.4	C54G10.2
+F12F6.7	C54G10.2
+F18A1.5	C54G10.2
+F21D5.6	C54G10.2
+F31E3.3	C54G10.2
+F32D1.10	C54G10.2
+F33H2.5	C54G10.2
+F43G6.1	C54G10.2
+F44B9.8	C54G10.2
+F58A4.4	C54G10.2
+F58F6.4	C54G10.2
+F59A3.6	C54G10.2
+F59A6.6	C54G10.2
+M04F3.1	C54G10.2
+R01H10.1	C54G10.2
+R04F11.3	C54G10.2
+R10E4.4	C54G10.2
+T13H5.7	C54G10.2
+T24C4.5	C54G10.2
+W02D9.1	C54G10.2
+W03D2.4	C54G10.2
+Y17G7B.5	C54G10.2
+Y39G10AR.14	C54G10.2
+Y47D3A.29	C54G10.2
+Y47G6A.8	C54G10.2
+Y53F4B.3	C54G10.2
+ZK632.1	C54G10.2
+F18A1.5	F08B4.5
+F21D5.6	F08B4.5
+F31E3.3	F08B4.5
+F32D1.10	F08B4.5
+F43G6.1	F08B4.5
+F44B9.8	F08B4.5
+F58F6.4	F08B4.5
+F59A3.6	F08B4.5
+F59A6.6	F08B4.5
+M04F3.1	F08B4.5
+R10E4.4	F08B4.5
+T13H5.7	F08B4.5
+W03D2.4	F08B4.5
+Y17G7B.5	F08B4.5
+Y39G10AR.14	F08B4.5
+Y47G6A.8	F08B4.5
+ZK632.1	F08B4.5
+F18A1.5	F10C2.4
+F21D5.6	F10C2.4
+F31E3.3	F10C2.4
+F32D1.10	F10C2.4
+F43G6.1	F10C2.4
+F44B9.8	F10C2.4
+F58F6.4	F10C2.4
+F59A3.6	F10C2.4
+F59A6.6	F10C2.4
+M04F3.1	F10C2.4
+R10E4.4	F10C2.4
+T13H5.7	F10C2.4
+W03D2.4	F10C2.4
+Y17G7B.5	F10C2.4
+Y39G10AR.14	F10C2.4
+Y47G6A.8	F10C2.4
+ZK632.1	F10C2.4
+F18A1.5	F12F6.7
+F21D5.6	F12F6.7
+F31E3.3	F12F6.7
+F32D1.10	F12F6.7
+F43G6.1	F12F6.7
+F44B9.8	F12F6.7
+F58F6.4	F12F6.7
+F59A3.6	F12F6.7
+F59A6.6	F12F6.7
+M04F3.1	F12F6.7
+R10E4.4	F12F6.7
+T13H5.7	F12F6.7
+W03D2.4	F12F6.7
+Y17G7B.5	F12F6.7
+Y39G10AR.14	F12F6.7
+Y47G6A.8	F12F6.7
+ZK632.1	F12F6.7
+F21D5.6	F18A1.5
+F31E3.3	F18A1.5
+F32D1.10	F18A1.5
+F33H2.5	F18A1.5
+F43G6.1	F18A1.5
+F44B9.8	F18A1.5
+F58A4.4	F18A1.5
+F58F6.4	F18A1.5
+F59A3.6	F18A1.5
+F59A6.6	F18A1.5
+M04F3.1	F18A1.5
+R01H10.1	F18A1.5
+R04F11.3	F18A1.5
+R10E4.4	F18A1.5
+T13H5.7	F18A1.5
+T24C4.5	F18A1.5
+W02D9.1	F18A1.5
+W03D2.4	F18A1.5
+Y17G7B.5	F18A1.5
+Y39G10AR.14	F18A1.5
+Y47D3A.29	F18A1.5
+Y47G6A.8	F18A1.5
+Y53F4B.3	F18A1.5
+ZK632.1	F18A1.5
+F31E3.3	F21D5.6
+F32D1.10	F21D5.6
+F33H2.5	F21D5.6
+F43G6.1	F21D5.6
+F44B9.8	F21D5.6
+F58A4.4	F21D5.6
+F58F6.4	F21D5.6
+F59A3.6	F21D5.6
+F59A6.6	F21D5.6
+M04F3.1	F21D5.6
+R01H10.1	F21D5.6
+R04F11.3	F21D5.6
+R10E4.4	F21D5.6
+T13H5.7	F21D5.6
+T24C4.5	F21D5.6
+W02D9.1	F21D5.6
+W03D2.4	F21D5.6
+Y17G7B.5	F21D5.6
+Y39G10AR.14	F21D5.6
+Y47D3A.29	F21D5.6
+Y47G6A.8	F21D5.6
+Y53F4B.3	F21D5.6
+ZK632.1	F21D5.6
+F32D1.10	F31E3.3
+F33H2.5	F31E3.3
+F43G6.1	F31E3.3
+F44B9.8	F31E3.3
+F58A4.4	F31E3.3
+F58F6.4	F31E3.3
+F59A3.6	F31E3.3
+F59A6.6	F31E3.3
+M04F3.1	F31E3.3
+R01H10.1	F31E3.3
+R04F11.3	F31E3.3
+R10E4.4	F31E3.3
+T13H5.7	F31E3.3
+T24C4.5	F31E3.3
+W02D9.1	F31E3.3
+W03D2.4	F31E3.3
+Y17G7B.5	F31E3.3
+Y39G10AR.14	F31E3.3
+Y47D3A.29	F31E3.3
+Y47G6A.8	F31E3.3
+Y53F4B.3	F31E3.3
+ZK632.1	F31E3.3
+F33H2.5	F32D1.10
+F43G6.1	F32D1.10
+F44B9.8	F32D1.10
+F58A4.4	F32D1.10
+F58F6.4	F32D1.10
+F59A3.6	F32D1.10
+F59A6.6	F32D1.10
+M04F3.1	F32D1.10
+R01H10.1	F32D1.10
+R04F11.3	F32D1.10
+R10E4.4	F32D1.10
+T13H5.7	F32D1.10
+T24C4.5	F32D1.10
+W02D9.1	F32D1.10
+W03D2.4	F32D1.10
+Y17G7B.5	F32D1.10
+Y39G10AR.14	F32D1.10
+Y47D3A.29	F32D1.10
+Y47G6A.8	F32D1.10
+Y53F4B.3	F32D1.10
+ZK632.1	F32D1.10
+F43G6.1	F33H2.5
+F44B9.8	F33H2.5
+F58F6.4	F33H2.5
+F59A3.6	F33H2.5
+F59A6.6	F33H2.5
+M04F3.1	F33H2.5
+R10E4.4	F33H2.5
+T13H5.7	F33H2.5
+W03D2.4	F33H2.5
+Y17G7B.5	F33H2.5
+Y39G10AR.14	F33H2.5
+Y47G6A.8	F33H2.5
+ZK632.1	F33H2.5
+F44B9.8	F43G6.1
+F58A4.4	F43G6.1
+F58F6.4	F43G6.1
+F59A3.6	F43G6.1
+F59A6.6	F43G6.1
+M04F3.1	F43G6.1
+R01H10.1	F43G6.1
+R04F11.3	F43G6.1
+R10E4.4	F43G6.1
+T13H5.7	F43G6.1
+T24C4.5	F43G6.1
+W02D9.1	F43G6.1
+W03D2.4	F43G6.1
+Y17G7B.5	F43G6.1
+Y39G10AR.14	F43G6.1
+Y47D3A.29	F43G6.1
+Y47G6A.8	F43G6.1
+Y53F4B.3	F43G6.1
+ZK632.1	F43G6.1
+F58A4.4	F44B9.8
+F58F6.4	F44B9.8
+F59A3.6	F44B9.8
+F59A6.6	F44B9.8
+M04F3.1	F44B9.8
+R01H10.1	F44B9.8
+R04F11.3	F44B9.8
+R10E4.4	F44B9.8
+T13H5.7	F44B9.8
+T24C4.5	F44B9.8
+W02D9.1	F44B9.8
+W03D2.4	F44B9.8
+Y17G7B.5	F44B9.8
+Y39G10AR.14	F44B9.8
+Y47D3A.29	F44B9.8
+Y47G6A.8	F44B9.8
+Y53F4B.3	F44B9.8
+ZK632.1	F44B9.8
+F58F6.4	F58A4.4
+F59A3.6	F58A4.4
+F59A6.6	F58A4.4
+M04F3.1	F58A4.4
+R10E4.4	F58A4.4
+T13H5.7	F58A4.4
+W03D2.4	F58A4.4
+Y17G7B.5	F58A4.4
+Y39G10AR.14	F58A4.4
+Y47G6A.8	F58A4.4
+ZK632.1	F58A4.4
+F59A3.6	F58F6.4
+F59A6.6	F58F6.4
+M04F3.1	F58F6.4
+R01H10.1	F58F6.4
+R04F11.3	F58F6.4
+R10E4.4	F58F6.4
+T13H5.7	F58F6.4
+T24C4.5	F58F6.4
+W02D9.1	F58F6.4
+W03D2.4	F58F6.4
+Y17G7B.5	F58F6.4
+Y39G10AR.14	F58F6.4
+Y47D3A.29	F58F6.4
+Y47G6A.8	F58F6.4
+Y53F4B.3	F58F6.4
+ZK632.1	F58F6.4
+F59A6.6	F59A3.6
+M04F3.1	F59A3.6
+R01H10.1	F59A3.6
+R04F11.3	F59A3.6
+R10E4.4	F59A3.6
+T13H5.7	F59A3.6
+T24C4.5	F59A3.6
+W02D9.1	F59A3.6
+W03D2.4	F59A3.6
+Y17G7B.5	F59A3.6
+Y39G10AR.14	F59A3.6
+Y47D3A.29	F59A3.6
+Y47G6A.8	F59A3.6
+Y53F4B.3	F59A3.6
+ZK632.1	F59A3.6
+M04F3.1	F59A6.6
+R01H10.1	F59A6.6
+R04F11.3	F59A6.6
+R10E4.4	F59A6.6
+T13H5.7	F59A6.6
+T24C4.5	F59A6.6
+W02D9.1	F59A6.6
+W03D2.4	F59A6.6
+Y17G7B.5	F59A6.6
+Y39G10AR.14	F59A6.6
+Y47D3A.29	F59A6.6
+Y47G6A.8	F59A6.6
+Y53F4B.3	F59A6.6
+ZK632.1	F59A6.6
+R01H10.1	M04F3.1
+R04F11.3	M04F3.1
+R10E4.4	M04F3.1
+T13H5.7	M04F3.1
+T24C4.5	M04F3.1
+W02D9.1	M04F3.1
+W03D2.4	M04F3.1
+Y17G7B.5	M04F3.1
+Y39G10AR.14	M04F3.1
+Y47D3A.29	M04F3.1
+Y47G6A.8	M04F3.1
+Y53F4B.3	M04F3.1
+ZK632.1	M04F3.1
+R10E4.4	R01H10.1
+T13H5.7	R01H10.1
+W03D2.4	R01H10.1
+Y17G7B.5	R01H10.1
+Y39G10AR.14	R01H10.1
+Y47G6A.8	R01H10.1
+ZK632.1	R01H10.1
+R10E4.4	R04F11.3
+T13H5.7	R04F11.3
+W03D2.4	R04F11.3
+Y17G7B.5	R04F11.3
+Y39G10AR.14	R04F11.3
+Y47G6A.8	R04F11.3
+ZK632.1	R04F11.3
+T13H5.7	R10E4.4
+T24C4.5	R10E4.4
+W02D9.1	R10E4.4
+W03D2.4	R10E4.4
+Y17G7B.5	R10E4.4
+Y39G10AR.14	R10E4.4
+Y47D3A.29	R10E4.4
+Y47G6A.8	R10E4.4
+Y53F4B.3	R10E4.4
+ZK632.1	R10E4.4
+T24C4.5	T13H5.7
+W02D9.1	T13H5.7
+W03D2.4	T13H5.7
+Y17G7B.5	T13H5.7
+Y39G10AR.14	T13H5.7
+Y47D3A.29	T13H5.7
+Y47G6A.8	T13H5.7
+Y53F4B.3	T13H5.7
+ZK632.1	T13H5.7
+W03D2.4	T24C4.5
+Y17G7B.5	T24C4.5
+Y39G10AR.14	T24C4.5
+Y47G6A.8	T24C4.5
+ZK632.1	T24C4.5
+W03D2.4	W02D9.1
+Y17G7B.5	W02D9.1
+Y39G10AR.14	W02D9.1
+Y47G6A.8	W02D9.1
+ZK632.1	W02D9.1
+Y17G7B.5	W03D2.4
+Y39G10AR.14	W03D2.4
+Y47D3A.29	W03D2.4
+Y47G6A.8	W03D2.4
+Y53F4B.3	W03D2.4
+ZK632.1	W03D2.4
+Y39G10AR.14	Y17G7B.5
+Y47D3A.29	Y17G7B.5
+Y47G6A.8	Y17G7B.5
+Y53F4B.3	Y17G7B.5
+ZK632.1	Y17G7B.5
+Y47D3A.29	Y39G10AR.14
+Y47G6A.8	Y39G10AR.14
+Y53F4B.3	Y39G10AR.14
+ZK632.1	Y39G10AR.14
+ZK632.1	Y47D3A.29
+Y53F4B.3	Y47G6A.8
+ZK632.1	Y47G6A.8
+ZK632.1	Y53F4B.3
+C04H5.6	C01F6.5
+C07A9.2	C01F6.5
+C07H6.4	C01F6.5
+C08B11.6	C01F6.5
+C12C8.1	C01F6.5
+C18D11.4	C01F6.5
+C33H5.12	C01F6.5
+C34D4.12	C01F6.5
+C36B1.5	C01F6.5
+C46F11.4	C01F6.5
+C50C3.6	C01F6.5
+C50D2.5	C01F6.5
+C50F2.3	C01F6.5
+C52E4.3	C01F6.5
+D1054.14	C01F6.5
+D1054.15	C01F6.5
+D1081.8	C01F6.5
+EEED8.5	C01F6.5
+EEED8.7	C01F6.5
+F01F1.7	C01F6.5
+F08B4.7	C01F6.5
+F08G12.2	C01F6.5
+F09D1.1	C01F6.5
+F11A10.2	C01F6.5
+F11F1.1	C01F6.5
+F19F10.9	C01F6.5
+F26B1.2	C01F6.5
+F26D10.3	C01F6.5
+F28F8.3	C01F6.5
+F32A5.7	C01F6.5
+F32B6.3	C01F6.5
+F42A6.7	C01F6.5
+F44E5.4	C01F6.5
+F44E5.5	C01F6.5
+F49D11.1	C01F6.5
+F53B7.3	C01F6.5
+F53H1.1	C01F6.5
+F56D2.6	C01F6.5
+F58B3.7	C01F6.5
+F58E10.3	C01F6.5
+H20J04.8	C01F6.5
+K02F2.3	C01F6.5
+K03H1.2	C01F6.5
+K04G7.10	C01F6.5
+K04G7.11	C01F6.5
+K07C5.6	C01F6.5
+M01E11.2	C01F6.5
+M03C11.7	C01F6.5
+M03F8.3	C01F6.5
+M28.5	C01F6.5
+R05D11.7	C01F6.5
+T01B7.4	C01F6.5
+T08A11.2	C01F6.5
+T10C6.5	C01F6.5
+T10F2.4	C01F6.5
+T10G3.6	C01F6.5
+T11G6.8	C01F6.5
+T12A2.7	C01F6.5
+T13H5.4	C01F6.5
+T21D12.3	C01F6.5
+T27F2.1	C01F6.5
+T28D9.10	C01F6.5
+W02B12.2	C01F6.5
+W02B12.3	C01F6.5
+W03F9.10	C01F6.5
+W04D2.6	C01F6.5
+W07E6.4	C01F6.5
+W08E3.1	C01F6.5
+Y108G3AL.2	C01F6.5
+Y110A7A.8	C01F6.5
+Y111B2A.18	C01F6.5
+Y116A8C.34	C01F6.5
+Y116A8C.35	C01F6.5
+Y116A8C.42	C01F6.5
+Y46G5A.4	C01F6.5
+Y47G6A.20	C01F6.5
+Y49E10.15	C01F6.5
+Y54F10BM.14	C01F6.5
+Y59A8B.6	C01F6.5
+Y62E10A.12	C01F6.5
+Y69A2AR.21	C01F6.5
+Y71D11A.2	C01F6.5
+Y71F9B.4	C01F6.5
+Y71G12B.14	C01F6.5
+Y73B6BL.32	C01F6.5
+Y80D3A.2	C01F6.5
+Y92C3B.2	C01F6.5
+ZK1098.1	C01F6.5
+ZK1127.9	C01F6.5
+ZK328.2	C01F6.5
+ZK593.7	C01F6.5
+ZK652.1	C01F6.5
+ZK686.4	C01F6.5
+C04H5.6	C02B10.4
+C07A9.2	C02B10.4
+C07H6.4	C02B10.4
+C08B11.6	C02B10.4
+C12C8.1	C02B10.4
+C18D11.4	C02B10.4
+C33H5.12	C02B10.4
+C34D4.12	C02B10.4
+C36B1.5	C02B10.4
+C46F11.4	C02B10.4
+C50C3.6	C02B10.4
+C50D2.5	C02B10.4
+C50F2.3	C02B10.4
+C52E4.3	C02B10.4
+D1054.14	C02B10.4
+D1054.15	C02B10.4
+D1081.8	C02B10.4
+EEED8.5	C02B10.4
+EEED8.7	C02B10.4
+F01F1.7	C02B10.4
+F08B4.7	C02B10.4
+F08G12.2	C02B10.4
+F09D1.1	C02B10.4
+F11A10.2	C02B10.4
+F11F1.1	C02B10.4
+F19F10.9	C02B10.4
+F26B1.2	C02B10.4
+F26D10.3	C02B10.4
+F28F8.3	C02B10.4
+F32A5.7	C02B10.4
+F32B6.3	C02B10.4
+F42A6.7	C02B10.4
+F44E5.4	C02B10.4
+F44E5.5	C02B10.4
+F49D11.1	C02B10.4
+F53B7.3	C02B10.4
+F53H1.1	C02B10.4
+F56D2.6	C02B10.4
+F58B3.7	C02B10.4
+F58E10.3	C02B10.4
+H20J04.8	C02B10.4
+K02F2.3	C02B10.4
+K03H1.2	C02B10.4
+K04G7.10	C02B10.4
+K04G7.11	C02B10.4
+K07C5.6	C02B10.4
+M01E11.2	C02B10.4
+M03C11.7	C02B10.4
+M03F8.3	C02B10.4
+M28.5	C02B10.4
+R05D11.7	C02B10.4
+T01B7.4	C02B10.4
+T08A11.2	C02B10.4
+T10C6.5	C02B10.4
+T10F2.4	C02B10.4
+T10G3.6	C02B10.4
+T11G6.8	C02B10.4
+T12A2.7	C02B10.4
+T13H5.4	C02B10.4
+T21D12.3	C02B10.4
+T27F2.1	C02B10.4
+T28D9.10	C02B10.4
+W02B12.2	C02B10.4
+W02B12.3	C02B10.4
+W03F9.10	C02B10.4
+W04D2.6	C02B10.4
+W07E6.4	C02B10.4
+W08E3.1	C02B10.4
+Y108G3AL.2	C02B10.4
+Y110A7A.8	C02B10.4
+Y111B2A.18	C02B10.4
+Y116A8C.34	C02B10.4
+Y116A8C.35	C02B10.4
+Y116A8C.42	C02B10.4
+Y46G5A.4	C02B10.4
+Y47G6A.20	C02B10.4
+Y49E10.15	C02B10.4
+Y54F10BM.14	C02B10.4
+Y59A8B.6	C02B10.4
+Y62E10A.12	C02B10.4
+Y69A2AR.21	C02B10.4
+Y71D11A.2	C02B10.4
+Y71F9B.4	C02B10.4
+Y71G12B.14	C02B10.4
+Y73B6BL.32	C02B10.4
+Y80D3A.2	C02B10.4
+Y92C3B.2	C02B10.4
+ZK1098.1	C02B10.4
+ZK1127.9	C02B10.4
+ZK328.2	C02B10.4
+ZK593.7	C02B10.4
+ZK652.1	C02B10.4
+ZK686.4	C02B10.4
+C07A9.2	C04H5.6
+C07H6.4	C04H5.6
+C08B11.6	C04H5.6
+C12C8.1	C04H5.6
+C16A3.8	C04H5.6
+C18D11.4	C04H5.6
+C33H5.12	C04H5.6
+C34D4.12	C04H5.6
+C36B1.5	C04H5.6
+C43E11.1	C04H5.6
+C46F11.4	C04H5.6
+C50C3.6	C04H5.6
+C50D2.5	C04H5.6
+C50F2.3	C04H5.6
+C52E4.3	C04H5.6
+D1054.14	C04H5.6
+D1054.15	C04H5.6
+D1081.8	C04H5.6
+EEED8.5	C04H5.6
+EEED8.7	C04H5.6
+F01F1.7	C04H5.6
+F08B4.7	C04H5.6
+F08G12.2	C04H5.6
+F09D1.1	C04H5.6
+F11A10.2	C04H5.6
+F11F1.1	C04H5.6
+F19F10.9	C04H5.6
+F23B2.6	C04H5.6
+F26A3.2	C04H5.6
+F26B1.2	C04H5.6
+F26D10.3	C04H5.6
+F28F8.3	C04H5.6
+F32A5.7	C04H5.6
+F32B6.3	C04H5.6
+F32H2.4	C04H5.6
+F33D11.10	C04H5.6
+F37E3.1	C04H5.6
+F42A6.7	C04H5.6
+F44E5.4	C04H5.6
+F44E5.5	C04H5.6
+F49D11.1	C04H5.6
+F53B7.3	C04H5.6
+F53H1.1	C04H5.6
+F56D2.6	C04H5.6
+F58B3.7	C04H5.6
+F58E10.3	C04H5.6
+H20J04.8	C04H5.6
+K02F2.3	C04H5.6
+K03H1.2	C04H5.6
+K04G7.10	C04H5.6
+K04G7.11	C04H5.6
+K07C5.6	C04H5.6
+M01E11.2	C04H5.6
+M03C11.7	C04H5.6
+M03F8.3	C04H5.6
+M18.7	C04H5.6
+M28.5	C04H5.6
+R05D11.7	C04H5.6
+R07E5.14	C04H5.6
+R09B3.5	C04H5.6
+T01B7.4	C04H5.6
+T02H6.2	C04H5.6
+T08A11.2	C04H5.6
+T10C6.5	C04H5.6
+T10F2.4	C04H5.6
+T10G3.6	C04H5.6
+T11G6.8	C04H5.6
+T12A2.7	C04H5.6
+T13H5.4	C04H5.6
+T21D12.3	C04H5.6
+T27F2.1	C04H5.6
+T28D9.10	C04H5.6
+W02B12.2	C04H5.6
+W02B12.3	C04H5.6
+W03F9.10	C04H5.6
+W04D2.6	C04H5.6
+W07E6.4	C04H5.6
+W08E3.1	C04H5.6
+Y108G3AL.2	C04H5.6
+Y110A7A.8	C04H5.6
+Y111B2A.18	C04H5.6
+Y116A8C.34	C04H5.6
+Y116A8C.35	C04H5.6
+Y116A8C.42	C04H5.6
+Y46G5A.4	C04H5.6
+Y47G6A.20	C04H5.6
+Y49E10.15	C04H5.6
+Y54F10BM.14	C04H5.6
+Y59A8B.6	C04H5.6
+Y62E10A.12	C04H5.6
+Y65B4A.6	C04H5.6
+Y69A2AR.21	C04H5.6
+Y71D11A.2	C04H5.6
+Y71F9B.4	C04H5.6
+Y71G12B.14	C04H5.6
+Y73B6BL.32	C04H5.6
+Y80D3A.2	C04H5.6
+Y92C3B.2	C04H5.6
+ZK1098.1	C04H5.6
+ZK1127.9	C04H5.6
+ZK328.2	C04H5.6
+ZK593.7	C04H5.6
+ZK652.1	C04H5.6
+ZK686.4	C04H5.6
+C07H6.4	C07A9.2
+C08B11.6	C07A9.2
+C12C8.1	C07A9.2
+C16A3.8	C07A9.2
+C18D11.4	C07A9.2
+C33H5.12	C07A9.2
+C34D4.12	C07A9.2
+C36B1.5	C07A9.2
+C43E11.1	C07A9.2
+C46F11.4	C07A9.2
+C50C3.6	C07A9.2
+C50D2.5	C07A9.2
+C50F2.3	C07A9.2
+C52E4.3	C07A9.2
+D1054.14	C07A9.2
+D1054.15	C07A9.2
+D1081.8	C07A9.2
+EEED8.5	C07A9.2
+EEED8.7	C07A9.2
+F01F1.7	C07A9.2
+F08B4.7	C07A9.2
+F08G12.2	C07A9.2
+F09D1.1	C07A9.2
+F11A10.2	C07A9.2
+F11F1.1	C07A9.2
+F19F10.9	C07A9.2
+F23B2.6	C07A9.2
+F26A3.2	C07A9.2
+F26B1.2	C07A9.2
+F26D10.3	C07A9.2
+F28F8.3	C07A9.2
+F32A5.7	C07A9.2
+F32B6.3	C07A9.2
+F32H2.4	C07A9.2
+F33D11.10	C07A9.2
+F37E3.1	C07A9.2
+F42A6.7	C07A9.2
+F44E5.4	C07A9.2
+F44E5.5	C07A9.2
+F49D11.1	C07A9.2
+F53B7.3	C07A9.2
+F53H1.1	C07A9.2
+F56D2.6	C07A9.2
+F58B3.7	C07A9.2
+F58E10.3	C07A9.2
+H20J04.8	C07A9.2
+K02F2.3	C07A9.2
+K03H1.2	C07A9.2
+K04G7.10	C07A9.2
+K04G7.11	C07A9.2
+K07C5.6	C07A9.2
+M01E11.2	C07A9.2
+M03C11.7	C07A9.2
+M03F8.3	C07A9.2
+M18.7	C07A9.2
+M28.5	C07A9.2
+R05D11.7	C07A9.2
+R07E5.14	C07A9.2
+R09B3.5	C07A9.2
+T01B7.4	C07A9.2
+T02H6.2	C07A9.2
+T08A11.2	C07A9.2
+T10C6.5	C07A9.2
+T10F2.4	C07A9.2
+T10G3.6	C07A9.2
+T11G6.8	C07A9.2
+T12A2.7	C07A9.2
+T13H5.4	C07A9.2
+T21D12.3	C07A9.2
+T27F2.1	C07A9.2
+T28D9.10	C07A9.2
+W02B12.2	C07A9.2
+W02B12.3	C07A9.2
+W03F9.10	C07A9.2
+W04D2.6	C07A9.2
+W07E6.4	C07A9.2
+W08E3.1	C07A9.2
+Y108G3AL.2	C07A9.2
+Y110A7A.8	C07A9.2
+Y111B2A.18	C07A9.2
+Y116A8C.34	C07A9.2
+Y116A8C.35	C07A9.2
+Y116A8C.42	C07A9.2
+Y46G5A.4	C07A9.2
+Y47G6A.20	C07A9.2
+Y49E10.15	C07A9.2
+Y54F10BM.14	C07A9.2
+Y59A8B.6	C07A9.2
+Y62E10A.12	C07A9.2
+Y65B4A.6	C07A9.2
+Y69A2AR.21	C07A9.2
+Y71D11A.2	C07A9.2
+Y71F9B.4	C07A9.2
+Y71G12B.14	C07A9.2
+Y73B6BL.32	C07A9.2
+Y80D3A.2	C07A9.2
+Y92C3B.2	C07A9.2
+ZK1098.1	C07A9.2
+ZK1127.9	C07A9.2
+ZK328.2	C07A9.2
+ZK593.7	C07A9.2
+ZK652.1	C07A9.2
+ZK686.4	C07A9.2
+C08B11.6	C07H6.4
+C12C8.1	C07H6.4
+C16A3.8	C07H6.4
+C18D11.4	C07H6.4
+C33H5.12	C07H6.4
+C34D4.12	C07H6.4
+C36B1.5	C07H6.4
+C43E11.1	C07H6.4
+C46F11.4	C07H6.4
+C50C3.6	C07H6.4
+C50D2.5	C07H6.4
+C50F2.3	C07H6.4
+C52E4.3	C07H6.4
+D1054.14	C07H6.4
+D1054.15	C07H6.4
+D1081.8	C07H6.4
+EEED8.5	C07H6.4
+EEED8.7	C07H6.4
+F01F1.7	C07H6.4
+F08B4.7	C07H6.4
+F08G12.2	C07H6.4
+F09D1.1	C07H6.4
+F11A10.2	C07H6.4
+F11F1.1	C07H6.4
+F19F10.9	C07H6.4
+F23B2.6	C07H6.4
+F26A3.2	C07H6.4
+F26B1.2	C07H6.4
+F26D10.3	C07H6.4
+F28F8.3	C07H6.4
+F32A5.7	C07H6.4
+F32B6.3	C07H6.4
+F32H2.4	C07H6.4
+F33D11.10	C07H6.4
+F37E3.1	C07H6.4
+F42A6.7	C07H6.4
+F44E5.4	C07H6.4
+F44E5.5	C07H6.4
+F49D11.1	C07H6.4
+F53B7.3	C07H6.4
+F53H1.1	C07H6.4
+F56D2.6	C07H6.4
+F58B3.7	C07H6.4
+F58E10.3	C07H6.4
+H20J04.8	C07H6.4
+K02F2.3	C07H6.4
+K03H1.2	C07H6.4
+K04G7.10	C07H6.4
+K04G7.11	C07H6.4
+K07C5.6	C07H6.4
+M01E11.2	C07H6.4
+M03C11.7	C07H6.4
+M03F8.3	C07H6.4
+M18.7	C07H6.4
+M28.5	C07H6.4
+R05D11.7	C07H6.4
+R07E5.14	C07H6.4
+R09B3.5	C07H6.4
+T01B7.4	C07H6.4
+T02H6.2	C07H6.4
+T08A11.2	C07H6.4
+T10C6.5	C07H6.4
+T10F2.4	C07H6.4
+T10G3.6	C07H6.4
+T11G6.8	C07H6.4
+T12A2.7	C07H6.4
+T13H5.4	C07H6.4
+T21D12.3	C07H6.4
+T27F2.1	C07H6.4
+T28D9.10	C07H6.4
+W02B12.2	C07H6.4
+W02B12.3	C07H6.4
+W03F9.10	C07H6.4
+W04D2.6	C07H6.4
+W07E6.4	C07H6.4
+W08E3.1	C07H6.4
+Y108G3AL.2	C07H6.4
+Y110A7A.8	C07H6.4
+Y111B2A.18	C07H6.4
+Y116A8C.34	C07H6.4
+Y116A8C.35	C07H6.4
+Y116A8C.42	C07H6.4
+Y46G5A.4	C07H6.4
+Y47G6A.20	C07H6.4
+Y49E10.15	C07H6.4
+Y54F10BM.14	C07H6.4
+Y59A8B.6	C07H6.4
+Y62E10A.12	C07H6.4
+Y65B4A.6	C07H6.4
+Y69A2AR.21	C07H6.4
+Y71D11A.2	C07H6.4
+Y71F9B.4	C07H6.4
+Y71G12B.14	C07H6.4
+Y73B6BL.32	C07H6.4
+Y80D3A.2	C07H6.4
+Y92C3B.2	C07H6.4
+ZK1098.1	C07H6.4
+ZK1127.9	C07H6.4
+ZK328.2	C07H6.4
+ZK593.7	C07H6.4
+ZK652.1	C07H6.4
+ZK686.4	C07H6.4
+C12C8.1	C08B11.6
+C16A3.8	C08B11.6
+C18D11.4	C08B11.6
+C33H5.12	C08B11.6
+C34D4.12	C08B11.6
+C36B1.5	C08B11.6
+C43E11.1	C08B11.6
+C46F11.4	C08B11.6
+C50C3.6	C08B11.6
+C50D2.5	C08B11.6
+C50F2.3	C08B11.6
+C52E4.3	C08B11.6
+D1054.14	C08B11.6
+D1054.15	C08B11.6
+D1081.8	C08B11.6
+EEED8.5	C08B11.6
+EEED8.7	C08B11.6
+F01F1.7	C08B11.6
+F08B4.7	C08B11.6
+F08G12.2	C08B11.6
+F09D1.1	C08B11.6
+F11A10.2	C08B11.6
+F11F1.1	C08B11.6
+F19F10.9	C08B11.6
+F23B2.6	C08B11.6
+F26A3.2	C08B11.6
+F26B1.2	C08B11.6
+F26D10.3	C08B11.6
+F28F8.3	C08B11.6
+F32A5.7	C08B11.6
+F32B6.3	C08B11.6
+F32H2.4	C08B11.6
+F33D11.10	C08B11.6
+F37E3.1	C08B11.6
+F42A6.7	C08B11.6
+F44E5.4	C08B11.6
+F44E5.5	C08B11.6
+F49D11.1	C08B11.6
+F53B7.3	C08B11.6
+F53H1.1	C08B11.6
+F56D2.6	C08B11.6
+F58B3.7	C08B11.6
+F58E10.3	C08B11.6
+H20J04.8	C08B11.6
+K02F2.3	C08B11.6
+K03H1.2	C08B11.6
+K04G7.10	C08B11.6
+K04G7.11	C08B11.6
+K07C5.6	C08B11.6
+M01E11.2	C08B11.6
+M03C11.7	C08B11.6
+M03F8.3	C08B11.6
+M18.7	C08B11.6
+M28.5	C08B11.6
+R05D11.7	C08B11.6
+R07E5.14	C08B11.6
+R09B3.5	C08B11.6
+T01B7.4	C08B11.6
+T02H6.2	C08B11.6
+T08A11.2	C08B11.6
+T10C6.5	C08B11.6
+T10F2.4	C08B11.6
+T10G3.6	C08B11.6
+T11G6.8	C08B11.6
+T12A2.7	C08B11.6
+T13H5.4	C08B11.6
+T21D12.3	C08B11.6
+T27F2.1	C08B11.6
+T28D9.10	C08B11.6
+W02B12.2	C08B11.6
+W02B12.3	C08B11.6
+W03F9.10	C08B11.6
+W04D2.6	C08B11.6
+W07E6.4	C08B11.6
+W08E3.1	C08B11.6
+Y108G3AL.2	C08B11.6
+Y110A7A.8	C08B11.6
+Y111B2A.18	C08B11.6
+Y116A8C.34	C08B11.6
+Y116A8C.35	C08B11.6
+Y116A8C.42	C08B11.6
+Y46G5A.4	C08B11.6
+Y47G6A.20	C08B11.6
+Y49E10.15	C08B11.6
+Y54F10BM.14	C08B11.6
+Y59A8B.6	C08B11.6
+Y62E10A.12	C08B11.6
+Y65B4A.6	C08B11.6
+Y69A2AR.21	C08B11.6
+Y71D11A.2	C08B11.6
+Y71F9B.4	C08B11.6
+Y71G12B.14	C08B11.6
+Y73B6BL.32	C08B11.6
+Y80D3A.2	C08B11.6
+Y92C3B.2	C08B11.6
+ZK1098.1	C08B11.6
+ZK1127.9	C08B11.6
+ZK328.2	C08B11.6
+ZK593.7	C08B11.6
+ZK652.1	C08B11.6
+ZK686.4	C08B11.6
+C16A3.8	C12C8.1
+C18D11.4	C12C8.1
+C33H5.12	C12C8.1
+C34D4.12	C12C8.1
+C36B1.5	C12C8.1
+C43E11.1	C12C8.1
+C46F11.4	C12C8.1
+C50C3.6	C12C8.1
+C50D2.5	C12C8.1
+C50F2.3	C12C8.1
+C52E4.3	C12C8.1
+D1054.14	C12C8.1
+D1054.15	C12C8.1
+D1081.8	C12C8.1
+EEED8.5	C12C8.1
+EEED8.7	C12C8.1
+F01F1.7	C12C8.1
+F08B4.7	C12C8.1
+F08G12.2	C12C8.1
+F09D1.1	C12C8.1
+F11A10.2	C12C8.1
+F11F1.1	C12C8.1
+F19F10.9	C12C8.1
+F23B2.6	C12C8.1
+F26A3.2	C12C8.1
+F26B1.2	C12C8.1
+F26D10.3	C12C8.1
+F28F8.3	C12C8.1
+F32A5.7	C12C8.1
+F32B6.3	C12C8.1
+F32H2.4	C12C8.1
+F33D11.10	C12C8.1
+F37E3.1	C12C8.1
+F42A6.7	C12C8.1
+F44E5.4	C12C8.1
+F44E5.5	C12C8.1
+F49D11.1	C12C8.1
+F53B7.3	C12C8.1
+F53H1.1	C12C8.1
+F56D2.6	C12C8.1
+F58B3.7	C12C8.1
+F58E10.3	C12C8.1
+H20J04.8	C12C8.1
+K02F2.3	C12C8.1
+K03H1.2	C12C8.1
+K04G7.10	C12C8.1
+K04G7.11	C12C8.1
+K07C5.6	C12C8.1
+M01E11.2	C12C8.1
+M03C11.7	C12C8.1
+M03F8.3	C12C8.1
+M18.7	C12C8.1
+M28.5	C12C8.1
+R05D11.7	C12C8.1
+R07E5.14	C12C8.1
+R09B3.5	C12C8.1
+T01B7.4	C12C8.1
+T02H6.2	C12C8.1
+T08A11.2	C12C8.1
+T10C6.5	C12C8.1
+T10F2.4	C12C8.1
+T10G3.6	C12C8.1
+T11G6.8	C12C8.1
+T12A2.7	C12C8.1
+T13H5.4	C12C8.1
+T21D12.3	C12C8.1
+T27F2.1	C12C8.1
+T28D9.10	C12C8.1
+W02B12.2	C12C8.1
+W02B12.3	C12C8.1
+W03F9.10	C12C8.1
+W04D2.6	C12C8.1
+W07E6.4	C12C8.1
+W08E3.1	C12C8.1
+Y108G3AL.2	C12C8.1
+Y110A7A.8	C12C8.1
+Y111B2A.18	C12C8.1
+Y116A8C.34	C12C8.1
+Y116A8C.35	C12C8.1
+Y116A8C.42	C12C8.1
+Y46G5A.4	C12C8.1
+Y47G6A.20	C12C8.1
+Y49E10.15	C12C8.1
+Y54F10BM.14	C12C8.1
+Y59A8B.6	C12C8.1
+Y62E10A.12	C12C8.1
+Y65B4A.6	C12C8.1
+Y69A2AR.21	C12C8.1
+Y71D11A.2	C12C8.1
+Y71F9B.4	C12C8.1
+Y71G12B.14	C12C8.1
+Y73B6BL.32	C12C8.1
+Y80D3A.2	C12C8.1
+Y92C3B.2	C12C8.1
+ZK1098.1	C12C8.1
+ZK1127.9	C12C8.1
+ZK328.2	C12C8.1
+ZK593.7	C12C8.1
+ZK652.1	C12C8.1
+ZK686.4	C12C8.1
+C18D11.4	C16A3.8
+C33H5.12	C16A3.8
+C34D4.12	C16A3.8
+C36B1.5	C16A3.8
+C46F11.4	C16A3.8
+C50C3.6	C16A3.8
+C50D2.5	C16A3.8
+C50F2.3	C16A3.8
+C52E4.3	C16A3.8
+D1054.14	C16A3.8
+D1054.15	C16A3.8
+D1081.8	C16A3.8
+EEED8.5	C16A3.8
+EEED8.7	C16A3.8
+F01F1.7	C16A3.8
+F08B4.7	C16A3.8
+F08G12.2	C16A3.8
+F09D1.1	C16A3.8
+F11A10.2	C16A3.8
+F11F1.1	C16A3.8
+F19F10.9	C16A3.8
+F26B1.2	C16A3.8
+F26D10.3	C16A3.8
+F28F8.3	C16A3.8
+F32A5.7	C16A3.8
+F32B6.3	C16A3.8
+F42A6.7	C16A3.8
+F44E5.4	C16A3.8
+F44E5.5	C16A3.8
+F49D11.1	C16A3.8
+F53B7.3	C16A3.8
+F53H1.1	C16A3.8
+F56D2.6	C16A3.8
+F58B3.7	C16A3.8
+F58E10.3	C16A3.8
+H20J04.8	C16A3.8
+K02F2.3	C16A3.8
+K03H1.2	C16A3.8
+K04G7.10	C16A3.8
+K04G7.11	C16A3.8
+K07C5.6	C16A3.8
+M01E11.2	C16A3.8
+M03C11.7	C16A3.8
+M03F8.3	C16A3.8
+M28.5	C16A3.8
+R05D11.7	C16A3.8
+T01B7.4	C16A3.8
+T08A11.2	C16A3.8
+T10C6.5	C16A3.8
+T10F2.4	C16A3.8
+T10G3.6	C16A3.8
+T11G6.8	C16A3.8
+T12A2.7	C16A3.8
+T13H5.4	C16A3.8
+T21D12.3	C16A3.8
+T27F2.1	C16A3.8
+T28D9.10	C16A3.8
+W02B12.2	C16A3.8
+W02B12.3	C16A3.8
+W03F9.10	C16A3.8
+W04D2.6	C16A3.8
+W07E6.4	C16A3.8
+W08E3.1	C16A3.8
+Y108G3AL.2	C16A3.8
+Y110A7A.8	C16A3.8
+Y111B2A.18	C16A3.8
+Y116A8C.34	C16A3.8
+Y116A8C.35	C16A3.8
+Y116A8C.42	C16A3.8
+Y46G5A.4	C16A3.8
+Y47G6A.20	C16A3.8
+Y49E10.15	C16A3.8
+Y54F10BM.14	C16A3.8
+Y59A8B.6	C16A3.8
+Y62E10A.12	C16A3.8
+Y69A2AR.21	C16A3.8
+Y71D11A.2	C16A3.8
+Y71F9B.4	C16A3.8
+Y71G12B.14	C16A3.8
+Y73B6BL.32	C16A3.8
+Y80D3A.2	C16A3.8
+Y92C3B.2	C16A3.8
+ZK1098.1	C16A3.8
+ZK1127.9	C16A3.8
+ZK328.2	C16A3.8
+ZK593.7	C16A3.8
+ZK652.1	C16A3.8
+ZK686.4	C16A3.8
+C33H5.12	C18D11.4
+C34D4.12	C18D11.4
+C36B1.5	C18D11.4
+C43E11.1	C18D11.4
+C46F11.4	C18D11.4
+C50C3.6	C18D11.4
+C50D2.5	C18D11.4
+C50F2.3	C18D11.4
+C52E4.3	C18D11.4
+D1054.14	C18D11.4
+D1054.15	C18D11.4
+D1081.8	C18D11.4
+EEED8.5	C18D11.4
+EEED8.7	C18D11.4
+F01F1.7	C18D11.4
+F08B4.7	C18D11.4
+F08G12.2	C18D11.4
+F09D1.1	C18D11.4
+F11A10.2	C18D11.4
+F11F1.1	C18D11.4
+F19F10.9	C18D11.4
+F23B2.6	C18D11.4
+F26A3.2	C18D11.4
+F26B1.2	C18D11.4
+F26D10.3	C18D11.4
+F28F8.3	C18D11.4
+F32A5.7	C18D11.4
+F32B6.3	C18D11.4
+F32H2.4	C18D11.4
+F33D11.10	C18D11.4
+F37E3.1	C18D11.4
+F42A6.7	C18D11.4
+F44E5.4	C18D11.4
+F44E5.5	C18D11.4
+F49D11.1	C18D11.4
+F53B7.3	C18D11.4
+F53H1.1	C18D11.4
+F56D2.6	C18D11.4
+F58B3.7	C18D11.4
+F58E10.3	C18D11.4
+H20J04.8	C18D11.4
+K02F2.3	C18D11.4
+K03H1.2	C18D11.4
+K04G7.10	C18D11.4
+K04G7.11	C18D11.4
+K07C5.6	C18D11.4
+M01E11.2	C18D11.4
+M03C11.7	C18D11.4
+M03F8.3	C18D11.4
+M18.7	C18D11.4
+M28.5	C18D11.4
+R05D11.7	C18D11.4
+R07E5.14	C18D11.4
+R09B3.5	C18D11.4
+T01B7.4	C18D11.4
+T02H6.2	C18D11.4
+T08A11.2	C18D11.4
+T10C6.5	C18D11.4
+T10F2.4	C18D11.4
+T10G3.6	C18D11.4
+T11G6.8	C18D11.4
+T12A2.7	C18D11.4
+T13H5.4	C18D11.4
+T21D12.3	C18D11.4
+T27F2.1	C18D11.4
+T28D9.10	C18D11.4
+W02B12.2	C18D11.4
+W02B12.3	C18D11.4
+W03F9.10	C18D11.4
+W04D2.6	C18D11.4
+W07E6.4	C18D11.4
+W08E3.1	C18D11.4
+Y108G3AL.2	C18D11.4
+Y110A7A.8	C18D11.4
+Y111B2A.18	C18D11.4
+Y116A8C.34	C18D11.4
+Y116A8C.35	C18D11.4
+Y116A8C.42	C18D11.4
+Y46G5A.4	C18D11.4
+Y47G6A.20	C18D11.4
+Y49E10.15	C18D11.4
+Y54F10BM.14	C18D11.4
+Y59A8B.6	C18D11.4
+Y62E10A.12	C18D11.4
+Y65B4A.6	C18D11.4
+Y69A2AR.21	C18D11.4
+Y71D11A.2	C18D11.4
+Y71F9B.4	C18D11.4
+Y71G12B.14	C18D11.4
+Y73B6BL.32	C18D11.4
+Y80D3A.2	C18D11.4
+Y92C3B.2	C18D11.4
+ZK1098.1	C18D11.4
+ZK1127.9	C18D11.4
+ZK328.2	C18D11.4
+ZK593.7	C18D11.4
+ZK652.1	C18D11.4
+ZK686.4	C18D11.4
+C34D4.12	C33H5.12
+C36B1.5	C33H5.12
+C43E11.1	C33H5.12
+C46F11.4	C33H5.12
+C50C3.6	C33H5.12
+C50D2.5	C33H5.12
+C50F2.3	C33H5.12
+C52E4.3	C33H5.12
+D1054.14	C33H5.12
+D1054.15	C33H5.12
+D1081.8	C33H5.12
+EEED8.5	C33H5.12
+EEED8.7	C33H5.12
+F01F1.7	C33H5.12
+F08B4.7	C33H5.12
+F08G12.2	C33H5.12
+F09D1.1	C33H5.12
+F11A10.2	C33H5.12
+F11F1.1	C33H5.12
+F19F10.9	C33H5.12
+F23B2.6	C33H5.12
+F26A3.2	C33H5.12
+F26B1.2	C33H5.12
+F26D10.3	C33H5.12
+F28F8.3	C33H5.12
+F32A5.7	C33H5.12
+F32B6.3	C33H5.12
+F32H2.4	C33H5.12
+F33D11.10	C33H5.12
+F37E3.1	C33H5.12
+F42A6.7	C33H5.12
+F44E5.4	C33H5.12
+F44E5.5	C33H5.12
+F49D11.1	C33H5.12
+F53B7.3	C33H5.12
+F53H1.1	C33H5.12
+F56D2.6	C33H5.12
+F58B3.7	C33H5.12
+F58E10.3	C33H5.12
+H20J04.8	C33H5.12
+K02F2.3	C33H5.12
+K03H1.2	C33H5.12
+K04G7.10	C33H5.12
+K04G7.11	C33H5.12
+K07C5.6	C33H5.12
+M01E11.2	C33H5.12
+M03C11.7	C33H5.12
+M03F8.3	C33H5.12
+M18.7	C33H5.12
+M28.5	C33H5.12
+R05D11.7	C33H5.12
+R07E5.14	C33H5.12
+R09B3.5	C33H5.12
+T01B7.4	C33H5.12
+T02H6.2	C33H5.12
+T08A11.2	C33H5.12
+T10C6.5	C33H5.12
+T10F2.4	C33H5.12
+T10G3.6	C33H5.12
+T11G6.8	C33H5.12
+T12A2.7	C33H5.12
+T13H5.4	C33H5.12
+T21D12.3	C33H5.12
+T27F2.1	C33H5.12
+T28D9.10	C33H5.12
+W02B12.2	C33H5.12
+W02B12.3	C33H5.12
+W03F9.10	C33H5.12
+W04D2.6	C33H5.12
+W07E6.4	C33H5.12
+W08E3.1	C33H5.12
+Y108G3AL.2	C33H5.12
+Y110A7A.8	C33H5.12
+Y111B2A.18	C33H5.12
+Y116A8C.34	C33H5.12
+Y116A8C.35	C33H5.12
+Y116A8C.42	C33H5.12
+Y46G5A.4	C33H5.12
+Y47G6A.20	C33H5.12
+Y49E10.15	C33H5.12
+Y54F10BM.14	C33H5.12
+Y59A8B.6	C33H5.12
+Y62E10A.12	C33H5.12
+Y65B4A.6	C33H5.12
+Y69A2AR.21	C33H5.12
+Y71D11A.2	C33H5.12
+Y71F9B.4	C33H5.12
+Y71G12B.14	C33H5.12
+Y73B6BL.32	C33H5.12
+Y80D3A.2	C33H5.12
+Y92C3B.2	C33H5.12
+ZK1098.1	C33H5.12
+ZK1127.9	C33H5.12
+ZK328.2	C33H5.12
+ZK593.7	C33H5.12
+ZK652.1	C33H5.12
+ZK686.4	C33H5.12
+C36B1.5	C34D4.12
+C43E11.1	C34D4.12
+C46F11.4	C34D4.12
+C50C3.6	C34D4.12
+C50D2.5	C34D4.12
+C50F2.3	C34D4.12
+C52E4.3	C34D4.12
+D1054.14	C34D4.12
+D1054.15	C34D4.12
+D1081.8	C34D4.12
+EEED8.5	C34D4.12
+EEED8.7	C34D4.12
+F01F1.7	C34D4.12
+F08B4.7	C34D4.12
+F08G12.2	C34D4.12
+F09D1.1	C34D4.12
+F11A10.2	C34D4.12
+F11F1.1	C34D4.12
+F19F10.9	C34D4.12
+F23B2.6	C34D4.12
+F26A3.2	C34D4.12
+F26B1.2	C34D4.12
+F26D10.3	C34D4.12
+F28F8.3	C34D4.12
+F32A5.7	C34D4.12
+F32B6.3	C34D4.12
+F32H2.4	C34D4.12
+F33D11.10	C34D4.12
+F37E3.1	C34D4.12
+F42A6.7	C34D4.12
+F44E5.4	C34D4.12
+F44E5.5	C34D4.12
+F49D11.1	C34D4.12
+F53B7.3	C34D4.12
+F53H1.1	C34D4.12
+F56D2.6	C34D4.12
+F58B3.7	C34D4.12
+F58E10.3	C34D4.12
+H20J04.8	C34D4.12
+K02F2.3	C34D4.12
+K03H1.2	C34D4.12
+K04G7.10	C34D4.12
+K04G7.11	C34D4.12
+K07C5.6	C34D4.12
+M01E11.2	C34D4.12
+M03C11.7	C34D4.12
+M03F8.3	C34D4.12
+M18.7	C34D4.12
+M28.5	C34D4.12
+R05D11.7	C34D4.12
+R07E5.14	C34D4.12
+R09B3.5	C34D4.12
+T01B7.4	C34D4.12
+T02H6.2	C34D4.12
+T08A11.2	C34D4.12
+T10C6.5	C34D4.12
+T10F2.4	C34D4.12
+T10G3.6	C34D4.12
+T11G6.8	C34D4.12
+T12A2.7	C34D4.12
+T13H5.4	C34D4.12
+T21D12.3	C34D4.12
+T27F2.1	C34D4.12
+T28D9.10	C34D4.12
+W02B12.2	C34D4.12
+W02B12.3	C34D4.12
+W03F9.10	C34D4.12
+W04D2.6	C34D4.12
+W07E6.4	C34D4.12
+W08E3.1	C34D4.12
+Y108G3AL.2	C34D4.12
+Y110A7A.8	C34D4.12
+Y111B2A.18	C34D4.12
+Y116A8C.34	C34D4.12
+Y116A8C.35	C34D4.12
+Y116A8C.42	C34D4.12
+Y46G5A.4	C34D4.12
+Y47G6A.20	C34D4.12
+Y49E10.15	C34D4.12
+Y54F10BM.14	C34D4.12
+Y59A8B.6	C34D4.12
+Y62E10A.12	C34D4.12
+Y65B4A.6	C34D4.12
+Y69A2AR.21	C34D4.12
+Y71D11A.2	C34D4.12
+Y71F9B.4	C34D4.12
+Y71G12B.14	C34D4.12
+Y73B6BL.32	C34D4.12
+Y80D3A.2	C34D4.12
+Y92C3B.2	C34D4.12
+ZK1098.1	C34D4.12
+ZK1127.9	C34D4.12
+ZK328.2	C34D4.12
+ZK593.7	C34D4.12
+ZK652.1	C34D4.12
+ZK686.4	C34D4.12
+C43E11.1	C36B1.5
+C46F11.4	C36B1.5
+C50C3.6	C36B1.5
+C50D2.5	C36B1.5
+C50F2.3	C36B1.5
+C52E4.3	C36B1.5
+D1054.14	C36B1.5
+D1054.15	C36B1.5
+D1081.8	C36B1.5
+EEED8.5	C36B1.5
+EEED8.7	C36B1.5
+F01F1.7	C36B1.5
+F08B4.7	C36B1.5
+F08G12.2	C36B1.5
+F09D1.1	C36B1.5
+F11A10.2	C36B1.5
+F11F1.1	C36B1.5
+F19F10.9	C36B1.5
+F23B2.6	C36B1.5
+F26A3.2	C36B1.5
+F26B1.2	C36B1.5
+F26D10.3	C36B1.5
+F28F8.3	C36B1.5
+F32A5.7	C36B1.5
+F32B6.3	C36B1.5
+F32H2.4	C36B1.5
+F33D11.10	C36B1.5
+F37E3.1	C36B1.5
+F42A6.7	C36B1.5
+F44E5.4	C36B1.5
+F44E5.5	C36B1.5
+F49D11.1	C36B1.5
+F53B7.3	C36B1.5
+F53H1.1	C36B1.5
+F56D2.6	C36B1.5
+F58B3.7	C36B1.5
+F58E10.3	C36B1.5
+H20J04.8	C36B1.5
+K02F2.3	C36B1.5
+K03H1.2	C36B1.5
+K04G7.10	C36B1.5
+K04G7.11	C36B1.5
+K07C5.6	C36B1.5
+M01E11.2	C36B1.5
+M03C11.7	C36B1.5
+M03F8.3	C36B1.5
+M18.7	C36B1.5
+M28.5	C36B1.5
+R05D11.7	C36B1.5
+R07E5.14	C36B1.5
+R09B3.5	C36B1.5
+T01B7.4	C36B1.5
+T02H6.2	C36B1.5
+T08A11.2	C36B1.5
+T10C6.5	C36B1.5
+T10F2.4	C36B1.5
+T10G3.6	C36B1.5
+T11G6.8	C36B1.5
+T12A2.7	C36B1.5
+T13H5.4	C36B1.5
+T21D12.3	C36B1.5
+T27F2.1	C36B1.5
+T28D9.10	C36B1.5
+W02B12.2	C36B1.5
+W02B12.3	C36B1.5
+W03F9.10	C36B1.5
+W04D2.6	C36B1.5
+W07E6.4	C36B1.5
+W08E3.1	C36B1.5
+Y108G3AL.2	C36B1.5
+Y110A7A.8	C36B1.5
+Y111B2A.18	C36B1.5
+Y116A8C.34	C36B1.5
+Y116A8C.35	C36B1.5
+Y116A8C.42	C36B1.5
+Y46G5A.4	C36B1.5
+Y47G6A.20	C36B1.5
+Y49E10.15	C36B1.5
+Y54F10BM.14	C36B1.5
+Y59A8B.6	C36B1.5
+Y62E10A.12	C36B1.5
+Y65B4A.6	C36B1.5
+Y69A2AR.21	C36B1.5
+Y71D11A.2	C36B1.5
+Y71F9B.4	C36B1.5
+Y71G12B.14	C36B1.5
+Y73B6BL.32	C36B1.5
+Y80D3A.2	C36B1.5
+Y92C3B.2	C36B1.5
+ZK1098.1	C36B1.5
+ZK1127.9	C36B1.5
+ZK328.2	C36B1.5
+ZK593.7	C36B1.5
+ZK652.1	C36B1.5
+ZK686.4	C36B1.5
+C46F11.4	C43E11.1
+C50C3.6	C43E11.1
+C50D2.5	C43E11.1
+C50F2.3	C43E11.1
+C52E4.3	C43E11.1
+D1054.14	C43E11.1
+D1054.15	C43E11.1
+D1081.8	C43E11.1
+EEED8.5	C43E11.1
+EEED8.7	C43E11.1
+F01F1.7	C43E11.1
+F08B4.7	C43E11.1
+F08G12.2	C43E11.1
+F09D1.1	C43E11.1
+F11A10.2	C43E11.1
+F11F1.1	C43E11.1
+F19F10.9	C43E11.1
+F26B1.2	C43E11.1
+F26D10.3	C43E11.1
+F28F8.3	C43E11.1
+F32A5.7	C43E11.1
+F32B6.3	C43E11.1
+F42A6.7	C43E11.1
+F44E5.4	C43E11.1
+F44E5.5	C43E11.1
+F49D11.1	C43E11.1
+F53B7.3	C43E11.1
+F53H1.1	C43E11.1
+F56D2.6	C43E11.1
+F58B3.7	C43E11.1
+F58E10.3	C43E11.1
+H20J04.8	C43E11.1
+K02F2.3	C43E11.1
+K03H1.2	C43E11.1
+K04G7.10	C43E11.1
+K04G7.11	C43E11.1
+K07C5.6	C43E11.1
+M01E11.2	C43E11.1
+M03C11.7	C43E11.1
+M03F8.3	C43E11.1
+M28.5	C43E11.1
+R05D11.7	C43E11.1
+T01B7.4	C43E11.1
+T08A11.2	C43E11.1
+T10C6.5	C43E11.1
+T10F2.4	C43E11.1
+T10G3.6	C43E11.1
+T11G6.8	C43E11.1
+T12A2.7	C43E11.1
+T13H5.4	C43E11.1
+T21D12.3	C43E11.1
+T27F2.1	C43E11.1
+T28D9.10	C43E11.1
+W02B12.2	C43E11.1
+W02B12.3	C43E11.1
+W03F9.10	C43E11.1
+W04D2.6	C43E11.1
+W07E6.4	C43E11.1
+W08E3.1	C43E11.1
+Y108G3AL.2	C43E11.1
+Y110A7A.8	C43E11.1
+Y111B2A.18	C43E11.1
+Y116A8C.34	C43E11.1
+Y116A8C.35	C43E11.1
+Y116A8C.42	C43E11.1
+Y46G5A.4	C43E11.1
+Y47G6A.20	C43E11.1
+Y49E10.15	C43E11.1
+Y54F10BM.14	C43E11.1
+Y59A8B.6	C43E11.1
+Y62E10A.12	C43E11.1
+Y69A2AR.21	C43E11.1
+Y71D11A.2	C43E11.1
+Y71F9B.4	C43E11.1
+Y71G12B.14	C43E11.1
+Y73B6BL.32	C43E11.1
+Y80D3A.2	C43E11.1
+Y92C3B.2	C43E11.1
+ZK1098.1	C43E11.1
+ZK1127.9	C43E11.1
+ZK328.2	C43E11.1
+ZK593.7	C43E11.1
+ZK652.1	C43E11.1
+ZK686.4	C43E11.1
+C50C3.6	C46F11.4
+C50D2.5	C46F11.4
+C50F2.3	C46F11.4
+C52E4.3	C46F11.4
+D1054.14	C46F11.4
+D1054.15	C46F11.4
+D1081.8	C46F11.4
+EEED8.5	C46F11.4
+EEED8.7	C46F11.4
+F01F1.7	C46F11.4
+F08B4.7	C46F11.4
+F08G12.2	C46F11.4
+F09D1.1	C46F11.4
+F11A10.2	C46F11.4
+F11F1.1	C46F11.4
+F19F10.9	C46F11.4
+F23B2.6	C46F11.4
+F26A3.2	C46F11.4
+F26B1.2	C46F11.4
+F26D10.3	C46F11.4
+F28F8.3	C46F11.4
+F32A5.7	C46F11.4
+F32B6.3	C46F11.4
+F32H2.4	C46F11.4
+F33D11.10	C46F11.4
+F37E3.1	C46F11.4
+F42A6.7	C46F11.4
+F44E5.4	C46F11.4
+F44E5.5	C46F11.4
+F49D11.1	C46F11.4
+F53B7.3	C46F11.4
+F53H1.1	C46F11.4
+F56D2.6	C46F11.4
+F58B3.7	C46F11.4
+F58E10.3	C46F11.4
+H20J04.8	C46F11.4
+K02F2.3	C46F11.4
+K03H1.2	C46F11.4
+K04G7.10	C46F11.4
+K04G7.11	C46F11.4
+K07C5.6	C46F11.4
+M01E11.2	C46F11.4
+M03C11.7	C46F11.4
+M03F8.3	C46F11.4
+M18.7	C46F11.4
+M28.5	C46F11.4
+R05D11.7	C46F11.4
+R07E5.14	C46F11.4
+R09B3.5	C46F11.4
+T01B7.4	C46F11.4
+T02H6.2	C46F11.4
+T08A11.2	C46F11.4
+T10C6.5	C46F11.4
+T10F2.4	C46F11.4
+T10G3.6	C46F11.4
+T11G6.8	C46F11.4
+T12A2.7	C46F11.4
+T13H5.4	C46F11.4
+T21D12.3	C46F11.4
+T27F2.1	C46F11.4
+T28D9.10	C46F11.4
+W02B12.2	C46F11.4
+W02B12.3	C46F11.4
+W03F9.10	C46F11.4
+W04D2.6	C46F11.4
+W07E6.4	C46F11.4
+W08E3.1	C46F11.4
+Y108G3AL.2	C46F11.4
+Y110A7A.8	C46F11.4
+Y111B2A.18	C46F11.4
+Y116A8C.34	C46F11.4
+Y116A8C.35	C46F11.4
+Y116A8C.42	C46F11.4
+Y46G5A.4	C46F11.4
+Y47G6A.20	C46F11.4
+Y49E10.15	C46F11.4
+Y54F10BM.14	C46F11.4
+Y59A8B.6	C46F11.4
+Y62E10A.12	C46F11.4
+Y65B4A.6	C46F11.4
+Y69A2AR.21	C46F11.4
+Y71D11A.2	C46F11.4
+Y71F9B.4	C46F11.4
+Y71G12B.14	C46F11.4
+Y73B6BL.32	C46F11.4
+Y80D3A.2	C46F11.4
+Y92C3B.2	C46F11.4
+ZK1098.1	C46F11.4
+ZK1127.9	C46F11.4
+ZK328.2	C46F11.4
+ZK593.7	C46F11.4
+ZK652.1	C46F11.4
+ZK686.4	C46F11.4
+C50D2.5	C50C3.6
+C50F2.3	C50C3.6
+C52E4.3	C50C3.6
+D1054.14	C50C3.6
+D1054.15	C50C3.6
+D1081.8	C50C3.6
+EEED8.5	C50C3.6
+EEED8.7	C50C3.6
+F01F1.7	C50C3.6
+F08B4.7	C50C3.6
+F08G12.2	C50C3.6
+F09D1.1	C50C3.6
+F11A10.2	C50C3.6
+F11F1.1	C50C3.6
+F19F10.9	C50C3.6
+F23B2.6	C50C3.6
+F26A3.2	C50C3.6
+F26B1.2	C50C3.6
+F26D10.3	C50C3.6
+F28F8.3	C50C3.6
+F32A5.7	C50C3.6
+F32B6.3	C50C3.6
+F32H2.4	C50C3.6
+F33D11.10	C50C3.6
+F37E3.1	C50C3.6
+F42A6.7	C50C3.6
+F44E5.4	C50C3.6
+F44E5.5	C50C3.6
+F49D11.1	C50C3.6
+F53B7.3	C50C3.6
+F53H1.1	C50C3.6
+F56D2.6	C50C3.6
+F58B3.7	C50C3.6
+F58E10.3	C50C3.6
+H20J04.8	C50C3.6
+K02F2.3	C50C3.6
+K03H1.2	C50C3.6
+K04G7.10	C50C3.6
+K04G7.11	C50C3.6
+K07C5.6	C50C3.6
+M01E11.2	C50C3.6
+M03C11.7	C50C3.6
+M03F8.3	C50C3.6
+M18.7	C50C3.6
+M28.5	C50C3.6
+R05D11.7	C50C3.6
+R07E5.14	C50C3.6
+R09B3.5	C50C3.6
+T01B7.4	C50C3.6
+T02H6.2	C50C3.6
+T08A11.2	C50C3.6
+T10C6.5	C50C3.6
+T10F2.4	C50C3.6
+T10G3.6	C50C3.6
+T11G6.8	C50C3.6
+T12A2.7	C50C3.6
+T13H5.4	C50C3.6
+T21D12.3	C50C3.6
+T27F2.1	C50C3.6
+T28D9.10	C50C3.6
+W02B12.2	C50C3.6
+W02B12.3	C50C3.6
+W03F9.10	C50C3.6
+W04D2.6	C50C3.6
+W07E6.4	C50C3.6
+W08E3.1	C50C3.6
+Y108G3AL.2	C50C3.6
+Y110A7A.8	C50C3.6
+Y111B2A.18	C50C3.6
+Y116A8C.34	C50C3.6
+Y116A8C.35	C50C3.6
+Y116A8C.42	C50C3.6
+Y46G5A.4	C50C3.6
+Y47G6A.20	C50C3.6
+Y49E10.15	C50C3.6
+Y54F10BM.14	C50C3.6
+Y59A8B.6	C50C3.6
+Y62E10A.12	C50C3.6
+Y65B4A.6	C50C3.6
+Y69A2AR.21	C50C3.6
+Y71D11A.2	C50C3.6
+Y71F9B.4	C50C3.6
+Y71G12B.14	C50C3.6
+Y73B6BL.32	C50C3.6
+Y80D3A.2	C50C3.6
+Y92C3B.2	C50C3.6
+ZK1098.1	C50C3.6
+ZK1127.9	C50C3.6
+ZK328.2	C50C3.6
+ZK593.7	C50C3.6
+ZK652.1	C50C3.6
+ZK686.4	C50C3.6
+C50F2.3	C50D2.5
+C52E4.3	C50D2.5
+D1054.14	C50D2.5
+D1054.15	C50D2.5
+D1081.8	C50D2.5
+EEED8.5	C50D2.5
+EEED8.7	C50D2.5
+F01F1.7	C50D2.5
+F08B4.7	C50D2.5
+F08G12.2	C50D2.5
+F09D1.1	C50D2.5
+F11A10.2	C50D2.5
+F11F1.1	C50D2.5
+F19F10.9	C50D2.5
+F23B2.6	C50D2.5
+F26A3.2	C50D2.5
+F26B1.2	C50D2.5
+F26D10.3	C50D2.5
+F28F8.3	C50D2.5
+F32A5.7	C50D2.5
+F32B6.3	C50D2.5
+F32H2.4	C50D2.5
+F33D11.10	C50D2.5
+F37E3.1	C50D2.5
+F42A6.7	C50D2.5
+F44E5.4	C50D2.5
+F44E5.5	C50D2.5
+F49D11.1	C50D2.5
+F53B7.3	C50D2.5
+F53H1.1	C50D2.5
+F56D2.6	C50D2.5
+F58B3.7	C50D2.5
+F58E10.3	C50D2.5
+H20J04.8	C50D2.5
+K02F2.3	C50D2.5
+K03H1.2	C50D2.5
+K04G7.10	C50D2.5
+K04G7.11	C50D2.5
+K07C5.6	C50D2.5
+M01E11.2	C50D2.5
+M03C11.7	C50D2.5
+M03F8.3	C50D2.5
+M18.7	C50D2.5
+M28.5	C50D2.5
+R05D11.7	C50D2.5
+R07E5.14	C50D2.5
+R09B3.5	C50D2.5
+T01B7.4	C50D2.5
+T02H6.2	C50D2.5
+T08A11.2	C50D2.5
+T10C6.5	C50D2.5
+T10F2.4	C50D2.5
+T10G3.6	C50D2.5
+T11G6.8	C50D2.5
+T12A2.7	C50D2.5
+T13H5.4	C50D2.5
+T21D12.3	C50D2.5
+T27F2.1	C50D2.5
+T28D9.10	C50D2.5
+W02B12.2	C50D2.5
+W02B12.3	C50D2.5
+W03F9.10	C50D2.5
+W04D2.6	C50D2.5
+W07E6.4	C50D2.5
+W08E3.1	C50D2.5
+Y108G3AL.2	C50D2.5
+Y110A7A.8	C50D2.5
+Y111B2A.18	C50D2.5
+Y116A8C.34	C50D2.5
+Y116A8C.35	C50D2.5
+Y116A8C.42	C50D2.5
+Y46G5A.4	C50D2.5
+Y47G6A.20	C50D2.5
+Y49E10.15	C50D2.5
+Y54F10BM.14	C50D2.5
+Y59A8B.6	C50D2.5
+Y62E10A.12	C50D2.5
+Y65B4A.6	C50D2.5
+Y69A2AR.21	C50D2.5
+Y71D11A.2	C50D2.5
+Y71F9B.4	C50D2.5
+Y71G12B.14	C50D2.5
+Y73B6BL.32	C50D2.5
+Y80D3A.2	C50D2.5
+Y92C3B.2	C50D2.5
+ZK1098.1	C50D2.5
+ZK1127.9	C50D2.5
+ZK328.2	C50D2.5
+ZK593.7	C50D2.5
+ZK652.1	C50D2.5
+ZK686.4	C50D2.5
+C52E4.3	C50F2.3
+D1054.14	C50F2.3
+D1054.15	C50F2.3
+D1081.8	C50F2.3
+EEED8.5	C50F2.3
+EEED8.7	C50F2.3
+F01F1.7	C50F2.3
+F08B4.7	C50F2.3
+F08G12.2	C50F2.3
+F09D1.1	C50F2.3
+F11A10.2	C50F2.3
+F11F1.1	C50F2.3
+F19F10.9	C50F2.3
+F23B2.6	C50F2.3
+F26A3.2	C50F2.3
+F26B1.2	C50F2.3
+F26D10.3	C50F2.3
+F28F8.3	C50F2.3
+F32A5.7	C50F2.3
+F32B6.3	C50F2.3
+F32H2.4	C50F2.3
+F33D11.10	C50F2.3
+F37E3.1	C50F2.3
+F42A6.7	C50F2.3
+F44E5.4	C50F2.3
+F44E5.5	C50F2.3
+F49D11.1	C50F2.3
+F53B7.3	C50F2.3
+F53H1.1	C50F2.3
+F56D2.6	C50F2.3
+F58B3.7	C50F2.3
+F58E10.3	C50F2.3
+H20J04.8	C50F2.3
+K02F2.3	C50F2.3
+K03H1.2	C50F2.3
+K04G7.10	C50F2.3
+K04G7.11	C50F2.3
+K07C5.6	C50F2.3
+M01E11.2	C50F2.3
+M03C11.7	C50F2.3
+M03F8.3	C50F2.3
+M18.7	C50F2.3
+M28.5	C50F2.3
+R05D11.7	C50F2.3
+R07E5.14	C50F2.3
+R09B3.5	C50F2.3
+T01B7.4	C50F2.3
+T02H6.2	C50F2.3
+T08A11.2	C50F2.3
+T10C6.5	C50F2.3
+T10F2.4	C50F2.3
+T10G3.6	C50F2.3
+T11G6.8	C50F2.3
+T12A2.7	C50F2.3
+T13H5.4	C50F2.3
+T21D12.3	C50F2.3
+T27F2.1	C50F2.3
+T28D9.10	C50F2.3
+W02B12.2	C50F2.3
+W02B12.3	C50F2.3
+W03F9.10	C50F2.3
+W04D2.6	C50F2.3
+W07E6.4	C50F2.3
+W08E3.1	C50F2.3
+Y108G3AL.2	C50F2.3
+Y110A7A.8	C50F2.3
+Y111B2A.18	C50F2.3
+Y116A8C.34	C50F2.3
+Y116A8C.35	C50F2.3
+Y116A8C.42	C50F2.3
+Y46G5A.4	C50F2.3
+Y47G6A.20	C50F2.3
+Y49E10.15	C50F2.3
+Y54F10BM.14	C50F2.3
+Y59A8B.6	C50F2.3
+Y62E10A.12	C50F2.3
+Y65B4A.6	C50F2.3
+Y69A2AR.21	C50F2.3
+Y71D11A.2	C50F2.3
+Y71F9B.4	C50F2.3
+Y71G12B.14	C50F2.3
+Y73B6BL.32	C50F2.3
+Y80D3A.2	C50F2.3
+Y92C3B.2	C50F2.3
+ZK1098.1	C50F2.3
+ZK1127.9	C50F2.3
+ZK328.2	C50F2.3
+ZK593.7	C50F2.3
+ZK652.1	C50F2.3
+ZK686.4	C50F2.3
+D1054.14	C52E4.3
+D1054.15	C52E4.3
+D1081.8	C52E4.3
+EEED8.5	C52E4.3
+EEED8.7	C52E4.3
+F01F1.7	C52E4.3
+F08B4.7	C52E4.3
+F08G12.2	C52E4.3
+F09D1.1	C52E4.3
+F11A10.2	C52E4.3
+F11F1.1	C52E4.3
+F19F10.9	C52E4.3
+F23B2.6	C52E4.3
+F26A3.2	C52E4.3
+F26B1.2	C52E4.3
+F26D10.3	C52E4.3
+F28F8.3	C52E4.3
+F32A5.7	C52E4.3
+F32B6.3	C52E4.3
+F32H2.4	C52E4.3
+F33D11.10	C52E4.3
+F37E3.1	C52E4.3
+F42A6.7	C52E4.3
+F44E5.4	C52E4.3
+F44E5.5	C52E4.3
+F49D11.1	C52E4.3
+F53B7.3	C52E4.3
+F53H1.1	C52E4.3
+F56D2.6	C52E4.3
+F58B3.7	C52E4.3
+F58E10.3	C52E4.3
+H20J04.8	C52E4.3
+K02F2.3	C52E4.3
+K03H1.2	C52E4.3
+K04G7.10	C52E4.3
+K04G7.11	C52E4.3
+K07C5.6	C52E4.3
+M01E11.2	C52E4.3
+M03C11.7	C52E4.3
+M03F8.3	C52E4.3
+M18.7	C52E4.3
+M28.5	C52E4.3
+R05D11.7	C52E4.3
+R07E5.14	C52E4.3
+R09B3.5	C52E4.3
+T01B7.4	C52E4.3
+T02H6.2	C52E4.3
+T08A11.2	C52E4.3
+T10C6.5	C52E4.3
+T10F2.4	C52E4.3
+T10G3.6	C52E4.3
+T11G6.8	C52E4.3
+T12A2.7	C52E4.3
+T13H5.4	C52E4.3
+T21D12.3	C52E4.3
+T27F2.1	C52E4.3
+T28D9.10	C52E4.3
+W02B12.2	C52E4.3
+W02B12.3	C52E4.3
+W03F9.10	C52E4.3
+W04D2.6	C52E4.3
+W07E6.4	C52E4.3
+W08E3.1	C52E4.3
+Y108G3AL.2	C52E4.3
+Y110A7A.8	C52E4.3
+Y111B2A.18	C52E4.3
+Y116A8C.34	C52E4.3
+Y116A8C.35	C52E4.3
+Y116A8C.42	C52E4.3
+Y46G5A.4	C52E4.3
+Y47G6A.20	C52E4.3
+Y49E10.15	C52E4.3
+Y54F10BM.14	C52E4.3
+Y59A8B.6	C52E4.3
+Y62E10A.12	C52E4.3
+Y65B4A.6	C52E4.3
+Y69A2AR.21	C52E4.3
+Y71D11A.2	C52E4.3
+Y71F9B.4	C52E4.3
+Y71G12B.14	C52E4.3
+Y73B6BL.32	C52E4.3
+Y80D3A.2	C52E4.3
+Y92C3B.2	C52E4.3
+ZK1098.1	C52E4.3
+ZK1127.9	C52E4.3
+ZK328.2	C52E4.3
+ZK593.7	C52E4.3
+ZK652.1	C52E4.3
+ZK686.4	C52E4.3
+D1054.15	D1054.14
+D1081.8	D1054.14
+EEED8.5	D1054.14
+EEED8.7	D1054.14
+F01F1.7	D1054.14
+F08B4.7	D1054.14
+F08G12.2	D1054.14
+F09D1.1	D1054.14
+F11A10.2	D1054.14
+F11F1.1	D1054.14
+F19F10.9	D1054.14
+F23B2.6	D1054.14
+F26A3.2	D1054.14
+F26B1.2	D1054.14
+F26D10.3	D1054.14
+F28F8.3	D1054.14
+F32A5.7	D1054.14
+F32B6.3	D1054.14
+F32H2.4	D1054.14
+F33D11.10	D1054.14
+F37E3.1	D1054.14
+F42A6.7	D1054.14
+F44E5.4	D1054.14
+F44E5.5	D1054.14
+F49D11.1	D1054.14
+F53B7.3	D1054.14
+F53H1.1	D1054.14
+F56D2.6	D1054.14
+F58B3.7	D1054.14
+F58E10.3	D1054.14
+H20J04.8	D1054.14
+K02F2.3	D1054.14
+K03H1.2	D1054.14
+K04G7.10	D1054.14
+K04G7.11	D1054.14
+K07C5.6	D1054.14
+M01E11.2	D1054.14
+M03C11.7	D1054.14
+M03F8.3	D1054.14
+M18.7	D1054.14
+M28.5	D1054.14
+R05D11.7	D1054.14
+R07E5.14	D1054.14
+R09B3.5	D1054.14
+T01B7.4	D1054.14
+T02H6.2	D1054.14
+T08A11.2	D1054.14
+T10C6.5	D1054.14
+T10F2.4	D1054.14
+T10G3.6	D1054.14
+T11G6.8	D1054.14
+T12A2.7	D1054.14
+T13H5.4	D1054.14
+T21D12.3	D1054.14
+T27F2.1	D1054.14
+T28D9.10	D1054.14
+W02B12.2	D1054.14
+W02B12.3	D1054.14
+W03F9.10	D1054.14
+W04D2.6	D1054.14
+W07E6.4	D1054.14
+W08E3.1	D1054.14
+Y108G3AL.2	D1054.14
+Y110A7A.8	D1054.14
+Y111B2A.18	D1054.14
+Y116A8C.34	D1054.14
+Y116A8C.35	D1054.14
+Y116A8C.42	D1054.14
+Y46G5A.4	D1054.14
+Y47G6A.20	D1054.14
+Y49E10.15	D1054.14
+Y54F10BM.14	D1054.14
+Y59A8B.6	D1054.14
+Y62E10A.12	D1054.14
+Y65B4A.6	D1054.14
+Y69A2AR.21	D1054.14
+Y71D11A.2	D1054.14
+Y71F9B.4	D1054.14
+Y71G12B.14	D1054.14
+Y73B6BL.32	D1054.14
+Y80D3A.2	D1054.14
+Y92C3B.2	D1054.14
+ZK1098.1	D1054.14
+ZK1127.9	D1054.14
+ZK328.2	D1054.14
+ZK593.7	D1054.14
+ZK652.1	D1054.14
+ZK686.4	D1054.14
+D1081.8	D1054.15
+EEED8.5	D1054.15
+EEED8.7	D1054.15
+F01F1.7	D1054.15
+F08B4.7	D1054.15
+F08G12.2	D1054.15
+F09D1.1	D1054.15
+F11A10.2	D1054.15
+F11F1.1	D1054.15
+F19F10.9	D1054.15
+F23B2.6	D1054.15
+F26A3.2	D1054.15
+F26B1.2	D1054.15
+F26D10.3	D1054.15
+F28F8.3	D1054.15
+F32A5.7	D1054.15
+F32B6.3	D1054.15
+F32H2.4	D1054.15
+F33D11.10	D1054.15
+F37E3.1	D1054.15
+F42A6.7	D1054.15
+F44E5.4	D1054.15
+F44E5.5	D1054.15
+F49D11.1	D1054.15
+F53B7.3	D1054.15
+F53H1.1	D1054.15
+F56D2.6	D1054.15
+F58B3.7	D1054.15
+F58E10.3	D1054.15
+H20J04.8	D1054.15
+K02F2.3	D1054.15
+K03H1.2	D1054.15
+K04G7.10	D1054.15
+K04G7.11	D1054.15
+K07C5.6	D1054.15
+M01E11.2	D1054.15
+M03C11.7	D1054.15
+M03F8.3	D1054.15
+M18.7	D1054.15
+M28.5	D1054.15
+R05D11.7	D1054.15
+R07E5.14	D1054.15
+R09B3.5	D1054.15
+T01B7.4	D1054.15
+T02H6.2	D1054.15
+T08A11.2	D1054.15
+T10C6.5	D1054.15
+T10F2.4	D1054.15
+T10G3.6	D1054.15
+T11G6.8	D1054.15
+T12A2.7	D1054.15
+T13H5.4	D1054.15
+T21D12.3	D1054.15
+T27F2.1	D1054.15
+T28D9.10	D1054.15
+W02B12.2	D1054.15
+W02B12.3	D1054.15
+W03F9.10	D1054.15
+W04D2.6	D1054.15
+W07E6.4	D1054.15
+W08E3.1	D1054.15
+Y108G3AL.2	D1054.15
+Y110A7A.8	D1054.15
+Y111B2A.18	D1054.15
+Y116A8C.34	D1054.15
+Y116A8C.35	D1054.15
+Y116A8C.42	D1054.15
+Y46G5A.4	D1054.15
+Y47G6A.20	D1054.15
+Y49E10.15	D1054.15
+Y54F10BM.14	D1054.15
+Y59A8B.6	D1054.15
+Y62E10A.12	D1054.15
+Y65B4A.6	D1054.15
+Y69A2AR.21	D1054.15
+Y71D11A.2	D1054.15
+Y71F9B.4	D1054.15
+Y71G12B.14	D1054.15
+Y73B6BL.32	D1054.15
+Y80D3A.2	D1054.15
+Y92C3B.2	D1054.15
+ZK1098.1	D1054.15
+ZK1127.9	D1054.15
+ZK328.2	D1054.15
+ZK593.7	D1054.15
+ZK652.1	D1054.15
+ZK686.4	D1054.15
+EEED8.5	D1081.8
+EEED8.7	D1081.8
+F01F1.7	D1081.8
+F08B4.7	D1081.8
+F08G12.2	D1081.8
+F09D1.1	D1081.8
+F11A10.2	D1081.8
+F11F1.1	D1081.8
+F19F10.9	D1081.8
+F23B2.6	D1081.8
+F26A3.2	D1081.8
+F26B1.2	D1081.8
+F26D10.3	D1081.8
+F28F8.3	D1081.8
+F32A5.7	D1081.8
+F32B6.3	D1081.8
+F32H2.4	D1081.8
+F33D11.10	D1081.8
+F37E3.1	D1081.8
+F42A6.7	D1081.8
+F44E5.4	D1081.8
+F44E5.5	D1081.8
+F49D11.1	D1081.8
+F53B7.3	D1081.8
+F53H1.1	D1081.8
+F56D2.6	D1081.8
+F58B3.7	D1081.8
+F58E10.3	D1081.8
+H20J04.8	D1081.8
+K02F2.3	D1081.8
+K03H1.2	D1081.8
+K04G7.10	D1081.8
+K04G7.11	D1081.8
+K07C5.6	D1081.8
+M01E11.2	D1081.8
+M03C11.7	D1081.8
+M03F8.3	D1081.8
+M18.7	D1081.8
+M28.5	D1081.8
+R05D11.7	D1081.8
+R07E5.14	D1081.8
+R09B3.5	D1081.8
+T01B7.4	D1081.8
+T02H6.2	D1081.8
+T08A11.2	D1081.8
+T10C6.5	D1081.8
+T10F2.4	D1081.8
+T10G3.6	D1081.8
+T11G6.8	D1081.8
+T12A2.7	D1081.8
+T13H5.4	D1081.8
+T21D12.3	D1081.8
+T27F2.1	D1081.8
+T28D9.10	D1081.8
+W02B12.2	D1081.8
+W02B12.3	D1081.8
+W03F9.10	D1081.8
+W04D2.6	D1081.8
+W07E6.4	D1081.8
+W08E3.1	D1081.8
+Y108G3AL.2	D1081.8
+Y110A7A.8	D1081.8
+Y111B2A.18	D1081.8
+Y116A8C.34	D1081.8
+Y116A8C.35	D1081.8
+Y116A8C.42	D1081.8
+Y46G5A.4	D1081.8
+Y47G6A.20	D1081.8
+Y49E10.15	D1081.8
+Y54F10BM.14	D1081.8
+Y59A8B.6	D1081.8
+Y62E10A.12	D1081.8
+Y65B4A.6	D1081.8
+Y69A2AR.21	D1081.8
+Y71D11A.2	D1081.8
+Y71F9B.4	D1081.8
+Y71G12B.14	D1081.8
+Y73B6BL.32	D1081.8
+Y80D3A.2	D1081.8
+Y92C3B.2	D1081.8
+ZK1098.1	D1081.8
+ZK1127.9	D1081.8
+ZK328.2	D1081.8
+ZK593.7	D1081.8
+ZK652.1	D1081.8
+ZK686.4	D1081.8
+EEED8.7	EEED8.5
+F01F1.7	EEED8.5
+F08B4.7	EEED8.5
+F08G12.2	EEED8.5
+F09D1.1	EEED8.5
+F11A10.2	EEED8.5
+F11F1.1	EEED8.5
+F19F10.9	EEED8.5
+F23B2.6	EEED8.5
+F26A3.2	EEED8.5
+F26B1.2	EEED8.5
+F26D10.3	EEED8.5
+F28F8.3	EEED8.5
+F32A5.7	EEED8.5
+F32B6.3	EEED8.5
+F32H2.4	EEED8.5
+F33D11.10	EEED8.5
+F37E3.1	EEED8.5
+F42A6.7	EEED8.5
+F44E5.4	EEED8.5
+F44E5.5	EEED8.5
+F49D11.1	EEED8.5
+F53B7.3	EEED8.5
+F53H1.1	EEED8.5
+F56D2.6	EEED8.5
+F58B3.7	EEED8.5
+F58E10.3	EEED8.5
+H20J04.8	EEED8.5
+K02F2.3	EEED8.5
+K03H1.2	EEED8.5
+K04G7.10	EEED8.5
+K04G7.11	EEED8.5
+K07C5.6	EEED8.5
+M01E11.2	EEED8.5
+M03C11.7	EEED8.5
+M03F8.3	EEED8.5
+M18.7	EEED8.5
+M28.5	EEED8.5
+R05D11.7	EEED8.5
+R07E5.14	EEED8.5
+R09B3.5	EEED8.5
+T01B7.4	EEED8.5
+T02H6.2	EEED8.5
+T08A11.2	EEED8.5
+T10C6.5	EEED8.5
+T10F2.4	EEED8.5
+T10G3.6	EEED8.5
+T11G6.8	EEED8.5
+T12A2.7	EEED8.5
+T13H5.4	EEED8.5
+T21D12.3	EEED8.5
+T27F2.1	EEED8.5
+T28D9.10	EEED8.5
+W02B12.2	EEED8.5
+W02B12.3	EEED8.5
+W03F9.10	EEED8.5
+W04D2.6	EEED8.5
+W07E6.4	EEED8.5
+W08E3.1	EEED8.5
+Y108G3AL.2	EEED8.5
+Y110A7A.8	EEED8.5
+Y111B2A.18	EEED8.5
+Y116A8C.34	EEED8.5
+Y116A8C.35	EEED8.5
+Y116A8C.42	EEED8.5
+Y46G5A.4	EEED8.5
+Y47G6A.20	EEED8.5
+Y49E10.15	EEED8.5
+Y54F10BM.14	EEED8.5
+Y59A8B.6	EEED8.5
+Y62E10A.12	EEED8.5
+Y65B4A.6	EEED8.5
+Y69A2AR.21	EEED8.5
+Y71D11A.2	EEED8.5
+Y71F9B.4	EEED8.5
+Y71G12B.14	EEED8.5
+Y73B6BL.32	EEED8.5
+Y80D3A.2	EEED8.5
+Y92C3B.2	EEED8.5
+ZK1098.1	EEED8.5
+ZK1127.9	EEED8.5
+ZK328.2	EEED8.5
+ZK593.7	EEED8.5
+ZK652.1	EEED8.5
+ZK686.4	EEED8.5
+F01F1.7	EEED8.7
+F08B4.7	EEED8.7
+F08G12.2	EEED8.7
+F09D1.1	EEED8.7
+F11A10.2	EEED8.7
+F11F1.1	EEED8.7
+F19F10.9	EEED8.7
+F23B2.6	EEED8.7
+F26A3.2	EEED8.7
+F26B1.2	EEED8.7
+F26D10.3	EEED8.7
+F28F8.3	EEED8.7
+F32A5.7	EEED8.7
+F32B6.3	EEED8.7
+F32H2.4	EEED8.7
+F33D11.10	EEED8.7
+F37E3.1	EEED8.7
+F42A6.7	EEED8.7
+F44E5.4	EEED8.7
+F44E5.5	EEED8.7
+F49D11.1	EEED8.7
+F53B7.3	EEED8.7
+F53H1.1	EEED8.7
+F56D2.6	EEED8.7
+F58B3.7	EEED8.7
+F58E10.3	EEED8.7
+H20J04.8	EEED8.7
+K02F2.3	EEED8.7
+K03H1.2	EEED8.7
+K04G7.10	EEED8.7
+K04G7.11	EEED8.7
+K07C5.6	EEED8.7
+M01E11.2	EEED8.7
+M03C11.7	EEED8.7
+M03F8.3	EEED8.7
+M18.7	EEED8.7
+M28.5	EEED8.7
+R05D11.7	EEED8.7
+R07E5.14	EEED8.7
+R09B3.5	EEED8.7
+T01B7.4	EEED8.7
+T02H6.2	EEED8.7
+T08A11.2	EEED8.7
+T10C6.5	EEED8.7
+T10F2.4	EEED8.7
+T10G3.6	EEED8.7
+T11G6.8	EEED8.7
+T12A2.7	EEED8.7
+T13H5.4	EEED8.7
+T21D12.3	EEED8.7
+T27F2.1	EEED8.7
+T28D9.10	EEED8.7
+W02B12.2	EEED8.7
+W02B12.3	EEED8.7
+W03F9.10	EEED8.7
+W04D2.6	EEED8.7
+W07E6.4	EEED8.7
+W08E3.1	EEED8.7
+Y108G3AL.2	EEED8.7
+Y110A7A.8	EEED8.7
+Y111B2A.18	EEED8.7
+Y116A8C.34	EEED8.7
+Y116A8C.35	EEED8.7
+Y116A8C.42	EEED8.7
+Y46G5A.4	EEED8.7
+Y47G6A.20	EEED8.7
+Y49E10.15	EEED8.7
+Y54F10BM.14	EEED8.7
+Y59A8B.6	EEED8.7
+Y62E10A.12	EEED8.7
+Y65B4A.6	EEED8.7
+Y69A2AR.21	EEED8.7
+Y71D11A.2	EEED8.7
+Y71F9B.4	EEED8.7
+Y71G12B.14	EEED8.7
+Y73B6BL.32	EEED8.7
+Y80D3A.2	EEED8.7
+Y92C3B.2	EEED8.7
+ZK1098.1	EEED8.7
+ZK1127.9	EEED8.7
+ZK328.2	EEED8.7
+ZK593.7	EEED8.7
+ZK652.1	EEED8.7
+ZK686.4	EEED8.7
+F08B4.7	F01F1.7
+F08G12.2	F01F1.7
+F09D1.1	F01F1.7
+F11A10.2	F01F1.7
+F11F1.1	F01F1.7
+F19F10.9	F01F1.7
+F23B2.6	F01F1.7
+F26A3.2	F01F1.7
+F26B1.2	F01F1.7
+F26D10.3	F01F1.7
+F28F8.3	F01F1.7
+F32A5.7	F01F1.7
+F32B6.3	F01F1.7
+F32H2.4	F01F1.7
+F33D11.10	F01F1.7
+F37E3.1	F01F1.7
+F42A6.7	F01F1.7
+F44E5.4	F01F1.7
+F44E5.5	F01F1.7
+F49D11.1	F01F1.7
+F53B7.3	F01F1.7
+F53H1.1	F01F1.7
+F56D2.6	F01F1.7
+F58B3.7	F01F1.7
+F58E10.3	F01F1.7
+H20J04.8	F01F1.7
+K02F2.3	F01F1.7
+K03H1.2	F01F1.7
+K04G7.10	F01F1.7
+K04G7.11	F01F1.7
+K07C5.6	F01F1.7
+M01E11.2	F01F1.7
+M03C11.7	F01F1.7
+M03F8.3	F01F1.7
+M18.7	F01F1.7
+M28.5	F01F1.7
+R05D11.7	F01F1.7
+R07E5.14	F01F1.7
+R09B3.5	F01F1.7
+T01B7.4	F01F1.7
+T02H6.2	F01F1.7
+T08A11.2	F01F1.7
+T10C6.5	F01F1.7
+T10F2.4	F01F1.7
+T10G3.6	F01F1.7
+T11G6.8	F01F1.7
+T12A2.7	F01F1.7
+T13H5.4	F01F1.7
+T21D12.3	F01F1.7
+T27F2.1	F01F1.7
+T28D9.10	F01F1.7
+W02B12.2	F01F1.7
+W02B12.3	F01F1.7
+W03F9.10	F01F1.7
+W04D2.6	F01F1.7
+W07E6.4	F01F1.7
+W08E3.1	F01F1.7
+Y108G3AL.2	F01F1.7
+Y110A7A.8	F01F1.7
+Y111B2A.18	F01F1.7
+Y116A8C.34	F01F1.7
+Y116A8C.35	F01F1.7
+Y116A8C.42	F01F1.7
+Y46G5A.4	F01F1.7
+Y47G6A.20	F01F1.7
+Y49E10.15	F01F1.7
+Y54F10BM.14	F01F1.7
+Y59A8B.6	F01F1.7
+Y62E10A.12	F01F1.7
+Y65B4A.6	F01F1.7
+Y69A2AR.21	F01F1.7
+Y71D11A.2	F01F1.7
+Y71F9B.4	F01F1.7
+Y71G12B.14	F01F1.7
+Y73B6BL.32	F01F1.7
+Y80D3A.2	F01F1.7
+Y92C3B.2	F01F1.7
+ZK1098.1	F01F1.7
+ZK1127.9	F01F1.7
+ZK328.2	F01F1.7
+ZK593.7	F01F1.7
+ZK652.1	F01F1.7
+ZK686.4	F01F1.7
+F08G12.2	F08B4.7
+F09D1.1	F08B4.7
+F11A10.2	F08B4.7
+F11F1.1	F08B4.7
+F19F10.9	F08B4.7
+F23B2.6	F08B4.7
+F26A3.2	F08B4.7
+F26B1.2	F08B4.7
+F26D10.3	F08B4.7
+F28F8.3	F08B4.7
+F32A5.7	F08B4.7
+F32B6.3	F08B4.7
+F32H2.4	F08B4.7
+F33D11.10	F08B4.7
+F37E3.1	F08B4.7
+F42A6.7	F08B4.7
+F44E5.4	F08B4.7
+F44E5.5	F08B4.7
+F49D11.1	F08B4.7
+F53B7.3	F08B4.7
+F53H1.1	F08B4.7
+F56D2.6	F08B4.7
+F58B3.7	F08B4.7
+F58E10.3	F08B4.7
+H20J04.8	F08B4.7
+K02F2.3	F08B4.7
+K03H1.2	F08B4.7
+K04G7.10	F08B4.7
+K04G7.11	F08B4.7
+K07C5.6	F08B4.7
+M01E11.2	F08B4.7
+M03C11.7	F08B4.7
+M03F8.3	F08B4.7
+M18.7	F08B4.7
+M28.5	F08B4.7
+R05D11.7	F08B4.7
+R07E5.14	F08B4.7
+R09B3.5	F08B4.7
+T01B7.4	F08B4.7
+T02H6.2	F08B4.7
+T08A11.2	F08B4.7
+T10C6.5	F08B4.7
+T10F2.4	F08B4.7
+T10G3.6	F08B4.7
+T11G6.8	F08B4.7
+T12A2.7	F08B4.7
+T13H5.4	F08B4.7
+T21D12.3	F08B4.7
+T27F2.1	F08B4.7
+T28D9.10	F08B4.7
+W02B12.2	F08B4.7
+W02B12.3	F08B4.7
+W03F9.10	F08B4.7
+W04D2.6	F08B4.7
+W07E6.4	F08B4.7
+W08E3.1	F08B4.7
+Y108G3AL.2	F08B4.7
+Y110A7A.8	F08B4.7
+Y111B2A.18	F08B4.7
+Y116A8C.34	F08B4.7
+Y116A8C.35	F08B4.7
+Y116A8C.42	F08B4.7
+Y46G5A.4	F08B4.7
+Y47G6A.20	F08B4.7
+Y49E10.15	F08B4.7
+Y54F10BM.14	F08B4.7
+Y59A8B.6	F08B4.7
+Y62E10A.12	F08B4.7
+Y65B4A.6	F08B4.7
+Y69A2AR.21	F08B4.7
+Y71D11A.2	F08B4.7
+Y71F9B.4	F08B4.7
+Y71G12B.14	F08B4.7
+Y73B6BL.32	F08B4.7
+Y80D3A.2	F08B4.7
+Y92C3B.2	F08B4.7
+ZK1098.1	F08B4.7
+ZK1127.9	F08B4.7
+ZK328.2	F08B4.7
+ZK593.7	F08B4.7
+ZK652.1	F08B4.7
+ZK686.4	F08B4.7
+F09D1.1	F08G12.2
+F11A10.2	F08G12.2
+F11F1.1	F08G12.2
+F19F10.9	F08G12.2
+F23B2.6	F08G12.2
+F26A3.2	F08G12.2
+F26B1.2	F08G12.2
+F26D10.3	F08G12.2
+F28F8.3	F08G12.2
+F32A5.7	F08G12.2
+F32B6.3	F08G12.2
+F32H2.4	F08G12.2
+F33D11.10	F08G12.2
+F37E3.1	F08G12.2
+F42A6.7	F08G12.2
+F44E5.4	F08G12.2
+F44E5.5	F08G12.2
+F49D11.1	F08G12.2
+F53B7.3	F08G12.2
+F53H1.1	F08G12.2
+F56D2.6	F08G12.2
+F58B3.7	F08G12.2
+F58E10.3	F08G12.2
+H20J04.8	F08G12.2
+K02F2.3	F08G12.2
+K03H1.2	F08G12.2
+K04G7.10	F08G12.2
+K04G7.11	F08G12.2
+K07C5.6	F08G12.2
+M01E11.2	F08G12.2
+M03C11.7	F08G12.2
+M03F8.3	F08G12.2
+M18.7	F08G12.2
+M28.5	F08G12.2
+R05D11.7	F08G12.2
+R07E5.14	F08G12.2
+R09B3.5	F08G12.2
+T01B7.4	F08G12.2
+T02H6.2	F08G12.2
+T08A11.2	F08G12.2
+T10C6.5	F08G12.2
+T10F2.4	F08G12.2
+T10G3.6	F08G12.2
+T11G6.8	F08G12.2
+T12A2.7	F08G12.2
+T13H5.4	F08G12.2
+T21D12.3	F08G12.2
+T27F2.1	F08G12.2
+T28D9.10	F08G12.2
+W02B12.2	F08G12.2
+W02B12.3	F08G12.2
+W03F9.10	F08G12.2
+W04D2.6	F08G12.2
+W07E6.4	F08G12.2
+W08E3.1	F08G12.2
+Y108G3AL.2	F08G12.2
+Y110A7A.8	F08G12.2
+Y111B2A.18	F08G12.2
+Y116A8C.34	F08G12.2
+Y116A8C.35	F08G12.2
+Y116A8C.42	F08G12.2
+Y46G5A.4	F08G12.2
+Y47G6A.20	F08G12.2
+Y49E10.15	F08G12.2
+Y54F10BM.14	F08G12.2
+Y59A8B.6	F08G12.2
+Y62E10A.12	F08G12.2
+Y65B4A.6	F08G12.2
+Y69A2AR.21	F08G12.2
+Y71D11A.2	F08G12.2
+Y71F9B.4	F08G12.2
+Y71G12B.14	F08G12.2
+Y73B6BL.32	F08G12.2
+Y80D3A.2	F08G12.2
+Y92C3B.2	F08G12.2
+ZK1098.1	F08G12.2
+ZK1127.9	F08G12.2
+ZK328.2	F08G12.2
+ZK593.7	F08G12.2
+ZK652.1	F08G12.2
+ZK686.4	F08G12.2
+F11A10.2	F09D1.1
+F11F1.1	F09D1.1
+F19F10.9	F09D1.1
+F23B2.6	F09D1.1
+F26A3.2	F09D1.1
+F26B1.2	F09D1.1
+F26D10.3	F09D1.1
+F28F8.3	F09D1.1
+F32A5.7	F09D1.1
+F32B6.3	F09D1.1
+F32H2.4	F09D1.1
+F33D11.10	F09D1.1
+F37E3.1	F09D1.1
+F42A6.7	F09D1.1
+F44E5.4	F09D1.1
+F44E5.5	F09D1.1
+F49D11.1	F09D1.1
+F53B7.3	F09D1.1
+F53H1.1	F09D1.1
+F56D2.6	F09D1.1
+F58B3.7	F09D1.1
+F58E10.3	F09D1.1
+H20J04.8	F09D1.1
+K02F2.3	F09D1.1
+K03H1.2	F09D1.1
+K04G7.10	F09D1.1
+K04G7.11	F09D1.1
+K07C5.6	F09D1.1
+M01E11.2	F09D1.1
+M03C11.7	F09D1.1
+M03F8.3	F09D1.1
+M18.7	F09D1.1
+M28.5	F09D1.1
+R05D11.7	F09D1.1
+R07E5.14	F09D1.1
+R09B3.5	F09D1.1
+T01B7.4	F09D1.1
+T02H6.2	F09D1.1
+T08A11.2	F09D1.1
+T10C6.5	F09D1.1
+T10F2.4	F09D1.1
+T10G3.6	F09D1.1
+T11G6.8	F09D1.1
+T12A2.7	F09D1.1
+T13H5.4	F09D1.1
+T21D12.3	F09D1.1
+T27F2.1	F09D1.1
+T28D9.10	F09D1.1
+W02B12.2	F09D1.1
+W02B12.3	F09D1.1
+W03F9.10	F09D1.1
+W04D2.6	F09D1.1
+W07E6.4	F09D1.1
+W08E3.1	F09D1.1
+Y108G3AL.2	F09D1.1
+Y110A7A.8	F09D1.1
+Y111B2A.18	F09D1.1
+Y116A8C.34	F09D1.1
+Y116A8C.35	F09D1.1
+Y116A8C.42	F09D1.1
+Y46G5A.4	F09D1.1
+Y47G6A.20	F09D1.1
+Y49E10.15	F09D1.1
+Y54F10BM.14	F09D1.1
+Y59A8B.6	F09D1.1
+Y62E10A.12	F09D1.1
+Y65B4A.6	F09D1.1
+Y69A2AR.21	F09D1.1
+Y71D11A.2	F09D1.1
+Y71F9B.4	F09D1.1
+Y71G12B.14	F09D1.1
+Y73B6BL.32	F09D1.1
+Y80D3A.2	F09D1.1
+Y92C3B.2	F09D1.1
+ZK1098.1	F09D1.1
+ZK1127.9	F09D1.1
+ZK328.2	F09D1.1
+ZK593.7	F09D1.1
+ZK652.1	F09D1.1
+ZK686.4	F09D1.1
+F11F1.1	F11A10.2
+F19F10.9	F11A10.2
+F23B2.6	F11A10.2
+F26A3.2	F11A10.2
+F26B1.2	F11A10.2
+F26D10.3	F11A10.2
+F28F8.3	F11A10.2
+F32A5.7	F11A10.2
+F32B6.3	F11A10.2
+F32H2.4	F11A10.2
+F33D11.10	F11A10.2
+F37E3.1	F11A10.2
+F42A6.7	F11A10.2
+F44E5.4	F11A10.2
+F44E5.5	F11A10.2
+F49D11.1	F11A10.2
+F53B7.3	F11A10.2
+F53H1.1	F11A10.2
+F56D2.6	F11A10.2
+F58B3.7	F11A10.2
+F58E10.3	F11A10.2
+H20J04.8	F11A10.2
+K02F2.3	F11A10.2
+K03H1.2	F11A10.2
+K04G7.10	F11A10.2
+K04G7.11	F11A10.2
+K07C5.6	F11A10.2
+M01E11.2	F11A10.2
+M03C11.7	F11A10.2
+M03F8.3	F11A10.2
+M18.7	F11A10.2
+M28.5	F11A10.2
+R05D11.7	F11A10.2
+R07E5.14	F11A10.2
+R09B3.5	F11A10.2
+T01B7.4	F11A10.2
+T02H6.2	F11A10.2
+T08A11.2	F11A10.2
+T10C6.5	F11A10.2
+T10F2.4	F11A10.2
+T10G3.6	F11A10.2
+T11G6.8	F11A10.2
+T12A2.7	F11A10.2
+T13H5.4	F11A10.2
+T21D12.3	F11A10.2
+T27F2.1	F11A10.2
+T28D9.10	F11A10.2
+W02B12.2	F11A10.2
+W02B12.3	F11A10.2
+W03F9.10	F11A10.2
+W04D2.6	F11A10.2
+W07E6.4	F11A10.2
+W08E3.1	F11A10.2
+Y108G3AL.2	F11A10.2
+Y110A7A.8	F11A10.2
+Y111B2A.18	F11A10.2
+Y116A8C.34	F11A10.2
+Y116A8C.35	F11A10.2
+Y116A8C.42	F11A10.2
+Y46G5A.4	F11A10.2
+Y47G6A.20	F11A10.2
+Y49E10.15	F11A10.2
+Y54F10BM.14	F11A10.2
+Y59A8B.6	F11A10.2
+Y62E10A.12	F11A10.2
+Y65B4A.6	F11A10.2
+Y69A2AR.21	F11A10.2
+Y71D11A.2	F11A10.2
+Y71F9B.4	F11A10.2
+Y71G12B.14	F11A10.2
+Y73B6BL.32	F11A10.2
+Y80D3A.2	F11A10.2
+Y92C3B.2	F11A10.2
+ZK1098.1	F11A10.2
+ZK1127.9	F11A10.2
+ZK328.2	F11A10.2
+ZK593.7	F11A10.2
+ZK652.1	F11A10.2
+ZK686.4	F11A10.2
+F19F10.9	F11F1.1
+F23B2.6	F11F1.1
+F26A3.2	F11F1.1
+F26B1.2	F11F1.1
+F26D10.3	F11F1.1
+F28F8.3	F11F1.1
+F32A5.7	F11F1.1
+F32B6.3	F11F1.1
+F32H2.4	F11F1.1
+F33D11.10	F11F1.1
+F37E3.1	F11F1.1
+F42A6.7	F11F1.1
+F44E5.4	F11F1.1
+F44E5.5	F11F1.1
+F49D11.1	F11F1.1
+F53B7.3	F11F1.1
+F53H1.1	F11F1.1
+F56D2.6	F11F1.1
+F58B3.7	F11F1.1
+F58E10.3	F11F1.1
+H20J04.8	F11F1.1
+K02F2.3	F11F1.1
+K03H1.2	F11F1.1
+K04G7.10	F11F1.1
+K04G7.11	F11F1.1
+K07C5.6	F11F1.1
+M01E11.2	F11F1.1
+M03C11.7	F11F1.1
+M03F8.3	F11F1.1
+M18.7	F11F1.1
+M28.5	F11F1.1
+R05D11.7	F11F1.1
+R07E5.14	F11F1.1
+R09B3.5	F11F1.1
+T01B7.4	F11F1.1
+T02H6.2	F11F1.1
+T08A11.2	F11F1.1
+T10C6.5	F11F1.1
+T10F2.4	F11F1.1
+T10G3.6	F11F1.1
+T11G6.8	F11F1.1
+T12A2.7	F11F1.1
+T13H5.4	F11F1.1
+T21D12.3	F11F1.1
+T27F2.1	F11F1.1
+T28D9.10	F11F1.1
+W02B12.2	F11F1.1
+W02B12.3	F11F1.1
+W03F9.10	F11F1.1
+W04D2.6	F11F1.1
+W07E6.4	F11F1.1
+W08E3.1	F11F1.1
+Y108G3AL.2	F11F1.1
+Y110A7A.8	F11F1.1
+Y111B2A.18	F11F1.1
+Y116A8C.34	F11F1.1
+Y116A8C.35	F11F1.1
+Y116A8C.42	F11F1.1
+Y46G5A.4	F11F1.1
+Y47G6A.20	F11F1.1
+Y49E10.15	F11F1.1
+Y54F10BM.14	F11F1.1
+Y59A8B.6	F11F1.1
+Y62E10A.12	F11F1.1
+Y65B4A.6	F11F1.1
+Y69A2AR.21	F11F1.1
+Y71D11A.2	F11F1.1
+Y71F9B.4	F11F1.1
+Y71G12B.14	F11F1.1
+Y73B6BL.32	F11F1.1
+Y80D3A.2	F11F1.1
+Y92C3B.2	F11F1.1
+ZK1098.1	F11F1.1
+ZK1127.9	F11F1.1
+ZK328.2	F11F1.1
+ZK593.7	F11F1.1
+ZK652.1	F11F1.1
+ZK686.4	F11F1.1
+F23B2.6	F19F10.9
+F26A3.2	F19F10.9
+F26B1.2	F19F10.9
+F26D10.3	F19F10.9
+F28F8.3	F19F10.9
+F32A5.7	F19F10.9
+F32B6.3	F19F10.9
+F32H2.4	F19F10.9
+F33D11.10	F19F10.9
+F37E3.1	F19F10.9
+F42A6.7	F19F10.9
+F44E5.4	F19F10.9
+F44E5.5	F19F10.9
+F49D11.1	F19F10.9
+F53B7.3	F19F10.9
+F53H1.1	F19F10.9
+F56D2.6	F19F10.9
+F58B3.7	F19F10.9
+F58E10.3	F19F10.9
+H20J04.8	F19F10.9
+K02F2.3	F19F10.9
+K03H1.2	F19F10.9
+K04G7.10	F19F10.9
+K04G7.11	F19F10.9
+K07C5.6	F19F10.9
+M01E11.2	F19F10.9
+M03C11.7	F19F10.9
+M03F8.3	F19F10.9
+M18.7	F19F10.9
+M28.5	F19F10.9
+R05D11.7	F19F10.9
+R07E5.14	F19F10.9
+R09B3.5	F19F10.9
+T01B7.4	F19F10.9
+T02H6.2	F19F10.9
+T08A11.2	F19F10.9
+T10C6.5	F19F10.9
+T10F2.4	F19F10.9
+T10G3.6	F19F10.9
+T11G6.8	F19F10.9
+T12A2.7	F19F10.9
+T13H5.4	F19F10.9
+T21D12.3	F19F10.9
+T27F2.1	F19F10.9
+T28D9.10	F19F10.9
+W02B12.2	F19F10.9
+W02B12.3	F19F10.9
+W03F9.10	F19F10.9
+W04D2.6	F19F10.9
+W07E6.4	F19F10.9
+W08E3.1	F19F10.9
+Y108G3AL.2	F19F10.9
+Y110A7A.8	F19F10.9
+Y111B2A.18	F19F10.9
+Y116A8C.34	F19F10.9
+Y116A8C.35	F19F10.9
+Y116A8C.42	F19F10.9
+Y46G5A.4	F19F10.9
+Y47G6A.20	F19F10.9
+Y49E10.15	F19F10.9
+Y54F10BM.14	F19F10.9
+Y59A8B.6	F19F10.9
+Y62E10A.12	F19F10.9
+Y65B4A.6	F19F10.9
+Y69A2AR.21	F19F10.9
+Y71D11A.2	F19F10.9
+Y71F9B.4	F19F10.9
+Y71G12B.14	F19F10.9
+Y73B6BL.32	F19F10.9
+Y80D3A.2	F19F10.9
+Y92C3B.2	F19F10.9
+ZK1098.1	F19F10.9
+ZK1127.9	F19F10.9
+ZK328.2	F19F10.9
+ZK593.7	F19F10.9
+ZK652.1	F19F10.9
+ZK686.4	F19F10.9
+F26B1.2	F23B2.6
+F26D10.3	F23B2.6
+F28F8.3	F23B2.6
+F32A5.7	F23B2.6
+F32B6.3	F23B2.6
+F42A6.7	F23B2.6
+F44E5.4	F23B2.6
+F44E5.5	F23B2.6
+F49D11.1	F23B2.6
+F53B7.3	F23B2.6
+F53H1.1	F23B2.6
+F56D2.6	F23B2.6
+F58B3.7	F23B2.6
+F58E10.3	F23B2.6
+H20J04.8	F23B2.6
+K02F2.3	F23B2.6
+K03H1.2	F23B2.6
+K04G7.10	F23B2.6
+K04G7.11	F23B2.6
+K07C5.6	F23B2.6
+M01E11.2	F23B2.6
+M03C11.7	F23B2.6
+M03F8.3	F23B2.6
+M28.5	F23B2.6
+R05D11.7	F23B2.6
+T01B7.4	F23B2.6
+T08A11.2	F23B2.6
+T10C6.5	F23B2.6
+T10F2.4	F23B2.6
+T10G3.6	F23B2.6
+T11G6.8	F23B2.6
+T12A2.7	F23B2.6
+T13H5.4	F23B2.6
+T21D12.3	F23B2.6
+T27F2.1	F23B2.6
+T28D9.10	F23B2.6
+W02B12.2	F23B2.6
+W02B12.3	F23B2.6
+W03F9.10	F23B2.6
+W04D2.6	F23B2.6
+W07E6.4	F23B2.6
+W08E3.1	F23B2.6
+Y108G3AL.2	F23B2.6
+Y110A7A.8	F23B2.6
+Y111B2A.18	F23B2.6
+Y116A8C.34	F23B2.6
+Y116A8C.35	F23B2.6
+Y116A8C.42	F23B2.6
+Y46G5A.4	F23B2.6
+Y47G6A.20	F23B2.6
+Y49E10.15	F23B2.6
+Y54F10BM.14	F23B2.6
+Y59A8B.6	F23B2.6
+Y62E10A.12	F23B2.6
+Y69A2AR.21	F23B2.6
+Y71D11A.2	F23B2.6
+Y71F9B.4	F23B2.6
+Y71G12B.14	F23B2.6
+Y73B6BL.32	F23B2.6
+Y80D3A.2	F23B2.6
+Y92C3B.2	F23B2.6
+ZK1098.1	F23B2.6
+ZK1127.9	F23B2.6
+ZK328.2	F23B2.6
+ZK593.7	F23B2.6
+ZK652.1	F23B2.6
+ZK686.4	F23B2.6
+F26B1.2	F26A3.2
+F26D10.3	F26A3.2
+F28F8.3	F26A3.2
+F32A5.7	F26A3.2
+F32B6.3	F26A3.2
+F42A6.7	F26A3.2
+F44E5.4	F26A3.2
+F44E5.5	F26A3.2
+F49D11.1	F26A3.2
+F53B7.3	F26A3.2
+F53H1.1	F26A3.2
+F56D2.6	F26A3.2
+F58B3.7	F26A3.2
+F58E10.3	F26A3.2
+H20J04.8	F26A3.2
+K02F2.3	F26A3.2
+K03H1.2	F26A3.2
+K04G7.10	F26A3.2
+K04G7.11	F26A3.2
+K07C5.6	F26A3.2
+M01E11.2	F26A3.2
+M03C11.7	F26A3.2
+M03F8.3	F26A3.2
+M28.5	F26A3.2
+R05D11.7	F26A3.2
+T01B7.4	F26A3.2
+T08A11.2	F26A3.2
+T10C6.5	F26A3.2
+T10F2.4	F26A3.2
+T10G3.6	F26A3.2
+T11G6.8	F26A3.2
+T12A2.7	F26A3.2
+T13H5.4	F26A3.2
+T21D12.3	F26A3.2
+T27F2.1	F26A3.2
+T28D9.10	F26A3.2
+W02B12.2	F26A3.2
+W02B12.3	F26A3.2
+W03F9.10	F26A3.2
+W04D2.6	F26A3.2
+W07E6.4	F26A3.2
+W08E3.1	F26A3.2
+Y108G3AL.2	F26A3.2
+Y110A7A.8	F26A3.2
+Y111B2A.18	F26A3.2
+Y116A8C.34	F26A3.2
+Y116A8C.35	F26A3.2
+Y116A8C.42	F26A3.2
+Y46G5A.4	F26A3.2
+Y47G6A.20	F26A3.2
+Y49E10.15	F26A3.2
+Y54F10BM.14	F26A3.2
+Y59A8B.6	F26A3.2
+Y62E10A.12	F26A3.2
+Y69A2AR.21	F26A3.2
+Y71D11A.2	F26A3.2
+Y71F9B.4	F26A3.2
+Y71G12B.14	F26A3.2
+Y73B6BL.32	F26A3.2
+Y80D3A.2	F26A3.2
+Y92C3B.2	F26A3.2
+ZK1098.1	F26A3.2
+ZK1127.9	F26A3.2
+ZK328.2	F26A3.2
+ZK593.7	F26A3.2
+ZK652.1	F26A3.2
+ZK686.4	F26A3.2
+F26D10.3	F26B1.2
+F28F8.3	F26B1.2
+F32A5.7	F26B1.2
+F32B6.3	F26B1.2
+F32H2.4	F26B1.2
+F33D11.10	F26B1.2
+F37E3.1	F26B1.2
+F42A6.7	F26B1.2
+F44E5.4	F26B1.2
+F44E5.5	F26B1.2
+F49D11.1	F26B1.2
+F53B7.3	F26B1.2
+F53H1.1	F26B1.2
+F56D2.6	F26B1.2
+F58B3.7	F26B1.2
+F58E10.3	F26B1.2
+H20J04.8	F26B1.2
+K02F2.3	F26B1.2
+K03H1.2	F26B1.2
+K04G7.10	F26B1.2
+K04G7.11	F26B1.2
+K07C5.6	F26B1.2
+M01E11.2	F26B1.2
+M03C11.7	F26B1.2
+M03F8.3	F26B1.2
+M18.7	F26B1.2
+M28.5	F26B1.2
+R05D11.7	F26B1.2
+R07E5.14	F26B1.2
+R09B3.5	F26B1.2
+T01B7.4	F26B1.2
+T02H6.2	F26B1.2
+T08A11.2	F26B1.2
+T10C6.5	F26B1.2
+T10F2.4	F26B1.2
+T10G3.6	F26B1.2
+T11G6.8	F26B1.2
+T12A2.7	F26B1.2
+T13H5.4	F26B1.2
+T21D12.3	F26B1.2
+T27F2.1	F26B1.2
+T28D9.10	F26B1.2
+W02B12.2	F26B1.2
+W02B12.3	F26B1.2
+W03F9.10	F26B1.2
+W04D2.6	F26B1.2
+W07E6.4	F26B1.2
+W08E3.1	F26B1.2
+Y108G3AL.2	F26B1.2
+Y110A7A.8	F26B1.2
+Y111B2A.18	F26B1.2
+Y116A8C.34	F26B1.2
+Y116A8C.35	F26B1.2
+Y116A8C.42	F26B1.2
+Y46G5A.4	F26B1.2
+Y47G6A.20	F26B1.2
+Y49E10.15	F26B1.2
+Y54F10BM.14	F26B1.2
+Y59A8B.6	F26B1.2
+Y62E10A.12	F26B1.2
+Y65B4A.6	F26B1.2
+Y69A2AR.21	F26B1.2
+Y71D11A.2	F26B1.2
+Y71F9B.4	F26B1.2
+Y71G12B.14	F26B1.2
+Y73B6BL.32	F26B1.2
+Y80D3A.2	F26B1.2
+Y92C3B.2	F26B1.2
+ZK1098.1	F26B1.2
+ZK1127.9	F26B1.2
+ZK328.2	F26B1.2
+ZK593.7	F26B1.2
+ZK652.1	F26B1.2
+ZK686.4	F26B1.2
+F28F8.3	F26D10.3
+F32A5.7	F26D10.3
+F32B6.3	F26D10.3
+F32H2.4	F26D10.3
+F33D11.10	F26D10.3
+F37E3.1	F26D10.3
+F42A6.7	F26D10.3
+F44E5.4	F26D10.3
+F44E5.5	F26D10.3
+F49D11.1	F26D10.3
+F53B7.3	F26D10.3
+F53H1.1	F26D10.3
+F56D2.6	F26D10.3
+F58B3.7	F26D10.3
+F58E10.3	F26D10.3
+H20J04.8	F26D10.3
+K02F2.3	F26D10.3
+K03H1.2	F26D10.3
+K04G7.10	F26D10.3
+K04G7.11	F26D10.3
+K07C5.6	F26D10.3
+M01E11.2	F26D10.3
+M03C11.7	F26D10.3
+M03F8.3	F26D10.3
+M18.7	F26D10.3
+M28.5	F26D10.3
+R05D11.7	F26D10.3
+R07E5.14	F26D10.3
+R09B3.5	F26D10.3
+T01B7.4	F26D10.3
+T02H6.2	F26D10.3
+T08A11.2	F26D10.3
+T10C6.5	F26D10.3
+T10F2.4	F26D10.3
+T10G3.6	F26D10.3
+T11G6.8	F26D10.3
+T12A2.7	F26D10.3
+T13H5.4	F26D10.3
+T21D12.3	F26D10.3
+T27F2.1	F26D10.3
+T28D9.10	F26D10.3
+W02B12.2	F26D10.3
+W02B12.3	F26D10.3
+W03F9.10	F26D10.3
+W04D2.6	F26D10.3
+W07E6.4	F26D10.3
+W08E3.1	F26D10.3
+Y108G3AL.2	F26D10.3
+Y110A7A.8	F26D10.3
+Y111B2A.18	F26D10.3
+Y116A8C.34	F26D10.3
+Y116A8C.35	F26D10.3
+Y116A8C.42	F26D10.3
+Y46G5A.4	F26D10.3
+Y47G6A.20	F26D10.3
+Y49E10.15	F26D10.3
+Y54F10BM.14	F26D10.3
+Y59A8B.6	F26D10.3
+Y62E10A.12	F26D10.3
+Y65B4A.6	F26D10.3
+Y69A2AR.21	F26D10.3
+Y71D11A.2	F26D10.3
+Y71F9B.4	F26D10.3
+Y71G12B.14	F26D10.3
+Y73B6BL.32	F26D10.3
+Y80D3A.2	F26D10.3
+Y92C3B.2	F26D10.3
+ZK1098.1	F26D10.3
+ZK1127.9	F26D10.3
+ZK328.2	F26D10.3
+ZK593.7	F26D10.3
+ZK652.1	F26D10.3
+ZK686.4	F26D10.3
+F32B6.3	F28F8.3
+F32H2.4	F28F8.3
+F33D11.10	F28F8.3
+F37E3.1	F28F8.3
+F42A6.7	F28F8.3
+F44E5.4	F28F8.3
+F44E5.5	F28F8.3
+F49D11.1	F28F8.3
+F53B7.3	F28F8.3
+F53H1.1	F28F8.3
+F56D2.6	F28F8.3
+F58B3.7	F28F8.3
+F58E10.3	F28F8.3
+H20J04.8	F28F8.3
+K02F2.3	F28F8.3
+K03H1.2	F28F8.3
+K04G7.10	F28F8.3
+K04G7.11	F28F8.3
+K07C5.6	F28F8.3
+M01E11.2	F28F8.3
+M03C11.7	F28F8.3
+M03F8.3	F28F8.3
+M18.7	F28F8.3
+M28.5	F28F8.3
+R05D11.7	F28F8.3
+R07E5.14	F28F8.3
+R09B3.5	F28F8.3
+T01B7.4	F28F8.3
+T02H6.2	F28F8.3
+T08A11.2	F28F8.3
+T10C6.5	F28F8.3
+T10F2.4	F28F8.3
+T11G6.8	F28F8.3
+T12A2.7	F28F8.3
+T13H5.4	F28F8.3
+T21D12.3	F28F8.3
+T27F2.1	F28F8.3
+T28D9.10	F28F8.3
+W02B12.2	F28F8.3
+W02B12.3	F28F8.3
+W03F9.10	F28F8.3
+W04D2.6	F28F8.3
+W07E6.4	F28F8.3
+W08E3.1	F28F8.3
+Y108G3AL.2	F28F8.3
+Y110A7A.8	F28F8.3
+Y111B2A.18	F28F8.3
+Y116A8C.34	F28F8.3
+Y116A8C.35	F28F8.3
+Y116A8C.42	F28F8.3
+Y46G5A.4	F28F8.3
+Y47G6A.20	F28F8.3
+Y49E10.15	F28F8.3
+Y54F10BM.14	F28F8.3
+Y59A8B.6	F28F8.3
+Y65B4A.6	F28F8.3
+Y69A2AR.21	F28F8.3
+Y71D11A.2	F28F8.3
+Y71F9B.4	F28F8.3
+Y80D3A.2	F28F8.3
+Y92C3B.2	F28F8.3
+ZK1098.1	F28F8.3
+ZK1127.9	F28F8.3
+ZK328.2	F28F8.3
+ZK652.1	F28F8.3
+ZK686.4	F28F8.3
+F32B6.3	F32A5.7
+F32H2.4	F32A5.7
+F33D11.10	F32A5.7
+F37E3.1	F32A5.7
+F42A6.7	F32A5.7
+F44E5.4	F32A5.7
+F44E5.5	F32A5.7
+F49D11.1	F32A5.7
+F53B7.3	F32A5.7
+F53H1.1	F32A5.7
+F56D2.6	F32A5.7
+F58B3.7	F32A5.7
+F58E10.3	F32A5.7
+H20J04.8	F32A5.7
+K02F2.3	F32A5.7
+K03H1.2	F32A5.7
+K04G7.10	F32A5.7
+K04G7.11	F32A5.7
+K07C5.6	F32A5.7
+M01E11.2	F32A5.7
+M03C11.7	F32A5.7
+M03F8.3	F32A5.7
+M18.7	F32A5.7
+M28.5	F32A5.7
+R05D11.7	F32A5.7
+R07E5.14	F32A5.7
+R09B3.5	F32A5.7
+T01B7.4	F32A5.7
+T02H6.2	F32A5.7
+T08A11.2	F32A5.7
+T10C6.5	F32A5.7
+T10F2.4	F32A5.7
+T11G6.8	F32A5.7
+T12A2.7	F32A5.7
+T13H5.4	F32A5.7
+T21D12.3	F32A5.7
+T27F2.1	F32A5.7
+T28D9.10	F32A5.7
+W02B12.2	F32A5.7
+W02B12.3	F32A5.7
+W03F9.10	F32A5.7
+W04D2.6	F32A5.7
+W07E6.4	F32A5.7
+W08E3.1	F32A5.7
+Y108G3AL.2	F32A5.7
+Y110A7A.8	F32A5.7
+Y111B2A.18	F32A5.7
+Y116A8C.34	F32A5.7
+Y116A8C.35	F32A5.7
+Y116A8C.42	F32A5.7
+Y46G5A.4	F32A5.7
+Y47G6A.20	F32A5.7
+Y49E10.15	F32A5.7
+Y54F10BM.14	F32A5.7
+Y59A8B.6	F32A5.7
+Y65B4A.6	F32A5.7
+Y69A2AR.21	F32A5.7
+Y71D11A.2	F32A5.7
+Y71F9B.4	F32A5.7
+Y80D3A.2	F32A5.7
+Y92C3B.2	F32A5.7
+ZK1098.1	F32A5.7
+ZK1127.9	F32A5.7
+ZK328.2	F32A5.7
+ZK652.1	F32A5.7
+ZK686.4	F32A5.7
+F32H2.4	F32B6.3
+F33D11.10	F32B6.3
+F37E3.1	F32B6.3
+F42A6.7	F32B6.3
+F44E5.4	F32B6.3
+F44E5.5	F32B6.3
+F49D11.1	F32B6.3
+F53B7.3	F32B6.3
+F53H1.1	F32B6.3
+F56D2.6	F32B6.3
+F58B3.7	F32B6.3
+F58E10.3	F32B6.3
+H20J04.8	F32B6.3
+K02F2.3	F32B6.3
+K03H1.2	F32B6.3
+K04G7.10	F32B6.3
+K04G7.11	F32B6.3
+K07C5.6	F32B6.3
+M01E11.2	F32B6.3
+M03C11.7	F32B6.3
+M03F8.3	F32B6.3
+M18.7	F32B6.3
+M28.5	F32B6.3
+R05D11.7	F32B6.3
+R07E5.14	F32B6.3
+R09B3.5	F32B6.3
+T01B7.4	F32B6.3
+T02H6.2	F32B6.3
+T08A11.2	F32B6.3
+T10C6.5	F32B6.3
+T10F2.4	F32B6.3
+T10G3.6	F32B6.3
+T11G6.8	F32B6.3
+T12A2.7	F32B6.3
+T13H5.4	F32B6.3
+T21D12.3	F32B6.3
+T27F2.1	F32B6.3
+T28D9.10	F32B6.3
+W02B12.2	F32B6.3
+W02B12.3	F32B6.3
+W03F9.10	F32B6.3
+W04D2.6	F32B6.3
+W07E6.4	F32B6.3
+W08E3.1	F32B6.3
+Y108G3AL.2	F32B6.3
+Y110A7A.8	F32B6.3
+Y111B2A.18	F32B6.3
+Y116A8C.34	F32B6.3
+Y116A8C.35	F32B6.3
+Y116A8C.42	F32B6.3
+Y46G5A.4	F32B6.3
+Y47G6A.20	F32B6.3
+Y49E10.15	F32B6.3
+Y54F10BM.14	F32B6.3
+Y59A8B.6	F32B6.3
+Y62E10A.12	F32B6.3
+Y65B4A.6	F32B6.3
+Y69A2AR.21	F32B6.3
+Y71D11A.2	F32B6.3
+Y71F9B.4	F32B6.3
+Y71G12B.14	F32B6.3
+Y73B6BL.32	F32B6.3
+Y80D3A.2	F32B6.3
+Y92C3B.2	F32B6.3
+ZK1098.1	F32B6.3
+ZK1127.9	F32B6.3
+ZK328.2	F32B6.3
+ZK593.7	F32B6.3
+ZK652.1	F32B6.3
+ZK686.4	F32B6.3
+F42A6.7	F32H2.4
+F44E5.4	F32H2.4
+F44E5.5	F32H2.4
+F49D11.1	F32H2.4
+F53B7.3	F32H2.4
+F53H1.1	F32H2.4
+F56D2.6	F32H2.4
+F58B3.7	F32H2.4
+F58E10.3	F32H2.4
+H20J04.8	F32H2.4
+K02F2.3	F32H2.4
+K03H1.2	F32H2.4
+K04G7.10	F32H2.4
+K04G7.11	F32H2.4
+K07C5.6	F32H2.4
+M01E11.2	F32H2.4
+M03C11.7	F32H2.4
+M03F8.3	F32H2.4
+M28.5	F32H2.4
+R05D11.7	F32H2.4
+T01B7.4	F32H2.4
+T08A11.2	F32H2.4
+T10C6.5	F32H2.4
+T10F2.4	F32H2.4
+T10G3.6	F32H2.4
+T11G6.8	F32H2.4
+T12A2.7	F32H2.4
+T13H5.4	F32H2.4
+T21D12.3	F32H2.4
+T27F2.1	F32H2.4
+T28D9.10	F32H2.4
+W02B12.2	F32H2.4
+W02B12.3	F32H2.4
+W03F9.10	F32H2.4
+W04D2.6	F32H2.4
+W07E6.4	F32H2.4
+W08E3.1	F32H2.4
+Y108G3AL.2	F32H2.4
+Y110A7A.8	F32H2.4
+Y111B2A.18	F32H2.4
+Y116A8C.34	F32H2.4
+Y116A8C.35	F32H2.4
+Y116A8C.42	F32H2.4
+Y46G5A.4	F32H2.4
+Y47G6A.20	F32H2.4
+Y49E10.15	F32H2.4
+Y54F10BM.14	F32H2.4
+Y59A8B.6	F32H2.4
+Y62E10A.12	F32H2.4
+Y69A2AR.21	F32H2.4
+Y71D11A.2	F32H2.4
+Y71F9B.4	F32H2.4
+Y71G12B.14	F32H2.4
+Y73B6BL.32	F32H2.4
+Y80D3A.2	F32H2.4
+Y92C3B.2	F32H2.4
+ZK1098.1	F32H2.4
+ZK1127.9	F32H2.4
+ZK328.2	F32H2.4
+ZK593.7	F32H2.4
+ZK652.1	F32H2.4
+ZK686.4	F32H2.4
+F42A6.7	F33D11.10
+F44E5.4	F33D11.10
+F44E5.5	F33D11.10
+F49D11.1	F33D11.10
+F53B7.3	F33D11.10
+F53H1.1	F33D11.10
+F56D2.6	F33D11.10
+F58B3.7	F33D11.10
+F58E10.3	F33D11.10
+H20J04.8	F33D11.10
+K02F2.3	F33D11.10
+K03H1.2	F33D11.10
+K04G7.10	F33D11.10
+K04G7.11	F33D11.10
+K07C5.6	F33D11.10
+M01E11.2	F33D11.10
+M03C11.7	F33D11.10
+M03F8.3	F33D11.10
+M28.5	F33D11.10
+R05D11.7	F33D11.10
+T01B7.4	F33D11.10
+T08A11.2	F33D11.10
+T10C6.5	F33D11.10
+T10F2.4	F33D11.10
+T10G3.6	F33D11.10
+T11G6.8	F33D11.10
+T12A2.7	F33D11.10
+T13H5.4	F33D11.10
+T21D12.3	F33D11.10
+T27F2.1	F33D11.10
+T28D9.10	F33D11.10
+W02B12.2	F33D11.10
+W02B12.3	F33D11.10
+W03F9.10	F33D11.10
+W04D2.6	F33D11.10
+W07E6.4	F33D11.10
+W08E3.1	F33D11.10
+Y108G3AL.2	F33D11.10
+Y110A7A.8	F33D11.10
+Y111B2A.18	F33D11.10
+Y116A8C.34	F33D11.10
+Y116A8C.35	F33D11.10
+Y116A8C.42	F33D11.10
+Y46G5A.4	F33D11.10
+Y47G6A.20	F33D11.10
+Y49E10.15	F33D11.10
+Y54F10BM.14	F33D11.10
+Y59A8B.6	F33D11.10
+Y62E10A.12	F33D11.10
+Y69A2AR.21	F33D11.10
+Y71D11A.2	F33D11.10
+Y71F9B.4	F33D11.10
+Y71G12B.14	F33D11.10
+Y73B6BL.32	F33D11.10
+Y80D3A.2	F33D11.10
+Y92C3B.2	F33D11.10
+ZK1098.1	F33D11.10
+ZK1127.9	F33D11.10
+ZK328.2	F33D11.10
+ZK593.7	F33D11.10
+ZK652.1	F33D11.10
+ZK686.4	F33D11.10
+F42A6.7	F37E3.1
+F44E5.4	F37E3.1
+F44E5.5	F37E3.1
+F49D11.1	F37E3.1
+F53B7.3	F37E3.1
+F53H1.1	F37E3.1
+F56D2.6	F37E3.1
+F58B3.7	F37E3.1
+F58E10.3	F37E3.1
+H20J04.8	F37E3.1
+K02F2.3	F37E3.1
+K03H1.2	F37E3.1
+K04G7.10	F37E3.1
+K04G7.11	F37E3.1
+K07C5.6	F37E3.1
+M01E11.2	F37E3.1
+M03C11.7	F37E3.1
+M03F8.3	F37E3.1
+M28.5	F37E3.1
+R05D11.7	F37E3.1
+T01B7.4	F37E3.1
+T08A11.2	F37E3.1
+T10C6.5	F37E3.1
+T10F2.4	F37E3.1
+T10G3.6	F37E3.1
+T11G6.8	F37E3.1
+T12A2.7	F37E3.1
+T13H5.4	F37E3.1
+T21D12.3	F37E3.1
+T27F2.1	F37E3.1
+T28D9.10	F37E3.1
+W02B12.2	F37E3.1
+W02B12.3	F37E3.1
+W03F9.10	F37E3.1
+W04D2.6	F37E3.1
+W07E6.4	F37E3.1
+W08E3.1	F37E3.1
+Y108G3AL.2	F37E3.1
+Y110A7A.8	F37E3.1
+Y111B2A.18	F37E3.1
+Y116A8C.34	F37E3.1
+Y116A8C.35	F37E3.1
+Y116A8C.42	F37E3.1
+Y46G5A.4	F37E3.1
+Y47G6A.20	F37E3.1
+Y49E10.15	F37E3.1
+Y54F10BM.14	F37E3.1
+Y59A8B.6	F37E3.1
+Y62E10A.12	F37E3.1
+Y69A2AR.21	F37E3.1
+Y71D11A.2	F37E3.1
+Y71F9B.4	F37E3.1
+Y71G12B.14	F37E3.1
+Y73B6BL.32	F37E3.1
+Y80D3A.2	F37E3.1
+Y92C3B.2	F37E3.1
+ZK1098.1	F37E3.1
+ZK1127.9	F37E3.1
+ZK328.2	F37E3.1
+ZK593.7	F37E3.1
+ZK652.1	F37E3.1
+ZK686.4	F37E3.1
+F44E5.4	F42A6.7
+F44E5.5	F42A6.7
+F49D11.1	F42A6.7
+F53B7.3	F42A6.7
+F53H1.1	F42A6.7
+F56D2.6	F42A6.7
+F58B3.7	F42A6.7
+F58E10.3	F42A6.7
+H20J04.8	F42A6.7
+K02F2.3	F42A6.7
+K03H1.2	F42A6.7
+K04G7.10	F42A6.7
+K04G7.11	F42A6.7
+K07C5.6	F42A6.7
+M01E11.2	F42A6.7
+M03C11.7	F42A6.7
+M03F8.3	F42A6.7
+M18.7	F42A6.7
+M28.5	F42A6.7
+R05D11.7	F42A6.7
+R07E5.14	F42A6.7
+R09B3.5	F42A6.7
+T01B7.4	F42A6.7
+T02H6.2	F42A6.7
+T08A11.2	F42A6.7
+T10C6.5	F42A6.7
+T10F2.4	F42A6.7
+T10G3.6	F42A6.7
+T11G6.8	F42A6.7
+T12A2.7	F42A6.7
+T13H5.4	F42A6.7
+T21D12.3	F42A6.7
+T27F2.1	F42A6.7
+T28D9.10	F42A6.7
+W02B12.2	F42A6.7
+W02B12.3	F42A6.7
+W03F9.10	F42A6.7
+W04D2.6	F42A6.7
+W07E6.4	F42A6.7
+W08E3.1	F42A6.7
+Y108G3AL.2	F42A6.7
+Y110A7A.8	F42A6.7
+Y111B2A.18	F42A6.7
+Y116A8C.34	F42A6.7
+Y116A8C.35	F42A6.7
+Y116A8C.42	F42A6.7
+Y46G5A.4	F42A6.7
+Y47G6A.20	F42A6.7
+Y49E10.15	F42A6.7
+Y54F10BM.14	F42A6.7
+Y59A8B.6	F42A6.7
+Y62E10A.12	F42A6.7
+Y65B4A.6	F42A6.7
+Y69A2AR.21	F42A6.7
+Y71D11A.2	F42A6.7
+Y71F9B.4	F42A6.7
+Y71G12B.14	F42A6.7
+Y73B6BL.32	F42A6.7
+Y80D3A.2	F42A6.7
+Y92C3B.2	F42A6.7
+ZK1098.1	F42A6.7
+ZK1127.9	F42A6.7
+ZK328.2	F42A6.7
+ZK593.7	F42A6.7
+ZK652.1	F42A6.7
+ZK686.4	F42A6.7
+F44E5.5	F44E5.4
+F49D11.1	F44E5.4
+F53B7.3	F44E5.4
+F53H1.1	F44E5.4
+F56D2.6	F44E5.4
+F58B3.7	F44E5.4
+F58E10.3	F44E5.4
+H20J04.8	F44E5.4
+K02F2.3	F44E5.4
+K03H1.2	F44E5.4
+K04G7.10	F44E5.4
+K04G7.11	F44E5.4
+K07C5.6	F44E5.4
+M01E11.2	F44E5.4
+M03C11.7	F44E5.4
+M03F8.3	F44E5.4
+M18.7	F44E5.4
+M28.5	F44E5.4
+R05D11.7	F44E5.4
+R07E5.14	F44E5.4
+R09B3.5	F44E5.4
+T01B7.4	F44E5.4
+T02H6.2	F44E5.4
+T08A11.2	F44E5.4
+T10C6.5	F44E5.4
+T10F2.4	F44E5.4
+T10G3.6	F44E5.4
+T11G6.8	F44E5.4
+T12A2.7	F44E5.4
+T13H5.4	F44E5.4
+T21D12.3	F44E5.4
+T27F2.1	F44E5.4
+T28D9.10	F44E5.4
+W02B12.2	F44E5.4
+W02B12.3	F44E5.4
+W03F9.10	F44E5.4
+W04D2.6	F44E5.4
+W07E6.4	F44E5.4
+W08E3.1	F44E5.4
+Y108G3AL.2	F44E5.4
+Y110A7A.8	F44E5.4
+Y111B2A.18	F44E5.4
+Y116A8C.34	F44E5.4
+Y116A8C.35	F44E5.4
+Y116A8C.42	F44E5.4
+Y46G5A.4	F44E5.4
+Y47G6A.20	F44E5.4
+Y49E10.15	F44E5.4
+Y54F10BM.14	F44E5.4
+Y59A8B.6	F44E5.4
+Y62E10A.12	F44E5.4
+Y65B4A.6	F44E5.4
+Y69A2AR.21	F44E5.4
+Y71D11A.2	F44E5.4
+Y71F9B.4	F44E5.4
+Y71G12B.14	F44E5.4
+Y73B6BL.32	F44E5.4
+Y80D3A.2	F44E5.4
+Y92C3B.2	F44E5.4
+ZK1098.1	F44E5.4
+ZK1127.9	F44E5.4
+ZK328.2	F44E5.4
+ZK593.7	F44E5.4
+ZK652.1	F44E5.4
+ZK686.4	F44E5.4
+F49D11.1	F44E5.5
+F53B7.3	F44E5.5
+F53H1.1	F44E5.5
+F56D2.6	F44E5.5
+F58B3.7	F44E5.5
+F58E10.3	F44E5.5
+H20J04.8	F44E5.5
+K02F2.3	F44E5.5
+K03H1.2	F44E5.5
+K04G7.10	F44E5.5
+K04G7.11	F44E5.5
+K07C5.6	F44E5.5
+M01E11.2	F44E5.5
+M03C11.7	F44E5.5
+M03F8.3	F44E5.5
+M18.7	F44E5.5
+M28.5	F44E5.5
+R05D11.7	F44E5.5
+R07E5.14	F44E5.5
+R09B3.5	F44E5.5
+T01B7.4	F44E5.5
+T02H6.2	F44E5.5
+T08A11.2	F44E5.5
+T10C6.5	F44E5.5
+T10F2.4	F44E5.5
+T10G3.6	F44E5.5
+T11G6.8	F44E5.5
+T12A2.7	F44E5.5
+T13H5.4	F44E5.5
+T21D12.3	F44E5.5
+T27F2.1	F44E5.5
+T28D9.10	F44E5.5
+W02B12.2	F44E5.5
+W02B12.3	F44E5.5
+W03F9.10	F44E5.5
+W04D2.6	F44E5.5
+W07E6.4	F44E5.5
+W08E3.1	F44E5.5
+Y108G3AL.2	F44E5.5
+Y110A7A.8	F44E5.5
+Y111B2A.18	F44E5.5
+Y116A8C.34	F44E5.5
+Y116A8C.35	F44E5.5
+Y116A8C.42	F44E5.5
+Y46G5A.4	F44E5.5
+Y47G6A.20	F44E5.5
+Y49E10.15	F44E5.5
+Y54F10BM.14	F44E5.5
+Y59A8B.6	F44E5.5
+Y62E10A.12	F44E5.5
+Y65B4A.6	F44E5.5
+Y69A2AR.21	F44E5.5
+Y71D11A.2	F44E5.5
+Y71F9B.4	F44E5.5
+Y71G12B.14	F44E5.5
+Y73B6BL.32	F44E5.5
+Y80D3A.2	F44E5.5
+Y92C3B.2	F44E5.5
+ZK1098.1	F44E5.5
+ZK1127.9	F44E5.5
+ZK328.2	F44E5.5
+ZK593.7	F44E5.5
+ZK652.1	F44E5.5
+ZK686.4	F44E5.5
+F53B7.3	F49D11.1
+F53H1.1	F49D11.1
+F56D2.6	F49D11.1
+F58B3.7	F49D11.1
+F58E10.3	F49D11.1
+H20J04.8	F49D11.1
+K02F2.3	F49D11.1
+K03H1.2	F49D11.1
+K04G7.10	F49D11.1
+K04G7.11	F49D11.1
+K07C5.6	F49D11.1
+M01E11.2	F49D11.1
+M03C11.7	F49D11.1
+M03F8.3	F49D11.1
+M18.7	F49D11.1
+M28.5	F49D11.1
+R05D11.7	F49D11.1
+R07E5.14	F49D11.1
+R09B3.5	F49D11.1
+T01B7.4	F49D11.1
+T02H6.2	F49D11.1
+T08A11.2	F49D11.1
+T10C6.5	F49D11.1
+T10F2.4	F49D11.1
+T10G3.6	F49D11.1
+T11G6.8	F49D11.1
+T12A2.7	F49D11.1
+T13H5.4	F49D11.1
+T21D12.3	F49D11.1
+T27F2.1	F49D11.1
+T28D9.10	F49D11.1
+W02B12.2	F49D11.1
+W02B12.3	F49D11.1
+W03F9.10	F49D11.1
+W04D2.6	F49D11.1
+W07E6.4	F49D11.1
+W08E3.1	F49D11.1
+Y108G3AL.2	F49D11.1
+Y110A7A.8	F49D11.1
+Y111B2A.18	F49D11.1
+Y116A8C.34	F49D11.1
+Y116A8C.35	F49D11.1
+Y116A8C.42	F49D11.1
+Y46G5A.4	F49D11.1
+Y47G6A.20	F49D11.1
+Y49E10.15	F49D11.1
+Y54F10BM.14	F49D11.1
+Y59A8B.6	F49D11.1
+Y62E10A.12	F49D11.1
+Y65B4A.6	F49D11.1
+Y69A2AR.21	F49D11.1
+Y71D11A.2	F49D11.1
+Y71F9B.4	F49D11.1
+Y71G12B.14	F49D11.1
+Y73B6BL.32	F49D11.1
+Y80D3A.2	F49D11.1
+Y92C3B.2	F49D11.1
+ZK1098.1	F49D11.1
+ZK1127.9	F49D11.1
+ZK328.2	F49D11.1
+ZK593.7	F49D11.1
+ZK652.1	F49D11.1
+ZK686.4	F49D11.1
+F53H1.1	F53B7.3
+F56D2.6	F53B7.3
+F58B3.7	F53B7.3
+F58E10.3	F53B7.3
+H20J04.8	F53B7.3
+K02F2.3	F53B7.3
+K03H1.2	F53B7.3
+K04G7.10	F53B7.3
+K04G7.11	F53B7.3
+K07C5.6	F53B7.3
+M01E11.2	F53B7.3
+M03C11.7	F53B7.3
+M03F8.3	F53B7.3
+M18.7	F53B7.3
+M28.5	F53B7.3
+R05D11.7	F53B7.3
+R07E5.14	F53B7.3
+R09B3.5	F53B7.3
+T01B7.4	F53B7.3
+T02H6.2	F53B7.3
+T08A11.2	F53B7.3
+T10C6.5	F53B7.3
+T10F2.4	F53B7.3
+T10G3.6	F53B7.3
+T11G6.8	F53B7.3
+T12A2.7	F53B7.3
+T13H5.4	F53B7.3
+T21D12.3	F53B7.3
+T27F2.1	F53B7.3
+T28D9.10	F53B7.3
+W02B12.2	F53B7.3
+W02B12.3	F53B7.3
+W03F9.10	F53B7.3
+W04D2.6	F53B7.3
+W07E6.4	F53B7.3
+W08E3.1	F53B7.3
+Y108G3AL.2	F53B7.3
+Y110A7A.8	F53B7.3
+Y111B2A.18	F53B7.3
+Y116A8C.34	F53B7.3
+Y116A8C.35	F53B7.3
+Y116A8C.42	F53B7.3
+Y46G5A.4	F53B7.3
+Y47G6A.20	F53B7.3
+Y49E10.15	F53B7.3
+Y54F10BM.14	F53B7.3
+Y59A8B.6	F53B7.3
+Y62E10A.12	F53B7.3
+Y65B4A.6	F53B7.3
+Y69A2AR.21	F53B7.3
+Y71D11A.2	F53B7.3
+Y71F9B.4	F53B7.3
+Y71G12B.14	F53B7.3
+Y73B6BL.32	F53B7.3
+Y80D3A.2	F53B7.3
+Y92C3B.2	F53B7.3
+ZK1098.1	F53B7.3
+ZK1127.9	F53B7.3
+ZK328.2	F53B7.3
+ZK593.7	F53B7.3
+ZK652.1	F53B7.3
+ZK686.4	F53B7.3
+F56D2.6	F53H1.1
+F58B3.7	F53H1.1
+F58E10.3	F53H1.1
+H20J04.8	F53H1.1
+K02F2.3	F53H1.1
+K03H1.2	F53H1.1
+K04G7.10	F53H1.1
+K04G7.11	F53H1.1
+K07C5.6	F53H1.1
+M01E11.2	F53H1.1
+M03C11.7	F53H1.1
+M03F8.3	F53H1.1
+M18.7	F53H1.1
+M28.5	F53H1.1
+R05D11.7	F53H1.1
+R07E5.14	F53H1.1
+R09B3.5	F53H1.1
+T01B7.4	F53H1.1
+T02H6.2	F53H1.1
+T08A11.2	F53H1.1
+T10C6.5	F53H1.1
+T10F2.4	F53H1.1
+T10G3.6	F53H1.1
+T11G6.8	F53H1.1
+T12A2.7	F53H1.1
+T13H5.4	F53H1.1
+T21D12.3	F53H1.1
+T27F2.1	F53H1.1
+T28D9.10	F53H1.1
+W02B12.2	F53H1.1
+W02B12.3	F53H1.1
+W03F9.10	F53H1.1
+W04D2.6	F53H1.1
+W07E6.4	F53H1.1
+W08E3.1	F53H1.1
+Y108G3AL.2	F53H1.1
+Y110A7A.8	F53H1.1
+Y111B2A.18	F53H1.1
+Y116A8C.34	F53H1.1
+Y116A8C.35	F53H1.1
+Y116A8C.42	F53H1.1
+Y46G5A.4	F53H1.1
+Y47G6A.20	F53H1.1
+Y49E10.15	F53H1.1
+Y54F10BM.14	F53H1.1
+Y59A8B.6	F53H1.1
+Y62E10A.12	F53H1.1
+Y65B4A.6	F53H1.1
+Y69A2AR.21	F53H1.1
+Y71D11A.2	F53H1.1
+Y71F9B.4	F53H1.1
+Y71G12B.14	F53H1.1
+Y73B6BL.32	F53H1.1
+Y80D3A.2	F53H1.1
+Y92C3B.2	F53H1.1
+ZK1098.1	F53H1.1
+ZK1127.9	F53H1.1
+ZK328.2	F53H1.1
+ZK593.7	F53H1.1
+ZK652.1	F53H1.1
+ZK686.4	F53H1.1
+F58B3.7	F56D2.6
+F58E10.3	F56D2.6
+H20J04.8	F56D2.6
+K02F2.3	F56D2.6
+K03H1.2	F56D2.6
+K04G7.10	F56D2.6
+K04G7.11	F56D2.6
+K07C5.6	F56D2.6
+M01E11.2	F56D2.6
+M03C11.7	F56D2.6
+M03F8.3	F56D2.6
+M18.7	F56D2.6
+M28.5	F56D2.6
+R05D11.7	F56D2.6
+R07E5.14	F56D2.6
+R09B3.5	F56D2.6
+T01B7.4	F56D2.6
+T02H6.2	F56D2.6
+T08A11.2	F56D2.6
+T10C6.5	F56D2.6
+T10F2.4	F56D2.6
+T10G3.6	F56D2.6
+T11G6.8	F56D2.6
+T12A2.7	F56D2.6
+T13H5.4	F56D2.6
+T21D12.3	F56D2.6
+T27F2.1	F56D2.6
+T28D9.10	F56D2.6
+W02B12.2	F56D2.6
+W02B12.3	F56D2.6
+W03F9.10	F56D2.6
+W04D2.6	F56D2.6
+W07E6.4	F56D2.6
+W08E3.1	F56D2.6
+Y108G3AL.2	F56D2.6
+Y110A7A.8	F56D2.6
+Y111B2A.18	F56D2.6
+Y116A8C.34	F56D2.6
+Y116A8C.35	F56D2.6
+Y116A8C.42	F56D2.6
+Y46G5A.4	F56D2.6
+Y47G6A.20	F56D2.6
+Y49E10.15	F56D2.6
+Y54F10BM.14	F56D2.6
+Y59A8B.6	F56D2.6
+Y62E10A.12	F56D2.6
+Y65B4A.6	F56D2.6
+Y69A2AR.21	F56D2.6
+Y71D11A.2	F56D2.6
+Y71F9B.4	F56D2.6
+Y71G12B.14	F56D2.6
+Y73B6BL.32	F56D2.6
+Y80D3A.2	F56D2.6
+Y92C3B.2	F56D2.6
+ZK1098.1	F56D2.6
+ZK1127.9	F56D2.6
+ZK328.2	F56D2.6
+ZK593.7	F56D2.6
+ZK652.1	F56D2.6
+ZK686.4	F56D2.6
+F58E10.3	F58B3.7
+H20J04.8	F58B3.7
+K02F2.3	F58B3.7
+K03H1.2	F58B3.7
+K04G7.10	F58B3.7
+K04G7.11	F58B3.7
+K07C5.6	F58B3.7
+M01E11.2	F58B3.7
+M03C11.7	F58B3.7
+M03F8.3	F58B3.7
+M18.7	F58B3.7
+M28.5	F58B3.7
+R05D11.7	F58B3.7
+R07E5.14	F58B3.7
+R09B3.5	F58B3.7
+T01B7.4	F58B3.7
+T02H6.2	F58B3.7
+T08A11.2	F58B3.7
+T10C6.5	F58B3.7
+T10F2.4	F58B3.7
+T10G3.6	F58B3.7
+T11G6.8	F58B3.7
+T12A2.7	F58B3.7
+T13H5.4	F58B3.7
+T21D12.3	F58B3.7
+T27F2.1	F58B3.7
+T28D9.10	F58B3.7
+W02B12.2	F58B3.7
+W02B12.3	F58B3.7
+W03F9.10	F58B3.7
+W04D2.6	F58B3.7
+W07E6.4	F58B3.7
+W08E3.1	F58B3.7
+Y108G3AL.2	F58B3.7
+Y110A7A.8	F58B3.7
+Y111B2A.18	F58B3.7
+Y116A8C.34	F58B3.7
+Y116A8C.35	F58B3.7
+Y116A8C.42	F58B3.7
+Y46G5A.4	F58B3.7
+Y47G6A.20	F58B3.7
+Y49E10.15	F58B3.7
+Y54F10BM.14	F58B3.7
+Y59A8B.6	F58B3.7
+Y62E10A.12	F58B3.7
+Y65B4A.6	F58B3.7
+Y69A2AR.21	F58B3.7
+Y71D11A.2	F58B3.7
+Y71F9B.4	F58B3.7
+Y71G12B.14	F58B3.7
+Y73B6BL.32	F58B3.7
+Y80D3A.2	F58B3.7
+Y92C3B.2	F58B3.7
+ZK1098.1	F58B3.7
+ZK1127.9	F58B3.7
+ZK328.2	F58B3.7
+ZK593.7	F58B3.7
+ZK652.1	F58B3.7
+ZK686.4	F58B3.7
+H20J04.8	F58E10.3
+K02F2.3	F58E10.3
+K03H1.2	F58E10.3
+K04G7.10	F58E10.3
+K04G7.11	F58E10.3
+K07C5.6	F58E10.3
+M01E11.2	F58E10.3
+M03C11.7	F58E10.3
+M03F8.3	F58E10.3
+M18.7	F58E10.3
+M28.5	F58E10.3
+R05D11.7	F58E10.3
+R07E5.14	F58E10.3
+R09B3.5	F58E10.3
+T01B7.4	F58E10.3
+T02H6.2	F58E10.3
+T08A11.2	F58E10.3
+T10C6.5	F58E10.3
+T10F2.4	F58E10.3
+T10G3.6	F58E10.3
+T11G6.8	F58E10.3
+T12A2.7	F58E10.3
+T13H5.4	F58E10.3
+T21D12.3	F58E10.3
+T27F2.1	F58E10.3
+T28D9.10	F58E10.3
+W02B12.2	F58E10.3
+W02B12.3	F58E10.3
+W03F9.10	F58E10.3
+W04D2.6	F58E10.3
+W07E6.4	F58E10.3
+W08E3.1	F58E10.3
+Y108G3AL.2	F58E10.3
+Y110A7A.8	F58E10.3
+Y111B2A.18	F58E10.3
+Y116A8C.34	F58E10.3
+Y116A8C.35	F58E10.3
+Y116A8C.42	F58E10.3
+Y46G5A.4	F58E10.3
+Y47G6A.20	F58E10.3
+Y49E10.15	F58E10.3
+Y54F10BM.14	F58E10.3
+Y59A8B.6	F58E10.3
+Y62E10A.12	F58E10.3
+Y65B4A.6	F58E10.3
+Y69A2AR.21	F58E10.3
+Y71D11A.2	F58E10.3
+Y71F9B.4	F58E10.3
+Y71G12B.14	F58E10.3
+Y73B6BL.32	F58E10.3
+Y80D3A.2	F58E10.3
+Y92C3B.2	F58E10.3
+ZK1098.1	F58E10.3
+ZK1127.9	F58E10.3
+ZK328.2	F58E10.3
+ZK593.7	F58E10.3
+ZK652.1	F58E10.3
+ZK686.4	F58E10.3
+K02F2.3	H20J04.8
+K03H1.2	H20J04.8
+K04G7.10	H20J04.8
+K04G7.11	H20J04.8
+K07C5.6	H20J04.8
+M01E11.2	H20J04.8
+M03C11.7	H20J04.8
+M03F8.3	H20J04.8
+M18.7	H20J04.8
+M28.5	H20J04.8
+R05D11.7	H20J04.8
+R07E5.14	H20J04.8
+R09B3.5	H20J04.8
+T01B7.4	H20J04.8
+T02H6.2	H20J04.8
+T08A11.2	H20J04.8
+T10C6.5	H20J04.8
+T10F2.4	H20J04.8
+T10G3.6	H20J04.8
+T11G6.8	H20J04.8
+T12A2.7	H20J04.8
+T13H5.4	H20J04.8
+T21D12.3	H20J04.8
+T27F2.1	H20J04.8
+T28D9.10	H20J04.8
+W02B12.2	H20J04.8
+W02B12.3	H20J04.8
+W03F9.10	H20J04.8
+W04D2.6	H20J04.8
+W07E6.4	H20J04.8
+W08E3.1	H20J04.8
+Y108G3AL.2	H20J04.8
+Y110A7A.8	H20J04.8
+Y111B2A.18	H20J04.8
+Y116A8C.34	H20J04.8
+Y116A8C.35	H20J04.8
+Y116A8C.42	H20J04.8
+Y46G5A.4	H20J04.8
+Y47G6A.20	H20J04.8
+Y49E10.15	H20J04.8
+Y54F10BM.14	H20J04.8
+Y59A8B.6	H20J04.8
+Y62E10A.12	H20J04.8
+Y65B4A.6	H20J04.8
+Y69A2AR.21	H20J04.8
+Y71D11A.2	H20J04.8
+Y71F9B.4	H20J04.8
+Y71G12B.14	H20J04.8
+Y73B6BL.32	H20J04.8
+Y80D3A.2	H20J04.8
+Y92C3B.2	H20J04.8
+ZK1098.1	H20J04.8
+ZK1127.9	H20J04.8
+ZK328.2	H20J04.8
+ZK593.7	H20J04.8
+ZK652.1	H20J04.8
+ZK686.4	H20J04.8
+K03H1.2	K02F2.3
+K04G7.10	K02F2.3
+K04G7.11	K02F2.3
+K07C5.6	K02F2.3
+M01E11.2	K02F2.3
+M03C11.7	K02F2.3
+M03F8.3	K02F2.3
+M18.7	K02F2.3
+M28.5	K02F2.3
+R05D11.7	K02F2.3
+R07E5.14	K02F2.3
+R09B3.5	K02F2.3
+T01B7.4	K02F2.3
+T02H6.2	K02F2.3
+T08A11.2	K02F2.3
+T10C6.5	K02F2.3
+T10F2.4	K02F2.3
+T10G3.6	K02F2.3
+T11G6.8	K02F2.3
+T12A2.7	K02F2.3
+T13H5.4	K02F2.3
+T21D12.3	K02F2.3
+T27F2.1	K02F2.3
+T28D9.10	K02F2.3
+W02B12.2	K02F2.3
+W02B12.3	K02F2.3
+W03F9.10	K02F2.3
+W04D2.6	K02F2.3
+W07E6.4	K02F2.3
+W08E3.1	K02F2.3
+Y108G3AL.2	K02F2.3
+Y110A7A.8	K02F2.3
+Y111B2A.18	K02F2.3
+Y116A8C.34	K02F2.3
+Y116A8C.35	K02F2.3
+Y116A8C.42	K02F2.3
+Y46G5A.4	K02F2.3
+Y47G6A.20	K02F2.3
+Y49E10.15	K02F2.3
+Y54F10BM.14	K02F2.3
+Y59A8B.6	K02F2.3
+Y62E10A.12	K02F2.3
+Y65B4A.6	K02F2.3
+Y69A2AR.21	K02F2.3
+Y71D11A.2	K02F2.3
+Y71F9B.4	K02F2.3
+Y71G12B.14	K02F2.3
+Y73B6BL.32	K02F2.3
+Y80D3A.2	K02F2.3
+Y92C3B.2	K02F2.3
+ZK1098.1	K02F2.3
+ZK1127.9	K02F2.3
+ZK328.2	K02F2.3
+ZK593.7	K02F2.3
+ZK652.1	K02F2.3
+ZK686.4	K02F2.3
+K04G7.10	K03H1.2
+K04G7.11	K03H1.2
+K07C5.6	K03H1.2
+M01E11.2	K03H1.2
+M03C11.7	K03H1.2
+M03F8.3	K03H1.2
+M18.7	K03H1.2
+M28.5	K03H1.2
+R05D11.7	K03H1.2
+R07E5.14	K03H1.2
+R09B3.5	K03H1.2
+T01B7.4	K03H1.2
+T02H6.2	K03H1.2
+T08A11.2	K03H1.2
+T10C6.5	K03H1.2
+T10F2.4	K03H1.2
+T10G3.6	K03H1.2
+T11G6.8	K03H1.2
+T12A2.7	K03H1.2
+T13H5.4	K03H1.2
+T21D12.3	K03H1.2
+T27F2.1	K03H1.2
+T28D9.10	K03H1.2
+W02B12.2	K03H1.2
+W02B12.3	K03H1.2
+W03F9.10	K03H1.2
+W04D2.6	K03H1.2
+W07E6.4	K03H1.2
+W08E3.1	K03H1.2
+Y108G3AL.2	K03H1.2
+Y110A7A.8	K03H1.2
+Y111B2A.18	K03H1.2
+Y116A8C.34	K03H1.2
+Y116A8C.35	K03H1.2
+Y116A8C.42	K03H1.2
+Y46G5A.4	K03H1.2
+Y47G6A.20	K03H1.2
+Y49E10.15	K03H1.2
+Y54F10BM.14	K03H1.2
+Y59A8B.6	K03H1.2
+Y62E10A.12	K03H1.2
+Y65B4A.6	K03H1.2
+Y69A2AR.21	K03H1.2
+Y71D11A.2	K03H1.2
+Y71F9B.4	K03H1.2
+Y71G12B.14	K03H1.2
+Y73B6BL.32	K03H1.2
+Y80D3A.2	K03H1.2
+Y92C3B.2	K03H1.2
+ZK1098.1	K03H1.2
+ZK1127.9	K03H1.2
+ZK328.2	K03H1.2
+ZK593.7	K03H1.2
+ZK652.1	K03H1.2
+ZK686.4	K03H1.2
+K04G7.11	K04G7.10
+K07C5.6	K04G7.10
+M01E11.2	K04G7.10
+M03C11.7	K04G7.10
+M03F8.3	K04G7.10
+M18.7	K04G7.10
+M28.5	K04G7.10
+R05D11.7	K04G7.10
+R07E5.14	K04G7.10
+R09B3.5	K04G7.10
+T01B7.4	K04G7.10
+T02H6.2	K04G7.10
+T08A11.2	K04G7.10
+T10C6.5	K04G7.10
+T10F2.4	K04G7.10
+T10G3.6	K04G7.10
+T11G6.8	K04G7.10
+T12A2.7	K04G7.10
+T13H5.4	K04G7.10
+T21D12.3	K04G7.10
+T27F2.1	K04G7.10
+T28D9.10	K04G7.10
+W02B12.2	K04G7.10
+W02B12.3	K04G7.10
+W03F9.10	K04G7.10
+W04D2.6	K04G7.10
+W07E6.4	K04G7.10
+W08E3.1	K04G7.10
+Y108G3AL.2	K04G7.10
+Y110A7A.8	K04G7.10
+Y111B2A.18	K04G7.10
+Y116A8C.34	K04G7.10
+Y116A8C.35	K04G7.10
+Y116A8C.42	K04G7.10
+Y46G5A.4	K04G7.10
+Y47G6A.20	K04G7.10
+Y49E10.15	K04G7.10
+Y54F10BM.14	K04G7.10
+Y59A8B.6	K04G7.10
+Y62E10A.12	K04G7.10
+Y65B4A.6	K04G7.10
+Y69A2AR.21	K04G7.10
+Y71D11A.2	K04G7.10
+Y71F9B.4	K04G7.10
+Y71G12B.14	K04G7.10
+Y73B6BL.32	K04G7.10
+Y80D3A.2	K04G7.10
+Y92C3B.2	K04G7.10
+ZK1098.1	K04G7.10
+ZK1127.9	K04G7.10
+ZK328.2	K04G7.10
+ZK593.7	K04G7.10
+ZK652.1	K04G7.10
+ZK686.4	K04G7.10
+K07C5.6	K04G7.11
+M01E11.2	K04G7.11
+M03C11.7	K04G7.11
+M03F8.3	K04G7.11
+M18.7	K04G7.11
+M28.5	K04G7.11
+R05D11.7	K04G7.11
+R07E5.14	K04G7.11
+R09B3.5	K04G7.11
+T01B7.4	K04G7.11
+T02H6.2	K04G7.11
+T08A11.2	K04G7.11
+T10C6.5	K04G7.11
+T10F2.4	K04G7.11
+T10G3.6	K04G7.11
+T11G6.8	K04G7.11
+T12A2.7	K04G7.11
+T13H5.4	K04G7.11
+T21D12.3	K04G7.11
+T27F2.1	K04G7.11
+T28D9.10	K04G7.11
+W02B12.2	K04G7.11
+W02B12.3	K04G7.11
+W03F9.10	K04G7.11
+W04D2.6	K04G7.11
+W07E6.4	K04G7.11
+W08E3.1	K04G7.11
+Y108G3AL.2	K04G7.11
+Y110A7A.8	K04G7.11
+Y111B2A.18	K04G7.11
+Y116A8C.34	K04G7.11
+Y116A8C.35	K04G7.11
+Y116A8C.42	K04G7.11
+Y46G5A.4	K04G7.11
+Y47G6A.20	K04G7.11
+Y49E10.15	K04G7.11
+Y54F10BM.14	K04G7.11
+Y59A8B.6	K04G7.11
+Y62E10A.12	K04G7.11
+Y65B4A.6	K04G7.11
+Y69A2AR.21	K04G7.11
+Y71D11A.2	K04G7.11
+Y71F9B.4	K04G7.11
+Y71G12B.14	K04G7.11
+Y73B6BL.32	K04G7.11
+Y80D3A.2	K04G7.11
+Y92C3B.2	K04G7.11
+ZK1098.1	K04G7.11
+ZK1127.9	K04G7.11
+ZK328.2	K04G7.11
+ZK593.7	K04G7.11
+ZK652.1	K04G7.11
+ZK686.4	K04G7.11
+M01E11.2	K07C5.6
+M03C11.7	K07C5.6
+M03F8.3	K07C5.6
+M18.7	K07C5.6
+M28.5	K07C5.6
+R05D11.7	K07C5.6
+R07E5.14	K07C5.6
+R09B3.5	K07C5.6
+T01B7.4	K07C5.6
+T02H6.2	K07C5.6
+T08A11.2	K07C5.6
+T10C6.5	K07C5.6
+T10F2.4	K07C5.6
+T10G3.6	K07C5.6
+T11G6.8	K07C5.6
+T12A2.7	K07C5.6
+T13H5.4	K07C5.6
+T21D12.3	K07C5.6
+T27F2.1	K07C5.6
+T28D9.10	K07C5.6
+W02B12.2	K07C5.6
+W02B12.3	K07C5.6
+W03F9.10	K07C5.6
+W04D2.6	K07C5.6
+W07E6.4	K07C5.6
+W08E3.1	K07C5.6
+Y108G3AL.2	K07C5.6
+Y110A7A.8	K07C5.6
+Y111B2A.18	K07C5.6
+Y116A8C.34	K07C5.6
+Y116A8C.35	K07C5.6
+Y116A8C.42	K07C5.6
+Y46G5A.4	K07C5.6
+Y47G6A.20	K07C5.6
+Y49E10.15	K07C5.6
+Y54F10BM.14	K07C5.6
+Y59A8B.6	K07C5.6
+Y62E10A.12	K07C5.6
+Y65B4A.6	K07C5.6
+Y69A2AR.21	K07C5.6
+Y71D11A.2	K07C5.6
+Y71F9B.4	K07C5.6
+Y71G12B.14	K07C5.6
+Y73B6BL.32	K07C5.6
+Y80D3A.2	K07C5.6
+Y92C3B.2	K07C5.6
+ZK1098.1	K07C5.6
+ZK1127.9	K07C5.6
+ZK328.2	K07C5.6
+ZK593.7	K07C5.6
+ZK652.1	K07C5.6
+ZK686.4	K07C5.6
+M03C11.7	M01E11.2
+M03F8.3	M01E11.2
+M18.7	M01E11.2
+M28.5	M01E11.2
+R05D11.7	M01E11.2
+R07E5.14	M01E11.2
+R09B3.5	M01E11.2
+T01B7.4	M01E11.2
+T02H6.2	M01E11.2
+T08A11.2	M01E11.2
+T10C6.5	M01E11.2
+T10F2.4	M01E11.2
+T10G3.6	M01E11.2
+T11G6.8	M01E11.2
+T12A2.7	M01E11.2
+T13H5.4	M01E11.2
+T21D12.3	M01E11.2
+T27F2.1	M01E11.2
+T28D9.10	M01E11.2
+W02B12.2	M01E11.2
+W02B12.3	M01E11.2
+W03F9.10	M01E11.2
+W04D2.6	M01E11.2
+W07E6.4	M01E11.2
+W08E3.1	M01E11.2
+Y108G3AL.2	M01E11.2
+Y110A7A.8	M01E11.2
+Y111B2A.18	M01E11.2
+Y116A8C.34	M01E11.2
+Y116A8C.35	M01E11.2
+Y116A8C.42	M01E11.2
+Y46G5A.4	M01E11.2
+Y47G6A.20	M01E11.2
+Y49E10.15	M01E11.2
+Y54F10BM.14	M01E11.2
+Y59A8B.6	M01E11.2
+Y62E10A.12	M01E11.2
+Y65B4A.6	M01E11.2
+Y69A2AR.21	M01E11.2
+Y71D11A.2	M01E11.2
+Y71F9B.4	M01E11.2
+Y71G12B.14	M01E11.2
+Y73B6BL.32	M01E11.2
+Y80D3A.2	M01E11.2
+Y92C3B.2	M01E11.2
+ZK1098.1	M01E11.2
+ZK1127.9	M01E11.2
+ZK328.2	M01E11.2
+ZK593.7	M01E11.2
+ZK652.1	M01E11.2
+ZK686.4	M01E11.2
+M03F8.3	M03C11.7
+M18.7	M03C11.7
+M28.5	M03C11.7
+R05D11.7	M03C11.7
+R07E5.14	M03C11.7
+R09B3.5	M03C11.7
+T01B7.4	M03C11.7
+T02H6.2	M03C11.7
+T08A11.2	M03C11.7
+T10C6.5	M03C11.7
+T10F2.4	M03C11.7
+T10G3.6	M03C11.7
+T11G6.8	M03C11.7
+T12A2.7	M03C11.7
+T13H5.4	M03C11.7
+T21D12.3	M03C11.7
+T27F2.1	M03C11.7
+T28D9.10	M03C11.7
+W02B12.2	M03C11.7
+W02B12.3	M03C11.7
+W03F9.10	M03C11.7
+W04D2.6	M03C11.7
+W07E6.4	M03C11.7
+W08E3.1	M03C11.7
+Y108G3AL.2	M03C11.7
+Y110A7A.8	M03C11.7
+Y111B2A.18	M03C11.7
+Y116A8C.34	M03C11.7
+Y116A8C.35	M03C11.7
+Y116A8C.42	M03C11.7
+Y46G5A.4	M03C11.7
+Y47G6A.20	M03C11.7
+Y49E10.15	M03C11.7
+Y54F10BM.14	M03C11.7
+Y59A8B.6	M03C11.7
+Y62E10A.12	M03C11.7
+Y65B4A.6	M03C11.7
+Y69A2AR.21	M03C11.7
+Y71D11A.2	M03C11.7
+Y71F9B.4	M03C11.7
+Y71G12B.14	M03C11.7
+Y73B6BL.32	M03C11.7
+Y80D3A.2	M03C11.7
+Y92C3B.2	M03C11.7
+ZK1098.1	M03C11.7
+ZK1127.9	M03C11.7
+ZK328.2	M03C11.7
+ZK593.7	M03C11.7
+ZK652.1	M03C11.7
+ZK686.4	M03C11.7
+M18.7	M03F8.3
+M28.5	M03F8.3
+R05D11.7	M03F8.3
+R07E5.14	M03F8.3
+R09B3.5	M03F8.3
+T01B7.4	M03F8.3
+T02H6.2	M03F8.3
+T08A11.2	M03F8.3
+T10C6.5	M03F8.3
+T10F2.4	M03F8.3
+T10G3.6	M03F8.3
+T11G6.8	M03F8.3
+T12A2.7	M03F8.3
+T13H5.4	M03F8.3
+T21D12.3	M03F8.3
+T27F2.1	M03F8.3
+T28D9.10	M03F8.3
+W02B12.2	M03F8.3
+W02B12.3	M03F8.3
+W03F9.10	M03F8.3
+W04D2.6	M03F8.3
+W07E6.4	M03F8.3
+W08E3.1	M03F8.3
+Y108G3AL.2	M03F8.3
+Y110A7A.8	M03F8.3
+Y111B2A.18	M03F8.3
+Y116A8C.34	M03F8.3
+Y116A8C.35	M03F8.3
+Y116A8C.42	M03F8.3
+Y46G5A.4	M03F8.3
+Y47G6A.20	M03F8.3
+Y49E10.15	M03F8.3
+Y54F10BM.14	M03F8.3
+Y59A8B.6	M03F8.3
+Y62E10A.12	M03F8.3
+Y65B4A.6	M03F8.3
+Y69A2AR.21	M03F8.3
+Y71D11A.2	M03F8.3
+Y71F9B.4	M03F8.3
+Y71G12B.14	M03F8.3
+Y73B6BL.32	M03F8.3
+Y80D3A.2	M03F8.3
+Y92C3B.2	M03F8.3
+ZK1098.1	M03F8.3
+ZK1127.9	M03F8.3
+ZK328.2	M03F8.3
+ZK593.7	M03F8.3
+ZK652.1	M03F8.3
+ZK686.4	M03F8.3
+M28.5	M18.7
+R05D11.7	M18.7
+T01B7.4	M18.7
+T08A11.2	M18.7
+T10C6.5	M18.7
+T10F2.4	M18.7
+T10G3.6	M18.7
+T11G6.8	M18.7
+T12A2.7	M18.7
+T13H5.4	M18.7
+T21D12.3	M18.7
+T27F2.1	M18.7
+T28D9.10	M18.7
+W02B12.2	M18.7
+W02B12.3	M18.7
+W03F9.10	M18.7
+W04D2.6	M18.7
+W07E6.4	M18.7
+W08E3.1	M18.7
+Y108G3AL.2	M18.7
+Y110A7A.8	M18.7
+Y111B2A.18	M18.7
+Y116A8C.34	M18.7
+Y116A8C.35	M18.7
+Y116A8C.42	M18.7
+Y46G5A.4	M18.7
+Y47G6A.20	M18.7
+Y49E10.15	M18.7
+Y54F10BM.14	M18.7
+Y59A8B.6	M18.7
+Y62E10A.12	M18.7
+Y69A2AR.21	M18.7
+Y71D11A.2	M18.7
+Y71F9B.4	M18.7
+Y71G12B.14	M18.7
+Y73B6BL.32	M18.7
+Y80D3A.2	M18.7
+Y92C3B.2	M18.7
+ZK1098.1	M18.7
+ZK1127.9	M18.7
+ZK328.2	M18.7
+ZK593.7	M18.7
+ZK652.1	M18.7
+ZK686.4	M18.7
+R05D11.7	M28.5
+R07E5.14	M28.5
+R09B3.5	M28.5
+T01B7.4	M28.5
+T02H6.2	M28.5
+T08A11.2	M28.5
+T10C6.5	M28.5
+T10F2.4	M28.5
+T10G3.6	M28.5
+T11G6.8	M28.5
+T12A2.7	M28.5
+T13H5.4	M28.5
+T21D12.3	M28.5
+T27F2.1	M28.5
+T28D9.10	M28.5
+W02B12.2	M28.5
+W02B12.3	M28.5
+W03F9.10	M28.5
+W04D2.6	M28.5
+W07E6.4	M28.5
+W08E3.1	M28.5
+Y108G3AL.2	M28.5
+Y110A7A.8	M28.5
+Y111B2A.18	M28.5
+Y116A8C.34	M28.5
+Y116A8C.35	M28.5
+Y116A8C.42	M28.5
+Y46G5A.4	M28.5
+Y47G6A.20	M28.5
+Y49E10.15	M28.5
+Y54F10BM.14	M28.5
+Y59A8B.6	M28.5
+Y62E10A.12	M28.5
+Y65B4A.6	M28.5
+Y69A2AR.21	M28.5
+Y71D11A.2	M28.5
+Y71F9B.4	M28.5
+Y71G12B.14	M28.5
+Y73B6BL.32	M28.5
+Y80D3A.2	M28.5
+Y92C3B.2	M28.5
+ZK1098.1	M28.5
+ZK1127.9	M28.5
+ZK328.2	M28.5
+ZK593.7	M28.5
+ZK652.1	M28.5
+ZK686.4	M28.5
+R07E5.14	R05D11.7
+R09B3.5	R05D11.7
+T01B7.4	R05D11.7
+T02H6.2	R05D11.7
+T08A11.2	R05D11.7
+T10C6.5	R05D11.7
+T10F2.4	R05D11.7
+T10G3.6	R05D11.7
+T11G6.8	R05D11.7
+T12A2.7	R05D11.7
+T13H5.4	R05D11.7
+T21D12.3	R05D11.7
+T27F2.1	R05D11.7
+T28D9.10	R05D11.7
+W02B12.2	R05D11.7
+W02B12.3	R05D11.7
+W03F9.10	R05D11.7
+W04D2.6	R05D11.7
+W07E6.4	R05D11.7
+W08E3.1	R05D11.7
+Y108G3AL.2	R05D11.7
+Y110A7A.8	R05D11.7
+Y111B2A.18	R05D11.7
+Y116A8C.34	R05D11.7
+Y116A8C.35	R05D11.7
+Y116A8C.42	R05D11.7
+Y46G5A.4	R05D11.7
+Y47G6A.20	R05D11.7
+Y49E10.15	R05D11.7
+Y54F10BM.14	R05D11.7
+Y59A8B.6	R05D11.7
+Y62E10A.12	R05D11.7
+Y65B4A.6	R05D11.7
+Y69A2AR.21	R05D11.7
+Y71D11A.2	R05D11.7
+Y71F9B.4	R05D11.7
+Y71G12B.14	R05D11.7
+Y73B6BL.32	R05D11.7
+Y80D3A.2	R05D11.7
+Y92C3B.2	R05D11.7
+ZK1098.1	R05D11.7
+ZK1127.9	R05D11.7
+ZK328.2	R05D11.7
+ZK593.7	R05D11.7
+ZK652.1	R05D11.7
+ZK686.4	R05D11.7
+T01B7.4	R07E5.14
+T08A11.2	R07E5.14
+T10C6.5	R07E5.14
+T10F2.4	R07E5.14
+T10G3.6	R07E5.14
+T11G6.8	R07E5.14
+T12A2.7	R07E5.14
+T13H5.4	R07E5.14
+T21D12.3	R07E5.14
+T27F2.1	R07E5.14
+T28D9.10	R07E5.14
+W02B12.2	R07E5.14
+W02B12.3	R07E5.14
+W03F9.10	R07E5.14
+W04D2.6	R07E5.14
+W07E6.4	R07E5.14
+W08E3.1	R07E5.14
+Y108G3AL.2	R07E5.14
+Y110A7A.8	R07E5.14
+Y111B2A.18	R07E5.14
+Y116A8C.34	R07E5.14
+Y116A8C.35	R07E5.14
+Y116A8C.42	R07E5.14
+Y46G5A.4	R07E5.14
+Y47G6A.20	R07E5.14
+Y49E10.15	R07E5.14
+Y54F10BM.14	R07E5.14
+Y59A8B.6	R07E5.14
+Y62E10A.12	R07E5.14
+Y69A2AR.21	R07E5.14
+Y71D11A.2	R07E5.14
+Y71F9B.4	R07E5.14
+Y71G12B.14	R07E5.14
+Y73B6BL.32	R07E5.14
+Y80D3A.2	R07E5.14
+Y92C3B.2	R07E5.14
+ZK1098.1	R07E5.14
+ZK1127.9	R07E5.14
+ZK328.2	R07E5.14
+ZK593.7	R07E5.14
+ZK652.1	R07E5.14
+ZK686.4	R07E5.14
+T01B7.4	R09B3.5
+T08A11.2	R09B3.5
+T10C6.5	R09B3.5
+T10F2.4	R09B3.5
+T10G3.6	R09B3.5
+T11G6.8	R09B3.5
+T12A2.7	R09B3.5
+T13H5.4	R09B3.5
+T21D12.3	R09B3.5
+T27F2.1	R09B3.5
+T28D9.10	R09B3.5
+W02B12.2	R09B3.5
+W02B12.3	R09B3.5
+W03F9.10	R09B3.5
+W04D2.6	R09B3.5
+W07E6.4	R09B3.5
+W08E3.1	R09B3.5
+Y108G3AL.2	R09B3.5
+Y110A7A.8	R09B3.5
+Y111B2A.18	R09B3.5
+Y116A8C.34	R09B3.5
+Y116A8C.35	R09B3.5
+Y116A8C.42	R09B3.5
+Y46G5A.4	R09B3.5
+Y47G6A.20	R09B3.5
+Y49E10.15	R09B3.5
+Y54F10BM.14	R09B3.5
+Y59A8B.6	R09B3.5
+Y62E10A.12	R09B3.5
+Y69A2AR.21	R09B3.5
+Y71D11A.2	R09B3.5
+Y71F9B.4	R09B3.5
+Y71G12B.14	R09B3.5
+Y73B6BL.32	R09B3.5
+Y80D3A.2	R09B3.5
+Y92C3B.2	R09B3.5
+ZK1098.1	R09B3.5
+ZK1127.9	R09B3.5
+ZK328.2	R09B3.5
+ZK593.7	R09B3.5
+ZK652.1	R09B3.5
+ZK686.4	R09B3.5
+T02H6.2	T01B7.4
+T08A11.2	T01B7.4
+T10C6.5	T01B7.4
+T10F2.4	T01B7.4
+T10G3.6	T01B7.4
+T11G6.8	T01B7.4
+T12A2.7	T01B7.4
+T13H5.4	T01B7.4
+T21D12.3	T01B7.4
+T27F2.1	T01B7.4
+T28D9.10	T01B7.4
+W02B12.2	T01B7.4
+W02B12.3	T01B7.4
+W03F9.10	T01B7.4
+W04D2.6	T01B7.4
+W07E6.4	T01B7.4
+W08E3.1	T01B7.4
+Y108G3AL.2	T01B7.4
+Y110A7A.8	T01B7.4
+Y111B2A.18	T01B7.4
+Y116A8C.34	T01B7.4
+Y116A8C.35	T01B7.4
+Y116A8C.42	T01B7.4
+Y46G5A.4	T01B7.4
+Y47G6A.20	T01B7.4
+Y49E10.15	T01B7.4
+Y54F10BM.14	T01B7.4
+Y59A8B.6	T01B7.4
+Y62E10A.12	T01B7.4
+Y65B4A.6	T01B7.4
+Y69A2AR.21	T01B7.4
+Y71D11A.2	T01B7.4
+Y71F9B.4	T01B7.4
+Y71G12B.14	T01B7.4
+Y73B6BL.32	T01B7.4
+Y80D3A.2	T01B7.4
+Y92C3B.2	T01B7.4
+ZK1098.1	T01B7.4
+ZK1127.9	T01B7.4
+ZK328.2	T01B7.4
+ZK593.7	T01B7.4
+ZK652.1	T01B7.4
+ZK686.4	T01B7.4
+T08A11.2	T02H6.2
+T10C6.5	T02H6.2
+T10F2.4	T02H6.2
+T10G3.6	T02H6.2
+T11G6.8	T02H6.2
+T12A2.7	T02H6.2
+T13H5.4	T02H6.2
+T21D12.3	T02H6.2
+T27F2.1	T02H6.2
+T28D9.10	T02H6.2
+W02B12.2	T02H6.2
+W02B12.3	T02H6.2
+W03F9.10	T02H6.2
+W04D2.6	T02H6.2
+W07E6.4	T02H6.2
+W08E3.1	T02H6.2
+Y108G3AL.2	T02H6.2
+Y110A7A.8	T02H6.2
+Y111B2A.18	T02H6.2
+Y116A8C.34	T02H6.2
+Y116A8C.35	T02H6.2
+Y116A8C.42	T02H6.2
+Y46G5A.4	T02H6.2
+Y47G6A.20	T02H6.2
+Y49E10.15	T02H6.2
+Y54F10BM.14	T02H6.2
+Y59A8B.6	T02H6.2
+Y62E10A.12	T02H6.2
+Y69A2AR.21	T02H6.2
+Y71D11A.2	T02H6.2
+Y71F9B.4	T02H6.2
+Y71G12B.14	T02H6.2
+Y73B6BL.32	T02H6.2
+Y80D3A.2	T02H6.2
+Y92C3B.2	T02H6.2
+ZK1098.1	T02H6.2
+ZK1127.9	T02H6.2
+ZK328.2	T02H6.2
+ZK593.7	T02H6.2
+ZK652.1	T02H6.2
+ZK686.4	T02H6.2
+T10C6.5	T08A11.2
+T10F2.4	T08A11.2
+T10G3.6	T08A11.2
+T11G6.8	T08A11.2
+T12A2.7	T08A11.2
+T13H5.4	T08A11.2
+T21D12.3	T08A11.2
+T27F2.1	T08A11.2
+T28D9.10	T08A11.2
+W02B12.2	T08A11.2
+W02B12.3	T08A11.2
+W03F9.10	T08A11.2
+W04D2.6	T08A11.2
+W07E6.4	T08A11.2
+W08E3.1	T08A11.2
+Y108G3AL.2	T08A11.2
+Y110A7A.8	T08A11.2
+Y111B2A.18	T08A11.2
+Y116A8C.34	T08A11.2
+Y116A8C.35	T08A11.2
+Y116A8C.42	T08A11.2
+Y46G5A.4	T08A11.2
+Y47G6A.20	T08A11.2
+Y49E10.15	T08A11.2
+Y54F10BM.14	T08A11.2
+Y59A8B.6	T08A11.2
+Y62E10A.12	T08A11.2
+Y65B4A.6	T08A11.2
+Y69A2AR.21	T08A11.2
+Y71D11A.2	T08A11.2
+Y71F9B.4	T08A11.2
+Y71G12B.14	T08A11.2
+Y73B6BL.32	T08A11.2
+Y80D3A.2	T08A11.2
+Y92C3B.2	T08A11.2
+ZK1098.1	T08A11.2
+ZK1127.9	T08A11.2
+ZK328.2	T08A11.2
+ZK593.7	T08A11.2
+ZK652.1	T08A11.2
+ZK686.4	T08A11.2
+T10F2.4	T10C6.5
+T10G3.6	T10C6.5
+T11G6.8	T10C6.5
+T12A2.7	T10C6.5
+T13H5.4	T10C6.5
+T21D12.3	T10C6.5
+T27F2.1	T10C6.5
+T28D9.10	T10C6.5
+W02B12.2	T10C6.5
+W02B12.3	T10C6.5
+W03F9.10	T10C6.5
+W04D2.6	T10C6.5
+W07E6.4	T10C6.5
+W08E3.1	T10C6.5
+Y108G3AL.2	T10C6.5
+Y110A7A.8	T10C6.5
+Y111B2A.18	T10C6.5
+Y116A8C.34	T10C6.5
+Y116A8C.35	T10C6.5
+Y116A8C.42	T10C6.5
+Y46G5A.4	T10C6.5
+Y47G6A.20	T10C6.5
+Y49E10.15	T10C6.5
+Y54F10BM.14	T10C6.5
+Y59A8B.6	T10C6.5
+Y62E10A.12	T10C6.5
+Y65B4A.6	T10C6.5
+Y69A2AR.21	T10C6.5
+Y71D11A.2	T10C6.5
+Y71F9B.4	T10C6.5
+Y71G12B.14	T10C6.5
+Y73B6BL.32	T10C6.5
+Y80D3A.2	T10C6.5
+ZK1098.1	T10C6.5
+ZK1127.9	T10C6.5
+ZK328.2	T10C6.5
+ZK593.7	T10C6.5
+ZK652.1	T10C6.5
+ZK686.4	T10C6.5
+T10G3.6	T10F2.4
+T11G6.8	T10F2.4
+T12A2.7	T10F2.4
+T13H5.4	T10F2.4
+T21D12.3	T10F2.4
+T27F2.1	T10F2.4
+T28D9.10	T10F2.4
+W02B12.2	T10F2.4
+W02B12.3	T10F2.4
+W03F9.10	T10F2.4
+W04D2.6	T10F2.4
+W07E6.4	T10F2.4
+W08E3.1	T10F2.4
+Y108G3AL.2	T10F2.4
+Y110A7A.8	T10F2.4
+Y111B2A.18	T10F2.4
+Y116A8C.34	T10F2.4
+Y116A8C.35	T10F2.4
+Y116A8C.42	T10F2.4
+Y46G5A.4	T10F2.4
+Y47G6A.20	T10F2.4
+Y49E10.15	T10F2.4
+Y54F10BM.14	T10F2.4
+Y59A8B.6	T10F2.4
+Y62E10A.12	T10F2.4
+Y65B4A.6	T10F2.4
+Y69A2AR.21	T10F2.4
+Y71D11A.2	T10F2.4
+Y71F9B.4	T10F2.4
+Y71G12B.14	T10F2.4
+Y73B6BL.32	T10F2.4
+Y80D3A.2	T10F2.4
+Y92C3B.2	T10F2.4
+ZK1098.1	T10F2.4
+ZK1127.9	T10F2.4
+ZK328.2	T10F2.4
+ZK593.7	T10F2.4
+ZK652.1	T10F2.4
+ZK686.4	T10F2.4
+T11G6.8	T10G3.6
+T12A2.7	T10G3.6
+T13H5.4	T10G3.6
+T21D12.3	T10G3.6
+T27F2.1	T10G3.6
+T28D9.10	T10G3.6
+W02B12.2	T10G3.6
+W02B12.3	T10G3.6
+W03F9.10	T10G3.6
+W04D2.6	T10G3.6
+W07E6.4	T10G3.6
+W08E3.1	T10G3.6
+Y108G3AL.2	T10G3.6
+Y110A7A.8	T10G3.6
+Y111B2A.18	T10G3.6
+Y116A8C.34	T10G3.6
+Y116A8C.35	T10G3.6
+Y116A8C.42	T10G3.6
+Y46G5A.4	T10G3.6
+Y47G6A.20	T10G3.6
+Y49E10.15	T10G3.6
+Y54F10BM.14	T10G3.6
+Y59A8B.6	T10G3.6
+Y65B4A.6	T10G3.6
+Y69A2AR.21	T10G3.6
+Y71D11A.2	T10G3.6
+Y71F9B.4	T10G3.6
+Y80D3A.2	T10G3.6
+Y92C3B.2	T10G3.6
+ZK1098.1	T10G3.6
+ZK1127.9	T10G3.6
+ZK328.2	T10G3.6
+ZK652.1	T10G3.6
+ZK686.4	T10G3.6
+T12A2.7	T11G6.8
+T13H5.4	T11G6.8
+T21D12.3	T11G6.8
+T27F2.1	T11G6.8
+T28D9.10	T11G6.8
+W02B12.2	T11G6.8
+W02B12.3	T11G6.8
+W03F9.10	T11G6.8
+W04D2.6	T11G6.8
+W07E6.4	T11G6.8
+W08E3.1	T11G6.8
+Y108G3AL.2	T11G6.8
+Y110A7A.8	T11G6.8
+Y111B2A.18	T11G6.8
+Y116A8C.34	T11G6.8
+Y116A8C.35	T11G6.8
+Y116A8C.42	T11G6.8
+Y46G5A.4	T11G6.8
+Y47G6A.20	T11G6.8
+Y49E10.15	T11G6.8
+Y54F10BM.14	T11G6.8
+Y59A8B.6	T11G6.8
+Y62E10A.12	T11G6.8
+Y65B4A.6	T11G6.8
+Y69A2AR.21	T11G6.8
+Y71D11A.2	T11G6.8
+Y71F9B.4	T11G6.8
+Y71G12B.14	T11G6.8
+Y73B6BL.32	T11G6.8
+Y80D3A.2	T11G6.8
+Y92C3B.2	T11G6.8
+ZK1098.1	T11G6.8
+ZK1127.9	T11G6.8
+ZK328.2	T11G6.8
+ZK593.7	T11G6.8
+ZK652.1	T11G6.8
+ZK686.4	T11G6.8
+T13H5.4	T12A2.7
+T21D12.3	T12A2.7
+T27F2.1	T12A2.7
+T28D9.10	T12A2.7
+W02B12.2	T12A2.7
+W02B12.3	T12A2.7
+W03F9.10	T12A2.7
+W04D2.6	T12A2.7
+W07E6.4	T12A2.7
+W08E3.1	T12A2.7
+Y108G3AL.2	T12A2.7
+Y110A7A.8	T12A2.7
+Y111B2A.18	T12A2.7
+Y116A8C.34	T12A2.7
+Y116A8C.35	T12A2.7
+Y116A8C.42	T12A2.7
+Y46G5A.4	T12A2.7
+Y47G6A.20	T12A2.7
+Y49E10.15	T12A2.7
+Y54F10BM.14	T12A2.7
+Y59A8B.6	T12A2.7
+Y62E10A.12	T12A2.7
+Y65B4A.6	T12A2.7
+Y69A2AR.21	T12A2.7
+Y71D11A.2	T12A2.7
+Y71F9B.4	T12A2.7
+Y71G12B.14	T12A2.7
+Y73B6BL.32	T12A2.7
+Y80D3A.2	T12A2.7
+Y92C3B.2	T12A2.7
+ZK1098.1	T12A2.7
+ZK1127.9	T12A2.7
+ZK328.2	T12A2.7
+ZK593.7	T12A2.7
+ZK652.1	T12A2.7
+ZK686.4	T12A2.7
+T21D12.3	T13H5.4
+T27F2.1	T13H5.4
+T28D9.10	T13H5.4
+W02B12.2	T13H5.4
+W02B12.3	T13H5.4
+W03F9.10	T13H5.4
+W04D2.6	T13H5.4
+W07E6.4	T13H5.4
+W08E3.1	T13H5.4
+Y108G3AL.2	T13H5.4
+Y110A7A.8	T13H5.4
+Y111B2A.18	T13H5.4
+Y116A8C.34	T13H5.4
+Y116A8C.35	T13H5.4
+Y116A8C.42	T13H5.4
+Y46G5A.4	T13H5.4
+Y47G6A.20	T13H5.4
+Y49E10.15	T13H5.4
+Y54F10BM.14	T13H5.4
+Y59A8B.6	T13H5.4
+Y62E10A.12	T13H5.4
+Y65B4A.6	T13H5.4
+Y69A2AR.21	T13H5.4
+Y71D11A.2	T13H5.4
+Y71F9B.4	T13H5.4
+Y71G12B.14	T13H5.4
+Y73B6BL.32	T13H5.4
+Y80D3A.2	T13H5.4
+Y92C3B.2	T13H5.4
+ZK1098.1	T13H5.4
+ZK1127.9	T13H5.4
+ZK328.2	T13H5.4
+ZK593.7	T13H5.4
+ZK652.1	T13H5.4
+ZK686.4	T13H5.4
+T27F2.1	T21D12.3
+T28D9.10	T21D12.3
+W02B12.2	T21D12.3
+W02B12.3	T21D12.3
+W03F9.10	T21D12.3
+W04D2.6	T21D12.3
+W07E6.4	T21D12.3
+W08E3.1	T21D12.3
+Y108G3AL.2	T21D12.3
+Y110A7A.8	T21D12.3
+Y111B2A.18	T21D12.3
+Y116A8C.34	T21D12.3
+Y116A8C.35	T21D12.3
+Y116A8C.42	T21D12.3
+Y46G5A.4	T21D12.3
+Y47G6A.20	T21D12.3
+Y49E10.15	T21D12.3
+Y54F10BM.14	T21D12.3
+Y59A8B.6	T21D12.3
+Y62E10A.12	T21D12.3
+Y65B4A.6	T21D12.3
+Y69A2AR.21	T21D12.3
+Y71D11A.2	T21D12.3
+Y71F9B.4	T21D12.3
+Y71G12B.14	T21D12.3
+Y73B6BL.32	T21D12.3
+Y80D3A.2	T21D12.3
+Y92C3B.2	T21D12.3
+ZK1098.1	T21D12.3
+ZK1127.9	T21D12.3
+ZK328.2	T21D12.3
+ZK593.7	T21D12.3
+ZK652.1	T21D12.3
+ZK686.4	T21D12.3
+T28D9.10	T27F2.1
+W02B12.2	T27F2.1
+W02B12.3	T27F2.1
+W03F9.10	T27F2.1
+W04D2.6	T27F2.1
+W07E6.4	T27F2.1
+W08E3.1	T27F2.1
+Y108G3AL.2	T27F2.1
+Y110A7A.8	T27F2.1
+Y111B2A.18	T27F2.1
+Y116A8C.34	T27F2.1
+Y116A8C.35	T27F2.1
+Y116A8C.42	T27F2.1
+Y46G5A.4	T27F2.1
+Y47G6A.20	T27F2.1
+Y49E10.15	T27F2.1
+Y54F10BM.14	T27F2.1
+Y59A8B.6	T27F2.1
+Y62E10A.12	T27F2.1
+Y65B4A.6	T27F2.1
+Y69A2AR.21	T27F2.1
+Y71D11A.2	T27F2.1
+Y71F9B.4	T27F2.1
+Y71G12B.14	T27F2.1
+Y73B6BL.32	T27F2.1
+Y80D3A.2	T27F2.1
+Y92C3B.2	T27F2.1
+ZK1098.1	T27F2.1
+ZK1127.9	T27F2.1
+ZK328.2	T27F2.1
+ZK593.7	T27F2.1
+ZK652.1	T27F2.1
+ZK686.4	T27F2.1
+W02B12.2	T28D9.10
+W02B12.3	T28D9.10
+W03F9.10	T28D9.10
+W04D2.6	T28D9.10
+W07E6.4	T28D9.10
+W08E3.1	T28D9.10
+Y108G3AL.2	T28D9.10
+Y110A7A.8	T28D9.10
+Y111B2A.18	T28D9.10
+Y116A8C.34	T28D9.10
+Y116A8C.35	T28D9.10
+Y116A8C.42	T28D9.10
+Y46G5A.4	T28D9.10
+Y47G6A.20	T28D9.10
+Y49E10.15	T28D9.10
+Y54F10BM.14	T28D9.10
+Y59A8B.6	T28D9.10
+Y62E10A.12	T28D9.10
+Y65B4A.6	T28D9.10
+Y69A2AR.21	T28D9.10
+Y71D11A.2	T28D9.10
+Y71F9B.4	T28D9.10
+Y71G12B.14	T28D9.10
+Y73B6BL.32	T28D9.10
+Y80D3A.2	T28D9.10
+Y92C3B.2	T28D9.10
+ZK1098.1	T28D9.10
+ZK1127.9	T28D9.10
+ZK328.2	T28D9.10
+ZK593.7	T28D9.10
+ZK652.1	T28D9.10
+ZK686.4	T28D9.10
+W02B12.3	W02B12.2
+W03F9.10	W02B12.2
+W04D2.6	W02B12.2
+W07E6.4	W02B12.2
+W08E3.1	W02B12.2
+Y108G3AL.2	W02B12.2
+Y110A7A.8	W02B12.2
+Y111B2A.18	W02B12.2
+Y116A8C.34	W02B12.2
+Y116A8C.35	W02B12.2
+Y116A8C.42	W02B12.2
+Y46G5A.4	W02B12.2
+Y47G6A.20	W02B12.2
+Y49E10.15	W02B12.2
+Y54F10BM.14	W02B12.2
+Y59A8B.6	W02B12.2
+Y62E10A.12	W02B12.2
+Y65B4A.6	W02B12.2
+Y69A2AR.21	W02B12.2
+Y71D11A.2	W02B12.2
+Y71F9B.4	W02B12.2
+Y71G12B.14	W02B12.2
+Y73B6BL.32	W02B12.2
+Y80D3A.2	W02B12.2
+Y92C3B.2	W02B12.2
+ZK1098.1	W02B12.2
+ZK1127.9	W02B12.2
+ZK328.2	W02B12.2
+ZK593.7	W02B12.2
+ZK652.1	W02B12.2
+ZK686.4	W02B12.2
+W03F9.10	W02B12.3
+W04D2.6	W02B12.3
+W07E6.4	W02B12.3
+W08E3.1	W02B12.3
+Y108G3AL.2	W02B12.3
+Y110A7A.8	W02B12.3
+Y111B2A.18	W02B12.3
+Y116A8C.34	W02B12.3
+Y116A8C.35	W02B12.3
+Y116A8C.42	W02B12.3
+Y46G5A.4	W02B12.3
+Y47G6A.20	W02B12.3
+Y49E10.15	W02B12.3
+Y54F10BM.14	W02B12.3
+Y59A8B.6	W02B12.3
+Y62E10A.12	W02B12.3
+Y65B4A.6	W02B12.3
+Y69A2AR.21	W02B12.3
+Y71D11A.2	W02B12.3
+Y71F9B.4	W02B12.3
+Y71G12B.14	W02B12.3
+Y73B6BL.32	W02B12.3
+Y80D3A.2	W02B12.3
+Y92C3B.2	W02B12.3
+ZK1098.1	W02B12.3
+ZK1127.9	W02B12.3
+ZK328.2	W02B12.3
+ZK593.7	W02B12.3
+ZK652.1	W02B12.3
+ZK686.4	W02B12.3
+W04D2.6	W03F9.10
+W07E6.4	W03F9.10
+W08E3.1	W03F9.10
+Y108G3AL.2	W03F9.10
+Y110A7A.8	W03F9.10
+Y111B2A.18	W03F9.10
+Y116A8C.34	W03F9.10
+Y116A8C.35	W03F9.10
+Y116A8C.42	W03F9.10
+Y46G5A.4	W03F9.10
+Y47G6A.20	W03F9.10
+Y49E10.15	W03F9.10
+Y54F10BM.14	W03F9.10
+Y59A8B.6	W03F9.10
+Y62E10A.12	W03F9.10
+Y65B4A.6	W03F9.10
+Y69A2AR.21	W03F9.10
+Y71D11A.2	W03F9.10
+Y71F9B.4	W03F9.10
+Y71G12B.14	W03F9.10
+Y73B6BL.32	W03F9.10
+Y80D3A.2	W03F9.10
+Y92C3B.2	W03F9.10
+ZK1098.1	W03F9.10
+ZK1127.9	W03F9.10
+ZK328.2	W03F9.10
+ZK593.7	W03F9.10
+ZK652.1	W03F9.10
+ZK686.4	W03F9.10
+W07E6.4	W04D2.6
+W08E3.1	W04D2.6
+Y108G3AL.2	W04D2.6
+Y110A7A.8	W04D2.6
+Y111B2A.18	W04D2.6
+Y116A8C.34	W04D2.6
+Y116A8C.35	W04D2.6
+Y116A8C.42	W04D2.6
+Y46G5A.4	W04D2.6
+Y47G6A.20	W04D2.6
+Y49E10.15	W04D2.6
+Y54F10BM.14	W04D2.6
+Y59A8B.6	W04D2.6
+Y62E10A.12	W04D2.6
+Y65B4A.6	W04D2.6
+Y69A2AR.21	W04D2.6
+Y71D11A.2	W04D2.6
+Y71F9B.4	W04D2.6
+Y71G12B.14	W04D2.6
+Y73B6BL.32	W04D2.6
+Y80D3A.2	W04D2.6
+Y92C3B.2	W04D2.6
+ZK1098.1	W04D2.6
+ZK1127.9	W04D2.6
+ZK328.2	W04D2.6
+ZK593.7	W04D2.6
+ZK652.1	W04D2.6
+ZK686.4	W04D2.6
+W08E3.1	W07E6.4
+Y108G3AL.2	W07E6.4
+Y110A7A.8	W07E6.4
+Y111B2A.18	W07E6.4
+Y116A8C.34	W07E6.4
+Y116A8C.35	W07E6.4
+Y116A8C.42	W07E6.4
+Y46G5A.4	W07E6.4
+Y47G6A.20	W07E6.4
+Y49E10.15	W07E6.4
+Y54F10BM.14	W07E6.4
+Y59A8B.6	W07E6.4
+Y62E10A.12	W07E6.4
+Y65B4A.6	W07E6.4
+Y69A2AR.21	W07E6.4
+Y71D11A.2	W07E6.4
+Y71F9B.4	W07E6.4
+Y71G12B.14	W07E6.4
+Y73B6BL.32	W07E6.4
+Y80D3A.2	W07E6.4
+Y92C3B.2	W07E6.4
+ZK1098.1	W07E6.4
+ZK1127.9	W07E6.4
+ZK328.2	W07E6.4
+ZK593.7	W07E6.4
+ZK652.1	W07E6.4
+ZK686.4	W07E6.4
+Y108G3AL.2	W08E3.1
+Y110A7A.8	W08E3.1
+Y111B2A.18	W08E3.1
+Y116A8C.34	W08E3.1
+Y116A8C.35	W08E3.1
+Y116A8C.42	W08E3.1
+Y46G5A.4	W08E3.1
+Y47G6A.20	W08E3.1
+Y49E10.15	W08E3.1
+Y54F10BM.14	W08E3.1
+Y59A8B.6	W08E3.1
+Y62E10A.12	W08E3.1
+Y65B4A.6	W08E3.1
+Y69A2AR.21	W08E3.1
+Y71D11A.2	W08E3.1
+Y71F9B.4	W08E3.1
+Y71G12B.14	W08E3.1
+Y73B6BL.32	W08E3.1
+Y80D3A.2	W08E3.1
+Y92C3B.2	W08E3.1
+ZK1098.1	W08E3.1
+ZK1127.9	W08E3.1
+ZK328.2	W08E3.1
+ZK593.7	W08E3.1
+ZK652.1	W08E3.1
+ZK686.4	W08E3.1
+Y110A7A.8	Y108G3AL.2
+Y111B2A.18	Y108G3AL.2
+Y116A8C.34	Y108G3AL.2
+Y116A8C.35	Y108G3AL.2
+Y116A8C.42	Y108G3AL.2
+Y46G5A.4	Y108G3AL.2
+Y47G6A.20	Y108G3AL.2
+Y49E10.15	Y108G3AL.2
+Y54F10BM.14	Y108G3AL.2
+Y59A8B.6	Y108G3AL.2
+Y62E10A.12	Y108G3AL.2
+Y65B4A.6	Y108G3AL.2
+Y69A2AR.21	Y108G3AL.2
+Y71D11A.2	Y108G3AL.2
+Y71F9B.4	Y108G3AL.2
+Y71G12B.14	Y108G3AL.2
+Y73B6BL.32	Y108G3AL.2
+Y80D3A.2	Y108G3AL.2
+Y92C3B.2	Y108G3AL.2
+ZK1098.1	Y108G3AL.2
+ZK1127.9	Y108G3AL.2
+ZK328.2	Y108G3AL.2
+ZK593.7	Y108G3AL.2
+ZK652.1	Y108G3AL.2
+ZK686.4	Y108G3AL.2
+Y111B2A.18	Y110A7A.8
+Y116A8C.34	Y110A7A.8
+Y116A8C.35	Y110A7A.8
+Y116A8C.42	Y110A7A.8
+Y46G5A.4	Y110A7A.8
+Y47G6A.20	Y110A7A.8
+Y49E10.15	Y110A7A.8
+Y54F10BM.14	Y110A7A.8
+Y59A8B.6	Y110A7A.8
+Y62E10A.12	Y110A7A.8
+Y65B4A.6	Y110A7A.8
+Y69A2AR.21	Y110A7A.8
+Y71D11A.2	Y110A7A.8
+Y71F9B.4	Y110A7A.8
+Y71G12B.14	Y110A7A.8
+Y73B6BL.32	Y110A7A.8
+Y80D3A.2	Y110A7A.8
+Y92C3B.2	Y110A7A.8
+ZK1098.1	Y110A7A.8
+ZK1127.9	Y110A7A.8
+ZK328.2	Y110A7A.8
+ZK593.7	Y110A7A.8
+ZK652.1	Y110A7A.8
+ZK686.4	Y110A7A.8
+Y116A8C.34	Y111B2A.18
+Y116A8C.35	Y111B2A.18
+Y116A8C.42	Y111B2A.18
+Y46G5A.4	Y111B2A.18
+Y47G6A.20	Y111B2A.18
+Y49E10.15	Y111B2A.18
+Y54F10BM.14	Y111B2A.18
+Y59A8B.6	Y111B2A.18
+Y62E10A.12	Y111B2A.18
+Y65B4A.6	Y111B2A.18
+Y69A2AR.21	Y111B2A.18
+Y71D11A.2	Y111B2A.18
+Y71F9B.4	Y111B2A.18
+Y71G12B.14	Y111B2A.18
+Y73B6BL.32	Y111B2A.18
+Y80D3A.2	Y111B2A.18
+Y92C3B.2	Y111B2A.18
+ZK1098.1	Y111B2A.18
+ZK1127.9	Y111B2A.18
+ZK328.2	Y111B2A.18
+ZK593.7	Y111B2A.18
+ZK652.1	Y111B2A.18
+ZK686.4	Y111B2A.18
+Y116A8C.35	Y116A8C.34
+Y116A8C.42	Y116A8C.34
+Y46G5A.4	Y116A8C.34
+Y47G6A.20	Y116A8C.34
+Y49E10.15	Y116A8C.34
+Y54F10BM.14	Y116A8C.34
+Y59A8B.6	Y116A8C.34
+Y62E10A.12	Y116A8C.34
+Y65B4A.6	Y116A8C.34
+Y69A2AR.21	Y116A8C.34
+Y71D11A.2	Y116A8C.34
+Y71F9B.4	Y116A8C.34
+Y71G12B.14	Y116A8C.34
+Y73B6BL.32	Y116A8C.34
+Y80D3A.2	Y116A8C.34
+Y92C3B.2	Y116A8C.34
+ZK1098.1	Y116A8C.34
+ZK1127.9	Y116A8C.34
+ZK328.2	Y116A8C.34
+ZK593.7	Y116A8C.34
+ZK652.1	Y116A8C.34
+ZK686.4	Y116A8C.34
+Y116A8C.42	Y116A8C.35
+Y46G5A.4	Y116A8C.35
+Y47G6A.20	Y116A8C.35
+Y49E10.15	Y116A8C.35
+Y54F10BM.14	Y116A8C.35
+Y59A8B.6	Y116A8C.35
+Y62E10A.12	Y116A8C.35
+Y65B4A.6	Y116A8C.35
+Y69A2AR.21	Y116A8C.35
+Y71D11A.2	Y116A8C.35
+Y71F9B.4	Y116A8C.35
+Y71G12B.14	Y116A8C.35
+Y73B6BL.32	Y116A8C.35
+Y80D3A.2	Y116A8C.35
+Y92C3B.2	Y116A8C.35
+ZK1098.1	Y116A8C.35
+ZK1127.9	Y116A8C.35
+ZK328.2	Y116A8C.35
+ZK593.7	Y116A8C.35
+ZK652.1	Y116A8C.35
+ZK686.4	Y116A8C.35
+Y46G5A.4	Y116A8C.42
+Y47G6A.20	Y116A8C.42
+Y49E10.15	Y116A8C.42
+Y54F10BM.14	Y116A8C.42
+Y59A8B.6	Y116A8C.42
+Y62E10A.12	Y116A8C.42
+Y65B4A.6	Y116A8C.42
+Y69A2AR.21	Y116A8C.42
+Y71D11A.2	Y116A8C.42
+Y71F9B.4	Y116A8C.42
+Y71G12B.14	Y116A8C.42
+Y73B6BL.32	Y116A8C.42
+Y80D3A.2	Y116A8C.42
+Y92C3B.2	Y116A8C.42
+ZK1098.1	Y116A8C.42
+ZK1127.9	Y116A8C.42
+ZK328.2	Y116A8C.42
+ZK593.7	Y116A8C.42
+ZK652.1	Y116A8C.42
+ZK686.4	Y116A8C.42
+Y47G6A.20	Y46G5A.4
+Y49E10.15	Y46G5A.4
+Y54F10BM.14	Y46G5A.4
+Y59A8B.6	Y46G5A.4
+Y62E10A.12	Y46G5A.4
+Y65B4A.6	Y46G5A.4
+Y69A2AR.21	Y46G5A.4
+Y71D11A.2	Y46G5A.4
+Y71F9B.4	Y46G5A.4
+Y71G12B.14	Y46G5A.4
+Y73B6BL.32	Y46G5A.4
+Y80D3A.2	Y46G5A.4
+Y92C3B.2	Y46G5A.4
+ZK1098.1	Y46G5A.4
+ZK1127.9	Y46G5A.4
+ZK328.2	Y46G5A.4
+ZK593.7	Y46G5A.4
+ZK652.1	Y46G5A.4
+ZK686.4	Y46G5A.4
+Y49E10.15	Y47G6A.20
+Y54F10BM.14	Y47G6A.20
+Y59A8B.6	Y47G6A.20
+Y62E10A.12	Y47G6A.20
+Y65B4A.6	Y47G6A.20
+Y69A2AR.21	Y47G6A.20
+Y71D11A.2	Y47G6A.20
+Y71F9B.4	Y47G6A.20
+Y71G12B.14	Y47G6A.20
+Y73B6BL.32	Y47G6A.20
+Y80D3A.2	Y47G6A.20
+Y92C3B.2	Y47G6A.20
+ZK1098.1	Y47G6A.20
+ZK1127.9	Y47G6A.20
+ZK328.2	Y47G6A.20
+ZK593.7	Y47G6A.20
+ZK652.1	Y47G6A.20
+ZK686.4	Y47G6A.20
+Y54F10BM.14	Y49E10.15
+Y59A8B.6	Y49E10.15
+Y62E10A.12	Y49E10.15
+Y65B4A.6	Y49E10.15
+Y69A2AR.21	Y49E10.15
+Y71D11A.2	Y49E10.15
+Y71F9B.4	Y49E10.15
+Y71G12B.14	Y49E10.15
+Y73B6BL.32	Y49E10.15
+Y80D3A.2	Y49E10.15
+Y92C3B.2	Y49E10.15
+ZK1098.1	Y49E10.15
+ZK1127.9	Y49E10.15
+ZK328.2	Y49E10.15
+ZK593.7	Y49E10.15
+ZK652.1	Y49E10.15
+ZK686.4	Y49E10.15
+Y59A8B.6	Y54F10BM.14
+Y62E10A.12	Y54F10BM.14
+Y65B4A.6	Y54F10BM.14
+Y69A2AR.21	Y54F10BM.14
+Y71D11A.2	Y54F10BM.14
+Y71F9B.4	Y54F10BM.14
+Y71G12B.14	Y54F10BM.14
+Y73B6BL.32	Y54F10BM.14
+Y80D3A.2	Y54F10BM.14
+Y92C3B.2	Y54F10BM.14
+ZK1098.1	Y54F10BM.14
+ZK1127.9	Y54F10BM.14
+ZK328.2	Y54F10BM.14
+ZK593.7	Y54F10BM.14
+ZK652.1	Y54F10BM.14
+ZK686.4	Y54F10BM.14
+Y62E10A.12	Y59A8B.6
+Y65B4A.6	Y59A8B.6
+Y69A2AR.21	Y59A8B.6
+Y71D11A.2	Y59A8B.6
+Y71F9B.4	Y59A8B.6
+Y71G12B.14	Y59A8B.6
+Y73B6BL.32	Y59A8B.6
+Y80D3A.2	Y59A8B.6
+Y92C3B.2	Y59A8B.6
+ZK1098.1	Y59A8B.6
+ZK1127.9	Y59A8B.6
+ZK328.2	Y59A8B.6
+ZK593.7	Y59A8B.6
+ZK652.1	Y59A8B.6
+ZK686.4	Y59A8B.6
+Y65B4A.6	Y62E10A.12
+Y69A2AR.21	Y62E10A.12
+Y71D11A.2	Y62E10A.12
+Y71F9B.4	Y62E10A.12
+Y80D3A.2	Y62E10A.12
+Y92C3B.2	Y62E10A.12
+ZK1098.1	Y62E10A.12
+ZK1127.9	Y62E10A.12
+ZK328.2	Y62E10A.12
+ZK652.1	Y62E10A.12
+ZK686.4	Y62E10A.12
+Y69A2AR.21	Y65B4A.6
+Y71D11A.2	Y65B4A.6
+Y71F9B.4	Y65B4A.6
+Y71G12B.14	Y65B4A.6
+Y73B6BL.32	Y65B4A.6
+Y80D3A.2	Y65B4A.6
+Y92C3B.2	Y65B4A.6
+ZK1098.1	Y65B4A.6
+ZK1127.9	Y65B4A.6
+ZK328.2	Y65B4A.6
+ZK593.7	Y65B4A.6
+ZK652.1	Y65B4A.6
+ZK686.4	Y65B4A.6
+Y71D11A.2	Y69A2AR.21
+Y71F9B.4	Y69A2AR.21
+Y71G12B.14	Y69A2AR.21
+Y73B6BL.32	Y69A2AR.21
+Y80D3A.2	Y69A2AR.21
+Y92C3B.2	Y69A2AR.21
+ZK1098.1	Y69A2AR.21
+ZK1127.9	Y69A2AR.21
+ZK328.2	Y69A2AR.21
+ZK593.7	Y69A2AR.21
+ZK652.1	Y69A2AR.21
+ZK686.4	Y69A2AR.21
+Y71F9B.4	Y71D11A.2
+Y71G12B.14	Y71D11A.2
+Y73B6BL.32	Y71D11A.2
+Y80D3A.2	Y71D11A.2
+Y92C3B.2	Y71D11A.2
+ZK1098.1	Y71D11A.2
+ZK1127.9	Y71D11A.2
+ZK328.2	Y71D11A.2
+ZK593.7	Y71D11A.2
+ZK652.1	Y71D11A.2
+ZK686.4	Y71D11A.2
+Y71G12B.14	Y71F9B.4
+Y73B6BL.32	Y71F9B.4
+Y80D3A.2	Y71F9B.4
+Y92C3B.2	Y71F9B.4
+ZK1098.1	Y71F9B.4
+ZK1127.9	Y71F9B.4
+ZK328.2	Y71F9B.4
+ZK593.7	Y71F9B.4
+ZK652.1	Y71F9B.4
+ZK686.4	Y71F9B.4
+Y80D3A.2	Y71G12B.14
+Y92C3B.2	Y71G12B.14
+ZK1098.1	Y71G12B.14
+ZK1127.9	Y71G12B.14
+ZK328.2	Y71G12B.14
+ZK652.1	Y71G12B.14
+ZK686.4	Y71G12B.14
+Y80D3A.2	Y73B6BL.32
+Y92C3B.2	Y73B6BL.32
+ZK1098.1	Y73B6BL.32
+ZK1127.9	Y73B6BL.32
+ZK328.2	Y73B6BL.32
+ZK652.1	Y73B6BL.32
+ZK686.4	Y73B6BL.32
+Y92C3B.2	Y80D3A.2
+ZK1098.1	Y80D3A.2
+ZK1127.9	Y80D3A.2
+ZK328.2	Y80D3A.2
+ZK593.7	Y80D3A.2
+ZK652.1	Y80D3A.2
+ZK686.4	Y80D3A.2
+ZK1098.1	Y92C3B.2
+ZK1127.9	Y92C3B.2
+ZK328.2	Y92C3B.2
+ZK593.7	Y92C3B.2
+ZK652.1	Y92C3B.2
+ZK686.4	Y92C3B.2
+ZK1127.9	ZK1098.1
+ZK328.2	ZK1098.1
+ZK593.7	ZK1098.1
+ZK652.1	ZK1098.1
+ZK686.4	ZK1098.1
+ZK328.2	ZK1127.9
+ZK593.7	ZK1127.9
+ZK652.1	ZK1127.9
+ZK686.4	ZK1127.9
+ZK593.7	ZK328.2
+ZK652.1	ZK328.2
+ZK686.4	ZK328.2
+ZK652.1	ZK593.7
+ZK686.4	ZK593.7
+ZK686.4	ZK652.1
+C02F5.9	B0205.3
+C10G11.8	B0205.3
+C14C10.5	B0205.3
+C15H11.7	B0205.3
+C23G10.4	B0205.3
+C30C11.2	B0205.3
+C36B1.4	B0205.3
+C47B2.4	B0205.3
+C52E4.4	B0205.3
+CD4.6	B0205.3
+D1054.2	B0205.3
+F10G7.8	B0205.3
+F23F1.8	B0205.3
+F23F12.6	B0205.3
+F25H2.9	B0205.3
+F29G9.5	B0205.3
+F37A4.5	B0205.3
+F39H11.5	B0205.3
+F49C12.8	B0205.3
+F56F11.4	B0205.3
+F56H1.4	B0205.3
+F57B9.10	B0205.3
+F59B2.5	B0205.3
+K05C4.1	B0205.3
+K07D4.3	B0205.3
+K08D12.1	B0205.3
+R12E2.3	B0205.3
+T06D8.8	B0205.3
+T20F5.2	B0205.3
+T22D1.9	B0205.3
+T28B8.3	B0205.3
+Y110A7A.14	B0205.3
+Y119D3B.15	B0205.3
+Y38A8.2	B0205.3
+Y49E10.1	B0205.3
+Y66D12A.9	B0205.3
+ZK20.5	B0205.3
+ZK945.2	B0205.3
+C10G11.8	C02F5.9
+C14C10.5	C02F5.9
+C15H11.7	C02F5.9
+C23G10.4	C02F5.9
+C30C11.2	C02F5.9
+C36B1.4	C02F5.9
+C47B2.4	C02F5.9
+C52E4.4	C02F5.9
+CD4.6	C02F5.9
+D1054.2	C02F5.9
+F10G7.8	C02F5.9
+F23F1.8	C02F5.9
+F23F12.6	C02F5.9
+F25H2.9	C02F5.9
+F29G9.5	C02F5.9
+F37A4.5	C02F5.9
+F39H11.5	C02F5.9
+F49C12.8	C02F5.9
+F56F11.4	C02F5.9
+F56H1.4	C02F5.9
+F57B9.10	C02F5.9
+F59B2.5	C02F5.9
+K05C4.1	C02F5.9
+K07D4.3	C02F5.9
+K08D12.1	C02F5.9
+R12E2.3	C02F5.9
+T06D8.8	C02F5.9
+T20F5.2	C02F5.9
+T22D1.9	C02F5.9
+T28B8.3	C02F5.9
+Y110A7A.14	C02F5.9
+Y119D3B.15	C02F5.9
+Y38A8.2	C02F5.9
+Y49E10.1	C02F5.9
+Y66D12A.9	C02F5.9
+ZK20.5	C02F5.9
+ZK945.2	C02F5.9
+C14C10.5	C10G11.8
+C15H11.7	C10G11.8
+C23G10.4	C10G11.8
+C30C11.2	C10G11.8
+C36B1.4	C10G11.8
+C47B2.4	C10G11.8
+C52E4.4	C10G11.8
+CD4.6	C10G11.8
+D1054.2	C10G11.8
+F10G7.8	C10G11.8
+F23F1.8	C10G11.8
+F23F12.6	C10G11.8
+F25H2.9	C10G11.8
+F29G9.5	C10G11.8
+F37A4.5	C10G11.8
+F39H11.5	C10G11.8
+F49C12.8	C10G11.8
+F56F11.4	C10G11.8
+F56H1.4	C10G11.8
+F57B9.10	C10G11.8
+F59B2.5	C10G11.8
+K05C4.1	C10G11.8
+K07D4.3	C10G11.8
+K08D12.1	C10G11.8
+R12E2.3	C10G11.8
+T06D8.8	C10G11.8
+T20F5.2	C10G11.8
+T22D1.9	C10G11.8
+T28B8.3	C10G11.8
+Y110A7A.14	C10G11.8
+Y119D3B.15	C10G11.8
+Y38A8.2	C10G11.8
+Y49E10.1	C10G11.8
+Y66D12A.9	C10G11.8
+ZK20.5	C10G11.8
+ZK945.2	C10G11.8
+C15H11.7	C14C10.5
+C23G10.4	C14C10.5
+C30C11.2	C14C10.5
+C36B1.4	C14C10.5
+C47B2.4	C14C10.5
+C52E4.4	C14C10.5
+CD4.6	C14C10.5
+D1054.2	C14C10.5
+F10G7.8	C14C10.5
+F23F1.8	C14C10.5
+F23F12.6	C14C10.5
+F25H2.9	C14C10.5
+F29G9.5	C14C10.5
+F37A4.5	C14C10.5
+F39H11.5	C14C10.5
+F49C12.8	C14C10.5
+F56F11.4	C14C10.5
+F56H1.4	C14C10.5
+F57B9.10	C14C10.5
+F59B2.5	C14C10.5
+K05C4.1	C14C10.5
+K07D4.3	C14C10.5
+K08D12.1	C14C10.5
+R12E2.3	C14C10.5
+T06D8.8	C14C10.5
+T20F5.2	C14C10.5
+T22D1.9	C14C10.5
+T28B8.3	C14C10.5
+Y110A7A.14	C14C10.5
+Y119D3B.15	C14C10.5
+Y38A8.2	C14C10.5
+Y49E10.1	C14C10.5
+Y66D12A.9	C14C10.5
+ZK20.5	C14C10.5
+ZK945.2	C14C10.5
+C23G10.4	C15H11.7
+C30C11.2	C15H11.7
+C36B1.4	C15H11.7
+C47B2.4	C15H11.7
+C52E4.4	C15H11.7
+CD4.6	C15H11.7
+D1054.2	C15H11.7
+F10G7.8	C15H11.7
+F23F1.8	C15H11.7
+F23F12.6	C15H11.7
+F25H2.9	C15H11.7
+F29G9.5	C15H11.7
+F37A4.5	C15H11.7
+F39H11.5	C15H11.7
+F49C12.8	C15H11.7
+F56F11.4	C15H11.7
+F56H1.4	C15H11.7
+F57B9.10	C15H11.7
+F59B2.5	C15H11.7
+K05C4.1	C15H11.7
+K07D4.3	C15H11.7
+K08D12.1	C15H11.7
+R12E2.3	C15H11.7
+T06D8.8	C15H11.7
+T20F5.2	C15H11.7
+T22D1.9	C15H11.7
+T28B8.3	C15H11.7
+Y110A7A.14	C15H11.7
+Y119D3B.15	C15H11.7
+Y38A8.2	C15H11.7
+Y49E10.1	C15H11.7
+Y66D12A.9	C15H11.7
+ZK20.5	C15H11.7
+ZK945.2	C15H11.7
+C30C11.2	C23G10.4
+C36B1.4	C23G10.4
+C47B2.4	C23G10.4
+C52E4.4	C23G10.4
+CD4.6	C23G10.4
+D1054.2	C23G10.4
+F10G7.8	C23G10.4
+F23F1.8	C23G10.4
+F23F12.6	C23G10.4
+F25H2.9	C23G10.4
+F29G9.5	C23G10.4
+F37A4.5	C23G10.4
+F39H11.5	C23G10.4
+F49C12.8	C23G10.4
+F56F11.4	C23G10.4
+F56H1.4	C23G10.4
+F57B9.10	C23G10.4
+F59B2.5	C23G10.4
+K05C4.1	C23G10.4
+K07D4.3	C23G10.4
+K08D12.1	C23G10.4
+R12E2.3	C23G10.4
+T06D8.8	C23G10.4
+T20F5.2	C23G10.4
+T22D1.9	C23G10.4
+T28B8.3	C23G10.4
+Y110A7A.14	C23G10.4
+Y119D3B.15	C23G10.4
+Y38A8.2	C23G10.4
+Y49E10.1	C23G10.4
+Y66D12A.9	C23G10.4
+ZK20.5	C23G10.4
+ZK945.2	C23G10.4
+C36B1.4	C30C11.2
+C47B2.4	C30C11.2
+C52E4.4	C30C11.2
+CD4.6	C30C11.2
+D1054.2	C30C11.2
+F10G7.8	C30C11.2
+F23F1.8	C30C11.2
+F23F12.6	C30C11.2
+F25H2.9	C30C11.2
+F29G9.5	C30C11.2
+F37A4.5	C30C11.2
+F39H11.5	C30C11.2
+F49C12.8	C30C11.2
+F56F11.4	C30C11.2
+F56H1.4	C30C11.2
+F57B9.10	C30C11.2
+F59B2.5	C30C11.2
+K05C4.1	C30C11.2
+K07D4.3	C30C11.2
+K08D12.1	C30C11.2
+R12E2.3	C30C11.2
+T06D8.8	C30C11.2
+T20F5.2	C30C11.2
+T22D1.9	C30C11.2
+T28B8.3	C30C11.2
+Y110A7A.14	C30C11.2
+Y119D3B.15	C30C11.2
+Y38A8.2	C30C11.2
+Y49E10.1	C30C11.2
+Y66D12A.9	C30C11.2
+ZK20.5	C30C11.2
+ZK945.2	C30C11.2
+C47B2.4	C36B1.4
+C52E4.4	C36B1.4
+CD4.6	C36B1.4
+D1054.2	C36B1.4
+F10G7.8	C36B1.4
+F23F1.8	C36B1.4
+F23F12.6	C36B1.4
+F25H2.9	C36B1.4
+F29G9.5	C36B1.4
+F37A4.5	C36B1.4
+F39H11.5	C36B1.4
+F49C12.8	C36B1.4
+F56F11.4	C36B1.4
+F56H1.4	C36B1.4
+F57B9.10	C36B1.4
+F59B2.5	C36B1.4
+K05C4.1	C36B1.4
+K07D4.3	C36B1.4
+K08D12.1	C36B1.4
+R12E2.3	C36B1.4
+T06D8.8	C36B1.4
+T20F5.2	C36B1.4
+T22D1.9	C36B1.4
+T28B8.3	C36B1.4
+Y110A7A.14	C36B1.4
+Y119D3B.15	C36B1.4
+Y38A8.2	C36B1.4
+Y49E10.1	C36B1.4
+Y66D12A.9	C36B1.4
+ZK20.5	C36B1.4
+ZK945.2	C36B1.4
+C52E4.4	C47B2.4
+CD4.6	C47B2.4
+D1054.2	C47B2.4
+F10G7.8	C47B2.4
+F23F1.8	C47B2.4
+F23F12.6	C47B2.4
+F25H2.9	C47B2.4
+F29G9.5	C47B2.4
+F37A4.5	C47B2.4
+F39H11.5	C47B2.4
+F49C12.8	C47B2.4
+F56F11.4	C47B2.4
+F56H1.4	C47B2.4
+F57B9.10	C47B2.4
+F59B2.5	C47B2.4
+K05C4.1	C47B2.4
+K07D4.3	C47B2.4
+K08D12.1	C47B2.4
+R12E2.3	C47B2.4
+T06D8.8	C47B2.4
+T20F5.2	C47B2.4
+T22D1.9	C47B2.4
+T28B8.3	C47B2.4
+Y110A7A.14	C47B2.4
+Y119D3B.15	C47B2.4
+Y38A8.2	C47B2.4
+Y49E10.1	C47B2.4
+Y66D12A.9	C47B2.4
+ZK20.5	C47B2.4
+ZK945.2	C47B2.4
+CD4.6	C52E4.4
+D1054.2	C52E4.4
+F10G7.8	C52E4.4
+F23F1.8	C52E4.4
+F23F12.6	C52E4.4
+F25H2.9	C52E4.4
+F29G9.5	C52E4.4
+F37A4.5	C52E4.4
+F39H11.5	C52E4.4
+F49C12.8	C52E4.4
+F56F11.4	C52E4.4
+F56H1.4	C52E4.4
+F57B9.10	C52E4.4
+F59B2.5	C52E4.4
+K05C4.1	C52E4.4
+K07D4.3	C52E4.4
+K08D12.1	C52E4.4
+R12E2.3	C52E4.4
+T06D8.8	C52E4.4
+T20F5.2	C52E4.4
+T22D1.9	C52E4.4
+T28B8.3	C52E4.4
+Y110A7A.14	C52E4.4
+Y119D3B.15	C52E4.4
+Y38A8.2	C52E4.4
+Y49E10.1	C52E4.4
+Y66D12A.9	C52E4.4
+ZK20.5	C52E4.4
+ZK945.2	C52E4.4
+D1054.2	CD4.6
+F10G7.8	CD4.6
+F23F1.8	CD4.6
+F23F12.6	CD4.6
+F25H2.9	CD4.6
+F29G9.5	CD4.6
+F37A4.5	CD4.6
+F39H11.5	CD4.6
+F49C12.8	CD4.6
+F56F11.4	CD4.6
+F56H1.4	CD4.6
+F57B9.10	CD4.6
+F59B2.5	CD4.6
+K05C4.1	CD4.6
+K07D4.3	CD4.6
+K08D12.1	CD4.6
+R12E2.3	CD4.6
+T06D8.8	CD4.6
+T20F5.2	CD4.6
+T22D1.9	CD4.6
+T28B8.3	CD4.6
+Y110A7A.14	CD4.6
+Y119D3B.15	CD4.6
+Y38A8.2	CD4.6
+Y49E10.1	CD4.6
+Y66D12A.9	CD4.6
+ZK20.5	CD4.6
+ZK945.2	CD4.6
+F10G7.8	D1054.2
+F23F1.8	D1054.2
+F23F12.6	D1054.2
+F25H2.9	D1054.2
+F29G9.5	D1054.2
+F37A4.5	D1054.2
+F39H11.5	D1054.2
+F49C12.8	D1054.2
+F56F11.4	D1054.2
+F56H1.4	D1054.2
+F57B9.10	D1054.2
+F59B2.5	D1054.2
+K05C4.1	D1054.2
+K07D4.3	D1054.2
+K08D12.1	D1054.2
+R12E2.3	D1054.2
+T06D8.8	D1054.2
+T20F5.2	D1054.2
+T22D1.9	D1054.2
+T28B8.3	D1054.2
+Y110A7A.14	D1054.2
+Y119D3B.15	D1054.2
+Y38A8.2	D1054.2
+Y49E10.1	D1054.2
+Y66D12A.9	D1054.2
+ZK20.5	D1054.2
+ZK945.2	D1054.2
+F23F1.8	F10G7.8
+F23F12.6	F10G7.8
+F25H2.9	F10G7.8
+F29G9.5	F10G7.8
+F37A4.5	F10G7.8
+F39H11.5	F10G7.8
+F49C12.8	F10G7.8
+F56F11.4	F10G7.8
+F56H1.4	F10G7.8
+F57B9.10	F10G7.8
+F59B2.5	F10G7.8
+K05C4.1	F10G7.8
+K07D4.3	F10G7.8
+K08D12.1	F10G7.8
+R12E2.3	F10G7.8
+T06D8.8	F10G7.8
+T20F5.2	F10G7.8
+T22D1.9	F10G7.8
+T28B8.3	F10G7.8
+Y110A7A.14	F10G7.8
+Y119D3B.15	F10G7.8
+Y38A8.2	F10G7.8
+Y49E10.1	F10G7.8
+Y66D12A.9	F10G7.8
+ZK20.5	F10G7.8
+ZK945.2	F10G7.8
+F23F12.6	F23F1.8
+F25H2.9	F23F1.8
+F29G9.5	F23F1.8
+F37A4.5	F23F1.8
+F39H11.5	F23F1.8
+F49C12.8	F23F1.8
+F56F11.4	F23F1.8
+F56H1.4	F23F1.8
+F57B9.10	F23F1.8
+F59B2.5	F23F1.8
+K05C4.1	F23F1.8
+K07D4.3	F23F1.8
+K08D12.1	F23F1.8
+R12E2.3	F23F1.8
+T06D8.8	F23F1.8
+T20F5.2	F23F1.8
+T22D1.9	F23F1.8
+T28B8.3	F23F1.8
+Y110A7A.14	F23F1.8
+Y119D3B.15	F23F1.8
+Y38A8.2	F23F1.8
+Y49E10.1	F23F1.8
+Y66D12A.9	F23F1.8
+ZK20.5	F23F1.8
+ZK945.2	F23F1.8
+F25H2.9	F23F12.6
+F29G9.5	F23F12.6
+F37A4.5	F23F12.6
+F39H11.5	F23F12.6
+F49C12.8	F23F12.6
+F56F11.4	F23F12.6
+F56H1.4	F23F12.6
+F57B9.10	F23F12.6
+F59B2.5	F23F12.6
+K05C4.1	F23F12.6
+K07D4.3	F23F12.6
+K08D12.1	F23F12.6
+R12E2.3	F23F12.6
+T06D8.8	F23F12.6
+T20F5.2	F23F12.6
+T22D1.9	F23F12.6
+T28B8.3	F23F12.6
+Y110A7A.14	F23F12.6
+Y119D3B.15	F23F12.6
+Y38A8.2	F23F12.6
+Y49E10.1	F23F12.6
+Y66D12A.9	F23F12.6
+ZK20.5	F23F12.6
+ZK945.2	F23F12.6
+F29G9.5	F25H2.9
+F37A4.5	F25H2.9
+F39H11.5	F25H2.9
+F49C12.8	F25H2.9
+F56F11.4	F25H2.9
+F56H1.4	F25H2.9
+F57B9.10	F25H2.9
+F59B2.5	F25H2.9
+K05C4.1	F25H2.9
+K07D4.3	F25H2.9
+K08D12.1	F25H2.9
+R12E2.3	F25H2.9
+T06D8.8	F25H2.9
+T20F5.2	F25H2.9
+T22D1.9	F25H2.9
+T28B8.3	F25H2.9
+Y110A7A.14	F25H2.9
+Y119D3B.15	F25H2.9
+Y38A8.2	F25H2.9
+Y49E10.1	F25H2.9
+Y66D12A.9	F25H2.9
+ZK20.5	F25H2.9
+ZK945.2	F25H2.9
+F37A4.5	F29G9.5
+F39H11.5	F29G9.5
+F49C12.8	F29G9.5
+F56F11.4	F29G9.5
+F56H1.4	F29G9.5
+F57B9.10	F29G9.5
+F59B2.5	F29G9.5
+K05C4.1	F29G9.5
+K07D4.3	F29G9.5
+K08D12.1	F29G9.5
+R12E2.3	F29G9.5
+T06D8.8	F29G9.5
+T20F5.2	F29G9.5
+T22D1.9	F29G9.5
+T28B8.3	F29G9.5
+Y110A7A.14	F29G9.5
+Y119D3B.15	F29G9.5
+Y38A8.2	F29G9.5
+Y49E10.1	F29G9.5
+Y66D12A.9	F29G9.5
+ZK20.5	F29G9.5
+ZK945.2	F29G9.5
+F39H11.5	F37A4.5
+F49C12.8	F37A4.5
+F56F11.4	F37A4.5
+F56H1.4	F37A4.5
+F57B9.10	F37A4.5
+F59B2.5	F37A4.5
+K05C4.1	F37A4.5
+K07D4.3	F37A4.5
+K08D12.1	F37A4.5
+R12E2.3	F37A4.5
+T06D8.8	F37A4.5
+T20F5.2	F37A4.5
+T22D1.9	F37A4.5
+T28B8.3	F37A4.5
+Y110A7A.14	F37A4.5
+Y119D3B.15	F37A4.5
+Y38A8.2	F37A4.5
+Y49E10.1	F37A4.5
+Y66D12A.9	F37A4.5
+ZK20.5	F37A4.5
+ZK945.2	F37A4.5
+F49C12.8	F39H11.5
+F56F11.4	F39H11.5
+F56H1.4	F39H11.5
+F57B9.10	F39H11.5
+F59B2.5	F39H11.5
+K05C4.1	F39H11.5
+K07D4.3	F39H11.5
+K08D12.1	F39H11.5
+R12E2.3	F39H11.5
+T06D8.8	F39H11.5
+T20F5.2	F39H11.5
+T22D1.9	F39H11.5
+T28B8.3	F39H11.5
+Y110A7A.14	F39H11.5
+Y119D3B.15	F39H11.5
+Y38A8.2	F39H11.5
+Y49E10.1	F39H11.5
+Y66D12A.9	F39H11.5
+ZK20.5	F39H11.5
+ZK945.2	F39H11.5
+F56F11.4	F49C12.8
+F56H1.4	F49C12.8
+F57B9.10	F49C12.8
+F59B2.5	F49C12.8
+K05C4.1	F49C12.8
+K07D4.3	F49C12.8
+K08D12.1	F49C12.8
+R12E2.3	F49C12.8
+T06D8.8	F49C12.8
+T20F5.2	F49C12.8
+T22D1.9	F49C12.8
+T28B8.3	F49C12.8
+Y110A7A.14	F49C12.8
+Y119D3B.15	F49C12.8
+Y38A8.2	F49C12.8
+Y49E10.1	F49C12.8
+Y66D12A.9	F49C12.8
+ZK20.5	F49C12.8
+ZK945.2	F49C12.8
+F56H1.4	F56F11.4
+F57B9.10	F56F11.4
+F59B2.5	F56F11.4
+K05C4.1	F56F11.4
+K07D4.3	F56F11.4
+K08D12.1	F56F11.4
+R12E2.3	F56F11.4
+T06D8.8	F56F11.4
+T20F5.2	F56F11.4
+T22D1.9	F56F11.4
+T28B8.3	F56F11.4
+Y110A7A.14	F56F11.4
+Y119D3B.15	F56F11.4
+Y38A8.2	F56F11.4
+Y49E10.1	F56F11.4
+Y66D12A.9	F56F11.4
+ZK20.5	F56F11.4
+ZK945.2	F56F11.4
+F57B9.10	F56H1.4
+F59B2.5	F56H1.4
+K05C4.1	F56H1.4
+K07D4.3	F56H1.4
+K08D12.1	F56H1.4
+R12E2.3	F56H1.4
+T06D8.8	F56H1.4
+T20F5.2	F56H1.4
+T22D1.9	F56H1.4
+T28B8.3	F56H1.4
+Y110A7A.14	F56H1.4
+Y119D3B.15	F56H1.4
+Y38A8.2	F56H1.4
+Y49E10.1	F56H1.4
+Y66D12A.9	F56H1.4
+ZK20.5	F56H1.4
+ZK945.2	F56H1.4
+F59B2.5	F57B9.10
+K05C4.1	F57B9.10
+K07D4.3	F57B9.10
+K08D12.1	F57B9.10
+R12E2.3	F57B9.10
+T06D8.8	F57B9.10
+T20F5.2	F57B9.10
+T22D1.9	F57B9.10
+T28B8.3	F57B9.10
+Y110A7A.14	F57B9.10
+Y119D3B.15	F57B9.10
+Y38A8.2	F57B9.10
+Y49E10.1	F57B9.10
+Y66D12A.9	F57B9.10
+ZK20.5	F57B9.10
+ZK945.2	F57B9.10
+K05C4.1	F59B2.5
+K07D4.3	F59B2.5
+K08D12.1	F59B2.5
+R12E2.3	F59B2.5
+T06D8.8	F59B2.5
+T20F5.2	F59B2.5
+T22D1.9	F59B2.5
+T28B8.3	F59B2.5
+Y110A7A.14	F59B2.5
+Y119D3B.15	F59B2.5
+Y38A8.2	F59B2.5
+Y49E10.1	F59B2.5
+Y66D12A.9	F59B2.5
+ZK20.5	F59B2.5
+ZK945.2	F59B2.5
+K07D4.3	K05C4.1
+K08D12.1	K05C4.1
+R12E2.3	K05C4.1
+T06D8.8	K05C4.1
+T20F5.2	K05C4.1
+T22D1.9	K05C4.1
+T28B8.3	K05C4.1
+Y110A7A.14	K05C4.1
+Y119D3B.15	K05C4.1
+Y38A8.2	K05C4.1
+Y49E10.1	K05C4.1
+Y66D12A.9	K05C4.1
+ZK20.5	K05C4.1
+ZK945.2	K05C4.1
+K08D12.1	K07D4.3
+R12E2.3	K07D4.3
+T06D8.8	K07D4.3
+T20F5.2	K07D4.3
+T22D1.9	K07D4.3
+T28B8.3	K07D4.3
+Y110A7A.14	K07D4.3
+Y119D3B.15	K07D4.3
+Y38A8.2	K07D4.3
+Y49E10.1	K07D4.3
+Y66D12A.9	K07D4.3
+ZK20.5	K07D4.3
+ZK945.2	K07D4.3
+R12E2.3	K08D12.1
+T06D8.8	K08D12.1
+T20F5.2	K08D12.1
+T22D1.9	K08D12.1
+T28B8.3	K08D12.1
+Y110A7A.14	K08D12.1
+Y119D3B.15	K08D12.1
+Y38A8.2	K08D12.1
+Y49E10.1	K08D12.1
+Y66D12A.9	K08D12.1
+ZK20.5	K08D12.1
+ZK945.2	K08D12.1
+T06D8.8	R12E2.3
+T20F5.2	R12E2.3
+T22D1.9	R12E2.3
+T28B8.3	R12E2.3
+Y110A7A.14	R12E2.3
+Y119D3B.15	R12E2.3
+Y38A8.2	R12E2.3
+Y49E10.1	R12E2.3
+Y66D12A.9	R12E2.3
+ZK20.5	R12E2.3
+ZK945.2	R12E2.3
+T20F5.2	T06D8.8
+T22D1.9	T06D8.8
+T28B8.3	T06D8.8
+Y110A7A.14	T06D8.8
+Y119D3B.15	T06D8.8
+Y38A8.2	T06D8.8
+Y49E10.1	T06D8.8
+Y66D12A.9	T06D8.8
+ZK20.5	T06D8.8
+ZK945.2	T06D8.8
+T22D1.9	T20F5.2
+T28B8.3	T20F5.2
+Y110A7A.14	T20F5.2
+Y119D3B.15	T20F5.2
+Y38A8.2	T20F5.2
+Y49E10.1	T20F5.2
+Y66D12A.9	T20F5.2
+ZK20.5	T20F5.2
+ZK945.2	T20F5.2
+T28B8.3	T22D1.9
+Y110A7A.14	T22D1.9
+Y119D3B.15	T22D1.9
+Y38A8.2	T22D1.9
+Y49E10.1	T22D1.9
+Y66D12A.9	T22D1.9
+ZK20.5	T22D1.9
+ZK945.2	T22D1.9
+Y110A7A.14	T28B8.3
+Y119D3B.15	T28B8.3
+Y38A8.2	T28B8.3
+Y49E10.1	T28B8.3
+Y66D12A.9	T28B8.3
+ZK20.5	T28B8.3
+ZK945.2	T28B8.3
+Y119D3B.15	Y110A7A.14
+Y38A8.2	Y110A7A.14
+Y49E10.1	Y110A7A.14
+Y66D12A.9	Y110A7A.14
+ZK20.5	Y110A7A.14
+ZK945.2	Y110A7A.14
+Y38A8.2	Y119D3B.15
+Y49E10.1	Y119D3B.15
+Y66D12A.9	Y119D3B.15
+ZK20.5	Y119D3B.15
+ZK945.2	Y119D3B.15
+Y49E10.1	Y38A8.2
+Y66D12A.9	Y38A8.2
+ZK20.5	Y38A8.2
+ZK945.2	Y38A8.2
+Y66D12A.9	Y49E10.1
+ZK20.5	Y49E10.1
+ZK945.2	Y49E10.1
+ZK20.5	Y66D12A.9
+ZK945.2	Y66D12A.9
+ZK945.2	ZK20.5
+C15H9.6	C01A2.3
+C18E9.2	C01A2.3
+C24H11.6	C01A2.3
+C34B2.10	C01A2.3
+F08D12.1	C01A2.3
+F21D5.7	C01A2.3
+F25G6.8	C01A2.3
+F32D8.6	C01A2.3
+F37F2.2	C01A2.3
+F38A1.8	C01A2.3
+F55C5.8	C01A2.3
+K12H4.4	C01A2.3
+R186.3	C01A2.3
+Y37D8A.10	C01A2.3
+Y38F2AR.9	C01A2.3
+Y54E10BR.5	C01A2.3
+Y55F3AM.8	C01A2.3
+Y57G11C.15	C01A2.3
+Y63D3A.6	C01A2.3
+ZK512.4	C01A2.3
+C18E9.2	C15H9.6
+C24H11.6	C15H9.6
+C34B2.10	C15H9.6
+F08D12.1	C15H9.6
+F21D5.7	C15H9.6
+F25G6.8	C15H9.6
+F32D8.6	C15H9.6
+F37F2.2	C15H9.6
+F38A1.8	C15H9.6
+F55C5.8	C15H9.6
+K12H4.4	C15H9.6
+R186.3	C15H9.6
+Y37D8A.10	C15H9.6
+Y38F2AR.9	C15H9.6
+Y54E10BR.5	C15H9.6
+Y55F3AM.8	C15H9.6
+Y57G11C.15	C15H9.6
+Y63D3A.6	C15H9.6
+ZK512.4	C15H9.6
+C24H11.6	C18E9.2
+C34B2.10	C18E9.2
+F08D12.1	C18E9.2
+F21D5.7	C18E9.2
+F25G6.8	C18E9.2
+F32D8.6	C18E9.2
+F37F2.2	C18E9.2
+F38A1.8	C18E9.2
+F55C5.8	C18E9.2
+K12H4.4	C18E9.2
+R186.3	C18E9.2
+Y37D8A.10	C18E9.2
+Y38F2AR.9	C18E9.2
+Y54E10BR.5	C18E9.2
+Y55F3AM.8	C18E9.2
+Y57G11C.15	C18E9.2
+Y63D3A.6	C18E9.2
+ZK512.4	C18E9.2
+C34B2.10	C24H11.6
+F08D12.1	C24H11.6
+F21D5.7	C24H11.6
+F25G6.8	C24H11.6
+F32D8.6	C24H11.6
+F37F2.2	C24H11.6
+F38A1.8	C24H11.6
+F55C5.8	C24H11.6
+K12H4.4	C24H11.6
+R186.3	C24H11.6
+Y37D8A.10	C24H11.6
+Y38F2AR.9	C24H11.6
+Y54E10BR.5	C24H11.6
+Y55F3AM.8	C24H11.6
+Y57G11C.15	C24H11.6
+Y63D3A.6	C24H11.6
+ZK512.4	C24H11.6
+F08D12.1	C34B2.10
+F21D5.7	C34B2.10
+F25G6.8	C34B2.10
+F32D8.6	C34B2.10
+F37F2.2	C34B2.10
+F38A1.8	C34B2.10
+F55C5.8	C34B2.10
+K12H4.4	C34B2.10
+R186.3	C34B2.10
+Y37D8A.10	C34B2.10
+Y38F2AR.9	C34B2.10
+Y54E10BR.5	C34B2.10
+Y55F3AM.8	C34B2.10
+Y57G11C.15	C34B2.10
+Y63D3A.6	C34B2.10
+ZK512.4	C34B2.10
+F21D5.7	F08D12.1
+F25G6.8	F08D12.1
+F32D8.6	F08D12.1
+F37F2.2	F08D12.1
+F38A1.8	F08D12.1
+F55C5.8	F08D12.1
+K12H4.4	F08D12.1
+R186.3	F08D12.1
+Y37D8A.10	F08D12.1
+Y38F2AR.9	F08D12.1
+Y54E10BR.5	F08D12.1
+Y55F3AM.8	F08D12.1
+Y57G11C.15	F08D12.1
+Y63D3A.6	F08D12.1
+ZK512.4	F08D12.1
+F25G6.8	F21D5.7
+F32D8.6	F21D5.7
+F37F2.2	F21D5.7
+F38A1.8	F21D5.7
+F55C5.8	F21D5.7
+K12H4.4	F21D5.7
+R186.3	F21D5.7
+Y37D8A.10	F21D5.7
+Y38F2AR.9	F21D5.7
+Y54E10BR.5	F21D5.7
+Y55F3AM.8	F21D5.7
+Y57G11C.15	F21D5.7
+Y63D3A.6	F21D5.7
+ZK512.4	F21D5.7
+F32D8.6	F25G6.8
+F37F2.2	F25G6.8
+F38A1.8	F25G6.8
+F55C5.8	F25G6.8
+K12H4.4	F25G6.8
+R186.3	F25G6.8
+Y37D8A.10	F25G6.8
+Y38F2AR.9	F25G6.8
+Y54E10BR.5	F25G6.8
+Y55F3AM.8	F25G6.8
+Y57G11C.15	F25G6.8
+Y63D3A.6	F25G6.8
+ZK512.4	F25G6.8
+F37F2.2	F32D8.6
+F38A1.8	F32D8.6
+F55C5.8	F32D8.6
+K12H4.4	F32D8.6
+R186.3	F32D8.6
+Y37D8A.10	F32D8.6
+Y38F2AR.9	F32D8.6
+Y54E10BR.5	F32D8.6
+Y55F3AM.8	F32D8.6
+Y57G11C.15	F32D8.6
+Y63D3A.6	F32D8.6
+ZK512.4	F32D8.6
+F38A1.8	F37F2.2
+F55C5.8	F37F2.2
+K12H4.4	F37F2.2
+R186.3	F37F2.2
+Y37D8A.10	F37F2.2
+Y38F2AR.9	F37F2.2
+Y54E10BR.5	F37F2.2
+Y55F3AM.8	F37F2.2
+Y57G11C.15	F37F2.2
+Y63D3A.6	F37F2.2
+ZK512.4	F37F2.2
+F55C5.8	F38A1.8
+K12H4.4	F38A1.8
+R186.3	F38A1.8
+Y37D8A.10	F38A1.8
+Y38F2AR.9	F38A1.8
+Y54E10BR.5	F38A1.8
+Y55F3AM.8	F38A1.8
+Y57G11C.15	F38A1.8
+Y63D3A.6	F38A1.8
+ZK512.4	F38A1.8
+K12H4.4	F55C5.8
+R186.3	F55C5.8
+Y37D8A.10	F55C5.8
+Y38F2AR.9	F55C5.8
+Y54E10BR.5	F55C5.8
+Y55F3AM.8	F55C5.8
+Y57G11C.15	F55C5.8
+Y63D3A.6	F55C5.8
+ZK512.4	F55C5.8
+R186.3	K12H4.4
+Y37D8A.10	K12H4.4
+Y38F2AR.9	K12H4.4
+Y54E10BR.5	K12H4.4
+Y55F3AM.8	K12H4.4
+Y57G11C.15	K12H4.4
+Y63D3A.6	K12H4.4
+ZK512.4	K12H4.4
+Y37D8A.10	R186.3
+Y38F2AR.9	R186.3
+Y54E10BR.5	R186.3
+Y55F3AM.8	R186.3
+Y57G11C.15	R186.3
+Y63D3A.6	R186.3
+ZK512.4	R186.3
+Y38F2AR.9	Y37D8A.10
+Y54E10BR.5	Y37D8A.10
+Y55F3AM.8	Y37D8A.10
+Y57G11C.15	Y37D8A.10
+Y63D3A.6	Y37D8A.10
+ZK512.4	Y37D8A.10
+Y54E10BR.5	Y38F2AR.9
+Y55F3AM.8	Y38F2AR.9
+Y57G11C.15	Y38F2AR.9
+Y63D3A.6	Y38F2AR.9
+ZK512.4	Y38F2AR.9
+Y55F3AM.8	Y54E10BR.5
+Y57G11C.15	Y54E10BR.5
+Y63D3A.6	Y54E10BR.5
+ZK512.4	Y54E10BR.5
+Y57G11C.15	Y55F3AM.8
+Y63D3A.6	Y55F3AM.8
+ZK512.4	Y55F3AM.8
+Y63D3A.6	Y57G11C.15
+ZK512.4	Y57G11C.15
+ZK512.4	Y63D3A.6
+E02H1.4	C29A12.3
+R09B3.1	C29A12.3
+R10E4.5	C29A12.3
+T05H10.2	C29A12.3
+Y56A3A.29	C29A12.3
+Y71F9AL.18	C29A12.3
+F08B4.5	E02H1.4
+F10C2.4	E02H1.4
+F12F6.7	E02H1.4
+F33H2.5	E02H1.4
+R04F11.3	E02H1.4
+R09B3.1	E02H1.4
+R10E4.5	E02H1.4
+T05H10.2	E02H1.4
+W03D2.4	E02H1.4
+Y47G6A.8	E02H1.4
+Y53F4B.3	E02H1.4
+Y56A3A.29	E02H1.4
+Y71F9AL.18	E02H1.4
+R09B3.1	F08B4.5
+R10E4.5	F08B4.5
+T05H10.2	F08B4.5
+Y56A3A.29	F08B4.5
+Y71F9AL.18	F08B4.5
+R09B3.1	F10C2.4
+R10E4.5	F10C2.4
+T05H10.2	F10C2.4
+Y56A3A.29	F10C2.4
+Y71F9AL.18	F10C2.4
+R09B3.1	F12F6.7
+R10E4.5	F12F6.7
+T05H10.2	F12F6.7
+Y56A3A.29	F12F6.7
+Y71F9AL.18	F12F6.7
+R09B3.1	F33H2.5
+R10E4.5	F33H2.5
+T05H10.2	F33H2.5
+Y56A3A.29	F33H2.5
+Y71F9AL.18	F33H2.5
+R09B3.1	R04F11.3
+R10E4.5	R04F11.3
+T05H10.2	R04F11.3
+Y56A3A.29	R04F11.3
+Y71F9AL.18	R04F11.3
+R10E4.5	R09B3.1
+T05H10.2	R09B3.1
+W03D2.4	R09B3.1
+Y47G6A.8	R09B3.1
+Y53F4B.3	R09B3.1
+Y71F9AL.18	R09B3.1
+T05H10.2	R10E4.5
+W03D2.4	R10E4.5
+Y47G6A.8	R10E4.5
+Y53F4B.3	R10E4.5
+Y56A3A.29	R10E4.5
+Y71F9AL.18	R10E4.5
+W03D2.4	T05H10.2
+Y47G6A.8	T05H10.2
+Y53F4B.3	T05H10.2
+Y56A3A.29	T05H10.2
+Y71F9AL.18	T05H10.2
+Y56A3A.29	W03D2.4
+Y71F9AL.18	W03D2.4
+Y56A3A.29	Y47G6A.8
+Y71F9AL.18	Y47G6A.8
+Y56A3A.29	Y53F4B.3
+Y71F9AL.18	Y53F4B.3
+Y71F9AL.18	Y56A3A.29
+C47D12.8	C29A12.3
+F10G8.7	C29A12.3
+F45E12.3	C29A12.3
+F53G2.7	C29A12.3
+F53H4.1	C29A12.3
+F57B10.6	C29A12.3
+K07G5.2	C29A12.3
+M18.5	C29A12.3
+R02D3.3	C29A12.3
+T16H12.4	C29A12.3
+Y39G10AL.3	C29A12.3
+Y49F6B.1	C29A12.3
+Y50D7A.2	C29A12.3
+Y55B1AL.2	C29A12.3
+Y66D12A.15	C29A12.3
+Y73F8A.24	C29A12.3
+Y76B12C.2	C29A12.3
+ZK1128.4	C29A12.3
+ZK20.3	C29A12.3
+ZK287.5	C29A12.3
+C47D12.8	C39E9.13
+F10G8.7	C39E9.13
+F45E12.3	C39E9.13
+F53G2.7	C39E9.13
+F53H4.1	C39E9.13
+F57B10.6	C39E9.13
+K07G5.2	C39E9.13
+M18.5	C39E9.13
+R02D3.3	C39E9.13
+T16H12.4	C39E9.13
+Y39G10AL.3	C39E9.13
+Y49F6B.1	C39E9.13
+Y50D7A.2	C39E9.13
+Y55B1AL.2	C39E9.13
+Y66D12A.15	C39E9.13
+Y73F8A.24	C39E9.13
+Y76B12C.2	C39E9.13
+ZK1128.4	C39E9.13
+ZK20.3	C39E9.13
+ZK287.5	C39E9.13
+C54G10.2	C47D12.8
+F08B4.5	C47D12.8
+F10C2.4	C47D12.8
+F10G8.7	C47D12.8
+F12F6.7	C47D12.8
+F18A1.5	C47D12.8
+F31E3.3	C47D12.8
+F33H2.5	C47D12.8
+F44B9.8	C47D12.8
+F45E12.3	C47D12.8
+F53G2.7	C47D12.8
+F53H4.1	C47D12.8
+F57B10.6	C47D12.8
+F58F6.4	C47D12.8
+F59A3.6	C47D12.8
+K07G5.2	C47D12.8
+M04F3.1	C47D12.8
+M18.5	C47D12.8
+R02D3.3	C47D12.8
+R04F11.3	C47D12.8
+T16H12.4	C47D12.8
+W03D2.4	C47D12.8
+Y39G10AL.3	C47D12.8
+Y49F6B.1	C47D12.8
+Y50D7A.2	C47D12.8
+Y53F4B.3	C47D12.8
+Y55B1AL.2	C47D12.8
+Y66D12A.15	C47D12.8
+Y73F8A.24	C47D12.8
+Y76B12C.2	C47D12.8
+ZK1128.4	C47D12.8
+ZK20.3	C47D12.8
+ZK287.5	C47D12.8
+F10G8.7	C54G10.2
+F45E12.3	C54G10.2
+F53G2.7	C54G10.2
+F53H4.1	C54G10.2
+F57B10.6	C54G10.2
+K07G5.2	C54G10.2
+M18.5	C54G10.2
+R02D3.3	C54G10.2
+T16H12.4	C54G10.2
+Y39G10AL.3	C54G10.2
+Y49F6B.1	C54G10.2
+Y50D7A.2	C54G10.2
+Y55B1AL.2	C54G10.2
+Y66D12A.15	C54G10.2
+Y73F8A.24	C54G10.2
+Y76B12C.2	C54G10.2
+ZK1128.4	C54G10.2
+ZK20.3	C54G10.2
+ZK287.5	C54G10.2
+F10G8.7	F08B4.5
+F45E12.3	F08B4.5
+F53G2.7	F08B4.5
+F53H4.1	F08B4.5
+F57B10.6	F08B4.5
+K07G5.2	F08B4.5
+M18.5	F08B4.5
+R02D3.3	F08B4.5
+T16H12.4	F08B4.5
+Y39G10AL.3	F08B4.5
+Y49F6B.1	F08B4.5
+Y50D7A.2	F08B4.5
+Y55B1AL.2	F08B4.5
+Y66D12A.15	F08B4.5
+Y73F8A.24	F08B4.5
+Y76B12C.2	F08B4.5
+ZK1128.4	F08B4.5
+ZK20.3	F08B4.5
+ZK287.5	F08B4.5
+F10G8.7	F10C2.4
+F45E12.3	F10C2.4
+F53G2.7	F10C2.4
+F53H4.1	F10C2.4
+F57B10.6	F10C2.4
+K07G5.2	F10C2.4
+M18.5	F10C2.4
+R02D3.3	F10C2.4
+T16H12.4	F10C2.4
+Y39G10AL.3	F10C2.4
+Y49F6B.1	F10C2.4
+Y50D7A.2	F10C2.4
+Y55B1AL.2	F10C2.4
+Y66D12A.15	F10C2.4
+Y73F8A.24	F10C2.4
+Y76B12C.2	F10C2.4
+ZK1128.4	F10C2.4
+ZK20.3	F10C2.4
+ZK287.5	F10C2.4
+F12F6.7	F10G8.7
+F18A1.5	F10G8.7
+F31E3.3	F10G8.7
+F33H2.5	F10G8.7
+F44B9.8	F10G8.7
+F45E12.3	F10G8.7
+F53G2.7	F10G8.7
+F53H4.1	F10G8.7
+F57B10.6	F10G8.7
+F58F6.4	F10G8.7
+F59A3.6	F10G8.7
+K07G5.2	F10G8.7
+M04F3.1	F10G8.7
+M18.5	F10G8.7
+R02D3.3	F10G8.7
+R04F11.3	F10G8.7
+T16H12.4	F10G8.7
+W03D2.4	F10G8.7
+Y39G10AL.3	F10G8.7
+Y49F6B.1	F10G8.7
+Y50D7A.2	F10G8.7
+Y53F4B.3	F10G8.7
+Y55B1AL.2	F10G8.7
+Y66D12A.15	F10G8.7
+Y73F8A.24	F10G8.7
+Y76B12C.2	F10G8.7
+ZK1128.4	F10G8.7
+ZK20.3	F10G8.7
+ZK287.5	F10G8.7
+F45E12.3	F12F6.7
+F53G2.7	F12F6.7
+F53H4.1	F12F6.7
+F57B10.6	F12F6.7
+K07G5.2	F12F6.7
+M18.5	F12F6.7
+R02D3.3	F12F6.7
+T16H12.4	F12F6.7
+Y39G10AL.3	F12F6.7
+Y49F6B.1	F12F6.7
+Y50D7A.2	F12F6.7
+Y55B1AL.2	F12F6.7
+Y66D12A.15	F12F6.7
+Y73F8A.24	F12F6.7
+Y76B12C.2	F12F6.7
+ZK1128.4	F12F6.7
+ZK20.3	F12F6.7
+ZK287.5	F12F6.7
+F45E12.3	F18A1.5
+F53G2.7	F18A1.5
+F53H4.1	F18A1.5
+F57B10.6	F18A1.5
+K07G5.2	F18A1.5
+M18.5	F18A1.5
+R02D3.3	F18A1.5
+T16H12.4	F18A1.5
+Y39G10AL.3	F18A1.5
+Y49F6B.1	F18A1.5
+Y50D7A.2	F18A1.5
+Y55B1AL.2	F18A1.5
+Y66D12A.15	F18A1.5
+Y73F8A.24	F18A1.5
+Y76B12C.2	F18A1.5
+ZK1128.4	F18A1.5
+ZK20.3	F18A1.5
+ZK287.5	F18A1.5
+F45E12.3	F31E3.3
+F53G2.7	F31E3.3
+F53H4.1	F31E3.3
+F57B10.6	F31E3.3
+K07G5.2	F31E3.3
+M18.5	F31E3.3
+R02D3.3	F31E3.3
+T16H12.4	F31E3.3
+Y39G10AL.3	F31E3.3
+Y49F6B.1	F31E3.3
+Y50D7A.2	F31E3.3
+Y55B1AL.2	F31E3.3
+Y66D12A.15	F31E3.3
+Y73F8A.24	F31E3.3
+Y76B12C.2	F31E3.3
+ZK1128.4	F31E3.3
+ZK20.3	F31E3.3
+ZK287.5	F31E3.3
+F45E12.3	F33H2.5
+F53G2.7	F33H2.5
+F53H4.1	F33H2.5
+F57B10.6	F33H2.5
+K07G5.2	F33H2.5
+M18.5	F33H2.5
+R02D3.3	F33H2.5
+T16H12.4	F33H2.5
+Y39G10AL.3	F33H2.5
+Y49F6B.1	F33H2.5
+Y50D7A.2	F33H2.5
+Y55B1AL.2	F33H2.5
+Y66D12A.15	F33H2.5
+Y73F8A.24	F33H2.5
+Y76B12C.2	F33H2.5
+ZK1128.4	F33H2.5
+ZK20.3	F33H2.5
+ZK287.5	F33H2.5
+F45E12.3	F44B9.8
+F53G2.7	F44B9.8
+F53H4.1	F44B9.8
+F57B10.6	F44B9.8
+K07G5.2	F44B9.8
+M18.5	F44B9.8
+R02D3.3	F44B9.8
+T16H12.4	F44B9.8
+Y39G10AL.3	F44B9.8
+Y49F6B.1	F44B9.8
+Y50D7A.2	F44B9.8
+Y55B1AL.2	F44B9.8
+Y66D12A.15	F44B9.8
+Y73F8A.24	F44B9.8
+Y76B12C.2	F44B9.8
+ZK1128.4	F44B9.8
+ZK20.3	F44B9.8
+ZK287.5	F44B9.8
+F53G2.7	F45E12.3
+F53H4.1	F45E12.3
+F57B10.6	F45E12.3
+F58F6.4	F45E12.3
+F59A3.6	F45E12.3
+K07G5.2	F45E12.3
+M04F3.1	F45E12.3
+M18.5	F45E12.3
+R02D3.3	F45E12.3
+R04F11.3	F45E12.3
+T16H12.4	F45E12.3
+W03D2.4	F45E12.3
+Y39G10AL.3	F45E12.3
+Y49F6B.1	F45E12.3
+Y50D7A.2	F45E12.3
+Y53F4B.3	F45E12.3
+Y55B1AL.2	F45E12.3
+Y66D12A.15	F45E12.3
+Y73F8A.24	F45E12.3
+Y76B12C.2	F45E12.3
+ZK1128.4	F45E12.3
+ZK20.3	F45E12.3
+ZK287.5	F45E12.3
+F53H4.1	F53G2.7
+F57B10.6	F53G2.7
+F58F6.4	F53G2.7
+F59A3.6	F53G2.7
+K07G5.2	F53G2.7
+M04F3.1	F53G2.7
+M18.5	F53G2.7
+R04F11.3	F53G2.7
+W03D2.4	F53G2.7
+Y53F4B.3	F53G2.7
+Y76B12C.2	F53G2.7
+ZK20.3	F53G2.7
+ZK287.5	F53G2.7
+F57B10.6	F53H4.1
+F58F6.4	F53H4.1
+F59A3.6	F53H4.1
+K07G5.2	F53H4.1
+M04F3.1	F53H4.1
+M18.5	F53H4.1
+R02D3.3	F53H4.1
+R04F11.3	F53H4.1
+T16H12.4	F53H4.1
+W03D2.4	F53H4.1
+Y39G10AL.3	F53H4.1
+Y49F6B.1	F53H4.1
+Y50D7A.2	F53H4.1
+Y53F4B.3	F53H4.1
+Y55B1AL.2	F53H4.1
+Y66D12A.15	F53H4.1
+Y73F8A.24	F53H4.1
+Y76B12C.2	F53H4.1
+ZK1128.4	F53H4.1
+ZK20.3	F53H4.1
+ZK287.5	F53H4.1
+F58F6.4	F57B10.6
+F59A3.6	F57B10.6
+K07G5.2	F57B10.6
+M04F3.1	F57B10.6
+M18.5	F57B10.6
+R02D3.3	F57B10.6
+R04F11.3	F57B10.6
+T16H12.4	F57B10.6
+W03D2.4	F57B10.6
+Y39G10AL.3	F57B10.6
+Y49F6B.1	F57B10.6
+Y50D7A.2	F57B10.6
+Y53F4B.3	F57B10.6
+Y55B1AL.2	F57B10.6
+Y66D12A.15	F57B10.6
+Y73F8A.24	F57B10.6
+Y76B12C.2	F57B10.6
+ZK1128.4	F57B10.6
+ZK20.3	F57B10.6
+ZK287.5	F57B10.6
+K07G5.2	F58F6.4
+M18.5	F58F6.4
+R02D3.3	F58F6.4
+T16H12.4	F58F6.4
+Y39G10AL.3	F58F6.4
+Y49F6B.1	F58F6.4
+Y50D7A.2	F58F6.4
+Y55B1AL.2	F58F6.4
+Y66D12A.15	F58F6.4
+Y73F8A.24	F58F6.4
+Y76B12C.2	F58F6.4
+ZK1128.4	F58F6.4
+ZK20.3	F58F6.4
+ZK287.5	F58F6.4
+K07G5.2	F59A3.6
+M18.5	F59A3.6
+R02D3.3	F59A3.6
+T16H12.4	F59A3.6
+Y39G10AL.3	F59A3.6
+Y49F6B.1	F59A3.6
+Y50D7A.2	F59A3.6
+Y55B1AL.2	F59A3.6
+Y66D12A.15	F59A3.6
+Y73F8A.24	F59A3.6
+Y76B12C.2	F59A3.6
+ZK1128.4	F59A3.6
+ZK20.3	F59A3.6
+ZK287.5	F59A3.6
+M04F3.1	K07G5.2
+M18.5	K07G5.2
+R02D3.3	K07G5.2
+R04F11.3	K07G5.2
+T16H12.4	K07G5.2
+W03D2.4	K07G5.2
+Y39G10AL.3	K07G5.2
+Y49F6B.1	K07G5.2
+Y50D7A.2	K07G5.2
+Y53F4B.3	K07G5.2
+Y55B1AL.2	K07G5.2
+Y66D12A.15	K07G5.2
+Y73F8A.24	K07G5.2
+Y76B12C.2	K07G5.2
+ZK1128.4	K07G5.2
+ZK20.3	K07G5.2
+ZK287.5	K07G5.2
+M18.5	M04F3.1
+R02D3.3	M04F3.1
+T16H12.4	M04F3.1
+Y39G10AL.3	M04F3.1
+Y49F6B.1	M04F3.1
+Y50D7A.2	M04F3.1
+Y55B1AL.2	M04F3.1
+Y66D12A.15	M04F3.1
+Y73F8A.24	M04F3.1
+Y76B12C.2	M04F3.1
+ZK1128.4	M04F3.1
+ZK20.3	M04F3.1
+ZK287.5	M04F3.1
+R02D3.3	M18.5
+R04F11.3	M18.5
+T16H12.4	M18.5
+W03D2.4	M18.5
+Y39G10AL.3	M18.5
+Y49F6B.1	M18.5
+Y50D7A.2	M18.5
+Y53F4B.3	M18.5
+Y55B1AL.2	M18.5
+Y66D12A.15	M18.5
+Y73F8A.24	M18.5
+Y76B12C.2	M18.5
+ZK1128.4	M18.5
+ZK20.3	M18.5
+ZK287.5	M18.5
+R04F11.3	R02D3.3
+W03D2.4	R02D3.3
+Y53F4B.3	R02D3.3
+Y76B12C.2	R02D3.3
+ZK20.3	R02D3.3
+ZK287.5	R02D3.3
+T16H12.4	R04F11.3
+Y39G10AL.3	R04F11.3
+Y49F6B.1	R04F11.3
+Y50D7A.2	R04F11.3
+Y55B1AL.2	R04F11.3
+Y66D12A.15	R04F11.3
+Y73F8A.24	R04F11.3
+Y76B12C.2	R04F11.3
+ZK1128.4	R04F11.3
+ZK20.3	R04F11.3
+ZK287.5	R04F11.3
+W03D2.4	T16H12.4
+Y53F4B.3	T16H12.4
+Y76B12C.2	T16H12.4
+ZK20.3	T16H12.4
+ZK287.5	T16H12.4
+Y39G10AL.3	W03D2.4
+Y49F6B.1	W03D2.4
+Y50D7A.2	W03D2.4
+Y55B1AL.2	W03D2.4
+Y66D12A.15	W03D2.4
+Y73F8A.24	W03D2.4
+Y76B12C.2	W03D2.4
+ZK1128.4	W03D2.4
+ZK20.3	W03D2.4
+ZK287.5	W03D2.4
+Y53F4B.3	Y39G10AL.3
+Y76B12C.2	Y39G10AL.3
+ZK20.3	Y39G10AL.3
+ZK287.5	Y39G10AL.3
+Y53F4B.3	Y49F6B.1
+Y76B12C.2	Y49F6B.1
+ZK20.3	Y49F6B.1
+ZK287.5	Y49F6B.1
+Y53F4B.3	Y50D7A.2
+Y76B12C.2	Y50D7A.2
+ZK20.3	Y50D7A.2
+ZK287.5	Y50D7A.2
+Y55B1AL.2	Y53F4B.3
+Y66D12A.15	Y53F4B.3
+Y73F8A.24	Y53F4B.3
+Y76B12C.2	Y53F4B.3
+ZK1128.4	Y53F4B.3
+ZK20.3	Y53F4B.3
+ZK287.5	Y53F4B.3
+Y76B12C.2	Y55B1AL.2
+ZK20.3	Y55B1AL.2
+ZK287.5	Y55B1AL.2
+Y76B12C.2	Y66D12A.15
+ZK20.3	Y66D12A.15
+ZK287.5	Y66D12A.15
+Y76B12C.2	Y73F8A.24
+ZK20.3	Y73F8A.24
+ZK287.5	Y73F8A.24
+ZK1128.4	Y76B12C.2
+ZK20.3	Y76B12C.2
+ZK287.5	Y76B12C.2
+ZK20.3	ZK1128.4
+ZK287.5	ZK1128.4
+ZK287.5	ZK20.3
+F45G2.3	C29A12.3
+H12C20.2	C29A12.3
+H26D21.2	C29A12.3
+T28A8.7	C29A12.3
+Y47G6A.11	C29A12.3
+F45G2.3	C39E9.13
+H12C20.2	C39E9.13
+H26D21.2	C39E9.13
+T28A8.7	C39E9.13
+Y47G6A.11	C39E9.13
+F45G2.3	C54G10.2
+H12C20.2	C54G10.2
+H26D21.2	C54G10.2
+T28A8.7	C54G10.2
+Y47G6A.11	C54G10.2
+F45G2.3	F10C2.4
+H12C20.2	F10C2.4
+H26D21.2	F10C2.4
+T28A8.7	F10C2.4
+Y47G6A.11	F10C2.4
+F45G2.3	F12F6.7
+H12C20.2	F12F6.7
+H26D21.2	F12F6.7
+T28A8.7	F12F6.7
+Y47G6A.11	F12F6.7
+F45G2.3	F18A1.5
+H12C20.2	F18A1.5
+H26D21.2	F18A1.5
+T28A8.7	F18A1.5
+Y47G6A.11	F18A1.5
+F45G2.3	F31E3.3
+H12C20.2	F31E3.3
+H26D21.2	F31E3.3
+T28A8.7	F31E3.3
+Y47G6A.11	F31E3.3
+F45G2.3	F44B9.8
+H12C20.2	F44B9.8
+H26D21.2	F44B9.8
+T28A8.7	F44B9.8
+Y47G6A.11	F44B9.8
+F58F6.4	F45G2.3
+F59A3.6	F45G2.3
+H12C20.2	F45G2.3
+H26D21.2	F45G2.3
+M04F3.1	F45G2.3
+R04F11.3	F45G2.3
+T28A8.7	F45G2.3
+W03D2.4	F45G2.3
+Y47G6A.11	F45G2.3
+H12C20.2	F58F6.4
+H26D21.2	F58F6.4
+T28A8.7	F58F6.4
+Y47G6A.11	F58F6.4
+H12C20.2	F59A3.6
+H26D21.2	F59A3.6
+T28A8.7	F59A3.6
+Y47G6A.11	F59A3.6
+H26D21.2	H12C20.2
+M04F3.1	H12C20.2
+R04F11.3	H12C20.2
+W03D2.4	H12C20.2
+M04F3.1	H26D21.2
+R04F11.3	H26D21.2
+T28A8.7	H26D21.2
+W03D2.4	H26D21.2
+T28A8.7	M04F3.1
+Y47G6A.11	M04F3.1
+T28A8.7	R04F11.3
+Y47G6A.11	R04F11.3
+W03D2.4	T28A8.7
+Y47G6A.11	W03D2.4
+F10C2.4	C43E11.2
+F12F6.7	C43E11.2
+F18A1.5	C43E11.2
+F59A3.6	C43E11.2
+M04F3.1	C43E11.2
+R04F11.3	C43E11.2
+T04A11.6	C43E11.2
+T04H1.4	C43E11.2
+W06D4.6	C43E11.2
+Y116A8C.13	C43E11.2
+Y119D3B.15	C43E11.2
+Y43C5A.6	C43E11.2
+Y48C3A.14	C43E11.2
+Y56A3A.27	C43E11.2
+ZC302.1	C43E11.2
+T04A11.6	F10C2.4
+T04H1.4	F10C2.4
+W06D4.6	F10C2.4
+Y116A8C.13	F10C2.4
+Y119D3B.15	F10C2.4
+Y43C5A.6	F10C2.4
+Y48C3A.14	F10C2.4
+Y56A3A.27	F10C2.4
+ZC302.1	F10C2.4
+T04A11.6	F12F6.7
+T04H1.4	F12F6.7
+W06D4.6	F12F6.7
+Y116A8C.13	F12F6.7
+Y119D3B.15	F12F6.7
+Y43C5A.6	F12F6.7
+Y48C3A.14	F12F6.7
+Y56A3A.27	F12F6.7
+ZC302.1	F12F6.7
+T04A11.6	F18A1.5
+T04H1.4	F18A1.5
+W06D4.6	F18A1.5
+Y116A8C.13	F18A1.5
+Y119D3B.15	F18A1.5
+Y43C5A.6	F18A1.5
+Y48C3A.14	F18A1.5
+Y56A3A.27	F18A1.5
+ZC302.1	F18A1.5
+T04A11.6	F59A3.6
+T04H1.4	F59A3.6
+W06D4.6	F59A3.6
+Y116A8C.13	F59A3.6
+Y119D3B.15	F59A3.6
+Y43C5A.6	F59A3.6
+Y48C3A.14	F59A3.6
+Y56A3A.27	F59A3.6
+ZC302.1	F59A3.6
+T04A11.6	M04F3.1
+T04H1.4	M04F3.1
+W06D4.6	M04F3.1
+Y116A8C.13	M04F3.1
+Y119D3B.15	M04F3.1
+Y43C5A.6	M04F3.1
+Y48C3A.14	M04F3.1
+Y56A3A.27	M04F3.1
+ZC302.1	M04F3.1
+T04A11.6	R04F11.3
+T04H1.4	R04F11.3
+W06D4.6	R04F11.3
+Y116A8C.13	R04F11.3
+Y119D3B.15	R04F11.3
+Y43C5A.6	R04F11.3
+Y48C3A.14	R04F11.3
+Y56A3A.27	R04F11.3
+ZC302.1	R04F11.3
+T04H1.4	T04A11.6
+W06D4.6	T04A11.6
+Y116A8C.13	T04A11.6
+Y119D3B.15	T04A11.6
+Y43C5A.6	T04A11.6
+Y48C3A.14	T04A11.6
+Y56A3A.27	T04A11.6
+ZC302.1	T04A11.6
+W06D4.6	T04H1.4
+Y116A8C.13	T04H1.4
+Y119D3B.15	T04H1.4
+Y43C5A.6	T04H1.4
+Y48C3A.14	T04H1.4
+Y56A3A.27	T04H1.4
+ZC302.1	T04H1.4
+Y116A8C.13	W06D4.6
+Y119D3B.15	W06D4.6
+Y43C5A.6	W06D4.6
+Y48C3A.14	W06D4.6
+Y56A3A.27	W06D4.6
+ZC302.1	W06D4.6
+Y119D3B.15	Y116A8C.13
+Y43C5A.6	Y116A8C.13
+Y48C3A.14	Y116A8C.13
+Y56A3A.27	Y116A8C.13
+ZC302.1	Y116A8C.13
+Y43C5A.6	Y119D3B.15
+Y48C3A.14	Y119D3B.15
+Y56A3A.27	Y119D3B.15
+ZC302.1	Y119D3B.15
+Y48C3A.14	Y43C5A.6
+Y56A3A.27	Y43C5A.6
+ZC302.1	Y43C5A.6
+Y56A3A.27	Y48C3A.14
+ZC302.1	Y48C3A.14
+ZC302.1	Y56A3A.27
+R07E5.8	C07H6.1
+T04H1.4	C07H6.1
+Y47D3A.4	C07H6.1
+Y47G6A.8	C07H6.1
+ZC302.1	C07H6.1
+T04H1.4	R07E5.8
+Y47D3A.4	R07E5.8
+Y47G6A.8	R07E5.8
+ZC302.1	R07E5.8
+Y47D3A.4	T04H1.4
+Y47G6A.8	T04H1.4
+Y47G6A.8	Y47D3A.4
+ZC302.1	Y47D3A.4
+ZC302.1	Y47G6A.8
+C07H6.6	C01G5.8
+C43E11.2	C01G5.8
+C47D12.8	C01G5.8
+F10G8.7	C01G5.8
+F18A1.5	C01G5.8
+F22B7.6	C01G5.8
+F33H2.1	C01G5.8
+F35G12.4	C01G5.8
+F35H10.5	C01G5.8
+F53A3.2	C01G5.8
+F56A3.2	C01G5.8
+F59A3.6	C01G5.8
+H12C20.2	C01G5.8
+M04F3.1	C01G5.8
+T04A11.6	C01G5.8
+T07C12.12	C01G5.8
+T28A8.7	C01G5.8
+W02D3.10	C01G5.8
+Y37B11A.2	C01G5.8
+Y41E3.9	C01G5.8
+Y43C5A.6	C01G5.8
+Y48C3A.14	C01G5.8
+Y56A3A.27	C01G5.8
+ZK675.2	C01G5.8
+C43E11.2	C07H6.6
+C47D12.8	C07H6.6
+F10G8.7	C07H6.6
+F18A1.5	C07H6.6
+F22B7.6	C07H6.6
+F33H2.1	C07H6.6
+F35G12.4	C07H6.6
+F35H10.5	C07H6.6
+F53A3.2	C07H6.6
+F56A3.2	C07H6.6
+F59A3.6	C07H6.6
+H12C20.2	C07H6.6
+M04F3.1	C07H6.6
+T04A11.6	C07H6.6
+T07C12.12	C07H6.6
+T28A8.7	C07H6.6
+W02D3.10	C07H6.6
+Y37B11A.2	C07H6.6
+Y41E3.9	C07H6.6
+Y43C5A.6	C07H6.6
+Y48C3A.14	C07H6.6
+Y56A3A.27	C07H6.6
+ZK675.2	C07H6.6
+C47D12.8	C43E11.2
+F10G8.7	C43E11.2
+F22B7.6	C43E11.2
+F33H2.1	C43E11.2
+F35G12.4	C43E11.2
+F35H10.5	C43E11.2
+F53A3.2	C43E11.2
+F56A3.2	C43E11.2
+H12C20.2	C43E11.2
+T07C12.12	C43E11.2
+T28A8.7	C43E11.2
+W02D3.10	C43E11.2
+Y37B11A.2	C43E11.2
+Y41E3.9	C43E11.2
+ZK675.2	C43E11.2
+F22B7.6	C47D12.8
+F33H2.1	C47D12.8
+F35G12.4	C47D12.8
+F35H10.5	C47D12.8
+F53A3.2	C47D12.8
+F56A3.2	C47D12.8
+H12C20.2	C47D12.8
+T04A11.6	C47D12.8
+T07C12.12	C47D12.8
+T28A8.7	C47D12.8
+W02D3.10	C47D12.8
+Y37B11A.2	C47D12.8
+Y41E3.9	C47D12.8
+Y43C5A.6	C47D12.8
+Y48C3A.14	C47D12.8
+Y56A3A.27	C47D12.8
+ZK675.2	C47D12.8
+F22B7.6	F10G8.7
+F33H2.1	F10G8.7
+F35G12.4	F10G8.7
+F35H10.5	F10G8.7
+F53A3.2	F10G8.7
+F56A3.2	F10G8.7
+H12C20.2	F10G8.7
+T04A11.6	F10G8.7
+T07C12.12	F10G8.7
+T28A8.7	F10G8.7
+W02D3.10	F10G8.7
+Y37B11A.2	F10G8.7
+Y41E3.9	F10G8.7
+Y43C5A.6	F10G8.7
+Y48C3A.14	F10G8.7
+Y56A3A.27	F10G8.7
+ZK675.2	F10G8.7
+F22B7.6	F18A1.5
+F33H2.1	F18A1.5
+F35G12.4	F18A1.5
+F35H10.5	F18A1.5
+F53A3.2	F18A1.5
+F56A3.2	F18A1.5
+T07C12.12	F18A1.5
+W02D3.10	F18A1.5
+Y37B11A.2	F18A1.5
+Y41E3.9	F18A1.5
+ZK675.2	F18A1.5
+F33H2.1	F22B7.6
+F35G12.4	F22B7.6
+F35H10.5	F22B7.6
+F53A3.2	F22B7.6
+F56A3.2	F22B7.6
+F59A3.6	F22B7.6
+H12C20.2	F22B7.6
+M04F3.1	F22B7.6
+T04A11.6	F22B7.6
+T07C12.12	F22B7.6
+T28A8.7	F22B7.6
+W02D3.10	F22B7.6
+Y37B11A.2	F22B7.6
+Y41E3.9	F22B7.6
+Y43C5A.6	F22B7.6
+Y48C3A.14	F22B7.6
+Y56A3A.27	F22B7.6
+ZK675.2	F22B7.6
+F35G12.4	F33H2.1
+F35H10.5	F33H2.1
+F53A3.2	F33H2.1
+F56A3.2	F33H2.1
+F59A3.6	F33H2.1
+H12C20.2	F33H2.1
+M04F3.1	F33H2.1
+T04A11.6	F33H2.1
+T07C12.12	F33H2.1
+T28A8.7	F33H2.1
+W02D3.10	F33H2.1
+Y37B11A.2	F33H2.1
+Y41E3.9	F33H2.1
+Y43C5A.6	F33H2.1
+Y48C3A.14	F33H2.1
+Y56A3A.27	F33H2.1
+ZK675.2	F33H2.1
+F35H10.5	F35G12.4
+F53A3.2	F35G12.4
+F56A3.2	F35G12.4
+F59A3.6	F35G12.4
+H12C20.2	F35G12.4
+M04F3.1	F35G12.4
+T04A11.6	F35G12.4
+T07C12.12	F35G12.4
+T28A8.7	F35G12.4
+W02D3.10	F35G12.4
+Y37B11A.2	F35G12.4
+Y41E3.9	F35G12.4
+Y43C5A.6	F35G12.4
+Y48C3A.14	F35G12.4
+Y56A3A.27	F35G12.4
+ZK675.2	F35G12.4
+F53A3.2	F35H10.5
+F56A3.2	F35H10.5
+F59A3.6	F35H10.5
+H12C20.2	F35H10.5
+M04F3.1	F35H10.5
+T04A11.6	F35H10.5
+T07C12.12	F35H10.5
+T28A8.7	F35H10.5
+W02D3.10	F35H10.5
+Y37B11A.2	F35H10.5
+Y41E3.9	F35H10.5
+Y43C5A.6	F35H10.5
+Y48C3A.14	F35H10.5
+Y56A3A.27	F35H10.5
+ZK675.2	F35H10.5
+F56A3.2	F53A3.2
+F59A3.6	F53A3.2
+H12C20.2	F53A3.2
+M04F3.1	F53A3.2
+T04A11.6	F53A3.2
+T07C12.12	F53A3.2
+T28A8.7	F53A3.2
+W02D3.10	F53A3.2
+Y37B11A.2	F53A3.2
+Y41E3.9	F53A3.2
+Y43C5A.6	F53A3.2
+Y48C3A.14	F53A3.2
+Y56A3A.27	F53A3.2
+ZK675.2	F53A3.2
+F59A3.6	F56A3.2
+H12C20.2	F56A3.2
+M04F3.1	F56A3.2
+T04A11.6	F56A3.2
+T07C12.12	F56A3.2
+T28A8.7	F56A3.2
+W02D3.10	F56A3.2
+Y37B11A.2	F56A3.2
+Y41E3.9	F56A3.2
+Y43C5A.6	F56A3.2
+Y48C3A.14	F56A3.2
+Y56A3A.27	F56A3.2
+ZK675.2	F56A3.2
+T07C12.12	F59A3.6
+W02D3.10	F59A3.6
+Y37B11A.2	F59A3.6
+Y41E3.9	F59A3.6
+ZK675.2	F59A3.6
+T04A11.6	H12C20.2
+T07C12.12	H12C20.2
+W02D3.10	H12C20.2
+Y37B11A.2	H12C20.2
+Y41E3.9	H12C20.2
+Y48C3A.14	H12C20.2
+Y56A3A.27	H12C20.2
+ZK675.2	H12C20.2
+T07C12.12	M04F3.1
+W02D3.10	M04F3.1
+Y37B11A.2	M04F3.1
+Y41E3.9	M04F3.1
+ZK675.2	M04F3.1
+T07C12.12	T04A11.6
+T28A8.7	T04A11.6
+W02D3.10	T04A11.6
+Y37B11A.2	T04A11.6
+Y41E3.9	T04A11.6
+ZK675.2	T04A11.6
+T28A8.7	T07C12.12
+W02D3.10	T07C12.12
+Y37B11A.2	T07C12.12
+Y41E3.9	T07C12.12
+Y43C5A.6	T07C12.12
+Y48C3A.14	T07C12.12
+Y56A3A.27	T07C12.12
+ZK675.2	T07C12.12
+W02D3.10	T28A8.7
+Y37B11A.2	T28A8.7
+Y41E3.9	T28A8.7
+Y48C3A.14	T28A8.7
+Y56A3A.27	T28A8.7
+ZK675.2	T28A8.7
+Y37B11A.2	W02D3.10
+Y41E3.9	W02D3.10
+Y43C5A.6	W02D3.10
+Y48C3A.14	W02D3.10
+Y56A3A.27	W02D3.10
+ZK675.2	W02D3.10
+Y41E3.9	Y37B11A.2
+Y43C5A.6	Y37B11A.2
+Y48C3A.14	Y37B11A.2
+Y56A3A.27	Y37B11A.2
+ZK675.2	Y37B11A.2
+Y43C5A.6	Y41E3.9
+Y48C3A.14	Y41E3.9
+Y56A3A.27	Y41E3.9
+ZK675.2	Y41E3.9
+ZK675.2	Y43C5A.6
+ZK675.2	Y48C3A.14
+ZK675.2	Y56A3A.27
+B0414.7	B0218.3
+B0478.1	B0218.3
+C02F4.2	B0218.3
+C03H5.4	B0218.3
+C04F12.8	B0218.3
+C05D11.4	B0218.3
+C07E3.9	B0218.3
+C09B8.7	B0218.3
+C12C8.1	B0218.3
+C12D8.10	B0218.3
+C14F5.5	B0218.3
+C23F12.1	B0218.3
+C37F5.1	B0218.3
+C44H4.5	B0218.3
+C48A7.1	B0218.3
+C50C3.9	B0218.3
+C54D2.5	B0218.3
+C54G4.1	B0218.3
+E01H11.1	B0218.3
+F08B1.1	B0218.3
+F11F1.1	B0218.3
+F14H12.4	B0218.3
+F17C8.4	B0218.3
+F18G5.3	B0218.3
+F25D1.1	B0218.3
+F26D10.3	B0218.3
+F28H6.1	B0218.3
+F35C8.1	B0218.3
+F42G10.2	B0218.3
+F43C1.2	B0218.3
+F44E5.4	B0218.3
+F44E5.5	B0218.3
+F46G10.6	B0218.3
+F47F2.1	B0218.3
+F53H8.2	B0218.3
+F55C10.1	B0218.3
+F59A6.1	B0218.3
+F59D6.7	B0218.3
+K08A8.1	B0218.3
+R03G5.2	B0218.3
+R07G3.1	B0218.3
+R166.5	B0218.3
+T01H8.1	B0218.3
+T02C5.5	B0218.3
+T14G10.2	B0218.3
+T17E9.1	B0218.3
+T28F12.3	B0218.3
+T28F2.5	B0218.3
+W06F12.1	B0218.3
+W07A8.2	B0218.3
+Y17G9B.5	B0218.3
+Y32F6B.3	B0218.3
+Y39B6A.2	B0218.3
+Y41D4B.13	B0218.3
+Y54E10BL.6	B0218.3
+Y66H1B.2	B0218.3
+Y71H2AL.1	B0218.3
+Y73B6A.5	B0218.3
+ZK1067.1	B0218.3
+ZK792.6	B0218.3
+ZK856.8	B0218.3
+ZK909.2	B0218.3
+B0478.1	B0414.7
+C02F4.2	B0414.7
+C03H5.4	B0414.7
+C04F12.8	B0414.7
+C05D11.4	B0414.7
+C07E3.9	B0414.7
+C09B8.7	B0414.7
+C12C8.1	B0414.7
+C12D8.10	B0414.7
+C14F5.5	B0414.7
+C23F12.1	B0414.7
+C37F5.1	B0414.7
+C44H4.5	B0414.7
+C48A7.1	B0414.7
+C50C3.9	B0414.7
+C54D2.5	B0414.7
+C54G4.1	B0414.7
+E01H11.1	B0414.7
+F08B1.1	B0414.7
+F11F1.1	B0414.7
+F14H12.4	B0414.7
+F17C8.4	B0414.7
+F18G5.3	B0414.7
+F25D1.1	B0414.7
+F26D10.3	B0414.7
+F28H6.1	B0414.7
+F35C8.1	B0414.7
+F42G10.2	B0414.7
+F42G8.3	B0414.7
+F43C1.2	B0414.7
+F44E5.4	B0414.7
+F44E5.5	B0414.7
+F46G10.6	B0414.7
+F47F2.1	B0414.7
+F53H8.2	B0414.7
+F55C10.1	B0414.7
+F59A6.1	B0414.7
+F59D6.7	B0414.7
+K08A8.1	B0414.7
+R03G5.2	B0414.7
+R07G3.1	B0414.7
+R166.5	B0414.7
+T01H8.1	B0414.7
+T02C5.5	B0414.7
+T14G10.2	B0414.7
+T17E9.1	B0414.7
+T28F12.3	B0414.7
+T28F2.5	B0414.7
+W06F12.1	B0414.7
+W07A8.2	B0414.7
+Y17G9B.5	B0414.7
+Y32F6B.3	B0414.7
+Y39B6A.2	B0414.7
+Y41D4B.13	B0414.7
+Y54E10BL.6	B0414.7
+Y66H1B.2	B0414.7
+Y71H2AL.1	B0414.7
+Y73B6A.5	B0414.7
+ZK1067.1	B0414.7
+ZK792.6	B0414.7
+ZK856.8	B0414.7
+ZK909.2	B0414.7
+C02F4.2	B0478.1
+C03H5.4	B0478.1
+C04F12.8	B0478.1
+C05D11.4	B0478.1
+C07E3.9	B0478.1
+C09B8.7	B0478.1
+C12C8.1	B0478.1
+C12D8.10	B0478.1
+C14F5.5	B0478.1
+C23F12.1	B0478.1
+C37F5.1	B0478.1
+C44H4.5	B0478.1
+C48A7.1	B0478.1
+C50C3.9	B0478.1
+C54D2.5	B0478.1
+C54G4.1	B0478.1
+E01H11.1	B0478.1
+F08B1.1	B0478.1
+F11F1.1	B0478.1
+F14H12.4	B0478.1
+F17C8.4	B0478.1
+F18G5.3	B0478.1
+F25D1.1	B0478.1
+F26D10.3	B0478.1
+F28H6.1	B0478.1
+F35C8.1	B0478.1
+F42G10.2	B0478.1
+F42G8.3	B0478.1
+F43C1.2	B0478.1
+F44E5.4	B0478.1
+F44E5.5	B0478.1
+F46G10.6	B0478.1
+F47F2.1	B0478.1
+F53H8.2	B0478.1
+F55C10.1	B0478.1
+F59A6.1	B0478.1
+F59D6.7	B0478.1
+K08A8.1	B0478.1
+R03G5.2	B0478.1
+R07G3.1	B0478.1
+R166.5	B0478.1
+T01H8.1	B0478.1
+T02C5.5	B0478.1
+T14G10.2	B0478.1
+T17E9.1	B0478.1
+T28F12.3	B0478.1
+T28F2.5	B0478.1
+W06F12.1	B0478.1
+W07A8.2	B0478.1
+Y17G9B.5	B0478.1
+Y32F6B.3	B0478.1
+Y39B6A.2	B0478.1
+Y41D4B.13	B0478.1
+Y54E10BL.6	B0478.1
+Y66H1B.2	B0478.1
+Y71H2AL.1	B0478.1
+Y73B6A.5	B0478.1
+ZK1067.1	B0478.1
+ZK792.6	B0478.1
+ZK856.8	B0478.1
+ZK909.2	B0478.1
+C03H5.4	C02F4.2
+C04F12.8	C02F4.2
+C05D11.4	C02F4.2
+C07E3.9	C02F4.2
+C09B8.7	C02F4.2
+C12C8.1	C02F4.2
+C12D8.10	C02F4.2
+C14F5.5	C02F4.2
+C23F12.1	C02F4.2
+C37F5.1	C02F4.2
+C44H4.5	C02F4.2
+C48A7.1	C02F4.2
+C50C3.9	C02F4.2
+C54D2.5	C02F4.2
+C54G4.1	C02F4.2
+E01H11.1	C02F4.2
+F08B1.1	C02F4.2
+F11F1.1	C02F4.2
+F14H12.4	C02F4.2
+F17C8.4	C02F4.2
+F18G5.3	C02F4.2
+F25D1.1	C02F4.2
+F26D10.3	C02F4.2
+F28H6.1	C02F4.2
+F35C8.1	C02F4.2
+F42G10.2	C02F4.2
+F42G8.3	C02F4.2
+F43C1.2	C02F4.2
+F44E5.4	C02F4.2
+F44E5.5	C02F4.2
+F46G10.6	C02F4.2
+F47F2.1	C02F4.2
+F53H8.2	C02F4.2
+F55C10.1	C02F4.2
+F59A6.1	C02F4.2
+F59D6.7	C02F4.2
+K08A8.1	C02F4.2
+R03G5.2	C02F4.2
+R07G3.1	C02F4.2
+R166.5	C02F4.2
+T01H8.1	C02F4.2
+T02C5.5	C02F4.2
+T14G10.2	C02F4.2
+T17E9.1	C02F4.2
+T28F12.3	C02F4.2
+T28F2.5	C02F4.2
+W06F12.1	C02F4.2
+W07A8.2	C02F4.2
+Y17G9B.5	C02F4.2
+Y32F6B.3	C02F4.2
+Y39B6A.2	C02F4.2
+Y41D4B.13	C02F4.2
+Y54E10BL.6	C02F4.2
+Y66H1B.2	C02F4.2
+Y71H2AL.1	C02F4.2
+Y73B6A.5	C02F4.2
+ZK1067.1	C02F4.2
+ZK792.6	C02F4.2
+ZK856.8	C02F4.2
+ZK909.2	C02F4.2
+C04F12.8	C03H5.4
+C05D11.4	C03H5.4
+C09B8.7	C03H5.4
+C12C8.1	C03H5.4
+C12D8.10	C03H5.4
+C14F5.5	C03H5.4
+C23F12.1	C03H5.4
+C37F5.1	C03H5.4
+C44H4.5	C03H5.4
+C48A7.1	C03H5.4
+C50C3.9	C03H5.4
+C54D2.5	C03H5.4
+C54G4.1	C03H5.4
+E01H11.1	C03H5.4
+F08B1.1	C03H5.4
+F11F1.1	C03H5.4
+F14H12.4	C03H5.4
+F17C8.4	C03H5.4
+F18G5.3	C03H5.4
+F25D1.1	C03H5.4
+F26D10.3	C03H5.4
+F28H6.1	C03H5.4
+F35C8.1	C03H5.4
+F42G10.2	C03H5.4
+F42G8.3	C03H5.4
+F43C1.2	C03H5.4
+F44E5.4	C03H5.4
+F44E5.5	C03H5.4
+F46G10.6	C03H5.4
+F47F2.1	C03H5.4
+F53H8.2	C03H5.4
+F55C10.1	C03H5.4
+F59A6.1	C03H5.4
+F59D6.7	C03H5.4
+K08A8.1	C03H5.4
+R03G5.2	C03H5.4
+R07G3.1	C03H5.4
+R166.5	C03H5.4
+T01H8.1	C03H5.4
+T02C5.5	C03H5.4
+T14G10.2	C03H5.4
+T17E9.1	C03H5.4
+T28F12.3	C03H5.4
+T28F2.5	C03H5.4
+W06F12.1	C03H5.4
+Y17G9B.5	C03H5.4
+Y32F6B.3	C03H5.4
+Y39B6A.2	C03H5.4
+Y41D4B.13	C03H5.4
+Y54E10BL.6	C03H5.4
+Y66H1B.2	C03H5.4
+Y71H2AL.1	C03H5.4
+Y73B6A.5	C03H5.4
+ZK1067.1	C03H5.4
+ZK792.6	C03H5.4
+ZK856.8	C03H5.4
+ZK909.2	C03H5.4
+C05D11.4	C04F12.8
+C07E3.9	C04F12.8
+C09B8.7	C04F12.8
+C12C8.1	C04F12.8
+C12D8.10	C04F12.8
+C14F5.5	C04F12.8
+C23F12.1	C04F12.8
+C37F5.1	C04F12.8
+C44H4.5	C04F12.8
+C48A7.1	C04F12.8
+C50C3.9	C04F12.8
+C54D2.5	C04F12.8
+C54G4.1	C04F12.8
+E01H11.1	C04F12.8
+F08B1.1	C04F12.8
+F11F1.1	C04F12.8
+F14H12.4	C04F12.8
+F17C8.4	C04F12.8
+F18G5.3	C04F12.8
+F25D1.1	C04F12.8
+F26D10.3	C04F12.8
+F28H6.1	C04F12.8
+F35C8.1	C04F12.8
+F42G10.2	C04F12.8
+F42G8.3	C04F12.8
+F43C1.2	C04F12.8
+F44E5.4	C04F12.8
+F44E5.5	C04F12.8
+F46G10.6	C04F12.8
+F47F2.1	C04F12.8
+F53H8.2	C04F12.8
+F55C10.1	C04F12.8
+F59A6.1	C04F12.8
+F59D6.7	C04F12.8
+K08A8.1	C04F12.8
+R03G5.2	C04F12.8
+R07G3.1	C04F12.8
+R166.5	C04F12.8
+T01H8.1	C04F12.8
+T02C5.5	C04F12.8
+T14G10.2	C04F12.8
+T17E9.1	C04F12.8
+T28F12.3	C04F12.8
+T28F2.5	C04F12.8
+W06F12.1	C04F12.8
+W07A8.2	C04F12.8
+Y17G9B.5	C04F12.8
+Y32F6B.3	C04F12.8
+Y39B6A.2	C04F12.8
+Y41D4B.13	C04F12.8
+Y54E10BL.6	C04F12.8
+Y66H1B.2	C04F12.8
+Y71H2AL.1	C04F12.8
+Y73B6A.5	C04F12.8
+ZK1067.1	C04F12.8
+ZK792.6	C04F12.8
+ZK856.8	C04F12.8
+ZK909.2	C04F12.8
+C07E3.9	C05D11.4
+C09B8.7	C05D11.4
+C12C8.1	C05D11.4
+C12D8.10	C05D11.4
+C14F5.5	C05D11.4
+C23F12.1	C05D11.4
+C37F5.1	C05D11.4
+C44H4.5	C05D11.4
+C48A7.1	C05D11.4
+C50C3.9	C05D11.4
+C54D2.5	C05D11.4
+C54G4.1	C05D11.4
+E01H11.1	C05D11.4
+F08B1.1	C05D11.4
+F11F1.1	C05D11.4
+F14H12.4	C05D11.4
+F17C8.4	C05D11.4
+F18G5.3	C05D11.4
+F25D1.1	C05D11.4
+F26D10.3	C05D11.4
+F28H6.1	C05D11.4
+F35C8.1	C05D11.4
+F42G10.2	C05D11.4
+F42G8.3	C05D11.4
+F43C1.2	C05D11.4
+F44E5.4	C05D11.4
+F44E5.5	C05D11.4
+F46G10.6	C05D11.4
+F47F2.1	C05D11.4
+F53H8.2	C05D11.4
+F55C10.1	C05D11.4
+F59A6.1	C05D11.4
+F59D6.7	C05D11.4
+K08A8.1	C05D11.4
+R03G5.2	C05D11.4
+R07G3.1	C05D11.4
+R166.5	C05D11.4
+T01H8.1	C05D11.4
+T02C5.5	C05D11.4
+T14G10.2	C05D11.4
+T17E9.1	C05D11.4
+T28F12.3	C05D11.4
+T28F2.5	C05D11.4
+W06F12.1	C05D11.4
+W07A8.2	C05D11.4
+Y17G9B.5	C05D11.4
+Y32F6B.3	C05D11.4
+Y39B6A.2	C05D11.4
+Y41D4B.13	C05D11.4
+Y54E10BL.6	C05D11.4
+Y66H1B.2	C05D11.4
+Y71H2AL.1	C05D11.4
+Y73B6A.5	C05D11.4
+ZK1067.1	C05D11.4
+ZK792.6	C05D11.4
+ZK856.8	C05D11.4
+ZK909.2	C05D11.4
+C09B8.7	C07E3.9
+C12C8.1	C07E3.9
+C12D8.10	C07E3.9
+C14F5.5	C07E3.9
+C23F12.1	C07E3.9
+C37F5.1	C07E3.9
+C44H4.5	C07E3.9
+C48A7.1	C07E3.9
+C50C3.9	C07E3.9
+C54D2.5	C07E3.9
+C54G4.1	C07E3.9
+E01H11.1	C07E3.9
+F08B1.1	C07E3.9
+F11F1.1	C07E3.9
+F14H12.4	C07E3.9
+F17C8.4	C07E3.9
+F18G5.3	C07E3.9
+F25D1.1	C07E3.9
+F26D10.3	C07E3.9
+F28H6.1	C07E3.9
+F35C8.1	C07E3.9
+F42G10.2	C07E3.9
+F42G8.3	C07E3.9
+F43C1.2	C07E3.9
+F44E5.4	C07E3.9
+F44E5.5	C07E3.9
+F46G10.6	C07E3.9
+F47F2.1	C07E3.9
+F53H8.2	C07E3.9
+F55C10.1	C07E3.9
+F59A6.1	C07E3.9
+F59D6.7	C07E3.9
+K08A8.1	C07E3.9
+R03G5.2	C07E3.9
+R07G3.1	C07E3.9
+R166.5	C07E3.9
+T01H8.1	C07E3.9
+T02C5.5	C07E3.9
+T14G10.2	C07E3.9
+T17E9.1	C07E3.9
+T28F12.3	C07E3.9
+T28F2.5	C07E3.9
+W06F12.1	C07E3.9
+Y17G9B.5	C07E3.9
+Y32F6B.3	C07E3.9
+Y39B6A.2	C07E3.9
+Y41D4B.13	C07E3.9
+Y54E10BL.6	C07E3.9
+Y66H1B.2	C07E3.9
+Y71H2AL.1	C07E3.9
+Y73B6A.5	C07E3.9
+ZK1067.1	C07E3.9
+ZK792.6	C07E3.9
+ZK856.8	C07E3.9
+ZK909.2	C07E3.9
+C12C8.1	C09B8.7
+C12D8.10	C09B8.7
+C14F5.5	C09B8.7
+C23F12.1	C09B8.7
+C37F5.1	C09B8.7
+C44H4.5	C09B8.7
+C48A7.1	C09B8.7
+C50C3.9	C09B8.7
+C54D2.5	C09B8.7
+C54G4.1	C09B8.7
+E01H11.1	C09B8.7
+F08B1.1	C09B8.7
+F11F1.1	C09B8.7
+F14H12.4	C09B8.7
+F17C8.4	C09B8.7
+F18G5.3	C09B8.7
+F25D1.1	C09B8.7
+F26D10.3	C09B8.7
+F28H6.1	C09B8.7
+F35C8.1	C09B8.7
+F42G10.2	C09B8.7
+F42G8.3	C09B8.7
+F43C1.2	C09B8.7
+F44E5.4	C09B8.7
+F44E5.5	C09B8.7
+F46G10.6	C09B8.7
+F47F2.1	C09B8.7
+F53H8.2	C09B8.7
+F55C10.1	C09B8.7
+F59A6.1	C09B8.7
+F59D6.7	C09B8.7
+K08A8.1	C09B8.7
+R03G5.2	C09B8.7
+R07G3.1	C09B8.7
+R166.5	C09B8.7
+T01H8.1	C09B8.7
+T02C5.5	C09B8.7
+T14G10.2	C09B8.7
+T17E9.1	C09B8.7
+T28F12.3	C09B8.7
+T28F2.5	C09B8.7
+W06F12.1	C09B8.7
+W07A8.2	C09B8.7
+Y17G9B.5	C09B8.7
+Y32F6B.3	C09B8.7
+Y39B6A.2	C09B8.7
+Y41D4B.13	C09B8.7
+Y54E10BL.6	C09B8.7
+Y66H1B.2	C09B8.7
+Y71H2AL.1	C09B8.7
+Y73B6A.5	C09B8.7
+ZK1067.1	C09B8.7
+ZK792.6	C09B8.7
+ZK856.8	C09B8.7
+ZK909.2	C09B8.7
+C12D8.10	C12C8.1
+C14F5.5	C12C8.1
+C23F12.1	C12C8.1
+C37F5.1	C12C8.1
+C44H4.5	C12C8.1
+C48A7.1	C12C8.1
+C50C3.9	C12C8.1
+C54D2.5	C12C8.1
+C54G4.1	C12C8.1
+E01H11.1	C12C8.1
+F08B1.1	C12C8.1
+F14H12.4	C12C8.1
+F17C8.4	C12C8.1
+F18G5.3	C12C8.1
+F25D1.1	C12C8.1
+F28H6.1	C12C8.1
+F35C8.1	C12C8.1
+F42G10.2	C12C8.1
+F42G8.3	C12C8.1
+F43C1.2	C12C8.1
+F46G10.6	C12C8.1
+F47F2.1	C12C8.1
+F53H8.2	C12C8.1
+F55C10.1	C12C8.1
+F59A6.1	C12C8.1
+F59D6.7	C12C8.1
+K08A8.1	C12C8.1
+R03G5.2	C12C8.1
+R07G3.1	C12C8.1
+R166.5	C12C8.1
+T01H8.1	C12C8.1
+T02C5.5	C12C8.1
+T14G10.2	C12C8.1
+T17E9.1	C12C8.1
+T28F12.3	C12C8.1
+T28F2.5	C12C8.1
+W06F12.1	C12C8.1
+W07A8.2	C12C8.1
+Y17G9B.5	C12C8.1
+Y32F6B.3	C12C8.1
+Y39B6A.2	C12C8.1
+Y41D4B.13	C12C8.1
+Y54E10BL.6	C12C8.1
+Y66H1B.2	C12C8.1
+Y71H2AL.1	C12C8.1
+Y73B6A.5	C12C8.1
+ZK1067.1	C12C8.1
+ZK792.6	C12C8.1
+ZK856.8	C12C8.1
+ZK909.2	C12C8.1
+C14F5.5	C12D8.10
+C23F12.1	C12D8.10
+C37F5.1	C12D8.10
+C44H4.5	C12D8.10
+C48A7.1	C12D8.10
+C50C3.9	C12D8.10
+C54D2.5	C12D8.10
+C54G4.1	C12D8.10
+E01H11.1	C12D8.10
+F08B1.1	C12D8.10
+F11F1.1	C12D8.10
+F14H12.4	C12D8.10
+F17C8.4	C12D8.10
+F18G5.3	C12D8.10
+F25D1.1	C12D8.10
+F26D10.3	C12D8.10
+F28H6.1	C12D8.10
+F35C8.1	C12D8.10
+F42G10.2	C12D8.10
+F42G8.3	C12D8.10
+F43C1.2	C12D8.10
+F44E5.4	C12D8.10
+F44E5.5	C12D8.10
+F46G10.6	C12D8.10
+F47F2.1	C12D8.10
+F53H8.2	C12D8.10
+F55C10.1	C12D8.10
+F59A6.1	C12D8.10
+F59D6.7	C12D8.10
+K08A8.1	C12D8.10
+R03G5.2	C12D8.10
+R07G3.1	C12D8.10
+R166.5	C12D8.10
+T01H8.1	C12D8.10
+T02C5.5	C12D8.10
+T14G10.2	C12D8.10
+T17E9.1	C12D8.10
+T28F12.3	C12D8.10
+T28F2.5	C12D8.10
+W06F12.1	C12D8.10
+W07A8.2	C12D8.10
+Y17G9B.5	C12D8.10
+Y32F6B.3	C12D8.10
+Y39B6A.2	C12D8.10
+Y41D4B.13	C12D8.10
+Y54E10BL.6	C12D8.10
+Y66H1B.2	C12D8.10
+Y71H2AL.1	C12D8.10
+Y73B6A.5	C12D8.10
+ZK1067.1	C12D8.10
+ZK792.6	C12D8.10
+ZK856.8	C12D8.10
+ZK909.2	C12D8.10
+C23F12.1	C14F5.5
+C37F5.1	C14F5.5
+C44H4.5	C14F5.5
+C48A7.1	C14F5.5
+C50C3.9	C14F5.5
+C54D2.5	C14F5.5
+C54G4.1	C14F5.5
+E01H11.1	C14F5.5
+F08B1.1	C14F5.5
+F11F1.1	C14F5.5
+F14H12.4	C14F5.5
+F17C8.4	C14F5.5
+F18G5.3	C14F5.5
+F25D1.1	C14F5.5
+F26D10.3	C14F5.5
+F28H6.1	C14F5.5
+F35C8.1	C14F5.5
+F42G10.2	C14F5.5
+F42G8.3	C14F5.5
+F43C1.2	C14F5.5
+F44E5.4	C14F5.5
+F44E5.5	C14F5.5
+F46G10.6	C14F5.5
+F47F2.1	C14F5.5
+F53H8.2	C14F5.5
+F55C10.1	C14F5.5
+F59A6.1	C14F5.5
+F59D6.7	C14F5.5
+K08A8.1	C14F5.5
+R03G5.2	C14F5.5
+R07G3.1	C14F5.5
+R166.5	C14F5.5
+T01H8.1	C14F5.5
+T02C5.5	C14F5.5
+T14G10.2	C14F5.5
+T17E9.1	C14F5.5
+T28F12.3	C14F5.5
+T28F2.5	C14F5.5
+W06F12.1	C14F5.5
+W07A8.2	C14F5.5
+Y17G9B.5	C14F5.5
+Y32F6B.3	C14F5.5
+Y39B6A.2	C14F5.5
+Y41D4B.13	C14F5.5
+Y54E10BL.6	C14F5.5
+Y66H1B.2	C14F5.5
+Y71H2AL.1	C14F5.5
+Y73B6A.5	C14F5.5
+ZK1067.1	C14F5.5
+ZK792.6	C14F5.5
+ZK856.8	C14F5.5
+ZK909.2	C14F5.5
+C37F5.1	C23F12.1
+C44H4.5	C23F12.1
+C48A7.1	C23F12.1
+C50C3.9	C23F12.1
+C54D2.5	C23F12.1
+C54G4.1	C23F12.1
+E01H11.1	C23F12.1
+F08B1.1	C23F12.1
+F11F1.1	C23F12.1
+F14H12.4	C23F12.1
+F17C8.4	C23F12.1
+F18G5.3	C23F12.1
+F25D1.1	C23F12.1
+F26D10.3	C23F12.1
+F28H6.1	C23F12.1
+F35C8.1	C23F12.1
+F42G10.2	C23F12.1
+F42G8.3	C23F12.1
+F43C1.2	C23F12.1
+F44E5.4	C23F12.1
+F44E5.5	C23F12.1
+F46G10.6	C23F12.1
+F47F2.1	C23F12.1
+F53H8.2	C23F12.1
+F55C10.1	C23F12.1
+F59A6.1	C23F12.1
+F59D6.7	C23F12.1
+K08A8.1	C23F12.1
+R03G5.2	C23F12.1
+R07G3.1	C23F12.1
+R166.5	C23F12.1
+T01H8.1	C23F12.1
+T02C5.5	C23F12.1
+T14G10.2	C23F12.1
+T17E9.1	C23F12.1
+T28F12.3	C23F12.1
+T28F2.5	C23F12.1
+W06F12.1	C23F12.1
+W07A8.2	C23F12.1
+Y17G9B.5	C23F12.1
+Y32F6B.3	C23F12.1
+Y39B6A.2	C23F12.1
+Y41D4B.13	C23F12.1
+Y54E10BL.6	C23F12.1
+Y66H1B.2	C23F12.1
+Y71H2AL.1	C23F12.1
+Y73B6A.5	C23F12.1
+ZK1067.1	C23F12.1
+ZK792.6	C23F12.1
+ZK856.8	C23F12.1
+ZK909.2	C23F12.1
+C44H4.5	C37F5.1
+C48A7.1	C37F5.1
+C50C3.9	C37F5.1
+C54D2.5	C37F5.1
+C54G4.1	C37F5.1
+E01H11.1	C37F5.1
+F08B1.1	C37F5.1
+F11F1.1	C37F5.1
+F14H12.4	C37F5.1
+F17C8.4	C37F5.1
+F18G5.3	C37F5.1
+F25D1.1	C37F5.1
+F26D10.3	C37F5.1
+F28H6.1	C37F5.1
+F35C8.1	C37F5.1
+F42G10.2	C37F5.1
+F42G8.3	C37F5.1
+F43C1.2	C37F5.1
+F44E5.4	C37F5.1
+F44E5.5	C37F5.1
+F46G10.6	C37F5.1
+F47F2.1	C37F5.1
+F53H8.2	C37F5.1
+F55C10.1	C37F5.1
+F59A6.1	C37F5.1
+F59D6.7	C37F5.1
+K08A8.1	C37F5.1
+R03G5.2	C37F5.1
+R07G3.1	C37F5.1
+R166.5	C37F5.1
+T01H8.1	C37F5.1
+T02C5.5	C37F5.1
+T14G10.2	C37F5.1
+T17E9.1	C37F5.1
+T28F12.3	C37F5.1
+T28F2.5	C37F5.1
+W06F12.1	C37F5.1
+W07A8.2	C37F5.1
+Y17G9B.5	C37F5.1
+Y32F6B.3	C37F5.1
+Y39B6A.2	C37F5.1
+Y41D4B.13	C37F5.1
+Y54E10BL.6	C37F5.1
+Y66H1B.2	C37F5.1
+Y71H2AL.1	C37F5.1
+Y73B6A.5	C37F5.1
+ZK1067.1	C37F5.1
+ZK792.6	C37F5.1
+ZK856.8	C37F5.1
+ZK909.2	C37F5.1
+C48A7.1	C44H4.5
+C50C3.9	C44H4.5
+C54D2.5	C44H4.5
+C54G4.1	C44H4.5
+E01H11.1	C44H4.5
+F08B1.1	C44H4.5
+F11F1.1	C44H4.5
+F14H12.4	C44H4.5
+F17C8.4	C44H4.5
+F18G5.3	C44H4.5
+F25D1.1	C44H4.5
+F26D10.3	C44H4.5
+F28H6.1	C44H4.5
+F35C8.1	C44H4.5
+F42G10.2	C44H4.5
+F42G8.3	C44H4.5
+F43C1.2	C44H4.5
+F44E5.4	C44H4.5
+F44E5.5	C44H4.5
+F46G10.6	C44H4.5
+F47F2.1	C44H4.5
+F53H8.2	C44H4.5
+F55C10.1	C44H4.5
+F59A6.1	C44H4.5
+F59D6.7	C44H4.5
+K08A8.1	C44H4.5
+R03G5.2	C44H4.5
+R07G3.1	C44H4.5
+R166.5	C44H4.5
+T01H8.1	C44H4.5
+T02C5.5	C44H4.5
+T14G10.2	C44H4.5
+T17E9.1	C44H4.5
+T28F12.3	C44H4.5
+T28F2.5	C44H4.5
+W06F12.1	C44H4.5
+W07A8.2	C44H4.5
+Y17G9B.5	C44H4.5
+Y32F6B.3	C44H4.5
+Y39B6A.2	C44H4.5
+Y41D4B.13	C44H4.5
+Y54E10BL.6	C44H4.5
+Y66H1B.2	C44H4.5
+Y71H2AL.1	C44H4.5
+Y73B6A.5	C44H4.5
+ZK1067.1	C44H4.5
+ZK792.6	C44H4.5
+ZK856.8	C44H4.5
+ZK909.2	C44H4.5
+C50C3.9	C48A7.1
+C54D2.5	C48A7.1
+C54G4.1	C48A7.1
+E01H11.1	C48A7.1
+F08B1.1	C48A7.1
+F11F1.1	C48A7.1
+F14H12.4	C48A7.1
+F17C8.4	C48A7.1
+F18G5.3	C48A7.1
+F25D1.1	C48A7.1
+F26D10.3	C48A7.1
+F28H6.1	C48A7.1
+F35C8.1	C48A7.1
+F42G10.2	C48A7.1
+F42G8.3	C48A7.1
+F43C1.2	C48A7.1
+F44E5.4	C48A7.1
+F44E5.5	C48A7.1
+F46G10.6	C48A7.1
+F47F2.1	C48A7.1
+F53H8.2	C48A7.1
+F55C10.1	C48A7.1
+F59A6.1	C48A7.1
+F59D6.7	C48A7.1
+K08A8.1	C48A7.1
+R03G5.2	C48A7.1
+R07G3.1	C48A7.1
+R166.5	C48A7.1
+T01H8.1	C48A7.1
+T02C5.5	C48A7.1
+T14G10.2	C48A7.1
+T17E9.1	C48A7.1
+T28F12.3	C48A7.1
+T28F2.5	C48A7.1
+W06F12.1	C48A7.1
+W07A8.2	C48A7.1
+Y17G9B.5	C48A7.1
+Y32F6B.3	C48A7.1
+Y39B6A.2	C48A7.1
+Y41D4B.13	C48A7.1
+Y54E10BL.6	C48A7.1
+Y66H1B.2	C48A7.1
+Y71H2AL.1	C48A7.1
+Y73B6A.5	C48A7.1
+ZK1067.1	C48A7.1
+ZK792.6	C48A7.1
+ZK856.8	C48A7.1
+ZK909.2	C48A7.1
+C54D2.5	C50C3.9
+C54G4.1	C50C3.9
+E01H11.1	C50C3.9
+F08B1.1	C50C3.9
+F11F1.1	C50C3.9
+F14H12.4	C50C3.9
+F17C8.4	C50C3.9
+F18G5.3	C50C3.9
+F25D1.1	C50C3.9
+F26D10.3	C50C3.9
+F28H6.1	C50C3.9
+F35C8.1	C50C3.9
+F42G10.2	C50C3.9
+F42G8.3	C50C3.9
+F43C1.2	C50C3.9
+F44E5.4	C50C3.9
+F44E5.5	C50C3.9
+F46G10.6	C50C3.9
+F47F2.1	C50C3.9
+F53H8.2	C50C3.9
+F55C10.1	C50C3.9
+F59A6.1	C50C3.9
+F59D6.7	C50C3.9
+K08A8.1	C50C3.9
+R03G5.2	C50C3.9
+R07G3.1	C50C3.9
+R166.5	C50C3.9
+T01H8.1	C50C3.9
+T02C5.5	C50C3.9
+T14G10.2	C50C3.9
+T17E9.1	C50C3.9
+T28F12.3	C50C3.9
+T28F2.5	C50C3.9
+W06F12.1	C50C3.9
+W07A8.2	C50C3.9
+Y17G9B.5	C50C3.9
+Y32F6B.3	C50C3.9
+Y39B6A.2	C50C3.9
+Y41D4B.13	C50C3.9
+Y54E10BL.6	C50C3.9
+Y66H1B.2	C50C3.9
+Y71H2AL.1	C50C3.9
+Y73B6A.5	C50C3.9
+ZK1067.1	C50C3.9
+ZK792.6	C50C3.9
+ZK856.8	C50C3.9
+ZK909.2	C50C3.9
+C54G4.1	C54D2.5
+E01H11.1	C54D2.5
+F08B1.1	C54D2.5
+F11F1.1	C54D2.5
+F14H12.4	C54D2.5
+F17C8.4	C54D2.5
+F18G5.3	C54D2.5
+F25D1.1	C54D2.5
+F26D10.3	C54D2.5
+F28H6.1	C54D2.5
+F35C8.1	C54D2.5
+F42G10.2	C54D2.5
+F42G8.3	C54D2.5
+F43C1.2	C54D2.5
+F44E5.4	C54D2.5
+F44E5.5	C54D2.5
+F46G10.6	C54D2.5
+F47F2.1	C54D2.5
+F53H8.2	C54D2.5
+F55C10.1	C54D2.5
+F59A6.1	C54D2.5
+F59D6.7	C54D2.5
+K08A8.1	C54D2.5
+R03G5.2	C54D2.5
+R07G3.1	C54D2.5
+R166.5	C54D2.5
+T01H8.1	C54D2.5
+T02C5.5	C54D2.5
+T14G10.2	C54D2.5
+T17E9.1	C54D2.5
+T28F12.3	C54D2.5
+T28F2.5	C54D2.5
+W06F12.1	C54D2.5
+W07A8.2	C54D2.5
+Y17G9B.5	C54D2.5
+Y32F6B.3	C54D2.5
+Y39B6A.2	C54D2.5
+Y41D4B.13	C54D2.5
+Y54E10BL.6	C54D2.5
+Y66H1B.2	C54D2.5
+Y71H2AL.1	C54D2.5
+Y73B6A.5	C54D2.5
+ZK1067.1	C54D2.5
+ZK792.6	C54D2.5
+ZK856.8	C54D2.5
+ZK909.2	C54D2.5
+E01H11.1	C54G4.1
+F08B1.1	C54G4.1
+F11F1.1	C54G4.1
+F14H12.4	C54G4.1
+F17C8.4	C54G4.1
+F18G5.3	C54G4.1
+F25D1.1	C54G4.1
+F26D10.3	C54G4.1
+F28H6.1	C54G4.1
+F35C8.1	C54G4.1
+F42G10.2	C54G4.1
+F42G8.3	C54G4.1
+F43C1.2	C54G4.1
+F44E5.4	C54G4.1
+F44E5.5	C54G4.1
+F46G10.6	C54G4.1
+F47F2.1	C54G4.1
+F53H8.2	C54G4.1
+F55C10.1	C54G4.1
+F59A6.1	C54G4.1
+F59D6.7	C54G4.1
+K08A8.1	C54G4.1
+R03G5.2	C54G4.1
+R07G3.1	C54G4.1
+R166.5	C54G4.1
+T01H8.1	C54G4.1
+T02C5.5	C54G4.1
+T14G10.2	C54G4.1
+T17E9.1	C54G4.1
+T28F12.3	C54G4.1
+T28F2.5	C54G4.1
+W06F12.1	C54G4.1
+W07A8.2	C54G4.1
+Y17G9B.5	C54G4.1
+Y32F6B.3	C54G4.1
+Y39B6A.2	C54G4.1
+Y41D4B.13	C54G4.1
+Y54E10BL.6	C54G4.1
+Y66H1B.2	C54G4.1
+Y71H2AL.1	C54G4.1
+Y73B6A.5	C54G4.1
+ZK1067.1	C54G4.1
+ZK792.6	C54G4.1
+ZK856.8	C54G4.1
+ZK909.2	C54G4.1
+F08B1.1	E01H11.1
+F11F1.1	E01H11.1
+F14H12.4	E01H11.1
+F17C8.4	E01H11.1
+F18G5.3	E01H11.1
+F25D1.1	E01H11.1
+F26D10.3	E01H11.1
+F28H6.1	E01H11.1
+F35C8.1	E01H11.1
+F42G10.2	E01H11.1
+F42G8.3	E01H11.1
+F43C1.2	E01H11.1
+F44E5.4	E01H11.1
+F44E5.5	E01H11.1
+F46G10.6	E01H11.1
+F47F2.1	E01H11.1
+F53H8.2	E01H11.1
+F55C10.1	E01H11.1
+F59A6.1	E01H11.1
+F59D6.7	E01H11.1
+K08A8.1	E01H11.1
+R03G5.2	E01H11.1
+R07G3.1	E01H11.1
+R166.5	E01H11.1
+T01H8.1	E01H11.1
+T02C5.5	E01H11.1
+T14G10.2	E01H11.1
+T17E9.1	E01H11.1
+T28F12.3	E01H11.1
+T28F2.5	E01H11.1
+W06F12.1	E01H11.1
+W07A8.2	E01H11.1
+Y17G9B.5	E01H11.1
+Y32F6B.3	E01H11.1
+Y39B6A.2	E01H11.1
+Y41D4B.13	E01H11.1
+Y54E10BL.6	E01H11.1
+Y66H1B.2	E01H11.1
+Y71H2AL.1	E01H11.1
+Y73B6A.5	E01H11.1
+ZK1067.1	E01H11.1
+ZK792.6	E01H11.1
+ZK856.8	E01H11.1
+ZK909.2	E01H11.1
+F11F1.1	F08B1.1
+F14H12.4	F08B1.1
+F17C8.4	F08B1.1
+F18G5.3	F08B1.1
+F25D1.1	F08B1.1
+F26D10.3	F08B1.1
+F28H6.1	F08B1.1
+F35C8.1	F08B1.1
+F42G10.2	F08B1.1
+F42G8.3	F08B1.1
+F43C1.2	F08B1.1
+F44E5.4	F08B1.1
+F44E5.5	F08B1.1
+F46G10.6	F08B1.1
+F47F2.1	F08B1.1
+F53H8.2	F08B1.1
+F55C10.1	F08B1.1
+F59A6.1	F08B1.1
+F59D6.7	F08B1.1
+K08A8.1	F08B1.1
+R03G5.2	F08B1.1
+R07G3.1	F08B1.1
+R166.5	F08B1.1
+T01H8.1	F08B1.1
+T02C5.5	F08B1.1
+T14G10.2	F08B1.1
+T17E9.1	F08B1.1
+T28F12.3	F08B1.1
+T28F2.5	F08B1.1
+W06F12.1	F08B1.1
+W07A8.2	F08B1.1
+Y17G9B.5	F08B1.1
+Y32F6B.3	F08B1.1
+Y39B6A.2	F08B1.1
+Y41D4B.13	F08B1.1
+Y54E10BL.6	F08B1.1
+Y66H1B.2	F08B1.1
+Y71H2AL.1	F08B1.1
+Y73B6A.5	F08B1.1
+ZK1067.1	F08B1.1
+ZK792.6	F08B1.1
+ZK856.8	F08B1.1
+ZK909.2	F08B1.1
+F14H12.4	F11F1.1
+F17C8.4	F11F1.1
+F18G5.3	F11F1.1
+F25D1.1	F11F1.1
+F28H6.1	F11F1.1
+F35C8.1	F11F1.1
+F42G10.2	F11F1.1
+F42G8.3	F11F1.1
+F43C1.2	F11F1.1
+F46G10.6	F11F1.1
+F47F2.1	F11F1.1
+F53H8.2	F11F1.1
+F55C10.1	F11F1.1
+F59A6.1	F11F1.1
+F59D6.7	F11F1.1
+K08A8.1	F11F1.1
+R03G5.2	F11F1.1
+R07G3.1	F11F1.1
+R166.5	F11F1.1
+T01H8.1	F11F1.1
+T02C5.5	F11F1.1
+T14G10.2	F11F1.1
+T17E9.1	F11F1.1
+T28F12.3	F11F1.1
+T28F2.5	F11F1.1
+W06F12.1	F11F1.1
+W07A8.2	F11F1.1
+Y17G9B.5	F11F1.1
+Y32F6B.3	F11F1.1
+Y39B6A.2	F11F1.1
+Y41D4B.13	F11F1.1
+Y54E10BL.6	F11F1.1
+Y66H1B.2	F11F1.1
+Y71H2AL.1	F11F1.1
+Y73B6A.5	F11F1.1
+ZK1067.1	F11F1.1
+ZK792.6	F11F1.1
+ZK856.8	F11F1.1
+ZK909.2	F11F1.1
+F17C8.4	F14H12.4
+F18G5.3	F14H12.4
+F25D1.1	F14H12.4
+F26D10.3	F14H12.4
+F28H6.1	F14H12.4
+F35C8.1	F14H12.4
+F42G10.2	F14H12.4
+F42G8.3	F14H12.4
+F43C1.2	F14H12.4
+F44E5.4	F14H12.4
+F44E5.5	F14H12.4
+F46G10.6	F14H12.4
+F47F2.1	F14H12.4
+F53H8.2	F14H12.4
+F55C10.1	F14H12.4
+F59A6.1	F14H12.4
+F59D6.7	F14H12.4
+K08A8.1	F14H12.4
+R03G5.2	F14H12.4
+R07G3.1	F14H12.4
+R166.5	F14H12.4
+T01H8.1	F14H12.4
+T02C5.5	F14H12.4
+T14G10.2	F14H12.4
+T17E9.1	F14H12.4
+T28F12.3	F14H12.4
+T28F2.5	F14H12.4
+W06F12.1	F14H12.4
+W07A8.2	F14H12.4
+Y17G9B.5	F14H12.4
+Y32F6B.3	F14H12.4
+Y39B6A.2	F14H12.4
+Y41D4B.13	F14H12.4
+Y54E10BL.6	F14H12.4
+Y66H1B.2	F14H12.4
+Y71H2AL.1	F14H12.4
+Y73B6A.5	F14H12.4
+ZK1067.1	F14H12.4
+ZK792.6	F14H12.4
+ZK856.8	F14H12.4
+ZK909.2	F14H12.4
+F18G5.3	F17C8.4
+F25D1.1	F17C8.4
+F26D10.3	F17C8.4
+F28H6.1	F17C8.4
+F35C8.1	F17C8.4
+F42G10.2	F17C8.4
+F42G8.3	F17C8.4
+F43C1.2	F17C8.4
+F44E5.4	F17C8.4
+F44E5.5	F17C8.4
+F46G10.6	F17C8.4
+F47F2.1	F17C8.4
+F53H8.2	F17C8.4
+F55C10.1	F17C8.4
+F59A6.1	F17C8.4
+F59D6.7	F17C8.4
+K08A8.1	F17C8.4
+R03G5.2	F17C8.4
+R07G3.1	F17C8.4
+R166.5	F17C8.4
+T01H8.1	F17C8.4
+T02C5.5	F17C8.4
+T14G10.2	F17C8.4
+T17E9.1	F17C8.4
+T28F12.3	F17C8.4
+T28F2.5	F17C8.4
+W06F12.1	F17C8.4
+W07A8.2	F17C8.4
+Y17G9B.5	F17C8.4
+Y32F6B.3	F17C8.4
+Y39B6A.2	F17C8.4
+Y41D4B.13	F17C8.4
+Y54E10BL.6	F17C8.4
+Y66H1B.2	F17C8.4
+Y71H2AL.1	F17C8.4
+Y73B6A.5	F17C8.4
+ZK1067.1	F17C8.4
+ZK792.6	F17C8.4
+ZK856.8	F17C8.4
+ZK909.2	F17C8.4
+F25D1.1	F18G5.3
+F26D10.3	F18G5.3
+F28H6.1	F18G5.3
+F35C8.1	F18G5.3
+F42G10.2	F18G5.3
+F42G8.3	F18G5.3
+F43C1.2	F18G5.3
+F44E5.4	F18G5.3
+F44E5.5	F18G5.3
+F46G10.6	F18G5.3
+F47F2.1	F18G5.3
+F53H8.2	F18G5.3
+F55C10.1	F18G5.3
+F59A6.1	F18G5.3
+F59D6.7	F18G5.3
+K08A8.1	F18G5.3
+R03G5.2	F18G5.3
+R166.5	F18G5.3
+T01H8.1	F18G5.3
+T02C5.5	F18G5.3
+T14G10.2	F18G5.3
+T17E9.1	F18G5.3
+T28F12.3	F18G5.3
+T28F2.5	F18G5.3
+W06F12.1	F18G5.3
+W07A8.2	F18G5.3
+Y17G9B.5	F18G5.3
+Y32F6B.3	F18G5.3
+Y39B6A.2	F18G5.3
+Y41D4B.13	F18G5.3
+Y54E10BL.6	F18G5.3
+Y66H1B.2	F18G5.3
+Y71H2AL.1	F18G5.3
+Y73B6A.5	F18G5.3
+ZK1067.1	F18G5.3
+ZK792.6	F18G5.3
+ZK856.8	F18G5.3
+ZK909.2	F18G5.3
+F26D10.3	F25D1.1
+F28H6.1	F25D1.1
+F35C8.1	F25D1.1
+F42G10.2	F25D1.1
+F42G8.3	F25D1.1
+F43C1.2	F25D1.1
+F44E5.4	F25D1.1
+F44E5.5	F25D1.1
+F46G10.6	F25D1.1
+F47F2.1	F25D1.1
+F53H8.2	F25D1.1
+F55C10.1	F25D1.1
+F59A6.1	F25D1.1
+F59D6.7	F25D1.1
+K08A8.1	F25D1.1
+R03G5.2	F25D1.1
+R07G3.1	F25D1.1
+R166.5	F25D1.1
+T01H8.1	F25D1.1
+T02C5.5	F25D1.1
+T14G10.2	F25D1.1
+T17E9.1	F25D1.1
+T28F12.3	F25D1.1
+T28F2.5	F25D1.1
+W06F12.1	F25D1.1
+W07A8.2	F25D1.1
+Y17G9B.5	F25D1.1
+Y32F6B.3	F25D1.1
+Y39B6A.2	F25D1.1
+Y41D4B.13	F25D1.1
+Y54E10BL.6	F25D1.1
+Y66H1B.2	F25D1.1
+Y71H2AL.1	F25D1.1
+Y73B6A.5	F25D1.1
+ZK1067.1	F25D1.1
+ZK792.6	F25D1.1
+ZK856.8	F25D1.1
+ZK909.2	F25D1.1
+F28H6.1	F26D10.3
+F35C8.1	F26D10.3
+F42G10.2	F26D10.3
+F42G8.3	F26D10.3
+F43C1.2	F26D10.3
+F46G10.6	F26D10.3
+F47F2.1	F26D10.3
+F53H8.2	F26D10.3
+F55C10.1	F26D10.3
+F59A6.1	F26D10.3
+F59D6.7	F26D10.3
+K08A8.1	F26D10.3
+R03G5.2	F26D10.3
+R07G3.1	F26D10.3
+R166.5	F26D10.3
+T01H8.1	F26D10.3
+T02C5.5	F26D10.3
+T14G10.2	F26D10.3
+T17E9.1	F26D10.3
+T28F12.3	F26D10.3
+T28F2.5	F26D10.3
+W06F12.1	F26D10.3
+W07A8.2	F26D10.3
+Y17G9B.5	F26D10.3
+Y32F6B.3	F26D10.3
+Y39B6A.2	F26D10.3
+Y41D4B.13	F26D10.3
+Y54E10BL.6	F26D10.3
+Y66H1B.2	F26D10.3
+Y71H2AL.1	F26D10.3
+Y73B6A.5	F26D10.3
+ZK1067.1	F26D10.3
+ZK792.6	F26D10.3
+ZK856.8	F26D10.3
+ZK909.2	F26D10.3
+F35C8.1	F28H6.1
+F42G10.2	F28H6.1
+F42G8.3	F28H6.1
+F43C1.2	F28H6.1
+F44E5.4	F28H6.1
+F44E5.5	F28H6.1
+F46G10.6	F28H6.1
+F47F2.1	F28H6.1
+F53H8.2	F28H6.1
+F55C10.1	F28H6.1
+F59A6.1	F28H6.1
+F59D6.7	F28H6.1
+K08A8.1	F28H6.1
+R03G5.2	F28H6.1
+R07G3.1	F28H6.1
+R166.5	F28H6.1
+T01H8.1	F28H6.1
+T02C5.5	F28H6.1
+T14G10.2	F28H6.1
+T17E9.1	F28H6.1
+T28F12.3	F28H6.1
+T28F2.5	F28H6.1
+W06F12.1	F28H6.1
+W07A8.2	F28H6.1
+Y17G9B.5	F28H6.1
+Y32F6B.3	F28H6.1
+Y39B6A.2	F28H6.1
+Y41D4B.13	F28H6.1
+Y54E10BL.6	F28H6.1
+Y66H1B.2	F28H6.1
+Y71H2AL.1	F28H6.1
+Y73B6A.5	F28H6.1
+ZK1067.1	F28H6.1
+ZK792.6	F28H6.1
+ZK856.8	F28H6.1
+ZK909.2	F28H6.1
+F42G10.2	F35C8.1
+F42G8.3	F35C8.1
+F43C1.2	F35C8.1
+F44E5.4	F35C8.1
+F44E5.5	F35C8.1
+F46G10.6	F35C8.1
+F47F2.1	F35C8.1
+F53H8.2	F35C8.1
+F55C10.1	F35C8.1
+F59A6.1	F35C8.1
+F59D6.7	F35C8.1
+K08A8.1	F35C8.1
+R03G5.2	F35C8.1
+R07G3.1	F35C8.1
+R166.5	F35C8.1
+T01H8.1	F35C8.1
+T02C5.5	F35C8.1
+T14G10.2	F35C8.1
+T17E9.1	F35C8.1
+T28F12.3	F35C8.1
+T28F2.5	F35C8.1
+W06F12.1	F35C8.1
+W07A8.2	F35C8.1
+Y17G9B.5	F35C8.1
+Y32F6B.3	F35C8.1
+Y39B6A.2	F35C8.1
+Y41D4B.13	F35C8.1
+Y54E10BL.6	F35C8.1
+Y66H1B.2	F35C8.1
+Y71H2AL.1	F35C8.1
+Y73B6A.5	F35C8.1
+ZK1067.1	F35C8.1
+ZK792.6	F35C8.1
+ZK856.8	F35C8.1
+ZK909.2	F35C8.1
+F42G8.3	F42G10.2
+F43C1.2	F42G10.2
+F44E5.4	F42G10.2
+F44E5.5	F42G10.2
+F46G10.6	F42G10.2
+F47F2.1	F42G10.2
+F53H8.2	F42G10.2
+F55C10.1	F42G10.2
+F59A6.1	F42G10.2
+F59D6.7	F42G10.2
+K08A8.1	F42G10.2
+R03G5.2	F42G10.2
+R07G3.1	F42G10.2
+R166.5	F42G10.2
+T01H8.1	F42G10.2
+T02C5.5	F42G10.2
+T14G10.2	F42G10.2
+T17E9.1	F42G10.2
+T28F12.3	F42G10.2
+T28F2.5	F42G10.2
+W06F12.1	F42G10.2
+W07A8.2	F42G10.2
+Y17G9B.5	F42G10.2
+Y32F6B.3	F42G10.2
+Y39B6A.2	F42G10.2
+Y41D4B.13	F42G10.2
+Y54E10BL.6	F42G10.2
+Y66H1B.2	F42G10.2
+Y71H2AL.1	F42G10.2
+Y73B6A.5	F42G10.2
+ZK1067.1	F42G10.2
+ZK792.6	F42G10.2
+ZK856.8	F42G10.2
+ZK909.2	F42G10.2
+F43C1.2	F42G8.3
+F44E5.4	F42G8.3
+F44E5.5	F42G8.3
+F46G10.6	F42G8.3
+F47F2.1	F42G8.3
+F53H8.2	F42G8.3
+F55C10.1	F42G8.3
+F59A6.1	F42G8.3
+F59D6.7	F42G8.3
+K08A8.1	F42G8.3
+R03G5.2	F42G8.3
+R07G3.1	F42G8.3
+R166.5	F42G8.3
+T01H8.1	F42G8.3
+T02C5.5	F42G8.3
+T14G10.2	F42G8.3
+T17E9.1	F42G8.3
+T28F12.3	F42G8.3
+T28F2.5	F42G8.3
+W06F12.1	F42G8.3
+W07A8.2	F42G8.3
+Y17G9B.5	F42G8.3
+Y32F6B.3	F42G8.3
+Y39B6A.2	F42G8.3
+Y41D4B.13	F42G8.3
+Y54E10BL.6	F42G8.3
+Y66H1B.2	F42G8.3
+Y71H2AL.1	F42G8.3
+Y73B6A.5	F42G8.3
+ZK1067.1	F42G8.3
+ZK792.6	F42G8.3
+ZK856.8	F42G8.3
+ZK909.2	F42G8.3
+F44E5.4	F43C1.2
+F44E5.5	F43C1.2
+F46G10.6	F43C1.2
+F47F2.1	F43C1.2
+F53H8.2	F43C1.2
+F55C10.1	F43C1.2
+F59A6.1	F43C1.2
+F59D6.7	F43C1.2
+K08A8.1	F43C1.2
+R03G5.2	F43C1.2
+R07G3.1	F43C1.2
+R166.5	F43C1.2
+T01H8.1	F43C1.2
+T02C5.5	F43C1.2
+T14G10.2	F43C1.2
+T17E9.1	F43C1.2
+T28F12.3	F43C1.2
+T28F2.5	F43C1.2
+W06F12.1	F43C1.2
+W07A8.2	F43C1.2
+Y17G9B.5	F43C1.2
+Y32F6B.3	F43C1.2
+Y39B6A.2	F43C1.2
+Y41D4B.13	F43C1.2
+Y54E10BL.6	F43C1.2
+Y66H1B.2	F43C1.2
+Y71H2AL.1	F43C1.2
+Y73B6A.5	F43C1.2
+ZK1067.1	F43C1.2
+ZK792.6	F43C1.2
+ZK856.8	F43C1.2
+ZK909.2	F43C1.2
+F46G10.6	F44E5.4
+F47F2.1	F44E5.4
+F53H8.2	F44E5.4
+F55C10.1	F44E5.4
+F59A6.1	F44E5.4
+F59D6.7	F44E5.4
+K08A8.1	F44E5.4
+R03G5.2	F44E5.4
+R07G3.1	F44E5.4
+R166.5	F44E5.4
+T01H8.1	F44E5.4
+T02C5.5	F44E5.4
+T14G10.2	F44E5.4
+T17E9.1	F44E5.4
+T28F12.3	F44E5.4
+T28F2.5	F44E5.4
+W06F12.1	F44E5.4
+W07A8.2	F44E5.4
+Y17G9B.5	F44E5.4
+Y32F6B.3	F44E5.4
+Y39B6A.2	F44E5.4
+Y41D4B.13	F44E5.4
+Y54E10BL.6	F44E5.4
+Y66H1B.2	F44E5.4
+Y71H2AL.1	F44E5.4
+Y73B6A.5	F44E5.4
+ZK1067.1	F44E5.4
+ZK792.6	F44E5.4
+ZK856.8	F44E5.4
+ZK909.2	F44E5.4
+F46G10.6	F44E5.5
+F47F2.1	F44E5.5
+F53H8.2	F44E5.5
+F55C10.1	F44E5.5
+F59A6.1	F44E5.5
+F59D6.7	F44E5.5
+K08A8.1	F44E5.5
+R03G5.2	F44E5.5
+R07G3.1	F44E5.5
+R166.5	F44E5.5
+T01H8.1	F44E5.5
+T02C5.5	F44E5.5
+T14G10.2	F44E5.5
+T17E9.1	F44E5.5
+T28F12.3	F44E5.5
+T28F2.5	F44E5.5
+W06F12.1	F44E5.5
+W07A8.2	F44E5.5
+Y17G9B.5	F44E5.5
+Y32F6B.3	F44E5.5
+Y39B6A.2	F44E5.5
+Y41D4B.13	F44E5.5
+Y54E10BL.6	F44E5.5
+Y66H1B.2	F44E5.5
+Y71H2AL.1	F44E5.5
+Y73B6A.5	F44E5.5
+ZK1067.1	F44E5.5
+ZK792.6	F44E5.5
+ZK856.8	F44E5.5
+ZK909.2	F44E5.5
+F47F2.1	F46G10.6
+F53H8.2	F46G10.6
+F55C10.1	F46G10.6
+F59A6.1	F46G10.6
+F59D6.7	F46G10.6
+K08A8.1	F46G10.6
+R03G5.2	F46G10.6
+R07G3.1	F46G10.6
+R166.5	F46G10.6
+T01H8.1	F46G10.6
+T02C5.5	F46G10.6
+T14G10.2	F46G10.6
+T17E9.1	F46G10.6
+T28F12.3	F46G10.6
+T28F2.5	F46G10.6
+W06F12.1	F46G10.6
+W07A8.2	F46G10.6
+Y17G9B.5	F46G10.6
+Y32F6B.3	F46G10.6
+Y39B6A.2	F46G10.6
+Y41D4B.13	F46G10.6
+Y54E10BL.6	F46G10.6
+Y66H1B.2	F46G10.6
+Y71H2AL.1	F46G10.6
+Y73B6A.5	F46G10.6
+ZK1067.1	F46G10.6
+ZK792.6	F46G10.6
+ZK856.8	F46G10.6
+ZK909.2	F46G10.6
+F53H8.2	F47F2.1
+F55C10.1	F47F2.1
+F59A6.1	F47F2.1
+F59D6.7	F47F2.1
+K08A8.1	F47F2.1
+R03G5.2	F47F2.1
+R07G3.1	F47F2.1
+R166.5	F47F2.1
+T01H8.1	F47F2.1
+T02C5.5	F47F2.1
+T14G10.2	F47F2.1
+T17E9.1	F47F2.1
+T28F12.3	F47F2.1
+T28F2.5	F47F2.1
+W06F12.1	F47F2.1
+W07A8.2	F47F2.1
+Y17G9B.5	F47F2.1
+Y32F6B.3	F47F2.1
+Y39B6A.2	F47F2.1
+Y41D4B.13	F47F2.1
+Y54E10BL.6	F47F2.1
+Y66H1B.2	F47F2.1
+Y71H2AL.1	F47F2.1
+Y73B6A.5	F47F2.1
+ZK1067.1	F47F2.1
+ZK792.6	F47F2.1
+ZK856.8	F47F2.1
+ZK909.2	F47F2.1
+F55C10.1	F53H8.2
+F59A6.1	F53H8.2
+F59D6.7	F53H8.2
+K08A8.1	F53H8.2
+R03G5.2	F53H8.2
+R07G3.1	F53H8.2
+R166.5	F53H8.2
+T01H8.1	F53H8.2
+T02C5.5	F53H8.2
+T14G10.2	F53H8.2
+T17E9.1	F53H8.2
+T28F12.3	F53H8.2
+T28F2.5	F53H8.2
+W06F12.1	F53H8.2
+W07A8.2	F53H8.2
+Y17G9B.5	F53H8.2
+Y32F6B.3	F53H8.2
+Y39B6A.2	F53H8.2
+Y41D4B.13	F53H8.2
+Y54E10BL.6	F53H8.2
+Y66H1B.2	F53H8.2
+Y71H2AL.1	F53H8.2
+Y73B6A.5	F53H8.2
+ZK1067.1	F53H8.2
+ZK792.6	F53H8.2
+ZK856.8	F53H8.2
+ZK909.2	F53H8.2
+F59A6.1	F55C10.1
+F59D6.7	F55C10.1
+K08A8.1	F55C10.1
+R03G5.2	F55C10.1
+R07G3.1	F55C10.1
+R166.5	F55C10.1
+T01H8.1	F55C10.1
+T02C5.5	F55C10.1
+T14G10.2	F55C10.1
+T17E9.1	F55C10.1
+T28F12.3	F55C10.1
+T28F2.5	F55C10.1
+W06F12.1	F55C10.1
+W07A8.2	F55C10.1
+Y17G9B.5	F55C10.1
+Y32F6B.3	F55C10.1
+Y39B6A.2	F55C10.1
+Y41D4B.13	F55C10.1
+Y54E10BL.6	F55C10.1
+Y66H1B.2	F55C10.1
+Y71H2AL.1	F55C10.1
+Y73B6A.5	F55C10.1
+ZK1067.1	F55C10.1
+ZK792.6	F55C10.1
+ZK856.8	F55C10.1
+ZK909.2	F55C10.1
+F59D6.7	F59A6.1
+K08A8.1	F59A6.1
+R03G5.2	F59A6.1
+R07G3.1	F59A6.1
+R166.5	F59A6.1
+T01H8.1	F59A6.1
+T02C5.5	F59A6.1
+T14G10.2	F59A6.1
+T17E9.1	F59A6.1
+T28F12.3	F59A6.1
+T28F2.5	F59A6.1
+W06F12.1	F59A6.1
+W07A8.2	F59A6.1
+Y17G9B.5	F59A6.1
+Y32F6B.3	F59A6.1
+Y39B6A.2	F59A6.1
+Y41D4B.13	F59A6.1
+Y54E10BL.6	F59A6.1
+Y66H1B.2	F59A6.1
+Y71H2AL.1	F59A6.1
+Y73B6A.5	F59A6.1
+ZK1067.1	F59A6.1
+ZK792.6	F59A6.1
+ZK856.8	F59A6.1
+ZK909.2	F59A6.1
+K08A8.1	F59D6.7
+R03G5.2	F59D6.7
+R07G3.1	F59D6.7
+R166.5	F59D6.7
+T01H8.1	F59D6.7
+T02C5.5	F59D6.7
+T14G10.2	F59D6.7
+T17E9.1	F59D6.7
+T28F12.3	F59D6.7
+T28F2.5	F59D6.7
+W06F12.1	F59D6.7
+W07A8.2	F59D6.7
+Y17G9B.5	F59D6.7
+Y32F6B.3	F59D6.7
+Y39B6A.2	F59D6.7
+Y41D4B.13	F59D6.7
+Y54E10BL.6	F59D6.7
+Y66H1B.2	F59D6.7
+Y71H2AL.1	F59D6.7
+Y73B6A.5	F59D6.7
+ZK1067.1	F59D6.7
+ZK792.6	F59D6.7
+ZK856.8	F59D6.7
+ZK909.2	F59D6.7
+R03G5.2	K08A8.1
+R07G3.1	K08A8.1
+R166.5	K08A8.1
+T01H8.1	K08A8.1
+T02C5.5	K08A8.1
+T14G10.2	K08A8.1
+T17E9.1	K08A8.1
+T28F12.3	K08A8.1
+T28F2.5	K08A8.1
+W06F12.1	K08A8.1
+W07A8.2	K08A8.1
+Y17G9B.5	K08A8.1
+Y32F6B.3	K08A8.1
+Y39B6A.2	K08A8.1
+Y41D4B.13	K08A8.1
+Y54E10BL.6	K08A8.1
+Y66H1B.2	K08A8.1
+Y71H2AL.1	K08A8.1
+Y73B6A.5	K08A8.1
+ZK1067.1	K08A8.1
+ZK792.6	K08A8.1
+ZK856.8	K08A8.1
+ZK909.2	K08A8.1
+R07G3.1	R03G5.2
+R166.5	R03G5.2
+T01H8.1	R03G5.2
+T02C5.5	R03G5.2
+T14G10.2	R03G5.2
+T17E9.1	R03G5.2
+T28F12.3	R03G5.2
+T28F2.5	R03G5.2
+W06F12.1	R03G5.2
+W07A8.2	R03G5.2
+Y17G9B.5	R03G5.2
+Y32F6B.3	R03G5.2
+Y39B6A.2	R03G5.2
+Y41D4B.13	R03G5.2
+Y54E10BL.6	R03G5.2
+Y66H1B.2	R03G5.2
+Y71H2AL.1	R03G5.2
+Y73B6A.5	R03G5.2
+ZK1067.1	R03G5.2
+ZK792.6	R03G5.2
+ZK856.8	R03G5.2
+ZK909.2	R03G5.2
+R166.5	R07G3.1
+T01H8.1	R07G3.1
+T02C5.5	R07G3.1
+T14G10.2	R07G3.1
+T17E9.1	R07G3.1
+T28F12.3	R07G3.1
+T28F2.5	R07G3.1
+W06F12.1	R07G3.1
+W07A8.2	R07G3.1
+Y17G9B.5	R07G3.1
+Y32F6B.3	R07G3.1
+Y39B6A.2	R07G3.1
+Y41D4B.13	R07G3.1
+Y54E10BL.6	R07G3.1
+Y66H1B.2	R07G3.1
+Y71H2AL.1	R07G3.1
+Y73B6A.5	R07G3.1
+ZK1067.1	R07G3.1
+ZK792.6	R07G3.1
+ZK856.8	R07G3.1
+ZK909.2	R07G3.1
+T01H8.1	R166.5
+T02C5.5	R166.5
+T14G10.2	R166.5
+T17E9.1	R166.5
+T28F12.3	R166.5
+T28F2.5	R166.5
+W06F12.1	R166.5
+W07A8.2	R166.5
+Y17G9B.5	R166.5
+Y32F6B.3	R166.5
+Y39B6A.2	R166.5
+Y41D4B.13	R166.5
+Y54E10BL.6	R166.5
+Y66H1B.2	R166.5
+Y71H2AL.1	R166.5
+Y73B6A.5	R166.5
+ZK1067.1	R166.5
+ZK792.6	R166.5
+ZK856.8	R166.5
+ZK909.2	R166.5
+T02C5.5	T01H8.1
+T14G10.2	T01H8.1
+T17E9.1	T01H8.1
+T28F12.3	T01H8.1
+T28F2.5	T01H8.1
+W06F12.1	T01H8.1
+W07A8.2	T01H8.1
+Y17G9B.5	T01H8.1
+Y32F6B.3	T01H8.1
+Y39B6A.2	T01H8.1
+Y41D4B.13	T01H8.1
+Y54E10BL.6	T01H8.1
+Y66H1B.2	T01H8.1
+Y71H2AL.1	T01H8.1
+Y73B6A.5	T01H8.1
+ZK1067.1	T01H8.1
+ZK792.6	T01H8.1
+ZK856.8	T01H8.1
+ZK909.2	T01H8.1
+T14G10.2	T02C5.5
+T17E9.1	T02C5.5
+T28F12.3	T02C5.5
+T28F2.5	T02C5.5
+W06F12.1	T02C5.5
+W07A8.2	T02C5.5
+Y17G9B.5	T02C5.5
+Y32F6B.3	T02C5.5
+Y39B6A.2	T02C5.5
+Y41D4B.13	T02C5.5
+Y54E10BL.6	T02C5.5
+Y66H1B.2	T02C5.5
+Y71H2AL.1	T02C5.5
+Y73B6A.5	T02C5.5
+ZK1067.1	T02C5.5
+ZK792.6	T02C5.5
+ZK856.8	T02C5.5
+ZK909.2	T02C5.5
+T17E9.1	T14G10.2
+T28F12.3	T14G10.2
+T28F2.5	T14G10.2
+W06F12.1	T14G10.2
+W07A8.2	T14G10.2
+Y17G9B.5	T14G10.2
+Y32F6B.3	T14G10.2
+Y39B6A.2	T14G10.2
+Y41D4B.13	T14G10.2
+Y54E10BL.6	T14G10.2
+Y66H1B.2	T14G10.2
+Y71H2AL.1	T14G10.2
+Y73B6A.5	T14G10.2
+ZK1067.1	T14G10.2
+ZK792.6	T14G10.2
+ZK856.8	T14G10.2
+ZK909.2	T14G10.2
+T28F12.3	T17E9.1
+T28F2.5	T17E9.1
+W06F12.1	T17E9.1
+W07A8.2	T17E9.1
+Y17G9B.5	T17E9.1
+Y32F6B.3	T17E9.1
+Y39B6A.2	T17E9.1
+Y41D4B.13	T17E9.1
+Y54E10BL.6	T17E9.1
+Y66H1B.2	T17E9.1
+Y71H2AL.1	T17E9.1
+Y73B6A.5	T17E9.1
+ZK1067.1	T17E9.1
+ZK792.6	T17E9.1
+ZK856.8	T17E9.1
+ZK909.2	T17E9.1
+T28F2.5	T28F12.3
+W06F12.1	T28F12.3
+W07A8.2	T28F12.3
+Y17G9B.5	T28F12.3
+Y32F6B.3	T28F12.3
+Y39B6A.2	T28F12.3
+Y41D4B.13	T28F12.3
+Y54E10BL.6	T28F12.3
+Y66H1B.2	T28F12.3
+Y71H2AL.1	T28F12.3
+Y73B6A.5	T28F12.3
+ZK1067.1	T28F12.3
+ZK792.6	T28F12.3
+ZK856.8	T28F12.3
+ZK909.2	T28F12.3
+W06F12.1	T28F2.5
+W07A8.2	T28F2.5
+Y17G9B.5	T28F2.5
+Y32F6B.3	T28F2.5
+Y39B6A.2	T28F2.5
+Y41D4B.13	T28F2.5
+Y54E10BL.6	T28F2.5
+Y66H1B.2	T28F2.5
+Y71H2AL.1	T28F2.5
+Y73B6A.5	T28F2.5
+ZK1067.1	T28F2.5
+ZK792.6	T28F2.5
+ZK856.8	T28F2.5
+ZK909.2	T28F2.5
+W07A8.2	W06F12.1
+Y17G9B.5	W06F12.1
+Y32F6B.3	W06F12.1
+Y39B6A.2	W06F12.1
+Y41D4B.13	W06F12.1
+Y54E10BL.6	W06F12.1
+Y66H1B.2	W06F12.1
+Y71H2AL.1	W06F12.1
+Y73B6A.5	W06F12.1
+ZK1067.1	W06F12.1
+ZK792.6	W06F12.1
+ZK856.8	W06F12.1
+ZK909.2	W06F12.1
+Y17G9B.5	W07A8.2
+Y32F6B.3	W07A8.2
+Y39B6A.2	W07A8.2
+Y41D4B.13	W07A8.2
+Y54E10BL.6	W07A8.2
+Y66H1B.2	W07A8.2
+Y71H2AL.1	W07A8.2
+Y73B6A.5	W07A8.2
+ZK1067.1	W07A8.2
+ZK792.6	W07A8.2
+ZK856.8	W07A8.2
+ZK909.2	W07A8.2
+Y32F6B.3	Y17G9B.5
+Y39B6A.2	Y17G9B.5
+Y41D4B.13	Y17G9B.5
+Y54E10BL.6	Y17G9B.5
+Y66H1B.2	Y17G9B.5
+Y71H2AL.1	Y17G9B.5
+Y73B6A.5	Y17G9B.5
+ZK1067.1	Y17G9B.5
+ZK792.6	Y17G9B.5
+ZK856.8	Y17G9B.5
+ZK909.2	Y17G9B.5
+Y39B6A.2	Y32F6B.3
+Y41D4B.13	Y32F6B.3
+Y54E10BL.6	Y32F6B.3
+Y66H1B.2	Y32F6B.3
+Y71H2AL.1	Y32F6B.3
+Y73B6A.5	Y32F6B.3
+ZK1067.1	Y32F6B.3
+ZK792.6	Y32F6B.3
+ZK856.8	Y32F6B.3
+ZK909.2	Y32F6B.3
+Y41D4B.13	Y39B6A.2
+Y54E10BL.6	Y39B6A.2
+Y66H1B.2	Y39B6A.2
+Y71H2AL.1	Y39B6A.2
+Y73B6A.5	Y39B6A.2
+ZK1067.1	Y39B6A.2
+ZK792.6	Y39B6A.2
+ZK856.8	Y39B6A.2
+ZK909.2	Y39B6A.2
+Y54E10BL.6	Y41D4B.13
+Y66H1B.2	Y41D4B.13
+Y71H2AL.1	Y41D4B.13
+Y73B6A.5	Y41D4B.13
+ZK1067.1	Y41D4B.13
+ZK792.6	Y41D4B.13
+ZK856.8	Y41D4B.13
+ZK909.2	Y41D4B.13
+Y66H1B.2	Y54E10BL.6
+Y71H2AL.1	Y54E10BL.6
+Y73B6A.5	Y54E10BL.6
+ZK1067.1	Y54E10BL.6
+ZK792.6	Y54E10BL.6
+ZK856.8	Y54E10BL.6
+ZK909.2	Y54E10BL.6
+Y71H2AL.1	Y66H1B.2
+Y73B6A.5	Y66H1B.2
+ZK1067.1	Y66H1B.2
+ZK792.6	Y66H1B.2
+ZK856.8	Y66H1B.2
+ZK909.2	Y66H1B.2
+Y73B6A.5	Y71H2AL.1
+ZK1067.1	Y71H2AL.1
+ZK792.6	Y71H2AL.1
+ZK856.8	Y71H2AL.1
+ZK909.2	Y71H2AL.1
+ZK1067.1	Y73B6A.5
+ZK792.6	Y73B6A.5
+ZK856.8	Y73B6A.5
+ZK909.2	Y73B6A.5
+ZK792.6	ZK1067.1
+ZK856.8	ZK1067.1
+ZK909.2	ZK1067.1
+ZK856.8	ZK792.6
+ZK909.2	ZK792.6
+ZK909.2	ZK856.8
+B0334.8	B0261.2
+B0478.1	B0261.2
+C09B8.7	B0261.2
+C12D8.10	B0261.2
+C14F5.5	B0261.2
+C30F8.4	B0261.2
+C37F5.1	B0261.2
+C44H4.6	B0261.2
+E01H11.1	B0261.2
+F28H6.1	B0261.2
+F42G10.2	B0261.2
+F43C1.2	B0261.2
+K08A8.1	B0261.2
+K11E8.1	B0261.2
+M02A10.3	B0261.2
+M79.1	B0261.2
+R04A9.7	B0261.2
+T01E8.3	B0261.2
+T28F12.3	B0261.2
+Y110A7A.10	B0261.2
+Y18D10A.5	B0261.2
+Y41D4B.13	B0261.2
+Y47D3A.16	B0261.2
+Y51H4A.17	B0261.2
+Y54E10BL.6	B0261.2
+Y73B6A.5	B0261.2
+ZK1067.1	B0261.2
+ZK470.5	B0261.2
+ZK792.6	B0261.2
+B0478.1	B0334.8
+C09B8.7	B0334.8
+C12D8.10	B0334.8
+C14F5.5	B0334.8
+C30F8.4	B0334.8
+C37F5.1	B0334.8
+C44H4.6	B0334.8
+E01H11.1	B0334.8
+F28H6.1	B0334.8
+F42G10.2	B0334.8
+F43C1.2	B0334.8
+K08A8.1	B0334.8
+K11E8.1	B0334.8
+M02A10.3	B0334.8
+M79.1	B0334.8
+R04A9.7	B0334.8
+T28F12.3	B0334.8
+Y110A7A.10	B0334.8
+Y18D10A.5	B0334.8
+Y41D4B.13	B0334.8
+Y47D3A.16	B0334.8
+Y51H4A.17	B0334.8
+Y54E10BL.6	B0334.8
+Y73B6A.5	B0334.8
+ZK1067.1	B0334.8
+ZK470.5	B0334.8
+ZK792.6	B0334.8
+C30F8.4	B0478.1
+C44H4.6	B0478.1
+K11E8.1	B0478.1
+M02A10.3	B0478.1
+M79.1	B0478.1
+R04A9.7	B0478.1
+T01E8.3	B0478.1
+Y110A7A.10	B0478.1
+Y18D10A.5	B0478.1
+Y47D3A.16	B0478.1
+Y51H4A.17	B0478.1
+ZK470.5	B0478.1
+C30F8.4	C09B8.7
+C44H4.6	C09B8.7
+K11E8.1	C09B8.7
+M02A10.3	C09B8.7
+M79.1	C09B8.7
+R04A9.7	C09B8.7
+T01E8.3	C09B8.7
+Y110A7A.10	C09B8.7
+Y18D10A.5	C09B8.7
+Y47D3A.16	C09B8.7
+Y51H4A.17	C09B8.7
+ZK470.5	C09B8.7
+C30F8.4	C12D8.10
+C44H4.6	C12D8.10
+K11E8.1	C12D8.10
+M02A10.3	C12D8.10
+M79.1	C12D8.10
+R04A9.7	C12D8.10
+T01E8.3	C12D8.10
+Y110A7A.10	C12D8.10
+Y18D10A.5	C12D8.10
+Y47D3A.16	C12D8.10
+Y51H4A.17	C12D8.10
+ZK470.5	C12D8.10
+C30F8.4	C14F5.5
+C44H4.6	C14F5.5
+K11E8.1	C14F5.5
+M02A10.3	C14F5.5
+M79.1	C14F5.5
+R04A9.7	C14F5.5
+T01E8.3	C14F5.5
+Y110A7A.10	C14F5.5
+Y18D10A.5	C14F5.5
+Y47D3A.16	C14F5.5
+Y51H4A.17	C14F5.5
+ZK470.5	C14F5.5
+C37F5.1	C30F8.4
+C44H4.6	C30F8.4
+E01H11.1	C30F8.4
+F28H6.1	C30F8.4
+F42G10.2	C30F8.4
+F43C1.2	C30F8.4
+K08A8.1	C30F8.4
+K11E8.1	C30F8.4
+M02A10.3	C30F8.4
+M79.1	C30F8.4
+R04A9.7	C30F8.4
+T01E8.3	C30F8.4
+T28F12.3	C30F8.4
+Y110A7A.10	C30F8.4
+Y18D10A.5	C30F8.4
+Y41D4B.13	C30F8.4
+Y47D3A.16	C30F8.4
+Y51H4A.17	C30F8.4
+Y54E10BL.6	C30F8.4
+Y73B6A.5	C30F8.4
+ZK1067.1	C30F8.4
+ZK470.5	C30F8.4
+ZK792.6	C30F8.4
+C44H4.6	C37F5.1
+K11E8.1	C37F5.1
+M02A10.3	C37F5.1
+M79.1	C37F5.1
+R04A9.7	C37F5.1
+T01E8.3	C37F5.1
+Y110A7A.10	C37F5.1
+Y18D10A.5	C37F5.1
+Y47D3A.16	C37F5.1
+Y51H4A.17	C37F5.1
+ZK470.5	C37F5.1
+E01H11.1	C44H4.6
+F28H6.1	C44H4.6
+F42G10.2	C44H4.6
+F43C1.2	C44H4.6
+K08A8.1	C44H4.6
+K11E8.1	C44H4.6
+M02A10.3	C44H4.6
+M79.1	C44H4.6
+R04A9.7	C44H4.6
+T01E8.3	C44H4.6
+T28F12.3	C44H4.6
+Y110A7A.10	C44H4.6
+Y18D10A.5	C44H4.6
+Y41D4B.13	C44H4.6
+Y47D3A.16	C44H4.6
+Y51H4A.17	C44H4.6
+Y54E10BL.6	C44H4.6
+Y73B6A.5	C44H4.6
+ZK1067.1	C44H4.6
+ZK470.5	C44H4.6
+ZK792.6	C44H4.6
+K11E8.1	E01H11.1
+M02A10.3	E01H11.1
+M79.1	E01H11.1
+R04A9.7	E01H11.1
+T01E8.3	E01H11.1
+Y110A7A.10	E01H11.1
+Y18D10A.5	E01H11.1
+Y47D3A.16	E01H11.1
+Y51H4A.17	E01H11.1
+ZK470.5	E01H11.1
+K11E8.1	F28H6.1
+M02A10.3	F28H6.1
+M79.1	F28H6.1
+R04A9.7	F28H6.1
+T01E8.3	F28H6.1
+Y110A7A.10	F28H6.1
+Y18D10A.5	F28H6.1
+Y47D3A.16	F28H6.1
+Y51H4A.17	F28H6.1
+ZK470.5	F28H6.1
+K11E8.1	F42G10.2
+M02A10.3	F42G10.2
+M79.1	F42G10.2
+R04A9.7	F42G10.2
+T01E8.3	F42G10.2
+Y110A7A.10	F42G10.2
+Y18D10A.5	F42G10.2
+Y47D3A.16	F42G10.2
+Y51H4A.17	F42G10.2
+ZK470.5	F42G10.2
+K11E8.1	F43C1.2
+M02A10.3	F43C1.2
+M79.1	F43C1.2
+R04A9.7	F43C1.2
+T01E8.3	F43C1.2
+Y110A7A.10	F43C1.2
+Y18D10A.5	F43C1.2
+Y47D3A.16	F43C1.2
+Y51H4A.17	F43C1.2
+ZK470.5	F43C1.2
+K11E8.1	K08A8.1
+M02A10.3	K08A8.1
+M79.1	K08A8.1
+R04A9.7	K08A8.1
+T01E8.3	K08A8.1
+Y110A7A.10	K08A8.1
+Y18D10A.5	K08A8.1
+Y47D3A.16	K08A8.1
+Y51H4A.17	K08A8.1
+ZK470.5	K08A8.1
+M02A10.3	K11E8.1
+M79.1	K11E8.1
+R04A9.7	K11E8.1
+T01E8.3	K11E8.1
+T28F12.3	K11E8.1
+Y110A7A.10	K11E8.1
+Y18D10A.5	K11E8.1
+Y41D4B.13	K11E8.1
+Y47D3A.16	K11E8.1
+Y51H4A.17	K11E8.1
+Y54E10BL.6	K11E8.1
+Y73B6A.5	K11E8.1
+ZK1067.1	K11E8.1
+ZK470.5	K11E8.1
+ZK792.6	K11E8.1
+M79.1	M02A10.3
+R04A9.7	M02A10.3
+T01E8.3	M02A10.3
+T28F12.3	M02A10.3
+Y110A7A.10	M02A10.3
+Y18D10A.5	M02A10.3
+Y41D4B.13	M02A10.3
+Y47D3A.16	M02A10.3
+Y51H4A.17	M02A10.3
+Y54E10BL.6	M02A10.3
+Y73B6A.5	M02A10.3
+ZK1067.1	M02A10.3
+ZK470.5	M02A10.3
+ZK792.6	M02A10.3
+R04A9.7	M79.1
+T01E8.3	M79.1
+T28F12.3	M79.1
+Y110A7A.10	M79.1
+Y18D10A.5	M79.1
+Y41D4B.13	M79.1
+Y47D3A.16	M79.1
+Y51H4A.17	M79.1
+Y54E10BL.6	M79.1
+Y73B6A.5	M79.1
+ZK1067.1	M79.1
+ZK470.5	M79.1
+ZK792.6	M79.1
+T01E8.3	R04A9.7
+T28F12.3	R04A9.7
+Y110A7A.10	R04A9.7
+Y18D10A.5	R04A9.7
+Y41D4B.13	R04A9.7
+Y47D3A.16	R04A9.7
+Y51H4A.17	R04A9.7
+Y54E10BL.6	R04A9.7
+Y73B6A.5	R04A9.7
+ZK1067.1	R04A9.7
+ZK470.5	R04A9.7
+ZK792.6	R04A9.7
+T28F12.3	T01E8.3
+Y110A7A.10	T01E8.3
+Y18D10A.5	T01E8.3
+Y41D4B.13	T01E8.3
+Y47D3A.16	T01E8.3
+Y51H4A.17	T01E8.3
+Y54E10BL.6	T01E8.3
+Y73B6A.5	T01E8.3
+ZK1067.1	T01E8.3
+ZK470.5	T01E8.3
+ZK792.6	T01E8.3
+Y110A7A.10	T28F12.3
+Y18D10A.5	T28F12.3
+Y47D3A.16	T28F12.3
+Y51H4A.17	T28F12.3
+ZK470.5	T28F12.3
+Y18D10A.5	Y110A7A.10
+Y41D4B.13	Y110A7A.10
+Y47D3A.16	Y110A7A.10
+Y51H4A.17	Y110A7A.10
+Y54E10BL.6	Y110A7A.10
+Y73B6A.5	Y110A7A.10
+ZK1067.1	Y110A7A.10
+ZK470.5	Y110A7A.10
+ZK792.6	Y110A7A.10
+Y41D4B.13	Y18D10A.5
+Y47D3A.16	Y18D10A.5
+Y51H4A.17	Y18D10A.5
+Y54E10BL.6	Y18D10A.5
+Y73B6A.5	Y18D10A.5
+ZK1067.1	Y18D10A.5
+ZK470.5	Y18D10A.5
+ZK792.6	Y18D10A.5
+Y47D3A.16	Y41D4B.13
+Y51H4A.17	Y41D4B.13
+ZK470.5	Y41D4B.13
+Y51H4A.17	Y47D3A.16
+Y54E10BL.6	Y47D3A.16
+Y73B6A.5	Y47D3A.16
+ZK1067.1	Y47D3A.16
+ZK470.5	Y47D3A.16
+ZK792.6	Y47D3A.16
+Y54E10BL.6	Y51H4A.17
+Y73B6A.5	Y51H4A.17
+ZK1067.1	Y51H4A.17
+ZK470.5	Y51H4A.17
+ZK792.6	Y51H4A.17
+ZK470.5	Y54E10BL.6
+ZK470.5	Y73B6A.5
+ZK470.5	ZK1067.1
+ZK792.6	ZK470.5
+C02F4.2	B0348.4
+C09B7.1	B0348.4
+C14B9.8	B0348.4
+C18E9.1	B0348.4
+C30F12.6	B0348.4
+C47E12.2	B0348.4
+E01H11.1	B0348.4
+F07F6.6	B0348.4
+F17C8.1	B0348.4
+F25B4.7	B0348.4
+F33D4.2	B0348.4
+F45H11.4	B0348.4
+F47F2.1	B0348.4
+F55C10.1	B0348.4
+F59C12.2	B0348.4
+F59D6.7	B0348.4
+K01H12.2	B0348.4
+K03A1.4	B0348.4
+K11C4.5	B0348.4
+K11D9.2	B0348.4
+K11E8.1	B0348.4
+M01D7.7	B0348.4
+R05G6.7	B0348.4
+R06A10.2	B0348.4
+T01B11.4	B0348.4
+T04D3.3	B0348.4
+T07G12.1	B0348.4
+T21H3.3	B0348.4
+T27E9.1	B0348.4
+W02D3.6	B0348.4
+Y113G7A.4	B0348.4
+Y40H4A.1	B0348.4
+Y67D8A.1	B0348.4
+Y67D8C.10	B0348.4
+Y71H2AL.1	B0348.4
+ZC373.4	B0348.4
+ZK1067.1	B0348.4
+ZK856.8	B0348.4
+ZK909.2	B0348.4
+C09B7.1	C02F4.2
+C14B9.8	C02F4.2
+C18E9.1	C02F4.2
+C30F12.6	C02F4.2
+C47E12.2	C02F4.2
+F07F6.6	C02F4.2
+F17C8.1	C02F4.2
+F25B4.7	C02F4.2
+F31B12.1	C02F4.2
+F33D4.2	C02F4.2
+F45H11.4	C02F4.2
+F59C12.2	C02F4.2
+K01H12.2	C02F4.2
+K03A1.4	C02F4.2
+K11C4.5	C02F4.2
+K11D9.2	C02F4.2
+K11E8.1	C02F4.2
+M01D7.7	C02F4.2
+R05G6.7	C02F4.2
+R05G6.8	C02F4.2
+R06A10.2	C02F4.2
+T01B11.4	C02F4.2
+T01E8.3	C02F4.2
+T04D3.3	C02F4.2
+T07G12.1	C02F4.2
+T21H3.3	C02F4.2
+T27E9.1	C02F4.2
+W02D3.6	C02F4.2
+Y113G7A.4	C02F4.2
+Y40H4A.1	C02F4.2
+Y67D8A.1	C02F4.2
+Y67D8C.10	C02F4.2
+ZC373.4	C02F4.2
+C14B9.8	C09B7.1
+C18E9.1	C09B7.1
+C30F12.6	C09B7.1
+C47E12.2	C09B7.1
+E01H11.1	C09B7.1
+F07F6.6	C09B7.1
+F17C8.1	C09B7.1
+F25B4.7	C09B7.1
+F31B12.1	C09B7.1
+F33D4.2	C09B7.1
+F45H11.4	C09B7.1
+F47F2.1	C09B7.1
+F55C10.1	C09B7.1
+F59C12.2	C09B7.1
+F59D6.7	C09B7.1
+K01H12.2	C09B7.1
+K03A1.4	C09B7.1
+K11C4.5	C09B7.1
+K11D9.2	C09B7.1
+K11E8.1	C09B7.1
+M01D7.7	C09B7.1
+R05G6.7	C09B7.1
+R05G6.8	C09B7.1
+R06A10.2	C09B7.1
+T01B11.4	C09B7.1
+T01E8.3	C09B7.1
+T04D3.3	C09B7.1
+T07G12.1	C09B7.1
+T21H3.3	C09B7.1
+T27E9.1	C09B7.1
+W02D3.6	C09B7.1
+Y113G7A.4	C09B7.1
+Y40H4A.1	C09B7.1
+Y67D8A.1	C09B7.1
+Y67D8C.10	C09B7.1
+Y71H2AL.1	C09B7.1
+ZC373.4	C09B7.1
+ZK1067.1	C09B7.1
+ZK856.8	C09B7.1
+ZK909.2	C09B7.1
+C18E9.1	C14B9.8
+C30F12.6	C14B9.8
+C47E12.2	C14B9.8
+E01H11.1	C14B9.8
+F07F6.6	C14B9.8
+F17C8.1	C14B9.8
+F25B4.7	C14B9.8
+F31B12.1	C14B9.8
+F33D4.2	C14B9.8
+F45H11.4	C14B9.8
+F47F2.1	C14B9.8
+F55C10.1	C14B9.8
+F59C12.2	C14B9.8
+F59D6.7	C14B9.8
+K01H12.2	C14B9.8
+K03A1.4	C14B9.8
+K11C4.5	C14B9.8
+K11D9.2	C14B9.8
+K11E8.1	C14B9.8
+M01D7.7	C14B9.8
+R05G6.7	C14B9.8
+R05G6.8	C14B9.8
+R06A10.2	C14B9.8
+T01B11.4	C14B9.8
+T01E8.3	C14B9.8
+T04D3.3	C14B9.8
+T07G12.1	C14B9.8
+T21H3.3	C14B9.8
+T27E9.1	C14B9.8
+W02D3.6	C14B9.8
+Y113G7A.4	C14B9.8
+Y40H4A.1	C14B9.8
+Y67D8A.1	C14B9.8
+Y67D8C.10	C14B9.8
+Y71H2AL.1	C14B9.8
+ZC373.4	C14B9.8
+ZK1067.1	C14B9.8
+ZK856.8	C14B9.8
+ZK909.2	C14B9.8
+C30F12.6	C18E9.1
+C47E12.2	C18E9.1
+E01H11.1	C18E9.1
+F07F6.6	C18E9.1
+F17C8.1	C18E9.1
+F25B4.7	C18E9.1
+F31B12.1	C18E9.1
+F33D4.2	C18E9.1
+F45H11.4	C18E9.1
+F47F2.1	C18E9.1
+F55C10.1	C18E9.1
+F59C12.2	C18E9.1
+F59D6.7	C18E9.1
+K01H12.2	C18E9.1
+K03A1.4	C18E9.1
+K11C4.5	C18E9.1
+K11D9.2	C18E9.1
+K11E8.1	C18E9.1
+M01D7.7	C18E9.1
+R05G6.7	C18E9.1
+R05G6.8	C18E9.1
+R06A10.2	C18E9.1
+T01B11.4	C18E9.1
+T01E8.3	C18E9.1
+T04D3.3	C18E9.1
+T07G12.1	C18E9.1
+T21H3.3	C18E9.1
+T27E9.1	C18E9.1
+W02D3.6	C18E9.1
+Y113G7A.4	C18E9.1
+Y40H4A.1	C18E9.1
+Y67D8A.1	C18E9.1
+Y67D8C.10	C18E9.1
+Y71H2AL.1	C18E9.1
+ZC373.4	C18E9.1
+ZK1067.1	C18E9.1
+ZK856.8	C18E9.1
+ZK909.2	C18E9.1
+C47E12.2	C30F12.6
+E01H11.1	C30F12.6
+F07F6.6	C30F12.6
+F17C8.1	C30F12.6
+F25B4.7	C30F12.6
+F31B12.1	C30F12.6
+F33D4.2	C30F12.6
+F45H11.4	C30F12.6
+F47F2.1	C30F12.6
+F55C10.1	C30F12.6
+F59C12.2	C30F12.6
+F59D6.7	C30F12.6
+K01H12.2	C30F12.6
+K03A1.4	C30F12.6
+K11C4.5	C30F12.6
+K11D9.2	C30F12.6
+K11E8.1	C30F12.6
+M01D7.7	C30F12.6
+R05G6.7	C30F12.6
+R05G6.8	C30F12.6
+R06A10.2	C30F12.6
+T01B11.4	C30F12.6
+T01E8.3	C30F12.6
+T04D3.3	C30F12.6
+T07G12.1	C30F12.6
+T21H3.3	C30F12.6
+T27E9.1	C30F12.6
+W02D3.6	C30F12.6
+Y113G7A.4	C30F12.6
+Y40H4A.1	C30F12.6
+Y67D8A.1	C30F12.6
+Y67D8C.10	C30F12.6
+Y71H2AL.1	C30F12.6
+ZC373.4	C30F12.6
+ZK1067.1	C30F12.6
+ZK856.8	C30F12.6
+ZK909.2	C30F12.6
+E01H11.1	C47E12.2
+F07F6.6	C47E12.2
+F17C8.1	C47E12.2
+F25B4.7	C47E12.2
+F31B12.1	C47E12.2
+F33D4.2	C47E12.2
+F45H11.4	C47E12.2
+F47F2.1	C47E12.2
+F55C10.1	C47E12.2
+F59C12.2	C47E12.2
+F59D6.7	C47E12.2
+K01H12.2	C47E12.2
+K03A1.4	C47E12.2
+K11C4.5	C47E12.2
+K11D9.2	C47E12.2
+K11E8.1	C47E12.2
+M01D7.7	C47E12.2
+R05G6.7	C47E12.2
+R05G6.8	C47E12.2
+R06A10.2	C47E12.2
+T01B11.4	C47E12.2
+T01E8.3	C47E12.2
+T04D3.3	C47E12.2
+T07G12.1	C47E12.2
+T21H3.3	C47E12.2
+T27E9.1	C47E12.2
+W02D3.6	C47E12.2
+Y113G7A.4	C47E12.2
+Y40H4A.1	C47E12.2
+Y67D8A.1	C47E12.2
+Y67D8C.10	C47E12.2
+Y71H2AL.1	C47E12.2
+ZC373.4	C47E12.2
+ZK1067.1	C47E12.2
+ZK856.8	C47E12.2
+ZK909.2	C47E12.2
+F07F6.6	E01H11.1
+F17C8.1	E01H11.1
+F25B4.7	E01H11.1
+F31B12.1	E01H11.1
+F33D4.2	E01H11.1
+F45H11.4	E01H11.1
+F59C12.2	E01H11.1
+K01H12.2	E01H11.1
+K03A1.4	E01H11.1
+K11C4.5	E01H11.1
+K11D9.2	E01H11.1
+M01D7.7	E01H11.1
+R05G6.7	E01H11.1
+R05G6.8	E01H11.1
+R06A10.2	E01H11.1
+T01B11.4	E01H11.1
+T04D3.3	E01H11.1
+T07G12.1	E01H11.1
+T21H3.3	E01H11.1
+T27E9.1	E01H11.1
+W02D3.6	E01H11.1
+Y113G7A.4	E01H11.1
+Y40H4A.1	E01H11.1
+Y67D8A.1	E01H11.1
+Y67D8C.10	E01H11.1
+ZC373.4	E01H11.1
+F17C8.1	F07F6.6
+F25B4.7	F07F6.6
+F31B12.1	F07F6.6
+F33D4.2	F07F6.6
+F45H11.4	F07F6.6
+F47F2.1	F07F6.6
+F55C10.1	F07F6.6
+F59C12.2	F07F6.6
+F59D6.7	F07F6.6
+K01H12.2	F07F6.6
+K03A1.4	F07F6.6
+K11C4.5	F07F6.6
+K11D9.2	F07F6.6
+K11E8.1	F07F6.6
+M01D7.7	F07F6.6
+R05G6.7	F07F6.6
+R05G6.8	F07F6.6
+R06A10.2	F07F6.6
+T01B11.4	F07F6.6
+T01E8.3	F07F6.6
+T04D3.3	F07F6.6
+T07G12.1	F07F6.6
+T21H3.3	F07F6.6
+T27E9.1	F07F6.6
+W02D3.6	F07F6.6
+Y113G7A.4	F07F6.6
+Y40H4A.1	F07F6.6
+Y67D8A.1	F07F6.6
+Y67D8C.10	F07F6.6
+Y71H2AL.1	F07F6.6
+ZC373.4	F07F6.6
+ZK1067.1	F07F6.6
+ZK856.8	F07F6.6
+ZK909.2	F07F6.6
+F25B4.7	F17C8.1
+F31B12.1	F17C8.1
+F33D4.2	F17C8.1
+F45H11.4	F17C8.1
+F47F2.1	F17C8.1
+F55C10.1	F17C8.1
+F59C12.2	F17C8.1
+F59D6.7	F17C8.1
+K01H12.2	F17C8.1
+K03A1.4	F17C8.1
+K11C4.5	F17C8.1
+K11D9.2	F17C8.1
+K11E8.1	F17C8.1
+M01D7.7	F17C8.1
+R05G6.7	F17C8.1
+R05G6.8	F17C8.1
+R06A10.2	F17C8.1
+T01B11.4	F17C8.1
+T01E8.3	F17C8.1
+T07G12.1	F17C8.1
+T21H3.3	F17C8.1
+T27E9.1	F17C8.1
+W02D3.6	F17C8.1
+Y113G7A.4	F17C8.1
+Y40H4A.1	F17C8.1
+Y67D8A.1	F17C8.1
+Y67D8C.10	F17C8.1
+Y71H2AL.1	F17C8.1
+ZC373.4	F17C8.1
+ZK1067.1	F17C8.1
+ZK856.8	F17C8.1
+ZK909.2	F17C8.1
+F31B12.1	F25B4.7
+F33D4.2	F25B4.7
+F45H11.4	F25B4.7
+F47F2.1	F25B4.7
+F55C10.1	F25B4.7
+F59C12.2	F25B4.7
+F59D6.7	F25B4.7
+K01H12.2	F25B4.7
+K03A1.4	F25B4.7
+K11C4.5	F25B4.7
+K11D9.2	F25B4.7
+K11E8.1	F25B4.7
+M01D7.7	F25B4.7
+R05G6.7	F25B4.7
+R05G6.8	F25B4.7
+R06A10.2	F25B4.7
+T01B11.4	F25B4.7
+T01E8.3	F25B4.7
+T04D3.3	F25B4.7
+T07G12.1	F25B4.7
+T21H3.3	F25B4.7
+T27E9.1	F25B4.7
+W02D3.6	F25B4.7
+Y113G7A.4	F25B4.7
+Y40H4A.1	F25B4.7
+Y67D8A.1	F25B4.7
+Y67D8C.10	F25B4.7
+Y71H2AL.1	F25B4.7
+ZC373.4	F25B4.7
+ZK1067.1	F25B4.7
+ZK856.8	F25B4.7
+ZK909.2	F25B4.7
+F33D4.2	F31B12.1
+F45H11.4	F31B12.1
+F47F2.1	F31B12.1
+F55C10.1	F31B12.1
+F59C12.2	F31B12.1
+F59D6.7	F31B12.1
+K01H12.2	F31B12.1
+K03A1.4	F31B12.1
+K11C4.5	F31B12.1
+K11D9.2	F31B12.1
+K11E8.1	F31B12.1
+M01D7.7	F31B12.1
+R05G6.7	F31B12.1
+R06A10.2	F31B12.1
+T01B11.4	F31B12.1
+T04D3.3	F31B12.1
+T07G12.1	F31B12.1
+T21H3.3	F31B12.1
+T27E9.1	F31B12.1
+W02D3.6	F31B12.1
+Y113G7A.4	F31B12.1
+Y40H4A.1	F31B12.1
+Y67D8A.1	F31B12.1
+Y67D8C.10	F31B12.1
+Y71H2AL.1	F31B12.1
+ZC373.4	F31B12.1
+ZK1067.1	F31B12.1
+ZK856.8	F31B12.1
+ZK909.2	F31B12.1
+F45H11.4	F33D4.2
+F47F2.1	F33D4.2
+F55C10.1	F33D4.2
+F59C12.2	F33D4.2
+F59D6.7	F33D4.2
+K01H12.2	F33D4.2
+K03A1.4	F33D4.2
+K11C4.5	F33D4.2
+K11D9.2	F33D4.2
+K11E8.1	F33D4.2
+M01D7.7	F33D4.2
+R05G6.7	F33D4.2
+R05G6.8	F33D4.2
+R06A10.2	F33D4.2
+T01B11.4	F33D4.2
+T01E8.3	F33D4.2
+T04D3.3	F33D4.2
+T07G12.1	F33D4.2
+T21H3.3	F33D4.2
+T27E9.1	F33D4.2
+W02D3.6	F33D4.2
+Y113G7A.4	F33D4.2
+Y40H4A.1	F33D4.2
+Y67D8A.1	F33D4.2
+Y67D8C.10	F33D4.2
+Y71H2AL.1	F33D4.2
+ZC373.4	F33D4.2
+ZK1067.1	F33D4.2
+ZK856.8	F33D4.2
+ZK909.2	F33D4.2
+F47F2.1	F45H11.4
+F55C10.1	F45H11.4
+F59C12.2	F45H11.4
+F59D6.7	F45H11.4
+K01H12.2	F45H11.4
+K03A1.4	F45H11.4
+K11C4.5	F45H11.4
+K11D9.2	F45H11.4
+K11E8.1	F45H11.4
+M01D7.7	F45H11.4
+R05G6.7	F45H11.4
+R05G6.8	F45H11.4
+R06A10.2	F45H11.4
+T01B11.4	F45H11.4
+T01E8.3	F45H11.4
+T04D3.3	F45H11.4
+T07G12.1	F45H11.4
+T21H3.3	F45H11.4
+T27E9.1	F45H11.4
+W02D3.6	F45H11.4
+Y113G7A.4	F45H11.4
+Y40H4A.1	F45H11.4
+Y67D8A.1	F45H11.4
+Y67D8C.10	F45H11.4
+Y71H2AL.1	F45H11.4
+ZC373.4	F45H11.4
+ZK1067.1	F45H11.4
+ZK856.8	F45H11.4
+ZK909.2	F45H11.4
+F59C12.2	F47F2.1
+K01H12.2	F47F2.1
+K03A1.4	F47F2.1
+K11C4.5	F47F2.1
+K11D9.2	F47F2.1
+K11E8.1	F47F2.1
+M01D7.7	F47F2.1
+R05G6.7	F47F2.1
+R05G6.8	F47F2.1
+R06A10.2	F47F2.1
+T01B11.4	F47F2.1
+T01E8.3	F47F2.1
+T04D3.3	F47F2.1
+T07G12.1	F47F2.1
+T21H3.3	F47F2.1
+T27E9.1	F47F2.1
+W02D3.6	F47F2.1
+Y113G7A.4	F47F2.1
+Y40H4A.1	F47F2.1
+Y67D8A.1	F47F2.1
+Y67D8C.10	F47F2.1
+ZC373.4	F47F2.1
+F59C12.2	F55C10.1
+K01H12.2	F55C10.1
+K03A1.4	F55C10.1
+K11C4.5	F55C10.1
+K11D9.2	F55C10.1
+K11E8.1	F55C10.1
+M01D7.7	F55C10.1
+R05G6.7	F55C10.1
+R05G6.8	F55C10.1
+R06A10.2	F55C10.1
+T01B11.4	F55C10.1
+T01E8.3	F55C10.1
+T04D3.3	F55C10.1
+T07G12.1	F55C10.1
+T21H3.3	F55C10.1
+T27E9.1	F55C10.1
+W02D3.6	F55C10.1
+Y113G7A.4	F55C10.1
+Y40H4A.1	F55C10.1
+Y67D8A.1	F55C10.1
+Y67D8C.10	F55C10.1
+ZC373.4	F55C10.1
+F59D6.7	F59C12.2
+K01H12.2	F59C12.2
+K03A1.4	F59C12.2
+K11C4.5	F59C12.2
+K11D9.2	F59C12.2
+K11E8.1	F59C12.2
+M01D7.7	F59C12.2
+R05G6.7	F59C12.2
+R05G6.8	F59C12.2
+R06A10.2	F59C12.2
+T01B11.4	F59C12.2
+T01E8.3	F59C12.2
+T04D3.3	F59C12.2
+T07G12.1	F59C12.2
+T21H3.3	F59C12.2
+T27E9.1	F59C12.2
+W02D3.6	F59C12.2
+Y113G7A.4	F59C12.2
+Y40H4A.1	F59C12.2
+Y67D8A.1	F59C12.2
+Y67D8C.10	F59C12.2
+Y71H2AL.1	F59C12.2
+ZC373.4	F59C12.2
+ZK1067.1	F59C12.2
+ZK856.8	F59C12.2
+ZK909.2	F59C12.2
+K01H12.2	F59D6.7
+K03A1.4	F59D6.7
+K11C4.5	F59D6.7
+K11D9.2	F59D6.7
+K11E8.1	F59D6.7
+M01D7.7	F59D6.7
+R05G6.7	F59D6.7
+R05G6.8	F59D6.7
+R06A10.2	F59D6.7
+T01B11.4	F59D6.7
+T01E8.3	F59D6.7
+T04D3.3	F59D6.7
+T07G12.1	F59D6.7
+T21H3.3	F59D6.7
+T27E9.1	F59D6.7
+W02D3.6	F59D6.7
+Y113G7A.4	F59D6.7
+Y40H4A.1	F59D6.7
+Y67D8A.1	F59D6.7
+Y67D8C.10	F59D6.7
+ZC373.4	F59D6.7
+K03A1.4	K01H12.2
+K11C4.5	K01H12.2
+K11D9.2	K01H12.2
+K11E8.1	K01H12.2
+M01D7.7	K01H12.2
+R05G6.7	K01H12.2
+R05G6.8	K01H12.2
+R06A10.2	K01H12.2
+T01B11.4	K01H12.2
+T01E8.3	K01H12.2
+T04D3.3	K01H12.2
+T07G12.1	K01H12.2
+T21H3.3	K01H12.2
+T27E9.1	K01H12.2
+W02D3.6	K01H12.2
+Y113G7A.4	K01H12.2
+Y40H4A.1	K01H12.2
+Y67D8A.1	K01H12.2
+Y67D8C.10	K01H12.2
+Y71H2AL.1	K01H12.2
+ZC373.4	K01H12.2
+ZK1067.1	K01H12.2
+ZK856.8	K01H12.2
+ZK909.2	K01H12.2
+K11C4.5	K03A1.4
+K11D9.2	K03A1.4
+K11E8.1	K03A1.4
+M01D7.7	K03A1.4
+R05G6.7	K03A1.4
+R05G6.8	K03A1.4
+R06A10.2	K03A1.4
+T01B11.4	K03A1.4
+T01E8.3	K03A1.4
+T04D3.3	K03A1.4
+T07G12.1	K03A1.4
+T21H3.3	K03A1.4
+T27E9.1	K03A1.4
+W02D3.6	K03A1.4
+Y113G7A.4	K03A1.4
+Y40H4A.1	K03A1.4
+Y67D8A.1	K03A1.4
+Y67D8C.10	K03A1.4
+Y71H2AL.1	K03A1.4
+ZC373.4	K03A1.4
+ZK1067.1	K03A1.4
+ZK856.8	K03A1.4
+ZK909.2	K03A1.4
+K11D9.2	K11C4.5
+K11E8.1	K11C4.5
+M01D7.7	K11C4.5
+R05G6.7	K11C4.5
+R05G6.8	K11C4.5
+R06A10.2	K11C4.5
+T01B11.4	K11C4.5
+T01E8.3	K11C4.5
+T04D3.3	K11C4.5
+T07G12.1	K11C4.5
+T21H3.3	K11C4.5
+T27E9.1	K11C4.5
+W02D3.6	K11C4.5
+Y113G7A.4	K11C4.5
+Y40H4A.1	K11C4.5
+Y67D8A.1	K11C4.5
+Y67D8C.10	K11C4.5
+Y71H2AL.1	K11C4.5
+ZC373.4	K11C4.5
+ZK1067.1	K11C4.5
+ZK856.8	K11C4.5
+ZK909.2	K11C4.5
+K11E8.1	K11D9.2
+M01D7.7	K11D9.2
+R05G6.7	K11D9.2
+R05G6.8	K11D9.2
+R06A10.2	K11D9.2
+T01B11.4	K11D9.2
+T01E8.3	K11D9.2
+T04D3.3	K11D9.2
+T07G12.1	K11D9.2
+T21H3.3	K11D9.2
+T27E9.1	K11D9.2
+W02D3.6	K11D9.2
+Y113G7A.4	K11D9.2
+Y40H4A.1	K11D9.2
+Y67D8A.1	K11D9.2
+Y67D8C.10	K11D9.2
+Y71H2AL.1	K11D9.2
+ZC373.4	K11D9.2
+ZK1067.1	K11D9.2
+ZK856.8	K11D9.2
+ZK909.2	K11D9.2
+M01D7.7	K11E8.1
+R05G6.7	K11E8.1
+R05G6.8	K11E8.1
+R06A10.2	K11E8.1
+T01B11.4	K11E8.1
+T04D3.3	K11E8.1
+T07G12.1	K11E8.1
+T21H3.3	K11E8.1
+T27E9.1	K11E8.1
+W02D3.6	K11E8.1
+Y113G7A.4	K11E8.1
+Y40H4A.1	K11E8.1
+Y67D8A.1	K11E8.1
+Y67D8C.10	K11E8.1
+Y71H2AL.1	K11E8.1
+ZC373.4	K11E8.1
+ZK856.8	K11E8.1
+ZK909.2	K11E8.1
+R05G6.7	M01D7.7
+R05G6.8	M01D7.7
+T01B11.4	M01D7.7
+T01E8.3	M01D7.7
+T04D3.3	M01D7.7
+T07G12.1	M01D7.7
+T21H3.3	M01D7.7
+T27E9.1	M01D7.7
+W02D3.6	M01D7.7
+Y113G7A.4	M01D7.7
+Y40H4A.1	M01D7.7
+Y67D8A.1	M01D7.7
+Y67D8C.10	M01D7.7
+Y71H2AL.1	M01D7.7
+ZC373.4	M01D7.7
+ZK1067.1	M01D7.7
+ZK856.8	M01D7.7
+ZK909.2	M01D7.7
+R05G6.8	R05G6.7
+R06A10.2	R05G6.7
+T01B11.4	R05G6.7
+T01E8.3	R05G6.7
+T04D3.3	R05G6.7
+T07G12.1	R05G6.7
+T21H3.3	R05G6.7
+T27E9.1	R05G6.7
+W02D3.6	R05G6.7
+Y113G7A.4	R05G6.7
+Y40H4A.1	R05G6.7
+Y67D8A.1	R05G6.7
+Y67D8C.10	R05G6.7
+Y71H2AL.1	R05G6.7
+ZC373.4	R05G6.7
+ZK1067.1	R05G6.7
+ZK856.8	R05G6.7
+ZK909.2	R05G6.7
+R06A10.2	R05G6.8
+T01B11.4	R05G6.8
+T04D3.3	R05G6.8
+T07G12.1	R05G6.8
+T21H3.3	R05G6.8
+T27E9.1	R05G6.8
+W02D3.6	R05G6.8
+Y113G7A.4	R05G6.8
+Y40H4A.1	R05G6.8
+Y67D8A.1	R05G6.8
+Y67D8C.10	R05G6.8
+Y71H2AL.1	R05G6.8
+ZC373.4	R05G6.8
+ZK1067.1	R05G6.8
+ZK856.8	R05G6.8
+ZK909.2	R05G6.8
+T01B11.4	R06A10.2
+T01E8.3	R06A10.2
+T04D3.3	R06A10.2
+T07G12.1	R06A10.2
+T21H3.3	R06A10.2
+T27E9.1	R06A10.2
+W02D3.6	R06A10.2
+Y113G7A.4	R06A10.2
+Y40H4A.1	R06A10.2
+Y67D8A.1	R06A10.2
+Y67D8C.10	R06A10.2
+Y71H2AL.1	R06A10.2
+ZC373.4	R06A10.2
+ZK1067.1	R06A10.2
+ZK856.8	R06A10.2
+ZK909.2	R06A10.2
+T01E8.3	T01B11.4
+T04D3.3	T01B11.4
+T07G12.1	T01B11.4
+T21H3.3	T01B11.4
+T27E9.1	T01B11.4
+W02D3.6	T01B11.4
+Y113G7A.4	T01B11.4
+Y40H4A.1	T01B11.4
+Y67D8A.1	T01B11.4
+Y67D8C.10	T01B11.4
+Y71H2AL.1	T01B11.4
+ZC373.4	T01B11.4
+ZK1067.1	T01B11.4
+ZK856.8	T01B11.4
+ZK909.2	T01B11.4
+T04D3.3	T01E8.3
+T07G12.1	T01E8.3
+T21H3.3	T01E8.3
+T27E9.1	T01E8.3
+W02D3.6	T01E8.3
+Y113G7A.4	T01E8.3
+Y40H4A.1	T01E8.3
+Y67D8A.1	T01E8.3
+Y67D8C.10	T01E8.3
+Y71H2AL.1	T01E8.3
+ZC373.4	T01E8.3
+ZK856.8	T01E8.3
+ZK909.2	T01E8.3
+T07G12.1	T04D3.3
+T21H3.3	T04D3.3
+T27E9.1	T04D3.3
+W02D3.6	T04D3.3
+Y113G7A.4	T04D3.3
+Y40H4A.1	T04D3.3
+Y67D8A.1	T04D3.3
+Y67D8C.10	T04D3.3
+Y71H2AL.1	T04D3.3
+ZC373.4	T04D3.3
+ZK1067.1	T04D3.3
+ZK856.8	T04D3.3
+ZK909.2	T04D3.3
+T21H3.3	T07G12.1
+T27E9.1	T07G12.1
+W02D3.6	T07G12.1
+Y113G7A.4	T07G12.1
+Y40H4A.1	T07G12.1
+Y67D8A.1	T07G12.1
+Y67D8C.10	T07G12.1
+Y71H2AL.1	T07G12.1
+ZC373.4	T07G12.1
+ZK1067.1	T07G12.1
+ZK856.8	T07G12.1
+ZK909.2	T07G12.1
+T27E9.1	T21H3.3
+W02D3.6	T21H3.3
+Y113G7A.4	T21H3.3
+Y40H4A.1	T21H3.3
+Y67D8A.1	T21H3.3
+Y67D8C.10	T21H3.3
+Y71H2AL.1	T21H3.3
+ZC373.4	T21H3.3
+ZK1067.1	T21H3.3
+ZK856.8	T21H3.3
+ZK909.2	T21H3.3
+W02D3.6	T27E9.1
+Y113G7A.4	T27E9.1
+Y40H4A.1	T27E9.1
+Y67D8A.1	T27E9.1
+Y67D8C.10	T27E9.1
+Y71H2AL.1	T27E9.1
+ZC373.4	T27E9.1
+ZK1067.1	T27E9.1
+ZK856.8	T27E9.1
+ZK909.2	T27E9.1
+Y113G7A.4	W02D3.6
+Y40H4A.1	W02D3.6
+Y67D8A.1	W02D3.6
+Y67D8C.10	W02D3.6
+Y71H2AL.1	W02D3.6
+ZC373.4	W02D3.6
+ZK1067.1	W02D3.6
+ZK856.8	W02D3.6
+ZK909.2	W02D3.6
+Y40H4A.1	Y113G7A.4
+Y67D8A.1	Y113G7A.4
+Y67D8C.10	Y113G7A.4
+Y71H2AL.1	Y113G7A.4
+ZC373.4	Y113G7A.4
+ZK1067.1	Y113G7A.4
+ZK856.8	Y113G7A.4
+ZK909.2	Y113G7A.4
+Y67D8A.1	Y40H4A.1
+Y67D8C.10	Y40H4A.1
+Y71H2AL.1	Y40H4A.1
+ZC373.4	Y40H4A.1
+ZK1067.1	Y40H4A.1
+ZK856.8	Y40H4A.1
+ZK909.2	Y40H4A.1
+Y67D8C.10	Y67D8A.1
+Y71H2AL.1	Y67D8A.1
+ZC373.4	Y67D8A.1
+ZK1067.1	Y67D8A.1
+ZK856.8	Y67D8A.1
+ZK909.2	Y67D8A.1
+Y71H2AL.1	Y67D8C.10
+ZC373.4	Y67D8C.10
+ZK1067.1	Y67D8C.10
+ZK856.8	Y67D8C.10
+ZK909.2	Y67D8C.10
+ZC373.4	Y71H2AL.1
+ZK1067.1	ZC373.4
+ZK856.8	ZC373.4
+ZK909.2	ZC373.4
+C09E10.2	B0025.1
+C18E9.1	B0025.1
+C33H5.18	B0025.1
+E01H11.1	B0025.1
+F33D4.2	B0025.1
+F42A9.1	B0025.1
+F54G8.2	B0025.1
+K03A1.4	B0025.1
+K06A1.6	B0025.1
+T07G12.1	B0025.1
+T21H3.3	B0025.1
+Y110A7A.10	B0025.1
+C09E10.2	B0334.8
+C18E9.1	B0334.8
+C33H5.18	B0334.8
+F33D4.2	B0334.8
+F42A9.1	B0334.8
+F54G8.2	B0334.8
+K03A1.4	B0334.8
+K06A1.6	B0334.8
+T07G12.1	B0334.8
+T21H3.3	B0334.8
+C09E10.2	B0348.4
+C33H5.18	B0348.4
+F42A9.1	B0348.4
+F54G8.2	B0348.4
+K06A1.6	B0348.4
+Y110A7A.10	B0348.4
+C09E10.2	C09B8.1
+C18E9.1	C09B8.1
+C33H5.18	C09B8.1
+E01H11.1	C09B8.1
+F33D4.2	C09B8.1
+F42A9.1	C09B8.1
+F54G8.2	C09B8.1
+K03A1.4	C09B8.1
+K06A1.6	C09B8.1
+T07G12.1	C09B8.1
+T21H3.3	C09B8.1
+Y110A7A.10	C09B8.1
+C18E9.1	C09E10.2
+E01H11.1	C09E10.2
+F13G3.5	C09E10.2
+F31B12.1	C09E10.2
+F33D4.2	C09E10.2
+F35H12.4	C09E10.2
+F39B1.1	C09E10.2
+F55A12.3	C09E10.2
+JC8.10	C09E10.2
+K03A1.4	C09E10.2
+R05G6.8	C09E10.2
+T01E8.3	C09E10.2
+T07G12.1	C09E10.2
+T21H3.3	C09E10.2
+VF11C1L.1	C09E10.2
+Y110A7A.10	C09E10.2
+Y48G9A.8	C09E10.2
+Y6B3B.5	C09E10.2
+Y75B8A.24	C09E10.2
+C33H5.18	C18E9.1
+F13G3.5	C18E9.1
+F35H12.4	C18E9.1
+F39B1.1	C18E9.1
+F42A9.1	C18E9.1
+F54G8.2	C18E9.1
+F55A12.3	C18E9.1
+JC8.10	C18E9.1
+K06A1.6	C18E9.1
+VF11C1L.1	C18E9.1
+Y110A7A.10	C18E9.1
+Y46G5A.5	C18E9.1
+Y48G9A.8	C18E9.1
+Y6B3B.5	C18E9.1
+Y75B8A.24	C18E9.1
+E01H11.1	C33H5.18
+F13G3.5	C33H5.18
+F31B12.1	C33H5.18
+F33D4.2	C33H5.18
+F35H12.4	C33H5.18
+F39B1.1	C33H5.18
+F55A12.3	C33H5.18
+JC8.10	C33H5.18
+K03A1.4	C33H5.18
+R05G6.8	C33H5.18
+T01E8.3	C33H5.18
+T07G12.1	C33H5.18
+T21H3.3	C33H5.18
+VF11C1L.1	C33H5.18
+Y110A7A.10	C33H5.18
+Y48G9A.8	C33H5.18
+Y6B3B.5	C33H5.18
+Y75B8A.24	C33H5.18
+F13G3.5	E01H11.1
+F35H12.4	E01H11.1
+F39B1.1	E01H11.1
+F42A9.1	E01H11.1
+F54G8.2	E01H11.1
+F55A12.3	E01H11.1
+JC8.10	E01H11.1
+K06A1.6	E01H11.1
+VF11C1L.1	E01H11.1
+Y46G5A.5	E01H11.1
+Y48G9A.8	E01H11.1
+Y6B3B.5	E01H11.1
+Y75B8A.24	E01H11.1
+F33D4.2	F13G3.5
+F42A9.1	F13G3.5
+F54G8.2	F13G3.5
+K03A1.4	F13G3.5
+K06A1.6	F13G3.5
+T07G12.1	F13G3.5
+T21H3.3	F13G3.5
+Y110A7A.10	F13G3.5
+F42A9.1	F31B12.1
+F54G8.2	F31B12.1
+K06A1.6	F31B12.1
+Y110A7A.10	F31B12.1
+F35H12.4	F33D4.2
+F39B1.1	F33D4.2
+F42A9.1	F33D4.2
+F54G8.2	F33D4.2
+F55A12.3	F33D4.2
+JC8.10	F33D4.2
+K06A1.6	F33D4.2
+VF11C1L.1	F33D4.2
+Y110A7A.10	F33D4.2
+Y46G5A.5	F33D4.2
+Y48G9A.8	F33D4.2
+Y6B3B.5	F33D4.2
+Y75B8A.24	F33D4.2
+F42A9.1	F35H12.4
+F54G8.2	F35H12.4
+K03A1.4	F35H12.4
+K06A1.6	F35H12.4
+T07G12.1	F35H12.4
+T21H3.3	F35H12.4
+Y110A7A.10	F35H12.4
+F42A9.1	F39B1.1
+F54G8.2	F39B1.1
+K03A1.4	F39B1.1
+K06A1.6	F39B1.1
+T07G12.1	F39B1.1
+T21H3.3	F39B1.1
+Y110A7A.10	F39B1.1
+F55A12.3	F42A9.1
+JC8.10	F42A9.1
+K03A1.4	F42A9.1
+R05G6.8	F42A9.1
+T01E8.3	F42A9.1
+T07G12.1	F42A9.1
+T21H3.3	F42A9.1
+VF11C1L.1	F42A9.1
+Y110A7A.10	F42A9.1
+Y48G9A.8	F42A9.1
+Y6B3B.5	F42A9.1
+Y75B8A.24	F42A9.1
+F55A12.3	F54G8.2
+JC8.10	F54G8.2
+K03A1.4	F54G8.2
+R05G6.8	F54G8.2
+T01E8.3	F54G8.2
+T07G12.1	F54G8.2
+T21H3.3	F54G8.2
+VF11C1L.1	F54G8.2
+Y110A7A.10	F54G8.2
+Y48G9A.8	F54G8.2
+Y6B3B.5	F54G8.2
+Y75B8A.24	F54G8.2
+K03A1.4	F55A12.3
+K06A1.6	F55A12.3
+T07G12.1	F55A12.3
+T21H3.3	F55A12.3
+Y110A7A.10	F55A12.3
+K03A1.4	JC8.10
+K06A1.6	JC8.10
+T07G12.1	JC8.10
+T21H3.3	JC8.10
+Y110A7A.10	JC8.10
+K06A1.6	K03A1.4
+VF11C1L.1	K03A1.4
+Y110A7A.10	K03A1.4
+Y46G5A.5	K03A1.4
+Y48G9A.8	K03A1.4
+Y6B3B.5	K03A1.4
+Y75B8A.24	K03A1.4
+R05G6.8	K06A1.6
+T01E8.3	K06A1.6
+T07G12.1	K06A1.6
+T21H3.3	K06A1.6
+VF11C1L.1	K06A1.6
+Y110A7A.10	K06A1.6
+Y48G9A.8	K06A1.6
+Y6B3B.5	K06A1.6
+Y75B8A.24	K06A1.6
+Y110A7A.10	R05G6.8
+VF11C1L.1	T07G12.1
+Y110A7A.10	T07G12.1
+Y46G5A.5	T07G12.1
+Y48G9A.8	T07G12.1
+Y6B3B.5	T07G12.1
+Y75B8A.24	T07G12.1
+VF11C1L.1	T21H3.3
+Y110A7A.10	T21H3.3
+Y46G5A.5	T21H3.3
+Y48G9A.8	T21H3.3
+Y6B3B.5	T21H3.3
+Y75B8A.24	T21H3.3
+Y110A7A.10	VF11C1L.1
+Y46G5A.5	Y110A7A.10
+Y48G9A.8	Y110A7A.10
+Y6B3B.5	Y110A7A.10
+Y75B8A.24	Y110A7A.10
+C15B12.5	C09B7.1
+C25G6.5	C09B7.1
+C38C10.1	C09B7.1
+C41G7.9	C09B7.1
+C49A9.7	C09B7.1
+F07B10.5	C09B7.1
+F11H8.2	C09B7.1
+F15A8.5	C09B7.1
+F41E7.3	C09B7.1
+F47D12.1	C09B7.1
+F54D7.3	C09B7.1
+F54E7.3	C09B7.1
+K09G1.4	C09B7.1
+T01C3.10	C09B7.1
+T14E8.3	C09B7.1
+T21C12.1	C09B7.1
+T23B3.4	C09B7.1
+Y22D7AR.13	C09B7.1
+Y39A3B.5	C09B7.1
+Y41G9A.4	C09B7.1
+Y4C6A.2	C09B7.1
+ZC482.1	C09B7.1
+ZC482.5	C09B7.1
+ZC506.4	C09B7.1
+ZK455.3	C09B7.1
+C25G6.5	C15B12.5
+C30F12.6	C15B12.5
+C38C10.1	C15B12.5
+C41G7.9	C15B12.5
+C49A9.7	C15B12.5
+F07B10.5	C15B12.5
+F07F6.6	C15B12.5
+F11H8.2	C15B12.5
+F15A8.5	C15B12.5
+F41E7.3	C15B12.5
+F45H11.4	C15B12.5
+F47D12.1	C15B12.5
+F54D7.3	C15B12.5
+F54E7.3	C15B12.5
+F59C12.2	C15B12.5
+K09G1.4	C15B12.5
+T01C3.10	C15B12.5
+T14E8.3	C15B12.5
+T21C12.1	C15B12.5
+T23B3.4	C15B12.5
+Y22D7AR.13	C15B12.5
+Y39A3B.5	C15B12.5
+Y40H4A.1	C15B12.5
+Y41G9A.4	C15B12.5
+Y4C6A.2	C15B12.5
+ZC482.1	C15B12.5
+ZC482.5	C15B12.5
+ZC506.4	C15B12.5
+ZK455.3	C15B12.5
+C30F12.6	C25G6.5
+C38C10.1	C25G6.5
+C41G7.9	C25G6.5
+C49A9.7	C25G6.5
+F07B10.5	C25G6.5
+F07F6.6	C25G6.5
+F11H8.2	C25G6.5
+F15A8.5	C25G6.5
+F41E7.3	C25G6.5
+F45H11.4	C25G6.5
+F47D12.1	C25G6.5
+F54D7.3	C25G6.5
+F54E7.3	C25G6.5
+F59C12.2	C25G6.5
+K09G1.4	C25G6.5
+T01C3.10	C25G6.5
+T14E8.3	C25G6.5
+T21C12.1	C25G6.5
+T23B3.4	C25G6.5
+Y22D7AR.13	C25G6.5
+Y39A3B.5	C25G6.5
+Y40H4A.1	C25G6.5
+Y41G9A.4	C25G6.5
+Y4C6A.2	C25G6.5
+ZC482.1	C25G6.5
+ZC482.5	C25G6.5
+ZC506.4	C25G6.5
+ZK455.3	C25G6.5
+C38C10.1	C30F12.6
+C41G7.9	C30F12.6
+C49A9.7	C30F12.6
+F07B10.5	C30F12.6
+F11H8.2	C30F12.6
+F15A8.5	C30F12.6
+F41E7.3	C30F12.6
+F47D12.1	C30F12.6
+F54D7.3	C30F12.6
+F54E7.3	C30F12.6
+K09G1.4	C30F12.6
+T01C3.10	C30F12.6
+T14E8.3	C30F12.6
+T21C12.1	C30F12.6
+T23B3.4	C30F12.6
+Y22D7AR.13	C30F12.6
+Y39A3B.5	C30F12.6
+Y41G9A.4	C30F12.6
+Y4C6A.2	C30F12.6
+ZC482.1	C30F12.6
+ZC482.5	C30F12.6
+ZC506.4	C30F12.6
+ZK455.3	C30F12.6
+C41G7.9	C38C10.1
+C49A9.7	C38C10.1
+F07B10.5	C38C10.1
+F07F6.6	C38C10.1
+F11H8.2	C38C10.1
+F15A8.5	C38C10.1
+F41E7.3	C38C10.1
+F45H11.4	C38C10.1
+F47D12.1	C38C10.1
+F54D7.3	C38C10.1
+F54E7.3	C38C10.1
+F59C12.2	C38C10.1
+K09G1.4	C38C10.1
+T01C3.10	C38C10.1
+T14E8.3	C38C10.1
+T21C12.1	C38C10.1
+T23B3.4	C38C10.1
+Y22D7AR.13	C38C10.1
+Y39A3B.5	C38C10.1
+Y40H4A.1	C38C10.1
+Y41G9A.4	C38C10.1
+Y4C6A.2	C38C10.1
+ZC482.1	C38C10.1
+ZC482.5	C38C10.1
+ZC506.4	C38C10.1
+ZK455.3	C38C10.1
+C49A9.7	C41G7.9
+F07B10.5	C41G7.9
+F07F6.6	C41G7.9
+F11H8.2	C41G7.9
+F15A8.5	C41G7.9
+F41E7.3	C41G7.9
+F45H11.4	C41G7.9
+F47D12.1	C41G7.9
+F54D7.3	C41G7.9
+F54E7.3	C41G7.9
+F59C12.2	C41G7.9
+K09G1.4	C41G7.9
+T01C3.10	C41G7.9
+T14E8.3	C41G7.9
+T21C12.1	C41G7.9
+T23B3.4	C41G7.9
+Y22D7AR.13	C41G7.9
+Y39A3B.5	C41G7.9
+Y40H4A.1	C41G7.9
+Y41G9A.4	C41G7.9
+Y4C6A.2	C41G7.9
+ZC482.1	C41G7.9
+ZC482.5	C41G7.9
+ZC506.4	C41G7.9
+ZK455.3	C41G7.9
+F07B10.5	C49A9.7
+F07F6.6	C49A9.7
+F11H8.2	C49A9.7
+F15A8.5	C49A9.7
+F41E7.3	C49A9.7
+F45H11.4	C49A9.7
+F47D12.1	C49A9.7
+F54D7.3	C49A9.7
+F54E7.3	C49A9.7
+F59C12.2	C49A9.7
+K09G1.4	C49A9.7
+T01C3.10	C49A9.7
+T14E8.3	C49A9.7
+T21C12.1	C49A9.7
+T23B3.4	C49A9.7
+Y22D7AR.13	C49A9.7
+Y39A3B.5	C49A9.7
+Y40H4A.1	C49A9.7
+Y41G9A.4	C49A9.7
+Y4C6A.2	C49A9.7
+ZC482.1	C49A9.7
+ZC482.5	C49A9.7
+ZC506.4	C49A9.7
+ZK455.3	C49A9.7
+F07F6.6	F07B10.5
+F11H8.2	F07B10.5
+F15A8.5	F07B10.5
+F41E7.3	F07B10.5
+F45H11.4	F07B10.5
+F47D12.1	F07B10.5
+F54D7.3	F07B10.5
+F54E7.3	F07B10.5
+F59C12.2	F07B10.5
+K09G1.4	F07B10.5
+T01C3.10	F07B10.5
+T14E8.3	F07B10.5
+T21C12.1	F07B10.5
+T23B3.4	F07B10.5
+Y22D7AR.13	F07B10.5
+Y39A3B.5	F07B10.5
+Y40H4A.1	F07B10.5
+Y41G9A.4	F07B10.5
+Y4C6A.2	F07B10.5
+ZC482.1	F07B10.5
+ZC482.5	F07B10.5
+ZC506.4	F07B10.5
+ZK455.3	F07B10.5
+F11H8.2	F07F6.6
+F15A8.5	F07F6.6
+F41E7.3	F07F6.6
+F47D12.1	F07F6.6
+F54D7.3	F07F6.6
+F54E7.3	F07F6.6
+K09G1.4	F07F6.6
+T01C3.10	F07F6.6
+T14E8.3	F07F6.6
+T21C12.1	F07F6.6
+T23B3.4	F07F6.6
+Y22D7AR.13	F07F6.6
+Y39A3B.5	F07F6.6
+Y41G9A.4	F07F6.6
+Y4C6A.2	F07F6.6
+ZC482.1	F07F6.6
+ZC482.5	F07F6.6
+ZC506.4	F07F6.6
+ZK455.3	F07F6.6
+F15A8.5	F11H8.2
+F41E7.3	F11H8.2
+F45H11.4	F11H8.2
+F47D12.1	F11H8.2
+F54D7.3	F11H8.2
+F54E7.3	F11H8.2
+F59C12.2	F11H8.2
+K09G1.4	F11H8.2
+T01C3.10	F11H8.2
+T14E8.3	F11H8.2
+T21C12.1	F11H8.2
+T23B3.4	F11H8.2
+Y22D7AR.13	F11H8.2
+Y39A3B.5	F11H8.2
+Y40H4A.1	F11H8.2
+Y41G9A.4	F11H8.2
+Y4C6A.2	F11H8.2
+ZC482.1	F11H8.2
+ZC482.5	F11H8.2
+ZC506.4	F11H8.2
+ZK455.3	F11H8.2
+F41E7.3	F15A8.5
+F45H11.4	F15A8.5
+F47D12.1	F15A8.5
+F54D7.3	F15A8.5
+F54E7.3	F15A8.5
+F59C12.2	F15A8.5
+K09G1.4	F15A8.5
+T01C3.10	F15A8.5
+T14E8.3	F15A8.5
+T21C12.1	F15A8.5
+T23B3.4	F15A8.5
+Y22D7AR.13	F15A8.5
+Y39A3B.5	F15A8.5
+Y40H4A.1	F15A8.5
+Y41G9A.4	F15A8.5
+Y4C6A.2	F15A8.5
+ZC482.1	F15A8.5
+ZC482.5	F15A8.5
+ZC506.4	F15A8.5
+ZK455.3	F15A8.5
+F45H11.4	F41E7.3
+F47D12.1	F41E7.3
+F54D7.3	F41E7.3
+F54E7.3	F41E7.3
+F59C12.2	F41E7.3
+K09G1.4	F41E7.3
+T01C3.10	F41E7.3
+T14E8.3	F41E7.3
+T21C12.1	F41E7.3
+T23B3.4	F41E7.3
+Y22D7AR.13	F41E7.3
+Y39A3B.5	F41E7.3
+Y40H4A.1	F41E7.3
+Y41G9A.4	F41E7.3
+Y4C6A.2	F41E7.3
+ZC482.1	F41E7.3
+ZC482.5	F41E7.3
+ZC506.4	F41E7.3
+ZK455.3	F41E7.3
+F47D12.1	F45H11.4
+F54D7.3	F45H11.4
+F54E7.3	F45H11.4
+K09G1.4	F45H11.4
+T01C3.10	F45H11.4
+T14E8.3	F45H11.4
+T21C12.1	F45H11.4
+T23B3.4	F45H11.4
+Y22D7AR.13	F45H11.4
+Y39A3B.5	F45H11.4
+Y41G9A.4	F45H11.4
+Y4C6A.2	F45H11.4
+ZC482.1	F45H11.4
+ZC482.5	F45H11.4
+ZC506.4	F45H11.4
+ZK455.3	F45H11.4
+F54D7.3	F47D12.1
+F54E7.3	F47D12.1
+F59C12.2	F47D12.1
+K09G1.4	F47D12.1
+T01C3.10	F47D12.1
+T14E8.3	F47D12.1
+T21C12.1	F47D12.1
+T23B3.4	F47D12.1
+Y22D7AR.13	F47D12.1
+Y39A3B.5	F47D12.1
+Y40H4A.1	F47D12.1
+Y41G9A.4	F47D12.1
+Y4C6A.2	F47D12.1
+ZC482.1	F47D12.1
+ZC482.5	F47D12.1
+ZC506.4	F47D12.1
+ZK455.3	F47D12.1
+F54E7.3	F54D7.3
+F59C12.2	F54D7.3
+K09G1.4	F54D7.3
+T01C3.10	F54D7.3
+T14E8.3	F54D7.3
+T21C12.1	F54D7.3
+T23B3.4	F54D7.3
+Y22D7AR.13	F54D7.3
+Y39A3B.5	F54D7.3
+Y40H4A.1	F54D7.3
+Y41G9A.4	F54D7.3
+Y4C6A.2	F54D7.3
+ZC482.1	F54D7.3
+ZC482.5	F54D7.3
+ZC506.4	F54D7.3
+ZK455.3	F54D7.3
+F59C12.2	F54E7.3
+K09G1.4	F54E7.3
+T01C3.10	F54E7.3
+T14E8.3	F54E7.3
+T21C12.1	F54E7.3
+T23B3.4	F54E7.3
+Y22D7AR.13	F54E7.3
+Y39A3B.5	F54E7.3
+Y40H4A.1	F54E7.3
+Y41G9A.4	F54E7.3
+Y4C6A.2	F54E7.3
+ZC482.1	F54E7.3
+ZC482.5	F54E7.3
+ZC506.4	F54E7.3
+ZK455.3	F54E7.3
+K09G1.4	F59C12.2
+T01C3.10	F59C12.2
+T14E8.3	F59C12.2
+T21C12.1	F59C12.2
+T23B3.4	F59C12.2
+Y39A3B.5	F59C12.2
+Y41G9A.4	F59C12.2
+Y4C6A.2	F59C12.2
+ZC482.1	F59C12.2
+ZC482.5	F59C12.2
+ZC506.4	F59C12.2
+ZK455.3	F59C12.2
+T01C3.10	K09G1.4
+T14E8.3	K09G1.4
+T21C12.1	K09G1.4
+T23B3.4	K09G1.4
+Y22D7AR.13	K09G1.4
+Y39A3B.5	K09G1.4
+Y40H4A.1	K09G1.4
+Y41G9A.4	K09G1.4
+Y4C6A.2	K09G1.4
+ZC482.1	K09G1.4
+ZC482.5	K09G1.4
+ZC506.4	K09G1.4
+ZK455.3	K09G1.4
+T14E8.3	T01C3.10
+T21C12.1	T01C3.10
+T23B3.4	T01C3.10
+Y22D7AR.13	T01C3.10
+Y39A3B.5	T01C3.10
+Y40H4A.1	T01C3.10
+Y41G9A.4	T01C3.10
+Y4C6A.2	T01C3.10
+ZC482.1	T01C3.10
+ZC482.5	T01C3.10
+ZC506.4	T01C3.10
+ZK455.3	T01C3.10
+T21C12.1	T14E8.3
+T23B3.4	T14E8.3
+Y22D7AR.13	T14E8.3
+Y39A3B.5	T14E8.3
+Y40H4A.1	T14E8.3
+Y41G9A.4	T14E8.3
+Y4C6A.2	T14E8.3
+ZC482.1	T14E8.3
+ZC482.5	T14E8.3
+ZC506.4	T14E8.3
+ZK455.3	T14E8.3
+T23B3.4	T21C12.1
+Y22D7AR.13	T21C12.1
+Y39A3B.5	T21C12.1
+Y40H4A.1	T21C12.1
+Y41G9A.4	T21C12.1
+Y4C6A.2	T21C12.1
+ZC482.1	T21C12.1
+ZC482.5	T21C12.1
+ZC506.4	T21C12.1
+ZK455.3	T21C12.1
+Y22D7AR.13	T23B3.4
+Y39A3B.5	T23B3.4
+Y40H4A.1	T23B3.4
+Y41G9A.4	T23B3.4
+Y4C6A.2	T23B3.4
+ZC482.1	T23B3.4
+ZC482.5	T23B3.4
+ZC506.4	T23B3.4
+ZK455.3	T23B3.4
+Y39A3B.5	Y22D7AR.13
+Y40H4A.1	Y22D7AR.13
+Y41G9A.4	Y22D7AR.13
+Y4C6A.2	Y22D7AR.13
+ZC482.1	Y22D7AR.13
+ZC482.5	Y22D7AR.13
+ZC506.4	Y22D7AR.13
+ZK455.3	Y22D7AR.13
+Y40H4A.1	Y39A3B.5
+Y41G9A.4	Y39A3B.5
+Y4C6A.2	Y39A3B.5
+ZC482.1	Y39A3B.5
+ZC482.5	Y39A3B.5
+ZC506.4	Y39A3B.5
+ZK455.3	Y39A3B.5
+Y41G9A.4	Y40H4A.1
+Y4C6A.2	Y40H4A.1
+ZC482.1	Y40H4A.1
+ZC482.5	Y40H4A.1
+ZC506.4	Y40H4A.1
+ZK455.3	Y40H4A.1
+Y4C6A.2	Y41G9A.4
+ZC482.1	Y41G9A.4
+ZC482.5	Y41G9A.4
+ZC506.4	Y41G9A.4
+ZK455.3	Y41G9A.4
+ZC482.1	Y4C6A.2
+ZC482.5	Y4C6A.2
+ZC506.4	Y4C6A.2
+ZK455.3	Y4C6A.2
+ZC482.5	ZC482.1
+ZC506.4	ZC482.1
+ZK455.3	ZC482.1
+ZC506.4	ZC482.5
+ZK455.3	ZC482.5
+ZK455.3	ZC506.4
+C06E2.3	C06A8.4
+C06E2.7	C06A8.4
+C08B6.9	C06A8.4
+C28G1.1	C06A8.4
+C35B1.1	C06A8.4
+C42D4.6	C06A8.4
+C47E12.5	C06A8.4
+C52D10.6	C06A8.4
+C52D10.7	C06A8.4
+C52D10.8	C06A8.4
+C52D10.9	C06A8.4
+D1022.1	C06A8.4
+D2045.6	C06A8.4
+D2085.4	C06A8.4
+F08G12.4	C06A8.4
+F10B5.6	C06A8.4
+F10C5.1	C06A8.4
+F11H8.1	C06A8.4
+F15H10.3	C06A8.4
+F25H2.8	C06A8.4
+F29B9.6	C06A8.4
+F35G12.9	C06A8.4
+F36A2.13	C06A8.4
+F40G9.3	C06A8.4
+F44G3.6	C06A8.4
+F45E12.3	C06A8.4
+F46A9.4	C06A8.4
+F46A9.5	C06A8.4
+F47H4.10	C06A8.4
+F48E8.7	C06A8.4
+F49E12.4	C06A8.4
+F52C6.12	C06A8.4
+F54D10.1	C06A8.4
+F55A11.3	C06A8.4
+F55B12.3	C06A8.4
+F56B3.12	C06A8.4
+F56D2.4	C06A8.4
+F58A4.10	C06A8.4
+F59E10.2	C06A8.4
+K06H7.6	C06A8.4
+K08E3.7	C06A8.4
+K08H2.1	C06A8.4
+K10B2.1	C06A8.4
+M02A10.3	C06A8.4
+M18.5	C06A8.4
+M7.1	C06A8.4
+R01H2.6	C06A8.4
+R09B3.4	C06A8.4
+R10A10.2	C06A8.4
+R12H7.3	C06A8.4
+R12H7.5	C06A8.4
+T05H10.5	C06A8.4
+T09B4.10	C06A8.4
+T10F2.4	C06A8.4
+W02A11.4	C06A8.4
+W10C6.1	C06A8.4
+W10D5.3	C06A8.4
+Y105C5B.13	C06A8.4
+Y108G3AL.1	C06A8.4
+Y110A2AM.3	C06A8.4
+Y110A2AR.2	C06A8.4
+Y110A7A.17	C06A8.4
+Y37E11AR.2	C06A8.4
+Y37H2C.2	C06A8.4
+Y39A1C.2	C06A8.4
+Y41C4A.10	C06A8.4
+Y47D7A.1	C06A8.4
+Y47D7A.8	C06A8.4
+Y48G1C.12	C06A8.4
+Y54E5B.4	C06A8.4
+Y54G2A.31	C06A8.4
+Y60A3A.18	C06A8.4
+Y65B4BR.4	C06A8.4
+Y66D12A.17	C06A8.4
+Y67D8C.5	C06A8.4
+Y71G12B.15	C06A8.4
+Y82E9BR.15	C06A8.4
+Y87G2A.9	C06A8.4
+Y92H12A.2	C06A8.4
+Y94H6A.6	C06A8.4
+ZK1307.6	C06A8.4
+ZK287.5	C06A8.4
+ZK520.4	C06A8.4
+ZK856.1	C06A8.4
+ZK858.4	C06A8.4
+C06E2.7	C06E2.3
+C08B6.9	C06E2.3
+C28G1.1	C06E2.3
+C35B1.1	C06E2.3
+C42D4.6	C06E2.3
+C47E12.5	C06E2.3
+C52D10.6	C06E2.3
+C52D10.7	C06E2.3
+C52D10.8	C06E2.3
+C52D10.9	C06E2.3
+D1022.1	C06E2.3
+D2045.6	C06E2.3
+D2085.4	C06E2.3
+F08G12.4	C06E2.3
+F10B5.6	C06E2.3
+F10C5.1	C06E2.3
+F11H8.1	C06E2.3
+F15H10.3	C06E2.3
+F25H2.8	C06E2.3
+F29B9.6	C06E2.3
+F35G12.9	C06E2.3
+F36A2.13	C06E2.3
+F40G9.3	C06E2.3
+F44G3.6	C06E2.3
+F45E12.3	C06E2.3
+F46A9.4	C06E2.3
+F46A9.5	C06E2.3
+F47H4.10	C06E2.3
+F48E8.7	C06E2.3
+F49E12.4	C06E2.3
+F52C6.12	C06E2.3
+F54D10.1	C06E2.3
+F55A11.3	C06E2.3
+F55B12.3	C06E2.3
+F56B3.12	C06E2.3
+F56D2.4	C06E2.3
+F58A4.10	C06E2.3
+F59E10.2	C06E2.3
+K06H7.6	C06E2.3
+K08E3.7	C06E2.3
+K08H2.1	C06E2.3
+K10B2.1	C06E2.3
+M02A10.3	C06E2.3
+M18.5	C06E2.3
+M7.1	C06E2.3
+R01H2.6	C06E2.3
+R09B3.4	C06E2.3
+R10A10.2	C06E2.3
+R12H7.3	C06E2.3
+R12H7.5	C06E2.3
+T05H10.5	C06E2.3
+T09B4.10	C06E2.3
+T10F2.4	C06E2.3
+W02A11.4	C06E2.3
+W10C6.1	C06E2.3
+W10D5.3	C06E2.3
+Y105C5B.13	C06E2.3
+Y108G3AL.1	C06E2.3
+Y110A2AM.3	C06E2.3
+Y110A2AR.2	C06E2.3
+Y110A7A.17	C06E2.3
+Y37E11AR.2	C06E2.3
+Y37H2C.2	C06E2.3
+Y39A1C.2	C06E2.3
+Y41C4A.10	C06E2.3
+Y47D7A.1	C06E2.3
+Y47D7A.8	C06E2.3
+Y48G1C.12	C06E2.3
+Y54E5B.4	C06E2.3
+Y54G2A.31	C06E2.3
+Y60A3A.18	C06E2.3
+Y65B4BR.4	C06E2.3
+Y66D12A.17	C06E2.3
+Y67D8C.5	C06E2.3
+Y71G12B.15	C06E2.3
+Y82E9BR.15	C06E2.3
+Y87G2A.9	C06E2.3
+Y92H12A.2	C06E2.3
+Y94H6A.6	C06E2.3
+ZK1307.6	C06E2.3
+ZK287.5	C06E2.3
+ZK520.4	C06E2.3
+ZK856.1	C06E2.3
+ZK858.4	C06E2.3
+C08B6.9	C06E2.7
+C28G1.1	C06E2.7
+C35B1.1	C06E2.7
+C42D4.6	C06E2.7
+C47E12.5	C06E2.7
+C52D10.6	C06E2.7
+C52D10.7	C06E2.7
+C52D10.8	C06E2.7
+C52D10.9	C06E2.7
+D1022.1	C06E2.7
+D2045.6	C06E2.7
+D2085.4	C06E2.7
+F08G12.4	C06E2.7
+F10B5.6	C06E2.7
+F10C5.1	C06E2.7
+F11H8.1	C06E2.7
+F15H10.3	C06E2.7
+F25H2.8	C06E2.7
+F29B9.6	C06E2.7
+F35G12.9	C06E2.7
+F36A2.13	C06E2.7
+F40G9.3	C06E2.7
+F44G3.6	C06E2.7
+F45E12.3	C06E2.7
+F46A9.4	C06E2.7
+F46A9.5	C06E2.7
+F47H4.10	C06E2.7
+F48E8.7	C06E2.7
+F49E12.4	C06E2.7
+F52C6.12	C06E2.7
+F54D10.1	C06E2.7
+F55A11.3	C06E2.7
+F55B12.3	C06E2.7
+F56B3.12	C06E2.7
+F56D2.4	C06E2.7
+F58A4.10	C06E2.7
+F59E10.2	C06E2.7
+K06H7.6	C06E2.7
+K08E3.7	C06E2.7
+K08H2.1	C06E2.7
+K10B2.1	C06E2.7
+M02A10.3	C06E2.7
+M18.5	C06E2.7
+M7.1	C06E2.7
+R01H2.6	C06E2.7
+R09B3.4	C06E2.7
+R10A10.2	C06E2.7
+R12H7.3	C06E2.7
+R12H7.5	C06E2.7
+T05H10.5	C06E2.7
+T09B4.10	C06E2.7
+T10F2.4	C06E2.7
+W02A11.4	C06E2.7
+W10C6.1	C06E2.7
+W10D5.3	C06E2.7
+Y105C5B.13	C06E2.7
+Y108G3AL.1	C06E2.7
+Y110A2AM.3	C06E2.7
+Y110A2AR.2	C06E2.7
+Y110A7A.17	C06E2.7
+Y37E11AR.2	C06E2.7
+Y37H2C.2	C06E2.7
+Y39A1C.2	C06E2.7
+Y41C4A.10	C06E2.7
+Y47D7A.1	C06E2.7
+Y47D7A.8	C06E2.7
+Y48G1C.12	C06E2.7
+Y54E5B.4	C06E2.7
+Y54G2A.31	C06E2.7
+Y60A3A.18	C06E2.7
+Y65B4BR.4	C06E2.7
+Y66D12A.17	C06E2.7
+Y67D8C.5	C06E2.7
+Y71G12B.15	C06E2.7
+Y82E9BR.15	C06E2.7
+Y87G2A.9	C06E2.7
+Y92H12A.2	C06E2.7
+Y94H6A.6	C06E2.7
+ZK1307.6	C06E2.7
+ZK287.5	C06E2.7
+ZK520.4	C06E2.7
+ZK856.1	C06E2.7
+ZK858.4	C06E2.7
+C28G1.1	C08B6.9
+C35B1.1	C08B6.9
+C42D4.6	C08B6.9
+C47E12.5	C08B6.9
+C52D10.6	C08B6.9
+C52D10.7	C08B6.9
+C52D10.8	C08B6.9
+C52D10.9	C08B6.9
+D1022.1	C08B6.9
+D2045.6	C08B6.9
+D2085.4	C08B6.9
+F08G12.4	C08B6.9
+F10B5.6	C08B6.9
+F10C5.1	C08B6.9
+F11H8.1	C08B6.9
+F15H10.3	C08B6.9
+F25H2.8	C08B6.9
+F35G12.9	C08B6.9
+F36A2.13	C08B6.9
+F40G9.3	C08B6.9
+F44G3.6	C08B6.9
+F45E12.3	C08B6.9
+F46A9.4	C08B6.9
+F46A9.5	C08B6.9
+F47H4.10	C08B6.9
+F48E8.7	C08B6.9
+F49E12.4	C08B6.9
+F52C6.12	C08B6.9
+F54D10.1	C08B6.9
+F55A11.3	C08B6.9
+F55B12.3	C08B6.9
+F56B3.12	C08B6.9
+F56D2.4	C08B6.9
+F58A4.10	C08B6.9
+F59E10.2	C08B6.9
+K06H7.6	C08B6.9
+K08E3.7	C08B6.9
+K08H2.1	C08B6.9
+K10B2.1	C08B6.9
+M02A10.3	C08B6.9
+M18.5	C08B6.9
+M7.1	C08B6.9
+R01H2.6	C08B6.9
+R09B3.4	C08B6.9
+R10A10.2	C08B6.9
+R12H7.3	C08B6.9
+R12H7.5	C08B6.9
+T05H10.5	C08B6.9
+T09B4.10	C08B6.9
+T10F2.4	C08B6.9
+W10C6.1	C08B6.9
+Y105C5B.13	C08B6.9
+Y108G3AL.1	C08B6.9
+Y110A2AM.3	C08B6.9
+Y110A2AR.2	C08B6.9
+Y110A7A.17	C08B6.9
+Y37E11AR.2	C08B6.9
+Y37H2C.2	C08B6.9
+Y39A1C.2	C08B6.9
+Y41C4A.10	C08B6.9
+Y47D7A.1	C08B6.9
+Y47D7A.8	C08B6.9
+Y48G1C.12	C08B6.9
+Y54E5B.4	C08B6.9
+Y54G2A.31	C08B6.9
+Y60A3A.18	C08B6.9
+Y65B4BR.4	C08B6.9
+Y66D12A.17	C08B6.9
+Y67D8C.5	C08B6.9
+Y71G12B.15	C08B6.9
+Y82E9BR.15	C08B6.9
+Y87G2A.9	C08B6.9
+Y92H12A.2	C08B6.9
+Y94H6A.6	C08B6.9
+ZK1307.6	C08B6.9
+ZK287.5	C08B6.9
+ZK520.4	C08B6.9
+ZK856.1	C08B6.9
+ZK858.4	C08B6.9
+C35B1.1	C28G1.1
+C42D4.6	C28G1.1
+C47E12.5	C28G1.1
+C52D10.6	C28G1.1
+C52D10.7	C28G1.1
+C52D10.8	C28G1.1
+C52D10.9	C28G1.1
+D1022.1	C28G1.1
+D2045.6	C28G1.1
+D2085.4	C28G1.1
+F08G12.4	C28G1.1
+F10B5.6	C28G1.1
+F10C5.1	C28G1.1
+F11H8.1	C28G1.1
+F15H10.3	C28G1.1
+F25H2.8	C28G1.1
+F29B9.6	C28G1.1
+F35G12.9	C28G1.1
+F36A2.13	C28G1.1
+F40G9.3	C28G1.1
+F44G3.6	C28G1.1
+F45E12.3	C28G1.1
+F46A9.4	C28G1.1
+F46A9.5	C28G1.1
+F47H4.10	C28G1.1
+F48E8.7	C28G1.1
+F49E12.4	C28G1.1
+F52C6.12	C28G1.1
+F54D10.1	C28G1.1
+F55A11.3	C28G1.1
+F55B12.3	C28G1.1
+F56B3.12	C28G1.1
+F56D2.4	C28G1.1
+F58A4.10	C28G1.1
+F59E10.2	C28G1.1
+K06H7.6	C28G1.1
+K08E3.7	C28G1.1
+K08H2.1	C28G1.1
+K10B2.1	C28G1.1
+M02A10.3	C28G1.1
+M18.5	C28G1.1
+M7.1	C28G1.1
+R01H2.6	C28G1.1
+R09B3.4	C28G1.1
+R10A10.2	C28G1.1
+R12H7.3	C28G1.1
+R12H7.5	C28G1.1
+T05H10.5	C28G1.1
+T09B4.10	C28G1.1
+T10F2.4	C28G1.1
+W02A11.4	C28G1.1
+W10C6.1	C28G1.1
+W10D5.3	C28G1.1
+Y105C5B.13	C28G1.1
+Y108G3AL.1	C28G1.1
+Y110A2AM.3	C28G1.1
+Y110A2AR.2	C28G1.1
+Y110A7A.17	C28G1.1
+Y37E11AR.2	C28G1.1
+Y37H2C.2	C28G1.1
+Y39A1C.2	C28G1.1
+Y41C4A.10	C28G1.1
+Y47D7A.1	C28G1.1
+Y47D7A.8	C28G1.1
+Y48G1C.12	C28G1.1
+Y54E5B.4	C28G1.1
+Y54G2A.31	C28G1.1
+Y60A3A.18	C28G1.1
+Y65B4BR.4	C28G1.1
+Y66D12A.17	C28G1.1
+Y67D8C.5	C28G1.1
+Y71G12B.15	C28G1.1
+Y82E9BR.15	C28G1.1
+Y87G2A.9	C28G1.1
+Y92H12A.2	C28G1.1
+Y94H6A.6	C28G1.1
+ZK1307.6	C28G1.1
+ZK287.5	C28G1.1
+ZK520.4	C28G1.1
+ZK856.1	C28G1.1
+ZK858.4	C28G1.1
+C42D4.6	C35B1.1
+C47E12.5	C35B1.1
+C52D10.6	C35B1.1
+C52D10.7	C35B1.1
+C52D10.8	C35B1.1
+C52D10.9	C35B1.1
+D1022.1	C35B1.1
+D2045.6	C35B1.1
+D2085.4	C35B1.1
+F08G12.4	C35B1.1
+F10B5.6	C35B1.1
+F10C5.1	C35B1.1
+F11H8.1	C35B1.1
+F15H10.3	C35B1.1
+F25H2.8	C35B1.1
+F29B9.6	C35B1.1
+F35G12.9	C35B1.1
+F36A2.13	C35B1.1
+F40G9.3	C35B1.1
+F44G3.6	C35B1.1
+F45E12.3	C35B1.1
+F46A9.4	C35B1.1
+F46A9.5	C35B1.1
+F47H4.10	C35B1.1
+F48E8.7	C35B1.1
+F49E12.4	C35B1.1
+F52C6.12	C35B1.1
+F54D10.1	C35B1.1
+F55A11.3	C35B1.1
+F55B12.3	C35B1.1
+F56B3.12	C35B1.1
+F56D2.4	C35B1.1
+F58A4.10	C35B1.1
+F59E10.2	C35B1.1
+K06H7.6	C35B1.1
+K08E3.7	C35B1.1
+K08H2.1	C35B1.1
+K10B2.1	C35B1.1
+M02A10.3	C35B1.1
+M18.5	C35B1.1
+R09B3.4	C35B1.1
+R10A10.2	C35B1.1
+R12H7.3	C35B1.1
+R12H7.5	C35B1.1
+T10F2.4	C35B1.1
+W02A11.4	C35B1.1
+W10C6.1	C35B1.1
+W10D5.3	C35B1.1
+Y105C5B.13	C35B1.1
+Y108G3AL.1	C35B1.1
+Y110A2AM.3	C35B1.1
+Y110A2AR.2	C35B1.1
+Y110A7A.17	C35B1.1
+Y37E11AR.2	C35B1.1
+Y37H2C.2	C35B1.1
+Y39A1C.2	C35B1.1
+Y41C4A.10	C35B1.1
+Y47D7A.1	C35B1.1
+Y47D7A.8	C35B1.1
+Y48G1C.12	C35B1.1
+Y54E5B.4	C35B1.1
+Y54G2A.31	C35B1.1
+Y60A3A.18	C35B1.1
+Y66D12A.17	C35B1.1
+Y67D8C.5	C35B1.1
+Y71G12B.15	C35B1.1
+Y82E9BR.15	C35B1.1
+Y87G2A.9	C35B1.1
+Y92H12A.2	C35B1.1
+Y94H6A.6	C35B1.1
+ZK1307.6	C35B1.1
+ZK287.5	C35B1.1
+ZK520.4	C35B1.1
+ZK856.1	C35B1.1
+ZK858.4	C35B1.1
+C47E12.5	C42D4.6
+C52D10.6	C42D4.6
+C52D10.7	C42D4.6
+C52D10.8	C42D4.6
+C52D10.9	C42D4.6
+D1022.1	C42D4.6
+D2045.6	C42D4.6
+D2085.4	C42D4.6
+F08G12.4	C42D4.6
+F10B5.6	C42D4.6
+F10C5.1	C42D4.6
+F11H8.1	C42D4.6
+F15H10.3	C42D4.6
+F25H2.8	C42D4.6
+F29B9.6	C42D4.6
+F35G12.9	C42D4.6
+F36A2.13	C42D4.6
+F40G9.3	C42D4.6
+F44G3.6	C42D4.6
+F45E12.3	C42D4.6
+F46A9.4	C42D4.6
+F46A9.5	C42D4.6
+F47H4.10	C42D4.6
+F48E8.7	C42D4.6
+F49E12.4	C42D4.6
+F52C6.12	C42D4.6
+F54D10.1	C42D4.6
+F55A11.3	C42D4.6
+F55B12.3	C42D4.6
+F56B3.12	C42D4.6
+F56D2.4	C42D4.6
+F58A4.10	C42D4.6
+F59E10.2	C42D4.6
+K06H7.6	C42D4.6
+K08E3.7	C42D4.6
+K08H2.1	C42D4.6
+K10B2.1	C42D4.6
+M02A10.3	C42D4.6
+M18.5	C42D4.6
+M7.1	C42D4.6
+R01H2.6	C42D4.6
+R09B3.4	C42D4.6
+R10A10.2	C42D4.6
+R12H7.3	C42D4.6
+R12H7.5	C42D4.6
+T05H10.5	C42D4.6
+T09B4.10	C42D4.6
+T10F2.4	C42D4.6
+W02A11.4	C42D4.6
+W10C6.1	C42D4.6
+W10D5.3	C42D4.6
+Y105C5B.13	C42D4.6
+Y108G3AL.1	C42D4.6
+Y110A2AM.3	C42D4.6
+Y110A2AR.2	C42D4.6
+Y110A7A.17	C42D4.6
+Y37E11AR.2	C42D4.6
+Y37H2C.2	C42D4.6
+Y39A1C.2	C42D4.6
+Y41C4A.10	C42D4.6
+Y47D7A.1	C42D4.6
+Y47D7A.8	C42D4.6
+Y48G1C.12	C42D4.6
+Y54E5B.4	C42D4.6
+Y54G2A.31	C42D4.6
+Y60A3A.18	C42D4.6
+Y65B4BR.4	C42D4.6
+Y66D12A.17	C42D4.6
+Y67D8C.5	C42D4.6
+Y71G12B.15	C42D4.6
+Y82E9BR.15	C42D4.6
+Y87G2A.9	C42D4.6
+Y92H12A.2	C42D4.6
+Y94H6A.6	C42D4.6
+ZK1307.6	C42D4.6
+ZK287.5	C42D4.6
+ZK520.4	C42D4.6
+ZK856.1	C42D4.6
+ZK858.4	C42D4.6
+C52D10.6	C47E12.5
+C52D10.7	C47E12.5
+C52D10.8	C47E12.5
+C52D10.9	C47E12.5
+D1022.1	C47E12.5
+D2045.6	C47E12.5
+D2085.4	C47E12.5
+F08G12.4	C47E12.5
+F10B5.6	C47E12.5
+F10C5.1	C47E12.5
+F11H8.1	C47E12.5
+F15H10.3	C47E12.5
+F25H2.8	C47E12.5
+F29B9.6	C47E12.5
+F35G12.9	C47E12.5
+F36A2.13	C47E12.5
+F40G9.3	C47E12.5
+F44G3.6	C47E12.5
+F45E12.3	C47E12.5
+F46A9.4	C47E12.5
+F46A9.5	C47E12.5
+F47H4.10	C47E12.5
+F48E8.7	C47E12.5
+F49E12.4	C47E12.5
+F52C6.12	C47E12.5
+F54D10.1	C47E12.5
+F55A11.3	C47E12.5
+F55B12.3	C47E12.5
+F56B3.12	C47E12.5
+F56D2.4	C47E12.5
+F58A4.10	C47E12.5
+F59E10.2	C47E12.5
+K06H7.6	C47E12.5
+K08E3.7	C47E12.5
+K08H2.1	C47E12.5
+K10B2.1	C47E12.5
+M02A10.3	C47E12.5
+M18.5	C47E12.5
+M7.1	C47E12.5
+R01H2.6	C47E12.5
+R09B3.4	C47E12.5
+R10A10.2	C47E12.5
+R12H7.3	C47E12.5
+R12H7.5	C47E12.5
+T05H10.5	C47E12.5
+T09B4.10	C47E12.5
+T10F2.4	C47E12.5
+W02A11.4	C47E12.5
+W10C6.1	C47E12.5
+W10D5.3	C47E12.5
+Y105C5B.13	C47E12.5
+Y108G3AL.1	C47E12.5
+Y110A2AM.3	C47E12.5
+Y110A2AR.2	C47E12.5
+Y110A7A.17	C47E12.5
+Y37E11AR.2	C47E12.5
+Y37H2C.2	C47E12.5
+Y39A1C.2	C47E12.5
+Y41C4A.10	C47E12.5
+Y47D7A.1	C47E12.5
+Y47D7A.8	C47E12.5
+Y48G1C.12	C47E12.5
+Y54E5B.4	C47E12.5
+Y54G2A.31	C47E12.5
+Y60A3A.18	C47E12.5
+Y65B4BR.4	C47E12.5
+Y66D12A.17	C47E12.5
+Y67D8C.5	C47E12.5
+Y71G12B.15	C47E12.5
+Y82E9BR.15	C47E12.5
+Y87G2A.9	C47E12.5
+Y92H12A.2	C47E12.5
+Y94H6A.6	C47E12.5
+ZK1307.6	C47E12.5
+ZK287.5	C47E12.5
+ZK520.4	C47E12.5
+ZK856.1	C47E12.5
+ZK858.4	C47E12.5
+C52D10.7	C52D10.6
+C52D10.8	C52D10.6
+C52D10.9	C52D10.6
+D1022.1	C52D10.6
+D2045.6	C52D10.6
+D2085.4	C52D10.6
+F08G12.4	C52D10.6
+F10B5.6	C52D10.6
+F10C5.1	C52D10.6
+F11H8.1	C52D10.6
+F15H10.3	C52D10.6
+F25H2.8	C52D10.6
+F29B9.6	C52D10.6
+F35G12.9	C52D10.6
+F36A2.13	C52D10.6
+F40G9.3	C52D10.6
+F44G3.6	C52D10.6
+F45E12.3	C52D10.6
+F46A9.4	C52D10.6
+F46A9.5	C52D10.6
+F47H4.10	C52D10.6
+F48E8.7	C52D10.6
+F49E12.4	C52D10.6
+F52C6.12	C52D10.6
+F54D10.1	C52D10.6
+F55A11.3	C52D10.6
+F55B12.3	C52D10.6
+F56B3.12	C52D10.6
+F56D2.4	C52D10.6
+F58A4.10	C52D10.6
+F59E10.2	C52D10.6
+K06H7.6	C52D10.6
+K08E3.7	C52D10.6
+K08H2.1	C52D10.6
+K10B2.1	C52D10.6
+M02A10.3	C52D10.6
+M18.5	C52D10.6
+M7.1	C52D10.6
+R01H2.6	C52D10.6
+R09B3.4	C52D10.6
+R10A10.2	C52D10.6
+R12H7.3	C52D10.6
+R12H7.5	C52D10.6
+T05H10.5	C52D10.6
+T09B4.10	C52D10.6
+T10F2.4	C52D10.6
+W02A11.4	C52D10.6
+W10C6.1	C52D10.6
+W10D5.3	C52D10.6
+Y105C5B.13	C52D10.6
+Y108G3AL.1	C52D10.6
+Y110A2AM.3	C52D10.6
+Y110A2AR.2	C52D10.6
+Y110A7A.17	C52D10.6
+Y37E11AR.2	C52D10.6
+Y37H2C.2	C52D10.6
+Y39A1C.2	C52D10.6
+Y41C4A.10	C52D10.6
+Y47D7A.1	C52D10.6
+Y47D7A.8	C52D10.6
+Y48G1C.12	C52D10.6
+Y54E5B.4	C52D10.6
+Y54G2A.31	C52D10.6
+Y60A3A.18	C52D10.6
+Y65B4BR.4	C52D10.6
+Y66D12A.17	C52D10.6
+Y67D8C.5	C52D10.6
+Y71G12B.15	C52D10.6
+Y82E9BR.15	C52D10.6
+Y87G2A.9	C52D10.6
+Y92H12A.2	C52D10.6
+Y94H6A.6	C52D10.6
+ZK1307.6	C52D10.6
+ZK287.5	C52D10.6
+ZK520.4	C52D10.6
+ZK856.1	C52D10.6
+ZK858.4	C52D10.6
+C52D10.8	C52D10.7
+C52D10.9	C52D10.7
+D1022.1	C52D10.7
+D2045.6	C52D10.7
+D2085.4	C52D10.7
+F08G12.4	C52D10.7
+F10B5.6	C52D10.7
+F10C5.1	C52D10.7
+F11H8.1	C52D10.7
+F15H10.3	C52D10.7
+F25H2.8	C52D10.7
+F29B9.6	C52D10.7
+F35G12.9	C52D10.7
+F36A2.13	C52D10.7
+F40G9.3	C52D10.7
+F44G3.6	C52D10.7
+F45E12.3	C52D10.7
+F46A9.4	C52D10.7
+F46A9.5	C52D10.7
+F47H4.10	C52D10.7
+F48E8.7	C52D10.7
+F49E12.4	C52D10.7
+F52C6.12	C52D10.7
+F54D10.1	C52D10.7
+F55A11.3	C52D10.7
+F55B12.3	C52D10.7
+F56B3.12	C52D10.7
+F56D2.4	C52D10.7
+F58A4.10	C52D10.7
+F59E10.2	C52D10.7
+K06H7.6	C52D10.7
+K08E3.7	C52D10.7
+K08H2.1	C52D10.7
+K10B2.1	C52D10.7
+M02A10.3	C52D10.7
+M18.5	C52D10.7
+M7.1	C52D10.7
+R01H2.6	C52D10.7
+R09B3.4	C52D10.7
+R10A10.2	C52D10.7
+R12H7.3	C52D10.7
+R12H7.5	C52D10.7
+T05H10.5	C52D10.7
+T09B4.10	C52D10.7
+T10F2.4	C52D10.7
+W02A11.4	C52D10.7
+W10C6.1	C52D10.7
+W10D5.3	C52D10.7
+Y105C5B.13	C52D10.7
+Y108G3AL.1	C52D10.7
+Y110A2AM.3	C52D10.7
+Y110A2AR.2	C52D10.7
+Y110A7A.17	C52D10.7
+Y37E11AR.2	C52D10.7
+Y37H2C.2	C52D10.7
+Y39A1C.2	C52D10.7
+Y41C4A.10	C52D10.7
+Y47D7A.1	C52D10.7
+Y47D7A.8	C52D10.7
+Y48G1C.12	C52D10.7
+Y54E5B.4	C52D10.7
+Y54G2A.31	C52D10.7
+Y60A3A.18	C52D10.7
+Y65B4BR.4	C52D10.7
+Y66D12A.17	C52D10.7
+Y67D8C.5	C52D10.7
+Y71G12B.15	C52D10.7
+Y82E9BR.15	C52D10.7
+Y87G2A.9	C52D10.7
+Y92H12A.2	C52D10.7
+Y94H6A.6	C52D10.7
+ZK1307.6	C52D10.7
+ZK287.5	C52D10.7
+ZK520.4	C52D10.7
+ZK856.1	C52D10.7
+ZK858.4	C52D10.7
+C52D10.9	C52D10.8
+D1022.1	C52D10.8
+D2045.6	C52D10.8
+D2085.4	C52D10.8
+F08G12.4	C52D10.8
+F10B5.6	C52D10.8
+F10C5.1	C52D10.8
+F11H8.1	C52D10.8
+F15H10.3	C52D10.8
+F25H2.8	C52D10.8
+F29B9.6	C52D10.8
+F35G12.9	C52D10.8
+F36A2.13	C52D10.8
+F40G9.3	C52D10.8
+F44G3.6	C52D10.8
+F45E12.3	C52D10.8
+F46A9.4	C52D10.8
+F46A9.5	C52D10.8
+F47H4.10	C52D10.8
+F48E8.7	C52D10.8
+F49E12.4	C52D10.8
+F52C6.12	C52D10.8
+F54D10.1	C52D10.8
+F55A11.3	C52D10.8
+F55B12.3	C52D10.8
+F56B3.12	C52D10.8
+F56D2.4	C52D10.8
+F58A4.10	C52D10.8
+F59E10.2	C52D10.8
+K06H7.6	C52D10.8
+K08E3.7	C52D10.8
+K08H2.1	C52D10.8
+K10B2.1	C52D10.8
+M02A10.3	C52D10.8
+M18.5	C52D10.8
+M7.1	C52D10.8
+R01H2.6	C52D10.8
+R09B3.4	C52D10.8
+R10A10.2	C52D10.8
+R12H7.3	C52D10.8
+R12H7.5	C52D10.8
+T05H10.5	C52D10.8
+T09B4.10	C52D10.8
+T10F2.4	C52D10.8
+W02A11.4	C52D10.8
+W10C6.1	C52D10.8
+W10D5.3	C52D10.8
+Y105C5B.13	C52D10.8
+Y108G3AL.1	C52D10.8
+Y110A2AM.3	C52D10.8
+Y110A2AR.2	C52D10.8
+Y110A7A.17	C52D10.8
+Y37E11AR.2	C52D10.8
+Y37H2C.2	C52D10.8
+Y39A1C.2	C52D10.8
+Y41C4A.10	C52D10.8
+Y47D7A.1	C52D10.8
+Y47D7A.8	C52D10.8
+Y48G1C.12	C52D10.8
+Y54E5B.4	C52D10.8
+Y54G2A.31	C52D10.8
+Y60A3A.18	C52D10.8
+Y65B4BR.4	C52D10.8
+Y66D12A.17	C52D10.8
+Y67D8C.5	C52D10.8
+Y71G12B.15	C52D10.8
+Y82E9BR.15	C52D10.8
+Y87G2A.9	C52D10.8
+Y92H12A.2	C52D10.8
+Y94H6A.6	C52D10.8
+ZK1307.6	C52D10.8
+ZK287.5	C52D10.8
+ZK520.4	C52D10.8
+ZK856.1	C52D10.8
+ZK858.4	C52D10.8
+D1022.1	C52D10.9
+D2045.6	C52D10.9
+D2085.4	C52D10.9
+F08G12.4	C52D10.9
+F10B5.6	C52D10.9
+F10C5.1	C52D10.9
+F11H8.1	C52D10.9
+F15H10.3	C52D10.9
+F25H2.8	C52D10.9
+F29B9.6	C52D10.9
+F35G12.9	C52D10.9
+F36A2.13	C52D10.9
+F40G9.3	C52D10.9
+F44G3.6	C52D10.9
+F45E12.3	C52D10.9
+F46A9.4	C52D10.9
+F46A9.5	C52D10.9
+F47H4.10	C52D10.9
+F48E8.7	C52D10.9
+F49E12.4	C52D10.9
+F52C6.12	C52D10.9
+F54D10.1	C52D10.9
+F55A11.3	C52D10.9
+F55B12.3	C52D10.9
+F56B3.12	C52D10.9
+F56D2.4	C52D10.9
+F58A4.10	C52D10.9
+F59E10.2	C52D10.9
+K06H7.6	C52D10.9
+K08E3.7	C52D10.9
+K08H2.1	C52D10.9
+K10B2.1	C52D10.9
+M02A10.3	C52D10.9
+M18.5	C52D10.9
+M7.1	C52D10.9
+R01H2.6	C52D10.9
+R09B3.4	C52D10.9
+R10A10.2	C52D10.9
+R12H7.3	C52D10.9
+R12H7.5	C52D10.9
+T05H10.5	C52D10.9
+T09B4.10	C52D10.9
+T10F2.4	C52D10.9
+W02A11.4	C52D10.9
+W10C6.1	C52D10.9
+W10D5.3	C52D10.9
+Y105C5B.13	C52D10.9
+Y108G3AL.1	C52D10.9
+Y110A2AM.3	C52D10.9
+Y110A2AR.2	C52D10.9
+Y110A7A.17	C52D10.9
+Y37E11AR.2	C52D10.9
+Y37H2C.2	C52D10.9
+Y39A1C.2	C52D10.9
+Y41C4A.10	C52D10.9
+Y47D7A.1	C52D10.9
+Y47D7A.8	C52D10.9
+Y48G1C.12	C52D10.9
+Y54E5B.4	C52D10.9
+Y54G2A.31	C52D10.9
+Y60A3A.18	C52D10.9
+Y65B4BR.4	C52D10.9
+Y66D12A.17	C52D10.9
+Y67D8C.5	C52D10.9
+Y71G12B.15	C52D10.9
+Y82E9BR.15	C52D10.9
+Y87G2A.9	C52D10.9
+Y92H12A.2	C52D10.9
+Y94H6A.6	C52D10.9
+ZK1307.6	C52D10.9
+ZK287.5	C52D10.9
+ZK520.4	C52D10.9
+ZK856.1	C52D10.9
+ZK858.4	C52D10.9
+D2045.6	D1022.1
+D2085.4	D1022.1
+F08G12.4	D1022.1
+F10B5.6	D1022.1
+F10C5.1	D1022.1
+F11H8.1	D1022.1
+F15H10.3	D1022.1
+F25H2.8	D1022.1
+F29B9.6	D1022.1
+F35G12.9	D1022.1
+F36A2.13	D1022.1
+F40G9.3	D1022.1
+F44G3.6	D1022.1
+F45E12.3	D1022.1
+F46A9.4	D1022.1
+F46A9.5	D1022.1
+F47H4.10	D1022.1
+F48E8.7	D1022.1
+F49E12.4	D1022.1
+F52C6.12	D1022.1
+F54D10.1	D1022.1
+F55A11.3	D1022.1
+F55B12.3	D1022.1
+F56B3.12	D1022.1
+F56D2.4	D1022.1
+F58A4.10	D1022.1
+F59E10.2	D1022.1
+K06H7.6	D1022.1
+K08E3.7	D1022.1
+K08H2.1	D1022.1
+K10B2.1	D1022.1
+M02A10.3	D1022.1
+M18.5	D1022.1
+M7.1	D1022.1
+R01H2.6	D1022.1
+R09B3.4	D1022.1
+R10A10.2	D1022.1
+R12H7.3	D1022.1
+R12H7.5	D1022.1
+T05H10.5	D1022.1
+T09B4.10	D1022.1
+T10F2.4	D1022.1
+W02A11.4	D1022.1
+W10C6.1	D1022.1
+W10D5.3	D1022.1
+Y105C5B.13	D1022.1
+Y108G3AL.1	D1022.1
+Y110A2AM.3	D1022.1
+Y110A2AR.2	D1022.1
+Y110A7A.17	D1022.1
+Y37E11AR.2	D1022.1
+Y37H2C.2	D1022.1
+Y39A1C.2	D1022.1
+Y41C4A.10	D1022.1
+Y47D7A.1	D1022.1
+Y47D7A.8	D1022.1
+Y48G1C.12	D1022.1
+Y54E5B.4	D1022.1
+Y54G2A.31	D1022.1
+Y60A3A.18	D1022.1
+Y65B4BR.4	D1022.1
+Y66D12A.17	D1022.1
+Y67D8C.5	D1022.1
+Y71G12B.15	D1022.1
+Y82E9BR.15	D1022.1
+Y87G2A.9	D1022.1
+Y92H12A.2	D1022.1
+Y94H6A.6	D1022.1
+ZK1307.6	D1022.1
+ZK287.5	D1022.1
+ZK520.4	D1022.1
+ZK856.1	D1022.1
+ZK858.4	D1022.1
+D2085.4	D2045.6
+F08G12.4	D2045.6
+F10B5.6	D2045.6
+F10C5.1	D2045.6
+F11H8.1	D2045.6
+F15H10.3	D2045.6
+F25H2.8	D2045.6
+F29B9.6	D2045.6
+F35G12.9	D2045.6
+F36A2.13	D2045.6
+F40G9.3	D2045.6
+F44G3.6	D2045.6
+F45E12.3	D2045.6
+F46A9.4	D2045.6
+F46A9.5	D2045.6
+F47H4.10	D2045.6
+F48E8.7	D2045.6
+F49E12.4	D2045.6
+F52C6.12	D2045.6
+F54D10.1	D2045.6
+F55A11.3	D2045.6
+F55B12.3	D2045.6
+F56B3.12	D2045.6
+F56D2.4	D2045.6
+F58A4.10	D2045.6
+F59E10.2	D2045.6
+K06H7.6	D2045.6
+K08E3.7	D2045.6
+K08H2.1	D2045.6
+K10B2.1	D2045.6
+M02A10.3	D2045.6
+M18.5	D2045.6
+M7.1	D2045.6
+R01H2.6	D2045.6
+R09B3.4	D2045.6
+R10A10.2	D2045.6
+R12H7.3	D2045.6
+R12H7.5	D2045.6
+T05H10.5	D2045.6
+T09B4.10	D2045.6
+T10F2.4	D2045.6
+W02A11.4	D2045.6
+W10C6.1	D2045.6
+W10D5.3	D2045.6
+Y105C5B.13	D2045.6
+Y108G3AL.1	D2045.6
+Y110A2AM.3	D2045.6
+Y110A2AR.2	D2045.6
+Y110A7A.17	D2045.6
+Y37E11AR.2	D2045.6
+Y37H2C.2	D2045.6
+Y39A1C.2	D2045.6
+Y41C4A.10	D2045.6
+Y47D7A.1	D2045.6
+Y47D7A.8	D2045.6
+Y48G1C.12	D2045.6
+Y54E5B.4	D2045.6
+Y54G2A.31	D2045.6
+Y60A3A.18	D2045.6
+Y65B4BR.4	D2045.6
+Y66D12A.17	D2045.6
+Y67D8C.5	D2045.6
+Y71G12B.15	D2045.6
+Y82E9BR.15	D2045.6
+Y87G2A.9	D2045.6
+Y92H12A.2	D2045.6
+Y94H6A.6	D2045.6
+ZK1307.6	D2045.6
+ZK287.5	D2045.6
+ZK520.4	D2045.6
+ZK856.1	D2045.6
+ZK858.4	D2045.6
+F08G12.4	D2085.4
+F10B5.6	D2085.4
+F10C5.1	D2085.4
+F11H8.1	D2085.4
+F15H10.3	D2085.4
+F25H2.8	D2085.4
+F29B9.6	D2085.4
+F35G12.9	D2085.4
+F36A2.13	D2085.4
+F40G9.3	D2085.4
+F44G3.6	D2085.4
+F45E12.3	D2085.4
+F46A9.4	D2085.4
+F46A9.5	D2085.4
+F47H4.10	D2085.4
+F48E8.7	D2085.4
+F49E12.4	D2085.4
+F52C6.12	D2085.4
+F54D10.1	D2085.4
+F55A11.3	D2085.4
+F55B12.3	D2085.4
+F56B3.12	D2085.4
+F56D2.4	D2085.4
+F58A4.10	D2085.4
+F59E10.2	D2085.4
+K06H7.6	D2085.4
+K08E3.7	D2085.4
+K08H2.1	D2085.4
+K10B2.1	D2085.4
+M02A10.3	D2085.4
+M18.5	D2085.4
+M7.1	D2085.4
+R01H2.6	D2085.4
+R09B3.4	D2085.4
+R10A10.2	D2085.4
+R12H7.3	D2085.4
+R12H7.5	D2085.4
+T05H10.5	D2085.4
+T09B4.10	D2085.4
+T10F2.4	D2085.4
+W02A11.4	D2085.4
+W10C6.1	D2085.4
+W10D5.3	D2085.4
+Y105C5B.13	D2085.4
+Y108G3AL.1	D2085.4
+Y110A2AM.3	D2085.4
+Y110A2AR.2	D2085.4
+Y110A7A.17	D2085.4
+Y37E11AR.2	D2085.4
+Y37H2C.2	D2085.4
+Y39A1C.2	D2085.4
+Y41C4A.10	D2085.4
+Y47D7A.1	D2085.4
+Y47D7A.8	D2085.4
+Y48G1C.12	D2085.4
+Y54E5B.4	D2085.4
+Y54G2A.31	D2085.4
+Y60A3A.18	D2085.4
+Y65B4BR.4	D2085.4
+Y66D12A.17	D2085.4
+Y67D8C.5	D2085.4
+Y71G12B.15	D2085.4
+Y82E9BR.15	D2085.4
+Y87G2A.9	D2085.4
+Y92H12A.2	D2085.4
+Y94H6A.6	D2085.4
+ZK1307.6	D2085.4
+ZK287.5	D2085.4
+ZK520.4	D2085.4
+ZK856.1	D2085.4
+ZK858.4	D2085.4
+F10B5.6	F08G12.4
+F10C5.1	F08G12.4
+F11H8.1	F08G12.4
+F15H10.3	F08G12.4
+F25H2.8	F08G12.4
+F29B9.6	F08G12.4
+F35G12.9	F08G12.4
+F36A2.13	F08G12.4
+F40G9.3	F08G12.4
+F44G3.6	F08G12.4
+F45E12.3	F08G12.4
+F46A9.4	F08G12.4
+F46A9.5	F08G12.4
+F47H4.10	F08G12.4
+F48E8.7	F08G12.4
+F49E12.4	F08G12.4
+F52C6.12	F08G12.4
+F54D10.1	F08G12.4
+F55A11.3	F08G12.4
+F55B12.3	F08G12.4
+F56B3.12	F08G12.4
+F56D2.4	F08G12.4
+F58A4.10	F08G12.4
+F59E10.2	F08G12.4
+K06H7.6	F08G12.4
+K08E3.7	F08G12.4
+K08H2.1	F08G12.4
+K10B2.1	F08G12.4
+M02A10.3	F08G12.4
+M18.5	F08G12.4
+M7.1	F08G12.4
+R01H2.6	F08G12.4
+R09B3.4	F08G12.4
+R10A10.2	F08G12.4
+R12H7.3	F08G12.4
+R12H7.5	F08G12.4
+T05H10.5	F08G12.4
+T09B4.10	F08G12.4
+T10F2.4	F08G12.4
+W02A11.4	F08G12.4
+W10C6.1	F08G12.4
+W10D5.3	F08G12.4
+Y105C5B.13	F08G12.4
+Y108G3AL.1	F08G12.4
+Y110A2AM.3	F08G12.4
+Y110A2AR.2	F08G12.4
+Y110A7A.17	F08G12.4
+Y37E11AR.2	F08G12.4
+Y37H2C.2	F08G12.4
+Y39A1C.2	F08G12.4
+Y41C4A.10	F08G12.4
+Y47D7A.1	F08G12.4
+Y47D7A.8	F08G12.4
+Y48G1C.12	F08G12.4
+Y54E5B.4	F08G12.4
+Y54G2A.31	F08G12.4
+Y60A3A.18	F08G12.4
+Y65B4BR.4	F08G12.4
+Y66D12A.17	F08G12.4
+Y67D8C.5	F08G12.4
+Y71G12B.15	F08G12.4
+Y82E9BR.15	F08G12.4
+Y87G2A.9	F08G12.4
+Y92H12A.2	F08G12.4
+Y94H6A.6	F08G12.4
+ZK1307.6	F08G12.4
+ZK287.5	F08G12.4
+ZK520.4	F08G12.4
+ZK856.1	F08G12.4
+ZK858.4	F08G12.4
+F10C5.1	F10B5.6
+F11H8.1	F10B5.6
+F15H10.3	F10B5.6
+F25H2.8	F10B5.6
+F29B9.6	F10B5.6
+F35G12.9	F10B5.6
+F36A2.13	F10B5.6
+F40G9.3	F10B5.6
+F44G3.6	F10B5.6
+F45E12.3	F10B5.6
+F46A9.4	F10B5.6
+F46A9.5	F10B5.6
+F47H4.10	F10B5.6
+F48E8.7	F10B5.6
+F49E12.4	F10B5.6
+F52C6.12	F10B5.6
+F54D10.1	F10B5.6
+F55A11.3	F10B5.6
+F55B12.3	F10B5.6
+F56B3.12	F10B5.6
+F56D2.4	F10B5.6
+F58A4.10	F10B5.6
+F59E10.2	F10B5.6
+K06H7.6	F10B5.6
+K08E3.7	F10B5.6
+K08H2.1	F10B5.6
+K10B2.1	F10B5.6
+M02A10.3	F10B5.6
+M18.5	F10B5.6
+M7.1	F10B5.6
+R01H2.6	F10B5.6
+R09B3.4	F10B5.6
+R10A10.2	F10B5.6
+R12H7.3	F10B5.6
+R12H7.5	F10B5.6
+T05H10.5	F10B5.6
+T09B4.10	F10B5.6
+T10F2.4	F10B5.6
+W02A11.4	F10B5.6
+W10C6.1	F10B5.6
+W10D5.3	F10B5.6
+Y105C5B.13	F10B5.6
+Y108G3AL.1	F10B5.6
+Y110A2AM.3	F10B5.6
+Y110A2AR.2	F10B5.6
+Y110A7A.17	F10B5.6
+Y37E11AR.2	F10B5.6
+Y37H2C.2	F10B5.6
+Y39A1C.2	F10B5.6
+Y41C4A.10	F10B5.6
+Y47D7A.1	F10B5.6
+Y47D7A.8	F10B5.6
+Y48G1C.12	F10B5.6
+Y54E5B.4	F10B5.6
+Y54G2A.31	F10B5.6
+Y60A3A.18	F10B5.6
+Y65B4BR.4	F10B5.6
+Y66D12A.17	F10B5.6
+Y67D8C.5	F10B5.6
+Y71G12B.15	F10B5.6
+Y82E9BR.15	F10B5.6
+Y87G2A.9	F10B5.6
+Y92H12A.2	F10B5.6
+Y94H6A.6	F10B5.6
+ZK1307.6	F10B5.6
+ZK287.5	F10B5.6
+ZK520.4	F10B5.6
+ZK856.1	F10B5.6
+ZK858.4	F10B5.6
+F11H8.1	F10C5.1
+F15H10.3	F10C5.1
+F25H2.8	F10C5.1
+F29B9.6	F10C5.1
+F35G12.9	F10C5.1
+F36A2.13	F10C5.1
+F40G9.3	F10C5.1
+F44G3.6	F10C5.1
+F45E12.3	F10C5.1
+F46A9.4	F10C5.1
+F46A9.5	F10C5.1
+F47H4.10	F10C5.1
+F48E8.7	F10C5.1
+F49E12.4	F10C5.1
+F52C6.12	F10C5.1
+F54D10.1	F10C5.1
+F55A11.3	F10C5.1
+F55B12.3	F10C5.1
+F56B3.12	F10C5.1
+F56D2.4	F10C5.1
+F58A4.10	F10C5.1
+F59E10.2	F10C5.1
+K06H7.6	F10C5.1
+K08E3.7	F10C5.1
+K08H2.1	F10C5.1
+K10B2.1	F10C5.1
+M02A10.3	F10C5.1
+M18.5	F10C5.1
+M7.1	F10C5.1
+R01H2.6	F10C5.1
+R09B3.4	F10C5.1
+R10A10.2	F10C5.1
+R12H7.3	F10C5.1
+R12H7.5	F10C5.1
+T05H10.5	F10C5.1
+T09B4.10	F10C5.1
+T10F2.4	F10C5.1
+W02A11.4	F10C5.1
+W10C6.1	F10C5.1
+W10D5.3	F10C5.1
+Y105C5B.13	F10C5.1
+Y108G3AL.1	F10C5.1
+Y110A2AM.3	F10C5.1
+Y110A2AR.2	F10C5.1
+Y110A7A.17	F10C5.1
+Y37E11AR.2	F10C5.1
+Y37H2C.2	F10C5.1
+Y39A1C.2	F10C5.1
+Y41C4A.10	F10C5.1
+Y47D7A.1	F10C5.1
+Y47D7A.8	F10C5.1
+Y48G1C.12	F10C5.1
+Y54E5B.4	F10C5.1
+Y54G2A.31	F10C5.1
+Y60A3A.18	F10C5.1
+Y65B4BR.4	F10C5.1
+Y66D12A.17	F10C5.1
+Y67D8C.5	F10C5.1
+Y71G12B.15	F10C5.1
+Y82E9BR.15	F10C5.1
+Y87G2A.9	F10C5.1
+Y92H12A.2	F10C5.1
+Y94H6A.6	F10C5.1
+ZK1307.6	F10C5.1
+ZK287.5	F10C5.1
+ZK520.4	F10C5.1
+ZK856.1	F10C5.1
+ZK858.4	F10C5.1
+F15H10.3	F11H8.1
+F25H2.8	F11H8.1
+F29B9.6	F11H8.1
+F35G12.9	F11H8.1
+F36A2.13	F11H8.1
+F40G9.3	F11H8.1
+F44G3.6	F11H8.1
+F45E12.3	F11H8.1
+F46A9.4	F11H8.1
+F46A9.5	F11H8.1
+F47H4.10	F11H8.1
+F48E8.7	F11H8.1
+F49E12.4	F11H8.1
+F52C6.12	F11H8.1
+F54D10.1	F11H8.1
+F55A11.3	F11H8.1
+F55B12.3	F11H8.1
+F56B3.12	F11H8.1
+F56D2.4	F11H8.1
+F58A4.10	F11H8.1
+F59E10.2	F11H8.1
+K06H7.6	F11H8.1
+K08E3.7	F11H8.1
+K08H2.1	F11H8.1
+K10B2.1	F11H8.1
+M02A10.3	F11H8.1
+M18.5	F11H8.1
+M7.1	F11H8.1
+R01H2.6	F11H8.1
+R09B3.4	F11H8.1
+R10A10.2	F11H8.1
+R12H7.3	F11H8.1
+R12H7.5	F11H8.1
+T05H10.5	F11H8.1
+T09B4.10	F11H8.1
+T10F2.4	F11H8.1
+W02A11.4	F11H8.1
+W10C6.1	F11H8.1
+W10D5.3	F11H8.1
+Y105C5B.13	F11H8.1
+Y108G3AL.1	F11H8.1
+Y110A2AM.3	F11H8.1
+Y110A2AR.2	F11H8.1
+Y110A7A.17	F11H8.1
+Y37E11AR.2	F11H8.1
+Y37H2C.2	F11H8.1
+Y39A1C.2	F11H8.1
+Y41C4A.10	F11H8.1
+Y47D7A.1	F11H8.1
+Y47D7A.8	F11H8.1
+Y48G1C.12	F11H8.1
+Y54E5B.4	F11H8.1
+Y54G2A.31	F11H8.1
+Y60A3A.18	F11H8.1
+Y65B4BR.4	F11H8.1
+Y66D12A.17	F11H8.1
+Y67D8C.5	F11H8.1
+Y71G12B.15	F11H8.1
+Y82E9BR.15	F11H8.1
+Y87G2A.9	F11H8.1
+Y92H12A.2	F11H8.1
+Y94H6A.6	F11H8.1
+ZK1307.6	F11H8.1
+ZK287.5	F11H8.1
+ZK520.4	F11H8.1
+ZK856.1	F11H8.1
+ZK858.4	F11H8.1
+F25H2.8	F15H10.3
+F29B9.6	F15H10.3
+F35G12.9	F15H10.3
+F36A2.13	F15H10.3
+F40G9.3	F15H10.3
+F44G3.6	F15H10.3
+F45E12.3	F15H10.3
+F46A9.4	F15H10.3
+F46A9.5	F15H10.3
+F47H4.10	F15H10.3
+F48E8.7	F15H10.3
+F49E12.4	F15H10.3
+F52C6.12	F15H10.3
+F54D10.1	F15H10.3
+F55A11.3	F15H10.3
+F55B12.3	F15H10.3
+F56B3.12	F15H10.3
+F56D2.4	F15H10.3
+F58A4.10	F15H10.3
+F59E10.2	F15H10.3
+K06H7.6	F15H10.3
+K08E3.7	F15H10.3
+K08H2.1	F15H10.3
+K10B2.1	F15H10.3
+M02A10.3	F15H10.3
+M18.5	F15H10.3
+M7.1	F15H10.3
+R01H2.6	F15H10.3
+R09B3.4	F15H10.3
+R10A10.2	F15H10.3
+R12H7.3	F15H10.3
+R12H7.5	F15H10.3
+T05H10.5	F15H10.3
+T09B4.10	F15H10.3
+T10F2.4	F15H10.3
+W02A11.4	F15H10.3
+W10C6.1	F15H10.3
+W10D5.3	F15H10.3
+Y105C5B.13	F15H10.3
+Y108G3AL.1	F15H10.3
+Y110A2AM.3	F15H10.3
+Y110A2AR.2	F15H10.3
+Y110A7A.17	F15H10.3
+Y37E11AR.2	F15H10.3
+Y37H2C.2	F15H10.3
+Y39A1C.2	F15H10.3
+Y41C4A.10	F15H10.3
+Y47D7A.1	F15H10.3
+Y47D7A.8	F15H10.3
+Y48G1C.12	F15H10.3
+Y54E5B.4	F15H10.3
+Y54G2A.31	F15H10.3
+Y60A3A.18	F15H10.3
+Y65B4BR.4	F15H10.3
+Y66D12A.17	F15H10.3
+Y67D8C.5	F15H10.3
+Y71G12B.15	F15H10.3
+Y82E9BR.15	F15H10.3
+Y87G2A.9	F15H10.3
+Y92H12A.2	F15H10.3
+Y94H6A.6	F15H10.3
+ZK1307.6	F15H10.3
+ZK287.5	F15H10.3
+ZK520.4	F15H10.3
+ZK856.1	F15H10.3
+ZK858.4	F15H10.3
+F29B9.6	F25H2.8
+F35G12.9	F25H2.8
+F36A2.13	F25H2.8
+F40G9.3	F25H2.8
+F44G3.6	F25H2.8
+F45E12.3	F25H2.8
+F46A9.4	F25H2.8
+F46A9.5	F25H2.8
+F47H4.10	F25H2.8
+F48E8.7	F25H2.8
+F49E12.4	F25H2.8
+F52C6.12	F25H2.8
+F54D10.1	F25H2.8
+F55A11.3	F25H2.8
+F55B12.3	F25H2.8
+F56B3.12	F25H2.8
+F56D2.4	F25H2.8
+F58A4.10	F25H2.8
+F59E10.2	F25H2.8
+K06H7.6	F25H2.8
+K08E3.7	F25H2.8
+K08H2.1	F25H2.8
+K10B2.1	F25H2.8
+M02A10.3	F25H2.8
+M18.5	F25H2.8
+M7.1	F25H2.8
+R01H2.6	F25H2.8
+R09B3.4	F25H2.8
+R10A10.2	F25H2.8
+R12H7.3	F25H2.8
+R12H7.5	F25H2.8
+T05H10.5	F25H2.8
+T09B4.10	F25H2.8
+T10F2.4	F25H2.8
+W02A11.4	F25H2.8
+W10C6.1	F25H2.8
+W10D5.3	F25H2.8
+Y105C5B.13	F25H2.8
+Y108G3AL.1	F25H2.8
+Y110A2AM.3	F25H2.8
+Y110A2AR.2	F25H2.8
+Y110A7A.17	F25H2.8
+Y37E11AR.2	F25H2.8
+Y37H2C.2	F25H2.8
+Y39A1C.2	F25H2.8
+Y41C4A.10	F25H2.8
+Y47D7A.1	F25H2.8
+Y47D7A.8	F25H2.8
+Y48G1C.12	F25H2.8
+Y54E5B.4	F25H2.8
+Y54G2A.31	F25H2.8
+Y60A3A.18	F25H2.8
+Y65B4BR.4	F25H2.8
+Y66D12A.17	F25H2.8
+Y67D8C.5	F25H2.8
+Y71G12B.15	F25H2.8
+Y82E9BR.15	F25H2.8
+Y87G2A.9	F25H2.8
+Y92H12A.2	F25H2.8
+Y94H6A.6	F25H2.8
+ZK1307.6	F25H2.8
+ZK287.5	F25H2.8
+ZK520.4	F25H2.8
+ZK856.1	F25H2.8
+ZK858.4	F25H2.8
+F35G12.9	F29B9.6
+F36A2.13	F29B9.6
+F40G9.3	F29B9.6
+F44G3.6	F29B9.6
+F45E12.3	F29B9.6
+F46A9.4	F29B9.6
+F46A9.5	F29B9.6
+F47H4.10	F29B9.6
+F48E8.7	F29B9.6
+F49E12.4	F29B9.6
+F52C6.12	F29B9.6
+F54D10.1	F29B9.6
+F55A11.3	F29B9.6
+F55B12.3	F29B9.6
+F56B3.12	F29B9.6
+F58A4.10	F29B9.6
+F59E10.2	F29B9.6
+K06H7.6	F29B9.6
+K08E3.7	F29B9.6
+K08H2.1	F29B9.6
+K10B2.1	F29B9.6
+M02A10.3	F29B9.6
+M18.5	F29B9.6
+M7.1	F29B9.6
+R01H2.6	F29B9.6
+R09B3.4	F29B9.6
+R10A10.2	F29B9.6
+R12H7.3	F29B9.6
+R12H7.5	F29B9.6
+T05H10.5	F29B9.6
+T09B4.10	F29B9.6
+T10F2.4	F29B9.6
+W10C6.1	F29B9.6
+Y105C5B.13	F29B9.6
+Y108G3AL.1	F29B9.6
+Y110A2AM.3	F29B9.6
+Y110A2AR.2	F29B9.6
+Y110A7A.17	F29B9.6
+Y37E11AR.2	F29B9.6
+Y37H2C.2	F29B9.6
+Y39A1C.2	F29B9.6
+Y41C4A.10	F29B9.6
+Y47D7A.1	F29B9.6
+Y47D7A.8	F29B9.6
+Y48G1C.12	F29B9.6
+Y54E5B.4	F29B9.6
+Y54G2A.31	F29B9.6
+Y60A3A.18	F29B9.6
+Y65B4BR.4	F29B9.6
+Y66D12A.17	F29B9.6
+Y67D8C.5	F29B9.6
+Y71G12B.15	F29B9.6
+Y82E9BR.15	F29B9.6
+Y87G2A.9	F29B9.6
+Y92H12A.2	F29B9.6
+Y94H6A.6	F29B9.6
+ZK1307.6	F29B9.6
+ZK287.5	F29B9.6
+ZK520.4	F29B9.6
+ZK856.1	F29B9.6
+ZK858.4	F29B9.6
+F40G9.3	F35G12.9
+F44G3.6	F35G12.9
+F45E12.3	F35G12.9
+F46A9.4	F35G12.9
+F46A9.5	F35G12.9
+F47H4.10	F35G12.9
+F48E8.7	F35G12.9
+F49E12.4	F35G12.9
+F52C6.12	F35G12.9
+F54D10.1	F35G12.9
+F55A11.3	F35G12.9
+F55B12.3	F35G12.9
+F56B3.12	F35G12.9
+F56D2.4	F35G12.9
+F58A4.10	F35G12.9
+F59E10.2	F35G12.9
+K06H7.6	F35G12.9
+K08E3.7	F35G12.9
+K08H2.1	F35G12.9
+K10B2.1	F35G12.9
+M02A10.3	F35G12.9
+M18.5	F35G12.9
+R01H2.6	F35G12.9
+R09B3.4	F35G12.9
+R10A10.2	F35G12.9
+R12H7.3	F35G12.9
+R12H7.5	F35G12.9
+T05H10.5	F35G12.9
+T09B4.10	F35G12.9
+T10F2.4	F35G12.9
+W02A11.4	F35G12.9
+W10C6.1	F35G12.9
+W10D5.3	F35G12.9
+Y105C5B.13	F35G12.9
+Y108G3AL.1	F35G12.9
+Y110A2AM.3	F35G12.9
+Y110A2AR.2	F35G12.9
+Y110A7A.17	F35G12.9
+Y37E11AR.2	F35G12.9
+Y37H2C.2	F35G12.9
+Y41C4A.10	F35G12.9
+Y47D7A.1	F35G12.9
+Y47D7A.8	F35G12.9
+Y48G1C.12	F35G12.9
+Y54E5B.4	F35G12.9
+Y54G2A.31	F35G12.9
+Y60A3A.18	F35G12.9
+Y66D12A.17	F35G12.9
+Y71G12B.15	F35G12.9
+Y82E9BR.15	F35G12.9
+Y87G2A.9	F35G12.9
+Y94H6A.6	F35G12.9
+ZK1307.6	F35G12.9
+ZK287.5	F35G12.9
+ZK520.4	F35G12.9
+ZK856.1	F35G12.9
+ZK858.4	F35G12.9
+F40G9.3	F36A2.13
+F44G3.6	F36A2.13
+F45E12.3	F36A2.13
+F46A9.4	F36A2.13
+F46A9.5	F36A2.13
+F47H4.10	F36A2.13
+F48E8.7	F36A2.13
+F49E12.4	F36A2.13
+F52C6.12	F36A2.13
+F54D10.1	F36A2.13
+F55A11.3	F36A2.13
+F55B12.3	F36A2.13
+F56B3.12	F36A2.13
+F56D2.4	F36A2.13
+F58A4.10	F36A2.13
+F59E10.2	F36A2.13
+K06H7.6	F36A2.13
+K08E3.7	F36A2.13
+K08H2.1	F36A2.13
+K10B2.1	F36A2.13
+M02A10.3	F36A2.13
+M18.5	F36A2.13
+R01H2.6	F36A2.13
+R09B3.4	F36A2.13
+R10A10.2	F36A2.13
+R12H7.3	F36A2.13
+R12H7.5	F36A2.13
+T05H10.5	F36A2.13
+T09B4.10	F36A2.13
+T10F2.4	F36A2.13
+W02A11.4	F36A2.13
+W10C6.1	F36A2.13
+W10D5.3	F36A2.13
+Y105C5B.13	F36A2.13
+Y108G3AL.1	F36A2.13
+Y110A2AM.3	F36A2.13
+Y110A2AR.2	F36A2.13
+Y110A7A.17	F36A2.13
+Y37E11AR.2	F36A2.13
+Y37H2C.2	F36A2.13
+Y41C4A.10	F36A2.13
+Y47D7A.1	F36A2.13
+Y47D7A.8	F36A2.13
+Y48G1C.12	F36A2.13
+Y54E5B.4	F36A2.13
+Y54G2A.31	F36A2.13
+Y60A3A.18	F36A2.13
+Y66D12A.17	F36A2.13
+Y71G12B.15	F36A2.13
+Y82E9BR.15	F36A2.13
+Y87G2A.9	F36A2.13
+Y94H6A.6	F36A2.13
+ZK1307.6	F36A2.13
+ZK287.5	F36A2.13
+ZK520.4	F36A2.13
+ZK856.1	F36A2.13
+ZK858.4	F36A2.13
+F44G3.6	F40G9.3
+F45E12.3	F40G9.3
+F46A9.4	F40G9.3
+F46A9.5	F40G9.3
+F47H4.10	F40G9.3
+F48E8.7	F40G9.3
+F49E12.4	F40G9.3
+F52C6.12	F40G9.3
+F54D10.1	F40G9.3
+F55A11.3	F40G9.3
+F55B12.3	F40G9.3
+F56B3.12	F40G9.3
+F56D2.4	F40G9.3
+F58A4.10	F40G9.3
+F59E10.2	F40G9.3
+K06H7.6	F40G9.3
+K08E3.7	F40G9.3
+K08H2.1	F40G9.3
+K10B2.1	F40G9.3
+M02A10.3	F40G9.3
+M18.5	F40G9.3
+M7.1	F40G9.3
+R01H2.6	F40G9.3
+R09B3.4	F40G9.3
+R10A10.2	F40G9.3
+R12H7.3	F40G9.3
+R12H7.5	F40G9.3
+T05H10.5	F40G9.3
+T09B4.10	F40G9.3
+T10F2.4	F40G9.3
+W02A11.4	F40G9.3
+W10C6.1	F40G9.3
+W10D5.3	F40G9.3
+Y105C5B.13	F40G9.3
+Y108G3AL.1	F40G9.3
+Y110A2AM.3	F40G9.3
+Y110A2AR.2	F40G9.3
+Y110A7A.17	F40G9.3
+Y37E11AR.2	F40G9.3
+Y37H2C.2	F40G9.3
+Y39A1C.2	F40G9.3
+Y41C4A.10	F40G9.3
+Y47D7A.1	F40G9.3
+Y47D7A.8	F40G9.3
+Y48G1C.12	F40G9.3
+Y54E5B.4	F40G9.3
+Y54G2A.31	F40G9.3
+Y60A3A.18	F40G9.3
+Y65B4BR.4	F40G9.3
+Y66D12A.17	F40G9.3
+Y67D8C.5	F40G9.3
+Y71G12B.15	F40G9.3
+Y82E9BR.15	F40G9.3
+Y87G2A.9	F40G9.3
+Y92H12A.2	F40G9.3
+Y94H6A.6	F40G9.3
+ZK1307.6	F40G9.3
+ZK287.5	F40G9.3
+ZK520.4	F40G9.3
+ZK856.1	F40G9.3
+ZK858.4	F40G9.3
+F45E12.3	F44G3.6
+F46A9.4	F44G3.6
+F46A9.5	F44G3.6
+F47H4.10	F44G3.6
+F48E8.7	F44G3.6
+F49E12.4	F44G3.6
+F52C6.12	F44G3.6
+F54D10.1	F44G3.6
+F55A11.3	F44G3.6
+F55B12.3	F44G3.6
+F56B3.12	F44G3.6
+F56D2.4	F44G3.6
+F58A4.10	F44G3.6
+F59E10.2	F44G3.6
+K06H7.6	F44G3.6
+K08E3.7	F44G3.6
+K08H2.1	F44G3.6
+K10B2.1	F44G3.6
+M02A10.3	F44G3.6
+M18.5	F44G3.6
+M7.1	F44G3.6
+R01H2.6	F44G3.6
+R09B3.4	F44G3.6
+R10A10.2	F44G3.6
+R12H7.3	F44G3.6
+R12H7.5	F44G3.6
+T05H10.5	F44G3.6
+T09B4.10	F44G3.6
+T10F2.4	F44G3.6
+W02A11.4	F44G3.6
+W10C6.1	F44G3.6
+W10D5.3	F44G3.6
+Y105C5B.13	F44G3.6
+Y108G3AL.1	F44G3.6
+Y110A2AM.3	F44G3.6
+Y110A2AR.2	F44G3.6
+Y110A7A.17	F44G3.6
+Y37E11AR.2	F44G3.6
+Y37H2C.2	F44G3.6
+Y39A1C.2	F44G3.6
+Y41C4A.10	F44G3.6
+Y47D7A.1	F44G3.6
+Y47D7A.8	F44G3.6
+Y48G1C.12	F44G3.6
+Y54E5B.4	F44G3.6
+Y54G2A.31	F44G3.6
+Y60A3A.18	F44G3.6
+Y65B4BR.4	F44G3.6
+Y66D12A.17	F44G3.6
+Y67D8C.5	F44G3.6
+Y71G12B.15	F44G3.6
+Y82E9BR.15	F44G3.6
+Y87G2A.9	F44G3.6
+Y92H12A.2	F44G3.6
+Y94H6A.6	F44G3.6
+ZK1307.6	F44G3.6
+ZK287.5	F44G3.6
+ZK520.4	F44G3.6
+ZK856.1	F44G3.6
+ZK858.4	F44G3.6
+F46A9.4	F45E12.3
+F46A9.5	F45E12.3
+F47H4.10	F45E12.3
+F48E8.7	F45E12.3
+F49E12.4	F45E12.3
+F52C6.12	F45E12.3
+F54D10.1	F45E12.3
+F55A11.3	F45E12.3
+F55B12.3	F45E12.3
+F56B3.12	F45E12.3
+F56D2.4	F45E12.3
+F58A4.10	F45E12.3
+F59E10.2	F45E12.3
+K06H7.6	F45E12.3
+K08E3.7	F45E12.3
+K08H2.1	F45E12.3
+K10B2.1	F45E12.3
+M02A10.3	F45E12.3
+M7.1	F45E12.3
+R01H2.6	F45E12.3
+R09B3.4	F45E12.3
+R10A10.2	F45E12.3
+R12H7.3	F45E12.3
+R12H7.5	F45E12.3
+T05H10.5	F45E12.3
+T09B4.10	F45E12.3
+T10F2.4	F45E12.3
+W02A11.4	F45E12.3
+W10C6.1	F45E12.3
+W10D5.3	F45E12.3
+Y105C5B.13	F45E12.3
+Y108G3AL.1	F45E12.3
+Y110A2AM.3	F45E12.3
+Y110A2AR.2	F45E12.3
+Y110A7A.17	F45E12.3
+Y37E11AR.2	F45E12.3
+Y37H2C.2	F45E12.3
+Y39A1C.2	F45E12.3
+Y41C4A.10	F45E12.3
+Y47D7A.1	F45E12.3
+Y47D7A.8	F45E12.3
+Y48G1C.12	F45E12.3
+Y54E5B.4	F45E12.3
+Y54G2A.31	F45E12.3
+Y60A3A.18	F45E12.3
+Y65B4BR.4	F45E12.3
+Y66D12A.17	F45E12.3
+Y67D8C.5	F45E12.3
+Y71G12B.15	F45E12.3
+Y82E9BR.15	F45E12.3
+Y87G2A.9	F45E12.3
+Y92H12A.2	F45E12.3
+Y94H6A.6	F45E12.3
+ZK1307.6	F45E12.3
+ZK520.4	F45E12.3
+ZK856.1	F45E12.3
+ZK858.4	F45E12.3
+F46A9.5	F46A9.4
+F47H4.10	F46A9.4
+F48E8.7	F46A9.4
+F49E12.4	F46A9.4
+F52C6.12	F46A9.4
+F54D10.1	F46A9.4
+F55A11.3	F46A9.4
+F55B12.3	F46A9.4
+F56B3.12	F46A9.4
+F56D2.4	F46A9.4
+F58A4.10	F46A9.4
+F59E10.2	F46A9.4
+K06H7.6	F46A9.4
+K08E3.7	F46A9.4
+K08H2.1	F46A9.4
+K10B2.1	F46A9.4
+M02A10.3	F46A9.4
+M18.5	F46A9.4
+M7.1	F46A9.4
+R01H2.6	F46A9.4
+R09B3.4	F46A9.4
+R10A10.2	F46A9.4
+R12H7.3	F46A9.4
+R12H7.5	F46A9.4
+T05H10.5	F46A9.4
+T09B4.10	F46A9.4
+T10F2.4	F46A9.4
+W02A11.4	F46A9.4
+W10C6.1	F46A9.4
+W10D5.3	F46A9.4
+Y105C5B.13	F46A9.4
+Y108G3AL.1	F46A9.4
+Y110A2AM.3	F46A9.4
+Y110A2AR.2	F46A9.4
+Y110A7A.17	F46A9.4
+Y37E11AR.2	F46A9.4
+Y37H2C.2	F46A9.4
+Y39A1C.2	F46A9.4
+Y41C4A.10	F46A9.4
+Y47D7A.1	F46A9.4
+Y47D7A.8	F46A9.4
+Y48G1C.12	F46A9.4
+Y54E5B.4	F46A9.4
+Y54G2A.31	F46A9.4
+Y60A3A.18	F46A9.4
+Y65B4BR.4	F46A9.4
+Y66D12A.17	F46A9.4
+Y67D8C.5	F46A9.4
+Y71G12B.15	F46A9.4
+Y82E9BR.15	F46A9.4
+Y87G2A.9	F46A9.4
+Y92H12A.2	F46A9.4
+Y94H6A.6	F46A9.4
+ZK1307.6	F46A9.4
+ZK287.5	F46A9.4
+ZK520.4	F46A9.4
+ZK856.1	F46A9.4
+ZK858.4	F46A9.4
+F47H4.10	F46A9.5
+F48E8.7	F46A9.5
+F49E12.4	F46A9.5
+F52C6.12	F46A9.5
+F54D10.1	F46A9.5
+F55A11.3	F46A9.5
+F55B12.3	F46A9.5
+F56B3.12	F46A9.5
+F56D2.4	F46A9.5
+F58A4.10	F46A9.5
+F59E10.2	F46A9.5
+K06H7.6	F46A9.5
+K08E3.7	F46A9.5
+K08H2.1	F46A9.5
+K10B2.1	F46A9.5
+M02A10.3	F46A9.5
+M18.5	F46A9.5
+M7.1	F46A9.5
+R01H2.6	F46A9.5
+R09B3.4	F46A9.5
+R10A10.2	F46A9.5
+R12H7.3	F46A9.5
+R12H7.5	F46A9.5
+T05H10.5	F46A9.5
+T09B4.10	F46A9.5
+T10F2.4	F46A9.5
+W02A11.4	F46A9.5
+W10C6.1	F46A9.5
+W10D5.3	F46A9.5
+Y105C5B.13	F46A9.5
+Y108G3AL.1	F46A9.5
+Y110A2AM.3	F46A9.5
+Y110A2AR.2	F46A9.5
+Y110A7A.17	F46A9.5
+Y37E11AR.2	F46A9.5
+Y37H2C.2	F46A9.5
+Y39A1C.2	F46A9.5
+Y41C4A.10	F46A9.5
+Y47D7A.1	F46A9.5
+Y47D7A.8	F46A9.5
+Y48G1C.12	F46A9.5
+Y54E5B.4	F46A9.5
+Y54G2A.31	F46A9.5
+Y60A3A.18	F46A9.5
+Y65B4BR.4	F46A9.5
+Y66D12A.17	F46A9.5
+Y67D8C.5	F46A9.5
+Y71G12B.15	F46A9.5
+Y82E9BR.15	F46A9.5
+Y87G2A.9	F46A9.5
+Y92H12A.2	F46A9.5
+Y94H6A.6	F46A9.5
+ZK1307.6	F46A9.5
+ZK287.5	F46A9.5
+ZK520.4	F46A9.5
+ZK856.1	F46A9.5
+ZK858.4	F46A9.5
+F48E8.7	F47H4.10
+F49E12.4	F47H4.10
+F52C6.12	F47H4.10
+F54D10.1	F47H4.10
+F55A11.3	F47H4.10
+F55B12.3	F47H4.10
+F56B3.12	F47H4.10
+F56D2.4	F47H4.10
+F58A4.10	F47H4.10
+F59E10.2	F47H4.10
+K06H7.6	F47H4.10
+K08E3.7	F47H4.10
+K08H2.1	F47H4.10
+K10B2.1	F47H4.10
+M02A10.3	F47H4.10
+M18.5	F47H4.10
+M7.1	F47H4.10
+R01H2.6	F47H4.10
+R09B3.4	F47H4.10
+R10A10.2	F47H4.10
+R12H7.3	F47H4.10
+R12H7.5	F47H4.10
+T05H10.5	F47H4.10
+T09B4.10	F47H4.10
+T10F2.4	F47H4.10
+W02A11.4	F47H4.10
+W10C6.1	F47H4.10
+W10D5.3	F47H4.10
+Y105C5B.13	F47H4.10
+Y108G3AL.1	F47H4.10
+Y110A2AM.3	F47H4.10
+Y110A2AR.2	F47H4.10
+Y110A7A.17	F47H4.10
+Y37E11AR.2	F47H4.10
+Y37H2C.2	F47H4.10
+Y39A1C.2	F47H4.10
+Y41C4A.10	F47H4.10
+Y47D7A.1	F47H4.10
+Y47D7A.8	F47H4.10
+Y48G1C.12	F47H4.10
+Y54E5B.4	F47H4.10
+Y54G2A.31	F47H4.10
+Y60A3A.18	F47H4.10
+Y65B4BR.4	F47H4.10
+Y66D12A.17	F47H4.10
+Y67D8C.5	F47H4.10
+Y71G12B.15	F47H4.10
+Y82E9BR.15	F47H4.10
+Y87G2A.9	F47H4.10
+Y92H12A.2	F47H4.10
+Y94H6A.6	F47H4.10
+ZK1307.6	F47H4.10
+ZK287.5	F47H4.10
+ZK520.4	F47H4.10
+ZK856.1	F47H4.10
+ZK858.4	F47H4.10
+F49E12.4	F48E8.7
+F52C6.12	F48E8.7
+F54D10.1	F48E8.7
+F55A11.3	F48E8.7
+F55B12.3	F48E8.7
+F56B3.12	F48E8.7
+F56D2.4	F48E8.7
+F58A4.10	F48E8.7
+F59E10.2	F48E8.7
+K06H7.6	F48E8.7
+K08E3.7	F48E8.7
+K08H2.1	F48E8.7
+K10B2.1	F48E8.7
+M02A10.3	F48E8.7
+M18.5	F48E8.7
+M7.1	F48E8.7
+R01H2.6	F48E8.7
+R09B3.4	F48E8.7
+R10A10.2	F48E8.7
+R12H7.3	F48E8.7
+R12H7.5	F48E8.7
+T05H10.5	F48E8.7
+T09B4.10	F48E8.7
+T10F2.4	F48E8.7
+W02A11.4	F48E8.7
+W10C6.1	F48E8.7
+W10D5.3	F48E8.7
+Y105C5B.13	F48E8.7
+Y108G3AL.1	F48E8.7
+Y110A2AM.3	F48E8.7
+Y110A2AR.2	F48E8.7
+Y110A7A.17	F48E8.7
+Y37E11AR.2	F48E8.7
+Y37H2C.2	F48E8.7
+Y39A1C.2	F48E8.7
+Y41C4A.10	F48E8.7
+Y47D7A.1	F48E8.7
+Y47D7A.8	F48E8.7
+Y48G1C.12	F48E8.7
+Y54E5B.4	F48E8.7
+Y54G2A.31	F48E8.7
+Y60A3A.18	F48E8.7
+Y65B4BR.4	F48E8.7
+Y66D12A.17	F48E8.7
+Y67D8C.5	F48E8.7
+Y71G12B.15	F48E8.7
+Y82E9BR.15	F48E8.7
+Y87G2A.9	F48E8.7
+Y92H12A.2	F48E8.7
+Y94H6A.6	F48E8.7
+ZK1307.6	F48E8.7
+ZK287.5	F48E8.7
+ZK520.4	F48E8.7
+ZK856.1	F48E8.7
+ZK858.4	F48E8.7
+F52C6.12	F49E12.4
+F54D10.1	F49E12.4
+F55A11.3	F49E12.4
+F55B12.3	F49E12.4
+F56B3.12	F49E12.4
+F56D2.4	F49E12.4
+F58A4.10	F49E12.4
+F59E10.2	F49E12.4
+K06H7.6	F49E12.4
+K08E3.7	F49E12.4
+K08H2.1	F49E12.4
+K10B2.1	F49E12.4
+M02A10.3	F49E12.4
+M18.5	F49E12.4
+M7.1	F49E12.4
+R01H2.6	F49E12.4
+R09B3.4	F49E12.4
+R10A10.2	F49E12.4
+R12H7.3	F49E12.4
+R12H7.5	F49E12.4
+T05H10.5	F49E12.4
+T09B4.10	F49E12.4
+T10F2.4	F49E12.4
+W02A11.4	F49E12.4
+W10C6.1	F49E12.4
+W10D5.3	F49E12.4
+Y105C5B.13	F49E12.4
+Y108G3AL.1	F49E12.4
+Y110A2AM.3	F49E12.4
+Y110A2AR.2	F49E12.4
+Y110A7A.17	F49E12.4
+Y37E11AR.2	F49E12.4
+Y37H2C.2	F49E12.4
+Y39A1C.2	F49E12.4
+Y41C4A.10	F49E12.4
+Y47D7A.1	F49E12.4
+Y47D7A.8	F49E12.4
+Y48G1C.12	F49E12.4
+Y54E5B.4	F49E12.4
+Y54G2A.31	F49E12.4
+Y60A3A.18	F49E12.4
+Y65B4BR.4	F49E12.4
+Y66D12A.17	F49E12.4
+Y67D8C.5	F49E12.4
+Y71G12B.15	F49E12.4
+Y82E9BR.15	F49E12.4
+Y87G2A.9	F49E12.4
+Y92H12A.2	F49E12.4
+Y94H6A.6	F49E12.4
+ZK1307.6	F49E12.4
+ZK287.5	F49E12.4
+ZK520.4	F49E12.4
+ZK856.1	F49E12.4
+ZK858.4	F49E12.4
+F54D10.1	F52C6.12
+F55A11.3	F52C6.12
+F55B12.3	F52C6.12
+F56B3.12	F52C6.12
+F56D2.4	F52C6.12
+F58A4.10	F52C6.12
+F59E10.2	F52C6.12
+K06H7.6	F52C6.12
+K08E3.7	F52C6.12
+K08H2.1	F52C6.12
+K10B2.1	F52C6.12
+M02A10.3	F52C6.12
+M18.5	F52C6.12
+M7.1	F52C6.12
+R01H2.6	F52C6.12
+R09B3.4	F52C6.12
+R10A10.2	F52C6.12
+R12H7.3	F52C6.12
+R12H7.5	F52C6.12
+T05H10.5	F52C6.12
+T09B4.10	F52C6.12
+T10F2.4	F52C6.12
+W02A11.4	F52C6.12
+W10C6.1	F52C6.12
+W10D5.3	F52C6.12
+Y105C5B.13	F52C6.12
+Y108G3AL.1	F52C6.12
+Y110A2AM.3	F52C6.12
+Y110A2AR.2	F52C6.12
+Y110A7A.17	F52C6.12
+Y37E11AR.2	F52C6.12
+Y37H2C.2	F52C6.12
+Y39A1C.2	F52C6.12
+Y41C4A.10	F52C6.12
+Y47D7A.1	F52C6.12
+Y47D7A.8	F52C6.12
+Y48G1C.12	F52C6.12
+Y54E5B.4	F52C6.12
+Y54G2A.31	F52C6.12
+Y60A3A.18	F52C6.12
+Y65B4BR.4	F52C6.12
+Y66D12A.17	F52C6.12
+Y67D8C.5	F52C6.12
+Y71G12B.15	F52C6.12
+Y82E9BR.15	F52C6.12
+Y87G2A.9	F52C6.12
+Y92H12A.2	F52C6.12
+Y94H6A.6	F52C6.12
+ZK1307.6	F52C6.12
+ZK287.5	F52C6.12
+ZK520.4	F52C6.12
+ZK856.1	F52C6.12
+ZK858.4	F52C6.12
+F55A11.3	F54D10.1
+F55B12.3	F54D10.1
+F56B3.12	F54D10.1
+F56D2.4	F54D10.1
+F58A4.10	F54D10.1
+F59E10.2	F54D10.1
+K06H7.6	F54D10.1
+K08E3.7	F54D10.1
+K08H2.1	F54D10.1
+K10B2.1	F54D10.1
+M02A10.3	F54D10.1
+M18.5	F54D10.1
+M7.1	F54D10.1
+R01H2.6	F54D10.1
+R09B3.4	F54D10.1
+R10A10.2	F54D10.1
+R12H7.3	F54D10.1
+R12H7.5	F54D10.1
+T05H10.5	F54D10.1
+T09B4.10	F54D10.1
+T10F2.4	F54D10.1
+W02A11.4	F54D10.1
+W10C6.1	F54D10.1
+W10D5.3	F54D10.1
+Y105C5B.13	F54D10.1
+Y108G3AL.1	F54D10.1
+Y110A2AM.3	F54D10.1
+Y110A2AR.2	F54D10.1
+Y110A7A.17	F54D10.1
+Y37E11AR.2	F54D10.1
+Y37H2C.2	F54D10.1
+Y39A1C.2	F54D10.1
+Y41C4A.10	F54D10.1
+Y47D7A.1	F54D10.1
+Y47D7A.8	F54D10.1
+Y48G1C.12	F54D10.1
+Y54E5B.4	F54D10.1
+Y54G2A.31	F54D10.1
+Y60A3A.18	F54D10.1
+Y65B4BR.4	F54D10.1
+Y66D12A.17	F54D10.1
+Y67D8C.5	F54D10.1
+Y71G12B.15	F54D10.1
+Y82E9BR.15	F54D10.1
+Y87G2A.9	F54D10.1
+Y92H12A.2	F54D10.1
+Y94H6A.6	F54D10.1
+ZK1307.6	F54D10.1
+ZK287.5	F54D10.1
+ZK520.4	F54D10.1
+ZK856.1	F54D10.1
+ZK858.4	F54D10.1
+F55B12.3	F55A11.3
+F56B3.12	F55A11.3
+F56D2.4	F55A11.3
+F58A4.10	F55A11.3
+F59E10.2	F55A11.3
+K06H7.6	F55A11.3
+K08E3.7	F55A11.3
+K08H2.1	F55A11.3
+K10B2.1	F55A11.3
+M02A10.3	F55A11.3
+M18.5	F55A11.3
+M7.1	F55A11.3
+R01H2.6	F55A11.3
+R09B3.4	F55A11.3
+R10A10.2	F55A11.3
+R12H7.3	F55A11.3
+R12H7.5	F55A11.3
+T05H10.5	F55A11.3
+T09B4.10	F55A11.3
+T10F2.4	F55A11.3
+W02A11.4	F55A11.3
+W10C6.1	F55A11.3
+W10D5.3	F55A11.3
+Y105C5B.13	F55A11.3
+Y108G3AL.1	F55A11.3
+Y110A2AM.3	F55A11.3
+Y110A2AR.2	F55A11.3
+Y110A7A.17	F55A11.3
+Y37E11AR.2	F55A11.3
+Y37H2C.2	F55A11.3
+Y39A1C.2	F55A11.3
+Y41C4A.10	F55A11.3
+Y47D7A.1	F55A11.3
+Y47D7A.8	F55A11.3
+Y48G1C.12	F55A11.3
+Y54E5B.4	F55A11.3
+Y54G2A.31	F55A11.3
+Y60A3A.18	F55A11.3
+Y65B4BR.4	F55A11.3
+Y66D12A.17	F55A11.3
+Y67D8C.5	F55A11.3
+Y71G12B.15	F55A11.3
+Y82E9BR.15	F55A11.3
+Y87G2A.9	F55A11.3
+Y92H12A.2	F55A11.3
+Y94H6A.6	F55A11.3
+ZK1307.6	F55A11.3
+ZK287.5	F55A11.3
+ZK520.4	F55A11.3
+ZK856.1	F55A11.3
+ZK858.4	F55A11.3
+F56B3.12	F55B12.3
+F56D2.4	F55B12.3
+F58A4.10	F55B12.3
+F59E10.2	F55B12.3
+K06H7.6	F55B12.3
+K08E3.7	F55B12.3
+K08H2.1	F55B12.3
+K10B2.1	F55B12.3
+M02A10.3	F55B12.3
+M18.5	F55B12.3
+M7.1	F55B12.3
+R01H2.6	F55B12.3
+R09B3.4	F55B12.3
+R10A10.2	F55B12.3
+R12H7.3	F55B12.3
+R12H7.5	F55B12.3
+T05H10.5	F55B12.3
+T09B4.10	F55B12.3
+T10F2.4	F55B12.3
+W02A11.4	F55B12.3
+W10C6.1	F55B12.3
+W10D5.3	F55B12.3
+Y105C5B.13	F55B12.3
+Y108G3AL.1	F55B12.3
+Y110A2AM.3	F55B12.3
+Y110A2AR.2	F55B12.3
+Y110A7A.17	F55B12.3
+Y37E11AR.2	F55B12.3
+Y37H2C.2	F55B12.3
+Y39A1C.2	F55B12.3
+Y41C4A.10	F55B12.3
+Y47D7A.1	F55B12.3
+Y47D7A.8	F55B12.3
+Y48G1C.12	F55B12.3
+Y54E5B.4	F55B12.3
+Y54G2A.31	F55B12.3
+Y60A3A.18	F55B12.3
+Y65B4BR.4	F55B12.3
+Y66D12A.17	F55B12.3
+Y67D8C.5	F55B12.3
+Y71G12B.15	F55B12.3
+Y82E9BR.15	F55B12.3
+Y87G2A.9	F55B12.3
+Y92H12A.2	F55B12.3
+Y94H6A.6	F55B12.3
+ZK1307.6	F55B12.3
+ZK287.5	F55B12.3
+ZK520.4	F55B12.3
+ZK856.1	F55B12.3
+ZK858.4	F55B12.3
+F56D2.4	F56B3.12
+F58A4.10	F56B3.12
+F59E10.2	F56B3.12
+K06H7.6	F56B3.12
+K08E3.7	F56B3.12
+K08H2.1	F56B3.12
+K10B2.1	F56B3.12
+M02A10.3	F56B3.12
+M18.5	F56B3.12
+M7.1	F56B3.12
+R01H2.6	F56B3.12
+R09B3.4	F56B3.12
+R10A10.2	F56B3.12
+R12H7.3	F56B3.12
+R12H7.5	F56B3.12
+T05H10.5	F56B3.12
+T09B4.10	F56B3.12
+T10F2.4	F56B3.12
+W02A11.4	F56B3.12
+W10C6.1	F56B3.12
+W10D5.3	F56B3.12
+Y105C5B.13	F56B3.12
+Y108G3AL.1	F56B3.12
+Y110A2AM.3	F56B3.12
+Y110A2AR.2	F56B3.12
+Y110A7A.17	F56B3.12
+Y37E11AR.2	F56B3.12
+Y37H2C.2	F56B3.12
+Y39A1C.2	F56B3.12
+Y41C4A.10	F56B3.12
+Y47D7A.1	F56B3.12
+Y47D7A.8	F56B3.12
+Y48G1C.12	F56B3.12
+Y54E5B.4	F56B3.12
+Y54G2A.31	F56B3.12
+Y60A3A.18	F56B3.12
+Y65B4BR.4	F56B3.12
+Y66D12A.17	F56B3.12
+Y67D8C.5	F56B3.12
+Y71G12B.15	F56B3.12
+Y82E9BR.15	F56B3.12
+Y87G2A.9	F56B3.12
+Y92H12A.2	F56B3.12
+Y94H6A.6	F56B3.12
+ZK1307.6	F56B3.12
+ZK287.5	F56B3.12
+ZK520.4	F56B3.12
+ZK856.1	F56B3.12
+ZK858.4	F56B3.12
+F58A4.10	F56D2.4
+F59E10.2	F56D2.4
+K06H7.6	F56D2.4
+K08E3.7	F56D2.4
+K08H2.1	F56D2.4
+K10B2.1	F56D2.4
+M02A10.3	F56D2.4
+M18.5	F56D2.4
+M7.1	F56D2.4
+R01H2.6	F56D2.4
+R09B3.4	F56D2.4
+R10A10.2	F56D2.4
+R12H7.3	F56D2.4
+R12H7.5	F56D2.4
+T05H10.5	F56D2.4
+T09B4.10	F56D2.4
+T10F2.4	F56D2.4
+W02A11.4	F56D2.4
+W10C6.1	F56D2.4
+W10D5.3	F56D2.4
+Y105C5B.13	F56D2.4
+Y108G3AL.1	F56D2.4
+Y110A2AM.3	F56D2.4
+Y110A2AR.2	F56D2.4
+Y110A7A.17	F56D2.4
+Y37E11AR.2	F56D2.4
+Y37H2C.2	F56D2.4
+Y39A1C.2	F56D2.4
+Y41C4A.10	F56D2.4
+Y47D7A.1	F56D2.4
+Y47D7A.8	F56D2.4
+Y48G1C.12	F56D2.4
+Y54E5B.4	F56D2.4
+Y54G2A.31	F56D2.4
+Y60A3A.18	F56D2.4
+Y65B4BR.4	F56D2.4
+Y66D12A.17	F56D2.4
+Y67D8C.5	F56D2.4
+Y71G12B.15	F56D2.4
+Y82E9BR.15	F56D2.4
+Y87G2A.9	F56D2.4
+Y92H12A.2	F56D2.4
+Y94H6A.6	F56D2.4
+ZK1307.6	F56D2.4
+ZK287.5	F56D2.4
+ZK520.4	F56D2.4
+ZK856.1	F56D2.4
+ZK858.4	F56D2.4
+F59E10.2	F58A4.10
+K06H7.6	F58A4.10
+K08E3.7	F58A4.10
+K08H2.1	F58A4.10
+K10B2.1	F58A4.10
+M02A10.3	F58A4.10
+M18.5	F58A4.10
+M7.1	F58A4.10
+R01H2.6	F58A4.10
+R09B3.4	F58A4.10
+R10A10.2	F58A4.10
+R12H7.3	F58A4.10
+R12H7.5	F58A4.10
+T05H10.5	F58A4.10
+T09B4.10	F58A4.10
+T10F2.4	F58A4.10
+W02A11.4	F58A4.10
+W10C6.1	F58A4.10
+W10D5.3	F58A4.10
+Y105C5B.13	F58A4.10
+Y108G3AL.1	F58A4.10
+Y110A2AM.3	F58A4.10
+Y110A2AR.2	F58A4.10
+Y110A7A.17	F58A4.10
+Y37E11AR.2	F58A4.10
+Y37H2C.2	F58A4.10
+Y39A1C.2	F58A4.10
+Y41C4A.10	F58A4.10
+Y47D7A.1	F58A4.10
+Y47D7A.8	F58A4.10
+Y48G1C.12	F58A4.10
+Y54E5B.4	F58A4.10
+Y54G2A.31	F58A4.10
+Y60A3A.18	F58A4.10
+Y65B4BR.4	F58A4.10
+Y66D12A.17	F58A4.10
+Y67D8C.5	F58A4.10
+Y71G12B.15	F58A4.10
+Y82E9BR.15	F58A4.10
+Y87G2A.9	F58A4.10
+Y92H12A.2	F58A4.10
+Y94H6A.6	F58A4.10
+ZK1307.6	F58A4.10
+ZK287.5	F58A4.10
+ZK520.4	F58A4.10
+ZK856.1	F58A4.10
+ZK858.4	F58A4.10
+K06H7.6	F59E10.2
+K08E3.7	F59E10.2
+K08H2.1	F59E10.2
+K10B2.1	F59E10.2
+M02A10.3	F59E10.2
+M18.5	F59E10.2
+M7.1	F59E10.2
+R01H2.6	F59E10.2
+R09B3.4	F59E10.2
+R10A10.2	F59E10.2
+R12H7.3	F59E10.2
+R12H7.5	F59E10.2
+T05H10.5	F59E10.2
+T09B4.10	F59E10.2
+T10F2.4	F59E10.2
+W02A11.4	F59E10.2
+W10C6.1	F59E10.2
+W10D5.3	F59E10.2
+Y105C5B.13	F59E10.2
+Y108G3AL.1	F59E10.2
+Y110A2AM.3	F59E10.2
+Y110A2AR.2	F59E10.2
+Y110A7A.17	F59E10.2
+Y37E11AR.2	F59E10.2
+Y37H2C.2	F59E10.2
+Y39A1C.2	F59E10.2
+Y41C4A.10	F59E10.2
+Y47D7A.1	F59E10.2
+Y47D7A.8	F59E10.2
+Y48G1C.12	F59E10.2
+Y54E5B.4	F59E10.2
+Y54G2A.31	F59E10.2
+Y60A3A.18	F59E10.2
+Y65B4BR.4	F59E10.2
+Y66D12A.17	F59E10.2
+Y67D8C.5	F59E10.2
+Y71G12B.15	F59E10.2
+Y82E9BR.15	F59E10.2
+Y87G2A.9	F59E10.2
+Y92H12A.2	F59E10.2
+Y94H6A.6	F59E10.2
+ZK1307.6	F59E10.2
+ZK287.5	F59E10.2
+ZK520.4	F59E10.2
+ZK856.1	F59E10.2
+ZK858.4	F59E10.2
+K08E3.7	K06H7.6
+K08H2.1	K06H7.6
+K10B2.1	K06H7.6
+M02A10.3	K06H7.6
+M18.5	K06H7.6
+M7.1	K06H7.6
+R01H2.6	K06H7.6
+R09B3.4	K06H7.6
+R10A10.2	K06H7.6
+R12H7.3	K06H7.6
+R12H7.5	K06H7.6
+T05H10.5	K06H7.6
+T09B4.10	K06H7.6
+T10F2.4	K06H7.6
+W02A11.4	K06H7.6
+W10C6.1	K06H7.6
+W10D5.3	K06H7.6
+Y105C5B.13	K06H7.6
+Y108G3AL.1	K06H7.6
+Y110A2AM.3	K06H7.6
+Y110A2AR.2	K06H7.6
+Y110A7A.17	K06H7.6
+Y37E11AR.2	K06H7.6
+Y37H2C.2	K06H7.6
+Y39A1C.2	K06H7.6
+Y41C4A.10	K06H7.6
+Y47D7A.1	K06H7.6
+Y47D7A.8	K06H7.6
+Y48G1C.12	K06H7.6
+Y54E5B.4	K06H7.6
+Y54G2A.31	K06H7.6
+Y60A3A.18	K06H7.6
+Y65B4BR.4	K06H7.6
+Y66D12A.17	K06H7.6
+Y67D8C.5	K06H7.6
+Y71G12B.15	K06H7.6
+Y82E9BR.15	K06H7.6
+Y87G2A.9	K06H7.6
+Y92H12A.2	K06H7.6
+Y94H6A.6	K06H7.6
+ZK1307.6	K06H7.6
+ZK287.5	K06H7.6
+ZK520.4	K06H7.6
+ZK856.1	K06H7.6
+ZK858.4	K06H7.6
+K08H2.1	K08E3.7
+K10B2.1	K08E3.7
+M02A10.3	K08E3.7
+M18.5	K08E3.7
+M7.1	K08E3.7
+R01H2.6	K08E3.7
+R09B3.4	K08E3.7
+R10A10.2	K08E3.7
+R12H7.3	K08E3.7
+R12H7.5	K08E3.7
+T10F2.4	K08E3.7
+W02A11.4	K08E3.7
+W10C6.1	K08E3.7
+W10D5.3	K08E3.7
+Y105C5B.13	K08E3.7
+Y108G3AL.1	K08E3.7
+Y110A2AM.3	K08E3.7
+Y110A2AR.2	K08E3.7
+Y110A7A.17	K08E3.7
+Y37E11AR.2	K08E3.7
+Y37H2C.2	K08E3.7
+Y39A1C.2	K08E3.7
+Y41C4A.10	K08E3.7
+Y47D7A.1	K08E3.7
+Y47D7A.8	K08E3.7
+Y48G1C.12	K08E3.7
+Y54E5B.4	K08E3.7
+Y54G2A.31	K08E3.7
+Y60A3A.18	K08E3.7
+Y65B4BR.4	K08E3.7
+Y66D12A.17	K08E3.7
+Y67D8C.5	K08E3.7
+Y71G12B.15	K08E3.7
+Y82E9BR.15	K08E3.7
+Y87G2A.9	K08E3.7
+Y92H12A.2	K08E3.7
+Y94H6A.6	K08E3.7
+ZK1307.6	K08E3.7
+ZK287.5	K08E3.7
+ZK520.4	K08E3.7
+ZK856.1	K08E3.7
+ZK858.4	K08E3.7
+K10B2.1	K08H2.1
+M02A10.3	K08H2.1
+M18.5	K08H2.1
+M7.1	K08H2.1
+R01H2.6	K08H2.1
+R09B3.4	K08H2.1
+R10A10.2	K08H2.1
+R12H7.3	K08H2.1
+R12H7.5	K08H2.1
+T05H10.5	K08H2.1
+T09B4.10	K08H2.1
+T10F2.4	K08H2.1
+W02A11.4	K08H2.1
+W10C6.1	K08H2.1
+W10D5.3	K08H2.1
+Y105C5B.13	K08H2.1
+Y108G3AL.1	K08H2.1
+Y110A2AM.3	K08H2.1
+Y110A2AR.2	K08H2.1
+Y110A7A.17	K08H2.1
+Y37E11AR.2	K08H2.1
+Y37H2C.2	K08H2.1
+Y39A1C.2	K08H2.1
+Y41C4A.10	K08H2.1
+Y47D7A.1	K08H2.1
+Y47D7A.8	K08H2.1
+Y48G1C.12	K08H2.1
+Y54E5B.4	K08H2.1
+Y54G2A.31	K08H2.1
+Y60A3A.18	K08H2.1
+Y65B4BR.4	K08H2.1
+Y66D12A.17	K08H2.1
+Y67D8C.5	K08H2.1
+Y71G12B.15	K08H2.1
+Y82E9BR.15	K08H2.1
+Y87G2A.9	K08H2.1
+Y92H12A.2	K08H2.1
+Y94H6A.6	K08H2.1
+ZK1307.6	K08H2.1
+ZK287.5	K08H2.1
+ZK520.4	K08H2.1
+ZK856.1	K08H2.1
+ZK858.4	K08H2.1
+M02A10.3	K10B2.1
+M18.5	K10B2.1
+M7.1	K10B2.1
+R01H2.6	K10B2.1
+R09B3.4	K10B2.1
+R10A10.2	K10B2.1
+R12H7.3	K10B2.1
+R12H7.5	K10B2.1
+T05H10.5	K10B2.1
+T09B4.10	K10B2.1
+T10F2.4	K10B2.1
+W02A11.4	K10B2.1
+W10C6.1	K10B2.1
+W10D5.3	K10B2.1
+Y105C5B.13	K10B2.1
+Y108G3AL.1	K10B2.1
+Y110A2AM.3	K10B2.1
+Y110A2AR.2	K10B2.1
+Y110A7A.17	K10B2.1
+Y37E11AR.2	K10B2.1
+Y37H2C.2	K10B2.1
+Y39A1C.2	K10B2.1
+Y41C4A.10	K10B2.1
+Y47D7A.1	K10B2.1
+Y47D7A.8	K10B2.1
+Y48G1C.12	K10B2.1
+Y54E5B.4	K10B2.1
+Y54G2A.31	K10B2.1
+Y60A3A.18	K10B2.1
+Y65B4BR.4	K10B2.1
+Y66D12A.17	K10B2.1
+Y67D8C.5	K10B2.1
+Y71G12B.15	K10B2.1
+Y82E9BR.15	K10B2.1
+Y87G2A.9	K10B2.1
+Y92H12A.2	K10B2.1
+Y94H6A.6	K10B2.1
+ZK1307.6	K10B2.1
+ZK287.5	K10B2.1
+ZK520.4	K10B2.1
+ZK856.1	K10B2.1
+ZK858.4	K10B2.1
+M18.5	M02A10.3
+M7.1	M02A10.3
+R01H2.6	M02A10.3
+R09B3.4	M02A10.3
+R10A10.2	M02A10.3
+R12H7.3	M02A10.3
+R12H7.5	M02A10.3
+T05H10.5	M02A10.3
+T09B4.10	M02A10.3
+T10F2.4	M02A10.3
+W02A11.4	M02A10.3
+W10C6.1	M02A10.3
+W10D5.3	M02A10.3
+Y105C5B.13	M02A10.3
+Y108G3AL.1	M02A10.3
+Y110A2AM.3	M02A10.3
+Y110A2AR.2	M02A10.3
+Y110A7A.17	M02A10.3
+Y37E11AR.2	M02A10.3
+Y37H2C.2	M02A10.3
+Y39A1C.2	M02A10.3
+Y41C4A.10	M02A10.3
+Y47D7A.1	M02A10.3
+Y47D7A.8	M02A10.3
+Y48G1C.12	M02A10.3
+Y54E5B.4	M02A10.3
+Y54G2A.31	M02A10.3
+Y60A3A.18	M02A10.3
+Y65B4BR.4	M02A10.3
+Y66D12A.17	M02A10.3
+Y67D8C.5	M02A10.3
+Y71G12B.15	M02A10.3
+Y82E9BR.15	M02A10.3
+Y87G2A.9	M02A10.3
+Y92H12A.2	M02A10.3
+Y94H6A.6	M02A10.3
+ZK1307.6	M02A10.3
+ZK287.5	M02A10.3
+ZK520.4	M02A10.3
+ZK856.1	M02A10.3
+ZK858.4	M02A10.3
+M7.1	M18.5
+R01H2.6	M18.5
+R09B3.4	M18.5
+R10A10.2	M18.5
+R12H7.3	M18.5
+R12H7.5	M18.5
+T05H10.5	M18.5
+T09B4.10	M18.5
+T10F2.4	M18.5
+W02A11.4	M18.5
+W10C6.1	M18.5
+W10D5.3	M18.5
+Y105C5B.13	M18.5
+Y108G3AL.1	M18.5
+Y110A2AM.3	M18.5
+Y110A2AR.2	M18.5
+Y110A7A.17	M18.5
+Y37E11AR.2	M18.5
+Y37H2C.2	M18.5
+Y39A1C.2	M18.5
+Y41C4A.10	M18.5
+Y47D7A.1	M18.5
+Y47D7A.8	M18.5
+Y48G1C.12	M18.5
+Y54E5B.4	M18.5
+Y54G2A.31	M18.5
+Y60A3A.18	M18.5
+Y65B4BR.4	M18.5
+Y66D12A.17	M18.5
+Y67D8C.5	M18.5
+Y71G12B.15	M18.5
+Y82E9BR.15	M18.5
+Y87G2A.9	M18.5
+Y92H12A.2	M18.5
+Y94H6A.6	M18.5
+ZK1307.6	M18.5
+ZK520.4	M18.5
+ZK856.1	M18.5
+ZK858.4	M18.5
+R09B3.4	M7.1
+R10A10.2	M7.1
+R12H7.3	M7.1
+R12H7.5	M7.1
+T10F2.4	M7.1
+W02A11.4	M7.1
+W10C6.1	M7.1
+W10D5.3	M7.1
+Y105C5B.13	M7.1
+Y108G3AL.1	M7.1
+Y110A2AM.3	M7.1
+Y110A2AR.2	M7.1
+Y110A7A.17	M7.1
+Y37E11AR.2	M7.1
+Y37H2C.2	M7.1
+Y41C4A.10	M7.1
+Y47D7A.1	M7.1
+Y47D7A.8	M7.1
+Y48G1C.12	M7.1
+Y54E5B.4	M7.1
+Y54G2A.31	M7.1
+Y60A3A.18	M7.1
+Y66D12A.17	M7.1
+Y71G12B.15	M7.1
+Y82E9BR.15	M7.1
+Y87G2A.9	M7.1
+Y94H6A.6	M7.1
+ZK1307.6	M7.1
+ZK287.5	M7.1
+ZK520.4	M7.1
+ZK856.1	M7.1
+ZK858.4	M7.1
+R09B3.4	R01H2.6
+R10A10.2	R01H2.6
+R12H7.3	R01H2.6
+R12H7.5	R01H2.6
+T10F2.4	R01H2.6
+W02A11.4	R01H2.6
+W10C6.1	R01H2.6
+W10D5.3	R01H2.6
+Y105C5B.13	R01H2.6
+Y108G3AL.1	R01H2.6
+Y110A2AM.3	R01H2.6
+Y110A2AR.2	R01H2.6
+Y110A7A.17	R01H2.6
+Y37E11AR.2	R01H2.6
+Y37H2C.2	R01H2.6
+Y39A1C.2	R01H2.6
+Y41C4A.10	R01H2.6
+Y47D7A.1	R01H2.6
+Y47D7A.8	R01H2.6
+Y48G1C.12	R01H2.6
+Y54E5B.4	R01H2.6
+Y54G2A.31	R01H2.6
+Y60A3A.18	R01H2.6
+Y66D12A.17	R01H2.6
+Y67D8C.5	R01H2.6
+Y71G12B.15	R01H2.6
+Y82E9BR.15	R01H2.6
+Y87G2A.9	R01H2.6
+Y92H12A.2	R01H2.6
+Y94H6A.6	R01H2.6
+ZK1307.6	R01H2.6
+ZK287.5	R01H2.6
+ZK520.4	R01H2.6
+ZK856.1	R01H2.6
+ZK858.4	R01H2.6
+R10A10.2	R09B3.4
+R12H7.3	R09B3.4
+R12H7.5	R09B3.4
+T05H10.5	R09B3.4
+T09B4.10	R09B3.4
+T10F2.4	R09B3.4
+W02A11.4	R09B3.4
+W10C6.1	R09B3.4
+W10D5.3	R09B3.4
+Y105C5B.13	R09B3.4
+Y108G3AL.1	R09B3.4
+Y110A2AM.3	R09B3.4
+Y110A2AR.2	R09B3.4
+Y110A7A.17	R09B3.4
+Y37E11AR.2	R09B3.4
+Y37H2C.2	R09B3.4
+Y39A1C.2	R09B3.4
+Y41C4A.10	R09B3.4
+Y47D7A.1	R09B3.4
+Y47D7A.8	R09B3.4
+Y48G1C.12	R09B3.4
+Y54E5B.4	R09B3.4
+Y54G2A.31	R09B3.4
+Y60A3A.18	R09B3.4
+Y65B4BR.4	R09B3.4
+Y66D12A.17	R09B3.4
+Y67D8C.5	R09B3.4
+Y71G12B.15	R09B3.4
+Y82E9BR.15	R09B3.4
+Y87G2A.9	R09B3.4
+Y92H12A.2	R09B3.4
+Y94H6A.6	R09B3.4
+ZK1307.6	R09B3.4
+ZK287.5	R09B3.4
+ZK520.4	R09B3.4
+ZK856.1	R09B3.4
+ZK858.4	R09B3.4
+R12H7.3	R10A10.2
+R12H7.5	R10A10.2
+T05H10.5	R10A10.2
+T09B4.10	R10A10.2
+T10F2.4	R10A10.2
+W02A11.4	R10A10.2
+W10C6.1	R10A10.2
+W10D5.3	R10A10.2
+Y105C5B.13	R10A10.2
+Y108G3AL.1	R10A10.2
+Y110A2AM.3	R10A10.2
+Y110A2AR.2	R10A10.2
+Y110A7A.17	R10A10.2
+Y37E11AR.2	R10A10.2
+Y37H2C.2	R10A10.2
+Y39A1C.2	R10A10.2
+Y41C4A.10	R10A10.2
+Y47D7A.1	R10A10.2
+Y47D7A.8	R10A10.2
+Y48G1C.12	R10A10.2
+Y54E5B.4	R10A10.2
+Y54G2A.31	R10A10.2
+Y60A3A.18	R10A10.2
+Y65B4BR.4	R10A10.2
+Y66D12A.17	R10A10.2
+Y67D8C.5	R10A10.2
+Y71G12B.15	R10A10.2
+Y82E9BR.15	R10A10.2
+Y87G2A.9	R10A10.2
+Y92H12A.2	R10A10.2
+Y94H6A.6	R10A10.2
+ZK1307.6	R10A10.2
+ZK287.5	R10A10.2
+ZK520.4	R10A10.2
+ZK856.1	R10A10.2
+ZK858.4	R10A10.2
+R12H7.5	R12H7.3
+T05H10.5	R12H7.3
+T09B4.10	R12H7.3
+T10F2.4	R12H7.3
+W02A11.4	R12H7.3
+W10C6.1	R12H7.3
+W10D5.3	R12H7.3
+Y105C5B.13	R12H7.3
+Y108G3AL.1	R12H7.3
+Y110A2AM.3	R12H7.3
+Y110A2AR.2	R12H7.3
+Y110A7A.17	R12H7.3
+Y37E11AR.2	R12H7.3
+Y37H2C.2	R12H7.3
+Y39A1C.2	R12H7.3
+Y41C4A.10	R12H7.3
+Y47D7A.1	R12H7.3
+Y47D7A.8	R12H7.3
+Y48G1C.12	R12H7.3
+Y54E5B.4	R12H7.3
+Y54G2A.31	R12H7.3
+Y60A3A.18	R12H7.3
+Y65B4BR.4	R12H7.3
+Y66D12A.17	R12H7.3
+Y67D8C.5	R12H7.3
+Y71G12B.15	R12H7.3
+Y82E9BR.15	R12H7.3
+Y87G2A.9	R12H7.3
+Y92H12A.2	R12H7.3
+Y94H6A.6	R12H7.3
+ZK1307.6	R12H7.3
+ZK287.5	R12H7.3
+ZK520.4	R12H7.3
+ZK856.1	R12H7.3
+ZK858.4	R12H7.3
+T05H10.5	R12H7.5
+T09B4.10	R12H7.5
+T10F2.4	R12H7.5
+W02A11.4	R12H7.5
+W10C6.1	R12H7.5
+W10D5.3	R12H7.5
+Y105C5B.13	R12H7.5
+Y108G3AL.1	R12H7.5
+Y110A2AM.3	R12H7.5
+Y110A2AR.2	R12H7.5
+Y110A7A.17	R12H7.5
+Y37E11AR.2	R12H7.5
+Y37H2C.2	R12H7.5
+Y39A1C.2	R12H7.5
+Y41C4A.10	R12H7.5
+Y47D7A.1	R12H7.5
+Y47D7A.8	R12H7.5
+Y48G1C.12	R12H7.5
+Y54E5B.4	R12H7.5
+Y54G2A.31	R12H7.5
+Y60A3A.18	R12H7.5
+Y65B4BR.4	R12H7.5
+Y66D12A.17	R12H7.5
+Y67D8C.5	R12H7.5
+Y71G12B.15	R12H7.5
+Y82E9BR.15	R12H7.5
+Y87G2A.9	R12H7.5
+Y92H12A.2	R12H7.5
+Y94H6A.6	R12H7.5
+ZK1307.6	R12H7.5
+ZK287.5	R12H7.5
+ZK520.4	R12H7.5
+ZK856.1	R12H7.5
+ZK858.4	R12H7.5
+T10F2.4	T05H10.5
+W02A11.4	T05H10.5
+W10C6.1	T05H10.5
+W10D5.3	T05H10.5
+Y105C5B.13	T05H10.5
+Y108G3AL.1	T05H10.5
+Y110A2AM.3	T05H10.5
+Y110A2AR.2	T05H10.5
+Y110A7A.17	T05H10.5
+Y37E11AR.2	T05H10.5
+Y37H2C.2	T05H10.5
+Y39A1C.2	T05H10.5
+Y41C4A.10	T05H10.5
+Y47D7A.1	T05H10.5
+Y47D7A.8	T05H10.5
+Y48G1C.12	T05H10.5
+Y54E5B.4	T05H10.5
+Y54G2A.31	T05H10.5
+Y60A3A.18	T05H10.5
+Y66D12A.17	T05H10.5
+Y67D8C.5	T05H10.5
+Y71G12B.15	T05H10.5
+Y82E9BR.15	T05H10.5
+Y87G2A.9	T05H10.5
+Y92H12A.2	T05H10.5
+Y94H6A.6	T05H10.5
+ZK1307.6	T05H10.5
+ZK287.5	T05H10.5
+ZK520.4	T05H10.5
+ZK856.1	T05H10.5
+ZK858.4	T05H10.5
+T10F2.4	T09B4.10
+W02A11.4	T09B4.10
+W10C6.1	T09B4.10
+W10D5.3	T09B4.10
+Y105C5B.13	T09B4.10
+Y108G3AL.1	T09B4.10
+Y110A2AM.3	T09B4.10
+Y110A2AR.2	T09B4.10
+Y110A7A.17	T09B4.10
+Y37E11AR.2	T09B4.10
+Y37H2C.2	T09B4.10
+Y39A1C.2	T09B4.10
+Y41C4A.10	T09B4.10
+Y47D7A.1	T09B4.10
+Y47D7A.8	T09B4.10
+Y48G1C.12	T09B4.10
+Y54E5B.4	T09B4.10
+Y54G2A.31	T09B4.10
+Y60A3A.18	T09B4.10
+Y66D12A.17	T09B4.10
+Y67D8C.5	T09B4.10
+Y71G12B.15	T09B4.10
+Y82E9BR.15	T09B4.10
+Y87G2A.9	T09B4.10
+Y92H12A.2	T09B4.10
+Y94H6A.6	T09B4.10
+ZK1307.6	T09B4.10
+ZK287.5	T09B4.10
+ZK520.4	T09B4.10
+ZK856.1	T09B4.10
+ZK858.4	T09B4.10
+W02A11.4	T10F2.4
+W10C6.1	T10F2.4
+W10D5.3	T10F2.4
+Y105C5B.13	T10F2.4
+Y108G3AL.1	T10F2.4
+Y110A2AM.3	T10F2.4
+Y110A2AR.2	T10F2.4
+Y110A7A.17	T10F2.4
+Y37E11AR.2	T10F2.4
+Y37H2C.2	T10F2.4
+Y39A1C.2	T10F2.4
+Y41C4A.10	T10F2.4
+Y47D7A.1	T10F2.4
+Y47D7A.8	T10F2.4
+Y48G1C.12	T10F2.4
+Y54E5B.4	T10F2.4
+Y54G2A.31	T10F2.4
+Y60A3A.18	T10F2.4
+Y65B4BR.4	T10F2.4
+Y66D12A.17	T10F2.4
+Y67D8C.5	T10F2.4
+Y71G12B.15	T10F2.4
+Y82E9BR.15	T10F2.4
+Y87G2A.9	T10F2.4
+Y92H12A.2	T10F2.4
+Y94H6A.6	T10F2.4
+ZK1307.6	T10F2.4
+ZK287.5	T10F2.4
+ZK520.4	T10F2.4
+ZK856.1	T10F2.4
+ZK858.4	T10F2.4
+W10C6.1	W02A11.4
+Y105C5B.13	W02A11.4
+Y108G3AL.1	W02A11.4
+Y110A2AM.3	W02A11.4
+Y110A2AR.2	W02A11.4
+Y110A7A.17	W02A11.4
+Y37E11AR.2	W02A11.4
+Y37H2C.2	W02A11.4
+Y39A1C.2	W02A11.4
+Y41C4A.10	W02A11.4
+Y47D7A.1	W02A11.4
+Y47D7A.8	W02A11.4
+Y48G1C.12	W02A11.4
+Y54E5B.4	W02A11.4
+Y54G2A.31	W02A11.4
+Y60A3A.18	W02A11.4
+Y65B4BR.4	W02A11.4
+Y66D12A.17	W02A11.4
+Y67D8C.5	W02A11.4
+Y71G12B.15	W02A11.4
+Y82E9BR.15	W02A11.4
+Y87G2A.9	W02A11.4
+Y92H12A.2	W02A11.4
+Y94H6A.6	W02A11.4
+ZK1307.6	W02A11.4
+ZK287.5	W02A11.4
+ZK520.4	W02A11.4
+ZK856.1	W02A11.4
+ZK858.4	W02A11.4
+W10D5.3	W10C6.1
+Y105C5B.13	W10C6.1
+Y108G3AL.1	W10C6.1
+Y110A2AM.3	W10C6.1
+Y110A2AR.2	W10C6.1
+Y110A7A.17	W10C6.1
+Y37E11AR.2	W10C6.1
+Y37H2C.2	W10C6.1
+Y39A1C.2	W10C6.1
+Y41C4A.10	W10C6.1
+Y47D7A.1	W10C6.1
+Y47D7A.8	W10C6.1
+Y48G1C.12	W10C6.1
+Y54E5B.4	W10C6.1
+Y54G2A.31	W10C6.1
+Y60A3A.18	W10C6.1
+Y65B4BR.4	W10C6.1
+Y66D12A.17	W10C6.1
+Y67D8C.5	W10C6.1
+Y71G12B.15	W10C6.1
+Y82E9BR.15	W10C6.1
+Y87G2A.9	W10C6.1
+Y92H12A.2	W10C6.1
+Y94H6A.6	W10C6.1
+ZK1307.6	W10C6.1
+ZK287.5	W10C6.1
+ZK520.4	W10C6.1
+ZK856.1	W10C6.1
+ZK858.4	W10C6.1
+Y105C5B.13	W10D5.3
+Y108G3AL.1	W10D5.3
+Y110A2AM.3	W10D5.3
+Y110A2AR.2	W10D5.3
+Y110A7A.17	W10D5.3
+Y37E11AR.2	W10D5.3
+Y37H2C.2	W10D5.3
+Y39A1C.2	W10D5.3
+Y41C4A.10	W10D5.3
+Y47D7A.1	W10D5.3
+Y47D7A.8	W10D5.3
+Y48G1C.12	W10D5.3
+Y54E5B.4	W10D5.3
+Y54G2A.31	W10D5.3
+Y60A3A.18	W10D5.3
+Y65B4BR.4	W10D5.3
+Y66D12A.17	W10D5.3
+Y67D8C.5	W10D5.3
+Y71G12B.15	W10D5.3
+Y82E9BR.15	W10D5.3
+Y87G2A.9	W10D5.3
+Y92H12A.2	W10D5.3
+Y94H6A.6	W10D5.3
+ZK1307.6	W10D5.3
+ZK287.5	W10D5.3
+ZK520.4	W10D5.3
+ZK856.1	W10D5.3
+ZK858.4	W10D5.3
+Y108G3AL.1	Y105C5B.13
+Y110A2AM.3	Y105C5B.13
+Y110A2AR.2	Y105C5B.13
+Y110A7A.17	Y105C5B.13
+Y37E11AR.2	Y105C5B.13
+Y37H2C.2	Y105C5B.13
+Y39A1C.2	Y105C5B.13
+Y41C4A.10	Y105C5B.13
+Y47D7A.1	Y105C5B.13
+Y47D7A.8	Y105C5B.13
+Y48G1C.12	Y105C5B.13
+Y54E5B.4	Y105C5B.13
+Y54G2A.31	Y105C5B.13
+Y60A3A.18	Y105C5B.13
+Y65B4BR.4	Y105C5B.13
+Y66D12A.17	Y105C5B.13
+Y67D8C.5	Y105C5B.13
+Y71G12B.15	Y105C5B.13
+Y82E9BR.15	Y105C5B.13
+Y87G2A.9	Y105C5B.13
+Y92H12A.2	Y105C5B.13
+Y94H6A.6	Y105C5B.13
+ZK1307.6	Y105C5B.13
+ZK287.5	Y105C5B.13
+ZK520.4	Y105C5B.13
+ZK856.1	Y105C5B.13
+ZK858.4	Y105C5B.13
+Y110A2AM.3	Y108G3AL.1
+Y110A2AR.2	Y108G3AL.1
+Y110A7A.17	Y108G3AL.1
+Y37E11AR.2	Y108G3AL.1
+Y37H2C.2	Y108G3AL.1
+Y39A1C.2	Y108G3AL.1
+Y41C4A.10	Y108G3AL.1
+Y47D7A.1	Y108G3AL.1
+Y47D7A.8	Y108G3AL.1
+Y48G1C.12	Y108G3AL.1
+Y54E5B.4	Y108G3AL.1
+Y54G2A.31	Y108G3AL.1
+Y60A3A.18	Y108G3AL.1
+Y65B4BR.4	Y108G3AL.1
+Y66D12A.17	Y108G3AL.1
+Y67D8C.5	Y108G3AL.1
+Y71G12B.15	Y108G3AL.1
+Y82E9BR.15	Y108G3AL.1
+Y87G2A.9	Y108G3AL.1
+Y92H12A.2	Y108G3AL.1
+Y94H6A.6	Y108G3AL.1
+ZK1307.6	Y108G3AL.1
+ZK287.5	Y108G3AL.1
+ZK520.4	Y108G3AL.1
+ZK856.1	Y108G3AL.1
+ZK858.4	Y108G3AL.1
+Y110A2AR.2	Y110A2AM.3
+Y110A7A.17	Y110A2AM.3
+Y37E11AR.2	Y110A2AM.3
+Y37H2C.2	Y110A2AM.3
+Y39A1C.2	Y110A2AM.3
+Y41C4A.10	Y110A2AM.3
+Y47D7A.1	Y110A2AM.3
+Y47D7A.8	Y110A2AM.3
+Y48G1C.12	Y110A2AM.3
+Y54E5B.4	Y110A2AM.3
+Y54G2A.31	Y110A2AM.3
+Y60A3A.18	Y110A2AM.3
+Y65B4BR.4	Y110A2AM.3
+Y66D12A.17	Y110A2AM.3
+Y67D8C.5	Y110A2AM.3
+Y71G12B.15	Y110A2AM.3
+Y82E9BR.15	Y110A2AM.3
+Y87G2A.9	Y110A2AM.3
+Y92H12A.2	Y110A2AM.3
+Y94H6A.6	Y110A2AM.3
+ZK1307.6	Y110A2AM.3
+ZK287.5	Y110A2AM.3
+ZK520.4	Y110A2AM.3
+ZK856.1	Y110A2AM.3
+ZK858.4	Y110A2AM.3
+Y110A7A.17	Y110A2AR.2
+Y37E11AR.2	Y110A2AR.2
+Y37H2C.2	Y110A2AR.2
+Y39A1C.2	Y110A2AR.2
+Y41C4A.10	Y110A2AR.2
+Y47D7A.1	Y110A2AR.2
+Y47D7A.8	Y110A2AR.2
+Y48G1C.12	Y110A2AR.2
+Y54E5B.4	Y110A2AR.2
+Y54G2A.31	Y110A2AR.2
+Y60A3A.18	Y110A2AR.2
+Y65B4BR.4	Y110A2AR.2
+Y66D12A.17	Y110A2AR.2
+Y67D8C.5	Y110A2AR.2
+Y71G12B.15	Y110A2AR.2
+Y82E9BR.15	Y110A2AR.2
+Y87G2A.9	Y110A2AR.2
+Y92H12A.2	Y110A2AR.2
+Y94H6A.6	Y110A2AR.2
+ZK1307.6	Y110A2AR.2
+ZK287.5	Y110A2AR.2
+ZK520.4	Y110A2AR.2
+ZK856.1	Y110A2AR.2
+ZK858.4	Y110A2AR.2
+Y37E11AR.2	Y110A7A.17
+Y37H2C.2	Y110A7A.17
+Y39A1C.2	Y110A7A.17
+Y41C4A.10	Y110A7A.17
+Y47D7A.1	Y110A7A.17
+Y47D7A.8	Y110A7A.17
+Y48G1C.12	Y110A7A.17
+Y54E5B.4	Y110A7A.17
+Y54G2A.31	Y110A7A.17
+Y60A3A.18	Y110A7A.17
+Y65B4BR.4	Y110A7A.17
+Y66D12A.17	Y110A7A.17
+Y67D8C.5	Y110A7A.17
+Y71G12B.15	Y110A7A.17
+Y82E9BR.15	Y110A7A.17
+Y87G2A.9	Y110A7A.17
+Y92H12A.2	Y110A7A.17
+Y94H6A.6	Y110A7A.17
+ZK1307.6	Y110A7A.17
+ZK287.5	Y110A7A.17
+ZK520.4	Y110A7A.17
+ZK856.1	Y110A7A.17
+ZK858.4	Y110A7A.17
+Y37H2C.2	Y37E11AR.2
+Y39A1C.2	Y37E11AR.2
+Y41C4A.10	Y37E11AR.2
+Y47D7A.1	Y37E11AR.2
+Y47D7A.8	Y37E11AR.2
+Y48G1C.12	Y37E11AR.2
+Y54E5B.4	Y37E11AR.2
+Y54G2A.31	Y37E11AR.2
+Y60A3A.18	Y37E11AR.2
+Y65B4BR.4	Y37E11AR.2
+Y66D12A.17	Y37E11AR.2
+Y67D8C.5	Y37E11AR.2
+Y71G12B.15	Y37E11AR.2
+Y82E9BR.15	Y37E11AR.2
+Y87G2A.9	Y37E11AR.2
+Y92H12A.2	Y37E11AR.2
+Y94H6A.6	Y37E11AR.2
+ZK1307.6	Y37E11AR.2
+ZK287.5	Y37E11AR.2
+ZK520.4	Y37E11AR.2
+ZK856.1	Y37E11AR.2
+ZK858.4	Y37E11AR.2
+Y39A1C.2	Y37H2C.2
+Y41C4A.10	Y37H2C.2
+Y47D7A.1	Y37H2C.2
+Y47D7A.8	Y37H2C.2
+Y48G1C.12	Y37H2C.2
+Y54E5B.4	Y37H2C.2
+Y54G2A.31	Y37H2C.2
+Y60A3A.18	Y37H2C.2
+Y65B4BR.4	Y37H2C.2
+Y66D12A.17	Y37H2C.2
+Y67D8C.5	Y37H2C.2
+Y71G12B.15	Y37H2C.2
+Y82E9BR.15	Y37H2C.2
+Y87G2A.9	Y37H2C.2
+Y92H12A.2	Y37H2C.2
+Y94H6A.6	Y37H2C.2
+ZK1307.6	Y37H2C.2
+ZK287.5	Y37H2C.2
+ZK520.4	Y37H2C.2
+ZK856.1	Y37H2C.2
+ZK858.4	Y37H2C.2
+Y41C4A.10	Y39A1C.2
+Y47D7A.1	Y39A1C.2
+Y47D7A.8	Y39A1C.2
+Y48G1C.12	Y39A1C.2
+Y54E5B.4	Y39A1C.2
+Y54G2A.31	Y39A1C.2
+Y60A3A.18	Y39A1C.2
+Y66D12A.17	Y39A1C.2
+Y71G12B.15	Y39A1C.2
+Y82E9BR.15	Y39A1C.2
+Y87G2A.9	Y39A1C.2
+Y94H6A.6	Y39A1C.2
+ZK1307.6	Y39A1C.2
+ZK287.5	Y39A1C.2
+ZK520.4	Y39A1C.2
+ZK856.1	Y39A1C.2
+ZK858.4	Y39A1C.2
+Y47D7A.1	Y41C4A.10
+Y47D7A.8	Y41C4A.10
+Y48G1C.12	Y41C4A.10
+Y54E5B.4	Y41C4A.10
+Y54G2A.31	Y41C4A.10
+Y60A3A.18	Y41C4A.10
+Y65B4BR.4	Y41C4A.10
+Y66D12A.17	Y41C4A.10
+Y67D8C.5	Y41C4A.10
+Y71G12B.15	Y41C4A.10
+Y82E9BR.15	Y41C4A.10
+Y87G2A.9	Y41C4A.10
+Y92H12A.2	Y41C4A.10
+Y94H6A.6	Y41C4A.10
+ZK1307.6	Y41C4A.10
+ZK287.5	Y41C4A.10
+ZK520.4	Y41C4A.10
+ZK856.1	Y41C4A.10
+ZK858.4	Y41C4A.10
+Y47D7A.8	Y47D7A.1
+Y48G1C.12	Y47D7A.1
+Y54E5B.4	Y47D7A.1
+Y54G2A.31	Y47D7A.1
+Y60A3A.18	Y47D7A.1
+Y65B4BR.4	Y47D7A.1
+Y66D12A.17	Y47D7A.1
+Y67D8C.5	Y47D7A.1
+Y71G12B.15	Y47D7A.1
+Y82E9BR.15	Y47D7A.1
+Y87G2A.9	Y47D7A.1
+Y92H12A.2	Y47D7A.1
+Y94H6A.6	Y47D7A.1
+ZK1307.6	Y47D7A.1
+ZK287.5	Y47D7A.1
+ZK520.4	Y47D7A.1
+ZK856.1	Y47D7A.1
+ZK858.4	Y47D7A.1
+Y48G1C.12	Y47D7A.8
+Y54E5B.4	Y47D7A.8
+Y54G2A.31	Y47D7A.8
+Y60A3A.18	Y47D7A.8
+Y65B4BR.4	Y47D7A.8
+Y66D12A.17	Y47D7A.8
+Y67D8C.5	Y47D7A.8
+Y71G12B.15	Y47D7A.8
+Y82E9BR.15	Y47D7A.8
+Y87G2A.9	Y47D7A.8
+Y92H12A.2	Y47D7A.8
+Y94H6A.6	Y47D7A.8
+ZK1307.6	Y47D7A.8
+ZK287.5	Y47D7A.8
+ZK520.4	Y47D7A.8
+ZK856.1	Y47D7A.8
+ZK858.4	Y47D7A.8
+Y54E5B.4	Y48G1C.12
+Y54G2A.31	Y48G1C.12
+Y60A3A.18	Y48G1C.12
+Y65B4BR.4	Y48G1C.12
+Y66D12A.17	Y48G1C.12
+Y67D8C.5	Y48G1C.12
+Y71G12B.15	Y48G1C.12
+Y82E9BR.15	Y48G1C.12
+Y87G2A.9	Y48G1C.12
+Y92H12A.2	Y48G1C.12
+Y94H6A.6	Y48G1C.12
+ZK1307.6	Y48G1C.12
+ZK287.5	Y48G1C.12
+ZK520.4	Y48G1C.12
+ZK856.1	Y48G1C.12
+ZK858.4	Y48G1C.12
+Y54G2A.31	Y54E5B.4
+Y60A3A.18	Y54E5B.4
+Y65B4BR.4	Y54E5B.4
+Y66D12A.17	Y54E5B.4
+Y67D8C.5	Y54E5B.4
+Y71G12B.15	Y54E5B.4
+Y82E9BR.15	Y54E5B.4
+Y87G2A.9	Y54E5B.4
+Y92H12A.2	Y54E5B.4
+Y94H6A.6	Y54E5B.4
+ZK1307.6	Y54E5B.4
+ZK287.5	Y54E5B.4
+ZK520.4	Y54E5B.4
+ZK856.1	Y54E5B.4
+ZK858.4	Y54E5B.4
+Y60A3A.18	Y54G2A.31
+Y65B4BR.4	Y54G2A.31
+Y66D12A.17	Y54G2A.31
+Y67D8C.5	Y54G2A.31
+Y71G12B.15	Y54G2A.31
+Y82E9BR.15	Y54G2A.31
+Y87G2A.9	Y54G2A.31
+Y92H12A.2	Y54G2A.31
+Y94H6A.6	Y54G2A.31
+ZK1307.6	Y54G2A.31
+ZK287.5	Y54G2A.31
+ZK520.4	Y54G2A.31
+ZK856.1	Y54G2A.31
+ZK858.4	Y54G2A.31
+Y65B4BR.4	Y60A3A.18
+Y66D12A.17	Y60A3A.18
+Y67D8C.5	Y60A3A.18
+Y71G12B.15	Y60A3A.18
+Y82E9BR.15	Y60A3A.18
+Y87G2A.9	Y60A3A.18
+Y92H12A.2	Y60A3A.18
+Y94H6A.6	Y60A3A.18
+ZK1307.6	Y60A3A.18
+ZK287.5	Y60A3A.18
+ZK520.4	Y60A3A.18
+ZK856.1	Y60A3A.18
+ZK858.4	Y60A3A.18
+Y66D12A.17	Y65B4BR.4
+Y71G12B.15	Y65B4BR.4
+Y82E9BR.15	Y65B4BR.4
+Y87G2A.9	Y65B4BR.4
+Y94H6A.6	Y65B4BR.4
+ZK1307.6	Y65B4BR.4
+ZK287.5	Y65B4BR.4
+ZK520.4	Y65B4BR.4
+ZK856.1	Y65B4BR.4
+ZK858.4	Y65B4BR.4
+Y67D8C.5	Y66D12A.17
+Y71G12B.15	Y66D12A.17
+Y82E9BR.15	Y66D12A.17
+Y87G2A.9	Y66D12A.17
+Y92H12A.2	Y66D12A.17
+Y94H6A.6	Y66D12A.17
+ZK1307.6	Y66D12A.17
+ZK287.5	Y66D12A.17
+ZK520.4	Y66D12A.17
+ZK856.1	Y66D12A.17
+ZK858.4	Y66D12A.17
+Y71G12B.15	Y67D8C.5
+Y82E9BR.15	Y67D8C.5
+Y87G2A.9	Y67D8C.5
+Y94H6A.6	Y67D8C.5
+ZK1307.6	Y67D8C.5
+ZK287.5	Y67D8C.5
+ZK520.4	Y67D8C.5
+ZK856.1	Y67D8C.5
+ZK858.4	Y67D8C.5
+Y82E9BR.15	Y71G12B.15
+Y87G2A.9	Y71G12B.15
+Y92H12A.2	Y71G12B.15
+Y94H6A.6	Y71G12B.15
+ZK1307.6	Y71G12B.15
+ZK287.5	Y71G12B.15
+ZK520.4	Y71G12B.15
+ZK856.1	Y71G12B.15
+ZK858.4	Y71G12B.15
+Y87G2A.9	Y82E9BR.15
+Y92H12A.2	Y82E9BR.15
+Y94H6A.6	Y82E9BR.15
+ZK1307.6	Y82E9BR.15
+ZK287.5	Y82E9BR.15
+ZK520.4	Y82E9BR.15
+ZK856.1	Y82E9BR.15
+ZK858.4	Y82E9BR.15
+Y92H12A.2	Y87G2A.9
+Y94H6A.6	Y87G2A.9
+ZK1307.6	Y87G2A.9
+ZK287.5	Y87G2A.9
+ZK520.4	Y87G2A.9
+ZK856.1	Y87G2A.9
+ZK858.4	Y87G2A.9
+Y94H6A.6	Y92H12A.2
+ZK1307.6	Y92H12A.2
+ZK287.5	Y92H12A.2
+ZK520.4	Y92H12A.2
+ZK856.1	Y92H12A.2
+ZK858.4	Y92H12A.2
+ZK1307.6	Y94H6A.6
+ZK287.5	Y94H6A.6
+ZK520.4	Y94H6A.6
+ZK856.1	Y94H6A.6
+ZK858.4	Y94H6A.6
+ZK287.5	ZK1307.6
+ZK520.4	ZK1307.6
+ZK856.1	ZK1307.6
+ZK858.4	ZK1307.6
+ZK520.4	ZK287.5
+ZK856.1	ZK287.5
+ZK858.4	ZK287.5
+ZK856.1	ZK520.4
+ZK858.4	ZK520.4
+ZK858.4	ZK856.1
+B0205.6	B0035.16
+D2023.5	B0035.16
+F11G11.9	B0035.16
+F29C4.6	B0035.16
+F29F11.3	B0035.16
+F42G8.6	B0035.16
+F49H6.5	B0035.16
+H12D21.4	B0035.16
+K10D2.7	B0035.16
+T27A3.6	B0035.16
+D2023.5	B0205.6
+F11G11.9	B0205.6
+F29C4.6	B0205.6
+F29F11.3	B0205.6
+F42G8.6	B0205.6
+F49H6.5	B0205.6
+H12D21.4	B0205.6
+K10D2.7	B0205.6
+T27A3.6	B0205.6
+F29C4.6	D2023.5
+F29F11.3	D2023.5
+F42G8.6	D2023.5
+F49H6.5	D2023.5
+K10D2.7	D2023.5
+T27A3.6	D2023.5
+F29C4.6	F11G11.9
+F29F11.3	F11G11.9
+F42G8.6	F11G11.9
+F49H6.5	F11G11.9
+K10D2.7	F11G11.9
+T27A3.6	F11G11.9
+F42G8.6	F29C4.6
+F49H6.5	F29C4.6
+H12D21.4	F29C4.6
+K10D2.7	F29C4.6
+T27A3.6	F29C4.6
+F42G8.6	F29F11.3
+F49H6.5	F29F11.3
+H12D21.4	F29F11.3
+K10D2.7	F29F11.3
+T27A3.6	F29F11.3
+F49H6.5	F42G8.6
+H12D21.4	F42G8.6
+T27A3.6	F42G8.6
+H12D21.4	F49H6.5
+K10D2.7	H12D21.4
+T27A3.6	H12D21.4
+B0361.10	B0272.2
+B0513.9	B0272.2
+C15C7.1	B0272.2
+C30A5.5	B0272.2
+F08F8.8	B0272.2
+F35C8.4	B0272.2
+F36F2.4	B0272.2
+F48F7.2	B0272.2
+F55A11.2	B0272.2
+F55A4.1	B0272.2
+F56A8.7	B0272.2
+K02D10.5	B0272.2
+M03E7.5	B0272.2
+T01B11.3	B0272.2
+T10H9.3	B0272.2
+T10H9.4	B0272.2
+T14D7.3	B0272.2
+VF39H2L.1	B0272.2
+Y22F5A.3	B0272.2
+Y57G11C.4	B0272.2
+Y59E9AL.7	B0272.2
+Y69A2AR.6	B0272.2
+ZC155.7	B0272.2
+ZK795.4	B0272.2
+B0513.9	B0361.10
+C15C7.1	B0361.10
+C30A5.5	B0361.10
+F08F8.8	B0361.10
+F35C8.4	B0361.10
+F36F2.4	B0361.10
+F48F7.2	B0361.10
+F55A11.2	B0361.10
+F55A4.1	B0361.10
+F56A8.7	B0361.10
+K02D10.5	B0361.10
+M03E7.5	B0361.10
+T01B11.3	B0361.10
+T10H9.3	B0361.10
+T10H9.4	B0361.10
+T14D7.3	B0361.10
+VF39H2L.1	B0361.10
+Y22F5A.3	B0361.10
+Y57G11C.4	B0361.10
+Y59E9AL.7	B0361.10
+Y69A2AR.6	B0361.10
+ZC155.7	B0361.10
+ZK795.4	B0361.10
+C15C7.1	B0513.9
+C30A5.5	B0513.9
+F08F8.8	B0513.9
+F35C8.4	B0513.9
+F36F2.4	B0513.9
+F48F7.2	B0513.9
+F55A11.2	B0513.9
+F55A4.1	B0513.9
+F56A8.7	B0513.9
+K02D10.5	B0513.9
+M03E7.5	B0513.9
+T01B11.3	B0513.9
+T10H9.3	B0513.9
+T10H9.4	B0513.9
+T14D7.3	B0513.9
+VF39H2L.1	B0513.9
+Y22F5A.3	B0513.9
+Y57G11C.4	B0513.9
+Y59E9AL.7	B0513.9
+Y69A2AR.6	B0513.9
+ZC155.7	B0513.9
+ZK795.4	B0513.9
+C30A5.5	C15C7.1
+F08F8.8	C15C7.1
+F36F2.4	C15C7.1
+F55A4.1	C15C7.1
+F56A8.7	C15C7.1
+K02D10.5	C15C7.1
+M03E7.5	C15C7.1
+T10H9.3	C15C7.1
+T10H9.4	C15C7.1
+T14D7.3	C15C7.1
+VF39H2L.1	C15C7.1
+Y22F5A.3	C15C7.1
+Y57G11C.4	C15C7.1
+Y59E9AL.7	C15C7.1
+Y69A2AR.6	C15C7.1
+ZC155.7	C15C7.1
+ZK795.4	C15C7.1
+F08F8.8	C30A5.5
+F35C8.4	C30A5.5
+F36F2.4	C30A5.5
+F48F7.2	C30A5.5
+F55A11.2	C30A5.5
+F55A4.1	C30A5.5
+F56A8.7	C30A5.5
+K02D10.5	C30A5.5
+M03E7.5	C30A5.5
+T01B11.3	C30A5.5
+T10H9.3	C30A5.5
+T10H9.4	C30A5.5
+T14D7.3	C30A5.5
+VF39H2L.1	C30A5.5
+Y22F5A.3	C30A5.5
+Y57G11C.4	C30A5.5
+Y59E9AL.7	C30A5.5
+Y69A2AR.6	C30A5.5
+ZC155.7	C30A5.5
+ZK795.4	C30A5.5
+F35C8.4	F08F8.8
+F36F2.4	F08F8.8
+F48F7.2	F08F8.8
+F55A11.2	F08F8.8
+F55A4.1	F08F8.8
+F56A8.7	F08F8.8
+K02D10.5	F08F8.8
+M03E7.5	F08F8.8
+T01B11.3	F08F8.8
+T10H9.3	F08F8.8
+T10H9.4	F08F8.8
+T14D7.3	F08F8.8
+VF39H2L.1	F08F8.8
+Y22F5A.3	F08F8.8
+Y57G11C.4	F08F8.8
+Y59E9AL.7	F08F8.8
+Y69A2AR.6	F08F8.8
+ZC155.7	F08F8.8
+ZK795.4	F08F8.8
+F36F2.4	F35C8.4
+F55A4.1	F35C8.4
+F56A8.7	F35C8.4
+K02D10.5	F35C8.4
+M03E7.5	F35C8.4
+T10H9.3	F35C8.4
+T10H9.4	F35C8.4
+T14D7.3	F35C8.4
+VF39H2L.1	F35C8.4
+Y22F5A.3	F35C8.4
+Y57G11C.4	F35C8.4
+Y59E9AL.7	F35C8.4
+Y69A2AR.6	F35C8.4
+ZC155.7	F35C8.4
+ZK795.4	F35C8.4
+F48F7.2	F36F2.4
+F55A11.2	F36F2.4
+F55A4.1	F36F2.4
+F56A8.7	F36F2.4
+K02D10.5	F36F2.4
+M03E7.5	F36F2.4
+T01B11.3	F36F2.4
+T10H9.3	F36F2.4
+T10H9.4	F36F2.4
+T14D7.3	F36F2.4
+VF39H2L.1	F36F2.4
+Y22F5A.3	F36F2.4
+Y57G11C.4	F36F2.4
+Y59E9AL.7	F36F2.4
+Y69A2AR.6	F36F2.4
+ZC155.7	F36F2.4
+ZK795.4	F36F2.4
+F55A4.1	F48F7.2
+F56A8.7	F48F7.2
+K02D10.5	F48F7.2
+M03E7.5	F48F7.2
+T10H9.3	F48F7.2
+T10H9.4	F48F7.2
+T14D7.3	F48F7.2
+VF39H2L.1	F48F7.2
+Y22F5A.3	F48F7.2
+Y57G11C.4	F48F7.2
+Y59E9AL.7	F48F7.2
+Y69A2AR.6	F48F7.2
+ZC155.7	F48F7.2
+ZK795.4	F48F7.2
+F55A4.1	F55A11.2
+F56A8.7	F55A11.2
+K02D10.5	F55A11.2
+M03E7.5	F55A11.2
+T10H9.3	F55A11.2
+T10H9.4	F55A11.2
+T14D7.3	F55A11.2
+VF39H2L.1	F55A11.2
+Y22F5A.3	F55A11.2
+Y57G11C.4	F55A11.2
+Y59E9AL.7	F55A11.2
+Y69A2AR.6	F55A11.2
+ZC155.7	F55A11.2
+ZK795.4	F55A11.2
+F56A8.7	F55A4.1
+K02D10.5	F55A4.1
+M03E7.5	F55A4.1
+T01B11.3	F55A4.1
+T10H9.3	F55A4.1
+T10H9.4	F55A4.1
+T14D7.3	F55A4.1
+VF39H2L.1	F55A4.1
+Y22F5A.3	F55A4.1
+Y57G11C.4	F55A4.1
+Y59E9AL.7	F55A4.1
+Y69A2AR.6	F55A4.1
+ZC155.7	F55A4.1
+ZK795.4	F55A4.1
+K02D10.5	F56A8.7
+M03E7.5	F56A8.7
+T01B11.3	F56A8.7
+T10H9.3	F56A8.7
+T10H9.4	F56A8.7
+T14D7.3	F56A8.7
+VF39H2L.1	F56A8.7
+Y22F5A.3	F56A8.7
+Y57G11C.4	F56A8.7
+Y59E9AL.7	F56A8.7
+Y69A2AR.6	F56A8.7
+ZC155.7	F56A8.7
+ZK795.4	F56A8.7
+M03E7.5	K02D10.5
+T01B11.3	K02D10.5
+T10H9.3	K02D10.5
+T10H9.4	K02D10.5
+T14D7.3	K02D10.5
+VF39H2L.1	K02D10.5
+Y22F5A.3	K02D10.5
+Y57G11C.4	K02D10.5
+Y59E9AL.7	K02D10.5
+Y69A2AR.6	K02D10.5
+ZC155.7	K02D10.5
+ZK795.4	K02D10.5
+T01B11.3	M03E7.5
+T10H9.3	M03E7.5
+T10H9.4	M03E7.5
+T14D7.3	M03E7.5
+VF39H2L.1	M03E7.5
+Y22F5A.3	M03E7.5
+Y57G11C.4	M03E7.5
+Y59E9AL.7	M03E7.5
+Y69A2AR.6	M03E7.5
+ZC155.7	M03E7.5
+ZK795.4	M03E7.5
+T10H9.3	T01B11.3
+T10H9.4	T01B11.3
+T14D7.3	T01B11.3
+VF39H2L.1	T01B11.3
+Y22F5A.3	T01B11.3
+Y57G11C.4	T01B11.3
+Y59E9AL.7	T01B11.3
+Y69A2AR.6	T01B11.3
+ZC155.7	T01B11.3
+ZK795.4	T01B11.3
+T10H9.4	T10H9.3
+T14D7.3	T10H9.3
+VF39H2L.1	T10H9.3
+Y22F5A.3	T10H9.3
+Y57G11C.4	T10H9.3
+Y59E9AL.7	T10H9.3
+Y69A2AR.6	T10H9.3
+ZC155.7	T10H9.3
+ZK795.4	T10H9.3
+T14D7.3	T10H9.4
+VF39H2L.1	T10H9.4
+Y22F5A.3	T10H9.4
+Y57G11C.4	T10H9.4
+Y59E9AL.7	T10H9.4
+Y69A2AR.6	T10H9.4
+ZC155.7	T10H9.4
+ZK795.4	T10H9.4
+VF39H2L.1	T14D7.3
+Y22F5A.3	T14D7.3
+Y57G11C.4	T14D7.3
+Y59E9AL.7	T14D7.3
+Y69A2AR.6	T14D7.3
+ZC155.7	T14D7.3
+ZK795.4	T14D7.3
+Y22F5A.3	VF39H2L.1
+Y57G11C.4	VF39H2L.1
+Y59E9AL.7	VF39H2L.1
+Y69A2AR.6	VF39H2L.1
+ZC155.7	VF39H2L.1
+ZK795.4	VF39H2L.1
+Y57G11C.4	Y22F5A.3
+Y59E9AL.7	Y22F5A.3
+Y69A2AR.6	Y22F5A.3
+ZC155.7	Y22F5A.3
+ZK795.4	Y22F5A.3
+Y59E9AL.7	Y57G11C.4
+Y69A2AR.6	Y57G11C.4
+ZC155.7	Y57G11C.4
+ZK795.4	Y57G11C.4
+Y69A2AR.6	Y59E9AL.7
+ZC155.7	Y59E9AL.7
+ZK795.4	Y59E9AL.7
+ZC155.7	Y69A2AR.6
+ZK795.4	Y69A2AR.6
+ZK795.4	ZC155.7
+B0336.8	B0025.1
+C32D5.9	B0025.1
+M7.5	B0025.1
+T01C8.1	B0025.1
+T19E7.3	B0025.1
+Y55F3AM.4	B0025.1
+Y60A3A.1	B0025.1
+Y71G12B.12	B0025.1
+Y87G2A.3	B0025.1
+ZK930.1	B0025.1
+C32D5.9	B0336.8
+M7.5	B0336.8
+T01C8.1	B0336.8
+T19E7.3	B0336.8
+Y55F3AM.4	B0336.8
+Y60A3A.1	B0336.8
+Y71G12B.12	B0336.8
+Y87G2A.3	B0336.8
+ZK930.1	B0336.8
+M7.5	C32D5.9
+T01C8.1	C32D5.9
+T19E7.3	C32D5.9
+Y55F3AM.4	C32D5.9
+Y60A3A.1	C32D5.9
+Y71G12B.12	C32D5.9
+Y87G2A.3	C32D5.9
+ZK930.1	C32D5.9
+T01C8.1	M7.5
+T19E7.3	M7.5
+Y55F3AM.4	M7.5
+Y60A3A.1	M7.5
+Y71G12B.12	M7.5
+Y87G2A.3	M7.5
+ZK930.1	M7.5
+T19E7.3	T01C8.1
+Y55F3AM.4	T01C8.1
+Y60A3A.1	T01C8.1
+Y71G12B.12	T01C8.1
+Y87G2A.3	T01C8.1
+ZK930.1	T01C8.1
+Y55F3AM.4	T19E7.3
+Y60A3A.1	T19E7.3
+Y71G12B.12	T19E7.3
+Y87G2A.3	T19E7.3
+ZK930.1	T19E7.3
+Y60A3A.1	Y55F3AM.4
+Y71G12B.12	Y55F3AM.4
+Y87G2A.3	Y55F3AM.4
+ZK930.1	Y55F3AM.4
+Y71G12B.12	Y60A3A.1
+Y87G2A.3	Y60A3A.1
+ZK930.1	Y60A3A.1
+Y87G2A.3	Y71G12B.12
+ZK930.1	Y71G12B.12
+ZK930.1	Y87G2A.3
+B0403.4	B0035.14
+B0478.1	B0035.14
+C05C10.6	B0035.14
+C06A1.1	B0035.14
+C06A8.4	B0035.14
+C07A12.4	B0035.14
+C12C8.1	B0035.14
+C14B1.1	B0035.14
+C14B9.2	B0035.14
+C15H9.6	B0035.14
+C16C10.7	B0035.14
+C18E9.2	B0035.14
+C24F3.1	B0035.14
+C41C4.4	B0035.14
+C41C4.8	B0035.14
+C42D4.6	B0035.14
+C47E12.3	B0035.14
+C47E8.5	B0035.14
+C52D10.6	B0035.14
+C52D10.7	B0035.14
+C52D10.8	B0035.14
+C52D10.9	B0035.14
+C52E4.5	B0035.14
+C55B6.2	B0035.14
+D1022.1	B0035.14
+D2030.1	B0035.14
+D2045.6	B0035.14
+F10C2.5	B0035.14
+F11F1.1	B0035.14
+F12F6.6	B0035.14
+F13H10.4	B0035.14
+F15C11.2	B0035.14
+F19B6.2	B0035.14
+F25D7.1	B0035.14
+F26D10.3	B0035.14
+F26E4.11	B0035.14
+F26F4.9	B0035.14
+F28F8.6	B0035.14
+F32D8.6	B0035.14
+F39B2.10	B0035.14
+F40F9.6	B0035.14
+F44E5.4	B0035.14
+F44E5.5	B0035.14
+F44G3.6	B0035.14
+F45D3.5	B0035.14
+F45E6.2	B0035.14
+F46A9.4	B0035.14
+F46A9.5	B0035.14
+F46C3.1	B0035.14
+F47H4.10	B0035.14
+F48E3.3	B0035.14
+F52C6.12	B0035.14
+F52D1.1	B0035.14
+F54D10.1	B0035.14
+F54F2.9	B0035.14
+F55A11.3	B0035.14
+F55A3.1	B0035.14
+F56B3.12	B0035.14
+F56G4.5	B0035.14
+F57B10.10	B0035.14
+F57B10.11	B0035.14
+F58A4.10	B0035.14
+F59A6.1	B0035.14
+F59E12.5	B0035.14
+H06H21.6	B0035.14
+H06O01.1	B0035.14
+H14N18.1	B0035.14
+K02B12.3	B0035.14
+K02G10.8	B0035.14
+K04G2.3	B0035.14
+K07A1.8	B0035.14
+K08A8.1	B0035.14
+K08E3.7	B0035.14
+K08H2.1	B0035.14
+M7.1	B0035.14
+R12H7.3	B0035.14
+R12H7.5	B0035.14
+R151.6	B0035.14
+R74.3	B0035.14
+T03G11.4	B0035.14
+T04G9.3	B0035.14
+T04G9.5	B0035.14
+T05C3.5	B0035.14
+T05E11.3	B0035.14
+T05H10.5	B0035.14
+T09A5.11	B0035.14
+T09B4.10	B0035.14
+T12A2.2	B0035.14
+T14G8.3	B0035.14
+T15H9.7	B0035.14
+T22D1.4	B0035.14
+T24H7.2	B0035.14
+Y105C5B.13	B0035.14
+Y105E8A.2	B0035.14
+Y110A2AM.3	B0035.14
+Y110A2AR.2	B0035.14
+Y113G7A.3	B0035.14
+Y37E3.10	B0035.14
+Y37H2C.2	B0035.14
+Y38A10A.5	B0035.14
+Y38F2AR.2	B0035.14
+Y38F2AR.9	B0035.14
+Y47D7A.1	B0035.14
+Y47D7A.8	B0035.14
+Y47H9C.5	B0035.14
+Y49E10.4	B0035.14
+Y54G2A.18	B0035.14
+Y56A3A.2	B0035.14
+Y56A3A.21	B0035.14
+Y57G11C.15	B0035.14
+Y60A3A.18	B0035.14
+Y63D3A.6	B0035.14
+Y71F9AM.6	B0035.14
+Y77E11A.13	B0035.14
+Y87G2A.9	B0035.14
+Y94H6A.9	B0035.14
+ZC410.3	B0035.14
+ZC506.1	B0035.14
+ZC518.2	B0035.14
+ZK1307.8	B0035.14
+ZK180.4	B0035.14
+ZK20.3	B0035.14
+ZK287.5	B0035.14
+ZK632.6	B0035.14
+ZK686.3	B0035.14
+B0478.1	B0403.4
+C05C10.6	B0403.4
+C06A1.1	B0403.4
+C06A8.4	B0403.4
+C07A12.4	B0403.4
+C12C8.1	B0403.4
+C14B1.1	B0403.4
+C14B9.2	B0403.4
+C15H9.6	B0403.4
+C16C10.7	B0403.4
+C18E9.2	B0403.4
+C24F3.1	B0403.4
+C41C4.4	B0403.4
+C41C4.8	B0403.4
+C42D4.6	B0403.4
+C47E12.3	B0403.4
+C47E8.5	B0403.4
+C52D10.6	B0403.4
+C52D10.7	B0403.4
+C52D10.8	B0403.4
+C52D10.9	B0403.4
+C52E4.5	B0403.4
+C55B6.2	B0403.4
+D1022.1	B0403.4
+D2030.1	B0403.4
+D2045.6	B0403.4
+F10C2.5	B0403.4
+F11F1.1	B0403.4
+F12F6.6	B0403.4
+F13H10.4	B0403.4
+F15C11.2	B0403.4
+F19B6.2	B0403.4
+F25D7.1	B0403.4
+F26D10.3	B0403.4
+F26E4.11	B0403.4
+F26F4.9	B0403.4
+F28F8.6	B0403.4
+F32D8.6	B0403.4
+F39B2.10	B0403.4
+F40F9.6	B0403.4
+F44E5.4	B0403.4
+F44E5.5	B0403.4
+F44G3.6	B0403.4
+F45D3.5	B0403.4
+F45E6.2	B0403.4
+F46A9.4	B0403.4
+F46A9.5	B0403.4
+F46C3.1	B0403.4
+F47H4.10	B0403.4
+F48E3.3	B0403.4
+F52C6.12	B0403.4
+F52D1.1	B0403.4
+F54D10.1	B0403.4
+F54F2.9	B0403.4
+F55A11.3	B0403.4
+F55A3.1	B0403.4
+F56B3.12	B0403.4
+F56G4.5	B0403.4
+F57B10.10	B0403.4
+F57B10.11	B0403.4
+F58A4.10	B0403.4
+F59A6.1	B0403.4
+F59E12.5	B0403.4
+H06H21.6	B0403.4
+H06O01.1	B0403.4
+H14N18.1	B0403.4
+K02B12.3	B0403.4
+K02G10.8	B0403.4
+K04G2.3	B0403.4
+K07A1.8	B0403.4
+K08A8.1	B0403.4
+K08E3.7	B0403.4
+K08H2.1	B0403.4
+M7.1	B0403.4
+R12H7.3	B0403.4
+R12H7.5	B0403.4
+R151.6	B0403.4
+R74.3	B0403.4
+T03G11.4	B0403.4
+T04G9.3	B0403.4
+T04G9.5	B0403.4
+T05C3.5	B0403.4
+T05E11.3	B0403.4
+T05H10.5	B0403.4
+T09A5.11	B0403.4
+T09B4.10	B0403.4
+T12A2.2	B0403.4
+T14G8.3	B0403.4
+T15H9.7	B0403.4
+T22D1.4	B0403.4
+T24H7.2	B0403.4
+Y105C5B.13	B0403.4
+Y105E8A.2	B0403.4
+Y110A2AM.3	B0403.4
+Y110A2AR.2	B0403.4
+Y113G7A.3	B0403.4
+Y37E3.10	B0403.4
+Y37H2C.2	B0403.4
+Y38A10A.5	B0403.4
+Y38F2AR.2	B0403.4
+Y38F2AR.9	B0403.4
+Y47D7A.1	B0403.4
+Y47D7A.8	B0403.4
+Y47H9C.5	B0403.4
+Y49E10.4	B0403.4
+Y54G2A.18	B0403.4
+Y56A3A.2	B0403.4
+Y56A3A.21	B0403.4
+Y57G11C.15	B0403.4
+Y60A3A.18	B0403.4
+Y63D3A.6	B0403.4
+Y71F9AM.6	B0403.4
+Y77E11A.13	B0403.4
+Y87G2A.9	B0403.4
+Y94H6A.9	B0403.4
+ZC410.3	B0403.4
+ZC506.1	B0403.4
+ZC518.2	B0403.4
+ZK1307.8	B0403.4
+ZK180.4	B0403.4
+ZK20.3	B0403.4
+ZK287.5	B0403.4
+ZK632.6	B0403.4
+ZK686.3	B0403.4
+C05C10.6	B0478.1
+C06A1.1	B0478.1
+C06A8.4	B0478.1
+C07A12.4	B0478.1
+C14B1.1	B0478.1
+C14B9.2	B0478.1
+C15H9.6	B0478.1
+C16C10.7	B0478.1
+C18E9.2	B0478.1
+C24F3.1	B0478.1
+C41C4.4	B0478.1
+C41C4.8	B0478.1
+C42D4.6	B0478.1
+C47E12.3	B0478.1
+C47E8.5	B0478.1
+C52D10.6	B0478.1
+C52D10.7	B0478.1
+C52D10.8	B0478.1
+C52D10.9	B0478.1
+C52E4.5	B0478.1
+C55B6.2	B0478.1
+D1022.1	B0478.1
+D2030.1	B0478.1
+D2045.6	B0478.1
+F10C2.5	B0478.1
+F12F6.6	B0478.1
+F13H10.4	B0478.1
+F15C11.2	B0478.1
+F19B6.2	B0478.1
+F25D7.1	B0478.1
+F26E4.11	B0478.1
+F26F4.9	B0478.1
+F28F8.6	B0478.1
+F32D8.6	B0478.1
+F39B2.10	B0478.1
+F40F9.6	B0478.1
+F44G3.6	B0478.1
+F45D3.5	B0478.1
+F45E6.2	B0478.1
+F46A9.4	B0478.1
+F46A9.5	B0478.1
+F46C3.1	B0478.1
+F47H4.10	B0478.1
+F48E3.3	B0478.1
+F52C6.12	B0478.1
+F52D1.1	B0478.1
+F54D10.1	B0478.1
+F54F2.9	B0478.1
+F55A11.3	B0478.1
+F55A3.1	B0478.1
+F56B3.12	B0478.1
+F56G4.5	B0478.1
+F57B10.10	B0478.1
+F57B10.11	B0478.1
+F58A4.10	B0478.1
+F59E12.5	B0478.1
+H06H21.6	B0478.1
+H06O01.1	B0478.1
+H14N18.1	B0478.1
+K02B12.3	B0478.1
+K02G10.8	B0478.1
+K04G2.3	B0478.1
+K07A1.8	B0478.1
+K08E3.7	B0478.1
+K08H2.1	B0478.1
+M7.1	B0478.1
+R12H7.3	B0478.1
+R12H7.5	B0478.1
+R151.6	B0478.1
+R74.3	B0478.1
+T03G11.4	B0478.1
+T04G9.3	B0478.1
+T04G9.5	B0478.1
+T05C3.5	B0478.1
+T05E11.3	B0478.1
+T05H10.5	B0478.1
+T09A5.11	B0478.1
+T09B4.10	B0478.1
+T12A2.2	B0478.1
+T14G8.3	B0478.1
+T15H9.7	B0478.1
+T22D1.4	B0478.1
+T24H7.2	B0478.1
+Y105C5B.13	B0478.1
+Y105E8A.2	B0478.1
+Y110A2AM.3	B0478.1
+Y110A2AR.2	B0478.1
+Y113G7A.3	B0478.1
+Y37E3.10	B0478.1
+Y37H2C.2	B0478.1
+Y38A10A.5	B0478.1
+Y38F2AR.2	B0478.1
+Y38F2AR.9	B0478.1
+Y47D7A.1	B0478.1
+Y47D7A.8	B0478.1
+Y47H9C.5	B0478.1
+Y49E10.4	B0478.1
+Y54G2A.18	B0478.1
+Y56A3A.2	B0478.1
+Y56A3A.21	B0478.1
+Y57G11C.15	B0478.1
+Y60A3A.18	B0478.1
+Y63D3A.6	B0478.1
+Y71F9AM.6	B0478.1
+Y77E11A.13	B0478.1
+Y87G2A.9	B0478.1
+Y94H6A.9	B0478.1
+ZC410.3	B0478.1
+ZC506.1	B0478.1
+ZC518.2	B0478.1
+ZK1307.8	B0478.1
+ZK180.4	B0478.1
+ZK20.3	B0478.1
+ZK287.5	B0478.1
+ZK632.6	B0478.1
+ZK686.3	B0478.1
+C06A1.1	C05C10.6
+C06A8.4	C05C10.6
+C07A12.4	C05C10.6
+C12C8.1	C05C10.6
+C14B1.1	C05C10.6
+C14B9.2	C05C10.6
+C15H9.6	C05C10.6
+C16C10.7	C05C10.6
+C18E9.2	C05C10.6
+C24F3.1	C05C10.6
+C41C4.4	C05C10.6
+C41C4.8	C05C10.6
+C42D4.6	C05C10.6
+C47E12.3	C05C10.6
+C47E8.5	C05C10.6
+C52D10.6	C05C10.6
+C52D10.7	C05C10.6
+C52D10.8	C05C10.6
+C52D10.9	C05C10.6
+C52E4.5	C05C10.6
+C55B6.2	C05C10.6
+D1022.1	C05C10.6
+D2030.1	C05C10.6
+D2045.6	C05C10.6
+F10C2.5	C05C10.6
+F11F1.1	C05C10.6
+F12F6.6	C05C10.6
+F13H10.4	C05C10.6
+F15C11.2	C05C10.6
+F19B6.2	C05C10.6
+F25D7.1	C05C10.6
+F26D10.3	C05C10.6
+F26E4.11	C05C10.6
+F26F4.9	C05C10.6
+F28F8.6	C05C10.6
+F32D8.6	C05C10.6
+F39B2.10	C05C10.6
+F40F9.6	C05C10.6
+F44E5.4	C05C10.6
+F44E5.5	C05C10.6
+F44G3.6	C05C10.6
+F45D3.5	C05C10.6
+F45E6.2	C05C10.6
+F46A9.4	C05C10.6
+F46A9.5	C05C10.6
+F46C3.1	C05C10.6
+F47H4.10	C05C10.6
+F48E3.3	C05C10.6
+F52C6.12	C05C10.6
+F52D1.1	C05C10.6
+F54D10.1	C05C10.6
+F54F2.9	C05C10.6
+F55A11.3	C05C10.6
+F55A3.1	C05C10.6
+F56B3.12	C05C10.6
+F56G4.5	C05C10.6
+F57B10.10	C05C10.6
+F57B10.11	C05C10.6
+F58A4.10	C05C10.6
+F59A6.1	C05C10.6
+F59E12.5	C05C10.6
+H06H21.6	C05C10.6
+H06O01.1	C05C10.6
+H14N18.1	C05C10.6
+K02B12.3	C05C10.6
+K02G10.8	C05C10.6
+K04G2.3	C05C10.6
+K07A1.8	C05C10.6
+K08A8.1	C05C10.6
+K08E3.7	C05C10.6
+K08H2.1	C05C10.6
+M7.1	C05C10.6
+R12H7.3	C05C10.6
+R12H7.5	C05C10.6
+R151.6	C05C10.6
+R74.3	C05C10.6
+T03G11.4	C05C10.6
+T04G9.3	C05C10.6
+T04G9.5	C05C10.6
+T05C3.5	C05C10.6
+T05E11.3	C05C10.6
+T05H10.5	C05C10.6
+T09A5.11	C05C10.6
+T09B4.10	C05C10.6
+T12A2.2	C05C10.6
+T14G8.3	C05C10.6
+T15H9.7	C05C10.6
+T22D1.4	C05C10.6
+T24H7.2	C05C10.6
+Y105C5B.13	C05C10.6
+Y105E8A.2	C05C10.6
+Y110A2AM.3	C05C10.6
+Y110A2AR.2	C05C10.6
+Y113G7A.3	C05C10.6
+Y37E3.10	C05C10.6
+Y37H2C.2	C05C10.6
+Y38A10A.5	C05C10.6
+Y38F2AR.2	C05C10.6
+Y38F2AR.9	C05C10.6
+Y47D7A.1	C05C10.6
+Y47D7A.8	C05C10.6
+Y47H9C.5	C05C10.6
+Y49E10.4	C05C10.6
+Y54G2A.18	C05C10.6
+Y56A3A.2	C05C10.6
+Y56A3A.21	C05C10.6
+Y57G11C.15	C05C10.6
+Y60A3A.18	C05C10.6
+Y63D3A.6	C05C10.6
+Y71F9AM.6	C05C10.6
+Y77E11A.13	C05C10.6
+Y87G2A.9	C05C10.6
+Y94H6A.9	C05C10.6
+ZC410.3	C05C10.6
+ZC506.1	C05C10.6
+ZC518.2	C05C10.6
+ZK1307.8	C05C10.6
+ZK180.4	C05C10.6
+ZK20.3	C05C10.6
+ZK287.5	C05C10.6
+ZK632.6	C05C10.6
+ZK686.3	C05C10.6
+C06A8.4	C06A1.1
+C07A12.4	C06A1.1
+C12C8.1	C06A1.1
+C14B1.1	C06A1.1
+C14B9.2	C06A1.1
+C15H9.6	C06A1.1
+C16C10.7	C06A1.1
+C18E9.2	C06A1.1
+C24F3.1	C06A1.1
+C41C4.4	C06A1.1
+C42D4.6	C06A1.1
+C47E12.3	C06A1.1
+C47E8.5	C06A1.1
+C52D10.6	C06A1.1
+C52D10.7	C06A1.1
+C52D10.8	C06A1.1
+C52D10.9	C06A1.1
+C52E4.5	C06A1.1
+C55B6.2	C06A1.1
+D1022.1	C06A1.1
+D2030.1	C06A1.1
+D2045.6	C06A1.1
+F10C2.5	C06A1.1
+F11F1.1	C06A1.1
+F12F6.6	C06A1.1
+F13H10.4	C06A1.1
+F15C11.2	C06A1.1
+F19B6.2	C06A1.1
+F25D7.1	C06A1.1
+F26D10.3	C06A1.1
+F26E4.11	C06A1.1
+F26F4.9	C06A1.1
+F28F8.6	C06A1.1
+F32D8.6	C06A1.1
+F39B2.10	C06A1.1
+F40F9.6	C06A1.1
+F44E5.4	C06A1.1
+F44E5.5	C06A1.1
+F44G3.6	C06A1.1
+F45D3.5	C06A1.1
+F45E6.2	C06A1.1
+F46A9.4	C06A1.1
+F46A9.5	C06A1.1
+F46C3.1	C06A1.1
+F47H4.10	C06A1.1
+F48E3.3	C06A1.1
+F52C6.12	C06A1.1
+F52D1.1	C06A1.1
+F54D10.1	C06A1.1
+F54F2.9	C06A1.1
+F55A11.3	C06A1.1
+F55A3.1	C06A1.1
+F56B3.12	C06A1.1
+F56G4.5	C06A1.1
+F57B10.10	C06A1.1
+F57B10.11	C06A1.1
+F58A4.10	C06A1.1
+F59A6.1	C06A1.1
+F59E12.5	C06A1.1
+H06H21.6	C06A1.1
+H06O01.1	C06A1.1
+H14N18.1	C06A1.1
+K02B12.3	C06A1.1
+K02G10.8	C06A1.1
+K07A1.8	C06A1.1
+K08A8.1	C06A1.1
+K08E3.7	C06A1.1
+K08H2.1	C06A1.1
+M7.1	C06A1.1
+R12H7.3	C06A1.1
+R12H7.5	C06A1.1
+R151.6	C06A1.1
+R74.3	C06A1.1
+T03G11.4	C06A1.1
+T04G9.3	C06A1.1
+T04G9.5	C06A1.1
+T05C3.5	C06A1.1
+T05E11.3	C06A1.1
+T05H10.5	C06A1.1
+T09A5.11	C06A1.1
+T09B4.10	C06A1.1
+T12A2.2	C06A1.1
+T14G8.3	C06A1.1
+T15H9.7	C06A1.1
+T22D1.4	C06A1.1
+T24H7.2	C06A1.1
+Y105C5B.13	C06A1.1
+Y105E8A.2	C06A1.1
+Y110A2AM.3	C06A1.1
+Y110A2AR.2	C06A1.1
+Y113G7A.3	C06A1.1
+Y37E3.10	C06A1.1
+Y37H2C.2	C06A1.1
+Y38A10A.5	C06A1.1
+Y38F2AR.2	C06A1.1
+Y38F2AR.9	C06A1.1
+Y47D7A.1	C06A1.1
+Y47D7A.8	C06A1.1
+Y47H9C.5	C06A1.1
+Y49E10.4	C06A1.1
+Y54G2A.18	C06A1.1
+Y56A3A.2	C06A1.1
+Y56A3A.21	C06A1.1
+Y57G11C.15	C06A1.1
+Y60A3A.18	C06A1.1
+Y63D3A.6	C06A1.1
+Y71F9AM.6	C06A1.1
+Y77E11A.13	C06A1.1
+Y87G2A.9	C06A1.1
+Y94H6A.9	C06A1.1
+ZC410.3	C06A1.1
+ZC506.1	C06A1.1
+ZC518.2	C06A1.1
+ZK1307.8	C06A1.1
+ZK180.4	C06A1.1
+ZK20.3	C06A1.1
+ZK287.5	C06A1.1
+ZK632.6	C06A1.1
+ZK686.3	C06A1.1
+C07A12.4	C06A8.4
+C12C8.1	C06A8.4
+C14B1.1	C06A8.4
+C14B9.2	C06A8.4
+C15H9.6	C06A8.4
+C16C10.7	C06A8.4
+C18E9.2	C06A8.4
+C24F3.1	C06A8.4
+C41C4.4	C06A8.4
+C41C4.8	C06A8.4
+C47E12.3	C06A8.4
+C47E8.5	C06A8.4
+C52E4.5	C06A8.4
+C55B6.2	C06A8.4
+D2030.1	C06A8.4
+F10C2.5	C06A8.4
+F11F1.1	C06A8.4
+F12F6.6	C06A8.4
+F13H10.4	C06A8.4
+F15C11.2	C06A8.4
+F19B6.2	C06A8.4
+F25D7.1	C06A8.4
+F26D10.3	C06A8.4
+F26E4.11	C06A8.4
+F26F4.9	C06A8.4
+F28F8.6	C06A8.4
+F32D8.6	C06A8.4
+F39B2.10	C06A8.4
+F40F9.6	C06A8.4
+F44E5.4	C06A8.4
+F44E5.5	C06A8.4
+F45D3.5	C06A8.4
+F45E6.2	C06A8.4
+F46C3.1	C06A8.4
+F48E3.3	C06A8.4
+F52D1.1	C06A8.4
+F54F2.9	C06A8.4
+F55A3.1	C06A8.4
+F56G4.5	C06A8.4
+F57B10.10	C06A8.4
+F57B10.11	C06A8.4
+F59A6.1	C06A8.4
+F59E12.5	C06A8.4
+H06H21.6	C06A8.4
+H06O01.1	C06A8.4
+H14N18.1	C06A8.4
+K02B12.3	C06A8.4
+K02G10.8	C06A8.4
+K04G2.3	C06A8.4
+K07A1.8	C06A8.4
+K08A8.1	C06A8.4
+R151.6	C06A8.4
+R74.3	C06A8.4
+T03G11.4	C06A8.4
+T04G9.3	C06A8.4
+T04G9.5	C06A8.4
+T05C3.5	C06A8.4
+T05E11.3	C06A8.4
+T09A5.11	C06A8.4
+T12A2.2	C06A8.4
+T14G8.3	C06A8.4
+T15H9.7	C06A8.4
+T22D1.4	C06A8.4
+T24H7.2	C06A8.4
+Y105E8A.2	C06A8.4
+Y113G7A.3	C06A8.4
+Y37E3.10	C06A8.4
+Y38A10A.5	C06A8.4
+Y38F2AR.2	C06A8.4
+Y38F2AR.9	C06A8.4
+Y47H9C.5	C06A8.4
+Y49E10.4	C06A8.4
+Y54G2A.18	C06A8.4
+Y56A3A.2	C06A8.4
+Y56A3A.21	C06A8.4
+Y57G11C.15	C06A8.4
+Y63D3A.6	C06A8.4
+Y71F9AM.6	C06A8.4
+Y77E11A.13	C06A8.4
+Y94H6A.9	C06A8.4
+ZC410.3	C06A8.4
+ZC506.1	C06A8.4
+ZC518.2	C06A8.4
+ZK1307.8	C06A8.4
+ZK180.4	C06A8.4
+ZK20.3	C06A8.4
+ZK632.6	C06A8.4
+ZK686.3	C06A8.4
+C12C8.1	C07A12.4
+C14B1.1	C07A12.4
+C14B9.2	C07A12.4
+C15H9.6	C07A12.4
+C16C10.7	C07A12.4
+C18E9.2	C07A12.4
+C24F3.1	C07A12.4
+C41C4.4	C07A12.4
+C41C4.8	C07A12.4
+C42D4.6	C07A12.4
+C47E12.3	C07A12.4
+C47E8.5	C07A12.4
+C52D10.6	C07A12.4
+C52D10.7	C07A12.4
+C52D10.8	C07A12.4
+C52D10.9	C07A12.4
+C52E4.5	C07A12.4
+C55B6.2	C07A12.4
+D1022.1	C07A12.4
+D2030.1	C07A12.4
+D2045.6	C07A12.4
+F10C2.5	C07A12.4
+F11F1.1	C07A12.4
+F12F6.6	C07A12.4
+F13H10.4	C07A12.4
+F15C11.2	C07A12.4
+F19B6.2	C07A12.4
+F25D7.1	C07A12.4
+F26D10.3	C07A12.4
+F26E4.11	C07A12.4
+F26F4.9	C07A12.4
+F28F8.6	C07A12.4
+F32D8.6	C07A12.4
+F39B2.10	C07A12.4
+F40F9.6	C07A12.4
+F44E5.4	C07A12.4
+F44E5.5	C07A12.4
+F44G3.6	C07A12.4
+F45D3.5	C07A12.4
+F45E6.2	C07A12.4
+F46A9.4	C07A12.4
+F46A9.5	C07A12.4
+F46C3.1	C07A12.4
+F47H4.10	C07A12.4
+F48E3.3	C07A12.4
+F52C6.12	C07A12.4
+F52D1.1	C07A12.4
+F54D10.1	C07A12.4
+F54F2.9	C07A12.4
+F55A11.3	C07A12.4
+F55A3.1	C07A12.4
+F56B3.12	C07A12.4
+F56G4.5	C07A12.4
+F57B10.10	C07A12.4
+F57B10.11	C07A12.4
+F58A4.10	C07A12.4
+F59A6.1	C07A12.4
+F59E12.5	C07A12.4
+H06H21.6	C07A12.4
+H06O01.1	C07A12.4
+H14N18.1	C07A12.4
+K02B12.3	C07A12.4
+K02G10.8	C07A12.4
+K04G2.3	C07A12.4
+K07A1.8	C07A12.4
+K08A8.1	C07A12.4
+K08E3.7	C07A12.4
+K08H2.1	C07A12.4
+M7.1	C07A12.4
+R12H7.3	C07A12.4
+R12H7.5	C07A12.4
+R151.6	C07A12.4
+R74.3	C07A12.4
+T03G11.4	C07A12.4
+T04G9.3	C07A12.4
+T04G9.5	C07A12.4
+T05C3.5	C07A12.4
+T05E11.3	C07A12.4
+T05H10.5	C07A12.4
+T09A5.11	C07A12.4
+T09B4.10	C07A12.4
+T12A2.2	C07A12.4
+T14G8.3	C07A12.4
+T15H9.7	C07A12.4
+T22D1.4	C07A12.4
+T24H7.2	C07A12.4
+Y105C5B.13	C07A12.4
+Y105E8A.2	C07A12.4
+Y110A2AM.3	C07A12.4
+Y110A2AR.2	C07A12.4
+Y113G7A.3	C07A12.4
+Y37E3.10	C07A12.4
+Y37H2C.2	C07A12.4
+Y38A10A.5	C07A12.4
+Y38F2AR.2	C07A12.4
+Y38F2AR.9	C07A12.4
+Y47D7A.1	C07A12.4
+Y47D7A.8	C07A12.4
+Y47H9C.5	C07A12.4
+Y49E10.4	C07A12.4
+Y54G2A.18	C07A12.4
+Y56A3A.2	C07A12.4
+Y56A3A.21	C07A12.4
+Y57G11C.15	C07A12.4
+Y60A3A.18	C07A12.4
+Y63D3A.6	C07A12.4
+Y71F9AM.6	C07A12.4
+Y77E11A.13	C07A12.4
+Y87G2A.9	C07A12.4
+Y94H6A.9	C07A12.4
+ZC410.3	C07A12.4
+ZC506.1	C07A12.4
+ZC518.2	C07A12.4
+ZK1307.8	C07A12.4
+ZK180.4	C07A12.4
+ZK20.3	C07A12.4
+ZK287.5	C07A12.4
+ZK632.6	C07A12.4
+ZK686.3	C07A12.4
+C14B1.1	C12C8.1
+C14B9.2	C12C8.1
+C15H9.6	C12C8.1
+C16C10.7	C12C8.1
+C18E9.2	C12C8.1
+C24F3.1	C12C8.1
+C41C4.4	C12C8.1
+C41C4.8	C12C8.1
+C42D4.6	C12C8.1
+C47E12.3	C12C8.1
+C47E8.5	C12C8.1
+C52D10.6	C12C8.1
+C52D10.7	C12C8.1
+C52D10.8	C12C8.1
+C52D10.9	C12C8.1
+C52E4.5	C12C8.1
+C55B6.2	C12C8.1
+D1022.1	C12C8.1
+D2030.1	C12C8.1
+D2045.6	C12C8.1
+F10C2.5	C12C8.1
+F12F6.6	C12C8.1
+F13H10.4	C12C8.1
+F15C11.2	C12C8.1
+F19B6.2	C12C8.1
+F25D7.1	C12C8.1
+F26E4.11	C12C8.1
+F26F4.9	C12C8.1
+F28F8.6	C12C8.1
+F32D8.6	C12C8.1
+F39B2.10	C12C8.1
+F40F9.6	C12C8.1
+F44G3.6	C12C8.1
+F45D3.5	C12C8.1
+F45E6.2	C12C8.1
+F46A9.4	C12C8.1
+F46A9.5	C12C8.1
+F46C3.1	C12C8.1
+F47H4.10	C12C8.1
+F48E3.3	C12C8.1
+F52C6.12	C12C8.1
+F52D1.1	C12C8.1
+F54D10.1	C12C8.1
+F54F2.9	C12C8.1
+F55A11.3	C12C8.1
+F55A3.1	C12C8.1
+F56B3.12	C12C8.1
+F56G4.5	C12C8.1
+F57B10.10	C12C8.1
+F57B10.11	C12C8.1
+F58A4.10	C12C8.1
+F59E12.5	C12C8.1
+H06H21.6	C12C8.1
+H06O01.1	C12C8.1
+H14N18.1	C12C8.1
+K02B12.3	C12C8.1
+K02G10.8	C12C8.1
+K04G2.3	C12C8.1
+K07A1.8	C12C8.1
+K08E3.7	C12C8.1
+K08H2.1	C12C8.1
+M7.1	C12C8.1
+R12H7.3	C12C8.1
+R12H7.5	C12C8.1
+R151.6	C12C8.1
+R74.3	C12C8.1
+T03G11.4	C12C8.1
+T04G9.3	C12C8.1
+T04G9.5	C12C8.1
+T05C3.5	C12C8.1
+T05E11.3	C12C8.1
+T05H10.5	C12C8.1
+T09A5.11	C12C8.1
+T09B4.10	C12C8.1
+T12A2.2	C12C8.1
+T14G8.3	C12C8.1
+T15H9.7	C12C8.1
+T22D1.4	C12C8.1
+T24H7.2	C12C8.1
+Y105C5B.13	C12C8.1
+Y105E8A.2	C12C8.1
+Y110A2AM.3	C12C8.1
+Y110A2AR.2	C12C8.1
+Y113G7A.3	C12C8.1
+Y37E3.10	C12C8.1
+Y37H2C.2	C12C8.1
+Y38A10A.5	C12C8.1
+Y38F2AR.2	C12C8.1
+Y38F2AR.9	C12C8.1
+Y47D7A.1	C12C8.1
+Y47D7A.8	C12C8.1
+Y47H9C.5	C12C8.1
+Y49E10.4	C12C8.1
+Y54G2A.18	C12C8.1
+Y56A3A.2	C12C8.1
+Y56A3A.21	C12C8.1
+Y57G11C.15	C12C8.1
+Y60A3A.18	C12C8.1
+Y63D3A.6	C12C8.1
+Y71F9AM.6	C12C8.1
+Y77E11A.13	C12C8.1
+Y87G2A.9	C12C8.1
+Y94H6A.9	C12C8.1
+ZC410.3	C12C8.1
+ZC506.1	C12C8.1
+ZC518.2	C12C8.1
+ZK1307.8	C12C8.1
+ZK180.4	C12C8.1
+ZK20.3	C12C8.1
+ZK287.5	C12C8.1
+ZK632.6	C12C8.1
+ZK686.3	C12C8.1
+C14B9.2	C14B1.1
+C15H9.6	C14B1.1
+C16C10.7	C14B1.1
+C18E9.2	C14B1.1
+C24F3.1	C14B1.1
+C41C4.4	C14B1.1
+C41C4.8	C14B1.1
+C42D4.6	C14B1.1
+C47E12.3	C14B1.1
+C47E8.5	C14B1.1
+C52D10.6	C14B1.1
+C52D10.7	C14B1.1
+C52D10.8	C14B1.1
+C52D10.9	C14B1.1
+C52E4.5	C14B1.1
+C55B6.2	C14B1.1
+D1022.1	C14B1.1
+D2030.1	C14B1.1
+D2045.6	C14B1.1
+F10C2.5	C14B1.1
+F11F1.1	C14B1.1
+F12F6.6	C14B1.1
+F13H10.4	C14B1.1
+F15C11.2	C14B1.1
+F19B6.2	C14B1.1
+F25D7.1	C14B1.1
+F26D10.3	C14B1.1
+F26E4.11	C14B1.1
+F26F4.9	C14B1.1
+F28F8.6	C14B1.1
+F32D8.6	C14B1.1
+F39B2.10	C14B1.1
+F40F9.6	C14B1.1
+F44E5.4	C14B1.1
+F44E5.5	C14B1.1
+F44G3.6	C14B1.1
+F45D3.5	C14B1.1
+F45E6.2	C14B1.1
+F46A9.4	C14B1.1
+F46A9.5	C14B1.1
+F46C3.1	C14B1.1
+F47H4.10	C14B1.1
+F48E3.3	C14B1.1
+F52C6.12	C14B1.1
+F52D1.1	C14B1.1
+F54D10.1	C14B1.1
+F54F2.9	C14B1.1
+F55A11.3	C14B1.1
+F55A3.1	C14B1.1
+F56B3.12	C14B1.1
+F56G4.5	C14B1.1
+F57B10.10	C14B1.1
+F57B10.11	C14B1.1
+F58A4.10	C14B1.1
+F59A6.1	C14B1.1
+F59E12.5	C14B1.1
+H06H21.6	C14B1.1
+H06O01.1	C14B1.1
+H14N18.1	C14B1.1
+K02B12.3	C14B1.1
+K02G10.8	C14B1.1
+K04G2.3	C14B1.1
+K07A1.8	C14B1.1
+K08A8.1	C14B1.1
+K08E3.7	C14B1.1
+K08H2.1	C14B1.1
+M7.1	C14B1.1
+R12H7.3	C14B1.1
+R12H7.5	C14B1.1
+R151.6	C14B1.1
+R74.3	C14B1.1
+T03G11.4	C14B1.1
+T04G9.3	C14B1.1
+T04G9.5	C14B1.1
+T05C3.5	C14B1.1
+T05E11.3	C14B1.1
+T05H10.5	C14B1.1
+T09A5.11	C14B1.1
+T09B4.10	C14B1.1
+T12A2.2	C14B1.1
+T14G8.3	C14B1.1
+T15H9.7	C14B1.1
+T22D1.4	C14B1.1
+T24H7.2	C14B1.1
+Y105C5B.13	C14B1.1
+Y105E8A.2	C14B1.1
+Y110A2AM.3	C14B1.1
+Y110A2AR.2	C14B1.1
+Y113G7A.3	C14B1.1
+Y37E3.10	C14B1.1
+Y37H2C.2	C14B1.1
+Y38A10A.5	C14B1.1
+Y38F2AR.2	C14B1.1
+Y38F2AR.9	C14B1.1
+Y47D7A.1	C14B1.1
+Y47D7A.8	C14B1.1
+Y47H9C.5	C14B1.1
+Y49E10.4	C14B1.1
+Y54G2A.18	C14B1.1
+Y56A3A.2	C14B1.1
+Y56A3A.21	C14B1.1
+Y57G11C.15	C14B1.1
+Y60A3A.18	C14B1.1
+Y63D3A.6	C14B1.1
+Y71F9AM.6	C14B1.1
+Y77E11A.13	C14B1.1
+Y87G2A.9	C14B1.1
+Y94H6A.9	C14B1.1
+ZC410.3	C14B1.1
+ZC506.1	C14B1.1
+ZC518.2	C14B1.1
+ZK1307.8	C14B1.1
+ZK180.4	C14B1.1
+ZK20.3	C14B1.1
+ZK287.5	C14B1.1
+ZK632.6	C14B1.1
+ZK686.3	C14B1.1
+C15H9.6	C14B9.2
+C16C10.7	C14B9.2
+C18E9.2	C14B9.2
+C24F3.1	C14B9.2
+C41C4.4	C14B9.2
+C41C4.8	C14B9.2
+C42D4.6	C14B9.2
+C47E12.3	C14B9.2
+C47E8.5	C14B9.2
+C52D10.6	C14B9.2
+C52D10.7	C14B9.2
+C52D10.8	C14B9.2
+C52D10.9	C14B9.2
+C52E4.5	C14B9.2
+C55B6.2	C14B9.2
+D1022.1	C14B9.2
+D2030.1	C14B9.2
+D2045.6	C14B9.2
+F10C2.5	C14B9.2
+F11F1.1	C14B9.2
+F12F6.6	C14B9.2
+F13H10.4	C14B9.2
+F15C11.2	C14B9.2
+F19B6.2	C14B9.2
+F25D7.1	C14B9.2
+F26D10.3	C14B9.2
+F26E4.11	C14B9.2
+F26F4.9	C14B9.2
+F28F8.6	C14B9.2
+F32D8.6	C14B9.2
+F39B2.10	C14B9.2
+F40F9.6	C14B9.2
+F44E5.4	C14B9.2
+F44E5.5	C14B9.2
+F44G3.6	C14B9.2
+F45D3.5	C14B9.2
+F45E6.2	C14B9.2
+F46A9.4	C14B9.2
+F46A9.5	C14B9.2
+F46C3.1	C14B9.2
+F47H4.10	C14B9.2
+F48E3.3	C14B9.2
+F52C6.12	C14B9.2
+F52D1.1	C14B9.2
+F54D10.1	C14B9.2
+F54F2.9	C14B9.2
+F55A11.3	C14B9.2
+F55A3.1	C14B9.2
+F56B3.12	C14B9.2
+F56G4.5	C14B9.2
+F57B10.10	C14B9.2
+F57B10.11	C14B9.2
+F58A4.10	C14B9.2
+F59A6.1	C14B9.2
+F59E12.5	C14B9.2
+H06H21.6	C14B9.2
+H06O01.1	C14B9.2
+H14N18.1	C14B9.2
+K02B12.3	C14B9.2
+K02G10.8	C14B9.2
+K04G2.3	C14B9.2
+K07A1.8	C14B9.2
+K08A8.1	C14B9.2
+K08E3.7	C14B9.2
+K08H2.1	C14B9.2
+M7.1	C14B9.2
+R12H7.3	C14B9.2
+R12H7.5	C14B9.2
+R151.6	C14B9.2
+R74.3	C14B9.2
+T03G11.4	C14B9.2
+T04G9.3	C14B9.2
+T04G9.5	C14B9.2
+T05C3.5	C14B9.2
+T05E11.3	C14B9.2
+T05H10.5	C14B9.2
+T09A5.11	C14B9.2
+T09B4.10	C14B9.2
+T12A2.2	C14B9.2
+T14G8.3	C14B9.2
+T15H9.7	C14B9.2
+T22D1.4	C14B9.2
+T24H7.2	C14B9.2
+Y105C5B.13	C14B9.2
+Y105E8A.2	C14B9.2
+Y110A2AM.3	C14B9.2
+Y110A2AR.2	C14B9.2
+Y113G7A.3	C14B9.2
+Y37E3.10	C14B9.2
+Y37H2C.2	C14B9.2
+Y38A10A.5	C14B9.2
+Y38F2AR.2	C14B9.2
+Y38F2AR.9	C14B9.2
+Y47D7A.1	C14B9.2
+Y47D7A.8	C14B9.2
+Y47H9C.5	C14B9.2
+Y49E10.4	C14B9.2
+Y54G2A.18	C14B9.2
+Y56A3A.2	C14B9.2
+Y56A3A.21	C14B9.2
+Y57G11C.15	C14B9.2
+Y60A3A.18	C14B9.2
+Y63D3A.6	C14B9.2
+Y71F9AM.6	C14B9.2
+Y77E11A.13	C14B9.2
+Y87G2A.9	C14B9.2
+Y94H6A.9	C14B9.2
+ZC410.3	C14B9.2
+ZC506.1	C14B9.2
+ZC518.2	C14B9.2
+ZK1307.8	C14B9.2
+ZK180.4	C14B9.2
+ZK20.3	C14B9.2
+ZK287.5	C14B9.2
+ZK632.6	C14B9.2
+ZK686.3	C14B9.2
+C16C10.7	C15H9.6
+C24F3.1	C15H9.6
+C41C4.4	C15H9.6
+C41C4.8	C15H9.6
+C42D4.6	C15H9.6
+C47E12.3	C15H9.6
+C47E8.5	C15H9.6
+C52D10.6	C15H9.6
+C52D10.7	C15H9.6
+C52D10.8	C15H9.6
+C52D10.9	C15H9.6
+C52E4.5	C15H9.6
+C55B6.2	C15H9.6
+D1022.1	C15H9.6
+D2030.1	C15H9.6
+D2045.6	C15H9.6
+F10C2.5	C15H9.6
+F11F1.1	C15H9.6
+F12F6.6	C15H9.6
+F13H10.4	C15H9.6
+F15C11.2	C15H9.6
+F19B6.2	C15H9.6
+F25D7.1	C15H9.6
+F26D10.3	C15H9.6
+F26E4.11	C15H9.6
+F26F4.9	C15H9.6
+F28F8.6	C15H9.6
+F39B2.10	C15H9.6
+F40F9.6	C15H9.6
+F44E5.4	C15H9.6
+F44E5.5	C15H9.6
+F44G3.6	C15H9.6
+F45D3.5	C15H9.6
+F45E6.2	C15H9.6
+F46A9.4	C15H9.6
+F46A9.5	C15H9.6
+F46C3.1	C15H9.6
+F47H4.10	C15H9.6
+F48E3.3	C15H9.6
+F52C6.12	C15H9.6
+F52D1.1	C15H9.6
+F54D10.1	C15H9.6
+F54F2.9	C15H9.6
+F55A11.3	C15H9.6
+F55A3.1	C15H9.6
+F56B3.12	C15H9.6
+F56G4.5	C15H9.6
+F57B10.10	C15H9.6
+F58A4.10	C15H9.6
+F59A6.1	C15H9.6
+F59E12.5	C15H9.6
+H06H21.6	C15H9.6
+H06O01.1	C15H9.6
+H14N18.1	C15H9.6
+K02B12.3	C15H9.6
+K02G10.8	C15H9.6
+K04G2.3	C15H9.6
+K07A1.8	C15H9.6
+K08A8.1	C15H9.6
+K08E3.7	C15H9.6
+K08H2.1	C15H9.6
+M7.1	C15H9.6
+R12H7.3	C15H9.6
+R12H7.5	C15H9.6
+R151.6	C15H9.6
+R74.3	C15H9.6
+T03G11.4	C15H9.6
+T04G9.3	C15H9.6
+T04G9.5	C15H9.6
+T05C3.5	C15H9.6
+T05E11.3	C15H9.6
+T05H10.5	C15H9.6
+T09A5.11	C15H9.6
+T09B4.10	C15H9.6
+T12A2.2	C15H9.6
+T14G8.3	C15H9.6
+T15H9.7	C15H9.6
+T22D1.4	C15H9.6
+T24H7.2	C15H9.6
+Y105C5B.13	C15H9.6
+Y105E8A.2	C15H9.6
+Y110A2AM.3	C15H9.6
+Y110A2AR.2	C15H9.6
+Y113G7A.3	C15H9.6
+Y37E3.10	C15H9.6
+Y37H2C.2	C15H9.6
+Y38A10A.5	C15H9.6
+Y38F2AR.2	C15H9.6
+Y47D7A.1	C15H9.6
+Y47D7A.8	C15H9.6
+Y47H9C.5	C15H9.6
+Y49E10.4	C15H9.6
+Y54G2A.18	C15H9.6
+Y56A3A.2	C15H9.6
+Y56A3A.21	C15H9.6
+Y60A3A.18	C15H9.6
+Y71F9AM.6	C15H9.6
+Y77E11A.13	C15H9.6
+Y87G2A.9	C15H9.6
+Y94H6A.9	C15H9.6
+ZC410.3	C15H9.6
+ZC506.1	C15H9.6
+ZC518.2	C15H9.6
+ZK1307.8	C15H9.6
+ZK180.4	C15H9.6
+ZK20.3	C15H9.6
+ZK287.5	C15H9.6
+ZK632.6	C15H9.6
+ZK686.3	C15H9.6
+C18E9.2	C16C10.7
+C24F3.1	C16C10.7
+C41C4.4	C16C10.7
+C41C4.8	C16C10.7
+C42D4.6	C16C10.7
+C47E12.3	C16C10.7
+C47E8.5	C16C10.7
+C52D10.6	C16C10.7
+C52D10.7	C16C10.7
+C52D10.8	C16C10.7
+C52D10.9	C16C10.7
+C52E4.5	C16C10.7
+C55B6.2	C16C10.7
+D1022.1	C16C10.7
+D2030.1	C16C10.7
+D2045.6	C16C10.7
+F10C2.5	C16C10.7
+F11F1.1	C16C10.7
+F12F6.6	C16C10.7
+F13H10.4	C16C10.7
+F15C11.2	C16C10.7
+F19B6.2	C16C10.7
+F25D7.1	C16C10.7
+F26D10.3	C16C10.7
+F26E4.11	C16C10.7
+F26F4.9	C16C10.7
+F28F8.6	C16C10.7
+F32D8.6	C16C10.7
+F39B2.10	C16C10.7
+F40F9.6	C16C10.7
+F44E5.4	C16C10.7
+F44E5.5	C16C10.7
+F44G3.6	C16C10.7
+F45D3.5	C16C10.7
+F45E6.2	C16C10.7
+F46A9.4	C16C10.7
+F46A9.5	C16C10.7
+F46C3.1	C16C10.7
+F47H4.10	C16C10.7
+F48E3.3	C16C10.7
+F52C6.12	C16C10.7
+F52D1.1	C16C10.7
+F54D10.1	C16C10.7
+F54F2.9	C16C10.7
+F55A11.3	C16C10.7
+F55A3.1	C16C10.7
+F56B3.12	C16C10.7
+F56G4.5	C16C10.7
+F57B10.10	C16C10.7
+F57B10.11	C16C10.7
+F58A4.10	C16C10.7
+F59A6.1	C16C10.7
+F59E12.5	C16C10.7
+H06H21.6	C16C10.7
+H06O01.1	C16C10.7
+H14N18.1	C16C10.7
+K02B12.3	C16C10.7
+K02G10.8	C16C10.7
+K04G2.3	C16C10.7
+K07A1.8	C16C10.7
+K08A8.1	C16C10.7
+K08E3.7	C16C10.7
+K08H2.1	C16C10.7
+R12H7.3	C16C10.7
+R12H7.5	C16C10.7
+R151.6	C16C10.7
+R74.3	C16C10.7
+T03G11.4	C16C10.7
+T04G9.3	C16C10.7
+T04G9.5	C16C10.7
+T05C3.5	C16C10.7
+T05E11.3	C16C10.7
+T05H10.5	C16C10.7
+T09A5.11	C16C10.7
+T09B4.10	C16C10.7
+T12A2.2	C16C10.7
+T14G8.3	C16C10.7
+T15H9.7	C16C10.7
+T22D1.4	C16C10.7
+T24H7.2	C16C10.7
+Y105C5B.13	C16C10.7
+Y105E8A.2	C16C10.7
+Y110A2AM.3	C16C10.7
+Y110A2AR.2	C16C10.7
+Y113G7A.3	C16C10.7
+Y37E3.10	C16C10.7
+Y37H2C.2	C16C10.7
+Y38A10A.5	C16C10.7
+Y38F2AR.2	C16C10.7
+Y38F2AR.9	C16C10.7
+Y47D7A.1	C16C10.7
+Y47D7A.8	C16C10.7
+Y47H9C.5	C16C10.7
+Y49E10.4	C16C10.7
+Y54G2A.18	C16C10.7
+Y56A3A.2	C16C10.7
+Y56A3A.21	C16C10.7
+Y57G11C.15	C16C10.7
+Y60A3A.18	C16C10.7
+Y63D3A.6	C16C10.7
+Y71F9AM.6	C16C10.7
+Y77E11A.13	C16C10.7
+Y87G2A.9	C16C10.7
+Y94H6A.9	C16C10.7
+ZC410.3	C16C10.7
+ZC506.1	C16C10.7
+ZC518.2	C16C10.7
+ZK1307.8	C16C10.7
+ZK180.4	C16C10.7
+ZK20.3	C16C10.7
+ZK287.5	C16C10.7
+ZK632.6	C16C10.7
+ZK686.3	C16C10.7
+C24F3.1	C18E9.2
+C41C4.4	C18E9.2
+C41C4.8	C18E9.2
+C42D4.6	C18E9.2
+C47E12.3	C18E9.2
+C47E8.5	C18E9.2
+C52D10.6	C18E9.2
+C52D10.7	C18E9.2
+C52D10.8	C18E9.2
+C52D10.9	C18E9.2
+C52E4.5	C18E9.2
+C55B6.2	C18E9.2
+D1022.1	C18E9.2
+D2030.1	C18E9.2
+D2045.6	C18E9.2
+F10C2.5	C18E9.2
+F11F1.1	C18E9.2
+F12F6.6	C18E9.2
+F13H10.4	C18E9.2
+F15C11.2	C18E9.2
+F19B6.2	C18E9.2
+F25D7.1	C18E9.2
+F26D10.3	C18E9.2
+F26E4.11	C18E9.2
+F26F4.9	C18E9.2
+F28F8.6	C18E9.2
+F39B2.10	C18E9.2
+F40F9.6	C18E9.2
+F44E5.4	C18E9.2
+F44E5.5	C18E9.2
+F44G3.6	C18E9.2
+F45D3.5	C18E9.2
+F45E6.2	C18E9.2
+F46A9.4	C18E9.2
+F46A9.5	C18E9.2
+F46C3.1	C18E9.2
+F47H4.10	C18E9.2
+F48E3.3	C18E9.2
+F52C6.12	C18E9.2
+F52D1.1	C18E9.2
+F54D10.1	C18E9.2
+F54F2.9	C18E9.2
+F55A11.3	C18E9.2
+F55A3.1	C18E9.2
+F56B3.12	C18E9.2
+F56G4.5	C18E9.2
+F57B10.10	C18E9.2
+F57B10.11	C18E9.2
+F58A4.10	C18E9.2
+F59A6.1	C18E9.2
+F59E12.5	C18E9.2
+H06H21.6	C18E9.2
+H06O01.1	C18E9.2
+H14N18.1	C18E9.2
+K02B12.3	C18E9.2
+K02G10.8	C18E9.2
+K04G2.3	C18E9.2
+K07A1.8	C18E9.2
+K08A8.1	C18E9.2
+K08E3.7	C18E9.2
+K08H2.1	C18E9.2
+M7.1	C18E9.2
+R12H7.3	C18E9.2
+R12H7.5	C18E9.2
+R151.6	C18E9.2
+R74.3	C18E9.2
+T03G11.4	C18E9.2
+T04G9.3	C18E9.2
+T04G9.5	C18E9.2
+T05C3.5	C18E9.2
+T05E11.3	C18E9.2
+T05H10.5	C18E9.2
+T09A5.11	C18E9.2
+T09B4.10	C18E9.2
+T12A2.2	C18E9.2
+T14G8.3	C18E9.2
+T15H9.7	C18E9.2
+T22D1.4	C18E9.2
+T24H7.2	C18E9.2
+Y105C5B.13	C18E9.2
+Y105E8A.2	C18E9.2
+Y110A2AM.3	C18E9.2
+Y110A2AR.2	C18E9.2
+Y113G7A.3	C18E9.2
+Y37E3.10	C18E9.2
+Y37H2C.2	C18E9.2
+Y38A10A.5	C18E9.2
+Y38F2AR.2	C18E9.2
+Y47D7A.1	C18E9.2
+Y47D7A.8	C18E9.2
+Y47H9C.5	C18E9.2
+Y49E10.4	C18E9.2
+Y54G2A.18	C18E9.2
+Y56A3A.2	C18E9.2
+Y56A3A.21	C18E9.2
+Y60A3A.18	C18E9.2
+Y71F9AM.6	C18E9.2
+Y77E11A.13	C18E9.2
+Y87G2A.9	C18E9.2
+Y94H6A.9	C18E9.2
+ZC410.3	C18E9.2
+ZC506.1	C18E9.2
+ZC518.2	C18E9.2
+ZK1307.8	C18E9.2
+ZK180.4	C18E9.2
+ZK20.3	C18E9.2
+ZK287.5	C18E9.2
+ZK632.6	C18E9.2
+ZK686.3	C18E9.2
+C41C4.4	C24F3.1
+C41C4.8	C24F3.1
+C42D4.6	C24F3.1
+C47E12.3	C24F3.1
+C47E8.5	C24F3.1
+C52D10.6	C24F3.1
+C52D10.7	C24F3.1
+C52D10.8	C24F3.1
+C52D10.9	C24F3.1
+C52E4.5	C24F3.1
+C55B6.2	C24F3.1
+D1022.1	C24F3.1
+D2030.1	C24F3.1
+D2045.6	C24F3.1
+F10C2.5	C24F3.1
+F11F1.1	C24F3.1
+F12F6.6	C24F3.1
+F13H10.4	C24F3.1
+F15C11.2	C24F3.1
+F19B6.2	C24F3.1
+F25D7.1	C24F3.1
+F26D10.3	C24F3.1
+F26E4.11	C24F3.1
+F26F4.9	C24F3.1
+F28F8.6	C24F3.1
+F32D8.6	C24F3.1
+F39B2.10	C24F3.1
+F40F9.6	C24F3.1
+F44E5.4	C24F3.1
+F44E5.5	C24F3.1
+F44G3.6	C24F3.1
+F45D3.5	C24F3.1
+F45E6.2	C24F3.1
+F46A9.4	C24F3.1
+F46A9.5	C24F3.1
+F46C3.1	C24F3.1
+F47H4.10	C24F3.1
+F48E3.3	C24F3.1
+F52C6.12	C24F3.1
+F52D1.1	C24F3.1
+F54D10.1	C24F3.1
+F54F2.9	C24F3.1
+F55A11.3	C24F3.1
+F55A3.1	C24F3.1
+F56B3.12	C24F3.1
+F56G4.5	C24F3.1
+F57B10.10	C24F3.1
+F57B10.11	C24F3.1
+F58A4.10	C24F3.1
+F59A6.1	C24F3.1
+F59E12.5	C24F3.1
+H06H21.6	C24F3.1
+H06O01.1	C24F3.1
+H14N18.1	C24F3.1
+K02B12.3	C24F3.1
+K02G10.8	C24F3.1
+K04G2.3	C24F3.1
+K07A1.8	C24F3.1
+K08A8.1	C24F3.1
+K08E3.7	C24F3.1
+K08H2.1	C24F3.1
+M7.1	C24F3.1
+R12H7.3	C24F3.1
+R12H7.5	C24F3.1
+R151.6	C24F3.1
+R74.3	C24F3.1
+T03G11.4	C24F3.1
+T04G9.3	C24F3.1
+T04G9.5	C24F3.1
+T05C3.5	C24F3.1
+T05E11.3	C24F3.1
+T05H10.5	C24F3.1
+T09A5.11	C24F3.1
+T09B4.10	C24F3.1
+T12A2.2	C24F3.1
+T14G8.3	C24F3.1
+T15H9.7	C24F3.1
+T22D1.4	C24F3.1
+T24H7.2	C24F3.1
+Y105C5B.13	C24F3.1
+Y105E8A.2	C24F3.1
+Y110A2AM.3	C24F3.1
+Y110A2AR.2	C24F3.1
+Y113G7A.3	C24F3.1
+Y37E3.10	C24F3.1
+Y37H2C.2	C24F3.1
+Y38A10A.5	C24F3.1
+Y38F2AR.2	C24F3.1
+Y38F2AR.9	C24F3.1
+Y47D7A.1	C24F3.1
+Y47D7A.8	C24F3.1
+Y47H9C.5	C24F3.1
+Y49E10.4	C24F3.1
+Y54G2A.18	C24F3.1
+Y56A3A.2	C24F3.1
+Y56A3A.21	C24F3.1
+Y57G11C.15	C24F3.1
+Y60A3A.18	C24F3.1
+Y63D3A.6	C24F3.1
+Y71F9AM.6	C24F3.1
+Y77E11A.13	C24F3.1
+Y87G2A.9	C24F3.1
+Y94H6A.9	C24F3.1
+ZC410.3	C24F3.1
+ZC506.1	C24F3.1
+ZC518.2	C24F3.1
+ZK1307.8	C24F3.1
+ZK180.4	C24F3.1
+ZK20.3	C24F3.1
+ZK287.5	C24F3.1
+ZK632.6	C24F3.1
+ZK686.3	C24F3.1
+C41C4.8	C41C4.4
+C42D4.6	C41C4.4
+C47E12.3	C41C4.4
+C47E8.5	C41C4.4
+C52D10.6	C41C4.4
+C52D10.7	C41C4.4
+C52D10.8	C41C4.4
+C52D10.9	C41C4.4
+C52E4.5	C41C4.4
+C55B6.2	C41C4.4
+D1022.1	C41C4.4
+D2030.1	C41C4.4
+D2045.6	C41C4.4
+F10C2.5	C41C4.4
+F11F1.1	C41C4.4
+F12F6.6	C41C4.4
+F13H10.4	C41C4.4
+F15C11.2	C41C4.4
+F19B6.2	C41C4.4
+F25D7.1	C41C4.4
+F26D10.3	C41C4.4
+F26E4.11	C41C4.4
+F26F4.9	C41C4.4
+F28F8.6	C41C4.4
+F32D8.6	C41C4.4
+F39B2.10	C41C4.4
+F40F9.6	C41C4.4
+F44E5.4	C41C4.4
+F44E5.5	C41C4.4
+F44G3.6	C41C4.4
+F45D3.5	C41C4.4
+F45E6.2	C41C4.4
+F46A9.4	C41C4.4
+F46A9.5	C41C4.4
+F46C3.1	C41C4.4
+F47H4.10	C41C4.4
+F48E3.3	C41C4.4
+F52C6.12	C41C4.4
+F52D1.1	C41C4.4
+F54D10.1	C41C4.4
+F54F2.9	C41C4.4
+F55A11.3	C41C4.4
+F55A3.1	C41C4.4
+F56B3.12	C41C4.4
+F56G4.5	C41C4.4
+F57B10.10	C41C4.4
+F57B10.11	C41C4.4
+F58A4.10	C41C4.4
+F59A6.1	C41C4.4
+F59E12.5	C41C4.4
+H06H21.6	C41C4.4
+H06O01.1	C41C4.4
+H14N18.1	C41C4.4
+K02B12.3	C41C4.4
+K02G10.8	C41C4.4
+K04G2.3	C41C4.4
+K07A1.8	C41C4.4
+K08A8.1	C41C4.4
+K08E3.7	C41C4.4
+K08H2.1	C41C4.4
+M7.1	C41C4.4
+R12H7.3	C41C4.4
+R12H7.5	C41C4.4
+R151.6	C41C4.4
+R74.3	C41C4.4
+T03G11.4	C41C4.4
+T04G9.3	C41C4.4
+T04G9.5	C41C4.4
+T05C3.5	C41C4.4
+T05E11.3	C41C4.4
+T05H10.5	C41C4.4
+T09A5.11	C41C4.4
+T09B4.10	C41C4.4
+T12A2.2	C41C4.4
+T14G8.3	C41C4.4
+T15H9.7	C41C4.4
+T22D1.4	C41C4.4
+T24H7.2	C41C4.4
+Y105C5B.13	C41C4.4
+Y105E8A.2	C41C4.4
+Y110A2AM.3	C41C4.4
+Y110A2AR.2	C41C4.4
+Y113G7A.3	C41C4.4
+Y37E3.10	C41C4.4
+Y37H2C.2	C41C4.4
+Y38A10A.5	C41C4.4
+Y38F2AR.2	C41C4.4
+Y38F2AR.9	C41C4.4
+Y47D7A.1	C41C4.4
+Y47D7A.8	C41C4.4
+Y47H9C.5	C41C4.4
+Y49E10.4	C41C4.4
+Y54G2A.18	C41C4.4
+Y56A3A.2	C41C4.4
+Y56A3A.21	C41C4.4
+Y57G11C.15	C41C4.4
+Y60A3A.18	C41C4.4
+Y63D3A.6	C41C4.4
+Y71F9AM.6	C41C4.4
+Y77E11A.13	C41C4.4
+Y87G2A.9	C41C4.4
+Y94H6A.9	C41C4.4
+ZC410.3	C41C4.4
+ZC506.1	C41C4.4
+ZC518.2	C41C4.4
+ZK1307.8	C41C4.4
+ZK180.4	C41C4.4
+ZK20.3	C41C4.4
+ZK287.5	C41C4.4
+ZK632.6	C41C4.4
+ZK686.3	C41C4.4
+C42D4.6	C41C4.8
+C47E12.3	C41C4.8
+C47E8.5	C41C4.8
+C52D10.6	C41C4.8
+C52D10.7	C41C4.8
+C52D10.8	C41C4.8
+C52D10.9	C41C4.8
+C52E4.5	C41C4.8
+C55B6.2	C41C4.8
+D1022.1	C41C4.8
+D2030.1	C41C4.8
+D2045.6	C41C4.8
+F10C2.5	C41C4.8
+F11F1.1	C41C4.8
+F12F6.6	C41C4.8
+F13H10.4	C41C4.8
+F15C11.2	C41C4.8
+F19B6.2	C41C4.8
+F25D7.1	C41C4.8
+F26D10.3	C41C4.8
+F26E4.11	C41C4.8
+F26F4.9	C41C4.8
+F28F8.6	C41C4.8
+F32D8.6	C41C4.8
+F39B2.10	C41C4.8
+F40F9.6	C41C4.8
+F44E5.4	C41C4.8
+F44E5.5	C41C4.8
+F44G3.6	C41C4.8
+F45D3.5	C41C4.8
+F45E6.2	C41C4.8
+F46A9.4	C41C4.8
+F46A9.5	C41C4.8
+F46C3.1	C41C4.8
+F47H4.10	C41C4.8
+F48E3.3	C41C4.8
+F52C6.12	C41C4.8
+F52D1.1	C41C4.8
+F54D10.1	C41C4.8
+F54F2.9	C41C4.8
+F55A11.3	C41C4.8
+F55A3.1	C41C4.8
+F56B3.12	C41C4.8
+F56G4.5	C41C4.8
+F57B10.10	C41C4.8
+F57B10.11	C41C4.8
+F58A4.10	C41C4.8
+F59A6.1	C41C4.8
+F59E12.5	C41C4.8
+H06H21.6	C41C4.8
+H06O01.1	C41C4.8
+H14N18.1	C41C4.8
+K02B12.3	C41C4.8
+K02G10.8	C41C4.8
+K07A1.8	C41C4.8
+K08A8.1	C41C4.8
+K08E3.7	C41C4.8
+K08H2.1	C41C4.8
+M7.1	C41C4.8
+R12H7.3	C41C4.8
+R12H7.5	C41C4.8
+R151.6	C41C4.8
+R74.3	C41C4.8
+T03G11.4	C41C4.8
+T04G9.3	C41C4.8
+T04G9.5	C41C4.8
+T05C3.5	C41C4.8
+T05E11.3	C41C4.8
+T05H10.5	C41C4.8
+T09A5.11	C41C4.8
+T09B4.10	C41C4.8
+T12A2.2	C41C4.8
+T14G8.3	C41C4.8
+T15H9.7	C41C4.8
+T22D1.4	C41C4.8
+T24H7.2	C41C4.8
+Y105C5B.13	C41C4.8
+Y105E8A.2	C41C4.8
+Y110A2AM.3	C41C4.8
+Y110A2AR.2	C41C4.8
+Y113G7A.3	C41C4.8
+Y37E3.10	C41C4.8
+Y37H2C.2	C41C4.8
+Y38A10A.5	C41C4.8
+Y38F2AR.2	C41C4.8
+Y38F2AR.9	C41C4.8
+Y47D7A.1	C41C4.8
+Y47D7A.8	C41C4.8
+Y47H9C.5	C41C4.8
+Y49E10.4	C41C4.8
+Y54G2A.18	C41C4.8
+Y56A3A.2	C41C4.8
+Y56A3A.21	C41C4.8
+Y57G11C.15	C41C4.8
+Y60A3A.18	C41C4.8
+Y63D3A.6	C41C4.8
+Y71F9AM.6	C41C4.8
+Y77E11A.13	C41C4.8
+Y87G2A.9	C41C4.8
+Y94H6A.9	C41C4.8
+ZC410.3	C41C4.8
+ZC506.1	C41C4.8
+ZC518.2	C41C4.8
+ZK1307.8	C41C4.8
+ZK180.4	C41C4.8
+ZK20.3	C41C4.8
+ZK287.5	C41C4.8
+ZK632.6	C41C4.8
+ZK686.3	C41C4.8
+C47E12.3	C42D4.6
+C47E8.5	C42D4.6
+C52E4.5	C42D4.6
+C55B6.2	C42D4.6
+D2030.1	C42D4.6
+F10C2.5	C42D4.6
+F11F1.1	C42D4.6
+F12F6.6	C42D4.6
+F13H10.4	C42D4.6
+F15C11.2	C42D4.6
+F19B6.2	C42D4.6
+F25D7.1	C42D4.6
+F26D10.3	C42D4.6
+F26E4.11	C42D4.6
+F26F4.9	C42D4.6
+F28F8.6	C42D4.6
+F32D8.6	C42D4.6
+F39B2.10	C42D4.6
+F40F9.6	C42D4.6
+F44E5.4	C42D4.6
+F44E5.5	C42D4.6
+F45D3.5	C42D4.6
+F45E6.2	C42D4.6
+F46C3.1	C42D4.6
+F48E3.3	C42D4.6
+F52D1.1	C42D4.6
+F54F2.9	C42D4.6
+F55A3.1	C42D4.6
+F56G4.5	C42D4.6
+F57B10.10	C42D4.6
+F57B10.11	C42D4.6
+F59A6.1	C42D4.6
+F59E12.5	C42D4.6
+H06H21.6	C42D4.6
+H06O01.1	C42D4.6
+H14N18.1	C42D4.6
+K02B12.3	C42D4.6
+K02G10.8	C42D4.6
+K04G2.3	C42D4.6
+K07A1.8	C42D4.6
+K08A8.1	C42D4.6
+R151.6	C42D4.6
+R74.3	C42D4.6
+T03G11.4	C42D4.6
+T04G9.3	C42D4.6
+T04G9.5	C42D4.6
+T05C3.5	C42D4.6
+T05E11.3	C42D4.6
+T09A5.11	C42D4.6
+T12A2.2	C42D4.6
+T14G8.3	C42D4.6
+T15H9.7	C42D4.6
+T22D1.4	C42D4.6
+T24H7.2	C42D4.6
+Y105E8A.2	C42D4.6
+Y113G7A.3	C42D4.6
+Y37E3.10	C42D4.6
+Y38A10A.5	C42D4.6
+Y38F2AR.2	C42D4.6
+Y38F2AR.9	C42D4.6
+Y47H9C.5	C42D4.6
+Y49E10.4	C42D4.6
+Y54G2A.18	C42D4.6
+Y56A3A.2	C42D4.6
+Y56A3A.21	C42D4.6
+Y57G11C.15	C42D4.6
+Y63D3A.6	C42D4.6
+Y71F9AM.6	C42D4.6
+Y77E11A.13	C42D4.6
+Y94H6A.9	C42D4.6
+ZC410.3	C42D4.6
+ZC506.1	C42D4.6
+ZC518.2	C42D4.6
+ZK1307.8	C42D4.6
+ZK180.4	C42D4.6
+ZK20.3	C42D4.6
+ZK632.6	C42D4.6
+ZK686.3	C42D4.6
+C47E8.5	C47E12.3
+C52D10.6	C47E12.3
+C52D10.7	C47E12.3
+C52D10.8	C47E12.3
+C52D10.9	C47E12.3
+C52E4.5	C47E12.3
+C55B6.2	C47E12.3
+D1022.1	C47E12.3
+D2030.1	C47E12.3
+D2045.6	C47E12.3
+F10C2.5	C47E12.3
+F11F1.1	C47E12.3
+F12F6.6	C47E12.3
+F13H10.4	C47E12.3
+F15C11.2	C47E12.3
+F19B6.2	C47E12.3
+F25D7.1	C47E12.3
+F26D10.3	C47E12.3
+F26E4.11	C47E12.3
+F26F4.9	C47E12.3
+F28F8.6	C47E12.3
+F32D8.6	C47E12.3
+F39B2.10	C47E12.3
+F40F9.6	C47E12.3
+F44E5.4	C47E12.3
+F44E5.5	C47E12.3
+F44G3.6	C47E12.3
+F45D3.5	C47E12.3
+F45E6.2	C47E12.3
+F46A9.4	C47E12.3
+F46A9.5	C47E12.3
+F46C3.1	C47E12.3
+F47H4.10	C47E12.3
+F48E3.3	C47E12.3
+F52C6.12	C47E12.3
+F52D1.1	C47E12.3
+F54D10.1	C47E12.3
+F54F2.9	C47E12.3
+F55A11.3	C47E12.3
+F55A3.1	C47E12.3
+F56B3.12	C47E12.3
+F56G4.5	C47E12.3
+F57B10.10	C47E12.3
+F57B10.11	C47E12.3
+F58A4.10	C47E12.3
+F59A6.1	C47E12.3
+F59E12.5	C47E12.3
+H06H21.6	C47E12.3
+H06O01.1	C47E12.3
+H14N18.1	C47E12.3
+K02B12.3	C47E12.3
+K02G10.8	C47E12.3
+K04G2.3	C47E12.3
+K07A1.8	C47E12.3
+K08A8.1	C47E12.3
+K08E3.7	C47E12.3
+K08H2.1	C47E12.3
+M7.1	C47E12.3
+R12H7.3	C47E12.3
+R12H7.5	C47E12.3
+R151.6	C47E12.3
+R74.3	C47E12.3
+T03G11.4	C47E12.3
+T04G9.3	C47E12.3
+T04G9.5	C47E12.3
+T05C3.5	C47E12.3
+T05E11.3	C47E12.3
+T05H10.5	C47E12.3
+T09A5.11	C47E12.3
+T09B4.10	C47E12.3
+T12A2.2	C47E12.3
+T14G8.3	C47E12.3
+T15H9.7	C47E12.3
+T22D1.4	C47E12.3
+T24H7.2	C47E12.3
+Y105C5B.13	C47E12.3
+Y105E8A.2	C47E12.3
+Y110A2AM.3	C47E12.3
+Y110A2AR.2	C47E12.3
+Y113G7A.3	C47E12.3
+Y37E3.10	C47E12.3
+Y37H2C.2	C47E12.3
+Y38A10A.5	C47E12.3
+Y38F2AR.2	C47E12.3
+Y38F2AR.9	C47E12.3
+Y47D7A.1	C47E12.3
+Y47D7A.8	C47E12.3
+Y47H9C.5	C47E12.3
+Y49E10.4	C47E12.3
+Y54G2A.18	C47E12.3
+Y56A3A.2	C47E12.3
+Y56A3A.21	C47E12.3
+Y57G11C.15	C47E12.3
+Y60A3A.18	C47E12.3
+Y63D3A.6	C47E12.3
+Y71F9AM.6	C47E12.3
+Y77E11A.13	C47E12.3
+Y87G2A.9	C47E12.3
+Y94H6A.9	C47E12.3
+ZC410.3	C47E12.3
+ZC506.1	C47E12.3
+ZC518.2	C47E12.3
+ZK1307.8	C47E12.3
+ZK180.4	C47E12.3
+ZK20.3	C47E12.3
+ZK287.5	C47E12.3
+ZK632.6	C47E12.3
+ZK686.3	C47E12.3
+C52D10.6	C47E8.5
+C52D10.7	C47E8.5
+C52D10.8	C47E8.5
+C52D10.9	C47E8.5
+C52E4.5	C47E8.5
+C55B6.2	C47E8.5
+D1022.1	C47E8.5
+D2030.1	C47E8.5
+D2045.6	C47E8.5
+F10C2.5	C47E8.5
+F11F1.1	C47E8.5
+F12F6.6	C47E8.5
+F13H10.4	C47E8.5
+F15C11.2	C47E8.5
+F19B6.2	C47E8.5
+F25D7.1	C47E8.5
+F26D10.3	C47E8.5
+F26E4.11	C47E8.5
+F26F4.9	C47E8.5
+F28F8.6	C47E8.5
+F32D8.6	C47E8.5
+F39B2.10	C47E8.5
+F40F9.6	C47E8.5
+F44E5.4	C47E8.5
+F44E5.5	C47E8.5
+F44G3.6	C47E8.5
+F45D3.5	C47E8.5
+F45E6.2	C47E8.5
+F46A9.4	C47E8.5
+F46A9.5	C47E8.5
+F46C3.1	C47E8.5
+F47H4.10	C47E8.5
+F48E3.3	C47E8.5
+F52C6.12	C47E8.5
+F52D1.1	C47E8.5
+F54D10.1	C47E8.5
+F54F2.9	C47E8.5
+F55A11.3	C47E8.5
+F55A3.1	C47E8.5
+F56B3.12	C47E8.5
+F56G4.5	C47E8.5
+F57B10.10	C47E8.5
+F57B10.11	C47E8.5
+F58A4.10	C47E8.5
+F59A6.1	C47E8.5
+F59E12.5	C47E8.5
+H06H21.6	C47E8.5
+H06O01.1	C47E8.5
+H14N18.1	C47E8.5
+K02B12.3	C47E8.5
+K02G10.8	C47E8.5
+K04G2.3	C47E8.5
+K07A1.8	C47E8.5
+K08A8.1	C47E8.5
+K08E3.7	C47E8.5
+K08H2.1	C47E8.5
+M7.1	C47E8.5
+R12H7.3	C47E8.5
+R12H7.5	C47E8.5
+R151.6	C47E8.5
+R74.3	C47E8.5
+T03G11.4	C47E8.5
+T04G9.3	C47E8.5
+T04G9.5	C47E8.5
+T05C3.5	C47E8.5
+T05E11.3	C47E8.5
+T05H10.5	C47E8.5
+T09A5.11	C47E8.5
+T09B4.10	C47E8.5
+T12A2.2	C47E8.5
+T14G8.3	C47E8.5
+T15H9.7	C47E8.5
+T22D1.4	C47E8.5
+T24H7.2	C47E8.5
+Y105C5B.13	C47E8.5
+Y105E8A.2	C47E8.5
+Y110A2AM.3	C47E8.5
+Y110A2AR.2	C47E8.5
+Y113G7A.3	C47E8.5
+Y37E3.10	C47E8.5
+Y37H2C.2	C47E8.5
+Y38A10A.5	C47E8.5
+Y38F2AR.2	C47E8.5
+Y38F2AR.9	C47E8.5
+Y47D7A.1	C47E8.5
+Y47D7A.8	C47E8.5
+Y47H9C.5	C47E8.5
+Y49E10.4	C47E8.5
+Y54G2A.18	C47E8.5
+Y56A3A.2	C47E8.5
+Y56A3A.21	C47E8.5
+Y57G11C.15	C47E8.5
+Y60A3A.18	C47E8.5
+Y63D3A.6	C47E8.5
+Y71F9AM.6	C47E8.5
+Y77E11A.13	C47E8.5
+Y87G2A.9	C47E8.5
+Y94H6A.9	C47E8.5
+ZC410.3	C47E8.5
+ZC506.1	C47E8.5
+ZC518.2	C47E8.5
+ZK1307.8	C47E8.5
+ZK180.4	C47E8.5
+ZK20.3	C47E8.5
+ZK287.5	C47E8.5
+ZK632.6	C47E8.5
+ZK686.3	C47E8.5
+C52E4.5	C52D10.6
+C55B6.2	C52D10.6
+D2030.1	C52D10.6
+F10C2.5	C52D10.6
+F11F1.1	C52D10.6
+F12F6.6	C52D10.6
+F13H10.4	C52D10.6
+F15C11.2	C52D10.6
+F19B6.2	C52D10.6
+F25D7.1	C52D10.6
+F26D10.3	C52D10.6
+F26E4.11	C52D10.6
+F26F4.9	C52D10.6
+F28F8.6	C52D10.6
+F32D8.6	C52D10.6
+F39B2.10	C52D10.6
+F40F9.6	C52D10.6
+F44E5.4	C52D10.6
+F44E5.5	C52D10.6
+F45D3.5	C52D10.6
+F45E6.2	C52D10.6
+F46C3.1	C52D10.6
+F48E3.3	C52D10.6
+F52D1.1	C52D10.6
+F54F2.9	C52D10.6
+F55A3.1	C52D10.6
+F56G4.5	C52D10.6
+F57B10.10	C52D10.6
+F57B10.11	C52D10.6
+F59A6.1	C52D10.6
+F59E12.5	C52D10.6
+H06H21.6	C52D10.6
+H06O01.1	C52D10.6
+H14N18.1	C52D10.6
+K02B12.3	C52D10.6
+K02G10.8	C52D10.6
+K04G2.3	C52D10.6
+K07A1.8	C52D10.6
+K08A8.1	C52D10.6
+R151.6	C52D10.6
+R74.3	C52D10.6
+T03G11.4	C52D10.6
+T04G9.3	C52D10.6
+T04G9.5	C52D10.6
+T05C3.5	C52D10.6
+T05E11.3	C52D10.6
+T09A5.11	C52D10.6
+T12A2.2	C52D10.6
+T14G8.3	C52D10.6
+T15H9.7	C52D10.6
+T22D1.4	C52D10.6
+T24H7.2	C52D10.6
+Y105E8A.2	C52D10.6
+Y113G7A.3	C52D10.6
+Y37E3.10	C52D10.6
+Y38A10A.5	C52D10.6
+Y38F2AR.2	C52D10.6
+Y38F2AR.9	C52D10.6
+Y47H9C.5	C52D10.6
+Y49E10.4	C52D10.6
+Y54G2A.18	C52D10.6
+Y56A3A.2	C52D10.6
+Y56A3A.21	C52D10.6
+Y57G11C.15	C52D10.6
+Y63D3A.6	C52D10.6
+Y71F9AM.6	C52D10.6
+Y77E11A.13	C52D10.6
+Y94H6A.9	C52D10.6
+ZC410.3	C52D10.6
+ZC506.1	C52D10.6
+ZC518.2	C52D10.6
+ZK1307.8	C52D10.6
+ZK180.4	C52D10.6
+ZK20.3	C52D10.6
+ZK632.6	C52D10.6
+ZK686.3	C52D10.6
+C52E4.5	C52D10.7
+C55B6.2	C52D10.7
+D2030.1	C52D10.7
+F10C2.5	C52D10.7
+F11F1.1	C52D10.7
+F12F6.6	C52D10.7
+F13H10.4	C52D10.7
+F15C11.2	C52D10.7
+F19B6.2	C52D10.7
+F25D7.1	C52D10.7
+F26D10.3	C52D10.7
+F26E4.11	C52D10.7
+F26F4.9	C52D10.7
+F28F8.6	C52D10.7
+F32D8.6	C52D10.7
+F39B2.10	C52D10.7
+F40F9.6	C52D10.7
+F44E5.4	C52D10.7
+F44E5.5	C52D10.7
+F45D3.5	C52D10.7
+F45E6.2	C52D10.7
+F46C3.1	C52D10.7
+F48E3.3	C52D10.7
+F52D1.1	C52D10.7
+F54F2.9	C52D10.7
+F55A3.1	C52D10.7
+F56G4.5	C52D10.7
+F57B10.10	C52D10.7
+F57B10.11	C52D10.7
+F59A6.1	C52D10.7
+F59E12.5	C52D10.7
+H06H21.6	C52D10.7
+H06O01.1	C52D10.7
+H14N18.1	C52D10.7
+K02B12.3	C52D10.7
+K02G10.8	C52D10.7
+K04G2.3	C52D10.7
+K07A1.8	C52D10.7
+K08A8.1	C52D10.7
+R151.6	C52D10.7
+R74.3	C52D10.7
+T03G11.4	C52D10.7
+T04G9.3	C52D10.7
+T04G9.5	C52D10.7
+T05C3.5	C52D10.7
+T05E11.3	C52D10.7
+T09A5.11	C52D10.7
+T12A2.2	C52D10.7
+T14G8.3	C52D10.7
+T15H9.7	C52D10.7
+T22D1.4	C52D10.7
+T24H7.2	C52D10.7
+Y105E8A.2	C52D10.7
+Y113G7A.3	C52D10.7
+Y37E3.10	C52D10.7
+Y38A10A.5	C52D10.7
+Y38F2AR.2	C52D10.7
+Y38F2AR.9	C52D10.7
+Y47H9C.5	C52D10.7
+Y49E10.4	C52D10.7
+Y54G2A.18	C52D10.7
+Y56A3A.2	C52D10.7
+Y56A3A.21	C52D10.7
+Y57G11C.15	C52D10.7
+Y63D3A.6	C52D10.7
+Y71F9AM.6	C52D10.7
+Y77E11A.13	C52D10.7
+Y94H6A.9	C52D10.7
+ZC410.3	C52D10.7
+ZC506.1	C52D10.7
+ZC518.2	C52D10.7
+ZK1307.8	C52D10.7
+ZK180.4	C52D10.7
+ZK20.3	C52D10.7
+ZK632.6	C52D10.7
+ZK686.3	C52D10.7
+C52E4.5	C52D10.8
+C55B6.2	C52D10.8
+D2030.1	C52D10.8
+F10C2.5	C52D10.8
+F11F1.1	C52D10.8
+F12F6.6	C52D10.8
+F13H10.4	C52D10.8
+F15C11.2	C52D10.8
+F19B6.2	C52D10.8
+F25D7.1	C52D10.8
+F26D10.3	C52D10.8
+F26E4.11	C52D10.8
+F26F4.9	C52D10.8
+F28F8.6	C52D10.8
+F32D8.6	C52D10.8
+F39B2.10	C52D10.8
+F40F9.6	C52D10.8
+F44E5.4	C52D10.8
+F44E5.5	C52D10.8
+F45D3.5	C52D10.8
+F45E6.2	C52D10.8
+F46C3.1	C52D10.8
+F48E3.3	C52D10.8
+F52D1.1	C52D10.8
+F54F2.9	C52D10.8
+F55A3.1	C52D10.8
+F56G4.5	C52D10.8
+F57B10.10	C52D10.8
+F57B10.11	C52D10.8
+F59A6.1	C52D10.8
+F59E12.5	C52D10.8
+H06H21.6	C52D10.8
+H06O01.1	C52D10.8
+H14N18.1	C52D10.8
+K02B12.3	C52D10.8
+K02G10.8	C52D10.8
+K04G2.3	C52D10.8
+K07A1.8	C52D10.8
+K08A8.1	C52D10.8
+R151.6	C52D10.8
+R74.3	C52D10.8
+T03G11.4	C52D10.8
+T04G9.3	C52D10.8
+T04G9.5	C52D10.8
+T05C3.5	C52D10.8
+T05E11.3	C52D10.8
+T09A5.11	C52D10.8
+T12A2.2	C52D10.8
+T14G8.3	C52D10.8
+T15H9.7	C52D10.8
+T22D1.4	C52D10.8
+T24H7.2	C52D10.8
+Y105E8A.2	C52D10.8
+Y113G7A.3	C52D10.8
+Y37E3.10	C52D10.8
+Y38A10A.5	C52D10.8
+Y38F2AR.2	C52D10.8
+Y38F2AR.9	C52D10.8
+Y47H9C.5	C52D10.8
+Y49E10.4	C52D10.8
+Y54G2A.18	C52D10.8
+Y56A3A.2	C52D10.8
+Y56A3A.21	C52D10.8
+Y57G11C.15	C52D10.8
+Y63D3A.6	C52D10.8
+Y71F9AM.6	C52D10.8
+Y77E11A.13	C52D10.8
+Y94H6A.9	C52D10.8
+ZC410.3	C52D10.8
+ZC506.1	C52D10.8
+ZC518.2	C52D10.8
+ZK1307.8	C52D10.8
+ZK180.4	C52D10.8
+ZK20.3	C52D10.8
+ZK632.6	C52D10.8
+ZK686.3	C52D10.8
+C52E4.5	C52D10.9
+C55B6.2	C52D10.9
+D2030.1	C52D10.9
+F10C2.5	C52D10.9
+F11F1.1	C52D10.9
+F12F6.6	C52D10.9
+F13H10.4	C52D10.9
+F15C11.2	C52D10.9
+F19B6.2	C52D10.9
+F25D7.1	C52D10.9
+F26D10.3	C52D10.9
+F26E4.11	C52D10.9
+F26F4.9	C52D10.9
+F28F8.6	C52D10.9
+F32D8.6	C52D10.9
+F39B2.10	C52D10.9
+F40F9.6	C52D10.9
+F44E5.4	C52D10.9
+F44E5.5	C52D10.9
+F45D3.5	C52D10.9
+F45E6.2	C52D10.9
+F46C3.1	C52D10.9
+F48E3.3	C52D10.9
+F52D1.1	C52D10.9
+F54F2.9	C52D10.9
+F55A3.1	C52D10.9
+F56G4.5	C52D10.9
+F57B10.10	C52D10.9
+F57B10.11	C52D10.9
+F59A6.1	C52D10.9
+F59E12.5	C52D10.9
+H06H21.6	C52D10.9
+H06O01.1	C52D10.9
+H14N18.1	C52D10.9
+K02B12.3	C52D10.9
+K02G10.8	C52D10.9
+K04G2.3	C52D10.9
+K07A1.8	C52D10.9
+K08A8.1	C52D10.9
+R151.6	C52D10.9
+R74.3	C52D10.9
+T03G11.4	C52D10.9
+T04G9.3	C52D10.9
+T04G9.5	C52D10.9
+T05C3.5	C52D10.9
+T05E11.3	C52D10.9
+T09A5.11	C52D10.9
+T12A2.2	C52D10.9
+T14G8.3	C52D10.9
+T15H9.7	C52D10.9
+T22D1.4	C52D10.9
+T24H7.2	C52D10.9
+Y105E8A.2	C52D10.9
+Y113G7A.3	C52D10.9
+Y37E3.10	C52D10.9
+Y38A10A.5	C52D10.9
+Y38F2AR.2	C52D10.9
+Y38F2AR.9	C52D10.9
+Y47H9C.5	C52D10.9
+Y49E10.4	C52D10.9
+Y54G2A.18	C52D10.9
+Y56A3A.2	C52D10.9
+Y56A3A.21	C52D10.9
+Y57G11C.15	C52D10.9
+Y63D3A.6	C52D10.9
+Y71F9AM.6	C52D10.9
+Y77E11A.13	C52D10.9
+Y94H6A.9	C52D10.9
+ZC410.3	C52D10.9
+ZC506.1	C52D10.9
+ZC518.2	C52D10.9
+ZK1307.8	C52D10.9
+ZK180.4	C52D10.9
+ZK20.3	C52D10.9
+ZK632.6	C52D10.9
+ZK686.3	C52D10.9
+C55B6.2	C52E4.5
+D1022.1	C52E4.5
+D2045.6	C52E4.5
+F10C2.5	C52E4.5
+F11F1.1	C52E4.5
+F12F6.6	C52E4.5
+F15C11.2	C52E4.5
+F19B6.2	C52E4.5
+F25D7.1	C52E4.5
+F26D10.3	C52E4.5
+F26E4.11	C52E4.5
+F26F4.9	C52E4.5
+F28F8.6	C52E4.5
+F32D8.6	C52E4.5
+F39B2.10	C52E4.5
+F44E5.4	C52E4.5
+F44E5.5	C52E4.5
+F44G3.6	C52E4.5
+F45D3.5	C52E4.5
+F45E6.2	C52E4.5
+F46A9.4	C52E4.5
+F46A9.5	C52E4.5
+F46C3.1	C52E4.5
+F47H4.10	C52E4.5
+F48E3.3	C52E4.5
+F52C6.12	C52E4.5
+F54D10.1	C52E4.5
+F54F2.9	C52E4.5
+F55A11.3	C52E4.5
+F55A3.1	C52E4.5
+F56B3.12	C52E4.5
+F56G4.5	C52E4.5
+F57B10.11	C52E4.5
+F58A4.10	C52E4.5
+F59A6.1	C52E4.5
+F59E12.5	C52E4.5
+H06H21.6	C52E4.5
+H06O01.1	C52E4.5
+H14N18.1	C52E4.5
+K02B12.3	C52E4.5
+K02G10.8	C52E4.5
+K04G2.3	C52E4.5
+K07A1.8	C52E4.5
+K08A8.1	C52E4.5
+K08E3.7	C52E4.5
+K08H2.1	C52E4.5
+M7.1	C52E4.5
+R12H7.3	C52E4.5
+R12H7.5	C52E4.5
+R151.6	C52E4.5
+R74.3	C52E4.5
+T04G9.3	C52E4.5
+T04G9.5	C52E4.5
+T05C3.5	C52E4.5
+T05E11.3	C52E4.5
+T05H10.5	C52E4.5
+T09B4.10	C52E4.5
+T14G8.3	C52E4.5
+T15H9.7	C52E4.5
+T24H7.2	C52E4.5
+Y105C5B.13	C52E4.5
+Y105E8A.2	C52E4.5
+Y110A2AM.3	C52E4.5
+Y110A2AR.2	C52E4.5
+Y113G7A.3	C52E4.5
+Y37E3.10	C52E4.5
+Y37H2C.2	C52E4.5
+Y38A10A.5	C52E4.5
+Y38F2AR.2	C52E4.5
+Y38F2AR.9	C52E4.5
+Y47D7A.1	C52E4.5
+Y47D7A.8	C52E4.5
+Y47H9C.5	C52E4.5
+Y49E10.4	C52E4.5
+Y54G2A.18	C52E4.5
+Y56A3A.2	C52E4.5
+Y56A3A.21	C52E4.5
+Y57G11C.15	C52E4.5
+Y60A3A.18	C52E4.5
+Y63D3A.6	C52E4.5
+Y71F9AM.6	C52E4.5
+Y77E11A.13	C52E4.5
+Y87G2A.9	C52E4.5
+Y94H6A.9	C52E4.5
+ZC506.1	C52E4.5
+ZC518.2	C52E4.5
+ZK1307.8	C52E4.5
+ZK180.4	C52E4.5
+ZK20.3	C52E4.5
+ZK287.5	C52E4.5
+ZK632.6	C52E4.5
+D1022.1	C55B6.2
+D2030.1	C55B6.2
+D2045.6	C55B6.2
+F10C2.5	C55B6.2
+F11F1.1	C55B6.2
+F12F6.6	C55B6.2
+F13H10.4	C55B6.2
+F15C11.2	C55B6.2
+F19B6.2	C55B6.2
+F25D7.1	C55B6.2
+F26D10.3	C55B6.2
+F26E4.11	C55B6.2
+F26F4.9	C55B6.2
+F28F8.6	C55B6.2
+F32D8.6	C55B6.2
+F39B2.10	C55B6.2
+F40F9.6	C55B6.2
+F44E5.4	C55B6.2
+F44E5.5	C55B6.2
+F44G3.6	C55B6.2
+F45D3.5	C55B6.2
+F45E6.2	C55B6.2
+F46A9.4	C55B6.2
+F46A9.5	C55B6.2
+F46C3.1	C55B6.2
+F47H4.10	C55B6.2
+F48E3.3	C55B6.2
+F52C6.12	C55B6.2
+F52D1.1	C55B6.2
+F54D10.1	C55B6.2
+F54F2.9	C55B6.2
+F55A11.3	C55B6.2
+F55A3.1	C55B6.2
+F56B3.12	C55B6.2
+F56G4.5	C55B6.2
+F57B10.10	C55B6.2
+F57B10.11	C55B6.2
+F58A4.10	C55B6.2
+F59A6.1	C55B6.2
+F59E12.5	C55B6.2
+H06H21.6	C55B6.2
+H06O01.1	C55B6.2
+H14N18.1	C55B6.2
+K02B12.3	C55B6.2
+K02G10.8	C55B6.2
+K04G2.3	C55B6.2
+K07A1.8	C55B6.2
+K08A8.1	C55B6.2
+K08E3.7	C55B6.2
+K08H2.1	C55B6.2
+M7.1	C55B6.2
+R12H7.3	C55B6.2
+R12H7.5	C55B6.2
+R151.6	C55B6.2
+R74.3	C55B6.2
+T03G11.4	C55B6.2
+T04G9.3	C55B6.2
+T04G9.5	C55B6.2
+T05C3.5	C55B6.2
+T05E11.3	C55B6.2
+T05H10.5	C55B6.2
+T09A5.11	C55B6.2
+T09B4.10	C55B6.2
+T12A2.2	C55B6.2
+T14G8.3	C55B6.2
+T15H9.7	C55B6.2
+T22D1.4	C55B6.2
+T24H7.2	C55B6.2
+Y105C5B.13	C55B6.2
+Y105E8A.2	C55B6.2
+Y110A2AM.3	C55B6.2
+Y110A2AR.2	C55B6.2
+Y113G7A.3	C55B6.2
+Y37E3.10	C55B6.2
+Y37H2C.2	C55B6.2
+Y38A10A.5	C55B6.2
+Y38F2AR.2	C55B6.2
+Y38F2AR.9	C55B6.2
+Y47D7A.1	C55B6.2
+Y47D7A.8	C55B6.2
+Y47H9C.5	C55B6.2
+Y49E10.4	C55B6.2
+Y54G2A.18	C55B6.2
+Y56A3A.2	C55B6.2
+Y56A3A.21	C55B6.2
+Y57G11C.15	C55B6.2
+Y60A3A.18	C55B6.2
+Y63D3A.6	C55B6.2
+Y71F9AM.6	C55B6.2
+Y77E11A.13	C55B6.2
+Y87G2A.9	C55B6.2
+Y94H6A.9	C55B6.2
+ZC410.3	C55B6.2
+ZC506.1	C55B6.2
+ZC518.2	C55B6.2
+ZK1307.8	C55B6.2
+ZK180.4	C55B6.2
+ZK20.3	C55B6.2
+ZK287.5	C55B6.2
+ZK632.6	C55B6.2
+ZK686.3	C55B6.2
+D2030.1	D1022.1
+F10C2.5	D1022.1
+F11F1.1	D1022.1
+F12F6.6	D1022.1
+F13H10.4	D1022.1
+F15C11.2	D1022.1
+F19B6.2	D1022.1
+F25D7.1	D1022.1
+F26D10.3	D1022.1
+F26E4.11	D1022.1
+F26F4.9	D1022.1
+F28F8.6	D1022.1
+F32D8.6	D1022.1
+F39B2.10	D1022.1
+F40F9.6	D1022.1
+F44E5.4	D1022.1
+F44E5.5	D1022.1
+F45D3.5	D1022.1
+F45E6.2	D1022.1
+F46C3.1	D1022.1
+F48E3.3	D1022.1
+F52D1.1	D1022.1
+F54F2.9	D1022.1
+F55A3.1	D1022.1
+F56G4.5	D1022.1
+F57B10.10	D1022.1
+F57B10.11	D1022.1
+F59A6.1	D1022.1
+F59E12.5	D1022.1
+H06H21.6	D1022.1
+H06O01.1	D1022.1
+H14N18.1	D1022.1
+K02B12.3	D1022.1
+K02G10.8	D1022.1
+K04G2.3	D1022.1
+K07A1.8	D1022.1
+K08A8.1	D1022.1
+R151.6	D1022.1
+R74.3	D1022.1
+T03G11.4	D1022.1
+T04G9.3	D1022.1
+T04G9.5	D1022.1
+T05C3.5	D1022.1
+T05E11.3	D1022.1
+T09A5.11	D1022.1
+T12A2.2	D1022.1
+T14G8.3	D1022.1
+T15H9.7	D1022.1
+T22D1.4	D1022.1
+T24H7.2	D1022.1
+Y105E8A.2	D1022.1
+Y113G7A.3	D1022.1
+Y37E3.10	D1022.1
+Y38A10A.5	D1022.1
+Y38F2AR.2	D1022.1
+Y38F2AR.9	D1022.1
+Y47H9C.5	D1022.1
+Y49E10.4	D1022.1
+Y54G2A.18	D1022.1
+Y56A3A.2	D1022.1
+Y56A3A.21	D1022.1
+Y57G11C.15	D1022.1
+Y63D3A.6	D1022.1
+Y71F9AM.6	D1022.1
+Y77E11A.13	D1022.1
+Y94H6A.9	D1022.1
+ZC410.3	D1022.1
+ZC506.1	D1022.1
+ZC518.2	D1022.1
+ZK1307.8	D1022.1
+ZK180.4	D1022.1
+ZK20.3	D1022.1
+ZK632.6	D1022.1
+ZK686.3	D1022.1
+D2045.6	D2030.1
+F10C2.5	D2030.1
+F11F1.1	D2030.1
+F12F6.6	D2030.1
+F15C11.2	D2030.1
+F19B6.2	D2030.1
+F25D7.1	D2030.1
+F26D10.3	D2030.1
+F26E4.11	D2030.1
+F26F4.9	D2030.1
+F28F8.6	D2030.1
+F32D8.6	D2030.1
+F39B2.10	D2030.1
+F44E5.4	D2030.1
+F44E5.5	D2030.1
+F44G3.6	D2030.1
+F45D3.5	D2030.1
+F45E6.2	D2030.1
+F46A9.4	D2030.1
+F46A9.5	D2030.1
+F46C3.1	D2030.1
+F47H4.10	D2030.1
+F48E3.3	D2030.1
+F52C6.12	D2030.1
+F54D10.1	D2030.1
+F54F2.9	D2030.1
+F55A11.3	D2030.1
+F55A3.1	D2030.1
+F56B3.12	D2030.1
+F56G4.5	D2030.1
+F57B10.11	D2030.1
+F58A4.10	D2030.1
+F59A6.1	D2030.1
+F59E12.5	D2030.1
+H06H21.6	D2030.1
+H06O01.1	D2030.1
+H14N18.1	D2030.1
+K02B12.3	D2030.1
+K02G10.8	D2030.1
+K04G2.3	D2030.1
+K07A1.8	D2030.1
+K08A8.1	D2030.1
+K08E3.7	D2030.1
+K08H2.1	D2030.1
+M7.1	D2030.1
+R12H7.3	D2030.1
+R12H7.5	D2030.1
+R151.6	D2030.1
+R74.3	D2030.1
+T04G9.3	D2030.1
+T04G9.5	D2030.1
+T05C3.5	D2030.1
+T05E11.3	D2030.1
+T05H10.5	D2030.1
+T09B4.10	D2030.1
+T14G8.3	D2030.1
+T15H9.7	D2030.1
+T24H7.2	D2030.1
+Y105C5B.13	D2030.1
+Y105E8A.2	D2030.1
+Y110A2AM.3	D2030.1
+Y110A2AR.2	D2030.1
+Y113G7A.3	D2030.1
+Y37E3.10	D2030.1
+Y37H2C.2	D2030.1
+Y38A10A.5	D2030.1
+Y38F2AR.2	D2030.1
+Y38F2AR.9	D2030.1
+Y47D7A.1	D2030.1
+Y47D7A.8	D2030.1
+Y47H9C.5	D2030.1
+Y49E10.4	D2030.1
+Y54G2A.18	D2030.1
+Y56A3A.2	D2030.1
+Y56A3A.21	D2030.1
+Y57G11C.15	D2030.1
+Y60A3A.18	D2030.1
+Y63D3A.6	D2030.1
+Y71F9AM.6	D2030.1
+Y77E11A.13	D2030.1
+Y87G2A.9	D2030.1
+Y94H6A.9	D2030.1
+ZC506.1	D2030.1
+ZC518.2	D2030.1
+ZK1307.8	D2030.1
+ZK180.4	D2030.1
+ZK20.3	D2030.1
+ZK287.5	D2030.1
+ZK632.6	D2030.1
+F10C2.5	D2045.6
+F11F1.1	D2045.6
+F12F6.6	D2045.6
+F13H10.4	D2045.6
+F15C11.2	D2045.6
+F19B6.2	D2045.6
+F25D7.1	D2045.6
+F26D10.3	D2045.6
+F26E4.11	D2045.6
+F26F4.9	D2045.6
+F28F8.6	D2045.6
+F32D8.6	D2045.6
+F39B2.10	D2045.6
+F40F9.6	D2045.6
+F44E5.4	D2045.6
+F44E5.5	D2045.6
+F45D3.5	D2045.6
+F45E6.2	D2045.6
+F46C3.1	D2045.6
+F48E3.3	D2045.6
+F52D1.1	D2045.6
+F54F2.9	D2045.6
+F55A3.1	D2045.6
+F56G4.5	D2045.6
+F57B10.10	D2045.6
+F57B10.11	D2045.6
+F59A6.1	D2045.6
+F59E12.5	D2045.6
+H06H21.6	D2045.6
+H06O01.1	D2045.6
+H14N18.1	D2045.6
+K02B12.3	D2045.6
+K02G10.8	D2045.6
+K04G2.3	D2045.6
+K07A1.8	D2045.6
+K08A8.1	D2045.6
+R151.6	D2045.6
+R74.3	D2045.6
+T03G11.4	D2045.6
+T04G9.3	D2045.6
+T04G9.5	D2045.6
+T05C3.5	D2045.6
+T05E11.3	D2045.6
+T09A5.11	D2045.6
+T12A2.2	D2045.6
+T14G8.3	D2045.6
+T15H9.7	D2045.6
+T22D1.4	D2045.6
+T24H7.2	D2045.6
+Y105E8A.2	D2045.6
+Y113G7A.3	D2045.6
+Y37E3.10	D2045.6
+Y38A10A.5	D2045.6
+Y38F2AR.2	D2045.6
+Y38F2AR.9	D2045.6
+Y47H9C.5	D2045.6
+Y49E10.4	D2045.6
+Y54G2A.18	D2045.6
+Y56A3A.2	D2045.6
+Y56A3A.21	D2045.6
+Y57G11C.15	D2045.6
+Y63D3A.6	D2045.6
+Y71F9AM.6	D2045.6
+Y77E11A.13	D2045.6
+Y94H6A.9	D2045.6
+ZC410.3	D2045.6
+ZC506.1	D2045.6
+ZC518.2	D2045.6
+ZK1307.8	D2045.6
+ZK180.4	D2045.6
+ZK20.3	D2045.6
+ZK632.6	D2045.6
+ZK686.3	D2045.6
+F11F1.1	F10C2.5
+F12F6.6	F10C2.5
+F13H10.4	F10C2.5
+F15C11.2	F10C2.5
+F19B6.2	F10C2.5
+F25D7.1	F10C2.5
+F26D10.3	F10C2.5
+F26E4.11	F10C2.5
+F26F4.9	F10C2.5
+F28F8.6	F10C2.5
+F32D8.6	F10C2.5
+F39B2.10	F10C2.5
+F40F9.6	F10C2.5
+F44E5.4	F10C2.5
+F44E5.5	F10C2.5
+F44G3.6	F10C2.5
+F45D3.5	F10C2.5
+F45E6.2	F10C2.5
+F46A9.4	F10C2.5
+F46A9.5	F10C2.5
+F46C3.1	F10C2.5
+F47H4.10	F10C2.5
+F48E3.3	F10C2.5
+F52C6.12	F10C2.5
+F52D1.1	F10C2.5
+F54D10.1	F10C2.5
+F54F2.9	F10C2.5
+F55A11.3	F10C2.5
+F55A3.1	F10C2.5
+F56B3.12	F10C2.5
+F56G4.5	F10C2.5
+F57B10.10	F10C2.5
+F57B10.11	F10C2.5
+F58A4.10	F10C2.5
+F59A6.1	F10C2.5
+F59E12.5	F10C2.5
+H06H21.6	F10C2.5
+H06O01.1	F10C2.5
+H14N18.1	F10C2.5
+K02B12.3	F10C2.5
+K02G10.8	F10C2.5
+K04G2.3	F10C2.5
+K07A1.8	F10C2.5
+K08A8.1	F10C2.5
+K08E3.7	F10C2.5
+K08H2.1	F10C2.5
+M7.1	F10C2.5
+R12H7.3	F10C2.5
+R12H7.5	F10C2.5
+R151.6	F10C2.5
+R74.3	F10C2.5
+T03G11.4	F10C2.5
+T04G9.3	F10C2.5
+T04G9.5	F10C2.5
+T05C3.5	F10C2.5
+T05E11.3	F10C2.5
+T05H10.5	F10C2.5
+T09A5.11	F10C2.5
+T09B4.10	F10C2.5
+T12A2.2	F10C2.5
+T14G8.3	F10C2.5
+T15H9.7	F10C2.5
+T22D1.4	F10C2.5
+T24H7.2	F10C2.5
+Y105C5B.13	F10C2.5
+Y105E8A.2	F10C2.5
+Y110A2AM.3	F10C2.5
+Y110A2AR.2	F10C2.5
+Y113G7A.3	F10C2.5
+Y37E3.10	F10C2.5
+Y37H2C.2	F10C2.5
+Y38A10A.5	F10C2.5
+Y38F2AR.2	F10C2.5
+Y38F2AR.9	F10C2.5
+Y47D7A.1	F10C2.5
+Y47D7A.8	F10C2.5
+Y47H9C.5	F10C2.5
+Y49E10.4	F10C2.5
+Y54G2A.18	F10C2.5
+Y56A3A.2	F10C2.5
+Y56A3A.21	F10C2.5
+Y57G11C.15	F10C2.5
+Y60A3A.18	F10C2.5
+Y63D3A.6	F10C2.5
+Y71F9AM.6	F10C2.5
+Y77E11A.13	F10C2.5
+Y87G2A.9	F10C2.5
+Y94H6A.9	F10C2.5
+ZC410.3	F10C2.5
+ZC506.1	F10C2.5
+ZC518.2	F10C2.5
+ZK1307.8	F10C2.5
+ZK180.4	F10C2.5
+ZK20.3	F10C2.5
+ZK287.5	F10C2.5
+ZK632.6	F10C2.5
+ZK686.3	F10C2.5
+F12F6.6	F11F1.1
+F13H10.4	F11F1.1
+F15C11.2	F11F1.1
+F19B6.2	F11F1.1
+F25D7.1	F11F1.1
+F26E4.11	F11F1.1
+F26F4.9	F11F1.1
+F28F8.6	F11F1.1
+F32D8.6	F11F1.1
+F39B2.10	F11F1.1
+F40F9.6	F11F1.1
+F44G3.6	F11F1.1
+F45D3.5	F11F1.1
+F45E6.2	F11F1.1
+F46A9.4	F11F1.1
+F46A9.5	F11F1.1
+F46C3.1	F11F1.1
+F47H4.10	F11F1.1
+F48E3.3	F11F1.1
+F52C6.12	F11F1.1
+F52D1.1	F11F1.1
+F54D10.1	F11F1.1
+F54F2.9	F11F1.1
+F55A11.3	F11F1.1
+F55A3.1	F11F1.1
+F56B3.12	F11F1.1
+F56G4.5	F11F1.1
+F57B10.10	F11F1.1
+F57B10.11	F11F1.1
+F58A4.10	F11F1.1
+F59E12.5	F11F1.1
+H06H21.6	F11F1.1
+H06O01.1	F11F1.1
+H14N18.1	F11F1.1
+K02B12.3	F11F1.1
+K02G10.8	F11F1.1
+K04G2.3	F11F1.1
+K07A1.8	F11F1.1
+K08E3.7	F11F1.1
+K08H2.1	F11F1.1
+M7.1	F11F1.1
+R12H7.3	F11F1.1
+R12H7.5	F11F1.1
+R151.6	F11F1.1
+R74.3	F11F1.1
+T03G11.4	F11F1.1
+T04G9.3	F11F1.1
+T04G9.5	F11F1.1
+T05C3.5	F11F1.1
+T05E11.3	F11F1.1
+T05H10.5	F11F1.1
+T09A5.11	F11F1.1
+T09B4.10	F11F1.1
+T12A2.2	F11F1.1
+T14G8.3	F11F1.1
+T15H9.7	F11F1.1
+T22D1.4	F11F1.1
+T24H7.2	F11F1.1
+Y105C5B.13	F11F1.1
+Y105E8A.2	F11F1.1
+Y110A2AM.3	F11F1.1
+Y110A2AR.2	F11F1.1
+Y113G7A.3	F11F1.1
+Y37E3.10	F11F1.1
+Y37H2C.2	F11F1.1
+Y38A10A.5	F11F1.1
+Y38F2AR.2	F11F1.1
+Y38F2AR.9	F11F1.1
+Y47D7A.1	F11F1.1
+Y47D7A.8	F11F1.1
+Y47H9C.5	F11F1.1
+Y49E10.4	F11F1.1
+Y54G2A.18	F11F1.1
+Y56A3A.2	F11F1.1
+Y56A3A.21	F11F1.1
+Y57G11C.15	F11F1.1
+Y60A3A.18	F11F1.1
+Y63D3A.6	F11F1.1
+Y71F9AM.6	F11F1.1
+Y77E11A.13	F11F1.1
+Y87G2A.9	F11F1.1
+Y94H6A.9	F11F1.1
+ZC410.3	F11F1.1
+ZC506.1	F11F1.1
+ZC518.2	F11F1.1
+ZK1307.8	F11F1.1
+ZK180.4	F11F1.1
+ZK20.3	F11F1.1
+ZK287.5	F11F1.1
+ZK632.6	F11F1.1
+ZK686.3	F11F1.1
+F13H10.4	F12F6.6
+F15C11.2	F12F6.6
+F19B6.2	F12F6.6
+F25D7.1	F12F6.6
+F26D10.3	F12F6.6
+F26E4.11	F12F6.6
+F26F4.9	F12F6.6
+F28F8.6	F12F6.6
+F32D8.6	F12F6.6
+F39B2.10	F12F6.6
+F40F9.6	F12F6.6
+F44E5.4	F12F6.6
+F44E5.5	F12F6.6
+F44G3.6	F12F6.6
+F45D3.5	F12F6.6
+F45E6.2	F12F6.6
+F46A9.4	F12F6.6
+F46A9.5	F12F6.6
+F46C3.1	F12F6.6
+F47H4.10	F12F6.6
+F48E3.3	F12F6.6
+F52C6.12	F12F6.6
+F52D1.1	F12F6.6
+F54D10.1	F12F6.6
+F54F2.9	F12F6.6
+F55A11.3	F12F6.6
+F55A3.1	F12F6.6
+F56B3.12	F12F6.6
+F56G4.5	F12F6.6
+F57B10.10	F12F6.6
+F57B10.11	F12F6.6
+F58A4.10	F12F6.6
+F59A6.1	F12F6.6
+F59E12.5	F12F6.6
+H06H21.6	F12F6.6
+H06O01.1	F12F6.6
+H14N18.1	F12F6.6
+K02B12.3	F12F6.6
+K02G10.8	F12F6.6
+K04G2.3	F12F6.6
+K07A1.8	F12F6.6
+K08A8.1	F12F6.6
+K08E3.7	F12F6.6
+K08H2.1	F12F6.6
+M7.1	F12F6.6
+R12H7.3	F12F6.6
+R12H7.5	F12F6.6
+R151.6	F12F6.6
+R74.3	F12F6.6
+T03G11.4	F12F6.6
+T04G9.3	F12F6.6
+T04G9.5	F12F6.6
+T05C3.5	F12F6.6
+T05E11.3	F12F6.6
+T05H10.5	F12F6.6
+T09A5.11	F12F6.6
+T09B4.10	F12F6.6
+T12A2.2	F12F6.6
+T14G8.3	F12F6.6
+T15H9.7	F12F6.6
+T22D1.4	F12F6.6
+T24H7.2	F12F6.6
+Y105C5B.13	F12F6.6
+Y105E8A.2	F12F6.6
+Y110A2AM.3	F12F6.6
+Y110A2AR.2	F12F6.6
+Y113G7A.3	F12F6.6
+Y37E3.10	F12F6.6
+Y37H2C.2	F12F6.6
+Y38A10A.5	F12F6.6
+Y38F2AR.2	F12F6.6
+Y38F2AR.9	F12F6.6
+Y47D7A.1	F12F6.6
+Y47D7A.8	F12F6.6
+Y47H9C.5	F12F6.6
+Y49E10.4	F12F6.6
+Y54G2A.18	F12F6.6
+Y56A3A.2	F12F6.6
+Y56A3A.21	F12F6.6
+Y57G11C.15	F12F6.6
+Y60A3A.18	F12F6.6
+Y63D3A.6	F12F6.6
+Y71F9AM.6	F12F6.6
+Y77E11A.13	F12F6.6
+Y87G2A.9	F12F6.6
+Y94H6A.9	F12F6.6
+ZC410.3	F12F6.6
+ZC506.1	F12F6.6
+ZC518.2	F12F6.6
+ZK1307.8	F12F6.6
+ZK180.4	F12F6.6
+ZK20.3	F12F6.6
+ZK287.5	F12F6.6
+ZK632.6	F12F6.6
+ZK686.3	F12F6.6
+F15C11.2	F13H10.4
+F19B6.2	F13H10.4
+F25D7.1	F13H10.4
+F26D10.3	F13H10.4
+F26E4.11	F13H10.4
+F26F4.9	F13H10.4
+F28F8.6	F13H10.4
+F32D8.6	F13H10.4
+F39B2.10	F13H10.4
+F44E5.4	F13H10.4
+F44E5.5	F13H10.4
+F44G3.6	F13H10.4
+F45D3.5	F13H10.4
+F45E6.2	F13H10.4
+F46A9.4	F13H10.4
+F46A9.5	F13H10.4
+F46C3.1	F13H10.4
+F47H4.10	F13H10.4
+F48E3.3	F13H10.4
+F52C6.12	F13H10.4
+F54D10.1	F13H10.4
+F54F2.9	F13H10.4
+F55A11.3	F13H10.4
+F55A3.1	F13H10.4
+F56B3.12	F13H10.4
+F56G4.5	F13H10.4
+F57B10.11	F13H10.4
+F58A4.10	F13H10.4
+F59A6.1	F13H10.4
+F59E12.5	F13H10.4
+H06H21.6	F13H10.4
+H06O01.1	F13H10.4
+H14N18.1	F13H10.4
+K02B12.3	F13H10.4
+K02G10.8	F13H10.4
+K04G2.3	F13H10.4
+K07A1.8	F13H10.4
+K08A8.1	F13H10.4
+K08E3.7	F13H10.4
+K08H2.1	F13H10.4
+M7.1	F13H10.4
+R12H7.3	F13H10.4
+R12H7.5	F13H10.4
+R151.6	F13H10.4
+R74.3	F13H10.4
+T04G9.3	F13H10.4
+T04G9.5	F13H10.4
+T05C3.5	F13H10.4
+T05E11.3	F13H10.4
+T05H10.5	F13H10.4
+T09B4.10	F13H10.4
+T14G8.3	F13H10.4
+T15H9.7	F13H10.4
+T24H7.2	F13H10.4
+Y105C5B.13	F13H10.4
+Y105E8A.2	F13H10.4
+Y110A2AM.3	F13H10.4
+Y110A2AR.2	F13H10.4
+Y113G7A.3	F13H10.4
+Y37E3.10	F13H10.4
+Y37H2C.2	F13H10.4
+Y38A10A.5	F13H10.4
+Y38F2AR.2	F13H10.4
+Y38F2AR.9	F13H10.4
+Y47D7A.1	F13H10.4
+Y47D7A.8	F13H10.4
+Y47H9C.5	F13H10.4
+Y49E10.4	F13H10.4
+Y54G2A.18	F13H10.4
+Y56A3A.2	F13H10.4
+Y56A3A.21	F13H10.4
+Y57G11C.15	F13H10.4
+Y60A3A.18	F13H10.4
+Y63D3A.6	F13H10.4
+Y71F9AM.6	F13H10.4
+Y77E11A.13	F13H10.4
+Y87G2A.9	F13H10.4
+Y94H6A.9	F13H10.4
+ZC506.1	F13H10.4
+ZC518.2	F13H10.4
+ZK1307.8	F13H10.4
+ZK180.4	F13H10.4
+ZK20.3	F13H10.4
+ZK287.5	F13H10.4
+ZK632.6	F13H10.4
+F19B6.2	F15C11.2
+F25D7.1	F15C11.2
+F26D10.3	F15C11.2
+F26E4.11	F15C11.2
+F26F4.9	F15C11.2
+F28F8.6	F15C11.2
+F32D8.6	F15C11.2
+F39B2.10	F15C11.2
+F40F9.6	F15C11.2
+F44E5.4	F15C11.2
+F44E5.5	F15C11.2
+F44G3.6	F15C11.2
+F45D3.5	F15C11.2
+F45E6.2	F15C11.2
+F46A9.4	F15C11.2
+F46A9.5	F15C11.2
+F46C3.1	F15C11.2
+F47H4.10	F15C11.2
+F48E3.3	F15C11.2
+F52C6.12	F15C11.2
+F52D1.1	F15C11.2
+F54D10.1	F15C11.2
+F54F2.9	F15C11.2
+F55A11.3	F15C11.2
+F55A3.1	F15C11.2
+F56B3.12	F15C11.2
+F56G4.5	F15C11.2
+F57B10.10	F15C11.2
+F57B10.11	F15C11.2
+F58A4.10	F15C11.2
+F59A6.1	F15C11.2
+F59E12.5	F15C11.2
+H06H21.6	F15C11.2
+H06O01.1	F15C11.2
+H14N18.1	F15C11.2
+K02B12.3	F15C11.2
+K02G10.8	F15C11.2
+K04G2.3	F15C11.2
+K07A1.8	F15C11.2
+K08A8.1	F15C11.2
+K08E3.7	F15C11.2
+K08H2.1	F15C11.2
+M7.1	F15C11.2
+R12H7.3	F15C11.2
+R12H7.5	F15C11.2
+R151.6	F15C11.2
+R74.3	F15C11.2
+T03G11.4	F15C11.2
+T04G9.3	F15C11.2
+T04G9.5	F15C11.2
+T05C3.5	F15C11.2
+T05E11.3	F15C11.2
+T05H10.5	F15C11.2
+T09A5.11	F15C11.2
+T09B4.10	F15C11.2
+T12A2.2	F15C11.2
+T14G8.3	F15C11.2
+T15H9.7	F15C11.2
+T22D1.4	F15C11.2
+T24H7.2	F15C11.2
+Y105C5B.13	F15C11.2
+Y105E8A.2	F15C11.2
+Y110A2AM.3	F15C11.2
+Y110A2AR.2	F15C11.2
+Y113G7A.3	F15C11.2
+Y37E3.10	F15C11.2
+Y37H2C.2	F15C11.2
+Y38A10A.5	F15C11.2
+Y38F2AR.2	F15C11.2
+Y38F2AR.9	F15C11.2
+Y47D7A.1	F15C11.2
+Y47D7A.8	F15C11.2
+Y47H9C.5	F15C11.2
+Y49E10.4	F15C11.2
+Y54G2A.18	F15C11.2
+Y56A3A.2	F15C11.2
+Y56A3A.21	F15C11.2
+Y57G11C.15	F15C11.2
+Y60A3A.18	F15C11.2
+Y63D3A.6	F15C11.2
+Y71F9AM.6	F15C11.2
+Y77E11A.13	F15C11.2
+Y87G2A.9	F15C11.2
+Y94H6A.9	F15C11.2
+ZC410.3	F15C11.2
+ZC506.1	F15C11.2
+ZC518.2	F15C11.2
+ZK1307.8	F15C11.2
+ZK180.4	F15C11.2
+ZK20.3	F15C11.2
+ZK287.5	F15C11.2
+ZK632.6	F15C11.2
+ZK686.3	F15C11.2
+F25D7.1	F19B6.2
+F26D10.3	F19B6.2
+F26E4.11	F19B6.2
+F26F4.9	F19B6.2
+F28F8.6	F19B6.2
+F32D8.6	F19B6.2
+F39B2.10	F19B6.2
+F40F9.6	F19B6.2
+F44E5.4	F19B6.2
+F44E5.5	F19B6.2
+F44G3.6	F19B6.2
+F45D3.5	F19B6.2
+F45E6.2	F19B6.2
+F46A9.4	F19B6.2
+F46A9.5	F19B6.2
+F46C3.1	F19B6.2
+F47H4.10	F19B6.2
+F48E3.3	F19B6.2
+F52C6.12	F19B6.2
+F52D1.1	F19B6.2
+F54D10.1	F19B6.2
+F54F2.9	F19B6.2
+F55A11.3	F19B6.2
+F55A3.1	F19B6.2
+F56B3.12	F19B6.2
+F56G4.5	F19B6.2
+F57B10.10	F19B6.2
+F57B10.11	F19B6.2
+F58A4.10	F19B6.2
+F59A6.1	F19B6.2
+F59E12.5	F19B6.2
+H06H21.6	F19B6.2
+H06O01.1	F19B6.2
+H14N18.1	F19B6.2
+K02B12.3	F19B6.2
+K02G10.8	F19B6.2
+K04G2.3	F19B6.2
+K07A1.8	F19B6.2
+K08A8.1	F19B6.2
+K08E3.7	F19B6.2
+K08H2.1	F19B6.2
+M7.1	F19B6.2
+R12H7.3	F19B6.2
+R12H7.5	F19B6.2
+R151.6	F19B6.2
+R74.3	F19B6.2
+T03G11.4	F19B6.2
+T04G9.3	F19B6.2
+T04G9.5	F19B6.2
+T05C3.5	F19B6.2
+T05E11.3	F19B6.2
+T05H10.5	F19B6.2
+T09A5.11	F19B6.2
+T09B4.10	F19B6.2
+T12A2.2	F19B6.2
+T14G8.3	F19B6.2
+T15H9.7	F19B6.2
+T22D1.4	F19B6.2
+T24H7.2	F19B6.2
+Y105C5B.13	F19B6.2
+Y105E8A.2	F19B6.2
+Y110A2AM.3	F19B6.2
+Y110A2AR.2	F19B6.2
+Y113G7A.3	F19B6.2
+Y37E3.10	F19B6.2
+Y37H2C.2	F19B6.2
+Y38A10A.5	F19B6.2
+Y38F2AR.2	F19B6.2
+Y38F2AR.9	F19B6.2
+Y47D7A.1	F19B6.2
+Y47D7A.8	F19B6.2
+Y47H9C.5	F19B6.2
+Y49E10.4	F19B6.2
+Y54G2A.18	F19B6.2
+Y56A3A.2	F19B6.2
+Y56A3A.21	F19B6.2
+Y57G11C.15	F19B6.2
+Y60A3A.18	F19B6.2
+Y63D3A.6	F19B6.2
+Y71F9AM.6	F19B6.2
+Y77E11A.13	F19B6.2
+Y87G2A.9	F19B6.2
+Y94H6A.9	F19B6.2
+ZC410.3	F19B6.2
+ZC506.1	F19B6.2
+ZC518.2	F19B6.2
+ZK1307.8	F19B6.2
+ZK180.4	F19B6.2
+ZK20.3	F19B6.2
+ZK287.5	F19B6.2
+ZK632.6	F19B6.2
+ZK686.3	F19B6.2
+F26D10.3	F25D7.1
+F26E4.11	F25D7.1
+F26F4.9	F25D7.1
+F28F8.6	F25D7.1
+F32D8.6	F25D7.1
+F39B2.10	F25D7.1
+F40F9.6	F25D7.1
+F44E5.4	F25D7.1
+F44E5.5	F25D7.1
+F44G3.6	F25D7.1
+F45D3.5	F25D7.1
+F45E6.2	F25D7.1
+F46A9.4	F25D7.1
+F46A9.5	F25D7.1
+F46C3.1	F25D7.1
+F47H4.10	F25D7.1
+F48E3.3	F25D7.1
+F52C6.12	F25D7.1
+F52D1.1	F25D7.1
+F54D10.1	F25D7.1
+F54F2.9	F25D7.1
+F55A11.3	F25D7.1
+F55A3.1	F25D7.1
+F56B3.12	F25D7.1
+F56G4.5	F25D7.1
+F57B10.10	F25D7.1
+F57B10.11	F25D7.1
+F58A4.10	F25D7.1
+F59A6.1	F25D7.1
+F59E12.5	F25D7.1
+H06H21.6	F25D7.1
+H06O01.1	F25D7.1
+H14N18.1	F25D7.1
+K02B12.3	F25D7.1
+K02G10.8	F25D7.1
+K04G2.3	F25D7.1
+K07A1.8	F25D7.1
+K08A8.1	F25D7.1
+K08E3.7	F25D7.1
+K08H2.1	F25D7.1
+M7.1	F25D7.1
+R12H7.3	F25D7.1
+R12H7.5	F25D7.1
+R151.6	F25D7.1
+R74.3	F25D7.1
+T03G11.4	F25D7.1
+T04G9.3	F25D7.1
+T04G9.5	F25D7.1
+T05C3.5	F25D7.1
+T05E11.3	F25D7.1
+T05H10.5	F25D7.1
+T09A5.11	F25D7.1
+T09B4.10	F25D7.1
+T12A2.2	F25D7.1
+T14G8.3	F25D7.1
+T15H9.7	F25D7.1
+T22D1.4	F25D7.1
+T24H7.2	F25D7.1
+Y105C5B.13	F25D7.1
+Y105E8A.2	F25D7.1
+Y110A2AM.3	F25D7.1
+Y110A2AR.2	F25D7.1
+Y113G7A.3	F25D7.1
+Y37E3.10	F25D7.1
+Y37H2C.2	F25D7.1
+Y38A10A.5	F25D7.1
+Y38F2AR.2	F25D7.1
+Y38F2AR.9	F25D7.1
+Y47D7A.1	F25D7.1
+Y47D7A.8	F25D7.1
+Y47H9C.5	F25D7.1
+Y49E10.4	F25D7.1
+Y54G2A.18	F25D7.1
+Y56A3A.2	F25D7.1
+Y56A3A.21	F25D7.1
+Y57G11C.15	F25D7.1
+Y60A3A.18	F25D7.1
+Y63D3A.6	F25D7.1
+Y71F9AM.6	F25D7.1
+Y77E11A.13	F25D7.1
+Y87G2A.9	F25D7.1
+Y94H6A.9	F25D7.1
+ZC410.3	F25D7.1
+ZC506.1	F25D7.1
+ZC518.2	F25D7.1
+ZK1307.8	F25D7.1
+ZK180.4	F25D7.1
+ZK20.3	F25D7.1
+ZK287.5	F25D7.1
+ZK632.6	F25D7.1
+ZK686.3	F25D7.1
+F26E4.11	F26D10.3
+F26F4.9	F26D10.3
+F28F8.6	F26D10.3
+F32D8.6	F26D10.3
+F39B2.10	F26D10.3
+F40F9.6	F26D10.3
+F44G3.6	F26D10.3
+F45D3.5	F26D10.3
+F45E6.2	F26D10.3
+F46A9.4	F26D10.3
+F46A9.5	F26D10.3
+F46C3.1	F26D10.3
+F47H4.10	F26D10.3
+F48E3.3	F26D10.3
+F52C6.12	F26D10.3
+F52D1.1	F26D10.3
+F54D10.1	F26D10.3
+F54F2.9	F26D10.3
+F55A11.3	F26D10.3
+F55A3.1	F26D10.3
+F56B3.12	F26D10.3
+F56G4.5	F26D10.3
+F57B10.10	F26D10.3
+F57B10.11	F26D10.3
+F58A4.10	F26D10.3
+F59E12.5	F26D10.3
+H06H21.6	F26D10.3
+H06O01.1	F26D10.3
+H14N18.1	F26D10.3
+K02B12.3	F26D10.3
+K02G10.8	F26D10.3
+K04G2.3	F26D10.3
+K07A1.8	F26D10.3
+K08E3.7	F26D10.3
+K08H2.1	F26D10.3
+M7.1	F26D10.3
+R12H7.3	F26D10.3
+R12H7.5	F26D10.3
+R151.6	F26D10.3
+R74.3	F26D10.3
+T03G11.4	F26D10.3
+T04G9.3	F26D10.3
+T04G9.5	F26D10.3
+T05C3.5	F26D10.3
+T05E11.3	F26D10.3
+T05H10.5	F26D10.3
+T09A5.11	F26D10.3
+T09B4.10	F26D10.3
+T12A2.2	F26D10.3
+T14G8.3	F26D10.3
+T15H9.7	F26D10.3
+T22D1.4	F26D10.3
+T24H7.2	F26D10.3
+Y105C5B.13	F26D10.3
+Y105E8A.2	F26D10.3
+Y110A2AM.3	F26D10.3
+Y110A2AR.2	F26D10.3
+Y113G7A.3	F26D10.3
+Y37E3.10	F26D10.3
+Y37H2C.2	F26D10.3
+Y38A10A.5	F26D10.3
+Y38F2AR.2	F26D10.3
+Y38F2AR.9	F26D10.3
+Y47D7A.1	F26D10.3
+Y47D7A.8	F26D10.3
+Y47H9C.5	F26D10.3
+Y49E10.4	F26D10.3
+Y54G2A.18	F26D10.3
+Y56A3A.2	F26D10.3
+Y56A3A.21	F26D10.3
+Y57G11C.15	F26D10.3
+Y60A3A.18	F26D10.3
+Y63D3A.6	F26D10.3
+Y71F9AM.6	F26D10.3
+Y77E11A.13	F26D10.3
+Y87G2A.9	F26D10.3
+Y94H6A.9	F26D10.3
+ZC410.3	F26D10.3
+ZC506.1	F26D10.3
+ZC518.2	F26D10.3
+ZK1307.8	F26D10.3
+ZK180.4	F26D10.3
+ZK20.3	F26D10.3
+ZK287.5	F26D10.3
+ZK632.6	F26D10.3
+ZK686.3	F26D10.3
+F26F4.9	F26E4.11
+F28F8.6	F26E4.11
+F32D8.6	F26E4.11
+F39B2.10	F26E4.11
+F40F9.6	F26E4.11
+F44E5.4	F26E4.11
+F44E5.5	F26E4.11
+F44G3.6	F26E4.11
+F45D3.5	F26E4.11
+F45E6.2	F26E4.11
+F46A9.4	F26E4.11
+F46A9.5	F26E4.11
+F46C3.1	F26E4.11
+F47H4.10	F26E4.11
+F48E3.3	F26E4.11
+F52C6.12	F26E4.11
+F52D1.1	F26E4.11
+F54D10.1	F26E4.11
+F54F2.9	F26E4.11
+F55A11.3	F26E4.11
+F55A3.1	F26E4.11
+F56B3.12	F26E4.11
+F56G4.5	F26E4.11
+F57B10.10	F26E4.11
+F57B10.11	F26E4.11
+F58A4.10	F26E4.11
+F59A6.1	F26E4.11
+F59E12.5	F26E4.11
+H06H21.6	F26E4.11
+H06O01.1	F26E4.11
+H14N18.1	F26E4.11
+K02B12.3	F26E4.11
+K02G10.8	F26E4.11
+K04G2.3	F26E4.11
+K07A1.8	F26E4.11
+K08A8.1	F26E4.11
+K08E3.7	F26E4.11
+K08H2.1	F26E4.11
+M7.1	F26E4.11
+R12H7.3	F26E4.11
+R12H7.5	F26E4.11
+R151.6	F26E4.11
+R74.3	F26E4.11
+T03G11.4	F26E4.11
+T04G9.3	F26E4.11
+T04G9.5	F26E4.11
+T05C3.5	F26E4.11
+T05E11.3	F26E4.11
+T05H10.5	F26E4.11
+T09A5.11	F26E4.11
+T09B4.10	F26E4.11
+T12A2.2	F26E4.11
+T14G8.3	F26E4.11
+T15H9.7	F26E4.11
+T22D1.4	F26E4.11
+T24H7.2	F26E4.11
+Y105C5B.13	F26E4.11
+Y105E8A.2	F26E4.11
+Y110A2AM.3	F26E4.11
+Y110A2AR.2	F26E4.11
+Y113G7A.3	F26E4.11
+Y37E3.10	F26E4.11
+Y37H2C.2	F26E4.11
+Y38A10A.5	F26E4.11
+Y38F2AR.2	F26E4.11
+Y38F2AR.9	F26E4.11
+Y47D7A.1	F26E4.11
+Y47D7A.8	F26E4.11
+Y47H9C.5	F26E4.11
+Y49E10.4	F26E4.11
+Y54G2A.18	F26E4.11
+Y56A3A.2	F26E4.11
+Y56A3A.21	F26E4.11
+Y57G11C.15	F26E4.11
+Y60A3A.18	F26E4.11
+Y63D3A.6	F26E4.11
+Y71F9AM.6	F26E4.11
+Y77E11A.13	F26E4.11
+Y87G2A.9	F26E4.11
+Y94H6A.9	F26E4.11
+ZC410.3	F26E4.11
+ZC506.1	F26E4.11
+ZC518.2	F26E4.11
+ZK1307.8	F26E4.11
+ZK180.4	F26E4.11
+ZK20.3	F26E4.11
+ZK287.5	F26E4.11
+ZK632.6	F26E4.11
+ZK686.3	F26E4.11
+F28F8.6	F26F4.9
+F32D8.6	F26F4.9
+F39B2.10	F26F4.9
+F40F9.6	F26F4.9
+F44E5.4	F26F4.9
+F44E5.5	F26F4.9
+F44G3.6	F26F4.9
+F45D3.5	F26F4.9
+F45E6.2	F26F4.9
+F46A9.4	F26F4.9
+F46A9.5	F26F4.9
+F46C3.1	F26F4.9
+F47H4.10	F26F4.9
+F48E3.3	F26F4.9
+F52C6.12	F26F4.9
+F52D1.1	F26F4.9
+F54D10.1	F26F4.9
+F54F2.9	F26F4.9
+F55A11.3	F26F4.9
+F55A3.1	F26F4.9
+F56B3.12	F26F4.9
+F56G4.5	F26F4.9
+F57B10.10	F26F4.9
+F57B10.11	F26F4.9
+F58A4.10	F26F4.9
+F59A6.1	F26F4.9
+F59E12.5	F26F4.9
+H06H21.6	F26F4.9
+H06O01.1	F26F4.9
+H14N18.1	F26F4.9
+K02B12.3	F26F4.9
+K02G10.8	F26F4.9
+K04G2.3	F26F4.9
+K07A1.8	F26F4.9
+K08A8.1	F26F4.9
+K08E3.7	F26F4.9
+K08H2.1	F26F4.9
+M7.1	F26F4.9
+R12H7.3	F26F4.9
+R12H7.5	F26F4.9
+R151.6	F26F4.9
+R74.3	F26F4.9
+T03G11.4	F26F4.9
+T04G9.3	F26F4.9
+T04G9.5	F26F4.9
+T05C3.5	F26F4.9
+T05E11.3	F26F4.9
+T05H10.5	F26F4.9
+T09A5.11	F26F4.9
+T09B4.10	F26F4.9
+T12A2.2	F26F4.9
+T14G8.3	F26F4.9
+T15H9.7	F26F4.9
+T22D1.4	F26F4.9
+T24H7.2	F26F4.9
+Y105C5B.13	F26F4.9
+Y105E8A.2	F26F4.9
+Y110A2AM.3	F26F4.9
+Y110A2AR.2	F26F4.9
+Y113G7A.3	F26F4.9
+Y37E3.10	F26F4.9
+Y37H2C.2	F26F4.9
+Y38A10A.5	F26F4.9
+Y38F2AR.2	F26F4.9
+Y38F2AR.9	F26F4.9
+Y47D7A.1	F26F4.9
+Y47D7A.8	F26F4.9
+Y47H9C.5	F26F4.9
+Y49E10.4	F26F4.9
+Y54G2A.18	F26F4.9
+Y56A3A.2	F26F4.9
+Y56A3A.21	F26F4.9
+Y57G11C.15	F26F4.9
+Y60A3A.18	F26F4.9
+Y63D3A.6	F26F4.9
+Y71F9AM.6	F26F4.9
+Y77E11A.13	F26F4.9
+Y87G2A.9	F26F4.9
+Y94H6A.9	F26F4.9
+ZC410.3	F26F4.9
+ZC506.1	F26F4.9
+ZC518.2	F26F4.9
+ZK1307.8	F26F4.9
+ZK180.4	F26F4.9
+ZK20.3	F26F4.9
+ZK287.5	F26F4.9
+ZK632.6	F26F4.9
+ZK686.3	F26F4.9
+F32D8.6	F28F8.6
+F39B2.10	F28F8.6
+F40F9.6	F28F8.6
+F44E5.4	F28F8.6
+F44E5.5	F28F8.6
+F44G3.6	F28F8.6
+F45D3.5	F28F8.6
+F45E6.2	F28F8.6
+F46A9.4	F28F8.6
+F46A9.5	F28F8.6
+F46C3.1	F28F8.6
+F47H4.10	F28F8.6
+F48E3.3	F28F8.6
+F52C6.12	F28F8.6
+F52D1.1	F28F8.6
+F54D10.1	F28F8.6
+F54F2.9	F28F8.6
+F55A11.3	F28F8.6
+F55A3.1	F28F8.6
+F56B3.12	F28F8.6
+F56G4.5	F28F8.6
+F57B10.10	F28F8.6
+F57B10.11	F28F8.6
+F58A4.10	F28F8.6
+F59A6.1	F28F8.6
+F59E12.5	F28F8.6
+H06H21.6	F28F8.6
+H06O01.1	F28F8.6
+H14N18.1	F28F8.6
+K02B12.3	F28F8.6
+K02G10.8	F28F8.6
+K04G2.3	F28F8.6
+K07A1.8	F28F8.6
+K08A8.1	F28F8.6
+K08E3.7	F28F8.6
+K08H2.1	F28F8.6
+M7.1	F28F8.6
+R12H7.3	F28F8.6
+R12H7.5	F28F8.6
+R151.6	F28F8.6
+R74.3	F28F8.6
+T03G11.4	F28F8.6
+T04G9.3	F28F8.6
+T04G9.5	F28F8.6
+T05C3.5	F28F8.6
+T05E11.3	F28F8.6
+T05H10.5	F28F8.6
+T09A5.11	F28F8.6
+T09B4.10	F28F8.6
+T12A2.2	F28F8.6
+T14G8.3	F28F8.6
+T15H9.7	F28F8.6
+T22D1.4	F28F8.6
+T24H7.2	F28F8.6
+Y105C5B.13	F28F8.6
+Y105E8A.2	F28F8.6
+Y110A2AM.3	F28F8.6
+Y110A2AR.2	F28F8.6
+Y113G7A.3	F28F8.6
+Y37E3.10	F28F8.6
+Y37H2C.2	F28F8.6
+Y38A10A.5	F28F8.6
+Y38F2AR.2	F28F8.6
+Y38F2AR.9	F28F8.6
+Y47D7A.1	F28F8.6
+Y47D7A.8	F28F8.6
+Y47H9C.5	F28F8.6
+Y49E10.4	F28F8.6
+Y54G2A.18	F28F8.6
+Y56A3A.2	F28F8.6
+Y56A3A.21	F28F8.6
+Y57G11C.15	F28F8.6
+Y60A3A.18	F28F8.6
+Y63D3A.6	F28F8.6
+Y71F9AM.6	F28F8.6
+Y77E11A.13	F28F8.6
+Y87G2A.9	F28F8.6
+Y94H6A.9	F28F8.6
+ZC410.3	F28F8.6
+ZC506.1	F28F8.6
+ZC518.2	F28F8.6
+ZK1307.8	F28F8.6
+ZK180.4	F28F8.6
+ZK20.3	F28F8.6
+ZK287.5	F28F8.6
+ZK632.6	F28F8.6
+ZK686.3	F28F8.6
+F39B2.10	F32D8.6
+F40F9.6	F32D8.6
+F44E5.4	F32D8.6
+F44E5.5	F32D8.6
+F44G3.6	F32D8.6
+F45D3.5	F32D8.6
+F45E6.2	F32D8.6
+F46A9.4	F32D8.6
+F46A9.5	F32D8.6
+F46C3.1	F32D8.6
+F47H4.10	F32D8.6
+F48E3.3	F32D8.6
+F52C6.12	F32D8.6
+F52D1.1	F32D8.6
+F54D10.1	F32D8.6
+F54F2.9	F32D8.6
+F55A11.3	F32D8.6
+F55A3.1	F32D8.6
+F56B3.12	F32D8.6
+F56G4.5	F32D8.6
+F57B10.10	F32D8.6
+F57B10.11	F32D8.6
+F58A4.10	F32D8.6
+F59A6.1	F32D8.6
+F59E12.5	F32D8.6
+H06H21.6	F32D8.6
+H06O01.1	F32D8.6
+H14N18.1	F32D8.6
+K02B12.3	F32D8.6
+K02G10.8	F32D8.6
+K04G2.3	F32D8.6
+K07A1.8	F32D8.6
+K08A8.1	F32D8.6
+K08E3.7	F32D8.6
+K08H2.1	F32D8.6
+M7.1	F32D8.6
+R12H7.3	F32D8.6
+R12H7.5	F32D8.6
+R151.6	F32D8.6
+R74.3	F32D8.6
+T03G11.4	F32D8.6
+T04G9.3	F32D8.6
+T04G9.5	F32D8.6
+T05C3.5	F32D8.6
+T05E11.3	F32D8.6
+T05H10.5	F32D8.6
+T09A5.11	F32D8.6
+T09B4.10	F32D8.6
+T12A2.2	F32D8.6
+T14G8.3	F32D8.6
+T15H9.7	F32D8.6
+T22D1.4	F32D8.6
+T24H7.2	F32D8.6
+Y105C5B.13	F32D8.6
+Y105E8A.2	F32D8.6
+Y110A2AM.3	F32D8.6
+Y110A2AR.2	F32D8.6
+Y113G7A.3	F32D8.6
+Y37E3.10	F32D8.6
+Y37H2C.2	F32D8.6
+Y38A10A.5	F32D8.6
+Y38F2AR.2	F32D8.6
+Y47D7A.1	F32D8.6
+Y47D7A.8	F32D8.6
+Y47H9C.5	F32D8.6
+Y49E10.4	F32D8.6
+Y54G2A.18	F32D8.6
+Y56A3A.2	F32D8.6
+Y56A3A.21	F32D8.6
+Y60A3A.18	F32D8.6
+Y71F9AM.6	F32D8.6
+Y77E11A.13	F32D8.6
+Y87G2A.9	F32D8.6
+Y94H6A.9	F32D8.6
+ZC410.3	F32D8.6
+ZC506.1	F32D8.6
+ZC518.2	F32D8.6
+ZK1307.8	F32D8.6
+ZK180.4	F32D8.6
+ZK20.3	F32D8.6
+ZK287.5	F32D8.6
+ZK632.6	F32D8.6
+ZK686.3	F32D8.6
+F40F9.6	F39B2.10
+F44E5.4	F39B2.10
+F44E5.5	F39B2.10
+F44G3.6	F39B2.10
+F45D3.5	F39B2.10
+F45E6.2	F39B2.10
+F46A9.4	F39B2.10
+F46A9.5	F39B2.10
+F46C3.1	F39B2.10
+F47H4.10	F39B2.10
+F48E3.3	F39B2.10
+F52C6.12	F39B2.10
+F52D1.1	F39B2.10
+F54D10.1	F39B2.10
+F54F2.9	F39B2.10
+F55A11.3	F39B2.10
+F55A3.1	F39B2.10
+F56B3.12	F39B2.10
+F56G4.5	F39B2.10
+F57B10.10	F39B2.10
+F57B10.11	F39B2.10
+F58A4.10	F39B2.10
+F59A6.1	F39B2.10
+F59E12.5	F39B2.10
+H06H21.6	F39B2.10
+H06O01.1	F39B2.10
+H14N18.1	F39B2.10
+K02B12.3	F39B2.10
+K02G10.8	F39B2.10
+K04G2.3	F39B2.10
+K07A1.8	F39B2.10
+K08A8.1	F39B2.10
+K08E3.7	F39B2.10
+K08H2.1	F39B2.10
+M7.1	F39B2.10
+R12H7.3	F39B2.10
+R12H7.5	F39B2.10
+R151.6	F39B2.10
+R74.3	F39B2.10
+T03G11.4	F39B2.10
+T04G9.3	F39B2.10
+T04G9.5	F39B2.10
+T05C3.5	F39B2.10
+T05E11.3	F39B2.10
+T05H10.5	F39B2.10
+T09A5.11	F39B2.10
+T09B4.10	F39B2.10
+T12A2.2	F39B2.10
+T14G8.3	F39B2.10
+T15H9.7	F39B2.10
+T22D1.4	F39B2.10
+T24H7.2	F39B2.10
+Y105C5B.13	F39B2.10
+Y105E8A.2	F39B2.10
+Y110A2AM.3	F39B2.10
+Y110A2AR.2	F39B2.10
+Y113G7A.3	F39B2.10
+Y37E3.10	F39B2.10
+Y37H2C.2	F39B2.10
+Y38A10A.5	F39B2.10
+Y38F2AR.2	F39B2.10
+Y38F2AR.9	F39B2.10
+Y47D7A.1	F39B2.10
+Y47D7A.8	F39B2.10
+Y47H9C.5	F39B2.10
+Y49E10.4	F39B2.10
+Y54G2A.18	F39B2.10
+Y56A3A.2	F39B2.10
+Y56A3A.21	F39B2.10
+Y57G11C.15	F39B2.10
+Y60A3A.18	F39B2.10
+Y63D3A.6	F39B2.10
+Y71F9AM.6	F39B2.10
+Y77E11A.13	F39B2.10
+Y87G2A.9	F39B2.10
+Y94H6A.9	F39B2.10
+ZC410.3	F39B2.10
+ZC506.1	F39B2.10
+ZC518.2	F39B2.10
+ZK1307.8	F39B2.10
+ZK180.4	F39B2.10
+ZK20.3	F39B2.10
+ZK287.5	F39B2.10
+ZK632.6	F39B2.10
+ZK686.3	F39B2.10
+F44E5.4	F40F9.6
+F44E5.5	F40F9.6
+F44G3.6	F40F9.6
+F45D3.5	F40F9.6
+F45E6.2	F40F9.6
+F46A9.4	F40F9.6
+F46A9.5	F40F9.6
+F46C3.1	F40F9.6
+F47H4.10	F40F9.6
+F48E3.3	F40F9.6
+F52C6.12	F40F9.6
+F54D10.1	F40F9.6
+F54F2.9	F40F9.6
+F55A11.3	F40F9.6
+F55A3.1	F40F9.6
+F56B3.12	F40F9.6
+F56G4.5	F40F9.6
+F57B10.11	F40F9.6
+F58A4.10	F40F9.6
+F59A6.1	F40F9.6
+F59E12.5	F40F9.6
+H06H21.6	F40F9.6
+H06O01.1	F40F9.6
+H14N18.1	F40F9.6
+K02B12.3	F40F9.6
+K02G10.8	F40F9.6
+K04G2.3	F40F9.6
+K07A1.8	F40F9.6
+K08A8.1	F40F9.6
+K08E3.7	F40F9.6
+K08H2.1	F40F9.6
+M7.1	F40F9.6
+R12H7.3	F40F9.6
+R12H7.5	F40F9.6
+R151.6	F40F9.6
+R74.3	F40F9.6
+T04G9.3	F40F9.6
+T04G9.5	F40F9.6
+T05C3.5	F40F9.6
+T05E11.3	F40F9.6
+T05H10.5	F40F9.6
+T09B4.10	F40F9.6
+T14G8.3	F40F9.6
+T15H9.7	F40F9.6
+T24H7.2	F40F9.6
+Y105C5B.13	F40F9.6
+Y105E8A.2	F40F9.6
+Y110A2AM.3	F40F9.6
+Y110A2AR.2	F40F9.6
+Y113G7A.3	F40F9.6
+Y37E3.10	F40F9.6
+Y37H2C.2	F40F9.6
+Y38A10A.5	F40F9.6
+Y38F2AR.2	F40F9.6
+Y38F2AR.9	F40F9.6
+Y47D7A.1	F40F9.6
+Y47D7A.8	F40F9.6
+Y47H9C.5	F40F9.6
+Y49E10.4	F40F9.6
+Y54G2A.18	F40F9.6
+Y56A3A.2	F40F9.6
+Y56A3A.21	F40F9.6
+Y57G11C.15	F40F9.6
+Y60A3A.18	F40F9.6
+Y63D3A.6	F40F9.6
+Y71F9AM.6	F40F9.6
+Y77E11A.13	F40F9.6
+Y87G2A.9	F40F9.6
+Y94H6A.9	F40F9.6
+ZC506.1	F40F9.6
+ZC518.2	F40F9.6
+ZK1307.8	F40F9.6
+ZK180.4	F40F9.6
+ZK20.3	F40F9.6
+ZK287.5	F40F9.6
+ZK632.6	F40F9.6
+F44G3.6	F44E5.4
+F45D3.5	F44E5.4
+F45E6.2	F44E5.4
+F46A9.4	F44E5.4
+F46A9.5	F44E5.4
+F46C3.1	F44E5.4
+F47H4.10	F44E5.4
+F48E3.3	F44E5.4
+F52C6.12	F44E5.4
+F52D1.1	F44E5.4
+F54D10.1	F44E5.4
+F54F2.9	F44E5.4
+F55A11.3	F44E5.4
+F55A3.1	F44E5.4
+F56B3.12	F44E5.4
+F56G4.5	F44E5.4
+F57B10.10	F44E5.4
+F57B10.11	F44E5.4
+F58A4.10	F44E5.4
+F59E12.5	F44E5.4
+H06H21.6	F44E5.4
+H06O01.1	F44E5.4
+H14N18.1	F44E5.4
+K02B12.3	F44E5.4
+K02G10.8	F44E5.4
+K04G2.3	F44E5.4
+K07A1.8	F44E5.4
+K08E3.7	F44E5.4
+K08H2.1	F44E5.4
+M7.1	F44E5.4
+R12H7.3	F44E5.4
+R12H7.5	F44E5.4
+R151.6	F44E5.4
+R74.3	F44E5.4
+T03G11.4	F44E5.4
+T04G9.3	F44E5.4
+T04G9.5	F44E5.4
+T05C3.5	F44E5.4
+T05E11.3	F44E5.4
+T05H10.5	F44E5.4
+T09A5.11	F44E5.4
+T09B4.10	F44E5.4
+T12A2.2	F44E5.4
+T14G8.3	F44E5.4
+T15H9.7	F44E5.4
+T22D1.4	F44E5.4
+T24H7.2	F44E5.4
+Y105C5B.13	F44E5.4
+Y105E8A.2	F44E5.4
+Y110A2AM.3	F44E5.4
+Y110A2AR.2	F44E5.4
+Y113G7A.3	F44E5.4
+Y37E3.10	F44E5.4
+Y37H2C.2	F44E5.4
+Y38A10A.5	F44E5.4
+Y38F2AR.2	F44E5.4
+Y38F2AR.9	F44E5.4
+Y47D7A.1	F44E5.4
+Y47D7A.8	F44E5.4
+Y47H9C.5	F44E5.4
+Y49E10.4	F44E5.4
+Y54G2A.18	F44E5.4
+Y56A3A.2	F44E5.4
+Y56A3A.21	F44E5.4
+Y57G11C.15	F44E5.4
+Y60A3A.18	F44E5.4
+Y63D3A.6	F44E5.4
+Y71F9AM.6	F44E5.4
+Y77E11A.13	F44E5.4
+Y87G2A.9	F44E5.4
+Y94H6A.9	F44E5.4
+ZC410.3	F44E5.4
+ZC506.1	F44E5.4
+ZC518.2	F44E5.4
+ZK1307.8	F44E5.4
+ZK180.4	F44E5.4
+ZK20.3	F44E5.4
+ZK287.5	F44E5.4
+ZK632.6	F44E5.4
+ZK686.3	F44E5.4
+F44G3.6	F44E5.5
+F45D3.5	F44E5.5
+F45E6.2	F44E5.5
+F46A9.4	F44E5.5
+F46A9.5	F44E5.5
+F46C3.1	F44E5.5
+F47H4.10	F44E5.5
+F48E3.3	F44E5.5
+F52C6.12	F44E5.5
+F52D1.1	F44E5.5
+F54D10.1	F44E5.5
+F54F2.9	F44E5.5
+F55A11.3	F44E5.5
+F55A3.1	F44E5.5
+F56B3.12	F44E5.5
+F56G4.5	F44E5.5
+F57B10.10	F44E5.5
+F57B10.11	F44E5.5
+F58A4.10	F44E5.5
+F59E12.5	F44E5.5
+H06H21.6	F44E5.5
+H06O01.1	F44E5.5
+H14N18.1	F44E5.5
+K02B12.3	F44E5.5
+K02G10.8	F44E5.5
+K04G2.3	F44E5.5
+K07A1.8	F44E5.5
+K08E3.7	F44E5.5
+K08H2.1	F44E5.5
+M7.1	F44E5.5
+R12H7.3	F44E5.5
+R12H7.5	F44E5.5
+R151.6	F44E5.5
+R74.3	F44E5.5
+T03G11.4	F44E5.5
+T04G9.3	F44E5.5
+T04G9.5	F44E5.5
+T05C3.5	F44E5.5
+T05E11.3	F44E5.5
+T05H10.5	F44E5.5
+T09A5.11	F44E5.5
+T09B4.10	F44E5.5
+T12A2.2	F44E5.5
+T14G8.3	F44E5.5
+T15H9.7	F44E5.5
+T22D1.4	F44E5.5
+T24H7.2	F44E5.5
+Y105C5B.13	F44E5.5
+Y105E8A.2	F44E5.5
+Y110A2AM.3	F44E5.5
+Y110A2AR.2	F44E5.5
+Y113G7A.3	F44E5.5
+Y37E3.10	F44E5.5
+Y37H2C.2	F44E5.5
+Y38A10A.5	F44E5.5
+Y38F2AR.2	F44E5.5
+Y38F2AR.9	F44E5.5
+Y47D7A.1	F44E5.5
+Y47D7A.8	F44E5.5
+Y47H9C.5	F44E5.5
+Y49E10.4	F44E5.5
+Y54G2A.18	F44E5.5
+Y56A3A.2	F44E5.5
+Y56A3A.21	F44E5.5
+Y57G11C.15	F44E5.5
+Y60A3A.18	F44E5.5
+Y63D3A.6	F44E5.5
+Y71F9AM.6	F44E5.5
+Y77E11A.13	F44E5.5
+Y87G2A.9	F44E5.5
+Y94H6A.9	F44E5.5
+ZC410.3	F44E5.5
+ZC506.1	F44E5.5
+ZC518.2	F44E5.5
+ZK1307.8	F44E5.5
+ZK180.4	F44E5.5
+ZK20.3	F44E5.5
+ZK287.5	F44E5.5
+ZK632.6	F44E5.5
+ZK686.3	F44E5.5
+F45D3.5	F44G3.6
+F45E6.2	F44G3.6
+F46C3.1	F44G3.6
+F48E3.3	F44G3.6
+F52D1.1	F44G3.6
+F54F2.9	F44G3.6
+F55A3.1	F44G3.6
+F56G4.5	F44G3.6
+F57B10.10	F44G3.6
+F57B10.11	F44G3.6
+F59A6.1	F44G3.6
+F59E12.5	F44G3.6
+H06H21.6	F44G3.6
+H06O01.1	F44G3.6
+H14N18.1	F44G3.6
+K02B12.3	F44G3.6
+K02G10.8	F44G3.6
+K04G2.3	F44G3.6
+K07A1.8	F44G3.6
+K08A8.1	F44G3.6
+R151.6	F44G3.6
+R74.3	F44G3.6
+T03G11.4	F44G3.6
+T04G9.3	F44G3.6
+T04G9.5	F44G3.6
+T05C3.5	F44G3.6
+T05E11.3	F44G3.6
+T09A5.11	F44G3.6
+T12A2.2	F44G3.6
+T14G8.3	F44G3.6
+T15H9.7	F44G3.6
+T22D1.4	F44G3.6
+T24H7.2	F44G3.6
+Y105E8A.2	F44G3.6
+Y113G7A.3	F44G3.6
+Y37E3.10	F44G3.6
+Y38A10A.5	F44G3.6
+Y38F2AR.2	F44G3.6
+Y38F2AR.9	F44G3.6
+Y47H9C.5	F44G3.6
+Y49E10.4	F44G3.6
+Y54G2A.18	F44G3.6
+Y56A3A.2	F44G3.6
+Y56A3A.21	F44G3.6
+Y57G11C.15	F44G3.6
+Y63D3A.6	F44G3.6
+Y71F9AM.6	F44G3.6
+Y77E11A.13	F44G3.6
+Y94H6A.9	F44G3.6
+ZC410.3	F44G3.6
+ZC506.1	F44G3.6
+ZC518.2	F44G3.6
+ZK1307.8	F44G3.6
+ZK180.4	F44G3.6
+ZK20.3	F44G3.6
+ZK632.6	F44G3.6
+ZK686.3	F44G3.6
+F45E6.2	F45D3.5
+F46A9.4	F45D3.5
+F46A9.5	F45D3.5
+F46C3.1	F45D3.5
+F47H4.10	F45D3.5
+F48E3.3	F45D3.5
+F52C6.12	F45D3.5
+F52D1.1	F45D3.5
+F54D10.1	F45D3.5
+F54F2.9	F45D3.5
+F55A11.3	F45D3.5
+F55A3.1	F45D3.5
+F56B3.12	F45D3.5
+F56G4.5	F45D3.5
+F57B10.10	F45D3.5
+F57B10.11	F45D3.5
+F58A4.10	F45D3.5
+F59A6.1	F45D3.5
+F59E12.5	F45D3.5
+H06H21.6	F45D3.5
+H06O01.1	F45D3.5
+H14N18.1	F45D3.5
+K02B12.3	F45D3.5
+K02G10.8	F45D3.5
+K04G2.3	F45D3.5
+K07A1.8	F45D3.5
+K08A8.1	F45D3.5
+K08E3.7	F45D3.5
+K08H2.1	F45D3.5
+M7.1	F45D3.5
+R12H7.3	F45D3.5
+R12H7.5	F45D3.5
+R151.6	F45D3.5
+R74.3	F45D3.5
+T03G11.4	F45D3.5
+T04G9.3	F45D3.5
+T04G9.5	F45D3.5
+T05C3.5	F45D3.5
+T05E11.3	F45D3.5
+T05H10.5	F45D3.5
+T09A5.11	F45D3.5
+T09B4.10	F45D3.5
+T12A2.2	F45D3.5
+T14G8.3	F45D3.5
+T15H9.7	F45D3.5
+T22D1.4	F45D3.5
+T24H7.2	F45D3.5
+Y105C5B.13	F45D3.5
+Y105E8A.2	F45D3.5
+Y110A2AM.3	F45D3.5
+Y110A2AR.2	F45D3.5
+Y113G7A.3	F45D3.5
+Y37E3.10	F45D3.5
+Y37H2C.2	F45D3.5
+Y38A10A.5	F45D3.5
+Y38F2AR.2	F45D3.5
+Y38F2AR.9	F45D3.5
+Y47D7A.1	F45D3.5
+Y47D7A.8	F45D3.5
+Y47H9C.5	F45D3.5
+Y49E10.4	F45D3.5
+Y54G2A.18	F45D3.5
+Y56A3A.2	F45D3.5
+Y56A3A.21	F45D3.5
+Y57G11C.15	F45D3.5
+Y60A3A.18	F45D3.5
+Y63D3A.6	F45D3.5
+Y71F9AM.6	F45D3.5
+Y77E11A.13	F45D3.5
+Y87G2A.9	F45D3.5
+Y94H6A.9	F45D3.5
+ZC410.3	F45D3.5
+ZC506.1	F45D3.5
+ZC518.2	F45D3.5
+ZK1307.8	F45D3.5
+ZK180.4	F45D3.5
+ZK20.3	F45D3.5
+ZK287.5	F45D3.5
+ZK632.6	F45D3.5
+ZK686.3	F45D3.5
+F46A9.4	F45E6.2
+F46A9.5	F45E6.2
+F46C3.1	F45E6.2
+F47H4.10	F45E6.2
+F48E3.3	F45E6.2
+F52C6.12	F45E6.2
+F52D1.1	F45E6.2
+F54D10.1	F45E6.2
+F54F2.9	F45E6.2
+F55A11.3	F45E6.2
+F55A3.1	F45E6.2
+F56B3.12	F45E6.2
+F56G4.5	F45E6.2
+F57B10.10	F45E6.2
+F57B10.11	F45E6.2
+F58A4.10	F45E6.2
+F59A6.1	F45E6.2
+F59E12.5	F45E6.2
+H06H21.6	F45E6.2
+H06O01.1	F45E6.2
+H14N18.1	F45E6.2
+K02B12.3	F45E6.2
+K02G10.8	F45E6.2
+K04G2.3	F45E6.2
+K07A1.8	F45E6.2
+K08A8.1	F45E6.2
+K08E3.7	F45E6.2
+K08H2.1	F45E6.2
+M7.1	F45E6.2
+R12H7.3	F45E6.2
+R12H7.5	F45E6.2
+R151.6	F45E6.2
+R74.3	F45E6.2
+T03G11.4	F45E6.2
+T04G9.3	F45E6.2
+T04G9.5	F45E6.2
+T05C3.5	F45E6.2
+T05E11.3	F45E6.2
+T05H10.5	F45E6.2
+T09A5.11	F45E6.2
+T09B4.10	F45E6.2
+T12A2.2	F45E6.2
+T14G8.3	F45E6.2
+T15H9.7	F45E6.2
+T22D1.4	F45E6.2
+T24H7.2	F45E6.2
+Y105C5B.13	F45E6.2
+Y105E8A.2	F45E6.2
+Y110A2AM.3	F45E6.2
+Y110A2AR.2	F45E6.2
+Y113G7A.3	F45E6.2
+Y37E3.10	F45E6.2
+Y37H2C.2	F45E6.2
+Y38A10A.5	F45E6.2
+Y38F2AR.2	F45E6.2
+Y38F2AR.9	F45E6.2
+Y47D7A.1	F45E6.2
+Y47D7A.8	F45E6.2
+Y47H9C.5	F45E6.2
+Y49E10.4	F45E6.2
+Y54G2A.18	F45E6.2
+Y56A3A.2	F45E6.2
+Y56A3A.21	F45E6.2
+Y57G11C.15	F45E6.2
+Y60A3A.18	F45E6.2
+Y63D3A.6	F45E6.2
+Y71F9AM.6	F45E6.2
+Y77E11A.13	F45E6.2
+Y87G2A.9	F45E6.2
+Y94H6A.9	F45E6.2
+ZC410.3	F45E6.2
+ZC506.1	F45E6.2
+ZC518.2	F45E6.2
+ZK1307.8	F45E6.2
+ZK180.4	F45E6.2
+ZK20.3	F45E6.2
+ZK287.5	F45E6.2
+ZK632.6	F45E6.2
+ZK686.3	F45E6.2
+F46C3.1	F46A9.4
+F48E3.3	F46A9.4
+F52D1.1	F46A9.4
+F54F2.9	F46A9.4
+F55A3.1	F46A9.4
+F56G4.5	F46A9.4
+F57B10.10	F46A9.4
+F57B10.11	F46A9.4
+F59A6.1	F46A9.4
+F59E12.5	F46A9.4
+H06H21.6	F46A9.4
+H06O01.1	F46A9.4
+H14N18.1	F46A9.4
+K02B12.3	F46A9.4
+K02G10.8	F46A9.4
+K04G2.3	F46A9.4
+K07A1.8	F46A9.4
+K08A8.1	F46A9.4
+R151.6	F46A9.4
+R74.3	F46A9.4
+T03G11.4	F46A9.4
+T04G9.3	F46A9.4
+T04G9.5	F46A9.4
+T05C3.5	F46A9.4
+T05E11.3	F46A9.4
+T09A5.11	F46A9.4
+T12A2.2	F46A9.4
+T14G8.3	F46A9.4
+T15H9.7	F46A9.4
+T22D1.4	F46A9.4
+T24H7.2	F46A9.4
+Y105E8A.2	F46A9.4
+Y113G7A.3	F46A9.4
+Y37E3.10	F46A9.4
+Y38A10A.5	F46A9.4
+Y38F2AR.2	F46A9.4
+Y38F2AR.9	F46A9.4
+Y47H9C.5	F46A9.4
+Y49E10.4	F46A9.4
+Y54G2A.18	F46A9.4
+Y56A3A.2	F46A9.4
+Y56A3A.21	F46A9.4
+Y57G11C.15	F46A9.4
+Y63D3A.6	F46A9.4
+Y71F9AM.6	F46A9.4
+Y77E11A.13	F46A9.4
+Y94H6A.9	F46A9.4
+ZC410.3	F46A9.4
+ZC506.1	F46A9.4
+ZC518.2	F46A9.4
+ZK1307.8	F46A9.4
+ZK180.4	F46A9.4
+ZK20.3	F46A9.4
+ZK632.6	F46A9.4
+ZK686.3	F46A9.4
+F46C3.1	F46A9.5
+F48E3.3	F46A9.5
+F52D1.1	F46A9.5
+F54F2.9	F46A9.5
+F55A3.1	F46A9.5
+F56G4.5	F46A9.5
+F57B10.10	F46A9.5
+F57B10.11	F46A9.5
+F59A6.1	F46A9.5
+F59E12.5	F46A9.5
+H06H21.6	F46A9.5
+H06O01.1	F46A9.5
+H14N18.1	F46A9.5
+K02B12.3	F46A9.5
+K02G10.8	F46A9.5
+K04G2.3	F46A9.5
+K07A1.8	F46A9.5
+K08A8.1	F46A9.5
+R151.6	F46A9.5
+R74.3	F46A9.5
+T03G11.4	F46A9.5
+T04G9.3	F46A9.5
+T04G9.5	F46A9.5
+T05C3.5	F46A9.5
+T05E11.3	F46A9.5
+T09A5.11	F46A9.5
+T12A2.2	F46A9.5
+T14G8.3	F46A9.5
+T15H9.7	F46A9.5
+T22D1.4	F46A9.5
+T24H7.2	F46A9.5
+Y105E8A.2	F46A9.5
+Y113G7A.3	F46A9.5
+Y37E3.10	F46A9.5
+Y38A10A.5	F46A9.5
+Y38F2AR.2	F46A9.5
+Y38F2AR.9	F46A9.5
+Y47H9C.5	F46A9.5
+Y49E10.4	F46A9.5
+Y54G2A.18	F46A9.5
+Y56A3A.2	F46A9.5
+Y56A3A.21	F46A9.5
+Y57G11C.15	F46A9.5
+Y63D3A.6	F46A9.5
+Y71F9AM.6	F46A9.5
+Y77E11A.13	F46A9.5
+Y94H6A.9	F46A9.5
+ZC410.3	F46A9.5
+ZC506.1	F46A9.5
+ZC518.2	F46A9.5
+ZK1307.8	F46A9.5
+ZK180.4	F46A9.5
+ZK20.3	F46A9.5
+ZK632.6	F46A9.5
+ZK686.3	F46A9.5
+F47H4.10	F46C3.1
+F48E3.3	F46C3.1
+F52C6.12	F46C3.1
+F52D1.1	F46C3.1
+F54D10.1	F46C3.1
+F54F2.9	F46C3.1
+F55A11.3	F46C3.1
+F55A3.1	F46C3.1
+F56B3.12	F46C3.1
+F56G4.5	F46C3.1
+F57B10.10	F46C3.1
+F57B10.11	F46C3.1
+F58A4.10	F46C3.1
+F59A6.1	F46C3.1
+F59E12.5	F46C3.1
+H06H21.6	F46C3.1
+H06O01.1	F46C3.1
+H14N18.1	F46C3.1
+K02B12.3	F46C3.1
+K02G10.8	F46C3.1
+K04G2.3	F46C3.1
+K07A1.8	F46C3.1
+K08A8.1	F46C3.1
+K08E3.7	F46C3.1
+K08H2.1	F46C3.1
+M7.1	F46C3.1
+R12H7.3	F46C3.1
+R12H7.5	F46C3.1
+R151.6	F46C3.1
+R74.3	F46C3.1
+T03G11.4	F46C3.1
+T04G9.3	F46C3.1
+T04G9.5	F46C3.1
+T05C3.5	F46C3.1
+T05E11.3	F46C3.1
+T05H10.5	F46C3.1
+T09A5.11	F46C3.1
+T09B4.10	F46C3.1
+T12A2.2	F46C3.1
+T14G8.3	F46C3.1
+T15H9.7	F46C3.1
+T22D1.4	F46C3.1
+T24H7.2	F46C3.1
+Y105C5B.13	F46C3.1
+Y105E8A.2	F46C3.1
+Y110A2AM.3	F46C3.1
+Y110A2AR.2	F46C3.1
+Y113G7A.3	F46C3.1
+Y37E3.10	F46C3.1
+Y37H2C.2	F46C3.1
+Y38A10A.5	F46C3.1
+Y38F2AR.2	F46C3.1
+Y38F2AR.9	F46C3.1
+Y47D7A.1	F46C3.1
+Y47D7A.8	F46C3.1
+Y47H9C.5	F46C3.1
+Y49E10.4	F46C3.1
+Y54G2A.18	F46C3.1
+Y56A3A.2	F46C3.1
+Y56A3A.21	F46C3.1
+Y57G11C.15	F46C3.1
+Y60A3A.18	F46C3.1
+Y63D3A.6	F46C3.1
+Y71F9AM.6	F46C3.1
+Y77E11A.13	F46C3.1
+Y87G2A.9	F46C3.1
+Y94H6A.9	F46C3.1
+ZC410.3	F46C3.1
+ZC506.1	F46C3.1
+ZC518.2	F46C3.1
+ZK1307.8	F46C3.1
+ZK180.4	F46C3.1
+ZK20.3	F46C3.1
+ZK287.5	F46C3.1
+ZK632.6	F46C3.1
+ZK686.3	F46C3.1
+F48E3.3	F47H4.10
+F52D1.1	F47H4.10
+F54F2.9	F47H4.10
+F55A3.1	F47H4.10
+F56G4.5	F47H4.10
+F57B10.10	F47H4.10
+F57B10.11	F47H4.10
+F59A6.1	F47H4.10
+F59E12.5	F47H4.10
+H06H21.6	F47H4.10
+H06O01.1	F47H4.10
+H14N18.1	F47H4.10
+K02B12.3	F47H4.10
+K02G10.8	F47H4.10
+K04G2.3	F47H4.10
+K07A1.8	F47H4.10
+K08A8.1	F47H4.10
+R151.6	F47H4.10
+R74.3	F47H4.10
+T03G11.4	F47H4.10
+T04G9.3	F47H4.10
+T04G9.5	F47H4.10
+T05C3.5	F47H4.10
+T05E11.3	F47H4.10
+T09A5.11	F47H4.10
+T12A2.2	F47H4.10
+T14G8.3	F47H4.10
+T15H9.7	F47H4.10
+T22D1.4	F47H4.10
+T24H7.2	F47H4.10
+Y105E8A.2	F47H4.10
+Y113G7A.3	F47H4.10
+Y37E3.10	F47H4.10
+Y38A10A.5	F47H4.10
+Y38F2AR.2	F47H4.10
+Y38F2AR.9	F47H4.10
+Y47H9C.5	F47H4.10
+Y49E10.4	F47H4.10
+Y54G2A.18	F47H4.10
+Y56A3A.2	F47H4.10
+Y56A3A.21	F47H4.10
+Y57G11C.15	F47H4.10
+Y63D3A.6	F47H4.10
+Y71F9AM.6	F47H4.10
+Y77E11A.13	F47H4.10
+Y94H6A.9	F47H4.10
+ZC410.3	F47H4.10
+ZC506.1	F47H4.10
+ZC518.2	F47H4.10
+ZK1307.8	F47H4.10
+ZK180.4	F47H4.10
+ZK20.3	F47H4.10
+ZK632.6	F47H4.10
+ZK686.3	F47H4.10
+F52C6.12	F48E3.3
+F52D1.1	F48E3.3
+F54D10.1	F48E3.3
+F54F2.9	F48E3.3
+F55A11.3	F48E3.3
+F55A3.1	F48E3.3
+F56B3.12	F48E3.3
+F56G4.5	F48E3.3
+F57B10.10	F48E3.3
+F57B10.11	F48E3.3
+F58A4.10	F48E3.3
+F59A6.1	F48E3.3
+F59E12.5	F48E3.3
+H06H21.6	F48E3.3
+H06O01.1	F48E3.3
+H14N18.1	F48E3.3
+K02B12.3	F48E3.3
+K02G10.8	F48E3.3
+K04G2.3	F48E3.3
+K07A1.8	F48E3.3
+K08A8.1	F48E3.3
+K08E3.7	F48E3.3
+K08H2.1	F48E3.3
+M7.1	F48E3.3
+R12H7.3	F48E3.3
+R12H7.5	F48E3.3
+R151.6	F48E3.3
+R74.3	F48E3.3
+T03G11.4	F48E3.3
+T04G9.3	F48E3.3
+T04G9.5	F48E3.3
+T05C3.5	F48E3.3
+T05E11.3	F48E3.3
+T05H10.5	F48E3.3
+T09A5.11	F48E3.3
+T09B4.10	F48E3.3
+T12A2.2	F48E3.3
+T14G8.3	F48E3.3
+T15H9.7	F48E3.3
+T22D1.4	F48E3.3
+T24H7.2	F48E3.3
+Y105C5B.13	F48E3.3
+Y105E8A.2	F48E3.3
+Y110A2AM.3	F48E3.3
+Y110A2AR.2	F48E3.3
+Y113G7A.3	F48E3.3
+Y37E3.10	F48E3.3
+Y37H2C.2	F48E3.3
+Y38A10A.5	F48E3.3
+Y38F2AR.2	F48E3.3
+Y38F2AR.9	F48E3.3
+Y47D7A.1	F48E3.3
+Y47D7A.8	F48E3.3
+Y47H9C.5	F48E3.3
+Y49E10.4	F48E3.3
+Y54G2A.18	F48E3.3
+Y56A3A.2	F48E3.3
+Y56A3A.21	F48E3.3
+Y57G11C.15	F48E3.3
+Y60A3A.18	F48E3.3
+Y63D3A.6	F48E3.3
+Y71F9AM.6	F48E3.3
+Y77E11A.13	F48E3.3
+Y87G2A.9	F48E3.3
+Y94H6A.9	F48E3.3
+ZC410.3	F48E3.3
+ZC506.1	F48E3.3
+ZC518.2	F48E3.3
+ZK1307.8	F48E3.3
+ZK180.4	F48E3.3
+ZK20.3	F48E3.3
+ZK287.5	F48E3.3
+ZK632.6	F48E3.3
+ZK686.3	F48E3.3
+F52D1.1	F52C6.12
+F54F2.9	F52C6.12
+F55A3.1	F52C6.12
+F56G4.5	F52C6.12
+F57B10.10	F52C6.12
+F57B10.11	F52C6.12
+F59A6.1	F52C6.12
+F59E12.5	F52C6.12
+H06H21.6	F52C6.12
+H06O01.1	F52C6.12
+H14N18.1	F52C6.12
+K02B12.3	F52C6.12
+K02G10.8	F52C6.12
+K04G2.3	F52C6.12
+K07A1.8	F52C6.12
+K08A8.1	F52C6.12
+R151.6	F52C6.12
+R74.3	F52C6.12
+T03G11.4	F52C6.12
+T04G9.3	F52C6.12
+T04G9.5	F52C6.12
+T05C3.5	F52C6.12
+T05E11.3	F52C6.12
+T09A5.11	F52C6.12
+T12A2.2	F52C6.12
+T14G8.3	F52C6.12
+T15H9.7	F52C6.12
+T22D1.4	F52C6.12
+T24H7.2	F52C6.12
+Y105E8A.2	F52C6.12
+Y113G7A.3	F52C6.12
+Y37E3.10	F52C6.12
+Y38A10A.5	F52C6.12
+Y38F2AR.2	F52C6.12
+Y38F2AR.9	F52C6.12
+Y47H9C.5	F52C6.12
+Y49E10.4	F52C6.12
+Y54G2A.18	F52C6.12
+Y56A3A.2	F52C6.12
+Y56A3A.21	F52C6.12
+Y57G11C.15	F52C6.12
+Y63D3A.6	F52C6.12
+Y71F9AM.6	F52C6.12
+Y77E11A.13	F52C6.12
+Y94H6A.9	F52C6.12
+ZC410.3	F52C6.12
+ZC506.1	F52C6.12
+ZC518.2	F52C6.12
+ZK1307.8	F52C6.12
+ZK180.4	F52C6.12
+ZK20.3	F52C6.12
+ZK632.6	F52C6.12
+ZK686.3	F52C6.12
+F54D10.1	F52D1.1
+F54F2.9	F52D1.1
+F55A11.3	F52D1.1
+F55A3.1	F52D1.1
+F56B3.12	F52D1.1
+F56G4.5	F52D1.1
+F57B10.11	F52D1.1
+F58A4.10	F52D1.1
+F59A6.1	F52D1.1
+F59E12.5	F52D1.1
+H06H21.6	F52D1.1
+H06O01.1	F52D1.1
+H14N18.1	F52D1.1
+K02B12.3	F52D1.1
+K02G10.8	F52D1.1
+K04G2.3	F52D1.1
+K07A1.8	F52D1.1
+K08A8.1	F52D1.1
+K08E3.7	F52D1.1
+K08H2.1	F52D1.1
+M7.1	F52D1.1
+R12H7.3	F52D1.1
+R12H7.5	F52D1.1
+R151.6	F52D1.1
+R74.3	F52D1.1
+T04G9.3	F52D1.1
+T04G9.5	F52D1.1
+T05C3.5	F52D1.1
+T05E11.3	F52D1.1
+T05H10.5	F52D1.1
+T09B4.10	F52D1.1
+T14G8.3	F52D1.1
+T15H9.7	F52D1.1
+T24H7.2	F52D1.1
+Y105C5B.13	F52D1.1
+Y105E8A.2	F52D1.1
+Y110A2AM.3	F52D1.1
+Y110A2AR.2	F52D1.1
+Y113G7A.3	F52D1.1
+Y37E3.10	F52D1.1
+Y37H2C.2	F52D1.1
+Y38A10A.5	F52D1.1
+Y38F2AR.2	F52D1.1
+Y38F2AR.9	F52D1.1
+Y47D7A.1	F52D1.1
+Y47D7A.8	F52D1.1
+Y47H9C.5	F52D1.1
+Y49E10.4	F52D1.1
+Y54G2A.18	F52D1.1
+Y56A3A.2	F52D1.1
+Y56A3A.21	F52D1.1
+Y57G11C.15	F52D1.1
+Y60A3A.18	F52D1.1
+Y63D3A.6	F52D1.1
+Y71F9AM.6	F52D1.1
+Y77E11A.13	F52D1.1
+Y87G2A.9	F52D1.1
+Y94H6A.9	F52D1.1
+ZC506.1	F52D1.1
+ZC518.2	F52D1.1
+ZK1307.8	F52D1.1
+ZK180.4	F52D1.1
+ZK20.3	F52D1.1
+ZK287.5	F52D1.1
+ZK632.6	F52D1.1
+F54F2.9	F54D10.1
+F55A3.1	F54D10.1
+F56G4.5	F54D10.1
+F57B10.10	F54D10.1
+F57B10.11	F54D10.1
+F59A6.1	F54D10.1
+F59E12.5	F54D10.1
+H06H21.6	F54D10.1
+H06O01.1	F54D10.1
+H14N18.1	F54D10.1
+K02B12.3	F54D10.1
+K02G10.8	F54D10.1
+K04G2.3	F54D10.1
+K07A1.8	F54D10.1
+K08A8.1	F54D10.1
+R151.6	F54D10.1
+R74.3	F54D10.1
+T03G11.4	F54D10.1
+T04G9.3	F54D10.1
+T04G9.5	F54D10.1
+T05C3.5	F54D10.1
+T05E11.3	F54D10.1
+T09A5.11	F54D10.1
+T12A2.2	F54D10.1
+T14G8.3	F54D10.1
+T15H9.7	F54D10.1
+T22D1.4	F54D10.1
+T24H7.2	F54D10.1
+Y105E8A.2	F54D10.1
+Y113G7A.3	F54D10.1
+Y37E3.10	F54D10.1
+Y38A10A.5	F54D10.1
+Y38F2AR.2	F54D10.1
+Y38F2AR.9	F54D10.1
+Y47H9C.5	F54D10.1
+Y49E10.4	F54D10.1
+Y54G2A.18	F54D10.1
+Y56A3A.2	F54D10.1
+Y56A3A.21	F54D10.1
+Y57G11C.15	F54D10.1
+Y63D3A.6	F54D10.1
+Y71F9AM.6	F54D10.1
+Y77E11A.13	F54D10.1
+Y94H6A.9	F54D10.1
+ZC410.3	F54D10.1
+ZC506.1	F54D10.1
+ZC518.2	F54D10.1
+ZK1307.8	F54D10.1
+ZK180.4	F54D10.1
+ZK20.3	F54D10.1
+ZK632.6	F54D10.1
+ZK686.3	F54D10.1
+F55A11.3	F54F2.9
+F55A3.1	F54F2.9
+F56B3.12	F54F2.9
+F56G4.5	F54F2.9
+F57B10.10	F54F2.9
+F57B10.11	F54F2.9
+F58A4.10	F54F2.9
+F59A6.1	F54F2.9
+F59E12.5	F54F2.9
+H06H21.6	F54F2.9
+H06O01.1	F54F2.9
+H14N18.1	F54F2.9
+K02B12.3	F54F2.9
+K02G10.8	F54F2.9
+K04G2.3	F54F2.9
+K07A1.8	F54F2.9
+K08A8.1	F54F2.9
+K08E3.7	F54F2.9
+K08H2.1	F54F2.9
+M7.1	F54F2.9
+R12H7.3	F54F2.9
+R12H7.5	F54F2.9
+R151.6	F54F2.9
+R74.3	F54F2.9
+T03G11.4	F54F2.9
+T04G9.3	F54F2.9
+T04G9.5	F54F2.9
+T05C3.5	F54F2.9
+T05E11.3	F54F2.9
+T05H10.5	F54F2.9
+T09A5.11	F54F2.9
+T09B4.10	F54F2.9
+T12A2.2	F54F2.9
+T14G8.3	F54F2.9
+T15H9.7	F54F2.9
+T22D1.4	F54F2.9
+T24H7.2	F54F2.9
+Y105C5B.13	F54F2.9
+Y105E8A.2	F54F2.9
+Y110A2AM.3	F54F2.9
+Y110A2AR.2	F54F2.9
+Y113G7A.3	F54F2.9
+Y37E3.10	F54F2.9
+Y37H2C.2	F54F2.9
+Y38A10A.5	F54F2.9
+Y38F2AR.2	F54F2.9
+Y38F2AR.9	F54F2.9
+Y47D7A.1	F54F2.9
+Y47D7A.8	F54F2.9
+Y47H9C.5	F54F2.9
+Y49E10.4	F54F2.9
+Y54G2A.18	F54F2.9
+Y56A3A.2	F54F2.9
+Y56A3A.21	F54F2.9
+Y57G11C.15	F54F2.9
+Y60A3A.18	F54F2.9
+Y63D3A.6	F54F2.9
+Y71F9AM.6	F54F2.9
+Y77E11A.13	F54F2.9
+Y87G2A.9	F54F2.9
+Y94H6A.9	F54F2.9
+ZC410.3	F54F2.9
+ZC506.1	F54F2.9
+ZC518.2	F54F2.9
+ZK1307.8	F54F2.9
+ZK180.4	F54F2.9
+ZK20.3	F54F2.9
+ZK287.5	F54F2.9
+ZK632.6	F54F2.9
+ZK686.3	F54F2.9
+F55A3.1	F55A11.3
+F56G4.5	F55A11.3
+F57B10.10	F55A11.3
+F57B10.11	F55A11.3
+F59A6.1	F55A11.3
+F59E12.5	F55A11.3
+H06H21.6	F55A11.3
+H06O01.1	F55A11.3
+H14N18.1	F55A11.3
+K02B12.3	F55A11.3
+K02G10.8	F55A11.3
+K04G2.3	F55A11.3
+K07A1.8	F55A11.3
+K08A8.1	F55A11.3
+R151.6	F55A11.3
+R74.3	F55A11.3
+T03G11.4	F55A11.3
+T04G9.3	F55A11.3
+T04G9.5	F55A11.3
+T05C3.5	F55A11.3
+T05E11.3	F55A11.3
+T09A5.11	F55A11.3
+T12A2.2	F55A11.3
+T14G8.3	F55A11.3
+T15H9.7	F55A11.3
+T22D1.4	F55A11.3
+T24H7.2	F55A11.3
+Y105E8A.2	F55A11.3
+Y113G7A.3	F55A11.3
+Y37E3.10	F55A11.3
+Y38A10A.5	F55A11.3
+Y38F2AR.2	F55A11.3
+Y38F2AR.9	F55A11.3
+Y47H9C.5	F55A11.3
+Y49E10.4	F55A11.3
+Y54G2A.18	F55A11.3
+Y56A3A.2	F55A11.3
+Y56A3A.21	F55A11.3
+Y57G11C.15	F55A11.3
+Y63D3A.6	F55A11.3
+Y71F9AM.6	F55A11.3
+Y77E11A.13	F55A11.3
+Y94H6A.9	F55A11.3
+ZC410.3	F55A11.3
+ZC506.1	F55A11.3
+ZC518.2	F55A11.3
+ZK1307.8	F55A11.3
+ZK180.4	F55A11.3
+ZK20.3	F55A11.3
+ZK632.6	F55A11.3
+ZK686.3	F55A11.3
+F56B3.12	F55A3.1
+F56G4.5	F55A3.1
+F57B10.10	F55A3.1
+F57B10.11	F55A3.1
+F58A4.10	F55A3.1
+F59A6.1	F55A3.1
+F59E12.5	F55A3.1
+H06H21.6	F55A3.1
+H06O01.1	F55A3.1
+H14N18.1	F55A3.1
+K02B12.3	F55A3.1
+K02G10.8	F55A3.1
+K04G2.3	F55A3.1
+K07A1.8	F55A3.1
+K08A8.1	F55A3.1
+K08E3.7	F55A3.1
+K08H2.1	F55A3.1
+M7.1	F55A3.1
+R12H7.3	F55A3.1
+R12H7.5	F55A3.1
+R151.6	F55A3.1
+R74.3	F55A3.1
+T03G11.4	F55A3.1
+T04G9.3	F55A3.1
+T04G9.5	F55A3.1
+T05C3.5	F55A3.1
+T05E11.3	F55A3.1
+T05H10.5	F55A3.1
+T09A5.11	F55A3.1
+T09B4.10	F55A3.1
+T12A2.2	F55A3.1
+T14G8.3	F55A3.1
+T15H9.7	F55A3.1
+T22D1.4	F55A3.1
+T24H7.2	F55A3.1
+Y105C5B.13	F55A3.1
+Y105E8A.2	F55A3.1
+Y110A2AM.3	F55A3.1
+Y110A2AR.2	F55A3.1
+Y113G7A.3	F55A3.1
+Y37E3.10	F55A3.1
+Y37H2C.2	F55A3.1
+Y38A10A.5	F55A3.1
+Y38F2AR.2	F55A3.1
+Y38F2AR.9	F55A3.1
+Y47D7A.1	F55A3.1
+Y47D7A.8	F55A3.1
+Y47H9C.5	F55A3.1
+Y49E10.4	F55A3.1
+Y54G2A.18	F55A3.1
+Y56A3A.2	F55A3.1
+Y56A3A.21	F55A3.1
+Y57G11C.15	F55A3.1
+Y60A3A.18	F55A3.1
+Y63D3A.6	F55A3.1
+Y71F9AM.6	F55A3.1
+Y77E11A.13	F55A3.1
+Y87G2A.9	F55A3.1
+Y94H6A.9	F55A3.1
+ZC410.3	F55A3.1
+ZC506.1	F55A3.1
+ZC518.2	F55A3.1
+ZK1307.8	F55A3.1
+ZK180.4	F55A3.1
+ZK20.3	F55A3.1
+ZK287.5	F55A3.1
+ZK632.6	F55A3.1
+ZK686.3	F55A3.1
+F56G4.5	F56B3.12
+F57B10.10	F56B3.12
+F57B10.11	F56B3.12
+F59A6.1	F56B3.12
+F59E12.5	F56B3.12
+H06H21.6	F56B3.12
+H06O01.1	F56B3.12
+H14N18.1	F56B3.12
+K02B12.3	F56B3.12
+K02G10.8	F56B3.12
+K04G2.3	F56B3.12
+K07A1.8	F56B3.12
+K08A8.1	F56B3.12
+R151.6	F56B3.12
+R74.3	F56B3.12
+T03G11.4	F56B3.12
+T04G9.3	F56B3.12
+T04G9.5	F56B3.12
+T05C3.5	F56B3.12
+T05E11.3	F56B3.12
+T09A5.11	F56B3.12
+T12A2.2	F56B3.12
+T14G8.3	F56B3.12
+T15H9.7	F56B3.12
+T22D1.4	F56B3.12
+T24H7.2	F56B3.12
+Y105E8A.2	F56B3.12
+Y113G7A.3	F56B3.12
+Y37E3.10	F56B3.12
+Y38A10A.5	F56B3.12
+Y38F2AR.2	F56B3.12
+Y38F2AR.9	F56B3.12
+Y47H9C.5	F56B3.12
+Y49E10.4	F56B3.12
+Y54G2A.18	F56B3.12
+Y56A3A.2	F56B3.12
+Y56A3A.21	F56B3.12
+Y57G11C.15	F56B3.12
+Y63D3A.6	F56B3.12
+Y71F9AM.6	F56B3.12
+Y77E11A.13	F56B3.12
+Y94H6A.9	F56B3.12
+ZC410.3	F56B3.12
+ZC506.1	F56B3.12
+ZC518.2	F56B3.12
+ZK1307.8	F56B3.12
+ZK180.4	F56B3.12
+ZK20.3	F56B3.12
+ZK632.6	F56B3.12
+ZK686.3	F56B3.12
+F57B10.10	F56G4.5
+F57B10.11	F56G4.5
+F58A4.10	F56G4.5
+F59A6.1	F56G4.5
+F59E12.5	F56G4.5
+H06H21.6	F56G4.5
+H06O01.1	F56G4.5
+H14N18.1	F56G4.5
+K02B12.3	F56G4.5
+K02G10.8	F56G4.5
+K04G2.3	F56G4.5
+K07A1.8	F56G4.5
+K08A8.1	F56G4.5
+K08E3.7	F56G4.5
+K08H2.1	F56G4.5
+M7.1	F56G4.5
+R12H7.3	F56G4.5
+R12H7.5	F56G4.5
+R151.6	F56G4.5
+R74.3	F56G4.5
+T03G11.4	F56G4.5
+T04G9.3	F56G4.5
+T04G9.5	F56G4.5
+T05C3.5	F56G4.5
+T05E11.3	F56G4.5
+T05H10.5	F56G4.5
+T09A5.11	F56G4.5
+T09B4.10	F56G4.5
+T12A2.2	F56G4.5
+T14G8.3	F56G4.5
+T15H9.7	F56G4.5
+T22D1.4	F56G4.5
+T24H7.2	F56G4.5
+Y105C5B.13	F56G4.5
+Y105E8A.2	F56G4.5
+Y110A2AM.3	F56G4.5
+Y110A2AR.2	F56G4.5
+Y113G7A.3	F56G4.5
+Y37E3.10	F56G4.5
+Y37H2C.2	F56G4.5
+Y38A10A.5	F56G4.5
+Y38F2AR.2	F56G4.5
+Y38F2AR.9	F56G4.5
+Y47D7A.1	F56G4.5
+Y47D7A.8	F56G4.5
+Y47H9C.5	F56G4.5
+Y49E10.4	F56G4.5
+Y54G2A.18	F56G4.5
+Y56A3A.2	F56G4.5
+Y56A3A.21	F56G4.5
+Y57G11C.15	F56G4.5
+Y60A3A.18	F56G4.5
+Y63D3A.6	F56G4.5
+Y71F9AM.6	F56G4.5
+Y77E11A.13	F56G4.5
+Y87G2A.9	F56G4.5
+Y94H6A.9	F56G4.5
+ZC410.3	F56G4.5
+ZC506.1	F56G4.5
+ZC518.2	F56G4.5
+ZK1307.8	F56G4.5
+ZK180.4	F56G4.5
+ZK20.3	F56G4.5
+ZK287.5	F56G4.5
+ZK632.6	F56G4.5
+ZK686.3	F56G4.5
+F57B10.11	F57B10.10
+F58A4.10	F57B10.10
+F59A6.1	F57B10.10
+F59E12.5	F57B10.10
+H06H21.6	F57B10.10
+H06O01.1	F57B10.10
+H14N18.1	F57B10.10
+K02B12.3	F57B10.10
+K02G10.8	F57B10.10
+K04G2.3	F57B10.10
+K07A1.8	F57B10.10
+K08A8.1	F57B10.10
+K08E3.7	F57B10.10
+K08H2.1	F57B10.10
+M7.1	F57B10.10
+R12H7.3	F57B10.10
+R12H7.5	F57B10.10
+R151.6	F57B10.10
+R74.3	F57B10.10
+T04G9.3	F57B10.10
+T04G9.5	F57B10.10
+T05C3.5	F57B10.10
+T05E11.3	F57B10.10
+T05H10.5	F57B10.10
+T09B4.10	F57B10.10
+T14G8.3	F57B10.10
+T15H9.7	F57B10.10
+T24H7.2	F57B10.10
+Y105C5B.13	F57B10.10
+Y105E8A.2	F57B10.10
+Y110A2AM.3	F57B10.10
+Y110A2AR.2	F57B10.10
+Y113G7A.3	F57B10.10
+Y37E3.10	F57B10.10
+Y37H2C.2	F57B10.10
+Y38A10A.5	F57B10.10
+Y38F2AR.2	F57B10.10
+Y38F2AR.9	F57B10.10
+Y47D7A.1	F57B10.10
+Y47D7A.8	F57B10.10
+Y47H9C.5	F57B10.10
+Y49E10.4	F57B10.10
+Y54G2A.18	F57B10.10
+Y56A3A.2	F57B10.10
+Y56A3A.21	F57B10.10
+Y57G11C.15	F57B10.10
+Y60A3A.18	F57B10.10
+Y63D3A.6	F57B10.10
+Y71F9AM.6	F57B10.10
+Y77E11A.13	F57B10.10
+Y87G2A.9	F57B10.10
+Y94H6A.9	F57B10.10
+ZC506.1	F57B10.10
+ZC518.2	F57B10.10
+ZK1307.8	F57B10.10
+ZK180.4	F57B10.10
+ZK20.3	F57B10.10
+ZK287.5	F57B10.10
+ZK632.6	F57B10.10
+F58A4.10	F57B10.11
+F59A6.1	F57B10.11
+F59E12.5	F57B10.11
+H06H21.6	F57B10.11
+H06O01.1	F57B10.11
+H14N18.1	F57B10.11
+K02B12.3	F57B10.11
+K02G10.8	F57B10.11
+K04G2.3	F57B10.11
+K07A1.8	F57B10.11
+K08A8.1	F57B10.11
+K08E3.7	F57B10.11
+K08H2.1	F57B10.11
+M7.1	F57B10.11
+R12H7.3	F57B10.11
+R12H7.5	F57B10.11
+R151.6	F57B10.11
+R74.3	F57B10.11
+T03G11.4	F57B10.11
+T04G9.3	F57B10.11
+T04G9.5	F57B10.11
+T05C3.5	F57B10.11
+T05E11.3	F57B10.11
+T05H10.5	F57B10.11
+T09A5.11	F57B10.11
+T09B4.10	F57B10.11
+T12A2.2	F57B10.11
+T14G8.3	F57B10.11
+T15H9.7	F57B10.11
+T22D1.4	F57B10.11
+T24H7.2	F57B10.11
+Y105C5B.13	F57B10.11
+Y105E8A.2	F57B10.11
+Y110A2AM.3	F57B10.11
+Y110A2AR.2	F57B10.11
+Y113G7A.3	F57B10.11
+Y37E3.10	F57B10.11
+Y37H2C.2	F57B10.11
+Y38A10A.5	F57B10.11
+Y38F2AR.2	F57B10.11
+Y38F2AR.9	F57B10.11
+Y47D7A.1	F57B10.11
+Y47D7A.8	F57B10.11
+Y47H9C.5	F57B10.11
+Y49E10.4	F57B10.11
+Y54G2A.18	F57B10.11
+Y56A3A.2	F57B10.11
+Y56A3A.21	F57B10.11
+Y57G11C.15	F57B10.11
+Y60A3A.18	F57B10.11
+Y63D3A.6	F57B10.11
+Y71F9AM.6	F57B10.11
+Y77E11A.13	F57B10.11
+Y87G2A.9	F57B10.11
+Y94H6A.9	F57B10.11
+ZC410.3	F57B10.11
+ZC506.1	F57B10.11
+ZC518.2	F57B10.11
+ZK1307.8	F57B10.11
+ZK180.4	F57B10.11
+ZK20.3	F57B10.11
+ZK287.5	F57B10.11
+ZK632.6	F57B10.11
+ZK686.3	F57B10.11
+F59A6.1	F58A4.10
+F59E12.5	F58A4.10
+H06H21.6	F58A4.10
+H06O01.1	F58A4.10
+H14N18.1	F58A4.10
+K02B12.3	F58A4.10
+K02G10.8	F58A4.10
+K04G2.3	F58A4.10
+K07A1.8	F58A4.10
+K08A8.1	F58A4.10
+R151.6	F58A4.10
+R74.3	F58A4.10
+T03G11.4	F58A4.10
+T04G9.3	F58A4.10
+T04G9.5	F58A4.10
+T05C3.5	F58A4.10
+T05E11.3	F58A4.10
+T09A5.11	F58A4.10
+T12A2.2	F58A4.10
+T14G8.3	F58A4.10
+T15H9.7	F58A4.10
+T22D1.4	F58A4.10
+T24H7.2	F58A4.10
+Y105E8A.2	F58A4.10
+Y113G7A.3	F58A4.10
+Y37E3.10	F58A4.10
+Y38A10A.5	F58A4.10
+Y38F2AR.2	F58A4.10
+Y38F2AR.9	F58A4.10
+Y47H9C.5	F58A4.10
+Y49E10.4	F58A4.10
+Y54G2A.18	F58A4.10
+Y56A3A.2	F58A4.10
+Y56A3A.21	F58A4.10
+Y57G11C.15	F58A4.10
+Y63D3A.6	F58A4.10
+Y71F9AM.6	F58A4.10
+Y77E11A.13	F58A4.10
+Y94H6A.9	F58A4.10
+ZC410.3	F58A4.10
+ZC506.1	F58A4.10
+ZC518.2	F58A4.10
+ZK1307.8	F58A4.10
+ZK180.4	F58A4.10
+ZK20.3	F58A4.10
+ZK632.6	F58A4.10
+ZK686.3	F58A4.10
+F59E12.5	F59A6.1
+H06H21.6	F59A6.1
+H06O01.1	F59A6.1
+H14N18.1	F59A6.1
+K02B12.3	F59A6.1
+K02G10.8	F59A6.1
+K04G2.3	F59A6.1
+K07A1.8	F59A6.1
+K08E3.7	F59A6.1
+K08H2.1	F59A6.1
+M7.1	F59A6.1
+R12H7.3	F59A6.1
+R12H7.5	F59A6.1
+R151.6	F59A6.1
+R74.3	F59A6.1
+T03G11.4	F59A6.1
+T04G9.3	F59A6.1
+T04G9.5	F59A6.1
+T05C3.5	F59A6.1
+T05E11.3	F59A6.1
+T05H10.5	F59A6.1
+T09A5.11	F59A6.1
+T09B4.10	F59A6.1
+T12A2.2	F59A6.1
+T14G8.3	F59A6.1
+T15H9.7	F59A6.1
+T22D1.4	F59A6.1
+T24H7.2	F59A6.1
+Y105C5B.13	F59A6.1
+Y105E8A.2	F59A6.1
+Y110A2AM.3	F59A6.1
+Y110A2AR.2	F59A6.1
+Y113G7A.3	F59A6.1
+Y37E3.10	F59A6.1
+Y37H2C.2	F59A6.1
+Y38A10A.5	F59A6.1
+Y38F2AR.2	F59A6.1
+Y38F2AR.9	F59A6.1
+Y47D7A.1	F59A6.1
+Y47D7A.8	F59A6.1
+Y47H9C.5	F59A6.1
+Y49E10.4	F59A6.1
+Y54G2A.18	F59A6.1
+Y56A3A.2	F59A6.1
+Y56A3A.21	F59A6.1
+Y57G11C.15	F59A6.1
+Y60A3A.18	F59A6.1
+Y63D3A.6	F59A6.1
+Y71F9AM.6	F59A6.1
+Y77E11A.13	F59A6.1
+Y87G2A.9	F59A6.1
+Y94H6A.9	F59A6.1
+ZC410.3	F59A6.1
+ZC506.1	F59A6.1
+ZC518.2	F59A6.1
+ZK1307.8	F59A6.1
+ZK180.4	F59A6.1
+ZK20.3	F59A6.1
+ZK287.5	F59A6.1
+ZK632.6	F59A6.1
+ZK686.3	F59A6.1
+H06H21.6	F59E12.5
+H06O01.1	F59E12.5
+H14N18.1	F59E12.5
+K02B12.3	F59E12.5
+K02G10.8	F59E12.5
+K04G2.3	F59E12.5
+K07A1.8	F59E12.5
+K08A8.1	F59E12.5
+K08E3.7	F59E12.5
+K08H2.1	F59E12.5
+M7.1	F59E12.5
+R12H7.3	F59E12.5
+R12H7.5	F59E12.5
+R151.6	F59E12.5
+R74.3	F59E12.5
+T03G11.4	F59E12.5
+T04G9.3	F59E12.5
+T04G9.5	F59E12.5
+T05C3.5	F59E12.5
+T05E11.3	F59E12.5
+T05H10.5	F59E12.5
+T09A5.11	F59E12.5
+T09B4.10	F59E12.5
+T12A2.2	F59E12.5
+T14G8.3	F59E12.5
+T15H9.7	F59E12.5
+T22D1.4	F59E12.5
+T24H7.2	F59E12.5
+Y105C5B.13	F59E12.5
+Y105E8A.2	F59E12.5
+Y110A2AM.3	F59E12.5
+Y110A2AR.2	F59E12.5
+Y113G7A.3	F59E12.5
+Y37E3.10	F59E12.5
+Y37H2C.2	F59E12.5
+Y38A10A.5	F59E12.5
+Y38F2AR.2	F59E12.5
+Y38F2AR.9	F59E12.5
+Y47D7A.1	F59E12.5
+Y47D7A.8	F59E12.5
+Y47H9C.5	F59E12.5
+Y49E10.4	F59E12.5
+Y54G2A.18	F59E12.5
+Y56A3A.2	F59E12.5
+Y56A3A.21	F59E12.5
+Y57G11C.15	F59E12.5
+Y60A3A.18	F59E12.5
+Y63D3A.6	F59E12.5
+Y71F9AM.6	F59E12.5
+Y77E11A.13	F59E12.5
+Y87G2A.9	F59E12.5
+Y94H6A.9	F59E12.5
+ZC410.3	F59E12.5
+ZC506.1	F59E12.5
+ZC518.2	F59E12.5
+ZK1307.8	F59E12.5
+ZK180.4	F59E12.5
+ZK20.3	F59E12.5
+ZK287.5	F59E12.5
+ZK632.6	F59E12.5
+ZK686.3	F59E12.5
+H06O01.1	H06H21.6
+H14N18.1	H06H21.6
+K02B12.3	H06H21.6
+K02G10.8	H06H21.6
+K04G2.3	H06H21.6
+K07A1.8	H06H21.6
+K08A8.1	H06H21.6
+K08E3.7	H06H21.6
+K08H2.1	H06H21.6
+M7.1	H06H21.6
+R12H7.3	H06H21.6
+R12H7.5	H06H21.6
+R151.6	H06H21.6
+R74.3	H06H21.6
+T03G11.4	H06H21.6
+T04G9.3	H06H21.6
+T04G9.5	H06H21.6
+T05C3.5	H06H21.6
+T05E11.3	H06H21.6
+T05H10.5	H06H21.6
+T09A5.11	H06H21.6
+T09B4.10	H06H21.6
+T12A2.2	H06H21.6
+T14G8.3	H06H21.6
+T15H9.7	H06H21.6
+T22D1.4	H06H21.6
+T24H7.2	H06H21.6
+Y105C5B.13	H06H21.6
+Y105E8A.2	H06H21.6
+Y110A2AM.3	H06H21.6
+Y110A2AR.2	H06H21.6
+Y113G7A.3	H06H21.6
+Y37E3.10	H06H21.6
+Y37H2C.2	H06H21.6
+Y38A10A.5	H06H21.6
+Y38F2AR.2	H06H21.6
+Y38F2AR.9	H06H21.6
+Y47D7A.1	H06H21.6
+Y47D7A.8	H06H21.6
+Y47H9C.5	H06H21.6
+Y49E10.4	H06H21.6
+Y54G2A.18	H06H21.6
+Y56A3A.2	H06H21.6
+Y56A3A.21	H06H21.6
+Y57G11C.15	H06H21.6
+Y60A3A.18	H06H21.6
+Y63D3A.6	H06H21.6
+Y71F9AM.6	H06H21.6
+Y77E11A.13	H06H21.6
+Y87G2A.9	H06H21.6
+Y94H6A.9	H06H21.6
+ZC410.3	H06H21.6
+ZC506.1	H06H21.6
+ZC518.2	H06H21.6
+ZK1307.8	H06H21.6
+ZK180.4	H06H21.6
+ZK20.3	H06H21.6
+ZK287.5	H06H21.6
+ZK632.6	H06H21.6
+ZK686.3	H06H21.6
+H14N18.1	H06O01.1
+K02B12.3	H06O01.1
+K02G10.8	H06O01.1
+K04G2.3	H06O01.1
+K07A1.8	H06O01.1
+K08A8.1	H06O01.1
+K08E3.7	H06O01.1
+K08H2.1	H06O01.1
+M7.1	H06O01.1
+R12H7.3	H06O01.1
+R12H7.5	H06O01.1
+R151.6	H06O01.1
+R74.3	H06O01.1
+T03G11.4	H06O01.1
+T04G9.3	H06O01.1
+T04G9.5	H06O01.1
+T05C3.5	H06O01.1
+T05E11.3	H06O01.1
+T05H10.5	H06O01.1
+T09A5.11	H06O01.1
+T09B4.10	H06O01.1
+T12A2.2	H06O01.1
+T14G8.3	H06O01.1
+T15H9.7	H06O01.1
+T22D1.4	H06O01.1
+T24H7.2	H06O01.1
+Y105C5B.13	H06O01.1
+Y105E8A.2	H06O01.1
+Y110A2AM.3	H06O01.1
+Y110A2AR.2	H06O01.1
+Y113G7A.3	H06O01.1
+Y37E3.10	H06O01.1
+Y37H2C.2	H06O01.1
+Y38A10A.5	H06O01.1
+Y38F2AR.2	H06O01.1
+Y38F2AR.9	H06O01.1
+Y47D7A.1	H06O01.1
+Y47D7A.8	H06O01.1
+Y47H9C.5	H06O01.1
+Y49E10.4	H06O01.1
+Y54G2A.18	H06O01.1
+Y56A3A.2	H06O01.1
+Y56A3A.21	H06O01.1
+Y57G11C.15	H06O01.1
+Y60A3A.18	H06O01.1
+Y63D3A.6	H06O01.1
+Y71F9AM.6	H06O01.1
+Y77E11A.13	H06O01.1
+Y87G2A.9	H06O01.1
+Y94H6A.9	H06O01.1
+ZC410.3	H06O01.1
+ZC506.1	H06O01.1
+ZC518.2	H06O01.1
+ZK1307.8	H06O01.1
+ZK180.4	H06O01.1
+ZK20.3	H06O01.1
+ZK287.5	H06O01.1
+ZK632.6	H06O01.1
+ZK686.3	H06O01.1
+K02B12.3	H14N18.1
+K02G10.8	H14N18.1
+K04G2.3	H14N18.1
+K07A1.8	H14N18.1
+K08A8.1	H14N18.1
+K08E3.7	H14N18.1
+K08H2.1	H14N18.1
+M7.1	H14N18.1
+R12H7.3	H14N18.1
+R12H7.5	H14N18.1
+R151.6	H14N18.1
+R74.3	H14N18.1
+T03G11.4	H14N18.1
+T04G9.3	H14N18.1
+T04G9.5	H14N18.1
+T05C3.5	H14N18.1
+T05E11.3	H14N18.1
+T05H10.5	H14N18.1
+T09A5.11	H14N18.1
+T09B4.10	H14N18.1
+T12A2.2	H14N18.1
+T14G8.3	H14N18.1
+T15H9.7	H14N18.1
+T22D1.4	H14N18.1
+T24H7.2	H14N18.1
+Y105C5B.13	H14N18.1
+Y105E8A.2	H14N18.1
+Y110A2AM.3	H14N18.1
+Y110A2AR.2	H14N18.1
+Y113G7A.3	H14N18.1
+Y37E3.10	H14N18.1
+Y37H2C.2	H14N18.1
+Y38A10A.5	H14N18.1
+Y38F2AR.2	H14N18.1
+Y38F2AR.9	H14N18.1
+Y47D7A.1	H14N18.1
+Y47D7A.8	H14N18.1
+Y47H9C.5	H14N18.1
+Y49E10.4	H14N18.1
+Y54G2A.18	H14N18.1
+Y56A3A.2	H14N18.1
+Y56A3A.21	H14N18.1
+Y57G11C.15	H14N18.1
+Y60A3A.18	H14N18.1
+Y63D3A.6	H14N18.1
+Y71F9AM.6	H14N18.1
+Y77E11A.13	H14N18.1
+Y87G2A.9	H14N18.1
+Y94H6A.9	H14N18.1
+ZC410.3	H14N18.1
+ZC506.1	H14N18.1
+ZC518.2	H14N18.1
+ZK1307.8	H14N18.1
+ZK180.4	H14N18.1
+ZK20.3	H14N18.1
+ZK287.5	H14N18.1
+ZK632.6	H14N18.1
+ZK686.3	H14N18.1
+K02G10.8	K02B12.3
+K04G2.3	K02B12.3
+K07A1.8	K02B12.3
+K08A8.1	K02B12.3
+K08E3.7	K02B12.3
+K08H2.1	K02B12.3
+M7.1	K02B12.3
+R12H7.3	K02B12.3
+R12H7.5	K02B12.3
+R151.6	K02B12.3
+R74.3	K02B12.3
+T03G11.4	K02B12.3
+T04G9.3	K02B12.3
+T04G9.5	K02B12.3
+T05C3.5	K02B12.3
+T05E11.3	K02B12.3
+T05H10.5	K02B12.3
+T09A5.11	K02B12.3
+T09B4.10	K02B12.3
+T12A2.2	K02B12.3
+T14G8.3	K02B12.3
+T15H9.7	K02B12.3
+T22D1.4	K02B12.3
+T24H7.2	K02B12.3
+Y105C5B.13	K02B12.3
+Y105E8A.2	K02B12.3
+Y110A2AM.3	K02B12.3
+Y110A2AR.2	K02B12.3
+Y113G7A.3	K02B12.3
+Y37E3.10	K02B12.3
+Y37H2C.2	K02B12.3
+Y38A10A.5	K02B12.3
+Y38F2AR.2	K02B12.3
+Y38F2AR.9	K02B12.3
+Y47D7A.1	K02B12.3
+Y47D7A.8	K02B12.3
+Y47H9C.5	K02B12.3
+Y49E10.4	K02B12.3
+Y54G2A.18	K02B12.3
+Y56A3A.2	K02B12.3
+Y56A3A.21	K02B12.3
+Y57G11C.15	K02B12.3
+Y60A3A.18	K02B12.3
+Y63D3A.6	K02B12.3
+Y71F9AM.6	K02B12.3
+Y77E11A.13	K02B12.3
+Y87G2A.9	K02B12.3
+Y94H6A.9	K02B12.3
+ZC410.3	K02B12.3
+ZC506.1	K02B12.3
+ZC518.2	K02B12.3
+ZK1307.8	K02B12.3
+ZK180.4	K02B12.3
+ZK20.3	K02B12.3
+ZK287.5	K02B12.3
+ZK632.6	K02B12.3
+ZK686.3	K02B12.3
+K04G2.3	K02G10.8
+K07A1.8	K02G10.8
+K08A8.1	K02G10.8
+K08E3.7	K02G10.8
+K08H2.1	K02G10.8
+M7.1	K02G10.8
+R12H7.3	K02G10.8
+R12H7.5	K02G10.8
+R151.6	K02G10.8
+R74.3	K02G10.8
+T03G11.4	K02G10.8
+T04G9.3	K02G10.8
+T04G9.5	K02G10.8
+T05C3.5	K02G10.8
+T05E11.3	K02G10.8
+T05H10.5	K02G10.8
+T09A5.11	K02G10.8
+T09B4.10	K02G10.8
+T12A2.2	K02G10.8
+T14G8.3	K02G10.8
+T15H9.7	K02G10.8
+T22D1.4	K02G10.8
+T24H7.2	K02G10.8
+Y105C5B.13	K02G10.8
+Y105E8A.2	K02G10.8
+Y110A2AM.3	K02G10.8
+Y110A2AR.2	K02G10.8
+Y113G7A.3	K02G10.8
+Y37E3.10	K02G10.8
+Y37H2C.2	K02G10.8
+Y38A10A.5	K02G10.8
+Y38F2AR.2	K02G10.8
+Y38F2AR.9	K02G10.8
+Y47D7A.1	K02G10.8
+Y47D7A.8	K02G10.8
+Y47H9C.5	K02G10.8
+Y49E10.4	K02G10.8
+Y54G2A.18	K02G10.8
+Y56A3A.2	K02G10.8
+Y56A3A.21	K02G10.8
+Y57G11C.15	K02G10.8
+Y60A3A.18	K02G10.8
+Y63D3A.6	K02G10.8
+Y71F9AM.6	K02G10.8
+Y77E11A.13	K02G10.8
+Y87G2A.9	K02G10.8
+Y94H6A.9	K02G10.8
+ZC410.3	K02G10.8
+ZC506.1	K02G10.8
+ZC518.2	K02G10.8
+ZK1307.8	K02G10.8
+ZK180.4	K02G10.8
+ZK20.3	K02G10.8
+ZK287.5	K02G10.8
+ZK632.6	K02G10.8
+ZK686.3	K02G10.8
+K07A1.8	K04G2.3
+K08A8.1	K04G2.3
+K08E3.7	K04G2.3
+K08H2.1	K04G2.3
+M7.1	K04G2.3
+R12H7.3	K04G2.3
+R12H7.5	K04G2.3
+R151.6	K04G2.3
+R74.3	K04G2.3
+T03G11.4	K04G2.3
+T04G9.3	K04G2.3
+T04G9.5	K04G2.3
+T05C3.5	K04G2.3
+T05E11.3	K04G2.3
+T05H10.5	K04G2.3
+T09A5.11	K04G2.3
+T09B4.10	K04G2.3
+T12A2.2	K04G2.3
+T14G8.3	K04G2.3
+T15H9.7	K04G2.3
+T22D1.4	K04G2.3
+T24H7.2	K04G2.3
+Y105C5B.13	K04G2.3
+Y105E8A.2	K04G2.3
+Y110A2AM.3	K04G2.3
+Y110A2AR.2	K04G2.3
+Y113G7A.3	K04G2.3
+Y37E3.10	K04G2.3
+Y37H2C.2	K04G2.3
+Y38A10A.5	K04G2.3
+Y38F2AR.2	K04G2.3
+Y38F2AR.9	K04G2.3
+Y47D7A.1	K04G2.3
+Y47D7A.8	K04G2.3
+Y47H9C.5	K04G2.3
+Y49E10.4	K04G2.3
+Y54G2A.18	K04G2.3
+Y56A3A.2	K04G2.3
+Y56A3A.21	K04G2.3
+Y57G11C.15	K04G2.3
+Y60A3A.18	K04G2.3
+Y63D3A.6	K04G2.3
+Y71F9AM.6	K04G2.3
+Y77E11A.13	K04G2.3
+Y87G2A.9	K04G2.3
+Y94H6A.9	K04G2.3
+ZC410.3	K04G2.3
+ZC506.1	K04G2.3
+ZC518.2	K04G2.3
+ZK1307.8	K04G2.3
+ZK180.4	K04G2.3
+ZK20.3	K04G2.3
+ZK287.5	K04G2.3
+ZK632.6	K04G2.3
+ZK686.3	K04G2.3
+K08A8.1	K07A1.8
+K08E3.7	K07A1.8
+K08H2.1	K07A1.8
+M7.1	K07A1.8
+R12H7.3	K07A1.8
+R12H7.5	K07A1.8
+R151.6	K07A1.8
+R74.3	K07A1.8
+T03G11.4	K07A1.8
+T04G9.3	K07A1.8
+T04G9.5	K07A1.8
+T05C3.5	K07A1.8
+T05E11.3	K07A1.8
+T05H10.5	K07A1.8
+T09A5.11	K07A1.8
+T09B4.10	K07A1.8
+T12A2.2	K07A1.8
+T14G8.3	K07A1.8
+T15H9.7	K07A1.8
+T22D1.4	K07A1.8
+T24H7.2	K07A1.8
+Y105C5B.13	K07A1.8
+Y105E8A.2	K07A1.8
+Y110A2AM.3	K07A1.8
+Y110A2AR.2	K07A1.8
+Y113G7A.3	K07A1.8
+Y37E3.10	K07A1.8
+Y37H2C.2	K07A1.8
+Y38A10A.5	K07A1.8
+Y38F2AR.2	K07A1.8
+Y38F2AR.9	K07A1.8
+Y47D7A.1	K07A1.8
+Y47D7A.8	K07A1.8
+Y47H9C.5	K07A1.8
+Y49E10.4	K07A1.8
+Y54G2A.18	K07A1.8
+Y56A3A.2	K07A1.8
+Y56A3A.21	K07A1.8
+Y57G11C.15	K07A1.8
+Y60A3A.18	K07A1.8
+Y63D3A.6	K07A1.8
+Y71F9AM.6	K07A1.8
+Y77E11A.13	K07A1.8
+Y87G2A.9	K07A1.8
+Y94H6A.9	K07A1.8
+ZC410.3	K07A1.8
+ZC506.1	K07A1.8
+ZC518.2	K07A1.8
+ZK1307.8	K07A1.8
+ZK180.4	K07A1.8
+ZK20.3	K07A1.8
+ZK287.5	K07A1.8
+ZK632.6	K07A1.8
+ZK686.3	K07A1.8
+K08E3.7	K08A8.1
+K08H2.1	K08A8.1
+M7.1	K08A8.1
+R12H7.3	K08A8.1
+R12H7.5	K08A8.1
+R151.6	K08A8.1
+R74.3	K08A8.1
+T03G11.4	K08A8.1
+T04G9.3	K08A8.1
+T04G9.5	K08A8.1
+T05C3.5	K08A8.1
+T05E11.3	K08A8.1
+T05H10.5	K08A8.1
+T09A5.11	K08A8.1
+T09B4.10	K08A8.1
+T12A2.2	K08A8.1
+T14G8.3	K08A8.1
+T15H9.7	K08A8.1
+T22D1.4	K08A8.1
+T24H7.2	K08A8.1
+Y105C5B.13	K08A8.1
+Y105E8A.2	K08A8.1
+Y110A2AM.3	K08A8.1
+Y110A2AR.2	K08A8.1
+Y113G7A.3	K08A8.1
+Y37E3.10	K08A8.1
+Y37H2C.2	K08A8.1
+Y38A10A.5	K08A8.1
+Y38F2AR.2	K08A8.1
+Y38F2AR.9	K08A8.1
+Y47D7A.1	K08A8.1
+Y47D7A.8	K08A8.1
+Y47H9C.5	K08A8.1
+Y49E10.4	K08A8.1
+Y54G2A.18	K08A8.1
+Y56A3A.2	K08A8.1
+Y56A3A.21	K08A8.1
+Y57G11C.15	K08A8.1
+Y60A3A.18	K08A8.1
+Y63D3A.6	K08A8.1
+Y71F9AM.6	K08A8.1
+Y77E11A.13	K08A8.1
+Y87G2A.9	K08A8.1
+Y94H6A.9	K08A8.1
+ZC410.3	K08A8.1
+ZC506.1	K08A8.1
+ZC518.2	K08A8.1
+ZK1307.8	K08A8.1
+ZK180.4	K08A8.1
+ZK20.3	K08A8.1
+ZK287.5	K08A8.1
+ZK632.6	K08A8.1
+ZK686.3	K08A8.1
+R151.6	K08E3.7
+R74.3	K08E3.7
+T03G11.4	K08E3.7
+T04G9.3	K08E3.7
+T04G9.5	K08E3.7
+T05C3.5	K08E3.7
+T05E11.3	K08E3.7
+T09A5.11	K08E3.7
+T12A2.2	K08E3.7
+T14G8.3	K08E3.7
+T15H9.7	K08E3.7
+T22D1.4	K08E3.7
+T24H7.2	K08E3.7
+Y105E8A.2	K08E3.7
+Y113G7A.3	K08E3.7
+Y37E3.10	K08E3.7
+Y38A10A.5	K08E3.7
+Y38F2AR.2	K08E3.7
+Y38F2AR.9	K08E3.7
+Y47H9C.5	K08E3.7
+Y49E10.4	K08E3.7
+Y54G2A.18	K08E3.7
+Y56A3A.2	K08E3.7
+Y56A3A.21	K08E3.7
+Y57G11C.15	K08E3.7
+Y63D3A.6	K08E3.7
+Y71F9AM.6	K08E3.7
+Y77E11A.13	K08E3.7
+Y94H6A.9	K08E3.7
+ZC410.3	K08E3.7
+ZC506.1	K08E3.7
+ZC518.2	K08E3.7
+ZK1307.8	K08E3.7
+ZK180.4	K08E3.7
+ZK20.3	K08E3.7
+ZK632.6	K08E3.7
+ZK686.3	K08E3.7
+R151.6	K08H2.1
+R74.3	K08H2.1
+T03G11.4	K08H2.1
+T04G9.3	K08H2.1
+T04G9.5	K08H2.1
+T05C3.5	K08H2.1
+T05E11.3	K08H2.1
+T09A5.11	K08H2.1
+T12A2.2	K08H2.1
+T14G8.3	K08H2.1
+T15H9.7	K08H2.1
+T22D1.4	K08H2.1
+T24H7.2	K08H2.1
+Y105E8A.2	K08H2.1
+Y113G7A.3	K08H2.1
+Y37E3.10	K08H2.1
+Y38A10A.5	K08H2.1
+Y38F2AR.2	K08H2.1
+Y38F2AR.9	K08H2.1
+Y47H9C.5	K08H2.1
+Y49E10.4	K08H2.1
+Y54G2A.18	K08H2.1
+Y56A3A.2	K08H2.1
+Y56A3A.21	K08H2.1
+Y57G11C.15	K08H2.1
+Y63D3A.6	K08H2.1
+Y71F9AM.6	K08H2.1
+Y77E11A.13	K08H2.1
+Y94H6A.9	K08H2.1
+ZC410.3	K08H2.1
+ZC506.1	K08H2.1
+ZC518.2	K08H2.1
+ZK1307.8	K08H2.1
+ZK180.4	K08H2.1
+ZK20.3	K08H2.1
+ZK632.6	K08H2.1
+ZK686.3	K08H2.1
+R151.6	M7.1
+R74.3	M7.1
+T03G11.4	M7.1
+T04G9.3	M7.1
+T04G9.5	M7.1
+T05C3.5	M7.1
+T05E11.3	M7.1
+T09A5.11	M7.1
+T12A2.2	M7.1
+T14G8.3	M7.1
+T15H9.7	M7.1
+T22D1.4	M7.1
+T24H7.2	M7.1
+Y105E8A.2	M7.1
+Y113G7A.3	M7.1
+Y37E3.10	M7.1
+Y38A10A.5	M7.1
+Y38F2AR.2	M7.1
+Y38F2AR.9	M7.1
+Y47H9C.5	M7.1
+Y49E10.4	M7.1
+Y54G2A.18	M7.1
+Y56A3A.2	M7.1
+Y56A3A.21	M7.1
+Y57G11C.15	M7.1
+Y63D3A.6	M7.1
+Y71F9AM.6	M7.1
+Y77E11A.13	M7.1
+Y94H6A.9	M7.1
+ZC410.3	M7.1
+ZC506.1	M7.1
+ZC518.2	M7.1
+ZK1307.8	M7.1
+ZK180.4	M7.1
+ZK20.3	M7.1
+ZK632.6	M7.1
+ZK686.3	M7.1
+R151.6	R12H7.3
+R74.3	R12H7.3
+T03G11.4	R12H7.3
+T04G9.3	R12H7.3
+T04G9.5	R12H7.3
+T05C3.5	R12H7.3
+T05E11.3	R12H7.3
+T09A5.11	R12H7.3
+T12A2.2	R12H7.3
+T14G8.3	R12H7.3
+T15H9.7	R12H7.3
+T22D1.4	R12H7.3
+T24H7.2	R12H7.3
+Y105E8A.2	R12H7.3
+Y113G7A.3	R12H7.3
+Y37E3.10	R12H7.3
+Y38A10A.5	R12H7.3
+Y38F2AR.2	R12H7.3
+Y38F2AR.9	R12H7.3
+Y47H9C.5	R12H7.3
+Y49E10.4	R12H7.3
+Y54G2A.18	R12H7.3
+Y56A3A.2	R12H7.3
+Y56A3A.21	R12H7.3
+Y57G11C.15	R12H7.3
+Y63D3A.6	R12H7.3
+Y71F9AM.6	R12H7.3
+Y77E11A.13	R12H7.3
+Y94H6A.9	R12H7.3
+ZC410.3	R12H7.3
+ZC506.1	R12H7.3
+ZC518.2	R12H7.3
+ZK1307.8	R12H7.3
+ZK180.4	R12H7.3
+ZK20.3	R12H7.3
+ZK632.6	R12H7.3
+ZK686.3	R12H7.3
+R151.6	R12H7.5
+R74.3	R12H7.5
+T03G11.4	R12H7.5
+T04G9.3	R12H7.5
+T04G9.5	R12H7.5
+T05C3.5	R12H7.5
+T05E11.3	R12H7.5
+T09A5.11	R12H7.5
+T12A2.2	R12H7.5
+T14G8.3	R12H7.5
+T15H9.7	R12H7.5
+T22D1.4	R12H7.5
+T24H7.2	R12H7.5
+Y105E8A.2	R12H7.5
+Y113G7A.3	R12H7.5
+Y37E3.10	R12H7.5
+Y38A10A.5	R12H7.5
+Y38F2AR.2	R12H7.5
+Y38F2AR.9	R12H7.5
+Y47H9C.5	R12H7.5
+Y49E10.4	R12H7.5
+Y54G2A.18	R12H7.5
+Y56A3A.2	R12H7.5
+Y56A3A.21	R12H7.5
+Y57G11C.15	R12H7.5
+Y63D3A.6	R12H7.5
+Y71F9AM.6	R12H7.5
+Y77E11A.13	R12H7.5
+Y94H6A.9	R12H7.5
+ZC410.3	R12H7.5
+ZC506.1	R12H7.5
+ZC518.2	R12H7.5
+ZK1307.8	R12H7.5
+ZK180.4	R12H7.5
+ZK20.3	R12H7.5
+ZK632.6	R12H7.5
+ZK686.3	R12H7.5
+R74.3	R151.6
+T03G11.4	R151.6
+T04G9.3	R151.6
+T04G9.5	R151.6
+T05C3.5	R151.6
+T05E11.3	R151.6
+T05H10.5	R151.6
+T09A5.11	R151.6
+T09B4.10	R151.6
+T12A2.2	R151.6
+T14G8.3	R151.6
+T15H9.7	R151.6
+T22D1.4	R151.6
+T24H7.2	R151.6
+Y105C5B.13	R151.6
+Y105E8A.2	R151.6
+Y110A2AM.3	R151.6
+Y110A2AR.2	R151.6
+Y113G7A.3	R151.6
+Y37E3.10	R151.6
+Y37H2C.2	R151.6
+Y38A10A.5	R151.6
+Y38F2AR.2	R151.6
+Y38F2AR.9	R151.6
+Y47D7A.1	R151.6
+Y47D7A.8	R151.6
+Y47H9C.5	R151.6
+Y49E10.4	R151.6
+Y54G2A.18	R151.6
+Y56A3A.2	R151.6
+Y56A3A.21	R151.6
+Y57G11C.15	R151.6
+Y60A3A.18	R151.6
+Y63D3A.6	R151.6
+Y71F9AM.6	R151.6
+Y77E11A.13	R151.6
+Y87G2A.9	R151.6
+Y94H6A.9	R151.6
+ZC410.3	R151.6
+ZC506.1	R151.6
+ZC518.2	R151.6
+ZK1307.8	R151.6
+ZK180.4	R151.6
+ZK20.3	R151.6
+ZK287.5	R151.6
+ZK632.6	R151.6
+ZK686.3	R151.6
+T03G11.4	R74.3
+T04G9.3	R74.3
+T04G9.5	R74.3
+T05C3.5	R74.3
+T05E11.3	R74.3
+T05H10.5	R74.3
+T09A5.11	R74.3
+T09B4.10	R74.3
+T12A2.2	R74.3
+T14G8.3	R74.3
+T15H9.7	R74.3
+T22D1.4	R74.3
+T24H7.2	R74.3
+Y105C5B.13	R74.3
+Y105E8A.2	R74.3
+Y110A2AM.3	R74.3
+Y110A2AR.2	R74.3
+Y113G7A.3	R74.3
+Y37E3.10	R74.3
+Y37H2C.2	R74.3
+Y38A10A.5	R74.3
+Y38F2AR.2	R74.3
+Y38F2AR.9	R74.3
+Y47D7A.1	R74.3
+Y47D7A.8	R74.3
+Y47H9C.5	R74.3
+Y49E10.4	R74.3
+Y54G2A.18	R74.3
+Y56A3A.2	R74.3
+Y56A3A.21	R74.3
+Y57G11C.15	R74.3
+Y60A3A.18	R74.3
+Y63D3A.6	R74.3
+Y71F9AM.6	R74.3
+Y77E11A.13	R74.3
+Y87G2A.9	R74.3
+Y94H6A.9	R74.3
+ZC410.3	R74.3
+ZC506.1	R74.3
+ZC518.2	R74.3
+ZK1307.8	R74.3
+ZK180.4	R74.3
+ZK20.3	R74.3
+ZK287.5	R74.3
+ZK632.6	R74.3
+ZK686.3	R74.3
+T04G9.3	T03G11.4
+T04G9.5	T03G11.4
+T05C3.5	T03G11.4
+T05E11.3	T03G11.4
+T05H10.5	T03G11.4
+T09B4.10	T03G11.4
+T14G8.3	T03G11.4
+T15H9.7	T03G11.4
+T24H7.2	T03G11.4
+Y105C5B.13	T03G11.4
+Y105E8A.2	T03G11.4
+Y110A2AM.3	T03G11.4
+Y110A2AR.2	T03G11.4
+Y113G7A.3	T03G11.4
+Y37E3.10	T03G11.4
+Y37H2C.2	T03G11.4
+Y38A10A.5	T03G11.4
+Y38F2AR.2	T03G11.4
+Y38F2AR.9	T03G11.4
+Y47D7A.1	T03G11.4
+Y47D7A.8	T03G11.4
+Y47H9C.5	T03G11.4
+Y49E10.4	T03G11.4
+Y54G2A.18	T03G11.4
+Y56A3A.2	T03G11.4
+Y56A3A.21	T03G11.4
+Y57G11C.15	T03G11.4
+Y60A3A.18	T03G11.4
+Y63D3A.6	T03G11.4
+Y71F9AM.6	T03G11.4
+Y77E11A.13	T03G11.4
+Y87G2A.9	T03G11.4
+Y94H6A.9	T03G11.4
+ZC506.1	T03G11.4
+ZC518.2	T03G11.4
+ZK1307.8	T03G11.4
+ZK180.4	T03G11.4
+ZK20.3	T03G11.4
+ZK287.5	T03G11.4
+ZK632.6	T03G11.4
+T04G9.5	T04G9.3
+T05C3.5	T04G9.3
+T05E11.3	T04G9.3
+T05H10.5	T04G9.3
+T09A5.11	T04G9.3
+T09B4.10	T04G9.3
+T12A2.2	T04G9.3
+T14G8.3	T04G9.3
+T15H9.7	T04G9.3
+T22D1.4	T04G9.3
+T24H7.2	T04G9.3
+Y105C5B.13	T04G9.3
+Y105E8A.2	T04G9.3
+Y110A2AM.3	T04G9.3
+Y110A2AR.2	T04G9.3
+Y113G7A.3	T04G9.3
+Y37E3.10	T04G9.3
+Y37H2C.2	T04G9.3
+Y38A10A.5	T04G9.3
+Y38F2AR.2	T04G9.3
+Y38F2AR.9	T04G9.3
+Y47D7A.1	T04G9.3
+Y47D7A.8	T04G9.3
+Y47H9C.5	T04G9.3
+Y49E10.4	T04G9.3
+Y54G2A.18	T04G9.3
+Y56A3A.2	T04G9.3
+Y56A3A.21	T04G9.3
+Y57G11C.15	T04G9.3
+Y60A3A.18	T04G9.3
+Y63D3A.6	T04G9.3
+Y71F9AM.6	T04G9.3
+Y77E11A.13	T04G9.3
+Y87G2A.9	T04G9.3
+Y94H6A.9	T04G9.3
+ZC410.3	T04G9.3
+ZC506.1	T04G9.3
+ZC518.2	T04G9.3
+ZK1307.8	T04G9.3
+ZK180.4	T04G9.3
+ZK20.3	T04G9.3
+ZK287.5	T04G9.3
+ZK632.6	T04G9.3
+ZK686.3	T04G9.3
+T05C3.5	T04G9.5
+T05E11.3	T04G9.5
+T05H10.5	T04G9.5
+T09A5.11	T04G9.5
+T09B4.10	T04G9.5
+T12A2.2	T04G9.5
+T14G8.3	T04G9.5
+T15H9.7	T04G9.5
+T22D1.4	T04G9.5
+T24H7.2	T04G9.5
+Y105C5B.13	T04G9.5
+Y105E8A.2	T04G9.5
+Y110A2AM.3	T04G9.5
+Y110A2AR.2	T04G9.5
+Y113G7A.3	T04G9.5
+Y37E3.10	T04G9.5
+Y37H2C.2	T04G9.5
+Y38A10A.5	T04G9.5
+Y38F2AR.2	T04G9.5
+Y38F2AR.9	T04G9.5
+Y47D7A.1	T04G9.5
+Y47D7A.8	T04G9.5
+Y47H9C.5	T04G9.5
+Y49E10.4	T04G9.5
+Y54G2A.18	T04G9.5
+Y56A3A.2	T04G9.5
+Y56A3A.21	T04G9.5
+Y57G11C.15	T04G9.5
+Y60A3A.18	T04G9.5
+Y63D3A.6	T04G9.5
+Y71F9AM.6	T04G9.5
+Y77E11A.13	T04G9.5
+Y87G2A.9	T04G9.5
+Y94H6A.9	T04G9.5
+ZC410.3	T04G9.5
+ZC506.1	T04G9.5
+ZC518.2	T04G9.5
+ZK1307.8	T04G9.5
+ZK180.4	T04G9.5
+ZK20.3	T04G9.5
+ZK287.5	T04G9.5
+ZK632.6	T04G9.5
+ZK686.3	T04G9.5
+T05E11.3	T05C3.5
+T05H10.5	T05C3.5
+T09A5.11	T05C3.5
+T09B4.10	T05C3.5
+T12A2.2	T05C3.5
+T14G8.3	T05C3.5
+T15H9.7	T05C3.5
+T22D1.4	T05C3.5
+T24H7.2	T05C3.5
+Y105C5B.13	T05C3.5
+Y105E8A.2	T05C3.5
+Y110A2AM.3	T05C3.5
+Y110A2AR.2	T05C3.5
+Y113G7A.3	T05C3.5
+Y37E3.10	T05C3.5
+Y37H2C.2	T05C3.5
+Y38A10A.5	T05C3.5
+Y38F2AR.2	T05C3.5
+Y38F2AR.9	T05C3.5
+Y47D7A.1	T05C3.5
+Y47D7A.8	T05C3.5
+Y47H9C.5	T05C3.5
+Y49E10.4	T05C3.5
+Y54G2A.18	T05C3.5
+Y56A3A.2	T05C3.5
+Y56A3A.21	T05C3.5
+Y57G11C.15	T05C3.5
+Y60A3A.18	T05C3.5
+Y63D3A.6	T05C3.5
+Y71F9AM.6	T05C3.5
+Y77E11A.13	T05C3.5
+Y87G2A.9	T05C3.5
+Y94H6A.9	T05C3.5
+ZC410.3	T05C3.5
+ZC506.1	T05C3.5
+ZC518.2	T05C3.5
+ZK1307.8	T05C3.5
+ZK180.4	T05C3.5
+ZK20.3	T05C3.5
+ZK287.5	T05C3.5
+ZK632.6	T05C3.5
+ZK686.3	T05C3.5
+T05H10.5	T05E11.3
+T09A5.11	T05E11.3
+T09B4.10	T05E11.3
+T12A2.2	T05E11.3
+T14G8.3	T05E11.3
+T15H9.7	T05E11.3
+T22D1.4	T05E11.3
+T24H7.2	T05E11.3
+Y105C5B.13	T05E11.3
+Y105E8A.2	T05E11.3
+Y110A2AM.3	T05E11.3
+Y110A2AR.2	T05E11.3
+Y113G7A.3	T05E11.3
+Y37E3.10	T05E11.3
+Y37H2C.2	T05E11.3
+Y38A10A.5	T05E11.3
+Y38F2AR.2	T05E11.3
+Y38F2AR.9	T05E11.3
+Y47D7A.1	T05E11.3
+Y47D7A.8	T05E11.3
+Y47H9C.5	T05E11.3
+Y49E10.4	T05E11.3
+Y54G2A.18	T05E11.3
+Y56A3A.2	T05E11.3
+Y56A3A.21	T05E11.3
+Y57G11C.15	T05E11.3
+Y60A3A.18	T05E11.3
+Y63D3A.6	T05E11.3
+Y71F9AM.6	T05E11.3
+Y77E11A.13	T05E11.3
+Y87G2A.9	T05E11.3
+Y94H6A.9	T05E11.3
+ZC410.3	T05E11.3
+ZC506.1	T05E11.3
+ZC518.2	T05E11.3
+ZK1307.8	T05E11.3
+ZK180.4	T05E11.3
+ZK20.3	T05E11.3
+ZK287.5	T05E11.3
+ZK632.6	T05E11.3
+ZK686.3	T05E11.3
+T09A5.11	T05H10.5
+T12A2.2	T05H10.5
+T14G8.3	T05H10.5
+T15H9.7	T05H10.5
+T22D1.4	T05H10.5
+T24H7.2	T05H10.5
+Y105E8A.2	T05H10.5
+Y113G7A.3	T05H10.5
+Y37E3.10	T05H10.5
+Y38A10A.5	T05H10.5
+Y38F2AR.2	T05H10.5
+Y38F2AR.9	T05H10.5
+Y47H9C.5	T05H10.5
+Y49E10.4	T05H10.5
+Y54G2A.18	T05H10.5
+Y56A3A.2	T05H10.5
+Y56A3A.21	T05H10.5
+Y57G11C.15	T05H10.5
+Y63D3A.6	T05H10.5
+Y71F9AM.6	T05H10.5
+Y77E11A.13	T05H10.5
+Y94H6A.9	T05H10.5
+ZC410.3	T05H10.5
+ZC506.1	T05H10.5
+ZC518.2	T05H10.5
+ZK1307.8	T05H10.5
+ZK180.4	T05H10.5
+ZK20.3	T05H10.5
+ZK632.6	T05H10.5
+ZK686.3	T05H10.5
+T09B4.10	T09A5.11
+T14G8.3	T09A5.11
+T15H9.7	T09A5.11
+T24H7.2	T09A5.11
+Y105C5B.13	T09A5.11
+Y105E8A.2	T09A5.11
+Y110A2AM.3	T09A5.11
+Y110A2AR.2	T09A5.11
+Y113G7A.3	T09A5.11
+Y37E3.10	T09A5.11
+Y37H2C.2	T09A5.11
+Y38A10A.5	T09A5.11
+Y38F2AR.2	T09A5.11
+Y38F2AR.9	T09A5.11
+Y47D7A.1	T09A5.11
+Y47D7A.8	T09A5.11
+Y47H9C.5	T09A5.11
+Y49E10.4	T09A5.11
+Y54G2A.18	T09A5.11
+Y56A3A.2	T09A5.11
+Y56A3A.21	T09A5.11
+Y57G11C.15	T09A5.11
+Y60A3A.18	T09A5.11
+Y63D3A.6	T09A5.11
+Y71F9AM.6	T09A5.11
+Y77E11A.13	T09A5.11
+Y87G2A.9	T09A5.11
+Y94H6A.9	T09A5.11
+ZC506.1	T09A5.11
+ZC518.2	T09A5.11
+ZK1307.8	T09A5.11
+ZK180.4	T09A5.11
+ZK20.3	T09A5.11
+ZK287.5	T09A5.11
+ZK632.6	T09A5.11
+T12A2.2	T09B4.10
+T14G8.3	T09B4.10
+T15H9.7	T09B4.10
+T22D1.4	T09B4.10
+T24H7.2	T09B4.10
+Y105E8A.2	T09B4.10
+Y113G7A.3	T09B4.10
+Y37E3.10	T09B4.10
+Y38A10A.5	T09B4.10
+Y38F2AR.2	T09B4.10
+Y38F2AR.9	T09B4.10
+Y47H9C.5	T09B4.10
+Y49E10.4	T09B4.10
+Y54G2A.18	T09B4.10
+Y56A3A.2	T09B4.10
+Y56A3A.21	T09B4.10
+Y57G11C.15	T09B4.10
+Y63D3A.6	T09B4.10
+Y71F9AM.6	T09B4.10
+Y77E11A.13	T09B4.10
+Y94H6A.9	T09B4.10
+ZC410.3	T09B4.10
+ZC506.1	T09B4.10
+ZC518.2	T09B4.10
+ZK1307.8	T09B4.10
+ZK180.4	T09B4.10
+ZK20.3	T09B4.10
+ZK632.6	T09B4.10
+ZK686.3	T09B4.10
+T14G8.3	T12A2.2
+T15H9.7	T12A2.2
+T24H7.2	T12A2.2
+Y105C5B.13	T12A2.2
+Y105E8A.2	T12A2.2
+Y110A2AM.3	T12A2.2
+Y110A2AR.2	T12A2.2
+Y113G7A.3	T12A2.2
+Y37E3.10	T12A2.2
+Y37H2C.2	T12A2.2
+Y38A10A.5	T12A2.2
+Y38F2AR.2	T12A2.2
+Y38F2AR.9	T12A2.2
+Y47D7A.1	T12A2.2
+Y47D7A.8	T12A2.2
+Y47H9C.5	T12A2.2
+Y49E10.4	T12A2.2
+Y54G2A.18	T12A2.2
+Y56A3A.2	T12A2.2
+Y56A3A.21	T12A2.2
+Y57G11C.15	T12A2.2
+Y60A3A.18	T12A2.2
+Y63D3A.6	T12A2.2
+Y71F9AM.6	T12A2.2
+Y77E11A.13	T12A2.2
+Y87G2A.9	T12A2.2
+Y94H6A.9	T12A2.2
+ZC506.1	T12A2.2
+ZC518.2	T12A2.2
+ZK1307.8	T12A2.2
+ZK180.4	T12A2.2
+ZK20.3	T12A2.2
+ZK287.5	T12A2.2
+ZK632.6	T12A2.2
+T15H9.7	T14G8.3
+T22D1.4	T14G8.3
+T24H7.2	T14G8.3
+Y105C5B.13	T14G8.3
+Y105E8A.2	T14G8.3
+Y110A2AM.3	T14G8.3
+Y110A2AR.2	T14G8.3
+Y113G7A.3	T14G8.3
+Y37E3.10	T14G8.3
+Y37H2C.2	T14G8.3
+Y38A10A.5	T14G8.3
+Y38F2AR.2	T14G8.3
+Y38F2AR.9	T14G8.3
+Y47D7A.1	T14G8.3
+Y47D7A.8	T14G8.3
+Y47H9C.5	T14G8.3
+Y49E10.4	T14G8.3
+Y54G2A.18	T14G8.3
+Y56A3A.2	T14G8.3
+Y56A3A.21	T14G8.3
+Y57G11C.15	T14G8.3
+Y60A3A.18	T14G8.3
+Y63D3A.6	T14G8.3
+Y71F9AM.6	T14G8.3
+Y77E11A.13	T14G8.3
+Y87G2A.9	T14G8.3
+Y94H6A.9	T14G8.3
+ZC410.3	T14G8.3
+ZC506.1	T14G8.3
+ZC518.2	T14G8.3
+ZK1307.8	T14G8.3
+ZK180.4	T14G8.3
+ZK20.3	T14G8.3
+ZK287.5	T14G8.3
+ZK632.6	T14G8.3
+ZK686.3	T14G8.3
+T22D1.4	T15H9.7
+T24H7.2	T15H9.7
+Y105C5B.13	T15H9.7
+Y105E8A.2	T15H9.7
+Y110A2AM.3	T15H9.7
+Y110A2AR.2	T15H9.7
+Y113G7A.3	T15H9.7
+Y37E3.10	T15H9.7
+Y37H2C.2	T15H9.7
+Y38A10A.5	T15H9.7
+Y38F2AR.2	T15H9.7
+Y38F2AR.9	T15H9.7
+Y47D7A.1	T15H9.7
+Y47D7A.8	T15H9.7
+Y47H9C.5	T15H9.7
+Y49E10.4	T15H9.7
+Y54G2A.18	T15H9.7
+Y56A3A.2	T15H9.7
+Y56A3A.21	T15H9.7
+Y57G11C.15	T15H9.7
+Y60A3A.18	T15H9.7
+Y63D3A.6	T15H9.7
+Y71F9AM.6	T15H9.7
+Y77E11A.13	T15H9.7
+Y87G2A.9	T15H9.7
+Y94H6A.9	T15H9.7
+ZC410.3	T15H9.7
+ZC506.1	T15H9.7
+ZC518.2	T15H9.7
+ZK1307.8	T15H9.7
+ZK180.4	T15H9.7
+ZK20.3	T15H9.7
+ZK287.5	T15H9.7
+ZK632.6	T15H9.7
+ZK686.3	T15H9.7
+T24H7.2	T22D1.4
+Y105C5B.13	T22D1.4
+Y105E8A.2	T22D1.4
+Y110A2AM.3	T22D1.4
+Y110A2AR.2	T22D1.4
+Y113G7A.3	T22D1.4
+Y37E3.10	T22D1.4
+Y37H2C.2	T22D1.4
+Y38A10A.5	T22D1.4
+Y38F2AR.2	T22D1.4
+Y38F2AR.9	T22D1.4
+Y47D7A.1	T22D1.4
+Y47D7A.8	T22D1.4
+Y47H9C.5	T22D1.4
+Y49E10.4	T22D1.4
+Y54G2A.18	T22D1.4
+Y56A3A.2	T22D1.4
+Y56A3A.21	T22D1.4
+Y57G11C.15	T22D1.4
+Y60A3A.18	T22D1.4
+Y63D3A.6	T22D1.4
+Y71F9AM.6	T22D1.4
+Y77E11A.13	T22D1.4
+Y87G2A.9	T22D1.4
+Y94H6A.9	T22D1.4
+ZC506.1	T22D1.4
+ZC518.2	T22D1.4
+ZK1307.8	T22D1.4
+ZK180.4	T22D1.4
+ZK20.3	T22D1.4
+ZK287.5	T22D1.4
+ZK632.6	T22D1.4
+Y105C5B.13	T24H7.2
+Y105E8A.2	T24H7.2
+Y110A2AM.3	T24H7.2
+Y110A2AR.2	T24H7.2
+Y113G7A.3	T24H7.2
+Y37E3.10	T24H7.2
+Y37H2C.2	T24H7.2
+Y38A10A.5	T24H7.2
+Y38F2AR.2	T24H7.2
+Y38F2AR.9	T24H7.2
+Y47D7A.1	T24H7.2
+Y47D7A.8	T24H7.2
+Y47H9C.5	T24H7.2
+Y49E10.4	T24H7.2
+Y54G2A.18	T24H7.2
+Y56A3A.2	T24H7.2
+Y56A3A.21	T24H7.2
+Y57G11C.15	T24H7.2
+Y60A3A.18	T24H7.2
+Y63D3A.6	T24H7.2
+Y71F9AM.6	T24H7.2
+Y77E11A.13	T24H7.2
+Y87G2A.9	T24H7.2
+Y94H6A.9	T24H7.2
+ZC410.3	T24H7.2
+ZC506.1	T24H7.2
+ZC518.2	T24H7.2
+ZK1307.8	T24H7.2
+ZK180.4	T24H7.2
+ZK20.3	T24H7.2
+ZK287.5	T24H7.2
+ZK632.6	T24H7.2
+ZK686.3	T24H7.2
+Y105E8A.2	Y105C5B.13
+Y113G7A.3	Y105C5B.13
+Y37E3.10	Y105C5B.13
+Y38A10A.5	Y105C5B.13
+Y38F2AR.2	Y105C5B.13
+Y38F2AR.9	Y105C5B.13
+Y47H9C.5	Y105C5B.13
+Y49E10.4	Y105C5B.13
+Y54G2A.18	Y105C5B.13
+Y56A3A.2	Y105C5B.13
+Y56A3A.21	Y105C5B.13
+Y57G11C.15	Y105C5B.13
+Y63D3A.6	Y105C5B.13
+Y71F9AM.6	Y105C5B.13
+Y77E11A.13	Y105C5B.13
+Y94H6A.9	Y105C5B.13
+ZC410.3	Y105C5B.13
+ZC506.1	Y105C5B.13
+ZC518.2	Y105C5B.13
+ZK1307.8	Y105C5B.13
+ZK180.4	Y105C5B.13
+ZK20.3	Y105C5B.13
+ZK632.6	Y105C5B.13
+ZK686.3	Y105C5B.13
+Y110A2AM.3	Y105E8A.2
+Y110A2AR.2	Y105E8A.2
+Y113G7A.3	Y105E8A.2
+Y37E3.10	Y105E8A.2
+Y37H2C.2	Y105E8A.2
+Y38A10A.5	Y105E8A.2
+Y38F2AR.2	Y105E8A.2
+Y38F2AR.9	Y105E8A.2
+Y47D7A.1	Y105E8A.2
+Y47D7A.8	Y105E8A.2
+Y47H9C.5	Y105E8A.2
+Y49E10.4	Y105E8A.2
+Y54G2A.18	Y105E8A.2
+Y56A3A.2	Y105E8A.2
+Y56A3A.21	Y105E8A.2
+Y57G11C.15	Y105E8A.2
+Y60A3A.18	Y105E8A.2
+Y63D3A.6	Y105E8A.2
+Y71F9AM.6	Y105E8A.2
+Y77E11A.13	Y105E8A.2
+Y87G2A.9	Y105E8A.2
+Y94H6A.9	Y105E8A.2
+ZC410.3	Y105E8A.2
+ZC506.1	Y105E8A.2
+ZC518.2	Y105E8A.2
+ZK1307.8	Y105E8A.2
+ZK180.4	Y105E8A.2
+ZK20.3	Y105E8A.2
+ZK287.5	Y105E8A.2
+ZK632.6	Y105E8A.2
+ZK686.3	Y105E8A.2
+Y113G7A.3	Y110A2AM.3
+Y37E3.10	Y110A2AM.3
+Y38A10A.5	Y110A2AM.3
+Y38F2AR.2	Y110A2AM.3
+Y38F2AR.9	Y110A2AM.3
+Y47H9C.5	Y110A2AM.3
+Y49E10.4	Y110A2AM.3
+Y54G2A.18	Y110A2AM.3
+Y56A3A.2	Y110A2AM.3
+Y56A3A.21	Y110A2AM.3
+Y57G11C.15	Y110A2AM.3
+Y63D3A.6	Y110A2AM.3
+Y71F9AM.6	Y110A2AM.3
+Y77E11A.13	Y110A2AM.3
+Y94H6A.9	Y110A2AM.3
+ZC410.3	Y110A2AM.3
+ZC506.1	Y110A2AM.3
+ZC518.2	Y110A2AM.3
+ZK1307.8	Y110A2AM.3
+ZK180.4	Y110A2AM.3
+ZK20.3	Y110A2AM.3
+ZK632.6	Y110A2AM.3
+ZK686.3	Y110A2AM.3
+Y113G7A.3	Y110A2AR.2
+Y37E3.10	Y110A2AR.2
+Y38A10A.5	Y110A2AR.2
+Y38F2AR.2	Y110A2AR.2
+Y38F2AR.9	Y110A2AR.2
+Y47H9C.5	Y110A2AR.2
+Y49E10.4	Y110A2AR.2
+Y54G2A.18	Y110A2AR.2
+Y56A3A.2	Y110A2AR.2
+Y56A3A.21	Y110A2AR.2
+Y57G11C.15	Y110A2AR.2
+Y63D3A.6	Y110A2AR.2
+Y71F9AM.6	Y110A2AR.2
+Y77E11A.13	Y110A2AR.2
+Y94H6A.9	Y110A2AR.2
+ZC410.3	Y110A2AR.2
+ZC506.1	Y110A2AR.2
+ZC518.2	Y110A2AR.2
+ZK1307.8	Y110A2AR.2
+ZK180.4	Y110A2AR.2
+ZK20.3	Y110A2AR.2
+ZK632.6	Y110A2AR.2
+ZK686.3	Y110A2AR.2
+Y37E3.10	Y113G7A.3
+Y37H2C.2	Y113G7A.3
+Y38A10A.5	Y113G7A.3
+Y38F2AR.2	Y113G7A.3
+Y38F2AR.9	Y113G7A.3
+Y47D7A.1	Y113G7A.3
+Y47D7A.8	Y113G7A.3
+Y47H9C.5	Y113G7A.3
+Y49E10.4	Y113G7A.3
+Y54G2A.18	Y113G7A.3
+Y56A3A.2	Y113G7A.3
+Y56A3A.21	Y113G7A.3
+Y57G11C.15	Y113G7A.3
+Y60A3A.18	Y113G7A.3
+Y63D3A.6	Y113G7A.3
+Y71F9AM.6	Y113G7A.3
+Y77E11A.13	Y113G7A.3
+Y87G2A.9	Y113G7A.3
+Y94H6A.9	Y113G7A.3
+ZC410.3	Y113G7A.3
+ZC506.1	Y113G7A.3
+ZC518.2	Y113G7A.3
+ZK1307.8	Y113G7A.3
+ZK180.4	Y113G7A.3
+ZK20.3	Y113G7A.3
+ZK287.5	Y113G7A.3
+ZK632.6	Y113G7A.3
+ZK686.3	Y113G7A.3
+Y37H2C.2	Y37E3.10
+Y38A10A.5	Y37E3.10
+Y38F2AR.2	Y37E3.10
+Y38F2AR.9	Y37E3.10
+Y47D7A.1	Y37E3.10
+Y47D7A.8	Y37E3.10
+Y47H9C.5	Y37E3.10
+Y49E10.4	Y37E3.10
+Y54G2A.18	Y37E3.10
+Y56A3A.2	Y37E3.10
+Y56A3A.21	Y37E3.10
+Y57G11C.15	Y37E3.10
+Y60A3A.18	Y37E3.10
+Y63D3A.6	Y37E3.10
+Y71F9AM.6	Y37E3.10
+Y87G2A.9	Y37E3.10
+Y94H6A.9	Y37E3.10
+ZC410.3	Y37E3.10
+ZC506.1	Y37E3.10
+ZC518.2	Y37E3.10
+ZK1307.8	Y37E3.10
+ZK180.4	Y37E3.10
+ZK20.3	Y37E3.10
+ZK287.5	Y37E3.10
+ZK632.6	Y37E3.10
+ZK686.3	Y37E3.10
+Y38A10A.5	Y37H2C.2
+Y38F2AR.2	Y37H2C.2
+Y38F2AR.9	Y37H2C.2
+Y47H9C.5	Y37H2C.2
+Y49E10.4	Y37H2C.2
+Y54G2A.18	Y37H2C.2
+Y56A3A.2	Y37H2C.2
+Y56A3A.21	Y37H2C.2
+Y57G11C.15	Y37H2C.2
+Y63D3A.6	Y37H2C.2
+Y71F9AM.6	Y37H2C.2
+Y77E11A.13	Y37H2C.2
+Y94H6A.9	Y37H2C.2
+ZC410.3	Y37H2C.2
+ZC506.1	Y37H2C.2
+ZC518.2	Y37H2C.2
+ZK1307.8	Y37H2C.2
+ZK180.4	Y37H2C.2
+ZK20.3	Y37H2C.2
+ZK632.6	Y37H2C.2
+ZK686.3	Y37H2C.2
+Y38F2AR.2	Y38A10A.5
+Y38F2AR.9	Y38A10A.5
+Y47D7A.1	Y38A10A.5
+Y47D7A.8	Y38A10A.5
+Y47H9C.5	Y38A10A.5
+Y49E10.4	Y38A10A.5
+Y54G2A.18	Y38A10A.5
+Y56A3A.2	Y38A10A.5
+Y56A3A.21	Y38A10A.5
+Y57G11C.15	Y38A10A.5
+Y60A3A.18	Y38A10A.5
+Y63D3A.6	Y38A10A.5
+Y71F9AM.6	Y38A10A.5
+Y77E11A.13	Y38A10A.5
+Y87G2A.9	Y38A10A.5
+Y94H6A.9	Y38A10A.5
+ZC410.3	Y38A10A.5
+ZC506.1	Y38A10A.5
+ZC518.2	Y38A10A.5
+ZK1307.8	Y38A10A.5
+ZK180.4	Y38A10A.5
+ZK20.3	Y38A10A.5
+ZK287.5	Y38A10A.5
+ZK632.6	Y38A10A.5
+ZK686.3	Y38A10A.5
+Y38F2AR.9	Y38F2AR.2
+Y47D7A.1	Y38F2AR.2
+Y47D7A.8	Y38F2AR.2
+Y47H9C.5	Y38F2AR.2
+Y49E10.4	Y38F2AR.2
+Y54G2A.18	Y38F2AR.2
+Y56A3A.2	Y38F2AR.2
+Y56A3A.21	Y38F2AR.2
+Y57G11C.15	Y38F2AR.2
+Y60A3A.18	Y38F2AR.2
+Y63D3A.6	Y38F2AR.2
+Y71F9AM.6	Y38F2AR.2
+Y77E11A.13	Y38F2AR.2
+Y87G2A.9	Y38F2AR.2
+Y94H6A.9	Y38F2AR.2
+ZC410.3	Y38F2AR.2
+ZC506.1	Y38F2AR.2
+ZC518.2	Y38F2AR.2
+ZK1307.8	Y38F2AR.2
+ZK180.4	Y38F2AR.2
+ZK20.3	Y38F2AR.2
+ZK287.5	Y38F2AR.2
+ZK632.6	Y38F2AR.2
+ZK686.3	Y38F2AR.2
+Y47D7A.1	Y38F2AR.9
+Y47D7A.8	Y38F2AR.9
+Y47H9C.5	Y38F2AR.9
+Y49E10.4	Y38F2AR.9
+Y54G2A.18	Y38F2AR.9
+Y56A3A.2	Y38F2AR.9
+Y56A3A.21	Y38F2AR.9
+Y60A3A.18	Y38F2AR.9
+Y71F9AM.6	Y38F2AR.9
+Y77E11A.13	Y38F2AR.9
+Y87G2A.9	Y38F2AR.9
+Y94H6A.9	Y38F2AR.9
+ZC410.3	Y38F2AR.9
+ZC506.1	Y38F2AR.9
+ZC518.2	Y38F2AR.9
+ZK1307.8	Y38F2AR.9
+ZK180.4	Y38F2AR.9
+ZK20.3	Y38F2AR.9
+ZK287.5	Y38F2AR.9
+ZK632.6	Y38F2AR.9
+ZK686.3	Y38F2AR.9
+Y47H9C.5	Y47D7A.1
+Y49E10.4	Y47D7A.1
+Y54G2A.18	Y47D7A.1
+Y56A3A.2	Y47D7A.1
+Y56A3A.21	Y47D7A.1
+Y57G11C.15	Y47D7A.1
+Y63D3A.6	Y47D7A.1
+Y71F9AM.6	Y47D7A.1
+Y77E11A.13	Y47D7A.1
+Y94H6A.9	Y47D7A.1
+ZC410.3	Y47D7A.1
+ZC506.1	Y47D7A.1
+ZC518.2	Y47D7A.1
+ZK1307.8	Y47D7A.1
+ZK180.4	Y47D7A.1
+ZK20.3	Y47D7A.1
+ZK632.6	Y47D7A.1
+ZK686.3	Y47D7A.1
+Y47H9C.5	Y47D7A.8
+Y49E10.4	Y47D7A.8
+Y54G2A.18	Y47D7A.8
+Y56A3A.2	Y47D7A.8
+Y56A3A.21	Y47D7A.8
+Y57G11C.15	Y47D7A.8
+Y63D3A.6	Y47D7A.8
+Y71F9AM.6	Y47D7A.8
+Y77E11A.13	Y47D7A.8
+Y94H6A.9	Y47D7A.8
+ZC410.3	Y47D7A.8
+ZC506.1	Y47D7A.8
+ZC518.2	Y47D7A.8
+ZK1307.8	Y47D7A.8
+ZK180.4	Y47D7A.8
+ZK20.3	Y47D7A.8
+ZK632.6	Y47D7A.8
+ZK686.3	Y47D7A.8
+Y49E10.4	Y47H9C.5
+Y54G2A.18	Y47H9C.5
+Y56A3A.2	Y47H9C.5
+Y56A3A.21	Y47H9C.5
+Y57G11C.15	Y47H9C.5
+Y60A3A.18	Y47H9C.5
+Y63D3A.6	Y47H9C.5
+Y71F9AM.6	Y47H9C.5
+Y77E11A.13	Y47H9C.5
+Y87G2A.9	Y47H9C.5
+Y94H6A.9	Y47H9C.5
+ZC410.3	Y47H9C.5
+ZC506.1	Y47H9C.5
+ZC518.2	Y47H9C.5
+ZK1307.8	Y47H9C.5
+ZK180.4	Y47H9C.5
+ZK20.3	Y47H9C.5
+ZK287.5	Y47H9C.5
+ZK632.6	Y47H9C.5
+ZK686.3	Y47H9C.5
+Y54G2A.18	Y49E10.4
+Y56A3A.2	Y49E10.4
+Y56A3A.21	Y49E10.4
+Y57G11C.15	Y49E10.4
+Y60A3A.18	Y49E10.4
+Y63D3A.6	Y49E10.4
+Y71F9AM.6	Y49E10.4
+Y77E11A.13	Y49E10.4
+Y87G2A.9	Y49E10.4
+Y94H6A.9	Y49E10.4
+ZC410.3	Y49E10.4
+ZC506.1	Y49E10.4
+ZC518.2	Y49E10.4
+ZK1307.8	Y49E10.4
+ZK180.4	Y49E10.4
+ZK20.3	Y49E10.4
+ZK287.5	Y49E10.4
+ZK632.6	Y49E10.4
+ZK686.3	Y49E10.4
+Y56A3A.2	Y54G2A.18
+Y56A3A.21	Y54G2A.18
+Y57G11C.15	Y54G2A.18
+Y60A3A.18	Y54G2A.18
+Y63D3A.6	Y54G2A.18
+Y71F9AM.6	Y54G2A.18
+Y77E11A.13	Y54G2A.18
+Y87G2A.9	Y54G2A.18
+Y94H6A.9	Y54G2A.18
+ZC410.3	Y54G2A.18
+ZC506.1	Y54G2A.18
+ZC518.2	Y54G2A.18
+ZK1307.8	Y54G2A.18
+ZK180.4	Y54G2A.18
+ZK20.3	Y54G2A.18
+ZK287.5	Y54G2A.18
+ZK632.6	Y54G2A.18
+ZK686.3	Y54G2A.18
+Y56A3A.21	Y56A3A.2
+Y57G11C.15	Y56A3A.2
+Y60A3A.18	Y56A3A.2
+Y63D3A.6	Y56A3A.2
+Y71F9AM.6	Y56A3A.2
+Y77E11A.13	Y56A3A.2
+Y87G2A.9	Y56A3A.2
+Y94H6A.9	Y56A3A.2
+ZC410.3	Y56A3A.2
+ZC506.1	Y56A3A.2
+ZC518.2	Y56A3A.2
+ZK1307.8	Y56A3A.2
+ZK180.4	Y56A3A.2
+ZK20.3	Y56A3A.2
+ZK287.5	Y56A3A.2
+ZK632.6	Y56A3A.2
+ZK686.3	Y56A3A.2
+Y57G11C.15	Y56A3A.21
+Y60A3A.18	Y56A3A.21
+Y63D3A.6	Y56A3A.21
+Y71F9AM.6	Y56A3A.21
+Y77E11A.13	Y56A3A.21
+Y87G2A.9	Y56A3A.21
+Y94H6A.9	Y56A3A.21
+ZC410.3	Y56A3A.21
+ZC506.1	Y56A3A.21
+ZC518.2	Y56A3A.21
+ZK1307.8	Y56A3A.21
+ZK180.4	Y56A3A.21
+ZK20.3	Y56A3A.21
+ZK287.5	Y56A3A.21
+ZK632.6	Y56A3A.21
+ZK686.3	Y56A3A.21
+Y60A3A.18	Y57G11C.15
+Y71F9AM.6	Y57G11C.15
+Y77E11A.13	Y57G11C.15
+Y87G2A.9	Y57G11C.15
+Y94H6A.9	Y57G11C.15
+ZC410.3	Y57G11C.15
+ZC506.1	Y57G11C.15
+ZC518.2	Y57G11C.15
+ZK1307.8	Y57G11C.15
+ZK180.4	Y57G11C.15
+ZK20.3	Y57G11C.15
+ZK287.5	Y57G11C.15
+ZK632.6	Y57G11C.15
+ZK686.3	Y57G11C.15
+Y63D3A.6	Y60A3A.18
+Y71F9AM.6	Y60A3A.18
+Y77E11A.13	Y60A3A.18
+Y94H6A.9	Y60A3A.18
+ZC410.3	Y60A3A.18
+ZC506.1	Y60A3A.18
+ZC518.2	Y60A3A.18
+ZK1307.8	Y60A3A.18
+ZK180.4	Y60A3A.18
+ZK20.3	Y60A3A.18
+ZK632.6	Y60A3A.18
+ZK686.3	Y60A3A.18
+Y71F9AM.6	Y63D3A.6
+Y77E11A.13	Y63D3A.6
+Y87G2A.9	Y63D3A.6
+Y94H6A.9	Y63D3A.6
+ZC410.3	Y63D3A.6
+ZC506.1	Y63D3A.6
+ZC518.2	Y63D3A.6
+ZK1307.8	Y63D3A.6
+ZK180.4	Y63D3A.6
+ZK20.3	Y63D3A.6
+ZK287.5	Y63D3A.6
+ZK632.6	Y63D3A.6
+ZK686.3	Y63D3A.6
+Y77E11A.13	Y71F9AM.6
+Y87G2A.9	Y71F9AM.6
+Y94H6A.9	Y71F9AM.6
+ZC410.3	Y71F9AM.6
+ZC506.1	Y71F9AM.6
+ZC518.2	Y71F9AM.6
+ZK1307.8	Y71F9AM.6
+ZK180.4	Y71F9AM.6
+ZK20.3	Y71F9AM.6
+ZK287.5	Y71F9AM.6
+ZK632.6	Y71F9AM.6
+ZK686.3	Y71F9AM.6
+Y87G2A.9	Y77E11A.13
+Y94H6A.9	Y77E11A.13
+ZC410.3	Y77E11A.13
+ZC506.1	Y77E11A.13
+ZC518.2	Y77E11A.13
+ZK1307.8	Y77E11A.13
+ZK180.4	Y77E11A.13
+ZK20.3	Y77E11A.13
+ZK287.5	Y77E11A.13
+ZK632.6	Y77E11A.13
+ZK686.3	Y77E11A.13
+Y94H6A.9	Y87G2A.9
+ZC410.3	Y87G2A.9
+ZC506.1	Y87G2A.9
+ZC518.2	Y87G2A.9
+ZK1307.8	Y87G2A.9
+ZK180.4	Y87G2A.9
+ZK20.3	Y87G2A.9
+ZK632.6	Y87G2A.9
+ZK686.3	Y87G2A.9
+ZC410.3	Y94H6A.9
+ZC506.1	Y94H6A.9
+ZC518.2	Y94H6A.9
+ZK1307.8	Y94H6A.9
+ZK180.4	Y94H6A.9
+ZK20.3	Y94H6A.9
+ZK287.5	Y94H6A.9
+ZK632.6	Y94H6A.9
+ZK686.3	Y94H6A.9
+ZC506.1	ZC410.3
+ZC518.2	ZC410.3
+ZK1307.8	ZC410.3
+ZK180.4	ZC410.3
+ZK20.3	ZC410.3
+ZK287.5	ZC410.3
+ZK632.6	ZC410.3
+ZC518.2	ZC506.1
+ZK1307.8	ZC506.1
+ZK180.4	ZC506.1
+ZK20.3	ZC506.1
+ZK287.5	ZC506.1
+ZK632.6	ZC506.1
+ZK686.3	ZC506.1
+ZK1307.8	ZC518.2
+ZK180.4	ZC518.2
+ZK20.3	ZC518.2
+ZK287.5	ZC518.2
+ZK632.6	ZC518.2
+ZK686.3	ZC518.2
+ZK180.4	ZK1307.8
+ZK20.3	ZK1307.8
+ZK287.5	ZK1307.8
+ZK632.6	ZK1307.8
+ZK686.3	ZK1307.8
+ZK20.3	ZK180.4
+ZK287.5	ZK180.4
+ZK632.6	ZK180.4
+ZK686.3	ZK180.4
+ZK632.6	ZK20.3
+ZK686.3	ZK20.3
+ZK632.6	ZK287.5
+ZK686.3	ZK287.5
+ZK686.3	ZK632.6
+C03B1.12	B0252.2
+C07B5.5	B0252.2
+C26H9A.1	B0252.2
+C28C12.7	B0252.2
+C30F8.2	B0252.2
+C33G3.4	B0252.2
+C41C4.7	B0252.2
+C52E4.1	B0252.2
+F02E8.6	B0252.2
+F07B10.1	B0252.2
+F09G8.2	B0252.2
+F13D12.6	B0252.2
+F29G9.3	B0252.2
+F32B5.8	B0252.2
+F32H5.1	B0252.2
+F35H10.4	B0252.2
+F36D3.9	B0252.2
+F41C3.5	B0252.2
+F41E6.6	B0252.2
+F44C4.3	B0252.2
+F44C4.5	B0252.2
+F52E1.10	B0252.2
+F53H8.1	B0252.2
+F55A12.7	B0252.2
+F55D10.1	B0252.2
+F57F5.1	B0252.2
+K04H4.6	B0252.2
+K09E4.4	B0252.2
+K11D2.3	B0252.2
+K11G12.3	B0252.2
+K11G12.4	B0252.2
+M04G12.2	B0252.2
+M05B5.4	B0252.2
+R04B3.2	B0252.2
+R07E4.4	B0252.2
+R10E11.2	B0252.2
+R10E11.8	B0252.2
+R11A5.1	B0252.2
+R12H7.2	B0252.2
+R148.6	B0252.2
+T01H3.1	B0252.2
+T03E6.7	B0252.2
+T10H4.12	B0252.2
+T14F9.1	B0252.2
+T14F9.3	B0252.2
+T20G5.1	B0252.2
+T23D8.2	B0252.2
+T28H10.3	B0252.2
+VW02B12L.1	B0252.2
+W04G3.4	B0252.2
+W07B8.1	B0252.2
+W07B8.4	B0252.2
+W07B8.5	B0252.2
+W09G10.4	B0252.2
+Y105E8A.9	B0252.2
+Y105E8B.9	B0252.2
+Y16B4A.2	B0252.2
+Y38F2AL.4	B0252.2
+Y40D12A.2	B0252.2
+Y48G8AL.14	B0252.2
+Y49E10.20	B0252.2
+Y50E8A.16	B0252.2
+Y53G8AR.7	B0252.2
+Y55H10A.1	B0252.2
+Y69A2AR.4	B0252.2
+ZK484.2	B0252.2
+ZK637.8	B0252.2
+C07B5.5	C03B1.12
+C26H9A.1	C03B1.12
+C28C12.7	C03B1.12
+C29E4.10	C03B1.12
+C30F8.2	C03B1.12
+C33C12.3	C03B1.12
+C33C12.8	C03B1.12
+C33G3.4	C03B1.12
+C41C4.7	C03B1.12
+C52E4.1	C03B1.12
+F02E8.6	C03B1.12
+F07B10.1	C03B1.12
+F09G8.2	C03B1.12
+F11E6.1	C03B1.12
+F13D12.6	C03B1.12
+F29G9.3	C03B1.12
+F32B5.8	C03B1.12
+F32H5.1	C03B1.12
+F35H10.4	C03B1.12
+F36D3.9	C03B1.12
+F41C3.5	C03B1.12
+F41E6.6	C03B1.12
+F44C4.3	C03B1.12
+F44C4.5	C03B1.12
+F52E1.10	C03B1.12
+F53H8.1	C03B1.12
+F55A12.7	C03B1.12
+F55D10.1	C03B1.12
+F57F5.1	C03B1.12
+K04H4.6	C03B1.12
+K09E4.4	C03B1.12
+K11D2.2	C03B1.12
+K11D2.3	C03B1.12
+K11G12.3	C03B1.12
+K11G12.4	C03B1.12
+M04G12.2	C03B1.12
+M05B5.4	C03B1.12
+R04B3.2	C03B1.12
+R07E4.4	C03B1.12
+R10E11.2	C03B1.12
+R10E11.8	C03B1.12
+R11A5.1	C03B1.12
+R12H7.2	C03B1.12
+R148.6	C03B1.12
+T01H3.1	C03B1.12
+T03E6.7	C03B1.12
+T10H4.12	C03B1.12
+T14F9.1	C03B1.12
+T14F9.3	C03B1.12
+T19B10.3	C03B1.12
+T20G5.1	C03B1.12
+T23D8.2	C03B1.12
+T28H10.3	C03B1.12
+VW02B12L.1	C03B1.12
+W03G1.7	C03B1.12
+W04G3.4	C03B1.12
+W07B8.1	C03B1.12
+W07B8.4	C03B1.12
+W07B8.5	C03B1.12
+W09G10.4	C03B1.12
+Y105E8A.9	C03B1.12
+Y105E8B.9	C03B1.12
+Y16B4A.2	C03B1.12
+Y38F2AL.4	C03B1.12
+Y40D12A.2	C03B1.12
+Y48G8AL.14	C03B1.12
+Y49E10.20	C03B1.12
+Y4C6B.6	C03B1.12
+Y50E8A.16	C03B1.12
+Y53G8AR.7	C03B1.12
+Y55H10A.1	C03B1.12
+Y69A2AR.4	C03B1.12
+ZK455.4	C03B1.12
+ZK484.2	C03B1.12
+ZK637.8	C03B1.12
+C26H9A.1	C07B5.5
+C28C12.7	C07B5.5
+C29E4.10	C07B5.5
+C30F8.2	C07B5.5
+C33C12.3	C07B5.5
+C33C12.8	C07B5.5
+C33G3.4	C07B5.5
+C41C4.7	C07B5.5
+C52E4.1	C07B5.5
+F02E8.6	C07B5.5
+F07B10.1	C07B5.5
+F09G8.2	C07B5.5
+F11E6.1	C07B5.5
+F13D12.6	C07B5.5
+F29G9.3	C07B5.5
+F32B5.8	C07B5.5
+F32H5.1	C07B5.5
+F35H10.4	C07B5.5
+F36D3.9	C07B5.5
+F41C3.5	C07B5.5
+F41E6.6	C07B5.5
+F44C4.3	C07B5.5
+F44C4.5	C07B5.5
+F52E1.10	C07B5.5
+F53H8.1	C07B5.5
+F55A12.7	C07B5.5
+F55D10.1	C07B5.5
+F57F5.1	C07B5.5
+K04H4.6	C07B5.5
+K09E4.4	C07B5.5
+K11D2.2	C07B5.5
+K11D2.3	C07B5.5
+K11G12.3	C07B5.5
+K11G12.4	C07B5.5
+M04G12.2	C07B5.5
+M05B5.4	C07B5.5
+R04B3.2	C07B5.5
+R07E4.4	C07B5.5
+R10E11.2	C07B5.5
+R10E11.8	C07B5.5
+R11A5.1	C07B5.5
+R12H7.2	C07B5.5
+R148.6	C07B5.5
+T01H3.1	C07B5.5
+T03E6.7	C07B5.5
+T10H4.12	C07B5.5
+T14F9.1	C07B5.5
+T14F9.3	C07B5.5
+T19B10.3	C07B5.5
+T20G5.1	C07B5.5
+T23D8.2	C07B5.5
+T28H10.3	C07B5.5
+VW02B12L.1	C07B5.5
+W03G1.7	C07B5.5
+W04G3.4	C07B5.5
+W07B8.1	C07B5.5
+W07B8.4	C07B5.5
+W07B8.5	C07B5.5
+W09G10.4	C07B5.5
+Y105E8A.9	C07B5.5
+Y105E8B.9	C07B5.5
+Y16B4A.2	C07B5.5
+Y38F2AL.4	C07B5.5
+Y40D12A.2	C07B5.5
+Y48G8AL.14	C07B5.5
+Y49E10.20	C07B5.5
+Y4C6B.6	C07B5.5
+Y50E8A.16	C07B5.5
+Y53G8AR.7	C07B5.5
+Y55H10A.1	C07B5.5
+Y69A2AR.4	C07B5.5
+ZK455.4	C07B5.5
+ZK484.2	C07B5.5
+ZK637.8	C07B5.5
+C28C12.7	C26H9A.1
+C29E4.10	C26H9A.1
+C33C12.3	C26H9A.1
+C33C12.8	C26H9A.1
+C33G3.4	C26H9A.1
+C41C4.7	C26H9A.1
+C52E4.1	C26H9A.1
+F02E8.6	C26H9A.1
+F07B10.1	C26H9A.1
+F09G8.2	C26H9A.1
+F11E6.1	C26H9A.1
+F13D12.6	C26H9A.1
+F29G9.3	C26H9A.1
+F32B5.8	C26H9A.1
+F32H5.1	C26H9A.1
+F36D3.9	C26H9A.1
+F41C3.5	C26H9A.1
+F41E6.6	C26H9A.1
+F44C4.3	C26H9A.1
+F44C4.5	C26H9A.1
+F53H8.1	C26H9A.1
+F55A12.7	C26H9A.1
+F55D10.1	C26H9A.1
+F57F5.1	C26H9A.1
+K04H4.6	C26H9A.1
+K09E4.4	C26H9A.1
+K11D2.2	C26H9A.1
+K11D2.3	C26H9A.1
+K11G12.3	C26H9A.1
+K11G12.4	C26H9A.1
+M04G12.2	C26H9A.1
+M05B5.4	C26H9A.1
+R04B3.2	C26H9A.1
+R07E4.4	C26H9A.1
+R11A5.1	C26H9A.1
+R12H7.2	C26H9A.1
+R148.6	C26H9A.1
+T03E6.7	C26H9A.1
+T10H4.12	C26H9A.1
+T14F9.3	C26H9A.1
+T19B10.3	C26H9A.1
+T20G5.1	C26H9A.1
+T23D8.2	C26H9A.1
+T28H10.3	C26H9A.1
+W03G1.7	C26H9A.1
+W04G3.4	C26H9A.1
+W07B8.1	C26H9A.1
+W07B8.4	C26H9A.1
+W07B8.5	C26H9A.1
+W09G10.4	C26H9A.1
+Y105E8A.9	C26H9A.1
+Y105E8B.9	C26H9A.1
+Y16B4A.2	C26H9A.1
+Y40D12A.2	C26H9A.1
+Y48G8AL.14	C26H9A.1
+Y49E10.20	C26H9A.1
+Y4C6B.6	C26H9A.1
+Y50E8A.16	C26H9A.1
+Y53G8AR.7	C26H9A.1
+Y69A2AR.4	C26H9A.1
+ZK455.4	C26H9A.1
+ZK484.2	C26H9A.1
+C29E4.10	C28C12.7
+C30F8.2	C28C12.7
+C33C12.3	C28C12.7
+C33C12.8	C28C12.7
+C33G3.4	C28C12.7
+C41C4.7	C28C12.7
+C52E4.1	C28C12.7
+F02E8.6	C28C12.7
+F07B10.1	C28C12.7
+F09G8.2	C28C12.7
+F11E6.1	C28C12.7
+F13D12.6	C28C12.7
+F29G9.3	C28C12.7
+F32B5.8	C28C12.7
+F32H5.1	C28C12.7
+F35H10.4	C28C12.7
+F36D3.9	C28C12.7
+F41C3.5	C28C12.7
+F41E6.6	C28C12.7
+F44C4.3	C28C12.7
+F44C4.5	C28C12.7
+F52E1.10	C28C12.7
+F53H8.1	C28C12.7
+F55A12.7	C28C12.7
+F55D10.1	C28C12.7
+F57F5.1	C28C12.7
+K04H4.6	C28C12.7
+K09E4.4	C28C12.7
+K11D2.2	C28C12.7
+K11D2.3	C28C12.7
+K11G12.3	C28C12.7
+K11G12.4	C28C12.7
+M04G12.2	C28C12.7
+M05B5.4	C28C12.7
+R04B3.2	C28C12.7
+R07E4.4	C28C12.7
+R10E11.2	C28C12.7
+R10E11.8	C28C12.7
+R11A5.1	C28C12.7
+R12H7.2	C28C12.7
+R148.6	C28C12.7
+T01H3.1	C28C12.7
+T03E6.7	C28C12.7
+T10H4.12	C28C12.7
+T14F9.1	C28C12.7
+T14F9.3	C28C12.7
+T19B10.3	C28C12.7
+T20G5.1	C28C12.7
+T23D8.2	C28C12.7
+T28H10.3	C28C12.7
+VW02B12L.1	C28C12.7
+W03G1.7	C28C12.7
+W04G3.4	C28C12.7
+W07B8.1	C28C12.7
+W07B8.4	C28C12.7
+W07B8.5	C28C12.7
+W09G10.4	C28C12.7
+Y105E8A.9	C28C12.7
+Y105E8B.9	C28C12.7
+Y16B4A.2	C28C12.7
+Y38F2AL.4	C28C12.7
+Y40D12A.2	C28C12.7
+Y48G8AL.14	C28C12.7
+Y49E10.20	C28C12.7
+Y4C6B.6	C28C12.7
+Y50E8A.16	C28C12.7
+Y53G8AR.7	C28C12.7
+Y55H10A.1	C28C12.7
+Y69A2AR.4	C28C12.7
+ZK455.4	C28C12.7
+ZK484.2	C28C12.7
+ZK637.8	C28C12.7
+C30F8.2	C29E4.10
+C33G3.4	C29E4.10
+C41C4.7	C29E4.10
+C52E4.1	C29E4.10
+F02E8.6	C29E4.10
+F07B10.1	C29E4.10
+F09G8.2	C29E4.10
+F13D12.6	C29E4.10
+F29G9.3	C29E4.10
+F32B5.8	C29E4.10
+F32H5.1	C29E4.10
+F35H10.4	C29E4.10
+F36D3.9	C29E4.10
+F41C3.5	C29E4.10
+F41E6.6	C29E4.10
+F44C4.3	C29E4.10
+F44C4.5	C29E4.10
+F52E1.10	C29E4.10
+F53H8.1	C29E4.10
+F55A12.7	C29E4.10
+F55D10.1	C29E4.10
+F57F5.1	C29E4.10
+K04H4.6	C29E4.10
+K09E4.4	C29E4.10
+K11D2.3	C29E4.10
+K11G12.3	C29E4.10
+K11G12.4	C29E4.10
+M04G12.2	C29E4.10
+M05B5.4	C29E4.10
+R04B3.2	C29E4.10
+R07E4.4	C29E4.10
+R10E11.2	C29E4.10
+R10E11.8	C29E4.10
+R11A5.1	C29E4.10
+R12H7.2	C29E4.10
+R148.6	C29E4.10
+T01H3.1	C29E4.10
+T03E6.7	C29E4.10
+T10H4.12	C29E4.10
+T14F9.1	C29E4.10
+T14F9.3	C29E4.10
+T20G5.1	C29E4.10
+T23D8.2	C29E4.10
+T28H10.3	C29E4.10
+VW02B12L.1	C29E4.10
+W04G3.4	C29E4.10
+W07B8.1	C29E4.10
+W07B8.4	C29E4.10
+W07B8.5	C29E4.10
+W09G10.4	C29E4.10
+Y105E8A.9	C29E4.10
+Y105E8B.9	C29E4.10
+Y16B4A.2	C29E4.10
+Y38F2AL.4	C29E4.10
+Y40D12A.2	C29E4.10
+Y48G8AL.14	C29E4.10
+Y49E10.20	C29E4.10
+Y50E8A.16	C29E4.10
+Y53G8AR.7	C29E4.10
+Y55H10A.1	C29E4.10
+Y69A2AR.4	C29E4.10
+ZK484.2	C29E4.10
+ZK637.8	C29E4.10
+C33C12.3	C30F8.2
+C33C12.8	C30F8.2
+C33G3.4	C30F8.2
+C41C4.7	C30F8.2
+C52E4.1	C30F8.2
+F02E8.6	C30F8.2
+F07B10.1	C30F8.2
+F09G8.2	C30F8.2
+F11E6.1	C30F8.2
+F13D12.6	C30F8.2
+F29G9.3	C30F8.2
+F32B5.8	C30F8.2
+F32H5.1	C30F8.2
+F36D3.9	C30F8.2
+F41C3.5	C30F8.2
+F41E6.6	C30F8.2
+F44C4.3	C30F8.2
+F44C4.5	C30F8.2
+F53H8.1	C30F8.2
+F55A12.7	C30F8.2
+F55D10.1	C30F8.2
+F57F5.1	C30F8.2
+K04H4.6	C30F8.2
+K09E4.4	C30F8.2
+K11D2.2	C30F8.2
+K11D2.3	C30F8.2
+K11G12.3	C30F8.2
+K11G12.4	C30F8.2
+M04G12.2	C30F8.2
+M05B5.4	C30F8.2
+R04B3.2	C30F8.2
+R07E4.4	C30F8.2
+R11A5.1	C30F8.2
+R12H7.2	C30F8.2
+R148.6	C30F8.2
+T03E6.7	C30F8.2
+T10H4.12	C30F8.2
+T14F9.3	C30F8.2
+T19B10.3	C30F8.2
+T20G5.1	C30F8.2
+T23D8.2	C30F8.2
+T28H10.3	C30F8.2
+W03G1.7	C30F8.2
+W04G3.4	C30F8.2
+W07B8.1	C30F8.2
+W07B8.4	C30F8.2
+W07B8.5	C30F8.2
+W09G10.4	C30F8.2
+Y105E8A.9	C30F8.2
+Y105E8B.9	C30F8.2
+Y16B4A.2	C30F8.2
+Y40D12A.2	C30F8.2
+Y48G8AL.14	C30F8.2
+Y49E10.20	C30F8.2
+Y4C6B.6	C30F8.2
+Y50E8A.16	C30F8.2
+Y53G8AR.7	C30F8.2
+Y69A2AR.4	C30F8.2
+ZK455.4	C30F8.2
+ZK484.2	C30F8.2
+C41C4.7	C33C12.3
+C52E4.1	C33C12.3
+F02E8.6	C33C12.3
+F07B10.1	C33C12.3
+F09G8.2	C33C12.3
+F13D12.6	C33C12.3
+F29G9.3	C33C12.3
+F32B5.8	C33C12.3
+F32H5.1	C33C12.3
+F35H10.4	C33C12.3
+F36D3.9	C33C12.3
+F41C3.5	C33C12.3
+F41E6.6	C33C12.3
+F44C4.3	C33C12.3
+F44C4.5	C33C12.3
+F52E1.10	C33C12.3
+F53H8.1	C33C12.3
+F55A12.7	C33C12.3
+F57F5.1	C33C12.3
+K04H4.6	C33C12.3
+K09E4.4	C33C12.3
+K11D2.3	C33C12.3
+K11G12.3	C33C12.3
+K11G12.4	C33C12.3
+M04G12.2	C33C12.3
+M05B5.4	C33C12.3
+R07E4.4	C33C12.3
+R10E11.2	C33C12.3
+R10E11.8	C33C12.3
+R11A5.1	C33C12.3
+R12H7.2	C33C12.3
+R148.6	C33C12.3
+T01H3.1	C33C12.3
+T03E6.7	C33C12.3
+T10H4.12	C33C12.3
+T14F9.1	C33C12.3
+T20G5.1	C33C12.3
+T23D8.2	C33C12.3
+T28H10.3	C33C12.3
+VW02B12L.1	C33C12.3
+W04G3.4	C33C12.3
+W07B8.1	C33C12.3
+W07B8.4	C33C12.3
+W07B8.5	C33C12.3
+W09G10.4	C33C12.3
+Y105E8A.9	C33C12.3
+Y105E8B.9	C33C12.3
+Y16B4A.2	C33C12.3
+Y38F2AL.4	C33C12.3
+Y40D12A.2	C33C12.3
+Y48G8AL.14	C33C12.3
+Y49E10.20	C33C12.3
+Y50E8A.16	C33C12.3
+Y53G8AR.7	C33C12.3
+Y55H10A.1	C33C12.3
+Y69A2AR.4	C33C12.3
+ZK484.2	C33C12.3
+ZK637.8	C33C12.3
+C41C4.7	C33C12.8
+C52E4.1	C33C12.8
+F02E8.6	C33C12.8
+F07B10.1	C33C12.8
+F09G8.2	C33C12.8
+F13D12.6	C33C12.8
+F29G9.3	C33C12.8
+F32B5.8	C33C12.8
+F32H5.1	C33C12.8
+F35H10.4	C33C12.8
+F36D3.9	C33C12.8
+F41C3.5	C33C12.8
+F41E6.6	C33C12.8
+F44C4.3	C33C12.8
+F44C4.5	C33C12.8
+F52E1.10	C33C12.8
+F53H8.1	C33C12.8
+F55A12.7	C33C12.8
+F57F5.1	C33C12.8
+K04H4.6	C33C12.8
+K09E4.4	C33C12.8
+K11D2.3	C33C12.8
+K11G12.3	C33C12.8
+K11G12.4	C33C12.8
+M04G12.2	C33C12.8
+M05B5.4	C33C12.8
+R07E4.4	C33C12.8
+R10E11.2	C33C12.8
+R10E11.8	C33C12.8
+R11A5.1	C33C12.8
+R12H7.2	C33C12.8
+R148.6	C33C12.8
+T01H3.1	C33C12.8
+T03E6.7	C33C12.8
+T10H4.12	C33C12.8
+T14F9.1	C33C12.8
+T20G5.1	C33C12.8
+T23D8.2	C33C12.8
+T28H10.3	C33C12.8
+VW02B12L.1	C33C12.8
+W04G3.4	C33C12.8
+W07B8.1	C33C12.8
+W07B8.4	C33C12.8
+W07B8.5	C33C12.8
+W09G10.4	C33C12.8
+Y105E8A.9	C33C12.8
+Y105E8B.9	C33C12.8
+Y16B4A.2	C33C12.8
+Y38F2AL.4	C33C12.8
+Y40D12A.2	C33C12.8
+Y48G8AL.14	C33C12.8
+Y49E10.20	C33C12.8
+Y50E8A.16	C33C12.8
+Y53G8AR.7	C33C12.8
+Y55H10A.1	C33C12.8
+Y69A2AR.4	C33C12.8
+ZK484.2	C33C12.8
+ZK637.8	C33C12.8
+C41C4.7	C33G3.4
+C52E4.1	C33G3.4
+F02E8.6	C33G3.4
+F07B10.1	C33G3.4
+F09G8.2	C33G3.4
+F13D12.6	C33G3.4
+F29G9.3	C33G3.4
+F32B5.8	C33G3.4
+F32H5.1	C33G3.4
+F35H10.4	C33G3.4
+F36D3.9	C33G3.4
+F41C3.5	C33G3.4
+F41E6.6	C33G3.4
+F44C4.3	C33G3.4
+F44C4.5	C33G3.4
+F52E1.10	C33G3.4
+F53H8.1	C33G3.4
+F55A12.7	C33G3.4
+F57F5.1	C33G3.4
+K04H4.6	C33G3.4
+K09E4.4	C33G3.4
+K11D2.2	C33G3.4
+K11D2.3	C33G3.4
+K11G12.3	C33G3.4
+K11G12.4	C33G3.4
+M04G12.2	C33G3.4
+M05B5.4	C33G3.4
+R07E4.4	C33G3.4
+R10E11.2	C33G3.4
+R10E11.8	C33G3.4
+R11A5.1	C33G3.4
+R12H7.2	C33G3.4
+R148.6	C33G3.4
+T01H3.1	C33G3.4
+T03E6.7	C33G3.4
+T10H4.12	C33G3.4
+T14F9.1	C33G3.4
+T20G5.1	C33G3.4
+T23D8.2	C33G3.4
+T28H10.3	C33G3.4
+VW02B12L.1	C33G3.4
+W03G1.7	C33G3.4
+W04G3.4	C33G3.4
+W07B8.1	C33G3.4
+W07B8.4	C33G3.4
+W07B8.5	C33G3.4
+W09G10.4	C33G3.4
+Y105E8A.9	C33G3.4
+Y105E8B.9	C33G3.4
+Y16B4A.2	C33G3.4
+Y38F2AL.4	C33G3.4
+Y40D12A.2	C33G3.4
+Y48G8AL.14	C33G3.4
+Y49E10.20	C33G3.4
+Y50E8A.16	C33G3.4
+Y53G8AR.7	C33G3.4
+Y55H10A.1	C33G3.4
+Y69A2AR.4	C33G3.4
+ZK455.4	C33G3.4
+ZK484.2	C33G3.4
+ZK637.8	C33G3.4
+C52E4.1	C41C4.7
+F02E8.6	C41C4.7
+F07B10.1	C41C4.7
+F09G8.2	C41C4.7
+F11E6.1	C41C4.7
+F13D12.6	C41C4.7
+F29G9.3	C41C4.7
+F32B5.8	C41C4.7
+F32H5.1	C41C4.7
+F35H10.4	C41C4.7
+F36D3.9	C41C4.7
+F41C3.5	C41C4.7
+F41E6.6	C41C4.7
+F44C4.3	C41C4.7
+F44C4.5	C41C4.7
+F52E1.10	C41C4.7
+F53H8.1	C41C4.7
+F55A12.7	C41C4.7
+F55D10.1	C41C4.7
+F57F5.1	C41C4.7
+K04H4.6	C41C4.7
+K09E4.4	C41C4.7
+K11D2.2	C41C4.7
+K11D2.3	C41C4.7
+K11G12.3	C41C4.7
+K11G12.4	C41C4.7
+M04G12.2	C41C4.7
+M05B5.4	C41C4.7
+R04B3.2	C41C4.7
+R07E4.4	C41C4.7
+R10E11.2	C41C4.7
+R10E11.8	C41C4.7
+R11A5.1	C41C4.7
+R12H7.2	C41C4.7
+R148.6	C41C4.7
+T01H3.1	C41C4.7
+T03E6.7	C41C4.7
+T10H4.12	C41C4.7
+T14F9.1	C41C4.7
+T14F9.3	C41C4.7
+T19B10.3	C41C4.7
+T20G5.1	C41C4.7
+T23D8.2	C41C4.7
+T28H10.3	C41C4.7
+VW02B12L.1	C41C4.7
+W03G1.7	C41C4.7
+W04G3.4	C41C4.7
+W07B8.1	C41C4.7
+W07B8.4	C41C4.7
+W07B8.5	C41C4.7
+W09G10.4	C41C4.7
+Y105E8A.9	C41C4.7
+Y105E8B.9	C41C4.7
+Y16B4A.2	C41C4.7
+Y38F2AL.4	C41C4.7
+Y40D12A.2	C41C4.7
+Y48G8AL.14	C41C4.7
+Y49E10.20	C41C4.7
+Y4C6B.6	C41C4.7
+Y50E8A.16	C41C4.7
+Y53G8AR.7	C41C4.7
+Y55H10A.1	C41C4.7
+Y69A2AR.4	C41C4.7
+ZK455.4	C41C4.7
+ZK484.2	C41C4.7
+ZK637.8	C41C4.7
+F02E8.6	C52E4.1
+F07B10.1	C52E4.1
+F09G8.2	C52E4.1
+F11E6.1	C52E4.1
+F13D12.6	C52E4.1
+F29G9.3	C52E4.1
+F32B5.8	C52E4.1
+F32H5.1	C52E4.1
+F35H10.4	C52E4.1
+F36D3.9	C52E4.1
+F41C3.5	C52E4.1
+F41E6.6	C52E4.1
+F44C4.3	C52E4.1
+F44C4.5	C52E4.1
+F52E1.10	C52E4.1
+F53H8.1	C52E4.1
+F55A12.7	C52E4.1
+F55D10.1	C52E4.1
+F57F5.1	C52E4.1
+K04H4.6	C52E4.1
+K09E4.4	C52E4.1
+K11D2.2	C52E4.1
+K11D2.3	C52E4.1
+K11G12.3	C52E4.1
+K11G12.4	C52E4.1
+M04G12.2	C52E4.1
+M05B5.4	C52E4.1
+R04B3.2	C52E4.1
+R07E4.4	C52E4.1
+R10E11.2	C52E4.1
+R10E11.8	C52E4.1
+R11A5.1	C52E4.1
+R12H7.2	C52E4.1
+R148.6	C52E4.1
+T01H3.1	C52E4.1
+T03E6.7	C52E4.1
+T10H4.12	C52E4.1
+T14F9.1	C52E4.1
+T14F9.3	C52E4.1
+T19B10.3	C52E4.1
+T20G5.1	C52E4.1
+T23D8.2	C52E4.1
+T28H10.3	C52E4.1
+VW02B12L.1	C52E4.1
+W03G1.7	C52E4.1
+W04G3.4	C52E4.1
+W07B8.1	C52E4.1
+W07B8.4	C52E4.1
+W07B8.5	C52E4.1
+W09G10.4	C52E4.1
+Y105E8A.9	C52E4.1
+Y105E8B.9	C52E4.1
+Y16B4A.2	C52E4.1
+Y38F2AL.4	C52E4.1
+Y40D12A.2	C52E4.1
+Y48G8AL.14	C52E4.1
+Y49E10.20	C52E4.1
+Y4C6B.6	C52E4.1
+Y50E8A.16	C52E4.1
+Y53G8AR.7	C52E4.1
+Y55H10A.1	C52E4.1
+Y69A2AR.4	C52E4.1
+ZK455.4	C52E4.1
+ZK484.2	C52E4.1
+ZK637.8	C52E4.1
+F07B10.1	F02E8.6
+F09G8.2	F02E8.6
+F11E6.1	F02E8.6
+F13D12.6	F02E8.6
+F29G9.3	F02E8.6
+F32B5.8	F02E8.6
+F32H5.1	F02E8.6
+F35H10.4	F02E8.6
+F36D3.9	F02E8.6
+F41C3.5	F02E8.6
+F41E6.6	F02E8.6
+F44C4.3	F02E8.6
+F44C4.5	F02E8.6
+F52E1.10	F02E8.6
+F53H8.1	F02E8.6
+F55A12.7	F02E8.6
+F55D10.1	F02E8.6
+F57F5.1	F02E8.6
+K04H4.6	F02E8.6
+K09E4.4	F02E8.6
+K11D2.2	F02E8.6
+K11D2.3	F02E8.6
+K11G12.3	F02E8.6
+K11G12.4	F02E8.6
+M04G12.2	F02E8.6
+M05B5.4	F02E8.6
+R04B3.2	F02E8.6
+R07E4.4	F02E8.6
+R10E11.2	F02E8.6
+R10E11.8	F02E8.6
+R11A5.1	F02E8.6
+R12H7.2	F02E8.6
+R148.6	F02E8.6
+T01H3.1	F02E8.6
+T03E6.7	F02E8.6
+T10H4.12	F02E8.6
+T14F9.1	F02E8.6
+T14F9.3	F02E8.6
+T19B10.3	F02E8.6
+T20G5.1	F02E8.6
+T23D8.2	F02E8.6
+T28H10.3	F02E8.6
+VW02B12L.1	F02E8.6
+W03G1.7	F02E8.6
+W04G3.4	F02E8.6
+W07B8.1	F02E8.6
+W07B8.4	F02E8.6
+W07B8.5	F02E8.6
+W09G10.4	F02E8.6
+Y105E8A.9	F02E8.6
+Y105E8B.9	F02E8.6
+Y16B4A.2	F02E8.6
+Y38F2AL.4	F02E8.6
+Y40D12A.2	F02E8.6
+Y48G8AL.14	F02E8.6
+Y49E10.20	F02E8.6
+Y4C6B.6	F02E8.6
+Y50E8A.16	F02E8.6
+Y53G8AR.7	F02E8.6
+Y55H10A.1	F02E8.6
+Y69A2AR.4	F02E8.6
+ZK455.4	F02E8.6
+ZK484.2	F02E8.6
+ZK637.8	F02E8.6
+F09G8.2	F07B10.1
+F11E6.1	F07B10.1
+F13D12.6	F07B10.1
+F29G9.3	F07B10.1
+F32B5.8	F07B10.1
+F32H5.1	F07B10.1
+F35H10.4	F07B10.1
+F36D3.9	F07B10.1
+F41C3.5	F07B10.1
+F41E6.6	F07B10.1
+F44C4.3	F07B10.1
+F44C4.5	F07B10.1
+F52E1.10	F07B10.1
+F53H8.1	F07B10.1
+F55A12.7	F07B10.1
+F55D10.1	F07B10.1
+F57F5.1	F07B10.1
+K04H4.6	F07B10.1
+K09E4.4	F07B10.1
+K11D2.2	F07B10.1
+K11D2.3	F07B10.1
+K11G12.3	F07B10.1
+K11G12.4	F07B10.1
+M04G12.2	F07B10.1
+M05B5.4	F07B10.1
+R04B3.2	F07B10.1
+R07E4.4	F07B10.1
+R10E11.2	F07B10.1
+R10E11.8	F07B10.1
+R11A5.1	F07B10.1
+R12H7.2	F07B10.1
+R148.6	F07B10.1
+T01H3.1	F07B10.1
+T03E6.7	F07B10.1
+T10H4.12	F07B10.1
+T14F9.1	F07B10.1
+T14F9.3	F07B10.1
+T19B10.3	F07B10.1
+T20G5.1	F07B10.1
+T23D8.2	F07B10.1
+T28H10.3	F07B10.1
+VW02B12L.1	F07B10.1
+W03G1.7	F07B10.1
+W04G3.4	F07B10.1
+W07B8.1	F07B10.1
+W07B8.4	F07B10.1
+W07B8.5	F07B10.1
+W09G10.4	F07B10.1
+Y105E8A.9	F07B10.1
+Y105E8B.9	F07B10.1
+Y16B4A.2	F07B10.1
+Y38F2AL.4	F07B10.1
+Y40D12A.2	F07B10.1
+Y48G8AL.14	F07B10.1
+Y49E10.20	F07B10.1
+Y4C6B.6	F07B10.1
+Y50E8A.16	F07B10.1
+Y53G8AR.7	F07B10.1
+Y55H10A.1	F07B10.1
+Y69A2AR.4	F07B10.1
+ZK455.4	F07B10.1
+ZK484.2	F07B10.1
+ZK637.8	F07B10.1
+F11E6.1	F09G8.2
+F13D12.6	F09G8.2
+F29G9.3	F09G8.2
+F32B5.8	F09G8.2
+F32H5.1	F09G8.2
+F35H10.4	F09G8.2
+F36D3.9	F09G8.2
+F41C3.5	F09G8.2
+F41E6.6	F09G8.2
+F44C4.3	F09G8.2
+F44C4.5	F09G8.2
+F52E1.10	F09G8.2
+F53H8.1	F09G8.2
+F55A12.7	F09G8.2
+F55D10.1	F09G8.2
+F57F5.1	F09G8.2
+K04H4.6	F09G8.2
+K09E4.4	F09G8.2
+K11D2.2	F09G8.2
+K11D2.3	F09G8.2
+K11G12.3	F09G8.2
+K11G12.4	F09G8.2
+M04G12.2	F09G8.2
+M05B5.4	F09G8.2
+R04B3.2	F09G8.2
+R07E4.4	F09G8.2
+R10E11.2	F09G8.2
+R10E11.8	F09G8.2
+R11A5.1	F09G8.2
+R12H7.2	F09G8.2
+R148.6	F09G8.2
+T01H3.1	F09G8.2
+T03E6.7	F09G8.2
+T10H4.12	F09G8.2
+T14F9.1	F09G8.2
+T14F9.3	F09G8.2
+T19B10.3	F09G8.2
+T20G5.1	F09G8.2
+T23D8.2	F09G8.2
+T28H10.3	F09G8.2
+VW02B12L.1	F09G8.2
+W03G1.7	F09G8.2
+W04G3.4	F09G8.2
+W07B8.1	F09G8.2
+W07B8.4	F09G8.2
+W07B8.5	F09G8.2
+W09G10.4	F09G8.2
+Y105E8A.9	F09G8.2
+Y105E8B.9	F09G8.2
+Y16B4A.2	F09G8.2
+Y38F2AL.4	F09G8.2
+Y40D12A.2	F09G8.2
+Y48G8AL.14	F09G8.2
+Y49E10.20	F09G8.2
+Y4C6B.6	F09G8.2
+Y50E8A.16	F09G8.2
+Y53G8AR.7	F09G8.2
+Y55H10A.1	F09G8.2
+Y69A2AR.4	F09G8.2
+ZK455.4	F09G8.2
+ZK484.2	F09G8.2
+ZK637.8	F09G8.2
+F13D12.6	F11E6.1
+F29G9.3	F11E6.1
+F32B5.8	F11E6.1
+F32H5.1	F11E6.1
+F35H10.4	F11E6.1
+F36D3.9	F11E6.1
+F41C3.5	F11E6.1
+F41E6.6	F11E6.1
+F44C4.3	F11E6.1
+F44C4.5	F11E6.1
+F52E1.10	F11E6.1
+F53H8.1	F11E6.1
+F55A12.7	F11E6.1
+F57F5.1	F11E6.1
+K04H4.6	F11E6.1
+K09E4.4	F11E6.1
+K11D2.3	F11E6.1
+K11G12.3	F11E6.1
+K11G12.4	F11E6.1
+M04G12.2	F11E6.1
+M05B5.4	F11E6.1
+R07E4.4	F11E6.1
+R10E11.2	F11E6.1
+R10E11.8	F11E6.1
+R11A5.1	F11E6.1
+R12H7.2	F11E6.1
+R148.6	F11E6.1
+T01H3.1	F11E6.1
+T03E6.7	F11E6.1
+T10H4.12	F11E6.1
+T14F9.1	F11E6.1
+T20G5.1	F11E6.1
+T23D8.2	F11E6.1
+T28H10.3	F11E6.1
+VW02B12L.1	F11E6.1
+W04G3.4	F11E6.1
+W07B8.1	F11E6.1
+W07B8.4	F11E6.1
+W07B8.5	F11E6.1
+W09G10.4	F11E6.1
+Y105E8A.9	F11E6.1
+Y105E8B.9	F11E6.1
+Y16B4A.2	F11E6.1
+Y38F2AL.4	F11E6.1
+Y40D12A.2	F11E6.1
+Y48G8AL.14	F11E6.1
+Y49E10.20	F11E6.1
+Y50E8A.16	F11E6.1
+Y53G8AR.7	F11E6.1
+Y55H10A.1	F11E6.1
+Y69A2AR.4	F11E6.1
+ZK484.2	F11E6.1
+ZK637.8	F11E6.1
+F29G9.3	F13D12.6
+F32B5.8	F13D12.6
+F32H5.1	F13D12.6
+F35H10.4	F13D12.6
+F36D3.9	F13D12.6
+F41C3.5	F13D12.6
+F41E6.6	F13D12.6
+F44C4.3	F13D12.6
+F44C4.5	F13D12.6
+F52E1.10	F13D12.6
+F53H8.1	F13D12.6
+F55A12.7	F13D12.6
+F55D10.1	F13D12.6
+F57F5.1	F13D12.6
+K04H4.6	F13D12.6
+K09E4.4	F13D12.6
+K11D2.2	F13D12.6
+K11D2.3	F13D12.6
+K11G12.3	F13D12.6
+K11G12.4	F13D12.6
+M04G12.2	F13D12.6
+M05B5.4	F13D12.6
+R04B3.2	F13D12.6
+R07E4.4	F13D12.6
+R10E11.2	F13D12.6
+R10E11.8	F13D12.6
+R11A5.1	F13D12.6
+R12H7.2	F13D12.6
+R148.6	F13D12.6
+T01H3.1	F13D12.6
+T03E6.7	F13D12.6
+T10H4.12	F13D12.6
+T14F9.1	F13D12.6
+T14F9.3	F13D12.6
+T19B10.3	F13D12.6
+T20G5.1	F13D12.6
+T23D8.2	F13D12.6
+T28H10.3	F13D12.6
+VW02B12L.1	F13D12.6
+W03G1.7	F13D12.6
+W04G3.4	F13D12.6
+W07B8.1	F13D12.6
+W07B8.4	F13D12.6
+W07B8.5	F13D12.6
+W09G10.4	F13D12.6
+Y105E8A.9	F13D12.6
+Y105E8B.9	F13D12.6
+Y16B4A.2	F13D12.6
+Y38F2AL.4	F13D12.6
+Y40D12A.2	F13D12.6
+Y48G8AL.14	F13D12.6
+Y49E10.20	F13D12.6
+Y4C6B.6	F13D12.6
+Y50E8A.16	F13D12.6
+Y53G8AR.7	F13D12.6
+Y55H10A.1	F13D12.6
+Y69A2AR.4	F13D12.6
+ZK455.4	F13D12.6
+ZK484.2	F13D12.6
+ZK637.8	F13D12.6
+F32B5.8	F29G9.3
+F32H5.1	F29G9.3
+F35H10.4	F29G9.3
+F36D3.9	F29G9.3
+F41C3.5	F29G9.3
+F41E6.6	F29G9.3
+F44C4.3	F29G9.3
+F44C4.5	F29G9.3
+F52E1.10	F29G9.3
+F53H8.1	F29G9.3
+F55A12.7	F29G9.3
+F55D10.1	F29G9.3
+F57F5.1	F29G9.3
+K04H4.6	F29G9.3
+K09E4.4	F29G9.3
+K11D2.2	F29G9.3
+K11D2.3	F29G9.3
+K11G12.3	F29G9.3
+K11G12.4	F29G9.3
+M04G12.2	F29G9.3
+M05B5.4	F29G9.3
+R04B3.2	F29G9.3
+R07E4.4	F29G9.3
+R10E11.2	F29G9.3
+R10E11.8	F29G9.3
+R11A5.1	F29G9.3
+R12H7.2	F29G9.3
+R148.6	F29G9.3
+T01H3.1	F29G9.3
+T03E6.7	F29G9.3
+T10H4.12	F29G9.3
+T14F9.1	F29G9.3
+T14F9.3	F29G9.3
+T19B10.3	F29G9.3
+T20G5.1	F29G9.3
+T23D8.2	F29G9.3
+T28H10.3	F29G9.3
+VW02B12L.1	F29G9.3
+W03G1.7	F29G9.3
+W04G3.4	F29G9.3
+W07B8.1	F29G9.3
+W07B8.4	F29G9.3
+W07B8.5	F29G9.3
+W09G10.4	F29G9.3
+Y105E8A.9	F29G9.3
+Y105E8B.9	F29G9.3
+Y16B4A.2	F29G9.3
+Y38F2AL.4	F29G9.3
+Y40D12A.2	F29G9.3
+Y48G8AL.14	F29G9.3
+Y49E10.20	F29G9.3
+Y4C6B.6	F29G9.3
+Y50E8A.16	F29G9.3
+Y53G8AR.7	F29G9.3
+Y55H10A.1	F29G9.3
+Y69A2AR.4	F29G9.3
+ZK455.4	F29G9.3
+ZK484.2	F29G9.3
+ZK637.8	F29G9.3
+F32H5.1	F32B5.8
+F35H10.4	F32B5.8
+F36D3.9	F32B5.8
+F41C3.5	F32B5.8
+F41E6.6	F32B5.8
+F44C4.3	F32B5.8
+F44C4.5	F32B5.8
+F52E1.10	F32B5.8
+F53H8.1	F32B5.8
+F55A12.7	F32B5.8
+F55D10.1	F32B5.8
+F57F5.1	F32B5.8
+K04H4.6	F32B5.8
+K09E4.4	F32B5.8
+K11D2.2	F32B5.8
+K11D2.3	F32B5.8
+K11G12.3	F32B5.8
+K11G12.4	F32B5.8
+M04G12.2	F32B5.8
+M05B5.4	F32B5.8
+R04B3.2	F32B5.8
+R07E4.4	F32B5.8
+R10E11.2	F32B5.8
+R10E11.8	F32B5.8
+R11A5.1	F32B5.8
+R12H7.2	F32B5.8
+R148.6	F32B5.8
+T01H3.1	F32B5.8
+T03E6.7	F32B5.8
+T10H4.12	F32B5.8
+T14F9.1	F32B5.8
+T14F9.3	F32B5.8
+T19B10.3	F32B5.8
+T20G5.1	F32B5.8
+T23D8.2	F32B5.8
+T28H10.3	F32B5.8
+VW02B12L.1	F32B5.8
+W03G1.7	F32B5.8
+W04G3.4	F32B5.8
+W07B8.1	F32B5.8
+W07B8.4	F32B5.8
+W07B8.5	F32B5.8
+W09G10.4	F32B5.8
+Y105E8A.9	F32B5.8
+Y105E8B.9	F32B5.8
+Y16B4A.2	F32B5.8
+Y38F2AL.4	F32B5.8
+Y40D12A.2	F32B5.8
+Y48G8AL.14	F32B5.8
+Y49E10.20	F32B5.8
+Y4C6B.6	F32B5.8
+Y50E8A.16	F32B5.8
+Y53G8AR.7	F32B5.8
+Y55H10A.1	F32B5.8
+Y69A2AR.4	F32B5.8
+ZK455.4	F32B5.8
+ZK484.2	F32B5.8
+ZK637.8	F32B5.8
+F35H10.4	F32H5.1
+F36D3.9	F32H5.1
+F41C3.5	F32H5.1
+F41E6.6	F32H5.1
+F44C4.3	F32H5.1
+F44C4.5	F32H5.1
+F52E1.10	F32H5.1
+F53H8.1	F32H5.1
+F55A12.7	F32H5.1
+F55D10.1	F32H5.1
+F57F5.1	F32H5.1
+K04H4.6	F32H5.1
+K09E4.4	F32H5.1
+K11D2.2	F32H5.1
+K11D2.3	F32H5.1
+K11G12.3	F32H5.1
+K11G12.4	F32H5.1
+M04G12.2	F32H5.1
+M05B5.4	F32H5.1
+R04B3.2	F32H5.1
+R07E4.4	F32H5.1
+R10E11.2	F32H5.1
+R10E11.8	F32H5.1
+R11A5.1	F32H5.1
+R12H7.2	F32H5.1
+R148.6	F32H5.1
+T01H3.1	F32H5.1
+T03E6.7	F32H5.1
+T10H4.12	F32H5.1
+T14F9.1	F32H5.1
+T14F9.3	F32H5.1
+T19B10.3	F32H5.1
+T20G5.1	F32H5.1
+T23D8.2	F32H5.1
+T28H10.3	F32H5.1
+VW02B12L.1	F32H5.1
+W03G1.7	F32H5.1
+W04G3.4	F32H5.1
+W07B8.1	F32H5.1
+W07B8.4	F32H5.1
+W07B8.5	F32H5.1
+W09G10.4	F32H5.1
+Y105E8A.9	F32H5.1
+Y105E8B.9	F32H5.1
+Y16B4A.2	F32H5.1
+Y38F2AL.4	F32H5.1
+Y40D12A.2	F32H5.1
+Y48G8AL.14	F32H5.1
+Y49E10.20	F32H5.1
+Y4C6B.6	F32H5.1
+Y50E8A.16	F32H5.1
+Y53G8AR.7	F32H5.1
+Y55H10A.1	F32H5.1
+Y69A2AR.4	F32H5.1
+ZK455.4	F32H5.1
+ZK484.2	F32H5.1
+ZK637.8	F32H5.1
+F36D3.9	F35H10.4
+F41C3.5	F35H10.4
+F41E6.6	F35H10.4
+F44C4.3	F35H10.4
+F44C4.5	F35H10.4
+F53H8.1	F35H10.4
+F55A12.7	F35H10.4
+F55D10.1	F35H10.4
+F57F5.1	F35H10.4
+K04H4.6	F35H10.4
+K09E4.4	F35H10.4
+K11D2.2	F35H10.4
+K11D2.3	F35H10.4
+K11G12.3	F35H10.4
+K11G12.4	F35H10.4
+M04G12.2	F35H10.4
+M05B5.4	F35H10.4
+R04B3.2	F35H10.4
+R07E4.4	F35H10.4
+R11A5.1	F35H10.4
+R12H7.2	F35H10.4
+R148.6	F35H10.4
+T03E6.7	F35H10.4
+T10H4.12	F35H10.4
+T14F9.3	F35H10.4
+T19B10.3	F35H10.4
+T20G5.1	F35H10.4
+T23D8.2	F35H10.4
+T28H10.3	F35H10.4
+W03G1.7	F35H10.4
+W04G3.4	F35H10.4
+W07B8.1	F35H10.4
+W07B8.4	F35H10.4
+W07B8.5	F35H10.4
+W09G10.4	F35H10.4
+Y105E8A.9	F35H10.4
+Y105E8B.9	F35H10.4
+Y16B4A.2	F35H10.4
+Y40D12A.2	F35H10.4
+Y48G8AL.14	F35H10.4
+Y49E10.20	F35H10.4
+Y4C6B.6	F35H10.4
+Y50E8A.16	F35H10.4
+Y53G8AR.7	F35H10.4
+Y69A2AR.4	F35H10.4
+ZK455.4	F35H10.4
+ZK484.2	F35H10.4
+F41C3.5	F36D3.9
+F41E6.6	F36D3.9
+F44C4.3	F36D3.9
+F44C4.5	F36D3.9
+F52E1.10	F36D3.9
+F53H8.1	F36D3.9
+F55A12.7	F36D3.9
+F55D10.1	F36D3.9
+F57F5.1	F36D3.9
+K04H4.6	F36D3.9
+K09E4.4	F36D3.9
+K11D2.2	F36D3.9
+K11D2.3	F36D3.9
+K11G12.3	F36D3.9
+K11G12.4	F36D3.9
+M04G12.2	F36D3.9
+M05B5.4	F36D3.9
+R04B3.2	F36D3.9
+R07E4.4	F36D3.9
+R10E11.2	F36D3.9
+R10E11.8	F36D3.9
+R11A5.1	F36D3.9
+R12H7.2	F36D3.9
+R148.6	F36D3.9
+T01H3.1	F36D3.9
+T03E6.7	F36D3.9
+T10H4.12	F36D3.9
+T14F9.1	F36D3.9
+T14F9.3	F36D3.9
+T19B10.3	F36D3.9
+T20G5.1	F36D3.9
+T23D8.2	F36D3.9
+T28H10.3	F36D3.9
+VW02B12L.1	F36D3.9
+W03G1.7	F36D3.9
+W04G3.4	F36D3.9
+W07B8.1	F36D3.9
+W07B8.4	F36D3.9
+W07B8.5	F36D3.9
+W09G10.4	F36D3.9
+Y105E8A.9	F36D3.9
+Y105E8B.9	F36D3.9
+Y16B4A.2	F36D3.9
+Y38F2AL.4	F36D3.9
+Y40D12A.2	F36D3.9
+Y48G8AL.14	F36D3.9
+Y49E10.20	F36D3.9
+Y4C6B.6	F36D3.9
+Y50E8A.16	F36D3.9
+Y53G8AR.7	F36D3.9
+Y55H10A.1	F36D3.9
+Y69A2AR.4	F36D3.9
+ZK455.4	F36D3.9
+ZK484.2	F36D3.9
+ZK637.8	F36D3.9
+F41E6.6	F41C3.5
+F44C4.3	F41C3.5
+F44C4.5	F41C3.5
+F52E1.10	F41C3.5
+F53H8.1	F41C3.5
+F55A12.7	F41C3.5
+F55D10.1	F41C3.5
+F57F5.1	F41C3.5
+K04H4.6	F41C3.5
+K09E4.4	F41C3.5
+K11D2.2	F41C3.5
+K11D2.3	F41C3.5
+K11G12.3	F41C3.5
+K11G12.4	F41C3.5
+M04G12.2	F41C3.5
+M05B5.4	F41C3.5
+R04B3.2	F41C3.5
+R07E4.4	F41C3.5
+R10E11.2	F41C3.5
+R10E11.8	F41C3.5
+R11A5.1	F41C3.5
+R12H7.2	F41C3.5
+R148.6	F41C3.5
+T01H3.1	F41C3.5
+T03E6.7	F41C3.5
+T10H4.12	F41C3.5
+T14F9.1	F41C3.5
+T14F9.3	F41C3.5
+T19B10.3	F41C3.5
+T20G5.1	F41C3.5
+T23D8.2	F41C3.5
+T28H10.3	F41C3.5
+VW02B12L.1	F41C3.5
+W03G1.7	F41C3.5
+W04G3.4	F41C3.5
+W07B8.1	F41C3.5
+W07B8.4	F41C3.5
+W07B8.5	F41C3.5
+W09G10.4	F41C3.5
+Y105E8A.9	F41C3.5
+Y105E8B.9	F41C3.5
+Y16B4A.2	F41C3.5
+Y38F2AL.4	F41C3.5
+Y40D12A.2	F41C3.5
+Y48G8AL.14	F41C3.5
+Y49E10.20	F41C3.5
+Y4C6B.6	F41C3.5
+Y50E8A.16	F41C3.5
+Y53G8AR.7	F41C3.5
+Y55H10A.1	F41C3.5
+Y69A2AR.4	F41C3.5
+ZK455.4	F41C3.5
+ZK484.2	F41C3.5
+ZK637.8	F41C3.5
+F44C4.3	F41E6.6
+F44C4.5	F41E6.6
+F52E1.10	F41E6.6
+F53H8.1	F41E6.6
+F55A12.7	F41E6.6
+F55D10.1	F41E6.6
+F57F5.1	F41E6.6
+K04H4.6	F41E6.6
+K09E4.4	F41E6.6
+K11D2.2	F41E6.6
+K11D2.3	F41E6.6
+K11G12.3	F41E6.6
+K11G12.4	F41E6.6
+M04G12.2	F41E6.6
+M05B5.4	F41E6.6
+R04B3.2	F41E6.6
+R07E4.4	F41E6.6
+R10E11.2	F41E6.6
+R10E11.8	F41E6.6
+R11A5.1	F41E6.6
+R12H7.2	F41E6.6
+R148.6	F41E6.6
+T01H3.1	F41E6.6
+T03E6.7	F41E6.6
+T10H4.12	F41E6.6
+T14F9.1	F41E6.6
+T14F9.3	F41E6.6
+T19B10.3	F41E6.6
+T20G5.1	F41E6.6
+T23D8.2	F41E6.6
+T28H10.3	F41E6.6
+VW02B12L.1	F41E6.6
+W03G1.7	F41E6.6
+W04G3.4	F41E6.6
+W07B8.1	F41E6.6
+W07B8.4	F41E6.6
+W07B8.5	F41E6.6
+W09G10.4	F41E6.6
+Y105E8A.9	F41E6.6
+Y105E8B.9	F41E6.6
+Y16B4A.2	F41E6.6
+Y38F2AL.4	F41E6.6
+Y40D12A.2	F41E6.6
+Y48G8AL.14	F41E6.6
+Y49E10.20	F41E6.6
+Y4C6B.6	F41E6.6
+Y50E8A.16	F41E6.6
+Y53G8AR.7	F41E6.6
+Y55H10A.1	F41E6.6
+Y69A2AR.4	F41E6.6
+ZK455.4	F41E6.6
+ZK484.2	F41E6.6
+ZK637.8	F41E6.6
+F44C4.5	F44C4.3
+F52E1.10	F44C4.3
+F53H8.1	F44C4.3
+F55A12.7	F44C4.3
+F55D10.1	F44C4.3
+F57F5.1	F44C4.3
+K04H4.6	F44C4.3
+K09E4.4	F44C4.3
+K11D2.2	F44C4.3
+K11D2.3	F44C4.3
+K11G12.3	F44C4.3
+K11G12.4	F44C4.3
+M04G12.2	F44C4.3
+M05B5.4	F44C4.3
+R04B3.2	F44C4.3
+R07E4.4	F44C4.3
+R10E11.2	F44C4.3
+R10E11.8	F44C4.3
+R11A5.1	F44C4.3
+R12H7.2	F44C4.3
+R148.6	F44C4.3
+T01H3.1	F44C4.3
+T03E6.7	F44C4.3
+T10H4.12	F44C4.3
+T14F9.1	F44C4.3
+T14F9.3	F44C4.3
+T19B10.3	F44C4.3
+T20G5.1	F44C4.3
+T23D8.2	F44C4.3
+T28H10.3	F44C4.3
+VW02B12L.1	F44C4.3
+W03G1.7	F44C4.3
+W04G3.4	F44C4.3
+W07B8.1	F44C4.3
+W07B8.4	F44C4.3
+W07B8.5	F44C4.3
+W09G10.4	F44C4.3
+Y105E8A.9	F44C4.3
+Y105E8B.9	F44C4.3
+Y16B4A.2	F44C4.3
+Y38F2AL.4	F44C4.3
+Y40D12A.2	F44C4.3
+Y48G8AL.14	F44C4.3
+Y49E10.20	F44C4.3
+Y4C6B.6	F44C4.3
+Y50E8A.16	F44C4.3
+Y53G8AR.7	F44C4.3
+Y55H10A.1	F44C4.3
+Y69A2AR.4	F44C4.3
+ZK455.4	F44C4.3
+ZK484.2	F44C4.3
+ZK637.8	F44C4.3
+F52E1.10	F44C4.5
+F53H8.1	F44C4.5
+F55A12.7	F44C4.5
+F55D10.1	F44C4.5
+F57F5.1	F44C4.5
+K04H4.6	F44C4.5
+K09E4.4	F44C4.5
+K11D2.2	F44C4.5
+K11D2.3	F44C4.5
+K11G12.3	F44C4.5
+K11G12.4	F44C4.5
+M04G12.2	F44C4.5
+M05B5.4	F44C4.5
+R04B3.2	F44C4.5
+R07E4.4	F44C4.5
+R10E11.2	F44C4.5
+R10E11.8	F44C4.5
+R11A5.1	F44C4.5
+R12H7.2	F44C4.5
+R148.6	F44C4.5
+T01H3.1	F44C4.5
+T03E6.7	F44C4.5
+T10H4.12	F44C4.5
+T14F9.1	F44C4.5
+T14F9.3	F44C4.5
+T19B10.3	F44C4.5
+T20G5.1	F44C4.5
+T23D8.2	F44C4.5
+T28H10.3	F44C4.5
+VW02B12L.1	F44C4.5
+W03G1.7	F44C4.5
+W04G3.4	F44C4.5
+W07B8.1	F44C4.5
+W07B8.4	F44C4.5
+W07B8.5	F44C4.5
+W09G10.4	F44C4.5
+Y105E8A.9	F44C4.5
+Y105E8B.9	F44C4.5
+Y16B4A.2	F44C4.5
+Y38F2AL.4	F44C4.5
+Y40D12A.2	F44C4.5
+Y48G8AL.14	F44C4.5
+Y49E10.20	F44C4.5
+Y4C6B.6	F44C4.5
+Y50E8A.16	F44C4.5
+Y53G8AR.7	F44C4.5
+Y55H10A.1	F44C4.5
+Y69A2AR.4	F44C4.5
+ZK455.4	F44C4.5
+ZK484.2	F44C4.5
+ZK637.8	F44C4.5
+F53H8.1	F52E1.10
+F55A12.7	F52E1.10
+F55D10.1	F52E1.10
+F57F5.1	F52E1.10
+K04H4.6	F52E1.10
+K09E4.4	F52E1.10
+K11D2.2	F52E1.10
+K11D2.3	F52E1.10
+K11G12.3	F52E1.10
+K11G12.4	F52E1.10
+M04G12.2	F52E1.10
+M05B5.4	F52E1.10
+R04B3.2	F52E1.10
+R07E4.4	F52E1.10
+R11A5.1	F52E1.10
+R12H7.2	F52E1.10
+R148.6	F52E1.10
+T03E6.7	F52E1.10
+T10H4.12	F52E1.10
+T14F9.3	F52E1.10
+T19B10.3	F52E1.10
+T20G5.1	F52E1.10
+T23D8.2	F52E1.10
+T28H10.3	F52E1.10
+W03G1.7	F52E1.10
+W04G3.4	F52E1.10
+W07B8.1	F52E1.10
+W07B8.4	F52E1.10
+W07B8.5	F52E1.10
+W09G10.4	F52E1.10
+Y105E8A.9	F52E1.10
+Y105E8B.9	F52E1.10
+Y16B4A.2	F52E1.10
+Y40D12A.2	F52E1.10
+Y48G8AL.14	F52E1.10
+Y49E10.20	F52E1.10
+Y4C6B.6	F52E1.10
+Y50E8A.16	F52E1.10
+Y53G8AR.7	F52E1.10
+Y69A2AR.4	F52E1.10
+ZK455.4	F52E1.10
+ZK484.2	F52E1.10
+F55A12.7	F53H8.1
+F55D10.1	F53H8.1
+F57F5.1	F53H8.1
+K04H4.6	F53H8.1
+K09E4.4	F53H8.1
+K11D2.2	F53H8.1
+K11D2.3	F53H8.1
+K11G12.3	F53H8.1
+K11G12.4	F53H8.1
+M04G12.2	F53H8.1
+M05B5.4	F53H8.1
+R04B3.2	F53H8.1
+R07E4.4	F53H8.1
+R10E11.2	F53H8.1
+R10E11.8	F53H8.1
+R11A5.1	F53H8.1
+R12H7.2	F53H8.1
+R148.6	F53H8.1
+T01H3.1	F53H8.1
+T03E6.7	F53H8.1
+T10H4.12	F53H8.1
+T14F9.1	F53H8.1
+T14F9.3	F53H8.1
+T19B10.3	F53H8.1
+T20G5.1	F53H8.1
+T23D8.2	F53H8.1
+T28H10.3	F53H8.1
+VW02B12L.1	F53H8.1
+W03G1.7	F53H8.1
+W04G3.4	F53H8.1
+W07B8.1	F53H8.1
+W07B8.4	F53H8.1
+W07B8.5	F53H8.1
+W09G10.4	F53H8.1
+Y105E8A.9	F53H8.1
+Y105E8B.9	F53H8.1
+Y16B4A.2	F53H8.1
+Y38F2AL.4	F53H8.1
+Y40D12A.2	F53H8.1
+Y48G8AL.14	F53H8.1
+Y49E10.20	F53H8.1
+Y4C6B.6	F53H8.1
+Y50E8A.16	F53H8.1
+Y53G8AR.7	F53H8.1
+Y55H10A.1	F53H8.1
+Y69A2AR.4	F53H8.1
+ZK455.4	F53H8.1
+ZK484.2	F53H8.1
+ZK637.8	F53H8.1
+F55D10.1	F55A12.7
+F57F5.1	F55A12.7
+K04H4.6	F55A12.7
+K09E4.4	F55A12.7
+K11D2.2	F55A12.7
+K11D2.3	F55A12.7
+K11G12.3	F55A12.7
+K11G12.4	F55A12.7
+M04G12.2	F55A12.7
+M05B5.4	F55A12.7
+R04B3.2	F55A12.7
+R07E4.4	F55A12.7
+R10E11.2	F55A12.7
+R10E11.8	F55A12.7
+R11A5.1	F55A12.7
+R12H7.2	F55A12.7
+R148.6	F55A12.7
+T01H3.1	F55A12.7
+T03E6.7	F55A12.7
+T10H4.12	F55A12.7
+T14F9.1	F55A12.7
+T14F9.3	F55A12.7
+T19B10.3	F55A12.7
+T20G5.1	F55A12.7
+T23D8.2	F55A12.7
+T28H10.3	F55A12.7
+VW02B12L.1	F55A12.7
+W03G1.7	F55A12.7
+W04G3.4	F55A12.7
+W07B8.1	F55A12.7
+W07B8.4	F55A12.7
+W07B8.5	F55A12.7
+W09G10.4	F55A12.7
+Y105E8A.9	F55A12.7
+Y105E8B.9	F55A12.7
+Y16B4A.2	F55A12.7
+Y38F2AL.4	F55A12.7
+Y40D12A.2	F55A12.7
+Y48G8AL.14	F55A12.7
+Y49E10.20	F55A12.7
+Y4C6B.6	F55A12.7
+Y50E8A.16	F55A12.7
+Y53G8AR.7	F55A12.7
+Y55H10A.1	F55A12.7
+Y69A2AR.4	F55A12.7
+ZK455.4	F55A12.7
+ZK484.2	F55A12.7
+ZK637.8	F55A12.7
+F57F5.1	F55D10.1
+K04H4.6	F55D10.1
+K09E4.4	F55D10.1
+K11D2.2	F55D10.1
+K11D2.3	F55D10.1
+K11G12.3	F55D10.1
+K11G12.4	F55D10.1
+M04G12.2	F55D10.1
+M05B5.4	F55D10.1
+R07E4.4	F55D10.1
+R10E11.2	F55D10.1
+R10E11.8	F55D10.1
+R11A5.1	F55D10.1
+R12H7.2	F55D10.1
+R148.6	F55D10.1
+T01H3.1	F55D10.1
+T03E6.7	F55D10.1
+T10H4.12	F55D10.1
+T14F9.1	F55D10.1
+T20G5.1	F55D10.1
+T23D8.2	F55D10.1
+T28H10.3	F55D10.1
+VW02B12L.1	F55D10.1
+W03G1.7	F55D10.1
+W04G3.4	F55D10.1
+W07B8.1	F55D10.1
+W07B8.4	F55D10.1
+W07B8.5	F55D10.1
+W09G10.4	F55D10.1
+Y105E8A.9	F55D10.1
+Y105E8B.9	F55D10.1
+Y16B4A.2	F55D10.1
+Y38F2AL.4	F55D10.1
+Y40D12A.2	F55D10.1
+Y48G8AL.14	F55D10.1
+Y49E10.20	F55D10.1
+Y50E8A.16	F55D10.1
+Y53G8AR.7	F55D10.1
+Y55H10A.1	F55D10.1
+Y69A2AR.4	F55D10.1
+ZK455.4	F55D10.1
+ZK484.2	F55D10.1
+ZK637.8	F55D10.1
+K04H4.6	F57F5.1
+K09E4.4	F57F5.1
+K11D2.2	F57F5.1
+K11D2.3	F57F5.1
+K11G12.3	F57F5.1
+K11G12.4	F57F5.1
+M04G12.2	F57F5.1
+M05B5.4	F57F5.1
+R04B3.2	F57F5.1
+R07E4.4	F57F5.1
+R10E11.2	F57F5.1
+R10E11.8	F57F5.1
+R11A5.1	F57F5.1
+R12H7.2	F57F5.1
+R148.6	F57F5.1
+T01H3.1	F57F5.1
+T03E6.7	F57F5.1
+T10H4.12	F57F5.1
+T14F9.1	F57F5.1
+T14F9.3	F57F5.1
+T19B10.3	F57F5.1
+T20G5.1	F57F5.1
+T23D8.2	F57F5.1
+T28H10.3	F57F5.1
+VW02B12L.1	F57F5.1
+W03G1.7	F57F5.1
+W04G3.4	F57F5.1
+W07B8.1	F57F5.1
+W07B8.4	F57F5.1
+W07B8.5	F57F5.1
+W09G10.4	F57F5.1
+Y105E8A.9	F57F5.1
+Y105E8B.9	F57F5.1
+Y16B4A.2	F57F5.1
+Y38F2AL.4	F57F5.1
+Y40D12A.2	F57F5.1
+Y48G8AL.14	F57F5.1
+Y49E10.20	F57F5.1
+Y4C6B.6	F57F5.1
+Y50E8A.16	F57F5.1
+Y53G8AR.7	F57F5.1
+Y55H10A.1	F57F5.1
+Y69A2AR.4	F57F5.1
+ZK455.4	F57F5.1
+ZK484.2	F57F5.1
+ZK637.8	F57F5.1
+K09E4.4	K04H4.6
+K11D2.2	K04H4.6
+K11D2.3	K04H4.6
+K11G12.3	K04H4.6
+K11G12.4	K04H4.6
+M04G12.2	K04H4.6
+M05B5.4	K04H4.6
+R04B3.2	K04H4.6
+R07E4.4	K04H4.6
+R10E11.2	K04H4.6
+R10E11.8	K04H4.6
+R11A5.1	K04H4.6
+R12H7.2	K04H4.6
+R148.6	K04H4.6
+T01H3.1	K04H4.6
+T03E6.7	K04H4.6
+T10H4.12	K04H4.6
+T14F9.1	K04H4.6
+T14F9.3	K04H4.6
+T19B10.3	K04H4.6
+T20G5.1	K04H4.6
+T23D8.2	K04H4.6
+T28H10.3	K04H4.6
+VW02B12L.1	K04H4.6
+W03G1.7	K04H4.6
+W04G3.4	K04H4.6
+W07B8.1	K04H4.6
+W07B8.4	K04H4.6
+W07B8.5	K04H4.6
+W09G10.4	K04H4.6
+Y105E8A.9	K04H4.6
+Y105E8B.9	K04H4.6
+Y16B4A.2	K04H4.6
+Y38F2AL.4	K04H4.6
+Y40D12A.2	K04H4.6
+Y48G8AL.14	K04H4.6
+Y49E10.20	K04H4.6
+Y4C6B.6	K04H4.6
+Y50E8A.16	K04H4.6
+Y53G8AR.7	K04H4.6
+Y55H10A.1	K04H4.6
+Y69A2AR.4	K04H4.6
+ZK455.4	K04H4.6
+ZK484.2	K04H4.6
+ZK637.8	K04H4.6
+K11D2.2	K09E4.4
+K11D2.3	K09E4.4
+K11G12.3	K09E4.4
+K11G12.4	K09E4.4
+M04G12.2	K09E4.4
+M05B5.4	K09E4.4
+R04B3.2	K09E4.4
+R07E4.4	K09E4.4
+R10E11.2	K09E4.4
+R10E11.8	K09E4.4
+R11A5.1	K09E4.4
+R12H7.2	K09E4.4
+R148.6	K09E4.4
+T01H3.1	K09E4.4
+T03E6.7	K09E4.4
+T10H4.12	K09E4.4
+T14F9.1	K09E4.4
+T20G5.1	K09E4.4
+T23D8.2	K09E4.4
+T28H10.3	K09E4.4
+VW02B12L.1	K09E4.4
+W03G1.7	K09E4.4
+W04G3.4	K09E4.4
+W07B8.1	K09E4.4
+W07B8.4	K09E4.4
+W07B8.5	K09E4.4
+W09G10.4	K09E4.4
+Y105E8A.9	K09E4.4
+Y16B4A.2	K09E4.4
+Y38F2AL.4	K09E4.4
+Y40D12A.2	K09E4.4
+Y48G8AL.14	K09E4.4
+Y49E10.20	K09E4.4
+Y4C6B.6	K09E4.4
+Y50E8A.16	K09E4.4
+Y53G8AR.7	K09E4.4
+Y55H10A.1	K09E4.4
+Y69A2AR.4	K09E4.4
+ZK455.4	K09E4.4
+ZK484.2	K09E4.4
+ZK637.8	K09E4.4
+K11D2.3	K11D2.2
+K11G12.3	K11D2.2
+K11G12.4	K11D2.2
+M04G12.2	K11D2.2
+M05B5.4	K11D2.2
+R04B3.2	K11D2.2
+R07E4.4	K11D2.2
+R10E11.2	K11D2.2
+R10E11.8	K11D2.2
+R11A5.1	K11D2.2
+R12H7.2	K11D2.2
+R148.6	K11D2.2
+T01H3.1	K11D2.2
+T03E6.7	K11D2.2
+T10H4.12	K11D2.2
+T14F9.1	K11D2.2
+T14F9.3	K11D2.2
+T20G5.1	K11D2.2
+T23D8.2	K11D2.2
+T28H10.3	K11D2.2
+VW02B12L.1	K11D2.2
+W04G3.4	K11D2.2
+W07B8.1	K11D2.2
+W07B8.4	K11D2.2
+W07B8.5	K11D2.2
+W09G10.4	K11D2.2
+Y105E8A.9	K11D2.2
+Y105E8B.9	K11D2.2
+Y16B4A.2	K11D2.2
+Y38F2AL.4	K11D2.2
+Y40D12A.2	K11D2.2
+Y48G8AL.14	K11D2.2
+Y49E10.20	K11D2.2
+Y50E8A.16	K11D2.2
+Y53G8AR.7	K11D2.2
+Y55H10A.1	K11D2.2
+Y69A2AR.4	K11D2.2
+ZK484.2	K11D2.2
+ZK637.8	K11D2.2
+K11G12.3	K11D2.3
+K11G12.4	K11D2.3
+M04G12.2	K11D2.3
+M05B5.4	K11D2.3
+R04B3.2	K11D2.3
+R07E4.4	K11D2.3
+R10E11.2	K11D2.3
+R10E11.8	K11D2.3
+R11A5.1	K11D2.3
+R12H7.2	K11D2.3
+R148.6	K11D2.3
+T01H3.1	K11D2.3
+T03E6.7	K11D2.3
+T10H4.12	K11D2.3
+T14F9.1	K11D2.3
+T14F9.3	K11D2.3
+T19B10.3	K11D2.3
+T20G5.1	K11D2.3
+T23D8.2	K11D2.3
+T28H10.3	K11D2.3
+VW02B12L.1	K11D2.3
+W03G1.7	K11D2.3
+W04G3.4	K11D2.3
+W07B8.1	K11D2.3
+W07B8.4	K11D2.3
+W07B8.5	K11D2.3
+W09G10.4	K11D2.3
+Y105E8A.9	K11D2.3
+Y105E8B.9	K11D2.3
+Y16B4A.2	K11D2.3
+Y38F2AL.4	K11D2.3
+Y40D12A.2	K11D2.3
+Y48G8AL.14	K11D2.3
+Y49E10.20	K11D2.3
+Y4C6B.6	K11D2.3
+Y50E8A.16	K11D2.3
+Y53G8AR.7	K11D2.3
+Y55H10A.1	K11D2.3
+Y69A2AR.4	K11D2.3
+ZK455.4	K11D2.3
+ZK484.2	K11D2.3
+ZK637.8	K11D2.3
+M04G12.2	K11G12.3
+M05B5.4	K11G12.3
+R04B3.2	K11G12.3
+R07E4.4	K11G12.3
+R10E11.2	K11G12.3
+R10E11.8	K11G12.3
+R11A5.1	K11G12.3
+R12H7.2	K11G12.3
+R148.6	K11G12.3
+T01H3.1	K11G12.3
+T03E6.7	K11G12.3
+T10H4.12	K11G12.3
+T14F9.1	K11G12.3
+T14F9.3	K11G12.3
+T19B10.3	K11G12.3
+T20G5.1	K11G12.3
+T23D8.2	K11G12.3
+T28H10.3	K11G12.3
+VW02B12L.1	K11G12.3
+W03G1.7	K11G12.3
+W04G3.4	K11G12.3
+W07B8.1	K11G12.3
+W07B8.4	K11G12.3
+W07B8.5	K11G12.3
+W09G10.4	K11G12.3
+Y105E8A.9	K11G12.3
+Y105E8B.9	K11G12.3
+Y16B4A.2	K11G12.3
+Y38F2AL.4	K11G12.3
+Y40D12A.2	K11G12.3
+Y48G8AL.14	K11G12.3
+Y49E10.20	K11G12.3
+Y4C6B.6	K11G12.3
+Y50E8A.16	K11G12.3
+Y53G8AR.7	K11G12.3
+Y55H10A.1	K11G12.3
+ZK455.4	K11G12.3
+ZK484.2	K11G12.3
+ZK637.8	K11G12.3
+M04G12.2	K11G12.4
+M05B5.4	K11G12.4
+R04B3.2	K11G12.4
+R07E4.4	K11G12.4
+R10E11.2	K11G12.4
+R10E11.8	K11G12.4
+R11A5.1	K11G12.4
+R12H7.2	K11G12.4
+R148.6	K11G12.4
+T01H3.1	K11G12.4
+T03E6.7	K11G12.4
+T10H4.12	K11G12.4
+T14F9.1	K11G12.4
+T14F9.3	K11G12.4
+T19B10.3	K11G12.4
+T20G5.1	K11G12.4
+T23D8.2	K11G12.4
+T28H10.3	K11G12.4
+VW02B12L.1	K11G12.4
+W03G1.7	K11G12.4
+W04G3.4	K11G12.4
+W07B8.1	K11G12.4
+W07B8.4	K11G12.4
+W07B8.5	K11G12.4
+W09G10.4	K11G12.4
+Y105E8A.9	K11G12.4
+Y105E8B.9	K11G12.4
+Y16B4A.2	K11G12.4
+Y38F2AL.4	K11G12.4
+Y40D12A.2	K11G12.4
+Y48G8AL.14	K11G12.4
+Y49E10.20	K11G12.4
+Y4C6B.6	K11G12.4
+Y50E8A.16	K11G12.4
+Y53G8AR.7	K11G12.4
+Y55H10A.1	K11G12.4
+ZK455.4	K11G12.4
+ZK484.2	K11G12.4
+ZK637.8	K11G12.4
+M05B5.4	M04G12.2
+R04B3.2	M04G12.2
+R07E4.4	M04G12.2
+R10E11.2	M04G12.2
+R10E11.8	M04G12.2
+R11A5.1	M04G12.2
+R12H7.2	M04G12.2
+R148.6	M04G12.2
+T01H3.1	M04G12.2
+T03E6.7	M04G12.2
+T10H4.12	M04G12.2
+T14F9.1	M04G12.2
+T14F9.3	M04G12.2
+T19B10.3	M04G12.2
+T20G5.1	M04G12.2
+T23D8.2	M04G12.2
+T28H10.3	M04G12.2
+VW02B12L.1	M04G12.2
+W03G1.7	M04G12.2
+W04G3.4	M04G12.2
+W07B8.1	M04G12.2
+W07B8.4	M04G12.2
+W07B8.5	M04G12.2
+W09G10.4	M04G12.2
+Y105E8A.9	M04G12.2
+Y105E8B.9	M04G12.2
+Y16B4A.2	M04G12.2
+Y38F2AL.4	M04G12.2
+Y40D12A.2	M04G12.2
+Y48G8AL.14	M04G12.2
+Y49E10.20	M04G12.2
+Y4C6B.6	M04G12.2
+Y50E8A.16	M04G12.2
+Y53G8AR.7	M04G12.2
+Y55H10A.1	M04G12.2
+Y69A2AR.4	M04G12.2
+ZK455.4	M04G12.2
+ZK484.2	M04G12.2
+ZK637.8	M04G12.2
+R04B3.2	M05B5.4
+R07E4.4	M05B5.4
+R10E11.2	M05B5.4
+R10E11.8	M05B5.4
+R11A5.1	M05B5.4
+R12H7.2	M05B5.4
+R148.6	M05B5.4
+T01H3.1	M05B5.4
+T03E6.7	M05B5.4
+T10H4.12	M05B5.4
+T14F9.1	M05B5.4
+T14F9.3	M05B5.4
+T19B10.3	M05B5.4
+T20G5.1	M05B5.4
+T23D8.2	M05B5.4
+T28H10.3	M05B5.4
+VW02B12L.1	M05B5.4
+W03G1.7	M05B5.4
+W04G3.4	M05B5.4
+W07B8.1	M05B5.4
+W07B8.4	M05B5.4
+W07B8.5	M05B5.4
+W09G10.4	M05B5.4
+Y105E8A.9	M05B5.4
+Y105E8B.9	M05B5.4
+Y16B4A.2	M05B5.4
+Y38F2AL.4	M05B5.4
+Y40D12A.2	M05B5.4
+Y48G8AL.14	M05B5.4
+Y49E10.20	M05B5.4
+Y4C6B.6	M05B5.4
+Y50E8A.16	M05B5.4
+Y53G8AR.7	M05B5.4
+Y55H10A.1	M05B5.4
+Y69A2AR.4	M05B5.4
+ZK455.4	M05B5.4
+ZK484.2	M05B5.4
+ZK637.8	M05B5.4
+R07E4.4	R04B3.2
+R10E11.2	R04B3.2
+R10E11.8	R04B3.2
+R11A5.1	R04B3.2
+R12H7.2	R04B3.2
+R148.6	R04B3.2
+T01H3.1	R04B3.2
+T03E6.7	R04B3.2
+T10H4.12	R04B3.2
+T14F9.1	R04B3.2
+T20G5.1	R04B3.2
+T23D8.2	R04B3.2
+T28H10.3	R04B3.2
+VW02B12L.1	R04B3.2
+W03G1.7	R04B3.2
+W04G3.4	R04B3.2
+W07B8.1	R04B3.2
+W07B8.4	R04B3.2
+W07B8.5	R04B3.2
+W09G10.4	R04B3.2
+Y105E8A.9	R04B3.2
+Y105E8B.9	R04B3.2
+Y16B4A.2	R04B3.2
+Y38F2AL.4	R04B3.2
+Y40D12A.2	R04B3.2
+Y48G8AL.14	R04B3.2
+Y49E10.20	R04B3.2
+Y50E8A.16	R04B3.2
+Y53G8AR.7	R04B3.2
+Y55H10A.1	R04B3.2
+Y69A2AR.4	R04B3.2
+ZK455.4	R04B3.2
+ZK484.2	R04B3.2
+ZK637.8	R04B3.2
+R10E11.2	R07E4.4
+R10E11.8	R07E4.4
+R11A5.1	R07E4.4
+R12H7.2	R07E4.4
+R148.6	R07E4.4
+T01H3.1	R07E4.4
+T03E6.7	R07E4.4
+T10H4.12	R07E4.4
+T14F9.1	R07E4.4
+T14F9.3	R07E4.4
+T19B10.3	R07E4.4
+T20G5.1	R07E4.4
+T23D8.2	R07E4.4
+T28H10.3	R07E4.4
+VW02B12L.1	R07E4.4
+W03G1.7	R07E4.4
+W04G3.4	R07E4.4
+W07B8.1	R07E4.4
+W07B8.4	R07E4.4
+W07B8.5	R07E4.4
+W09G10.4	R07E4.4
+Y105E8A.9	R07E4.4
+Y105E8B.9	R07E4.4
+Y16B4A.2	R07E4.4
+Y38F2AL.4	R07E4.4
+Y40D12A.2	R07E4.4
+Y48G8AL.14	R07E4.4
+Y49E10.20	R07E4.4
+Y4C6B.6	R07E4.4
+Y50E8A.16	R07E4.4
+Y53G8AR.7	R07E4.4
+Y55H10A.1	R07E4.4
+Y69A2AR.4	R07E4.4
+ZK455.4	R07E4.4
+ZK484.2	R07E4.4
+ZK637.8	R07E4.4
+R11A5.1	R10E11.2
+R12H7.2	R10E11.2
+R148.6	R10E11.2
+T03E6.7	R10E11.2
+T10H4.12	R10E11.2
+T14F9.3	R10E11.2
+T19B10.3	R10E11.2
+T20G5.1	R10E11.2
+T23D8.2	R10E11.2
+T28H10.3	R10E11.2
+W03G1.7	R10E11.2
+W04G3.4	R10E11.2
+W07B8.1	R10E11.2
+W07B8.4	R10E11.2
+W07B8.5	R10E11.2
+W09G10.4	R10E11.2
+Y105E8A.9	R10E11.2
+Y105E8B.9	R10E11.2
+Y16B4A.2	R10E11.2
+Y40D12A.2	R10E11.2
+Y48G8AL.14	R10E11.2
+Y49E10.20	R10E11.2
+Y4C6B.6	R10E11.2
+Y50E8A.16	R10E11.2
+Y53G8AR.7	R10E11.2
+Y69A2AR.4	R10E11.2
+ZK455.4	R10E11.2
+ZK484.2	R10E11.2
+R11A5.1	R10E11.8
+R12H7.2	R10E11.8
+R148.6	R10E11.8
+T03E6.7	R10E11.8
+T10H4.12	R10E11.8
+T14F9.3	R10E11.8
+T19B10.3	R10E11.8
+T20G5.1	R10E11.8
+T23D8.2	R10E11.8
+T28H10.3	R10E11.8
+W03G1.7	R10E11.8
+W04G3.4	R10E11.8
+W07B8.1	R10E11.8
+W07B8.4	R10E11.8
+W07B8.5	R10E11.8
+W09G10.4	R10E11.8
+Y105E8A.9	R10E11.8
+Y105E8B.9	R10E11.8
+Y16B4A.2	R10E11.8
+Y40D12A.2	R10E11.8
+Y48G8AL.14	R10E11.8
+Y49E10.20	R10E11.8
+Y4C6B.6	R10E11.8
+Y50E8A.16	R10E11.8
+Y53G8AR.7	R10E11.8
+Y69A2AR.4	R10E11.8
+ZK455.4	R10E11.8
+ZK484.2	R10E11.8
+R12H7.2	R11A5.1
+R148.6	R11A5.1
+T01H3.1	R11A5.1
+T03E6.7	R11A5.1
+T10H4.12	R11A5.1
+T14F9.1	R11A5.1
+T14F9.3	R11A5.1
+T19B10.3	R11A5.1
+T20G5.1	R11A5.1
+T23D8.2	R11A5.1
+T28H10.3	R11A5.1
+VW02B12L.1	R11A5.1
+W03G1.7	R11A5.1
+W04G3.4	R11A5.1
+W07B8.1	R11A5.1
+W07B8.4	R11A5.1
+W07B8.5	R11A5.1
+W09G10.4	R11A5.1
+Y105E8A.9	R11A5.1
+Y105E8B.9	R11A5.1
+Y16B4A.2	R11A5.1
+Y38F2AL.4	R11A5.1
+Y40D12A.2	R11A5.1
+Y48G8AL.14	R11A5.1
+Y49E10.20	R11A5.1
+Y4C6B.6	R11A5.1
+Y50E8A.16	R11A5.1
+Y53G8AR.7	R11A5.1
+Y55H10A.1	R11A5.1
+Y69A2AR.4	R11A5.1
+ZK455.4	R11A5.1
+ZK484.2	R11A5.1
+ZK637.8	R11A5.1
+R148.6	R12H7.2
+T01H3.1	R12H7.2
+T03E6.7	R12H7.2
+T10H4.12	R12H7.2
+T14F9.1	R12H7.2
+T14F9.3	R12H7.2
+T19B10.3	R12H7.2
+T20G5.1	R12H7.2
+T23D8.2	R12H7.2
+T28H10.3	R12H7.2
+VW02B12L.1	R12H7.2
+W03G1.7	R12H7.2
+W04G3.4	R12H7.2
+W07B8.1	R12H7.2
+W07B8.4	R12H7.2
+W07B8.5	R12H7.2
+W09G10.4	R12H7.2
+Y105E8A.9	R12H7.2
+Y105E8B.9	R12H7.2
+Y16B4A.2	R12H7.2
+Y38F2AL.4	R12H7.2
+Y40D12A.2	R12H7.2
+Y48G8AL.14	R12H7.2
+Y49E10.20	R12H7.2
+Y4C6B.6	R12H7.2
+Y50E8A.16	R12H7.2
+Y53G8AR.7	R12H7.2
+Y55H10A.1	R12H7.2
+Y69A2AR.4	R12H7.2
+ZK455.4	R12H7.2
+ZK484.2	R12H7.2
+ZK637.8	R12H7.2
+T01H3.1	R148.6
+T03E6.7	R148.6
+T10H4.12	R148.6
+T14F9.1	R148.6
+T14F9.3	R148.6
+T19B10.3	R148.6
+T20G5.1	R148.6
+T23D8.2	R148.6
+T28H10.3	R148.6
+VW02B12L.1	R148.6
+W03G1.7	R148.6
+W04G3.4	R148.6
+W07B8.1	R148.6
+W07B8.4	R148.6
+W07B8.5	R148.6
+W09G10.4	R148.6
+Y105E8A.9	R148.6
+Y105E8B.9	R148.6
+Y16B4A.2	R148.6
+Y38F2AL.4	R148.6
+Y40D12A.2	R148.6
+Y48G8AL.14	R148.6
+Y49E10.20	R148.6
+Y4C6B.6	R148.6
+Y50E8A.16	R148.6
+Y53G8AR.7	R148.6
+Y55H10A.1	R148.6
+Y69A2AR.4	R148.6
+ZK455.4	R148.6
+ZK484.2	R148.6
+ZK637.8	R148.6
+T03E6.7	T01H3.1
+T10H4.12	T01H3.1
+T14F9.3	T01H3.1
+T19B10.3	T01H3.1
+T20G5.1	T01H3.1
+T23D8.2	T01H3.1
+T28H10.3	T01H3.1
+W03G1.7	T01H3.1
+W04G3.4	T01H3.1
+W07B8.1	T01H3.1
+W07B8.4	T01H3.1
+W07B8.5	T01H3.1
+W09G10.4	T01H3.1
+Y105E8A.9	T01H3.1
+Y105E8B.9	T01H3.1
+Y16B4A.2	T01H3.1
+Y40D12A.2	T01H3.1
+Y48G8AL.14	T01H3.1
+Y49E10.20	T01H3.1
+Y4C6B.6	T01H3.1
+Y50E8A.16	T01H3.1
+Y53G8AR.7	T01H3.1
+Y69A2AR.4	T01H3.1
+ZK455.4	T01H3.1
+ZK484.2	T01H3.1
+T10H4.12	T03E6.7
+T14F9.1	T03E6.7
+T14F9.3	T03E6.7
+T19B10.3	T03E6.7
+T20G5.1	T03E6.7
+T23D8.2	T03E6.7
+T28H10.3	T03E6.7
+VW02B12L.1	T03E6.7
+W03G1.7	T03E6.7
+W04G3.4	T03E6.7
+W07B8.1	T03E6.7
+W07B8.4	T03E6.7
+W07B8.5	T03E6.7
+W09G10.4	T03E6.7
+Y105E8A.9	T03E6.7
+Y105E8B.9	T03E6.7
+Y16B4A.2	T03E6.7
+Y38F2AL.4	T03E6.7
+Y40D12A.2	T03E6.7
+Y48G8AL.14	T03E6.7
+Y49E10.20	T03E6.7
+Y4C6B.6	T03E6.7
+Y50E8A.16	T03E6.7
+Y53G8AR.7	T03E6.7
+Y55H10A.1	T03E6.7
+Y69A2AR.4	T03E6.7
+ZK455.4	T03E6.7
+ZK484.2	T03E6.7
+ZK637.8	T03E6.7
+T14F9.1	T10H4.12
+T14F9.3	T10H4.12
+T19B10.3	T10H4.12
+T20G5.1	T10H4.12
+T23D8.2	T10H4.12
+T28H10.3	T10H4.12
+VW02B12L.1	T10H4.12
+W03G1.7	T10H4.12
+W04G3.4	T10H4.12
+W07B8.1	T10H4.12
+W07B8.4	T10H4.12
+W07B8.5	T10H4.12
+W09G10.4	T10H4.12
+Y105E8A.9	T10H4.12
+Y105E8B.9	T10H4.12
+Y16B4A.2	T10H4.12
+Y38F2AL.4	T10H4.12
+Y40D12A.2	T10H4.12
+Y48G8AL.14	T10H4.12
+Y49E10.20	T10H4.12
+Y4C6B.6	T10H4.12
+Y50E8A.16	T10H4.12
+Y53G8AR.7	T10H4.12
+Y55H10A.1	T10H4.12
+Y69A2AR.4	T10H4.12
+ZK455.4	T10H4.12
+ZK484.2	T10H4.12
+ZK637.8	T10H4.12
+T14F9.3	T14F9.1
+T19B10.3	T14F9.1
+T20G5.1	T14F9.1
+T23D8.2	T14F9.1
+T28H10.3	T14F9.1
+W03G1.7	T14F9.1
+W04G3.4	T14F9.1
+W07B8.1	T14F9.1
+W07B8.4	T14F9.1
+W07B8.5	T14F9.1
+W09G10.4	T14F9.1
+Y105E8A.9	T14F9.1
+Y105E8B.9	T14F9.1
+Y16B4A.2	T14F9.1
+Y40D12A.2	T14F9.1
+Y48G8AL.14	T14F9.1
+Y49E10.20	T14F9.1
+Y4C6B.6	T14F9.1
+Y50E8A.16	T14F9.1
+Y53G8AR.7	T14F9.1
+Y69A2AR.4	T14F9.1
+ZK455.4	T14F9.1
+ZK484.2	T14F9.1
+T20G5.1	T14F9.3
+T23D8.2	T14F9.3
+T28H10.3	T14F9.3
+VW02B12L.1	T14F9.3
+W03G1.7	T14F9.3
+W04G3.4	T14F9.3
+W07B8.1	T14F9.3
+W07B8.4	T14F9.3
+W07B8.5	T14F9.3
+W09G10.4	T14F9.3
+Y105E8A.9	T14F9.3
+Y16B4A.2	T14F9.3
+Y38F2AL.4	T14F9.3
+Y40D12A.2	T14F9.3
+Y48G8AL.14	T14F9.3
+Y49E10.20	T14F9.3
+Y50E8A.16	T14F9.3
+Y53G8AR.7	T14F9.3
+Y55H10A.1	T14F9.3
+Y69A2AR.4	T14F9.3
+ZK455.4	T14F9.3
+ZK484.2	T14F9.3
+ZK637.8	T14F9.3
+T20G5.1	T19B10.3
+T23D8.2	T19B10.3
+T28H10.3	T19B10.3
+VW02B12L.1	T19B10.3
+W04G3.4	T19B10.3
+W07B8.1	T19B10.3
+W07B8.4	T19B10.3
+W07B8.5	T19B10.3
+W09G10.4	T19B10.3
+Y105E8A.9	T19B10.3
+Y16B4A.2	T19B10.3
+Y38F2AL.4	T19B10.3
+Y40D12A.2	T19B10.3
+Y48G8AL.14	T19B10.3
+Y49E10.20	T19B10.3
+Y50E8A.16	T19B10.3
+Y53G8AR.7	T19B10.3
+Y55H10A.1	T19B10.3
+Y69A2AR.4	T19B10.3
+ZK484.2	T19B10.3
+ZK637.8	T19B10.3
+T23D8.2	T20G5.1
+T28H10.3	T20G5.1
+VW02B12L.1	T20G5.1
+W03G1.7	T20G5.1
+W04G3.4	T20G5.1
+W07B8.1	T20G5.1
+W07B8.4	T20G5.1
+W07B8.5	T20G5.1
+W09G10.4	T20G5.1
+Y105E8A.9	T20G5.1
+Y105E8B.9	T20G5.1
+Y16B4A.2	T20G5.1
+Y38F2AL.4	T20G5.1
+Y40D12A.2	T20G5.1
+Y48G8AL.14	T20G5.1
+Y49E10.20	T20G5.1
+Y4C6B.6	T20G5.1
+Y50E8A.16	T20G5.1
+Y53G8AR.7	T20G5.1
+Y55H10A.1	T20G5.1
+Y69A2AR.4	T20G5.1
+ZK455.4	T20G5.1
+ZK484.2	T20G5.1
+ZK637.8	T20G5.1
+T28H10.3	T23D8.2
+VW02B12L.1	T23D8.2
+W03G1.7	T23D8.2
+W04G3.4	T23D8.2
+W07B8.1	T23D8.2
+W07B8.4	T23D8.2
+W07B8.5	T23D8.2
+W09G10.4	T23D8.2
+Y105E8A.9	T23D8.2
+Y105E8B.9	T23D8.2
+Y16B4A.2	T23D8.2
+Y38F2AL.4	T23D8.2
+Y40D12A.2	T23D8.2
+Y48G8AL.14	T23D8.2
+Y49E10.20	T23D8.2
+Y4C6B.6	T23D8.2
+Y50E8A.16	T23D8.2
+Y53G8AR.7	T23D8.2
+Y55H10A.1	T23D8.2
+Y69A2AR.4	T23D8.2
+ZK455.4	T23D8.2
+ZK484.2	T23D8.2
+ZK637.8	T23D8.2
+VW02B12L.1	T28H10.3
+W03G1.7	T28H10.3
+W04G3.4	T28H10.3
+W07B8.1	T28H10.3
+W07B8.4	T28H10.3
+W07B8.5	T28H10.3
+W09G10.4	T28H10.3
+Y105E8A.9	T28H10.3
+Y105E8B.9	T28H10.3
+Y16B4A.2	T28H10.3
+Y38F2AL.4	T28H10.3
+Y40D12A.2	T28H10.3
+Y48G8AL.14	T28H10.3
+Y49E10.20	T28H10.3
+Y4C6B.6	T28H10.3
+Y50E8A.16	T28H10.3
+Y53G8AR.7	T28H10.3
+Y55H10A.1	T28H10.3
+Y69A2AR.4	T28H10.3
+ZK455.4	T28H10.3
+ZK484.2	T28H10.3
+ZK637.8	T28H10.3
+W03G1.7	VW02B12L.1
+W04G3.4	VW02B12L.1
+W07B8.1	VW02B12L.1
+W07B8.4	VW02B12L.1
+W07B8.5	VW02B12L.1
+W09G10.4	VW02B12L.1
+Y105E8A.9	VW02B12L.1
+Y105E8B.9	VW02B12L.1
+Y16B4A.2	VW02B12L.1
+Y40D12A.2	VW02B12L.1
+Y48G8AL.14	VW02B12L.1
+Y49E10.20	VW02B12L.1
+Y4C6B.6	VW02B12L.1
+Y50E8A.16	VW02B12L.1
+Y53G8AR.7	VW02B12L.1
+Y69A2AR.4	VW02B12L.1
+ZK455.4	VW02B12L.1
+ZK484.2	VW02B12L.1
+W04G3.4	W03G1.7
+W07B8.1	W03G1.7
+W07B8.4	W03G1.7
+W07B8.5	W03G1.7
+W09G10.4	W03G1.7
+Y105E8A.9	W03G1.7
+Y105E8B.9	W03G1.7
+Y16B4A.2	W03G1.7
+Y38F2AL.4	W03G1.7
+Y40D12A.2	W03G1.7
+Y48G8AL.14	W03G1.7
+Y49E10.20	W03G1.7
+Y50E8A.16	W03G1.7
+Y53G8AR.7	W03G1.7
+Y55H10A.1	W03G1.7
+Y69A2AR.4	W03G1.7
+ZK484.2	W03G1.7
+ZK637.8	W03G1.7
+W07B8.1	W04G3.4
+W07B8.4	W04G3.4
+W07B8.5	W04G3.4
+W09G10.4	W04G3.4
+Y105E8A.9	W04G3.4
+Y105E8B.9	W04G3.4
+Y16B4A.2	W04G3.4
+Y38F2AL.4	W04G3.4
+Y40D12A.2	W04G3.4
+Y48G8AL.14	W04G3.4
+Y49E10.20	W04G3.4
+Y4C6B.6	W04G3.4
+Y50E8A.16	W04G3.4
+Y53G8AR.7	W04G3.4
+Y55H10A.1	W04G3.4
+Y69A2AR.4	W04G3.4
+ZK455.4	W04G3.4
+ZK484.2	W04G3.4
+ZK637.8	W04G3.4
+W07B8.4	W07B8.1
+W07B8.5	W07B8.1
+W09G10.4	W07B8.1
+Y105E8A.9	W07B8.1
+Y105E8B.9	W07B8.1
+Y16B4A.2	W07B8.1
+Y38F2AL.4	W07B8.1
+Y40D12A.2	W07B8.1
+Y48G8AL.14	W07B8.1
+Y49E10.20	W07B8.1
+Y4C6B.6	W07B8.1
+Y50E8A.16	W07B8.1
+Y53G8AR.7	W07B8.1
+Y55H10A.1	W07B8.1
+Y69A2AR.4	W07B8.1
+ZK455.4	W07B8.1
+ZK484.2	W07B8.1
+ZK637.8	W07B8.1
+W07B8.5	W07B8.4
+W09G10.4	W07B8.4
+Y105E8A.9	W07B8.4
+Y105E8B.9	W07B8.4
+Y16B4A.2	W07B8.4
+Y38F2AL.4	W07B8.4
+Y40D12A.2	W07B8.4
+Y48G8AL.14	W07B8.4
+Y49E10.20	W07B8.4
+Y4C6B.6	W07B8.4
+Y50E8A.16	W07B8.4
+Y53G8AR.7	W07B8.4
+Y55H10A.1	W07B8.4
+Y69A2AR.4	W07B8.4
+ZK455.4	W07B8.4
+ZK484.2	W07B8.4
+ZK637.8	W07B8.4
+W09G10.4	W07B8.5
+Y105E8A.9	W07B8.5
+Y105E8B.9	W07B8.5
+Y16B4A.2	W07B8.5
+Y38F2AL.4	W07B8.5
+Y40D12A.2	W07B8.5
+Y48G8AL.14	W07B8.5
+Y49E10.20	W07B8.5
+Y4C6B.6	W07B8.5
+Y50E8A.16	W07B8.5
+Y53G8AR.7	W07B8.5
+Y55H10A.1	W07B8.5
+Y69A2AR.4	W07B8.5
+ZK455.4	W07B8.5
+ZK484.2	W07B8.5
+ZK637.8	W07B8.5
+Y105E8A.9	W09G10.4
+Y105E8B.9	W09G10.4
+Y16B4A.2	W09G10.4
+Y38F2AL.4	W09G10.4
+Y40D12A.2	W09G10.4
+Y48G8AL.14	W09G10.4
+Y49E10.20	W09G10.4
+Y4C6B.6	W09G10.4
+Y50E8A.16	W09G10.4
+Y53G8AR.7	W09G10.4
+Y55H10A.1	W09G10.4
+Y69A2AR.4	W09G10.4
+ZK455.4	W09G10.4
+ZK484.2	W09G10.4
+ZK637.8	W09G10.4
+Y105E8B.9	Y105E8A.9
+Y16B4A.2	Y105E8A.9
+Y38F2AL.4	Y105E8A.9
+Y40D12A.2	Y105E8A.9
+Y48G8AL.14	Y105E8A.9
+Y49E10.20	Y105E8A.9
+Y4C6B.6	Y105E8A.9
+Y50E8A.16	Y105E8A.9
+Y53G8AR.7	Y105E8A.9
+Y55H10A.1	Y105E8A.9
+Y69A2AR.4	Y105E8A.9
+ZK455.4	Y105E8A.9
+ZK484.2	Y105E8A.9
+ZK637.8	Y105E8A.9
+Y16B4A.2	Y105E8B.9
+Y38F2AL.4	Y105E8B.9
+Y40D12A.2	Y105E8B.9
+Y48G8AL.14	Y105E8B.9
+Y49E10.20	Y105E8B.9
+Y4C6B.6	Y105E8B.9
+Y50E8A.16	Y105E8B.9
+Y53G8AR.7	Y105E8B.9
+Y55H10A.1	Y105E8B.9
+Y69A2AR.4	Y105E8B.9
+ZK455.4	Y105E8B.9
+ZK484.2	Y105E8B.9
+ZK637.8	Y105E8B.9
+Y38F2AL.4	Y16B4A.2
+Y40D12A.2	Y16B4A.2
+Y48G8AL.14	Y16B4A.2
+Y49E10.20	Y16B4A.2
+Y4C6B.6	Y16B4A.2
+Y50E8A.16	Y16B4A.2
+Y53G8AR.7	Y16B4A.2
+Y55H10A.1	Y16B4A.2
+Y69A2AR.4	Y16B4A.2
+ZK455.4	Y16B4A.2
+ZK484.2	Y16B4A.2
+ZK637.8	Y16B4A.2
+Y40D12A.2	Y38F2AL.4
+Y48G8AL.14	Y38F2AL.4
+Y49E10.20	Y38F2AL.4
+Y4C6B.6	Y38F2AL.4
+Y50E8A.16	Y38F2AL.4
+Y53G8AR.7	Y38F2AL.4
+Y69A2AR.4	Y38F2AL.4
+ZK455.4	Y38F2AL.4
+ZK484.2	Y38F2AL.4
+Y48G8AL.14	Y40D12A.2
+Y49E10.20	Y40D12A.2
+Y4C6B.6	Y40D12A.2
+Y50E8A.16	Y40D12A.2
+Y53G8AR.7	Y40D12A.2
+Y55H10A.1	Y40D12A.2
+Y69A2AR.4	Y40D12A.2
+ZK455.4	Y40D12A.2
+ZK484.2	Y40D12A.2
+ZK637.8	Y40D12A.2
+Y49E10.20	Y48G8AL.14
+Y4C6B.6	Y48G8AL.14
+Y50E8A.16	Y48G8AL.14
+Y53G8AR.7	Y48G8AL.14
+Y55H10A.1	Y48G8AL.14
+Y69A2AR.4	Y48G8AL.14
+ZK455.4	Y48G8AL.14
+ZK484.2	Y48G8AL.14
+ZK637.8	Y48G8AL.14
+Y4C6B.6	Y49E10.20
+Y50E8A.16	Y49E10.20
+Y53G8AR.7	Y49E10.20
+Y55H10A.1	Y49E10.20
+Y69A2AR.4	Y49E10.20
+ZK455.4	Y49E10.20
+ZK484.2	Y49E10.20
+ZK637.8	Y49E10.20
+Y50E8A.16	Y4C6B.6
+Y53G8AR.7	Y4C6B.6
+Y55H10A.1	Y4C6B.6
+Y69A2AR.4	Y4C6B.6
+ZK484.2	Y4C6B.6
+ZK637.8	Y4C6B.6
+Y53G8AR.7	Y50E8A.16
+Y55H10A.1	Y50E8A.16
+Y69A2AR.4	Y50E8A.16
+ZK455.4	Y50E8A.16
+ZK637.8	Y50E8A.16
+Y55H10A.1	Y53G8AR.7
+Y69A2AR.4	Y53G8AR.7
+ZK455.4	Y53G8AR.7
+ZK484.2	Y53G8AR.7
+ZK637.8	Y53G8AR.7
+Y69A2AR.4	Y55H10A.1
+ZK455.4	Y55H10A.1
+ZK484.2	Y55H10A.1
+ZK455.4	Y69A2AR.4
+ZK484.2	Y69A2AR.4
+ZK637.8	Y69A2AR.4
+ZK484.2	ZK455.4
+ZK637.8	ZK455.4
+ZK637.8	ZK484.2
+C02C6.1	C01A2.4
+C04G6.3	C01A2.4
+C06A6.3	C01A2.4
+C07G1.5	C01A2.4
+C09G12.9	C01A2.4
+C12C8.1	C01A2.4
+C27F2.5	C01A2.4
+C34G6.7	C01A2.4
+C37C3.3	C01A2.4
+C56A3.7	C01A2.4
+C56C10.3	C01A2.4
+CD4.4	C01A2.4
+E01B7.1	C01A2.4
+F02E8.3	C01A2.4
+F07F6.4	C01A2.4
+F09E5.1	C01A2.4
+F11F1.1	C01A2.4
+F17C11.8	C01A2.4
+F19C6.1	C01A2.4
+F23C8.6	C01A2.4
+F26D10.3	C01A2.4
+F35A5.8	C01A2.4
+F41E6.9	C01A2.4
+F44E5.4	C01A2.4
+F44E5.5	C01A2.4
+F53G12.1	C01A2.4
+F53H8.2	C01A2.4
+F54E7.3	C01A2.4
+F55A12.3	C01A2.4
+F55C12.1	C01A2.4
+F59F3.1	C01A2.4
+F59F3.5	C01A2.4
+K02B12.7	C01A2.4
+M02A10.3	C01A2.4
+M02B7.5	C01A2.4
+R07G3.1	C01A2.4
+R10E12.1	C01A2.4
+R12C12.5	C01A2.4
+R160.1	C01A2.4
+T04C10.2	C01A2.4
+T04D1.3	C01A2.4
+T10G3.5	C01A2.4
+T12E12.4	C01A2.4
+T13F2.8	C01A2.4
+T17A3.1	C01A2.4
+T20B5.1	C01A2.4
+T20G5.1	C01A2.4
+T24B8.2	C01A2.4
+T26E3.3	C01A2.4
+T27F7.1	C01A2.4
+VF11C1L.1	C01A2.4
+W02A11.2	C01A2.4
+W02B3.2	C01A2.4
+W03C9.3	C01A2.4
+W04G5.2	C01A2.4
+W06H8.1	C01A2.4
+W09D10.1	C01A2.4
+Y116A8C.12	C01A2.4
+Y17G7B.15	C01A2.4
+Y32F6B.3	C01A2.4
+Y34D9A.10	C01A2.4
+Y39A1A.15	C01A2.4
+Y42H9AR.3	C01A2.4
+Y46G5A.12	C01A2.4
+Y51H4A.3	C01A2.4
+Y55D9A.1	C01A2.4
+Y65B4A.3	C01A2.4
+Y65B4BR.4	C01A2.4
+Y71H2B.10	C01A2.4
+Y87G2A.10	C01A2.4
+Y92H12A.2	C01A2.4
+ZK1067.1	C01A2.4
+C04G6.3	C02C6.1
+C06A6.3	C02C6.1
+C07G1.5	C02C6.1
+C09G12.9	C02C6.1
+C12C8.1	C02C6.1
+C27F2.5	C02C6.1
+C34G6.7	C02C6.1
+C37C3.3	C02C6.1
+C56A3.7	C02C6.1
+C56C10.3	C02C6.1
+CD4.4	C02C6.1
+E01B7.1	C02C6.1
+F02E8.3	C02C6.1
+F07F6.4	C02C6.1
+F09E5.1	C02C6.1
+F11F1.1	C02C6.1
+F17C11.8	C02C6.1
+F19C6.1	C02C6.1
+F23C8.6	C02C6.1
+F26D10.3	C02C6.1
+F35A5.8	C02C6.1
+F41E6.9	C02C6.1
+F44E5.4	C02C6.1
+F44E5.5	C02C6.1
+F53G12.1	C02C6.1
+F53H8.2	C02C6.1
+F54E7.3	C02C6.1
+F55A12.3	C02C6.1
+F55C12.1	C02C6.1
+F59F3.1	C02C6.1
+F59F3.5	C02C6.1
+K02B12.7	C02C6.1
+M02A10.3	C02C6.1
+M02B7.5	C02C6.1
+R10E12.1	C02C6.1
+R12C12.5	C02C6.1
+R160.1	C02C6.1
+T04C10.2	C02C6.1
+T04D1.3	C02C6.1
+T10G3.5	C02C6.1
+T12E12.4	C02C6.1
+T13F2.8	C02C6.1
+T17A3.1	C02C6.1
+T20B5.1	C02C6.1
+T20G5.1	C02C6.1
+T24B8.2	C02C6.1
+T26E3.3	C02C6.1
+T27F7.1	C02C6.1
+VF11C1L.1	C02C6.1
+W02A11.2	C02C6.1
+W02B3.2	C02C6.1
+W04G5.2	C02C6.1
+W06H8.1	C02C6.1
+W09D10.1	C02C6.1
+Y116A8C.12	C02C6.1
+Y17G7B.15	C02C6.1
+Y32F6B.3	C02C6.1
+Y34D9A.10	C02C6.1
+Y39A1A.15	C02C6.1
+Y42H9AR.3	C02C6.1
+Y46G5A.12	C02C6.1
+Y55D9A.1	C02C6.1
+Y65B4A.3	C02C6.1
+Y65B4BR.4	C02C6.1
+Y71H2B.10	C02C6.1
+Y87G2A.10	C02C6.1
+Y92H12A.2	C02C6.1
+ZK1067.1	C02C6.1
+C06A6.3	C04G6.3
+C07G1.5	C04G6.3
+C09G12.9	C04G6.3
+C12C8.1	C04G6.3
+C27F2.5	C04G6.3
+C34G6.7	C04G6.3
+C37C3.3	C04G6.3
+C56A3.7	C04G6.3
+C56C10.3	C04G6.3
+CD4.4	C04G6.3
+E01B7.1	C04G6.3
+F02E8.3	C04G6.3
+F07F6.4	C04G6.3
+F09E5.1	C04G6.3
+F11F1.1	C04G6.3
+F17C11.8	C04G6.3
+F19C6.1	C04G6.3
+F23C8.6	C04G6.3
+F26D10.3	C04G6.3
+F35A5.8	C04G6.3
+F41E6.9	C04G6.3
+F44E5.4	C04G6.3
+F44E5.5	C04G6.3
+F53G12.1	C04G6.3
+F53H8.2	C04G6.3
+F54E7.3	C04G6.3
+F55A12.3	C04G6.3
+F55C12.1	C04G6.3
+F59F3.1	C04G6.3
+F59F3.5	C04G6.3
+K02B12.7	C04G6.3
+M02A10.3	C04G6.3
+M02B7.5	C04G6.3
+R07G3.1	C04G6.3
+R10E12.1	C04G6.3
+R12C12.5	C04G6.3
+R160.1	C04G6.3
+T04C10.2	C04G6.3
+T04D1.3	C04G6.3
+T10G3.5	C04G6.3
+T12E12.4	C04G6.3
+T13F2.8	C04G6.3
+T17A3.1	C04G6.3
+T20B5.1	C04G6.3
+T20G5.1	C04G6.3
+T24B8.2	C04G6.3
+T26E3.3	C04G6.3
+T27F7.1	C04G6.3
+VF11C1L.1	C04G6.3
+W02A11.2	C04G6.3
+W02B3.2	C04G6.3
+W03C9.3	C04G6.3
+W04G5.2	C04G6.3
+W06H8.1	C04G6.3
+W09D10.1	C04G6.3
+Y116A8C.12	C04G6.3
+Y17G7B.15	C04G6.3
+Y32F6B.3	C04G6.3
+Y34D9A.10	C04G6.3
+Y39A1A.15	C04G6.3
+Y42H9AR.3	C04G6.3
+Y46G5A.12	C04G6.3
+Y51H4A.3	C04G6.3
+Y55D9A.1	C04G6.3
+Y65B4A.3	C04G6.3
+Y65B4BR.4	C04G6.3
+Y71H2B.10	C04G6.3
+Y87G2A.10	C04G6.3
+Y92H12A.2	C04G6.3
+ZK1067.1	C04G6.3
+C07G1.5	C06A6.3
+C09G12.9	C06A6.3
+C12C8.1	C06A6.3
+C27F2.5	C06A6.3
+C34G6.7	C06A6.3
+C37C3.3	C06A6.3
+C56A3.7	C06A6.3
+C56C10.3	C06A6.3
+CD4.4	C06A6.3
+E01B7.1	C06A6.3
+F02E8.3	C06A6.3
+F07F6.4	C06A6.3
+F09E5.1	C06A6.3
+F11F1.1	C06A6.3
+F17C11.8	C06A6.3
+F19C6.1	C06A6.3
+F23C8.6	C06A6.3
+F26D10.3	C06A6.3
+F35A5.8	C06A6.3
+F41E6.9	C06A6.3
+F44E5.4	C06A6.3
+F44E5.5	C06A6.3
+F53G12.1	C06A6.3
+F53H8.2	C06A6.3
+F54E7.3	C06A6.3
+F55A12.3	C06A6.3
+F55C12.1	C06A6.3
+F59F3.1	C06A6.3
+F59F3.5	C06A6.3
+K02B12.7	C06A6.3
+M02A10.3	C06A6.3
+M02B7.5	C06A6.3
+R07G3.1	C06A6.3
+R10E12.1	C06A6.3
+R12C12.5	C06A6.3
+R160.1	C06A6.3
+T04C10.2	C06A6.3
+T04D1.3	C06A6.3
+T10G3.5	C06A6.3
+T12E12.4	C06A6.3
+T13F2.8	C06A6.3
+T17A3.1	C06A6.3
+T20B5.1	C06A6.3
+T20G5.1	C06A6.3
+T24B8.2	C06A6.3
+T26E3.3	C06A6.3
+T27F7.1	C06A6.3
+VF11C1L.1	C06A6.3
+W02A11.2	C06A6.3
+W02B3.2	C06A6.3
+W03C9.3	C06A6.3
+W04G5.2	C06A6.3
+W06H8.1	C06A6.3
+W09D10.1	C06A6.3
+Y116A8C.12	C06A6.3
+Y17G7B.15	C06A6.3
+Y32F6B.3	C06A6.3
+Y34D9A.10	C06A6.3
+Y39A1A.15	C06A6.3
+Y42H9AR.3	C06A6.3
+Y46G5A.12	C06A6.3
+Y51H4A.3	C06A6.3
+Y55D9A.1	C06A6.3
+Y65B4A.3	C06A6.3
+Y65B4BR.4	C06A6.3
+Y71H2B.10	C06A6.3
+Y87G2A.10	C06A6.3
+Y92H12A.2	C06A6.3
+ZK1067.1	C06A6.3
+C09G12.9	C07G1.5
+C12C8.1	C07G1.5
+C27F2.5	C07G1.5
+C34G6.7	C07G1.5
+C37C3.3	C07G1.5
+C56A3.7	C07G1.5
+C56C10.3	C07G1.5
+CD4.4	C07G1.5
+E01B7.1	C07G1.5
+F02E8.3	C07G1.5
+F07F6.4	C07G1.5
+F09E5.1	C07G1.5
+F11F1.1	C07G1.5
+F17C11.8	C07G1.5
+F19C6.1	C07G1.5
+F23C8.6	C07G1.5
+F26D10.3	C07G1.5
+F35A5.8	C07G1.5
+F41E6.9	C07G1.5
+F44E5.4	C07G1.5
+F44E5.5	C07G1.5
+F53G12.1	C07G1.5
+F53H8.2	C07G1.5
+F54E7.3	C07G1.5
+F55A12.3	C07G1.5
+F55C12.1	C07G1.5
+F59F3.1	C07G1.5
+F59F3.5	C07G1.5
+K02B12.7	C07G1.5
+M02A10.3	C07G1.5
+M02B7.5	C07G1.5
+R07G3.1	C07G1.5
+R10E12.1	C07G1.5
+R12C12.5	C07G1.5
+R160.1	C07G1.5
+T04C10.2	C07G1.5
+T04D1.3	C07G1.5
+T10G3.5	C07G1.5
+T12E12.4	C07G1.5
+T13F2.8	C07G1.5
+T17A3.1	C07G1.5
+T20B5.1	C07G1.5
+T20G5.1	C07G1.5
+T24B8.2	C07G1.5
+T26E3.3	C07G1.5
+T27F7.1	C07G1.5
+VF11C1L.1	C07G1.5
+W02A11.2	C07G1.5
+W02B3.2	C07G1.5
+W03C9.3	C07G1.5
+W04G5.2	C07G1.5
+W06H8.1	C07G1.5
+W09D10.1	C07G1.5
+Y116A8C.12	C07G1.5
+Y17G7B.15	C07G1.5
+Y32F6B.3	C07G1.5
+Y34D9A.10	C07G1.5
+Y39A1A.15	C07G1.5
+Y42H9AR.3	C07G1.5
+Y46G5A.12	C07G1.5
+Y51H4A.3	C07G1.5
+Y55D9A.1	C07G1.5
+Y65B4A.3	C07G1.5
+Y65B4BR.4	C07G1.5
+Y71H2B.10	C07G1.5
+Y87G2A.10	C07G1.5
+Y92H12A.2	C07G1.5
+ZK1067.1	C07G1.5
+C12C8.1	C09G12.9
+C27F2.5	C09G12.9
+C34G6.7	C09G12.9
+C37C3.3	C09G12.9
+C56A3.7	C09G12.9
+C56C10.3	C09G12.9
+CD4.4	C09G12.9
+E01B7.1	C09G12.9
+F02E8.3	C09G12.9
+F07F6.4	C09G12.9
+F09E5.1	C09G12.9
+F11F1.1	C09G12.9
+F17C11.8	C09G12.9
+F19C6.1	C09G12.9
+F23C8.6	C09G12.9
+F26D10.3	C09G12.9
+F35A5.8	C09G12.9
+F41E6.9	C09G12.9
+F44E5.4	C09G12.9
+F44E5.5	C09G12.9
+F53G12.1	C09G12.9
+F53H8.2	C09G12.9
+F54E7.3	C09G12.9
+F55A12.3	C09G12.9
+F55C12.1	C09G12.9
+F59F3.1	C09G12.9
+F59F3.5	C09G12.9
+K02B12.7	C09G12.9
+M02A10.3	C09G12.9
+M02B7.5	C09G12.9
+R07G3.1	C09G12.9
+R10E12.1	C09G12.9
+R12C12.5	C09G12.9
+R160.1	C09G12.9
+T04C10.2	C09G12.9
+T04D1.3	C09G12.9
+T10G3.5	C09G12.9
+T12E12.4	C09G12.9
+T13F2.8	C09G12.9
+T17A3.1	C09G12.9
+T20B5.1	C09G12.9
+T20G5.1	C09G12.9
+T24B8.2	C09G12.9
+T26E3.3	C09G12.9
+T27F7.1	C09G12.9
+VF11C1L.1	C09G12.9
+W02A11.2	C09G12.9
+W02B3.2	C09G12.9
+W03C9.3	C09G12.9
+W04G5.2	C09G12.9
+W06H8.1	C09G12.9
+W09D10.1	C09G12.9
+Y116A8C.12	C09G12.9
+Y17G7B.15	C09G12.9
+Y32F6B.3	C09G12.9
+Y34D9A.10	C09G12.9
+Y39A1A.15	C09G12.9
+Y42H9AR.3	C09G12.9
+Y46G5A.12	C09G12.9
+Y51H4A.3	C09G12.9
+Y55D9A.1	C09G12.9
+Y65B4A.3	C09G12.9
+Y65B4BR.4	C09G12.9
+Y71H2B.10	C09G12.9
+Y87G2A.10	C09G12.9
+Y92H12A.2	C09G12.9
+ZK1067.1	C09G12.9
+C27F2.5	C12C8.1
+C34G6.7	C12C8.1
+C37C3.3	C12C8.1
+C56A3.7	C12C8.1
+C56C10.3	C12C8.1
+CD4.4	C12C8.1
+E01B7.1	C12C8.1
+F02E8.3	C12C8.1
+F07F6.4	C12C8.1
+F09E5.1	C12C8.1
+F17C11.8	C12C8.1
+F19C6.1	C12C8.1
+F23C8.6	C12C8.1
+F35A5.8	C12C8.1
+F41E6.9	C12C8.1
+F53G12.1	C12C8.1
+F54E7.3	C12C8.1
+F55A12.3	C12C8.1
+F55C12.1	C12C8.1
+F59F3.1	C12C8.1
+F59F3.5	C12C8.1
+K02B12.7	C12C8.1
+M02A10.3	C12C8.1
+M02B7.5	C12C8.1
+R10E12.1	C12C8.1
+R12C12.5	C12C8.1
+R160.1	C12C8.1
+T04C10.2	C12C8.1
+T04D1.3	C12C8.1
+T10G3.5	C12C8.1
+T12E12.4	C12C8.1
+T13F2.8	C12C8.1
+T17A3.1	C12C8.1
+T20B5.1	C12C8.1
+T20G5.1	C12C8.1
+T24B8.2	C12C8.1
+T26E3.3	C12C8.1
+T27F7.1	C12C8.1
+VF11C1L.1	C12C8.1
+W02A11.2	C12C8.1
+W02B3.2	C12C8.1
+W03C9.3	C12C8.1
+W04G5.2	C12C8.1
+W06H8.1	C12C8.1
+W09D10.1	C12C8.1
+Y116A8C.12	C12C8.1
+Y17G7B.15	C12C8.1
+Y34D9A.10	C12C8.1
+Y39A1A.15	C12C8.1
+Y42H9AR.3	C12C8.1
+Y46G5A.12	C12C8.1
+Y51H4A.3	C12C8.1
+Y55D9A.1	C12C8.1
+Y65B4A.3	C12C8.1
+Y65B4BR.4	C12C8.1
+Y71H2B.10	C12C8.1
+Y87G2A.10	C12C8.1
+Y92H12A.2	C12C8.1
+C34G6.7	C27F2.5
+C37C3.3	C27F2.5
+C56A3.7	C27F2.5
+C56C10.3	C27F2.5
+CD4.4	C27F2.5
+E01B7.1	C27F2.5
+F02E8.3	C27F2.5
+F07F6.4	C27F2.5
+F09E5.1	C27F2.5
+F11F1.1	C27F2.5
+F17C11.8	C27F2.5
+F19C6.1	C27F2.5
+F23C8.6	C27F2.5
+F26D10.3	C27F2.5
+F35A5.8	C27F2.5
+F41E6.9	C27F2.5
+F44E5.4	C27F2.5
+F44E5.5	C27F2.5
+F53G12.1	C27F2.5
+F53H8.2	C27F2.5
+F54E7.3	C27F2.5
+F55A12.3	C27F2.5
+F55C12.1	C27F2.5
+F59F3.1	C27F2.5
+F59F3.5	C27F2.5
+K02B12.7	C27F2.5
+M02A10.3	C27F2.5
+M02B7.5	C27F2.5
+R07G3.1	C27F2.5
+R10E12.1	C27F2.5
+R12C12.5	C27F2.5
+R160.1	C27F2.5
+T04C10.2	C27F2.5
+T04D1.3	C27F2.5
+T10G3.5	C27F2.5
+T12E12.4	C27F2.5
+T13F2.8	C27F2.5
+T17A3.1	C27F2.5
+T20B5.1	C27F2.5
+T20G5.1	C27F2.5
+T24B8.2	C27F2.5
+T26E3.3	C27F2.5
+T27F7.1	C27F2.5
+VF11C1L.1	C27F2.5
+W02A11.2	C27F2.5
+W02B3.2	C27F2.5
+W03C9.3	C27F2.5
+W04G5.2	C27F2.5
+W06H8.1	C27F2.5
+W09D10.1	C27F2.5
+Y116A8C.12	C27F2.5
+Y17G7B.15	C27F2.5
+Y32F6B.3	C27F2.5
+Y34D9A.10	C27F2.5
+Y39A1A.15	C27F2.5
+Y42H9AR.3	C27F2.5
+Y46G5A.12	C27F2.5
+Y51H4A.3	C27F2.5
+Y55D9A.1	C27F2.5
+Y65B4A.3	C27F2.5
+Y65B4BR.4	C27F2.5
+Y71H2B.10	C27F2.5
+Y87G2A.10	C27F2.5
+Y92H12A.2	C27F2.5
+ZK1067.1	C27F2.5
+C37C3.3	C34G6.7
+C56A3.7	C34G6.7
+C56C10.3	C34G6.7
+CD4.4	C34G6.7
+E01B7.1	C34G6.7
+F02E8.3	C34G6.7
+F07F6.4	C34G6.7
+F09E5.1	C34G6.7
+F11F1.1	C34G6.7
+F17C11.8	C34G6.7
+F19C6.1	C34G6.7
+F23C8.6	C34G6.7
+F26D10.3	C34G6.7
+F35A5.8	C34G6.7
+F41E6.9	C34G6.7
+F44E5.4	C34G6.7
+F44E5.5	C34G6.7
+F53G12.1	C34G6.7
+F53H8.2	C34G6.7
+F54E7.3	C34G6.7
+F55A12.3	C34G6.7
+F55C12.1	C34G6.7
+F59F3.1	C34G6.7
+F59F3.5	C34G6.7
+K02B12.7	C34G6.7
+M02A10.3	C34G6.7
+M02B7.5	C34G6.7
+R07G3.1	C34G6.7
+R10E12.1	C34G6.7
+R12C12.5	C34G6.7
+R160.1	C34G6.7
+T04C10.2	C34G6.7
+T04D1.3	C34G6.7
+T10G3.5	C34G6.7
+T12E12.4	C34G6.7
+T13F2.8	C34G6.7
+T17A3.1	C34G6.7
+T20B5.1	C34G6.7
+T20G5.1	C34G6.7
+T24B8.2	C34G6.7
+T26E3.3	C34G6.7
+T27F7.1	C34G6.7
+VF11C1L.1	C34G6.7
+W02A11.2	C34G6.7
+W02B3.2	C34G6.7
+W03C9.3	C34G6.7
+W04G5.2	C34G6.7
+W06H8.1	C34G6.7
+W09D10.1	C34G6.7
+Y116A8C.12	C34G6.7
+Y17G7B.15	C34G6.7
+Y32F6B.3	C34G6.7
+Y34D9A.10	C34G6.7
+Y39A1A.15	C34G6.7
+Y42H9AR.3	C34G6.7
+Y46G5A.12	C34G6.7
+Y51H4A.3	C34G6.7
+Y55D9A.1	C34G6.7
+Y65B4A.3	C34G6.7
+Y65B4BR.4	C34G6.7
+Y71H2B.10	C34G6.7
+Y87G2A.10	C34G6.7
+Y92H12A.2	C34G6.7
+ZK1067.1	C34G6.7
+C56A3.7	C37C3.3
+C56C10.3	C37C3.3
+CD4.4	C37C3.3
+E01B7.1	C37C3.3
+F02E8.3	C37C3.3
+F07F6.4	C37C3.3
+F09E5.1	C37C3.3
+F11F1.1	C37C3.3
+F17C11.8	C37C3.3
+F19C6.1	C37C3.3
+F23C8.6	C37C3.3
+F26D10.3	C37C3.3
+F35A5.8	C37C3.3
+F41E6.9	C37C3.3
+F44E5.4	C37C3.3
+F44E5.5	C37C3.3
+F53G12.1	C37C3.3
+F53H8.2	C37C3.3
+F54E7.3	C37C3.3
+F55A12.3	C37C3.3
+F55C12.1	C37C3.3
+F59F3.1	C37C3.3
+F59F3.5	C37C3.3
+K02B12.7	C37C3.3
+M02A10.3	C37C3.3
+M02B7.5	C37C3.3
+R07G3.1	C37C3.3
+R10E12.1	C37C3.3
+R12C12.5	C37C3.3
+R160.1	C37C3.3
+T04C10.2	C37C3.3
+T04D1.3	C37C3.3
+T10G3.5	C37C3.3
+T12E12.4	C37C3.3
+T13F2.8	C37C3.3
+T17A3.1	C37C3.3
+T20B5.1	C37C3.3
+T20G5.1	C37C3.3
+T24B8.2	C37C3.3
+T26E3.3	C37C3.3
+T27F7.1	C37C3.3
+VF11C1L.1	C37C3.3
+W02A11.2	C37C3.3
+W02B3.2	C37C3.3
+W03C9.3	C37C3.3
+W04G5.2	C37C3.3
+W06H8.1	C37C3.3
+W09D10.1	C37C3.3
+Y116A8C.12	C37C3.3
+Y17G7B.15	C37C3.3
+Y32F6B.3	C37C3.3
+Y34D9A.10	C37C3.3
+Y39A1A.15	C37C3.3
+Y42H9AR.3	C37C3.3
+Y46G5A.12	C37C3.3
+Y51H4A.3	C37C3.3
+Y55D9A.1	C37C3.3
+Y65B4A.3	C37C3.3
+Y65B4BR.4	C37C3.3
+Y71H2B.10	C37C3.3
+Y87G2A.10	C37C3.3
+Y92H12A.2	C37C3.3
+ZK1067.1	C37C3.3
+C56C10.3	C56A3.7
+CD4.4	C56A3.7
+E01B7.1	C56A3.7
+F02E8.3	C56A3.7
+F07F6.4	C56A3.7
+F09E5.1	C56A3.7
+F11F1.1	C56A3.7
+F17C11.8	C56A3.7
+F19C6.1	C56A3.7
+F23C8.6	C56A3.7
+F26D10.3	C56A3.7
+F35A5.8	C56A3.7
+F41E6.9	C56A3.7
+F44E5.4	C56A3.7
+F44E5.5	C56A3.7
+F53G12.1	C56A3.7
+F53H8.2	C56A3.7
+F54E7.3	C56A3.7
+F55A12.3	C56A3.7
+F55C12.1	C56A3.7
+F59F3.1	C56A3.7
+F59F3.5	C56A3.7
+K02B12.7	C56A3.7
+M02A10.3	C56A3.7
+M02B7.5	C56A3.7
+R07G3.1	C56A3.7
+R10E12.1	C56A3.7
+R12C12.5	C56A3.7
+R160.1	C56A3.7
+T04C10.2	C56A3.7
+T04D1.3	C56A3.7
+T10G3.5	C56A3.7
+T12E12.4	C56A3.7
+T13F2.8	C56A3.7
+T17A3.1	C56A3.7
+T20B5.1	C56A3.7
+T20G5.1	C56A3.7
+T24B8.2	C56A3.7
+T26E3.3	C56A3.7
+T27F7.1	C56A3.7
+VF11C1L.1	C56A3.7
+W02A11.2	C56A3.7
+W02B3.2	C56A3.7
+W03C9.3	C56A3.7
+W04G5.2	C56A3.7
+W06H8.1	C56A3.7
+W09D10.1	C56A3.7
+Y116A8C.12	C56A3.7
+Y17G7B.15	C56A3.7
+Y32F6B.3	C56A3.7
+Y34D9A.10	C56A3.7
+Y39A1A.15	C56A3.7
+Y42H9AR.3	C56A3.7
+Y46G5A.12	C56A3.7
+Y51H4A.3	C56A3.7
+Y55D9A.1	C56A3.7
+Y65B4A.3	C56A3.7
+Y65B4BR.4	C56A3.7
+Y71H2B.10	C56A3.7
+Y87G2A.10	C56A3.7
+Y92H12A.2	C56A3.7
+ZK1067.1	C56A3.7
+CD4.4	C56C10.3
+E01B7.1	C56C10.3
+F02E8.3	C56C10.3
+F07F6.4	C56C10.3
+F09E5.1	C56C10.3
+F11F1.1	C56C10.3
+F17C11.8	C56C10.3
+F19C6.1	C56C10.3
+F23C8.6	C56C10.3
+F26D10.3	C56C10.3
+F35A5.8	C56C10.3
+F41E6.9	C56C10.3
+F44E5.4	C56C10.3
+F44E5.5	C56C10.3
+F53G12.1	C56C10.3
+F53H8.2	C56C10.3
+F54E7.3	C56C10.3
+F55A12.3	C56C10.3
+F55C12.1	C56C10.3
+F59F3.1	C56C10.3
+F59F3.5	C56C10.3
+K02B12.7	C56C10.3
+M02A10.3	C56C10.3
+M02B7.5	C56C10.3
+R07G3.1	C56C10.3
+R10E12.1	C56C10.3
+R12C12.5	C56C10.3
+R160.1	C56C10.3
+T04C10.2	C56C10.3
+T04D1.3	C56C10.3
+T10G3.5	C56C10.3
+T12E12.4	C56C10.3
+T13F2.8	C56C10.3
+T17A3.1	C56C10.3
+T20B5.1	C56C10.3
+T20G5.1	C56C10.3
+T24B8.2	C56C10.3
+T26E3.3	C56C10.3
+T27F7.1	C56C10.3
+VF11C1L.1	C56C10.3
+W02A11.2	C56C10.3
+W02B3.2	C56C10.3
+W03C9.3	C56C10.3
+W04G5.2	C56C10.3
+W06H8.1	C56C10.3
+W09D10.1	C56C10.3
+Y116A8C.12	C56C10.3
+Y17G7B.15	C56C10.3
+Y32F6B.3	C56C10.3
+Y34D9A.10	C56C10.3
+Y39A1A.15	C56C10.3
+Y42H9AR.3	C56C10.3
+Y46G5A.12	C56C10.3
+Y51H4A.3	C56C10.3
+Y55D9A.1	C56C10.3
+Y65B4A.3	C56C10.3
+Y65B4BR.4	C56C10.3
+Y71H2B.10	C56C10.3
+Y87G2A.10	C56C10.3
+Y92H12A.2	C56C10.3
+ZK1067.1	C56C10.3
+E01B7.1	CD4.4
+F02E8.3	CD4.4
+F07F6.4	CD4.4
+F09E5.1	CD4.4
+F11F1.1	CD4.4
+F17C11.8	CD4.4
+F19C6.1	CD4.4
+F23C8.6	CD4.4
+F26D10.3	CD4.4
+F35A5.8	CD4.4
+F41E6.9	CD4.4
+F44E5.4	CD4.4
+F44E5.5	CD4.4
+F53G12.1	CD4.4
+F53H8.2	CD4.4
+F54E7.3	CD4.4
+F55A12.3	CD4.4
+F55C12.1	CD4.4
+F59F3.1	CD4.4
+F59F3.5	CD4.4
+K02B12.7	CD4.4
+M02A10.3	CD4.4
+M02B7.5	CD4.4
+R07G3.1	CD4.4
+R10E12.1	CD4.4
+R12C12.5	CD4.4
+R160.1	CD4.4
+T04C10.2	CD4.4
+T04D1.3	CD4.4
+T10G3.5	CD4.4
+T12E12.4	CD4.4
+T13F2.8	CD4.4
+T17A3.1	CD4.4
+T20B5.1	CD4.4
+T20G5.1	CD4.4
+T24B8.2	CD4.4
+T26E3.3	CD4.4
+T27F7.1	CD4.4
+VF11C1L.1	CD4.4
+W02A11.2	CD4.4
+W02B3.2	CD4.4
+W03C9.3	CD4.4
+W04G5.2	CD4.4
+W06H8.1	CD4.4
+W09D10.1	CD4.4
+Y116A8C.12	CD4.4
+Y17G7B.15	CD4.4
+Y32F6B.3	CD4.4
+Y34D9A.10	CD4.4
+Y39A1A.15	CD4.4
+Y42H9AR.3	CD4.4
+Y46G5A.12	CD4.4
+Y51H4A.3	CD4.4
+Y55D9A.1	CD4.4
+Y65B4A.3	CD4.4
+Y65B4BR.4	CD4.4
+Y71H2B.10	CD4.4
+Y87G2A.10	CD4.4
+Y92H12A.2	CD4.4
+ZK1067.1	CD4.4
+F02E8.3	E01B7.1
+F07F6.4	E01B7.1
+F09E5.1	E01B7.1
+F11F1.1	E01B7.1
+F17C11.8	E01B7.1
+F19C6.1	E01B7.1
+F23C8.6	E01B7.1
+F26D10.3	E01B7.1
+F35A5.8	E01B7.1
+F41E6.9	E01B7.1
+F44E5.4	E01B7.1
+F44E5.5	E01B7.1
+F53G12.1	E01B7.1
+F53H8.2	E01B7.1
+F54E7.3	E01B7.1
+F55A12.3	E01B7.1
+F55C12.1	E01B7.1
+F59F3.1	E01B7.1
+F59F3.5	E01B7.1
+K02B12.7	E01B7.1
+M02A10.3	E01B7.1
+M02B7.5	E01B7.1
+R07G3.1	E01B7.1
+R10E12.1	E01B7.1
+R12C12.5	E01B7.1
+R160.1	E01B7.1
+T04C10.2	E01B7.1
+T04D1.3	E01B7.1
+T10G3.5	E01B7.1
+T12E12.4	E01B7.1
+T13F2.8	E01B7.1
+T17A3.1	E01B7.1
+T20B5.1	E01B7.1
+T20G5.1	E01B7.1
+T24B8.2	E01B7.1
+T26E3.3	E01B7.1
+T27F7.1	E01B7.1
+VF11C1L.1	E01B7.1
+W02A11.2	E01B7.1
+W02B3.2	E01B7.1
+W03C9.3	E01B7.1
+W04G5.2	E01B7.1
+W06H8.1	E01B7.1
+W09D10.1	E01B7.1
+Y116A8C.12	E01B7.1
+Y17G7B.15	E01B7.1
+Y32F6B.3	E01B7.1
+Y34D9A.10	E01B7.1
+Y39A1A.15	E01B7.1
+Y42H9AR.3	E01B7.1
+Y46G5A.12	E01B7.1
+Y51H4A.3	E01B7.1
+Y55D9A.1	E01B7.1
+Y65B4A.3	E01B7.1
+Y65B4BR.4	E01B7.1
+Y71H2B.10	E01B7.1
+Y87G2A.10	E01B7.1
+Y92H12A.2	E01B7.1
+ZK1067.1	E01B7.1
+F07F6.4	F02E8.3
+F09E5.1	F02E8.3
+F11F1.1	F02E8.3
+F17C11.8	F02E8.3
+F19C6.1	F02E8.3
+F23C8.6	F02E8.3
+F26D10.3	F02E8.3
+F35A5.8	F02E8.3
+F41E6.9	F02E8.3
+F44E5.4	F02E8.3
+F44E5.5	F02E8.3
+F53G12.1	F02E8.3
+F53H8.2	F02E8.3
+F54E7.3	F02E8.3
+F55A12.3	F02E8.3
+F55C12.1	F02E8.3
+F59F3.1	F02E8.3
+F59F3.5	F02E8.3
+K02B12.7	F02E8.3
+M02A10.3	F02E8.3
+M02B7.5	F02E8.3
+R07G3.1	F02E8.3
+R10E12.1	F02E8.3
+R12C12.5	F02E8.3
+R160.1	F02E8.3
+T04C10.2	F02E8.3
+T04D1.3	F02E8.3
+T10G3.5	F02E8.3
+T12E12.4	F02E8.3
+T13F2.8	F02E8.3
+T17A3.1	F02E8.3
+T20B5.1	F02E8.3
+T20G5.1	F02E8.3
+T24B8.2	F02E8.3
+T26E3.3	F02E8.3
+T27F7.1	F02E8.3
+VF11C1L.1	F02E8.3
+W02A11.2	F02E8.3
+W02B3.2	F02E8.3
+W03C9.3	F02E8.3
+W04G5.2	F02E8.3
+W06H8.1	F02E8.3
+W09D10.1	F02E8.3
+Y116A8C.12	F02E8.3
+Y17G7B.15	F02E8.3
+Y32F6B.3	F02E8.3
+Y34D9A.10	F02E8.3
+Y39A1A.15	F02E8.3
+Y42H9AR.3	F02E8.3
+Y46G5A.12	F02E8.3
+Y51H4A.3	F02E8.3
+Y55D9A.1	F02E8.3
+Y65B4A.3	F02E8.3
+Y65B4BR.4	F02E8.3
+Y71H2B.10	F02E8.3
+Y87G2A.10	F02E8.3
+Y92H12A.2	F02E8.3
+ZK1067.1	F02E8.3
+F09E5.1	F07F6.4
+F11F1.1	F07F6.4
+F17C11.8	F07F6.4
+F19C6.1	F07F6.4
+F23C8.6	F07F6.4
+F26D10.3	F07F6.4
+F35A5.8	F07F6.4
+F41E6.9	F07F6.4
+F44E5.4	F07F6.4
+F44E5.5	F07F6.4
+F53G12.1	F07F6.4
+F53H8.2	F07F6.4
+F54E7.3	F07F6.4
+F55A12.3	F07F6.4
+F55C12.1	F07F6.4
+F59F3.1	F07F6.4
+F59F3.5	F07F6.4
+K02B12.7	F07F6.4
+M02A10.3	F07F6.4
+M02B7.5	F07F6.4
+R07G3.1	F07F6.4
+R10E12.1	F07F6.4
+R12C12.5	F07F6.4
+R160.1	F07F6.4
+T04C10.2	F07F6.4
+T04D1.3	F07F6.4
+T10G3.5	F07F6.4
+T12E12.4	F07F6.4
+T13F2.8	F07F6.4
+T17A3.1	F07F6.4
+T20B5.1	F07F6.4
+T20G5.1	F07F6.4
+T24B8.2	F07F6.4
+T26E3.3	F07F6.4
+T27F7.1	F07F6.4
+VF11C1L.1	F07F6.4
+W02A11.2	F07F6.4
+W02B3.2	F07F6.4
+W03C9.3	F07F6.4
+W04G5.2	F07F6.4
+W06H8.1	F07F6.4
+W09D10.1	F07F6.4
+Y116A8C.12	F07F6.4
+Y17G7B.15	F07F6.4
+Y32F6B.3	F07F6.4
+Y34D9A.10	F07F6.4
+Y39A1A.15	F07F6.4
+Y42H9AR.3	F07F6.4
+Y46G5A.12	F07F6.4
+Y51H4A.3	F07F6.4
+Y55D9A.1	F07F6.4
+Y65B4A.3	F07F6.4
+Y65B4BR.4	F07F6.4
+Y71H2B.10	F07F6.4
+Y87G2A.10	F07F6.4
+Y92H12A.2	F07F6.4
+ZK1067.1	F07F6.4
+F11F1.1	F09E5.1
+F17C11.8	F09E5.1
+F19C6.1	F09E5.1
+F23C8.6	F09E5.1
+F26D10.3	F09E5.1
+F35A5.8	F09E5.1
+F41E6.9	F09E5.1
+F44E5.4	F09E5.1
+F44E5.5	F09E5.1
+F53G12.1	F09E5.1
+F53H8.2	F09E5.1
+F54E7.3	F09E5.1
+F55A12.3	F09E5.1
+F55C12.1	F09E5.1
+F59F3.1	F09E5.1
+F59F3.5	F09E5.1
+K02B12.7	F09E5.1
+M02A10.3	F09E5.1
+M02B7.5	F09E5.1
+R07G3.1	F09E5.1
+R10E12.1	F09E5.1
+R12C12.5	F09E5.1
+R160.1	F09E5.1
+T04C10.2	F09E5.1
+T04D1.3	F09E5.1
+T10G3.5	F09E5.1
+T12E12.4	F09E5.1
+T13F2.8	F09E5.1
+T17A3.1	F09E5.1
+T20B5.1	F09E5.1
+T20G5.1	F09E5.1
+T24B8.2	F09E5.1
+T26E3.3	F09E5.1
+T27F7.1	F09E5.1
+VF11C1L.1	F09E5.1
+W02A11.2	F09E5.1
+W02B3.2	F09E5.1
+W03C9.3	F09E5.1
+W04G5.2	F09E5.1
+W06H8.1	F09E5.1
+W09D10.1	F09E5.1
+Y116A8C.12	F09E5.1
+Y17G7B.15	F09E5.1
+Y32F6B.3	F09E5.1
+Y34D9A.10	F09E5.1
+Y39A1A.15	F09E5.1
+Y42H9AR.3	F09E5.1
+Y46G5A.12	F09E5.1
+Y51H4A.3	F09E5.1
+Y55D9A.1	F09E5.1
+Y65B4A.3	F09E5.1
+Y65B4BR.4	F09E5.1
+Y71H2B.10	F09E5.1
+Y87G2A.10	F09E5.1
+Y92H12A.2	F09E5.1
+ZK1067.1	F09E5.1
+F17C11.8	F11F1.1
+F19C6.1	F11F1.1
+F23C8.6	F11F1.1
+F35A5.8	F11F1.1
+F41E6.9	F11F1.1
+F53G12.1	F11F1.1
+F54E7.3	F11F1.1
+F55A12.3	F11F1.1
+F55C12.1	F11F1.1
+F59F3.1	F11F1.1
+F59F3.5	F11F1.1
+K02B12.7	F11F1.1
+M02A10.3	F11F1.1
+M02B7.5	F11F1.1
+R10E12.1	F11F1.1
+R12C12.5	F11F1.1
+R160.1	F11F1.1
+T04C10.2	F11F1.1
+T04D1.3	F11F1.1
+T10G3.5	F11F1.1
+T12E12.4	F11F1.1
+T13F2.8	F11F1.1
+T17A3.1	F11F1.1
+T20B5.1	F11F1.1
+T20G5.1	F11F1.1
+T24B8.2	F11F1.1
+T26E3.3	F11F1.1
+T27F7.1	F11F1.1
+VF11C1L.1	F11F1.1
+W02A11.2	F11F1.1
+W02B3.2	F11F1.1
+W03C9.3	F11F1.1
+W04G5.2	F11F1.1
+W06H8.1	F11F1.1
+W09D10.1	F11F1.1
+Y116A8C.12	F11F1.1
+Y17G7B.15	F11F1.1
+Y34D9A.10	F11F1.1
+Y39A1A.15	F11F1.1
+Y42H9AR.3	F11F1.1
+Y46G5A.12	F11F1.1
+Y51H4A.3	F11F1.1
+Y55D9A.1	F11F1.1
+Y65B4A.3	F11F1.1
+Y65B4BR.4	F11F1.1
+Y71H2B.10	F11F1.1
+Y87G2A.10	F11F1.1
+Y92H12A.2	F11F1.1
+F19C6.1	F17C11.8
+F23C8.6	F17C11.8
+F26D10.3	F17C11.8
+F35A5.8	F17C11.8
+F41E6.9	F17C11.8
+F44E5.4	F17C11.8
+F44E5.5	F17C11.8
+F53G12.1	F17C11.8
+F53H8.2	F17C11.8
+F54E7.3	F17C11.8
+F55A12.3	F17C11.8
+F55C12.1	F17C11.8
+F59F3.1	F17C11.8
+F59F3.5	F17C11.8
+K02B12.7	F17C11.8
+M02A10.3	F17C11.8
+M02B7.5	F17C11.8
+R07G3.1	F17C11.8
+R10E12.1	F17C11.8
+R12C12.5	F17C11.8
+R160.1	F17C11.8
+T04C10.2	F17C11.8
+T04D1.3	F17C11.8
+T10G3.5	F17C11.8
+T12E12.4	F17C11.8
+T13F2.8	F17C11.8
+T17A3.1	F17C11.8
+T20B5.1	F17C11.8
+T20G5.1	F17C11.8
+T24B8.2	F17C11.8
+T26E3.3	F17C11.8
+T27F7.1	F17C11.8
+VF11C1L.1	F17C11.8
+W02A11.2	F17C11.8
+W02B3.2	F17C11.8
+W03C9.3	F17C11.8
+W04G5.2	F17C11.8
+W06H8.1	F17C11.8
+W09D10.1	F17C11.8
+Y116A8C.12	F17C11.8
+Y17G7B.15	F17C11.8
+Y32F6B.3	F17C11.8
+Y34D9A.10	F17C11.8
+Y39A1A.15	F17C11.8
+Y42H9AR.3	F17C11.8
+Y46G5A.12	F17C11.8
+Y51H4A.3	F17C11.8
+Y55D9A.1	F17C11.8
+Y65B4A.3	F17C11.8
+Y65B4BR.4	F17C11.8
+Y71H2B.10	F17C11.8
+Y87G2A.10	F17C11.8
+Y92H12A.2	F17C11.8
+ZK1067.1	F17C11.8
+F23C8.6	F19C6.1
+F26D10.3	F19C6.1
+F35A5.8	F19C6.1
+F41E6.9	F19C6.1
+F44E5.4	F19C6.1
+F44E5.5	F19C6.1
+F53G12.1	F19C6.1
+F53H8.2	F19C6.1
+F54E7.3	F19C6.1
+F55A12.3	F19C6.1
+F55C12.1	F19C6.1
+F59F3.1	F19C6.1
+F59F3.5	F19C6.1
+K02B12.7	F19C6.1
+M02A10.3	F19C6.1
+M02B7.5	F19C6.1
+R07G3.1	F19C6.1
+R10E12.1	F19C6.1
+R12C12.5	F19C6.1
+R160.1	F19C6.1
+T04C10.2	F19C6.1
+T04D1.3	F19C6.1
+T10G3.5	F19C6.1
+T12E12.4	F19C6.1
+T13F2.8	F19C6.1
+T17A3.1	F19C6.1
+T20B5.1	F19C6.1
+T20G5.1	F19C6.1
+T24B8.2	F19C6.1
+T26E3.3	F19C6.1
+T27F7.1	F19C6.1
+VF11C1L.1	F19C6.1
+W02A11.2	F19C6.1
+W02B3.2	F19C6.1
+W03C9.3	F19C6.1
+W04G5.2	F19C6.1
+W06H8.1	F19C6.1
+W09D10.1	F19C6.1
+Y116A8C.12	F19C6.1
+Y17G7B.15	F19C6.1
+Y32F6B.3	F19C6.1
+Y34D9A.10	F19C6.1
+Y39A1A.15	F19C6.1
+Y42H9AR.3	F19C6.1
+Y46G5A.12	F19C6.1
+Y51H4A.3	F19C6.1
+Y55D9A.1	F19C6.1
+Y65B4A.3	F19C6.1
+Y65B4BR.4	F19C6.1
+Y71H2B.10	F19C6.1
+Y87G2A.10	F19C6.1
+Y92H12A.2	F19C6.1
+ZK1067.1	F19C6.1
+F26D10.3	F23C8.6
+F35A5.8	F23C8.6
+F41E6.9	F23C8.6
+F44E5.4	F23C8.6
+F44E5.5	F23C8.6
+F53G12.1	F23C8.6
+F53H8.2	F23C8.6
+F54E7.3	F23C8.6
+F55A12.3	F23C8.6
+F55C12.1	F23C8.6
+F59F3.1	F23C8.6
+F59F3.5	F23C8.6
+K02B12.7	F23C8.6
+M02A10.3	F23C8.6
+M02B7.5	F23C8.6
+R07G3.1	F23C8.6
+R10E12.1	F23C8.6
+R12C12.5	F23C8.6
+R160.1	F23C8.6
+T04C10.2	F23C8.6
+T04D1.3	F23C8.6
+T10G3.5	F23C8.6
+T12E12.4	F23C8.6
+T13F2.8	F23C8.6
+T17A3.1	F23C8.6
+T20B5.1	F23C8.6
+T20G5.1	F23C8.6
+T24B8.2	F23C8.6
+T26E3.3	F23C8.6
+T27F7.1	F23C8.6
+VF11C1L.1	F23C8.6
+W02A11.2	F23C8.6
+W02B3.2	F23C8.6
+W03C9.3	F23C8.6
+W04G5.2	F23C8.6
+W06H8.1	F23C8.6
+W09D10.1	F23C8.6
+Y116A8C.12	F23C8.6
+Y17G7B.15	F23C8.6
+Y32F6B.3	F23C8.6
+Y34D9A.10	F23C8.6
+Y39A1A.15	F23C8.6
+Y42H9AR.3	F23C8.6
+Y46G5A.12	F23C8.6
+Y51H4A.3	F23C8.6
+Y55D9A.1	F23C8.6
+Y65B4A.3	F23C8.6
+Y65B4BR.4	F23C8.6
+Y71H2B.10	F23C8.6
+Y87G2A.10	F23C8.6
+Y92H12A.2	F23C8.6
+ZK1067.1	F23C8.6
+F35A5.8	F26D10.3
+F41E6.9	F26D10.3
+F53G12.1	F26D10.3
+F54E7.3	F26D10.3
+F55A12.3	F26D10.3
+F55C12.1	F26D10.3
+F59F3.1	F26D10.3
+F59F3.5	F26D10.3
+K02B12.7	F26D10.3
+M02A10.3	F26D10.3
+M02B7.5	F26D10.3
+R10E12.1	F26D10.3
+R12C12.5	F26D10.3
+R160.1	F26D10.3
+T04C10.2	F26D10.3
+T04D1.3	F26D10.3
+T10G3.5	F26D10.3
+T12E12.4	F26D10.3
+T13F2.8	F26D10.3
+T17A3.1	F26D10.3
+T20B5.1	F26D10.3
+T20G5.1	F26D10.3
+T24B8.2	F26D10.3
+T26E3.3	F26D10.3
+T27F7.1	F26D10.3
+VF11C1L.1	F26D10.3
+W02A11.2	F26D10.3
+W02B3.2	F26D10.3
+W03C9.3	F26D10.3
+W04G5.2	F26D10.3
+W06H8.1	F26D10.3
+W09D10.1	F26D10.3
+Y116A8C.12	F26D10.3
+Y17G7B.15	F26D10.3
+Y34D9A.10	F26D10.3
+Y39A1A.15	F26D10.3
+Y42H9AR.3	F26D10.3
+Y46G5A.12	F26D10.3
+Y51H4A.3	F26D10.3
+Y55D9A.1	F26D10.3
+Y65B4A.3	F26D10.3
+Y65B4BR.4	F26D10.3
+Y71H2B.10	F26D10.3
+Y87G2A.10	F26D10.3
+Y92H12A.2	F26D10.3
+F41E6.9	F35A5.8
+F44E5.4	F35A5.8
+F44E5.5	F35A5.8
+F53G12.1	F35A5.8
+F53H8.2	F35A5.8
+F54E7.3	F35A5.8
+F55A12.3	F35A5.8
+F55C12.1	F35A5.8
+F59F3.1	F35A5.8
+F59F3.5	F35A5.8
+K02B12.7	F35A5.8
+M02A10.3	F35A5.8
+M02B7.5	F35A5.8
+R07G3.1	F35A5.8
+R10E12.1	F35A5.8
+R12C12.5	F35A5.8
+R160.1	F35A5.8
+T04C10.2	F35A5.8
+T04D1.3	F35A5.8
+T10G3.5	F35A5.8
+T12E12.4	F35A5.8
+T13F2.8	F35A5.8
+T17A3.1	F35A5.8
+T20B5.1	F35A5.8
+T20G5.1	F35A5.8
+T24B8.2	F35A5.8
+T26E3.3	F35A5.8
+T27F7.1	F35A5.8
+VF11C1L.1	F35A5.8
+W02A11.2	F35A5.8
+W02B3.2	F35A5.8
+W03C9.3	F35A5.8
+W04G5.2	F35A5.8
+W06H8.1	F35A5.8
+W09D10.1	F35A5.8
+Y116A8C.12	F35A5.8
+Y17G7B.15	F35A5.8
+Y32F6B.3	F35A5.8
+Y34D9A.10	F35A5.8
+Y39A1A.15	F35A5.8
+Y42H9AR.3	F35A5.8
+Y46G5A.12	F35A5.8
+Y51H4A.3	F35A5.8
+Y55D9A.1	F35A5.8
+Y65B4A.3	F35A5.8
+Y65B4BR.4	F35A5.8
+Y71H2B.10	F35A5.8
+Y87G2A.10	F35A5.8
+Y92H12A.2	F35A5.8
+ZK1067.1	F35A5.8
+F44E5.4	F41E6.9
+F44E5.5	F41E6.9
+F53G12.1	F41E6.9
+F53H8.2	F41E6.9
+F54E7.3	F41E6.9
+F55A12.3	F41E6.9
+F55C12.1	F41E6.9
+F59F3.1	F41E6.9
+F59F3.5	F41E6.9
+K02B12.7	F41E6.9
+M02A10.3	F41E6.9
+M02B7.5	F41E6.9
+R07G3.1	F41E6.9
+R10E12.1	F41E6.9
+R12C12.5	F41E6.9
+R160.1	F41E6.9
+T04C10.2	F41E6.9
+T04D1.3	F41E6.9
+T10G3.5	F41E6.9
+T12E12.4	F41E6.9
+T13F2.8	F41E6.9
+T17A3.1	F41E6.9
+T20B5.1	F41E6.9
+T20G5.1	F41E6.9
+T24B8.2	F41E6.9
+T26E3.3	F41E6.9
+T27F7.1	F41E6.9
+VF11C1L.1	F41E6.9
+W02A11.2	F41E6.9
+W02B3.2	F41E6.9
+W03C9.3	F41E6.9
+W04G5.2	F41E6.9
+W06H8.1	F41E6.9
+W09D10.1	F41E6.9
+Y116A8C.12	F41E6.9
+Y17G7B.15	F41E6.9
+Y32F6B.3	F41E6.9
+Y34D9A.10	F41E6.9
+Y39A1A.15	F41E6.9
+Y42H9AR.3	F41E6.9
+Y46G5A.12	F41E6.9
+Y51H4A.3	F41E6.9
+Y55D9A.1	F41E6.9
+Y65B4A.3	F41E6.9
+Y65B4BR.4	F41E6.9
+Y71H2B.10	F41E6.9
+Y87G2A.10	F41E6.9
+Y92H12A.2	F41E6.9
+ZK1067.1	F41E6.9
+F53G12.1	F44E5.4
+F54E7.3	F44E5.4
+F55A12.3	F44E5.4
+F55C12.1	F44E5.4
+F59F3.1	F44E5.4
+F59F3.5	F44E5.4
+K02B12.7	F44E5.4
+M02A10.3	F44E5.4
+M02B7.5	F44E5.4
+R10E12.1	F44E5.4
+R12C12.5	F44E5.4
+R160.1	F44E5.4
+T04C10.2	F44E5.4
+T04D1.3	F44E5.4
+T10G3.5	F44E5.4
+T12E12.4	F44E5.4
+T13F2.8	F44E5.4
+T17A3.1	F44E5.4
+T20B5.1	F44E5.4
+T20G5.1	F44E5.4
+T24B8.2	F44E5.4
+T26E3.3	F44E5.4
+T27F7.1	F44E5.4
+VF11C1L.1	F44E5.4
+W02A11.2	F44E5.4
+W02B3.2	F44E5.4
+W03C9.3	F44E5.4
+W04G5.2	F44E5.4
+W06H8.1	F44E5.4
+W09D10.1	F44E5.4
+Y116A8C.12	F44E5.4
+Y17G7B.15	F44E5.4
+Y34D9A.10	F44E5.4
+Y39A1A.15	F44E5.4
+Y42H9AR.3	F44E5.4
+Y46G5A.12	F44E5.4
+Y51H4A.3	F44E5.4
+Y55D9A.1	F44E5.4
+Y65B4A.3	F44E5.4
+Y65B4BR.4	F44E5.4
+Y71H2B.10	F44E5.4
+Y87G2A.10	F44E5.4
+Y92H12A.2	F44E5.4
+F53G12.1	F44E5.5
+F54E7.3	F44E5.5
+F55A12.3	F44E5.5
+F55C12.1	F44E5.5
+F59F3.1	F44E5.5
+F59F3.5	F44E5.5
+K02B12.7	F44E5.5
+M02A10.3	F44E5.5
+M02B7.5	F44E5.5
+R10E12.1	F44E5.5
+R12C12.5	F44E5.5
+R160.1	F44E5.5
+T04C10.2	F44E5.5
+T04D1.3	F44E5.5
+T10G3.5	F44E5.5
+T12E12.4	F44E5.5
+T13F2.8	F44E5.5
+T17A3.1	F44E5.5
+T20B5.1	F44E5.5
+T20G5.1	F44E5.5
+T24B8.2	F44E5.5
+T26E3.3	F44E5.5
+T27F7.1	F44E5.5
+VF11C1L.1	F44E5.5
+W02A11.2	F44E5.5
+W02B3.2	F44E5.5
+W03C9.3	F44E5.5
+W04G5.2	F44E5.5
+W06H8.1	F44E5.5
+W09D10.1	F44E5.5
+Y116A8C.12	F44E5.5
+Y17G7B.15	F44E5.5
+Y34D9A.10	F44E5.5
+Y39A1A.15	F44E5.5
+Y42H9AR.3	F44E5.5
+Y46G5A.12	F44E5.5
+Y51H4A.3	F44E5.5
+Y55D9A.1	F44E5.5
+Y65B4A.3	F44E5.5
+Y65B4BR.4	F44E5.5
+Y71H2B.10	F44E5.5
+Y87G2A.10	F44E5.5
+Y92H12A.2	F44E5.5
+F53H8.2	F53G12.1
+F54E7.3	F53G12.1
+F55A12.3	F53G12.1
+F55C12.1	F53G12.1
+F59F3.1	F53G12.1
+F59F3.5	F53G12.1
+K02B12.7	F53G12.1
+M02A10.3	F53G12.1
+M02B7.5	F53G12.1
+R07G3.1	F53G12.1
+R10E12.1	F53G12.1
+R12C12.5	F53G12.1
+R160.1	F53G12.1
+T04C10.2	F53G12.1
+T04D1.3	F53G12.1
+T10G3.5	F53G12.1
+T12E12.4	F53G12.1
+T13F2.8	F53G12.1
+T17A3.1	F53G12.1
+T20B5.1	F53G12.1
+T20G5.1	F53G12.1
+T24B8.2	F53G12.1
+T26E3.3	F53G12.1
+T27F7.1	F53G12.1
+VF11C1L.1	F53G12.1
+W02A11.2	F53G12.1
+W02B3.2	F53G12.1
+W03C9.3	F53G12.1
+W04G5.2	F53G12.1
+W06H8.1	F53G12.1
+W09D10.1	F53G12.1
+Y116A8C.12	F53G12.1
+Y17G7B.15	F53G12.1
+Y32F6B.3	F53G12.1
+Y34D9A.10	F53G12.1
+Y39A1A.15	F53G12.1
+Y42H9AR.3	F53G12.1
+Y46G5A.12	F53G12.1
+Y51H4A.3	F53G12.1
+Y55D9A.1	F53G12.1
+Y65B4A.3	F53G12.1
+Y65B4BR.4	F53G12.1
+Y71H2B.10	F53G12.1
+Y87G2A.10	F53G12.1
+Y92H12A.2	F53G12.1
+ZK1067.1	F53G12.1
+F54E7.3	F53H8.2
+F55A12.3	F53H8.2
+F55C12.1	F53H8.2
+F59F3.1	F53H8.2
+F59F3.5	F53H8.2
+K02B12.7	F53H8.2
+M02A10.3	F53H8.2
+M02B7.5	F53H8.2
+R10E12.1	F53H8.2
+R12C12.5	F53H8.2
+R160.1	F53H8.2
+T04C10.2	F53H8.2
+T04D1.3	F53H8.2
+T10G3.5	F53H8.2
+T12E12.4	F53H8.2
+T13F2.8	F53H8.2
+T17A3.1	F53H8.2
+T20B5.1	F53H8.2
+T20G5.1	F53H8.2
+T24B8.2	F53H8.2
+T26E3.3	F53H8.2
+T27F7.1	F53H8.2
+VF11C1L.1	F53H8.2
+W02A11.2	F53H8.2
+W02B3.2	F53H8.2
+W03C9.3	F53H8.2
+W04G5.2	F53H8.2
+W06H8.1	F53H8.2
+W09D10.1	F53H8.2
+Y116A8C.12	F53H8.2
+Y17G7B.15	F53H8.2
+Y34D9A.10	F53H8.2
+Y39A1A.15	F53H8.2
+Y42H9AR.3	F53H8.2
+Y46G5A.12	F53H8.2
+Y51H4A.3	F53H8.2
+Y55D9A.1	F53H8.2
+Y65B4A.3	F53H8.2
+Y65B4BR.4	F53H8.2
+Y71H2B.10	F53H8.2
+Y87G2A.10	F53H8.2
+Y92H12A.2	F53H8.2
+F55A12.3	F54E7.3
+F55C12.1	F54E7.3
+F59F3.1	F54E7.3
+F59F3.5	F54E7.3
+K02B12.7	F54E7.3
+M02A10.3	F54E7.3
+M02B7.5	F54E7.3
+R07G3.1	F54E7.3
+R10E12.1	F54E7.3
+R12C12.5	F54E7.3
+R160.1	F54E7.3
+T04C10.2	F54E7.3
+T04D1.3	F54E7.3
+T10G3.5	F54E7.3
+T12E12.4	F54E7.3
+T13F2.8	F54E7.3
+T17A3.1	F54E7.3
+T20B5.1	F54E7.3
+T20G5.1	F54E7.3
+T24B8.2	F54E7.3
+T26E3.3	F54E7.3
+T27F7.1	F54E7.3
+VF11C1L.1	F54E7.3
+W02A11.2	F54E7.3
+W02B3.2	F54E7.3
+W03C9.3	F54E7.3
+W04G5.2	F54E7.3
+W06H8.1	F54E7.3
+W09D10.1	F54E7.3
+Y116A8C.12	F54E7.3
+Y17G7B.15	F54E7.3
+Y32F6B.3	F54E7.3
+Y34D9A.10	F54E7.3
+Y39A1A.15	F54E7.3
+Y42H9AR.3	F54E7.3
+Y46G5A.12	F54E7.3
+Y51H4A.3	F54E7.3
+Y55D9A.1	F54E7.3
+Y65B4A.3	F54E7.3
+Y65B4BR.4	F54E7.3
+Y71H2B.10	F54E7.3
+Y87G2A.10	F54E7.3
+Y92H12A.2	F54E7.3
+ZK1067.1	F54E7.3
+F55C12.1	F55A12.3
+F59F3.1	F55A12.3
+F59F3.5	F55A12.3
+K02B12.7	F55A12.3
+M02A10.3	F55A12.3
+M02B7.5	F55A12.3
+R07G3.1	F55A12.3
+R10E12.1	F55A12.3
+R12C12.5	F55A12.3
+R160.1	F55A12.3
+T04C10.2	F55A12.3
+T04D1.3	F55A12.3
+T10G3.5	F55A12.3
+T12E12.4	F55A12.3
+T13F2.8	F55A12.3
+T17A3.1	F55A12.3
+T20B5.1	F55A12.3
+T20G5.1	F55A12.3
+T24B8.2	F55A12.3
+T26E3.3	F55A12.3
+T27F7.1	F55A12.3
+W02A11.2	F55A12.3
+W02B3.2	F55A12.3
+W03C9.3	F55A12.3
+W04G5.2	F55A12.3
+W06H8.1	F55A12.3
+W09D10.1	F55A12.3
+Y116A8C.12	F55A12.3
+Y17G7B.15	F55A12.3
+Y32F6B.3	F55A12.3
+Y34D9A.10	F55A12.3
+Y39A1A.15	F55A12.3
+Y42H9AR.3	F55A12.3
+Y46G5A.12	F55A12.3
+Y51H4A.3	F55A12.3
+Y55D9A.1	F55A12.3
+Y65B4A.3	F55A12.3
+Y65B4BR.4	F55A12.3
+Y71H2B.10	F55A12.3
+Y87G2A.10	F55A12.3
+Y92H12A.2	F55A12.3
+ZK1067.1	F55A12.3
+F59F3.1	F55C12.1
+F59F3.5	F55C12.1
+K02B12.7	F55C12.1
+M02A10.3	F55C12.1
+M02B7.5	F55C12.1
+R07G3.1	F55C12.1
+R10E12.1	F55C12.1
+R12C12.5	F55C12.1
+R160.1	F55C12.1
+T04C10.2	F55C12.1
+T04D1.3	F55C12.1
+T10G3.5	F55C12.1
+T12E12.4	F55C12.1
+T13F2.8	F55C12.1
+T17A3.1	F55C12.1
+T20B5.1	F55C12.1
+T20G5.1	F55C12.1
+T24B8.2	F55C12.1
+T26E3.3	F55C12.1
+T27F7.1	F55C12.1
+VF11C1L.1	F55C12.1
+W02A11.2	F55C12.1
+W02B3.2	F55C12.1
+W03C9.3	F55C12.1
+W04G5.2	F55C12.1
+W06H8.1	F55C12.1
+W09D10.1	F55C12.1
+Y116A8C.12	F55C12.1
+Y17G7B.15	F55C12.1
+Y32F6B.3	F55C12.1
+Y34D9A.10	F55C12.1
+Y39A1A.15	F55C12.1
+Y42H9AR.3	F55C12.1
+Y46G5A.12	F55C12.1
+Y51H4A.3	F55C12.1
+Y55D9A.1	F55C12.1
+Y65B4A.3	F55C12.1
+Y65B4BR.4	F55C12.1
+Y71H2B.10	F55C12.1
+Y87G2A.10	F55C12.1
+Y92H12A.2	F55C12.1
+ZK1067.1	F55C12.1
+F59F3.5	F59F3.1
+K02B12.7	F59F3.1
+M02A10.3	F59F3.1
+M02B7.5	F59F3.1
+R07G3.1	F59F3.1
+R10E12.1	F59F3.1
+R12C12.5	F59F3.1
+R160.1	F59F3.1
+T04C10.2	F59F3.1
+T04D1.3	F59F3.1
+T10G3.5	F59F3.1
+T12E12.4	F59F3.1
+T13F2.8	F59F3.1
+T17A3.1	F59F3.1
+T20B5.1	F59F3.1
+T20G5.1	F59F3.1
+T24B8.2	F59F3.1
+T26E3.3	F59F3.1
+T27F7.1	F59F3.1
+VF11C1L.1	F59F3.1
+W02A11.2	F59F3.1
+W02B3.2	F59F3.1
+W03C9.3	F59F3.1
+W04G5.2	F59F3.1
+W06H8.1	F59F3.1
+W09D10.1	F59F3.1
+Y116A8C.12	F59F3.1
+Y17G7B.15	F59F3.1
+Y32F6B.3	F59F3.1
+Y34D9A.10	F59F3.1
+Y39A1A.15	F59F3.1
+Y42H9AR.3	F59F3.1
+Y46G5A.12	F59F3.1
+Y51H4A.3	F59F3.1
+Y55D9A.1	F59F3.1
+Y65B4A.3	F59F3.1
+Y65B4BR.4	F59F3.1
+Y71H2B.10	F59F3.1
+Y87G2A.10	F59F3.1
+Y92H12A.2	F59F3.1
+ZK1067.1	F59F3.1
+K02B12.7	F59F3.5
+M02A10.3	F59F3.5
+M02B7.5	F59F3.5
+R07G3.1	F59F3.5
+R10E12.1	F59F3.5
+R12C12.5	F59F3.5
+R160.1	F59F3.5
+T04C10.2	F59F3.5
+T04D1.3	F59F3.5
+T10G3.5	F59F3.5
+T12E12.4	F59F3.5
+T13F2.8	F59F3.5
+T17A3.1	F59F3.5
+T20B5.1	F59F3.5
+T20G5.1	F59F3.5
+T24B8.2	F59F3.5
+T26E3.3	F59F3.5
+T27F7.1	F59F3.5
+VF11C1L.1	F59F3.5
+W02A11.2	F59F3.5
+W02B3.2	F59F3.5
+W03C9.3	F59F3.5
+W04G5.2	F59F3.5
+W06H8.1	F59F3.5
+W09D10.1	F59F3.5
+Y116A8C.12	F59F3.5
+Y17G7B.15	F59F3.5
+Y32F6B.3	F59F3.5
+Y34D9A.10	F59F3.5
+Y39A1A.15	F59F3.5
+Y42H9AR.3	F59F3.5
+Y46G5A.12	F59F3.5
+Y51H4A.3	F59F3.5
+Y55D9A.1	F59F3.5
+Y65B4A.3	F59F3.5
+Y65B4BR.4	F59F3.5
+Y71H2B.10	F59F3.5
+Y87G2A.10	F59F3.5
+Y92H12A.2	F59F3.5
+ZK1067.1	F59F3.5
+M02A10.3	K02B12.7
+M02B7.5	K02B12.7
+R07G3.1	K02B12.7
+R10E12.1	K02B12.7
+R12C12.5	K02B12.7
+R160.1	K02B12.7
+T04C10.2	K02B12.7
+T04D1.3	K02B12.7
+T10G3.5	K02B12.7
+T12E12.4	K02B12.7
+T13F2.8	K02B12.7
+T17A3.1	K02B12.7
+T20B5.1	K02B12.7
+T20G5.1	K02B12.7
+T24B8.2	K02B12.7
+T26E3.3	K02B12.7
+T27F7.1	K02B12.7
+VF11C1L.1	K02B12.7
+W02A11.2	K02B12.7
+W02B3.2	K02B12.7
+W03C9.3	K02B12.7
+W04G5.2	K02B12.7
+W06H8.1	K02B12.7
+W09D10.1	K02B12.7
+Y116A8C.12	K02B12.7
+Y17G7B.15	K02B12.7
+Y32F6B.3	K02B12.7
+Y34D9A.10	K02B12.7
+Y39A1A.15	K02B12.7
+Y42H9AR.3	K02B12.7
+Y46G5A.12	K02B12.7
+Y51H4A.3	K02B12.7
+Y55D9A.1	K02B12.7
+Y65B4A.3	K02B12.7
+Y65B4BR.4	K02B12.7
+Y71H2B.10	K02B12.7
+Y87G2A.10	K02B12.7
+Y92H12A.2	K02B12.7
+ZK1067.1	K02B12.7
+M02B7.5	M02A10.3
+R07G3.1	M02A10.3
+R10E12.1	M02A10.3
+R12C12.5	M02A10.3
+R160.1	M02A10.3
+T04C10.2	M02A10.3
+T04D1.3	M02A10.3
+T10G3.5	M02A10.3
+T12E12.4	M02A10.3
+T13F2.8	M02A10.3
+T17A3.1	M02A10.3
+T20B5.1	M02A10.3
+T20G5.1	M02A10.3
+T24B8.2	M02A10.3
+T26E3.3	M02A10.3
+T27F7.1	M02A10.3
+VF11C1L.1	M02A10.3
+W02A11.2	M02A10.3
+W02B3.2	M02A10.3
+W03C9.3	M02A10.3
+W04G5.2	M02A10.3
+W06H8.1	M02A10.3
+W09D10.1	M02A10.3
+Y116A8C.12	M02A10.3
+Y17G7B.15	M02A10.3
+Y32F6B.3	M02A10.3
+Y34D9A.10	M02A10.3
+Y39A1A.15	M02A10.3
+Y42H9AR.3	M02A10.3
+Y46G5A.12	M02A10.3
+Y51H4A.3	M02A10.3
+Y55D9A.1	M02A10.3
+Y65B4A.3	M02A10.3
+Y71H2B.10	M02A10.3
+Y87G2A.10	M02A10.3
+R07G3.1	M02B7.5
+R10E12.1	M02B7.5
+R12C12.5	M02B7.5
+R160.1	M02B7.5
+T04C10.2	M02B7.5
+T04D1.3	M02B7.5
+T10G3.5	M02B7.5
+T12E12.4	M02B7.5
+T13F2.8	M02B7.5
+T17A3.1	M02B7.5
+T20B5.1	M02B7.5
+T20G5.1	M02B7.5
+T24B8.2	M02B7.5
+T26E3.3	M02B7.5
+T27F7.1	M02B7.5
+VF11C1L.1	M02B7.5
+W02A11.2	M02B7.5
+W02B3.2	M02B7.5
+W03C9.3	M02B7.5
+W04G5.2	M02B7.5
+W06H8.1	M02B7.5
+W09D10.1	M02B7.5
+Y116A8C.12	M02B7.5
+Y17G7B.15	M02B7.5
+Y32F6B.3	M02B7.5
+Y34D9A.10	M02B7.5
+Y39A1A.15	M02B7.5
+Y42H9AR.3	M02B7.5
+Y46G5A.12	M02B7.5
+Y51H4A.3	M02B7.5
+Y55D9A.1	M02B7.5
+Y65B4A.3	M02B7.5
+Y65B4BR.4	M02B7.5
+Y71H2B.10	M02B7.5
+Y87G2A.10	M02B7.5
+Y92H12A.2	M02B7.5
+ZK1067.1	M02B7.5
+R10E12.1	R07G3.1
+R12C12.5	R07G3.1
+R160.1	R07G3.1
+T04C10.2	R07G3.1
+T04D1.3	R07G3.1
+T10G3.5	R07G3.1
+T12E12.4	R07G3.1
+T13F2.8	R07G3.1
+T17A3.1	R07G3.1
+T20B5.1	R07G3.1
+T20G5.1	R07G3.1
+T24B8.2	R07G3.1
+T26E3.3	R07G3.1
+T27F7.1	R07G3.1
+VF11C1L.1	R07G3.1
+W02A11.2	R07G3.1
+W02B3.2	R07G3.1
+W04G5.2	R07G3.1
+W06H8.1	R07G3.1
+W09D10.1	R07G3.1
+Y116A8C.12	R07G3.1
+Y17G7B.15	R07G3.1
+Y34D9A.10	R07G3.1
+Y39A1A.15	R07G3.1
+Y42H9AR.3	R07G3.1
+Y46G5A.12	R07G3.1
+Y55D9A.1	R07G3.1
+Y65B4A.3	R07G3.1
+Y65B4BR.4	R07G3.1
+Y71H2B.10	R07G3.1
+Y87G2A.10	R07G3.1
+Y92H12A.2	R07G3.1
+R12C12.5	R10E12.1
+R160.1	R10E12.1
+T04C10.2	R10E12.1
+T04D1.3	R10E12.1
+T10G3.5	R10E12.1
+T12E12.4	R10E12.1
+T13F2.8	R10E12.1
+T17A3.1	R10E12.1
+T20B5.1	R10E12.1
+T20G5.1	R10E12.1
+T24B8.2	R10E12.1
+T26E3.3	R10E12.1
+T27F7.1	R10E12.1
+VF11C1L.1	R10E12.1
+W02A11.2	R10E12.1
+W02B3.2	R10E12.1
+W03C9.3	R10E12.1
+W04G5.2	R10E12.1
+W06H8.1	R10E12.1
+W09D10.1	R10E12.1
+Y116A8C.12	R10E12.1
+Y17G7B.15	R10E12.1
+Y32F6B.3	R10E12.1
+Y34D9A.10	R10E12.1
+Y39A1A.15	R10E12.1
+Y42H9AR.3	R10E12.1
+Y46G5A.12	R10E12.1
+Y51H4A.3	R10E12.1
+Y55D9A.1	R10E12.1
+Y65B4A.3	R10E12.1
+Y65B4BR.4	R10E12.1
+Y71H2B.10	R10E12.1
+Y87G2A.10	R10E12.1
+Y92H12A.2	R10E12.1
+ZK1067.1	R10E12.1
+R160.1	R12C12.5
+T04C10.2	R12C12.5
+T04D1.3	R12C12.5
+T10G3.5	R12C12.5
+T12E12.4	R12C12.5
+T13F2.8	R12C12.5
+T17A3.1	R12C12.5
+T20B5.1	R12C12.5
+T20G5.1	R12C12.5
+T24B8.2	R12C12.5
+T26E3.3	R12C12.5
+T27F7.1	R12C12.5
+VF11C1L.1	R12C12.5
+W02A11.2	R12C12.5
+W02B3.2	R12C12.5
+W03C9.3	R12C12.5
+W04G5.2	R12C12.5
+W06H8.1	R12C12.5
+W09D10.1	R12C12.5
+Y116A8C.12	R12C12.5
+Y17G7B.15	R12C12.5
+Y32F6B.3	R12C12.5
+Y34D9A.10	R12C12.5
+Y39A1A.15	R12C12.5
+Y42H9AR.3	R12C12.5
+Y46G5A.12	R12C12.5
+Y51H4A.3	R12C12.5
+Y55D9A.1	R12C12.5
+Y65B4A.3	R12C12.5
+Y65B4BR.4	R12C12.5
+Y71H2B.10	R12C12.5
+Y87G2A.10	R12C12.5
+Y92H12A.2	R12C12.5
+ZK1067.1	R12C12.5
+T04C10.2	R160.1
+T04D1.3	R160.1
+T10G3.5	R160.1
+T12E12.4	R160.1
+T13F2.8	R160.1
+T17A3.1	R160.1
+T20B5.1	R160.1
+T20G5.1	R160.1
+T24B8.2	R160.1
+T26E3.3	R160.1
+T27F7.1	R160.1
+VF11C1L.1	R160.1
+W02A11.2	R160.1
+W02B3.2	R160.1
+W03C9.3	R160.1
+W04G5.2	R160.1
+W06H8.1	R160.1
+W09D10.1	R160.1
+Y116A8C.12	R160.1
+Y17G7B.15	R160.1
+Y32F6B.3	R160.1
+Y34D9A.10	R160.1
+Y39A1A.15	R160.1
+Y42H9AR.3	R160.1
+Y46G5A.12	R160.1
+Y51H4A.3	R160.1
+Y55D9A.1	R160.1
+Y65B4A.3	R160.1
+Y65B4BR.4	R160.1
+Y71H2B.10	R160.1
+Y87G2A.10	R160.1
+Y92H12A.2	R160.1
+ZK1067.1	R160.1
+T04D1.3	T04C10.2
+T10G3.5	T04C10.2
+T12E12.4	T04C10.2
+T13F2.8	T04C10.2
+T17A3.1	T04C10.2
+T20B5.1	T04C10.2
+T20G5.1	T04C10.2
+T24B8.2	T04C10.2
+T26E3.3	T04C10.2
+T27F7.1	T04C10.2
+VF11C1L.1	T04C10.2
+W02A11.2	T04C10.2
+W02B3.2	T04C10.2
+W03C9.3	T04C10.2
+W04G5.2	T04C10.2
+W06H8.1	T04C10.2
+W09D10.1	T04C10.2
+Y116A8C.12	T04C10.2
+Y17G7B.15	T04C10.2
+Y32F6B.3	T04C10.2
+Y34D9A.10	T04C10.2
+Y39A1A.15	T04C10.2
+Y42H9AR.3	T04C10.2
+Y46G5A.12	T04C10.2
+Y51H4A.3	T04C10.2
+Y55D9A.1	T04C10.2
+Y65B4A.3	T04C10.2
+Y65B4BR.4	T04C10.2
+Y71H2B.10	T04C10.2
+Y87G2A.10	T04C10.2
+Y92H12A.2	T04C10.2
+ZK1067.1	T04C10.2
+T10G3.5	T04D1.3
+T12E12.4	T04D1.3
+T13F2.8	T04D1.3
+T17A3.1	T04D1.3
+T20B5.1	T04D1.3
+T20G5.1	T04D1.3
+T24B8.2	T04D1.3
+T26E3.3	T04D1.3
+T27F7.1	T04D1.3
+VF11C1L.1	T04D1.3
+W02A11.2	T04D1.3
+W02B3.2	T04D1.3
+W03C9.3	T04D1.3
+W04G5.2	T04D1.3
+W06H8.1	T04D1.3
+W09D10.1	T04D1.3
+Y116A8C.12	T04D1.3
+Y17G7B.15	T04D1.3
+Y32F6B.3	T04D1.3
+Y34D9A.10	T04D1.3
+Y39A1A.15	T04D1.3
+Y42H9AR.3	T04D1.3
+Y46G5A.12	T04D1.3
+Y51H4A.3	T04D1.3
+Y55D9A.1	T04D1.3
+Y65B4A.3	T04D1.3
+Y65B4BR.4	T04D1.3
+Y71H2B.10	T04D1.3
+Y87G2A.10	T04D1.3
+Y92H12A.2	T04D1.3
+ZK1067.1	T04D1.3
+T12E12.4	T10G3.5
+T13F2.8	T10G3.5
+T17A3.1	T10G3.5
+T20B5.1	T10G3.5
+T20G5.1	T10G3.5
+T24B8.2	T10G3.5
+T26E3.3	T10G3.5
+T27F7.1	T10G3.5
+VF11C1L.1	T10G3.5
+W02A11.2	T10G3.5
+W02B3.2	T10G3.5
+W03C9.3	T10G3.5
+W04G5.2	T10G3.5
+W06H8.1	T10G3.5
+W09D10.1	T10G3.5
+Y116A8C.12	T10G3.5
+Y17G7B.15	T10G3.5
+Y32F6B.3	T10G3.5
+Y34D9A.10	T10G3.5
+Y39A1A.15	T10G3.5
+Y42H9AR.3	T10G3.5
+Y46G5A.12	T10G3.5
+Y51H4A.3	T10G3.5
+Y55D9A.1	T10G3.5
+Y65B4A.3	T10G3.5
+Y65B4BR.4	T10G3.5
+Y71H2B.10	T10G3.5
+Y87G2A.10	T10G3.5
+Y92H12A.2	T10G3.5
+ZK1067.1	T10G3.5
+T13F2.8	T12E12.4
+T17A3.1	T12E12.4
+T20B5.1	T12E12.4
+T20G5.1	T12E12.4
+T24B8.2	T12E12.4
+T26E3.3	T12E12.4
+T27F7.1	T12E12.4
+VF11C1L.1	T12E12.4
+W02A11.2	T12E12.4
+W02B3.2	T12E12.4
+W03C9.3	T12E12.4
+W04G5.2	T12E12.4
+W06H8.1	T12E12.4
+W09D10.1	T12E12.4
+Y116A8C.12	T12E12.4
+Y17G7B.15	T12E12.4
+Y32F6B.3	T12E12.4
+Y34D9A.10	T12E12.4
+Y39A1A.15	T12E12.4
+Y42H9AR.3	T12E12.4
+Y46G5A.12	T12E12.4
+Y51H4A.3	T12E12.4
+Y55D9A.1	T12E12.4
+Y65B4A.3	T12E12.4
+Y65B4BR.4	T12E12.4
+Y71H2B.10	T12E12.4
+Y87G2A.10	T12E12.4
+Y92H12A.2	T12E12.4
+ZK1067.1	T12E12.4
+T17A3.1	T13F2.8
+T20B5.1	T13F2.8
+T20G5.1	T13F2.8
+T24B8.2	T13F2.8
+T26E3.3	T13F2.8
+T27F7.1	T13F2.8
+VF11C1L.1	T13F2.8
+W02A11.2	T13F2.8
+W02B3.2	T13F2.8
+W03C9.3	T13F2.8
+W04G5.2	T13F2.8
+W06H8.1	T13F2.8
+W09D10.1	T13F2.8
+Y116A8C.12	T13F2.8
+Y17G7B.15	T13F2.8
+Y32F6B.3	T13F2.8
+Y34D9A.10	T13F2.8
+Y39A1A.15	T13F2.8
+Y42H9AR.3	T13F2.8
+Y46G5A.12	T13F2.8
+Y51H4A.3	T13F2.8
+Y55D9A.1	T13F2.8
+Y65B4A.3	T13F2.8
+Y65B4BR.4	T13F2.8
+Y71H2B.10	T13F2.8
+Y87G2A.10	T13F2.8
+Y92H12A.2	T13F2.8
+ZK1067.1	T13F2.8
+T20B5.1	T17A3.1
+T20G5.1	T17A3.1
+T24B8.2	T17A3.1
+T26E3.3	T17A3.1
+T27F7.1	T17A3.1
+VF11C1L.1	T17A3.1
+W02A11.2	T17A3.1
+W02B3.2	T17A3.1
+W03C9.3	T17A3.1
+W04G5.2	T17A3.1
+W06H8.1	T17A3.1
+W09D10.1	T17A3.1
+Y116A8C.12	T17A3.1
+Y17G7B.15	T17A3.1
+Y32F6B.3	T17A3.1
+Y34D9A.10	T17A3.1
+Y39A1A.15	T17A3.1
+Y42H9AR.3	T17A3.1
+Y46G5A.12	T17A3.1
+Y51H4A.3	T17A3.1
+Y55D9A.1	T17A3.1
+Y65B4A.3	T17A3.1
+Y65B4BR.4	T17A3.1
+Y71H2B.10	T17A3.1
+Y87G2A.10	T17A3.1
+Y92H12A.2	T17A3.1
+ZK1067.1	T17A3.1
+T20G5.1	T20B5.1
+T24B8.2	T20B5.1
+T26E3.3	T20B5.1
+T27F7.1	T20B5.1
+VF11C1L.1	T20B5.1
+W02A11.2	T20B5.1
+W02B3.2	T20B5.1
+W03C9.3	T20B5.1
+W04G5.2	T20B5.1
+W06H8.1	T20B5.1
+W09D10.1	T20B5.1
+Y116A8C.12	T20B5.1
+Y17G7B.15	T20B5.1
+Y32F6B.3	T20B5.1
+Y34D9A.10	T20B5.1
+Y39A1A.15	T20B5.1
+Y42H9AR.3	T20B5.1
+Y46G5A.12	T20B5.1
+Y51H4A.3	T20B5.1
+Y55D9A.1	T20B5.1
+Y65B4A.3	T20B5.1
+Y65B4BR.4	T20B5.1
+Y71H2B.10	T20B5.1
+Y87G2A.10	T20B5.1
+Y92H12A.2	T20B5.1
+ZK1067.1	T20B5.1
+T24B8.2	T20G5.1
+T26E3.3	T20G5.1
+T27F7.1	T20G5.1
+VF11C1L.1	T20G5.1
+W02A11.2	T20G5.1
+W02B3.2	T20G5.1
+W03C9.3	T20G5.1
+W04G5.2	T20G5.1
+W06H8.1	T20G5.1
+W09D10.1	T20G5.1
+Y116A8C.12	T20G5.1
+Y17G7B.15	T20G5.1
+Y32F6B.3	T20G5.1
+Y34D9A.10	T20G5.1
+Y39A1A.15	T20G5.1
+Y42H9AR.3	T20G5.1
+Y46G5A.12	T20G5.1
+Y51H4A.3	T20G5.1
+Y55D9A.1	T20G5.1
+Y65B4A.3	T20G5.1
+Y65B4BR.4	T20G5.1
+Y71H2B.10	T20G5.1
+Y87G2A.10	T20G5.1
+Y92H12A.2	T20G5.1
+ZK1067.1	T20G5.1
+T26E3.3	T24B8.2
+T27F7.1	T24B8.2
+VF11C1L.1	T24B8.2
+W02A11.2	T24B8.2
+W02B3.2	T24B8.2
+W03C9.3	T24B8.2
+W04G5.2	T24B8.2
+W06H8.1	T24B8.2
+W09D10.1	T24B8.2
+Y116A8C.12	T24B8.2
+Y17G7B.15	T24B8.2
+Y32F6B.3	T24B8.2
+Y34D9A.10	T24B8.2
+Y39A1A.15	T24B8.2
+Y42H9AR.3	T24B8.2
+Y46G5A.12	T24B8.2
+Y51H4A.3	T24B8.2
+Y55D9A.1	T24B8.2
+Y65B4A.3	T24B8.2
+Y65B4BR.4	T24B8.2
+Y71H2B.10	T24B8.2
+Y87G2A.10	T24B8.2
+Y92H12A.2	T24B8.2
+ZK1067.1	T24B8.2
+T27F7.1	T26E3.3
+VF11C1L.1	T26E3.3
+W02A11.2	T26E3.3
+W02B3.2	T26E3.3
+W03C9.3	T26E3.3
+W04G5.2	T26E3.3
+W06H8.1	T26E3.3
+W09D10.1	T26E3.3
+Y116A8C.12	T26E3.3
+Y17G7B.15	T26E3.3
+Y32F6B.3	T26E3.3
+Y34D9A.10	T26E3.3
+Y39A1A.15	T26E3.3
+Y42H9AR.3	T26E3.3
+Y46G5A.12	T26E3.3
+Y51H4A.3	T26E3.3
+Y55D9A.1	T26E3.3
+Y65B4A.3	T26E3.3
+Y65B4BR.4	T26E3.3
+Y71H2B.10	T26E3.3
+Y87G2A.10	T26E3.3
+Y92H12A.2	T26E3.3
+ZK1067.1	T26E3.3
+VF11C1L.1	T27F7.1
+W02A11.2	T27F7.1
+W02B3.2	T27F7.1
+W03C9.3	T27F7.1
+W04G5.2	T27F7.1
+W06H8.1	T27F7.1
+W09D10.1	T27F7.1
+Y116A8C.12	T27F7.1
+Y17G7B.15	T27F7.1
+Y32F6B.3	T27F7.1
+Y34D9A.10	T27F7.1
+Y39A1A.15	T27F7.1
+Y42H9AR.3	T27F7.1
+Y46G5A.12	T27F7.1
+Y51H4A.3	T27F7.1
+Y55D9A.1	T27F7.1
+Y65B4A.3	T27F7.1
+Y65B4BR.4	T27F7.1
+Y71H2B.10	T27F7.1
+Y87G2A.10	T27F7.1
+Y92H12A.2	T27F7.1
+ZK1067.1	T27F7.1
+W02A11.2	VF11C1L.1
+W02B3.2	VF11C1L.1
+W03C9.3	VF11C1L.1
+W04G5.2	VF11C1L.1
+W06H8.1	VF11C1L.1
+W09D10.1	VF11C1L.1
+Y116A8C.12	VF11C1L.1
+Y17G7B.15	VF11C1L.1
+Y32F6B.3	VF11C1L.1
+Y34D9A.10	VF11C1L.1
+Y39A1A.15	VF11C1L.1
+Y42H9AR.3	VF11C1L.1
+Y46G5A.12	VF11C1L.1
+Y51H4A.3	VF11C1L.1
+Y55D9A.1	VF11C1L.1
+Y65B4A.3	VF11C1L.1
+Y65B4BR.4	VF11C1L.1
+Y71H2B.10	VF11C1L.1
+Y87G2A.10	VF11C1L.1
+Y92H12A.2	VF11C1L.1
+ZK1067.1	VF11C1L.1
+W02B3.2	W02A11.2
+W03C9.3	W02A11.2
+W04G5.2	W02A11.2
+W06H8.1	W02A11.2
+W09D10.1	W02A11.2
+Y116A8C.12	W02A11.2
+Y17G7B.15	W02A11.2
+Y32F6B.3	W02A11.2
+Y34D9A.10	W02A11.2
+Y39A1A.15	W02A11.2
+Y42H9AR.3	W02A11.2
+Y46G5A.12	W02A11.2
+Y51H4A.3	W02A11.2
+Y55D9A.1	W02A11.2
+Y65B4A.3	W02A11.2
+Y65B4BR.4	W02A11.2
+Y71H2B.10	W02A11.2
+Y87G2A.10	W02A11.2
+Y92H12A.2	W02A11.2
+ZK1067.1	W02A11.2
+W03C9.3	W02B3.2
+W04G5.2	W02B3.2
+W06H8.1	W02B3.2
+W09D10.1	W02B3.2
+Y116A8C.12	W02B3.2
+Y17G7B.15	W02B3.2
+Y32F6B.3	W02B3.2
+Y34D9A.10	W02B3.2
+Y39A1A.15	W02B3.2
+Y42H9AR.3	W02B3.2
+Y46G5A.12	W02B3.2
+Y51H4A.3	W02B3.2
+Y55D9A.1	W02B3.2
+Y65B4A.3	W02B3.2
+Y65B4BR.4	W02B3.2
+Y71H2B.10	W02B3.2
+Y87G2A.10	W02B3.2
+Y92H12A.2	W02B3.2
+ZK1067.1	W02B3.2
+W04G5.2	W03C9.3
+W06H8.1	W03C9.3
+W09D10.1	W03C9.3
+Y116A8C.12	W03C9.3
+Y17G7B.15	W03C9.3
+Y32F6B.3	W03C9.3
+Y34D9A.10	W03C9.3
+Y39A1A.15	W03C9.3
+Y42H9AR.3	W03C9.3
+Y46G5A.12	W03C9.3
+Y55D9A.1	W03C9.3
+Y65B4A.3	W03C9.3
+Y65B4BR.4	W03C9.3
+Y71H2B.10	W03C9.3
+Y87G2A.10	W03C9.3
+Y92H12A.2	W03C9.3
+ZK1067.1	W03C9.3
+W06H8.1	W04G5.2
+W09D10.1	W04G5.2
+Y116A8C.12	W04G5.2
+Y17G7B.15	W04G5.2
+Y32F6B.3	W04G5.2
+Y34D9A.10	W04G5.2
+Y39A1A.15	W04G5.2
+Y42H9AR.3	W04G5.2
+Y46G5A.12	W04G5.2
+Y51H4A.3	W04G5.2
+Y55D9A.1	W04G5.2
+Y65B4A.3	W04G5.2
+Y65B4BR.4	W04G5.2
+Y71H2B.10	W04G5.2
+Y87G2A.10	W04G5.2
+Y92H12A.2	W04G5.2
+ZK1067.1	W04G5.2
+W09D10.1	W06H8.1
+Y116A8C.12	W06H8.1
+Y17G7B.15	W06H8.1
+Y32F6B.3	W06H8.1
+Y34D9A.10	W06H8.1
+Y39A1A.15	W06H8.1
+Y42H9AR.3	W06H8.1
+Y46G5A.12	W06H8.1
+Y51H4A.3	W06H8.1
+Y55D9A.1	W06H8.1
+Y65B4A.3	W06H8.1
+Y65B4BR.4	W06H8.1
+Y71H2B.10	W06H8.1
+Y87G2A.10	W06H8.1
+Y92H12A.2	W06H8.1
+ZK1067.1	W06H8.1
+Y116A8C.12	W09D10.1
+Y17G7B.15	W09D10.1
+Y32F6B.3	W09D10.1
+Y34D9A.10	W09D10.1
+Y39A1A.15	W09D10.1
+Y42H9AR.3	W09D10.1
+Y46G5A.12	W09D10.1
+Y51H4A.3	W09D10.1
+Y55D9A.1	W09D10.1
+Y65B4A.3	W09D10.1
+Y65B4BR.4	W09D10.1
+Y71H2B.10	W09D10.1
+Y87G2A.10	W09D10.1
+Y92H12A.2	W09D10.1
+ZK1067.1	W09D10.1
+Y17G7B.15	Y116A8C.12
+Y32F6B.3	Y116A8C.12
+Y34D9A.10	Y116A8C.12
+Y39A1A.15	Y116A8C.12
+Y42H9AR.3	Y116A8C.12
+Y46G5A.12	Y116A8C.12
+Y51H4A.3	Y116A8C.12
+Y55D9A.1	Y116A8C.12
+Y65B4A.3	Y116A8C.12
+Y65B4BR.4	Y116A8C.12
+Y71H2B.10	Y116A8C.12
+Y87G2A.10	Y116A8C.12
+Y92H12A.2	Y116A8C.12
+ZK1067.1	Y116A8C.12
+Y32F6B.3	Y17G7B.15
+Y34D9A.10	Y17G7B.15
+Y39A1A.15	Y17G7B.15
+Y42H9AR.3	Y17G7B.15
+Y46G5A.12	Y17G7B.15
+Y51H4A.3	Y17G7B.15
+Y55D9A.1	Y17G7B.15
+Y65B4A.3	Y17G7B.15
+Y65B4BR.4	Y17G7B.15
+Y71H2B.10	Y17G7B.15
+Y87G2A.10	Y17G7B.15
+Y92H12A.2	Y17G7B.15
+ZK1067.1	Y17G7B.15
+Y34D9A.10	Y32F6B.3
+Y39A1A.15	Y32F6B.3
+Y42H9AR.3	Y32F6B.3
+Y46G5A.12	Y32F6B.3
+Y51H4A.3	Y32F6B.3
+Y55D9A.1	Y32F6B.3
+Y65B4A.3	Y32F6B.3
+Y65B4BR.4	Y32F6B.3
+Y71H2B.10	Y32F6B.3
+Y87G2A.10	Y32F6B.3
+Y92H12A.2	Y32F6B.3
+Y39A1A.15	Y34D9A.10
+Y42H9AR.3	Y34D9A.10
+Y46G5A.12	Y34D9A.10
+Y51H4A.3	Y34D9A.10
+Y55D9A.1	Y34D9A.10
+Y65B4A.3	Y34D9A.10
+Y65B4BR.4	Y34D9A.10
+Y71H2B.10	Y34D9A.10
+Y87G2A.10	Y34D9A.10
+Y92H12A.2	Y34D9A.10
+ZK1067.1	Y34D9A.10
+Y42H9AR.3	Y39A1A.15
+Y46G5A.12	Y39A1A.15
+Y51H4A.3	Y39A1A.15
+Y55D9A.1	Y39A1A.15
+Y65B4A.3	Y39A1A.15
+Y65B4BR.4	Y39A1A.15
+Y71H2B.10	Y39A1A.15
+Y87G2A.10	Y39A1A.15
+Y92H12A.2	Y39A1A.15
+ZK1067.1	Y39A1A.15
+Y46G5A.12	Y42H9AR.3
+Y51H4A.3	Y42H9AR.3
+Y55D9A.1	Y42H9AR.3
+Y65B4A.3	Y42H9AR.3
+Y65B4BR.4	Y42H9AR.3
+Y71H2B.10	Y42H9AR.3
+Y87G2A.10	Y42H9AR.3
+Y92H12A.2	Y42H9AR.3
+ZK1067.1	Y42H9AR.3
+Y51H4A.3	Y46G5A.12
+Y55D9A.1	Y46G5A.12
+Y65B4A.3	Y46G5A.12
+Y65B4BR.4	Y46G5A.12
+Y71H2B.10	Y46G5A.12
+Y87G2A.10	Y46G5A.12
+Y92H12A.2	Y46G5A.12
+ZK1067.1	Y46G5A.12
+Y55D9A.1	Y51H4A.3
+Y65B4A.3	Y51H4A.3
+Y65B4BR.4	Y51H4A.3
+Y71H2B.10	Y51H4A.3
+Y87G2A.10	Y51H4A.3
+Y92H12A.2	Y51H4A.3
+ZK1067.1	Y51H4A.3
+Y65B4A.3	Y55D9A.1
+Y65B4BR.4	Y55D9A.1
+Y71H2B.10	Y55D9A.1
+Y87G2A.10	Y55D9A.1
+Y92H12A.2	Y55D9A.1
+ZK1067.1	Y55D9A.1
+Y65B4BR.4	Y65B4A.3
+Y71H2B.10	Y65B4A.3
+Y87G2A.10	Y65B4A.3
+Y92H12A.2	Y65B4A.3
+ZK1067.1	Y65B4A.3
+Y71H2B.10	Y65B4BR.4
+Y87G2A.10	Y65B4BR.4
+ZK1067.1	Y65B4BR.4
+Y87G2A.10	Y71H2B.10
+Y92H12A.2	Y71H2B.10
+ZK1067.1	Y71H2B.10
+Y92H12A.2	Y87G2A.10
+ZK1067.1	Y87G2A.10
+ZK1067.1	Y92H12A.2
+B0272.1	B0025.1
+C03B1.12	B0025.1
+C07G1.5	B0025.1
+C17H12.1	B0025.1
+C17H12.14	B0025.1
+C26H9A.1	B0025.1
+C30F8.2	B0025.1
+C36E8.5	B0025.1
+C39E9.14	B0025.1
+C44B11.3	B0025.1
+C54C6.2	B0025.1
+F18C12.1	B0025.1
+F20B6.2	B0025.1
+F32D8.6	B0025.1
+F35H10.4	B0025.1
+F36F2.4	B0025.1
+F44F4.11	B0025.1
+F46F11.5	B0025.1
+F49C12.13	B0025.1
+F52E1.10	B0025.1
+F55A4.1	B0025.1
+F55H2.2	B0025.1
+K01G5.7	B0025.1
+M03F4.2	B0025.1
+R10E11.2	B0025.1
+R10E11.8	B0025.1
+T01H3.1	B0025.1
+T03E6.7	B0025.1
+T04C12.4	B0025.1
+T04C12.5	B0025.1
+T04C12.6	B0025.1
+T04H1.9	B0025.1
+T10G3.5	B0025.1
+T10H9.3	B0025.1
+T14F9.1	B0025.1
+T21E12.4	B0025.1
+VW02B12L.1	B0025.1
+W03C9.3	B0025.1
+Y110A7A.12	B0025.1
+Y38A10A.5	B0025.1
+Y38F2AL.3	B0025.1
+Y38F2AL.4	B0025.1
+Y38F2AR.9	B0025.1
+Y49A3A.2	B0025.1
+Y55H10A.1	B0025.1
+Y57G11C.15	B0025.1
+ZK1058.2	B0025.1
+ZK154.3	B0025.1
+ZK632.6	B0025.1
+ZK637.8	B0025.1
+ZK970.4	B0025.1
+C03B1.12	B0272.1
+C07G1.5	B0272.1
+C17H12.1	B0272.1
+C17H12.14	B0272.1
+C26H9A.1	B0272.1
+C30F8.2	B0272.1
+C36E8.5	B0272.1
+C39E9.14	B0272.1
+C44B11.3	B0272.1
+C54C6.2	B0272.1
+F18C12.1	B0272.1
+F20B6.2	B0272.1
+F32D8.6	B0272.1
+F35H10.4	B0272.1
+F36F2.4	B0272.1
+F44F4.11	B0272.1
+F46F11.5	B0272.1
+F49C12.13	B0272.1
+F52E1.10	B0272.1
+F55A4.1	B0272.1
+F55H2.2	B0272.1
+K01G5.7	B0272.1
+M03F4.2	B0272.1
+R10E11.2	B0272.1
+R10E11.8	B0272.1
+T01H3.1	B0272.1
+T03E6.7	B0272.1
+T04C12.4	B0272.1
+T04C12.5	B0272.1
+T04C12.6	B0272.1
+T04H1.9	B0272.1
+T10G3.5	B0272.1
+T10H9.3	B0272.1
+T14F9.1	B0272.1
+T21E12.4	B0272.1
+VW02B12L.1	B0272.1
+W03C9.3	B0272.1
+Y110A7A.12	B0272.1
+Y38A10A.5	B0272.1
+Y38F2AL.3	B0272.1
+Y38F2AL.4	B0272.1
+Y38F2AR.9	B0272.1
+Y49A3A.2	B0272.1
+Y55H10A.1	B0272.1
+Y57G11C.15	B0272.1
+ZK1058.2	B0272.1
+ZK154.3	B0272.1
+ZK632.6	B0272.1
+ZK637.8	B0272.1
+ZK970.4	B0272.1
+C07G1.5	C03B1.12
+C17H12.1	C03B1.12
+C17H12.14	C03B1.12
+C36E8.5	C03B1.12
+C39E9.14	C03B1.12
+C44B11.3	C03B1.12
+C54C6.2	C03B1.12
+F18C12.1	C03B1.12
+F20B6.2	C03B1.12
+F32D8.6	C03B1.12
+F36F2.4	C03B1.12
+F44F4.11	C03B1.12
+F46F11.5	C03B1.12
+F49C12.13	C03B1.12
+F55A4.1	C03B1.12
+F55H2.2	C03B1.12
+K01G5.7	C03B1.12
+M03F4.2	C03B1.12
+T04C12.4	C03B1.12
+T04C12.5	C03B1.12
+T04C12.6	C03B1.12
+T04H1.9	C03B1.12
+T10G3.5	C03B1.12
+T10H9.3	C03B1.12
+T21E12.4	C03B1.12
+W03C9.3	C03B1.12
+Y110A7A.12	C03B1.12
+Y38A10A.5	C03B1.12
+Y38F2AL.3	C03B1.12
+Y38F2AR.9	C03B1.12
+Y49A3A.2	C03B1.12
+Y57G11C.15	C03B1.12
+ZK1058.2	C03B1.12
+ZK154.3	C03B1.12
+ZK632.6	C03B1.12
+ZK970.4	C03B1.12
+C17H12.1	C07G1.5
+C17H12.14	C07G1.5
+C26H9A.1	C07G1.5
+C30F8.2	C07G1.5
+C36E8.5	C07G1.5
+C39E9.14	C07G1.5
+C44B11.3	C07G1.5
+C54C6.2	C07G1.5
+F18C12.1	C07G1.5
+F20B6.2	C07G1.5
+F32D8.6	C07G1.5
+F35H10.4	C07G1.5
+F36F2.4	C07G1.5
+F44F4.11	C07G1.5
+F46F11.5	C07G1.5
+F49C12.13	C07G1.5
+F52E1.10	C07G1.5
+F55A4.1	C07G1.5
+F55H2.2	C07G1.5
+K01G5.7	C07G1.5
+M03F4.2	C07G1.5
+R10E11.2	C07G1.5
+R10E11.8	C07G1.5
+T01H3.1	C07G1.5
+T03E6.7	C07G1.5
+T04C12.4	C07G1.5
+T04C12.5	C07G1.5
+T04C12.6	C07G1.5
+T04H1.9	C07G1.5
+T10H9.3	C07G1.5
+T14F9.1	C07G1.5
+T21E12.4	C07G1.5
+VW02B12L.1	C07G1.5
+Y110A7A.12	C07G1.5
+Y38A10A.5	C07G1.5
+Y38F2AL.3	C07G1.5
+Y38F2AL.4	C07G1.5
+Y38F2AR.9	C07G1.5
+Y49A3A.2	C07G1.5
+Y55H10A.1	C07G1.5
+Y57G11C.15	C07G1.5
+ZK1058.2	C07G1.5
+ZK154.3	C07G1.5
+ZK632.6	C07G1.5
+ZK637.8	C07G1.5
+ZK970.4	C07G1.5
+C17H12.14	C17H12.1
+C26H9A.1	C17H12.1
+C30F8.2	C17H12.1
+C36E8.5	C17H12.1
+C39E9.14	C17H12.1
+C44B11.3	C17H12.1
+C54C6.2	C17H12.1
+F18C12.1	C17H12.1
+F20B6.2	C17H12.1
+F32D8.6	C17H12.1
+F35H10.4	C17H12.1
+F36F2.4	C17H12.1
+F44F4.11	C17H12.1
+F46F11.5	C17H12.1
+F49C12.13	C17H12.1
+F52E1.10	C17H12.1
+F55A4.1	C17H12.1
+F55H2.2	C17H12.1
+K01G5.7	C17H12.1
+M03F4.2	C17H12.1
+R10E11.2	C17H12.1
+R10E11.8	C17H12.1
+T01H3.1	C17H12.1
+T03E6.7	C17H12.1
+T04C12.4	C17H12.1
+T04C12.5	C17H12.1
+T04C12.6	C17H12.1
+T04H1.9	C17H12.1
+T10G3.5	C17H12.1
+T10H9.3	C17H12.1
+T14F9.1	C17H12.1
+T21E12.4	C17H12.1
+VW02B12L.1	C17H12.1
+W03C9.3	C17H12.1
+Y110A7A.12	C17H12.1
+Y38A10A.5	C17H12.1
+Y38F2AL.3	C17H12.1
+Y38F2AL.4	C17H12.1
+Y38F2AR.9	C17H12.1
+Y49A3A.2	C17H12.1
+Y55H10A.1	C17H12.1
+Y57G11C.15	C17H12.1
+ZK1058.2	C17H12.1
+ZK154.3	C17H12.1
+ZK632.6	C17H12.1
+ZK637.8	C17H12.1
+ZK970.4	C17H12.1
+C36E8.5	C17H12.14
+C39E9.14	C17H12.14
+C44B11.3	C17H12.14
+C54C6.2	C17H12.14
+F18C12.1	C17H12.14
+F32D8.6	C17H12.14
+F36F2.4	C17H12.14
+F44F4.11	C17H12.14
+F55A4.1	C17H12.14
+K01G5.7	C17H12.14
+M03F4.2	C17H12.14
+T03E6.7	C17H12.14
+T04C12.4	C17H12.14
+T04C12.5	C17H12.14
+T04C12.6	C17H12.14
+T04H1.9	C17H12.14
+T10G3.5	C17H12.14
+T10H9.3	C17H12.14
+T21E12.4	C17H12.14
+W03C9.3	C17H12.14
+Y38A10A.5	C17H12.14
+Y38F2AR.9	C17H12.14
+Y57G11C.15	C17H12.14
+ZK1058.2	C17H12.14
+ZK154.3	C17H12.14
+ZK632.6	C17H12.14
+C36E8.5	C26H9A.1
+C39E9.14	C26H9A.1
+C44B11.3	C26H9A.1
+C54C6.2	C26H9A.1
+F18C12.1	C26H9A.1
+F32D8.6	C26H9A.1
+F36F2.4	C26H9A.1
+F44F4.11	C26H9A.1
+F55A4.1	C26H9A.1
+K01G5.7	C26H9A.1
+M03F4.2	C26H9A.1
+T04C12.4	C26H9A.1
+T04C12.5	C26H9A.1
+T04C12.6	C26H9A.1
+T04H1.9	C26H9A.1
+T10G3.5	C26H9A.1
+T10H9.3	C26H9A.1
+T21E12.4	C26H9A.1
+W03C9.3	C26H9A.1
+Y38A10A.5	C26H9A.1
+Y38F2AR.9	C26H9A.1
+Y57G11C.15	C26H9A.1
+ZK1058.2	C26H9A.1
+ZK154.3	C26H9A.1
+ZK632.6	C26H9A.1
+C36E8.5	C30F8.2
+C39E9.14	C30F8.2
+C44B11.3	C30F8.2
+C54C6.2	C30F8.2
+F18C12.1	C30F8.2
+F32D8.6	C30F8.2
+F36F2.4	C30F8.2
+F44F4.11	C30F8.2
+F55A4.1	C30F8.2
+K01G5.7	C30F8.2
+M03F4.2	C30F8.2
+T04C12.4	C30F8.2
+T04C12.5	C30F8.2
+T04C12.6	C30F8.2
+T04H1.9	C30F8.2
+T10G3.5	C30F8.2
+T10H9.3	C30F8.2
+T21E12.4	C30F8.2
+W03C9.3	C30F8.2
+Y38A10A.5	C30F8.2
+Y38F2AR.9	C30F8.2
+Y57G11C.15	C30F8.2
+ZK1058.2	C30F8.2
+ZK154.3	C30F8.2
+ZK632.6	C30F8.2
+C39E9.14	C36E8.5
+C44B11.3	C36E8.5
+C54C6.2	C36E8.5
+F18C12.1	C36E8.5
+F20B6.2	C36E8.5
+F32D8.6	C36E8.5
+F35H10.4	C36E8.5
+F36F2.4	C36E8.5
+F44F4.11	C36E8.5
+F46F11.5	C36E8.5
+F49C12.13	C36E8.5
+F52E1.10	C36E8.5
+F55A4.1	C36E8.5
+F55H2.2	C36E8.5
+K01G5.7	C36E8.5
+M03F4.2	C36E8.5
+R10E11.2	C36E8.5
+R10E11.8	C36E8.5
+T01H3.1	C36E8.5
+T03E6.7	C36E8.5
+T04C12.4	C36E8.5
+T04C12.5	C36E8.5
+T04C12.6	C36E8.5
+T04H1.9	C36E8.5
+T10G3.5	C36E8.5
+T10H9.3	C36E8.5
+T14F9.1	C36E8.5
+T21E12.4	C36E8.5
+VW02B12L.1	C36E8.5
+W03C9.3	C36E8.5
+Y110A7A.12	C36E8.5
+Y38A10A.5	C36E8.5
+Y38F2AL.3	C36E8.5
+Y38F2AL.4	C36E8.5
+Y38F2AR.9	C36E8.5
+Y49A3A.2	C36E8.5
+Y55H10A.1	C36E8.5
+Y57G11C.15	C36E8.5
+ZK1058.2	C36E8.5
+ZK154.3	C36E8.5
+ZK632.6	C36E8.5
+ZK637.8	C36E8.5
+ZK970.4	C36E8.5
+C44B11.3	C39E9.14
+C54C6.2	C39E9.14
+F18C12.1	C39E9.14
+F20B6.2	C39E9.14
+F32D8.6	C39E9.14
+F35H10.4	C39E9.14
+F36F2.4	C39E9.14
+F44F4.11	C39E9.14
+F46F11.5	C39E9.14
+F49C12.13	C39E9.14
+F52E1.10	C39E9.14
+F55A4.1	C39E9.14
+F55H2.2	C39E9.14
+K01G5.7	C39E9.14
+M03F4.2	C39E9.14
+R10E11.2	C39E9.14
+R10E11.8	C39E9.14
+T01H3.1	C39E9.14
+T03E6.7	C39E9.14
+T04C12.4	C39E9.14
+T04C12.5	C39E9.14
+T04C12.6	C39E9.14
+T04H1.9	C39E9.14
+T10G3.5	C39E9.14
+T10H9.3	C39E9.14
+T14F9.1	C39E9.14
+T21E12.4	C39E9.14
+VW02B12L.1	C39E9.14
+W03C9.3	C39E9.14
+Y110A7A.12	C39E9.14
+Y38A10A.5	C39E9.14
+Y38F2AL.3	C39E9.14
+Y38F2AL.4	C39E9.14
+Y38F2AR.9	C39E9.14
+Y49A3A.2	C39E9.14
+Y55H10A.1	C39E9.14
+Y57G11C.15	C39E9.14
+ZK1058.2	C39E9.14
+ZK154.3	C39E9.14
+ZK632.6	C39E9.14
+ZK637.8	C39E9.14
+ZK970.4	C39E9.14
+F18C12.1	C44B11.3
+F20B6.2	C44B11.3
+F32D8.6	C44B11.3
+F35H10.4	C44B11.3
+F36F2.4	C44B11.3
+F44F4.11	C44B11.3
+F46F11.5	C44B11.3
+F49C12.13	C44B11.3
+F52E1.10	C44B11.3
+F55A4.1	C44B11.3
+F55H2.2	C44B11.3
+K01G5.7	C44B11.3
+M03F4.2	C44B11.3
+R10E11.2	C44B11.3
+R10E11.8	C44B11.3
+T01H3.1	C44B11.3
+T03E6.7	C44B11.3
+T04C12.4	C44B11.3
+T04C12.5	C44B11.3
+T04C12.6	C44B11.3
+T04H1.9	C44B11.3
+T10G3.5	C44B11.3
+T10H9.3	C44B11.3
+T14F9.1	C44B11.3
+T21E12.4	C44B11.3
+VW02B12L.1	C44B11.3
+W03C9.3	C44B11.3
+Y110A7A.12	C44B11.3
+Y38A10A.5	C44B11.3
+Y38F2AL.3	C44B11.3
+Y38F2AL.4	C44B11.3
+Y38F2AR.9	C44B11.3
+Y49A3A.2	C44B11.3
+Y55H10A.1	C44B11.3
+Y57G11C.15	C44B11.3
+ZK1058.2	C44B11.3
+ZK154.3	C44B11.3
+ZK632.6	C44B11.3
+ZK637.8	C44B11.3
+ZK970.4	C44B11.3
+F18C12.1	C54C6.2
+F20B6.2	C54C6.2
+F32D8.6	C54C6.2
+F35H10.4	C54C6.2
+F36F2.4	C54C6.2
+F44F4.11	C54C6.2
+F46F11.5	C54C6.2
+F49C12.13	C54C6.2
+F52E1.10	C54C6.2
+F55A4.1	C54C6.2
+F55H2.2	C54C6.2
+K01G5.7	C54C6.2
+M03F4.2	C54C6.2
+R10E11.2	C54C6.2
+R10E11.8	C54C6.2
+T01H3.1	C54C6.2
+T03E6.7	C54C6.2
+T04C12.4	C54C6.2
+T04C12.5	C54C6.2
+T04C12.6	C54C6.2
+T04H1.9	C54C6.2
+T10G3.5	C54C6.2
+T10H9.3	C54C6.2
+T14F9.1	C54C6.2
+T21E12.4	C54C6.2
+VW02B12L.1	C54C6.2
+W03C9.3	C54C6.2
+Y110A7A.12	C54C6.2
+Y38A10A.5	C54C6.2
+Y38F2AL.3	C54C6.2
+Y38F2AL.4	C54C6.2
+Y38F2AR.9	C54C6.2
+Y49A3A.2	C54C6.2
+Y55H10A.1	C54C6.2
+Y57G11C.15	C54C6.2
+ZK1058.2	C54C6.2
+ZK154.3	C54C6.2
+ZK632.6	C54C6.2
+ZK637.8	C54C6.2
+ZK970.4	C54C6.2
+F20B6.2	F18C12.1
+F32D8.6	F18C12.1
+F35H10.4	F18C12.1
+F36F2.4	F18C12.1
+F44F4.11	F18C12.1
+F46F11.5	F18C12.1
+F49C12.13	F18C12.1
+F52E1.10	F18C12.1
+F55A4.1	F18C12.1
+F55H2.2	F18C12.1
+K01G5.7	F18C12.1
+M03F4.2	F18C12.1
+R10E11.2	F18C12.1
+R10E11.8	F18C12.1
+T01H3.1	F18C12.1
+T03E6.7	F18C12.1
+T04C12.4	F18C12.1
+T04C12.5	F18C12.1
+T04C12.6	F18C12.1
+T04H1.9	F18C12.1
+T10G3.5	F18C12.1
+T10H9.3	F18C12.1
+T14F9.1	F18C12.1
+T21E12.4	F18C12.1
+VW02B12L.1	F18C12.1
+W03C9.3	F18C12.1
+Y110A7A.12	F18C12.1
+Y38A10A.5	F18C12.1
+Y38F2AL.3	F18C12.1
+Y38F2AL.4	F18C12.1
+Y38F2AR.9	F18C12.1
+Y49A3A.2	F18C12.1
+Y55H10A.1	F18C12.1
+Y57G11C.15	F18C12.1
+ZK1058.2	F18C12.1
+ZK154.3	F18C12.1
+ZK632.6	F18C12.1
+ZK637.8	F18C12.1
+ZK970.4	F18C12.1
+F32D8.6	F20B6.2
+F36F2.4	F20B6.2
+F44F4.11	F20B6.2
+F55A4.1	F20B6.2
+K01G5.7	F20B6.2
+M03F4.2	F20B6.2
+T03E6.7	F20B6.2
+T04C12.4	F20B6.2
+T04C12.5	F20B6.2
+T04C12.6	F20B6.2
+T04H1.9	F20B6.2
+T10G3.5	F20B6.2
+T10H9.3	F20B6.2
+T21E12.4	F20B6.2
+W03C9.3	F20B6.2
+Y38A10A.5	F20B6.2
+Y38F2AR.9	F20B6.2
+Y57G11C.15	F20B6.2
+ZK1058.2	F20B6.2
+ZK154.3	F20B6.2
+ZK632.6	F20B6.2
+F35H10.4	F32D8.6
+F36F2.4	F32D8.6
+F44F4.11	F32D8.6
+F46F11.5	F32D8.6
+F49C12.13	F32D8.6
+F52E1.10	F32D8.6
+F55A4.1	F32D8.6
+F55H2.2	F32D8.6
+K01G5.7	F32D8.6
+M03F4.2	F32D8.6
+R10E11.2	F32D8.6
+R10E11.8	F32D8.6
+T01H3.1	F32D8.6
+T03E6.7	F32D8.6
+T04C12.4	F32D8.6
+T04C12.5	F32D8.6
+T04C12.6	F32D8.6
+T04H1.9	F32D8.6
+T10G3.5	F32D8.6
+T10H9.3	F32D8.6
+T14F9.1	F32D8.6
+T21E12.4	F32D8.6
+VW02B12L.1	F32D8.6
+W03C9.3	F32D8.6
+Y110A7A.12	F32D8.6
+Y38F2AL.3	F32D8.6
+Y38F2AL.4	F32D8.6
+Y49A3A.2	F32D8.6
+Y55H10A.1	F32D8.6
+ZK1058.2	F32D8.6
+ZK154.3	F32D8.6
+ZK637.8	F32D8.6
+ZK970.4	F32D8.6
+F36F2.4	F35H10.4
+F44F4.11	F35H10.4
+F55A4.1	F35H10.4
+K01G5.7	F35H10.4
+M03F4.2	F35H10.4
+T04C12.4	F35H10.4
+T04C12.5	F35H10.4
+T04C12.6	F35H10.4
+T04H1.9	F35H10.4
+T10G3.5	F35H10.4
+T10H9.3	F35H10.4
+T21E12.4	F35H10.4
+W03C9.3	F35H10.4
+Y38A10A.5	F35H10.4
+Y38F2AR.9	F35H10.4
+Y57G11C.15	F35H10.4
+ZK1058.2	F35H10.4
+ZK154.3	F35H10.4
+ZK632.6	F35H10.4
+F44F4.11	F36F2.4
+F46F11.5	F36F2.4
+F49C12.13	F36F2.4
+F52E1.10	F36F2.4
+F55H2.2	F36F2.4
+K01G5.7	F36F2.4
+M03F4.2	F36F2.4
+R10E11.2	F36F2.4
+R10E11.8	F36F2.4
+T01H3.1	F36F2.4
+T03E6.7	F36F2.4
+T04C12.4	F36F2.4
+T04C12.5	F36F2.4
+T04C12.6	F36F2.4
+T04H1.9	F36F2.4
+T10G3.5	F36F2.4
+T14F9.1	F36F2.4
+T21E12.4	F36F2.4
+VW02B12L.1	F36F2.4
+W03C9.3	F36F2.4
+Y110A7A.12	F36F2.4
+Y38A10A.5	F36F2.4
+Y38F2AL.3	F36F2.4
+Y38F2AL.4	F36F2.4
+Y38F2AR.9	F36F2.4
+Y49A3A.2	F36F2.4
+Y55H10A.1	F36F2.4
+Y57G11C.15	F36F2.4
+ZK1058.2	F36F2.4
+ZK154.3	F36F2.4
+ZK632.6	F36F2.4
+ZK637.8	F36F2.4
+ZK970.4	F36F2.4
+F46F11.5	F44F4.11
+F49C12.13	F44F4.11
+F52E1.10	F44F4.11
+F55A4.1	F44F4.11
+F55H2.2	F44F4.11
+K01G5.7	F44F4.11
+M03F4.2	F44F4.11
+R10E11.2	F44F4.11
+R10E11.8	F44F4.11
+T01H3.1	F44F4.11
+T03E6.7	F44F4.11
+T04C12.4	F44F4.11
+T04C12.5	F44F4.11
+T04C12.6	F44F4.11
+T04H1.9	F44F4.11
+T10G3.5	F44F4.11
+T10H9.3	F44F4.11
+T14F9.1	F44F4.11
+T21E12.4	F44F4.11
+VW02B12L.1	F44F4.11
+W03C9.3	F44F4.11
+Y110A7A.12	F44F4.11
+Y38A10A.5	F44F4.11
+Y38F2AL.3	F44F4.11
+Y38F2AL.4	F44F4.11
+Y38F2AR.9	F44F4.11
+Y49A3A.2	F44F4.11
+Y55H10A.1	F44F4.11
+Y57G11C.15	F44F4.11
+ZK1058.2	F44F4.11
+ZK154.3	F44F4.11
+ZK632.6	F44F4.11
+ZK637.8	F44F4.11
+ZK970.4	F44F4.11
+F55A4.1	F46F11.5
+K01G5.7	F46F11.5
+M03F4.2	F46F11.5
+T03E6.7	F46F11.5
+T04C12.4	F46F11.5
+T04C12.5	F46F11.5
+T04C12.6	F46F11.5
+T04H1.9	F46F11.5
+T10G3.5	F46F11.5
+T10H9.3	F46F11.5
+T21E12.4	F46F11.5
+W03C9.3	F46F11.5
+Y38A10A.5	F46F11.5
+Y38F2AR.9	F46F11.5
+Y57G11C.15	F46F11.5
+ZK1058.2	F46F11.5
+ZK154.3	F46F11.5
+ZK632.6	F46F11.5
+F55A4.1	F49C12.13
+K01G5.7	F49C12.13
+M03F4.2	F49C12.13
+T03E6.7	F49C12.13
+T04C12.4	F49C12.13
+T04C12.5	F49C12.13
+T04C12.6	F49C12.13
+T04H1.9	F49C12.13
+T10G3.5	F49C12.13
+T10H9.3	F49C12.13
+T21E12.4	F49C12.13
+W03C9.3	F49C12.13
+Y38A10A.5	F49C12.13
+Y38F2AR.9	F49C12.13
+Y57G11C.15	F49C12.13
+ZK1058.2	F49C12.13
+ZK154.3	F49C12.13
+ZK632.6	F49C12.13
+F55A4.1	F52E1.10
+K01G5.7	F52E1.10
+M03F4.2	F52E1.10
+T04C12.4	F52E1.10
+T04C12.5	F52E1.10
+T04C12.6	F52E1.10
+T04H1.9	F52E1.10
+T10G3.5	F52E1.10
+T10H9.3	F52E1.10
+T21E12.4	F52E1.10
+W03C9.3	F52E1.10
+Y38A10A.5	F52E1.10
+Y38F2AR.9	F52E1.10
+Y57G11C.15	F52E1.10
+ZK1058.2	F52E1.10
+ZK154.3	F52E1.10
+ZK632.6	F52E1.10
+F55H2.2	F55A4.1
+K01G5.7	F55A4.1
+M03F4.2	F55A4.1
+R10E11.2	F55A4.1
+R10E11.8	F55A4.1
+T01H3.1	F55A4.1
+T03E6.7	F55A4.1
+T04C12.4	F55A4.1
+T04C12.5	F55A4.1
+T04C12.6	F55A4.1
+T04H1.9	F55A4.1
+T10G3.5	F55A4.1
+T14F9.1	F55A4.1
+T21E12.4	F55A4.1
+VW02B12L.1	F55A4.1
+W03C9.3	F55A4.1
+Y110A7A.12	F55A4.1
+Y38A10A.5	F55A4.1
+Y38F2AL.3	F55A4.1
+Y38F2AL.4	F55A4.1
+Y38F2AR.9	F55A4.1
+Y49A3A.2	F55A4.1
+Y55H10A.1	F55A4.1
+Y57G11C.15	F55A4.1
+ZK1058.2	F55A4.1
+ZK154.3	F55A4.1
+ZK632.6	F55A4.1
+ZK637.8	F55A4.1
+ZK970.4	F55A4.1
+K01G5.7	F55H2.2
+M03F4.2	F55H2.2
+T03E6.7	F55H2.2
+T04C12.4	F55H2.2
+T04C12.5	F55H2.2
+T04C12.6	F55H2.2
+T04H1.9	F55H2.2
+T10G3.5	F55H2.2
+T10H9.3	F55H2.2
+T21E12.4	F55H2.2
+W03C9.3	F55H2.2
+Y38A10A.5	F55H2.2
+Y38F2AR.9	F55H2.2
+Y57G11C.15	F55H2.2
+ZK1058.2	F55H2.2
+ZK154.3	F55H2.2
+ZK632.6	F55H2.2
+M03F4.2	K01G5.7
+R10E11.2	K01G5.7
+R10E11.8	K01G5.7
+T01H3.1	K01G5.7
+T03E6.7	K01G5.7
+T04C12.4	K01G5.7
+T04C12.5	K01G5.7
+T04C12.6	K01G5.7
+T04H1.9	K01G5.7
+T10G3.5	K01G5.7
+T10H9.3	K01G5.7
+T14F9.1	K01G5.7
+T21E12.4	K01G5.7
+VW02B12L.1	K01G5.7
+W03C9.3	K01G5.7
+Y110A7A.12	K01G5.7
+Y38A10A.5	K01G5.7
+Y38F2AL.3	K01G5.7
+Y38F2AL.4	K01G5.7
+Y38F2AR.9	K01G5.7
+Y49A3A.2	K01G5.7
+Y55H10A.1	K01G5.7
+Y57G11C.15	K01G5.7
+ZK1058.2	K01G5.7
+ZK154.3	K01G5.7
+ZK632.6	K01G5.7
+ZK637.8	K01G5.7
+ZK970.4	K01G5.7
+R10E11.2	M03F4.2
+R10E11.8	M03F4.2
+T01H3.1	M03F4.2
+T03E6.7	M03F4.2
+T04C12.4	M03F4.2
+T04C12.5	M03F4.2
+T04C12.6	M03F4.2
+T04H1.9	M03F4.2
+T10G3.5	M03F4.2
+T10H9.3	M03F4.2
+T14F9.1	M03F4.2
+T21E12.4	M03F4.2
+VW02B12L.1	M03F4.2
+W03C9.3	M03F4.2
+Y110A7A.12	M03F4.2
+Y38A10A.5	M03F4.2
+Y38F2AL.3	M03F4.2
+Y38F2AL.4	M03F4.2
+Y38F2AR.9	M03F4.2
+Y49A3A.2	M03F4.2
+Y55H10A.1	M03F4.2
+Y57G11C.15	M03F4.2
+ZK1058.2	M03F4.2
+ZK154.3	M03F4.2
+ZK632.6	M03F4.2
+ZK637.8	M03F4.2
+ZK970.4	M03F4.2
+T04C12.4	R10E11.2
+T04C12.5	R10E11.2
+T04C12.6	R10E11.2
+T04H1.9	R10E11.2
+T10G3.5	R10E11.2
+T10H9.3	R10E11.2
+T21E12.4	R10E11.2
+W03C9.3	R10E11.2
+Y38A10A.5	R10E11.2
+Y38F2AR.9	R10E11.2
+Y57G11C.15	R10E11.2
+ZK1058.2	R10E11.2
+ZK154.3	R10E11.2
+ZK632.6	R10E11.2
+T04C12.4	R10E11.8
+T04C12.5	R10E11.8
+T04C12.6	R10E11.8
+T04H1.9	R10E11.8
+T10G3.5	R10E11.8
+T10H9.3	R10E11.8
+T21E12.4	R10E11.8
+W03C9.3	R10E11.8
+Y38A10A.5	R10E11.8
+Y38F2AR.9	R10E11.8
+Y57G11C.15	R10E11.8
+ZK1058.2	R10E11.8
+ZK154.3	R10E11.8
+ZK632.6	R10E11.8
+T04C12.4	T01H3.1
+T04C12.5	T01H3.1
+T04C12.6	T01H3.1
+T04H1.9	T01H3.1
+T10G3.5	T01H3.1
+T10H9.3	T01H3.1
+T21E12.4	T01H3.1
+W03C9.3	T01H3.1
+Y38A10A.5	T01H3.1
+Y38F2AR.9	T01H3.1
+Y57G11C.15	T01H3.1
+ZK1058.2	T01H3.1
+ZK154.3	T01H3.1
+ZK632.6	T01H3.1
+T04C12.4	T03E6.7
+T04C12.5	T03E6.7
+T04C12.6	T03E6.7
+T04H1.9	T03E6.7
+T10G3.5	T03E6.7
+T10H9.3	T03E6.7
+T21E12.4	T03E6.7
+W03C9.3	T03E6.7
+Y110A7A.12	T03E6.7
+Y38A10A.5	T03E6.7
+Y38F2AL.3	T03E6.7
+Y38F2AR.9	T03E6.7
+Y49A3A.2	T03E6.7
+Y57G11C.15	T03E6.7
+ZK1058.2	T03E6.7
+ZK154.3	T03E6.7
+ZK632.6	T03E6.7
+ZK970.4	T03E6.7
+T04C12.5	T04C12.4
+T04C12.6	T04C12.4
+T04H1.9	T04C12.4
+T10G3.5	T04C12.4
+T10H9.3	T04C12.4
+T14F9.1	T04C12.4
+T21E12.4	T04C12.4
+VW02B12L.1	T04C12.4
+W03C9.3	T04C12.4
+Y110A7A.12	T04C12.4
+Y38A10A.5	T04C12.4
+Y38F2AL.3	T04C12.4
+Y38F2AL.4	T04C12.4
+Y38F2AR.9	T04C12.4
+Y49A3A.2	T04C12.4
+Y55H10A.1	T04C12.4
+Y57G11C.15	T04C12.4
+ZK1058.2	T04C12.4
+ZK154.3	T04C12.4
+ZK632.6	T04C12.4
+ZK637.8	T04C12.4
+ZK970.4	T04C12.4
+T04C12.6	T04C12.5
+T04H1.9	T04C12.5
+T10G3.5	T04C12.5
+T10H9.3	T04C12.5
+T14F9.1	T04C12.5
+T21E12.4	T04C12.5
+VW02B12L.1	T04C12.5
+W03C9.3	T04C12.5
+Y110A7A.12	T04C12.5
+Y38A10A.5	T04C12.5
+Y38F2AL.3	T04C12.5
+Y38F2AL.4	T04C12.5
+Y38F2AR.9	T04C12.5
+Y49A3A.2	T04C12.5
+Y55H10A.1	T04C12.5
+Y57G11C.15	T04C12.5
+ZK1058.2	T04C12.5
+ZK154.3	T04C12.5
+ZK632.6	T04C12.5
+ZK637.8	T04C12.5
+ZK970.4	T04C12.5
+T04H1.9	T04C12.6
+T10G3.5	T04C12.6
+T10H9.3	T04C12.6
+T14F9.1	T04C12.6
+T21E12.4	T04C12.6
+VW02B12L.1	T04C12.6
+W03C9.3	T04C12.6
+Y110A7A.12	T04C12.6
+Y38A10A.5	T04C12.6
+Y38F2AL.3	T04C12.6
+Y38F2AL.4	T04C12.6
+Y38F2AR.9	T04C12.6
+Y49A3A.2	T04C12.6
+Y55H10A.1	T04C12.6
+Y57G11C.15	T04C12.6
+ZK1058.2	T04C12.6
+ZK154.3	T04C12.6
+ZK632.6	T04C12.6
+ZK637.8	T04C12.6
+ZK970.4	T04C12.6
+T10G3.5	T04H1.9
+T10H9.3	T04H1.9
+T14F9.1	T04H1.9
+T21E12.4	T04H1.9
+VW02B12L.1	T04H1.9
+W03C9.3	T04H1.9
+Y110A7A.12	T04H1.9
+Y38A10A.5	T04H1.9
+Y38F2AL.3	T04H1.9
+Y38F2AL.4	T04H1.9
+Y38F2AR.9	T04H1.9
+Y49A3A.2	T04H1.9
+Y55H10A.1	T04H1.9
+Y57G11C.15	T04H1.9
+ZK1058.2	T04H1.9
+ZK154.3	T04H1.9
+ZK632.6	T04H1.9
+ZK637.8	T04H1.9
+ZK970.4	T04H1.9
+T10H9.3	T10G3.5
+T14F9.1	T10G3.5
+T21E12.4	T10G3.5
+VW02B12L.1	T10G3.5
+Y110A7A.12	T10G3.5
+Y38A10A.5	T10G3.5
+Y38F2AL.3	T10G3.5
+Y38F2AL.4	T10G3.5
+Y38F2AR.9	T10G3.5
+Y49A3A.2	T10G3.5
+Y55H10A.1	T10G3.5
+Y57G11C.15	T10G3.5
+ZK1058.2	T10G3.5
+ZK154.3	T10G3.5
+ZK632.6	T10G3.5
+ZK637.8	T10G3.5
+ZK970.4	T10G3.5
+T14F9.1	T10H9.3
+T21E12.4	T10H9.3
+VW02B12L.1	T10H9.3
+W03C9.3	T10H9.3
+Y110A7A.12	T10H9.3
+Y38A10A.5	T10H9.3
+Y38F2AL.3	T10H9.3
+Y38F2AL.4	T10H9.3
+Y38F2AR.9	T10H9.3
+Y49A3A.2	T10H9.3
+Y55H10A.1	T10H9.3
+Y57G11C.15	T10H9.3
+ZK1058.2	T10H9.3
+ZK154.3	T10H9.3
+ZK632.6	T10H9.3
+ZK637.8	T10H9.3
+ZK970.4	T10H9.3
+T21E12.4	T14F9.1
+W03C9.3	T14F9.1
+Y38A10A.5	T14F9.1
+Y38F2AR.9	T14F9.1
+Y57G11C.15	T14F9.1
+ZK1058.2	T14F9.1
+ZK154.3	T14F9.1
+ZK632.6	T14F9.1
+VW02B12L.1	T21E12.4
+W03C9.3	T21E12.4
+Y110A7A.12	T21E12.4
+Y38A10A.5	T21E12.4
+Y38F2AL.3	T21E12.4
+Y38F2AL.4	T21E12.4
+Y38F2AR.9	T21E12.4
+Y49A3A.2	T21E12.4
+Y55H10A.1	T21E12.4
+Y57G11C.15	T21E12.4
+ZK1058.2	T21E12.4
+ZK154.3	T21E12.4
+ZK632.6	T21E12.4
+ZK637.8	T21E12.4
+ZK970.4	T21E12.4
+W03C9.3	VW02B12L.1
+Y38A10A.5	VW02B12L.1
+Y38F2AR.9	VW02B12L.1
+Y57G11C.15	VW02B12L.1
+ZK1058.2	VW02B12L.1
+ZK154.3	VW02B12L.1
+ZK632.6	VW02B12L.1
+Y110A7A.12	W03C9.3
+Y38A10A.5	W03C9.3
+Y38F2AL.3	W03C9.3
+Y38F2AL.4	W03C9.3
+Y38F2AR.9	W03C9.3
+Y49A3A.2	W03C9.3
+Y55H10A.1	W03C9.3
+Y57G11C.15	W03C9.3
+ZK1058.2	W03C9.3
+ZK154.3	W03C9.3
+ZK632.6	W03C9.3
+ZK637.8	W03C9.3
+ZK970.4	W03C9.3
+Y38A10A.5	Y110A7A.12
+Y38F2AR.9	Y110A7A.12
+Y57G11C.15	Y110A7A.12
+ZK1058.2	Y110A7A.12
+ZK154.3	Y110A7A.12
+ZK632.6	Y110A7A.12
+Y38F2AL.3	Y38A10A.5
+Y38F2AL.4	Y38A10A.5
+Y49A3A.2	Y38A10A.5
+Y55H10A.1	Y38A10A.5
+ZK1058.2	Y38A10A.5
+ZK154.3	Y38A10A.5
+ZK637.8	Y38A10A.5
+ZK970.4	Y38A10A.5
+Y38F2AR.9	Y38F2AL.3
+Y57G11C.15	Y38F2AL.3
+ZK1058.2	Y38F2AL.3
+ZK154.3	Y38F2AL.3
+ZK632.6	Y38F2AL.3
+Y38F2AR.9	Y38F2AL.4
+Y57G11C.15	Y38F2AL.4
+ZK1058.2	Y38F2AL.4
+ZK154.3	Y38F2AL.4
+ZK632.6	Y38F2AL.4
+Y49A3A.2	Y38F2AR.9
+Y55H10A.1	Y38F2AR.9
+ZK1058.2	Y38F2AR.9
+ZK154.3	Y38F2AR.9
+ZK637.8	Y38F2AR.9
+ZK970.4	Y38F2AR.9
+Y57G11C.15	Y49A3A.2
+ZK1058.2	Y49A3A.2
+ZK154.3	Y49A3A.2
+ZK632.6	Y49A3A.2
+Y57G11C.15	Y55H10A.1
+ZK1058.2	Y55H10A.1
+ZK154.3	Y55H10A.1
+ZK632.6	Y55H10A.1
+ZK1058.2	Y57G11C.15
+ZK154.3	Y57G11C.15
+ZK637.8	Y57G11C.15
+ZK970.4	Y57G11C.15
+ZK154.3	ZK1058.2
+ZK632.6	ZK1058.2
+ZK637.8	ZK1058.2
+ZK970.4	ZK1058.2
+ZK632.6	ZK154.3
+ZK637.8	ZK154.3
+ZK970.4	ZK154.3
+ZK637.8	ZK632.6
+ZK970.4	ZK632.6
+B0395.3	B0334.3
+C08A9.1	B0334.3
+C15F1.7	B0334.3
+C15H9.8	B0334.3
+C24A3.4	B0334.3
+C34C6.6	B0334.3
+C34E10.4	B0334.3
+C34F6.8	B0334.3
+C44B7.9	B0334.3
+C46F4.2	B0334.3
+C47A10.5	B0334.3
+C47B2.8	B0334.3
+C48B4.1	B0334.3
+C54G10.3	B0334.3
+F08A8.1	B0334.3
+F08A8.2	B0334.3
+F08A8.3	B0334.3
+F08A8.4	B0334.3
+F08B12.2	B0334.3
+F10D11.1	B0334.3
+F15E6.6	B0334.3
+F18E3.7	B0334.3
+F18F11.1	B0334.3
+F25E2.3	B0334.3
+F28F8.2	B0334.3
+F32A5.6	B0334.3
+F32D8.13	B0334.3
+F36H9.3	B0334.3
+F37C12.7	B0334.3
+F41E6.5	B0334.3
+F47G6.2	B0334.3
+F54F2.8	B0334.3
+F55B11.1	B0334.3
+F55H2.1	B0334.3
+F58F9.7	B0334.3
+F59B8.2	B0334.3
+F59F4.1	B0334.3
+R06F6.9	B0334.3
+R07C3.4	B0334.3
+R07H5.1	B0334.3
+R09E10.3	B0334.3
+R09E10.4	B0334.3
+T02D1.5	B0334.3
+T08B1.6	B0334.3
+T14D7.1	B0334.3
+T18D3.9	B0334.3
+T20B3.1	B0334.3
+Y25C1A.13	B0334.3
+Y42G9A.4	B0334.3
+Y46G5A.21	B0334.3
+Y50D7A.7	B0334.3
+Y54G11A.13	B0334.3
+Y54G11A.5	B0334.3
+Y54G11A.6	B0334.3
+Y57A10C.6	B0334.3
+Y65B4BL.5	B0334.3
+Y69A2AR.5	B0334.3
+Y71G12B.10	B0334.3
+Y71H10A.2	B0334.3
+Y76A2B.3	B0334.3
+ZK1320.1	B0334.3
+ZK550.6	B0334.3
+ZK809.7	B0334.3
+C08A9.1	B0395.3
+C15F1.7	B0395.3
+C15H9.8	B0395.3
+C24A3.4	B0395.3
+C34C6.6	B0395.3
+C34E10.4	B0395.3
+C34F6.8	B0395.3
+C44B7.9	B0395.3
+C46F4.2	B0395.3
+C47A10.5	B0395.3
+C47B2.8	B0395.3
+C48B4.1	B0395.3
+C54G10.3	B0395.3
+F08A8.1	B0395.3
+F08A8.2	B0395.3
+F08A8.3	B0395.3
+F08A8.4	B0395.3
+F08B12.2	B0395.3
+F10D11.1	B0395.3
+F15E6.6	B0395.3
+F18E3.7	B0395.3
+F18F11.1	B0395.3
+F25E2.3	B0395.3
+F28F8.2	B0395.3
+F32A5.6	B0395.3
+F32D8.13	B0395.3
+F36H9.3	B0395.3
+F37C12.7	B0395.3
+F41E6.5	B0395.3
+F47G6.2	B0395.3
+F54F2.8	B0395.3
+F55B11.1	B0395.3
+F55H2.1	B0395.3
+F58F9.7	B0395.3
+F59B8.2	B0395.3
+F59F4.1	B0395.3
+R06F6.9	B0395.3
+R07C3.4	B0395.3
+R07H5.1	B0395.3
+R09E10.3	B0395.3
+R09E10.4	B0395.3
+T02D1.5	B0395.3
+T08B1.6	B0395.3
+T14D7.1	B0395.3
+T18D3.9	B0395.3
+T20B3.1	B0395.3
+Y25C1A.13	B0395.3
+Y42G9A.4	B0395.3
+Y46G5A.21	B0395.3
+Y50D7A.7	B0395.3
+Y54G11A.13	B0395.3
+Y54G11A.5	B0395.3
+Y54G11A.6	B0395.3
+Y57A10C.6	B0395.3
+Y65B4BL.5	B0395.3
+Y69A2AR.5	B0395.3
+Y71G12B.10	B0395.3
+Y71H10A.2	B0395.3
+Y76A2B.3	B0395.3
+ZK1320.1	B0395.3
+ZK550.6	B0395.3
+ZK809.7	B0395.3
+C15F1.7	C08A9.1
+C15H9.8	C08A9.1
+C24A3.4	C08A9.1
+C34C6.6	C08A9.1
+C34E10.4	C08A9.1
+C34F6.8	C08A9.1
+C44B7.9	C08A9.1
+C46F4.2	C08A9.1
+C47A10.5	C08A9.1
+C47B2.8	C08A9.1
+C48B4.1	C08A9.1
+C54G10.3	C08A9.1
+F08A8.1	C08A9.1
+F08A8.2	C08A9.1
+F08A8.3	C08A9.1
+F08A8.4	C08A9.1
+F08B12.2	C08A9.1
+F10D11.1	C08A9.1
+F15E6.6	C08A9.1
+F18E3.7	C08A9.1
+F18F11.1	C08A9.1
+F25E2.3	C08A9.1
+F28F8.2	C08A9.1
+F32A5.6	C08A9.1
+F32D8.13	C08A9.1
+F36H9.3	C08A9.1
+F37C12.7	C08A9.1
+F41E6.5	C08A9.1
+F47G6.2	C08A9.1
+F54F2.8	C08A9.1
+F55B11.1	C08A9.1
+F55H2.1	C08A9.1
+F58F9.7	C08A9.1
+F59B8.2	C08A9.1
+F59F4.1	C08A9.1
+R06F6.9	C08A9.1
+R07C3.4	C08A9.1
+R07H5.1	C08A9.1
+R09E10.3	C08A9.1
+R09E10.4	C08A9.1
+T02D1.5	C08A9.1
+T08B1.6	C08A9.1
+T14D7.1	C08A9.1
+T18D3.9	C08A9.1
+T20B3.1	C08A9.1
+Y25C1A.13	C08A9.1
+Y42G9A.4	C08A9.1
+Y46G5A.21	C08A9.1
+Y50D7A.7	C08A9.1
+Y54G11A.13	C08A9.1
+Y54G11A.5	C08A9.1
+Y54G11A.6	C08A9.1
+Y57A10C.6	C08A9.1
+Y65B4BL.5	C08A9.1
+Y69A2AR.5	C08A9.1
+Y71G12B.10	C08A9.1
+Y71H10A.2	C08A9.1
+Y76A2B.3	C08A9.1
+ZK1320.1	C08A9.1
+ZK550.6	C08A9.1
+ZK809.7	C08A9.1
+C15H9.8	C15F1.7
+C24A3.4	C15F1.7
+C34C6.6	C15F1.7
+C34E10.4	C15F1.7
+C34F6.8	C15F1.7
+C44B7.9	C15F1.7
+C46F4.2	C15F1.7
+C47A10.5	C15F1.7
+C47B2.8	C15F1.7
+C48B4.1	C15F1.7
+C54G10.3	C15F1.7
+F08A8.1	C15F1.7
+F08A8.2	C15F1.7
+F08A8.3	C15F1.7
+F08A8.4	C15F1.7
+F08B12.2	C15F1.7
+F10D11.1	C15F1.7
+F15E6.6	C15F1.7
+F18E3.7	C15F1.7
+F18F11.1	C15F1.7
+F25E2.3	C15F1.7
+F28F8.2	C15F1.7
+F32A5.6	C15F1.7
+F32D8.13	C15F1.7
+F36H9.3	C15F1.7
+F37C12.7	C15F1.7
+F41E6.5	C15F1.7
+F47G6.2	C15F1.7
+F54F2.8	C15F1.7
+F55B11.1	C15F1.7
+F58F9.7	C15F1.7
+F59B8.2	C15F1.7
+F59F4.1	C15F1.7
+R06F6.9	C15F1.7
+R07C3.4	C15F1.7
+R07H5.1	C15F1.7
+R09E10.3	C15F1.7
+R09E10.4	C15F1.7
+T02D1.5	C15F1.7
+T08B1.6	C15F1.7
+T14D7.1	C15F1.7
+T18D3.9	C15F1.7
+T20B3.1	C15F1.7
+Y25C1A.13	C15F1.7
+Y42G9A.4	C15F1.7
+Y46G5A.21	C15F1.7
+Y50D7A.7	C15F1.7
+Y54G11A.13	C15F1.7
+Y54G11A.5	C15F1.7
+Y54G11A.6	C15F1.7
+Y57A10C.6	C15F1.7
+Y65B4BL.5	C15F1.7
+Y69A2AR.5	C15F1.7
+Y71G12B.10	C15F1.7
+Y71H10A.2	C15F1.7
+Y76A2B.3	C15F1.7
+ZK1320.1	C15F1.7
+ZK550.6	C15F1.7
+ZK809.7	C15F1.7
+C24A3.4	C15H9.8
+C34C6.6	C15H9.8
+C34E10.4	C15H9.8
+C34F6.8	C15H9.8
+C44B7.9	C15H9.8
+C46F4.2	C15H9.8
+C47A10.5	C15H9.8
+C47B2.8	C15H9.8
+C48B4.1	C15H9.8
+C54G10.3	C15H9.8
+F08A8.1	C15H9.8
+F08A8.2	C15H9.8
+F08A8.3	C15H9.8
+F08A8.4	C15H9.8
+F08B12.2	C15H9.8
+F10D11.1	C15H9.8
+F15E6.6	C15H9.8
+F18E3.7	C15H9.8
+F18F11.1	C15H9.8
+F25E2.3	C15H9.8
+F28F8.2	C15H9.8
+F32A5.6	C15H9.8
+F32D8.13	C15H9.8
+F36H9.3	C15H9.8
+F37C12.7	C15H9.8
+F41E6.5	C15H9.8
+F47G6.2	C15H9.8
+F54F2.8	C15H9.8
+F55B11.1	C15H9.8
+F55H2.1	C15H9.8
+F58F9.7	C15H9.8
+F59B8.2	C15H9.8
+F59F4.1	C15H9.8
+R06F6.9	C15H9.8
+R07C3.4	C15H9.8
+R07H5.1	C15H9.8
+R09E10.3	C15H9.8
+R09E10.4	C15H9.8
+T02D1.5	C15H9.8
+T08B1.6	C15H9.8
+T14D7.1	C15H9.8
+T18D3.9	C15H9.8
+T20B3.1	C15H9.8
+Y25C1A.13	C15H9.8
+Y42G9A.4	C15H9.8
+Y46G5A.21	C15H9.8
+Y50D7A.7	C15H9.8
+Y54G11A.13	C15H9.8
+Y54G11A.5	C15H9.8
+Y54G11A.6	C15H9.8
+Y57A10C.6	C15H9.8
+Y65B4BL.5	C15H9.8
+Y69A2AR.5	C15H9.8
+Y71G12B.10	C15H9.8
+Y71H10A.2	C15H9.8
+Y76A2B.3	C15H9.8
+ZK1320.1	C15H9.8
+ZK550.6	C15H9.8
+ZK809.7	C15H9.8
+C34C6.6	C24A3.4
+C34E10.4	C24A3.4
+C34F6.8	C24A3.4
+C44B7.9	C24A3.4
+C46F4.2	C24A3.4
+C47A10.5	C24A3.4
+C47B2.8	C24A3.4
+C48B4.1	C24A3.4
+C54G10.3	C24A3.4
+F08A8.1	C24A3.4
+F08A8.2	C24A3.4
+F08A8.3	C24A3.4
+F08A8.4	C24A3.4
+F08B12.2	C24A3.4
+F10D11.1	C24A3.4
+F15E6.6	C24A3.4
+F18E3.7	C24A3.4
+F18F11.1	C24A3.4
+F25E2.3	C24A3.4
+F28F8.2	C24A3.4
+F32A5.6	C24A3.4
+F32D8.13	C24A3.4
+F36H9.3	C24A3.4
+F37C12.7	C24A3.4
+F41E6.5	C24A3.4
+F47G6.2	C24A3.4
+F54F2.8	C24A3.4
+F55B11.1	C24A3.4
+F55H2.1	C24A3.4
+F58F9.7	C24A3.4
+F59B8.2	C24A3.4
+F59F4.1	C24A3.4
+R06F6.9	C24A3.4
+R07C3.4	C24A3.4
+R07H5.1	C24A3.4
+R09E10.3	C24A3.4
+R09E10.4	C24A3.4
+T02D1.5	C24A3.4
+T08B1.6	C24A3.4
+T14D7.1	C24A3.4
+T18D3.9	C24A3.4
+T20B3.1	C24A3.4
+Y25C1A.13	C24A3.4
+Y42G9A.4	C24A3.4
+Y46G5A.21	C24A3.4
+Y50D7A.7	C24A3.4
+Y54G11A.13	C24A3.4
+Y54G11A.5	C24A3.4
+Y54G11A.6	C24A3.4
+Y57A10C.6	C24A3.4
+Y65B4BL.5	C24A3.4
+Y69A2AR.5	C24A3.4
+Y71G12B.10	C24A3.4
+Y71H10A.2	C24A3.4
+Y76A2B.3	C24A3.4
+ZK1320.1	C24A3.4
+ZK550.6	C24A3.4
+ZK809.7	C24A3.4
+C34E10.4	C34C6.6
+C34F6.8	C34C6.6
+C44B7.9	C34C6.6
+C46F4.2	C34C6.6
+C47A10.5	C34C6.6
+C47B2.8	C34C6.6
+C48B4.1	C34C6.6
+C54G10.3	C34C6.6
+F08A8.1	C34C6.6
+F08A8.2	C34C6.6
+F08A8.3	C34C6.6
+F08A8.4	C34C6.6
+F08B12.2	C34C6.6
+F10D11.1	C34C6.6
+F15E6.6	C34C6.6
+F18E3.7	C34C6.6
+F18F11.1	C34C6.6
+F25E2.3	C34C6.6
+F28F8.2	C34C6.6
+F32A5.6	C34C6.6
+F32D8.13	C34C6.6
+F36H9.3	C34C6.6
+F37C12.7	C34C6.6
+F41E6.5	C34C6.6
+F47G6.2	C34C6.6
+F54F2.8	C34C6.6
+F55B11.1	C34C6.6
+F55H2.1	C34C6.6
+F58F9.7	C34C6.6
+F59B8.2	C34C6.6
+F59F4.1	C34C6.6
+R06F6.9	C34C6.6
+R07C3.4	C34C6.6
+R07H5.1	C34C6.6
+R09E10.3	C34C6.6
+R09E10.4	C34C6.6
+T02D1.5	C34C6.6
+T08B1.6	C34C6.6
+T14D7.1	C34C6.6
+T18D3.9	C34C6.6
+T20B3.1	C34C6.6
+Y25C1A.13	C34C6.6
+Y42G9A.4	C34C6.6
+Y46G5A.21	C34C6.6
+Y50D7A.7	C34C6.6
+Y54G11A.13	C34C6.6
+Y54G11A.5	C34C6.6
+Y54G11A.6	C34C6.6
+Y57A10C.6	C34C6.6
+Y65B4BL.5	C34C6.6
+Y69A2AR.5	C34C6.6
+Y71G12B.10	C34C6.6
+Y71H10A.2	C34C6.6
+Y76A2B.3	C34C6.6
+ZK1320.1	C34C6.6
+ZK550.6	C34C6.6
+ZK809.7	C34C6.6
+C34F6.8	C34E10.4
+C44B7.9	C34E10.4
+C46F4.2	C34E10.4
+C47A10.5	C34E10.4
+C47B2.8	C34E10.4
+C48B4.1	C34E10.4
+C54G10.3	C34E10.4
+F08A8.1	C34E10.4
+F08A8.2	C34E10.4
+F08A8.3	C34E10.4
+F08A8.4	C34E10.4
+F08B12.2	C34E10.4
+F10D11.1	C34E10.4
+F15E6.6	C34E10.4
+F18E3.7	C34E10.4
+F18F11.1	C34E10.4
+F25E2.3	C34E10.4
+F28F8.2	C34E10.4
+F32A5.6	C34E10.4
+F32D8.13	C34E10.4
+F36H9.3	C34E10.4
+F37C12.7	C34E10.4
+F41E6.5	C34E10.4
+F47G6.2	C34E10.4
+F54F2.8	C34E10.4
+F55B11.1	C34E10.4
+F55H2.1	C34E10.4
+F58F9.7	C34E10.4
+F59B8.2	C34E10.4
+F59F4.1	C34E10.4
+R06F6.9	C34E10.4
+R07C3.4	C34E10.4
+R07H5.1	C34E10.4
+R09E10.3	C34E10.4
+R09E10.4	C34E10.4
+T02D1.5	C34E10.4
+T08B1.6	C34E10.4
+T14D7.1	C34E10.4
+T18D3.9	C34E10.4
+T20B3.1	C34E10.4
+Y25C1A.13	C34E10.4
+Y42G9A.4	C34E10.4
+Y46G5A.21	C34E10.4
+Y50D7A.7	C34E10.4
+Y54G11A.13	C34E10.4
+Y54G11A.5	C34E10.4
+Y54G11A.6	C34E10.4
+Y57A10C.6	C34E10.4
+Y65B4BL.5	C34E10.4
+Y69A2AR.5	C34E10.4
+Y71G12B.10	C34E10.4
+Y71H10A.2	C34E10.4
+Y76A2B.3	C34E10.4
+ZK1320.1	C34E10.4
+ZK550.6	C34E10.4
+ZK809.7	C34E10.4
+C44B7.9	C34F6.8
+C46F4.2	C34F6.8
+C47A10.5	C34F6.8
+C47B2.8	C34F6.8
+C48B4.1	C34F6.8
+C54G10.3	C34F6.8
+F08A8.1	C34F6.8
+F08A8.2	C34F6.8
+F08A8.3	C34F6.8
+F08A8.4	C34F6.8
+F08B12.2	C34F6.8
+F10D11.1	C34F6.8
+F15E6.6	C34F6.8
+F18E3.7	C34F6.8
+F18F11.1	C34F6.8
+F25E2.3	C34F6.8
+F28F8.2	C34F6.8
+F32A5.6	C34F6.8
+F32D8.13	C34F6.8
+F36H9.3	C34F6.8
+F37C12.7	C34F6.8
+F41E6.5	C34F6.8
+F47G6.2	C34F6.8
+F54F2.8	C34F6.8
+F55B11.1	C34F6.8
+F55H2.1	C34F6.8
+F58F9.7	C34F6.8
+F59F4.1	C34F6.8
+R06F6.9	C34F6.8
+R07C3.4	C34F6.8
+R07H5.1	C34F6.8
+R09E10.3	C34F6.8
+R09E10.4	C34F6.8
+T02D1.5	C34F6.8
+T08B1.6	C34F6.8
+T14D7.1	C34F6.8
+T18D3.9	C34F6.8
+T20B3.1	C34F6.8
+Y25C1A.13	C34F6.8
+Y42G9A.4	C34F6.8
+Y46G5A.21	C34F6.8
+Y50D7A.7	C34F6.8
+Y54G11A.13	C34F6.8
+Y54G11A.5	C34F6.8
+Y54G11A.6	C34F6.8
+Y57A10C.6	C34F6.8
+Y65B4BL.5	C34F6.8
+Y69A2AR.5	C34F6.8
+Y71G12B.10	C34F6.8
+Y71H10A.2	C34F6.8
+Y76A2B.3	C34F6.8
+ZK550.6	C34F6.8
+ZK809.7	C34F6.8
+C46F4.2	C44B7.9
+C47A10.5	C44B7.9
+C47B2.8	C44B7.9
+C48B4.1	C44B7.9
+F08A8.1	C44B7.9
+F08A8.2	C44B7.9
+F08A8.3	C44B7.9
+F08A8.4	C44B7.9
+F08B12.2	C44B7.9
+F10D11.1	C44B7.9
+F15E6.6	C44B7.9
+F18E3.7	C44B7.9
+F18F11.1	C44B7.9
+F25E2.3	C44B7.9
+F28F8.2	C44B7.9
+F32A5.6	C44B7.9
+F32D8.13	C44B7.9
+F36H9.3	C44B7.9
+F37C12.7	C44B7.9
+F41E6.5	C44B7.9
+F47G6.2	C44B7.9
+F54F2.8	C44B7.9
+F55B11.1	C44B7.9
+F55H2.1	C44B7.9
+F58F9.7	C44B7.9
+F59B8.2	C44B7.9
+F59F4.1	C44B7.9
+R06F6.9	C44B7.9
+R07C3.4	C44B7.9
+R07H5.1	C44B7.9
+R09E10.3	C44B7.9
+R09E10.4	C44B7.9
+T08B1.6	C44B7.9
+T14D7.1	C44B7.9
+T18D3.9	C44B7.9
+T20B3.1	C44B7.9
+Y25C1A.13	C44B7.9
+Y42G9A.4	C44B7.9
+Y46G5A.21	C44B7.9
+Y50D7A.7	C44B7.9
+Y54G11A.13	C44B7.9
+Y54G11A.5	C44B7.9
+Y54G11A.6	C44B7.9
+Y57A10C.6	C44B7.9
+Y65B4BL.5	C44B7.9
+Y69A2AR.5	C44B7.9
+Y71G12B.10	C44B7.9
+Y71H10A.2	C44B7.9
+Y76A2B.3	C44B7.9
+ZK1320.1	C44B7.9
+ZK550.6	C44B7.9
+ZK809.7	C44B7.9
+C47A10.5	C46F4.2
+C47B2.8	C46F4.2
+C54G10.3	C46F4.2
+F08B12.2	C46F4.2
+F10D11.1	C46F4.2
+F15E6.6	C46F4.2
+F18E3.7	C46F4.2
+F18F11.1	C46F4.2
+F25E2.3	C46F4.2
+F32A5.6	C46F4.2
+F32D8.13	C46F4.2
+F36H9.3	C46F4.2
+F41E6.5	C46F4.2
+F54F2.8	C46F4.2
+F55B11.1	C46F4.2
+F55H2.1	C46F4.2
+F59B8.2	C46F4.2
+R07H5.1	C46F4.2
+T02D1.5	C46F4.2
+T14D7.1	C46F4.2
+T18D3.9	C46F4.2
+T20B3.1	C46F4.2
+Y25C1A.13	C46F4.2
+Y42G9A.4	C46F4.2
+Y46G5A.21	C46F4.2
+Y50D7A.7	C46F4.2
+Y54G11A.13	C46F4.2
+Y54G11A.5	C46F4.2
+Y54G11A.6	C46F4.2
+Y57A10C.6	C46F4.2
+Y69A2AR.5	C46F4.2
+Y71G12B.10	C46F4.2
+Y71H10A.2	C46F4.2
+ZK1320.1	C46F4.2
+ZK550.6	C46F4.2
+ZK809.7	C46F4.2
+C47B2.8	C47A10.5
+C48B4.1	C47A10.5
+C54G10.3	C47A10.5
+F08A8.1	C47A10.5
+F08A8.2	C47A10.5
+F08A8.3	C47A10.5
+F08A8.4	C47A10.5
+F08B12.2	C47A10.5
+F10D11.1	C47A10.5
+F15E6.6	C47A10.5
+F18F11.1	C47A10.5
+F25E2.3	C47A10.5
+F28F8.2	C47A10.5
+F32A5.6	C47A10.5
+F32D8.13	C47A10.5
+F36H9.3	C47A10.5
+F37C12.7	C47A10.5
+F41E6.5	C47A10.5
+F47G6.2	C47A10.5
+F54F2.8	C47A10.5
+F55B11.1	C47A10.5
+F55H2.1	C47A10.5
+F58F9.7	C47A10.5
+F59B8.2	C47A10.5
+F59F4.1	C47A10.5
+R06F6.9	C47A10.5
+R07C3.4	C47A10.5
+R07H5.1	C47A10.5
+R09E10.3	C47A10.5
+R09E10.4	C47A10.5
+T02D1.5	C47A10.5
+T08B1.6	C47A10.5
+T18D3.9	C47A10.5
+T20B3.1	C47A10.5
+Y25C1A.13	C47A10.5
+Y42G9A.4	C47A10.5
+Y46G5A.21	C47A10.5
+Y50D7A.7	C47A10.5
+Y54G11A.13	C47A10.5
+Y54G11A.5	C47A10.5
+Y54G11A.6	C47A10.5
+Y57A10C.6	C47A10.5
+Y65B4BL.5	C47A10.5
+Y69A2AR.5	C47A10.5
+Y71G12B.10	C47A10.5
+Y71H10A.2	C47A10.5
+Y76A2B.3	C47A10.5
+ZK1320.1	C47A10.5
+ZK550.6	C47A10.5
+ZK809.7	C47A10.5
+C48B4.1	C47B2.8
+C54G10.3	C47B2.8
+F08A8.1	C47B2.8
+F08A8.2	C47B2.8
+F08A8.3	C47B2.8
+F08A8.4	C47B2.8
+F08B12.2	C47B2.8
+F10D11.1	C47B2.8
+F15E6.6	C47B2.8
+F18E3.7	C47B2.8
+F18F11.1	C47B2.8
+F25E2.3	C47B2.8
+F28F8.2	C47B2.8
+F32A5.6	C47B2.8
+F32D8.13	C47B2.8
+F36H9.3	C47B2.8
+F37C12.7	C47B2.8
+F41E6.5	C47B2.8
+F47G6.2	C47B2.8
+F54F2.8	C47B2.8
+F55B11.1	C47B2.8
+F55H2.1	C47B2.8
+F58F9.7	C47B2.8
+F59B8.2	C47B2.8
+F59F4.1	C47B2.8
+R06F6.9	C47B2.8
+R07C3.4	C47B2.8
+R07H5.1	C47B2.8
+R09E10.3	C47B2.8
+R09E10.4	C47B2.8
+T02D1.5	C47B2.8
+T08B1.6	C47B2.8
+T14D7.1	C47B2.8
+T18D3.9	C47B2.8
+T20B3.1	C47B2.8
+Y25C1A.13	C47B2.8
+Y42G9A.4	C47B2.8
+Y46G5A.21	C47B2.8
+Y50D7A.7	C47B2.8
+Y54G11A.13	C47B2.8
+Y54G11A.5	C47B2.8
+Y54G11A.6	C47B2.8
+Y57A10C.6	C47B2.8
+Y65B4BL.5	C47B2.8
+Y69A2AR.5	C47B2.8
+Y71G12B.10	C47B2.8
+Y71H10A.2	C47B2.8
+Y76A2B.3	C47B2.8
+ZK1320.1	C47B2.8
+ZK550.6	C47B2.8
+ZK809.7	C47B2.8
+C54G10.3	C48B4.1
+F08B12.2	C48B4.1
+F10D11.1	C48B4.1
+F15E6.6	C48B4.1
+F18E3.7	C48B4.1
+F18F11.1	C48B4.1
+F25E2.3	C48B4.1
+F32A5.6	C48B4.1
+F32D8.13	C48B4.1
+F36H9.3	C48B4.1
+F41E6.5	C48B4.1
+F54F2.8	C48B4.1
+F55B11.1	C48B4.1
+F55H2.1	C48B4.1
+F59B8.2	C48B4.1
+R07H5.1	C48B4.1
+T02D1.5	C48B4.1
+T14D7.1	C48B4.1
+T18D3.9	C48B4.1
+T20B3.1	C48B4.1
+Y25C1A.13	C48B4.1
+Y42G9A.4	C48B4.1
+Y46G5A.21	C48B4.1
+Y50D7A.7	C48B4.1
+Y54G11A.13	C48B4.1
+Y54G11A.5	C48B4.1
+Y54G11A.6	C48B4.1
+Y57A10C.6	C48B4.1
+Y69A2AR.5	C48B4.1
+Y71G12B.10	C48B4.1
+Y71H10A.2	C48B4.1
+ZK1320.1	C48B4.1
+ZK550.6	C48B4.1
+ZK809.7	C48B4.1
+F08A8.1	C54G10.3
+F08A8.2	C54G10.3
+F08A8.3	C54G10.3
+F08A8.4	C54G10.3
+F08B12.2	C54G10.3
+F10D11.1	C54G10.3
+F15E6.6	C54G10.3
+F18E3.7	C54G10.3
+F18F11.1	C54G10.3
+F25E2.3	C54G10.3
+F28F8.2	C54G10.3
+F32A5.6	C54G10.3
+F32D8.13	C54G10.3
+F36H9.3	C54G10.3
+F37C12.7	C54G10.3
+F41E6.5	C54G10.3
+F47G6.2	C54G10.3
+F54F2.8	C54G10.3
+F55B11.1	C54G10.3
+F55H2.1	C54G10.3
+F58F9.7	C54G10.3
+F59B8.2	C54G10.3
+F59F4.1	C54G10.3
+R06F6.9	C54G10.3
+R07C3.4	C54G10.3
+R07H5.1	C54G10.3
+R09E10.3	C54G10.3
+R09E10.4	C54G10.3
+T08B1.6	C54G10.3
+T14D7.1	C54G10.3
+T18D3.9	C54G10.3
+T20B3.1	C54G10.3
+Y25C1A.13	C54G10.3
+Y42G9A.4	C54G10.3
+Y46G5A.21	C54G10.3
+Y50D7A.7	C54G10.3
+Y54G11A.13	C54G10.3
+Y54G11A.5	C54G10.3
+Y54G11A.6	C54G10.3
+Y57A10C.6	C54G10.3
+Y65B4BL.5	C54G10.3
+Y69A2AR.5	C54G10.3
+Y71G12B.10	C54G10.3
+Y71H10A.2	C54G10.3
+Y76A2B.3	C54G10.3
+ZK1320.1	C54G10.3
+ZK550.6	C54G10.3
+ZK809.7	C54G10.3
+F08B12.2	F08A8.1
+F10D11.1	F08A8.1
+F15E6.6	F08A8.1
+F18E3.7	F08A8.1
+F18F11.1	F08A8.1
+F25E2.3	F08A8.1
+F32A5.6	F08A8.1
+F32D8.13	F08A8.1
+F36H9.3	F08A8.1
+F41E6.5	F08A8.1
+F54F2.8	F08A8.1
+F55B11.1	F08A8.1
+F55H2.1	F08A8.1
+F59B8.2	F08A8.1
+R07H5.1	F08A8.1
+T02D1.5	F08A8.1
+T14D7.1	F08A8.1
+T18D3.9	F08A8.1
+T20B3.1	F08A8.1
+Y25C1A.13	F08A8.1
+Y42G9A.4	F08A8.1
+Y46G5A.21	F08A8.1
+Y50D7A.7	F08A8.1
+Y54G11A.13	F08A8.1
+Y54G11A.5	F08A8.1
+Y54G11A.6	F08A8.1
+Y57A10C.6	F08A8.1
+Y69A2AR.5	F08A8.1
+Y71G12B.10	F08A8.1
+Y71H10A.2	F08A8.1
+ZK1320.1	F08A8.1
+ZK550.6	F08A8.1
+ZK809.7	F08A8.1
+F08B12.2	F08A8.2
+F10D11.1	F08A8.2
+F15E6.6	F08A8.2
+F18E3.7	F08A8.2
+F18F11.1	F08A8.2
+F25E2.3	F08A8.2
+F32A5.6	F08A8.2
+F32D8.13	F08A8.2
+F36H9.3	F08A8.2
+F41E6.5	F08A8.2
+F54F2.8	F08A8.2
+F55B11.1	F08A8.2
+F55H2.1	F08A8.2
+F59B8.2	F08A8.2
+R07H5.1	F08A8.2
+T02D1.5	F08A8.2
+T14D7.1	F08A8.2
+T18D3.9	F08A8.2
+T20B3.1	F08A8.2
+Y25C1A.13	F08A8.2
+Y42G9A.4	F08A8.2
+Y46G5A.21	F08A8.2
+Y50D7A.7	F08A8.2
+Y54G11A.13	F08A8.2
+Y54G11A.5	F08A8.2
+Y54G11A.6	F08A8.2
+Y57A10C.6	F08A8.2
+Y69A2AR.5	F08A8.2
+Y71G12B.10	F08A8.2
+Y71H10A.2	F08A8.2
+ZK1320.1	F08A8.2
+ZK550.6	F08A8.2
+ZK809.7	F08A8.2
+F08B12.2	F08A8.3
+F10D11.1	F08A8.3
+F15E6.6	F08A8.3
+F18E3.7	F08A8.3
+F18F11.1	F08A8.3
+F25E2.3	F08A8.3
+F32A5.6	F08A8.3
+F32D8.13	F08A8.3
+F36H9.3	F08A8.3
+F41E6.5	F08A8.3
+F54F2.8	F08A8.3
+F55B11.1	F08A8.3
+F55H2.1	F08A8.3
+F59B8.2	F08A8.3
+R07H5.1	F08A8.3
+T02D1.5	F08A8.3
+T14D7.1	F08A8.3
+T18D3.9	F08A8.3
+T20B3.1	F08A8.3
+Y25C1A.13	F08A8.3
+Y42G9A.4	F08A8.3
+Y46G5A.21	F08A8.3
+Y50D7A.7	F08A8.3
+Y54G11A.13	F08A8.3
+Y54G11A.5	F08A8.3
+Y54G11A.6	F08A8.3
+Y57A10C.6	F08A8.3
+Y69A2AR.5	F08A8.3
+Y71G12B.10	F08A8.3
+Y71H10A.2	F08A8.3
+ZK1320.1	F08A8.3
+ZK550.6	F08A8.3
+ZK809.7	F08A8.3
+F08B12.2	F08A8.4
+F10D11.1	F08A8.4
+F15E6.6	F08A8.4
+F18E3.7	F08A8.4
+F18F11.1	F08A8.4
+F25E2.3	F08A8.4
+F32A5.6	F08A8.4
+F32D8.13	F08A8.4
+F36H9.3	F08A8.4
+F41E6.5	F08A8.4
+F54F2.8	F08A8.4
+F55B11.1	F08A8.4
+F55H2.1	F08A8.4
+F59B8.2	F08A8.4
+R07H5.1	F08A8.4
+T02D1.5	F08A8.4
+T14D7.1	F08A8.4
+T18D3.9	F08A8.4
+T20B3.1	F08A8.4
+Y25C1A.13	F08A8.4
+Y42G9A.4	F08A8.4
+Y46G5A.21	F08A8.4
+Y50D7A.7	F08A8.4
+Y54G11A.13	F08A8.4
+Y54G11A.5	F08A8.4
+Y54G11A.6	F08A8.4
+Y57A10C.6	F08A8.4
+Y69A2AR.5	F08A8.4
+Y71G12B.10	F08A8.4
+Y71H10A.2	F08A8.4
+ZK1320.1	F08A8.4
+ZK550.6	F08A8.4
+ZK809.7	F08A8.4
+F10D11.1	F08B12.2
+F15E6.6	F08B12.2
+F18E3.7	F08B12.2
+F18F11.1	F08B12.2
+F25E2.3	F08B12.2
+F28F8.2	F08B12.2
+F32A5.6	F08B12.2
+F32D8.13	F08B12.2
+F36H9.3	F08B12.2
+F37C12.7	F08B12.2
+F41E6.5	F08B12.2
+F47G6.2	F08B12.2
+F54F2.8	F08B12.2
+F55B11.1	F08B12.2
+F55H2.1	F08B12.2
+F58F9.7	F08B12.2
+F59B8.2	F08B12.2
+F59F4.1	F08B12.2
+R06F6.9	F08B12.2
+R07C3.4	F08B12.2
+R07H5.1	F08B12.2
+R09E10.3	F08B12.2
+R09E10.4	F08B12.2
+T02D1.5	F08B12.2
+T08B1.6	F08B12.2
+T14D7.1	F08B12.2
+T18D3.9	F08B12.2
+T20B3.1	F08B12.2
+Y25C1A.13	F08B12.2
+Y42G9A.4	F08B12.2
+Y46G5A.21	F08B12.2
+Y50D7A.7	F08B12.2
+Y54G11A.13	F08B12.2
+Y54G11A.5	F08B12.2
+Y54G11A.6	F08B12.2
+Y57A10C.6	F08B12.2
+Y65B4BL.5	F08B12.2
+Y69A2AR.5	F08B12.2
+Y71G12B.10	F08B12.2
+Y71H10A.2	F08B12.2
+Y76A2B.3	F08B12.2
+ZK1320.1	F08B12.2
+ZK550.6	F08B12.2
+ZK809.7	F08B12.2
+F15E6.6	F10D11.1
+F18E3.7	F10D11.1
+F18F11.1	F10D11.1
+F25E2.3	F10D11.1
+F28F8.2	F10D11.1
+F32A5.6	F10D11.1
+F32D8.13	F10D11.1
+F36H9.3	F10D11.1
+F37C12.7	F10D11.1
+F41E6.5	F10D11.1
+F47G6.2	F10D11.1
+F54F2.8	F10D11.1
+F55B11.1	F10D11.1
+F55H2.1	F10D11.1
+F58F9.7	F10D11.1
+F59B8.2	F10D11.1
+F59F4.1	F10D11.1
+R06F6.9	F10D11.1
+R07C3.4	F10D11.1
+R07H5.1	F10D11.1
+R09E10.3	F10D11.1
+R09E10.4	F10D11.1
+T02D1.5	F10D11.1
+T08B1.6	F10D11.1
+T14D7.1	F10D11.1
+T18D3.9	F10D11.1
+T20B3.1	F10D11.1
+Y25C1A.13	F10D11.1
+Y42G9A.4	F10D11.1
+Y46G5A.21	F10D11.1
+Y50D7A.7	F10D11.1
+Y54G11A.13	F10D11.1
+Y54G11A.5	F10D11.1
+Y54G11A.6	F10D11.1
+Y57A10C.6	F10D11.1
+Y65B4BL.5	F10D11.1
+Y69A2AR.5	F10D11.1
+Y71G12B.10	F10D11.1
+Y71H10A.2	F10D11.1
+Y76A2B.3	F10D11.1
+ZK1320.1	F10D11.1
+ZK550.6	F10D11.1
+ZK809.7	F10D11.1
+F18E3.7	F15E6.6
+F18F11.1	F15E6.6
+F25E2.3	F15E6.6
+F28F8.2	F15E6.6
+F32A5.6	F15E6.6
+F32D8.13	F15E6.6
+F36H9.3	F15E6.6
+F37C12.7	F15E6.6
+F41E6.5	F15E6.6
+F47G6.2	F15E6.6
+F54F2.8	F15E6.6
+F55H2.1	F15E6.6
+F58F9.7	F15E6.6
+F59B8.2	F15E6.6
+F59F4.1	F15E6.6
+R06F6.9	F15E6.6
+R07C3.4	F15E6.6
+R07H5.1	F15E6.6
+R09E10.3	F15E6.6
+R09E10.4	F15E6.6
+T02D1.5	F15E6.6
+T08B1.6	F15E6.6
+T14D7.1	F15E6.6
+T18D3.9	F15E6.6
+T20B3.1	F15E6.6
+Y25C1A.13	F15E6.6
+Y42G9A.4	F15E6.6
+Y46G5A.21	F15E6.6
+Y50D7A.7	F15E6.6
+Y54G11A.13	F15E6.6
+Y54G11A.5	F15E6.6
+Y54G11A.6	F15E6.6
+Y57A10C.6	F15E6.6
+Y65B4BL.5	F15E6.6
+Y69A2AR.5	F15E6.6
+Y71G12B.10	F15E6.6
+Y71H10A.2	F15E6.6
+Y76A2B.3	F15E6.6
+ZK1320.1	F15E6.6
+ZK550.6	F15E6.6
+ZK809.7	F15E6.6
+F18F11.1	F18E3.7
+F25E2.3	F18E3.7
+F28F8.2	F18E3.7
+F32A5.6	F18E3.7
+F32D8.13	F18E3.7
+F36H9.3	F18E3.7
+F37C12.7	F18E3.7
+F41E6.5	F18E3.7
+F47G6.2	F18E3.7
+F54F2.8	F18E3.7
+F55B11.1	F18E3.7
+F55H2.1	F18E3.7
+F58F9.7	F18E3.7
+F59B8.2	F18E3.7
+F59F4.1	F18E3.7
+R06F6.9	F18E3.7
+R07C3.4	F18E3.7
+R07H5.1	F18E3.7
+R09E10.3	F18E3.7
+R09E10.4	F18E3.7
+T02D1.5	F18E3.7
+T08B1.6	F18E3.7
+T18D3.9	F18E3.7
+T20B3.1	F18E3.7
+Y25C1A.13	F18E3.7
+Y42G9A.4	F18E3.7
+Y46G5A.21	F18E3.7
+Y50D7A.7	F18E3.7
+Y54G11A.13	F18E3.7
+Y54G11A.5	F18E3.7
+Y54G11A.6	F18E3.7
+Y57A10C.6	F18E3.7
+Y65B4BL.5	F18E3.7
+Y69A2AR.5	F18E3.7
+Y71G12B.10	F18E3.7
+Y71H10A.2	F18E3.7
+Y76A2B.3	F18E3.7
+ZK1320.1	F18E3.7
+ZK550.6	F18E3.7
+ZK809.7	F18E3.7
+F25E2.3	F18F11.1
+F28F8.2	F18F11.1
+F32A5.6	F18F11.1
+F32D8.13	F18F11.1
+F36H9.3	F18F11.1
+F37C12.7	F18F11.1
+F41E6.5	F18F11.1
+F47G6.2	F18F11.1
+F54F2.8	F18F11.1
+F55B11.1	F18F11.1
+F55H2.1	F18F11.1
+F58F9.7	F18F11.1
+F59B8.2	F18F11.1
+F59F4.1	F18F11.1
+R06F6.9	F18F11.1
+R07C3.4	F18F11.1
+R07H5.1	F18F11.1
+R09E10.3	F18F11.1
+R09E10.4	F18F11.1
+T02D1.5	F18F11.1
+T08B1.6	F18F11.1
+T14D7.1	F18F11.1
+T18D3.9	F18F11.1
+T20B3.1	F18F11.1
+Y25C1A.13	F18F11.1
+Y42G9A.4	F18F11.1
+Y46G5A.21	F18F11.1
+Y50D7A.7	F18F11.1
+Y54G11A.13	F18F11.1
+Y54G11A.5	F18F11.1
+Y54G11A.6	F18F11.1
+Y57A10C.6	F18F11.1
+Y65B4BL.5	F18F11.1
+Y69A2AR.5	F18F11.1
+Y71G12B.10	F18F11.1
+Y71H10A.2	F18F11.1
+Y76A2B.3	F18F11.1
+ZK1320.1	F18F11.1
+ZK550.6	F18F11.1
+ZK809.7	F18F11.1
+F28F8.2	F25E2.3
+F32A5.6	F25E2.3
+F32D8.13	F25E2.3
+F36H9.3	F25E2.3
+F37C12.7	F25E2.3
+F41E6.5	F25E2.3
+F47G6.2	F25E2.3
+F54F2.8	F25E2.3
+F55B11.1	F25E2.3
+F55H2.1	F25E2.3
+F58F9.7	F25E2.3
+F59B8.2	F25E2.3
+F59F4.1	F25E2.3
+R06F6.9	F25E2.3
+R07C3.4	F25E2.3
+R07H5.1	F25E2.3
+R09E10.3	F25E2.3
+R09E10.4	F25E2.3
+T02D1.5	F25E2.3
+T08B1.6	F25E2.3
+T14D7.1	F25E2.3
+T18D3.9	F25E2.3
+T20B3.1	F25E2.3
+Y25C1A.13	F25E2.3
+Y42G9A.4	F25E2.3
+Y46G5A.21	F25E2.3
+Y50D7A.7	F25E2.3
+Y54G11A.13	F25E2.3
+Y54G11A.5	F25E2.3
+Y54G11A.6	F25E2.3
+Y57A10C.6	F25E2.3
+Y65B4BL.5	F25E2.3
+Y69A2AR.5	F25E2.3
+Y71G12B.10	F25E2.3
+Y71H10A.2	F25E2.3
+Y76A2B.3	F25E2.3
+ZK1320.1	F25E2.3
+ZK550.6	F25E2.3
+ZK809.7	F25E2.3
+F32A5.6	F28F8.2
+F32D8.13	F28F8.2
+F36H9.3	F28F8.2
+F41E6.5	F28F8.2
+F54F2.8	F28F8.2
+F55B11.1	F28F8.2
+F55H2.1	F28F8.2
+F59B8.2	F28F8.2
+R07H5.1	F28F8.2
+T02D1.5	F28F8.2
+T14D7.1	F28F8.2
+T18D3.9	F28F8.2
+T20B3.1	F28F8.2
+Y25C1A.13	F28F8.2
+Y42G9A.4	F28F8.2
+Y46G5A.21	F28F8.2
+Y50D7A.7	F28F8.2
+Y54G11A.13	F28F8.2
+Y54G11A.5	F28F8.2
+Y54G11A.6	F28F8.2
+Y57A10C.6	F28F8.2
+Y69A2AR.5	F28F8.2
+Y71G12B.10	F28F8.2
+Y71H10A.2	F28F8.2
+ZK1320.1	F28F8.2
+ZK550.6	F28F8.2
+ZK809.7	F28F8.2
+F32D8.13	F32A5.6
+F36H9.3	F32A5.6
+F37C12.7	F32A5.6
+F41E6.5	F32A5.6
+F47G6.2	F32A5.6
+F54F2.8	F32A5.6
+F55B11.1	F32A5.6
+F55H2.1	F32A5.6
+F58F9.7	F32A5.6
+F59B8.2	F32A5.6
+F59F4.1	F32A5.6
+R06F6.9	F32A5.6
+R07C3.4	F32A5.6
+R07H5.1	F32A5.6
+R09E10.3	F32A5.6
+R09E10.4	F32A5.6
+T02D1.5	F32A5.6
+T08B1.6	F32A5.6
+T14D7.1	F32A5.6
+T18D3.9	F32A5.6
+T20B3.1	F32A5.6
+Y25C1A.13	F32A5.6
+Y42G9A.4	F32A5.6
+Y46G5A.21	F32A5.6
+Y50D7A.7	F32A5.6
+Y54G11A.13	F32A5.6
+Y54G11A.5	F32A5.6
+Y54G11A.6	F32A5.6
+Y57A10C.6	F32A5.6
+Y65B4BL.5	F32A5.6
+Y69A2AR.5	F32A5.6
+Y71G12B.10	F32A5.6
+Y71H10A.2	F32A5.6
+Y76A2B.3	F32A5.6
+ZK1320.1	F32A5.6
+ZK550.6	F32A5.6
+ZK809.7	F32A5.6
+F36H9.3	F32D8.13
+F37C12.7	F32D8.13
+F41E6.5	F32D8.13
+F47G6.2	F32D8.13
+F54F2.8	F32D8.13
+F55B11.1	F32D8.13
+F55H2.1	F32D8.13
+F58F9.7	F32D8.13
+F59B8.2	F32D8.13
+F59F4.1	F32D8.13
+R06F6.9	F32D8.13
+R07C3.4	F32D8.13
+R07H5.1	F32D8.13
+R09E10.3	F32D8.13
+R09E10.4	F32D8.13
+T02D1.5	F32D8.13
+T08B1.6	F32D8.13
+T14D7.1	F32D8.13
+T18D3.9	F32D8.13
+T20B3.1	F32D8.13
+Y25C1A.13	F32D8.13
+Y46G5A.21	F32D8.13
+Y50D7A.7	F32D8.13
+Y54G11A.13	F32D8.13
+Y54G11A.5	F32D8.13
+Y54G11A.6	F32D8.13
+Y57A10C.6	F32D8.13
+Y65B4BL.5	F32D8.13
+Y69A2AR.5	F32D8.13
+Y71G12B.10	F32D8.13
+Y71H10A.2	F32D8.13
+Y76A2B.3	F32D8.13
+ZK1320.1	F32D8.13
+ZK550.6	F32D8.13
+ZK809.7	F32D8.13
+F37C12.7	F36H9.3
+F41E6.5	F36H9.3
+F47G6.2	F36H9.3
+F54F2.8	F36H9.3
+F55B11.1	F36H9.3
+F55H2.1	F36H9.3
+F58F9.7	F36H9.3
+F59B8.2	F36H9.3
+F59F4.1	F36H9.3
+R06F6.9	F36H9.3
+R07C3.4	F36H9.3
+R07H5.1	F36H9.3
+R09E10.3	F36H9.3
+R09E10.4	F36H9.3
+T02D1.5	F36H9.3
+T08B1.6	F36H9.3
+T14D7.1	F36H9.3
+T18D3.9	F36H9.3
+T20B3.1	F36H9.3
+Y25C1A.13	F36H9.3
+Y42G9A.4	F36H9.3
+Y46G5A.21	F36H9.3
+Y50D7A.7	F36H9.3
+Y54G11A.13	F36H9.3
+Y54G11A.5	F36H9.3
+Y54G11A.6	F36H9.3
+Y57A10C.6	F36H9.3
+Y65B4BL.5	F36H9.3
+Y69A2AR.5	F36H9.3
+Y71G12B.10	F36H9.3
+Y71H10A.2	F36H9.3
+Y76A2B.3	F36H9.3
+ZK1320.1	F36H9.3
+ZK550.6	F36H9.3
+ZK809.7	F36H9.3
+F41E6.5	F37C12.7
+F54F2.8	F37C12.7
+F55B11.1	F37C12.7
+F55H2.1	F37C12.7
+F59B8.2	F37C12.7
+R07H5.1	F37C12.7
+T02D1.5	F37C12.7
+T14D7.1	F37C12.7
+T18D3.9	F37C12.7
+T20B3.1	F37C12.7
+Y25C1A.13	F37C12.7
+Y42G9A.4	F37C12.7
+Y46G5A.21	F37C12.7
+Y50D7A.7	F37C12.7
+Y54G11A.13	F37C12.7
+Y54G11A.5	F37C12.7
+Y54G11A.6	F37C12.7
+Y57A10C.6	F37C12.7
+Y69A2AR.5	F37C12.7
+Y71G12B.10	F37C12.7
+Y71H10A.2	F37C12.7
+ZK1320.1	F37C12.7
+ZK550.6	F37C12.7
+ZK809.7	F37C12.7
+F47G6.2	F41E6.5
+F54F2.8	F41E6.5
+F55B11.1	F41E6.5
+F55H2.1	F41E6.5
+F58F9.7	F41E6.5
+F59B8.2	F41E6.5
+F59F4.1	F41E6.5
+R06F6.9	F41E6.5
+R07C3.4	F41E6.5
+R07H5.1	F41E6.5
+R09E10.3	F41E6.5
+R09E10.4	F41E6.5
+T02D1.5	F41E6.5
+T08B1.6	F41E6.5
+T14D7.1	F41E6.5
+T18D3.9	F41E6.5
+T20B3.1	F41E6.5
+Y25C1A.13	F41E6.5
+Y42G9A.4	F41E6.5
+Y46G5A.21	F41E6.5
+Y50D7A.7	F41E6.5
+Y54G11A.13	F41E6.5
+Y54G11A.5	F41E6.5
+Y54G11A.6	F41E6.5
+Y57A10C.6	F41E6.5
+Y65B4BL.5	F41E6.5
+Y69A2AR.5	F41E6.5
+Y71G12B.10	F41E6.5
+Y71H10A.2	F41E6.5
+Y76A2B.3	F41E6.5
+ZK1320.1	F41E6.5
+ZK550.6	F41E6.5
+ZK809.7	F41E6.5
+F54F2.8	F47G6.2
+F55B11.1	F47G6.2
+F55H2.1	F47G6.2
+F59B8.2	F47G6.2
+R07H5.1	F47G6.2
+T02D1.5	F47G6.2
+T14D7.1	F47G6.2
+T18D3.9	F47G6.2
+T20B3.1	F47G6.2
+Y25C1A.13	F47G6.2
+Y42G9A.4	F47G6.2
+Y46G5A.21	F47G6.2
+Y50D7A.7	F47G6.2
+Y54G11A.13	F47G6.2
+Y54G11A.5	F47G6.2
+Y54G11A.6	F47G6.2
+Y57A10C.6	F47G6.2
+Y69A2AR.5	F47G6.2
+Y71G12B.10	F47G6.2
+Y71H10A.2	F47G6.2
+ZK1320.1	F47G6.2
+ZK550.6	F47G6.2
+ZK809.7	F47G6.2
+F55B11.1	F54F2.8
+F55H2.1	F54F2.8
+F58F9.7	F54F2.8
+F59B8.2	F54F2.8
+F59F4.1	F54F2.8
+R06F6.9	F54F2.8
+R07C3.4	F54F2.8
+R07H5.1	F54F2.8
+R09E10.3	F54F2.8
+R09E10.4	F54F2.8
+T02D1.5	F54F2.8
+T08B1.6	F54F2.8
+T14D7.1	F54F2.8
+T18D3.9	F54F2.8
+T20B3.1	F54F2.8
+Y25C1A.13	F54F2.8
+Y42G9A.4	F54F2.8
+Y46G5A.21	F54F2.8
+Y50D7A.7	F54F2.8
+Y54G11A.13	F54F2.8
+Y54G11A.5	F54F2.8
+Y54G11A.6	F54F2.8
+Y57A10C.6	F54F2.8
+Y65B4BL.5	F54F2.8
+Y69A2AR.5	F54F2.8
+Y71G12B.10	F54F2.8
+Y71H10A.2	F54F2.8
+Y76A2B.3	F54F2.8
+ZK1320.1	F54F2.8
+ZK550.6	F54F2.8
+ZK809.7	F54F2.8
+F55H2.1	F55B11.1
+F58F9.7	F55B11.1
+F59B8.2	F55B11.1
+F59F4.1	F55B11.1
+R06F6.9	F55B11.1
+R07C3.4	F55B11.1
+R07H5.1	F55B11.1
+R09E10.3	F55B11.1
+R09E10.4	F55B11.1
+T02D1.5	F55B11.1
+T08B1.6	F55B11.1
+T14D7.1	F55B11.1
+T18D3.9	F55B11.1
+T20B3.1	F55B11.1
+Y25C1A.13	F55B11.1
+Y42G9A.4	F55B11.1
+Y46G5A.21	F55B11.1
+Y50D7A.7	F55B11.1
+Y54G11A.13	F55B11.1
+Y54G11A.5	F55B11.1
+Y54G11A.6	F55B11.1
+Y57A10C.6	F55B11.1
+Y65B4BL.5	F55B11.1
+Y69A2AR.5	F55B11.1
+Y71G12B.10	F55B11.1
+Y71H10A.2	F55B11.1
+Y76A2B.3	F55B11.1
+ZK1320.1	F55B11.1
+ZK550.6	F55B11.1
+ZK809.7	F55B11.1
+F58F9.7	F55H2.1
+F59B8.2	F55H2.1
+F59F4.1	F55H2.1
+R06F6.9	F55H2.1
+R07C3.4	F55H2.1
+R07H5.1	F55H2.1
+R09E10.3	F55H2.1
+R09E10.4	F55H2.1
+T02D1.5	F55H2.1
+T08B1.6	F55H2.1
+T14D7.1	F55H2.1
+T18D3.9	F55H2.1
+T20B3.1	F55H2.1
+Y25C1A.13	F55H2.1
+Y42G9A.4	F55H2.1
+Y46G5A.21	F55H2.1
+Y50D7A.7	F55H2.1
+Y54G11A.13	F55H2.1
+Y54G11A.5	F55H2.1
+Y54G11A.6	F55H2.1
+Y57A10C.6	F55H2.1
+Y65B4BL.5	F55H2.1
+Y69A2AR.5	F55H2.1
+Y71G12B.10	F55H2.1
+Y71H10A.2	F55H2.1
+Y76A2B.3	F55H2.1
+ZK1320.1	F55H2.1
+ZK550.6	F55H2.1
+ZK809.7	F55H2.1
+F59B8.2	F58F9.7
+R07H5.1	F58F9.7
+T02D1.5	F58F9.7
+T14D7.1	F58F9.7
+T18D3.9	F58F9.7
+T20B3.1	F58F9.7
+Y25C1A.13	F58F9.7
+Y42G9A.4	F58F9.7
+Y46G5A.21	F58F9.7
+Y50D7A.7	F58F9.7
+Y54G11A.13	F58F9.7
+Y54G11A.5	F58F9.7
+Y54G11A.6	F58F9.7
+Y57A10C.6	F58F9.7
+Y69A2AR.5	F58F9.7
+Y71G12B.10	F58F9.7
+Y71H10A.2	F58F9.7
+ZK1320.1	F58F9.7
+ZK550.6	F58F9.7
+ZK809.7	F58F9.7
+F59F4.1	F59B8.2
+R06F6.9	F59B8.2
+R07C3.4	F59B8.2
+R07H5.1	F59B8.2
+R09E10.3	F59B8.2
+R09E10.4	F59B8.2
+T02D1.5	F59B8.2
+T08B1.6	F59B8.2
+T14D7.1	F59B8.2
+T18D3.9	F59B8.2
+T20B3.1	F59B8.2
+Y25C1A.13	F59B8.2
+Y42G9A.4	F59B8.2
+Y46G5A.21	F59B8.2
+Y50D7A.7	F59B8.2
+Y54G11A.13	F59B8.2
+Y54G11A.5	F59B8.2
+Y54G11A.6	F59B8.2
+Y57A10C.6	F59B8.2
+Y65B4BL.5	F59B8.2
+Y69A2AR.5	F59B8.2
+Y71G12B.10	F59B8.2
+Y71H10A.2	F59B8.2
+Y76A2B.3	F59B8.2
+ZK550.6	F59B8.2
+ZK809.7	F59B8.2
+R07H5.1	F59F4.1
+T02D1.5	F59F4.1
+T14D7.1	F59F4.1
+T18D3.9	F59F4.1
+T20B3.1	F59F4.1
+Y25C1A.13	F59F4.1
+Y42G9A.4	F59F4.1
+Y46G5A.21	F59F4.1
+Y50D7A.7	F59F4.1
+Y54G11A.13	F59F4.1
+Y54G11A.5	F59F4.1
+Y54G11A.6	F59F4.1
+Y57A10C.6	F59F4.1
+Y69A2AR.5	F59F4.1
+Y71G12B.10	F59F4.1
+Y71H10A.2	F59F4.1
+ZK1320.1	F59F4.1
+ZK550.6	F59F4.1
+ZK809.7	F59F4.1
+R07H5.1	R06F6.9
+T02D1.5	R06F6.9
+T14D7.1	R06F6.9
+T18D3.9	R06F6.9
+T20B3.1	R06F6.9
+Y25C1A.13	R06F6.9
+Y42G9A.4	R06F6.9
+Y46G5A.21	R06F6.9
+Y50D7A.7	R06F6.9
+Y54G11A.13	R06F6.9
+Y54G11A.5	R06F6.9
+Y54G11A.6	R06F6.9
+Y57A10C.6	R06F6.9
+Y69A2AR.5	R06F6.9
+Y71G12B.10	R06F6.9
+Y71H10A.2	R06F6.9
+ZK1320.1	R06F6.9
+ZK550.6	R06F6.9
+ZK809.7	R06F6.9
+R07H5.1	R07C3.4
+T02D1.5	R07C3.4
+T14D7.1	R07C3.4
+T18D3.9	R07C3.4
+T20B3.1	R07C3.4
+Y25C1A.13	R07C3.4
+Y42G9A.4	R07C3.4
+Y46G5A.21	R07C3.4
+Y50D7A.7	R07C3.4
+Y54G11A.13	R07C3.4
+Y54G11A.5	R07C3.4
+Y54G11A.6	R07C3.4
+Y57A10C.6	R07C3.4
+Y69A2AR.5	R07C3.4
+Y71G12B.10	R07C3.4
+Y71H10A.2	R07C3.4
+ZK1320.1	R07C3.4
+ZK550.6	R07C3.4
+ZK809.7	R07C3.4
+R09E10.3	R07H5.1
+R09E10.4	R07H5.1
+T02D1.5	R07H5.1
+T08B1.6	R07H5.1
+T14D7.1	R07H5.1
+T18D3.9	R07H5.1
+T20B3.1	R07H5.1
+Y25C1A.13	R07H5.1
+Y42G9A.4	R07H5.1
+Y46G5A.21	R07H5.1
+Y50D7A.7	R07H5.1
+Y54G11A.13	R07H5.1
+Y54G11A.5	R07H5.1
+Y54G11A.6	R07H5.1
+Y57A10C.6	R07H5.1
+Y65B4BL.5	R07H5.1
+Y69A2AR.5	R07H5.1
+Y71G12B.10	R07H5.1
+Y71H10A.2	R07H5.1
+Y76A2B.3	R07H5.1
+ZK1320.1	R07H5.1
+ZK550.6	R07H5.1
+ZK809.7	R07H5.1
+T02D1.5	R09E10.3
+T14D7.1	R09E10.3
+T18D3.9	R09E10.3
+T20B3.1	R09E10.3
+Y25C1A.13	R09E10.3
+Y42G9A.4	R09E10.3
+Y46G5A.21	R09E10.3
+Y50D7A.7	R09E10.3
+Y54G11A.13	R09E10.3
+Y54G11A.5	R09E10.3
+Y54G11A.6	R09E10.3
+Y57A10C.6	R09E10.3
+Y69A2AR.5	R09E10.3
+Y71G12B.10	R09E10.3
+Y71H10A.2	R09E10.3
+ZK1320.1	R09E10.3
+ZK550.6	R09E10.3
+ZK809.7	R09E10.3
+T02D1.5	R09E10.4
+T14D7.1	R09E10.4
+T18D3.9	R09E10.4
+T20B3.1	R09E10.4
+Y25C1A.13	R09E10.4
+Y42G9A.4	R09E10.4
+Y46G5A.21	R09E10.4
+Y50D7A.7	R09E10.4
+Y54G11A.13	R09E10.4
+Y54G11A.5	R09E10.4
+Y54G11A.6	R09E10.4
+Y57A10C.6	R09E10.4
+Y69A2AR.5	R09E10.4
+Y71G12B.10	R09E10.4
+Y71H10A.2	R09E10.4
+ZK1320.1	R09E10.4
+ZK550.6	R09E10.4
+ZK809.7	R09E10.4
+T08B1.6	T02D1.5
+T14D7.1	T02D1.5
+T18D3.9	T02D1.5
+T20B3.1	T02D1.5
+Y25C1A.13	T02D1.5
+Y42G9A.4	T02D1.5
+Y46G5A.21	T02D1.5
+Y50D7A.7	T02D1.5
+Y54G11A.13	T02D1.5
+Y54G11A.5	T02D1.5
+Y54G11A.6	T02D1.5
+Y57A10C.6	T02D1.5
+Y65B4BL.5	T02D1.5
+Y69A2AR.5	T02D1.5
+Y71G12B.10	T02D1.5
+Y71H10A.2	T02D1.5
+Y76A2B.3	T02D1.5
+ZK1320.1	T02D1.5
+ZK550.6	T02D1.5
+ZK809.7	T02D1.5
+T14D7.1	T08B1.6
+T18D3.9	T08B1.6
+T20B3.1	T08B1.6
+Y25C1A.13	T08B1.6
+Y42G9A.4	T08B1.6
+Y46G5A.21	T08B1.6
+Y50D7A.7	T08B1.6
+Y54G11A.13	T08B1.6
+Y54G11A.5	T08B1.6
+Y54G11A.6	T08B1.6
+Y57A10C.6	T08B1.6
+Y69A2AR.5	T08B1.6
+Y71G12B.10	T08B1.6
+Y71H10A.2	T08B1.6
+ZK1320.1	T08B1.6
+ZK550.6	T08B1.6
+ZK809.7	T08B1.6
+T18D3.9	T14D7.1
+T20B3.1	T14D7.1
+Y25C1A.13	T14D7.1
+Y42G9A.4	T14D7.1
+Y46G5A.21	T14D7.1
+Y50D7A.7	T14D7.1
+Y54G11A.13	T14D7.1
+Y54G11A.5	T14D7.1
+Y54G11A.6	T14D7.1
+Y57A10C.6	T14D7.1
+Y65B4BL.5	T14D7.1
+Y71G12B.10	T14D7.1
+Y71H10A.2	T14D7.1
+Y76A2B.3	T14D7.1
+ZK1320.1	T14D7.1
+ZK550.6	T14D7.1
+ZK809.7	T14D7.1
+T20B3.1	T18D3.9
+Y25C1A.13	T18D3.9
+Y42G9A.4	T18D3.9
+Y46G5A.21	T18D3.9
+Y50D7A.7	T18D3.9
+Y54G11A.13	T18D3.9
+Y54G11A.5	T18D3.9
+Y54G11A.6	T18D3.9
+Y57A10C.6	T18D3.9
+Y65B4BL.5	T18D3.9
+Y69A2AR.5	T18D3.9
+Y71G12B.10	T18D3.9
+Y71H10A.2	T18D3.9
+Y76A2B.3	T18D3.9
+ZK1320.1	T18D3.9
+ZK550.6	T18D3.9
+ZK809.7	T18D3.9
+Y25C1A.13	T20B3.1
+Y42G9A.4	T20B3.1
+Y46G5A.21	T20B3.1
+Y50D7A.7	T20B3.1
+Y54G11A.13	T20B3.1
+Y54G11A.5	T20B3.1
+Y54G11A.6	T20B3.1
+Y57A10C.6	T20B3.1
+Y65B4BL.5	T20B3.1
+Y69A2AR.5	T20B3.1
+Y71G12B.10	T20B3.1
+Y71H10A.2	T20B3.1
+Y76A2B.3	T20B3.1
+ZK1320.1	T20B3.1
+ZK550.6	T20B3.1
+ZK809.7	T20B3.1
+Y42G9A.4	Y25C1A.13
+Y46G5A.21	Y25C1A.13
+Y50D7A.7	Y25C1A.13
+Y54G11A.13	Y25C1A.13
+Y54G11A.5	Y25C1A.13
+Y54G11A.6	Y25C1A.13
+Y57A10C.6	Y25C1A.13
+Y65B4BL.5	Y25C1A.13
+Y69A2AR.5	Y25C1A.13
+Y71G12B.10	Y25C1A.13
+Y71H10A.2	Y25C1A.13
+Y76A2B.3	Y25C1A.13
+ZK1320.1	Y25C1A.13
+ZK550.6	Y25C1A.13
+ZK809.7	Y25C1A.13
+Y46G5A.21	Y42G9A.4
+Y50D7A.7	Y42G9A.4
+Y54G11A.13	Y42G9A.4
+Y54G11A.5	Y42G9A.4
+Y54G11A.6	Y42G9A.4
+Y57A10C.6	Y42G9A.4
+Y65B4BL.5	Y42G9A.4
+Y69A2AR.5	Y42G9A.4
+Y71G12B.10	Y42G9A.4
+Y71H10A.2	Y42G9A.4
+Y76A2B.3	Y42G9A.4
+ZK1320.1	Y42G9A.4
+ZK550.6	Y42G9A.4
+ZK809.7	Y42G9A.4
+Y50D7A.7	Y46G5A.21
+Y54G11A.13	Y46G5A.21
+Y54G11A.5	Y46G5A.21
+Y54G11A.6	Y46G5A.21
+Y57A10C.6	Y46G5A.21
+Y65B4BL.5	Y46G5A.21
+Y69A2AR.5	Y46G5A.21
+Y71G12B.10	Y46G5A.21
+Y71H10A.2	Y46G5A.21
+Y76A2B.3	Y46G5A.21
+ZK1320.1	Y46G5A.21
+ZK550.6	Y46G5A.21
+ZK809.7	Y46G5A.21
+Y54G11A.13	Y50D7A.7
+Y54G11A.5	Y50D7A.7
+Y54G11A.6	Y50D7A.7
+Y57A10C.6	Y50D7A.7
+Y65B4BL.5	Y50D7A.7
+Y69A2AR.5	Y50D7A.7
+Y71G12B.10	Y50D7A.7
+Y71H10A.2	Y50D7A.7
+Y76A2B.3	Y50D7A.7
+ZK1320.1	Y50D7A.7
+ZK550.6	Y50D7A.7
+ZK809.7	Y50D7A.7
+Y57A10C.6	Y54G11A.13
+Y65B4BL.5	Y54G11A.13
+Y69A2AR.5	Y54G11A.13
+Y71G12B.10	Y54G11A.13
+Y71H10A.2	Y54G11A.13
+Y76A2B.3	Y54G11A.13
+ZK1320.1	Y54G11A.13
+ZK550.6	Y54G11A.13
+ZK809.7	Y54G11A.13
+Y57A10C.6	Y54G11A.5
+Y65B4BL.5	Y54G11A.5
+Y69A2AR.5	Y54G11A.5
+Y71G12B.10	Y54G11A.5
+Y71H10A.2	Y54G11A.5
+Y76A2B.3	Y54G11A.5
+ZK1320.1	Y54G11A.5
+ZK550.6	Y54G11A.5
+ZK809.7	Y54G11A.5
+Y57A10C.6	Y54G11A.6
+Y65B4BL.5	Y54G11A.6
+Y69A2AR.5	Y54G11A.6
+Y71G12B.10	Y54G11A.6
+Y71H10A.2	Y54G11A.6
+Y76A2B.3	Y54G11A.6
+ZK1320.1	Y54G11A.6
+ZK550.6	Y54G11A.6
+ZK809.7	Y54G11A.6
+Y65B4BL.5	Y57A10C.6
+Y69A2AR.5	Y57A10C.6
+Y71G12B.10	Y57A10C.6
+Y71H10A.2	Y57A10C.6
+Y76A2B.3	Y57A10C.6
+ZK1320.1	Y57A10C.6
+ZK550.6	Y57A10C.6
+ZK809.7	Y57A10C.6
+Y69A2AR.5	Y65B4BL.5
+Y71G12B.10	Y65B4BL.5
+Y71H10A.2	Y65B4BL.5
+ZK1320.1	Y65B4BL.5
+ZK550.6	Y65B4BL.5
+ZK809.7	Y65B4BL.5
+Y71G12B.10	Y69A2AR.5
+Y71H10A.2	Y69A2AR.5
+Y76A2B.3	Y69A2AR.5
+ZK1320.1	Y69A2AR.5
+ZK550.6	Y69A2AR.5
+ZK809.7	Y69A2AR.5
+Y71H10A.2	Y71G12B.10
+Y76A2B.3	Y71G12B.10
+ZK1320.1	Y71G12B.10
+ZK550.6	Y71G12B.10
+ZK809.7	Y71G12B.10
+Y76A2B.3	Y71H10A.2
+ZK1320.1	Y71H10A.2
+ZK550.6	Y71H10A.2
+ZK809.7	Y71H10A.2
+ZK1320.1	Y76A2B.3
+ZK550.6	Y76A2B.3
+ZK809.7	Y76A2B.3
+ZK550.6	ZK1320.1
+ZK809.7	ZK1320.1
+ZK809.7	ZK550.6
+B0348.6	B0261.2
+C05D9.5	B0261.2
+C10C5.6	B0261.2
+C10H11.8	B0261.2
+F38A6.3	B0261.2
+F53A2.6	B0261.2
+F54C8.5	B0261.2
+H42K12.1	B0261.2
+R02E12.2	B0261.2
+R04A9.4	B0261.2
+T01C8.1	B0261.2
+T01H8.1	B0261.2
+Y57A10A.30	B0261.2
+Y59A8B.14	B0261.2
+Y60A3A.1	B0261.2
+Y71A12B.1	B0261.2
+B0348.6	B0334.8
+C05D9.5	B0334.8
+C10C5.6	B0334.8
+C10H11.8	B0334.8
+F38A6.3	B0334.8
+F53A2.6	B0334.8
+F54C8.5	B0334.8
+H42K12.1	B0334.8
+R02E12.2	B0334.8
+R04A9.4	B0334.8
+T01C8.1	B0334.8
+T01H8.1	B0334.8
+Y57A10A.30	B0334.8
+Y59A8B.14	B0334.8
+Y60A3A.1	B0334.8
+Y71A12B.1	B0334.8
+C10C5.6	B0348.6
+C10H11.8	B0348.6
+C12D8.10	B0348.6
+F28H6.1	B0348.6
+F38A6.3	B0348.6
+F43C1.2	B0348.6
+F54C8.5	B0348.6
+H42K12.1	B0348.6
+R02E12.2	B0348.6
+R04A9.7	B0348.6
+T01C8.1	B0348.6
+T01H8.1	B0348.6
+Y110A7A.10	B0348.6
+Y47D3A.16	B0348.6
+Y59A8B.14	B0348.6
+Y60A3A.1	B0348.6
+Y71A12B.1	B0348.6
+Y73B6A.5	B0348.6
+C10C5.6	C05D9.5
+C10H11.8	C05D9.5
+C12D8.10	C05D9.5
+F28H6.1	C05D9.5
+F38A6.3	C05D9.5
+F43C1.2	C05D9.5
+F54C8.5	C05D9.5
+H42K12.1	C05D9.5
+R02E12.2	C05D9.5
+R04A9.7	C05D9.5
+T01C8.1	C05D9.5
+T01H8.1	C05D9.5
+Y110A7A.10	C05D9.5
+Y47D3A.16	C05D9.5
+Y59A8B.14	C05D9.5
+Y60A3A.1	C05D9.5
+Y71A12B.1	C05D9.5
+Y73B6A.5	C05D9.5
+C10H11.8	C10C5.6
+C12D8.10	C10C5.6
+F28H6.1	C10C5.6
+F38A6.3	C10C5.6
+F43C1.2	C10C5.6
+F53A2.6	C10C5.6
+F54C8.5	C10C5.6
+H42K12.1	C10C5.6
+R02E12.2	C10C5.6
+R04A9.4	C10C5.6
+R04A9.7	C10C5.6
+T01C8.1	C10C5.6
+T01H8.1	C10C5.6
+Y110A7A.10	C10C5.6
+Y47D3A.16	C10C5.6
+Y57A10A.30	C10C5.6
+Y59A8B.14	C10C5.6
+Y60A3A.1	C10C5.6
+Y71A12B.1	C10C5.6
+Y73B6A.5	C10C5.6
+C12D8.10	C10H11.8
+F28H6.1	C10H11.8
+F38A6.3	C10H11.8
+F43C1.2	C10H11.8
+F53A2.6	C10H11.8
+F54C8.5	C10H11.8
+H42K12.1	C10H11.8
+R02E12.2	C10H11.8
+R04A9.4	C10H11.8
+R04A9.7	C10H11.8
+T01C8.1	C10H11.8
+T01H8.1	C10H11.8
+Y110A7A.10	C10H11.8
+Y47D3A.16	C10H11.8
+Y57A10A.30	C10H11.8
+Y59A8B.14	C10H11.8
+Y60A3A.1	C10H11.8
+Y71A12B.1	C10H11.8
+Y73B6A.5	C10H11.8
+F38A6.3	C12D8.10
+F53A2.6	C12D8.10
+F54C8.5	C12D8.10
+H42K12.1	C12D8.10
+R02E12.2	C12D8.10
+R04A9.4	C12D8.10
+T01C8.1	C12D8.10
+Y57A10A.30	C12D8.10
+Y59A8B.14	C12D8.10
+Y60A3A.1	C12D8.10
+Y71A12B.1	C12D8.10
+F38A6.3	F28H6.1
+F53A2.6	F28H6.1
+F54C8.5	F28H6.1
+H42K12.1	F28H6.1
+R02E12.2	F28H6.1
+R04A9.4	F28H6.1
+T01C8.1	F28H6.1
+Y57A10A.30	F28H6.1
+Y59A8B.14	F28H6.1
+Y60A3A.1	F28H6.1
+Y71A12B.1	F28H6.1
+F43C1.2	F38A6.3
+F53A2.6	F38A6.3
+F54C8.5	F38A6.3
+H42K12.1	F38A6.3
+R02E12.2	F38A6.3
+R04A9.4	F38A6.3
+R04A9.7	F38A6.3
+T01C8.1	F38A6.3
+T01H8.1	F38A6.3
+Y110A7A.10	F38A6.3
+Y47D3A.16	F38A6.3
+Y57A10A.30	F38A6.3
+Y59A8B.14	F38A6.3
+Y60A3A.1	F38A6.3
+Y71A12B.1	F38A6.3
+Y73B6A.5	F38A6.3
+F53A2.6	F43C1.2
+F54C8.5	F43C1.2
+H42K12.1	F43C1.2
+R02E12.2	F43C1.2
+R04A9.4	F43C1.2
+T01C8.1	F43C1.2
+Y57A10A.30	F43C1.2
+Y59A8B.14	F43C1.2
+Y60A3A.1	F43C1.2
+Y71A12B.1	F43C1.2
+F54C8.5	F53A2.6
+H42K12.1	F53A2.6
+R02E12.2	F53A2.6
+R04A9.7	F53A2.6
+T01C8.1	F53A2.6
+T01H8.1	F53A2.6
+Y110A7A.10	F53A2.6
+Y47D3A.16	F53A2.6
+Y59A8B.14	F53A2.6
+Y60A3A.1	F53A2.6
+Y71A12B.1	F53A2.6
+Y73B6A.5	F53A2.6
+H42K12.1	F54C8.5
+R02E12.2	F54C8.5
+R04A9.4	F54C8.5
+R04A9.7	F54C8.5
+T01C8.1	F54C8.5
+T01H8.1	F54C8.5
+Y110A7A.10	F54C8.5
+Y47D3A.16	F54C8.5
+Y57A10A.30	F54C8.5
+Y59A8B.14	F54C8.5
+Y60A3A.1	F54C8.5
+Y71A12B.1	F54C8.5
+Y73B6A.5	F54C8.5
+R02E12.2	H42K12.1
+R04A9.4	H42K12.1
+R04A9.7	H42K12.1
+T01C8.1	H42K12.1
+T01H8.1	H42K12.1
+Y110A7A.10	H42K12.1
+Y47D3A.16	H42K12.1
+Y57A10A.30	H42K12.1
+Y59A8B.14	H42K12.1
+Y60A3A.1	H42K12.1
+Y71A12B.1	H42K12.1
+Y73B6A.5	H42K12.1
+R04A9.4	R02E12.2
+R04A9.7	R02E12.2
+T01C8.1	R02E12.2
+T01H8.1	R02E12.2
+Y110A7A.10	R02E12.2
+Y47D3A.16	R02E12.2
+Y57A10A.30	R02E12.2
+Y59A8B.14	R02E12.2
+Y60A3A.1	R02E12.2
+Y71A12B.1	R02E12.2
+Y73B6A.5	R02E12.2
+R04A9.7	R04A9.4
+T01C8.1	R04A9.4
+T01H8.1	R04A9.4
+Y110A7A.10	R04A9.4
+Y47D3A.16	R04A9.4
+Y59A8B.14	R04A9.4
+Y60A3A.1	R04A9.4
+Y71A12B.1	R04A9.4
+Y73B6A.5	R04A9.4
+T01C8.1	R04A9.7
+T01H8.1	R04A9.7
+Y57A10A.30	R04A9.7
+Y59A8B.14	R04A9.7
+Y60A3A.1	R04A9.7
+Y71A12B.1	R04A9.7
+T01H8.1	T01C8.1
+Y110A7A.10	T01C8.1
+Y47D3A.16	T01C8.1
+Y57A10A.30	T01C8.1
+Y59A8B.14	T01C8.1
+Y71A12B.1	T01C8.1
+Y73B6A.5	T01C8.1
+Y110A7A.10	T01H8.1
+Y47D3A.16	T01H8.1
+Y57A10A.30	T01H8.1
+Y59A8B.14	T01H8.1
+Y60A3A.1	T01H8.1
+Y71A12B.1	T01H8.1
+Y57A10A.30	Y110A7A.10
+Y59A8B.14	Y110A7A.10
+Y60A3A.1	Y110A7A.10
+Y71A12B.1	Y110A7A.10
+Y57A10A.30	Y47D3A.16
+Y59A8B.14	Y47D3A.16
+Y60A3A.1	Y47D3A.16
+Y71A12B.1	Y47D3A.16
+Y59A8B.14	Y57A10A.30
+Y60A3A.1	Y57A10A.30
+Y71A12B.1	Y57A10A.30
+Y73B6A.5	Y57A10A.30
+Y60A3A.1	Y59A8B.14
+Y71A12B.1	Y59A8B.14
+Y73B6A.5	Y59A8B.14
+Y71A12B.1	Y60A3A.1
+Y73B6A.5	Y60A3A.1
+Y73B6A.5	Y71A12B.1
+B0336.1	B0205.7
+B0348.4	B0205.7
+B0478.1	B0205.7
+C02F4.2	B0205.7
+C03C10.1	B0205.7
+C06A8.4	B0205.7
+C10H11.9	B0205.7
+C13G3.3	B0205.7
+C27H6.2	B0205.7
+C34F11.9	B0205.7
+C42D4.6	B0205.7
+C44H4.6	B0205.7
+C52D10.6	B0205.7
+C52D10.7	B0205.7
+C52D10.8	B0205.7
+C52D10.9	B0205.7
+C54D1.6	B0205.7
+D2045.6	B0205.7
+E01H11.1	B0205.7
+F27E11.3	B0205.7
+F35H12.3	B0205.7
+F38E1.7	B0205.7
+F38H4.9	B0205.7
+F44G3.6	B0205.7
+F46A9.4	B0205.7
+F46A9.5	B0205.7
+F47F2.1	B0205.7
+F47H4.10	B0205.7
+F48E8.5	B0205.7
+F49E10.5	B0205.7
+F54D10.1	B0205.7
+F55C10.1	B0205.7
+F56B3.12	B0205.7
+F56E10.2	B0205.7
+F59D6.7	B0205.7
+K05C4.6	B0205.7
+K08H2.1	B0205.7
+K10B2.1	B0205.7
+K11E8.1	B0205.7
+R10E11.1	B0205.7
+R12B2.1	B0205.7
+R12H7.3	B0205.7
+R12H7.5	B0205.7
+T07H6.2	B0205.7
+T23D8.1	B0205.7
+W06F12.1	B0205.7
+W08G11.4	B0205.7
+Y105C5B.13	B0205.7
+Y18D10A.5	B0205.7
+Y34D9B.1	B0205.7
+Y37E11AR.2	B0205.7
+Y37H2C.2	B0205.7
+Y38F1A.5	B0205.7
+Y47D7A.1	B0205.7
+Y47D7A.8	B0205.7
+Y51H4A.3	B0205.7
+Y60A3A.18	B0205.7
+Y71F9B.5	B0205.7
+Y71H2AL.1	B0205.7
+ZK287.5	B0205.7
+ZK856.8	B0205.7
+ZK909.2	B0205.7
+B0348.4	B0336.1
+B0478.1	B0336.1
+C02F4.2	B0336.1
+C03C10.1	B0336.1
+C06A8.4	B0336.1
+C10H11.9	B0336.1
+C13G3.3	B0336.1
+C27H6.2	B0336.1
+C34F11.9	B0336.1
+C42D4.6	B0336.1
+C44H4.6	B0336.1
+C52D10.6	B0336.1
+C52D10.7	B0336.1
+C52D10.8	B0336.1
+C52D10.9	B0336.1
+D2045.6	B0336.1
+E01H11.1	B0336.1
+F27E11.3	B0336.1
+F35H12.3	B0336.1
+F38E1.7	B0336.1
+F38H4.9	B0336.1
+F44G3.6	B0336.1
+F46A9.4	B0336.1
+F46A9.5	B0336.1
+F47F2.1	B0336.1
+F47H4.10	B0336.1
+F48E8.5	B0336.1
+F49E10.5	B0336.1
+F54D10.1	B0336.1
+F55C10.1	B0336.1
+F56B3.12	B0336.1
+F56E10.2	B0336.1
+F59D6.7	B0336.1
+K08H2.1	B0336.1
+K10B2.1	B0336.1
+K11E8.1	B0336.1
+R10E11.1	B0336.1
+R12B2.1	B0336.1
+R12H7.3	B0336.1
+R12H7.5	B0336.1
+T01G9.6	B0336.1
+T07H6.2	B0336.1
+T23D8.1	B0336.1
+W06F12.1	B0336.1
+W08G11.4	B0336.1
+Y105C5B.13	B0336.1
+Y18D10A.5	B0336.1
+Y34D9B.1	B0336.1
+Y37E11AR.2	B0336.1
+Y37H2C.2	B0336.1
+Y38F1A.5	B0336.1
+Y47D7A.1	B0336.1
+Y47D7A.8	B0336.1
+Y51H4A.3	B0336.1
+Y60A3A.18	B0336.1
+Y71F9B.5	B0336.1
+Y71H2AL.1	B0336.1
+ZK287.5	B0336.1
+ZK856.8	B0336.1
+ZK909.2	B0336.1
+B0478.1	B0348.4
+C03C10.1	B0348.4
+C06A8.4	B0348.4
+C10H11.9	B0348.4
+C13G3.3	B0348.4
+C27H6.2	B0348.4
+C34F11.9	B0348.4
+C42D4.6	B0348.4
+C44H4.6	B0348.4
+C52D10.6	B0348.4
+C52D10.7	B0348.4
+C52D10.8	B0348.4
+C52D10.9	B0348.4
+C54D1.6	B0348.4
+D2045.6	B0348.4
+F27E11.3	B0348.4
+F35H12.3	B0348.4
+F38E1.7	B0348.4
+F38H4.9	B0348.4
+F44G3.6	B0348.4
+F46A9.4	B0348.4
+F46A9.5	B0348.4
+F47H4.10	B0348.4
+F48E8.5	B0348.4
+F49E10.5	B0348.4
+F54D10.1	B0348.4
+F56B3.12	B0348.4
+F56E10.2	B0348.4
+K05C4.6	B0348.4
+K08H2.1	B0348.4
+K10B2.1	B0348.4
+R10E11.1	B0348.4
+R12B2.1	B0348.4
+R12H7.3	B0348.4
+R12H7.5	B0348.4
+T01G9.6	B0348.4
+T07H6.2	B0348.4
+T23D8.1	B0348.4
+W06F12.1	B0348.4
+W08G11.4	B0348.4
+Y105C5B.13	B0348.4
+Y18D10A.5	B0348.4
+Y34D9B.1	B0348.4
+Y37E11AR.2	B0348.4
+Y37H2C.2	B0348.4
+Y38F1A.5	B0348.4
+Y47D7A.1	B0348.4
+Y47D7A.8	B0348.4
+Y51H4A.3	B0348.4
+Y60A3A.18	B0348.4
+Y71F9B.5	B0348.4
+ZK287.5	B0348.4
+C03C10.1	B0478.1
+C10H11.9	B0478.1
+C13G3.3	B0478.1
+C27H6.2	B0478.1
+C34F11.9	B0478.1
+C54D1.6	B0478.1
+F27E11.3	B0478.1
+F35H12.3	B0478.1
+F38E1.7	B0478.1
+F38H4.9	B0478.1
+F48E8.5	B0478.1
+F49E10.5	B0478.1
+F56E10.2	B0478.1
+K05C4.6	B0478.1
+K10B2.1	B0478.1
+R10E11.1	B0478.1
+R12B2.1	B0478.1
+T01G9.6	B0478.1
+T07H6.2	B0478.1
+T23D8.1	B0478.1
+W08G11.4	B0478.1
+Y34D9B.1	B0478.1
+Y37E11AR.2	B0478.1
+Y38F1A.5	B0478.1
+Y51H4A.3	B0478.1
+Y71F9B.5	B0478.1
+C03C10.1	C02F4.2
+C06A8.4	C02F4.2
+C10H11.9	C02F4.2
+C13G3.3	C02F4.2
+C27H6.2	C02F4.2
+C34F11.9	C02F4.2
+C42D4.6	C02F4.2
+C44H4.6	C02F4.2
+C52D10.6	C02F4.2
+C52D10.7	C02F4.2
+C52D10.8	C02F4.2
+C52D10.9	C02F4.2
+C54D1.6	C02F4.2
+D2045.6	C02F4.2
+F27E11.3	C02F4.2
+F35H12.3	C02F4.2
+F38E1.7	C02F4.2
+F38H4.9	C02F4.2
+F44G3.6	C02F4.2
+F46A9.4	C02F4.2
+F46A9.5	C02F4.2
+F47H4.10	C02F4.2
+F48E8.5	C02F4.2
+F49E10.5	C02F4.2
+F54D10.1	C02F4.2
+F56B3.12	C02F4.2
+F56E10.2	C02F4.2
+K05C4.6	C02F4.2
+K08H2.1	C02F4.2
+K10B2.1	C02F4.2
+R10E11.1	C02F4.2
+R12B2.1	C02F4.2
+R12H7.3	C02F4.2
+R12H7.5	C02F4.2
+T01G9.6	C02F4.2
+T07H6.2	C02F4.2
+T23D8.1	C02F4.2
+W08G11.4	C02F4.2
+Y105C5B.13	C02F4.2
+Y18D10A.5	C02F4.2
+Y34D9B.1	C02F4.2
+Y37E11AR.2	C02F4.2
+Y37H2C.2	C02F4.2
+Y38F1A.5	C02F4.2
+Y47D7A.1	C02F4.2
+Y47D7A.8	C02F4.2
+Y51H4A.3	C02F4.2
+Y60A3A.18	C02F4.2
+Y71F9B.5	C02F4.2
+ZK287.5	C02F4.2
+C06A8.4	C03C10.1
+C10H11.9	C03C10.1
+C13G3.3	C03C10.1
+C27H6.2	C03C10.1
+C34F11.9	C03C10.1
+C42D4.6	C03C10.1
+C44H4.6	C03C10.1
+C52D10.6	C03C10.1
+C52D10.7	C03C10.1
+C52D10.8	C03C10.1
+C52D10.9	C03C10.1
+C54D1.6	C03C10.1
+D2045.6	C03C10.1
+E01H11.1	C03C10.1
+F27E11.3	C03C10.1
+F35H12.3	C03C10.1
+F38E1.7	C03C10.1
+F38H4.9	C03C10.1
+F44G3.6	C03C10.1
+F46A9.4	C03C10.1
+F46A9.5	C03C10.1
+F47F2.1	C03C10.1
+F47H4.10	C03C10.1
+F48E8.5	C03C10.1
+F49E10.5	C03C10.1
+F54D10.1	C03C10.1
+F55C10.1	C03C10.1
+F56B3.12	C03C10.1
+F56E10.2	C03C10.1
+F59D6.7	C03C10.1
+K05C4.6	C03C10.1
+K08H2.1	C03C10.1
+K10B2.1	C03C10.1
+K11E8.1	C03C10.1
+R10E11.1	C03C10.1
+R12B2.1	C03C10.1
+R12H7.3	C03C10.1
+R12H7.5	C03C10.1
+T01G9.6	C03C10.1
+T07H6.2	C03C10.1
+T23D8.1	C03C10.1
+W06F12.1	C03C10.1
+W08G11.4	C03C10.1
+Y105C5B.13	C03C10.1
+Y18D10A.5	C03C10.1
+Y34D9B.1	C03C10.1
+Y37E11AR.2	C03C10.1
+Y37H2C.2	C03C10.1
+Y38F1A.5	C03C10.1
+Y47D7A.1	C03C10.1
+Y47D7A.8	C03C10.1
+Y51H4A.3	C03C10.1
+Y60A3A.18	C03C10.1
+Y71F9B.5	C03C10.1
+Y71H2AL.1	C03C10.1
+ZK287.5	C03C10.1
+ZK856.8	C03C10.1
+ZK909.2	C03C10.1
+C10H11.9	C06A8.4
+C13G3.3	C06A8.4
+C27H6.2	C06A8.4
+C34F11.9	C06A8.4
+C44H4.6	C06A8.4
+C54D1.6	C06A8.4
+E01H11.1	C06A8.4
+F27E11.3	C06A8.4
+F35H12.3	C06A8.4
+F38E1.7	C06A8.4
+F38H4.9	C06A8.4
+F47F2.1	C06A8.4
+F48E8.5	C06A8.4
+F49E10.5	C06A8.4
+F55C10.1	C06A8.4
+F56E10.2	C06A8.4
+F59D6.7	C06A8.4
+K05C4.6	C06A8.4
+K11E8.1	C06A8.4
+R10E11.1	C06A8.4
+R12B2.1	C06A8.4
+T01G9.6	C06A8.4
+T07H6.2	C06A8.4
+T23D8.1	C06A8.4
+W06F12.1	C06A8.4
+W08G11.4	C06A8.4
+Y18D10A.5	C06A8.4
+Y34D9B.1	C06A8.4
+Y38F1A.5	C06A8.4
+Y51H4A.3	C06A8.4
+Y71F9B.5	C06A8.4
+Y71H2AL.1	C06A8.4
+ZK856.8	C06A8.4
+ZK909.2	C06A8.4
+C13G3.3	C10H11.9
+C27H6.2	C10H11.9
+C34F11.9	C10H11.9
+C42D4.6	C10H11.9
+C44H4.6	C10H11.9
+C52D10.6	C10H11.9
+C52D10.7	C10H11.9
+C52D10.8	C10H11.9
+C52D10.9	C10H11.9
+C54D1.6	C10H11.9
+D2045.6	C10H11.9
+E01H11.1	C10H11.9
+F27E11.3	C10H11.9
+F35H12.3	C10H11.9
+F38E1.7	C10H11.9
+F38H4.9	C10H11.9
+F44G3.6	C10H11.9
+F46A9.4	C10H11.9
+F46A9.5	C10H11.9
+F47F2.1	C10H11.9
+F47H4.10	C10H11.9
+F48E8.5	C10H11.9
+F49E10.5	C10H11.9
+F54D10.1	C10H11.9
+F55C10.1	C10H11.9
+F56B3.12	C10H11.9
+F56E10.2	C10H11.9
+F59D6.7	C10H11.9
+K05C4.6	C10H11.9
+K08H2.1	C10H11.9
+K10B2.1	C10H11.9
+K11E8.1	C10H11.9
+R10E11.1	C10H11.9
+R12B2.1	C10H11.9
+R12H7.3	C10H11.9
+R12H7.5	C10H11.9
+T01G9.6	C10H11.9
+T07H6.2	C10H11.9
+T23D8.1	C10H11.9
+W06F12.1	C10H11.9
+W08G11.4	C10H11.9
+Y105C5B.13	C10H11.9
+Y18D10A.5	C10H11.9
+Y34D9B.1	C10H11.9
+Y37E11AR.2	C10H11.9
+Y37H2C.2	C10H11.9
+Y38F1A.5	C10H11.9
+Y47D7A.1	C10H11.9
+Y47D7A.8	C10H11.9
+Y51H4A.3	C10H11.9
+Y60A3A.18	C10H11.9
+Y71F9B.5	C10H11.9
+Y71H2AL.1	C10H11.9
+ZK287.5	C10H11.9
+ZK856.8	C10H11.9
+ZK909.2	C10H11.9
+C27H6.2	C13G3.3
+C34F11.9	C13G3.3
+C42D4.6	C13G3.3
+C44H4.6	C13G3.3
+C52D10.6	C13G3.3
+C52D10.7	C13G3.3
+C52D10.8	C13G3.3
+C52D10.9	C13G3.3
+C54D1.6	C13G3.3
+D2045.6	C13G3.3
+E01H11.1	C13G3.3
+F27E11.3	C13G3.3
+F35H12.3	C13G3.3
+F38E1.7	C13G3.3
+F44G3.6	C13G3.3
+F46A9.4	C13G3.3
+F46A9.5	C13G3.3
+F47F2.1	C13G3.3
+F47H4.10	C13G3.3
+F49E10.5	C13G3.3
+F54D10.1	C13G3.3
+F55C10.1	C13G3.3
+F56B3.12	C13G3.3
+F56E10.2	C13G3.3
+F59D6.7	C13G3.3
+K05C4.6	C13G3.3
+K08H2.1	C13G3.3
+K10B2.1	C13G3.3
+K11E8.1	C13G3.3
+R10E11.1	C13G3.3
+R12B2.1	C13G3.3
+R12H7.3	C13G3.3
+R12H7.5	C13G3.3
+T01G9.6	C13G3.3
+T07H6.2	C13G3.3
+T23D8.1	C13G3.3
+W06F12.1	C13G3.3
+Y105C5B.13	C13G3.3
+Y18D10A.5	C13G3.3
+Y34D9B.1	C13G3.3
+Y37E11AR.2	C13G3.3
+Y37H2C.2	C13G3.3
+Y38F1A.5	C13G3.3
+Y47D7A.1	C13G3.3
+Y47D7A.8	C13G3.3
+Y51H4A.3	C13G3.3
+Y60A3A.18	C13G3.3
+Y71F9B.5	C13G3.3
+Y71H2AL.1	C13G3.3
+ZK287.5	C13G3.3
+ZK856.8	C13G3.3
+ZK909.2	C13G3.3
+C34F11.9	C27H6.2
+C42D4.6	C27H6.2
+C44H4.6	C27H6.2
+C52D10.6	C27H6.2
+C52D10.7	C27H6.2
+C52D10.8	C27H6.2
+C52D10.9	C27H6.2
+C54D1.6	C27H6.2
+D2045.6	C27H6.2
+E01H11.1	C27H6.2
+F27E11.3	C27H6.2
+F35H12.3	C27H6.2
+F38E1.7	C27H6.2
+F38H4.9	C27H6.2
+F44G3.6	C27H6.2
+F46A9.4	C27H6.2
+F46A9.5	C27H6.2
+F47F2.1	C27H6.2
+F47H4.10	C27H6.2
+F48E8.5	C27H6.2
+F49E10.5	C27H6.2
+F54D10.1	C27H6.2
+F55C10.1	C27H6.2
+F56B3.12	C27H6.2
+F56E10.2	C27H6.2
+F59D6.7	C27H6.2
+K05C4.6	C27H6.2
+K08H2.1	C27H6.2
+K10B2.1	C27H6.2
+K11E8.1	C27H6.2
+R10E11.1	C27H6.2
+R12B2.1	C27H6.2
+R12H7.3	C27H6.2
+R12H7.5	C27H6.2
+T01G9.6	C27H6.2
+T07H6.2	C27H6.2
+T23D8.1	C27H6.2
+W06F12.1	C27H6.2
+W08G11.4	C27H6.2
+Y105C5B.13	C27H6.2
+Y18D10A.5	C27H6.2
+Y34D9B.1	C27H6.2
+Y37E11AR.2	C27H6.2
+Y37H2C.2	C27H6.2
+Y38F1A.5	C27H6.2
+Y47D7A.1	C27H6.2
+Y47D7A.8	C27H6.2
+Y51H4A.3	C27H6.2
+Y60A3A.18	C27H6.2
+Y71F9B.5	C27H6.2
+Y71H2AL.1	C27H6.2
+ZK287.5	C27H6.2
+ZK856.8	C27H6.2
+ZK909.2	C27H6.2
+C42D4.6	C34F11.9
+C44H4.6	C34F11.9
+C52D10.6	C34F11.9
+C52D10.7	C34F11.9
+C52D10.8	C34F11.9
+C52D10.9	C34F11.9
+C54D1.6	C34F11.9
+D2045.6	C34F11.9
+E01H11.1	C34F11.9
+F27E11.3	C34F11.9
+F35H12.3	C34F11.9
+F38E1.7	C34F11.9
+F38H4.9	C34F11.9
+F44G3.6	C34F11.9
+F46A9.4	C34F11.9
+F46A9.5	C34F11.9
+F47F2.1	C34F11.9
+F47H4.10	C34F11.9
+F48E8.5	C34F11.9
+F49E10.5	C34F11.9
+F54D10.1	C34F11.9
+F55C10.1	C34F11.9
+F56B3.12	C34F11.9
+F56E10.2	C34F11.9
+F59D6.7	C34F11.9
+K05C4.6	C34F11.9
+K08H2.1	C34F11.9
+K10B2.1	C34F11.9
+K11E8.1	C34F11.9
+R10E11.1	C34F11.9
+R12B2.1	C34F11.9
+R12H7.3	C34F11.9
+R12H7.5	C34F11.9
+T01G9.6	C34F11.9
+T07H6.2	C34F11.9
+T23D8.1	C34F11.9
+W06F12.1	C34F11.9
+W08G11.4	C34F11.9
+Y105C5B.13	C34F11.9
+Y18D10A.5	C34F11.9
+Y34D9B.1	C34F11.9
+Y37E11AR.2	C34F11.9
+Y37H2C.2	C34F11.9
+Y38F1A.5	C34F11.9
+Y47D7A.1	C34F11.9
+Y47D7A.8	C34F11.9
+Y51H4A.3	C34F11.9
+Y60A3A.18	C34F11.9
+Y71F9B.5	C34F11.9
+Y71H2AL.1	C34F11.9
+ZK287.5	C34F11.9
+ZK856.8	C34F11.9
+ZK909.2	C34F11.9
+C44H4.6	C42D4.6
+C54D1.6	C42D4.6
+E01H11.1	C42D4.6
+F27E11.3	C42D4.6
+F35H12.3	C42D4.6
+F38E1.7	C42D4.6
+F38H4.9	C42D4.6
+F47F2.1	C42D4.6
+F48E8.5	C42D4.6
+F49E10.5	C42D4.6
+F55C10.1	C42D4.6
+F56E10.2	C42D4.6
+F59D6.7	C42D4.6
+K05C4.6	C42D4.6
+K11E8.1	C42D4.6
+R10E11.1	C42D4.6
+R12B2.1	C42D4.6
+T01G9.6	C42D4.6
+T07H6.2	C42D4.6
+T23D8.1	C42D4.6
+W06F12.1	C42D4.6
+W08G11.4	C42D4.6
+Y18D10A.5	C42D4.6
+Y34D9B.1	C42D4.6
+Y38F1A.5	C42D4.6
+Y51H4A.3	C42D4.6
+Y71F9B.5	C42D4.6
+Y71H2AL.1	C42D4.6
+ZK856.8	C42D4.6
+ZK909.2	C42D4.6
+C52D10.6	C44H4.6
+C52D10.7	C44H4.6
+C52D10.8	C44H4.6
+C52D10.9	C44H4.6
+C54D1.6	C44H4.6
+D2045.6	C44H4.6
+F27E11.3	C44H4.6
+F35H12.3	C44H4.6
+F38E1.7	C44H4.6
+F38H4.9	C44H4.6
+F44G3.6	C44H4.6
+F46A9.4	C44H4.6
+F46A9.5	C44H4.6
+F47F2.1	C44H4.6
+F47H4.10	C44H4.6
+F48E8.5	C44H4.6
+F49E10.5	C44H4.6
+F54D10.1	C44H4.6
+F55C10.1	C44H4.6
+F56B3.12	C44H4.6
+F56E10.2	C44H4.6
+F59D6.7	C44H4.6
+K05C4.6	C44H4.6
+K08H2.1	C44H4.6
+K10B2.1	C44H4.6
+R10E11.1	C44H4.6
+R12B2.1	C44H4.6
+R12H7.3	C44H4.6
+R12H7.5	C44H4.6
+T01G9.6	C44H4.6
+T07H6.2	C44H4.6
+T23D8.1	C44H4.6
+W06F12.1	C44H4.6
+W08G11.4	C44H4.6
+Y105C5B.13	C44H4.6
+Y34D9B.1	C44H4.6
+Y37E11AR.2	C44H4.6
+Y37H2C.2	C44H4.6
+Y38F1A.5	C44H4.6
+Y47D7A.1	C44H4.6
+Y47D7A.8	C44H4.6
+Y51H4A.3	C44H4.6
+Y60A3A.18	C44H4.6
+Y71F9B.5	C44H4.6
+Y71H2AL.1	C44H4.6
+ZK287.5	C44H4.6
+ZK856.8	C44H4.6
+ZK909.2	C44H4.6
+C54D1.6	C52D10.6
+E01H11.1	C52D10.6
+F27E11.3	C52D10.6
+F35H12.3	C52D10.6
+F38E1.7	C52D10.6
+F38H4.9	C52D10.6
+F47F2.1	C52D10.6
+F48E8.5	C52D10.6
+F49E10.5	C52D10.6
+F55C10.1	C52D10.6
+F56E10.2	C52D10.6
+F59D6.7	C52D10.6
+K05C4.6	C52D10.6
+K11E8.1	C52D10.6
+R10E11.1	C52D10.6
+R12B2.1	C52D10.6
+T01G9.6	C52D10.6
+T07H6.2	C52D10.6
+T23D8.1	C52D10.6
+W06F12.1	C52D10.6
+W08G11.4	C52D10.6
+Y18D10A.5	C52D10.6
+Y34D9B.1	C52D10.6
+Y38F1A.5	C52D10.6
+Y51H4A.3	C52D10.6
+Y71F9B.5	C52D10.6
+Y71H2AL.1	C52D10.6
+ZK856.8	C52D10.6
+ZK909.2	C52D10.6
+C54D1.6	C52D10.7
+E01H11.1	C52D10.7
+F27E11.3	C52D10.7
+F35H12.3	C52D10.7
+F38E1.7	C52D10.7
+F38H4.9	C52D10.7
+F47F2.1	C52D10.7
+F48E8.5	C52D10.7
+F49E10.5	C52D10.7
+F55C10.1	C52D10.7
+F56E10.2	C52D10.7
+F59D6.7	C52D10.7
+K05C4.6	C52D10.7
+K11E8.1	C52D10.7
+R10E11.1	C52D10.7
+R12B2.1	C52D10.7
+T01G9.6	C52D10.7
+T07H6.2	C52D10.7
+T23D8.1	C52D10.7
+W06F12.1	C52D10.7
+W08G11.4	C52D10.7
+Y18D10A.5	C52D10.7
+Y34D9B.1	C52D10.7
+Y38F1A.5	C52D10.7
+Y51H4A.3	C52D10.7
+Y71F9B.5	C52D10.7
+Y71H2AL.1	C52D10.7
+ZK856.8	C52D10.7
+ZK909.2	C52D10.7
+C54D1.6	C52D10.8
+E01H11.1	C52D10.8
+F27E11.3	C52D10.8
+F35H12.3	C52D10.8
+F38E1.7	C52D10.8
+F38H4.9	C52D10.8
+F47F2.1	C52D10.8
+F48E8.5	C52D10.8
+F49E10.5	C52D10.8
+F55C10.1	C52D10.8
+F56E10.2	C52D10.8
+F59D6.7	C52D10.8
+K05C4.6	C52D10.8
+K11E8.1	C52D10.8
+R10E11.1	C52D10.8
+R12B2.1	C52D10.8
+T01G9.6	C52D10.8
+T07H6.2	C52D10.8
+T23D8.1	C52D10.8
+W06F12.1	C52D10.8
+W08G11.4	C52D10.8
+Y18D10A.5	C52D10.8
+Y34D9B.1	C52D10.8
+Y38F1A.5	C52D10.8
+Y51H4A.3	C52D10.8
+Y71F9B.5	C52D10.8
+Y71H2AL.1	C52D10.8
+ZK856.8	C52D10.8
+ZK909.2	C52D10.8
+C54D1.6	C52D10.9
+E01H11.1	C52D10.9
+F27E11.3	C52D10.9
+F35H12.3	C52D10.9
+F38E1.7	C52D10.9
+F38H4.9	C52D10.9
+F47F2.1	C52D10.9
+F48E8.5	C52D10.9
+F49E10.5	C52D10.9
+F55C10.1	C52D10.9
+F56E10.2	C52D10.9
+F59D6.7	C52D10.9
+K05C4.6	C52D10.9
+K11E8.1	C52D10.9
+R10E11.1	C52D10.9
+R12B2.1	C52D10.9
+T01G9.6	C52D10.9
+T07H6.2	C52D10.9
+T23D8.1	C52D10.9
+W06F12.1	C52D10.9
+W08G11.4	C52D10.9
+Y18D10A.5	C52D10.9
+Y34D9B.1	C52D10.9
+Y38F1A.5	C52D10.9
+Y51H4A.3	C52D10.9
+Y71F9B.5	C52D10.9
+Y71H2AL.1	C52D10.9
+ZK856.8	C52D10.9
+ZK909.2	C52D10.9
+D2045.6	C54D1.6
+E01H11.1	C54D1.6
+F27E11.3	C54D1.6
+F35H12.3	C54D1.6
+F38E1.7	C54D1.6
+F38H4.9	C54D1.6
+F44G3.6	C54D1.6
+F46A9.4	C54D1.6
+F46A9.5	C54D1.6
+F47F2.1	C54D1.6
+F47H4.10	C54D1.6
+F48E8.5	C54D1.6
+F49E10.5	C54D1.6
+F54D10.1	C54D1.6
+F55C10.1	C54D1.6
+F56B3.12	C54D1.6
+F56E10.2	C54D1.6
+F59D6.7	C54D1.6
+K08H2.1	C54D1.6
+K10B2.1	C54D1.6
+K11E8.1	C54D1.6
+R10E11.1	C54D1.6
+R12B2.1	C54D1.6
+R12H7.3	C54D1.6
+R12H7.5	C54D1.6
+T01G9.6	C54D1.6
+T07H6.2	C54D1.6
+T23D8.1	C54D1.6
+W06F12.1	C54D1.6
+W08G11.4	C54D1.6
+Y105C5B.13	C54D1.6
+Y18D10A.5	C54D1.6
+Y34D9B.1	C54D1.6
+Y37E11AR.2	C54D1.6
+Y37H2C.2	C54D1.6
+Y38F1A.5	C54D1.6
+Y47D7A.1	C54D1.6
+Y47D7A.8	C54D1.6
+Y51H4A.3	C54D1.6
+Y60A3A.18	C54D1.6
+Y71F9B.5	C54D1.6
+Y71H2AL.1	C54D1.6
+ZK287.5	C54D1.6
+ZK856.8	C54D1.6
+ZK909.2	C54D1.6
+E01H11.1	D2045.6
+F27E11.3	D2045.6
+F35H12.3	D2045.6
+F38E1.7	D2045.6
+F38H4.9	D2045.6
+F47F2.1	D2045.6
+F48E8.5	D2045.6
+F49E10.5	D2045.6
+F55C10.1	D2045.6
+F56E10.2	D2045.6
+F59D6.7	D2045.6
+K05C4.6	D2045.6
+K11E8.1	D2045.6
+R10E11.1	D2045.6
+R12B2.1	D2045.6
+T01G9.6	D2045.6
+T07H6.2	D2045.6
+T23D8.1	D2045.6
+W06F12.1	D2045.6
+W08G11.4	D2045.6
+Y18D10A.5	D2045.6
+Y34D9B.1	D2045.6
+Y38F1A.5	D2045.6
+Y51H4A.3	D2045.6
+Y71F9B.5	D2045.6
+Y71H2AL.1	D2045.6
+ZK856.8	D2045.6
+ZK909.2	D2045.6
+F27E11.3	E01H11.1
+F35H12.3	E01H11.1
+F38E1.7	E01H11.1
+F38H4.9	E01H11.1
+F44G3.6	E01H11.1
+F46A9.4	E01H11.1
+F46A9.5	E01H11.1
+F47H4.10	E01H11.1
+F48E8.5	E01H11.1
+F49E10.5	E01H11.1
+F54D10.1	E01H11.1
+F56B3.12	E01H11.1
+F56E10.2	E01H11.1
+K05C4.6	E01H11.1
+K08H2.1	E01H11.1
+K10B2.1	E01H11.1
+R10E11.1	E01H11.1
+R12B2.1	E01H11.1
+R12H7.3	E01H11.1
+R12H7.5	E01H11.1
+T01G9.6	E01H11.1
+T07H6.2	E01H11.1
+T23D8.1	E01H11.1
+W08G11.4	E01H11.1
+Y105C5B.13	E01H11.1
+Y34D9B.1	E01H11.1
+Y37E11AR.2	E01H11.1
+Y37H2C.2	E01H11.1
+Y38F1A.5	E01H11.1
+Y47D7A.1	E01H11.1
+Y47D7A.8	E01H11.1
+Y51H4A.3	E01H11.1
+Y60A3A.18	E01H11.1
+Y71F9B.5	E01H11.1
+ZK287.5	E01H11.1
+F35H12.3	F27E11.3
+F38H4.9	F27E11.3
+F44G3.6	F27E11.3
+F46A9.4	F27E11.3
+F46A9.5	F27E11.3
+F47F2.1	F27E11.3
+F47H4.10	F27E11.3
+F48E8.5	F27E11.3
+F49E10.5	F27E11.3
+F54D10.1	F27E11.3
+F55C10.1	F27E11.3
+F56B3.12	F27E11.3
+F56E10.2	F27E11.3
+F59D6.7	F27E11.3
+K05C4.6	F27E11.3
+K08H2.1	F27E11.3
+K10B2.1	F27E11.3
+K11E8.1	F27E11.3
+R10E11.1	F27E11.3
+R12B2.1	F27E11.3
+R12H7.3	F27E11.3
+R12H7.5	F27E11.3
+T01G9.6	F27E11.3
+T07H6.2	F27E11.3
+W06F12.1	F27E11.3
+W08G11.4	F27E11.3
+Y105C5B.13	F27E11.3
+Y18D10A.5	F27E11.3
+Y37E11AR.2	F27E11.3
+Y37H2C.2	F27E11.3
+Y38F1A.5	F27E11.3
+Y47D7A.1	F27E11.3
+Y47D7A.8	F27E11.3
+Y51H4A.3	F27E11.3
+Y60A3A.18	F27E11.3
+Y71H2AL.1	F27E11.3
+ZK287.5	F27E11.3
+ZK856.8	F27E11.3
+ZK909.2	F27E11.3
+F38E1.7	F35H12.3
+F38H4.9	F35H12.3
+F44G3.6	F35H12.3
+F46A9.4	F35H12.3
+F46A9.5	F35H12.3
+F47F2.1	F35H12.3
+F47H4.10	F35H12.3
+F48E8.5	F35H12.3
+F49E10.5	F35H12.3
+F54D10.1	F35H12.3
+F55C10.1	F35H12.3
+F56B3.12	F35H12.3
+F56E10.2	F35H12.3
+F59D6.7	F35H12.3
+K05C4.6	F35H12.3
+K08H2.1	F35H12.3
+K10B2.1	F35H12.3
+K11E8.1	F35H12.3
+R10E11.1	F35H12.3
+R12B2.1	F35H12.3
+R12H7.3	F35H12.3
+R12H7.5	F35H12.3
+T01G9.6	F35H12.3
+T07H6.2	F35H12.3
+T23D8.1	F35H12.3
+W06F12.1	F35H12.3
+W08G11.4	F35H12.3
+Y105C5B.13	F35H12.3
+Y18D10A.5	F35H12.3
+Y34D9B.1	F35H12.3
+Y37E11AR.2	F35H12.3
+Y37H2C.2	F35H12.3
+Y38F1A.5	F35H12.3
+Y47D7A.1	F35H12.3
+Y47D7A.8	F35H12.3
+Y51H4A.3	F35H12.3
+Y60A3A.18	F35H12.3
+Y71F9B.5	F35H12.3
+Y71H2AL.1	F35H12.3
+ZK287.5	F35H12.3
+ZK856.8	F35H12.3
+ZK909.2	F35H12.3
+F38H4.9	F38E1.7
+F44G3.6	F38E1.7
+F46A9.4	F38E1.7
+F46A9.5	F38E1.7
+F47F2.1	F38E1.7
+F47H4.10	F38E1.7
+F48E8.5	F38E1.7
+F49E10.5	F38E1.7
+F54D10.1	F38E1.7
+F55C10.1	F38E1.7
+F56B3.12	F38E1.7
+F56E10.2	F38E1.7
+F59D6.7	F38E1.7
+K05C4.6	F38E1.7
+K08H2.1	F38E1.7
+K10B2.1	F38E1.7
+K11E8.1	F38E1.7
+R10E11.1	F38E1.7
+R12B2.1	F38E1.7
+R12H7.3	F38E1.7
+R12H7.5	F38E1.7
+T01G9.6	F38E1.7
+T07H6.2	F38E1.7
+W06F12.1	F38E1.7
+W08G11.4	F38E1.7
+Y105C5B.13	F38E1.7
+Y18D10A.5	F38E1.7
+Y37E11AR.2	F38E1.7
+Y37H2C.2	F38E1.7
+Y38F1A.5	F38E1.7
+Y47D7A.1	F38E1.7
+Y47D7A.8	F38E1.7
+Y51H4A.3	F38E1.7
+Y60A3A.18	F38E1.7
+Y71H2AL.1	F38E1.7
+ZK287.5	F38E1.7
+ZK856.8	F38E1.7
+ZK909.2	F38E1.7
+F44G3.6	F38H4.9
+F46A9.4	F38H4.9
+F46A9.5	F38H4.9
+F47F2.1	F38H4.9
+F47H4.10	F38H4.9
+F49E10.5	F38H4.9
+F54D10.1	F38H4.9
+F55C10.1	F38H4.9
+F56B3.12	F38H4.9
+F56E10.2	F38H4.9
+F59D6.7	F38H4.9
+K05C4.6	F38H4.9
+K08H2.1	F38H4.9
+K10B2.1	F38H4.9
+K11E8.1	F38H4.9
+R10E11.1	F38H4.9
+R12B2.1	F38H4.9
+R12H7.3	F38H4.9
+R12H7.5	F38H4.9
+T01G9.6	F38H4.9
+T07H6.2	F38H4.9
+T23D8.1	F38H4.9
+W06F12.1	F38H4.9
+Y105C5B.13	F38H4.9
+Y18D10A.5	F38H4.9
+Y34D9B.1	F38H4.9
+Y37E11AR.2	F38H4.9
+Y37H2C.2	F38H4.9
+Y38F1A.5	F38H4.9
+Y47D7A.1	F38H4.9
+Y47D7A.8	F38H4.9
+Y51H4A.3	F38H4.9
+Y60A3A.18	F38H4.9
+Y71F9B.5	F38H4.9
+Y71H2AL.1	F38H4.9
+ZK287.5	F38H4.9
+ZK856.8	F38H4.9
+ZK909.2	F38H4.9
+F47F2.1	F44G3.6
+F48E8.5	F44G3.6
+F49E10.5	F44G3.6
+F55C10.1	F44G3.6
+F56E10.2	F44G3.6
+F59D6.7	F44G3.6
+K05C4.6	F44G3.6
+K11E8.1	F44G3.6
+R10E11.1	F44G3.6
+R12B2.1	F44G3.6
+T01G9.6	F44G3.6
+T07H6.2	F44G3.6
+T23D8.1	F44G3.6
+W06F12.1	F44G3.6
+W08G11.4	F44G3.6
+Y18D10A.5	F44G3.6
+Y34D9B.1	F44G3.6
+Y38F1A.5	F44G3.6
+Y51H4A.3	F44G3.6
+Y71F9B.5	F44G3.6
+Y71H2AL.1	F44G3.6
+ZK856.8	F44G3.6
+ZK909.2	F44G3.6
+F47F2.1	F46A9.4
+F48E8.5	F46A9.4
+F49E10.5	F46A9.4
+F55C10.1	F46A9.4
+F56E10.2	F46A9.4
+F59D6.7	F46A9.4
+K05C4.6	F46A9.4
+K11E8.1	F46A9.4
+R10E11.1	F46A9.4
+R12B2.1	F46A9.4
+T01G9.6	F46A9.4
+T07H6.2	F46A9.4
+T23D8.1	F46A9.4
+W06F12.1	F46A9.4
+W08G11.4	F46A9.4
+Y18D10A.5	F46A9.4
+Y34D9B.1	F46A9.4
+Y38F1A.5	F46A9.4
+Y51H4A.3	F46A9.4
+Y71F9B.5	F46A9.4
+Y71H2AL.1	F46A9.4
+ZK856.8	F46A9.4
+ZK909.2	F46A9.4
+F47F2.1	F46A9.5
+F48E8.5	F46A9.5
+F49E10.5	F46A9.5
+F55C10.1	F46A9.5
+F56E10.2	F46A9.5
+F59D6.7	F46A9.5
+K05C4.6	F46A9.5
+K11E8.1	F46A9.5
+R10E11.1	F46A9.5
+R12B2.1	F46A9.5
+T01G9.6	F46A9.5
+T07H6.2	F46A9.5
+T23D8.1	F46A9.5
+W06F12.1	F46A9.5
+W08G11.4	F46A9.5
+Y18D10A.5	F46A9.5
+Y34D9B.1	F46A9.5
+Y38F1A.5	F46A9.5
+Y51H4A.3	F46A9.5
+Y71F9B.5	F46A9.5
+Y71H2AL.1	F46A9.5
+ZK856.8	F46A9.5
+ZK909.2	F46A9.5
+F47H4.10	F47F2.1
+F48E8.5	F47F2.1
+F49E10.5	F47F2.1
+F54D10.1	F47F2.1
+F56B3.12	F47F2.1
+F56E10.2	F47F2.1
+K05C4.6	F47F2.1
+K08H2.1	F47F2.1
+K10B2.1	F47F2.1
+R10E11.1	F47F2.1
+R12B2.1	F47F2.1
+R12H7.3	F47F2.1
+R12H7.5	F47F2.1
+T01G9.6	F47F2.1
+T07H6.2	F47F2.1
+T23D8.1	F47F2.1
+W08G11.4	F47F2.1
+Y105C5B.13	F47F2.1
+Y18D10A.5	F47F2.1
+Y34D9B.1	F47F2.1
+Y37E11AR.2	F47F2.1
+Y37H2C.2	F47F2.1
+Y38F1A.5	F47F2.1
+Y47D7A.1	F47F2.1
+Y47D7A.8	F47F2.1
+Y51H4A.3	F47F2.1
+Y60A3A.18	F47F2.1
+Y71F9B.5	F47F2.1
+ZK287.5	F47F2.1
+F48E8.5	F47H4.10
+F49E10.5	F47H4.10
+F55C10.1	F47H4.10
+F56E10.2	F47H4.10
+F59D6.7	F47H4.10
+K05C4.6	F47H4.10
+K11E8.1	F47H4.10
+R10E11.1	F47H4.10
+R12B2.1	F47H4.10
+T01G9.6	F47H4.10
+T07H6.2	F47H4.10
+T23D8.1	F47H4.10
+W06F12.1	F47H4.10
+W08G11.4	F47H4.10
+Y18D10A.5	F47H4.10
+Y34D9B.1	F47H4.10
+Y38F1A.5	F47H4.10
+Y51H4A.3	F47H4.10
+Y71F9B.5	F47H4.10
+Y71H2AL.1	F47H4.10
+ZK856.8	F47H4.10
+ZK909.2	F47H4.10
+F49E10.5	F48E8.5
+F54D10.1	F48E8.5
+F55C10.1	F48E8.5
+F56B3.12	F48E8.5
+F56E10.2	F48E8.5
+F59D6.7	F48E8.5
+K05C4.6	F48E8.5
+K08H2.1	F48E8.5
+K10B2.1	F48E8.5
+K11E8.1	F48E8.5
+R10E11.1	F48E8.5
+R12B2.1	F48E8.5
+R12H7.3	F48E8.5
+R12H7.5	F48E8.5
+T01G9.6	F48E8.5
+T07H6.2	F48E8.5
+T23D8.1	F48E8.5
+W06F12.1	F48E8.5
+Y105C5B.13	F48E8.5
+Y18D10A.5	F48E8.5
+Y34D9B.1	F48E8.5
+Y37E11AR.2	F48E8.5
+Y37H2C.2	F48E8.5
+Y38F1A.5	F48E8.5
+Y47D7A.1	F48E8.5
+Y47D7A.8	F48E8.5
+Y51H4A.3	F48E8.5
+Y60A3A.18	F48E8.5
+Y71F9B.5	F48E8.5
+Y71H2AL.1	F48E8.5
+ZK287.5	F48E8.5
+ZK856.8	F48E8.5
+ZK909.2	F48E8.5
+F54D10.1	F49E10.5
+F55C10.1	F49E10.5
+F56B3.12	F49E10.5
+F56E10.2	F49E10.5
+F59D6.7	F49E10.5
+K05C4.6	F49E10.5
+K08H2.1	F49E10.5
+K10B2.1	F49E10.5
+K11E8.1	F49E10.5
+R10E11.1	F49E10.5
+R12B2.1	F49E10.5
+R12H7.3	F49E10.5
+R12H7.5	F49E10.5
+T01G9.6	F49E10.5
+T07H6.2	F49E10.5
+T23D8.1	F49E10.5
+W06F12.1	F49E10.5
+W08G11.4	F49E10.5
+Y105C5B.13	F49E10.5
+Y18D10A.5	F49E10.5
+Y34D9B.1	F49E10.5
+Y37E11AR.2	F49E10.5
+Y37H2C.2	F49E10.5
+Y38F1A.5	F49E10.5
+Y47D7A.1	F49E10.5
+Y47D7A.8	F49E10.5
+Y51H4A.3	F49E10.5
+Y60A3A.18	F49E10.5
+Y71F9B.5	F49E10.5
+Y71H2AL.1	F49E10.5
+ZK287.5	F49E10.5
+ZK856.8	F49E10.5
+ZK909.2	F49E10.5
+F55C10.1	F54D10.1
+F56E10.2	F54D10.1
+F59D6.7	F54D10.1
+K05C4.6	F54D10.1
+K11E8.1	F54D10.1
+R10E11.1	F54D10.1
+R12B2.1	F54D10.1
+T01G9.6	F54D10.1
+T07H6.2	F54D10.1
+T23D8.1	F54D10.1
+W06F12.1	F54D10.1
+W08G11.4	F54D10.1
+Y18D10A.5	F54D10.1
+Y34D9B.1	F54D10.1
+Y38F1A.5	F54D10.1
+Y51H4A.3	F54D10.1
+Y71F9B.5	F54D10.1
+Y71H2AL.1	F54D10.1
+ZK856.8	F54D10.1
+ZK909.2	F54D10.1
+F56B3.12	F55C10.1
+F56E10.2	F55C10.1
+K05C4.6	F55C10.1
+K08H2.1	F55C10.1
+K10B2.1	F55C10.1
+R10E11.1	F55C10.1
+R12B2.1	F55C10.1
+R12H7.3	F55C10.1
+R12H7.5	F55C10.1
+T01G9.6	F55C10.1
+T07H6.2	F55C10.1
+T23D8.1	F55C10.1
+W08G11.4	F55C10.1
+Y105C5B.13	F55C10.1
+Y18D10A.5	F55C10.1
+Y34D9B.1	F55C10.1
+Y37E11AR.2	F55C10.1
+Y37H2C.2	F55C10.1
+Y38F1A.5	F55C10.1
+Y47D7A.1	F55C10.1
+Y47D7A.8	F55C10.1
+Y51H4A.3	F55C10.1
+Y60A3A.18	F55C10.1
+Y71F9B.5	F55C10.1
+ZK287.5	F55C10.1
+F56E10.2	F56B3.12
+F59D6.7	F56B3.12
+K05C4.6	F56B3.12
+K11E8.1	F56B3.12
+R10E11.1	F56B3.12
+R12B2.1	F56B3.12
+T01G9.6	F56B3.12
+T07H6.2	F56B3.12
+T23D8.1	F56B3.12
+W06F12.1	F56B3.12
+W08G11.4	F56B3.12
+Y18D10A.5	F56B3.12
+Y34D9B.1	F56B3.12
+Y38F1A.5	F56B3.12
+Y51H4A.3	F56B3.12
+Y71F9B.5	F56B3.12
+Y71H2AL.1	F56B3.12
+ZK856.8	F56B3.12
+ZK909.2	F56B3.12
+F59D6.7	F56E10.2
+K05C4.6	F56E10.2
+K08H2.1	F56E10.2
+K10B2.1	F56E10.2
+K11E8.1	F56E10.2
+R10E11.1	F56E10.2
+R12B2.1	F56E10.2
+R12H7.3	F56E10.2
+R12H7.5	F56E10.2
+T01G9.6	F56E10.2
+T07H6.2	F56E10.2
+T23D8.1	F56E10.2
+W06F12.1	F56E10.2
+W08G11.4	F56E10.2
+Y105C5B.13	F56E10.2
+Y18D10A.5	F56E10.2
+Y34D9B.1	F56E10.2
+Y37E11AR.2	F56E10.2
+Y37H2C.2	F56E10.2
+Y38F1A.5	F56E10.2
+Y47D7A.1	F56E10.2
+Y47D7A.8	F56E10.2
+Y51H4A.3	F56E10.2
+Y60A3A.18	F56E10.2
+Y71F9B.5	F56E10.2
+Y71H2AL.1	F56E10.2
+ZK287.5	F56E10.2
+ZK856.8	F56E10.2
+ZK909.2	F56E10.2
+K05C4.6	F59D6.7
+K08H2.1	F59D6.7
+K10B2.1	F59D6.7
+R10E11.1	F59D6.7
+R12B2.1	F59D6.7
+R12H7.3	F59D6.7
+R12H7.5	F59D6.7
+T01G9.6	F59D6.7
+T07H6.2	F59D6.7
+T23D8.1	F59D6.7
+W08G11.4	F59D6.7
+Y105C5B.13	F59D6.7
+Y18D10A.5	F59D6.7
+Y34D9B.1	F59D6.7
+Y37E11AR.2	F59D6.7
+Y37H2C.2	F59D6.7
+Y38F1A.5	F59D6.7
+Y47D7A.1	F59D6.7
+Y47D7A.8	F59D6.7
+Y51H4A.3	F59D6.7
+Y60A3A.18	F59D6.7
+Y71F9B.5	F59D6.7
+ZK287.5	F59D6.7
+K08H2.1	K05C4.6
+K10B2.1	K05C4.6
+K11E8.1	K05C4.6
+R10E11.1	K05C4.6
+R12B2.1	K05C4.6
+R12H7.3	K05C4.6
+R12H7.5	K05C4.6
+T01G9.6	K05C4.6
+T07H6.2	K05C4.6
+T23D8.1	K05C4.6
+W06F12.1	K05C4.6
+W08G11.4	K05C4.6
+Y105C5B.13	K05C4.6
+Y18D10A.5	K05C4.6
+Y34D9B.1	K05C4.6
+Y37E11AR.2	K05C4.6
+Y37H2C.2	K05C4.6
+Y38F1A.5	K05C4.6
+Y47D7A.1	K05C4.6
+Y47D7A.8	K05C4.6
+Y51H4A.3	K05C4.6
+Y60A3A.18	K05C4.6
+Y71F9B.5	K05C4.6
+Y71H2AL.1	K05C4.6
+ZK287.5	K05C4.6
+ZK856.8	K05C4.6
+ZK909.2	K05C4.6
+K11E8.1	K08H2.1
+R10E11.1	K08H2.1
+R12B2.1	K08H2.1
+T01G9.6	K08H2.1
+T07H6.2	K08H2.1
+T23D8.1	K08H2.1
+W06F12.1	K08H2.1
+W08G11.4	K08H2.1
+Y18D10A.5	K08H2.1
+Y34D9B.1	K08H2.1
+Y38F1A.5	K08H2.1
+Y51H4A.3	K08H2.1
+Y71F9B.5	K08H2.1
+Y71H2AL.1	K08H2.1
+ZK856.8	K08H2.1
+ZK909.2	K08H2.1
+K11E8.1	K10B2.1
+R10E11.1	K10B2.1
+R12B2.1	K10B2.1
+T01G9.6	K10B2.1
+T07H6.2	K10B2.1
+T23D8.1	K10B2.1
+W06F12.1	K10B2.1
+W08G11.4	K10B2.1
+Y18D10A.5	K10B2.1
+Y34D9B.1	K10B2.1
+Y38F1A.5	K10B2.1
+Y51H4A.3	K10B2.1
+Y71F9B.5	K10B2.1
+Y71H2AL.1	K10B2.1
+ZK856.8	K10B2.1
+ZK909.2	K10B2.1
+R10E11.1	K11E8.1
+R12B2.1	K11E8.1
+R12H7.3	K11E8.1
+R12H7.5	K11E8.1
+T01G9.6	K11E8.1
+T07H6.2	K11E8.1
+T23D8.1	K11E8.1
+W06F12.1	K11E8.1
+W08G11.4	K11E8.1
+Y105C5B.13	K11E8.1
+Y34D9B.1	K11E8.1
+Y37E11AR.2	K11E8.1
+Y37H2C.2	K11E8.1
+Y38F1A.5	K11E8.1
+Y47D7A.1	K11E8.1
+Y47D7A.8	K11E8.1
+Y51H4A.3	K11E8.1
+Y60A3A.18	K11E8.1
+Y71F9B.5	K11E8.1
+ZK287.5	K11E8.1
+R12B2.1	R10E11.1
+R12H7.3	R10E11.1
+R12H7.5	R10E11.1
+T01G9.6	R10E11.1
+T07H6.2	R10E11.1
+T23D8.1	R10E11.1
+W06F12.1	R10E11.1
+W08G11.4	R10E11.1
+Y105C5B.13	R10E11.1
+Y18D10A.5	R10E11.1
+Y34D9B.1	R10E11.1
+Y37E11AR.2	R10E11.1
+Y37H2C.2	R10E11.1
+Y38F1A.5	R10E11.1
+Y47D7A.1	R10E11.1
+Y47D7A.8	R10E11.1
+Y51H4A.3	R10E11.1
+Y60A3A.18	R10E11.1
+Y71F9B.5	R10E11.1
+Y71H2AL.1	R10E11.1
+ZK287.5	R10E11.1
+ZK856.8	R10E11.1
+ZK909.2	R10E11.1
+R12H7.3	R12B2.1
+R12H7.5	R12B2.1
+T01G9.6	R12B2.1
+T07H6.2	R12B2.1
+T23D8.1	R12B2.1
+W06F12.1	R12B2.1
+W08G11.4	R12B2.1
+Y105C5B.13	R12B2.1
+Y18D10A.5	R12B2.1
+Y34D9B.1	R12B2.1
+Y37E11AR.2	R12B2.1
+Y37H2C.2	R12B2.1
+Y38F1A.5	R12B2.1
+Y47D7A.1	R12B2.1
+Y47D7A.8	R12B2.1
+Y51H4A.3	R12B2.1
+Y60A3A.18	R12B2.1
+Y71F9B.5	R12B2.1
+Y71H2AL.1	R12B2.1
+ZK287.5	R12B2.1
+ZK856.8	R12B2.1
+ZK909.2	R12B2.1
+T01G9.6	R12H7.3
+T07H6.2	R12H7.3
+T23D8.1	R12H7.3
+W06F12.1	R12H7.3
+W08G11.4	R12H7.3
+Y18D10A.5	R12H7.3
+Y34D9B.1	R12H7.3
+Y38F1A.5	R12H7.3
+Y51H4A.3	R12H7.3
+Y71F9B.5	R12H7.3
+Y71H2AL.1	R12H7.3
+ZK856.8	R12H7.3
+ZK909.2	R12H7.3
+T01G9.6	R12H7.5
+T07H6.2	R12H7.5
+T23D8.1	R12H7.5
+W06F12.1	R12H7.5
+W08G11.4	R12H7.5
+Y18D10A.5	R12H7.5
+Y34D9B.1	R12H7.5
+Y38F1A.5	R12H7.5
+Y51H4A.3	R12H7.5
+Y71F9B.5	R12H7.5
+Y71H2AL.1	R12H7.5
+ZK856.8	R12H7.5
+ZK909.2	R12H7.5
+T07H6.2	T01G9.6
+T23D8.1	T01G9.6
+W06F12.1	T01G9.6
+W08G11.4	T01G9.6
+Y105C5B.13	T01G9.6
+Y18D10A.5	T01G9.6
+Y34D9B.1	T01G9.6
+Y37E11AR.2	T01G9.6
+Y37H2C.2	T01G9.6
+Y38F1A.5	T01G9.6
+Y47D7A.1	T01G9.6
+Y47D7A.8	T01G9.6
+Y51H4A.3	T01G9.6
+Y60A3A.18	T01G9.6
+Y71F9B.5	T01G9.6
+Y71H2AL.1	T01G9.6
+ZK287.5	T01G9.6
+ZK856.8	T01G9.6
+ZK909.2	T01G9.6
+T23D8.1	T07H6.2
+W06F12.1	T07H6.2
+W08G11.4	T07H6.2
+Y105C5B.13	T07H6.2
+Y18D10A.5	T07H6.2
+Y34D9B.1	T07H6.2
+Y37E11AR.2	T07H6.2
+Y37H2C.2	T07H6.2
+Y38F1A.5	T07H6.2
+Y47D7A.1	T07H6.2
+Y47D7A.8	T07H6.2
+Y51H4A.3	T07H6.2
+Y60A3A.18	T07H6.2
+Y71F9B.5	T07H6.2
+Y71H2AL.1	T07H6.2
+ZK287.5	T07H6.2
+ZK856.8	T07H6.2
+ZK909.2	T07H6.2
+W06F12.1	T23D8.1
+W08G11.4	T23D8.1
+Y105C5B.13	T23D8.1
+Y18D10A.5	T23D8.1
+Y37E11AR.2	T23D8.1
+Y37H2C.2	T23D8.1
+Y38F1A.5	T23D8.1
+Y47D7A.1	T23D8.1
+Y47D7A.8	T23D8.1
+Y51H4A.3	T23D8.1
+Y60A3A.18	T23D8.1
+Y71H2AL.1	T23D8.1
+ZK287.5	T23D8.1
+ZK856.8	T23D8.1
+ZK909.2	T23D8.1
+W08G11.4	W06F12.1
+Y105C5B.13	W06F12.1
+Y18D10A.5	W06F12.1
+Y34D9B.1	W06F12.1
+Y37E11AR.2	W06F12.1
+Y37H2C.2	W06F12.1
+Y38F1A.5	W06F12.1
+Y47D7A.1	W06F12.1
+Y47D7A.8	W06F12.1
+Y51H4A.3	W06F12.1
+Y60A3A.18	W06F12.1
+Y71F9B.5	W06F12.1
+ZK287.5	W06F12.1
+Y105C5B.13	W08G11.4
+Y18D10A.5	W08G11.4
+Y34D9B.1	W08G11.4
+Y37E11AR.2	W08G11.4
+Y37H2C.2	W08G11.4
+Y38F1A.5	W08G11.4
+Y47D7A.1	W08G11.4
+Y47D7A.8	W08G11.4
+Y51H4A.3	W08G11.4
+Y60A3A.18	W08G11.4
+Y71F9B.5	W08G11.4
+Y71H2AL.1	W08G11.4
+ZK287.5	W08G11.4
+ZK856.8	W08G11.4
+ZK909.2	W08G11.4
+Y18D10A.5	Y105C5B.13
+Y34D9B.1	Y105C5B.13
+Y38F1A.5	Y105C5B.13
+Y51H4A.3	Y105C5B.13
+Y71F9B.5	Y105C5B.13
+Y71H2AL.1	Y105C5B.13
+ZK856.8	Y105C5B.13
+ZK909.2	Y105C5B.13
+Y34D9B.1	Y18D10A.5
+Y37E11AR.2	Y18D10A.5
+Y37H2C.2	Y18D10A.5
+Y38F1A.5	Y18D10A.5
+Y47D7A.1	Y18D10A.5
+Y47D7A.8	Y18D10A.5
+Y51H4A.3	Y18D10A.5
+Y60A3A.18	Y18D10A.5
+Y71F9B.5	Y18D10A.5
+Y71H2AL.1	Y18D10A.5
+ZK287.5	Y18D10A.5
+ZK856.8	Y18D10A.5
+ZK909.2	Y18D10A.5
+Y37E11AR.2	Y34D9B.1
+Y37H2C.2	Y34D9B.1
+Y38F1A.5	Y34D9B.1
+Y47D7A.1	Y34D9B.1
+Y47D7A.8	Y34D9B.1
+Y51H4A.3	Y34D9B.1
+Y60A3A.18	Y34D9B.1
+Y71H2AL.1	Y34D9B.1
+ZK287.5	Y34D9B.1
+ZK856.8	Y34D9B.1
+ZK909.2	Y34D9B.1
+Y38F1A.5	Y37E11AR.2
+Y51H4A.3	Y37E11AR.2
+Y71F9B.5	Y37E11AR.2
+Y71H2AL.1	Y37E11AR.2
+ZK856.8	Y37E11AR.2
+ZK909.2	Y37E11AR.2
+Y38F1A.5	Y37H2C.2
+Y51H4A.3	Y37H2C.2
+Y71F9B.5	Y37H2C.2
+Y71H2AL.1	Y37H2C.2
+ZK856.8	Y37H2C.2
+ZK909.2	Y37H2C.2
+Y47D7A.1	Y38F1A.5
+Y47D7A.8	Y38F1A.5
+Y51H4A.3	Y38F1A.5
+Y60A3A.18	Y38F1A.5
+Y71F9B.5	Y38F1A.5
+Y71H2AL.1	Y38F1A.5
+ZK287.5	Y38F1A.5
+ZK856.8	Y38F1A.5
+ZK909.2	Y38F1A.5
+Y51H4A.3	Y47D7A.1
+Y71F9B.5	Y47D7A.1
+Y71H2AL.1	Y47D7A.1
+ZK856.8	Y47D7A.1
+ZK909.2	Y47D7A.1
+Y51H4A.3	Y47D7A.8
+Y71F9B.5	Y47D7A.8
+Y71H2AL.1	Y47D7A.8
+ZK856.8	Y47D7A.8
+ZK909.2	Y47D7A.8
+Y60A3A.18	Y51H4A.3
+Y71F9B.5	Y51H4A.3
+Y71H2AL.1	Y51H4A.3
+ZK287.5	Y51H4A.3
+ZK856.8	Y51H4A.3
+ZK909.2	Y51H4A.3
+Y71F9B.5	Y60A3A.18
+Y71H2AL.1	Y60A3A.18
+ZK856.8	Y60A3A.18
+ZK909.2	Y60A3A.18
+Y71H2AL.1	Y71F9B.5
+ZK287.5	Y71F9B.5
+ZK856.8	Y71F9B.5
+ZK909.2	Y71F9B.5
+ZK287.5	Y71H2AL.1
+ZK856.8	ZK287.5
+ZK909.2	ZK287.5
+B0464.4	B0414.5
+C01G5.2	B0414.5
+C14F5.5	B0414.5
+D2030.6	B0414.5
+F43C1.2	B0414.5
+T12G3.8	B0414.5
+T28F12.3	B0414.5
+Y54E10BL.6	B0414.5
+Y73B6BL.6	B0414.5
+ZK1067.1	B0414.5
+ZK792.6	B0414.5
+C01G5.2	B0464.4
+C14F5.5	B0464.4
+D2030.6	B0464.4
+F43C1.2	B0464.4
+T12G3.8	B0464.4
+T28F12.3	B0464.4
+Y54E10BL.6	B0464.4
+Y73B6BL.6	B0464.4
+ZK1067.1	B0464.4
+ZK792.6	B0464.4
+C14F5.5	C01G5.2
+D2030.6	C01G5.2
+F43C1.2	C01G5.2
+T12G3.8	C01G5.2
+T28F12.3	C01G5.2
+Y54E10BL.6	C01G5.2
+Y73B6BL.6	C01G5.2
+ZK1067.1	C01G5.2
+ZK792.6	C01G5.2
+D2030.6	C14F5.5
+T12G3.8	C14F5.5
+Y73B6BL.6	C14F5.5
+F43C1.2	D2030.6
+T12G3.8	D2030.6
+T28F12.3	D2030.6
+Y54E10BL.6	D2030.6
+Y73B6BL.6	D2030.6
+ZK1067.1	D2030.6
+ZK792.6	D2030.6
+T12G3.8	F43C1.2
+Y73B6BL.6	F43C1.2
+T28F12.3	T12G3.8
+Y54E10BL.6	T12G3.8
+Y73B6BL.6	T12G3.8
+ZK1067.1	T12G3.8
+ZK792.6	T12G3.8
+Y73B6BL.6	T28F12.3
+Y73B6BL.6	Y54E10BL.6
+ZK1067.1	Y73B6BL.6
+ZK792.6	Y73B6BL.6
+C18E3.8	C08B11.2
+C34F11.9	C08B11.2
+F35H12.3	C08B11.2
+F49E10.5	C08B11.2
+F55F8.4	C08B11.2
+K08B4.1	C08B11.2
+R10E11.1	C08B11.2
+T03D8.1	C08B11.2
+T27F2.1	C08B11.2
+T28D6.9	C08B11.2
+VF36H2L.1	C08B11.2
+Y47G6A.6	C08B11.2
+ZC434.6	C08B11.2
+ZK154.7	C08B11.2
+ZK524.1	C08B11.2
+C34F11.9	C18E3.8
+C53A5.3	C18E3.8
+F49E10.5	C18E3.8
+F55F8.4	C18E3.8
+K08B4.1	C18E3.8
+R06C1.1	C18E3.8
+R10E11.1	C18E3.8
+T03D8.1	C18E3.8
+T27F2.1	C18E3.8
+T28D6.9	C18E3.8
+VF36H2L.1	C18E3.8
+Y47G6A.6	C18E3.8
+ZC434.6	C18E3.8
+ZK154.7	C18E3.8
+C53A5.3	C34F11.9
+F55F8.4	C34F11.9
+K08B4.1	C34F11.9
+R06C1.1	C34F11.9
+T03D8.1	C34F11.9
+T27F2.1	C34F11.9
+T28D6.9	C34F11.9
+VF36H2L.1	C34F11.9
+Y47G6A.6	C34F11.9
+ZC434.6	C34F11.9
+ZK154.7	C34F11.9
+ZK524.1	C34F11.9
+F35H12.3	C53A5.3
+F49E10.5	C53A5.3
+F55F8.4	C53A5.3
+K08B4.1	C53A5.3
+R10E11.1	C53A5.3
+T03D8.1	C53A5.3
+T27F2.1	C53A5.3
+T28D6.9	C53A5.3
+VF36H2L.1	C53A5.3
+Y47G6A.6	C53A5.3
+ZC434.6	C53A5.3
+ZK154.7	C53A5.3
+ZK524.1	C53A5.3
+F55F8.4	F35H12.3
+K08B4.1	F35H12.3
+R06C1.1	F35H12.3
+T03D8.1	F35H12.3
+T27F2.1	F35H12.3
+T28D6.9	F35H12.3
+VF36H2L.1	F35H12.3
+Y47G6A.6	F35H12.3
+ZC434.6	F35H12.3
+ZK154.7	F35H12.3
+F55F8.4	F49E10.5
+K08B4.1	F49E10.5
+R06C1.1	F49E10.5
+T03D8.1	F49E10.5
+T27F2.1	F49E10.5
+T28D6.9	F49E10.5
+VF36H2L.1	F49E10.5
+Y47G6A.6	F49E10.5
+ZC434.6	F49E10.5
+ZK154.7	F49E10.5
+ZK524.1	F49E10.5
+K08B4.1	F55F8.4
+R06C1.1	F55F8.4
+R10E11.1	F55F8.4
+T03D8.1	F55F8.4
+T27F2.1	F55F8.4
+T28D6.9	F55F8.4
+VF36H2L.1	F55F8.4
+Y47G6A.6	F55F8.4
+ZC434.6	F55F8.4
+ZK154.7	F55F8.4
+ZK524.1	F55F8.4
+R06C1.1	K08B4.1
+R10E11.1	K08B4.1
+T03D8.1	K08B4.1
+T27F2.1	K08B4.1
+T28D6.9	K08B4.1
+VF36H2L.1	K08B4.1
+Y47G6A.6	K08B4.1
+ZC434.6	K08B4.1
+ZK154.7	K08B4.1
+ZK524.1	K08B4.1
+R10E11.1	R06C1.1
+T03D8.1	R06C1.1
+T27F2.1	R06C1.1
+T28D6.9	R06C1.1
+VF36H2L.1	R06C1.1
+Y47G6A.6	R06C1.1
+ZC434.6	R06C1.1
+ZK154.7	R06C1.1
+ZK524.1	R06C1.1
+T03D8.1	R10E11.1
+T27F2.1	R10E11.1
+T28D6.9	R10E11.1
+VF36H2L.1	R10E11.1
+Y47G6A.6	R10E11.1
+ZC434.6	R10E11.1
+ZK154.7	R10E11.1
+ZK524.1	R10E11.1
+T27F2.1	T03D8.1
+T28D6.9	T03D8.1
+VF36H2L.1	T03D8.1
+Y47G6A.6	T03D8.1
+ZC434.6	T03D8.1
+ZK154.7	T03D8.1
+ZK524.1	T03D8.1
+T28D6.9	T27F2.1
+VF36H2L.1	T27F2.1
+Y47G6A.6	T27F2.1
+ZC434.6	T27F2.1
+ZK154.7	T27F2.1
+ZK524.1	T27F2.1
+VF36H2L.1	T28D6.9
+Y47G6A.6	T28D6.9
+ZC434.6	T28D6.9
+ZK154.7	T28D6.9
+ZK524.1	T28D6.9
+Y47G6A.6	VF36H2L.1
+ZC434.6	VF36H2L.1
+ZK154.7	VF36H2L.1
+ZK524.1	VF36H2L.1
+ZC434.6	Y47G6A.6
+ZK154.7	Y47G6A.6
+ZK524.1	Y47G6A.6
+ZK154.7	ZC434.6
+ZK524.1	ZC434.6
+ZK524.1	ZK154.7
+E02H4.6	C03C10.1
+F16B12.5	C03C10.1
+F21H12.4	C03C10.1
+F29D11.1	C03C10.1
+K04C1.5	C03C10.1
+T25F10.2	C03C10.1
+Y106G6E.6	C03C10.1
+ZK675.1	C03C10.1
+E02H4.6	C44H4.6
+F16B12.5	C44H4.6
+F21H12.4	C44H4.6
+F29D11.1	C44H4.6
+K04C1.5	C44H4.6
+T25F10.2	C44H4.6
+Y106G6E.6	C44H4.6
+ZK675.1	C44H4.6
+F16B12.5	E02H4.6
+F21H12.4	E02H4.6
+F29D11.1	E02H4.6
+F38E1.7	E02H4.6
+F47F2.1	E02H4.6
+K04C1.5	E02H4.6
+K10B2.1	E02H4.6
+T25F10.2	E02H4.6
+Y106G6E.6	E02H4.6
+Y18D10A.5	E02H4.6
+ZK675.1	E02H4.6
+ZK909.2	E02H4.6
+F21H12.4	F16B12.5
+F29D11.1	F16B12.5
+F38E1.7	F16B12.5
+F47F2.1	F16B12.5
+K04C1.5	F16B12.5
+K10B2.1	F16B12.5
+T25F10.2	F16B12.5
+Y106G6E.6	F16B12.5
+Y18D10A.5	F16B12.5
+ZK675.1	F16B12.5
+ZK909.2	F16B12.5
+F29D11.1	F21H12.4
+F38E1.7	F21H12.4
+F47F2.1	F21H12.4
+K04C1.5	F21H12.4
+K10B2.1	F21H12.4
+T25F10.2	F21H12.4
+Y106G6E.6	F21H12.4
+Y18D10A.5	F21H12.4
+ZK675.1	F21H12.4
+ZK909.2	F21H12.4
+F38E1.7	F29D11.1
+F47F2.1	F29D11.1
+K04C1.5	F29D11.1
+K10B2.1	F29D11.1
+T25F10.2	F29D11.1
+Y106G6E.6	F29D11.1
+Y18D10A.5	F29D11.1
+ZK675.1	F29D11.1
+ZK909.2	F29D11.1
+K04C1.5	F38E1.7
+T25F10.2	F38E1.7
+Y106G6E.6	F38E1.7
+ZK675.1	F38E1.7
+K04C1.5	F47F2.1
+T25F10.2	F47F2.1
+Y106G6E.6	F47F2.1
+ZK675.1	F47F2.1
+K10B2.1	K04C1.5
+T25F10.2	K04C1.5
+Y106G6E.6	K04C1.5
+Y18D10A.5	K04C1.5
+ZK675.1	K04C1.5
+ZK909.2	K04C1.5
+T25F10.2	K10B2.1
+Y106G6E.6	K10B2.1
+ZK675.1	K10B2.1
+Y106G6E.6	T25F10.2
+Y18D10A.5	T25F10.2
+ZK675.1	T25F10.2
+ZK909.2	T25F10.2
+Y18D10A.5	Y106G6E.6
+ZK675.1	Y106G6E.6
+ZK909.2	Y106G6E.6
+ZK675.1	Y18D10A.5
+ZK909.2	ZK675.1
+C32F10.2	C06A8.4
+F43C1.2	C06A8.4
+R04A9.7	C06A8.4
+T25F10.2	C06A8.4
+Y47D3A.16	C06A8.4
+C32F10.2	C10H11.9
+F43C1.2	C10H11.9
+R04A9.7	C10H11.9
+T25F10.2	C10H11.9
+Y47D3A.16	C10H11.9
+C42D4.6	C32F10.2
+C52D10.6	C32F10.2
+C52D10.7	C32F10.2
+C52D10.8	C32F10.2
+C52D10.9	C32F10.2
+D2045.6	C32F10.2
+F38H4.9	C32F10.2
+F43C1.2	C32F10.2
+F44G3.6	C32F10.2
+F46A9.4	C32F10.2
+F46A9.5	C32F10.2
+F47H4.10	C32F10.2
+F48E8.5	C32F10.2
+F54D10.1	C32F10.2
+F56B3.12	C32F10.2
+K08H2.1	C32F10.2
+R04A9.7	C32F10.2
+R10E11.1	C32F10.2
+R12B2.1	C32F10.2
+R12H7.3	C32F10.2
+R12H7.5	C32F10.2
+T25F10.2	C32F10.2
+Y105C5B.13	C32F10.2
+Y37H2C.2	C32F10.2
+Y47D3A.16	C32F10.2
+Y47D7A.1	C32F10.2
+Y47D7A.8	C32F10.2
+Y51H4A.3	C32F10.2
+Y60A3A.18	C32F10.2
+ZK287.5	C32F10.2
+F43C1.2	C42D4.6
+R04A9.7	C42D4.6
+T25F10.2	C42D4.6
+Y47D3A.16	C42D4.6
+F43C1.2	C52D10.6
+R04A9.7	C52D10.6
+T25F10.2	C52D10.6
+Y47D3A.16	C52D10.6
+F43C1.2	C52D10.7
+R04A9.7	C52D10.7
+T25F10.2	C52D10.7
+Y47D3A.16	C52D10.7
+F43C1.2	C52D10.8
+R04A9.7	C52D10.8
+T25F10.2	C52D10.8
+Y47D3A.16	C52D10.8
+F43C1.2	C52D10.9
+R04A9.7	C52D10.9
+T25F10.2	C52D10.9
+Y47D3A.16	C52D10.9
+F43C1.2	D2045.6
+R04A9.7	D2045.6
+T25F10.2	D2045.6
+Y47D3A.16	D2045.6
+F43C1.2	F38H4.9
+R04A9.7	F38H4.9
+T25F10.2	F38H4.9
+Y47D3A.16	F38H4.9
+F44G3.6	F43C1.2
+F46A9.4	F43C1.2
+F46A9.5	F43C1.2
+F47H4.10	F43C1.2
+F48E8.5	F43C1.2
+F54D10.1	F43C1.2
+F56B3.12	F43C1.2
+K08H2.1	F43C1.2
+R10E11.1	F43C1.2
+R12B2.1	F43C1.2
+R12H7.3	F43C1.2
+R12H7.5	F43C1.2
+T25F10.2	F43C1.2
+Y105C5B.13	F43C1.2
+Y37H2C.2	F43C1.2
+Y47D7A.1	F43C1.2
+Y47D7A.8	F43C1.2
+Y51H4A.3	F43C1.2
+Y60A3A.18	F43C1.2
+ZK287.5	F43C1.2
+R04A9.7	F44G3.6
+T25F10.2	F44G3.6
+Y47D3A.16	F44G3.6
+R04A9.7	F46A9.4
+T25F10.2	F46A9.4
+Y47D3A.16	F46A9.4
+R04A9.7	F46A9.5
+T25F10.2	F46A9.5
+Y47D3A.16	F46A9.5
+R04A9.7	F47H4.10
+T25F10.2	F47H4.10
+Y47D3A.16	F47H4.10
+R04A9.7	F48E8.5
+T25F10.2	F48E8.5
+Y47D3A.16	F48E8.5
+R04A9.7	F54D10.1
+T25F10.2	F54D10.1
+Y47D3A.16	F54D10.1
+R04A9.7	F56B3.12
+T25F10.2	F56B3.12
+Y47D3A.16	F56B3.12
+R04A9.7	K08H2.1
+T25F10.2	K08H2.1
+Y47D3A.16	K08H2.1
+R10E11.1	R04A9.7
+R12B2.1	R04A9.7
+R12H7.3	R04A9.7
+R12H7.5	R04A9.7
+T25F10.2	R04A9.7
+Y105C5B.13	R04A9.7
+Y37H2C.2	R04A9.7
+Y47D7A.1	R04A9.7
+Y47D7A.8	R04A9.7
+Y51H4A.3	R04A9.7
+Y60A3A.18	R04A9.7
+ZK287.5	R04A9.7
+T25F10.2	R10E11.1
+Y47D3A.16	R10E11.1
+T25F10.2	R12B2.1
+Y47D3A.16	R12B2.1
+T25F10.2	R12H7.3
+Y47D3A.16	R12H7.3
+T25F10.2	R12H7.5
+Y47D3A.16	R12H7.5
+Y105C5B.13	T25F10.2
+Y37H2C.2	T25F10.2
+Y47D3A.16	T25F10.2
+Y47D7A.1	T25F10.2
+Y47D7A.8	T25F10.2
+Y51H4A.3	T25F10.2
+Y60A3A.18	T25F10.2
+ZK287.5	T25F10.2
+Y47D3A.16	Y105C5B.13
+Y47D3A.16	Y37H2C.2
+Y47D7A.1	Y47D3A.16
+Y47D7A.8	Y47D3A.16
+Y51H4A.3	Y47D3A.16
+Y60A3A.18	Y47D3A.16
+ZK287.5	Y47D3A.16
+F01G12.5	C54D1.5
+F41G3.12	C54D1.5
+F57C7.3	C54D1.5
+K08C7.3	C54D1.5
+T22A3.8	C54D1.5
+W03F8.5	C54D1.5
+ZK1058.2	C54D1.5
+F41G3.12	F01G12.5
+F57C7.3	F01G12.5
+K08C7.3	F01G12.5
+T22A3.8	F01G12.5
+W03F8.5	F01G12.5
+ZK1058.2	F01G12.5
+F57C7.3	F41G3.12
+K08C7.3	F41G3.12
+T22A3.8	F41G3.12
+W03F8.5	F41G3.12
+ZK1058.2	F41G3.12
+K08C7.3	F57C7.3
+T22A3.8	F57C7.3
+W03F8.5	F57C7.3
+ZK1058.2	F57C7.3
+T22A3.8	K08C7.3
+W03F8.5	K08C7.3
+ZK1058.2	K08C7.3
+W03F8.5	T22A3.8
+ZK1058.2	T22A3.8
+ZK1058.2	W03F8.5
+C34G6.7	B0334.8
+F59G1.5	B0334.8
+R10E11.1	B0334.8
+W10D5.3	B0334.8
+Y38F1A.5	B0334.8
+C34G6.7	C12D8.10
+F59G1.5	C12D8.10
+R10E11.1	C12D8.10
+W10D5.3	C12D8.10
+Y38F1A.5	C12D8.10
+C34G6.7	C14F5.5
+F59G1.5	C14F5.5
+R10E11.1	C14F5.5
+W10D5.3	C14F5.5
+Y38F1A.5	C14F5.5
+F28H6.1	C34G6.7
+F59G1.5	C34G6.7
+R10E11.1	C34G6.7
+T28F12.3	C34G6.7
+W10D5.3	C34G6.7
+Y110A7A.10	C34G6.7
+Y38F1A.5	C34G6.7
+Y51H4A.17	C34G6.7
+F59G1.5	F28H6.1
+R10E11.1	F28H6.1
+W10D5.3	F28H6.1
+Y38F1A.5	F28H6.1
+M02A10.3	F59G1.5
+R10E11.1	F59G1.5
+T28F12.3	F59G1.5
+W10D5.3	F59G1.5
+Y110A7A.10	F59G1.5
+Y38F1A.5	F59G1.5
+Y51H4A.17	F59G1.5
+R10E11.1	M02A10.3
+Y38F1A.5	M02A10.3
+T28F12.3	R10E11.1
+W10D5.3	R10E11.1
+Y110A7A.10	R10E11.1
+Y51H4A.17	R10E11.1
+W10D5.3	T28F12.3
+Y38F1A.5	T28F12.3
+Y110A7A.10	W10D5.3
+Y38F1A.5	W10D5.3
+Y51H4A.17	W10D5.3
+Y38F1A.5	Y110A7A.10
+Y51H4A.17	Y38F1A.5
+C02F4.2	B0334.8
+C35B8.2	B0334.8
+F55C10.1	B0334.8
+F59D6.7	B0334.8
+Y71H2AL.1	B0334.8
+ZK856.8	B0334.8
+C35B8.2	C02F4.2
+F59G1.5	C02F4.2
+Y110A7A.10	C02F4.2
+C35B8.2	C09B8.7
+F59G1.5	C09B8.7
+C35B8.2	C14F5.5
+E01H11.1	C35B8.2
+F43C1.2	C35B8.2
+F55C10.1	C35B8.2
+F59D6.7	C35B8.2
+F59G1.5	C35B8.2
+T01E8.3	C35B8.2
+T28F12.3	C35B8.2
+Y110A7A.10	C35B8.2
+Y54E10BL.6	C35B8.2
+Y71H2AL.1	C35B8.2
+Y73B6A.5	C35B8.2
+ZK792.6	C35B8.2
+ZK856.8	C35B8.2
+F59G1.5	E01H11.1
+F59G1.5	F43C1.2
+F59G1.5	F55C10.1
+Y110A7A.10	F55C10.1
+F59G1.5	F59D6.7
+Y110A7A.10	F59D6.7
+T01E8.3	F59G1.5
+Y54E10BL.6	F59G1.5
+Y71H2AL.1	F59G1.5
+Y73B6A.5	F59G1.5
+ZK792.6	F59G1.5
+ZK856.8	F59G1.5
+Y71H2AL.1	Y110A7A.10
+ZK856.8	Y110A7A.10
+B0334.8	B0218.3
+B0414.5	B0218.3
+C14B9.4	B0218.3
+C47E8.5	B0218.3
+E01F3.1	B0218.3
+F10B5.6	B0218.3
+F10C5.1	B0218.3
+F15H10.3	B0218.3
+F17C8.1	B0218.3
+F35G12.9	B0218.3
+F55G1.8	B0218.3
+K06H7.6	B0218.3
+R06C7.8	B0218.3
+T05G5.3	B0218.3
+T06E6.2	B0218.3
+W10C6.1	B0218.3
+Y110A7A.10	B0218.3
+Y110A7A.17	B0218.3
+Y43E12A.1	B0218.3
+Y48G1C.12	B0218.3
+Y66D12A.17	B0218.3
+Y69A2AR.30	B0218.3
+Y71F9B.7	B0218.3
+Y95B8A.5	B0218.3
+ZC168.4	B0218.3
+ZK1307.6	B0218.3
+ZK507.6	B0218.3
+B0414.5	B0334.8
+C14B9.4	B0334.8
+C47E8.5	B0334.8
+E01F3.1	B0334.8
+F10B5.6	B0334.8
+F10C5.1	B0334.8
+F15H10.3	B0334.8
+F17C8.1	B0334.8
+F35G12.9	B0334.8
+F42G8.3	B0334.8
+F47F2.1	B0334.8
+F55G1.8	B0334.8
+K06H7.6	B0334.8
+R06C7.8	B0334.8
+T05G5.3	B0334.8
+T06E6.2	B0334.8
+W10C6.1	B0334.8
+Y110A7A.17	B0334.8
+Y43E12A.1	B0334.8
+Y48G1C.12	B0334.8
+Y66D12A.17	B0334.8
+Y69A2AR.30	B0334.8
+Y71F9B.7	B0334.8
+Y95B8A.5	B0334.8
+ZC168.4	B0334.8
+ZK1307.6	B0334.8
+ZK507.6	B0334.8
+ZK909.2	B0334.8
+B0478.1	B0414.5
+C12D8.10	B0414.5
+C14B9.4	B0414.5
+C47E8.5	B0414.5
+E01F3.1	B0414.5
+F10B5.6	B0414.5
+F10C5.1	B0414.5
+F15H10.3	B0414.5
+F17C8.1	B0414.5
+F28H6.1	B0414.5
+F35G12.9	B0414.5
+F42G8.3	B0414.5
+F47F2.1	B0414.5
+F55G1.8	B0414.5
+K06H7.6	B0414.5
+R06C7.8	B0414.5
+T01H8.1	B0414.5
+T05G5.3	B0414.5
+T06E6.2	B0414.5
+W10C6.1	B0414.5
+Y110A7A.10	B0414.5
+Y110A7A.17	B0414.5
+Y43E12A.1	B0414.5
+Y48G1C.12	B0414.5
+Y66D12A.17	B0414.5
+Y69A2AR.30	B0414.5
+Y71F9B.7	B0414.5
+Y73B6A.5	B0414.5
+Y95B8A.5	B0414.5
+ZC168.4	B0414.5
+ZK1307.6	B0414.5
+ZK507.6	B0414.5
+ZK909.2	B0414.5
+C14B9.4	B0478.1
+E01F3.1	B0478.1
+F10B5.6	B0478.1
+F10C5.1	B0478.1
+F15H10.3	B0478.1
+F17C8.1	B0478.1
+F35G12.9	B0478.1
+F55G1.8	B0478.1
+K06H7.6	B0478.1
+R06C7.8	B0478.1
+T05G5.3	B0478.1
+T06E6.2	B0478.1
+W10C6.1	B0478.1
+Y110A7A.17	B0478.1
+Y43E12A.1	B0478.1
+Y48G1C.12	B0478.1
+Y66D12A.17	B0478.1
+Y69A2AR.30	B0478.1
+Y71F9B.7	B0478.1
+Y95B8A.5	B0478.1
+ZC168.4	B0478.1
+ZK1307.6	B0478.1
+ZK507.6	B0478.1
+C14B9.4	C12D8.10
+C47E8.5	C12D8.10
+E01F3.1	C12D8.10
+F10B5.6	C12D8.10
+F10C5.1	C12D8.10
+F15H10.3	C12D8.10
+F17C8.1	C12D8.10
+F35G12.9	C12D8.10
+F55G1.8	C12D8.10
+K06H7.6	C12D8.10
+R06C7.8	C12D8.10
+T05G5.3	C12D8.10
+T06E6.2	C12D8.10
+W10C6.1	C12D8.10
+Y110A7A.17	C12D8.10
+Y43E12A.1	C12D8.10
+Y48G1C.12	C12D8.10
+Y66D12A.17	C12D8.10
+Y69A2AR.30	C12D8.10
+Y71F9B.7	C12D8.10
+Y95B8A.5	C12D8.10
+ZC168.4	C12D8.10
+ZK1307.6	C12D8.10
+ZK507.6	C12D8.10
+C47E8.5	C14B9.4
+E01F3.1	C14B9.4
+F10B5.6	C14B9.4
+F10C5.1	C14B9.4
+F15H10.3	C14B9.4
+F17C8.1	C14B9.4
+F28H6.1	C14B9.4
+F35G12.9	C14B9.4
+F42G8.3	C14B9.4
+F43C1.2	C14B9.4
+F47F2.1	C14B9.4
+F55G1.8	C14B9.4
+K06H7.6	C14B9.4
+R06C7.8	C14B9.4
+T01H8.1	C14B9.4
+T05G5.3	C14B9.4
+T06E6.2	C14B9.4
+W10C6.1	C14B9.4
+Y110A7A.10	C14B9.4
+Y110A7A.17	C14B9.4
+Y43E12A.1	C14B9.4
+Y48G1C.12	C14B9.4
+Y54E10BL.6	C14B9.4
+Y66D12A.17	C14B9.4
+Y69A2AR.30	C14B9.4
+Y71F9B.7	C14B9.4
+Y73B6A.5	C14B9.4
+Y95B8A.5	C14B9.4
+ZC168.4	C14B9.4
+ZK1307.6	C14B9.4
+ZK507.6	C14B9.4
+ZK792.6	C14B9.4
+ZK909.2	C14B9.4
+E01F3.1	C47E8.5
+F10B5.6	C47E8.5
+F10C5.1	C47E8.5
+F15H10.3	C47E8.5
+F17C8.1	C47E8.5
+F28H6.1	C47E8.5
+F35G12.9	C47E8.5
+F42G8.3	C47E8.5
+F43C1.2	C47E8.5
+F47F2.1	C47E8.5
+F55G1.8	C47E8.5
+K06H7.6	C47E8.5
+R06C7.8	C47E8.5
+T01H8.1	C47E8.5
+T05G5.3	C47E8.5
+T06E6.2	C47E8.5
+W10C6.1	C47E8.5
+Y110A7A.10	C47E8.5
+Y110A7A.17	C47E8.5
+Y43E12A.1	C47E8.5
+Y48G1C.12	C47E8.5
+Y54E10BL.6	C47E8.5
+Y66D12A.17	C47E8.5
+Y69A2AR.30	C47E8.5
+Y71F9B.7	C47E8.5
+Y73B6A.5	C47E8.5
+Y95B8A.5	C47E8.5
+ZC168.4	C47E8.5
+ZK1307.6	C47E8.5
+ZK507.6	C47E8.5
+ZK792.6	C47E8.5
+ZK909.2	C47E8.5
+F10B5.6	E01F3.1
+F10C5.1	E01F3.1
+F15H10.3	E01F3.1
+F28H6.1	E01F3.1
+F35G12.9	E01F3.1
+F42G8.3	E01F3.1
+F43C1.2	E01F3.1
+F47F2.1	E01F3.1
+F55G1.8	E01F3.1
+K06H7.6	E01F3.1
+R06C7.8	E01F3.1
+T01H8.1	E01F3.1
+T05G5.3	E01F3.1
+T06E6.2	E01F3.1
+W10C6.1	E01F3.1
+Y110A7A.10	E01F3.1
+Y110A7A.17	E01F3.1
+Y43E12A.1	E01F3.1
+Y48G1C.12	E01F3.1
+Y54E10BL.6	E01F3.1
+Y66D12A.17	E01F3.1
+Y69A2AR.30	E01F3.1
+Y71F9B.7	E01F3.1
+Y73B6A.5	E01F3.1
+Y95B8A.5	E01F3.1
+ZC168.4	E01F3.1
+ZK1307.6	E01F3.1
+ZK507.6	E01F3.1
+ZK792.6	E01F3.1
+ZK909.2	E01F3.1
+F17C8.1	F10B5.6
+F28H6.1	F10B5.6
+F42G8.3	F10B5.6
+F43C1.2	F10B5.6
+F47F2.1	F10B5.6
+F55G1.8	F10B5.6
+R06C7.8	F10B5.6
+T01H8.1	F10B5.6
+T05G5.3	F10B5.6
+T06E6.2	F10B5.6
+Y110A7A.10	F10B5.6
+Y43E12A.1	F10B5.6
+Y54E10BL.6	F10B5.6
+Y69A2AR.30	F10B5.6
+Y71F9B.7	F10B5.6
+Y73B6A.5	F10B5.6
+Y95B8A.5	F10B5.6
+ZC168.4	F10B5.6
+ZK507.6	F10B5.6
+ZK792.6	F10B5.6
+ZK909.2	F10B5.6
+F17C8.1	F10C5.1
+F28H6.1	F10C5.1
+F42G8.3	F10C5.1
+F43C1.2	F10C5.1
+F47F2.1	F10C5.1
+F55G1.8	F10C5.1
+R06C7.8	F10C5.1
+T01H8.1	F10C5.1
+T05G5.3	F10C5.1
+T06E6.2	F10C5.1
+Y110A7A.10	F10C5.1
+Y43E12A.1	F10C5.1
+Y54E10BL.6	F10C5.1
+Y69A2AR.30	F10C5.1
+Y71F9B.7	F10C5.1
+Y73B6A.5	F10C5.1
+Y95B8A.5	F10C5.1
+ZC168.4	F10C5.1
+ZK507.6	F10C5.1
+ZK792.6	F10C5.1
+ZK909.2	F10C5.1
+F17C8.1	F15H10.3
+F28H6.1	F15H10.3
+F42G8.3	F15H10.3
+F43C1.2	F15H10.3
+F47F2.1	F15H10.3
+F55G1.8	F15H10.3
+R06C7.8	F15H10.3
+T01H8.1	F15H10.3
+T05G5.3	F15H10.3
+T06E6.2	F15H10.3
+Y110A7A.10	F15H10.3
+Y43E12A.1	F15H10.3
+Y54E10BL.6	F15H10.3
+Y69A2AR.30	F15H10.3
+Y71F9B.7	F15H10.3
+Y73B6A.5	F15H10.3
+Y95B8A.5	F15H10.3
+ZC168.4	F15H10.3
+ZK507.6	F15H10.3
+ZK792.6	F15H10.3
+ZK909.2	F15H10.3
+F28H6.1	F17C8.1
+F35G12.9	F17C8.1
+F42G8.3	F17C8.1
+F43C1.2	F17C8.1
+F55G1.8	F17C8.1
+K06H7.6	F17C8.1
+R06C7.8	F17C8.1
+T01H8.1	F17C8.1
+T05G5.3	F17C8.1
+T06E6.2	F17C8.1
+W10C6.1	F17C8.1
+Y110A7A.10	F17C8.1
+Y110A7A.17	F17C8.1
+Y43E12A.1	F17C8.1
+Y48G1C.12	F17C8.1
+Y54E10BL.6	F17C8.1
+Y66D12A.17	F17C8.1
+Y69A2AR.30	F17C8.1
+Y71F9B.7	F17C8.1
+Y73B6A.5	F17C8.1
+Y95B8A.5	F17C8.1
+ZC168.4	F17C8.1
+ZK1307.6	F17C8.1
+ZK507.6	F17C8.1
+ZK792.6	F17C8.1
+F35G12.9	F28H6.1
+F55G1.8	F28H6.1
+K06H7.6	F28H6.1
+R06C7.8	F28H6.1
+T05G5.3	F28H6.1
+T06E6.2	F28H6.1
+W10C6.1	F28H6.1
+Y110A7A.17	F28H6.1
+Y43E12A.1	F28H6.1
+Y48G1C.12	F28H6.1
+Y66D12A.17	F28H6.1
+Y69A2AR.30	F28H6.1
+Y71F9B.7	F28H6.1
+Y95B8A.5	F28H6.1
+ZC168.4	F28H6.1
+ZK1307.6	F28H6.1
+ZK507.6	F28H6.1
+F42G8.3	F35G12.9
+F43C1.2	F35G12.9
+F47F2.1	F35G12.9
+F55G1.8	F35G12.9
+R06C7.8	F35G12.9
+T01H8.1	F35G12.9
+T05G5.3	F35G12.9
+T06E6.2	F35G12.9
+Y110A7A.10	F35G12.9
+Y43E12A.1	F35G12.9
+Y54E10BL.6	F35G12.9
+Y69A2AR.30	F35G12.9
+Y71F9B.7	F35G12.9
+Y73B6A.5	F35G12.9
+Y95B8A.5	F35G12.9
+ZC168.4	F35G12.9
+ZK507.6	F35G12.9
+ZK792.6	F35G12.9
+ZK909.2	F35G12.9
+F55G1.8	F42G8.3
+K06H7.6	F42G8.3
+R06C7.8	F42G8.3
+T05G5.3	F42G8.3
+T06E6.2	F42G8.3
+W10C6.1	F42G8.3
+Y110A7A.10	F42G8.3
+Y110A7A.17	F42G8.3
+Y43E12A.1	F42G8.3
+Y48G1C.12	F42G8.3
+Y66D12A.17	F42G8.3
+Y69A2AR.30	F42G8.3
+Y71F9B.7	F42G8.3
+Y95B8A.5	F42G8.3
+ZC168.4	F42G8.3
+ZK1307.6	F42G8.3
+ZK507.6	F42G8.3
+F55G1.8	F43C1.2
+K06H7.6	F43C1.2
+R06C7.8	F43C1.2
+T05G5.3	F43C1.2
+T06E6.2	F43C1.2
+W10C6.1	F43C1.2
+Y110A7A.17	F43C1.2
+Y43E12A.1	F43C1.2
+Y48G1C.12	F43C1.2
+Y66D12A.17	F43C1.2
+Y69A2AR.30	F43C1.2
+Y71F9B.7	F43C1.2
+Y95B8A.5	F43C1.2
+ZC168.4	F43C1.2
+ZK1307.6	F43C1.2
+ZK507.6	F43C1.2
+F55G1.8	F47F2.1
+K06H7.6	F47F2.1
+R06C7.8	F47F2.1
+T05G5.3	F47F2.1
+T06E6.2	F47F2.1
+W10C6.1	F47F2.1
+Y110A7A.10	F47F2.1
+Y110A7A.17	F47F2.1
+Y43E12A.1	F47F2.1
+Y48G1C.12	F47F2.1
+Y66D12A.17	F47F2.1
+Y69A2AR.30	F47F2.1
+Y71F9B.7	F47F2.1
+Y95B8A.5	F47F2.1
+ZC168.4	F47F2.1
+ZK1307.6	F47F2.1
+ZK507.6	F47F2.1
+K06H7.6	F55G1.8
+R06C7.8	F55G1.8
+T01H8.1	F55G1.8
+T05G5.3	F55G1.8
+T06E6.2	F55G1.8
+W10C6.1	F55G1.8
+Y110A7A.10	F55G1.8
+Y110A7A.17	F55G1.8
+Y43E12A.1	F55G1.8
+Y48G1C.12	F55G1.8
+Y54E10BL.6	F55G1.8
+Y66D12A.17	F55G1.8
+Y69A2AR.30	F55G1.8
+Y71F9B.7	F55G1.8
+Y73B6A.5	F55G1.8
+Y95B8A.5	F55G1.8
+ZC168.4	F55G1.8
+ZK1307.6	F55G1.8
+ZK507.6	F55G1.8
+ZK792.6	F55G1.8
+ZK909.2	F55G1.8
+R06C7.8	K06H7.6
+T01H8.1	K06H7.6
+T05G5.3	K06H7.6
+T06E6.2	K06H7.6
+Y110A7A.10	K06H7.6
+Y43E12A.1	K06H7.6
+Y54E10BL.6	K06H7.6
+Y69A2AR.30	K06H7.6
+Y71F9B.7	K06H7.6
+Y73B6A.5	K06H7.6
+Y95B8A.5	K06H7.6
+ZC168.4	K06H7.6
+ZK507.6	K06H7.6
+ZK792.6	K06H7.6
+ZK909.2	K06H7.6
+T01H8.1	R06C7.8
+T05G5.3	R06C7.8
+T06E6.2	R06C7.8
+W10C6.1	R06C7.8
+Y110A7A.10	R06C7.8
+Y110A7A.17	R06C7.8
+Y43E12A.1	R06C7.8
+Y48G1C.12	R06C7.8
+Y54E10BL.6	R06C7.8
+Y66D12A.17	R06C7.8
+Y69A2AR.30	R06C7.8
+Y71F9B.7	R06C7.8
+Y73B6A.5	R06C7.8
+Y95B8A.5	R06C7.8
+ZC168.4	R06C7.8
+ZK1307.6	R06C7.8
+ZK507.6	R06C7.8
+ZK792.6	R06C7.8
+ZK909.2	R06C7.8
+T05G5.3	T01H8.1
+T06E6.2	T01H8.1
+W10C6.1	T01H8.1
+Y110A7A.17	T01H8.1
+Y43E12A.1	T01H8.1
+Y48G1C.12	T01H8.1
+Y66D12A.17	T01H8.1
+Y69A2AR.30	T01H8.1
+Y71F9B.7	T01H8.1
+Y95B8A.5	T01H8.1
+ZC168.4	T01H8.1
+ZK1307.6	T01H8.1
+ZK507.6	T01H8.1
+T06E6.2	T05G5.3
+W10C6.1	T05G5.3
+Y110A7A.10	T05G5.3
+Y110A7A.17	T05G5.3
+Y43E12A.1	T05G5.3
+Y48G1C.12	T05G5.3
+Y54E10BL.6	T05G5.3
+Y66D12A.17	T05G5.3
+Y69A2AR.30	T05G5.3
+Y71F9B.7	T05G5.3
+Y73B6A.5	T05G5.3
+Y95B8A.5	T05G5.3
+ZC168.4	T05G5.3
+ZK1307.6	T05G5.3
+ZK507.6	T05G5.3
+ZK792.6	T05G5.3
+ZK909.2	T05G5.3
+W10C6.1	T06E6.2
+Y110A7A.10	T06E6.2
+Y110A7A.17	T06E6.2
+Y43E12A.1	T06E6.2
+Y48G1C.12	T06E6.2
+Y54E10BL.6	T06E6.2
+Y66D12A.17	T06E6.2
+Y69A2AR.30	T06E6.2
+Y71F9B.7	T06E6.2
+Y73B6A.5	T06E6.2
+Y95B8A.5	T06E6.2
+ZK1307.6	T06E6.2
+ZK507.6	T06E6.2
+ZK792.6	T06E6.2
+ZK909.2	T06E6.2
+Y110A7A.10	W10C6.1
+Y43E12A.1	W10C6.1
+Y54E10BL.6	W10C6.1
+Y69A2AR.30	W10C6.1
+Y71F9B.7	W10C6.1
+Y73B6A.5	W10C6.1
+Y95B8A.5	W10C6.1
+ZC168.4	W10C6.1
+ZK507.6	W10C6.1
+ZK792.6	W10C6.1
+ZK909.2	W10C6.1
+Y110A7A.17	Y110A7A.10
+Y43E12A.1	Y110A7A.10
+Y48G1C.12	Y110A7A.10
+Y66D12A.17	Y110A7A.10
+Y69A2AR.30	Y110A7A.10
+Y71F9B.7	Y110A7A.10
+Y95B8A.5	Y110A7A.10
+ZC168.4	Y110A7A.10
+ZK1307.6	Y110A7A.10
+ZK507.6	Y110A7A.10
+ZK909.2	Y110A7A.10
+Y43E12A.1	Y110A7A.17
+Y54E10BL.6	Y110A7A.17
+Y69A2AR.30	Y110A7A.17
+Y71F9B.7	Y110A7A.17
+Y73B6A.5	Y110A7A.17
+Y95B8A.5	Y110A7A.17
+ZC168.4	Y110A7A.17
+ZK507.6	Y110A7A.17
+ZK792.6	Y110A7A.17
+ZK909.2	Y110A7A.17
+Y48G1C.12	Y43E12A.1
+Y54E10BL.6	Y43E12A.1
+Y66D12A.17	Y43E12A.1
+Y69A2AR.30	Y43E12A.1
+Y71F9B.7	Y43E12A.1
+Y73B6A.5	Y43E12A.1
+Y95B8A.5	Y43E12A.1
+ZC168.4	Y43E12A.1
+ZK1307.6	Y43E12A.1
+ZK507.6	Y43E12A.1
+ZK792.6	Y43E12A.1
+ZK909.2	Y43E12A.1
+Y54E10BL.6	Y48G1C.12
+Y69A2AR.30	Y48G1C.12
+Y71F9B.7	Y48G1C.12
+Y73B6A.5	Y48G1C.12
+Y95B8A.5	Y48G1C.12
+ZC168.4	Y48G1C.12
+ZK507.6	Y48G1C.12
+ZK792.6	Y48G1C.12
+ZK909.2	Y48G1C.12
+Y66D12A.17	Y54E10BL.6
+Y69A2AR.30	Y54E10BL.6
+Y71F9B.7	Y54E10BL.6
+Y95B8A.5	Y54E10BL.6
+ZC168.4	Y54E10BL.6
+ZK1307.6	Y54E10BL.6
+ZK507.6	Y54E10BL.6
+Y69A2AR.30	Y66D12A.17
+Y71F9B.7	Y66D12A.17
+Y73B6A.5	Y66D12A.17
+Y95B8A.5	Y66D12A.17
+ZC168.4	Y66D12A.17
+ZK507.6	Y66D12A.17
+ZK792.6	Y66D12A.17
+ZK909.2	Y66D12A.17
+Y71F9B.7	Y69A2AR.30
+Y73B6A.5	Y69A2AR.30
+Y95B8A.5	Y69A2AR.30
+ZC168.4	Y69A2AR.30
+ZK1307.6	Y69A2AR.30
+ZK507.6	Y69A2AR.30
+ZK792.6	Y69A2AR.30
+ZK909.2	Y69A2AR.30
+Y73B6A.5	Y71F9B.7
+Y95B8A.5	Y71F9B.7
+ZC168.4	Y71F9B.7
+ZK1307.6	Y71F9B.7
+ZK507.6	Y71F9B.7
+ZK792.6	Y71F9B.7
+ZK909.2	Y71F9B.7
+Y95B8A.5	Y73B6A.5
+ZC168.4	Y73B6A.5
+ZK1307.6	Y73B6A.5
+ZK507.6	Y73B6A.5
+ZC168.4	Y95B8A.5
+ZK1307.6	Y95B8A.5
+ZK507.6	Y95B8A.5
+ZK792.6	Y95B8A.5
+ZK909.2	Y95B8A.5
+ZK1307.6	ZC168.4
+ZK507.6	ZC168.4
+ZK792.6	ZC168.4
+ZK909.2	ZC168.4
+ZK507.6	ZK1307.6
+ZK792.6	ZK1307.6
+ZK909.2	ZK1307.6
+ZK792.6	ZK507.6
+ZK909.2	ZK507.6
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/hartford_drug.edgelist b/myenv/share/doc/networkx-2.8.5/examples/algorithms/hartford_drug.edgelist
new file mode 100644
index 0000000..c1e92c8
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/hartford_drug.edgelist
@@ -0,0 +1,338 @@
+# source target
+1 2
+1 10
+2 1
+2 10
+3 7
+4 7
+4 209
+5 132
+6 150
+7 3
+7 4
+7 9
+8 106
+8 115
+9 1
+9 2
+9 7
+10 1
+10 2
+11 133
+11 218
+12 88
+13 214
+14 24
+14 52
+16 10
+16 19
+17 64
+17 78
+18 55
+18 103
+18 163
+19 18
+20 64
+20 180
+21 16
+21 22
+22 21
+22 64
+22 106
+23 20
+23 22
+23 64
+24 14
+24 31
+24 122
+27 115
+28 29
+29 28
+30 19
+31 24
+31 32
+31 122
+31 147
+31 233
+32 31
+32 86
+34 35
+34 37
+35 34
+35 43
+36 132
+36 187
+37 38
+37 90
+37 282
+38 42
+38 43
+38 210
+40 20
+42 15
+42 38
+43 34
+43 35
+43 38
+45 107
+46 61
+46 72
+48 23
+49 30
+49 64
+49 108
+49 115
+49 243
+50 30
+50 47
+50 55
+50 125
+50 163
+52 218
+52 224
+54 111
+54 210
+55 65
+55 67
+55 105
+55 108
+55 222
+56 18
+56 64
+57 65
+57 125
+58 20
+58 30
+58 50
+58 103
+58 180
+59 164
+63 125
+64 8
+64 50
+64 70
+64 256
+66 20
+66 84
+66 106
+66 125
+67 22
+67 50
+67 113
+68 50
+70 50
+70 64
+71 72
+74 29
+74 75
+74 215
+75 74
+75 215
+76 58
+76 104
+77 103
+78 64
+78 68
+80 207
+80 210
+82 8
+82 77
+82 83
+82 97
+82 163
+83 82
+83 226
+83 243
+84 29
+84 154
+87 101
+87 189
+89 90
+90 89
+90 94
+91 86
+92 19
+92 30
+92 106
+94 72
+94 89
+94 90
+95 30
+96 75
+96 256
+97 80
+97 128
+98 86
+100 86
+101 87
+103 77
+103 104
+104 58
+104 77
+104 103
+106 22
+107 38
+107 114
+107 122
+108 49
+108 55
+111 121
+111 128
+111 210
+113 253
+114 107
+116 30
+116 140
+118 129
+118 138
+120 88
+121 128
+122 31
+123 32
+124 244
+125 132
+126 163
+126 180
+128 38
+128 111
+129 118
+132 29
+132 30
+133 30
+134 135
+134 150
+135 134
+137 144
+138 118
+138 129
+139 142
+141 157
+141 163
+142 139
+143 2
+144 137
+145 151
+146 137
+146 165
+146 169
+146 171
+147 31
+147 128
+148 146
+148 169
+148 171
+148 282
+149 128
+149 148
+149 172
+150 86
+151 145
+152 4
+153 134
+154 155
+156 161
+157 141
+161 156
+165 144
+165 148
+167 149
+169 15
+169 148
+169 171
+170 115
+170 173
+170 183
+170 202
+171 72
+171 148
+171 169
+173 170
+175 100
+176 10
+178 181
+181 178
+182 38
+182 171
+183 96
+185 50
+186 127
+187 50
+187 65
+188 30
+188 50
+189 87
+189 89
+190 35
+190 38
+190 122
+190 182
+191 54
+191 118
+191 129
+191 172
+192 149
+192 167
+195 75
+197 50
+197 188
+198 218
+198 221
+198 222
+200 65
+200 220
+201 113
+202 156
+203 232
+204 194
+207 38
+207 122
+207 124
+208 30
+208 50
+210 38
+210 207
+211 37
+213 35
+213 38
+214 13
+214 14
+214 171
+214 213
+215 75
+217 39
+218 68
+218 222
+221 198
+222 198
+222 218
+223 39
+225 3
+226 22
+229 65
+230 68
+231 43
+232 95
+232 203
+233 99
+234 68
+234 230
+237 244
+238 145
+242 3
+242 113
+244 237
+249 96
+250 156
+252 65
+254 65
+258 113
+268 4
+270 183
+272 6
+275 96
+280 183
+280 206
+282 37
+285 75
+290 285
+293 290
\ No newline at end of file
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_beam_search.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_beam_search.py
new file mode 100644
index 0000000..c465bbb
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_beam_search.py
@@ -0,0 +1,112 @@
+"""
+===========
+Beam Search
+===========
+
+Beam search with dynamic beam width.
+
+The progressive widening beam search repeatedly executes a beam search
+with increasing beam width until the target node is found.
+"""
+import math
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+def progressive_widening_search(G, source, value, condition, initial_width=1):
+    """Progressive widening beam search to find a node.
+
+    The progressive widening beam search involves a repeated beam
+    search, starting with a small beam width then extending to
+    progressively larger beam widths if the target node is not
+    found. This implementation simply returns the first node found that
+    matches the termination condition.
+
+    `G` is a NetworkX graph.
+
+    `source` is a node in the graph. The search for the node of interest
+    begins here and extends only to those nodes in the (weakly)
+    connected component of this node.
+
+    `value` is a function that returns a real number indicating how good
+    a potential neighbor node is when deciding which neighbor nodes to
+    enqueue in the breadth-first search. Only the best nodes within the
+    current beam width will be enqueued at each step.
+
+    `condition` is the termination condition for the search. This is a
+    function that takes a node as input and return a Boolean indicating
+    whether the node is the target. If no node matches the termination
+    condition, this function raises :exc:`NodeNotFound`.
+
+    `initial_width` is the starting beam width for the beam search (the
+    default is one). If no node matching the `condition` is found with
+    this beam width, the beam search is restarted from the `source` node
+    with a beam width that is twice as large (so the beam width
+    increases exponentially). The search terminates after the beam width
+    exceeds the number of nodes in the graph.
+
+    """
+    # Check for the special case in which the source node satisfies the
+    # termination condition.
+    if condition(source):
+        return source
+    # The largest possible value of `i` in this range yields a width at
+    # least the number of nodes in the graph, so the final invocation of
+    # `bfs_beam_edges` is equivalent to a plain old breadth-first
+    # search. Therefore, all nodes will eventually be visited.
+    log_m = math.ceil(math.log2(len(G)))
+    for i in range(log_m):
+        width = initial_width * pow(2, i)
+        # Since we are always starting from the same source node, this
+        # search may visit the same nodes many times (depending on the
+        # implementation of the `value` function).
+        for u, v in nx.bfs_beam_edges(G, source, value, width):
+            if condition(v):
+                return v
+    # At this point, since all nodes have been visited, we know that
+    # none of the nodes satisfied the termination condition.
+    raise nx.NodeNotFound("no node satisfied the termination condition")
+
+
+###############################################################################
+# Search for a node with high centrality.
+# ---------------------------------------
+#
+# We generate a random graph, compute the centrality of each node, then perform
+# the progressive widening search in order to find a node of high centrality.
+
+# Set a seed for random number generation so the example is reproducible
+seed = 89
+
+G = nx.gnp_random_graph(100, 0.5, seed=seed)
+centrality = nx.eigenvector_centrality(G)
+avg_centrality = sum(centrality.values()) / len(G)
+
+
+def has_high_centrality(v):
+    return centrality[v] >= avg_centrality
+
+
+source = 0
+value = centrality.get
+condition = has_high_centrality
+
+found_node = progressive_widening_search(G, source, value, condition)
+c = centrality[found_node]
+print(f"found node {found_node} with centrality {c}")
+
+
+# Draw graph
+pos = nx.spring_layout(G, seed=seed)
+options = {
+    "node_color": "blue",
+    "node_size": 20,
+    "edge_color": "grey",
+    "linewidths": 0,
+    "width": 0.1,
+}
+nx.draw(G, pos, **options)
+# Draw node with high centrality as large and red
+nx.draw_networkx_nodes(G, pos, nodelist=[found_node], node_size=100, node_color="r")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_betweenness_centrality.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_betweenness_centrality.py
new file mode 100644
index 0000000..e8354c6
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_betweenness_centrality.py
@@ -0,0 +1,83 @@
+"""
+=====================
+Betweeness Centrality
+=====================
+
+Betweenness centrality measures of positive gene functional associations
+using WormNet v.3-GS.
+
+Data from: https://www.inetbio.org/wormnet/downloadnetwork.php
+"""
+
+from random import sample
+import networkx as nx
+import matplotlib.pyplot as plt
+
+# Gold standard data of positive gene functional associations
+# from https://www.inetbio.org/wormnet/downloadnetwork.php
+G = nx.read_edgelist("WormNet.v3.benchmark.txt")
+
+# remove randomly selected nodes (to make example fast)
+num_to_remove = int(len(G) / 1.5)
+nodes = sample(list(G.nodes), num_to_remove)
+G.remove_nodes_from(nodes)
+
+# remove low-degree nodes
+low_degree = [n for n, d in G.degree() if d < 10]
+G.remove_nodes_from(low_degree)
+
+# largest connected component
+components = nx.connected_components(G)
+largest_component = max(components, key=len)
+H = G.subgraph(largest_component)
+
+# compute centrality
+centrality = nx.betweenness_centrality(H, k=10, endpoints=True)
+
+# compute community structure
+lpc = nx.community.label_propagation_communities(H)
+community_index = {n: i for i, com in enumerate(lpc) for n in com}
+
+#### draw graph ####
+fig, ax = plt.subplots(figsize=(20, 15))
+pos = nx.spring_layout(H, k=0.15, seed=4572321)
+node_color = [community_index[n] for n in H]
+node_size = [v * 20000 for v in centrality.values()]
+nx.draw_networkx(
+    H,
+    pos=pos,
+    with_labels=False,
+    node_color=node_color,
+    node_size=node_size,
+    edge_color="gainsboro",
+    alpha=0.4,
+)
+
+# Title/legend
+font = {"color": "k", "fontweight": "bold", "fontsize": 20}
+ax.set_title("Gene functional association network (C. elegans)", font)
+# Change font color for legend
+font["color"] = "r"
+
+ax.text(
+    0.80,
+    0.10,
+    "node color = community structure",
+    horizontalalignment="center",
+    transform=ax.transAxes,
+    fontdict=font,
+)
+ax.text(
+    0.80,
+    0.06,
+    "node size = betweeness centrality",
+    horizontalalignment="center",
+    transform=ax.transAxes,
+    fontdict=font,
+)
+
+# Resize figure for label readibility
+ax.margins(0.1, 0.05)
+fig.tight_layout()
+plt.axis("off")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_blockmodel.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_blockmodel.py
new file mode 100644
index 0000000..e3fec60
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_blockmodel.py
@@ -0,0 +1,79 @@
+"""
+==========
+Blockmodel
+==========
+
+Example of creating a block model using the quotient_graph function in NX.  Data
+used is the Hartford, CT drug users network::
+
+    @article{weeks2002social,
+      title={Social networks of drug users in high-risk sites: Finding the connections},
+      url = {https://doi.org/10.1023/A:1015457400897},
+      doi = {10.1023/A:1015457400897},
+      author={Weeks, Margaret R and Clair, Scott and Borgatti, Stephen P and Radda, Kim and Schensul, Jean J},
+      journal={{AIDS and Behavior}},
+      volume={6},
+      number={2},
+      pages={193--206},
+      year={2002},
+      publisher={Springer}
+    }
+
+"""
+
+from collections import defaultdict
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+from scipy.cluster import hierarchy
+from scipy.spatial import distance
+
+
+def create_hc(G):
+    """Creates hierarchical cluster of graph G from distance matrix"""
+    path_length = nx.all_pairs_shortest_path_length(G)
+    distances = np.zeros((len(G), len(G)))
+    for u, p in path_length:
+        for v, d in p.items():
+            distances[u][v] = d
+    # Create hierarchical cluster
+    Y = distance.squareform(distances)
+    Z = hierarchy.complete(Y)  # Creates HC using farthest point linkage
+    # This partition selection is arbitrary, for illustrive purposes
+    membership = list(hierarchy.fcluster(Z, t=1.15))
+    # Create collection of lists for blockmodel
+    partition = defaultdict(list)
+    for n, p in zip(list(range(len(G))), membership):
+        partition[p].append(n)
+    return list(partition.values())
+
+
+G = nx.read_edgelist("hartford_drug.edgelist")
+
+# Extract largest connected component into graph H
+H = G.subgraph(next(nx.connected_components(G)))
+# Makes life easier to have consecutively labeled integer nodes
+H = nx.convert_node_labels_to_integers(H)
+# Create parititions with hierarchical clustering
+partitions = create_hc(H)
+# Build blockmodel graph
+BM = nx.quotient_graph(H, partitions, relabel=True)
+
+# Draw original graph
+pos = nx.spring_layout(H, iterations=100, seed=83)  # Seed for reproducibility
+plt.subplot(211)
+nx.draw(H, pos, with_labels=False, node_size=10)
+
+# Draw block model with weighted edges and nodes sized by number of internal nodes
+node_size = [BM.nodes[x]["nnodes"] * 10 for x in BM.nodes()]
+edge_width = [(2 * d["weight"]) for (u, v, d) in BM.edges(data=True)]
+# Set positions to mean of positions of internal nodes from original graph
+posBM = {}
+for n in BM:
+    xy = np.array([pos[u] for u in BM.nodes[n]["graph"]])
+    posBM[n] = xy.mean(axis=0)
+plt.subplot(212)
+nx.draw(BM, posBM, node_size=node_size, width=edge_width, with_labels=False)
+plt.axis("off")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_circuits.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_circuits.py
new file mode 100644
index 0000000..5481aed
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_circuits.py
@@ -0,0 +1,103 @@
+"""
+========
+Circuits
+========
+
+Convert a Boolean circuit to an equivalent Boolean formula.
+
+A Boolean circuit can be exponentially more expressive than an
+equivalent formula in the worst case, since the circuit can reuse
+subcircuits multiple times, whereas a formula cannot reuse subformulas
+more than once. Thus creating a Boolean formula from a Boolean circuit
+in this way may be infeasible if the circuit is large.
+
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+def circuit_to_formula(circuit):
+    # Convert the circuit to an equivalent formula.
+    formula = nx.dag_to_branching(circuit)
+    # Transfer the operator or variable labels for each node from the
+    # circuit to the formula.
+    for v in formula:
+        source = formula.nodes[v]["source"]
+        formula.nodes[v]["label"] = circuit.nodes[source]["label"]
+    return formula
+
+
+def formula_to_string(formula):
+    def _to_string(formula, root):
+        # If there are no children, this is a variable node.
+        label = formula.nodes[root]["label"]
+        if not formula[root]:
+            return label
+        # Otherwise, this is an operator.
+        children = formula[root]
+        # If one child, the label must be a NOT operator.
+        if len(children) == 1:
+            child = nx.utils.arbitrary_element(children)
+            return f"{label}({_to_string(formula, child)})"
+        # NB "left" and "right" here are a little misleading: there is
+        # no order on the children of a node. That's okay because the
+        # Boolean AND and OR operators are symmetric. It just means that
+        # the order of the operands cannot be predicted and hence the
+        # function does not necessarily behave the same way on every
+        # invocation.
+        left, right = formula[root]
+        left_subformula = _to_string(formula, left)
+        right_subformula = _to_string(formula, right)
+        return f"({left_subformula} {label} {right_subformula})"
+
+    root = next(v for v, d in formula.in_degree() if d == 0)
+    return _to_string(formula, root)
+
+
+###############################################################################
+# Create an example Boolean circuit.
+# ----------------------------------
+#
+# This circuit has a ∧ at the output and two ∨s at the next layer.
+# The third layer has a variable x that appears in the left ∨, a
+# variable y that appears in both the left and right ∨s, and a
+# negation for the variable z that appears as the sole node in the
+# fourth layer.
+circuit = nx.DiGraph()
+# Layer 0
+circuit.add_node(0, label="∧", layer=0)
+# Layer 1
+circuit.add_node(1, label="∨", layer=1)
+circuit.add_node(2, label="∨", layer=1)
+circuit.add_edge(0, 1)
+circuit.add_edge(0, 2)
+# Layer 2
+circuit.add_node(3, label="x", layer=2)
+circuit.add_node(4, label="y", layer=2)
+circuit.add_node(5, label="¬", layer=2)
+circuit.add_edge(1, 3)
+circuit.add_edge(1, 4)
+circuit.add_edge(2, 4)
+circuit.add_edge(2, 5)
+# Layer 3
+circuit.add_node(6, label="z", layer=3)
+circuit.add_edge(5, 6)
+# Convert the circuit to an equivalent formula.
+formula = circuit_to_formula(circuit)
+print(formula_to_string(formula))
+
+
+labels = nx.get_node_attributes(circuit, "label")
+options = {
+    "node_size": 600,
+    "alpha": 0.5,
+    "node_color": "blue",
+    "labels": labels,
+    "font_size": 22,
+}
+plt.figure(figsize=(8, 8))
+pos = nx.multipartite_layout(circuit, subset_key="layer")
+nx.draw_networkx(circuit, pos, **options)
+plt.title(formula_to_string(formula))
+plt.axis("equal")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_davis_club.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_davis_club.py
new file mode 100644
index 0000000..517d523
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_davis_club.py
@@ -0,0 +1,43 @@
+"""
+==========
+Davis Club
+==========
+
+Davis Southern Club Women
+
+Shows how to make unipartite projections of the graph and compute the
+properties of those graphs.
+
+These data were collected by Davis et al. in the 1930s.
+They represent observed attendance at 14 social events by 18 Southern women.
+The graph is bipartite (clubs, women).
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+import networkx.algorithms.bipartite as bipartite
+
+G = nx.davis_southern_women_graph()
+women = G.graph["top"]
+clubs = G.graph["bottom"]
+
+print("Biadjacency matrix")
+print(bipartite.biadjacency_matrix(G, women, clubs))
+
+# project bipartite graph onto women nodes
+W = bipartite.projected_graph(G, women)
+print()
+print("#Friends, Member")
+for w in women:
+    print(f"{W.degree(w)} {w}")
+
+# project bipartite graph onto women nodes keeping number of co-occurence
+# the degree computed is weighted and counts the total number of shared contacts
+W = bipartite.weighted_projected_graph(G, women)
+print()
+print("#Friend meetings, Member")
+for w in women:
+    print(f"{W.degree(w, weight='weight')} {w}")
+
+pos = nx.spring_layout(G, seed=648)  # Seed layout for reproducible node positions
+nx.draw(G, pos)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_dedensification.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_dedensification.py
new file mode 100644
index 0000000..9104d54
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_dedensification.py
@@ -0,0 +1,92 @@
+"""
+===============
+Dedensification
+===============
+
+Examples of dedensification of a graph.  Dedensification retains the structural
+pattern of the original graph and will only add compressor nodes when doing so
+would result in fewer edges in the compressed graph.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+plt.suptitle("Dedensification")
+
+original_graph = nx.DiGraph()
+white_nodes = ["1", "2", "3", "4", "5", "6"]
+red_nodes = ["A", "B", "C"]
+node_sizes = [250 for node in white_nodes + red_nodes]
+node_colors = ["white" for n in white_nodes] + ["red" for n in red_nodes]
+
+original_graph.add_nodes_from(white_nodes + red_nodes)
+original_graph.add_edges_from(
+    [
+        ("1", "C"),
+        ("1", "B"),
+        ("2", "C"),
+        ("2", "B"),
+        ("2", "A"),
+        ("3", "B"),
+        ("3", "A"),
+        ("3", "6"),
+        ("4", "C"),
+        ("4", "B"),
+        ("4", "A"),
+        ("5", "B"),
+        ("5", "A"),
+        ("6", "5"),
+        ("A", "6"),
+    ]
+)
+base_options = dict(with_labels=True, edgecolors="black")
+pos = {
+    "3": (0, 1),
+    "2": (0, 2),
+    "1": (0, 3),
+    "6": (1, 0),
+    "A": (1, 1),
+    "B": (1, 2),
+    "C": (1, 3),
+    "4": (2, 3),
+    "5": (2, 1),
+}
+ax1 = plt.subplot(1, 2, 1)
+plt.title("Original (%s edges)" % original_graph.number_of_edges())
+nx.draw_networkx(original_graph, pos=pos, node_color=node_colors, **base_options)
+
+nonexp_graph, compression_nodes = nx.summarization.dedensify(
+    original_graph, threshold=2, copy=False
+)
+nonexp_node_colors = list(node_colors)
+nonexp_node_sizes = list(node_sizes)
+for node in compression_nodes:
+    nonexp_node_colors.append("yellow")
+    nonexp_node_sizes.append(600)
+plt.subplot(1, 2, 2)
+
+plt.title("Dedensified (%s edges)" % nonexp_graph.number_of_edges())
+nonexp_pos = {
+    "5": (0, 0),
+    "B": (0, 2),
+    "1": (0, 3),
+    "6": (1, 0.75),
+    "3": (1.5, 1.5),
+    "A": (2, 0),
+    "C": (2, 3),
+    "4": (3, 1.5),
+    "2": (3, 2.5),
+}
+c_nodes = list(compression_nodes)
+c_nodes.sort()
+for spot, node in enumerate(c_nodes):
+    nonexp_pos[node] = (2, spot + 2)
+nx.draw_networkx(
+    nonexp_graph,
+    pos=nonexp_pos,
+    node_color=nonexp_node_colors,
+    node_size=nonexp_node_sizes,
+    **base_options
+)
+
+plt.tight_layout()
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_iterated_dynamical_systems.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_iterated_dynamical_systems.py
new file mode 100644
index 0000000..a19baeb
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_iterated_dynamical_systems.py
@@ -0,0 +1,210 @@
+"""
+==========================
+Iterated Dynamical Systems
+==========================
+
+Digraphs from Integer-valued Iterated Functions
+
+Sums of cubes on 3N
+-------------------
+
+The number 153 has a curious property.
+
+Let 3N={3,6,9,12,...} be the set of positive multiples of 3.  Define an
+iterative process f:3N->3N as follows: for a given n, take each digit
+of n (in base 10), cube it and then sum the cubes to obtain f(n).
+
+When this process is repeated, the resulting series n, f(n), f(f(n)),...
+terminate in 153 after a finite number of iterations (the process ends
+because 153 = 1**3 + 5**3 + 3**3).
+
+In the language of discrete dynamical systems, 153 is the global
+attractor for the iterated map f restricted to the set 3N.
+
+For example: take the number 108
+
+f(108) = 1**3 + 0**3 + 8**3 = 513
+
+and
+
+f(513) = 5**3 + 1**3 + 3**3 = 153
+
+So, starting at 108 we reach 153 in two iterations,
+represented as:
+
+108->513->153
+
+Computing all orbits of 3N up to 10**5 reveals that the attractor
+153 is reached in a maximum of 14 iterations. In this code we
+show that 13 cycles is the maximum required for all integers (in 3N)
+less than 10,000.
+
+The smallest number that requires 13 iterations to reach 153, is 177, i.e.,
+
+177->687->1071->345->216->225->141->66->432->99->1458->702->351->153
+
+The resulting large digraphs are useful for testing network software.
+
+The general problem
+-------------------
+
+Given numbers n, a power p and base b, define F(n; p, b) as the sum of
+the digits of n (in base b) raised to the power p. The above example
+corresponds to f(n)=F(n; 3,10), and below F(n; p, b) is implemented as
+the function powersum(n,p,b). The iterative dynamical system defined by
+the mapping n:->f(n) above (over 3N) converges to a single fixed point;
+153. Applying the map to all positive integers N, leads to a discrete
+dynamical process with 5 fixed points: 1, 153, 370, 371, 407. Modulo 3
+those numbers are 1, 0, 1, 2, 2. The function f above has the added
+property that it maps a multiple of 3 to another multiple of 3; i.e. it
+is invariant on the subset 3N.
+
+
+The squaring of digits (in base 10) result in cycles and the
+single fixed point 1. I.e., from a certain point on, the process
+starts repeating itself.
+
+keywords: "Recurring Digital Invariant", "Narcissistic Number",
+"Happy Number"
+
+The 3n+1 problem
+----------------
+
+There is a rich history of mathematical recreations
+associated with discrete dynamical systems.  The most famous
+is the Collatz 3n+1 problem. See the function
+collatz_problem_digraph below. The Collatz conjecture
+--- that every orbit returns to the fixed point 1 in finite time
+--- is still unproven. Even the great Paul Erdos said "Mathematics
+is not yet ready for such problems", and offered $500
+for its solution.
+
+keywords: "3n+1", "3x+1", "Collatz problem", "Thwaite's conjecture"
+"""
+
+import networkx as nx
+
+nmax = 10000
+p = 3
+
+
+def digitsrep(n, b=10):
+    """Return list of digits comprising n represented in base b.
+    n must be a nonnegative integer"""
+
+    if n <= 0:
+        return [0]
+
+    dlist = []
+    while n > 0:
+        # Prepend next least-significant digit
+        dlist = [n % b] + dlist
+        # Floor-division
+        n = n // b
+    return dlist
+
+
+def powersum(n, p, b=10):
+    """Return sum of digits of n (in base b) raised to the power p."""
+    dlist = digitsrep(n, b)
+    sum = 0
+    for k in dlist:
+        sum += k**p
+    return sum
+
+
+def attractor153_graph(n, p, multiple=3, b=10):
+    """Return digraph of iterations of powersum(n,3,10)."""
+    G = nx.DiGraph()
+    for k in range(1, n + 1):
+        if k % multiple == 0 and k not in G:
+            k1 = k
+            knext = powersum(k1, p, b)
+            while k1 != knext:
+                G.add_edge(k1, knext)
+                k1 = knext
+                knext = powersum(k1, p, b)
+    return G
+
+
+def squaring_cycle_graph_old(n, b=10):
+    """Return digraph of iterations of powersum(n,2,10)."""
+    G = nx.DiGraph()
+    for k in range(1, n + 1):
+        k1 = k
+        G.add_node(k1)  # case k1==knext, at least add node
+        knext = powersum(k1, 2, b)
+        G.add_edge(k1, knext)
+        while k1 != knext:  # stop if fixed point
+            k1 = knext
+            knext = powersum(k1, 2, b)
+            G.add_edge(k1, knext)
+            if G.out_degree(knext) >= 1:
+                # knext has already been iterated in and out
+                break
+    return G
+
+
+def sum_of_digits_graph(nmax, b=10):
+    def f(n):
+        return powersum(n, 1, b)
+
+    return discrete_dynamics_digraph(nmax, f)
+
+
+def squaring_cycle_digraph(nmax, b=10):
+    def f(n):
+        return powersum(n, 2, b)
+
+    return discrete_dynamics_digraph(nmax, f)
+
+
+def cubing_153_digraph(nmax):
+    def f(n):
+        return powersum(n, 3, 10)
+
+    return discrete_dynamics_digraph(nmax, f)
+
+
+def discrete_dynamics_digraph(nmax, f, itermax=50000):
+    G = nx.DiGraph()
+    for k in range(1, nmax + 1):
+        kold = k
+        G.add_node(kold)
+        knew = f(kold)
+        G.add_edge(kold, knew)
+        while kold != knew and kold << itermax:
+            # iterate until fixed point reached or itermax is exceeded
+            kold = knew
+            knew = f(kold)
+            G.add_edge(kold, knew)
+            if G.out_degree(knew) >= 1:
+                # knew has already been iterated in and out
+                break
+    return G
+
+
+def collatz_problem_digraph(nmax):
+    def f(n):
+        if n % 2 == 0:
+            return n // 2
+        else:
+            return 3 * n + 1
+
+    return discrete_dynamics_digraph(nmax, f)
+
+
+def fixed_points(G):
+    """Return a list of fixed points for the discrete dynamical
+    system represented by the digraph G.
+    """
+    return [n for n in G if G.out_degree(n) == 0]
+
+
+nmax = 10000
+print(f"Building cubing_153_digraph({nmax})")
+G = cubing_153_digraph(nmax)
+print("Resulting digraph has", len(G), "nodes and", G.size(), " edges")
+print("Shortest path from 177 to 153 is:")
+print(nx.shortest_path(G, 177, 153))
+print(f"fixed points are {fixed_points(G)}")
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_krackhardt_centrality.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_krackhardt_centrality.py
new file mode 100644
index 0000000..9d3e2a2
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_krackhardt_centrality.py
@@ -0,0 +1,31 @@
+"""
+=====================
+Krackhardt Centrality
+=====================
+
+Centrality measures of Krackhardt social network.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.krackhardt_kite_graph()
+
+print("Betweenness")
+b = nx.betweenness_centrality(G)
+for v in G.nodes():
+    print(f"{v:2} {b[v]:.3f}")
+
+print("Degree centrality")
+d = nx.degree_centrality(G)
+for v in G.nodes():
+    print(f"{v:2} {d[v]:.3f}")
+
+print("Closeness centrality")
+c = nx.closeness_centrality(G)
+for v in G.nodes():
+    print(f"{v:2} {c[v]:.3f}")
+
+pos = nx.spring_layout(G, seed=367)  # Seed layout for reproducibility
+nx.draw(G, pos)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_parallel_betweenness.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_parallel_betweenness.py
new file mode 100644
index 0000000..d9333f4
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_parallel_betweenness.py
@@ -0,0 +1,82 @@
+"""
+====================
+Parallel Betweenness
+====================
+
+Example of parallel implementation of betweenness centrality using the
+multiprocessing module from Python Standard Library.
+
+The function betweenness centrality accepts a bunch of nodes and computes
+the contribution of those nodes to the betweenness centrality of the whole
+network. Here we divide the network in chunks of nodes and we compute their
+contribution to the betweenness centrality of the whole network.
+
+Note: The example output below shows that the non-parallel implementation is
+faster. This is a limitation of our CI/CD pipeline running on a single core.
+
+Depending on your setup, you will likely observe a speedup.
+"""
+from multiprocessing import Pool
+import time
+import itertools
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+def chunks(l, n):
+    """Divide a list of nodes `l` in `n` chunks"""
+    l_c = iter(l)
+    while 1:
+        x = tuple(itertools.islice(l_c, n))
+        if not x:
+            return
+        yield x
+
+
+def betweenness_centrality_parallel(G, processes=None):
+    """Parallel betweenness centrality  function"""
+    p = Pool(processes=processes)
+    node_divisor = len(p._pool) * 4
+    node_chunks = list(chunks(G.nodes(), G.order() // node_divisor))
+    num_chunks = len(node_chunks)
+    bt_sc = p.starmap(
+        nx.betweenness_centrality_subset,
+        zip(
+            [G] * num_chunks,
+            node_chunks,
+            [list(G)] * num_chunks,
+            [True] * num_chunks,
+            [None] * num_chunks,
+        ),
+    )
+
+    # Reduce the partial solutions
+    bt_c = bt_sc[0]
+    for bt in bt_sc[1:]:
+        for n in bt:
+            bt_c[n] += bt[n]
+    return bt_c
+
+
+G_ba = nx.barabasi_albert_graph(1000, 3)
+G_er = nx.gnp_random_graph(1000, 0.01)
+G_ws = nx.connected_watts_strogatz_graph(1000, 4, 0.1)
+for G in [G_ba, G_er, G_ws]:
+    print("")
+    print("Computing betweenness centrality for:")
+    print(nx.info(G))
+    print("\tParallel version")
+    start = time.time()
+    bt = betweenness_centrality_parallel(G)
+    print(f"\t\tTime: {(time.time() - start):.4F} seconds")
+    print(f"\t\tBetweenness centrality for node 0: {bt[0]:.5f}")
+    print("\tNon-Parallel version")
+    start = time.time()
+    bt = nx.betweenness_centrality(G)
+    print(f"\t\tTime: {(time.time() - start):.4F} seconds")
+    print(f"\t\tBetweenness centrality for node 0: {bt[0]:.5f}")
+print("")
+
+nx.draw(G_ba, node_size=100)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_rcm.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_rcm.py
new file mode 100644
index 0000000..fc08739
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_rcm.py
@@ -0,0 +1,40 @@
+"""
+======================
+Reverse Cuthill--McKee
+======================
+
+Cuthill-McKee ordering of matrices
+
+The reverse Cuthill--McKee algorithm gives a sparse matrix ordering that
+reduces the matrix bandwidth.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import networkx as nx
+
+
+# build low-bandwidth matrix
+G = nx.grid_2d_graph(3, 3)
+rcm = list(nx.utils.reverse_cuthill_mckee_ordering(G))
+print("ordering", rcm)
+
+print("unordered Laplacian matrix")
+A = nx.laplacian_matrix(G)
+x, y = np.nonzero(A)
+# print(f"lower bandwidth: {(y - x).max()}")
+# print(f"upper bandwidth: {(x - y).max()}")
+print(f"bandwidth: {(y - x).max() + (x - y).max() + 1}")
+print(A)
+
+B = nx.laplacian_matrix(G, nodelist=rcm)
+print("low-bandwidth Laplacian matrix")
+x, y = np.nonzero(B)
+# print(f"lower bandwidth: {(y - x).max()}")
+# print(f"upper bandwidth: {(x - y).max()}")
+print(f"bandwidth: {(y - x).max() + (x - y).max() + 1}")
+print(B)
+
+sns.heatmap(B.todense(), cbar=False, square=True, linewidths=0.5, annot=True)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_snap.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_snap.py
new file mode 100644
index 0000000..85ea71d
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_snap.py
@@ -0,0 +1,108 @@
+"""
+==================
+SNAP Graph Summary
+==================
+An example of summarizing a graph based on node attributes and edge attributes
+using the Summarization by Grouping Nodes on Attributes and Pairwise
+edges (SNAP) algorithm (not to be confused with the Stanford Network
+Analysis Project).  The algorithm groups nodes by their unique
+combinations of node attribute values and edge types with other groups
+of nodes to produce a summary graph.  The summary graph can then be used to
+infer how nodes with different attributes values relate to other nodes in the
+graph.
+"""
+import networkx as nx
+import matplotlib.pyplot as plt
+
+
+nodes = {
+    "A": dict(color="Red"),
+    "B": dict(color="Red"),
+    "C": dict(color="Red"),
+    "D": dict(color="Red"),
+    "E": dict(color="Blue"),
+    "F": dict(color="Blue"),
+    "G": dict(color="Blue"),
+    "H": dict(color="Blue"),
+    "I": dict(color="Yellow"),
+    "J": dict(color="Yellow"),
+    "K": dict(color="Yellow"),
+    "L": dict(color="Yellow"),
+}
+edges = [
+    ("A", "B", "Strong"),
+    ("A", "C", "Weak"),
+    ("A", "E", "Strong"),
+    ("A", "I", "Weak"),
+    ("B", "D", "Weak"),
+    ("B", "J", "Weak"),
+    ("B", "F", "Strong"),
+    ("C", "G", "Weak"),
+    ("D", "H", "Weak"),
+    ("I", "J", "Strong"),
+    ("J", "K", "Strong"),
+    ("I", "L", "Strong"),
+]
+original_graph = nx.Graph()
+original_graph.add_nodes_from(n for n in nodes.items())
+original_graph.add_edges_from((u, v, {"type": label}) for u, v, label in edges)
+
+
+plt.suptitle("SNAP Summarization")
+
+base_options = dict(with_labels=True, edgecolors="black", node_size=500)
+
+ax1 = plt.subplot(1, 2, 1)
+plt.title(
+    "Original (%s nodes, %s edges)"
+    % (original_graph.number_of_nodes(), original_graph.number_of_edges())
+)
+pos = nx.spring_layout(original_graph, seed=7482934)
+node_colors = [d["color"] for _, d in original_graph.nodes(data=True)]
+
+edge_type_visual_weight_lookup = {"Weak": 1.0, "Strong": 3.0}
+edge_weights = [
+    edge_type_visual_weight_lookup[d["type"]]
+    for _, _, d in original_graph.edges(data=True)
+]
+
+nx.draw_networkx(
+    original_graph, pos=pos, node_color=node_colors, width=edge_weights, **base_options
+)
+
+node_attributes = ("color",)
+edge_attributes = ("type",)
+summary_graph = nx.snap_aggregation(
+    original_graph, node_attributes, edge_attributes, prefix="S-"
+)
+
+plt.subplot(1, 2, 2)
+
+plt.title(
+    "SNAP Aggregation (%s nodes, %s edges)"
+    % (summary_graph.number_of_nodes(), summary_graph.number_of_edges())
+)
+summary_pos = nx.spring_layout(summary_graph, seed=8375428)
+node_colors = []
+for node in summary_graph:
+    color = summary_graph.nodes[node]["color"]
+    node_colors.append(color)
+
+edge_weights = []
+for edge in summary_graph.edges():
+    edge_types = summary_graph.get_edge_data(*edge)["types"]
+    edge_weight = 0.0
+    for edge_type in edge_types:
+        edge_weight += edge_type_visual_weight_lookup[edge_type["type"]]
+    edge_weights.append(edge_weight)
+
+nx.draw_networkx(
+    summary_graph,
+    pos=summary_pos,
+    node_color=node_colors,
+    width=edge_weights,
+    **base_options
+)
+
+plt.tight_layout()
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_subgraphs.py b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_subgraphs.py
new file mode 100644
index 0000000..0812702
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/algorithms/plot_subgraphs.py
@@ -0,0 +1,170 @@
+"""
+=========
+Subgraphs
+=========
+Example of partitioning a directed graph with nodes labeled as
+supported and unsupported nodes into a list of subgraphs
+that contain only entirely supported or entirely unsupported nodes.
+Adopted from 
+https://github.com/lobpcg/python_examples/blob/master/networkx_example.py
+"""
+
+import networkx as nx
+import matplotlib.pyplot as plt
+
+
+def graph_partitioning(G, plotting=True):
+    """Partition a directed graph into a list of subgraphs that contain
+    only entirely supported or entirely unsupported nodes.
+    """
+    # Categorize nodes by their node_type attribute
+    supported_nodes = {n for n, d in G.nodes(data="node_type") if d == "supported"}
+    unsupported_nodes = {n for n, d in G.nodes(data="node_type") if d == "unsupported"}
+
+    # Make a copy of the graph.
+    H = G.copy()
+    # Remove all edges connecting supported and unsupported nodes.
+    H.remove_edges_from(
+        (n, nbr, d)
+        for n, nbrs in G.adj.items()
+        if n in supported_nodes
+        for nbr, d in nbrs.items()
+        if nbr in unsupported_nodes
+    )
+    H.remove_edges_from(
+        (n, nbr, d)
+        for n, nbrs in G.adj.items()
+        if n in unsupported_nodes
+        for nbr, d in nbrs.items()
+        if nbr in supported_nodes
+    )
+
+    # Collect all removed edges for reconstruction.
+    G_minus_H = nx.DiGraph()
+    G_minus_H.add_edges_from(set(G.edges) - set(H.edges))
+
+    if plotting:
+        # Plot the stripped graph with the edges removed.
+        _node_colors = [c for _, c in H.nodes(data="node_color")]
+        _pos = nx.spring_layout(H)
+        plt.figure(figsize=(8, 8))
+        nx.draw_networkx_edges(H, _pos, alpha=0.3, edge_color="k")
+        nx.draw_networkx_nodes(H, _pos, node_color=_node_colors)
+        nx.draw_networkx_labels(H, _pos, font_size=14)
+        plt.axis("off")
+        plt.title("The stripped graph with the edges removed.")
+        plt.show()
+        # Plot the the edges removed.
+        _pos = nx.spring_layout(G_minus_H)
+        plt.figure(figsize=(8, 8))
+        ncl = [G.nodes[n]["node_color"] for n in G_minus_H.nodes]
+        nx.draw_networkx_edges(G_minus_H, _pos, alpha=0.3, edge_color="k")
+        nx.draw_networkx_nodes(G_minus_H, _pos, node_color=ncl)
+        nx.draw_networkx_labels(G_minus_H, _pos, font_size=14)
+        plt.axis("off")
+        plt.title("The removed edges.")
+        plt.show()
+
+    # Find the connected components in the stripped undirected graph.
+    # And use the sets, specifying the components, to partition
+    # the original directed graph into a list of directed subgraphs
+    # that contain only entirely supported or entirely unsupported nodes.
+    subgraphs = [
+        H.subgraph(c).copy() for c in nx.connected_components(H.to_undirected())
+    ]
+
+    return subgraphs, G_minus_H
+
+
+###############################################################################
+# Create an example directed graph.
+# ---------------------------------
+#
+# This directed graph has one input node labeled `in` and plotted in blue color
+# and one output node labeled `out` and plotted in magenta color.
+# The other six nodes are classified as four `supported` plotted in green color
+# and two `unsupported` plotted in red color. The goal is computing a list
+# of subgraphs that contain only entirely `supported` or `unsupported` nodes.
+G_ex = nx.DiGraph()
+G_ex.add_nodes_from(["In"], node_type="input", node_color="b")
+G_ex.add_nodes_from(["A", "C", "E", "F"], node_type="supported", node_color="g")
+G_ex.add_nodes_from(["B", "D"], node_type="unsupported", node_color="r")
+G_ex.add_nodes_from(["Out"], node_type="output", node_color="m")
+G_ex.add_edges_from(
+    [
+        ("In", "A"),
+        ("A", "B"),
+        ("B", "C"),
+        ("B", "D"),
+        ("D", "E"),
+        ("C", "F"),
+        ("E", "F"),
+        ("F", "Out"),
+    ]
+)
+
+###############################################################################
+# Plot the original graph.
+# ------------------------
+#
+node_color_list = [nc for _, nc in G_ex.nodes(data="node_color")]
+pos = nx.spectral_layout(G_ex)
+plt.figure(figsize=(8, 8))
+nx.draw_networkx_edges(G_ex, pos, alpha=0.3, edge_color="k")
+nx.draw_networkx_nodes(G_ex, pos, alpha=0.8, node_color=node_color_list)
+nx.draw_networkx_labels(G_ex, pos, font_size=14)
+plt.axis("off")
+plt.title("The original graph.")
+plt.show()
+
+###############################################################################
+# Calculate the subgraphs with plotting all results of intemediate steps.
+# -----------------------------------------------------------------------
+#
+subgraphs_of_G_ex, removed_edges = graph_partitioning(G_ex, plotting=True)
+
+###############################################################################
+# Plot the results: every subgraph in the list.
+# ---------------------------------------------
+#
+for subgraph in subgraphs_of_G_ex:
+    _pos = nx.spring_layout(subgraph)
+    plt.figure(figsize=(8, 8))
+    nx.draw_networkx_edges(subgraph, _pos, alpha=0.3, edge_color="k")
+    node_color_list_c = [nc for _, nc in subgraph.nodes(data="node_color")]
+    nx.draw_networkx_nodes(subgraph, _pos, node_color=node_color_list_c)
+    nx.draw_networkx_labels(subgraph, _pos, font_size=14)
+    plt.axis("off")
+    plt.title("One of the subgraphs.")
+    plt.show()
+
+###############################################################################
+# Put the graph back from the list of subgraphs
+# ---------------------------------------------
+#
+G_ex_r = nx.DiGraph()
+# Composing all subgraphs.
+for subgraph in subgraphs_of_G_ex:
+    G_ex_r = nx.compose(G_ex_r, subgraph)
+# Adding the previously stored edges.
+G_ex_r.add_edges_from(removed_edges.edges())
+
+###############################################################################
+# Check that the original graph and the reconstructed graphs are isomorphic.
+# --------------------------------------------------------------------------
+#
+assert nx.is_isomorphic(G_ex, G_ex_r)
+
+###############################################################################
+# Plot the reconstructed graph.
+# -----------------------------
+#
+node_color_list = [nc for _, nc in G_ex_r.nodes(data="node_color")]
+pos = nx.spectral_layout(G_ex_r)
+plt.figure(figsize=(8, 8))
+nx.draw_networkx_edges(G_ex_r, pos, alpha=0.3, edge_color="k")
+nx.draw_networkx_nodes(G_ex_r, pos, alpha=0.8, node_color=node_color_list)
+nx.draw_networkx_labels(G_ex_r, pos, font_size=14)
+plt.axis("off")
+plt.title("The reconstructed graph.")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/basic/README.txt b/myenv/share/doc/networkx-2.8.5/examples/basic/README.txt
new file mode 100644
index 0000000..c1cc18b
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/basic/README.txt
@@ -0,0 +1,2 @@
+Basic
+-----
diff --git a/myenv/share/doc/networkx-2.8.5/examples/basic/plot_properties.py b/myenv/share/doc/networkx-2.8.5/examples/basic/plot_properties.py
new file mode 100644
index 0000000..7eb25f3
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/basic/plot_properties.py
@@ -0,0 +1,49 @@
+"""
+==========
+Properties
+==========
+
+Compute some network properties for the lollipop graph.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.lollipop_graph(4, 6)
+
+pathlengths = []
+
+print("source vertex {target:length, }")
+for v in G.nodes():
+    spl = dict(nx.single_source_shortest_path_length(G, v))
+    print(f"{v} {spl} ")
+    for p in spl:
+        pathlengths.append(spl[p])
+
+print()
+print(f"average shortest path length {sum(pathlengths) / len(pathlengths)}")
+
+# histogram of path lengths
+dist = {}
+for p in pathlengths:
+    if p in dist:
+        dist[p] += 1
+    else:
+        dist[p] = 1
+
+print()
+print("length #paths")
+verts = dist.keys()
+for d in sorted(verts):
+    print(f"{d} {dist[d]}")
+
+print(f"radius: {nx.radius(G)}")
+print(f"diameter: {nx.diameter(G)}")
+print(f"eccentricity: {nx.eccentricity(G)}")
+print(f"center: {nx.center(G)}")
+print(f"periphery: {nx.periphery(G)}")
+print(f"density: {nx.density(G)}")
+
+pos = nx.spring_layout(G, seed=3068)  # Seed layout for reproducibility
+nx.draw(G, pos=pos, with_labels=True)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/basic/plot_read_write.py b/myenv/share/doc/networkx-2.8.5/examples/basic/plot_read_write.py
new file mode 100644
index 0000000..c9fa89e
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/basic/plot_read_write.py
@@ -0,0 +1,24 @@
+"""
+======================
+Read and write graphs.
+======================
+
+Read and write graphs.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.grid_2d_graph(5, 5)  # 5x5 grid
+
+# print the adjacency list
+for line in nx.generate_adjlist(G):
+    print(line)
+# write edgelist to grid.edgelist
+nx.write_edgelist(G, path="grid.edgelist", delimiter=":")
+# read edgelist from grid.edgelist
+H = nx.read_edgelist(path="grid.edgelist", delimiter=":")
+
+pos = nx.spring_layout(H, seed=200)
+nx.draw(H, pos)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/basic/plot_simple_graph.py b/myenv/share/doc/networkx-2.8.5/examples/basic/plot_simple_graph.py
new file mode 100644
index 0000000..fcd7caf
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/basic/plot_simple_graph.py
@@ -0,0 +1,60 @@
+"""
+============
+Simple graph
+============
+
+Draw simple graph with manual layout.
+"""
+
+import networkx as nx
+import matplotlib.pyplot as plt
+
+G = nx.Graph()
+G.add_edge(1, 2)
+G.add_edge(1, 3)
+G.add_edge(1, 5)
+G.add_edge(2, 3)
+G.add_edge(3, 4)
+G.add_edge(4, 5)
+
+# explicitly set positions
+pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}
+
+options = {
+    "font_size": 36,
+    "node_size": 3000,
+    "node_color": "white",
+    "edgecolors": "black",
+    "linewidths": 5,
+    "width": 5,
+}
+nx.draw_networkx(G, pos, **options)
+
+# Set margins for the axes so that nodes aren't clipped
+ax = plt.gca()
+ax.margins(0.20)
+plt.axis("off")
+plt.show()
+
+# %%
+# A directed graph
+
+G = nx.DiGraph([(0, 3), (1, 3), (2, 4), (3, 5), (3, 6), (4, 6), (5, 6)])
+
+# group nodes by column
+left_nodes = [0, 1, 2]
+middle_nodes = [3, 4]
+right_nodes = [5, 6]
+
+# set the position according to column (x-coord)
+pos = {n: (0, i) for i, n in enumerate(left_nodes)}
+pos.update({n: (1, i + 0.5) for i, n in enumerate(middle_nodes)})
+pos.update({n: (2, i + 0.5) for i, n in enumerate(right_nodes)})
+
+nx.draw_networkx(G, pos, **options)
+
+# Set margins for the axes so that nodes aren't clipped
+ax = plt.gca()
+ax.margins(0.20)
+plt.axis("off")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/README.txt b/myenv/share/doc/networkx-2.8.5/examples/drawing/README.txt
new file mode 100644
index 0000000..c25993d
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/README.txt
@@ -0,0 +1,2 @@
+Drawing
+-------
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/chess_masters_WCC.pgn.bz2 b/myenv/share/doc/networkx-2.8.5/examples/drawing/chess_masters_WCC.pgn.bz2
new file mode 100644
index 0000000..3761ce5
Binary files /dev/null and b/myenv/share/doc/networkx-2.8.5/examples/drawing/chess_masters_WCC.pgn.bz2 differ
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/knuth_miles.txt.gz b/myenv/share/doc/networkx-2.8.5/examples/drawing/knuth_miles.txt.gz
new file mode 100644
index 0000000..62b7f95
Binary files /dev/null and b/myenv/share/doc/networkx-2.8.5/examples/drawing/knuth_miles.txt.gz differ
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_chess_masters.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_chess_masters.py
new file mode 100644
index 0000000..52f4cfb
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_chess_masters.py
@@ -0,0 +1,152 @@
+"""
+=============
+Chess Masters
+=============
+
+An example of the MultiDiGraph class.
+
+The function `chess_pgn_graph` reads a collection of chess matches stored in
+the specified PGN file (PGN ="Portable Game Notation").  Here the (compressed)
+default file::
+
+    chess_masters_WCC.pgn.bz2
+
+contains all 685 World Chess Championship matches from 1886--1985.
+(data from http://chessproblem.my-free-games.com/chess/games/Download-PGN.php)
+
+The `chess_pgn_graph()` function returns a `MultiDiGraph` with multiple edges.
+Each node is the last name of a chess master. Each edge is directed from white
+to black and contains selected game info.
+
+The key statement in `chess_pgn_graph` below is::
+
+    G.add_edge(white, black, game_info)
+
+where `game_info` is a `dict` describing each game.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# tag names specifying what game info should be
+# stored in the dict on each digraph edge
+game_details = ["Event", "Date", "Result", "ECO", "Site"]
+
+
+def chess_pgn_graph(pgn_file="chess_masters_WCC.pgn.bz2"):
+    """Read chess games in pgn format in pgn_file.
+
+    Filenames ending in .bz2 will be uncompressed.
+
+    Return the MultiDiGraph of players connected by a chess game.
+    Edges contain game data in a dict.
+
+    """
+    import bz2
+
+    G = nx.MultiDiGraph()
+    game = {}
+    with bz2.BZ2File(pgn_file) as datafile:
+        lines = [line.decode().rstrip("\r\n") for line in datafile]
+    for line in lines:
+        if line.startswith("["):
+            tag, value = line[1:-1].split(" ", 1)
+            game[str(tag)] = value.strip('"')
+        else:
+            # empty line after tag set indicates
+            # we finished reading game info
+            if game:
+                white = game.pop("White")
+                black = game.pop("Black")
+                G.add_edge(white, black, **game)
+                game = {}
+    return G
+
+
+G = chess_pgn_graph()
+
+print(
+    f"Loaded {G.number_of_edges()} chess games between {G.number_of_nodes()} players\n"
+)
+
+# identify connected components of the undirected version
+H = G.to_undirected()
+Gcc = [H.subgraph(c) for c in nx.connected_components(H)]
+if len(Gcc) > 1:
+    print(f"Note the disconnected component consisting of:\n{Gcc[1].nodes()}")
+
+# find all games with B97 opening (as described in ECO)
+openings = {game_info["ECO"] for (white, black, game_info) in G.edges(data=True)}
+print(f"\nFrom a total of {len(openings)} different openings,")
+print("the following games used the Sicilian opening")
+print('with the Najdorff 7...Qb6 "Poisoned Pawn" variation.\n')
+
+for (white, black, game_info) in G.edges(data=True):
+    if game_info["ECO"] == "B97":
+        summary = f"{white} vs {black}\n"
+        for k, v in game_info.items():
+            summary += f"   {k}: {v}\n"
+        summary += "\n"
+        print(summary)
+
+# make new undirected graph H without multi-edges
+H = nx.Graph(G)
+
+# edge width is proportional number of games played
+edgewidth = [len(G.get_edge_data(u, v)) for u, v in H.edges()]
+
+# node size is proportional to number of games won
+wins = dict.fromkeys(G.nodes(), 0.0)
+for (u, v, d) in G.edges(data=True):
+    r = d["Result"].split("-")
+    if r[0] == "1":
+        wins[u] += 1.0
+    elif r[0] == "1/2":
+        wins[u] += 0.5
+        wins[v] += 0.5
+    else:
+        wins[v] += 1.0
+nodesize = [wins[v] * 50 for v in H]
+
+# Generate layout for visualization
+pos = nx.kamada_kawai_layout(H)
+# Manual tweaking to limit node label overlap in the visualization
+pos["Reshevsky, Samuel H"] += (0.05, -0.10)
+pos["Botvinnik, Mikhail M"] += (0.03, -0.06)
+pos["Smyslov, Vassily V"] += (0.05, -0.03)
+
+fig, ax = plt.subplots(figsize=(12, 12))
+# Visualize graph components
+nx.draw_networkx_edges(H, pos, alpha=0.3, width=edgewidth, edge_color="m")
+nx.draw_networkx_nodes(H, pos, node_size=nodesize, node_color="#210070", alpha=0.9)
+label_options = {"ec": "k", "fc": "white", "alpha": 0.7}
+nx.draw_networkx_labels(H, pos, font_size=14, bbox=label_options)
+
+# Title/legend
+font = {"fontname": "Helvetica", "color": "k", "fontweight": "bold", "fontsize": 14}
+ax.set_title("World Chess Championship Games: 1886 - 1985", font)
+# Change font color for legend
+font["color"] = "r"
+
+ax.text(
+    0.80,
+    0.10,
+    "edge width = # games played",
+    horizontalalignment="center",
+    transform=ax.transAxes,
+    fontdict=font,
+)
+ax.text(
+    0.80,
+    0.06,
+    "node size = # games won",
+    horizontalalignment="center",
+    transform=ax.transAxes,
+    fontdict=font,
+)
+
+# Resize figure for label readibility
+ax.margins(0.1, 0.05)
+fig.tight_layout()
+plt.axis("off")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_custom_node_icons.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_custom_node_icons.py
new file mode 100644
index 0000000..c13458f
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_custom_node_icons.py
@@ -0,0 +1,75 @@
+"""
+=================
+Custom node icons
+=================
+
+Example of using custom icons to represent nodes with matplotlib.
+
+Images for node icons courtesy of www.materialui.co
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import PIL
+
+# Image URLs for graph nodes
+icons = {
+    "router": "icons/router_black_144x144.png",
+    "switch": "icons/switch_black_144x144.png",
+    "PC": "icons/computer_black_144x144.png",
+}
+
+# Load images
+images = {k: PIL.Image.open(fname) for k, fname in icons.items()}
+
+# Generate the computer network graph
+G = nx.Graph()
+
+G.add_node("router", image=images["router"])
+for i in range(1, 4):
+    G.add_node(f"switch_{i}", image=images["switch"])
+    for j in range(1, 4):
+        G.add_node("PC_" + str(i) + "_" + str(j), image=images["PC"])
+
+G.add_edge("router", "switch_1")
+G.add_edge("router", "switch_2")
+G.add_edge("router", "switch_3")
+for u in range(1, 4):
+    for v in range(1, 4):
+        G.add_edge("switch_" + str(u), "PC_" + str(u) + "_" + str(v))
+
+# Get a reproducible layout and create figure
+pos = nx.spring_layout(G, seed=1734289230)
+fig, ax = plt.subplots()
+
+# Note: the min_source/target_margin kwargs only work with FancyArrowPatch objects.
+# Force the use of FancyArrowPatch for edge drawing by setting `arrows=True`,
+# but suppress arrowheads with `arrowstyle="-"`
+nx.draw_networkx_edges(
+    G,
+    pos=pos,
+    ax=ax,
+    arrows=True,
+    arrowstyle="-",
+    min_source_margin=15,
+    min_target_margin=15,
+)
+
+# Transform from data coordinates (scaled between xlim and ylim) to display coordinates
+tr_figure = ax.transData.transform
+# Transform from display to figure coordinates
+tr_axes = fig.transFigure.inverted().transform
+
+# Select the size of the image (relative to the X axis)
+icon_size = (ax.get_xlim()[1] - ax.get_xlim()[0]) * 0.025
+icon_center = icon_size / 2.0
+
+# Add the respective image to each node
+for n in G.nodes:
+    xf, yf = tr_figure(pos[n])
+    xa, ya = tr_axes((xf, yf))
+    # get overlapped axes and plot icon
+    a = plt.axes([xa - icon_center, ya - icon_center, icon_size, icon_size])
+    a.imshow(G.nodes[n]["image"])
+    a.axis("off")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_degree.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_degree.py
new file mode 100644
index 0000000..9d7abe4
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_degree.py
@@ -0,0 +1,50 @@
+"""
+===============
+Degree Analysis
+===============
+
+This example shows several ways to visualize the distribution of the degree of
+nodes with two common techniques: a *degree-rank plot* and a
+*degree histogram*.
+
+In this example, a random Graph is generated with 100 nodes. The degree of
+each node is determined, and a figure is generated showing three things:
+1. The subgraph of connected components
+2. The degree-rank plot for the Graph, and
+3. The degree histogram
+"""
+import networkx as nx
+import numpy as np
+import matplotlib.pyplot as plt
+
+G = nx.gnp_random_graph(100, 0.02, seed=10374196)
+
+degree_sequence = sorted((d for n, d in G.degree()), reverse=True)
+dmax = max(degree_sequence)
+
+fig = plt.figure("Degree of a random graph", figsize=(8, 8))
+# Create a gridspec for adding subplots of different sizes
+axgrid = fig.add_gridspec(5, 4)
+
+ax0 = fig.add_subplot(axgrid[0:3, :])
+Gcc = G.subgraph(sorted(nx.connected_components(G), key=len, reverse=True)[0])
+pos = nx.spring_layout(Gcc, seed=10396953)
+nx.draw_networkx_nodes(Gcc, pos, ax=ax0, node_size=20)
+nx.draw_networkx_edges(Gcc, pos, ax=ax0, alpha=0.4)
+ax0.set_title("Connected components of G")
+ax0.set_axis_off()
+
+ax1 = fig.add_subplot(axgrid[3:, :2])
+ax1.plot(degree_sequence, "b-", marker="o")
+ax1.set_title("Degree Rank Plot")
+ax1.set_ylabel("Degree")
+ax1.set_xlabel("Rank")
+
+ax2 = fig.add_subplot(axgrid[3:, 2:])
+ax2.bar(*np.unique(degree_sequence, return_counts=True))
+ax2.set_title("Degree histogram")
+ax2.set_xlabel("Degree")
+ax2.set_ylabel("# of Nodes")
+
+fig.tight_layout()
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_directed.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_directed.py
new file mode 100644
index 0000000..8af58d3
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_directed.py
@@ -0,0 +1,46 @@
+"""
+==============
+Directed Graph
+==============
+
+Draw a graph with directed edges using a colormap and different node sizes.
+
+Edges have different colors and alphas (opacity). Drawn using matplotlib.
+"""
+
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import networkx as nx
+
+seed = 13648  # Seed random number generators for reproducibility
+G = nx.random_k_out_graph(10, 3, 0.5, seed=seed)
+pos = nx.spring_layout(G, seed=seed)
+
+node_sizes = [3 + 10 * i for i in range(len(G))]
+M = G.number_of_edges()
+edge_colors = range(2, M + 2)
+edge_alphas = [(5 + i) / (M + 4) for i in range(M)]
+cmap = plt.cm.plasma
+
+nodes = nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color="indigo")
+edges = nx.draw_networkx_edges(
+    G,
+    pos,
+    node_size=node_sizes,
+    arrowstyle="->",
+    arrowsize=10,
+    edge_color=edge_colors,
+    edge_cmap=cmap,
+    width=2,
+)
+# set alpha value for each edge
+for i in range(M):
+    edges[i].set_alpha(edge_alphas[i])
+
+pc = mpl.collections.PatchCollection(edges, cmap=cmap)
+pc.set_array(edge_colors)
+plt.colorbar(pc)
+
+ax = plt.gca()
+ax.set_axis_off()
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_edge_colormap.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_edge_colormap.py
new file mode 100644
index 0000000..e0d569b
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_edge_colormap.py
@@ -0,0 +1,23 @@
+"""
+=============
+Edge Colormap
+=============
+
+Draw a graph with matplotlib, color edges.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.star_graph(20)
+pos = nx.spring_layout(G, seed=63)  # Seed layout for reproducibility
+colors = range(20)
+options = {
+    "node_color": "#A0CBE2",
+    "edge_color": colors,
+    "width": 4,
+    "edge_cmap": plt.cm.Blues,
+    "with_labels": False,
+}
+nx.draw(G, pos, **options)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_ego_graph.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_ego_graph.py
new file mode 100644
index 0000000..fde5740
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_ego_graph.py
@@ -0,0 +1,35 @@
+"""
+=========
+Ego Graph
+=========
+
+Example using the NetworkX ego_graph() function to return the main egonet of
+the largest hub in a Barabási-Albert network.
+"""
+
+from operator import itemgetter
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# Create a BA model graph - use seed for reproducibility
+n = 1000
+m = 2
+seed = 20532
+G = nx.barabasi_albert_graph(n, m, seed=seed)
+
+# find node with largest degree
+node_and_degree = G.degree()
+(largest_hub, degree) = sorted(node_and_degree, key=itemgetter(1))[-1]
+
+# Create ego graph of main hub
+hub_ego = nx.ego_graph(G, largest_hub)
+
+# Draw graph
+pos = nx.spring_layout(hub_ego, seed=seed)  # Seed layout for reproducibility
+nx.draw(hub_ego, pos, node_color="b", node_size=50, with_labels=False)
+
+# Draw ego as large and red
+options = {"node_size": 300, "node_color": "r"}
+nx.draw_networkx_nodes(hub_ego, pos, nodelist=[largest_hub], **options)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_eigenvalues.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_eigenvalues.py
new file mode 100644
index 0000000..b0df67a
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_eigenvalues.py
@@ -0,0 +1,22 @@
+"""
+===========
+Eigenvalues
+===========
+
+Create an G{n,m} random graph and compute the eigenvalues.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy.linalg
+
+n = 1000  # 1000 nodes
+m = 5000  # 5000 edges
+G = nx.gnm_random_graph(n, m, seed=5040)  # Seed for reproducibility
+
+L = nx.normalized_laplacian_matrix(G)
+e = numpy.linalg.eigvals(L.A)
+print("Largest eigenvalue:", max(e))
+print("Smallest eigenvalue:", min(e))
+plt.hist(e, bins=100)  # histogram with 100 bins
+plt.xlim(0, 2)  # eigenvalues between 0 and 2
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_four_grids.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_four_grids.py
new file mode 100644
index 0000000..17af4e5
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_four_grids.py
@@ -0,0 +1,52 @@
+"""
+==========
+Four Grids
+==========
+
+Draw a 4x4 graph with matplotlib.
+
+This example illustrates the use of keyword arguments to `networkx.draw` to
+customize the visualization of a simple Graph comprising a 4x4 grid.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.grid_2d_graph(4, 4)  # 4x4 grid
+
+pos = nx.spring_layout(G, iterations=100, seed=39775)
+
+# Create a 2x2 subplot
+fig, all_axes = plt.subplots(2, 2)
+ax = all_axes.flat
+
+nx.draw(G, pos, ax=ax[0], font_size=8)
+nx.draw(G, pos, ax=ax[1], node_size=0, with_labels=False)
+nx.draw(
+    G,
+    pos,
+    ax=ax[2],
+    node_color="tab:green",
+    edgecolors="tab:gray",  # Node surface color
+    edge_color="tab:gray",  # Color of graph edges
+    node_size=250,
+    with_labels=False,
+    width=6,
+)
+H = G.to_directed()
+nx.draw(
+    H,
+    pos,
+    ax=ax[3],
+    node_color="tab:orange",
+    node_size=20,
+    with_labels=False,
+    arrowsize=10,
+    width=2,
+)
+
+# Set margins for the axes so that nodes aren't clipped
+for a in ax:
+    a.margins(0.10)
+fig.tight_layout()
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_house_with_colors.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_house_with_colors.py
new file mode 100644
index 0000000..c3a2809
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_house_with_colors.py
@@ -0,0 +1,26 @@
+"""
+=================
+House With Colors
+=================
+
+Draw a graph with matplotlib.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.house_graph()
+# explicitly set positions
+pos = {0: (0, 0), 1: (1, 0), 2: (0, 1), 3: (1, 1), 4: (0.5, 2.0)}
+
+# Plot nodes with different properties for the "wall" and "roof" nodes
+nx.draw_networkx_nodes(
+    G, pos, node_size=3000, nodelist=[0, 1, 2, 3], node_color="tab:blue"
+)
+nx.draw_networkx_nodes(G, pos, node_size=2000, nodelist=[4], node_color="tab:orange")
+nx.draw_networkx_edges(G, pos, alpha=0.5, width=6)
+# Customize axes
+ax = plt.gca()
+ax.margins(0.11)
+plt.tight_layout()
+plt.axis("off")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_knuth_miles.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_knuth_miles.py
new file mode 100644
index 0000000..e0ebea8
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_knuth_miles.py
@@ -0,0 +1,142 @@
+"""
+===========
+Knuth Miles
+===========
+
+`miles_graph()` returns an undirected graph over 128 US cities. The
+cities each have location and population data.  The edges are labeled with the
+distance between the two cities.
+
+This example is described in Section 1.1 of
+
+    Donald E. Knuth, "The Stanford GraphBase: A Platform for Combinatorial
+    Computing", ACM Press, New York, 1993.
+    http://www-cs-faculty.stanford.edu/~knuth/sgb.html
+
+The data file can be found at:
+
+- https://github.com/networkx/networkx/blob/main/examples/drawing/knuth_miles.txt.gz
+"""
+
+import gzip
+import re
+
+# Ignore any warnings related to downloading shpfiles with cartopy
+import warnings
+
+warnings.simplefilter("ignore")
+
+import numpy as np
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+def miles_graph():
+    """Return the cites example graph in miles_dat.txt
+    from the Stanford GraphBase.
+    """
+    # open file miles_dat.txt.gz (or miles_dat.txt)
+
+    fh = gzip.open("knuth_miles.txt.gz", "r")
+
+    G = nx.Graph()
+    G.position = {}
+    G.population = {}
+
+    cities = []
+    for line in fh.readlines():
+        line = line.decode()
+        if line.startswith("*"):  # skip comments
+            continue
+
+        numfind = re.compile(r"^\d+")
+
+        if numfind.match(line):  # this line is distances
+            dist = line.split()
+            for d in dist:
+                G.add_edge(city, cities[i], weight=int(d))
+                i = i + 1
+        else:  # this line is a city, position, population
+            i = 1
+            (city, coordpop) = line.split("[")
+            cities.insert(0, city)
+            (coord, pop) = coordpop.split("]")
+            (y, x) = coord.split(",")
+
+            G.add_node(city)
+            # assign position - Convert string to lat/long
+            G.position[city] = (-float(x) / 100, float(y) / 100)
+            G.population[city] = float(pop) / 1000
+    return G
+
+
+G = miles_graph()
+
+print("Loaded miles_dat.txt containing 128 cities.")
+print(G)
+
+# make new graph of cites, edge if less then 300 miles between them
+H = nx.Graph()
+for v in G:
+    H.add_node(v)
+for (u, v, d) in G.edges(data=True):
+    if d["weight"] < 300:
+        H.add_edge(u, v)
+
+# draw with matplotlib/pylab
+fig = plt.figure(figsize=(8, 6))
+
+# nodes colored by degree sized by population
+node_color = [float(H.degree(v)) for v in H]
+
+# Use cartopy to provide a backdrop for the visualization
+try:
+    import cartopy.crs as ccrs
+    import cartopy.io.shapereader as shpreader
+
+    ax = fig.add_axes([0, 0, 1, 1], projection=ccrs.LambertConformal(), frameon=False)
+    ax.set_extent([-125, -66.5, 20, 50], ccrs.Geodetic())
+    # Add map of countries & US states as a backdrop
+    for shapename in ("admin_1_states_provinces_lakes_shp", "admin_0_countries"):
+        shp = shpreader.natural_earth(
+            resolution="110m", category="cultural", name=shapename
+        )
+        ax.add_geometries(
+            shpreader.Reader(shp).geometries(),
+            ccrs.PlateCarree(),
+            facecolor="none",
+            edgecolor="k",
+        )
+    # NOTE: When using cartopy, use matplotlib directly rather than nx.draw
+    # to take advantage of the cartopy transforms
+    ax.scatter(
+        *np.array([v for v in G.position.values()]).T,
+        s=[G.population[v] for v in H],
+        c=node_color,
+        transform=ccrs.PlateCarree(),
+        zorder=100  # Ensure nodes lie on top of edges/state lines
+    )
+    # Plot edges between the cities
+    for edge in H.edges():
+        edge_coords = np.array([G.position[v] for v in edge])
+        ax.plot(
+            edge_coords[:, 0],
+            edge_coords[:, 1],
+            transform=ccrs.PlateCarree(),
+            linewidth=0.75,
+            color="k",
+        )
+
+except ImportError:
+    # If cartopy is unavailable, the backdrop for the plot will be blank;
+    # though you should still be able to discern the general shape of the US
+    # from graph nodes and edges!
+    nx.draw(
+        H,
+        G.position,
+        node_size=[G.population[v] for v in H],
+        node_color=node_color,
+        with_labels=False,
+    )
+
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_labels_and_colors.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_labels_and_colors.py
new file mode 100644
index 0000000..b7eddfd
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_labels_and_colors.py
@@ -0,0 +1,54 @@
+"""
+=================
+Labels And Colors
+=================
+
+Use `nodelist` and `edgelist` to apply custom coloring and labels to various
+components of a graph.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.cubical_graph()
+pos = nx.spring_layout(G, seed=3113794652)  # positions for all nodes
+
+# nodes
+options = {"edgecolors": "tab:gray", "node_size": 800, "alpha": 0.9}
+nx.draw_networkx_nodes(G, pos, nodelist=[0, 1, 2, 3], node_color="tab:red", **options)
+nx.draw_networkx_nodes(G, pos, nodelist=[4, 5, 6, 7], node_color="tab:blue", **options)
+
+# edges
+nx.draw_networkx_edges(G, pos, width=1.0, alpha=0.5)
+nx.draw_networkx_edges(
+    G,
+    pos,
+    edgelist=[(0, 1), (1, 2), (2, 3), (3, 0)],
+    width=8,
+    alpha=0.5,
+    edge_color="tab:red",
+)
+nx.draw_networkx_edges(
+    G,
+    pos,
+    edgelist=[(4, 5), (5, 6), (6, 7), (7, 4)],
+    width=8,
+    alpha=0.5,
+    edge_color="tab:blue",
+)
+
+
+# some math labels
+labels = {}
+labels[0] = r"$a$"
+labels[1] = r"$b$"
+labels[2] = r"$c$"
+labels[3] = r"$d$"
+labels[4] = r"$\alpha$"
+labels[5] = r"$\beta$"
+labels[6] = r"$\gamma$"
+labels[7] = r"$\delta$"
+nx.draw_networkx_labels(G, pos, labels, font_size=22, font_color="whitesmoke")
+
+plt.tight_layout()
+plt.axis("off")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_multipartite_graph.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_multipartite_graph.py
new file mode 100644
index 0000000..15c4d82
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_multipartite_graph.py
@@ -0,0 +1,41 @@
+"""
+===================
+Multipartite Layout
+===================
+"""
+
+import itertools
+import matplotlib.pyplot as plt
+import networkx as nx
+
+subset_sizes = [5, 5, 4, 3, 2, 4, 4, 3]
+subset_color = [
+    "gold",
+    "violet",
+    "violet",
+    "violet",
+    "violet",
+    "limegreen",
+    "limegreen",
+    "darkorange",
+]
+
+
+def multilayered_graph(*subset_sizes):
+    extents = nx.utils.pairwise(itertools.accumulate((0,) + subset_sizes))
+    layers = [range(start, end) for start, end in extents]
+    G = nx.Graph()
+    for (i, layer) in enumerate(layers):
+        G.add_nodes_from(layer, layer=i)
+    for layer1, layer2 in nx.utils.pairwise(layers):
+        G.add_edges_from(itertools.product(layer1, layer2))
+    return G
+
+
+G = multilayered_graph(*subset_sizes)
+color = [subset_color[data["layer"]] for v, data in G.nodes(data=True)]
+pos = nx.multipartite_layout(G, subset_key="layer")
+plt.figure(figsize=(8, 8))
+nx.draw(G, pos, node_color=color, with_labels=False)
+plt.axis("equal")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_node_colormap.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_node_colormap.py
new file mode 100644
index 0000000..ea31a46
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_node_colormap.py
@@ -0,0 +1,15 @@
+"""
+=============
+Node Colormap
+=============
+
+Draw a graph with matplotlib, color by degree.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.cycle_graph(24)
+pos = nx.circular_layout(G)
+nx.draw(G, pos, node_color=range(24), node_size=800, cmap=plt.cm.Blues)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_rainbow_coloring.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_rainbow_coloring.py
new file mode 100644
index 0000000..1d9e607
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_rainbow_coloring.py
@@ -0,0 +1,68 @@
+"""
+================
+Rainbow Coloring
+================
+
+Generate a complete graph with 13 nodes in a circular layout with the
+edges colored by node distance. The node distance is given by the minimum
+number of nodes traversed along an arc between any two nodes on the circle.
+
+Such graphs are the subject of Ringel's conjecture, which states: any complete
+graph with ``2n + 1`` nodes can be tiled by any tree with ``n + 1`` nodes
+(i.e. copies of the tree can be placed over the complete graph such that each
+edge in the complete graph is covered exactly once). The edge coloring is
+helpful in determining how to place the tree copies.
+
+References
+----------
+https://www.quantamagazine.org/mathematicians-prove-ringels-graph-theory-conjecture-20200219/
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# A rainbow color mapping using matplotlib's tableau colors
+node_dist_to_color = {
+    1: "tab:red",
+    2: "tab:orange",
+    3: "tab:olive",
+    4: "tab:green",
+    5: "tab:blue",
+    6: "tab:purple",
+}
+
+# Create a complete graph with an odd number of nodes
+nnodes = 13
+G = nx.complete_graph(nnodes)
+
+# A graph with (2n + 1) nodes requires n colors for the edges
+n = (nnodes - 1) // 2
+ndist_iter = list(range(1, n + 1))
+
+# Take advantage of circular symmetry in determining node distances
+ndist_iter += ndist_iter[::-1]
+
+
+def cycle(nlist, n):
+    return nlist[-n:] + nlist[:-n]
+
+
+# Rotate nodes around the circle and assign colors for each edge based on
+# node distance
+nodes = list(G.nodes())
+for i, nd in enumerate(ndist_iter):
+    for u, v in zip(nodes, cycle(nodes, i + 1)):
+        G[u][v]["color"] = node_dist_to_color[nd]
+
+pos = nx.circular_layout(G)
+# Create a figure with 1:1 aspect ratio to preserve the circle.
+fig, ax = plt.subplots(figsize=(8, 8))
+node_opts = {"node_size": 500, "node_color": "w", "edgecolors": "k", "linewidths": 2.0}
+nx.draw_networkx_nodes(G, pos, **node_opts)
+nx.draw_networkx_labels(G, pos, font_size=14)
+# Extract color from edge data
+edge_colors = [edgedata["color"] for _, _, edgedata in G.edges(data=True)]
+nx.draw_networkx_edges(G, pos, width=2.0, edge_color=edge_colors)
+
+ax.set_axis_off()
+fig.tight_layout()
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_random_geometric_graph.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_random_geometric_graph.py
new file mode 100644
index 0000000..6b7c95d
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_random_geometric_graph.py
@@ -0,0 +1,44 @@
+"""
+======================
+Random Geometric Graph
+======================
+
+Example
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# Use seed when creating the graph for reproducibility
+G = nx.random_geometric_graph(200, 0.125, seed=896803)
+# position is stored as node attribute data for random_geometric_graph
+pos = nx.get_node_attributes(G, "pos")
+
+# find node near center (0.5,0.5)
+dmin = 1
+ncenter = 0
+for n in pos:
+    x, y = pos[n]
+    d = (x - 0.5) ** 2 + (y - 0.5) ** 2
+    if d < dmin:
+        ncenter = n
+        dmin = d
+
+# color by path length from node near center
+p = dict(nx.single_source_shortest_path_length(G, ncenter))
+
+plt.figure(figsize=(8, 8))
+nx.draw_networkx_edges(G, pos, alpha=0.4)
+nx.draw_networkx_nodes(
+    G,
+    pos,
+    nodelist=list(p.keys()),
+    node_size=80,
+    node_color=list(p.values()),
+    cmap=plt.cm.Reds_r,
+)
+
+plt.xlim(-0.05, 1.05)
+plt.ylim(-0.05, 1.05)
+plt.axis("off")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_sampson.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_sampson.py
new file mode 100644
index 0000000..d6eff64
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_sampson.py
@@ -0,0 +1,47 @@
+"""
+=======
+Sampson
+=======
+
+Sampson's monastery data.
+
+Shows how to read data from a zip file and plot multiple frames.
+
+The data file can be found at:
+
+- https://github.com/networkx/networkx/blob/main/examples/drawing/sampson_data.zip
+"""
+
+import zipfile
+from io import BytesIO as StringIO
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+with zipfile.ZipFile("sampson_data.zip") as zf:
+    e1 = StringIO(zf.read("samplike1.txt"))
+    e2 = StringIO(zf.read("samplike2.txt"))
+    e3 = StringIO(zf.read("samplike3.txt"))
+
+G1 = nx.read_edgelist(e1, delimiter="\t")
+G2 = nx.read_edgelist(e2, delimiter="\t")
+G3 = nx.read_edgelist(e3, delimiter="\t")
+pos = nx.spring_layout(G3, iterations=100, seed=173)
+plt.clf()
+
+plt.subplot(221)
+plt.title("samplike1")
+nx.draw(G1, pos, node_size=50, with_labels=False)
+plt.subplot(222)
+plt.title("samplike2")
+nx.draw(G2, pos, node_size=50, with_labels=False)
+plt.subplot(223)
+plt.title("samplike3")
+nx.draw(G3, pos, node_size=50, with_labels=False)
+plt.subplot(224)
+plt.title("samplike1,2,3")
+nx.draw(G3, pos, edgelist=list(G3.edges()), node_size=50, with_labels=False)
+nx.draw_networkx_edges(G1, pos, alpha=0.25)
+nx.draw_networkx_edges(G2, pos, alpha=0.25)
+plt.tight_layout()
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_selfloops.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_selfloops.py
new file mode 100644
index 0000000..11bcf50
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_selfloops.py
@@ -0,0 +1,29 @@
+"""
+==========
+Self-loops
+==========
+
+A self-loop is an edge that originates from and terminates the same node.
+This example shows how to draw self-loops with `nx_pylab`.
+
+"""
+import networkx as nx
+import matplotlib.pyplot as plt
+
+# Create a graph and add a self-loop to node 0
+G = nx.complete_graph(3, create_using=nx.DiGraph)
+G.add_edge(0, 0)
+pos = nx.circular_layout(G)
+
+# As of version 2.6, self-loops are drawn by default with the same styling as
+# other edges
+nx.draw(G, pos, with_labels=True)
+
+# Add self-loops to the remaining nodes
+edgelist = [(1, 1), (2, 2)]
+G.add_edges_from(edgelist)
+
+# Draw the newly added self-loops with different formatting
+nx.draw_networkx_edges(G, pos, edgelist=edgelist, arrowstyle="<|-", style="dashed")
+
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_simple_path.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_simple_path.py
new file mode 100644
index 0000000..ec52185
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_simple_path.py
@@ -0,0 +1,14 @@
+"""
+===========
+Simple Path
+===========
+
+Draw a graph with matplotlib.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.path_graph(8)
+pos = nx.spring_layout(G, seed=47)  # Seed layout for reproducibility
+nx.draw(G, pos=pos)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_spectral_grid.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_spectral_grid.py
new file mode 100644
index 0000000..80ef6f1
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_spectral_grid.py
@@ -0,0 +1,58 @@
+"""
+==================
+Spectral Embedding
+==================
+
+The spectral layout positions the nodes of the graph based on the
+eigenvectors of the graph Laplacian $L = D - A$, where $A$ is the
+adjacency matrix and $D$ is the degree matrix of the graph.
+By default, the spectral layout will embed the graph in two
+dimensions (you can embed your graph in other dimensions using the
+``dim`` argument to either :func:`~drawing.nx_pylab.draw_spectral` or
+:func:`~drawing.layout.spectral_layout`).
+
+When the edges of the graph represent similarity between the incident
+nodes, the spectral embedding will place highly similar nodes closer
+to one another than nodes which are less similar.
+
+This is particularly striking when you spectrally embed a grid
+graph.  In the full grid graph, the nodes in the center of the
+graph are pulled apart more than nodes on the periphery.
+As you remove internal nodes, this effect increases.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+options = {"node_color": "C0", "node_size": 100}
+
+G = nx.grid_2d_graph(6, 6)
+plt.subplot(332)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((2, 2), (2, 3))
+plt.subplot(334)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((3, 2), (3, 3))
+plt.subplot(335)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((2, 2), (3, 2))
+plt.subplot(336)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((2, 3), (3, 3))
+plt.subplot(337)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((1, 2), (1, 3))
+plt.subplot(338)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((4, 2), (4, 3))
+plt.subplot(339)
+nx.draw_spectral(G, **options)
+
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_tsp.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_tsp.py
new file mode 100644
index 0000000..78c731b
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_tsp.py
@@ -0,0 +1,52 @@
+"""
+==========================
+Traveling Salesman Problem
+==========================
+
+This is an example of a drawing solution of the traveling salesman problem
+
+The function is used to produce the solution is christofides,
+where given a set of nodes, it calculates the route of the nodes
+that the traveler has to follow in order to minimize the total cost.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import networkx.algorithms.approximation as nx_app
+import math
+
+G = nx.random_geometric_graph(20, radius=0.4, seed=3)
+pos = nx.get_node_attributes(G, "pos")
+
+# Depot should be at (0,0)
+pos[0] = (0.5, 0.5)
+
+H = G.copy()
+
+
+# Calculating the distances between the nodes as edge's weight.
+for i in range(len(pos)):
+    for j in range(i + 1, len(pos)):
+        dist = math.hypot(pos[i][0] - pos[j][0], pos[i][1] - pos[j][1])
+        dist = dist
+        G.add_edge(i, j, weight=dist)
+
+cycle = nx_app.christofides(G, weight="weight")
+edge_list = list(nx.utils.pairwise(cycle))
+
+# Draw closest edges on each node only
+nx.draw_networkx_edges(H, pos, edge_color="blue", width=0.5)
+
+# Draw the route
+nx.draw_networkx(
+    G,
+    pos,
+    with_labels=True,
+    edgelist=edge_list,
+    edge_color="red",
+    node_size=200,
+    width=3,
+)
+
+print("The route of the traveller is:", cycle)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_unix_email.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_unix_email.py
new file mode 100644
index 0000000..25fce7a
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_unix_email.py
@@ -0,0 +1,62 @@
+"""
+==========
+Unix Email
+==========
+
+Create a directed graph, allowing multiple edges and self loops, from a unix
+mailbox.  The nodes are email addresses with links that point from the sender
+to the receivers.  The edge data is a Python email.Message object which
+contains all of the email message data.
+
+This example shows the power of `DiGraph` to hold edge data of arbitrary Python
+objects (in this case a list of email messages).
+
+
+The sample unix email mailbox called "unix_email.mbox" may be found here:
+
+- https://github.com/networkx/networkx/blob/main/examples/drawing/unix_email.mbox
+"""
+
+from email.utils import getaddresses, parseaddr
+import mailbox
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# unix mailbox recipe
+# see https://docs.python.org/3/library/mailbox.html
+
+
+def mbox_graph():
+    mbox = mailbox.mbox("unix_email.mbox")  # parse unix mailbox
+
+    G = nx.MultiDiGraph()  # create empty graph
+
+    # parse each messages and build graph
+    for msg in mbox:  # msg is python email.Message.Message object
+        (source_name, source_addr) = parseaddr(msg["From"])  # sender
+        # get all recipients
+        # see https://docs.python.org/3/library/email.html
+        tos = msg.get_all("to", [])
+        ccs = msg.get_all("cc", [])
+        resent_tos = msg.get_all("resent-to", [])
+        resent_ccs = msg.get_all("resent-cc", [])
+        all_recipients = getaddresses(tos + ccs + resent_tos + resent_ccs)
+        # now add the edges for this mail message
+        for (target_name, target_addr) in all_recipients:
+            G.add_edge(source_addr, target_addr, message=msg)
+
+    return G
+
+
+G = mbox_graph()
+
+# print edges with message subject
+for (u, v, d) in G.edges(data=True):
+    print(f"From: {u} To: {v} Subject: {d['message']['Subject']}")
+
+pos = nx.spring_layout(G, iterations=10, seed=227)
+nx.draw(G, pos, node_size=0, alpha=0.4, edge_color="r", font_size=16, with_labels=True)
+ax = plt.gca()
+ax.margins(0.08)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_weighted_graph.py b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_weighted_graph.py
new file mode 100644
index 0000000..ba7721c
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/plot_weighted_graph.py
@@ -0,0 +1,44 @@
+"""
+==============
+Weighted Graph
+==============
+
+An example using Graph as a weighted network.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.Graph()
+
+G.add_edge("a", "b", weight=0.6)
+G.add_edge("a", "c", weight=0.2)
+G.add_edge("c", "d", weight=0.1)
+G.add_edge("c", "e", weight=0.7)
+G.add_edge("c", "f", weight=0.9)
+G.add_edge("a", "d", weight=0.3)
+
+elarge = [(u, v) for (u, v, d) in G.edges(data=True) if d["weight"] > 0.5]
+esmall = [(u, v) for (u, v, d) in G.edges(data=True) if d["weight"] <= 0.5]
+
+pos = nx.spring_layout(G, seed=7)  # positions for all nodes - seed for reproducibility
+
+# nodes
+nx.draw_networkx_nodes(G, pos, node_size=700)
+
+# edges
+nx.draw_networkx_edges(G, pos, edgelist=elarge, width=6)
+nx.draw_networkx_edges(
+    G, pos, edgelist=esmall, width=6, alpha=0.5, edge_color="b", style="dashed"
+)
+
+# node labels
+nx.draw_networkx_labels(G, pos, font_size=20, font_family="sans-serif")
+# edge weight labels
+edge_labels = nx.get_edge_attributes(G, "weight")
+nx.draw_networkx_edge_labels(G, pos, edge_labels)
+
+ax = plt.gca()
+ax.margins(0.08)
+plt.axis("off")
+plt.tight_layout()
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/drawing/unix_email.mbox b/myenv/share/doc/networkx-2.8.5/examples/drawing/unix_email.mbox
new file mode 100644
index 0000000..a3a7cf8
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/drawing/unix_email.mbox
@@ -0,0 +1,84 @@
+From alice@edu  Thu Jun 16 16:12:12 2005
+From: Alice <alice@edu>
+Subject: NetworkX
+Date: Thu, 16 Jun 2005 16:12:13 -0700
+To: Bob <bob@gov>
+Status: RO
+Content-Length: 86
+Lines: 5
+
+Bob, check out the new networkx release - you and
+Carol might really like it.
+
+Alice
+
+
+From bob@gov   Thu Jun 16 18:13:12 2005
+Return-Path: <bob@gov>
+Subject: Re: NetworkX
+From: Bob <bob@gov>
+To: Alice <alice@edu>
+Content-Type: text/plain
+Date: Thu, 16 Jun 2005 18:13:12 -0700
+Status: RO
+Content-Length: 26
+Lines: 4
+
+Thanks for the tip.
+
+Bob
+
+
+From ted@com  Thu Jul 28 09:53:31 2005
+Return-Path: <ted@com>
+Subject: Graph package in Python?
+From: Ted <ted@com>
+To: Bob <bob@gov>
+Content-Type: text/plain
+Date: Thu, 28 Jul 2005 09:47:03 -0700
+Status: RO
+Content-Length: 90
+Lines: 3
+
+Hey Ted - I'm looking for a Python package for
+graphs and networks.  Do you know of any?
+
+
+From bob@gov  Thu Jul 28 09:59:31 2005
+Return-Path: <bob@gov>
+Subject: Re: Graph package in Python?
+From: Bob <bob@gov>
+To: Ted <ted@com>
+Content-Type: text/plain
+Date: Thu, 28 Jul 2005 09:59:03 -0700
+Status: RO
+Content-Length: 180
+Lines: 9
+
+
+Check out the NetworkX package - Alice sent me the tip!
+
+Bob
+
+>> bob@gov scrawled:
+>> Hey Ted - I'm looking for a Python package for
+>> graphs and networks.  Do you know of any?
+
+
+From ted@com  Thu Jul 28 15:53:31 2005
+Return-Path: <ted@com>
+Subject: get together for lunch to discuss Networks?
+From: Ted <ted@com>
+To: Bob <bob@gov>, Carol <carol@gov>, Alice <alice@edu>
+Content-Type: text/plain
+Date: Thu, 28 Jul 2005 15:47:03 -0700
+Status: RO
+Content-Length: 139
+Lines: 5
+
+Hey everyrone!  Want to meet at that restaurant on the
+island in Konigsburg tonight?  Bring your laptops
+and we can install NetworkX.
+
+Ted
+
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/README.txt b/myenv/share/doc/networkx-2.8.5/examples/graph/README.txt
new file mode 100644
index 0000000..9b0e3b2
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/graph/README.txt
@@ -0,0 +1,2 @@
+Graph
+-----
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/plot_degree_sequence.py b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_degree_sequence.py
new file mode 100644
index 0000000..0d32091
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_degree_sequence.py
@@ -0,0 +1,34 @@
+"""
+===============
+Degree Sequence
+===============
+
+Random graph from given degree sequence.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# Specify seed for reproducibility
+seed = 668273
+
+z = [5, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
+print(nx.is_graphical(z))
+
+print("Configuration model")
+G = nx.configuration_model(z, seed=seed)  # configuration model, seed for reproduciblity
+degree_sequence = [d for n, d in G.degree()]  # degree sequence
+print(f"Degree sequence {degree_sequence}")
+print("Degree histogram")
+hist = {}
+for d in degree_sequence:
+    if d in hist:
+        hist[d] += 1
+    else:
+        hist[d] = 1
+print("degree #nodes")
+for d in hist:
+    print(f"{d:4} {hist[d]:6}")
+
+pos = nx.spring_layout(G, seed=seed)  # Seed layout for reproducibility
+nx.draw(G, pos=pos)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/plot_erdos_renyi.py b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_erdos_renyi.py
new file mode 100644
index 0000000..e132676
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_erdos_renyi.py
@@ -0,0 +1,36 @@
+"""
+===========
+Erdos Renyi
+===========
+
+Create an G{n,m} random graph with n nodes and m edges
+and report some properties.
+
+This graph is sometimes called the Erdős-Rényi graph
+but is different from G{n,p} or binomial_graph which is also
+sometimes called the Erdős-Rényi graph.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+n = 10  # 10 nodes
+m = 20  # 20 edges
+seed = 20160  # seed random number generators for reproducibility
+
+# Use seed for reproducibility
+G = nx.gnm_random_graph(n, m, seed=seed)
+
+# some properties
+print("node degree clustering")
+for v in nx.nodes(G):
+    print(f"{v} {nx.degree(G, v)} {nx.clustering(G, v)}")
+
+print()
+print("the adjacency list")
+for line in nx.generate_adjlist(G):
+    print(line)
+
+pos = nx.spring_layout(G, seed=seed)  # Seed for reproducible layout
+nx.draw(G, pos=pos)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/plot_expected_degree_sequence.py b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_expected_degree_sequence.py
new file mode 100644
index 0000000..1fc6799
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_expected_degree_sequence.py
@@ -0,0 +1,20 @@
+"""
+========================
+Expected Degree Sequence
+========================
+
+Random graph from given degree sequence.
+"""
+
+import networkx as nx
+
+# make a random graph of 500 nodes with expected degrees of 50
+n = 500  # n nodes
+p = 0.1
+w = [p * n for i in range(n)]  # w = p*n for all nodes
+G = nx.expected_degree_graph(w)  # configuration model
+print("Degree histogram")
+print("degree (#nodes) ****")
+dh = nx.degree_histogram(G)
+for i, d in enumerate(dh):
+    print(f"{i:2} ({d:2}) {'*'*d}")
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/plot_football.py b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_football.py
new file mode 100644
index 0000000..f6397f0
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_football.py
@@ -0,0 +1,44 @@
+"""
+========
+Football
+========
+
+Load football network in GML format and compute some network statistcs.
+
+Shows how to download GML graph in a zipped file, unpack it, and load
+into a NetworkX graph.
+
+Requires Internet connection to download the URL
+http://www-personal.umich.edu/~mejn/netdata/football.zip
+"""
+
+import urllib.request
+import io
+import zipfile
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+url = "http://www-personal.umich.edu/~mejn/netdata/football.zip"
+
+sock = urllib.request.urlopen(url)  # open URL
+s = io.BytesIO(sock.read())  # read into BytesIO "file"
+sock.close()
+
+zf = zipfile.ZipFile(s)  # zipfile object
+txt = zf.read("football.txt").decode()  # read info file
+gml = zf.read("football.gml").decode()  # read gml data
+# throw away bogus first line with # from mejn files
+gml = gml.split("\n")[1:]
+G = nx.parse_gml(gml)  # parse gml data
+
+print(txt)
+# print degree for each team - number of games
+for n, d in G.degree():
+    print(f"{n:20} {d:2}")
+
+options = {"node_color": "black", "node_size": 50, "linewidths": 0, "width": 0.1}
+
+pos = nx.spring_layout(G, seed=1969)  # Seed for reproducible layout
+nx.draw(G, pos, **options)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/plot_karate_club.py b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_karate_club.py
new file mode 100644
index 0000000..c4fe5bc
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_karate_club.py
@@ -0,0 +1,25 @@
+"""
+===========
+Karate Club
+===========
+
+Zachary's Karate Club graph
+
+Data file from:
+http://vlado.fmf.uni-lj.si/pub/networks/data/Ucinet/UciData.htm
+
+Zachary W. (1977).
+An information flow model for conflict and fission in small groups.
+Journal of Anthropological Research, 33, 452-473.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.karate_club_graph()
+print("Node Degree")
+for v in G:
+    print(f"{v:4} {G.degree(v):6}")
+
+nx.draw_circular(G, with_labels=True)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/plot_morse_trie.py b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_morse_trie.py
new file mode 100644
index 0000000..88b424c
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_morse_trie.py
@@ -0,0 +1,96 @@
+"""
+==========
+Morse Trie
+==========
+
+A prefix tree (aka a "trie") representing the Morse encoding of the alphabet.
+A letter can be encoded by tracing the path from the corresponding node in the
+tree to the root node, reversing the order of the symbols encountered along
+the path.
+"""
+import networkx as nx
+
+# Unicode characters to represent the dots/dashes (or dits/dahs) of Morse code
+dot = "•"
+dash = "—"
+
+# Start with the direct mapping of letter -> code
+morse_direct_mapping = {
+    "a": dot + dash,
+    "b": dash + dot * 3,
+    "c": dash + dot + dash + dot,
+    "d": dash + dot * 2,
+    "e": dot,
+    "f": dot * 2 + dash + dot,
+    "g": dash * 2 + dot,
+    "h": dot * 4,
+    "i": dot * 2,
+    "j": dot + dash * 3,
+    "k": dash + dot + dash,
+    "l": dot + dash + dot * 2,
+    "m": dash * 2,
+    "n": dash + dot,
+    "o": dash * 3,
+    "p": dot + dash * 2 + dot,
+    "q": dash * 2 + dot + dash,
+    "r": dot + dash + dot,
+    "s": dot * 3,
+    "t": dash,
+    "u": dot * 2 + dash,
+    "v": dot * 3 + dash,
+    "w": dot + dash * 2,
+    "x": dash + dot * 2 + dash,
+    "y": dash + dot + dash * 2,
+    "z": dash * 2 + dot * 2,
+}
+
+### Manually construct the prefix tree from this mapping
+
+# Some preprocessing: sort the original mapping by code length and character
+# value
+morse_mapping_sorted = dict(
+    sorted(morse_direct_mapping.items(), key=lambda item: (len(item[1]), item[1]))
+)
+
+# More preprocessing: create the reverse mapping to simplify lookup
+reverse_mapping = {v: k for k, v in morse_direct_mapping.items()}
+reverse_mapping[""] = ""  # Represent the "root" node with an empty string
+
+# Construct the prefix tree from the sorted mapping
+G = nx.DiGraph()
+for node, char in morse_mapping_sorted.items():
+    pred = char[:-1]
+    # Store the dot/dash relating the two letters as an edge attribute "char"
+    G.add_edge(reverse_mapping[pred], node, char=char[-1])
+
+# For visualization purposes, layout the nodes in topological order
+for i, layer in enumerate(nx.topological_generations(G)):
+    for n in layer:
+        G.nodes[n]["layer"] = i
+pos = nx.multipartite_layout(G, subset_key="layer", align="horizontal")
+# Flip the layout so the root node is on top
+for k in pos:
+    pos[k][-1] *= -1
+
+# Visualize the trie
+nx.draw(G, pos=pos, with_labels=True)
+elabels = {(u, v): l for u, v, l in G.edges(data="char")}
+nx.draw_networkx_edge_labels(G, pos, edge_labels=elabels)
+
+# A letter can be encoded by following the path from the given letter (node) to
+# the root node
+def morse_encode(letter):
+    pred = next(G.predecessors(letter))  # Each letter has only 1 predecessor
+    symbol = G[pred][letter]["char"]
+    if pred != "":
+        return morse_encode(pred) + symbol  # Traversing the trie in reverse
+    return symbol
+
+
+# Verify that the trie encoding is correct
+import string
+
+for letter in string.ascii_lowercase:
+    assert morse_encode(letter) == morse_direct_mapping[letter]
+
+print(" ".join([morse_encode(ltr) for ltr in "ilovenetworkx"]))
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/plot_napoleon_russian_campaign.py b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_napoleon_russian_campaign.py
new file mode 100644
index 0000000..46ef64d
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_napoleon_russian_campaign.py
@@ -0,0 +1,133 @@
+"""
+=========================
+Napoleon Russian Campaign
+=========================
+
+Minard's data from Napoleon's 1812-1813  Russian Campaign.
+https://web.archive.org/web/20080112042656/http://www.math.yorku.ca/SCS/Gallery/minard/minard.txt
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+def minard_graph():
+    data1 = """\
+24.0,54.9,340000,A,1
+24.5,55.0,340000,A,1
+25.5,54.5,340000,A,1
+26.0,54.7,320000,A,1
+27.0,54.8,300000,A,1
+28.0,54.9,280000,A,1
+28.5,55.0,240000,A,1
+29.0,55.1,210000,A,1
+30.0,55.2,180000,A,1
+30.3,55.3,175000,A,1
+32.0,54.8,145000,A,1
+33.2,54.9,140000,A,1
+34.4,55.5,127100,A,1
+35.5,55.4,100000,A,1
+36.0,55.5,100000,A,1
+37.6,55.8,100000,A,1
+37.7,55.7,100000,R,1
+37.5,55.7,98000,R,1
+37.0,55.0,97000,R,1
+36.8,55.0,96000,R,1
+35.4,55.3,87000,R,1
+34.3,55.2,55000,R,1
+33.3,54.8,37000,R,1
+32.0,54.6,24000,R,1
+30.4,54.4,20000,R,1
+29.2,54.3,20000,R,1
+28.5,54.2,20000,R,1
+28.3,54.3,20000,R,1
+27.5,54.5,20000,R,1
+26.8,54.3,12000,R,1
+26.4,54.4,14000,R,1
+25.0,54.4,8000,R,1
+24.4,54.4,4000,R,1
+24.2,54.4,4000,R,1
+24.1,54.4,4000,R,1"""
+    data2 = """\
+24.0,55.1,60000,A,2
+24.5,55.2,60000,A,2
+25.5,54.7,60000,A,2
+26.6,55.7,40000,A,2
+27.4,55.6,33000,A,2
+28.7,55.5,33000,R,2
+29.2,54.2,30000,R,2
+28.5,54.1,30000,R,2
+28.3,54.2,28000,R,2"""
+    data3 = """\
+24.0,55.2,22000,A,3
+24.5,55.3,22000,A,3
+24.6,55.8,6000,A,3
+24.6,55.8,6000,R,3
+24.2,54.4,6000,R,3
+24.1,54.4,6000,R,3"""
+    cities = """\
+24.0,55.0,Kowno
+25.3,54.7,Wilna
+26.4,54.4,Smorgoni
+26.8,54.3,Moiodexno
+27.7,55.2,Gloubokoe
+27.6,53.9,Minsk
+28.5,54.3,Studienska
+28.7,55.5,Polotzk
+29.2,54.4,Bobr
+30.2,55.3,Witebsk
+30.4,54.5,Orscha
+30.4,53.9,Mohilow
+32.0,54.8,Smolensk
+33.2,54.9,Dorogobouge
+34.3,55.2,Wixma
+34.4,55.5,Chjat
+36.0,55.5,Mojaisk
+37.6,55.8,Moscou
+36.6,55.3,Tarantino
+36.5,55.0,Malo-Jarosewii"""
+
+    c = {}
+    for line in cities.split("\n"):
+        x, y, name = line.split(",")
+        c[name] = (float(x), float(y))
+
+    g = []
+
+    for data in [data1, data2, data3]:
+        G = nx.Graph()
+        i = 0
+        G.pos = {}  # location
+        G.pop = {}  # size
+        last = None
+        for line in data.split("\n"):
+            x, y, p, r, n = line.split(",")
+            G.pos[i] = (float(x), float(y))
+            G.pop[i] = int(p)
+            if last is None:
+                last = i
+            else:
+                G.add_edge(i, last, **{r: int(n)})
+                last = i
+            i = i + 1
+        g.append(G)
+
+    return g, c
+
+
+(g, city) = minard_graph()
+
+plt.figure(1, figsize=(11, 5))
+plt.clf()
+colors = ["b", "g", "r"]
+for G in g:
+    c = colors.pop(0)
+    node_size = [G.pop[n] // 300 for n in G]
+    nx.draw_networkx_edges(G, G.pos, edge_color=c, width=4, alpha=0.5)
+    nx.draw_networkx_nodes(G, G.pos, node_size=node_size, node_color=c, alpha=0.5)
+    nx.draw_networkx_nodes(G, G.pos, node_size=5, node_color="k")
+
+for c in city:
+    x, y = city[c]
+    plt.text(x, y + 0.1, c)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/plot_roget.py b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_roget.py
new file mode 100644
index 0000000..777c017
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_roget.py
@@ -0,0 +1,80 @@
+"""
+=====
+Roget
+=====
+
+Build a directed graph of 1022 categories and 5075 cross-references as defined
+in the 1879 version of Roget's Thesaurus. This example is described in Section
+1.2 of
+
+    Donald E. Knuth, "The Stanford GraphBase: A Platform for Combinatorial
+    Computing", ACM Press, New York, 1993.
+    http://www-cs-faculty.stanford.edu/~knuth/sgb.html
+
+Note that one of the 5075 cross references is a self loop yet it is included in
+the graph built here because the standard networkx `DiGraph` class allows self
+loops.  (cf. 400pungency:400 401 403 405).
+
+The data file can be found at:
+
+- https://github.com/networkx/networkx/blob/main/examples/graph/roget_dat.txt.gz
+"""
+
+import gzip
+import re
+import sys
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+def roget_graph():
+    """Return the thesaurus graph from the roget.dat example in
+    the Stanford Graph Base.
+    """
+    # open file roget_dat.txt.gz
+    fh = gzip.open("roget_dat.txt.gz", "r")
+
+    G = nx.DiGraph()
+
+    for line in fh.readlines():
+        line = line.decode()
+        if line.startswith("*"):  # skip comments
+            continue
+        if line.startswith(" "):  # this is a continuation line, append
+            line = oldline + line
+        if line.endswith("\\\n"):  # continuation line, buffer, goto next
+            oldline = line.strip("\\\n")
+            continue
+
+        (headname, tails) = line.split(":")
+
+        # head
+        numfind = re.compile(r"^\d+")  # re to find the number of this word
+        head = numfind.findall(headname)[0]  # get the number
+
+        G.add_node(head)
+
+        for tail in tails.split():
+            if head == tail:
+                print("skipping self loop", head, tail, file=sys.stderr)
+            G.add_edge(head, tail)
+
+    return G
+
+
+G = roget_graph()
+print("Loaded roget_dat.txt containing 1022 categories.")
+print(G)
+UG = G.to_undirected()
+print(nx.number_connected_components(UG), "connected components")
+
+options = {
+    "node_color": "black",
+    "node_size": 1,
+    "edge_color": "gray",
+    "linewidths": 0,
+    "width": 0.1,
+}
+nx.draw_circular(UG, **options)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/plot_words.py b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_words.py
new file mode 100644
index 0000000..e5211f5
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/graph/plot_words.py
@@ -0,0 +1,88 @@
+"""
+==================
+Words/Ladder Graph
+==================
+
+Generate  an undirected graph over the 5757 5-letter words in the datafile
+`words_dat.txt.gz`.  Two words are connected by an edge if they differ in one
+letter, resulting in 14,135 edges. This example is described in Section 1.1 of
+
+    Donald E. Knuth, "The Stanford GraphBase: A Platform for Combinatorial
+    Computing", ACM Press, New York, 1993.
+    http://www-cs-faculty.stanford.edu/~knuth/sgb.html
+
+The data file can be found at:
+
+- https://github.com/networkx/networkx/blob/main/examples/graph/words_dat.txt.gz
+"""
+
+import gzip
+from string import ascii_lowercase as lowercase
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+def generate_graph(words):
+    G = nx.Graph(name="words")
+    lookup = {c: lowercase.index(c) for c in lowercase}
+
+    def edit_distance_one(word):
+        for i in range(len(word)):
+            left, c, right = word[0:i], word[i], word[i + 1 :]
+            j = lookup[c]  # lowercase.index(c)
+            for cc in lowercase[j + 1 :]:
+                yield left + cc + right
+
+    candgen = (
+        (word, cand)
+        for word in sorted(words)
+        for cand in edit_distance_one(word)
+        if cand in words
+    )
+    G.add_nodes_from(words)
+    for word, cand in candgen:
+        G.add_edge(word, cand)
+    return G
+
+
+def words_graph():
+    """Return the words example graph from the Stanford GraphBase"""
+    fh = gzip.open("words_dat.txt.gz", "r")
+    words = set()
+    for line in fh.readlines():
+        line = line.decode()
+        if line.startswith("*"):
+            continue
+        w = str(line[0:5])
+        words.add(w)
+    return generate_graph(words)
+
+
+G = words_graph()
+print("Loaded words_dat.txt containing 5757 five-letter English words.")
+print("Two words are connected if they differ in one letter.")
+print(G)
+print(f"{nx.number_connected_components(G)} connected components")
+
+for (source, target) in [("chaos", "order"), ("nodes", "graph"), ("pound", "marks")]:
+    print(f"Shortest path between {source} and {target} is")
+    try:
+        shortest_path = nx.shortest_path(G, source, target)
+        for n in shortest_path:
+            print(n)
+    except nx.NetworkXNoPath:
+        print("None")
+
+
+# draw a subset of the graph
+boundary = list(nx.node_boundary(G, shortest_path))
+G.add_nodes_from(shortest_path, color="red")
+G.add_nodes_from(boundary, color="blue")
+H = G.subgraph(shortest_path + boundary)
+colors = nx.get_node_attributes(H, "color")
+options = {"node_size": 1500, "alpha": 0.3, "node_color": colors.values()}
+pos = nx.kamada_kawai_layout(H)
+nx.draw(H, pos, **options)
+nx.draw_networkx_labels(H, pos, font_weight="bold")
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/roget_dat.txt.gz b/myenv/share/doc/networkx-2.8.5/examples/graph/roget_dat.txt.gz
new file mode 100644
index 0000000..6552465
Binary files /dev/null and b/myenv/share/doc/networkx-2.8.5/examples/graph/roget_dat.txt.gz differ
diff --git a/myenv/share/doc/networkx-2.8.5/examples/graph/words_dat.txt.gz b/myenv/share/doc/networkx-2.8.5/examples/graph/words_dat.txt.gz
new file mode 100644
index 0000000..78aff79
Binary files /dev/null and b/myenv/share/doc/networkx-2.8.5/examples/graph/words_dat.txt.gz differ
diff --git a/myenv/share/doc/networkx-2.8.5/examples/subclass/README.txt b/myenv/share/doc/networkx-2.8.5/examples/subclass/README.txt
new file mode 100644
index 0000000..e3650b1
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/subclass/README.txt
@@ -0,0 +1,2 @@
+Subclass
+--------
diff --git a/myenv/share/doc/networkx-2.8.5/examples/subclass/plot_antigraph.py b/myenv/share/doc/networkx-2.8.5/examples/subclass/plot_antigraph.py
new file mode 100644
index 0000000..154a321
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/subclass/plot_antigraph.py
@@ -0,0 +1,192 @@
+"""
+=========
+Antigraph
+=========
+
+Complement graph class for small footprint when working on dense graphs.
+
+This class allows you to add the edges that *do not exist* in the dense
+graph. However, when applying algorithms to this complement graph data
+structure, it behaves as if it were the dense version. So it can be used
+directly in several NetworkX algorithms.
+
+This subclass has only been tested for k-core, connected_components,
+and biconnected_components algorithms but might also work for other
+algorithms.
+
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+from networkx import Graph
+
+
+class AntiGraph(Graph):
+    """
+    Class for complement graphs.
+
+    The main goal is to be able to work with big and dense graphs with
+    a low memory footprint.
+
+    In this class you add the edges that *do not exist* in the dense graph,
+    the report methods of the class return the neighbors, the edges and
+    the degree as if it was the dense graph. Thus it's possible to use
+    an instance of this class with some of NetworkX functions.
+    """
+
+    all_edge_dict = {"weight": 1}
+
+    def single_edge_dict(self):
+        return self.all_edge_dict
+
+    edge_attr_dict_factory = single_edge_dict
+
+    def __getitem__(self, n):
+        """Return a dict of neighbors of node n in the dense graph.
+
+        Parameters
+        ----------
+        n : node
+           A node in the graph.
+
+        Returns
+        -------
+        adj_dict : dictionary
+           The adjacency dictionary for nodes connected to n.
+
+        """
+        return {
+            node: self.all_edge_dict for node in set(self.adj) - set(self.adj[n]) - {n}
+        }
+
+    def neighbors(self, n):
+        """Return an iterator over all neighbors of node n in the
+        dense graph.
+
+        """
+        try:
+            return iter(set(self.adj) - set(self.adj[n]) - {n})
+        except KeyError as err:
+            raise nx.NetworkXError(f"The node {n} is not in the graph.") from err
+
+    def degree(self, nbunch=None, weight=None):
+        """Return an iterator for (node, degree) in the dense graph.
+
+        The node degree is the number of edges adjacent to the node.
+
+        Parameters
+        ----------
+        nbunch : iterable container, optional (default=all nodes)
+            A container of nodes.  The container will be iterated
+            through once.
+
+        weight : string or None, optional (default=None)
+           The edge attribute that holds the numerical value used
+           as a weight.  If None, then each edge has weight 1.
+           The degree is the sum of the edge weights adjacent to the node.
+
+        Returns
+        -------
+        nd_iter : iterator
+            The iterator returns two-tuples of (node, degree).
+
+        See Also
+        --------
+        degree
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> G.degree(0)  # node 0 with degree 1
+        1
+        >>> list(G.degree([0, 1]))
+        [(0, 1), (1, 2)]
+
+        """
+        if nbunch is None:
+            nodes_nbrs = (
+                (
+                    n,
+                    {
+                        v: self.all_edge_dict
+                        for v in set(self.adj) - set(self.adj[n]) - {n}
+                    },
+                )
+                for n in self.nodes()
+            )
+        elif nbunch in self:
+            nbrs = set(self.nodes()) - set(self.adj[nbunch]) - {nbunch}
+            return len(nbrs)
+        else:
+            nodes_nbrs = (
+                (
+                    n,
+                    {
+                        v: self.all_edge_dict
+                        for v in set(self.nodes()) - set(self.adj[n]) - {n}
+                    },
+                )
+                for n in self.nbunch_iter(nbunch)
+            )
+
+        if weight is None:
+            return ((n, len(nbrs)) for n, nbrs in nodes_nbrs)
+        else:
+            # AntiGraph is a ThinGraph so all edges have weight 1
+            return (
+                (n, sum((nbrs[nbr].get(weight, 1)) for nbr in nbrs))
+                for n, nbrs in nodes_nbrs
+            )
+
+    def adjacency(self):
+        """Return an iterator of (node, adjacency set) tuples for all nodes
+           in the dense graph.
+
+        This is the fastest way to look at every edge.
+        For directed graphs, only outgoing adjacencies are included.
+
+        Returns
+        -------
+        adj_iter : iterator
+           An iterator of (node, adjacency set) for all nodes in
+           the graph.
+        """
+        nodes = set(self.adj)
+        for n, nbrs in self.adj.items():
+            yield (n, nodes - set(nbrs) - {n})
+
+
+# Build several pairs of graphs, a regular graph
+# and the AntiGraph of it's complement, which behaves
+# as if it were the original graph.
+Gnp = nx.gnp_random_graph(20, 0.8, seed=42)
+Anp = AntiGraph(nx.complement(Gnp))
+Gd = nx.davis_southern_women_graph()
+Ad = AntiGraph(nx.complement(Gd))
+Gk = nx.karate_club_graph()
+Ak = AntiGraph(nx.complement(Gk))
+pairs = [(Gnp, Anp), (Gd, Ad), (Gk, Ak)]
+# test connected components
+for G, A in pairs:
+    gc = [set(c) for c in nx.connected_components(G)]
+    ac = [set(c) for c in nx.connected_components(A)]
+    for comp in ac:
+        assert comp in gc
+# test biconnected components
+for G, A in pairs:
+    gc = [set(c) for c in nx.biconnected_components(G)]
+    ac = [set(c) for c in nx.biconnected_components(A)]
+    for comp in ac:
+        assert comp in gc
+# test degree
+for G, A in pairs:
+    node = list(G.nodes())[0]
+    nodes = list(G.nodes())[1:4]
+    assert G.degree(node) == A.degree(node)
+    assert sum(d for n, d in G.degree()) == sum(d for n, d in A.degree())
+    # AntiGraph is a ThinGraph, so all the weights are 1
+    assert sum(d for n, d in A.degree()) == sum(d for n, d in A.degree(weight="weight"))
+    assert sum(d for n, d in G.degree(nodes)) == sum(d for n, d in A.degree(nodes))
+
+pos = nx.spring_layout(G, seed=268)  # Seed for reproducible layout
+nx.draw(Gnp, pos=pos)
+plt.show()
diff --git a/myenv/share/doc/networkx-2.8.5/examples/subclass/plot_printgraph.py b/myenv/share/doc/networkx-2.8.5/examples/subclass/plot_printgraph.py
new file mode 100644
index 0000000..08efcf1
--- /dev/null
+++ b/myenv/share/doc/networkx-2.8.5/examples/subclass/plot_printgraph.py
@@ -0,0 +1,88 @@
+"""
+===========
+Print Graph
+===========
+
+Example subclass of the Graph class.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+from networkx import Graph
+
+
+class PrintGraph(Graph):
+    """
+    Example subclass of the Graph class.
+
+    Prints activity log to file or standard output.
+    """
+
+    def __init__(self, data=None, name="", file=None, **attr):
+        super().__init__(data=data, name=name, **attr)
+        if file is None:
+            import sys
+
+            self.fh = sys.stdout
+        else:
+            self.fh = open(file, "w")
+
+    def add_node(self, n, attr_dict=None, **attr):
+        super().add_node(n, attr_dict=attr_dict, **attr)
+        self.fh.write(f"Add node: {n}\n")
+
+    def add_nodes_from(self, nodes, **attr):
+        for n in nodes:
+            self.add_node(n, **attr)
+
+    def remove_node(self, n):
+        super().remove_node(n)
+        self.fh.write(f"Remove node: {n}\n")
+
+    def remove_nodes_from(self, nodes):
+        for n in nodes:
+            self.remove_node(n)
+
+    def add_edge(self, u, v, attr_dict=None, **attr):
+        super().add_edge(u, v, attr_dict=attr_dict, **attr)
+        self.fh.write(f"Add edge: {u}-{v}\n")
+
+    def add_edges_from(self, ebunch, attr_dict=None, **attr):
+        for e in ebunch:
+            u, v = e[0:2]
+            self.add_edge(u, v, attr_dict=attr_dict, **attr)
+
+    def remove_edge(self, u, v):
+        super().remove_edge(u, v)
+        self.fh.write(f"Remove edge: {u}-{v}\n")
+
+    def remove_edges_from(self, ebunch):
+        for e in ebunch:
+            u, v = e[0:2]
+            self.remove_edge(u, v)
+
+    def clear(self):
+        super().clear()
+        self.fh.write("Clear graph\n")
+
+
+G = PrintGraph()
+G.add_node("foo")
+G.add_nodes_from("bar", weight=8)
+G.remove_node("b")
+G.remove_nodes_from("ar")
+print("Nodes in G: ", G.nodes(data=True))
+G.add_edge(0, 1, weight=10)
+print("Edges in G: ", G.edges(data=True))
+G.remove_edge(0, 1)
+G.add_edges_from(zip(range(0, 3), range(1, 4)), weight=10)
+print("Edges in G: ", G.edges(data=True))
+G.remove_edges_from(zip(range(0, 3), range(1, 4)))
+print("Edges in G: ", G.edges(data=True))
+
+G = PrintGraph()
+nx.add_path(G, range(10))
+nx.add_star(G, range(9, 13))
+pos = nx.spring_layout(G, seed=225)  # Seed for reproducible layout
+nx.draw(G, pos)
+plt.show()
diff --git a/pyproject.toml b/pyproject.toml
index f24ba1d..7ffe14c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -27,5 +27,5 @@ isort = "^5.10.1"
 markers = ["bonus: optional task applicants don't have to solve"]
 
 [build-system]
-requires = ["poetry-core>=1.0.0"]
+requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
diff --git a/test_melli.py b/test_melli.py
index a305474..2930180 100644
--- a/test_melli.py
+++ b/test_melli.py
@@ -1,12 +1,12 @@
 import pytest
-from httpx import AsyncClient
+import httpx
+# from httpx import AsyncClient
 
 from melli import app
 
-
 @pytest.fixture()
 async def async_client():
-    async_client = AsyncClient(app=app, base_url="http://test")
+    async_client = httpx.AsyncClient(app=app, base_url="http://test")
     yield async_client
     await async_client.aclose()
 
@@ -49,7 +49,6 @@ async def test_task2(async_client):
         "isFutureUnicorn": True,
     }
 
-
 @pytest.mark.depends(on=["test_task2"])
 def test_task2_success_message():
     print(